1 /*-
2 * Copyright (c) 2006 Benno Rice. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 *
13 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
14 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
15 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
16 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
17 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
18 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
19 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
20 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
22 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23 */
24
25 #include <sys/cdefs.h>
26 __FBSDID("$FreeBSD: releng/8.0/sys/arm/xscale/pxa/pxa_smi.c 179595 2008-06-06 05:08:09Z benno $");
27
28 #include <sys/param.h>
29 #include <sys/systm.h>
30 #include <sys/bus.h>
31 #include <sys/kernel.h>
32 #include <sys/module.h>
33 #include <sys/malloc.h>
34 #include <sys/rman.h>
35 #include <sys/timetc.h>
36 #include <machine/bus.h>
37 #include <machine/intr.h>
38
39 #include <vm/vm.h>
40 #include <vm/pmap.h>
41
42 #include <arm/xscale/pxa/pxavar.h>
43 #include <arm/xscale/pxa/pxareg.h>
44
45 MALLOC_DEFINE(M_PXASMI, "PXA SMI", "Data for static memory interface devices.");
46
47 struct pxa_smi_softc {
48 struct resource *ps_res[1];
49 struct rman ps_mem;
50 bus_space_tag_t ps_bst;
51 bus_addr_t ps_base;
52 };
53
54 struct smi_ivars {
55 struct resource_list smid_resources;
56 bus_addr_t smid_mem;
57 };
58
59 static struct resource_spec pxa_smi_spec[] = {
60 { SYS_RES_MEMORY, 0, RF_ACTIVE },
61 { -1, 0 }
62 };
63
64 static int pxa_smi_probe(device_t);
65 static int pxa_smi_attach(device_t);
66
67 static int pxa_smi_print_child(device_t, device_t);
68
69 static int pxa_smi_read_ivar(device_t, device_t, int, uintptr_t *);
70
71 static struct resource * pxa_smi_alloc_resource(device_t, device_t,
72 int, int *, u_long, u_long, u_long, u_int);
73 static int pxa_smi_release_resource(device_t, device_t,
74 int, int, struct resource *);
75 static int pxa_smi_activate_resource(device_t, device_t,
76 int, int, struct resource *);
77
78 static void pxa_smi_add_device(device_t, const char *, int);
79
80 static int
81 pxa_smi_probe(device_t dev)
82 {
83
84 if (resource_disabled("smi", device_get_unit(dev)))
85 return (ENXIO);
86
87 device_set_desc(dev, "Static Memory Interface");
88 return (0);
89 }
90
91 static int
92 pxa_smi_attach(device_t dev)
93 {
94 int error, i, dunit;
95 const char *dname;
96 struct pxa_smi_softc *sc;
97
98 sc = (struct pxa_smi_softc *)device_get_softc(dev);
99
100 error = bus_alloc_resources(dev, pxa_smi_spec, sc->ps_res);
101 if (error) {
102 device_printf(dev, "could not allocate resources\n");
103 return (ENXIO);
104 }
105
106 sc->ps_mem.rm_type = RMAN_ARRAY;
107 sc->ps_mem.rm_descr = device_get_nameunit(dev);
108 if (rman_init(&sc->ps_mem) != 0)
109 panic("pxa_smi_attach: failed to init mem rman");
110 if (rman_manage_region(&sc->ps_mem, 0, PXA2X0_CS_SIZE * 6) != 0)
111 panic("pxa_smi_attach: failed ot set up mem rman");
112
113 sc->ps_bst = base_tag;
114 sc->ps_base = rman_get_start(sc->ps_res[0]);
115
116 i = 0;
117 while (resource_find_match(&i, &dname, &dunit, "at",
118 device_get_nameunit(dev)) == 0) {
119 pxa_smi_add_device(dev, dname, dunit);
120 }
121
122 bus_generic_probe(dev);
123 bus_generic_attach(dev);
124
125 return (0);
126 }
127
128 static int
129 pxa_smi_print_child(device_t dev, device_t child)
130 {
131 struct smi_ivars *smid;
132 int retval;
133
134 smid = (struct smi_ivars *)device_get_ivars(child);
135 if (smid == NULL) {
136 device_printf(dev, "unknown device: %s\n",
137 device_get_nameunit(child));
138 return (0);
139 }
140
141 retval = 0;
142
143 retval += bus_print_child_header(dev, child);
144
145 retval += resource_list_print_type(&smid->smid_resources, "at mem",
146 SYS_RES_MEMORY, "%#lx");
147 retval += resource_list_print_type(&smid->smid_resources, "irq",
148 SYS_RES_IRQ, "%ld");
149
150 retval += bus_print_child_footer(dev, child);
151
152 return (retval);
153 }
154
155 static int
156 pxa_smi_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
157 {
158 struct pxa_smi_softc *sc;
159 struct smi_ivars *smid;
160
161 sc = device_get_softc(dev);
162 smid = device_get_ivars(child);
163
164 switch (which) {
165 case SMI_IVAR_PHYSBASE:
166 *((bus_addr_t *)result) = smid->smid_mem;
167 break;
168
169 default:
170 return (ENOENT);
171 }
172
173 return (0);
174 }
175
176 static struct resource *
177 pxa_smi_alloc_resource(device_t dev, device_t child, int type, int *rid,
178 u_long start, u_long end, u_long count, u_int flags)
179 {
180 struct pxa_smi_softc *sc;
181 struct smi_ivars *smid;
182 struct resource *rv;
183 struct resource_list *rl;
184 struct resource_list_entry *rle;
185 int needactivate;
186
187 sc = (struct pxa_smi_softc *)device_get_softc(dev);
188 smid = (struct smi_ivars *)device_get_ivars(child);
189 rl = &smid->smid_resources;
190
191 if (type == SYS_RES_IOPORT)
192 type = SYS_RES_MEMORY;
193
194 rle = resource_list_find(rl, type, *rid);
195 if (rle == NULL)
196 return (NULL);
197 if (rle->res != NULL)
198 panic("pxa_smi_alloc_resource: resource is busy");
199
200 needactivate = flags & RF_ACTIVE;
201 flags &= ~RF_ACTIVE;
202
203 switch (type) {
204 case SYS_RES_MEMORY:
205 rv = rman_reserve_resource(&sc->ps_mem, rle->start, rle->end,
206 rle->count, flags, child);
207 if (rv == NULL)
208 return (NULL);
209 rle->res = rv;
210 rman_set_rid(rv, *rid);
211 rman_set_bustag(rv, sc->ps_bst);
212 rman_set_bushandle(rv, rle->start);
213 if (needactivate) {
214 if (bus_activate_resource(child, type, *rid, rv) != 0) {
215 rman_release_resource(rv);
216 return (NULL);
217 }
218 }
219
220 break;
221
222 case SYS_RES_IRQ:
223 rv = bus_alloc_resource(dev, type, rid, rle->start, rle->end,
224 rle->count, flags);
225 if (rv == NULL)
226 return (NULL);
227 if (needactivate) {
228 if (bus_activate_resource(child, type, *rid, rv) != 0) {
229 bus_release_resource(dev, type, *rid, rv);
230 return (NULL);
231 }
232 }
233
234 break;
235
236 default:
237 return (NULL);
238 }
239
240 return (rv);
241 }
242
243 static int
244 pxa_smi_release_resource(device_t dev, device_t child, int type, int rid,
245 struct resource *r)
246 {
247 struct smi_ivars *smid;
248 struct resource_list *rl;
249 struct resource_list_entry *rle;
250
251 if (type == SYS_RES_IRQ)
252 return (bus_release_resource(dev, SYS_RES_IRQ, rid, r));
253
254 smid = (struct smi_ivars *)device_get_ivars(child);
255 rl = &smid->smid_resources;
256
257 if (type == SYS_RES_IOPORT)
258 type = SYS_RES_MEMORY;
259
260 rle = resource_list_find(rl, type, rid);
261 if (rle == NULL)
262 panic("pxa_smi_release_resource: can't find resource");
263 if (rle->res == NULL)
264 panic("pxa_smi_release_resource: resource entry not busy");
265
266 rman_release_resource(rle->res);
267 rle->res = NULL;
268
269 return (0);
270 }
271
272 static int
273 pxa_smi_activate_resource(device_t dev, device_t child, int type, int rid,
274 struct resource *r)
275 {
276 struct pxa_smi_softc *sc;
277
278 sc = (struct pxa_smi_softc *)device_get_softc(dev);
279
280 if (type == SYS_RES_IRQ)
281 return (bus_activate_resource(dev, SYS_RES_IRQ, rid, r));
282
283 rman_set_bushandle(r, (bus_space_handle_t)pmap_mapdev(rman_get_start(r),
284 rman_get_size(r)));
285 return (rman_activate_resource(r));
286 }
287
288 static device_method_t pxa_smi_methods[] = {
289 DEVMETHOD(device_probe, pxa_smi_probe),
290 DEVMETHOD(device_attach, pxa_smi_attach),
291
292 DEVMETHOD(bus_print_child, pxa_smi_print_child),
293
294 DEVMETHOD(bus_read_ivar, pxa_smi_read_ivar),
295
296 DEVMETHOD(bus_setup_intr, bus_generic_setup_intr),
297
298 DEVMETHOD(bus_alloc_resource, pxa_smi_alloc_resource),
299 DEVMETHOD(bus_release_resource, pxa_smi_release_resource),
300 DEVMETHOD(bus_activate_resource, pxa_smi_activate_resource),
301
302 {0, 0}
303 };
304
305 static driver_t pxa_smi_driver = {
306 "smi",
307 pxa_smi_methods,
308 sizeof(struct pxa_smi_softc),
309 };
310
311 static devclass_t pxa_smi_devclass;
312
313 DRIVER_MODULE(smi, pxa, pxa_smi_driver, pxa_smi_devclass, 0, 0);
314
315 static void
316 pxa_smi_add_device(device_t dev, const char *name, int unit)
317 {
318 device_t child;
319 int start, count;
320 struct smi_ivars *ivars;
321
322 ivars = (struct smi_ivars *)malloc(
323 sizeof(struct smi_ivars), M_PXASMI, M_WAITOK);
324 if (ivars == NULL)
325 return;
326
327 child = device_add_child(dev, name, unit);
328 if (child == NULL) {
329 free(ivars, M_PXASMI);
330 return;
331 }
332
333 device_set_ivars(child, ivars);
334 resource_list_init(&ivars->smid_resources);
335
336 start = 0;
337 count = 0;
338 resource_int_value(name, unit, "mem", &start);
339 resource_int_value(name, unit, "size", &count);
340 if (start > 0 || count > 0) {
341 resource_list_add(&ivars->smid_resources, SYS_RES_MEMORY, 0,
342 start, start + count, count);
343 ivars->smid_mem = (bus_addr_t)start;
344 }
345
346 start = -1;
347 count = 0;
348 resource_int_value(name, unit, "irq", &start);
349 if (start > -1)
350 resource_list_add(&ivars->smid_resources, SYS_RES_IRQ, 0, start,
351 start, 1);
352
353 if (resource_disabled(name, unit))
354 device_disable(child);
355 }
Cache object: bfe3ec4c9802dfe122c07b029ff22b32
|