NetBSD/sys/arch/vax/vsa/vsbus.c

653 lines
16 KiB
C

/* $NetBSD: vsbus.c,v 1.2 1996/08/27 21:58:51 cgd Exp $ */
/*
* Copyright (c) 1996 Ludd, University of Lule}, Sweden.
* All rights reserved.
*
* This code is derived from software contributed to Ludd by Bertram Barth.
*
* 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.
* 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.
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/conf.h>
#include <sys/file.h>
#include <sys/ioctl.h>
#include <sys/proc.h>
#include <sys/user.h>
#include <sys/map.h>
#include <sys/device.h>
#include <sys/dkstat.h>
#include <sys/disklabel.h>
#include <sys/syslog.h>
#include <sys/stat.h>
#include <machine/pte.h>
#include <machine/sid.h>
#include <machine/scb.h>
#include <machine/cpu.h>
#include <machine/trap.h>
#include <machine/nexus.h>
#include <machine/uvax.h>
#include <machine/ka410.h>
#include <machine/ka43.h>
#include <machine/vsbus.h>
#define trace(x)
#define debug(x)
int vsbus_match __P((struct device *, void *, void *));
void vsbus_attach __P((struct device *, struct device *, void *));
int vsbus_print __P((void *, const char *));
void ka410_attach __P((struct device *, struct device *, void *));
void ka43_attach __P((struct device *, struct device *, void *));
struct cfdriver vsbus_cd = {
NULL, "vsbus", DV_DULL
};
struct cfattach vsbus_ca = {
sizeof(struct device), vsbus_match, vsbus_attach
};
/*
void vsbus_intr_register __P((struct confargs *ca, int (*)(void*), void*));
void vsbus_intr_unregister __P((struct confargs *));
*/
void vsbus_intr_dispatch __P((int i));
#define VSBUS_MAXDEVS 8
#define VSBUS_MAXINTR 8
struct confargs *vsbus_devs = NULL;
#ifdef VAX410 /* also: KA420 */
struct confargs ka410_devs[] = {
/* name intslot intpri intvec intbit ioaddr */
{ "dc", 7, 7, 0x2C0, (1<<7), KA410_SER_BASE,
6, 6, 0x2C4, (1<<6), 0x01, },
{ "dc (xmit)", 6, 6, 0x2C4, (1<<6), KA410_SER_BASE, },
{ "le", 5, 5, 0x250, (1<<5), KA410_LAN_BASE,
KA410_NWA_BASE, 0x00, },
{ "ncr", 1, 1, 0x3F8, (1<<1), KA410_SCS_BASE,
KA410_SCS_DADR, KA410_SCS_DCNT, KA410_SCS_DDIR,
KA410_DMA_BASE, KA410_DMA_SIZE, 0x00, 0x07, },
{ "hdc", 0, 0, 0x3FC, (1<<0), KA410_DKC_BASE,
0, 0, 0,
KA410_DMA_BASE, KA410_DMA_SIZE, 0x00, },
#if 0
{ "dc (recv)", 7, 7, 0x2C0, (1<<7), KA410_SER_BASE, },
{ "dc (xmit)", 6, 6, 0x2C4, (1<<6), KA410_SER_BASE, },
{ "hdc9224", 0, 0, 0x3FC, (1<<0), KA410_DKC_BASE, },
{ "ncr5380", 1, 1, 0x3F8, (1<<1), KA410_SCS_BASE, },
{ "am7990", 5, 5, 0x250, (1<<5), KA410_LAN_BASE, },
{ "NETOPT", 4, 4, 0x254, (1<<4), KA410_LAN_BASE, },
#endif
{ "" },
};
#endif
#ifdef VAX43
struct confargs ka43_devs[] = {
/* name intslot intpri intvec intbit ioaddr */
{ "dc", 7, 7, 0x2C0, (1<<7), KA43_SER_BASE,
6, 6, 0x2C4, (1<<6), 0x01, },
{ "dc (xmit)", 6, 6, 0x2C4, (1<<6), KA43_SER_BASE, },
{ "le", 5, 5, 0x250, (1<<5), KA43_LAN_BASE,
KA43_NWA_BASE, 0x00, },
{ "ncr", 1, 1, 0x3F8, (1<<1), KA43_SC1_BASE,
KA43_SC1_DADR, KA43_SC1_DCNT, KA43_SC1_DDIR,
KA43_DMA_BASE, KA43_DMA_SIZE, 0x01, 0x06, },
{ "ncr", 0, 0, 0x3FC, (1<<0), KA43_SC2_BASE,
KA43_SC2_DADR, KA43_SC2_DCNT, KA43_SC2_DDIR,
KA43_DMA_BASE, KA43_DMA_SIZE, 0x01, 0x06, },
#if 0
{ "le (2nd)", 4, 4, 0x254, (1<<4), 0x???, },
{ "NETOPT", 4, 4, 0x254, (1<<4), 0x???, },
#endif
{ "" },
};
#endif
int
vsbus_print(aux, name)
void *aux;
const char *name;
{
struct confargs *ca = aux;
trace(("vsbus_print(%x, %s)\n", ca->ca_name, name));
if (name) {
printf ("device %s at %s", ca->ca_name, name);
return (UNSUPP);
}
return (UNCONF);
}
int
vsbus_match(parent, cf, aux)
struct device *parent;
void *cf;
void *aux;
{
struct bp_conf *bp = aux;
trace(("vsbus_match: bp->type = \"%s\"\n", bp->type));
if (strcmp(bp->type, "vsbus"))
return 0;
/*
* on machines which can have it, the vsbus is always there
*/
if ((vax_bustype & VAX_VSBUS) == 0)
return (0);
return (1);
}
#if 1 /*------------------------------------------------------------*/
#if 1
#define REG(name) short name; short X##name##X;
#else
#define REG(name) int name;
#endif
static volatile struct {/* base address of DZ-controller: 0x200A0000 */
REG(csr); /* 00 Csr: control/status register */
REG(rbuf); /* 04 Rbuf/Lpr: receive buffer/line param reg. */
REG(tcr); /* 08 Tcr: transmit console register */
REG(tdr); /* 0C Msr/Tdr: modem status reg/transmit data reg */
REG(lpr0); /* 10 Lpr0: */
REG(lpr1); /* 14 Lpr0: */
REG(lpr2); /* 18 Lpr0: */
REG(lpr3); /* 1C Lpr0: */
} *dz = (void*)0x200A0000;
extern int dzcnrint();
extern int dzcntint();
int hardclock_count = 0;
int
ka410_consintr_enable()
{
vsbus_intr_enable(&ka410_devs[0]);
vsbus_intr_enable(&ka410_devs[1]);
}
int
ka410_consRecv_intr(p)
void *p;
{
/* printf("ka410_consRecv_intr: hc-count=%d\n", hardclock_count); */
dzcnrint();
/* printf("gencnrint() returned.\n"); */
return(0);
}
int
ka410_consXmit_intr(p)
void *p;
{
/* printf("ka410_consXmit_intr: hc-count=%d\n", hardclock_count); */
dzcntint();
/* printf("gencntint() returned.\n"); */
return(0);
}
#endif /*------------------------------------------------------------*/
void
vsbus_attach(parent, self, aux)
struct device *parent, *self;
void *aux;
{
struct confargs *ca;
int i;
printf("\n");
trace (("vsbus_attach()\n"));
printf("vsbus_attach: boardtype = %x\n", vax_boardtype);
switch (vax_boardtype) {
case VAX_BTYP_410:
case VAX_BTYP_420:
vsbus_devs = ka410_devs;
break;
case VAX_BTYP_43:
case VAX_BTYP_46:
case VAX_BTYP_49:
vsbus_devs = ka43_devs;
break;
default:
printf ("unsupported boardtype 0x%x in vsbus_attach()\n",
vax_boardtype);
return;
}
/*
* first setup interrupt-table, so that devices can register
* their interrupt-routines...
*/
vsbus_intr_setup();
/*
* now check for all possible devices on this "bus"
*/
for (i=0; i<VSBUS_MAXDEVS; i++) {
ca = &vsbus_devs[i];
if (*ca->ca_name == '\0')
break;
config_found(self, (void*)ca, vsbus_print);
}
/*
* as long as there's no working DZ-driver, we use this dummy
*/
vsbus_intr_register(&ka410_devs[0], ka410_consRecv_intr, NULL);
vsbus_intr_register(&ka410_devs[1], ka410_consXmit_intr, NULL);
}
#define VSBUS_MAX_INTR 8 /* 64? */
/*
* interrupt service routines are given an int as argument, which is
* pushed onto stack as LITERAL. Thus the value is between 0-63.
* This array of 64 might be oversized for now, but it's all which
* ever will be possible.
*/
struct vsbus_ivec {
struct ivec_dsp intr_vec; /* this is referenced in SCB */
int intr_count; /* keep track of interrupts */
int intr_flags; /* valid, etc. */
void (*enab)(int); /* enable interrupt */
void (*disab)(int); /* disable interrupt */
void (*prep)(int); /* need pre-processing? */
int (*handler)(void*); /* isr-routine to call */
void *hndlarg; /* args to this routine */
void (*postp)(int); /* need post-processing? */
} vsbus_ivtab[VSBUS_MAX_INTR];
/*
*
*/
int
vsbus_intr_setup()
{
int i;
struct vsbus_ivec *ip;
extern struct ivec_dsp idsptch; /* subr.s */
for (i=0; i<VSBUS_MAX_INTR; i++) {
ip = &vsbus_ivtab[i];
bcopy(&idsptch, &ip->intr_vec, sizeof(struct ivec_dsp));
ip->intr_vec.pushlarg = i;
ip->intr_vec.hoppaddr = vsbus_intr_dispatch;
ip->intr_count = 0;
ip->intr_flags = 0;
ip->enab = NULL;
ip->disab = NULL;
ip->postp = NULL;
}
switch (vax_boardtype) {
case VAX_BTYP_410:
case VAX_BTYP_420:
case VAX_BTYP_43:
case VAX_BTYP_46:
case VAX_BTYP_49:
ka410_intr_setup();
return(0);
default:
printf("unsupported board-type 0x%x in vsbus_intr_setup()\n",
vax_boardtype);
return(1);
}
}
int
vsbus_intr_register(ca, handler, arg)
struct confargs *ca;
int (*handler)(void*);
void *arg;
{
/* struct device *dev = arg; */
int i = ca->ca_intslot;
struct vsbus_ivec *ip = &vsbus_ivtab[i];
trace (("vsbus_intr_register(%s/%d)\n", ca->ca_name, ca->ca_intslot));
ip->handler = handler;
ip->hndlarg = arg;
}
int
vsbus_intr_enable(ca)
struct confargs *ca;
{
int i = ca->ca_intslot;
struct vsbus_ivec *ip = &vsbus_ivtab[i];
trace (("vsbus_intr_enable(%s/%d)\n", ca->ca_name, ca->ca_intslot));
/* XXX check for valid handler etc. !!! */
if (ip->handler == NULL) {
printf("interrupts for \"%s\"(%d) not enabled: null-handler\n",
ca->ca_name, ca->ca_intslot);
return;
}
ip->enab(i);
}
int
vsbus_intr_disable(ca)
struct confargs *ca;
{
int i = ca->ca_intslot;
struct vsbus_ivec *ip = &vsbus_ivtab[i];
trace (("vsbus_intr_disable(%s/%d)\n", ca->ca_name, i));
ip->disab(i);
}
int
vsbus_intr_unregister(ca)
struct confargs *ca;
{
int i = ca->ca_intslot;
struct vsbus_ivec *ip = &vsbus_ivtab[i];
trace (("vsbus_intr_unregister(%s/%d)\n", ca->ca_name, i));
ip->handler = NULL;
ip->hndlarg = NULL;
}
void
vsbus_intr_dispatch(i)
register int i;
{
register struct vsbus_ivec *ip = &vsbus_ivtab[i];
trace (("vsbus_intr_dispatch(%d)", i));
if (i < VSBUS_MAX_INTR && ip->handler != NULL) {
ip->intr_count++;
debug (("intr-count[%d] = %d\n", i, ip->intr_count));
(ip->handler)(ip->hndlarg);
if (ip->postp)
(ip->postp)(i);
return;
}
if (i < 0 || i >= VSBUS_MAX_INTR) {
printf ("stray interrupt %d on vsbus.\n", i);
return;
}
if (!ip->handler) {
printf ("unhandled interrupt %d on vsbus.\n", i);
return;
}
}
/*
* These addresses are invalid and will be updated/corrected by
* ka410_intr_setup(), but having them this way helps debugging
*/
static volatile u_char *ka410_intmsk = (void*)KA410_INTMSK;
static volatile u_char *ka410_intreq = (void*)KA410_INTREQ;
static volatile u_char *ka410_intclr = (void*)KA410_INTCLR;
static void
ka410_intr_enable(i)
int i;
{
trace (("ka410_intr_enable(%d)\n", i));
*ka410_intmsk |= (1<<i);
}
static void
ka410_intr_disable(i)
int i;
{
trace (("ka410_intr_disable(%d)\n", i));
*ka410_intmsk &= ~(1<<i);
}
static void
ka410_intr_clear(i)
int i;
{
trace (("ka410_intr_clear(%d)\n", i));
*ka410_intclr = (1<<i);
}
ka410_intr_setup()
{
int i;
struct vsbus_ivec *ip;
void **scbP = (void*)scb;
trace (("ka410_intr_setup()\n"));
ka410_intmsk = (void*)uvax_phys2virt(KA410_INTMSK);
ka410_intreq = (void*)uvax_phys2virt(KA410_INTREQ);
ka410_intclr = (void*)uvax_phys2virt(KA410_INTCLR);
*ka410_intmsk = 0; /* disable all interrupts */
*ka410_intclr = 0xFF; /* clear all old interrupts */
/*
* insert the VS2000-specific routines into ivec-table...
*/
for (i=0; i<8; i++) {
ip = &vsbus_ivtab[i];
ip->enab = ka410_intr_enable;
ip->disab = ka410_intr_disable;
/* ip->postp = ka410_intr_clear; bertram XXX */
}
/*
* ...and register the interrupt-vectors in SCB
*/
scbP[IVEC_DC/4] = &vsbus_ivtab[0].intr_vec;
scbP[IVEC_SC/4] = &vsbus_ivtab[1].intr_vec;
scbP[IVEC_VS/4] = &vsbus_ivtab[2].intr_vec;
scbP[IVEC_VF/4] = &vsbus_ivtab[3].intr_vec;
scbP[IVEC_NS/4] = &vsbus_ivtab[4].intr_vec;
scbP[IVEC_NP/4] = &vsbus_ivtab[5].intr_vec;
scbP[IVEC_ST/4] = &vsbus_ivtab[6].intr_vec;
scbP[IVEC_SR/4] = &vsbus_ivtab[7].intr_vec;
}
/*
*
*
*/
static volatile struct dma_lock {
int dl_locked;
int dl_wanted;
void *dl_owner;
int dl_count;
} dmalock = { 0, 0, NULL, 0 };
int
vsbus_lockDMA(ca)
struct confargs *ca;
{
while (dmalock.dl_locked) {
dmalock.dl_wanted++;
sleep((caddr_t)&dmalock, PRIBIO); /* PLOCK or PRIBIO ? */
dmalock.dl_wanted--;
}
dmalock.dl_locked++;
dmalock.dl_owner = ca;
/*
* no checks yet, no timeouts, nothing...
*/
#ifdef DEBUG
if ((++dmalock.dl_count % 1000) == 0)
printf("%d locks, owner: %s\n", dmalock.dl_count, ca->ca_name);
#endif
return (0);
}
int
vsbus_unlockDMA(ca)
struct confargs *ca;
{
if (dmalock.dl_locked != 1 || dmalock.dl_owner != ca) {
printf("locking-problem: %d, %s\n", dmalock.dl_locked,
(dmalock.dl_owner ? dmalock.dl_owner : "null"));
dmalock.dl_locked = 0;
return (-1);
}
dmalock.dl_owner = NULL;
dmalock.dl_locked = 0;
if (dmalock.dl_wanted) {
wakeup((caddr_t)&dmalock);
}
return (0);
}
/*----------------------------------------------------------------------*/
#if 0
/*
* small set of routines needed for mapping when doing pseudo-DMA,
* quasi-DMA or virtual-DMA (choose whatever name you like).
*
* Once I know how VS3100 is doing real DMA (I hope it does), this
* should be rewritten to present a general interface...
*
*/
extern u_long uVAX_physmap;
u_long
vsdma_mapin(bp, len)
struct buf *bp;
int len;
{
pt_entry_t *pte; /* pointer to Page-Table-Entry */
struct pcb *pcb; /* pointer to Process-Controll-Block */
pt_entry_t *xpte;
caddr_t addr;
int pgoff; /* offset into 1st page */
int pgcnt; /* number of pages needed */
int pfnum;
int i;
trace(("mapin(bp=%x, bp->data=%x)\n", bp, bp->b_data));
addr = bp->b_data;
pgoff = (int)bp->b_data & PGOFSET; /* get starting offset */
pgcnt = btoc(bp->b_bcount + pgoff) + 1; /* one more than needed */
/*
* Get a pointer to the pte pointing out the first virtual address.
* Use different ways in kernel and user space.
*/
if ((bp->b_flags & B_PHYS) == 0) {
pte = kvtopte(addr);
} else {
pcb = bp->b_proc->p_vmspace->vm_pmap.pm_pcb;
pte = uvtopte(addr, pcb);
}
/*
* When we are doing DMA to user space, be sure that all pages
* we want to transfer to are mapped. WHY DO WE NEED THIS???
* SHOULDN'T THEY ALWAYS BE MAPPED WHEN DOING THIS???
*/
for (i=0; i<(pgcnt-1); i++) {
if ((pte + i)->pg_pfn == 0) {
int rv;
rv = vm_fault(&bp->b_proc->p_vmspace->vm_map,
(unsigned)addr + i * NBPG,
VM_PROT_READ|VM_PROT_WRITE, FALSE);
if (rv)
panic("vs-DMA to nonexistent page, %d", rv);
}
}
/*
* now insert new mappings for this memory area into kernel's
* mapping-table
*/
xpte = kvtopte(uVAX_physmap);
while (--pgcnt > 0) {
pfnum = pte->pg_pfn;
if (pfnum == 0)
panic("vsbus: zero entry");
*(int *)xpte++ = *(int *)pte++;
}
*(int *)xpte = 0; /* mark last mapped page as invalid! */
debug(("uVAX: 0x%x\n", uVAX_physmap + pgoff));
return (uVAX_physmap + pgoff); /* ??? */
}
#endif
/*----------------------------------------------------------------------*/
/*
* Here follows some currently(?) unused stuff. Someday this should be removed
*/
#if 0
/*
* Configure devices on VS2000/KA410 directly attached to vsbus
*/
void
ka410_attach(parent, self, aux)
struct device *parent;
struct device *self;
void *aux;
{
struct confargs *ca;
int i;
for (i=0; i<KA410_MAXDEVS; i++) {
ca = &ka410_devs[i];
if (*ca->ca_name == '\0')
break;
config_found(self, (void*)ca, vsbus_print);
}
/*
* as long as there's no real DZ-driver, we used this dummy
*/
vsbus_intr_register(&ka410_devs[0], ka410_consRecv_intr, NULL);
vsbus_intr_register(&ka410_devs[1], ka410_consXmit_intr, NULL);
}
#endif