![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_ie.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / sys / boot / stand|
Return to if_ie.c CVS log | Up to [Research Unix] / researchv9 / sys / boot / stand |
1.1 ! root 1: #ifndef lint ! 2: static char sccsid[] = "@(#)if_ie.c 1.1 86/02/03 Copyr 1985 Sun Micro"; ! 3: #endif ! 4: ! 5: /* ! 6: * Copyright (c) 1985 by Sun Microsystems, Inc. ! 7: */ ! 8: ! 9: /* ! 10: * Parameters controlling TIMEBOMB action: times out if chip hangs. ! 11: * ! 12: */ ! 13: #define TIMEBOMB 1000000 /* One million times around is all... */ ! 14: #define TIMEOUT -1 /* if (function()) return (TIMEOUT); */ ! 15: #define OK 0 /* Traditional OK value */ ! 16: ! 17: ! 18: /* ! 19: * Sun Intel Ethernet Controller interface ! 20: */ ! 21: #include "saio.h" ! 22: #include "param.h" ! 23: #include "../h/socket.h" ! 24: #include "../sunif/if_iereg.h" ! 25: #include "../sunif/if_mie.h" ! 26: #include "../sunif/if_obie.h" ! 27: #include "../mon/idprom.h" ! 28: #include "../mon/cpu.map.h" ! 29: ! 30: int iexmit(), iepoll(), iereset(); ! 31: ! 32: unsigned long iestd[] = { 0x88000, 0x8C000 }; ! 33: #define NSTD 2 ! 34: ! 35: struct saif ieif = { ! 36: iexmit, ! 37: iepoll, ! 38: iereset, ! 39: }; ! 40: ! 41: #define IEVVSIZ 1024 /* # of pages in page map */ ! 42: #define IEPHYMEMSIZ (16*1024) ! 43: #define IEVIRMEMSIZ (16*1024) ! 44: #define IEPAGSIZ 1024 ! 45: #define IERBUFSIZ 1600 ! 46: #define IEXBUFSIZ 1600 ! 47: ! 48: #ifdef SUN2 ! 49: #define IEDMABASE 0x000000 /* Can access all of memory */ ! 50: #endif SUN2 ! 51: #ifdef SUN3 ! 52: #define IEDMABASE 0x0F000000 /* Can access top 16MB of memory */ ! 53: #endif SUN3 ! 54: ! 55: /* Location in virtual memory of the SCP (System Configuration Pointer) */ ! 56: #define SCP_LOC (char *)(IEDMABASE+IESCPADDR) ! 57: ! 58: /* controller types */ ! 59: #define IE_MB 1 /* Multibus */ ! 60: #define IE_OB 2 /* onboard */ ! 61: ! 62: struct ie_softc { ! 63: /* ! 64: * This first item does two things. First, it reserves space for ! 65: * all the various protocols that need to put their locals somewhere ! 66: * (it was decided that HERE is convenient!). Second, it fills ! 67: * out the structure to align es_scp to the wierd-in address ! 68: * that Intel (thanks guys) fetches it from. ! 69: */ ! 70: char es_fill[PROTOSCRATCH-sizeof(struct iescp)]; /* Align */ ! 71: struct iescp es_scp; /* System config pointer (used once) */ ! 72: struct ieiscp es_iscp; /* Intermediate sys config ptr (once) */ ! 73: struct iescb es_scb; /* Sys Control Block, the real mama */ ! 74: struct ierbd es_rbd; ! 75: struct ierbd es_rbd2; /* Hack for 82586 ucode bugs */ ! 76: struct ierfd es_rfd; ! 77: struct ietfd es_tfd; ! 78: struct ietbd es_tbd; ! 79: struct mie_device *es_mie; ! 80: struct obie_device *es_obie; ! 81: short es_type; ! 82: struct ieiaddr es_iaddr; /* Cmd to set up our Ethernet addr */ ! 83: struct ieconf es_ic; /* Cmd to configure the chip */ ! 84: char es_rbuf[IERBUFSIZ]; ! 85: char es_xbuf[IEXBUFSIZ]; /* buffer accessible by chip */ ! 86: char es_rbuf2[10]; /* Hack for 82586 ucode bugs */ ! 87: }; ! 88: ! 89: /* ! 90: * This initializes the onboard Ethernet control reg to: ! 91: * Reset is active ! 92: * Loopback is NOT active ! 93: * Channel Attn is not active ! 94: * Interrupt enable is not active. ! 95: * Loopback is deactivated due to a bug in the Intel serial interface ! 96: * chip. This chip powers-up in a locked up state if Loopback is active. ! 97: * It "unlocks" itself if you release Loopback; then it's OK to reassert it. ! 98: */ ! 99: struct obie_device obie_reset = {0, 1, 0, 0, 0, 0, 0}; ! 100: ! 101: ieoff_t to_ieoff(); ! 102: ieaddr_t to_ieaddr(); ! 103: ! 104: #ifdef DEBUG ! 105: ieint_t from_ieint(); ! 106: #endif DEBUG ! 107: ! 108: struct devinfo ieinfo = { ! 109: sizeof (struct mie_device), ! 110: sizeof(struct ie_softc), ! 111: 0, ! 112: NSTD, ! 113: iestd, ! 114: MAP_MBMEM, ! 115: 0, /* transfer size handled by ND */ ! 116: }; ! 117: ! 118: int xxprobe(), xxboot(), ieopen(), ieclose(), etherstrategy(), nullsys(); ! 119: ! 120: struct boottab iedriver = { ! 121: "ie", xxprobe, xxboot, ieopen, ieclose, ! 122: etherstrategy, "ie: Sun/Intel Ethernet", &ieinfo, ! 123: }; ! 124: ! 125: /* ! 126: * Open Intel Ethernet nd connection, return -1 for errors. ! 127: */ ! 128: ieopen(sip) ! 129: struct saioreq *sip; ! 130: { ! 131: register int result; ! 132: ! 133: sip->si_sif = &ieif; ! 134: if ( ieinit(sip) || (result = etheropen(sip)) < 0 ) { ! 135: ieclose(sip); /* Make sure we kill chip */ ! 136: return (-1); ! 137: } ! 138: return (result); ! 139: } ! 140: ! 141: /* ! 142: * Set up memory maps and Ethernet chip. ! 143: * Returns 1 for error, 0 for ok. ! 144: */ ! 145: int ! 146: ieinit(sip) ! 147: struct saioreq *sip; ! 148: { ! 149: register struct ie_softc *es; ! 150: int paddr; ! 151: int i; ! 152: struct idprom id; ! 153: ! 154: if (idprom(IDFORM_1, &id) == IDFORM_1 && ! 155: id.id_machine != IDM_SUN2_MULTI && ! 156: (sip->si_ctlr == 0 || sip->si_ctlr == iestd[0])) { ! 157: /* onboard Ethernet */ ! 158: register struct obie_device *obie; ! 159: ! 160: es = (struct ie_softc *)sip->si_dmaaddr; ! 161: bzero((char *)es, sizeof *es); ! 162: es->es_type = IE_OB; ! 163: es->es_obie = obie = (struct obie_device *) ! 164: devalloc(MAP_OBIO, VIOPG_ETHER << BYTES_PG_SHIFT, ! 165: sizeof(*obie)); ! 166: } else { ! 167: register struct mie_device *mie; ! 168: struct miepg *pg; ! 169: short *ap; ! 170: ! 171: mie = (struct mie_device *) sip->si_devaddr; ! 172: mie->mie_peack = 1; ! 173: mie->mie_noloop = 0; ! 174: mie->mie_ie = 0; ! 175: mie->mie_pie = 0; ! 176: paddr = mie->mie_mbmhi << 16; ! 177: ap = (short *)mie->mie_pgmap; ! 178: for (i=0; i<IEVVSIZ; i++) /* note: sets p2mem -> 0 */ ! 179: *ap++ = 0; ! 180: for (i=0; i<IEPHYMEMSIZ/IEPAGSIZ; i++) { ! 181: mie->mie_pgmap[0].mp_pfnum = i; ! 182: } ! 183: pg = &mie->mie_pgmap[0]; ! 184: for (i=0; i<IEVIRMEMSIZ/IEPAGSIZ; i++) { ! 185: pg->mp_swab = 1; ! 186: pg->mp_pfnum = i; ! 187: pg++; ! 188: } ! 189: /* last page for chip init */ ! 190: mie->mie_pgmap[IEVVSIZ-1].mp_pfnum = (PROTOSCRATCH/IEPAGSIZ)-1; ! 191: es = (struct ie_softc *) ! 192: devalloc(MAP_MBMEM, paddr, sizeof(struct ie_softc)); ! 193: bzero((char *)es, sizeof *es); ! 194: es->es_type = IE_MB; ! 195: es->es_mie = mie; ! 196: } ! 197: /* FIXME, release multibus resources ifdef. */ ! 198: sip->si_devdata = (caddr_t)es; ! 199: return iereset(es, sip); ! 200: } ! 201: ! 202: /* ! 203: * Basic 82586 initialization ! 204: * Returns 1 for error, 0 for ok. ! 205: */ ! 206: int ! 207: iereset(es, sip) ! 208: register struct ie_softc *es; ! 209: struct saioreq *sip; ! 210: { ! 211: struct ieiscp *iscp = &es->es_iscp; ! 212: struct iescb *scb = &es->es_scb; ! 213: struct ieiaddr *iad = &es->es_iaddr; ! 214: struct ieconf *ic = &es->es_ic; ! 215: int j; ! 216: int savepmap; ! 217: register struct mie_device *mie = es->es_mie; ! 218: register struct obie_device *obie = es->es_obie; ! 219: ! 220: for (j = 0; j < 10; j++) { ! 221: /* Set up the control blocks for initializing the chip */ ! 222: bzero((caddr_t)&es->es_scp, sizeof (struct iescp)); ! 223: es->es_scp.ie_iscp = to_ieaddr(es, (caddr_t)iscp); ! 224: bzero((caddr_t)iscp, sizeof (struct ieiscp)); ! 225: iscp->ie_busy = 1; ! 226: iscp->ie_scb = to_ieoff(es, (caddr_t)scb); ! 227: iscp->ie_cbbase = to_ieaddr(es, (caddr_t)es); ! 228: bzero((caddr_t)scb, sizeof (struct iescb)); ! 229: if (es->es_type == IE_OB) { ! 230: /* ! 231: * The 82586 has bugs that require us to be in ! 232: * loopback mode while we initialize it, to avoid ! 233: * transitions on CRS (carrier sense). ! 234: * ! 235: * However, the Intel serial interface chip used ! 236: * on Carrera also has bugs: if it powers-up in ! 237: * loopback, you have to release loopback at least ! 238: * once to make it behave -- it powers up with ! 239: * CRS and CDT permanently active, which rapes the 586. ! 240: * ! 241: * How do you spell "broken"? I-N-T-E-L... ! 242: */ ! 243: *obie = obie_reset; /* Reset chip & interface */ ! 244: DELAY(20); ! 245: obie->obie_noloop = 0; /* Put it in loopback now */ ! 246: DELAY(20); ! 247: obie->obie_noreset = 1; /* Release Reset on 82586 */ ! 248: DELAY(200); ! 249: /* ! 250: * Now set up to let the Ethernet chip read the SCP. ! 251: * Intel wired in the address of the SCP. It happens ! 252: * to be 0xFFFFF6. ! 253: */ ! 254: savepmap = getpgmap(SCP_LOC); ! 255: setpgmap(SCP_LOC, getpgmap((char *)&es->es_scp)); ! 256: } else { ! 257: mie->mie_reset = 1; ! 258: DELAY(20); ! 259: mie->mie_reset = 0; ! 260: DELAY(200); ! 261: } ! 262: ! 263: /* ! 264: * We are set up. Give the chip a zap, then wait up to ! 265: * 1 sec, or until chip comes ready. ! 266: */ ! 267: ieca(es); ! 268: CDELAY(iscp->ie_busy != 1, 1000); ! 269: ! 270: /* Whether or not it worked, we have to clean up. */ ! 271: if (es->es_type == IE_OB) { ! 272: /* If it didn't init, reset chip again. */ ! 273: if (iscp->ie_busy == 1) ! 274: obie->obie_noreset = 0; ! 275: setpgmap(SCP_LOC, savepmap); ! 276: } ! 277: if (iscp->ie_busy == 1) ! 278: continue; /* Continue loop until we get it */ ! 279: ! 280: /* ! 281: * Now try to run a few simple commands before we say "OK". ! 282: */ ! 283: bzero((caddr_t)iad, sizeof (struct ieiaddr)); ! 284: iad->ieia_cb.ie_cmd = IE_IADDR; ! 285: myetheraddr((struct ether_addr *)iad->ieia_addr); ! 286: if (iesimple(es, &iad->ieia_cb)) { ! 287: printf("ie: hang while setting Ethernet address.\n"); ! 288: continue; ! 289: } ! 290: ! 291: iedefaultconf(ic); ! 292: if (iesimple(es, &ic->ieconf_cb)) { ! 293: printf("ie: hang while setting chip config.\n"); ! 294: continue; ! 295: } ! 296: ! 297: /* ! 298: * Take the Ethernet interface chip out of loopback mode, i.e. ! 299: * put us on the wire. We can't do this before having ! 300: * initialized the Ethernet chip because the chip does random ! 301: * things if its 'wire' is active between the time it's reset ! 302: * and the first CA. Also, the IA-setup and configure commands ! 303: * will hang under some conditions unless the interface is ! 304: * very quiet and still. ! 305: */ ! 306: if (es->es_type == IE_OB) ! 307: obie->obie_noloop = 1; ! 308: if (es->es_type == IE_MB) ! 309: mie->mie_noloop = 1; ! 310: if (ierustart(es)) { ! 311: printf("ie: hang while starting receiver.\n"); ! 312: continue; ! 313: } ! 314: ! 315: return 0; /* It all worked! */ ! 316: } ! 317: ! 318: /* We tried a bunch of times, no luck. */ ! 319: printf("ie: cannot initialize\n"); ! 320: return 1; ! 321: } ! 322: ! 323: /* ! 324: * Initialize and start the Receive Unit ! 325: */ ! 326: int ! 327: ierustart(es) ! 328: register struct ie_softc *es; ! 329: { ! 330: register struct ierbd *rbd = &es->es_rbd; ! 331: struct ierbd *rbd2 = &es->es_rbd2; ! 332: register struct ierfd *rfd = &es->es_rfd; ! 333: register struct iescb *scb = &es->es_scb; ! 334: int timebomb = TIMEBOMB; ! 335: ! 336: /* ! 337: * Stop the RU, since we're sharing buffers with it. ! 338: * Then wait until it has really stopped. ! 339: */ ! 340: while (scb->ie_rus == IERUS_READY) { ! 341: while (scb->ie_cmd != 0) /* XXX */ ! 342: if (timebomb-- <= 0) return TIMEOUT; ! 343: scb->ie_cmd = IECMD_RU_ABORT; ! 344: ieca(es); ! 345: } ! 346: ! 347: while (scb->ie_cmd != 0) /* XXX */ ! 348: if (timebomb-- <= 0) return TIMEOUT; ! 349: ! 350: /* Real receive buffer descriptor */ ! 351: *(short *)rbd = 0; ! 352: rbd->ierbd_next = to_ieoff(es, (caddr_t)rbd2); /* Fake */ ! 353: rbd->ierbd_el = 0; /* Fake */ ! 354: rbd->ierbd_buf = to_ieaddr(es, es->es_rbuf); ! 355: rbd->ierbd_sizehi = IERBUFSIZ >> 8; ! 356: rbd->ierbd_sizelo = IERBUFSIZ & 0xFF; ! 357: ! 358: /* Fake receive buffer to avoid chip lockups in B0 mask */ ! 359: *(short *)rbd2 = 0; ! 360: rbd2->ierbd_next = -1; /* unnecessary since el = 1 */ ! 361: rbd2->ierbd_el = 1; ! 362: rbd2->ierbd_buf = to_ieaddr(es, es->es_rbuf2); ! 363: rbd2->ierbd_sizehi = 0; ! 364: rbd2->ierbd_sizelo = sizeof(es->es_rbuf2) & 0xFF; ! 365: ! 366: /* Real receive frame descriptor */ ! 367: *(short *)rfd = 0; ! 368: rfd->ierfd_next = -1; /* Unused since el = 1 */ ! 369: rfd->ierfd_el = 1; ! 370: rfd->ierfd_susp = 1; /* Suspend after receiving one */ ! 371: rfd->ierfd_rbd = to_ieoff(es, (caddr_t)rbd); ! 372: ! 373: /* ! 374: * Start the RU again. ! 375: */ ! 376: scb->ie_rfa = to_ieoff(es, (caddr_t)rfd); ! 377: scb->ie_cmd = IECMD_RU_START; ! 378: ieca(es); ! 379: return OK; ! 380: } ! 381: ! 382: ieca(es) ! 383: register struct ie_softc *es; ! 384: { ! 385: if (es->es_type == IE_OB) { ! 386: es->es_obie->obie_ca = 1; ! 387: es->es_obie->obie_ca = 0; ! 388: } else { ! 389: es->es_mie->mie_ca = 1; ! 390: es->es_mie->mie_ca = 0; ! 391: } ! 392: } ! 393: ! 394: int ! 395: iesimple(es, cb) ! 396: register struct ie_softc *es; ! 397: register struct iecb *cb; ! 398: { ! 399: register struct iescb *scb = &es->es_scb; ! 400: register timebomb = TIMEBOMB; ! 401: ! 402: *(short *)cb = 0; /* clear status bits */ ! 403: cb->ie_el = 1; ! 404: cb->ie_next = 0; ! 405: ! 406: /* start CU */ ! 407: while (scb->ie_cmd != 0) /* XXX */ ! 408: if (timebomb-- <= 0) return TIMEOUT; ! 409: scb->ie_cbl = to_ieoff(es, (caddr_t)cb); ! 410: scb->ie_cmd = IECMD_CU_START; ! 411: if (scb->ie_cx) ! 412: scb->ie_cmd |= IECMD_ACK_CX; ! 413: if (scb->ie_cnr) ! 414: scb->ie_cmd |= IECMD_ACK_CNR; ! 415: ieca(es); ! 416: while (!cb->ie_done) /* XXX */ ! 417: if (timebomb-- <= 0) return TIMEOUT; ! 418: while (scb->ie_cmd != 0) /* XXX */ ! 419: if (timebomb-- <= 0) return TIMEOUT; ! 420: if (scb->ie_cx) ! 421: scb->ie_cmd |= IECMD_ACK_CX; ! 422: if (scb->ie_cnr) ! 423: scb->ie_cmd |= IECMD_ACK_CNR; ! 424: ieca(es); ! 425: return OK; ! 426: } ! 427: ! 428: /* ! 429: * Transmit a packet. ! 430: * Always copy the packet for the sake of Multibus ! 431: * boards and Sun3's. This is not a performance critical situation ! 432: */ ! 433: iexmit(es, buf, count) ! 434: register struct ie_softc *es; ! 435: char *buf; ! 436: int count; ! 437: { ! 438: register struct ietbd *tbd = &es->es_tbd; ! 439: register struct ietfd *td = &es->es_tfd; ! 440: ! 441: bzero((caddr_t)tbd, sizeof *tbd); ! 442: tbd->ietbd_eof = 1; ! 443: tbd->ietbd_cntlo = count & 0xFF; ! 444: tbd->ietbd_cnthi = count >> 8; ! 445: bcopy(buf, es->es_xbuf, count); ! 446: tbd->ietbd_buf = to_ieaddr(es, es->es_xbuf); ! 447: td->ietfd_tbd = to_ieoff(es, (caddr_t)tbd); ! 448: td->ietfd_cmd = IE_TRANSMIT; ! 449: if (iesimple(es, (struct iecb *)td)) { ! 450: printf("ie: xmit hang\n"); ! 451: return -1; ! 452: } ! 453: #ifdef DEBUG ! 454: if (!td->ietfd_ok) { ! 455: /* Print status bits from transmit command */ ! 456: printf("ie xmit failed: %x\n", *(unsigned short *)td); ! 457: } ! 458: #endif DEBUG ! 459: if (td->ietfd_ok) ! 460: return (0); ! 461: if (td->ietfd_xcoll) ! 462: printf("ie: Ethernet cable problem\n"); ! 463: return (-1); ! 464: } ! 465: ! 466: ! 467: ! 468: int ! 469: iepoll(es, buf) ! 470: register struct ie_softc *es; ! 471: char *buf; ! 472: { ! 473: register struct ierbd *rbd = &es->es_rbd; ! 474: register struct ierfd *rfd = &es->es_rfd; ! 475: register struct iescb *scb = &es->es_scb; ! 476: int len; ! 477: int timebomb = TIMEBOMB; ! 478: ! 479: #ifdef DEBUG ! 480: /* Check for error status, and printf if so */ ! 481: /* ! 482: * Resource errors should be ignored, they happen even when we ! 483: * are not interested in listening. ! 484: */ ! 485: if (scb->ie_crcerrs || scb->ie_alnerrs || scb->ie_ovrnerrs) { ! 486: printf("ie recv %x CRC %d, ALN %d, OVRN %d\n", ! 487: scb->ie_rus, ! 488: from_ieint(scb->ie_crcerrs), ! 489: from_ieint(scb->ie_alnerrs), ! 490: from_ieint(scb->ie_ovrnerrs)); ! 491: scb->ie_crcerrs = 0; ! 492: scb->ie_alnerrs = 0; ! 493: scb->ie_ovrnerrs = 0; ! 494: } ! 495: #endif DEBUG ! 496: ! 497: /* ! 498: * Note, this assumes that the RU is set up to get out of READY ! 499: * state after receiving one packet. ! 500: */ ! 501: if (scb->ie_rus == IERUS_READY) { ! 502: return (0); /* No packet yet */ ! 503: } else { ! 504: /* RU not ready, see if because we got a packet. */ ! 505: if (!rfd->ierfd_done || !rbd->ierbd_eof) { ! 506: /* No, randomness zapped it. */ ! 507: #ifdef DEBUG ! 508: printf("ie recv restart from %x: scb %x frm %x buf %x\n" ! 509: , scb->ie_rus, ! 510: *(unsigned short *)scb, *(unsigned short *)rfd, ! 511: *(unsigned short *)rbd); ! 512: #endif DEBUG ! 513: ierustart(es); ! 514: return (0); ! 515: } ! 516: } ! 517: ! 518: /* ! 519: * We got a packet. ! 520: */ ! 521: len = (rbd->ierbd_cnthi << 8) + rbd->ierbd_cntlo; ! 522: bcopy(es->es_rbuf, buf, len); ! 523: while (scb->ie_cmd != 0) /* XXX */ ! 524: if (timebomb-- <= 0) return TIMEOUT; ! 525: if (scb->ie_fr) ! 526: scb->ie_cmd |= IECMD_ACK_FR; ! 527: if (scb->ie_rnr) ! 528: scb->ie_cmd |= IECMD_ACK_RNR; ! 529: ieca(es); ! 530: ierustart(es); ! 531: return (len); ! 532: } ! 533: ! 534: /* ! 535: * Convert a CPU virtual address into an Ethernet virtual address. ! 536: * ! 537: * For Multibus, we assume it's in the Ethernet's memory space, and we ! 538: * just subtract off the start of the memory space (==es). For Model 50, ! 539: * the Ethernet chip has full access to supervisor virtual memory. ! 540: * For Carrera, the chip can access the top 16MB of virtual memory, ! 541: * but we never give it addresses outside that range, so the high ! 542: * order bits can be ignored. ! 543: */ ! 544: ieaddr_t ! 545: to_ieaddr(es, cp) ! 546: struct ie_softc *es; ! 547: caddr_t cp; ! 548: { ! 549: union { ! 550: int n; ! 551: char c[4]; ! 552: } a, b; ! 553: ! 554: #ifdef SUN3 ! 555: #ifdef DEBUG ! 556: if (cp < (char *)0x0F000000 || cp >= (char *)0x10000000) { ! 557: /* printf("Bad ptr to_ieaddr(%x)\n", cp); */ ! 558: ; asm(" .word 0xFFFF") ; ; ! 559: } ! 560: #endif DEBUG ! 561: #endif SUN3 ! 562: if (es->es_type == IE_MB) ! 563: a.n = cp - (caddr_t)es; ! 564: else /* if (es->es_type == IE_OB) */ ! 565: a.n = (int)cp; ! 566: b.c[0] = a.c[3]; ! 567: b.c[1] = a.c[2]; ! 568: b.c[2] = a.c[1]; ! 569: b.c[3] = 0; ! 570: return (b.n); ! 571: } ! 572: ! 573: /* ! 574: * Convert a CPU virtual address into a 16-bit offset for the Ethernet ! 575: * chip. ! 576: * ! 577: * This is the same for Onboard and Multibus, since the offset is based ! 578: * on the absolute address supplied in the initial system configuration ! 579: * block -- which we customize for Multibus or Onboard. ! 580: */ ! 581: ieoff_t ! 582: to_ieoff(es, addr) ! 583: register struct ie_softc *es; ! 584: caddr_t addr; ! 585: { ! 586: union { ! 587: short s; ! 588: char c[2]; ! 589: } a, b; ! 590: ! 591: a.s = (short)(addr - (caddr_t)es); ! 592: b.c[0] = a.c[1]; ! 593: b.c[1] = a.c[0]; ! 594: return (b.s); ! 595: } ! 596: ! 597: ! 598: #ifdef DEBUG ! 599: ieint_t ! 600: from_ieint(n) ! 601: short n; ! 602: { ! 603: union { ! 604: short s; ! 605: char c[2]; ! 606: } a, b; ! 607: ! 608: a.s = n; ! 609: b.c[0] = a.c[1]; ! 610: b.c[1] = a.c[0]; ! 611: return (b.s); ! 612: } ! 613: #endif DEBUG ! 614: ! 615: /* ! 616: * Set default configuration parameters ! 617: * As spec'd by Intel, except acloc == 1 for header in data ! 618: */ ! 619: iedefaultconf(ic) ! 620: register struct ieconf *ic; ! 621: { ! 622: bzero((caddr_t)ic, sizeof (struct ieconf)); ! 623: ic->ieconf_cb.ie_cmd = IE_CONFIG; ! 624: ic->ieconf_bytes = 12; ! 625: ic->ieconf_fifolim = 8; ! 626: ic->ieconf_pream = 2; /* 8 byte preamble */ ! 627: ic->ieconf_alen = 6; ! 628: ic->ieconf_acloc = 1; ! 629: ic->ieconf_space = 96; ! 630: ic->ieconf_slttmh = 512 >> 8; ! 631: ic->ieconf_minfrm = 64; ! 632: ic->ieconf_retry = 15; ! 633: } ! 634: ! 635: /* ! 636: * Close down intel ethernet device. ! 637: * On the Model 50, we reset the chip and take it off the wire, since ! 638: * it is sharing main memory with us (occasionally reading and writing), ! 639: * and most programs don't know how to deal with that -- they just assume ! 640: * that main memory is theirs to play with. ! 641: */ ! 642: ieclose(sip) ! 643: struct saioreq *sip; ! 644: { ! 645: register struct ie_softc *es = (struct ie_softc *) sip->si_devdata; ! 646: ! 647: if (es->es_type == IE_OB) ! 648: *es->es_obie = obie_reset; ! 649: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.