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