1: /* 2: * @(#)if_hy.c 7.1 (Berkeley) 6/5/86 3: */ 4: 5: /* 6: * 4.2 BSD Unix Kernel - Vax Network Interface Support 7: * 8: * $Header: if_hy.c,v 10.1 84/07/22 21:02:56 steveg Exp $ 9: * $Locker: $ 10: * 11: * Modifications from Berkeley 4.2 BSD 12: * Copyright (c) 1983, Tektronix Inc. 13: * All Rights Reserved 14: * 15: * $Log: if_hy.c,v $ 16: * Revision 10.1 84/07/22 21:02:56 steveg 17: * define PI13 (moved from if_hyreg.h, somehow got dropped in the process) 18: * rework hywatch to check for power fails first 19: * 20: * Revision 10.0 84/06/30 19:54:27 steveg 21: * Big Build 22: * 23: * Revision 3.17 84/06/20 19:20:28 steveg 24: * increment hy_ntime in hywatch 25: * print out state name, csr, last command, and hy_flags when watchdog timer 26: * expires 27: * 28: * Revision 3.16 84/06/20 19:09:34 steveg 29: * turn on continuous logging by default 30: * 31: * Revision 3.15 84/05/30 22:19:09 steveg 32: * changes to reflect new layout ot statistics data 33: * 34: * Revision 3.14 84/05/30 19:25:15 steveg 35: * move driver states to if_hy.h so log printing programs can use them 36: * 37: * Revision 3.13 84/05/30 17:13:26 steveg 38: * make it compile 39: * 40: * Revision 3.12 84/05/30 13:46:16 steveg 41: * rework logging 42: * 43: * Revision 3.11 84/05/18 19:35:02 steveg 44: * clear IFF_RUNNING and IFF_UP on unibus reset to force resource allocation 45: * by the init routine 46: * 47: * Revision 3.10 84/05/04 12:14:44 steveg 48: * more rework to make it actually work under 4.2 49: * 50: * Revision 3.9 84/05/01 23:34:52 steveg 51: * fix typo so it compiles (unit -> ui->ui_unit) 52: * 53: * Revision 3.8 84/05/01 23:18:30 steveg 54: * changes after talking with rickk 55: * - check power off more closely 56: * - support remote loopback through A710 adapters 57: * - IMPLINK -> HYLINK 58: * - return EHOSTUNREACH on hyroute failure 59: * - bump if_collisions on abnormal interrupts that aren't input or output 60: * 61: * 62: */ 63: 64: 65: #include "hy.h" 66: #if NHY > 0 67: 68: /* 69: * Network Systems Copropration Hyperchanel interface 70: */ 71: #include "machine/pte.h" 72: 73: #include "param.h" 74: #include "systm.h" 75: #include "mbuf.h" 76: #include "buf.h" 77: #include "protosw.h" 78: #include "socket.h" 79: #include "vmmac.h" 80: #include "errno.h" 81: #include "time.h" 82: #include "kernel.h" 83: #include "ioctl.h" 84: 85: #include "../net/if.h" 86: #include "../net/netisr.h" 87: #include "../net/route.h" 88: 89: #ifdef INET 90: #include "../netinet/in.h" 91: #include "../netinet/in_systm.h" 92: #include "../netinet/in_var.h" 93: #include "../netinet/ip.h" 94: #endif 95: 96: #include "../vax/cpu.h" 97: #include "../vax/mtpr.h" 98: #include "../vaxuba/ubareg.h" 99: #include "../vaxuba/ubavar.h" 100: 101: /* 102: * configuration specific paramters 103: * - change as appropriate for particular installaions 104: */ 105: #define HYROUTE 106: #define HYELOG 107: #define HYLOG 108: #define HYMTU 1100 109: #define PI13 110: 111: #ifdef DEBUG 112: #define HYLOG 113: #endif 114: 115: #include "if_hy.h" 116: #include "if_hyreg.h" 117: #include "if_uba.h" 118: 119: int hyprobe(), hyattach(), hyinit(), hyioctl(); 120: int hyoutput(), hyreset(), hywatch(); 121: struct uba_device *hyinfo[NHY]; 122: u_short hystd[] = { 0772410, 0 }; 123: struct uba_driver hydriver = 124: { hyprobe, 0, hyattach, 0, hystd, "hy", hyinfo }; 125: 126: /* 127: * Hyperchannel software status per interface. 128: * 129: * Each interface is referenced by a network interface structure, 130: * hy_if, which the routing code uses to locate the interface. 131: * This structure contains the output queue for the interface, its address, ... 132: * We also have, for each interface, a UBA interface structure, which 133: * contains information about the UNIBUS resources held by the interface: 134: * map registers, buffered data paths, etc. Information is cached in this 135: * structure for use by the if_uba.c routines in running the interface 136: * efficiently. 137: */ 138: struct hy_softc { 139: struct ifnet hy_if; /* network-visible interface */ 140: struct ifuba hy_ifuba; /* UNIBUS resources */ 141: short hy_flags; /* flags */ 142: short hy_state; /* driver state */ 143: u_short hy_host; /* local host number */ 144: struct in_addr hy_addr; /* internet address */ 145: int hy_olen; /* packet length on output */ 146: int hy_lastwcr; /* last command's word count */ 147: short hy_savedstate; /* saved for reissue after status */ 148: short hy_savedcmd; /* saved command for reissue */ 149: int hy_savedcount; /* saved byte count for reissue */ 150: int hy_savedaddr; /* saved unibus address for reissue */ 151: int hy_ntime; /* number of timeouts since last cmd */ 152: int hy_retry; /* retry counter */ 153: struct hy_stat hy_stat; /* statistics */ 154: struct hy_status hy_status; /* status */ 155: } hy_softc[NHY]; 156: 157: #ifdef HYELOG 158: u_long hy_elog[HYE_SIZE]; 159: #endif 160: 161: #ifdef HYLOG 162: struct hy_log hy_log; 163: #endif 164: 165: #ifdef HYROUTE 166: struct hy_route hy_route[NHY]; 167: #endif 168: 169: #ifdef DEBUG 170: #define printL printf 171: #define printD if (hy_debug_flag) printf 172: int hy_debug_flag = 0; 173: /* 174: * hy_nodebug bit 0x01 set hy_debug_flag on hycancel 175: * hy_nodebug bit 0x02 set hy_debug_flag on command reissue 176: * hy_nodebug bit 0x04 set hy_debug_flag on abnormal interrupt 177: */ 178: int hy_nodebug = 0x0; 179: #endif 180: 181: #define SCANINTERVAL 10 /* seconds */ 182: #define MAXINTERVAL 20 /* seconds (max action) */ 183: 184: /* 185: * Cause a device interrupt. This code uses a buffer starting at 186: * location zero on the unibus (which is already mapped by the 187: * autoconfigure code in the kernel). 188: */ 189: hyprobe(reg) 190: caddr_t reg; 191: { 192: register int br, cvec; /* r11, r10 value-result */ 193: register struct hydevice *addr = (struct hydevice *) reg; 194: 195: #ifdef lint 196: br = 0; cvec = br; br = cvec; 197: hyint(0); 198: #endif 199: /* 200: * request adapter status to a buffer starting at unibus location 0 201: */ 202: addr->hyd_bar = 0; 203: addr->hyd_wcr = -((sizeof(struct hy_status) + 1) >> 1); 204: addr->hyd_dbuf = HYF_STATUS; 205: #ifdef PI13 206: addr->hyd_csr |= S_GO | S_IE | S_IATTN; 207: #else 208: addr->hyd_csr |= S_GO | S_IE; 209: #endif 210: DELAY(10000); 211: #ifdef PI13 212: addr->hyd_csr |= S_CLRINT; /* clear any stacked interrupts */ 213: #endif 214: addr->hyd_csr &= ~(S_IE | S_CLRINT); /* disable further interrupts */ 215: return(sizeof(struct hydevice)); 216: } 217: 218: /* 219: * Interface exists: make available by filling in network interface 220: * record. System will initialize the interface when it is ready 221: * to accept packets. 222: */ 223: hyattach(ui) 224: struct uba_device *ui; 225: { 226: register struct hy_softc *is = &hy_softc[ui->ui_unit]; 227: register struct ifnet *ifp = &is->hy_if; 228: 229: ifp->if_unit = ui->ui_unit; 230: ifp->if_name = "hy"; 231: ifp->if_mtu = HYMTU; 232: is->hy_state = STARTUP; /* don't allow state transitions yet */ 233: ifp->if_init = hyinit; 234: ifp->if_ioctl = hyioctl; 235: ifp->if_output = hyoutput; 236: ifp->if_reset = hyreset; 237: ifp->if_watchdog = hywatch; 238: ifp->if_timer = SCANINTERVAL; 239: is->hy_ifuba.ifu_flags = UBA_CANTWAIT; 240: #ifdef notdef 241: is->hy_ifuba.ifu_flags |= UBA_NEEDBDP; 242: #endif 243: if_attach(ifp); 244: } 245: 246: /* 247: * Reset of interface after UNIBUS reset. 248: * If interface is on specified uba, reset its state. 249: */ 250: hyreset(unit, uban) 251: int unit, uban; 252: { 253: register struct uba_device *ui; 254: register struct hy_softc *is; 255: 256: if (unit >= NHY || (ui = hyinfo[unit]) == 0 || ui->ui_alive == 0 || 257: ui->ui_ubanum != uban) 258: return; 259: printf(" hy%d", unit); 260: is = &hy_softc[unit]; /* force unibus resource allocation */ 261: is->hy_if.if_flags &= ~(IFF_UP|IFF_RUNNING); 262: hyinit(unit); 263: } 264: 265: /* 266: * Initialization of interface; clear recorded pending 267: * operations, and reinitialize UNIBUS usage. 268: */ 269: hyinit(unit) 270: int unit; 271: { 272: register struct hy_softc *is = &hy_softc[unit]; 273: register struct uba_device *ui = hyinfo[unit]; 274: register struct mbuf *m; 275: int s; 276: 277: if (is->hy_if.if_addrlist == 0) /* address still unknown */ 278: return; 279: if (is->hy_if.if_flags & IFF_RUNNING) /* just reset the device */ 280: goto justreset; 281: if (if_ubainit(&is->hy_ifuba, ui->ui_ubanum, 282: sizeof (struct hym_hdr), (int)btoc(HYMTU)) == 0) { 283: #ifdef DEBUG 284: if (hy_nodebug & 4) 285: hy_debug_flag = 1; 286: #endif 287: printf("hy%d: can't initialize\n", unit); 288: is->hy_if.if_flags &= ~IFF_UP; 289: return; 290: } 291: is->hy_if.if_flags |= IFF_RUNNING; 292: 293: justreset: 294: /* 295: * remove any left over outgoing messages, reset the hardware and 296: * start the state machine 297: */ 298: s = splimp(); 299: #ifdef HYLOG 300: hylog(HYL_RESET, 0, (char *)0); 301: #endif 302: is->hy_state = IDLE; 303: is->hy_flags = RQ_STATUS | RQ_STATISTICS | RQ_MARKUP; 304: is->hy_retry = 0; 305: for(;;) { 306: IF_DEQUEUE(&is->hy_if.if_snd, m); 307: if (m != NULL) 308: m_freem(m); 309: else 310: break; 311: } 312: hycancel(ui); /* also bumps the state machine */ 313: splx(s); 314: } 315: 316: /* 317: * Issue a command to the adapter 318: */ 319: hystart(ui, cmd, count, ubaddr) 320: struct uba_device *ui; 321: int cmd, count, ubaddr; 322: { 323: register struct hy_softc *is = &hy_softc[ui->ui_unit]; 324: register struct hydevice *addr = (struct hydevice *)ui->ui_addr; 325: 326: #ifdef DEBUG 327: printD("hy%d: hystart cmd = 0x%x count=%d ubaddr=0x%x\n", 328: ui->ui_unit, cmd, count, ubaddr); 329: printD("hy%d: - csr = 0x%b, bar = 0x%x, wcr = 0x%x\n", 330: ui->ui_unit, addr->hyd_csr, HY_CSR_BITS, addr->hyd_bar, 331: addr->hyd_wcr); 332: #endif 333: if (((is->hy_flags & RQ_REISSUE) == 0) && 334: (cmd != HYF_STATUS) && (cmd != HYF_END_OP) && (cmd != HYF_RSTATS)) { 335: is->hy_savedstate = is->hy_state; 336: is->hy_savedcmd = cmd; 337: is->hy_savedcount = count; 338: is->hy_savedaddr = ubaddr; 339: } 340: #ifdef PI13 341: if (addr->hyd_csr & S_POWEROFF) { 342: printf("hy%d: \"Soft\" Adapter Power Failure (hystart)\n", ui->ui_unit); 343: addr->hyd_csr |= S_POWEROFF; 344: DELAY(100); 345: if (addr->hyd_csr & S_POWEROFF) { 346: printf( "hy%d: \"Hard\" Adapter Power Failure, Network Shutdown (hystart)\n", ui->ui_unit); 347: if_down(&is->hy_if); 348: is->hy_if.if_flags &= ~IFF_UP; 349: is->hy_state = STARTUP; 350: } else { 351: printf("hy%d: Adapter Power Restored (hystart)\n", ui->ui_unit); 352: } 353: return; 354: } 355: #endif 356: addr->hyd_bar = ubaddr & 0xffff; 357: addr->hyd_wcr = is->hy_lastwcr = -((count+1) >> 1); 358: addr->hyd_dbuf = cmd; 359: #ifdef PI13 360: addr->hyd_csr = ((ubaddr >> XBASHIFT) & S_XBA) | S_GO | S_IE | S_IATTN; 361: #else 362: addr->hyd_csr = ((ubaddr >> XBASHIFT) & S_XBA) | S_GO | S_IE; 363: #endif 364: #ifdef DEBUG 365: printD("hy%d: exit hystart - csr = 0x%b, bar = 0x%x, wcr = 0x%x\n", 366: ui->ui_unit, addr->hyd_csr, HY_CSR_BITS, addr->hyd_bar, 367: addr->hyd_wcr); 368: #endif 369: #ifdef HYLOG 370: { 371: struct { 372: u_char hcmd; 373: u_char hstate; 374: short hcount; 375: } hcl; 376: 377: hcl.hcmd = cmd; 378: hcl.hstate = is->hy_state; 379: hcl.hcount = count; 380: hylog(HYL_CMD, sizeof(hcl), (char *)&hcl); 381: } 382: #endif 383: is->hy_ntime = 0; 384: } 385: 386: int hyint_active = 0; /* set during hy interrupt */ 387: /* 388: * Hyperchannel interface interrupt. 389: * 390: * An interrupt can occur for many reasons. Examine the status of 391: * the hyperchannel status bits to determine what to do next. 392: * 393: * If input error just drop packet. 394: * Otherwise purge input buffered data path and examine 395: * packet to determine type. Othewise decapsulate 396: * packet based on type and pass to type specific higher-level 397: * input routine. 398: */ 399: hyint(unit) 400: int unit; 401: { 402: register struct hy_softc *is = &hy_softc[unit]; 403: register struct uba_device *ui = hyinfo[unit]; 404: register struct hydevice *addr = (struct hydevice *)ui->ui_addr; 405: 406: if (hyint_active) 407: panic("RECURSIVE HYPERCHANNEL INTERRUPT"); 408: hyint_active++; 409: #ifdef DEBUG 410: printD("hy%d: hyint enter - csr = 0x%b, bar = 0x%x, wcr = 0x%x\n", 411: unit, addr->hyd_csr, HY_CSR_BITS, addr->hyd_bar, addr->hyd_wcr); 412: #endif 413: #ifdef HYLOG 414: logit: 415: { 416: struct { 417: u_char hstate; 418: u_char hflags; 419: short hcsr; 420: short hwcr; 421: } hil; 422: hil.hstate = is->hy_state; 423: hil.hflags = is->hy_flags; 424: hil.hcsr = addr->hyd_csr; 425: hil.hwcr = addr->hyd_wcr; 426: hylog(HYL_INT, sizeof(hil), (char *)&hil); 427: } 428: #endif 429: if (HYS_ERROR(addr) && ((addr->hyd_csr & S_ATTN) == 0)) { 430: /* 431: * Error bit set, some sort of error in the interface. 432: * 433: * The adapter sets attn on command completion so that's not 434: * a real error even though the interface considers it one. 435: */ 436: #ifdef DEBUG 437: if (hy_nodebug & 4) 438: hy_debug_flag = 1; 439: #endif 440: printf("csr = 0x%b\nbar = 0x%x\nwcr = 0x%x\n", 441: addr->hyd_csr, HY_CSR_BITS, addr->hyd_bar, 442: addr->hyd_wcr); 443: if (addr->hyd_csr & S_NEX) { 444: printf("hy%d: NEX - Non Existant Memory\n", unit); 445: #ifdef PI13 446: addr->hyd_csr |= S_NEX; /* as per PI13 manual */ 447: #else 448: addr->hyd_csr &= ~S_NEX; 449: #endif 450: hycancel(ui); 451: #ifdef PI13 452: } else if (addr->hyd_csr & S_POWEROFF) { 453: printf("hy%d: \"Soft\" Adapter Power Failure (hyint)\n", unit); 454: addr->hyd_csr |= S_POWEROFF; 455: DELAY(100); 456: if (addr->hyd_csr & S_POWEROFF) { 457: printf( "hy%d: \"Hard\" Adapter Power Failure, Network Shutdown (hyint)\n", unit); 458: if_down(&is->hy_if); 459: is->hy_if.if_flags &= ~IFF_UP; 460: is->hy_state = STARTUP; 461: } else { 462: printf("hy%d: Adapter Power Restored (hyint)\n", unit); 463: } 464: #endif 465: } else { 466: printf("hy%d: BAR overflow\n", unit); 467: hycancel(ui); 468: } 469: } else if (HYS_NORMAL(addr)) { 470: /* 471: * Normal interrupt, bump state machine unless in state 472: * waiting and no data present (assumed to be word count 473: * zero interrupt or other hardware botch). 474: */ 475: if (is->hy_state != WAITING || HYS_RECVDATA(addr)) 476: hyact(ui); 477: } else if (HYS_ABNORMAL(addr)) { 478: /* 479: * Abnormal termination. 480: * bump error counts, retry the last function 481: * 'MAXRETRY' times before kicking the bucket. 482: * 483: * Don't reissue the cmd if in certain states, abnormal 484: * on a reissued cmd or max retry exceeded. 485: */ 486: #ifdef HYLOG 487: if (hy_log.hyl_enable != hy_log.hyl_onerr) { 488: hy_log.hyl_enable = hy_log.hyl_onerr; 489: goto logit; 490: } 491: #endif 492: #ifdef DEBUG 493: if (hy_nodebug & 4) 494: hy_debug_flag = 1; 495: printD("hy%d: abnormal interrupt, driver state \"%s\" (%d)\n", 496: unit, hy_state_names[is->hy_state], is->hy_state); 497: printD("\tflags 0x%x olen %d lastwcr %d retry %d\n", 498: is->hy_flags, is->hy_olen, is->hy_lastwcr, is->hy_retry); 499: printD("\tsaved: state %d count %d cmd 0x%x ptr 0x%x\n", 500: is->hy_savedstate, is->hy_savedcount, 501: is->hy_savedaddr, is->hy_savedcmd); 502: #endif 503: #ifdef PI13 504: addr->hyd_csr &= ~S_C; /* clear the damned PI-13 */ 505: #endif 506: if (is->hy_state == XMITSENT || is->hy_state == XMITDATASENT) 507: is->hy_if.if_oerrors++; 508: else if (is->hy_state == RECVSENT || is->hy_state == RECVDATASENT) 509: is->hy_if.if_ierrors++; 510: else 511: is->hy_if.if_collisions++; /* other errors */ 512: if (is->hy_state == XMITDATASENT || 513: is->hy_state == RECVSENT || 514: is->hy_state == RECVDATASENT || 515: (is->hy_flags & RQ_REISSUE) != 0 || is->hy_retry > MAXRETRY) 516: hycancel(ui); 517: else { 518: #ifdef DEBUG 519: if (hy_nodebug & 2) 520: hy_debug_flag = 1; 521: #endif 522: is->hy_retry++; 523: is->hy_flags |= RQ_ENDOP | RQ_STATUS | RQ_REISSUE; 524: is->hy_state = IDLE; 525: hyact(ui); 526: } 527: } else { 528: /* 529: * Interrupt is neither normal, abnormal, or interface error. 530: * Ignore it. It's either stacked or a word count 0. 531: */ 532: #ifdef HYLOG 533: if (hy_log.hyl_enable != hy_log.hyl_onerr) { 534: hy_log.hyl_enable = hy_log.hyl_onerr; 535: goto logit; 536: } 537: #endif 538: #ifdef DEBUG 539: printD("hy%d: possible stacked interrupt ignored\n", unit); 540: #endif 541: } 542: #ifdef DEBUG 543: printD("hy%d: hyint exit\n\n", unit); 544: #endif 545: hyint_active = 0; 546: 547: } 548: 549: int hyoutprint = 0; 550: 551: /* 552: * Encapsulate a packet of type family for the local net. 553: */ 554: hyoutput(ifp, m0, dst) 555: struct ifnet *ifp; 556: struct mbuf *m0; 557: struct sockaddr *dst; 558: { 559: register struct hym_hdr *hym; 560: register struct mbuf *m; 561: register char *mp; 562: int dlen; /* packet size, incl hardware header, but not sw header */ 563: int error = 0; 564: int s; 565: 566: /* 567: * Calculate packet length for later deciding whether it will fit 568: * in a message proper or we also need associated data. 569: */ 570: dlen = 0; 571: for (m = m0; m; m = m->m_next) 572: dlen += m->m_len; 573: m = m0; 574: if (dst->sa_family == AF_HYLINK) { /* don't add header */ 575: dlen -= HYM_SWLEN; 576: goto headerexists; 577: } 578: 579: /* 580: * Add the software and hardware hyperchannel headers. 581: * If there's not enough space in the first mbuf, allocate another. 582: * If that should fail, drop this sucker. 583: * No extra space for headers is allocated. 584: */ 585: mp = mtod(m, char *); /* save pointer to real message */ 586: if (m->m_off > MMAXOFF || 587: MMINOFF + sizeof(struct hym_hdr) > m->m_off) { 588: m = m_get(M_DONTWAIT, MT_HEADER); 589: if (m == 0) { 590: m = m0; 591: error = ENOBUFS; 592: goto drop; 593: } 594: m->m_next = m0; 595: m->m_off = MMINOFF; 596: m->m_len = sizeof(struct hym_hdr); 597: } else { 598: m->m_off -= sizeof(struct hym_hdr); 599: m->m_len += sizeof(struct hym_hdr); 600: } 601: 602: dlen += sizeof(struct hym_hdr) - HYM_SWLEN; 603: 604: hym = mtod(m, struct hym_hdr *); 605: 606: bzero((caddr_t)hym, sizeof(struct hym_hdr)); 607: 608: switch(dst->sa_family) { 609: 610: #ifdef INET 611: case AF_INET: { 612: int i; 613: 614: /* 615: * if loopback address, swizzle ip header so when 616: * it comes back it looks like it was addressed to us 617: */ 618: i = hyroute(ifp, (u_long)in_lnaof(((struct sockaddr_in *)dst)->sin_addr), hym); 619: if (i < 0) 620: goto notfound; 621: if (i > 0) { 622: struct in_addr temp; 623: 624: temp.s_addr = ((struct ip *)mp)->ip_dst.s_addr; 625: ((struct ip *)mp)->ip_dst.s_addr = ((struct ip *)mp)->ip_src.s_addr; 626: ((struct ip *)mp)->ip_src.s_addr = temp.s_addr; 627: } 628: /* 629: * If entire packet won't fit in message proper, just 630: * send hyperchannel hardware header and ip header in 631: * message proper. 632: * 633: * This insures that the associated data is at least a 634: * TCP/UDP header in length and thus prevents potential 635: * problems with very short word counts. 636: */ 637: if (dlen > MPSIZE) 638: hym->hym_mplen = sizeof(struct hy_hdr) + (((struct ip *)mp)->ip_hl << 2); 639: hym->hym_type = HYLINK_IP; 640: break; 641: } 642: #endif 643: 644: default: 645: printf("hy%d: can't handle af%d\n", ifp->if_unit, 646: dst->sa_family); 647: error = EAFNOSUPPORT; 648: goto drop; 649: } 650: 651: 652: headerexists: 653: 654: /* 655: * insure message proper is below the maximum 656: */ 657: if (hym->hym_mplen > MPSIZE || (dlen > MPSIZE && hym->hym_mplen == 0)) 658: hym->hym_mplen = MPSIZE; 659: 660: hym->hym_from = htons(hy_softc[ifp->if_unit].hy_host); 661: if (hym->hym_mplen) 662: hym->hym_ctl |= H_ASSOC; 663: else 664: hym->hym_ctl &= ~H_ASSOC; 665: if (hyoutprint) printf("hy%d: output mplen=%x ctl=%x access=%x to=%x from=%x param=%x type=%x\n", 666: ifp->if_unit, hym->hym_mplen, hym->hym_ctl, 667: hym->hym_access, hym->hym_to, hym->hym_from, 668: hym->hym_param, hym->hym_type); 669: #ifdef DEBUG 670: printD("hy%d: output mplen=%x ctl=%x access=%x to=%x from=%x param=%x type=%x\n", 671: ifp->if_unit, hym->hym_mplen, hym->hym_ctl, 672: hym->hym_access, hym->hym_to, hym->hym_from, 673: hym->hym_param, hym->hym_type); 674: #endif 675: s = splimp(); 676: if (IF_QFULL(&ifp->if_snd)) { 677: IF_DROP(&ifp->if_snd); 678: error = ENOBUFS; 679: splx(s); 680: goto drop; 681: } 682: IF_ENQUEUE(&ifp->if_snd, m); 683: if (hy_softc[ifp->if_unit].hy_state == WAITING) 684: hyact(hyinfo[ifp->if_unit]); 685: splx(s); 686: return (0); 687: notfound: 688: error = EHOSTUNREACH; 689: drop: 690: m_freem(m); 691: return (error); 692: } 693: 694: int 695: hyroute(ifp, dest, hym) 696: register struct ifnet *ifp; 697: u_long dest; 698: register struct hym_hdr *hym; 699: { 700: #ifdef HYROUTE 701: register struct hy_route *rt = &hy_route[ifp->if_unit]; 702: register struct hyr_hash *rhash; 703: register int i; 704: #endif 705: 706: hym->hym_param = 0; 707: #ifdef HYROUTE 708: if (rt->hyr_lasttime != 0) { 709: i = HYRHASH(dest); 710: rhash = &rt->hyr_hash[i]; 711: i = 0; 712: while (rhash->hyr_key != dest) { 713: if (rhash->hyr_flags == 0 || i > HYRSIZE) 714: return(-1); 715: rhash++; i++; 716: if (rhash >= &rt->hyr_hash[HYRSIZE]) 717: rhash = &rt->hyr_hash[0]; 718: } 719: if (rhash->hyr_flags & HYR_GATE) { 720: i = rhash->hyr_nextgate; 721: if (i >= rhash->hyr_egate) 722: rhash->hyr_nextgate = rhash->hyr_pgate; 723: else 724: rhash->hyr_nextgate++; 725: rhash = &rt->hyr_hash[rt->hyr_gateway[i]]; 726: if ((rhash->hyr_flags & HYR_DIR) == 0) 727: return(-1); 728: } else if (rhash->hyr_flags & HYR_LOOP) { 729: hym->hym_param = H_LOOPBK; /* adapter loopback */ 730: } else if (rhash->hyr_flags & HYR_RLOOP) { 731: hym->hym_param = H_RLOOPBK; /* A710 remote loopback */ 732: } 733: hym->hym_ctl = rhash->hyr_ctl; 734: hym->hym_access = rhash->hyr_access; 735: hym->hym_to = rhash->hyr_dst; 736: } else { 737: #endif 738: hym->hym_ctl = H_XTRUNKS | H_RTRUNKS; 739: hym->hym_access = 0; 740: hym->hym_to = htons((u_short)dest); 741: if (dest & 0x010000) 742: hym->hym_param = H_LOOPBK; /* adapter loopback */ 743: else if (dest & 0x020000) 744: hym->hym_param = H_RLOOPBK; /* A710 remote loopback */ 745: #ifdef HYROUTE 746: } 747: #endif 748: 749: if (hym->hym_param == 0) 750: return(0); 751: else 752: return(1); 753: } 754: 755: hyact(ui) 756: register struct uba_device *ui; 757: { 758: register struct hy_softc *is = &hy_softc[ui->ui_unit]; 759: register struct hydevice *addr = (struct hydevice *)ui->ui_addr; 760: 761: actloop: 762: #ifdef DEBUG 763: printD("hy%d: hyact, enter state \"%s\"\n", ui->ui_unit, 764: hy_state_names[is->hy_state]); 765: #endif 766: switch (is->hy_state) { 767: 768: case STARTUP: 769: goto endintr; 770: 771: case IDLE: { 772: register rq = is->hy_flags; 773: 774: if (rq & RQ_STATUS) { 775: is->hy_flags &= ~RQ_STATUS; 776: is->hy_state = STATSENT; 777: hystart(ui, HYF_STATUS, sizeof (is->hy_status), 778: is->hy_ifuba.ifu_r.ifrw_info); 779: } else if (rq & RQ_ENDOP) { 780: is->hy_flags &= ~RQ_ENDOP; 781: is->hy_state = ENDOPSENT; 782: hystart(ui, HYF_END_OP, 0, 0); 783: } else if (rq & RQ_STATISTICS) { 784: is->hy_flags &= ~RQ_STATISTICS; 785: is->hy_state = RSTATSENT; 786: hystart(ui, HYF_RSTATS, sizeof (is->hy_stat), 787: is->hy_ifuba.ifu_r.ifrw_info); 788: } else if (HYS_RECVDATA(addr)) { 789: is->hy_state = RECVSENT; 790: is->hy_retry = 0; 791: hystart(ui, HYF_INPUTMSG, MPSIZE, is->hy_ifuba.ifu_r.ifrw_info + HYM_SWLEN); 792: } else if (rq & RQ_REISSUE) { 793: is->hy_flags &= ~RQ_REISSUE; 794: is->hy_state = is->hy_savedstate; 795: #ifdef DEBUG 796: printD("hy%d: reissue cmd=0x%x count=%d", 797: ui->ui_unit, is->hy_savedcmd, is->hy_savedcount); 798: printD(" ubaddr=0x%x retry=%d\n", 799: is->hy_savedaddr, is->hy_retry); 800: #endif 801: hystart(ui, is->hy_savedcmd, is->hy_savedcount, 802: is->hy_savedaddr); 803: } else { 804: register struct mbuf *m; 805: 806: IF_DEQUEUE(&is->hy_if.if_snd, m); 807: if (m != NULL) { 808: register struct hym_hdr *hym; 809: register int mplen; 810: register int cmd; 811: 812: is->hy_state = XMITSENT; 813: is->hy_retry = 0; 814: hym = mtod(m, struct hym_hdr *); 815: #ifdef HYLOG 816: hylog(HYL_XMIT, sizeof(struct hym_hdr), 817: (char *)hym); 818: #endif 819: mplen = hym->hym_mplen; 820: if (hym->hym_to_adapter == hym->hym_from_adapter) 821: cmd = HYF_XMITLOCMSG; 822: else 823: cmd = HYF_XMITMSG; 824: #ifdef DEBUG 825: printD("hy%d: hym_hdr = ", ui->ui_unit); 826: if (hy_debug_flag) 827: hyprintdata((char *)hym, 828: sizeof (struct hym_hdr)); 829: #endif 830: is->hy_olen = if_wubaput(&is->hy_ifuba, m) - HYM_SWLEN; 831: if (is->hy_ifuba.ifu_flags & UBA_NEEDBDP) 832: UBAPURGE(is->hy_ifuba.ifu_uba, 833: is->hy_ifuba.ifu_w.ifrw_bdp); 834: #ifdef DEBUG 835: printD( 836: "hy%d: sending packet (mplen = %d, hy_olen = %d) data = ", 837: ui->ui_unit, mplen, is->hy_olen); 838: if (hy_debug_flag) 839: hyprintdata( 840: is->hy_ifuba.ifu_w.ifrw_addr, 841: is->hy_olen + HYM_SWLEN); 842: #endif 843: if (mplen == 0) { 844: is->hy_flags &= ~RQ_XASSOC; 845: mplen = is->hy_olen; 846: } else { 847: is->hy_flags |= RQ_XASSOC; 848: } 849: hystart(ui, cmd, mplen, is->hy_ifuba.ifu_w.ifrw_info + HYM_SWLEN); 850: } else if (rq & RQ_MARKDOWN) { 851: is->hy_flags &= ~(RQ_MARKUP | RQ_MARKDOWN); 852: is->hy_state = MARKPORT; 853: is->hy_retry = 0; 854: /* 855: * Port number is taken from status data 856: */ 857: hystart(ui, 858: (int)(HYF_MARKP0|(PORTNUM(&is->hy_status)<<2)), 859: 0, 0); 860: } else if (rq & RQ_MARKUP) { 861: register struct ifnet *ifp = &is->hy_if; 862: 863: is->hy_flags &= ~RQ_MARKUP; 864: is->hy_retry = 0; 865: /* 866: * Fill in the host number 867: * from the status buffer 868: */ 869: printf( 870: "hy%d: unit number 0x%x port %d type %x microcode level 0x%x\n", 871: ui->ui_unit, 872: is->hy_stat.hyc_uaddr, 873: PORTNUM(&is->hy_status), 874: (is->hy_stat.hyc_atype[0]<<8) | 875: is->hy_stat.hyc_atype[1], 876: is->hy_stat.hyc_atype[2]); 877: 878: is->hy_host = 879: (is->hy_stat.hyc_uaddr << 8) | 880: PORTNUM(&is->hy_status); 881: ifp->if_flags |= IFF_UP; 882: #ifdef HYLOG 883: hylog(HYL_UP, 0, (char *)0); 884: #endif 885: } else { 886: is->hy_state = WAITING; 887: is->hy_retry = 0; 888: hystart(ui, HYF_WAITFORMSG, 0, 0); 889: } 890: } 891: break; 892: } 893: 894: case STATSENT: 895: bcopy(is->hy_ifuba.ifu_r.ifrw_addr, (caddr_t)&is->hy_status, 896: sizeof (struct hy_status)); 897: #ifdef DEBUG 898: printD("hy%d: status - %x %x %x %x %x %x %x %x\n", 899: ui->ui_unit, is->hy_status.hys_gen_status, 900: is->hy_status.hys_last_fcn, 901: is->hy_status.hys_resp_trunk, 902: is->hy_status.hys_status_trunk, 903: is->hy_status.hys_recd_resp, 904: is->hy_status.hys_error, 905: is->hy_status.hys_caddr, 906: is->hy_status.hys_pad); 907: #endif 908: is->hy_state = IDLE; 909: #ifdef HYLOG 910: hylog(HYL_STATUS, sizeof (struct hy_status), 911: (char *)&is->hy_status); 912: #endif 913: #ifdef HYELOG 914: { 915: register int i; 916: 917: i = is->hy_status.hys_error; 918: if (i > HYE_MAX) 919: i = HYE_MAX; 920: switch (is->hy_status.hys_last_fcn) { 921: case HYF_XMITLOCMSG: 922: i += HYE_MAX+1; /* fall through */ 923: case HYF_XMITLSTDATA: 924: i += HYE_MAX+1; /* fall through */ 925: case HYF_XMITMSG: 926: i += HYE_MAX+1; 927: } 928: hy_elog[i]++; 929: } 930: #endif 931: break; 932: 933: case RSTATSENT: { 934: register struct hy_stat *p = 935: (struct hy_stat *)is->hy_ifuba.ifu_r.ifrw_addr; 936: 937: bcopy((caddr_t)p, (caddr_t)&is->hy_stat, sizeof(struct hy_stat)); 938: #ifdef DEBUG 939: 940: printD("hy%d: statistics - df0 %d df1 %d df2 %d df3 %d\n", 941: ui->ui_unit, 942: (is->hy_stat.hyc_df0[0]<<16) | (is->hy_stat.hyc_df0[1]<<8) | is->hy_stat.hyc_df0[2], 943: (is->hy_stat.hyc_df1[0]<<16) | (is->hy_stat.hyc_df1[1]<<8) | is->hy_stat.hyc_df1[2], 944: (is->hy_stat.hyc_df2[0]<<16) | (is->hy_stat.hyc_df2[1]<<8) | is->hy_stat.hyc_df2[2], 945: (is->hy_stat.hyc_df3[0]<<16) | (is->hy_stat.hyc_df3[1]<<8) | is->hy_stat.hyc_df3[2]); 946: printD(" ret0 %d ret1 %d ret2 %d ret3 %d\n", 947: (is->hy_stat.hyc_ret0[0]<<16) | (is->hy_stat.hyc_ret0[1]<<8) | is->hy_stat.hyc_ret0[2], 948: (is->hy_stat.hyc_ret1[0]<<16) | (is->hy_stat.hyc_ret1[1]<<8) | is->hy_stat.hyc_ret1[2], 949: (is->hy_stat.hyc_ret2[0]<<16) | (is->hy_stat.hyc_ret2[1]<<8) | is->hy_stat.hyc_ret2[2], 950: (is->hy_stat.hyc_ret3[0]<<16) | (is->hy_stat.hyc_ret3[1]<<8) | is->hy_stat.hyc_ret3[2]); 951: printD(" cancel %d abort %d atype %x %x %x uaddr %x\n", 952: (is->hy_stat.hyc_cancel[0]<<8) | is->hy_stat.hyc_cancel[1], 953: (is->hy_stat.hyc_abort[0]<<8) | is->hy_stat.hyc_abort[1], 954: is->hy_stat.hyc_atype[0], is->hy_stat.hyc_atype[1], 955: is->hy_stat.hyc_atype[2], is->hy_stat.hyc_uaddr); 956: #endif 957: is->hy_state = IDLE; 958: #ifdef HYLOG 959: hylog(HYL_STATISTICS, sizeof (struct hy_stat), 960: (char *)&is->hy_stat); 961: #endif 962: break; 963: } 964: 965: case CLEARSENT: 966: is->hy_state = IDLE; 967: break; 968: 969: case ENDOPSENT: 970: is->hy_state = IDLE; 971: break; 972: 973: case RECVSENT: { 974: register struct hym_hdr *hym; 975: register unsigned len; 976: 977: if (is->hy_ifuba.ifu_flags & UBA_NEEDBDP) 978: UBAPURGE(is->hy_ifuba.ifu_uba, 979: is->hy_ifuba.ifu_r.ifrw_bdp); 980: hym = (struct hym_hdr *) (is->hy_ifuba.ifu_r.ifrw_addr); 981: len = (0xffff & (addr->hyd_wcr - is->hy_lastwcr)) << 1; 982: if (len > MPSIZE) { 983: printf("hy%d: RECVD MP > MPSIZE (%d)\n", 984: ui->ui_unit, len); 985: is->hy_state = IDLE; 986: #ifdef DEBUG 987: hy_debug_flag = 1; 988: printD("hy%d: csr = 0x%b, bar = 0x%x, wcr = 0x%x\n", 989: ui->ui_unit, addr->hyd_csr, HY_CSR_BITS, 990: addr->hyd_bar, addr->hyd_wcr); 991: #endif 992: } 993: hym->hym_mplen = len; 994: #ifdef DEBUG 995: printD("hy%d: recvd mp, len = %d, data = ", ui->ui_unit, len); 996: if (hy_debug_flag) 997: hyprintdata((char *)hym, len + HYM_SWLEN); 998: #endif 999: if (hym->hym_ctl & H_ASSOC) { 1000: is->hy_state = RECVDATASENT; 1001: is->hy_retry = 0; 1002: hystart(ui, HYF_INPUTDATA, 1003: (int)(HYMTU + sizeof (struct hy_hdr) - len), 1004: (int)(HYM_SWLEN + is->hy_ifuba.ifu_r.ifrw_info + len)); 1005: } else { 1006: hyrecvdata(ui, hym, (int)len + HYM_SWLEN); 1007: is->hy_state = IDLE; 1008: } 1009: break; 1010: } 1011: 1012: case RECVDATASENT: { 1013: register struct hym_hdr *hym; 1014: register unsigned len; 1015: 1016: if (is->hy_ifuba.ifu_flags & UBA_NEEDBDP) 1017: UBAPURGE(is->hy_ifuba.ifu_uba, 1018: is->hy_ifuba.ifu_r.ifrw_bdp); 1019: hym = (struct hym_hdr *) (is->hy_ifuba.ifu_r.ifrw_addr); 1020: len = (0xffff & (addr->hyd_wcr - is->hy_lastwcr)) << 1; 1021: #ifdef DEBUG 1022: printD("hy%d: recvd assoc data, len = %d, data = ", 1023: ui->ui_unit, len); 1024: if (hy_debug_flag) 1025: hyprintdata((char *)hym + hym->hym_mplen, len); 1026: #endif 1027: hyrecvdata(ui, hym, (int)(len + hym->hym_mplen + HYM_SWLEN)); 1028: is->hy_state = IDLE; 1029: break; 1030: } 1031: 1032: case XMITSENT: 1033: if (is->hy_flags & RQ_XASSOC) { 1034: register int len; 1035: 1036: is->hy_flags &= ~RQ_XASSOC; 1037: is->hy_state = XMITDATASENT; 1038: is->hy_retry = 0; 1039: len = (0xffff & (addr->hyd_wcr - is->hy_lastwcr)) << 1; 1040: if (len > is->hy_olen) { 1041: printf( 1042: "hy%d: xmit error - len > hy_olen [%d > %d]\n", 1043: ui->ui_unit, len, is->hy_olen); 1044: #ifdef DEBUG 1045: hy_debug_flag = 1; 1046: #endif 1047: } 1048: hystart(ui, HYF_XMITLSTDATA, is->hy_olen - len, 1049: is->hy_ifuba.ifu_w.ifrw_info + HYM_SWLEN + len); 1050: break; 1051: } 1052: /* fall through to ... */ 1053: 1054: case XMITDATASENT: 1055: hyxmitdata(ui); 1056: is->hy_state = IDLE; 1057: break; 1058: 1059: case WAITING: /* wait for message complete or output requested */ 1060: if (HYS_RECVDATA(addr)) 1061: is->hy_state = IDLE; 1062: else { 1063: is->hy_state = CLEARSENT; 1064: is->hy_retry = 0; 1065: hystart(ui, HYF_CLRWFMSG, 0, 0); 1066: } 1067: break; 1068: 1069: case MARKPORT: 1070: is->hy_state = STARTUP; 1071: if_down(&is->hy_if); 1072: is->hy_if.if_flags &= ~IFF_UP; 1073: goto endintr; 1074: 1075: default: 1076: printf("hy%d: DRIVER BUG - INVALID STATE %d\n", 1077: ui->ui_unit, is->hy_state); 1078: panic("HYPERCHANNEL IN INVALID STATE"); 1079: /*NOTREACHED*/ 1080: } 1081: if (is->hy_state == IDLE) 1082: goto actloop; 1083: endintr: 1084: ; 1085: #ifdef DEBUG 1086: printD("hy%d: hyact, exit at \"%s\"\n", ui->ui_unit, 1087: hy_state_names[is->hy_state]); 1088: #endif 1089: } 1090: 1091: struct sockproto hypproto = { PF_HYLINK }; 1092: struct sockaddr_in hypdst = { AF_HYLINK }; 1093: struct sockaddr_in hypsrc = { AF_HYLINK }; 1094: 1095: /* 1096: * Called from device interrupt when receiving data. 1097: * Examine packet to determine type. Decapsulate packet 1098: * based on type and pass to type specific higher-level 1099: * input routine. 1100: */ 1101: hyrecvdata(ui, hym, len) 1102: struct uba_device *ui; 1103: register struct hym_hdr *hym; 1104: int len; 1105: { 1106: register struct hy_softc *is = &hy_softc[ui->ui_unit]; 1107: struct mbuf *m; 1108: register struct ifqueue *inq; 1109: 1110: is->hy_if.if_ipackets++; 1111: #ifdef DEBUG 1112: printD("hy%d: recieved packet, len = %d\n", ui->ui_unit, len); 1113: #endif 1114: #ifdef HYLOG 1115: { 1116: struct { 1117: short hlen; 1118: struct hym_hdr hhdr; 1119: } hh; 1120: hh.hlen = len; 1121: hh.hhdr = *hym; 1122: hylog(HYL_RECV, sizeof(hh), (char *)&hh); 1123: } 1124: #endif 1125: if (len > HYMTU + MPSIZE || len == 0) 1126: return; /* sanity */ 1127: /* 1128: * Pull packet off interface. 1129: */ 1130: m = if_rubaget(&is->hy_ifuba, len, 0, &is->hy_if); 1131: if (m == NULL) 1132: return; 1133: 1134: /* 1135: * if normal or adapter loopback response packet believe hym_type, 1136: * otherwise, use the raw input queue cause it's a response from an 1137: * adapter command. 1138: */ 1139: if (hym->hym_param != 0 && (u_short)hym->hym_param != 0x80ff) 1140: goto rawlinkin; 1141: 1142: switch (hym->hym_type) { 1143: 1144: #ifdef INET 1145: case HYLINK_IP: 1146: schednetisr(NETISR_IP); 1147: inq = &ipintrq; 1148: break; 1149: #endif 1150: default: 1151: rawlinkin: 1152: { 1153: struct mbuf *m0; 1154: 1155: MGET(m0, M_DONTWAIT, MT_DATA); 1156: if (m0 == 0) { 1157: m_freem(m); 1158: return; 1159: } 1160: m0->m_off = MMINOFF; 1161: m0->m_len = sizeof(struct hym_hdr); 1162: m0->m_next = m; 1163: bcopy((caddr_t)hym, mtod(m0, caddr_t), sizeof(struct hym_hdr)); 1164: m = m0; 1165: hypproto.sp_protocol = 0; 1166: hypdst.sin_addr = is->hy_addr; 1167: hypsrc.sin_addr = is->hy_addr; 1168: raw_input(m, &hypproto, (struct sockaddr *)&hypsrc, 1169: (struct sockaddr *)&hypdst); 1170: return; 1171: } 1172: } 1173: if (IF_QFULL(inq)) { 1174: IF_DROP(inq); 1175: m_freem(m); 1176: } else 1177: IF_ENQUEUE(inq, m); 1178: } 1179: 1180: /* 1181: * Transmit done, release resources, bump counters. 1182: */ 1183: hyxmitdata(ui) 1184: struct uba_device *ui; 1185: { 1186: register struct hy_softc *is = &hy_softc[ui->ui_unit]; 1187: 1188: is->hy_if.if_opackets++; 1189: if (is->hy_ifuba.ifu_xtofree) { 1190: m_freem(is->hy_ifuba.ifu_xtofree); 1191: is->hy_ifuba.ifu_xtofree = 0; 1192: } 1193: } 1194: 1195: hycancel(ui) 1196: register struct uba_device *ui; 1197: { 1198: register struct hy_softc *is = &hy_softc[ui->ui_unit]; 1199: 1200: if (is->hy_ifuba.ifu_xtofree) { 1201: m_freem(is->hy_ifuba.ifu_xtofree); 1202: is->hy_ifuba.ifu_xtofree = 0; 1203: } 1204: #ifdef HYLOG 1205: hylog(HYL_CANCEL, 0, (char *)0); 1206: #endif 1207: #ifdef DEBUG 1208: if (hy_nodebug & 1) 1209: hy_debug_flag = 1; 1210: #endif 1211: #ifdef DEBUG 1212: printD("hy%d: cancel from state \"%s\" cmd=0x%x count=%d ptr=0x%x\n", 1213: ui->ui_unit, hy_state_names[is->hy_state], is->hy_savedcmd, 1214: is->hy_savedcount, is->hy_savedaddr); 1215: printD("\tflags 0x%x olen %d lastwcr %d retry %d\n", 1216: is->hy_flags, is->hy_olen, is->hy_lastwcr, is->hy_retry); 1217: printD("\tsaved: state %d count %d ptr 0x%x cmd 0x%x\n", 1218: is->hy_savedstate, is->hy_savedcount, is->hy_savedaddr, 1219: is->hy_savedcmd); 1220: #endif 1221: is->hy_state = IDLE; 1222: is->hy_flags |= (RQ_ENDOP | RQ_STATUS); 1223: hyact(ui); 1224: } 1225: 1226: #ifdef DEBUG 1227: hyprintdata(cp, len) 1228: register char *cp; 1229: register int len; 1230: { 1231: register int count = 16; 1232: register char *fmt; 1233: static char regfmt[] = "\n\t %x"; 1234: 1235: fmt = ®fmt[2]; 1236: while (--len >= 0) { 1237: printL(fmt, *cp++ & 0xff); 1238: fmt = ®fmt[2]; 1239: if (--count <= 0) { 1240: fmt = ®fmt[0]; 1241: count = 16; 1242: } 1243: } 1244: printL("\n"); 1245: } 1246: #endif 1247: 1248: hywatch(unit) 1249: int unit; 1250: { 1251: register struct hy_softc *is = &hy_softc[unit]; 1252: register struct uba_device *ui = hyinfo[unit]; 1253: register struct hydevice *addr = (struct hydevice *)ui->ui_addr; 1254: int s; 1255: 1256: s = splimp(); 1257: #ifdef PI13 1258: if ((addr->hyd_csr & S_POWEROFF) != 0) { 1259: addr->hyd_csr |= S_POWEROFF; 1260: DELAY(100); 1261: if ((addr->hyd_csr & S_POWEROFF) == 0) { 1262: printf("hy%d: Adapter Power Restored (hywatch)\n", unit); 1263: is->hy_state = IDLE; 1264: is->hy_flags |= 1265: (RQ_MARKUP | RQ_STATISTICS | RQ_ENDOP | RQ_STATUS); 1266: hyact(ui); 1267: } 1268: } 1269: #endif 1270: if (++is->hy_ntime >= 2 && is->hy_state != WAITING && 1271: is->hy_state != STARTUP && is->hy_state != IDLE) { 1272: #ifdef HYLOG 1273: printf("hy%d: watchdog timer expired in state \"%s\"\n", unit, 1274: hy_state_names[is->hy_state]); 1275: #else 1276: printf("hy%d: watchdog timer expired in state %d\n", unit, 1277: is->hy_state); 1278: #endif 1279: printf("hy%d: last command 0x%x, flags 0x%x, csr 0x%b\n", unit, 1280: is->hy_savedcmd, is->hy_flags, addr->hyd_csr, HY_CSR_BITS); 1281: hycancel(ui); 1282: } 1283: splx(s); 1284: is->hy_if.if_timer = SCANINTERVAL; 1285: } 1286: 1287: #ifdef HYLOG 1288: hylog(code, len, ptr) 1289: int code, len; 1290: char *ptr; 1291: { 1292: register unsigned char *p; 1293: int s; 1294: 1295: s = splimp(); 1296: if (hy_log.hyl_self != &hy_log) { 1297: hy_log.hyl_eptr = &hy_log.hyl_buf[HYL_SIZE]; 1298: hy_log.hyl_ptr = &hy_log.hyl_buf[0]; 1299: hy_log.hyl_self = &hy_log; 1300: hy_log.hyl_enable = HYL_CONTINUOUS; 1301: hy_log.hyl_onerr = HYL_CONTINUOUS; 1302: hy_log.hyl_count = 0; 1303: hy_log.hyl_icount = 16; 1304: hy_log.hyl_filter = 0xffff; /* enable all */ 1305: } 1306: if (hy_log.hyl_enable == HYL_DISABLED || ((1 << code) & hy_log.hyl_filter) == 0) 1307: goto out; 1308: p = hy_log.hyl_ptr; 1309: if (p + len + 3 >= hy_log.hyl_eptr) { 1310: bzero((caddr_t)p, (unsigned)(hy_log.hyl_eptr - p)); 1311: p = &hy_log.hyl_buf[0]; 1312: if (hy_log.hyl_enable != HYL_CONTINUOUS) { 1313: hy_log.hyl_enable = HYL_DISABLED; 1314: goto out; 1315: } 1316: } 1317: *p++ = code; 1318: *p++ = len; 1319: bcopy((caddr_t)ptr, (caddr_t)p, (unsigned)len); 1320: if (hy_log.hyl_count != 0 && --hy_log.hyl_count == 0) { 1321: *p++ = '\0'; 1322: hy_log.hyl_enable = HYL_DISABLED; 1323: hy_log.hyl_count = hy_log.hyl_icount; 1324: } 1325: p += len; 1326: if (hy_log.hyl_wait != 0) { /* wakeup HYGETLOG if wanted */ 1327: if (hy_log.hyl_wait <= p - hy_log.hyl_ptr) { 1328: wakeup((caddr_t)&hy_log); 1329: hy_log.hyl_wait = 0; 1330: } else 1331: hy_log.hyl_wait -= p - hy_log.hyl_ptr; 1332: } 1333: hy_log.hyl_ptr = p; 1334: out: 1335: splx(s); 1336: } 1337: #endif 1338: 1339: /*ARGSUSED*/ 1340: hyioctl(ifp, cmd, data) 1341: register struct ifnet *ifp; 1342: int cmd; 1343: caddr_t data; 1344: { 1345: struct ifaddr *ifa = (struct ifaddr *) data; 1346: struct hyrsetget *sg = (struct hyrsetget *)data; 1347: #if defined(HYLOG) || defined(HYELOG) 1348: struct hylsetget *sgl = (struct hylsetget *)data; 1349: #endif 1350: struct hy_route *r = (struct hy_route *)&hy_route[ifp->if_unit]; 1351: int s = splimp(), error = 0; 1352: #ifdef HYLOG 1353: struct hy_softc *is = &hy_softc[ifp->if_unit]; 1354: struct { 1355: u_char hstate; 1356: u_char hflags; 1357: u_short iflags; 1358: int hcmd; 1359: int herror; 1360: u_long haddr; 1361: u_long hmisc; 1362: } hil; 1363: 1364: hil.hmisc = -1; 1365: hil.hstate = is->hy_state; 1366: hil.hflags = is->hy_flags; 1367: hil.hcmd = cmd; 1368: #endif 1369: 1370: switch(cmd) { 1371: 1372: case SIOCSIFADDR: 1373: if (ifa->ifa_addr.sa_family != AF_INET) 1374: return(EINVAL); 1375: if ((ifp->if_flags & IFF_RUNNING) == 0) 1376: hyinit(ifp->if_unit); 1377: hy_softc[ifp->if_unit].hy_addr = IA_SIN(ifa)->sin_addr; 1378: #ifdef HYLOG 1379: hil.haddr = is->hy_addr.s_addr; 1380: #endif 1381: break; 1382: 1383: case HYSETROUTE: 1384: if (!suser()) { 1385: error = EPERM; 1386: goto out; 1387: } 1388: 1389: if (sg->hyrsg_len != sizeof(struct hy_route)) { 1390: error = EINVAL; 1391: goto out; 1392: } 1393: if (copyin((caddr_t)(sg->hyrsg_ptr), (caddr_t)r, sg->hyrsg_len)) { 1394: r->hyr_lasttime = 0; /* disable further routing if trouble */ 1395: error = EFAULT; 1396: goto out; 1397: } 1398: r->hyr_lasttime = time.tv_sec; 1399: #ifdef HYLOG 1400: hil.hmisc = r->hyr_lasttime; 1401: #endif 1402: break; 1403: 1404: case HYGETROUTE: 1405: if (sg->hyrsg_len < sizeof(struct hy_route)) { 1406: error = EINVAL; 1407: goto out; 1408: } 1409: if (copyout((caddr_t)r, (caddr_t) (sg->hyrsg_ptr), sizeof(struct hy_route))) { 1410: error = EFAULT; 1411: goto out; 1412: } 1413: break; 1414: 1415: #ifdef HYELOG 1416: case HYGETELOG: 1417: if (sgl->hylsg_len < sizeof(hy_elog)) { 1418: error = EINVAL; 1419: goto out; 1420: } 1421: if (copyout((caddr_t)hy_elog, sgl->hylsg_ptr, sizeof(hy_elog))) { 1422: error = EFAULT; 1423: goto out; 1424: } 1425: if (sgl->hylsg_cmd) { 1426: if (!suser()) { 1427: error = EPERM; 1428: goto out; 1429: } 1430: bzero((caddr_t)hy_elog, sizeof(hy_elog)); 1431: } 1432: break; 1433: #endif 1434: 1435: #ifdef HYLOG 1436: case HYSETLOG: 1437: if (!suser()) { 1438: error = EPERM; 1439: goto out; 1440: } 1441: hy_log.hyl_enable = HYL_DISABLED; 1442: hylog(HYL_NOP, 0, (char *)0); /* force log init */ 1443: hy_log.hyl_enable = sgl->hylsg_cmd & 0x0f; 1444: hy_log.hyl_onerr = (sgl->hylsg_cmd >> 4) & 0x0f; 1445: hy_log.hyl_filter = (sgl->hylsg_cmd >> 8) & 0xffffff; 1446: hy_log.hyl_count = hy_log.hyl_icount = sgl->hylsg_len; 1447: wakeup((caddr_t)&hy_log); /* wakeup sleeping HYGETLOG */ 1448: break; 1449: 1450: case HYGETLOG: 1451: if (sgl->hylsg_len < sizeof(hy_log)) { 1452: error = EINVAL; 1453: goto out; 1454: } 1455: if (sgl->hylsg_cmd != 0) { 1456: if (hy_log.hyl_wait) { 1457: error = EBUSY; 1458: goto out; 1459: } 1460: hy_log.hyl_wait = sgl->hylsg_cmd; 1461: sleep((caddr_t)&hy_log, PZERO - 1); 1462: } 1463: 1464: if (copyout((caddr_t)&hy_log, sgl->hylsg_ptr, sizeof(hy_log))) { 1465: error = EFAULT; 1466: goto out; 1467: } 1468: break; 1469: #endif 1470: 1471: default: 1472: error = EINVAL; 1473: break; 1474: } 1475: out: 1476: #ifdef HYLOG 1477: hil.herror = error; 1478: hil.iflags = ifp->if_flags; 1479: hil.haddr = is->hy_addr.s_addr; 1480: hylog(HYL_IOCTL, sizeof(hil), (char *)&hil); 1481: #endif 1482: splx(s); 1483: return (error); 1484: } 1485: #endif
Defined functions
Defined variables
hy_debug_flag
defined in line 172; used 12 times
Defined struct's
Defined macros
MAXINTERVAL
defined in line 182; never used
|
Last modified: 1986-06-06
Generated: 2016-12-26 |
Generated by src2html V0.67
page hit count: 4999 |
|