4.4BSD/usr/src/sys/vax/uba/up.c.disklabel
/*
* Copyright (c) 1982, 1986 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*
* %W% (Berkeley) %D%
*/
/*
* up.c, driver for Emulex SC21, SC31 disk controllers
* with support for disklabels.
* UNTESTED.
*/
#ifdef UPDEBUG
int updebug;
#endif
#ifdef UPBDEBUG
int upbdebug;
#endif
#include "up.h"
#if NSC > 0
/*
* UNIBUS disk driver with:
* overlapped seeks,
* ECC recovery, and
* bad sector forwarding.
*
* TODO:
* Check that offset recovery code works
*/
#include "../machine/pte.h"
#include "param.h"
#include "systm.h"
#include "dkstat.h"
#include "dkbad.h"
#include "ioctl.h"
#include "disklabel.h"
#include "buf.h"
#include "conf.h"
#include "dir.h"
#include "file.h"
#include "user.h"
#include "map.h"
#include "vm.h"
#include "cmap.h"
#include "uio.h"
#include "kernel.h"
#include "syslog.h"
#include "stat.h"
#include "../vax/mtpr.h"
#include "../vax/cpu.h"
#include "../vax/nexus.h"
#include "ubavar.h"
#include "ubareg.h"
#include "upreg.h"
#define COMPAT_42
#define B_FORMAT B_XXX
#define upunit(dev) (minor(dev) >> 3)
#define uppart(dev) (minor(dev) & 07)
#define upminor(unit, part) (((unit) << 3) | (part))
int upprobe(), upslave(), upattach(), updgo(), upintr();
struct uba_ctlr *upminfo[NSC];
struct uba_device *updinfo[NUP];
#define UPIPUNITS 8
struct uba_device *upip[NSC][UPIPUNITS]; /* fuji w/fixed head gives n,n+4 */
u_short upstd[] = { 0776700, 0774400, 0776300, 0 };
struct uba_driver scdriver =
{ upprobe, upslave, upattach, updgo, upstd, "up", updinfo, "sc", upminfo };
struct buf uputab[NUP];
char upinit[NUP];
u_char up_offset[16] = {
UPOF_P400, UPOF_M400, UPOF_P400, UPOF_M400,
UPOF_P800, UPOF_M800, UPOF_P800, UPOF_M800,
UPOF_P1200, UPOF_M1200, UPOF_P1200, UPOF_M1200,
0, 0, 0, 0
};
struct buf bupbuf[NUP];
struct dkbad upbad[NUP];
struct upsoftc {
u_char sc_recal; /* recalibrate state */
u_char sc_doseeks; /* perform explicit seeks */
#ifdef COMPAT_42
u_char sc_hdr; /* next i/o includes header */
#endif
short sc_state; /* open fsm */
short sc_wlabel; /* label sector is currently writeable */
u_long sc_openpart; /* bit mask of open subunits */
u_long sc_copenpart; /* bit mask of open character subunits */
u_long sc_bopenpart; /* bit mask of open block subunits */
int sc_blkdone; /* amount sucessfully transfered */
daddr_t sc_badbn; /* replacement block number */
short sc_softas; /* bitmask of drives needing attention */
short sc_ndrive; /* count of drives */
int sc_wticks; /* watchdog timer */
int sc_status; /* copy of drive status reg after format */
int sc_upds; /* copy of upds reg after format */
int sc_er1; /* copy of error reg 1 after format */
int sc_er2; /* copy of error reg 2 after format */
} upsoftc[NSC];
/*
* Drive states. Used during steps of open/initialization.
* States < OPEN (> 0) are transient, during an open operation.
* OPENRAW is used for unlabeled disks,
* to inhibit bad-sector forwarding or allow format operations.
*/
#define CLOSED 0 /* disk is closed. */
#define WANTOPEN 1 /* open requested, not started */
#define WANTOPENRAW 2 /* open requested, no label */
#define RDLABEL 3 /* reading pack label */
#define RDBADTBL 4 /* reading bad-sector table */
#define OPEN 5 /* initialized and ready */
#define OPENRAW 6 /* open, no label or badsect */
#define b_cylin b_resid /* cyl number, for disksort */
#define b_bufsiz b_bdone /* amount done, in ui_tab only */
int upwstart, upwatch(); /* Have started guardian */
int upseek;
int upwaitdry;
upprobe(reg)
caddr_t reg;
{
register int br, cvec;
#ifdef lint
br = 0; cvec = br; br = cvec; upintr(0);
#endif
((struct updevice *)reg)->upcs1 = UP_IE|UP_RDY;
DELAY(10);
((struct updevice *)reg)->upcs1 = 0;
return (sizeof (struct updevice));
}
upslave(ui, reg)
struct uba_device *ui;
caddr_t reg;
{
register struct updevice *upaddr = (struct updevice *)reg;
upaddr->upcs1 = 0; /* conservative */
upaddr->upcs2 = ui->ui_slave;
upaddr->upcs1 = UP_NOP|UP_GO;
if (upaddr->upcs2&UPCS2_NED) {
upaddr->upcs1 = UP_DCLR|UP_GO;
return (0);
}
return (1);
}
upattach(ui)
register struct uba_device *ui;
{
register int unit = ui->ui_unit;
if (upwstart == 0) {
timeout(upwatch, (caddr_t)0, hz);
upwstart++;
}
upip[ui->ui_ctlr][ui->ui_slave] = ui;
up_softc[ui->ui_ctlr].sc_ndrive++;
/*
* Try to initialize device and read pack label.
*/
if (upinit(upminor(unit, 0), 0) == 0) {
printf(": %s", uplabel[unit].d_typename);
#ifdef notyet
addswap(makedev(UPMAJOR, upminor(unit, 0)), &uplabel[unit]);
#endif
} else
printf(": offline");
}
upopen(dev, flags, fmt)
dev_t dev;
int flags, fmt;
{
register int unit = upunit(dev);
register struct upsoftc *sc;
register struct disklabel *lp;
register struct partition *pp;
struct uba_device *ui;
int s, error, part = uppart(dev), mask = 1 << part;
daddr_t start, end;
if (unit >= NUP || (ui = updinfo[unit]) == 0 || ui->ui_alive == 0)
return (ENXIO);
sc = &upsoftc[unit];
lp = &uplabel[unit];
s = spl5();
while (sc->sc_state != OPEN && sc->sc_state != OPENRAW &&
sc->sc_state != CLOSED)
sleep ((caddr_t)sc, PZERO+1);
splx(s);
if (sc->sc_state != OPEN && sc->sc_state != OPENRAW)
if (error = upinit(dev, flags))
return (error);
if (part >= lp->d_npartitions)
return (ENXIO);
/*
* Warn if a partion is opened
* that overlaps another partition which is open
* unless one is the "raw" partition (whole disk).
*/
#define RAWPART 2 /* 'c' partition */ /* XXX */
if ((sc->sc_openpart & mask) == 0 && part != RAWPART) {
pp = &lp->d_partitions[part];
start = pp->p_offset;
end = pp->p_offset + pp->p_size;
for (pp = lp->d_partitions;
pp < &lp->d_partitions[lp->d_npartitions]; pp++) {
if (pp->p_offset + pp->p_size <= start ||
pp->p_offset >= end)
continue;
if ((s = pp - lp->d_partitions) == RAWPART)
continue;
if (sc->sc_openpart & (1 << s))
log(LOG_WARNING,
"up%d%c: overlaps open partition (%c)\n",
unit, part + 'a', s + 'a');
}
}
switch (fmt) {
case S_IFCHR:
sc->sc_copenpart |= mask;
break;
case S_IFBLK:
sc->sc_bopenpart |= mask;
break;
}
sc->sc_openpart |= mask;
return (0);
}
/* ARGSUSED */
upclose(dev, flags, fmt)
dev_t dev;
int flags, fmt;
{
register int unit = upunit(dev);
register struct upsoftc *sc = &upsoftc[unit];
struct uba_device *ui = updinfo[unit];
int s;
switch (fmt) {
case S_IFCHR:
sc->sc_copenpart &= ~(1 << uppart(dev));
break;
case S_IFBLK:
sc->sc_bopenpart &= ~(1 << uppart(dev));
break;
}
if (sc->sc_openpart)
sc->sc_openpart = sc->sc_copenpart | sc->sc_bopenpart;
/*
* If this was the last open partition on the drive, then
* we must wait for the i/o to complete (so caller knows its
* ok to turn the drive off). If not the last, no problem,
* as some other partition must still be active. (Potential
* problem is some part of the "drive" can be spun down
* while leaving other part of same drive running ..)
*
* (this will also happen if we have disabled the drive because
* of an unanticipated pack change, but no harm there)
*/
if (sc->sc_openpart == 0) {
s = spl5();
while (ui->ui_tab.b_actf)
sleep((caddr_t)sc, PZERO - 1);
splx(s);
sc->sc_state = CLOSED;
}
return (0);
}
upinit(dev, flags)
dev_t dev;
int flags;
{
register struct upsoftc *sc;
register struct buf *bp;
register struct disklabel *lp;
struct uba_device *ui;
struct dkbad *db;
char *msg, *readdisklabel();
int unit, i, error = 0;
extern int cold;
unit = upunit(dev);
sc = &upsoftc[unit];
lp = &uplabel[unit];
ui = updinfo[unit];
sc->sc_state = WANTOPEN;
/*
* Obtain the physical drive characteristics from the
* controller, for use until the label overrides them.
*/
upphysical(ui->ui_addr, lp);
if (flags & O_NDELAY)
goto raw;
/*
* Preset, pack acknowledge will be done in upstart
* during first read operation.
*/
if (msg = readdisklabel(dev, upstrategy, lp)) {
if (cold)
printf(": %s", msg);
else
log(LOG_ERR, "up%d: %s\n", unit, msg);
#ifdef COMPAT_42
if (upmaptype(ui, lp) == 0)
#endif
goto raw;
}
/*
* Seconds per word = (60 / rpm) / (nsectors * secsize/2)
*/
if (ui->ui_dk >= 0 && lp->d_rpm)
dk_mspw[ui->ui_dk] = 120.0 /
(lp->d_rpm * lp->d_nsectors * lp->d_secsize);
/*
* Read bad sector table into memory.
*/
bp = geteblk(DEV_BSIZE); /* max sector size */
bp->b_dev = dev;
sc->sc_state = RDBADTBL;
i = 0;
do {
u.u_error = 0; /* XXX */
bp->b_flags = B_BUSY | B_READ;
bp->b_blkno = lp->d_secperunit - lp->d_nsectors + i;
bp->b_bcount = lp->d_secsize;
bp->b_cylin = lp->d_ncylinders - 1;
upstrategy(bp);
biowait(bp);
} while ((bp->b_flags & B_ERROR) && (i += 2) < 10 &&
i < lp->d_nsectors);
db = (struct dkbad *)(bp->b_un.b_addr);
if ((bp->b_flags & B_ERROR) == 0 && db->bt_mbz == 0 &&
db->bt_flag == 0) {
upbad[unit] = *db;
sc->sc_state = OPEN;
} else {
log(LOG_ERR, "up%d: %s bad-sector file\n", unit,
(bp->b_flags & B_ERROR) ? "can't read" : "format error in");
u.u_error = 0; /* XXX */
sc->sc_state = OPENRAW;
}
bp->b_flags = B_INVAL | B_AGE;
brelse(bp);
done:
wakeup((caddr_t)sc);
return (error);
raw:
sc->sc_state = OPENRAW;
wakeup((caddr_t)sc);
return (error);
}
/*
* obtain the physical drive layout from the controller prom
* (we know this isn't a dec controller, so we can assume sanity)
*/
upphysical(upaddr, lp)
register struct updevice *upaddr;
register struct disklabel *lp;
{
upaddr->upcs1 = 0;
upaddr->upcs2 = ui->ui_slave;
upaddr->uphr = UPHR_MAXTRAK;
lp->d_ntracks = upaddr->uphr + 1;
upaddr->uphr = UPHR_MAXSECT;
lp->d_nsectors = upaddr->uphr + 1;
upaddr->uphr = UPHR_MAXCYL;
lp->d_ncylinders = upaddr->uphr + 1;
lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
lp->d_secperunit = lp->d_secpercyl * lp->d_ncylinders;
lp->d_npartitions = 1; /* ??? (allow label write) */
lp->d_partitions[0].p_offset = 0;
lp->d_partitions[0].p_size = lp->d_secperunit;
lp->d_secsize = DEV_BSIZE; /* assume this */
upaddr->upcs2 = UPCS2_CLR;
}
upstrategy(bp)
register struct buf *bp;
{
register struct uba_device *ui;
register struct disklabel *lp;
register struct upsoftc *sc;
register int unit;
register struct buf *dp;
long bn, sz;
daddr_t maxsz;
int xunit = uppart(bp->b_dev);
int s;
sz = (bp->b_bcount + DEV_BSIZE - 1) >> DEV_BSHIFT;
unit = hpunit(bp->b_dev);
if (unit >= NUP) {
bp->b_error = ENXIO;
goto bad;
}
ui = updinfo[unit];
if (ui == 0 || ui->ui_alive == 0) {
bp->b_error = ENXIO;
goto bad;
}
sc = &upsoftc[unit];
lp = &uplabel[unit];
if (sc->sc_state < OPEN)
goto q;
if ((sc->sc_openpart & (1 << xunit)) == 0) {
bp->b_error = ENODEV;
goto bad;
}
maxsz = lp->d_partitions[xunit].p_size;
if (bp->b_blkno < 0 || bp->b_blkno + sz > maxsz) {
if (bp->b_blkno == maxsz) {
bp->b_resid = bp->b_bcount;
goto done;
}
sz = maxsz - bp->b_blkno;
if (sz <= 0) {
bp->b_error = EINVAL;
goto bad;
}
bp->b_bcount = sz << DEV_BSHIFT;
}
bp->b_cylin = (bp->b_blkno + lp->d_partitions[xunit].p_offset) /
lp->d_secpercyl;
q:
s = spl5();
dp = &uputab[ui->ui_unit];
disksort(dp, bp);
if (dp->b_active == 0) {
(void) upustart(ui);
bp = &ui->ui_mi->um_tab;
if (bp->b_actf && bp->b_active == 0)
(void) upstart(ui->ui_mi);
}
splx(s);
return;
bad:
bp->b_flags |= B_ERROR;
done:
biodone(bp);
return;
}
/*
* Unit start routine.
* Seek the drive to be where the data is
* and then generate another interrupt
* to actually start the transfer.
* If there is only one drive on the controller,
* or we are very close to the data, don't
* bother with the search. If called after
* searching once, don't bother to look where
* we are, just queue for transfer (to avoid
* positioning forever without transferrring.)
*/
upustart(ui)
register struct uba_device *ui;
{
register struct buf *bp, *dp;
register struct uba_ctlr *um;
register struct updevice *upaddr;
register struct disklabel *lp;
struct upsoftc *sc = &upsoftc[ui->ui_unit];
daddr_t bn;
int sn, tn, dist;
/*
* The SC21 cancels commands if you just say
* cs1 = UP_IE
* so we are cautious about handling of cs1.
* Also don't bother to clear as bits other than in upintr().
*/
int didie = 0;
if (ui == 0)
return (0);
um = ui->ui_mi;
dk_busy &= ~(1<<ui->ui_dk);
dp = &uputab[ui->ui_unit];
retry:
if ((bp = dp->b_actf) == NULL)
return (0);
/*
* If the controller is active, just remember
* that this device would like to be positioned...
* if we tried to position now we would confuse the SC21.
*/
if (um->um_tab.b_active) {
up_softc[um->um_ctlr].sc_softas |= 1<<ui->ui_slave;
return (0);
}
/*
* If we have already positioned this drive,
* then just put it on the ready queue.
*/
if (dp->b_active)
goto done;
dp->b_active = 1;
lp = &uplabel[ui->ui_unit];
upaddr = (struct updevice *)um->um_addr;
upaddr->upcs2 = ui->ui_slave;
switch (sc->sc_recal) {
case 1:
(void)HPWAIT(mi, hpaddr);
upaddr->updc = bp->b_cylin;
upaddr->upcs1 = UP_IE|UP_SEEK|UP_GO;
sc->sc_recal++;
return (1);
case 2:
break;
}
sc->sc_recal = 0;
/*
* If drive has just come up,
* setup the pack.
*/
if ((upaddr->upds & UPDS_VV) == 0) {
struct buf *bbp = &bupbuf[ui->ui_unit];
if (sc->sc_state == OPEN && lp->d_flags & D_REMOVABLE) {
if (sc->sc_openpart)
log(LOG_ERR, "up%d: volume changed\n",
ui->ui_unit);
sc->sc_openpart = 0;
do {
dp->b_actf = bp->b_forw;
bp->b_flags |= B_ERROR;
bp->b_errno = ENXIO;
iodone(bp);
} while (bp = dp->b_actf);
return (0);
}
upaddr->upcs1 = UP_IE|UP_DCLR|UP_GO;
upaddr->upcs1 = UP_IE|UP_PRESET|UP_GO;
upaddr->upof = UPOF_FMT22;
if (sc->sc_state == WANTOPENRAW) {
sc->sc_state = OPENRAW;
return (1);
}
if (sc->sc_state == WANTOPEN)
sc->sc_state = RDLABEL;
didie = 1;
}
/*
* If drive is offline, forget about positioning.
*/
if ((upaddr->upds & (UPDS_DPR|UPDS_MOL)) != (UPDS_DPR|UPDS_MOL))
goto done;
/*
* If there is only one drive,
* dont bother searching.
*/
if (up_softc[um->um_ctlr].sc_ndrive == 1)
goto done;
/*
* Figure out where this transfer is going to
* and see if we are close enough to justify not searching.
*/
st = &upst[ui->ui_type];
bn = bp->b_blkno;
sn = bn % lp->d_secpercyl;
tn = sn / lp->d_nsectors;
sn = sn % lp->d_nsectors;
if (bp->b_cylin == upaddr->updc) {
if (sc->sc_doseeks)
goto done; /* Ok just to be on-cylinder */
dist = sn - (upaddr->upla>>6) - 1;
if (dist < 0)
dist += lp->d_nsectors;
if (dist <= lp->d_maxdist && dist >= lp->d_mindist)
goto done;
} else
upaddr->updc = bp->b_cylin;
/*
* Not on cylinder at correct position,
* seek/search.
*/
if (sc->sc_doseeks)
upaddr->upcs1 = UP_IE|UP_SEEK|UP_GO;
else {
sn = (sn + lp->d_nsectors - lp->d_sdist) % lp->d_nsectors;
upaddr->upda = sn;
upaddr->upcs1 = UP_IE|UP_SEARCH|UP_GO;
}
didie = 1;
/*
* Mark unit busy for iostat.
*/
if (ui->ui_dk >= 0) {
dk_busy |= 1<<ui->ui_dk;
dk_seek[ui->ui_dk]++;
}
goto out;
done:
/*
* Device is ready to go.
* Put it on the ready queue for the controller
* (unless its already there.)
*/
if (dp->b_active != 2) {
dp->b_forw = NULL;
if (um->um_tab.b_actf == NULL)
um->um_tab.b_actf = dp;
else
um->um_tab.b_actl->b_forw = dp;
um->um_tab.b_actl = dp;
dp->b_active = 2;
}
out:
return (didie);
}
/*
* Start up a transfer on a drive.
*/
upstart(um)
register struct uba_ctlr *um;
{
register struct buf *bp, *dp;
register struct uba_device *ui;
register struct updevice *upaddr;
register struct disklabel *lp = &uplabel[ui->ui_unit];
struct upsoftc *sc = &upsoftc[ui->ui_unit];
daddr_t bn;
int cn, dn, sn, tn, cmd, waitdry;
loop:
/*
* Pull a request off the controller queue
*/
if ((dp = um->um_tab.b_actf) == NULL)
return (0);
if ((bp = dp->b_actf) == NULL) {
um->um_tab.b_actf = dp->b_forw;
goto loop;
}
/*
* Mark controller busy, and
* determine destination of this request.
*/
um->um_tab.b_active++;
ui = updinfo[upunit(bp->b_dev)];
bn = bp->b_blkno;
dn = ui->ui_slave;
st = &upst[ui->ui_type];
sn = bn%st->nspc;
tn = sn/st->nsect;
sn %= st->nsect;
upaddr = (struct updevice *)ui->ui_addr;
/*
* Select drive if not selected already.
*/
if ((upaddr->upcs2&07) != dn)
upaddr->upcs2 = dn;
/*
* Check that it is ready and online
*/
waitdry = 0;
while ((upaddr->upds&UPDS_DRY) == 0) {
log(LOG_ERR, "up%d: ds wait ds=%o\n", upunit(bp->b_dev),
upaddr->upds);
if (++waitdry > 512)
break;
upwaitdry++;
}
if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) {
/*
* this should be "log()", but log with split
* messages is very messy, and we also depend here
* on there being a real (measureable) time taken
* doing the printf, to give the drive a chance to
* recover .. printf polls the terminal, so takes ages
*/
printf("up%d: not ready", upunit(bp->b_dev));
if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) {
printf("\n");
um->um_tab.b_active = 0;
um->um_tab.b_errcnt = 0;
dp->b_actf = bp->av_forw;
dp->b_active = 0;
bp->b_flags |= B_ERROR;
iodone(bp);
goto loop;
}
/*
* Oh, well, sometimes this
* happens, for reasons unknown.
*/
printf(" (flakey)\n");
}
/*
* Setup for the transfer, and get in the
* UNIBUS adaptor queue.
*/
if (bp->b_flags & B_BAD) {
bn = sc->sc_badbn;
cn = bn / lp->d_secpercyl;
} else {
bn = bp->b_blkno;
cn = bp->b_cylin;
}
sn = bn % lp->d_secpercyl;
if ((bp->b_flags & B_BAD) == 0)
sn += sc->sc_blkdone;
tn = sn / lp->d_nsectors;
sn %= lp->d_nsectors;
cn += tn / lp->d_ntracks;
tn %= lp->d_ntracks;
upaddr->updc = cn;
upaddr->upda = (tn << 8) + sn;
if (bp->b_bcount >= 0)
upaddr->upwc = (-bp->b_bcount + ui->ui_tab.b_bdone) /
sizeof (short);
else
upaddr->upwc = (bp->b_wcount + ui->ui_tab.b_bdone) /
sizeof (short);
switch (bp->b_flags & (B_READ|B_WRITE|B_FORMAT)) {
case B_READ:
cmd = UP_IE|UP_RCOM|UP_GO;
break;
case B_WRITE:
cmd = UP_IE|UP_WCOM|UP_GO;
break;
case B_READ|B_FORMAT:
cmd = UP_IE|UP_RHDR|UP_GO;
break;
case B_WRITE|B_FORMAT:
cmd = UP_IE|UP_WHDR|UP_GO;
break;
}
um->um_cmd = cmd;
ui->ui_tab.b_bdone = dbtob(sc->sc_blkdone);
(void) ubago(ui);
return (1);
}
/*
* Now all ready to go, stuff the registers.
*/
updgo(um)
struct uba_ctlr *um;
{
register struct updevice *upaddr = (struct updevice *)um->um_addr;
um->um_tab.b_active = 2; /* should now be 2 */
upaddr->upba = um->um_ubinfo;
upaddr->upcs1 = um->um_cmd|((um->um_ubinfo>>8)&0x300);
}
/*
* Handle a disk interrupt.
*/
upintr(sc21)
register sc21;
{
register struct buf *bp, *dp;
register struct uba_ctlr *um = upminfo[sc21];
register struct uba_device *ui;
register struct updevice *upaddr = (struct updevice *)um->um_addr;
register unit;
struct up_softc *sc = &up_softc[um->um_ctlr];
int as = (upaddr->upas & 0377) | sc->sc_softas;
int needie = 1, waitdry;
sc->sc_wticks = 0;
sc->sc_softas = 0;
/*
* If controller wasn't transferring, then this is an
* interrupt for attention status on seeking drives.
* Just service them.
*/
if (um->um_tab.b_active != 2 && !sc->sc_recal) {
if (upaddr->upcs1 & UP_TRE)
upaddr->upcs1 = UP_TRE;
goto doattn;
}
um->um_tab.b_active = 1;
/*
* Get device and block structures, and a pointer
* to the uba_device for the drive. Select the drive.
*/
dp = um->um_tab.b_actf;
bp = dp->b_actf;
ui = updinfo[upunit(bp->b_dev)];
dk_busy &= ~(1 << ui->ui_dk);
if ((upaddr->upcs2&07) != ui->ui_slave)
upaddr->upcs2 = ui->ui_slave;
/*
* Check for and process errors on
* either the drive or the controller.
*/
if ((upaddr->upds&UPDS_ERR) || (upaddr->upcs1&UP_TRE)) {
er1 = upaddr->uper1;
er2 = upaddr->uper2;
if (bp->b_flags & B_BAD) {
npf = bp->b_error;
bn = sc->sc_badbn;
} else {
npf = btop(bp->b_bcount + upaddr->upwc * sizeof(short));
if (er1 & (UPER_DCK | UPER_ECH))
npf--;
bn = bp->b_blkno + npf;
}
if (UPWAIT(upaddr, upunit(bp->b_dev)) == 0)
goto hard;
#ifdef UPDEBUG
if (updebug) {
log(LOG_DEBUG,
"uperr: bp %x cyl %d blk %d blkdone %d as %o dc %x da %x\n",
bp, bp->b_cylin, bn, sc->sc_blkdone,
upaddr->upas, upaddr->updc, upaddr->upda);
log(LOG_DEBUG,
"errcnt %d er1 %b er2 %b wc -%d (bc %d)\n",
um->um_tab.b_errcnt, er1, UPER1_BITS,
er2, UPER2_BITS, -up->upwc,-up->upwc*sizeof(short));
}
#endif
if (er1 & UPER1_HCRC) {
er1 &= ~(UPER1_HCE|UPER1_FER);
er2 &= ~UPER2_BSE;
}
if (er1 & UPER1_WLE) {
/*
* Give up on write locked devices
* immediately.
*/
log(LOG_WARNING, "up%d: write locked\n",
upunit(bp->b_dev));
bp->b_flags |= B_ERROR;
} else if (bp->b_flags & B_FORMAT) {
goto hard;
} else if (er2 & UPER2_BSE) {
if (upecc(ui, BSW))
return;
goto hard;
} else if ((er1 & (UPER1_DCK|UPER1_ECH)) == UPER1_DCK &&
um->um_tab.b_errcnt >= 3) {
if (upecc(ui, ECC))
return;
/* see comment in hp.c */
if (ui->ui_tab.b_errcnt == 3)
ui->ui_tab.b_errcnt = 0;
} else if (er1 & UPER1_HCRC && upecc(ui, BSE)) {
return;
} else if (++um->um_tab.b_errcnt > 27 || er1 & HPER1_HARD) {
hard:
bp->b_blkno = bn; /* XXX */
harderr(bp, "up");
printf("cn=%d tn=%d sn=%d cs2=%b er1=%b er2=%b",
upaddr->updc, ((upaddr->upda)>>8)&077,
(upaddr->upda)&037,
upaddr->upcs2, UPCS2_BITS,
upaddr->uper1, UPER1_BITS,
upaddr->uper2, UPER2_BITS);
if (bp->b_flags & B_FORMAT)
printf(" (hdr i/o)");
printf("\n");
bp->b_flags |= B_ERROR;
bp->b_flags &= ~B_BAD;
} else
um->um_tab.b_active = 0; /* force retry */
/*
* Clear drive error and, every eight attempts,
* (starting with the fourth)
* recalibrate to clear the slate.
*/
upaddr->upcs1 = UP_TRE|UP_IE|UP_DCLR|UP_GO;
needie = 0;
if ((um->um_tab.b_errcnt&07) == 4 && um->um_tab.b_active == 0) {
upaddr->upcs1 = UP_RECAL|UP_IE|UP_GO;
sc->sc_recal = 0;
goto nextrecal;
}
}
#ifdef UPDEBUG
else if (updebug && sc->sc_recal) {
log(LOG_DEBUG, "up: recal %d errcnt %d er1=%b er2=%b\n",
sc->sc_recal, um->um_tab.b_errcnt,
upaddr->uper1, UPER1_BITS,
upaddr->uper2, UPER2_BITS);
}
#endif
/*
* Advance recalibration finite state machine
* if recalibrate in progress, through
* RECAL
* SEEK
* OFFSET (optional)
* RETRY
*/
switch (sc->sc_recal) {
case 1:
upaddr->updc = bp->b_cylin;
upaddr->upcs1 = UP_SEEK|UP_IE|UP_GO;
goto nextrecal;
case 2:
if (um->um_tab.b_errcnt < 16 || (bp->b_flags&B_READ) == 0)
goto donerecal;
upaddr->upof = up_offset[um->um_tab.b_errcnt&017] | UPOF_FMT22;
upaddr->upcs1 = UP_IE|UP_OFFSET|UP_GO;
goto nextrecal;
nextrecal:
sc->sc_recal++;
um->um_tab.b_active = 1;
return;
donerecal:
case 3:
sc->sc_recal = 0;
um->um_tab.b_active = 0;
break;
}
/*
* If still ``active'', then don't need any more retries.
*/
if (um->um_tab.b_active) {
/*
* If we were offset positioning,
* return to centerline.
*/
if (um->um_tab.b_errcnt >= 16) {
upaddr->upof = UPOF_FMT22;
upaddr->upcs1 = UP_RTC|UP_GO|UP_IE;
while (upaddr->upds & UPDS_PIP)
DELAY(25);
needie = 0;
}
um->um_tab.b_active = 0;
um->um_tab.b_errcnt = 0;
um->um_tab.b_actf = dp->b_forw;
dp->b_active = 0;
dp->b_errcnt = 0;
dp->b_actf = bp->av_forw;
bp->b_resid = (-upaddr->upwc * sizeof(short));
sc->sc_blkdone = 0;
if (sc->sc_openpart == 0)
wakeup((caddr_t)sc);
iodone(bp);
/*
* If this unit has more work to do,
* then start it up right away.
*/
if (dp->b_actf)
if (upustart(ui))
needie = 0;
}
as &= ~(1<<ui->ui_slave);
/*
* Release unibus resources and flush data paths.
*/
ubadone(um);
doattn:
/*
* Process other units which need attention.
* For each unit which needs attention, call
* the unit start routine to place the slave
* on the controller device queue.
*/
while (unit = ffs((long)as)) {
unit--; /* was 1 origin */
as &= ~(1<<unit);
upaddr->upas = 1<<unit;
if (unit < UPIPUNITS && upustart(upip[sc21][unit]))
needie = 0;
}
/*
* If the controller is not transferring, but
* there are devices ready to transfer, start
* the controller.
*/
if (um->um_tab.b_actf && um->um_tab.b_active == 0)
if (upstart(um))
needie = 0;
if (needie)
upaddr->upcs1 = UP_IE;
}
upioctl(dev, cmd, data, flag)
dev_t dev;
int cmd;
caddr_t data;
int flag;
{
int unit = upunit(dev);
register struct disklabel *lp;
register struct format_op *fop;
int error = 0;
int upformat();
lp = &uplabel[unit];
switch (cmd) {
case DIOCGDINFO:
*(struct disklabel *)data = *lp;
break;
case DIOCGPART:
((struct partinfo *)data)->disklab = lp;
((struct partinfo *)data)->part =
&lp->d_partitions[uppart(dev)];
break;
case DIOCSDINFO:
if ((flag & FWRITE) == 0)
error = EBADF;
else
*lp = *(struct disklabel *)data;
break;
case DIOCWDINFO:
if ((flag & FWRITE) == 0) {
error = EBADF;
break;
}
{
struct buf *bp;
struct disklabel *dlp;
*lp = *(struct disklabel *)data;
bp = geteblk(lp->d_secsize);
bp->b_dev = makedev(major(dev), upminor(upunit(dev), 0));
bp->b_blkno = LABELSECTOR;
bp->b_bcount = lp->d_secsize;
bp->b_flags = B_READ;
dlp = (struct disklabel *)(bp->b_un.b_addr + LABELOFFSET);
upstrategy(bp);
biowait(bp);
if (bp->b_flags & B_ERROR) {
error = u.u_error; /* XXX */
u.u_error = 0;
goto bad;
}
*dlp = *lp;
bp->b_flags = B_WRITE;
upstrategy(bp);
biowait(bp);
if (bp->b_flags & B_ERROR) {
error = u.u_error; /* XXX */
u.u_error = 0;
}
bad:
brelse(bp);
break;
}
#ifdef notyet
case DIOCWFORMAT:
if ((flag & FWRITE) == 0) {
error = EBADF;
break;
}
{
struct uio auio;
struct iovec aiov;
fop = (struct format_op *)data;
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 * lp->d_secsize;
error = physio(upformat, &rupbuf[unit], dev, B_WRITE,
minphys, &auio);
fop->df_count -= auio.uio_resid;
fop->df_reg[0] = sc->sc_status;
fop->df_reg[1] = sc->sc_error;
}
break;
#endif
default:
error = ENOTTY;
break;
}
return (error);
}
upformat(bp)
struct buf *bp;
{
bp->b_flags |= B_FORMAT;
return (upstrategy(bp));
}
/*
* Correct an ECC error, and restart the i/o to complete
* the transfer if necessary. This is quite complicated because
* the transfer may be going to an odd memory address base and/or
* across a page boundary.
*/
upecc(ui, flag)
register struct uba_device *ui;
int flag;
{
register struct updevice *up = (struct updevice *)ui->ui_addr;
register struct buf *bp = uputab[ui->ui_unit].b_actf;
register struct uba_ctlr *um = ui->ui_mi;
register struct disklabel *lp = &hplabel[mi->mi_unit];
struct uba_regs *ubp = ui->ui_hd->uh_uba;
struct hpsoftc *sc = &hpsoftc[mi->mi_unit];
register int i;
caddr_t addr;
int reg, bit, byte, npf, mask, o, cmd, ubaddr;
int bn, cn, tn, sn;
int bcr;
/*
* Npf is the number of sectors transferred before the sector
* containing the ECC error, and reg is the UBA register
* mapping (the first part of) the transfer.
* O is offset within a memory page of the first byte transferred.
*/
bcr = -up->upwc * sizeof(short);
if (flag == CONT)
npf = bp->b_error;
else {
npf = bp->b_bcount - bcr;
/*
* Watch out for fractional sector at end of transfer;
* want to round up if finished, otherwise round down.
*/
if (bcr == 0)
npf += 511;
npf = btodb(npf);
}
reg = btop(um->um_ubinfo&0x3ffff) + npf;
o = (int)bp->b_un.b_addr & PGOFSET;
mask = up->upec2;
#ifdef UPECCDEBUG
if (upeccdebug)
log(LOG_DEBUG, "npf %d reg %x o %d mask %o pos %d\n",
npf, reg, o, mask, up->upec1);
#endif
bn = bp->b_blkno;
cn = bp->b_cylin;
sn = bn % lp->d_secpercyl + npf;
tn = sn / lp->d_nsectors;
sn %= lp->d_nsectors;
cn += tn / lp->d_ntracks;
tn %= lp->d_ntracks;
bn += npf;
ubapurge(um);
um->um_tab.b_active = 2;
/*
* action taken depends on the flag
*/
switch (flag) {
case ECC: {
register int i;
caddr_t addr;
struct pte mpte;
int bit, byte, mask;
npf--; /* because block in error is previous block */
bn--;
reg--;
if (bp->b_flags & B_BAD)
bn = sc->sc_badbn;
log(LOG_WARNING, "up%d%c: soft ecc sn%d\n", upunit(bp->b_dev),
'a' + uppart(bp->b_dev), bp->b_blkno + npf);
/*
* Flush the buffered data path, and compute the
* byte and bit position of the error. The variable i
* is the byte offset in the transfer, the variable byte
* is the offset from a page boundary in main memory.
*/
i = up->upec1 - 1; /* -1 makes 0 origin */
mask = up->upec2;
bit = i&07;
i = (i&~07)>>3;
byte = i + o;
/*
* Correct while possible bits remain of mask. Since mask
* contains 11 bits, we continue while the bit offset is > -11.
* Also watch out for end of this block and the end of the whole
* transfer.
*/
while (i < 512 && (int)dbtob(npf)+i < bp->b_bcount && bit > -11) {
struct pte pte;
pte = ubp->uba_map[reg + btop(byte)];
addr = ptob(pte.pg_pfnum) + (byte & PGOFSET);
#ifdef UPECCDEBUG
printf("addr %x map reg %x\n",
addr, *(int *)(&ubp->uba_map[reg+btop(byte)]));
printf("old: %x, ", getmemc(addr));
#endif
putmemc(addr, getmemc(addr)^(mask<<bit));
#ifdef UPECCDEBUG
printf("new: %x\n", getmemc(addr));
#endif
byte++;
i++;
bit -= 8;
}
if (bcr == 0)
return (0);
npf++;
reg++;
break;
}
case BSE:
if (sc->sc_state == OPENRAW)
return (0);
#ifdef UPBDEBUG
if (upbdebug)
log(LOG_DEBUG, "upecc, BSE: bn %d cn %d tn %d sn %d\n",
bn, cn, tn, sn);
#endif
if (bp->b_flags & B_BAD)
return (0);
/*
* if not in bad sector table, return 0
*/
if ((bn = isbad(&upbad[ui->ui_unit], cn, tn, sn)) < 0)
return(0);
/*
* flag this one as bad
*/
bp->b_flags |= B_BAD;
bp->b_error = npf + 1;
#ifdef UPBDEBUG
if (upbdebug)
log(LOG_DEBUG "BSE: restart at %d\n",npf+1);
#endif
bn = lp->d_ncylinders * lp->d_secpercyl -
lp->d_nsectors - 1 - bn;
sc->sc_badbn = bn;
fixregs:
cn = bn / lp->d_secpercyl;
sn = bn % lp->d_secpercyl;
tn = sn / lp->d_nsectors;
sn %= lp->d_nsectors;
bcr = bp->b_bcount - (int)ptob(npf);
bcr = MIN(bcr, 512);
up->upwc = -bcr;
#ifdef UPBDEBUG
if (upbdebug)
log(LOG_DEBUG, "revector to cn %d tn %d sn %d\n",
cn, tn, sn);
#endif
break;
case CONT:
#ifdef UPBDEBUG
if (upbdebug)
log(LOG_DEBUG, "upecc, CONT: bn %d cn %d tn %d sn %d\n",
bn, cn, tn, sn);
#endif
bp->b_flags &= ~B_BAD;
if ((int)ptob(npf) >= bp->b_bcount)
return (0);
up->upwc = -((bp->b_bcount - (int)ptob(npf)) / sizeof(short));
break;
}
if (up->upwc == 0) {
um->um_tab.b_active = 0; /* retry */
return (0);
}
/*
* Have to continue the transfer... clear the drive,
* and compute the position where the transfer is to continue.
* We have completed npf+1 sectors of the transfer already;
* restart at offset o of next sector (i.e. in UBA register reg+1).
*/
#ifdef notdef
up->uper1 = 0;
up->upcs1 |= UP_GO;
#else
up->upcs1 = UP_TRE|UP_IE|UP_DCLR|UP_GO;
up->updc = cn;
up->upda = (tn << 8) | sn;
ubaddr = (int)ptob(reg) + o;
up->upba = ubaddr;
cmd = (ubaddr >> 8) & 0x300;
cmd |= ((bp->b_flags&B_READ)?UP_RCOM:UP_WCOM)|UP_IE|UP_GO;
um->um_tab.b_errcnt = 0;
up->upcs1 = cmd;
#endif
sc->sc_blkdone = npf;
return (1);
}
/*
* Reset driver after UBA init.
* Cancel software state of all pending transfers
* and restart all units and the controller.
*/
upreset(uban)
int uban;
{
register struct uba_ctlr *um;
register struct uba_device *ui;
register sc21, unit;
for (sc21 = 0; sc21 < NSC; sc21++) {
if ((um = upminfo[sc21]) == 0 || um->um_ubanum != uban ||
um->um_alive == 0)
continue;
printf(" sc%d", sc21);
um->um_tab.b_active = 0;
um->um_tab.b_actf = um->um_tab.b_actl = 0;
up_softc[sc21].sc_recal = 0;
up_softc[sc21].sc_wticks = 0;
if (um->um_ubinfo) {
printf("<%d>", (um->um_ubinfo>>28)&0xf);
um->um_ubinfo = 0;
}
((struct updevice *)(um->um_addr))->upcs2 = UPCS2_CLR;
for (unit = 0; unit < NUP; unit++) {
if ((ui = updinfo[unit]) == 0)
continue;
if (ui->ui_alive == 0 || ui->ui_mi != um)
continue;
uputab[unit].b_active = 0;
(void) upustart(ui);
}
(void) upstart(um);
}
}
/*
* Wake up every second and if an interrupt is pending
* but nothing has happened increment a counter.
* If nothing happens for 20 seconds, reset the UNIBUS
* and begin anew.
*/
upwatch()
{
register struct uba_ctlr *um;
register sc21, unit;
register struct up_softc *sc;
timeout(upwatch, (caddr_t)0, hz);
for (sc21 = 0; sc21 < NSC; sc21++) {
um = upminfo[sc21];
if (um == 0 || um->um_alive == 0)
continue;
sc = &up_softc[sc21];
if (um->um_tab.b_active == 0) {
for (unit = 0; unit < NUP; unit++)
if (uputab[unit].b_active &&
updinfo[unit]->ui_mi == um)
goto active;
sc->sc_wticks = 0;
continue;
}
active:
sc->sc_wticks++;
if (sc->sc_wticks >= 20) {
sc->sc_wticks = 0;
printf("sc%d: lost interrupt\n", sc21);
ubareset(um->um_ubanum);
}
}
}
#define DBSIZE 20
updump(dev)
dev_t dev;
{
struct updevice *upaddr;
char *start;
int num, blk, unit;
struct size *sizes;
register struct uba_regs *uba;
register struct uba_device *ui;
register short *rp;
struct upst *st;
register int retry;
register struct disklabel *lp;
unit = upunit(dev);
if (unit >= NUP)
return (ENXIO);
#define phys(cast, addr) ((cast)((int)addr & 0x7fffffff))
ui = phys(struct uba_device *, updinfo[unit]);
if (ui == 0 || ui->ui_alive == 0)
return (ENXIO);
uba = phys(struct uba_hd *, ui->ui_hd)->uh_physuba;
ubainit(uba);
upaddr = (struct updevice *)ui->ui_physaddr;
DELAY(5000000);
num = maxfree;
upaddr->upcs2 = unit;
DELAY(100);
upaddr->upcs1 = UP_DCLR|UP_GO;
upaddr->upcs1 = UP_PRESET|UP_GO;
upaddr->upof = UPOF_FMT22;
retry = 0;
do {
DELAY(25);
if (++retry > 527)
break;
} while ((upaddr->upds & UP_RDY) == 0);
if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY)
return (EFAULT);
start = 0;
if (dumplo < 0)
return (EINVAL);
lp = &uplabel[unit];
/* should check uupart(dev) < lp->p_npartitions ? */
if (dumplo + num >= lp->d_partitions[uppart(dev)].p_size)
num = lp->d_partitions[uppart(dev)].p_size - dumplo;
while (num > 0) {
register struct pte *io;
register int i;
int blk, cn, sn, tn;
daddr_t bn;
blk = num > DBSIZE ? DBSIZE : num;
io = uba->uba_map;
for (i = 0; i < blk; i++)
*(int *)io++ = (btop(start)+i) | (1<<21) | UBAMR_MRV;
*(int *)io = 0;
bn = dumplo + btop(start);
cn = (bn + lp->d_partitions[hppart(dev)].p_offset) /
lp->d_secpercyl;
sn = bn % lp->d_secpercyl;
tn = sn / lp->d_nsectors;
sn = sn % lp->d_nsectors;
upaddr->updc = cn;
rp = (short *) &upaddr->upda;
*rp = (tn << 8) + sn;
*--rp = 0;
*--rp = -blk*NBPG / sizeof (short);
*--rp = UP_GO|UP_WCOM;
retry = 0;
do {
DELAY(25);
if (++retry > 527)
break;
} while ((upaddr->upcs1 & UP_RDY) == 0);
if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) {
printf("up%d: not ready", unit);
if ((upaddr->upds & UPDS_DREADY) != UPDS_DREADY) {
printf("\n");
return (EIO);
}
printf(" (flakey)\n");
}
if (upaddr->upds&UPDS_ERR)
return (EIO);
start += blk*NBPG;
num -= blk;
}
return (0);
}
upsize(dev)
dev_t dev;
{
register int unit = upunit(dev);
struct uba_device *ui;
if (unit >= NUP || (ui = updinfo[unit]) == 0 || ui->ui_alive == 0 ||
upsoftc[unit].sc_state != OPEN)
return (-1);
return ((int)uplabel[unit].d_partitions[uppart(dev)].p_size);
}
#ifdef COMPAT_42
/*
* Compatibility code to fake up pack label
* for unlabeled disks.
*/
struct size {
daddr_t nblocks;
int cyloff;
} up9300_sizes[8] = {
15884, 0, /* A=cyl 0 thru 26 */
33440, 27, /* B=cyl 27 thru 81 */
495520, 0, /* C=cyl 0 thru 814 */
15884, 562, /* D=cyl 562 thru 588 */
55936, 589, /* E=cyl 589 thru 680 */
81376, 681, /* F=cyl 681 thru 814 */
153728, 562, /* G=cyl 562 thru 814 */
291346, 82, /* H=cyl 82 thru 561 */
}, up9766_sizes[8] = {
15884, 0, /* A=cyl 0 thru 26 */
33440, 27, /* B=cyl 27 thru 81 */
500384, 0, /* C=cyl 0 thru 822 */
15884, 562, /* D=cyl 562 thru 588 */
55936, 589, /* E=cyl 589 thru 680 */
86240, 681, /* F=cyl 681 thru 822 */
158592, 562, /* G=cyl 562 thru 822 */
291346, 82, /* H=cyl 82 thru 561 */
}, up160_sizes[8] = {
15884, 0, /* A=cyl 0 thru 49 */
33440, 50, /* B=cyl 50 thru 154 */
263360, 0, /* C=cyl 0 thru 822 */
15884, 155, /* D=cyl 155 thru 204 */
55936, 205, /* E=cyl 205 thru 379 */
141664, 380, /* F=cyl 380 thru 822 */
213664, 155, /* G=cyl 155 thru 822 */
0, 0,
}, upam_sizes[8] = {
15884, 0, /* A=cyl 0 thru 31 */
33440, 32, /* B=cyl 32 thru 97 */
524288, 0, /* C=cyl 0 thru 1023 */
15884, 668, /* D=cyl 668 thru 699 */
55936, 700, /* E=cyl 700 thru 809 */
109472, 810, /* F=cyl 810 thru 1023 */
182176, 668, /* G=cyl 668 thru 1023 */
291346, 98, /* H=cyl 98 thru 667 */
}, up980_sizes[8] = {
15884, 0, /* A=cyl 0 thru 99 */
33440, 100, /* B=cyl 100 thru 308 */
131680, 0, /* C=cyl 0 thru 822 */
15884, 309, /* D=cyl 309 thru 408 */
55936, 409, /* E=cyl 409 thru 758 */
10080, 759, /* F=cyl 759 thru 822 */
82080, 309, /* G=cyl 309 thru 822 */
0, 0,
}, upeagle_sizes[8] = {
15884, 0, /* A=cyl 0 thru 16 */
66880, 17, /* B=cyl 17 thru 86 */
808320, 0, /* C=cyl 0 thru 841 */
15884, 391, /* D=cyl 391 thru 407 */
307200, 408, /* E=cyl 408 thru 727 */
109296, 728, /* F=cyl 728 thru 841 */
432816, 391, /* G=cyl 391 thru 841 */
291346, 87, /* H=cyl 87 thru 390 */
};
struct upst {
short nsect; /* # sectors/track */
short ntrak; /* # tracks/cylinder */
short nspc; /* # sectors/cylinder */
short ncyl; /* # cylinders */
struct size *sizes; /* partition tables */
short sdist; /* seek distance metric */
short rdist; /* rotational distance metric */
short mdist; /* min rotation (all guesswork) */
} upst[] = {
{ 32, 19, 32*19, 815, up9300_sizes, 3, 4, 1 }, /*9300*/
{ 32, 19, 32*19, 823, up9766_sizes, 3, 4, 1 }, /*9766*/
{ 32, 10, 32*10, 823, up160_sizes, 3, 4, 1 }, /*fuji160m*/
{ 32, 16, 32*16, 1024, upam_sizes, 7, 8, 2 }, /*Capricorn*/
{ 32, 5, 32*5, 823, up980_sizes, 3, 4, 1 }, /*DM980*/
{ 48, 20, 48*20, 842, upeagle_sizes, 15, 8, 3 }, /*EAGLE*/
{ 0, 0, 0, 0, 0, 0, 0, 0 }
};
/*
* These variable are all measured in sectors.
* Sdist is how much to "lead" in the search for a desired sector
* (i.e. if want N, search for N-sdist.)
* Maxdist and mindist define the region right before our desired sector within
* which we don't bother searching. We don't search when we are already less
* then maxdist and more than mindist sectors "before" our desired sector.
* Maxdist should be >= sdist.
*
* Beware, sdist, mindist and maxdist are not well tuned
* for many of the drives listed in this table.
* Try patching things with something i/o intensive
* running and watch iostat.
*/
/*
* Map apparent SC[23]1 drive type into manufacturer
* specific configuration.
*/
upmaptype(ui, lp)
register struct uba_device *ui;
register struct disklabel *lp;
{
register int type;
register struct upst *st;
upphysical(ui->ui_addr, lp); /* get the real drive numbers */
for (st = upst, type = 0; st->nsect != 0; st++, type++)
if (lp->d_ntracks == st->ntrak &&
lp->d_nsectors == st->nsect &&
lp->d_ncylinders == st->ncyl)
break;
if (st->nsect == 0) {
printf(": %dx%dx%d (s,t,c)?", lp->d_nsectors,
lp->d_ntracks, lp->d_ncylinders);
return (0);
}
ui->ui_type = type;
/*
* set up minimal disk label.
*/
st = &hpst[type];
lp->d_secsize = 512;
lp->d_nsectors = st->nsect;
lp->d_ntracks = st->ntrak;
lp->d_secpercyl = st->nspc;
lp->d_ncylinders = st->ncyl;
lp->d_secperunit = st->nspc * st->ncyl;
lp->d_sdist = st->sdist;
lp->d_mindist = st->rdist;
lp->d_maxdist = st->mdist;
bcopy(hpst[type].name, lp->d_typename, sizeof(lp->d_typename));
lp->d_npartitions = 8;
for (i = 0; i < 8; i++) {
lp->d_partitions[i].p_offset = st->sizes[i].cyloff *
lp->d_secpercyl;
lp->d_partitions[i].p_size = st->sizes[i].nblocks;
}
return (1);
}
#endif /* COMPAT_42 */
#endif /* NSC > 0 */