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/module.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 #endif /* CONFIG_PPC64 */ 186 187 #ifdef HAS_PPC_PMC_PA6T 188 SYSFS_PMCSETUP(pa6t_pmc0, SPRN_PA6T_PMC0); 189 SYSFS_PMCSETUP(pa6t_pmc1, SPRN_PA6T_PMC1); 190 SYSFS_PMCSETUP(pa6t_pmc2, SPRN_PA6T_PMC2); 191 SYSFS_PMCSETUP(pa6t_pmc3, SPRN_PA6T_PMC3); 192 SYSFS_PMCSETUP(pa6t_pmc4, SPRN_PA6T_PMC4); 193 SYSFS_PMCSETUP(pa6t_pmc5, SPRN_PA6T_PMC5); 194 #ifdef CONFIG_DEBUG_KERNEL 195 SYSFS_PMCSETUP(hid0, SPRN_HID0); 196 SYSFS_PMCSETUP(hid1, SPRN_HID1); 197 SYSFS_PMCSETUP(hid4, SPRN_HID4); 198 SYSFS_PMCSETUP(hid5, SPRN_HID5); 199 SYSFS_PMCSETUP(ima0, SPRN_PA6T_IMA0); 200 SYSFS_PMCSETUP(ima1, SPRN_PA6T_IMA1); 201 SYSFS_PMCSETUP(ima2, SPRN_PA6T_IMA2); 202 SYSFS_PMCSETUP(ima3, SPRN_PA6T_IMA3); 203 SYSFS_PMCSETUP(ima4, SPRN_PA6T_IMA4); 204 SYSFS_PMCSETUP(ima5, SPRN_PA6T_IMA5); 205 SYSFS_PMCSETUP(ima6, SPRN_PA6T_IMA6); 206 SYSFS_PMCSETUP(ima7, SPRN_PA6T_IMA7); 207 SYSFS_PMCSETUP(ima8, SPRN_PA6T_IMA8); 208 SYSFS_PMCSETUP(ima9, SPRN_PA6T_IMA9); 209 SYSFS_PMCSETUP(imaat, SPRN_PA6T_IMAAT); 210 SYSFS_PMCSETUP(btcr, SPRN_PA6T_BTCR); 211 SYSFS_PMCSETUP(pccr, SPRN_PA6T_PCCR); 212 SYSFS_PMCSETUP(rpccr, SPRN_PA6T_RPCCR); 213 SYSFS_PMCSETUP(der, SPRN_PA6T_DER); 214 SYSFS_PMCSETUP(mer, SPRN_PA6T_MER); 215 SYSFS_PMCSETUP(ber, SPRN_PA6T_BER); 216 SYSFS_PMCSETUP(ier, SPRN_PA6T_IER); 217 SYSFS_PMCSETUP(sier, SPRN_PA6T_SIER); 218 SYSFS_PMCSETUP(siar, SPRN_PA6T_SIAR); 219 SYSFS_PMCSETUP(tsr0, SPRN_PA6T_TSR0); 220 SYSFS_PMCSETUP(tsr1, SPRN_PA6T_TSR1); 221 SYSFS_PMCSETUP(tsr2, SPRN_PA6T_TSR2); 222 SYSFS_PMCSETUP(tsr3, SPRN_PA6T_TSR3); 223 #endif /* CONFIG_DEBUG_KERNEL */ 224 #endif /* HAS_PPC_PMC_PA6T */ 225 226 #ifdef HAS_PPC_PMC_IBM 227 static struct sysdev_attribute ibm_common_attrs[] = { 228 _SYSDEV_ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0), 229 _SYSDEV_ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1), 230 }; 231 #endif /* HAS_PPC_PMC_G4 */ 232 233 #ifdef HAS_PPC_PMC_G4 234 static struct sysdev_attribute g4_common_attrs[] = { 235 _SYSDEV_ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0), 236 _SYSDEV_ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1), 237 _SYSDEV_ATTR(mmcr2, 0600, show_mmcr2, store_mmcr2), 238 }; 239 #endif /* HAS_PPC_PMC_G4 */ 240 241 static struct sysdev_attribute classic_pmc_attrs[] = { 242 _SYSDEV_ATTR(pmc1, 0600, show_pmc1, store_pmc1), 243 _SYSDEV_ATTR(pmc2, 0600, show_pmc2, store_pmc2), 244 _SYSDEV_ATTR(pmc3, 0600, show_pmc3, store_pmc3), 245 _SYSDEV_ATTR(pmc4, 0600, show_pmc4, store_pmc4), 246 _SYSDEV_ATTR(pmc5, 0600, show_pmc5, store_pmc5), 247 _SYSDEV_ATTR(pmc6, 0600, show_pmc6, store_pmc6), 248 #ifdef CONFIG_PPC64 249 _SYSDEV_ATTR(pmc7, 0600, show_pmc7, store_pmc7), 250 _SYSDEV_ATTR(pmc8, 0600, show_pmc8, store_pmc8), 251 #endif 252 }; 253 254 #ifdef HAS_PPC_PMC_PA6T 255 static struct sysdev_attribute pa6t_attrs[] = { 256 _SYSDEV_ATTR(mmcr0, 0600, show_mmcr0, store_mmcr0), 257 _SYSDEV_ATTR(mmcr1, 0600, show_mmcr1, store_mmcr1), 258 _SYSDEV_ATTR(pmc0, 0600, show_pa6t_pmc0, store_pa6t_pmc0), 259 _SYSDEV_ATTR(pmc1, 0600, show_pa6t_pmc1, store_pa6t_pmc1), 260 _SYSDEV_ATTR(pmc2, 0600, show_pa6t_pmc2, store_pa6t_pmc2), 261 _SYSDEV_ATTR(pmc3, 0600, show_pa6t_pmc3, store_pa6t_pmc3), 262 _SYSDEV_ATTR(pmc4, 0600, show_pa6t_pmc4, store_pa6t_pmc4), 263 _SYSDEV_ATTR(pmc5, 0600, show_pa6t_pmc5, store_pa6t_pmc5), 264 #ifdef CONFIG_DEBUG_KERNEL 265 _SYSDEV_ATTR(hid0, 0600, show_hid0, store_hid0), 266 _SYSDEV_ATTR(hid1, 0600, show_hid1, store_hid1), 267 _SYSDEV_ATTR(hid4, 0600, show_hid4, store_hid4), 268 _SYSDEV_ATTR(hid5, 0600, show_hid5, store_hid5), 269 _SYSDEV_ATTR(ima0, 0600, show_ima0, store_ima0), 270 _SYSDEV_ATTR(ima1, 0600, show_ima1, store_ima1), 271 _SYSDEV_ATTR(ima2, 0600, show_ima2, store_ima2), 272 _SYSDEV_ATTR(ima3, 0600, show_ima3, store_ima3), 273 _SYSDEV_ATTR(ima4, 0600, show_ima4, store_ima4), 274 _SYSDEV_ATTR(ima5, 0600, show_ima5, store_ima5), 275 _SYSDEV_ATTR(ima6, 0600, show_ima6, store_ima6), 276 _SYSDEV_ATTR(ima7, 0600, show_ima7, store_ima7), 277 _SYSDEV_ATTR(ima8, 0600, show_ima8, store_ima8), 278 _SYSDEV_ATTR(ima9, 0600, show_ima9, store_ima9), 279 _SYSDEV_ATTR(imaat, 0600, show_imaat, store_imaat), 280 _SYSDEV_ATTR(btcr, 0600, show_btcr, store_btcr), 281 _SYSDEV_ATTR(pccr, 0600, show_pccr, store_pccr), 282 _SYSDEV_ATTR(rpccr, 0600, show_rpccr, store_rpccr), 283 _SYSDEV_ATTR(der, 0600, show_der, store_der), 284 _SYSDEV_ATTR(mer, 0600, show_mer, store_mer), 285 _SYSDEV_ATTR(ber, 0600, show_ber, store_ber), 286 _SYSDEV_ATTR(ier, 0600, show_ier, store_ier), 287 _SYSDEV_ATTR(sier, 0600, show_sier, store_sier), 288 _SYSDEV_ATTR(siar, 0600, show_siar, store_siar), 289 _SYSDEV_ATTR(tsr0, 0600, show_tsr0, store_tsr0), 290 _SYSDEV_ATTR(tsr1, 0600, show_tsr1, store_tsr1), 291 _SYSDEV_ATTR(tsr2, 0600, show_tsr2, store_tsr2), 292 _SYSDEV_ATTR(tsr3, 0600, show_tsr3, store_tsr3), 293 #endif /* CONFIG_DEBUG_KERNEL */ 294 }; 295 #endif /* HAS_PPC_PMC_PA6T */ 296 #endif /* HAS_PPC_PMC_CLASSIC */ 297 298 static void __cpuinit register_cpu_online(unsigned int cpu) 299 { 300 struct cpu *c = &per_cpu(cpu_devices, cpu); 301 struct sys_device *s = &c->sysdev; 302 struct sysdev_attribute *attrs, *pmc_attrs; 303 int i, nattrs; 304 305 #ifdef CONFIG_PPC64 306 if (!firmware_has_feature(FW_FEATURE_ISERIES) && 307 cpu_has_feature(CPU_FTR_SMT)) 308 sysdev_create_file(s, &attr_smt_snooze_delay); 309 #endif 310 311 /* PMC stuff */ 312 switch (cur_cpu_spec->pmc_type) { 313 #ifdef HAS_PPC_PMC_IBM 314 case PPC_PMC_IBM: 315 attrs = ibm_common_attrs; 316 nattrs = sizeof(ibm_common_attrs) / sizeof(struct sysdev_attribute); 317 pmc_attrs = classic_pmc_attrs; 318 break; 319 #endif /* HAS_PPC_PMC_IBM */ 320 #ifdef HAS_PPC_PMC_G4 321 case PPC_PMC_G4: 322 attrs = g4_common_attrs; 323 nattrs = sizeof(g4_common_attrs) / sizeof(struct sysdev_attribute); 324 pmc_attrs = classic_pmc_attrs; 325 break; 326 #endif /* HAS_PPC_PMC_G4 */ 327 #ifdef HAS_PPC_PMC_PA6T 328 case PPC_PMC_PA6T: 329 /* PA Semi starts counting at PMC0 */ 330 attrs = pa6t_attrs; 331 nattrs = sizeof(pa6t_attrs) / sizeof(struct sysdev_attribute); 332 pmc_attrs = NULL; 333 break; 334 #endif /* HAS_PPC_PMC_PA6T */ 335 default: 336 attrs = NULL; 337 nattrs = 0; 338 pmc_attrs = NULL; 339 } 340 341 for (i = 0; i < nattrs; i++) 342 sysdev_create_file(s, &attrs[i]); 343 344 if (pmc_attrs) 345 for (i = 0; i < cur_cpu_spec->num_pmcs; i++) 346 sysdev_create_file(s, &pmc_attrs[i]); 347 348 #ifdef CONFIG_PPC64 349 if (cpu_has_feature(CPU_FTR_MMCRA)) 350 sysdev_create_file(s, &attr_mmcra); 351 352 if (cpu_has_feature(CPU_FTR_PURR)) 353 sysdev_create_file(s, &attr_purr); 354 355 if (cpu_has_feature(CPU_FTR_SPURR)) 356 sysdev_create_file(s, &attr_spurr); 357 358 if (cpu_has_feature(CPU_FTR_DSCR)) 359 sysdev_create_file(s, &attr_dscr); 360 #endif /* CONFIG_PPC64 */ 361 362 cacheinfo_cpu_online(cpu); 363 } 364 365 #ifdef CONFIG_HOTPLUG_CPU 366 static void unregister_cpu_online(unsigned int cpu) 367 { 368 struct cpu *c = &per_cpu(cpu_devices, cpu); 369 struct sys_device *s = &c->sysdev; 370 struct sysdev_attribute *attrs, *pmc_attrs; 371 int i, nattrs; 372 373 BUG_ON(!c->hotpluggable); 374 375 #ifdef CONFIG_PPC64 376 if (!firmware_has_feature(FW_FEATURE_ISERIES) && 377 cpu_has_feature(CPU_FTR_SMT)) 378 sysdev_remove_file(s, &attr_smt_snooze_delay); 379 #endif 380 381 /* PMC stuff */ 382 switch (cur_cpu_spec->pmc_type) { 383 #ifdef HAS_PPC_PMC_IBM 384 case PPC_PMC_IBM: 385 attrs = ibm_common_attrs; 386 nattrs = sizeof(ibm_common_attrs) / sizeof(struct sysdev_attribute); 387 pmc_attrs = classic_pmc_attrs; 388 break; 389 #endif /* HAS_PPC_PMC_IBM */ 390 #ifdef HAS_PPC_PMC_G4 391 case PPC_PMC_G4: 392 attrs = g4_common_attrs; 393 nattrs = sizeof(g4_common_attrs) / sizeof(struct sysdev_attribute); 394 pmc_attrs = classic_pmc_attrs; 395 break; 396 #endif /* HAS_PPC_PMC_G4 */ 397 #ifdef HAS_PPC_PMC_PA6T 398 case PPC_PMC_PA6T: 399 /* PA Semi starts counting at PMC0 */ 400 attrs = pa6t_attrs; 401 nattrs = sizeof(pa6t_attrs) / sizeof(struct sysdev_attribute); 402 pmc_attrs = NULL; 403 break; 404 #endif /* HAS_PPC_PMC_PA6T */ 405 default: 406 attrs = NULL; 407 nattrs = 0; 408 pmc_attrs = NULL; 409 } 410 411 for (i = 0; i < nattrs; i++) 412 sysdev_remove_file(s, &attrs[i]); 413 414 if (pmc_attrs) 415 for (i = 0; i < cur_cpu_spec->num_pmcs; i++) 416 sysdev_remove_file(s, &pmc_attrs[i]); 417 418 #ifdef CONFIG_PPC64 419 if (cpu_has_feature(CPU_FTR_MMCRA)) 420 sysdev_remove_file(s, &attr_mmcra); 421 422 if (cpu_has_feature(CPU_FTR_PURR)) 423 sysdev_remove_file(s, &attr_purr); 424 425 if (cpu_has_feature(CPU_FTR_SPURR)) 426 sysdev_remove_file(s, &attr_spurr); 427 428 if (cpu_has_feature(CPU_FTR_DSCR)) 429 sysdev_remove_file(s, &attr_dscr); 430 #endif /* CONFIG_PPC64 */ 431 432 cacheinfo_cpu_offline(cpu); 433 } 434 435 #ifdef CONFIG_ARCH_CPU_PROBE_RELEASE 436 ssize_t arch_cpu_probe(const char *buf, size_t count) 437 { 438 if (ppc_md.cpu_probe) 439 return ppc_md.cpu_probe(buf, count); 440 441 return -EINVAL; 442 } 443 444 ssize_t arch_cpu_release(const char *buf, size_t count) 445 { 446 if (ppc_md.cpu_release) 447 return ppc_md.cpu_release(buf, count); 448 449 return -EINVAL; 450 } 451 #endif /* CONFIG_ARCH_CPU_PROBE_RELEASE */ 452 453 #endif /* CONFIG_HOTPLUG_CPU */ 454 455 static int __cpuinit sysfs_cpu_notify(struct notifier_block *self, 456 unsigned long action, void *hcpu) 457 { 458 unsigned int cpu = (unsigned int)(long)hcpu; 459 460 switch (action) { 461 case CPU_ONLINE: 462 case CPU_ONLINE_FROZEN: 463 register_cpu_online(cpu); 464 break; 465 #ifdef CONFIG_HOTPLUG_CPU 466 case CPU_DEAD: 467 case CPU_DEAD_FROZEN: 468 unregister_cpu_online(cpu); 469 break; 470 #endif 471 } 472 return NOTIFY_OK; 473 } 474 475 static struct notifier_block __cpuinitdata sysfs_cpu_nb = { 476 .notifier_call = sysfs_cpu_notify, 477 }; 478 479 static DEFINE_MUTEX(cpu_mutex); 480 481 int cpu_add_sysdev_attr(struct sysdev_attribute *attr) 482 { 483 int cpu; 484 485 mutex_lock(&cpu_mutex); 486 487 for_each_possible_cpu(cpu) { 488 sysdev_create_file(get_cpu_sysdev(cpu), attr); 489 } 490 491 mutex_unlock(&cpu_mutex); 492 return 0; 493 } 494 EXPORT_SYMBOL_GPL(cpu_add_sysdev_attr); 495 496 int cpu_add_sysdev_attr_group(struct attribute_group *attrs) 497 { 498 int cpu; 499 struct sys_device *sysdev; 500 int ret; 501 502 mutex_lock(&cpu_mutex); 503 504 for_each_possible_cpu(cpu) { 505 sysdev = get_cpu_sysdev(cpu); 506 ret = sysfs_create_group(&sysdev->kobj, attrs); 507 WARN_ON(ret != 0); 508 } 509 510 mutex_unlock(&cpu_mutex); 511 return 0; 512 } 513 EXPORT_SYMBOL_GPL(cpu_add_sysdev_attr_group); 514 515 516 void cpu_remove_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_remove_file(get_cpu_sysdev(cpu), attr); 524 } 525 526 mutex_unlock(&cpu_mutex); 527 } 528 EXPORT_SYMBOL_GPL(cpu_remove_sysdev_attr); 529 530 void cpu_remove_sysdev_attr_group(struct attribute_group *attrs) 531 { 532 int cpu; 533 struct sys_device *sysdev; 534 535 mutex_lock(&cpu_mutex); 536 537 for_each_possible_cpu(cpu) { 538 sysdev = get_cpu_sysdev(cpu); 539 sysfs_remove_group(&sysdev->kobj, attrs); 540 } 541 542 mutex_unlock(&cpu_mutex); 543 } 544 EXPORT_SYMBOL_GPL(cpu_remove_sysdev_attr_group); 545 546 547 /* NUMA stuff */ 548 549 #ifdef CONFIG_NUMA 550 static void register_nodes(void) 551 { 552 int i; 553 554 for (i = 0; i < MAX_NUMNODES; i++) 555 register_one_node(i); 556 } 557 558 int sysfs_add_device_to_node(struct sys_device *dev, int nid) 559 { 560 struct node *node = &node_devices[nid]; 561 return sysfs_create_link(&node->sysdev.kobj, &dev->kobj, 562 kobject_name(&dev->kobj)); 563 } 564 EXPORT_SYMBOL_GPL(sysfs_add_device_to_node); 565 566 void sysfs_remove_device_from_node(struct sys_device *dev, int nid) 567 { 568 struct node *node = &node_devices[nid]; 569 sysfs_remove_link(&node->sysdev.kobj, kobject_name(&dev->kobj)); 570 } 571 EXPORT_SYMBOL_GPL(sysfs_remove_device_from_node); 572 573 #else 574 static void register_nodes(void) 575 { 576 return; 577 } 578 579 #endif 580 581 /* Only valid if CPU is present. */ 582 static ssize_t show_physical_id(struct sys_device *dev, 583 struct sysdev_attribute *attr, char *buf) 584 { 585 struct cpu *cpu = container_of(dev, struct cpu, sysdev); 586 587 return sprintf(buf, "%d\n", get_hard_smp_processor_id(cpu->sysdev.id)); 588 } 589 static SYSDEV_ATTR(physical_id, 0444, show_physical_id, NULL); 590 591 static int __init topology_init(void) 592 { 593 int cpu; 594 595 register_nodes(); 596 register_cpu_notifier(&sysfs_cpu_nb); 597 598 for_each_possible_cpu(cpu) { 599 struct cpu *c = &per_cpu(cpu_devices, cpu); 600 601 /* 602 * For now, we just see if the system supports making 603 * the RTAS calls for CPU hotplug. But, there may be a 604 * more comprehensive way to do this for an individual 605 * CPU. For instance, the boot cpu might never be valid 606 * for hotplugging. 607 */ 608 if (ppc_md.cpu_die) 609 c->hotpluggable = 1; 610 611 if (cpu_online(cpu) || c->hotpluggable) { 612 register_cpu(c, cpu); 613 614 sysdev_create_file(&c->sysdev, &attr_physical_id); 615 } 616 617 if (cpu_online(cpu)) 618 register_cpu_online(cpu); 619 } 620 621 return 0; 622 } 623 subsys_initcall(topology_init); 624