Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mfashe...
[linux-2.6] / drivers / char / tipar.c
1 /* Hey EMACS -*- linux-c -*-
2  *
3  * tipar - low level driver for handling a parallel link cable designed
4  * for Texas Instruments graphing calculators (http://lpg.ticalc.org).
5  * A part of the TiLP project.
6  *
7  * Copyright (C) 2000-2002, Romain Lievin <roms@lpg.ticalc.org>
8  * under the terms of the GNU General Public License.
9  *
10  * Various fixes & clean-up from the Linux Kernel Mailing List
11  * (Alan Cox, Richard B. Johnson, Christoph Hellwig).
12  */
13
14 /* This driver should, in theory, work with any parallel port that has an
15  * appropriate low-level driver; all I/O is done through the parport
16  * abstraction layer.
17  *
18  * If this driver is built into the kernel, you can configure it using the
19  * kernel command-line.  For example:
20  *
21  *      tipar=timeout,delay       (set timeout and delay)
22  *
23  * If the driver is loaded as a module, similar functionality is available
24  * using module parameters.  The equivalent of the above commands would be:
25  *
26  *      # insmod tipar timeout=15 delay=10
27  */
28
29 /* COMPATIBILITY WITH OLD KERNELS
30  *
31  * Usually, parallel cables were bound to ports at
32  * particular I/O addresses, as follows:
33  *
34  *      tipar0             0x378
35  *      tipar1             0x278
36  *      tipar2             0x3bc
37  *
38  *
39  * This driver, by default, binds tipar devices according to parport and
40  * the minor number.
41  *
42  */
43 #undef DEBUG                            /* change to #define to get debugging
44                                          * output - for pr_debug() */
45 #include <linux/config.h>
46 #include <linux/module.h>
47 #include <linux/types.h>
48 #include <linux/errno.h>
49 #include <linux/kernel.h>
50 #include <linux/sched.h>
51 #include <linux/delay.h>
52 #include <linux/fcntl.h>
53 #include <linux/fs.h>
54 #include <linux/init.h>
55 #include <asm/uaccess.h>
56 #include <linux/ioport.h>
57 #include <asm/io.h>
58 #include <linux/bitops.h>
59 #include <linux/parport.h>              /* Our code depend on parport */
60 #include <linux/device.h>
61
62 /*
63  * TI definitions
64  */
65 #include <linux/ticable.h>
66
67 /*
68  * Version Information
69  */
70 #define DRIVER_VERSION "1.19"
71 #define DRIVER_AUTHOR  "Romain Lievin <roms@lpg.ticalc.org>"
72 #define DRIVER_DESC    "Device driver for TI/PC parallel link cables"
73 #define DRIVER_LICENSE "GPL"
74
75 #define VERSION(ver,rel,seq) (((ver)<<16) | ((rel)<<8) | (seq))
76
77 /* ----- global variables --------------------------------------------- */
78
79 struct tipar_struct {
80         struct pardevice *dev;  /* Parport device entry */
81 };
82
83 #define PP_NO 3
84 static struct tipar_struct table[PP_NO];
85
86 static int delay = IO_DELAY;    /* inter-bit delay in microseconds */
87 static int timeout = TIMAXTIME; /* timeout in tenth of seconds     */
88
89 static unsigned int tp_count;   /* tipar count */
90 static unsigned long opened;    /* opened devices */
91
92 static struct class *tipar_class;
93
94 /* --- macros for parport access -------------------------------------- */
95
96 #define r_dtr(x)        (parport_read_data(table[(x)].dev->port))
97 #define r_str(x)        (parport_read_status(table[(x)].dev->port))
98 #define w_ctr(x,y)      (parport_write_control(table[(x)].dev->port, (y)))
99 #define w_dtr(x,y)      (parport_write_data(table[(x)].dev->port, (y)))
100
101 /* --- setting states on the D-bus with the right timing: ------------- */
102
103 static inline void
104 outbyte(int value, int minor)
105 {
106         w_dtr(minor, value);
107 }
108
109 static inline int
110 inbyte(int minor)
111 {
112         return (r_str(minor));
113 }
114
115 static inline void
116 init_ti_parallel(int minor)
117 {
118         outbyte(3, minor);
119 }
120
121 /* ----- global defines ----------------------------------------------- */
122
123 #define START(x) { x = jiffies + (HZ * timeout) / 10; }
124 #define WAIT(x)  { \
125   if (time_before((x), jiffies)) return -1; \
126   if (need_resched()) schedule(); }
127
128 /* ----- D-bus bit-banging functions ---------------------------------- */
129
130 /* D-bus protocol (45kbit/s max):
131                     1                 0                      0
132        _______        ______|______    __________|________    __________
133 Red  :        ________      |      ____          |        ____
134        _        ____________|________      ______|__________       _____
135 White:  ________            |        ______      |          _______
136 */
137
138 /* Try to transmit a byte on the specified port (-1 if error). */
139 static int
140 put_ti_parallel(int minor, unsigned char data)
141 {
142         unsigned int bit;
143         unsigned long max;
144
145         for (bit = 0; bit < 8; bit++) {
146                 if (data & 1) {
147                         outbyte(2, minor);
148                         START(max);
149                         do {
150                                 WAIT(max);
151                         } while (inbyte(minor) & 0x10);
152
153                         outbyte(3, minor);
154                         START(max);
155                         do {
156                                 WAIT(max);
157                         } while (!(inbyte(minor) & 0x10));
158                 } else {
159                         outbyte(1, minor);
160                         START(max);
161                         do {
162                                 WAIT(max);
163                         } while (inbyte(minor) & 0x20);
164
165                         outbyte(3, minor);
166                         START(max);
167                         do {
168                                 WAIT(max);
169                         } while (!(inbyte(minor) & 0x20));
170                 }
171
172                 data >>= 1;
173                 udelay(delay);
174
175                 if (need_resched())
176                         schedule();
177         }
178
179         return 0;
180 }
181
182 /* Receive a byte on the specified port or -1 if error. */
183 static int
184 get_ti_parallel(int minor)
185 {
186         unsigned int bit;
187         unsigned char v, data = 0;
188         unsigned long max;
189
190         for (bit = 0; bit < 8; bit++) {
191                 START(max);
192                 do {
193                         WAIT(max);
194                 } while ((v = inbyte(minor) & 0x30) == 0x30);
195
196                 if (v == 0x10) {
197                         data = (data >> 1) | 0x80;
198                         outbyte(1, minor);
199                         START(max);
200                         do {
201                                 WAIT(max);
202                         } while (!(inbyte(minor) & 0x20));
203                         outbyte(3, minor);
204                 } else {
205                         data = data >> 1;
206                         outbyte(2, minor);
207                         START(max);
208                         do {
209                                 WAIT(max);
210                         } while (!(inbyte(minor) & 0x10));
211                         outbyte(3, minor);
212                 }
213
214                 udelay(delay);
215                 if (need_resched())
216                         schedule();
217         }
218
219         return (int) data;
220 }
221
222 /* Try to detect a parallel link cable on the specified port */
223 static int
224 probe_ti_parallel(int minor)
225 {
226         int i;
227         int seq[] = { 0x00, 0x20, 0x10, 0x30 };
228
229         for (i = 3; i >= 0; i--) {
230                 outbyte(3, minor);
231                 outbyte(i, minor);
232                 udelay(delay);
233                 pr_debug("tipar: Probing -> %i: 0x%02x 0x%02x\n", i,
234                         data & 0x30, seq[i]);
235                 if ((inbyte(minor) & 0x30) != seq[i]) {
236                         outbyte(3, minor);
237                         return -1;
238                 }
239         }
240
241         outbyte(3, minor);
242         return 0;
243 }
244
245 /* ----- kernel module functions--------------------------------------- */
246
247 static int
248 tipar_open(struct inode *inode, struct file *file)
249 {
250         unsigned int minor = iminor(inode) - TIPAR_MINOR;
251
252         if (tp_count == 0 || minor > tp_count - 1)
253                 return -ENXIO;
254
255         if (test_and_set_bit(minor, &opened))
256                 return -EBUSY;
257
258         if (!table[minor].dev) {
259                 printk(KERN_ERR "%s: NULL device for minor %u\n",
260                                 __FUNCTION__, minor);
261                 return -ENXIO;
262         }
263         parport_claim_or_block(table[minor].dev);
264         init_ti_parallel(minor);
265         parport_release(table[minor].dev);
266
267         return nonseekable_open(inode, file);
268 }
269
270 static int
271 tipar_close(struct inode *inode, struct file *file)
272 {
273         unsigned int minor = iminor(inode) - TIPAR_MINOR;
274
275         if (minor > tp_count - 1)
276                 return -ENXIO;
277
278         clear_bit(minor, &opened);
279
280         return 0;
281 }
282
283 static ssize_t
284 tipar_write (struct file *file, const char __user *buf, size_t count,
285                 loff_t * ppos)
286 {
287         unsigned int minor = iminor(file->f_dentry->d_inode) - TIPAR_MINOR;
288         ssize_t n;
289
290         parport_claim_or_block(table[minor].dev);
291
292         for (n = 0; n < count; n++) {
293                 unsigned char b;
294
295                 if (get_user(b, buf + n)) {
296                         n = -EFAULT;
297                         goto out;
298                 }
299
300                 if (put_ti_parallel(minor, b) == -1) {
301                         init_ti_parallel(minor);
302                         n = -ETIMEDOUT;
303                         goto out;
304                 }
305         }
306       out:
307         parport_release(table[minor].dev);
308         return n;
309 }
310
311 static ssize_t
312 tipar_read(struct file *file, char __user *buf, size_t count, loff_t * ppos)
313 {
314         int b = 0;
315         unsigned int minor = iminor(file->f_dentry->d_inode) - TIPAR_MINOR;
316         ssize_t retval = 0;
317         ssize_t n = 0;
318
319         if (count == 0)
320                 return 0;
321
322         parport_claim_or_block(table[minor].dev);
323
324         while (n < count) {
325                 b = get_ti_parallel(minor);
326                 if (b == -1) {
327                         init_ti_parallel(minor);
328                         retval = -ETIMEDOUT;
329                         goto out;
330                 } else {
331                         if (put_user(b, buf + n)) {
332                                 retval = -EFAULT;
333                                 break;
334                         } else
335                                 retval = ++n;
336                 }
337
338                 /* Non-blocking mode : try again ! */
339                 if (file->f_flags & O_NONBLOCK) {
340                         retval = -EAGAIN;
341                         goto out;
342                 }
343
344                 /* Signal pending, try again ! */
345                 if (signal_pending(current)) {
346                         retval = -ERESTARTSYS;
347                         goto out;
348                 }
349
350                 if (need_resched())
351                         schedule();
352         }
353
354       out:
355         parport_release(table[minor].dev);
356         return retval;
357 }
358
359 static int
360 tipar_ioctl(struct inode *inode, struct file *file,
361             unsigned int cmd, unsigned long arg)
362 {
363         int retval = 0;
364
365         switch (cmd) {
366         case IOCTL_TIPAR_DELAY:
367                 delay = (int)arg;    //get_user(delay, &arg);
368                 break;
369         case IOCTL_TIPAR_TIMEOUT:
370                 if (arg != 0)
371                         timeout = (int)arg;
372                 else
373                         retval = -EINVAL;
374           break;
375         default:
376                 retval = -ENOTTY;
377                 break;
378         }
379
380         return retval;
381 }
382
383 /* ----- kernel module registering ------------------------------------ */
384
385 static struct file_operations tipar_fops = {
386         .owner = THIS_MODULE,
387         .llseek = no_llseek,
388         .read = tipar_read,
389         .write = tipar_write,
390         .ioctl = tipar_ioctl,
391         .open = tipar_open,
392         .release = tipar_close,
393 };
394
395 /* --- initialisation code ------------------------------------- */
396
397 #ifndef MODULE
398 /*      You must set these - there is no sane way to probe for this cable.
399  *      You can use 'tipar=timeout,delay' to set these now. */
400 static int __init
401 tipar_setup(char *str)
402 {
403         int ints[3];
404
405         str = get_options(str, ARRAY_SIZE(ints), ints);
406
407         if (ints[0] > 0) {
408                 if (ints[1] != 0)
409                         timeout = ints[1];
410                 else
411                         printk(KERN_WARNING "tipar: bad timeout value (0), "
412                                 "using default value instead");
413                 if (ints[0] > 1) {
414                         delay = ints[2];
415                 }
416         }
417
418         return 1;
419 }
420 #endif
421
422 /*
423  * Register our module into parport.
424  * Pass also 2 callbacks functions to parport: a pre-emptive function and an
425  * interrupt handler function (unused).
426  * Display a message such "tipar0: using parport0 (polling)".
427  */
428 static int
429 tipar_register(int nr, struct parport *port)
430 {
431         int err = 0;
432
433         /* Register our module into parport */
434         table[nr].dev = parport_register_device(port, "tipar",
435                                                 NULL, NULL, NULL, 0,
436                                                 (void *) &table[nr]);
437
438         if (table[nr].dev == NULL) {
439                 err = 1;
440                 goto out;
441         }
442
443         class_device_create(tipar_class, NULL, MKDEV(TIPAR_MAJOR,
444                         TIPAR_MINOR + nr), NULL, "par%d", nr);
445
446         /* Display informations */
447         pr_info("tipar%d: using %s (%s)\n", nr, port->name, (port->irq ==
448                 PARPORT_IRQ_NONE) ? "polling" : "interrupt-driven");
449
450         if (probe_ti_parallel(nr) != -1)
451                 pr_info("tipar%d: link cable found\n", nr);
452         else
453                 pr_info("tipar%d: link cable not found\n", nr);
454
455         err = 0;
456
457 out:
458         return err;
459 }
460
461 static void
462 tipar_attach(struct parport *port)
463 {
464         if (tp_count == PP_NO) {
465                 pr_info("tipar: ignoring parallel port (max. %d)\n", PP_NO);
466                 return;
467         }
468
469         if (!tipar_register(tp_count, port))
470                 tp_count++;
471 }
472
473 static void
474 tipar_detach(struct parport *port)
475 {
476         /* Nothing to do */
477 }
478
479 static struct parport_driver tipar_driver = {
480         .name = "tipar",
481         .attach = tipar_attach,
482         .detach = tipar_detach,
483 };
484
485 static int __init
486 tipar_init_module(void)
487 {
488         int err = 0;
489
490         pr_info("tipar: parallel link cable driver, version %s\n",
491                 DRIVER_VERSION);
492
493         if (register_chrdev(TIPAR_MAJOR, "tipar", &tipar_fops)) {
494                 printk(KERN_ERR "tipar: unable to get major %d\n", TIPAR_MAJOR);
495                 err = -EIO;
496                 goto out;
497         }
498
499         tipar_class = class_create(THIS_MODULE, "ticables");
500         if (IS_ERR(tipar_class)) {
501                 err = PTR_ERR(tipar_class);
502                 goto out_chrdev;
503         }
504         if (parport_register_driver(&tipar_driver)) {
505                 printk(KERN_ERR "tipar: unable to register with parport\n");
506                 err = -EIO;
507                 goto out_class;
508         }
509
510         err = 0;
511         goto out;
512
513 out_class:
514         class_destroy(tipar_class);
515
516 out_chrdev:
517         unregister_chrdev(TIPAR_MAJOR, "tipar");
518 out:
519         return err;     
520 }
521
522 static void __exit
523 tipar_cleanup_module(void)
524 {
525         unsigned int i;
526
527         /* Unregistering module */
528         parport_unregister_driver(&tipar_driver);
529
530         unregister_chrdev(TIPAR_MAJOR, "tipar");
531
532         for (i = 0; i < PP_NO; i++) {
533                 if (table[i].dev == NULL)
534                         continue;
535                 parport_unregister_device(table[i].dev);
536                 class_device_destroy(tipar_class, MKDEV(TIPAR_MAJOR, i));
537         }
538         class_destroy(tipar_class);
539
540         pr_info("tipar: module unloaded\n");
541 }
542
543 /* --------------------------------------------------------------------- */
544
545 __setup("tipar=", tipar_setup);
546 module_init(tipar_init_module);
547 module_exit(tipar_cleanup_module);
548
549 MODULE_AUTHOR(DRIVER_AUTHOR);
550 MODULE_DESCRIPTION(DRIVER_DESC);
551 MODULE_LICENSE(DRIVER_LICENSE);
552
553 module_param(timeout, int, 0);
554 MODULE_PARM_DESC(timeout, "Timeout (default=1.5 seconds)");
555 module_param(delay, int, 0);
556 MODULE_PARM_DESC(delay, "Inter-bit delay (default=10 microseconds)");