1 /*
2 * IEEE-1284 implementation for parport.
3 *
4 * Authors: Phil Blundell <philb@gnu.org>
5 * Carsten Gross <carsten@sol.wohnheim.uni-ulm.de>
6 * Jose Renau <renau@acm.org>
7 * Tim Waugh <tim@cyberelk.demon.co.uk> (largely rewritten)
8 *
9 * This file is responsible for IEEE 1284 negotiation, and for handing
10 * read/write requests to low-level drivers.
11 *
12 * Any part of this program may be used in documents licensed under
13 * the GNU Free Documentation License, Version 1.1 or any later version
14 * published by the Free Software Foundation.
15 *
16 * Various hacks, Fred Barnes <frmb2@ukc.ac.uk>, 04/2000
17 */
18
19 #include <linux/module.h>
20 #include <linux/threads.h>
21 #include <linux/parport.h>
22 #include <linux/delay.h>
23 #include <linux/kernel.h>
24 #include <linux/interrupt.h>
25 #include <linux/timer.h>
26 #include <linux/sched/signal.h>
27
28 #undef DEBUG /* undef me for production */
29
30 #ifdef CONFIG_LP_CONSOLE
31 #undef DEBUG /* Don't want a garbled console */
32 #endif
33
34 #ifdef DEBUG
35 #define DPRINTK(stuff...) printk (stuff)
36 #else
37 #define DPRINTK(stuff...)
38 #endif
39
40 /* Make parport_wait_peripheral wake up.
41 * It will be useful to call this from an interrupt handler. */
42 static void parport_ieee1284_wakeup (struct parport *port)
43 {
44 up (&port->physport->ieee1284.irq);
45 }
46
47 static void timeout_waiting_on_port (struct timer_list *t)
48 {
49 struct parport *port = from_timer(port, t, timer);
50
51 parport_ieee1284_wakeup (port);
52 }
53
54 /**
55 * parport_wait_event - wait for an event on a parallel port
56 * @port: port to wait on
57 * @timeout: time to wait (in jiffies)
58 *
59 * This function waits for up to @timeout jiffies for an
60 * interrupt to occur on a parallel port. If the port timeout is
61 * set to zero, it returns immediately.
62 *
63 * If an interrupt occurs before the timeout period elapses, this
64 * function returns zero immediately. If it times out, it returns
65 * one. An error code less than zero indicates an error (most
66 * likely a pending signal), and the calling code should finish
67 * what it's doing as soon as it can.
68 */
69
70 int parport_wait_event (struct parport *port, signed long timeout)
71 {
72 int ret;
73
74 if (!port->physport->cad->timeout)
75 /* Zero timeout is special, and we can't down() the
76 semaphore. */
77 return 1;
78
79 timer_setup(&port->timer, timeout_waiting_on_port, 0);
80 mod_timer(&port->timer, jiffies + timeout);
81 ret = down_interruptible (&port->physport->ieee1284.irq);
82 if (!del_timer_sync(&port->timer) && !ret)
83 /* Timed out. */
84 ret = 1;
85
86 return ret;
87 }
88
89 /**
90 * parport_poll_peripheral - poll status lines
91 * @port: port to watch
92 * @mask: status lines to watch
93 * @result: desired values of chosen status lines
94 * @usec: timeout
95 *
96 * This function busy-waits until the masked status lines have
97 * the desired values, or until the timeout period elapses. The
98 * @mask and @result parameters are bitmasks, with the bits
99 * defined by the constants in parport.h: %PARPORT_STATUS_BUSY,
100 * and so on.
101 *
102 * This function does not call schedule(); instead it busy-waits
103 * using udelay(). It currently has a resolution of 5usec.
104 *
105 * If the status lines take on the desired values before the
106 * timeout period elapses, parport_poll_peripheral() returns zero
107 * immediately. A return value greater than zero indicates
108 * a timeout. An error code (less than zero) indicates an error,
109 * most likely a signal that arrived, and the caller should
110 * finish what it is doing as soon as possible.
111 */
112
113 int parport_poll_peripheral(struct parport *port,
114 unsigned char mask,
115 unsigned char result,
116 int usec)
117 {
118 /* Zero return code is success, >0 is timeout. */
119 int count = usec / 5 + 2;
120 int i;
121 unsigned char status;
122 for (i = 0; i < count; i++) {
123 status = parport_read_status (port);
124 if ((status & mask) == result)
125 return 0;
126 if (signal_pending (current))
127 return -EINTR;
128 if (need_resched())
129 break;
130 if (i >= 2)
131 udelay (5);
132 }
133
134 return 1;
135 }
136
137 /**
138 * parport_wait_peripheral - wait for status lines to change in 35ms
139 * @port: port to watch
140 * @mask: status lines to watch
141 * @result: desired values of chosen status lines
142 *
143 * This function waits until the masked status lines have the
144 * desired values, or until 35ms have elapsed (see IEEE 1284-1994
145 * page 24 to 25 for why this value in particular is hardcoded).
146 * The @mask and @result parameters are bitmasks, with the bits
147 * defined by the constants in parport.h: %PARPORT_STATUS_BUSY,
148 * and so on.
149 *
150 * The port is polled quickly to start off with, in anticipation
151 * of a fast response from the peripheral. This fast polling
152 * time is configurable (using /proc), and defaults to 500usec.
153 * If the timeout for this port (see parport_set_timeout()) is
154 * zero, the fast polling time is 35ms, and this function does
155 * not call schedule().
156 *
157 * If the timeout for this port is non-zero, after the fast
158 * polling fails it uses parport_wait_event() to wait for up to
159 * 10ms, waking up if an interrupt occurs.
160 */
161
162 int parport_wait_peripheral(struct parport *port,
163 unsigned char mask,
164 unsigned char result)
165 {
166 int ret;
167 int usec;
168 unsigned long deadline;
169 unsigned char status;
170
171 usec = port->physport->spintime; /* usecs of fast polling */
172 if (!port->physport->cad->timeout)
173 /* A zero timeout is "special": busy wait for the
174 entire 35ms. */
175 usec = 35000;
176
177 /* Fast polling.
178 *
179 * This should be adjustable.
180 * How about making a note (in the device structure) of how long
181 * it takes, so we know for next time?
182 */
183 ret = parport_poll_peripheral (port, mask, result, usec);
184 if (ret != 1)
185 return ret;
186
187 if (!port->physport->cad->timeout)
188 /* We may be in an interrupt handler, so we can't poll
189 * slowly anyway. */
190 return 1;
191
192 /* 40ms of slow polling. */
193 deadline = jiffies + msecs_to_jiffies(40);
194 while (time_before (jiffies, deadline)) {
195 if (signal_pending (current))
196 return -EINTR;
197
198 /* Wait for 10ms (or until an interrupt occurs if
199 * the handler is set) */
200 if ((ret = parport_wait_event (port, msecs_to_jiffies(10))) < 0)
201 return ret;
202
203 status = parport_read_status (port);
204 if ((status & mask) == result)
205 return 0;
206
207 if (!ret) {
208 /* parport_wait_event didn't time out, but the
209 * peripheral wasn't actually ready either.
210 * Wait for another 10ms. */
211 schedule_timeout_interruptible(msecs_to_jiffies(10));
212 }
213 }
214
215 return 1;
216 }
217
218 #ifdef CONFIG_PARPORT_1284
219 /* Terminate a negotiated mode. */
220 static void parport_ieee1284_terminate (struct parport *port)
221 {
222 int r;
223 port = port->physport;
224
225 /* EPP terminates differently. */
226 switch (port->ieee1284.mode) {
227 case IEEE1284_MODE_EPP:
228 case IEEE1284_MODE_EPPSL:
229 case IEEE1284_MODE_EPPSWE:
230 /* Terminate from EPP mode. */
231
232 /* Event 68: Set nInit low */
233 parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
234 udelay (50);
235
236 /* Event 69: Set nInit high, nSelectIn low */
237 parport_frob_control (port,
238 PARPORT_CONTROL_SELECT
239 | PARPORT_CONTROL_INIT,
240 PARPORT_CONTROL_SELECT
241 | PARPORT_CONTROL_INIT);
242 break;
243
244 case IEEE1284_MODE_ECP:
245 case IEEE1284_MODE_ECPRLE:
246 case IEEE1284_MODE_ECPSWE:
247 /* In ECP we can only terminate from fwd idle phase. */
248 if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE) {
249 /* Event 47: Set nInit high */
250 parport_frob_control (port,
251 PARPORT_CONTROL_INIT
252 | PARPORT_CONTROL_AUTOFD,
253 PARPORT_CONTROL_INIT
254 | PARPORT_CONTROL_AUTOFD);
255
256 /* Event 49: PError goes high */
257 r = parport_wait_peripheral (port,
258 PARPORT_STATUS_PAPEROUT,
259 PARPORT_STATUS_PAPEROUT);
260 if (r)
261 DPRINTK (KERN_INFO "%s: Timeout at event 49\n",
262 port->name);
263
264 parport_data_forward (port);
265 DPRINTK (KERN_DEBUG "%s: ECP direction: forward\n",
266 port->name);
267 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
268 }
269
270 /* fall through */
271
272 default:
273 /* Terminate from all other modes. */
274
275 /* Event 22: Set nSelectIn low, nAutoFd high */
276 parport_frob_control (port,
277 PARPORT_CONTROL_SELECT
278 | PARPORT_CONTROL_AUTOFD,
279 PARPORT_CONTROL_SELECT);
280
281 /* Event 24: nAck goes low */
282 r = parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0);
283 if (r)
284 DPRINTK (KERN_INFO "%s: Timeout at event 24\n",
285 port->name);
286
287 /* Event 25: Set nAutoFd low */
288 parport_frob_control (port,
289 PARPORT_CONTROL_AUTOFD,
290 PARPORT_CONTROL_AUTOFD);
291
292 /* Event 27: nAck goes high */
293 r = parport_wait_peripheral (port,
294 PARPORT_STATUS_ACK,
295 PARPORT_STATUS_ACK);
296 if (r)
297 DPRINTK (KERN_INFO "%s: Timeout at event 27\n",
298 port->name);
299
300 /* Event 29: Set nAutoFd high */
301 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
302 }
303
304 port->ieee1284.mode = IEEE1284_MODE_COMPAT;
305 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
306
307 DPRINTK (KERN_DEBUG "%s: In compatibility (forward idle) mode\n",
308 port->name);
309 }
310 #endif /* IEEE1284 support */
311
312 /**
313 * parport_negotiate - negotiate an IEEE 1284 mode
314 * @port: port to use
315 * @mode: mode to negotiate to
316 *
317 * Use this to negotiate to a particular IEEE 1284 transfer mode.
318 * The @mode parameter should be one of the constants in
319 * parport.h starting %IEEE1284_MODE_xxx.
320 *
321 * The return value is 0 if the peripheral has accepted the
322 * negotiation to the mode specified, -1 if the peripheral is not
323 * IEEE 1284 compliant (or not present), or 1 if the peripheral
324 * has rejected the negotiation.
325 */
326
327 int parport_negotiate (struct parport *port, int mode)
328 {
329 #ifndef CONFIG_PARPORT_1284
330 if (mode == IEEE1284_MODE_COMPAT)
331 return 0;
332 printk (KERN_ERR "parport: IEEE1284 not supported in this kernel\n");
333 return -1;
334 #else
335 int m = mode & ~IEEE1284_ADDR;
336 int r;
337 unsigned char xflag;
338
339 port = port->physport;
340
341 /* Is there anything to do? */
342 if (port->ieee1284.mode == mode)
343 return 0;
344
345 /* Is the difference just an address-or-not bit? */
346 if ((port->ieee1284.mode & ~IEEE1284_ADDR) == (mode & ~IEEE1284_ADDR)){
347 port->ieee1284.mode = mode;
348 return 0;
349 }
350
351 /* Go to compatibility forward idle mode */
352 if (port->ieee1284.mode != IEEE1284_MODE_COMPAT)
353 parport_ieee1284_terminate (port);
354
355 if (mode == IEEE1284_MODE_COMPAT)
356 /* Compatibility mode: no negotiation. */
357 return 0;
358
359 switch (mode) {
360 case IEEE1284_MODE_ECPSWE:
361 m = IEEE1284_MODE_ECP;
362 break;
363 case IEEE1284_MODE_EPPSL:
364 case IEEE1284_MODE_EPPSWE:
365 m = IEEE1284_MODE_EPP;
366 break;
367 case IEEE1284_MODE_BECP:
368 return -ENOSYS; /* FIXME (implement BECP) */
369 }
370
371 if (mode & IEEE1284_EXT_LINK)
372 m = 1<<7; /* request extensibility link */
373
374 port->ieee1284.phase = IEEE1284_PH_NEGOTIATION;
375
376 /* Start off with nStrobe and nAutoFd high, and nSelectIn low */
377 parport_frob_control (port,
378 PARPORT_CONTROL_STROBE
379 | PARPORT_CONTROL_AUTOFD
380 | PARPORT_CONTROL_SELECT,
381 PARPORT_CONTROL_SELECT);
382 udelay(1);
383
384 /* Event 0: Set data */
385 parport_data_forward (port);
386 parport_write_data (port, m);
387 udelay (400); /* Shouldn't need to wait this long. */
388
389 /* Event 1: Set nSelectIn high, nAutoFd low */
390 parport_frob_control (port,
391 PARPORT_CONTROL_SELECT
392 | PARPORT_CONTROL_AUTOFD,
393 PARPORT_CONTROL_AUTOFD);
394
395 /* Event 2: PError, Select, nFault go high, nAck goes low */
396 if (parport_wait_peripheral (port,
397 PARPORT_STATUS_ERROR
398 | PARPORT_STATUS_SELECT
399 | PARPORT_STATUS_PAPEROUT
400 | PARPORT_STATUS_ACK,
401 PARPORT_STATUS_ERROR
402 | PARPORT_STATUS_SELECT
403 | PARPORT_STATUS_PAPEROUT)) {
404 /* Timeout */
405 parport_frob_control (port,
406 PARPORT_CONTROL_SELECT
407 | PARPORT_CONTROL_AUTOFD,
408 PARPORT_CONTROL_SELECT);
409 DPRINTK (KERN_DEBUG
410 "%s: Peripheral not IEEE1284 compliant (0x%02X)\n",
411 port->name, parport_read_status (port));
412 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
413 return -1; /* Not IEEE1284 compliant */
414 }
415
416 /* Event 3: Set nStrobe low */
417 parport_frob_control (port,
418 PARPORT_CONTROL_STROBE,
419 PARPORT_CONTROL_STROBE);
420
421 /* Event 4: Set nStrobe and nAutoFd high */
422 udelay (5);
423 parport_frob_control (port,
424 PARPORT_CONTROL_STROBE
425 | PARPORT_CONTROL_AUTOFD,
426 0);
427
428 /* Event 6: nAck goes high */
429 if (parport_wait_peripheral (port,
430 PARPORT_STATUS_ACK,
431 PARPORT_STATUS_ACK)) {
432 /* This shouldn't really happen with a compliant device. */
433 DPRINTK (KERN_DEBUG
434 "%s: Mode 0x%02x not supported? (0x%02x)\n",
435 port->name, mode, port->ops->read_status (port));
436 parport_ieee1284_terminate (port);
437 return 1;
438 }
439
440 xflag = parport_read_status (port) & PARPORT_STATUS_SELECT;
441
442 /* xflag should be high for all modes other than nibble (0). */
443 if (mode && !xflag) {
444 /* Mode not supported. */
445 DPRINTK (KERN_DEBUG "%s: Mode 0x%02x rejected by peripheral\n",
446 port->name, mode);
447 parport_ieee1284_terminate (port);
448 return 1;
449 }
450
451 /* More to do if we've requested extensibility link. */
452 if (mode & IEEE1284_EXT_LINK) {
453 m = mode & 0x7f;
454 udelay (1);
455 parport_write_data (port, m);
456 udelay (1);
457
458 /* Event 51: Set nStrobe low */
459 parport_frob_control (port,
460 PARPORT_CONTROL_STROBE,
461 PARPORT_CONTROL_STROBE);
462
463 /* Event 52: nAck goes low */
464 if (parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0)) {
465 /* This peripheral is _very_ slow. */
466 DPRINTK (KERN_DEBUG
467 "%s: Event 52 didn't happen\n",
468 port->name);
469 parport_ieee1284_terminate (port);
470 return 1;
471 }
472
473 /* Event 53: Set nStrobe high */
474 parport_frob_control (port,
475 PARPORT_CONTROL_STROBE,
476 0);
477
478 /* Event 55: nAck goes high */
479 if (parport_wait_peripheral (port,
480 PARPORT_STATUS_ACK,
481 PARPORT_STATUS_ACK)) {
482 /* This shouldn't really happen with a compliant
483 * device. */
484 DPRINTK (KERN_DEBUG
485 "%s: Mode 0x%02x not supported? (0x%02x)\n",
486 port->name, mode,
487 port->ops->read_status (port));
488 parport_ieee1284_terminate (port);
489 return 1;
490 }
491
492 /* Event 54: Peripheral sets XFlag to reflect support */
493 xflag = parport_read_status (port) & PARPORT_STATUS_SELECT;
494
495 /* xflag should be high. */
496 if (!xflag) {
497 /* Extended mode not supported. */
498 DPRINTK (KERN_DEBUG "%s: Extended mode 0x%02x not "
499 "supported\n", port->name, mode);
500 parport_ieee1284_terminate (port);
501 return 1;
502 }
503
504 /* Any further setup is left to the caller. */
505 }
506
507 /* Mode is supported */
508 DPRINTK (KERN_DEBUG "%s: In mode 0x%02x\n", port->name, mode);
509 port->ieee1284.mode = mode;
510
511 /* But ECP is special */
512 if (!(mode & IEEE1284_EXT_LINK) && (m & IEEE1284_MODE_ECP)) {
513 port->ieee1284.phase = IEEE1284_PH_ECP_SETUP;
514
515 /* Event 30: Set nAutoFd low */
516 parport_frob_control (port,
517 PARPORT_CONTROL_AUTOFD,
518 PARPORT_CONTROL_AUTOFD);
519
520 /* Event 31: PError goes high. */
521 r = parport_wait_peripheral (port,
522 PARPORT_STATUS_PAPEROUT,
523 PARPORT_STATUS_PAPEROUT);
524 if (r) {
525 DPRINTK (KERN_INFO "%s: Timeout at event 31\n",
526 port->name);
527 }
528
529 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
530 DPRINTK (KERN_DEBUG "%s: ECP direction: forward\n",
531 port->name);
532 } else switch (mode) {
533 case IEEE1284_MODE_NIBBLE:
534 case IEEE1284_MODE_BYTE:
535 port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
536 break;
537 default:
538 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
539 }
540
541
542 return 0;
543 #endif /* IEEE1284 support */
544 }
545
546 /* Acknowledge that the peripheral has data available.
547 * Events 18-20, in order to get from Reverse Idle phase
548 * to Host Busy Data Available.
549 * This will most likely be called from an interrupt.
550 * Returns zero if data was available.
551 */
552 #ifdef CONFIG_PARPORT_1284
553 static int parport_ieee1284_ack_data_avail (struct parport *port)
554 {
555 if (parport_read_status (port) & PARPORT_STATUS_ERROR)
556 /* Event 18 didn't happen. */
557 return -1;
558
559 /* Event 20: nAutoFd goes high. */
560 port->ops->frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
561 port->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL;
562 return 0;
563 }
564 #endif /* IEEE1284 support */
565
566 /* Handle an interrupt. */
567 void parport_ieee1284_interrupt (void *handle)
568 {
569 struct parport *port = handle;
570 parport_ieee1284_wakeup (port);
571
572 #ifdef CONFIG_PARPORT_1284
573 if (port->ieee1284.phase == IEEE1284_PH_REV_IDLE) {
574 /* An interrupt in this phase means that data
575 * is now available. */
576 DPRINTK (KERN_DEBUG "%s: Data available\n", port->name);
577 parport_ieee1284_ack_data_avail (port);
578 }
579 #endif /* IEEE1284 support */
580 }
581
582 /**
583 * parport_write - write a block of data to a parallel port
584 * @port: port to write to
585 * @buffer: data buffer (in kernel space)
586 * @len: number of bytes of data to transfer
587 *
588 * This will write up to @len bytes of @buffer to the port
589 * specified, using the IEEE 1284 transfer mode most recently
590 * negotiated to (using parport_negotiate()), as long as that
591 * mode supports forward transfers (host to peripheral).
592 *
593 * It is the caller's responsibility to ensure that the first
594 * @len bytes of @buffer are valid.
595 *
596 * This function returns the number of bytes transferred (if zero
597 * or positive), or else an error code.
598 */
599
600 ssize_t parport_write (struct parport *port, const void *buffer, size_t len)
601 {
602 #ifndef CONFIG_PARPORT_1284
603 return port->ops->compat_write_data (port, buffer, len, 0);
604 #else
605 ssize_t retval;
606 int mode = port->ieee1284.mode;
607 int addr = mode & IEEE1284_ADDR;
608 size_t (*fn) (struct parport *, const void *, size_t, int);
609
610 /* Ignore the device-ID-request bit and the address bit. */
611 mode &= ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
612
613 /* Use the mode we're in. */
614 switch (mode) {
615 case IEEE1284_MODE_NIBBLE:
616 case IEEE1284_MODE_BYTE:
617 parport_negotiate (port, IEEE1284_MODE_COMPAT);
618 /* fall through */
619 case IEEE1284_MODE_COMPAT:
620 DPRINTK (KERN_DEBUG "%s: Using compatibility mode\n",
621 port->name);
622 fn = port->ops->compat_write_data;
623 break;
624
625 case IEEE1284_MODE_EPP:
626 DPRINTK (KERN_DEBUG "%s: Using EPP mode\n", port->name);
627 if (addr) {
628 fn = port->ops->epp_write_addr;
629 } else {
630 fn = port->ops->epp_write_data;
631 }
632 break;
633 case IEEE1284_MODE_EPPSWE:
634 DPRINTK (KERN_DEBUG "%s: Using software-emulated EPP mode\n",
635 port->name);
636 if (addr) {
637 fn = parport_ieee1284_epp_write_addr;
638 } else {
639 fn = parport_ieee1284_epp_write_data;
640 }
641 break;
642 case IEEE1284_MODE_ECP:
643 case IEEE1284_MODE_ECPRLE:
644 DPRINTK (KERN_DEBUG "%s: Using ECP mode\n", port->name);
645 if (addr) {
646 fn = port->ops->ecp_write_addr;
647 } else {
648 fn = port->ops->ecp_write_data;
649 }
650 break;
651
652 case IEEE1284_MODE_ECPSWE:
653 DPRINTK (KERN_DEBUG "%s: Using software-emulated ECP mode\n",
654 port->name);
655 /* The caller has specified that it must be emulated,
656 * even if we have ECP hardware! */
657 if (addr) {
658 fn = parport_ieee1284_ecp_write_addr;
659 } else {
660 fn = parport_ieee1284_ecp_write_data;
661 }
662 break;
663
664 default:
665 DPRINTK (KERN_DEBUG "%s: Unknown mode 0x%02x\n", port->name,
666 port->ieee1284.mode);
667 return -ENOSYS;
668 }
669
670 retval = (*fn) (port, buffer, len, 0);
671 DPRINTK (KERN_DEBUG "%s: wrote %d/%d bytes\n", port->name, retval, len);
672 return retval;
673 #endif /* IEEE1284 support */
674 }
675
676 /**
677 * parport_read - read a block of data from a parallel port
678 * @port: port to read from
679 * @buffer: data buffer (in kernel space)
680 * @len: number of bytes of data to transfer
681 *
682 * This will read up to @len bytes of @buffer to the port
683 * specified, using the IEEE 1284 transfer mode most recently
684 * negotiated to (using parport_negotiate()), as long as that
685 * mode supports reverse transfers (peripheral to host).
686 *
687 * It is the caller's responsibility to ensure that the first
688 * @len bytes of @buffer are available to write to.
689 *
690 * This function returns the number of bytes transferred (if zero
691 * or positive), or else an error code.
692 */
693
694 ssize_t parport_read (struct parport *port, void *buffer, size_t len)
695 {
696 #ifndef CONFIG_PARPORT_1284
697 printk (KERN_ERR "parport: IEEE1284 not supported in this kernel\n");
698 return -ENODEV;
699 #else
700 int mode = port->physport->ieee1284.mode;
701 int addr = mode & IEEE1284_ADDR;
702 size_t (*fn) (struct parport *, void *, size_t, int);
703
704 /* Ignore the device-ID-request bit and the address bit. */
705 mode &= ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
706
707 /* Use the mode we're in. */
708 switch (mode) {
709 case IEEE1284_MODE_COMPAT:
710 /* if we can tri-state use BYTE mode instead of NIBBLE mode,
711 * if that fails, revert to NIBBLE mode -- ought to store somewhere
712 * the device's ability to do BYTE mode reverse transfers, so we don't
713 * end up needlessly calling negotiate(BYTE) repeately.. (fb)
714 */
715 if ((port->physport->modes & PARPORT_MODE_TRISTATE) &&
716 !parport_negotiate (port, IEEE1284_MODE_BYTE)) {
717 /* got into BYTE mode OK */
718 DPRINTK (KERN_DEBUG "%s: Using byte mode\n", port->name);
719 fn = port->ops->byte_read_data;
720 break;
721 }
722 if (parport_negotiate (port, IEEE1284_MODE_NIBBLE)) {
723 return -EIO;
724 }
725 /* fall through - to NIBBLE */
726 case IEEE1284_MODE_NIBBLE:
727 DPRINTK (KERN_DEBUG "%s: Using nibble mode\n", port->name);
728 fn = port->ops->nibble_read_data;
729 break;
730
731 case IEEE1284_MODE_BYTE:
732 DPRINTK (KERN_DEBUG "%s: Using byte mode\n", port->name);
733 fn = port->ops->byte_read_data;
734 break;
735
736 case IEEE1284_MODE_EPP:
737 DPRINTK (KERN_DEBUG "%s: Using EPP mode\n", port->name);
738 if (addr) {
739 fn = port->ops->epp_read_addr;
740 } else {
741 fn = port->ops->epp_read_data;
742 }
743 break;
744 case IEEE1284_MODE_EPPSWE:
745 DPRINTK (KERN_DEBUG "%s: Using software-emulated EPP mode\n",
746 port->name);
747 if (addr) {
748 fn = parport_ieee1284_epp_read_addr;
749 } else {
750 fn = parport_ieee1284_epp_read_data;
751 }
752 break;
753 case IEEE1284_MODE_ECP:
754 case IEEE1284_MODE_ECPRLE:
755 DPRINTK (KERN_DEBUG "%s: Using ECP mode\n", port->name);
756 fn = port->ops->ecp_read_data;
757 break;
758
759 case IEEE1284_MODE_ECPSWE:
760 DPRINTK (KERN_DEBUG "%s: Using software-emulated ECP mode\n",
761 port->name);
762 fn = parport_ieee1284_ecp_read_data;
763 break;
764
765 default:
766 DPRINTK (KERN_DEBUG "%s: Unknown mode 0x%02x\n", port->name,
767 port->physport->ieee1284.mode);
768 return -ENOSYS;
769 }
770
771 return (*fn) (port, buffer, len, 0);
772 #endif /* IEEE1284 support */
773 }
774
775 /**
776 * parport_set_timeout - set the inactivity timeout for a device
777 * @dev: device on a port
778 * @inactivity: inactivity timeout (in jiffies)
779 *
780 * This sets the inactivity timeout for a particular device on a
781 * port. This affects functions like parport_wait_peripheral().
782 * The special value 0 means not to call schedule() while dealing
783 * with this device.
784 *
785 * The return value is the previous inactivity timeout.
786 *
787 * Any callers of parport_wait_event() for this device are woken
788 * up.
789 */
790
791 long parport_set_timeout (struct pardevice *dev, long inactivity)
792 {
793 long int old = dev->timeout;
794
795 dev->timeout = inactivity;
796
797 if (dev->port->physport->cad == dev)
798 parport_ieee1284_wakeup (dev->port);
799
800 return old;
801 }
802
803 /* Exported symbols for modules. */
804
805 EXPORT_SYMBOL(parport_negotiate);
806 EXPORT_SYMBOL(parport_write);
807 EXPORT_SYMBOL(parport_read);
808 EXPORT_SYMBOL(parport_wait_peripheral);
809 EXPORT_SYMBOL(parport_wait_event);
810 EXPORT_SYMBOL(parport_set_timeout);
811 EXPORT_SYMBOL(parport_ieee1284_interrupt);