// SPDX-License-Identifier: GPL-2.0
/* IEEE-1284 operations for parport.
 *
 * This file is for generic IEEE 1284 operations.  The idea is that
 * they are used by the low-level drivers.  If they have a special way
 * of doing something, they can provide their own routines (and put
 * the function pointers in port->ops); if not, they can just use these
 * as a fallback.
 *
 * Note: Make no assumptions about hardware or architecture in this file!
 *
 * Author: Tim Waugh <tim@cyberelk.demon.co.uk>
 * Fixed AUTOFD polarity in ecp_forward_to_reverse().  Fred Barnes, 1999
 * Software emulated EPP fixes, Fred Barnes, 04/2001.
 */


#include <linux/module.h>
#include <linux/parport.h>
#include <linux/delay.h>
#include <linux/sched/signal.h>
#include <linux/uaccess.h>

#undef DEBUG /* undef me for production */

#ifdef CONFIG_LP_CONSOLE
#undef DEBUG /* Don't want a garbled console */
#endif

/***                                *
 * One-way data transfer functions. *
 *                                ***/

/* Compatibility mode. */
size_t parport_ieee1284_write_compat (struct parport *port,
                                      const void *buffer, size_t len,
                                      int flags)
{
        int no_irq = 1;
        ssize_t count = 0;
        const unsigned char *addr = buffer;
        unsigned char byte;
        struct pardevice *dev = port->physport->cad;
        unsigned char ctl = (PARPORT_CONTROL_SELECT
                             | PARPORT_CONTROL_INIT);

        if (port->irq != PARPORT_IRQ_NONE) {
                parport_enable_irq (port);
                no_irq = 0;
        }

        port->physport->ieee1284.phase = IEEE1284_PH_FWD_DATA;
        parport_write_control (port, ctl);
        parport_data_forward (port);
        while (count < len) {
                unsigned long expire = jiffies + dev->timeout;
                long wait = msecs_to_jiffies(10);
                unsigned char mask = (PARPORT_STATUS_ERROR
                                      | PARPORT_STATUS_BUSY);
                unsigned char val = (PARPORT_STATUS_ERROR
                                     | PARPORT_STATUS_BUSY);

                /* Wait until the peripheral's ready */
                do {
                        /* Is the peripheral ready yet? */
                        if (!parport_wait_peripheral (port, mask, val))
                                /* Skip the loop */
                                goto ready;

                        /* Is the peripheral upset? */
                        if ((parport_read_status (port) &
                             (PARPORT_STATUS_PAPEROUT |
                              PARPORT_STATUS_SELECT |
                              PARPORT_STATUS_ERROR))
                            != (PARPORT_STATUS_SELECT |
                                PARPORT_STATUS_ERROR))
                                /* If nFault is asserted (i.e. no
                                 * error) and PAPEROUT and SELECT are
                                 * just red herrings, give the driver
                                 * a chance to check it's happy with
                                 * that before continuing. */
                                goto stop;

                        /* Have we run out of time? */
                        if (!time_before (jiffies, expire))
                                break;

                        /* Yield the port for a while.  If this is the
                           first time around the loop, don't let go of
                           the port.  This way, we find out if we have
                           our interrupt handler called. */
                        if (count && no_irq) {
                                parport_release (dev);
                                schedule_timeout_interruptible(wait);
                                parport_claim_or_block (dev);
                        }
                        else
                                /* We must have the device claimed here */
                                parport_wait_event (port, wait);

                        /* Is there a signal pending? */
                        if (signal_pending (current))
                                break;

                        /* Wait longer next time. */
                        wait *= 2;
                } while (time_before (jiffies, expire));

                if (signal_pending (current))
                        break;

                pr_debug("%s: Timed out\n", port->name);
                break;

        ready:
                /* Write the character to the data lines. */
                byte = *addr++;
                parport_write_data (port, byte);
                udelay (1);

                /* Pulse strobe. */
                parport_write_control (port, ctl | PARPORT_CONTROL_STROBE);
                udelay (1); /* strobe */

                parport_write_control (port, ctl);
                udelay (1); /* hold */

                /* Assume the peripheral received it. */
                count++;

                /* Let another process run if it needs to. */
                if (time_before (jiffies, expire))
                        if (!parport_yield_blocking (dev)
                            && need_resched())
                                schedule ();
        }
 stop:
        port->physport->ieee1284.phase = IEEE1284_PH_FWD_IDLE;

        return count;
}

/* Nibble mode. */
size_t parport_ieee1284_read_nibble (struct parport *port, 
                                     void *buffer, size_t len,
                                     int flags)
{
#ifndef CONFIG_PARPORT_1284
        return 0;
#else
        unsigned char *buf = buffer;
        int i;
        unsigned char byte = 0;

        len *= 2; /* in nibbles */
        for (i=0; i < len; i++) {
                unsigned char nibble;

                /* Does the error line indicate end of data? */
                if (((i & 1) == 0) &&
                    (parport_read_status(port) & PARPORT_STATUS_ERROR)) {
                        goto end_of_data;
                }

                /* Event 7: Set nAutoFd low. */
                parport_frob_control (port,
                                      PARPORT_CONTROL_AUTOFD,
                                      PARPORT_CONTROL_AUTOFD);

                /* Event 9: nAck goes low. */
                port->ieee1284.phase = IEEE1284_PH_REV_DATA;
                if (parport_wait_peripheral (port,
                                             PARPORT_STATUS_ACK, 0)) {
                        /* Timeout -- no more data? */
                        pr_debug("%s: Nibble timeout at event 9 (%d bytes)\n",
                                 port->name, i / 2);
                        parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);
                        break;
                }


                /* Read a nibble. */
                nibble = parport_read_status (port) >> 3;
                nibble &= ~8;
                if ((nibble & 0x10) == 0)
                        nibble |= 8;
                nibble &= 0xf;

                /* Event 10: Set nAutoFd high. */
                parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);

                /* Event 11: nAck goes high. */
                if (parport_wait_peripheral (port,
                                             PARPORT_STATUS_ACK,
                                             PARPORT_STATUS_ACK)) {
                        /* Timeout -- no more data? */
                        pr_debug("%s: Nibble timeout at event 11\n",
                                 port->name);
                        break;
                }

                if (i & 1) {
                        /* Second nibble */
                        byte |= nibble << 4;
                        *buf++ = byte;
                } else 
                        byte = nibble;
        }

        if (i == len) {
                /* Read the last nibble without checking data avail. */
                if (parport_read_status (port) & PARPORT_STATUS_ERROR) {
                end_of_data:
                        pr_debug("%s: No more nibble data (%d bytes)\n",
                                 port->name, i / 2);

                        /* Go to reverse idle phase. */
                        parport_frob_control (port,
                                              PARPORT_CONTROL_AUTOFD,
                                              PARPORT_CONTROL_AUTOFD);
                        port->physport->ieee1284.phase = IEEE1284_PH_REV_IDLE;
                }
                else
                        port->physport->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL;
        }

        return i/2;
#endif /* IEEE1284 support */
}

/* Byte mode. */
size_t parport_ieee1284_read_byte (struct parport *port,
                                   void *buffer, size_t len,
                                   int flags)
{
#ifndef CONFIG_PARPORT_1284
        return 0;
#else
        unsigned char *buf = buffer;
        ssize_t count = 0;

        for (count = 0; count < len; count++) {
                unsigned char byte;

                /* Data available? */
                if (parport_read_status (port) & PARPORT_STATUS_ERROR) {
                        goto end_of_data;
                }

                /* Event 14: Place data bus in high impedance state. */
                parport_data_reverse (port);

                /* Event 7: Set nAutoFd low. */
                parport_frob_control (port,
                                      PARPORT_CONTROL_AUTOFD,
                                      PARPORT_CONTROL_AUTOFD);

                /* Event 9: nAck goes low. */
                port->physport->ieee1284.phase = IEEE1284_PH_REV_DATA;
                if (parport_wait_peripheral (port,
                                             PARPORT_STATUS_ACK,
                                             0)) {
                        /* Timeout -- no more data? */
                        parport_frob_control (port, PARPORT_CONTROL_AUTOFD,
                                                 0);
                        pr_debug("%s: Byte timeout at event 9\n", port->name);
                        break;
                }

                byte = parport_read_data (port);
                *buf++ = byte;

                /* Event 10: Set nAutoFd high */
                parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);

                /* Event 11: nAck goes high. */
                if (parport_wait_peripheral (port,
                                             PARPORT_STATUS_ACK,
                                             PARPORT_STATUS_ACK)) {
                        /* Timeout -- no more data? */
                        pr_debug("%s: Byte timeout at event 11\n", port->name);
                        break;
                }

                /* Event 16: Set nStrobe low. */
                parport_frob_control (port,
                                      PARPORT_CONTROL_STROBE,
                                      PARPORT_CONTROL_STROBE);
                udelay (5);

                /* Event 17: Set nStrobe high. */
                parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
        }

        if (count == len) {
                /* Read the last byte without checking data avail. */
                if (parport_read_status (port) & PARPORT_STATUS_ERROR) {
                end_of_data:
                        pr_debug("%s: No more byte data (%zd bytes)\n",
                                 port->name, count);

                        /* Go to reverse idle phase. */
                        parport_frob_control (port,
                                              PARPORT_CONTROL_AUTOFD,
                                              PARPORT_CONTROL_AUTOFD);
                        port->physport->ieee1284.phase = IEEE1284_PH_REV_IDLE;
                }
                else
                        port->physport->ieee1284.phase = IEEE1284_PH_HBUSY_DAVAIL;
        }

        return count;
#endif /* IEEE1284 support */
}

/***              *
 * ECP Functions. *
 *              ***/

#ifdef CONFIG_PARPORT_1284

static inline
int ecp_forward_to_reverse (struct parport *port)
{
        int retval;

        /* Event 38: Set nAutoFd low */
        parport_frob_control (port,
                              PARPORT_CONTROL_AUTOFD,
                              PARPORT_CONTROL_AUTOFD);
        parport_data_reverse (port);
        udelay (5);

        /* Event 39: Set nInit low to initiate bus reversal */
        parport_frob_control (port,
                              PARPORT_CONTROL_INIT,
                              0);

        /* Event 40: PError goes low */
        retval = parport_wait_peripheral (port,
                                          PARPORT_STATUS_PAPEROUT, 0);

        if (!retval) {
                pr_debug("%s: ECP direction: reverse\n", port->name);
                port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
        } else {
                pr_debug("%s: ECP direction: failed to reverse\n", port->name);
                port->ieee1284.phase = IEEE1284_PH_ECP_DIR_UNKNOWN;
        }

        return retval;
}

static inline
int ecp_reverse_to_forward (struct parport *port)
{
        int retval;

        /* Event 47: Set nInit high */
        parport_frob_control (port,
                              PARPORT_CONTROL_INIT
                              | PARPORT_CONTROL_AUTOFD,
                              PARPORT_CONTROL_INIT
                              | PARPORT_CONTROL_AUTOFD);

        /* Event 49: PError goes high */
        retval = parport_wait_peripheral (port,
                                          PARPORT_STATUS_PAPEROUT,
                                          PARPORT_STATUS_PAPEROUT);

        if (!retval) {
                parport_data_forward (port);
                pr_debug("%s: ECP direction: forward\n", port->name);
                port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
        } else {
                pr_debug("%s: ECP direction: failed to switch forward\n",
                         port->name);
                port->ieee1284.phase = IEEE1284_PH_ECP_DIR_UNKNOWN;
        }


        return retval;
}

#endif /* IEEE1284 support */

/* ECP mode, forward channel, data. */
size_t parport_ieee1284_ecp_write_data (struct parport *port,
                                        const void *buffer, size_t len,
                                        int flags)
{
#ifndef CONFIG_PARPORT_1284
        return 0;
#else
        const unsigned char *buf = buffer;
        size_t written;
        int retry;

        port = port->physport;

        if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE)
                if (ecp_reverse_to_forward (port))
                        return 0;

        port->ieee1284.phase = IEEE1284_PH_FWD_DATA;

        /* HostAck high (data, not command) */
        parport_frob_control (port,
                              PARPORT_CONTROL_AUTOFD
                              | PARPORT_CONTROL_STROBE
                              | PARPORT_CONTROL_INIT,
                              PARPORT_CONTROL_INIT);
        for (written = 0; written < len; written++, buf++) {
                unsigned long expire = jiffies + port->cad->timeout;
                unsigned char byte;

                byte = *buf;
        try_again:
                parport_write_data (port, byte);
                parport_frob_control (port, PARPORT_CONTROL_STROBE,
                                      PARPORT_CONTROL_STROBE);
                udelay (5);
                for (retry = 0; retry < 100; retry++) {
                        if (!parport_wait_peripheral (port,
                                                      PARPORT_STATUS_BUSY, 0))
                                goto success;

                        if (signal_pending (current)) {
                                parport_frob_control (port,
                                                      PARPORT_CONTROL_STROBE,
                                                      0);
                                break;
                        }
                }

                /* Time for Host Transfer Recovery (page 41 of IEEE1284) */
                pr_debug("%s: ECP transfer stalled!\n", port->name);

                parport_frob_control (port, PARPORT_CONTROL_INIT,
                                      PARPORT_CONTROL_INIT);
                udelay (50);
                if (parport_read_status (port) & PARPORT_STATUS_PAPEROUT) {
                        /* It's buggered. */
                        parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
                        break;
                }

                parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
                udelay (50);
                if (!(parport_read_status (port) & PARPORT_STATUS_PAPEROUT))
                        break;

                pr_debug("%s: Host transfer recovered\n", port->name);

                if (time_after_eq (jiffies, expire)) break;
                goto try_again;
        success:
                parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
                udelay (5);
                if (parport_wait_peripheral (port,
                                             PARPORT_STATUS_BUSY,
                                             PARPORT_STATUS_BUSY))
                        /* Peripheral hasn't accepted the data. */
                        break;
        }

        port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;

        return written;
#endif /* IEEE1284 support */
}

/* ECP mode, reverse channel, data. */
size_t parport_ieee1284_ecp_read_data (struct parport *port,
                                       void *buffer, size_t len, int flags)
{
#ifndef CONFIG_PARPORT_1284
        return 0;
#else
        struct pardevice *dev = port->cad;
        unsigned char *buf = buffer;
        int rle_count = 0; /* shut gcc up */
        unsigned char ctl;
        int rle = 0;
        ssize_t count = 0;

        port = port->physport;

        if (port->ieee1284.phase != IEEE1284_PH_REV_IDLE)
                if (ecp_forward_to_reverse (port))
                        return 0;

        port->ieee1284.phase = IEEE1284_PH_REV_DATA;

        /* Set HostAck low to start accepting data. */
        ctl = parport_read_control (port);
        ctl &= ~(PARPORT_CONTROL_STROBE | PARPORT_CONTROL_INIT |
                 PARPORT_CONTROL_AUTOFD);
        parport_write_control (port,
                               ctl | PARPORT_CONTROL_AUTOFD);
        while (count < len) {
                unsigned long expire = jiffies + dev->timeout;
                unsigned char byte;
                int command;

                /* Event 43: Peripheral sets nAck low. It can take as
                   long as it wants. */
                while (parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0)) {
                        /* The peripheral hasn't given us data in
                           35ms.  If we have data to give back to the
                           caller, do it now. */
                        if (count)
                                goto out;

                        /* If we've used up all the time we were allowed,
                           give up altogether. */
                        if (!time_before (jiffies, expire))
                                goto out;

                        /* Yield the port for a while. */
                        if (dev->port->irq != PARPORT_IRQ_NONE) {
                                parport_release (dev);
                                schedule_timeout_interruptible(msecs_to_jiffies(40));
                                parport_claim_or_block (dev);
                        }
                        else
                                /* We must have the device claimed here. */
                                parport_wait_event (port, msecs_to_jiffies(40));

                        /* Is there a signal pending? */
                        if (signal_pending (current))
                                goto out;
                }

                /* Is this a command? */
                if (rle)
                        /* The last byte was a run-length count, so
                           this can't be as well. */
                        command = 0;
                else
                        command = (parport_read_status (port) &
                                   PARPORT_STATUS_BUSY) ? 1 : 0;

                /* Read the data. */
                byte = parport_read_data (port);

                /* If this is a channel command, rather than an RLE
                   command or a normal data byte, don't accept it. */
                if (command) {
                        if (byte & 0x80) {
                                pr_debug("%s: stopping short at channel command (%02x)\n",
                                         port->name, byte);
                                goto out;
                        }
                        else if (port->ieee1284.mode != IEEE1284_MODE_ECPRLE)
                                pr_debug("%s: device illegally using RLE; accepting anyway\n",
                                         port->name);

                        rle_count = byte + 1;

                        /* Are we allowed to read that many bytes? */
                        if (rle_count > (len - count)) {
                                pr_debug("%s: leaving %d RLE bytes for next time\n",
                                         port->name, rle_count);
                                break;
                        }

                        rle = 1;
                }

                /* Event 44: Set HostAck high, acknowledging handshake. */
                parport_write_control (port, ctl);

                /* Event 45: The peripheral has 35ms to set nAck high. */
                if (parport_wait_peripheral (port, PARPORT_STATUS_ACK,
                                             PARPORT_STATUS_ACK)) {
                        /* It's gone wrong.  Return what data we have
                           to the caller. */
                        pr_debug("ECP read timed out at 45\n");

                        if (command)
                                pr_warn("%s: command ignored (%02x)\n",
                                        port->name, byte);

                        break;
                }

                /* Event 46: Set HostAck low and accept the data. */
                parport_write_control (port,
                                       ctl | PARPORT_CONTROL_AUTOFD);

                /* If we just read a run-length count, fetch the data. */
                if (command)
                        continue;

                /* If this is the byte after a run-length count, decompress. */
                if (rle) {
                        rle = 0;
                        memset (buf, byte, rle_count);
                        buf += rle_count;
                        count += rle_count;
                        pr_debug("%s: decompressed to %d bytes\n",
                                 port->name, rle_count);
                } else {
                        /* Normal data byte. */
                        *buf = byte;
                        buf++, count++;
                }
        }

 out:
        port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
        return count;
#endif /* IEEE1284 support */
}

/* ECP mode, forward channel, commands. */
size_t parport_ieee1284_ecp_write_addr (struct parport *port,
                                        const void *buffer, size_t len,
                                        int flags)
{
#ifndef CONFIG_PARPORT_1284
        return 0;
#else
        const unsigned char *buf = buffer;
        size_t written;
        int retry;

        port = port->physport;

        if (port->ieee1284.phase != IEEE1284_PH_FWD_IDLE)
                if (ecp_reverse_to_forward (port))
                        return 0;

        port->ieee1284.phase = IEEE1284_PH_FWD_DATA;

        /* HostAck low (command, not data) */
        parport_frob_control (port,
                              PARPORT_CONTROL_AUTOFD
                              | PARPORT_CONTROL_STROBE
                              | PARPORT_CONTROL_INIT,
                              PARPORT_CONTROL_AUTOFD
                              | PARPORT_CONTROL_INIT);
        for (written = 0; written < len; written++, buf++) {
                unsigned long expire = jiffies + port->cad->timeout;
                unsigned char byte;

                byte = *buf;
        try_again:
                parport_write_data (port, byte);
                parport_frob_control (port, PARPORT_CONTROL_STROBE,
                                      PARPORT_CONTROL_STROBE);
                udelay (5);
                for (retry = 0; retry < 100; retry++) {
                        if (!parport_wait_peripheral (port,
                                                      PARPORT_STATUS_BUSY, 0))
                                goto success;

                        if (signal_pending (current)) {
                                parport_frob_control (port,
                                                      PARPORT_CONTROL_STROBE,
                                                      0);
                                break;
                        }
                }

                /* Time for Host Transfer Recovery (page 41 of IEEE1284) */
                pr_debug("%s: ECP transfer stalled!\n", port->name);

                parport_frob_control (port, PARPORT_CONTROL_INIT,
                                      PARPORT_CONTROL_INIT);
                udelay (50);
                if (parport_read_status (port) & PARPORT_STATUS_PAPEROUT) {
                        /* It's buggered. */
                        parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
                        break;
                }

                parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
                udelay (50);
                if (!(parport_read_status (port) & PARPORT_STATUS_PAPEROUT))
                        break;

                pr_debug("%s: Host transfer recovered\n", port->name);

                if (time_after_eq (jiffies, expire)) break;
                goto try_again;
        success:
                parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
                udelay (5);
                if (parport_wait_peripheral (port,
                                             PARPORT_STATUS_BUSY,
                                             PARPORT_STATUS_BUSY))
                        /* Peripheral hasn't accepted the data. */
                        break;
        }

        port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;

        return written;
#endif /* IEEE1284 support */
}

/***              *
 * EPP functions. *
 *              ***/

/* EPP mode, forward channel, data. */
size_t parport_ieee1284_epp_write_data (struct parport *port,
                                        const void *buffer, size_t len,
                                        int flags)
{
        unsigned char *bp = (unsigned char *) buffer;
        size_t ret = 0;

        /* set EPP idle state (just to make sure) with strobe low */
        parport_frob_control (port,
                              PARPORT_CONTROL_STROBE |
                              PARPORT_CONTROL_AUTOFD |
                              PARPORT_CONTROL_SELECT |
                              PARPORT_CONTROL_INIT,
                              PARPORT_CONTROL_STROBE |
                              PARPORT_CONTROL_INIT);
        port->ops->data_forward (port);
        for (; len > 0; len--, bp++) {
                /* Event 62: Write data and set autofd low */
                parport_write_data (port, *bp);
                parport_frob_control (port, PARPORT_CONTROL_AUTOFD,
                                      PARPORT_CONTROL_AUTOFD);

                /* Event 58: wait for busy (nWait) to go high */
                if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 0, 10))
                        break;

                /* Event 63: set nAutoFd (nDStrb) high */
                parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);

                /* Event 60: wait for busy (nWait) to go low */
                if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY,
                                             PARPORT_STATUS_BUSY, 5))
                        break;

                ret++;
        }

        /* Event 61: set strobe (nWrite) high */
        parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);

        return ret;
}

/* EPP mode, reverse channel, data. */
size_t parport_ieee1284_epp_read_data (struct parport *port,
                                       void *buffer, size_t len,
                                       int flags)
{
        unsigned char *bp = (unsigned char *) buffer;
        unsigned ret = 0;

        /* set EPP idle state (just to make sure) with strobe high */
        parport_frob_control (port,
                              PARPORT_CONTROL_STROBE |
                              PARPORT_CONTROL_AUTOFD |
                              PARPORT_CONTROL_SELECT |
                              PARPORT_CONTROL_INIT,
                              PARPORT_CONTROL_INIT);
        port->ops->data_reverse (port);
        for (; len > 0; len--, bp++) {
                /* Event 67: set nAutoFd (nDStrb) low */
                parport_frob_control (port,
                                      PARPORT_CONTROL_AUTOFD,
                                      PARPORT_CONTROL_AUTOFD);
                /* Event 58: wait for Busy to go high */
                if (parport_wait_peripheral (port, PARPORT_STATUS_BUSY, 0)) {
                        break;
                }

                *bp = parport_read_data (port);

                /* Event 63: set nAutoFd (nDStrb) high */
                parport_frob_control (port, PARPORT_CONTROL_AUTOFD, 0);

                /* Event 60: wait for Busy to go low */
                if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY,
                                             PARPORT_STATUS_BUSY, 5)) {
                        break;
                }

                ret++;
        }
        port->ops->data_forward (port);

        return ret;
}

/* EPP mode, forward channel, addresses. */
size_t parport_ieee1284_epp_write_addr (struct parport *port,
                                        const void *buffer, size_t len,
                                        int flags)
{
        unsigned char *bp = (unsigned char *) buffer;
        size_t ret = 0;

        /* set EPP idle state (just to make sure) with strobe low */
        parport_frob_control (port,
                              PARPORT_CONTROL_STROBE |
                              PARPORT_CONTROL_AUTOFD |
                              PARPORT_CONTROL_SELECT |
                              PARPORT_CONTROL_INIT,
                              PARPORT_CONTROL_STROBE |
                              PARPORT_CONTROL_INIT);
        port->ops->data_forward (port);
        for (; len > 0; len--, bp++) {
                /* Event 56: Write data and set nAStrb low. */
                parport_write_data (port, *bp);
                parport_frob_control (port, PARPORT_CONTROL_SELECT,
                                      PARPORT_CONTROL_SELECT);

                /* Event 58: wait for busy (nWait) to go high */
                if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 0, 10))
                        break;

                /* Event 59: set nAStrb high */
                parport_frob_control (port, PARPORT_CONTROL_SELECT, 0);

                /* Event 60: wait for busy (nWait) to go low */
                if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY,
                                             PARPORT_STATUS_BUSY, 5))
                        break;

                ret++;
        }

        /* Event 61: set strobe (nWrite) high */
        parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);

        return ret;
}

/* EPP mode, reverse channel, addresses. */
size_t parport_ieee1284_epp_read_addr (struct parport *port,
                                       void *buffer, size_t len,
                                       int flags)
{
        unsigned char *bp = (unsigned char *) buffer;
        unsigned ret = 0;

        /* Set EPP idle state (just to make sure) with strobe high */
        parport_frob_control (port,
                              PARPORT_CONTROL_STROBE |
                              PARPORT_CONTROL_AUTOFD |
                              PARPORT_CONTROL_SELECT |
                              PARPORT_CONTROL_INIT,
                              PARPORT_CONTROL_INIT);
        port->ops->data_reverse (port);
        for (; len > 0; len--, bp++) {
                /* Event 64: set nSelectIn (nAStrb) low */
                parport_frob_control (port, PARPORT_CONTROL_SELECT,
                                      PARPORT_CONTROL_SELECT);

                /* Event 58: wait for Busy to go high */
                if (parport_wait_peripheral (port, PARPORT_STATUS_BUSY, 0)) {
                        break;
                }

                *bp = parport_read_data (port);

                /* Event 59: set nSelectIn (nAStrb) high */
                parport_frob_control (port, PARPORT_CONTROL_SELECT,
                                      0);

                /* Event 60: wait for Busy to go low */
                if (parport_poll_peripheral (port, PARPORT_STATUS_BUSY, 
                                             PARPORT_STATUS_BUSY, 5))
                        break;

                ret++;
        }
        port->ops->data_forward (port);

        return ret;
}

EXPORT_SYMBOL(parport_ieee1284_ecp_write_data);
EXPORT_SYMBOL(parport_ieee1284_ecp_read_data);
EXPORT_SYMBOL(parport_ieee1284_ecp_write_addr);
EXPORT_SYMBOL(parport_ieee1284_write_compat);
EXPORT_SYMBOL(parport_ieee1284_read_nibble);
EXPORT_SYMBOL(parport_ieee1284_read_byte);
EXPORT_SYMBOL(parport_ieee1284_epp_write_data);
EXPORT_SYMBOL(parport_ieee1284_epp_read_data);
EXPORT_SYMBOL(parport_ieee1284_epp_write_addr);
EXPORT_SYMBOL(parport_ieee1284_epp_read_addr);