linux/arch/m32r/kernel/smp.c
<<
>>
Prefs
   1/*
   2 *  linux/arch/m32r/kernel/smp.c
   3 *
   4 *  M32R SMP support routines.
   5 *
   6 *  Copyright (c) 2001, 2002  Hitoshi Yamamoto
   7 *
   8 *  Taken from i386 version.
   9 *    (c) 1995 Alan Cox, Building #3 <alan@redhat.com>
  10 *    (c) 1998-99, 2000 Ingo Molnar <mingo@redhat.com>
  11 *
  12 *  This code is released under the GNU General Public License version 2 or
  13 *  later.
  14 */
  15
  16#undef DEBUG_SMP
  17
  18#include <linux/irq.h>
  19#include <linux/interrupt.h>
  20#include <linux/sched.h>
  21#include <linux/spinlock.h>
  22#include <linux/mm.h>
  23#include <linux/smp.h>
  24#include <linux/profile.h>
  25#include <linux/cpu.h>
  26
  27#include <asm/cacheflush.h>
  28#include <asm/pgalloc.h>
  29#include <linux/atomic.h>
  30#include <asm/io.h>
  31#include <asm/mmu_context.h>
  32#include <asm/m32r.h>
  33#include <asm/tlbflush.h>
  34
  35/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
  36/* Data structures and variables                                             */
  37/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
  38
  39/*
  40 * For flush_cache_all()
  41 */
  42static DEFINE_SPINLOCK(flushcache_lock);
  43static volatile unsigned long flushcache_cpumask = 0;
  44
  45/*
  46 * For flush_tlb_others()
  47 */
  48static volatile cpumask_t flush_cpumask;
  49static struct mm_struct *flush_mm;
  50static struct vm_area_struct *flush_vma;
  51static volatile unsigned long flush_va;
  52static DEFINE_SPINLOCK(tlbstate_lock);
  53#define FLUSH_ALL 0xffffffff
  54
  55DECLARE_PER_CPU(int, prof_multiplier);
  56DECLARE_PER_CPU(int, prof_old_multiplier);
  57DECLARE_PER_CPU(int, prof_counter);
  58
  59extern spinlock_t ipi_lock[];
  60
  61/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
  62/* Function Prototypes                                                       */
  63/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
  64
  65void smp_reschedule_interrupt(void);
  66void smp_flush_cache_all_interrupt(void);
  67
  68static void flush_tlb_all_ipi(void *);
  69static void flush_tlb_others(cpumask_t, struct mm_struct *,
  70        struct vm_area_struct *, unsigned long);
  71
  72void smp_invalidate_interrupt(void);
  73
  74static void stop_this_cpu(void *);
  75
  76void smp_ipi_timer_interrupt(struct pt_regs *);
  77void smp_local_timer_interrupt(void);
  78
  79static void send_IPI_allbutself(int, int);
  80static void send_IPI_mask(const struct cpumask *, int, int);
  81
  82/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
  83/* Rescheduling request Routines                                             */
  84/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
  85
  86/*==========================================================================*
  87 * Name:         smp_send_reschedule
  88 *
  89 * Description:  This routine requests other CPU to execute rescheduling.
  90 *               1.Send 'RESCHEDULE_IPI' to other CPU.
  91 *                 Request other CPU to execute 'smp_reschedule_interrupt()'.
  92 *
  93 * Born on Date: 2002.02.05
  94 *
  95 * Arguments:    cpu_id - Target CPU ID
  96 *
  97 * Returns:      void (cannot fail)
  98 *
  99 * Modification log:
 100 * Date       Who Description
 101 * ---------- --- --------------------------------------------------------
 102 *
 103 *==========================================================================*/
 104void smp_send_reschedule(int cpu_id)
 105{
 106        WARN_ON(cpu_is_offline(cpu_id));
 107        send_IPI_mask(cpumask_of(cpu_id), RESCHEDULE_IPI, 1);
 108}
 109
 110/*==========================================================================*
 111 * Name:         smp_reschedule_interrupt
 112 *
 113 * Description:  This routine executes on CPU which received
 114 *               'RESCHEDULE_IPI'.
 115 *
 116 * Born on Date: 2002.02.05
 117 *
 118 * Arguments:    NONE
 119 *
 120 * Returns:      void (cannot fail)
 121 *
 122 * Modification log:
 123 * Date       Who Description
 124 * ---------- --- --------------------------------------------------------
 125 *
 126 *==========================================================================*/
 127void smp_reschedule_interrupt(void)
 128{
 129        scheduler_ipi();
 130}
 131
 132/*==========================================================================*
 133 * Name:         smp_flush_cache_all
 134 *
 135 * Description:  This routine sends a 'INVALIDATE_CACHE_IPI' to all other
 136 *               CPUs in the system.
 137 *
 138 * Born on Date: 2003-05-28
 139 *
 140 * Arguments:    NONE
 141 *
 142 * Returns:      void (cannot fail)
 143 *
 144 * Modification log:
 145 * Date       Who Description
 146 * ---------- --- --------------------------------------------------------
 147 *
 148 *==========================================================================*/
 149void smp_flush_cache_all(void)
 150{
 151        cpumask_t cpumask;
 152        unsigned long *mask;
 153
 154        preempt_disable();
 155        cpumask_copy(&cpumask, cpu_online_mask);
 156        cpumask_clear_cpu(smp_processor_id(), &cpumask);
 157        spin_lock(&flushcache_lock);
 158        mask=cpumask_bits(&cpumask);
 159        atomic_set_mask(*mask, (atomic_t *)&flushcache_cpumask);
 160        send_IPI_mask(&cpumask, INVALIDATE_CACHE_IPI, 0);
 161        _flush_cache_copyback_all();
 162        while (flushcache_cpumask)
 163                mb();
 164        spin_unlock(&flushcache_lock);
 165        preempt_enable();
 166}
 167
 168void smp_flush_cache_all_interrupt(void)
 169{
 170        _flush_cache_copyback_all();
 171        clear_bit(smp_processor_id(), &flushcache_cpumask);
 172}
 173
 174/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
 175/* TLB flush request Routines                                                */
 176/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
 177
 178/*==========================================================================*
 179 * Name:         smp_flush_tlb_all
 180 *
 181 * Description:  This routine flushes all processes TLBs.
 182 *               1.Request other CPU to execute 'flush_tlb_all_ipi()'.
 183 *               2.Execute 'do_flush_tlb_all_local()'.
 184 *
 185 * Born on Date: 2002.02.05
 186 *
 187 * Arguments:    NONE
 188 *
 189 * Returns:      void (cannot fail)
 190 *
 191 * Modification log:
 192 * Date       Who Description
 193 * ---------- --- --------------------------------------------------------
 194 *
 195 *==========================================================================*/
 196void smp_flush_tlb_all(void)
 197{
 198        unsigned long flags;
 199
 200        preempt_disable();
 201        local_irq_save(flags);
 202        __flush_tlb_all();
 203        local_irq_restore(flags);
 204        smp_call_function(flush_tlb_all_ipi, NULL, 1);
 205        preempt_enable();
 206}
 207
 208/*==========================================================================*
 209 * Name:         flush_tlb_all_ipi
 210 *
 211 * Description:  This routine flushes all local TLBs.
 212 *               1.Execute 'do_flush_tlb_all_local()'.
 213 *
 214 * Born on Date: 2002.02.05
 215 *
 216 * Arguments:    *info - not used
 217 *
 218 * Returns:      void (cannot fail)
 219 *
 220 * Modification log:
 221 * Date       Who Description
 222 * ---------- --- --------------------------------------------------------
 223 *
 224 *==========================================================================*/
 225static void flush_tlb_all_ipi(void *info)
 226{
 227        __flush_tlb_all();
 228}
 229
 230/*==========================================================================*
 231 * Name:         smp_flush_tlb_mm
 232 *
 233 * Description:  This routine flushes the specified mm context TLB's.
 234 *
 235 * Born on Date: 2002.02.05
 236 *
 237 * Arguments:    *mm - a pointer to the mm struct for flush TLB
 238 *
 239 * Returns:      void (cannot fail)
 240 *
 241 * Modification log:
 242 * Date       Who Description
 243 * ---------- --- --------------------------------------------------------
 244 *
 245 *==========================================================================*/
 246void smp_flush_tlb_mm(struct mm_struct *mm)
 247{
 248        int cpu_id;
 249        cpumask_t cpu_mask;
 250        unsigned long *mmc;
 251        unsigned long flags;
 252
 253        preempt_disable();
 254        cpu_id = smp_processor_id();
 255        mmc = &mm->context[cpu_id];
 256        cpumask_copy(&cpu_mask, mm_cpumask(mm));
 257        cpumask_clear_cpu(cpu_id, &cpu_mask);
 258
 259        if (*mmc != NO_CONTEXT) {
 260                local_irq_save(flags);
 261                *mmc = NO_CONTEXT;
 262                if (mm == current->mm)
 263                        activate_context(mm);
 264                else
 265                        cpumask_clear_cpu(cpu_id, mm_cpumask(mm));
 266                local_irq_restore(flags);
 267        }
 268        if (!cpumask_empty(&cpu_mask))
 269                flush_tlb_others(cpu_mask, mm, NULL, FLUSH_ALL);
 270
 271        preempt_enable();
 272}
 273
 274/*==========================================================================*
 275 * Name:         smp_flush_tlb_range
 276 *
 277 * Description:  This routine flushes a range of pages.
 278 *
 279 * Born on Date: 2002.02.05
 280 *
 281 * Arguments:    *mm - a pointer to the mm struct for flush TLB
 282 *               start - not used
 283 *               end - not used
 284 *
 285 * Returns:      void (cannot fail)
 286 *
 287 * Modification log:
 288 * Date       Who Description
 289 * ---------- --- --------------------------------------------------------
 290 *
 291 *==========================================================================*/
 292void smp_flush_tlb_range(struct vm_area_struct *vma, unsigned long start,
 293        unsigned long end)
 294{
 295        smp_flush_tlb_mm(vma->vm_mm);
 296}
 297
 298/*==========================================================================*
 299 * Name:         smp_flush_tlb_page
 300 *
 301 * Description:  This routine flushes one page.
 302 *
 303 * Born on Date: 2002.02.05
 304 *
 305 * Arguments:    *vma - a pointer to the vma struct include va
 306 *               va - virtual address for flush TLB
 307 *
 308 * Returns:      void (cannot fail)
 309 *
 310 * Modification log:
 311 * Date       Who Description
 312 * ---------- --- --------------------------------------------------------
 313 *
 314 *==========================================================================*/
 315void smp_flush_tlb_page(struct vm_area_struct *vma, unsigned long va)
 316{
 317        struct mm_struct *mm = vma->vm_mm;
 318        int cpu_id;
 319        cpumask_t cpu_mask;
 320        unsigned long *mmc;
 321        unsigned long flags;
 322
 323        preempt_disable();
 324        cpu_id = smp_processor_id();
 325        mmc = &mm->context[cpu_id];
 326        cpumask_copy(&cpu_mask, mm_cpumask(mm));
 327        cpumask_clear_cpu(cpu_id, &cpu_mask);
 328
 329#ifdef DEBUG_SMP
 330        if (!mm)
 331                BUG();
 332#endif
 333
 334        if (*mmc != NO_CONTEXT) {
 335                local_irq_save(flags);
 336                va &= PAGE_MASK;
 337                va |= (*mmc & MMU_CONTEXT_ASID_MASK);
 338                __flush_tlb_page(va);
 339                local_irq_restore(flags);
 340        }
 341        if (!cpumask_empty(&cpu_mask))
 342                flush_tlb_others(cpu_mask, mm, vma, va);
 343
 344        preempt_enable();
 345}
 346
 347/*==========================================================================*
 348 * Name:         flush_tlb_others
 349 *
 350 * Description:  This routine requests other CPU to execute flush TLB.
 351 *               1.Setup parameters.
 352 *               2.Send 'INVALIDATE_TLB_IPI' to other CPU.
 353 *                 Request other CPU to execute 'smp_invalidate_interrupt()'.
 354 *               3.Wait for other CPUs operation finished.
 355 *
 356 * Born on Date: 2002.02.05
 357 *
 358 * Arguments:    cpumask - bitmap of target CPUs
 359 *               *mm -  a pointer to the mm struct for flush TLB
 360 *               *vma -  a pointer to the vma struct include va
 361 *               va - virtual address for flush TLB
 362 *
 363 * Returns:      void (cannot fail)
 364 *
 365 * Modification log:
 366 * Date       Who Description
 367 * ---------- --- --------------------------------------------------------
 368 *
 369 *==========================================================================*/
 370static void flush_tlb_others(cpumask_t cpumask, struct mm_struct *mm,
 371        struct vm_area_struct *vma, unsigned long va)
 372{
 373        unsigned long *mask;
 374#ifdef DEBUG_SMP
 375        unsigned long flags;
 376        __save_flags(flags);
 377        if (!(flags & 0x0040))  /* Interrupt Disable NONONO */
 378                BUG();
 379#endif /* DEBUG_SMP */
 380
 381        /*
 382         * A couple of (to be removed) sanity checks:
 383         *
 384         * - we do not send IPIs to not-yet booted CPUs.
 385         * - current CPU must not be in mask
 386         * - mask must exist :)
 387         */
 388        BUG_ON(cpumask_empty(&cpumask));
 389
 390        BUG_ON(cpumask_test_cpu(smp_processor_id(), &cpumask));
 391        BUG_ON(!mm);
 392
 393        /* If a CPU which we ran on has gone down, OK. */
 394        cpumask_and(&cpumask, &cpumask, cpu_online_mask);
 395        if (cpumask_empty(&cpumask))
 396                return;
 397
 398        /*
 399         * i'm not happy about this global shared spinlock in the
 400         * MM hot path, but we'll see how contended it is.
 401         * Temporarily this turns IRQs off, so that lockups are
 402         * detected by the NMI watchdog.
 403         */
 404        spin_lock(&tlbstate_lock);
 405
 406        flush_mm = mm;
 407        flush_vma = vma;
 408        flush_va = va;
 409        mask=cpumask_bits(&cpumask);
 410        atomic_set_mask(*mask, (atomic_t *)&flush_cpumask);
 411
 412        /*
 413         * We have to send the IPI only to
 414         * CPUs affected.
 415         */
 416        send_IPI_mask(&cpumask, INVALIDATE_TLB_IPI, 0);
 417
 418        while (!cpumask_empty((cpumask_t*)&flush_cpumask)) {
 419                /* nothing. lockup detection does not belong here */
 420                mb();
 421        }
 422
 423        flush_mm = NULL;
 424        flush_vma = NULL;
 425        flush_va = 0;
 426        spin_unlock(&tlbstate_lock);
 427}
 428
 429/*==========================================================================*
 430 * Name:         smp_invalidate_interrupt
 431 *
 432 * Description:  This routine executes on CPU which received
 433 *               'INVALIDATE_TLB_IPI'.
 434 *               1.Flush local TLB.
 435 *               2.Report flush TLB process was finished.
 436 *
 437 * Born on Date: 2002.02.05
 438 *
 439 * Arguments:    NONE
 440 *
 441 * Returns:      void (cannot fail)
 442 *
 443 * Modification log:
 444 * Date       Who Description
 445 * ---------- --- --------------------------------------------------------
 446 *
 447 *==========================================================================*/
 448void smp_invalidate_interrupt(void)
 449{
 450        int cpu_id = smp_processor_id();
 451        unsigned long *mmc = &flush_mm->context[cpu_id];
 452
 453        if (!cpumask_test_cpu(cpu_id, &flush_cpumask))
 454                return;
 455
 456        if (flush_va == FLUSH_ALL) {
 457                *mmc = NO_CONTEXT;
 458                if (flush_mm == current->active_mm)
 459                        activate_context(flush_mm);
 460                else
 461                        cpumask_clear_cpu(cpu_id, mm_cpumask(flush_mm));
 462        } else {
 463                unsigned long va = flush_va;
 464
 465                if (*mmc != NO_CONTEXT) {
 466                        va &= PAGE_MASK;
 467                        va |= (*mmc & MMU_CONTEXT_ASID_MASK);
 468                        __flush_tlb_page(va);
 469                }
 470        }
 471        cpumask_clear_cpu(cpu_id, (cpumask_t*)&flush_cpumask);
 472}
 473
 474/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
 475/* Stop CPU request Routines                                                 */
 476/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
 477
 478/*==========================================================================*
 479 * Name:         smp_send_stop
 480 *
 481 * Description:  This routine requests stop all CPUs.
 482 *               1.Request other CPU to execute 'stop_this_cpu()'.
 483 *
 484 * Born on Date: 2002.02.05
 485 *
 486 * Arguments:    NONE
 487 *
 488 * Returns:      void (cannot fail)
 489 *
 490 * Modification log:
 491 * Date       Who Description
 492 * ---------- --- --------------------------------------------------------
 493 *
 494 *==========================================================================*/
 495void smp_send_stop(void)
 496{
 497        smp_call_function(stop_this_cpu, NULL, 0);
 498}
 499
 500/*==========================================================================*
 501 * Name:         stop_this_cpu
 502 *
 503 * Description:  This routine halt CPU.
 504 *
 505 * Born on Date: 2002.02.05
 506 *
 507 * Arguments:    NONE
 508 *
 509 * Returns:      void (cannot fail)
 510 *
 511 * Modification log:
 512 * Date       Who Description
 513 * ---------- --- --------------------------------------------------------
 514 *
 515 *==========================================================================*/
 516static void stop_this_cpu(void *dummy)
 517{
 518        int cpu_id = smp_processor_id();
 519
 520        /*
 521         * Remove this CPU:
 522         */
 523        set_cpu_online(cpu_id, false);
 524
 525        /*
 526         * PSW IE = 1;
 527         * IMASK = 0;
 528         * goto SLEEP
 529         */
 530        local_irq_disable();
 531        outl(0, M32R_ICU_IMASK_PORTL);
 532        inl(M32R_ICU_IMASK_PORTL);      /* dummy read */
 533        local_irq_enable();
 534
 535        for ( ; ; );
 536}
 537
 538void arch_send_call_function_ipi_mask(const struct cpumask *mask)
 539{
 540        send_IPI_mask(mask, CALL_FUNCTION_IPI, 0);
 541}
 542
 543void arch_send_call_function_single_ipi(int cpu)
 544{
 545        send_IPI_mask(cpumask_of(cpu), CALL_FUNC_SINGLE_IPI, 0);
 546}
 547
 548/*==========================================================================*
 549 * Name:         smp_call_function_interrupt
 550 *
 551 * Description:  This routine executes on CPU which received
 552 *               'CALL_FUNCTION_IPI'.
 553 *
 554 * Born on Date: 2002.02.05
 555 *
 556 * Arguments:    NONE
 557 *
 558 * Returns:      void (cannot fail)
 559 *
 560 * Modification log:
 561 * Date       Who Description
 562 * ---------- --- --------------------------------------------------------
 563 *
 564 *==========================================================================*/
 565void smp_call_function_interrupt(void)
 566{
 567        irq_enter();
 568        generic_smp_call_function_interrupt();
 569        irq_exit();
 570}
 571
 572void smp_call_function_single_interrupt(void)
 573{
 574        irq_enter();
 575        generic_smp_call_function_single_interrupt();
 576        irq_exit();
 577}
 578
 579/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
 580/* Timer Routines                                                            */
 581/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
 582
 583/*==========================================================================*
 584 * Name:         smp_send_timer
 585 *
 586 * Description:  This routine sends a 'LOCAL_TIMER_IPI' to all other CPUs
 587 *               in the system.
 588 *
 589 * Born on Date: 2002.02.05
 590 *
 591 * Arguments:    NONE
 592 *
 593 * Returns:      void (cannot fail)
 594 *
 595 * Modification log:
 596 * Date       Who Description
 597 * ---------- --- --------------------------------------------------------
 598 *
 599 *==========================================================================*/
 600void smp_send_timer(void)
 601{
 602        send_IPI_allbutself(LOCAL_TIMER_IPI, 1);
 603}
 604
 605/*==========================================================================*
 606 * Name:         smp_send_timer
 607 *
 608 * Description:  This routine executes on CPU which received
 609 *               'LOCAL_TIMER_IPI'.
 610 *
 611 * Born on Date: 2002.02.05
 612 *
 613 * Arguments:    *regs - a pointer to the saved regster info
 614 *
 615 * Returns:      void (cannot fail)
 616 *
 617 * Modification log:
 618 * Date       Who Description
 619 * ---------- --- --------------------------------------------------------
 620 *
 621 *==========================================================================*/
 622void smp_ipi_timer_interrupt(struct pt_regs *regs)
 623{
 624        struct pt_regs *old_regs;
 625        old_regs = set_irq_regs(regs);
 626        irq_enter();
 627        smp_local_timer_interrupt();
 628        irq_exit();
 629        set_irq_regs(old_regs);
 630}
 631
 632/*==========================================================================*
 633 * Name:         smp_local_timer_interrupt
 634 *
 635 * Description:  Local timer interrupt handler. It does both profiling and
 636 *               process statistics/rescheduling.
 637 *               We do profiling in every local tick, statistics/rescheduling
 638 *               happen only every 'profiling multiplier' ticks. The default
 639 *               multiplier is 1 and it can be changed by writing the new
 640 *               multiplier value into /proc/profile.
 641 *
 642 * Born on Date: 2002.02.05
 643 *
 644 * Arguments:    *regs - a pointer to the saved regster info
 645 *
 646 * Returns:      void (cannot fail)
 647 *
 648 * Original:     arch/i386/kernel/apic.c
 649 *
 650 * Modification log:
 651 * Date       Who Description
 652 * ---------- --- --------------------------------------------------------
 653 * 2003-06-24 hy  use per_cpu structure.
 654 *==========================================================================*/
 655void smp_local_timer_interrupt(void)
 656{
 657        int user = user_mode(get_irq_regs());
 658        int cpu_id = smp_processor_id();
 659
 660        /*
 661         * The profiling function is SMP safe. (nothing can mess
 662         * around with "current", and the profiling counters are
 663         * updated with atomic operations). This is especially
 664         * useful with a profiling multiplier != 1
 665         */
 666
 667        profile_tick(CPU_PROFILING);
 668
 669        if (--per_cpu(prof_counter, cpu_id) <= 0) {
 670                /*
 671                 * The multiplier may have changed since the last time we got
 672                 * to this point as a result of the user writing to
 673                 * /proc/profile. In this case we need to adjust the APIC
 674                 * timer accordingly.
 675                 *
 676                 * Interrupts are already masked off at this point.
 677                 */
 678                per_cpu(prof_counter, cpu_id)
 679                        = per_cpu(prof_multiplier, cpu_id);
 680                if (per_cpu(prof_counter, cpu_id)
 681                        != per_cpu(prof_old_multiplier, cpu_id))
 682                {
 683                        per_cpu(prof_old_multiplier, cpu_id)
 684                                = per_cpu(prof_counter, cpu_id);
 685                }
 686
 687                update_process_times(user);
 688        }
 689}
 690
 691/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
 692/* Send IPI Routines                                                         */
 693/*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*=*/
 694
 695/*==========================================================================*
 696 * Name:         send_IPI_allbutself
 697 *
 698 * Description:  This routine sends a IPI to all other CPUs in the system.
 699 *
 700 * Born on Date: 2002.02.05
 701 *
 702 * Arguments:    ipi_num - Number of IPI
 703 *               try -  0 : Send IPI certainly.
 704 *                     !0 : The following IPI is not sent when Target CPU
 705 *                          has not received the before IPI.
 706 *
 707 * Returns:      void (cannot fail)
 708 *
 709 * Modification log:
 710 * Date       Who Description
 711 * ---------- --- --------------------------------------------------------
 712 *
 713 *==========================================================================*/
 714static void send_IPI_allbutself(int ipi_num, int try)
 715{
 716        cpumask_t cpumask;
 717
 718        cpumask_copy(&cpumask, cpu_online_mask);
 719        cpumask_clear_cpu(smp_processor_id(), &cpumask);
 720
 721        send_IPI_mask(&cpumask, ipi_num, try);
 722}
 723
 724/*==========================================================================*
 725 * Name:         send_IPI_mask
 726 *
 727 * Description:  This routine sends a IPI to CPUs in the system.
 728 *
 729 * Born on Date: 2002.02.05
 730 *
 731 * Arguments:    cpu_mask - Bitmap of target CPUs logical ID
 732 *               ipi_num - Number of IPI
 733 *               try -  0 : Send IPI certainly.
 734 *                     !0 : The following IPI is not sent when Target CPU
 735 *                          has not received the before IPI.
 736 *
 737 * Returns:      void (cannot fail)
 738 *
 739 * Modification log:
 740 * Date       Who Description
 741 * ---------- --- --------------------------------------------------------
 742 *
 743 *==========================================================================*/
 744static void send_IPI_mask(const struct cpumask *cpumask, int ipi_num, int try)
 745{
 746        cpumask_t physid_mask, tmp;
 747        int cpu_id, phys_id;
 748        int num_cpus = num_online_cpus();
 749
 750        if (num_cpus <= 1)      /* NO MP */
 751                return;
 752
 753        cpumask_and(&tmp, cpumask, cpu_online_mask);
 754        BUG_ON(!cpumask_equal(cpumask, &tmp));
 755
 756        cpumask_clear(&physid_mask);
 757        for_each_cpu(cpu_id, cpumask) {
 758                if ((phys_id = cpu_to_physid(cpu_id)) != -1)
 759                        cpumask_set_cpu(phys_id, &physid_mask);
 760        }
 761
 762        send_IPI_mask_phys(&physid_mask, ipi_num, try);
 763}
 764
 765/*==========================================================================*
 766 * Name:         send_IPI_mask_phys
 767 *
 768 * Description:  This routine sends a IPI to other CPUs in the system.
 769 *
 770 * Born on Date: 2002.02.05
 771 *
 772 * Arguments:    cpu_mask - Bitmap of target CPUs physical ID
 773 *               ipi_num - Number of IPI
 774 *               try -  0 : Send IPI certainly.
 775 *                     !0 : The following IPI is not sent when Target CPU
 776 *                          has not received the before IPI.
 777 *
 778 * Returns:      IPICRi regster value.
 779 *
 780 * Modification log:
 781 * Date       Who Description
 782 * ---------- --- --------------------------------------------------------
 783 *
 784 *==========================================================================*/
 785unsigned long send_IPI_mask_phys(const cpumask_t *physid_mask, int ipi_num,
 786        int try)
 787{
 788        spinlock_t *ipilock;
 789        volatile unsigned long *ipicr_addr;
 790        unsigned long ipicr_val;
 791        unsigned long my_physid_mask;
 792        unsigned long mask = cpumask_bits(physid_mask)[0];
 793
 794
 795        if (mask & ~physids_coerce(phys_cpu_present_map))
 796                BUG();
 797        if (ipi_num >= NR_IPIS || ipi_num < 0)
 798                BUG();
 799
 800        mask <<= IPI_SHIFT;
 801        ipilock = &ipi_lock[ipi_num];
 802        ipicr_addr = (volatile unsigned long *)(M32R_ICU_IPICR_ADDR
 803                + (ipi_num << 2));
 804        my_physid_mask = ~(1 << smp_processor_id());
 805
 806        /*
 807         * lock ipi_lock[i]
 808         * check IPICRi == 0
 809         * write IPICRi (send IPIi)
 810         * unlock ipi_lock[i]
 811         */
 812        spin_lock(ipilock);
 813        __asm__ __volatile__ (
 814                ";; CHECK IPICRi == 0           \n\t"
 815                ".fillinsn                      \n"
 816                "1:                             \n\t"
 817                "ld     %0, @%1                 \n\t"
 818                "and    %0, %4                  \n\t"
 819                "beqz   %0, 2f                  \n\t"
 820                "bnez   %3, 3f                  \n\t"
 821                "bra    1b                      \n\t"
 822                ";; WRITE IPICRi (send IPIi)    \n\t"
 823                ".fillinsn                      \n"
 824                "2:                             \n\t"
 825                "st     %2, @%1                 \n\t"
 826                ".fillinsn                      \n"
 827                "3:                             \n\t"
 828                : "=&r"(ipicr_val)
 829                : "r"(ipicr_addr), "r"(mask), "r"(try), "r"(my_physid_mask)
 830                : "memory"
 831        );
 832        spin_unlock(ipilock);
 833
 834        return ipicr_val;
 835}
 836