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