/* Hey EMACS -*- linux-c -*- * * tipar - low level driver for handling a parallel link cable designed * for Texas Instruments graphing calculators (http://lpg.ticalc.org). * A part of the TiLP project. * * Copyright (C) 2000-2002, Romain Lievin <roms@lpg.ticalc.org> * under the terms of the GNU General Public License. * * Various fixes & clean-up from the Linux Kernel Mailing List * (Alan Cox, Richard B. Johnson, Christoph Hellwig). */ /* This driver should, in theory, work with any parallel port that has an * appropriate low-level driver; all I/O is done through the parport * abstraction layer. * * If this driver is built into the kernel, you can configure it using the * kernel command-line. For example: * * tipar=timeout,delay (set timeout and delay) * * If the driver is loaded as a module, similar functionality is available * using module parameters. The equivalent of the above commands would be: * * # insmod tipar timeout=15 delay=10 */ /* COMPATIBILITY WITH OLD KERNELS * * Usually, parallel cables were bound to ports at * particular I/O addresses, as follows: * * tipar0 0x378 * tipar1 0x278 * tipar2 0x3bc * * * This driver, by default, binds tipar devices according to parport and * the minor number. * */#undef DEBUG /* change to #define to get debugging * output - for pr_debug() */#include <linux/module.h>#include <linux/types.h>#include <linux/errno.h>#include <linux/kernel.h>#include <linux/sched.h>#include <linux/delay.h>#include <linux/fcntl.h>#include <linux/fs.h>#include <linux/init.h>#include <asm/uaccess.h>#include <linux/ioport.h>#include <asm/io.h>#include <linux/bitops.h>#include <linux/parport.h> /* Our code depend on parport */#include <linux/device.h> /* * TI definitions */#include <linux/ticable.h> /* * Version Information */#define DRIVER_VERSION "1.19"#define DRIVER_AUTHOR "Romain Lievin <roms@lpg.ticalc.org>"#define DRIVER_DESC "Device driver for TI/PC parallel link cables"#define DRIVER_LICENSE "GPL" #define VERSION(ver,rel,seq) (((ver)<<16) | ((rel)<<8) | (seq)) /* ----- global variables --------------------------------------------- */ struct tipar_struct { struct pardevice *dev; /* Parport device entry */}; #define PP_NO 3static struct tipar_struct table[PP_NO]; static int delay = IO_DELAY; /* inter-bit delay in microseconds */static int timeout = TIMAXTIME; /* timeout in tenth of seconds */ static unsigned int tp_count; /* tipar count */static unsigned long opened; /* opened devices */ static struct class *tipar_class; /* --- macros for parport access -------------------------------------- */ #define r_dtr(x) (parport_read_data(table[(x)].dev->port))#define r_str(x) (parport_read_status(table[(x)].dev->port))#define w_ctr(x,y) (parport_write_control(table[(x)].dev->port, (y)))#define w_dtr(x,y) (parport_write_data(table[(x)].dev->port, (y))) /* --- setting states on the D-bus with the right timing: ------------- */ static inline voidoutbyte(int value, int minor){ w_dtr(minor, value);} static inline intinbyte(int minor){ return (r_str(minor));} static inline voidinit_ti_parallel(int minor){ outbyte(3, minor);} /* ----- global defines ----------------------------------------------- */ #define START(x) { x = jiffies + (HZ * timeout) / 10; }#define WAIT(x) { \ if (time_before((x), jiffies)) return -1; \ if (need_resched()) schedule(); } /* ----- D-bus bit-banging functions ---------------------------------- */ /* D-bus protocol (45kbit/s max): 1 0 0 _______ ______|______ __________|________ __________Red : ________ | ____ | ____ _ ____________|________ ______|__________ _____White: ________ | ______ | _______*/ /* Try to transmit a byte on the specified port (-1 if error). */static intput_ti_parallel(int minor, unsigned char data){ unsigned int bit; unsigned long max; for (bit = 0; bit < 8; bit++) { if (data & 1) { outbyte(2, minor); START(max); do { WAIT(max); } while (inbyte(minor) & 0x10); outbyte(3, minor); START(max); do { WAIT(max); } while (!(inbyte(minor) & 0x10)); } else { outbyte(1, minor); START(max); do { WAIT(max); } while (inbyte(minor) & 0x20); outbyte(3, minor); START(max); do { WAIT(max); } while (!(inbyte(minor) & 0x20)); } data >>= 1; udelay(delay); if (need_resched()) schedule(); } return 0;} /* Receive a byte on the specified port or -1 if error. */static intget_ti_parallel(int minor){ unsigned int bit; unsigned char v, data = 0; unsigned long max; for (bit = 0; bit < 8; bit++) { START(max); do { WAIT(max); } while ((v = inbyte(minor) & 0x30) == 0x30); if (v == 0x10) { data = (data >> 1) | 0x80; outbyte(1, minor); START(max); do { WAIT(max); } while (!(inbyte(minor) & 0x20)); outbyte(3, minor); } else { data = data >> 1; outbyte(2, minor); START(max); do { WAIT(max); } while (!(inbyte(minor) & 0x10)); outbyte(3, minor); } udelay(delay); if (need_resched()) schedule(); } return (int) data;} /* Try to detect a parallel link cable on the specified port */static intprobe_ti_parallel(int minor){ int i; int seq[] = { 0x00, 0x20, 0x10, 0x30 }; int data; for (i = 3; i >= 0; i--) { outbyte(3, minor); outbyte(i, minor); udelay(delay); data = inbyte(minor) & 0x30; pr_debug("tipar: Probing -> %i: 0x%02x 0x%02x\n", i, data, seq[i]); if (data != seq[i]) { outbyte(3, minor); return -1; } } outbyte(3, minor); return 0;} /* ----- kernel module functions--------------------------------------- */ static inttipar_open(struct inode *inode, struct file *file){ unsigned int minor = iminor(inode) - TIPAR_MINOR; if (tp_count == 0 || minor > tp_count - 1) return -ENXIO; if (test_and_set_bit(minor, &opened)) return -EBUSY; if (!table[minor].dev) { printk(KERN_ERR "%s: NULL device for minor %u\n", __FUNCTION__, minor); return -ENXIO; } parport_claim_or_block(table[minor].dev); init_ti_parallel(minor); parport_release(table[minor].dev); return nonseekable_open(inode, file);} static inttipar_close(struct inode *inode, struct file *file){ unsigned int minor = iminor(inode) - TIPAR_MINOR; if (minor > tp_count - 1) return -ENXIO; clear_bit(minor, &opened); return 0;} static ssize_ttipar_write (struct file *file, const char __user *buf, size_t count, loff_t * ppos){ unsigned int minor = iminor(file->f_path.dentry->d_inode) - TIPAR_MINOR; ssize_t n; parport_claim_or_block(table[minor].dev); for (n = 0; n < count; n++) { unsigned char b; if (get_user(b, buf + n)) { n = -EFAULT; goto out; } if (put_ti_parallel(minor, b) == -1) { init_ti_parallel(minor); n = -ETIMEDOUT; goto out; } } out: parport_release(table[minor].dev); return n;} static ssize_ttipar_read(struct file *file, char __user *buf, size_t count, loff_t * ppos){ int b = 0; unsigned int minor = iminor(file->f_path.dentry->d_inode) - TIPAR_MINOR; ssize_t retval = 0; ssize_t n = 0; if (count == 0) return 0; parport_claim_or_block(table[minor].dev); while (n < count) { b = get_ti_parallel(minor); if (b == -1) { init_ti_parallel(minor); retval = -ETIMEDOUT; goto out; } else { if (put_user(b, buf + n)) { retval = -EFAULT; break; } else retval = ++n; } /* Non-blocking mode : try again ! */ if (file->f_flags & O_NONBLOCK) { retval = -EAGAIN; goto out; } /* Signal pending, try again ! */ if (signal_pending(current)) { retval = -ERESTARTSYS; goto out; } if (need_resched()) schedule(); } out: parport_release(table[minor].dev); return retval;} static inttipar_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg){ int retval = 0; switch (cmd) { case IOCTL_TIPAR_DELAY: delay = (int)arg; //get_user(delay, &arg); break; case IOCTL_TIPAR_TIMEOUT: if (arg != 0) timeout = (int)arg; else retval = -EINVAL; break; default: retval = -ENOTTY; break; } return retval;} /* ----- kernel module registering ------------------------------------ */ static const struct file_operations tipar_fops = { .owner = THIS_MODULE, .llseek = no_llseek, .read = tipar_read, .write = tipar_write, .ioctl = tipar_ioctl, .open = tipar_open, .release = tipar_close,}; /* --- initialisation code ------------------------------------- */ #ifndef MODULE/* You must set these - there is no sane way to probe for this cable. * You can use 'tipar=timeout,delay' to set these now. */static int __inittipar_setup(char *str){ int ints[3]; str = get_options(str, ARRAY_SIZE(ints), ints); if (ints[0] > 0) { if (ints[1] != 0) timeout = ints[1]; else printk(KERN_WARNING "tipar: bad timeout value (0), " "using default value instead"); if (ints[0] > 1) { delay = ints[2]; } } return 1;}#endif /* * Register our module into parport. * Pass also 2 callbacks functions to parport: a pre-emptive function and an * interrupt handler function (unused). * Display a message such "tipar0: using parport0 (polling)". */static inttipar_register(int nr, struct parport *port){ int err = 0; /* Register our module into parport */ table[nr].dev = parport_register_device(port, "tipar", NULL, NULL, NULL, 0, (void *) &table[nr]); if (table[nr].dev == NULL) { err = 1; goto out; } class_device_create(tipar_class, NULL, MKDEV(TIPAR_MAJOR, TIPAR_MINOR + nr), NULL, "par%d", nr); /* Display informations */ pr_info("tipar%d: using %s (%s)\n", nr, port->name, (port->irq == PARPORT_IRQ_NONE) ? "polling" : "interrupt-driven"); if (probe_ti_parallel(nr) != -1) pr_info("tipar%d: link cable found\n", nr); else pr_info("tipar%d: link cable not found\n", nr); err = 0; out: return err;} static voidtipar_attach(struct parport *port){ if (tp_count == PP_NO) { pr_info("tipar: ignoring parallel port (max. %d)\n", PP_NO); return; } if (!tipar_register(tp_count, port)) tp_count++;} static voidtipar_detach(struct parport *port){ /* Nothing to do */} static struct parport_driver tipar_driver = { .name = "tipar", .attach = tipar_attach, .detach = tipar_detach,}; static int __inittipar_init_module(void){ int err = 0; pr_info("tipar: parallel link cable driver, version %s\n", DRIVER_VERSION); if (register_chrdev(TIPAR_MAJOR, "tipar", &tipar_fops)) { printk(KERN_ERR "tipar: unable to get major %d\n", TIPAR_MAJOR); err = -EIO; goto out; } tipar_class = class_create(THIS_MODULE, "ticables");Lines 1–500 of 557. Load more
/* Hey EMACS -*- linux-c -*- * * tipar - low level driver for handling a parallel link cable designed * for Texas Instruments graphing calculators (http://lpg.ticalc.org). * A part of the TiLP project. * * Copyright (C) 2000-2002, Romain Lievin <roms@lpg.ticalc.org> * under the terms of the GNU General Public License. * * Various fixes & clean-up from the Linux Kernel Mailing List * (Alan Cox, Richard B. Johnson, Christoph Hellwig). */ /* This driver should, in theory, work with any parallel port that has an * appropriate low-level driver; all I/O is done through the parport * abstraction layer. * * If this driver is built into the kernel, you can configure it using the * kernel command-line. For example: * * tipar=timeout,delay (set timeout and delay) * * If the driver is loaded as a module, similar functionality is available * using module parameters. The equivalent of the above commands would be: * * # insmod tipar timeout=15 delay=10 */ /* COMPATIBILITY WITH OLD KERNELS * * Usually, parallel cables were bound to ports at * particular I/O addresses, as follows: * * tipar0 0x378 * tipar1 0x278 * tipar2 0x3bc * * * This driver, by default, binds tipar devices according to parport and * the minor number. * */ #undef DEBUG /* change to #define to get debugging * output - for pr_debug() */ #include <linux/module.h> #include <linux/types.h> #include <linux/errno.h> #include <linux/kernel.h> #include <linux/sched.h> #include <linux/delay.h> #include <linux/fcntl.h> #include <linux/fs.h> #include <linux/init.h> #include <asm/uaccess.h> #include <linux/ioport.h> #include <asm/io.h> #include <linux/bitops.h> #include <linux/parport.h> /* Our code depend on parport */ #include <linux/device.h> /* * TI definitions */ #include <linux/ticable.h> /* * Version Information */ #define DRIVER_VERSION "1.19" #define DRIVER_AUTHOR "Romain Lievin <roms@lpg.ticalc.org>" #define DRIVER_DESC "Device driver for TI/PC parallel link cables" #define DRIVER_LICENSE "GPL" #define VERSION(ver,rel,seq) (((ver)<<16) | ((rel)<<8) | (seq)) /* ----- global variables --------------------------------------------- */ struct tipar_struct { struct pardevice *dev; /* Parport device entry */ }; #define PP_NO 3 static struct tipar_struct table[PP_NO]; static int delay = IO_DELAY; /* inter-bit delay in microseconds */ static int timeout = TIMAXTIME; /* timeout in tenth of seconds */ static unsigned int tp_count; /* tipar count */ static unsigned long opened; /* opened devices */ static struct class *tipar_class; /* --- macros for parport access -------------------------------------- */ #define r_dtr(x) (parport_read_data(table[(x)].dev->port)) #define r_str(x) (parport_read_status(table[(x)].dev->port)) #define w_ctr(x,y) (parport_write_control(table[(x)].dev->port, (y))) #define w_dtr(x,y) (parport_write_data(table[(x)].dev->port, (y))) /* --- setting states on the D-bus with the right timing: ------------- */ static inline void outbyte(int value, int minor) { w_dtr(minor, value); } static inline int inbyte(int minor) { return (r_str(minor)); } static inline void init_ti_parallel(int minor) { outbyte(3, minor); } /* ----- global defines ----------------------------------------------- */ #define START(x) { x = jiffies + (HZ * timeout) / 10; } #define WAIT(x) { \ if (time_before((x), jiffies)) return -1; \ if (need_resched()) schedule(); } /* ----- D-bus bit-banging functions ---------------------------------- */ /* D-bus protocol (45kbit/s max): 1 0 0 _______ ______|______ __________|________ __________ Red : ________ | ____ | ____ _ ____________|________ ______|__________ _____ White: ________ | ______ | _______ */ /* Try to transmit a byte on the specified port (-1 if error). */ static int put_ti_parallel(int minor, unsigned char data) { unsigned int bit; unsigned long max; for (bit = 0; bit < 8; bit++) { if (data & 1) { outbyte(2, minor); START(max); do { WAIT(max); } while (inbyte(minor) & 0x10); outbyte(3, minor); START(max); do { WAIT(max); } while (!(inbyte(minor) & 0x10)); } else { outbyte(1, minor); START(max); do { WAIT(max); } while (inbyte(minor) & 0x20); outbyte(3, minor); START(max); do { WAIT(max); } while (!(inbyte(minor) & 0x20)); } data >>= 1; udelay(delay); if (need_resched()) schedule(); } return 0; } /* Receive a byte on the specified port or -1 if error. */ static int get_ti_parallel(int minor) { unsigned int bit; unsigned char v, data = 0; unsigned long max; for (bit = 0; bit < 8; bit++) { START(max); do { WAIT(max); } while ((v = inbyte(minor) & 0x30) == 0x30); if (v == 0x10) { data = (data >> 1) | 0x80; outbyte(1, minor); START(max); do { WAIT(max); } while (!(inbyte(minor) & 0x20)); outbyte(3, minor); } else { data = data >> 1; outbyte(2, minor); START(max); do { WAIT(max); } while (!(inbyte(minor) & 0x10)); outbyte(3, minor); } udelay(delay); if (need_resched()) schedule(); } return (int) data; } /* Try to detect a parallel link cable on the specified port */ static int probe_ti_parallel(int minor) { int i; int seq[] = { 0x00, 0x20, 0x10, 0x30 }; int data; for (i = 3; i >= 0; i--) { outbyte(3, minor); outbyte(i, minor); udelay(delay); data = inbyte(minor) & 0x30; pr_debug("tipar: Probing -> %i: 0x%02x 0x%02x\n", i, data, seq[i]); if (data != seq[i]) { outbyte(3, minor); return -1; } } outbyte(3, minor); return 0; } /* ----- kernel module functions--------------------------------------- */ static int tipar_open(struct inode *inode, struct file *file) { unsigned int minor = iminor(inode) - TIPAR_MINOR; if (tp_count == 0 || minor > tp_count - 1) return -ENXIO; if (test_and_set_bit(minor, &opened)) return -EBUSY; if (!table[minor].dev) { printk(KERN_ERR "%s: NULL device for minor %u\n", __FUNCTION__, minor); return -ENXIO; } parport_claim_or_block(table[minor].dev); init_ti_parallel(minor); parport_release(table[minor].dev); return nonseekable_open(inode, file); } static int tipar_close(struct inode *inode, struct file *file) { unsigned int minor = iminor(inode) - TIPAR_MINOR; if (minor > tp_count - 1) return -ENXIO; clear_bit(minor, &opened); return 0; } static ssize_t tipar_write (struct file *file, const char __user *buf, size_t count, loff_t * ppos) { unsigned int minor = iminor(file->f_path.dentry->d_inode) - TIPAR_MINOR; ssize_t n; parport_claim_or_block(table[minor].dev); for (n = 0; n < count; n++) { unsigned char b; if (get_user(b, buf + n)) { n = -EFAULT; goto out; } if (put_ti_parallel(minor, b) == -1) { init_ti_parallel(minor); n = -ETIMEDOUT; goto out; } } out: parport_release(table[minor].dev); return n; } static ssize_t tipar_read(struct file *file, char __user *buf, size_t count, loff_t * ppos) { int b = 0; unsigned int minor = iminor(file->f_path.dentry->d_inode) - TIPAR_MINOR; ssize_t retval = 0; ssize_t n = 0; if (count == 0) return 0; parport_claim_or_block(table[minor].dev); while (n < count) { b = get_ti_parallel(minor); if (b == -1) { init_ti_parallel(minor); retval = -ETIMEDOUT; goto out; } else { if (put_user(b, buf + n)) { retval = -EFAULT; break; } else retval = ++n; } /* Non-blocking mode : try again ! */ if (file->f_flags & O_NONBLOCK) { retval = -EAGAIN; goto out; } /* Signal pending, try again ! */ if (signal_pending(current)) { retval = -ERESTARTSYS; goto out; } if (need_resched()) schedule(); } out: parport_release(table[minor].dev); return retval; } static int tipar_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg) { int retval = 0; switch (cmd) { case IOCTL_TIPAR_DELAY: delay = (int)arg; //get_user(delay, &arg); break; case IOCTL_TIPAR_TIMEOUT: if (arg != 0) timeout = (int)arg; else retval = -EINVAL; break; default: retval = -ENOTTY; break; } return retval; } /* ----- kernel module registering ------------------------------------ */ static const struct file_operations tipar_fops = { .owner = THIS_MODULE, .llseek = no_llseek, .read = tipar_read, .write = tipar_write, .ioctl = tipar_ioctl, .open = tipar_open, .release = tipar_close, }; /* --- initialisation code ------------------------------------- */ #ifndef MODULE /* You must set these - there is no sane way to probe for this cable. * You can use 'tipar=timeout,delay' to set these now. */ static int __init tipar_setup(char *str) { int ints[3]; str = get_options(str, ARRAY_SIZE(ints), ints); if (ints[0] > 0) { if (ints[1] != 0) timeout = ints[1]; else printk(KERN_WARNING "tipar: bad timeout value (0), " "using default value instead"); if (ints[0] > 1) { delay = ints[2]; } } return 1; } #endif /* * Register our module into parport. * Pass also 2 callbacks functions to parport: a pre-emptive function and an * interrupt handler function (unused). * Display a message such "tipar0: using parport0 (polling)". */ static int tipar_register(int nr, struct parport *port) { int err = 0; /* Register our module into parport */ table[nr].dev = parport_register_device(port, "tipar", NULL, NULL, NULL, 0, (void *) &table[nr]); if (table[nr].dev == NULL) { err = 1; goto out; } class_device_create(tipar_class, NULL, MKDEV(TIPAR_MAJOR, TIPAR_MINOR + nr), NULL, "par%d", nr); /* Display informations */ pr_info("tipar%d: using %s (%s)\n", nr, port->name, (port->irq == PARPORT_IRQ_NONE) ? "polling" : "interrupt-driven"); if (probe_ti_parallel(nr) != -1) pr_info("tipar%d: link cable found\n", nr); else pr_info("tipar%d: link cable not found\n", nr); err = 0; out: return err; } static void tipar_attach(struct parport *port) { if (tp_count == PP_NO) { pr_info("tipar: ignoring parallel port (max. %d)\n", PP_NO); return; } if (!tipar_register(tp_count, port)) tp_count++; } static void tipar_detach(struct parport *port) { /* Nothing to do */ } static struct parport_driver tipar_driver = { .name = "tipar", .attach = tipar_attach, .detach = tipar_detach, }; static int __init tipar_init_module(void) { int err = 0; pr_info("tipar: parallel link cable driver, version %s\n", DRIVER_VERSION); if (register_chrdev(TIPAR_MAJOR, "tipar", &tipar_fops)) { printk(KERN_ERR "tipar: unable to get major %d\n", TIPAR_MAJOR); err = -EIO; goto out; } tipar_class = class_create(THIS_MODULE, "ticables");