LXR linux/drivers/parport/ieee1284

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