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/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                         port->physport->ieee1284.phase = IEEE1284_PH_HBUSY_DNA;
 169                         DPRINTK (KERN_DEBUG
 170                                 "%s: No more nibble data (%d bytes)\n",
 171                                 port->name, i/2);
 172
 173                         /* Go to reverse idle phase. */
 174                         parport_frob_control (port,
 175                                               PARPORT_CONTROL_AUTOFD,
 176                                               PARPORT_CONTROL_AUTOFD);
 177                         port->physport->ieee1284.phase = IEEE1284_PH_REV_IDLE;
 178                         break;
 179                 }
 180
 181                 /* Event 7: Set nAutoFd low. */
 182                 parport_frob_control (port,
 183                                       PARPORT_CONTROL_AUTOFD,
 184                                       PARPORT_CONTROL_AUTOFD);
 185
 186                 /* Event 9: nAck goes low. */
 187                 port->ieee1284.phase = IEEE1284_PH_REV_DATA;
 188                 if (parport_wait_peripheral (port,
 189                                              PARPORT_STATUS_ACK, 0)) {
 190                         /* Timeout -- no more data? */
 191                         DPRINTK (KERN_DEBUG
 192                                  "%s: Nibble timeout at event 9 (%d bytes)\n",
 193                                  port->name, i/2);
 194                         parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
 195                         break;
 196                 }
 197
 198
 199                 /* Read a nibble. */
 200                 nibble = parport_read_status (port) >> 3;
 201                 nibble &= ~8;
 202                 if ((nibble & 0x10) == 0)
 203                         nibble |= 8;
 204                 nibble &= 0xf;
 205
 206                 /* Event 10: Set nAutoFd high. */
 207                 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
 208
 209                 /* Event 11: nAck goes high. */
 210                 if (parport_wait_peripheral (port,
 211                                              PARPORT_STATUS_ACK,
 212                                              PARPORT_STATUS_ACK)) {
 213                         /* Timeout -- no more data? */
 214                         DPRINTK (KERN_DEBUG
 215                                  "%s: Nibble timeout at event 11\n",
 216                                  port->name);
 217                         break;
 218                 }
 219
 220                 if (i & 1) {
 221                         /* Second nibble */
 222                         byte |= nibble << 4;
 223                         *buf++ = byte;
 224                 } else
 225                         byte = nibble;
 226         }
 227
 228         i /= 2; /* i is now in bytes */
 229
 230         if (i == len) {
 231                 /* Read the last nibble without checking data avail. */
 232                 port = port->physport;
 233                 if (parport_read_status (port) & PARPORT_STATUS_ERROR)
 234                         port->ieee1284.phase = IEEE1284_PH_HBUSY_DNA;
 235                 else
 236                         port->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL;
 237         }
 238
 239         return i;
 240 #endif /* IEEE1284 support */
 241 }
 242
 243 /* Byte mode. */
 244 size_t parport_ieee1284_read_byte (struct parport *port,
 245                                    void *buffer, size_t len,
 246                                    int flags)
 247 {
 248 #ifndef CONFIG_PARPORT_1284
 249         return 0;
 250 #else
 251         unsigned char *buf = buffer;
 252         ssize_t count = 0;
 253
 254         for (count = 0; count < len; count++) {
 255                 unsigned char byte;
 256
 257                 /* Data available? */
 258                 if (parport_read_status (port) & PARPORT_STATUS_ERROR) {
 259                         port->physport->ieee1284.phase = IEEE1284_PH_HBUSY_DNA;
 260                         DPRINTK (KERN_DEBUG
 261                                  "%s: No more byte data (%Zd bytes)\n",
 262                                  port->name, count);
 263
 264                         /* Go to reverse idle phase. */
 265                         parport_frob_control (port,
 266                                               PARPORT_CONTROL_AUTOFD,
 267                                               PARPORT_CONTROL_AUTOFD);
 268                         port->physport->ieee1284.phase = IEEE1284_PH_REV_IDLE;
 269                         break;
 270                 }
 271
 272                 /* Event 14: Place data bus in high impedance state. */
 273                 parport_data_reverse (port);
 274
 275                 /* Event 7: Set nAutoFd low. */
 276                 parport_frob_control (port,
 277                                       PARPORT_CONTROL_AUTOFD,
 278                                       PARPORT_CONTROL_AUTOFD);
 279
 280                 /* Event 9: nAck goes low. */
 281                 port->physport->ieee1284.phase = IEEE1284_PH_REV_DATA;
 282                 if (parport_wait_peripheral (port,
 283                                              PARPORT_STATUS_ACK,
 284                                              0)) {
 285                         /* Timeout -- no more data? */
 286                         parport_frob_control (port, PARPORT_CONTROL_AUTOFD,
 287                                                  0);
 288                         DPRINTK (KERN_DEBUG "%s: Byte timeout at event 9\n",
 289                                  port->name);
 290                         break;
 291                 }
 292
 293                 byte = parport_read_data (port);
 294                 *buf++ = byte;
 295
 296                 /* Event 10: Set nAutoFd high */
 297                 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
 298
 299                 /* Event 11: nAck goes high. */
 300                 if (parport_wait_peripheral (port,
 301                                              PARPORT_STATUS_ACK,
 302                                              PARPORT_STATUS_ACK)) {
 303                         /* Timeout -- no more data? */
 304                         DPRINTK (KERN_DEBUG "%s: Byte timeout at event 11\n",
 305                                  port->name);
 306                         break;
 307                 }
 308
 309                 /* Event 16: Set nStrobe low. */
 310                 parport_frob_control (port,
 311                                       PARPORT_CONTROL_STROBE,
 312                                       PARPORT_CONTROL_STROBE);
 313                 udelay (5);
 314
 315                 /* Event 17: Set nStrobe high. */
 316                 parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
 317         }
 318
 319         if (count == len) {
 320                 /* Read the last byte without checking data avail. */
 321                 port = port->physport;
 322                 if (parport_read_status (port) & PARPORT_STATUS_ERROR)
 323                         port->ieee1284.phase = IEEE1284_PH_HBUSY_DNA;
 324                 else
 325                         port->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL;
 326         }
 327
 328         return count;
 329 #endif /* IEEE1284 support */
 330 }
 331
 332 /***              *
 333  * ECP Functions. *
 334  *              ***/
 335
 336 #ifdef CONFIG_PARPORT_1284
 337
 338 static inline
 339 int ecp_forward_to_reverse (struct parport *port)
 340 {
 341         int retval;
 342
 343         /* Event 38: Set nAutoFd low */
 344         parport_frob_control (port,
 345                               PARPORT_CONTROL_AUTOFD,
 346                               PARPORT_CONTROL_AUTOFD);
 347         parport_data_reverse (port);
 348         udelay (5);
 349
 350         /* Event 39: Set nInit low to initiate bus reversal */
 351         parport_frob_control (port,
 352                               PARPORT_CONTROL_INIT,
 353                               0);
 354
 355         /* Event 40: PError goes low */
 356         retval = parport_wait_peripheral (port,
 357                                           PARPORT_STATUS_PAPEROUT, 0);
 358
 359         if (!retval) {
 360                 DPRINTK (KERN_DEBUG "%s: ECP direction: reverse\n",
 361                          port->name);
 362                 port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
 363         } else {
 364                 DPRINTK (KERN_DEBUG "%s: ECP direction: failed to reverse\n",
 365                          port->name);
 366                 port->ieee1284.phase = IEEE1284_PH_ECP_DIR_UNKNOWN;
 367         }
 368
 369         return retval;
 370 }
 371
 372 static inline
 373 int ecp_reverse_to_forward (struct parport *port)
 374 {
 375         int retval;
 376
 377         /* Event 47: Set nInit high */
 378         parport_frob_control (port,
 379                               PARPORT_CONTROL_INIT
 380                               | PARPORT_CONTROL_AUTOFD,
 381                               PARPORT_CONTROL_INIT
 382                               | PARPORT_CONTROL_AUTOFD);
 383
 384         /* Event 49: PError goes high */
 385         retval = parport_wait_peripheral (port,
 386                                           PARPORT_STATUS_PAPEROUT,
 387                                           PARPORT_STATUS_PAPEROUT);
 388
 389         if (!retval) {
 390                 parport_data_forward (port);
 391                 DPRINTK (KERN_DEBUG "%s: ECP direction: forward\n",
 392                          port->name);
 393                 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
 394         } else {
 395                 DPRINTK (KERN_DEBUG
 396                          "%s: ECP direction: failed to switch forward\n",
 397                          port->name);
 398                 port->ieee1284.phase = IEEE1284_PH_ECP_DIR_UNKNOWN;
 399         }
 400
 401
 402         return retval;
 403 }
 404
 405 #endif /* IEEE1284 support */
 406
 407 /* ECP mode, forward channel, data. */
 408 size_t parport_ieee1284_ecp_write_data (struct parport *port,
 409                                         const void *buffer, size_t len,
 410                                         int flags)
 411 {
 412 #ifndef CONFIG_PARPORT_1284
 413         return 0;
 414 #else
 415         const unsigned char *buf = buffer;
 416         size_t written;
 417         int retry;
 418
 419         port = port->physport;
 420
 421         if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE)
 422                 if (ecp_reverse_to_forward (port))
 423                         return 0;
 424
 425         port->ieee1284.phase = IEEE1284_PH_FWD_DATA;
 426
 427         /* HostAck high (data, not command) */
 428         parport_frob_control (port,
 429                               PARPORT_CONTROL_AUTOFD
 430                               | PARPORT_CONTROL_STROBE
 431                               | PARPORT_CONTROL_INIT,
 432                               PARPORT_CONTROL_INIT);
 433         for (written = 0; written < len; written++, buf++) {
 434                 unsigned long expire = jiffies + port->cad->timeout;
 435                 unsigned char byte;
 436
 437                 byte = *buf;
 438         try_again:
 439                 parport_write_data (port, byte);
 440                 parport_frob_control (port, PARPORT_CONTROL_STROBE,
 441                                       PARPORT_CONTROL_STROBE);
 442                 udelay (5);
 443                 for (retry = 0; retry < 100; retry++) {
 444                         if (!parport_wait_peripheral (port,
 445                                                       PARPORT_STATUS_BUSY, 0))
 446                                 goto success;
 447
 448                         if (signal_pending (current)) {
 449                                 parport_frob_control (port,
 450                                                       PARPORT_CONTROL_STROBE,
 451                                                       0);
 452                                 break;
 453                         }
 454                 }
 455
 456                 /* Time for Host Transfer Recovery (page 41 of IEEE1284) */
 457                 DPRINTK (KERN_DEBUG "%s: ECP transfer stalled!\n", port->name);
 458
 459                 parport_frob_control (port, PARPORT_CONTROL_INIT,
 460                                       PARPORT_CONTROL_INIT);
 461                 udelay (50);
 462                 if (parport_read_status (port) & PARPORT_STATUS_PAPEROUT) {
 463                         /* It's buggered. */
 464                         parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
 465                         break;
 466                 }
 467
 468                 parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
 469                 udelay (50);
 470                 if (!(parport_read_status (port) & PARPORT_STATUS_PAPEROUT))
 471                         break;
 472
 473                 DPRINTK (KERN_DEBUG "%s: Host transfer recovered\n",
 474                          port->name);
 475
 476                 if (time_after_eq (jiffies, expire)) break;
 477                 goto try_again;
 478         success:
 479                 parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
 480                 udelay (5);
 481                 if (parport_wait_peripheral (port,
 482                                              PARPORT_STATUS_BUSY,
 483                                              PARPORT_STATUS_BUSY))
 484                         /* Peripheral hasn't accepted the data. */
 485                         break;
 486         }
 487
 488         port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
 489
 490         return written;
 491 #endif /* IEEE1284 support */
 492 }
 493
 494 /* ECP mode, reverse channel, data. */
 495 size_t parport_ieee1284_ecp_read_data (struct parport *port,
 496                                        void *buffer, size_t len, int flags)
 497 {
 498 #ifndef CONFIG_PARPORT_1284
 499         return 0;
 500 #else
 501         struct pardevice *dev = port->cad;
 502         unsigned char *buf = buffer;
 503         int rle_count = 0; /* shut gcc up */
 504         unsigned char ctl;
 505         int rle = 0;
 506         ssize_t count = 0;
 507
 508         port = port->physport;
 509
 510         if (port->ieee1284.phase != IEEE1284_PH_REV_IDLE)
 511                 if (ecp_forward_to_reverse (port))
 512                         return 0;
 513
 514         port->ieee1284.phase = IEEE1284_PH_REV_DATA;
 515
 516         /* Set HostAck low to start accepting data. */
 517         ctl = parport_read_control (port);
 518         ctl &= ~(PARPORT_CONTROL_STROBE | PARPORT_CONTROL_INIT |
 519                  PARPORT_CONTROL_AUTOFD);
 520         parport_write_control (port,
 521                                ctl | PARPORT_CONTROL_AUTOFD);
 522         while (count < len) {
 523                 unsigned long expire = jiffies + dev->timeout;
 524                 unsigned char byte;
 525                 int command;
 526
 527                 /* Event 43: Peripheral sets nAck low. It can take as
 528                    long as it wants. */
 529                 while (parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0)) {
 530                         /* The peripheral hasn't given us data in
 531                            35ms.  If we have data to give back to the
 532                            caller, do it now. */
 533                         if (count)
 534                                 goto out;
 535
 536                         /* If we've used up all the time we were allowed,
 537                            give up altogether. */
 538                         if (!time_before (jiffies, expire))
 539                                 goto out;
 540
 541                         /* Yield the port for a while. */
 542                         if (count && dev->port->irq != PARPORT_IRQ_NONE) {
 543                                 parport_release (dev);
 544                                 schedule_timeout_interruptible(msecs_to_jiffies(40));
 545                                 parport_claim_or_block (dev);
 546                         }
 547                         else
 548                                 /* We must have the device claimed here. */
 549                                 parport_wait_event (port, msecs_to_jiffies(40));
 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. */
 643 size_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                 unsigned 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. */
 735 size_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. */
 779 size_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. */
 823 size_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. */
 867 size_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 EXPORT_SYMBOL(parport_ieee1284_ecp_write_data);
 911 EXPORT_SYMBOL(parport_ieee1284_ecp_read_data);
 912 EXPORT_SYMBOL(parport_ieee1284_ecp_write_addr);
 913 EXPORT_SYMBOL(parport_ieee1284_write_compat);
 914 EXPORT_SYMBOL(parport_ieee1284_read_nibble);
 915 EXPORT_SYMBOL(parport_ieee1284_read_byte);
 916 EXPORT_SYMBOL(parport_ieee1284_epp_write_data);
 917 EXPORT_SYMBOL(parport_ieee1284_epp_read_data);
 918 EXPORT_SYMBOL(parport_ieee1284_epp_write_addr);
 919 EXPORT_SYMBOL(parport_ieee1284_epp_read_addr);