Merge ../linux-2.6/
[linux-2.6] / drivers / parport / ieee1284.c
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/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. */
43 static void parport_ieee1284_wakeup (struct parport *port)
44 {
45         up (&port->physport->ieee1284.irq);
46 }
47
48 static struct parport *port_from_cookie[PARPORT_MAX];
49 static 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
64  *      function returns one immediately.  If it times out, it returns
65  *      a value greater than zero.  An error code less than zero
66  *      indicates an error (most likely a pending signal), and the
67  *      calling code should finish 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         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
113  *      immediately.  A zero return value greater than zero indicates
114  *      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
119 int 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
168 int 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. */
199         deadline = jiffies + (HZ + 24) / 25;
200         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) */
208                 if ((ret = parport_wait_event (port, (HZ + 99) / 100)) < 0)
209                         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. */
219                         __set_current_state (TASK_INTERRUPTIBLE);
220                         schedule_timeout ((HZ+ 99) / 100);
221                 }
222         }
223
224         return 1;
225 }
226
227 #ifdef CONFIG_PARPORT_1284
228 /* Terminate a negotiated mode. */
229 static void parport_ieee1284_terminate (struct parport *port)
230 {
231         int r;
232         port = port->physport;
233
234         /* EPP terminates differently. */
235         switch (port->ieee1284.mode) {
236         case IEEE1284_MODE_EPP:
237         case IEEE1284_MODE_EPPSL:
238         case IEEE1284_MODE_EPPSWE:
239                 /* Terminate from EPP mode. */
240
241                 /* Event 68: Set nInit low */
242                 parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
243                 udelay (50);
244
245                 /* Event 69: Set nInit high, nSelectIn low */
246                 parport_frob_control (port,
247                                       PARPORT_CONTROL_SELECT
248                                       | PARPORT_CONTROL_INIT,
249                                       PARPORT_CONTROL_SELECT
250                                       | PARPORT_CONTROL_INIT);
251                 break;
252
253         case IEEE1284_MODE_ECP:
254         case IEEE1284_MODE_ECPRLE:
255         case IEEE1284_MODE_ECPSWE:
256                 /* In ECP we can only terminate from fwd idle phase. */
257                 if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE) {
258                         /* Event 47: Set nInit high */
259                         parport_frob_control (port,
260                                               PARPORT_CONTROL_INIT
261                                               | PARPORT_CONTROL_AUTOFD,
262                                               PARPORT_CONTROL_INIT
263                                               | PARPORT_CONTROL_AUTOFD);
264
265                         /* Event 49: PError goes high */
266                         r = parport_wait_peripheral (port,
267                                                      PARPORT_STATUS_PAPEROUT,
268                                                      PARPORT_STATUS_PAPEROUT);
269                         if (r)
270                                 DPRINTK (KERN_INFO "%s: Timeout at event 49\n",
271                                          port->name);
272
273                         parport_data_forward (port);
274                         DPRINTK (KERN_DEBUG "%s: ECP direction: forward\n",
275                                  port->name);
276                         port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
277                 }
278
279                 /* fall-though.. */
280
281         default:
282                 /* Terminate from all other modes. */
283
284                 /* Event 22: Set nSelectIn low, nAutoFd high */
285                 parport_frob_control (port,
286                                       PARPORT_CONTROL_SELECT
287                                       | PARPORT_CONTROL_AUTOFD,
288                                       PARPORT_CONTROL_SELECT);
289
290                 /* Event 24: nAck goes low */
291                 r = parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0);
292                 if (r)
293                         DPRINTK (KERN_INFO "%s: Timeout at event 24\n",
294                                  port->name);
295
296                 /* Event 25: Set nAutoFd low */
297                 parport_frob_control (port,
298                                       PARPORT_CONTROL_AUTOFD,
299                                       PARPORT_CONTROL_AUTOFD);
300
301                 /* Event 27: nAck goes high */
302                 r = parport_wait_peripheral (port,
303                                              PARPORT_STATUS_ACK, 
304                                              PARPORT_STATUS_ACK);
305                 if (r)
306                         DPRINTK (KERN_INFO "%s: Timeout at event 27\n",
307                                  port->name);
308
309                 /* Event 29: Set nAutoFd high */
310                 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
311         }
312
313         port->ieee1284.mode = IEEE1284_MODE_COMPAT;
314         port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
315
316         DPRINTK (KERN_DEBUG "%s: In compatibility (forward idle) mode\n",
317                  port->name);
318 }               
319 #endif /* IEEE1284 support */
320
321 /**
322  *      parport_negotiate - negotiate an IEEE 1284 mode
323  *      @port: port to use
324  *      @mode: mode to negotiate to
325  *
326  *      Use this to negotiate to a particular IEEE 1284 transfer mode.
327  *      The @mode parameter should be one of the constants in
328  *      parport.h starting %IEEE1284_MODE_xxx.
329  *
330  *      The return value is 0 if the peripheral has accepted the
331  *      negotiation to the mode specified, -1 if the peripheral is not
332  *      IEEE 1284 compliant (or not present), or 1 if the peripheral
333  *      has rejected the negotiation.
334  */
335
336 int parport_negotiate (struct parport *port, int mode)
337 {
338 #ifndef CONFIG_PARPORT_1284
339         if (mode == IEEE1284_MODE_COMPAT)
340                 return 0;
341         printk (KERN_ERR "parport: IEEE1284 not supported in this kernel\n");
342         return -1;
343 #else
344         int m = mode & ~IEEE1284_ADDR;
345         int r;
346         unsigned char xflag;
347
348         port = port->physport;
349
350         /* Is there anything to do? */
351         if (port->ieee1284.mode == mode)
352                 return 0;
353
354         /* Is the difference just an address-or-not bit? */
355         if ((port->ieee1284.mode & ~IEEE1284_ADDR) == (mode & ~IEEE1284_ADDR)){
356                 port->ieee1284.mode = mode;
357                 return 0;
358         }
359
360         /* Go to compability forward idle mode */
361         if (port->ieee1284.mode != IEEE1284_MODE_COMPAT)
362                 parport_ieee1284_terminate (port);
363
364         if (mode == IEEE1284_MODE_COMPAT)
365                 /* Compatibility mode: no negotiation. */
366                 return 0; 
367
368         switch (mode) {
369         case IEEE1284_MODE_ECPSWE:
370                 m = IEEE1284_MODE_ECP;
371                 break;
372         case IEEE1284_MODE_EPPSL:
373         case IEEE1284_MODE_EPPSWE:
374                 m = IEEE1284_MODE_EPP;
375                 break;
376         case IEEE1284_MODE_BECP:
377                 return -ENOSYS; /* FIXME (implement BECP) */
378         }
379
380         if (mode & IEEE1284_EXT_LINK)
381                 m = 1<<7; /* request extensibility link */
382
383         port->ieee1284.phase = IEEE1284_PH_NEGOTIATION;
384
385         /* Start off with nStrobe and nAutoFd high, and nSelectIn low */
386         parport_frob_control (port,
387                               PARPORT_CONTROL_STROBE
388                               | PARPORT_CONTROL_AUTOFD
389                               | PARPORT_CONTROL_SELECT,
390                               PARPORT_CONTROL_SELECT);
391         udelay(1);
392
393         /* Event 0: Set data */
394         parport_data_forward (port);
395         parport_write_data (port, m);
396         udelay (400); /* Shouldn't need to wait this long. */
397
398         /* Event 1: Set nSelectIn high, nAutoFd low */
399         parport_frob_control (port,
400                               PARPORT_CONTROL_SELECT
401                               | PARPORT_CONTROL_AUTOFD,
402                               PARPORT_CONTROL_AUTOFD);
403
404         /* Event 2: PError, Select, nFault go high, nAck goes low */
405         if (parport_wait_peripheral (port,
406                                      PARPORT_STATUS_ERROR
407                                      | PARPORT_STATUS_SELECT
408                                      | PARPORT_STATUS_PAPEROUT
409                                      | PARPORT_STATUS_ACK,
410                                      PARPORT_STATUS_ERROR
411                                      | PARPORT_STATUS_SELECT
412                                      | PARPORT_STATUS_PAPEROUT)) {
413                 /* Timeout */
414                 parport_frob_control (port,
415                                       PARPORT_CONTROL_SELECT
416                                       | PARPORT_CONTROL_AUTOFD,
417                                       PARPORT_CONTROL_SELECT);
418                 DPRINTK (KERN_DEBUG
419                          "%s: Peripheral not IEEE1284 compliant (0x%02X)\n",
420                          port->name, parport_read_status (port));
421                 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
422                 return -1; /* Not IEEE1284 compliant */
423         }
424
425         /* Event 3: Set nStrobe low */
426         parport_frob_control (port,
427                               PARPORT_CONTROL_STROBE,
428                               PARPORT_CONTROL_STROBE);
429
430         /* Event 4: Set nStrobe and nAutoFd high */
431         udelay (5);
432         parport_frob_control (port,
433                               PARPORT_CONTROL_STROBE
434                               | PARPORT_CONTROL_AUTOFD,
435                               0);
436
437         /* Event 6: nAck goes high */
438         if (parport_wait_peripheral (port,
439                                      PARPORT_STATUS_ACK,
440                                      PARPORT_STATUS_ACK)) {
441                 /* This shouldn't really happen with a compliant device. */
442                 DPRINTK (KERN_DEBUG
443                          "%s: Mode 0x%02x not supported? (0x%02x)\n",
444                          port->name, mode, port->ops->read_status (port));
445                 parport_ieee1284_terminate (port);
446                 return 1;
447         }
448
449         xflag = parport_read_status (port) & PARPORT_STATUS_SELECT;
450
451         /* xflag should be high for all modes other than nibble (0). */
452         if (mode && !xflag) {
453                 /* Mode not supported. */
454                 DPRINTK (KERN_DEBUG "%s: Mode 0x%02x rejected by peripheral\n",
455                          port->name, mode);
456                 parport_ieee1284_terminate (port);
457                 return 1;
458         }
459
460         /* More to do if we've requested extensibility link. */
461         if (mode & IEEE1284_EXT_LINK) {
462                 m = mode & 0x7f;
463                 udelay (1);
464                 parport_write_data (port, m);
465                 udelay (1);
466
467                 /* Event 51: Set nStrobe low */
468                 parport_frob_control (port,
469                                       PARPORT_CONTROL_STROBE,
470                                       PARPORT_CONTROL_STROBE);
471
472                 /* Event 52: nAck goes low */
473                 if (parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0)) {
474                         /* This peripheral is _very_ slow. */
475                         DPRINTK (KERN_DEBUG
476                                  "%s: Event 52 didn't happen\n",
477                                  port->name);
478                         parport_ieee1284_terminate (port);
479                         return 1;
480                 }
481
482                 /* Event 53: Set nStrobe high */
483                 parport_frob_control (port,
484                                       PARPORT_CONTROL_STROBE,
485                                       0);
486
487                 /* Event 55: nAck goes high */
488                 if (parport_wait_peripheral (port,
489                                              PARPORT_STATUS_ACK,
490                                              PARPORT_STATUS_ACK)) {
491                         /* This shouldn't really happen with a compliant
492                          * device. */
493                         DPRINTK (KERN_DEBUG
494                                  "%s: Mode 0x%02x not supported? (0x%02x)\n",
495                                  port->name, mode,
496                                  port->ops->read_status (port));
497                         parport_ieee1284_terminate (port);
498                         return 1;
499                 }
500
501                 /* Event 54: Peripheral sets XFlag to reflect support */
502                 xflag = parport_read_status (port) & PARPORT_STATUS_SELECT;
503
504                 /* xflag should be high. */
505                 if (!xflag) {
506                         /* Extended mode not supported. */
507                         DPRINTK (KERN_DEBUG "%s: Extended mode 0x%02x not "
508                                  "supported\n", port->name, mode);
509                         parport_ieee1284_terminate (port);
510                         return 1;
511                 }
512
513                 /* Any further setup is left to the caller. */
514         }
515
516         /* Mode is supported */
517         DPRINTK (KERN_DEBUG "%s: In mode 0x%02x\n", port->name, mode);
518         port->ieee1284.mode = mode;
519
520         /* But ECP is special */
521         if (!(mode & IEEE1284_EXT_LINK) && (m & IEEE1284_MODE_ECP)) {
522                 port->ieee1284.phase = IEEE1284_PH_ECP_SETUP;
523
524                 /* Event 30: Set nAutoFd low */
525                 parport_frob_control (port,
526                                       PARPORT_CONTROL_AUTOFD,
527                                       PARPORT_CONTROL_AUTOFD);
528
529                 /* Event 31: PError goes high. */
530                 r = parport_wait_peripheral (port,
531                                              PARPORT_STATUS_PAPEROUT,
532                                              PARPORT_STATUS_PAPEROUT);
533                 if (r) {
534                         DPRINTK (KERN_INFO "%s: Timeout at event 31\n",
535                                 port->name);
536                 }
537
538                 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
539                 DPRINTK (KERN_DEBUG "%s: ECP direction: forward\n",
540                          port->name);
541         } else switch (mode) {
542         case IEEE1284_MODE_NIBBLE:
543         case IEEE1284_MODE_BYTE:
544                 port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
545                 break;
546         default:
547                 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
548         }
549
550
551         return 0;
552 #endif /* IEEE1284 support */
553 }
554
555 /* Acknowledge that the peripheral has data available.
556  * Events 18-20, in order to get from Reverse Idle phase
557  * to Host Busy Data Available.
558  * This will most likely be called from an interrupt.
559  * Returns zero if data was available.
560  */
561 #ifdef CONFIG_PARPORT_1284
562 static int parport_ieee1284_ack_data_avail (struct parport *port)
563 {
564         if (parport_read_status (port) & PARPORT_STATUS_ERROR)
565                 /* Event 18 didn't happen. */
566                 return -1;
567
568         /* Event 20: nAutoFd goes high. */
569         port->ops->frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
570         port->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL;
571         return 0;
572 }
573 #endif /* IEEE1284 support */
574
575 /* Handle an interrupt. */
576 void parport_ieee1284_interrupt (int which, void *handle, struct pt_regs *regs)
577 {
578         struct parport *port = handle;
579         parport_ieee1284_wakeup (port);
580
581 #ifdef CONFIG_PARPORT_1284
582         if (port->ieee1284.phase == IEEE1284_PH_REV_IDLE) {
583                 /* An interrupt in this phase means that data
584                  * is now available. */
585                 DPRINTK (KERN_DEBUG "%s: Data available\n", port->name);
586                 parport_ieee1284_ack_data_avail (port);
587         }
588 #endif /* IEEE1284 support */
589 }
590
591 /**
592  *      parport_write - write a block of data to a parallel port
593  *      @port: port to write to
594  *      @buffer: data buffer (in kernel space)
595  *      @len: number of bytes of data to transfer
596  *
597  *      This will write up to @len bytes of @buffer to the port
598  *      specified, using the IEEE 1284 transfer mode most recently
599  *      negotiated to (using parport_negotiate()), as long as that
600  *      mode supports forward transfers (host to peripheral).
601  *
602  *      It is the caller's responsibility to ensure that the first
603  *      @len bytes of @buffer are valid.
604  *
605  *      This function returns the number of bytes transferred (if zero
606  *      or positive), or else an error code.
607  */
608
609 ssize_t parport_write (struct parport *port, const void *buffer, size_t len)
610 {
611 #ifndef CONFIG_PARPORT_1284
612         return port->ops->compat_write_data (port, buffer, len, 0);
613 #else
614         ssize_t retval;
615         int mode = port->ieee1284.mode;
616         int addr = mode & IEEE1284_ADDR;
617         size_t (*fn) (struct parport *, const void *, size_t, int);
618
619         /* Ignore the device-ID-request bit and the address bit. */
620         mode &= ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
621
622         /* Use the mode we're in. */
623         switch (mode) {
624         case IEEE1284_MODE_NIBBLE:
625         case IEEE1284_MODE_BYTE:
626                 parport_negotiate (port, IEEE1284_MODE_COMPAT);
627         case IEEE1284_MODE_COMPAT:
628                 DPRINTK (KERN_DEBUG "%s: Using compatibility mode\n",
629                          port->name);
630                 fn = port->ops->compat_write_data;
631                 break;
632
633         case IEEE1284_MODE_EPP:
634                 DPRINTK (KERN_DEBUG "%s: Using EPP mode\n", port->name);
635                 if (addr) {
636                         fn = port->ops->epp_write_addr;
637                 } else {
638                         fn = port->ops->epp_write_data;
639                 }
640                 break;
641         case IEEE1284_MODE_EPPSWE:
642                 DPRINTK (KERN_DEBUG "%s: Using software-emulated EPP mode\n",
643                         port->name);
644                 if (addr) {
645                         fn = parport_ieee1284_epp_write_addr;
646                 } else {
647                         fn = parport_ieee1284_epp_write_data;
648                 }
649                 break;
650         case IEEE1284_MODE_ECP:
651         case IEEE1284_MODE_ECPRLE:
652                 DPRINTK (KERN_DEBUG "%s: Using ECP mode\n", port->name);
653                 if (addr) {
654                         fn = port->ops->ecp_write_addr;
655                 } else {
656                         fn = port->ops->ecp_write_data;
657                 }
658                 break;
659
660         case IEEE1284_MODE_ECPSWE:
661                 DPRINTK (KERN_DEBUG "%s: Using software-emulated ECP mode\n",
662                          port->name);
663                 /* The caller has specified that it must be emulated,
664                  * even if we have ECP hardware! */
665                 if (addr) {
666                         fn = parport_ieee1284_ecp_write_addr;
667                 } else {
668                         fn = parport_ieee1284_ecp_write_data;
669                 }
670                 break;
671
672         default:
673                 DPRINTK (KERN_DEBUG "%s: Unknown mode 0x%02x\n", port->name,
674                         port->ieee1284.mode);
675                 return -ENOSYS;
676         }
677
678         retval = (*fn) (port, buffer, len, 0);
679         DPRINTK (KERN_DEBUG "%s: wrote %d/%d bytes\n", port->name, retval, len);
680         return retval;
681 #endif /* IEEE1284 support */
682 }
683
684 /**
685  *      parport_read - read a block of data from a parallel port
686  *      @port: port to read from
687  *      @buffer: data buffer (in kernel space)
688  *      @len: number of bytes of data to transfer
689  *
690  *      This will read up to @len bytes of @buffer to the port
691  *      specified, using the IEEE 1284 transfer mode most recently
692  *      negotiated to (using parport_negotiate()), as long as that
693  *      mode supports reverse transfers (peripheral to host).
694  *
695  *      It is the caller's responsibility to ensure that the first
696  *      @len bytes of @buffer are available to write to.
697  *
698  *      This function returns the number of bytes transferred (if zero
699  *      or positive), or else an error code.
700  */
701
702 ssize_t parport_read (struct parport *port, void *buffer, size_t len)
703 {
704 #ifndef CONFIG_PARPORT_1284
705         printk (KERN_ERR "parport: IEEE1284 not supported in this kernel\n");
706         return -ENODEV;
707 #else
708         int mode = port->physport->ieee1284.mode;
709         int addr = mode & IEEE1284_ADDR;
710         size_t (*fn) (struct parport *, void *, size_t, int);
711
712         /* Ignore the device-ID-request bit and the address bit. */
713         mode &= ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
714
715         /* Use the mode we're in. */
716         switch (mode) {
717         case IEEE1284_MODE_COMPAT:
718                 /* if we can tri-state use BYTE mode instead of NIBBLE mode,
719                  * if that fails, revert to NIBBLE mode -- ought to store somewhere
720                  * the device's ability to do BYTE mode reverse transfers, so we don't
721                  * end up needlessly calling negotiate(BYTE) repeately..  (fb)
722                  */
723                 if ((port->physport->modes & PARPORT_MODE_TRISTATE) &&
724                     !parport_negotiate (port, IEEE1284_MODE_BYTE)) {
725                         /* got into BYTE mode OK */
726                         DPRINTK (KERN_DEBUG "%s: Using byte mode\n", port->name);
727                         fn = port->ops->byte_read_data;
728                         break;
729                 }
730                 if (parport_negotiate (port, IEEE1284_MODE_NIBBLE)) {
731                         return -EIO;
732                 }
733                 /* fall through to NIBBLE */
734         case IEEE1284_MODE_NIBBLE:
735                 DPRINTK (KERN_DEBUG "%s: Using nibble mode\n", port->name);
736                 fn = port->ops->nibble_read_data;
737                 break;
738
739         case IEEE1284_MODE_BYTE:
740                 DPRINTK (KERN_DEBUG "%s: Using byte mode\n", port->name);
741                 fn = port->ops->byte_read_data;
742                 break;
743
744         case IEEE1284_MODE_EPP:
745                 DPRINTK (KERN_DEBUG "%s: Using EPP mode\n", port->name);
746                 if (addr) {
747                         fn = port->ops->epp_read_addr;
748                 } else {
749                         fn = port->ops->epp_read_data;
750                 }
751                 break;
752         case IEEE1284_MODE_EPPSWE:
753                 DPRINTK (KERN_DEBUG "%s: Using software-emulated EPP mode\n",
754                         port->name);
755                 if (addr) {
756                         fn = parport_ieee1284_epp_read_addr;
757                 } else {
758                         fn = parport_ieee1284_epp_read_data;
759                 }
760                 break;
761         case IEEE1284_MODE_ECP:
762         case IEEE1284_MODE_ECPRLE:
763                 DPRINTK (KERN_DEBUG "%s: Using ECP mode\n", port->name);
764                 fn = port->ops->ecp_read_data;
765                 break;
766
767         case IEEE1284_MODE_ECPSWE:
768                 DPRINTK (KERN_DEBUG "%s: Using software-emulated ECP mode\n",
769                          port->name);
770                 fn = parport_ieee1284_ecp_read_data;
771                 break;
772
773         default:
774                 DPRINTK (KERN_DEBUG "%s: Unknown mode 0x%02x\n", port->name,
775                          port->physport->ieee1284.mode);
776                 return -ENOSYS;
777         }
778
779         return (*fn) (port, buffer, len, 0);
780 #endif /* IEEE1284 support */
781 }
782
783 /**
784  *      parport_set_timeout - set the inactivity timeout for a device
785  *      @dev: device on a port
786  *      @inactivity: inactivity timeout (in jiffies)
787  *
788  *      This sets the inactivity timeout for a particular device on a
789  *      port.  This affects functions like parport_wait_peripheral().
790  *      The special value 0 means not to call schedule() while dealing
791  *      with this device.
792  *
793  *      The return value is the previous inactivity timeout.
794  *
795  *      Any callers of parport_wait_event() for this device are woken
796  *      up.
797  */
798
799 long parport_set_timeout (struct pardevice *dev, long inactivity)
800 {
801         long int old = dev->timeout;
802
803         dev->timeout = inactivity;
804
805         if (dev->port->physport->cad == dev)
806                 parport_ieee1284_wakeup (dev->port);
807
808         return old;
809 }
810
811 /* Exported symbols for modules. */
812
813 EXPORT_SYMBOL(parport_negotiate);
814 EXPORT_SYMBOL(parport_write);
815 EXPORT_SYMBOL(parport_read);
816 EXPORT_SYMBOL(parport_wait_peripheral);
817 EXPORT_SYMBOL(parport_wait_event);
818 EXPORT_SYMBOL(parport_set_timeout);
819 EXPORT_SYMBOL(parport_ieee1284_interrupt);