![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_de6c.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_de6c.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at |
1.1 ! root 1: #define DEBUG 1 ! 2: /* ! 3: * Mach Operating System ! 4: * Copyright (c) 1994,1993,1992 Carnegie Mellon University ! 5: * All Rights Reserved. ! 6: * ! 7: * Permission to use, copy, modify and distribute this software and its ! 8: * documentation is hereby granted, provided that both the copyright ! 9: * notice and this permission notice appear in all copies of the ! 10: * software, derivative works or modified versions, and any portions ! 11: * thereof, and that both notices appear in supporting documentation. ! 12: * ! 13: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" ! 14: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR ! 15: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. ! 16: * ! 17: * Carnegie Mellon requests users of this software to return to ! 18: * ! 19: * Software Distribution Coordinator or [email protected] ! 20: * School of Computer Science ! 21: * Carnegie Mellon University ! 22: * Pittsburgh PA 15213-3890 ! 23: * ! 24: * any improvements or extensions that they make and grant Carnegie Mellon ! 25: * the rights to redistribute these changes. ! 26: */ ! 27: ! 28: /* ! 29: * HISTORY ! 30: * 17-Feb-94 David Golub (dbg) at Carnegie-Mellon University ! 31: * Fix from Bob Baron to fix transmitter problems. ! 32: * ! 33: * $Log: if_de6c.c,v $ ! 34: * Revision 1.1.1.1 1997/02/25 21:27:16 thomas ! 35: * Initial source ! 36: * ! 37: * Revision 1.1.1.1 1996/10/30 01:39:26 thomas ! 38: * Imported from UK22 ! 39: * ! 40: * Revision 1.1 1994/11/08 20:47:24 baford ! 41: * merged in CMU's MK83-MK83a diffs ! 42: * ! 43: * Revision 2.2 93/11/17 18:29:25 dbg ! 44: * Moved source into kernel/i386at/DLINK/if_de6c.c, since we ! 45: * can't release it but don't want to lose it. ! 46: * [93/11/17 dbg] ! 47: * ! 48: * Removed u_long. ! 49: * [93/03/25 dbg] ! 50: * ! 51: * Created. ! 52: * I have used if_3c501.c as a typical driver template and ! 53: * spliced in the appropriate particulars for the ! 54: * d-link 600. ! 55: * [92/08/13 rvb] ! 56: * ! 57: * ! 58: * File: if_de6c.c ! 59: * Author: Robert V. Baron ! 60: */ ! 61: ! 62: /* ! 63: * File: if_3c501.c ! 64: * Author: Philippe Bernadat ! 65: * Date: 1989 ! 66: * Copyright (c) 1989 OSF Research Institute ! 67: * ! 68: * 3COM Etherlink d-link "600" Mach Ethernet drvier ! 69: */ ! 70: /* ! 71: Copyright 1990 by Open Software Foundation, ! 72: Cambridge, MA. ! 73: ! 74: All Rights Reserved ! 75: ! 76: Permission to use, copy, modify, and distribute this software and ! 77: its documentation for any purpose and without fee is hereby granted, ! 78: provided that the above copyright notice appears in all copies and ! 79: that both the copyright notice and this permission notice appear in ! 80: supporting documentation, and that the name of OSF or Open Software ! 81: Foundation not be used in advertising or publicity pertaining to ! 82: distribution of the software without specific, written prior ! 83: permission. ! 84: ! 85: OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE ! 86: INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, ! 87: IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR ! 88: CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM ! 89: LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT, ! 90: NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION ! 91: WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ! 92: */ ! 93: ! 94: /* ! 95: * I have tried to make it clear what is device specific code ! 96: * and what code supports the general BSD ethernet interface. d-link ! 97: * specific code is preceded by a line or two of ! 98: * "d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON" ! 99: * and followed by a line or two of ! 100: * "d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF" ! 101: * ! 102: * The main routines that do device specific processing are: ! 103: * de6cintr - interrupt dispatcher ! 104: * de6crcv - rcv packets and switch to new buffers ! 105: * de6cxmt - xmt packet and wait for xmtbusy to clear ! 106: * de6calive - probe for device ! 107: * de6cinit - device initialization ! 108: * de6cintoff - turn it off. ! 109: * There are a couple of interesting macros at the head of this ! 110: * file and some support subroutines at the end. ! 111: * ! 112: * Lastly, to get decent performance on i386SX class machines, it ! 113: * was necessary to recode the read and write d-link memory routines in ! 114: * assembler. The deread and dewrite routines that are used are in ! 115: * if_de6s.s ! 116: * ! 117: */ ! 118: ! 119: /* Questions: ! 120: ! 121: Make sure that iopl maps 378, 278 and 3bc. ! 122: ! 123: If you set command w/o MODE and page bit, what happens? ! 124: ! 125: Could I get xmt interrupts; currently I spin - this is not an issue? ! 126: ! 127: enable promiscuous? ! 128: ! 129: Can you assert TXEN and RXen simulatneously? ! 130: */ ! 131: ! 132: #include <de6c.h> ! 133: #include <par.h> ! 134: ! 135: #ifdef MACH_KERNEL ! 136: #include <kern/time_out.h> ! 137: #include <device/device_types.h> ! 138: #include <device/errno.h> ! 139: #include <device/io_req.h> ! 140: #include <device/if_hdr.h> ! 141: #include <device/if_ether.h> ! 142: #include <device/net_status.h> ! 143: #include <device/net_io.h> ! 144: #include <chips/busses.h> ! 145: #else MACH_KERNEL ! 146: #include <sys/param.h> ! 147: #include <mach/machine/vm_param.h> ! 148: #include <sys/systm.h> ! 149: #include <sys/mbuf.h> ! 150: #include <sys/buf.h> ! 151: #include <sys/protosw.h> ! 152: #include <sys/socket.h> ! 153: #include <sys/vmmac.h> ! 154: #include <sys/ioctl.h> ! 155: #include <sys/errno.h> ! 156: #include <sys/syslog.h> ! 157: ! 158: #include <net/if.h> ! 159: #include <net/netisr.h> ! 160: #include <net/route.h> ! 161: #include <i386at/atbus.h> ! 162: ! 163: #ifdef INET ! 164: #include <netinet/in.h> ! 165: #include <netinet/in_systm.h> ! 166: #include <netinet/in_var.h> ! 167: #include <netinet/ip.h> ! 168: #include <netinet/if_ether.h> ! 169: #endif ! 170: ! 171: #ifdef NS ! 172: #include <netns/ns.h> ! 173: #include <netns/ns_if.h> ! 174: #endif ! 175: #endif MACH_KERNEL ! 176: ! 177: #include <vm/vm_kern.h> ! 178: #include <i386/ipl.h> ! 179: #include <i386/pio.h> ! 180: #include <i386at/if_de6c.h> ! 181: ! 182: #define SPLNET spl6 ! 183: ! 184: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 185: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 186: #define de6cwrite(sp, addr, buf, len) \ ! 187: de6cwriteasm(addr, buf, len, DATA(sp->port), sp->latency) ! 188: ! 189: #define de6cread(sp, addr, buf, len) \ ! 190: de6creadasm(addr, buf, len, DATA(sp->port), sp->latency) ! 191: ! 192: #define DATA_OUT(sp, p, f, z) \ ! 193: de6coutb(sp, DATA(p), ((z)<<4) | f);\ ! 194: de6coutb(sp, DATA(p), ((z)&0xf0)| f | STROBE) ! 195: ! 196: #define STAT_IN(sp, p, in) \ ! 197: de6coutb(sp, DATA(p), STATUS); \ ! 198: in = inb(STAT(port)); \ ! 199: de6coutb(sp, DATA(p), NUL_CMD | STROBE) ! 200: ! 201: #define XMTidx 3 ! 202: #define XMT_BSY_WAIT 10000 ! 203: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 204: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 205: ! 206: int de6cprobe(); ! 207: void de6cattach(); ! 208: int de6cintr(); ! 209: int de6cinit(); ! 210: int de6coutput(); ! 211: int de6cioctl(); ! 212: int de6creset(); ! 213: void de6cwatch(); ! 214: ! 215: static vm_offset_t de6c_std[NDE6C] = { 0 }; ! 216: static struct bus_device *de6c_info[NDE6C]; ! 217: ! 218: #ifdef MACH_KERNEL ! 219: struct bus_driver de6cdriver = ! 220: {de6cprobe, 0, de6cattach, 0, de6c_std, "de", de6c_info, }; ! 221: extern struct bus_device *lprinfo[]; ! 222: ! 223: #define MM io_req_t ! 224: #define PIC sysdep1 ! 225: #define DEV bus_device ! 226: #else MACH_KERNEL ! 227: int (*de6cintrs[])() = { de6cintr, 0}; ! 228: struct isa_driver de6cdriver = ! 229: {de6cprobe, 0, de6cattach, "de", 0, 0, 0}; ! 230: extern struct isa_dev *lprinfo[]; ! 231: ! 232: #define MM struct mbuf * ! 233: #define PIC dev_pic ! 234: #define DEV isa_dev ! 235: #endif MACH_KERNEL ! 236: ! 237: int watchdog_id; ! 238: ! 239: typedef struct { ! 240: #ifdef MACH_KERNEL ! 241: struct ifnet ds_if; /* generic interface header */ ! 242: u_char ds_addr[6]; /* Ethernet hardware address */ ! 243: #else MACH_KERNEL ! 244: struct arpcom de6c_ac; ! 245: #define ds_if de6c_ac.ac_if ! 246: #define ds_addr de6c_ac.ac_enaddr ! 247: #endif MACH_KERNEL ! 248: int flags; ! 249: int timer; ! 250: u_char address[6]; ! 251: short mode; ! 252: int port; ! 253: int latency; ! 254: int xmt; ! 255: int rcv; ! 256: int rcvoff; ! 257: int rcvspin; ! 258: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 259: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 260: int produce; ! 261: int consume; ! 262: int rcvlen[XMTidx]; ! 263: int alive; ! 264: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 265: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 266: int (*oldvect)(); ! 267: int oldunit; ! 268: } de6c_softc_t; ! 269: ! 270: de6c_softc_t de6c_softc[NDE6C]; ! 271: ! 272: int de6cactive[NDE6C]; ! 273: ! 274: /* ! 275: * Patch to change latency value ! 276: */ ! 277: int de6c_latency = 30; /* works on NEC Versa (pottsylvania.mach) */ ! 278: ! 279: #ifdef DEBUG ! 280: int de6crcv0, de6crcv1, de6crcv2, de6crcv3; ! 281: int de6cdo_rcvintr = 0, de6cdo_watch = 0; ! 282: int de6cdo_xmt = 0; ! 283: #define D(X) X ! 284: #else /* DEBUG */ ! 285: #define D(X) ! 286: #endif /* DEBUG */ ! 287: ! 288: /* ! 289: * de6cprobe: ! 290: * We are not directly probed. The lprattach will call de6cattach. ! 291: * But what we have is plausible for a probe. ! 292: */ ! 293: de6cprobe(port, dev) ! 294: struct DEV *dev; ! 295: { ! 296: #ifdef MACH_KERNEL ! 297: int unit = dev->unit; ! 298: #else MACH_KERNEL ! 299: int unit = dev->dev_unit; ! 300: #endif MACH_KERNEL ! 301: ! 302: if ((unit < 0) || (unit >= NDE6C)) { ! 303: return(0); ! 304: } ! 305: return(1); ! 306: } ! 307: ! 308: /* ! 309: * de6cattach: ! 310: * ! 311: * Called from lprattach ! 312: * ! 313: */ ! 314: void de6cattach(dev) ! 315: #ifdef MACH_KERNEL ! 316: struct bus_device *dev; ! 317: #else MACH_KERNEL ! 318: struct isa_dev *dev; ! 319: #endif MACH_KERNEL ! 320: { ! 321: de6c_softc_t *sp; ! 322: struct ifnet *ifp; ! 323: #ifdef MACH_KERNEL ! 324: int unit = dev->unit; ! 325: int port = (int)dev->address; ! 326: #else MACH_KERNEL ! 327: int unit = dev->dev_unit; ! 328: int port = (int)dev->dev_addr; ! 329: #endif MACH_KERNEL ! 330: ! 331: sp = &de6c_softc[unit]; ! 332: sp->port = port; ! 333: sp->timer = -1; ! 334: sp->flags = 0; ! 335: sp->mode = 0; ! 336: ! 337: ifp = &(sp->ds_if); ! 338: ifp->if_unit = unit; ! 339: ifp->if_mtu = ETHERMTU; ! 340: ifp->if_flags = IFF_BROADCAST; ! 341: ! 342: #ifdef MACH_KERNEL ! 343: ifp->if_header_size = sizeof(struct ether_header); ! 344: ifp->if_header_format = HDR_ETHERNET; ! 345: ifp->if_address_size = 6; ! 346: ifp->if_address = (char *)&sp->address[0]; ! 347: if_init_queues(ifp); ! 348: #else MACH_KERNEL ! 349: ifp->if_name = "de"; ! 350: ifp->if_init = de6cinit; ! 351: ifp->if_output = de6coutput; ! 352: ifp->if_ioctl = de6cioctl; ! 353: ifp->if_reset = de6creset; ! 354: ifp->if_next = NULL; ! 355: if_attach(ifp); ! 356: #endif MACH_KERNEL ! 357: ! 358: sp->alive = de6calive(sp); ! 359: } ! 360: ! 361: de6calive(sp) ! 362: de6c_softc_t *sp; ! 363: { ! 364: int port = sp->port; ! 365: int unit = sp->ds_if.if_unit; ! 366: struct DEV *dev = lprinfo[unit]; ! 367: int i; ! 368: ! 369: #ifdef MACH_KERNEL ! 370: #else /* MACH_KERNEL */ ! 371: extern int tcp_recvspace; /* empircal messure */ ! 372: #endif /* MACH_KERNEL */ ! 373: ! 374: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 375: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 376: de6coutb(sp, CMD(port), SLT_NIC); ! 377: DATA_OUT(sp, port, COMMAND, RESET); ! 378: DATA_OUT(sp, port, COMMAND, STOP_RESET); ! 379: sp->latency = 101; ! 380: if (!de6cgetid(sp, sp->ds_addr)) { ! 381: de6coutb(sp, CMD(port), SLT_PRN); ! 382: return 0; ! 383: } ! 384: ! 385: #ifdef MACH_KERNEL ! 386: #else /* MACH_KERNEL */ ! 387: tcp_recvspace = 0x300; /* empircal messure */ ! 388: #endif /* MACH_KERNEL */ ! 389: ! 390: #ifdef de6cwrite ! 391: sp->latency = de6c_latency; ! 392: #else /* de6cwrite */ ! 393: sp->latency = 0; ! 394: #endif /* de6cwrite */ ! 395: ! 396: for (i = 0; i++ < 10;) { ! 397: if (de6cmemcheck(sp)) ! 398: break; ! 399: sp->latency += 10; ! 400: } ! 401: ! 402: de6cgetid(sp, sp->ds_addr); ! 403: de6cgetid(sp, sp->address); ! 404: de6csetid(sp, sp->address); ! 405: de6coutb(sp, CMD(port), SLT_PRN); ! 406: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 407: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 408: ! 409: #ifdef MACH_KERNEL ! 410: #if NPAR > 0 ! 411: printf("\n"); ! 412: #endif /* NPAR > 0 */ ! 413: printf(" de%d: at lpr%d, port = %x, spl = %d, pic = %d. ", ! 414: unit, unit, dev->address, dev->sysdep, dev->sysdep1); ! 415: ! 416: printf("ethernet id [%x:%x:%x:%x:%x:%x]", ! 417: sp->address[0],sp->address[1],sp->address[2], ! 418: sp->address[3],sp->address[4],sp->address[5]); ! 419: ! 420: if (sp->latency > 1) { ! 421: printf("\n"); ! 422: printf(" LATENCY = %d", sp->latency); ! 423: printf(" LATENCY = %d", sp->latency); ! 424: printf(" LATENCY = %d", sp->latency); ! 425: printf(" LATENCY = %d", sp->latency); ! 426: } ! 427: #else MACH_KERNEL ! 428: printf("de%d: port = %x, spl = %d, pic = %d. ", ! 429: unit, dev->dev_addr, dev->dev_spl, dev->dev_pic); ! 430: ! 431: printf("ethernet id [%x:%x:%x:%x:%x:%x]\n", ! 432: sp->address[0],sp->address[1],sp->address[2], ! 433: sp->address[3],sp->address[4],sp->address[5]); ! 434: ! 435: if (sp->latency > 1) { ! 436: printf("de%d:", unit); ! 437: printf(" LATENCY = %d", sp->latency); ! 438: printf(" LATENCY = %d", sp->latency); ! 439: printf(" LATENCY = %d", sp->latency); ! 440: printf(" LATENCY = %d", sp->latency); ! 441: printf("\n"); ! 442: } ! 443: #endif MACH_KERNEL ! 444: ! 445: return 1; ! 446: } ! 447: ! 448: /* ! 449: * de6cwatch(): ! 450: * ! 451: */ ! 452: void de6cwatch(b_ptr) ! 453: short *b_ptr; ! 454: { ! 455: #ifdef DEBUG_MORE ! 456: int unit = *b_ptr; ! 457: de6c_softc_t *sp = &de6c_softc[unit]; ! 458: ! 459: if(!de6cdo_watch) return; ! 460: de6cintr(unit); ! 461: if (sp->ds_if.if_flags & IFF_RUNNING) ! 462: timeout(de6cwatch, b_ptr, de6cdo_watch); ! 463: #endif /* DEBUG_MORE */ ! 464: } ! 465: ! 466: #ifdef MACH_KERNEL ! 467: void de6cstart(int); /* forward */ ! 468: ! 469: de6coutput(dev, ior) ! 470: dev_t dev; ! 471: io_req_t ior; ! 472: { ! 473: register int unit = minor(dev); ! 474: ! 475: if (unit < 0 || unit >= NDE6C || ! 476: de6c_softc[unit].port == 0) ! 477: return (ENXIO); ! 478: ! 479: return (net_write(&de6c_softc[unit].ds_if, de6cstart, ior)); ! 480: } ! 481: ! 482: io_return_t ! 483: de6csetinput( ! 484: dev_t dev, ! 485: mach_port_t receive_port, ! 486: int priority, ! 487: filter_t filter[], ! 488: natural_t filter_count) ! 489: { ! 490: register int unit = minor(dev); ! 491: ! 492: if (unit < 0 || unit >= NDE6C || ! 493: de6c_softc[unit].port == 0) ! 494: return ENXIO; ! 495: ! 496: return net_set_filter(&de6c_softc[unit].ds_if, ! 497: receive_port, priority, ! 498: filter, filter_count); ! 499: } ! 500: ! 501: #else MACH_KERNEL ! 502: /* ! 503: * de6coutput: ! 504: * ! 505: * This routine is called by the "if" layer to output a packet to ! 506: * the network. This code resolves the local ethernet address, and ! 507: * puts it into the mbuf if there is room. If not, then a new mbuf ! 508: * is allocated with the header information and precedes the data ! 509: * to be transmitted. ! 510: * ! 511: * input: ifnet structure pointer, an mbuf with data, and address ! 512: * to be resolved ! 513: * output: mbuf is updated to hold enet address, or a new mbuf ! 514: * with the address is added ! 515: * ! 516: */ ! 517: de6coutput(ifp, m0, dst) ! 518: struct ifnet *ifp; ! 519: struct mbuf *m0; ! 520: struct sockaddr *dst; ! 521: { ! 522: register de6c_softc_t *sp = &de6c_softc[ifp->if_unit]; ! 523: int type, opri, error; ! 524: u_char edst[6]; ! 525: struct in_addr idst; ! 526: register struct mbuf *m = m0; ! 527: register struct ether_header *eh; ! 528: register int off; ! 529: int usetrailers; ! 530: ! 531: if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING)) { ! 532: de6cintoff(ifp->if_unit); ! 533: error = ENETDOWN; ! 534: goto bad; ! 535: } ! 536: switch (dst->sa_family) { ! 537: ! 538: #ifdef INET ! 539: case AF_INET: ! 540: idst = ((struct sockaddr_in *)dst)->sin_addr; ! 541: if (!arpresolve(&sp->de6c_ac, m, &idst, edst, &usetrailers)){ ! 542: return (0); /* if not yet resolved */ ! 543: } ! 544: off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len; ! 545: ! 546: if (usetrailers && off > 0 && (off & 0x1ff) == 0 && ! 547: m->m_off >= MMINOFF + 2 * sizeof (u_short)) { ! 548: type = ETHERTYPE_TRAIL + (off>>9); ! 549: m->m_off -= 2 * sizeof (u_short); ! 550: m->m_len += 2 * sizeof (u_short); ! 551: *mtod(m, u_short *) = htons((u_short)ETHERTYPE_IP); ! 552: *(mtod(m, u_short *) + 1) = htons((u_short)m->m_len); ! 553: goto gottrailertype; ! 554: } ! 555: type = ETHERTYPE_IP; ! 556: off = 0; ! 557: goto gottype; ! 558: #endif ! 559: #ifdef NS ! 560: case AF_NS: ! 561: type = ETHERTYPE_NS; ! 562: bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host), ! 563: (caddr_t)edst, sizeof (edst)); ! 564: off = 0; ! 565: goto gottype; ! 566: #endif ! 567: ! 568: case AF_UNSPEC: ! 569: eh = (struct ether_header *)dst->sa_data; ! 570: bcopy((caddr_t)eh->ether_dhost, (caddr_t)edst, sizeof (edst)); ! 571: type = eh->ether_type; ! 572: goto gottype; ! 573: ! 574: default: ! 575: printf("de6c%d: can't handle af%d\n", ifp->if_unit, ! 576: dst->sa_family); ! 577: error = EAFNOSUPPORT; ! 578: goto bad; ! 579: } ! 580: ! 581: gottrailertype: ! 582: /* ! 583: * Packet to be sent as trailer: move first packet ! 584: * (control information) to end of chain. ! 585: */ ! 586: while (m->m_next) ! 587: m = m->m_next; ! 588: m->m_next = m0; ! 589: m = m0->m_next; ! 590: m0->m_next = 0; ! 591: m0 = m; ! 592: ! 593: gottype: ! 594: /* ! 595: * Add local net header. If no space in first mbuf, ! 596: * allocate another. ! 597: */ ! 598: if (m->m_off > MMAXOFF || ! 599: MMINOFF + sizeof (struct ether_header) > m->m_off) { ! 600: m = m_get(M_DONTWAIT, MT_HEADER); ! 601: if (m == 0) { ! 602: error = ENOBUFS; ! 603: goto bad; ! 604: } ! 605: m->m_next = m0; ! 606: m->m_off = MMINOFF; ! 607: m->m_len = sizeof (struct ether_header); ! 608: } else { ! 609: m->m_off -= sizeof (struct ether_header); ! 610: m->m_len += sizeof (struct ether_header); ! 611: } ! 612: eh = mtod(m, struct ether_header *); ! 613: eh->ether_type = htons((u_short)type); ! 614: bcopy((caddr_t)edst, (caddr_t)eh->ether_dhost, sizeof (edst)); ! 615: bcopy((caddr_t)sp->address,(caddr_t)eh->ether_shost, sizeof(edst)); ! 616: /* ! 617: * Queue message on interface, and start output if interface ! 618: * not yet active. ! 619: */ ! 620: opri = SPLNET(); ! 621: if (IF_QFULL(&ifp->if_snd)) { ! 622: IF_DROP(&ifp->if_snd); ! 623: splx(opri); ! 624: m_freem(m); ! 625: return (ENOBUFS); ! 626: } ! 627: IF_ENQUEUE(&ifp->if_snd, m); ! 628: de6cstart(ifp->if_unit); ! 629: splx(opri); ! 630: return (0); ! 631: ! 632: bad: ! 633: m_freem(m0); ! 634: return (error); ! 635: } ! 636: #endif MACH_KERNEL ! 637: ! 638: /* ! 639: * de6creset: ! 640: * ! 641: * This routine is in part an entry point for the "if" code. Since most ! 642: * of the actual initialization has already (we hope already) been done ! 643: * by calling de6cattach(). ! 644: * ! 645: * input : unit number or board number to reset ! 646: * output : board is reset ! 647: * ! 648: */ ! 649: de6creset(unit) ! 650: int unit; ! 651: { ! 652: de6c_softc[unit].ds_if.if_flags &= ~IFF_RUNNING; ! 653: return(de6cinit(unit)); ! 654: } ! 655: ! 656: ! 657: ! 658: /* ! 659: * de6cinit: ! 660: * ! 661: * Another routine that interfaces the "if" layer to this driver. ! 662: * Simply resets the structures that are used by "upper layers". ! 663: * ! 664: * input : board number ! 665: * output : structures (if structs) and board are reset ! 666: * ! 667: */ ! 668: de6cinit(unit) ! 669: int unit; ! 670: { ! 671: de6c_softc_t *sp = &de6c_softc[unit]; ! 672: struct ifnet *ifp = &(sp->ds_if); ! 673: int port = sp->port; ! 674: int pic = lprinfo[unit]->PIC; ! 675: spl_t oldpri; ! 676: ! 677: #ifdef MACH_KERNEL ! 678: #else MACH_KERNEL ! 679: if (ifp->if_addrlist == (struct ifaddr *)0) { ! 680: return; ! 681: } ! 682: #endif MACH_KERNEL ! 683: oldpri = SPLNET(); ! 684: ! 685: if (ivect[pic] != de6cintr) { ! 686: sp->oldvect = ivect[pic]; ! 687: ivect[pic] = de6cintr; ! 688: sp->oldunit = iunit[pic]; ! 689: iunit[pic] = unit; ! 690: } ! 691: ! 692: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 693: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 694: sp->consume = 0; ! 695: sp->produce = 0; ! 696: de6coutb(sp, CMD(port), SLT_NIC); ! 697: DATA_OUT(sp, port, COMMAND, RESET); ! 698: DATA_OUT(sp, port, COMMAND, STOP_RESET); ! 699: de6coutb(sp, CMD(port), IRQEN); ! 700: DATA_OUT(sp, port, COMMAND, RX_BP|(sp->produce<<4)); ! 701: DATA_OUT(sp, port, COMMAND, RX_BP|(sp->produce<<4)|RXEN); ! 702: de6coutb(sp, CMD(port), SLT_PRN); ! 703: #if 0 ! 704: if (sp->mode & IFF_PROMISC) { ! 705: /* handle promiscuous case */; ! 706: } ! 707: #endif 0 ! 708: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 709: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 710: sp->ds_if.if_flags |= IFF_RUNNING; ! 711: sp->flags |= DSF_RUNNING; ! 712: sp->timer = 5; ! 713: timeout(de6cwatch, &(ifp->if_unit), 3); ! 714: de6cstart(unit); ! 715: splx(oldpri); ! 716: } ! 717: ! 718: #ifdef MACH_KERNEL ! 719: /*ARGSUSED*/ ! 720: de6copen(dev, flag) ! 721: dev_t dev; ! 722: int flag; ! 723: { ! 724: register int unit = minor(dev); ! 725: ! 726: if (unit < 0 || unit >= NDE6C || ! 727: de6c_softc[unit].port == 0) ! 728: return (ENXIO); ! 729: ! 730: de6c_softc[unit].ds_if.if_flags |= IFF_UP; ! 731: de6cinit(unit); ! 732: return(0); ! 733: } ! 734: #endif MACH_KERNEL ! 735: ! 736: /* ! 737: * de6cstart: ! 738: * ! 739: * This is yet another interface routine that simply tries to output a ! 740: * in an mbuf after a reset. ! 741: * ! 742: * input : board number ! 743: * output : stuff sent to board if any there ! 744: * ! 745: */ ! 746: ! 747: /* NOTE: called at SPLNET */ ! 748: void de6cstart( ! 749: int unit) ! 750: { ! 751: struct ifnet *ifp = &(de6c_softc[unit].ds_if); ! 752: MM m; ! 753: ! 754: for(;;) { ! 755: IF_DEQUEUE(&ifp->if_snd, m); ! 756: if (m != (MM) 0) ! 757: de6cxmt(unit, m); ! 758: else ! 759: return; ! 760: } ! 761: } ! 762: ! 763: #ifdef MACH_KERNEL ! 764: /*ARGSUSED*/ ! 765: io_return_t ! 766: de6cgetstat( ! 767: dev_t dev, ! 768: int flavor, ! 769: dev_status_t status, /* pointer to OUT array */ ! 770: natural_t *count) /* out */ ! 771: { ! 772: register int unit = minor(dev); ! 773: register de6c_softc_t *sp; ! 774: ! 775: if (unit < 0 || unit >= NDE6C || ! 776: de6c_softc[unit].port == 0) ! 777: return (ENXIO); ! 778: ! 779: sp = &de6c_softc[unit]; ! 780: if (! sp->alive) ! 781: if (! (sp->alive = de6calive(sp))) ! 782: return ENXIO; ! 783: ! 784: return (net_getstat(&de6c_softc[unit].ds_if, ! 785: flavor, ! 786: status, ! 787: count)); ! 788: } ! 789: ! 790: io_return_t ! 791: de6csetstat( ! 792: dev_t dev, ! 793: int flavor, ! 794: dev_status_t status, ! 795: natural_t count) ! 796: { ! 797: register int unit = minor(dev); ! 798: register de6c_softc_t *sp; ! 799: ! 800: if (unit < 0 || unit >= NDE6C || ! 801: de6c_softc[unit].port == 0) ! 802: return (ENXIO); ! 803: ! 804: sp = &de6c_softc[unit]; ! 805: if (! sp->alive) ! 806: if (! (sp->alive = de6calive(sp))) ! 807: return ENXIO; ! 808: ! 809: ! 810: switch (flavor) { ! 811: case NET_STATUS: ! 812: { ! 813: /* ! 814: * All we can change are flags, and not many of those. ! 815: */ ! 816: register struct net_status *ns = (struct net_status *)status; ! 817: int mode = 0; ! 818: ! 819: if (count < NET_STATUS_COUNT) ! 820: return (D_INVALID_SIZE); ! 821: ! 822: if (ns->flags & IFF_ALLMULTI) ! 823: mode |= MOD_ENAL; ! 824: if (ns->flags & IFF_PROMISC) ! 825: mode |= MOD_PROM; ! 826: ! 827: /* ! 828: * Force a compilete reset if the receive mode changes ! 829: * so that these take effect immediately. ! 830: */ ! 831: if (sp->mode != mode) { ! 832: sp->mode = mode; ! 833: if (sp->flags & DSF_RUNNING) { ! 834: sp->flags &= ~(DSF_LOCK | DSF_RUNNING); ! 835: de6cinit(unit); ! 836: } ! 837: } ! 838: break; ! 839: } ! 840: case NET_ADDRESS: ! 841: { ! 842: register union ether_cvt { ! 843: char addr[6]; ! 844: int lwd[2]; ! 845: } *ec = (union ether_cvt *)status; ! 846: ! 847: if (count < sizeof(*ec)/sizeof(int)) ! 848: return (D_INVALID_SIZE); ! 849: ! 850: ec->lwd[0] = ntohl(ec->lwd[0]); ! 851: ec->lwd[1] = ntohl(ec->lwd[1]); ! 852: de6csetid(sp->port, ec->addr); ! 853: break; ! 854: } ! 855: ! 856: default: ! 857: return (D_INVALID_OPERATION); ! 858: } ! 859: return (D_SUCCESS); ! 860: } ! 861: #else MACH_KERNEL ! 862: ! 863: /* ! 864: * de6cioctl: ! 865: * ! 866: * This routine processes an ioctl request from the "if" layer ! 867: * above. ! 868: * ! 869: * input : pointer the appropriate "if" struct, command, and data ! 870: * output : based on command appropriate action is taken on the ! 871: * de6c board(s) or related structures ! 872: * return : error is returned containing exit conditions ! 873: * ! 874: */ ! 875: de6cioctl(ifp, cmd, data) ! 876: struct ifnet *ifp; ! 877: int cmd; ! 878: caddr_t data; ! 879: { ! 880: register struct ifaddr *ifa = (struct ifaddr *)data; ! 881: register de6c_softc_t *sp = &de6c_softc[ifp->if_unit]; ! 882: int opri, error; ! 883: short mode = 0; ! 884: ! 885: if (! sp->alive) ! 886: if (! (sp->alive = de6calive(sp))) ! 887: return ENXIO; ! 888: ! 889: opri = SPLNET(); ! 890: error = 0; ! 891: switch (cmd) { ! 892: case SIOCSIFADDR: ! 893: ifp->if_flags |= IFF_UP; ! 894: de6cinit(ifp->if_unit); ! 895: switch (ifa->ifa_addr.sa_family) { ! 896: #ifdef INET ! 897: case AF_INET: ! 898: ((struct arpcom *)ifp)->ac_ipaddr = ! 899: IA_SIN(ifa)->sin_addr; ! 900: arpwhohas((struct arpcom *)ifp, ! 901: &IA_SIN(ifa)->sin_addr); ! 902: break; ! 903: #endif ! 904: #ifdef NS ! 905: case AF_NS: ! 906: { ! 907: register struct ns_addr *ina = ! 908: &(IA_SNS(ifa)->sns_addr); ! 909: if (ns_nullhost(*ina)) ! 910: ina->x_host = ! 911: *(union ns_host *)(ds->ds_addr); ! 912: else ! 913: de6cseteh(ina->x_host.c_host, ! 914: de6c_softc[ifp->if_unit].port); ! 915: break; ! 916: } ! 917: #endif ! 918: } ! 919: break; ! 920: case SIOCSIFFLAGS: ! 921: if (ifp->if_flags & IFF_ALLMULTI) ! 922: mode |= MOD_ENAL; ! 923: if (ifp->if_flags & IFF_PROMISC) ! 924: mode |= MOD_PROM; ! 925: /* ! 926: * force a complete reset if the receive multicast/ ! 927: * promiscuous mode changes so that these take ! 928: * effect immediately. ! 929: * ! 930: */ ! 931: if (sp->mode != mode) { ! 932: sp->mode = mode; ! 933: if (sp->flags & DSF_RUNNING) { ! 934: sp->flags &= ! 935: ~(DSF_LOCK|DSF_RUNNING); ! 936: de6cinit(ifp->if_unit); ! 937: } ! 938: } ! 939: if ((ifp->if_flags & IFF_UP) == 0 && ! 940: sp->flags & DSF_RUNNING) { ! 941: sp->timer = -1; ! 942: de6cintoff(ifp->if_unit); ! 943: } else ! 944: if (ifp->if_flags & IFF_UP && ! 945: (sp->flags & DSF_RUNNING) == 0) ! 946: de6cinit(ifp->if_unit); ! 947: break; ! 948: default: ! 949: error = EINVAL; ! 950: } ! 951: splx(opri); ! 952: return (error); ! 953: } ! 954: #endif MACH_KERNEL ! 955: ! 956: /* ! 957: * de6cintr: ! 958: * ! 959: * This function is the interrupt handler for the de6c ethernet ! 960: * board. This routine will be called whenever either a packet ! 961: * is received, or a packet has successfully been transfered and ! 962: * the unit is ready to transmit another packet. ! 963: * ! 964: * input : board number that interrupted ! 965: * output : either a packet is received, or a packet is transfered ! 966: * ! 967: */ ! 968: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 969: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 970: #ifdef DEBUG_MORE ! 971: de6crcvintr(unit) ! 972: int unit; ! 973: { ! 974: if(!de6cdo_rcvintr) ! 975: return; ! 976: de6cintr(unit); ! 977: } ! 978: #endif /* DEBUG_MORE */ ! 979: ! 980: de6cintr(unit) ! 981: int unit; ! 982: { ! 983: register de6c_softc_t *sp = &de6c_softc[unit]; ! 984: int port = sp->port; ! 985: int in; ! 986: ! 987: if (de6cactive[unit] || !(sp->flags & DSF_RUNNING)) ! 988: return; ! 989: de6cactive[unit]++; ! 990: de6coutb(sp, CMD(port), SLT_NIC); ! 991: STAT_IN(sp, port, in); ! 992: ! 993: if ((in & (GOOD|TXBUSY)) == (GOOD|TXBUSY)) { ! 994: /* on L40's means that we are disconnected */ ! 995: printf("de6intr%d: Card was disconnected; turning off network.\n", unit); ! 996: de6cintoff(unit); ! 997: de6cactive[unit]--; ! 998: return; ! 999: } ! 1000: ! 1001: if (in & GOOD) ! 1002: de6crcv(unit, in); ! 1003: else ! 1004: /*rvb:tmp printf("intr: %x\n", in)*/; ! 1005: ! 1006: ! 1007: de6coutb(sp, CMD(port), SLT_PRN); ! 1008: de6cactive[unit]--; ! 1009: } ! 1010: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1011: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1012: ! 1013: /* ! 1014: * de6crcv: ! 1015: * ! 1016: * This routine is called by the interrupt handler to initiate a ! 1017: * packet transfer from the board to the "if" layer above this ! 1018: * driver. This routine checks if a buffer has been successfully ! 1019: * received by the de6c. If so, the routine de6cread is called ! 1020: * to do the actual transfer of the board data (including the ! 1021: * ethernet header) into a packet (consisting of an mbuf chain). ! 1022: * ! 1023: * input : number of the board to check ! 1024: * output : if a packet is available, it is "sent up" ! 1025: * ! 1026: */ ! 1027: de6crcv(unit, in) ! 1028: int unit, in; ! 1029: { ! 1030: register de6c_softc_t *sp = &de6c_softc[unit]; ! 1031: register struct ifnet *ifp = &sp->ds_if; ! 1032: int port = sp->port; ! 1033: int bo; ! 1034: int collision = 0; ! 1035: int spins = 0; ! 1036: u_short len; ! 1037: struct ether_header header; ! 1038: int tlen; ! 1039: register struct ifqueue *inq; ! 1040: int opri; ! 1041: struct ether_header eh; ! 1042: #ifdef MACH_KERNEL ! 1043: ipc_kmsg_t new_kmsg; ! 1044: struct ether_header *ehp; ! 1045: struct packet_header *pkt; ! 1046: #else MACH_KERNEL ! 1047: struct mbuf *m, *tm; ! 1048: #endif MACH_KERNEL ! 1049: ! 1050: sp->rcv++; ! 1051: ! 1052: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1053: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1054: D(de6crcv0++); ! 1055: #define MT (sp->consume == sp->produce) ! 1056: while (in & GOOD || !MT) { ! 1057: spins++; ! 1058: D(de6crcv1++); ! 1059: if (in & GOOD) { ! 1060: sp->rcvlen[sp->produce] = de6clen(sp); ! 1061: if ( ((sp->produce + 1) % XMTidx) != sp->consume) { ! 1062: if (++sp->produce == XMTidx) ! 1063: sp->produce = 0; ! 1064: DATA_OUT(sp, port, COMMAND, RX_BP|(sp->produce<<4)); ! 1065: DATA_OUT(sp, port, COMMAND, RX_BP|(sp->produce<<4)|RXEN); ! 1066: } else collision = 1; ! 1067: } ! 1068: len = sp->rcvlen[sp->consume]; ! 1069: bo = sp->consume*BFRSIZ; ! 1070: if (len < 60) { ! 1071: printf("de%d: len(%d) < 60\n", unit, len); ! 1072: goto out; ! 1073: return; ! 1074: } ! 1075: de6cread(sp, bo, &eh, sizeof(struct ether_header)); ! 1076: bo += sizeof(struct ether_header); ! 1077: len -= 18; ! 1078: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1079: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1080: ! 1081: #ifdef MACH_KERNEL ! 1082: new_kmsg = net_kmsg_get(); ! 1083: if (new_kmsg == IKM_NULL) { ! 1084: /* ! 1085: * Drop the packet. ! 1086: */ ! 1087: sp->ds_if.if_rcvdrops++; ! 1088: goto out; ! 1089: return; ! 1090: } ! 1091: ! 1092: ehp = (struct ether_header *) ! 1093: (&net_kmsg(new_kmsg)->header[0]); ! 1094: pkt = (struct packet_header *) ! 1095: (&net_kmsg(new_kmsg)->packet[0]); ! 1096: ! 1097: /* ! 1098: * Get header. ! 1099: */ ! 1100: *ehp = eh; ! 1101: ! 1102: /* ! 1103: * Get body ! 1104: */ ! 1105: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1106: de6cread(sp, bo, (char *)(pkt + 1), len); ! 1107: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1108: pkt->type = ehp->ether_type; ! 1109: pkt->length = len + sizeof(struct packet_header); ! 1110: ! 1111: /* ! 1112: * Hand the packet to the network module. ! 1113: */ ! 1114: net_packet(ifp, new_kmsg, pkt->length, ! 1115: ethernet_priority(new_kmsg)); ! 1116: ! 1117: #else MACH_KERNEL ! 1118: eh.ether_type = htons(eh.ether_type); ! 1119: m =(struct mbuf *)0; ! 1120: while ( len ) { ! 1121: if (m == (struct mbuf *)0) { ! 1122: m = m_get(M_DONTWAIT, MT_DATA); ! 1123: if (m == (struct mbuf *)0) { ! 1124: printf("de6crcv: Lost frame\n"); ! 1125: goto out; ! 1126: return; ! 1127: } ! 1128: tm = m; ! 1129: tm->m_off = MMINOFF; ! 1130: /* ! 1131: * first mbuf in the packet must contain a pointer to the ! 1132: * ifnet structure. other mbufs that follow and make up ! 1133: * the packet do not need this pointer in the mbuf. ! 1134: * ! 1135: */ ! 1136: *(mtod(tm, struct ifnet **)) = ifp; ! 1137: tm->m_len = sizeof(struct ifnet **); ! 1138: } ! 1139: else { ! 1140: tm->m_next = m_get(M_DONTWAIT, MT_DATA); ! 1141: tm = tm->m_next; ! 1142: tm->m_off = MMINOFF; ! 1143: tm->m_len = 0; ! 1144: if (tm == (struct mbuf *)0) { ! 1145: m_freem(m); ! 1146: printf("de6crcv: No mbufs, lost frame\n"); ! 1147: goto out; ! 1148: return; ! 1149: } ! 1150: } ! 1151: tlen = MIN( MLEN - tm->m_len, len ); ! 1152: tm->m_next = (struct mbuf *)0; ! 1153: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1154: de6cread(sp, bo, mtod(tm, char *)+tm->m_len, tlen); ! 1155: bo += tlen; ! 1156: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1157: tm->m_len += tlen; ! 1158: len -= tlen; ! 1159: } ! 1160: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1161: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1162: STAT_IN(sp, port, in); ! 1163: if (in & GOOD) { /* got another */ ! 1164: D(de6crcv2++); ! 1165: sp->rcvlen[sp->produce] = de6clen(sp); ! 1166: if ( ((sp->produce + 1) % XMTidx) != sp->consume) { ! 1167: if (++sp->produce == XMTidx) ! 1168: sp->produce = 0; ! 1169: DATA_OUT(sp, port, COMMAND, RX_BP|(sp->produce<<4)); ! 1170: DATA_OUT(sp, port, COMMAND, RX_BP|(sp->produce<<4)|RXEN); ! 1171: } else collision = 1; ! 1172: } ! 1173: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1174: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1175: ! 1176: /* ! 1177: * received packet is now in a chain of mbuf's. next step is ! 1178: * to pass the packet upwards. ! 1179: * ! 1180: */ ! 1181: switch (eh.ether_type) { ! 1182: ! 1183: #ifdef INET ! 1184: case ETHERTYPE_IP: ! 1185: schednetisr(NETISR_IP); ! 1186: inq = &ipintrq; ! 1187: break; ! 1188: case ETHERTYPE_ARP: ! 1189: arpinput(&sp->de6c_ac, m); ! 1190: goto out; ! 1191: return; ! 1192: #endif ! 1193: #ifdef NS ! 1194: case ETHERTYPE_NS: ! 1195: schednetisr(NETISR_NS); ! 1196: inq = &nsintrq; ! 1197: break; ! 1198: #endif ! 1199: default: ! 1200: m_freem(m); ! 1201: goto out; ! 1202: return; ! 1203: } ! 1204: opri = SPLNET(); ! 1205: if (IF_QFULL(inq)) { ! 1206: IF_DROP(inq); ! 1207: splx(opri); ! 1208: m_freem(m); ! 1209: goto out; ! 1210: return; ! 1211: } ! 1212: IF_ENQUEUE(inq, m); ! 1213: splx(opri); ! 1214: #endif MACH_KERNEL ! 1215: out: ! 1216: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1217: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1218: STAT_IN(sp, port, in); ! 1219: if (in & GOOD) { /* got another */ ! 1220: D(de6crcv3++); ! 1221: } ! 1222: /*2*/ /* implies wrap and pause */ ! 1223: if (collision) { ! 1224: collision = 0; ! 1225: D(printf("*C* ")); ! 1226: sp->rcvoff++; ! 1227: if (++sp->produce == XMTidx) ! 1228: sp->produce = 0; ! 1229: DATA_OUT(sp, port, COMMAND, RX_BP|(sp->produce<<4)); ! 1230: DATA_OUT(sp, port, COMMAND, RX_BP|(sp->produce<<4)|RXEN); ! 1231: } ! 1232: /*2*/ /* implies wrap and pause */ ! 1233: if (++sp->consume == XMTidx) ! 1234: sp->consume = 0; ! 1235: if (spins > 10) { ! 1236: spins = 0; ! 1237: D(printf("*R* ")); ! 1238: sp->rcvspin++; ! 1239: /* how should we recover here ??? */; ! 1240: /* return does not work */; ! 1241: /* de6cinit(unit) gets ugly if we are called from ! 1242: de6cxmt */; ! 1243: } ! 1244: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1245: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1246: } ! 1247: } ! 1248: ! 1249: ! 1250: /* ! 1251: * de6cxmt: ! 1252: * ! 1253: * This routine fills in the appropriate registers and memory ! 1254: * locations on the d-link "600" board and starts the board off on ! 1255: * the transmit. ! 1256: * ! 1257: * input : board number of interest, and a pointer to the mbuf ! 1258: * output : board memory and registers are set for xfer and attention ! 1259: * ! 1260: */ ! 1261: /* NOTE: called at SPLNET */ ! 1262: /* ! 1263: * This implies that rcv interrupts will be blocked. ! 1264: */ ! 1265: #define max(a,b) (((a) > (b)) ? (a) : (b)) ! 1266: ! 1267: char de6mt[ETHERMIN]; ! 1268: de6cxmt(unit, m) ! 1269: int unit; ! 1270: MM m; ! 1271: { ! 1272: #ifdef MACH_KERNEL ! 1273: #else MACH_KERNEL ! 1274: register struct mbuf *tm_p; ! 1275: #endif MACH_KERNEL ! 1276: int i; ! 1277: int in; ! 1278: int bo, boo; ! 1279: de6c_softc_t *sp = &de6c_softc[unit]; ! 1280: int port = sp->port; ! 1281: u_short count = 0; ! 1282: u_short bytes_in_msg; ! 1283: static int m_length(); ! 1284: ! 1285: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1286: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1287: if (de6cactive[unit] >= 2) /* a funny loop caused by */ ! 1288: return; /* a flood of arps */ ! 1289: if (de6cactive[unit]++ == 0) ! 1290: de6coutb(sp, CMD(port), SLT_NIC); ! 1291: STAT_IN(sp, port, in); ! 1292: ! 1293: D(if (de6cdo_xmt) printf("xmt: stat[-] = %x\n", in)); ! 1294: if (in & GOOD) { ! 1295: de6crcv(unit, in); ! 1296: } ! 1297: sp->xmt++; ! 1298: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1299: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1300: ! 1301: #ifdef MACH_KERNEL ! 1302: count = m->io_count; ! 1303: bytes_in_msg = max(count, ETHERMIN + sizeof(struct ether_header)); ! 1304: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1305: boo = bo = XMTidx*BFRSIZ+(BFRSIZ-bytes_in_msg); ! 1306: de6cwrite(sp, bo, m->io_data, count); ! 1307: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1308: bo += count; ! 1309: iodone(m); ! 1310: #else MACH_KERNEL ! 1311: bytes_in_msg = max(m_length(m), ETHERMIN + sizeof(struct ether_header)); ! 1312: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1313: boo = bo = XMTidx*BFRSIZ+(BFRSIZ-bytes_in_msg); ! 1314: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1315: ! 1316: for (tm_p = m; tm_p != (struct mbuf *)0; tm_p = tm_p->m_next) { ! 1317: if (count + tm_p->m_len > ETHERMTU + sizeof(struct ether_header)) ! 1318: break; ! 1319: if (tm_p->m_len == 0) ! 1320: continue; ! 1321: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1322: de6cwrite(sp, bo, mtod(tm_p, caddr_t), tm_p->m_len); ! 1323: bo += tm_p->m_len; ! 1324: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1325: count += tm_p->m_len; ! 1326: } ! 1327: m_freem(m); ! 1328: #endif MACH_KERNEL ! 1329: ! 1330: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1331: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1332: if (bytes_in_msg - count > 0) ! 1333: de6cwrite(sp, bo, de6mt, bytes_in_msg - count); ! 1334: ! 1335: DATA_OUT(sp, port, TX_ADR, boo & 0xff); ! 1336: DATA_OUT(sp, port, TX_ADR, (boo >> 8) & 0xff); ! 1337: DATA_OUT(sp, port, COMMAND, RX_BP|(sp->produce<<4)); ! 1338: DATA_OUT(sp, port, COMMAND, RX_BP|(sp->produce<<4)|TXEN); ! 1339: ! 1340: for (i = 0; i < XMT_BSY_WAIT; i++) { ! 1341: STAT_IN(sp, port, in); ! 1342: D(if (de6cdo_xmt) printf("xmt: stat[%d] = %x\n", i, in)); ! 1343: if (in & GOOD) { ! 1344: /* ! 1345: * this does indeed happen ! 1346: * printf("!#"); ! 1347: */ ! 1348: de6crcv(unit, in); ! 1349: } ! 1350: if (!(in & TXBUSY)) { ! 1351: goto out; ! 1352: return; ! 1353: } ! 1354: } ! 1355: printf("dexmt: stat[??] = %x\n", i, in); ! 1356: out: ! 1357: DATA_OUT(sp, port, COMMAND, RX_BP|(sp->produce<<4)); ! 1358: DATA_OUT(sp, port, COMMAND, RX_BP|(sp->produce<<4)|RXEN); ! 1359: ! 1360: if (--de6cactive[unit] == 0) ! 1361: de6coutb(sp, CMD(port), SLT_PRN); ! 1362: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1363: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1364: } ! 1365: ! 1366: /* ! 1367: * de6cintoff: ! 1368: * ! 1369: * This function turns interrupts off for the de6c board indicated. ! 1370: * ! 1371: */ ! 1372: de6cintoff(unit) ! 1373: int unit; ! 1374: { ! 1375: de6c_softc_t *sp = &de6c_softc[unit]; ! 1376: int port = sp->port; ! 1377: int pic = lprinfo[unit]->PIC; ! 1378: ! 1379: printf("de%d: Turning off d-link \"600\"\n", unit); ! 1380: sp->ds_if.if_flags &= ~(IFF_UP|IFF_RUNNING); ! 1381: sp->flags &= ~(DSF_LOCK | DSF_RUNNING); ! 1382: ! 1383: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1384: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1385: de6coutb(sp, CMD(port), SLT_NIC); ! 1386: DATA_OUT(sp, port, COMMAND, RESET); ! 1387: DATA_OUT(sp, port, COMMAND, STOP_RESET); ! 1388: de6coutb(sp, CMD(port), SLT_PRN); ! 1389: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1390: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1391: ! 1392: outb(CMD(sp->port), 0x07); ! 1393: ivect[pic] = sp->oldvect; ! 1394: iunit[pic] = sp->oldunit; ! 1395: } ! 1396: ! 1397: #ifdef MACH_KERNEL ! 1398: #else MACH_KERNEL ! 1399: /* ! 1400: * The length of an mbuf chain ! 1401: */ ! 1402: static ! 1403: m_length(m) ! 1404: register struct mbuf *m; ! 1405: { ! 1406: register int len = 0; ! 1407: ! 1408: while (m) { ! 1409: len += m->m_len; ! 1410: m = m->m_next; ! 1411: } ! 1412: return len; ! 1413: } ! 1414: #endif MACH_KERNEL ! 1415: ! 1416: ! 1417: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1418: /* d-link 600 ON; d-link 600 ON; d-link 600 ON; d-link 600 ON */ ! 1419: de6cgetid(sp, buf) ! 1420: de6c_softc_t *sp; ! 1421: u_char *buf; ! 1422: { ! 1423: de6cread(sp, EADDR, buf, 6); ! 1424: if ((buf[0] != 0x00) || (buf[1] != 0xde) || (buf[2] != 0x15)) ! 1425: return 0; ! 1426: buf[0] = 0x80; ! 1427: buf[1] = 0x00; ! 1428: buf[2] = 0xc8; ! 1429: /* for this model d-link we assert 0x70 as the high mfr's nibble. */ ! 1430: buf[3] = 0x70 | (buf[3] & 0xf); ! 1431: return 1; ! 1432: } ! 1433: ! 1434: de6csetid(sp, buf) ! 1435: de6c_softc_t *sp; ! 1436: char *buf; ! 1437: { ! 1438: de6cwrite(sp, EADDR, buf, 6); ! 1439: } ! 1440: ! 1441: /* ! 1442: * get length of packet just rcv'd. ! 1443: * includes ether header and crc ! 1444: */ ! 1445: de6clen(sp) ! 1446: de6c_softc_t *sp; ! 1447: { ! 1448: int port = sp->port; ! 1449: int in; ! 1450: int i; ! 1451: ! 1452: de6coutb(sp, DATA(port), RX_LEN); ! 1453: in = inb(STAT(port)); ! 1454: de6coutb(sp, DATA(port), RX_LEN|STROBE); ! 1455: i = ((in>>4) | (inb(STAT(port)) & 0xf0)); ! 1456: ! 1457: de6coutb(sp, DATA(port), RX_LEN); ! 1458: in = inb(STAT(port)); ! 1459: de6coutb(sp, DATA(port), RX_LEN|STROBE); ! 1460: i |= ((in>>4) | (inb(STAT(port)) & 0xf0)) << 8; ! 1461: ! 1462: return i; ! 1463: } ! 1464: ! 1465: #if 0 ! 1466: de6cread(sp, address, buf, len) ! 1467: de6c_softc_t *sp; ! 1468: unsigned char *buf; ! 1469: { ! 1470: int port = sp->port; ! 1471: u_char in; ! 1472: ! 1473: DATA_OUT(sp, port, RW_ADR, address & 0xff); ! 1474: DATA_OUT(sp, port, RW_ADR, (address >> 8) & 0xff); ! 1475: ! 1476: while (len--) { ! 1477: de6coutb(sp, DATA(port), READ); ! 1478: in = inb(STAT(port)); ! 1479: de6coutb(sp, DATA(port), READ|STROBE); ! 1480: *buf++ = ((in>>4) | (inb(STAT(port)) & 0xf0)); ! 1481: } ! 1482: } ! 1483: ! 1484: de6cwrite(sp, address, buf, len) ! 1485: de6c_softc_t *sp; ! 1486: unsigned char *buf; ! 1487: { ! 1488: int port = sp->port; ! 1489: int out; ! 1490: ! 1491: DATA_OUT(sp, port, RW_ADR, address & 0xff); ! 1492: DATA_OUT(sp, port, RW_ADR, (address >> 8) & 0xff); ! 1493: ! 1494: while (len--) { ! 1495: out = *buf++; ! 1496: DATA_OUT(sp, port, WRITE, out); ! 1497: ! 1498: } ! 1499: } ! 1500: #endif 0 ! 1501: ! 1502: #ifndef de6cread ! 1503: de6cread(sp, address, buf, len) ! 1504: de6c_softc_t *sp; ! 1505: unsigned char *buf; ! 1506: { ! 1507: int port = sp->port; ! 1508: register volatile int i; ! 1509: unsigned char in; ! 1510: ! 1511: outb(port, ((address)<<4) | RW_ADR); ! 1512: i = sp->latency; while (i-- > 0); ! 1513: outb(port, ((address)&0xf0)| RW_ADR | 0x8); ! 1514: i = sp->latency; while (i-- > 0); ! 1515: ! 1516: outb(port, ((address>>8)<<4) | RW_ADR); ! 1517: i = sp->latency; while (i-- > 0); ! 1518: outb(port, ((address>>8)&0xf0)| RW_ADR | 0x8); ! 1519: i = sp->latency; while (i-- > 0); ! 1520: ! 1521: while (len--) { ! 1522: outb(port, READ); ! 1523: i = sp->latency; while (i-- > 0); ! 1524: in = inb(STAT(port)); ! 1525: outb(port, READ|0x08); ! 1526: i = sp->latency; while (i-- > 0); ! 1527: *buf++ = ((in>>4) | (inb(STAT(port)) & 0xf0)); ! 1528: } ! 1529: } ! 1530: #endif /* de6cread */ ! 1531: ! 1532: #ifndef de6cwrite ! 1533: de6cwrite(sp, address, buf, len) ! 1534: de6c_softc_t *sp; ! 1535: unsigned char *buf; ! 1536: { ! 1537: int port = sp->port; ! 1538: register volatile int i; ! 1539: unsigned char out; ! 1540: ! 1541: outb(port, ((address)<<4) | RW_ADR); ! 1542: i = sp->latency; while (i-- > 0); ! 1543: outb(port, ((address)&0xf0)| RW_ADR | 0x8); ! 1544: i = sp->latency; while (i-- > 0); ! 1545: ! 1546: outb(port, ((address>>8)<<4) | RW_ADR); ! 1547: i = sp->latency; while (i-- > 0); ! 1548: outb(port, ((address>>8)&0xf0)| RW_ADR | 0x8); ! 1549: i = sp->latency; while (i-- > 0); ! 1550: ! 1551: while (len--) { ! 1552: out = *buf++; ! 1553: outb(port, ((out)<<4) | WRITE); ! 1554: i = sp->latency; while (i-- > 0); ! 1555: outb(port, ((out)&0xf0)| WRITE | 0x8); ! 1556: i = sp->latency; while (i-- > 0); ! 1557: } ! 1558: } ! 1559: #endif /* de6cwrite */ ! 1560: ! 1561: de6coutb(sp, p, v) ! 1562: de6c_softc_t *sp; ! 1563: { ! 1564: register volatile int i = sp->latency; ! 1565: ! 1566: outb(p, v); ! 1567: while (i-- > 0); ! 1568: } ! 1569: ! 1570: de6cmemcheck(sp) ! 1571: de6c_softc_t *sp; ! 1572: { ! 1573: int i; ! 1574: int off = 0; ! 1575: int ret = 1; ! 1576: #ifdef MACH_KERNEL ! 1577: unsigned short *memchk; ! 1578: unsigned short *chkmem; ! 1579: if (kmem_alloc(kernel_map, (vm_offset_t *)&memchk, BFRS * BFRSIZ) != ! 1580: KERN_SUCCESS || ! 1581: kmem_alloc(kernel_map, (vm_offset_t *)&chkmem, BFRS * BFRSIZ) != ! 1582: KERN_SUCCESS) { ! 1583: printf("de6c: memory allocation failure!!\n"); ! 1584: return 0; ! 1585: } ! 1586: #else /* MACH_KERNEL */ ! 1587: unsigned short *memchk = (unsigned short *) kmem_alloc(kernel_map, BFRS * BFRSIZ); ! 1588: unsigned short *chkmem = (unsigned short *) kmem_alloc(kernel_map, BFRS * BFRSIZ); ! 1589: if ( ! ((int) memchk) || ! ((int) chkmem)) { ! 1590: printf("de6c: memory allocation failure!!\n"); ! 1591: return 0; ! 1592: } ! 1593: #endif /* MACH_KERNEL */ ! 1594: ! 1595: for (i = 0; i < BFRS * BFRSIZ/sizeof (short); i++) ! 1596: memchk[i] = i; ! 1597: bzero(chkmem, BFRS * BFRSIZ); ! 1598: ! 1599: ! 1600: for (off = 0; off < BFRS * BFRSIZ; off += BFRSIZ/2) { ! 1601: de6cwrite(sp, off, memchk+(off/sizeof (short)), BFRSIZ/2); ! 1602: de6cread (sp, off, chkmem+(off/sizeof (short)), BFRSIZ/2); ! 1603: } ! 1604: ! 1605: for (i = 0; i < BFRS * (BFRSIZ/sizeof (short)); i++) ! 1606: if (memchk[i] != chkmem[i]) { ! 1607: printf("de: tilt:seq [%x:%d] %x != %x\n", ! 1608: i, i, memchk[i], chkmem[i]); ! 1609: ret = 0; ! 1610: break; ! 1611: } ! 1612: ! 1613: kmem_free(kernel_map, (vm_offset_t) memchk, BFRS * BFRSIZ); ! 1614: kmem_free(kernel_map, (vm_offset_t) chkmem, BFRS * BFRSIZ); ! 1615: ! 1616: return ret; ! 1617: } ! 1618: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1619: /* d-link 600 OFF; d-link 600 OFF; d-link 600 OFF; d-link 600 OFF */ ! 1620: ! 1621: #ifdef DEBUG ! 1622: #define STATIC ! 1623: STATIC int print_pkt(), print_bdy(); ! 1624: STATIC int print_e_hdr(), print_ip_hdr(), print_ip(); ! 1625: STATIC int print_ipa(), print_arp(), print_e(), print_chars(); ! 1626: ! 1627: STATIC ! 1628: print_pkt(p, len) ! 1629: unsigned char *p; ! 1630: { ! 1631: int j, k; ! 1632: int type; ! 1633: ! 1634: if (len < 18) ! 1635: printf("print_pkt: too small %d\n", len); ! 1636: ! 1637: type = print_e_hdr(p); ! 1638: ! 1639: switch (type) { ! 1640: case 0x806: ! 1641: print_arp(p+14); ! 1642: break; ! 1643: case 0x800: ! 1644: print_ip(p+14, len - 18); ! 1645: break; ! 1646: default: ! 1647: for (j = 14; j < len; j +=20) { ! 1648: for (k = 0; k < 20; k++) ! 1649: printf("%2x ", p[j+k]); ! 1650: printf("\n"); ! 1651: } ! 1652: } ! 1653: } ! 1654: ! 1655: STATIC ! 1656: print_bdy(p, len, type) ! 1657: unsigned char *p; ! 1658: { ! 1659: int j, k; ! 1660: ! 1661: if (len < 18) ! 1662: printf("print_pkt: too small %d|n", len); ! 1663: ! 1664: switch (type) { ! 1665: case 0x806: ! 1666: print_arp(p); ! 1667: break; ! 1668: case 0x800: ! 1669: print_ip(p, len); ! 1670: break; ! 1671: default: ! 1672: for (j = 0; j < len; j +=20) { ! 1673: for (k = 0; k < 20; k++) ! 1674: printf("%2x ", p[j+k]); ! 1675: printf("\n"); ! 1676: } ! 1677: } ! 1678: } ! 1679: ! 1680: STATIC ! 1681: print_e_hdr(p) ! 1682: unsigned char *p; ! 1683: { ! 1684: int type = ntohs(((unsigned short *)p)[6]); ! 1685: ! 1686: printf("S=%x:%x:%x:%x:%x:%x, ", p[6], p[7], p[8], p[9], p[10], p[11]); ! 1687: printf("D=%x:%x:%x:%x:%x:%x, ", p[0], p[1], p[2], p[3], p[4], p[5]); ! 1688: printf("T=%x\n", type); ! 1689: ! 1690: return type; ! 1691: } ! 1692: ! 1693: STATIC ! 1694: print_ip_hdr(u) ! 1695: u_char *u; ! 1696: { ! 1697: ! 1698: int l = ntohs(*(u_short *)(u+2)); ! 1699: ! 1700: print_ipa(u+12); ! 1701: printf(" -> "); ! 1702: print_ipa(u+12+4); ! 1703: printf(" L%d(0x%x)\n", l, l); ! 1704: } ! 1705: ! 1706: STATIC ! 1707: print_ip(p, len) ! 1708: unsigned char *p; ! 1709: { ! 1710: int j,k; ! 1711: ! 1712: print_ip_hdr(p); ! 1713: for (k =0; k < 12; k++) ! 1714: printf("%2x ", p[k]); ! 1715: print_ipa(p+12); ! 1716: printf(" "); ! 1717: print_ipa(p+12+4); ! 1718: printf("\n"); ! 1719: for (j = 20; j < len; j +=16) { ! 1720: for (k = 0; k < 16; k++) ! 1721: printf("%2x ", p[j+k]); ! 1722: print_chars(&p[j], 16); ! 1723: printf("\n"); ! 1724: } ! 1725: } ! 1726: ! 1727: STATIC ! 1728: print_ipa(u) ! 1729: u_char *u; ! 1730: { ! 1731: printf("%d.%d.%d.%d", u[0], u[1], u[2], u[3]); ! 1732: } ! 1733: ! 1734: STATIC ! 1735: print_arp(p) ! 1736: #ifdef MACH_KERNEL ! 1737: {} ! 1738: #else MACH_KERNEL ! 1739: struct arphdr *p; ! 1740: { ! 1741: u_char *u = (u_char *)(p+1); ! 1742: ! 1743: printf("op = %x, pro = %x, hln = %x, pln = %x\n", ! 1744: ntohs(p->ar_op), ntohs(p->ar_pro), p->ar_hln, p->ar_pln); ! 1745: ! 1746: print_e(u); ! 1747: print_ipa(u+p->ar_hln); ! 1748: printf(" seeks\n"); ! 1749: ! 1750: print_e(u+p->ar_hln+p->ar_pln); ! 1751: print_ipa(u+p->ar_hln+p->ar_pln+p->ar_hln); ! 1752: printf("\n"); ! 1753: ! 1754: } ! 1755: #endif MACH_KERNEL ! 1756: ! 1757: STATIC ! 1758: print_e(u) ! 1759: u_char *u; ! 1760: { ! 1761: printf("%x:%x:%x:%x:%x:%x ", u[0], u[1], u[2], u[3], u[4], u[5]); ! 1762: } ! 1763: ! 1764: STATIC ! 1765: print_chars(u, len) ! 1766: u_char *u; ! 1767: { ! 1768: int c; ! 1769: ! 1770: printf("|>"); ! 1771: while (len--) { ! 1772: c = *u++; ! 1773: if (c < 0x7f && c > 0x1f) ! 1774: printf("%c", c); ! 1775: else ! 1776: printf(" "); ! 1777: } ! 1778: printf("<|"); ! 1779: } ! 1780: #endif DEBUG
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.