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