/* * Copyright (c) 1994 Charles Hannum. * Copyright (c) 1990 The Regents of the University of California. * All rights reserved. * * This code is derived from software contributed to Berkeley by * William Jolitz. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * from: @(#)wd.c 7.2 (Berkeley) 5/9/91 * $Id: wd.c,v 1.67 1994/03/10 21:52:10 mycroft Exp $ */ #define INSTRUMENT /* instrumentation stuff by Brad Parker */ #include "wd.h" #if NWDC > 0 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef INSTRUMENT #include #endif #include #include #include #include #include #include #include #include #define WDCNDELAY 100000 /* delay = 100us; so 10s for a controller state change */ #define WDCDELAY 100 #define RECOVERYTIME hz/2 /* time to recover from an error */ #if 0 /* If you enable this, it will report any delays more than 100us * N long. */ #define WDCNDELAY_DEBUG 50 #endif #define WDIORETRIES 5 /* number of retries before giving up */ #define WDUNIT(dev) ((minor(dev) & 0xf8) >> 3) #define WDPART(dev) ((minor(dev) & 0x07) ) #define makewddev(maj, unit, part) (makedev(maj, ((unit << 3) + part))) #define WDRAW 3 /* 'd' partition isn't a partition! */ #define b_cylin b_resid /* cylinder number for doing IO to */ /* shares an entry in the buf struct */ /* * Drive states. Used to initialize drive. */ #define CLOSED 0 /* disk is closed */ #define WANTOPEN 1 /* open requested, not started */ #define RECAL 2 /* doing restore */ #define OPEN 3 /* done with open */ /* * Drive status. */ struct wd_softc { struct device sc_dev; long sc_bcount; /* byte count left */ long sc_mbcount; /* total byte count left */ short sc_skip; /* blocks already transferred */ short sc_mskip; /* blocks already transferred for multi */ char sc_unit; /* physical unit number */ char sc_lunit; /* logical unit number */ char sc_state; /* control state */ u_long sc_copenpart; /* character units open on this drive */ u_long sc_bopenpart; /* block units open on this drive */ u_long sc_openpart; /* all units open on this drive */ short sc_wlabel; /* label writable? */ short sc_flags; /* drive characteistics found */ #define WDF_SINGLE 0x00004 /* sector at a time mode */ #define WDF_ERROR 0x00008 /* processing a disk error */ #define WDF_BSDLABEL 0x00010 /* has a BSD disk label */ #define WDF_BADSECT 0x00020 /* has a bad144 badsector table */ #define WDF_WRITEPROT 0x00040 /* manual unit write protect */ struct buf sc_q; struct wdparams sc_params; /* ESDI/IDE drive/controller parameters */ struct disklabel sc_label; /* device configuration data */ struct cpu_disklabel sc_cpulabel; long sc_badsect[127]; /* 126 plus trailing -1 marker */ } *wd_softc[NWD]; struct wdc_softc { struct device sc_dev; struct buf sc_q; u_char sc_status; /* copy of status register */ u_char sc_error; /* copy of error register */ u_short sc_iobase; /* i/o port base */ int sc_timeout; /* timeout counter */ } wdc_softc[NWDC]; int wdcprobe(), wdcattach(), wdprobe(), wdattach(), wdintr(); struct isa_driver wdcdriver = { wdcprobe, wdcattach, "wdc", }; struct isa_driver wddriver = { wdprobe, wdattach, "wd", }; void wdfinish __P((struct wd_softc *, struct buf *)); static void wdstart __P((struct wd_softc *)); static void wdcstart __P((struct wdc_softc *)); static int wdcommand __P((struct wd_softc *, int, int, int, int, int)); static int wdcontrol __P((struct buf *)); static int wdsetctlr __P((struct wd_softc *)); static int wdgetctlr __P((struct wd_softc *)); static void bad144intern __P((struct wd_softc *)); static int wdcreset __P((struct wdc_softc *)); static void wdcrestart __P((struct wdc_softc *)); static void wdcunwedge __P((struct wdc_softc *)); static void wdctimeout __P((struct wdc_softc *)); void wddisksort __P((struct buf *, struct buf *)); static void wderror __P((void *, struct buf *, char *)); int wdcwait __P((struct wdc_softc *, int)); #define wait_for_drq(d) wdcwait(d, WDCS_DRQ) #define wait_for_ready(d) wdcwait(d, WDCS_READY | WDCS_SEEKCMPLT) #define wait_for_unbusy(d) wdcwait(d, 0) /* * Probe for controller. */ int wdcprobe(dev) struct isa_device *dev; { struct wd_softc *wd; struct wdc_softc *wdc; u_short iobase; if (dev->id_unit >= NWDC) return 0; wdc = &wdc_softc[dev->id_unit]; /* XXX HACK */ sprintf(wdc->sc_dev.dv_xname, "%s%d", wdcdriver.name, dev->id_unit); wdc->sc_dev.dv_unit = dev->id_unit; wdc->sc_iobase = iobase = dev->id_iobase; /* Check if we have registers that work. */ outb(iobase+wd_error, 0x5a); /* Error register not writable. */ outb(iobase+wd_cyl_lo, 0xa5); /* But all of cyllo are implemented. */ if (inb(iobase+wd_error) == 0x5a || inb(iobase+wd_cyl_lo) != 0xa5) return 0; if (wdcreset(wdc) != 0) { delay(500000); if (wdcreset(wdc) != 0) return 0; } /* * XXX wdcommand() accepts a wd_softc, so we have to make it one. */ wd = (void *)malloc(sizeof(struct wd_softc), M_TEMP, M_NOWAIT); bzero(wd, sizeof(struct wd_softc)); wd->sc_unit = 0; wd->sc_lunit = 0; wd->sc_dev.dv_parent = (void *)wdc; /* Execute a controller only command. */ if (wdcommand(wd, 0, 0, 0, 0, WDCC_DIAGNOSE) != 0 || wait_for_unbusy(wdc) != 0) goto lose; wdctimeout(wdc); free(wd, M_TEMP); return 8; lose: free(wd, M_TEMP); return 0; } int wdcattach(dev) struct isa_device *dev; { } int wdprobe(dev) struct isa_device *dev; { return 1; } /* * Called for the controller too. Attach each drive if possible. */ int wdattach(dev) struct isa_device *dev; { int lunit; struct wd_softc *wd; struct wdc_softc *wdc; int i, blank; if (dev->id_masunit >= NWDC) return 0; lunit = dev->id_unit; if (lunit == -1) { printf("%s: cannot support unit ?\n", wdc->sc_dev.dv_xname); return 0; } if (lunit >= NWD) return 0; wdc = &wdc_softc[dev->id_masunit]; wd_softc[lunit] = wd = (void *)malloc(sizeof(struct wd_softc), M_TEMP, M_NOWAIT); bzero(wd, sizeof(struct wd_softc)); wd->sc_unit = dev->id_physid; wd->sc_lunit = lunit; /* XXX HACK */ sprintf(wd->sc_dev.dv_xname, "%s%d", wddriver.name, dev->id_unit); wd->sc_dev.dv_unit = dev->id_unit; wd->sc_dev.dv_parent = (void *)wdc; if (wdgetctlr(wd) != 0) return 0; printf("%s at %s targ %d: ", wd->sc_dev.dv_xname, wdc->sc_dev.dv_xname, dev->id_physid); if (wd->sc_params.wdp_heads == 0) printf("(unknown size) <"); else printf("%dMB %d cyl, %d head, %d sec <", wd->sc_label.d_ncylinders * wd->sc_label.d_secpercyl / (1048576 / DEV_BSIZE), wd->sc_label.d_ncylinders, wd->sc_label.d_ntracks, wd->sc_label.d_nsectors); for (i = blank = 0; i < sizeof(wd->sc_params.wdp_model); i++) { char c = wd->sc_params.wdp_model[i]; if (c == '\0') break; if (c != ' ') { if (blank) printf(" %c", c); else printf("%c", c); blank = 0; } else blank = 1; } printf(">\n"); return 1; } /* * Read/write routine for a buffer. Finds the proper unit, range checks * arguments, and schedules the transfer. Does not wait for the transfer to * complete. Multi-page transfers are supported. All I/O requests must be a * multiple of a sector in length. */ void wdstrategy(bp) struct buf *bp; { struct buf *dp; struct wd_softc *wd; /* disk unit to do the IO */ struct wdc_softc *wdc; int lunit = WDUNIT(bp->b_dev); int s; /* Valid unit, controller, and request? */ if (lunit >= NWD || bp->b_blkno < 0 || howmany(bp->b_bcount, DEV_BSIZE) >= (1 << NBBY) || (wd = wd_softc[lunit]) == 0) { bp->b_error = EINVAL; bp->b_flags |= B_ERROR; goto done; } /* "Soft" write protect check. */ if ((wd->sc_flags & WDF_WRITEPROT) && (bp->b_flags & B_READ) == 0) { bp->b_error = EROFS; bp->b_flags |= B_ERROR; goto done; } /* Have partitions and want to use them? */ if ((wd->sc_flags & WDF_BSDLABEL) != 0 && WDPART(bp->b_dev) != WDRAW) { /* * Do bounds checking, adjust transfer. if error, process. * If end of partition, just return. */ if (bounds_check_with_label(bp, &wd->sc_label, wd->sc_wlabel) <= 0) goto done; /* Otherwise, process transfer request. */ } /* Don't bother doing rotational optimization. */ bp->b_cylin = 0; /* Queue transfer on drive, activate drive and controller if idle. */ dp = &wd->sc_q; s = splbio(); wddisksort(dp, bp); if (dp->b_active == 0) wdstart(wd); /* Start drive. */ wdc = (void *)wd->sc_dev.dv_parent; if (wdc->sc_q.b_active == 0) wdcstart(wdc); /* Start controller. */ splx(s); return; done: /* Toss transfer; we're done early. */ biodone(bp); } /* * Need to skip over multitransfer bufs. */ void wddisksort(dp, bp) struct buf *dp, *bp; { struct buf *ap; while ((ap = dp->b_actf) && ap->b_flags & B_XXX) dp = ap; disksort(dp, bp); } /* * Routine to queue a command to the controller. The unit's request is linked * into the active list for the controller. If the controller is idle, the * transfer is started. */ static void wdstart(wd) struct wd_softc *wd; { struct buf *dp; struct wdc_softc *wdc; dp = &wd->sc_q; /* Unit already active? */ if (dp->b_active) return; /* Anything to start? */ if (dp->b_actf == NULL) return; /* Link onto controller queue. */ dp->b_forw = NULL; wdc = (void *)wd->sc_dev.dv_parent; if (wdc->sc_q.b_forw == NULL) wdc->sc_q.b_forw = dp; else wdc->sc_q.b_actl->b_forw = dp; wdc->sc_q.b_actl = dp; /* Mark the drive unit as busy. */ dp->b_active = 1; } void wdfinish(wd, bp) struct wd_softc *wd; struct buf *bp; { struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent; #ifdef INSTRUMENT dk_busy &= ~(1 << wd->sc_unit); #endif wd->sc_flags &= ~(WDF_SINGLE | WDF_ERROR); wdc->sc_q.b_errcnt = 0; /* * If this is the only buf or the last buf in the transfer (taking into * account any residual, in case we erred)... */ wd->sc_mbcount -= wd->sc_bcount; if (wd->sc_mbcount == 0) { /* * ...then move this drive to the end of the queue to give * others a `fair' chance. */ wdc->sc_q.b_forw = wd->sc_q.b_forw; wd->sc_mskip = 0; wd->sc_q.b_active = 0; if (wd->sc_q.b_actf) wdstart(wd); } bp->b_resid = wd->sc_bcount; bp->b_flags &= ~B_XXX; wd->sc_skip = 0; wd->sc_q.b_actf = bp->b_actf; biodone(bp); } /* * Controller startup routine. This does the calculation, and starts a * single-sector read or write operation. Called to start a transfer, or from * the interrupt routine to continue a multi-sector transfer. * RESTRICTIONS: * 1. The transfer length must be an exact multiple of the sector size. */ static void wdcstart(wdc) struct wdc_softc *wdc; { struct wd_softc *wd; /* disk unit for IO */ struct buf *bp; struct disklabel *lp; struct buf *dp; long blknum, cylin, head, sector; long secpertrk, secpercyl; int xfrblknum; int lunit; loop: /* Is there a drive for the controller to do a transfer with? */ dp = wdc->sc_q.b_forw; if (dp == NULL) { wdc->sc_q.b_active = 0; return; } /* Is there a transfer to this drive? If not, deactivate drive. */ bp = dp->b_actf; if (bp == NULL) { dp->b_active = 0; wdc->sc_q.b_forw = dp->b_forw; goto loop; } /* Obtain controller and drive information */ lunit = WDUNIT(bp->b_dev); wd = wd_softc[lunit]; if (wdc->sc_q.b_errcnt >= WDIORETRIES) { wderror(wd, bp, "hard error"); bp->b_error = EIO; bp->b_flags |= B_ERROR; wdfinish(wd, bp); goto loop; } /* Clear any pending timeout, just in case. */ wdc->sc_timeout = 0; /* If not really a transfer, do control operations specially. */ if (wd->sc_state < OPEN) { (void) wdcontrol(bp); return; } /* * WDF_ERROR is set by wdcunwedge() and wdintr() when an error is * encountered *only* in multi-sector mode. We switch to single-sector * mode and retry the operation from the start. */ if (wd->sc_flags & WDF_ERROR) { /* Switch to single-sector mode. */ wd->sc_flags &= ~WDF_ERROR; wd->sc_flags |= WDF_SINGLE; wd->sc_skip = 0; wd->sc_mskip = 0; } /* Calculate transfer details. */ blknum = bp->b_blkno + wd->sc_skip; #ifdef WDDEBUG if (wd->sc_skip == 0) printf("\nwdcstart %d: %s %d@%d; map ", lunit, (bp->b_flags & B_READ) ? "read" : "write", bp->b_bcount, blknum); else printf(" %d)%x", wd->sc_skip, inb(wd->sc_iobase+wd_altsts)); #endif if (wd->sc_skip == 0) wd->sc_bcount = bp->b_bcount; if (wd->sc_mskip == 0) { struct buf *oldbp, *nextbp; oldbp = bp; nextbp = bp->b_actf; wd->sc_mbcount = wd->sc_bcount; oldbp->b_flags |= B_XXX; while (nextbp && (oldbp->b_flags & WDF_SINGLE) == 0 && oldbp->b_dev == nextbp->b_dev && nextbp->b_blkno == (oldbp->b_blkno + (oldbp->b_bcount / DEV_BSIZE)) && (oldbp->b_flags & B_READ) == (nextbp->b_flags & B_READ)) { if ((wd->sc_mbcount + nextbp->b_bcount) / DEV_BSIZE >= 240) break; wd->sc_mbcount += nextbp->b_bcount; nextbp->b_flags |= B_XXX; oldbp = nextbp; nextbp = nextbp->b_actf; } } lp = &wd->sc_label; secpertrk = lp->d_nsectors; secpercyl = lp->d_secpercyl; if ((wd->sc_flags & WDF_BSDLABEL) != 0 && WDPART(bp->b_dev) != WDRAW) blknum += lp->d_partitions[WDPART(bp->b_dev)].p_offset; cylin = blknum / secpercyl; head = (blknum % secpercyl) / secpertrk; sector = blknum % secpertrk; /* * Check for bad sectors if we have them, and not formatting. Only do * this in single-sector mode, or when starting a multiple-sector * transfer. */ if ((wd->sc_flags & WDF_BADSECT) && #ifdef B_FORMAT (bp->b_flags & B_FORMAT) == 0 && #endif (wd->sc_mskip == 0 || (wd->sc_flags & WDF_SINGLE))) { long blkchk, blkend, blknew; int i; blkend = blknum + howmany(wd->sc_mbcount, DEV_BSIZE) - 1; for (i = 0; (blkchk = wd->sc_badsect[i]) != -1; i++) { if (blkchk > blkend) break; /* Transfer is completely OK; done. */ if (blkchk == blknum) { blknew = lp->d_secperunit - lp->d_nsectors - i - 1; cylin = blknew / secpercyl; head = (blknew % secpercyl) / secpertrk; sector = blknew % secpertrk; wd->sc_flags |= WDF_SINGLE; /* Found and replaced first blk of transfer; done. */ break; } else if (blkchk > blknum) { wd->sc_flags |= WDF_SINGLE; break; /* Bad block inside transfer; done. */ } } } if (wd->sc_flags & WDF_SINGLE) { wd->sc_mbcount = wd->sc_bcount; wd->sc_mskip = wd->sc_skip; } #ifdef WDDEBUG printf("c%d h%d s%d ", cylin, head, sector); #endif sector++; /* Sectors begin with 1, not 0. */ wdc->sc_q.b_active = 1; /* Mark controller active. */ #ifdef INSTRUMENT if (wd->sc_skip == 0) { dk_busy |= 1 << wd->sc_lunit; dk_wds[wd->sc_lunit] += bp->b_bcount >> 6; } #endif /* If starting a multisector transfer, or doing single transfers. */ if (wd->sc_mskip == 0 || (wd->sc_flags & WDF_SINGLE)) { int command, count; #ifdef INSTRUMENT ++dk_seek[wd->sc_lunit]; ++dk_xfer[wd->sc_lunit]; #endif #ifdef B_FORMAT if (bp->b_flags & B_FORMAT) { sector = lp->d_gap3; count = lp->d_nsectors; command = WDCC_FORMAT; } else { if (wd->sc_flags & WDF_SINGLE) count = 1; else count = howmany(wd->sc_mbcount, DEV_BSIZE); command = (bp->b_flags & B_READ) ? WDCC_READ : WDCC_WRITE; } #else if (wd->sc_flags & WDF_SINGLE) count = 1; else count = howmany(wd->sc_mbcount, DEV_BSIZE); command = (bp->b_flags & B_READ) ? WDCC_READ : WDCC_WRITE; #endif /* Initiate command! */ if (wdcommand(wd, cylin, head, sector, count, command) != 0) { wderror(wd, NULL, "wdcstart: timeout waiting for unbusy"); wdcunwedge(wdc); return; } #ifdef WDDEBUG printf("sector %d cylin %d head %d addr %x sts %x\n", sector, cylin, head, bp->b_un.b_addr, inb(wd->sc_iobase+wd_altsts)); #endif } wdc->sc_timeout = 4; /* If this is a read operation, just go away until it's done. */ if (bp->b_flags & B_READ) return; if (wait_for_drq(wdc) < 0) { wderror(wd, NULL, "wdcstart: timeout waiting for drq"); wdcunwedge(wdc); return; } /* Then send it! */ outsw(wdc->sc_iobase+wd_data, bp->b_un.b_addr + wd->sc_skip * DEV_BSIZE, DEV_BSIZE / sizeof(short)); } /* * Interrupt routine for the controller. Acknowledge the interrupt, check for * errors on the current operation, mark it done if necessary, and start the * next request. Also check for a partially done transfer, and continue with * the next chunk if so. */ int wdintr(ctrlr) int ctrlr; { struct wdc_softc *wdc = &wdc_softc[ctrlr]; struct wd_softc *wd; struct buf *bp; /* Clear the pending interrupt. */ (void) inb(wdc->sc_iobase+wd_status); if (!wdc->sc_q.b_active) { printf("%s: extra interrupt\n", wdc->sc_dev.dv_xname); return 0; } bp = wdc->sc_q.b_forw->b_actf; wd = wd_softc[WDUNIT(bp->b_dev)]; wdc->sc_timeout = 0; #ifdef WDDEBUG printf("I%d ", ctrlr); #endif if (wait_for_unbusy(wdc) < 0) { wderror(wd, NULL, "wdintr: timeout waiting for unbusy"); wdc->sc_status |= WDCS_ERR; /* XXX */ } /* Is it not a transfer, but a control operation? */ if (wd->sc_state < OPEN) { wdc->sc_q.b_active = 0; if (wdcontrol(bp)) wdcstart(wdc); return 1; } /* Have we an error? */ if (wdc->sc_status & (WDCS_ERR | WDCS_ECCCOR)) { lose: #ifdef WDDEBUG wderror(wd, NULL, "wdintr"); #endif if ((wd->sc_flags & WDF_SINGLE) == 0) { wd->sc_flags |= WDF_ERROR; goto restart; } #ifdef B_FORMAT if (bp->b_flags & B_FORMAT) { bp->b_error = EIO; bp->b_flags |= B_ERROR; goto done; } #endif /* Error or error correction? */ if (wdc->sc_status & WDCS_ERR) { if (++wdc->sc_q.b_errcnt >= WDIORETRIES) { wderror(wd, bp, "hard error"); bp->b_error = EIO; bp->b_flags |= B_ERROR; /* Flag the error. */ goto done; } else goto restart; } else wderror(wd, bp, "soft ecc"); } /* If this was a read, fetch the data. */ if (bp->b_flags & B_READ) { /* Ready to receive data? */ if (wait_for_drq(wdc) != 0) { wderror(wd, NULL, "wdintr: read error detected late"); wdcunwedge(wdc); return 1; } /* Suck in data. */ insw(wdc->sc_iobase+wd_data, bp->b_un.b_addr + wd->sc_skip * DEV_BSIZE, DEV_BSIZE / sizeof(short)); } /* If we encountered any abnormalities, flag it as a soft error. */ if (wdc->sc_q.b_errcnt) { wderror(wd, bp, "soft error"); wdc->sc_q.b_errcnt = 0; } /* Ready for the next block, if any. */ wd->sc_skip++; wd->sc_mskip++; wd->sc_bcount -= DEV_BSIZE; wd->sc_mbcount -= DEV_BSIZE; /* See if more to transfer. */ if (wd->sc_bcount > 0) goto restart; done: /* Done with this transfer, with or without error. */ wdfinish(wd, bp); restart: /* Start the next transfer, if any. */ wdc->sc_q.b_active = 0; wdcstart(wdc); return 1; } /* * Initialize a drive. */ int wdopen(dev, flag, fmt, p) dev_t dev; int flag; int fmt; struct proc *p; { int lunit; struct wd_softc *wd; int part = WDPART(dev), mask = 1 << part; struct partition *pp; char *msg; lunit = WDUNIT(dev); if (lunit >= NWD) return ENXIO; wd = wd_softc[lunit]; if (wd == 0) return ENXIO; if ((wd->sc_flags & WDF_BSDLABEL) == 0) { wd->sc_flags |= WDF_WRITEPROT; wd->sc_q.b_actf = NULL; /* * Use the default sizes until we've read the label, or longer * if there isn't one there. */ bzero(&wd->sc_label, sizeof(wd->sc_label)); wd->sc_label.d_type = DTYPE_ST506; wd->sc_label.d_ncylinders = 1024; wd->sc_label.d_secsize = DEV_BSIZE; wd->sc_label.d_ntracks = 8; wd->sc_label.d_nsectors = 17; wd->sc_label.d_secpercyl = 17*8; wd->sc_label.d_secperunit = 17*8*1024; wd->sc_state = WANTOPEN; /* Read label using "raw" partition. */ #ifdef notdef /* wdsetctlr(wd); */ /* Maybe do this TIH */ msg = readdisklabel(makewddev(major(dev), WDUNIT(dev), WDRAW), wdstrategy, &wd->sc_label, &wd->sc_cpulabel); wdsetctlr(wd); #endif if (msg = readdisklabel(makewddev(major(dev), WDUNIT(dev), WDRAW), wdstrategy, &wd->sc_label, &wd->sc_cpulabel)) { log(LOG_WARNING, "%s: cannot find label (%s)\n", wd->sc_dev.dv_xname, msg); if (part != WDRAW) return EINVAL; /* XXX needs translation */ } else { wdsetctlr(wd); wd->sc_flags |= WDF_BSDLABEL; wd->sc_flags &= ~WDF_WRITEPROT; if (wd->sc_label.d_flags & D_BADSECT) wd->sc_flags |= WDF_BADSECT; } } if (wd->sc_flags & WDF_BADSECT) bad144intern(wd); /* * Warn if a partition is opened that overlaps another partition which * is open unless one is the "raw" partition (whole disk). */ if ((wd->sc_openpart & mask) == 0 && part != WDRAW) { int start, end; pp = &wd->sc_label.d_partitions[part]; start = pp->p_offset; end = pp->p_offset + pp->p_size; for (pp = wd->sc_label.d_partitions; pp < &wd->sc_label.d_partitions[wd->sc_label.d_npartitions]; pp++) { if (pp->p_offset + pp->p_size <= start || pp->p_offset >= end) continue; if (pp - wd->sc_label.d_partitions == WDRAW) continue; if (wd->sc_openpart & (1 << (pp - wd->sc_label.d_partitions))) log(LOG_WARNING, "%s%c: overlaps open partition (%c)\n", wd->sc_dev.dv_xname, part + 'a', pp - wd->sc_label.d_partitions + 'a'); } } if (part >= wd->sc_label.d_npartitions && part != WDRAW) return ENXIO; /* Insure only one open at a time. */ switch (fmt) { case S_IFCHR: wd->sc_copenpart |= mask; break; case S_IFBLK: wd->sc_bopenpart |= mask; break; } wd->sc_openpart = wd->sc_copenpart | wd->sc_bopenpart; return 0; } /* * Implement operations other than read/write. * Called from wdcstart or wdintr during opens and formats. * Uses finite-state-machine to track progress of operation in progress. * Returns 0 if operation still in progress, 1 if completed. */ static int wdcontrol(bp) struct buf *bp; { struct wd_softc *wd = wd_softc[WDUNIT(bp->b_dev)]; struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent; switch (wd->sc_state) { case WANTOPEN: /* Set SDH, step rate, do restore. */ tryagainrecal: wdgetctlr(wd); /* XXX Is this necessary? */ wdc->sc_q.b_active = 1; if (wdcommand(wd, 0, 0, 0, 0, WDCC_RESTORE | WD_STEP) != 0) { wderror(wd, NULL, "wdcontrol: wdcommand failed"); wdcunwedge(wdc); return 0; } wd->sc_state = RECAL; return 0; case RECAL: if (wdc->sc_status & WDCS_ERR || wdsetctlr(wd) != 0) { wderror(wd, NULL, "wdcontrol: recal failed"); wdcunwedge(wdc); return 0; } wdc->sc_q.b_errcnt = 0; wd->sc_state = OPEN; /* * The rest of the initialization can be done by normal means. */ return 1; } #ifdef DIAGNOSTIC panic("wdcontrol: impossible"); #endif } /* * Send a command and wait uninterruptibly until controller is finished. * Return -1 if controller busy for too long, otherwise return non-zero if * error. Intended for brief controller commands at critical points. * Assumes interrupts are blocked. */ static int wdcommand(wd, cylin, head, sector, count, cmd) struct wd_softc *wd; int cylin, head, sector, count; int cmd; { struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent; int stat; u_short iobase; /* Controller ready for command? */ if (wait_for_unbusy(wdc) < 0) return -1; /* Select drive. */ iobase = wdc->sc_iobase; outb(iobase+wd_sdh, WDSD_IBM | (wd->sc_unit << 4) | head); if (cmd == WDCC_DIAGNOSE || cmd == WDCC_IDC) stat = wait_for_unbusy(wdc); else stat = wdcwait(wdc, WDCS_READY); if (stat < 0) return -1; /* Load parameters. */ outb(iobase+wd_precomp, wd->sc_label.d_precompcyl / 4); outb(iobase+wd_cyl_lo, cylin); outb(iobase+wd_cyl_hi, cylin >> 8); outb(iobase+wd_sector, sector); outb(iobase+wd_seccnt, count); /* Send command, await results. */ outb(iobase+wd_command, cmd); return 0; } /* * Issue IDC to drive to tell it just what geometry it is to be. */ static int wdsetctlr(wd) struct wd_softc *wd; { struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent; #ifdef WDDEBUG printf("wd(%d,%d) C%dH%dS%d\n", wd->sc_ctrlr, wd->sc_unit, wd->sc_label.d_ncylinders, wd->sc_label.d_ntracks, wd->sc_label.d_nsectors); #endif if (wdcommand(wd, wd->sc_label.d_ncylinders, wd->sc_label.d_ntracks - 1, 0, wd->sc_label.d_nsectors, WDCC_IDC) != 0 || wdcwait(wdc, WDCS_READY) != 0) { wderror(wd, NULL, "wdsetctlr: failed"); return -1; } return 0; } /* * Issue READP to drive to ask it what it is. */ static int wdgetctlr(wd) struct wd_softc *wd; { struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent; int i; char tb[DEV_BSIZE]; struct wdparams *wp; if (wdcommand(wd, 0, 0, 0, 0, WDCC_READP) != 0 || wait_for_drq(wdc) != 0) { /* * If WDCC_READP fails then we might have an old drive so we * try a seek to 0; if that passes then the drive is there but * it's OLD AND KRUSTY. */ if (wdcommand(wd, 0, 0, 0, 0, WDCC_RESTORE | WD_STEP) != 0 || wait_for_ready(wdc) != 0) return -1; strncpy(wd->sc_label.d_typename, "ST506", sizeof wd->sc_label.d_typename); strncpy(wd->sc_params.wdp_model, "Unknown Type", sizeof wd->sc_params.wdp_model); wd->sc_label.d_type = DTYPE_ST506; } else { /* Obtain parameters. */ wp = &wd->sc_params; insw(wdc->sc_iobase+wd_data, tb, sizeof(tb) / sizeof(short)); bcopy(tb, wp, sizeof(struct wdparams)); /* Shuffle string byte order. */ for (i = 0; i < sizeof(wp->wdp_model); i += 2) { u_short *p; p = (u_short *)(wp->wdp_model + i); *p = ntohs(*p); } strncpy(wd->sc_label.d_typename, "ESDI/IDE", sizeof wd->sc_label.d_typename); wd->sc_label.d_type = DTYPE_ESDI; bcopy(wp->wdp_model+20, wd->sc_label.d_packname, 14-1); /* Update disklabel given drive information. */ wd->sc_label.d_ncylinders = wp->wdp_fixedcyl + wp->wdp_removcyl /*+- 1*/; wd->sc_label.d_ntracks = wp->wdp_heads; wd->sc_label.d_nsectors = wp->wdp_sectors; wd->sc_label.d_secpercyl = wd->sc_label.d_ntracks * wd->sc_label.d_nsectors; wd->sc_label.d_partitions[1].p_size = wd->sc_label.d_secpercyl * wp->wdp_sectors; wd->sc_label.d_partitions[1].p_offset = 0; } #if 0 printf("gc %x cyl %d trk %d sec %d type %d sz %d model %s\n", wp->wdp_config, wp->wdp_fixedcyl + wp->wdp_removcyl, wp->wdp_heads, wp->wdp_sectors, wp->wdp_cntype, wp->wdp_cnsbsz, wp->wdp_model); #endif wd->sc_label.d_subtype |= DSTYPE_GEOMETRY; /* XXX sometimes possibly needed */ (void) inb(wdc->sc_iobase+wd_status); return 0; } int wdclose(dev, flag, fmt) dev_t dev; int flag; int fmt; { struct wd_softc *wd = wd_softc[WDUNIT(dev)]; int part = WDPART(dev), mask = 1 << part; switch (fmt) { case S_IFCHR: wd->sc_copenpart &= ~mask; break; case S_IFBLK: wd->sc_bopenpart &= ~mask; break; } wd->sc_openpart = wd->sc_copenpart | wd->sc_bopenpart; return 0; } int wdioctl(dev, cmd, addr, flag, p) dev_t dev; int cmd; caddr_t addr; int flag; struct proc *p; { int lunit = WDUNIT(dev); struct wd_softc *wd = wd_softc[lunit]; int error; switch (cmd) { case DIOCSBAD: if ((flag & FWRITE) == 0) return EBADF; wd->sc_cpulabel.bad = *(struct dkbad *)addr; bad144intern(wd); return 0; case DIOCGDINFO: *(struct disklabel *)addr = wd->sc_label; return 0; case DIOCGPART: ((struct partinfo *)addr)->disklab = &wd->sc_label; ((struct partinfo *)addr)->part = &wd->sc_label.d_partitions[WDPART(dev)]; return 0; case DIOCSDINFO: if ((flag & FWRITE) == 0) return EBADF; error = setdisklabel(&wd->sc_label, (struct disklabel *)addr, /*(wd->sc_flags & WDF_BSDLABEL) ? wd->sc_openpart : */0, &wd->sc_cpulabel); if (error == 0) { wd->sc_flags |= WDF_BSDLABEL; wdsetctlr(wd); } return error; case DIOCWLABEL: wd->sc_flags &= ~WDF_WRITEPROT; if ((flag & FWRITE) == 0) return EBADF; wd->sc_wlabel = *(int *)addr; return 0; case DIOCWDINFO: wd->sc_flags &= ~WDF_WRITEPROT; if ((flag & FWRITE) == 0) return EBADF; error = setdisklabel(&wd->sc_label, (struct disklabel *)addr, /*(wd->sc_flags & WDF_BSDLABEL) ? wd->sc_openpart :*/0, &wd->sc_cpulabel); if (error == 0) { int wlab; wd->sc_flags |= WDF_BSDLABEL; wdsetctlr(wd); /* Simulate opening partition 0 so write succeeds. */ wd->sc_openpart |= (1 << 0); /* XXX */ wlab = wd->sc_wlabel; wd->sc_wlabel = 1; error = writedisklabel(dev, wdstrategy, &wd->sc_label, &wd->sc_cpulabel); wd->sc_openpart = wd->sc_copenpart | wd->sc_bopenpart; wd->sc_wlabel = wlab; } return error; #ifdef notyet case DIOCGDINFOP: *(struct disklabel **)addr = &wd->sc_label; return 0; case DIOCWFORMAT: if ((flag & FWRITE) == 0) return EBADF; { register struct format_op *fop; struct iovec aiov; struct uio auio; fop = (struct format_op *)addr; aiov.iov_base = fop->df_buf; aiov.iov_len = fop->df_count; auio.uio_iov = &aiov; auio.uio_iovcnt = 1; auio.uio_resid = fop->df_count; auio.uio_segflg = 0; auio.uio_offset = fop->df_startblk * wd->sc_label.d_secsize; error = physio(wdformat, NULL, dev, B_WRITE, minphys, &auio); fop->df_count -= auio.uio_resid; fop->df_reg[0] = wdc->sc_status; fop->df_reg[1] = wdc->sc_error; return error; } #endif default: return ENOTTY; } #ifdef DIAGNOSTIC panic("wdioctl: impossible"); #endif } #ifdef B_FORMAT int wdformat(struct buf *bp) { bp->b_flags |= B_FORMAT; return wdstrategy(bp); } #endif int wdsize(dev) dev_t dev; { int lunit = WDUNIT(dev), part = WDPART(dev); struct wd_softc *wd; if (lunit >= NWD) return -1; wd = wd_softc[lunit]; if (wd == 0) return -1; if (wd->sc_state < OPEN || (wd->sc_flags & WDF_BSDLABEL) == 0) { int val; val = wdopen(makewddev(major(dev), lunit, WDRAW), FREAD, S_IFBLK, 0); /* XXX Clear the open flag? */ if (val != 0) return -1; } if ((wd->sc_flags & (WDF_WRITEPROT | WDF_BSDLABEL)) != WDF_BSDLABEL) return -1; return (int)wd->sc_label.d_partitions[part].p_size; } /* * Dump core after a system crash. */ int wddump(dev) dev_t dev; { struct wd_softc *wd; /* disk unit to do the IO */ struct wdc_softc *wdc; long num; /* number of sectors to write */ int lunit, part; long blkoff, blknum; long cylin, head, sector; long secpertrk, secpercyl, nblocks; char *addr; static wddoingadump = 0; extern caddr_t CADDR1; extern struct pte *CMAP1; addr = (char *)0; /* starting address */ #if DO_NOT_KNOW_HOW /* Toss any characters present prior to dump, ie. non-blocking getc. */ while (cngetc()) ; #endif lunit = WDUNIT(dev); /* Check for acceptable drive number. */ if (lunit >= NWD) return ENXIO; wd = wd_softc[lunit]; /* Was it ever initialized? */ if (wd == 0 || wd->sc_state < OPEN || wd->sc_flags & WDF_WRITEPROT) return ENXIO; wdc = (void *)wd->sc_dev.dv_parent; /* Convert to disk sectors. */ num = ctob(physmem) / wd->sc_label.d_secsize; secpertrk = wd->sc_label.d_nsectors; secpercyl = wd->sc_label.d_secpercyl; part = WDPART(dev); nblocks = wd->sc_label.d_partitions[part].p_size; blkoff = wd->sc_label.d_partitions[part].p_offset; /*printf("part %x, nblocks %d, dumplo %d, num %d\n", part, nblocks, dumplo, num);*/ /* Check transfer bounds against partition size. */ if (dumplo < 0 || dumplo + num > nblocks) return EINVAL; if (wddoingadump) return EFAULT; wddoingadump = 1; /* Recalibrate. */ if (wdcommand(wd, 0, 0, 0, 0, WDCC_RESTORE | WD_STEP) != 0 || wait_for_ready(wdc) != 0 || wdsetctlr(wd) != 0) { wderror(wd, NULL, "wddump: recal failed"); return EIO; } blknum = dumplo + blkoff; while (num > 0) { /* Compute disk address. */ cylin = blknum / secpercyl; head = (blknum % secpercyl) / secpertrk; sector = blknum % secpertrk; if (wd->sc_flags & WDF_BADSECT) { long newblk; int i; for (i = 0; wd->sc_badsect[i] != -1; i++) { if (blknum < wd->sc_badsect[i]) { /* Sorted list, passed our block by. */ break; } else if (blknum == wd->sc_badsect[i]) { newblk = wd->sc_label.d_secperunit - wd->sc_label.d_nsectors - i - 1; cylin = newblk / secpercyl; head = (newblk % secpercyl) / secpertrk; sector = newblk % secpertrk; /* Found and replaced; done. */ break; } } } sector++; /* origin 1 */ #ifdef notdef /* Let's just talk about this first. */ printf("cylin %d, head %d, sector %d, addr 0x%x", cylin, head, sector, addr); #endif if (wdcommand(wd, cylin, head, sector, 1, WDCC_WRITE) != 0) { wderror(wd, NULL, "wddump: wdcommand failed"); return EIO; } if (wait_for_drq(wdc) != 0) { wderror(wd, NULL, "wddump: timeout waiting for drq"); return EIO; } #ifdef notdef /* Cannot use this since this address was mapped differently. */ pmap_enter(kernel_pmap, CADDR1, trunc_page(addr), VM_PROT_READ, TRUE); #else *(int *)CMAP1 = PG_V | PG_KW | ctob((long)addr); tlbflush(); #endif outsw(wdc->sc_iobase+wd_data, CADDR1 + ((int)addr & PGOFSET), DEV_BSIZE / sizeof(short)); /* Check data request (should be done). */ if (wait_for_ready(wdc) != 0) { wderror(wd, NULL, "wddump: timeout waiting for ready"); return EIO; } if (wdc->sc_status & WDCS_DRQ) { wderror(wd, NULL, "wddump: extra drq"); return EIO; } if ((unsigned)addr % 1048576 == 0) printf("%d ", num / (1048576 / DEV_BSIZE)); /* Update block count. */ num--; blknum++; (int)addr += DEV_BSIZE; #if DO_NOT_KNOW_HOW /* Operator aborting dump? non-blocking getc() */ if (cngetc()) return EINTR; #endif } return 0; } /* * Internalize the bad sector table. */ void bad144intern(wd) struct wd_softc *wd; { int i; if ((wd->sc_flags & WDF_BADSECT) == 0) return; for (i = 0; i < 127; i++) wd->sc_badsect[i] = -1; for (i = 0; i < 126; i++) { if (wd->sc_cpulabel.bad.bt_bad[i].bt_cyl == 0xffff) break; wd->sc_badsect[i] = wd->sc_cpulabel.bad.bt_bad[i].bt_cyl * wd->sc_label.d_secpercyl + (wd->sc_cpulabel.bad.bt_bad[i].bt_trksec >> 8) * wd->sc_label.d_nsectors + (wd->sc_cpulabel.bad.bt_bad[i].bt_trksec & 0x00ff); } } static int wdcreset(wdc) struct wdc_softc *wdc; { u_short iobase = wdc->sc_iobase; /* Reset the device. */ outb(iobase+wd_ctlr, WDCTL_RST | WDCTL_IDS); delay(1000); outb(iobase+wd_ctlr, WDCTL_IDS); delay(1000); (void) inb(iobase+wd_error); outb(iobase+wd_ctlr, WDCTL_4BIT); if (wait_for_unbusy(wdc) < 0) { printf("%s: reset failed\n", wdc->sc_dev.dv_xname); return 1; } return 0; } static void wdcrestart(wdc) struct wdc_softc *wdc; { int s = splbio(); wdc->sc_q.b_active = 0; wdcstart(wdc); splx(s); } /* * Unwedge the controller after an unexpected error. We do this by resetting * it, marking all drives for recalibration, and stalling the queue for a short * period to give the reset time to finish. * NOTE: We use a timeout here, so this routine must not be called during * autoconfig or dump. */ static void wdcunwedge(wdc) struct wdc_softc *wdc; { int lunit; wdc->sc_timeout = 0; (void) wdcreset(wdc); /* Schedule recalibrate for all drives on this controller. */ for (lunit = 0; lunit < NWD; lunit++) { struct wd_softc *wd = wd_softc[lunit]; if (!wd || (void *)wd->sc_dev.dv_parent != wdc) continue; if (wd->sc_state > WANTOPEN) wd->sc_state = WANTOPEN; if (wd->sc_q.b_active && (wd->sc_flags & WDF_SINGLE) == 0) wd->sc_flags |= WDF_ERROR; } ++wdc->sc_q.b_errcnt; /* Wake up in a little bit and restart the operation. */ timeout((timeout_t)wdcrestart, (caddr_t)wdc, RECOVERYTIME); } int wdcwait(wdc, mask) struct wdc_softc *wdc; int mask; { u_short iobase = wdc->sc_iobase; int timeout = 0; u_char status; for (;;) { wdc->sc_status = status = inb(iobase+wd_altsts); if ((status & WDCS_BUSY) == 0 && (status & mask) == mask) break; if (++timeout > WDCNDELAY) return -1; delay(WDCDELAY); } if (status & WDCS_ERR) wdc->sc_error = inb(iobase+wd_error); #ifdef WDCNDELAY_DEBUG if (timeout > WDCNDELAY_DEBUG) printf("%s: busy-wait took %dus\n", wdc->sc_dev.dv_xname, WDCDELAY * timeout); #endif return status & WDCS_ERR; } static void wdctimeout(wdc) struct wdc_softc *wdc; { int s = splbio(); if (wdc->sc_timeout && --wdc->sc_timeout == 0) { wderror(wdc, NULL, "lost interrupt"); wdcunwedge(wdc); } timeout((timeout_t)wdctimeout, (caddr_t)wdc, hz); splx(s); } static void wderror(dev, bp, msg) void *dev; struct buf *bp; char *msg; { struct wd_softc *wd = dev; struct wdc_softc *wdc = dev; if (bp) diskerr(bp, "wd", msg, LOG_PRINTF, wd->sc_skip, &wd->sc_label); else printf("%s: %s: status %b error %b\n", wdc->sc_dev.dv_xname, msg, wdc->sc_status, WDCS_BITS, wdc->sc_error, WDERR_BITS); } #endif /* NWDC > 0 */