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