/* $NetBSD: if_plip.c,v 1.38 2022/09/04 15:59:08 rjs Exp $ */

/*-
 * Copyright (c) 1997 Poul-Henning Kamp
 * Copyright (c) 2003, 2004 Gary Thorpe <gathorpe@users.sourceforge.net>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 *      From Id: lpt.c,v 1.55.2.1 1996/11/12 09:08:38 phk Exp
 * FreeBSD: src/sys/dev/ppbus/if_plip.c,v 1.19.2.1 2000/05/24 00:20:57 n_hibma Exp
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: if_plip.c,v 1.38 2022/09/04 15:59:08 rjs Exp $");

/*
 * Parallel port TCP/IP interfaces added.  I looked at the driver from
 * MACH but this is a complete rewrite, and btw. incompatible, and it
 * should perform better too.  I have never run the MACH driver though.
 *
 * This driver sends two bytes (0x08, 0x00) in front of each packet,
 * to allow us to distinguish another format later.
 *
 * Now added a Linux/Crynwr compatibility mode which is enabled using
 * IF_LINK0 - Tim Wilkinson.
 *
 * TODO:
 *    Make HDLC/PPP mode, use IF_LLC1 to enable.
 *
 * Connect the two computers using a Laplink parallel cable to use this
 * feature:
 *
 *      +----------------------------------------+
 *      |A-name A-End   B-End   Descr.  Port/Bit |
 *      +----------------------------------------+
 *      |DATA0  2       15      Data    0/0x01   |
 *      |-ERROR 15      2               1/0x08   |
 *      +----------------------------------------+
 *      |DATA1  3       13      Data    0/0x02   |
 *      |+SLCT  13      3               1/0x10   |
 *      +----------------------------------------+
 *      |DATA2  4       12      Data    0/0x04   |
 *      |+PE    12      4               1/0x20   |
 *      +----------------------------------------+
 *      |DATA3  5       10      Strobe  0/0x08   |
 *      |-ACK   10      5               1/0x40   |
 *      +----------------------------------------+
 *      |DATA4  6       11      Data    0/0x10   |
 *      |BUSY   11      6               1/~0x80  |
 *      +----------------------------------------+
 *      |GND    18-25   18-25   GND     -        |
 *      +----------------------------------------+
 *
 * Expect transfer-rates up to 75 kbyte/sec.
 *
 * If GCC could correctly grok
 *      register int port __asm("edx")
 * the code would be cleaner
 *
 * Poul-Henning Kamp <phk@freebsd.org>
 */

/*
 * Update for ppbus, PLIP support only - Nicolas Souchu
 */

#include "opt_inet.h"
#include "opt_plip.h"

#include <sys/systm.h>
#include <sys/param.h>
#include <sys/proc.h>
#include <sys/types.h>
#include <sys/device.h>
#include <sys/ioctl.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>

#include <net/if.h>
#include <net/if_types.h>

#include <sys/time.h>
#include <net/bpf.h>

#ifdef INET
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/in_var.h>
#include <netinet/ip.h>
#else
#error Cannot config lp/plip without inet
#endif

#include <dev/ppbus/ppbus_base.h>
#include <dev/ppbus/ppbus_device.h>
#include <dev/ppbus/ppbus_io.h>
#include <dev/ppbus/ppbus_var.h>

#include <machine/types.h>
#include <sys/intr.h>

#ifndef LPMTU                   /* MTU for the lp# interfaces */
#define LPMTU           1500
#endif

#ifndef LPMAXSPIN1              /* DELAY factor for the lp# interfaces */
#define LPMAXSPIN1      8000    /* Spinning for remote intr to happen */
#endif

#ifndef LPMAXSPIN2              /* DELAY factor for the lp# interfaces */
#define LPMAXSPIN2      500     /* Spinning for remote handshake to happen */
#endif

#ifndef LPMAXERRS               /* Max errors before !RUNNING */
#define LPMAXERRS       100
#endif

#ifndef LPMAXRTRY
#define LPMAXRTRY       100     /* If channel busy, retry LPMAXRTRY
                                        consecutive times */
#endif

#define CLPIPHDRLEN     14      /* We send dummy ethernet addresses (two) + packet type in front of packet */
#define CLPIP_SHAKE     0x80    /* This bit toggles between nibble reception */
#define MLPIPHDRLEN     CLPIPHDRLEN

#define LPIPHDRLEN      2       /* We send 0x08, 0x00 in front of packet */
#define LPIP_SHAKE      0x40    /* This bit toggles between nibble reception */
#if !defined(MLPIPHDRLEN) || LPIPHDRLEN > MLPIPHDRLEN
#define MLPIPHDRLEN     LPIPHDRLEN
#endif

#define LPIPTBLSIZE     256     /* Size of octet translation table */

#define LP_PRINTF       if (lpflag) printf

#ifdef PLIP_DEBUG
static int volatile lpflag = 1;
#else
static int volatile lpflag = 0;
#endif

/* Tx/Rsv tables for the lp interface */
static u_char *txmith;
#define txmitl (txmith+(1*LPIPTBLSIZE))
#define trecvh (txmith+(2*LPIPTBLSIZE))
#define trecvl (txmith+(3*LPIPTBLSIZE))
static u_char *ctxmith;
#define ctxmitl (ctxmith+(1*LPIPTBLSIZE))
#define ctrecvh (ctxmith+(2*LPIPTBLSIZE))
#define ctrecvl (ctxmith+(3*LPIPTBLSIZE))
static uint16_t lp_count = 0;

/* Autoconf functions */
static int lp_probe(device_t, cfdata_t, void *);
static void lp_attach(device_t, device_t, void *);
static int lp_detach(device_t, int);

/* Soft config data */
struct lp_softc {
        struct ppbus_device_softc ppbus_dev;
        struct ifnet sc_if;
        u_char *sc_ifbuf;
        unsigned short sc_iferrs;
        unsigned short sc_xmit_rtry;
        u_int8_t sc_dev_ok; /* Zero means ok */
};

/* Autoconf structure */
CFATTACH_DECL_NEW(plip, sizeof(struct lp_softc), lp_probe, lp_attach, lp_detach,
        NULL);

/* Functions for the lp interface */
static void lpinittables(void);
static void lpfreetables(void);
static int lpioctl(struct ifnet *, u_long, void *);
static int lpoutput(struct ifnet *, struct mbuf *, const struct sockaddr *,
    const struct rtentry *);
static void lpstart(struct ifnet *);
static void lp_intr(void *);


static int
lp_probe(device_t parent, cfdata_t match, void *aux)
{
        struct ppbus_attach_args * args = aux;

        /* Fail if ppbus is not interrupt capable */
        if (args->capabilities & PPBUS_HAS_INTR)
                return 1;

        printf("%s(%s): not an interrupt-driven port.\n", __func__,
                device_xname(parent));
        return 0;
}

static void
lp_attach(device_t parent, device_t self, void *aux)
{
        struct lp_softc * lp = device_private(self);
        struct ifnet * ifp = &lp->sc_if;

        lp->ppbus_dev.sc_dev = self;
        lp->sc_dev_ok = 0;
        lp->sc_ifbuf = NULL;
        lp->sc_iferrs = 0;
        lp->sc_xmit_rtry = 0;

        ifp->if_softc = lp;
        strlcpy(ifp->if_xname, device_xname(self), IFNAMSIZ);
        ifp->if_mtu = LPMTU;
        ifp->if_flags = IFF_SIMPLEX | IFF_POINTOPOINT | IFF_MULTICAST;
        ifp->if_ioctl = lpioctl;
        ifp->if_output = lpoutput;
        ifp->if_start = lpstart;
        ifp->if_type = IFT_PARA;
        ifp->if_hdrlen = 0;
        ifp->if_addrlen = 0;
        ifp->if_dlt = DLT_NULL;
        IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN);
        IFQ_SET_READY(&ifp->if_snd);
        if_attach(ifp);
        if_alloc_sadl(ifp);

        bpf_attach(ifp, DLT_NULL, sizeof(u_int32_t));

        if (lp_count++ == 0)
                lpinittables();
        printf("\n");
}

static int
lp_detach(device_t self, int flags)
{
        int error = 0;
        struct lp_softc * lp = device_private(self);
        device_t ppbus = device_parent(self);

        if (lp->sc_dev_ok) {
                if (!(flags & DETACH_QUIET))
                        LP_PRINTF("%s(%s): device not properly attached! "
                                "Skipping detach....\n", __func__,
                                device_xname(self));
                return error;
        }

        /* If interface is up, bring it down and release ppbus */
        if (lp->sc_if.if_flags & IFF_RUNNING) {
                ppbus_wctr(ppbus, 0x00);
                if_detach(&lp->sc_if);
                error = ppbus_remove_handler(ppbus, lp_intr);
                if (error) {
                        if (!(flags & DETACH_QUIET))
                                LP_PRINTF("%s(%s): unable to remove interrupt "
                                        "callback.\n", __func__,
                                        device_xname(self));
                        if (!(flags & DETACH_FORCE))
                                return error;
                }
                error = ppbus_release_bus(ppbus, self, 0, 0);
                if (error) {
                        if (!(flags & DETACH_QUIET))
                                LP_PRINTF("%s(%s): error releasing bus %s.\n",
                                        __func__, device_xname(self),
                                        device_xname(ppbus));
                        if (!(flags & DETACH_FORCE))
                                return error;
                }
        }

        if (lp->sc_ifbuf)
                free(lp->sc_ifbuf, M_DEVBUF);

        if (--lp_count == 0)
                lpfreetables();
        return error;
}

/*
 * Build the translation tables for the LPIP (BSD unix) protocol.
 * We don't want to calculate these nasties in our tight loop, so we
 * precalculate them when we initialize.
 */
static void
lpinittables(void)
{
        int i;

        if (!txmith)
                txmith = malloc(4*LPIPTBLSIZE, M_DEVBUF, M_WAITOK);

        if (!ctxmith)
                ctxmith = malloc(4*LPIPTBLSIZE, M_DEVBUF, M_WAITOK);

        for (i = 0; i < LPIPTBLSIZE; i++) {
                ctxmith[i] = (i & 0xF0) >> 4;
                ctxmitl[i] = 0x10 | (i & 0x0F);
                ctrecvh[i] = (i & 0x78) << 1;
                ctrecvl[i] = (i & 0x78) >> 3;
        }

        for (i = 0; i < LPIPTBLSIZE; i++) {
                txmith[i] = ((i & 0x80) >> 3) | ((i & 0x70) >> 4) | 0x08;
                txmitl[i] = ((i & 0x08) << 1) | (i & 0x07);
                trecvh[i] = ((~i) & 0x80) | ((i & 0x38) << 1);
                trecvl[i] = (((~i) & 0x80) >> 4) | ((i & 0x38) >> 3);
        }
}

/* Free translation tables */
static void
lpfreetables(void)
{
        if (txmith)
                free(txmith, M_DEVBUF);
        if (ctxmith)
                free(ctxmith, M_DEVBUF);
        txmith = ctxmith = NULL;
}


/* Process an ioctl request. */
static int
lpioctl(struct ifnet *ifp, u_long cmd, void *data)
{
        struct lp_softc * sc = ifp->if_softc;
        device_t dev = sc->ppbus_dev.sc_dev;
        device_t ppbus = device_parent(dev);
        struct ifaddr * ifa = (struct ifaddr *)data;
        struct ifreq * ifr = (struct ifreq *)data;
        u_char * ptr;
        int error, s;

        error = 0;
        s = splnet();

        if (sc->sc_dev_ok) {
                LP_PRINTF("%s(%s): device not properly attached!", __func__,
                        device_xname(dev));
                error = ENODEV;
                goto end;
        }

        switch (cmd) {

        case SIOCSIFDSTADDR:
                if (ifa->ifa_addr->sa_family != AF_INET)
                        error = EAFNOSUPPORT;
                break;

        case SIOCINITIFADDR:
                if (ifa->ifa_addr->sa_family != AF_INET) {
                        error = EAFNOSUPPORT;
                        break;
                }
                ifp->if_flags |= IFF_UP;
        /* FALLTHROUGH */
        case SIOCSIFFLAGS:
                if (cmd == SIOCSIFFLAGS) {
                        if ((error = ifioctl_common(ifp, cmd, data)) != 0)
                                break;
                }
                if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) == IFF_UP) {
                        if ((error = ppbus_request_bus(ppbus, dev, 0, 0)))
                                break;
                        error = ppbus_set_mode(ppbus, PPBUS_COMPATIBLE, 0);
                        if (error)
                                break;

                        error = ppbus_add_handler(ppbus, lp_intr, dev);
                        if (error) {
                                LP_PRINTF("%s(%s): unable to register interrupt"
                                        " callback.\n", __func__,
                                        device_xname(dev));
                                ppbus_release_bus(ppbus, dev, 0, 0);
                                break;
                        }

                        /* Allocate a buffer if necessary */
                        if (sc->sc_ifbuf == NULL) {
                                sc->sc_ifbuf = malloc(sc->sc_if.if_mtu +
                                        MLPIPHDRLEN, M_DEVBUF, M_WAITOK);
                        }

                        ppbus_wctr(ppbus, IRQENABLE);
                        ifp->if_flags |= IFF_RUNNING;
                }
                if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) == IFF_RUNNING) {
                        ppbus_remove_handler(ppbus, lp_intr);
                        error = ppbus_release_bus(ppbus, dev, 0, 0);
                        ifp->if_flags &= ~IFF_RUNNING;
                }
                /* Go quiescent */
                ppbus_wdtr(ppbus, 0);
                break;

        case SIOCSIFMTU:
                if (sc->sc_if.if_mtu == ifr->ifr_mtu)
                        break;
                ptr = sc->sc_ifbuf;
                sc->sc_ifbuf = malloc(ifr->ifr_mtu + MLPIPHDRLEN, M_DEVBUF,
                        M_WAITOK);
                if (ptr)
                        free(ptr,M_DEVBUF);
                /*FALLTHROUGH*/
        case SIOCGIFMTU:
                if ((error = ifioctl_common(ifp, cmd, data)) == ENETRESET)
                        error = 0;
                break;

        case SIOCADDMULTI:
        case SIOCDELMULTI:
                if (ifr == NULL) {
                        error = EAFNOSUPPORT;           /* XXX */
                        break;
                }
                switch (ifreq_getaddr(cmd, ifr)->sa_family) {
                case AF_INET:
                        break;
                default:
                        splx(s);
                        return EAFNOSUPPORT;
                }
                break;

        case SIOCGIFMEDIA:
                /*
                 * No ifmedia support at this stage; maybe use it
                 * in future for eg. protocol selection.
                 */
        default:
                LP_PRINTF("LP:ioctl(0x%lx)\n", cmd);
                error = ifioctl_common(ifp, cmd, data);
        }

end:
        splx(s);
        return error;
}

static inline int
clpoutbyte(u_char byte, int spin, device_t ppbus)
{
        int s = spin;
        ppbus_wdtr(ppbus, ctxmitl[byte]);
        while (ppbus_rstr(ppbus) & CLPIP_SHAKE) {
                if (--s == 0) {
                        return 1;
                }
        }
        s = spin;
        ppbus_wdtr(ppbus, ctxmith[byte]);
        while (!(ppbus_rstr(ppbus) & CLPIP_SHAKE)) {
                if (--s == 0) {
                        return 1;
                }
        }
        return 0;
}

static inline int
clpinbyte(int spin, device_t ppbus)
{
        u_char c, cl;
        int s = spin;

        while (ppbus_rstr(ppbus) & CLPIP_SHAKE) {
                if (!--s) {
                        return -1;
                }
        }
        cl = ppbus_rstr(ppbus);
        ppbus_wdtr(ppbus, 0x10);

        s = spin;
        while (!(ppbus_rstr(ppbus) & CLPIP_SHAKE)) {
                if (!--s) {
                        return -1;
                }
        }
        c = ppbus_rstr(ppbus);
        ppbus_wdtr(ppbus, 0x00);

        return (ctrecvl[cl] | ctrecvh[c]);
}

static void
lptap(struct ifnet *ifp, struct mbuf *m, u_int direction)
{
        /*
         * Send a packet through bpf. We need to prepend the address family
         * as a four byte field. Cons up a dummy header to pacify bpf. This
         * is safe because bpf will only read from the mbuf (i.e., it won't
         * try to free it or keep a pointer to it).
         */
        u_int32_t af = AF_INET;
        struct mbuf m0;

        m0.m_type = MT_DATA;
        m0.m_next = m;
        m0.m_nextpkt = NULL;
        m0.m_owner = NULL;
        m0.m_len = sizeof(u_int32_t);
        m0.m_data = (char *)&af;
        m0.m_flags = 0;
        bpf_mtap(ifp, &m0, direction);
}

/* Soft interrupt handler called by hardware interrupt handler */
static void
lp_intr(void *arg)
{
        device_t dev = (device_t)arg;
        device_t ppbus = device_parent(dev);
        struct lp_softc * sc = device_private(dev);
        struct ifnet * ifp = &sc->sc_if;
        struct mbuf *top;
        int len, s, j;
        u_char *bp;
        u_char c, cl;

        s = splnet();

        /* Do nothing if device not properly attached */
        if (sc->sc_dev_ok) {
                LP_PRINTF("%s(%s): device not properly attached!", __func__,
                        device_xname(dev));
                goto done;
        }

        /* Do nothing if interface is not up */
        if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
                goto done;

        /* If other side is no longer transmitting, do nothing */
        if (!(ppbus_rstr(ppbus) & LPIP_SHAKE))
                goto done;

        /* Disable interrupts until we finish */
        ppbus_wctr(ppbus, ~IRQENABLE);

        top = NULL;
        bp = sc->sc_ifbuf;
        /* Linux/crynwyr protocol receiving */
        if (ifp->if_flags & IFF_LINK0) {
                /* Ack. the request */
                ppbus_wdtr(ppbus, 0x01);

                /* Get the packet length */
                j = clpinbyte(LPMAXSPIN2, ppbus);
                if (j == -1)
                        goto err;
                len = j;
                j = clpinbyte(LPMAXSPIN2, ppbus);
                if (j == -1)
                        goto err;
                len = len + (j << 8);
                if (len > ifp->if_mtu + MLPIPHDRLEN)
                        goto err;

                while (len--) {
                        j = clpinbyte(LPMAXSPIN2, ppbus);
                        if (j == -1) {
                                goto err;
                        }
                        *bp++ = j;
                }
                /* Get and ignore checksum */
                j = clpinbyte(LPMAXSPIN2, ppbus);
                if (j == -1) {
                        goto err;
                }

                /* Return to idle state */
                ppbus_wdtr(ppbus, 0);
                len = bp - sc->sc_ifbuf;
                if (len <= CLPIPHDRLEN)
                        goto err;
                len -= CLPIPHDRLEN;
                top = m_devget(sc->sc_ifbuf + CLPIPHDRLEN, len, 0, ifp);
        }
        /* FreeBSD protocol receiving */
        else {
                len = ifp->if_mtu + LPIPHDRLEN;
                while (len--) {
                        cl = ppbus_rstr(ppbus);
                        ppbus_wdtr(ppbus, 0x08);

                        j = LPMAXSPIN2;
                        while ((ppbus_rstr(ppbus) & LPIP_SHAKE)) {
                                if (!--j)
                                        goto err;
                        }

                        c = ppbus_rstr(ppbus);
                        ppbus_wdtr(ppbus, 0);

                        *bp++= trecvh[cl] | trecvl[c];

                        j = LPMAXSPIN2;
                        while (!((cl = ppbus_rstr(ppbus)) & LPIP_SHAKE)) {
                                if (cl != c &&
                                        (((cl = ppbus_rstr(ppbus)) ^ 0xb8) &
                                        0xf8) == (c & 0xf8))
                                        goto end;
                                if (!--j)
                                        goto err;
                        }
                }

end:
                len = bp - sc->sc_ifbuf;
                if (len <= LPIPHDRLEN)
                        goto err;
                len -= LPIPHDRLEN;
                top = m_devget(sc->sc_ifbuf + LPIPHDRLEN, len, 0, ifp);
        }

        if (top == NULL) {
                if_statinc(ifp, if_iqdrops);
                goto err;
        }
        if (ifp->if_bpf) {
                lptap(ifp, top, BPF_D_IN);
        }
        if (__predict_false(!pktq_enqueue(ip_pktq, top, 0))) {
                if_statinc(ifp, if_iqdrops);
                m_freem(top);
                goto err;
        }
        if_statinc(ifp, if_ipackets);
        if_statadd(ifp, if_ibytes, len);
        sc->sc_iferrs = 0;

        goto done;

err:
        /* Return to idle state */
        ppbus_wdtr(ppbus, 0);
        if_statinc(ifp, if_ierrors);
        sc->sc_iferrs++;
        LP_PRINTF("R");
        /* Disable interface if there are too many errors */
        if (sc->sc_iferrs > LPMAXERRS) {
                aprint_error_dev(dev, "Too many consecutive errors, going off-line.\n");
                ppbus_wctr(ppbus, ~IRQENABLE);
                if_down(ifp);
                sc->sc_iferrs = 0;
        }

done:
        /* Re-enable interrupts */
        ppbus_wctr(ppbus, IRQENABLE);
        /* If interface is not active, send some packets */
        if ((ifp->if_flags & IFF_OACTIVE) == 0)
                lpstart(ifp);
        splx(s);
        return;
}

static inline int
lpoutbyte(u_char byte, int spin, device_t ppbus)
{
        int s = spin;
        ppbus_wdtr(ppbus, txmith[byte]);
        while (!(ppbus_rstr(ppbus) & LPIP_SHAKE)) {
                if (--s == 0)
                        return 1;
        }
        s = spin;
        ppbus_wdtr(ppbus, txmitl[byte]);
        while (ppbus_rstr(ppbus) & LPIP_SHAKE) {
                if (--s == 0)
                        return 1;
        }
        return 0;
}

/* Queue a packet for delivery */
static int
lpoutput(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst,
    const struct rtentry *rt)
{
        struct lp_softc * sc = ifp->if_softc;
        device_t dev = sc->ppbus_dev.sc_dev;
        device_t ppbus = device_parent(dev);
        int err;
        int s;

        s = splnet();

        if (sc->sc_dev_ok) {
                LP_PRINTF("%s(%s): device not properly attached!", __func__,
                        device_xname(dev));
                err = ENODEV;
                goto endoutput;
        }

        if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
                err = ENETDOWN;
                goto endoutput;
        }

        /* Only support INET */
        if (dst->sa_family != AF_INET) {
                LP_PRINTF("%s: af%d not supported\n", ifp->if_xname,
                    dst->sa_family);
                if_statinc(ifp, if_noproto);
                err = EAFNOSUPPORT;
                goto endoutput;
        }

        IFQ_CLASSIFY(&ifp->if_snd, m, dst->sa_family);
        IFQ_ENQUEUE(&ifp->if_snd, m, err);
        if (err == 0) {
                if ((ifp->if_flags & IFF_OACTIVE) == 0)
                        lpstart(ifp);
        } else {
                if_statinc(ifp, if_oerrors);
                sc->sc_iferrs++;
                LP_PRINTF("Q");

                /* Disable interface if there are too many errors */
                if (sc->sc_iferrs > LPMAXERRS) {
                        aprint_error_dev(dev, "Too many errors, going off-line.\n");
                        ppbus_wctr(ppbus, ~IRQENABLE);
                        if_down(ifp);
                        sc->sc_iferrs = 0;
                }
        }

endoutput:
        if ((err != 0) && (err != ENOBUFS))
                m_freem(m);
        splx(s);
        return err;
}

/* Send routine: send packets over PLIP cable. Call at splnet(). */
void
lpstart(struct ifnet * ifp)
{
        struct lp_softc * lp = ifp->if_softc;
        device_t dev = lp->ppbus_dev.sc_dev;
        device_t ppbus = device_parent(dev);
        struct mbuf * mm;
        struct mbuf * m;
        u_char * cp;
        int err, i, len, spin, count;
        u_char str, chksum;

        if (lp->sc_dev_ok) {
                LP_PRINTF("%s(%s): device not properly attached!", __func__,
                        device_xname(dev));
                return;
        }

        if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
                return;
        }

        ifp->if_flags |= IFF_OACTIVE;

        /* Go quiescent */
        ppbus_wdtr(ppbus, 0);

        /* Output loop */
        for (;;) {
                /* Check if there are packets to send */
                if (IFQ_IS_EMPTY(&ifp->if_snd)) {
                        goto final;
                }
                /* Try to send a packet, dequeue it later if successful */
                IFQ_POLL(&ifp->if_snd, m);
                if (m == NULL)
                        goto final;

                str = ppbus_rstr(ppbus);
                /* Wait until other side is not transmitting */
                if ((str & LPIP_SHAKE) ||
                        ((ifp->if_flags & IFF_LINK0) && !(str & CLPIP_SHAKE))) {
                        LP_PRINTF("&");
                        if (++lp->sc_xmit_rtry > LPMAXRTRY) {
                                aprint_error_dev(dev, "Too many retries while channel "
                                        "busy, going off-line.\n");
                                ppbus_wctr(ppbus, ~IRQENABLE);
                                if_down(ifp);
                                lp->sc_xmit_rtry = 0;
                        }
                        goto final;
                }
                lp->sc_xmit_rtry = 0;

                /* Disable interrupt generation */
                ppbus_wctr(ppbus, ~IRQENABLE);

                err = 1;

                /* Output packet for Linux/crynwyr compatible protocol */
                if (ifp->if_flags & IFF_LINK0) {
                        /* Calculate packet length */
                        count = 14;             /* Ethernet header len */
                        for (mm = m; mm; mm = mm->m_next) {
                                count += mm->m_len;
                        }

                        /* Alert other end to pending packet */
                        spin = LPMAXSPIN1;
                        ppbus_wdtr(ppbus, 0x08);
                        while ((ppbus_rstr(ppbus) & 0x08) == 0) {
                                if (--spin == 0) {
                                        goto nend;
                                }
                        }

                        if (clpoutbyte(count & 0xFF, LPMAXSPIN1, ppbus))
                                goto nend;
                        if (clpoutbyte((count >> 8) & 0xFF, LPMAXSPIN1, ppbus))
                                goto nend;

                        /* Send dummy ethernet header */
                        chksum = 0;
                        for (i = 0; i < 12; i++) {
                                if (clpoutbyte(i, LPMAXSPIN1, ppbus))
                                        goto nend;
                                chksum += i;
                        }

                        if (clpoutbyte(0x08, LPMAXSPIN1, ppbus))
                                goto nend;
                        if (clpoutbyte(0x00, LPMAXSPIN1, ppbus))
                                goto nend;
                        chksum += 0x08 + 0x00;          /* Add into checksum */

                        mm = m;
                        do {
                                cp = mtod(mm, u_char *);
                                len = mm->m_len;
                                while (len--) {
                                        if (clpoutbyte(*cp, LPMAXSPIN2, ppbus))
                                                goto nend;
                                        chksum += *cp++;
                                }
                        } while ((mm = mm->m_next));

                        /* Send checksum */
                        if (clpoutbyte(chksum, LPMAXSPIN2, ppbus))
                                goto nend;

                        /* No errors */
                        err = 0;
                        /* Go quiescent */
                        ppbus_wdtr(ppbus, 0);
                }
                /* Output packet for FreeBSD compatible protocol */
                else {
                        /* We need a sensible value if we abort */
                        cp = NULL;

                        if (lpoutbyte(0x08, LPMAXSPIN1, ppbus))
                                goto end;
                        if (lpoutbyte(0x00, LPMAXSPIN2, ppbus))
                                goto end;

                        mm = m;
                        do {
                                cp = mtod(mm,u_char *);
                                len = mm->m_len;
                                while (len--)
                                        if (lpoutbyte(*cp++, LPMAXSPIN2, ppbus))
                                                goto end;
                        } while ((mm = mm->m_next));

                        /* no errors were encountered */
                        err = 0;

end:
                        if (cp)
                                ppbus_wdtr(ppbus, txmitl[*(--cp)] ^ 0x17);
                        else
                                ppbus_wdtr(ppbus, txmitl['\0'] ^ 0x17);
                }

nend:
                /* Re-enable interrupt generation */
                ppbus_wctr(ppbus, IRQENABLE);

                if (err) {
                        /* Go quiescent */
                        ppbus_wdtr(ppbus, 0);

                        if_statinc(ifp, if_oerrors);
                        lp->sc_iferrs++;
                        LP_PRINTF("X");

                        /* Disable interface if there are too many errors */
                        if (lp->sc_iferrs > LPMAXERRS) {
                                aprint_error_dev(dev, "Too many errors, going off-line.\n");
                                ppbus_wctr(ppbus, ~IRQENABLE);
                                if_down(ifp);
                                lp->sc_iferrs = 0;
                                goto final;
                        }
                } else {
                        /* Dequeue packet on success */
                        IFQ_DEQUEUE(&ifp->if_snd, m);
                        if(ifp->if_bpf)
                                lptap(ifp, m, BPF_D_OUT);
                        if_statinc(ifp, if_opackets);
                        if_statadd(ifp, if_obytes, m->m_pkthdr.len);
                        m_freem(m);
                }
        }

final:
        ifp->if_flags &= ~IFF_OACTIVE;
        return;
}