![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_3c501.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at|
Return to if_3c501.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at |
1.1 ! root 1: /* ! 2: * Mach Operating System ! 3: * Copyright (c) 1991,1990,1989 Carnegie Mellon University ! 4: * All Rights Reserved. ! 5: * ! 6: * Permission to use, copy, modify and distribute this software and its ! 7: * documentation is hereby granted, provided that both the copyright ! 8: * notice and this permission notice appear in all copies of the ! 9: * software, derivative works or modified versions, and any portions ! 10: * thereof, and that both notices appear in supporting documentation. ! 11: * ! 12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" ! 13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR ! 14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. ! 15: * ! 16: * Carnegie Mellon requests users of this software to return to ! 17: * ! 18: * Software Distribution Coordinator or [email protected] ! 19: * School of Computer Science ! 20: * Carnegie Mellon University ! 21: * Pittsburgh PA 15213-3890 ! 22: * ! 23: * any improvements or extensions that they make and grant Carnegie Mellon ! 24: * the rights to redistribute these changes. ! 25: */ ! 26: /* ! 27: * File: if_3c501.c ! 28: * Author: Philippe Bernadat ! 29: * Date: 1989 ! 30: * Copyright (c) 1989 OSF Research Institute ! 31: * ! 32: * 3COM Etherlink 3C501 Mach Ethernet drvier ! 33: */ ! 34: /* ! 35: Copyright 1990 by Open Software Foundation, ! 36: Cambridge, MA. ! 37: ! 38: All Rights Reserved ! 39: ! 40: Permission to use, copy, modify, and distribute this software and ! 41: its documentation for any purpose and without fee is hereby granted, ! 42: provided that the above copyright notice appears in all copies and ! 43: that both the copyright notice and this permission notice appear in ! 44: supporting documentation, and that the name of OSF or Open Software ! 45: Foundation not be used in advertising or publicity pertaining to ! 46: distribution of the software without specific, written prior ! 47: permission. ! 48: ! 49: OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE ! 50: INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, ! 51: IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR ! 52: CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM ! 53: LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT, ! 54: NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION ! 55: WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ! 56: */ ! 57: ! 58: #include <at3c501.h> ! 59: ! 60: #ifdef MACH_KERNEL ! 61: #include <kern/time_out.h> ! 62: #include <device/device_types.h> ! 63: #include <device/errno.h> ! 64: #include <device/io_req.h> ! 65: #include <device/if_hdr.h> ! 66: #include <device/if_ether.h> ! 67: #include <device/net_status.h> ! 68: #include <device/net_io.h> ! 69: #else MACH_KERNEL ! 70: #include <sys/param.h> ! 71: #include <mach/machine/vm_param.h> ! 72: #include <sys/systm.h> ! 73: #include <sys/mbuf.h> ! 74: #include <sys/buf.h> ! 75: #include <sys/protosw.h> ! 76: #include <sys/socket.h> ! 77: #include <sys/vmmac.h> ! 78: #include <sys/ioctl.h> ! 79: #include <sys/errno.h> ! 80: #include <sys/syslog.h> ! 81: ! 82: #include <net/if.h> ! 83: #include <net/netisr.h> ! 84: #include <net/route.h> ! 85: ! 86: #ifdef INET ! 87: #include <netinet/in.h> ! 88: #include <netinet/in_systm.h> ! 89: #include <netinet/in_var.h> ! 90: #include <netinet/ip.h> ! 91: #include <netinet/if_ether.h> ! 92: #endif ! 93: ! 94: #ifdef NS ! 95: #include <netns/ns.h> ! 96: #include <netns/ns_if.h> ! 97: #endif ! 98: #endif MACH_KERNEL ! 99: ! 100: #include <i386/ipl.h> ! 101: #include <chips/busses.h> ! 102: #include <i386at/if_3c501.h> ! 103: ! 104: #define SPLNET spl6 ! 105: ! 106: int at3c501probe(); ! 107: void at3c501attach(); ! 108: int at3c501intr(); ! 109: int at3c501init(); ! 110: int at3c501output(); ! 111: int at3c501ioctl(); ! 112: int at3c501reset(); ! 113: int at3c501watch(); ! 114: ! 115: static vm_offset_t at3c501_std[NAT3C501] = { 0 }; ! 116: static struct bus_device *at3c501_info[NAT3C501]; ! 117: struct bus_driver at3c501driver = ! 118: {at3c501probe, 0, at3c501attach, 0, at3c501_std, "et", at3c501_info, }; ! 119: ! 120: int watchdog_id; ! 121: ! 122: typedef struct { ! 123: #ifdef MACH_KERNEL ! 124: struct ifnet ds_if; /* generic interface header */ ! 125: u_char ds_addr[6]; /* Ethernet hardware address */ ! 126: #else MACH_KERNEL ! 127: struct arpcom at3c501_ac; ! 128: #define ds_if at3c501_ac.ac_if ! 129: #define ds_addr at3c501_ac.ac_enaddr ! 130: #endif MACH_KERNEL ! 131: int flags; ! 132: int timer; ! 133: char *base; ! 134: u_char address[ETHER_ADD_SIZE]; ! 135: short mode; ! 136: int badxmt; ! 137: int badrcv; ! 138: int spurious; ! 139: int rcv; ! 140: int xmt; ! 141: } at3c501_softc_t; ! 142: ! 143: at3c501_softc_t at3c501_softc[NAT3C501]; ! 144: ! 145: /* ! 146: * at3c501probe: ! 147: * ! 148: * This function "probes" or checks for the 3c501 board on the bus to see ! 149: * if it is there. As far as I can tell, the best break between this ! 150: * routine and the attach code is to simply determine whether the board ! 151: * is configured in properly. Currently my approach to this is to write ! 152: * and read a string from the Packet Buffer on the board being probed. ! 153: * If the string comes back properly then we assume the board is there. ! 154: * The config code expects to see a successful return from the probe ! 155: * routine before attach will be called. ! 156: * ! 157: * input : address device is mapped to, and unit # being checked ! 158: * output : a '1' is returned if the board exists, and a 0 otherwise ! 159: * ! 160: */ ! 161: at3c501probe(port, dev) ! 162: struct bus_device *dev; ! 163: { ! 164: caddr_t base = (caddr_t)dev->address; ! 165: int unit = dev->unit; ! 166: char inbuf[50]; ! 167: char *str = "3c501 ethernet board %d out of range\n"; ! 168: int strsize = strlen(str); ! 169: ! 170: if ((unit < 0) || (unit >= NAT3C501)) { ! 171: printf(str, unit); ! 172: return(0); ! 173: } ! 174: ! 175: /* reset */ ! 176: outb(IE_CSR(base), IE_RESET); ! 177: ! 178: /* write a string to the packet buffer */ ! 179: ! 180: outb(IE_CSR(base), IE_RIDE | IE_SYSBFR); ! 181: outw(IE_GP(base), 0); ! 182: loutb(IE_BFR(base), str, strsize); ! 183: ! 184: /* read it back */ ! 185: ! 186: outb(IE_CSR(base), IE_RIDE | IE_SYSBFR); ! 187: outw(IE_GP(base), 0); ! 188: linb(IE_BFR(base), inbuf, strsize); ! 189: /* compare them */ ! 190: ! 191: #ifdef MACH_KERNEL ! 192: if (strncmp(str, inbuf, strsize)) ! 193: #else MACH_KERNEL ! 194: if (bcmp(str, inbuf, strsize)) ! 195: #endif MACH_KERNEL ! 196: { ! 197: return(0); ! 198: } ! 199: at3c501_softc[unit].base = base; ! 200: ! 201: return(1); ! 202: } ! 203: ! 204: /* ! 205: * at3c501attach: ! 206: * ! 207: * This function attaches a 3C501 board to the "system". The rest of ! 208: * runtime structures are initialized here (this routine is called after ! 209: * a successful probe of the board). Once the ethernet address is read ! 210: * and stored, the board's ifnet structure is attached and readied. ! 211: * ! 212: * input : bus_device structure setup in autoconfig ! 213: * output : board structs and ifnet is setup ! 214: * ! 215: */ ! 216: void at3c501attach(dev) ! 217: struct bus_device *dev; ! 218: { ! 219: at3c501_softc_t *sp; ! 220: struct ifnet *ifp; ! 221: u_char unit; ! 222: caddr_t base; ! 223: #ifdef MACH_KERNEL ! 224: #else MACH_KERNEL ! 225: extern int tcp_recvspace; ! 226: tcp_recvspace = 0x300; /* empircal messure */ ! 227: #endif MACH_KERNEL ! 228: ! 229: take_dev_irq(dev); ! 230: unit = (u_char)dev->unit; ! 231: printf(", port = %x, spl = %d, pic = %d. ", ! 232: dev->address, dev->sysdep, dev->sysdep1); ! 233: ! 234: sp = &at3c501_softc[unit]; ! 235: base = sp->base; ! 236: if (base != (caddr_t)dev->address) { ! 237: printf("3C501 board %d attach address error\n", unit); ! 238: return; ! 239: } ! 240: sp->timer = -1; ! 241: sp->flags = 0; ! 242: sp->mode = 0; ! 243: outb(IE_CSR(sp->base), IE_RESET); ! 244: at3c501geteh(base, sp->ds_addr); ! 245: at3c501geteh(base, sp->address); ! 246: at3c501seteh(base, sp->address); ! 247: printf("ethernet id [%x:%x:%x:%x:%x:%x]", ! 248: sp->address[0],sp->address[1],sp->address[2], ! 249: sp->address[3],sp->address[4],sp->address[5]); ! 250: ifp = &(sp->ds_if); ! 251: ifp->if_unit = unit; ! 252: ifp->if_mtu = ETHERMTU; ! 253: ifp->if_flags = IFF_BROADCAST; ! 254: #ifdef MACH_KERNEL ! 255: ifp->if_header_size = sizeof(struct ether_header); ! 256: ifp->if_header_format = HDR_ETHERNET; ! 257: ifp->if_address_size = 6; ! 258: ifp->if_address = (char *)&sp->address[0]; ! 259: if_init_queues(ifp); ! 260: #else MACH_KERNEL ! 261: ifp->if_name = "et"; ! 262: ifp->if_init = at3c501init; ! 263: ifp->if_output = at3c501output; ! 264: ifp->if_ioctl = at3c501ioctl; ! 265: ifp->if_reset = at3c501reset; ! 266: ifp->if_next = NULL; ! 267: if_attach(ifp); ! 268: #ifdef notdef ! 269: watchdog_id = timeout(at3c501watch, &(ifp->if_unit), 20*HZ); ! 270: #endif ! 271: #endif MACH_KERNEL ! 272: } ! 273: ! 274: /* ! 275: * at3c501watch(): ! 276: * ! 277: */ ! 278: at3c501watch(b_ptr) ! 279: ! 280: caddr_t b_ptr; ! 281: ! 282: { ! 283: int x, ! 284: y, ! 285: opri, ! 286: unit; ! 287: at3c501_softc_t *is; ! 288: ! 289: unit = *b_ptr; ! 290: #ifdef MACH_KERNEL ! 291: timeout(at3c501watch,b_ptr,20*hz); ! 292: #else MACH_KERNEL ! 293: watchdog_id = timeout(at3c501watch,b_ptr,20*HZ); ! 294: #endif MACH_KERNEL ! 295: is = &at3c501_softc[unit]; ! 296: printf("\nxmt/bad rcv/bad spurious\n"); ! 297: printf("%d/%d %d/%d %d\n", is->xmt, is->badxmt, \ ! 298: is->rcv, is->badrcv, is->spurious); ! 299: is->rcv=is->badrcv=is->xmt=is->badxmt=is->spurious=0; ! 300: } ! 301: ! 302: /* ! 303: * at3c501geteh: ! 304: * ! 305: * This function gets the ethernet address (array of 6 unsigned ! 306: * bytes) from the 3c501 board prom. ! 307: * ! 308: */ ! 309: ! 310: at3c501geteh(base, ep) ! 311: caddr_t base; ! 312: char *ep; ! 313: { ! 314: int i; ! 315: ! 316: for (i = 0; i < ETHER_ADD_SIZE; i++) { ! 317: outw(IE_GP(base), i); ! 318: *ep++ = inb(IE_SAPROM(base)); ! 319: } ! 320: } ! 321: ! 322: /* ! 323: * at3c501seteh: ! 324: * ! 325: * This function sets the ethernet address (array of 6 unsigned ! 326: * bytes) on the 3c501 board. ! 327: * ! 328: */ ! 329: ! 330: at3c501seteh(base, ep) ! 331: caddr_t base; ! 332: char *ep; ! 333: { ! 334: int i; ! 335: ! 336: for (i = 0; i < ETHER_ADD_SIZE; i++) { ! 337: outb(EDLC_ADDR(base) + i, *ep++); ! 338: } ! 339: } ! 340: ! 341: #ifdef MACH_KERNEL ! 342: int at3c501start(); /* forward */ ! 343: ! 344: at3c501output(dev, ior) ! 345: dev_t dev; ! 346: io_req_t ior; ! 347: { ! 348: register int unit = minor(dev); ! 349: ! 350: if (unit < 0 || unit >= NAT3C501 || ! 351: at3c501_softc[unit].base == 0) ! 352: return (ENXIO); ! 353: ! 354: return (net_write(&at3c501_softc[unit].ds_if, at3c501start, ior)); ! 355: } ! 356: ! 357: at3c501setinput(dev, receive_port, priority, filter, filter_count) ! 358: dev_t dev; ! 359: mach_port_t receive_port; ! 360: int priority; ! 361: filter_t filter[]; ! 362: u_int filter_count; ! 363: { ! 364: register int unit = minor(dev); ! 365: ! 366: if (unit < 0 || unit >= NAT3C501 || ! 367: at3c501_softc[unit].base == 0) ! 368: return (ENXIO); ! 369: ! 370: return (net_set_filter(&at3c501_softc[unit].ds_if, ! 371: receive_port, priority, ! 372: filter, filter_count)); ! 373: } ! 374: ! 375: #else MACH_KERNEL ! 376: /* ! 377: * at3c501output: ! 378: * ! 379: * This routine is called by the "if" layer to output a packet to ! 380: * the network. This code resolves the local ethernet address, and ! 381: * puts it into the mbuf if there is room. If not, then a new mbuf ! 382: * is allocated with the header information and precedes the data ! 383: * to be transmitted. ! 384: * ! 385: * input: ifnet structure pointer, an mbuf with data, and address ! 386: * to be resolved ! 387: * output: mbuf is updated to hold enet address, or a new mbuf ! 388: * with the address is added ! 389: * ! 390: */ ! 391: at3c501output(ifp, m0, dst) ! 392: struct ifnet *ifp; ! 393: struct mbuf *m0; ! 394: struct sockaddr *dst; ! 395: { ! 396: int type, error; ! 397: spl_t opri; ! 398: u_char edst[6]; ! 399: struct in_addr idst; ! 400: register at3c501_softc_t *is; ! 401: register struct mbuf *m = m0; ! 402: register struct ether_header *eh; ! 403: register int off; ! 404: int usetrailers; ! 405: ! 406: is = &at3c501_softc[ifp->if_unit]; ! 407: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) { ! 408: printf("3C501 Turning off board %d\n", ifp->if_unit); ! 409: at3c501intoff(ifp->if_unit); ! 410: error = ENETDOWN; ! 411: goto bad; ! 412: } ! 413: switch (dst->sa_family) { ! 414: ! 415: #ifdef INET ! 416: case AF_INET: ! 417: idst = ((struct sockaddr_in *)dst)->sin_addr; ! 418: if (!arpresolve(&is->at3c501_ac, m, &idst, edst, &usetrailers)){ ! 419: return (0); /* if not yet resolved */ ! 420: } ! 421: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len; ! 422: ! 423: if (usetrailers && off > 0 && (off & 0x1ff) == 0 && ! 424: m->m_off >= MMINOFF + 2 * sizeof (u_short)) { ! 425: type = ETHERTYPE_TRAIL + (off>>9); ! 426: m->m_off -= 2 * sizeof (u_short); ! 427: m->m_len += 2 * sizeof (u_short); ! 428: *mtod(m, u_short *) = htons((u_short)ETHERTYPE_IP); ! 429: *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len); ! 430: goto gottrailertype; ! 431: } ! 432: type = ETHERTYPE_IP; ! 433: off = 0; ! 434: goto gottype; ! 435: #endif ! 436: #ifdef NS ! 437: case AF_NS: ! 438: type = ETHERTYPE_NS; ! 439: bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host), ! 440: (caddr_t)edst, sizeof (edst)); ! 441: off = 0; ! 442: goto gottype; ! 443: #endif ! 444: ! 445: case AF_UNSPEC: ! 446: eh = (struct ether_header *)dst->sa_data; ! 447: bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, sizeof (edst)); ! 448: type = eh->ether_type; ! 449: goto gottype; ! 450: ! 451: default: ! 452: printf("at3c501%d: can't handle af%d\n", ifp->if_unit, ! 453: dst->sa_family); ! 454: error = EAFNOSUPPORT; ! 455: goto bad; ! 456: } ! 457: ! 458: gottrailertype: ! 459: /* ! 460: * Packet to be sent as trailer: move first packet ! 461: * (control information) to end of chain. ! 462: */ ! 463: while (m->m_next) ! 464: m = m->m_next; ! 465: m->m_next = m0; ! 466: m = m0->m_next; ! 467: m0->m_next = 0; ! 468: m0 = m; ! 469: ! 470: gottype: ! 471: /* ! 472: * Add local net header. If no space in first mbuf, ! 473: * allocate another. ! 474: */ ! 475: if (m->m_off > MMAXOFF || ! 476: MMINOFF + sizeof (struct ether_header) > m->m_off) { ! 477: m = m_get(M_DONTWAIT, MT_HEADER); ! 478: if (m == 0) { ! 479: error = ENOBUFS; ! 480: goto bad; ! 481: } ! 482: m->m_next = m0; ! 483: m->m_off = MMINOFF; ! 484: m->m_len = sizeof (struct ether_header); ! 485: } else { ! 486: m->m_off -= sizeof (struct ether_header); ! 487: m->m_len += sizeof (struct ether_header); ! 488: } ! 489: eh = mtod(m, struct ether_header *); ! 490: eh->ether_type = htons((u_short)type); ! 491: bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst)); ! 492: bcopy((caddr_t)is->address,(caddr_t)eh->ether_shost, ! 493: sizeof(edst)); ! 494: /* ! 495: * Queue message on interface, and start output if interface ! 496: * not yet active. ! 497: */ ! 498: opri = SPLNET(); ! 499: if (IF_QFULL(&ifp->if_snd)) { ! 500: IF_DROP(&ifp->if_snd); ! 501: splx(opri); ! 502: m_freem(m); ! 503: return (ENOBUFS); ! 504: } ! 505: IF_ENQUEUE(&ifp->if_snd, m); ! 506: /* ! 507: * Some action needs to be added here for checking whether the ! 508: * board is already transmitting. If it is, we don't want to ! 509: * start it up (ie call at3c501start()). We will attempt to send ! 510: * packets that are queued up after an interrupt occurs. Some ! 511: * flag checking action has to happen here and/or in the start ! 512: * routine. This note is here to remind me that some thought ! 513: * is needed and there is a potential problem here. ! 514: * ! 515: */ ! 516: at3c501start(ifp->if_unit); ! 517: splx(opri); ! 518: return (0); ! 519: ! 520: bad: ! 521: m_freem(m0); ! 522: return (error); ! 523: } ! 524: #endif MACH_KERNEL ! 525: ! 526: /* ! 527: * at3c501reset: ! 528: * ! 529: * This routine is in part an entry point for the "if" code. Since most ! 530: * of the actual initialization has already (we hope already) been done ! 531: * by calling at3c501attach(). ! 532: * ! 533: * input : unit number or board number to reset ! 534: * output : board is reset ! 535: * ! 536: */ ! 537: at3c501reset(unit) ! 538: int unit; ! 539: { ! 540: at3c501_softc[unit].ds_if.if_flags &= ~IFF_RUNNING; ! 541: return(at3c501init(unit)); ! 542: } ! 543: ! 544: ! 545: ! 546: /* ! 547: * at3c501init: ! 548: * ! 549: * Another routine that interfaces the "if" layer to this driver. ! 550: * Simply resets the structures that are used by "upper layers". ! 551: * As well as calling at3c501hwrst that does reset the at3c501 board. ! 552: * ! 553: * input : board number ! 554: * output : structures (if structs) and board are reset ! 555: * ! 556: */ ! 557: at3c501init(unit) ! 558: int unit; ! 559: { ! 560: struct ifnet *ifp; ! 561: int stat; ! 562: spl_t oldpri; ! 563: ! 564: ifp = &(at3c501_softc[unit].ds_if); ! 565: #ifdef MACH_KERNEL ! 566: #else MACH_KERNEL ! 567: if (ifp->if_addrlist == (struct ifaddr *)0) { ! 568: return; ! 569: } ! 570: #endif MACH_KERNEL ! 571: oldpri = SPLNET(); ! 572: if ((stat = at3c501hwrst(unit)) == TRUE) { ! 573: at3c501_softc[unit].ds_if.if_flags |= IFF_RUNNING; ! 574: at3c501_softc[unit].flags |= DSF_RUNNING; ! 575: at3c501start(unit); ! 576: } ! 577: else ! 578: printf("3C501 trouble resetting board %d\n", unit); ! 579: at3c501_softc[unit].timer = 5; ! 580: splx(oldpri); ! 581: return(stat); ! 582: ! 583: } ! 584: ! 585: #ifdef MACH_KERNEL ! 586: /*ARGSUSED*/ ! 587: at3c501open(dev, flag) ! 588: dev_t dev; ! 589: int flag; ! 590: { ! 591: register int unit = minor(dev); ! 592: ! 593: if (unit < 0 || unit >= NAT3C501 || ! 594: at3c501_softc[unit].base == 0) ! 595: return (ENXIO); ! 596: ! 597: at3c501_softc[unit].ds_if.if_flags |= IFF_UP; ! 598: at3c501init(unit); ! 599: return(0); ! 600: } ! 601: #endif MACH_KERNEL ! 602: ! 603: /* ! 604: * at3c501start: ! 605: * ! 606: * This is yet another interface routine that simply tries to output a ! 607: * in an mbuf after a reset. ! 608: * ! 609: * input : board number ! 610: * output : stuff sent to board if any there ! 611: * ! 612: */ ! 613: at3c501start(unit) ! 614: int unit; ! 615: ! 616: { ! 617: #ifdef MACH_KERNEL ! 618: io_req_t m; ! 619: #else MACH_KERNEL ! 620: struct mbuf *m; ! 621: #endif MACH_KERNEL ! 622: struct ifnet *ifp; ! 623: ! 624: ifp = &(at3c501_softc[unit].ds_if); ! 625: for(;;) { ! 626: IF_DEQUEUE(&ifp->if_snd, m); ! 627: #ifdef MACH_KERNEL ! 628: if (m != 0) ! 629: #else MACH_KERNEL ! 630: if (m != (struct mbuf *)0) ! 631: #endif MACH_KERNEL ! 632: at3c501xmt(unit, m); ! 633: else ! 634: return; ! 635: } ! 636: } ! 637: ! 638: #ifdef MACH_KERNEL ! 639: /*ARGSUSED*/ ! 640: at3c501getstat(dev, flavor, status, count) ! 641: dev_t dev; ! 642: int flavor; ! 643: dev_status_t status; /* pointer to OUT array */ ! 644: u_int *count; /* out */ ! 645: { ! 646: register int unit = minor(dev); ! 647: ! 648: if (unit < 0 || unit >= NAT3C501 || ! 649: at3c501_softc[unit].base == 0) ! 650: return (ENXIO); ! 651: ! 652: return (net_getstat(&at3c501_softc[unit].ds_if, ! 653: flavor, ! 654: status, ! 655: count)); ! 656: } ! 657: ! 658: at3c501setstat(dev, flavor, status, count) ! 659: dev_t dev; ! 660: int flavor; ! 661: dev_status_t status; ! 662: u_int count; ! 663: { ! 664: register int unit = minor(dev); ! 665: register at3c501_softc_t *sp; ! 666: ! 667: if (unit < 0 || unit >= NAT3C501 || ! 668: at3c501_softc[unit].base == 0) ! 669: return (ENXIO); ! 670: ! 671: sp = &at3c501_softc[unit]; ! 672: ! 673: switch (flavor) { ! 674: case NET_STATUS: ! 675: { ! 676: /* ! 677: * All we can change are flags, and not many of those. ! 678: */ ! 679: register struct net_status *ns = (struct net_status *)status; ! 680: int mode = 0; ! 681: ! 682: if (count < NET_STATUS_COUNT) ! 683: return (D_INVALID_SIZE); ! 684: ! 685: if (ns->flags & IFF_ALLMULTI) ! 686: mode |= MOD_ENAL; ! 687: if (ns->flags & IFF_PROMISC) ! 688: mode |= MOD_PROM; ! 689: ! 690: /* ! 691: * Force a compilete reset if the receive mode changes ! 692: * so that these take effect immediately. ! 693: */ ! 694: if (sp->mode != mode) { ! 695: sp->mode = mode; ! 696: if (sp->flags & DSF_RUNNING) { ! 697: sp->flags &= ~(DSF_LOCK | DSF_RUNNING); ! 698: at3c501init(unit); ! 699: } ! 700: } ! 701: break; ! 702: } ! 703: case NET_ADDRESS: ! 704: { ! 705: register union ether_cvt { ! 706: char addr[6]; ! 707: int lwd[2]; ! 708: } *ec = (union ether_cvt *)status; ! 709: ! 710: if (count < sizeof(*ec)/sizeof(int)) ! 711: return (D_INVALID_SIZE); ! 712: ! 713: ec->lwd[0] = ntohl(ec->lwd[0]); ! 714: ec->lwd[1] = ntohl(ec->lwd[1]); ! 715: at3c501seteh(sp->base, ec->addr); ! 716: break; ! 717: } ! 718: ! 719: default: ! 720: return (D_INVALID_OPERATION); ! 721: } ! 722: return (D_SUCCESS); ! 723: } ! 724: #else MACH_KERNEL ! 725: ! 726: /* ! 727: * at3c501ioctl: ! 728: * ! 729: * This routine processes an ioctl request from the "if" layer ! 730: * above. ! 731: * ! 732: * input : pointer the appropriate "if" struct, command, and data ! 733: * output : based on command appropriate action is taken on the ! 734: * at3c501 board(s) or related structures ! 735: * return : error is returned containing exit conditions ! 736: * ! 737: */ ! 738: int curr_ipl; ! 739: u_short curr_pic_mask; ! 740: u_short pic_mask[]; ! 741: ! 742: at3c501ioctl(ifp, cmd, data) ! 743: struct ifnet *ifp; ! 744: int cmd; ! 745: caddr_t data; ! 746: { ! 747: register struct ifaddr *ifa = (struct ifaddr *)data; ! 748: register at3c501_softc_t *is; ! 749: int error; ! 750: spl_t opri; ! 751: short mode = 0; ! 752: ! 753: is = &at3c501_softc[ifp->if_unit]; ! 754: opri = SPLNET(); ! 755: error = 0; ! 756: switch (cmd) { ! 757: case SIOCSIFADDR: ! 758: ifp->if_flags |= IFF_UP; ! 759: at3c501init(ifp->if_unit); ! 760: switch (ifa->ifa_addr.sa_family) { ! 761: #ifdef INET ! 762: case AF_INET: ! 763: ((struct arpcom *)ifp)->ac_ipaddr = ! 764: IA_SIN(ifa)->sin_addr; ! 765: arpwhohas((struct arpcom *)ifp, ! 766: &IA_SIN(ifa)->sin_addr); ! 767: break; ! 768: #endif ! 769: #ifdef NS ! 770: case AF_NS: ! 771: { ! 772: register struct ns_addr *ina = ! 773: &(IA_SNS(ifa)->sns_addr); ! 774: if (ns_nullhost(*ina)) ! 775: ina->x_host = ! 776: *(union ns_host *)(ds->ds_addr); ! 777: else ! 778: at3c501seteh(ina->x_host.c_host, ! 779: at3c501_softc[ifp->if_unit].base); ! 780: break; ! 781: } ! 782: #endif ! 783: } ! 784: break; ! 785: case SIOCSIFFLAGS: ! 786: if (ifp->if_flags & IFF_ALLMULTI) ! 787: mode |= MOD_ENAL; ! 788: if (ifp->if_flags & IFF_PROMISC) ! 789: mode |= MOD_PROM; ! 790: /* ! 791: * force a complete reset if the receive multicast/ ! 792: * promiscuous mode changes so that these take ! 793: * effect immediately. ! 794: * ! 795: */ ! 796: if (is->mode != mode) { ! 797: is->mode = mode; ! 798: if (is->flags & DSF_RUNNING) { ! 799: is->flags &= ! 800: ~(DSF_LOCK|DSF_RUNNING); ! 801: at3c501init(ifp->if_unit); ! 802: } ! 803: } ! 804: if ((ifp->if_flags & IFF_UP) == 0 && ! 805: is->flags & DSF_RUNNING) { ! 806: printf("AT3C501 ioctl: turning off board %d\n", ! 807: ifp->if_unit); ! 808: is->flags &= ~(DSF_LOCK | DSF_RUNNING); ! 809: is->timer = -1; ! 810: at3c501intoff(ifp->if_unit); ! 811: } else ! 812: if (ifp->if_flags & IFF_UP && ! 813: (is->flags & DSF_RUNNING) == 0) ! 814: at3c501init(ifp->if_unit); ! 815: break; ! 816: default: ! 817: error = EINVAL; ! 818: } ! 819: splx(opri); ! 820: return (error); ! 821: } ! 822: #endif MACH_KERNEL ! 823: ! 824: ! 825: /* ! 826: * at3c501hwrst: ! 827: * ! 828: * This routine resets the at3c501 board that corresponds to the ! 829: * board number passed in. ! 830: * ! 831: * input : board number to do a hardware reset ! 832: * output : board is reset ! 833: * ! 834: */ ! 835: #define XMT_STAT (EDLC_16|EDLC_JAM|EDLC_UNDER|EDLC_IDLE) ! 836: #define RCV_STAT (EDLC_STALE|EDLC_ANY|EDLC_SHORT|EDLC_DRIBBLE|EDLC_OVER|EDLC_FCS) ! 837: int ! 838: at3c501hwrst(unit) ! 839: int unit; ! 840: { ! 841: u_char stat; ! 842: caddr_t base = at3c501_softc[unit].base; ! 843: ! 844: outb(IE_CSR(base), IE_RESET); ! 845: outb(IE_CSR(base), 0); ! 846: at3c501seteh(base, at3c501_softc[unit].address); ! 847: if ((stat = inb(IE_CSR(base))) != IE_RESET) { ! 848: printf("at3c501reset: can't reset CSR: %x\n", stat); ! 849: return(FALSE); ! 850: } ! 851: if ((stat = inb(EDLC_XMT(base))) & XMT_STAT) { ! 852: printf("at3c501reset: can't reset XMT: %x\n", stat); ! 853: return(FALSE); ! 854: } ! 855: if (((stat = inb(EDLC_RCV(base))) & RCV_STAT) != EDLC_STALE) { ! 856: printf("at3c501reset: can't reset RCV: %x\n", stat); ! 857: return(FALSE); ! 858: } ! 859: if (at3c501config(unit) == FALSE) { ! 860: printf("at3c501hwrst(): failed to config\n"); ! 861: return(FALSE); ! 862: } ! 863: outb(IE_RP(base), 0); ! 864: outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC); ! 865: return(TRUE); ! 866: } ! 867: ! 868: /* ! 869: * at3c501intr: ! 870: * ! 871: * This function is the interrupt handler for the at3c501 ethernet ! 872: * board. This routine will be called whenever either a packet ! 873: * is received, or a packet has successfully been transfered and ! 874: * the unit is ready to transmit another packet. ! 875: * ! 876: * input : board number that interrupted ! 877: * output : either a packet is received, or a packet is transfered ! 878: * ! 879: */ ! 880: at3c501intr(unit) ! 881: int unit; ! 882: { ! 883: at3c501rcv(unit); ! 884: at3c501start(unit); ! 885: ! 886: return(0); ! 887: } ! 888: ! 889: ! 890: /* ! 891: * at3c501rcv: ! 892: * ! 893: * This routine is called by the interrupt handler to initiate a ! 894: * packet transfer from the board to the "if" layer above this ! 895: * driver. This routine checks if a buffer has been successfully ! 896: * received by the at3c501. If so, the routine at3c501read is called ! 897: * to do the actual transfer of the board data (including the ! 898: * ethernet header) into a packet (consisting of an mbuf chain). ! 899: * ! 900: * input : number of the board to check ! 901: * output : if a packet is available, it is "sent up" ! 902: * ! 903: */ ! 904: at3c501rcv(unit) ! 905: int unit; ! 906: { ! 907: int stat; ! 908: caddr_t base; ! 909: #ifdef MACH_KERNEL ! 910: ipc_kmsg_t new_kmsg; ! 911: struct ether_header *ehp; ! 912: struct packet_header *pkt; ! 913: #else MACH_KERNEL ! 914: struct mbuf *m, *tm; ! 915: #endif MACH_KERNEL ! 916: u_short len; ! 917: register struct ifnet *ifp; ! 918: struct ether_header header; ! 919: int tlen; ! 920: register at3c501_softc_t *is; ! 921: register struct ifqueue *inq; ! 922: spl_t opri; ! 923: struct ether_header eh; ! 924: ! 925: is = &at3c501_softc[unit]; ! 926: ifp = &is->ds_if; ! 927: base = at3c501_softc[unit].base; ! 928: is->rcv++; ! 929: if (inb(IE_CSR(base)) & IE_RCVBSY) ! 930: is->spurious++; ! 931: while (!((stat=inb(EDLC_RCV(base))) & EDLC_STALE)) { ! 932: outb(IE_CSR(base), IE_SYSBFR); ! 933: if (!(stat & EDLC_ANY)) { ! 934: outw(IE_GP(base), 0); ! 935: len = inw(IE_RP(base))-sizeof(struct ether_header); ! 936: outb(IE_RP(base), 0); ! 937: outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC); ! 938: is->badrcv++; ! 939: #ifdef DEBUG ! 940: printf("at3c501rcv: received %d bad bytes", len); ! 941: if (stat & EDLC_SHORT) ! 942: printf(" Short frame"); ! 943: if (stat & EDLC_OVER) ! 944: printf(" Data overflow"); ! 945: if (stat & EDLC_DRIBBLE) ! 946: printf(" Dribble error"); ! 947: if (stat & EDLC_FCS) ! 948: printf(" CRC error"); ! 949: printf("\n"); ! 950: #endif DEBUG ! 951: } else { ! 952: outw(IE_GP(base), 0); ! 953: len = inw(IE_RP(base)); ! 954: if (len < 60) { ! 955: outb(IE_RP(base), 0); ! 956: outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC); ! 957: return; ! 958: } ! 959: linb(IE_BFR(base), &eh, sizeof(struct ether_header)); ! 960: #ifdef MACH_KERNEL ! 961: new_kmsg = net_kmsg_get(); ! 962: if (new_kmsg == IKM_NULL) { ! 963: /* ! 964: * Drop the packet. ! 965: */ ! 966: is->ds_if.if_rcvdrops++; ! 967: ! 968: outb(IE_RP(base), 0); ! 969: outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC); ! 970: return; ! 971: } ! 972: ! 973: ehp = (struct ether_header *) ! 974: (&net_kmsg(new_kmsg)->header[0]); ! 975: pkt = (struct packet_header *) ! 976: (&net_kmsg(new_kmsg)->packet[0]); ! 977: ! 978: /* ! 979: * Get header. ! 980: */ ! 981: *ehp = eh; ! 982: ! 983: /* ! 984: * Get body ! 985: */ ! 986: linb(IE_BFR(base), ! 987: (char *)(pkt + 1), ! 988: len - sizeof(struct ether_header)); ! 989: ! 990: outb(IE_RP(base), 0); ! 991: outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC); ! 992: ! 993: pkt->type = ehp->ether_type; ! 994: pkt->length = len - sizeof(struct ether_header) ! 995: + sizeof(struct packet_header); ! 996: ! 997: /* ! 998: * Hand the packet to the network module. ! 999: */ ! 1000: net_packet(ifp, new_kmsg, pkt->length, ! 1001: ethernet_priority(new_kmsg)); ! 1002: ! 1003: #else MACH_KERNEL ! 1004: eh.ether_type = htons(eh.ether_type); ! 1005: m =(struct mbuf *)0; ! 1006: #ifdef DEBUG ! 1007: printf("received %d bytes\n", len); ! 1008: #endif DEBUG ! 1009: len -= sizeof(struct ether_header); ! 1010: while ( len ) { ! 1011: if (m == (struct mbuf *)0) { ! 1012: m = m_get(M_DONTWAIT, MT_DATA); ! 1013: if (m == (struct mbuf *)0) { ! 1014: printf("at3c501rcv: Lost frame\n"); ! 1015: outb(IE_RP(base), 0); ! 1016: outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC); ! 1017: ! 1018: return; ! 1019: } ! 1020: tm = m; ! 1021: tm->m_off = MMINOFF; ! 1022: /* ! 1023: * first mbuf in the packet must contain a pointer to the ! 1024: * ifnet structure. other mbufs that follow and make up ! 1025: * the packet do not need this pointer in the mbuf. ! 1026: * ! 1027: */ ! 1028: *(mtod(tm, struct ifnet **)) = ifp; ! 1029: tm->m_len = sizeof(struct ifnet **); ! 1030: } ! 1031: else { ! 1032: tm->m_next = m_get(M_DONTWAIT, MT_DATA); ! 1033: tm = tm->m_next; ! 1034: tm->m_off = MMINOFF; ! 1035: tm->m_len = 0; ! 1036: if (tm == (struct mbuf *)0) { ! 1037: m_freem(m); ! 1038: printf("at3c501rcv: No mbufs, lost frame\n"); ! 1039: outb(IE_RP(base), 0); ! 1040: outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC); ! 1041: return; ! 1042: } ! 1043: } ! 1044: tlen = MIN( MLEN - tm->m_len, len ); ! 1045: tm->m_next = (struct mbuf *)0; ! 1046: linb(IE_BFR(base), mtod(tm, char *)+tm->m_len, tlen ); ! 1047: tm->m_len += tlen; ! 1048: len -= tlen; ! 1049: } ! 1050: outb(IE_RP(base), 0); ! 1051: outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC); ! 1052: /* ! 1053: * received packet is now in a chain of mbuf's. next step is ! 1054: * to pass the packet upwards. ! 1055: * ! 1056: */ ! 1057: switch (eh.ether_type) { ! 1058: #ifdef INET ! 1059: case ETHERTYPE_IP: ! 1060: schednetisr(NETISR_IP); ! 1061: inq = &ipintrq; ! 1062: break; ! 1063: case ETHERTYPE_ARP: ! 1064: arpinput(&is->at3c501_ac, m); ! 1065: return; ! 1066: #endif ! 1067: #ifdef NS ! 1068: case ETHERTYPE_NS: ! 1069: schednetisr(NETISR_NS); ! 1070: inq = &nsintrq; ! 1071: break; ! 1072: #endif ! 1073: default: ! 1074: m_freem(m); ! 1075: return; ! 1076: } ! 1077: opri = SPLNET(); ! 1078: if (IF_QFULL(inq)) { ! 1079: IF_DROP(inq); ! 1080: splx(opri); ! 1081: m_freem(m); ! 1082: return; ! 1083: } ! 1084: IF_ENQUEUE(inq, m); ! 1085: splx(opri); ! 1086: #endif MACH_KERNEL ! 1087: } ! 1088: } ! 1089: } ! 1090: ! 1091: ! 1092: /* ! 1093: * at3c501xmt: ! 1094: * ! 1095: * This routine fills in the appropriate registers and memory ! 1096: * locations on the 3C501 board and starts the board off on ! 1097: * the transmit. ! 1098: * ! 1099: * input : board number of interest, and a pointer to the mbuf ! 1100: * output : board memory and registers are set for xfer and attention ! 1101: * ! 1102: */ ! 1103: at3c501xmt(unit, m) ! 1104: int unit; ! 1105: #ifdef MACH_KERNEL ! 1106: io_req_t m; ! 1107: #else MACH_KERNEL ! 1108: struct mbuf *m; ! 1109: #endif MACH_KERNEL ! 1110: { ! 1111: #ifdef MACH_KERNEL ! 1112: #else MACH_KERNEL ! 1113: register struct mbuf *tm_p; ! 1114: #endif MACH_KERNEL ! 1115: int i; ! 1116: at3c501_softc_t *is = &at3c501_softc[unit]; ! 1117: caddr_t base = is->base; ! 1118: u_short count = 0; ! 1119: u_short bytes_in_msg; ! 1120: ! 1121: is->xmt++; ! 1122: outb(IE_CSR(base), IE_SYSBFR); ! 1123: #ifdef MACH_KERNEL ! 1124: count = m->io_count; ! 1125: #define max(a,b) (((a) > (b)) ? (a) : (b)) ! 1126: bytes_in_msg = max(count, ! 1127: ETHERMIN + sizeof(struct ether_header)); ! 1128: #else MACH_KERNEL ! 1129: bytes_in_msg = max(m_length(m), ETHERMIN + sizeof(struct ether_header)); ! 1130: #endif MACH_KERNEL ! 1131: outw(IE_GP(base), BFRSIZ-bytes_in_msg); ! 1132: #ifdef MACH_KERNEL ! 1133: loutb(IE_BFR(base), m->io_data, count); ! 1134: #else MACH_KERNEL ! 1135: for (tm_p = m; tm_p != (struct mbuf *)0; tm_p = tm_p->m_next) { ! 1136: if (count + tm_p->m_len > ETHERMTU + sizeof(struct ether_header)) ! 1137: break; ! 1138: if (tm_p->m_len == 0) ! 1139: continue; ! 1140: loutb(IE_BFR(base), mtod(tm_p, caddr_t), tm_p->m_len); ! 1141: count += tm_p->m_len; ! 1142: } ! 1143: #endif MACH_KERNEL ! 1144: while (count < bytes_in_msg) { ! 1145: outb(IE_BFR(base), 0); ! 1146: count++; ! 1147: } ! 1148: do { ! 1149: if (!(int)m) { ! 1150: outb(IE_CSR(base), IE_SYSBFR); ! 1151: } ! 1152: outw(IE_GP(base), BFRSIZ-bytes_in_msg); ! 1153: outb(IE_CSR(base), IE_RIDE|IE_XMTEDLC); ! 1154: if (m) { ! 1155: #ifdef MACH_KERNEL ! 1156: iodone(m); ! 1157: m = 0; ! 1158: #else MACH_KERNEL ! 1159: m_freem(m); ! 1160: m = (struct mbuf *) 0; ! 1161: #endif MACH_KERNEL ! 1162: } ! 1163: for (i=0; inb(IE_CSR(base)) & IE_XMTBSY; i++); ! 1164: if ((i=inb(EDLC_XMT(base))) & EDLC_JAM) { ! 1165: is->badxmt++; ! 1166: #ifdef DEBUG ! 1167: printf("at3c501xmt jam\n"); ! 1168: #endif DEBUG ! 1169: } ! 1170: } while ((i & EDLC_JAM) && !(i & EDLC_16)); ! 1171: ! 1172: if (i & EDLC_16) { ! 1173: printf("%"); ! 1174: } ! 1175: return; ! 1176: ! 1177: } ! 1178: ! 1179: /* ! 1180: * at3c501config: ! 1181: * ! 1182: * This routine does a standard config of the at3c501 board. ! 1183: * ! 1184: */ ! 1185: at3c501config(unit) ! 1186: int unit; ! 1187: { ! 1188: caddr_t base = at3c501_softc[unit].base; ! 1189: u_char stat; ! 1190: ! 1191: /* Enable DMA & Interrupts */ ! 1192: ! 1193: outb(IE_CSR(base), IE_RIDE|IE_SYSBFR); ! 1194: ! 1195: /* No Transmit Interrupts */ ! 1196: ! 1197: outb(EDLC_XMT(base), 0); ! 1198: inb(EDLC_XMT(base)); ! 1199: ! 1200: /* Setup Receive Interrupts */ ! 1201: ! 1202: outb(EDLC_RCV(base), EDLC_BROAD|EDLC_SHORT|EDLC_GOOD|EDLC_DRIBBLE|EDLC_OVER); ! 1203: inb(EDLC_RCV(base)); ! 1204: ! 1205: outb(IE_CSR(base), IE_RIDE|IE_SYSBFR); ! 1206: outb(IE_RP(base), 0); ! 1207: outb(IE_CSR(base), IE_RIDE|IE_RCVEDLC); ! 1208: return(TRUE); ! 1209: } ! 1210: ! 1211: /* ! 1212: * at3c501intoff: ! 1213: * ! 1214: * This function turns interrupts off for the at3c501 board indicated. ! 1215: * ! 1216: */ ! 1217: at3c501intoff(unit) ! 1218: int unit; ! 1219: { ! 1220: caddr_t base = at3c501_softc[unit].base; ! 1221: outb(IE_CSR(base), 0); ! 1222: } ! 1223: ! 1224: #ifdef MACH_KERNEL ! 1225: #else MACH_KERNEL ! 1226: /* ! 1227: * The length of an mbuf chain ! 1228: */ ! 1229: m_length(m) ! 1230: register struct mbuf *m; ! 1231: { ! 1232: register int len = 0; ! 1233: ! 1234: while (m) { ! 1235: len += m->m_len; ! 1236: m = m->m_next; ! 1237: } ! 1238: return len; ! 1239: } ! 1240: #endif MACH_KERNEL
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.