Branch data Line data Source code
1 : :
2 : : #include <linux/device.h>
3 : : #include <linux/io.h>
4 : : #include <linux/ioport.h>
5 : : #include <linux/module.h>
6 : : #include <linux/of_address.h>
7 : : #include <linux/pci_regs.h>
8 : : #include <linux/string.h>
9 : :
10 : : /* Max address size we deal with */
11 : : #define OF_MAX_ADDR_CELLS 4
12 : : #define OF_CHECK_ADDR_COUNT(na) ((na) > 0 && (na) <= OF_MAX_ADDR_CELLS)
13 : : #define OF_CHECK_COUNTS(na, ns) (OF_CHECK_ADDR_COUNT(na) && (ns) > 0)
14 : :
15 : : static struct of_bus *of_match_bus(struct device_node *np);
16 : : static int __of_address_to_resource(struct device_node *dev,
17 : : const __be32 *addrp, u64 size, unsigned int flags,
18 : : const char *name, struct resource *r);
19 : :
20 : : /* Debug utility */
21 : : #ifdef DEBUG
22 : : static void of_dump_addr(const char *s, const __be32 *addr, int na)
23 : : {
24 : : printk(KERN_DEBUG "%s", s);
25 : : while (na--)
26 : : printk(" %08x", be32_to_cpu(*(addr++)));
27 : : printk("\n");
28 : : }
29 : : #else
30 : : static void of_dump_addr(const char *s, const __be32 *addr, int na) { }
31 : : #endif
32 : :
33 : : /* Callbacks for bus specific translators */
34 : : struct of_bus {
35 : : const char *name;
36 : : const char *addresses;
37 : : int (*match)(struct device_node *parent);
38 : : void (*count_cells)(struct device_node *child,
39 : : int *addrc, int *sizec);
40 : : u64 (*map)(__be32 *addr, const __be32 *range,
41 : : int na, int ns, int pna);
42 : : int (*translate)(__be32 *addr, u64 offset, int na);
43 : : unsigned int (*get_flags)(const __be32 *addr);
44 : : };
45 : :
46 : : /*
47 : : * Default translator (generic bus)
48 : : */
49 : :
50 : 0 : static void of_bus_default_count_cells(struct device_node *dev,
51 : : int *addrc, int *sizec)
52 : : {
53 [ # # ]: 0 : if (addrc)
54 : 0 : *addrc = of_n_addr_cells(dev);
55 [ # # ]: 0 : if (sizec)
56 : 0 : *sizec = of_n_size_cells(dev);
57 : 0 : }
58 : :
59 : 0 : static u64 of_bus_default_map(__be32 *addr, const __be32 *range,
60 : : int na, int ns, int pna)
61 : : {
62 : : u64 cp, s, da;
63 : :
64 : : cp = of_read_number(range, na);
65 : 0 : s = of_read_number(range + na + pna, ns);
66 : : da = of_read_number(addr, na);
67 : :
68 : : pr_debug("OF: default map, cp=%llx, s=%llx, da=%llx\n",
69 : : (unsigned long long)cp, (unsigned long long)s,
70 : : (unsigned long long)da);
71 : :
72 [ # # ][ # # ]: 0 : if (da < cp || da >= (cp + s))
73 : : return OF_BAD_ADDR;
74 : 0 : return da - cp;
75 : : }
76 : :
77 : 0 : static int of_bus_default_translate(__be32 *addr, u64 offset, int na)
78 : : {
79 : : u64 a = of_read_number(addr, na);
80 [ # # ]: 0 : memset(addr, 0, na * 4);
81 : 0 : a += offset;
82 [ # # ]: 0 : if (na > 1)
83 [ # # ]: 0 : addr[na - 2] = cpu_to_be32(a >> 32);
84 [ # # ]: 0 : addr[na - 1] = cpu_to_be32(a & 0xffffffffu);
85 : :
86 : 0 : return 0;
87 : : }
88 : :
89 : 0 : static unsigned int of_bus_default_get_flags(const __be32 *addr)
90 : : {
91 : 0 : return IORESOURCE_MEM;
92 : : }
93 : :
94 : : #ifdef CONFIG_PCI
95 : : /*
96 : : * PCI bus specific translator
97 : : */
98 : :
99 : : static int of_bus_pci_match(struct device_node *np)
100 : : {
101 : : /*
102 : : * "pciex" is PCI Express
103 : : * "vci" is for the /chaos bridge on 1st-gen PCI powermacs
104 : : * "ht" is hypertransport
105 : : */
106 : : return !strcmp(np->type, "pci") || !strcmp(np->type, "pciex") ||
107 : : !strcmp(np->type, "vci") || !strcmp(np->type, "ht");
108 : : }
109 : :
110 : : static void of_bus_pci_count_cells(struct device_node *np,
111 : : int *addrc, int *sizec)
112 : : {
113 : : if (addrc)
114 : : *addrc = 3;
115 : : if (sizec)
116 : : *sizec = 2;
117 : : }
118 : :
119 : : static unsigned int of_bus_pci_get_flags(const __be32 *addr)
120 : : {
121 : : unsigned int flags = 0;
122 : : u32 w = be32_to_cpup(addr);
123 : :
124 : : switch((w >> 24) & 0x03) {
125 : : case 0x01:
126 : : flags |= IORESOURCE_IO;
127 : : break;
128 : : case 0x02: /* 32 bits */
129 : : case 0x03: /* 64 bits */
130 : : flags |= IORESOURCE_MEM;
131 : : break;
132 : : }
133 : : if (w & 0x40000000)
134 : : flags |= IORESOURCE_PREFETCH;
135 : : return flags;
136 : : }
137 : :
138 : : static u64 of_bus_pci_map(__be32 *addr, const __be32 *range, int na, int ns,
139 : : int pna)
140 : : {
141 : : u64 cp, s, da;
142 : : unsigned int af, rf;
143 : :
144 : : af = of_bus_pci_get_flags(addr);
145 : : rf = of_bus_pci_get_flags(range);
146 : :
147 : : /* Check address type match */
148 : : if ((af ^ rf) & (IORESOURCE_MEM | IORESOURCE_IO))
149 : : return OF_BAD_ADDR;
150 : :
151 : : /* Read address values, skipping high cell */
152 : : cp = of_read_number(range + 1, na - 1);
153 : : s = of_read_number(range + na + pna, ns);
154 : : da = of_read_number(addr + 1, na - 1);
155 : :
156 : : pr_debug("OF: PCI map, cp=%llx, s=%llx, da=%llx\n",
157 : : (unsigned long long)cp, (unsigned long long)s,
158 : : (unsigned long long)da);
159 : :
160 : : if (da < cp || da >= (cp + s))
161 : : return OF_BAD_ADDR;
162 : : return da - cp;
163 : : }
164 : :
165 : : static int of_bus_pci_translate(__be32 *addr, u64 offset, int na)
166 : : {
167 : : return of_bus_default_translate(addr + 1, offset, na - 1);
168 : : }
169 : :
170 : : const __be32 *of_get_pci_address(struct device_node *dev, int bar_no, u64 *size,
171 : : unsigned int *flags)
172 : : {
173 : : const __be32 *prop;
174 : : unsigned int psize;
175 : : struct device_node *parent;
176 : : struct of_bus *bus;
177 : : int onesize, i, na, ns;
178 : :
179 : : /* Get parent & match bus type */
180 : : parent = of_get_parent(dev);
181 : : if (parent == NULL)
182 : : return NULL;
183 : : bus = of_match_bus(parent);
184 : : if (strcmp(bus->name, "pci")) {
185 : : of_node_put(parent);
186 : : return NULL;
187 : : }
188 : : bus->count_cells(dev, &na, &ns);
189 : : of_node_put(parent);
190 : : if (!OF_CHECK_ADDR_COUNT(na))
191 : : return NULL;
192 : :
193 : : /* Get "reg" or "assigned-addresses" property */
194 : : prop = of_get_property(dev, bus->addresses, &psize);
195 : : if (prop == NULL)
196 : : return NULL;
197 : : psize /= 4;
198 : :
199 : : onesize = na + ns;
200 : : for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++) {
201 : : u32 val = be32_to_cpu(prop[0]);
202 : : if ((val & 0xff) == ((bar_no * 4) + PCI_BASE_ADDRESS_0)) {
203 : : if (size)
204 : : *size = of_read_number(prop + na, ns);
205 : : if (flags)
206 : : *flags = bus->get_flags(prop);
207 : : return prop;
208 : : }
209 : : }
210 : : return NULL;
211 : : }
212 : : EXPORT_SYMBOL(of_get_pci_address);
213 : :
214 : : int of_pci_address_to_resource(struct device_node *dev, int bar,
215 : : struct resource *r)
216 : : {
217 : : const __be32 *addrp;
218 : : u64 size;
219 : : unsigned int flags;
220 : :
221 : : addrp = of_get_pci_address(dev, bar, &size, &flags);
222 : : if (addrp == NULL)
223 : : return -EINVAL;
224 : : return __of_address_to_resource(dev, addrp, size, flags, NULL, r);
225 : : }
226 : : EXPORT_SYMBOL_GPL(of_pci_address_to_resource);
227 : :
228 : : int of_pci_range_parser_init(struct of_pci_range_parser *parser,
229 : : struct device_node *node)
230 : : {
231 : : const int na = 3, ns = 2;
232 : : int rlen;
233 : :
234 : : parser->node = node;
235 : : parser->pna = of_n_addr_cells(node);
236 : : parser->np = parser->pna + na + ns;
237 : :
238 : : parser->range = of_get_property(node, "ranges", &rlen);
239 : : if (parser->range == NULL)
240 : : return -ENOENT;
241 : :
242 : : parser->end = parser->range + rlen / sizeof(__be32);
243 : :
244 : : return 0;
245 : : }
246 : : EXPORT_SYMBOL_GPL(of_pci_range_parser_init);
247 : :
248 : : struct of_pci_range *of_pci_range_parser_one(struct of_pci_range_parser *parser,
249 : : struct of_pci_range *range)
250 : : {
251 : : const int na = 3, ns = 2;
252 : :
253 : : if (!range)
254 : : return NULL;
255 : :
256 : : if (!parser->range || parser->range + parser->np > parser->end)
257 : : return NULL;
258 : :
259 : : range->pci_space = parser->range[0];
260 : : range->flags = of_bus_pci_get_flags(parser->range);
261 : : range->pci_addr = of_read_number(parser->range + 1, ns);
262 : : range->cpu_addr = of_translate_address(parser->node,
263 : : parser->range + na);
264 : : range->size = of_read_number(parser->range + parser->pna + na, ns);
265 : :
266 : : parser->range += parser->np;
267 : :
268 : : /* Now consume following elements while they are contiguous */
269 : : while (parser->range + parser->np <= parser->end) {
270 : : u32 flags, pci_space;
271 : : u64 pci_addr, cpu_addr, size;
272 : :
273 : : pci_space = be32_to_cpup(parser->range);
274 : : flags = of_bus_pci_get_flags(parser->range);
275 : : pci_addr = of_read_number(parser->range + 1, ns);
276 : : cpu_addr = of_translate_address(parser->node,
277 : : parser->range + na);
278 : : size = of_read_number(parser->range + parser->pna + na, ns);
279 : :
280 : : if (flags != range->flags)
281 : : break;
282 : : if (pci_addr != range->pci_addr + range->size ||
283 : : cpu_addr != range->cpu_addr + range->size)
284 : : break;
285 : :
286 : : range->size += size;
287 : : parser->range += parser->np;
288 : : }
289 : :
290 : : return range;
291 : : }
292 : : EXPORT_SYMBOL_GPL(of_pci_range_parser_one);
293 : :
294 : : #endif /* CONFIG_PCI */
295 : :
296 : : /*
297 : : * ISA bus specific translator
298 : : */
299 : :
300 : 0 : static int of_bus_isa_match(struct device_node *np)
301 : : {
302 : 0 : return !strcmp(np->name, "isa");
303 : : }
304 : :
305 : 0 : static void of_bus_isa_count_cells(struct device_node *child,
306 : : int *addrc, int *sizec)
307 : : {
308 [ # # ]: 0 : if (addrc)
309 : 0 : *addrc = 2;
310 [ # # ]: 0 : if (sizec)
311 : 0 : *sizec = 1;
312 : 0 : }
313 : :
314 : 0 : static u64 of_bus_isa_map(__be32 *addr, const __be32 *range, int na, int ns,
315 : : int pna)
316 : : {
317 : : u64 cp, s, da;
318 : :
319 : : /* Check address type match */
320 [ # # ]: 0 : if ((addr[0] ^ range[0]) & cpu_to_be32(1))
321 : : return OF_BAD_ADDR;
322 : :
323 : : /* Read address values, skipping high cell */
324 : 0 : cp = of_read_number(range + 1, na - 1);
325 : 0 : s = of_read_number(range + na + pna, ns);
326 : 0 : da = of_read_number(addr + 1, na - 1);
327 : :
328 : : pr_debug("OF: ISA map, cp=%llx, s=%llx, da=%llx\n",
329 : : (unsigned long long)cp, (unsigned long long)s,
330 : : (unsigned long long)da);
331 : :
332 [ # # ][ # # ]: 0 : if (da < cp || da >= (cp + s))
333 : : return OF_BAD_ADDR;
334 : 0 : return da - cp;
335 : : }
336 : :
337 : 0 : static int of_bus_isa_translate(__be32 *addr, u64 offset, int na)
338 : : {
339 : 0 : return of_bus_default_translate(addr + 1, offset, na - 1);
340 : : }
341 : :
342 : 0 : static unsigned int of_bus_isa_get_flags(const __be32 *addr)
343 : : {
344 : : unsigned int flags = 0;
345 : : u32 w = be32_to_cpup(addr);
346 : :
347 [ # # ]: 0 : if (w & 1)
348 : : flags |= IORESOURCE_IO;
349 : : else
350 : : flags |= IORESOURCE_MEM;
351 : 0 : return flags;
352 : : }
353 : :
354 : : /*
355 : : * Array of bus specific translators
356 : : */
357 : :
358 : : static struct of_bus of_busses[] = {
359 : : #ifdef CONFIG_PCI
360 : : /* PCI */
361 : : {
362 : : .name = "pci",
363 : : .addresses = "assigned-addresses",
364 : : .match = of_bus_pci_match,
365 : : .count_cells = of_bus_pci_count_cells,
366 : : .map = of_bus_pci_map,
367 : : .translate = of_bus_pci_translate,
368 : : .get_flags = of_bus_pci_get_flags,
369 : : },
370 : : #endif /* CONFIG_PCI */
371 : : /* ISA */
372 : : {
373 : : .name = "isa",
374 : : .addresses = "reg",
375 : : .match = of_bus_isa_match,
376 : : .count_cells = of_bus_isa_count_cells,
377 : : .map = of_bus_isa_map,
378 : : .translate = of_bus_isa_translate,
379 : : .get_flags = of_bus_isa_get_flags,
380 : : },
381 : : /* Default */
382 : : {
383 : : .name = "default",
384 : : .addresses = "reg",
385 : : .match = NULL,
386 : : .count_cells = of_bus_default_count_cells,
387 : : .map = of_bus_default_map,
388 : : .translate = of_bus_default_translate,
389 : : .get_flags = of_bus_default_get_flags,
390 : : },
391 : : };
392 : :
393 : 0 : static struct of_bus *of_match_bus(struct device_node *np)
394 : : {
395 : : int i;
396 : :
397 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(of_busses); i++)
398 [ # # ][ # # ]: 0 : if (!of_busses[i].match || of_busses[i].match(np))
399 : 0 : return &of_busses[i];
400 : 0 : BUG();
401 : : return NULL;
402 : : }
403 : :
404 : 0 : static int of_translate_one(struct device_node *parent, struct of_bus *bus,
405 : : struct of_bus *pbus, __be32 *addr,
406 : : int na, int ns, int pna, const char *rprop)
407 : : {
408 : : const __be32 *ranges;
409 : : unsigned int rlen;
410 : : int rone;
411 : : u64 offset = OF_BAD_ADDR;
412 : :
413 : : /* Normally, an absence of a "ranges" property means we are
414 : : * crossing a non-translatable boundary, and thus the addresses
415 : : * below the current not cannot be converted to CPU physical ones.
416 : : * Unfortunately, while this is very clear in the spec, it's not
417 : : * what Apple understood, and they do have things like /uni-n or
418 : : * /ht nodes with no "ranges" property and a lot of perfectly
419 : : * useable mapped devices below them. Thus we treat the absence of
420 : : * "ranges" as equivalent to an empty "ranges" property which means
421 : : * a 1:1 translation at that level. It's up to the caller not to try
422 : : * to translate addresses that aren't supposed to be translated in
423 : : * the first place. --BenH.
424 : : *
425 : : * As far as we know, this damage only exists on Apple machines, so
426 : : * This code is only enabled on powerpc. --gcl
427 : : */
428 : 0 : ranges = of_get_property(parent, rprop, &rlen);
429 : : #if !defined(CONFIG_PPC)
430 [ # # ]: 0 : if (ranges == NULL) {
431 : 0 : pr_err("OF: no ranges; cannot translate\n");
432 : : return 1;
433 : : }
434 : : #endif /* !defined(CONFIG_PPC) */
435 [ # # ][ # # ]: 0 : if (ranges == NULL || rlen == 0) {
436 : : offset = of_read_number(addr, na);
437 [ # # ]: 0 : memset(addr, 0, pna * 4);
438 : : pr_debug("OF: empty ranges; 1:1 translation\n");
439 : : goto finish;
440 : : }
441 : :
442 : : pr_debug("OF: walking ranges...\n");
443 : :
444 : : /* Now walk through the ranges */
445 : 0 : rlen /= 4;
446 : 0 : rone = na + pna + ns;
447 [ # # ]: 0 : for (; rlen >= rone; rlen -= rone, ranges += rone) {
448 : 0 : offset = bus->map(addr, ranges, na, ns, pna);
449 [ # # ]: 0 : if (offset != OF_BAD_ADDR)
450 : : break;
451 : : }
452 [ # # ]: 0 : if (offset == OF_BAD_ADDR) {
453 : : pr_debug("OF: not found !\n");
454 : : return 1;
455 : : }
456 : 0 : memcpy(addr, ranges + na, 4 * pna);
457 : :
458 : : finish:
459 : : of_dump_addr("OF: parent translation for:", addr, pna);
460 : : pr_debug("OF: with offset: %llx\n", (unsigned long long)offset);
461 : :
462 : : /* Translate it into parent bus space */
463 : 0 : return pbus->translate(addr, offset, pna);
464 : : }
465 : :
466 : : /*
467 : : * Translate an address from the device-tree into a CPU physical address,
468 : : * this walks up the tree and applies the various bus mappings on the
469 : : * way.
470 : : *
471 : : * Note: We consider that crossing any level with #size-cells == 0 to mean
472 : : * that translation is impossible (that is we are not dealing with a value
473 : : * that can be mapped to a cpu physical address). This is not really specified
474 : : * that way, but this is traditionally the way IBM at least do things
475 : : */
476 : 0 : static u64 __of_translate_address(struct device_node *dev,
477 : : const __be32 *in_addr, const char *rprop)
478 : : {
479 : : struct device_node *parent = NULL;
480 : : struct of_bus *bus, *pbus;
481 : : __be32 addr[OF_MAX_ADDR_CELLS];
482 : : int na, ns, pna, pns;
483 : : u64 result = OF_BAD_ADDR;
484 : :
485 : : pr_debug("OF: ** translation for device %s **\n", of_node_full_name(dev));
486 : :
487 : : /* Increase refcount at current level */
488 : : of_node_get(dev);
489 : :
490 : : /* Get parent & match bus type */
491 : 0 : parent = of_get_parent(dev);
492 [ # # ]: 0 : if (parent == NULL)
493 : : goto bail;
494 : 0 : bus = of_match_bus(parent);
495 : :
496 : : /* Count address cells & copy address locally */
497 : 0 : bus->count_cells(dev, &na, &ns);
498 [ # # ][ # # ]: 0 : if (!OF_CHECK_COUNTS(na, ns)) {
499 : 0 : printk(KERN_ERR "prom_parse: Bad cell count for %s\n",
500 : : of_node_full_name(dev));
501 : 0 : goto bail;
502 : : }
503 : 0 : memcpy(addr, in_addr, na * 4);
504 : :
505 : : pr_debug("OF: bus is %s (na=%d, ns=%d) on %s\n",
506 : : bus->name, na, ns, of_node_full_name(parent));
507 : : of_dump_addr("OF: translating address:", addr, na);
508 : :
509 : : /* Translate */
510 : : for (;;) {
511 : : /* Switch to parent bus */
512 : : of_node_put(dev);
513 : : dev = parent;
514 : 0 : parent = of_get_parent(dev);
515 : :
516 : : /* If root, we have finished */
517 [ # # ]: 0 : if (parent == NULL) {
518 : : pr_debug("OF: reached root node\n");
519 : 0 : result = of_read_number(addr, na);
520 : : break;
521 : : }
522 : :
523 : : /* Get new parent bus and counts */
524 : 0 : pbus = of_match_bus(parent);
525 : 0 : pbus->count_cells(dev, &pna, &pns);
526 [ # # ][ # # ]: 0 : if (!OF_CHECK_COUNTS(pna, pns)) {
527 : 0 : printk(KERN_ERR "prom_parse: Bad cell count for %s\n",
528 : : of_node_full_name(dev));
529 : 0 : break;
530 : : }
531 : :
532 : : pr_debug("OF: parent bus is %s (na=%d, ns=%d) on %s\n",
533 : : pbus->name, pna, pns, of_node_full_name(parent));
534 : :
535 : : /* Apply bus translation */
536 [ # # ]: 0 : if (of_translate_one(dev, bus, pbus, addr, na, ns, pna, rprop))
537 : : break;
538 : :
539 : : /* Complete the move up one level */
540 : 0 : na = pna;
541 : 0 : ns = pns;
542 : : bus = pbus;
543 : :
544 : : of_dump_addr("OF: one level translation:", addr, na);
545 : : }
546 : : bail:
547 : : of_node_put(parent);
548 : : of_node_put(dev);
549 : :
550 : 0 : return result;
551 : : }
552 : :
553 : 0 : u64 of_translate_address(struct device_node *dev, const __be32 *in_addr)
554 : : {
555 : 0 : return __of_translate_address(dev, in_addr, "ranges");
556 : : }
557 : : EXPORT_SYMBOL(of_translate_address);
558 : :
559 : 0 : u64 of_translate_dma_address(struct device_node *dev, const __be32 *in_addr)
560 : : {
561 : 0 : return __of_translate_address(dev, in_addr, "dma-ranges");
562 : : }
563 : : EXPORT_SYMBOL(of_translate_dma_address);
564 : :
565 : 0 : bool of_can_translate_address(struct device_node *dev)
566 : : {
567 : : struct device_node *parent;
568 : : struct of_bus *bus;
569 : : int na, ns;
570 : :
571 : 0 : parent = of_get_parent(dev);
572 [ # # ]: 0 : if (parent == NULL)
573 : : return false;
574 : :
575 : 0 : bus = of_match_bus(parent);
576 : 0 : bus->count_cells(dev, &na, &ns);
577 : :
578 : : of_node_put(parent);
579 : :
580 [ # # ][ # # ]: 0 : return OF_CHECK_COUNTS(na, ns);
581 : : }
582 : : EXPORT_SYMBOL(of_can_translate_address);
583 : :
584 : 0 : const __be32 *of_get_address(struct device_node *dev, int index, u64 *size,
585 : : unsigned int *flags)
586 : : {
587 : : const __be32 *prop;
588 : : unsigned int psize;
589 : : struct device_node *parent;
590 : : struct of_bus *bus;
591 : : int onesize, i, na, ns;
592 : :
593 : : /* Get parent & match bus type */
594 : 0 : parent = of_get_parent(dev);
595 [ # # ]: 0 : if (parent == NULL)
596 : : return NULL;
597 : 0 : bus = of_match_bus(parent);
598 : 0 : bus->count_cells(dev, &na, &ns);
599 : : of_node_put(parent);
600 [ # # ]: 0 : if (!OF_CHECK_ADDR_COUNT(na))
601 : : return NULL;
602 : :
603 : : /* Get "reg" or "assigned-addresses" property */
604 : 0 : prop = of_get_property(dev, bus->addresses, &psize);
605 [ # # ]: 0 : if (prop == NULL)
606 : : return NULL;
607 : 0 : psize /= 4;
608 : :
609 : 0 : onesize = na + ns;
610 [ # # ]: 0 : for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++)
611 [ # # ]: 0 : if (i == index) {
612 [ # # ]: 0 : if (size)
613 : 0 : *size = of_read_number(prop + na, ns);
614 [ # # ]: 0 : if (flags)
615 : 0 : *flags = bus->get_flags(prop);
616 : 0 : return prop;
617 : : }
618 : : return NULL;
619 : : }
620 : : EXPORT_SYMBOL(of_get_address);
621 : :
622 : 0 : unsigned long __weak pci_address_to_pio(phys_addr_t address)
623 : : {
624 [ # # ]: 0 : if (address > IO_SPACE_LIMIT)
625 : : return (unsigned long)-1;
626 : :
627 : 0 : return (unsigned long) address;
628 : : }
629 : :
630 : 0 : static int __of_address_to_resource(struct device_node *dev,
631 : : const __be32 *addrp, u64 size, unsigned int flags,
632 : : const char *name, struct resource *r)
633 : : {
634 : : u64 taddr;
635 : :
636 [ # # ]: 0 : if ((flags & (IORESOURCE_IO | IORESOURCE_MEM)) == 0)
637 : : return -EINVAL;
638 : : taddr = of_translate_address(dev, addrp);
639 [ # # ]: 0 : if (taddr == OF_BAD_ADDR)
640 : : return -EINVAL;
641 : 0 : memset(r, 0, sizeof(struct resource));
642 [ # # ]: 0 : if (flags & IORESOURCE_IO) {
643 : : unsigned long port;
644 : 0 : port = pci_address_to_pio(taddr);
645 [ # # ]: 0 : if (port == (unsigned long)-1)
646 : : return -EINVAL;
647 : 0 : r->start = port;
648 : 0 : r->end = port + size - 1;
649 : : } else {
650 : 0 : r->start = taddr;
651 : 0 : r->end = taddr + size - 1;
652 : : }
653 : 0 : r->flags = flags;
654 [ # # ]: 0 : r->name = name ? name : dev->full_name;
655 : :
656 : 0 : return 0;
657 : : }
658 : :
659 : : /**
660 : : * of_address_to_resource - Translate device tree address and return as resource
661 : : *
662 : : * Note that if your address is a PIO address, the conversion will fail if
663 : : * the physical address can't be internally converted to an IO token with
664 : : * pci_address_to_pio(), that is because it's either called to early or it
665 : : * can't be matched to any host bridge IO space
666 : : */
667 : 0 : int of_address_to_resource(struct device_node *dev, int index,
668 : : struct resource *r)
669 : : {
670 : : const __be32 *addrp;
671 : : u64 size;
672 : : unsigned int flags;
673 : 0 : const char *name = NULL;
674 : :
675 : 0 : addrp = of_get_address(dev, index, &size, &flags);
676 [ # # ]: 0 : if (addrp == NULL)
677 : : return -EINVAL;
678 : :
679 : : /* Get optional "reg-names" property to add a name to a resource */
680 : 0 : of_property_read_string_index(dev, "reg-names", index, &name);
681 : :
682 : 0 : return __of_address_to_resource(dev, addrp, size, flags, name, r);
683 : : }
684 : : EXPORT_SYMBOL_GPL(of_address_to_resource);
685 : :
686 : 0 : struct device_node *of_find_matching_node_by_address(struct device_node *from,
687 : : const struct of_device_id *matches,
688 : : u64 base_address)
689 : : {
690 : : struct device_node *dn = of_find_matching_node(from, matches);
691 : : struct resource res;
692 : :
693 [ # # ]: 0 : while (dn) {
694 [ # # ]: 0 : if (of_address_to_resource(dn, 0, &res))
695 : 0 : continue;
696 [ # # ]: 0 : if (res.start == base_address)
697 : : return dn;
698 : : dn = of_find_matching_node(dn, matches);
699 : : }
700 : :
701 : : return NULL;
702 : : }
703 : :
704 : :
705 : : /**
706 : : * of_iomap - Maps the memory mapped IO for a given device_node
707 : : * @device: the device whose io range will be mapped
708 : : * @index: index of the io range
709 : : *
710 : : * Returns a pointer to the mapped memory
711 : : */
712 : 0 : void __iomem *of_iomap(struct device_node *np, int index)
713 : : {
714 : : struct resource res;
715 : :
716 [ # # ]: 0 : if (of_address_to_resource(np, index, &res))
717 : : return NULL;
718 : :
719 : 0 : return ioremap(res.start, resource_size(&res));
720 : : }
721 : : EXPORT_SYMBOL(of_iomap);
|
