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

Make simplebus a base class of ofwbus. This allows the elimination of

Browse Source 
duplicated code in the two classes, and also allows devices in FDT-based
systems to declare simplebus as their parent and still work correctly
when the FDT data describes the device at the root of the tree rather
than as a child of a simplebus (which is common for interrupt, clock,
and power controllers).

Differential Revision:	https://reviews.freebsd.org/D1990
Submitted by:	Michal Meloun
This commit is contained in:
Ian Lepore 2015-03-27 23:10:15 +00:00
parent 8465cb4016
commit ecaecbc7d8
4 changed files with 132 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
sys/conf/files.powerpc
View File

@ -29,6 +29,8 @@ dev/adb/adb_buttons.c optional adb
dev/agp/agp_apple.c optional agp powermac
dev/fb/fb.c optional sc
dev/fdt/fdt_powerpc.c optional fdt
# ofwbus depends on simplebus.
dev/fdt/simplebus.c optional aim | fdt
dev/hwpmc/hwpmc_powerpc.c optional hwpmc
dev/hwpmc/hwpmc_mpc7xxx.c optional hwpmc
dev/hwpmc/hwpmc_ppc970.c optional hwpmc

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

@ -49,7 +49,10 @@ static struct resource *simplebus_alloc_resource(device_t, device_t, int,
int *, u_long, u_long, u_long, u_int);
static void simplebus_probe_nomatch(device_t bus, device_t child);
static int simplebus_print_child(device_t bus, device_t child);
static device_t simplebus_add_child(device_t dev, u_int order,
const char *name, int unit);
static struct resource_list *simplebus_get_resource_list(device_t bus,
device_t child);
/*
* ofw_bus interface
*/
@ -62,8 +65,6 @@ static const struct ofw_bus_devinfo *simplebus_get_devinfo(device_t bus,
static int simplebus_fill_ranges(phandle_t node,
struct simplebus_softc *sc);
static struct simplebus_devinfo *simplebus_setup_dinfo(device_t dev,
phandle_t node);
/*
* Driver methods.
@ -72,10 +73,17 @@ static device_method_t simplebus_methods[] = {
/* Device interface */
DEVMETHOD(device_probe, simplebus_probe),
DEVMETHOD(device_attach, simplebus_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_add_child, simplebus_add_child),
DEVMETHOD(bus_print_child, simplebus_print_child),
DEVMETHOD(bus_probe_nomatch, simplebus_probe_nomatch),
DEVMETHOD(bus_read_ivar, bus_generic_read_ivar),
DEVMETHOD(bus_write_ivar, bus_generic_write_ivar),
DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
DEVMETHOD(bus_alloc_resource, simplebus_alloc_resource),
@ -83,7 +91,10 @@ static device_method_t simplebus_methods[] = {
DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
DEVMETHOD(bus_adjust_resource, bus_generic_adjust_resource),
DEVMETHOD(bus_set_resource, bus_generic_rl_set_resource),
DEVMETHOD(bus_get_resource, bus_generic_rl_get_resource),
DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str),
DEVMETHOD(bus_get_resource_list, simplebus_get_resource_list),
/* ofw_bus interface */
DEVMETHOD(ofw_bus_get_devinfo, simplebus_get_devinfo),
@ -132,13 +143,33 @@ static int
simplebus_attach(device_t dev)
{
struct simplebus_softc *sc;
struct simplebus_devinfo *di;
phandle_t node;
device_t cdev;
node = ofw_bus_get_node(dev);
sc = device_get_softc(dev);
simplebus_init(dev, 0);
if (simplebus_fill_ranges(sc->node, sc) < 0) {
device_printf(dev, "could not get ranges\n");
return (ENXIO);
}
/*
* In principle, simplebus could have an interrupt map, but ignore that
* for now
*/
for (node = OF_child(sc->node); node > 0; node = OF_peer(node))
simplebus_add_device(dev, node, 0, NULL, -1, NULL);
return (bus_generic_attach(dev));
}
void
simplebus_init(device_t dev, phandle_t node)
{
struct simplebus_softc *sc;
sc = device_get_softc(dev);
if (node == 0)
node = ofw_bus_get_node(dev);
sc->dev = dev;
sc->node = node;
@ -149,33 +180,6 @@ simplebus_attach(device_t dev)
OF_getencprop(node, "#address-cells", &sc->acells, sizeof(sc->acells));
sc->scells = 1;
OF_getencprop(node, "#size-cells", &sc->scells, sizeof(sc->scells));
if (simplebus_fill_ranges(node, sc) < 0) {
device_printf(dev, "could not get ranges\n");
return (ENXIO);
}
/*
* In principle, simplebus could have an interrupt map, but ignore that
* for now
*/
for (node = OF_child(node); node > 0; node = OF_peer(node)) {
if ((di = simplebus_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",
di->obdinfo.obd_name);
resource_list_free(&di->rl);
ofw_bus_gen_destroy_devinfo(&di->obdinfo);
free(di, M_DEVBUF);
continue;
}
device_set_ivars(cdev, di);
}
return (bus_generic_attach(dev));
}
static int
@ -227,17 +231,21 @@ simplebus_fill_ranges(phandle_t node, struct simplebus_softc *sc)
return (sc->nranges);
}
static struct simplebus_devinfo *
simplebus_setup_dinfo(device_t dev, phandle_t node)
struct simplebus_devinfo *
simplebus_setup_dinfo(device_t dev, phandle_t node,
struct simplebus_devinfo *di)
{
struct simplebus_softc *sc;
struct simplebus_devinfo *ndi;
sc = device_get_softc(dev);
ndi = malloc(sizeof(*ndi), M_DEVBUF, M_WAITOK | M_ZERO);
if (di == NULL)
ndi = malloc(sizeof(*ndi), M_DEVBUF, M_WAITOK | M_ZERO);
else
ndi = di;
if (ofw_bus_gen_setup_devinfo(&ndi->obdinfo, node) != 0) {
free(ndi, M_DEVBUF);
if (di == NULL)
free(ndi, M_DEVBUF);
return (NULL);
}
@ -248,6 +256,48 @@ simplebus_setup_dinfo(device_t dev, phandle_t node)
return (ndi);
}
device_t
simplebus_add_device(device_t dev, phandle_t node, u_int order,
const char *name, int unit, struct simplebus_devinfo *di)
{
struct simplebus_devinfo *ndi;
device_t cdev;
if ((ndi = simplebus_setup_dinfo(dev, node, di)) == NULL)
return (NULL);
cdev = device_add_child_ordered(dev, order, name, unit);
if (cdev == NULL) {
device_printf(dev, "<%s>: device_add_child failed\n",
ndi->obdinfo.obd_name);
resource_list_free(&ndi->rl);
ofw_bus_gen_destroy_devinfo(&ndi->obdinfo);
if (di == NULL)
free(ndi, M_DEVBUF);
return (NULL);
}
device_set_ivars(cdev, ndi);
return(cdev);
}
static device_t
simplebus_add_child(device_t dev, u_int order, const char *name, int unit)
{
device_t cdev;
struct simplebus_devinfo *ndi;
cdev = device_add_child_ordered(dev, order, name, unit);
if (cdev == NULL)
return (NULL);
ndi = malloc(sizeof(*ndi), M_DEVBUF, M_WAITOK | M_ZERO);
ndi->obdinfo.obd_node = -1;
resource_list_init(&ndi->rl);
device_set_ivars(cdev, ndi);
return (cdev);
}
static const struct ofw_bus_devinfo *
simplebus_get_devinfo(device_t bus __unused, device_t child)
{
@ -257,6 +307,15 @@ simplebus_get_devinfo(device_t bus __unused, device_t child)
return (&ndi->obdinfo);
}
static struct resource_list *
simplebus_get_resource_list(device_t bus __unused, device_t child)
{
struct simplebus_devinfo *ndi;
ndi = device_get_ivars(child);
return (&ndi->rl);
}
static struct resource *
simplebus_alloc_resource(device_t bus, device_t child, int type, int *rid,
u_long start, u_long end, u_long count, u_int flags)
@ -335,9 +394,11 @@ simplebus_probe_nomatch(device_t bus, device_t child)
if (!bootverbose)
return;
compat = ofw_bus_get_compat(child);
if (compat == NULL)
return;
name = ofw_bus_get_name(child);
type = ofw_bus_get_type(child);
compat = ofw_bus_get_compat(child);
device_printf(bus, "<%s>", name != NULL ? name : "unknown");
simplebus_print_res(device_get_ivars(child));
@ -345,9 +406,7 @@ simplebus_probe_nomatch(device_t bus, device_t child)
printf(" disabled");
if (type)
printf(" type %s", type);
if (compat)
printf(" compat %s", compat);
printf(" (no driver attached)\n");
printf(" compat %s (no driver attached)\n", compat);
}
static int

14
sys/dev/fdt/simplebus.h
View File

@ -26,8 +26,10 @@
* $FreeBSD$
*/
#ifndef _FDT_SIMPLEBUS_PRIVATE_H
#define _FDT_SIMPLEBUS_PRIVATE_H
#ifndef _FDT_SIMPLEBUS_H
#define _FDT_SIMPLEBUS_H
#include <dev/ofw/ofw_bus.h>
/* FDT simplebus */
DECLARE_CLASS(simplebus_driver);
@ -53,4 +55,10 @@ struct simplebus_devinfo {
struct ofw_bus_devinfo obdinfo;
struct resource_list rl;
};
#endif /* _FDT_SIMPLEBUS_PRIVATE_H */
void simplebus_init(device_t dev, phandle_t node);
device_t simplebus_add_device(device_t dev, phandle_t node, u_int order,
const char *name, int unit, struct simplebus_devinfo *di);
struct simplebus_devinfo *simplebus_setup_dinfo(device_t dev, phandle_t node,
struct simplebus_devinfo *di);
#endif /* _FDT_SIMPLEBUS_H */

248
sys/dev/ofw/ofwbus.c
View File

@ -50,6 +50,7 @@ __FBSDID("$FreeBSD$");
#include <dev/ofw/ofw_bus.h>
#include <dev/ofw/ofw_bus_subr.h>
#include <dev/ofw/openfirm.h>
#include <dev/fdt/simplebus.h>
#include <machine/bus.h>
#include <machine/resource.h>
@ -62,13 +63,8 @@ __FBSDID("$FreeBSD$");
*
*/
struct ofwbus_devinfo {
struct ofw_bus_devinfo ndi_obdinfo;
struct resource_list ndi_rl;
};
struct ofwbus_softc {
uint32_t acells, scells;
struct simplebus_softc simplebus_sc;
struct rman sc_intr_rman;
struct rman sc_mem_rman;
};
@ -76,113 +72,31 @@ struct ofwbus_softc {
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 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_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, 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, ofwbus_add_child),
DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str),
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, 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, 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),
DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node),
DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type),
DEVMETHOD_END
};
static driver_t ofwbus_driver = {
"ofwbus",
ofwbus_methods,
sizeof(struct ofwbus_softc)
};
DEFINE_CLASS_1(ofwbus, ofwbus_driver, ofwbus_methods,
sizeof(struct ofwbus_softc), simplebus_driver);
static devclass_t ofwbus_devclass;
EARLY_DRIVER_MODULE(ofwbus, nexus, ofwbus_driver, ofwbus_devclass, 0, 0,
BUS_PASS_BUS + BUS_PASS_ORDER_MIDDLE);
MODULE_VERSION(ofwbus, 1);
static const char *const ofwbus_excl_name[] = {
"FJSV,system",
"aliases",
"associations",
"chosen",
"cmp",
"counter-timer", /* No separate device; handled by psycho/sbus */
"failsafe",
"memory",
"openprom",
"options",
"packages",
"physical-memory",
"rsc",
"sgcn",
"todsg",
"virtual-memory",
NULL
};
static const char *const ofwbus_excl_type[] = {
"core",
"cpu",
NULL
};
static int
ofwbus_inlist(const char *name, const char *const *list)
{
int i;
if (name == NULL)
return (0);
for (i = 0; list[i] != NULL; i++)
if (strcmp(name, list[i]) == 0)
return (1);
return (0);
}
#define OFWBUS_EXCLUDED(name, type) \
(ofwbus_inlist((name), ofwbus_excl_name) || \
((type) != NULL && ofwbus_inlist((type), ofwbus_excl_type)))
static void
ofwbus_identify(driver_t *driver, device_t parent)
{
@ -190,7 +104,7 @@ ofwbus_identify(driver_t *driver, device_t parent)
/* Check if Open Firmware has been instantiated */
if (OF_peer(0) == 0)
return;
if (device_find_child(parent, "ofwbus", -1) == NULL)
BUS_ADD_CHILD(parent, 0, "ofwbus", -1);
}
@ -206,10 +120,9 @@ ofwbus_probe(device_t dev)
static int
ofwbus_attach(device_t dev)
{
struct ofwbus_devinfo *ndi;
struct ofwbus_softc *sc;
device_t cdev;
phandle_t node;
struct ofw_bus_devinfo obd;
sc = device_get_softc(dev);
@ -221,6 +134,11 @@ ofwbus_attach(device_t dev)
if (node == -1)
return (ENXIO);
/*
* ofwbus bus starts on unamed node in FDT, so we cannot make
* ofw_bus_devinfo from it. Pass node to simplebus_init directly.
*/
simplebus_init(dev, node);
sc->sc_intr_rman.rm_type = RMAN_ARRAY;
sc->sc_intr_rman.rm_descr = "Interrupts";
sc->sc_mem_rman.rm_type = RMAN_ARRAY;
@ -236,79 +154,17 @@ ofwbus_attach(device_t dev)
*/
bus_generic_probe(dev);
/*
* Some important numbers
*/
sc->acells = 2;
OF_getencprop(node, "#address-cells", &sc->acells, sizeof(sc->acells));
sc->scells = 1;
OF_getencprop(node, "#size-cells", &sc->scells, sizeof(sc->scells));
/*
* Now walk the OFW tree and attach top-level devices.
*/
for (node = OF_child(node); node > 0; node = OF_peer(node)) {
if ((ndi = ofwbus_setup_dinfo(dev, node)) == NULL)
if (ofw_bus_gen_setup_devinfo(&obd, node) != 0)
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);
ofwbus_destroy_dinfo(ndi);
continue;
}
device_set_ivars(cdev, ndi);
simplebus_add_device(dev, node, 0, NULL, -1, NULL);
}
return (bus_generic_attach(dev));
}
static device_t
ofwbus_add_child(device_t dev, u_int order, const char *name, int unit)
{
device_t cdev;
struct ofwbus_devinfo *ndi;
cdev = device_add_child_ordered(dev, order, name, unit);
if (cdev == NULL)
return (NULL);
ndi = malloc(sizeof(*ndi), M_DEVBUF, M_WAITOK | M_ZERO);
ndi->ndi_obdinfo.obd_node = -1;
resource_list_init(&ndi->ndi_rl);
device_set_ivars(cdev, ndi);
return (cdev);
}
static int
ofwbus_print_child(device_t bus, device_t child)
{
int rv;
rv = bus_print_child_header(bus, child);
rv += ofwbus_print_res(device_get_ivars(child));
rv += bus_print_child_footer(bus, child);
return (rv);
}
static void
ofwbus_probe_nomatch(device_t bus, device_t child)
{
const char *name, *type;
if (!bootverbose)
return;
name = ofw_bus_get_name(child);
type = ofw_bus_get_type(child);
device_printf(bus, "<%s>",
name != NULL ? name : "unknown");
ofwbus_print_res(device_get_ivars(child));
printf(" type %s (no driver attached)\n",
type != NULL ? type : "unknown");
}
static struct resource *
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)
@ -323,14 +179,15 @@ ofwbus_alloc_resource(device_t bus, device_t child, int type, int *rid,
passthrough = (device_get_parent(child) != bus);
sc = device_get_softc(bus);
rle = NULL;
if (!passthrough && isdefault) {
rle = resource_list_find(BUS_GET_RESOURCE_LIST(bus, child),
type, *rid);
if (rle == NULL)
if (rle == NULL) {
if (bootverbose)
device_printf(bus, "no default resources for "
"rid = %d, type = %d\n", *rid, type);
return (NULL);
if (rle->res != NULL)
panic("%s: resource entry is busy", __func__);
}
start = rle->start;
count = ulmax(count, rle->count);
end = ulmax(rle->end, start + count - 1);
@ -417,72 +274,3 @@ ofwbus_release_resource(device_t bus, device_t child, int type,
}
return (rman_release_resource(r));
}
static struct resource_list *
ofwbus_get_resource_list(device_t bus __unused, device_t child)
{
struct ofwbus_devinfo *ndi;
ndi = device_get_ivars(child);
return (&ndi->ndi_rl);
}
static const struct ofw_bus_devinfo *
ofwbus_get_devinfo(device_t bus __unused, device_t child)
{
struct ofwbus_devinfo *ndi;
ndi = device_get_ivars(child);
return (&ndi->ndi_obdinfo);
}
static struct ofwbus_devinfo *
ofwbus_setup_dinfo(device_t dev, phandle_t node)
{
struct ofwbus_softc *sc;
struct ofwbus_devinfo *ndi;
const char *nodename;
sc = device_get_softc(dev);
ndi = malloc(sizeof(*ndi), M_DEVBUF, M_WAITOK | M_ZERO);
if (ofw_bus_gen_setup_devinfo(&ndi->ndi_obdinfo, node) != 0) {
free(ndi, M_DEVBUF);
return (NULL);
}
nodename = ndi->ndi_obdinfo.obd_name;
if (OFWBUS_EXCLUDED(nodename, ndi->ndi_obdinfo.obd_type)) {
ofw_bus_gen_destroy_devinfo(&ndi->ndi_obdinfo);
free(ndi, M_DEVBUF);
return (NULL);
}
resource_list_init(&ndi->ndi_rl);
ofw_bus_reg_to_rl(dev, node, sc->acells, sc->scells, &ndi->ndi_rl);
ofw_bus_intr_to_rl(dev, node, &ndi->ndi_rl);
return (ndi);
}
static void
ofwbus_destroy_dinfo(struct ofwbus_devinfo *ndi)
{
resource_list_free(&ndi->ndi_rl);
ofw_bus_gen_destroy_devinfo(&ndi->ndi_obdinfo);
free(ndi, M_DEVBUF);
}
static int
ofwbus_print_res(struct ofwbus_devinfo *ndi)
{
int rv;
rv = 0;
rv += resource_list_print_type(&ndi->ndi_rl, "mem", SYS_RES_MEMORY,
"%#lx");
rv += resource_list_print_type(&ndi->ndi_rl, "irq", SYS_RES_IRQ,
"%ld");
return (rv);
}