1/*-
2 * Copyright (c) 2003 Jake Burkholder.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright

--- 11 unchanged lines hidden (view full) ---

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
24 * SUCH DAMAGE.
25 */
26
27#include <sys/cdefs.h>
28__FBSDID("$FreeBSD: head/sys/sparc64/central/central.c 146398 2005-05-19 15:09:56Z marius $");
29
30#include <sys/param.h>
31#include <sys/systm.h>
32#include <sys/bus.h>
33#include <sys/kernel.h>
34#include <sys/malloc.h>
35#include <sys/module.h>
36
37#include <dev/ofw/ofw_bus.h>
38#include <dev/ofw/openfirm.h>
39
40#include <machine/bus.h>
41#include <machine/nexusvar.h>
42#include <machine/ofw_upa.h>
43#include <machine/resource.h>
44
45#include <sys/rman.h>
46
47#include <sparc64/sbus/ofw_sbus.h>
48
49struct central_devinfo {
50 char *cdi_compat;
51 char *cdi_model;
52 char *cdi_name;
53 char *cdi_type;
54 phandle_t cdi_node;
55 struct resource_list cdi_rl;
56};
57
58struct central_softc {
59 phandle_t sc_node;
60 int sc_nrange;
61 struct sbus_ranges *sc_ranges;
62};
63
64static device_probe_t central_probe;
65static device_attach_t central_attach;
66static bus_print_child_t central_print_child;
67static bus_probe_nomatch_t central_probe_nomatch;
68static bus_alloc_resource_t central_alloc_resource;
69static bus_get_resource_list_t central_get_resource_list;
70static ofw_bus_get_compat_t central_get_compat;
71static ofw_bus_get_model_t central_get_model;
72static ofw_bus_get_name_t central_get_name;
73static ofw_bus_get_node_t central_get_node;
74static ofw_bus_get_type_t central_get_type;
75
76static device_method_t central_methods[] = {
77 /* Device interface. */
78 DEVMETHOD(device_probe, central_probe),
79 DEVMETHOD(device_attach, central_attach),
80
81 /* Bus interface. */
82 DEVMETHOD(bus_print_child, central_print_child),
83 DEVMETHOD(bus_probe_nomatch, central_probe_nomatch),
84 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
85 DEVMETHOD(bus_teardown_intr, bus_generic_teardown_intr),
86 DEVMETHOD(bus_alloc_resource, central_alloc_resource),
87 DEVMETHOD(bus_release_resource, bus_generic_rl_release_resource),
88 DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
89 DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
90 DEVMETHOD(bus_get_resource_list, central_get_resource_list),
91 DEVMETHOD(bus_get_resource, bus_generic_rl_get_resource),
92
93 /* ofw_bus interface */
94 DEVMETHOD(ofw_bus_get_compat, central_get_compat),
95 DEVMETHOD(ofw_bus_get_model, central_get_model),
96 DEVMETHOD(ofw_bus_get_name, central_get_name),
97 DEVMETHOD(ofw_bus_get_node, central_get_node),
98 DEVMETHOD(ofw_bus_get_type, central_get_type),
99
100 { NULL, NULL }
101};
102
103static driver_t central_driver = {
104 "central",
105 central_methods,
106 sizeof(struct central_softc),

--- 17 unchanged lines hidden (view full) ---

124static int
125central_attach(device_t dev)
126{
127 struct central_devinfo *cdi;
128 struct sbus_regs *reg;
129 struct central_softc *sc;
130 phandle_t child;
131 phandle_t node;
132 bus_addr_t size;
133 bus_addr_t off;
134 device_t cdev;
135 char *name;
136 int nreg;
137 int i;
138
139 sc = device_get_softc(dev);
140 node = nexus_get_node(dev);
141 sc->sc_node = node;
142
143 sc->sc_nrange = OF_getprop_alloc(node, "ranges",
144 sizeof(*sc->sc_ranges), (void **)&sc->sc_ranges);
145 if (sc->sc_nrange == -1) {
146 device_printf(dev, "can't get ranges\n");
147 return (ENXIO);
148 }
149
150 for (child = OF_child(node); child != 0; child = OF_peer(child)) {
151 if ((OF_getprop_alloc(child, "name", 1, (void **)&name)) == -1)
152 continue;
153 cdev = device_add_child(dev, NULL, -1);
154 if (cdev != NULL) {
155 cdi = malloc(sizeof(*cdi), M_DEVBUF, M_WAITOK | M_ZERO);
156 if (cdi == NULL)
157 continue;
158 cdi->cdi_name = name;
159 cdi->cdi_node = child;
160 OF_getprop_alloc(child, "compatible", 1,
161 (void **)&cdi->cdi_compat);
162 OF_getprop_alloc(child, "device_type", 1,
163 (void **)&cdi->cdi_type);
164 OF_getprop_alloc(child, "model", 1,
165 (void **)&cdi->cdi_model);
166 resource_list_init(&cdi->cdi_rl);
167 nreg = OF_getprop_alloc(child, "reg", sizeof(*reg),
168 (void **)&reg);
169 if (nreg != -1) {
170 for (i = 0; i < nreg; i++) {
171 off = reg[i].sbr_offset;
172 size = reg[i].sbr_size;
173 resource_list_add(&cdi->cdi_rl,
174 SYS_RES_MEMORY, i, off, off + size,
175 size);
176 }
177 free(reg, M_OFWPROP);
178 }
179 device_set_ivars(cdev, cdi);
180 } else
181 free(name, M_OFWPROP);
182 }
183
184 return (bus_generic_attach(dev));
185}
186
187static int
188central_print_child(device_t dev, device_t child)
189{
190 struct central_devinfo *cdi;
191 int rv;
192
193 cdi = device_get_ivars(child);
194 rv = bus_print_child_header(dev, child);
195 rv += resource_list_print_type(&cdi->cdi_rl, "mem",
196 SYS_RES_MEMORY, "%#lx");
197 rv += bus_print_child_footer(dev, child);
198 return (rv);
199}
200
201static void
202central_probe_nomatch(device_t dev, device_t child)
203{
204 struct central_devinfo *cdi;
205
206 cdi = device_get_ivars(child);
207 device_printf(dev, "<%s>", cdi->cdi_name);
208 resource_list_print_type(&cdi->cdi_rl, "mem", SYS_RES_MEMORY, "%#lx");
209 printf(" type %s (no driver attached)\n",
210 cdi->cdi_type != NULL ? cdi->cdi_type : "unknown");
211}
212
213static struct resource *
214central_alloc_resource(device_t bus, device_t child, int type, int *rid,
215 u_long start, u_long end, u_long count, u_int flags)
216{
217 struct resource_list *rl;
218 struct resource_list_entry *rle;

--- 54 unchanged lines hidden (view full) ---

273central_get_resource_list(device_t bus, device_t child)
274{
275 struct central_devinfo *cdi;
276
277 cdi = device_get_ivars(child);
278 return (&cdi->cdi_rl);
279}
280
281static const char *
282central_get_compat(device_t bus, device_t dev)
283{
284 struct central_devinfo *dinfo;
285
286 dinfo = device_get_ivars(dev);
287 return (dinfo->cdi_compat);
288}
289
290static const char *
291central_get_model(device_t bus, device_t dev)
292{
293 struct central_devinfo *dinfo;
294
295 dinfo = device_get_ivars(dev);
296 return (dinfo->cdi_model);
297}
298
299static const char *
300central_get_name(device_t bus, device_t dev)
301{
302 struct central_devinfo *dinfo;
303
304 dinfo = device_get_ivars(dev);
305 return (dinfo->cdi_name);
306}
307
308static phandle_t
309central_get_node(device_t bus, device_t dev)
310{
311 struct central_devinfo *dinfo;
312
313 dinfo = device_get_ivars(dev);
314 return (dinfo->cdi_node);
315}
316
317static const char *
318central_get_type(device_t bus, device_t dev)
319{
320 struct central_devinfo *dinfo;
321
322 dinfo = device_get_ivars(dev);
323 return (dinfo->cdi_type);
324}