drivers/parport/ieee1284_ops.c

   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. */
  40 size_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. */
 149 size_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. */
 240 size_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
 333 static inline
 334 int 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
 367 static inline
 368 int 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. */
 403 size_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. */
 490 size_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. */
 638 size_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. */
 730 size_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. */
 774 size_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. */
 818 size_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. */
 862 size_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
 905 EXPORT_SYMBOL(parport_ieee1284_ecp_write_data);
 906 EXPORT_SYMBOL(parport_ieee1284_ecp_read_data);
 907 EXPORT_SYMBOL(parport_ieee1284_ecp_write_addr);
 908 EXPORT_SYMBOL(parport_ieee1284_write_compat);
 909 EXPORT_SYMBOL(parport_ieee1284_read_nibble);
 910 EXPORT_SYMBOL(parport_ieee1284_read_byte);
 911 EXPORT_SYMBOL(parport_ieee1284_epp_write_data);
 912 EXPORT_SYMBOL(parport_ieee1284_epp_read_data);
 913 EXPORT_SYMBOL(parport_ieee1284_epp_write_addr);
 914 EXPORT_SYMBOL(parport_ieee1284_epp_read_addr);