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 29static 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 */ 38DEFINE_PER_CPU(long, smt_snooze_delay) = { 100 }; 39 40static 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 58static 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 67static SYSDEV_ATTR(smt_snooze_delay, 0644, show_smt_snooze_delay, 68 store_smt_snooze_delay); 69 70static 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 93static DEFINE_PER_CPU(char, pmcs_enabled); 94 95void 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} 108EXPORT_SYMBOL(ppc_enable_pmcs); 109 110#define SYSFS_PMCSETUP(NAME, ADDRESS) \ 111static void read_##NAME(void *val) \ 112{ \ 113 *(unsigned long *)val = mfspr(ADDRESS); \ 114} \ 115static void write_##NAME(void *val) \ 116{ \ 117 ppc_enable_pmcs(); \ 118 mtspr(ADDRESS, *(unsigned long *)val); \ 119} \ 120static 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} \ 129static 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 159SYSFS_PMCSETUP(mmcr0, SPRN_MMCR0); 160SYSFS_PMCSETUP(mmcr1, SPRN_MMCR1); 161SYSFS_PMCSETUP(pmc1, SPRN_PMC1); 162SYSFS_PMCSETUP(pmc2, SPRN_PMC2); 163SYSFS_PMCSETUP(pmc3, SPRN_PMC3); 164SYSFS_PMCSETUP(pmc4, SPRN_PMC4); 165SYSFS_PMCSETUP(pmc5, SPRN_PMC5); 166SYSFS_PMCSETUP(pmc6, SPRN_PMC6); 167 168#ifdef HAS_PPC_PMC_G4 169SYSFS_PMCSETUP(mmcr2, SPRN_MMCR2); 170#endif 171 172#ifdef CONFIG_PPC64 173SYSFS_PMCSETUP(pmc7, SPRN_PMC7); 174SYSFS_PMCSETUP(pmc8, SPRN_PMC8); 175 176SYSFS_PMCSETUP(mmcra, SPRN_MMCRA); 177SYSFS_PMCSETUP(purr, SPRN_PURR); 178SYSFS_PMCSETUP(spurr, SPRN_SPURR); 179SYSFS_PMCSETUP(dscr, SPRN_DSCR); 180 181static SYSDEV_ATTR(mmcra, 0600, show_mmcra, store_mmcra); 182static SYSDEV_ATTR(spurr, 0600, show_spurr, NULL); 183static SYSDEV_ATTR(dscr, 0600, show_dscr, store_dscr); 184static SYSDEV_ATTR(purr, 0600, show_purr, store_purr); 185#endif /* CONFIG_PPC64 */ 186 187#ifdef HAS_PPC_PMC_PA6T 188SYSFS_PMCSETUP(pa6t_pmc0, SPRN_PA6T_PMC0); 189SYSFS_PMCSETUP(pa6t_pmc1, SPRN_PA6T_PMC1); 190SYSFS_PMCSETUP(pa6t_pmc2, SPRN_PA6T_PMC2); 191SYSFS_PMCSETUP(pa6t_pmc3, SPRN_PA6T_PMC3); 192SYSFS_PMCSETUP(pa6t_pmc4, SPRN_PA6T_PMC4); 193SYSFS_PMCSETUP(pa6t_pmc5, SPRN_PA6T_PMC5); 194#ifdef CONFIG_DEBUG_KERNEL 195SYSFS_PMCSETUP(hid0, SPRN_HID0); 196SYSFS_PMCSETUP(hid1, SPRN_HID1); 197SYSFS_PMCSETUP(hid4, SPRN_HID4); 198SYSFS_PMCSETUP(hid5, SPRN_HID5); 199SYSFS_PMCSETUP(ima0, SPRN_PA6T_IMA0); 200SYSFS_PMCSETUP(ima1, SPRN_PA6T_IMA1); 201SYSFS_PMCSETUP(ima2, SPRN_PA6T_IMA2); 202SYSFS_PMCSETUP(ima3, SPRN_PA6T_IMA3); 203SYSFS_PMCSETUP(ima4, SPRN_PA6T_IMA4); 204SYSFS_PMCSETUP(ima5, SPRN_PA6T_IMA5); 205SYSFS_PMCSETUP(ima6, SPRN_PA6T_IMA6); 206SYSFS_PMCSETUP(ima7, SPRN_PA6T_IMA7); 207SYSFS_PMCSETUP(ima8, SPRN_PA6T_IMA8); 208SYSFS_PMCSETUP(ima9, SPRN_PA6T_IMA9); 209SYSFS_PMCSETUP(imaat, SPRN_PA6T_IMAAT); 210SYSFS_PMCSETUP(btcr, SPRN_PA6T_BTCR); 211SYSFS_PMCSETUP(pccr, SPRN_PA6T_PCCR); 212SYSFS_PMCSETUP(rpccr, SPRN_PA6T_RPCCR); 213SYSFS_PMCSETUP(der, SPRN_PA6T_DER); 214SYSFS_PMCSETUP(mer, SPRN_PA6T_MER); 215SYSFS_PMCSETUP(ber, SPRN_PA6T_BER); 216SYSFS_PMCSETUP(ier, SPRN_PA6T_IER); 217SYSFS_PMCSETUP(sier, SPRN_PA6T_SIER); 218SYSFS_PMCSETUP(siar, SPRN_PA6T_SIAR); 219SYSFS_PMCSETUP(tsr0, SPRN_PA6T_TSR0); 220SYSFS_PMCSETUP(tsr1, SPRN_PA6T_TSR1); 221SYSFS_PMCSETUP(tsr2, SPRN_PA6T_TSR2); 222SYSFS_PMCSETUP(tsr3, SPRN_PA6T_TSR3); 223#endif /* CONFIG_DEBUG_KERNEL */ 224#endif /* HAS_PPC_PMC_PA6T */ 225 226#ifdef HAS_PPC_PMC_IBM 227static 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 234static 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 241static 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 255static 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 298static 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 366static 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 436ssize_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 444ssize_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 455static 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 475static struct notifier_block __cpuinitdata sysfs_cpu_nb = { 476 .notifier_call = sysfs_cpu_notify, 477}; 478 479static DEFINE_MUTEX(cpu_mutex); 480 481int 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} 494EXPORT_SYMBOL_GPL(cpu_add_sysdev_attr); 495 496int 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} 513EXPORT_SYMBOL_GPL(cpu_add_sysdev_attr_group); 514 515 516void 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} 528EXPORT_SYMBOL_GPL(cpu_remove_sysdev_attr); 529 530void 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} 544EXPORT_SYMBOL_GPL(cpu_remove_sysdev_attr_group); 545 546 547/* NUMA stuff */ 548 549#ifdef CONFIG_NUMA 550static void register_nodes(void) 551{ 552 int i; 553 554 for (i = 0; i < MAX_NUMNODES; i++) 555 register_one_node(i); 556} 557 558int 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} 564EXPORT_SYMBOL_GPL(sysfs_add_device_to_node); 565 566void 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} 571EXPORT_SYMBOL_GPL(sysfs_remove_device_from_node); 572 573#else 574static void register_nodes(void) 575{ 576 return; 577} 578 579#endif 580 581/* Only valid if CPU is present. */ 582static 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} 589static SYSDEV_ATTR(physical_id, 0444, show_physical_id, NULL); 590 591static 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} 623subsys_initcall(topology_init); 624