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