1 #include <linux/config.h>
2 #include <linux/sysdev.h>
5 #include <linux/percpu.h>
6 #include <linux/init.h>
7 #include <linux/sched.h>
8 #include <linux/module.h>
9 #include <linux/nodemask.h>
10 #include <linux/cpumask.h>
11 #include <linux/notifier.h>
13 #include <asm/current.h>
14 #include <asm/processor.h>
15 #include <asm/cputable.h>
16 #include <asm/firmware.h>
17 #include <asm/hvcall.h>
19 #include <asm/systemcfg.h>
21 #include <asm/lppaca.h>
22 #include <asm/machdep.h>
24 static DEFINE_PER_CPU(struct cpu
, cpu_devices
);
28 #ifdef CONFIG_PPC_MULTIPLATFORM
29 /* default to snooze disabled */
30 DEFINE_PER_CPU(unsigned long, smt_snooze_delay
);
32 static ssize_t
store_smt_snooze_delay(struct sys_device
*dev
, const char *buf
,
35 struct cpu
*cpu
= container_of(dev
, struct cpu
, sysdev
);
39 ret
= sscanf(buf
, "%lu", &snooze
);
43 per_cpu(smt_snooze_delay
, cpu
->sysdev
.id
) = snooze
;
48 static ssize_t
show_smt_snooze_delay(struct sys_device
*dev
, char *buf
)
50 struct cpu
*cpu
= container_of(dev
, struct cpu
, sysdev
);
52 return sprintf(buf
, "%lu\n", per_cpu(smt_snooze_delay
, cpu
->sysdev
.id
));
55 static SYSDEV_ATTR(smt_snooze_delay
, 0644, show_smt_snooze_delay
,
56 store_smt_snooze_delay
);
58 /* Only parse OF options if the matching cmdline option was not specified */
59 static int smt_snooze_cmdline
;
61 static int __init
smt_setup(void)
63 struct device_node
*options
;
67 if (!cpu_has_feature(CPU_FTR_SMT
))
70 options
= find_path_device("/options");
74 val
= (unsigned int *)get_property(options
, "ibm,smt-snooze-delay",
76 if (!smt_snooze_cmdline
&& val
) {
78 per_cpu(smt_snooze_delay
, cpu
) = *val
;
83 __initcall(smt_setup
);
85 static int __init
setup_smt_snooze_delay(char *str
)
90 if (!cpu_has_feature(CPU_FTR_SMT
))
93 smt_snooze_cmdline
= 1;
95 if (get_option(&str
, &snooze
)) {
97 per_cpu(smt_snooze_delay
, cpu
) = snooze
;
102 __setup("smt-snooze-delay=", setup_smt_snooze_delay
);
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)
114 #ifdef CONFIG_PPC_PSERIES
115 unsigned long set
, reset
;
116 #endif /* CONFIG_PPC_PSERIES */
118 /* Only need to enable them once */
119 if (__get_cpu_var(pmcs_enabled
))
122 __get_cpu_var(pmcs_enabled
) = 1;
124 switch (systemcfg
->platform
) {
125 case PLATFORM_PSERIES
:
126 case PLATFORM_POWERMAC
:
128 hid0
|= 1UL << (63 - 20);
130 /* POWER4 requires the following sequence */
140 "isync" : "=&r" (hid0
) : "i" (HID0
), "0" (hid0
):
144 #ifdef CONFIG_PPC_PSERIES
145 case PLATFORM_PSERIES_LPAR
:
148 plpar_hcall_norets(H_PERFMON
, set
, reset
);
150 #endif /* CONFIG_PPC_PSERIES */
156 /* instruct hypervisor to maintain PMCs */
157 if (firmware_has_feature(FW_FEATURE_SPLPAR
))
158 get_paca()->lppaca
.pmcregs_in_use
= 1;
164 void ppc64_enable_pmcs(void)
166 /* XXX Implement for iseries */
168 #endif /* CONFIG_PPC_MULTIPLATFORM */
170 EXPORT_SYMBOL(ppc64_enable_pmcs
);
172 /* XXX convert to rusty's on_one_cpu */
173 static unsigned long run_on_cpu(unsigned long cpu
,
174 unsigned long (*func
)(unsigned long),
177 cpumask_t old_affinity
= current
->cpus_allowed
;
180 /* should return -EINVAL to userspace */
181 if (set_cpus_allowed(current
, cpumask_of_cpu(cpu
)))
186 set_cpus_allowed(current
, old_affinity
);
191 #define SYSFS_PMCSETUP(NAME, ADDRESS) \
192 static unsigned long read_##NAME(unsigned long junk) \
194 return mfspr(ADDRESS); \
196 static unsigned long write_##NAME(unsigned long val) \
198 ppc64_enable_pmcs(); \
199 mtspr(ADDRESS, val); \
202 static ssize_t show_##NAME(struct sys_device *dev, char *buf) \
204 struct cpu *cpu = container_of(dev, struct cpu, sysdev); \
205 unsigned long val = run_on_cpu(cpu->sysdev.id, read_##NAME, 0); \
206 return sprintf(buf, "%lx\n", val); \
208 static ssize_t __attribute_used__ \
209 store_##NAME(struct sys_device *dev, const char *buf, size_t count) \
211 struct cpu *cpu = container_of(dev, struct cpu, sysdev); \
213 int ret = sscanf(buf, "%lx", &val); \
216 run_on_cpu(cpu->sysdev.id, write_##NAME, val); \
220 SYSFS_PMCSETUP(mmcr0
, SPRN_MMCR0
);
221 SYSFS_PMCSETUP(mmcr1
, SPRN_MMCR1
);
222 SYSFS_PMCSETUP(mmcra
, SPRN_MMCRA
);
223 SYSFS_PMCSETUP(pmc1
, SPRN_PMC1
);
224 SYSFS_PMCSETUP(pmc2
, SPRN_PMC2
);
225 SYSFS_PMCSETUP(pmc3
, SPRN_PMC3
);
226 SYSFS_PMCSETUP(pmc4
, SPRN_PMC4
);
227 SYSFS_PMCSETUP(pmc5
, SPRN_PMC5
);
228 SYSFS_PMCSETUP(pmc6
, SPRN_PMC6
);
229 SYSFS_PMCSETUP(pmc7
, SPRN_PMC7
);
230 SYSFS_PMCSETUP(pmc8
, SPRN_PMC8
);
231 SYSFS_PMCSETUP(purr
, SPRN_PURR
);
233 static SYSDEV_ATTR(mmcr0
, 0600, show_mmcr0
, store_mmcr0
);
234 static SYSDEV_ATTR(mmcr1
, 0600, show_mmcr1
, store_mmcr1
);
235 static SYSDEV_ATTR(mmcra
, 0600, show_mmcra
, store_mmcra
);
236 static SYSDEV_ATTR(pmc1
, 0600, show_pmc1
, store_pmc1
);
237 static SYSDEV_ATTR(pmc2
, 0600, show_pmc2
, store_pmc2
);
238 static SYSDEV_ATTR(pmc3
, 0600, show_pmc3
, store_pmc3
);
239 static SYSDEV_ATTR(pmc4
, 0600, show_pmc4
, store_pmc4
);
240 static SYSDEV_ATTR(pmc5
, 0600, show_pmc5
, store_pmc5
);
241 static SYSDEV_ATTR(pmc6
, 0600, show_pmc6
, store_pmc6
);
242 static SYSDEV_ATTR(pmc7
, 0600, show_pmc7
, store_pmc7
);
243 static SYSDEV_ATTR(pmc8
, 0600, show_pmc8
, store_pmc8
);
244 static SYSDEV_ATTR(purr
, 0600, show_purr
, NULL
);
246 static void register_cpu_online(unsigned int cpu
)
248 struct cpu
*c
= &per_cpu(cpu_devices
, cpu
);
249 struct sys_device
*s
= &c
->sysdev
;
251 #ifndef CONFIG_PPC_ISERIES
252 if (cpu_has_feature(CPU_FTR_SMT
))
253 sysdev_create_file(s
, &attr_smt_snooze_delay
);
258 sysdev_create_file(s
, &attr_mmcr0
);
259 sysdev_create_file(s
, &attr_mmcr1
);
261 if (cpu_has_feature(CPU_FTR_MMCRA
))
262 sysdev_create_file(s
, &attr_mmcra
);
264 sysdev_create_file(s
, &attr_pmc1
);
265 sysdev_create_file(s
, &attr_pmc2
);
266 sysdev_create_file(s
, &attr_pmc3
);
267 sysdev_create_file(s
, &attr_pmc4
);
268 sysdev_create_file(s
, &attr_pmc5
);
269 sysdev_create_file(s
, &attr_pmc6
);
271 if (cpu_has_feature(CPU_FTR_PMC8
)) {
272 sysdev_create_file(s
, &attr_pmc7
);
273 sysdev_create_file(s
, &attr_pmc8
);
276 if (cpu_has_feature(CPU_FTR_SMT
))
277 sysdev_create_file(s
, &attr_purr
);
280 #ifdef CONFIG_HOTPLUG_CPU
281 static void unregister_cpu_online(unsigned int cpu
)
283 struct cpu
*c
= &per_cpu(cpu_devices
, cpu
);
284 struct sys_device
*s
= &c
->sysdev
;
286 BUG_ON(c
->no_control
);
288 #ifndef CONFIG_PPC_ISERIES
289 if (cpu_has_feature(CPU_FTR_SMT
))
290 sysdev_remove_file(s
, &attr_smt_snooze_delay
);
295 sysdev_remove_file(s
, &attr_mmcr0
);
296 sysdev_remove_file(s
, &attr_mmcr1
);
298 if (cpu_has_feature(CPU_FTR_MMCRA
))
299 sysdev_remove_file(s
, &attr_mmcra
);
301 sysdev_remove_file(s
, &attr_pmc1
);
302 sysdev_remove_file(s
, &attr_pmc2
);
303 sysdev_remove_file(s
, &attr_pmc3
);
304 sysdev_remove_file(s
, &attr_pmc4
);
305 sysdev_remove_file(s
, &attr_pmc5
);
306 sysdev_remove_file(s
, &attr_pmc6
);
308 if (cpu_has_feature(CPU_FTR_PMC8
)) {
309 sysdev_remove_file(s
, &attr_pmc7
);
310 sysdev_remove_file(s
, &attr_pmc8
);
313 if (cpu_has_feature(CPU_FTR_SMT
))
314 sysdev_remove_file(s
, &attr_purr
);
316 #endif /* CONFIG_HOTPLUG_CPU */
318 static int __devinit
sysfs_cpu_notify(struct notifier_block
*self
,
319 unsigned long action
, void *hcpu
)
321 unsigned int cpu
= (unsigned int)(long)hcpu
;
325 register_cpu_online(cpu
);
327 #ifdef CONFIG_HOTPLUG_CPU
329 unregister_cpu_online(cpu
);
336 static struct notifier_block __devinitdata sysfs_cpu_nb
= {
337 .notifier_call
= sysfs_cpu_notify
,
343 static struct node node_devices
[MAX_NUMNODES
];
345 static void register_nodes(void)
349 for (i
= 0; i
< MAX_NUMNODES
; i
++) {
350 if (node_online(i
)) {
351 int p_node
= parent_node(i
);
352 struct node
*parent
= NULL
;
355 parent
= &node_devices
[p_node
];
357 register_node(&node_devices
[i
], i
, parent
);
362 static void register_nodes(void)
368 /* Only valid if CPU is present. */
369 static ssize_t
show_physical_id(struct sys_device
*dev
, char *buf
)
371 struct cpu
*cpu
= container_of(dev
, struct cpu
, sysdev
);
373 return sprintf(buf
, "%d\n", get_hard_smp_processor_id(cpu
->sysdev
.id
));
375 static SYSDEV_ATTR(physical_id
, 0444, show_physical_id
, NULL
);
377 static int __init
topology_init(void)
380 struct node
*parent
= NULL
;
384 register_cpu_notifier(&sysfs_cpu_nb
);
387 struct cpu
*c
= &per_cpu(cpu_devices
, cpu
);
390 /* The node to which a cpu belongs can't be known
391 * until the cpu is made present.
394 if (cpu_present(cpu
))
395 parent
= &node_devices
[cpu_to_node(cpu
)];
398 * For now, we just see if the system supports making
399 * the RTAS calls for CPU hotplug. But, there may be a
400 * more comprehensive way to do this for an individual
401 * CPU. For instance, the boot cpu might never be valid
407 if (cpu_online(cpu
) || (c
->no_control
== 0)) {
408 register_cpu(c
, cpu
, parent
);
410 sysdev_create_file(&c
->sysdev
, &attr_physical_id
);
414 register_cpu_online(cpu
);
419 __initcall(topology_init
);