1 #include <linux/sysdev.h> 2 #include <linux/cpu.h> 3 #include <linux/smp.h> 4 #include <linux/percpu.h> 5 #include <linux/init.h> 6 #include <linux/sched.h> 7 #include <linux/export.h> 8 #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> 15 #include <asm/firmware.h> 16 #include <asm/hvcall.h> 17 #include <asm/prom.h> 18 #include <asm/machdep.h> 19 #include <asm/smp.h> 20 #include <asm/pmc.h> 21 22 #include "cacheinfo.h" 23 24 #ifdef CONFIG_PPC64 25 #include <asm/paca.h> 26 #include <asm/lppaca.h> 27 #endif 28 29 static DEFINE_PER_CPU(struct cpu, cpu_devices); 30 31 /* 32 * SMT snooze delay stuff, 64-bit only for now 33 */ 34 35 #ifdef CONFIG_PPC64 36 37 /* Time in microseconds we delay before sleeping in the idle loop */ 38 DEFINE_PER_CPU(long, smt_snooze_delay) = { 100 }; 39 40 static ssize_t store_smt_snooze_delay(struct sys_device *dev, 41 struct sysdev_attribute *attr, 42 const char *buf, 43 size_t count) 44 { 45 struct cpu *cpu = container_of(dev, struct cpu, sysdev); 46 ssize_t ret; 47 long snooze; 48 49 ret = sscanf(buf, "%ld", &snooze); 50 if (ret != 1) 51 return -EINVAL; 52 53 per_cpu(smt_snooze_delay, cpu->sysdev.id) = snooze; 54 55 return count; 56 } 57 58 static ssize_t show_smt_snooze_delay(struct sys_device *dev, 59 struct sysdev_attribute *attr, 60 char *buf) 61 { 62 struct cpu *cpu = container_of(dev, struct cpu, sysdev); 63 64 return sprintf(buf, "%ld\n", per_cpu(smt_snooze_delay, cpu->sysdev.id)); 65 } 66 67 static SYSDEV_ATTR(smt_snooze_delay, 0644, show_smt_snooze_delay, 68 store_smt_snooze_delay); 69 70 static int __init setup_smt_snooze_delay(char *str) 71 { 72 unsigned int cpu; 73 long snooze; 74 75 if (!cpu_has_feature(CPU_FTR_SMT)) 76 return 1; 77 78 snooze = simple_strtol(str, NULL, 10); 79 for_each_possible_cpu(cpu) 80 per_cpu(smt_snooze_delay, cpu) = snooze; 81 82 return 1; 83 } 84 __setup("smt-snooze-delay=", setup_smt_snooze_delay); 85 86 #endif /* CONFIG_PPC64 */ 87 88 /* 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 93 static DEFINE_PER_CPU(char, pmcs_enabled); 94 95 void ppc_enable_pmcs(void) 96 { 97 ppc_set_pmu_inuse(1); 98 99 /* Only need to enable them once */ 100 if (__get_cpu_var(pmcs_enabled)) 101 return; 102 103 __get_cpu_var(pmcs_enabled) = 1; 104 105 if (ppc_md.enable_pmcs) 106 ppc_md.enable_pmcs(); 107 } 108 EXPORT_SYMBOL(ppc_enable_pmcs); 109 110 #define SYSFS_PMCSETUP(NAME, ADDRESS) \ 111 static void read_##NAME(void *val) \ 112 { \ 113 *(unsigned long *)val = mfspr(ADDRESS); \ 114 } \ 115 static void write_##NAME(void *val) \ 116 { \ 117 ppc_enable_pmcs(); \ 118 mtspr(ADDRESS, *(unsigned long *)val); \ 119 } \ 120 static ssize_t show_##NAME(struct sys_device *dev, \ 121 struct sysdev_attribute *attr, \ 122 char *buf) \ 123 { \ 124 struct cpu *cpu = container_of(dev, struct cpu, sysdev); \ 125 unsigned long val; \ 126 smp_call_function_single(cpu->sysdev.id, read_##NAME, &val, 1); \ 127 return sprintf(buf, "%lx\n", val); \ 128 } \ 129 static ssize_t __used \ 130 store_##NAME(struct sys_device *dev, struct sysdev_attribute *attr, \ 131 const char *buf, size_t count) \ 132 { \ 133 struct cpu *cpu = container_of(dev, struct cpu, sysdev); \ 134 unsigned long val; \ 135 int ret = sscanf(buf, "%lx", &val); \ 136 if (ret != 1) \ 137 return -EINVAL; \ 138 smp_call_function_single(cpu->sysdev.id, write_##NAME, &val, 1); \ 139 return count; \ 140 } 141 142 143 /* Let's define all possible registers, we'll only hook up the ones 144 * that are implemented on the current processor 145 */ 146 147 #if defined(CONFIG_PPC64) 148 #define HAS_PPC_PMC_CLASSIC 1 149 #define HAS_PPC_PMC_IBM 1 150 #define HAS_PPC_PMC_PA6T 1 151 #elif defined(CONFIG_6xx) 152 #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 159 SYSFS_PMCSETUP(mmcr0, SPRN_MMCR0); 160 SYSFS_PMCSETUP(mmcr1, SPRN_MMCR1); 161 SYSFS_PMCSETUP(pmc1, SPRN_PMC1); 162 SYSFS_PMCSETUP(pmc2, SPRN_PMC2); 163 SYSFS_PMCSETUP(pmc3, SPRN_PMC3); 164 SYSFS_PMCSETUP(pmc4, SPRN_PMC4); 165 SYSFS_PMCSETUP(pmc5, SPRN_PMC5); 166 SYSFS_PMCSETUP(pmc6, SPRN_PMC6); 167 168 #ifdef HAS_PPC_PMC_G4 169 SYSFS_PMCSETUP(mmcr2, SPRN_MMCR2); 170 #endif 171 172 #ifdef CONFIG_PPC64 173 SYSFS_PMCSETUP(pmc7, SPRN_PMC7); 174 SYSFS_PMCSETUP(pmc8, SPRN_PMC8); 175 176 SYSFS_PMCSETUP(mmcra, SPRN_MMCRA); 177 SYSFS_PMCSETUP(purr, SPRN_PURR); 178 SYSFS_PMCSETUP(spurr, SPRN_SPURR); 179 SYSFS_PMCSETUP(dscr, SPRN_DSCR); 180 181 static SYSDEV_ATTR(mmcra, 0600, show_mmcra, store_mmcra); 182 static SYSDEV_ATTR(spurr, 0600, show_spurr, NULL); 183 static SYSDEV_ATTR(dscr, 0600, show_dscr, store_dscr); 184 static SYSDEV_ATTR(purr, 0600, show_purr, store_purr); 185 186 unsigned long dscr_default = 0; 187 EXPORT_SYMBOL(dscr_default); 188 189 static ssize_t show_dscr_default(struct sysdev_class *class, 190 struct sysdev_class_attribute *attr, char *buf) 191 { 192 return sprintf(buf, "%lx\n", dscr_default); 193 } 194 195 static ssize_t __used store_dscr_default(struct sysdev_class *class, 196 struct sysdev_class_attribute *attr, const char *buf, 197 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 210 static SYSDEV_CLASS_ATTR(dscr_default, 0600, 211 show_dscr_default, store_dscr_default); 212 213 static void sysfs_create_dscr_default(void) 214 { 215 int err = 0; 216 if (cpu_has_feature(CPU_FTR_DSCR)) 217 err = sysfs_create_file(&cpu_sysdev_class.kset.kobj, 218 &attr_dscr_default.attr); 219 } 220 #endif /* CONFIG_PPC64 */ 221 222 #ifdef HAS_PPC_PMC_PA6T 223 SYSFS_PMCSETUP(pa6t_pmc0, SPRN_PA6T_PMC0); 224 SYSFS_PMCSETUP(pa6t_pmc1, SPRN_PA6T_PMC1); 225 SYSFS_PMCSETUP(pa6t_pmc2, SPRN_PA6T_PMC2); 226 SYSFS_PMCSETUP(pa6t_pmc3, SPRN_PA6T_PMC3); 227 SYSFS_PMCSETUP(pa6t_pmc4, SPRN_PA6T_PMC4); 228 SYSFS_PMCSETUP(pa6t_pmc5, SPRN_PA6T_PMC5); 229 #ifdef CONFIG_DEBUG_KERNEL 230 SYSFS_PMCSETUP(hid0, SPRN_HID0); 231 SYSFS_PMCSETUP(hid1, SPRN_HID1); 232 SYSFS_PMCSETUP(hid4, SPRN_HID4); 233 SYSFS_PMCSETUP(hid5, SPRN_HID5); 234 SYSFS_PMCSETUP(ima0, SPRN_PA6T_IMA0); 235 SYSFS_PMCSETUP(ima1, SPRN_PA6T_IMA1); 236 SYSFS_PMCSETUP(ima2, SPRN_PA6T_IMA2); 237 SYSFS_PMCSETUP(ima3, SPRN_PA6T_IMA3); 238 SYSFS_PMCSETUP(ima4, SPRN_PA6T_IMA4); 239 SYSFS_PMCSETUP(ima5, SPRN_PA6T_IMA5); 240 SYSFS_PMCSETUP(ima6, SPRN_PA6T_IMA6); 241 SYSFS_PMCSETUP(ima7, SPRN_PA6T_IMA7); 242 SYSFS_PMCSETUP(ima8, SPRN_PA6T_IMA8); 243 SYSFS_PMCSETUP(ima9, SPRN_PA6T_IMA9); 244 SYSFS_PMCSETUP(imaat, SPRN_PA6T_IMAAT); 245 SYSFS_PMCSETUP(btcr, SPRN_PA6T_BTCR); 246 SYSFS_PMCSETUP(pccr, SPRN_PA6T_PCCR); 247 SYSFS_PMCSETUP(rpccr, SPRN_PA6T_RPCCR); 248 SYSFS_PMCSETUP(der, SPRN_PA6T_DER); 249 SYSFS_PMCSETUP(mer, SPRN_PA6T_MER); 250 SYSFS_PMCSETUP(ber, SPRN_PA6T_BER); 251 SYSFS_PMCSETUP(ier, SPRN_PA6T_IER); 252 SYSFS_PMCSETUP(sier, SPRN_PA6T_SIER); 253 SYSFS_PMCSETUP(siar, SPRN_PA6T_SIAR); 254 SYSFS_PMCSETUP(tsr0, SPRN_PA6T_TSR0); 255 SYSFS_PMCSETUP(tsr1, SPRN_PA6T_TSR1); 256 SYSFS_PMCSETUP(tsr2, SPRN_PA6T_TSR2); 257 SYSFS_PMCSETUP(tsr3, SPRN_PA6T_TSR3); 258 #endif /* CONFIG_DEBUG_KERNEL */ 259 #endif /* HAS_PPC_PMC_PA6T */ 260 261 #ifdef HAS_PPC_PMC_IBM 262 static struct sysdev_attribute ibm_common_attrs[] = { 263 _SYSDEV_ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0), 264 _SYSDEV_ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1), 265 }; 266 #endif /* HAS_PPC_PMC_G4 */ 267 268 #ifdef HAS_PPC_PMC_G4 269 static struct sysdev_attribute g4_common_attrs[] = { 270 _SYSDEV_ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0), 271 _SYSDEV_ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1), 272 _SYSDEV_ATTR(mmcr2, 0600, show_mmcr2, store_mmcr2), 273 }; 274 #endif /* HAS_PPC_PMC_G4 */ 275 276 static struct sysdev_attribute classic_pmc_attrs[] = { 277 _SYSDEV_ATTR(pmc1, 0600, show_pmc1, store_pmc1), 278 _SYSDEV_ATTR(pmc2, 0600, show_pmc2, store_pmc2), 279 _SYSDEV_ATTR(pmc3, 0600, show_pmc3, store_pmc3), 280 _SYSDEV_ATTR(pmc4, 0600, show_pmc4, store_pmc4), 281 _SYSDEV_ATTR(pmc5, 0600, show_pmc5, store_pmc5), 282 _SYSDEV_ATTR(pmc6, 0600, show_pmc6, store_pmc6), 283 #ifdef CONFIG_PPC64 284 _SYSDEV_ATTR(pmc7, 0600, show_pmc7, store_pmc7), 285 _SYSDEV_ATTR(pmc8, 0600, show_pmc8, store_pmc8), 286 #endif 287 }; 288 289 #ifdef HAS_PPC_PMC_PA6T 290 static struct sysdev_attribute pa6t_attrs[] = { 291 _SYSDEV_ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0), 292 _SYSDEV_ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1), 293 _SYSDEV_ATTR(pmc0, 0600, show_pa6t_pmc0, store_pa6t_pmc0), 294 _SYSDEV_ATTR(pmc1, 0600, show_pa6t_pmc1, store_pa6t_pmc1), 295 _SYSDEV_ATTR(pmc2, 0600, show_pa6t_pmc2, store_pa6t_pmc2), 296 _SYSDEV_ATTR(pmc3, 0600, show_pa6t_pmc3, store_pa6t_pmc3), 297 _SYSDEV_ATTR(pmc4, 0600, show_pa6t_pmc4, store_pa6t_pmc4), 298 _SYSDEV_ATTR(pmc5, 0600, show_pa6t_pmc5, store_pa6t_pmc5), 299 #ifdef CONFIG_DEBUG_KERNEL 300 _SYSDEV_ATTR(hid0, 0600, show_hid0, store_hid0), 301 _SYSDEV_ATTR(hid1, 0600, show_hid1, store_hid1), 302 _SYSDEV_ATTR(hid4, 0600, show_hid4, store_hid4), 303 _SYSDEV_ATTR(hid5, 0600, show_hid5, store_hid5), 304 _SYSDEV_ATTR(ima0, 0600, show_ima0, store_ima0), 305 _SYSDEV_ATTR(ima1, 0600, show_ima1, store_ima1), 306 _SYSDEV_ATTR(ima2, 0600, show_ima2, store_ima2), 307 _SYSDEV_ATTR(ima3, 0600, show_ima3, store_ima3), 308 _SYSDEV_ATTR(ima4, 0600, show_ima4, store_ima4), 309 _SYSDEV_ATTR(ima5, 0600, show_ima5, store_ima5), 310 _SYSDEV_ATTR(ima6, 0600, show_ima6, store_ima6), 311 _SYSDEV_ATTR(ima7, 0600, show_ima7, store_ima7), 312 _SYSDEV_ATTR(ima8, 0600, show_ima8, store_ima8), 313 _SYSDEV_ATTR(ima9, 0600, show_ima9, store_ima9), 314 _SYSDEV_ATTR(imaat, 0600, show_imaat, store_imaat), 315 _SYSDEV_ATTR(btcr, 0600, show_btcr, store_btcr), 316 _SYSDEV_ATTR(pccr, 0600, show_pccr, store_pccr), 317 _SYSDEV_ATTR(rpccr, 0600, show_rpccr, store_rpccr), 318 _SYSDEV_ATTR(der, 0600, show_der, store_der), 319 _SYSDEV_ATTR(mer, 0600, show_mer, store_mer), 320 _SYSDEV_ATTR(ber, 0600, show_ber, store_ber), 321 _SYSDEV_ATTR(ier, 0600, show_ier, store_ier), 322 _SYSDEV_ATTR(sier, 0600, show_sier, store_sier), 323 _SYSDEV_ATTR(siar, 0600, show_siar, store_siar), 324 _SYSDEV_ATTR(tsr0, 0600, show_tsr0, store_tsr0), 325 _SYSDEV_ATTR(tsr1, 0600, show_tsr1, store_tsr1), 326 _SYSDEV_ATTR(tsr2, 0600, show_tsr2, store_tsr2), 327 _SYSDEV_ATTR(tsr3, 0600, show_tsr3, store_tsr3), 328 #endif /* CONFIG_DEBUG_KERNEL */ 329 }; 330 #endif /* HAS_PPC_PMC_PA6T */ 331 #endif /* HAS_PPC_PMC_CLASSIC */ 332 333 static void __cpuinit register_cpu_online(unsigned int cpu) 334 { 335 struct cpu *c = &per_cpu(cpu_devices, cpu); 336 struct sys_device *s = &c->sysdev; 337 struct sysdev_attribute *attrs, *pmc_attrs; 338 int i, nattrs; 339 340 #ifdef CONFIG_PPC64 341 if (!firmware_has_feature(FW_FEATURE_ISERIES) && 342 cpu_has_feature(CPU_FTR_SMT)) 343 sysdev_create_file(s, &attr_smt_snooze_delay); 344 #endif 345 346 /* PMC stuff */ 347 switch (cur_cpu_spec->pmc_type) { 348 #ifdef HAS_PPC_PMC_IBM 349 case PPC_PMC_IBM: 350 attrs = ibm_common_attrs; 351 nattrs = sizeof(ibm_common_attrs) / sizeof(struct sysdev_attribute); 352 pmc_attrs = classic_pmc_attrs; 353 break; 354 #endif /* HAS_PPC_PMC_IBM */ 355 #ifdef HAS_PPC_PMC_G4 356 case PPC_PMC_G4: 357 attrs = g4_common_attrs; 358 nattrs = sizeof(g4_common_attrs) / sizeof(struct sysdev_attribute); 359 pmc_attrs = classic_pmc_attrs; 360 break; 361 #endif /* HAS_PPC_PMC_G4 */ 362 #ifdef HAS_PPC_PMC_PA6T 363 case PPC_PMC_PA6T: 364 /* PA Semi starts counting at PMC0 */ 365 attrs = pa6t_attrs; 366 nattrs = sizeof(pa6t_attrs) / sizeof(struct sysdev_attribute); 367 pmc_attrs = NULL; 368 break; 369 #endif /* HAS_PPC_PMC_PA6T */ 370 default: 371 attrs = NULL; 372 nattrs = 0; 373 pmc_attrs = NULL; 374 } 375 376 for (i = 0; i < nattrs; i++) 377 sysdev_create_file(s, &attrs[i]); 378 379 if (pmc_attrs) 380 for (i = 0; i < cur_cpu_spec->num_pmcs; i++) 381 sysdev_create_file(s, &pmc_attrs[i]); 382 383 #ifdef CONFIG_PPC64 384 if (cpu_has_feature(CPU_FTR_MMCRA)) 385 sysdev_create_file(s, &attr_mmcra); 386 387 if (cpu_has_feature(CPU_FTR_PURR)) 388 sysdev_create_file(s, &attr_purr); 389 390 if (cpu_has_feature(CPU_FTR_SPURR)) 391 sysdev_create_file(s, &attr_spurr); 392 393 if (cpu_has_feature(CPU_FTR_DSCR)) 394 sysdev_create_file(s, &attr_dscr); 395 #endif /* CONFIG_PPC64 */ 396 397 cacheinfo_cpu_online(cpu); 398 } 399 400 #ifdef CONFIG_HOTPLUG_CPU 401 static void unregister_cpu_online(unsigned int cpu) 402 { 403 struct cpu *c = &per_cpu(cpu_devices, cpu); 404 struct sys_device *s = &c->sysdev; 405 struct sysdev_attribute *attrs, *pmc_attrs; 406 int i, nattrs; 407 408 BUG_ON(!c->hotpluggable); 409 410 #ifdef CONFIG_PPC64 411 if (!firmware_has_feature(FW_FEATURE_ISERIES) && 412 cpu_has_feature(CPU_FTR_SMT)) 413 sysdev_remove_file(s, &attr_smt_snooze_delay); 414 #endif 415 416 /* PMC stuff */ 417 switch (cur_cpu_spec->pmc_type) { 418 #ifdef HAS_PPC_PMC_IBM 419 case PPC_PMC_IBM: 420 attrs = ibm_common_attrs; 421 nattrs = sizeof(ibm_common_attrs) / sizeof(struct sysdev_attribute); 422 pmc_attrs = classic_pmc_attrs; 423 break; 424 #endif /* HAS_PPC_PMC_IBM */ 425 #ifdef HAS_PPC_PMC_G4 426 case PPC_PMC_G4: 427 attrs = g4_common_attrs; 428 nattrs = sizeof(g4_common_attrs) / sizeof(struct sysdev_attribute); 429 pmc_attrs = classic_pmc_attrs; 430 break; 431 #endif /* HAS_PPC_PMC_G4 */ 432 #ifdef HAS_PPC_PMC_PA6T 433 case PPC_PMC_PA6T: 434 /* PA Semi starts counting at PMC0 */ 435 attrs = pa6t_attrs; 436 nattrs = sizeof(pa6t_attrs) / sizeof(struct sysdev_attribute); 437 pmc_attrs = NULL; 438 break; 439 #endif /* HAS_PPC_PMC_PA6T */ 440 default: 441 attrs = NULL; 442 nattrs = 0; 443 pmc_attrs = NULL; 444 } 445 446 for (i = 0; i < nattrs; i++) 447 sysdev_remove_file(s, &attrs[i]); 448 449 if (pmc_attrs) 450 for (i = 0; i < cur_cpu_spec->num_pmcs; i++) 451 sysdev_remove_file(s, &pmc_attrs[i]); 452 453 #ifdef CONFIG_PPC64 454 if (cpu_has_feature(CPU_FTR_MMCRA)) 455 sysdev_remove_file(s, &attr_mmcra); 456 457 if (cpu_has_feature(CPU_FTR_PURR)) 458 sysdev_remove_file(s, &attr_purr); 459 460 if (cpu_has_feature(CPU_FTR_SPURR)) 461 sysdev_remove_file(s, &attr_spurr); 462 463 if (cpu_has_feature(CPU_FTR_DSCR)) 464 sysdev_remove_file(s, &attr_dscr); 465 #endif /* CONFIG_PPC64 */ 466 467 cacheinfo_cpu_offline(cpu); 468 } 469 470 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE 471 ssize_t arch_cpu_probe(const char *buf, size_t count) 472 { 473 if (ppc_md.cpu_probe) 474 return ppc_md.cpu_probe(buf, count); 475 476 return -EINVAL; 477 } 478 479 ssize_t arch_cpu_release(const char *buf, size_t count) 480 { 481 if (ppc_md.cpu_release) 482 return ppc_md.cpu_release(buf, count); 483 484 return -EINVAL; 485 } 486 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */ 487 488 #endif /* CONFIG_HOTPLUG_CPU */ 489 490 static int __cpuinit sysfs_cpu_notify(struct notifier_block *self, 491 unsigned long action, void *hcpu) 492 { 493 unsigned int cpu = (unsigned int)(long)hcpu; 494 495 switch (action) { 496 case CPU_ONLINE: 497 case CPU_ONLINE_FROZEN: 498 register_cpu_online(cpu); 499 break; 500 #ifdef CONFIG_HOTPLUG_CPU 501 case CPU_DEAD: 502 case CPU_DEAD_FROZEN: 503 unregister_cpu_online(cpu); 504 break; 505 #endif 506 } 507 return NOTIFY_OK; 508 } 509 510 static struct notifier_block __cpuinitdata sysfs_cpu_nb = { 511 .notifier_call = sysfs_cpu_notify, 512 }; 513 514 static DEFINE_MUTEX(cpu_mutex); 515 516 int cpu_add_sysdev_attr(struct sysdev_attribute *attr) 517 { 518 int cpu; 519 520 mutex_lock(&cpu_mutex); 521 522 for_each_possible_cpu(cpu) { 523 sysdev_create_file(get_cpu_sysdev(cpu), attr); 524 } 525 526 mutex_unlock(&cpu_mutex); 527 return 0; 528 } 529 EXPORT_SYMBOL_GPL(cpu_add_sysdev_attr); 530 531 int cpu_add_sysdev_attr_group(struct attribute_group *attrs) 532 { 533 int cpu; 534 struct sys_device *sysdev; 535 int ret; 536 537 mutex_lock(&cpu_mutex); 538 539 for_each_possible_cpu(cpu) { 540 sysdev = get_cpu_sysdev(cpu); 541 ret = sysfs_create_group(&sysdev->kobj, attrs); 542 WARN_ON(ret != 0); 543 } 544 545 mutex_unlock(&cpu_mutex); 546 return 0; 547 } 548 EXPORT_SYMBOL_GPL(cpu_add_sysdev_attr_group); 549 550 551 void cpu_remove_sysdev_attr(struct sysdev_attribute *attr) 552 { 553 int cpu; 554 555 mutex_lock(&cpu_mutex); 556 557 for_each_possible_cpu(cpu) { 558 sysdev_remove_file(get_cpu_sysdev(cpu), attr); 559 } 560 561 mutex_unlock(&cpu_mutex); 562 } 563 EXPORT_SYMBOL_GPL(cpu_remove_sysdev_attr); 564 565 void cpu_remove_sysdev_attr_group(struct attribute_group *attrs) 566 { 567 int cpu; 568 struct sys_device *sysdev; 569 570 mutex_lock(&cpu_mutex); 571 572 for_each_possible_cpu(cpu) { 573 sysdev = get_cpu_sysdev(cpu); 574 sysfs_remove_group(&sysdev->kobj, attrs); 575 } 576 577 mutex_unlock(&cpu_mutex); 578 } 579 EXPORT_SYMBOL_GPL(cpu_remove_sysdev_attr_group); 580 581 582 /* NUMA stuff */ 583 584 #ifdef CONFIG_NUMA 585 static void register_nodes(void) 586 { 587 int i; 588 589 for (i = 0; i < MAX_NUMNODES; i++) 590 register_one_node(i); 591 } 592 593 int sysfs_add_device_to_node(struct sys_device *dev, int nid) 594 { 595 struct node *node = &node_devices[nid]; 596 return sysfs_create_link(&node->sysdev.kobj, &dev->kobj, 597 kobject_name(&dev->kobj)); 598 } 599 EXPORT_SYMBOL_GPL(sysfs_add_device_to_node); 600 601 void sysfs_remove_device_from_node(struct sys_device *dev, int nid) 602 { 603 struct node *node = &node_devices[nid]; 604 sysfs_remove_link(&node->sysdev.kobj, kobject_name(&dev->kobj)); 605 } 606 EXPORT_SYMBOL_GPL(sysfs_remove_device_from_node); 607 608 #else 609 static void register_nodes(void) 610 { 611 return; 612 } 613 614 #endif 615 616 /* Only valid if CPU is present. */ 617 static ssize_t show_physical_id(struct sys_device *dev, 618 struct sysdev_attribute *attr, char *buf) 619 { 620 struct cpu *cpu = container_of(dev, struct cpu, sysdev); 621 622 return sprintf(buf, "%d\n", get_hard_smp_processor_id(cpu->sysdev.id)); 623 } 624 static SYSDEV_ATTR(physical_id, 0444, show_physical_id, NULL); 625 626 static int __init topology_init(void) 627 { 628 int cpu; 629 630 register_nodes(); 631 register_cpu_notifier(&sysfs_cpu_nb); 632 633 for_each_possible_cpu(cpu) { 634 struct cpu *c = &per_cpu(cpu_devices, cpu); 635 636 /* 637 * For now, we just see if the system supports making 638 * the RTAS calls for CPU hotplug. But, there may be a 639 * more comprehensive way to do this for an individual 640 * CPU. For instance, the boot cpu might never be valid 641 * for hotplugging. 642 */ 643 if (ppc_md.cpu_die) 644 c->hotpluggable = 1; 645 646 if (cpu_online(cpu) || c->hotpluggable) { 647 register_cpu(c, cpu); 648 649 sysdev_create_file(&c->sysdev, &attr_physical_id); 650 } 651 652 if (cpu_online(cpu)) 653 register_cpu_online(cpu); 654 } 655 #ifdef CONFIG_PPC64 656 sysfs_create_dscr_default(); 657 #endif /* CONFIG_PPC64 */ 658 659 return 0; 660 } 661 subsys_initcall(topology_init); 662