arch/m32r/kernel/smp.c

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