Commit | Line | Data |
---|---|---|
1da177e4 LT |
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() */ | |
1da177e4 LT |
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> | |
1da177e4 LT |
58 | #include <linux/parport.h> /* Our code depend on parport */ |
59 | #include <linux/device.h> | |
60 | ||
61 | /* | |
62 | * TI definitions | |
63 | */ | |
64 | #include <linux/ticable.h> | |
65 | ||
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" | |
73 | ||
74 | #define VERSION(ver,rel,seq) (((ver)<<16) | ((rel)<<8) | (seq)) | |
75 | ||
76 | /* ----- global variables --------------------------------------------- */ | |
77 | ||
78 | struct tipar_struct { | |
79 | struct pardevice *dev; /* Parport device entry */ | |
80 | }; | |
81 | ||
82 | #define PP_NO 3 | |
83 | static struct tipar_struct table[PP_NO]; | |
84 | ||
85 | static int delay = IO_DELAY; /* inter-bit delay in microseconds */ | |
86 | static int timeout = TIMAXTIME; /* timeout in tenth of seconds */ | |
87 | ||
88 | static unsigned int tp_count; /* tipar count */ | |
89 | static unsigned long opened; /* opened devices */ | |
90 | ||
ca8eca68 | 91 | static struct class *tipar_class; |
1da177e4 LT |
92 | |
93 | /* --- macros for parport access -------------------------------------- */ | |
94 | ||
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))) | |
99 | ||
100 | /* --- setting states on the D-bus with the right timing: ------------- */ | |
101 | ||
102 | static inline void | |
103 | outbyte(int value, int minor) | |
104 | { | |
105 | w_dtr(minor, value); | |
106 | } | |
107 | ||
108 | static inline int | |
109 | inbyte(int minor) | |
110 | { | |
111 | return (r_str(minor)); | |
112 | } | |
113 | ||
114 | static inline void | |
115 | init_ti_parallel(int minor) | |
116 | { | |
117 | outbyte(3, minor); | |
118 | } | |
119 | ||
120 | /* ----- global defines ----------------------------------------------- */ | |
121 | ||
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(); } | |
126 | ||
127 | /* ----- D-bus bit-banging functions ---------------------------------- */ | |
128 | ||
129 | /* D-bus protocol (45kbit/s max): | |
130 | 1 0 0 | |
131 | _______ ______|______ __________|________ __________ | |
132 | Red : ________ | ____ | ____ | |
133 | _ ____________|________ ______|__________ _____ | |
134 | White: ________ | ______ | _______ | |
135 | */ | |
136 | ||
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; | |
143 | ||
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); | |
151 | ||
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); | |
163 | ||
164 | outbyte(3, minor); | |
165 | START(max); | |
166 | do { | |
167 | WAIT(max); | |
168 | } while (!(inbyte(minor) & 0x20)); | |
169 | } | |
170 | ||
171 | data >>= 1; | |
172 | udelay(delay); | |
173 | ||
174 | if (need_resched()) | |
175 | schedule(); | |
176 | } | |
177 | ||
178 | return 0; | |
179 | } | |
180 | ||
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; | |
188 | ||
189 | for (bit = 0; bit < 8; bit++) { | |
190 | START(max); | |
191 | do { | |
192 | WAIT(max); | |
193 | } while ((v = inbyte(minor) & 0x30) == 0x30); | |
194 | ||
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 | } | |
212 | ||
213 | udelay(delay); | |
214 | if (need_resched()) | |
215 | schedule(); | |
216 | } | |
217 | ||
218 | return (int) data; | |
219 | } | |
220 | ||
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 }; | |
5df0a29d | 227 | int data; |
1da177e4 LT |
228 | |
229 | for (i = 3; i >= 0; i--) { | |
230 | outbyte(3, minor); | |
231 | outbyte(i, minor); | |
232 | udelay(delay); | |
5df0a29d | 233 | data = inbyte(minor) & 0x30; |
1da177e4 | 234 | pr_debug("tipar: Probing -> %i: 0x%02x 0x%02x\n", i, |
5df0a29d ZB |
235 | data, seq[i]); |
236 | if (data != seq[i]) { | |
1da177e4 LT |
237 | outbyte(3, minor); |
238 | return -1; | |
239 | } | |
240 | } | |
241 | ||
242 | outbyte(3, minor); | |
243 | return 0; | |
244 | } | |
245 | ||
246 | /* ----- kernel module functions--------------------------------------- */ | |
247 | ||
248 | static int | |
249 | tipar_open(struct inode *inode, struct file *file) | |
250 | { | |
251 | unsigned int minor = iminor(inode) - TIPAR_MINOR; | |
252 | ||
1d308839 | 253 | if (tp_count == 0 || minor > tp_count - 1) |
1da177e4 LT |
254 | return -ENXIO; |
255 | ||
256 | if (test_and_set_bit(minor, &opened)) | |
257 | return -EBUSY; | |
258 | ||
1d308839 AM |
259 | if (!table[minor].dev) { |
260 | printk(KERN_ERR "%s: NULL device for minor %u\n", | |
261 | __FUNCTION__, minor); | |
262 | return -ENXIO; | |
263 | } | |
1da177e4 LT |
264 | parport_claim_or_block(table[minor].dev); |
265 | init_ti_parallel(minor); | |
266 | parport_release(table[minor].dev); | |
267 | ||
268 | return nonseekable_open(inode, file); | |
269 | } | |
270 | ||
271 | static int | |
272 | tipar_close(struct inode *inode, struct file *file) | |
273 | { | |
274 | unsigned int minor = iminor(inode) - TIPAR_MINOR; | |
275 | ||
276 | if (minor > tp_count - 1) | |
277 | return -ENXIO; | |
278 | ||
279 | clear_bit(minor, &opened); | |
280 | ||
281 | return 0; | |
282 | } | |
283 | ||
284 | static ssize_t | |
285 | tipar_write (struct file *file, const char __user *buf, size_t count, | |
286 | loff_t * ppos) | |
287 | { | |
a7113a96 | 288 | unsigned int minor = iminor(file->f_path.dentry->d_inode) - TIPAR_MINOR; |
1da177e4 LT |
289 | ssize_t n; |
290 | ||
291 | parport_claim_or_block(table[minor].dev); | |
292 | ||
293 | for (n = 0; n < count; n++) { | |
294 | unsigned char b; | |
295 | ||
296 | if (get_user(b, buf + n)) { | |
297 | n = -EFAULT; | |
298 | goto out; | |
299 | } | |
300 | ||
301 | if (put_ti_parallel(minor, b) == -1) { | |
302 | init_ti_parallel(minor); | |
303 | n = -ETIMEDOUT; | |
304 | goto out; | |
305 | } | |
306 | } | |
307 | out: | |
308 | parport_release(table[minor].dev); | |
309 | return n; | |
310 | } | |
311 | ||
312 | static ssize_t | |
313 | tipar_read(struct file *file, char __user *buf, size_t count, loff_t * ppos) | |
314 | { | |
315 | int b = 0; | |
a7113a96 | 316 | unsigned int minor = iminor(file->f_path.dentry->d_inode) - TIPAR_MINOR; |
1da177e4 LT |
317 | ssize_t retval = 0; |
318 | ssize_t n = 0; | |
319 | ||
320 | if (count == 0) | |
321 | return 0; | |
322 | ||
323 | parport_claim_or_block(table[minor].dev); | |
324 | ||
325 | while (n < count) { | |
326 | b = get_ti_parallel(minor); | |
327 | if (b == -1) { | |
328 | init_ti_parallel(minor); | |
329 | retval = -ETIMEDOUT; | |
330 | goto out; | |
331 | } else { | |
332 | if (put_user(b, buf + n)) { | |
333 | retval = -EFAULT; | |
334 | break; | |
335 | } else | |
336 | retval = ++n; | |
337 | } | |
338 | ||
339 | /* Non-blocking mode : try again ! */ | |
340 | if (file->f_flags & O_NONBLOCK) { | |
341 | retval = -EAGAIN; | |
342 | goto out; | |
343 | } | |
344 | ||
345 | /* Signal pending, try again ! */ | |
346 | if (signal_pending(current)) { | |
347 | retval = -ERESTARTSYS; | |
348 | goto out; | |
349 | } | |
350 | ||
351 | if (need_resched()) | |
352 | schedule(); | |
353 | } | |
354 | ||
355 | out: | |
356 | parport_release(table[minor].dev); | |
357 | return retval; | |
358 | } | |
359 | ||
360 | static int | |
361 | tipar_ioctl(struct inode *inode, struct file *file, | |
362 | unsigned int cmd, unsigned long arg) | |
363 | { | |
364 | int retval = 0; | |
365 | ||
366 | switch (cmd) { | |
367 | case IOCTL_TIPAR_DELAY: | |
368 | delay = (int)arg; //get_user(delay, &arg); | |
369 | break; | |
370 | case IOCTL_TIPAR_TIMEOUT: | |
371 | if (arg != 0) | |
372 | timeout = (int)arg; | |
373 | else | |
374 | retval = -EINVAL; | |
375 | break; | |
376 | default: | |
377 | retval = -ENOTTY; | |
378 | break; | |
379 | } | |
380 | ||
381 | return retval; | |
382 | } | |
383 | ||
384 | /* ----- kernel module registering ------------------------------------ */ | |
385 | ||
62322d25 | 386 | static const struct file_operations tipar_fops = { |
1da177e4 LT |
387 | .owner = THIS_MODULE, |
388 | .llseek = no_llseek, | |
389 | .read = tipar_read, | |
390 | .write = tipar_write, | |
391 | .ioctl = tipar_ioctl, | |
392 | .open = tipar_open, | |
393 | .release = tipar_close, | |
394 | }; | |
395 | ||
396 | /* --- initialisation code ------------------------------------- */ | |
397 | ||
398 | #ifndef MODULE | |
399 | /* You must set these - there is no sane way to probe for this cable. | |
400 | * You can use 'tipar=timeout,delay' to set these now. */ | |
401 | static int __init | |
402 | tipar_setup(char *str) | |
403 | { | |
45ae36cb | 404 | int ints[3]; |
1da177e4 LT |
405 | |
406 | str = get_options(str, ARRAY_SIZE(ints), ints); | |
407 | ||
408 | if (ints[0] > 0) { | |
409 | if (ints[1] != 0) | |
410 | timeout = ints[1]; | |
411 | else | |
412 | printk(KERN_WARNING "tipar: bad timeout value (0), " | |
413 | "using default value instead"); | |
414 | if (ints[0] > 1) { | |
415 | delay = ints[2]; | |
416 | } | |
417 | } | |
418 | ||
419 | return 1; | |
420 | } | |
421 | #endif | |
422 | ||
423 | /* | |
424 | * Register our module into parport. | |
425 | * Pass also 2 callbacks functions to parport: a pre-emptive function and an | |
426 | * interrupt handler function (unused). | |
427 | * Display a message such "tipar0: using parport0 (polling)". | |
428 | */ | |
429 | static int | |
430 | tipar_register(int nr, struct parport *port) | |
431 | { | |
432 | int err = 0; | |
433 | ||
434 | /* Register our module into parport */ | |
435 | table[nr].dev = parport_register_device(port, "tipar", | |
436 | NULL, NULL, NULL, 0, | |
437 | (void *) &table[nr]); | |
438 | ||
439 | if (table[nr].dev == NULL) { | |
440 | err = 1; | |
441 | goto out; | |
442 | } | |
443 | ||
53f46542 | 444 | class_device_create(tipar_class, NULL, MKDEV(TIPAR_MAJOR, |
1da177e4 | 445 | TIPAR_MINOR + nr), NULL, "par%d", nr); |
1da177e4 LT |
446 | |
447 | /* Display informations */ | |
448 | pr_info("tipar%d: using %s (%s)\n", nr, port->name, (port->irq == | |
449 | PARPORT_IRQ_NONE) ? "polling" : "interrupt-driven"); | |
450 | ||
451 | if (probe_ti_parallel(nr) != -1) | |
452 | pr_info("tipar%d: link cable found\n", nr); | |
453 | else | |
454 | pr_info("tipar%d: link cable not found\n", nr); | |
455 | ||
456 | err = 0; | |
1da177e4 | 457 | |
1da177e4 LT |
458 | out: |
459 | return err; | |
460 | } | |
461 | ||
462 | static void | |
463 | tipar_attach(struct parport *port) | |
464 | { | |
465 | if (tp_count == PP_NO) { | |
466 | pr_info("tipar: ignoring parallel port (max. %d)\n", PP_NO); | |
467 | return; | |
468 | } | |
469 | ||
470 | if (!tipar_register(tp_count, port)) | |
471 | tp_count++; | |
472 | } | |
473 | ||
474 | static void | |
475 | tipar_detach(struct parport *port) | |
476 | { | |
477 | /* Nothing to do */ | |
478 | } | |
479 | ||
480 | static struct parport_driver tipar_driver = { | |
481 | .name = "tipar", | |
482 | .attach = tipar_attach, | |
483 | .detach = tipar_detach, | |
484 | }; | |
485 | ||
486 | static int __init | |
487 | tipar_init_module(void) | |
488 | { | |
489 | int err = 0; | |
490 | ||
491 | pr_info("tipar: parallel link cable driver, version %s\n", | |
492 | DRIVER_VERSION); | |
493 | ||
494 | if (register_chrdev(TIPAR_MAJOR, "tipar", &tipar_fops)) { | |
495 | printk(KERN_ERR "tipar: unable to get major %d\n", TIPAR_MAJOR); | |
496 | err = -EIO; | |
497 | goto out; | |
498 | } | |
499 | ||
ca8eca68 | 500 | tipar_class = class_create(THIS_MODULE, "ticables"); |
1da177e4 LT |
501 | if (IS_ERR(tipar_class)) { |
502 | err = PTR_ERR(tipar_class); | |
503 | goto out_chrdev; | |
504 | } | |
1ac3836c | 505 | if (parport_register_driver(&tipar_driver)) { |
1da177e4 LT |
506 | printk(KERN_ERR "tipar: unable to register with parport\n"); |
507 | err = -EIO; | |
1d308839 | 508 | goto out_class; |
1da177e4 LT |
509 | } |
510 | ||
511 | err = 0; | |
512 | goto out; | |
513 | ||
1d308839 AM |
514 | out_class: |
515 | class_destroy(tipar_class); | |
516 | ||
1da177e4 LT |
517 | out_chrdev: |
518 | unregister_chrdev(TIPAR_MAJOR, "tipar"); | |
519 | out: | |
520 | return err; | |
521 | } | |
522 | ||
523 | static void __exit | |
524 | tipar_cleanup_module(void) | |
525 | { | |
526 | unsigned int i; | |
527 | ||
528 | /* Unregistering module */ | |
529 | parport_unregister_driver(&tipar_driver); | |
530 | ||
531 | unregister_chrdev(TIPAR_MAJOR, "tipar"); | |
532 | ||
533 | for (i = 0; i < PP_NO; i++) { | |
534 | if (table[i].dev == NULL) | |
535 | continue; | |
536 | parport_unregister_device(table[i].dev); | |
ca8eca68 | 537 | class_device_destroy(tipar_class, MKDEV(TIPAR_MAJOR, i)); |
1da177e4 | 538 | } |
ca8eca68 | 539 | class_destroy(tipar_class); |
1da177e4 LT |
540 | |
541 | pr_info("tipar: module unloaded\n"); | |
542 | } | |
543 | ||
544 | /* --------------------------------------------------------------------- */ | |
545 | ||
546 | __setup("tipar=", tipar_setup); | |
547 | module_init(tipar_init_module); | |
548 | module_exit(tipar_cleanup_module); | |
549 | ||
550 | MODULE_AUTHOR(DRIVER_AUTHOR); | |
551 | MODULE_DESCRIPTION(DRIVER_DESC); | |
552 | MODULE_LICENSE(DRIVER_LICENSE); | |
553 | ||
554 | module_param(timeout, int, 0); | |
555 | MODULE_PARM_DESC(timeout, "Timeout (default=1.5 seconds)"); | |
556 | module_param(delay, int, 0); | |
557 | MODULE_PARM_DESC(delay, "Inter-bit delay (default=10 microseconds)"); |