blob: 72c33fbe451d6c31f1b50d0f38ced362d5258210 [file] [log] [blame]
Grant Likely6b884a82010-06-08 07:48:09 -06001
2#include <linux/io.h>
3#include <linux/ioport.h>
Grant Likelydbbdee92010-06-08 07:48:10 -06004#include <linux/module.h>
Grant Likely6b884a82010-06-08 07:48:09 -06005#include <linux/of_address.h>
Grant Likelydbbdee92010-06-08 07:48:10 -06006#include <linux/pci_regs.h>
7#include <linux/string.h>
Grant Likely6b884a82010-06-08 07:48:09 -06008
Grant Likelydbbdee92010-06-08 07:48:10 -06009/* Max address size we deal with */
10#define OF_MAX_ADDR_CELLS 4
11#define OF_CHECK_COUNTS(na, ns) ((na) > 0 && (na) <= OF_MAX_ADDR_CELLS && \
12 (ns) > 0)
13
14static struct of_bus *of_match_bus(struct device_node *np);
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +010015static int __of_address_to_resource(struct device_node *dev,
16 const __be32 *addrp, u64 size, unsigned int flags,
Grant Likelydbbdee92010-06-08 07:48:10 -060017 struct resource *r);
18
19/* Debug utility */
20#ifdef DEBUG
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +010021static void of_dump_addr(const char *s, const __be32 *addr, int na)
Grant Likelydbbdee92010-06-08 07:48:10 -060022{
23 printk(KERN_DEBUG "%s", s);
24 while (na--)
Grant Likely154063a92010-06-08 07:48:11 -060025 printk(" %08x", be32_to_cpu(*(addr++)));
Grant Likelydbbdee92010-06-08 07:48:10 -060026 printk("\n");
27}
28#else
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +010029static void of_dump_addr(const char *s, const __be32 *addr, int na) { }
Grant Likelydbbdee92010-06-08 07:48:10 -060030#endif
31
32/* Callbacks for bus specific translators */
33struct of_bus {
34 const char *name;
35 const char *addresses;
36 int (*match)(struct device_node *parent);
37 void (*count_cells)(struct device_node *child,
38 int *addrc, int *sizec);
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +010039 u64 (*map)(u32 *addr, const __be32 *range,
Grant Likelydbbdee92010-06-08 07:48:10 -060040 int na, int ns, int pna);
41 int (*translate)(u32 *addr, u64 offset, int na);
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +010042 unsigned int (*get_flags)(const __be32 *addr);
Grant Likelydbbdee92010-06-08 07:48:10 -060043};
44
45/*
46 * Default translator (generic bus)
47 */
48
49static void of_bus_default_count_cells(struct device_node *dev,
50 int *addrc, int *sizec)
51{
52 if (addrc)
53 *addrc = of_n_addr_cells(dev);
54 if (sizec)
55 *sizec = of_n_size_cells(dev);
56}
57
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +010058static u64 of_bus_default_map(u32 *addr, const __be32 *range,
Grant Likelydbbdee92010-06-08 07:48:10 -060059 int na, int ns, int pna)
60{
61 u64 cp, s, da;
62
63 cp = of_read_number(range, na);
64 s = of_read_number(range + na + pna, ns);
65 da = of_read_number(addr, na);
66
67 pr_debug("OF: default map, cp=%llx, s=%llx, da=%llx\n",
68 (unsigned long long)cp, (unsigned long long)s,
69 (unsigned long long)da);
70
71 if (da < cp || da >= (cp + s))
72 return OF_BAD_ADDR;
73 return da - cp;
74}
75
76static int of_bus_default_translate(u32 *addr, u64 offset, int na)
77{
78 u64 a = of_read_number(addr, na);
79 memset(addr, 0, na * 4);
80 a += offset;
81 if (na > 1)
Grant Likely154063a92010-06-08 07:48:11 -060082 addr[na - 2] = cpu_to_be32(a >> 32);
83 addr[na - 1] = cpu_to_be32(a & 0xffffffffu);
Grant Likelydbbdee92010-06-08 07:48:10 -060084
85 return 0;
86}
87
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +010088static unsigned int of_bus_default_get_flags(const __be32 *addr)
Grant Likelydbbdee92010-06-08 07:48:10 -060089{
90 return IORESOURCE_MEM;
91}
92
93#ifdef CONFIG_PCI
94/*
95 * PCI bus specific translator
96 */
97
98static int of_bus_pci_match(struct device_node *np)
99{
100 /* "vci" is for the /chaos bridge on 1st-gen PCI powermacs */
101 return !strcmp(np->type, "pci") || !strcmp(np->type, "vci");
102}
103
104static void of_bus_pci_count_cells(struct device_node *np,
105 int *addrc, int *sizec)
106{
107 if (addrc)
108 *addrc = 3;
109 if (sizec)
110 *sizec = 2;
111}
112
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +0100113static unsigned int of_bus_pci_get_flags(const __be32 *addr)
Grant Likelydbbdee92010-06-08 07:48:10 -0600114{
115 unsigned int flags = 0;
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +0100116 u32 w = be32_to_cpup(addr);
Grant Likelydbbdee92010-06-08 07:48:10 -0600117
118 switch((w >> 24) & 0x03) {
119 case 0x01:
120 flags |= IORESOURCE_IO;
121 break;
122 case 0x02: /* 32 bits */
123 case 0x03: /* 64 bits */
124 flags |= IORESOURCE_MEM;
125 break;
126 }
127 if (w & 0x40000000)
128 flags |= IORESOURCE_PREFETCH;
129 return flags;
130}
131
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +0100132static u64 of_bus_pci_map(u32 *addr, const __be32 *range, int na, int ns,
133 int pna)
Grant Likelydbbdee92010-06-08 07:48:10 -0600134{
135 u64 cp, s, da;
136 unsigned int af, rf;
137
138 af = of_bus_pci_get_flags(addr);
139 rf = of_bus_pci_get_flags(range);
140
141 /* Check address type match */
142 if ((af ^ rf) & (IORESOURCE_MEM | IORESOURCE_IO))
143 return OF_BAD_ADDR;
144
145 /* Read address values, skipping high cell */
146 cp = of_read_number(range + 1, na - 1);
147 s = of_read_number(range + na + pna, ns);
148 da = of_read_number(addr + 1, na - 1);
149
150 pr_debug("OF: PCI map, cp=%llx, s=%llx, da=%llx\n",
151 (unsigned long long)cp, (unsigned long long)s,
152 (unsigned long long)da);
153
154 if (da < cp || da >= (cp + s))
155 return OF_BAD_ADDR;
156 return da - cp;
157}
158
159static int of_bus_pci_translate(u32 *addr, u64 offset, int na)
160{
161 return of_bus_default_translate(addr + 1, offset, na - 1);
162}
163
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +0100164const __be32 *of_get_pci_address(struct device_node *dev, int bar_no, u64 *size,
Grant Likelydbbdee92010-06-08 07:48:10 -0600165 unsigned int *flags)
166{
Jeremy Kerra9fadee2010-10-10 21:24:10 -0600167 const __be32 *prop;
Grant Likelydbbdee92010-06-08 07:48:10 -0600168 unsigned int psize;
169 struct device_node *parent;
170 struct of_bus *bus;
171 int onesize, i, na, ns;
172
173 /* Get parent & match bus type */
174 parent = of_get_parent(dev);
175 if (parent == NULL)
176 return NULL;
177 bus = of_match_bus(parent);
178 if (strcmp(bus->name, "pci")) {
179 of_node_put(parent);
180 return NULL;
181 }
182 bus->count_cells(dev, &na, &ns);
183 of_node_put(parent);
184 if (!OF_CHECK_COUNTS(na, ns))
185 return NULL;
186
187 /* Get "reg" or "assigned-addresses" property */
188 prop = of_get_property(dev, bus->addresses, &psize);
189 if (prop == NULL)
190 return NULL;
191 psize /= 4;
192
193 onesize = na + ns;
Grant Likely154063a92010-06-08 07:48:11 -0600194 for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++) {
195 u32 val = be32_to_cpu(prop[0]);
196 if ((val & 0xff) == ((bar_no * 4) + PCI_BASE_ADDRESS_0)) {
Grant Likelydbbdee92010-06-08 07:48:10 -0600197 if (size)
198 *size = of_read_number(prop + na, ns);
199 if (flags)
200 *flags = bus->get_flags(prop);
201 return prop;
202 }
Grant Likely154063a92010-06-08 07:48:11 -0600203 }
Grant Likelydbbdee92010-06-08 07:48:10 -0600204 return NULL;
205}
206EXPORT_SYMBOL(of_get_pci_address);
207
208int of_pci_address_to_resource(struct device_node *dev, int bar,
209 struct resource *r)
210{
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +0100211 const __be32 *addrp;
Grant Likelydbbdee92010-06-08 07:48:10 -0600212 u64 size;
213 unsigned int flags;
214
215 addrp = of_get_pci_address(dev, bar, &size, &flags);
216 if (addrp == NULL)
217 return -EINVAL;
218 return __of_address_to_resource(dev, addrp, size, flags, r);
219}
220EXPORT_SYMBOL_GPL(of_pci_address_to_resource);
221#endif /* CONFIG_PCI */
222
223/*
224 * ISA bus specific translator
225 */
226
227static int of_bus_isa_match(struct device_node *np)
228{
229 return !strcmp(np->name, "isa");
230}
231
232static void of_bus_isa_count_cells(struct device_node *child,
233 int *addrc, int *sizec)
234{
235 if (addrc)
236 *addrc = 2;
237 if (sizec)
238 *sizec = 1;
239}
240
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +0100241static u64 of_bus_isa_map(u32 *addr, const __be32 *range, int na, int ns,
242 int pna)
Grant Likelydbbdee92010-06-08 07:48:10 -0600243{
244 u64 cp, s, da;
245
246 /* Check address type match */
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +0100247 if ((addr[0] ^ range[0]) & cpu_to_be32(1))
Grant Likelydbbdee92010-06-08 07:48:10 -0600248 return OF_BAD_ADDR;
249
250 /* Read address values, skipping high cell */
251 cp = of_read_number(range + 1, na - 1);
252 s = of_read_number(range + na + pna, ns);
253 da = of_read_number(addr + 1, na - 1);
254
255 pr_debug("OF: ISA map, cp=%llx, s=%llx, da=%llx\n",
256 (unsigned long long)cp, (unsigned long long)s,
257 (unsigned long long)da);
258
259 if (da < cp || da >= (cp + s))
260 return OF_BAD_ADDR;
261 return da - cp;
262}
263
264static int of_bus_isa_translate(u32 *addr, u64 offset, int na)
265{
266 return of_bus_default_translate(addr + 1, offset, na - 1);
267}
268
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +0100269static unsigned int of_bus_isa_get_flags(const __be32 *addr)
Grant Likelydbbdee92010-06-08 07:48:10 -0600270{
271 unsigned int flags = 0;
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +0100272 u32 w = be32_to_cpup(addr);
Grant Likelydbbdee92010-06-08 07:48:10 -0600273
274 if (w & 1)
275 flags |= IORESOURCE_IO;
276 else
277 flags |= IORESOURCE_MEM;
278 return flags;
279}
280
281/*
282 * Array of bus specific translators
283 */
284
285static struct of_bus of_busses[] = {
286#ifdef CONFIG_PCI
287 /* PCI */
288 {
289 .name = "pci",
290 .addresses = "assigned-addresses",
291 .match = of_bus_pci_match,
292 .count_cells = of_bus_pci_count_cells,
293 .map = of_bus_pci_map,
294 .translate = of_bus_pci_translate,
295 .get_flags = of_bus_pci_get_flags,
296 },
297#endif /* CONFIG_PCI */
298 /* ISA */
299 {
300 .name = "isa",
301 .addresses = "reg",
302 .match = of_bus_isa_match,
303 .count_cells = of_bus_isa_count_cells,
304 .map = of_bus_isa_map,
305 .translate = of_bus_isa_translate,
306 .get_flags = of_bus_isa_get_flags,
307 },
308 /* Default */
309 {
310 .name = "default",
311 .addresses = "reg",
312 .match = NULL,
313 .count_cells = of_bus_default_count_cells,
314 .map = of_bus_default_map,
315 .translate = of_bus_default_translate,
316 .get_flags = of_bus_default_get_flags,
317 },
318};
319
320static struct of_bus *of_match_bus(struct device_node *np)
321{
322 int i;
323
324 for (i = 0; i < ARRAY_SIZE(of_busses); i++)
325 if (!of_busses[i].match || of_busses[i].match(np))
326 return &of_busses[i];
327 BUG();
328 return NULL;
329}
330
331static int of_translate_one(struct device_node *parent, struct of_bus *bus,
332 struct of_bus *pbus, u32 *addr,
333 int na, int ns, int pna, const char *rprop)
334{
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +0100335 const __be32 *ranges;
Grant Likelydbbdee92010-06-08 07:48:10 -0600336 unsigned int rlen;
337 int rone;
338 u64 offset = OF_BAD_ADDR;
339
340 /* Normally, an absence of a "ranges" property means we are
341 * crossing a non-translatable boundary, and thus the addresses
342 * below the current not cannot be converted to CPU physical ones.
343 * Unfortunately, while this is very clear in the spec, it's not
344 * what Apple understood, and they do have things like /uni-n or
345 * /ht nodes with no "ranges" property and a lot of perfectly
346 * useable mapped devices below them. Thus we treat the absence of
347 * "ranges" as equivalent to an empty "ranges" property which means
348 * a 1:1 translation at that level. It's up to the caller not to try
349 * to translate addresses that aren't supposed to be translated in
350 * the first place. --BenH.
Grant Likely3930f292010-06-08 07:48:11 -0600351 *
352 * As far as we know, this damage only exists on Apple machines, so
353 * This code is only enabled on powerpc. --gcl
Grant Likelydbbdee92010-06-08 07:48:10 -0600354 */
355 ranges = of_get_property(parent, rprop, &rlen);
Grant Likely3930f292010-06-08 07:48:11 -0600356#if !defined(CONFIG_PPC)
357 if (ranges == NULL) {
358 pr_err("OF: no ranges; cannot translate\n");
359 return 1;
360 }
361#endif /* !defined(CONFIG_PPC) */
Grant Likelydbbdee92010-06-08 07:48:10 -0600362 if (ranges == NULL || rlen == 0) {
363 offset = of_read_number(addr, na);
364 memset(addr, 0, pna * 4);
Grant Likely3930f292010-06-08 07:48:11 -0600365 pr_debug("OF: empty ranges; 1:1 translation\n");
Grant Likelydbbdee92010-06-08 07:48:10 -0600366 goto finish;
367 }
368
369 pr_debug("OF: walking ranges...\n");
370
371 /* Now walk through the ranges */
372 rlen /= 4;
373 rone = na + pna + ns;
374 for (; rlen >= rone; rlen -= rone, ranges += rone) {
375 offset = bus->map(addr, ranges, na, ns, pna);
376 if (offset != OF_BAD_ADDR)
377 break;
378 }
379 if (offset == OF_BAD_ADDR) {
380 pr_debug("OF: not found !\n");
381 return 1;
382 }
383 memcpy(addr, ranges + na, 4 * pna);
384
385 finish:
386 of_dump_addr("OF: parent translation for:", addr, pna);
387 pr_debug("OF: with offset: %llx\n", (unsigned long long)offset);
388
389 /* Translate it into parent bus space */
390 return pbus->translate(addr, offset, pna);
391}
392
393/*
394 * Translate an address from the device-tree into a CPU physical address,
395 * this walks up the tree and applies the various bus mappings on the
396 * way.
397 *
398 * Note: We consider that crossing any level with #size-cells == 0 to mean
399 * that translation is impossible (that is we are not dealing with a value
400 * that can be mapped to a cpu physical address). This is not really specified
401 * that way, but this is traditionally the way IBM at least do things
402 */
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +0100403u64 __of_translate_address(struct device_node *dev, const __be32 *in_addr,
Grant Likelydbbdee92010-06-08 07:48:10 -0600404 const char *rprop)
405{
406 struct device_node *parent = NULL;
407 struct of_bus *bus, *pbus;
408 u32 addr[OF_MAX_ADDR_CELLS];
409 int na, ns, pna, pns;
410 u64 result = OF_BAD_ADDR;
411
412 pr_debug("OF: ** translation for device %s **\n", dev->full_name);
413
414 /* Increase refcount at current level */
415 of_node_get(dev);
416
417 /* Get parent & match bus type */
418 parent = of_get_parent(dev);
419 if (parent == NULL)
420 goto bail;
421 bus = of_match_bus(parent);
422
423 /* Cound address cells & copy address locally */
424 bus->count_cells(dev, &na, &ns);
425 if (!OF_CHECK_COUNTS(na, ns)) {
426 printk(KERN_ERR "prom_parse: Bad cell count for %s\n",
427 dev->full_name);
428 goto bail;
429 }
430 memcpy(addr, in_addr, na * 4);
431
432 pr_debug("OF: bus is %s (na=%d, ns=%d) on %s\n",
433 bus->name, na, ns, parent->full_name);
434 of_dump_addr("OF: translating address:", addr, na);
435
436 /* Translate */
437 for (;;) {
438 /* Switch to parent bus */
439 of_node_put(dev);
440 dev = parent;
441 parent = of_get_parent(dev);
442
443 /* If root, we have finished */
444 if (parent == NULL) {
445 pr_debug("OF: reached root node\n");
446 result = of_read_number(addr, na);
447 break;
448 }
449
450 /* Get new parent bus and counts */
451 pbus = of_match_bus(parent);
452 pbus->count_cells(dev, &pna, &pns);
453 if (!OF_CHECK_COUNTS(pna, pns)) {
454 printk(KERN_ERR "prom_parse: Bad cell count for %s\n",
455 dev->full_name);
456 break;
457 }
458
459 pr_debug("OF: parent bus is %s (na=%d, ns=%d) on %s\n",
460 pbus->name, pna, pns, parent->full_name);
461
462 /* Apply bus translation */
463 if (of_translate_one(dev, bus, pbus, addr, na, ns, pna, rprop))
464 break;
465
466 /* Complete the move up one level */
467 na = pna;
468 ns = pns;
469 bus = pbus;
470
471 of_dump_addr("OF: one level translation:", addr, na);
472 }
473 bail:
474 of_node_put(parent);
475 of_node_put(dev);
476
477 return result;
478}
479
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +0100480u64 of_translate_address(struct device_node *dev, const __be32 *in_addr)
Grant Likelydbbdee92010-06-08 07:48:10 -0600481{
482 return __of_translate_address(dev, in_addr, "ranges");
483}
484EXPORT_SYMBOL(of_translate_address);
485
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +0100486u64 of_translate_dma_address(struct device_node *dev, const __be32 *in_addr)
Grant Likelydbbdee92010-06-08 07:48:10 -0600487{
488 return __of_translate_address(dev, in_addr, "dma-ranges");
489}
490EXPORT_SYMBOL(of_translate_dma_address);
491
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +0100492const __be32 *of_get_address(struct device_node *dev, int index, u64 *size,
Grant Likelydbbdee92010-06-08 07:48:10 -0600493 unsigned int *flags)
494{
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +0100495 const __be32 *prop;
Grant Likelydbbdee92010-06-08 07:48:10 -0600496 unsigned int psize;
497 struct device_node *parent;
498 struct of_bus *bus;
499 int onesize, i, na, ns;
500
501 /* Get parent & match bus type */
502 parent = of_get_parent(dev);
503 if (parent == NULL)
504 return NULL;
505 bus = of_match_bus(parent);
506 bus->count_cells(dev, &na, &ns);
507 of_node_put(parent);
508 if (!OF_CHECK_COUNTS(na, ns))
509 return NULL;
510
511 /* Get "reg" or "assigned-addresses" property */
512 prop = of_get_property(dev, bus->addresses, &psize);
513 if (prop == NULL)
514 return NULL;
515 psize /= 4;
516
517 onesize = na + ns;
518 for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++)
519 if (i == index) {
520 if (size)
521 *size = of_read_number(prop + na, ns);
522 if (flags)
523 *flags = bus->get_flags(prop);
524 return prop;
525 }
526 return NULL;
527}
528EXPORT_SYMBOL(of_get_address);
529
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +0100530static int __of_address_to_resource(struct device_node *dev,
531 const __be32 *addrp, u64 size, unsigned int flags,
Grant Likelydbbdee92010-06-08 07:48:10 -0600532 struct resource *r)
Grant Likely1f5bef32010-06-08 07:48:09 -0600533{
534 u64 taddr;
535
536 if ((flags & (IORESOURCE_IO | IORESOURCE_MEM)) == 0)
537 return -EINVAL;
538 taddr = of_translate_address(dev, addrp);
539 if (taddr == OF_BAD_ADDR)
540 return -EINVAL;
541 memset(r, 0, sizeof(struct resource));
542 if (flags & IORESOURCE_IO) {
543 unsigned long port;
544 port = pci_address_to_pio(taddr);
545 if (port == (unsigned long)-1)
546 return -EINVAL;
547 r->start = port;
548 r->end = port + size - 1;
549 } else {
550 r->start = taddr;
551 r->end = taddr + size - 1;
552 }
553 r->flags = flags;
Grant Likelyd3571c32010-06-08 07:48:12 -0600554 r->name = dev->full_name;
Grant Likely1f5bef32010-06-08 07:48:09 -0600555 return 0;
556}
557
558/**
559 * of_address_to_resource - Translate device tree address and return as resource
560 *
561 * Note that if your address is a PIO address, the conversion will fail if
562 * the physical address can't be internally converted to an IO token with
563 * pci_address_to_pio(), that is because it's either called to early or it
564 * can't be matched to any host bridge IO space
565 */
566int of_address_to_resource(struct device_node *dev, int index,
567 struct resource *r)
568{
Sebastian Andrzej Siewior0131d892010-12-01 10:54:46 +0100569 const __be32 *addrp;
Grant Likely1f5bef32010-06-08 07:48:09 -0600570 u64 size;
571 unsigned int flags;
572
573 addrp = of_get_address(dev, index, &size, &flags);
574 if (addrp == NULL)
575 return -EINVAL;
576 return __of_address_to_resource(dev, addrp, size, flags, r);
577}
578EXPORT_SYMBOL_GPL(of_address_to_resource);
579
Grant Likely90e33f62011-07-05 23:42:28 -0600580struct device_node *of_find_matching_node_by_address(struct device_node *from,
581 const struct of_device_id *matches,
582 u64 base_address)
583{
584 struct device_node *dn = of_find_matching_node(from, matches);
585 struct resource res;
586
587 while (dn) {
588 if (of_address_to_resource(dn, 0, &res))
589 continue;
590 if (res.start == base_address)
591 return dn;
592 dn = of_find_matching_node(dn, matches);
593 }
594
595 return NULL;
596}
597
Grant Likely1f5bef32010-06-08 07:48:09 -0600598
Grant Likely6b884a82010-06-08 07:48:09 -0600599/**
600 * of_iomap - Maps the memory mapped IO for a given device_node
601 * @device: the device whose io range will be mapped
602 * @index: index of the io range
603 *
604 * Returns a pointer to the mapped memory
605 */
606void __iomem *of_iomap(struct device_node *np, int index)
607{
608 struct resource res;
609
610 if (of_address_to_resource(np, index, &res))
611 return NULL;
612
Felipe Balbi28c1b6d2011-07-22 22:47:21 +0300613 return ioremap(res.start, resource_size(&res));
Grant Likely6b884a82010-06-08 07:48:09 -0600614}
615EXPORT_SYMBOL(of_iomap);