if_plip.c revision 43433 
1/*-
2 * Copyright (c) 1997 Poul-Henning Kamp
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24 * SUCH DAMAGE.
25 *
26 *	From Id: lpt.c,v 1.55.2.1 1996/11/12 09:08:38 phk Exp
27 *	$Id: if_plip.c,v 1.8 1999/01/23 17:07:49 nsouch Exp $
28 */
29
30/*
31 * Parallel port TCP/IP interfaces added.  I looked at the driver from
32 * MACH but this is a complete rewrite, and btw. incompatible, and it
33 * should perform better too.  I have never run the MACH driver though.
34 *
35 * This driver sends two bytes (0x08, 0x00) in front of each packet,
36 * to allow us to distinguish another format later.
37 *
38 * Now added an Linux/Crynwr compatibility mode which is enabled using
39 * IF_LINK0 - Tim Wilkinson.
40 *
41 * TODO:
42 *    Make HDLC/PPP mode, use IF_LLC1 to enable.
43 *
44 * Connect the two computers using a Laplink parallel cable to use this
45 * feature:
46 *
47 *      +----------------------------------------+
48 * 	|A-name	A-End	B-End	Descr.	Port/Bit |
49 *      +----------------------------------------+
50 *	|DATA0	2	15	Data	0/0x01   |
51 *	|-ERROR	15	2	   	1/0x08   |
52 *      +----------------------------------------+
53 *	|DATA1	3	13	Data	0/0x02	 |
54 *	|+SLCT	13	3	   	1/0x10   |
55 *      +----------------------------------------+
56 *	|DATA2	4	12	Data	0/0x04   |
57 *	|+PE	12	4	   	1/0x20   |
58 *      +----------------------------------------+
59 *	|DATA3	5	10	Strobe	0/0x08   |
60 *	|-ACK	10	5	   	1/0x40   |
61 *      +----------------------------------------+
62 *	|DATA4	6	11	Data	0/0x10   |
63 *	|BUSY	11	6	   	1/~0x80  |
64 *      +----------------------------------------+
65 *	|GND	18-25	18-25	GND	-        |
66 *      +----------------------------------------+
67 *
68 * Expect transfer-rates up to 75 kbyte/sec.
69 *
70 * If GCC could correctly grok
71 *	register int port asm("edx")
72 * the code would be cleaner
73 *
74 * Poul-Henning Kamp <phk@freebsd.org>
75 */
76
77/*
78 * Update for ppbus, PLIP support only - Nicolas Souchu
79 */
80
81#include <sys/param.h>
82#include <sys/systm.h>
83#include <sys/mbuf.h>
84#include <sys/socket.h>
85#include <sys/sockio.h>
86#include <sys/kernel.h>
87#include <sys/malloc.h>
88
89#include <net/if.h>
90#include <net/if_types.h>
91#include <net/netisr.h>
92
93#include <netinet/in.h>
94#include <netinet/in_var.h>
95
96#include "bpfilter.h"
97#if NBPFILTER > 0
98#include <net/bpf.h>
99#endif
100
101#include <dev/ppbus/ppbconf.h>
102#include <dev/ppbus/nlpt.h>
103
104#include "opt_plip.h"
105
106#ifndef LPMTU			/* MTU for the lp# interfaces */
107#define	LPMTU	1500
108#endif
109
110#ifndef LPMAXSPIN1		/* DELAY factor for the lp# interfaces */
111#define	LPMAXSPIN1	8000   /* Spinning for remote intr to happen */
112#endif
113
114#ifndef LPMAXSPIN2		/* DELAY factor for the lp# interfaces */
115#define	LPMAXSPIN2	500	/* Spinning for remote handshake to happen */
116#endif
117
118#ifndef LPMAXERRS		/* Max errors before !RUNNING */
119#define	LPMAXERRS	100
120#endif
121
122#define CLPIPHDRLEN	14	/* We send dummy ethernet addresses (two) + packet type in front of packet */
123#define	CLPIP_SHAKE	0x80	/* This bit toggles between nibble reception */
124#define MLPIPHDRLEN	CLPIPHDRLEN
125
126#define LPIPHDRLEN	2	/* We send 0x08, 0x00 in front of packet */
127#define	LPIP_SHAKE	0x40	/* This bit toggles between nibble reception */
128#if !defined(MLPIPHDRLEN) || LPIPHDRLEN > MLPIPHDRLEN
129#define MLPIPHDRLEN	LPIPHDRLEN
130#endif
131
132#define	LPIPTBLSIZE	256	/* Size of octet translation table */
133
134#define lprintf		if (lptflag) printf
135
136#ifdef PLIP_DEBUG
137static int volatile lptflag = 1;
138#else
139static int volatile lptflag = 0;
140#endif
141
142struct lpt_softc {
143	unsigned short lp_unit;
144
145	struct ppb_device lp_dev;
146
147	struct  ifnet	sc_if;
148	u_char		*sc_ifbuf;
149	int		sc_iferrs;
150};
151
152static int	nlp = 0;
153#define MAXPLIP	8			/* XXX not much better! */
154static struct lpt_softc *lpdata[MAXPLIP];
155
156
157/* Tables for the lp# interface */
158static u_char *txmith;
159#define txmitl (txmith+(1*LPIPTBLSIZE))
160#define trecvh (txmith+(2*LPIPTBLSIZE))
161#define trecvl (txmith+(3*LPIPTBLSIZE))
162
163static u_char *ctxmith;
164#define ctxmitl (ctxmith+(1*LPIPTBLSIZE))
165#define ctrecvh (ctxmith+(2*LPIPTBLSIZE))
166#define ctrecvl (ctxmith+(3*LPIPTBLSIZE))
167
168/* Functions for the lp# interface */
169static struct ppb_device	*lpprobe(struct ppb_data *);
170static int			lpattach(struct ppb_device *);
171
172static int lpinittables(void);
173static int lpioctl(struct ifnet *, u_long, caddr_t);
174static int lpoutput(struct ifnet *, struct mbuf *, struct sockaddr *,
175	struct rtentry *);
176static void lpintr(int);
177
178/*
179 * Make ourselves visible as a ppbus driver
180 */
181
182static struct ppb_driver lpdriver = {
183    lpprobe, lpattach, "lp"
184};
185DATA_SET(ppbdriver_set, lpdriver);
186
187
188/*
189 * lpprobe()
190 */
191static struct ppb_device *
192lpprobe(struct ppb_data *ppb)
193{
194	struct lpt_softc *lp;
195
196	/* if we haven't interrupts, the probe fails */
197	if (!ppb->ppb_link->id_irq)
198		return (0);
199
200	lp = (struct lpt_softc *) malloc(sizeof(struct lpt_softc),
201							M_TEMP, M_NOWAIT);
202	if (!lp) {
203		printf("lp: cannot malloc!\n");
204		return (0);
205	}
206	bzero(lp, sizeof(struct lpt_softc));
207
208	lpdata[nlp] = lp;
209
210	/*
211	 * lp dependent initialisation.
212	 */
213	lp->lp_unit = nlp;
214
215	if (bootverbose)
216		printf("plip: irq %d\n", ppb->ppb_link->id_irq);
217
218	/*
219	 * ppbus dependent initialisation.
220	 */
221	lp->lp_dev.id_unit = lp->lp_unit;
222	lp->lp_dev.name = lpdriver.name;
223	lp->lp_dev.ppb = ppb;
224	lp->lp_dev.intr = lpintr;
225
226	/* Ok, go to next device on next probe */
227	nlp ++;
228
229	return (&lp->lp_dev);
230}
231
232static int
233lpattach (struct ppb_device *dev)
234{
235	int unit = dev->id_unit;
236	struct lpt_softc *sc = lpdata[unit];
237	struct ifnet *ifp = &sc->sc_if;
238
239	/*
240	 * Report ourselves
241	 */
242	printf("plip%d: <PLIP network interface> on ppbus %d\n",
243	       dev->id_unit, dev->ppb->ppb_link->adapter_unit);
244
245	ifp->if_softc = sc;
246	ifp->if_name = "lp";
247	ifp->if_unit = unit;
248	ifp->if_mtu = LPMTU;
249	ifp->if_flags = IFF_SIMPLEX | IFF_POINTOPOINT | IFF_MULTICAST;
250	ifp->if_ioctl = lpioctl;
251	ifp->if_output = lpoutput;
252	ifp->if_type = IFT_PARA;
253	ifp->if_hdrlen = 0;
254	ifp->if_addrlen = 0;
255	ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
256	if_attach(ifp);
257
258#if NBPFILTER > 0
259	bpfattach(ifp, DLT_NULL, LPIPHDRLEN);
260#endif
261
262	return (1);
263}
264/*
265 * Build the translation tables for the LPIP (BSD unix) protocol.
266 * We don't want to calculate these nasties in our tight loop, so we
267 * precalculate them when we initialize.
268 */
269static int
270lpinittables (void)
271{
272    int i;
273
274    if (!txmith)
275	txmith = malloc(4*LPIPTBLSIZE, M_DEVBUF, M_NOWAIT);
276
277    if (!txmith)
278	return 1;
279
280    if (!ctxmith)
281	ctxmith = malloc(4*LPIPTBLSIZE, M_DEVBUF, M_NOWAIT);
282
283    if (!ctxmith)
284	return 1;
285
286    for (i=0; i < LPIPTBLSIZE; i++) {
287	ctxmith[i] = (i & 0xF0) >> 4;
288	ctxmitl[i] = 0x10 | (i & 0x0F);
289	ctrecvh[i] = (i & 0x78) << 1;
290	ctrecvl[i] = (i & 0x78) >> 3;
291    }
292
293    for (i=0; i < LPIPTBLSIZE; i++) {
294	txmith[i] = ((i & 0x80) >> 3) | ((i & 0x70) >> 4) | 0x08;
295	txmitl[i] = ((i & 0x08) << 1) | (i & 0x07);
296	trecvh[i] = ((~i) & 0x80) | ((i & 0x38) << 1);
297	trecvl[i] = (((~i) & 0x80) >> 4) | ((i & 0x38) >> 3);
298    }
299
300    return 0;
301}
302
303/*
304 * Process an ioctl request.
305 */
306
307static int
308lpioctl (struct ifnet *ifp, u_long cmd, caddr_t data)
309{
310    struct lpt_softc *sc = lpdata[ifp->if_unit];
311    struct ifaddr *ifa = (struct ifaddr *)data;
312    struct ifreq *ifr = (struct ifreq *)data;
313    u_char *ptr;
314    int error;
315
316    switch (cmd) {
317
318    case SIOCSIFDSTADDR:
319    case SIOCAIFADDR:
320    case SIOCSIFADDR:
321	if (ifa->ifa_addr->sa_family != AF_INET)
322	    return EAFNOSUPPORT;
323
324	ifp->if_flags |= IFF_UP;
325	/* FALLTHROUGH */
326    case SIOCSIFFLAGS:
327	if ((!(ifp->if_flags & IFF_UP)) && (ifp->if_flags & IFF_RUNNING)) {
328
329	    ppb_wctr(&sc->lp_dev, 0x00);
330	    ifp->if_flags &= ~IFF_RUNNING;
331
332	    /* IFF_UP is not set, try to release the bus anyway */
333	    ppb_release_bus(&sc->lp_dev);
334	    break;
335	}
336	if (((ifp->if_flags & IFF_UP)) && (!(ifp->if_flags & IFF_RUNNING))) {
337
338	    /* XXX
339	     * Should the request be interruptible?
340	     */
341	    if ((error = ppb_request_bus(&sc->lp_dev, PPB_WAIT|PPB_INTR)))
342		return (error);
343
344	    /* Now IFF_UP means that we own the bus */
345
346	    ppb_set_mode(&sc->lp_dev, PPB_COMPATIBLE);
347
348	    if (lpinittables()) {
349		ppb_release_bus(&sc->lp_dev);
350		return ENOBUFS;
351	    }
352
353	    sc->sc_ifbuf = malloc(sc->sc_if.if_mtu + MLPIPHDRLEN,
354				  M_DEVBUF, M_WAITOK);
355	    if (!sc->sc_ifbuf) {
356		ppb_release_bus(&sc->lp_dev);
357		return ENOBUFS;
358	    }
359
360	    ppb_wctr(&sc->lp_dev, LPC_ENA);
361	    ifp->if_flags |= IFF_RUNNING;
362	}
363	break;
364
365    case SIOCSIFMTU:
366	ptr = sc->sc_ifbuf;
367	sc->sc_ifbuf = malloc(ifr->ifr_mtu+MLPIPHDRLEN, M_DEVBUF, M_NOWAIT);
368	if (!sc->sc_ifbuf) {
369	    sc->sc_ifbuf = ptr;
370	    return ENOBUFS;
371	}
372	if (ptr)
373	    free(ptr,M_DEVBUF);
374	sc->sc_if.if_mtu = ifr->ifr_mtu;
375	break;
376
377    case SIOCGIFMTU:
378	ifr->ifr_mtu = sc->sc_if.if_mtu;
379	break;
380
381    case SIOCADDMULTI:
382    case SIOCDELMULTI:
383	if (ifr == 0) {
384	    return EAFNOSUPPORT;		/* XXX */
385	}
386	switch (ifr->ifr_addr.sa_family) {
387
388	case AF_INET:
389	    break;
390
391	default:
392	    return EAFNOSUPPORT;
393	}
394	break;
395
396    case SIOCGIFMEDIA:
397	/*
398	 * No ifmedia support at this stage; maybe use it
399	 * in future for eg. protocol selection.
400	 */
401	return EINVAL;
402
403    default:
404	lprintf("LP:ioctl(0x%lx)\n", cmd);
405	return EINVAL;
406    }
407    return 0;
408}
409
410static __inline int
411clpoutbyte (u_char byte, int spin, struct ppb_device *dev)
412{
413	ppb_wdtr(dev, ctxmitl[byte]);
414	while (ppb_rstr(dev) & CLPIP_SHAKE)
415		if (--spin == 0) {
416			return 1;
417		}
418	ppb_wdtr(dev, ctxmith[byte]);
419	while (!(ppb_rstr(dev) & CLPIP_SHAKE))
420		if (--spin == 0) {
421			return 1;
422		}
423	return 0;
424}
425
426static __inline int
427clpinbyte (int spin, struct ppb_device *dev)
428{
429	u_char c, cl;
430
431	while((ppb_rstr(dev) & CLPIP_SHAKE))
432	    if(!--spin) {
433		return -1;
434	    }
435	cl = ppb_rstr(dev);
436	ppb_wdtr(dev, 0x10);
437
438	while(!(ppb_rstr(dev) & CLPIP_SHAKE))
439	    if(!--spin) {
440		return -1;
441	    }
442	c = ppb_rstr(dev);
443	ppb_wdtr(dev, 0x00);
444
445	return (ctrecvl[cl] | ctrecvh[c]);
446}
447
448static void
449lpintr (int unit)
450{
451	struct   lpt_softc *sc = lpdata[unit];
452	int len, s, j;
453	u_char *bp;
454	u_char c, cl;
455	struct mbuf *top;
456
457	s = splhigh();
458
459	if (sc->sc_if.if_flags & IFF_LINK0) {
460
461	    /* Ack. the request */
462	    ppb_wdtr(&sc->lp_dev, 0x01);
463
464	    /* Get the packet length */
465	    j = clpinbyte(LPMAXSPIN2, &sc->lp_dev);
466	    if (j == -1)
467		goto err;
468	    len = j;
469	    j = clpinbyte(LPMAXSPIN2, &sc->lp_dev);
470	    if (j == -1)
471		goto err;
472	    len = len + (j << 8);
473	    if (len > sc->sc_if.if_mtu + MLPIPHDRLEN)
474		goto err;
475
476	    bp  = sc->sc_ifbuf;
477
478	    while (len--) {
479	        j = clpinbyte(LPMAXSPIN2, &sc->lp_dev);
480	        if (j == -1) {
481		    goto err;
482	        }
483	        *bp++ = j;
484	    }
485	    /* Get and ignore checksum */
486	    j = clpinbyte(LPMAXSPIN2, &sc->lp_dev);
487	    if (j == -1) {
488	        goto err;
489	    }
490
491	    len = bp - sc->sc_ifbuf;
492	    if (len <= CLPIPHDRLEN)
493	        goto err;
494
495	    sc->sc_iferrs = 0;
496
497	    if (IF_QFULL(&ipintrq)) {
498	        lprintf("DROP");
499	        IF_DROP(&ipintrq);
500		goto done;
501	    }
502	    len -= CLPIPHDRLEN;
503	    sc->sc_if.if_ipackets++;
504	    sc->sc_if.if_ibytes += len;
505	    top = m_devget(sc->sc_ifbuf + CLPIPHDRLEN, len, 0, &sc->sc_if, 0);
506	    if (top) {
507	        IF_ENQUEUE(&ipintrq, top);
508	        schednetisr(NETISR_IP);
509	    }
510	    goto done;
511	}
512	while ((ppb_rstr(&sc->lp_dev) & LPIP_SHAKE)) {
513	    len = sc->sc_if.if_mtu + LPIPHDRLEN;
514	    bp  = sc->sc_ifbuf;
515	    while (len--) {
516
517		cl = ppb_rstr(&sc->lp_dev);
518		ppb_wdtr(&sc->lp_dev, 8);
519
520		j = LPMAXSPIN2;
521		while((ppb_rstr(&sc->lp_dev) & LPIP_SHAKE))
522		    if(!--j) goto err;
523
524		c = ppb_rstr(&sc->lp_dev);
525		ppb_wdtr(&sc->lp_dev, 0);
526
527		*bp++= trecvh[cl] | trecvl[c];
528
529		j = LPMAXSPIN2;
530		while (!((cl=ppb_rstr(&sc->lp_dev)) & LPIP_SHAKE)) {
531		    if (cl != c &&
532			(((cl = ppb_rstr(&sc->lp_dev)) ^ 0xb8) & 0xf8) ==
533			  (c & 0xf8))
534			goto end;
535		    if (!--j) goto err;
536		}
537	    }
538
539	end:
540	    len = bp - sc->sc_ifbuf;
541	    if (len <= LPIPHDRLEN)
542		goto err;
543
544	    sc->sc_iferrs = 0;
545
546	    if (IF_QFULL(&ipintrq)) {
547		lprintf("DROP");
548		IF_DROP(&ipintrq);
549		goto done;
550	    }
551#if NBPFILTER > 0
552	    if (sc->sc_if.if_bpf) {
553		bpf_tap(&sc->sc_if, sc->sc_ifbuf, len);
554	    }
555#endif
556	    len -= LPIPHDRLEN;
557	    sc->sc_if.if_ipackets++;
558	    sc->sc_if.if_ibytes += len;
559	    top = m_devget(sc->sc_ifbuf + LPIPHDRLEN, len, 0, &sc->sc_if, 0);
560	    if (top) {
561		    IF_ENQUEUE(&ipintrq, top);
562		    schednetisr(NETISR_IP);
563	    }
564	}
565	goto done;
566
567    err:
568	ppb_wdtr(&sc->lp_dev, 0);
569	lprintf("R");
570	sc->sc_if.if_ierrors++;
571	sc->sc_iferrs++;
572
573	/*
574	 * We are not able to send receive anything for now,
575	 * so stop wasting our time
576	 */
577	if (sc->sc_iferrs > LPMAXERRS) {
578	    printf("lp%d: Too many errors, Going off-line.\n", unit);
579	    ppb_wctr(&sc->lp_dev, 0x00);
580	    sc->sc_if.if_flags &= ~IFF_RUNNING;
581	    sc->sc_iferrs=0;
582	}
583
584    done:
585	splx(s);
586	return;
587}
588
589static __inline int
590lpoutbyte (u_char byte, int spin, struct ppb_device *dev)
591{
592    ppb_wdtr(dev, txmith[byte]);
593    while (!(ppb_rstr(dev) & LPIP_SHAKE))
594	if (--spin == 0)
595		return 1;
596    ppb_wdtr(dev, txmitl[byte]);
597    while (ppb_rstr(dev) & LPIP_SHAKE)
598	if (--spin == 0)
599		return 1;
600    return 0;
601}
602
603static int
604lpoutput (struct ifnet *ifp, struct mbuf *m,
605	  struct sockaddr *dst, struct rtentry *rt)
606{
607    struct lpt_softc *sc = lpdata[ifp->if_unit];
608    int s, err;
609    struct mbuf *mm;
610    u_char *cp = "\0\0";
611    u_char chksum = 0;
612    int count = 0;
613    int i;
614    int spin;
615
616    /* We need a sensible value if we abort */
617    cp++;
618    ifp->if_flags |= IFF_RUNNING;
619
620    err = 1;			/* assume we're aborting because of an error */
621
622    s = splhigh();
623
624    /* Suspend (on laptops) or receive-errors might have taken us offline */
625    ppb_wctr(&sc->lp_dev, LPC_ENA);
626
627    if (ifp->if_flags & IFF_LINK0) {
628
629	if (!(ppb_rstr(&sc->lp_dev) & CLPIP_SHAKE)) {
630	    lprintf("&");
631	    lpintr(ifp->if_unit);
632	}
633
634	/* Alert other end to pending packet */
635	spin = LPMAXSPIN1;
636	ppb_wdtr(&sc->lp_dev, 0x08);
637	while ((ppb_rstr(&sc->lp_dev) & 0x08) == 0)
638		if (--spin == 0) {
639			goto nend;
640		}
641
642	/* Calculate length of packet, then send that */
643
644	count += 14;		/* Ethernet header len */
645
646	mm = m;
647	for (mm = m; mm; mm = mm->m_next) {
648		count += mm->m_len;
649	}
650	if (clpoutbyte(count & 0xFF, LPMAXSPIN1, &sc->lp_dev))
651		goto nend;
652	if (clpoutbyte((count >> 8) & 0xFF, LPMAXSPIN1, &sc->lp_dev))
653		goto nend;
654
655	/* Send dummy ethernet header */
656	for (i = 0; i < 12; i++) {
657		if (clpoutbyte(i, LPMAXSPIN1, &sc->lp_dev))
658			goto nend;
659		chksum += i;
660	}
661
662	if (clpoutbyte(0x08, LPMAXSPIN1, &sc->lp_dev))
663		goto nend;
664	if (clpoutbyte(0x00, LPMAXSPIN1, &sc->lp_dev))
665		goto nend;
666	chksum += 0x08 + 0x00;		/* Add into checksum */
667
668	mm = m;
669	do {
670		cp = mtod(mm, u_char *);
671		while (mm->m_len--) {
672			chksum += *cp;
673			if (clpoutbyte(*cp++, LPMAXSPIN2, &sc->lp_dev))
674				goto nend;
675		}
676	} while ((mm = mm->m_next));
677
678	/* Send checksum */
679	if (clpoutbyte(chksum, LPMAXSPIN2, &sc->lp_dev))
680		goto nend;
681
682	/* Go quiescent */
683	ppb_wdtr(&sc->lp_dev, 0);
684
685	err = 0;			/* No errors */
686
687	nend:
688	if (err)  {				/* if we didn't timeout... */
689		ifp->if_oerrors++;
690		lprintf("X");
691	} else {
692		ifp->if_opackets++;
693		ifp->if_obytes += m->m_pkthdr.len;
694	}
695
696	m_freem(m);
697
698	if (!(ppb_rstr(&sc->lp_dev) & CLPIP_SHAKE)) {
699		lprintf("^");
700		lpintr(ifp->if_unit);
701	}
702	(void) splx(s);
703	return 0;
704    }
705
706    if (ppb_rstr(&sc->lp_dev) & LPIP_SHAKE) {
707        lprintf("&");
708        lpintr(ifp->if_unit);
709    }
710
711    if (lpoutbyte(0x08, LPMAXSPIN1, &sc->lp_dev))
712        goto end;
713    if (lpoutbyte(0x00, LPMAXSPIN2, &sc->lp_dev))
714        goto end;
715
716    mm = m;
717    do {
718        cp = mtod(mm,u_char *);
719        while (mm->m_len--)
720	    if (lpoutbyte(*cp++, LPMAXSPIN2, &sc->lp_dev))
721	        goto end;
722    } while ((mm = mm->m_next));
723
724    err = 0;				/* no errors were encountered */
725
726    end:
727    --cp;
728    ppb_wdtr(&sc->lp_dev, txmitl[*cp] ^ 0x17);
729
730    if (err)  {				/* if we didn't timeout... */
731	ifp->if_oerrors++;
732        lprintf("X");
733    } else {
734	ifp->if_opackets++;
735	ifp->if_obytes += m->m_pkthdr.len;
736#if NBPFILTER > 0
737	if (ifp->if_bpf) {
738	    /*
739	     * We need to prepend the packet type as
740	     * a two byte field.  Cons up a dummy header
741	     * to pacify bpf.  This is safe because bpf
742	     * will only read from the mbuf (i.e., it won't
743	     * try to free it or keep a pointer to it).
744	     */
745	    struct mbuf m0;
746	    u_short hdr = 0x800;
747
748	    m0.m_next = m;
749	    m0.m_len = 2;
750	    m0.m_data = (char *)&hdr;
751
752	    bpf_mtap(ifp, &m0);
753	}
754#endif
755    }
756
757    m_freem(m);
758
759    if (ppb_rstr(&sc->lp_dev) & LPIP_SHAKE) {
760	lprintf("^");
761	lpintr(ifp->if_unit);
762    }
763
764    (void) splx(s);
765    return 0;
766}
767