![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to autoconf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / hp300|
Return to autoconf.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / hp300 |
1.1 ! root 1: /* ! 2: * Copyright (c) 1988 University of Utah. ! 3: * Copyright (c) 1982, 1986, 1990 The Regents of the University of California. ! 4: * All rights reserved. ! 5: * ! 6: * This code is derived from software contributed to Berkeley by ! 7: * the Systems Programming Group of the University of Utah Computer ! 8: * Science Department. ! 9: * ! 10: * Redistribution is only permitted until one year after the first shipment ! 11: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and ! 12: * binary forms are permitted provided that: (1) source distributions retain ! 13: * this entire copyright notice and comment, and (2) distributions including ! 14: * binaries display the following acknowledgement: This product includes ! 15: * software developed by the University of California, Berkeley and its ! 16: * contributors'' in the documentation or other materials provided with the ! 17: * distribution and in all advertising materials mentioning features or use ! 18: * of this software. Neither the name of the University nor the names of ! 19: * its contributors may be used to endorse or promote products derived from ! 20: * this software without specific prior written permission. ! 21: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 22: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 23: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 24: * ! 25: * from: Utah $Hdr: autoconf.c 1.25 89/10/07$ ! 26: * ! 27: * @(#)autoconf.c 7.2 (Berkeley) 5/25/90 ! 28: */ ! 29: ! 30: /* ! 31: * Setup the system to run on the current machine. ! 32: * ! 33: * Configure() is called at boot time. Available ! 34: * devices are determined (from possibilities mentioned in ioconf.c), ! 35: * and the drivers are initialized. ! 36: */ ! 37: ! 38: #include "param.h" ! 39: #include "systm.h" ! 40: #include "map.h" ! 41: #include "buf.h" ! 42: #include "dkstat.h" ! 43: #include "vm.h" ! 44: #include "conf.h" ! 45: #include "dmap.h" ! 46: #include "reboot.h" ! 47: ! 48: #include "pte.h" ! 49: #include "cpu.h" ! 50: #include "isr.h" ! 51: #include "../hpdev/device.h" ! 52: #include "../hpdev/grfioctl.h" ! 53: #include "../hpdev/grfvar.h" ! 54: ! 55: /* ! 56: * The following several variables are related to ! 57: * the configuration process, and are used in initializing ! 58: * the machine. ! 59: */ ! 60: int cold; /* if 1, still working on cold-start */ ! 61: int dkn; /* number of iostat dk numbers assigned so far */ ! 62: int cpuspeed = MHZ_8; /* relative cpu speed */ ! 63: struct isr isrqueue[NISR]; ! 64: struct hp_hw sc_table[MAX_CTLR]; ! 65: ! 66: extern int internalhpib; ! 67: ! 68: #ifdef DEBUG ! 69: int acdebug = 0; ! 70: #endif ! 71: ! 72: /* ! 73: * Determine mass storage and memory configuration for a machine. ! 74: */ ! 75: configure() ! 76: { ! 77: register struct hp_hw *hw; ! 78: int found; ! 79: ! 80: /* ! 81: * XXX: these should be consolidated into some kind of table ! 82: */ ! 83: hilinit(); ! 84: isrinit(); ! 85: dmainit(); ! 86: ! 87: /* ! 88: * Look over each hardware device actually found and attempt ! 89: * to match it with an ioconf.c table entry. ! 90: */ ! 91: for (hw = sc_table; hw->hw_type; hw++) { ! 92: if (hw->hw_type & CONTROLLER) ! 93: found = find_controller(hw); ! 94: else ! 95: found = find_device(hw); ! 96: #ifdef DEBUG ! 97: if (!found) { ! 98: int sc = addrtosc((u_int)hw->hw_addr); ! 99: ! 100: printf("unconfigured %s ", hw->hw_name); ! 101: if (sc < 256) ! 102: printf("at sc%d\n", sc); ! 103: else ! 104: printf("csr at %x\n", sc); ! 105: } ! 106: #endif ! 107: } ! 108: ! 109: #include "cd.h" ! 110: #if NCD > 0 ! 111: /* ! 112: * Now deal with concatenated disks ! 113: */ ! 114: find_cdevices(); ! 115: #endif ! 116: ! 117: #if GENERIC ! 118: if ((boothowto & RB_ASKNAME) == 0) ! 119: setroot(); ! 120: setconf(); ! 121: #else ! 122: setroot(); ! 123: #endif ! 124: swapconf(); ! 125: cold = 0; ! 126: } ! 127: ! 128: #define dr_type(d, s) \ ! 129: (strcmp((d)->d_name, (s)) == 0) ! 130: ! 131: #define same_hw_ctlr(hw, hc) \ ! 132: ((hw)->hw_type == HPIB && dr_type((hc)->hp_driver, "hpib") || \ ! 133: (hw)->hw_type == SCSI && dr_type((hc)->hp_driver, "scsi")) ! 134: ! 135: find_controller(hw) ! 136: register struct hp_hw *hw; ! 137: { ! 138: register struct hp_ctlr *hc; ! 139: struct hp_ctlr *match_c; ! 140: caddr_t oaddr; ! 141: int sc; ! 142: ! 143: #ifdef DEBUG ! 144: if (acdebug) ! 145: printf("find_controller: hw: %s at sc%d (%x), type %x...", ! 146: hw->hw_name, hw->hw_sc, hw->hw_addr, hw->hw_type); ! 147: #endif ! 148: sc = hw->hw_sc; ! 149: match_c = NULL; ! 150: for (hc = hp_cinit; hc->hp_driver; hc++) { ! 151: if (hc->hp_alive) ! 152: continue; ! 153: /* ! 154: * Make sure we are looking at the right ! 155: * controller type. ! 156: */ ! 157: if (!same_hw_ctlr(hw, hc)) ! 158: continue; ! 159: /* ! 160: * Exact match; all done ! 161: */ ! 162: if ((int)hc->hp_addr == sc) { ! 163: match_c = hc; ! 164: break; ! 165: } ! 166: /* ! 167: * Wildcard; possible match so remember first instance ! 168: * but continue looking for exact match. ! 169: */ ! 170: if ((int)hc->hp_addr == WILD_CARD_CTLR && match_c == NULL) ! 171: match_c = hc; ! 172: } ! 173: #ifdef DEBUG ! 174: if (acdebug) { ! 175: if (match_c) ! 176: printf("found %s%d\n", ! 177: match_c->hp_driver->d_name, ! 178: match_c->hp_unit); ! 179: else ! 180: printf("not found\n"); ! 181: } ! 182: #endif ! 183: /* ! 184: * Didn't find an ioconf entry for this piece of hardware, ! 185: * just ignore it. ! 186: */ ! 187: if (match_c == NULL) ! 188: return(0); ! 189: /* ! 190: * Found a match, attempt to initialize and configure all attached ! 191: * slaves. Note, we can still fail if HW won't initialize. ! 192: */ ! 193: hc = match_c; ! 194: oaddr = hc->hp_addr; ! 195: hc->hp_addr = hw->hw_addr; ! 196: if ((*hc->hp_driver->d_init)(hc)) { ! 197: hc->hp_alive = 1; ! 198: printf("%s%d", hc->hp_driver->d_name, hc->hp_unit); ! 199: sc = addrtosc((u_int)hc->hp_addr); ! 200: if (sc < 256) ! 201: printf(" at sc%d,", sc); ! 202: else ! 203: printf(" csr 0x%x,", sc); ! 204: printf(" ipl %d", hc->hp_ipl); ! 205: if (hc->hp_flags) ! 206: printf(" flags 0x%x", hc->hp_flags); ! 207: printf("\n"); ! 208: find_slaves(hc); ! 209: } else ! 210: hc->hp_addr = oaddr; ! 211: return(1); ! 212: } ! 213: ! 214: find_device(hw) ! 215: register struct hp_hw *hw; ! 216: { ! 217: register struct hp_device *hd; ! 218: struct hp_device *match_d; ! 219: caddr_t oaddr; ! 220: int sc; ! 221: ! 222: #ifdef DEBUG ! 223: if (acdebug) ! 224: printf("find_device: hw: %s at sc%d (%x), type %x...", ! 225: hw->hw_name, hw->hw_sc, hw->hw_addr, hw->hw_type); ! 226: #endif ! 227: match_d = NULL; ! 228: for (hd = hp_dinit; hd->hp_driver; hd++) { ! 229: if (hd->hp_alive) ! 230: continue; ! 231: /* Must not be a slave */ ! 232: if (hd->hp_cdriver) ! 233: continue; ! 234: /* ! 235: * XXX: A graphics device that was found as part of the ! 236: * console init will have the hp_addr field already set ! 237: * (i.e. no longer the select code). Gotta perform a ! 238: * slightly different check for an exact match. ! 239: */ ! 240: if (hw->hw_type == BITMAP && hd->hp_addr >= (caddr_t)IOBASE) { ! 241: /* must be an exact match */ ! 242: if (hd->hp_addr == hw->hw_addr) { ! 243: match_d = hd; ! 244: break; ! 245: } ! 246: continue; ! 247: } ! 248: sc = (int) hd->hp_addr; ! 249: /* ! 250: * Exact match; all done. ! 251: */ ! 252: if (sc > 0 && sc == hw->hw_sc) { ! 253: match_d = hd; ! 254: break; ! 255: } ! 256: /* ! 257: * Wildcard; possible match so remember first instance ! 258: * but continue looking for exact match. ! 259: */ ! 260: if (sc == 0 && same_hw_device(hw, hd) && match_d == NULL) ! 261: match_d = hd; ! 262: } ! 263: #ifdef DEBUG ! 264: if (acdebug) { ! 265: if (match_d) ! 266: printf("found %s%d\n", ! 267: match_d->hp_driver->d_name, ! 268: match_d->hp_unit); ! 269: else ! 270: printf("not found\n"); ! 271: } ! 272: #endif ! 273: /* ! 274: * Didn't find an ioconf entry for this piece ! 275: * of hardware, just ignore it. ! 276: */ ! 277: if (match_d == NULL) ! 278: return(0); ! 279: /* ! 280: * Found a match, attempt to initialize. ! 281: * Note, we can still fail if HW won't initialize. ! 282: */ ! 283: hd = match_d; ! 284: oaddr = hd->hp_addr; ! 285: hd->hp_addr = hw->hw_addr; ! 286: if ((*hd->hp_driver->d_init)(hd)) { ! 287: hd->hp_alive = 1; ! 288: printf("%s%d", hd->hp_driver->d_name, hd->hp_unit); ! 289: sc = addrtosc((u_int)hd->hp_addr); ! 290: if (sc < 32) ! 291: printf(" at sc%d", sc); ! 292: else ! 293: printf(" csr 0x%x", sc); ! 294: if (hd->hp_ipl) ! 295: printf(", ipl %d", hd->hp_ipl); ! 296: if (hd->hp_flags) ! 297: printf(", flags 0x%x", hd->hp_flags); ! 298: printf("\n"); ! 299: } else ! 300: hd->hp_addr = oaddr; ! 301: return(1); ! 302: } ! 303: ! 304: find_slaves(hc) ! 305: struct hp_ctlr *hc; ! 306: { ! 307: /* ! 308: * The SCSI bus is structured very much like the HP-IB ! 309: * except that the host adaptor is slave 7 so we only want ! 310: * to look at the first 6 slaves. ! 311: */ ! 312: if (dr_type(hc->hp_driver, "hpib")) ! 313: find_busslaves(hc, MAXSLAVES); ! 314: else if (dr_type(hc->hp_driver, "scsi")) ! 315: find_busslaves(hc, MAXSLAVES-1); ! 316: } ! 317: ! 318: /* ! 319: * Search each BUS controller found for slaves attached to it. ! 320: * The bad news is that we don't know how to uniquely identify all slaves ! 321: * (e.g. PPI devices on HP-IB). The good news is that we can at least ! 322: * differentiate those from slaves we can identify. At worst (a totally ! 323: * wildcarded entry) this will cause us to locate such a slave at the first ! 324: * unused position instead of where it really is. To save grief, non- ! 325: * identifing devices should always be fully qualified. ! 326: */ ! 327: find_busslaves(hc, maxslaves) ! 328: register struct hp_ctlr *hc; ! 329: int maxslaves; ! 330: { ! 331: register int s; ! 332: register struct hp_device *hd; ! 333: struct hp_device *match_s; ! 334: int new_s, new_c, old_s, old_c; ! 335: int rescan; ! 336: ! 337: #ifdef DEBUG ! 338: if (acdebug) ! 339: printf("find_busslaves: for %s%d\n", ! 340: hc->hp_driver->d_name, hc->hp_unit); ! 341: #endif ! 342: for (s = 0; s < maxslaves; s++) { ! 343: rescan = 1; ! 344: match_s = NULL; ! 345: for (hd = hp_dinit; hd->hp_driver; hd++) { ! 346: /* ! 347: * Rule out the easy ones: ! 348: * 1. slave already assigned or not a slave ! 349: * 2. not of the proper type ! 350: * 3. controller specified but not this one ! 351: * 4. slave specified but not this one ! 352: */ ! 353: if (hd->hp_alive || hd->hp_cdriver == NULL) ! 354: continue; ! 355: if (!dr_type(hc->hp_driver, hd->hp_cdriver->d_name)) ! 356: continue; ! 357: if (hd->hp_ctlr >= 0 && hd->hp_ctlr != hc->hp_unit) ! 358: continue; ! 359: if (hd->hp_slave >= 0 && hd->hp_slave != s) ! 360: continue; ! 361: /* ! 362: * Case 0: first possible match. ! 363: * Remember it and keep looking for better. ! 364: */ ! 365: if (match_s == NULL) { ! 366: match_s = hd; ! 367: new_c = hc->hp_unit; ! 368: new_s = s; ! 369: continue; ! 370: } ! 371: /* ! 372: * Case 1: exact match. ! 373: * All done. Note that we do not attempt any other ! 374: * matches if this one fails. This allows us to ! 375: * "reserve" locations for dynamic addition of ! 376: * disk/tape drives by fully qualifing the location. ! 377: */ ! 378: if (hd->hp_slave == s && hd->hp_ctlr == hc->hp_unit) { ! 379: match_s = hd; ! 380: rescan = 0; ! 381: break; ! 382: } ! 383: /* ! 384: * Case 2: right controller, wildcarded slave. ! 385: * Remember first and keep looking for an exact match. ! 386: */ ! 387: if (hd->hp_ctlr == hc->hp_unit && ! 388: match_s->hp_ctlr < 0) { ! 389: match_s = hd; ! 390: new_s = s; ! 391: continue; ! 392: } ! 393: /* ! 394: * Case 3: right slave, wildcarded controller. ! 395: * Remember and keep looking for a better match. ! 396: */ ! 397: if (hd->hp_slave == s && ! 398: match_s->hp_ctlr < 0 && match_s->hp_slave < 0) { ! 399: match_s = hd; ! 400: new_c = hc->hp_unit; ! 401: continue; ! 402: } ! 403: /* ! 404: * OW: we had a totally wildcarded spec. ! 405: * If we got this far, we have found a possible ! 406: * match already (match_s != NULL) so there is no ! 407: * reason to remember this one. ! 408: */ ! 409: continue; ! 410: } ! 411: /* ! 412: * Found a match. We need to set hp_ctlr/hp_slave properly ! 413: * for the init routines but we also need to remember all ! 414: * the old values in case this doesn't pan out. ! 415: */ ! 416: if (match_s) { ! 417: hd = match_s; ! 418: old_c = hd->hp_ctlr; ! 419: old_s = hd->hp_slave; ! 420: if (hd->hp_ctlr < 0) ! 421: hd->hp_ctlr = new_c; ! 422: if (hd->hp_slave < 0) ! 423: hd->hp_slave = new_s; ! 424: #ifdef DEBUG ! 425: if (acdebug) ! 426: printf("looking for %s%d at slave %d...", ! 427: hd->hp_driver->d_name, ! 428: hd->hp_unit, hd->hp_slave); ! 429: #endif ! 430: ! 431: if ((*hd->hp_driver->d_init)(hd)) { ! 432: #ifdef DEBUG ! 433: if (acdebug) ! 434: printf("found\n"); ! 435: #endif ! 436: printf("%s%d at %s%d, slave %d", ! 437: hd->hp_driver->d_name, hd->hp_unit, ! 438: hc->hp_driver->d_name, hd->hp_ctlr, ! 439: hd->hp_slave); ! 440: if (hd->hp_flags) ! 441: printf(" flags 0x%x", hd->hp_flags); ! 442: printf("\n"); ! 443: hd->hp_alive = 1; ! 444: if (hd->hp_dk && dkn < DK_NDRIVE) ! 445: hd->hp_dk = dkn++; ! 446: else ! 447: hd->hp_dk = -1; ! 448: rescan = 1; ! 449: } else { ! 450: #ifdef DEBUG ! 451: if (acdebug) ! 452: printf("not found\n"); ! 453: #endif ! 454: hd->hp_ctlr = old_c; ! 455: hd->hp_slave = old_s; ! 456: } ! 457: /* ! 458: * XXX: This should be handled better. ! 459: * Re-scan a slave. There are two reasons to do this. ! 460: * 1. It is possible to have both a tape and disk ! 461: * (e.g. 7946) or two disks (e.g. 9122) at the ! 462: * same slave address. Here we need to rescan ! 463: * looking only at entries with a different ! 464: * physical unit number (hp_flags). ! 465: * 2. It is possible that an init failed because the ! 466: * slave was there but of the wrong type. In this ! 467: * case it may still be possible to match the slave ! 468: * to another ioconf entry of a different type. ! 469: * Here we need to rescan looking only at entries ! 470: * of different types. ! 471: * In both cases we avoid looking at undesirable ! 472: * ioconf entries of the same type by setting their ! 473: * alive fields to -1. ! 474: */ ! 475: if (rescan) { ! 476: for (hd = hp_dinit; hd->hp_driver; hd++) { ! 477: if (hd->hp_alive) ! 478: continue; ! 479: if (match_s->hp_alive == 1) { /* 1 */ ! 480: if (hd->hp_flags == match_s->hp_flags) ! 481: hd->hp_alive = -1; ! 482: } else { /* 2 */ ! 483: if (hd->hp_driver == match_s->hp_driver) ! 484: hd->hp_alive = -1; ! 485: } ! 486: } ! 487: s--; ! 488: continue; ! 489: } ! 490: } ! 491: /* ! 492: * Reset bogon alive fields prior to attempting next slave ! 493: */ ! 494: for (hd = hp_dinit; hd->hp_driver; hd++) ! 495: if (hd->hp_alive == -1) ! 496: hd->hp_alive = 0; ! 497: } ! 498: } ! 499: ! 500: sctoaddr(addr) ! 501: register int addr; ! 502: { ! 503: if (addr == 7 && internalhpib) ! 504: addr = internalhpib; ! 505: else if (addr < 32) ! 506: addr = IOV(EXTIOBASE + (addr * IOCARDSIZE)); ! 507: else ! 508: addr = IOV(addr); ! 509: return(addr); ! 510: } ! 511: ! 512: addrtosc(addr) ! 513: register u_int addr; ! 514: { ! 515: #if defined(HP360) || defined(HP370) ! 516: extern char grfregs[]; ! 517: ! 518: if (addr == (u_int)grfregs) ! 519: addr = 132; ! 520: else ! 521: #endif ! 522: if (addr == internalhpib) ! 523: addr = 7; ! 524: else if (addr >= IOV(IOBASE)) { ! 525: addr = UNIOV(addr); ! 526: if (addr >= EXTIOBASE) ! 527: addr = (addr - EXTIOBASE) / IOCARDSIZE; ! 528: } ! 529: return((int)addr); ! 530: } ! 531: ! 532: same_hw_device(hw, hd) ! 533: struct hp_hw *hw; ! 534: struct hp_device *hd; ! 535: { ! 536: int found = 0; ! 537: ! 538: switch (hw->hw_type) { ! 539: case HPIB: ! 540: case RD: ! 541: case PPI: ! 542: case CT: ! 543: found = dr_type(hd->hp_driver, "hpib"); ! 544: break; ! 545: case BITMAP: ! 546: found = dr_type(hd->hp_driver, "grf"); ! 547: break; ! 548: case NET: ! 549: found = dr_type(hd->hp_driver, "le"); ! 550: break; ! 551: case COMMDCA: ! 552: found = dr_type(hd->hp_driver, "dca"); ! 553: break; ! 554: case COMMDCL: ! 555: found = dr_type(hd->hp_driver, "dcl"); ! 556: break; ! 557: case COMMDCM: ! 558: found = dr_type(hd->hp_driver, "dcm"); ! 559: break; ! 560: case SCSI: ! 561: found = dr_type(hd->hp_driver, "scsi"); ! 562: break; ! 563: case FPA: /* Unsupported so far */ ! 564: case VME: ! 565: case FLINK: ! 566: case MISC: ! 567: break; ! 568: } ! 569: return(found); ! 570: } ! 571: ! 572: find_devs() ! 573: { ! 574: short sc; ! 575: u_char *id_reg; ! 576: register int addr; ! 577: register struct hp_hw *hw; ! 578: ! 579: hw = sc_table; ! 580: for (sc = -1; sc < 32; sc++) { ! 581: #if defined(HP360) || defined(HP370) ! 582: /* ! 583: * XXX: special check for bit-mapped display ! 584: * at SC132 in DIO II space on the 340. ! 585: */ ! 586: if (sc == -1 && machineid == HP_340) { ! 587: extern struct pte Grfmap[]; ! 588: extern char grfregs[]; ! 589: ! 590: physaccess(Grfmap, (caddr_t)DIOIIBASE, ! 591: DIOIICSIZE, PG_RW|PG_CI); ! 592: addr = (int) grfregs; ! 593: /* ! 594: * Nothing there or not a display, ! 595: * try the usual internal display address. ! 596: */ ! 597: if (badaddr((caddr_t)addr) || ! 598: (((u_char *)addr)[1] & 0xff) != 57) ! 599: addr = IOV(GRFIADDR); ! 600: } else ! 601: #endif ! 602: /* ! 603: * Probe all select codes + internal display addr ! 604: */ ! 605: if (sc == -1) ! 606: addr = IOV(GRFIADDR); ! 607: else ! 608: addr = sctoaddr(sc); ! 609: if (badaddr((caddr_t)addr)) ! 610: continue; ! 611: ! 612: id_reg = (u_char *) addr; ! 613: hw->hw_id = id_reg[1] & 0xff; ! 614: hw->hw_sc = sc; ! 615: hw->hw_addr = (char *) addr; ! 616: /* ! 617: * Internal HP-IB on some machines (345/375) doesn't return ! 618: * consistant id info so we use the info gleaned from the ! 619: * boot ROMs SYSFLAG. ! 620: */ ! 621: if (sc == 7 && internalhpib) { ! 622: hw->hw_name = "98624A"; ! 623: hw->hw_type = HPIB; ! 624: hw++; ! 625: continue; ! 626: } ! 627: /* ! 628: * XXX: the following could be in a big static table ! 629: */ ! 630: switch (hw->hw_id) { ! 631: /* Null device? */ ! 632: case 0: ! 633: break; ! 634: case 2: ! 635: case 128+2: ! 636: hw->hw_name = "98626A"; ! 637: hw->hw_type = COMMDCA; ! 638: break; ! 639: case 3: ! 640: hw->hw_name = "98622A"; ! 641: hw->hw_type = MISC; ! 642: break; ! 643: case 4: ! 644: hw->hw_name = "98623A"; ! 645: hw->hw_type = MISC; ! 646: break; ! 647: case 5: ! 648: case 128+5: ! 649: hw->hw_name = "98642A"; ! 650: hw->hw_type = COMMDCM; ! 651: break; ! 652: case 6: ! 653: hw->hw_name = "Parallel Port"; ! 654: hw->hw_type = PPORT; ! 655: break; ! 656: case 7: ! 657: case 39: ! 658: case 71: ! 659: case 103: ! 660: hw->hw_name = "98265A"; ! 661: hw->hw_type = SCSI; ! 662: break; ! 663: case 8: ! 664: hw->hw_name = "98625B"; ! 665: hw->hw_type = HPIB; ! 666: break; ! 667: case 9: ! 668: hw->hw_name = "98287A"; ! 669: hw->hw_type = KEYBOARD; ! 670: break; ! 671: case 10: ! 672: hw->hw_name = "98635A"; ! 673: hw->hw_type = FPA; ! 674: break; ! 675: case 11: ! 676: hw->hw_name = "Timer"; ! 677: hw->hw_type = MISC; ! 678: break; ! 679: case 18: ! 680: hw->hw_name = "98640A"; ! 681: hw->hw_type = MISC; ! 682: break; ! 683: case 21: ! 684: hw->hw_name = "98643A"; ! 685: hw->hw_type = NET; ! 686: break; ! 687: case 22: ! 688: hw->hw_name = "98659A"; ! 689: hw->hw_type = MISC; ! 690: break; ! 691: case 25: ! 692: hw->hw_name = "237"; ! 693: hw->hw_type = BITMAP; ! 694: break; ! 695: case 26: ! 696: hw->hw_name = "Quad"; ! 697: hw->hw_type = MISC; ! 698: break; ! 699: case 27: ! 700: hw->hw_name = "98253A"; ! 701: hw->hw_type = MISC; ! 702: break; ! 703: case 28: ! 704: hw->hw_name = "98627A"; ! 705: hw->hw_type = BITMAP; ! 706: break; ! 707: case 29: ! 708: hw->hw_name = "98633A"; ! 709: hw->hw_type = BITMAP; ! 710: break; ! 711: case 30: ! 712: hw->hw_name = "98259A"; ! 713: hw->hw_type = MISC; ! 714: break; ! 715: case 31: ! 716: hw->hw_name = "8741"; ! 717: hw->hw_type = MISC; ! 718: break; ! 719: case 49: ! 720: hw->hw_name = "98577A"; ! 721: hw->hw_type = VME; ! 722: sc++; ! 723: break; ! 724: case 52: ! 725: case 180: ! 726: hw->hw_name = "98628A"; ! 727: hw->hw_type = COMMDCL; ! 728: break; ! 729: case 57: ! 730: hw->hw_type = BITMAP; ! 731: hw->hw_id2 = id_reg[0x15]; ! 732: switch (hw->hw_id2) { ! 733: case 1: ! 734: hw->hw_name = "98700 "; ! 735: break; ! 736: case 2: ! 737: hw->hw_name = "TOPCAT"; ! 738: break; ! 739: case 4: ! 740: hw->hw_name = "98720 "; ! 741: sc++; ! 742: break; ! 743: case 5: ! 744: case 6: ! 745: case 7: ! 746: case 9: ! 747: hw->hw_name = "CATSEYE"; ! 748: break; ! 749: case 8: ! 750: hw->hw_name = "98730 "; ! 751: sc++; ! 752: break; ! 753: default: ! 754: hw->hw_name = "987xx "; ! 755: break; ! 756: } ! 757: break; ! 758: case 66: ! 759: case 128+66: ! 760: hw->hw_name = "98644A"; ! 761: hw->hw_type = COMMDCA; ! 762: break; ! 763: case 128: ! 764: hw->hw_name = "98624A"; ! 765: hw->hw_type = HPIB; ! 766: break; ! 767: default: ! 768: hw->hw_name = "DEFAULT"; ! 769: hw->hw_type = MISC; ! 770: break; ! 771: } ! 772: hw++; ! 773: } ! 774: } ! 775: ! 776: #if NCD > 0 ! 777: #include "../hpdev/cdvar.h" ! 778: ! 779: find_cdevices() ! 780: { ! 781: register struct cddevice *cd; ! 782: ! 783: for (cd = cddevice; cd->cd_unit >= 0; cd++) { ! 784: /* ! 785: * XXX ! 786: * Assign disk index first so that init routine ! 787: * can use it (saves having the driver drag around ! 788: * the cddevice pointer just to set up the dk_* ! 789: * info in the open routine). ! 790: */ ! 791: if (dkn < DK_NDRIVE) ! 792: cd->cd_dk = dkn++; ! 793: else ! 794: cd->cd_dk = -1; ! 795: if (cdinit(cd)) ! 796: printf("cd%d configured\n", cd->cd_unit); ! 797: else if (cd->cd_dk >= 0) { ! 798: cd->cd_dk = -1; ! 799: dkn--; ! 800: } ! 801: } ! 802: } ! 803: #endif ! 804: ! 805: isrinit() ! 806: { ! 807: register int i; ! 808: ! 809: for (i = 0; i < NISR; i++) ! 810: isrqueue[i].isr_forw = isrqueue[i].isr_back = &isrqueue[i]; ! 811: } ! 812: ! 813: void ! 814: isrlink(isr) ! 815: register struct isr *isr; ! 816: { ! 817: int i = ISRIPL(isr->isr_ipl); ! 818: ! 819: if (i < 0 || i >= NISR) { ! 820: printf("bad IPL %d\n", i); ! 821: panic("configure"); ! 822: } ! 823: insque(isr, isrqueue[i].isr_back); ! 824: } ! 825: ! 826: /* ! 827: * Configure swap space and related parameters. ! 828: */ ! 829: swapconf() ! 830: { ! 831: register struct swdevt *swp; ! 832: register int nblks; ! 833: ! 834: for (swp = swdevt; swp->sw_dev; swp++) ! 835: if (bdevsw[major(swp->sw_dev)].d_psize) { ! 836: nblks = ! 837: (*bdevsw[major(swp->sw_dev)].d_psize)(swp->sw_dev); ! 838: if (nblks != -1 && ! 839: (swp->sw_nblks == 0 || swp->sw_nblks > nblks)) ! 840: swp->sw_nblks = nblks; ! 841: } ! 842: dumpconf(); ! 843: } ! 844: ! 845: #define DOSWAP /* Change swdevt, argdev, and dumpdev too */ ! 846: u_long bootdev; /* should be dev_t, but not until 32 bits */ ! 847: ! 848: static char devname[][2] = { ! 849: 0,0, /* 0 = ct */ ! 850: 0,0, /* 1 = xx */ ! 851: 'r','d', /* 2 = rd */ ! 852: 0,0, /* 3 = sw */ ! 853: 's','d', /* 4 = rd */ ! 854: }; ! 855: ! 856: #define PARTITIONMASK 0x7 ! 857: #define PARTITIONSHIFT 3 ! 858: ! 859: /* ! 860: * Attempt to find the device from which we were booted. ! 861: * If we can do so, and not instructed not to do so, ! 862: * change rootdev to correspond to the load device. ! 863: */ ! 864: setroot() ! 865: { ! 866: register struct hp_ctlr *hc; ! 867: register struct hp_device *hd; ! 868: int majdev, mindev, unit, part, adaptor; ! 869: dev_t temp, orootdev; ! 870: struct swdevt *swp; ! 871: ! 872: if (boothowto & RB_DFLTROOT || ! 873: (bootdev & B_MAGICMASK) != (u_long)B_DEVMAGIC) ! 874: return; ! 875: majdev = (bootdev >> B_TYPESHIFT) & B_TYPEMASK; ! 876: if (majdev > sizeof(devname) / sizeof(devname[0])) ! 877: return; ! 878: adaptor = (bootdev >> B_ADAPTORSHIFT) & B_ADAPTORMASK; ! 879: part = (bootdev >> B_PARTITIONSHIFT) & B_PARTITIONMASK; ! 880: unit = (bootdev >> B_UNITSHIFT) & B_UNITMASK; ! 881: /* ! 882: * First, find the controller type which support this device. ! 883: */ ! 884: for (hd = hp_dinit; hd->hp_driver; hd++) ! 885: if (hd->hp_driver->d_name[0] == devname[majdev][0] && ! 886: hd->hp_driver->d_name[1] == devname[majdev][1]) ! 887: break; ! 888: if (hd->hp_driver == 0) ! 889: return; ! 890: /* ! 891: * Next, find the controller of that type corresponding to ! 892: * the adaptor number. ! 893: */ ! 894: for (hc = hp_cinit; hc->hp_driver; hc++) ! 895: if (hc->hp_alive && hc->hp_unit == adaptor && ! 896: hc->hp_driver == hd->hp_cdriver) ! 897: break; ! 898: if (hc->hp_driver == 0) ! 899: return; ! 900: /* ! 901: * Finally, find the device in question attached to that controller. ! 902: */ ! 903: for (hd = hp_dinit; hd->hp_driver; hd++) ! 904: if (hd->hp_alive && hd->hp_slave == unit && ! 905: hd->hp_cdriver == hc->hp_driver && ! 906: hd->hp_ctlr == hc->hp_unit) ! 907: break; ! 908: if (hd->hp_driver == 0) ! 909: return; ! 910: mindev = hd->hp_unit; ! 911: /* ! 912: * Form a new rootdev ! 913: */ ! 914: mindev = (mindev << PARTITIONSHIFT) + part; ! 915: orootdev = rootdev; ! 916: rootdev = makedev(majdev, mindev); ! 917: /* ! 918: * If the original rootdev is the same as the one ! 919: * just calculated, don't need to adjust the swap configuration. ! 920: */ ! 921: if (rootdev == orootdev) ! 922: return; ! 923: ! 924: printf("Changing root device to %c%c%d%c\n", ! 925: devname[majdev][0], devname[majdev][1], ! 926: mindev >> PARTITIONSHIFT, part + 'a'); ! 927: ! 928: #ifdef DOSWAP ! 929: mindev &= ~PARTITIONMASK; ! 930: for (swp = swdevt; swp->sw_dev; swp++) { ! 931: if (majdev == major(swp->sw_dev) && ! 932: mindev == (minor(swp->sw_dev) & ~PARTITIONMASK)) { ! 933: temp = swdevt[0].sw_dev; ! 934: swdevt[0].sw_dev = swp->sw_dev; ! 935: swp->sw_dev = temp; ! 936: break; ! 937: } ! 938: } ! 939: if (swp->sw_dev == 0) ! 940: return; ! 941: ! 942: /* ! 943: * If argdev and dumpdev were the same as the old primary swap ! 944: * device, move them to the new primary swap device. ! 945: */ ! 946: if (temp == dumpdev) ! 947: dumpdev = swdevt[0].sw_dev; ! 948: if (temp == argdev) ! 949: argdev = swdevt[0].sw_dev; ! 950: #endif ! 951: } ! 952: ! 953: strcmp(s1, s2) ! 954: register char *s1, *s2; ! 955: { ! 956: while (*s1 == *s2++) ! 957: if (*s1++=='\0') ! 958: return (0); ! 959: return (*s1 - *--s2); ! 960: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.