drivers/parport/ieee1284_ops.c

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