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