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