790 lines · 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 handing10 * read/write requests to low-level drivers.11 *12 * Any part of this program may be used in documents licensed under13 * the GNU Free Documentation License, Version 1.1 or any later version14 * published by the Free Software Foundation.15 *16 * Various hacks, Fred Barnes <frmb2@ukc.ac.uk>, 04/200017 */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/signal.h>27 28#undef DEBUG /* undef me for production */29 30#ifdef CONFIG_LP_CONSOLE31#undef DEBUG /* Don't want a garbled console */32#endif33 34/* Make parport_wait_peripheral wake up.35 * It will be useful to call this from an interrupt handler. */36static void parport_ieee1284_wakeup (struct parport *port)37{38 up (&port->physport->ieee1284.irq);39}40 41static void timeout_waiting_on_port (struct timer_list *t)42{43 struct parport *port = from_timer(port, t, timer);44 45 parport_ieee1284_wakeup (port);46}47 48/**49 * parport_wait_event - wait for an event on a parallel port50 * @port: port to wait on51 * @timeout: time to wait (in jiffies)52 *53 * This function waits for up to @timeout jiffies for an54 * interrupt to occur on a parallel port. If the port timeout is55 * set to zero, it returns immediately.56 *57 * If an interrupt occurs before the timeout period elapses, this58 * function returns zero immediately. If it times out, it returns59 * one. An error code less than zero indicates an error (most60 * likely a pending signal), and the calling code should finish61 * what it's doing as soon as it can.62 */63 64int parport_wait_event (struct parport *port, signed long timeout)65{66 int ret;67 68 if (!port->physport->cad->timeout)69 /* Zero timeout is special, and we can't down() the70 semaphore. */71 return 1;72 73 timer_setup(&port->timer, timeout_waiting_on_port, 0);74 mod_timer(&port->timer, jiffies + timeout);75 ret = down_interruptible (&port->physport->ieee1284.irq);76 if (!del_timer_sync(&port->timer) && !ret)77 /* Timed out. */78 ret = 1;79 80 return ret;81}82 83/**84 * parport_poll_peripheral - poll status lines85 * @port: port to watch86 * @mask: status lines to watch87 * @result: desired values of chosen status lines88 * @usec: timeout89 *90 * This function busy-waits until the masked status lines have91 * the desired values, or until the timeout period elapses. The92 * @mask and @result parameters are bitmasks, with the bits93 * defined by the constants in parport.h: %PARPORT_STATUS_BUSY,94 * and so on.95 *96 * This function does not call schedule(); instead it busy-waits97 * using udelay(). It currently has a resolution of 5usec.98 *99 * If the status lines take on the desired values before the100 * timeout period elapses, parport_poll_peripheral() returns zero101 * immediately. A return value greater than zero indicates102 * a timeout. An error code (less than zero) indicates an error,103 * most likely a signal that arrived, and the caller should104 * finish what it is doing as soon as possible.105*/106 107int parport_poll_peripheral(struct parport *port,108 unsigned char mask,109 unsigned char result,110 int usec)111{112 /* Zero return code is success, >0 is timeout. */113 int count = usec / 5 + 2;114 int i;115 unsigned char status;116 for (i = 0; i < count; i++) {117 status = parport_read_status (port);118 if ((status & mask) == result)119 return 0;120 if (signal_pending (current))121 return -EINTR;122 if (need_resched())123 break;124 if (i >= 2)125 udelay (5);126 }127 128 return 1;129}130 131/**132 * parport_wait_peripheral - wait for status lines to change in 35ms133 * @port: port to watch134 * @mask: status lines to watch135 * @result: desired values of chosen status lines136 *137 * This function waits until the masked status lines have the138 * desired values, or until 35ms have elapsed (see IEEE 1284-1994139 * page 24 to 25 for why this value in particular is hardcoded).140 * The @mask and @result parameters are bitmasks, with the bits141 * defined by the constants in parport.h: %PARPORT_STATUS_BUSY,142 * and so on.143 *144 * The port is polled quickly to start off with, in anticipation145 * of a fast response from the peripheral. This fast polling146 * time is configurable (using /proc), and defaults to 500usec.147 * If the timeout for this port (see parport_set_timeout()) is148 * zero, the fast polling time is 35ms, and this function does149 * not call schedule().150 *151 * If the timeout for this port is non-zero, after the fast152 * polling fails it uses parport_wait_event() to wait for up to153 * 10ms, waking up if an interrupt occurs.154 */155 156int parport_wait_peripheral(struct parport *port,157 unsigned char mask, 158 unsigned char result)159{160 int ret;161 int usec;162 unsigned long deadline;163 unsigned char status;164 165 usec = port->physport->spintime; /* usecs of fast polling */166 if (!port->physport->cad->timeout)167 /* A zero timeout is "special": busy wait for the168 entire 35ms. */169 usec = 35000;170 171 /* Fast polling.172 *173 * This should be adjustable.174 * How about making a note (in the device structure) of how long175 * it takes, so we know for next time?176 */177 ret = parport_poll_peripheral (port, mask, result, usec);178 if (ret != 1)179 return ret;180 181 if (!port->physport->cad->timeout)182 /* We may be in an interrupt handler, so we can't poll183 * slowly anyway. */184 return 1;185 186 /* 40ms of slow polling. */187 deadline = jiffies + msecs_to_jiffies(40);188 while (time_before (jiffies, deadline)) {189 if (signal_pending (current))190 return -EINTR;191 192 /* Wait for 10ms (or until an interrupt occurs if193 * the handler is set) */194 if ((ret = parport_wait_event (port, msecs_to_jiffies(10))) < 0)195 return ret;196 197 status = parport_read_status (port);198 if ((status & mask) == result)199 return 0;200 201 if (!ret) {202 /* parport_wait_event didn't time out, but the203 * peripheral wasn't actually ready either.204 * Wait for another 10ms. */205 schedule_timeout_interruptible(msecs_to_jiffies(10));206 }207 }208 209 return 1;210}211 212#ifdef CONFIG_PARPORT_1284213/* Terminate a negotiated mode. */214static void parport_ieee1284_terminate (struct parport *port)215{216 int r;217 port = port->physport;218 219 /* EPP terminates differently. */220 switch (port->ieee1284.mode) {221 case IEEE1284_MODE_EPP:222 case IEEE1284_MODE_EPPSL:223 case IEEE1284_MODE_EPPSWE:224 /* Terminate from EPP mode. */225 226 /* Event 68: Set nInit low */227 parport_frob_control (port, PARPORT_CONTROL_INIT, 0);228 udelay (50);229 230 /* Event 69: Set nInit high, nSelectIn low */231 parport_frob_control (port,232 PARPORT_CONTROL_SELECT233 | PARPORT_CONTROL_INIT,234 PARPORT_CONTROL_SELECT235 | PARPORT_CONTROL_INIT);236 break;237 238 case IEEE1284_MODE_ECP:239 case IEEE1284_MODE_ECPRLE:240 case IEEE1284_MODE_ECPSWE:241 /* In ECP we can only terminate from fwd idle phase. */242 if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE) {243 /* Event 47: Set nInit high */244 parport_frob_control (port,245 PARPORT_CONTROL_INIT246 | PARPORT_CONTROL_AUTOFD,247 PARPORT_CONTROL_INIT248 | PARPORT_CONTROL_AUTOFD);249 250 /* Event 49: PError goes high */251 r = parport_wait_peripheral (port,252 PARPORT_STATUS_PAPEROUT,253 PARPORT_STATUS_PAPEROUT);254 if (r)255 pr_debug("%s: Timeout at event 49\n",256 port->name);257 258 parport_data_forward (port);259 pr_debug("%s: ECP direction: forward\n", port->name);260 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;261 }262 263 fallthrough;264 265 default:266 /* Terminate from all other modes. */267 268 /* Event 22: Set nSelectIn low, nAutoFd high */269 parport_frob_control (port,270 PARPORT_CONTROL_SELECT271 | PARPORT_CONTROL_AUTOFD,272 PARPORT_CONTROL_SELECT);273 274 /* Event 24: nAck goes low */275 r = parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0);276 if (r)277 pr_debug("%s: Timeout at event 24\n", port->name);278 279 /* Event 25: Set nAutoFd low */280 parport_frob_control (port,281 PARPORT_CONTROL_AUTOFD,282 PARPORT_CONTROL_AUTOFD);283 284 /* Event 27: nAck goes high */285 r = parport_wait_peripheral (port,286 PARPORT_STATUS_ACK, 287 PARPORT_STATUS_ACK);288 if (r)289 pr_debug("%s: Timeout at event 27\n", port->name);290 291 /* Event 29: Set nAutoFd high */292 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);293 }294 295 port->ieee1284.mode = IEEE1284_MODE_COMPAT;296 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;297 298 pr_debug("%s: In compatibility (forward idle) mode\n", port->name);299} 300#endif /* IEEE1284 support */301 302/**303 * parport_negotiate - negotiate an IEEE 1284 mode304 * @port: port to use305 * @mode: mode to negotiate to306 *307 * Use this to negotiate to a particular IEEE 1284 transfer mode.308 * The @mode parameter should be one of the constants in309 * parport.h starting %IEEE1284_MODE_xxx.310 *311 * The return value is 0 if the peripheral has accepted the312 * negotiation to the mode specified, -1 if the peripheral is not313 * IEEE 1284 compliant (or not present), or 1 if the peripheral314 * has rejected the negotiation.315 */316 317int parport_negotiate (struct parport *port, int mode)318{319#ifndef CONFIG_PARPORT_1284320 if (mode == IEEE1284_MODE_COMPAT)321 return 0;322 pr_err("parport: IEEE1284 not supported in this kernel\n");323 return -1;324#else325 int m = mode & ~IEEE1284_ADDR;326 int r;327 unsigned char xflag;328 329 port = port->physport;330 331 /* Is there anything to do? */332 if (port->ieee1284.mode == mode)333 return 0;334 335 /* Is the difference just an address-or-not bit? */336 if ((port->ieee1284.mode & ~IEEE1284_ADDR) == (mode & ~IEEE1284_ADDR)){337 port->ieee1284.mode = mode;338 return 0;339 }340 341 /* Go to compatibility forward idle mode */342 if (port->ieee1284.mode != IEEE1284_MODE_COMPAT)343 parport_ieee1284_terminate (port);344 345 if (mode == IEEE1284_MODE_COMPAT)346 /* Compatibility mode: no negotiation. */347 return 0; 348 349 switch (mode) {350 case IEEE1284_MODE_ECPSWE:351 m = IEEE1284_MODE_ECP;352 break;353 case IEEE1284_MODE_EPPSL:354 case IEEE1284_MODE_EPPSWE:355 m = IEEE1284_MODE_EPP;356 break;357 case IEEE1284_MODE_BECP:358 return -ENOSYS; /* FIXME (implement BECP) */359 }360 361 if (mode & IEEE1284_EXT_LINK)362 m = 1<<7; /* request extensibility link */363 364 port->ieee1284.phase = IEEE1284_PH_NEGOTIATION;365 366 /* Start off with nStrobe and nAutoFd high, and nSelectIn low */367 parport_frob_control (port,368 PARPORT_CONTROL_STROBE369 | PARPORT_CONTROL_AUTOFD370 | PARPORT_CONTROL_SELECT,371 PARPORT_CONTROL_SELECT);372 udelay(1);373 374 /* Event 0: Set data */375 parport_data_forward (port);376 parport_write_data (port, m);377 udelay (400); /* Shouldn't need to wait this long. */378 379 /* Event 1: Set nSelectIn high, nAutoFd low */380 parport_frob_control (port,381 PARPORT_CONTROL_SELECT382 | PARPORT_CONTROL_AUTOFD,383 PARPORT_CONTROL_AUTOFD);384 385 /* Event 2: PError, Select, nFault go high, nAck goes low */386 if (parport_wait_peripheral (port,387 PARPORT_STATUS_ERROR388 | PARPORT_STATUS_SELECT389 | PARPORT_STATUS_PAPEROUT390 | PARPORT_STATUS_ACK,391 PARPORT_STATUS_ERROR392 | PARPORT_STATUS_SELECT393 | PARPORT_STATUS_PAPEROUT)) {394 /* Timeout */395 parport_frob_control (port,396 PARPORT_CONTROL_SELECT397 | PARPORT_CONTROL_AUTOFD,398 PARPORT_CONTROL_SELECT);399 pr_debug("%s: Peripheral not IEEE1284 compliant (0x%02X)\n",400 port->name, parport_read_status (port));401 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;402 return -1; /* Not IEEE1284 compliant */403 }404 405 /* Event 3: Set nStrobe low */406 parport_frob_control (port,407 PARPORT_CONTROL_STROBE,408 PARPORT_CONTROL_STROBE);409 410 /* Event 4: Set nStrobe and nAutoFd high */411 udelay (5);412 parport_frob_control (port,413 PARPORT_CONTROL_STROBE414 | PARPORT_CONTROL_AUTOFD,415 0);416 417 /* Event 6: nAck goes high */418 if (parport_wait_peripheral (port,419 PARPORT_STATUS_ACK,420 PARPORT_STATUS_ACK)) {421 /* This shouldn't really happen with a compliant device. */422 pr_debug("%s: Mode 0x%02x not supported? (0x%02x)\n",423 port->name, mode, port->ops->read_status (port));424 parport_ieee1284_terminate (port);425 return 1;426 }427 428 xflag = parport_read_status (port) & PARPORT_STATUS_SELECT;429 430 /* xflag should be high for all modes other than nibble (0). */431 if (mode && !xflag) {432 /* Mode not supported. */433 pr_debug("%s: Mode 0x%02x rejected by peripheral\n",434 port->name, mode);435 parport_ieee1284_terminate (port);436 return 1;437 }438 439 /* More to do if we've requested extensibility link. */440 if (mode & IEEE1284_EXT_LINK) {441 m = mode & 0x7f;442 udelay (1);443 parport_write_data (port, m);444 udelay (1);445 446 /* Event 51: Set nStrobe low */447 parport_frob_control (port,448 PARPORT_CONTROL_STROBE,449 PARPORT_CONTROL_STROBE);450 451 /* Event 52: nAck goes low */452 if (parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0)) {453 /* This peripheral is _very_ slow. */454 pr_debug("%s: Event 52 didn't happen\n", port->name);455 parport_ieee1284_terminate (port);456 return 1;457 }458 459 /* Event 53: Set nStrobe high */460 parport_frob_control (port,461 PARPORT_CONTROL_STROBE,462 0);463 464 /* Event 55: nAck goes high */465 if (parport_wait_peripheral (port,466 PARPORT_STATUS_ACK,467 PARPORT_STATUS_ACK)) {468 /* This shouldn't really happen with a compliant469 * device. */470 pr_debug("%s: Mode 0x%02x not supported? (0x%02x)\n",471 port->name, mode,472 port->ops->read_status(port));473 parport_ieee1284_terminate (port);474 return 1;475 }476 477 /* Event 54: Peripheral sets XFlag to reflect support */478 xflag = parport_read_status (port) & PARPORT_STATUS_SELECT;479 480 /* xflag should be high. */481 if (!xflag) {482 /* Extended mode not supported. */483 pr_debug("%s: Extended mode 0x%02x not supported\n",484 port->name, mode);485 parport_ieee1284_terminate (port);486 return 1;487 }488 489 /* Any further setup is left to the caller. */490 }491 492 /* Mode is supported */493 pr_debug("%s: In mode 0x%02x\n", port->name, mode);494 port->ieee1284.mode = mode;495 496 /* But ECP is special */497 if (!(mode & IEEE1284_EXT_LINK) && (m & IEEE1284_MODE_ECP)) {498 port->ieee1284.phase = IEEE1284_PH_ECP_SETUP;499 500 /* Event 30: Set nAutoFd low */501 parport_frob_control (port,502 PARPORT_CONTROL_AUTOFD,503 PARPORT_CONTROL_AUTOFD);504 505 /* Event 31: PError goes high. */506 r = parport_wait_peripheral (port,507 PARPORT_STATUS_PAPEROUT,508 PARPORT_STATUS_PAPEROUT);509 if (r) {510 pr_debug("%s: Timeout at event 31\n", port->name);511 }512 513 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;514 pr_debug("%s: ECP direction: forward\n", port->name);515 } else switch (mode) {516 case IEEE1284_MODE_NIBBLE:517 case IEEE1284_MODE_BYTE:518 port->ieee1284.phase = IEEE1284_PH_REV_IDLE;519 break;520 default:521 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;522 }523 524 525 return 0;526#endif /* IEEE1284 support */527}528 529/* Acknowledge that the peripheral has data available.530 * Events 18-20, in order to get from Reverse Idle phase531 * to Host Busy Data Available.532 * This will most likely be called from an interrupt.533 * Returns zero if data was available.534 */535#ifdef CONFIG_PARPORT_1284536static int parport_ieee1284_ack_data_avail (struct parport *port)537{538 if (parport_read_status (port) & PARPORT_STATUS_ERROR)539 /* Event 18 didn't happen. */540 return -1;541 542 /* Event 20: nAutoFd goes high. */543 port->ops->frob_control (port, PARPORT_CONTROL_AUTOFD, 0);544 port->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL;545 return 0;546}547#endif /* IEEE1284 support */548 549/* Handle an interrupt. */550void parport_ieee1284_interrupt (void *handle)551{552 struct parport *port = handle;553 parport_ieee1284_wakeup (port);554 555#ifdef CONFIG_PARPORT_1284556 if (port->ieee1284.phase == IEEE1284_PH_REV_IDLE) {557 /* An interrupt in this phase means that data558 * is now available. */559 pr_debug("%s: Data available\n", port->name);560 parport_ieee1284_ack_data_avail (port);561 }562#endif /* IEEE1284 support */563}564 565/**566 * parport_write - write a block of data to a parallel port567 * @port: port to write to568 * @buffer: data buffer (in kernel space)569 * @len: number of bytes of data to transfer570 *571 * This will write up to @len bytes of @buffer to the port572 * specified, using the IEEE 1284 transfer mode most recently573 * negotiated to (using parport_negotiate()), as long as that574 * mode supports forward transfers (host to peripheral).575 *576 * It is the caller's responsibility to ensure that the first577 * @len bytes of @buffer are valid.578 *579 * This function returns the number of bytes transferred (if zero580 * or positive), or else an error code.581 */582 583ssize_t parport_write (struct parport *port, const void *buffer, size_t len)584{585#ifndef CONFIG_PARPORT_1284586 return port->ops->compat_write_data (port, buffer, len, 0);587#else588 ssize_t retval;589 int mode = port->ieee1284.mode;590 int addr = mode & IEEE1284_ADDR;591 size_t (*fn) (struct parport *, const void *, size_t, int);592 593 /* Ignore the device-ID-request bit and the address bit. */594 mode &= ~(IEEE1284_DEVICEID | IEEE1284_ADDR);595 596 /* Use the mode we're in. */597 switch (mode) {598 case IEEE1284_MODE_NIBBLE:599 case IEEE1284_MODE_BYTE:600 parport_negotiate (port, IEEE1284_MODE_COMPAT);601 fallthrough;602 case IEEE1284_MODE_COMPAT:603 pr_debug("%s: Using compatibility mode\n", port->name);604 fn = port->ops->compat_write_data;605 break;606 607 case IEEE1284_MODE_EPP:608 pr_debug("%s: Using EPP mode\n", port->name);609 if (addr) {610 fn = port->ops->epp_write_addr;611 } else {612 fn = port->ops->epp_write_data;613 }614 break;615 case IEEE1284_MODE_EPPSWE:616 pr_debug("%s: Using software-emulated EPP mode\n", port->name);617 if (addr) {618 fn = parport_ieee1284_epp_write_addr;619 } else {620 fn = parport_ieee1284_epp_write_data;621 }622 break;623 case IEEE1284_MODE_ECP:624 case IEEE1284_MODE_ECPRLE:625 pr_debug("%s: Using ECP mode\n", port->name);626 if (addr) {627 fn = port->ops->ecp_write_addr;628 } else {629 fn = port->ops->ecp_write_data;630 }631 break;632 633 case IEEE1284_MODE_ECPSWE:634 pr_debug("%s: Using software-emulated ECP mode\n", port->name);635 /* The caller has specified that it must be emulated,636 * even if we have ECP hardware! */637 if (addr) {638 fn = parport_ieee1284_ecp_write_addr;639 } else {640 fn = parport_ieee1284_ecp_write_data;641 }642 break;643 644 default:645 pr_debug("%s: Unknown mode 0x%02x\n",646 port->name, port->ieee1284.mode);647 return -ENOSYS;648 }649 650 retval = (*fn) (port, buffer, len, 0);651 pr_debug("%s: wrote %zd/%zu bytes\n", port->name, retval, len);652 return retval;653#endif /* IEEE1284 support */654}655 656/**657 * parport_read - read a block of data from a parallel port658 * @port: port to read from659 * @buffer: data buffer (in kernel space)660 * @len: number of bytes of data to transfer661 *662 * This will read up to @len bytes of @buffer to the port663 * specified, using the IEEE 1284 transfer mode most recently664 * negotiated to (using parport_negotiate()), as long as that665 * mode supports reverse transfers (peripheral to host).666 *667 * It is the caller's responsibility to ensure that the first668 * @len bytes of @buffer are available to write to.669 *670 * This function returns the number of bytes transferred (if zero671 * or positive), or else an error code.672 */673 674ssize_t parport_read (struct parport *port, void *buffer, size_t len)675{676#ifndef CONFIG_PARPORT_1284677 pr_err("parport: IEEE1284 not supported in this kernel\n");678 return -ENODEV;679#else680 int mode = port->physport->ieee1284.mode;681 int addr = mode & IEEE1284_ADDR;682 size_t (*fn) (struct parport *, void *, size_t, int);683 684 /* Ignore the device-ID-request bit and the address bit. */685 mode &= ~(IEEE1284_DEVICEID | IEEE1284_ADDR);686 687 /* Use the mode we're in. */688 switch (mode) {689 case IEEE1284_MODE_COMPAT:690 /* if we can tri-state use BYTE mode instead of NIBBLE mode,691 * if that fails, revert to NIBBLE mode -- ought to store somewhere692 * the device's ability to do BYTE mode reverse transfers, so we don't693 * end up needlessly calling negotiate(BYTE) repeately.. (fb)694 */695 if ((port->physport->modes & PARPORT_MODE_TRISTATE) &&696 !parport_negotiate (port, IEEE1284_MODE_BYTE)) {697 /* got into BYTE mode OK */698 pr_debug("%s: Using byte mode\n", port->name);699 fn = port->ops->byte_read_data;700 break;701 }702 if (parport_negotiate (port, IEEE1284_MODE_NIBBLE)) {703 return -EIO;704 }705 fallthrough; /* to NIBBLE */706 case IEEE1284_MODE_NIBBLE:707 pr_debug("%s: Using nibble mode\n", port->name);708 fn = port->ops->nibble_read_data;709 break;710 711 case IEEE1284_MODE_BYTE:712 pr_debug("%s: Using byte mode\n", port->name);713 fn = port->ops->byte_read_data;714 break;715 716 case IEEE1284_MODE_EPP:717 pr_debug("%s: Using EPP mode\n", port->name);718 if (addr) {719 fn = port->ops->epp_read_addr;720 } else {721 fn = port->ops->epp_read_data;722 }723 break;724 case IEEE1284_MODE_EPPSWE:725 pr_debug("%s: Using software-emulated EPP mode\n", port->name);726 if (addr) {727 fn = parport_ieee1284_epp_read_addr;728 } else {729 fn = parport_ieee1284_epp_read_data;730 }731 break;732 case IEEE1284_MODE_ECP:733 case IEEE1284_MODE_ECPRLE:734 pr_debug("%s: Using ECP mode\n", port->name);735 fn = port->ops->ecp_read_data;736 break;737 738 case IEEE1284_MODE_ECPSWE:739 pr_debug("%s: Using software-emulated ECP mode\n", port->name);740 fn = parport_ieee1284_ecp_read_data;741 break;742 743 default:744 pr_debug("%s: Unknown mode 0x%02x\n",745 port->name, port->physport->ieee1284.mode);746 return -ENOSYS;747 }748 749 return (*fn) (port, buffer, len, 0);750#endif /* IEEE1284 support */751}752 753/**754 * parport_set_timeout - set the inactivity timeout for a device755 * @dev: device on a port756 * @inactivity: inactivity timeout (in jiffies)757 *758 * This sets the inactivity timeout for a particular device on a759 * port. This affects functions like parport_wait_peripheral().760 * The special value 0 means not to call schedule() while dealing761 * with this device.762 *763 * The return value is the previous inactivity timeout.764 *765 * Any callers of parport_wait_event() for this device are woken766 * up.767 */768 769long parport_set_timeout (struct pardevice *dev, long inactivity)770{771 long int old = dev->timeout;772 773 dev->timeout = inactivity;774 775 if (dev->port->physport->cad == dev)776 parport_ieee1284_wakeup (dev->port);777 778 return old;779}780 781/* Exported symbols for modules. */782 783EXPORT_SYMBOL(parport_negotiate);784EXPORT_SYMBOL(parport_write);785EXPORT_SYMBOL(parport_read);786EXPORT_SYMBOL(parport_wait_peripheral);787EXPORT_SYMBOL(parport_wait_event);788EXPORT_SYMBOL(parport_set_timeout);789EXPORT_SYMBOL(parport_ieee1284_interrupt);790