drivers/parport/ieee1284.c

   1 /*
   2  * IEEE-1284 implementation for parport.
   3  *
   4  * Authors: Phil Blundell <[email protected]>
   5  *          Carsten Gross <[email protected]>
   6  *          Jose Renau <[email protected]>
   7  *          Tim Waugh <[email protected]> (largely rewritten)
   8  *
   9  * This file is responsible for IEEE 1284 negotiation, and for handing
  10  * read/write requests to low-level drivers.
  11  *
  12  * Any part of this program may be used in documents licensed under
  13  * the GNU Free Documentation License, Version 1.1 or any later version
  14  * published by the Free Software Foundation.
  15  *
  16  * Various hacks, Fred Barnes <[email protected]>, 04/2000
  17  */
  18
  19 #include <linux/module.h>
  20 #include <linux/threads.h>
  21 #include <linux/parport.h>
  22 #include <linux/delay.h>
  23 #include <linux/kernel.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/timer.h>
  26 #include <linux/sched/signal.h>
  27
  28 #undef DEBUG /* undef me for production */
  29
  30 #ifdef CONFIG_LP_CONSOLE
  31 #undef DEBUG /* Don't want a garbled console */
  32 #endif
  33
  34 #ifdef DEBUG
  35 #define DPRINTK(stuff...) printk (stuff)
  36 #else
  37 #define DPRINTK(stuff...)
  38 #endif
  39
  40 /* Make parport_wait_peripheral wake up.
  41  * It will be useful to call this from an interrupt handler. */
  42 static void parport_ieee1284_wakeup (struct parport *port)
  43 {
  44         up (&port->physport->ieee1284.irq);
  45 }
  46
  47 static void timeout_waiting_on_port (struct timer_list *t)
  48 {
  49         struct parport *port = from_timer(port, t, timer);
  50
  51         parport_ieee1284_wakeup (port);
  52 }
  53
  54 /**
  55  *      parport_wait_event - wait for an event on a parallel port
  56  *      @port: port to wait on
  57  *      @timeout: time to wait (in jiffies)
  58  *
  59  *      This function waits for up to @timeout jiffies for an
  60  *      interrupt to occur on a parallel port.  If the port timeout is
  61  *      set to zero, it returns immediately.
  62  *
  63  *      If an interrupt occurs before the timeout period elapses, this
  64  *      function returns zero immediately.  If it times out, it returns
  65  *      one.  An error code less than zero indicates an error (most
  66  *      likely a pending signal), and the calling code should finish
  67  *      what it's doing as soon as it can.
  68  */
  69
  70 int parport_wait_event (struct parport *port, signed long timeout)
  71 {
  72         int ret;
  73
  74         if (!port->physport->cad->timeout)
  75                 /* Zero timeout is special, and we can't down() the
  76                    semaphore. */
  77                 return 1;
  78
  79         timer_setup(&port->timer, timeout_waiting_on_port, 0);
  80         mod_timer(&port->timer, jiffies + timeout);
  81         ret = down_interruptible (&port->physport->ieee1284.irq);
  82         if (!del_timer_sync(&port->timer) && !ret)
  83                 /* Timed out. */
  84                 ret = 1;
  85
  86         return ret;
  87 }
  88
  89 /**
  90  *      parport_poll_peripheral - poll status lines
  91  *      @port: port to watch
  92  *      @mask: status lines to watch
  93  *      @result: desired values of chosen status lines
  94  *      @usec: timeout
  95  *
  96  *      This function busy-waits until the masked status lines have
  97  *      the desired values, or until the timeout period elapses.  The
  98  *      @mask and @result parameters are bitmasks, with the bits
  99  *      defined by the constants in parport.h: %PARPORT_STATUS_BUSY,
 100  *      and so on.
 101  *
 102  *      This function does not call schedule(); instead it busy-waits
 103  *      using udelay().  It currently has a resolution of 5usec.
 104  *
 105  *      If the status lines take on the desired values before the
 106  *      timeout period elapses, parport_poll_peripheral() returns zero
 107  *      immediately.  A return value greater than zero indicates
 108  *      a timeout.  An error code (less than zero) indicates an error,
 109  *      most likely a signal that arrived, and the caller should
 110  *      finish what it is doing as soon as possible.
 111 */
 112
 113 int parport_poll_peripheral(struct parport *port,
 114                             unsigned char mask,
 115                             unsigned char result,
 116                             int usec)
 117 {
 118         /* Zero return code is success, >0 is timeout. */
 119         int count = usec / 5 + 2;
 120         int i;
 121         unsigned char status;
 122         for (i = 0; i < count; i++) {
 123                 status = parport_read_status (port);
 124                 if ((status & mask) == result)
 125                         return 0;
 126                 if (signal_pending (current))
 127                         return -EINTR;
 128                 if (need_resched())
 129                         break;
 130                 if (i >= 2)
 131                         udelay (5);
 132         }
 133
 134         return 1;
 135 }
 136
 137 /**
 138  *      parport_wait_peripheral - wait for status lines to change in 35ms
 139  *      @port: port to watch
 140  *      @mask: status lines to watch
 141  *      @result: desired values of chosen status lines
 142  *
 143  *      This function waits until the masked status lines have the
 144  *      desired values, or until 35ms have elapsed (see IEEE 1284-1994
 145  *      page 24 to 25 for why this value in particular is hardcoded).
 146  *      The @mask and @result parameters are bitmasks, with the bits
 147  *      defined by the constants in parport.h: %PARPORT_STATUS_BUSY,
 148  *      and so on.
 149  *
 150  *      The port is polled quickly to start off with, in anticipation
 151  *      of a fast response from the peripheral.  This fast polling
 152  *      time is configurable (using /proc), and defaults to 500usec.
 153  *      If the timeout for this port (see parport_set_timeout()) is
 154  *      zero, the fast polling time is 35ms, and this function does
 155  *      not call schedule().
 156  *
 157  *      If the timeout for this port is non-zero, after the fast
 158  *      polling fails it uses parport_wait_event() to wait for up to
 159  *      10ms, waking up if an interrupt occurs.
 160  */
 161
 162 int parport_wait_peripheral(struct parport *port,
 163                             unsigned char mask,
 164                             unsigned char result)
 165 {
 166         int ret;
 167         int usec;
 168         unsigned long deadline;
 169         unsigned char status;
 170
 171         usec = port->physport->spintime; /* usecs of fast polling */
 172         if (!port->physport->cad->timeout)
 173                 /* A zero timeout is "special": busy wait for the
 174                    entire 35ms. */
 175                 usec = 35000;
 176
 177         /* Fast polling.
 178          *
 179          * This should be adjustable.
 180          * How about making a note (in the device structure) of how long
 181          * it takes, so we know for next time?
 182          */
 183         ret = parport_poll_peripheral (port, mask, result, usec);
 184         if (ret != 1)
 185                 return ret;
 186
 187         if (!port->physport->cad->timeout)
 188                 /* We may be in an interrupt handler, so we can't poll
 189                  * slowly anyway. */
 190                 return 1;
 191
 192         /* 40ms of slow polling. */
 193         deadline = jiffies + msecs_to_jiffies(40);
 194         while (time_before (jiffies, deadline)) {
 195                 if (signal_pending (current))
 196                         return -EINTR;
 197
 198                 /* Wait for 10ms (or until an interrupt occurs if
 199                  * the handler is set) */
 200                 if ((ret = parport_wait_event (port, msecs_to_jiffies(10))) < 0)
 201                         return ret;
 202
 203                 status = parport_read_status (port);
 204                 if ((status & mask) == result)
 205                         return 0;
 206
 207                 if (!ret) {
 208                         /* parport_wait_event didn't time out, but the
 209                          * peripheral wasn't actually ready either.
 210                          * Wait for another 10ms. */
 211                         schedule_timeout_interruptible(msecs_to_jiffies(10));
 212                 }
 213         }
 214
 215         return 1;
 216 }
 217
 218 #ifdef CONFIG_PARPORT_1284
 219 /* Terminate a negotiated mode. */
 220 static void parport_ieee1284_terminate (struct parport *port)
 221 {
 222         int r;
 223         port = port->physport;
 224
 225         /* EPP terminates differently. */
 226         switch (port->ieee1284.mode) {
 227         case IEEE1284_MODE_EPP:
 228         case IEEE1284_MODE_EPPSL:
 229         case IEEE1284_MODE_EPPSWE:
 230                 /* Terminate from EPP mode. */
 231
 232                 /* Event 68: Set nInit low */
 233                 parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
 234                 udelay (50);
 235
 236                 /* Event 69: Set nInit high, nSelectIn low */
 237                 parport_frob_control (port,
 238                                       PARPORT_CONTROL_SELECT
 239                                       | PARPORT_CONTROL_INIT,
 240                                       PARPORT_CONTROL_SELECT
 241                                       | PARPORT_CONTROL_INIT);
 242                 break;
 243
 244         case IEEE1284_MODE_ECP:
 245         case IEEE1284_MODE_ECPRLE:
 246         case IEEE1284_MODE_ECPSWE:
 247                 /* In ECP we can only terminate from fwd idle phase. */
 248                 if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE) {
 249                         /* Event 47: Set nInit high */
 250                         parport_frob_control (port,
 251                                               PARPORT_CONTROL_INIT
 252                                               | PARPORT_CONTROL_AUTOFD,
 253                                               PARPORT_CONTROL_INIT
 254                                               | PARPORT_CONTROL_AUTOFD);
 255
 256                         /* Event 49: PError goes high */
 257                         r = parport_wait_peripheral (port,
 258                                                      PARPORT_STATUS_PAPEROUT,
 259                                                      PARPORT_STATUS_PAPEROUT);
 260                         if (r)
 261                                 DPRINTK (KERN_INFO "%s: Timeout at event 49\n",
 262                                          port->name);
 263
 264                         parport_data_forward (port);
 265                         DPRINTK (KERN_DEBUG "%s: ECP direction: forward\n",
 266                                  port->name);
 267                         port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
 268                 }
 269
 270                 /* fall through */
 271
 272         default:
 273                 /* Terminate from all other modes. */
 274
 275                 /* Event 22: Set nSelectIn low, nAutoFd high */
 276                 parport_frob_control (port,
 277                                       PARPORT_CONTROL_SELECT
 278                                       | PARPORT_CONTROL_AUTOFD,
 279                                       PARPORT_CONTROL_SELECT);
 280
 281                 /* Event 24: nAck goes low */
 282                 r = parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0);
 283                 if (r)
 284                         DPRINTK (KERN_INFO "%s: Timeout at event 24\n",
 285                                  port->name);
 286
 287                 /* Event 25: Set nAutoFd low */
 288                 parport_frob_control (port,
 289                                       PARPORT_CONTROL_AUTOFD,
 290                                       PARPORT_CONTROL_AUTOFD);
 291
 292                 /* Event 27: nAck goes high */
 293                 r = parport_wait_peripheral (port,
 294                                              PARPORT_STATUS_ACK,
 295                                              PARPORT_STATUS_ACK);
 296                 if (r)
 297                         DPRINTK (KERN_INFO "%s: Timeout at event 27\n",
 298                                  port->name);
 299
 300                 /* Event 29: Set nAutoFd high */
 301                 parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
 302         }
 303
 304         port->ieee1284.mode = IEEE1284_MODE_COMPAT;
 305         port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
 306
 307         DPRINTK (KERN_DEBUG "%s: In compatibility (forward idle) mode\n",
 308                  port->name);
 309 }
 310 #endif /* IEEE1284 support */
 311
 312 /**
 313  *      parport_negotiate - negotiate an IEEE 1284 mode
 314  *      @port: port to use
 315  *      @mode: mode to negotiate to
 316  *
 317  *      Use this to negotiate to a particular IEEE 1284 transfer mode.
 318  *      The @mode parameter should be one of the constants in
 319  *      parport.h starting %IEEE1284_MODE_xxx.
 320  *
 321  *      The return value is 0 if the peripheral has accepted the
 322  *      negotiation to the mode specified, -1 if the peripheral is not
 323  *      IEEE 1284 compliant (or not present), or 1 if the peripheral
 324  *      has rejected the negotiation.
 325  */
 326
 327 int parport_negotiate (struct parport *port, int mode)
 328 {
 329 #ifndef CONFIG_PARPORT_1284
 330         if (mode == IEEE1284_MODE_COMPAT)
 331                 return 0;
 332         printk (KERN_ERR "parport: IEEE1284 not supported in this kernel\n");
 333         return -1;
 334 #else
 335         int m = mode & ~IEEE1284_ADDR;
 336         int r;
 337         unsigned char xflag;
 338
 339         port = port->physport;
 340
 341         /* Is there anything to do? */
 342         if (port->ieee1284.mode == mode)
 343                 return 0;
 344
 345         /* Is the difference just an address-or-not bit? */
 346         if ((port->ieee1284.mode & ~IEEE1284_ADDR) == (mode & ~IEEE1284_ADDR)){
 347                 port->ieee1284.mode = mode;
 348                 return 0;
 349         }
 350
 351         /* Go to compatibility forward idle mode */
 352         if (port->ieee1284.mode != IEEE1284_MODE_COMPAT)
 353                 parport_ieee1284_terminate (port);
 354
 355         if (mode == IEEE1284_MODE_COMPAT)
 356                 /* Compatibility mode: no negotiation. */
 357                 return 0;
 358
 359         switch (mode) {
 360         case IEEE1284_MODE_ECPSWE:
 361                 m = IEEE1284_MODE_ECP;
 362                 break;
 363         case IEEE1284_MODE_EPPSL:
 364         case IEEE1284_MODE_EPPSWE:
 365                 m = IEEE1284_MODE_EPP;
 366                 break;
 367         case IEEE1284_MODE_BECP:
 368                 return -ENOSYS; /* FIXME (implement BECP) */
 369         }
 370
 371         if (mode & IEEE1284_EXT_LINK)
 372                 m = 1<<7; /* request extensibility link */
 373
 374         port->ieee1284.phase = IEEE1284_PH_NEGOTIATION;
 375
 376         /* Start off with nStrobe and nAutoFd high, and nSelectIn low */
 377         parport_frob_control (port,
 378                               PARPORT_CONTROL_STROBE
 379                               | PARPORT_CONTROL_AUTOFD
 380                               | PARPORT_CONTROL_SELECT,
 381                               PARPORT_CONTROL_SELECT);
 382         udelay(1);
 383
 384         /* Event 0: Set data */
 385         parport_data_forward (port);
 386         parport_write_data (port, m);
 387         udelay (400); /* Shouldn't need to wait this long. */
 388
 389         /* Event 1: Set nSelectIn high, nAutoFd low */
 390         parport_frob_control (port,
 391                               PARPORT_CONTROL_SELECT
 392                               | PARPORT_CONTROL_AUTOFD,
 393                               PARPORT_CONTROL_AUTOFD);
 394
 395         /* Event 2: PError, Select, nFault go high, nAck goes low */
 396         if (parport_wait_peripheral (port,
 397                                      PARPORT_STATUS_ERROR
 398                                      | PARPORT_STATUS_SELECT
 399                                      | PARPORT_STATUS_PAPEROUT
 400                                      | PARPORT_STATUS_ACK,
 401                                      PARPORT_STATUS_ERROR
 402                                      | PARPORT_STATUS_SELECT
 403                                      | PARPORT_STATUS_PAPEROUT)) {
 404                 /* Timeout */
 405                 parport_frob_control (port,
 406                                       PARPORT_CONTROL_SELECT
 407                                       | PARPORT_CONTROL_AUTOFD,
 408                                       PARPORT_CONTROL_SELECT);
 409                 DPRINTK (KERN_DEBUG
 410                          "%s: Peripheral not IEEE1284 compliant (0x%02X)\n",
 411                          port->name, parport_read_status (port));
 412                 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
 413                 return -1; /* Not IEEE1284 compliant */
 414         }
 415
 416         /* Event 3: Set nStrobe low */
 417         parport_frob_control (port,
 418                               PARPORT_CONTROL_STROBE,
 419                               PARPORT_CONTROL_STROBE);
 420
 421         /* Event 4: Set nStrobe and nAutoFd high */
 422         udelay (5);
 423         parport_frob_control (port,
 424                               PARPORT_CONTROL_STROBE
 425                               | PARPORT_CONTROL_AUTOFD,
 426                               0);
 427
 428         /* Event 6: nAck goes high */
 429         if (parport_wait_peripheral (port,
 430                                      PARPORT_STATUS_ACK,
 431                                      PARPORT_STATUS_ACK)) {
 432                 /* This shouldn't really happen with a compliant device. */
 433                 DPRINTK (KERN_DEBUG
 434                          "%s: Mode 0x%02x not supported? (0x%02x)\n",
 435                          port->name, mode, port->ops->read_status (port));
 436                 parport_ieee1284_terminate (port);
 437                 return 1;
 438         }
 439
 440         xflag = parport_read_status (port) & PARPORT_STATUS_SELECT;
 441
 442         /* xflag should be high for all modes other than nibble (0). */
 443         if (mode && !xflag) {
 444                 /* Mode not supported. */
 445                 DPRINTK (KERN_DEBUG "%s: Mode 0x%02x rejected by peripheral\n",
 446                          port->name, mode);
 447                 parport_ieee1284_terminate (port);
 448                 return 1;
 449         }
 450
 451         /* More to do if we've requested extensibility link. */
 452         if (mode & IEEE1284_EXT_LINK) {
 453                 m = mode & 0x7f;
 454                 udelay (1);
 455                 parport_write_data (port, m);
 456                 udelay (1);
 457
 458                 /* Event 51: Set nStrobe low */
 459                 parport_frob_control (port,
 460                                       PARPORT_CONTROL_STROBE,
 461                                       PARPORT_CONTROL_STROBE);
 462
 463                 /* Event 52: nAck goes low */
 464                 if (parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0)) {
 465                         /* This peripheral is _very_ slow. */
 466                         DPRINTK (KERN_DEBUG
 467                                  "%s: Event 52 didn't happen\n",
 468                                  port->name);
 469                         parport_ieee1284_terminate (port);
 470                         return 1;
 471                 }
 472
 473                 /* Event 53: Set nStrobe high */
 474                 parport_frob_control (port,
 475                                       PARPORT_CONTROL_STROBE,
 476                                       0);
 477
 478                 /* Event 55: nAck goes high */
 479                 if (parport_wait_peripheral (port,
 480                                              PARPORT_STATUS_ACK,
 481                                              PARPORT_STATUS_ACK)) {
 482                         /* This shouldn't really happen with a compliant
 483                          * device. */
 484                         DPRINTK (KERN_DEBUG
 485                                  "%s: Mode 0x%02x not supported? (0x%02x)\n",
 486                                  port->name, mode,
 487                                  port->ops->read_status (port));
 488                         parport_ieee1284_terminate (port);
 489                         return 1;
 490                 }
 491
 492                 /* Event 54: Peripheral sets XFlag to reflect support */
 493                 xflag = parport_read_status (port) & PARPORT_STATUS_SELECT;
 494
 495                 /* xflag should be high. */
 496                 if (!xflag) {
 497                         /* Extended mode not supported. */
 498                         DPRINTK (KERN_DEBUG "%s: Extended mode 0x%02x not "
 499                                  "supported\n", port->name, mode);
 500                         parport_ieee1284_terminate (port);
 501                         return 1;
 502                 }
 503
 504                 /* Any further setup is left to the caller. */
 505         }
 506
 507         /* Mode is supported */
 508         DPRINTK (KERN_DEBUG "%s: In mode 0x%02x\n", port->name, mode);
 509         port->ieee1284.mode = mode;
 510
 511         /* But ECP is special */
 512         if (!(mode & IEEE1284_EXT_LINK) && (m & IEEE1284_MODE_ECP)) {
 513                 port->ieee1284.phase = IEEE1284_PH_ECP_SETUP;
 514
 515                 /* Event 30: Set nAutoFd low */
 516                 parport_frob_control (port,
 517                                       PARPORT_CONTROL_AUTOFD,
 518                                       PARPORT_CONTROL_AUTOFD);
 519
 520                 /* Event 31: PError goes high. */
 521                 r = parport_wait_peripheral (port,
 522                                              PARPORT_STATUS_PAPEROUT,
 523                                              PARPORT_STATUS_PAPEROUT);
 524                 if (r) {
 525                         DPRINTK (KERN_INFO "%s: Timeout at event 31\n",
 526                                 port->name);
 527                 }
 528
 529                 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
 530                 DPRINTK (KERN_DEBUG "%s: ECP direction: forward\n",
 531                          port->name);
 532         } else switch (mode) {
 533         case IEEE1284_MODE_NIBBLE:
 534         case IEEE1284_MODE_BYTE:
 535                 port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
 536                 break;
 537         default:
 538                 port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
 539         }
 540
 541
 542         return 0;
 543 #endif /* IEEE1284 support */
 544 }
 545
 546 /* Acknowledge that the peripheral has data available.
 547  * Events 18-20, in order to get from Reverse Idle phase
 548  * to Host Busy Data Available.
 549  * This will most likely be called from an interrupt.
 550  * Returns zero if data was available.
 551  */
 552 #ifdef CONFIG_PARPORT_1284
 553 static int parport_ieee1284_ack_data_avail (struct parport *port)
 554 {
 555         if (parport_read_status (port) & PARPORT_STATUS_ERROR)
 556                 /* Event 18 didn't happen. */
 557                 return -1;
 558
 559         /* Event 20: nAutoFd goes high. */
 560         port->ops->frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
 561         port->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL;
 562         return 0;
 563 }
 564 #endif /* IEEE1284 support */
 565
 566 /* Handle an interrupt. */
 567 void parport_ieee1284_interrupt (void *handle)
 568 {
 569         struct parport *port = handle;
 570         parport_ieee1284_wakeup (port);
 571
 572 #ifdef CONFIG_PARPORT_1284
 573         if (port->ieee1284.phase == IEEE1284_PH_REV_IDLE) {
 574                 /* An interrupt in this phase means that data
 575                  * is now available. */
 576                 DPRINTK (KERN_DEBUG "%s: Data available\n", port->name);
 577                 parport_ieee1284_ack_data_avail (port);
 578         }
 579 #endif /* IEEE1284 support */
 580 }
 581
 582 /**
 583  *      parport_write - write a block of data to a parallel port
 584  *      @port: port to write to
 585  *      @buffer: data buffer (in kernel space)
 586  *      @len: number of bytes of data to transfer
 587  *
 588  *      This will write up to @len bytes of @buffer to the port
 589  *      specified, using the IEEE 1284 transfer mode most recently
 590  *      negotiated to (using parport_negotiate()), as long as that
 591  *      mode supports forward transfers (host to peripheral).
 592  *
 593  *      It is the caller's responsibility to ensure that the first
 594  *      @len bytes of @buffer are valid.
 595  *
 596  *      This function returns the number of bytes transferred (if zero
 597  *      or positive), or else an error code.
 598  */
 599
 600 ssize_t parport_write (struct parport *port, const void *buffer, size_t len)
 601 {
 602 #ifndef CONFIG_PARPORT_1284
 603         return port->ops->compat_write_data (port, buffer, len, 0);
 604 #else
 605         ssize_t retval;
 606         int mode = port->ieee1284.mode;
 607         int addr = mode & IEEE1284_ADDR;
 608         size_t (*fn) (struct parport *, const void *, size_t, int);
 609
 610         /* Ignore the device-ID-request bit and the address bit. */
 611         mode &= ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
 612
 613         /* Use the mode we're in. */
 614         switch (mode) {
 615         case IEEE1284_MODE_NIBBLE:
 616         case IEEE1284_MODE_BYTE:
 617                 parport_negotiate (port, IEEE1284_MODE_COMPAT);
 618                 /* fall through */
 619         case IEEE1284_MODE_COMPAT:
 620                 DPRINTK (KERN_DEBUG "%s: Using compatibility mode\n",
 621                          port->name);
 622                 fn = port->ops->compat_write_data;
 623                 break;
 624
 625         case IEEE1284_MODE_EPP:
 626                 DPRINTK (KERN_DEBUG "%s: Using EPP mode\n", port->name);
 627                 if (addr) {
 628                         fn = port->ops->epp_write_addr;
 629                 } else {
 630                         fn = port->ops->epp_write_data;
 631                 }
 632                 break;
 633         case IEEE1284_MODE_EPPSWE:
 634                 DPRINTK (KERN_DEBUG "%s: Using software-emulated EPP mode\n",
 635                         port->name);
 636                 if (addr) {
 637                         fn = parport_ieee1284_epp_write_addr;
 638                 } else {
 639                         fn = parport_ieee1284_epp_write_data;
 640                 }
 641                 break;
 642         case IEEE1284_MODE_ECP:
 643         case IEEE1284_MODE_ECPRLE:
 644                 DPRINTK (KERN_DEBUG "%s: Using ECP mode\n", port->name);
 645                 if (addr) {
 646                         fn = port->ops->ecp_write_addr;
 647                 } else {
 648                         fn = port->ops->ecp_write_data;
 649                 }
 650                 break;
 651
 652         case IEEE1284_MODE_ECPSWE:
 653                 DPRINTK (KERN_DEBUG "%s: Using software-emulated ECP mode\n",
 654                          port->name);
 655                 /* The caller has specified that it must be emulated,
 656                  * even if we have ECP hardware! */
 657                 if (addr) {
 658                         fn = parport_ieee1284_ecp_write_addr;
 659                 } else {
 660                         fn = parport_ieee1284_ecp_write_data;
 661                 }
 662                 break;
 663
 664         default:
 665                 DPRINTK (KERN_DEBUG "%s: Unknown mode 0x%02x\n", port->name,
 666                         port->ieee1284.mode);
 667                 return -ENOSYS;
 668         }
 669
 670         retval = (*fn) (port, buffer, len, 0);
 671         DPRINTK (KERN_DEBUG "%s: wrote %d/%d bytes\n", port->name, retval, len);
 672         return retval;
 673 #endif /* IEEE1284 support */
 674 }
 675
 676 /**
 677  *      parport_read - read a block of data from a parallel port
 678  *      @port: port to read from
 679  *      @buffer: data buffer (in kernel space)
 680  *      @len: number of bytes of data to transfer
 681  *
 682  *      This will read up to @len bytes of @buffer to the port
 683  *      specified, using the IEEE 1284 transfer mode most recently
 684  *      negotiated to (using parport_negotiate()), as long as that
 685  *      mode supports reverse transfers (peripheral to host).
 686  *
 687  *      It is the caller's responsibility to ensure that the first
 688  *      @len bytes of @buffer are available to write to.
 689  *
 690  *      This function returns the number of bytes transferred (if zero
 691  *      or positive), or else an error code.
 692  */
 693
 694 ssize_t parport_read (struct parport *port, void *buffer, size_t len)
 695 {
 696 #ifndef CONFIG_PARPORT_1284
 697         printk (KERN_ERR "parport: IEEE1284 not supported in this kernel\n");
 698         return -ENODEV;
 699 #else
 700         int mode = port->physport->ieee1284.mode;
 701         int addr = mode & IEEE1284_ADDR;
 702         size_t (*fn) (struct parport *, void *, size_t, int);
 703
 704         /* Ignore the device-ID-request bit and the address bit. */
 705         mode &= ~(IEEE1284_DEVICEID | IEEE1284_ADDR);
 706
 707         /* Use the mode we're in. */
 708         switch (mode) {
 709         case IEEE1284_MODE_COMPAT:
 710                 /* if we can tri-state use BYTE mode instead of NIBBLE mode,
 711                  * if that fails, revert to NIBBLE mode -- ought to store somewhere
 712                  * the device's ability to do BYTE mode reverse transfers, so we don't
 713                  * end up needlessly calling negotiate(BYTE) repeately..  (fb)
 714                  */
 715                 if ((port->physport->modes & PARPORT_MODE_TRISTATE) &&
 716                     !parport_negotiate (port, IEEE1284_MODE_BYTE)) {
 717                         /* got into BYTE mode OK */
 718                         DPRINTK (KERN_DEBUG "%s: Using byte mode\n", port->name);
 719                         fn = port->ops->byte_read_data;
 720                         break;
 721                 }
 722                 if (parport_negotiate (port, IEEE1284_MODE_NIBBLE)) {
 723                         return -EIO;
 724                 }
 725                 /* fall through to NIBBLE */
 726         case IEEE1284_MODE_NIBBLE:
 727                 DPRINTK (KERN_DEBUG "%s: Using nibble mode\n", port->name);
 728                 fn = port->ops->nibble_read_data;
 729                 break;
 730
 731         case IEEE1284_MODE_BYTE:
 732                 DPRINTK (KERN_DEBUG "%s: Using byte mode\n", port->name);
 733                 fn = port->ops->byte_read_data;
 734                 break;
 735
 736         case IEEE1284_MODE_EPP:
 737                 DPRINTK (KERN_DEBUG "%s: Using EPP mode\n", port->name);
 738                 if (addr) {
 739                         fn = port->ops->epp_read_addr;
 740                 } else {
 741                         fn = port->ops->epp_read_data;
 742                 }
 743                 break;
 744         case IEEE1284_MODE_EPPSWE:
 745                 DPRINTK (KERN_DEBUG "%s: Using software-emulated EPP mode\n",
 746                         port->name);
 747                 if (addr) {
 748                         fn = parport_ieee1284_epp_read_addr;
 749                 } else {
 750                         fn = parport_ieee1284_epp_read_data;
 751                 }
 752                 break;
 753         case IEEE1284_MODE_ECP:
 754         case IEEE1284_MODE_ECPRLE:
 755                 DPRINTK (KERN_DEBUG "%s: Using ECP mode\n", port->name);
 756                 fn = port->ops->ecp_read_data;
 757                 break;
 758
 759         case IEEE1284_MODE_ECPSWE:
 760                 DPRINTK (KERN_DEBUG "%s: Using software-emulated ECP mode\n",
 761                          port->name);
 762                 fn = parport_ieee1284_ecp_read_data;
 763                 break;
 764
 765         default:
 766                 DPRINTK (KERN_DEBUG "%s: Unknown mode 0x%02x\n", port->name,
 767                          port->physport->ieee1284.mode);
 768                 return -ENOSYS;
 769         }
 770
 771         return (*fn) (port, buffer, len, 0);
 772 #endif /* IEEE1284 support */
 773 }
 774
 775 /**
 776  *      parport_set_timeout - set the inactivity timeout for a device
 777  *      @dev: device on a port
 778  *      @inactivity: inactivity timeout (in jiffies)
 779  *
 780  *      This sets the inactivity timeout for a particular device on a
 781  *      port.  This affects functions like parport_wait_peripheral().
 782  *      The special value 0 means not to call schedule() while dealing
 783  *      with this device.
 784  *
 785  *      The return value is the previous inactivity timeout.
 786  *
 787  *      Any callers of parport_wait_event() for this device are woken
 788  *      up.
 789  */
 790
 791 long parport_set_timeout (struct pardevice *dev, long inactivity)
 792 {
 793         long int old = dev->timeout;
 794
 795         dev->timeout = inactivity;
 796
 797         if (dev->port->physport->cad == dev)
 798                 parport_ieee1284_wakeup (dev->port);
 799
 800         return old;
 801 }
 802
 803 /* Exported symbols for modules. */
 804
 805 EXPORT_SYMBOL(parport_negotiate);
 806 EXPORT_SYMBOL(parport_write);
 807 EXPORT_SYMBOL(parport_read);
 808 EXPORT_SYMBOL(parport_wait_peripheral);
 809 EXPORT_SYMBOL(parport_wait_event);
 810 EXPORT_SYMBOL(parport_set_timeout);
 811 EXPORT_SYMBOL(parport_ieee1284_interrupt);