NetBSD/sys/arch/pmax/tc/asic.c

/*	$NetBSD: asic.c,v 1.2 1995/08/10 04:30:41 jonathan Exp $	*/

/*
 * Copyright (c) 1994, 1995 Carnegie-Mellon University.
 * All rights reserved.
 *
 * Author: Keith Bostic, Chris G. Demetriou, Jonathan Stone
 * 
 * Permission to use, copy, modify and distribute this software and
 * its documentation is hereby granted, provided that both the copyright
 * notice and this permission notice appear in all copies of the
 * software, derivative works or modified versions, and any portions
 * thereof, and that both notices appear in supporting documentation.
 * 
 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 
 * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND 
 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
 * 
 * Carnegie Mellon requests users of this software to return to
 *
 *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
 *  School of Computer Science
 *  Carnegie Mellon University
 *  Pittsburgh PA 15213-3890
 *
 * any improvements or extensions that they make and grant Carnegie the
 * rights to redistribute these changes.
 */

#include <sys/param.h>
#include <sys/kernel.h>
#include <sys/systm.h>
#include <sys/device.h>

#include <machine/autoconf.h>
#include <machine/pte.h>

#if 0
#include <machine/rpb.h>
#include <alpha/tc/tc.h>
#include <alpha/tc/asic.h>
#endif

#ifdef pmax
#include <pmax/pmax/pmaxtype.h>
#include <pmax/pmax/asic.h>
#include <pmax/pmax/kn01.h>
#include <pmax/pmax/kn02.h>
#include <pmax/pmax/kmin.h>
#include <pmax/pmax/maxine.h>
#include <pmax/pmax/kn03.h>
#include <pmax/pmax/turbochannel.h>	/* interrupt enable declaration */

#include <pmax/pmax/kn03.h>
#include <pmax/pmax/kmin.h>
#include <machine/machConst.h>
#include <pmax/pmax/nameglue.h>

extern int cputype;
#endif

struct asic_softc {
	struct	device sc_dv;
	struct	abus sc_bus;
	caddr_t	sc_base;
};

/* Definition of the driver for autoconfig. */
int	asicmatch __P((struct device *, void *, void *));
void	asicattach __P((struct device *, struct device *, void *));
int     asicprint(void *, char *);
struct cfdriver asiccd =
    { NULL, "asic", asicmatch, asicattach, DV_DULL, sizeof(struct asic_softc) };

void    asic_intr_establish __P((struct confargs *, intr_handler_t,
				 handler_arg_t));
void    asic_intr_disestablish __P((struct confargs *));
caddr_t asic_cvtaddr __P((struct confargs *));
int     asic_matchname __P((struct confargs *, char *));

#ifndef pmax
int	asic_intr __P((void *));
#endif

int	asic_intrnull __P((handler_arg_t));

struct asic_slot {
	struct confargs	as_ca;
	u_int		as_bits;
	intr_handler_t	as_handler;
	void		*as_val;
};

#ifdef	pmax
struct asic_slot *asic_slots;

#include "ds-asic-conf.c"

#else	/*!pmax*/
struct asic_slot asic_slots[ASIC_MAX_NSLOTS] =

{
	{ { "lance",		/* XXX */ 0, 0x000c0000, },
	    ASIC_INTR_LANCE, asic_intrnull, (void *)(long)ASIC_SLOT_LANCE, },
	{ { "scc",		/* XXX */ 1, 0x00100000, },
	    ASIC_INTR_SCC_0, asic_intrnull, (void *)(long)ASIC_SLOT_SCC0, },
	{ { "scc",		/* XXX */ 2, 0x00180000, },
	    ASIC_INTR_SCC_1, asic_intrnull, (void *)(long)ASIC_SLOT_SCC1, },
	{ { "dallas_rtc",	/* XXX */ 3, 0x00200000, },
	    0, asic_intrnull, (void *)(long)ASIC_SLOT_RTC, },
	{ { "AMD79c30",		/* XXX */ 4, 0x00240000, },
	    0 /* XXX */, asic_intrnull, (void *)(long)ASIC_SLOT_ISDN, },
};
#endif	/*!pmax*/

caddr_t asic_base;		/* XXX XXX XXX */

int
asicmatch(parent, cfdata, aux)
	struct device *parent;
	void *cfdata;
	void *aux;
{
	struct cfdata *cf = cfdata;
	struct confargs *ca = aux;

	/* It can only occur on the turbochannel, anyway. */
	if (ca->ca_bus->ab_type != BUS_TC)
		return (0);

	/* The 3MAX (kn02) is special. */
	if (BUS_MATCHNAME(ca, KN02_ASIC_NAME)) {
		printf("(configuring KN02 system slot as asic)\n");
		goto gotasic;
	}

	/* Make sure that we're looking for this type of device. */
	if (!BUS_MATCHNAME(ca, "IOCTL   "))
		return (0);
gotasic:

	/* See if the unit number is valid. */
	switch (cputype) {
	case DS_3MIN:
		if (cf->cf_unit > 0)
			return (0);
		asic_slots = NULL;
		break;
	case DS_MAXINE:
		if (cf->cf_unit > 0)
			return (0);
		asic_slots = NULL;
		break;
	case DS_3MAX:
		if (cf->cf_unit > 0)
			return (0);
		asic_slots = kn02_asic_slots;
		break;
	case DS_3MAXPLUS:
		if (cf->cf_unit > 0)
			return (0);
		asic_slots = kn03_asic_slots;
		break;
	default:
		printf("no ASIC config table for this machine\n");
		return (0);
	}

	return (1);
}

void
asicattach(parent, self, aux)
	struct device *parent, *self;
	void *aux;
{
	struct asic_softc *sc = (struct asic_softc *)self;
	struct confargs *ca = aux;
	struct confargs *nca;
	int i;
	extern int cputype;

	if (asic_slots == NULL)
		panic("asicattach: no asic_slot map\n");

	sc->sc_base = BUS_CVTADDR(ca);
	asic_base = sc->sc_base;			/* XXX XXX XXX */

	sc->sc_bus.ab_dv = (struct device *)sc;
	sc->sc_bus.ab_type = BUS_ASIC;
	sc->sc_bus.ab_intr_establish = asic_intr_establish;
	sc->sc_bus.ab_intr_disestablish = asic_intr_disestablish;
	sc->sc_bus.ab_cvtaddr = asic_cvtaddr;
	sc->sc_bus.ab_matchname = asic_matchname;

#ifdef pmax
	printf("\n");
#else	/* Alpha AXP: select ASIC speed  */
#ifdef DEC_3000_300
	if (cputype == ST_DEC_3000_300) {
		*(volatile u_int *)ASIC_REG_CSR(sc->sc_base) |=
		    ASIC_CSR_FASTMODE;
		MB();
		printf(": slow mode\n");
	} else
#endif /*DEC_3000_300*/
		printf(": fast mode\n");
	
	/* Decstations use hand-craft code to enable asic interrupts */
	BUS_INTR_ESTABLISH(ca, asic_intr, sc);

#endif 	/* Alpha AXP: select ASIC speed  */


/* The MAXINE has seven pseudo-slots in its system slot */
#define ASIC_MAX_NSLOTS 7 /*XXX*/

        /* Try to configure each CPU-internal device */
        for (i = 0; i < ASIC_MAX_NSLOTS; i++) {

#ifdef DEBUG_ASIC
		printf("asicattach: entry %d\n", i);		/*XXX*/
#endif

                nca = &asic_slots[i].as_ca;
		if (nca == NULL) panic ("bad asic table\n");
		if (nca->ca_name == NULL && nca->ca_bus == NULL)
			break;
                nca->ca_bus = &sc->sc_bus;

#ifdef DEBUG_ASIC
		printf(" adding %s subslot %d offset %x\n",	/*XXX*/
		       nca->ca_name, nca->ca_slot, nca->ca_offset);
#endif

                /* Tell the autoconfig machinery we've found the hardware. */
                config_found(self, nca, asicprint);
        }

}

int
asicprint(aux, pnp)
	void *aux;
	char *pnp;
{
	struct confargs *ca = aux;

	if (pnp)
		printf("%s at %s", ca->ca_name, pnp);
	printf(" offset 0x%lx", ca->ca_offset);
	return (UNCONF);
}

/*
 * Save interrupt slotname and enable mask (??)
 * On decstaitons this isn't useful, as the turbochannel
 * decstations all have incompatible ways of mapping interrupts
 * to IO ASIC or r3000 interrupt bits.
 * Instead of writing "as_bits" directly into an IOASIC interrupt-enable
 * register,  Decstations use a  machine-dependent function that
 * interpret (pseudo-) slot numbers and do ``the right thing'' to enable
 * or disable  interrupts for a specific slot (or pseudo-slot), by
 * slot number, on that given CPU.
 */
void
asic_intr_establish(ca, handler, val)
	struct confargs *ca;
	intr_handler_t handler;
        handler_arg_t val;
{

#ifdef DIAGNOSTIC
	if (ca->ca_slot == ASIC_SLOT_RTC)
		panic("setting clock interrupt incorrectly");
#endif	/*DIAGNOSTIC*/

	/* XXX SHOULD NOT BE THIS LITERAL */
	if (asic_slots[ca->ca_slot].as_handler != asic_intrnull)
		/*panic*/ printf("asic_intr_establish: slot %d twice", ca->ca_slot);

	/*
	 * XXX  We need to invent a better interface to machine-dependent
	 * interrupt-enable code, or redo the Decstation configuration
	 * tables with unused entries, so that slot is always equal
	 * to "priority" (software pseudo-slot number).
	 */
#ifdef pmax
#ifdef	DEBUG_ASIC
	printf("asic:%s%d:  intr for entry %d(%d) slot %d\n", 
		 ca->ca_name, val, ca->ca_slot, ca->ca_slotpri,
		 asic_slots[ca->ca_slot].as_val);
#endif	/*DEBUG*/
	tc_enable_interrupt(ca->ca_slotpri, handler, (int)val, 1);

#else	/* Alpha AXP */

	/* Save handler info so it can be enabled later (??) */
	asic_slots[ca->ca_slot].as_handler = handler;
	asic_slots[ca->ca_slot].as_val = val;
#endif	/* Alpha AXP */
}

void
asic_intr_disestablish(ca)
	struct confargs *ca;
{

#ifdef pmax
	panic("asic_intr_disestablish: shouldn't ever be called\n");
#else
	if (ca->ca_slot == ASIC_SLOT_RTC)
	        panic("asic_intr_disestablish: can't do clock interrupt");

	/* XXX SHOULD NOT BE THIS LITERAL */
	if (asic_slots[ca->ca_slot].as_handler == asic_intrnull)
		panic("asic_intr_disestablish: slot %d missing intr",
		    ca->ca_slot);

	asic_slots[ca->ca_slot].as_handler = dsasic_intrnull;
	asic_slots[ca->ca_slot].as_val = (void *)(long)ca->ca_slot;
#endif
}

caddr_t
asic_cvtaddr(ca)
	struct confargs *ca;
{

	return
	    (((struct asic_softc *)ca->ca_bus->ab_dv)->sc_base + ca->ca_offset);
}

int
asic_matchname(ca, name)
	struct confargs *ca;
	char *name;
{

	return (strcmp(name, ca->ca_name) == 0);
}

#ifndef	pmax
/*
 * asic_intr --
 *	ASIC interrupt handler.
 */
int
asic_intr(val)
	void *val;
{
	register struct asic_softc *sc = val;
	register int i, ifound;
	int gifound;
	u_int32_t sir, junk;
	volatile u_int32_t *sirp, *junkp;

	sirp = (volatile u_int32_t *)ASIC_REG_INTR(sc->sc_base);

	gifound = 0;
	do {
		ifound = 0;
		MB();
		MAGIC_READ;
		MB();

		sir = *sirp;
		for (i = 0; i < ASIC_MAX_NSLOTS; i++)
			if (sir & asic_slots[i].as_bits) {
				(void)(*asic_slots[i].as_handler)
				    (asic_slots[i].as_val);
				ifound = 1;
			}
		gifound |= ifound;
	} while (ifound);

	return (gifound);
}
#endif /*!pmax*/

int
asic_intrnull(val)
	handler_arg_t val;
{

        panic("uncaught IOCTL ASIC intr for slot %ld\n", (long)val);
}