blob: f396ef27916bca9aad9c7e807394963706cfa0a4 [file] [log] [blame]
Kay Sievers8a25a2f2011-12-21 14:29:42 -08001#include <linux/device.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07002#include <linux/cpu.h>
3#include <linux/smp.h>
4#include <linux/percpu.h>
5#include <linux/init.h>
6#include <linux/sched.h>
Paul Gortmaker4b16f8e2011-07-22 18:24:23 -04007#include <linux/export.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07008#include <linux/nodemask.h>
9#include <linux/cpumask.h>
10#include <linux/notifier.h>
11
12#include <asm/current.h>
13#include <asm/processor.h>
14#include <asm/cputable.h>
Stephen Rothwell1ababe12005-08-03 14:35:25 +100015#include <asm/firmware.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <asm/hvcall.h>
17#include <asm/prom.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <asm/machdep.h>
Paul Mackerras2249ca92005-11-07 13:18:13 +110019#include <asm/smp.h>
Paul Mackerrasa6dbf932009-09-09 01:26:03 +000020#include <asm/pmc.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
Nathan Lynch93197a32008-12-23 18:55:54 +000022#include "cacheinfo.h"
23
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +100024#ifdef CONFIG_PPC64
25#include <asm/paca.h>
26#include <asm/lppaca.h>
27#endif
28
Linus Torvalds1da177e2005-04-16 15:20:36 -070029static DEFINE_PER_CPU(struct cpu, cpu_devices);
30
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +100031/*
32 * SMT snooze delay stuff, 64-bit only for now
33 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +100035#ifdef CONFIG_PPC64
36
Anton Blanchard0ddd3e72006-09-22 20:30:14 +100037/* Time in microseconds we delay before sleeping in the idle loop */
Anton Blanchardb878dc02010-05-16 20:02:39 +000038DEFINE_PER_CPU(long, smt_snooze_delay) = { 100 };
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Kay Sievers8a25a2f2011-12-21 14:29:42 -080040static ssize_t store_smt_snooze_delay(struct device *dev,
41 struct device_attribute *attr,
Andi Kleen4a0b2b42008-07-01 18:48:41 +020042 const char *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -070043 size_t count)
44{
Kay Sievers8a25a2f2011-12-21 14:29:42 -080045 struct cpu *cpu = container_of(dev, struct cpu, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 ssize_t ret;
Anton Blanchardb878dc02010-05-16 20:02:39 +000047 long snooze;
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Anton Blanchardb878dc02010-05-16 20:02:39 +000049 ret = sscanf(buf, "%ld", &snooze);
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 if (ret != 1)
51 return -EINVAL;
52
Kay Sievers8a25a2f2011-12-21 14:29:42 -080053 per_cpu(smt_snooze_delay, cpu->dev.id) = snooze;
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
55 return count;
56}
57
Kay Sievers8a25a2f2011-12-21 14:29:42 -080058static ssize_t show_smt_snooze_delay(struct device *dev,
59 struct device_attribute *attr,
Andi Kleen4a0b2b42008-07-01 18:48:41 +020060 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070061{
Kay Sievers8a25a2f2011-12-21 14:29:42 -080062 struct cpu *cpu = container_of(dev, struct cpu, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
Kay Sievers8a25a2f2011-12-21 14:29:42 -080064 return sprintf(buf, "%ld\n", per_cpu(smt_snooze_delay, cpu->dev.id));
Linus Torvalds1da177e2005-04-16 15:20:36 -070065}
66
Kay Sievers8a25a2f2011-12-21 14:29:42 -080067static DEVICE_ATTR(smt_snooze_delay, 0644, show_smt_snooze_delay,
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 store_smt_snooze_delay);
69
Linus Torvalds1da177e2005-04-16 15:20:36 -070070static int __init setup_smt_snooze_delay(char *str)
71{
72 unsigned int cpu;
Anton Blanchardb878dc02010-05-16 20:02:39 +000073 long snooze;
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
75 if (!cpu_has_feature(CPU_FTR_SMT))
76 return 1;
77
Anton Blanchardb878dc02010-05-16 20:02:39 +000078 snooze = simple_strtol(str, NULL, 10);
79 for_each_possible_cpu(cpu)
80 per_cpu(smt_snooze_delay, cpu) = snooze;
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
82 return 1;
83}
84__setup("smt-snooze-delay=", setup_smt_snooze_delay);
85
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +100086#endif /* CONFIG_PPC64 */
Michael Ellerman180a3362005-08-09 11:13:36 +100087
Linus Torvalds1da177e2005-04-16 15:20:36 -070088/*
89 * Enabling PMCs will slow partition context switch times so we only do
90 * it the first time we write to the PMCs.
91 */
92
93static DEFINE_PER_CPU(char, pmcs_enabled);
94
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +100095void ppc_enable_pmcs(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070096{
Paul Mackerrasa6dbf932009-09-09 01:26:03 +000097 ppc_set_pmu_inuse(1);
98
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 /* Only need to enable them once */
100 if (__get_cpu_var(pmcs_enabled))
101 return;
102
103 __get_cpu_var(pmcs_enabled) = 1;
104
Michael Ellerman180a3362005-08-09 11:13:36 +1000105 if (ppc_md.enable_pmcs)
106 ppc_md.enable_pmcs();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107}
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000108EXPORT_SYMBOL(ppc_enable_pmcs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110#define SYSFS_PMCSETUP(NAME, ADDRESS) \
Rusty Russell9a371932009-03-11 12:20:05 +0000111static void read_##NAME(void *val) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112{ \
Benjamin Herrenschmidtec78c8a2009-03-26 19:29:06 +0000113 *(unsigned long *)val = mfspr(ADDRESS); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114} \
Benjamin Herrenschmidtec78c8a2009-03-26 19:29:06 +0000115static void write_##NAME(void *val) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116{ \
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000117 ppc_enable_pmcs(); \
Rusty Russell9a371932009-03-11 12:20:05 +0000118 mtspr(ADDRESS, *(unsigned long *)val); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119} \
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800120static ssize_t show_##NAME(struct device *dev, \
121 struct device_attribute *attr, \
Andi Kleen4a0b2b42008-07-01 18:48:41 +0200122 char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123{ \
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800124 struct cpu *cpu = container_of(dev, struct cpu, dev); \
Rusty Russell9a371932009-03-11 12:20:05 +0000125 unsigned long val; \
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800126 smp_call_function_single(cpu->dev.id, read_##NAME, &val, 1); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 return sprintf(buf, "%lx\n", val); \
128} \
Adrian Bunk3ff6eec2008-01-24 22:16:20 +0100129static ssize_t __used \
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800130 store_##NAME(struct device *dev, struct device_attribute *attr, \
Andi Kleen4a0b2b42008-07-01 18:48:41 +0200131 const char *buf, size_t count) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132{ \
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800133 struct cpu *cpu = container_of(dev, struct cpu, dev); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 unsigned long val; \
135 int ret = sscanf(buf, "%lx", &val); \
136 if (ret != 1) \
137 return -EINVAL; \
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800138 smp_call_function_single(cpu->dev.id, write_##NAME, &val, 1); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 return count; \
140}
141
Olof Johansson6529c132007-01-28 21:25:57 -0600142
143/* Let's define all possible registers, we'll only hook up the ones
144 * that are implemented on the current processor
145 */
146
Kumar Gala33a7f122008-09-18 17:50:42 -0500147#if defined(CONFIG_PPC64)
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000148#define HAS_PPC_PMC_CLASSIC 1
149#define HAS_PPC_PMC_IBM 1
150#define HAS_PPC_PMC_PA6T 1
Kumar Gala33a7f122008-09-18 17:50:42 -0500151#elif defined(CONFIG_6xx)
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000152#define HAS_PPC_PMC_CLASSIC 1
153#define HAS_PPC_PMC_IBM 1
154#define HAS_PPC_PMC_G4 1
155#endif
156
157
158#ifdef HAS_PPC_PMC_CLASSIC
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159SYSFS_PMCSETUP(mmcr0, SPRN_MMCR0);
160SYSFS_PMCSETUP(mmcr1, SPRN_MMCR1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161SYSFS_PMCSETUP(pmc1, SPRN_PMC1);
162SYSFS_PMCSETUP(pmc2, SPRN_PMC2);
163SYSFS_PMCSETUP(pmc3, SPRN_PMC3);
164SYSFS_PMCSETUP(pmc4, SPRN_PMC4);
165SYSFS_PMCSETUP(pmc5, SPRN_PMC5);
166SYSFS_PMCSETUP(pmc6, SPRN_PMC6);
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000167
168#ifdef HAS_PPC_PMC_G4
169SYSFS_PMCSETUP(mmcr2, SPRN_MMCR2);
170#endif
171
172#ifdef CONFIG_PPC64
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173SYSFS_PMCSETUP(pmc7, SPRN_PMC7);
174SYSFS_PMCSETUP(pmc8, SPRN_PMC8);
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000175
176SYSFS_PMCSETUP(mmcra, SPRN_MMCRA);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177SYSFS_PMCSETUP(purr, SPRN_PURR);
Anton Blanchardf0509822006-12-08 17:51:13 +1100178SYSFS_PMCSETUP(spurr, SPRN_SPURR);
Anton Blanchard4c1985572006-12-08 17:46:58 +1100179SYSFS_PMCSETUP(dscr, SPRN_DSCR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800181static DEVICE_ATTR(mmcra, 0600, show_mmcra, store_mmcra);
182static DEVICE_ATTR(spurr, 0600, show_spurr, NULL);
183static DEVICE_ATTR(dscr, 0600, show_dscr, store_dscr);
184static DEVICE_ATTR(purr, 0600, show_purr, store_purr);
Alexey Kardashevskiyefcac652011-03-02 15:18:48 +0000185
186unsigned long dscr_default = 0;
187EXPORT_SYMBOL(dscr_default);
188
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800189static ssize_t show_dscr_default(struct device *dev,
190 struct device_attribute *attr, char *buf)
Alexey Kardashevskiyefcac652011-03-02 15:18:48 +0000191{
192 return sprintf(buf, "%lx\n", dscr_default);
193}
194
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800195static ssize_t __used store_dscr_default(struct device *dev,
196 struct device_attribute *attr, const char *buf,
Alexey Kardashevskiyefcac652011-03-02 15:18:48 +0000197 size_t count)
198{
199 unsigned long val;
200 int ret = 0;
201
202 ret = sscanf(buf, "%lx", &val);
203 if (ret != 1)
204 return -EINVAL;
205 dscr_default = val;
206
207 return count;
208}
209
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800210static DEVICE_ATTR(dscr_default, 0600,
Alexey Kardashevskiyefcac652011-03-02 15:18:48 +0000211 show_dscr_default, store_dscr_default);
212
213static void sysfs_create_dscr_default(void)
214{
215 int err = 0;
216 if (cpu_has_feature(CPU_FTR_DSCR))
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800217 err = device_create_file(cpu_subsys.dev_root, &dev_attr_dscr_default);
Alexey Kardashevskiyefcac652011-03-02 15:18:48 +0000218}
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000219#endif /* CONFIG_PPC64 */
220
221#ifdef HAS_PPC_PMC_PA6T
Olof Johansson25fc5302007-04-18 16:38:21 +1000222SYSFS_PMCSETUP(pa6t_pmc0, SPRN_PA6T_PMC0);
223SYSFS_PMCSETUP(pa6t_pmc1, SPRN_PA6T_PMC1);
224SYSFS_PMCSETUP(pa6t_pmc2, SPRN_PA6T_PMC2);
225SYSFS_PMCSETUP(pa6t_pmc3, SPRN_PA6T_PMC3);
226SYSFS_PMCSETUP(pa6t_pmc4, SPRN_PA6T_PMC4);
227SYSFS_PMCSETUP(pa6t_pmc5, SPRN_PA6T_PMC5);
Olof Johansson2e1957f2007-09-05 12:09:06 +1000228#ifdef CONFIG_DEBUG_KERNEL
229SYSFS_PMCSETUP(hid0, SPRN_HID0);
230SYSFS_PMCSETUP(hid1, SPRN_HID1);
231SYSFS_PMCSETUP(hid4, SPRN_HID4);
232SYSFS_PMCSETUP(hid5, SPRN_HID5);
233SYSFS_PMCSETUP(ima0, SPRN_PA6T_IMA0);
234SYSFS_PMCSETUP(ima1, SPRN_PA6T_IMA1);
235SYSFS_PMCSETUP(ima2, SPRN_PA6T_IMA2);
236SYSFS_PMCSETUP(ima3, SPRN_PA6T_IMA3);
237SYSFS_PMCSETUP(ima4, SPRN_PA6T_IMA4);
238SYSFS_PMCSETUP(ima5, SPRN_PA6T_IMA5);
239SYSFS_PMCSETUP(ima6, SPRN_PA6T_IMA6);
240SYSFS_PMCSETUP(ima7, SPRN_PA6T_IMA7);
241SYSFS_PMCSETUP(ima8, SPRN_PA6T_IMA8);
242SYSFS_PMCSETUP(ima9, SPRN_PA6T_IMA9);
243SYSFS_PMCSETUP(imaat, SPRN_PA6T_IMAAT);
244SYSFS_PMCSETUP(btcr, SPRN_PA6T_BTCR);
245SYSFS_PMCSETUP(pccr, SPRN_PA6T_PCCR);
246SYSFS_PMCSETUP(rpccr, SPRN_PA6T_RPCCR);
247SYSFS_PMCSETUP(der, SPRN_PA6T_DER);
248SYSFS_PMCSETUP(mer, SPRN_PA6T_MER);
249SYSFS_PMCSETUP(ber, SPRN_PA6T_BER);
250SYSFS_PMCSETUP(ier, SPRN_PA6T_IER);
251SYSFS_PMCSETUP(sier, SPRN_PA6T_SIER);
252SYSFS_PMCSETUP(siar, SPRN_PA6T_SIAR);
253SYSFS_PMCSETUP(tsr0, SPRN_PA6T_TSR0);
254SYSFS_PMCSETUP(tsr1, SPRN_PA6T_TSR1);
255SYSFS_PMCSETUP(tsr2, SPRN_PA6T_TSR2);
256SYSFS_PMCSETUP(tsr3, SPRN_PA6T_TSR3);
257#endif /* CONFIG_DEBUG_KERNEL */
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000258#endif /* HAS_PPC_PMC_PA6T */
Olof Johansson6529c132007-01-28 21:25:57 -0600259
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000260#ifdef HAS_PPC_PMC_IBM
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800261static struct device_attribute ibm_common_attrs[] = {
262 __ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0),
263 __ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1),
Olof Johansson6529c132007-01-28 21:25:57 -0600264};
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000265#endif /* HAS_PPC_PMC_G4 */
Olof Johansson6529c132007-01-28 21:25:57 -0600266
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000267#ifdef HAS_PPC_PMC_G4
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800268static struct device_attribute g4_common_attrs[] = {
269 __ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0),
270 __ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1),
271 __ATTR(mmcr2, 0600, show_mmcr2, store_mmcr2),
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000272};
273#endif /* HAS_PPC_PMC_G4 */
274
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800275static struct device_attribute classic_pmc_attrs[] = {
276 __ATTR(pmc1, 0600, show_pmc1, store_pmc1),
277 __ATTR(pmc2, 0600, show_pmc2, store_pmc2),
278 __ATTR(pmc3, 0600, show_pmc3, store_pmc3),
279 __ATTR(pmc4, 0600, show_pmc4, store_pmc4),
280 __ATTR(pmc5, 0600, show_pmc5, store_pmc5),
281 __ATTR(pmc6, 0600, show_pmc6, store_pmc6),
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000282#ifdef CONFIG_PPC64
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800283 __ATTR(pmc7, 0600, show_pmc7, store_pmc7),
284 __ATTR(pmc8, 0600, show_pmc8, store_pmc8),
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000285#endif
Olof Johansson6529c132007-01-28 21:25:57 -0600286};
287
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000288#ifdef HAS_PPC_PMC_PA6T
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800289static struct device_attribute pa6t_attrs[] = {
290 __ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0),
291 __ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1),
292 __ATTR(pmc0, 0600, show_pa6t_pmc0, store_pa6t_pmc0),
293 __ATTR(pmc1, 0600, show_pa6t_pmc1, store_pa6t_pmc1),
294 __ATTR(pmc2, 0600, show_pa6t_pmc2, store_pa6t_pmc2),
295 __ATTR(pmc3, 0600, show_pa6t_pmc3, store_pa6t_pmc3),
296 __ATTR(pmc4, 0600, show_pa6t_pmc4, store_pa6t_pmc4),
297 __ATTR(pmc5, 0600, show_pa6t_pmc5, store_pa6t_pmc5),
Olof Johansson2e1957f2007-09-05 12:09:06 +1000298#ifdef CONFIG_DEBUG_KERNEL
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800299 __ATTR(hid0, 0600, show_hid0, store_hid0),
300 __ATTR(hid1, 0600, show_hid1, store_hid1),
301 __ATTR(hid4, 0600, show_hid4, store_hid4),
302 __ATTR(hid5, 0600, show_hid5, store_hid5),
303 __ATTR(ima0, 0600, show_ima0, store_ima0),
304 __ATTR(ima1, 0600, show_ima1, store_ima1),
305 __ATTR(ima2, 0600, show_ima2, store_ima2),
306 __ATTR(ima3, 0600, show_ima3, store_ima3),
307 __ATTR(ima4, 0600, show_ima4, store_ima4),
308 __ATTR(ima5, 0600, show_ima5, store_ima5),
309 __ATTR(ima6, 0600, show_ima6, store_ima6),
310 __ATTR(ima7, 0600, show_ima7, store_ima7),
311 __ATTR(ima8, 0600, show_ima8, store_ima8),
312 __ATTR(ima9, 0600, show_ima9, store_ima9),
313 __ATTR(imaat, 0600, show_imaat, store_imaat),
314 __ATTR(btcr, 0600, show_btcr, store_btcr),
315 __ATTR(pccr, 0600, show_pccr, store_pccr),
316 __ATTR(rpccr, 0600, show_rpccr, store_rpccr),
317 __ATTR(der, 0600, show_der, store_der),
318 __ATTR(mer, 0600, show_mer, store_mer),
319 __ATTR(ber, 0600, show_ber, store_ber),
320 __ATTR(ier, 0600, show_ier, store_ier),
321 __ATTR(sier, 0600, show_sier, store_sier),
322 __ATTR(siar, 0600, show_siar, store_siar),
323 __ATTR(tsr0, 0600, show_tsr0, store_tsr0),
324 __ATTR(tsr1, 0600, show_tsr1, store_tsr1),
325 __ATTR(tsr2, 0600, show_tsr2, store_tsr2),
326 __ATTR(tsr3, 0600, show_tsr3, store_tsr3),
Olof Johansson2e1957f2007-09-05 12:09:06 +1000327#endif /* CONFIG_DEBUG_KERNEL */
Olof Johansson6529c132007-01-28 21:25:57 -0600328};
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000329#endif /* HAS_PPC_PMC_PA6T */
330#endif /* HAS_PPC_PMC_CLASSIC */
Olof Johansson6529c132007-01-28 21:25:57 -0600331
Nathan Lynch9ba19842008-07-27 15:24:51 +1000332static void __cpuinit register_cpu_online(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333{
334 struct cpu *c = &per_cpu(cpu_devices, cpu);
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800335 struct device *s = &c->dev;
336 struct device_attribute *attrs, *pmc_attrs;
Olof Johansson6529c132007-01-28 21:25:57 -0600337 int i, nattrs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000339#ifdef CONFIG_PPC64
Stephen Rothwellad5cb172006-11-13 14:46:04 +1100340 if (!firmware_has_feature(FW_FEATURE_ISERIES) &&
341 cpu_has_feature(CPU_FTR_SMT))
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800342 device_create_file(s, &dev_attr_smt_snooze_delay);
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000343#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
345 /* PMC stuff */
Olof Johansson6529c132007-01-28 21:25:57 -0600346 switch (cur_cpu_spec->pmc_type) {
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000347#ifdef HAS_PPC_PMC_IBM
Olof Johansson6529c132007-01-28 21:25:57 -0600348 case PPC_PMC_IBM:
349 attrs = ibm_common_attrs;
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800350 nattrs = sizeof(ibm_common_attrs) / sizeof(struct device_attribute);
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000351 pmc_attrs = classic_pmc_attrs;
Olof Johansson6529c132007-01-28 21:25:57 -0600352 break;
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000353#endif /* HAS_PPC_PMC_IBM */
354#ifdef HAS_PPC_PMC_G4
355 case PPC_PMC_G4:
356 attrs = g4_common_attrs;
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800357 nattrs = sizeof(g4_common_attrs) / sizeof(struct device_attribute);
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000358 pmc_attrs = classic_pmc_attrs;
359 break;
360#endif /* HAS_PPC_PMC_G4 */
361#ifdef HAS_PPC_PMC_PA6T
Olof Johansson6529c132007-01-28 21:25:57 -0600362 case PPC_PMC_PA6T:
363 /* PA Semi starts counting at PMC0 */
364 attrs = pa6t_attrs;
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800365 nattrs = sizeof(pa6t_attrs) / sizeof(struct device_attribute);
Olof Johansson6529c132007-01-28 21:25:57 -0600366 pmc_attrs = NULL;
367 break;
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000368#endif /* HAS_PPC_PMC_PA6T */
Olof Johansson6529c132007-01-28 21:25:57 -0600369 default:
370 attrs = NULL;
371 nattrs = 0;
372 pmc_attrs = NULL;
373 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374
Olof Johansson6529c132007-01-28 21:25:57 -0600375 for (i = 0; i < nattrs; i++)
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800376 device_create_file(s, &attrs[i]);
Olof Johansson6529c132007-01-28 21:25:57 -0600377
378 if (pmc_attrs)
379 for (i = 0; i < cur_cpu_spec->num_pmcs; i++)
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800380 device_create_file(s, &pmc_attrs[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000382#ifdef CONFIG_PPC64
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 if (cpu_has_feature(CPU_FTR_MMCRA))
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800384 device_create_file(s, &dev_attr_mmcra);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
Michael Neulingafd05422006-07-28 13:58:37 +1000386 if (cpu_has_feature(CPU_FTR_PURR))
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800387 device_create_file(s, &dev_attr_purr);
Anton Blanchard4c1985572006-12-08 17:46:58 +1100388
Anton Blanchardf0509822006-12-08 17:51:13 +1100389 if (cpu_has_feature(CPU_FTR_SPURR))
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800390 device_create_file(s, &dev_attr_spurr);
Anton Blanchardf0509822006-12-08 17:51:13 +1100391
Anton Blanchard4c1985572006-12-08 17:46:58 +1100392 if (cpu_has_feature(CPU_FTR_DSCR))
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800393 device_create_file(s, &dev_attr_dscr);
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000394#endif /* CONFIG_PPC64 */
Nathan Lynch124c27d2008-07-27 15:24:55 +1000395
Nathan Lynch93197a32008-12-23 18:55:54 +0000396 cacheinfo_cpu_online(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397}
398
399#ifdef CONFIG_HOTPLUG_CPU
400static void unregister_cpu_online(unsigned int cpu)
401{
402 struct cpu *c = &per_cpu(cpu_devices, cpu);
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800403 struct device *s = &c->dev;
404 struct device_attribute *attrs, *pmc_attrs;
Olof Johansson6529c132007-01-28 21:25:57 -0600405 int i, nattrs;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
Siddha, Suresh B72486f12006-12-07 02:14:10 +0100407 BUG_ON(!c->hotpluggable);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Milton Millera1e0eb12008-11-16 11:44:42 +0000409#ifdef CONFIG_PPC64
Stephen Rothwellad5cb172006-11-13 14:46:04 +1100410 if (!firmware_has_feature(FW_FEATURE_ISERIES) &&
411 cpu_has_feature(CPU_FTR_SMT))
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800412 device_remove_file(s, &dev_attr_smt_snooze_delay);
Milton Millera1e0eb12008-11-16 11:44:42 +0000413#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414
415 /* PMC stuff */
Olof Johansson6529c132007-01-28 21:25:57 -0600416 switch (cur_cpu_spec->pmc_type) {
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000417#ifdef HAS_PPC_PMC_IBM
Olof Johansson6529c132007-01-28 21:25:57 -0600418 case PPC_PMC_IBM:
419 attrs = ibm_common_attrs;
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800420 nattrs = sizeof(ibm_common_attrs) / sizeof(struct device_attribute);
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000421 pmc_attrs = classic_pmc_attrs;
Olof Johansson6529c132007-01-28 21:25:57 -0600422 break;
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000423#endif /* HAS_PPC_PMC_IBM */
424#ifdef HAS_PPC_PMC_G4
425 case PPC_PMC_G4:
426 attrs = g4_common_attrs;
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800427 nattrs = sizeof(g4_common_attrs) / sizeof(struct device_attribute);
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000428 pmc_attrs = classic_pmc_attrs;
429 break;
430#endif /* HAS_PPC_PMC_G4 */
431#ifdef HAS_PPC_PMC_PA6T
Olof Johansson6529c132007-01-28 21:25:57 -0600432 case PPC_PMC_PA6T:
433 /* PA Semi starts counting at PMC0 */
434 attrs = pa6t_attrs;
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800435 nattrs = sizeof(pa6t_attrs) / sizeof(struct device_attribute);
Olof Johansson6529c132007-01-28 21:25:57 -0600436 pmc_attrs = NULL;
437 break;
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000438#endif /* HAS_PPC_PMC_PA6T */
Olof Johansson6529c132007-01-28 21:25:57 -0600439 default:
440 attrs = NULL;
441 nattrs = 0;
442 pmc_attrs = NULL;
443 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444
Olof Johansson6529c132007-01-28 21:25:57 -0600445 for (i = 0; i < nattrs; i++)
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800446 device_remove_file(s, &attrs[i]);
Olof Johansson6529c132007-01-28 21:25:57 -0600447
448 if (pmc_attrs)
449 for (i = 0; i < cur_cpu_spec->num_pmcs; i++)
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800450 device_remove_file(s, &pmc_attrs[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000452#ifdef CONFIG_PPC64
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 if (cpu_has_feature(CPU_FTR_MMCRA))
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800454 device_remove_file(s, &dev_attr_mmcra);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
Michael Neulingafd05422006-07-28 13:58:37 +1000456 if (cpu_has_feature(CPU_FTR_PURR))
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800457 device_remove_file(s, &dev_attr_purr);
Anton Blanchard4c1985572006-12-08 17:46:58 +1100458
Anton Blanchardf0509822006-12-08 17:51:13 +1100459 if (cpu_has_feature(CPU_FTR_SPURR))
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800460 device_remove_file(s, &dev_attr_spurr);
Anton Blanchardf0509822006-12-08 17:51:13 +1100461
Anton Blanchard4c1985572006-12-08 17:46:58 +1100462 if (cpu_has_feature(CPU_FTR_DSCR))
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800463 device_remove_file(s, &dev_attr_dscr);
Benjamin Herrenschmidtb950bdd2008-08-18 14:23:51 +1000464#endif /* CONFIG_PPC64 */
Nathan Lynch124c27d2008-07-27 15:24:55 +1000465
Nathan Lynch93197a32008-12-23 18:55:54 +0000466 cacheinfo_cpu_offline(cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467}
Nathan Fontenot12633e82009-11-25 17:23:25 +0000468
469#ifdef CONFIG_ARCH_CPU_PROBE_RELEASE
470ssize_t arch_cpu_probe(const char *buf, size_t count)
471{
472 if (ppc_md.cpu_probe)
473 return ppc_md.cpu_probe(buf, count);
474
475 return -EINVAL;
476}
477
478ssize_t arch_cpu_release(const char *buf, size_t count)
479{
480 if (ppc_md.cpu_release)
481 return ppc_md.cpu_release(buf, count);
482
483 return -EINVAL;
484}
485#endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */
486
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487#endif /* CONFIG_HOTPLUG_CPU */
488
Chandra Seetharaman8c78f302006-07-30 03:03:35 -0700489static int __cpuinit sysfs_cpu_notify(struct notifier_block *self,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 unsigned long action, void *hcpu)
491{
492 unsigned int cpu = (unsigned int)(long)hcpu;
493
494 switch (action) {
495 case CPU_ONLINE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700496 case CPU_ONLINE_FROZEN:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 register_cpu_online(cpu);
498 break;
499#ifdef CONFIG_HOTPLUG_CPU
500 case CPU_DEAD:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700501 case CPU_DEAD_FROZEN:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 unregister_cpu_online(cpu);
503 break;
504#endif
505 }
506 return NOTIFY_OK;
507}
508
Chandra Seetharaman8c78f302006-07-30 03:03:35 -0700509static struct notifier_block __cpuinitdata sysfs_cpu_nb = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 .notifier_call = sysfs_cpu_notify,
511};
512
Christian Krafft0344c6c2006-10-24 18:31:24 +0200513static DEFINE_MUTEX(cpu_mutex);
514
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800515int cpu_add_dev_attr(struct device_attribute *attr)
Christian Krafft0344c6c2006-10-24 18:31:24 +0200516{
517 int cpu;
518
519 mutex_lock(&cpu_mutex);
520
521 for_each_possible_cpu(cpu) {
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800522 device_create_file(get_cpu_device(cpu), attr);
Christian Krafft0344c6c2006-10-24 18:31:24 +0200523 }
524
525 mutex_unlock(&cpu_mutex);
526 return 0;
527}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800528EXPORT_SYMBOL_GPL(cpu_add_dev_attr);
Christian Krafft0344c6c2006-10-24 18:31:24 +0200529
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800530int cpu_add_dev_attr_group(struct attribute_group *attrs)
Christian Krafft0344c6c2006-10-24 18:31:24 +0200531{
532 int cpu;
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800533 struct device *dev;
Olof Johansson6bcc4c02007-09-05 12:43:17 +1000534 int ret;
Christian Krafft0344c6c2006-10-24 18:31:24 +0200535
536 mutex_lock(&cpu_mutex);
537
538 for_each_possible_cpu(cpu) {
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800539 dev = get_cpu_device(cpu);
540 ret = sysfs_create_group(&dev->kobj, attrs);
Olof Johansson6bcc4c02007-09-05 12:43:17 +1000541 WARN_ON(ret != 0);
Christian Krafft0344c6c2006-10-24 18:31:24 +0200542 }
543
544 mutex_unlock(&cpu_mutex);
545 return 0;
546}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800547EXPORT_SYMBOL_GPL(cpu_add_dev_attr_group);
Christian Krafft0344c6c2006-10-24 18:31:24 +0200548
549
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800550void cpu_remove_dev_attr(struct device_attribute *attr)
Christian Krafft0344c6c2006-10-24 18:31:24 +0200551{
552 int cpu;
553
554 mutex_lock(&cpu_mutex);
555
556 for_each_possible_cpu(cpu) {
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800557 device_remove_file(get_cpu_device(cpu), attr);
Christian Krafft0344c6c2006-10-24 18:31:24 +0200558 }
559
560 mutex_unlock(&cpu_mutex);
561}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800562EXPORT_SYMBOL_GPL(cpu_remove_dev_attr);
Christian Krafft0344c6c2006-10-24 18:31:24 +0200563
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800564void cpu_remove_dev_attr_group(struct attribute_group *attrs)
Christian Krafft0344c6c2006-10-24 18:31:24 +0200565{
566 int cpu;
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800567 struct device *dev;
Christian Krafft0344c6c2006-10-24 18:31:24 +0200568
569 mutex_lock(&cpu_mutex);
570
571 for_each_possible_cpu(cpu) {
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800572 dev = get_cpu_device(cpu);
573 sysfs_remove_group(&dev->kobj, attrs);
Christian Krafft0344c6c2006-10-24 18:31:24 +0200574 }
575
576 mutex_unlock(&cpu_mutex);
577}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800578EXPORT_SYMBOL_GPL(cpu_remove_dev_attr_group);
Christian Krafft0344c6c2006-10-24 18:31:24 +0200579
580
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581/* NUMA stuff */
582
583#ifdef CONFIG_NUMA
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584static void register_nodes(void)
585{
586 int i;
587
Yasunori Goto0fc44152006-06-27 02:53:38 -0700588 for (i = 0; i < MAX_NUMNODES; i++)
589 register_one_node(i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590}
Jeremy Kerr953039c2006-05-01 12:16:12 -0700591
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800592int sysfs_add_device_to_node(struct device *dev, int nid)
Jeremy Kerr953039c2006-05-01 12:16:12 -0700593{
594 struct node *node = &node_devices[nid];
595 return sysfs_create_link(&node->sysdev.kobj, &dev->kobj,
596 kobject_name(&dev->kobj));
597}
Johannes Berg12654f72007-07-05 19:35:33 +1000598EXPORT_SYMBOL_GPL(sysfs_add_device_to_node);
Jeremy Kerr953039c2006-05-01 12:16:12 -0700599
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800600void sysfs_remove_device_from_node(struct device *dev, int nid)
Jeremy Kerr953039c2006-05-01 12:16:12 -0700601{
602 struct node *node = &node_devices[nid];
603 sysfs_remove_link(&node->sysdev.kobj, kobject_name(&dev->kobj));
604}
Johannes Berg12654f72007-07-05 19:35:33 +1000605EXPORT_SYMBOL_GPL(sysfs_remove_device_from_node);
Jeremy Kerr953039c2006-05-01 12:16:12 -0700606
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607#else
608static void register_nodes(void)
609{
610 return;
611}
Jeremy Kerr953039c2006-05-01 12:16:12 -0700612
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613#endif
614
615/* Only valid if CPU is present. */
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800616static ssize_t show_physical_id(struct device *dev,
617 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618{
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800619 struct cpu *cpu = container_of(dev, struct cpu, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800621 return sprintf(buf, "%d\n", get_hard_smp_processor_id(cpu->dev.id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622}
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800623static DEVICE_ATTR(physical_id, 0444, show_physical_id, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624
625static int __init topology_init(void)
626{
627 int cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628
629 register_nodes();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 register_cpu_notifier(&sysfs_cpu_nb);
631
KAMEZAWA Hiroyuki0e551952006-03-28 14:50:51 -0800632 for_each_possible_cpu(cpu) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 struct cpu *c = &per_cpu(cpu_devices, cpu);
634
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 /*
636 * For now, we just see if the system supports making
637 * the RTAS calls for CPU hotplug. But, there may be a
638 * more comprehensive way to do this for an individual
639 * CPU. For instance, the boot cpu might never be valid
640 * for hotplugging.
641 */
Siddha, Suresh B72486f12006-12-07 02:14:10 +0100642 if (ppc_md.cpu_die)
643 c->hotpluggable = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
Siddha, Suresh B72486f12006-12-07 02:14:10 +0100645 if (cpu_online(cpu) || c->hotpluggable) {
KAMEZAWA Hiroyuki76b67ed2006-06-27 02:53:41 -0700646 register_cpu(c, cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647
Kay Sievers8a25a2f2011-12-21 14:29:42 -0800648 device_create_file(&c->dev, &dev_attr_physical_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 }
650
651 if (cpu_online(cpu))
652 register_cpu_online(cpu);
653 }
Alexey Kardashevskiyefcac652011-03-02 15:18:48 +0000654#ifdef CONFIG_PPC64
655 sysfs_create_dscr_default();
656#endif /* CONFIG_PPC64 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
658 return 0;
659}
Kevin Corrye9e77ce2007-05-03 03:11:49 +1000660subsys_initcall(topology_init);