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