1 #include <linux/sysdev.h>
4 #include <linux/percpu.h>
5 #include <linux/init.h>
6 #include <linux/sched.h>
7 #include <linux/module.h>
8 #include <linux/nodemask.h>
9 #include <linux/cpumask.h>
10 #include <linux/notifier.h>
12 #include <asm/current.h>
13 #include <asm/processor.h>
14 #include <asm/cputable.h>
15 #include <asm/firmware.h>
16 #include <asm/hvcall.h>
19 #include <asm/lppaca.h>
20 #include <asm/machdep.h>
23 static DEFINE_PER_CPU(struct cpu
, cpu_devices
);
27 #ifdef CONFIG_PPC_MULTIPLATFORM
28 /* Time in microseconds we delay before sleeping in the idle loop */
29 DEFINE_PER_CPU(unsigned long, smt_snooze_delay
) = { 100 };
31 static ssize_t
store_smt_snooze_delay(struct sys_device
*dev
, const char *buf
,
34 struct cpu
*cpu
= container_of(dev
, struct cpu
, sysdev
);
38 ret
= sscanf(buf
, "%lu", &snooze
);
42 per_cpu(smt_snooze_delay
, cpu
->sysdev
.id
) = snooze
;
47 static ssize_t
show_smt_snooze_delay(struct sys_device
*dev
, char *buf
)
49 struct cpu
*cpu
= container_of(dev
, struct cpu
, sysdev
);
51 return sprintf(buf
, "%lu\n", per_cpu(smt_snooze_delay
, cpu
->sysdev
.id
));
54 static SYSDEV_ATTR(smt_snooze_delay
, 0644, show_smt_snooze_delay
,
55 store_smt_snooze_delay
);
57 /* Only parse OF options if the matching cmdline option was not specified */
58 static int smt_snooze_cmdline
;
60 static int __init
smt_setup(void)
62 struct device_node
*options
;
63 const unsigned int *val
;
66 if (!cpu_has_feature(CPU_FTR_SMT
))
69 options
= find_path_device("/options");
73 val
= of_get_property(options
, "ibm,smt-snooze-delay", NULL
);
74 if (!smt_snooze_cmdline
&& val
) {
75 for_each_possible_cpu(cpu
)
76 per_cpu(smt_snooze_delay
, cpu
) = *val
;
81 __initcall(smt_setup
);
83 static int __init
setup_smt_snooze_delay(char *str
)
88 if (!cpu_has_feature(CPU_FTR_SMT
))
91 smt_snooze_cmdline
= 1;
93 if (get_option(&str
, &snooze
)) {
94 for_each_possible_cpu(cpu
)
95 per_cpu(smt_snooze_delay
, cpu
) = snooze
;
100 __setup("smt-snooze-delay=", setup_smt_snooze_delay
);
102 #endif /* CONFIG_PPC_MULTIPLATFORM */
105 * Enabling PMCs will slow partition context switch times so we only do
106 * it the first time we write to the PMCs.
109 static DEFINE_PER_CPU(char, pmcs_enabled
);
111 void ppc64_enable_pmcs(void)
113 /* Only need to enable them once */
114 if (__get_cpu_var(pmcs_enabled
))
117 __get_cpu_var(pmcs_enabled
) = 1;
119 if (ppc_md
.enable_pmcs
)
120 ppc_md
.enable_pmcs();
122 EXPORT_SYMBOL(ppc64_enable_pmcs
);
124 /* XXX convert to rusty's on_one_cpu */
125 static unsigned long run_on_cpu(unsigned long cpu
,
126 unsigned long (*func
)(unsigned long),
129 cpumask_t old_affinity
= current
->cpus_allowed
;
132 /* should return -EINVAL to userspace */
133 if (set_cpus_allowed(current
, cpumask_of_cpu(cpu
)))
138 set_cpus_allowed(current
, old_affinity
);
143 #define SYSFS_PMCSETUP(NAME, ADDRESS) \
144 static unsigned long read_##NAME(unsigned long junk) \
146 return mfspr(ADDRESS); \
148 static unsigned long write_##NAME(unsigned long val) \
150 ppc64_enable_pmcs(); \
151 mtspr(ADDRESS, val); \
154 static ssize_t show_##NAME(struct sys_device *dev, char *buf) \
156 struct cpu *cpu = container_of(dev, struct cpu, sysdev); \
157 unsigned long val = run_on_cpu(cpu->sysdev.id, read_##NAME, 0); \
158 return sprintf(buf, "%lx\n", val); \
160 static ssize_t __attribute_used__ \
161 store_##NAME(struct sys_device *dev, const char *buf, size_t count) \
163 struct cpu *cpu = container_of(dev, struct cpu, sysdev); \
165 int ret = sscanf(buf, "%lx", &val); \
168 run_on_cpu(cpu->sysdev.id, write_##NAME, val); \
173 /* Let's define all possible registers, we'll only hook up the ones
174 * that are implemented on the current processor
177 SYSFS_PMCSETUP(mmcr0
, SPRN_MMCR0
);
178 SYSFS_PMCSETUP(mmcr1
, SPRN_MMCR1
);
179 SYSFS_PMCSETUP(mmcra
, SPRN_MMCRA
);
180 SYSFS_PMCSETUP(pmc1
, SPRN_PMC1
);
181 SYSFS_PMCSETUP(pmc2
, SPRN_PMC2
);
182 SYSFS_PMCSETUP(pmc3
, SPRN_PMC3
);
183 SYSFS_PMCSETUP(pmc4
, SPRN_PMC4
);
184 SYSFS_PMCSETUP(pmc5
, SPRN_PMC5
);
185 SYSFS_PMCSETUP(pmc6
, SPRN_PMC6
);
186 SYSFS_PMCSETUP(pmc7
, SPRN_PMC7
);
187 SYSFS_PMCSETUP(pmc8
, SPRN_PMC8
);
188 SYSFS_PMCSETUP(purr
, SPRN_PURR
);
189 SYSFS_PMCSETUP(spurr
, SPRN_SPURR
);
190 SYSFS_PMCSETUP(dscr
, SPRN_DSCR
);
192 SYSFS_PMCSETUP(pa6t_pmc0
, PA6T_SPRN_PMC0
);
193 SYSFS_PMCSETUP(pa6t_pmc1
, PA6T_SPRN_PMC1
);
194 SYSFS_PMCSETUP(pa6t_pmc2
, PA6T_SPRN_PMC2
);
195 SYSFS_PMCSETUP(pa6t_pmc3
, PA6T_SPRN_PMC3
);
196 SYSFS_PMCSETUP(pa6t_pmc4
, PA6T_SPRN_PMC4
);
197 SYSFS_PMCSETUP(pa6t_pmc5
, PA6T_SPRN_PMC5
);
200 static SYSDEV_ATTR(mmcra
, 0600, show_mmcra
, store_mmcra
);
201 static SYSDEV_ATTR(spurr
, 0600, show_spurr
, NULL
);
202 static SYSDEV_ATTR(dscr
, 0600, show_dscr
, store_dscr
);
203 static SYSDEV_ATTR(purr
, 0600, show_purr
, store_purr
);
205 static struct sysdev_attribute ibm_common_attrs
[] = {
206 _SYSDEV_ATTR(mmcr0
, 0600, show_mmcr0
, store_mmcr0
),
207 _SYSDEV_ATTR(mmcr1
, 0600, show_mmcr1
, store_mmcr1
),
210 static struct sysdev_attribute ibm_pmc_attrs
[] = {
211 _SYSDEV_ATTR(pmc1
, 0600, show_pmc1
, store_pmc1
),
212 _SYSDEV_ATTR(pmc2
, 0600, show_pmc2
, store_pmc2
),
213 _SYSDEV_ATTR(pmc3
, 0600, show_pmc3
, store_pmc3
),
214 _SYSDEV_ATTR(pmc4
, 0600, show_pmc4
, store_pmc4
),
215 _SYSDEV_ATTR(pmc5
, 0600, show_pmc5
, store_pmc5
),
216 _SYSDEV_ATTR(pmc6
, 0600, show_pmc6
, store_pmc6
),
217 _SYSDEV_ATTR(pmc7
, 0600, show_pmc7
, store_pmc7
),
218 _SYSDEV_ATTR(pmc8
, 0600, show_pmc8
, store_pmc8
),
221 static struct sysdev_attribute pa6t_attrs
[] = {
222 _SYSDEV_ATTR(mmcr0
, 0600, show_mmcr0
, store_mmcr0
),
223 _SYSDEV_ATTR(mmcr1
, 0600, show_mmcr1
, store_mmcr1
),
224 _SYSDEV_ATTR(pmc0
, 0600, show_pa6t_pmc0
, store_pa6t_pmc0
),
225 _SYSDEV_ATTR(pmc1
, 0600, show_pa6t_pmc1
, store_pa6t_pmc1
),
226 _SYSDEV_ATTR(pmc2
, 0600, show_pa6t_pmc2
, store_pa6t_pmc2
),
227 _SYSDEV_ATTR(pmc3
, 0600, show_pa6t_pmc3
, store_pa6t_pmc3
),
228 _SYSDEV_ATTR(pmc4
, 0600, show_pa6t_pmc4
, store_pa6t_pmc4
),
229 _SYSDEV_ATTR(pmc5
, 0600, show_pa6t_pmc5
, store_pa6t_pmc5
),
233 static void register_cpu_online(unsigned int cpu
)
235 struct cpu
*c
= &per_cpu(cpu_devices
, cpu
);
236 struct sys_device
*s
= &c
->sysdev
;
237 struct sysdev_attribute
*attrs
, *pmc_attrs
;
240 if (!firmware_has_feature(FW_FEATURE_ISERIES
) &&
241 cpu_has_feature(CPU_FTR_SMT
))
242 sysdev_create_file(s
, &attr_smt_snooze_delay
);
245 switch (cur_cpu_spec
->pmc_type
) {
247 attrs
= ibm_common_attrs
;
248 nattrs
= sizeof(ibm_common_attrs
) / sizeof(struct sysdev_attribute
);
249 pmc_attrs
= ibm_pmc_attrs
;
252 /* PA Semi starts counting at PMC0 */
254 nattrs
= sizeof(pa6t_attrs
) / sizeof(struct sysdev_attribute
);
263 for (i
= 0; i
< nattrs
; i
++)
264 sysdev_create_file(s
, &attrs
[i
]);
267 for (i
= 0; i
< cur_cpu_spec
->num_pmcs
; i
++)
268 sysdev_create_file(s
, &pmc_attrs
[i
]);
270 if (cpu_has_feature(CPU_FTR_MMCRA
))
271 sysdev_create_file(s
, &attr_mmcra
);
273 if (cpu_has_feature(CPU_FTR_PURR
))
274 sysdev_create_file(s
, &attr_purr
);
276 if (cpu_has_feature(CPU_FTR_SPURR
))
277 sysdev_create_file(s
, &attr_spurr
);
279 if (cpu_has_feature(CPU_FTR_DSCR
))
280 sysdev_create_file(s
, &attr_dscr
);
283 #ifdef CONFIG_HOTPLUG_CPU
284 static void unregister_cpu_online(unsigned int cpu
)
286 struct cpu
*c
= &per_cpu(cpu_devices
, cpu
);
287 struct sys_device
*s
= &c
->sysdev
;
288 struct sysdev_attribute
*attrs
, *pmc_attrs
;
291 BUG_ON(!c
->hotpluggable
);
293 if (!firmware_has_feature(FW_FEATURE_ISERIES
) &&
294 cpu_has_feature(CPU_FTR_SMT
))
295 sysdev_remove_file(s
, &attr_smt_snooze_delay
);
298 switch (cur_cpu_spec
->pmc_type
) {
300 attrs
= ibm_common_attrs
;
301 nattrs
= sizeof(ibm_common_attrs
) / sizeof(struct sysdev_attribute
);
302 pmc_attrs
= ibm_pmc_attrs
;
305 /* PA Semi starts counting at PMC0 */
307 nattrs
= sizeof(pa6t_attrs
) / sizeof(struct sysdev_attribute
);
316 for (i
= 0; i
< nattrs
; i
++)
317 sysdev_remove_file(s
, &attrs
[i
]);
320 for (i
= 0; i
< cur_cpu_spec
->num_pmcs
; i
++)
321 sysdev_remove_file(s
, &pmc_attrs
[i
]);
323 if (cpu_has_feature(CPU_FTR_MMCRA
))
324 sysdev_remove_file(s
, &attr_mmcra
);
326 if (cpu_has_feature(CPU_FTR_PURR
))
327 sysdev_remove_file(s
, &attr_purr
);
329 if (cpu_has_feature(CPU_FTR_SPURR
))
330 sysdev_remove_file(s
, &attr_spurr
);
332 if (cpu_has_feature(CPU_FTR_DSCR
))
333 sysdev_remove_file(s
, &attr_dscr
);
335 #endif /* CONFIG_HOTPLUG_CPU */
337 static int __cpuinit
sysfs_cpu_notify(struct notifier_block
*self
,
338 unsigned long action
, void *hcpu
)
340 unsigned int cpu
= (unsigned int)(long)hcpu
;
344 register_cpu_online(cpu
);
346 #ifdef CONFIG_HOTPLUG_CPU
348 unregister_cpu_online(cpu
);
355 static struct notifier_block __cpuinitdata sysfs_cpu_nb
= {
356 .notifier_call
= sysfs_cpu_notify
,
359 static DEFINE_MUTEX(cpu_mutex
);
361 int cpu_add_sysdev_attr(struct sysdev_attribute
*attr
)
365 mutex_lock(&cpu_mutex
);
367 for_each_possible_cpu(cpu
) {
368 sysdev_create_file(get_cpu_sysdev(cpu
), attr
);
371 mutex_unlock(&cpu_mutex
);
374 EXPORT_SYMBOL_GPL(cpu_add_sysdev_attr
);
376 int cpu_add_sysdev_attr_group(struct attribute_group
*attrs
)
379 struct sys_device
*sysdev
;
381 mutex_lock(&cpu_mutex
);
383 for_each_possible_cpu(cpu
) {
384 sysdev
= get_cpu_sysdev(cpu
);
385 sysfs_create_group(&sysdev
->kobj
, attrs
);
388 mutex_unlock(&cpu_mutex
);
391 EXPORT_SYMBOL_GPL(cpu_add_sysdev_attr_group
);
394 void cpu_remove_sysdev_attr(struct sysdev_attribute
*attr
)
398 mutex_lock(&cpu_mutex
);
400 for_each_possible_cpu(cpu
) {
401 sysdev_remove_file(get_cpu_sysdev(cpu
), attr
);
404 mutex_unlock(&cpu_mutex
);
406 EXPORT_SYMBOL_GPL(cpu_remove_sysdev_attr
);
408 void cpu_remove_sysdev_attr_group(struct attribute_group
*attrs
)
411 struct sys_device
*sysdev
;
413 mutex_lock(&cpu_mutex
);
415 for_each_possible_cpu(cpu
) {
416 sysdev
= get_cpu_sysdev(cpu
);
417 sysfs_remove_group(&sysdev
->kobj
, attrs
);
420 mutex_unlock(&cpu_mutex
);
422 EXPORT_SYMBOL_GPL(cpu_remove_sysdev_attr_group
);
428 static void register_nodes(void)
432 for (i
= 0; i
< MAX_NUMNODES
; i
++)
433 register_one_node(i
);
436 int sysfs_add_device_to_node(struct sys_device
*dev
, int nid
)
438 struct node
*node
= &node_devices
[nid
];
439 return sysfs_create_link(&node
->sysdev
.kobj
, &dev
->kobj
,
440 kobject_name(&dev
->kobj
));
443 void sysfs_remove_device_from_node(struct sys_device
*dev
, int nid
)
445 struct node
*node
= &node_devices
[nid
];
446 sysfs_remove_link(&node
->sysdev
.kobj
, kobject_name(&dev
->kobj
));
450 static void register_nodes(void)
457 EXPORT_SYMBOL_GPL(sysfs_add_device_to_node
);
458 EXPORT_SYMBOL_GPL(sysfs_remove_device_from_node
);
460 /* Only valid if CPU is present. */
461 static ssize_t
show_physical_id(struct sys_device
*dev
, char *buf
)
463 struct cpu
*cpu
= container_of(dev
, struct cpu
, sysdev
);
465 return sprintf(buf
, "%d\n", get_hard_smp_processor_id(cpu
->sysdev
.id
));
467 static SYSDEV_ATTR(physical_id
, 0444, show_physical_id
, NULL
);
469 static int __init
topology_init(void)
474 register_cpu_notifier(&sysfs_cpu_nb
);
476 for_each_possible_cpu(cpu
) {
477 struct cpu
*c
= &per_cpu(cpu_devices
, cpu
);
480 * For now, we just see if the system supports making
481 * the RTAS calls for CPU hotplug. But, there may be a
482 * more comprehensive way to do this for an individual
483 * CPU. For instance, the boot cpu might never be valid
489 if (cpu_online(cpu
) || c
->hotpluggable
) {
490 register_cpu(c
, cpu
);
492 sysdev_create_file(&c
->sysdev
, &attr_physical_id
);
496 register_cpu_online(cpu
);
501 __initcall(topology_init
);