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

296 lines
7.7 KiB
C
Raw Normal View History

/* $NetBSD: mba.c,v 1.13 1998/01/24 14:16:50 ragge Exp $ */
1995-02-13 03:43:59 +03:00
/*
* Copyright (c) 1994, 1996 Ludd, University of Lule}, Sweden.
1995-02-13 03:43:59 +03:00
* 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}, Sweden and its contributors.
1995-02-13 03:43:59 +03:00
* 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.
*/
/*
* Simple massbus drive routine.
* TODO:
* Autoconfig new devices 'on the fly'.
* More intelligent way to handle different interrupts.
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/queue.h>
#include <sys/buf.h>
#include <sys/proc.h>
1995-02-13 03:43:59 +03:00
#include <vm/vm.h>
#include <vm/vm_kern.h>
1995-02-13 03:43:59 +03:00
#include <machine/trap.h>
#include <machine/scb.h>
#include <machine/nexus.h>
#include <machine/pte.h>
#include <machine/pcb.h>
#include <machine/sid.h>
1995-02-13 03:43:59 +03:00
1996-02-02 21:05:36 +03:00
#include <vax/mba/mbareg.h>
#include <vax/mba/mbavar.h>
struct mbaunit mbaunit[] = {
{MBADT_RP04, "rp04", MB_RP},
{MBADT_RP05, "rp05", MB_RP},
{MBADT_RP06, "rp06", MB_RP},
{MBADT_RP07, "rp07", MB_RP},
{MBADT_RM02, "rm02", MB_RP},
{MBADT_RM03, "rm03", MB_RP},
{MBADT_RM05, "rm05", MB_RP},
{MBADT_RM80, "rm80", MB_RP},
{0, 0, 0}
};
int mbamatch __P((struct device *, struct cfdata *, void *));
void mbaattach __P((struct device *, struct device *, void *));
void mbaintr __P((int));
int mbaprint __P((void *, const char *));
void mbaqueue __P((struct mba_device *));
void mbastart __P((struct mba_softc *));
void mbamapregs __P((struct mba_softc *));
struct cfattach mba_cmi_ca = {
sizeof(struct mba_softc), mbamatch, mbaattach
};
struct cfattach mba_sbi_ca = {
sizeof(struct mba_softc), mbamatch, mbaattach
};
extern struct cfdriver mba_cd;
1998-01-12 23:52:29 +03:00
/*
* Look if this is a massbuss adapter.
*/
int
mbamatch(parent, cf, aux)
struct device *parent;
struct cfdata *cf;
void *aux;
{
struct sbi_attach_args *sa = (struct sbi_attach_args *)aux;
1995-02-13 03:43:59 +03:00
if ((cf->cf_loc[0] != sa->nexnum) && (cf->cf_loc[0] > -1 ))
return 0;
1995-02-13 03:43:59 +03:00
if (sa->type == NEX_MBA)
return 1;
1995-02-13 03:43:59 +03:00
return 0;
}
/*
* Attach the found massbuss adapter. Setup its interrupt vectors,
* reset it and go searching for drives on it.
*/
void
mbaattach(parent, self, aux)
struct device *parent, *self;
void *aux;
{
struct mba_softc *sc = (void *)self;
struct sbi_attach_args *sa = (struct sbi_attach_args *)aux;
volatile struct mba_regs *mbar = (struct mba_regs *)sa->nexaddr;
struct mba_attach_args ma;
extern struct ivec_dsp idsptch;
int i, j;
1996-10-13 07:29:05 +04:00
printf("\n");
/*
* Set up interrupt vectors for this MBA.
*/
bcopy(&idsptch, &sc->sc_dsp, sizeof(struct ivec_dsp));
scb->scb_nexvec[0][sa->nexnum] = scb->scb_nexvec[1][sa->nexnum] =
scb->scb_nexvec[2][sa->nexnum] = scb->scb_nexvec[3][sa->nexnum] =
&sc->sc_dsp;
sc->sc_dsp.pushlarg = sc->sc_dev.dv_unit;
sc->sc_dsp.hoppaddr = mbaintr;
sc->sc_physnr = sa->nexnum - 8; /* MBA's have TR between 8 - 11... */
#ifdef VAX750
if (vax_cputype == VAX_750)
sc->sc_physnr += 4; /* ...but not on 11/750 */
#endif
sc->sc_first = 0;
sc->sc_last = (void *)&sc->sc_first;
sc->sc_mbareg = (struct mba_regs *)mbar;
mbar->mba_cr = MBACR_INIT; /* Reset adapter */
mbar->mba_cr = MBACR_IE; /* Enable interrupts */
1995-02-13 03:43:59 +03:00
for (i = 0; i < MAXMBADEV; i++) {
sc->sc_state = SC_AUTOCONF;
if ((mbar->mba_md[i].md_ds & MBADS_DPR) == 0)
continue;
/* We have a drive, ok. */
ma.unit = i;
ma.type = mbar->mba_md[i].md_dt & 0777;
j = 0;
while (mbaunit[j++].nr)
if (mbaunit[j].nr == ma.type)
break;
ma.devtyp = mbaunit[j].devtyp;
ma.name = mbaunit[j].name;
config_found(&sc->sc_dev, (void *)&ma, mbaprint);
1995-02-13 03:43:59 +03:00
}
}
/*
* We got an interrupt. Check type of interrupt and call the specific
* device interrupt handling routine.
1995-02-13 03:43:59 +03:00
*/
void
mbaintr(mba)
int mba;
{
struct mba_softc *sc = mba_cd.cd_devs[mba];
volatile struct mba_regs *mr = sc->sc_mbareg;
struct mba_device *md;
struct buf *bp;
int itype, attn, anr;
itype = mr->mba_sr;
mr->mba_sr = itype; /* Write back to clear bits */
attn = mr->mba_md[0].md_as & 0xff;
mr->mba_md[0].md_as = attn;
if (sc->sc_state == SC_AUTOCONF)
return; /* During autoconfig */
md = sc->sc_first;
bp = md->md_q.b_actf;
/*
* A data-transfer interrupt. Current operation is finished,
* call that device's finish routine to see what to do next.
*/
if (sc->sc_state == SC_ACTIVE) {
sc->sc_state = SC_IDLE;
switch ((*md->md_finish)(md, itype, &attn)) {
case XFER_FINISH:
/*
* Transfer is finished. Take buffer of drive
* queue, and take drive of adapter queue.
* If more to transfer, start the adapter again
* by calling mbastart().
*/
md->md_q.b_actf = bp->b_actf;
sc->sc_first = md->md_back;
md->md_back = 0;
if (sc->sc_first == 0)
sc->sc_last = (void *)&sc->sc_first;
1995-02-13 03:43:59 +03:00
if (md->md_q.b_actf) {
sc->sc_last->md_back = md;
sc->sc_last = md;
}
bp->b_resid = 0;
biodone(bp);
if (sc->sc_first)
mbastart(sc);
break;
case XFER_RESTART:
/*
* Something went wrong with the transfer. Try again.
*/
mbastart(sc);
break;
}
}
while (attn) {
anr = ffs(attn) - 1;
attn &= ~(1 << anr);
if (sc->sc_md[anr]->md_attn == 0)
panic("Should check for new MBA device %d", anr);
(*sc->sc_md[anr]->md_attn)(sc->sc_md[anr]);
}
}
int
mbaprint(aux, mbaname)
void *aux;
const char *mbaname;
{
struct mba_attach_args *ma = aux;
if (mbaname) {
if (ma->name)
1996-10-13 07:29:05 +04:00
printf("%s", ma->name);
else
1996-10-13 07:29:05 +04:00
printf("device type %o", ma->type);
printf(" at %s", mbaname);
}
1996-10-13 07:29:05 +04:00
printf(" drive %d", ma->unit);
return (ma->name ? UNCONF : UNSUPP);
}
1995-02-13 03:43:59 +03:00
/*
* A device calls mbaqueue() when it wants to get on the adapter queue.
* Called at splbio(). If the adapter is inactive, start it.
1995-02-13 03:43:59 +03:00
*/
void
mbaqueue(md)
struct mba_device *md;
{
struct mba_softc *sc = md->md_mba;
int i = (int)sc->sc_first;
sc->sc_last->md_back = md;
sc->sc_last = md;
if (i == 0)
mbastart(sc);
}
1995-02-13 03:43:59 +03:00
/*
* Start activity on (idling) adapter. Calls mbamapregs() to setup
* for dma transfer, then the unit-specific start routine.
1995-02-13 03:43:59 +03:00
*/
void
mbastart(sc)
struct mba_softc *sc;
{
struct mba_device *md = sc->sc_first;
volatile struct mba_regs *mr = sc->sc_mbareg;
struct buf *bp = md->md_q.b_actf;
disk_reallymapin(md->md_q.b_actf, sc->sc_mbareg->mba_map, 0, PG_V);
sc->sc_state = SC_ACTIVE;
mr->mba_var = ((u_int)bp->b_un.b_addr & PGOFSET);
mr->mba_bc = (~bp->b_bcount) + 1;
(*md->md_start)(md); /* machine-dependent start */
}