Commit | Line | Data |
---|---|---|
d1405b86 BH |
1 | #undef DEBUG |
2 | ||
3 | #include <linux/kernel.h> | |
4 | #include <linux/string.h> | |
5 | #include <linux/pci_regs.h> | |
6 | #include <linux/module.h> | |
d2dd482b | 7 | #include <linux/ioport.h> |
d1405b86 | 8 | #include <asm/prom.h> |
d2dd482b | 9 | #include <asm/pci-bridge.h> |
d1405b86 BH |
10 | |
11 | #ifdef DEBUG | |
12 | #define DBG(fmt...) do { printk(fmt); } while(0) | |
13 | #else | |
14 | #define DBG(fmt...) do { } while(0) | |
15 | #endif | |
16 | ||
17 | #ifdef CONFIG_PPC64 | |
18 | #define PRu64 "%lx" | |
19 | #else | |
20 | #define PRu64 "%llx" | |
21 | #endif | |
22 | ||
23 | /* Max address size we deal with */ | |
24 | #define OF_MAX_ADDR_CELLS 4 | |
25 | #define OF_CHECK_COUNTS(na, ns) ((na) > 0 && (na) <= OF_MAX_ADDR_CELLS && \ | |
26 | (ns) > 0) | |
27 | ||
28 | /* Debug utility */ | |
29 | #ifdef DEBUG | |
30 | static void of_dump_addr(const char *s, u32 *addr, int na) | |
31 | { | |
32 | printk("%s", s); | |
33 | while(na--) | |
34 | printk(" %08x", *(addr++)); | |
35 | printk("\n"); | |
36 | } | |
37 | #else | |
38 | static void of_dump_addr(const char *s, u32 *addr, int na) { } | |
39 | #endif | |
40 | ||
d1405b86 BH |
41 | |
42 | /* Callbacks for bus specific translators */ | |
43 | struct of_bus { | |
44 | const char *name; | |
45 | const char *addresses; | |
46 | int (*match)(struct device_node *parent); | |
47 | void (*count_cells)(struct device_node *child, | |
48 | int *addrc, int *sizec); | |
49 | u64 (*map)(u32 *addr, u32 *range, int na, int ns, int pna); | |
50 | int (*translate)(u32 *addr, u64 offset, int na); | |
d2dd482b | 51 | unsigned int (*get_flags)(u32 *addr); |
d1405b86 BH |
52 | }; |
53 | ||
54 | ||
55 | /* | |
56 | * Default translator (generic bus) | |
57 | */ | |
58 | ||
d2dd482b BH |
59 | static void of_bus_default_count_cells(struct device_node *dev, |
60 | int *addrc, int *sizec) | |
d1405b86 BH |
61 | { |
62 | if (addrc) | |
63 | *addrc = prom_n_addr_cells(dev); | |
64 | if (sizec) | |
65 | *sizec = prom_n_size_cells(dev); | |
66 | } | |
67 | ||
d2dd482b | 68 | static u64 of_bus_default_map(u32 *addr, u32 *range, int na, int ns, int pna) |
d1405b86 BH |
69 | { |
70 | u64 cp, s, da; | |
71 | ||
cc9fd71c BH |
72 | cp = of_read_number(range, na); |
73 | s = of_read_number(range + na + pna, ns); | |
74 | da = of_read_number(addr, na); | |
d1405b86 BH |
75 | |
76 | DBG("OF: default map, cp="PRu64", s="PRu64", da="PRu64"\n", | |
77 | cp, s, da); | |
78 | ||
79 | if (da < cp || da >= (cp + s)) | |
80 | return OF_BAD_ADDR; | |
81 | return da - cp; | |
82 | } | |
83 | ||
d2dd482b | 84 | static int of_bus_default_translate(u32 *addr, u64 offset, int na) |
d1405b86 | 85 | { |
cc9fd71c | 86 | u64 a = of_read_number(addr, na); |
d1405b86 BH |
87 | memset(addr, 0, na * 4); |
88 | a += offset; | |
89 | if (na > 1) | |
90 | addr[na - 2] = a >> 32; | |
91 | addr[na - 1] = a & 0xffffffffu; | |
92 | ||
93 | return 0; | |
94 | } | |
95 | ||
d2dd482b BH |
96 | static unsigned int of_bus_default_get_flags(u32 *addr) |
97 | { | |
98 | return IORESOURCE_MEM; | |
99 | } | |
100 | ||
d1405b86 BH |
101 | |
102 | /* | |
103 | * PCI bus specific translator | |
104 | */ | |
105 | ||
106 | static int of_bus_pci_match(struct device_node *np) | |
107 | { | |
d5f07900 PM |
108 | /* "vci" is for the /chaos bridge on 1st-gen PCI powermacs */ |
109 | return !strcmp(np->type, "pci") || !strcmp(np->type, "vci"); | |
d1405b86 BH |
110 | } |
111 | ||
112 | static void of_bus_pci_count_cells(struct device_node *np, | |
113 | int *addrc, int *sizec) | |
114 | { | |
115 | if (addrc) | |
116 | *addrc = 3; | |
117 | if (sizec) | |
118 | *sizec = 2; | |
119 | } | |
120 | ||
121 | static u64 of_bus_pci_map(u32 *addr, u32 *range, int na, int ns, int pna) | |
122 | { | |
123 | u64 cp, s, da; | |
124 | ||
125 | /* Check address type match */ | |
126 | if ((addr[0] ^ range[0]) & 0x03000000) | |
127 | return OF_BAD_ADDR; | |
128 | ||
129 | /* Read address values, skipping high cell */ | |
cc9fd71c BH |
130 | cp = of_read_number(range + 1, na - 1); |
131 | s = of_read_number(range + na + pna, ns); | |
132 | da = of_read_number(addr + 1, na - 1); | |
d1405b86 BH |
133 | |
134 | DBG("OF: PCI map, cp="PRu64", s="PRu64", da="PRu64"\n", cp, s, da); | |
135 | ||
136 | if (da < cp || da >= (cp + s)) | |
137 | return OF_BAD_ADDR; | |
138 | return da - cp; | |
139 | } | |
140 | ||
141 | static int of_bus_pci_translate(u32 *addr, u64 offset, int na) | |
142 | { | |
d2dd482b BH |
143 | return of_bus_default_translate(addr + 1, offset, na - 1); |
144 | } | |
145 | ||
146 | static unsigned int of_bus_pci_get_flags(u32 *addr) | |
147 | { | |
148 | unsigned int flags = 0; | |
149 | u32 w = addr[0]; | |
150 | ||
151 | switch((w >> 24) & 0x03) { | |
152 | case 0x01: | |
153 | flags |= IORESOURCE_IO; | |
154 | case 0x02: /* 32 bits */ | |
155 | case 0x03: /* 64 bits */ | |
156 | flags |= IORESOURCE_MEM; | |
157 | } | |
158 | if (w & 0x40000000) | |
159 | flags |= IORESOURCE_PREFETCH; | |
160 | return flags; | |
d1405b86 BH |
161 | } |
162 | ||
163 | /* | |
164 | * ISA bus specific translator | |
165 | */ | |
166 | ||
167 | static int of_bus_isa_match(struct device_node *np) | |
168 | { | |
169 | return !strcmp(np->name, "isa"); | |
170 | } | |
171 | ||
172 | static void of_bus_isa_count_cells(struct device_node *child, | |
173 | int *addrc, int *sizec) | |
174 | { | |
175 | if (addrc) | |
176 | *addrc = 2; | |
177 | if (sizec) | |
178 | *sizec = 1; | |
179 | } | |
180 | ||
181 | static u64 of_bus_isa_map(u32 *addr, u32 *range, int na, int ns, int pna) | |
182 | { | |
183 | u64 cp, s, da; | |
184 | ||
185 | /* Check address type match */ | |
186 | if ((addr[0] ^ range[0]) & 0x00000001) | |
187 | return OF_BAD_ADDR; | |
188 | ||
189 | /* Read address values, skipping high cell */ | |
cc9fd71c BH |
190 | cp = of_read_number(range + 1, na - 1); |
191 | s = of_read_number(range + na + pna, ns); | |
192 | da = of_read_number(addr + 1, na - 1); | |
d1405b86 BH |
193 | |
194 | DBG("OF: ISA map, cp="PRu64", s="PRu64", da="PRu64"\n", cp, s, da); | |
195 | ||
196 | if (da < cp || da >= (cp + s)) | |
197 | return OF_BAD_ADDR; | |
198 | return da - cp; | |
199 | } | |
200 | ||
201 | static int of_bus_isa_translate(u32 *addr, u64 offset, int na) | |
202 | { | |
d2dd482b BH |
203 | return of_bus_default_translate(addr + 1, offset, na - 1); |
204 | } | |
205 | ||
206 | static unsigned int of_bus_isa_get_flags(u32 *addr) | |
207 | { | |
208 | unsigned int flags = 0; | |
209 | u32 w = addr[0]; | |
210 | ||
211 | if (w & 1) | |
212 | flags |= IORESOURCE_IO; | |
213 | else | |
214 | flags |= IORESOURCE_MEM; | |
215 | return flags; | |
d1405b86 BH |
216 | } |
217 | ||
d2dd482b | 218 | |
d1405b86 BH |
219 | /* |
220 | * Array of bus specific translators | |
221 | */ | |
222 | ||
223 | static struct of_bus of_busses[] = { | |
224 | /* PCI */ | |
225 | { | |
226 | .name = "pci", | |
227 | .addresses = "assigned-addresses", | |
228 | .match = of_bus_pci_match, | |
229 | .count_cells = of_bus_pci_count_cells, | |
230 | .map = of_bus_pci_map, | |
231 | .translate = of_bus_pci_translate, | |
d2dd482b | 232 | .get_flags = of_bus_pci_get_flags, |
d1405b86 BH |
233 | }, |
234 | /* ISA */ | |
235 | { | |
236 | .name = "isa", | |
237 | .addresses = "reg", | |
238 | .match = of_bus_isa_match, | |
239 | .count_cells = of_bus_isa_count_cells, | |
240 | .map = of_bus_isa_map, | |
241 | .translate = of_bus_isa_translate, | |
d2dd482b | 242 | .get_flags = of_bus_isa_get_flags, |
d1405b86 BH |
243 | }, |
244 | /* Default */ | |
245 | { | |
246 | .name = "default", | |
247 | .addresses = "reg", | |
248 | .match = NULL, | |
d2dd482b BH |
249 | .count_cells = of_bus_default_count_cells, |
250 | .map = of_bus_default_map, | |
251 | .translate = of_bus_default_translate, | |
252 | .get_flags = of_bus_default_get_flags, | |
d1405b86 BH |
253 | }, |
254 | }; | |
255 | ||
256 | static struct of_bus *of_match_bus(struct device_node *np) | |
257 | { | |
258 | int i; | |
259 | ||
260 | for (i = 0; i < ARRAY_SIZE(of_busses); i ++) | |
261 | if (!of_busses[i].match || of_busses[i].match(np)) | |
262 | return &of_busses[i]; | |
263 | BUG(); | |
264 | return NULL; | |
265 | } | |
266 | ||
267 | static int of_translate_one(struct device_node *parent, struct of_bus *bus, | |
268 | struct of_bus *pbus, u32 *addr, | |
269 | int na, int ns, int pna) | |
270 | { | |
271 | u32 *ranges; | |
272 | unsigned int rlen; | |
273 | int rone; | |
274 | u64 offset = OF_BAD_ADDR; | |
275 | ||
276 | /* Normally, an absence of a "ranges" property means we are | |
277 | * crossing a non-translatable boundary, and thus the addresses | |
278 | * below the current not cannot be converted to CPU physical ones. | |
279 | * Unfortunately, while this is very clear in the spec, it's not | |
280 | * what Apple understood, and they do have things like /uni-n or | |
281 | * /ht nodes with no "ranges" property and a lot of perfectly | |
282 | * useable mapped devices below them. Thus we treat the absence of | |
283 | * "ranges" as equivalent to an empty "ranges" property which means | |
284 | * a 1:1 translation at that level. It's up to the caller not to try | |
285 | * to translate addresses that aren't supposed to be translated in | |
286 | * the first place. --BenH. | |
287 | */ | |
288 | ranges = (u32 *)get_property(parent, "ranges", &rlen); | |
289 | if (ranges == NULL || rlen == 0) { | |
cc9fd71c | 290 | offset = of_read_number(addr, na); |
d2dd482b BH |
291 | memset(addr, 0, pna * 4); |
292 | DBG("OF: no ranges, 1:1 translation\n"); | |
d1405b86 BH |
293 | goto finish; |
294 | } | |
295 | ||
296 | DBG("OF: walking ranges...\n"); | |
297 | ||
298 | /* Now walk through the ranges */ | |
299 | rlen /= 4; | |
300 | rone = na + pna + ns; | |
301 | for (; rlen >= rone; rlen -= rone, ranges += rone) { | |
302 | offset = bus->map(addr, ranges, na, ns, pna); | |
303 | if (offset != OF_BAD_ADDR) | |
304 | break; | |
305 | } | |
306 | if (offset == OF_BAD_ADDR) { | |
307 | DBG("OF: not found !\n"); | |
308 | return 1; | |
309 | } | |
310 | memcpy(addr, ranges + na, 4 * pna); | |
311 | ||
312 | finish: | |
313 | of_dump_addr("OF: parent translation for:", addr, pna); | |
bb6b9b28 | 314 | DBG("OF: with offset: "PRu64"\n", offset); |
d1405b86 BH |
315 | |
316 | /* Translate it into parent bus space */ | |
317 | return pbus->translate(addr, offset, pna); | |
318 | } | |
319 | ||
320 | ||
321 | /* | |
322 | * Translate an address from the device-tree into a CPU physical address, | |
323 | * this walks up the tree and applies the various bus mappings on the | |
324 | * way. | |
325 | * | |
326 | * Note: We consider that crossing any level with #size-cells == 0 to mean | |
327 | * that translation is impossible (that is we are not dealing with a value | |
328 | * that can be mapped to a cpu physical address). This is not really specified | |
329 | * that way, but this is traditionally the way IBM at least do things | |
330 | */ | |
331 | u64 of_translate_address(struct device_node *dev, u32 *in_addr) | |
332 | { | |
333 | struct device_node *parent = NULL; | |
334 | struct of_bus *bus, *pbus; | |
335 | u32 addr[OF_MAX_ADDR_CELLS]; | |
336 | int na, ns, pna, pns; | |
337 | u64 result = OF_BAD_ADDR; | |
338 | ||
339 | DBG("OF: ** translation for device %s **\n", dev->full_name); | |
340 | ||
341 | /* Increase refcount at current level */ | |
342 | of_node_get(dev); | |
343 | ||
344 | /* Get parent & match bus type */ | |
345 | parent = of_get_parent(dev); | |
346 | if (parent == NULL) | |
347 | goto bail; | |
348 | bus = of_match_bus(parent); | |
349 | ||
350 | /* Cound address cells & copy address locally */ | |
351 | bus->count_cells(dev, &na, &ns); | |
352 | if (!OF_CHECK_COUNTS(na, ns)) { | |
353 | printk(KERN_ERR "prom_parse: Bad cell count for %s\n", | |
354 | dev->full_name); | |
355 | goto bail; | |
356 | } | |
357 | memcpy(addr, in_addr, na * 4); | |
358 | ||
359 | DBG("OF: bus is %s (na=%d, ns=%d) on %s\n", | |
360 | bus->name, na, ns, parent->full_name); | |
361 | of_dump_addr("OF: translating address:", addr, na); | |
362 | ||
363 | /* Translate */ | |
364 | for (;;) { | |
365 | /* Switch to parent bus */ | |
366 | of_node_put(dev); | |
367 | dev = parent; | |
368 | parent = of_get_parent(dev); | |
369 | ||
370 | /* If root, we have finished */ | |
371 | if (parent == NULL) { | |
372 | DBG("OF: reached root node\n"); | |
cc9fd71c | 373 | result = of_read_number(addr, na); |
d1405b86 BH |
374 | break; |
375 | } | |
376 | ||
377 | /* Get new parent bus and counts */ | |
378 | pbus = of_match_bus(parent); | |
379 | pbus->count_cells(dev, &pna, &pns); | |
380 | if (!OF_CHECK_COUNTS(pna, pns)) { | |
381 | printk(KERN_ERR "prom_parse: Bad cell count for %s\n", | |
382 | dev->full_name); | |
383 | break; | |
384 | } | |
385 | ||
386 | DBG("OF: parent bus is %s (na=%d, ns=%d) on %s\n", | |
387 | pbus->name, pna, pns, parent->full_name); | |
388 | ||
389 | /* Apply bus translation */ | |
390 | if (of_translate_one(dev, bus, pbus, addr, na, ns, pna)) | |
391 | break; | |
392 | ||
393 | /* Complete the move up one level */ | |
394 | na = pna; | |
395 | ns = pns; | |
396 | bus = pbus; | |
397 | ||
398 | of_dump_addr("OF: one level translation:", addr, na); | |
399 | } | |
400 | bail: | |
401 | of_node_put(parent); | |
402 | of_node_put(dev); | |
403 | ||
404 | return result; | |
405 | } | |
406 | EXPORT_SYMBOL(of_translate_address); | |
407 | ||
d2dd482b BH |
408 | u32 *of_get_address(struct device_node *dev, int index, u64 *size, |
409 | unsigned int *flags) | |
d1405b86 BH |
410 | { |
411 | u32 *prop; | |
412 | unsigned int psize; | |
413 | struct device_node *parent; | |
414 | struct of_bus *bus; | |
415 | int onesize, i, na, ns; | |
416 | ||
417 | /* Get parent & match bus type */ | |
418 | parent = of_get_parent(dev); | |
419 | if (parent == NULL) | |
420 | return NULL; | |
421 | bus = of_match_bus(parent); | |
422 | bus->count_cells(dev, &na, &ns); | |
423 | of_node_put(parent); | |
424 | if (!OF_CHECK_COUNTS(na, ns)) | |
425 | return NULL; | |
426 | ||
427 | /* Get "reg" or "assigned-addresses" property */ | |
428 | prop = (u32 *)get_property(dev, bus->addresses, &psize); | |
429 | if (prop == NULL) | |
430 | return NULL; | |
431 | psize /= 4; | |
432 | ||
433 | onesize = na + ns; | |
434 | for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++) | |
435 | if (i == index) { | |
436 | if (size) | |
cc9fd71c | 437 | *size = of_read_number(prop + na, ns); |
d2dd482b BH |
438 | if (flags) |
439 | *flags = bus->get_flags(prop); | |
d1405b86 BH |
440 | return prop; |
441 | } | |
442 | return NULL; | |
443 | } | |
444 | EXPORT_SYMBOL(of_get_address); | |
445 | ||
d2dd482b BH |
446 | u32 *of_get_pci_address(struct device_node *dev, int bar_no, u64 *size, |
447 | unsigned int *flags) | |
d1405b86 | 448 | { |
d2dd482b BH |
449 | u32 *prop; |
450 | unsigned int psize; | |
451 | struct device_node *parent; | |
452 | struct of_bus *bus; | |
453 | int onesize, i, na, ns; | |
d1405b86 | 454 | |
d2dd482b BH |
455 | /* Get parent & match bus type */ |
456 | parent = of_get_parent(dev); | |
457 | if (parent == NULL) | |
458 | return NULL; | |
459 | bus = of_match_bus(parent); | |
d60dcd94 OH |
460 | if (strcmp(bus->name, "pci")) { |
461 | of_node_put(parent); | |
d2dd482b | 462 | return NULL; |
d60dcd94 | 463 | } |
d2dd482b BH |
464 | bus->count_cells(dev, &na, &ns); |
465 | of_node_put(parent); | |
466 | if (!OF_CHECK_COUNTS(na, ns)) | |
467 | return NULL; | |
468 | ||
469 | /* Get "reg" or "assigned-addresses" property */ | |
470 | prop = (u32 *)get_property(dev, bus->addresses, &psize); | |
471 | if (prop == NULL) | |
472 | return NULL; | |
473 | psize /= 4; | |
474 | ||
475 | onesize = na + ns; | |
476 | for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++) | |
477 | if ((prop[0] & 0xff) == ((bar_no * 4) + PCI_BASE_ADDRESS_0)) { | |
478 | if (size) | |
cc9fd71c | 479 | *size = of_read_number(prop + na, ns); |
d2dd482b BH |
480 | if (flags) |
481 | *flags = bus->get_flags(prop); | |
482 | return prop; | |
483 | } | |
d1405b86 BH |
484 | return NULL; |
485 | } | |
486 | EXPORT_SYMBOL(of_get_pci_address); | |
d2dd482b BH |
487 | |
488 | static int __of_address_to_resource(struct device_node *dev, u32 *addrp, | |
489 | u64 size, unsigned int flags, | |
490 | struct resource *r) | |
491 | { | |
492 | u64 taddr; | |
493 | ||
494 | if ((flags & (IORESOURCE_IO | IORESOURCE_MEM)) == 0) | |
495 | return -EINVAL; | |
496 | taddr = of_translate_address(dev, addrp); | |
497 | if (taddr == OF_BAD_ADDR) | |
498 | return -EINVAL; | |
499 | memset(r, 0, sizeof(struct resource)); | |
500 | if (flags & IORESOURCE_IO) { | |
f2c4583a | 501 | unsigned long port; |
d2dd482b | 502 | port = pci_address_to_pio(taddr); |
f2c4583a | 503 | if (port == (unsigned long)-1) |
d2dd482b BH |
504 | return -EINVAL; |
505 | r->start = port; | |
506 | r->end = port + size - 1; | |
507 | } else { | |
508 | r->start = taddr; | |
509 | r->end = taddr + size - 1; | |
510 | } | |
511 | r->flags = flags; | |
512 | r->name = dev->name; | |
513 | return 0; | |
514 | } | |
515 | ||
516 | int of_address_to_resource(struct device_node *dev, int index, | |
517 | struct resource *r) | |
518 | { | |
519 | u32 *addrp; | |
520 | u64 size; | |
521 | unsigned int flags; | |
522 | ||
523 | addrp = of_get_address(dev, index, &size, &flags); | |
524 | if (addrp == NULL) | |
525 | return -EINVAL; | |
526 | return __of_address_to_resource(dev, addrp, size, flags, r); | |
527 | } | |
528 | EXPORT_SYMBOL_GPL(of_address_to_resource); | |
529 | ||
530 | int of_pci_address_to_resource(struct device_node *dev, int bar, | |
531 | struct resource *r) | |
532 | { | |
533 | u32 *addrp; | |
534 | u64 size; | |
535 | unsigned int flags; | |
536 | ||
537 | addrp = of_get_pci_address(dev, bar, &size, &flags); | |
538 | if (addrp == NULL) | |
539 | return -EINVAL; | |
540 | return __of_address_to_resource(dev, addrp, size, flags, r); | |
541 | } | |
542 | EXPORT_SYMBOL_GPL(of_pci_address_to_resource); | |
d4ad66fa JK |
543 | |
544 | void of_parse_dma_window(struct device_node *dn, unsigned char *dma_window_prop, | |
545 | unsigned long *busno, unsigned long *phys, unsigned long *size) | |
546 | { | |
547 | u32 *dma_window, cells; | |
548 | unsigned char *prop; | |
549 | ||
550 | dma_window = (u32 *)dma_window_prop; | |
551 | ||
552 | /* busno is always one cell */ | |
553 | *busno = *(dma_window++); | |
554 | ||
555 | prop = get_property(dn, "ibm,#dma-address-cells", NULL); | |
03ac829b WS |
556 | if (!prop) |
557 | prop = get_property(dn, "#address-cells", NULL); | |
558 | ||
d4ad66fa | 559 | cells = prop ? *(u32 *)prop : prom_n_addr_cells(dn); |
cc9fd71c | 560 | *phys = of_read_number(dma_window, cells); |
d4ad66fa JK |
561 | |
562 | dma_window += cells; | |
563 | ||
564 | prop = get_property(dn, "ibm,#dma-size-cells", NULL); | |
565 | cells = prop ? *(u32 *)prop : prom_n_size_cells(dn); | |
cc9fd71c BH |
566 | *size = of_read_number(dma_window, cells); |
567 | } | |
568 | ||
569 | /* | |
570 | * Interrupt remapper | |
571 | */ | |
572 | ||
573 | static unsigned int of_irq_workarounds; | |
574 | static struct device_node *of_irq_dflt_pic; | |
575 | ||
576 | static struct device_node *of_irq_find_parent(struct device_node *child) | |
577 | { | |
578 | struct device_node *p; | |
579 | phandle *parp; | |
580 | ||
581 | if (!of_node_get(child)) | |
582 | return NULL; | |
583 | ||
584 | do { | |
585 | parp = (phandle *)get_property(child, "interrupt-parent", NULL); | |
586 | if (parp == NULL) | |
587 | p = of_get_parent(child); | |
588 | else { | |
589 | if (of_irq_workarounds & OF_IMAP_NO_PHANDLE) | |
590 | p = of_node_get(of_irq_dflt_pic); | |
591 | else | |
592 | p = of_find_node_by_phandle(*parp); | |
593 | } | |
594 | of_node_put(child); | |
595 | child = p; | |
596 | } while (p && get_property(p, "#interrupt-cells", NULL) == NULL); | |
597 | ||
598 | return p; | |
599 | } | |
600 | ||
601 | static u8 of_irq_pci_swizzle(u8 slot, u8 pin) | |
602 | { | |
603 | return (((pin - 1) + slot) % 4) + 1; | |
d4ad66fa | 604 | } |
cc9fd71c BH |
605 | |
606 | /* This doesn't need to be called if you don't have any special workaround | |
607 | * flags to pass | |
608 | */ | |
609 | void of_irq_map_init(unsigned int flags) | |
610 | { | |
611 | of_irq_workarounds = flags; | |
612 | ||
613 | /* OldWorld, don't bother looking at other things */ | |
614 | if (flags & OF_IMAP_OLDWORLD_MAC) | |
615 | return; | |
616 | ||
617 | /* If we don't have phandles, let's try to locate a default interrupt | |
618 | * controller (happens when booting with BootX). We do a first match | |
619 | * here, hopefully, that only ever happens on machines with one | |
620 | * controller. | |
621 | */ | |
622 | if (flags & OF_IMAP_NO_PHANDLE) { | |
623 | struct device_node *np; | |
624 | ||
625 | for(np = NULL; (np = of_find_all_nodes(np)) != NULL;) { | |
626 | if (get_property(np, "interrupt-controller", NULL) | |
627 | == NULL) | |
628 | continue; | |
629 | /* Skip /chosen/interrupt-controller */ | |
630 | if (strcmp(np->name, "chosen") == 0) | |
631 | continue; | |
632 | /* It seems like at least one person on this planet wants | |
633 | * to use BootX on a machine with an AppleKiwi controller | |
634 | * which happens to pretend to be an interrupt | |
635 | * controller too. | |
636 | */ | |
637 | if (strcmp(np->name, "AppleKiwi") == 0) | |
638 | continue; | |
639 | /* I think we found one ! */ | |
640 | of_irq_dflt_pic = np; | |
641 | break; | |
642 | } | |
643 | } | |
644 | ||
645 | } | |
646 | ||
647 | int of_irq_map_raw(struct device_node *parent, u32 *intspec, u32 *addr, | |
648 | struct of_irq *out_irq) | |
649 | { | |
650 | struct device_node *ipar, *tnode, *old = NULL, *newpar = NULL; | |
651 | u32 *tmp, *imap, *imask; | |
652 | u32 intsize = 1, addrsize, newintsize = 0, newaddrsize = 0; | |
653 | int imaplen, match, i; | |
654 | ||
655 | ipar = of_node_get(parent); | |
656 | ||
657 | /* First get the #interrupt-cells property of the current cursor | |
658 | * that tells us how to interpret the passed-in intspec. If there | |
659 | * is none, we are nice and just walk up the tree | |
660 | */ | |
661 | do { | |
662 | tmp = (u32 *)get_property(ipar, "#interrupt-cells", NULL); | |
663 | if (tmp != NULL) { | |
664 | intsize = *tmp; | |
665 | break; | |
666 | } | |
667 | tnode = ipar; | |
668 | ipar = of_irq_find_parent(ipar); | |
669 | of_node_put(tnode); | |
670 | } while (ipar); | |
671 | if (ipar == NULL) { | |
672 | DBG(" -> no parent found !\n"); | |
673 | goto fail; | |
674 | } | |
675 | ||
676 | DBG("of_irq_map_raw: ipar=%s, size=%d\n", ipar->full_name, intsize); | |
677 | ||
678 | /* Look for this #address-cells. We have to implement the old linux | |
679 | * trick of looking for the parent here as some device-trees rely on it | |
680 | */ | |
681 | old = of_node_get(ipar); | |
682 | do { | |
683 | tmp = (u32 *)get_property(old, "#address-cells", NULL); | |
684 | tnode = of_get_parent(old); | |
685 | of_node_put(old); | |
686 | old = tnode; | |
687 | } while(old && tmp == NULL); | |
688 | of_node_put(old); | |
689 | old = NULL; | |
690 | addrsize = (tmp == NULL) ? 2 : *tmp; | |
691 | ||
692 | DBG(" -> addrsize=%d\n", addrsize); | |
693 | ||
694 | /* Now start the actual "proper" walk of the interrupt tree */ | |
695 | while (ipar != NULL) { | |
696 | /* Now check if cursor is an interrupt-controller and if it is | |
697 | * then we are done | |
698 | */ | |
699 | if (get_property(ipar, "interrupt-controller", NULL) != NULL) { | |
700 | DBG(" -> got it !\n"); | |
701 | memcpy(out_irq->specifier, intspec, | |
702 | intsize * sizeof(u32)); | |
703 | out_irq->size = intsize; | |
704 | out_irq->controller = ipar; | |
705 | of_node_put(old); | |
706 | return 0; | |
707 | } | |
708 | ||
709 | /* Now look for an interrupt-map */ | |
710 | imap = (u32 *)get_property(ipar, "interrupt-map", &imaplen); | |
711 | /* No interrupt map, check for an interrupt parent */ | |
712 | if (imap == NULL) { | |
713 | DBG(" -> no map, getting parent\n"); | |
714 | newpar = of_irq_find_parent(ipar); | |
715 | goto skiplevel; | |
716 | } | |
717 | imaplen /= sizeof(u32); | |
718 | ||
719 | /* Look for a mask */ | |
720 | imask = (u32 *)get_property(ipar, "interrupt-map-mask", NULL); | |
721 | ||
722 | /* If we were passed no "reg" property and we attempt to parse | |
723 | * an interrupt-map, then #address-cells must be 0. | |
724 | * Fail if it's not. | |
725 | */ | |
726 | if (addr == NULL && addrsize != 0) { | |
727 | DBG(" -> no reg passed in when needed !\n"); | |
728 | goto fail; | |
729 | } | |
730 | ||
731 | /* Parse interrupt-map */ | |
732 | match = 0; | |
733 | while (imaplen > (addrsize + intsize + 1) && !match) { | |
734 | /* Compare specifiers */ | |
735 | match = 1; | |
736 | for (i = 0; i < addrsize && match; ++i) { | |
737 | u32 mask = imask ? imask[i] : 0xffffffffu; | |
738 | match = ((addr[i] ^ imap[i]) & mask) == 0; | |
739 | } | |
740 | for (; i < (addrsize + intsize) && match; ++i) { | |
741 | u32 mask = imask ? imask[i] : 0xffffffffu; | |
742 | match = | |
743 | ((intspec[i-addrsize] ^ imap[i]) & mask) == 0; | |
744 | } | |
745 | imap += addrsize + intsize; | |
746 | imaplen -= addrsize + intsize; | |
747 | ||
748 | DBG(" -> match=%d (imaplen=%d)\n", match, imaplen); | |
749 | ||
750 | /* Get the interrupt parent */ | |
751 | if (of_irq_workarounds & OF_IMAP_NO_PHANDLE) | |
752 | newpar = of_node_get(of_irq_dflt_pic); | |
753 | else | |
754 | newpar = of_find_node_by_phandle((phandle)*imap); | |
755 | imap++; | |
756 | --imaplen; | |
757 | ||
758 | /* Check if not found */ | |
759 | if (newpar == NULL) { | |
760 | DBG(" -> imap parent not found !\n"); | |
761 | goto fail; | |
762 | } | |
763 | ||
764 | /* Get #interrupt-cells and #address-cells of new | |
765 | * parent | |
766 | */ | |
767 | tmp = (u32 *)get_property(newpar, "#interrupt-cells", | |
768 | NULL); | |
769 | if (tmp == NULL) { | |
770 | DBG(" -> parent lacks #interrupt-cells !\n"); | |
771 | goto fail; | |
772 | } | |
773 | newintsize = *tmp; | |
774 | tmp = (u32 *)get_property(newpar, "#address-cells", | |
775 | NULL); | |
776 | newaddrsize = (tmp == NULL) ? 0 : *tmp; | |
777 | ||
778 | DBG(" -> newintsize=%d, newaddrsize=%d\n", | |
779 | newintsize, newaddrsize); | |
780 | ||
781 | /* Check for malformed properties */ | |
782 | if (imaplen < (newaddrsize + newintsize)) | |
783 | goto fail; | |
784 | ||
785 | imap += newaddrsize + newintsize; | |
786 | imaplen -= newaddrsize + newintsize; | |
787 | ||
788 | DBG(" -> imaplen=%d\n", imaplen); | |
789 | } | |
790 | if (!match) | |
791 | goto fail; | |
792 | ||
793 | of_node_put(old); | |
794 | old = of_node_get(newpar); | |
795 | addrsize = newaddrsize; | |
796 | intsize = newintsize; | |
797 | intspec = imap - intsize; | |
798 | addr = intspec - addrsize; | |
799 | ||
800 | skiplevel: | |
801 | /* Iterate again with new parent */ | |
802 | DBG(" -> new parent: %s\n", newpar ? newpar->full_name : "<>"); | |
803 | of_node_put(ipar); | |
804 | ipar = newpar; | |
805 | newpar = NULL; | |
806 | } | |
807 | fail: | |
808 | of_node_put(ipar); | |
809 | of_node_put(old); | |
810 | of_node_put(newpar); | |
811 | ||
812 | return -EINVAL; | |
813 | } | |
814 | EXPORT_SYMBOL_GPL(of_irq_map_raw); | |
815 | ||
816 | #if defined(CONFIG_PPC_PMAC) && defined(CONFIG_PPC32) | |
817 | static int of_irq_map_oldworld(struct device_node *device, int index, | |
818 | struct of_irq *out_irq) | |
819 | { | |
820 | u32 *ints; | |
821 | int intlen; | |
822 | ||
823 | /* | |
824 | * Old machines just have a list of interrupt numbers | |
825 | * and no interrupt-controller nodes. | |
826 | */ | |
827 | ints = (u32 *) get_property(device, "AAPL,interrupts", &intlen); | |
828 | if (ints == NULL) | |
829 | return -EINVAL; | |
830 | intlen /= sizeof(u32); | |
831 | ||
832 | if (index >= intlen) | |
833 | return -EINVAL; | |
834 | ||
835 | out_irq->controller = NULL; | |
836 | out_irq->specifier[0] = ints[index]; | |
837 | out_irq->size = 1; | |
838 | ||
839 | return 0; | |
840 | } | |
841 | #else /* defined(CONFIG_PPC_PMAC) && defined(CONFIG_PPC32) */ | |
842 | static int of_irq_map_oldworld(struct device_node *device, int index, | |
843 | struct of_irq *out_irq) | |
844 | { | |
845 | return -EINVAL; | |
846 | } | |
847 | #endif /* !(defined(CONFIG_PPC_PMAC) && defined(CONFIG_PPC32)) */ | |
848 | ||
849 | int of_irq_map_one(struct device_node *device, int index, struct of_irq *out_irq) | |
850 | { | |
851 | struct device_node *p; | |
852 | u32 *intspec, *tmp, intsize, intlen, *addr; | |
853 | int res; | |
854 | ||
855 | DBG("of_irq_map_one: dev=%s, index=%d\n", device->full_name, index); | |
856 | ||
857 | /* OldWorld mac stuff is "special", handle out of line */ | |
858 | if (of_irq_workarounds & OF_IMAP_OLDWORLD_MAC) | |
859 | return of_irq_map_oldworld(device, index, out_irq); | |
860 | ||
861 | /* Get the interrupts property */ | |
862 | intspec = (u32 *)get_property(device, "interrupts", &intlen); | |
863 | if (intspec == NULL) | |
864 | return -EINVAL; | |
865 | intlen /= sizeof(u32); | |
866 | ||
867 | /* Get the reg property (if any) */ | |
868 | addr = (u32 *)get_property(device, "reg", NULL); | |
869 | ||
870 | /* Look for the interrupt parent. */ | |
871 | p = of_irq_find_parent(device); | |
872 | if (p == NULL) | |
873 | return -EINVAL; | |
874 | ||
875 | /* Get size of interrupt specifier */ | |
876 | tmp = (u32 *)get_property(p, "#interrupt-cells", NULL); | |
877 | if (tmp == NULL) { | |
878 | of_node_put(p); | |
879 | return -EINVAL; | |
880 | } | |
881 | intsize = *tmp; | |
882 | ||
883 | /* Check index */ | |
884 | if (index * intsize >= intlen) | |
885 | return -EINVAL; | |
886 | ||
887 | /* Get new specifier and map it */ | |
888 | res = of_irq_map_raw(p, intspec + index * intsize, addr, out_irq); | |
889 | of_node_put(p); | |
890 | return res; | |
891 | } | |
892 | EXPORT_SYMBOL_GPL(of_irq_map_one); | |
893 | ||
894 | int of_irq_map_pci(struct pci_dev *pdev, struct of_irq *out_irq) | |
895 | { | |
896 | struct device_node *dn, *ppnode; | |
897 | struct pci_dev *ppdev; | |
898 | u32 lspec; | |
899 | u32 laddr[3]; | |
900 | u8 pin; | |
901 | int rc; | |
902 | ||
903 | /* Check if we have a device node, if yes, fallback to standard OF | |
904 | * parsing | |
905 | */ | |
906 | dn = pci_device_to_OF_node(pdev); | |
907 | if (dn) | |
908 | return of_irq_map_one(dn, 0, out_irq); | |
909 | ||
910 | /* Ok, we don't, time to have fun. Let's start by building up an | |
911 | * interrupt spec. we assume #interrupt-cells is 1, which is standard | |
912 | * for PCI. If you do different, then don't use that routine. | |
913 | */ | |
914 | rc = pci_read_config_byte(pdev, PCI_INTERRUPT_PIN, &pin); | |
915 | if (rc != 0) | |
916 | return rc; | |
917 | /* No pin, exit */ | |
918 | if (pin == 0) | |
919 | return -ENODEV; | |
920 | ||
921 | /* Now we walk up the PCI tree */ | |
922 | lspec = pin; | |
923 | for (;;) { | |
924 | /* Get the pci_dev of our parent */ | |
925 | ppdev = pdev->bus->self; | |
926 | ||
927 | /* Ouch, it's a host bridge... */ | |
928 | if (ppdev == NULL) { | |
929 | #ifdef CONFIG_PPC64 | |
930 | ppnode = pci_bus_to_OF_node(pdev->bus); | |
931 | #else | |
932 | struct pci_controller *host; | |
933 | host = pci_bus_to_host(pdev->bus); | |
934 | ppnode = host ? host->arch_data : NULL; | |
935 | #endif | |
936 | /* No node for host bridge ? give up */ | |
937 | if (ppnode == NULL) | |
938 | return -EINVAL; | |
939 | } else | |
940 | /* We found a P2P bridge, check if it has a node */ | |
941 | ppnode = pci_device_to_OF_node(ppdev); | |
942 | ||
943 | /* Ok, we have found a parent with a device-node, hand over to | |
944 | * the OF parsing code. | |
945 | * We build a unit address from the linux device to be used for | |
946 | * resolution. Note that we use the linux bus number which may | |
947 | * not match your firmware bus numbering. | |
948 | * Fortunately, in most cases, interrupt-map-mask doesn't include | |
949 | * the bus number as part of the matching. | |
950 | * You should still be careful about that though if you intend | |
951 | * to rely on this function (you ship a firmware that doesn't | |
952 | * create device nodes for all PCI devices). | |
953 | */ | |
954 | if (ppnode) | |
955 | break; | |
956 | ||
957 | /* We can only get here if we hit a P2P bridge with no node, | |
958 | * let's do standard swizzling and try again | |
959 | */ | |
960 | lspec = of_irq_pci_swizzle(PCI_SLOT(pdev->devfn), lspec); | |
961 | pdev = ppdev; | |
962 | } | |
963 | ||
964 | laddr[0] = (pdev->bus->number << 16) | |
965 | | (pdev->devfn << 8); | |
966 | laddr[1] = laddr[2] = 0; | |
967 | return of_irq_map_raw(ppnode, &lspec, laddr, out_irq); | |
968 | } | |
969 | EXPORT_SYMBOL_GPL(of_irq_map_pci); | |
970 |