drivers/of/pdt.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /* pdt.c: OF PROM device tree support code.
   3  *
   4  * Paul Mackerras       August 1996.
   5  * Copyright (C) 1996-2005 Paul Mackerras.
   6  *
   7  *  Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
   8  *    {engebret|bergner}@us.ibm.com
   9  *
  10  *  Adapted for sparc by David S. Miller davem@davemloft.net
  11  *  Adapted for multiple architectures by Andres Salomon <dilinger@queued.net>
  12  */
  13
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/errno.h>
  17 #include <linux/mutex.h>
  18 #include <linux/slab.h>
  19 #include <linux/of.h>
  20 #include <linux/of_pdt.h>
  21
  22 static struct of_pdt_ops *of_pdt_prom_ops __initdata;
  23
  24 void __initdata (*of_pdt_build_more)(struct device_node *dp);
  25
  26 #if defined(CONFIG_SPARC)
  27 unsigned int of_pdt_unique_id __initdata;
  28
  29 #define of_pdt_incr_unique_id(p) do { \
  30         (p)->unique_id = of_pdt_unique_id++; \
  31 } while (0)
  32
  33 static char * __init of_pdt_build_full_name(struct device_node *dp)
  34 {
  35         return build_path_component(dp);
  36 }
  37
  38 #else /* CONFIG_SPARC */
  39
  40 static inline void of_pdt_incr_unique_id(void *p) { }
  41 static inline void irq_trans_init(struct device_node *dp) { }
  42
  43 static char * __init of_pdt_build_full_name(struct device_node *dp)
  44 {
  45         static int failsafe_id = 0; /* for generating unique names on failure */
  46         const char *name;
  47         char path[256];
  48         char *buf;
  49         int len;
  50
  51         if (!of_pdt_prom_ops->pkg2path(dp->phandle, path, sizeof(path), &len)) {
  52                 name = kbasename(path);
  53                 buf = prom_early_alloc(strlen(name) + 1);
  54                 strcpy(buf, name);
  55                 return buf;
  56         }
  57
  58         name = of_get_property(dp, "name", &len);
  59         buf = prom_early_alloc(len + 16);
  60         sprintf(buf, "%s@unknown%i", name, failsafe_id++);
  61         pr_err("%s: pkg2path failed; assigning %s\n", __func__, buf);
  62         return buf;
  63 }
  64
  65 #endif /* !CONFIG_SPARC */
  66
  67 static struct property * __init of_pdt_build_one_prop(phandle node, char *prev,
  68                                                char *special_name,
  69                                                void *special_val,
  70                                                int special_len)
  71 {
  72         static struct property *tmp = NULL;
  73         struct property *p;
  74         int err;
  75
  76         if (tmp) {
  77                 p = tmp;
  78                 memset(p, 0, sizeof(*p) + 32);
  79                 tmp = NULL;
  80         } else {
  81                 p = prom_early_alloc(sizeof(struct property) + 32);
  82                 of_pdt_incr_unique_id(p);
  83         }
  84
  85         p->name = (char *) (p + 1);
  86         if (special_name) {
  87                 strcpy(p->name, special_name);
  88                 p->length = special_len;
  89                 p->value = prom_early_alloc(special_len);
  90                 memcpy(p->value, special_val, special_len);
  91         } else {
  92                 err = of_pdt_prom_ops->nextprop(node, prev, p->name);
  93                 if (err) {
  94                         tmp = p;
  95                         return NULL;
  96                 }
  97                 p->length = of_pdt_prom_ops->getproplen(node, p->name);
  98                 if (p->length <= 0) {
  99                         p->length = 0;
 100                 } else {
 101                         int len;
 102
 103                         p->value = prom_early_alloc(p->length + 1);
 104                         len = of_pdt_prom_ops->getproperty(node, p->name,
 105                                         p->value, p->length);
 106                         if (len <= 0)
 107                                 p->length = 0;
 108                         ((unsigned char *)p->value)[p->length] = '\0';
 109                 }
 110         }
 111         return p;
 112 }
 113
 114 static struct property * __init of_pdt_build_prop_list(phandle node)
 115 {
 116         struct property *head, *tail;
 117
 118         head = tail = of_pdt_build_one_prop(node, NULL,
 119                                      ".node", &node, sizeof(node));
 120
 121         tail->next = of_pdt_build_one_prop(node, NULL, NULL, NULL, 0);
 122         tail = tail->next;
 123         while(tail) {
 124                 tail->next = of_pdt_build_one_prop(node, tail->name,
 125                                             NULL, NULL, 0);
 126                 tail = tail->next;
 127         }
 128
 129         return head;
 130 }
 131
 132 static char * __init of_pdt_get_one_property(phandle node, const char *name)
 133 {
 134         char *buf = "<NULL>";
 135         int len;
 136
 137         len = of_pdt_prom_ops->getproplen(node, name);
 138         if (len > 0) {
 139                 buf = prom_early_alloc(len);
 140                 len = of_pdt_prom_ops->getproperty(node, name, buf, len);
 141         }
 142
 143         return buf;
 144 }
 145
 146 static struct device_node * __init of_pdt_create_node(phandle node,
 147                                                     struct device_node *parent)
 148 {
 149         struct device_node *dp;
 150
 151         if (!node)
 152                 return NULL;
 153
 154         dp = prom_early_alloc(sizeof(*dp));
 155         of_node_init(dp);
 156         of_pdt_incr_unique_id(dp);
 157         dp->parent = parent;
 158
 159         dp->name = of_pdt_get_one_property(node, "name");
 160         dp->type = of_pdt_get_one_property(node, "device_type");
 161         dp->phandle = node;
 162
 163         dp->properties = of_pdt_build_prop_list(node);
 164
 165         dp->full_name = of_pdt_build_full_name(dp);
 166
 167         irq_trans_init(dp);
 168
 169         return dp;
 170 }
 171
 172 static struct device_node * __init of_pdt_build_tree(struct device_node *parent,
 173                                                    phandle node)
 174 {
 175         struct device_node *ret = NULL, *prev_sibling = NULL;
 176         struct device_node *dp;
 177
 178         while (1) {
 179                 dp = of_pdt_create_node(node, parent);
 180                 if (!dp)
 181                         break;
 182
 183                 if (prev_sibling)
 184                         prev_sibling->sibling = dp;
 185
 186                 if (!ret)
 187                         ret = dp;
 188                 prev_sibling = dp;
 189
 190                 dp->child = of_pdt_build_tree(dp, of_pdt_prom_ops->getchild(node));
 191
 192                 if (of_pdt_build_more)
 193                         of_pdt_build_more(dp);
 194
 195                 node = of_pdt_prom_ops->getsibling(node);
 196         }
 197
 198         return ret;
 199 }
 200
 201 static void * __init kernel_tree_alloc(u64 size, u64 align)
 202 {
 203         return prom_early_alloc(size);
 204 }
 205
 206 void __init of_pdt_build_devicetree(phandle root_node, struct of_pdt_ops *ops)
 207 {
 208         BUG_ON(!ops);
 209         of_pdt_prom_ops = ops;
 210
 211         of_root = of_pdt_create_node(root_node, NULL);
 212         of_root->full_name = "/";
 213
 214         of_root->child = of_pdt_build_tree(of_root,
 215                                 of_pdt_prom_ops->getchild(of_root->phandle));
 216
 217         /* Get pointer to "/chosen" and "/aliases" nodes for use everywhere */
 218         of_alias_scan(kernel_tree_alloc);
 219 }