 @@ -1,14 +1,14 @@
-/*	$NetBSD: pci_machdep.c,v 1.64 2009/11/28 21:32:46 mrg Exp $	*/
+/*	$NetBSD: pci_machdep.c,v 1.65 2009/11/30 05:00:58 mrg Exp $	*/
 /*
  * Copyright (c) 1999, 2000 Matthew R. Green
  * 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.
 @@ -21,27 +21,27 @@
  * 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.
  */
 /*
  * functions expected by the MI PCI code.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: pci_machdep.c,v 1.64 2009/11/28 21:32:46 mrg Exp $");
+__KERNEL_RCSID(0, "$NetBSD: pci_machdep.c,v 1.65 2009/11/30 05:00:58 mrg Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/time.h>
 #include <sys/systm.h>
 #include <sys/errno.h>
 #include <sys/device.h>
 #include <sys/malloc.h>
 #define _SPARC_BUS_DMA_PRIVATE
 #include <machine/bus.h>
 #include <machine/autoconf.h>
 #include <machine/openfirm.h>
 @@ -365,69 +365,26 @@ sparc64_pci_enumerate_bus(struct pci_sof
 		bhlc &= ~((PCI_LATTIMER_MASK << PCI_LATTIMER_SHIFT) |
 			  (PCI_CACHELINE_MASK << PCI_CACHELINE_SHIFT));
 		bhlc |= (lt << PCI_LATTIMER_SHIFT) |
 			(cl << PCI_CACHELINE_SHIFT);
 		pci_conf_write(pc, tag, PCI_BHLC_REG, bhlc);
 		ret = pci_probe_device(sc, tag, match, pap);
 		if (match != NULL && ret != 0)
 			return (ret);
+	}
 	return (0);
+}
 /*
  * interrupt mapping foo.
  * XXX: how does this deal with multiple interrupts for a device?
  */
 int
 pci_intr_map(struct pci_attach_args *pa, pci_intr_handle_t *ihp)
 	pcitag_t tag = pa->pa_tag;
 	int interrupts, *intp;
 	int len, node = PCITAG_NODE(tag);
 	char devtype[30];
 	intp = &interrupts;
 	len = 1;
 	if (prom_getprop(node, "interrupts", sizeof(interrupts),
 			&len, &intp) != 0 || len != 1) {
 		DPRINTF(SPDB_INTMAP,
 			("pci_intr_map: could not read interrupts\n"));
 		return (ENODEV);
 	if (OF_mapintr(node, &interrupts, sizeof(interrupts),
 		sizeof(interrupts)) < 0) {
 		printf("OF_mapintr failed\n");
 		KASSERT(pa->pa_pc->spc_find_ino);
 		pa->pa_pc->spc_find_ino(pa, &interrupts);
 	DPRINTF(SPDB_INTMAP, ("OF_mapintr() gave %x\n", interrupts));
 	/* Try to find an IPL for this type of device. */
 	prom_getpropstringA(node, "device_type", devtype, sizeof(devtype));
 	for (len = 0; intrmap[len].in_class != NULL; len++)
 		if (strcmp(intrmap[len].in_class, devtype) == 0) {
 			interrupts |= INTLEVENCODE(intrmap[len].in_lev);
 			DPRINTF(SPDB_INTMAP, ("reset to %x\n", interrupts));
 			break;
 	/* XXXX -- we use the ino.  What if there is a valid IGN? */
 	*ihp = interrupts;
 	return (0);
 const char *
 pci_intr_string(pci_chipset_tag_t pc, pci_intr_handle_t ih)
+{
 	static char str[16];
 	sprintf(str, "ivec %x", ih);
 	DPRINTF(SPDB_INTR, ("pci_intr_string: returning %s\n", str));
 	return (str);
+}
 const struct evcnt *
 pci_intr_evcnt(pci_chipset_tag_t pc, pci_intr_handle_t ih)

 @@ -1,14 +1,14 @@
-/*	$NetBSD: psycho.c,v 1.96 2009/11/27 22:31:29 mrg Exp $	*/
+/*	$NetBSD: psycho.c,v 1.97 2009/11/30 05:00:58 mrg Exp $	*/
 /*
  * Copyright (c) 1999, 2000 Matthew R. Green
  * 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.
 @@ -45,27 +45,27 @@
  * 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/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: psycho.c,v 1.96 2009/11/27 22:31:29 mrg Exp $");
+__KERNEL_RCSID(0, "$NetBSD: psycho.c,v 1.97 2009/11/30 05:00:58 mrg Exp $");
 #include "opt_ddb.h"
 /*
  * Support for `psycho' and `psycho+' UPA to PCI bridge and
  * UltraSPARC IIi and IIe `sabre' PCI controllers.
  */
 #ifdef DEBUG
 #define PDB_PROM	0x01
 #define PDB_BUSMAP	0x02
 #define PDB_INTR	0x04
 #define PDB_INTMAP	0x08
 @@ -106,26 +106,28 @@ int psycho_debug = 0x0;
 static pci_chipset_tag_t psycho_alloc_chipset(struct psycho_pbm *, int,
 	pci_chipset_tag_t);
 static struct extent *psycho_alloc_extent(struct psycho_pbm *, int, int,
 	const char *);
 static void psycho_get_bus_range(int, int *);
 static void psycho_get_ranges(int, struct psycho_ranges **, int *);
 static void psycho_set_intr(struct psycho_softc *, int, void *, uint64_t *,
 	uint64_t *);
 /* chipset handlers */
 static pcireg_t	psycho_pci_conf_read(pci_chipset_tag_t, pcitag_t, int);
 static void	psycho_pci_conf_write(pci_chipset_tag_t, pcitag_t, int,
 				      pcireg_t);
 static int	psycho_pci_intr_map(struct pci_attach_args *,
 				     pci_intr_handle_t *);
 static void	*psycho_pci_intr_establish(pci_chipset_tag_t,
 					   pci_intr_handle_t,
 					   int, int (*)(void *), void *);
 static int	psycho_pci_find_ino(struct pci_attach_args *,
 				    pci_intr_handle_t *);
 /* Interrupt handlers */
 static int psycho_ue(void *);
 static int psycho_ce(void *);
 static int psycho_bus_a(void *);
 static int psycho_bus_b(void *);
 static int psycho_powerfail(void *);
 static int psycho_wakeup(void *);
 @@ -741,26 +743,27 @@ psycho_power_button_pressed(void *arg)
 static pci_chipset_tag_t
 psycho_alloc_chipset(struct psycho_pbm *pp, int node, pci_chipset_tag_t pc)
+{
 	pci_chipset_tag_t npc;
 	npc = malloc(sizeof *npc, M_DEVBUF, M_NOWAIT);
 	if (npc == NULL)
 		panic("could not allocate pci_chipset_tag_t");
 	memcpy(npc, pc, sizeof *pc);
 	npc->cookie = pp;
 	npc->rootnode = node;
 	npc->spc_conf_read = psycho_pci_conf_read;
 	npc->spc_conf_write = psycho_pci_conf_write;
 	npc->spc_intr_map = psycho_pci_intr_map;
 	npc->spc_intr_establish = psycho_pci_intr_establish;
 	npc->spc_find_ino = psycho_pci_find_ino;
 	return (npc);
+}
 /*
  * create extent for free bus space, then allocate assigned regions.
  */
 static struct extent *
 psycho_alloc_extent(struct psycho_pbm *pp, int node, int ss, const char *name)
+{
 	struct psycho_registers *pa = NULL;
 @@ -1379,26 +1382,69 @@ psycho_pci_conf_write(pci_chipset_tag_t
 		(long long)(sc->sc_configaddr._ptr + PCITAG_OFFSET(tag) + reg),
 		(int)PCITAG_OFFSET(tag) + reg));
 	/* If we don't know it, just punt it.  */
 	if (PCITAG_NODE(tag) == -1) {
 		DPRINTF(PDB_CONF, ("pci_conf_write: bad addr"));
 		return;
+	}
 	bus_space_write_4(sc->sc_configtag, sc->sc_configaddr,
 		PCITAG_OFFSET(tag) + reg, data);
+}
 /*
  * interrupt mapping foo.
  * XXX: how does this deal with multiple interrupts for a device?
  */
 int
 psycho_pci_intr_map(struct pci_attach_args *pa, pci_intr_handle_t *ihp)
+{
 	pcitag_t tag = pa->pa_tag;
 	int interrupts, *intp;
 	int len, node = PCITAG_NODE(tag);
 	char devtype[30];
 	intp = &interrupts;
 	len = 1;
 	if (prom_getprop(node, "interrupts", sizeof(interrupts),
 			&len, &intp) != 0 || len != 1) {
 		DPRINTF(PDB_INTMAP,
 			("pci_intr_map: could not read interrupts\n"));
 		return (ENODEV);
+	}
 	if (OF_mapintr(node, &interrupts, sizeof(interrupts),
 		sizeof(interrupts)) < 0) {
 		printf("OF_mapintr failed\n");
 		KASSERT(pa->pa_pc->spc_find_ino);
 		pa->pa_pc->spc_find_ino(pa, &interrupts);
+	}
 	DPRINTF(PDB_INTMAP, ("OF_mapintr() gave %x\n", interrupts));
 	/* Try to find an IPL for this type of device. */
 	prom_getpropstringA(node, "device_type", devtype, sizeof(devtype));
 	for (len = 0; intrmap[len].in_class != NULL; len++)
 		if (strcmp(intrmap[len].in_class, devtype) == 0) {
 			interrupts |= INTLEVENCODE(intrmap[len].in_lev);
 			DPRINTF(PDB_INTMAP, ("reset to %x\n", interrupts));
 			break;
+		}
 	/* XXXX -- we use the ino.  What if there is a valid IGN? */
 	*ihp = interrupts;
 	return (0);
+}
 static void *
 psycho_pci_intr_establish(pci_chipset_tag_t pc, pci_intr_handle_t ih, int level,
 	int (*func)(void *), void *arg)
+{
 	void *cookie;
 	struct psycho_pbm *pp = (struct psycho_pbm *)pc->cookie;
 	DPRINTF(PDB_INTR, ("%s: ih %lx; level %d", __func__, (u_long)ih, level));
 	cookie = bus_intr_establish(pp->pp_memt, ih, level, func, arg);
 	DPRINTF(PDB_INTR, ("; returning handle %p\n", cookie));
 	return (cookie);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: schizo.c,v 1.9 2009/11/27 22:31:29 mrg Exp $	*/
+/*	$NetBSD: schizo.c,v 1.10 2009/11/30 05:00:58 mrg Exp $	*/
 /*	$OpenBSD: schizo.c,v 1.55 2008/08/18 20:29:37 brad Exp $	*/
 /*
  * Copyright (c) 2002 Jason L. Wright (jason@thought.net)
  * Copyright (c) 2003 Henric Jungheim
  * 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
 @@ -84,33 +84,33 @@ int schizo_pci_error(void *);
 pci_chipset_tag_t schizo_alloc_chipset(struct schizo_pbm *, int,
     pci_chipset_tag_t);
 bus_space_tag_t schizo_alloc_mem_tag(struct schizo_pbm *);
 bus_space_tag_t schizo_alloc_io_tag(struct schizo_pbm *);
 bus_space_tag_t schizo_alloc_config_tag(struct schizo_pbm *);
 bus_space_tag_t schizo_alloc_bus_tag(struct schizo_pbm *, const char *,
     int);
 bus_dma_tag_t schizo_alloc_dma_tag(struct schizo_pbm *);
 pcireg_t schizo_conf_read(pci_chipset_tag_t, pcitag_t, int);
 void schizo_conf_write(pci_chipset_tag_t, pcitag_t, int, pcireg_t);
 int schizo_intr_map(struct pci_attach_args *, pci_intr_handle_t *);
 int schizo_bus_map(bus_space_tag_t t, bus_addr_t offset, bus_size_t size,
 	           int flags, vaddr_t unused, bus_space_handle_t *hp);
 static paddr_t schizo_bus_mmap(bus_space_tag_t t, bus_addr_t paddr,
                                off_t off, int prot, int flags);
 static void *schizo_intr_establish(bus_space_tag_t, int, int, int (*)(void *),
 	void *, void(*)(void));
 static int schizo_pci_intr_map(struct pci_attach_args *, pci_intr_handle_t *);
 static void *schizo_pci_intr_establish(pci_chipset_tag_t, pci_intr_handle_t,
                                        int, int (*)(void *), void *);
 static int schizo_pci_find_ino(struct pci_attach_args *, pci_intr_handle_t *);
 static int schizo_dmamap_create(bus_dma_tag_t, bus_size_t, int, bus_size_t,
 	bus_size_t, int, bus_dmamap_t *);
 int
 schizo_match(struct device *parent, struct cfdata *match, void *aux)
+{
 	struct mainbus_attach_args *ma = aux;
 	char *str;
 	if (strcmp(ma->ma_name, "pci") != 0)
 @@ -126,50 +126,48 @@ schizo_match(struct device *parent, stru
 	if (strcmp(str, "pci108e,8002") == 0)		/* XMITS */
 		return (1);
 	if (strcmp(str, "pci108e,a801") == 0)		/* Tomatillo */
 		return (1);
 	return (0);
+}
 void
 schizo_attach(struct device *parent, struct device *self, void *aux)
+{
 	struct schizo_softc *sc = (struct schizo_softc *)self;
 	struct mainbus_attach_args *ma = aux;
-	uint64_t eccctrl, csr;
+	uint64_t eccctrl;
 	char *str;
 	printf(": addr %lx", ma->ma_reg[0].ur_paddr);
 	str = prom_getpropstring(ma->ma_node, "compatible");
 	if (strcmp(str, "pci108e,a801") == 0)
 		sc->sc_tomatillo = 1;
 	sc->sc_node = ma->ma_node;
 	sc->sc_dmat = ma->ma_dmatag;
 	sc->sc_bustag = ma->ma_bustag;
 	sc->sc_ctrl = ma->ma_reg[1].ur_paddr - 0x10000UL;
 	sc->sc_reg0 = ma->ma_reg[0];
 	if (bus_space_map(sc->sc_bustag, sc->sc_ctrl,
 	    sizeof(struct schizo_regs), 0,
 	    &sc->sc_ctrlh)) {
 		printf(": failed to map registers\n");
 		return;
+	}
-	csr = schizo_read(sc, SCZ_CONTROL_STATUS);
+	sc->sc_ign = INTIGN(ma->ma_upaid << INTMAP_IGN_SHIFT);
 	sc->sc_ign = ((csr & SCZ_CONTROL_STATUS_AID_MASK) >>
 		       SCZ_CONTROL_STATUS_AID_SHIFT);
 	/* enable schizo ecc error interrupts */
 	eccctrl = schizo_read(sc, SCZ_ECCCTRL);
 	eccctrl |= SCZ_ECCCTRL_EE_INTEN |
 		   SCZ_ECCCTRL_UE_INTEN |
 		   SCZ_ECCCTRL_CE_INTEN;
 	schizo_write(sc, SCZ_ECCCTRL, eccctrl);
 	schizo_init(sc);
+}
 void
 schizo_init(struct schizo_softc *sc)
 @@ -577,26 +575,27 @@ schizo_alloc_dma_tag(struct schizo_pbm *
 pci_chipset_tag_t
 schizo_alloc_chipset(struct schizo_pbm *pbm, int node, pci_chipset_tag_t pc)
+{
 	pci_chipset_tag_t npc;
 	npc = malloc(sizeof *npc, M_DEVBUF, M_NOWAIT);
 	if (npc == NULL)
 		panic("schizo: could not allocate pci_chipset_tag_t");
 	memcpy(npc, pc, sizeof *pc);
 	npc->cookie = pbm;
 	npc->rootnode = node;
 	npc->spc_conf_read = schizo_conf_read;
 	npc->spc_conf_write = schizo_conf_write;
 	npc->spc_intr_map = schizo_pci_intr_map;
 	npc->spc_intr_establish = schizo_pci_intr_establish;
 	npc->spc_find_ino = schizo_pci_find_ino;
 	return (npc);
+}
 int
 schizo_dmamap_create(bus_dma_tag_t t, bus_size_t size,
     int nsegments, bus_size_t maxsegsz, bus_size_t boundary, int flags,
     bus_dmamap_t *dmamp)
+{
 	struct schizo_pbm *pbm = t->_cookie;
 	int error;
 @@ -672,26 +671,71 @@ schizo_bus_mmap(bus_space_tag_t t, bus_a
 	if (sr != NULL) {
 		paddr = BUS_ADDR(sr->phys_hi, sr->phys_lo + offset);
 		DPRINTF(SDB_BUSMAP, ("%s: mapping paddr "
 				     "space %lx offset %lx paddr %qx\n",
 			       __func__, (long)ss, (long)offset,
 			       (unsigned long long)paddr));
 		return (bus_space_mmap(sc->sc_bustag, paddr, off,
 				       prot, flags));
+	}
 	DPRINTF(SDB_BUSMAP, ("%s: FAILED\n", __func__));
 	return (-1);
+}
 /*
  * interrupt mapping foo.
  * XXX: how does this deal with multiple interrupts for a device?
  */
 int
 schizo_pci_intr_map(struct pci_attach_args *pa, pci_intr_handle_t *ihp)
+{
 	pcitag_t tag = pa->pa_tag;
 	struct schizo_pbm *pbm = pa->pa_pc->cookie;
 	struct schizo_softc *sc = pbm->sp_sc;
 	int interrupts, *intp;
 	int len, node = PCITAG_NODE(tag);
 	char devtype[30];
 	intp = &interrupts;
 	len = 1;
 	if (prom_getprop(node, "interrupts", sizeof(interrupts),
 			&len, &intp) != 0 || len != 1) {
 		DPRINTF(SDB_INTMAP,
 			("pci_intr_map: could not read interrupts\n"));
 		return (ENODEV);
+	}
 	if (OF_mapintr(node, &interrupts, sizeof(interrupts),
 		sizeof(interrupts)) < 0) {
 		printf("OF_mapintr failed\n");
 		KASSERT(pa->pa_pc->spc_find_ino);
 		pa->pa_pc->spc_find_ino(pa, &interrupts);
+	}
 	DPRINTF(SDB_INTMAP, ("OF_mapintr() gave %x\n", interrupts));
 	/* Try to find an IPL for this type of device. */
 	prom_getpropstringA(node, "device_type", devtype, sizeof(devtype));
 	for (len = 0; intrmap[len].in_class != NULL; len++)
 		if (strcmp(intrmap[len].in_class, devtype) == 0) {
 			interrupts |= INTLEVENCODE(intrmap[len].in_lev);
 			DPRINTF(SDB_INTMAP, ("reset to %x\n", interrupts));
 			break;
+		}
 	*ihp = interrupts | sc->sc_ign;
 	DPRINTF(SDB_INTMAP, ("returning IGN adjusted to %x\n", *ihp));
 	return (0);
+}
 static void *
 schizo_intr_establish(bus_space_tag_t t, int ihandle, int level,
 	int (*handler)(void *), void *arg, void (*fastvec)(void) /* ignored */)
+{
 	struct schizo_pbm *pbm = t->cookie;
 	struct schizo_softc *sc = pbm->sp_sc;
 	struct intrhand *ih = NULL;
 	uint64_t mapoff, clroff;
 	volatile uint64_t *intrmapptr = NULL, *intrclrptr = NULL;
 	int ino;
 	long vec;
 	vec = INTVEC(ihandle);

 @@ -1,14 +1,14 @@
-/* $NetBSD: pci_machdep.h,v 1.22 2008/12/10 03:31:51 mrg Exp $ */
+/* $NetBSD: pci_machdep.h,v 1.23 2009/11/30 05:00:58 mrg Exp $ */
 /*
  * Copyright (c) 1999 Matthew R. Green
  * 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.
 @@ -57,54 +57,56 @@ struct pci_attach_args;
 typedef uint64_t pcitag_t;
 typedef struct sparc_pci_chipset *pci_chipset_tag_t;
 typedef u_int pci_intr_handle_t;
 struct sparc_pci_chipset {
 	void		*cookie;	/* psycho_pbm/, but sssh! */
 	int		rootnode;	/* PCI controller */
 	/* pci(9) interfaces */
 	pcireg_t	(*spc_conf_read)(pci_chipset_tag_t, pcitag_t, int);
 	void		(*spc_conf_write)(pci_chipset_tag_t, pcitag_t, int, pcireg_t);
 	int		(*spc_intr_map)(struct pci_attach_args *, pci_intr_handle_t *);
 	void		*(*spc_intr_establish)(pci_chipset_tag_t, pci_intr_handle_t, int, int (*)(void *), void *);
 	/* private interfaces */
 	int		(*spc_find_ino)(struct pci_attach_args *, pci_intr_handle_t *);
 	int		spc_busmax;
 	struct spc_busnode {
 		int	node;
 		int	(*valid)(void *);
 		void	*arg;
 	}		(*spc_busnode)[256];
 };
 void		pci_attach_hook(struct device *, struct device *,
 				     struct pcibus_attach_args *);
 int		pci_bus_maxdevs(pci_chipset_tag_t, int);
 pcitag_t	pci_make_tag(pci_chipset_tag_t, int, int, int);
 void		pci_decompose_tag(pci_chipset_tag_t, pcitag_t, int *, int *,
 		    int *);
 int		pci_intr_map(struct pci_attach_args *, pci_intr_handle_t *);
 const char	*pci_intr_string(pci_chipset_tag_t, pci_intr_handle_t);
 const struct evcnt *pci_intr_evcnt(pci_chipset_tag_t, pci_intr_handle_t);
 void		pci_intr_disestablish(pci_chipset_tag_t, void *);
 int		sparc64_pci_enumerate_bus(struct pci_softc *, const int *,
 		    int (*)(struct pci_attach_args *),
 		    struct pci_attach_args *);
 #define PCI_MACHDEP_ENUMERATE_BUS sparc64_pci_enumerate_bus
 #define	pci_conf_read(pc, tag, reg) \
 		((pc)->spc_conf_read(pc, tag, reg))
 #define	pci_conf_write(pc, tag, reg, val) \
 		((pc)->spc_conf_write(pc, tag, reg, val))
 #define	pci_intr_map(pa, handle) \
 		((pa)->pa_pc->spc_intr_map(pa, handle))
 #define	pci_intr_establish(pc, handle, level, func, arg) \
 		((pc)->spc_intr_establish(pc, handle, level, func, arg))
 /* SPARC specific PCI interfaces */
 int		sparc_pci_childspace(int);
 #endif /* _MACHINE_PCI_MACHDEP_H_ */