Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
e4102b8797
NetBSD/sys/dev/isa/wd.c

1542 lines
38 KiB
C
Raw Blame History

/*
* 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.64 1994/03/10 05:18:33 mycroft Exp $
*/
#define INSTRUMENT /* instrumentation stuff by Brad Parker */
#include "wd.h"
#if NWDC > 0
#include <sys/param.h>
#include <sys/dkbad.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/conf.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/disklabel.h>
#include <sys/buf.h>
#include <sys/uio.h>
#include <sys/malloc.h>
#include <sys/device.h>
#include <sys/syslog.h>
#ifdef INSTRUMENT
#include <sys/dkstat.h>
#endif
#include <vm/vm.h>
#include <machine/cpu.h>
#include <machine/cpufunc.h>
#include <machine/pio.h>
#include <i386/isa/isa.h>
#include <i386/isa/isa_device.h>
#include <i386/isa/icu.h>
#include <i386/isa/wdreg.h>
#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 wdprobe(), wdattach(), wdintr();
struct isa_driver wdcdriver = {
wdprobe, wdattach, "wdc",
};
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
wdprobe(isa_dev)
struct isa_device *isa_dev;
{
struct wd_softc *wd;
struct wdc_softc *wdc;
u_short iobase;
if (isa_dev->id_unit >= NWDC)
return 0;
wdc = &wdc_softc[isa_dev->id_unit];
/* XXX HACK */
sprintf(wdc->sc_dev.dv_xname, "%s%d", "wdc", isa_dev->id_unit);
wdc->sc_dev.dv_unit = isa_dev->id_unit;
wdc->sc_iobase = iobase = isa_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;
}
/*
* Called for the controller too. Attach each drive if possible.
*/
int
wdattach(isa_dev)
struct isa_device *isa_dev;
{
int lunit;
struct wd_softc *wd;
struct wdc_softc *wdc;
int i, blank;
if (isa_dev->id_masunit == -1)
return 0;
if (isa_dev->id_masunit >= NWDC)
return 0;
lunit = isa_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[isa_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 = isa_dev->id_physid;
wd->sc_lunit = lunit;
/* XXX HACK */
sprintf(wd->sc_dev.dv_xname, "%s%d", "wd", isa_dev->id_unit);
wd->sc_dev.dv_unit = isa_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,
isa_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 */
Reference in New Issue View Git Blame Copy Permalink