1 /* 2 * This program is free software; you can redistribute it and/or 3 * modify it under the terms of the GNU General Public License 4 * as published by the Free Software Foundation; either version 2 5 * of the License, or (at your option) any later version. 6 * 7 * This program is distributed in the hope that it will be useful, 8 * but WITHOUT ANY WARRANTY; without even the implied warranty of 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 10 * GNU General Public License for more details. 11 * 12 * You should have received a copy of the GNU General Public License 13 * along with this program; if not, write to the Free Software 14 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 15 * 16 * Copyright (C) 2000, 2001 Kanoj Sarcar 17 * Copyright (C) 2000, 2001 Ralf Baechle 18 * Copyright (C) 2000, 2001 Silicon Graphics, Inc. 19 * Copyright (C) 2000, 2001, 2003 Broadcom Corporation 20 */ 21 #include <linux/cache.h> 22 #include <linux/delay.h> 23 #include <linux/init.h> 24 #include <linux/interrupt.h> 25 #include <linux/smp.h> 26 #include <linux/spinlock.h> 27 #include <linux/threads.h> 28 #include <linux/module.h> 29 #include <linux/time.h> 30 #include <linux/timex.h> 31 #include <linux/sched.h> 32 #include <linux/cpumask.h> 33 #include <linux/cpu.h> 34 #include <linux/err.h> 35 #include <linux/ftrace.h> 36 #include <linux/irqdomain.h> 37 #include <linux/of.h> 38 #include <linux/of_irq.h> 39 40 #include <linux/atomic.h> 41 #include <asm/cpu.h> 42 #include <asm/processor.h> 43 #include <asm/idle.h> 44 #include <asm/r4k-timer.h> 45 #include <asm/mips-cpc.h> 46 #include <asm/mmu_context.h> 47 #include <asm/time.h> 48 #include <asm/setup.h> 49 #include <asm/maar.h> 50 51 cpumask_t cpu_callin_map; /* Bitmask of started secondaries */ 52 53 int __cpu_number_map[NR_CPUS]; /* Map physical to logical */ 54 EXPORT_SYMBOL(__cpu_number_map); 55 56 int __cpu_logical_map[NR_CPUS]; /* Map logical to physical */ 57 EXPORT_SYMBOL(__cpu_logical_map); 58 59 /* Number of TCs (or siblings in Intel speak) per CPU core */ 60 int smp_num_siblings = 1; 61 EXPORT_SYMBOL(smp_num_siblings); 62 63 /* representing the TCs (or siblings in Intel speak) of each logical CPU */ 64 cpumask_t cpu_sibling_map[NR_CPUS] __read_mostly; 65 EXPORT_SYMBOL(cpu_sibling_map); 66 67 /* representing the core map of multi-core chips of each logical CPU */ 68 cpumask_t cpu_core_map[NR_CPUS] __read_mostly; 69 EXPORT_SYMBOL(cpu_core_map); 70 71 /* 72 * A logcal cpu mask containing only one VPE per core to 73 * reduce the number of IPIs on large MT systems. 74 */ 75 cpumask_t cpu_foreign_map __read_mostly; 76 EXPORT_SYMBOL(cpu_foreign_map); 77 78 /* representing cpus for which sibling maps can be computed */ 79 static cpumask_t cpu_sibling_setup_map; 80 81 /* representing cpus for which core maps can be computed */ 82 static cpumask_t cpu_core_setup_map; 83 84 cpumask_t cpu_coherent_mask; 85 86 #ifdef CONFIG_GENERIC_IRQ_IPI 87 static struct irq_desc *call_desc; 88 static struct irq_desc *sched_desc; 89 #endif 90 91 static inline void set_cpu_sibling_map(int cpu) 92 { 93 int i; 94 95 cpumask_set_cpu(cpu, &cpu_sibling_setup_map); 96 97 if (smp_num_siblings > 1) { 98 for_each_cpu(i, &cpu_sibling_setup_map) { 99 if (cpu_data[cpu].package == cpu_data[i].package && 100 cpu_data[cpu].core == cpu_data[i].core) { 101 cpumask_set_cpu(i, &cpu_sibling_map[cpu]); 102 cpumask_set_cpu(cpu, &cpu_sibling_map[i]); 103 } 104 } 105 } else 106 cpumask_set_cpu(cpu, &cpu_sibling_map[cpu]); 107 } 108 109 static inline void set_cpu_core_map(int cpu) 110 { 111 int i; 112 113 cpumask_set_cpu(cpu, &cpu_core_setup_map); 114 115 for_each_cpu(i, &cpu_core_setup_map) { 116 if (cpu_data[cpu].package == cpu_data[i].package) { 117 cpumask_set_cpu(i, &cpu_core_map[cpu]); 118 cpumask_set_cpu(cpu, &cpu_core_map[i]); 119 } 120 } 121 } 122 123 /* 124 * Calculate a new cpu_foreign_map mask whenever a 125 * new cpu appears or disappears. 126 */ 127 static inline void calculate_cpu_foreign_map(void) 128 { 129 int i, k, core_present; 130 cpumask_t temp_foreign_map; 131 132 /* Re-calculate the mask */ 133 cpumask_clear(&temp_foreign_map); 134 for_each_online_cpu(i) { 135 core_present = 0; 136 for_each_cpu(k, &temp_foreign_map) 137 if (cpu_data[i].package == cpu_data[k].package && 138 cpu_data[i].core == cpu_data[k].core) 139 core_present = 1; 140 if (!core_present) 141 cpumask_set_cpu(i, &temp_foreign_map); 142 } 143 144 cpumask_copy(&cpu_foreign_map, &temp_foreign_map); 145 } 146 147 struct plat_smp_ops *mp_ops; 148 EXPORT_SYMBOL(mp_ops); 149 150 void register_smp_ops(struct plat_smp_ops *ops) 151 { 152 if (mp_ops) 153 printk(KERN_WARNING "Overriding previously set SMP ops\n"); 154 155 mp_ops = ops; 156 } 157 158 #ifdef CONFIG_GENERIC_IRQ_IPI 159 void mips_smp_send_ipi_single(int cpu, unsigned int action) 160 { 161 mips_smp_send_ipi_mask(cpumask_of(cpu), action); 162 } 163 164 void mips_smp_send_ipi_mask(const struct cpumask *mask, unsigned int action) 165 { 166 unsigned long flags; 167 unsigned int core; 168 int cpu; 169 170 local_irq_save(flags); 171 172 switch (action) { 173 case SMP_CALL_FUNCTION: 174 __ipi_send_mask(call_desc, mask); 175 break; 176 177 case SMP_RESCHEDULE_YOURSELF: 178 __ipi_send_mask(sched_desc, mask); 179 break; 180 181 default: 182 BUG(); 183 } 184 185 if (mips_cpc_present()) { 186 for_each_cpu(cpu, mask) { 187 core = cpu_data[cpu].core; 188 189 if (core == current_cpu_data.core) 190 continue; 191 192 while (!cpumask_test_cpu(cpu, &cpu_coherent_mask)) { 193 mips_cpc_lock_other(core); 194 write_cpc_co_cmd(CPC_Cx_CMD_PWRUP); 195 mips_cpc_unlock_other(); 196 } 197 } 198 } 199 200 local_irq_restore(flags); 201 } 202 203 204 static irqreturn_t ipi_resched_interrupt(int irq, void *dev_id) 205 { 206 scheduler_ipi(); 207 208 return IRQ_HANDLED; 209 } 210 211 static irqreturn_t ipi_call_interrupt(int irq, void *dev_id) 212 { 213 generic_smp_call_function_interrupt(); 214 215 return IRQ_HANDLED; 216 } 217 218 static struct irqaction irq_resched = { 219 .handler = ipi_resched_interrupt, 220 .flags = IRQF_PERCPU, 221 .name = "IPI resched" 222 }; 223 224 static struct irqaction irq_call = { 225 .handler = ipi_call_interrupt, 226 .flags = IRQF_PERCPU, 227 .name = "IPI call" 228 }; 229 230 static __init void smp_ipi_init_one(unsigned int virq, 231 struct irqaction *action) 232 { 233 int ret; 234 235 irq_set_handler(virq, handle_percpu_irq); 236 ret = setup_irq(virq, action); 237 BUG_ON(ret); 238 } 239 240 static int __init mips_smp_ipi_init(void) 241 { 242 unsigned int call_virq, sched_virq; 243 struct irq_domain *ipidomain; 244 struct device_node *node; 245 246 node = of_irq_find_parent(of_root); 247 ipidomain = irq_find_matching_host(node, DOMAIN_BUS_IPI); 248 249 /* 250 * Some platforms have half DT setup. So if we found irq node but 251 * didn't find an ipidomain, try to search for one that is not in the 252 * DT. 253 */ 254 if (node && !ipidomain) 255 ipidomain = irq_find_matching_host(NULL, DOMAIN_BUS_IPI); 256 257 BUG_ON(!ipidomain); 258 259 call_virq = irq_reserve_ipi(ipidomain, cpu_possible_mask); 260 BUG_ON(!call_virq); 261 262 sched_virq = irq_reserve_ipi(ipidomain, cpu_possible_mask); 263 BUG_ON(!sched_virq); 264 265 if (irq_domain_is_ipi_per_cpu(ipidomain)) { 266 int cpu; 267 268 for_each_cpu(cpu, cpu_possible_mask) { 269 smp_ipi_init_one(call_virq + cpu, &irq_call); 270 smp_ipi_init_one(sched_virq + cpu, &irq_resched); 271 } 272 } else { 273 smp_ipi_init_one(call_virq, &irq_call); 274 smp_ipi_init_one(sched_virq, &irq_resched); 275 } 276 277 call_desc = irq_to_desc(call_virq); 278 sched_desc = irq_to_desc(sched_virq); 279 280 return 0; 281 } 282 early_initcall(mips_smp_ipi_init); 283 #endif 284 285 /* 286 * First C code run on the secondary CPUs after being started up by 287 * the master. 288 */ 289 asmlinkage void start_secondary(void) 290 { 291 unsigned int cpu; 292 293 cpu_probe(); 294 per_cpu_trap_init(false); 295 mips_clockevent_init(); 296 mp_ops->init_secondary(); 297 cpu_report(); 298 maar_init(); 299 300 /* 301 * XXX parity protection should be folded in here when it's converted 302 * to an option instead of something based on .cputype 303 */ 304 305 calibrate_delay(); 306 preempt_disable(); 307 cpu = smp_processor_id(); 308 cpu_data[cpu].udelay_val = loops_per_jiffy; 309 310 cpumask_set_cpu(cpu, &cpu_coherent_mask); 311 notify_cpu_starting(cpu); 312 313 set_cpu_online(cpu, true); 314 315 set_cpu_sibling_map(cpu); 316 set_cpu_core_map(cpu); 317 318 calculate_cpu_foreign_map(); 319 320 cpumask_set_cpu(cpu, &cpu_callin_map); 321 322 synchronise_count_slave(cpu); 323 324 /* 325 * irq will be enabled in ->smp_finish(), enabling it too early 326 * is dangerous. 327 */ 328 WARN_ON_ONCE(!irqs_disabled()); 329 mp_ops->smp_finish(); 330 331 cpu_startup_entry(CPUHP_AP_ONLINE_IDLE); 332 } 333 334 static void stop_this_cpu(void *dummy) 335 { 336 /* 337 * Remove this CPU. Be a bit slow here and 338 * set the bits for every online CPU so we don't miss 339 * any IPI whilst taking this VPE down. 340 */ 341 342 cpumask_copy(&cpu_foreign_map, cpu_online_mask); 343 344 /* Make it visible to every other CPU */ 345 smp_mb(); 346 347 set_cpu_online(smp_processor_id(), false); 348 calculate_cpu_foreign_map(); 349 local_irq_disable(); 350 while (1); 351 } 352 353 void smp_send_stop(void) 354 { 355 smp_call_function(stop_this_cpu, NULL, 0); 356 } 357 358 void __init smp_cpus_done(unsigned int max_cpus) 359 { 360 } 361 362 /* called from main before smp_init() */ 363 void __init smp_prepare_cpus(unsigned int max_cpus) 364 { 365 init_new_context(current, &init_mm); 366 current_thread_info()->cpu = 0; 367 mp_ops->prepare_cpus(max_cpus); 368 set_cpu_sibling_map(0); 369 set_cpu_core_map(0); 370 calculate_cpu_foreign_map(); 371 #ifndef CONFIG_HOTPLUG_CPU 372 init_cpu_present(cpu_possible_mask); 373 #endif 374 cpumask_copy(&cpu_coherent_mask, cpu_possible_mask); 375 } 376 377 /* preload SMP state for boot cpu */ 378 void smp_prepare_boot_cpu(void) 379 { 380 set_cpu_possible(0, true); 381 set_cpu_online(0, true); 382 cpumask_set_cpu(0, &cpu_callin_map); 383 } 384 385 int __cpu_up(unsigned int cpu, struct task_struct *tidle) 386 { 387 mp_ops->boot_secondary(cpu, tidle); 388 389 /* 390 * Trust is futile. We should really have timeouts ... 391 */ 392 while (!cpumask_test_cpu(cpu, &cpu_callin_map)) { 393 udelay(100); 394 schedule(); 395 } 396 397 synchronise_count_master(cpu); 398 return 0; 399 } 400 401 /* Not really SMP stuff ... */ 402 int setup_profiling_timer(unsigned int multiplier) 403 { 404 return 0; 405 } 406 407 static void flush_tlb_all_ipi(void *info) 408 { 409 local_flush_tlb_all(); 410 } 411 412 void flush_tlb_all(void) 413 { 414 on_each_cpu(flush_tlb_all_ipi, NULL, 1); 415 } 416 417 static void flush_tlb_mm_ipi(void *mm) 418 { 419 local_flush_tlb_mm((struct mm_struct *)mm); 420 } 421 422 /* 423 * Special Variant of smp_call_function for use by TLB functions: 424 * 425 * o No return value 426 * o collapses to normal function call on UP kernels 427 * o collapses to normal function call on systems with a single shared 428 * primary cache. 429 */ 430 static inline void smp_on_other_tlbs(void (*func) (void *info), void *info) 431 { 432 smp_call_function(func, info, 1); 433 } 434 435 static inline void smp_on_each_tlb(void (*func) (void *info), void *info) 436 { 437 preempt_disable(); 438 439 smp_on_other_tlbs(func, info); 440 func(info); 441 442 preempt_enable(); 443 } 444 445 /* 446 * The following tlb flush calls are invoked when old translations are 447 * being torn down, or pte attributes are changing. For single threaded 448 * address spaces, a new context is obtained on the current cpu, and tlb 449 * context on other cpus are invalidated to force a new context allocation 450 * at switch_mm time, should the mm ever be used on other cpus. For 451 * multithreaded address spaces, intercpu interrupts have to be sent. 452 * Another case where intercpu interrupts are required is when the target 453 * mm might be active on another cpu (eg debuggers doing the flushes on 454 * behalf of debugees, kswapd stealing pages from another process etc). 455 * Kanoj 07/00. 456 */ 457 458 void flush_tlb_mm(struct mm_struct *mm) 459 { 460 preempt_disable(); 461 462 if ((atomic_read(&mm->mm_users) != 1) || (current->mm != mm)) { 463 smp_on_other_tlbs(flush_tlb_mm_ipi, mm); 464 } else { 465 unsigned int cpu; 466 467 for_each_online_cpu(cpu) { 468 if (cpu != smp_processor_id() && cpu_context(cpu, mm)) 469 cpu_context(cpu, mm) = 0; 470 } 471 } 472 local_flush_tlb_mm(mm); 473 474 preempt_enable(); 475 } 476 477 struct flush_tlb_data { 478 struct vm_area_struct *vma; 479 unsigned long addr1; 480 unsigned long addr2; 481 }; 482 483 static void flush_tlb_range_ipi(void *info) 484 { 485 struct flush_tlb_data *fd = info; 486 487 local_flush_tlb_range(fd->vma, fd->addr1, fd->addr2); 488 } 489 490 void flush_tlb_range(struct vm_area_struct *vma, unsigned long start, unsigned long end) 491 { 492 struct mm_struct *mm = vma->vm_mm; 493 494 preempt_disable(); 495 if ((atomic_read(&mm->mm_users) != 1) || (current->mm != mm)) { 496 struct flush_tlb_data fd = { 497 .vma = vma, 498 .addr1 = start, 499 .addr2 = end, 500 }; 501 502 smp_on_other_tlbs(flush_tlb_range_ipi, &fd); 503 } else { 504 unsigned int cpu; 505 506 for_each_online_cpu(cpu) { 507 if (cpu != smp_processor_id() && cpu_context(cpu, mm)) 508 cpu_context(cpu, mm) = 0; 509 } 510 } 511 local_flush_tlb_range(vma, start, end); 512 preempt_enable(); 513 } 514 515 static void flush_tlb_kernel_range_ipi(void *info) 516 { 517 struct flush_tlb_data *fd = info; 518 519 local_flush_tlb_kernel_range(fd->addr1, fd->addr2); 520 } 521 522 void flush_tlb_kernel_range(unsigned long start, unsigned long end) 523 { 524 struct flush_tlb_data fd = { 525 .addr1 = start, 526 .addr2 = end, 527 }; 528 529 on_each_cpu(flush_tlb_kernel_range_ipi, &fd, 1); 530 } 531 532 static void flush_tlb_page_ipi(void *info) 533 { 534 struct flush_tlb_data *fd = info; 535 536 local_flush_tlb_page(fd->vma, fd->addr1); 537 } 538 539 void flush_tlb_page(struct vm_area_struct *vma, unsigned long page) 540 { 541 preempt_disable(); 542 if ((atomic_read(&vma->vm_mm->mm_users) != 1) || (current->mm != vma->vm_mm)) { 543 struct flush_tlb_data fd = { 544 .vma = vma, 545 .addr1 = page, 546 }; 547 548 smp_on_other_tlbs(flush_tlb_page_ipi, &fd); 549 } else { 550 unsigned int cpu; 551 552 for_each_online_cpu(cpu) { 553 if (cpu != smp_processor_id() && cpu_context(cpu, vma->vm_mm)) 554 cpu_context(cpu, vma->vm_mm) = 0; 555 } 556 } 557 local_flush_tlb_page(vma, page); 558 preempt_enable(); 559 } 560 561 static void flush_tlb_one_ipi(void *info) 562 { 563 unsigned long vaddr = (unsigned long) info; 564 565 local_flush_tlb_one(vaddr); 566 } 567 568 void flush_tlb_one(unsigned long vaddr) 569 { 570 smp_on_each_tlb(flush_tlb_one_ipi, (void *) vaddr); 571 } 572 573 EXPORT_SYMBOL(flush_tlb_page); 574 EXPORT_SYMBOL(flush_tlb_one); 575 576 #if defined(CONFIG_KEXEC) 577 void (*dump_ipi_function_ptr)(void *) = NULL; 578 void dump_send_ipi(void (*dump_ipi_callback)(void *)) 579 { 580 int i; 581 int cpu = smp_processor_id(); 582 583 dump_ipi_function_ptr = dump_ipi_callback; 584 smp_mb(); 585 for_each_online_cpu(i) 586 if (i != cpu) 587 mp_ops->send_ipi_single(i, SMP_DUMP); 588 589 } 590 EXPORT_SYMBOL(dump_send_ipi); 591 #endif 592 593 #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST 594 595 static DEFINE_PER_CPU(atomic_t, tick_broadcast_count); 596 static DEFINE_PER_CPU(struct call_single_data, tick_broadcast_csd); 597 598 void tick_broadcast(const struct cpumask *mask) 599 { 600 atomic_t *count; 601 struct call_single_data *csd; 602 int cpu; 603 604 for_each_cpu(cpu, mask) { 605 count = &per_cpu(tick_broadcast_count, cpu); 606 csd = &per_cpu(tick_broadcast_csd, cpu); 607 608 if (atomic_inc_return(count) == 1) 609 smp_call_function_single_async(cpu, csd); 610 } 611 } 612 613 static void tick_broadcast_callee(void *info) 614 { 615 int cpu = smp_processor_id(); 616 tick_receive_broadcast(); 617 atomic_set(&per_cpu(tick_broadcast_count, cpu), 0); 618 } 619 620 static int __init tick_broadcast_init(void) 621 { 622 struct call_single_data *csd; 623 int cpu; 624 625 for (cpu = 0; cpu < NR_CPUS; cpu++) { 626 csd = &per_cpu(tick_broadcast_csd, cpu); 627 csd->func = tick_broadcast_callee; 628 } 629 630 return 0; 631 } 632 early_initcall(tick_broadcast_init); 633 634 #endif /* CONFIG_GENERIC_CLOCKEVENTS_BROADCAST */ 635