projects/linux·blob master · refs

210 lines · 6.2 KiB

1// SPDX-License-Identifier: GPL-2.0
2#include <linux/cpu.h>
3#include <linux/kernel.h>
4#include <linux/of.h>
5
6/**
7 * of_get_cpu_hwid - Get the hardware ID from a CPU device node
8 *
9 * @cpun: CPU number(logical index) for which device node is required
10 * @thread: The local thread number to get the hardware ID for.
11 *
12 * Return: The hardware ID for the CPU node or ~0ULL if not found.
13 */
14u64 of_get_cpu_hwid(struct device_node *cpun, unsigned int thread)
15{
16 const __be32 *cell;
17 int ac, len;
18
19 ac = of_n_addr_cells(cpun);
20 cell = of_get_property(cpun, "reg", &len);
21 if (!cell || !ac || ((sizeof(*cell) * ac * (thread + 1)) > len))
22 return ~0ULL;
23
24 cell += ac * thread;
25 return of_read_number(cell, ac);
26}
27
28/*
29 * arch_match_cpu_phys_id - Match the given logical CPU and physical id
30 *
31 * @cpu: logical cpu index of a core/thread
32 * @phys_id: physical identifier of a core/thread
33 *
34 * CPU logical to physical index mapping is architecture specific.
35 * However this __weak function provides a default match of physical
36 * id to logical cpu index. phys_id provided here is usually values read
37 * from the device tree which must match the hardware internal registers.
38 *
39 * Returns true if the physical identifier and the logical cpu index
40 * correspond to the same core/thread, false otherwise.
41 */
42bool __weak arch_match_cpu_phys_id(int cpu, u64 phys_id)
43{
44 return (u32)phys_id == cpu;
45}
46
47/*
48 * Checks if the given "prop_name" property holds the physical id of the
49 * core/thread corresponding to the logical cpu 'cpu'. If 'thread' is not
50 * NULL, local thread number within the core is returned in it.
51 */
52static bool __of_find_n_match_cpu_property(struct device_node *cpun,
53 const char *prop_name, int cpu, unsigned int *thread)
54{
55 const __be32 *cell;
56 int ac, prop_len, tid;
57 u64 hwid;
58
59 ac = of_n_addr_cells(cpun);
60 cell = of_get_property(cpun, prop_name, &prop_len);
61 if (!cell && !ac && arch_match_cpu_phys_id(cpu, 0))
62 return true;
63 if (!cell || !ac || ac > 2)
64 return false;
65 prop_len /= sizeof(*cell) * ac;
66 for (tid = 0; tid < prop_len; tid++) {
67 hwid = of_read_number(cell, ac);
68 if (arch_match_cpu_phys_id(cpu, hwid)) {
69 if (thread)
70 *thread = tid;
71 return true;
72 }
73 cell += ac;
74 }
75 return false;
76}
77
78/*
79 * arch_find_n_match_cpu_physical_id - See if the given device node is
80 * for the cpu corresponding to logical cpu 'cpu'. Return true if so,
81 * else false. If 'thread' is non-NULL, the local thread number within the
82 * core is returned in it.
83 */
84bool __weak arch_find_n_match_cpu_physical_id(struct device_node *cpun,
85 int cpu, unsigned int *thread)
86{
87 /* Check for non-standard "ibm,ppc-interrupt-server#s" property
88 * for thread ids on PowerPC. If it doesn't exist fallback to
89 * standard "reg" property.
90 */
91 if (IS_ENABLED(CONFIG_PPC) &&
92 __of_find_n_match_cpu_property(cpun,
93 "ibm,ppc-interrupt-server#s",
94 cpu, thread))
95 return true;
96
97 return __of_find_n_match_cpu_property(cpun, "reg", cpu, thread);
98}
99
100/**
101 * of_get_cpu_node - Get device node associated with the given logical CPU
102 *
103 * @cpu: CPU number(logical index) for which device node is required
104 * @thread: if not NULL, local thread number within the physical core is
105 * returned
106 *
107 * The main purpose of this function is to retrieve the device node for the
108 * given logical CPU index. It should be used to initialize the of_node in
109 * cpu device. Once of_node in cpu device is populated, all the further
110 * references can use that instead.
111 *
112 * CPU logical to physical index mapping is architecture specific and is built
113 * before booting secondary cores. This function uses arch_match_cpu_phys_id
114 * which can be overridden by architecture specific implementation.
115 *
116 * Return: A node pointer for the logical cpu with refcount incremented, use
117 * of_node_put() on it when done. Returns NULL if not found.
118 */
119struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
120{
121 struct device_node *cpun;
122
123 for_each_of_cpu_node(cpun) {
124 if (arch_find_n_match_cpu_physical_id(cpun, cpu, thread))
125 return cpun;
126 }
127 return NULL;
128}
129EXPORT_SYMBOL(of_get_cpu_node);
130
131/**
132 * of_cpu_device_node_get: Get the CPU device_node for a given logical CPU number
133 *
134 * @cpu: The logical CPU number
135 *
136 * Return: Pointer to the device_node for CPU with its reference count
137 * incremented of the given logical CPU number or NULL if the CPU device_node
138 * is not found.
139 */
140struct device_node *of_cpu_device_node_get(int cpu)
141{
142 struct device *cpu_dev;
143 cpu_dev = get_cpu_device(cpu);
144 if (!cpu_dev)
145 return of_get_cpu_node(cpu, NULL);
146 return of_node_get(cpu_dev->of_node);
147}
148EXPORT_SYMBOL(of_cpu_device_node_get);
149
150/**
151 * of_cpu_node_to_id: Get the logical CPU number for a given device_node
152 *
153 * @cpu_node: Pointer to the device_node for CPU.
154 *
155 * Return: The logical CPU number of the given CPU device_node or -ENODEV if the
156 * CPU is not found.
157 */
158int of_cpu_node_to_id(struct device_node *cpu_node)
159{
160 int cpu;
161 bool found = false;
162 struct device_node *np;
163
164 for_each_possible_cpu(cpu) {
165 np = of_cpu_device_node_get(cpu);
166 found = (cpu_node == np);
167 of_node_put(np);
168 if (found)
169 return cpu;
170 }
171
172 return -ENODEV;
173}
174EXPORT_SYMBOL(of_cpu_node_to_id);
175
176/**
177 * of_get_cpu_state_node - Get CPU's idle state node at the given index
178 *
179 * @cpu_node: The device node for the CPU
180 * @index: The index in the list of the idle states
181 *
182 * Two generic methods can be used to describe a CPU's idle states, either via
183 * a flattened description through the "cpu-idle-states" binding or via the
184 * hierarchical layout, using the "power-domains" and the "domain-idle-states"
185 * bindings. This function check for both and returns the idle state node for
186 * the requested index.
187 *
188 * Return: An idle state node if found at @index. The refcount is incremented
189 * for it, so call of_node_put() on it when done. Returns NULL if not found.
190 */
191struct device_node *of_get_cpu_state_node(const struct device_node *cpu_node,
192 int index)
193{
194 struct of_phandle_args args;
195 int err;
196
197 err = of_parse_phandle_with_args(cpu_node, "power-domains",
198 "#power-domain-cells", 0, &args);
199 if (!err) {
200 struct device_node *state_node =
201 of_parse_phandle(args.np, "domain-idle-states", index);
202
203 of_node_put(args.np);
204 if (state_node)
205 return state_node;
206 }
207
208 return of_parse_phandle(cpu_node, "cpu-idle-states", index);
209}
210EXPORT_SYMBOL(of_get_cpu_state_node);