NetBSD/sys/arch/vax/mba/hp.c

367 lines
10 KiB
C

/* $NetBSD: hp.c,v 1.1 1995/02/13 00:43:59 ragge Exp $ */
/*
* Copyright (c) 1994 Ludd, University of Lule}, Sweden.
* All rights reserved.
*
* 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 at Ludd, University of Lule}.
* 4. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
*/
/* All bugs are subject to removal without further notice */
/* hp.c - drivrutiner f|r massbussdiskar 940325/ragge */
#include "param.h"
#include "types.h"
#include "fcntl.h"
#include "syslog.h"
#include "disklabel.h"
#include "buf.h"
#include "vax/mba/mbareg.h"
#include "vax/mba/mbavar.h"
#include "vax/mba/hpdefs.h"
#include "hp.h"
struct mba_device *hpinfo[NHP];
struct hp_info hp_info[NHP];
struct disklabel hplabel[NHP];
int hpslave(), hpattach();
char hptypes[]={
0x22,0
};
struct mba_driver hpdriver={
hpslave, 0, "hp", hptypes, hpattach, hpinfo
};
hpslave(){
printf("Hpslave.\n");
asm("halt");
};
hpopen(){
printf("hpopen");
asm("halt");
};
hpclose(){
printf("hpclose\n");
asm("halt");
};
hpioctl(){
printf("hpioctl\n");
asm("halt");
}
hpdump(){
printf("hpdump\n");
asm("halt");
};
hpsize(){
printf("hpsize");
asm("halt");
};
hpattach(mi)
struct mba_device *mi;
{
struct mba_drv *md;
/*
* We check status of the drive first; to see if there is any idea
* to try to read the label.
*/
md=&(mi->mi_mba->mba_drv[mi->drive]);
if(!md->rmcs1&HPCS1_DVA){
printf(": Drive not available");
return;
}
if(!md->rmds&HPDS_MOL){
printf(": Drive offline");
return;
}
if (hpinit(mi, 0))
printf(": offline");
/* else if (ra_info[unit].ra_state == OPEN) {
printf(": %s, size = %d sectors",
udalabel[unit].d_typename, ra_info[unit].ra_dsize);
*/
printf("rmcs1: %x, rmds: %x, rmdt: %x rmsn: %x\n",
md->rmcs1, md->rmds, md->rmdt, md->rmsn);
/* asm("halt"); */
/*
if (MSCP_MID_ECH(1, ra_info[unit].ra_mediaid) == 'X' - '@') {
printf(": floppy");
return;
}
if (ui->ui_dk >= 0)
dk_wpms[ui->ui_dk] = (60 * 31 * 256);
udaip[ui->ui_ctlr][ui->ui_slave] = ui;
if (uda_rainit(ui, 0))
printf(": offline");
else if (ra_info[unit].ra_state == OPEN) {
printf(": %s, size = %d sectors",
udalabel[unit].d_typename, ra_info[unit].ra_dsize);
}*/
}
/*
* Initialise a drive. If it is not already, bring it on line,
* and set a timeout on it in case it fails to respond.
* When on line, read in the pack label.
*/
hpinit(mi, flags)
struct mba_device *mi;
{
/* struct uda_softc *sc = &uda_softc[ui->ui_ctlr]; */
struct disklabel *lp;
struct hp_info *hp;
/* struct mscp *mp; */
int unit = mi->unit;
char *msg, *readdisklabel();
int s, i, hpstrategy();
extern int cold;
hp = &hp_info[unit];
/*
if ((ui->ui_flags & UNIT_ONLINE) == 0) {
mp = mscp_getcp(&sc->sc_mi, MSCP_WAIT);
mp->mscp_opcode = M_OP_ONLINE;
mp->mscp_unit = ui->ui_slave;
mp->mscp_cmdref = (long)&ui->ui_flags;
*mp->mscp_addr |= MSCP_OWN | MSCP_INT;
ra->ra_state = WANTOPEN;
if (!cold)
s = spl5();
i = ((struct udadevice *)ui->ui_addr)->udaip;
if (cold) {
i = todr() + 1000;
while ((ui->ui_flags & UNIT_ONLINE) == 0)
if (todr() > i)
break;
} else {
timeout(wakeup, (caddr_t)&ui->ui_flags, 10 * hz);
sleep((caddr_t)&ui->ui_flags, PSWP + 1);
splx(s);
untimeout(wakeup, (caddr_t)&ui->ui_flags);
}
if (ra->ra_state != OPENRAW) {
ra->ra_state = CLOSED;
wakeup((caddr_t)ra);
return (EIO);
}
}
*/
lp = &hplabel[unit];
lp->d_secsize = DEV_BSIZE;
lp->d_secsize = DEV_BSIZE;
lp->d_secperunit = 15 /*ra->ra_dsize*/;
if (flags & O_NDELAY)
return (0);
hp->hp_state = RDLABEL;
/*
* Set up default sizes until we have the label, or longer
* if there is none. Set secpercyl, as readdisklabel wants
* to compute b_cylin (although we do not need it), and set
* nsectors in case diskerr is called.
*/
lp->d_secpercyl = 1;
lp->d_npartitions = 1;
lp->d_secsize = 512;
/* lp->d_secperunit = ra->ra_dsize; */
lp->d_nsectors = 15 /*ra->ra_geom.rg_nsectors*/;
lp->d_partitions[0].p_size = lp->d_secperunit;
lp->d_partitions[0].p_offset = 0;
/*
* Read pack label.
*/
if ((msg = readdisklabel(hpminor(unit, 0), hpstrategy, lp)) != NULL) {
if (cold)
printf(": %s", msg);
else
log(LOG_ERR, "hp%d: %s", unit, msg);
/* ra->ra_state = OPENRAW; */
/* uda_makefakelabel(ra, lp); */
} else
/* ra->ra_state = OPEN; */
/* wakeup((caddr_t)hp); */
return (0);
}
/*
* Queue a transfer request, and if possible, hand it to the controller.
*
* This routine is broken into two so that the internal version
* udastrat1() can be called by the (nonexistent, as yet) bad block
* revectoring routine.
*/
hpstrategy(bp)
register struct buf *bp;
{
register int unit;
register struct uba_device *ui;
register struct hp_info *hp;
struct partition *pp;
int p;
daddr_t sz, maxsz;
/*
* Make sure this is a reasonable drive to use.
*/
/* bp->b_error = ENXIO;
goto bad;
*/
unit = hpunit(bp->b_dev);
/*
* If drive is open `raw' or reading label, let it at it.
*/
if (hp->hp_state < OPEN) {
hpstrat1(bp);
return;
}
/* if ((unit = udaunit(bp->b_dev)) >= NRA ||
(ui = udadinfo[unit]) == NULL || ui->ui_alive == 0 ||
(ra = &ra_info[unit])->ra_state == CLOSED) {
bp->b_error = ENXIO;
goto bad;
}
*/
/*
* If drive is open `raw' or reading label, let it at it.
*/
/*
if (ra->ra_state < OPEN) {
udastrat1(bp);
return;
}
p = udapart(bp->b_dev);
if ((ra->ra_openpart & (1 << p)) == 0) {
bp->b_error = ENODEV;
goto bad;
}
*/
/*
* Determine the size of the transfer, and make sure it is
* within the boundaries of the partition.
*/
/*
pp = &udalabel[unit].d_partitions[p];
maxsz = pp->p_size;
if (pp->p_offset + pp->p_size > ra->ra_dsize)
maxsz = ra->ra_dsize - pp->p_offset;
sz = (bp->b_bcount + DEV_BSIZE - 1) >> DEV_BSHIFT;
if (bp->b_blkno + pp->p_offset <= LABELSECTOR &&
#if LABELSECTOR != 0
bp->b_blkno + pp->p_offset + sz > LABELSECTOR &&
#endif
(bp->b_flags & B_READ) == 0 && ra->ra_wlabel == 0) {
bp->b_error = EROFS;
goto bad;
}
if (bp->b_blkno < 0 || bp->b_blkno + sz > maxsz) {
/* if exactly at end of disk, return an EOF */
/*
if (bp->b_blkno == maxsz) {
bp->b_resid = bp->b_bcount;
biodone(bp);
return;
}
/* or truncate if part of it fits */
/*
sz = maxsz - bp->b_blkno;
if (sz <= 0) {
bp->b_error = EINVAL; /* or hang it up */
/*
goto bad;
}
bp->b_bcount = sz << DEV_BSHIFT;
}
udastrat1(bp);
return;
*/
bad:
bp->b_flags |= B_ERROR;
biodone(bp);
}
/*
* Work routine for udastrategy.
*/
hpstrat1(bp)
register struct buf *bp;
{
register int unit = hpunit(bp->b_dev);
register struct hp_ctlr *um;
register struct buf *dp;
struct hp_device *ui;
/* int s = spl5(); */
asm("halt");
/*
* Append the buffer to the drive queue, and if it is not
* already there, the drive to the controller queue. (However,
* if the drive queue is marked to be requeued, we must be
* awaiting an on line or get unit status command; in this
* case, leave it off the controller queue.)
*/
/*
um = (ui = udadinfo[unit])->ui_mi;
dp = &udautab[unit];
APPEND(bp, dp, av_forw);
if (dp->b_active == 0 && (ui->ui_flags & UNIT_REQUEUE) == 0) {
APPEND(dp, &um->um_tab, b_forw);
dp->b_active++;
}
/*
* Start activity on the controller. Note that unlike other
* Unibus drivers, we must always do this, not just when the
* controller is not active.
*/
/*
udastart(um);
splx(s);
*/
}