Root/drivers/parport/ieee1284.c

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

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive