diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 22:20:36 (GMT) |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 22:20:36 (GMT) |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/char/tipar.c | |
download | linux-1da177e4c3f41524e886b7f1b8a0c1fc7321cac2.tar.xz |
Linux-2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'drivers/char/tipar.c')
-rw-r--r-- | drivers/char/tipar.c | 564 |
1 files changed, 564 insertions, 0 deletions
diff --git a/drivers/char/tipar.c b/drivers/char/tipar.c new file mode 100644 index 0000000..0c5ba9d --- /dev/null +++ b/drivers/char/tipar.c @@ -0,0 +1,564 @@ +/* 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/config.h> +#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/devfs_fs_kernel.h> /* DevFs support */ +#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_simple *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 }; + + for (i = 3; i >= 0; i--) { + outbyte(3, minor); + outbyte(i, minor); + udelay(delay); + pr_debug("tipar: Probing -> %i: 0x%02x 0x%02x\n", i, + data & 0x30, seq[i]); + if ((inbyte(minor) & 0x30) != 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 (minor > tp_count - 1) + return -ENXIO; + + if (test_and_set_bit(minor, &opened)) + return -EBUSY; + + 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_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_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 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[2]; + + 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_simple_device_add(tipar_class, MKDEV(TIPAR_MAJOR, + TIPAR_MINOR + nr), NULL, "par%d", nr); + /* Use devfs, tree: /dev/ticables/par/[0..2] */ + err = devfs_mk_cdev(MKDEV(TIPAR_MAJOR, TIPAR_MINOR + nr), + S_IFCHR | S_IRUGO | S_IWUGO, + "ticables/par/%d", nr); + if (err) + goto out_class; + + /* 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; + goto out; + +out_class: + class_simple_device_remove(MKDEV(TIPAR_MAJOR, TIPAR_MINOR + nr)); + class_simple_destroy(tipar_class); +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; + } + + /* Use devfs with tree: /dev/ticables/par/[0..2] */ + devfs_mk_dir("ticables/par"); + + tipar_class = class_simple_create(THIS_MODULE, "ticables"); + if (IS_ERR(tipar_class)) { + err = PTR_ERR(tipar_class); + goto out_chrdev; + } + if (parport_register_driver(&tipar_driver)) { + printk(KERN_ERR "tipar: unable to register with parport\n"); + err = -EIO; + goto out; + } + + err = 0; + goto out; + +out_chrdev: + unregister_chrdev(TIPAR_MAJOR, "tipar"); +out: + return err; +} + +static void __exit +tipar_cleanup_module(void) +{ + unsigned int i; + + /* Unregistering module */ + parport_unregister_driver(&tipar_driver); + + unregister_chrdev(TIPAR_MAJOR, "tipar"); + + for (i = 0; i < PP_NO; i++) { + if (table[i].dev == NULL) + continue; + parport_unregister_device(table[i].dev); + class_simple_device_remove(MKDEV(TIPAR_MAJOR, i)); + devfs_remove("ticables/par/%d", i); + } + class_simple_destroy(tipar_class); + devfs_remove("ticables/par"); + + pr_info("tipar: module unloaded\n"); +} + +/* --------------------------------------------------------------------- */ + +__setup("tipar=", tipar_setup); +module_init(tipar_init_module); +module_exit(tipar_cleanup_module); + +MODULE_AUTHOR(DRIVER_AUTHOR); +MODULE_DESCRIPTION(DRIVER_DESC); +MODULE_LICENSE(DRIVER_LICENSE); + +module_param(timeout, int, 0); +MODULE_PARM_DESC(timeout, "Timeout (default=1.5 seconds)"); +module_param(delay, int, 0); +MODULE_PARM_DESC(delay, "Inter-bit delay (default=10 microseconds)"); |