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