xref: /src/sys/arch/vax/mba/hp.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);
*/
}