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)
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(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);
211