1 /* IEEE-1284 operations for parport. 2 * 3 * This file is for generic IEEE 1284 operations. The idea is that 4 * they are used by the low-level drivers. If they have a special way 5 * of doing something, they can provide their own routines (and put 6 * the function pointers in port->ops); if not, they can just use these 7 * as a fallback. 8 * 9 * Note: Make no assumptions about hardware or architecture in this file! 10 * 11 * Author: Tim Waugh <tim@cyberelk.demon.co.uk> 12 * Fixed AUTOFD polarity in ecp_forward_to_reverse(). Fred Barnes, 1999 13 * Software emulated EPP fixes, Fred Barnes, 04/2001. 14 */ 15 16 17 #include <linux/config.h> 18 #include <linux/module.h> 19 #include <linux/parport.h> 20 #include <linux/delay.h> 21 #include <linux/sched.h> 22 #include <asm/uaccess.h> 23 24 #undef DEBUG /* undef me for production */ 25 26 #ifdef CONFIG_LP_CONSOLE 27 #undef DEBUG /* Don't want a garbled console */ 28 #endif 29 30 #ifdef DEBUG 31 #define DPRINTK(stuff...) printk (stuff) 32 #else 33 #define DPRINTK(stuff...) 34 #endif 35 36 /*** * 37 * One-way data transfer functions. * 38 * ***/ 39 40 /* Compatibility mode. */ 41 size_t parport_ieee1284_write_compat (struct parport *port, 42 const void *buffer, size_t len, 43 int flags) 44 { 45 int no_irq = 1; 46 ssize_t count = 0; 47 const unsigned char *addr = buffer; 48 unsigned char byte; 49 struct pardevice *dev = port->physport->cad; 50 unsigned char ctl = (PARPORT_CONTROL_SELECT 51 | PARPORT_CONTROL_INIT); 52 53 if (port->irq != PARPORT_IRQ_NONE) { 54 parport_enable_irq (port); 55 no_irq = 0; 56 } 57 58 port->physport->ieee1284.phase = IEEE1284_PH_FWD_DATA; 59 parport_write_control (port, ctl); 60 parport_data_forward (port); 61 while (count < len) { 62 unsigned long expire = jiffies + dev->timeout; 63 long wait = msecs_to_jiffies(10); 64 unsigned char mask = (PARPORT_STATUS_ERROR 65 | PARPORT_STATUS_BUSY); 66 unsigned char val = (PARPORT_STATUS_ERROR 67 | PARPORT_STATUS_BUSY); 68 69 /* Wait until the peripheral's ready */ 70 do { 71 /* Is the peripheral ready yet? */ 72 if (!parport_wait_peripheral (port, mask, val)) 73 /* Skip the loop */ 74 goto ready; 75 76 /* Is the peripheral upset? */ 77 if ((parport_read_status (port) & 78 (PARPORT_STATUS_PAPEROUT | 79 PARPORT_STATUS_SELECT | 80 PARPORT_STATUS_ERROR)) 81 != (PARPORT_STATUS_SELECT | 82 PARPORT_STATUS_ERROR)) 83 /* If nFault is asserted (i.e. no 84 * error) and PAPEROUT and SELECT are 85 * just red herrings, give the driver 86 * a chance to check it's happy with 87 * that before continuing. */ 88 goto stop; 89 90 /* Have we run out of time? */ 91 if (!time_before (jiffies, expire)) 92 break; 93 94 /* Yield the port for a while. If this is the 95 first time around the loop, don't let go of 96 the port. This way, we find out if we have 97 our interrupt handler called. */ 98 if (count && no_irq) { 99 parport_release (dev); 100 schedule_timeout_interruptible(wait); 101 parport_claim_or_block (dev); 102 } 103 else 104 /* We must have the device claimed here */ 105 parport_wait_event (port, wait); 106 107 /* Is there a signal pending? */ 108 if (signal_pending (current)) 109 break; 110 111 /* Wait longer next time. */ 112 wait *= 2; 113 } while (time_before (jiffies, expire)); 114 115 if (signal_pending (current)) 116 break; 117 118 DPRINTK (KERN_DEBUG "%s: Timed out\n", port->name); 119 break; 120 121 ready: 122 /* Write the character to the data lines. */ 123 byte = *addr++; 124 parport_write_data (port, byte); 125 udelay (1); 126 127 /* Pulse strobe. */ 128 parport_write_control (port, ctl | PARPORT_CONTROL_STROBE); 129 udelay (1); /* strobe */ 130 131 parport_write_control (port, ctl); 132 udelay (1); /* hold */ 133 134 /* Assume the peripheral received it. */ 135 count++; 136 137 /* Let another process run if it needs to. */ 138 if (time_before (jiffies, expire)) 139 if (!parport_yield_blocking (dev) 140 && need_resched()) 141 schedule (); 142 } 143 stop: 144 port->physport->ieee1284.phase = IEEE1284_PH_FWD_IDLE; 145 146 return count; 147 } 148 149 /* Nibble mode. */ 150 size_t parport_ieee1284_read_nibble (struct parport *port, 151 void *buffer, size_t len, 152 int flags) 153 { 154 #ifndef CONFIG_PARPORT_1284 155 return 0; 156 #else 157 unsigned char *buf = buffer; 158 int i; 159 unsigned char byte = 0; 160 161 len *= 2; /* in nibbles */ 162 for (i=0; i < len; i++) { 163 unsigned char nibble; 164 165 /* Does the error line indicate end of data? */ 166 if (((i & 1) == 0) && 167 (parport_read_status(port) & PARPORT_STATUS_ERROR)) { 168 goto end_of_data; 169 } 170 171 /* Event 7: Set nAutoFd low. */ 172 parport_frob_control (port, 173 PARPORT_CONTROL_AUTOFD, 174 PARPORT_CONTROL_AUTOFD); 175 176 /* Event 9: nAck goes low. */ 177 port->ieee1284.phase = IEEE1284_PH_REV_DATA; 178 if (parport_wait_peripheral (port, 179 PARPORT_STATUS_ACK, 0)) { 180 /* Timeout -- no more data? */ 181 DPRINTK (KERN_DEBUG 182 "%s: Nibble timeout at event 9 (%d bytes)\n", 183 port->name, i/2); 184 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0); 185 break; 186 } 187 188 189 /* Read a nibble. */ 190 nibble = parport_read_status (port) >> 3; 191 nibble &= ~8; 192 if ((nibble & 0x10) == 0) 193 nibble |= 8; 194 nibble &= 0xf; 195 196 /* Event 10: Set nAutoFd high. */ 197 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0); 198 199 /* Event 11: nAck goes high. */ 200 if (parport_wait_peripheral (port, 201 PARPORT_STATUS_ACK, 202 PARPORT_STATUS_ACK)) { 203 /* Timeout -- no more data? */ 204 DPRINTK (KERN_DEBUG 205 "%s: Nibble timeout at event 11\n", 206 port->name); 207 break; 208 } 209 210 if (i & 1) { 211 /* Second nibble */ 212 byte |= nibble << 4; 213 *buf++ = byte; 214 } else 215 byte = nibble; 216 } 217 218 if (i == len) { 219 /* Read the last nibble without checking data avail. */ 220 if (parport_read_status (port) & PARPORT_STATUS_ERROR) { 221 end_of_data: 222 DPRINTK (KERN_DEBUG 223 "%s: No more nibble data (%d bytes)\n", 224 port->name, i/2); 225 226 /* Go to reverse idle phase. */ 227 parport_frob_control (port, 228 PARPORT_CONTROL_AUTOFD, 229 PARPORT_CONTROL_AUTOFD); 230 port->physport->ieee1284.phase = IEEE1284_PH_REV_IDLE; 231 } 232 else 233 port->physport->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL; 234 } 235 236 return i/2; 237 #endif /* IEEE1284 support */ 238 } 239 240 /* Byte mode. */ 241 size_t parport_ieee1284_read_byte (struct parport *port, 242 void *buffer, size_t len, 243 int flags) 244 { 245 #ifndef CONFIG_PARPORT_1284 246 return 0; 247 #else 248 unsigned char *buf = buffer; 249 ssize_t count = 0; 250 251 for (count = 0; count < len; count++) { 252 unsigned char byte; 253 254 /* Data available? */ 255 if (parport_read_status (port) & PARPORT_STATUS_ERROR) { 256 goto end_of_data; 257 } 258 259 /* Event 14: Place data bus in high impedance state. */ 260 parport_data_reverse (port); 261 262 /* Event 7: Set nAutoFd low. */ 263 parport_frob_control (port, 264 PARPORT_CONTROL_AUTOFD, 265 PARPORT_CONTROL_AUTOFD); 266 267 /* Event 9: nAck goes low. */ 268 port->physport->ieee1284.phase = IEEE1284_PH_REV_DATA; 269 if (parport_wait_peripheral (port, 270 PARPORT_STATUS_ACK, 271 0)) { 272 /* Timeout -- no more data? */ 273 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 274 0); 275 DPRINTK (KERN_DEBUG "%s: Byte timeout at event 9\n", 276 port->name); 277 break; 278 } 279 280 byte = parport_read_data (port); 281 *buf++ = byte; 282 283 /* Event 10: Set nAutoFd high */ 284 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0); 285 286 /* Event 11: nAck goes high. */ 287 if (parport_wait_peripheral (port, 288 PARPORT_STATUS_ACK, 289 PARPORT_STATUS_ACK)) { 290 /* Timeout -- no more data? */ 291 DPRINTK (KERN_DEBUG "%s: Byte timeout at event 11\n", 292 port->name); 293 break; 294 } 295 296 /* Event 16: Set nStrobe low. */ 297 parport_frob_control (port, 298 PARPORT_CONTROL_STROBE, 299 PARPORT_CONTROL_STROBE); 300 udelay (5); 301 302 /* Event 17: Set nStrobe high. */ 303 parport_frob_control (port, PARPORT_CONTROL_STROBE, 0); 304 } 305 306 if (count == len) { 307 /* Read the last byte without checking data avail. */ 308 if (parport_read_status (port) & PARPORT_STATUS_ERROR) { 309 end_of_data: 310 DPRINTK (KERN_DEBUG 311 "%s: No more byte data (%Zd bytes)\n", 312 port->name, count); 313 314 /* Go to reverse idle phase. */ 315 parport_frob_control (port, 316 PARPORT_CONTROL_AUTOFD, 317 PARPORT_CONTROL_AUTOFD); 318 port->physport->ieee1284.phase = IEEE1284_PH_REV_IDLE; 319 } 320 else 321 port->physport->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL; 322 } 323 324 return count; 325 #endif /* IEEE1284 support */ 326 } 327 328 /*** * 329 * ECP Functions. * 330 * ***/ 331 332 #ifdef CONFIG_PARPORT_1284 333 334 static inline 335 int ecp_forward_to_reverse (struct parport *port) 336 { 337 int retval; 338 339 /* Event 38: Set nAutoFd low */ 340 parport_frob_control (port, 341 PARPORT_CONTROL_AUTOFD, 342 PARPORT_CONTROL_AUTOFD); 343 parport_data_reverse (port); 344 udelay (5); 345 346 /* Event 39: Set nInit low to initiate bus reversal */ 347 parport_frob_control (port, 348 PARPORT_CONTROL_INIT, 349 0); 350 351 /* Event 40: PError goes low */ 352 retval = parport_wait_peripheral (port, 353 PARPORT_STATUS_PAPEROUT, 0); 354 355 if (!retval) { 356 DPRINTK (KERN_DEBUG "%s: ECP direction: reverse\n", 357 port->name); 358 port->ieee1284.phase = IEEE1284_PH_REV_IDLE; 359 } else { 360 DPRINTK (KERN_DEBUG "%s: ECP direction: failed to reverse\n", 361 port->name); 362 port->ieee1284.phase = IEEE1284_PH_ECP_DIR_UNKNOWN; 363 } 364 365 return retval; 366 } 367 368 static inline 369 int ecp_reverse_to_forward (struct parport *port) 370 { 371 int retval; 372 373 /* Event 47: Set nInit high */ 374 parport_frob_control (port, 375 PARPORT_CONTROL_INIT 376 | PARPORT_CONTROL_AUTOFD, 377 PARPORT_CONTROL_INIT 378 | PARPORT_CONTROL_AUTOFD); 379 380 /* Event 49: PError goes high */ 381 retval = parport_wait_peripheral (port, 382 PARPORT_STATUS_PAPEROUT, 383 PARPORT_STATUS_PAPEROUT); 384 385 if (!retval) { 386 parport_data_forward (port); 387 DPRINTK (KERN_DEBUG "%s: ECP direction: forward\n", 388 port->name); 389 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE; 390 } else { 391 DPRINTK (KERN_DEBUG 392 "%s: ECP direction: failed to switch forward\n", 393 port->name); 394 port->ieee1284.phase = IEEE1284_PH_ECP_DIR_UNKNOWN; 395 } 396 397 398 return retval; 399 } 400 401 #endif /* IEEE1284 support */ 402 403 /* ECP mode, forward channel, data. */ 404 size_t parport_ieee1284_ecp_write_data (struct parport *port, 405 const void *buffer, size_t len, 406 int flags) 407 { 408 #ifndef CONFIG_PARPORT_1284 409 return 0; 410 #else 411 const unsigned char *buf = buffer; 412 size_t written; 413 int retry; 414 415 port = port->physport; 416 417 if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE) 418 if (ecp_reverse_to_forward (port)) 419 return 0; 420 421 port->ieee1284.phase = IEEE1284_PH_FWD_DATA; 422 423 /* HostAck high (data, not command) */ 424 parport_frob_control (port, 425 PARPORT_CONTROL_AUTOFD 426 | PARPORT_CONTROL_STROBE 427 | PARPORT_CONTROL_INIT, 428 PARPORT_CONTROL_INIT); 429 for (written = 0; written < len; written++, buf++) { 430 unsigned long expire = jiffies + port->cad->timeout; 431 unsigned char byte; 432 433 byte = *buf; 434 try_again: 435 parport_write_data (port, byte); 436 parport_frob_control (port, PARPORT_CONTROL_STROBE, 437 PARPORT_CONTROL_STROBE); 438 udelay (5); 439 for (retry = 0; retry < 100; retry++) { 440 if (!parport_wait_peripheral (port, 441 PARPORT_STATUS_BUSY, 0)) 442 goto success; 443 444 if (signal_pending (current)) { 445 parport_frob_control (port, 446 PARPORT_CONTROL_STROBE, 447 0); 448 break; 449 } 450 } 451 452 /* Time for Host Transfer Recovery (page 41 of IEEE1284) */ 453 DPRINTK (KERN_DEBUG "%s: ECP transfer stalled!\n", port->name); 454 455 parport_frob_control (port, PARPORT_CONTROL_INIT, 456 PARPORT_CONTROL_INIT); 457 udelay (50); 458 if (parport_read_status (port) & PARPORT_STATUS_PAPEROUT) { 459 /* It's buggered. */ 460 parport_frob_control (port, PARPORT_CONTROL_INIT, 0); 461 break; 462 } 463 464 parport_frob_control (port, PARPORT_CONTROL_INIT, 0); 465 udelay (50); 466 if (!(parport_read_status (port) & PARPORT_STATUS_PAPEROUT)) 467 break; 468 469 DPRINTK (KERN_DEBUG "%s: Host transfer recovered\n", 470 port->name); 471 472 if (time_after_eq (jiffies, expire)) break; 473 goto try_again; 474 success: 475 parport_frob_control (port, PARPORT_CONTROL_STROBE, 0); 476 udelay (5); 477 if (parport_wait_peripheral (port, 478 PARPORT_STATUS_BUSY, 479 PARPORT_STATUS_BUSY)) 480 /* Peripheral hasn't accepted the data. */ 481 break; 482 } 483 484 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE; 485 486 return written; 487 #endif /* IEEE1284 support */ 488 } 489 490 /* ECP mode, reverse channel, data. */ 491 size_t parport_ieee1284_ecp_read_data (struct parport *port, 492 void *buffer, size_t len, int flags) 493 { 494 #ifndef CONFIG_PARPORT_1284 495 return 0; 496 #else 497 struct pardevice *dev = port->cad; 498 unsigned char *buf = buffer; 499 int rle_count = 0; /* shut gcc up */ 500 unsigned char ctl; 501 int rle = 0; 502 ssize_t count = 0; 503 504 port = port->physport; 505 506 if (port->ieee1284.phase != IEEE1284_PH_REV_IDLE) 507 if (ecp_forward_to_reverse (port)) 508 return 0; 509 510 port->ieee1284.phase = IEEE1284_PH_REV_DATA; 511 512 /* Set HostAck low to start accepting data. */ 513 ctl = parport_read_control (port); 514 ctl &= ~(PARPORT_CONTROL_STROBE | PARPORT_CONTROL_INIT | 515 PARPORT_CONTROL_AUTOFD); 516 parport_write_control (port, 517 ctl | PARPORT_CONTROL_AUTOFD); 518 while (count < len) { 519 unsigned long expire = jiffies + dev->timeout; 520 unsigned char byte; 521 int command; 522 523 /* Event 43: Peripheral sets nAck low. It can take as 524 long as it wants. */ 525 while (parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0)) { 526 /* The peripheral hasn't given us data in 527 35ms. If we have data to give back to the 528 caller, do it now. */ 529 if (count) 530 goto out; 531 532 /* If we've used up all the time we were allowed, 533 give up altogether. */ 534 if (!time_before (jiffies, expire)) 535 goto out; 536 537 /* Yield the port for a while. */ 538 if (count && dev->port->irq != PARPORT_IRQ_NONE) { 539 parport_release (dev); 540 schedule_timeout_interruptible(msecs_to_jiffies(40)); 541 parport_claim_or_block (dev); 542 } 543 else 544 /* We must have the device claimed here. */ 545 parport_wait_event (port, msecs_to_jiffies(40)); 546 547 /* Is there a signal pending? */ 548 if (signal_pending (current)) 549 goto out; 550 } 551 552 /* Is this a command? */ 553 if (rle) 554 /* The last byte was a run-length count, so 555 this can't be as well. */ 556 command = 0; 557 else 558 command = (parport_read_status (port) & 559 PARPORT_STATUS_BUSY) ? 1 : 0; 560 561 /* Read the data. */ 562 byte = parport_read_data (port); 563 564 /* If this is a channel command, rather than an RLE 565 command or a normal data byte, don't accept it. */ 566 if (command) { 567 if (byte & 0x80) { 568 DPRINTK (KERN_DEBUG "%s: stopping short at " 569 "channel command (%02x)\n", 570 port->name, byte); 571 goto out; 572 } 573 else if (port->ieee1284.mode != IEEE1284_MODE_ECPRLE) 574 DPRINTK (KERN_DEBUG "%s: device illegally " 575 "using RLE; accepting anyway\n", 576 port->name); 577 578 rle_count = byte + 1; 579 580 /* Are we allowed to read that many bytes? */ 581 if (rle_count > (len - count)) { 582 DPRINTK (KERN_DEBUG "%s: leaving %d RLE bytes " 583 "for next time\n", port->name, 584 rle_count); 585 break; 586 } 587 588 rle = 1; 589 } 590 591 /* Event 44: Set HostAck high, acknowledging handshake. */ 592 parport_write_control (port, ctl); 593 594 /* Event 45: The peripheral has 35ms to set nAck high. */ 595 if (parport_wait_peripheral (port, PARPORT_STATUS_ACK, 596 PARPORT_STATUS_ACK)) { 597 /* It's gone wrong. Return what data we have 598 to the caller. */ 599 DPRINTK (KERN_DEBUG "ECP read timed out at 45\n"); 600 601 if (command) 602 printk (KERN_WARNING 603 "%s: command ignored (%02x)\n", 604 port->name, byte); 605 606 break; 607 } 608 609 /* Event 46: Set HostAck low and accept the data. */ 610 parport_write_control (port, 611 ctl | PARPORT_CONTROL_AUTOFD); 612 613 /* If we just read a run-length count, fetch the data. */ 614 if (command) 615 continue; 616 617 /* If this is the byte after a run-length count, decompress. */ 618 if (rle) { 619 rle = 0; 620 memset (buf, byte, rle_count); 621 buf += rle_count; 622 count += rle_count; 623 DPRINTK (KERN_DEBUG "%s: decompressed to %d bytes\n", 624 port->name, rle_count); 625 } else { 626 /* Normal data byte. */ 627 *buf = byte; 628 buf++, count++; 629 } 630 } 631 632 out: 633 port->ieee1284.phase = IEEE1284_PH_REV_IDLE; 634 return count; 635 #endif /* IEEE1284 support */ 636 } 637 638 /* ECP mode, forward channel, commands. */ 639 size_t parport_ieee1284_ecp_write_addr (struct parport *port, 640 const void *buffer, size_t len, 641 int flags) 642 { 643 #ifndef CONFIG_PARPORT_1284 644 return 0; 645 #else 646 const unsigned char *buf = buffer; 647 size_t written; 648 int retry; 649 650 port = port->physport; 651 652 if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE) 653 if (ecp_reverse_to_forward (port)) 654 return 0; 655 656 port->ieee1284.phase = IEEE1284_PH_FWD_DATA; 657 658 /* HostAck low (command, not data) */ 659 parport_frob_control (port, 660 PARPORT_CONTROL_AUTOFD 661 | PARPORT_CONTROL_STROBE 662 | PARPORT_CONTROL_INIT, 663 PARPORT_CONTROL_AUTOFD 664 | PARPORT_CONTROL_INIT); 665 for (written = 0; written < len; written++, buf++) { 666 unsigned long expire = jiffies + port->cad->timeout; 667 unsigned char byte; 668 669 byte = *buf; 670 try_again: 671 parport_write_data (port, byte); 672 parport_frob_control (port, PARPORT_CONTROL_STROBE, 673 PARPORT_CONTROL_STROBE); 674 udelay (5); 675 for (retry = 0; retry < 100; retry++) { 676 if (!parport_wait_peripheral (port, 677 PARPORT_STATUS_BUSY, 0)) 678 goto success; 679 680 if (signal_pending (current)) { 681 parport_frob_control (port, 682 PARPORT_CONTROL_STROBE, 683 0); 684 break; 685 } 686 } 687 688 /* Time for Host Transfer Recovery (page 41 of IEEE1284) */ 689 DPRINTK (KERN_DEBUG "%s: ECP transfer stalled!\n", port->name); 690 691 parport_frob_control (port, PARPORT_CONTROL_INIT, 692 PARPORT_CONTROL_INIT); 693 udelay (50); 694 if (parport_read_status (port) & PARPORT_STATUS_PAPEROUT) { 695 /* It's buggered. */ 696 parport_frob_control (port, PARPORT_CONTROL_INIT, 0); 697 break; 698 } 699 700 parport_frob_control (port, PARPORT_CONTROL_INIT, 0); 701 udelay (50); 702 if (!(parport_read_status (port) & PARPORT_STATUS_PAPEROUT)) 703 break; 704 705 DPRINTK (KERN_DEBUG "%s: Host transfer recovered\n", 706 port->name); 707 708 if (time_after_eq (jiffies, expire)) break; 709 goto try_again; 710 success: 711 parport_frob_control (port, PARPORT_CONTROL_STROBE, 0); 712 udelay (5); 713 if (parport_wait_peripheral (port, 714 PARPORT_STATUS_BUSY, 715 PARPORT_STATUS_BUSY)) 716 /* Peripheral hasn't accepted the data. */ 717 break; 718 } 719 720 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE; 721 722 return written; 723 #endif /* IEEE1284 support */ 724 } 725 726 /*** * 727 * EPP functions. * 728 * ***/ 729 730 /* EPP mode, forward channel, data. */ 731 size_t parport_ieee1284_epp_write_data (struct parport *port, 732 const void *buffer, size_t len, 733 int flags) 734 { 735 unsigned char *bp = (unsigned char *) buffer; 736 size_t ret = 0; 737 738 /* set EPP idle state (just to make sure) with strobe low */ 739 parport_frob_control (port, 740 PARPORT_CONTROL_STROBE | 741 PARPORT_CONTROL_AUTOFD | 742 PARPORT_CONTROL_SELECT | 743 PARPORT_CONTROL_INIT, 744 PARPORT_CONTROL_STROBE | 745 PARPORT_CONTROL_INIT); 746 port->ops->data_forward (port); 747 for (; len > 0; len--, bp++) { 748 /* Event 62: Write data and set autofd low */ 749 parport_write_data (port, *bp); 750 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 751 PARPORT_CONTROL_AUTOFD); 752 753 /* Event 58: wait for busy (nWait) to go high */ 754 if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 0, 10)) 755 break; 756 757 /* Event 63: set nAutoFd (nDStrb) high */ 758 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0); 759 760 /* Event 60: wait for busy (nWait) to go low */ 761 if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 762 PARPORT_STATUS_BUSY, 5)) 763 break; 764 765 ret++; 766 } 767 768 /* Event 61: set strobe (nWrite) high */ 769 parport_frob_control (port, PARPORT_CONTROL_STROBE, 0); 770 771 return ret; 772 } 773 774 /* EPP mode, reverse channel, data. */ 775 size_t parport_ieee1284_epp_read_data (struct parport *port, 776 void *buffer, size_t len, 777 int flags) 778 { 779 unsigned char *bp = (unsigned char *) buffer; 780 unsigned ret = 0; 781 782 /* set EPP idle state (just to make sure) with strobe high */ 783 parport_frob_control (port, 784 PARPORT_CONTROL_STROBE | 785 PARPORT_CONTROL_AUTOFD | 786 PARPORT_CONTROL_SELECT | 787 PARPORT_CONTROL_INIT, 788 PARPORT_CONTROL_INIT); 789 port->ops->data_reverse (port); 790 for (; len > 0; len--, bp++) { 791 /* Event 67: set nAutoFd (nDStrb) low */ 792 parport_frob_control (port, 793 PARPORT_CONTROL_AUTOFD, 794 PARPORT_CONTROL_AUTOFD); 795 /* Event 58: wait for Busy to go high */ 796 if (parport_wait_peripheral (port, PARPORT_STATUS_BUSY, 0)) { 797 break; 798 } 799 800 *bp = parport_read_data (port); 801 802 /* Event 63: set nAutoFd (nDStrb) high */ 803 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0); 804 805 /* Event 60: wait for Busy to go low */ 806 if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 807 PARPORT_STATUS_BUSY, 5)) { 808 break; 809 } 810 811 ret++; 812 } 813 port->ops->data_forward (port); 814 815 return ret; 816 } 817 818 /* EPP mode, forward channel, addresses. */ 819 size_t parport_ieee1284_epp_write_addr (struct parport *port, 820 const void *buffer, size_t len, 821 int flags) 822 { 823 unsigned char *bp = (unsigned char *) buffer; 824 size_t ret = 0; 825 826 /* set EPP idle state (just to make sure) with strobe low */ 827 parport_frob_control (port, 828 PARPORT_CONTROL_STROBE | 829 PARPORT_CONTROL_AUTOFD | 830 PARPORT_CONTROL_SELECT | 831 PARPORT_CONTROL_INIT, 832 PARPORT_CONTROL_STROBE | 833 PARPORT_CONTROL_INIT); 834 port->ops->data_forward (port); 835 for (; len > 0; len--, bp++) { 836 /* Event 56: Write data and set nAStrb low. */ 837 parport_write_data (port, *bp); 838 parport_frob_control (port, PARPORT_CONTROL_SELECT, 839 PARPORT_CONTROL_SELECT); 840 841 /* Event 58: wait for busy (nWait) to go high */ 842 if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 0, 10)) 843 break; 844 845 /* Event 59: set nAStrb high */ 846 parport_frob_control (port, PARPORT_CONTROL_SELECT, 0); 847 848 /* Event 60: wait for busy (nWait) to go low */ 849 if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 850 PARPORT_STATUS_BUSY, 5)) 851 break; 852 853 ret++; 854 } 855 856 /* Event 61: set strobe (nWrite) high */ 857 parport_frob_control (port, PARPORT_CONTROL_STROBE, 0); 858 859 return ret; 860 } 861 862 /* EPP mode, reverse channel, addresses. */ 863 size_t parport_ieee1284_epp_read_addr (struct parport *port, 864 void *buffer, size_t len, 865 int flags) 866 { 867 unsigned char *bp = (unsigned char *) buffer; 868 unsigned ret = 0; 869 870 /* Set EPP idle state (just to make sure) with strobe high */ 871 parport_frob_control (port, 872 PARPORT_CONTROL_STROBE | 873 PARPORT_CONTROL_AUTOFD | 874 PARPORT_CONTROL_SELECT | 875 PARPORT_CONTROL_INIT, 876 PARPORT_CONTROL_INIT); 877 port->ops->data_reverse (port); 878 for (; len > 0; len--, bp++) { 879 /* Event 64: set nSelectIn (nAStrb) low */ 880 parport_frob_control (port, PARPORT_CONTROL_SELECT, 881 PARPORT_CONTROL_SELECT); 882 883 /* Event 58: wait for Busy to go high */ 884 if (parport_wait_peripheral (port, PARPORT_STATUS_BUSY, 0)) { 885 break; 886 } 887 888 *bp = parport_read_data (port); 889 890 /* Event 59: set nSelectIn (nAStrb) high */ 891 parport_frob_control (port, PARPORT_CONTROL_SELECT, 892 PARPORT_CONTROL_SELECT); 893 894 /* Event 60: wait for Busy to go low */ 895 if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 896 PARPORT_STATUS_BUSY, 5)) 897 break; 898 899 ret++; 900 } 901 port->ops->data_forward (port); 902 903 return ret; 904 } 905 906 EXPORT_SYMBOL(parport_ieee1284_ecp_write_data); 907 EXPORT_SYMBOL(parport_ieee1284_ecp_read_data); 908 EXPORT_SYMBOL(parport_ieee1284_ecp_write_addr); 909 EXPORT_SYMBOL(parport_ieee1284_write_compat); 910 EXPORT_SYMBOL(parport_ieee1284_read_nibble); 911 EXPORT_SYMBOL(parport_ieee1284_read_byte); 912 EXPORT_SYMBOL(parport_ieee1284_epp_write_data); 913 EXPORT_SYMBOL(parport_ieee1284_epp_read_data); 914 EXPORT_SYMBOL(parport_ieee1284_epp_write_addr); 915 EXPORT_SYMBOL(parport_ieee1284_epp_read_addr); 916