Merge tag 'mfd-for-linus-3.17' of git://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd
[firefly-linux-kernel-4.4.55.git] / drivers / base / cpu.c
1 /*
2  * CPU subsystem support
3  */
4
5 #include <linux/kernel.h>
6 #include <linux/module.h>
7 #include <linux/init.h>
8 #include <linux/sched.h>
9 #include <linux/cpu.h>
10 #include <linux/topology.h>
11 #include <linux/device.h>
12 #include <linux/node.h>
13 #include <linux/gfp.h>
14 #include <linux/slab.h>
15 #include <linux/percpu.h>
16 #include <linux/acpi.h>
17 #include <linux/of.h>
18 #include <linux/cpufeature.h>
19
20 #include "base.h"
21
22 static DEFINE_PER_CPU(struct device *, cpu_sys_devices);
23
24 static int cpu_subsys_match(struct device *dev, struct device_driver *drv)
25 {
26         /* ACPI style match is the only one that may succeed. */
27         if (acpi_driver_match_device(dev, drv))
28                 return 1;
29
30         return 0;
31 }
32
33 #ifdef CONFIG_HOTPLUG_CPU
34 static void change_cpu_under_node(struct cpu *cpu,
35                         unsigned int from_nid, unsigned int to_nid)
36 {
37         int cpuid = cpu->dev.id;
38         unregister_cpu_under_node(cpuid, from_nid);
39         register_cpu_under_node(cpuid, to_nid);
40         cpu->node_id = to_nid;
41 }
42
43 static int __ref cpu_subsys_online(struct device *dev)
44 {
45         struct cpu *cpu = container_of(dev, struct cpu, dev);
46         int cpuid = dev->id;
47         int from_nid, to_nid;
48         int ret;
49
50         from_nid = cpu_to_node(cpuid);
51         if (from_nid == NUMA_NO_NODE)
52                 return -ENODEV;
53
54         ret = cpu_up(cpuid);
55         /*
56          * When hot adding memory to memoryless node and enabling a cpu
57          * on the node, node number of the cpu may internally change.
58          */
59         to_nid = cpu_to_node(cpuid);
60         if (from_nid != to_nid)
61                 change_cpu_under_node(cpu, from_nid, to_nid);
62
63         return ret;
64 }
65
66 static int cpu_subsys_offline(struct device *dev)
67 {
68         return cpu_down(dev->id);
69 }
70
71 void unregister_cpu(struct cpu *cpu)
72 {
73         int logical_cpu = cpu->dev.id;
74
75         unregister_cpu_under_node(logical_cpu, cpu_to_node(logical_cpu));
76
77         device_unregister(&cpu->dev);
78         per_cpu(cpu_sys_devices, logical_cpu) = NULL;
79         return;
80 }
81
82 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
83 static ssize_t cpu_probe_store(struct device *dev,
84                                struct device_attribute *attr,
85                                const char *buf,
86                                size_t count)
87 {
88         ssize_t cnt;
89         int ret;
90
91         ret = lock_device_hotplug_sysfs();
92         if (ret)
93                 return ret;
94
95         cnt = arch_cpu_probe(buf, count);
96
97         unlock_device_hotplug();
98         return cnt;
99 }
100
101 static ssize_t cpu_release_store(struct device *dev,
102                                  struct device_attribute *attr,
103                                  const char *buf,
104                                  size_t count)
105 {
106         ssize_t cnt;
107         int ret;
108
109         ret = lock_device_hotplug_sysfs();
110         if (ret)
111                 return ret;
112
113         cnt = arch_cpu_release(buf, count);
114
115         unlock_device_hotplug();
116         return cnt;
117 }
118
119 static DEVICE_ATTR(probe, S_IWUSR, NULL, cpu_probe_store);
120 static DEVICE_ATTR(release, S_IWUSR, NULL, cpu_release_store);
121 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
122 #endif /* CONFIG_HOTPLUG_CPU */
123
124 struct bus_type cpu_subsys = {
125         .name = "cpu",
126         .dev_name = "cpu",
127         .match = cpu_subsys_match,
128 #ifdef CONFIG_HOTPLUG_CPU
129         .online = cpu_subsys_online,
130         .offline = cpu_subsys_offline,
131 #endif
132 };
133 EXPORT_SYMBOL_GPL(cpu_subsys);
134
135 #ifdef CONFIG_KEXEC
136 #include <linux/kexec.h>
137
138 static ssize_t show_crash_notes(struct device *dev, struct device_attribute *attr,
139                                 char *buf)
140 {
141         struct cpu *cpu = container_of(dev, struct cpu, dev);
142         ssize_t rc;
143         unsigned long long addr;
144         int cpunum;
145
146         cpunum = cpu->dev.id;
147
148         /*
149          * Might be reading other cpu's data based on which cpu read thread
150          * has been scheduled. But cpu data (memory) is allocated once during
151          * boot up and this data does not change there after. Hence this
152          * operation should be safe. No locking required.
153          */
154         addr = per_cpu_ptr_to_phys(per_cpu_ptr(crash_notes, cpunum));
155         rc = sprintf(buf, "%Lx\n", addr);
156         return rc;
157 }
158 static DEVICE_ATTR(crash_notes, 0400, show_crash_notes, NULL);
159
160 static ssize_t show_crash_notes_size(struct device *dev,
161                                      struct device_attribute *attr,
162                                      char *buf)
163 {
164         ssize_t rc;
165
166         rc = sprintf(buf, "%zu\n", sizeof(note_buf_t));
167         return rc;
168 }
169 static DEVICE_ATTR(crash_notes_size, 0400, show_crash_notes_size, NULL);
170
171 static struct attribute *crash_note_cpu_attrs[] = {
172         &dev_attr_crash_notes.attr,
173         &dev_attr_crash_notes_size.attr,
174         NULL
175 };
176
177 static struct attribute_group crash_note_cpu_attr_group = {
178         .attrs = crash_note_cpu_attrs,
179 };
180 #endif
181
182 static const struct attribute_group *common_cpu_attr_groups[] = {
183 #ifdef CONFIG_KEXEC
184         &crash_note_cpu_attr_group,
185 #endif
186         NULL
187 };
188
189 static const struct attribute_group *hotplugable_cpu_attr_groups[] = {
190 #ifdef CONFIG_KEXEC
191         &crash_note_cpu_attr_group,
192 #endif
193         NULL
194 };
195
196 /*
197  * Print cpu online, possible, present, and system maps
198  */
199
200 struct cpu_attr {
201         struct device_attribute attr;
202         const struct cpumask *const * const map;
203 };
204
205 static ssize_t show_cpus_attr(struct device *dev,
206                               struct device_attribute *attr,
207                               char *buf)
208 {
209         struct cpu_attr *ca = container_of(attr, struct cpu_attr, attr);
210         int n = cpulist_scnprintf(buf, PAGE_SIZE-2, *(ca->map));
211
212         buf[n++] = '\n';
213         buf[n] = '\0';
214         return n;
215 }
216
217 #define _CPU_ATTR(name, map) \
218         { __ATTR(name, 0444, show_cpus_attr, NULL), map }
219
220 /* Keep in sync with cpu_subsys_attrs */
221 static struct cpu_attr cpu_attrs[] = {
222         _CPU_ATTR(online, &cpu_online_mask),
223         _CPU_ATTR(possible, &cpu_possible_mask),
224         _CPU_ATTR(present, &cpu_present_mask),
225 };
226
227 /*
228  * Print values for NR_CPUS and offlined cpus
229  */
230 static ssize_t print_cpus_kernel_max(struct device *dev,
231                                      struct device_attribute *attr, char *buf)
232 {
233         int n = snprintf(buf, PAGE_SIZE-2, "%d\n", NR_CPUS - 1);
234         return n;
235 }
236 static DEVICE_ATTR(kernel_max, 0444, print_cpus_kernel_max, NULL);
237
238 /* arch-optional setting to enable display of offline cpus >= nr_cpu_ids */
239 unsigned int total_cpus;
240
241 static ssize_t print_cpus_offline(struct device *dev,
242                                   struct device_attribute *attr, char *buf)
243 {
244         int n = 0, len = PAGE_SIZE-2;
245         cpumask_var_t offline;
246
247         /* display offline cpus < nr_cpu_ids */
248         if (!alloc_cpumask_var(&offline, GFP_KERNEL))
249                 return -ENOMEM;
250         cpumask_andnot(offline, cpu_possible_mask, cpu_online_mask);
251         n = cpulist_scnprintf(buf, len, offline);
252         free_cpumask_var(offline);
253
254         /* display offline cpus >= nr_cpu_ids */
255         if (total_cpus && nr_cpu_ids < total_cpus) {
256                 if (n && n < len)
257                         buf[n++] = ',';
258
259                 if (nr_cpu_ids == total_cpus-1)
260                         n += snprintf(&buf[n], len - n, "%d", nr_cpu_ids);
261                 else
262                         n += snprintf(&buf[n], len - n, "%d-%d",
263                                                       nr_cpu_ids, total_cpus-1);
264         }
265
266         n += snprintf(&buf[n], len - n, "\n");
267         return n;
268 }
269 static DEVICE_ATTR(offline, 0444, print_cpus_offline, NULL);
270
271 static void cpu_device_release(struct device *dev)
272 {
273         /*
274          * This is an empty function to prevent the driver core from spitting a
275          * warning at us.  Yes, I know this is directly opposite of what the
276          * documentation for the driver core and kobjects say, and the author
277          * of this code has already been publically ridiculed for doing
278          * something as foolish as this.  However, at this point in time, it is
279          * the only way to handle the issue of statically allocated cpu
280          * devices.  The different architectures will have their cpu device
281          * code reworked to properly handle this in the near future, so this
282          * function will then be changed to correctly free up the memory held
283          * by the cpu device.
284          *
285          * Never copy this way of doing things, or you too will be made fun of
286          * on the linux-kernel list, you have been warned.
287          */
288 }
289
290 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE
291 static ssize_t print_cpu_modalias(struct device *dev,
292                                   struct device_attribute *attr,
293                                   char *buf)
294 {
295         ssize_t n;
296         u32 i;
297
298         n = sprintf(buf, "cpu:type:" CPU_FEATURE_TYPEFMT ":feature:",
299                     CPU_FEATURE_TYPEVAL);
300
301         for (i = 0; i < MAX_CPU_FEATURES; i++)
302                 if (cpu_have_feature(i)) {
303                         if (PAGE_SIZE < n + sizeof(",XXXX\n")) {
304                                 WARN(1, "CPU features overflow page\n");
305                                 break;
306                         }
307                         n += sprintf(&buf[n], ",%04X", i);
308                 }
309         buf[n++] = '\n';
310         return n;
311 }
312
313 static int cpu_uevent(struct device *dev, struct kobj_uevent_env *env)
314 {
315         char *buf = kzalloc(PAGE_SIZE, GFP_KERNEL);
316         if (buf) {
317                 print_cpu_modalias(NULL, NULL, buf);
318                 add_uevent_var(env, "MODALIAS=%s", buf);
319                 kfree(buf);
320         }
321         return 0;
322 }
323 #endif
324
325 /*
326  * register_cpu - Setup a sysfs device for a CPU.
327  * @cpu - cpu->hotpluggable field set to 1 will generate a control file in
328  *        sysfs for this CPU.
329  * @num - CPU number to use when creating the device.
330  *
331  * Initialize and register the CPU device.
332  */
333 int register_cpu(struct cpu *cpu, int num)
334 {
335         int error;
336
337         cpu->node_id = cpu_to_node(num);
338         memset(&cpu->dev, 0x00, sizeof(struct device));
339         cpu->dev.id = num;
340         cpu->dev.bus = &cpu_subsys;
341         cpu->dev.release = cpu_device_release;
342         cpu->dev.offline_disabled = !cpu->hotpluggable;
343         cpu->dev.offline = !cpu_online(num);
344         cpu->dev.of_node = of_get_cpu_node(num, NULL);
345 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE
346         cpu->dev.bus->uevent = cpu_uevent;
347 #endif
348         cpu->dev.groups = common_cpu_attr_groups;
349         if (cpu->hotpluggable)
350                 cpu->dev.groups = hotplugable_cpu_attr_groups;
351         error = device_register(&cpu->dev);
352         if (!error)
353                 per_cpu(cpu_sys_devices, num) = &cpu->dev;
354         if (!error)
355                 register_cpu_under_node(num, cpu_to_node(num));
356
357         return error;
358 }
359
360 struct device *get_cpu_device(unsigned cpu)
361 {
362         if (cpu < nr_cpu_ids && cpu_possible(cpu))
363                 return per_cpu(cpu_sys_devices, cpu);
364         else
365                 return NULL;
366 }
367 EXPORT_SYMBOL_GPL(get_cpu_device);
368
369 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE
370 static DEVICE_ATTR(modalias, 0444, print_cpu_modalias, NULL);
371 #endif
372
373 static struct attribute *cpu_root_attrs[] = {
374 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
375         &dev_attr_probe.attr,
376         &dev_attr_release.attr,
377 #endif
378         &cpu_attrs[0].attr.attr,
379         &cpu_attrs[1].attr.attr,
380         &cpu_attrs[2].attr.attr,
381         &dev_attr_kernel_max.attr,
382         &dev_attr_offline.attr,
383 #ifdef CONFIG_GENERIC_CPU_AUTOPROBE
384         &dev_attr_modalias.attr,
385 #endif
386         NULL
387 };
388
389 static struct attribute_group cpu_root_attr_group = {
390         .attrs = cpu_root_attrs,
391 };
392
393 static const struct attribute_group *cpu_root_attr_groups[] = {
394         &cpu_root_attr_group,
395         NULL,
396 };
397
398 bool cpu_is_hotpluggable(unsigned cpu)
399 {
400         struct device *dev = get_cpu_device(cpu);
401         return dev && container_of(dev, struct cpu, dev)->hotpluggable;
402 }
403 EXPORT_SYMBOL_GPL(cpu_is_hotpluggable);
404
405 #ifdef CONFIG_GENERIC_CPU_DEVICES
406 static DEFINE_PER_CPU(struct cpu, cpu_devices);
407 #endif
408
409 static void __init cpu_dev_register_generic(void)
410 {
411 #ifdef CONFIG_GENERIC_CPU_DEVICES
412         int i;
413
414         for_each_possible_cpu(i) {
415                 if (register_cpu(&per_cpu(cpu_devices, i), i))
416                         panic("Failed to register CPU device");
417         }
418 #endif
419 }
420
421 void __init cpu_dev_init(void)
422 {
423         if (subsys_system_register(&cpu_subsys, cpu_root_attr_groups))
424                 panic("Failed to register CPU subsystem");
425
426         cpu_dev_register_generic();
427 }