d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Move Open Firmware device root on PowerPC, ARM, and MIPS systems to

Browse Source 
a sub-node of nexus (ofwbus) rather than direct attach under nexus. This
fixes FDT on x86 and will make coexistence with ACPI on ARM systems easier.
SPARC is unchanged.

Reviewed by:	imp, ian
This commit is contained in:
Nathan Whitehorn 2014-02-05 14:44:22 +00:00
parent 2fdfccfd7c
commit 65d08437ef
31 changed files with 166 additions and 279 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
sys/arm/arm/nexus.c
View File

@ -63,11 +63,11 @@ __FBSDID("$FreeBSD$");
#include "opt_platform.h"
#ifdef FDT
#include <dev/ofw/ofw_nexus.h>
#include <dev/fdt/fdt_common.h>
#include <machine/fdt.h>
#include "ofw_bus_if.h"
#else
#endif
static MALLOC_DEFINE(M_NEXUSDEV, "nexusdev", "Nexus device");
struct nexus_device {
@ -84,7 +84,6 @@ static int nexus_print_child(device_t, device_t);
static device_t nexus_add_child(device_t, u_int, const char *, int);
static struct resource *nexus_alloc_resource(device_t, device_t, int, int *,
u_long, u_long, u_long, u_int);
#endif
static int nexus_activate_resource(device_t, device_t, int, int,
struct resource *);
static int nexus_config_intr(device_t dev, int irq, enum intr_trigger trig,
@ -102,7 +101,6 @@ static int nexus_ofw_map_intr(device_t dev, device_t child, phandle_t iparent,
#endif
static device_method_t nexus_methods[] = {
#ifndef FDT
/* Device interface */
DEVMETHOD(device_probe, nexus_probe),
DEVMETHOD(device_attach, nexus_attach),
@ -110,7 +108,6 @@ static device_method_t nexus_methods[] = {
DEVMETHOD(bus_print_child, nexus_print_child),
DEVMETHOD(bus_add_child, nexus_add_child),
DEVMETHOD(bus_alloc_resource, nexus_alloc_resource),
#endif
DEVMETHOD(bus_activate_resource, nexus_activate_resource),
DEVMETHOD(bus_config_intr, nexus_config_intr),
DEVMETHOD(bus_deactivate_resource, nexus_deactivate_resource),
@ -123,19 +120,13 @@ static device_method_t nexus_methods[] = {
};
static devclass_t nexus_devclass;
#ifndef FDT
static driver_t nexus_driver = {
"nexus",
nexus_methods,
1 /* no softc */
};
#else
DEFINE_CLASS_1(nexus, nexus_driver, nexus_methods,
sizeof(struct ofw_nexus_softc), ofw_nexus_driver);
#endif
DRIVER_MODULE(nexus, root, nexus_driver, nexus_devclass, 0, 0);
#ifndef FDT
static int
nexus_probe(device_t dev)
{
@ -235,7 +226,6 @@ nexus_alloc_resource(device_t bus, device_t child, int type, int *rid,
return (rv);
}
#endif
static int
nexus_config_intr(device_t dev, int irq, enum intr_trigger trig,

2
sys/arm/broadcom/bcm2835/bcm2835_fb.c
View File

@ -361,7 +361,7 @@ static driver_t bcm_fb_driver = {
sizeof(struct bcmsc_softc),
};
DRIVER_MODULE(bcm2835fb, nexus, bcm_fb_driver, bcm_fb_devclass, 0, 0);
DRIVER_MODULE(bcm2835fb, ofwbus, bcm_fb_driver, bcm_fb_devclass, 0, 0);
/*
* Video driver routines and glue.

2
sys/arm/broadcom/bcm2835/bcm2835_fbd.c
View File

@ -315,4 +315,4 @@ static driver_t bcm_fb_driver = {
sizeof(struct bcmsc_softc),
};
DRIVER_MODULE(bcm2835fb, nexus, bcm_fb_driver, bcm_fb_devclass, 0, 0);
DRIVER_MODULE(bcm2835fb, ofwbus, bcm_fb_driver, bcm_fb_devclass, 0, 0);

4
sys/arm/freescale/imx/tzic.c
View File

@ -146,9 +146,9 @@ static devclass_t tzic_devclass;
/*
* Memory space of controller located outside of device range, so let him to
* attach not only to simplebus, but nexus also.
* attach not only to simplebus, but ofwbus also.
*/
EARLY_DRIVER_MODULE(tzic, nexus, tzic_driver, tzic_devclass, 0, 0,
EARLY_DRIVER_MODULE(tzic, ofwbus, tzic_driver, tzic_devclass, 0, 0,
BUS_PASS_INTERRUPT);
EARLY_DRIVER_MODULE(tzic, simplebus, tzic_driver, tzic_devclass, 0, 0,
BUS_PASS_INTERRUPT);

2
sys/arm/mv/mv_localbus.c
View File

@ -156,7 +156,7 @@ static struct localbus_bank localbus_banks[MV_LOCALBUS_MAX_BANKS];
devclass_t localbus_devclass;
DRIVER_MODULE(localbus, nexus, localbus_driver, localbus_devclass, 0, 0);
DRIVER_MODULE(localbus, ofwbus, localbus_driver, localbus_devclass, 0, 0);
static int
fdt_localbus_reg_decode(phandle_t node, struct localbus_softc *sc,

2
sys/arm/mv/mv_pci.c
View File

@ -398,7 +398,7 @@ static driver_t mv_pcib_driver = {
devclass_t pcib_devclass;
DRIVER_MODULE(pcib, nexus, mv_pcib_driver, pcib_devclass, 0, 0);
DRIVER_MODULE(pcib, ofwbus, mv_pcib_driver, pcib_devclass, 0, 0);
static struct mtx pcicfg_mtx;

3
sys/conf/files
View File

@ -1370,7 +1370,6 @@ dev/fdt/fdt_common.c optional fdt
dev/fdt/fdt_slicer.c optional fdt cfi | fdt nand
dev/fdt/fdt_static_dtb.S optional fdt fdt_dtb_static \
dependency "$S/boot/fdt/dts/${FDT_DTS_FILE}"
dev/fdt/fdtbus.c optional fdtbus
dev/fdt/simplebus.c optional fdt
dev/fe/if_fe.c optional fe
dev/fe/if_fe_pccard.c optional fe pccard
@ -1886,7 +1885,7 @@ dev/ofw/ofw_bus_subr.c optional fdt
dev/ofw/ofw_fdt.c optional fdt
dev/ofw/ofw_if.m optional fdt
dev/ofw/ofw_iicbus.c optional fdt iicbus
dev/ofw/ofw_nexus.c optional fdt
dev/ofw/ofwbus.c optional fdt
dev/ofw/openfirm.c optional fdt
dev/ofw/openfirmio.c optional fdt
dev/patm/if_patm.c optional patm pci

2
sys/conf/files.powerpc
View File

@ -48,7 +48,7 @@ dev/ofw/ofw_bus_subr.c optional aim
dev/ofw/ofw_console.c optional aim
dev/ofw/ofw_disk.c optional ofwd aim
dev/ofw/ofw_iicbus.c optional iicbus aim
dev/ofw/ofw_nexus.c optional aim | fdt
dev/ofw/ofwbus.c optional aim | fdt
dev/ofw/ofw_standard.c optional aim powerpc
dev/powermac_nvram/powermac_nvram.c optional powermac_nvram powermac
dev/quicc/quicc_bfe_fdt.c optional quicc mpc85xx

91
sys/dev/fdt/fdtbus.c
View File

@ -1,91 +0,0 @@
/*-
* Copyright (c) 2009-2010 The FreeBSD Foundation
* All rights reserved.
*
* This software was developed by Semihalf under sponsorship from
* the FreeBSD Foundation.
*
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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>
__FBSDID("$FreeBSD$");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/ktr.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/bus.h>
#include <sys/rman.h>
#include <sys/malloc.h>
#include <dev/ofw/openfirm.h>
#include <dev/ofw/ofw_nexus.h>
#include "ofw_bus_if.h"
/*
* Prototypes.
*/
static void fdtbus_identify(driver_t *, device_t);
static int fdtbus_probe(device_t);
/*
* Bus interface definition.
*/
static device_method_t fdtbus_methods[] = {
/* Device interface */
DEVMETHOD(device_identify, fdtbus_identify),
DEVMETHOD(device_probe, fdtbus_probe),
/* Bus interface */
DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
DEVMETHOD(bus_config_intr, bus_generic_config_intr),
DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
DEVMETHOD_END
};
devclass_t fdtbus_devclass;
DEFINE_CLASS_1(fdtbus, fdtbus_driver, fdtbus_methods,
sizeof(struct ofw_nexus_softc), ofw_nexus_driver);
DRIVER_MODULE(fdtbus, nexus, fdtbus_driver, fdtbus_devclass, 0, 0);
static void
fdtbus_identify(driver_t *driver, device_t parent)
{
if (device_find_child(parent, "fdtbus", -1) == NULL)
BUS_ADD_CHILD(parent, 0, "fdtbus", -1);
}
static int
fdtbus_probe(device_t dev)
{
device_set_desc(dev, "Flattened Device Tree");
return (BUS_PROBE_NOWILDCARD);
}

2
sys/dev/fdt/simplebus.c
View File

@ -121,7 +121,7 @@ static driver_t simplebus_driver = {
sizeof(struct simplebus_softc)
};
static devclass_t simplebus_devclass;
DRIVER_MODULE(simplebus, nexus, simplebus_driver, simplebus_devclass, 0, 0);
DRIVER_MODULE(simplebus, ofwbus, simplebus_driver, simplebus_devclass, 0, 0);
DRIVER_MODULE(simplebus, simplebus, simplebus_driver, simplebus_devclass, 0, 0);
static int

40
sys/dev/ofw/ofw_nexus.h
View File

@ -1,40 +0,0 @@
/*-
* Copyright (c) 2010 Marius Strobl <marius@FreeBSD.org>
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.
*
* $FreeBSD$
*/
#ifndef _OFW_NEXUS_H_
#define _OFW_NEXUS_H_
struct ofw_nexus_softc {
uint32_t acells, scells;
struct rman sc_intr_rman;
struct rman sc_mem_rman;
};
DECLARE_CLASS(ofw_nexus_driver);
#endif /* _OFW_NEXUS_H_ */

191
sys/dev/ofw/ofw_nexus.c → sys/dev/ofw/ofwbus.c
View File

@ -49,69 +49,78 @@ __FBSDID("$FreeBSD$");
#include <dev/ofw/ofw_bus.h>
#include <dev/ofw/ofw_bus_subr.h>
#include <dev/ofw/ofw_nexus.h>
#include <dev/ofw/openfirm.h>
#include <machine/bus.h>
#include <machine/resource.h>
/*
* The nexus (which is a pseudo-bus actually) iterates over the nodes that
* The ofwbus (which is a pseudo-bus actually) iterates over the nodes that
* hang from the Open Firmware root node and adds them as devices to this bus
* (except some special nodes which are excluded) so that drivers can be
* attached to them.
*
* Additionally, interrupt setup/teardown and some resource management are
* done at this level.
*
*/
struct nexus_devinfo {
struct ofwbus_devinfo {
struct ofw_bus_devinfo ndi_obdinfo;
struct resource_list ndi_rl;
};
static device_probe_t nexus_probe;
static device_attach_t nexus_attach;
static bus_print_child_t nexus_print_child;
static bus_add_child_t nexus_add_child;
static bus_probe_nomatch_t nexus_probe_nomatch;
static bus_alloc_resource_t nexus_alloc_resource;
static bus_adjust_resource_t nexus_adjust_resource;
static bus_release_resource_t nexus_release_resource;
static bus_get_resource_list_t nexus_get_resource_list;
static ofw_bus_get_devinfo_t nexus_get_devinfo;
struct ofwbus_softc {
uint32_t acells, scells;
struct rman sc_intr_rman;
struct rman sc_mem_rman;
};
static int nexus_inlist(const char *, const char *const *);
static struct nexus_devinfo * nexus_setup_dinfo(device_t, phandle_t);
static void nexus_destroy_dinfo(struct nexus_devinfo *);
static int nexus_print_res(struct nexus_devinfo *);
static device_identify_t ofwbus_identify;
static device_probe_t ofwbus_probe;
static device_attach_t ofwbus_attach;
static bus_print_child_t ofwbus_print_child;
static bus_add_child_t ofwbus_add_child;
static bus_probe_nomatch_t ofwbus_probe_nomatch;
static bus_alloc_resource_t ofwbus_alloc_resource;
static bus_adjust_resource_t ofwbus_adjust_resource;
static bus_release_resource_t ofwbus_release_resource;
static bus_get_resource_list_t ofwbus_get_resource_list;
static ofw_bus_get_devinfo_t ofwbus_get_devinfo;
static device_method_t nexus_methods[] = {
static int ofwbus_inlist(const char *, const char *const *);
static struct ofwbus_devinfo * ofwbus_setup_dinfo(device_t, phandle_t);
static void ofwbus_destroy_dinfo(struct ofwbus_devinfo *);
static int ofwbus_print_res(struct ofwbus_devinfo *);
static device_method_t ofwbus_methods[] = {
/* Device interface */
DEVMETHOD(device_probe, nexus_probe),
DEVMETHOD(device_attach, nexus_attach),
DEVMETHOD(device_identify, ofwbus_identify),
DEVMETHOD(device_probe, ofwbus_probe),
DEVMETHOD(device_attach, ofwbus_attach),
DEVMETHOD(device_detach, bus_generic_detach),
DEVMETHOD(device_shutdown, bus_generic_shutdown),
DEVMETHOD(device_suspend, bus_generic_suspend),
DEVMETHOD(device_resume, bus_generic_resume),
/* Bus interface */
DEVMETHOD(bus_print_child, nexus_print_child),
DEVMETHOD(bus_probe_nomatch, nexus_probe_nomatch),
DEVMETHOD(bus_print_child, ofwbus_print_child),
DEVMETHOD(bus_probe_nomatch, ofwbus_probe_nomatch),
DEVMETHOD(bus_read_ivar, bus_generic_read_ivar),
DEVMETHOD(bus_write_ivar, bus_generic_write_ivar),
DEVMETHOD(bus_add_child, nexus_add_child),
DEVMETHOD(bus_add_child, ofwbus_add_child),
DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str),
DEVMETHOD(bus_alloc_resource, nexus_alloc_resource),
DEVMETHOD(bus_adjust_resource, nexus_adjust_resource),
DEVMETHOD(bus_release_resource, nexus_release_resource),
DEVMETHOD(bus_alloc_resource, ofwbus_alloc_resource),
DEVMETHOD(bus_adjust_resource, ofwbus_adjust_resource),
DEVMETHOD(bus_release_resource, ofwbus_release_resource),
DEVMETHOD(bus_set_resource, bus_generic_rl_set_resource),
DEVMETHOD(bus_get_resource, bus_generic_rl_get_resource),
DEVMETHOD(bus_get_resource_list, nexus_get_resource_list),
DEVMETHOD(bus_get_resource_list, ofwbus_get_resource_list),
DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
DEVMETHOD(bus_config_intr, bus_generic_config_intr),
DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
/* ofw_bus interface */
DEVMETHOD(ofw_bus_get_devinfo, nexus_get_devinfo),
DEVMETHOD(ofw_bus_get_devinfo, ofwbus_get_devinfo),
DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat),
DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model),
DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name),
@ -121,11 +130,16 @@ static device_method_t nexus_methods[] = {
DEVMETHOD_END
};
DEFINE_CLASS_0(ofw_nexus, ofw_nexus_driver, nexus_methods,
sizeof(struct ofw_nexus_softc));
MODULE_VERSION(ofw_nexus, 1);
static driver_t ofwbus_driver = {
"ofwbus",
ofwbus_methods,
sizeof(struct ofwbus_softc)
};
static devclass_t ofwbus_devclass;
DRIVER_MODULE(ofwbus, nexus, ofwbus_driver, ofwbus_devclass, 0, 0);
MODULE_VERSION(ofwbus, 1);
static const char *const nexus_excl_name[] = {
static const char *const ofwbus_excl_name[] = {
"FJSV,system",
"aliases",
"associations",
@ -145,14 +159,14 @@ static const char *const nexus_excl_name[] = {
NULL
};
static const char *const nexus_excl_type[] = {
static const char *const ofwbus_excl_type[] = {
"core",
"cpu",
NULL
};
static int
nexus_inlist(const char *name, const char *const *list)
ofwbus_inlist(const char *name, const char *const *list)
{
int i;
@ -164,24 +178,35 @@ nexus_inlist(const char *name, const char *const *list)
return (0);
}
#define NEXUS_EXCLUDED(name, type) \
(nexus_inlist((name), nexus_excl_name) || \
((type) != NULL && nexus_inlist((type), nexus_excl_type)))
#define OFWBUS_EXCLUDED(name, type) \
(ofwbus_inlist((name), ofwbus_excl_name) || \
((type) != NULL && ofwbus_inlist((type), ofwbus_excl_type)))
static int
nexus_probe(device_t dev)
static void
ofwbus_identify(driver_t *driver, device_t parent)
{
/* Nexus does always match. */
device_set_desc(dev, "Open Firmware Nexus device");
return (0);
/* Check if Open Firmware has been instantiated */
if (OF_peer(0) == -1)
return;
if (device_find_child(parent, "ofwbus", -1) == NULL)
BUS_ADD_CHILD(parent, 0, "ofwbus", -1);
}
static int
nexus_attach(device_t dev)
ofwbus_probe(device_t dev)
{
struct nexus_devinfo *ndi;
struct ofw_nexus_softc *sc;
device_set_desc(dev, "Open Firmware Device Tree");
return (BUS_PROBE_NOWILDCARD);
}
static int
ofwbus_attach(device_t dev)
{
struct ofwbus_devinfo *ndi;
struct ofwbus_softc *sc;
device_t cdev;
phandle_t node;
@ -189,6 +214,12 @@ nexus_attach(device_t dev)
node = OF_peer(0);
/*
* If no Open Firmware, bail early
*/
if (node == -1)
return (ENXIO);
sc->sc_intr_rman.rm_type = RMAN_ARRAY;
sc->sc_intr_rman.rm_descr = "Interrupts";
sc->sc_mem_rman.rm_type = RMAN_ARRAY;
@ -204,12 +235,6 @@ nexus_attach(device_t dev)
*/
bus_generic_probe(dev);
/*
* If no Open Firmware, bail early
*/
if (node == -1)
return (bus_generic_attach(dev));
/*
* Some important numbers
*/
@ -222,13 +247,13 @@ nexus_attach(device_t dev)
* Now walk the OFW tree and attach top-level devices.
*/
for (node = OF_child(node); node > 0; node = OF_peer(node)) {
if ((ndi = nexus_setup_dinfo(dev, node)) == NULL)
if ((ndi = ofwbus_setup_dinfo(dev, node)) == NULL)
continue;
cdev = device_add_child(dev, NULL, -1);
if (cdev == NULL) {
device_printf(dev, "<%s>: device_add_child failed\n",
ndi->ndi_obdinfo.obd_name);
nexus_destroy_dinfo(ndi);
ofwbus_destroy_dinfo(ndi);
continue;
}
device_set_ivars(cdev, ndi);
@ -237,10 +262,10 @@ nexus_attach(device_t dev)
}
static device_t
nexus_add_child(device_t dev, u_int order, const char *name, int unit)
ofwbus_add_child(device_t dev, u_int order, const char *name, int unit)
{
device_t cdev;
struct nexus_devinfo *ndi;
struct ofwbus_devinfo *ndi;
cdev = device_add_child_ordered(dev, order, name, unit);
if (cdev == NULL)
@ -255,18 +280,18 @@ nexus_add_child(device_t dev, u_int order, const char *name, int unit)
}
static int
nexus_print_child(device_t bus, device_t child)
ofwbus_print_child(device_t bus, device_t child)
{
int rv;
rv = bus_print_child_header(bus, child);
rv += nexus_print_res(device_get_ivars(child));
rv += ofwbus_print_res(device_get_ivars(child));
rv += bus_print_child_footer(bus, child);
return (rv);
}
static void
nexus_probe_nomatch(device_t bus, device_t child)
ofwbus_probe_nomatch(device_t bus, device_t child)
{
const char *name, *type;
@ -278,16 +303,16 @@ nexus_probe_nomatch(device_t bus, device_t child)
device_printf(bus, "<%s>",
name != NULL ? name : "unknown");
nexus_print_res(device_get_ivars(child));
ofwbus_print_res(device_get_ivars(child));
printf(" type %s (no driver attached)\n",
type != NULL ? type : "unknown");
}
static struct resource *
nexus_alloc_resource(device_t bus, device_t child, int type, int *rid,
ofwbus_alloc_resource(device_t bus, device_t child, int type, int *rid,
u_long start, u_long end, u_long count, u_int flags)
{
struct ofw_nexus_softc *sc;
struct ofwbus_softc *sc;
struct rman *rm;
struct resource *rv;
struct resource_list_entry *rle;
@ -344,17 +369,17 @@ nexus_alloc_resource(device_t bus, device_t child, int type, int *rid,
}
static int
nexus_adjust_resource(device_t bus, device_t child __unused, int type,
ofwbus_adjust_resource(device_t bus, device_t child __unused, int type,
struct resource *r, u_long start, u_long end)
{
struct ofw_nexus_softc *sc;
struct ofwbus_softc *sc;
struct rman *rm;
device_t nexus;
device_t ofwbus;
nexus = bus;
while (strcmp(device_get_name(device_get_parent(nexus)), "root") != 0)
nexus = device_get_parent(nexus);
sc = device_get_softc(nexus);
ofwbus = bus;
while (strcmp(device_get_name(device_get_parent(ofwbus)), "root") != 0)
ofwbus = device_get_parent(ofwbus);
sc = device_get_softc(ofwbus);
switch (type) {
case SYS_RES_IRQ:
rm = &sc->sc_intr_rman;
@ -373,7 +398,7 @@ nexus_adjust_resource(device_t bus, device_t child __unused, int type,
}
static int
nexus_release_resource(device_t bus __unused, device_t child, int type,
ofwbus_release_resource(device_t bus __unused, device_t child, int type,
int rid, struct resource *r)
{
int error;
@ -387,28 +412,28 @@ nexus_release_resource(device_t bus __unused, device_t child, int type,
}
static struct resource_list *
nexus_get_resource_list(device_t bus __unused, device_t child)
ofwbus_get_resource_list(device_t bus __unused, device_t child)
{
struct nexus_devinfo *ndi;
struct ofwbus_devinfo *ndi;
ndi = device_get_ivars(child);
return (&ndi->ndi_rl);
}
static const struct ofw_bus_devinfo *
nexus_get_devinfo(device_t bus __unused, device_t child)
ofwbus_get_devinfo(device_t bus __unused, device_t child)
{
struct nexus_devinfo *ndi;
struct ofwbus_devinfo *ndi;
ndi = device_get_ivars(child);
return (&ndi->ndi_obdinfo);
}
static struct nexus_devinfo *
nexus_setup_dinfo(device_t dev, phandle_t node)
static struct ofwbus_devinfo *
ofwbus_setup_dinfo(device_t dev, phandle_t node)
{
struct ofw_nexus_softc *sc;
struct nexus_devinfo *ndi;
struct ofwbus_softc *sc;
struct ofwbus_devinfo *ndi;
uint32_t *reg, *intr, icells;
uint64_t phys, size;
phandle_t iparent;
@ -423,7 +448,7 @@ nexus_setup_dinfo(device_t dev, phandle_t node)
free(ndi, M_DEVBUF);
return (NULL);
}
if (NEXUS_EXCLUDED(ndi->ndi_obdinfo.obd_name,
if (OFWBUS_EXCLUDED(ndi->ndi_obdinfo.obd_name,
ndi->ndi_obdinfo.obd_type)) {
ofw_bus_gen_destroy_devinfo(&ndi->ndi_obdinfo);
free(ndi, M_DEVBUF);
@ -479,7 +504,7 @@ nexus_setup_dinfo(device_t dev, phandle_t node)
}
static void
nexus_destroy_dinfo(struct nexus_devinfo *ndi)
ofwbus_destroy_dinfo(struct ofwbus_devinfo *ndi)
{
resource_list_free(&ndi->ndi_rl);
@ -488,7 +513,7 @@ nexus_destroy_dinfo(struct nexus_devinfo *ndi)
}
static int
nexus_print_res(struct nexus_devinfo *ndi)
ofwbus_print_res(struct ofwbus_devinfo *ndi)
{
int rv;

2
sys/dev/powermac_nvram/powermac_nvram.c
View File

@ -84,7 +84,7 @@ static driver_t powermac_nvram_driver = {
static devclass_t powermac_nvram_devclass;
DRIVER_MODULE(powermac_nvram, nexus, powermac_nvram_driver, powermac_nvram_devclass, 0, 0);
DRIVER_MODULE(powermac_nvram, ofwbus, powermac_nvram_driver, powermac_nvram_devclass, 0, 0);
/*
* Cdev methods.

2
sys/mips/beri/beri_simplebus.c
View File

@ -136,7 +136,7 @@ static driver_t simplebus_driver = {
devclass_t simplebus_devclass;
DRIVER_MODULE(simplebus, nexus, simplebus_driver, simplebus_devclass, 0, 0);
DRIVER_MODULE(simplebus, ofwbus, simplebus_driver, simplebus_devclass, 0, 0);
DRIVER_MODULE(simplebus, simplebus, simplebus_driver, simplebus_devclass, 0,
0);

15
sys/mips/mips/nexus.c
View File

@ -60,10 +60,6 @@ __FBSDID("$FreeBSD$");
#include "opt_platform.h"
#ifdef FDT
#include <dev/ofw/ofw_nexus.h>
#endif
#undef NEXUS_DEBUG
#ifdef NEXUS_DEBUG
#define dprintf printf
@ -73,7 +69,6 @@ __FBSDID("$FreeBSD$");
#define NUM_MIPS_IRQS 6
#ifndef FDT
static MALLOC_DEFINE(M_NEXUSDEV, "nexusdev", "Nexus device");
struct nexus_device {
@ -102,7 +97,6 @@ static int nexus_release_resource(device_t, device_t, int, int,
struct resource *);
static int nexus_set_resource(device_t, device_t, int, int, u_long,
u_long);
#endif
static int nexus_activate_resource(device_t, device_t, int, int,
struct resource *);
static int nexus_deactivate_resource(device_t, device_t, int, int,
@ -115,7 +109,6 @@ static int nexus_teardown_intr(device_t, device_t, struct resource *,
void *);
static device_method_t nexus_methods[] = {
#ifndef FDT
/* Device interface */
DEVMETHOD(device_probe, nexus_probe),
DEVMETHOD(device_attach, nexus_attach),
@ -129,7 +122,6 @@ static device_method_t nexus_methods[] = {
DEVMETHOD(bus_print_child, nexus_print_child),
DEVMETHOD(bus_release_resource, nexus_release_resource),
DEVMETHOD(bus_set_resource, nexus_set_resource),
#endif
DEVMETHOD(bus_setup_intr, nexus_setup_intr),
DEVMETHOD(bus_teardown_intr, nexus_teardown_intr),
DEVMETHOD(bus_activate_resource,nexus_activate_resource),
@ -139,19 +131,13 @@ static device_method_t nexus_methods[] = {
{ 0, 0 }
};
#ifndef FDT
static driver_t nexus_driver = {
"nexus",
nexus_methods,
1 /* no softc */
};
#else
DEFINE_CLASS_1(nexus, nexus_driver, nexus_methods,
sizeof(struct ofw_nexus_softc), ofw_nexus_driver);
#endif
static devclass_t nexus_devclass;
#ifndef FDT
static int
nexus_probe(device_t dev)
{
@ -387,7 +373,6 @@ nexus_release_resource(device_t bus, device_t child, int type, int rid,
return (rman_release_resource(r));
}
#endif
static int
nexus_activate_resource(device_t bus, device_t child, int type, int rid,

2
sys/powerpc/mambo/mambo.c
View File

@ -75,7 +75,7 @@ static driver_t mambobus_driver = {
static devclass_t mambobus_devclass;
DRIVER_MODULE(mambo, nexus, mambobus_driver, mambobus_devclass, 0, 0);
DRIVER_MODULE(mambo, ofwbus, mambobus_driver, mambobus_devclass, 0, 0);
static int
mambobus_probe(device_t dev)

2
sys/powerpc/mpc85xx/lbc.c
View File

@ -113,7 +113,7 @@ static driver_t lbc_driver = {
devclass_t lbc_devclass;
DRIVER_MODULE(lbc, nexus, lbc_driver, lbc_devclass, 0, 0);
DRIVER_MODULE(lbc, ofwbus, lbc_driver, lbc_devclass, 0, 0);
/*
* Calculate address mask used by OR(n) registers. Use memory region size to

2
sys/powerpc/mpc85xx/pci_mpc85xx.c
View File

@ -170,7 +170,7 @@ static devclass_t fsl_pcib_devclass;
DEFINE_CLASS_1(pcib, fsl_pcib_driver, fsl_pcib_methods,
sizeof(struct fsl_pcib_softc), ofw_pci_driver);
DRIVER_MODULE(pcib, nexus, fsl_pcib_driver, fsl_pcib_devclass, 0, 0);
DRIVER_MODULE(pcib, ofwbus, fsl_pcib_driver, fsl_pcib_devclass, 0, 0);
static int
fsl_pcib_probe(device_t dev)

2
sys/powerpc/ofw/ofw_cpu.c
View File

@ -74,7 +74,7 @@ static driver_t ofw_cpulist_driver = {
static devclass_t ofw_cpulist_devclass;
DRIVER_MODULE(ofw_cpulist, nexus, ofw_cpulist_driver, ofw_cpulist_devclass,
DRIVER_MODULE(ofw_cpulist, ofwbus, ofw_cpulist_driver, ofw_cpulist_devclass,
0, 0);
static int

2
sys/powerpc/ofw/openpic_ofw.c
View File

@ -93,7 +93,7 @@ static driver_t openpic_ofw_driver = {
sizeof(struct openpic_softc),
};
DRIVER_MODULE(openpic, nexus, openpic_ofw_driver, openpic_devclass, 0, 0);
DRIVER_MODULE(openpic, ofwbus, openpic_ofw_driver, openpic_devclass, 0, 0);
DRIVER_MODULE(openpic, simplebus, openpic_ofw_driver, openpic_devclass, 0, 0);
DRIVER_MODULE(openpic, macio, openpic_ofw_driver, openpic_devclass, 0, 0);

2
sys/powerpc/powermac/cpcht.c
View File

@ -135,7 +135,7 @@ struct cpcht_softc {
static devclass_t cpcht_devclass;
DEFINE_CLASS_1(pcib, cpcht_driver, cpcht_methods, sizeof(struct cpcht_softc),
ofw_pci_driver);
DRIVER_MODULE(cpcht, nexus, cpcht_driver, cpcht_devclass, 0, 0);
DRIVER_MODULE(cpcht, ofwbus, cpcht_driver, cpcht_devclass, 0, 0);
#define CPCHT_IOPORT_BASE 0xf4000000UL /* Hardwired */
#define CPCHT_IOPORT_SIZE 0x00400000UL

2
sys/powerpc/powermac/grackle.c
View File

@ -102,7 +102,7 @@ static device_method_t grackle_methods[] = {
static devclass_t grackle_devclass;
DEFINE_CLASS_1(pcib, grackle_driver, grackle_methods,
sizeof(struct grackle_softc), ofw_pci_driver);
DRIVER_MODULE(grackle, nexus, grackle_driver, grackle_devclass, 0, 0);
DRIVER_MODULE(grackle, ofwbus, grackle_driver, grackle_devclass, 0, 0);
static int
grackle_probe(device_t dev)

2
sys/powerpc/powermac/smu.c
View File

@ -210,7 +210,7 @@ static driver_t smu_driver = {
static devclass_t smu_devclass;
DRIVER_MODULE(smu, nexus, smu_driver, smu_devclass, 0, 0);
DRIVER_MODULE(smu, ofwbus, smu_driver, smu_devclass, 0, 0);
static MALLOC_DEFINE(M_SMU, "smu", "SMU Sensor Information");
#define SMU_MAILBOX 0x8000860c

2
sys/powerpc/powermac/uninorth.c
View File

@ -143,7 +143,7 @@ static devclass_t unin_chip_devclass;
*/
static device_t unin_chip;
DRIVER_MODULE(unin, nexus, unin_chip_driver, unin_chip_devclass, 0, 0);
DRIVER_MODULE(unin, ofwbus, unin_chip_driver, unin_chip_devclass, 0, 0);
/*
* Add an interrupt to the dev's resource list if present

2
sys/powerpc/powermac/uninorthpci.c
View File

@ -98,7 +98,7 @@ static devclass_t uninorth_devclass;
DEFINE_CLASS_1(pcib, uninorth_driver, uninorth_methods,
sizeof(struct uninorth_softc), ofw_pci_driver);
DRIVER_MODULE(uninorth, nexus, uninorth_driver, uninorth_devclass, 0, 0);
DRIVER_MODULE(uninorth, ofwbus, uninorth_driver, uninorth_devclass, 0, 0);
static int
uninorth_probe(device_t dev)

39
sys/powerpc/powerpc/nexus.c
View File

@ -49,7 +49,6 @@ __FBSDID("$FreeBSD$");
#include <dev/ofw/ofw_bus.h>
#include <dev/ofw/ofw_bus_subr.h>
#include <dev/ofw/ofw_nexus.h>
#include <dev/ofw/openfirm.h>
#include <machine/bus.h>
@ -57,15 +56,12 @@ __FBSDID("$FreeBSD$");
#include <machine/resource.h>
/*
* The nexus (which is a pseudo-bus actually) iterates over the nodes that
* hang from the Open Firmware root node and adds them as devices to this bus
* (except some special nodes which are excluded) so that drivers can be
* attached to them.
*
* Additionally, interrupt setup/teardown and some resource management are
* done at this level.
* The nexus handles root-level resource allocation requests and interrupt
* mapping. All direct subdevices of nexus are attached by DEVICE_IDENTIFY().
*/
static device_probe_t nexus_probe;
static device_attach_t nexus_attach;
static bus_setup_intr_t nexus_setup_intr;
static bus_teardown_intr_t nexus_teardown_intr;
static bus_activate_resource_t nexus_activate_resource;
@ -77,7 +73,12 @@ static bus_config_intr_t nexus_config_intr;
static ofw_bus_map_intr_t nexus_ofw_map_intr;
static device_method_t nexus_methods[] = {
/* Device interface */
DEVMETHOD(device_probe, nexus_probe),
DEVMETHOD(device_attach, nexus_attach),
/* Bus interface */
DEVMETHOD(bus_add_child, bus_generic_add_child),
DEVMETHOD(bus_activate_resource, nexus_activate_resource),
DEVMETHOD(bus_deactivate_resource, nexus_deactivate_resource),
DEVMETHOD(bus_setup_intr, nexus_setup_intr),
@ -95,12 +96,30 @@ static device_method_t nexus_methods[] = {
static devclass_t nexus_devclass;
DEFINE_CLASS_1(nexus, nexus_driver, nexus_methods,
sizeof(struct ofw_nexus_softc), ofw_nexus_driver);
DEFINE_CLASS_0(nexus, nexus_driver, nexus_methods, 1);
EARLY_DRIVER_MODULE(nexus, root, nexus_driver, nexus_devclass, 0, 0,
BUS_PASS_BUS);
MODULE_VERSION(nexus, 1);
static int
nexus_probe(device_t dev)
{
device_quiet(dev); /* suppress attach message for neatness */
return (BUS_PROBE_DEFAULT);
}
static int
nexus_attach(device_t dev)
{
bus_generic_probe(dev);
bus_generic_attach(dev);
return (0);
}
static int
nexus_setup_intr(device_t bus __unused, device_t child, struct resource *r,
int flags, driver_filter_t *filt, driver_intr_t *intr, void *arg,

2
sys/powerpc/pseries/rtas_dev.c
View File

@ -73,7 +73,7 @@ static driver_t rtasdev_driver = {
static devclass_t rtasdev_devclass;
DRIVER_MODULE(rtasdev, nexus, rtasdev_driver, rtasdev_devclass, 0, 0);
DRIVER_MODULE(rtasdev, ofwbus, rtasdev_driver, rtasdev_devclass, 0, 0);
static int
rtasdev_probe(device_t dev)

2
sys/powerpc/pseries/rtas_pci.c
View File

@ -99,7 +99,7 @@ struct rtaspci_softc {
static devclass_t rtaspci_devclass;
DEFINE_CLASS_1(pcib, rtaspci_driver, rtaspci_methods,
sizeof(struct rtaspci_softc), ofw_pci_driver);
DRIVER_MODULE(rtaspci, nexus, rtaspci_driver, rtaspci_devclass, 0, 0);
DRIVER_MODULE(rtaspci, ofwbus, rtaspci_driver, rtaspci_devclass, 0, 0);
static int
rtaspci_probe(device_t dev)

2
sys/powerpc/pseries/vdevice.c
View File

@ -103,7 +103,7 @@ static driver_t vdevice_driver = {
static devclass_t vdevice_devclass;
DRIVER_MODULE(vdevice, nexus, vdevice_driver, vdevice_devclass, 0, 0);
DRIVER_MODULE(vdevice, ofwbus, vdevice_driver, vdevice_devclass, 0, 0);
static int
vdevice_probe(device_t dev)

4
sys/powerpc/pseries/xics.c
View File

@ -122,9 +122,9 @@ static driver_t xics_driver = {
static devclass_t xicp_devclass;
static devclass_t xics_devclass;
EARLY_DRIVER_MODULE(xicp, nexus, xicp_driver, xicp_devclass, 0, 0,
EARLY_DRIVER_MODULE(xicp, ofwbus, xicp_driver, xicp_devclass, 0, 0,
BUS_PASS_INTERRUPT-1);
EARLY_DRIVER_MODULE(xics, nexus, xics_driver, xics_devclass, 0, 0,
EARLY_DRIVER_MODULE(xics, ofwbus, xics_driver, xics_devclass, 0, 0,
BUS_PASS_INTERRUPT);
static int

2
sys/powerpc/psim/iobus.c
View File

@ -116,7 +116,7 @@ static driver_t iobus_driver = {
devclass_t iobus_devclass;
DRIVER_MODULE(iobus, nexus, iobus_driver, iobus_devclass, 0, 0);
DRIVER_MODULE(iobus, ofwbus, iobus_driver, iobus_devclass, 0, 0);
static int
iobus_probe(device_t dev)