LXR linux/drivers/parport/ieee1284

   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. */
  35size_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. */
 144size_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. */
 232size_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
 322static inline
 323int 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
 354static inline
 355int 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. */
 388size_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. */
 474size_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 (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                                pr_warn("%s: command ignored (%02x)\n",
 583                                        port->name, byte);
 584
 585                        break;
 586                }
 587
 588                /* Event 46: Set HostAck low and accept the data. */
 589                parport_write_control (port,
 590                                       ctl | PARPORT_CONTROL_AUTOFD);
 591
 592                /* If we just read a run-length count, fetch the data. */
 593                if (command)
 594                        continue;
 595
 596                /* If this is the byte after a run-length count, decompress. */
 597                if (rle) {
 598                        rle = 0;
 599                        memset (buf, byte, rle_count);
 600                        buf += rle_count;
 601                        count += rle_count;
 602                        pr_debug("%s: decompressed to %d bytes\n",
 603                                 port->name, rle_count);
 604                } else {
 605                        /* Normal data byte. */
 606                        *buf = byte;
 607                        buf++, count++;
 608                }
 609        }
 610
 611 out:
 612        port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
 613        return count;
 614#endif /* IEEE1284 support */
 615}
 616
 617/* ECP mode, forward channel, commands. */
 618size_t parport_ieee1284_ecp_write_addr (struct parport *port,
 619                                        const void *buffer, size_t len,
 620                                        int flags)
 621{
 622#ifndef CONFIG_PARPORT_1284
 623        return 0;
 624#else
 625        const unsigned char *buf = buffer;
 626        size_t written;
 627        int retry;
 628
 629        port = port->physport;
 630
 631        if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE)
 632                if (ecp_reverse_to_forward (port))
 633                        return 0;
 634
 635        port->ieee1284.phase = IEEE1284_PH_FWD_DATA;
 636
 637        /* HostAck low (command, not data) */
 638        parport_frob_control (port,
 639                              PARPORT_CONTROL_AUTOFD
 640                              | PARPORT_CONTROL_STROBE
 641                              | PARPORT_CONTROL_INIT,
 642                              PARPORT_CONTROL_AUTOFD
 643                              | PARPORT_CONTROL_INIT);
 644        for (written = 0; written < len; written++, buf++) {
 645                unsigned long expire = jiffies + port->cad->timeout;
 646                unsigned char byte;
 647
 648                byte = *buf;
 649        try_again:
 650                parport_write_data (port, byte);
 651                parport_frob_control (port, PARPORT_CONTROL_STROBE,
 652                                      PARPORT_CONTROL_STROBE);
 653                udelay (5);
 654                for (retry = 0; retry < 100; retry++) {
 655                        if (!parport_wait_peripheral (port,
 656                                                      PARPORT_STATUS_BUSY, 0))
 657                                goto success;
 658
 659                        if (signal_pending (current)) {
 660                                parport_frob_control (port,
 661                                                      PARPORT_CONTROL_STROBE,
 662                                                      0);
 663                                break;
 664                        }
 665                }
 666
 667                /* Time for Host Transfer Recovery (page 41 of IEEE1284) */
 668                pr_debug("%s: ECP transfer stalled!\n", port->name);
 669
 670                parport_frob_control (port, PARPORT_CONTROL_INIT,
 671                                      PARPORT_CONTROL_INIT);
 672                udelay (50);
 673                if (parport_read_status (port) & PARPORT_STATUS_PAPEROUT) {
 674                        /* It's buggered. */
 675                        parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
 676                        break;
 677                }
 678
 679                parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
 680                udelay (50);
 681                if (!(parport_read_status (port) & PARPORT_STATUS_PAPEROUT))
 682                        break;
 683
 684                pr_debug("%s: Host transfer recovered\n", port->name);
 685
 686                if (time_after_eq (jiffies, expire)) break;
 687                goto try_again;
 688        success:
 689                parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
 690                udelay (5);
 691                if (parport_wait_peripheral (port,
 692                                             PARPORT_STATUS_BUSY,
 693                                             PARPORT_STATUS_BUSY))
 694                        /* Peripheral hasn't accepted the data. */
 695                        break;
 696        }
 697
 698        port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
 699
 700        return written;
 701#endif /* IEEE1284 support */
 702}
 703
 704/***              *
 705 * EPP functions. *
 706 *              ***/
 707
 708/* EPP mode, forward channel, data. */
 709size_t parport_ieee1284_epp_write_data (struct parport *port,
 710                                        const void *buffer, size_t len,
 711                                        int flags)
 712{
 713        unsigned char *bp = (unsigned char *) buffer;
 714        size_t ret = 0;
 715
 716        /* set EPP idle state (just to make sure) with strobe low */
 717        parport_frob_control (port,
 718                              PARPORT_CONTROL_STROBE |
 719                              PARPORT_CONTROL_AUTOFD |
 720                              PARPORT_CONTROL_SELECT |
 721                              PARPORT_CONTROL_INIT,
 722                              PARPORT_CONTROL_STROBE |
 723                              PARPORT_CONTROL_INIT);
 724        port->ops->data_forward (port);
 725        for (; len > 0; len--, bp++) {
 726                /* Event 62: Write data and set autofd low */
 727                parport_write_data (port, *bp);
 728                parport_frob_control (port, PARPORT_CONTROL_AUTOFD,
 729                                      PARPORT_CONTROL_AUTOFD);
 730
 731                /* Event 58: wait for busy (nWait) to go high */
 732                if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 0, 10))
 733                        break;
 734
 735                /* Event 63: set nAutoFd (nDStrb) high */
 736                parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
 737
 738                /* Event 60: wait for busy (nWait) to go low */
 739                if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY,
 740                                             PARPORT_STATUS_BUSY, 5))
 741                        break;
 742
 743                ret++;
 744        }
 745
 746        /* Event 61: set strobe (nWrite) high */
 747        parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
 748
 749        return ret;
 750}
 751
 752/* EPP mode, reverse channel, data. */
 753size_t parport_ieee1284_epp_read_data (struct parport *port,
 754                                       void *buffer, size_t len,
 755                                       int flags)
 756{
 757        unsigned char *bp = (unsigned char *) buffer;
 758        unsigned ret = 0;
 759
 760        /* set EPP idle state (just to make sure) with strobe high */
 761        parport_frob_control (port,
 762                              PARPORT_CONTROL_STROBE |
 763                              PARPORT_CONTROL_AUTOFD |
 764                              PARPORT_CONTROL_SELECT |
 765                              PARPORT_CONTROL_INIT,
 766                              PARPORT_CONTROL_INIT);
 767        port->ops->data_reverse (port);
 768        for (; len > 0; len--, bp++) {
 769                /* Event 67: set nAutoFd (nDStrb) low */
 770                parport_frob_control (port,
 771                                      PARPORT_CONTROL_AUTOFD,
 772                                      PARPORT_CONTROL_AUTOFD);
 773                /* Event 58: wait for Busy to go high */
 774                if (parport_wait_peripheral (port, PARPORT_STATUS_BUSY, 0)) {
 775                        break;
 776                }
 777
 778                *bp = parport_read_data (port);
 779
 780                /* Event 63: set nAutoFd (nDStrb) high */
 781                parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
 782
 783                /* Event 60: wait for Busy to go low */
 784                if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY,
 785                                             PARPORT_STATUS_BUSY, 5)) {
 786                        break;
 787                }
 788
 789                ret++;
 790        }
 791        port->ops->data_forward (port);
 792
 793        return ret;
 794}
 795
 796/* EPP mode, forward channel, addresses. */
 797size_t parport_ieee1284_epp_write_addr (struct parport *port,
 798                                        const void *buffer, size_t len,
 799                                        int flags)
 800{
 801        unsigned char *bp = (unsigned char *) buffer;
 802        size_t ret = 0;
 803
 804        /* set EPP idle state (just to make sure) with strobe low */
 805        parport_frob_control (port,
 806                              PARPORT_CONTROL_STROBE |
 807                              PARPORT_CONTROL_AUTOFD |
 808                              PARPORT_CONTROL_SELECT |
 809                              PARPORT_CONTROL_INIT,
 810                              PARPORT_CONTROL_STROBE |
 811                              PARPORT_CONTROL_INIT);
 812        port->ops->data_forward (port);
 813        for (; len > 0; len--, bp++) {
 814                /* Event 56: Write data and set nAStrb low. */
 815                parport_write_data (port, *bp);
 816                parport_frob_control (port, PARPORT_CONTROL_SELECT,
 817                                      PARPORT_CONTROL_SELECT);
 818
 819                /* Event 58: wait for busy (nWait) to go high */
 820                if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 0, 10))
 821                        break;
 822
 823                /* Event 59: set nAStrb high */
 824                parport_frob_control (port, PARPORT_CONTROL_SELECT, 0);
 825
 826                /* Event 60: wait for busy (nWait) to go low */
 827                if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY,
 828                                             PARPORT_STATUS_BUSY, 5))
 829                        break;
 830
 831                ret++;
 832        }
 833
 834        /* Event 61: set strobe (nWrite) high */
 835        parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
 836
 837        return ret;
 838}
 839
 840/* EPP mode, reverse channel, addresses. */
 841size_t parport_ieee1284_epp_read_addr (struct parport *port,
 842                                       void *buffer, size_t len,
 843                                       int flags)
 844{
 845        unsigned char *bp = (unsigned char *) buffer;
 846        unsigned ret = 0;
 847
 848        /* Set EPP idle state (just to make sure) with strobe high */
 849        parport_frob_control (port,
 850                              PARPORT_CONTROL_STROBE |
 851                              PARPORT_CONTROL_AUTOFD |
 852                              PARPORT_CONTROL_SELECT |
 853                              PARPORT_CONTROL_INIT,
 854                              PARPORT_CONTROL_INIT);
 855        port->ops->data_reverse (port);
 856        for (; len > 0; len--, bp++) {
 857                /* Event 64: set nSelectIn (nAStrb) low */
 858                parport_frob_control (port, PARPORT_CONTROL_SELECT,
 859                                      PARPORT_CONTROL_SELECT);
 860
 861                /* Event 58: wait for Busy to go high */
 862                if (parport_wait_peripheral (port, PARPORT_STATUS_BUSY, 0)) {
 863                        break;
 864                }
 865
 866                *bp = parport_read_data (port);
 867
 868                /* Event 59: set nSelectIn (nAStrb) high */
 869                parport_frob_control (port, PARPORT_CONTROL_SELECT,
 870                                      0);
 871
 872                /* Event 60: wait for Busy to go low */
 873                if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 
 874                                             PARPORT_STATUS_BUSY, 5))
 875                        break;
 876
 877                ret++;
 878        }
 879        port->ops->data_forward (port);
 880
 881        return ret;
 882}
 883
 884EXPORT_SYMBOL(parport_ieee1284_ecp_write_data);
 885EXPORT_SYMBOL(parport_ieee1284_ecp_read_data);
 886EXPORT_SYMBOL(parport_ieee1284_ecp_write_addr);
 887EXPORT_SYMBOL(parport_ieee1284_write_compat);
 888EXPORT_SYMBOL(parport_ieee1284_read_nibble);
 889EXPORT_SYMBOL(parport_ieee1284_read_byte);
 890EXPORT_SYMBOL(parport_ieee1284_epp_write_data);
 891EXPORT_SYMBOL(parport_ieee1284_epp_read_data);
 892EXPORT_SYMBOL(parport_ieee1284_epp_write_addr);
 893EXPORT_SYMBOL(parport_ieee1284_epp_read_addr);
 894