2.11BSD/sys/OTHERS/rm02.03.05/rm.c
/*
* Copyright (c) 1986 Regents of the University of California.
* All rights reserved. The Berkeley software License Agreement
* specifies the terms and conditions for redistribution.
*
* @(#)rm.c 1.2 (2.11BSD GTE) 1/2/93
*/
/*
* RJM02/RWM03, RM02/03/05 disk driver
* For simplicity we use hpreg.h instead of an rmreg.h. The bits
* are the same. Only the register names have been changed to
* protect the innocent.
*
* Added RM_RM05 #ifdef (RM_NTRAC gets updated) for RM05 type drive.
* Put this #define in the rm.h file.
*/
#include "rm.h"
#if NRM > 0
#include "param.h"
#include "systm.h"
#include "buf.h"
#include "conf.h"
#include "user.h"
#include "hpreg.h"
#ifdef RM_DUMP
#include "seg.h"
#endif
#include "uba.h"
#include "dkbad.h"
#include "dk.h"
#include "xp.h"
struct hpdevice *RMADDR = (struct hpdevice *)0176700;
#if NXPD > 0
extern struct size {
daddr_t nblocks;
int cyloff;
} rm_sizes[8];
#else !NXPD
struct size {
daddr_t nblocks;
int cyloff;
} rm_sizes[8] = {
4800, 0, /* cyl 0 - 29 */
4800, 30, /* cyl 30 - 59 */
122080, 60, /* cyl 60 - 822 */
62720, 60, /* cyl 60 - 451 */
59360, 452, /* cyl 452 - 822 */
0, 0, /* Not Defined */
0, 0, /* Not Defined */
131680, 0, /* cyl 0 - 822 */
};
#endif NXPD
int rm_offset[] =
{
HPOF_P400, HPOF_M400, HPOF_P400, HPOF_M400,
HPOF_P800, HPOF_M800, HPOF_P800, HPOF_M800,
HPOF_P1200, HPOF_M1200, HPOF_P1200, HPOF_M1200,
0, 0, 0, 0
};
#define RM_NSECT 32
#ifdef RM_RM05
#define RM_NTRAC 19 /* RM05 */
#else
#define RM_NTRAC 5 /* RM02/03 */
#endif
#define RM_NCYL 823
#define RM_SDIST 2
#define RM_RDIST 6
struct buf rmtab;
#if NRM > 1
struct buf rmutab[NRM];
#endif
#ifdef BADSECT
struct dkbad rmbad[NRM];
struct buf brmbuf[NRM];
bool_t rm_init[NRM];
#endif
#if NRM > 1
int rmcc[NRM]; /* Current cylinder */
#endif
void
rmroot()
{
rmattach(RMADDR, 0);
}
rmattach(addr, unit)
register struct hpdevice *addr;
{
if (unit != 0)
return(0);
if ((addr != (struct hpdevice *) NULL) && (fioword(addr) != -1)) {
RMADDR = addr;
if (fioword(&(addr->hpbae)) != -1)
rmtab.b_flags |= B_RH70;
return(1);
}
RMADDR = (struct hpdevice *) NULL;
return(0);
}
rmstrategy(bp)
register struct buf *bp;
{
register struct buf *dp;
register unit;
long bn;
unit = minor(bp->b_dev) & 077;
if (unit >= (NRM << 3) || (RMADDR == (struct hpdevice *) NULL)) {
bp->b_error = ENXIO;
goto errexit;
}
if (bp->b_blkno < 0 ||
(bn = dkblock(bp)) + (long) ((bp->b_bcount + 511) >> 9)
> rm_sizes[unit & 07].nblocks) {
bp->b_error = EINVAL;
errexit:
bp->b_flags |= B_ERROR;
iodone(bp);
return;
}
if ((rmtab.b_flags & B_RH70) == 0)
mapalloc(bp);
bp->b_cylin = bn / (RM_NSECT * RM_NTRAC) + rm_sizes[unit & 07].cyloff;
unit = dkunit(bp);
#if NRM > 1
dp = &rmutab[unit];
#else
dp = &rmtab;
#endif
(void) _spl5();
disksort(dp, bp);
if (dp->b_active == 0) {
#if NRM > 1
rmustart(unit);
if (rmtab.b_active == 0)
rmstart();
#else
rmstart();
#endif
}
(void) _spl0();
}
#if NRM > 1
rmustart(unit)
register unit;
{
register struct hpdevice *rmaddr = RMADDR;
register struct buf *dp;
struct buf *bp;
daddr_t bn;
int sn, cn, csn;
rmaddr->hpcs2.w = unit;
rmaddr->hpcs1.c[0] = HP_IE;
rmaddr->hpas = 1 << unit;
if (unit >= NRM)
return;
#ifdef RM_DKN
dk_busy &= ~(1 << (unit + RM_DKN));
#endif
dp = &rmutab[unit];
if ((bp=dp->b_actf) == NULL)
return;
/*
* If we have already positioned this drive,
* then just put it on the ready queue.
*/
if (dp->b_active)
goto done;
dp->b_active++;
/*
* If drive has just come up,
* set up the pack.
*/
#ifdef BADSECT
if (((rmaddr->hpds & HPDS_VV) == 0) || (rm_init[unit] == 0))
#else
if ((rmaddr->hpds & HPDS_VV) == 0)
#endif
{
#ifdef BADSECT
struct buf *bbp = &brmbuf[unit];
rm_init[unit] = 1;
#endif
/* SHOULD WARN SYSTEM THAT THIS HAPPENED */
rmaddr->hpcs1.c[0] = HP_IE | HP_PRESET | HP_GO;
rmaddr->hpof = HPOF_FMT22;
#ifdef BADSECT
bbp->b_flags = B_READ | B_BUSY | B_PHYS;
bbp->b_dev = bp->b_dev;
bbp->b_bcount = sizeof(struct dkbad);
bbp->b_un.b_addr = (caddr_t)&rmbad[unit];
bbp->b_blkno = (daddr_t)RM_NCYL * (RM_NSECT*RM_NTRAC)
- RM_NSECT;
bbp->b_cylin = RM_NCYL - 1;
if ((rmtab.b_flags & B_RH70) == 0)
mapalloc(bbp);
dp->b_actf = bbp;
bbp->av_forw = bp;
bp = bbp;
#endif BADSECT
}
/*
* If drive is offline, forget about positioning.
*/
if ((rmaddr->hpds & (HPDS_DPR | HPDS_MOL)) != (HPDS_DPR | HPDS_MOL))
goto done;
bn = dkblock(bp);
cn = bp->b_cylin;
sn = bn % (RM_NSECT * RM_NTRAC);
sn = (sn + RM_NSECT - RM_SDIST) % RM_NSECT;
if (rmcc[unit] != cn)
goto search;
csn = (rmaddr->hpla >> 6) - sn + RM_SDIST - 1;
if (csn < 0)
csn += RM_NSECT;
if (csn > RM_NSECT - RM_RDIST)
goto done;
search:
rmaddr->hpdc = cn;
rmaddr->hpda = sn;
rmaddr->hpcs1.c[0] = HP_IE | HP_SEARCH | HP_GO;
rmcc[unit] = cn;
/*
* Mark unit busy for iostat.
*/
#ifdef RM_DKN
unit += RM_DKN;
dk_busy |= 1 << unit;
dk_numb[unit]++;
#endif
return;
done:
/*
* Device is ready to go.
* Put it on the ready queue for the controller.
*/
dp->b_forw = NULL;
if (rmtab.b_actf == NULL)
rmtab.b_actf = dp;
else
rmtab.b_actl->b_forw = dp;
rmtab.b_actl = dp;
}
#endif
/*
* Start up a transfer on a drive.
*/
rmstart()
{
register struct hpdevice *rmaddr = RMADDR;
register struct buf *bp;
struct buf *dp;
register unit;
daddr_t bn;
int dn, sn, tn, cn;
loop:
/*
* Pull a request off the controller queue.
*/
#if NRM == 1
dp = &rmtab;
if ((bp = dp->b_actf) == NULL)
return;
#else
if ((dp = rmtab.b_actf) == NULL)
return;
if ((bp = dp->b_actf) == NULL) {
rmtab.b_actf = dp->b_forw;
goto loop;
}
#endif
/*
* Mark controller busy and
* determine destination of this request.
*/
rmtab.b_active++;
unit = minor(bp->b_dev) & 077;
dn = dkunit(bp);
/*
* Select drive.
*/
rmaddr->hpcs2.w = dn;
#if NRM == 1
/*
* If drive has just come up,
* set up the pack.
*/
#ifdef BADSECT
if (((rmaddr->hpds & HPDS_VV) == 0) || (rm_init[dn] == 0))
#else
if ((rmaddr->hpds & HPDS_VV) == 0)
#endif
{
#ifdef BADSECT
struct buf *bbp = &brmbuf[dn];
rm_init[dn] = 1;
#endif
/* SHOULD WARN SYSTEM THAT THIS HAPPENED */
rmaddr->hpcs1.c[0] = HP_IE | HP_PRESET | HP_GO;
rmaddr->hpof = HPOF_FMT22;
#ifdef BADSECT
bbp->b_flags = B_READ | B_BUSY | B_PHYS;
bbp->b_dev = bp->b_dev;
bbp->b_bcount = sizeof(struct dkbad);
bbp->b_un.b_addr = (caddr_t)&rmbad[dn];
bbp->b_blkno = (daddr_t)RM_NCYL * (RM_NSECT*RM_NTRAC)
- RM_NSECT;
bbp->b_cylin = RM_NCYL - 1;
if ((rmtab.b_flags & B_RH70) == 0)
mapalloc(bbp);
dp->b_actf = bbp;
bbp->av_forw = bp;
bp = bbp;
#endif BADSECT
}
#endif
bn = dkblock(bp);
cn = bp->b_cylin;
sn = bn % (RM_NSECT * RM_NTRAC);
tn = sn / RM_NSECT;
sn = sn % RM_NSECT;
/*
* Check that it is ready and online.
*/
if ((rmaddr->hpds & (HPDS_DPR | HPDS_MOL)) != (HPDS_DPR | HPDS_MOL)) {
rmtab.b_active = 0;
rmtab.b_errcnt = 0;
dp->b_actf = bp->av_forw;
bp->b_flags |= B_ERROR;
iodone(bp);
goto loop;
}
if (rmtab.b_errcnt >= 16 && (bp->b_flags & B_READ)) {
rmaddr->hpof = rm_offset[rmtab.b_errcnt & 017] | HPOF_FMT22;
rmaddr->hpcs1.w = HP_OFFSET | HP_GO;
while ((rmaddr->hpds & (HPDS_PIP | HPDS_DRY)) != HPDS_DRY)
;
}
rmaddr->hpdc = cn;
rmaddr->hpda = (tn << 8) + sn;
rmaddr->hpba = bp->b_un.b_addr;
if (rmtab.b_flags & B_RH70)
rmaddr->hpbae = bp->b_xmem;
rmaddr->hpwc = -(bp->b_bcount >> 1);
/*
* Warning: unit is being used as a temporary.
*/
unit = ((bp->b_xmem & 3) << 8) | HP_IE | HP_GO;
#ifdef RM_FORMAT
if (minor(bp->b_dev) & 0200)
unit |= bp->b_flags & B_READ? HP_RHDR : HP_WHDR;
else
unit |= bp->b_flags & B_READ? HP_RCOM : HP_WCOM;
#else
if (bp->b_flags & B_READ)
unit |= HP_RCOM;
else
unit |= HP_WCOM;
#endif
rmaddr->hpcs1.w = unit;
#ifdef RM_DKN
dk_busy |= 1 << (RM_DKN + NRM);
dk_numb[RM_DKN + NRM]++;
dk_wds[RM_DKN + NRM] += bp->b_bcount >> 6;
#endif
}
/*
* Handle a disk interrupt.
*/
rmintr()
{
register struct hpdevice *rmaddr = RMADDR;
register struct buf *bp, *dp;
short unit;
int as, i, j;
as = rmaddr->hpas & 0377;
if (rmtab.b_active) {
#ifdef RM_DKN
dk_busy &= ~(1 << (RM_DKN + NRM));
#endif
/*
* Get device and block structures. Select the drive.
*/
#if NRM > 1
dp = rmtab.b_actf;
#else
dp = &rmtab;
#endif
bp = dp->b_actf;
#ifdef BADSECT
if (bp->b_flags&B_BAD)
if (rmecc(bp, CONT))
return;
#endif
unit = dkunit(bp);
rmaddr->hpcs2.c[0] = unit;
/*
* Check for and process errors.
*/
if (rmaddr->hpcs1.w & HP_TRE) { /* error bit */
while ((rmaddr->hpds & HPDS_DRY) == 0)
;
if (rmaddr->hper1 & HPER1_WLE) {
/*
* Give up on write locked devices
* immediately.
*/
printf("rm%d: write locked\n", unit);
bp->b_flags |= B_ERROR;
#ifdef BADSECT
} else if (rmaddr->rmer2 & RMER2_BSE) {
#ifdef RM_FORMAT
/*
* Allow this error on format devices.
*/
if (minor(bp->b_dev) & 0200)
goto errdone;
#endif
if (rmecc(bp, BSE))
return;
else
goto hard;
#endif BADSECT
} else {
/*
* After 28 retries (16 without offset and
* 12 with offset positioning), give up.
*/
if (++rmtab.b_errcnt > 28) {
hard:
harderr(bp, "rm");
printf("cs2=%b er1=%b\n", rmaddr->hpcs2.w,
HPCS2_BITS, rmaddr->hper1, HPER1_BITS);
bp->b_flags |= B_ERROR;
} else
rmtab.b_active = 0;
}
/*
* If soft ecc, correct it (continuing
* by returning if necessary).
* Otherwise, fall through and retry the transfer.
*/
if((rmaddr->hper1 & (HPER1_DCK|HPER1_ECH)) == HPER1_DCK)
if (rmecc(bp, ECC))
return;
errdone:
rmaddr->hpcs1.w = HP_TRE | HP_IE | HP_DCLR | HP_GO;
if ((rmtab.b_errcnt & 07) == 4) {
rmaddr->hpcs1.w = HP_RECAL | HP_IE | HP_GO;
while ((rmaddr->hpds & (HPDS_PIP | HPDS_DRY)) != HPDS_DRY)
;
}
#if NRM > 1
rmcc[unit] = -1;
#endif
}
if (rmtab.b_active) {
if (rmtab.b_errcnt) {
rmaddr->hpcs1.w = HP_RTC | HP_GO;
while ((rmaddr->hpds & (HPDS_PIP | HPDS_DRY)) != HPDS_DRY)
;
}
rmtab.b_errcnt = 0;
#if NRM > 1
rmtab.b_active = 0;
rmtab.b_actf = dp->b_forw;
rmcc[unit] = bp->b_cylin;
#endif
dp->b_active = 0;
dp->b_actf = bp->b_actf;
bp->b_resid = - (rmaddr->hpwc << 1);
iodone(bp);
rmaddr->hpcs1.w = HP_IE;
#if NRM > 1
if (dp->b_actf)
rmustart(unit);
#endif
}
#if NRM > 1
as &= ~(1 << unit);
#endif
} else {
if (as == 0)
rmaddr->hpcs1.w = HP_IE;
rmaddr->hpcs1.c[1] = HP_TRE >> 8;
}
#if NRM > 1
for(unit = 0; unit < NRM; unit++)
if (as & (1 << unit))
rmustart(unit);
#endif
rmstart();
}
#define exadr(x,y) (((long)(x) << 16) | (unsigned)(y))
/*
* Correct an ECC error and restart the i/o to complete
* the transfer if necessary. This is quite complicated because
* the correction may be going to an odd memory address base
* and the transfer may cross a sector boundary.
*/
rmecc(bp, flag)
register struct buf *bp;
{
register struct hpdevice *rmaddr = RMADDR;
register unsigned byte;
ubadr_t bb, addr;
long wrong;
int bit, wc;
unsigned ndone, npx;
int ocmd;
int cn, tn, sn;
daddr_t bn;
struct ubmap *ubp;
int unit;
/*
* ndone is #bytes including the error
* which is assumed to be in the last disk page transferred.
*/
unit = dkunit(bp);
#ifdef BADSECT
if (flag == CONT) {
npx = bp->b_error;
bp->b_error = 0;
ndone = npx * NBPG;
wc = ((int)(ndone - bp->b_bcount)) / NBPW;
} else
#endif
{
wc = rmaddr->hpwc;
ndone = (wc * NBPW) + bp->b_bcount;
npx = ndone / NBPG;
}
ocmd = (rmaddr->hpcs1.w & ~HP_RDY) | HP_IE | HP_GO;
bb = exadr(bp->b_xmem, bp->b_un.b_addr);
bn = dkblock(bp);
cn = bp->b_cylin - bn / (RM_NSECT * RM_NTRAC);
bn += npx;
cn += bn / (RM_NSECT * RM_NTRAC);
sn = bn % (RM_NSECT * RM_NTRAC);
tn = sn / RM_NSECT;
sn %= RM_NSECT;
switch (flag) {
case ECC:
printf("rm%d%c: soft ecc bn %D\n",
unit, 'a' + (minor(bp->b_dev) & 07),
bp->b_blkno + (npx - 1));
wrong = rmaddr->hpec2;
if (wrong == 0) {
rmaddr->hpof = HPOF_FMT22;
rmaddr->hpcs1.w |= HP_IE;
return (0);
}
/*
* Compute the byte/bit position of the err
* within the last disk page transferred.
* Hpec1 is origin-1.
*/
byte = rmaddr->hpec1 - 1;
bit = byte & 07;
byte >>= 3;
byte += ndone - NBPG;
wrong <<= bit;
/*
* Correct until mask is zero or until end of transfer,
* whichever comes first.
*/
while (byte < bp->b_bcount && wrong != 0) {
addr = bb + byte;
if (bp->b_flags & (B_MAP|B_UBAREMAP)) {
/*
* Simulate UNIBUS map if UNIBUS transfer.
*/
ubp = UBMAP + ((addr >> 13) & 037);
addr = exadr(ubp->ub_hi, ubp->ub_lo)
+ (addr & 017777);
}
putmemc(addr, getmemc(addr) ^ (int) wrong);
byte++;
wrong >>= 8;
}
break;
#ifdef BADSECT
case BSE:
if ((bn = isbad(&rmbad[unit], cn, tn, sn)) < 0)
return(0);
bp->b_flags |= B_BAD;
bp->b_error = npx + 1;
bn = (daddr_t)RM_NCYL * (RM_NSECT * RM_NTRAC)
- RM_NSECT - 1 - bn;
cn = bn/(RM_NSECT * RM_NTRAC);
sn = bn%(RM_NSECT * RM_NTRAC);
tn = sn/RM_NSECT;
sn %= RM_NSECT;
#ifdef DEBUG
printf("revector to cn %d tn %d sn %d\n", cn, tn, sn);
#endif
wc = -(512 / NBPW);
break;
case CONT:
bp->b_flags &= ~B_BAD;
#ifdef DEBUG
printf("rmecc CONT: bn %D cn %d tn %d sn %d\n", bn, cn, tn, sn);
#endif
break;
#endif BADSECT
}
rmtab.b_active++;
if (wc == 0)
return (0);
/*
* Have to continue the transfer. Clear the drive
* and compute the position where the transfer is to continue.
* We have completed npx sectors of the transfer already.
*/
rmaddr->hpcs2.w = unit;
rmaddr->hpcs1.w = HP_TRE | HP_DCLR | HP_GO;
addr = bb + ndone;
rmaddr->hpdc = cn;
rmaddr->hpda = (tn << 8) + sn;
rmaddr->hpwc = wc;
rmaddr->hpba = (caddr_t)addr;
if (rmtab.b_flags & B_RH70)
rmaddr->hpbae = (short)(addr >> 16);
rmaddr->hpcs1.w = ocmd;
return (1);
}
#ifdef RM_DUMP
/*
* Dump routine for RM02/RM03.
* Dumps from dumplo to end of memory/end of disk section for minor(dev).
*/
#define DBSIZE 16 /* number of blocks to write */
rmdump(dev)
dev_t dev;
{
register struct hpdevice *rmaddr = RMADDR;
daddr_t bn, dumpsize;
long paddr;
register sn;
register count;
register struct ubmap *ubp;
if ((bdevsw[major(dev)].d_strategy != rmstrategy) /* paranoia */
|| ((dev=minor(dev)) > (NRM << 3)))
return(EINVAL);
dumpsize = rm_sizes[dev & 07].nblocks;
if ((dumplo < 0) || (dumplo >= dumpsize))
return(EINVAL);
dumpsize -= dumplo;
rmaddr->hpcs2.w = dev >> 3;
if ((rmaddr->hpds & HPDS_VV) == 0) {
rmaddr->hpcs1.w = HP_DCLR | HP_GO;
rmaddr->hpcs1.w = HP_PRESET | HP_GO;
rmaddr->hpof = HPOF_FMT22;
}
if ((rmaddr->hpds & (HPDS_DPR | HPDS_MOL)) != (HPDS_DPR | HPDS_MOL))
return(EFAULT);
dev &= 07;
ubp = &UBMAP[0];
for (paddr = 0L; dumpsize > 0; dumpsize -= count) {
count = dumpsize>DBSIZE? DBSIZE: dumpsize;
bn = dumplo + (paddr >> PGSHIFT);
rmaddr->hpdc = bn / (RM_NSECT*RM_NTRAC) + rm_sizes[dev].cyloff;
sn = bn % (RM_NSECT * RM_NTRAC);
rmaddr->hpda = ((sn / RM_NSECT) << 8) | (sn % RM_NSECT);
rmaddr->hpwc = -(count << (PGSHIFT - 1));
if (ubmap && ((rmtab.b_flags & B_RH70) == 0)) {
ubp->ub_lo = loint(paddr);
ubp->ub_hi = hiint(paddr);
rmaddr->hpba = 0;
rmaddr->hpcs1.w = HP_WCOM | HP_GO;
}
else
{
/*
* Non-UNIBUS map, or 11/70 RM03 (MASSBUS)
*/
rmaddr->hpba = loint(paddr);
if (rmtab.b_flags & B_RH70)
rmaddr->hpbae = hiint(paddr);
rmaddr->hpcs1.w = HP_WCOM | HP_GO | ((paddr >> 8) & (03 << 8));
}
while (rmaddr->hpcs1.w & HP_GO)
;
if (rmaddr->hpcs1.w & HP_TRE) {
if (rmaddr->hpcs2.w & HPCS2_NEM)
return(0); /* made it to end of memory */
return(EIO);
}
paddr += (DBSIZE << PGSHIFT);
}
return(0); /* filled disk minor dev */
}
#endif RM_DUMP
#endif NRM