diff options
author | Grant Likely <grant.likely@secretlab.ca> | 2010-06-08 09:48:10 -0400 |
---|---|---|
committer | Grant Likely <grant.likely@secretlab.ca> | 2010-07-05 18:14:26 -0400 |
commit | dbbdee94734bf6f1db7af42008a53655e77cab8f (patch) | |
tree | c0f571b0ab57a6483bc07e21e3b888e253d699ea /arch/powerpc/kernel/prom_parse.c | |
parent | 1f5bef30cf6c66f097ea5dfc580a41924df888d1 (diff) |
of/address: Merge all of the bus translation code
Microblaze and PowerPC share a large chunk of code for translating
OF device tree data into usable addresses. Differences between the two
consist of cosmetic differences, and the addition of dma-ranges support
code to powerpc but not microblaze. This patch moves the powerpc
version into common code and applies many of the cosmetic (non-functional)
changes from the microblaze version.
Signed-off-by: Grant Likely <grant.likely@secretlab.ca>
Acked-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
CC: Michal Simek <monstr@monstr.eu>
CC: Wolfram Sang <w.sang@pengutronix.de>
CC: Stephen Rothwell <sfr@canb.auug.org.au>
Diffstat (limited to 'arch/powerpc/kernel/prom_parse.c')
-rw-r--r-- | arch/powerpc/kernel/prom_parse.c | 515 |
1 files changed, 0 insertions, 515 deletions
diff --git a/arch/powerpc/kernel/prom_parse.c b/arch/powerpc/kernel/prom_parse.c index 1dac535de78f..88334af038e5 100644 --- a/arch/powerpc/kernel/prom_parse.c +++ b/arch/powerpc/kernel/prom_parse.c | |||
@@ -10,225 +10,7 @@ | |||
10 | #include <asm/prom.h> | 10 | #include <asm/prom.h> |
11 | #include <asm/pci-bridge.h> | 11 | #include <asm/pci-bridge.h> |
12 | 12 | ||
13 | #ifdef DEBUG | ||
14 | #define DBG(fmt...) do { printk(fmt); } while(0) | ||
15 | #else | ||
16 | #define DBG(fmt...) do { } while(0) | ||
17 | #endif | ||
18 | |||
19 | #ifdef CONFIG_PPC64 | ||
20 | #define PRu64 "%lx" | ||
21 | #else | ||
22 | #define PRu64 "%llx" | ||
23 | #endif | ||
24 | |||
25 | /* Max address size we deal with */ | ||
26 | #define OF_MAX_ADDR_CELLS 4 | ||
27 | #define OF_CHECK_COUNTS(na, ns) ((na) > 0 && (na) <= OF_MAX_ADDR_CELLS && \ | ||
28 | (ns) > 0) | ||
29 | |||
30 | static struct of_bus *of_match_bus(struct device_node *np); | ||
31 | |||
32 | /* Debug utility */ | ||
33 | #ifdef DEBUG | ||
34 | static void of_dump_addr(const char *s, const u32 *addr, int na) | ||
35 | { | ||
36 | printk("%s", s); | ||
37 | while(na--) | ||
38 | printk(" %08x", *(addr++)); | ||
39 | printk("\n"); | ||
40 | } | ||
41 | #else | ||
42 | static void of_dump_addr(const char *s, const u32 *addr, int na) { } | ||
43 | #endif | ||
44 | |||
45 | |||
46 | /* Callbacks for bus specific translators */ | ||
47 | struct of_bus { | ||
48 | const char *name; | ||
49 | const char *addresses; | ||
50 | int (*match)(struct device_node *parent); | ||
51 | void (*count_cells)(struct device_node *child, | ||
52 | int *addrc, int *sizec); | ||
53 | u64 (*map)(u32 *addr, const u32 *range, | ||
54 | int na, int ns, int pna); | ||
55 | int (*translate)(u32 *addr, u64 offset, int na); | ||
56 | unsigned int (*get_flags)(const u32 *addr); | ||
57 | }; | ||
58 | |||
59 | |||
60 | /* | ||
61 | * Default translator (generic bus) | ||
62 | */ | ||
63 | |||
64 | static void of_bus_default_count_cells(struct device_node *dev, | ||
65 | int *addrc, int *sizec) | ||
66 | { | ||
67 | if (addrc) | ||
68 | *addrc = of_n_addr_cells(dev); | ||
69 | if (sizec) | ||
70 | *sizec = of_n_size_cells(dev); | ||
71 | } | ||
72 | |||
73 | static u64 of_bus_default_map(u32 *addr, const u32 *range, | ||
74 | int na, int ns, int pna) | ||
75 | { | ||
76 | u64 cp, s, da; | ||
77 | |||
78 | cp = of_read_number(range, na); | ||
79 | s = of_read_number(range + na + pna, ns); | ||
80 | da = of_read_number(addr, na); | ||
81 | |||
82 | DBG("OF: default map, cp="PRu64", s="PRu64", da="PRu64"\n", | ||
83 | cp, s, da); | ||
84 | |||
85 | if (da < cp || da >= (cp + s)) | ||
86 | return OF_BAD_ADDR; | ||
87 | return da - cp; | ||
88 | } | ||
89 | |||
90 | static int of_bus_default_translate(u32 *addr, u64 offset, int na) | ||
91 | { | ||
92 | u64 a = of_read_number(addr, na); | ||
93 | memset(addr, 0, na * 4); | ||
94 | a += offset; | ||
95 | if (na > 1) | ||
96 | addr[na - 2] = a >> 32; | ||
97 | addr[na - 1] = a & 0xffffffffu; | ||
98 | |||
99 | return 0; | ||
100 | } | ||
101 | |||
102 | static unsigned int of_bus_default_get_flags(const u32 *addr) | ||
103 | { | ||
104 | return IORESOURCE_MEM; | ||
105 | } | ||
106 | |||
107 | |||
108 | #ifdef CONFIG_PCI | 13 | #ifdef CONFIG_PCI |
109 | /* | ||
110 | * PCI bus specific translator | ||
111 | */ | ||
112 | |||
113 | static int of_bus_pci_match(struct device_node *np) | ||
114 | { | ||
115 | /* "vci" is for the /chaos bridge on 1st-gen PCI powermacs */ | ||
116 | return !strcmp(np->type, "pci") || !strcmp(np->type, "vci"); | ||
117 | } | ||
118 | |||
119 | static void of_bus_pci_count_cells(struct device_node *np, | ||
120 | int *addrc, int *sizec) | ||
121 | { | ||
122 | if (addrc) | ||
123 | *addrc = 3; | ||
124 | if (sizec) | ||
125 | *sizec = 2; | ||
126 | } | ||
127 | |||
128 | static unsigned int of_bus_pci_get_flags(const u32 *addr) | ||
129 | { | ||
130 | unsigned int flags = 0; | ||
131 | u32 w = addr[0]; | ||
132 | |||
133 | switch((w >> 24) & 0x03) { | ||
134 | case 0x01: | ||
135 | flags |= IORESOURCE_IO; | ||
136 | break; | ||
137 | case 0x02: /* 32 bits */ | ||
138 | case 0x03: /* 64 bits */ | ||
139 | flags |= IORESOURCE_MEM; | ||
140 | break; | ||
141 | } | ||
142 | if (w & 0x40000000) | ||
143 | flags |= IORESOURCE_PREFETCH; | ||
144 | return flags; | ||
145 | } | ||
146 | |||
147 | static u64 of_bus_pci_map(u32 *addr, const u32 *range, int na, int ns, int pna) | ||
148 | { | ||
149 | u64 cp, s, da; | ||
150 | unsigned int af, rf; | ||
151 | |||
152 | af = of_bus_pci_get_flags(addr); | ||
153 | rf = of_bus_pci_get_flags(range); | ||
154 | |||
155 | /* Check address type match */ | ||
156 | if ((af ^ rf) & (IORESOURCE_MEM | IORESOURCE_IO)) | ||
157 | return OF_BAD_ADDR; | ||
158 | |||
159 | /* Read address values, skipping high cell */ | ||
160 | cp = of_read_number(range + 1, na - 1); | ||
161 | s = of_read_number(range + na + pna, ns); | ||
162 | da = of_read_number(addr + 1, na - 1); | ||
163 | |||
164 | DBG("OF: PCI map, cp="PRu64", s="PRu64", da="PRu64"\n", cp, s, da); | ||
165 | |||
166 | if (da < cp || da >= (cp + s)) | ||
167 | return OF_BAD_ADDR; | ||
168 | return da - cp; | ||
169 | } | ||
170 | |||
171 | static int of_bus_pci_translate(u32 *addr, u64 offset, int na) | ||
172 | { | ||
173 | return of_bus_default_translate(addr + 1, offset, na - 1); | ||
174 | } | ||
175 | |||
176 | const u32 *of_get_pci_address(struct device_node *dev, int bar_no, u64 *size, | ||
177 | unsigned int *flags) | ||
178 | { | ||
179 | const u32 *prop; | ||
180 | unsigned int psize; | ||
181 | struct device_node *parent; | ||
182 | struct of_bus *bus; | ||
183 | int onesize, i, na, ns; | ||
184 | |||
185 | /* Get parent & match bus type */ | ||
186 | parent = of_get_parent(dev); | ||
187 | if (parent == NULL) | ||
188 | return NULL; | ||
189 | bus = of_match_bus(parent); | ||
190 | if (strcmp(bus->name, "pci")) { | ||
191 | of_node_put(parent); | ||
192 | return NULL; | ||
193 | } | ||
194 | bus->count_cells(dev, &na, &ns); | ||
195 | of_node_put(parent); | ||
196 | if (!OF_CHECK_COUNTS(na, ns)) | ||
197 | return NULL; | ||
198 | |||
199 | /* Get "reg" or "assigned-addresses" property */ | ||
200 | prop = of_get_property(dev, bus->addresses, &psize); | ||
201 | if (prop == NULL) | ||
202 | return NULL; | ||
203 | psize /= 4; | ||
204 | |||
205 | onesize = na + ns; | ||
206 | for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++) | ||
207 | if ((prop[0] & 0xff) == ((bar_no * 4) + PCI_BASE_ADDRESS_0)) { | ||
208 | if (size) | ||
209 | *size = of_read_number(prop + na, ns); | ||
210 | if (flags) | ||
211 | *flags = bus->get_flags(prop); | ||
212 | return prop; | ||
213 | } | ||
214 | return NULL; | ||
215 | } | ||
216 | EXPORT_SYMBOL(of_get_pci_address); | ||
217 | |||
218 | int of_pci_address_to_resource(struct device_node *dev, int bar, | ||
219 | struct resource *r) | ||
220 | { | ||
221 | const u32 *addrp; | ||
222 | u64 size; | ||
223 | unsigned int flags; | ||
224 | |||
225 | addrp = of_get_pci_address(dev, bar, &size, &flags); | ||
226 | if (addrp == NULL) | ||
227 | return -EINVAL; | ||
228 | return __of_address_to_resource(dev, addrp, size, flags, r); | ||
229 | } | ||
230 | EXPORT_SYMBOL_GPL(of_pci_address_to_resource); | ||
231 | |||
232 | int of_irq_map_pci(struct pci_dev *pdev, struct of_irq *out_irq) | 14 | int of_irq_map_pci(struct pci_dev *pdev, struct of_irq *out_irq) |
233 | { | 15 | { |
234 | struct device_node *dn, *ppnode; | 16 | struct device_node *dn, *ppnode; |
@@ -310,303 +92,6 @@ int of_irq_map_pci(struct pci_dev *pdev, struct of_irq *out_irq) | |||
310 | EXPORT_SYMBOL_GPL(of_irq_map_pci); | 92 | EXPORT_SYMBOL_GPL(of_irq_map_pci); |
311 | #endif /* CONFIG_PCI */ | 93 | #endif /* CONFIG_PCI */ |
312 | 94 | ||
313 | /* | ||
314 | * ISA bus specific translator | ||
315 | */ | ||
316 | |||
317 | static int of_bus_isa_match(struct device_node *np) | ||
318 | { | ||
319 | return !strcmp(np->name, "isa"); | ||
320 | } | ||
321 | |||
322 | static void of_bus_isa_count_cells(struct device_node *child, | ||
323 | int *addrc, int *sizec) | ||
324 | { | ||
325 | if (addrc) | ||
326 | *addrc = 2; | ||
327 | if (sizec) | ||
328 | *sizec = 1; | ||
329 | } | ||
330 | |||
331 | static u64 of_bus_isa_map(u32 *addr, const u32 *range, int na, int ns, int pna) | ||
332 | { | ||
333 | u64 cp, s, da; | ||
334 | |||
335 | /* Check address type match */ | ||
336 | if ((addr[0] ^ range[0]) & 0x00000001) | ||
337 | return OF_BAD_ADDR; | ||
338 | |||
339 | /* Read address values, skipping high cell */ | ||
340 | cp = of_read_number(range + 1, na - 1); | ||
341 | s = of_read_number(range + na + pna, ns); | ||
342 | da = of_read_number(addr + 1, na - 1); | ||
343 | |||
344 | DBG("OF: ISA map, cp="PRu64", s="PRu64", da="PRu64"\n", cp, s, da); | ||
345 | |||
346 | if (da < cp || da >= (cp + s)) | ||
347 | return OF_BAD_ADDR; | ||
348 | return da - cp; | ||
349 | } | ||
350 | |||
351 | static int of_bus_isa_translate(u32 *addr, u64 offset, int na) | ||
352 | { | ||
353 | return of_bus_default_translate(addr + 1, offset, na - 1); | ||
354 | } | ||
355 | |||
356 | static unsigned int of_bus_isa_get_flags(const u32 *addr) | ||
357 | { | ||
358 | unsigned int flags = 0; | ||
359 | u32 w = addr[0]; | ||
360 | |||
361 | if (w & 1) | ||
362 | flags |= IORESOURCE_IO; | ||
363 | else | ||
364 | flags |= IORESOURCE_MEM; | ||
365 | return flags; | ||
366 | } | ||
367 | |||
368 | |||
369 | /* | ||
370 | * Array of bus specific translators | ||
371 | */ | ||
372 | |||
373 | static struct of_bus of_busses[] = { | ||
374 | #ifdef CONFIG_PCI | ||
375 | /* PCI */ | ||
376 | { | ||
377 | .name = "pci", | ||
378 | .addresses = "assigned-addresses", | ||
379 | .match = of_bus_pci_match, | ||
380 | .count_cells = of_bus_pci_count_cells, | ||
381 | .map = of_bus_pci_map, | ||
382 | .translate = of_bus_pci_translate, | ||
383 | .get_flags = of_bus_pci_get_flags, | ||
384 | }, | ||
385 | #endif /* CONFIG_PCI */ | ||
386 | /* ISA */ | ||
387 | { | ||
388 | .name = "isa", | ||
389 | .addresses = "reg", | ||
390 | .match = of_bus_isa_match, | ||
391 | .count_cells = of_bus_isa_count_cells, | ||
392 | .map = of_bus_isa_map, | ||
393 | .translate = of_bus_isa_translate, | ||
394 | .get_flags = of_bus_isa_get_flags, | ||
395 | }, | ||
396 | /* Default */ | ||
397 | { | ||
398 | .name = "default", | ||
399 | .addresses = "reg", | ||
400 | .match = NULL, | ||
401 | .count_cells = of_bus_default_count_cells, | ||
402 | .map = of_bus_default_map, | ||
403 | .translate = of_bus_default_translate, | ||
404 | .get_flags = of_bus_default_get_flags, | ||
405 | }, | ||
406 | }; | ||
407 | |||
408 | static struct of_bus *of_match_bus(struct device_node *np) | ||
409 | { | ||
410 | int i; | ||
411 | |||
412 | for (i = 0; i < ARRAY_SIZE(of_busses); i ++) | ||
413 | if (!of_busses[i].match || of_busses[i].match(np)) | ||
414 | return &of_busses[i]; | ||
415 | BUG(); | ||
416 | return NULL; | ||
417 | } | ||
418 | |||
419 | static int of_translate_one(struct device_node *parent, struct of_bus *bus, | ||
420 | struct of_bus *pbus, u32 *addr, | ||
421 | int na, int ns, int pna, const char *rprop) | ||
422 | { | ||
423 | const u32 *ranges; | ||
424 | unsigned int rlen; | ||
425 | int rone; | ||
426 | u64 offset = OF_BAD_ADDR; | ||
427 | |||
428 | /* Normally, an absence of a "ranges" property means we are | ||
429 | * crossing a non-translatable boundary, and thus the addresses | ||
430 | * below the current not cannot be converted to CPU physical ones. | ||
431 | * Unfortunately, while this is very clear in the spec, it's not | ||
432 | * what Apple understood, and they do have things like /uni-n or | ||
433 | * /ht nodes with no "ranges" property and a lot of perfectly | ||
434 | * useable mapped devices below them. Thus we treat the absence of | ||
435 | * "ranges" as equivalent to an empty "ranges" property which means | ||
436 | * a 1:1 translation at that level. It's up to the caller not to try | ||
437 | * to translate addresses that aren't supposed to be translated in | ||
438 | * the first place. --BenH. | ||
439 | */ | ||
440 | ranges = of_get_property(parent, rprop, &rlen); | ||
441 | if (ranges == NULL || rlen == 0) { | ||
442 | offset = of_read_number(addr, na); | ||
443 | memset(addr, 0, pna * 4); | ||
444 | DBG("OF: no ranges, 1:1 translation\n"); | ||
445 | goto finish; | ||
446 | } | ||
447 | |||
448 | DBG("OF: walking ranges...\n"); | ||
449 | |||
450 | /* Now walk through the ranges */ | ||
451 | rlen /= 4; | ||
452 | rone = na + pna + ns; | ||
453 | for (; rlen >= rone; rlen -= rone, ranges += rone) { | ||
454 | offset = bus->map(addr, ranges, na, ns, pna); | ||
455 | if (offset != OF_BAD_ADDR) | ||
456 | break; | ||
457 | } | ||
458 | if (offset == OF_BAD_ADDR) { | ||
459 | DBG("OF: not found !\n"); | ||
460 | return 1; | ||
461 | } | ||
462 | memcpy(addr, ranges + na, 4 * pna); | ||
463 | |||
464 | finish: | ||
465 | of_dump_addr("OF: parent translation for:", addr, pna); | ||
466 | DBG("OF: with offset: "PRu64"\n", offset); | ||
467 | |||
468 | /* Translate it into parent bus space */ | ||
469 | return pbus->translate(addr, offset, pna); | ||
470 | } | ||
471 | |||
472 | |||
473 | /* | ||
474 | * Translate an address from the device-tree into a CPU physical address, | ||
475 | * this walks up the tree and applies the various bus mappings on the | ||
476 | * way. | ||
477 | * | ||
478 | * Note: We consider that crossing any level with #size-cells == 0 to mean | ||
479 | * that translation is impossible (that is we are not dealing with a value | ||
480 | * that can be mapped to a cpu physical address). This is not really specified | ||
481 | * that way, but this is traditionally the way IBM at least do things | ||
482 | */ | ||
483 | u64 __of_translate_address(struct device_node *dev, const u32 *in_addr, | ||
484 | const char *rprop) | ||
485 | { | ||
486 | struct device_node *parent = NULL; | ||
487 | struct of_bus *bus, *pbus; | ||
488 | u32 addr[OF_MAX_ADDR_CELLS]; | ||
489 | int na, ns, pna, pns; | ||
490 | u64 result = OF_BAD_ADDR; | ||
491 | |||
492 | DBG("OF: ** translation for device %s **\n", dev->full_name); | ||
493 | |||
494 | /* Increase refcount at current level */ | ||
495 | of_node_get(dev); | ||
496 | |||
497 | /* Get parent & match bus type */ | ||
498 | parent = of_get_parent(dev); | ||
499 | if (parent == NULL) | ||
500 | goto bail; | ||
501 | bus = of_match_bus(parent); | ||
502 | |||
503 | /* Cound address cells & copy address locally */ | ||
504 | bus->count_cells(dev, &na, &ns); | ||
505 | if (!OF_CHECK_COUNTS(na, ns)) { | ||
506 | printk(KERN_ERR "prom_parse: Bad cell count for %s\n", | ||
507 | dev->full_name); | ||
508 | goto bail; | ||
509 | } | ||
510 | memcpy(addr, in_addr, na * 4); | ||
511 | |||
512 | DBG("OF: bus is %s (na=%d, ns=%d) on %s\n", | ||
513 | bus->name, na, ns, parent->full_name); | ||
514 | of_dump_addr("OF: translating address:", addr, na); | ||
515 | |||
516 | /* Translate */ | ||
517 | for (;;) { | ||
518 | /* Switch to parent bus */ | ||
519 | of_node_put(dev); | ||
520 | dev = parent; | ||
521 | parent = of_get_parent(dev); | ||
522 | |||
523 | /* If root, we have finished */ | ||
524 | if (parent == NULL) { | ||
525 | DBG("OF: reached root node\n"); | ||
526 | result = of_read_number(addr, na); | ||
527 | break; | ||
528 | } | ||
529 | |||
530 | /* Get new parent bus and counts */ | ||
531 | pbus = of_match_bus(parent); | ||
532 | pbus->count_cells(dev, &pna, &pns); | ||
533 | if (!OF_CHECK_COUNTS(pna, pns)) { | ||
534 | printk(KERN_ERR "prom_parse: Bad cell count for %s\n", | ||
535 | dev->full_name); | ||
536 | break; | ||
537 | } | ||
538 | |||
539 | DBG("OF: parent bus is %s (na=%d, ns=%d) on %s\n", | ||
540 | pbus->name, pna, pns, parent->full_name); | ||
541 | |||
542 | /* Apply bus translation */ | ||
543 | if (of_translate_one(dev, bus, pbus, addr, na, ns, pna, rprop)) | ||
544 | break; | ||
545 | |||
546 | /* Complete the move up one level */ | ||
547 | na = pna; | ||
548 | ns = pns; | ||
549 | bus = pbus; | ||
550 | |||
551 | of_dump_addr("OF: one level translation:", addr, na); | ||
552 | } | ||
553 | bail: | ||
554 | of_node_put(parent); | ||
555 | of_node_put(dev); | ||
556 | |||
557 | return result; | ||
558 | } | ||
559 | |||
560 | u64 of_translate_address(struct device_node *dev, const u32 *in_addr) | ||
561 | { | ||
562 | return __of_translate_address(dev, in_addr, "ranges"); | ||
563 | } | ||
564 | EXPORT_SYMBOL(of_translate_address); | ||
565 | |||
566 | u64 of_translate_dma_address(struct device_node *dev, const u32 *in_addr) | ||
567 | { | ||
568 | return __of_translate_address(dev, in_addr, "dma-ranges"); | ||
569 | } | ||
570 | EXPORT_SYMBOL(of_translate_dma_address); | ||
571 | |||
572 | const u32 *of_get_address(struct device_node *dev, int index, u64 *size, | ||
573 | unsigned int *flags) | ||
574 | { | ||
575 | const u32 *prop; | ||
576 | unsigned int psize; | ||
577 | struct device_node *parent; | ||
578 | struct of_bus *bus; | ||
579 | int onesize, i, na, ns; | ||
580 | |||
581 | /* Get parent & match bus type */ | ||
582 | parent = of_get_parent(dev); | ||
583 | if (parent == NULL) | ||
584 | return NULL; | ||
585 | bus = of_match_bus(parent); | ||
586 | bus->count_cells(dev, &na, &ns); | ||
587 | of_node_put(parent); | ||
588 | if (!OF_CHECK_COUNTS(na, ns)) | ||
589 | return NULL; | ||
590 | |||
591 | /* Get "reg" or "assigned-addresses" property */ | ||
592 | prop = of_get_property(dev, bus->addresses, &psize); | ||
593 | if (prop == NULL) | ||
594 | return NULL; | ||
595 | psize /= 4; | ||
596 | |||
597 | onesize = na + ns; | ||
598 | for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++) | ||
599 | if (i == index) { | ||
600 | if (size) | ||
601 | *size = of_read_number(prop + na, ns); | ||
602 | if (flags) | ||
603 | *flags = bus->get_flags(prop); | ||
604 | return prop; | ||
605 | } | ||
606 | return NULL; | ||
607 | } | ||
608 | EXPORT_SYMBOL(of_get_address); | ||
609 | |||
610 | void of_parse_dma_window(struct device_node *dn, const void *dma_window_prop, | 95 | void of_parse_dma_window(struct device_node *dn, const void *dma_window_prop, |
611 | unsigned long *busno, unsigned long *phys, unsigned long *size) | 96 | unsigned long *busno, unsigned long *phys, unsigned long *size) |
612 | { | 97 | { |