1 /* 2 * SMP support for ppc. 3 * 4 * Written by Cort Dougan (cort@cs.nmt.edu) borrowing a great 5 * deal of code from the sparc and intel versions. 6 * 7 * Copyright (C) 1999 Cort Dougan <cort@cs.nmt.edu> 8 * 9 * PowerPC-64 Support added by Dave Engebretsen, Peter Bergner, and 10 * Mike Corrigan {engebret|bergner|mikec}@us.ibm.com 11 * 12 * This program is free software; you can redistribute it and/or 13 * modify it under the terms of the GNU General Public License 14 * as published by the Free Software Foundation; either version 15 * 2 of the License, or (at your option) any later version. 16 */ 17 18 #undef DEBUG 19 20 #include <linux/kernel.h> 21 #include <linux/export.h> 22 #include <linux/sched.h> 23 #include <linux/smp.h> 24 #include <linux/interrupt.h> 25 #include <linux/delay.h> 26 #include <linux/init.h> 27 #include <linux/spinlock.h> 28 #include <linux/cache.h> 29 #include <linux/err.h> 30 #include <linux/sysdev.h> 31 #include <linux/cpu.h> 32 #include <linux/notifier.h> 33 #include <linux/topology.h> 34 35 #include <asm/ptrace.h> 36 #include <linux/atomic.h> 37 #include <asm/irq.h> 38 #include <asm/page.h> 39 #include <asm/pgtable.h> 40 #include <asm/prom.h> 41 #include <asm/smp.h> 42 #include <asm/time.h> 43 #include <asm/machdep.h> 44 #include <asm/cputhreads.h> 45 #include <asm/cputable.h> 46 #include <asm/system.h> 47 #include <asm/mpic.h> 48 #include <asm/vdso_datapage.h> 49 #ifdef CONFIG_PPC64 50 #include <asm/paca.h> 51 #endif 52 53 #ifdef DEBUG 54 #include <asm/udbg.h> 55 #define DBG(fmt...) udbg_printf(fmt) 56 #else 57 #define DBG(fmt...) 58 #endif 59 60 61 /* Store all idle threads, this can be reused instead of creating 62 * a new thread. Also avoids complicated thread destroy functionality 63 * for idle threads. 64 */ 65 #ifdef CONFIG_HOTPLUG_CPU 66 /* 67 * Needed only for CONFIG_HOTPLUG_CPU because __cpuinitdata is 68 * removed after init for !CONFIG_HOTPLUG_CPU. 69 */ 70 static DEFINE_PER_CPU(struct task_struct *, idle_thread_array); 71 #define get_idle_for_cpu(x) (per_cpu(idle_thread_array, x)) 72 #define set_idle_for_cpu(x, p) (per_cpu(idle_thread_array, x) = (p)) 73 74 /* State of each CPU during hotplug phases */ 75 static DEFINE_PER_CPU(int, cpu_state) = { 0 }; 76 77 #else 78 static struct task_struct *idle_thread_array[NR_CPUS] __cpuinitdata ; 79 #define get_idle_for_cpu(x) (idle_thread_array[(x)]) 80 #define set_idle_for_cpu(x, p) (idle_thread_array[(x)] = (p)) 81 #endif 82 83 struct thread_info *secondary_ti; 84 85 DEFINE_PER_CPU(cpumask_var_t, cpu_sibling_map); 86 DEFINE_PER_CPU(cpumask_var_t, cpu_core_map); 87 88 EXPORT_PER_CPU_SYMBOL(cpu_sibling_map); 89 EXPORT_PER_CPU_SYMBOL(cpu_core_map); 90 91 /* SMP operations for this machine */ 92 struct smp_ops_t *smp_ops; 93 94 /* Can't be static due to PowerMac hackery */ 95 volatile unsigned int cpu_callin_map[NR_CPUS]; 96 97 int smt_enabled_at_boot = 1; 98 99 static void (*crash_ipi_function_ptr)(struct pt_regs *) = NULL; 100 101 #ifdef CONFIG_PPC64 102 int __devinit smp_generic_kick_cpu(int nr) 103 { 104 BUG_ON(nr < 0 || nr >= NR_CPUS); 105 106 /* 107 * The processor is currently spinning, waiting for the 108 * cpu_start field to become non-zero After we set cpu_start, 109 * the processor will continue on to secondary_start 110 */ 111 if (!paca[nr].cpu_start) { 112 paca[nr].cpu_start = 1; 113 smp_mb(); 114 return 0; 115 } 116 117 #ifdef CONFIG_HOTPLUG_CPU 118 /* 119 * Ok it's not there, so it might be soft-unplugged, let's 120 * try to bring it back 121 */ 122 per_cpu(cpu_state, nr) = CPU_UP_PREPARE; 123 smp_wmb(); 124 smp_send_reschedule(nr); 125 #endif /* CONFIG_HOTPLUG_CPU */ 126 127 return 0; 128 } 129 #endif /* CONFIG_PPC64 */ 130 131 static irqreturn_t call_function_action(int irq, void *data) 132 { 133 generic_smp_call_function_interrupt(); 134 return IRQ_HANDLED; 135 } 136 137 static irqreturn_t reschedule_action(int irq, void *data) 138 { 139 scheduler_ipi(); 140 return IRQ_HANDLED; 141 } 142 143 static irqreturn_t call_function_single_action(int irq, void *data) 144 { 145 generic_smp_call_function_single_interrupt(); 146 return IRQ_HANDLED; 147 } 148 149 static irqreturn_t debug_ipi_action(int irq, void *data) 150 { 151 if (crash_ipi_function_ptr) { 152 crash_ipi_function_ptr(get_irq_regs()); 153 return IRQ_HANDLED; 154 } 155 156 #ifdef CONFIG_DEBUGGER 157 debugger_ipi(get_irq_regs()); 158 #endif /* CONFIG_DEBUGGER */ 159 160 return IRQ_HANDLED; 161 } 162 163 static irq_handler_t smp_ipi_action[] = { 164 [PPC_MSG_CALL_FUNCTION] = call_function_action, 165 [PPC_MSG_RESCHEDULE] = reschedule_action, 166 [PPC_MSG_CALL_FUNC_SINGLE] = call_function_single_action, 167 [PPC_MSG_DEBUGGER_BREAK] = debug_ipi_action, 168 }; 169 170 const char *smp_ipi_name[] = { 171 [PPC_MSG_CALL_FUNCTION] = "ipi call function", 172 [PPC_MSG_RESCHEDULE] = "ipi reschedule", 173 [PPC_MSG_CALL_FUNC_SINGLE] = "ipi call function single", 174 [PPC_MSG_DEBUGGER_BREAK] = "ipi debugger", 175 }; 176 177 /* optional function to request ipi, for controllers with >= 4 ipis */ 178 int smp_request_message_ipi(int virq, int msg) 179 { 180 int err; 181 182 if (msg < 0 || msg > PPC_MSG_DEBUGGER_BREAK) { 183 return -EINVAL; 184 } 185 #if !defined(CONFIG_DEBUGGER) && !defined(CONFIG_KEXEC) 186 if (msg == PPC_MSG_DEBUGGER_BREAK) { 187 return 1; 188 } 189 #endif 190 err = request_irq(virq, smp_ipi_action[msg], IRQF_DISABLED|IRQF_PERCPU, 191 smp_ipi_name[msg], 0); 192 WARN(err < 0, "unable to request_irq %d for %s (rc %d)\n", 193 virq, smp_ipi_name[msg], err); 194 195 return err; 196 } 197 198 #ifdef CONFIG_PPC_SMP_MUXED_IPI 199 struct cpu_messages { 200 int messages; /* current messages */ 201 unsigned long data; /* data for cause ipi */ 202 }; 203 static DEFINE_PER_CPU_SHARED_ALIGNED(struct cpu_messages, ipi_message); 204 205 void smp_muxed_ipi_set_data(int cpu, unsigned long data) 206 { 207 struct cpu_messages *info = &per_cpu(ipi_message, cpu); 208 209 info->data = data; 210 } 211 212 void smp_muxed_ipi_message_pass(int cpu, int msg) 213 { 214 struct cpu_messages *info = &per_cpu(ipi_message, cpu); 215 char *message = (char *)&info->messages; 216 217 message[msg] = 1; 218 mb(); 219 smp_ops->cause_ipi(cpu, info->data); 220 } 221 222 irqreturn_t smp_ipi_demux(void) 223 { 224 struct cpu_messages *info = &__get_cpu_var(ipi_message); 225 unsigned int all; 226 227 mb(); /* order any irq clear */ 228 229 do { 230 all = xchg_local(&info->messages, 0); 231 232 #ifdef __BIG_ENDIAN 233 if (all & (1 << (24 - 8 * PPC_MSG_CALL_FUNCTION))) 234 generic_smp_call_function_interrupt(); 235 if (all & (1 << (24 - 8 * PPC_MSG_RESCHEDULE))) 236 scheduler_ipi(); 237 if (all & (1 << (24 - 8 * PPC_MSG_CALL_FUNC_SINGLE))) 238 generic_smp_call_function_single_interrupt(); 239 if (all & (1 << (24 - 8 * PPC_MSG_DEBUGGER_BREAK))) 240 debug_ipi_action(0, NULL); 241 #else 242 #error Unsupported ENDIAN 243 #endif 244 } while (info->messages); 245 246 return IRQ_HANDLED; 247 } 248 #endif /* CONFIG_PPC_SMP_MUXED_IPI */ 249 250 static inline void do_message_pass(int cpu, int msg) 251 { 252 if (smp_ops->message_pass) 253 smp_ops->message_pass(cpu, msg); 254 #ifdef CONFIG_PPC_SMP_MUXED_IPI 255 else 256 smp_muxed_ipi_message_pass(cpu, msg); 257 #endif 258 } 259 260 void smp_send_reschedule(int cpu) 261 { 262 if (likely(smp_ops)) 263 do_message_pass(cpu, PPC_MSG_RESCHEDULE); 264 } 265 EXPORT_SYMBOL_GPL(smp_send_reschedule); 266 267 void arch_send_call_function_single_ipi(int cpu) 268 { 269 do_message_pass(cpu, PPC_MSG_CALL_FUNC_SINGLE); 270 } 271 272 void arch_send_call_function_ipi_mask(const struct cpumask *mask) 273 { 274 unsigned int cpu; 275 276 for_each_cpu(cpu, mask) 277 do_message_pass(cpu, PPC_MSG_CALL_FUNCTION); 278 } 279 280 #if defined(CONFIG_DEBUGGER) || defined(CONFIG_KEXEC) 281 void smp_send_debugger_break(void) 282 { 283 int cpu; 284 int me = raw_smp_processor_id(); 285 286 if (unlikely(!smp_ops)) 287 return; 288 289 for_each_online_cpu(cpu) 290 if (cpu != me) 291 do_message_pass(cpu, PPC_MSG_DEBUGGER_BREAK); 292 } 293 #endif 294 295 #ifdef CONFIG_KEXEC 296 void crash_send_ipi(void (*crash_ipi_callback)(struct pt_regs *)) 297 { 298 crash_ipi_function_ptr = crash_ipi_callback; 299 if (crash_ipi_callback) { 300 mb(); 301 smp_send_debugger_break(); 302 } 303 } 304 #endif 305 306 static void stop_this_cpu(void *dummy) 307 { 308 /* Remove this CPU */ 309 set_cpu_online(smp_processor_id(), false); 310 311 local_irq_disable(); 312 while (1) 313 ; 314 } 315 316 void smp_send_stop(void) 317 { 318 smp_call_function(stop_this_cpu, NULL, 0); 319 } 320 321 struct thread_info *current_set[NR_CPUS]; 322 323 static void __devinit smp_store_cpu_info(int id) 324 { 325 per_cpu(cpu_pvr, id) = mfspr(SPRN_PVR); 326 #ifdef CONFIG_PPC_FSL_BOOK3E 327 per_cpu(next_tlbcam_idx, id) 328 = (mfspr(SPRN_TLB1CFG) & TLBnCFG_N_ENTRY) - 1; 329 #endif 330 } 331 332 void __init smp_prepare_cpus(unsigned int max_cpus) 333 { 334 unsigned int cpu; 335 336 DBG("smp_prepare_cpus\n"); 337 338 /* 339 * setup_cpu may need to be called on the boot cpu. We havent 340 * spun any cpus up but lets be paranoid. 341 */ 342 BUG_ON(boot_cpuid != smp_processor_id()); 343 344 /* Fixup boot cpu */ 345 smp_store_cpu_info(boot_cpuid); 346 cpu_callin_map[boot_cpuid] = 1; 347 348 for_each_possible_cpu(cpu) { 349 zalloc_cpumask_var_node(&per_cpu(cpu_sibling_map, cpu), 350 GFP_KERNEL, cpu_to_node(cpu)); 351 zalloc_cpumask_var_node(&per_cpu(cpu_core_map, cpu), 352 GFP_KERNEL, cpu_to_node(cpu)); 353 } 354 355 cpumask_set_cpu(boot_cpuid, cpu_sibling_mask(boot_cpuid)); 356 cpumask_set_cpu(boot_cpuid, cpu_core_mask(boot_cpuid)); 357 358 if (smp_ops) 359 if (smp_ops->probe) 360 max_cpus = smp_ops->probe(); 361 else 362 max_cpus = NR_CPUS; 363 else 364 max_cpus = 1; 365 } 366 367 void __devinit smp_prepare_boot_cpu(void) 368 { 369 BUG_ON(smp_processor_id() != boot_cpuid); 370 #ifdef CONFIG_PPC64 371 paca[boot_cpuid].__current = current; 372 #endif 373 current_set[boot_cpuid] = task_thread_info(current); 374 } 375 376 #ifdef CONFIG_HOTPLUG_CPU 377 378 int generic_cpu_disable(void) 379 { 380 unsigned int cpu = smp_processor_id(); 381 382 if (cpu == boot_cpuid) 383 return -EBUSY; 384 385 set_cpu_online(cpu, false); 386 #ifdef CONFIG_PPC64 387 vdso_data->processorCount--; 388 #endif 389 migrate_irqs(); 390 return 0; 391 } 392 393 void generic_cpu_die(unsigned int cpu) 394 { 395 int i; 396 397 for (i = 0; i < 100; i++) { 398 smp_rmb(); 399 if (per_cpu(cpu_state, cpu) == CPU_DEAD) 400 return; 401 msleep(100); 402 } 403 printk(KERN_ERR "CPU%d didn't die...\n", cpu); 404 } 405 406 void generic_mach_cpu_die(void) 407 { 408 unsigned int cpu; 409 410 local_irq_disable(); 411 idle_task_exit(); 412 cpu = smp_processor_id(); 413 printk(KERN_DEBUG "CPU%d offline\n", cpu); 414 __get_cpu_var(cpu_state) = CPU_DEAD; 415 smp_wmb(); 416 while (__get_cpu_var(cpu_state) != CPU_UP_PREPARE) 417 cpu_relax(); 418 } 419 420 void generic_set_cpu_dead(unsigned int cpu) 421 { 422 per_cpu(cpu_state, cpu) = CPU_DEAD; 423 } 424 425 int generic_check_cpu_restart(unsigned int cpu) 426 { 427 return per_cpu(cpu_state, cpu) == CPU_UP_PREPARE; 428 } 429 #endif 430 431 struct create_idle { 432 struct work_struct work; 433 struct task_struct *idle; 434 struct completion done; 435 int cpu; 436 }; 437 438 static void __cpuinit do_fork_idle(struct work_struct *work) 439 { 440 struct create_idle *c_idle = 441 container_of(work, struct create_idle, work); 442 443 c_idle->idle = fork_idle(c_idle->cpu); 444 complete(&c_idle->done); 445 } 446 447 static int __cpuinit create_idle(unsigned int cpu) 448 { 449 struct thread_info *ti; 450 struct create_idle c_idle = { 451 .cpu = cpu, 452 .done = COMPLETION_INITIALIZER_ONSTACK(c_idle.done), 453 }; 454 INIT_WORK_ONSTACK(&c_idle.work, do_fork_idle); 455 456 c_idle.idle = get_idle_for_cpu(cpu); 457 458 /* We can't use kernel_thread since we must avoid to 459 * reschedule the child. We use a workqueue because 460 * we want to fork from a kernel thread, not whatever 461 * userspace process happens to be trying to online us. 462 */ 463 if (!c_idle.idle) { 464 schedule_work(&c_idle.work); 465 wait_for_completion(&c_idle.done); 466 } else 467 init_idle(c_idle.idle, cpu); 468 if (IS_ERR(c_idle.idle)) { 469 pr_err("Failed fork for CPU %u: %li", cpu, PTR_ERR(c_idle.idle)); 470 return PTR_ERR(c_idle.idle); 471 } 472 ti = task_thread_info(c_idle.idle); 473 474 #ifdef CONFIG_PPC64 475 paca[cpu].__current = c_idle.idle; 476 paca[cpu].kstack = (unsigned long)ti + THREAD_SIZE - STACK_FRAME_OVERHEAD; 477 #endif 478 ti->cpu = cpu; 479 current_set[cpu] = ti; 480 481 return 0; 482 } 483 484 int __cpuinit __cpu_up(unsigned int cpu) 485 { 486 int rc, c; 487 488 if (smp_ops == NULL || 489 (smp_ops->cpu_bootable && !smp_ops->cpu_bootable(cpu))) 490 return -EINVAL; 491 492 /* Make sure we have an idle thread */ 493 rc = create_idle(cpu); 494 if (rc) 495 return rc; 496 497 secondary_ti = current_set[cpu]; 498 499 /* Make sure callin-map entry is 0 (can be leftover a CPU 500 * hotplug 501 */ 502 cpu_callin_map[cpu] = 0; 503 504 /* The information for processor bringup must 505 * be written out to main store before we release 506 * the processor. 507 */ 508 smp_mb(); 509 510 /* wake up cpus */ 511 DBG("smp: kicking cpu %d\n", cpu); 512 rc = smp_ops->kick_cpu(cpu); 513 if (rc) { 514 pr_err("smp: failed starting cpu %d (rc %d)\n", cpu, rc); 515 return rc; 516 } 517 518 /* 519 * wait to see if the cpu made a callin (is actually up). 520 * use this value that I found through experimentation. 521 * -- Cort 522 */ 523 if (system_state < SYSTEM_RUNNING) 524 for (c = 50000; c && !cpu_callin_map[cpu]; c--) 525 udelay(100); 526 #ifdef CONFIG_HOTPLUG_CPU 527 else 528 /* 529 * CPUs can take much longer to come up in the 530 * hotplug case. Wait five seconds. 531 */ 532 for (c = 5000; c && !cpu_callin_map[cpu]; c--) 533 msleep(1); 534 #endif 535 536 if (!cpu_callin_map[cpu]) { 537 printk(KERN_ERR "Processor %u is stuck.\n", cpu); 538 return -ENOENT; 539 } 540 541 DBG("Processor %u found.\n", cpu); 542 543 if (smp_ops->give_timebase) 544 smp_ops->give_timebase(); 545 546 /* Wait until cpu puts itself in the online map */ 547 while (!cpu_online(cpu)) 548 cpu_relax(); 549 550 return 0; 551 } 552 553 /* Return the value of the reg property corresponding to the given 554 * logical cpu. 555 */ 556 int cpu_to_core_id(int cpu) 557 { 558 struct device_node *np; 559 const int *reg; 560 int id = -1; 561 562 np = of_get_cpu_node(cpu, NULL); 563 if (!np) 564 goto out; 565 566 reg = of_get_property(np, "reg", NULL); 567 if (!reg) 568 goto out; 569 570 id = *reg; 571 out: 572 of_node_put(np); 573 return id; 574 } 575 576 /* Helper routines for cpu to core mapping */ 577 int cpu_core_index_of_thread(int cpu) 578 { 579 return cpu >> threads_shift; 580 } 581 EXPORT_SYMBOL_GPL(cpu_core_index_of_thread); 582 583 int cpu_first_thread_of_core(int core) 584 { 585 return core << threads_shift; 586 } 587 EXPORT_SYMBOL_GPL(cpu_first_thread_of_core); 588 589 /* Must be called when no change can occur to cpu_present_mask, 590 * i.e. during cpu online or offline. 591 */ 592 static struct device_node *cpu_to_l2cache(int cpu) 593 { 594 struct device_node *np; 595 struct device_node *cache; 596 597 if (!cpu_present(cpu)) 598 return NULL; 599 600 np = of_get_cpu_node(cpu, NULL); 601 if (np == NULL) 602 return NULL; 603 604 cache = of_find_next_cache_node(np); 605 606 of_node_put(np); 607 608 return cache; 609 } 610 611 /* Activate a secondary processor. */ 612 void __devinit start_secondary(void *unused) 613 { 614 unsigned int cpu = smp_processor_id(); 615 struct device_node *l2_cache; 616 int i, base; 617 618 atomic_inc(&init_mm.mm_count); 619 current->active_mm = &init_mm; 620 621 smp_store_cpu_info(cpu); 622 set_dec(tb_ticks_per_jiffy); 623 preempt_disable(); 624 cpu_callin_map[cpu] = 1; 625 626 if (smp_ops->setup_cpu) 627 smp_ops->setup_cpu(cpu); 628 if (smp_ops->take_timebase) 629 smp_ops->take_timebase(); 630 631 secondary_cpu_time_init(); 632 633 #ifdef CONFIG_PPC64 634 if (system_state == SYSTEM_RUNNING) 635 vdso_data->processorCount++; 636 #endif 637 ipi_call_lock(); 638 notify_cpu_starting(cpu); 639 set_cpu_online(cpu, true); 640 /* Update sibling maps */ 641 base = cpu_first_thread_sibling(cpu); 642 for (i = 0; i < threads_per_core; i++) { 643 if (cpu_is_offline(base + i)) 644 continue; 645 cpumask_set_cpu(cpu, cpu_sibling_mask(base + i)); 646 cpumask_set_cpu(base + i, cpu_sibling_mask(cpu)); 647 648 /* cpu_core_map should be a superset of 649 * cpu_sibling_map even if we don't have cache 650 * information, so update the former here, too. 651 */ 652 cpumask_set_cpu(cpu, cpu_core_mask(base + i)); 653 cpumask_set_cpu(base + i, cpu_core_mask(cpu)); 654 } 655 l2_cache = cpu_to_l2cache(cpu); 656 for_each_online_cpu(i) { 657 struct device_node *np = cpu_to_l2cache(i); 658 if (!np) 659 continue; 660 if (np == l2_cache) { 661 cpumask_set_cpu(cpu, cpu_core_mask(i)); 662 cpumask_set_cpu(i, cpu_core_mask(cpu)); 663 } 664 of_node_put(np); 665 } 666 of_node_put(l2_cache); 667 ipi_call_unlock(); 668 669 local_irq_enable(); 670 671 cpu_idle(); 672 673 BUG(); 674 } 675 676 int setup_profiling_timer(unsigned int multiplier) 677 { 678 return 0; 679 } 680 681 void __init smp_cpus_done(unsigned int max_cpus) 682 { 683 cpumask_var_t old_mask; 684 685 /* We want the setup_cpu() here to be called from CPU 0, but our 686 * init thread may have been "borrowed" by another CPU in the meantime 687 * se we pin us down to CPU 0 for a short while 688 */ 689 alloc_cpumask_var(&old_mask, GFP_NOWAIT); 690 cpumask_copy(old_mask, tsk_cpus_allowed(current)); 691 set_cpus_allowed_ptr(current, cpumask_of(boot_cpuid)); 692 693 if (smp_ops && smp_ops->setup_cpu) 694 smp_ops->setup_cpu(boot_cpuid); 695 696 set_cpus_allowed_ptr(current, old_mask); 697 698 free_cpumask_var(old_mask); 699 700 if (smp_ops && smp_ops->bringup_done) 701 smp_ops->bringup_done(); 702 703 dump_numa_cpu_topology(); 704 705 } 706 707 int arch_sd_sibling_asym_packing(void) 708 { 709 if (cpu_has_feature(CPU_FTR_ASYM_SMT)) { 710 printk_once(KERN_INFO "Enabling Asymmetric SMT scheduling\n"); 711 return SD_ASYM_PACKING; 712 } 713 return 0; 714 } 715 716 #ifdef CONFIG_HOTPLUG_CPU 717 int __cpu_disable(void) 718 { 719 struct device_node *l2_cache; 720 int cpu = smp_processor_id(); 721 int base, i; 722 int err; 723 724 if (!smp_ops->cpu_disable) 725 return -ENOSYS; 726 727 err = smp_ops->cpu_disable(); 728 if (err) 729 return err; 730 731 /* Update sibling maps */ 732 base = cpu_first_thread_sibling(cpu); 733 for (i = 0; i < threads_per_core; i++) { 734 cpumask_clear_cpu(cpu, cpu_sibling_mask(base + i)); 735 cpumask_clear_cpu(base + i, cpu_sibling_mask(cpu)); 736 cpumask_clear_cpu(cpu, cpu_core_mask(base + i)); 737 cpumask_clear_cpu(base + i, cpu_core_mask(cpu)); 738 } 739 740 l2_cache = cpu_to_l2cache(cpu); 741 for_each_present_cpu(i) { 742 struct device_node *np = cpu_to_l2cache(i); 743 if (!np) 744 continue; 745 if (np == l2_cache) { 746 cpumask_clear_cpu(cpu, cpu_core_mask(i)); 747 cpumask_clear_cpu(i, cpu_core_mask(cpu)); 748 } 749 of_node_put(np); 750 } 751 of_node_put(l2_cache); 752 753 754 return 0; 755 } 756 757 void __cpu_die(unsigned int cpu) 758 { 759 if (smp_ops->cpu_die) 760 smp_ops->cpu_die(cpu); 761 } 762 763 static DEFINE_MUTEX(powerpc_cpu_hotplug_driver_mutex); 764 765 void cpu_hotplug_driver_lock() 766 { 767 mutex_lock(&powerpc_cpu_hotplug_driver_mutex); 768 } 769 770 void cpu_hotplug_driver_unlock() 771 { 772 mutex_unlock(&powerpc_cpu_hotplug_driver_mutex); 773 } 774 775 void cpu_die(void) 776 { 777 if (ppc_md.cpu_die) 778 ppc_md.cpu_die(); 779 780 /* If we return, we re-enter start_secondary */ 781 start_secondary_resume(); 782 } 783 784 #endif 785