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