field names
SCCS-vsn: sys/vax/mba/ht.c 4.8
SCCS-vsn: sys/vax/mba/mba.c 4.16
SCCS-vsn: sys/vax/uba/rk.c 4.24
SCCS-vsn: sys/vax/uba/tm.c 4.23
SCCS-vsn: sys/vax/uba/up.c 4.30
#if NHT > 0
/*
* TM03/TU?? tape driver
#if NHT > 0
/*
* TM03/TU?? tape driver
#include "../h/user.h"
#include "../h/map.h"
#include "../h/pte.h"
#include "../h/user.h"
#include "../h/map.h"
#include "../h/pte.h"
+#include "../h/mbareg.h"
+#include "../h/mbavar.h"
#include "../h/mtio.h"
#include "../h/ioctl.h"
#include "../h/cmap.h"
#include "../h/mtio.h"
#include "../h/ioctl.h"
#include "../h/cmap.h"
short httypes[] =
{ MBDT_TE16, MBDT_TU45, MBDT_TU77, 0 };
short httypes[] =
{ MBDT_TE16, MBDT_TU45, MBDT_TU77, 0 };
-struct mba_info *htinfo[NHT];
-int htdkinit(), htustart(), htndtint(), htdtint();
+struct mba_device *htinfo[NHT];
+int htdkinit(), htattach(), htslave(), htustart(), htndtint(), htdtint();
struct mba_driver htdriver =
struct mba_driver htdriver =
- { htdkinit, htustart, 0, htdtint, htndtint, httypes, htinfo };
+ { htattach, htslave, htustart, 0, htdtint, htndtint,
+ httypes, "ht", "tu", htinfo };
#define MASKREG(r) ((r) & 0xffff)
/* bits in minor device */
#define MASKREG(r) ((r) & 0xffff)
/* bits in minor device */
-#define HTUNIT(dev) (minor(dev)&03)
+#define TUUNIT(dev) (minor(dev)&03)
#define H_NOREWIND 04
#define H_1600BPI 08
#define H_NOREWIND 04
#define H_1600BPI 08
+#define HTUNIT(dev) (htunit[TUUNIT(dev)])
+
#define INF (daddr_t)1000000L /* a block number that wont exist */
struct ht_softc {
#define INF (daddr_t)1000000L /* a block number that wont exist */
struct ht_softc {
u_short sc_dsreg;
short sc_resid;
short sc_dens;
u_short sc_dsreg;
short sc_resid;
short sc_dens;
+ struct mba_device *sc_mi;
+ int sc_slave;
+} ht_softc[NTU];
+short htunit[NTU];
#define H_REWIND 4 /* last unit start was a rewind */
/*ARGSUSED*/
#define H_REWIND 4 /* last unit start was a rewind */
/*ARGSUSED*/
-htdkinit(mi)
- struct mba_info *mi;
+htattach(mi)
+ struct mba_device *mi;
+{
+
+}
+
+htslave(mi, ms)
+ struct mba_device *mi;
+ struct mba_slave *ms;
+ register struct ht_softc *sc = &ht_softc[ms->ms_unit];
+ sc->sc_mi = mi;
+ sc->sc_slave = ms->ms_slave;
+ htunit[ms->ms_unit] = mi->mi_unit;
int flag;
{
register int unit;
int flag;
{
register int unit;
- register struct mba_info *mi;
+ register struct mba_device *mi;
register struct ht_softc *sc;
register struct ht_softc *sc;
- unit = HTUNIT(dev);
- if (unit >= NHT || (sc = &ht_softc[unit])->sc_openf ||
- (mi = htinfo[unit]) == 0 || mi->mi_alive == 0) {
+ unit = TUUNIT(dev);
+ if (unit >= NTU || (sc = &ht_softc[unit])->sc_openf ||
+ (mi = htinfo[HTUNIT(dev)]) == 0 || mi->mi_alive == 0) {
u.u_error = ENXIO;
return;
}
u.u_error = ENXIO;
return;
}
}
sc->sc_dens =
((minor(dev)&H_1600BPI)?HTTC_1600BPI:HTTC_800BPI)|
}
sc->sc_dens =
((minor(dev)&H_1600BPI)?HTTC_1600BPI:HTTC_800BPI)|
- HTTC_PDP11|mi->mi_slave;
+ HTTC_PDP11|sc->sc_slave;
sc->sc_openf = 1;
sc->sc_blkno = (daddr_t)0;
sc->sc_nxrec = INF;
sc->sc_openf = 1;
sc->sc_blkno = (daddr_t)0;
sc->sc_nxrec = INF;
register dev_t dev;
register flag;
{
register dev_t dev;
register flag;
{
- register struct ht_softc *sc = &ht_softc[HTUNIT(dev)];
+ register struct ht_softc *sc = &ht_softc[TUUNIT(dev)];
if (flag == FWRITE || ((flag&FWRITE) && (sc->sc_flags&H_WRITTEN))) {
htcommand(dev, HT_WEOF, 1);
if (flag == FWRITE || ((flag&FWRITE) && (sc->sc_flags&H_WRITTEN))) {
htcommand(dev, HT_WEOF, 1);
bp = &chtbuf[HTUNIT(dev)];
(void) spl5();
while (bp->b_flags&B_BUSY) {
bp = &chtbuf[HTUNIT(dev)];
(void) spl5();
while (bp->b_flags&B_BUSY) {
+ if (bp->b_command == H_REWIND && bp->b_repcnt == 0 &&
+ (bp->b_flags&B_DONE))
+ break;
bp->b_flags |= B_WANTED;
sleep((caddr_t)bp, PRIBIO);
}
bp->b_flags |= B_WANTED;
sleep((caddr_t)bp, PRIBIO);
}
register struct buf *bp;
{
register int unit = HTUNIT(bp->b_dev);
register struct buf *bp;
{
register int unit = HTUNIT(bp->b_dev);
- register struct mba_info *mi = htinfo[unit];
+ register struct mba_device *mi = htinfo[unit];
register struct buf *dp;
bp->av_forw = NULL;
register struct buf *dp;
bp->av_forw = NULL;
- register struct mba_info *mi;
+ register struct mba_device *mi;
{
register struct htdevice *htaddr =
(struct htdevice *)mi->mi_drv;
register struct buf *bp = mi->mi_tab.b_actf;
{
register struct htdevice *htaddr =
(struct htdevice *)mi->mi_drv;
register struct buf *bp = mi->mi_tab.b_actf;
- int unit = HTUNIT(bp->b_dev);
+ int unit = TUUNIT(bp->b_dev);
register struct ht_softc *sc = &ht_softc[unit];
daddr_t blkno;
register struct ht_softc *sc = &ht_softc[unit];
daddr_t blkno;
*/
/*ARGSUSED*/
htdtint(mi, mbasr)
*/
/*ARGSUSED*/
htdtint(mi, mbasr)
- register struct mba_info *mi;
+ register struct mba_device *mi;
int mbasr;
{
register struct htdevice *htaddr = (struct htdevice *)mi->mi_drv;
int mbasr;
{
register struct htdevice *htaddr = (struct htdevice *)mi->mi_drv;
register struct ht_softc *sc;
int ds, er, mbs;
register struct ht_softc *sc;
int ds, er, mbs;
- sc = &ht_softc[HTUNIT(bp->b_dev)];
+ sc = &ht_softc[TUUNIT(bp->b_dev)];
ds = sc->sc_dsreg = MASKREG(htaddr->htds);
er = sc->sc_erreg = MASKREG(htaddr->hter);
sc->sc_resid = MASKREG(htaddr->htfc);
ds = sc->sc_dsreg = MASKREG(htaddr->htds);
er = sc->sc_erreg = MASKREG(htaddr->hter);
sc->sc_resid = MASKREG(htaddr->htfc);
er && ++mi->mi_tab.b_errcnt >= 7) {
if ((ds & HTDS_MOL) == 0 && sc->sc_openf > 0)
sc->sc_openf = -1;
er && ++mi->mi_tab.b_errcnt >= 7) {
if ((ds & HTDS_MOL) == 0 && sc->sc_openf > 0)
sc->sc_openf = -1;
- printf("ht%d: hard error bn%d mbasr=%b er=%b\n",
- HTUNIT(bp->b_dev), bp->b_blkno,
+ printf("tu%d: hard error bn%d mbasr=%b er=%b\n",
+ TUUNIT(bp->b_dev), bp->b_blkno,
mbasr, mbasr_bits,
MASKREG(htaddr->hter), HTER_BITS);
bp->b_flags |= B_ERROR;
mbasr, mbasr_bits,
MASKREG(htaddr->hter), HTER_BITS);
bp->b_flags |= B_ERROR;
* non-data-transfer interrupt
*/
htndtint(mi)
* non-data-transfer interrupt
*/
htndtint(mi)
- register struct mba_info *mi;
+ register struct mba_device *mi;
{
register struct htdevice *htaddr = (struct htdevice *)mi->mi_drv;
register struct buf *bp = mi->mi_tab.b_actf;
register struct ht_softc *sc;
int er, ds, fc;
{
register struct htdevice *htaddr = (struct htdevice *)mi->mi_drv;
register struct buf *bp = mi->mi_tab.b_actf;
register struct ht_softc *sc;
int er, ds, fc;
- sc = &ht_softc[HTUNIT(bp->b_dev)];
+ if (bp == 0)
+ return (MBN_SKIP);
+ sc = &ht_softc[TUUNIT(bp->b_dev)];
ds = sc->sc_dsreg = MASKREG(htaddr->htds);
er = sc->sc_erreg = MASKREG(htaddr->hter);
fc = sc->sc_resid = MASKREG(htaddr->htfc);
ds = sc->sc_dsreg = MASKREG(htaddr->htds);
er = sc->sc_erreg = MASKREG(htaddr->hter);
fc = sc->sc_resid = MASKREG(htaddr->htfc);
htaddr->htcs1 = HT_DCLR|HT_GO;
mbclrattn(mi);
}
htaddr->htcs1 = HT_DCLR|HT_GO;
mbclrattn(mi);
}
- if (bp == &chtbuf[HTUNIT(bp->b_dev)]) {
+ if (sc->sc_flags&H_REWIND) {
+ sc->sc_flags &= ~H_REWIND;
+ return (MBN_CONT);
+ }
+ if (bp == &chtbuf[TUUNIT(bp->b_dev)]) {
if (bp->b_command == HT_REWOFFL)
/* offline is on purpose; don't do anything special */
ds |= HTDS_MOL;
if (bp->b_command == HT_REWOFFL)
/* offline is on purpose; don't do anything special */
ds |= HTDS_MOL;
if ((ds & (HTDS_ERR|HTDS_MOL)) != HTDS_MOL) {
if ((ds & HTDS_MOL) == 0 && sc->sc_openf > 0)
sc->sc_openf = -1;
if ((ds & (HTDS_ERR|HTDS_MOL)) != HTDS_MOL) {
if ((ds & HTDS_MOL) == 0 && sc->sc_openf > 0)
sc->sc_openf = -1;
- printf("ht%d: hard error bn%d er=%b ds=%b\n",
- HTUNIT(bp->b_dev), bp->b_blkno,
+ printf("tu%d: hard error bn%d er=%b ds=%b\n",
+ TUUNIT(bp->b_dev), bp->b_blkno,
sc->sc_erreg, HTER_BITS, sc->sc_dsreg, HTDS_BITS);
bp->b_flags |= B_ERROR;
return (MBN_DONE);
}
sc->sc_erreg, HTER_BITS, sc->sc_dsreg, HTDS_BITS);
bp->b_flags |= B_ERROR;
return (MBN_DONE);
}
- if (bp == &chtbuf[HTUNIT(bp->b_dev)]) {
+ if (bp == &chtbuf[TUUNIT(bp->b_dev)]) {
if (sc->sc_flags & H_REWIND)
return (ds & HTDS_BOT ? MBN_DONE : MBN_RETRY);
bp->b_resid = -sc->sc_resid;
if (sc->sc_flags & H_REWIND)
return (ds & HTDS_BOT ? MBN_DONE : MBN_RETRY);
bp->b_resid = -sc->sc_resid;
- register struct mba_info *mi;
+ register struct mba_device *mi;
register struct mba_regs *mp;
register struct htdevice *htaddr;
int blk, num;
register struct mba_regs *mp;
register struct htdevice *htaddr;
int blk, num;
#define phys(a,b) ((b)((int)(a)&0x7fffffff))
if (htinfo[0] == 0)
return (ENXIO);
#define phys(a,b) ((b)((int)(a)&0x7fffffff))
if (htinfo[0] == 0)
return (ENXIO);
- mi = phys(htinfo[0], struct mba_info *);
+ mi = phys(htinfo[0], struct mba_device *);
mp = phys(mi->mi_hd, struct mba_hd *)->mh_physmba;
#if VAX780
if (cpu == VAX780)
mp = phys(mi->mi_hd, struct mba_hd *)->mh_physmba;
#if VAX780
if (cpu == VAX780)
-/* mba.c 4.15 81/03/06 */
+/* mba.c 4.16 81/03/07 */
#include "mba.h"
#if NMBA > 0
#include "mba.h"
#if NMBA > 0
#include "../h/proc.h"
#include "../h/map.h"
#include "../h/pte.h"
#include "../h/proc.h"
#include "../h/map.h"
#include "../h/pte.h"
+#include "../h/mbareg.h"
+#include "../h/mbavar.h"
#include "../h/mtpr.h"
#include "../h/vm.h"
char mbasr_bits[] = MBASR_BITS;
/*
* Start activity on a massbus device.
#include "../h/mtpr.h"
#include "../h/vm.h"
char mbasr_bits[] = MBASR_BITS;
/*
* Start activity on a massbus device.
- * We are given the device's mba_info structure and activate
+ * We are given the device's mba_device structure and activate
* the device via the unit start routine. The unit start
* routine may indicate that it is finished (e.g. if the operation
* was a ``sense'' on a tape drive), that the (multi-ported) unit
* the device via the unit start routine. The unit start
* routine may indicate that it is finished (e.g. if the operation
* was a ``sense'' on a tape drive), that the (multi-ported) unit
* set up a data transfer operation and we should start the massbus adaptor.
*/
mbustart(mi)
* set up a data transfer operation and we should start the massbus adaptor.
*/
mbustart(mi)
- register struct mba_info *mi;
+ register struct mba_device *mi;
{
register struct buf *bp; /* i/o operation at head of queue */
register struct mba_hd *mhp; /* header for mba device is on */
{
register struct buf *bp; /* i/o operation at head of queue */
register struct mba_hd *mhp; /* header for mba device is on */
case MBU_DODATA: /* all ready to do data transfer */
/*
case MBU_DODATA: /* all ready to do data transfer */
/*
- * Queue the device mba_info structure on the massbus
+ * Queue the device mba_device structure on the massbus
* mba_hd structure for processing as soon as the
* data path is available.
*/
* mba_hd structure for processing as soon as the
* data path is available.
*/
mbstart(mhp)
register struct mba_hd *mhp;
{
mbstart(mhp)
register struct mba_hd *mhp;
{
- register struct mba_info *mi;
+ register struct mba_device *mi;
struct buf *bp;
register struct mba_regs *mbp;
struct buf *bp;
register struct mba_regs *mbp;
* we screwed up, and can't really do the operation.
*/
if ((mi->mi_drv->mbd_ds & (MBD_DPR|MBD_MOL)) != (MBD_DPR|MBD_MOL)) {
* we screwed up, and can't really do the operation.
*/
if ((mi->mi_drv->mbd_ds & (MBD_DPR|MBD_MOL)) != (MBD_DPR|MBD_MOL)) {
- printf("%c%d: not ready\n", mi->mi_name, dkunit(bp));
+ printf("%s%d: not ready\n", mi->mi_driver->md_dname,
+ dkunit(bp));
mi->mi_tab.b_actf = bp->av_forw;
mi->mi_tab.b_errcnt = 0;
mi->mi_tab.b_active = 0;
mi->mi_tab.b_actf = bp->av_forw;
mi->mi_tab.b_errcnt = 0;
mi->mi_tab.b_active = 0;
{
register struct mba_hd *mhp = &mba_hd[mbanum];
register struct mba_regs *mbp = mhp->mh_mba;
{
register struct mba_hd *mhp = &mba_hd[mbanum];
register struct mba_regs *mbp = mhp->mh_mba;
- register struct mba_info *mi;
+ register struct mba_device *mi;
register struct buf *bp;
register int drive;
int mbasr, as;
register struct buf *bp;
register int drive;
int mbasr, as;
while (drive = ffs(as)) {
drive--; /* was 1 origin */
as &= ~(1 << drive);
while (drive = ffs(as)) {
drive--; /* was 1 origin */
as &= ~(1 << drive);
+ mi = mhp->mh_mbip[drive];
+ if (mi == NULL)
+ continue;
- * driver has a handler for non-data transfer
+ * If driver has a handler for non-data transfer
* interrupts, give it a chance to tell us that
* the operation needs to be redone
*/
* interrupts, give it a chance to tell us that
* the operation needs to be redone
*/
- mi = mhp->mh_mbip[drive];
- if (mi == NULL)
- continue;
if (mi->mi_driver->md_ndint) {
mi->mi_tab.b_active = 0;
switch ((*mi->mi_driver->md_ndint)(mi)) {
if (mi->mi_driver->md_ndint) {
mi->mi_tab.b_active = 0;
switch ((*mi->mi_driver->md_ndint)(mi)) {
* completed i/o request's processing.
*/
mi->mi_tab.b_errcnt = 0;
* completed i/o request's processing.
*/
mi->mi_tab.b_errcnt = 0;
+ bp = mi->mi_tab.b_actf;
mi->mi_tab.b_actf = bp->av_forw;
iodone(bp);
/* fall into... */
mi->mi_tab.b_actf = bp->av_forw;
iodone(bp);
/* fall into... */
+ case MBN_SKIP:
+ /*
+ * Ignore (unsolicited interrupt, e.g.)
+ */
+ break;
+
+ case MBN_CONT:
+ /*
+ * Continue with unit active, e.g.
+ * between first and second rewind
+ * interrupts.
+ */
+ mi->mi_tab.b_active = 1;
+ break;
+
default:
panic("mbintr");
}
default:
panic("mbintr");
}
* Setup the mapping registers for a transfer.
*/
mbasetup(mi)
* Setup the mapping registers for a transfer.
*/
mbasetup(mi)
- register struct mba_info *mi;
+ register struct mba_device *mi;
{
register struct mba_regs *mbap = mi->mi_mba;
struct buf *bp = mi->mi_tab.b_actf;
{
register struct mba_regs *mbap = mi->mi_mba;
struct buf *bp = mi->mi_tab.b_actf;
#include "../h/pte.h"
#include "../h/map.h"
#include "../h/vm.h"
#include "../h/pte.h"
#include "../h/map.h"
#include "../h/vm.h"
+#include "../h/ubareg.h"
+#include "../h/ubavar.h"
#include "../h/dk.h"
#include "../h/cpu.h"
#include "../h/cmap.h"
#include "../h/dk.h"
#include "../h/cpu.h"
#include "../h/cmap.h"
/* END OF STUFF WHICH SHOULD BE READ IN PER DISK */
int rkprobe(), rkslave(), rkattach(), rkdgo(), rkintr();
/* END OF STUFF WHICH SHOULD BE READ IN PER DISK */
int rkprobe(), rkslave(), rkattach(), rkdgo(), rkintr();
-struct uba_minfo *rkminfo[NHK];
-struct uba_dinfo *rkdinfo[NRK];
-struct uba_dinfo *rkip[NHK][4];
+struct uba_ctlr *rkminfo[NHK];
+struct uba_device *rkdinfo[NRK];
+struct uba_device *rkip[NHK][4];
u_short rkstd[] = { 0777440, 0 };
struct uba_driver hkdriver =
u_short rkstd[] = { 0777440, 0 };
struct uba_driver hkdriver =
caddr_t reg;
{
register struct rkdevice *rkaddr = (struct rkdevice *)reg;
caddr_t reg;
{
register struct rkdevice *rkaddr = (struct rkdevice *)reg;
- register struct uba_dinfo *ui;
+ register struct uba_device *ui;
rkstrategy(bp)
register struct buf *bp;
{
rkstrategy(bp)
register struct buf *bp;
{
- register struct uba_dinfo *ui;
+ register struct uba_device *ui;
register struct rkst *st;
register int unit;
register struct buf *dp;
register struct rkst *st;
register int unit;
register struct buf *dp;
- register struct uba_dinfo *ui;
+ register struct uba_device *ui;
{
register struct buf *bp, *dp;
{
register struct buf *bp, *dp;
- register struct uba_minfo *um;
+ register struct uba_ctlr *um;
register struct rkdevice *rkaddr;
register struct rkst *st;
daddr_t bn;
register struct rkdevice *rkaddr;
register struct rkst *st;
daddr_t bn;
- register struct uba_minfo *um;
+ register struct uba_ctlr *um;
{
register struct buf *bp, *dp;
{
register struct buf *bp, *dp;
- register struct uba_dinfo *ui;
+ register struct uba_device *ui;
register struct rkdevice *rkaddr;
struct rkst *st;
daddr_t bn;
register struct rkdevice *rkaddr;
struct rkst *st;
daddr_t bn;
- register struct uba_minfo *um;
+ register struct uba_ctlr *um;
{
register struct rkdevice *rkaddr = (struct rkdevice *)um->um_addr;
{
register struct rkdevice *rkaddr = (struct rkdevice *)um->um_addr;
- register struct uba_minfo *um = rkminfo[rk11];
- register struct uba_dinfo *ui;
+ register struct uba_ctlr *um = rkminfo[rk11];
+ register struct uba_device *ui;
register struct rkdevice *rkaddr = (struct rkdevice *)um->um_addr;
register struct buf *bp, *dp;
int unit;
register struct rkdevice *rkaddr = (struct rkdevice *)um->um_addr;
register struct buf *bp, *dp;
int unit;
as &= ~(1<<ui->ui_slave);
}
for (unit = 0; as; as >>= 1, unit++)
as &= ~(1<<ui->ui_slave);
}
for (unit = 0; as; as >>= 1, unit++)
- if (as & 1)
- if (rkustart(rkip[rk11][unit]))
- needie = 0;
+ if (as & 1) {
+ ui = rkip[rk11][unit];
+ if (ui) {
+ if (rkustart(rkip[rk11][unit]))
+ needie = 0;
+ } else {
+ rkaddr->rkcs1 = RK_CERR|RK_CDT;
+ rkaddr->rkcs2 = unit;
+ rkaddr->rkcs1 = RK_CDT|RK_DCLR|RK_GO;
+ rkwait(rkaddr);
+ }
+ }
if (um->um_tab.b_actf && um->um_tab.b_active == 0)
if (rkstart(um))
needie = 0;
if (um->um_tab.b_actf && um->um_tab.b_active == 0)
if (rkstart(um))
needie = 0;
- register struct uba_dinfo *ui;
+ register struct uba_device *ui;
{
register struct rkdevice *rk = (struct rkdevice *)ui->ui_addr;
register struct buf *bp = rkutab[ui->ui_unit].b_actf;
{
register struct rkdevice *rk = (struct rkdevice *)ui->ui_addr;
register struct buf *bp = rkutab[ui->ui_unit].b_actf;
- register struct uba_minfo *um = ui->ui_mi;
+ register struct uba_ctlr *um = ui->ui_mi;
register struct rkst *st;
struct uba_regs *ubp = ui->ui_hd->uh_uba;
register int i;
register struct rkst *st;
struct uba_regs *ubp = ui->ui_hd->uh_uba;
register int i;
rkreset(uban)
int uban;
{
rkreset(uban)
int uban;
{
- register struct uba_minfo *um;
- register struct uba_dinfo *ui;
+ register struct uba_ctlr *um;
+ register struct uba_device *ui;
register rk11, unit;
for (rk11 = 0; rk11 < NHK; rk11++) {
register rk11, unit;
for (rk11 = 0; rk11 < NHK; rk11++) {
- register struct uba_minfo *um;
+ register struct uba_ctlr *um;
register rk11, unit;
register struct rk_softc *sc;
register rk11, unit;
register struct rk_softc *sc;
int num, blk, unit;
struct size *sizes;
register struct uba_regs *uba;
int num, blk, unit;
struct size *sizes;
register struct uba_regs *uba;
- register struct uba_dinfo *ui;
+ register struct uba_device *ui;
register short *rp;
struct rkst *st;
register short *rp;
struct rkst *st;
if (unit >= NRK)
return (ENXIO);
#define phys(cast, addr) ((cast)((int)addr & 0x7fffffff))
if (unit >= NRK)
return (ENXIO);
#define phys(cast, addr) ((cast)((int)addr & 0x7fffffff))
- ui = phys(struct uba_dinfo *, rkdinfo[unit]);
+ ui = phys(struct uba_device *, rkdinfo[unit]);
if (ui->ui_alive == 0)
return (ENXIO);
uba = phys(struct uba_hd *, ui->ui_hd)->uh_physuba;
if (ui->ui_alive == 0)
return (ENXIO);
uba = phys(struct uba_hd *, ui->ui_hd)->uh_physuba;
blk = num > DBSIZE ? DBSIZE : num;
io = uba->uba_map;
for (i = 0; i < blk; i++)
blk = num > DBSIZE ? DBSIZE : num;
io = uba->uba_map;
for (i = 0; i < blk; i++)
- *(int *)io++ = (btop(start)+i) | (1<<21) | UBA_MRV;
+ *(int *)io++ = (btop(start)+i) | (1<<21) | UBAMR_MRV;
*(int *)io = 0;
bn = dumplo + btop(start);
cn = bn/st->nspc + sizes[minor(dev)&07].cyloff;
*(int *)io = 0;
bn = dumplo + btop(start);
cn = bn/st->nspc + sizes[minor(dev)&07].cyloff;
#include "te.h"
#if NTM > 0
#include "te.h"
#if NTM > 0
#include "../h/map.h"
#include "../h/pte.h"
#include "../h/vm.h"
#include "../h/map.h"
#include "../h/pte.h"
#include "../h/vm.h"
+#include "../h/ubareg.h"
+#include "../h/ubavar.h"
#include "../h/mtio.h"
#include "../h/ioctl.h"
#include "../h/cmap.h"
#include "../h/mtio.h"
#include "../h/ioctl.h"
#include "../h/cmap.h"
struct buf rtmbuf[NTE];
int tmprobe(), tmslave(), tmattach(), tmdgo(), tmintr();
struct buf rtmbuf[NTE];
int tmprobe(), tmslave(), tmattach(), tmdgo(), tmintr();
-struct uba_minfo *tmminfo[NTM];
-struct uba_dinfo *tmdinfo[NTE];
+struct uba_ctlr *tmminfo[NTM];
+struct uba_device *tmdinfo[NTE];
struct buf tmutab[NTE];
#ifdef notyet
struct buf tmutab[NTE];
#ifdef notyet
-struct uba_dinfo *tmip[NTM][4];
+struct uba_device *tmip[NTM][4];
#endif
u_short tmstd[] = { 0772520, 0 };
struct uba_driver tmdriver =
#endif
u_short tmstd[] = { 0772520, 0 };
struct uba_driver tmdriver =
*/
/*ARGSUSED*/
tmslave(ui, reg)
*/
/*ARGSUSED*/
tmslave(ui, reg)
*/
/*ARGSUSED*/
tmattach(ui)
*/
/*ARGSUSED*/
tmattach(ui)
int flag;
{
register int unit;
int flag;
{
register int unit;
- register struct uba_dinfo *ui;
+ register struct uba_device *ui;
register struct tm_softc *sc;
unit = TMUNIT(dev);
register struct tm_softc *sc;
unit = TMUNIT(dev);
register struct buf *bp;
{
int unit = TMUNIT(bp->b_dev);
register struct buf *bp;
{
int unit = TMUNIT(bp->b_dev);
- register struct uba_minfo *um;
+ register struct uba_ctlr *um;
register struct buf *dp;
register struct tm_softc *sc = &tm_softc[unit];
register struct buf *dp;
register struct tm_softc *sc = &tm_softc[unit];
* Start activity on a tm controller.
*/
tmstart(um)
* Start activity on a tm controller.
*/
tmstart(um)
- register struct uba_minfo *um;
+ register struct uba_ctlr *um;
{
register struct buf *bp, *dp;
register struct device *addr = (struct device *)um->um_addr;
register struct tm_softc *sc;
{
register struct buf *bp, *dp;
register struct device *addr = (struct device *)um->um_addr;
register struct tm_softc *sc;
- register struct uba_dinfo *ui;
+ register struct uba_device *ui;
int unit, cmd;
daddr_t blkno;
int unit, cmd;
daddr_t blkno;
* allocated to us; start the device.
*/
tmdgo(um)
* allocated to us; start the device.
*/
tmdgo(um)
- register struct uba_minfo *um;
+ register struct uba_ctlr *um;
{
register struct device *addr = (struct device *)um->um_addr;
{
register struct device *addr = (struct device *)um->um_addr;
{
struct buf *dp;
register struct buf *bp;
{
struct buf *dp;
register struct buf *bp;
- register struct uba_minfo *um = tmminfo[tm11];
+ register struct uba_ctlr *um = tmminfo[tm11];
register struct device *addr = (struct device *)tmdinfo[tm11]->ui_addr;
register struct tm_softc *sc;
int unit;
register struct device *addr = (struct device *)tmdinfo[tm11]->ui_addr;
register struct tm_softc *sc;
int unit;
+ if (u.u_error)
+ return;
physio(tmstrategy, &rtmbuf[TMUNIT(dev)], dev, B_READ, minphys);
}
physio(tmstrategy, &rtmbuf[TMUNIT(dev)], dev, B_READ, minphys);
}
+ if (u.u_error)
+ return;
physio(tmstrategy, &rtmbuf[TMUNIT(dev)], dev, B_WRITE, minphys);
}
tmphys(dev)
dev_t dev;
{
physio(tmstrategy, &rtmbuf[TMUNIT(dev)], dev, B_WRITE, minphys);
}
tmphys(dev)
dev_t dev;
{
+ register int unit = TMUNIT(dev);
- register struct tm_softc *sc = &tm_softc[TMUNIT(dev)];
+ register struct tm_softc *sc;
+ if (unit >= NTM) {
+ u.u_error = ENXIO;
+ return;
+ }
+ sc = &tm_softc[TMUNIT(dev)];
a = dbtofsb(u.u_offset >> 9);
sc->sc_blkno = a;
sc->sc_nxrec = a + 1;
a = dbtofsb(u.u_offset >> 9);
sc->sc_blkno = a;
sc->sc_nxrec = a + 1;
tmreset(uban)
int uban;
{
tmreset(uban)
int uban;
{
- register struct uba_minfo *um;
+ register struct uba_ctlr *um;
- register struct uba_dinfo *ui;
+ register struct uba_device *ui;
register struct buf *dp;
for (tm11 = 0; tm11 < NTM; tm11++) {
register struct buf *dp;
for (tm11 = 0; tm11 < NTM; tm11++) {
- register struct uba_dinfo *ui;
+ register struct uba_device *ui;
register struct uba_regs *up;
register struct device *addr;
int blk, num;
register struct uba_regs *up;
register struct device *addr;
int blk, num;
#define phys(a,b) ((b)((int)(a)&0x7fffffff))
if (tmdinfo[0] == 0)
return (ENXIO);
#define phys(a,b) ((b)((int)(a)&0x7fffffff))
if (tmdinfo[0] == 0)
return (ENXIO);
- ui = phys(tmdinfo[0], struct uba_dinfo *);
+ ui = phys(tmdinfo[0], struct uba_device *);
up = phys(ui->ui_hd, struct uba_hd *)->uh_physuba;
#if VAX780
if (cpu == VAX_780)
up = phys(ui->ui_hd, struct uba_hd *)->uh_physuba;
#if VAX780
if (cpu == VAX_780)
io = up->uba_map;
npf = num+1;
while (--npf != 0)
io = up->uba_map;
npf = num+1;
while (--npf != 0)
- *(int *)io++ = (dbuf++ | (1<<UBA_DPSHIFT) | UBA_MRV);
+ *(int *)io++ = (dbuf++ | (1<<UBAMR_DPSHIFT) | UBAMR_MRV);
*(int *)io = 0;
addr->tmbc = -(num*NBPG);
addr->tmba = 0;
*(int *)io = 0;
addr->tmbc = -(num*NBPG);
addr->tmba = 0;
-/* up.c 4.29 81/03/06 */
+/* up.c 4.30 81/03/07 */
#include "up.h"
#if NSC > 0
#include "up.h"
#if NSC > 0
* UNIBUS disk driver with overlapped seeks and ECC recovery.
*
* TODO:
* UNIBUS disk driver with overlapped seeks and ECC recovery.
*
* TODO:
- * Check out handling of spun-down drives and write lock
* Add reading of bad sector information and disk layout from sector 1
* Add bad sector forwarding code
* Check multiple drive handling
* Add reading of bad sector information and disk layout from sector 1
* Add bad sector forwarding code
* Check multiple drive handling
* Check unibus reset code
* Check unibus reset code
+ * Check that offset recovery code, etc works
*/
#define DELAY(N) { register int d; d = N; while (--d > 0); }
*/
#define DELAY(N) { register int d; d = N; while (--d > 0); }
#include "../h/pte.h"
#include "../h/mtpr.h"
#include "../h/vm.h"
#include "../h/pte.h"
#include "../h/mtpr.h"
#include "../h/vm.h"
+#include "../h/ubavar.h"
+#include "../h/ubareg.h"
#include "../h/cmap.h"
#include "../h/upreg.h"
#include "../h/cmap.h"
#include "../h/upreg.h"
int upRDIST = _upRDIST;
int upprobe(), upslave(), upattach(), updgo(), upintr();
int upRDIST = _upRDIST;
int upprobe(), upslave(), upattach(), updgo(), upintr();
-struct uba_minfo *upminfo[NSC];
-struct uba_dinfo *updinfo[NUP];
-struct uba_dinfo *upip[NSC][4];
+struct uba_ctlr *upminfo[NSC];
+struct uba_device *updinfo[NUP];
+struct uba_device *upip[NSC][4];
u_short upstd[] = { 0776700, 0774400, 0776300, 0 };
struct uba_driver scdriver =
u_short upstd[] = { 0776700, 0774400, 0776300, 0 };
struct uba_driver scdriver =
caddr_t reg;
{
register struct updevice *upaddr = (struct updevice *)reg;
caddr_t reg;
{
register struct updevice *upaddr = (struct updevice *)reg;
- register struct uba_dinfo *ui;
+ register struct uba_device *ui;
{
#ifdef notdef
register struct updevice *upaddr;
{
#ifdef notdef
register struct updevice *upaddr;
upstrategy(bp)
register struct buf *bp;
{
upstrategy(bp)
register struct buf *bp;
{
- register struct uba_dinfo *ui;
+ register struct uba_device *ui;
register struct upst *st;
register int unit;
register struct buf *dp;
register struct upst *st;
register int unit;
register struct buf *dp;
* positioning forever without transferrring.)
*/
upustart(ui)
* positioning forever without transferrring.)
*/
upustart(ui)
- register struct uba_dinfo *ui;
+ register struct uba_device *ui;
{
register struct buf *bp, *dp;
{
register struct buf *bp, *dp;
- register struct uba_minfo *um = ui->ui_mi;
+ register struct uba_ctlr *um;
register struct updevice *upaddr;
register struct upst *st;
daddr_t bn;
register struct updevice *upaddr;
register struct upst *st;
daddr_t bn;
dk_busy &= ~(1<<ui->ui_dk);
dp = &uputab[ui->ui_unit];
if ((bp = dp->b_actf) == NULL)
dk_busy &= ~(1<<ui->ui_dk);
dp = &uputab[ui->ui_unit];
if ((bp = dp->b_actf) == NULL)
* Start up a transfer on a drive.
*/
upstart(um)
* Start up a transfer on a drive.
*/
upstart(um)
- register struct uba_minfo *um;
+ register struct uba_ctlr *um;
{
register struct buf *bp, *dp;
{
register struct buf *bp, *dp;
- register struct uba_dinfo *ui;
+ register struct uba_device *ui;
register struct updevice *upaddr;
struct upst *st;
daddr_t bn;
register struct updevice *upaddr;
struct upst *st;
daddr_t bn;
* Now all ready to go, stuff the registers.
*/
updgo(um)
* Now all ready to go, stuff the registers.
*/
updgo(um)
{
register struct updevice *upaddr = (struct updevice *)um->um_addr;
{
register struct updevice *upaddr = (struct updevice *)um->um_addr;
register sc21;
{
register struct buf *bp, *dp;
register sc21;
{
register struct buf *bp, *dp;
- register struct uba_minfo *um = upminfo[sc21];
- register struct uba_dinfo *ui;
+ 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];
register struct updevice *upaddr = (struct updevice *)um->um_addr;
register unit;
struct up_softc *sc = &up_softc[um->um_ctlr];
}
/*
* Get device and block structures, and a pointer
}
/*
* Get device and block structures, and a pointer
- * to the uba_dinfo for the drive. Select the drive.
+ * to the uba_device for the drive. Select the drive.
*/
dp = um->um_tab.b_actf;
bp = dp->b_actf;
*/
dp = um->um_tab.b_actf;
bp = dp->b_actf;
* across a page boundary.
*/
upecc(ui)
* across a page boundary.
*/
upecc(ui)
- register struct uba_dinfo *ui;
+ register struct uba_device *ui;
{
register struct updevice *up = (struct updevice *)ui->ui_addr;
register struct buf *bp = uputab[ui->ui_unit].b_actf;
{
register struct updevice *up = (struct updevice *)ui->ui_addr;
register struct buf *bp = uputab[ui->ui_unit].b_actf;
- register struct uba_minfo *um = ui->ui_mi;
+ register struct uba_ctlr *um = ui->ui_mi;
register struct upst *st;
struct uba_regs *ubp = ui->ui_hd->uh_uba;
register int i;
register struct upst *st;
struct uba_regs *ubp = ui->ui_hd->uh_uba;
register int i;
npf = btop((up->upwc * sizeof(short)) + bp->b_bcount) - 1;
reg = btop(um->um_ubinfo&0x3ffff) + npf;
o = (int)bp->b_un.b_addr & PGOFSET;
npf = btop((up->upwc * sizeof(short)) + bp->b_bcount) - 1;
reg = btop(um->um_ubinfo&0x3ffff) + npf;
o = (int)bp->b_un.b_addr & PGOFSET;
- printf("up%d%c: soft ecc bn%d\n", dkunit(bp),
+ printf("up%d%c: soft ecc sn%d\n", dkunit(bp),
'a'+(minor(bp->b_dev)&07), bp->b_blkno + npf);
mask = up->upec2;
/*
'a'+(minor(bp->b_dev)&07), bp->b_blkno + npf);
mask = up->upec2;
/*
upreset(uban)
int uban;
{
upreset(uban)
int uban;
{
- register struct uba_minfo *um;
- register struct uba_dinfo *ui;
+ register struct uba_ctlr *um;
+ register struct uba_device *ui;
register sc21, unit;
for (sc21 = 0; sc21 < NSC; sc21++) {
register sc21, unit;
for (sc21 = 0; sc21 < NSC; sc21++) {
- register struct uba_minfo *um;
+ register struct uba_ctlr *um;
register sc21, unit;
register struct up_softc *sc;
register sc21, unit;
register struct up_softc *sc;
int num, blk, unit, i;
struct size *sizes;
register struct uba_regs *uba;
int num, blk, unit, i;
struct size *sizes;
register struct uba_regs *uba;
- register struct uba_dinfo *ui;
+ register struct uba_device *ui;
register short *rp;
struct upst *st;
register short *rp;
struct upst *st;
if (unit >= NUP)
return (ENXIO);
#define phys(cast, addr) ((cast)((int)addr & 0x7fffffff))
if (unit >= NUP)
return (ENXIO);
#define phys(cast, addr) ((cast)((int)addr & 0x7fffffff))
- ui = phys(struct uba_dinfo *, updinfo[unit]);
+ ui = phys(struct uba_device *, updinfo[unit]);
if (ui->ui_alive == 0)
return (ENXIO);
uba = phys(struct uba_hd *, ui->ui_hd)->uh_physuba;
if (ui->ui_alive == 0)
return (ENXIO);
uba = phys(struct uba_hd *, ui->ui_hd)->uh_physuba;
-#if VAX780
- if (cpu == VAX_780)
- ubainit(uba);
-#endif
upaddr = (struct updevice *)ui->ui_physaddr;
upaddr = (struct updevice *)ui->ui_physaddr;
- if ((upaddr->upcs1&UP_DVA) == 0)
- return (EFAULT);
num = maxfree;
start = 0;
upaddr->upcs2 = unit;
num = maxfree;
start = 0;
upaddr->upcs2 = unit;
+ DELAY(100);
+ if ((upaddr->upcs1&UP_DVA) == 0)
+ return (EFAULT);
if ((upaddr->upds & UP_VV) == 0) {
upaddr->upcs1 = UP_DCLR|UP_GO;
upaddr->upcs1 = UP_PRESET|UP_GO;
if ((upaddr->upds & UP_VV) == 0) {
upaddr->upcs1 = UP_DCLR|UP_GO;
upaddr->upcs1 = UP_PRESET|UP_GO;
blk = num > DBSIZE ? DBSIZE : num;
io = uba->uba_map;
for (i = 0; i < blk; i++)
blk = num > DBSIZE ? DBSIZE : num;
io = uba->uba_map;
for (i = 0; i < blk; i++)
- *(int *)io++ = (btop(start)+i) | (1<<21) | UBA_MRV;
+ *(int *)io++ = (btop(start)+i) | (1<<21) | UBAMR_MRV;
*(int *)io = 0;
bn = dumplo + btop(start);
cn = bn/st->nspc + sizes[minor(dev)&07].cyloff;
*(int *)io = 0;
bn = dumplo + btop(start);
cn = bn/st->nspc + sizes[minor(dev)&07].cyloff;
projects / unix-history / commitdiff