![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to il.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / sys / dev|
Return to il.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 ! root 1: #include "il.h" ! 2: ! 3: #if NIL > 0 ! 4: ! 5: #include "../h/param.h" ! 6: #include "../h/systm.h" ! 7: #include "../h/dir.h" ! 8: #include "../h/user.h" ! 9: #include "../h/map.h" ! 10: #include "../h/pte.h" ! 11: #include "../h/buf.h" ! 12: #include "../h/ubareg.h" ! 13: #include "../h/ubavar.h" ! 14: #include "../h/proc.h" ! 15: #include "../h/tty.h" ! 16: /*#include "../h/queue.h"*/ ! 17: #include "../h/ilreg.h" ! 18: #include "../h/conf.h" ! 19: ! 20: #define PRINET 26 /* sleep priority: interruptible */ ! 21: ! 22: struct ilcb ilcb[NIL]; ! 23: extern int ilprobe(), ilattach(), ilrint(), ilcint(); ! 24: struct uba_device *ildinfo[NIL]; ! 25: u_short ilstd[] = {0164040}; ! 26: struct uba_driver ildriver = ! 27: { ilprobe, 0, ilattach, 0, ilstd, "il", ildinfo }; ! 28: ! 29: ! 30: /*++* ! 31: * Macro: NM10command ! 32: * Abstract: pass the NM10 board an inline command ! 33: * Parameters: ! 34: * command: command to process ! 35: * size: size of data buffer ! 36: * buf: data buffer ! 37: * addr: NM10 device addr ! 38: * Returns: nothing ! 39: * Affects: nothing ! 40: * Errors: none ! 41: * Design: trivial ! 42: * ! 43: *--*/ ! 44: #define NM10command(command, size, buf) \ ! 45: { \ ! 46: register unsigned int map = ((unsigned int) buf); \ ! 47: reg->bcr = size; \ ! 48: reg->bar = map & 0xffff; \ ! 49: reg->csr = ((map & 0x30000) >> 2) | command; \ ! 50: while ((reg->csr & IL_CMD_DONE) == 0); \ ! 51: } ! 52: ! 53: ! 54: /*++* ! 55: * Routine: ilinit ! 56: * Abstract: Initialize the Interlan ethernet driver. ! 57: * Parameters: ! 58: * dev: number device to initialize; ! 59: * Returns: nothing ! 60: * Affects: nothing ! 61: * Errors: ! 62: * Design: trivial ! 63: * ! 64: *--*/ ! 65: ilinit (dev) ! 66: { ! 67: register struct ilcb *ib = &ilcb[dev]; ! 68: register struct uba_device *ui = ildinfo[dev]; ! 69: register struct ilreg *reg = (struct ilreg *)ui->ui_addr; ! 70: ! 71: if (ib->avail) ! 72: { ! 73: u.u_error = EBUSY; ! 74: return; ! 75: } ! 76: ! 77: ib->in_map = uballoc(ui->ui_ubanum, (caddr_t) 0x80000000, ! 78: ILUBASIZE, UBA_NEEDBDP|UBA_CANTWAIT); ! 79: ib->cmd_map = uballoc(ui->ui_ubanum, (caddr_t) 0x80000000, ! 80: ILUBASIZE, UBA_NEEDBDP|UBA_CANTWAIT); ! 81: ! 82: if ((ib->in_map == 0) || (ib->cmd_map == 0)) ! 83: { ! 84: if (ib->in_map) ! 85: ubarelse (ui->ui_ubanum, &ib->in_map); ! 86: if (ib->cmd_map) ! 87: ubarelse (ui->ui_ubanum, &ib->cmd_map); ! 88: u.u_error = ENOMEM; ! 89: return; ! 90: } ! 91: ! 92: /*++* ! 93: * initialize cummulative statistics ! 94: * ! 95: *--*/ ! 96: { ! 97: struct ilstats stats; ! 98: register unsigned short *st = (unsigned short *) &stats.rframes; ! 99: register unsigned int *in = (unsigned int *) &ib->info.rframes; ! 100: ! 101: NM10command (IL_RPT_STATS, 66, ! 102: ubaremap(ui->ui_ubanum, ib->in_map, stats)); ! 103: ! 104: /* we do this remap to cause a ubapurge */ ! 105: ubaremap(ui->ui_ubanum, ib->in_map, stats); ! 106: ! 107: while (st > (unsigned short *) &stats.modid) ! 108: *in++ = *st++; ! 109: ! 110: ib->info.iladdr = stats.iladdr; ! 111: ib->info.modid = stats.modid; ! 112: ib->info.firmid = stats.firmid; ! 113: } ! 114: ! 115: ib->in_ptr = 0; ! 116: ib->in_packet = NULL; ! 117: ib->cmd_packet = NULL; ! 118: ib->in_next = NULL; ! 119: ! 120: initqueue((struct Queue *)&ib->cmd_q); ! 121: ! 122: ilrstart (ui); ! 123: NM10command (IL_ON_LINE, 0, 0); ! 124: } ! 125: ! 126: ilopen (dev, flag) ! 127: { ! 128: register struct ilcb *ib = &ilcb[dev]; ! 129: ! 130: if (ib > &ilcb[NIL] || !ib->attached) ! 131: { ! 132: u.u_error = ENXIO; ! 133: return; ! 134: } ! 135: ! 136: } ! 137: ! 138: ilclose (dev) ! 139: { ! 140: return; ! 141: } ! 142: ! 143: ! 144: /*++* ! 145: * Procedure: ilcommand ! 146: * Abstract: ! 147: * send command to net. ! 148: * Parameters: ! 149: * dev = device number ! 150: * p = pointer to packet that is to be given to Interland device. ! 151: * Design: ! 152: * ! 153: *--*/ ! 154: ilcommand(dev, p) ! 155: register struct ilpacket *p; ! 156: { ! 157: register struct uba_device *ui = ildinfo [dev]; ! 158: register struct ilcb *ib = &ilcb [dev]; ! 159: int ipl; ! 160: extern ilcmdstart(); ! 161: ! 162: ipl = spl6(); ! 163: ! 164: if (ib->cmd_packet == NULL) ! 165: { ! 166: ib->cmd_packet = p; ! 167: ilcmdstart (ui); ! 168: } ! 169: else enqueue (&ib->cmd_q, p); ! 170: ! 171: splx(ipl); ! 172: } ! 173: ! 174: ! 175: ! 176: ilioctl (dev, cmd, arg) int *arg; ! 177: { ! 178: switch (cmd) ! 179: { ! 180: case IL_INIT: ! 181: { ! 182: if (suser()) ! 183: ilinit (dev); ! 184: else ! 185: { ! 186: u.u_error = EPERM; ! 187: return; ! 188: } ! 189: } ! 190: break; ! 191: ! 192: case IL_DISABLE: ! 193: { ! 194: /* ildisable (dev); */ ! 195: } ! 196: break; ! 197: ! 198: case IL_STATS: ! 199: { ! 200: register struct ilcb *ib = &ilcb[dev]; ! 201: unsigned short buf[ILPHEAD + 66]; ! 202: register struct ilpacket *p = (struct ilpacket *)buf; ! 203: extern ilstats (); ! 204: ! 205: p->command = IL_RPT_STATS; ! 206: p->function = ilstats; ! 207: p->count = 66; ! 208: ilcommand (dev, p); ! 209: ! 210: while (p->command == IL_RPT_STATS) ! 211: sleep((caddr_t) p, PRINET); ! 212: copyout(&ib->info, arg, sizeof ib->info); ! 213: } ! 214: break; ! 215: ! 216: default: ! 217: { ! 218: u.u_error = EINVAL; ! 219: } ! 220: break; ! 221: } ! 222: } ! 223: ! 224: ! 225: /*++* ! 226: * Routine: ilfind ! 227: * Abstract: find a type filter that matched a specified type. ! 228: * Parameters: ! 229: * ib = pointer to the ethernet device ilcb. ! 230: * type = type that filter will match. ! 231: * Returns: ! 232: * SUCCESS: a descriptor with the matched type. ! 233: * FAILURE: NULL ! 234: * Affects: nothing ! 235: * Errors: none ! 236: * Design: trivial ! 237: * ! 238: *--*/ ! 239: struct iltype *ilfind(ib, type) register unsigned short type; ! 240: register struct ilcb *ib; ! 241: { ! 242: register struct iltype *d; ! 243: for ( d = (struct iltype *)ib->type_q.F; ! 244: d != (struct iltype *)&ib->type_q; ! 245: d = (struct iltype *) d->head.F ) ! 246: if (d->type == type) ! 247: return (d); ! 248: return (NULL); ! 249: } ! 250: ! 251: ! 252: /*++* ! 253: * Routine: ilconnect ! 254: * Abstract: create and ethernet type filter entry ! 255: * Parameters: ! 256: * unit = ethernet device unit number. ! 257: * type = ethernet type ! 258: * funct = function to call if we find a match ! 259: * Returns: ! 260: * SUCCESS: 1 ! 261: * FAILURE: 0 ! 262: * Affects: ! 263: * ilcb[unit].type_q: entry placed in queue ! 264: * ilcb[unit].free_q: entry removed from queue ! 265: * Errors: none ! 266: * Design: ... ! 267: * ! 268: *--*/ ! 269: ilconnect (unit, type, function) register funct *function; ! 270: { ! 271: register struct iltype *d; ! 272: register struct ilcb *ib = &ilcb[unit]; ! 273: register int ipl; ! 274: ! 275: ipl = spl6(); ! 276: if (ilfind (ib, type) == NULL) ! 277: if (d = (struct iltype *) dequeue (&ib->free_q)) ! 278: { ! 279: ib->num_free--; ! 280: d->type = type; ! 281: d->funct = function; ! 282: enqueue (&ib->type_q, d); ! 283: ib->num_types++; ! 284: splx (ipl); ! 285: return (1); ! 286: } ! 287: splx (ipl); ! 288: return (0); ! 289: } ! 290: ! 291: ! 292: ! 293: /*++* ! 294: * Routine: ildisconnect ! 295: * Abstract: remove an ethernet type filter match entry ! 296: * Parameters: ! 297: * unit = ethernet device unit number ! 298: * type = ethernet type ! 299: * Returns: ! 300: * SUCCESS: 1 ! 301: * FAILURE: 0 ! 302: * Affects: ! 303: * ilcb[unit].type_q: entry removed ! 304: * ilcb[unit].free_q: entry entered ! 305: * Errors: none ! 306: * Design: ... ! 307: * ! 308: *--*/ ! 309: ildisconnect (unit, type) register int type; ! 310: { ! 311: struct iltype *d; ! 312: register struct ilcb *ib = &ilcb[unit]; ! 313: register int ipl; ! 314: ! 315: if (d = ilfind (ib, type)) ! 316: { ! 317: ipl = spl6 (); ! 318: enqueue (&ib->free_q, dequeue (&d)); ! 319: ib->num_types--; ! 320: ib->num_free++; ! 321: splx(ipl); ! 322: } ! 323: } ! 324: ! 325: ! 326: ! 327: /*++* ! 328: * Routine: iladdress ! 329: * Abstract: return (by reference) the device net address ! 330: * Parameters: ! 331: * addr = the network address. ! 332: * Returns: nothing ! 333: * Affects: nothing ! 334: * Errors: none ! 335: * Design: trivial ! 336: * ! 337: *--*/ ! 338: iladdress (dev, addr) register struct iladdr *addr; ! 339: { ! 340: register struct ilcb *ib = &ilcb[dev]; ! 341: *addr = ib->info.iladdr; ! 342: } ! 343: ! 344: ! 345: /*++* ! 346: * Procedure: ilrstart ! 347: * Abstract: Start read operation on net. ! 348: * Parameters: ! 349: * 'ui' type "uba_device *": pointer to ethernet device to be started. ! 350: * ! 351: *--*/ ! 352: ! 353: ilrstart(ui) ! 354: register struct uba_device *ui; ! 355: { ! 356: register struct ilreg *reg = (struct ilreg *)ui->ui_addr; ! 357: register struct ilcb *ib = &ilcb[ui->ui_unit]; ! 358: register struct ilpacket *p; ! 359: int ipl; ! 360: ! 361: if (ib->in_packet == NULL) ! 362: { ! 363: ipl = spl6(); ! 364: ib->in_packet = &ib->in_pool[ib->in_ptr]; ! 365: ib->in_ptr ^= 1; ! 366: ib->in_next = ubaremap (ui->ui_ubanum, ib->in_map, ! 367: ib->in_packet->data); ! 368: if (ib->cmd_packet == NULL) ! 369: { ! 370: NM10command (IL_RCVR_BUFFER | IL_RCV_INTR, ! 371: ILPACKETSIZE, ! 372: ib->in_next); ! 373: ib->in_next = NULL; ! 374: } ! 375: splx (ipl); ! 376: } ! 377: } ! 378: ! 379: ! 380: ! 381: /*++* ! 382: * Procedure: ilcmdstart ! 383: * Abstract: Start packet transmission on net. ! 384: * Parameters: ! 385: * ui pointer to ethernet device structure. ! 386: * Design: ! 387: * We give the Interland device the correct command ! 388: * ! 389: * The UNIBUS address is derived by calculating the offset of the ! 390: * packet from the packet pool buffer base address and adding it to the ! 391: * allocated unibus buffer base address. ! 392: * ! 393: * We must do a purge to make sure the uba device has no data words ! 394: * lying around that might get sent on the next DMA. ! 395: * ! 396: *--*/ ! 397: ilcmdstart(ui) ! 398: register struct uba_device *ui; ! 399: { ! 400: ! 401: register struct ilcb *ib = &ilcb[ui->ui_unit]; ! 402: register struct ilreg *ilreg = (struct ilreg *)ui->ui_addr; ! 403: register struct ilpacket *p; ! 404: register unsigned int buffer; ! 405: ! 406: if (ib->cmd_packet == NULL) ! 407: if ((ib->cmd_packet = (struct ilpacket *)dequeue(&ib->cmd_q)) == NULL) ! 408: return; ! 409: ! 410: /* we dont use NM10command here since we are not interested ! 411: in waiting for the command to complete synchronously */ ! 412: ! 413: p = ib->cmd_packet; ! 414: buffer = (unsigned int) ubaremap (ui->ui_ubanum, ib->cmd_map, ! 415: p->data); ! 416: ilreg->bcr = p->count; ! 417: ilreg->bar = buffer & 0xffff; ! 418: ilreg->csr = ((buffer & 0x30000) >> 2) ! 419: | p->command | IL_CMD_INTR | IL_RCV_INTR; ! 420: ! 421: } ! 422: ! 423: ! 424: /*++* ! 425: * Procedure: ilrint ! 426: * Abstract: Net read interrupt handler. ! 427: * Parameters: ! 428: * dev = number of ethernet device. ! 429: * ! 430: *--*/ ! 431: ilrint(dev) ! 432: { ! 433: ! 434: register struct ilcb *ib = &ilcb[dev]; ! 435: register struct uba_device *ui = ildinfo[dev]; ! 436: register struct il_rheader *l; ! 437: register struct iltype *d; ! 438: ! 439: l = (struct il_rheader *)ib->in_packet; ! 440: ilrstart(ui); ! 441: if (l->status & IL_RCV_STATUS) ! 442: printf ("il%d: received bad packet; status %x\n", dev, l); ! 443: else if (d = ilfind(ib, l->type)) ! 444: (*d->funct)(dev, l); ! 445: } ! 446: ! 447: ! 448: /*++* ! 449: * Procedure: ilcint ! 450: * Abstract: Net transmit interrupt handler. ! 451: * Parameters: ! 452: * 'en' number of device we interrupted on. ! 453: * ! 454: *--*/ ! 455: ! 456: ilcint(dev) ! 457: { ! 458: register struct ilcb *ib = &ilcb[dev]; ! 459: register struct uba_device *ui = ildinfo[dev]; ! 460: register unsigned short status; ! 461: register struct ilpacket *p = ib->cmd_packet; ! 462: register struct ilreg *reg = (struct ilreg *) ui->ui_addr; ! 463: ! 464: if (p == NULL) ! 465: { ! 466: printf ("il%d: spurious transmit interrupt\n", dev); ! 467: return; ! 468: } ! 469: ! 470: status = reg->csr & IL_CMD_STATUS; ! 471: if (p->command == IL_XMIT_SEND) ! 472: { ! 473: if ((status) > 1) ! 474: printf ("il%d: dropped xmit packet\n", dev); ! 475: } ! 476: else if (status) ! 477: printf ("il%d: command %x bad status packet: %x\n", ! 478: dev, p->command, p); ! 479: ! 480: if (p->function != NULL) ! 481: (*(p->function)) (p, dev); ! 482: ! 483: if (ib->in_next) ! 484: { ! 485: NM10command (IL_RCVR_BUFFER | IL_RCV_INTR, ! 486: ILPACKETSIZE, ! 487: ib->in_next); ! 488: } ! 489: ! 490: ib->in_next = NULL; ! 491: ib->cmd_packet = NULL; ! 492: ilcmdstart (ui); ! 493: } ! 494: ! 495: ! 496: /*++* ! 497: * Procedure: ilstats ! 498: * Abstract: ! 499: * Merge currently collected data into the device statistics ! 500: * table. This routine assumes HIGH PRIORITY. ! 501: * ! 502: *--*/ ! 503: ilstats (p, dev) struct ilpacket *p; ! 504: { ! 505: register struct ilcb *ib = &ilcb[dev]; ! 506: register struct ilstats *stats = (struct ilstats *)p->data; ! 507: register unsigned int *in = (unsigned int *) &ib->info.rframes; ! 508: register unsigned short *st = (unsigned short *) &stats->rframes; ! 509: ! 510: while (st < (unsigned short *) stats) ! 511: *in++ += *st++; ! 512: ib->info.rfifo = stats->rfifo; ! 513: p->command = IL_NULL_CMD; ! 514: wakeup((caddr_t) p); ! 515: } ! 516: ! 517: ! 518: ! 519: /*++* ! 520: * Procedure: ilattach ! 521: * Abstract: ! 522: * This routine is called at system startup and initializes ! 523: * the device information structures. ! 524: * Parameters: ! 525: * 'ui' type "uba_device *": pointer to the device information ! 526: * structure. ! 527: *--*/ ! 528: ilattach(ui) ! 529: register struct uba_device *ui; ! 530: { ! 531: register struct ilreg *reg = (struct ilreg *) ui->ui_addr; ! 532: register struct ilcb *ib = &ilcb[ui->ui_unit]; ! 533: register unsigned short status; ! 534: register int i; ! 535: ! 536: if (&ilcb[ui->ui_unit] > &ilcb[NIL]) ! 537: { ! 538: printf ("il%d: unit number to large. Max = %d\n", ! 539: ui->ui_unit, NIL); ! 540: return; ! 541: } ! 542: ! 543: if (status = (reg->csr & IL_CMD_STATUS)) ! 544: { ! 545: printf ("il%d: bad reset status %x\n"); ! 546: return; ! 547: } ! 548: ! 549: ib->attached = 1; ! 550: ! 551: initqueue((struct Queue *)&ib->type_q); ! 552: initqueue((struct Queue *)&ib->free_q); ! 553: ib->num_types = 0; ! 554: ib->num_free = ILMAXTYPES; ! 555: ! 556: for (i = 0; i < ILMAXTYPES; i++) ! 557: enqueue (&ib->free_q, ib->type[i]); ! 558: ! 559: #ifdef TCP_IP ! 560: #if NBBNNET > 0 ! 561: il_attach(); ! 562: #endif NBBNNET ! 563: #endif TCP_IP ! 564: } ! 565: ! 566: ! 567: ! 568: /*++* ! 569: * Procedure: ilprobe ! 570: * Abstract: ! 571: * This routine is called by the system auto configurer ! 572: * at boot time. It locates the interrupt vectors of the device ! 573: * by doing FM (f___ing Magic). Cvec is used as a global register ! 574: * in which the interrupt routine places the interrupt vector ! 575: * that it found when the device interrupted. ! 576: * We can use this routine to do some boot time testing if ! 577: * we want. ! 578: * Parameters: ! 579: * 'reg' the base address of the ethernet device. ! 580: * ! 581: *--*/ ! 582: ilprobe(reg) ! 583: struct ilreg *reg; ! 584: { ! 585: register int br,cvec; ! 586: ! 587: #ifdef lint ! 588: br = 0; cvec = br; br = cvec; ! 589: #endif ! 590: ! 591: reg->bcr = 0; ! 592: reg->bar = 0; ! 593: reg->csr = IL_OFF_LINE | IL_CMD_INTR; ! 594: DELAY(10000); ! 595: ! 596: br = reg->csr; /* clear off status from il board */ ! 597: cvec &= ~0xf; /* make sure we have the first intr vector */ ! 598: return(1); ! 599: } ! 600: ! 601: ! 602: ! 603: ! 604: /*++* ! 605: * Procedure: ilreset ! 606: * Abstract: ! 607: * reset the interlan ethernet device ! 608: * Called on UBA reset to restart pending I/O. ! 609: * Just prints the device name and restarts the receiver and ! 610: * transmitter. No other state that we care about is lost by ! 611: * the reset. ! 612: * Parameters: ! 613: * 'uban' number of the uba that was reset. ! 614: * ! 615: *--*/ ! 616: ilreset(uban) ! 617: { ! 618: ! 619: register int dev; ! 620: register struct uba_device *ui; ! 621: register struct ilreg *reg = (struct ilreg *) ui->ui_addr; ! 622: register struct ilcb *ib; ! 623: ! 624: for (dev = 0; dev < NIL; dev++) ! 625: { ! 626: if ((ui = ildinfo[dev]) || ! 627: ui->ui_alive == 0 || ! 628: ui->ui_ubanum != uban) ! 629: continue; ! 630: ! 631: ! 632: ib = &ilcb[dev]; ! 633: /*++* ! 634: * do a reset command so we are sure of the state ! 635: * ! 636: *--*/ ! 637: NM10command (IL_RESET, 0, 0); ! 638: printf("[reset] "); ! 639: ! 640: /*++* ! 641: * put us back on line if we are active ! 642: * and start the command and receive processes. ! 643: * ! 644: *--*/ ! 645: if (ib->avail) ! 646: { ! 647: NM10command (IL_ON_LINE, 0, 0); ! 648: printf ("[on line]"); ! 649: } ! 650: else printf ("[off line]"); ! 651: } ! 652: ! 653: if (ib->cmd_packet) ! 654: (*ib->cmd_packet->function) (ib->cmd_packet, dev); ! 655: ! 656: ib->in_ptr = 0; ! 657: ib->in_packet = NULL; ! 658: ib->in_next = NULL; ! 659: ib->cmd_packet = NULL; ! 660: ilcmdstart(ui); ! 661: ilrstart (ui); ! 662: } ! 663:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.