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