diff options
author | Rusty Russell <rusty@rustcorp.com.au> | 2008-12-31 07:35:57 -0500 |
---|---|---|
committer | Rusty Russell <rusty@rustcorp.com.au> | 2008-12-31 07:35:57 -0500 |
commit | 2ca1a615835d9f4990f42102ab1f2ef434e7e89c (patch) | |
tree | 726cf3d5f29a6c66c44e4bd68e7ebed2fd83d059 /arch/sparc/kernel/of_device_64.c | |
parent | e12f0102ac81d660c9f801d0a0e10ccf4537a9de (diff) | |
parent | 6a94cb73064c952255336cc57731904174b2c58f (diff) |
Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
Conflicts:
arch/x86/kernel/io_apic.c
Diffstat (limited to 'arch/sparc/kernel/of_device_64.c')
-rw-r--r-- | arch/sparc/kernel/of_device_64.c | 898 |
1 files changed, 898 insertions, 0 deletions
diff --git a/arch/sparc/kernel/of_device_64.c b/arch/sparc/kernel/of_device_64.c new file mode 100644 index 000000000000..4873f28905b0 --- /dev/null +++ b/arch/sparc/kernel/of_device_64.c | |||
@@ -0,0 +1,898 @@ | |||
1 | #include <linux/string.h> | ||
2 | #include <linux/kernel.h> | ||
3 | #include <linux/of.h> | ||
4 | #include <linux/init.h> | ||
5 | #include <linux/module.h> | ||
6 | #include <linux/mod_devicetable.h> | ||
7 | #include <linux/slab.h> | ||
8 | #include <linux/errno.h> | ||
9 | #include <linux/irq.h> | ||
10 | #include <linux/of_device.h> | ||
11 | #include <linux/of_platform.h> | ||
12 | |||
13 | void __iomem *of_ioremap(struct resource *res, unsigned long offset, unsigned long size, char *name) | ||
14 | { | ||
15 | unsigned long ret = res->start + offset; | ||
16 | struct resource *r; | ||
17 | |||
18 | if (res->flags & IORESOURCE_MEM) | ||
19 | r = request_mem_region(ret, size, name); | ||
20 | else | ||
21 | r = request_region(ret, size, name); | ||
22 | if (!r) | ||
23 | ret = 0; | ||
24 | |||
25 | return (void __iomem *) ret; | ||
26 | } | ||
27 | EXPORT_SYMBOL(of_ioremap); | ||
28 | |||
29 | void of_iounmap(struct resource *res, void __iomem *base, unsigned long size) | ||
30 | { | ||
31 | if (res->flags & IORESOURCE_MEM) | ||
32 | release_mem_region((unsigned long) base, size); | ||
33 | else | ||
34 | release_region((unsigned long) base, size); | ||
35 | } | ||
36 | EXPORT_SYMBOL(of_iounmap); | ||
37 | |||
38 | static int node_match(struct device *dev, void *data) | ||
39 | { | ||
40 | struct of_device *op = to_of_device(dev); | ||
41 | struct device_node *dp = data; | ||
42 | |||
43 | return (op->node == dp); | ||
44 | } | ||
45 | |||
46 | struct of_device *of_find_device_by_node(struct device_node *dp) | ||
47 | { | ||
48 | struct device *dev = bus_find_device(&of_platform_bus_type, NULL, | ||
49 | dp, node_match); | ||
50 | |||
51 | if (dev) | ||
52 | return to_of_device(dev); | ||
53 | |||
54 | return NULL; | ||
55 | } | ||
56 | EXPORT_SYMBOL(of_find_device_by_node); | ||
57 | |||
58 | unsigned int irq_of_parse_and_map(struct device_node *node, int index) | ||
59 | { | ||
60 | struct of_device *op = of_find_device_by_node(node); | ||
61 | |||
62 | if (!op || index >= op->num_irqs) | ||
63 | return 0; | ||
64 | |||
65 | return op->irqs[index]; | ||
66 | } | ||
67 | EXPORT_SYMBOL(irq_of_parse_and_map); | ||
68 | |||
69 | /* Take the archdata values for IOMMU, STC, and HOSTDATA found in | ||
70 | * BUS and propagate to all child of_device objects. | ||
71 | */ | ||
72 | void of_propagate_archdata(struct of_device *bus) | ||
73 | { | ||
74 | struct dev_archdata *bus_sd = &bus->dev.archdata; | ||
75 | struct device_node *bus_dp = bus->node; | ||
76 | struct device_node *dp; | ||
77 | |||
78 | for (dp = bus_dp->child; dp; dp = dp->sibling) { | ||
79 | struct of_device *op = of_find_device_by_node(dp); | ||
80 | |||
81 | op->dev.archdata.iommu = bus_sd->iommu; | ||
82 | op->dev.archdata.stc = bus_sd->stc; | ||
83 | op->dev.archdata.host_controller = bus_sd->host_controller; | ||
84 | op->dev.archdata.numa_node = bus_sd->numa_node; | ||
85 | |||
86 | if (dp->child) | ||
87 | of_propagate_archdata(op); | ||
88 | } | ||
89 | } | ||
90 | |||
91 | struct bus_type of_platform_bus_type; | ||
92 | EXPORT_SYMBOL(of_platform_bus_type); | ||
93 | |||
94 | static inline u64 of_read_addr(const u32 *cell, int size) | ||
95 | { | ||
96 | u64 r = 0; | ||
97 | while (size--) | ||
98 | r = (r << 32) | *(cell++); | ||
99 | return r; | ||
100 | } | ||
101 | |||
102 | static void __init get_cells(struct device_node *dp, | ||
103 | int *addrc, int *sizec) | ||
104 | { | ||
105 | if (addrc) | ||
106 | *addrc = of_n_addr_cells(dp); | ||
107 | if (sizec) | ||
108 | *sizec = of_n_size_cells(dp); | ||
109 | } | ||
110 | |||
111 | /* Max address size we deal with */ | ||
112 | #define OF_MAX_ADDR_CELLS 4 | ||
113 | |||
114 | struct of_bus { | ||
115 | const char *name; | ||
116 | const char *addr_prop_name; | ||
117 | int (*match)(struct device_node *parent); | ||
118 | void (*count_cells)(struct device_node *child, | ||
119 | int *addrc, int *sizec); | ||
120 | int (*map)(u32 *addr, const u32 *range, | ||
121 | int na, int ns, int pna); | ||
122 | unsigned long (*get_flags)(const u32 *addr, unsigned long); | ||
123 | }; | ||
124 | |||
125 | /* | ||
126 | * Default translator (generic bus) | ||
127 | */ | ||
128 | |||
129 | static void of_bus_default_count_cells(struct device_node *dev, | ||
130 | int *addrc, int *sizec) | ||
131 | { | ||
132 | get_cells(dev, addrc, sizec); | ||
133 | } | ||
134 | |||
135 | /* Make sure the least significant 64-bits are in-range. Even | ||
136 | * for 3 or 4 cell values it is a good enough approximation. | ||
137 | */ | ||
138 | static int of_out_of_range(const u32 *addr, const u32 *base, | ||
139 | const u32 *size, int na, int ns) | ||
140 | { | ||
141 | u64 a = of_read_addr(addr, na); | ||
142 | u64 b = of_read_addr(base, na); | ||
143 | |||
144 | if (a < b) | ||
145 | return 1; | ||
146 | |||
147 | b += of_read_addr(size, ns); | ||
148 | if (a >= b) | ||
149 | return 1; | ||
150 | |||
151 | return 0; | ||
152 | } | ||
153 | |||
154 | static int of_bus_default_map(u32 *addr, const u32 *range, | ||
155 | int na, int ns, int pna) | ||
156 | { | ||
157 | u32 result[OF_MAX_ADDR_CELLS]; | ||
158 | int i; | ||
159 | |||
160 | if (ns > 2) { | ||
161 | printk("of_device: Cannot handle size cells (%d) > 2.", ns); | ||
162 | return -EINVAL; | ||
163 | } | ||
164 | |||
165 | if (of_out_of_range(addr, range, range + na + pna, na, ns)) | ||
166 | return -EINVAL; | ||
167 | |||
168 | /* Start with the parent range base. */ | ||
169 | memcpy(result, range + na, pna * 4); | ||
170 | |||
171 | /* Add in the child address offset. */ | ||
172 | for (i = 0; i < na; i++) | ||
173 | result[pna - 1 - i] += | ||
174 | (addr[na - 1 - i] - | ||
175 | range[na - 1 - i]); | ||
176 | |||
177 | memcpy(addr, result, pna * 4); | ||
178 | |||
179 | return 0; | ||
180 | } | ||
181 | |||
182 | static unsigned long of_bus_default_get_flags(const u32 *addr, unsigned long flags) | ||
183 | { | ||
184 | if (flags) | ||
185 | return flags; | ||
186 | return IORESOURCE_MEM; | ||
187 | } | ||
188 | |||
189 | /* | ||
190 | * PCI bus specific translator | ||
191 | */ | ||
192 | |||
193 | static int of_bus_pci_match(struct device_node *np) | ||
194 | { | ||
195 | if (!strcmp(np->name, "pci")) { | ||
196 | const char *model = of_get_property(np, "model", NULL); | ||
197 | |||
198 | if (model && !strcmp(model, "SUNW,simba")) | ||
199 | return 0; | ||
200 | |||
201 | /* Do not do PCI specific frobbing if the | ||
202 | * PCI bridge lacks a ranges property. We | ||
203 | * want to pass it through up to the next | ||
204 | * parent as-is, not with the PCI translate | ||
205 | * method which chops off the top address cell. | ||
206 | */ | ||
207 | if (!of_find_property(np, "ranges", NULL)) | ||
208 | return 0; | ||
209 | |||
210 | return 1; | ||
211 | } | ||
212 | |||
213 | return 0; | ||
214 | } | ||
215 | |||
216 | static int of_bus_simba_match(struct device_node *np) | ||
217 | { | ||
218 | const char *model = of_get_property(np, "model", NULL); | ||
219 | |||
220 | if (model && !strcmp(model, "SUNW,simba")) | ||
221 | return 1; | ||
222 | |||
223 | /* Treat PCI busses lacking ranges property just like | ||
224 | * simba. | ||
225 | */ | ||
226 | if (!strcmp(np->name, "pci")) { | ||
227 | if (!of_find_property(np, "ranges", NULL)) | ||
228 | return 1; | ||
229 | } | ||
230 | |||
231 | return 0; | ||
232 | } | ||
233 | |||
234 | static int of_bus_simba_map(u32 *addr, const u32 *range, | ||
235 | int na, int ns, int pna) | ||
236 | { | ||
237 | return 0; | ||
238 | } | ||
239 | |||
240 | static void of_bus_pci_count_cells(struct device_node *np, | ||
241 | int *addrc, int *sizec) | ||
242 | { | ||
243 | if (addrc) | ||
244 | *addrc = 3; | ||
245 | if (sizec) | ||
246 | *sizec = 2; | ||
247 | } | ||
248 | |||
249 | static int of_bus_pci_map(u32 *addr, const u32 *range, | ||
250 | int na, int ns, int pna) | ||
251 | { | ||
252 | u32 result[OF_MAX_ADDR_CELLS]; | ||
253 | int i; | ||
254 | |||
255 | /* Check address type match */ | ||
256 | if ((addr[0] ^ range[0]) & 0x03000000) | ||
257 | return -EINVAL; | ||
258 | |||
259 | if (of_out_of_range(addr + 1, range + 1, range + na + pna, | ||
260 | na - 1, ns)) | ||
261 | return -EINVAL; | ||
262 | |||
263 | /* Start with the parent range base. */ | ||
264 | memcpy(result, range + na, pna * 4); | ||
265 | |||
266 | /* Add in the child address offset, skipping high cell. */ | ||
267 | for (i = 0; i < na - 1; i++) | ||
268 | result[pna - 1 - i] += | ||
269 | (addr[na - 1 - i] - | ||
270 | range[na - 1 - i]); | ||
271 | |||
272 | memcpy(addr, result, pna * 4); | ||
273 | |||
274 | return 0; | ||
275 | } | ||
276 | |||
277 | static unsigned long of_bus_pci_get_flags(const u32 *addr, unsigned long flags) | ||
278 | { | ||
279 | u32 w = addr[0]; | ||
280 | |||
281 | /* For PCI, we override whatever child busses may have used. */ | ||
282 | flags = 0; | ||
283 | switch((w >> 24) & 0x03) { | ||
284 | case 0x01: | ||
285 | flags |= IORESOURCE_IO; | ||
286 | break; | ||
287 | |||
288 | case 0x02: /* 32 bits */ | ||
289 | case 0x03: /* 64 bits */ | ||
290 | flags |= IORESOURCE_MEM; | ||
291 | break; | ||
292 | } | ||
293 | if (w & 0x40000000) | ||
294 | flags |= IORESOURCE_PREFETCH; | ||
295 | return flags; | ||
296 | } | ||
297 | |||
298 | /* | ||
299 | * SBUS bus specific translator | ||
300 | */ | ||
301 | |||
302 | static int of_bus_sbus_match(struct device_node *np) | ||
303 | { | ||
304 | return !strcmp(np->name, "sbus") || | ||
305 | !strcmp(np->name, "sbi"); | ||
306 | } | ||
307 | |||
308 | static void of_bus_sbus_count_cells(struct device_node *child, | ||
309 | int *addrc, int *sizec) | ||
310 | { | ||
311 | if (addrc) | ||
312 | *addrc = 2; | ||
313 | if (sizec) | ||
314 | *sizec = 1; | ||
315 | } | ||
316 | |||
317 | /* | ||
318 | * FHC/Central bus specific translator. | ||
319 | * | ||
320 | * This is just needed to hard-code the address and size cell | ||
321 | * counts. 'fhc' and 'central' nodes lack the #address-cells and | ||
322 | * #size-cells properties, and if you walk to the root on such | ||
323 | * Enterprise boxes all you'll get is a #size-cells of 2 which is | ||
324 | * not what we want to use. | ||
325 | */ | ||
326 | static int of_bus_fhc_match(struct device_node *np) | ||
327 | { | ||
328 | return !strcmp(np->name, "fhc") || | ||
329 | !strcmp(np->name, "central"); | ||
330 | } | ||
331 | |||
332 | #define of_bus_fhc_count_cells of_bus_sbus_count_cells | ||
333 | |||
334 | /* | ||
335 | * Array of bus specific translators | ||
336 | */ | ||
337 | |||
338 | static struct of_bus of_busses[] = { | ||
339 | /* PCI */ | ||
340 | { | ||
341 | .name = "pci", | ||
342 | .addr_prop_name = "assigned-addresses", | ||
343 | .match = of_bus_pci_match, | ||
344 | .count_cells = of_bus_pci_count_cells, | ||
345 | .map = of_bus_pci_map, | ||
346 | .get_flags = of_bus_pci_get_flags, | ||
347 | }, | ||
348 | /* SIMBA */ | ||
349 | { | ||
350 | .name = "simba", | ||
351 | .addr_prop_name = "assigned-addresses", | ||
352 | .match = of_bus_simba_match, | ||
353 | .count_cells = of_bus_pci_count_cells, | ||
354 | .map = of_bus_simba_map, | ||
355 | .get_flags = of_bus_pci_get_flags, | ||
356 | }, | ||
357 | /* SBUS */ | ||
358 | { | ||
359 | .name = "sbus", | ||
360 | .addr_prop_name = "reg", | ||
361 | .match = of_bus_sbus_match, | ||
362 | .count_cells = of_bus_sbus_count_cells, | ||
363 | .map = of_bus_default_map, | ||
364 | .get_flags = of_bus_default_get_flags, | ||
365 | }, | ||
366 | /* FHC */ | ||
367 | { | ||
368 | .name = "fhc", | ||
369 | .addr_prop_name = "reg", | ||
370 | .match = of_bus_fhc_match, | ||
371 | .count_cells = of_bus_fhc_count_cells, | ||
372 | .map = of_bus_default_map, | ||
373 | .get_flags = of_bus_default_get_flags, | ||
374 | }, | ||
375 | /* Default */ | ||
376 | { | ||
377 | .name = "default", | ||
378 | .addr_prop_name = "reg", | ||
379 | .match = NULL, | ||
380 | .count_cells = of_bus_default_count_cells, | ||
381 | .map = of_bus_default_map, | ||
382 | .get_flags = of_bus_default_get_flags, | ||
383 | }, | ||
384 | }; | ||
385 | |||
386 | static struct of_bus *of_match_bus(struct device_node *np) | ||
387 | { | ||
388 | int i; | ||
389 | |||
390 | for (i = 0; i < ARRAY_SIZE(of_busses); i ++) | ||
391 | if (!of_busses[i].match || of_busses[i].match(np)) | ||
392 | return &of_busses[i]; | ||
393 | BUG(); | ||
394 | return NULL; | ||
395 | } | ||
396 | |||
397 | static int __init build_one_resource(struct device_node *parent, | ||
398 | struct of_bus *bus, | ||
399 | struct of_bus *pbus, | ||
400 | u32 *addr, | ||
401 | int na, int ns, int pna) | ||
402 | { | ||
403 | const u32 *ranges; | ||
404 | int rone, rlen; | ||
405 | |||
406 | ranges = of_get_property(parent, "ranges", &rlen); | ||
407 | if (ranges == NULL || rlen == 0) { | ||
408 | u32 result[OF_MAX_ADDR_CELLS]; | ||
409 | int i; | ||
410 | |||
411 | memset(result, 0, pna * 4); | ||
412 | for (i = 0; i < na; i++) | ||
413 | result[pna - 1 - i] = | ||
414 | addr[na - 1 - i]; | ||
415 | |||
416 | memcpy(addr, result, pna * 4); | ||
417 | return 0; | ||
418 | } | ||
419 | |||
420 | /* Now walk through the ranges */ | ||
421 | rlen /= 4; | ||
422 | rone = na + pna + ns; | ||
423 | for (; rlen >= rone; rlen -= rone, ranges += rone) { | ||
424 | if (!bus->map(addr, ranges, na, ns, pna)) | ||
425 | return 0; | ||
426 | } | ||
427 | |||
428 | /* When we miss an I/O space match on PCI, just pass it up | ||
429 | * to the next PCI bridge and/or controller. | ||
430 | */ | ||
431 | if (!strcmp(bus->name, "pci") && | ||
432 | (addr[0] & 0x03000000) == 0x01000000) | ||
433 | return 0; | ||
434 | |||
435 | return 1; | ||
436 | } | ||
437 | |||
438 | static int __init use_1to1_mapping(struct device_node *pp) | ||
439 | { | ||
440 | /* If we have a ranges property in the parent, use it. */ | ||
441 | if (of_find_property(pp, "ranges", NULL) != NULL) | ||
442 | return 0; | ||
443 | |||
444 | /* If the parent is the dma node of an ISA bus, pass | ||
445 | * the translation up to the root. | ||
446 | * | ||
447 | * Some SBUS devices use intermediate nodes to express | ||
448 | * hierarchy within the device itself. These aren't | ||
449 | * real bus nodes, and don't have a 'ranges' property. | ||
450 | * But, we should still pass the translation work up | ||
451 | * to the SBUS itself. | ||
452 | */ | ||
453 | if (!strcmp(pp->name, "dma") || | ||
454 | !strcmp(pp->name, "espdma") || | ||
455 | !strcmp(pp->name, "ledma") || | ||
456 | !strcmp(pp->name, "lebuffer")) | ||
457 | return 0; | ||
458 | |||
459 | /* Similarly for all PCI bridges, if we get this far | ||
460 | * it lacks a ranges property, and this will include | ||
461 | * cases like Simba. | ||
462 | */ | ||
463 | if (!strcmp(pp->name, "pci")) | ||
464 | return 0; | ||
465 | |||
466 | return 1; | ||
467 | } | ||
468 | |||
469 | static int of_resource_verbose; | ||
470 | |||
471 | static void __init build_device_resources(struct of_device *op, | ||
472 | struct device *parent) | ||
473 | { | ||
474 | struct of_device *p_op; | ||
475 | struct of_bus *bus; | ||
476 | int na, ns; | ||
477 | int index, num_reg; | ||
478 | const void *preg; | ||
479 | |||
480 | if (!parent) | ||
481 | return; | ||
482 | |||
483 | p_op = to_of_device(parent); | ||
484 | bus = of_match_bus(p_op->node); | ||
485 | bus->count_cells(op->node, &na, &ns); | ||
486 | |||
487 | preg = of_get_property(op->node, bus->addr_prop_name, &num_reg); | ||
488 | if (!preg || num_reg == 0) | ||
489 | return; | ||
490 | |||
491 | /* Convert to num-cells. */ | ||
492 | num_reg /= 4; | ||
493 | |||
494 | /* Convert to num-entries. */ | ||
495 | num_reg /= na + ns; | ||
496 | |||
497 | /* Prevent overrunning the op->resources[] array. */ | ||
498 | if (num_reg > PROMREG_MAX) { | ||
499 | printk(KERN_WARNING "%s: Too many regs (%d), " | ||
500 | "limiting to %d.\n", | ||
501 | op->node->full_name, num_reg, PROMREG_MAX); | ||
502 | num_reg = PROMREG_MAX; | ||
503 | } | ||
504 | |||
505 | for (index = 0; index < num_reg; index++) { | ||
506 | struct resource *r = &op->resource[index]; | ||
507 | u32 addr[OF_MAX_ADDR_CELLS]; | ||
508 | const u32 *reg = (preg + (index * ((na + ns) * 4))); | ||
509 | struct device_node *dp = op->node; | ||
510 | struct device_node *pp = p_op->node; | ||
511 | struct of_bus *pbus, *dbus; | ||
512 | u64 size, result = OF_BAD_ADDR; | ||
513 | unsigned long flags; | ||
514 | int dna, dns; | ||
515 | int pna, pns; | ||
516 | |||
517 | size = of_read_addr(reg + na, ns); | ||
518 | memcpy(addr, reg, na * 4); | ||
519 | |||
520 | flags = bus->get_flags(addr, 0); | ||
521 | |||
522 | if (use_1to1_mapping(pp)) { | ||
523 | result = of_read_addr(addr, na); | ||
524 | goto build_res; | ||
525 | } | ||
526 | |||
527 | dna = na; | ||
528 | dns = ns; | ||
529 | dbus = bus; | ||
530 | |||
531 | while (1) { | ||
532 | dp = pp; | ||
533 | pp = dp->parent; | ||
534 | if (!pp) { | ||
535 | result = of_read_addr(addr, dna); | ||
536 | break; | ||
537 | } | ||
538 | |||
539 | pbus = of_match_bus(pp); | ||
540 | pbus->count_cells(dp, &pna, &pns); | ||
541 | |||
542 | if (build_one_resource(dp, dbus, pbus, addr, | ||
543 | dna, dns, pna)) | ||
544 | break; | ||
545 | |||
546 | flags = pbus->get_flags(addr, flags); | ||
547 | |||
548 | dna = pna; | ||
549 | dns = pns; | ||
550 | dbus = pbus; | ||
551 | } | ||
552 | |||
553 | build_res: | ||
554 | memset(r, 0, sizeof(*r)); | ||
555 | |||
556 | if (of_resource_verbose) | ||
557 | printk("%s reg[%d] -> %lx\n", | ||
558 | op->node->full_name, index, | ||
559 | result); | ||
560 | |||
561 | if (result != OF_BAD_ADDR) { | ||
562 | if (tlb_type == hypervisor) | ||
563 | result &= 0x0fffffffffffffffUL; | ||
564 | |||
565 | r->start = result; | ||
566 | r->end = result + size - 1; | ||
567 | r->flags = flags; | ||
568 | } | ||
569 | r->name = op->node->name; | ||
570 | } | ||
571 | } | ||
572 | |||
573 | static struct device_node * __init | ||
574 | apply_interrupt_map(struct device_node *dp, struct device_node *pp, | ||
575 | const u32 *imap, int imlen, const u32 *imask, | ||
576 | unsigned int *irq_p) | ||
577 | { | ||
578 | struct device_node *cp; | ||
579 | unsigned int irq = *irq_p; | ||
580 | struct of_bus *bus; | ||
581 | phandle handle; | ||
582 | const u32 *reg; | ||
583 | int na, num_reg, i; | ||
584 | |||
585 | bus = of_match_bus(pp); | ||
586 | bus->count_cells(dp, &na, NULL); | ||
587 | |||
588 | reg = of_get_property(dp, "reg", &num_reg); | ||
589 | if (!reg || !num_reg) | ||
590 | return NULL; | ||
591 | |||
592 | imlen /= ((na + 3) * 4); | ||
593 | handle = 0; | ||
594 | for (i = 0; i < imlen; i++) { | ||
595 | int j; | ||
596 | |||
597 | for (j = 0; j < na; j++) { | ||
598 | if ((reg[j] & imask[j]) != imap[j]) | ||
599 | goto next; | ||
600 | } | ||
601 | if (imap[na] == irq) { | ||
602 | handle = imap[na + 1]; | ||
603 | irq = imap[na + 2]; | ||
604 | break; | ||
605 | } | ||
606 | |||
607 | next: | ||
608 | imap += (na + 3); | ||
609 | } | ||
610 | if (i == imlen) { | ||
611 | /* Psycho and Sabre PCI controllers can have 'interrupt-map' | ||
612 | * properties that do not include the on-board device | ||
613 | * interrupts. Instead, the device's 'interrupts' property | ||
614 | * is already a fully specified INO value. | ||
615 | * | ||
616 | * Handle this by deciding that, if we didn't get a | ||
617 | * match in the parent's 'interrupt-map', and the | ||
618 | * parent is an IRQ translater, then use the parent as | ||
619 | * our IRQ controller. | ||
620 | */ | ||
621 | if (pp->irq_trans) | ||
622 | return pp; | ||
623 | |||
624 | return NULL; | ||
625 | } | ||
626 | |||
627 | *irq_p = irq; | ||
628 | cp = of_find_node_by_phandle(handle); | ||
629 | |||
630 | return cp; | ||
631 | } | ||
632 | |||
633 | static unsigned int __init pci_irq_swizzle(struct device_node *dp, | ||
634 | struct device_node *pp, | ||
635 | unsigned int irq) | ||
636 | { | ||
637 | const struct linux_prom_pci_registers *regs; | ||
638 | unsigned int bus, devfn, slot, ret; | ||
639 | |||
640 | if (irq < 1 || irq > 4) | ||
641 | return irq; | ||
642 | |||
643 | regs = of_get_property(dp, "reg", NULL); | ||
644 | if (!regs) | ||
645 | return irq; | ||
646 | |||
647 | bus = (regs->phys_hi >> 16) & 0xff; | ||
648 | devfn = (regs->phys_hi >> 8) & 0xff; | ||
649 | slot = (devfn >> 3) & 0x1f; | ||
650 | |||
651 | if (pp->irq_trans) { | ||
652 | /* Derived from Table 8-3, U2P User's Manual. This branch | ||
653 | * is handling a PCI controller that lacks a proper set of | ||
654 | * interrupt-map and interrupt-map-mask properties. The | ||
655 | * Ultra-E450 is one example. | ||
656 | * | ||
657 | * The bit layout is BSSLL, where: | ||
658 | * B: 0 on bus A, 1 on bus B | ||
659 | * D: 2-bit slot number, derived from PCI device number as | ||
660 | * (dev - 1) for bus A, or (dev - 2) for bus B | ||
661 | * L: 2-bit line number | ||
662 | */ | ||
663 | if (bus & 0x80) { | ||
664 | /* PBM-A */ | ||
665 | bus = 0x00; | ||
666 | slot = (slot - 1) << 2; | ||
667 | } else { | ||
668 | /* PBM-B */ | ||
669 | bus = 0x10; | ||
670 | slot = (slot - 2) << 2; | ||
671 | } | ||
672 | irq -= 1; | ||
673 | |||
674 | ret = (bus | slot | irq); | ||
675 | } else { | ||
676 | /* Going through a PCI-PCI bridge that lacks a set of | ||
677 | * interrupt-map and interrupt-map-mask properties. | ||
678 | */ | ||
679 | ret = ((irq - 1 + (slot & 3)) & 3) + 1; | ||
680 | } | ||
681 | |||
682 | return ret; | ||
683 | } | ||
684 | |||
685 | static int of_irq_verbose; | ||
686 | |||
687 | static unsigned int __init build_one_device_irq(struct of_device *op, | ||
688 | struct device *parent, | ||
689 | unsigned int irq) | ||
690 | { | ||
691 | struct device_node *dp = op->node; | ||
692 | struct device_node *pp, *ip; | ||
693 | unsigned int orig_irq = irq; | ||
694 | int nid; | ||
695 | |||
696 | if (irq == 0xffffffff) | ||
697 | return irq; | ||
698 | |||
699 | if (dp->irq_trans) { | ||
700 | irq = dp->irq_trans->irq_build(dp, irq, | ||
701 | dp->irq_trans->data); | ||
702 | |||
703 | if (of_irq_verbose) | ||
704 | printk("%s: direct translate %x --> %x\n", | ||
705 | dp->full_name, orig_irq, irq); | ||
706 | |||
707 | goto out; | ||
708 | } | ||
709 | |||
710 | /* Something more complicated. Walk up to the root, applying | ||
711 | * interrupt-map or bus specific translations, until we hit | ||
712 | * an IRQ translator. | ||
713 | * | ||
714 | * If we hit a bus type or situation we cannot handle, we | ||
715 | * stop and assume that the original IRQ number was in a | ||
716 | * format which has special meaning to it's immediate parent. | ||
717 | */ | ||
718 | pp = dp->parent; | ||
719 | ip = NULL; | ||
720 | while (pp) { | ||
721 | const void *imap, *imsk; | ||
722 | int imlen; | ||
723 | |||
724 | imap = of_get_property(pp, "interrupt-map", &imlen); | ||
725 | imsk = of_get_property(pp, "interrupt-map-mask", NULL); | ||
726 | if (imap && imsk) { | ||
727 | struct device_node *iret; | ||
728 | int this_orig_irq = irq; | ||
729 | |||
730 | iret = apply_interrupt_map(dp, pp, | ||
731 | imap, imlen, imsk, | ||
732 | &irq); | ||
733 | |||
734 | if (of_irq_verbose) | ||
735 | printk("%s: Apply [%s:%x] imap --> [%s:%x]\n", | ||
736 | op->node->full_name, | ||
737 | pp->full_name, this_orig_irq, | ||
738 | (iret ? iret->full_name : "NULL"), irq); | ||
739 | |||
740 | if (!iret) | ||
741 | break; | ||
742 | |||
743 | if (iret->irq_trans) { | ||
744 | ip = iret; | ||
745 | break; | ||
746 | } | ||
747 | } else { | ||
748 | if (!strcmp(pp->name, "pci")) { | ||
749 | unsigned int this_orig_irq = irq; | ||
750 | |||
751 | irq = pci_irq_swizzle(dp, pp, irq); | ||
752 | if (of_irq_verbose) | ||
753 | printk("%s: PCI swizzle [%s] " | ||
754 | "%x --> %x\n", | ||
755 | op->node->full_name, | ||
756 | pp->full_name, this_orig_irq, | ||
757 | irq); | ||
758 | |||
759 | } | ||
760 | |||
761 | if (pp->irq_trans) { | ||
762 | ip = pp; | ||
763 | break; | ||
764 | } | ||
765 | } | ||
766 | dp = pp; | ||
767 | pp = pp->parent; | ||
768 | } | ||
769 | if (!ip) | ||
770 | return orig_irq; | ||
771 | |||
772 | irq = ip->irq_trans->irq_build(op->node, irq, | ||
773 | ip->irq_trans->data); | ||
774 | if (of_irq_verbose) | ||
775 | printk("%s: Apply IRQ trans [%s] %x --> %x\n", | ||
776 | op->node->full_name, ip->full_name, orig_irq, irq); | ||
777 | |||
778 | out: | ||
779 | nid = of_node_to_nid(dp); | ||
780 | if (nid != -1) { | ||
781 | cpumask_t numa_mask = *cpumask_of_node(nid); | ||
782 | |||
783 | irq_set_affinity(irq, &numa_mask); | ||
784 | } | ||
785 | |||
786 | return irq; | ||
787 | } | ||
788 | |||
789 | static struct of_device * __init scan_one_device(struct device_node *dp, | ||
790 | struct device *parent) | ||
791 | { | ||
792 | struct of_device *op = kzalloc(sizeof(*op), GFP_KERNEL); | ||
793 | const unsigned int *irq; | ||
794 | struct dev_archdata *sd; | ||
795 | int len, i; | ||
796 | |||
797 | if (!op) | ||
798 | return NULL; | ||
799 | |||
800 | sd = &op->dev.archdata; | ||
801 | sd->prom_node = dp; | ||
802 | sd->op = op; | ||
803 | |||
804 | op->node = dp; | ||
805 | |||
806 | op->clock_freq = of_getintprop_default(dp, "clock-frequency", | ||
807 | (25*1000*1000)); | ||
808 | op->portid = of_getintprop_default(dp, "upa-portid", -1); | ||
809 | if (op->portid == -1) | ||
810 | op->portid = of_getintprop_default(dp, "portid", -1); | ||
811 | |||
812 | irq = of_get_property(dp, "interrupts", &len); | ||
813 | if (irq) { | ||
814 | op->num_irqs = len / 4; | ||
815 | |||
816 | /* Prevent overrunning the op->irqs[] array. */ | ||
817 | if (op->num_irqs > PROMINTR_MAX) { | ||
818 | printk(KERN_WARNING "%s: Too many irqs (%d), " | ||
819 | "limiting to %d.\n", | ||
820 | dp->full_name, op->num_irqs, PROMINTR_MAX); | ||
821 | op->num_irqs = PROMINTR_MAX; | ||
822 | } | ||
823 | memcpy(op->irqs, irq, op->num_irqs * 4); | ||
824 | } else { | ||
825 | op->num_irqs = 0; | ||
826 | } | ||
827 | |||
828 | build_device_resources(op, parent); | ||
829 | for (i = 0; i < op->num_irqs; i++) | ||
830 | op->irqs[i] = build_one_device_irq(op, parent, op->irqs[i]); | ||
831 | |||
832 | op->dev.parent = parent; | ||
833 | op->dev.bus = &of_platform_bus_type; | ||
834 | if (!parent) | ||
835 | dev_set_name(&op->dev, "root"); | ||
836 | else | ||
837 | dev_set_name(&op->dev, "%08x", dp->node); | ||
838 | |||
839 | if (of_device_register(op)) { | ||
840 | printk("%s: Could not register of device.\n", | ||
841 | dp->full_name); | ||
842 | kfree(op); | ||
843 | op = NULL; | ||
844 | } | ||
845 | |||
846 | return op; | ||
847 | } | ||
848 | |||
849 | static void __init scan_tree(struct device_node *dp, struct device *parent) | ||
850 | { | ||
851 | while (dp) { | ||
852 | struct of_device *op = scan_one_device(dp, parent); | ||
853 | |||
854 | if (op) | ||
855 | scan_tree(dp->child, &op->dev); | ||
856 | |||
857 | dp = dp->sibling; | ||
858 | } | ||
859 | } | ||
860 | |||
861 | static void __init scan_of_devices(void) | ||
862 | { | ||
863 | struct device_node *root = of_find_node_by_path("/"); | ||
864 | struct of_device *parent; | ||
865 | |||
866 | parent = scan_one_device(root, NULL); | ||
867 | if (!parent) | ||
868 | return; | ||
869 | |||
870 | scan_tree(root->child, &parent->dev); | ||
871 | } | ||
872 | |||
873 | static int __init of_bus_driver_init(void) | ||
874 | { | ||
875 | int err; | ||
876 | |||
877 | err = of_bus_type_init(&of_platform_bus_type, "of"); | ||
878 | if (!err) | ||
879 | scan_of_devices(); | ||
880 | |||
881 | return err; | ||
882 | } | ||
883 | |||
884 | postcore_initcall(of_bus_driver_init); | ||
885 | |||
886 | static int __init of_debug(char *str) | ||
887 | { | ||
888 | int val = 0; | ||
889 | |||
890 | get_option(&str, &val); | ||
891 | if (val & 1) | ||
892 | of_resource_verbose = 1; | ||
893 | if (val & 2) | ||
894 | of_irq_verbose = 1; | ||
895 | return 1; | ||
896 | } | ||
897 | |||
898 | __setup("of_debug=", of_debug); | ||