![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nhd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at|
Return to nhd.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at |
1.1 ! root 1: /* ! 2: * Copyright (c) 1994 Shantanu Goel ! 3: * All Rights Reserved. ! 4: * ! 5: * Permission to use, copy, modify and distribute this software and its ! 6: * documentation is hereby granted, provided that both the copyright ! 7: * notice and this permission notice appear in all copies of the ! 8: * software, derivative works or modified versions, and any portions ! 9: * thereof, and that both notices appear in supporting documentation. ! 10: * ! 11: * THE AUTHOR ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" ! 12: * CONDITION. THE AUTHOR DISCLAIMS ANY LIABILITY OF ANY KIND FOR ! 13: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. ! 14: * ! 15: * MODIFIED BY KEVIN T. VAN MAREN, University of Utah, CSL ! 16: * Copyright (c) 1996, University of Utah, CSL ! 17: * ! 18: * Uses a 'unified' partition code with the SCSI driver. ! 19: * Reading/Writing disklabels through the kernel is NOT recommended. ! 20: * (The preferred method is through the raw device (wd0), with no ! 21: * open partitions). setdisklabel() should work for the in-core ! 22: * fudged disklabel, but will not change the partitioning. The driver ! 23: * *never* sees the disklabel on the disk. ! 24: * ! 25: */ ! 26: ! 27: ! 28: #include <hd.h> ! 29: #if NHD > 0 && !defined(LINUX_DEV) ! 30: /* ! 31: * Hard disk driver. ! 32: * ! 33: * Supports: ! 34: * 1 controller and 2 drives. ! 35: * Arbitrarily sized read/write requests. ! 36: * Misaligned requests. ! 37: * Multiple sector transfer mode (not tested extensively). ! 38: * ! 39: * TODO: ! 40: * 1) Real probe routines for controller and drives. ! 41: * 2) Support for multiple controllers. The driver does ! 42: * not assume a single controller since all functions ! 43: * take the controller and/or device structure as an ! 44: * argument, however the probe routines limit the ! 45: * number of controllers and drives to 1 and 2 respectively. ! 46: * ! 47: * Shantanu Goel ([email protected]) ! 48: */ ! 49: #include <sys/types.h> ! 50: #include <sys/ioctl.h> ! 51: #include "vm_param.h" ! 52: #include <kern/time_out.h> ! 53: #include <vm/vm_kern.h> ! 54: #include <vm/pmap.h> ! 55: #include <device/param.h> ! 56: #include <device/buf.h> ! 57: #include <device/errno.h> ! 58: #include <device/device_types.h> ! 59: #include <device/disk_status.h> ! 60: #include <chips/busses.h> ! 61: #include <i386/machspl.h> ! 62: #include <i386/pio.h> ! 63: #include <i386at/cram.h> ! 64: #include <i386at/disk.h> ! 65: #include <i386at/nhdreg.h> ! 66: ! 67: #include <scsi/rz_labels.h> ! 68: ! 69: ! 70: /* this is for the partition code */ ! 71: typedef struct ide_driver_info { ! 72: dev_t dev; ! 73: /* struct buf *bp; */ ! 74: int sectorsize; ! 75: } ide_driver_info; ! 76: ! 77: #define MAX_IDE_PARTS 32 /* max partitions per drive */ ! 78: static char *drive_name[4]={"wd0: ","wd1: ","xxx ","yyy "}; ! 79: ! 80: /* ! 81: * XXX: This will have to be fixed for controllers that ! 82: * can support upto 4 drives. ! 83: */ ! 84: #define NDRIVES_PER_HDC 2 ! 85: #define NHDC ((NHD + NDRIVES_PER_HDC - 1) / NDRIVES_PER_HDC) ! 86: ! 87: #define b_cylin b_resid ! 88: ! 89: #define B_ABS B_MD1 ! 90: #define B_IDENTIFY (B_MD1 << 1) ! 91: ! 92: /* shift right SLICE_BITS + PARTITION_BITS. Note: 2^10 = 1024 sub-parts */ ! 93: #define hdunit(dev) (((dev) >> 10) & 3) ! 94: #define hdpart(dev) ((dev) & 0x3ff) ! 95: ! 96: #define MAX_RETRIES 12 /* maximum number of retries */ ! 97: #define OP_TIMEOUT 7 /* time to wait (secs) for an operation */ ! 98: ! 99: /* ! 100: * Autoconfiguration stuff. ! 101: */ ! 102: struct bus_ctlr *hdminfo[NHDC]; ! 103: struct bus_device *hddinfo[NHD]; ! 104: int hdstd[] = { 0 }; ! 105: int hdprobe(), hdslave(), hdstrategy(); ! 106: void hdattach(); ! 107: struct bus_driver hddriver = { ! 108: hdprobe, hdslave, hdattach, 0, hdstd, "hd", hddinfo, "hdc", hdminfo, 0 ! 109: }; ! 110: ! 111: /* ! 112: * BIOS geometry. ! 113: */ ! 114: struct hdbios { ! 115: int bg_ncyl; /* cylinders/unit */ ! 116: int bg_ntrk; /* tracks/cylinder */ ! 117: int bg_precomp; /* write precomp cylinder */ ! 118: int bg_nsect; /* sectors/track */ ! 119: } hdbios[NHD]; ! 120: ! 121: /* ! 122: * Controller state. ! 123: */ ! 124: struct hdcsoftc { ! 125: int sc_state; /* transfer fsm */ ! 126: caddr_t sc_addr; /* buffer address */ ! 127: int sc_resid; /* amount left to transfer */ ! 128: int sc_amt; /* amount currently being transferred */ ! 129: int sc_cnt; /* amount transferred per interrupt */ ! 130: int sc_sn; /* sector number */ ! 131: int sc_tn; /* track number */ ! 132: int sc_cn; /* cylinder number */ ! 133: int sc_recalerr; /* # recalibration errors */ ! 134: int sc_ioerr; /* # i/o errors */ ! 135: int sc_wticks; /* watchdog */ ! 136: caddr_t sc_buf; /* buffer for unaligned requests */ ! 137: } hdcsoftc[NHDC]; ! 138: ! 139: /* ! 140: * Transfer states. ! 141: */ ! 142: #define IDLE 0 /* controller is idle */ ! 143: #define SETPARAM 1 /* set disk parameters */ ! 144: #define SETPARAMDONE 2 /* set parameters done */ ! 145: #define RESTORE 3 /* recalibrate drive */ ! 146: #define RESTOREDONE 4 /* recalibrate done */ ! 147: #define TRANSFER 5 /* perform I/O transfer */ ! 148: #define TRANSFERDONE 6 /* transfer done */ ! 149: #define IDENTIFY 7 /* get drive info */ ! 150: #define IDENTIFYDONE 8 /* get drive info done */ ! 151: #define SETMULTI 9 /* set multiple mode count */ ! 152: #define SETMULTIDONE 10 /* set multiple mode count done */ ! 153: ! 154: /* ! 155: * Drive state. ! 156: */ ! 157: struct hdsoftc { ! 158: int sc_flags; ! 159: #define HDF_SETPARAM 0x001 /* set drive parameters before I/O operation */ ! 160: #define HDF_RESTORE 0x002 /* drive needs recalibration */ ! 161: #define HDF_WANT 0x004 /* some one is waiting for drive */ ! 162: #define HDF_UNALIGNED 0x008 /* request is not a multiple of sector size */ ! 163: #define HDF_SETMULTI 0x010 /* set multiple count before I/O operation */ ! 164: #define HDF_MULTIDONE 0x020 /* multicnt field is valid */ ! 165: #define HDF_IDENTDONE 0x040 /* identify command done */ ! 166: #define HDF_LBA 0x080 /* use LBA mode */ ! 167: int sc_multicnt; /* current multiple count */ ! 168: int sc_abssn; /* absolute sector number (for {RD,WR}ABS) */ ! 169: int sc_abscnt; /* absolute sector count */ ! 170: int sc_openpart; /* bit mask of open partitions */ ! 171: struct hdident sc_id; /* info returned by identify */ ! 172: } hdsoftc[NHD]; ! 173: ! 174: struct buf hdtab[NHDC]; /* controller queues */ ! 175: struct buf hdutab[NHD]; /* drive queues */ ! 176: struct disklabel hdlabel[NHD]; /* disklabels -- incorrect info! */ ! 177: struct diskpart array[NHD*MAX_IDE_PARTS]; /* partition info */ ! 178: ! 179: /* ! 180: * To enable multiple mode, ! 181: * set this, recompile, and reboot the machine. ! 182: */ ! 183: int hdenmulti = 0; ! 184: ! 185: char *hderrchk(); ! 186: struct buf *geteblk(); ! 187: int hdwstart = 0; ! 188: void hdwatch(); ! 189: ! 190: /* ! 191: * Probe for a controller. ! 192: */ ! 193: int ! 194: hdprobe(xxx, um) ! 195: int xxx; ! 196: struct bus_ctlr *um; ! 197: { ! 198: struct hdcsoftc *hdc; ! 199: ! 200: if (um->unit >= NHDC) { ! 201: printf("hdc%d: not configured\n", um->unit); ! 202: return (0); ! 203: } ! 204: if (um->unit > 0) { /* XXX: only 1 controller */ ! 205: ! 206: printf("nhd:probe for 2+ controllers -- not implemented\n"); ! 207: return (0); ! 208: } ! 209: ! 210: /* ! 211: * XXX: need real probe ! 212: */ ! 213: hdc = &hdcsoftc[um->unit]; ! 214: if (!hdc->sc_buf) ! 215: kmem_alloc(kernel_map, ! 216: (vm_offset_t *)&hdc->sc_buf, I386_PGBYTES); ! 217: take_ctlr_irq(um); ! 218: return (1); ! 219: } ! 220: ! 221: /* ! 222: * Probe for a drive. ! 223: */ ! 224: int ! 225: hdslave(ui) ! 226: struct bus_device *ui; ! 227: { ! 228: int type; ! 229: ! 230: if (ui->unit >= NHD) { ! 231: printf("hd%d: not configured\n", ui->unit); ! 232: return (0); ! 233: } ! 234: if (ui->unit > 1) /* XXX: only 2 drives */ ! 235: return (0); ! 236: ! 237: /* ! 238: * Find out if drive exists by reading CMOS. ! 239: */ ! 240: outb(CMOS_ADDR, 0x12); ! 241: type = inb(CMOS_DATA); ! 242: if (ui->unit == 0) ! 243: type >>= 4; ! 244: type &= 0x0f; ! 245: return (type); ! 246: } ! 247: ! 248: /* ! 249: * Attach a drive to the system. ! 250: */ ! 251: void ! 252: hdattach(ui) ! 253: struct bus_device *ui; ! 254: { ! 255: char *tbl; ! 256: unsigned n; ! 257: /* struct hdsoftc *sc = &hdsoftc[ui->unit]; */ ! 258: struct disklabel *lp = &hdlabel[ui->unit]; ! 259: struct hdbios *bg = &hdbios[ui->unit]; ! 260: ! 261: /* ! 262: * Set up a temporary disklabel from BIOS parameters. ! 263: * The actual partition table will be read during open. ! 264: */ ! 265: n = *(unsigned *)phystokv(ui->address); ! 266: tbl = (unsigned char *)phystokv((n & 0xffff) + ((n >> 12) & 0xffff0)); ! 267: bg->bg_ncyl = *(unsigned short *)tbl; ! 268: bg->bg_ntrk = *(unsigned char *)(tbl + 2); ! 269: bg->bg_precomp = *(unsigned short *)(tbl + 5); ! 270: bg->bg_nsect = *(unsigned char *)(tbl + 14); ! 271: fudge_bsd_label(lp, DTYPE_ESDI, bg->bg_ncyl*bg->bg_ntrk*bg->bg_nsect, ! 272: bg->bg_ntrk, bg->bg_nsect, SECSIZE, 3); ! 273: ! 274: /* FORCE sector size to 512... */ ! 275: ! 276: printf(": ntrak(heads) %d, ncyl %d, nsec %d, size %u MB", ! 277: lp->d_ntracks, lp->d_ncylinders, lp->d_nsectors, ! 278: lp->d_secperunit * lp->d_secsize / (1024*1024)); ! 279: } ! 280: ! 281: int ! 282: hdopen(dev, mode) ! 283: dev_t dev; ! 284: int mode; ! 285: { ! 286: int unit = hdunit(dev), part = hdpart(dev) /*, error */; ! 287: struct bus_device *ui; ! 288: struct hdsoftc *sc; ! 289: struct diskpart *label; ! 290: ! 291: if (unit >= NHD || (ui = hddinfo[unit]) == 0 || ui->alive == 0) ! 292: return (ENXIO); ! 293: if (!hdwstart) { ! 294: hdwstart++; ! 295: timeout(hdwatch, 0, hz); ! 296: } ! 297: sc = &hdsoftc[unit]; ! 298: /* should this be changed so only gets called once, even if all ! 299: partitions are closed and re-opened? */ ! 300: if (sc->sc_openpart == 0) { ! 301: hdinit(dev); ! 302: if (sc->sc_flags & HDF_LBA) ! 303: printf("hd%d: Using LBA mode\n", ui->unit); ! 304: } ! 305: ! 306: /* Note: should set a bit in the label structure to ensure that ! 307: aliasing prevents multiple instances to be opened. */ ! 308: #if 0 ! 309: if (part >= MAXPARTITIONS || lp->d_partitions[part].p_size == 0) ! 310: return (ENXIO); ! 311: #endif 0 ! 312: ! 313: label=lookup_part(&array[MAX_IDE_PARTS*unit], hdpart(dev)); ! 314: if (!label) ! 315: return (ENXIO); ! 316: ! 317: ! 318: sc->sc_openpart |= 1 << part; ! 319: return (0); ! 320: } ! 321: ! 322: int ! 323: hdclose(dev) ! 324: dev_t dev; ! 325: { ! 326: int unit = hdunit(dev), s; ! 327: struct hdsoftc *sc = &hdsoftc[unit]; ! 328: ! 329: sc->sc_openpart &= ~(1 << hdpart(dev)); ! 330: if (sc->sc_openpart == 0) { ! 331: s = splbio(); ! 332: while (hdutab[unit].b_active) { ! 333: sc->sc_flags |= HDF_WANT; ! 334: assert_wait((event_t)sc, FALSE); ! 335: thread_block((void (*)())0); ! 336: } ! 337: splx(s); ! 338: } ! 339: return (0); ! 340: } ! 341: ! 342: int ! 343: hdread(dev, ior) ! 344: dev_t dev; ! 345: io_req_t ior; ! 346: { ! 347: return (block_io(hdstrategy, minphys, ior)); ! 348: } ! 349: ! 350: int ! 351: hdwrite(dev, ior) ! 352: dev_t dev; ! 353: io_req_t ior; ! 354: { ! 355: return (block_io(hdstrategy, minphys, ior)); ! 356: } ! 357: ! 358: int ! 359: hdgetstat(dev, flavor, data, count) ! 360: dev_t dev; ! 361: dev_flavor_t flavor; ! 362: dev_status_t data; ! 363: mach_msg_type_number_t *count; ! 364: { ! 365: int unit = hdunit(dev), part = hdpart(dev); ! 366: struct hdsoftc *sc = &hdsoftc[unit]; ! 367: struct disklabel *lp = &hdlabel[unit]; ! 368: struct buf *bp; ! 369: struct diskpart *label; ! 370: ! 371: label=lookup_part(&array[MAX_IDE_PARTS*unit], hdpart(dev)); ! 372: switch (flavor) { ! 373: ! 374: case DEV_GET_SIZE: ! 375: if (label) { ! 376: data[DEV_GET_SIZE_DEVICE_SIZE] = (label->size * lp->d_secsize); ! 377: data[DEV_GET_SIZE_RECORD_SIZE] = lp->d_secsize; ! 378: *count = DEV_GET_SIZE_COUNT; ! 379: } else { /* Kevin: added checking here */ ! 380: data[DEV_GET_SIZE_DEVICE_SIZE] = 0; ! 381: data[DEV_GET_SIZE_RECORD_SIZE] = 0; ! 382: *count = 0; ! 383: } ! 384: break; ! 385: ! 386: case DIOCGDINFO: ! 387: case DIOCGDINFO - (0x10 << 16): ! 388: dkgetlabel(lp, flavor, data, count); ! 389: break; ! 390: ! 391: case V_GETPARMS: ! 392: { ! 393: struct disk_parms *dp; ! 394: struct hdbios *bg = &hdbios[unit]; ! 395: ! 396: if (*count < (sizeof(struct disk_parms) / sizeof(int))) ! 397: return (D_INVALID_OPERATION); ! 398: dp = (struct disk_parms *)data; ! 399: dp->dp_type = DPT_WINI; ! 400: dp->dp_heads = lp->d_ntracks; ! 401: dp->dp_cyls = lp->d_ncylinders; ! 402: dp->dp_sectors = lp->d_nsectors; ! 403: dp->dp_dosheads = bg->bg_ntrk; ! 404: dp->dp_doscyls = bg->bg_ncyl; ! 405: dp->dp_dossectors = bg->bg_nsect; ! 406: dp->dp_secsiz = lp->d_secsize; ! 407: dp->dp_ptag = 0; ! 408: dp->dp_pflag = 0; ! 409: if (label) { ! 410: dp->dp_pstartsec = label->start; ! 411: dp->dp_pnumsec = label->size; ! 412: } else { /* added by Kevin */ ! 413: dp->dp_pstartsec = -1; ! 414: dp->dp_pnumsec = -1; ! 415: } ! 416: ! 417: *count = sizeof(struct disk_parms) / sizeof(int); ! 418: break; ! 419: } ! 420: case V_RDABS: ! 421: if (*count < lp->d_secsize / sizeof(int)) { ! 422: printf("hd%d: RDABS, bad size %d\n", unit, *count); ! 423: return (EINVAL); ! 424: } ! 425: bp = geteblk(lp->d_secsize); ! 426: bp->b_flags = B_READ | B_ABS; ! 427: bp->b_blkno = sc->sc_abssn; ! 428: bp->b_dev = dev; ! 429: bp->b_bcount = lp->d_secsize; ! 430: hdstrategy(bp); ! 431: biowait(bp); ! 432: if (bp->b_flags & B_ERROR) { ! 433: printf("hd%d: RDABS failed\n", unit); ! 434: brelse(bp); ! 435: return (EIO); ! 436: } ! 437: bcopy(bp->b_un.b_addr, (caddr_t)data, lp->d_secsize); ! 438: brelse(bp); ! 439: *count = lp->d_secsize / sizeof(int); ! 440: break; ! 441: ! 442: case V_VERIFY: ! 443: { ! 444: int i, amt, n, error = 0; ! 445: ! 446: bp = geteblk(I386_PGBYTES); ! 447: bp->b_blkno = sc->sc_abssn; ! 448: bp->b_dev = dev; ! 449: amt = sc->sc_abscnt; ! 450: n = I386_PGBYTES / lp->d_secsize; ! 451: while (amt > 0) { ! 452: i = (amt > n) ? n : amt; ! 453: bp->b_bcount = i * lp->d_secsize; ! 454: bp->b_flags = B_READ | B_ABS; ! 455: hdstrategy(bp); ! 456: biowait(bp); ! 457: if (bp->b_flags & B_ERROR) { ! 458: error = BAD_BLK; ! 459: break; ! 460: } ! 461: amt -= bp->b_bcount; ! 462: bp->b_blkno += i; ! 463: } ! 464: brelse(bp); ! 465: data[0] = error; ! 466: *count = 1; ! 467: break; ! 468: } ! 469: default: ! 470: return (D_INVALID_OPERATION); ! 471: } ! 472: return (0); ! 473: } ! 474: ! 475: int ! 476: hdsetstat(dev, flavor, data, count) ! 477: dev_t dev; ! 478: dev_flavor_t flavor; ! 479: dev_status_t data; ! 480: mach_msg_type_number_t count; ! 481: { ! 482: int unit = hdunit(dev); /* , part = hdpart(dev); */ ! 483: int error = 0 /*, s */; ! 484: struct hdsoftc *sc = &hdsoftc[unit]; ! 485: struct disklabel *lp = &hdlabel[unit]; ! 486: struct buf *bp; ! 487: ! 488: switch (flavor) { ! 489: ! 490: case DIOCWLABEL: ! 491: case DIOCWLABEL - (0x10 << 16): ! 492: break; ! 493: ! 494: case DIOCSDINFO: ! 495: case DIOCSDINFO - (0x10 << 16): ! 496: if (count != (sizeof(struct disklabel) / sizeof(int))) ! 497: return (D_INVALID_SIZE); ! 498: error = setdisklabel(lp, (struct disklabel *)data); ! 499: if (error == 0 && (sc->sc_flags & HDF_LBA) == 0) ! 500: sc->sc_flags |= HDF_SETPARAM; ! 501: break; ! 502: ! 503: case DIOCWDINFO: ! 504: case DIOCWDINFO - (0x10 << 16): ! 505: if (count != (sizeof(struct disklabel) / sizeof(int))) ! 506: return (D_INVALID_SIZE); ! 507: error = setdisklabel(lp, (struct disklabel *)data); ! 508: if (error == 0) { ! 509: if ((sc->sc_flags & HDF_LBA) == 0) ! 510: sc->sc_flags |= HDF_SETPARAM; ! 511: error = hdwritelabel(dev); ! 512: } ! 513: break; ! 514: ! 515: case V_REMOUNT: ! 516: hdinit(dev); ! 517: break; ! 518: ! 519: case V_ABS: ! 520: if (count != 1 && count != 2) ! 521: return (D_INVALID_OPERATION); ! 522: sc->sc_abssn = *(int *)data; ! 523: if (sc->sc_abssn < 0 || sc->sc_abssn >= lp->d_secperunit) ! 524: return (D_INVALID_OPERATION); ! 525: if (count == 2) ! 526: sc->sc_abscnt = *((int *)data + 1); ! 527: else ! 528: sc->sc_abscnt = 1; ! 529: if (sc->sc_abscnt <= 0 ! 530: || sc->sc_abssn + sc->sc_abscnt > lp->d_secperunit) ! 531: return (D_INVALID_OPERATION); ! 532: break; ! 533: ! 534: case V_WRABS: ! 535: if (count < (lp->d_secsize / sizeof(int))) { ! 536: printf("hd%d: WRABS, bad size %d\n", unit, count); ! 537: return (D_INVALID_OPERATION); ! 538: } ! 539: bp = geteblk(lp->d_secsize); ! 540: bcopy((caddr_t)data, bp->b_un.b_addr, lp->d_secsize); ! 541: bp->b_flags = B_WRITE | B_ABS; ! 542: bp->b_blkno = sc->sc_abssn; ! 543: bp->b_bcount = lp->d_secsize; ! 544: bp->b_dev = dev; ! 545: hdstrategy(bp); ! 546: biowait(bp); ! 547: if (bp->b_flags & B_ERROR) { ! 548: printf("hd%d: WRABS failed\n", unit); ! 549: error = EIO; ! 550: } ! 551: brelse(bp); ! 552: break; ! 553: ! 554: default: ! 555: return (D_INVALID_OPERATION); ! 556: } ! 557: return (error); ! 558: } ! 559: ! 560: int ! 561: hddevinfo(dev, flavor, info) ! 562: dev_t dev; ! 563: int flavor; ! 564: char *info; ! 565: { ! 566: switch (flavor) { ! 567: ! 568: case D_INFO_BLOCK_SIZE: ! 569: *((int *)info) = SECSIZE; /* #defined to 512 */ ! 570: break; ! 571: ! 572: default: ! 573: return (D_INVALID_OPERATION); ! 574: } ! 575: return (0); ! 576: } ! 577: ! 578: ! 579: ! 580: ! 581: /* Kevin T. Van Maren: Added this low-level routine for the unified ! 582: partition code. A pointer to this routine is passed, along with param* */ ! 583: int ! 584: ide_read_fun(struct ide_driver_info *param, int sectornum, char *buff) ! 585: { ! 586: struct buf *bp; ! 587: ! 588: bp = geteblk(param->sectorsize); ! 589: bp->b_flags = B_READ | B_ABS; ! 590: ! 591: bp->b_bcount = param->sectorsize; ! 592: bp->b_blkno = sectornum; ! 593: ! 594: /* WARNING: DEPENDS ON NUMBER OF BITS FOR PARTITIONS */ ! 595: bp->b_dev = param->dev & ~0x3ff; ! 596: hdstrategy(bp); ! 597: biowait(bp); ! 598: if ((bp->b_flags & B_ERROR) == 0) ! 599: bcopy((char *)bp->b_un.b_addr, buff, param->sectorsize); ! 600: else { ! 601: printf("ERROR!\n"); ! 602: return(B_ERROR); ! 603: } ! 604: ! 605: brelse(bp); ! 606: return(0); ! 607: } ! 608: ! 609: ! 610: ! 611: /* ! 612: * Initialize drive. ! 613: */ ! 614: int ! 615: hdinit(dev) ! 616: dev_t dev; ! 617: { ! 618: int unit = hdunit(dev); ! 619: struct hdsoftc *sc = &hdsoftc[unit]; ! 620: struct disklabel *lp = &hdlabel[unit], *dlp; ! 621: struct buf *bp = 0; ! 622: int numpart; ! 623: ! 624: struct ide_driver_info ide_param = { dev, /* bp, */ lp->d_secsize }; ! 625: int ret; ! 626: ! 627: /* ! 628: * Issue identify command. ! 629: */ ! 630: if ((sc->sc_flags & HDF_IDENTDONE) == 0) { ! 631: sc->sc_flags |= HDF_IDENTDONE; ! 632: bp = geteblk(lp->d_secsize); ! 633: /* sector size #defined to 512 */ ! 634: bp->b_flags = B_IDENTIFY; ! 635: bp->b_dev = dev; ! 636: hdstrategy(bp); ! 637: biowait(bp); ! 638: if ((bp->b_flags & B_ERROR) == 0) { ! 639: bcopy((char *)bp->b_un.b_addr, ! 640: (char *)&sc->sc_id, sizeof(struct hdident)); ! 641: ! 642: /* ! 643: * Check if drive supports LBA mode. ! 644: */ ! 645: if (sc->sc_id.id_capability & 2) ! 646: sc->sc_flags |= HDF_LBA; ! 647: } ! 648: } ! 649: ! 650: /* ! 651: * Check if drive supports multiple read/write mode. ! 652: */ ! 653: hdmulti(dev); ! 654: ! 655: /* Note: label was fudged during attach! */ ! 656: ! 657: /* ensure the 'raw disk' can be accessed reliably */ ! 658: array[MAX_IDE_PARTS*unit].start=0; ! 659: array[MAX_IDE_PARTS*unit].size=lp->d_secperunit; /* fill in root for MY reads */ ! 660: #if 0 ! 661: array[MAX_IDE_PARTS*unit].subs=0; ! 662: array[MAX_IDE_PARTS*unit].nsubs=0; ! 663: array[MAX_IDE_PARTS*unit].type=0; ! 664: array[MAX_IDE_PARTS*unit].fsys=0; ! 665: #endif 0 ! 666: ! 667: numpart=get_only_partition(&ide_param, (*ide_read_fun), ! 668: &array[MAX_IDE_PARTS*unit],MAX_IDE_PARTS,lp->d_secperunit, ! 669: drive_name[unit]); ! 670: ! 671: printf("%s %d partitions found\n",drive_name[unit],numpart); ! 672: ! 673: if ((sc->sc_flags & HDF_LBA) == 0) ! 674: sc->sc_flags |= HDF_SETPARAM; ! 675: ! 676: brelse(bp); ! 677: return(ret); ! 678: } ! 679: ! 680: ! 681: ! 682: ! 683: /* ! 684: * Check if drive supports multiple read/write mode. ! 685: */ ! 686: int ! 687: hdmulti(dev) ! 688: dev_t dev; ! 689: { ! 690: int unit = hdunit(dev); ! 691: struct hdsoftc *sc = &hdsoftc[unit]; ! 692: struct buf *bp; ! 693: struct hdident *id; ! 694: ! 695: if (sc->sc_flags & HDF_MULTIDONE) ! 696: return(0); ! 697: ! 698: sc->sc_flags |= HDF_MULTIDONE; ! 699: ! 700: if (hdenmulti == 0) ! 701: return(0); ! 702: ! 703: /* ! 704: * Get drive information by issuing IDENTIFY command. ! 705: */ ! 706: bp = geteblk(DEV_BSIZE); ! 707: bp->b_flags = B_IDENTIFY; ! 708: bp->b_dev = dev; ! 709: hdstrategy(bp); ! 710: biowait(bp); ! 711: id = (struct hdident *)bp->b_un.b_addr; ! 712: ! 713: /* ! 714: * If controller does not recognise IDENTIFY command, ! 715: * or does not support multiple mode, clear count. ! 716: */ ! 717: if ((bp->b_flags & B_ERROR) || !id->id_multisize) ! 718: sc->sc_multicnt = 0; ! 719: else { ! 720: sc->sc_multicnt = id->id_multisize; ! 721: printf("hd%d: max multiple size %u", unit, sc->sc_multicnt); ! 722: /* ! 723: * Use 4096 since it is the minimum block size in FFS. ! 724: */ ! 725: if (sc->sc_multicnt > 4096 / 512) ! 726: sc->sc_multicnt = 4096 / 512; ! 727: printf(", using %u\n", sc->sc_multicnt); ! 728: sc->sc_flags |= HDF_SETMULTI; ! 729: } ! 730: brelse(bp); ! 731: } ! 732: ! 733: /* ! 734: * Write label to disk. ! 735: */ ! 736: int ! 737: hdwritelabel(dev) ! 738: dev_t dev; ! 739: { ! 740: int unit = hdunit(dev), error = 0; ! 741: long labelsect; ! 742: struct buf *bp; ! 743: struct disklabel *lp = &hdlabel[unit]; ! 744: ! 745: printf("hdwritelabel: no longer implemented\n"); ! 746: ! 747: #if 0 ! 748: bp = geteblk(lp->d_secsize); ! 749: bp->b_flags = B_READ | B_ABS; ! 750: bp->b_blkno = LBLLOC + lp->d_partitions[PART_DISK].p_offset; ! 751: bp->b_bcount = lp->d_secsize; ! 752: bp->b_dev = dev; ! 753: hdstrategy(bp); ! 754: biowait(bp); ! 755: if (bp->b_flags & B_ERROR) { ! 756: printf("hd%d: hdwritelabel(), error reading disklabel\n",unit); ! 757: error = EIO; ! 758: goto out; ! 759: } ! 760: *(struct disklabel *)bp->b_un.b_addr = *lp; /* copy disk label */ ! 761: bp->b_flags = B_WRITE | B_ABS; ! 762: hdstrategy(bp); ! 763: biowait(bp); ! 764: if (bp->b_flags & B_ERROR) { ! 765: printf("hd%d: hdwritelabel(), error writing disklabel\n",unit); ! 766: error = EIO; ! 767: } ! 768: out: ! 769: brelse(bp); ! 770: #endif 0 ! 771: ! 772: return (error); ! 773: } ! 774: ! 775: /* ! 776: * Strategy routine. ! 777: * Enqueue request on drive. ! 778: */ ! 779: int ! 780: hdstrategy(bp) ! 781: struct buf *bp; ! 782: { ! 783: int unit = hdunit(bp->b_dev), part = hdpart(bp->b_dev), s; ! 784: long bn, sz, maxsz; ! 785: struct buf *dp; ! 786: struct hdsoftc *sc = &hdsoftc[unit]; ! 787: struct bus_device *ui = hddinfo[unit]; ! 788: struct disklabel *lp = &hdlabel[unit]; ! 789: struct diskpart *label; ! 790: ! 791: if (bp->b_flags & B_IDENTIFY) { ! 792: bp->b_cylin = 0; ! 793: goto q; ! 794: } ! 795: bn = bp->b_blkno; ! 796: if (bp->b_flags & B_ABS) ! 797: goto q1; ! 798: sz = (bp->b_bcount + lp->d_secsize - 1) / lp->d_secsize; ! 799: label=lookup_part(&array[MAX_IDE_PARTS*unit], hdpart(bp->b_dev)); ! 800: if (label) { ! 801: maxsz = label->size; ! 802: } else { ! 803: bp->b_flags |= B_ERROR; ! 804: bp->b_error = EINVAL; ! 805: goto done; ! 806: } ! 807: ! 808: if (bn < 0 || bn + sz > maxsz) { ! 809: if (bn == maxsz) { ! 810: bp->b_resid = bp->b_bcount; ! 811: goto done; ! 812: } ! 813: sz = maxsz - bn; ! 814: if (sz <= 0) { ! 815: bp->b_flags |= B_ERROR; ! 816: bp->b_error = EINVAL; ! 817: goto done; ! 818: } ! 819: bp->b_bcount = sz * lp->d_secsize; ! 820: } ! 821: bn += lp->d_partitions[part].p_offset; ! 822: bn += label->start; ! 823: ! 824: q1: ! 825: bp->b_cylin = (sc->sc_flags & HDF_LBA) ? bn : bn / lp->d_secpercyl; ! 826: q: ! 827: dp = &hdutab[unit]; ! 828: s = splbio(); ! 829: disksort(dp, bp); ! 830: if (!dp->b_active) { ! 831: hdustart(ui); ! 832: if (!hdtab[ui->mi->unit].b_active) ! 833: hdstart(ui->mi); ! 834: } ! 835: splx(s); ! 836: return(0); ! 837: done: ! 838: biodone(bp); ! 839: return(0); ! 840: } ! 841: ! 842: /* ! 843: * Unit start routine. ! 844: * Move request from drive to controller queue. ! 845: */ ! 846: int ! 847: hdustart(ui) ! 848: struct bus_device *ui; ! 849: { ! 850: struct buf *bp; ! 851: struct buf *dp; ! 852: ! 853: bp = &hdutab[ui->unit]; ! 854: if (bp->b_actf == 0) ! 855: return(0); ! 856: dp = &hdtab[ui->mi->unit]; ! 857: if (dp->b_actf == 0) ! 858: dp->b_actf = bp; ! 859: else ! 860: dp->b_actl->b_forw = bp; ! 861: bp->b_forw = 0; ! 862: dp->b_actl = bp; ! 863: bp->b_active++; ! 864: } ! 865: ! 866: /* ! 867: * Start output on controller. ! 868: */ ! 869: int ! 870: hdstart(um) ! 871: struct bus_ctlr *um; ! 872: { ! 873: long bn; ! 874: struct buf *bp; ! 875: struct buf *dp; ! 876: struct hdsoftc *sc; ! 877: struct hdcsoftc *hdc; ! 878: struct bus_device *ui; ! 879: struct disklabel *lp; ! 880: struct diskpart *label; ! 881: ! 882: /* ! 883: * Pull a request from the controller queue. ! 884: */ ! 885: dp = &hdtab[um->unit]; ! 886: if ((bp = dp->b_actf) == 0) ! 887: return(0); ! 888: bp = bp->b_actf; ! 889: ! 890: hdc = &hdcsoftc[um->unit]; ! 891: ui = hddinfo[hdunit(bp->b_dev)]; ! 892: sc = &hdsoftc[ui->unit]; ! 893: lp = &hdlabel[ui->unit]; ! 894: ! 895: label = lookup_part(&array[MAX_IDE_PARTS*hdunit(bp->b_dev)], hdpart(bp->b_dev)); ! 896: ! 897: /* ! 898: * Mark controller busy. ! 899: */ ! 900: dp->b_active++; ! 901: ! 902: if (bp->b_flags & B_IDENTIFY) { ! 903: hdc->sc_state = IDENTIFY; ! 904: goto doit; ! 905: } ! 906: ! 907: /* ! 908: * Figure out where this request is going. ! 909: */ ! 910: if (sc->sc_flags & HDF_LBA) ! 911: hdc->sc_cn = bp->b_cylin; ! 912: else { ! 913: bn = bp->b_blkno; ! 914: if ((bp->b_flags & B_ABS) == 0) { ! 915: bn += label->start; /* partition must be valid */ ! 916: } ! 917: hdc->sc_cn = bp->b_cylin; ! 918: hdc->sc_sn = bn % lp->d_secpercyl; ! 919: hdc->sc_tn = hdc->sc_sn / lp->d_nsectors; ! 920: hdc->sc_sn %= lp->d_nsectors; ! 921: } ! 922: ! 923: /* ! 924: * Set up for multi-sector transfer. ! 925: */ ! 926: hdc->sc_addr = bp->b_un.b_addr; ! 927: hdc->sc_resid = bp->b_bcount; ! 928: hdc->sc_wticks = 0; ! 929: hdc->sc_recalerr = 0; ! 930: hdc->sc_ioerr = 0; ! 931: ! 932: /* ! 933: * Set initial transfer state. ! 934: */ ! 935: if (sc->sc_flags & HDF_SETPARAM) ! 936: hdc->sc_state = SETPARAM; ! 937: else if (sc->sc_flags & HDF_RESTORE) ! 938: hdc->sc_state = RESTORE; ! 939: else if (sc->sc_flags & HDF_SETMULTI) ! 940: hdc->sc_state = SETMULTI; ! 941: else ! 942: hdc->sc_state = TRANSFER; ! 943: ! 944: doit: ! 945: /* ! 946: * Call transfer state routine to do the actual I/O. ! 947: */ ! 948: hdstate(um); ! 949: } ! 950: ! 951: /* ! 952: * Interrupt routine. ! 953: */ ! 954: int ! 955: hdintr(ctlr) ! 956: int ctlr; ! 957: { ! 958: int timedout; ! 959: struct bus_ctlr *um = hdminfo[ctlr]; ! 960: struct bus_device *ui; ! 961: struct buf *bp; ! 962: struct buf *dp = &hdtab[ctlr]; ! 963: struct hdcsoftc *hdc = &hdcsoftc[ctlr]; ! 964: ! 965: if (!dp->b_active) { ! 966: (void) inb(HD_STATUS(um->address)); ! 967: printf("hdc%d: stray interrupt\n", ctlr); ! 968: return(0); ! 969: } ! 970: timedout = hdc->sc_wticks >= OP_TIMEOUT; ! 971: hdc->sc_wticks = 0; ! 972: ! 973: /* ! 974: * Operation timed out, terminate request. ! 975: */ ! 976: if (timedout) { ! 977: bp = dp->b_actf->b_actf; ! 978: ui = hddinfo[hdunit(bp->b_dev)]; ! 979: hderror("timed out", ui); ! 980: hdsoftc[ui->unit].sc_flags |= HDF_RESTORE; ! 981: bp->b_flags |= B_ERROR; ! 982: bp->b_error = EIO; ! 983: hddone(ui, bp); ! 984: return(0); ! 985: } ! 986: ! 987: /* ! 988: * Let transfer state routine handle the rest. ! 989: */ ! 990: hdstate(um); ! 991: } ! 992: ! 993: /* ! 994: * Transfer finite state machine driver. ! 995: */ ! 996: int ! 997: hdstate(um) ! 998: struct bus_ctlr *um; ! 999: { ! 1000: char *msg; ! 1001: int op; ! 1002: struct buf *bp; ! 1003: struct hdsoftc *sc; ! 1004: struct bus_device *ui; ! 1005: struct disklabel *lp; ! 1006: struct hdcsoftc *hdc = &hdcsoftc[um->unit]; ! 1007: struct hdbios *bg; ! 1008: ! 1009: bp = hdtab[um->unit].b_actf->b_actf; ! 1010: ui = hddinfo[hdunit(bp->b_dev)]; ! 1011: lp = &hdlabel[ui->unit]; ! 1012: sc = &hdsoftc[ui->unit]; ! 1013: bg = &hdbios[ui->unit]; ! 1014: ! 1015: /* ! 1016: * Ensure controller is not busy. ! 1017: */ ! 1018: if (!hdwait(um)) ! 1019: goto ctlr_err; ! 1020: ! 1021: while (1) switch (hdc->sc_state) { ! 1022: ! 1023: case SETPARAM: ! 1024: /* ! 1025: * Set drive parameters. ! 1026: */ ! 1027: outb(HD_DRVHD(um->address), ! 1028: 0xa0 | (ui->slave << 4) | (lp->d_ntracks - 1)); ! 1029: outb(HD_SECTCNT(um->address), lp->d_nsectors); ! 1030: outb(HD_CMD(um->address), CMD_SETPARAM); ! 1031: hdc->sc_state = SETPARAMDONE; ! 1032: return(0); ! 1033: ! 1034: case SETPARAMDONE: ! 1035: /* ! 1036: * Set parameters complete. ! 1037: */ ! 1038: if (msg = hderrchk(um)) ! 1039: goto bad; ! 1040: sc->sc_flags &= ~HDF_SETPARAM; ! 1041: hdc->sc_state = RESTORE; ! 1042: break; ! 1043: ! 1044: case RESTORE: ! 1045: /* ! 1046: * Recalibrate drive. ! 1047: */ ! 1048: outb(HD_DRVHD(um->address), 0xa0 | (ui->slave << 4)); ! 1049: outb(HD_CMD(um->address), CMD_RESTORE); ! 1050: hdc->sc_state = RESTOREDONE; ! 1051: return(0); ! 1052: ! 1053: case RESTOREDONE: ! 1054: /* ! 1055: * Recalibration complete. ! 1056: */ ! 1057: if (msg = hderrchk(um)) { ! 1058: if (++hdc->sc_recalerr == 2) ! 1059: goto bad; ! 1060: hdc->sc_state = RESTORE; ! 1061: break; ! 1062: } ! 1063: sc->sc_flags &= ~HDF_RESTORE; ! 1064: hdc->sc_recalerr = 0; ! 1065: if (sc->sc_flags & HDF_SETMULTI) ! 1066: hdc->sc_state = SETMULTI; ! 1067: else ! 1068: hdc->sc_state = TRANSFER; ! 1069: break; ! 1070: ! 1071: case TRANSFER: ! 1072: /* ! 1073: * Perform I/O transfer. ! 1074: */ ! 1075: sc->sc_flags &= ~HDF_UNALIGNED; ! 1076: hdc->sc_state = TRANSFERDONE; ! 1077: hdc->sc_amt = hdc->sc_resid / lp->d_secsize; ! 1078: if (hdc->sc_amt == 0) { ! 1079: sc->sc_flags |= HDF_UNALIGNED; ! 1080: hdc->sc_amt = 1; ! 1081: } else if (hdc->sc_amt > 256) ! 1082: hdc->sc_amt = 256; ! 1083: if (sc->sc_multicnt > 1 && hdc->sc_amt >= sc->sc_multicnt) { ! 1084: hdc->sc_cnt = sc->sc_multicnt; ! 1085: hdc->sc_amt -= hdc->sc_amt % hdc->sc_cnt; ! 1086: if (bp->b_flags & B_READ) ! 1087: op = CMD_READMULTI; ! 1088: else ! 1089: op = CMD_WRITEMULTI; ! 1090: } else { ! 1091: hdc->sc_cnt = 1; ! 1092: if (bp->b_flags & B_READ) ! 1093: op = CMD_READ; ! 1094: else ! 1095: op = CMD_WRITE; ! 1096: } ! 1097: if (sc->sc_flags & HDF_LBA) { ! 1098: outb(HD_DRVHD(um->address), ! 1099: (0xe0 | (ui->slave << 4) ! 1100: | ((hdc->sc_cn >> 24) & 0x0f))); ! 1101: outb(HD_SECT(um->address), hdc->sc_cn); ! 1102: outb(HD_CYLLO(um->address), hdc->sc_cn >> 8); ! 1103: outb(HD_CYLHI(um->address), hdc->sc_cn >> 16); ! 1104: } else { ! 1105: outb(HD_DRVHD(um->address), ! 1106: 0xa0 | (ui->slave << 4) | hdc->sc_tn); ! 1107: outb(HD_SECT(um->address), hdc->sc_sn + 1); ! 1108: outb(HD_CYLLO(um->address), hdc->sc_cn); ! 1109: outb(HD_CYLHI(um->address), hdc->sc_cn >> 8); ! 1110: } ! 1111: outb(HD_SECTCNT(um->address), hdc->sc_amt & 0xff); ! 1112: outb(HD_PRECOMP(um->address), bg->bg_precomp / 4); ! 1113: outb(HD_CMD(um->address), op); ! 1114: if ((bp->b_flags & B_READ) == 0) { ! 1115: int i; ! 1116: caddr_t buf; ! 1117: ! 1118: if (sc->sc_flags & HDF_UNALIGNED) { ! 1119: buf = hdc->sc_buf; ! 1120: bcopy(hdc->sc_addr, buf, hdc->sc_resid); ! 1121: bzero(buf + hdc->sc_resid, ! 1122: lp->d_secsize - hdc->sc_resid); ! 1123: } else ! 1124: buf = hdc->sc_addr; ! 1125: for (i = 0; i < 1000000; i++) ! 1126: if (inb(HD_STATUS(um->address)) & ST_DREQ) { ! 1127: loutw(HD_DATA(um->address), buf, ! 1128: hdc->sc_cnt * lp->d_secsize / 2); ! 1129: return(0); ! 1130: } ! 1131: goto ctlr_err; ! 1132: } ! 1133: return(0); ! 1134: ! 1135: case TRANSFERDONE: ! 1136: /* ! 1137: * Transfer complete. ! 1138: */ ! 1139: if (msg = hderrchk(um)) { ! 1140: if (++hdc->sc_ioerr == MAX_RETRIES) ! 1141: goto bad; ! 1142: /* ! 1143: * Every fourth attempt print a message ! 1144: * and recalibrate the drive. ! 1145: */ ! 1146: if (hdc->sc_ioerr & 3) ! 1147: hdc->sc_state = TRANSFER; ! 1148: else { ! 1149: hderror(msg, ui); ! 1150: hdc->sc_state = RESTORE; ! 1151: } ! 1152: break; ! 1153: } ! 1154: if (bp->b_flags & B_READ) { ! 1155: if (sc->sc_flags & HDF_UNALIGNED) { ! 1156: linw(HD_DATA(um->address), hdc->sc_buf, ! 1157: lp->d_secsize / 2); ! 1158: bcopy(hdc->sc_buf, hdc->sc_addr, ! 1159: hdc->sc_resid); ! 1160: } else ! 1161: linw(HD_DATA(um->address), hdc->sc_addr, ! 1162: hdc->sc_cnt * lp->d_secsize / 2); ! 1163: } ! 1164: hdc->sc_resid -= hdc->sc_cnt * lp->d_secsize; ! 1165: if (hdc->sc_resid <= 0) { ! 1166: bp->b_resid = 0; ! 1167: hddone(ui, bp); ! 1168: return(0); ! 1169: } ! 1170: if (sc->sc_flags & HDF_LBA) ! 1171: hdc->sc_cn += hdc->sc_cnt; ! 1172: else { ! 1173: hdc->sc_sn += hdc->sc_cnt; ! 1174: while (hdc->sc_sn >= lp->d_nsectors) { ! 1175: hdc->sc_sn -= lp->d_nsectors; ! 1176: if (++hdc->sc_tn == lp->d_ntracks) { ! 1177: hdc->sc_tn = 0; ! 1178: hdc->sc_cn++; ! 1179: } ! 1180: } ! 1181: } ! 1182: hdc->sc_ioerr = 0; ! 1183: hdc->sc_addr += hdc->sc_cnt * lp->d_secsize; ! 1184: hdc->sc_amt -= hdc->sc_cnt; ! 1185: if (hdc->sc_amt == 0) { ! 1186: hdc->sc_state = TRANSFER; ! 1187: break; ! 1188: } ! 1189: if ((bp->b_flags & B_READ) == 0) { ! 1190: int i; ! 1191: ! 1192: for (i = 0; i < 1000000; i++) ! 1193: if (inb(HD_STATUS(um->address)) & ST_DREQ) { ! 1194: loutw(HD_DATA(um->address), ! 1195: hdc->sc_addr, ! 1196: hdc->sc_cnt * lp->d_secsize / 2); ! 1197: return(0); ! 1198: } ! 1199: goto ctlr_err; ! 1200: } ! 1201: return(0); ! 1202: ! 1203: case IDENTIFY: ! 1204: /* ! 1205: * Get drive info. ! 1206: */ ! 1207: hdc->sc_state = IDENTIFYDONE; ! 1208: outb(HD_DRVHD(um->address), 0xa0 | (ui->slave << 4)); ! 1209: outb(HD_CMD(um->address), CMD_IDENTIFY); ! 1210: return(0); ! 1211: ! 1212: case IDENTIFYDONE: ! 1213: /* ! 1214: * Get drive info complete. ! 1215: */ ! 1216: if (msg = hderrchk(um)) ! 1217: goto bad; ! 1218: linw(HD_DATA(um->address), (u_short *)bp->b_un.b_addr, 256); ! 1219: hddone(ui, bp); ! 1220: return(0); ! 1221: ! 1222: case SETMULTI: ! 1223: /* ! 1224: * Set multiple mode count. ! 1225: */ ! 1226: hdc->sc_state = SETMULTIDONE; ! 1227: outb(HD_DRVHD(um->address), 0xa0 | (ui->slave << 4)); ! 1228: outb(HD_SECTCNT(um->address), sc->sc_multicnt); ! 1229: outb(HD_CMD(um->address), CMD_SETMULTI); ! 1230: return(0); ! 1231: ! 1232: case SETMULTIDONE: ! 1233: /* ! 1234: * Set multiple mode count complete. ! 1235: */ ! 1236: sc->sc_flags &= ~HDF_SETMULTI; ! 1237: if (msg = hderrchk(um)) { ! 1238: sc->sc_multicnt = 0; ! 1239: goto bad; ! 1240: } ! 1241: hdc->sc_state = TRANSFER; ! 1242: break; ! 1243: ! 1244: default: ! 1245: printf("hd%d: invalid state\n", ui->unit); ! 1246: panic("hdstate"); ! 1247: /*NOTREACHED*/ ! 1248: } ! 1249: ! 1250: ctlr_err: ! 1251: msg = "controller error"; ! 1252: ! 1253: bad: ! 1254: hderror(msg, ui); ! 1255: bp->b_flags |= B_ERROR; ! 1256: bp->b_error = EIO; ! 1257: sc->sc_flags |= HDF_RESTORE; ! 1258: hddone(ui, bp); ! 1259: } ! 1260: ! 1261: /* ! 1262: * Terminate current request and start ! 1263: * any others that are queued. ! 1264: */ ! 1265: int ! 1266: hddone(ui, bp) ! 1267: struct bus_device *ui; ! 1268: struct buf *bp; ! 1269: { ! 1270: struct bus_ctlr *um = ui->mi; ! 1271: struct hdsoftc *sc = &hdsoftc[ui->unit]; ! 1272: struct hdcsoftc *hdc = &hdcsoftc[um->unit]; ! 1273: struct buf *dp = &hdtab[um->unit]; ! 1274: ! 1275: sc->sc_flags &= ~HDF_UNALIGNED; ! 1276: ! 1277: /* ! 1278: * Remove this request from queue. ! 1279: */ ! 1280: hdutab[ui->unit].b_actf = bp->b_actf; ! 1281: biodone(bp); ! 1282: bp = &hdutab[ui->unit]; ! 1283: dp->b_actf = bp->b_forw; ! 1284: ! 1285: /* ! 1286: * Mark controller and drive idle. ! 1287: */ ! 1288: dp->b_active = 0; ! 1289: bp->b_active = 0; ! 1290: hdc->sc_state = IDLE; ! 1291: ! 1292: /* ! 1293: * Start up other requests. ! 1294: */ ! 1295: hdustart(ui); ! 1296: hdstart(um); ! 1297: ! 1298: /* ! 1299: * Wakeup anyone waiting for drive. ! 1300: */ ! 1301: if (sc->sc_flags & HDF_WANT) { ! 1302: sc->sc_flags &= ~HDF_WANT; ! 1303: wakeup((caddr_t)sc); ! 1304: } ! 1305: } ! 1306: ! 1307: /* ! 1308: * Wait for controller to be idle. ! 1309: */ ! 1310: int ! 1311: hdwait(um) ! 1312: struct bus_ctlr *um; ! 1313: { ! 1314: int i, status; ! 1315: ! 1316: for (i = 0; i < 1000000; i++) { ! 1317: status = inb(HD_STATUS(um->address)); ! 1318: if ((status & ST_BUSY) == 0 && (status & ST_READY)) ! 1319: return (status); ! 1320: } ! 1321: return (0); ! 1322: } ! 1323: ! 1324: /* ! 1325: * Check for errors on completion of an operation. ! 1326: */ ! 1327: char * ! 1328: hderrchk(um) ! 1329: struct bus_ctlr *um; ! 1330: { ! 1331: int status; ! 1332: ! 1333: status = inb(HD_STATUS(um->address)); ! 1334: if (status & ST_WRTFLT) ! 1335: return ("write fault"); ! 1336: if (status & ST_ERROR) { ! 1337: status = inb(HD_ERROR(um->address)); ! 1338: if (status & ERR_DAM) ! 1339: return ("data address mark not found"); ! 1340: if (status & ERR_TR0) ! 1341: return ("track 0 not found"); ! 1342: if (status & ERR_ID) ! 1343: return ("sector not found"); ! 1344: if (status & ERR_ECC) ! 1345: return ("uncorrectable ECC error"); ! 1346: if (status & ERR_BADBLK) ! 1347: return ("bad block detected"); ! 1348: if (status & ERR_ABORT) ! 1349: return ("command aborted"); ! 1350: return ("hard error"); ! 1351: } ! 1352: return (NULL); ! 1353: } ! 1354: ! 1355: /* ! 1356: * Print an error message. ! 1357: */ ! 1358: hderror(msg, ui) ! 1359: char *msg; ! 1360: struct bus_device *ui; ! 1361: { ! 1362: char *op; ! 1363: int prn_sn = 0; ! 1364: struct hdcsoftc *hdc = &hdcsoftc[ui->mi->unit]; ! 1365: ! 1366: switch (hdc->sc_state) { ! 1367: ! 1368: case SETPARAM: ! 1369: case SETPARAMDONE: ! 1370: op = "SETPARAM: "; ! 1371: break; ! 1372: ! 1373: case RESTORE: ! 1374: case RESTOREDONE: ! 1375: op = "RESTORE: "; ! 1376: break; ! 1377: ! 1378: case TRANSFER: ! 1379: case TRANSFERDONE: ! 1380: if (hdutab[ui->unit].b_actf->b_flags & B_READ) ! 1381: op = "READ: "; ! 1382: else ! 1383: op = "WRITE: "; ! 1384: prn_sn = 1; ! 1385: break; ! 1386: ! 1387: case IDENTIFY: ! 1388: case IDENTIFYDONE: ! 1389: op = "IDENTIFY: "; ! 1390: break; ! 1391: ! 1392: case SETMULTI: ! 1393: case SETMULTIDONE: ! 1394: op = "SETMULTI: "; ! 1395: break; ! 1396: ! 1397: default: ! 1398: op = ""; ! 1399: break; ! 1400: } ! 1401: printf("hd%d: %s%s", ui->unit, op, msg); ! 1402: if (prn_sn) { ! 1403: if (hdsoftc[ui->unit].sc_flags & HDF_LBA) ! 1404: printf(", bn %d", hdc->sc_cn); ! 1405: else ! 1406: printf(", cn %d tn %d sn %d", ! 1407: hdc->sc_cn, hdc->sc_tn, hdc->sc_sn + 1); ! 1408: } ! 1409: printf("\n"); ! 1410: } ! 1411: ! 1412: /* ! 1413: * Watchdog routine. ! 1414: * Check for any hung operations. ! 1415: */ ! 1416: void ! 1417: hdwatch() ! 1418: { ! 1419: int unit, s; ! 1420: ! 1421: timeout(hdwatch, 0, hz); ! 1422: s = splbio(); ! 1423: for (unit = 0; unit < NHDC; unit++) ! 1424: if (hdtab[unit].b_active ! 1425: && ++hdcsoftc[unit].sc_wticks >= OP_TIMEOUT) ! 1426: hdintr(unit); ! 1427: splx(s); ! 1428: } ! 1429: ! 1430: #endif /* NHD > 0 && !LINUX_DEV */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.