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