freebsd-dev/sys/dev/ppbus/if_plip.c

/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 1997 Poul-Henning Kamp
 * 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
 */

#include <sys/cdefs.h>
/*
 * 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_plip.h"

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/module.h>
#include <sys/bus.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/kernel.h>
#include <sys/malloc.h>

#include <machine/bus.h>
#include <machine/resource.h>
#include <sys/rman.h>

#include <net/if.h>
#include <net/if_var.h>
#include <net/if_types.h>
#include <net/netisr.h>
#include <net/route.h>

#include <netinet/in.h>
#include <netinet/in_var.h>

#include <net/bpf.h>

#include <dev/ppbus/ppbconf.h>
#include "ppbus_if.h"
#include <dev/ppbus/ppbio.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

#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	lprintf		if (lptflag) printf

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

struct lp_data {
	struct  ifnet	*sc_ifp;
	device_t	sc_dev;
	u_char		*sc_ifbuf;
	int		sc_iferrs;

	struct resource *res_irq;
	void		*sc_intr_cookie;
};

static struct mtx lp_tables_lock;
MTX_SYSINIT(lp_tables, &lp_tables_lock, "plip tables", MTX_DEF);

/* 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))

/* Functions for the lp# interface */
static int lpinittables(void);
static int lpioctl(if_t, u_long, caddr_t);
static int lpoutput(if_t, struct mbuf *, const struct sockaddr *,
       struct route *);
static void lpstop(struct lp_data *);
static void lp_intr(void *);
static int lp_module_handler(module_t, int, void *);

#define	DEVTOSOFTC(dev) \
	((struct lp_data *)device_get_softc(dev))

static int
lp_module_handler(module_t mod, int what, void *arg)
{

	switch (what) {
	case MOD_UNLOAD:
		mtx_lock(&lp_tables_lock);
		if (txmith != NULL) {
			free(txmith, M_DEVBUF);
			txmith = NULL;
		}
		if (ctxmith != NULL) {
			free(ctxmith, M_DEVBUF);
			ctxmith = NULL;
		}
		mtx_unlock(&lp_tables_lock);
		break;
	case MOD_LOAD:
	case MOD_QUIESCE:
		break;
	default:
		return (EOPNOTSUPP);
	}
	return (0);
}

static void
lp_identify(driver_t *driver, device_t parent)
{
	device_t dev;

	dev = device_find_child(parent, "plip", -1);
	if (!dev)
		BUS_ADD_CHILD(parent, 0, "plip", -1);
}

static int
lp_probe(device_t dev)
{

	device_set_desc(dev, "PLIP network interface");

	return (0);
}

static int
lp_attach(device_t dev)
{
	struct lp_data *lp = DEVTOSOFTC(dev);
	if_t ifp;
	int error, rid = 0;

	lp->sc_dev = dev;

	/*
	 * Reserve the interrupt resource.  If we don't have one, the
	 * attach fails.
	 */
	lp->res_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
	    RF_SHAREABLE);
	if (lp->res_irq == NULL) {
		device_printf(dev, "cannot reserve interrupt, failed.\n");
		return (ENXIO);
	}

	ifp = lp->sc_ifp = if_alloc(IFT_PARA);
	if (ifp == NULL) {
		return (ENOSPC);
	}

	if_setsoftc(ifp, lp);
	if_initname(ifp, device_get_name(dev), device_get_unit(dev));
	if_setmtu(ifp, LPMTU);
	if_setflags(ifp, IFF_SIMPLEX | IFF_POINTOPOINT | IFF_MULTICAST);
	if_setioctlfn(ifp, lpioctl);
	if_setoutputfn(ifp, lpoutput);
	if_setsendqlen(ifp, ifqmaxlen);
	if_attach(ifp);

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

	/*
	 * Attach our interrupt handler.  It is only called while we
	 * own the ppbus.
	 */
	error = bus_setup_intr(dev, lp->res_irq, INTR_TYPE_NET | INTR_MPSAFE,
	    NULL, lp_intr, lp, &lp->sc_intr_cookie);
	if (error) {
		bpfdetach(ifp);
		if_detach(ifp);
		bus_release_resource(dev, SYS_RES_IRQ, 0, lp->res_irq);
		device_printf(dev, "Unable to register interrupt handler\n");
		return (error);
	}

	return (0);
}

static int
lp_detach(device_t dev)
{
	struct lp_data *sc = device_get_softc(dev);
	device_t ppbus = device_get_parent(dev);

	ppb_lock(ppbus);
	lpstop(sc);
	ppb_unlock(ppbus);
	bpfdetach(sc->sc_ifp);
	if_detach(sc->sc_ifp);
	bus_teardown_intr(dev, sc->res_irq, sc->sc_intr_cookie);
	bus_release_resource(dev, SYS_RES_IRQ, 0, sc->res_irq);
	return (0);
}

/*
 * 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 int
lpinittables(void)
{
	int i;

	mtx_lock(&lp_tables_lock);
	if (txmith == NULL)
		txmith = malloc(4 * LPIPTBLSIZE, M_DEVBUF, M_NOWAIT);

	if (txmith == NULL) {
		mtx_unlock(&lp_tables_lock);
		return (1);
	}

	if (ctxmith == NULL)
		ctxmith = malloc(4 * LPIPTBLSIZE, M_DEVBUF, M_NOWAIT);

	if (ctxmith == NULL) {
		mtx_unlock(&lp_tables_lock);
		return (1);
	}

	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);
	}
	mtx_unlock(&lp_tables_lock);

	return (0);
}

static void
lpstop(struct lp_data *sc)
{
	device_t ppbus = device_get_parent(sc->sc_dev);

	ppb_assert_locked(ppbus);
	ppb_wctr(ppbus, 0x00);
	if_setdrvflagbits(sc->sc_ifp, 0, (IFF_DRV_RUNNING | IFF_DRV_OACTIVE));
	free(sc->sc_ifbuf, M_DEVBUF);
	sc->sc_ifbuf = NULL;

	/* IFF_UP is not set, try to release the bus anyway */
	ppb_release_bus(ppbus, sc->sc_dev);
}

static int
lpinit_locked(if_t ifp)
{
	struct lp_data *sc = if_getsoftc(ifp);
	device_t dev = sc->sc_dev;
	device_t ppbus = device_get_parent(dev);
	int error;

	ppb_assert_locked(ppbus);
	error = ppb_request_bus(ppbus, dev, PPB_DONTWAIT);
	if (error)
		return (error);

	/* Now IFF_UP means that we own the bus */
	ppb_set_mode(ppbus, PPB_COMPATIBLE);

	if (lpinittables()) {
		ppb_release_bus(ppbus, dev);
		return (ENOBUFS);
	}

	sc->sc_ifbuf = malloc(if_getmtu(sc->sc_ifp) + MLPIPHDRLEN,
	    M_DEVBUF, M_NOWAIT);
	if (sc->sc_ifbuf == NULL) {
		ppb_release_bus(ppbus, dev);
		return (ENOBUFS);
	}

	ppb_wctr(ppbus, IRQENABLE);

	if_setdrvflagbits(ifp, IFF_DRV_RUNNING, 0);
	if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
	return (0);
}

/*
 * Process an ioctl request.
 */
static int
lpioctl(if_t ifp, u_long cmd, caddr_t data)
{
	struct lp_data *sc = if_getsoftc(ifp);
	device_t dev = sc->sc_dev;
	device_t ppbus = device_get_parent(dev);
	struct ifaddr *ifa = (struct ifaddr *)data;
	struct ifreq *ifr = (struct ifreq *)data;
	u_char *ptr;
	int error;

	switch (cmd) {
	case SIOCAIFADDR:
	case SIOCSIFADDR:
		if (ifa->ifa_addr->sa_family != AF_INET)
			return (EAFNOSUPPORT);

		if_setflagbits(ifp, IFF_UP, 0);
		/* FALLTHROUGH */
	case SIOCSIFFLAGS:
		error = 0;
		ppb_lock(ppbus);
		if ((!(if_getflags(ifp) & IFF_UP)) &&
		    (if_getdrvflags(ifp) & IFF_DRV_RUNNING))
			lpstop(sc);
		else if (((if_getflags(ifp) & IFF_UP)) &&
		    (!(if_getdrvflags(ifp) & IFF_DRV_RUNNING)))
			error = lpinit_locked(ifp);
		ppb_unlock(ppbus);
		return (error);

	case SIOCSIFMTU:
		ppb_lock(ppbus);
		if (if_getdrvflags(ifp) & IFF_DRV_RUNNING) {
			ptr = malloc(ifr->ifr_mtu + MLPIPHDRLEN, M_DEVBUF,
			    M_NOWAIT);
			if (ptr == NULL) {
				ppb_unlock(ppbus);
				return (ENOBUFS);
			}
			if (sc->sc_ifbuf)
				free(sc->sc_ifbuf, M_DEVBUF);
			sc->sc_ifbuf = ptr;
		}
		if_setmtu(ifp, ifr->ifr_mtu);
		ppb_unlock(ppbus);
		break;

	case SIOCGIFMTU:
		ifr->ifr_mtu = if_getmtu(sc->sc_ifp);
		break;

	case SIOCADDMULTI:
	case SIOCDELMULTI:
		if (ifr == NULL) {
			return (EAFNOSUPPORT);		/* XXX */
		}
		switch (ifr->ifr_addr.sa_family) {
		case AF_INET:
			break;
		default:
			return (EAFNOSUPPORT);
		}
		break;

	case SIOCGIFMEDIA:
		/*
		 * No ifmedia support at this stage; maybe use it
		 * in future for eg. protocol selection.
		 */
		return (EINVAL);

	default:
		lprintf("LP:ioctl(0x%lx)\n", cmd);
		return (EINVAL);
	}
	return (0);
}

static __inline int
clpoutbyte(u_char byte, int spin, device_t ppbus)
{

	ppb_wdtr(ppbus, ctxmitl[byte]);
	while (ppb_rstr(ppbus) & CLPIP_SHAKE)
		if (--spin == 0) {
			return (1);
		}
	ppb_wdtr(ppbus, ctxmith[byte]);
	while (!(ppb_rstr(ppbus) & CLPIP_SHAKE))
		if (--spin == 0) {
			return (1);
		}
	return (0);
}

static __inline int
clpinbyte(int spin, device_t ppbus)
{
	u_char c, cl;

	while ((ppb_rstr(ppbus) & CLPIP_SHAKE))
		if (!--spin) {
			return (-1);
		}
	cl = ppb_rstr(ppbus);
	ppb_wdtr(ppbus, 0x10);

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

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

static void
lptap(if_t ifp, struct mbuf *m)
{
	u_int32_t af = AF_INET;

	bpf_mtap2_if(ifp, &af, sizeof(af), m);
}

static void
lp_intr(void *arg)
{
	struct lp_data *sc = arg;
	device_t ppbus = device_get_parent(sc->sc_dev);
	int len, j;
	u_char *bp;
	u_char c, cl;
	struct mbuf *top;

	ppb_assert_locked(ppbus);
	if (if_getflags(sc->sc_ifp) & IFF_LINK0) {
		/* Ack. the request */
		ppb_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 > if_getmtu(sc->sc_ifp) + MLPIPHDRLEN)
			goto err;

		bp = sc->sc_ifbuf;

		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;
		}

		len = bp - sc->sc_ifbuf;
		if (len <= CLPIPHDRLEN)
			goto err;

		sc->sc_iferrs = 0;

		len -= CLPIPHDRLEN;
		if_inc_counter(sc->sc_ifp, IFCOUNTER_IPACKETS, 1);
		if_inc_counter(sc->sc_ifp, IFCOUNTER_IBYTES, len);
		top = m_devget(sc->sc_ifbuf + CLPIPHDRLEN, len, 0, sc->sc_ifp,
		    0);
		if (top) {
			ppb_unlock(ppbus);
			lptap(sc->sc_ifp, top);

			M_SETFIB(top, if_getfib(sc->sc_ifp));

			/* mbuf is free'd on failure. */
			netisr_queue(NETISR_IP, top);
			ppb_lock(ppbus);
		}
		return;
	}
	while ((ppb_rstr(ppbus) & LPIP_SHAKE)) {
		len = if_getmtu(sc->sc_ifp) + LPIPHDRLEN;
		bp  = sc->sc_ifbuf;
		while (len--) {
			cl = ppb_rstr(ppbus);
			ppb_wdtr(ppbus, 8);

			j = LPMAXSPIN2;
			while ((ppb_rstr(ppbus) & LPIP_SHAKE))
				if (!--j)
					goto err;

			c = ppb_rstr(ppbus);
			ppb_wdtr(ppbus, 0);

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

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

	end:
		len = bp - sc->sc_ifbuf;
		if (len <= LPIPHDRLEN)
			goto err;

		sc->sc_iferrs = 0;

		len -= LPIPHDRLEN;
		if_inc_counter(sc->sc_ifp, IFCOUNTER_IPACKETS, 1);
		if_inc_counter(sc->sc_ifp, IFCOUNTER_IBYTES, len);
		top = m_devget(sc->sc_ifbuf + LPIPHDRLEN, len, 0, sc->sc_ifp,
		    0);
		if (top) {
			ppb_unlock(ppbus);
			lptap(sc->sc_ifp, top);

			M_SETFIB(top, if_getfib(sc->sc_ifp));

			/* mbuf is free'd on failure. */
			netisr_queue(NETISR_IP, top);
			ppb_lock(ppbus);
		}
	}
	return;

err:
	ppb_wdtr(ppbus, 0);
	lprintf("R");
	if_inc_counter(sc->sc_ifp, IFCOUNTER_IERRORS, 1);
	sc->sc_iferrs++;

	/*
	 * We are not able to send receive anything for now,
	 * so stop wasting our time
	 */
	if (sc->sc_iferrs > LPMAXERRS) {
		if_printf(sc->sc_ifp, "Too many errors, Going off-line.\n");
		ppb_wctr(ppbus, 0x00);
		if_setdrvflagbits(sc->sc_ifp, 0, IFF_DRV_RUNNING);
		sc->sc_iferrs = 0;
	}
}

static __inline int
lpoutbyte(u_char byte, int spin, device_t ppbus)
{

	ppb_wdtr(ppbus, txmith[byte]);
	while (!(ppb_rstr(ppbus) & LPIP_SHAKE))
		if (--spin == 0)
			return (1);
	ppb_wdtr(ppbus, txmitl[byte]);
	while (ppb_rstr(ppbus) & LPIP_SHAKE)
		if (--spin == 0)
			return (1);
	return (0);
}

static int
lpoutput(if_t ifp, struct mbuf *m, const struct sockaddr *dst,
    struct route *ro)
{
	struct lp_data *sc = if_getsoftc(ifp);
	device_t dev = sc->sc_dev;
	device_t ppbus = device_get_parent(dev);
	int err;
	struct mbuf *mm;
	u_char *cp = "\0\0";
	u_char chksum = 0;
	int count = 0;
	int i, len, spin;

	/* We need a sensible value if we abort */
	cp++;
	ppb_lock(ppbus);
	if_setdrvflagbits(ifp, IFF_DRV_OACTIVE, 0);

	err = 1;		/* assume we're aborting because of an error */

	/* Suspend (on laptops) or receive-errors might have taken us offline */
	ppb_wctr(ppbus, IRQENABLE);

	if (if_getflags(ifp) & IFF_LINK0) {
		if (!(ppb_rstr(ppbus) & CLPIP_SHAKE)) {
			lprintf("&");
			lp_intr(sc);
		}

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

		/* Calculate length of packet, then send that */

		count += 14;		/* Ethernet header len */

		mm = m;
		for (mm = m; mm; mm = mm->m_next) {
			count += mm->m_len;
		}
		if (clpoutbyte(count & 0xFF, LPMAXSPIN1, ppbus))
			goto nend;
		if (clpoutbyte((count >> 8) & 0xFF, LPMAXSPIN1, ppbus))
			goto nend;

		/* Send dummy ethernet header */
		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--) {
				chksum += *cp;
				if (clpoutbyte(*cp++, LPMAXSPIN2, ppbus))
					goto nend;
			}
		} while ((mm = mm->m_next));

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

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

		err = 0;			/* No errors */

	nend:
		if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
		if (err)  {			/* if we didn't timeout... */
			if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
			lprintf("X");
		} else {
			if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
			if_inc_counter(ifp, IFCOUNTER_OBYTES, m->m_pkthdr.len);
			lptap(ifp, m);
		}

		m_freem(m);

		if (!(ppb_rstr(ppbus) & CLPIP_SHAKE)) {
			lprintf("^");
			lp_intr(sc);
		}
		ppb_unlock(ppbus);
		return (0);
	}

	if (ppb_rstr(ppbus) & LPIP_SHAKE) {
		lprintf("&");
		lp_intr(sc);
	}

	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));

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

end:
	--cp;
	ppb_wdtr(ppbus, txmitl[*cp] ^ 0x17);

	if_setdrvflagbits(ifp, 0, IFF_DRV_OACTIVE);
	if (err)  {			/* if we didn't timeout... */
		if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);
		lprintf("X");
	} else {
		if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
		if_inc_counter(ifp, IFCOUNTER_OBYTES, m->m_pkthdr.len);
		lptap(ifp, m);
	}

	m_freem(m);

	if (ppb_rstr(ppbus) & LPIP_SHAKE) {
		lprintf("^");
		lp_intr(sc);
	}

	ppb_unlock(ppbus);
	return (0);
}

static device_method_t lp_methods[] = {
  	/* device interface */
	DEVMETHOD(device_identify,	lp_identify),
	DEVMETHOD(device_probe,		lp_probe),
	DEVMETHOD(device_attach,	lp_attach),
	DEVMETHOD(device_detach,	lp_detach),
	{ 0, 0 }
};

static driver_t lp_driver = {
	"plip",
	lp_methods,
	sizeof(struct lp_data),
};

DRIVER_MODULE(plip, ppbus, lp_driver, lp_module_handler, NULL);
MODULE_DEPEND(plip, ppbus, 1, 1, 1);