[PATCH] V4L: SAA7134 alsa build fix
[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 + msecs_to_jiffies(40);
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, msecs_to_jiffies(10))) < 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                         schedule_timeout_interruptible(msecs_to_jiffies(10));
220                 }
221         }
222
223         return 1;
224 }
225
226 #ifdef CONFIG_PARPORT_1284
227 /* Terminate a negotiated mode. */
228 static 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
335 int 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
561 static 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. */
575 void 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
608 ssize_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
701 ssize_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
798 long 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
812 EXPORT_SYMBOL(parport_negotiate);
813 EXPORT_SYMBOL(parport_write);
814 EXPORT_SYMBOL(parport_read);
815 EXPORT_SYMBOL(parport_wait_peripheral);
816 EXPORT_SYMBOL(parport_wait_event);
817 EXPORT_SYMBOL(parport_set_timeout);
818 EXPORT_SYMBOL(parport_ieee1284_interrupt);