arm64: dts: rockchip: enable dmc and set A53 1.5G voltage to 1.1V on rk3399 mid
[firefly-linux-kernel-4.4.55.git] / drivers / of / address.c
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/sizes.h>
9 #include <linux/slab.h>
10 #include <linux/string.h>
11
12 /* Max address size we deal with */
13 #define OF_MAX_ADDR_CELLS       4
14 #define OF_CHECK_ADDR_COUNT(na) ((na) > 0 && (na) <= OF_MAX_ADDR_CELLS)
15 #define OF_CHECK_COUNTS(na, ns) (OF_CHECK_ADDR_COUNT(na) && (ns) > 0)
16
17 static struct of_bus *of_match_bus(struct device_node *np);
18 static int __of_address_to_resource(struct device_node *dev,
19                 const __be32 *addrp, u64 size, unsigned int flags,
20                 const char *name, struct resource *r);
21
22 /* Debug utility */
23 #ifdef DEBUG
24 static void of_dump_addr(const char *s, const __be32 *addr, int na)
25 {
26         printk(KERN_DEBUG "%s", s);
27         while (na--)
28                 printk(" %08x", be32_to_cpu(*(addr++)));
29         printk("\n");
30 }
31 #else
32 static void of_dump_addr(const char *s, const __be32 *addr, int na) { }
33 #endif
34
35 /* Callbacks for bus specific translators */
36 struct of_bus {
37         const char      *name;
38         const char      *addresses;
39         int             (*match)(struct device_node *parent);
40         void            (*count_cells)(struct device_node *child,
41                                        int *addrc, int *sizec);
42         u64             (*map)(__be32 *addr, const __be32 *range,
43                                 int na, int ns, int pna);
44         int             (*translate)(__be32 *addr, u64 offset, int na);
45         unsigned int    (*get_flags)(const __be32 *addr);
46 };
47
48 /*
49  * Default translator (generic bus)
50  */
51
52 static void of_bus_default_count_cells(struct device_node *dev,
53                                        int *addrc, int *sizec)
54 {
55         if (addrc)
56                 *addrc = of_n_addr_cells(dev);
57         if (sizec)
58                 *sizec = of_n_size_cells(dev);
59 }
60
61 static u64 of_bus_default_map(__be32 *addr, const __be32 *range,
62                 int na, int ns, int pna)
63 {
64         u64 cp, s, da;
65
66         cp = of_read_number(range, na);
67         s  = of_read_number(range + na + pna, ns);
68         da = of_read_number(addr, na);
69
70         pr_debug("OF: default map, cp=%llx, s=%llx, da=%llx\n",
71                  (unsigned long long)cp, (unsigned long long)s,
72                  (unsigned long long)da);
73
74         if (da < cp || da >= (cp + s))
75                 return OF_BAD_ADDR;
76         return da - cp;
77 }
78
79 static int of_bus_default_translate(__be32 *addr, u64 offset, int na)
80 {
81         u64 a = of_read_number(addr, na);
82         memset(addr, 0, na * 4);
83         a += offset;
84         if (na > 1)
85                 addr[na - 2] = cpu_to_be32(a >> 32);
86         addr[na - 1] = cpu_to_be32(a & 0xffffffffu);
87
88         return 0;
89 }
90
91 static unsigned int of_bus_default_get_flags(const __be32 *addr)
92 {
93         return IORESOURCE_MEM;
94 }
95
96 #ifdef CONFIG_OF_ADDRESS_PCI
97 /*
98  * PCI bus specific translator
99  */
100
101 static int of_bus_pci_match(struct device_node *np)
102 {
103         /*
104          * "pciex" is PCI Express
105          * "vci" is for the /chaos bridge on 1st-gen PCI powermacs
106          * "ht" is hypertransport
107          */
108         return !strcmp(np->type, "pci") || !strcmp(np->type, "pciex") ||
109                 !strcmp(np->type, "vci") || !strcmp(np->type, "ht");
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 unsigned int of_bus_pci_get_flags(const __be32 *addr)
122 {
123         unsigned int flags = 0;
124         u32 w = be32_to_cpup(addr);
125
126         switch((w >> 24) & 0x03) {
127         case 0x01:
128                 flags |= IORESOURCE_IO;
129                 break;
130         case 0x02: /* 32 bits */
131         case 0x03: /* 64 bits */
132                 flags |= IORESOURCE_MEM;
133                 break;
134         }
135         if (w & 0x40000000)
136                 flags |= IORESOURCE_PREFETCH;
137         return flags;
138 }
139
140 static u64 of_bus_pci_map(__be32 *addr, const __be32 *range, int na, int ns,
141                 int pna)
142 {
143         u64 cp, s, da;
144         unsigned int af, rf;
145
146         af = of_bus_pci_get_flags(addr);
147         rf = of_bus_pci_get_flags(range);
148
149         /* Check address type match */
150         if ((af ^ rf) & (IORESOURCE_MEM | IORESOURCE_IO))
151                 return OF_BAD_ADDR;
152
153         /* Read address values, skipping high cell */
154         cp = of_read_number(range + 1, na - 1);
155         s  = of_read_number(range + na + pna, ns);
156         da = of_read_number(addr + 1, na - 1);
157
158         pr_debug("OF: PCI map, cp=%llx, s=%llx, da=%llx\n",
159                  (unsigned long long)cp, (unsigned long long)s,
160                  (unsigned long long)da);
161
162         if (da < cp || da >= (cp + s))
163                 return OF_BAD_ADDR;
164         return da - cp;
165 }
166
167 static int of_bus_pci_translate(__be32 *addr, u64 offset, int na)
168 {
169         return of_bus_default_translate(addr + 1, offset, na - 1);
170 }
171 #endif /* CONFIG_OF_ADDRESS_PCI */
172
173 #ifdef CONFIG_PCI
174 const __be32 *of_get_pci_address(struct device_node *dev, int bar_no, u64 *size,
175                         unsigned int *flags)
176 {
177         const __be32 *prop;
178         unsigned int psize;
179         struct device_node *parent;
180         struct of_bus *bus;
181         int onesize, i, na, ns;
182
183         /* Get parent & match bus type */
184         parent = of_get_parent(dev);
185         if (parent == NULL)
186                 return NULL;
187         bus = of_match_bus(parent);
188         if (strcmp(bus->name, "pci")) {
189                 of_node_put(parent);
190                 return NULL;
191         }
192         bus->count_cells(dev, &na, &ns);
193         of_node_put(parent);
194         if (!OF_CHECK_ADDR_COUNT(na))
195                 return NULL;
196
197         /* Get "reg" or "assigned-addresses" property */
198         prop = of_get_property(dev, bus->addresses, &psize);
199         if (prop == NULL)
200                 return NULL;
201         psize /= 4;
202
203         onesize = na + ns;
204         for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++) {
205                 u32 val = be32_to_cpu(prop[0]);
206                 if ((val & 0xff) == ((bar_no * 4) + PCI_BASE_ADDRESS_0)) {
207                         if (size)
208                                 *size = of_read_number(prop + na, ns);
209                         if (flags)
210                                 *flags = bus->get_flags(prop);
211                         return prop;
212                 }
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 __be32    *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, NULL, r);
229 }
230 EXPORT_SYMBOL_GPL(of_pci_address_to_resource);
231
232 int of_pci_range_parser_init(struct of_pci_range_parser *parser,
233                                 struct device_node *node)
234 {
235         const int na = 3, ns = 2;
236         int rlen;
237
238         parser->node = node;
239         parser->pna = of_n_addr_cells(node);
240         parser->np = parser->pna + na + ns;
241
242         parser->range = of_get_property(node, "ranges", &rlen);
243         if (parser->range == NULL)
244                 return -ENOENT;
245
246         parser->end = parser->range + rlen / sizeof(__be32);
247
248         return 0;
249 }
250 EXPORT_SYMBOL_GPL(of_pci_range_parser_init);
251
252 struct of_pci_range *of_pci_range_parser_one(struct of_pci_range_parser *parser,
253                                                 struct of_pci_range *range)
254 {
255         const int na = 3, ns = 2;
256
257         if (!range)
258                 return NULL;
259
260         if (!parser->range || parser->range + parser->np > parser->end)
261                 return NULL;
262
263         range->pci_space = parser->range[0];
264         range->flags = of_bus_pci_get_flags(parser->range);
265         range->pci_addr = of_read_number(parser->range + 1, ns);
266         range->cpu_addr = of_translate_address(parser->node,
267                                 parser->range + na);
268         range->size = of_read_number(parser->range + parser->pna + na, ns);
269
270         parser->range += parser->np;
271
272         /* Now consume following elements while they are contiguous */
273         while (parser->range + parser->np <= parser->end) {
274                 u32 flags, pci_space;
275                 u64 pci_addr, cpu_addr, size;
276
277                 pci_space = be32_to_cpup(parser->range);
278                 flags = of_bus_pci_get_flags(parser->range);
279                 pci_addr = of_read_number(parser->range + 1, ns);
280                 cpu_addr = of_translate_address(parser->node,
281                                 parser->range + na);
282                 size = of_read_number(parser->range + parser->pna + na, ns);
283
284                 if (flags != range->flags)
285                         break;
286                 if (pci_addr != range->pci_addr + range->size ||
287                     cpu_addr != range->cpu_addr + range->size)
288                         break;
289
290                 range->size += size;
291                 parser->range += parser->np;
292         }
293
294         return range;
295 }
296 EXPORT_SYMBOL_GPL(of_pci_range_parser_one);
297
298 /*
299  * of_pci_range_to_resource - Create a resource from an of_pci_range
300  * @range:      the PCI range that describes the resource
301  * @np:         device node where the range belongs to
302  * @res:        pointer to a valid resource that will be updated to
303  *              reflect the values contained in the range.
304  *
305  * Returns EINVAL if the range cannot be converted to resource.
306  *
307  * Note that if the range is an IO range, the resource will be converted
308  * using pci_address_to_pio() which can fail if it is called too early or
309  * if the range cannot be matched to any host bridge IO space (our case here).
310  * To guard against that we try to register the IO range first.
311  * If that fails we know that pci_address_to_pio() will do too.
312  */
313 int of_pci_range_to_resource(struct of_pci_range *range,
314                              struct device_node *np, struct resource *res)
315 {
316         int err;
317         res->flags = range->flags;
318         res->parent = res->child = res->sibling = NULL;
319         res->name = np->full_name;
320
321         if (res->flags & IORESOURCE_IO) {
322                 unsigned long port;
323                 err = pci_register_io_range(range->cpu_addr, range->size);
324                 if (err)
325                         goto invalid_range;
326                 port = pci_address_to_pio(range->cpu_addr);
327                 if (port == (unsigned long)-1) {
328                         err = -EINVAL;
329                         goto invalid_range;
330                 }
331                 res->start = port;
332         } else {
333                 if ((sizeof(resource_size_t) < 8) &&
334                     upper_32_bits(range->cpu_addr)) {
335                         err = -EINVAL;
336                         goto invalid_range;
337                 }
338
339                 res->start = range->cpu_addr;
340         }
341         res->end = res->start + range->size - 1;
342         return 0;
343
344 invalid_range:
345         res->start = (resource_size_t)OF_BAD_ADDR;
346         res->end = (resource_size_t)OF_BAD_ADDR;
347         return err;
348 }
349 #endif /* CONFIG_PCI */
350
351 /*
352  * ISA bus specific translator
353  */
354
355 static int of_bus_isa_match(struct device_node *np)
356 {
357         return !strcmp(np->name, "isa");
358 }
359
360 static void of_bus_isa_count_cells(struct device_node *child,
361                                    int *addrc, int *sizec)
362 {
363         if (addrc)
364                 *addrc = 2;
365         if (sizec)
366                 *sizec = 1;
367 }
368
369 static u64 of_bus_isa_map(__be32 *addr, const __be32 *range, int na, int ns,
370                 int pna)
371 {
372         u64 cp, s, da;
373
374         /* Check address type match */
375         if ((addr[0] ^ range[0]) & cpu_to_be32(1))
376                 return OF_BAD_ADDR;
377
378         /* Read address values, skipping high cell */
379         cp = of_read_number(range + 1, na - 1);
380         s  = of_read_number(range + na + pna, ns);
381         da = of_read_number(addr + 1, na - 1);
382
383         pr_debug("OF: ISA map, cp=%llx, s=%llx, da=%llx\n",
384                  (unsigned long long)cp, (unsigned long long)s,
385                  (unsigned long long)da);
386
387         if (da < cp || da >= (cp + s))
388                 return OF_BAD_ADDR;
389         return da - cp;
390 }
391
392 static int of_bus_isa_translate(__be32 *addr, u64 offset, int na)
393 {
394         return of_bus_default_translate(addr + 1, offset, na - 1);
395 }
396
397 static unsigned int of_bus_isa_get_flags(const __be32 *addr)
398 {
399         unsigned int flags = 0;
400         u32 w = be32_to_cpup(addr);
401
402         if (w & 1)
403                 flags |= IORESOURCE_IO;
404         else
405                 flags |= IORESOURCE_MEM;
406         return flags;
407 }
408
409 /*
410  * Array of bus specific translators
411  */
412
413 static struct of_bus of_busses[] = {
414 #ifdef CONFIG_OF_ADDRESS_PCI
415         /* PCI */
416         {
417                 .name = "pci",
418                 .addresses = "assigned-addresses",
419                 .match = of_bus_pci_match,
420                 .count_cells = of_bus_pci_count_cells,
421                 .map = of_bus_pci_map,
422                 .translate = of_bus_pci_translate,
423                 .get_flags = of_bus_pci_get_flags,
424         },
425 #endif /* CONFIG_OF_ADDRESS_PCI */
426         /* ISA */
427         {
428                 .name = "isa",
429                 .addresses = "reg",
430                 .match = of_bus_isa_match,
431                 .count_cells = of_bus_isa_count_cells,
432                 .map = of_bus_isa_map,
433                 .translate = of_bus_isa_translate,
434                 .get_flags = of_bus_isa_get_flags,
435         },
436         /* Default */
437         {
438                 .name = "default",
439                 .addresses = "reg",
440                 .match = NULL,
441                 .count_cells = of_bus_default_count_cells,
442                 .map = of_bus_default_map,
443                 .translate = of_bus_default_translate,
444                 .get_flags = of_bus_default_get_flags,
445         },
446 };
447
448 static struct of_bus *of_match_bus(struct device_node *np)
449 {
450         int i;
451
452         for (i = 0; i < ARRAY_SIZE(of_busses); i++)
453                 if (!of_busses[i].match || of_busses[i].match(np))
454                         return &of_busses[i];
455         BUG();
456         return NULL;
457 }
458
459 static int of_empty_ranges_quirk(struct device_node *np)
460 {
461         if (IS_ENABLED(CONFIG_PPC)) {
462                 /* To save cycles, we cache the result for global "Mac" setting */
463                 static int quirk_state = -1;
464
465                 /* PA-SEMI sdc DT bug */
466                 if (of_device_is_compatible(np, "1682m-sdc"))
467                         return true;
468
469                 /* Make quirk cached */
470                 if (quirk_state < 0)
471                         quirk_state =
472                                 of_machine_is_compatible("Power Macintosh") ||
473                                 of_machine_is_compatible("MacRISC");
474                 return quirk_state;
475         }
476         return false;
477 }
478
479 static int of_translate_one(struct device_node *parent, struct of_bus *bus,
480                             struct of_bus *pbus, __be32 *addr,
481                             int na, int ns, int pna, const char *rprop)
482 {
483         const __be32 *ranges;
484         unsigned int rlen;
485         int rone;
486         u64 offset = OF_BAD_ADDR;
487
488         /*
489          * Normally, an absence of a "ranges" property means we are
490          * crossing a non-translatable boundary, and thus the addresses
491          * below the current cannot be converted to CPU physical ones.
492          * Unfortunately, while this is very clear in the spec, it's not
493          * what Apple understood, and they do have things like /uni-n or
494          * /ht nodes with no "ranges" property and a lot of perfectly
495          * useable mapped devices below them. Thus we treat the absence of
496          * "ranges" as equivalent to an empty "ranges" property which means
497          * a 1:1 translation at that level. It's up to the caller not to try
498          * to translate addresses that aren't supposed to be translated in
499          * the first place. --BenH.
500          *
501          * As far as we know, this damage only exists on Apple machines, so
502          * This code is only enabled on powerpc. --gcl
503          */
504         ranges = of_get_property(parent, rprop, &rlen);
505         if (ranges == NULL && !of_empty_ranges_quirk(parent)) {
506                 pr_debug("OF: no ranges; cannot translate\n");
507                 return 1;
508         }
509         if (ranges == NULL || rlen == 0) {
510                 offset = of_read_number(addr, na);
511                 memset(addr, 0, pna * 4);
512                 pr_debug("OF: empty ranges; 1:1 translation\n");
513                 goto finish;
514         }
515
516         pr_debug("OF: walking ranges...\n");
517
518         /* Now walk through the ranges */
519         rlen /= 4;
520         rone = na + pna + ns;
521         for (; rlen >= rone; rlen -= rone, ranges += rone) {
522                 offset = bus->map(addr, ranges, na, ns, pna);
523                 if (offset != OF_BAD_ADDR)
524                         break;
525         }
526         if (offset == OF_BAD_ADDR) {
527                 pr_debug("OF: not found !\n");
528                 return 1;
529         }
530         memcpy(addr, ranges + na, 4 * pna);
531
532  finish:
533         of_dump_addr("OF: parent translation for:", addr, pna);
534         pr_debug("OF: with offset: %llx\n", (unsigned long long)offset);
535
536         /* Translate it into parent bus space */
537         return pbus->translate(addr, offset, pna);
538 }
539
540 /*
541  * Translate an address from the device-tree into a CPU physical address,
542  * this walks up the tree and applies the various bus mappings on the
543  * way.
544  *
545  * Note: We consider that crossing any level with #size-cells == 0 to mean
546  * that translation is impossible (that is we are not dealing with a value
547  * that can be mapped to a cpu physical address). This is not really specified
548  * that way, but this is traditionally the way IBM at least do things
549  */
550 static u64 __of_translate_address(struct device_node *dev,
551                                   const __be32 *in_addr, const char *rprop)
552 {
553         struct device_node *parent = NULL;
554         struct of_bus *bus, *pbus;
555         __be32 addr[OF_MAX_ADDR_CELLS];
556         int na, ns, pna, pns;
557         u64 result = OF_BAD_ADDR;
558
559         pr_debug("OF: ** translation for device %s **\n", of_node_full_name(dev));
560
561         /* Increase refcount at current level */
562         of_node_get(dev);
563
564         /* Get parent & match bus type */
565         parent = of_get_parent(dev);
566         if (parent == NULL)
567                 goto bail;
568         bus = of_match_bus(parent);
569
570         /* Count address cells & copy address locally */
571         bus->count_cells(dev, &na, &ns);
572         if (!OF_CHECK_COUNTS(na, ns)) {
573                 pr_debug("OF: Bad cell count for %s\n", of_node_full_name(dev));
574                 goto bail;
575         }
576         memcpy(addr, in_addr, na * 4);
577
578         pr_debug("OF: bus is %s (na=%d, ns=%d) on %s\n",
579             bus->name, na, ns, of_node_full_name(parent));
580         of_dump_addr("OF: translating address:", addr, na);
581
582         /* Translate */
583         for (;;) {
584                 /* Switch to parent bus */
585                 of_node_put(dev);
586                 dev = parent;
587                 parent = of_get_parent(dev);
588
589                 /* If root, we have finished */
590                 if (parent == NULL) {
591                         pr_debug("OF: reached root node\n");
592                         result = of_read_number(addr, na);
593                         break;
594                 }
595
596                 /* Get new parent bus and counts */
597                 pbus = of_match_bus(parent);
598                 pbus->count_cells(dev, &pna, &pns);
599                 if (!OF_CHECK_COUNTS(pna, pns)) {
600                         printk(KERN_ERR "prom_parse: Bad cell count for %s\n",
601                                of_node_full_name(dev));
602                         break;
603                 }
604
605                 pr_debug("OF: parent bus is %s (na=%d, ns=%d) on %s\n",
606                     pbus->name, pna, pns, of_node_full_name(parent));
607
608                 /* Apply bus translation */
609                 if (of_translate_one(dev, bus, pbus, addr, na, ns, pna, rprop))
610                         break;
611
612                 /* Complete the move up one level */
613                 na = pna;
614                 ns = pns;
615                 bus = pbus;
616
617                 of_dump_addr("OF: one level translation:", addr, na);
618         }
619  bail:
620         of_node_put(parent);
621         of_node_put(dev);
622
623         return result;
624 }
625
626 u64 of_translate_address(struct device_node *dev, const __be32 *in_addr)
627 {
628         return __of_translate_address(dev, in_addr, "ranges");
629 }
630 EXPORT_SYMBOL(of_translate_address);
631
632 u64 of_translate_dma_address(struct device_node *dev, const __be32 *in_addr)
633 {
634         return __of_translate_address(dev, in_addr, "dma-ranges");
635 }
636 EXPORT_SYMBOL(of_translate_dma_address);
637
638 const __be32 *of_get_address(struct device_node *dev, int index, u64 *size,
639                     unsigned int *flags)
640 {
641         const __be32 *prop;
642         unsigned int psize;
643         struct device_node *parent;
644         struct of_bus *bus;
645         int onesize, i, na, ns;
646
647         /* Get parent & match bus type */
648         parent = of_get_parent(dev);
649         if (parent == NULL)
650                 return NULL;
651         bus = of_match_bus(parent);
652         bus->count_cells(dev, &na, &ns);
653         of_node_put(parent);
654         if (!OF_CHECK_ADDR_COUNT(na))
655                 return NULL;
656
657         /* Get "reg" or "assigned-addresses" property */
658         prop = of_get_property(dev, bus->addresses, &psize);
659         if (prop == NULL)
660                 return NULL;
661         psize /= 4;
662
663         onesize = na + ns;
664         for (i = 0; psize >= onesize; psize -= onesize, prop += onesize, i++)
665                 if (i == index) {
666                         if (size)
667                                 *size = of_read_number(prop + na, ns);
668                         if (flags)
669                                 *flags = bus->get_flags(prop);
670                         return prop;
671                 }
672         return NULL;
673 }
674 EXPORT_SYMBOL(of_get_address);
675
676 #ifdef PCI_IOBASE
677 struct io_range {
678         struct list_head list;
679         phys_addr_t start;
680         resource_size_t size;
681 };
682
683 static LIST_HEAD(io_range_list);
684 static DEFINE_SPINLOCK(io_range_lock);
685 #endif
686
687 /*
688  * Record the PCI IO range (expressed as CPU physical address + size).
689  * Return a negative value if an error has occured, zero otherwise
690  */
691 int __weak pci_register_io_range(phys_addr_t addr, resource_size_t size)
692 {
693         int err = 0;
694
695 #ifdef PCI_IOBASE
696         struct io_range *range;
697         resource_size_t allocated_size = 0;
698
699         /* check if the range hasn't been previously recorded */
700         spin_lock(&io_range_lock);
701         list_for_each_entry(range, &io_range_list, list) {
702                 if (addr >= range->start && addr + size <= range->start + size) {
703                         /* range already registered, bail out */
704                         goto end_register;
705                 }
706                 allocated_size += range->size;
707         }
708
709         /* range not registed yet, check for available space */
710         if (allocated_size + size - 1 > IO_SPACE_LIMIT) {
711                 /* if it's too big check if 64K space can be reserved */
712                 if (allocated_size + SZ_64K - 1 > IO_SPACE_LIMIT) {
713                         err = -E2BIG;
714                         goto end_register;
715                 }
716
717                 size = SZ_64K;
718                 pr_warn("Requested IO range too big, new size set to 64K\n");
719         }
720
721         /* add the range to the list */
722         range = kzalloc(sizeof(*range), GFP_ATOMIC);
723         if (!range) {
724                 err = -ENOMEM;
725                 goto end_register;
726         }
727
728         range->start = addr;
729         range->size = size;
730
731         list_add_tail(&range->list, &io_range_list);
732
733 end_register:
734         spin_unlock(&io_range_lock);
735 #endif
736
737         return err;
738 }
739
740 phys_addr_t pci_pio_to_address(unsigned long pio)
741 {
742         phys_addr_t address = (phys_addr_t)OF_BAD_ADDR;
743
744 #ifdef PCI_IOBASE
745         struct io_range *range;
746         resource_size_t allocated_size = 0;
747
748         if (pio > IO_SPACE_LIMIT)
749                 return address;
750
751         spin_lock(&io_range_lock);
752         list_for_each_entry(range, &io_range_list, list) {
753                 if (pio >= allocated_size && pio < allocated_size + range->size) {
754                         address = range->start + pio - allocated_size;
755                         break;
756                 }
757                 allocated_size += range->size;
758         }
759         spin_unlock(&io_range_lock);
760 #endif
761
762         return address;
763 }
764
765 unsigned long __weak pci_address_to_pio(phys_addr_t address)
766 {
767 #ifdef PCI_IOBASE
768         struct io_range *res;
769         resource_size_t offset = 0;
770         unsigned long addr = -1;
771
772         spin_lock(&io_range_lock);
773         list_for_each_entry(res, &io_range_list, list) {
774                 if (address >= res->start && address < res->start + res->size) {
775                         addr = address - res->start + offset;
776                         break;
777                 }
778                 offset += res->size;
779         }
780         spin_unlock(&io_range_lock);
781
782         return addr;
783 #else
784         if (address > IO_SPACE_LIMIT)
785                 return (unsigned long)-1;
786
787         return (unsigned long) address;
788 #endif
789 }
790
791 static int __of_address_to_resource(struct device_node *dev,
792                 const __be32 *addrp, u64 size, unsigned int flags,
793                 const char *name, struct resource *r)
794 {
795         u64 taddr;
796
797         if ((flags & (IORESOURCE_IO | IORESOURCE_MEM)) == 0)
798                 return -EINVAL;
799         taddr = of_translate_address(dev, addrp);
800         if (taddr == OF_BAD_ADDR)
801                 return -EINVAL;
802         memset(r, 0, sizeof(struct resource));
803         if (flags & IORESOURCE_IO) {
804                 unsigned long port;
805                 port = pci_address_to_pio(taddr);
806                 if (port == (unsigned long)-1)
807                         return -EINVAL;
808                 r->start = port;
809                 r->end = port + size - 1;
810         } else {
811                 r->start = taddr;
812                 r->end = taddr + size - 1;
813         }
814         r->flags = flags;
815         r->name = name ? name : dev->full_name;
816
817         return 0;
818 }
819
820 /**
821  * of_address_to_resource - Translate device tree address and return as resource
822  *
823  * Note that if your address is a PIO address, the conversion will fail if
824  * the physical address can't be internally converted to an IO token with
825  * pci_address_to_pio(), that is because it's either called to early or it
826  * can't be matched to any host bridge IO space
827  */
828 int of_address_to_resource(struct device_node *dev, int index,
829                            struct resource *r)
830 {
831         const __be32    *addrp;
832         u64             size;
833         unsigned int    flags;
834         const char      *name = NULL;
835
836         addrp = of_get_address(dev, index, &size, &flags);
837         if (addrp == NULL)
838                 return -EINVAL;
839
840         /* Get optional "reg-names" property to add a name to a resource */
841         of_property_read_string_index(dev, "reg-names", index, &name);
842
843         return __of_address_to_resource(dev, addrp, size, flags, name, r);
844 }
845 EXPORT_SYMBOL_GPL(of_address_to_resource);
846
847 struct device_node *of_find_matching_node_by_address(struct device_node *from,
848                                         const struct of_device_id *matches,
849                                         u64 base_address)
850 {
851         struct device_node *dn = of_find_matching_node(from, matches);
852         struct resource res;
853
854         while (dn) {
855                 if (!of_address_to_resource(dn, 0, &res) &&
856                     res.start == base_address)
857                         return dn;
858
859                 dn = of_find_matching_node(dn, matches);
860         }
861
862         return NULL;
863 }
864
865
866 /**
867  * of_iomap - Maps the memory mapped IO for a given device_node
868  * @device:     the device whose io range will be mapped
869  * @index:      index of the io range
870  *
871  * Returns a pointer to the mapped memory
872  */
873 void __iomem *of_iomap(struct device_node *np, int index)
874 {
875         struct resource res;
876
877         if (of_address_to_resource(np, index, &res))
878                 return NULL;
879
880         return ioremap(res.start, resource_size(&res));
881 }
882 EXPORT_SYMBOL(of_iomap);
883
884 /*
885  * of_io_request_and_map - Requests a resource and maps the memory mapped IO
886  *                         for a given device_node
887  * @device:     the device whose io range will be mapped
888  * @index:      index of the io range
889  * @name:       name of the resource
890  *
891  * Returns a pointer to the requested and mapped memory or an ERR_PTR() encoded
892  * error code on failure. Usage example:
893  *
894  *      base = of_io_request_and_map(node, 0, "foo");
895  *      if (IS_ERR(base))
896  *              return PTR_ERR(base);
897  */
898 void __iomem *of_io_request_and_map(struct device_node *np, int index,
899                                         const char *name)
900 {
901         struct resource res;
902         void __iomem *mem;
903
904         if (of_address_to_resource(np, index, &res))
905                 return IOMEM_ERR_PTR(-EINVAL);
906
907         if (!request_mem_region(res.start, resource_size(&res), name))
908                 return IOMEM_ERR_PTR(-EBUSY);
909
910         mem = ioremap(res.start, resource_size(&res));
911         if (!mem) {
912                 release_mem_region(res.start, resource_size(&res));
913                 return IOMEM_ERR_PTR(-ENOMEM);
914         }
915
916         return mem;
917 }
918 EXPORT_SYMBOL(of_io_request_and_map);
919
920 /**
921  * of_dma_get_range - Get DMA range info
922  * @np:         device node to get DMA range info
923  * @dma_addr:   pointer to store initial DMA address of DMA range
924  * @paddr:      pointer to store initial CPU address of DMA range
925  * @size:       pointer to store size of DMA range
926  *
927  * Look in bottom up direction for the first "dma-ranges" property
928  * and parse it.
929  *  dma-ranges format:
930  *      DMA addr (dma_addr)     : naddr cells
931  *      CPU addr (phys_addr_t)  : pna cells
932  *      size                    : nsize cells
933  *
934  * It returns -ENODEV if "dma-ranges" property was not found
935  * for this device in DT.
936  */
937 int of_dma_get_range(struct device_node *np, u64 *dma_addr, u64 *paddr, u64 *size)
938 {
939         struct device_node *node = of_node_get(np);
940         const __be32 *ranges = NULL;
941         int len, naddr, nsize, pna;
942         int ret = 0;
943         u64 dmaaddr;
944
945         if (!node)
946                 return -EINVAL;
947
948         while (1) {
949                 naddr = of_n_addr_cells(node);
950                 nsize = of_n_size_cells(node);
951                 node = of_get_next_parent(node);
952                 if (!node)
953                         break;
954
955                 ranges = of_get_property(node, "dma-ranges", &len);
956
957                 /* Ignore empty ranges, they imply no translation required */
958                 if (ranges && len > 0)
959                         break;
960
961                 /*
962                  * At least empty ranges has to be defined for parent node if
963                  * DMA is supported
964                  */
965                 if (!ranges)
966                         break;
967         }
968
969         if (!ranges) {
970                 pr_debug("%s: no dma-ranges found for node(%s)\n",
971                          __func__, np->full_name);
972                 ret = -ENODEV;
973                 goto out;
974         }
975
976         len /= sizeof(u32);
977
978         pna = of_n_addr_cells(node);
979
980         /* dma-ranges format:
981          * DMA addr     : naddr cells
982          * CPU addr     : pna cells
983          * size         : nsize cells
984          */
985         dmaaddr = of_read_number(ranges, naddr);
986         *paddr = of_translate_dma_address(np, ranges);
987         if (*paddr == OF_BAD_ADDR) {
988                 pr_err("%s: translation of DMA address(%pad) to CPU address failed node(%s)\n",
989                        __func__, dma_addr, np->full_name);
990                 ret = -EINVAL;
991                 goto out;
992         }
993         *dma_addr = dmaaddr;
994
995         *size = of_read_number(ranges + naddr + pna, nsize);
996
997         pr_debug("dma_addr(%llx) cpu_addr(%llx) size(%llx)\n",
998                  *dma_addr, *paddr, *size);
999
1000 out:
1001         of_node_put(node);
1002
1003         return ret;
1004 }
1005 EXPORT_SYMBOL_GPL(of_dma_get_range);
1006
1007 /**
1008  * of_dma_is_coherent - Check if device is coherent
1009  * @np: device node
1010  *
1011  * It returns true if "dma-coherent" property was found
1012  * for this device in DT.
1013  */
1014 bool of_dma_is_coherent(struct device_node *np)
1015 {
1016         struct device_node *node = of_node_get(np);
1017
1018         while (node) {
1019                 if (of_property_read_bool(node, "dma-coherent")) {
1020                         of_node_put(node);
1021                         return true;
1022                 }
1023                 node = of_get_next_parent(node);
1024         }
1025         of_node_put(node);
1026         return false;
1027 }
1028 EXPORT_SYMBOL_GPL(of_dma_is_coherent);