drivers/of/of_numa.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * OF NUMA Parsing support.
   4  *
   5  * Copyright (C) 2015 - 2016 Cavium Inc.
   6  */
   7
   8 #define pr_fmt(fmt) "OF: NUMA: " fmt
   9
  10 #include <linux/of.h>
  11 #include <linux/of_address.h>
  12 #include <linux/nodemask.h>
  13
  14 #include <asm/numa.h>
  15
  16 /* define default numa node to 0 */
  17 #define DEFAULT_NODE 0
  18
  19 /*
  20  * Even though we connect cpus to numa domains later in SMP
  21  * init, we need to know the node ids now for all cpus.
  22 */
  23 static void __init of_numa_parse_cpu_nodes(void)
  24 {
  25         u32 nid;
  26         int r;
  27         struct device_node *cpus;
  28         struct device_node *np = NULL;
  29
  30         cpus = of_find_node_by_path("/cpus");
  31         if (!cpus)
  32                 return;
  33
  34         for_each_child_of_node(cpus, np) {
  35                 /* Skip things that are not CPUs */
  36                 if (of_node_cmp(np->type, "cpu") != 0)
  37                         continue;
  38
  39                 r = of_property_read_u32(np, "numa-node-id", &nid);
  40                 if (r)
  41                         continue;
  42
  43                 pr_debug("CPU on %u\n", nid);
  44                 if (nid >= MAX_NUMNODES)
  45                         pr_warn("Node id %u exceeds maximum value\n", nid);
  46                 else
  47                         node_set(nid, numa_nodes_parsed);
  48         }
  49
  50         of_node_put(cpus);
  51 }
  52
  53 static int __init of_numa_parse_memory_nodes(void)
  54 {
  55         struct device_node *np = NULL;
  56         struct resource rsrc;
  57         u32 nid;
  58         int i, r;
  59
  60         for_each_node_by_type(np, "memory") {
  61                 r = of_property_read_u32(np, "numa-node-id", &nid);
  62                 if (r == -EINVAL)
  63                         /*
  64                          * property doesn't exist if -EINVAL, continue
  65                          * looking for more memory nodes with
  66                          * "numa-node-id" property
  67                          */
  68                         continue;
  69
  70                 if (nid >= MAX_NUMNODES) {
  71                         pr_warn("Node id %u exceeds maximum value\n", nid);
  72                         r = -EINVAL;
  73                 }
  74
  75                 for (i = 0; !r && !of_address_to_resource(np, i, &rsrc); i++)
  76                         r = numa_add_memblk(nid, rsrc.start, rsrc.end + 1);
  77
  78                 if (!i || r) {
  79                         of_node_put(np);
  80                         pr_err("bad property in memory node\n");
  81                         return r ? : -EINVAL;
  82                 }
  83         }
  84
  85         return 0;
  86 }
  87
  88 static int __init of_numa_parse_distance_map_v1(struct device_node *map)
  89 {
  90         const __be32 *matrix;
  91         int entry_count;
  92         int i;
  93
  94         pr_info("parsing numa-distance-map-v1\n");
  95
  96         matrix = of_get_property(map, "distance-matrix", NULL);
  97         if (!matrix) {
  98                 pr_err("No distance-matrix property in distance-map\n");
  99                 return -EINVAL;
 100         }
 101
 102         entry_count = of_property_count_u32_elems(map, "distance-matrix");
 103         if (entry_count <= 0) {
 104                 pr_err("Invalid distance-matrix\n");
 105                 return -EINVAL;
 106         }
 107
 108         for (i = 0; i + 2 < entry_count; i += 3) {
 109                 u32 nodea, nodeb, distance;
 110
 111                 nodea = of_read_number(matrix, 1);
 112                 matrix++;
 113                 nodeb = of_read_number(matrix, 1);
 114                 matrix++;
 115                 distance = of_read_number(matrix, 1);
 116                 matrix++;
 117
 118                 if ((nodea == nodeb && distance != LOCAL_DISTANCE) ||
 119                     (nodea != nodeb && distance <= LOCAL_DISTANCE)) {
 120                         pr_err("Invalid distance[node%d -> node%d] = %d\n",
 121                                nodea, nodeb, distance);
 122                         return -EINVAL;
 123                 }
 124
 125                 numa_set_distance(nodea, nodeb, distance);
 126
 127                 /* Set default distance of node B->A same as A->B */
 128                 if (nodeb > nodea)
 129                         numa_set_distance(nodeb, nodea, distance);
 130         }
 131
 132         return 0;
 133 }
 134
 135 static int __init of_numa_parse_distance_map(void)
 136 {
 137         int ret = 0;
 138         struct device_node *np;
 139
 140         np = of_find_compatible_node(NULL, NULL,
 141                                      "numa-distance-map-v1");
 142         if (np)
 143                 ret = of_numa_parse_distance_map_v1(np);
 144
 145         of_node_put(np);
 146         return ret;
 147 }
 148
 149 int of_node_to_nid(struct device_node *device)
 150 {
 151         struct device_node *np;
 152         u32 nid;
 153         int r = -ENODATA;
 154
 155         np = of_node_get(device);
 156
 157         while (np) {
 158                 r = of_property_read_u32(np, "numa-node-id", &nid);
 159                 /*
 160                  * -EINVAL indicates the property was not found, and
 161                  *  we walk up the tree trying to find a parent with a
 162                  *  "numa-node-id".  Any other type of error indicates
 163                  *  a bad device tree and we give up.
 164                  */
 165                 if (r != -EINVAL)
 166                         break;
 167
 168                 np = of_get_next_parent(np);
 169         }
 170         if (np && r)
 171                 pr_warn("Invalid \"numa-node-id\" property in node %pOFn\n",
 172                         np);
 173         of_node_put(np);
 174
 175         /*
 176          * If numa=off passed on command line, or with a defective
 177          * device tree, the nid may not be in the set of possible
 178          * nodes.  Check for this case and return NUMA_NO_NODE.
 179          */
 180         if (!r && nid < MAX_NUMNODES && node_possible(nid))
 181                 return nid;
 182
 183         return NUMA_NO_NODE;
 184 }
 185
 186 int __init of_numa_init(void)
 187 {
 188         int r;
 189
 190         of_numa_parse_cpu_nodes();
 191         r = of_numa_parse_memory_nodes();
 192         if (r)
 193                 return r;
 194         return of_numa_parse_distance_map();
 195 }