drivers/parport/ieee1284.c

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