2 * Copyright (c) 2013 Nathan Whitehorn
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
29 #include <sys/param.h>
30 #include <sys/systm.h>
31 #include <sys/module.h>
34 #include <sys/kernel.h>
37 #include <dev/ofw/openfirm.h>
38 #include <dev/ofw/ofw_bus.h>
39 #include <dev/ofw/ofw_bus_subr.h>
41 struct simplebus_range {
47 struct simplebus_softc {
51 struct simplebus_range *ranges;
54 pcell_t acells, scells;
57 struct simplebus_devinfo {
58 struct ofw_bus_devinfo obdinfo;
59 struct resource_list rl;
65 static int simplebus_probe(device_t dev);
66 static int simplebus_attach(device_t dev);
67 static struct resource *simplebus_alloc_resource(device_t, device_t, int,
68 int *, u_long, u_long, u_long, u_int);
69 static void simplebus_probe_nomatch(device_t bus, device_t child);
70 static int simplebus_print_child(device_t bus, device_t child);
75 static const struct ofw_bus_devinfo *simplebus_get_devinfo(device_t bus,
82 static int simplebus_fill_ranges(phandle_t node,
83 struct simplebus_softc *sc);
84 static struct simplebus_devinfo *simplebus_setup_dinfo(device_t dev,
90 static device_method_t simplebus_methods[] = {
91 /* Device interface */
92 DEVMETHOD(device_probe, simplebus_probe),
93 DEVMETHOD(device_attach, simplebus_attach),
96 DEVMETHOD(bus_print_child, simplebus_print_child),
97 DEVMETHOD(bus_probe_nomatch, simplebus_probe_nomatch),
98 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
99 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
100 DEVMETHOD(bus_alloc_resource, simplebus_alloc_resource),
101 DEVMETHOD(bus_release_resource, bus_generic_release_resource),
102 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
103 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
104 DEVMETHOD(bus_adjust_resource, bus_generic_adjust_resource),
105 DEVMETHOD(bus_child_pnpinfo_str, ofw_bus_gen_child_pnpinfo_str),
107 /* ofw_bus interface */
108 DEVMETHOD(ofw_bus_get_devinfo, simplebus_get_devinfo),
109 DEVMETHOD(ofw_bus_get_compat, ofw_bus_gen_get_compat),
110 DEVMETHOD(ofw_bus_get_model, ofw_bus_gen_get_model),
111 DEVMETHOD(ofw_bus_get_name, ofw_bus_gen_get_name),
112 DEVMETHOD(ofw_bus_get_node, ofw_bus_gen_get_node),
113 DEVMETHOD(ofw_bus_get_type, ofw_bus_gen_get_type),
118 static driver_t simplebus_driver = {
121 sizeof(struct simplebus_softc)
123 static devclass_t simplebus_devclass;
124 DRIVER_MODULE(simplebus, nexus, simplebus_driver, simplebus_devclass, 0, 0);
125 DRIVER_MODULE(simplebus, simplebus, simplebus_driver, simplebus_devclass, 0, 0);
128 simplebus_probe(device_t dev)
131 if (!ofw_bus_status_okay(dev))
134 if (!ofw_bus_is_compatible(dev, "simple-bus") &&
135 (ofw_bus_get_type(dev) == NULL || strcmp(ofw_bus_get_type(dev),
139 device_set_desc(dev, "Flattened device tree simple bus");
141 return (BUS_PROBE_GENERIC);
145 simplebus_attach(device_t dev)
147 struct simplebus_softc *sc;
148 struct simplebus_devinfo *di;
152 node = ofw_bus_get_node(dev);
153 sc = device_get_softc(dev);
159 * Some important numbers
162 OF_getencprop(node, "#address-cells", &sc->acells, sizeof(sc->acells));
164 OF_getencprop(node, "#size-cells", &sc->scells, sizeof(sc->scells));
166 if (simplebus_fill_ranges(node, sc) < 0) {
167 device_printf(dev, "could not get ranges\n");
172 * In principle, simplebus could have an interrupt map, but ignore that
176 for (node = OF_child(node); node > 0; node = OF_peer(node)) {
177 if ((di = simplebus_setup_dinfo(dev, node)) == NULL)
179 cdev = device_add_child(dev, NULL, -1);
181 device_printf(dev, "<%s>: device_add_child failed\n",
182 di->obdinfo.obd_name);
183 resource_list_free(&di->rl);
184 ofw_bus_gen_destroy_devinfo(&di->obdinfo);
188 device_set_ivars(cdev, di);
191 return (bus_generic_attach(dev));
195 simplebus_fill_ranges(phandle_t node, struct simplebus_softc *sc)
197 int host_address_cells;
199 ssize_t nbase_ranges;
203 err = OF_searchencprop(OF_parent(node), "#address-cells",
204 &host_address_cells, sizeof(host_address_cells));
208 nbase_ranges = OF_getproplen(node, "ranges");
209 if (nbase_ranges < 0)
211 sc->nranges = nbase_ranges / sizeof(cell_t) /
212 (sc->acells + host_address_cells + sc->scells);
213 if (sc->nranges == 0)
216 sc->ranges = malloc(sc->nranges * sizeof(sc->ranges[0]),
218 base_ranges = malloc(nbase_ranges, M_DEVBUF, M_WAITOK);
219 OF_getencprop(node, "ranges", base_ranges, nbase_ranges);
221 for (i = 0, j = 0; i < sc->nranges; i++) {
222 sc->ranges[i].bus = 0;
223 for (k = 0; k < sc->acells; k++) {
224 sc->ranges[i].bus <<= 32;
225 sc->ranges[i].bus |= base_ranges[j++];
227 sc->ranges[i].host = 0;
228 for (k = 0; k < host_address_cells; k++) {
229 sc->ranges[i].host <<= 32;
230 sc->ranges[i].host |= base_ranges[j++];
232 sc->ranges[i].size = 0;
233 for (k = 0; k < sc->scells; k++) {
234 sc->ranges[i].size <<= 32;
235 sc->ranges[i].size |= base_ranges[j++];
239 free(base_ranges, M_DEVBUF);
240 return (sc->nranges);
243 static struct simplebus_devinfo *
244 simplebus_setup_dinfo(device_t dev, phandle_t node)
246 struct simplebus_softc *sc;
247 struct simplebus_devinfo *ndi;
248 uint32_t *reg, *intr, icells;
255 sc = device_get_softc(dev);
257 ndi = malloc(sizeof(*ndi), M_DEVBUF, M_WAITOK | M_ZERO);
258 if (ofw_bus_gen_setup_devinfo(&ndi->obdinfo, node) != 0) {
263 resource_list_init(&ndi->rl);
264 nreg = OF_getencprop_alloc(node, "reg", sizeof(*reg), (void **)®);
267 if (nreg % (sc->acells + sc->scells) != 0) {
269 device_printf(dev, "Malformed reg property on <%s>\n",
270 ndi->obdinfo.obd_name);
274 for (i = 0, k = 0; i < nreg; i += sc->acells + sc->scells, k++) {
276 for (j = 0; j < sc->acells; j++) {
280 for (j = 0; j < sc->scells; j++) {
282 size |= reg[i + sc->acells + j];
285 resource_list_add(&ndi->rl, SYS_RES_MEMORY, k,
286 phys, phys + size - 1, size);
288 free(reg, M_OFWPROP);
290 nintr = OF_getencprop_alloc(node, "interrupts", sizeof(*intr),
293 if (OF_searchencprop(node, "interrupt-parent", &iparent,
294 sizeof(iparent)) == -1) {
295 device_printf(dev, "No interrupt-parent found, "
296 "assuming direct parent\n");
297 iparent = OF_parent(node);
299 if (OF_searchencprop(OF_xref_phandle(iparent),
300 "#interrupt-cells", &icells, sizeof(icells)) == -1) {
301 device_printf(dev, "Missing #interrupt-cells property, "
305 if (icells < 1 || icells > nintr) {
306 device_printf(dev, "Invalid #interrupt-cells property "
307 "value <%d>, assuming <1>\n", icells);
310 for (i = 0, k = 0; i < nintr; i += icells, k++) {
311 intr[i] = ofw_bus_map_intr(dev, iparent, icells,
313 resource_list_add(&ndi->rl, SYS_RES_IRQ, k, intr[i],
316 free(intr, M_OFWPROP);
322 static const struct ofw_bus_devinfo *
323 simplebus_get_devinfo(device_t bus __unused, device_t child)
325 struct simplebus_devinfo *ndi;
327 ndi = device_get_ivars(child);
328 return (&ndi->obdinfo);
331 static struct resource *
332 simplebus_alloc_resource(device_t bus, device_t child, int type, int *rid,
333 u_long start, u_long end, u_long count, u_int flags)
335 struct simplebus_softc *sc;
336 struct simplebus_devinfo *di;
337 struct resource_list_entry *rle;
340 sc = device_get_softc(bus);
343 * Request for the default allocation with a given rid: use resource
344 * list stored in the local device info.
346 if ((start == 0UL) && (end == ~0UL)) {
347 if ((di = device_get_ivars(child)) == NULL)
350 if (type == SYS_RES_IOPORT)
351 type = SYS_RES_MEMORY;
353 rle = resource_list_find(&di->rl, type, *rid);
356 device_printf(bus, "no default resources for "
357 "rid = %d, type = %d\n", *rid, type);
365 if (type == SYS_RES_MEMORY) {
366 /* Remap through ranges property */
367 for (j = 0; j < sc->nranges; j++) {
368 if (start >= sc->ranges[j].bus && end <
369 sc->ranges[j].bus + sc->ranges[j].size) {
370 start -= sc->ranges[j].bus;
371 start += sc->ranges[j].host;
372 end -= sc->ranges[j].bus;
373 end += sc->ranges[j].host;
377 if (j == sc->nranges && sc->nranges != 0) {
379 device_printf(bus, "Could not map resource "
380 "%#lx-%#lx\n", start, end);
386 return (bus_generic_alloc_resource(bus, child, type, rid, start, end,
391 simplebus_print_res(struct simplebus_devinfo *di)
396 rv += resource_list_print_type(&di->rl, "mem", SYS_RES_MEMORY, "%#lx");
397 rv += resource_list_print_type(&di->rl, "irq", SYS_RES_IRQ, "%ld");
402 simplebus_probe_nomatch(device_t bus, device_t child)
404 const char *name, *type;
409 name = ofw_bus_get_name(child);
410 type = ofw_bus_get_type(child);
412 device_printf(bus, "<%s>", name != NULL ? name : "unknown");
413 simplebus_print_res(device_get_ivars(child));
414 printf(" type %s (no driver attached)\n",
415 type != NULL ? type : "unknown");
419 simplebus_print_child(device_t bus, device_t child)
423 rv = bus_print_child_header(bus, child);
424 rv += simplebus_print_res(device_get_ivars(child));
425 rv += bus_print_child_footer(bus, child);