ia64/linux-2.6.18-xen.hg

view drivers/char/tipar.c @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 831230e53067
children
line source
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 */
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 */
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/module.h>
46 #include <linux/types.h>
47 #include <linux/errno.h>
48 #include <linux/kernel.h>
49 #include <linux/sched.h>
50 #include <linux/delay.h>
51 #include <linux/fcntl.h>
52 #include <linux/fs.h>
53 #include <linux/init.h>
54 #include <asm/uaccess.h>
55 #include <linux/ioport.h>
56 #include <asm/io.h>
57 #include <linux/bitops.h>
58 #include <linux/parport.h> /* Our code depend on parport */
59 #include <linux/device.h>
61 /*
62 * TI definitions
63 */
64 #include <linux/ticable.h>
66 /*
67 * Version Information
68 */
69 #define DRIVER_VERSION "1.19"
70 #define DRIVER_AUTHOR "Romain Lievin <roms@lpg.ticalc.org>"
71 #define DRIVER_DESC "Device driver for TI/PC parallel link cables"
72 #define DRIVER_LICENSE "GPL"
74 #define VERSION(ver,rel,seq) (((ver)<<16) | ((rel)<<8) | (seq))
76 /* ----- global variables --------------------------------------------- */
78 struct tipar_struct {
79 struct pardevice *dev; /* Parport device entry */
80 };
82 #define PP_NO 3
83 static struct tipar_struct table[PP_NO];
85 static int delay = IO_DELAY; /* inter-bit delay in microseconds */
86 static int timeout = TIMAXTIME; /* timeout in tenth of seconds */
88 static unsigned int tp_count; /* tipar count */
89 static unsigned long opened; /* opened devices */
91 static struct class *tipar_class;
93 /* --- macros for parport access -------------------------------------- */
95 #define r_dtr(x) (parport_read_data(table[(x)].dev->port))
96 #define r_str(x) (parport_read_status(table[(x)].dev->port))
97 #define w_ctr(x,y) (parport_write_control(table[(x)].dev->port, (y)))
98 #define w_dtr(x,y) (parport_write_data(table[(x)].dev->port, (y)))
100 /* --- setting states on the D-bus with the right timing: ------------- */
102 static inline void
103 outbyte(int value, int minor)
104 {
105 w_dtr(minor, value);
106 }
108 static inline int
109 inbyte(int minor)
110 {
111 return (r_str(minor));
112 }
114 static inline void
115 init_ti_parallel(int minor)
116 {
117 outbyte(3, minor);
118 }
120 /* ----- global defines ----------------------------------------------- */
122 #define START(x) { x = jiffies + (HZ * timeout) / 10; }
123 #define WAIT(x) { \
124 if (time_before((x), jiffies)) return -1; \
125 if (need_resched()) schedule(); }
127 /* ----- D-bus bit-banging functions ---------------------------------- */
129 /* D-bus protocol (45kbit/s max):
130 1 0 0
131 _______ ______|______ __________|________ __________
132 Red : ________ | ____ | ____
133 _ ____________|________ ______|__________ _____
134 White: ________ | ______ | _______
135 */
137 /* Try to transmit a byte on the specified port (-1 if error). */
138 static int
139 put_ti_parallel(int minor, unsigned char data)
140 {
141 unsigned int bit;
142 unsigned long max;
144 for (bit = 0; bit < 8; bit++) {
145 if (data & 1) {
146 outbyte(2, minor);
147 START(max);
148 do {
149 WAIT(max);
150 } while (inbyte(minor) & 0x10);
152 outbyte(3, minor);
153 START(max);
154 do {
155 WAIT(max);
156 } while (!(inbyte(minor) & 0x10));
157 } else {
158 outbyte(1, minor);
159 START(max);
160 do {
161 WAIT(max);
162 } while (inbyte(minor) & 0x20);
164 outbyte(3, minor);
165 START(max);
166 do {
167 WAIT(max);
168 } while (!(inbyte(minor) & 0x20));
169 }
171 data >>= 1;
172 udelay(delay);
174 if (need_resched())
175 schedule();
176 }
178 return 0;
179 }
181 /* Receive a byte on the specified port or -1 if error. */
182 static int
183 get_ti_parallel(int minor)
184 {
185 unsigned int bit;
186 unsigned char v, data = 0;
187 unsigned long max;
189 for (bit = 0; bit < 8; bit++) {
190 START(max);
191 do {
192 WAIT(max);
193 } while ((v = inbyte(minor) & 0x30) == 0x30);
195 if (v == 0x10) {
196 data = (data >> 1) | 0x80;
197 outbyte(1, minor);
198 START(max);
199 do {
200 WAIT(max);
201 } while (!(inbyte(minor) & 0x20));
202 outbyte(3, minor);
203 } else {
204 data = data >> 1;
205 outbyte(2, minor);
206 START(max);
207 do {
208 WAIT(max);
209 } while (!(inbyte(minor) & 0x10));
210 outbyte(3, minor);
211 }
213 udelay(delay);
214 if (need_resched())
215 schedule();
216 }
218 return (int) data;
219 }
221 /* Try to detect a parallel link cable on the specified port */
222 static int
223 probe_ti_parallel(int minor)
224 {
225 int i;
226 int seq[] = { 0x00, 0x20, 0x10, 0x30 };
228 for (i = 3; i >= 0; i--) {
229 outbyte(3, minor);
230 outbyte(i, minor);
231 udelay(delay);
232 pr_debug("tipar: Probing -> %i: 0x%02x 0x%02x\n", i,
233 data & 0x30, seq[i]);
234 if ((inbyte(minor) & 0x30) != seq[i]) {
235 outbyte(3, minor);
236 return -1;
237 }
238 }
240 outbyte(3, minor);
241 return 0;
242 }
244 /* ----- kernel module functions--------------------------------------- */
246 static int
247 tipar_open(struct inode *inode, struct file *file)
248 {
249 unsigned int minor = iminor(inode) - TIPAR_MINOR;
251 if (tp_count == 0 || minor > tp_count - 1)
252 return -ENXIO;
254 if (test_and_set_bit(minor, &opened))
255 return -EBUSY;
257 if (!table[minor].dev) {
258 printk(KERN_ERR "%s: NULL device for minor %u\n",
259 __FUNCTION__, minor);
260 return -ENXIO;
261 }
262 parport_claim_or_block(table[minor].dev);
263 init_ti_parallel(minor);
264 parport_release(table[minor].dev);
266 return nonseekable_open(inode, file);
267 }
269 static int
270 tipar_close(struct inode *inode, struct file *file)
271 {
272 unsigned int minor = iminor(inode) - TIPAR_MINOR;
274 if (minor > tp_count - 1)
275 return -ENXIO;
277 clear_bit(minor, &opened);
279 return 0;
280 }
282 static ssize_t
283 tipar_write (struct file *file, const char __user *buf, size_t count,
284 loff_t * ppos)
285 {
286 unsigned int minor = iminor(file->f_dentry->d_inode) - TIPAR_MINOR;
287 ssize_t n;
289 parport_claim_or_block(table[minor].dev);
291 for (n = 0; n < count; n++) {
292 unsigned char b;
294 if (get_user(b, buf + n)) {
295 n = -EFAULT;
296 goto out;
297 }
299 if (put_ti_parallel(minor, b) == -1) {
300 init_ti_parallel(minor);
301 n = -ETIMEDOUT;
302 goto out;
303 }
304 }
305 out:
306 parport_release(table[minor].dev);
307 return n;
308 }
310 static ssize_t
311 tipar_read(struct file *file, char __user *buf, size_t count, loff_t * ppos)
312 {
313 int b = 0;
314 unsigned int minor = iminor(file->f_dentry->d_inode) - TIPAR_MINOR;
315 ssize_t retval = 0;
316 ssize_t n = 0;
318 if (count == 0)
319 return 0;
321 parport_claim_or_block(table[minor].dev);
323 while (n < count) {
324 b = get_ti_parallel(minor);
325 if (b == -1) {
326 init_ti_parallel(minor);
327 retval = -ETIMEDOUT;
328 goto out;
329 } else {
330 if (put_user(b, buf + n)) {
331 retval = -EFAULT;
332 break;
333 } else
334 retval = ++n;
335 }
337 /* Non-blocking mode : try again ! */
338 if (file->f_flags & O_NONBLOCK) {
339 retval = -EAGAIN;
340 goto out;
341 }
343 /* Signal pending, try again ! */
344 if (signal_pending(current)) {
345 retval = -ERESTARTSYS;
346 goto out;
347 }
349 if (need_resched())
350 schedule();
351 }
353 out:
354 parport_release(table[minor].dev);
355 return retval;
356 }
358 static int
359 tipar_ioctl(struct inode *inode, struct file *file,
360 unsigned int cmd, unsigned long arg)
361 {
362 int retval = 0;
364 switch (cmd) {
365 case IOCTL_TIPAR_DELAY:
366 delay = (int)arg; //get_user(delay, &arg);
367 break;
368 case IOCTL_TIPAR_TIMEOUT:
369 if (arg != 0)
370 timeout = (int)arg;
371 else
372 retval = -EINVAL;
373 break;
374 default:
375 retval = -ENOTTY;
376 break;
377 }
379 return retval;
380 }
382 /* ----- kernel module registering ------------------------------------ */
384 static const struct file_operations tipar_fops = {
385 .owner = THIS_MODULE,
386 .llseek = no_llseek,
387 .read = tipar_read,
388 .write = tipar_write,
389 .ioctl = tipar_ioctl,
390 .open = tipar_open,
391 .release = tipar_close,
392 };
394 /* --- initialisation code ------------------------------------- */
396 #ifndef MODULE
397 /* You must set these - there is no sane way to probe for this cable.
398 * You can use 'tipar=timeout,delay' to set these now. */
399 static int __init
400 tipar_setup(char *str)
401 {
402 int ints[3];
404 str = get_options(str, ARRAY_SIZE(ints), ints);
406 if (ints[0] > 0) {
407 if (ints[1] != 0)
408 timeout = ints[1];
409 else
410 printk(KERN_WARNING "tipar: bad timeout value (0), "
411 "using default value instead");
412 if (ints[0] > 1) {
413 delay = ints[2];
414 }
415 }
417 return 1;
418 }
419 #endif
421 /*
422 * Register our module into parport.
423 * Pass also 2 callbacks functions to parport: a pre-emptive function and an
424 * interrupt handler function (unused).
425 * Display a message such "tipar0: using parport0 (polling)".
426 */
427 static int
428 tipar_register(int nr, struct parport *port)
429 {
430 int err = 0;
432 /* Register our module into parport */
433 table[nr].dev = parport_register_device(port, "tipar",
434 NULL, NULL, NULL, 0,
435 (void *) &table[nr]);
437 if (table[nr].dev == NULL) {
438 err = 1;
439 goto out;
440 }
442 class_device_create(tipar_class, NULL, MKDEV(TIPAR_MAJOR,
443 TIPAR_MINOR + nr), NULL, "par%d", nr);
445 /* Display informations */
446 pr_info("tipar%d: using %s (%s)\n", nr, port->name, (port->irq ==
447 PARPORT_IRQ_NONE) ? "polling" : "interrupt-driven");
449 if (probe_ti_parallel(nr) != -1)
450 pr_info("tipar%d: link cable found\n", nr);
451 else
452 pr_info("tipar%d: link cable not found\n", nr);
454 err = 0;
456 out:
457 return err;
458 }
460 static void
461 tipar_attach(struct parport *port)
462 {
463 if (tp_count == PP_NO) {
464 pr_info("tipar: ignoring parallel port (max. %d)\n", PP_NO);
465 return;
466 }
468 if (!tipar_register(tp_count, port))
469 tp_count++;
470 }
472 static void
473 tipar_detach(struct parport *port)
474 {
475 /* Nothing to do */
476 }
478 static struct parport_driver tipar_driver = {
479 .name = "tipar",
480 .attach = tipar_attach,
481 .detach = tipar_detach,
482 };
484 static int __init
485 tipar_init_module(void)
486 {
487 int err = 0;
489 pr_info("tipar: parallel link cable driver, version %s\n",
490 DRIVER_VERSION);
492 if (register_chrdev(TIPAR_MAJOR, "tipar", &tipar_fops)) {
493 printk(KERN_ERR "tipar: unable to get major %d\n", TIPAR_MAJOR);
494 err = -EIO;
495 goto out;
496 }
498 tipar_class = class_create(THIS_MODULE, "ticables");
499 if (IS_ERR(tipar_class)) {
500 err = PTR_ERR(tipar_class);
501 goto out_chrdev;
502 }
503 if (parport_register_driver(&tipar_driver)) {
504 printk(KERN_ERR "tipar: unable to register with parport\n");
505 err = -EIO;
506 goto out_class;
507 }
509 err = 0;
510 goto out;
512 out_class:
513 class_destroy(tipar_class);
515 out_chrdev:
516 unregister_chrdev(TIPAR_MAJOR, "tipar");
517 out:
518 return err;
519 }
521 static void __exit
522 tipar_cleanup_module(void)
523 {
524 unsigned int i;
526 /* Unregistering module */
527 parport_unregister_driver(&tipar_driver);
529 unregister_chrdev(TIPAR_MAJOR, "tipar");
531 for (i = 0; i < PP_NO; i++) {
532 if (table[i].dev == NULL)
533 continue;
534 parport_unregister_device(table[i].dev);
535 class_device_destroy(tipar_class, MKDEV(TIPAR_MAJOR, i));
536 }
537 class_destroy(tipar_class);
539 pr_info("tipar: module unloaded\n");
540 }
542 /* --------------------------------------------------------------------- */
544 __setup("tipar=", tipar_setup);
545 module_init(tipar_init_module);
546 module_exit(tipar_cleanup_module);
548 MODULE_AUTHOR(DRIVER_AUTHOR);
549 MODULE_DESCRIPTION(DRIVER_DESC);
550 MODULE_LICENSE(DRIVER_LICENSE);
552 module_param(timeout, int, 0);
553 MODULE_PARM_DESC(timeout, "Timeout (default=1.5 seconds)");
554 module_param(delay, int, 0);
555 MODULE_PARM_DESC(delay, "Inter-bit delay (default=10 microseconds)");