![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to wd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / i386 / isa|
Return to wd.c CVS log | Up to [Net/2] / Net2 / arch / i386 / isa |
1.1 ! root 1: /*- ! 2: * Copyright (c) 1990 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * This code is derived from software contributed to Berkeley by ! 6: * William Jolitz. ! 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: * @(#)wd.c 7.2 (Berkeley) 5/9/91 ! 37: */ ! 38: ! 39: /* TODO:peel out buffer at low ipl, ! 40: speed improvement, rewrite to clean code from garbage artifacts */ ! 41: ! 42: ! 43: #include "wd.h" ! 44: #if NWD > 0 ! 45: ! 46: #include "param.h" ! 47: #include "dkbad.h" ! 48: #include "systm.h" ! 49: #include "conf.h" ! 50: #include "file.h" ! 51: #include "stat.h" ! 52: #include "ioctl.h" ! 53: #include "disklabel.h" ! 54: #include "buf.h" ! 55: #include "uio.h" ! 56: #include "i386/isa/isa_device.h" ! 57: #include "i386/isa/icu.h" ! 58: #include "i386/isa/wdreg.h" ! 59: #include "syslog.h" ! 60: #include "vm/vm.h" ! 61: ! 62: #define RETRIES 5 /* number of retries before giving up */ ! 63: #define MAXTRANSFER 32 /* max size of transfer in page clusters */ ! 64: ! 65: #define wdctlr(dev) ((minor(dev) & 0x80) >> 7) ! 66: #define wdunit(dev) ((minor(dev) & 0x60) >> 5) ! 67: #define wdpart(dev) ((minor(dev) & 0x1f)) ! 68: ! 69: #define b_cylin b_resid /* cylinder number for doing IO to */ ! 70: /* shares an entry in the buf struct */ ! 71: ! 72: /* ! 73: * Drive states. Used for open and format operations. ! 74: * States < OPEN (> 0) are transient, during an open operation. ! 75: * OPENRAW is used for unlabeled disks, and for floppies, to inhibit ! 76: * bad-sector forwarding. ! 77: */ ! 78: #define RAWDISK 8 /* raw disk operation, no translation*/ ! 79: #define ISRAWSTATE(s) (RAWDISK&(s)) /* are we in a raw state? */ ! 80: #define DISKSTATE(s) (~RAWDISK&(s)) /* are we in a given state regardless ! 81: of raw or cooked mode? */ ! 82: ! 83: #define CLOSED 0 /* disk is closed. */ ! 84: /* "cooked" disk states */ ! 85: #define WANTOPEN 1 /* open requested, not started */ ! 86: #define RECAL 2 /* doing restore */ ! 87: #define RDLABEL 3 /* reading pack label */ ! 88: #define RDBADTBL 4 /* reading bad-sector table */ ! 89: #define OPEN 5 /* done with open */ ! 90: ! 91: #define WANTOPENRAW (WANTOPEN|RAWDISK) /* raw WANTOPEN */ ! 92: #define RECALRAW (RECAL|RAWDISK) /* raw open, doing restore */ ! 93: #define OPENRAW (OPEN|RAWDISK) /* open, but unlabeled disk or floppy */ ! 94: ! 95: ! 96: /* ! 97: * The structure of a disk drive. ! 98: */ ! 99: struct disk { ! 100: struct disklabel dk_dd; /* device configuration data */ ! 101: long dk_bc; /* byte count left */ ! 102: short dk_skip; /* blocks already transferred */ ! 103: char dk_unit; /* physical unit number */ ! 104: char dk_state; /* control state */ ! 105: u_char dk_status; /* copy of status reg. */ ! 106: u_char dk_error; /* copy of error reg. */ ! 107: short dk_open; /* open/closed refcnt */ ! 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: short dk_wlabel; /* label writable? */ ! 112: }; ! 113: ! 114: /* ! 115: * This label is used as a default when initializing a new or raw disk. ! 116: * It really only lets us access the first track until we know more. ! 117: */ ! 118: struct disklabel dflt_sizes = { ! 119: DISKMAGIC, DTYPE_ST506, 0, "default", "", ! 120: 512, /* sector size */ ! 121: 17, /* # of sectors per track */ ! 122: 8, /* # of tracks per cylinder */ ! 123: 766, /* # of cylinders per unit */ ! 124: 17*8, /* # of sectors per cylinder */ ! 125: 766*8*17, /* # of sectors per unit */ ! 126: 0, /* # of spare sectors per track */ ! 127: 0, /* # of spare sectors per cylinder */ ! 128: 0, /* # of alt. cylinders per unit */ ! 129: 3600, /* rotational speed */ ! 130: 1, /* hardware sector interleave */ ! 131: 0, /* sector 0 skew, per track */ ! 132: 0, /* sector 0 skew, per cylinder */ ! 133: 0, /* head switch time, usec */ ! 134: 0, /* track-to-track seek, usec */ ! 135: 0, /* generic flags */ ! 136: 0,0,0,0,0, ! 137: 0,0,0,0,0, ! 138: DISKMAGIC, ! 139: 0, ! 140: 8, ! 141: 8192, ! 142: 8192, ! 143: ! 144: {{21600, 0, 0,0,0,0}, /* A=root filesystem */ ! 145: {21600, 40, 0,0,0,0}, ! 146: {660890, 0, 0,0,0,0}, /* C=whole disk */ ! 147: {216000, 80, 0,0,0,0}, ! 148: {0, 0, 0,0,0,0}, ! 149: {0, 0, 0,0,0,0}, ! 150: {0, 0, 0,0,0,0}, ! 151: {399600, 480, 0,0,0,0}} ! 152: }; ! 153: ! 154: static struct dkbad dkbad[NWD]; ! 155: struct disk wddrives[NWD] = {0}; /* table of units */ ! 156: struct buf wdtab = {0}; ! 157: struct buf wdutab[NWD] = {0}; /* head of queue per drive */ ! 158: struct buf rwdbuf[NWD] = {0}; /* buffers for raw IO */ ! 159: long wdxfer[NWD] = {0}; /* count of transfers */ ! 160: int writeprotected[NWD] = { 0 }; ! 161: int wdprobe(), wdattach(), wdintr(); ! 162: struct isa_driver wddriver = { ! 163: wdprobe, wdattach, "wd", ! 164: }; ! 165: ! 166: static wdc; ! 167: /* ! 168: * Probe routine ! 169: */ ! 170: wdprobe(dvp) ! 171: struct isa_device *dvp; ! 172: { ! 173: wdc = dvp->id_iobase; ! 174: ! 175: #ifdef lint ! 176: wdintr(0); ! 177: #endif ! 178: /* XXX sorry, needs to be better */ ! 179: outb(wdc+wd_error, 0x5a) ; /* error register not writable */ ! 180: outb(wdc+wd_cyl_lo, 0xa5) ; /* but all of cyllo are implemented */ ! 181: if(inb(wdc+wd_error) != 0x5a && inb(wdc+wd_cyl_lo) == 0xa5) ! 182: return(1) ; ! 183: return (0); ! 184: } ! 185: ! 186: /* ! 187: * attach each drive if possible. ! 188: */ ! 189: wdattach(dvp) ! 190: struct isa_device *dvp; ! 191: { ! 192: int unit = dvp->id_unit; ! 193: ! 194: outb(wdc+wd_ctlr,12); ! 195: DELAY(1000); ! 196: outb(wdc+wd_ctlr,8); ! 197: } ! 198: ! 199: /* Read/write routine for a buffer. Finds the proper unit, range checks ! 200: * arguments, and schedules the transfer. Does not wait for the transfer ! 201: * to complete. Multi-page transfers are supported. All I/O requests must ! 202: * be a multiple of a sector in length. ! 203: */ ! 204: wdstrategy(bp) ! 205: register struct buf *bp; /* IO operation to perform */ ! 206: { ! 207: register struct buf *dp; ! 208: register struct disk *du; /* Disk unit to do the IO. */ ! 209: register struct partition *p; ! 210: long maxsz, sz; ! 211: int unit = wdunit(bp->b_dev); ! 212: int s; ! 213: ! 214: if ((unit >= NWD) || (bp->b_blkno < 0)) { ! 215: printf("wdstrat: unit = %d, blkno = %d, bcount = %d\n", ! 216: unit, bp->b_blkno, bp->b_bcount); ! 217: pg("wd:error in wdstrategy"); ! 218: bp->b_flags |= B_ERROR; ! 219: goto bad; ! 220: } ! 221: if (writeprotected[unit] && (bp->b_flags & B_READ) == 0) { ! 222: printf("wd%d: write protected\n", unit); ! 223: goto bad; ! 224: } ! 225: du = &wddrives[unit]; ! 226: if (DISKSTATE(du->dk_state) != OPEN) ! 227: goto q; ! 228: #ifdef old ! 229: /* ! 230: * Convert DEV_BSIZE "blocks" to sectors. ! 231: * Note: doing the conversions this way limits the partition size ! 232: * to about 8 million sectors (1-8 Gb). ! 233: */ ! 234: blknum = (unsigned long) bp->b_blkno * DEV_BSIZE / du->dk_dd.d_secsize; ! 235: if (((u_long) bp->b_blkno * DEV_BSIZE % du->dk_dd.d_secsize != 0) || ! 236: bp->b_bcount >= MAXTRANSFER * CLBYTES) { ! 237: bp->b_flags |= B_ERROR; ! 238: goto bad; ! 239: } ! 240: nblocks = du->dk_dd.d_partitions[part].p_size; ! 241: cyloff = du->dk_dd.d_partitions[part].p_offset; ! 242: if (blknum + (bp->b_bcount / du->dk_dd.d_secsize) > nblocks) { ! 243: if (blknum == nblocks) ! 244: bp->b_resid = bp->b_bcount; ! 245: else ! 246: bp->b_flags |= B_ERROR; ! 247: goto bad; ! 248: } ! 249: bp->b_cylin = blknum / du->dk_dd.d_secpercyl + cyloff; ! 250: #else ! 251: /* ! 252: * Determine the size of the transfer, and make sure it is ! 253: * within the boundaries of the partition. ! 254: */ ! 255: p = &du->dk_dd.d_partitions[wdpart(bp->b_dev)]; ! 256: maxsz = p->p_size; ! 257: sz = (bp->b_bcount + DEV_BSIZE - 1) >> DEV_BSHIFT; ! 258: if (bp->b_blkno + p->p_offset <= LABELSECTOR && ! 259: #if LABELSECTOR != 0 ! 260: bp->b_blkno + p->p_offset + sz > LABELSECTOR && ! 261: #endif ! 262: (bp->b_flags & B_READ) == 0 && du->dk_wlabel == 0) { ! 263: bp->b_error = EROFS; ! 264: goto bad; ! 265: } ! 266: if (bp->b_blkno < 0 || bp->b_blkno + sz > maxsz) { ! 267: /* if exactly at end of disk, return an EOF */ ! 268: if (bp->b_blkno == maxsz) { ! 269: bp->b_resid = bp->b_bcount; ! 270: biodone(bp); ! 271: return; ! 272: } ! 273: /* or truncate if part of it fits */ ! 274: sz = maxsz - bp->b_blkno; ! 275: if (sz <= 0) ! 276: goto bad; ! 277: bp->b_bcount = sz << DEV_BSHIFT; ! 278: } ! 279: bp->b_cylin = (bp->b_blkno + p->p_offset) / du->dk_dd.d_secpercyl; ! 280: #endif ! 281: q: ! 282: dp = &wdutab[unit]; ! 283: s = splhigh(); ! 284: disksort(dp, bp); ! 285: if (dp->b_active == 0) ! 286: wdustart(du); /* start drive if idle */ ! 287: if (wdtab.b_active == 0) ! 288: wdstart(s); /* start IO if controller idle */ ! 289: splx(s); ! 290: return; ! 291: ! 292: bad: ! 293: bp->b_error = EINVAL; ! 294: biodone(bp); ! 295: } ! 296: ! 297: /* Routine to queue a read or write command to the controller. The request is ! 298: * linked into the active list for the controller. If the controller is idle, ! 299: * the transfer is started. ! 300: */ ! 301: wdustart(du) ! 302: register struct disk *du; ! 303: { ! 304: register struct buf *bp, *dp; ! 305: ! 306: dp = &wdutab[du->dk_unit]; ! 307: if (dp->b_active) ! 308: return; ! 309: bp = dp->b_actf; ! 310: if (bp == NULL) ! 311: return; ! 312: dp->b_forw = NULL; ! 313: if (wdtab.b_actf == NULL) /* link unit into active list */ ! 314: wdtab.b_actf = dp; ! 315: else ! 316: wdtab.b_actl->b_forw = dp; ! 317: wdtab.b_actl = dp; ! 318: dp->b_active = 1; /* mark the drive as busy */ ! 319: } ! 320: ! 321: /* ! 322: * Controller startup routine. This does the calculation, and starts ! 323: * a single-sector read or write operation. Called to start a transfer, ! 324: * or from the interrupt routine to continue a multi-sector transfer. ! 325: * RESTRICTIONS: ! 326: * 1. The transfer length must be an exact multiple of the sector size. ! 327: */ ! 328: ! 329: static wd_sebyse; ! 330: ! 331: wdstart() ! 332: { ! 333: register struct disk *du; /* disk unit for IO */ ! 334: register struct buf *bp; ! 335: struct buf *dp; ! 336: register struct bt_bad *bt_ptr; ! 337: long blknum, pagcnt, cylin, head, sector; ! 338: long secpertrk, secpercyl, addr, i; ! 339: int unit, s; ! 340: ! 341: loop: ! 342: dp = wdtab.b_actf; ! 343: if (dp == NULL) ! 344: return; ! 345: bp = dp->b_actf; ! 346: if (bp == NULL) { ! 347: wdtab.b_actf = dp->b_forw; ! 348: goto loop; ! 349: } ! 350: unit = wdunit(bp->b_dev); ! 351: du = &wddrives[unit]; ! 352: if (DISKSTATE(du->dk_state) <= RDLABEL) { ! 353: if (wdcontrol(bp)) { ! 354: dp->b_actf = bp->av_forw; ! 355: goto loop; /* done */ ! 356: } ! 357: return; ! 358: } ! 359: secpertrk = du->dk_dd.d_nsectors; ! 360: secpercyl = du->dk_dd.d_secpercyl; ! 361: /* ! 362: * Convert DEV_BSIZE "blocks" to sectors. ! 363: */ ! 364: blknum = (unsigned long) bp->b_blkno * DEV_BSIZE / du->dk_dd.d_secsize ! 365: + du->dk_skip; ! 366: #ifdef WDDEBUG ! 367: if (du->dk_skip == 0) { ! 368: dprintf(DDSK,"\nwdstart %d: %s %d@%d; map ", unit, ! 369: (bp->b_flags & B_READ) ? "read" : "write", ! 370: bp->b_bcount, blknum); ! 371: } else { ! 372: dprintf(DDSK," %d)%x", du->dk_skip, inb(wdc+wd_altsts)); ! 373: } ! 374: #endif ! 375: ! 376: addr = (int) bp->b_un.b_addr; ! 377: if(du->dk_skip==0) du->dk_bc = bp->b_bcount; ! 378: cylin = blknum / secpercyl; ! 379: head = (blknum % secpercyl) / secpertrk; ! 380: sector = blknum % secpertrk; ! 381: if (DISKSTATE(du->dk_state) == OPEN) ! 382: cylin += du->dk_dd.d_partitions[wdpart(bp->b_dev)].p_offset ! 383: / secpercyl; ! 384: ! 385: /* ! 386: * See if the current block is in the bad block list. ! 387: * (If we have one, and not formatting.) ! 388: */ ! 389: if (DISKSTATE(du->dk_state) == OPEN && wd_sebyse) ! 390: for (bt_ptr = dkbad[unit].bt_bad; bt_ptr->bt_cyl != -1; bt_ptr++) { ! 391: if (bt_ptr->bt_cyl > cylin) ! 392: /* Sorted list, and we passed our cylinder. quit. */ ! 393: break; ! 394: if (bt_ptr->bt_cyl == cylin && ! 395: bt_ptr->bt_trksec == (head << 8) + sector) { ! 396: /* ! 397: * Found bad block. Calculate new block addr. ! 398: * This starts at the end of the disk (skip the ! 399: * last track which is used for the bad block list), ! 400: * and works backwards to the front of the disk. ! 401: */ ! 402: #ifdef WDDEBUG ! 403: dprintf(DDSK,"--- badblock code -> Old = %d; ", ! 404: blknum); ! 405: #endif ! 406: blknum = du->dk_dd.d_secperunit - du->dk_dd.d_nsectors ! 407: - (bt_ptr - dkbad[unit].bt_bad) - 1; ! 408: cylin = blknum / secpercyl; ! 409: head = (blknum % secpercyl) / secpertrk; ! 410: sector = blknum % secpertrk; ! 411: #ifdef WDDEBUG ! 412: dprintf(DDSK, "new = %d\n", blknum); ! 413: #endif ! 414: break; ! 415: } ! 416: } ! 417: sector += 1; /* sectors begin with 1, not 0 */ ! 418: ! 419: wdtab.b_active = 1; /* mark controller active */ ! 420: ! 421: if(du->dk_skip==0 || wd_sebyse) { ! 422: if(wdtab.b_errcnt && (bp->b_flags & B_READ) == 0) du->dk_bc += 512; ! 423: while ((inb(wdc+wd_status) & WDCS_BUSY) != 0) ; ! 424: /*while ((inb(wdc+wd_status) & WDCS_DRQ)) inb(wdc+wd_data);*/ ! 425: outb(wdc+wd_precomp, 0xff); ! 426: /*wr(wdc+wd_precomp, du->dk_dd.dk_precompcyl / 4);*/ ! 427: /*if (bp->b_flags & B_FORMAT) { ! 428: wr(wdc+wd_sector, du->dk_dd.dk_gap3); ! 429: wr(wdc+wd_seccnt, du->dk_dd.dk_nsectors); ! 430: } else {*/ ! 431: if(wd_sebyse) ! 432: outb(wdc+wd_seccnt, 1); ! 433: else ! 434: outb(wdc+wd_seccnt, ((du->dk_bc +511) / 512)); ! 435: outb(wdc+wd_sector, sector); ! 436: ! 437: outb(wdc+wd_cyl_lo, cylin); ! 438: outb(wdc+wd_cyl_hi, cylin >> 8); ! 439: ! 440: /* Set up the SDH register (select drive). */ ! 441: outb(wdc+wd_sdh, WDSD_IBM | (unit<<4) | (head & 0xf)); ! 442: while ((inb(wdc+wd_status) & WDCS_READY) == 0) ; ! 443: ! 444: /*if (bp->b_flags & B_FORMAT) ! 445: wr(wdc+wd_command, WDCC_FORMAT); ! 446: else*/ ! 447: outb(wdc+wd_command, ! 448: (bp->b_flags & B_READ)? WDCC_READ : WDCC_WRITE); ! 449: #ifdef WDDEBUG ! 450: dprintf(DDSK,"sector %d cylin %d head %d addr %x sts %x\n", ! 451: sector, cylin, head, addr, inb(wdc+wd_altsts)); ! 452: #endif ! 453: } ! 454: ! 455: /* If this is a read operation, just go away until it's done. */ ! 456: if (bp->b_flags & B_READ) return; ! 457: ! 458: /* Ready to send data? */ ! 459: while ((inb(wdc+wd_status) & WDCS_DRQ) == 0); ! 460: ! 461: /* ASSUMES CONTIGUOUS MEMORY */ ! 462: outsw (wdc+wd_data, addr+du->dk_skip*512, 256); ! 463: du->dk_bc -= 512; ! 464: } ! 465: ! 466: /* ! 467: * these are globally defined so they can be found ! 468: * by the debugger easily in the case of a system crash ! 469: */ ! 470: daddr_t wd_errsector; ! 471: daddr_t wd_errbn; ! 472: unsigned char wd_errstat; ! 473: ! 474: /* Interrupt routine for the controller. Acknowledge the interrupt, check for ! 475: * errors on the current operation, mark it done if necessary, and start ! 476: * the next request. Also check for a partially done transfer, and ! 477: * continue with the next chunk if so. ! 478: */ ! 479: wdintr(unit) ! 480: { ! 481: register struct disk *du; ! 482: register struct buf *bp, *dp; ! 483: int status; ! 484: char partch ; ! 485: static wd_haderror; ! 486: ! 487: /* Shouldn't need this, but it may be a slow controller. */ ! 488: while ((status = inb(wdc+wd_status)) & WDCS_BUSY) ; ! 489: if (!wdtab.b_active) { ! 490: printf("wd: extra interrupt\n"); ! 491: return; ! 492: } ! 493: ! 494: #ifdef WDDEBUG ! 495: dprintf(DDSK,"I "); ! 496: #endif ! 497: dp = wdtab.b_actf; ! 498: bp = dp->b_actf; ! 499: du = &wddrives[wdunit(bp->b_dev)]; ! 500: partch = wdpart(bp->b_dev) + 'a'; ! 501: if (DISKSTATE(du->dk_state) <= RDLABEL) { ! 502: if (wdcontrol(bp)) ! 503: goto done; ! 504: return; ! 505: } ! 506: if (status & (WDCS_ERR | WDCS_ECCCOR)) { ! 507: wd_errstat = inb(wdc+wd_error); /* save error status */ ! 508: #ifdef WDDEBUG ! 509: printf("status %x error %x\n", status, wd_errstat); ! 510: #endif ! 511: if(wd_sebyse == 0) { ! 512: wd_haderror = 1; ! 513: goto outt; ! 514: } ! 515: /*if (bp->b_flags & B_FORMAT) { ! 516: du->dk_status = status; ! 517: du->dk_error = wdp->wd_error; ! 518: bp->b_flags |= B_ERROR; ! 519: goto done; ! 520: }*/ ! 521: ! 522: wd_errsector = (bp->b_cylin * du->dk_dd.d_secpercyl) + ! 523: (((unsigned long) bp->b_blkno * DEV_BSIZE / ! 524: du->dk_dd.d_secsize) % du->dk_dd.d_secpercyl) + ! 525: du->dk_skip; ! 526: wd_errbn = bp->b_blkno ! 527: + du->dk_skip * du->dk_dd.d_secsize / DEV_BSIZE ; ! 528: if (status & WDCS_ERR) { ! 529: if (++wdtab.b_errcnt < RETRIES) { ! 530: wdtab.b_active = 0; ! 531: } else { ! 532: printf("wd%d%c: ", du->dk_unit, partch); ! 533: printf( ! 534: "hard %s error, sn %d bn %d status %b error %b\n", ! 535: (bp->b_flags & B_READ)? "read":"write", ! 536: wd_errsector, wd_errbn, status, WDCS_BITS, ! 537: wd_errstat, WDERR_BITS); ! 538: bp->b_flags |= B_ERROR; /* flag the error */ ! 539: } ! 540: } else ! 541: log(LOG_WARNING,"wd%d%c: soft ecc sn %d bn %d\n", ! 542: du->dk_unit, partch, wd_errsector, ! 543: wd_errbn); ! 544: } ! 545: outt: ! 546: ! 547: /* ! 548: * If this was a successful read operation, fetch the data. ! 549: */ ! 550: if (((bp->b_flags & (B_READ | B_ERROR)) == B_READ) && wdtab.b_active) { ! 551: int chk, dummy; ! 552: ! 553: chk = min(256,du->dk_bc/2); ! 554: /* Ready to receive data? */ ! 555: while ((inb(wdc+wd_status) & WDCS_DRQ) == 0) ; ! 556: ! 557: /*dprintf(DDSK,"addr %x\n", (int)bp->b_un.b_addr + du->dk_skip * 512);*/ ! 558: insw(wdc+wd_data,(int)bp->b_un.b_addr + du->dk_skip * 512 ,chk); ! 559: du->dk_bc -= 2*chk; ! 560: while (chk++ < 256) insw (wdc+wd_data,&dummy,1); ! 561: } ! 562: ! 563: wdxfer[du->dk_unit]++; ! 564: if (wdtab.b_active) { ! 565: if ((bp->b_flags & B_ERROR) == 0) { ! 566: du->dk_skip++; /* Add to successful sectors. */ ! 567: if (wdtab.b_errcnt) { ! 568: log(LOG_WARNING, "wd%d%c: ", ! 569: du->dk_unit, partch); ! 570: log(LOG_WARNING, ! 571: "soft %s error, sn %d bn %d error %b retries %d\n", ! 572: (bp->b_flags & B_READ) ? "read" : "write", ! 573: wd_errsector, wd_errbn, wd_errstat, ! 574: WDERR_BITS, wdtab.b_errcnt); ! 575: } ! 576: wdtab.b_errcnt = 0; ! 577: ! 578: /* see if more to transfer */ ! 579: /*if (du->dk_skip < (bp->b_bcount + 511) / 512) {*/ ! 580: if (du->dk_bc > 0 && wd_haderror == 0) { ! 581: wdstart(); ! 582: return; /* next chunk is started */ ! 583: } else if (wd_haderror && wd_sebyse == 0) { ! 584: du->dk_skip = 0; ! 585: wd_haderror = 0; ! 586: wd_sebyse = 1; ! 587: wdstart(); ! 588: return; /* redo xfer sector by sector */ ! 589: } ! 590: } ! 591: ! 592: done: ! 593: wd_sebyse = 0; ! 594: /* done with this transfer, with or without error */ ! 595: wdtab.b_actf = dp->b_forw; ! 596: wdtab.b_errcnt = 0; ! 597: du->dk_skip = 0; ! 598: dp->b_active = 0; ! 599: dp->b_actf = bp->av_forw; ! 600: dp->b_errcnt = 0; ! 601: bp->b_resid = 0; ! 602: biodone(bp); ! 603: } ! 604: wdtab.b_active = 0; ! 605: if (dp->b_actf) ! 606: wdustart(du); /* requeue disk if more io to do */ ! 607: if (wdtab.b_actf) ! 608: wdstart(); /* start IO on next drive */ ! 609: } ! 610: ! 611: /* ! 612: * Initialize a drive. ! 613: */ ! 614: wdopen(dev, flags, fmt) ! 615: dev_t dev; ! 616: int flags, fmt; ! 617: { ! 618: register unsigned int unit; ! 619: register struct buf *bp; ! 620: register struct disk *du; ! 621: int part = wdpart(dev), mask = 1 << part; ! 622: struct partition *pp; ! 623: struct dkbad *db; ! 624: int i, error = 0; ! 625: ! 626: unit = wdunit(dev); ! 627: if (unit >= NWD) return (ENXIO) ; ! 628: du = &wddrives[unit]; ! 629: #ifdef notdef ! 630: if (du->dk_open){ ! 631: du->dk_open++ ; ! 632: return(0); /* already is open, don't mess with it */ ! 633: } ! 634: #endif ! 635: du->dk_unit = unit; ! 636: wdutab[unit].b_actf = NULL; ! 637: /*if (flags & O_NDELAY) ! 638: du->dk_state = WANTOPENRAW; ! 639: else*/ ! 640: du->dk_state = WANTOPEN; ! 641: /* ! 642: * Use the default sizes until we've read the label, ! 643: * or longer if there isn't one there. ! 644: */ ! 645: du->dk_dd = dflt_sizes; ! 646: ! 647: /* ! 648: * Recal, read of disk label will be done in wdcontrol ! 649: * during first read operation. ! 650: */ ! 651: bp = geteblk(512); ! 652: bp->b_dev = dev & 0xff00; ! 653: bp->b_bcount = 0; ! 654: bp->b_blkno = LABELSECTOR; ! 655: bp->b_flags = B_READ; ! 656: wdstrategy(bp); ! 657: biowait(bp); ! 658: if (bp->b_flags & B_ERROR) { ! 659: error = ENXIO; ! 660: du->dk_state = CLOSED; ! 661: goto done; ! 662: } ! 663: if (du->dk_state == OPENRAW) { ! 664: du->dk_state = OPENRAW; ! 665: goto done; ! 666: } ! 667: /* ! 668: * Read bad sector table into memory. ! 669: */ ! 670: i = 0; ! 671: do { ! 672: bp->b_flags = B_BUSY | B_READ; ! 673: bp->b_blkno = du->dk_dd.d_secperunit - du->dk_dd.d_nsectors ! 674: + i; ! 675: if (du->dk_dd.d_secsize > DEV_BSIZE) ! 676: bp->b_blkno *= du->dk_dd.d_secsize / DEV_BSIZE; ! 677: else ! 678: bp->b_blkno /= DEV_BSIZE / du->dk_dd.d_secsize; ! 679: bp->b_bcount = du->dk_dd.d_secsize; ! 680: bp->b_cylin = du->dk_dd.d_ncylinders - 1; ! 681: wdstrategy(bp); ! 682: biowait(bp); ! 683: } while ((bp->b_flags & B_ERROR) && (i += 2) < 10 && ! 684: i < du->dk_dd.d_nsectors); ! 685: db = (struct dkbad *)(bp->b_un.b_addr); ! 686: #define DKBAD_MAGIC 0x4321 ! 687: if ((bp->b_flags & B_ERROR) == 0 && db->bt_mbz == 0 && ! 688: db->bt_flag == DKBAD_MAGIC) { ! 689: dkbad[unit] = *db; ! 690: du->dk_state = OPEN; ! 691: } else { ! 692: printf("wd%d: %s bad-sector file\n", unit, ! 693: (bp->b_flags & B_ERROR) ? "can't read" : "format error in"); ! 694: error = ENXIO ; ! 695: du->dk_state = OPENRAW; ! 696: } ! 697: done: ! 698: bp->b_flags = B_INVAL | B_AGE; ! 699: brelse(bp); ! 700: if (error == 0) ! 701: du->dk_open = 1; ! 702: ! 703: /* ! 704: * Warn if a partion is opened ! 705: * that overlaps another partition which is open ! 706: * unless one is the "raw" partition (whole disk). ! 707: */ ! 708: #define RAWPART 8 /* 'x' partition */ /* XXX */ ! 709: if ((du->dk_openpart & mask) == 0 && part != RAWPART) { ! 710: int start, end; ! 711: ! 712: pp = &du->dk_dd.d_partitions[part]; ! 713: start = pp->p_offset; ! 714: end = pp->p_offset + pp->p_size; ! 715: for (pp = du->dk_dd.d_partitions; ! 716: pp < &du->dk_dd.d_partitions[du->dk_dd.d_npartitions]; ! 717: pp++) { ! 718: if (pp->p_offset + pp->p_size <= start || ! 719: pp->p_offset >= end) ! 720: continue; ! 721: if (pp - du->dk_dd.d_partitions == RAWPART) ! 722: continue; ! 723: if (du->dk_openpart & (1 << (pp - ! 724: du->dk_dd.d_partitions))) ! 725: log(LOG_WARNING, ! 726: "wd%d%c: overlaps open partition (%c)\n", ! 727: unit, part + 'a', ! 728: pp - du->dk_dd.d_partitions + 'a'); ! 729: } ! 730: } ! 731: if (part >= du->dk_dd.d_npartitions) ! 732: return (ENXIO); ! 733: du->dk_openpart |= mask; ! 734: switch (fmt) { ! 735: case S_IFCHR: ! 736: du->dk_copenpart |= mask; ! 737: break; ! 738: case S_IFBLK: ! 739: du->dk_bopenpart |= mask; ! 740: break; ! 741: } ! 742: return (error); ! 743: } ! 744: ! 745: /* ! 746: * Implement operations other than read/write. ! 747: * Called from wdstart or wdintr during opens and formats. ! 748: * Uses finite-state-machine to track progress of operation in progress. ! 749: * Returns 0 if operation still in progress, 1 if completed. ! 750: */ ! 751: wdcontrol(bp) ! 752: register struct buf *bp; ! 753: { ! 754: register struct disk *du; ! 755: register unit; ! 756: unsigned char stat; ! 757: int s, cnt; ! 758: extern int bootdev, cyloffset; ! 759: ! 760: du = &wddrives[wdunit(bp->b_dev)]; ! 761: unit = du->dk_unit; ! 762: switch (DISKSTATE(du->dk_state)) { ! 763: ! 764: tryagainrecal: ! 765: case WANTOPEN: /* set SDH, step rate, do restore */ ! 766: #ifdef WDDEBUG ! 767: dprintf(DDSK,"wd%d: recal ", unit); ! 768: #endif ! 769: s = splbio(); /* not called from intr level ... */ ! 770: outb(wdc+wd_sdh, WDSD_IBM | (unit << 4)); ! 771: wdtab.b_active = 1; ! 772: outb(wdc+wd_command, WDCC_RESTORE | WD_STEP); ! 773: du->dk_state++; ! 774: splx(s); ! 775: return(0); ! 776: ! 777: case RECAL: ! 778: if ((stat = inb(wdc+wd_status)) & WDCS_ERR) { ! 779: printf("wd%d: recal", du->dk_unit); ! 780: if (unit == 0) { ! 781: printf(": status %b error %b\n", ! 782: stat, WDCS_BITS, ! 783: inb(wdc+wd_error), WDERR_BITS); ! 784: if (++wdtab.b_errcnt < RETRIES) ! 785: goto tryagainrecal; ! 786: } ! 787: goto badopen; ! 788: } ! 789: ! 790: /* some compaq controllers require this ... */ ! 791: wdsetctlr(bp->b_dev, du); ! 792: ! 793: wdtab.b_errcnt = 0; ! 794: if (ISRAWSTATE(du->dk_state)) { ! 795: du->dk_state = OPENRAW; ! 796: return(1); ! 797: } ! 798: retry: ! 799: #ifdef WDDEBUG ! 800: dprintf(DDSK,"rdlabel "); ! 801: #endif ! 802: if( cyloffset < 0 || cyloffset > 8192) cyloffset=0; ! 803: /* ! 804: * Read in sector LABELSECTOR to get the pack label ! 805: * and geometry. ! 806: */ ! 807: outb(wdc+wd_precomp, 0xff);/* sometimes this is head bit 3 */ ! 808: outb(wdc+wd_seccnt, 1); ! 809: outb(wdc+wd_sector, LABELSECTOR+1); ! 810: /*if (bp->b_dev == bootdev) { ! 811: (wdc+wd_cyl_lo = cyloffset & 0xff; ! 812: (wdc+wd_cyl_hi = cyloffset >> 8; ! 813: } else { ! 814: (wdc+wd_cyl_lo = 0; ! 815: (wdc+wd_cyl_hi = 0; ! 816: }*/ ! 817: outb(wdc+wd_cyl_lo, (cyloffset & 0xff)); ! 818: outb(wdc+wd_cyl_hi, (cyloffset >> 8)); ! 819: outb(wdc+wd_sdh, WDSD_IBM | (unit << 4)); ! 820: outb(wdc+wd_command, WDCC_READ); ! 821: du->dk_state = RDLABEL; ! 822: return(0); ! 823: ! 824: case RDLABEL: ! 825: if ((stat = inb(wdc+wd_status)) & WDCS_ERR) { ! 826: if (++wdtab.b_errcnt < RETRIES) ! 827: goto retry; ! 828: printf("wd%d: read label", unit); ! 829: goto badopen; ! 830: } ! 831: ! 832: insw(wdc+wd_data, bp->b_un.b_addr, 256); ! 833: ! 834: if (((struct disklabel *) ! 835: (bp->b_un.b_addr + LABELOFFSET))->d_magic == DISKMAGIC) { ! 836: du->dk_dd = ! 837: * (struct disklabel *) (bp->b_un.b_addr + LABELOFFSET); ! 838: } else { ! 839: printf("wd%d: bad disk label\n", du->dk_unit); ! 840: du->dk_state = OPENRAW; ! 841: } ! 842: ! 843: s = splbio(); /* not called from intr level ... */ ! 844: while ((stat = inb(wdc+wd_status)) & WDCS_BUSY); ! 845: ! 846: wdsetctlr(bp->b_dev, du); ! 847: ! 848: outb(wdc+wd_seccnt, 0); ! 849: splx(s); ! 850: ! 851: if (du->dk_state == RDLABEL) ! 852: du->dk_state = RDBADTBL; ! 853: /* ! 854: * The rest of the initialization can be done ! 855: * by normal means. ! 856: */ ! 857: return(1); ! 858: ! 859: default: ! 860: panic("wdcontrol"); ! 861: } ! 862: /* NOTREACHED */ ! 863: ! 864: badopen: ! 865: printf(": status %b error %b\n", ! 866: stat, WDCS_BITS, inb(wdc+wd_error), WDERR_BITS); ! 867: du->dk_state = OPENRAW; ! 868: return(1); ! 869: } ! 870: ! 871: wdsetctlr(dev, du) dev_t dev; struct disk *du; { ! 872: int stat; ! 873: ! 874: outb(wdc+wd_cyl_lo, du->dk_dd.d_ncylinders); ! 875: outb(wdc+wd_cyl_hi, (du->dk_dd.d_ncylinders)>>8); ! 876: outb(wdc+wd_sdh, WDSD_IBM | (wdunit(dev) << 4) + du->dk_dd.d_ntracks-1); ! 877: outb(wdc+wd_seccnt, du->dk_dd.d_nsectors); ! 878: outb(wdc+wd_command, 0x91); ! 879: ! 880: while ((stat = inb(wdc+wd_status)) & WDCS_BUSY) ; ! 881: stat = inb(wdc+wd_error); ! 882: return(stat); ! 883: } ! 884: ! 885: /* ARGSUSED */ ! 886: wdclose(dev, flags, fmt) ! 887: dev_t dev; ! 888: int flags, fmt; ! 889: { ! 890: register struct disk *du; ! 891: ! 892: du = &wddrives[wdunit(dev)]; ! 893: du->dk_open-- ; ! 894: /*if (du->dk_open == 0) du->dk_state = CLOSED ; does not work */ ! 895: } ! 896: ! 897: wdioctl(dev,cmd,addr,flag) ! 898: dev_t dev; ! 899: caddr_t addr; ! 900: { ! 901: int unit = wdunit(dev); ! 902: register struct disk *du; ! 903: int error = 0; ! 904: struct uio auio; ! 905: struct iovec aiov; ! 906: /*int wdformat();*/ ! 907: ! 908: du = &wddrives[unit]; ! 909: ! 910: switch (cmd) { ! 911: ! 912: case DIOCGDINFO: ! 913: *(struct disklabel *)addr = du->dk_dd; ! 914: break; ! 915: ! 916: case DIOCGPART: ! 917: ((struct partinfo *)addr)->disklab = &du->dk_dd; ! 918: ((struct partinfo *)addr)->part = ! 919: &du->dk_dd.d_partitions[wdpart(dev)]; ! 920: break; ! 921: ! 922: case DIOCSDINFO: ! 923: if ((flag & FWRITE) == 0) ! 924: error = EBADF; ! 925: else ! 926: error = setdisklabel(&du->dk_dd, ! 927: (struct disklabel *)addr, ! 928: 0 /*(dk->dk_state == OPENRAW) ? 0 : dk->dk_openpart*/); ! 929: /*if (error == 0 && dk->dk_state == OPENRAW && ! 930: vdreset_drive(vddinfo[unit])) ! 931: dk->dk_state = OPEN;*/ ! 932: wdsetctlr(dev, du); ! 933: break; ! 934: ! 935: case DIOCWLABEL: ! 936: if ((flag & FWRITE) == 0) ! 937: error = EBADF; ! 938: else ! 939: du->dk_wlabel = *(int *)addr; ! 940: break; ! 941: ! 942: case DIOCWDINFO: ! 943: if ((flag & FWRITE) == 0) ! 944: error = EBADF; ! 945: else if ((error = setdisklabel(&du->dk_dd, (struct disklabel *)addr, ! 946: 0/*(dk->dk_state == OPENRAW) ? 0 : dk->dk_openpart*/)) == 0) { ! 947: int wlab; ! 948: ! 949: /*if (error == 0 && dk->dk_state == OPENRAW && ! 950: vdreset_drive(vddinfo[unit])) ! 951: dk->dk_state = OPEN; */ ! 952: wdsetctlr(dev, du); ! 953: ! 954: /* simulate opening partition 0 so write succeeds */ ! 955: /* dk->dk_openpart |= (1 << 0); /* XXX */ ! 956: wlab = du->dk_wlabel; ! 957: du->dk_wlabel = 1; ! 958: error = writedisklabel(dev, wdstrategy, &du->dk_dd,wdpart(dev)); ! 959: /*dk->dk_openpart = dk->dk_copenpart | dk->dk_bopenpart;*/ ! 960: du->dk_wlabel = wlab; ! 961: } ! 962: break; ! 963: ! 964: #ifdef notyet ! 965: case DIOCGDINFOP: ! 966: *(struct disklabel **)addr = &(du->dk_dd); ! 967: break; ! 968: ! 969: case DIOCWFORMAT: ! 970: if ((flag & FWRITE) == 0) ! 971: error = EBADF; ! 972: else { ! 973: register struct format_op *fop; ! 974: ! 975: fop = (struct format_op *)addr; ! 976: aiov.iov_base = fop->df_buf; ! 977: aiov.iov_len = fop->df_count; ! 978: auio.uio_iov = &aiov; ! 979: auio.uio_iovcnt = 1; ! 980: auio.uio_resid = fop->df_count; ! 981: auio.uio_segflg = 0; ! 982: auio.uio_offset = ! 983: fop->df_startblk * du->dk_dd.d_secsize; ! 984: error = physio(wdformat, &rwdbuf[unit], dev, B_WRITE, ! 985: minphys, &auio); ! 986: fop->df_count -= auio.uio_resid; ! 987: fop->df_reg[0] = du->dk_status; ! 988: fop->df_reg[1] = du->dk_error; ! 989: } ! 990: break; ! 991: #endif ! 992: ! 993: default: ! 994: error = ENOTTY; ! 995: break; ! 996: } ! 997: return (error); ! 998: } ! 999: ! 1000: /*wdformat(bp) ! 1001: struct buf *bp; ! 1002: { ! 1003: ! 1004: bp->b_flags |= B_FORMAT; ! 1005: return (wdstrategy(bp)); ! 1006: }*/ ! 1007: ! 1008: /* ! 1009: * Routines to do raw IO for a unit. ! 1010: */ ! 1011: wdread(dev, uio) /* character read routine */ ! 1012: dev_t dev; ! 1013: struct uio *uio; ! 1014: { ! 1015: int unit = wdunit(dev) ; ! 1016: ! 1017: if (unit >= NWD) return(ENXIO); ! 1018: return(physio(wdstrategy, &rwdbuf[unit], dev, B_READ, minphys, uio)); ! 1019: } ! 1020: ! 1021: ! 1022: wdwrite(dev, uio) /* character write routine */ ! 1023: dev_t dev; ! 1024: struct uio *uio; ! 1025: { ! 1026: int unit = wdunit(dev) ; ! 1027: ! 1028: if (unit >= NWD) return(ENXIO); ! 1029: return(physio(wdstrategy, &rwdbuf[unit], dev, B_WRITE, minphys, uio)); ! 1030: } ! 1031: ! 1032: wdsize(dev) ! 1033: dev_t dev; ! 1034: { ! 1035: register unit = wdunit(dev); ! 1036: register part = wdpart(dev); ! 1037: register struct disk *du; ! 1038: register val ; ! 1039: ! 1040: if (unit >= NWD) return(-1); ! 1041: if (wddrives[unit].dk_state == 0) { ! 1042: val = wdopen (dev, 0); ! 1043: if (val < 0) ! 1044: return (-1); ! 1045: } ! 1046: du = &wddrives[unit]; ! 1047: return((int)((u_long)du->dk_dd.d_partitions[part].p_size * ! 1048: du->dk_dd.d_secsize / 512)); ! 1049: } ! 1050: ! 1051: extern char *vmmap; /* poor name! */ ! 1052: ! 1053: wddump(dev) /* dump core after a system crash */ ! 1054: dev_t dev; ! 1055: { ! 1056: register struct disk *du; /* disk unit to do the IO */ ! 1057: register struct bt_bad *bt_ptr; ! 1058: long num; /* number of sectors to write */ ! 1059: int unit, part; ! 1060: long cyloff, blknum, blkcnt; ! 1061: long cylin, head, sector, stat; ! 1062: long secpertrk, secpercyl, nblocks, i; ! 1063: char *addr; ! 1064: extern int Maxmem; ! 1065: static wddoingadump = 0 ; ! 1066: extern CMAP1; ! 1067: extern char CADDR1[]; ! 1068: ! 1069: ! 1070: #ifdef ARGO ! 1071: outb(0x461,0); /* disable failsafe timer */ ! 1072: #endif ! 1073: addr = (char *) 0; /* starting address */ ! 1074: /* size of memory to dump */ ! 1075: num = Maxmem; ! 1076: unit = wdunit(dev); /* eventually support floppies? */ ! 1077: part = wdpart(dev); /* file system */ ! 1078: /* check for acceptable drive number */ ! 1079: if (unit >= NWD) return(ENXIO); ! 1080: ! 1081: du = &wddrives[unit]; ! 1082: /* was it ever initialized ? */ ! 1083: if (du->dk_state < OPEN) return (ENXIO) ; ! 1084: ! 1085: /* Convert to disk sectors */ ! 1086: num = (u_long) num * NBPG / du->dk_dd.d_secsize; ! 1087: ! 1088: /* check if controller active */ ! 1089: /*if (wdtab.b_active) return(EFAULT); */ ! 1090: if (wddoingadump) return(EFAULT); ! 1091: ! 1092: secpertrk = du->dk_dd.d_nsectors; ! 1093: secpercyl = du->dk_dd.d_secpercyl; ! 1094: nblocks = du->dk_dd.d_partitions[part].p_size; ! 1095: cyloff = du->dk_dd.d_partitions[part].p_offset / secpercyl; ! 1096: ! 1097: /*pg("xunit %x, nblocks %d, dumplo %d num %d\n", part,nblocks,dumplo,num);*/ ! 1098: /* check transfer bounds against partition size */ ! 1099: if ((dumplo < 0) || ((dumplo + num) > nblocks)) ! 1100: return(EINVAL); ! 1101: ! 1102: /*wdtab.b_active = 1; /* mark controller active for if we ! 1103: panic during the dump */ ! 1104: wddoingadump = 1 ; i = 100000 ; ! 1105: while ((inb(wdc+wd_status) & WDCS_BUSY) && (i-- > 0)) ; ! 1106: outb(wdc+wd_sdh, WDSD_IBM | (unit << 4)); ! 1107: outb(wdc+wd_command, WDCC_RESTORE | WD_STEP); ! 1108: while (inb(wdc+wd_status) & WDCS_BUSY) ; ! 1109: ! 1110: /* some compaq controllers require this ... */ ! 1111: wdsetctlr(dev, du); ! 1112: ! 1113: blknum = dumplo; ! 1114: while (num > 0) { ! 1115: #ifdef notdef ! 1116: if (blkcnt > MAXTRANSFER) blkcnt = MAXTRANSFER; ! 1117: if ((blknum + blkcnt - 1) / secpercyl != blknum / secpercyl) ! 1118: blkcnt = secpercyl - (blknum % secpercyl); ! 1119: /* keep transfer within current cylinder */ ! 1120: #endif ! 1121: pmap_enter(pmap_kernel(), vmmap, addr, VM_PROT_READ, TRUE); ! 1122: ! 1123: /* compute disk address */ ! 1124: cylin = blknum / secpercyl; ! 1125: head = (blknum % secpercyl) / secpertrk; ! 1126: sector = blknum % secpertrk; ! 1127: cylin += cyloff; ! 1128: ! 1129: #ifdef notyet ! 1130: /* ! 1131: * See if the current block is in the bad block list. ! 1132: * (If we have one.) ! 1133: */ ! 1134: for (bt_ptr = dkbad[unit].bt_bad; ! 1135: bt_ptr->bt_cyl != -1; bt_ptr++) { ! 1136: if (bt_ptr->bt_cyl > cylin) ! 1137: /* Sorted list, and we passed our cylinder. ! 1138: quit. */ ! 1139: break; ! 1140: if (bt_ptr->bt_cyl == cylin && ! 1141: bt_ptr->bt_trksec == (head << 8) + sector) { ! 1142: /* ! 1143: * Found bad block. Calculate new block addr. ! 1144: * This starts at the end of the disk (skip the ! 1145: * last track which is used for the bad block list), ! 1146: * and works backwards to the front of the disk. ! 1147: */ ! 1148: blknum = (du->dk_dd.d_secperunit) ! 1149: - du->dk_dd.d_nsectors ! 1150: - (bt_ptr - dkbad[unit].bt_bad) - 1; ! 1151: cylin = blknum / secpercyl; ! 1152: head = (blknum % secpercyl) / secpertrk; ! 1153: sector = blknum % secpertrk; ! 1154: break; ! 1155: } ! 1156: ! 1157: #endif ! 1158: sector++; /* origin 1 */ ! 1159: ! 1160: /* select drive. */ ! 1161: outb(wdc+wd_sdh, WDSD_IBM | (unit<<4) | (head & 0xf)); ! 1162: while ((inb(wdc+wd_status) & WDCS_READY) == 0) ; ! 1163: ! 1164: /* transfer some blocks */ ! 1165: outb(wdc+wd_sector, sector); ! 1166: outb(wdc+wd_seccnt,1); ! 1167: outb(wdc+wd_cyl_lo, cylin); ! 1168: outb(wdc+wd_cyl_hi, cylin >> 8); ! 1169: #ifdef notdef ! 1170: /* lets just talk about this first...*/ ! 1171: pg ("sdh 0%o sector %d cyl %d addr 0x%x", ! 1172: inb(wdc+wd_sdh), inb(wdc+wd_sector), ! 1173: inb(wdc+wd_cyl_hi)*256+inb(wdc+wd_cyl_lo), addr) ; ! 1174: #endif ! 1175: #ifdef ODYSSEUS ! 1176: if(cylin < 46 || cylin > 91)pg("oops"); ! 1177: #endif ! 1178: #ifdef PRIAM ! 1179: if(cylin < 40 || cylin > 79)pg("oops"); ! 1180: #endif ! 1181: outb(wdc+wd_command, WDCC_WRITE); ! 1182: ! 1183: /* Ready to send data? */ ! 1184: while ((inb(wdc+wd_status) & WDCS_DRQ) == 0) ; ! 1185: if (inb(wdc+wd_status) & WDCS_ERR) return(EIO) ; ! 1186: ! 1187: outsw (wdc+wd_data, CADDR1+((int)addr&(NBPG-1)), 256); ! 1188: (int) addr += 512; ! 1189: ! 1190: if (inb(wdc+wd_status) & WDCS_ERR) return(EIO) ; ! 1191: /* Check data request (should be done). */ ! 1192: if (inb(wdc+wd_status) & WDCS_DRQ) return(EIO) ; ! 1193: ! 1194: /* wait for completion */ ! 1195: for ( i = 1000000 ; inb(wdc+wd_status) & WDCS_BUSY ; i--) { ! 1196: if (i < 0) return (EIO) ; ! 1197: } ! 1198: /* error check the xfer */ ! 1199: if (inb(wdc+wd_status) & WDCS_ERR) return(EIO) ; ! 1200: /* update block count */ ! 1201: num--; ! 1202: blknum++ ; ! 1203: if (num % 100 == 0) printf(".") ; ! 1204: } ! 1205: return(0); ! 1206: } ! 1207: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.