1 /* Hey EMACS -*- linux-c -*-
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.
7 * Copyright (C) 2000-2002, Romain Lievin <roms@lpg.ticalc.org>
8 * under the terms of the GNU General Public License.
10 * Various fixes & clean-up from the Linux Kernel Mailing List
11 * (Alan Cox, Richard B. Johnson, Christoph Hellwig).
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
18 * If this driver is built into the kernel, you can configure it using the
19 * kernel command-line. For example:
21 * tipar=timeout,delay (set timeout and delay)
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:
26 * # insmod tipar timeout=15 delay=10
29 /* COMPATIBILITY WITH OLD KERNELS
31 * Usually, parallel cables were bound to ports at
32 * particular I/O addresses, as follows:
39 * This driver, by default, binds tipar devices according to parport and
44 #include <linux/config.h>
45 #include <linux/module.h>
46 #include <linux/version.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>
54 #include <linux/init.h>
55 #include <asm/uaccess.h>
56 #include <linux/ioport.h>
58 #include <asm/bitops.h>
59 #include <linux/devfs_fs_kernel.h> /* DevFs support */
60 #include <linux/parport.h> /* Our code depend on parport */
65 #include <linux/ticable.h>
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"
75 #define VERSION(ver,rel,seq) (((ver)<<16) | ((rel)<<8) | (seq))
76 #if LINUX_VERSION_CODE < VERSION(2,5,0)
77 # define need_resched() (current->need_resched)
80 /* ----- global variables --------------------------------------------- */
83 struct pardevice *dev; /* Parport device entry */
87 static struct tipar_struct table[PP_NO];
89 static int delay = IO_DELAY; /* inter-bit delay in microseconds */
90 static int timeout = TIMAXTIME; /* timeout in tenth of seconds */
92 static unsigned int tp_count; /* tipar count */
93 static unsigned long opened; /* opened devices */
95 /* --- macros for parport access -------------------------------------- */
97 #define r_dtr(x) (parport_read_data(table[(x)].dev->port))
98 #define r_str(x) (parport_read_status(table[(x)].dev->port))
99 #define w_ctr(x,y) (parport_write_control(table[(x)].dev->port, (y)))
100 #define w_dtr(x,y) (parport_write_data(table[(x)].dev->port, (y)))
102 /* --- setting states on the D-bus with the right timing: ------------- */
105 outbyte(int value, int minor)
113 return (r_str(minor));
117 init_ti_parallel(int minor)
122 /* ----- global defines ----------------------------------------------- */
124 #define START(x) { x = jiffies + (HZ * timeout) / 10; }
126 if (time_before((x), jiffies)) return -1; \
127 if (need_resched()) schedule(); }
129 /* ----- D-bus bit-banging functions ---------------------------------- */
131 /* D-bus protocol (45kbit/s max):
133 _______ ______|______ __________|________ __________
134 Red : ________ | ____ | ____
135 _ ____________|________ ______|__________ _____
136 White: ________ | ______ | _______
139 /* Try to transmit a byte on the specified port (-1 if error). */
141 put_ti_parallel(int minor, unsigned char data)
146 for (bit = 0; bit < 8; bit++) {
152 } while (inbyte(minor) & 0x10);
158 } while (!(inbyte(minor) & 0x10));
164 } while (inbyte(minor) & 0x20);
170 } while (!(inbyte(minor) & 0x20));
183 /* Receive a byte on the specified port or -1 if error. */
185 get_ti_parallel(int minor)
188 unsigned char v, data = 0;
191 for (bit = 0; bit < 8; bit++) {
195 } while ((v = inbyte(minor) & 0x30) == 0x30);
198 data = (data >> 1) | 0x80;
203 } while (!(inbyte(minor) & 0x20));
211 } while (!(inbyte(minor) & 0x10));
223 /* Try to detect a parallel link cable on the specified port */
225 probe_ti_parallel(int minor)
228 int seq[] = { 0x00, 0x20, 0x10, 0x30 };
230 for (i = 3; i >= 0; i--) {
234 /*printk(KERN_DEBUG "Probing -> %i: 0x%02x 0x%02x\n", i, data & 0x30, seq[i]); */
235 if ((inbyte(minor) & 0x30) != seq[i]) {
245 /* ----- kernel module functions--------------------------------------- */
248 tipar_open(struct inode *inode, struct file *file)
250 unsigned int minor = iminor(inode) - TIPAR_MINOR;
252 if (minor > tp_count - 1)
255 if (test_and_set_bit(minor, &opened))
258 parport_claim_or_block(table[minor].dev);
259 init_ti_parallel(minor);
260 parport_release(table[minor].dev);
266 tipar_close(struct inode *inode, struct file *file)
268 unsigned int minor = iminor(inode) - TIPAR_MINOR;
270 if (minor > tp_count - 1)
273 clear_bit(minor, &opened);
279 tipar_write(struct file *file, const char *buf, size_t count, loff_t * ppos)
281 unsigned int minor = iminor(file->f_dentry->d_inode) - TIPAR_MINOR;
284 parport_claim_or_block(table[minor].dev);
286 for (n = 0; n < count; n++) {
289 if (get_user(b, buf + n)) {
294 if (put_ti_parallel(minor, b) == -1) {
295 init_ti_parallel(minor);
301 parport_release(table[minor].dev);
306 tipar_read(struct file *file, char *buf, size_t count, loff_t * ppos)
309 unsigned int minor = iminor(file->f_dentry->d_inode) - TIPAR_MINOR;
316 if (ppos != &file->f_pos)
319 parport_claim_or_block(table[minor].dev);
322 b = get_ti_parallel(minor);
324 init_ti_parallel(minor);
328 if (put_user(b, ((unsigned char *) buf) + n)) {
335 /* Non-blocking mode : try again ! */
336 if (file->f_flags & O_NONBLOCK) {
341 /* Signal pending, try again ! */
342 if (signal_pending(current)) {
343 retval = -ERESTARTSYS;
352 parport_release(table[minor].dev);
357 tipar_ioctl(struct inode *inode, struct file *file,
358 unsigned int cmd, unsigned long arg)
363 case IOCTL_TIPAR_DELAY:
364 delay = (int)arg; //get_user(delay, &arg);
366 case IOCTL_TIPAR_TIMEOUT:
380 /* ----- kernel module registering ------------------------------------ */
382 static struct file_operations tipar_fops = {
383 .owner = THIS_MODULE,
386 .write = tipar_write,
387 .ioctl = tipar_ioctl,
389 .release = tipar_close,
392 /* --- initialisation code ------------------------------------- */
395 /* You must set these - there is no sane way to probe for this cable.
396 * You can use 'tipar=timeout,delay' to set these now. */
398 tipar_setup(char *str)
402 str = get_options(str, ARRAY_SIZE(ints), ints);
408 printk("tipar: wrong timeout value (0), using default value instead.");
419 * Register our module into parport.
420 * Pass also 2 callbacks functions to parport: a pre-emptive function and an
421 * interrupt handler function (unused).
422 * Display a message such "tipar0: using parport0 (polling)".
425 tipar_register(int nr, struct parport *port)
427 /* Register our module into parport */
428 table[nr].dev = parport_register_device(port, "tipar",
430 (void *) &table[nr]);
432 if (table[nr].dev == NULL)
435 /* Use devfs, tree: /dev/ticables/par/[0..2] */
436 devfs_mk_cdev(MKDEV(TIPAR_MAJOR, TIPAR_MINOR + nr),
437 S_IFCHR | S_IRUGO | S_IWUGO,
438 "ticables/par/%d", nr);
440 /* Display informations */
441 printk(KERN_INFO "tipar%d: using %s (%s).\n", nr, port->name,
443 PARPORT_IRQ_NONE) ? "polling" : "interrupt-driven");
445 if (probe_ti_parallel(nr) != -1)
446 printk("tipar%d: link cable found !\n", nr);
448 printk("tipar%d: link cable not found.\n", nr);
454 tipar_attach(struct parport *port)
456 if (tp_count == PP_NO) {
457 printk("tipar: ignoring parallel port (max. %d)\n", PP_NO);
461 if (!tipar_register(tp_count, port))
466 tipar_detach(struct parport *port)
471 static struct parport_driver tipar_driver = {
473 .attach = tipar_attach,
474 .detach = tipar_detach,
478 tipar_init_module(void)
480 printk("tipar: parallel link cable driver, version %s\n",
483 if (register_chrdev(TIPAR_MAJOR, "tipar", &tipar_fops)) {
484 printk("tipar: unable to get major %d\n", TIPAR_MAJOR);
488 /* Use devfs with tree: /dev/ticables/par/[0..2] */
489 devfs_mk_dir("ticables/par");
491 if (parport_register_driver(&tipar_driver)) {
492 printk("tipar: unable to register with parport\n");
500 tipar_cleanup_module(void)
504 /* Unregistering module */
505 parport_unregister_driver(&tipar_driver);
507 unregister_chrdev(TIPAR_MAJOR, "tipar");
509 for (i = 0; i < PP_NO; i++) {
510 if (table[i].dev == NULL)
512 parport_unregister_device(table[i].dev);
513 devfs_remove("ticables/par/%d", i);
515 devfs_remove("ticables/par");
517 printk("tipar: module unloaded !\n");
520 /* --------------------------------------------------------------------- */
522 __setup("tipar=", tipar_setup);
523 module_init(tipar_init_module);
524 module_exit(tipar_cleanup_module);
526 MODULE_AUTHOR(DRIVER_AUTHOR);
527 MODULE_DESCRIPTION(DRIVER_DESC);
528 MODULE_LICENSE(DRIVER_LICENSE);
530 MODULE_PARM(timeout, "i");
531 MODULE_PARM_DESC(timeout, "Timeout (default=1.5 seconds)");
532 MODULE_PARM(delay, "i");
533 MODULE_PARM_DESC(delay, "Inter-bit delay (default=10 microseconds)");