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/signal.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 /* Make parport_wait_peripheral wake up. 35 * It will be useful to call this from an interrupt handler. */ 36 static void parport_ieee1284_wakeup (struct parport *port) 37 { 38 up (&port->physport->ieee1284.irq); 39 } 40 41 static 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 port 50 * @port: port to wait on 51 * @timeout: time to wait (in jiffies) 52 * 53 * This function waits for up to @timeout jiffies for an 54 * interrupt to occur on a parallel port. If the port timeout is 55 * set to zero, it returns immediately. 56 * 57 * If an interrupt occurs before the timeout period elapses, this 58 * function returns zero immediately. If it times out, it returns 59 * one. An error code less than zero indicates an error (most 60 * likely a pending signal), and the calling code should finish 61 * what it's doing as soon as it can. 62 */ 63 64 int 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() the 70 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 lines 85 * @port: port to watch 86 * @mask: status lines to watch 87 * @result: desired values of chosen status lines 88 * @usec: timeout 89 * 90 * This function busy-waits until the masked status lines have 91 * the desired values, or until the timeout period elapses. The 92 * @mask and @result parameters are bitmasks, with the bits 93 * 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-waits 97 * using udelay(). It currently has a resolution of 5usec. 98 * 99 * If the status lines take on the desired values before the 100 * timeout period elapses, parport_poll_peripheral() returns zero 101 * immediately. A return value greater than zero indicates 102 * a timeout. An error code (less than zero) indicates an error, 103 * most likely a signal that arrived, and the caller should 104 * finish what it is doing as soon as possible. 105 */ 106 107 int 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 35ms 133 * @port: port to watch 134 * @mask: status lines to watch 135 * @result: desired values of chosen status lines 136 * 137 * This function waits until the masked status lines have the 138 * desired values, or until 35ms have elapsed (see IEEE 1284-1994 139 * page 24 to 25 for why this value in particular is hardcoded). 140 * The @mask and @result parameters are bitmasks, with the bits 141 * 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 anticipation 145 * of a fast response from the peripheral. This fast polling 146 * time is configurable (using /proc), and defaults to 500usec. 147 * If the timeout for this port (see parport_set_timeout()) is 148 * zero, the fast polling time is 35ms, and this function does 149 * not call schedule(). 150 * 151 * If the timeout for this port is non-zero, after the fast 152 * polling fails it uses parport_wait_event() to wait for up to 153 * 10ms, waking up if an interrupt occurs. 154 */ 155 156 int 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 the 168 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 long 175 * 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 poll 183 * 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 if 193 * 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 the 203 * 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_1284 213 /* Terminate a negotiated mode. */ 214 static 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_SELECT 233 | PARPORT_CONTROL_INIT, 234 PARPORT_CONTROL_SELECT 235 | 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_INIT 246 | PARPORT_CONTROL_AUTOFD, 247 PARPORT_CONTROL_INIT 248 | 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_SELECT 271 | 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 mode 304 * @port: port to use 305 * @mode: mode to negotiate to 306 * 307 * Use this to negotiate to a particular IEEE 1284 transfer mode. 308 * The @mode parameter should be one of the constants in 309 * parport.h starting %IEEE1284_MODE_xxx. 310 * 311 * The return value is 0 if the peripheral has accepted the 312 * negotiation to the mode specified, -1 if the peripheral is not 313 * IEEE 1284 compliant (or not present), or 1 if the peripheral 314 * has rejected the negotiation. 315 */ 316 317 int parport_negotiate (struct parport *port, int mode) 318 { 319 #ifndef CONFIG_PARPORT_1284 320 if (mode == IEEE1284_MODE_COMPAT) 321 return 0; 322 pr_err("parport: IEEE1284 not supported in this kernel\n"); 323 return -1; 324 #else 325 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_STROBE 369 | PARPORT_CONTROL_AUTOFD 370 | 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_SELECT 382 | 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_ERROR 388 | PARPORT_STATUS_SELECT 389 | PARPORT_STATUS_PAPEROUT 390 | PARPORT_STATUS_ACK, 391 PARPORT_STATUS_ERROR 392 | PARPORT_STATUS_SELECT 393 | PARPORT_STATUS_PAPEROUT)) { 394 /* Timeout */ 395 parport_frob_control (port, 396 PARPORT_CONTROL_SELECT 397 | 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_STROBE 414 | 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 compliant 469 * 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 phase 531 * 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_1284 536 static 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. */ 550 void parport_ieee1284_interrupt (void *handle) 551 { 552 struct parport *port = handle; 553 parport_ieee1284_wakeup (port); 554 555 #ifdef CONFIG_PARPORT_1284 556 if (port->ieee1284.phase == IEEE1284_PH_REV_IDLE) { 557 /* An interrupt in this phase means that data 558 * 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 port 567 * @port: port to write to 568 * @buffer: data buffer (in kernel space) 569 * @len: number of bytes of data to transfer 570 * 571 * This will write up to @len bytes of @buffer to the port 572 * specified, using the IEEE 1284 transfer mode most recently 573 * negotiated to (using parport_negotiate()), as long as that 574 * mode supports forward transfers (host to peripheral). 575 * 576 * It is the caller's responsibility to ensure that the first 577 * @len bytes of @buffer are valid. 578 * 579 * This function returns the number of bytes transferred (if zero 580 * or positive), or else an error code. 581 */ 582 583 ssize_t parport_write (struct parport *port, const void *buffer, size_t len) 584 { 585 #ifndef CONFIG_PARPORT_1284 586 return port->ops->compat_write_data (port, buffer, len, 0); 587 #else 588 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 port 658 * @port: port to read from 659 * @buffer: data buffer (in kernel space) 660 * @len: number of bytes of data to transfer 661 * 662 * This will read up to @len bytes of @buffer to the port 663 * specified, using the IEEE 1284 transfer mode most recently 664 * negotiated to (using parport_negotiate()), as long as that 665 * mode supports reverse transfers (peripheral to host). 666 * 667 * It is the caller's responsibility to ensure that the first 668 * @len bytes of @buffer are available to write to. 669 * 670 * This function returns the number of bytes transferred (if zero 671 * or positive), or else an error code. 672 */ 673 674 ssize_t parport_read (struct parport *port, void *buffer, size_t len) 675 { 676 #ifndef CONFIG_PARPORT_1284 677 pr_err("parport: IEEE1284 not supported in this kernel\n"); 678 return -ENODEV; 679 #else 680 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 somewhere 692 * the device's ability to do BYTE mode reverse transfers, so we don't 693 * 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 device 755 * @dev: device on a port 756 * @inactivity: inactivity timeout (in jiffies) 757 * 758 * This sets the inactivity timeout for a particular device on a 759 * port. This affects functions like parport_wait_peripheral(). 760 * The special value 0 means not to call schedule() while dealing 761 * 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 woken 766 * up. 767 */ 768 769 long 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 783 EXPORT_SYMBOL(parport_negotiate); 784 EXPORT_SYMBOL(parport_write); 785 EXPORT_SYMBOL(parport_read); 786 EXPORT_SYMBOL(parport_wait_peripheral); 787 EXPORT_SYMBOL(parport_wait_event); 788 EXPORT_SYMBOL(parport_set_timeout); 789 EXPORT_SYMBOL(parport_ieee1284_interrupt); 790