Home | History | Annotate | Line # | Download | only in ppbus
if_plip.c revision 1.27
      1 /* $NetBSD: if_plip.c,v 1.26 2016/04/20 09:01:03 knakahara Exp $ */
      2 
      3 /*-
      4  * Copyright (c) 1997 Poul-Henning Kamp
      5  * Copyright (c) 2003, 2004 Gary Thorpe <gathorpe (at) users.sourceforge.net>
      6  * All rights reserved.
      7  *
      8  * Redistribution and use in source and binary forms, with or without
      9  * modification, are permitted provided that the following conditions
     10  * are met:
     11  * 1. Redistributions of source code must retain the above copyright
     12  *    notice, this list of conditions and the following disclaimer.
     13  * 2. Redistributions in binary form must reproduce the above copyright
     14  *    notice, this list of conditions and the following disclaimer in the
     15  *    documentation and/or other materials provided with the distribution.
     16  *
     17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
     18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     27  * SUCH DAMAGE.
     28  *
     29  *	From Id: lpt.c,v 1.55.2.1 1996/11/12 09:08:38 phk Exp
     30  * FreeBSD: src/sys/dev/ppbus/if_plip.c,v 1.19.2.1 2000/05/24 00:20:57 n_hibma Exp
     31  */
     32 
     33 #include <sys/cdefs.h>
     34 __KERNEL_RCSID(0, "$NetBSD: if_plip.c,v 1.26 2016/04/20 09:01:03 knakahara Exp $");
     35 
     36 /*
     37  * Parallel port TCP/IP interfaces added.  I looked at the driver from
     38  * MACH but this is a complete rewrite, and btw. incompatible, and it
     39  * should perform better too.  I have never run the MACH driver though.
     40  *
     41  * This driver sends two bytes (0x08, 0x00) in front of each packet,
     42  * to allow us to distinguish another format later.
     43  *
     44  * Now added an Linux/Crynwr compatibility mode which is enabled using
     45  * IF_LINK0 - Tim Wilkinson.
     46  *
     47  * TODO:
     48  *    Make HDLC/PPP mode, use IF_LLC1 to enable.
     49  *
     50  * Connect the two computers using a Laplink parallel cable to use this
     51  * feature:
     52  *
     53  *      +----------------------------------------+
     54  * 	|A-name	A-End	B-End	Descr.	Port/Bit |
     55  *      +----------------------------------------+
     56  *	|DATA0	2	15	Data	0/0x01   |
     57  *	|-ERROR	15	2	   	1/0x08   |
     58  *      +----------------------------------------+
     59  *	|DATA1	3	13	Data	0/0x02	 |
     60  *	|+SLCT	13	3	   	1/0x10   |
     61  *      +----------------------------------------+
     62  *	|DATA2	4	12	Data	0/0x04   |
     63  *	|+PE	12	4	   	1/0x20   |
     64  *      +----------------------------------------+
     65  *	|DATA3	5	10	Strobe	0/0x08   |
     66  *	|-ACK	10	5	   	1/0x40   |
     67  *      +----------------------------------------+
     68  *	|DATA4	6	11	Data	0/0x10   |
     69  *	|BUSY	11	6	   	1/~0x80  |
     70  *      +----------------------------------------+
     71  *	|GND	18-25	18-25	GND	-        |
     72  *      +----------------------------------------+
     73  *
     74  * Expect transfer-rates up to 75 kbyte/sec.
     75  *
     76  * If GCC could correctly grok
     77  *	register int port __asm("edx")
     78  * the code would be cleaner
     79  *
     80  * Poul-Henning Kamp <phk (at) freebsd.org>
     81  */
     82 
     83 /*
     84  * Update for ppbus, PLIP support only - Nicolas Souchu
     85  */
     86 
     87 #include "opt_inet.h"
     88 #include "opt_plip.h"
     89 
     90 #include <sys/systm.h>
     91 #include <sys/param.h>
     92 #include <sys/proc.h>
     93 #include <sys/types.h>
     94 #include <sys/device.h>
     95 #include <sys/ioctl.h>
     96 #include <sys/malloc.h>
     97 #include <sys/mbuf.h>
     98 
     99 #include <net/if.h>
    100 #include <net/if_types.h>
    101 #include <net/netisr.h>
    102 
    103 #include <sys/time.h>
    104 #include <net/bpf.h>
    105 
    106 #ifdef INET
    107 #include <netinet/in_var.h>
    108 /* #include <netinet/in.h> */
    109 #else
    110 #error Cannot config lp/plip without inet
    111 #endif
    112 
    113 #include <dev/ppbus/ppbus_base.h>
    114 #include <dev/ppbus/ppbus_device.h>
    115 #include <dev/ppbus/ppbus_io.h>
    116 #include <dev/ppbus/ppbus_var.h>
    117 
    118 #include <machine/types.h>
    119 #include <sys/intr.h>
    120 
    121 #ifndef LPMTU			/* MTU for the lp# interfaces */
    122 #define	LPMTU		1500
    123 #endif
    124 
    125 #ifndef LPMAXSPIN1		/* DELAY factor for the lp# interfaces */
    126 #define	LPMAXSPIN1	8000	/* Spinning for remote intr to happen */
    127 #endif
    128 
    129 #ifndef LPMAXSPIN2		/* DELAY factor for the lp# interfaces */
    130 #define	LPMAXSPIN2	500	/* Spinning for remote handshake to happen */
    131 #endif
    132 
    133 #ifndef LPMAXERRS		/* Max errors before !RUNNING */
    134 #define	LPMAXERRS	100
    135 #endif
    136 
    137 #ifndef LPMAXRTRY
    138 #define LPMAXRTRY	100	/* If channel busy, retry LPMAXRTRY
    139 					consecutive times */
    140 #endif
    141 
    142 #define CLPIPHDRLEN	14	/* We send dummy ethernet addresses (two) + packet type in front of packet */
    143 #define	CLPIP_SHAKE	0x80	/* This bit toggles between nibble reception */
    144 #define MLPIPHDRLEN	CLPIPHDRLEN
    145 
    146 #define LPIPHDRLEN	2	/* We send 0x08, 0x00 in front of packet */
    147 #define	LPIP_SHAKE	0x40	/* This bit toggles between nibble reception */
    148 #if !defined(MLPIPHDRLEN) || LPIPHDRLEN > MLPIPHDRLEN
    149 #define MLPIPHDRLEN	LPIPHDRLEN
    150 #endif
    151 
    152 #define	LPIPTBLSIZE	256	/* Size of octet translation table */
    153 
    154 #define LP_PRINTF	if (lpflag) printf
    155 
    156 #ifdef PLIP_DEBUG
    157 static int volatile lpflag = 1;
    158 #else
    159 static int volatile lpflag = 0;
    160 #endif
    161 
    162 /* Tx/Rsv tables for the lp interface */
    163 static u_char *txmith;
    164 #define txmitl (txmith+(1*LPIPTBLSIZE))
    165 #define trecvh (txmith+(2*LPIPTBLSIZE))
    166 #define trecvl (txmith+(3*LPIPTBLSIZE))
    167 static u_char *ctxmith;
    168 #define ctxmitl (ctxmith+(1*LPIPTBLSIZE))
    169 #define ctrecvh (ctxmith+(2*LPIPTBLSIZE))
    170 #define ctrecvl (ctxmith+(3*LPIPTBLSIZE))
    171 static uint16_t lp_count = 0;
    172 
    173 /* Autoconf functions */
    174 static int lp_probe(device_t, cfdata_t, void *);
    175 static void lp_attach(device_t, device_t, void *);
    176 static int lp_detach(device_t, int);
    177 
    178 /* Soft config data */
    179 struct lp_softc {
    180 	struct ppbus_device_softc ppbus_dev;
    181 	struct ifnet sc_if;
    182 	u_char *sc_ifbuf;
    183 	unsigned short sc_iferrs;
    184 	unsigned short sc_xmit_rtry;
    185 	u_int8_t sc_dev_ok; /* Zero means ok */
    186 };
    187 
    188 /* Autoconf structure */
    189 CFATTACH_DECL_NEW(plip, sizeof(struct lp_softc), lp_probe, lp_attach, lp_detach,
    190 	NULL);
    191 
    192 /* Functions for the lp interface */
    193 static void lpinittables(void);
    194 static void lpfreetables(void);
    195 static int lpioctl(struct ifnet *, u_long, void *);
    196 static int lpoutput(struct ifnet *, struct mbuf *, const struct sockaddr *,
    197 	const struct rtentry *);
    198 static void lpstart(struct ifnet *);
    199 static void lp_intr(void *);
    200 
    201 
    202 static int
    203 lp_probe(device_t parent, cfdata_t match, void *aux)
    204 {
    205 	struct ppbus_attach_args * args = aux;
    206 
    207 	/* Fail if ppbus is not interrupt capable */
    208 	if(args->capabilities & PPBUS_HAS_INTR)
    209 		return 1;
    210 
    211 	printf("%s(%s): not an interrupt-driven port.\n", __func__,
    212 		device_xname(parent));
    213 	return 0;
    214 }
    215 
    216 static void
    217 lp_attach(device_t parent, device_t self, void *aux)
    218 {
    219 	struct lp_softc * lp = device_private(self);
    220 	struct ifnet * ifp = &lp->sc_if;
    221 
    222 	lp->ppbus_dev.sc_dev = self;
    223 	lp->sc_dev_ok = 0;
    224 	lp->sc_ifbuf = NULL;
    225 	lp->sc_iferrs = 0;
    226 	lp->sc_xmit_rtry = 0;
    227 
    228 	ifp->if_softc = lp;
    229 	strlcpy(ifp->if_xname, device_xname(self), IFNAMSIZ);
    230 	ifp->if_mtu = LPMTU;
    231 	ifp->if_flags = IFF_SIMPLEX | IFF_POINTOPOINT | IFF_MULTICAST;
    232 	ifp->if_ioctl = lpioctl;
    233 	ifp->if_output = lpoutput;
    234 	ifp->if_start = lpstart;
    235 	ifp->if_type = IFT_PARA;
    236 	ifp->if_hdrlen = 0;
    237 	ifp->if_addrlen = 0;
    238 	ifp->if_dlt = DLT_NULL;
    239 	IFQ_SET_MAXLEN(&ifp->if_snd, IFQ_MAXLEN);
    240 	IFQ_SET_READY(&ifp->if_snd);
    241 	if_attach(ifp);
    242 	if_alloc_sadl(ifp);
    243 
    244 	bpf_attach(ifp, DLT_NULL, sizeof(u_int32_t));
    245 
    246 	if(lp_count++ == 0)
    247 		lpinittables();
    248 	printf("\n");
    249 }
    250 
    251 static int
    252 lp_detach(device_t self, int flags)
    253 {
    254 	int error = 0;
    255 	struct lp_softc * lp = device_private(self);
    256 	device_t ppbus = device_parent(self);
    257 
    258 	if(lp->sc_dev_ok) {
    259 		if(!(flags & DETACH_QUIET))
    260 			LP_PRINTF("%s(%s): device not properly attached! "
    261 				"Skipping detach....\n", __func__,
    262 				device_xname(self));
    263 		return error;
    264 	}
    265 
    266 	/* If interface is up, bring it down and release ppbus */
    267 	if(lp->sc_if.if_flags & IFF_RUNNING) {
    268 		ppbus_wctr(ppbus, 0x00);
    269 		if_detach(&lp->sc_if);
    270 		error = ppbus_remove_handler(ppbus, lp_intr);
    271 		if(error) {
    272 			if(!(flags & DETACH_QUIET))
    273 				LP_PRINTF("%s(%s): unable to remove interrupt "
    274 					"callback.\n", __func__,
    275 					device_xname(self));
    276 			if(!(flags & DETACH_FORCE))
    277 				return error;
    278 		}
    279 		error = ppbus_release_bus(ppbus, self, 0, 0);
    280 		if(error) {
    281 			if(!(flags & DETACH_QUIET))
    282 				LP_PRINTF("%s(%s): error releasing bus %s.\n",
    283 					__func__, device_xname(self),
    284 					device_xname(ppbus));
    285 			if(!(flags & DETACH_FORCE))
    286 				return error;
    287 		}
    288 	}
    289 
    290 	if(lp->sc_ifbuf)
    291 		free(lp->sc_ifbuf, M_DEVBUF);
    292 
    293 	if(--lp_count == 0)
    294 		lpfreetables();
    295 	return error;
    296 }
    297 
    298 /*
    299  * Build the translation tables for the LPIP (BSD unix) protocol.
    300  * We don't want to calculate these nasties in our tight loop, so we
    301  * precalculate them when we initialize.
    302  */
    303 static void
    304 lpinittables (void)
    305 {
    306 	int i;
    307 
    308 	if (!txmith)
    309 		txmith = malloc(4*LPIPTBLSIZE, M_DEVBUF, M_WAITOK);
    310 
    311 	if (!ctxmith)
    312 		ctxmith = malloc(4*LPIPTBLSIZE, M_DEVBUF, M_WAITOK);
    313 
    314 	for(i = 0; i < LPIPTBLSIZE; i++) {
    315 		ctxmith[i] = (i & 0xF0) >> 4;
    316 		ctxmitl[i] = 0x10 | (i & 0x0F);
    317 		ctrecvh[i] = (i & 0x78) << 1;
    318 		ctrecvl[i] = (i & 0x78) >> 3;
    319 	}
    320 
    321 	for(i = 0; i < LPIPTBLSIZE; i++) {
    322 		txmith[i] = ((i & 0x80) >> 3) | ((i & 0x70) >> 4) | 0x08;
    323 		txmitl[i] = ((i & 0x08) << 1) | (i & 0x07);
    324 		trecvh[i] = ((~i) & 0x80) | ((i & 0x38) << 1);
    325 		trecvl[i] = (((~i) & 0x80) >> 4) | ((i & 0x38) >> 3);
    326 	}
    327 }
    328 
    329 /* Free translation tables */
    330 static void
    331 lpfreetables (void)
    332 {
    333 	if (txmith)
    334 		free(txmith, M_DEVBUF);
    335 	if (ctxmith)
    336 		free(ctxmith, M_DEVBUF);
    337 	txmith = ctxmith = NULL;
    338 }
    339 
    340 
    341 /* Process an ioctl request. */
    342 static int
    343 lpioctl(struct ifnet *ifp, u_long cmd, void *data)
    344 {
    345 	struct lp_softc * sc = ifp->if_softc;
    346 	device_t dev = sc->ppbus_dev.sc_dev;
    347 	device_t ppbus = device_parent(dev);
    348 	struct ifaddr * ifa = (struct ifaddr *)data;
    349 	struct ifreq * ifr = (struct ifreq *)data;
    350 	u_char * ptr;
    351 	int error, s;
    352 
    353 	error = 0;
    354 	s = splnet();
    355 
    356 	if(sc->sc_dev_ok) {
    357 		LP_PRINTF("%s(%s): device not properly attached!", __func__,
    358 			device_xname(dev));
    359 		error = ENODEV;
    360 		goto end;
    361 	}
    362 
    363 	switch (cmd) {
    364 
    365 	case SIOCSIFDSTADDR:
    366 		if (ifa->ifa_addr->sa_family != AF_INET)
    367 			error = EAFNOSUPPORT;
    368 		break;
    369 
    370 	case SIOCINITIFADDR:
    371 		if (ifa->ifa_addr->sa_family != AF_INET) {
    372 			error = EAFNOSUPPORT;
    373 			break;
    374 		}
    375 		ifp->if_flags |= IFF_UP;
    376 	/* FALLTHROUGH */
    377 	case SIOCSIFFLAGS:
    378 		if ((error = ifioctl_common(ifp, cmd, data)) != 0)
    379 			break;
    380 		if((ifp->if_flags & (IFF_UP|IFF_RUNNING)) == IFF_UP) {
    381 			if((error = ppbus_request_bus(ppbus, dev, 0, 0)))
    382 				break;
    383 			error = ppbus_set_mode(ppbus, PPBUS_COMPATIBLE, 0);
    384 			if(error)
    385 				break;
    386 
    387 			error = ppbus_add_handler(ppbus, lp_intr, dev);
    388 			if(error) {
    389 				LP_PRINTF("%s(%s): unable to register interrupt"
    390 					" callback.\n", __func__,
    391 					device_xname(dev));
    392 				ppbus_release_bus(ppbus, dev, 0, 0);
    393 				break;
    394 			}
    395 
    396 			/* Allocate a buffer if necessary */
    397 			if(sc->sc_ifbuf == NULL) {
    398 				sc->sc_ifbuf = malloc(sc->sc_if.if_mtu +
    399 					MLPIPHDRLEN, M_DEVBUF, M_NOWAIT);
    400 				if (!sc->sc_ifbuf) {
    401 					error = ENOBUFS;
    402 					ppbus_release_bus(ppbus, dev, 0, 0);
    403 					break;
    404 				}
    405 			}
    406 
    407 			ppbus_wctr(ppbus, IRQENABLE);
    408 			ifp->if_flags |= IFF_RUNNING;
    409 		}
    410 		if((ifp->if_flags & (IFF_UP|IFF_RUNNING)) == IFF_RUNNING) {
    411 			ppbus_remove_handler(ppbus, lp_intr);
    412 			error = ppbus_release_bus(ppbus, dev, 0, 0);
    413 			ifp->if_flags &= ~IFF_RUNNING;
    414 		}
    415 		/* Go quiescent */
    416 		ppbus_wdtr(ppbus, 0);
    417 		break;
    418 
    419 	case SIOCSIFMTU:
    420 		if(sc->sc_if.if_mtu == ifr->ifr_mtu)
    421 			break;
    422 		ptr = sc->sc_ifbuf;
    423 		sc->sc_ifbuf = malloc(ifr->ifr_mtu+MLPIPHDRLEN, M_DEVBUF,
    424 			M_NOWAIT);
    425 		if (!sc->sc_ifbuf) {
    426 			sc->sc_ifbuf = ptr;
    427 			error = ENOBUFS;
    428 			break;
    429 		}
    430 		if(ptr)
    431 			free(ptr,M_DEVBUF);
    432 		/*FALLTHROUGH*/
    433 	case SIOCGIFMTU:
    434 		if ((error = ifioctl_common(ifp, cmd, data)) == ENETRESET)
    435 			error = 0;
    436 		break;
    437 
    438 	case SIOCADDMULTI:
    439 	case SIOCDELMULTI:
    440 		if (ifr == NULL) {
    441 			error = EAFNOSUPPORT;		/* XXX */
    442 			break;
    443 		}
    444 		switch (ifreq_getaddr(cmd, ifr)->sa_family) {
    445 		case AF_INET:
    446 			break;
    447 		default:
    448 			return EAFNOSUPPORT;
    449 		}
    450 		break;
    451 
    452 	case SIOCGIFMEDIA:
    453 		/*
    454 		 * No ifmedia support at this stage; maybe use it
    455 		 * in future for eg. protocol selection.
    456 		 */
    457 	default:
    458 		LP_PRINTF("LP:ioctl(0x%lx)\n", cmd);
    459 		error = ifioctl_common(ifp, cmd, data);
    460 	}
    461 
    462 end:
    463 	splx(s);
    464 	return error;
    465 }
    466 
    467 static inline int
    468 clpoutbyte (u_char byte, int spin, device_t ppbus)
    469 {
    470 	int s = spin;
    471 	ppbus_wdtr(ppbus, ctxmitl[byte]);
    472 	while (ppbus_rstr(ppbus) & CLPIP_SHAKE) {
    473 		if (--s == 0) {
    474 			return 1;
    475 		}
    476 	}
    477 	s = spin;
    478 	ppbus_wdtr(ppbus, ctxmith[byte]);
    479 	while (!(ppbus_rstr(ppbus) & CLPIP_SHAKE)) {
    480 		if (--s == 0) {
    481 			return 1;
    482 		}
    483 	}
    484 	return 0;
    485 }
    486 
    487 static inline int
    488 clpinbyte (int spin, device_t ppbus)
    489 {
    490 	u_char c, cl;
    491 	int s = spin;
    492 
    493 	while(ppbus_rstr(ppbus) & CLPIP_SHAKE) {
    494 		if(!--s) {
    495 			return -1;
    496 		}
    497 	}
    498 	cl = ppbus_rstr(ppbus);
    499 	ppbus_wdtr(ppbus, 0x10);
    500 
    501 	s = spin;
    502 	while(!(ppbus_rstr(ppbus) & CLPIP_SHAKE)) {
    503 		if(!--s) {
    504 			return -1;
    505 		}
    506 	}
    507 	c = ppbus_rstr(ppbus);
    508 	ppbus_wdtr(ppbus, 0x00);
    509 
    510 	return (ctrecvl[cl] | ctrecvh[c]);
    511 }
    512 
    513 static void
    514 lptap(struct ifnet *ifp, struct mbuf *m)
    515 {
    516 	/*
    517 	 * Send a packet through bpf. We need to prepend the address family
    518 	 * as a four byte field. Cons up a dummy header to pacify bpf. This
    519 	 * is safe because bpf will only read from the mbuf (i.e., it won't
    520 	 * try to free it or keep a pointer to it).
    521 	 */
    522 	u_int32_t af = AF_INET;
    523 	struct mbuf m0;
    524 
    525 	m0.m_next = m;
    526 	m0.m_len = sizeof(u_int32_t);
    527 	m0.m_data = (char *)&af;
    528 	bpf_mtap(ifp, &m0);
    529 }
    530 
    531 /* Soft interrupt handler called by hardware interrupt handler */
    532 static void
    533 lp_intr (void *arg)
    534 {
    535 	device_t dev = (device_t)arg;
    536         device_t ppbus = device_parent(dev);
    537 	struct lp_softc * sc = device_private(dev);
    538 	struct ifnet * ifp = &sc->sc_if;
    539 	struct mbuf *top;
    540 	int len, s, j;
    541 	u_char *bp;
    542 	u_char c, cl;
    543 
    544 	s = splnet();
    545 
    546 	/* Do nothing if device not properly attached */
    547 	if(sc->sc_dev_ok) {
    548 		LP_PRINTF("%s(%s): device not properly attached!", __func__,
    549 			device_xname(dev));
    550 		goto done;
    551 	}
    552 
    553 	/* Do nothing if interface is not up */
    554 	if((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
    555 		goto done;
    556 
    557 	/* If other side is no longer transmitting, do nothing */
    558 	if(!(ppbus_rstr(ppbus) & LPIP_SHAKE))
    559 		goto done;
    560 
    561 	/* Disable interrupts until we finish */
    562 	ppbus_wctr(ppbus, ~IRQENABLE);
    563 
    564 	top = NULL;
    565 	bp = sc->sc_ifbuf;
    566 	/* Linux/crynwyr protocol receiving */
    567 	if(ifp->if_flags & IFF_LINK0) {
    568 		/* Ack. the request */
    569 		ppbus_wdtr(ppbus, 0x01);
    570 
    571 		/* Get the packet length */
    572 		j = clpinbyte(LPMAXSPIN2, ppbus);
    573 		if(j == -1)
    574 			goto err;
    575 		len = j;
    576 		j = clpinbyte(LPMAXSPIN2, ppbus);
    577 		if(j == -1)
    578 			goto err;
    579 		len = len + (j << 8);
    580 		if(len > ifp->if_mtu + MLPIPHDRLEN)
    581 			goto err;
    582 
    583 		while(len--) {
    584 			j = clpinbyte(LPMAXSPIN2, ppbus);
    585 			if (j == -1) {
    586 				goto err;
    587 			}
    588 			*bp++ = j;
    589 		}
    590 		/* Get and ignore checksum */
    591 		j = clpinbyte(LPMAXSPIN2, ppbus);
    592 		if(j == -1) {
    593 			goto err;
    594 		}
    595 
    596 		/* Return to idle state */
    597 		ppbus_wdtr(ppbus, 0);
    598 		len = bp - sc->sc_ifbuf;
    599 		if (len <= CLPIPHDRLEN)
    600 			goto err;
    601 		len -= CLPIPHDRLEN;
    602 		top = m_devget(sc->sc_ifbuf + CLPIPHDRLEN, len, 0, ifp, NULL);
    603 	}
    604 	/* FreeBSD protocol receiving */
    605 	else {
    606 		len = ifp->if_mtu + LPIPHDRLEN;
    607 		while(len--) {
    608 			cl = ppbus_rstr(ppbus);
    609 			ppbus_wdtr(ppbus, 0x08);
    610 
    611 			j = LPMAXSPIN2;
    612 			while((ppbus_rstr(ppbus) & LPIP_SHAKE)) {
    613 				if(!--j) goto err;
    614 			}
    615 
    616 			c = ppbus_rstr(ppbus);
    617 			ppbus_wdtr(ppbus, 0);
    618 
    619 			*bp++= trecvh[cl] | trecvl[c];
    620 
    621 			j = LPMAXSPIN2;
    622 			while(!((cl=ppbus_rstr(ppbus)) & LPIP_SHAKE)) {
    623 				if(cl != c &&
    624 					(((cl = ppbus_rstr(ppbus)) ^ 0xb8) &
    625 					0xf8) == (c & 0xf8))
    626 					goto end;
    627 				if(!--j) goto err;
    628 			}
    629 		}
    630 
    631 end:
    632 		len = bp - sc->sc_ifbuf;
    633 		if(len <= LPIPHDRLEN)
    634 			goto err;
    635 		len -= LPIPHDRLEN;
    636 		top = m_devget(sc->sc_ifbuf + LPIPHDRLEN, len, 0, ifp, NULL);
    637 	}
    638 
    639 	if (top == NULL) {
    640 		ifp->if_iqdrops++;
    641 		goto err;
    642 	}
    643 	if (ifp->if_bpf) {
    644 		lptap(ifp, top);
    645 	}
    646 	if (__predict_false(!pktq_enqueue(ip_pktq, top, 0))) {
    647 		ifp->if_iqdrops++;
    648 		m_freem(top);
    649 		goto err;
    650 	}
    651 	ifp->if_ipackets++;
    652 	ifp->if_ibytes += len;
    653 	sc->sc_iferrs = 0;
    654 
    655 	goto done;
    656 
    657 err:
    658 	/* Return to idle state */
    659 	ppbus_wdtr(ppbus, 0);
    660 	ifp->if_ierrors++;
    661 	sc->sc_iferrs++;
    662 	LP_PRINTF("R");
    663 	/* Disable interface if there are too many errors */
    664 	if(sc->sc_iferrs > LPMAXERRS) {
    665 		aprint_error_dev(dev, "Too many consecutive errors, going off-line.\n");
    666 		ppbus_wctr(ppbus, ~IRQENABLE);
    667 		if_down(ifp);
    668 		sc->sc_iferrs = 0;
    669 	}
    670 
    671 done:
    672 	/* Re-enable interrupts */
    673 	ppbus_wctr(ppbus, IRQENABLE);
    674 	/* If interface is not active, send some packets */
    675 	if((ifp->if_flags & IFF_OACTIVE) == 0)
    676 		lpstart(ifp);
    677 	splx(s);
    678 	return;
    679 }
    680 
    681 static inline int
    682 lpoutbyte(u_char byte, int spin, device_t ppbus)
    683 {
    684 	int s = spin;
    685 	ppbus_wdtr(ppbus, txmith[byte]);
    686 	while(!(ppbus_rstr(ppbus) & LPIP_SHAKE)) {
    687 		if(--s == 0)
    688 			return 1;
    689 	}
    690 	s = spin;
    691 	ppbus_wdtr(ppbus, txmitl[byte]);
    692 	while(ppbus_rstr(ppbus) & LPIP_SHAKE) {
    693 		if(--s == 0)
    694 			return 1;
    695 	}
    696 	return 0;
    697 }
    698 
    699 /* Queue a packet for delivery */
    700 static int
    701 lpoutput(struct ifnet *ifp, struct mbuf *m, const struct sockaddr *dst,
    702 	const struct rtentry *rt)
    703 {
    704 	struct lp_softc * sc = ifp->if_softc;
    705 	device_t dev = sc->ppbus_dev.sc_dev;
    706 	device_t ppbus = device_parent(dev);
    707 	int err;
    708 	int s;
    709 
    710 	s = splnet();
    711 
    712 	if(sc->sc_dev_ok) {
    713 		LP_PRINTF("%s(%s): device not properly attached!", __func__,
    714 			device_xname(dev));
    715 		err = ENODEV;
    716 		goto endoutput;
    717 	}
    718 
    719 	if((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
    720 		err = ENETDOWN;
    721 		goto endoutput;
    722 	}
    723 
    724 	/* Only support INET */
    725 	if(dst->sa_family != AF_INET) {
    726 		LP_PRINTF("%s: af%d not supported\n", ifp->if_xname,
    727 		    dst->sa_family);
    728 		ifp->if_noproto++;
    729 		err = EAFNOSUPPORT;
    730 		goto endoutput;
    731 	}
    732 
    733 	IFQ_CLASSIFY(&ifp->if_snd, m, dst->sa_family);
    734 	IFQ_ENQUEUE(&ifp->if_snd, m, err);
    735 	if(err == 0) {
    736 		if((ifp->if_flags & IFF_OACTIVE) == 0)
    737 			lpstart(ifp);
    738 	}
    739 	else {
    740 		ifp->if_oerrors++;
    741 		sc->sc_iferrs++;
    742 		LP_PRINTF("Q");
    743 
    744 		/* Disable interface if there are too many errors */
    745 		if(sc->sc_iferrs > LPMAXERRS) {
    746 			aprint_error_dev(dev, "Too many errors, going off-line.\n");
    747 			ppbus_wctr(ppbus, ~IRQENABLE);
    748 			if_down(ifp);
    749 			sc->sc_iferrs = 0;
    750 		}
    751 	}
    752 
    753 endoutput:
    754 	if((err != 0) && (err != ENOBUFS))
    755 		m_freem(m);
    756 	splx(s);
    757 	return err;
    758 }
    759 
    760 /* Send routine: send packets over PLIP cable. Call at splnet(). */
    761 void
    762 lpstart(struct ifnet * ifp)
    763 {
    764 	struct lp_softc * lp = ifp->if_softc;
    765 	device_t dev = lp->ppbus_dev.sc_dev;
    766 	device_t ppbus = device_parent(dev);
    767 	struct mbuf * mm;
    768 	struct mbuf * m;
    769 	u_char * cp;
    770 	int err, i, len, spin, count;
    771 	u_char str, chksum;
    772 
    773 	if(lp->sc_dev_ok) {
    774 		LP_PRINTF("%s(%s): device not properly attached!", __func__,
    775 			device_xname(dev));
    776 		return;
    777 	}
    778 
    779 	if((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) {
    780 		return;
    781 	}
    782 
    783 	ifp->if_flags |= IFF_OACTIVE;
    784 
    785 	/* Go quiescent */
    786 	ppbus_wdtr(ppbus, 0);
    787 
    788 	/* Output loop */
    789 	for(;;) {
    790 		/* Check if there are packets to send */
    791 		if(IFQ_IS_EMPTY(&ifp->if_snd)) {
    792 			goto final;
    793 		}
    794 		/* Try to send a packet, dequeue it later if successful */
    795 		IFQ_POLL(&ifp->if_snd, m);
    796 		if(m == NULL)
    797 			goto final;
    798 
    799 		str = ppbus_rstr(ppbus);
    800 		/* Wait until other side is not transmitting */
    801 		if((str & LPIP_SHAKE) ||
    802 			((ifp->if_flags & IFF_LINK0) && !(str & CLPIP_SHAKE))) {
    803 			LP_PRINTF("&");
    804 			if(++lp->sc_xmit_rtry > LPMAXRTRY) {
    805 				aprint_error_dev(dev, "Too many retries while channel "
    806 					"busy, going off-line.\n");
    807 				ppbus_wctr(ppbus, ~IRQENABLE);
    808 				if_down(ifp);
    809 				lp->sc_xmit_rtry = 0;
    810 			}
    811 			goto final;
    812 		}
    813 		lp->sc_xmit_rtry = 0;
    814 
    815 		/* Disable interrupt generation */
    816 		ppbus_wctr(ppbus, ~IRQENABLE);
    817 
    818 		err = 1;
    819 
    820 		/* Output packet for Linux/crynwyr compatible protocol */
    821 		if(ifp->if_flags & IFF_LINK0) {
    822 			/* Calculate packet length */
    823 			count = 14;		/* Ethernet header len */
    824 			for(mm = m; mm; mm = mm->m_next) {
    825 				count += mm->m_len;
    826 			}
    827 
    828 			/* Alert other end to pending packet */
    829 			spin = LPMAXSPIN1;
    830 			ppbus_wdtr(ppbus, 0x08);
    831 			while((ppbus_rstr(ppbus) & 0x08) == 0) {
    832 				if (--spin == 0) {
    833 					goto nend;
    834 				}
    835 			}
    836 
    837 			if(clpoutbyte(count & 0xFF, LPMAXSPIN1, ppbus))
    838 				goto nend;
    839 			if(clpoutbyte((count >> 8) & 0xFF, LPMAXSPIN1, ppbus))
    840 				goto nend;
    841 
    842 			/* Send dummy ethernet header */
    843 			chksum = 0;
    844 			for(i = 0; i < 12; i++) {
    845 				if(clpoutbyte(i, LPMAXSPIN1, ppbus))
    846 					goto nend;
    847 				chksum += i;
    848 			}
    849 
    850 			if(clpoutbyte(0x08, LPMAXSPIN1, ppbus))
    851 				goto nend;
    852 			if(clpoutbyte(0x00, LPMAXSPIN1, ppbus))
    853 				goto nend;
    854 			chksum += 0x08 + 0x00;		/* Add into checksum */
    855 
    856 			mm = m;
    857 			do {
    858 				cp = mtod(mm, u_char *);
    859 				len = mm->m_len;
    860 				while(len--) {
    861 					if(clpoutbyte(*cp, LPMAXSPIN2, ppbus))
    862 						goto nend;
    863 					chksum += *cp++;
    864 				}
    865 			} while ((mm = mm->m_next));
    866 
    867 			/* Send checksum */
    868 			if(clpoutbyte(chksum, LPMAXSPIN2, ppbus))
    869 				goto nend;
    870 
    871 			/* No errors */
    872 			err = 0;
    873 			/* Go quiescent */
    874 			ppbus_wdtr(ppbus, 0);
    875 		}
    876 		/* Output packet for FreeBSD compatible protocol */
    877 		else {
    878 			/* We need a sensible value if we abort */
    879 			cp = NULL;
    880 
    881 			if(lpoutbyte(0x08, LPMAXSPIN1, ppbus))
    882 				goto end;
    883 			if(lpoutbyte(0x00, LPMAXSPIN2, ppbus))
    884 				goto end;
    885 
    886 			mm = m;
    887 			do {
    888 				cp = mtod(mm,u_char *);
    889 				len = mm->m_len;
    890 				while(len--)
    891 					if(lpoutbyte(*cp++, LPMAXSPIN2, ppbus))
    892 						goto end;
    893 			} while ((mm = mm->m_next));
    894 
    895 			/* no errors were encountered */
    896 			err = 0;
    897 
    898 end:
    899 			if(cp)
    900 				ppbus_wdtr(ppbus, txmitl[*(--cp)] ^ 0x17);
    901 			else
    902 				ppbus_wdtr(ppbus, txmitl['\0'] ^ 0x17);
    903 		}
    904 
    905 nend:
    906 		/* Re-enable interrupt generation */
    907 		ppbus_wctr(ppbus, IRQENABLE);
    908 
    909 		if(err) {
    910 			/* Go quiescent */
    911 			ppbus_wdtr(ppbus, 0);
    912 
    913 			ifp->if_oerrors++;
    914 			lp->sc_iferrs++;
    915 			LP_PRINTF("X");
    916 
    917 			/* Disable interface if there are too many errors */
    918 			if(lp->sc_iferrs > LPMAXERRS) {
    919 				aprint_error_dev(dev, "Too many errors, going off-line.\n");
    920 				ppbus_wctr(ppbus, ~IRQENABLE);
    921 				if_down(ifp);
    922 				lp->sc_iferrs = 0;
    923 				goto final;
    924 			}
    925 		}
    926 		else {
    927 			/* Dequeue packet on success */
    928 			IFQ_DEQUEUE(&ifp->if_snd, m);
    929 			if(ifp->if_bpf)
    930 				lptap(ifp, m);
    931 			ifp->if_opackets++;
    932 			ifp->if_obytes += m->m_pkthdr.len;
    933 			m_freem(m);
    934 		}
    935 	}
    936 
    937 final:
    938 	ifp->if_flags &= ~IFF_OACTIVE;
    939 	return;
    940 }
    941