linux/drivers/parport/ieee1284.c
<<
>>
Prefs
   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. */
  42static void parport_ieee1284_wakeup (struct parport *port)
  43{
  44        up (&port->physport->ieee1284.irq);
  45}
  46
  47static struct parport *port_from_cookie[PARPORT_MAX];
  48static 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
  69int 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
 120int 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
 169int 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. */
 227static 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
 334int 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
 560static 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. */
 574void 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
 607ssize_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
 700ssize_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
 797long 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
 811EXPORT_SYMBOL(parport_negotiate);
 812EXPORT_SYMBOL(parport_write);
 813EXPORT_SYMBOL(parport_read);
 814EXPORT_SYMBOL(parport_wait_peripheral);
 815EXPORT_SYMBOL(parport_wait_event);
 816EXPORT_SYMBOL(parport_set_timeout);
 817EXPORT_SYMBOL(parport_ieee1284_interrupt);
 818
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.