1 /* 2 * Copyright (c) 1988 Regents of the University of California. 3 * All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * Chris Torek. 7 * 8 * %sccs.include.redist.c% 9 * 10 * @(#)kdb.c 7.10 (Berkeley) 12/16/90 11 */ 12 13 /* 14 * KDB50/MSCP device driver 15 */ 16 17 /* 18 * TODO 19 * rethink BI software interface 20 * write bad block forwarding code 21 */ 22 23 #include "kra.h" /* XXX */ 24 25 #define DRIVENAMES "kra" /* XXX */ 26 27 #if NKDB > 0 28 29 /* 30 * CONFIGURATION OPTIONS. The next three defines are tunable -- tune away! 31 * 32 * NRSPL2 and NCMDL2 control the number of response and command 33 * packets respectively. They may be any value from 0 to 7, though 34 * setting them higher than 5 is unlikely to be of any value. 35 * If you get warnings about your command ring being too small, 36 * try increasing the values by one. 37 * 38 * MAXUNIT controls the maximum slave number (and hence number of drives 39 * per controller) we are prepared to handle. 40 */ 41 #define NRSPL2 5 /* log2 number of response packets */ 42 #define NCMDL2 5 /* log2 number of command packets */ 43 #define MAXUNIT 8 /* maximum allowed unit number */ 44 45 #include "sys/param.h" 46 #include "sys/systm.h" 47 #include "sys/malloc.h" 48 #include "sys/map.h" 49 #include "sys/buf.h" 50 #include "sys/conf.h" 51 #include "sys/user.h" 52 #include "sys/proc.h" 53 #include "sys/vm.h" 54 #include "sys/dkstat.h" 55 #include "sys/cmap.h" 56 #include "sys/syslog.h" 57 #include "sys/kernel.h" 58 59 #define NRSP (1 << NRSPL2) 60 #define NCMD (1 << NCMDL2) 61 62 #include "../include/pte.h" 63 #include "../include/cpu.h" 64 #include "../vax/mscp.h" 65 #include "../vax/mscpvar.h" 66 #include "../include/mtpr.h" 67 68 #include "bireg.h" 69 #include "kdbreg.h" 70 71 #include "../uba/ubavar.h" 72 73 /* 74 * Conversions from kernel virtual to physical and page table addresses. 75 * PHYS works only for kernel text and primary (compile time) data addresses. 76 */ 77 #define PHYS(cast, addr) \ 78 ((cast) ((int)(addr) & 0x7fffffff)) 79 80 /* 81 * KDB variables, per controller. 82 */ 83 struct kdbinfo { 84 /* software info, per KDB */ 85 struct kdb_regs *ki_kdb; /* KDB registers */ 86 struct kdb_regs *ki_physkdb; /* phys address of KDB registers */ 87 short ki_state; /* KDB50 state; see below */ 88 short ki_flags; /* flags; see below */ 89 int ki_micro; /* microcode revision */ 90 short ki_vec; /* scb vector offset */ 91 short ki_wticks; /* watchdog timer ticks */ 92 93 /* 94 * KDB PTEs must be contiguous. Some I/O is done on addresses 95 * for which this is true (PTEs in Sysmap and Usrptmap), but 96 * other transfers may have PTEs that are scattered in physical 97 * space. Ki_map maps a physically contiguous PTE space used 98 * for these transfers. 99 */ 100 #define KI_MAPSIZ (NCMD + 2) 101 struct map *ki_map; /* resource map */ 102 #define KI_PTES 256 103 struct pte ki_pte[KI_PTES]; /* contiguous PTE space */ 104 long ki_ptephys; /* phys address of &ki_pte[0] */ 105 106 struct mscp_info ki_mi; /* MSCP info (per mscpvar.h) */ 107 struct buf ki_tab; /* controller queue */ 108 109 /* stuff read and written by hardware */ 110 struct kdbca ki_ca; /* communications area */ 111 struct mscp ki_rsp[NRSP]; /* response packets */ 112 struct mscp ki_cmd[NCMD]; /* command packets */ 113 } kdbinfo[NKDB]; 114 115 #define ki_ctlr ki_mi.mi_ctlr 116 117 /* 118 * Controller states 119 */ 120 #define ST_IDLE 0 /* uninitialised */ 121 #define ST_STEP1 1 /* in `STEP 1' */ 122 #define ST_STEP2 2 /* in `STEP 2' */ 123 #define ST_STEP3 3 /* in `STEP 3' */ 124 #define ST_SETCHAR 4 /* in `Set Controller Characteristics' */ 125 #define ST_RUN 5 /* up and running */ 126 127 /* 128 * Flags 129 */ 130 #define KDB_ALIVE 0x01 /* this KDB50 exists */ 131 #define KDB_GRIPED 0x04 /* griped about cmd ring too small */ 132 #define KDB_INSLAVE 0x08 /* inside kdbslave() */ 133 #define KDB_DOWAKE 0x10 /* wakeup when ctlr init done */ 134 135 struct kdbstats kdbstats; /* statistics */ 136 137 /* 138 * Device to unit number and partition: 139 */ 140 #define UNITSHIFT 3 141 #define UNITMASK 7 142 #define kdbunit(dev) (minor(dev) >> UNITSHIFT) 143 #define kdbpart(dev) (minor(dev) & UNITMASK) 144 145 /* THIS SHOULD BE READ OFF THE PACK, PER DRIVE */ 146 /* THESE SHOULD BE SHARED WITH uda.c (but not yet) */ 147 struct size { 148 daddr_t nblocks; 149 daddr_t blkoff; 150 } kra81_sizes[8] = { 151 #ifdef MARYLAND 152 67832, 0, /* A=cyl 0 thru 94 + 2 sectors */ 153 67828, 67832, /* B=cyl 95 thru 189 - 2 sectors */ 154 -1, 0, /* C=cyl 0 thru 1247 */ 155 -1, 135660, /* D=cyl 190 thru 1247 */ 156 449466, 49324, /* E xxx */ 157 64260, 498790, /* F xxx */ 158 328022, 563050, /* G xxx */ 159 0, 0, 160 #else 161 15884, 0, /* a */ 162 33440, 15884, /* b */ 163 -1, 0, /* c */ 164 -1, 49324, /* d */ 165 449466, 49324, /* e */ 166 64260, 498790, /* f */ 167 328022, 563050, /* g */ 168 0, 0, 169 #endif 170 }, kra80_sizes[8] = { 171 15884, 0, /* A=blk 0 thru 15883 */ 172 33440, 15884, /* B=blk 15884 thru 49323 */ 173 -1, 0, /* C=blk 0 thru end */ 174 0, 0, 175 0, 0, 176 0, 0, 177 82080, 49324, /* G=blk 49324 thru 131403 */ 178 -1, 131404, /* H=blk 131404 thru end */ 179 }, kra60_sizes[8] = { 180 15884, 0, /* A=blk 0 thru 15883 */ 181 33440, 15884, /* B=blk 15884 thru 49323 */ 182 -1, 0, /* C=blk 0 thru end */ 183 -1, 49324, /* D=blk 49324 thru end */ 184 0, 0, 185 0, 0, 186 82080, 49324, /* G=blk 49324 thru 131403 */ 187 -1, 131404, /* H=blk 131404 thru end */ 188 }; 189 /* END OF STUFF WHICH SHOULD BE READ IN PER DISK */ 190 191 /* 192 * Drive type index decoding table. `ut_name' is null iff the 193 * type is not known. 194 */ 195 struct kdbtypes { 196 char *ut_name; /* drive type name */ 197 struct size *ut_sizes; /* partition tables */ 198 } kdbtypes[] = { 199 NULL, NULL, 200 "ra80", kra80_sizes, /* 1 = ra80 */ 201 NULL, NULL, 202 NULL, NULL, 203 "ra60", kra60_sizes, /* 4 = ra60 */ 204 "ra81", kra81_sizes, /* 5 = ra81 */ 205 }; 206 207 #define NTYPES 6 208 209 /* 210 * Definition of the driver for autoconf and generic MSCP code. 211 * SOME OF THIS IS BOGUS (must fix config) 212 */ 213 214 #ifdef notdef /* not when driver is for kra disks */ 215 /* 216 * Some of these variables (per-drive stuff) are shared 217 * with the UDA50 code (why not, they are the same drives). 218 * N.B.: kdbdinfo must not be shared. 219 */ 220 #define kdbutab udautab /* shared */ 221 #define kdbslavereply udaslavereply /* shared */ 222 #endif 223 224 int kdbprobe(); /* XXX */ 225 int kdbslave(), kdbattach(); 226 227 int kdbdgram(), kdbctlrdone(), kdbunconf(), kdbiodone(); 228 int kdbonline(), kdbgotstatus(), kdbioerror(); 229 230 struct uba_device *kdbdinfo[NKRA]; /* uba_device indeed! */ 231 struct buf kdbutab[NKRA]; /* per drive transfer queue */ 232 233 u_short kdbstd[] = { 0 }; /* XXX */ 234 struct uba_driver kdbdriver = /* XXX */ 235 { kdbprobe, kdbslave, kdbattach, 0, kdbstd, DRIVENAMES, kdbdinfo, "kdb" }; 236 237 struct mscp_driver kdbmscpdriver = 238 { MAXUNIT, NKRA, UNITSHIFT, kdbutab, (struct disklabel *)0, kdbdinfo, 239 kdbdgram, kdbctlrdone, kdbunconf, kdbiodone, 240 kdbonline, kdbgotstatus, NULL, kdbioerror, NULL, 241 "kdb", DRIVENAMES }; 242 243 /* 244 * Miscellaneous private variables. 245 */ 246 char kdbsr_bits[] = KDBSR_BITS; 247 248 struct uba_device *kdbip[NKDB][MAXUNIT]; 249 /* inverting pointers: ctlr & unit => `Unibus' 250 device pointer */ 251 252 daddr_t ra_dsize[NKRA]; /* drive sizes, from on line end packets */ 253 254 struct mscp kdbslavereply; /* get unit status response packet, set 255 for kdbslave by kdbunconf, via kdbintr */ 256 257 int kdbwstart, kdbwatch(); /* watchdog timer */ 258 int wakeup(); 259 260 /* 261 * If kdbprobe is called, return 0 to keep Unibus code from attempting 262 * to use this device. XXX rethink 263 */ 264 /* ARGSUSED */ 265 kdbprobe(reg, ctlr) 266 caddr_t reg; 267 int ctlr; 268 { 269 270 return (0); 271 } 272 273 /* 274 * Configure in a KDB50 controller. 275 */ 276 kdbconfig(kdbnum, va, pa, vec) 277 int kdbnum; 278 struct biiregs *va, *pa; 279 int vec; 280 { 281 register struct kdbinfo *ki; 282 #define mi (&ki->ki_mi) 283 284 #ifdef lint 285 extern int (*kdbint0[])(); 286 287 (*kdbint0[0])(0); /* this is a config botch */ 288 kdbintr(0); 289 #endif 290 291 /* 292 * Set up local KDB status. 293 */ 294 ki = &kdbinfo[kdbnum]; 295 ki->ki_kdb = (struct kdb_regs *)va; 296 ki->ki_physkdb = (struct kdb_regs *)pa; 297 ki->ki_vec = vec; 298 ki->ki_map = 299 (struct map *)malloc((u_long)(KI_MAPSIZ * sizeof(struct map)), 300 M_DEVBUF, M_NOWAIT); 301 if (ki->ki_map == NULL) { 302 printf("kdb%d: cannot get memory for ptes\n", kdbnum); 303 return; 304 } 305 ki->ki_ptephys = PHYS(long, ki->ki_pte); /* kvtophys(ki->ki_pte) */ 306 ki->ki_flags = KDB_ALIVE; 307 308 /* THE FOLLOWING IS ONLY NEEDED TO CIRCUMVENT A BUG IN rminit */ 309 bzero((caddr_t)ki->ki_map, KI_MAPSIZ * sizeof(struct map)); 310 311 rminit(ki->ki_map, (long)KI_PTES, (long)1, "kdb", KI_MAPSIZ); 312 313 /* 314 * Set up the generic MSCP structures. 315 */ 316 mi->mi_md = &kdbmscpdriver; 317 mi->mi_ctlr = kdbnum; /* also sets ki->ki_ctlr */ 318 mi->mi_tab = &ki->ki_tab; 319 mi->mi_ip = kdbip[kdbnum]; 320 mi->mi_cmd.mri_size = NCMD; 321 mi->mi_cmd.mri_desc = ki->ki_ca.ca_cmddsc; 322 mi->mi_cmd.mri_ring = ki->ki_cmd; 323 mi->mi_rsp.mri_size = NRSP; 324 mi->mi_rsp.mri_desc = ki->ki_ca.ca_rspdsc; 325 mi->mi_rsp.mri_ring = ki->ki_rsp; 326 mi->mi_wtab.av_forw = mi->mi_wtab.av_back = &mi->mi_wtab; 327 #undef mi 328 } 329 330 /* 331 * Find a slave. 332 * Note that by the time kdbslave is called, the interrupt vector 333 * for the KDB50 has been set up (so that kdbunconf() will be called). 334 */ 335 kdbslave(ui) 336 register struct uba_device *ui; 337 { 338 register struct kdbinfo *ki; 339 register struct mscp *mp; 340 int next = 0, type, timeout, tries, i; 341 342 #ifdef lint 343 i = 0; i = i; 344 #endif 345 /* 346 * Make sure the controller is fully initialised, by waiting 347 * for it if necessary. 348 */ 349 ki = &kdbinfo[ui->ui_ctlr]; 350 if (ki->ki_state == ST_RUN) 351 goto findunit; 352 tries = 0; 353 again: 354 if (kdbinit(ki)) 355 return (0); 356 timeout = todr() + 1000; /* 10 seconds */ 357 while (todr() < timeout) 358 if (ki->ki_state == ST_RUN) /* made it */ 359 goto findunit; 360 if (++tries < 2) 361 goto again; 362 printf("kdb%d: controller hung\n", ki->ki_ctlr); 363 return (0); 364 365 /* 366 * The controller is all set; go find the unit. Grab an 367 * MSCP packet and send out a Get Unit Status command, with 368 * the `next unit' modifier if we are looking for a generic 369 * unit. We set the `in slave' flag so that kdbunconf() 370 * knows to copy the response to `kdbslavereply'. 371 */ 372 findunit: 373 kdbslavereply.mscp_opcode = 0; 374 ki->ki_flags |= KDB_INSLAVE; 375 if ((mp = mscp_getcp(&ki->ki_mi, MSCP_DONTWAIT)) == NULL) 376 panic("kdbslave"); /* `cannot happen' */ 377 mp->mscp_opcode = M_OP_GETUNITST; 378 if (ui->ui_slave == '?') { 379 mp->mscp_unit = next; 380 mp->mscp_modifier = M_GUM_NEXTUNIT; 381 } else { 382 mp->mscp_unit = ui->ui_slave; 383 mp->mscp_modifier = 0; 384 } 385 *mp->mscp_addr |= MSCP_OWN | MSCP_INT; 386 i = ki->ki_kdb->kdb_ip; /* initiate polling */ 387 mp = &kdbslavereply; 388 timeout = todr() + 1000; 389 while (todr() < timeout) 390 if (mp->mscp_opcode) 391 goto gotit; 392 printf("kdb%d: no response to Get Unit Status request\n", 393 ki->ki_ctlr); 394 ki->ki_flags &= ~KDB_INSLAVE; 395 return (0); 396 397 gotit: 398 ki->ki_flags &= ~KDB_INSLAVE; 399 400 /* 401 * Got a slave response. If the unit is there, use it. 402 */ 403 switch (mp->mscp_status & M_ST_MASK) { 404 405 case M_ST_SUCCESS: /* worked */ 406 case M_ST_AVAILABLE: /* found another drive */ 407 break; /* use it */ 408 409 case M_ST_OFFLINE: 410 /* 411 * Figure out why it is off line. It may be because 412 * it is nonexistent, or because it is spun down, or 413 * for some other reason. 414 */ 415 switch (mp->mscp_status & ~M_ST_MASK) { 416 417 case M_OFFLINE_UNKNOWN: 418 /* 419 * No such drive, and there are none with 420 * higher unit numbers either, if we are 421 * using M_GUM_NEXTUNIT. 422 */ 423 return (0); 424 425 case M_OFFLINE_UNMOUNTED: 426 /* 427 * The drive is not spun up. Use it anyway. 428 * 429 * N.B.: this seems to be a common occurrance 430 * after a power failure. The first attempt 431 * to bring it on line seems to spin it up 432 * (and thus takes several minutes). Perhaps 433 * we should note here that the on-line may 434 * take longer than usual. 435 */ 436 break; 437 438 default: 439 /* 440 * In service, or something else equally unusable. 441 */ 442 printf("kdb%d: unit %d off line:", ki->ki_ctlr, 443 mp->mscp_unit); 444 mscp_printevent(mp); 445 goto try_another; 446 } 447 break; 448 449 default: 450 printf("kdb%d: unable to get unit status:", ki->ki_ctlr); 451 mscp_printevent(mp); 452 return (0); 453 } 454 455 /* 456 * Does this ever happen? What (if anything) does it mean? 457 */ 458 if (mp->mscp_unit < next) { 459 printf("kdb%d: unit %d, next %d\n", 460 ki->ki_ctlr, mp->mscp_unit, next); 461 return (0); 462 } 463 464 if (mp->mscp_unit >= MAXUNIT) { 465 printf("kdb%d: cannot handle unit number %d (max is %d)\n", 466 ki->ki_ctlr, mp->mscp_unit, MAXUNIT - 1); 467 return (0); 468 } 469 470 /* 471 * See if we already handle this drive. 472 * (Only likely if ui->ui_slave=='?'.) 473 */ 474 if (kdbip[ki->ki_ctlr][mp->mscp_unit] != NULL) 475 goto try_another; 476 477 /* 478 * Make sure we know about this kind of drive. 479 * Others say we should treat unknowns as RA81s; I am 480 * not sure this is safe. 481 */ 482 type = mp->mscp_guse.guse_drivetype; 483 if (type >= NTYPES || kdbtypes[type].ut_name == 0) { 484 register long id = mp->mscp_guse.guse_mediaid; 485 486 printf("kdb%d: unit %d: media ID `", ki->ki_ctlr, 487 mp->mscp_unit); 488 printf("%c%c %c%c%c%d", 489 MSCP_MID_CHAR(4, id), MSCP_MID_CHAR(3, id), 490 MSCP_MID_CHAR(2, id), MSCP_MID_CHAR(1, id), 491 MSCP_MID_CHAR(0, id), MSCP_MID_NUM(id)); 492 printf("' is of unknown type %d; ignored\n", type); 493 try_another: 494 if (ui->ui_slave != '?') 495 return (0); 496 next = mp->mscp_unit + 1; 497 goto findunit; 498 } 499 500 /* 501 * Voila! 502 */ 503 ui->ui_type = type; 504 ui->ui_flags = 0; /* not on line, nor anything else */ 505 ui->ui_slave = mp->mscp_unit; 506 return (1); 507 } 508 509 /* 510 * Attach a found slave. Make sure the watchdog timer is running. 511 * If this disk is being profiled, fill in the `wpms' value (used by 512 * what?). Set up the inverting pointer, and attempt to bring the 513 * drive on line. 514 */ 515 kdbattach(ui) 516 register struct uba_device *ui; 517 { 518 519 if (kdbwstart == 0) { 520 timeout(kdbwatch, (caddr_t)0, hz); 521 kdbwstart++; 522 } 523 if (ui->ui_dk >= 0) 524 dk_wpms[ui->ui_dk] = (60 * 31 * 256); /* approx */ 525 kdbip[ui->ui_ctlr][ui->ui_slave] = ui; 526 (void) kdb_bringonline(ui, 1); 527 /* should we get its status too? */ 528 } 529 530 /* 531 * Initialise a KDB50. Return true iff something goes wrong. 532 */ 533 kdbinit(ki) 534 register struct kdbinfo *ki; 535 { 536 register struct kdb_regs *ka = ki->ki_kdb; 537 int timo; 538 539 /* 540 * While we are thinking about it, reset the next command 541 * and response indicies. 542 */ 543 ki->ki_mi.mi_cmd.mri_next = 0; 544 ki->ki_mi.mi_rsp.mri_next = 0; 545 546 /* 547 * Start up the hardware initialisation sequence. 548 */ 549 #define STEP0MASK (KDB_ERR | KDB_STEP4 | KDB_STEP3 | KDB_STEP2 | KDB_STEP1) 550 551 ki->ki_state = ST_IDLE; /* in case init fails */ 552 553 bi_reset(&ka->kdb_bi); /* reset bi node (but not the BI itself) */ 554 555 timo = todr() + 1000; 556 while ((ka->kdb_sa & STEP0MASK) == 0) { 557 if (todr() > timo) { 558 printf("kdb%d: timeout during init\n", ki->ki_ctlr); 559 return (-1); 560 } 561 } 562 if ((ka->kdb_sa & STEP0MASK) != KDB_STEP1) { 563 printf("kdb%d: init failed, sa=%b\n", ki->ki_ctlr, 564 ka->kdb_sa, kdbsr_bits); 565 return (-1); 566 } 567 568 /* 569 * Success! Record new state, and start step 1 initialisation. 570 * The rest is done in the interrupt handler. 571 */ 572 ki->ki_state = ST_STEP1; 573 ka->kdb_bi.bi_intrdes = 1 << mastercpu; 574 #ifdef unneeded /* is it? */ 575 ka->kdb_bi.bi_csr = (ka->kdb_bi.bi_csr&~BICSR_ARB_MASK)|BICSR_ARB_???; 576 #endif 577 ka->kdb_bi.bi_bcicsr |= BCI_STOPEN | BCI_IDENTEN | BCI_UINTEN | 578 BCI_INTEN; 579 580 /* I THINK THIS IS WRONG */ 581 /* Mach uses 0x601d0, which includes IPL16, but 1d0 is IPL17, nexzvec...? */ 582 ka->kdb_bi.bi_eintrcsr = BIEIC_IPL15 | ki->ki_vec; /* ??? */ 583 /* END I THINK WRONG */ 584 585 ka->kdb_bi.bi_uintrcsr = ki->ki_vec; 586 ka->kdb_sw = KDB_ERR | (NCMDL2 << 11) | (NRSPL2 << 8) | KDB_IE | 587 (ki->ki_vec >> 2); 588 return (0); 589 } 590 591 /* 592 * Open a drive. 593 */ 594 /*ARGSUSED*/ 595 kdbopen(dev, flag) 596 dev_t dev; 597 int flag; 598 { 599 register int unit; 600 register struct uba_device *ui; 601 register struct kdbinfo *ki; 602 int s; 603 604 /* 605 * Make sure this is a reasonable open request. 606 */ 607 unit = kdbunit(dev); 608 if (unit >= NKRA || (ui = kdbdinfo[unit]) == 0 || ui->ui_alive == 0) 609 return (ENXIO); 610 611 /* 612 * Make sure the controller is running, by (re)initialising it if 613 * necessary. 614 */ 615 ki = &kdbinfo[ui->ui_ctlr]; 616 s = spl5(); 617 if (ki->ki_state != ST_RUN) { 618 if (ki->ki_state == ST_IDLE && kdbinit(ki)) { 619 splx(s); 620 return (EIO); 621 } 622 /* 623 * In case it does not come up, make sure we will be 624 * restarted in 10 seconds. This corresponds to the 625 * 10 second timeouts in kdbprobe() and kdbslave(). 626 */ 627 ki->ki_flags |= KDB_DOWAKE; 628 timeout(wakeup, (caddr_t)&ki->ki_flags, 10 * hz); 629 sleep((caddr_t)&ki->ki_flags, PRIBIO); 630 if (ki->ki_state != ST_RUN) { 631 splx(s); 632 printf("kdb%d: controller hung\n", ui->ui_ctlr); 633 return (EIO); 634 } 635 untimeout(wakeup, (caddr_t)&ki->ki_flags); 636 } 637 if ((ui->ui_flags & UNIT_ONLINE) == 0) { 638 /* 639 * Bring the drive on line so we can find out how 640 * big it is. If it is not spun up, it will not 641 * come on line; this cannot really be considered 642 * an `error condition'. 643 */ 644 if (kdb_bringonline(ui, 0)) { 645 splx(s); 646 printf("%s%d: drive will not come on line\n", 647 kdbdriver.ud_dname, unit); 648 return (EIO); 649 } 650 } 651 splx(s); 652 return (0); 653 } 654 655 /* 656 * Bring a drive on line. In case it fails to respond, we set 657 * a timeout on it. The `nosleep' parameter should be set if 658 * we are to spin-wait; otherwise this must be called at spl5(). 659 */ 660 kdb_bringonline(ui, nosleep) 661 register struct uba_device *ui; 662 int nosleep; 663 { 664 register struct kdbinfo *ki = &kdbinfo[ui->ui_ctlr]; 665 register struct mscp *mp; 666 int i; 667 668 if (nosleep) { 669 mp = mscp_getcp(&ki->ki_mi, MSCP_DONTWAIT); 670 if (mp == NULL) 671 return (-1); 672 } else 673 mp = mscp_getcp(&ki->ki_mi, MSCP_WAIT); 674 mp->mscp_opcode = M_OP_ONLINE; 675 mp->mscp_unit = ui->ui_slave; 676 mp->mscp_cmdref = (long)&ui->ui_flags; 677 *mp->mscp_addr |= MSCP_OWN | MSCP_INT; 678 i = ki->ki_kdb->kdb_ip; 679 680 if (nosleep) { 681 i = todr() + 1000; 682 while ((ui->ui_flags & UNIT_ONLINE) == 0) 683 if (todr() > i) 684 return (-1); 685 } else { 686 timeout(wakeup, (caddr_t)&ui->ui_flags, 10 * hz); 687 sleep((caddr_t)&ui->ui_flags, PRIBIO); 688 if ((ui->ui_flags & UNIT_ONLINE) == 0) 689 return (-1); 690 untimeout(wakeup, (caddr_t)&ui->ui_flags); 691 } 692 return (0); /* made it */ 693 } 694 695 /* 696 * Queue a transfer request, and if possible, hand it to the controller. 697 * 698 * This routine is broken into two so that the internal version 699 * kdbstrat1() can be called by the (nonexistent, as yet) bad block 700 * revectoring routine. 701 */ 702 kdbstrategy(bp) 703 register struct buf *bp; 704 { 705 register int unit; 706 register struct uba_device *ui; 707 register struct size *st; 708 daddr_t sz, maxsz; 709 710 /* 711 * Make sure this is a reasonable drive to use. 712 */ 713 if ((unit = kdbunit(bp->b_dev)) >= NKRA || 714 (ui = kdbdinfo[unit]) == NULL || ui->ui_alive == 0) { 715 bp->b_error = ENXIO; 716 bp->b_flags |= B_ERROR; 717 biodone(bp); 718 return; 719 } 720 721 /* 722 * Determine the size of the transfer, and make sure it is 723 * within the boundaries of the drive. 724 */ 725 sz = (bp->b_bcount + 511) >> 9; 726 st = &kdbtypes[ui->ui_type].ut_sizes[kdbpart(bp->b_dev)]; 727 if ((maxsz = st->nblocks) < 0) 728 maxsz = ra_dsize[unit] - st->blkoff; 729 if (bp->b_blkno < 0 || bp->b_blkno + sz > maxsz || 730 st->blkoff >= ra_dsize[unit]) { 731 /* if exactly at end of disk, return an EOF */ 732 if (bp->b_blkno == maxsz) 733 bp->b_resid = bp->b_bcount; 734 else { 735 bp->b_error = EINVAL; 736 bp->b_flags |= B_ERROR; 737 } 738 biodone(bp); 739 return; 740 } 741 kdbstrat1(bp); 742 } 743 744 /* 745 * Work routine for kdbstrategy. 746 */ 747 kdbstrat1(bp) 748 register struct buf *bp; 749 { 750 register int unit = kdbunit(bp->b_dev); 751 register struct buf *dp; 752 register struct kdbinfo *ki; 753 struct uba_device *ui; 754 int s; 755 756 /* 757 * Append the buffer to the drive queue, and if it is not 758 * already there, the drive to the controller queue. (However, 759 * if the drive queue is marked to be requeued, we must be 760 * awaiting an on line or get unit status command; in this 761 * case, leave it off the controller queue.) 762 */ 763 ui = kdbdinfo[unit]; 764 ki = &kdbinfo[ui->ui_ctlr]; 765 dp = &kdbutab[unit]; 766 s = spl5(); 767 APPEND(bp, dp, av_forw); 768 if (dp->b_active == 0 && (ui->ui_flags & UNIT_REQUEUE) == 0) { 769 APPEND(dp, &ki->ki_tab, b_forw); 770 dp->b_active++; 771 } 772 773 /* 774 * Start activity on the controller. 775 */ 776 kdbstart(ki); 777 splx(s); 778 } 779 780 /* 781 * Find the physical address of some contiguous PTEs that map the 782 * transfer described in `bp', creating them (by copying) if 783 * necessary. Store the physical base address of the map through 784 * mapbase, and the page offset through offset, and any resource 785 * information in *info (or 0 if none). 786 * 787 * If we cannot allocate space, return a nonzero status. 788 */ 789 int 790 kdbmap(ki, bp, mapbase, offset, info) 791 struct kdbinfo *ki; 792 register struct buf *bp; 793 long *mapbase, *offset; 794 int *info; 795 { 796 register struct pte *spte, *dpte; 797 register struct proc *rp; 798 register int i, a, o; 799 u_int v; 800 int npf; 801 802 o = (int)bp->b_un.b_addr & PGOFSET; 803 804 /* handle contiguous cases */ 805 if ((bp->b_flags & B_PHYS) == 0) { 806 spte = kvtopte(bp->b_un.b_addr); 807 kdbstats.ks_sys++; 808 *mapbase = PHYS(long, spte); 809 *offset = o; 810 *info = 0; 811 return (0); 812 } 813 if (bp->b_flags & B_PAGET) { 814 spte = &Usrptmap[btokmx((struct pte *)bp->b_un.b_addr)]; 815 if (spte->pg_v == 0) panic("kdbmap"); 816 kdbstats.ks_paget++; 817 *mapbase = PHYS(long, spte); 818 *offset = o; 819 *info = 0; 820 return (0); 821 } 822 823 /* potentially discontiguous or invalid ptes */ 824 v = btop(bp->b_un.b_addr); 825 rp = bp->b_flags & B_DIRTY ? &proc[2] : bp->b_proc; 826 if (bp->b_flags & B_UAREA) 827 spte = &rp->p_addr[v]; 828 else 829 spte = vtopte(rp, v); 830 npf = btoc(bp->b_bcount + o); 831 832 #ifdef notdef 833 /* 834 * The current implementation of the VM system requires 835 * that all of these be done with a copy. Even if the 836 * PTEs could be used now, they may be snatched out from 837 * under us later. It would be nice if we could stop that.... 838 */ 839 840 /* check for invalid */ 841 /* CONSIDER CHANGING VM TO VALIDATE PAGES EARLIER */ 842 for (dpte = spte, i = npf; --i >= 0; dpte++) 843 if (dpte->pg_v == 0) 844 goto copy1; 845 /* 846 * Check for discontiguous physical pte addresses. It is 847 * not necessary to check each pte, since they come in clumps 848 * of pages. 849 */ 850 i = howmany(npf + (((int)spte & PGOFSET) / sizeof (*spte)), NPTEPG); 851 /* often i==1, and we can avoid work */ 852 if (--i > 0) { 853 dpte = kvtopte(spte); 854 a = dpte->pg_pfnum; 855 while (--i >= 0) 856 if ((++dpte)->pg_pfnum != ++a) 857 goto copy2; 858 } 859 860 /* made it */ 861 kdbstats.ks_contig++; 862 *mapbase = kvtophys(spte); 863 *offset = o; 864 *info = 0; 865 return (0); 866 867 copy1: 868 kdbstats.ks_inval++; /* temp */ 869 copy2: 870 #endif /* notdef */ 871 kdbstats.ks_copies++; 872 i = npf + 1; 873 if ((a = rmalloc(ki->ki_map, (long)i)) == 0) { 874 kdbstats.ks_mapwait++; 875 return (-1); 876 } 877 *info = (i << 16) | a; 878 a--; 879 /* if offset > PGOFSET, btop(offset) indexes mapbase */ 880 *mapbase = ki->ki_ptephys; 881 *offset = (a << PGSHIFT) | o; 882 dpte = &ki->ki_pte[a]; 883 while (--i > 0) 884 *(int *)dpte++ = PG_V | *(int *)spte++; 885 *(int *)dpte = 0; 886 return (0); 887 } 888 889 #define KDBFREE(ki, info) if (info) \ 890 rmfree((ki)->ki_map, (long)((info) >> 16), (long)((info) & 0xffff)) 891 892 /* 893 * Start up whatever transfers we can find. 894 * Note that kdbstart() must be called at spl5(). 895 */ 896 kdbstart(ki) 897 register struct kdbinfo *ki; 898 { 899 register struct buf *bp, *dp; 900 register struct mscp *mp; 901 register struct uba_device *ui; 902 long mapbase, offset; 903 int info, ncmd = 0; 904 905 /* 906 * If it is not running, try (again and again...) to initialise 907 * it. If it is currently initialising just ignore it for now. 908 */ 909 if (ki->ki_state != ST_RUN) { 910 if (ki->ki_state == ST_IDLE && kdbinit(ki)) 911 printf("kdb%d: still hung\n", ki->ki_ctlr); 912 return; 913 } 914 915 loop: 916 /* if insufficient credit, avoid overhead */ 917 if (ki->ki_mi.mi_credits <= MSCP_MINCREDITS) 918 goto out; 919 920 /* 921 * Service the drive at the head of the queue. It may not 922 * need anything; eventually this will finish up the close 923 * protocol, but that is yet to be implemented here. 924 */ 925 if ((dp = ki->ki_tab.b_actf) == NULL) 926 goto out; 927 if ((bp = dp->b_actf) == NULL) { 928 dp->b_active = 0; 929 ki->ki_tab.b_actf = dp->b_forw; 930 goto loop; 931 } 932 933 if (ki->ki_kdb->kdb_sa & KDB_ERR) { /* ctlr fatal error */ 934 kdbsaerror(ki); 935 goto out; 936 } 937 938 /* find or create maps for this transfer */ 939 if (kdbmap(ki, bp, &mapbase, &offset, &info)) 940 goto out; /* effectively, resource wait */ 941 942 /* 943 * Get an MSCP packet, then figure out what to do. If 944 * we cannot get a command packet, the command ring may 945 * be too small: We should have at least as many command 946 * packets as credits, for best performance. 947 */ 948 if ((mp = mscp_getcp(&ki->ki_mi, MSCP_DONTWAIT)) == NULL) { 949 if (ki->ki_mi.mi_credits > MSCP_MINCREDITS && 950 (ki->ki_flags & KDB_GRIPED) == 0) { 951 log(LOG_NOTICE, "kdb%d: command ring too small\n", 952 ki->ki_ctlr); 953 ki->ki_flags |= KDB_GRIPED;/* complain only once */ 954 } 955 KDBFREE(ki, info); 956 goto out; 957 } 958 959 /* 960 * Bring the drive on line if it is not already. Get its status 961 * if we do not already have it. Otherwise just start the transfer. 962 */ 963 ui = kdbdinfo[kdbunit(bp->b_dev)]; 964 if ((ui->ui_flags & UNIT_ONLINE) == 0) { 965 mp->mscp_opcode = M_OP_ONLINE; 966 goto common; 967 } 968 if ((ui->ui_flags & UNIT_HAVESTATUS) == 0) { 969 mp->mscp_opcode = M_OP_GETUNITST; 970 common: 971 if (ui->ui_flags & UNIT_REQUEUE) panic("kdbstart"); 972 /* 973 * Take the drive off the controller queue. When the 974 * command finishes, make sure the drive is requeued. 975 * Give up any mapping (not needed now). This last is 976 * not efficient, but is rare. 977 */ 978 KDBFREE(ki, info); 979 ki->ki_tab.b_actf = dp->b_forw; 980 dp->b_active = 0; 981 ui->ui_flags |= UNIT_REQUEUE; 982 mp->mscp_unit = ui->ui_slave; 983 *mp->mscp_addr |= MSCP_OWN | MSCP_INT; 984 ncmd++; 985 goto loop; 986 } 987 988 mp->mscp_opcode = (bp->b_flags & B_READ) ? M_OP_READ : M_OP_WRITE; 989 mp->mscp_unit = ui->ui_slave; 990 mp->mscp_seq.seq_lbn = bp->b_blkno + 991 kdbtypes[ui->ui_type].ut_sizes[kdbpart(bp->b_dev)].blkoff; 992 mp->mscp_seq.seq_bytecount = bp->b_bcount; 993 994 mp->mscp_seq.seq_buffer = offset | KDB_MAP; 995 mp->mscp_seq.seq_mapbase = mapbase; 996 997 /* profile the drive */ 998 if (ui->ui_dk >= 0) { 999 dk_busy |= 1 << ui->ui_dk; 1000 dk_xfer[ui->ui_dk]++; 1001 dk_wds[ui->ui_dk] += bp->b_bcount >> 6; 1002 } 1003 1004 /* 1005 * Fill in the rest of the MSCP packet and move the buffer to the 1006 * I/O wait queue. 1007 */ 1008 mscp_go(&ki->ki_mi, mp, info); 1009 ncmd++; /* note the transfer */ 1010 ki->ki_tab.b_active++; /* another one going */ 1011 goto loop; 1012 1013 out: 1014 if (ncmd >= KS_MAXC) 1015 ncmd = KS_MAXC - 1; 1016 kdbstats.ks_cmd[ncmd]++; 1017 if (ncmd) /* start some transfers */ 1018 ncmd = ki->ki_kdb->kdb_ip; 1019 } 1020 1021 /* ARGSUSED */ 1022 kdbiodone(mi, bp, info) 1023 struct mscp_info *mi; 1024 struct buf *bp; 1025 int info; 1026 { 1027 register struct kdbinfo *ki = &kdbinfo[mi->mi_ctlr]; 1028 1029 KDBFREE(ki, info); 1030 biodone(bp); 1031 ki->ki_tab.b_active--; /* another one done */ 1032 } 1033 1034 /* 1035 * The error bit was set in the controller status register. Gripe, 1036 * reset the controller, requeue pending transfers. 1037 */ 1038 kdbsaerror(ki) 1039 register struct kdbinfo *ki; 1040 { 1041 1042 printf("kdb%d: controller error, sa=%b\n", ki->ki_ctlr, 1043 ki->ki_kdb->kdb_sa, kdbsr_bits); 1044 mscp_requeue(&ki->ki_mi); 1045 (void) kdbinit(ki); 1046 } 1047 1048 /* 1049 * Interrupt routine. Depending on the state of the controller, 1050 * continue initialisation, or acknowledge command and response 1051 * interrupts, and process responses. 1052 */ 1053 kdbintr(ctlr) 1054 int ctlr; 1055 { 1056 register struct kdbinfo *ki = &kdbinfo[ctlr]; 1057 register struct kdb_regs *kdbaddr = ki->ki_kdb; 1058 register struct mscp *mp; 1059 register int i; 1060 1061 ki->ki_wticks = 0; /* reset interrupt watchdog */ 1062 1063 /* 1064 * Combinations during steps 1, 2, and 3: STEPnMASK 1065 * corresponds to which bits should be tested; 1066 * STEPnGOOD corresponds to the pattern that should 1067 * appear after the interrupt from STEPn initialisation. 1068 * All steps test the bits in ALLSTEPS. 1069 */ 1070 #define ALLSTEPS (KDB_ERR|KDB_STEP4|KDB_STEP3|KDB_STEP2|KDB_STEP1) 1071 1072 #define STEP1MASK (ALLSTEPS | KDB_IE | KDB_NCNRMASK) 1073 #define STEP1GOOD (KDB_STEP2 | KDB_IE | (NCMDL2 << 3) | NRSPL2) 1074 1075 #define STEP2MASK (ALLSTEPS | KDB_IE | KDB_IVECMASK) 1076 #define STEP2GOOD (KDB_STEP3 | KDB_IE | (ki->ki_vec >> 2)) 1077 1078 #define STEP3MASK ALLSTEPS 1079 #define STEP3GOOD KDB_STEP4 1080 1081 switch (ki->ki_state) { 1082 1083 case ST_IDLE: 1084 /* 1085 * Ignore unsolicited interrupts. 1086 */ 1087 log(LOG_WARNING, "kdb%d: stray intr\n", ctlr); 1088 return; 1089 1090 case ST_STEP1: 1091 /* 1092 * Begin step two initialisation. 1093 */ 1094 if ((kdbaddr->kdb_sa & STEP1MASK) != STEP1GOOD) { 1095 i = 1; 1096 initfailed: 1097 printf("kdb%d: init step %d failed, sa=%b\n", 1098 ctlr, i, kdbaddr->kdb_sa, kdbsr_bits); 1099 ki->ki_state = ST_IDLE; 1100 if (ki->ki_flags & KDB_DOWAKE) { 1101 ki->ki_flags &= ~KDB_DOWAKE; 1102 wakeup((caddr_t)&ki->ki_flags); 1103 } 1104 return; 1105 } 1106 kdbaddr->kdb_sw = PHYS(int, &ki->ki_ca.ca_rspdsc[0]); 1107 ki->ki_state = ST_STEP2; 1108 return; 1109 1110 case ST_STEP2: 1111 /* 1112 * Begin step 3 initialisation. 1113 */ 1114 if ((kdbaddr->kdb_sa & STEP2MASK) != STEP2GOOD) { 1115 i = 2; 1116 goto initfailed; 1117 } 1118 kdbaddr->kdb_sw = PHYS(int, &ki->ki_ca.ca_rspdsc[0]) >> 16; 1119 ki->ki_state = ST_STEP3; 1120 return; 1121 1122 case ST_STEP3: 1123 /* 1124 * Set controller characteristics (finish initialisation). 1125 */ 1126 if ((kdbaddr->kdb_sa & STEP3MASK) != STEP3GOOD) { 1127 i = 3; 1128 goto initfailed; 1129 } 1130 i = kdbaddr->kdb_sa & 0xff; 1131 if (i != ki->ki_micro) { 1132 ki->ki_micro = i; 1133 printf("kdb%d: version %d model %d\n", 1134 ctlr, i & 0xf, i >> 4); 1135 } 1136 1137 kdbaddr->kdb_sw = KDB_GO; 1138 1139 /* initialise hardware data structures */ 1140 for (i = 0, mp = ki->ki_rsp; i < NRSP; i++, mp++) { 1141 ki->ki_ca.ca_rspdsc[i] = MSCP_OWN | MSCP_INT | 1142 PHYS(long, &ki->ki_rsp[i].mscp_cmdref); 1143 mp->mscp_addr = &ki->ki_ca.ca_rspdsc[i]; 1144 mp->mscp_msglen = MSCP_MSGLEN; 1145 } 1146 for (i = 0, mp = ki->ki_cmd; i < NCMD; i++, mp++) { 1147 ki->ki_ca.ca_cmddsc[i] = MSCP_INT | 1148 PHYS(long, &ki->ki_cmd[i].mscp_cmdref); 1149 mp->mscp_addr = &ki->ki_ca.ca_cmddsc[i]; 1150 mp->mscp_msglen = MSCP_MSGLEN; 1151 } 1152 1153 /* 1154 * Before we can get a command packet, we need some 1155 * credits. Fake some up to keep mscp_getcp() happy, 1156 * get a packet, and cancel all credits (the right 1157 * number should come back in the response to the 1158 * SCC packet). 1159 */ 1160 ki->ki_mi.mi_credits = MSCP_MINCREDITS + 1; 1161 mp = mscp_getcp(&ki->ki_mi, MSCP_DONTWAIT); 1162 if (mp == NULL) /* `cannot happen' */ 1163 panic("kdbintr"); 1164 ki->ki_mi.mi_credits = 0; 1165 mp->mscp_opcode = M_OP_SETCTLRC; 1166 mp->mscp_unit = 0; 1167 mp->mscp_sccc.sccc_ctlrflags = M_CF_ATTN | M_CF_MISC | 1168 M_CF_THIS; 1169 *mp->mscp_addr |= MSCP_OWN | MSCP_INT; 1170 i = kdbaddr->kdb_ip; 1171 ki->ki_state = ST_SETCHAR; 1172 return; 1173 1174 case ST_SETCHAR: 1175 case ST_RUN: 1176 /* 1177 * Handle Set Ctlr Characteristics responses and operational 1178 * responses (via mscp_dorsp). 1179 */ 1180 break; 1181 1182 default: 1183 log(LOG_ERR, "kdb%d: driver bug, state %d\n", ctlr, 1184 ki->ki_state); 1185 return; 1186 } 1187 1188 if (kdbaddr->kdb_sa & KDB_ERR) {/* ctlr fatal error */ 1189 kdbsaerror(ki); 1190 return; 1191 } 1192 1193 /* 1194 * Handle buffer purge requests. 1195 * KDB DOES NOT HAVE BDPs 1196 */ 1197 if (ki->ki_ca.ca_bdp) { 1198 printf("kdb%d: purge bdp %d\n", ctlr, ki->ki_ca.ca_bdp); 1199 panic("kdb purge"); 1200 } 1201 1202 /* 1203 * Check for response and command ring transitions. 1204 */ 1205 if (ki->ki_ca.ca_rspint) { 1206 ki->ki_ca.ca_rspint = 0; 1207 mscp_dorsp(&ki->ki_mi); 1208 } 1209 if (ki->ki_ca.ca_cmdint) { 1210 ki->ki_ca.ca_cmdint = 0; 1211 MSCP_DOCMD(&ki->ki_mi); 1212 } 1213 if (ki->ki_tab.b_actf != NULL) 1214 kdbstart(ki); 1215 } 1216 1217 /* 1218 * Handle an error datagram. All we do now is decode it. 1219 */ 1220 kdbdgram(mi, mp) 1221 struct mscp_info *mi; 1222 struct mscp *mp; 1223 { 1224 1225 mscp_decodeerror(mi->mi_md->md_mname, mi->mi_ctlr, mp); 1226 } 1227 1228 /* 1229 * The Set Controller Characteristics command finished. 1230 * Record the new state of the controller. 1231 */ 1232 kdbctlrdone(mi, mp) 1233 struct mscp_info *mi; 1234 struct mscp *mp; 1235 { 1236 register struct kdbinfo *ki = &kdbinfo[mi->mi_ctlr]; 1237 1238 if ((mp->mscp_status & M_ST_MASK) == M_ST_SUCCESS) 1239 ki->ki_state = ST_RUN; 1240 else { 1241 printf("kdb%d: SETCTLRC failed, status 0x%x\n", 1242 ki->ki_ctlr, mp->mscp_status); 1243 ki->ki_state = ST_IDLE; 1244 } 1245 if (ki->ki_flags & KDB_DOWAKE) { 1246 ki->ki_flags &= ~KDB_DOWAKE; 1247 wakeup((caddr_t)&ki->ki_flags); 1248 } 1249 } 1250 1251 /* 1252 * Received a response from an as-yet unconfigured drive. Configure it 1253 * in, if possible. 1254 */ 1255 kdbunconf(mi, mp) 1256 struct mscp_info *mi; 1257 register struct mscp *mp; 1258 { 1259 1260 /* 1261 * If it is a slave response, copy it to kdbslavereply for 1262 * kdbslave() to look at. 1263 */ 1264 if (mp->mscp_opcode == (M_OP_GETUNITST | M_OP_END) && 1265 (kdbinfo[mi->mi_ctlr].ki_flags & KDB_INSLAVE) != 0) { 1266 kdbslavereply = *mp; 1267 return (MSCP_DONE); 1268 } 1269 1270 /* 1271 * Otherwise, it had better be an available attention response. 1272 */ 1273 if (mp->mscp_opcode != M_OP_AVAILATTN) 1274 return (MSCP_FAILED); 1275 1276 /* do what autoconf does */ 1277 return (MSCP_FAILED); /* not yet */ 1278 } 1279 1280 /* 1281 * A drive came on line. Check its type and size. Return DONE if 1282 * we think the drive is truly on line. In any case, awaken anyone 1283 * sleeping on the drive on-line-ness. 1284 */ 1285 kdbonline(ui, mp) 1286 register struct uba_device *ui; 1287 struct mscp *mp; 1288 { 1289 register int type; 1290 1291 wakeup((caddr_t)&ui->ui_flags); 1292 if ((mp->mscp_status & M_ST_MASK) != M_ST_SUCCESS) { 1293 printf("kdb%d: attempt to bring %s%d on line failed:", 1294 ui->ui_ctlr, kdbdriver.ud_dname, ui->ui_unit); 1295 mscp_printevent(mp); 1296 return (MSCP_FAILED); 1297 } 1298 1299 type = mp->mscp_onle.onle_drivetype; 1300 if (type >= NTYPES || kdbtypes[type].ut_name == 0) { 1301 printf("kdb%d: %s%d: unknown type %d\n", 1302 ui->ui_ctlr, kdbdriver.ud_dname, ui->ui_unit, type); 1303 return (MSCP_FAILED); 1304 } 1305 /* 1306 * Note any change of types. Not sure if we should do 1307 * something special about them, or if so, what.... 1308 */ 1309 if (type != ui->ui_type) { 1310 printf("%s%d: changed types! was %s\n", 1311 kdbdriver.ud_dname, ui->ui_unit, 1312 kdbtypes[ui->ui_type].ut_name); 1313 ui->ui_type = type; 1314 } 1315 ra_dsize[ui->ui_unit] = (daddr_t) mp->mscp_onle.onle_unitsize; 1316 printf("%s%d: %s, size = %d sectors\n", 1317 kdbdriver.ud_dname, ui->ui_unit, 1318 kdbtypes[type].ut_name, ra_dsize[ui->ui_unit]); 1319 return (MSCP_DONE); 1320 } 1321 1322 /* 1323 * We got some (configured) unit's status. Return DONE if it succeeded. 1324 */ 1325 kdbgotstatus(ui, mp) 1326 register struct uba_device *ui; 1327 register struct mscp *mp; 1328 { 1329 1330 if ((mp->mscp_status & M_ST_MASK) != M_ST_SUCCESS) { 1331 printf("kdb%d: attempt to get status for %s%d failed:", 1332 ui->ui_ctlr, kdbdriver.ud_dname, ui->ui_unit); 1333 mscp_printevent(mp); 1334 return (MSCP_FAILED); 1335 } 1336 /* need to record later for bad block forwarding - for now, print */ 1337 printf("\ 1338 %s%d: unit %d, nspt %d, group %d, ngpc %d, rctsize %d, nrpt %d, nrct %d\n", 1339 kdbdriver.ud_dname, ui->ui_unit, mp->mscp_unit, 1340 mp->mscp_guse.guse_nspt, mp->mscp_guse.guse_group, 1341 mp->mscp_guse.guse_ngpc, mp->mscp_guse.guse_rctsize, 1342 mp->mscp_guse.guse_nrpt, mp->mscp_guse.guse_nrct); 1343 return (MSCP_DONE); 1344 } 1345 1346 /* 1347 * A transfer failed. We get a chance to fix or restart it. 1348 * Need to write the bad block forwaring code first.... 1349 */ 1350 /*ARGSUSED*/ 1351 kdbioerror(ui, mp, bp) 1352 register struct uba_device *ui; 1353 register struct mscp *mp; 1354 struct buf *bp; 1355 { 1356 1357 if (mp->mscp_flags & M_EF_BBLKR) { 1358 /* 1359 * A bad block report. Eventually we will 1360 * restart this transfer, but for now, just 1361 * log it and give up. 1362 */ 1363 log(LOG_ERR, "%s%d: bad block report: %d%s\n", 1364 kdbdriver.ud_dname, ui->ui_unit, mp->mscp_seq.seq_lbn, 1365 mp->mscp_flags & M_EF_BBLKU ? " + others" : ""); 1366 } else { 1367 /* 1368 * What the heck IS a `serious exception' anyway? 1369 */ 1370 if (mp->mscp_flags & M_EF_SEREX) 1371 log(LOG_ERR, "%s%d: serious exception reported\n", 1372 kdbdriver.ud_dname, ui->ui_unit); 1373 } 1374 return (MSCP_FAILED); 1375 } 1376 1377 1378 #ifdef notyet 1379 /* 1380 * I/O controls. Not yet! 1381 */ 1382 kdbioctl(dev, cmd, flag, data) 1383 dev_t dev; 1384 int cmd, flag; 1385 caddr_t data; 1386 { 1387 int error = 0; 1388 register int unit = kdbunit(dev); 1389 1390 if (unit >= NKRA || uddinfo[unit] == NULL) 1391 return (ENXIO); 1392 1393 switch (cmd) { 1394 1395 case KDBIOCREPLACE: 1396 /* 1397 * Initiate bad block replacement for the given LBN. 1398 * (Should we allow modifiers?) 1399 */ 1400 error = EOPNOTSUPP; 1401 break; 1402 1403 case KDBIOCGMICRO: 1404 /* 1405 * Return the microcode revision for the KDB50 running 1406 * this drive. 1407 */ 1408 *(int *)data = kdbinfo[kdbdinfo[unit]->ui_ctlr].ki_micro; 1409 break; 1410 1411 case KDBIOCGSIZE: 1412 /* 1413 * Return the size (in 512 byte blocks) of this 1414 * disk drive. 1415 */ 1416 *(daddr_t *)data = ra_dsize[unit]; 1417 break; 1418 1419 default: 1420 error = EINVAL; 1421 break; 1422 } 1423 return (error); 1424 } 1425 #endif 1426 1427 #ifdef notyet 1428 /* 1429 * Reset a KDB50 (self test and all). 1430 * What if it fails? 1431 */ 1432 kdbreset(ki) 1433 register struct kdbinfo *ki; 1434 { 1435 1436 printf("reset kdb%d", ki->ki_ctlr); 1437 bi_selftest(&ki->ki_kdb.kdb_bi); 1438 ki->ki_state = ST_IDLE; 1439 rminit(ki->ki_map, (long)KI_PTES, (long)1, "kdb", KI_MAPSIZ); 1440 mscp_requeue(&ki->ki_mi); 1441 if (kdbinit(ctlr)) 1442 printf(" (hung)"); 1443 printf("\n"); 1444 } 1445 #endif 1446 1447 /* 1448 * Watchdog timer: If the controller is active, and no interrupts 1449 * have occurred for 30 seconds, assume it has gone away. 1450 */ 1451 kdbwatch() 1452 { 1453 register struct kdbinfo *ki; 1454 register int i; 1455 1456 timeout(kdbwatch, (caddr_t)0, hz); /* every second */ 1457 for (i = 0, ki = kdbinfo; i < NKDB; i++, ki++) { 1458 if ((ki->ki_flags & KDB_ALIVE) == 0) 1459 continue; 1460 if (ki->ki_state == ST_IDLE) 1461 continue; 1462 if (ki->ki_state == ST_RUN && !ki->ki_tab.b_active) 1463 ki->ki_wticks = 0; 1464 else if (++ki->ki_wticks >= 30) { 1465 ki->ki_wticks = 0; 1466 printf("kdb%d: lost interrupt\n", i); 1467 /* kdbreset(ki); */ 1468 panic("kdb lost interrupt"); 1469 } 1470 } 1471 } 1472 1473 /* 1474 * Do a panic dump. 1475 */ 1476 #define DBSIZE 32 /* dump 16K at a time */ 1477 1478 struct kdbdumpspace { 1479 struct kdb1ca kd_ca; 1480 struct mscp kd_rsp; 1481 struct mscp kd_cmd; 1482 } kdbdumpspace; 1483 1484 kdbdump(dev) 1485 dev_t dev; 1486 { 1487 register struct kdbdumpspace *kd; 1488 register struct kdb_regs *k; 1489 register int i; 1490 struct uba_device *ui; 1491 char *start; 1492 int num, blk, unit, maxsz, blkoff; 1493 1494 /* 1495 * Make sure the device is a reasonable place on which to dump. 1496 */ 1497 unit = kdbunit(dev); 1498 if (unit >= NKRA) 1499 return (ENXIO); 1500 ui = PHYS(struct uba_device *, kdbdinfo[unit]); 1501 if (ui == NULL || ui->ui_alive == 0) 1502 return (ENXIO); 1503 1504 /* 1505 * Find and initialise the KDB; get the physical address of the 1506 * device registers, and of communications area and command and 1507 * response packet. 1508 */ 1509 k = PHYS(struct kdbinfo *, &kdbinfo[ui->ui_ctlr])->ki_physkdb; 1510 kd = PHYS(struct kdbdumpspace *, &kdbdumpspace); 1511 1512 /* 1513 * Initialise the controller, with one command and one response 1514 * packet. 1515 */ 1516 bi_reset(&k->kdb_bi); 1517 if (kdbdumpwait(k, KDB_STEP1)) 1518 return (EFAULT); 1519 k->kdb_sw = KDB_ERR; 1520 if (kdbdumpwait(k, KDB_STEP2)) 1521 return (EFAULT); 1522 k->kdb_sw = (int)&kd->kd_ca.ca_rspdsc; 1523 if (kdbdumpwait(k, KDB_STEP3)) 1524 return (EFAULT); 1525 k->kdb_sw = ((int)&kd->kd_ca.ca_rspdsc) >> 16; 1526 if (kdbdumpwait(k, KDB_STEP4)) 1527 return (EFAULT); 1528 k->kdb_sw = KDB_GO; 1529 1530 /* 1531 * Set up the command and response descriptor, then set the 1532 * controller characteristics and bring the drive on line. 1533 * Note that all uninitialised locations in kd_cmd are zero. 1534 */ 1535 kd->kd_ca.ca_rspdsc = (long)&kd->kd_rsp.mscp_cmdref; 1536 kd->kd_ca.ca_cmddsc = (long)&kd->kd_cmd.mscp_cmdref; 1537 /* kd->kd_cmd.mscp_sccc.sccc_ctlrflags = 0; */ 1538 /* kd->kd_cmd.mscp_sccc.sccc_version = 0; */ 1539 if (kdbdumpcmd(M_OP_SETCTLRC, k, kd, ui->ui_ctlr)) 1540 return (EFAULT); 1541 kd->kd_cmd.mscp_unit = ui->ui_slave; 1542 if (kdbdumpcmd(M_OP_ONLINE, k, kd, ui->ui_ctlr)) 1543 return (EFAULT); 1544 1545 /* 1546 * Pick up the drive type from the on line end packet; 1547 * convert that to a dump area size and a disk offset. 1548 * Note that the assembler uses pc-relative addressing 1549 * to get at kdbtypes[], no need for PHYS(). 1550 */ 1551 i = kd->kd_rsp.mscp_onle.onle_drivetype; 1552 if (i >= NTYPES || kdbtypes[i].ut_name == 0) { 1553 printf("disk type %d unknown\ndump "); 1554 return (EINVAL); 1555 } 1556 printf("on %s ", kdbtypes[i].ut_name); 1557 1558 maxsz = kdbtypes[i].ut_sizes[kdbpart(dev)].nblocks; 1559 blkoff = kdbtypes[i].ut_sizes[kdbpart(dev)].blkoff; 1560 1561 /* 1562 * Dump all of physical memory, or as much as will fit in the 1563 * space provided. 1564 */ 1565 start = 0; 1566 num = maxfree; 1567 if (dumplo < 0) 1568 return (EINVAL); 1569 if (dumplo + num >= maxsz) 1570 num = maxsz - dumplo; 1571 blkoff += dumplo; 1572 1573 /* 1574 * Write out memory, DBSIZE pages at a time. 1575 * N.B.: this code depends on the fact that the sector 1576 * size == the page size. 1577 */ 1578 while (num > 0) { 1579 blk = num > DBSIZE ? DBSIZE : num; 1580 kd->kd_cmd.mscp_unit = ui->ui_slave; 1581 kd->kd_cmd.mscp_seq.seq_lbn = btop(start) + blkoff; 1582 kd->kd_cmd.mscp_seq.seq_bytecount = blk << PGSHIFT; 1583 kd->kd_cmd.mscp_seq.seq_buffer = (long)start | KDB_PHYS; 1584 if (kdbdumpcmd(M_OP_WRITE, k, kd, ui->ui_ctlr)) 1585 return (EIO); 1586 start += blk << PGSHIFT; 1587 num -= blk; 1588 } 1589 return (0); /* made it! */ 1590 } 1591 1592 /* 1593 * Wait for some of the bits in `bits' to come on. If the error bit 1594 * comes on, or ten seconds pass without response, return true (error). 1595 */ 1596 kdbdumpwait(k, bits) 1597 register struct kdb_regs *k; 1598 register int bits; 1599 { 1600 register int timo = todr() + 1000; 1601 1602 while ((k->kdb_sa & bits) == 0) { 1603 if (k->kdb_sa & KDB_ERR) { 1604 printf("kdb_sa=%b\ndump ", k->kdb_sa, kdbsr_bits); 1605 return (1); 1606 } 1607 if (todr() >= timo) { 1608 printf("timeout\ndump "); 1609 return (1); 1610 } 1611 } 1612 return (0); 1613 } 1614 1615 /* 1616 * Feed a command to the KDB50, wait for its response, and return 1617 * true iff something went wrong. 1618 */ 1619 kdbdumpcmd(op, k, kd, ctlr) 1620 int op; 1621 register struct kdb_regs *k; 1622 register struct kdbdumpspace *kd; 1623 int ctlr; 1624 { 1625 register int n; 1626 #define mp (&kd->kd_rsp) 1627 1628 kd->kd_cmd.mscp_opcode = op; 1629 kd->kd_cmd.mscp_msglen = MSCP_MSGLEN; 1630 kd->kd_rsp.mscp_msglen = MSCP_MSGLEN; 1631 kd->kd_ca.ca_rspdsc |= MSCP_OWN | MSCP_INT; 1632 kd->kd_ca.ca_cmddsc |= MSCP_OWN | MSCP_INT; 1633 if (k->kdb_sa & KDB_ERR) { 1634 printf("kdb_sa=%b\ndump ", k->kdb_sa, kdbsr_bits); 1635 return (1); 1636 } 1637 n = k->kdb_ip; 1638 n = todr() + 1000; 1639 for (;;) { 1640 if (todr() > n) { 1641 printf("timeout\ndump "); 1642 return (1); 1643 } 1644 if (kd->kd_ca.ca_cmdint) 1645 kd->kd_ca.ca_cmdint = 0; 1646 if (kd->kd_ca.ca_rspint == 0) 1647 continue; 1648 kd->kd_ca.ca_rspint = 0; 1649 if (mp->mscp_opcode == (op | M_OP_END)) 1650 break; 1651 printf("\n"); 1652 switch (MSCP_MSGTYPE(mp->mscp_msgtc)) { 1653 1654 case MSCPT_SEQ: 1655 printf("sequential"); 1656 break; 1657 1658 case MSCPT_DATAGRAM: 1659 mscp_decodeerror("kdb", ctlr, mp); 1660 printf("datagram"); 1661 break; 1662 1663 case MSCPT_CREDITS: 1664 printf("credits"); 1665 break; 1666 1667 case MSCPT_MAINTENANCE: 1668 printf("maintenance"); 1669 break; 1670 1671 default: 1672 printf("unknown (type 0x%x)", 1673 MSCP_MSGTYPE(mp->mscp_msgtc)); 1674 break; 1675 } 1676 printf(" ignored\ndump "); 1677 kd->kd_ca.ca_rspdsc |= MSCP_OWN | MSCP_INT; 1678 } 1679 if ((mp->mscp_status & M_ST_MASK) != M_ST_SUCCESS) { 1680 printf("error: op 0x%x => 0x%x status 0x%x\ndump ", op, 1681 mp->mscp_opcode, mp->mscp_status); 1682 return (1); 1683 } 1684 return (0); 1685 #undef mp 1686 } 1687 1688 /* 1689 * Return the size of a partition, if known, or -1 if not. 1690 */ 1691 kdbsize(dev) 1692 dev_t dev; 1693 { 1694 register int unit = kdbunit(dev); 1695 register struct uba_device *ui; 1696 register struct size *st; 1697 1698 if (unit >= NKRA || (ui = kdbdinfo[unit]) == NULL || ui->ui_alive == 0) 1699 return (-1); 1700 st = &kdbtypes[ui->ui_type].ut_sizes[kdbpart(dev)]; 1701 if (st->nblocks == -1) { 1702 int s = spl5(); 1703 1704 /* 1705 * We need to have the drive on line to find the size 1706 * of this particular partition. 1707 * IS IT OKAY TO GO TO SLEEP IN THIS ROUTINE? 1708 * (If not, better not page on one of these...) 1709 */ 1710 if ((ui->ui_flags & UNIT_ONLINE) == 0) { 1711 if (kdb_bringonline(ui, 0)) { 1712 splx(s); 1713 return (-1); 1714 } 1715 } 1716 splx(s); 1717 if (st->blkoff > ra_dsize[unit]) 1718 return (-1); 1719 return (ra_dsize[unit] - st->blkoff); 1720 } 1721 return (st->nblocks); 1722 } 1723 1724 #endif NKDB > 0 1725