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