![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to hd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / tahoe / vba|
Return to hd.c CVS log | Up to [Net/2] / Net2 / arch / tahoe / vba |
1.1 ! root 1: /* ! 2: * Copyright (c) 1988 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * This code is derived from software contributed to Berkeley by ! 6: * Harris Corp. ! 7: * ! 8: * Redistribution and use in source and binary forms, with or without ! 9: * modification, are permitted provided that the following conditions ! 10: * are met: ! 11: * 1. Redistributions of source code must retain the above copyright ! 12: * notice, this list of conditions and the following disclaimer. ! 13: * 2. Redistributions in binary form must reproduce the above copyright ! 14: * notice, this list of conditions and the following disclaimer in the ! 15: * documentation and/or other materials provided with the distribution. ! 16: * 3. All advertising materials mentioning features or use of this software ! 17: * must display the following acknowledgement: ! 18: * This product includes software developed by the University of ! 19: * California, Berkeley and its contributors. ! 20: * 4. Neither the name of the University nor the names of its contributors ! 21: * may be used to endorse or promote products derived from this software ! 22: * without specific prior written permission. ! 23: * ! 24: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 25: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 26: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 27: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 28: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 29: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 30: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 31: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 33: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 34: * SUCH DAMAGE. ! 35: * ! 36: * @(#)hd.c 7.12 (Berkeley) 12/16/90 ! 37: */ ! 38: ! 39: #include "hd.h" ! 40: ! 41: #if NHD > 0 ! 42: #include "sys/param.h" ! 43: #include "sys/buf.h" ! 44: #include "sys/conf.h" ! 45: #include "sys/dkstat.h" ! 46: #include "sys/disklabel.h" ! 47: #include "sys/file.h" ! 48: #include "sys/systm.h" ! 49: #include "sys/vmmac.h" ! 50: #include "sys/time.h" ! 51: #include "sys/proc.h" ! 52: #include "sys/uio.h" ! 53: #include "sys/syslog.h" ! 54: #include "sys/kernel.h" ! 55: #include "sys/ioctl.h" ! 56: #include "sys/stat.h" ! 57: #include "sys/errno.h" ! 58: ! 59: #include "../include/cpu.h" ! 60: #include "../include/mtpr.h" ! 61: ! 62: #include "../vba/vbavar.h" ! 63: #include "../vba/hdreg.h" ! 64: ! 65: #define b_cylin b_resid ! 66: ! 67: #define hdunit(dev) (minor(dev)>>3) ! 68: #define hdpart(dev) (minor(dev)&0x07) ! 69: #define hdminor(unit, part) (((unit)<<3)|(part)) ! 70: ! 71: struct vba_ctlr *hdcminfo[NHDC]; ! 72: struct vba_device *hddinfo[NHD]; ! 73: int hdcprobe(), hdslave(), hdattach(), hddgo(), hdstrategy(); ! 74: long hdstd[] = { 0 }; ! 75: struct vba_driver hdcdriver = ! 76: { hdcprobe, hdslave, hdattach, hddgo, hdstd, "hd", hddinfo, "hdc", hdcminfo }; ! 77: ! 78: /* ! 79: * Per-controller state. ! 80: */ ! 81: struct hdcsoftc { ! 82: u_short hdc_flags; ! 83: #define HDC_INIT 0x01 /* controller initialized */ ! 84: #define HDC_STARTED 0x02 /* start command issued */ ! 85: #define HDC_LOCKED 0x04 /* locked for direct controller access */ ! 86: #define HDC_WAIT 0x08 /* someone needs direct controller access */ ! 87: u_short hdc_wticks; /* timeout */ ! 88: struct master_mcb *hdc_mcbp; /* address of controller mcb */ ! 89: struct registers *hdc_reg; /* base address of i/o regs */ ! 90: struct vb_buf hdc_rbuf; /* vba resources */ ! 91: struct master_mcb hdc_mcb; /* controller mcb */ ! 92: } hdcsoftc[NHDC]; ! 93: ! 94: #define HDCMAXTIME 20 /* max time for operation, sec. */ ! 95: #define HDCINTERRUPT 0xf0 /* interrupt vector */ ! 96: ! 97: /* ! 98: * Per-drive state; probably everything should be "hd_", not "dk_", ! 99: * but it's not worth it, and dk is a better mnemonic for disk anyway. ! 100: */ ! 101: struct dksoftc { ! 102: #ifdef COMPAT_42 ! 103: u_short dk_def_cyl; /* definition track cylinder address */ ! 104: #endif ! 105: int dk_state; /* open fsm */ ! 106: u_short dk_bshift; /* shift for * (DEV_BSIZE / sectorsize) XXX */ ! 107: int dk_wlabel; /* if label sector is writeable */ ! 108: u_long dk_copenpart; /* character units open on this drive */ ! 109: u_long dk_bopenpart; /* block units open on this drive */ ! 110: u_long dk_openpart; /* all units open on this drive */ ! 111: int dk_unit; /* unit# */ ! 112: int dk_ctlr; /* controller# */ ! 113: int dk_format; /* if format program is using disk */ ! 114: struct buf dk_utab; /* i/o queue header */ ! 115: struct disklabel dk_label; /* disklabel for this disk */ ! 116: struct mcb dk_mcb; /* disk mcb */ ! 117: } dksoftc[NHD]; ! 118: ! 119: /* ! 120: * Drive states. Used during steps of open/initialization. ! 121: * States < OPEN (> 0) are transient, during an open operation. ! 122: * OPENRAW is used for unlabeled disks, to allow format operations. ! 123: */ ! 124: #define CLOSED 0 /* disk is closed */ ! 125: #define WANTOPEN 1 /* open requested, not started */ ! 126: #define WANTOPENRAW 2 /* open requested, no label */ ! 127: #define RDLABEL 3 /* reading pack label */ ! 128: #define OPEN 4 /* intialized and ready */ ! 129: #define OPENRAW 5 /* open, no label */ ! 130: ! 131: int hdcwstart, hdcwatch(); ! 132: ! 133: /* see if the controller is really there, if so, init it. */ ! 134: /* ARGSUSED */ ! 135: hdcprobe(reg, vm) ! 136: caddr_t reg; ! 137: /* register */ struct vba_ctlr *vm; ! 138: { ! 139: register int br, cvec; /* must be r12, r11 */ ! 140: register struct hdcsoftc *hdc; ! 141: static struct module_id id; ! 142: struct pte *dummypte; ! 143: caddr_t putl; ! 144: ! 145: /* initialize the hdc controller structure. */ ! 146: hdc = &hdcsoftc[vm->um_ctlr]; ! 147: if (!vbmemalloc(1, reg, &dummypte, &putl)) { ! 148: printf("hdc%d: vbmemalloc failed.\n", vm->um_ctlr); ! 149: return(0); ! 150: } ! 151: hdc->hdc_reg = (struct registers *)putl; ! 152: ! 153: /* ! 154: * try and ping the MID register; side effect of wbadaddr is to read ! 155: * the module id; the controller is bad if it's not an hdc, the hdc's ! 156: * writeable control store is not loaded, or the hdc failed the ! 157: * functional integrity test; ! 158: */ ! 159: if (wbadaddr(&hdc->hdc_reg->module_id, 4, ! 160: vtoph((struct process *)NULL, &id))) ! 161: return(0); ! 162: DELAY(10000); ! 163: mtpr(PADC, 0); ! 164: if (id.module_id != (u_char)HDC_MID) { ! 165: printf("hdc%d: bad module id; id = %x.\n", ! 166: vm->um_ctlr, id.module_id); ! 167: return(0); ! 168: } ! 169: if (id.code_rev == (u_char)0xff) { ! 170: printf("hdc%d: micro-code not loaded.\n", vm->um_ctlr); ! 171: return(0); ! 172: } ! 173: if (id.fit != (u_char)0xff) { ! 174: printf("hdc%d: FIT test failed.\n", vm->um_ctlr); ! 175: return(0); ! 176: } ! 177: ! 178: /* reset that pup; flag as inited */ ! 179: hdc->hdc_reg->soft_reset = 0; ! 180: DELAY(1000000); ! 181: hdc->hdc_flags |= HDC_INIT; ! 182: ! 183: /* allocate page tables and i/o buffer. */ ! 184: if (!vbainit(&hdc->hdc_rbuf, MAXPHYS, VB_32BIT|VB_SCATTER)) { ! 185: printf("hdc%d: vbainit failed\n", vm->um_ctlr); ! 186: return (0); ! 187: } ! 188: ! 189: /* set pointer to master control block */ ! 190: hdc->hdc_mcbp = ! 191: (struct master_mcb *)vtoph((struct proc *)NULL, &hdc->hdc_mcb); ! 192: ! 193: br = 0x17, cvec = HDCINTERRUPT + vm->um_ctlr; /* XXX */ ! 194: return(sizeof(struct registers)); ! 195: } ! 196: ! 197: /* ARGSUSED */ ! 198: hdslave(vi, vdaddr) ! 199: struct vba_device *vi; ! 200: struct vddevice *vdaddr; ! 201: { ! 202: register struct mcb *mcb; ! 203: register struct disklabel *lp; ! 204: register struct dksoftc *dk; ! 205: static struct status status; ! 206: ! 207: dk = &dksoftc[vi->ui_unit]; ! 208: dk->dk_unit = vi->ui_unit; ! 209: dk->dk_ctlr = vi->ui_ctlr; ! 210: ! 211: mcb = &dk->dk_mcb; ! 212: mcb->command = HCMD_STATUS; ! 213: mcb->chain[0].wcount = sizeof(struct status) / sizeof(long); ! 214: mcb->chain[0].memadr = (u_long)vtoph((struct process *)0, &status); ! 215: if (hdimcb(dk)) { ! 216: printf(" (no status)\n"); ! 217: return(0); ! 218: } ! 219: ! 220: /* ! 221: * Report the drive down if anything in the drive status looks bad. ! 222: * If the drive is offline and it is not on cylinder, then the drive ! 223: * is not there. If there is a fault condition, the hdc will try to ! 224: * clear it when we read the disklabel information. ! 225: */ ! 226: if (!(status.drs&DRS_ONLINE)) { ! 227: if (status.drs&DRS_ON_CYLINDER) ! 228: printf(" (not online)\n"); ! 229: return(0); ! 230: } ! 231: if (status.drs&DRS_FAULT) ! 232: printf(" (clearing fault)"); ! 233: ! 234: lp = &dk->dk_label; ! 235: #ifdef RAW_SIZE ! 236: lp->d_secsize = status.bytes_per_sec; ! 237: #else ! 238: lp->d_secsize = 512; ! 239: #endif ! 240: lp->d_nsectors = status.max_sector + 1; ! 241: lp->d_ntracks = status.max_head + 1; ! 242: lp->d_ncylinders = status.max_cyl + 1; ! 243: lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors; ! 244: lp->d_npartitions = 1; ! 245: lp->d_partitions[0].p_offset = 0; ! 246: lp->d_partitions[0].p_size = LABELSECTOR + 1; ! 247: lp->d_rpm = status.rpm; ! 248: lp->d_typename[0] = 'h'; ! 249: lp->d_typename[1] = 'd'; ! 250: lp->d_typename[2] = '\0'; ! 251: #ifdef COMPAT_42 ! 252: dk->dk_def_cyl = status.def_cyl; ! 253: #endif ! 254: return(1); ! 255: } ! 256: ! 257: hdattach(vi) ! 258: register struct vba_device *vi; ! 259: { ! 260: register struct dksoftc *dk; ! 261: register struct disklabel *lp; ! 262: register int unit; ! 263: ! 264: unit = vi->ui_unit; ! 265: if (hdinit(hdminor(unit, 0), 0)) { ! 266: printf(": unknown drive type"); ! 267: return; ! 268: } ! 269: dk = &dksoftc[unit]; ! 270: lp = &dk->dk_label; ! 271: hd_setsecsize(dk, lp); ! 272: if (dk->dk_state == OPEN) ! 273: printf(": %s <secsize %d, ntrak %d, ncyl %d, nsec %d>", ! 274: lp->d_typename, lp->d_secsize, lp->d_ntracks, ! 275: lp->d_ncylinders, lp->d_nsectors); ! 276: ! 277: /* ! 278: * (60 / rpm) / (sectors per track * (bytes per sector / 2)) ! 279: */ ! 280: if (vi->ui_dk >= 0) ! 281: dk_wpms[vi->ui_dk] = ! 282: (lp->d_rpm * lp->d_nsectors * lp->d_secsize) / 120; ! 283: #ifdef notyet ! 284: addswap(makedev(HDMAJOR, hdminor(unit, 0)), lp); ! 285: #endif ! 286: } ! 287: ! 288: hdopen(dev, flags, fmt) ! 289: dev_t dev; ! 290: int flags, fmt; ! 291: { ! 292: register struct disklabel *lp; ! 293: register struct dksoftc *dk; ! 294: register struct partition *pp; ! 295: register int unit; ! 296: struct vba_device *vi; ! 297: int s, error, part = hdpart(dev), mask = 1 << part; ! 298: daddr_t start, end; ! 299: ! 300: unit = hdunit(dev); ! 301: if (unit >= NHD || (vi = hddinfo[unit]) == 0 || vi->ui_alive == 0) ! 302: return(ENXIO); ! 303: dk = &dksoftc[unit]; ! 304: lp = &dk->dk_label; ! 305: s = spl7(); ! 306: while (dk->dk_state != OPEN && dk->dk_state != OPENRAW && ! 307: dk->dk_state != CLOSED) ! 308: if (error = tsleep((caddr_t)dk, (PZERO+1) | PCATCH, ! 309: devopn, 0)) { ! 310: splx(s); ! 311: return (error); ! 312: } ! 313: splx(s); ! 314: if (dk->dk_state != OPEN && dk->dk_state != OPENRAW) ! 315: if (error = hdinit(dev, flags)) ! 316: return(error); ! 317: ! 318: if (hdcwstart == 0) { ! 319: timeout(hdcwatch, (caddr_t)0, hz); ! 320: hdcwstart++; ! 321: } ! 322: /* ! 323: * Warn if a partion is opened that overlaps another partition ! 324: * which is open unless one is the "raw" partition (whole disk). ! 325: */ ! 326: #define RAWPART 8 /* 'x' partition */ /* XXX */ ! 327: if ((dk->dk_openpart & mask) == 0 && part != RAWPART) { ! 328: pp = &lp->d_partitions[part]; ! 329: start = pp->p_offset; ! 330: end = pp->p_offset + pp->p_size; ! 331: for (pp = lp->d_partitions; ! 332: pp < &lp->d_partitions[lp->d_npartitions]; pp++) { ! 333: if (pp->p_offset + pp->p_size <= start || ! 334: pp->p_offset >= end) ! 335: continue; ! 336: if (pp - lp->d_partitions == RAWPART) ! 337: continue; ! 338: if (dk->dk_openpart & (1 << (pp - lp->d_partitions))) ! 339: log(LOG_WARNING, ! 340: "hd%d%c: overlaps open partition (%c)\n", ! 341: unit, part + 'a', ! 342: pp - lp->d_partitions + 'a'); ! 343: } ! 344: } ! 345: if (part >= lp->d_npartitions) ! 346: return(ENXIO); ! 347: dk->dk_openpart |= mask; ! 348: switch (fmt) { ! 349: case S_IFCHR: ! 350: dk->dk_copenpart |= mask; ! 351: break; ! 352: case S_IFBLK: ! 353: dk->dk_bopenpart |= mask; ! 354: break; ! 355: } ! 356: return(0); ! 357: } ! 358: ! 359: /* ARGSUSED */ ! 360: hdclose(dev, flags, fmt) ! 361: dev_t dev; ! 362: int flags, fmt; ! 363: { ! 364: register struct dksoftc *dk; ! 365: int mask; ! 366: ! 367: dk = &dksoftc[hdunit(dev)]; ! 368: mask = 1 << hdpart(dev); ! 369: switch (fmt) { ! 370: case S_IFCHR: ! 371: dk->dk_copenpart &= ~mask; ! 372: break; ! 373: case S_IFBLK: ! 374: dk->dk_bopenpart &= ~mask; ! 375: break; ! 376: } ! 377: if (((dk->dk_copenpart | dk->dk_bopenpart) & mask) == 0) ! 378: dk->dk_openpart &= ~mask; ! 379: /* ! 380: * Should wait for i/o to complete on this partition ! 381: * even if others are open, but wait for work on blkflush(). ! 382: */ ! 383: if (dk->dk_openpart == 0) { ! 384: int s = spl7(); ! 385: while (dk->dk_utab.b_actf) ! 386: sleep((caddr_t)dk, PZERO-1); ! 387: splx(s); ! 388: dk->dk_state = CLOSED; ! 389: dk->dk_wlabel = 0; ! 390: } ! 391: return(0); ! 392: } ! 393: ! 394: hdinit(dev, flags) ! 395: dev_t dev; ! 396: int flags; ! 397: { ! 398: register struct dksoftc *dk; ! 399: register struct disklabel *lp; ! 400: struct vba_device *vi; ! 401: int error, unit; ! 402: char *msg, *readdisklabel(); ! 403: extern int cold; ! 404: ! 405: vi = hddinfo[unit = hdunit(dev)]; ! 406: dk = &dksoftc[unit]; ! 407: dk->dk_unit = vi->ui_slave; ! 408: dk->dk_ctlr = vi->ui_ctlr; ! 409: ! 410: if (flags & O_NDELAY) { ! 411: dk->dk_state = OPENRAW; ! 412: return(0); ! 413: } ! 414: ! 415: error = 0; ! 416: lp = &dk->dk_label; ! 417: dk->dk_state = RDLABEL; ! 418: if (msg = readdisklabel(dev, hdstrategy, lp)) { ! 419: if (cold) { ! 420: printf(": %s\n", msg); ! 421: dk->dk_state = CLOSED; ! 422: } else { ! 423: log(LOG_ERR, "hd%d: %s\n", unit, msg); ! 424: dk->dk_state = OPENRAW; ! 425: } ! 426: #ifdef COMPAT_42 ! 427: hdclock(vi->ui_ctlr); ! 428: if (!(error = hdreadgeometry(dk))) ! 429: dk->dk_state = OPEN; ! 430: hdcunlock(vi->ui_ctlr); ! 431: #endif ! 432: } else ! 433: dk->dk_state = OPEN; ! 434: wakeup((caddr_t)dk); ! 435: return(error); ! 436: } ! 437: ! 438: hd_setsecsize(dk, lp) ! 439: register struct dksoftc *dk; ! 440: struct disklabel *lp; ! 441: { ! 442: register int mul; ! 443: ! 444: /* ! 445: * Calculate scaling shift for mapping ! 446: * DEV_BSIZE blocks to drive sectors. ! 447: */ ! 448: mul = DEV_BSIZE / lp->d_secsize; ! 449: dk->dk_bshift = 0; ! 450: while ((mul >>= 1) > 0) ! 451: dk->dk_bshift++; ! 452: } ! 453: ! 454: /* ARGSUSED */ ! 455: hddgo(vm) ! 456: struct vba_device *vm; ! 457: {} ! 458: ! 459: extern int name_ext; ! 460: hdstrategy(bp) ! 461: register struct buf *bp; ! 462: { ! 463: register struct vba_device *vi; ! 464: register struct disklabel *lp; ! 465: register struct dksoftc *dk; ! 466: struct buf *dp; ! 467: register int unit; ! 468: daddr_t sn, sz, maxsz; ! 469: int part, s; ! 470: ! 471: vi = hddinfo[unit = hdunit(bp->b_dev)]; ! 472: if (unit >= NHD || vi == 0 || vi->ui_alive == 0) { ! 473: bp->b_error = ENXIO; ! 474: goto bad; ! 475: } ! 476: dk = &dksoftc[unit]; ! 477: if (dk->dk_state < OPEN) ! 478: goto q; ! 479: if (dk->dk_state != OPEN && (bp->b_flags & B_READ) == 0) { ! 480: bp->b_error = EROFS; ! 481: goto bad; ! 482: } ! 483: part = hdpart(bp->b_dev); ! 484: if ((dk->dk_openpart & (1 << part)) == 0) { ! 485: bp->b_error = ENODEV; ! 486: goto bad; ! 487: } ! 488: lp = &dk->dk_label; ! 489: sz = (bp->b_bcount + lp->d_secsize - 1) / lp->d_secsize; ! 490: maxsz = lp->d_partitions[part].p_size; ! 491: sn = bp->b_blkno << dk->dk_bshift; ! 492: if (sn + lp->d_partitions[part].p_offset <= LABELSECTOR && ! 493: #if LABELSECTOR != 0 ! 494: sn + lp->d_partitions[part].p_offset + sz > LABELSECTOR && ! 495: #endif ! 496: (bp->b_flags & B_READ) == 0 && dk->dk_wlabel == 0) { ! 497: bp->b_error = EROFS; ! 498: goto bad; ! 499: } ! 500: if (sn < 0 || sn + sz > maxsz) { ! 501: if (sn == maxsz) { ! 502: bp->b_resid = bp->b_bcount; ! 503: goto done; ! 504: } ! 505: sz = maxsz - sn; ! 506: if (sz <= 0) { ! 507: bp->b_error = EINVAL; ! 508: goto bad; ! 509: } ! 510: bp->b_bcount = sz * lp->d_secsize; ! 511: } ! 512: bp->b_cylin = (sn + lp->d_partitions[part].p_offset) / lp->d_secpercyl; ! 513: ! 514: q: s = spl7(); ! 515: dp = &dk->dk_utab; ! 516: disksort(dp, bp); ! 517: if (!dp->b_active) { ! 518: (void)hdustart(vi); ! 519: if (!vi->ui_mi->um_tab.b_active) ! 520: hdcstart(vi->ui_mi); ! 521: } ! 522: splx(s); ! 523: return; ! 524: bad: ! 525: bp->b_flags |= B_ERROR; ! 526: done: ! 527: biodone(bp); ! 528: } ! 529: ! 530: hdustart(vi) ! 531: register struct vba_device *vi; ! 532: { ! 533: register struct buf *bp, *dp; ! 534: register struct vba_ctlr *vm; ! 535: register struct dksoftc *dk; ! 536: ! 537: dk = &dksoftc[vi->ui_unit]; ! 538: dp = &dk->dk_utab; ! 539: ! 540: /* if queue empty, nothing to do. impossible? */ ! 541: if (dp->b_actf == NULL) ! 542: return; ! 543: ! 544: /* place on controller transfer queue */ ! 545: vm = vi->ui_mi; ! 546: if (vm->um_tab.b_actf == NULL) ! 547: vm->um_tab.b_actf = dp; ! 548: else ! 549: vm->um_tab.b_actl->b_forw = dp; ! 550: vm->um_tab.b_actl = dp; ! 551: dp->b_forw = NULL; ! 552: dp->b_active++; ! 553: } ! 554: ! 555: hdcstart(vm) ! 556: register struct vba_ctlr *vm; ! 557: { ! 558: register struct buf *bp; ! 559: register struct dksoftc *dk; ! 560: register struct disklabel *lp; ! 561: register struct master_mcb *master; ! 562: register struct mcb *mcb; ! 563: struct vba_device *vi; ! 564: struct hdcsoftc *hdc; ! 565: struct buf *dp; ! 566: int sn; ! 567: ! 568: /* pull a request off the controller queue */ ! 569: for (;;) { ! 570: if ((dp = vm->um_tab.b_actf) == NULL) ! 571: return; ! 572: if (bp = dp->b_actf) ! 573: break; ! 574: vm->um_tab.b_actf = dp->b_forw; ! 575: } ! 576: ! 577: /* mark controller active */ ! 578: vm->um_tab.b_active++; ! 579: ! 580: vi = hddinfo[hdunit(bp->b_dev)]; ! 581: dk = &dksoftc[vi->ui_unit]; ! 582: lp = &dk->dk_label; ! 583: sn = bp->b_blkno << dk->dk_bshift; ! 584: ! 585: /* fill in mcb */ ! 586: mcb = &dk->dk_mcb; ! 587: mcb->forw_phaddr = 0; ! 588: /* mcb->priority = 0; */ ! 589: mcb->interrupt = 1; ! 590: mcb->command = (bp->b_flags & B_READ) ? HCMD_READ:HCMD_WRITE; ! 591: mcb->cyl = bp->b_cylin; ! 592: /* assumes partition starts on cylinder boundary */ ! 593: mcb->head = (sn / lp->d_nsectors) % lp->d_ntracks; ! 594: mcb->sector = sn % lp->d_nsectors; ! 595: mcb->drive = vi->ui_slave; ! 596: /* mcb->context = 0; /* what do we want on interrupt? */ ! 597: ! 598: hdc = &hdcsoftc[vm->um_ctlr]; ! 599: if (!hd_sgsetup(bp, &hdc->hdc_rbuf, mcb->chain)) { ! 600: mcb->chain[0].wcount = (bp->b_bcount+3) >> 2; ! 601: mcb->chain[0].memadr = ! 602: vbasetup(bp, &hdc->hdc_rbuf, (int)lp->d_secsize); ! 603: } ! 604: ! 605: if (vi->ui_dk >= 0) { ! 606: dk_busy |= 1<<vi->ui_dk; ! 607: dk_xfer[vi->ui_dk]++; ! 608: dk_wds[vi->ui_dk] += bp->b_bcount>>6; ! 609: } ! 610: ! 611: master = &hdc->hdc_mcb; ! 612: master->mcw = MCL_QUEUED; ! 613: master->interrupt = HDCINTERRUPT + vm->um_ctlr; ! 614: master->forw_phaddr = (u_long)vtoph((struct proc *)NULL, mcb); ! 615: hdc->hdc_reg->master_mcb = (u_long)hdc->hdc_mcbp; ! 616: } ! 617: ! 618: /* ! 619: * Wait for controller to finish current operation ! 620: * so that direct controller accesses can be done. ! 621: */ ! 622: hdclock(ctlr) ! 623: int ctlr; ! 624: { ! 625: register struct vba_ctlr *vm = hdcminfo[ctlr]; ! 626: register struct hdcsoftc *hdc; ! 627: int s; ! 628: ! 629: hdc = &hdcsoftc[ctlr]; ! 630: s = spl7(); ! 631: while (vm->um_tab.b_active || hdc->hdc_flags & HDC_LOCKED) { ! 632: hdc->hdc_flags |= HDC_WAIT; ! 633: sleep((caddr_t)hdc, PRIBIO); ! 634: } ! 635: hdc->hdc_flags |= HDC_LOCKED; ! 636: splx(s); ! 637: } ! 638: ! 639: /* ! 640: * Continue normal operations after pausing for ! 641: * munging the controller directly. ! 642: */ ! 643: hdcunlock(ctlr) ! 644: int ctlr; ! 645: { ! 646: register struct vba_ctlr *vm; ! 647: register struct hdcsoftc *hdc = &hdcsoftc[ctlr]; ! 648: ! 649: hdc->hdc_flags &= ~HDC_LOCKED; ! 650: if (hdc->hdc_flags & HDC_WAIT) { ! 651: hdc->hdc_flags &= ~HDC_WAIT; ! 652: wakeup((caddr_t)hdc); ! 653: } else { ! 654: vm = hdcminfo[ctlr]; ! 655: if (vm->um_tab.b_actf) ! 656: hdcstart(vm); ! 657: } ! 658: } ! 659: ! 660: hdintr(ctlr) ! 661: int ctlr; ! 662: { ! 663: register struct buf *bp, *dp; ! 664: register struct vba_ctlr *vm; ! 665: register struct vba_device *vi; ! 666: register struct hdcsoftc *hdc; ! 667: register struct mcb *mcb; ! 668: struct master_mcb *master; ! 669: register int status; ! 670: int timedout; ! 671: struct dksoftc *dk; ! 672: ! 673: hdc = &hdcsoftc[ctlr]; ! 674: master = &hdc->hdc_mcb; ! 675: uncache(&master->mcs); ! 676: uncache(&master->context); ! 677: ! 678: vm = hdcminfo[ctlr]; ! 679: if (!vm->um_tab.b_active || !(master->mcs&MCS_DONE)) { ! 680: printf("hd%d: stray interrupt\n", ctlr); ! 681: return; ! 682: } ! 683: ! 684: dp = vm->um_tab.b_actf; ! 685: bp = dp->b_actf; ! 686: vi = hddinfo[hdunit(bp->b_dev)]; ! 687: dk = &dksoftc[vi->ui_unit]; ! 688: if (vi->ui_dk >= 0) ! 689: dk_busy &= ~(1<<vi->ui_dk); ! 690: timedout = (hdc->hdc_wticks >= HDCMAXTIME); ! 691: ! 692: mcb = &dk->dk_mcb; ! 693: ! 694: if (master->mcs & (MCS_SOFTERROR | MCS_FATALERROR) || timedout) ! 695: hdcerror(ctlr, *(u_long *)master->xstatus); ! 696: else ! 697: hdc->hdc_wticks = 0; ! 698: if (vm->um_tab.b_active) { ! 699: vm->um_tab.b_active = 0; ! 700: vm->um_tab.b_actf = dp->b_forw; ! 701: dp->b_active = 0; ! 702: dp->b_errcnt = 0; ! 703: dp->b_actf = bp->av_forw; ! 704: bp->b_resid = 0; ! 705: vbadone(bp, &hdc->hdc_rbuf); ! 706: biodone(bp); ! 707: /* start up now, if more work to do */ ! 708: if (dp->b_actf) ! 709: hdustart(vi); ! 710: else if (dk->dk_openpart == 0) ! 711: wakeup((caddr_t)dk); ! 712: } ! 713: /* if there are devices ready to transfer, start the controller. */ ! 714: if (hdc->hdc_flags & HDC_WAIT) { ! 715: hdc->hdc_flags &= ~HDC_WAIT; ! 716: wakeup((caddr_t)hdc); ! 717: } else if (vm->um_tab.b_actf) ! 718: hdcstart(vm); ! 719: } ! 720: ! 721: hdioctl(dev, cmd, data, flag) ! 722: dev_t dev; ! 723: int cmd, flag; ! 724: caddr_t data; ! 725: { ! 726: register int unit; ! 727: register struct dksoftc *dk; ! 728: register struct disklabel *lp; ! 729: int error; ! 730: ! 731: unit = hdunit(dev); ! 732: dk = &dksoftc[unit]; ! 733: lp = &dk->dk_label; ! 734: error = 0; ! 735: switch (cmd) { ! 736: case DIOCGDINFO: ! 737: *(struct disklabel *)data = *lp; ! 738: break; ! 739: case DIOCGPART: ! 740: ((struct partinfo *)data)->disklab = lp; ! 741: ((struct partinfo *)data)->part = ! 742: &lp->d_partitions[hdpart(dev)]; ! 743: break; ! 744: case DIOCSDINFO: ! 745: if ((flag & FWRITE) == 0) ! 746: error = EBADF; ! 747: else ! 748: error = setdisklabel(lp, (struct disklabel *)data, ! 749: (dk->dk_state == OPENRAW) ? 0 : dk->dk_openpart); ! 750: if (error == 0 && dk->dk_state == OPENRAW) ! 751: dk->dk_state = OPEN; ! 752: break; ! 753: case DIOCWLABEL: ! 754: if ((flag & FWRITE) == 0) ! 755: error = EBADF; ! 756: else ! 757: dk->dk_wlabel = *(int *)data; ! 758: break; ! 759: case DIOCWDINFO: ! 760: if ((flag & FWRITE) == 0) ! 761: error = EBADF; ! 762: else if ((error = setdisklabel(lp, (struct disklabel *)data, ! 763: (dk->dk_state == OPENRAW) ? 0 : dk->dk_openpart)) == 0) { ! 764: int wlab; ! 765: ! 766: if (error == 0 && dk->dk_state == OPENRAW) ! 767: dk->dk_state = OPEN; ! 768: /* simulate opening partition 0 so write succeeds */ ! 769: dk->dk_openpart |= (1 << 0); /* XXX */ ! 770: wlab = dk->dk_wlabel; ! 771: dk->dk_wlabel = 1; ! 772: error = writedisklabel(dev, hdstrategy, lp); ! 773: dk->dk_openpart = dk->dk_copenpart | dk->dk_bopenpart; ! 774: dk->dk_wlabel = wlab; ! 775: } ! 776: break; ! 777: default: ! 778: error = ENOTTY; ! 779: break; ! 780: } ! 781: return (error); ! 782: } ! 783: ! 784: /* ! 785: * Watch for lost interrupts. ! 786: */ ! 787: hdcwatch() ! 788: { ! 789: register struct hdcsoftc *hdc; ! 790: register struct vba_ctlr **vmp; ! 791: register int ctlr; ! 792: int s; ! 793: ! 794: timeout(hdcwatch, (caddr_t)0, hz); ! 795: for (vmp = hdcminfo, hdc = hdcsoftc, ctlr = 0; ctlr < NHDC; ! 796: ++ctlr, ++vmp, ++hdc) { ! 797: if (*vmp == 0 || (*vmp)->um_alive == 0) ! 798: continue; ! 799: s = spl7(); ! 800: if ((*vmp)->um_tab.b_active && ! 801: hdc->hdc_wticks++ >= HDCMAXTIME) { ! 802: printf("hd%d: lost interrupt\n", ctlr); ! 803: hdintr(ctlr); ! 804: } ! 805: splx(s); ! 806: } ! 807: } ! 808: ! 809: hddump(dev) ! 810: dev_t dev; ! 811: { ! 812: return(ENXIO); ! 813: } ! 814: ! 815: hdsize(dev) ! 816: dev_t dev; ! 817: { ! 818: register int unit = hdunit(dev); ! 819: register struct dksoftc *dk; ! 820: struct vba_device *vi; ! 821: struct disklabel *lp; ! 822: ! 823: if (unit >= NHD || (vi = hddinfo[unit]) == 0 || vi->ui_alive == 0 || ! 824: (dk = &dksoftc[unit])->dk_state != OPEN) ! 825: return (-1); ! 826: lp = &dk->dk_label; ! 827: return ((int)lp->d_partitions[hdpart(dev)].p_size >> dk->dk_bshift); ! 828: } ! 829: ! 830: hdimcb(dk) ! 831: register struct dksoftc *dk; ! 832: { ! 833: register struct master_mcb *master; ! 834: register struct mcb *mcb; ! 835: register struct hdcsoftc *hdc; ! 836: int timeout; ! 837: ! 838: /* fill in mcb */ ! 839: mcb = &dk->dk_mcb; ! 840: mcb->interrupt = 0; ! 841: mcb->forw_phaddr = 0; ! 842: mcb->drive = dk->dk_unit; ! 843: ! 844: hdc = &hdcsoftc[dk->dk_ctlr]; ! 845: master = &hdc->hdc_mcb; ! 846: ! 847: /* fill in master mcb */ ! 848: master->mcw = MCL_IMMEDIATE; ! 849: master->forw_phaddr = (u_long)vtoph((struct proc *)NULL, mcb); ! 850: master->mcs = 0; ! 851: ! 852: /* kick controller and wait */ ! 853: hdc->hdc_reg->master_mcb = (u_long)hdc->hdc_mcbp; ! 854: for (timeout = 15000; timeout; --timeout) { ! 855: DELAY(1000); ! 856: mtpr(PADC, 0); ! 857: if (master->mcs&MCS_FATALERROR) { ! 858: printf("hdc%d: fatal error\n", dk->dk_ctlr); ! 859: hdcerror(dk->dk_ctlr, *(u_long *)master->xstatus); ! 860: return(1); ! 861: } ! 862: if (master->mcs&MCS_DONE) ! 863: return(0); ! 864: } ! 865: printf("hdc%d: timed out\n", dk->dk_ctlr); ! 866: return(1); ! 867: } ! 868: ! 869: hdcerror(ctlr, code) ! 870: int ctlr; ! 871: u_long code; ! 872: { ! 873: printf("hd%d: error %lx\n", ctlr, code); ! 874: } ! 875: ! 876: #ifdef COMPAT_42 ! 877: hdreadgeometry(dk) ! 878: struct dksoftc *dk; ! 879: { ! 880: static geometry_sector geometry; ! 881: register struct mcb *mcb; ! 882: register struct disklabel *lp; ! 883: geometry_block *geo; ! 884: int cnt; ! 885: ! 886: /* ! 887: * Read the geometry block (at head = 0 sector = 0 of the drive ! 888: * definition cylinder), validate it (must have the correct version ! 889: * number, header, and checksum). ! 890: */ ! 891: mcb = &dk->dk_mcb; ! 892: mcb->command = HCMD_READ; ! 893: mcb->cyl = dk->dk_def_cyl; ! 894: mcb->head = 0; ! 895: mcb->sector = 0; ! 896: mcb->chain[0].wcount = sizeof(geometry_sector) / sizeof(long); ! 897: mcb->chain[0].memadr = (u_long)vtoph((struct process *)0, &geometry); ! 898: /* mcb->chain[0].memadr = (long)&geometry; */ ! 899: if (hdimcb(dk)) { ! 900: printf("hd%d: can't read default geometry.\n", dk->dk_unit); ! 901: return(1); ! 902: } ! 903: geo = &geometry.geometry_block; ! 904: if (geo->version > 64000 || geo->version < 0) { ! 905: printf("hd%d: bad default geometry version#.\n", dk->dk_unit); ! 906: return(1); ! 907: } ! 908: if (bcmp(&geo->id[0], GB_ID, GB_ID_LEN)) { ! 909: printf("hd%d: bad default geometry header.\n", dk->dk_unit); ! 910: return(1); ! 911: } ! 912: GB_CHECKSUM(geo, cnt); ! 913: if (geometry.checksum != cnt) { ! 914: printf("hd%d: bad default geometry checksum.\n", dk->dk_unit); ! 915: return(1); ! 916: } ! 917: lp = &dk->dk_label; ! 918: ! 919: /* 1K block in Harris geometry; convert to sectors for disklabels */ ! 920: for (cnt = 0; cnt < GB_MAXPART; cnt++) { ! 921: lp->d_partitions[cnt].p_offset = ! 922: geo->partition[cnt].start * (1024 / lp->d_secsize); ! 923: lp->d_partitions[cnt].p_size = ! 924: geo->partition[cnt].length * (1024 / lp->d_secsize); ! 925: } ! 926: lp->d_npartitions = GB_MAXPART; ! 927: return(0); ! 928: } ! 929: #endif /* COMPAT_42 */ ! 930: #endif /* NHD */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.