~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/arm/kernel/smp.c

Version: ~ [ linux-5.10-rc1 ] ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  linux/arch/arm/kernel/smp.c
  3  *
  4  *  Copyright (C) 2002 ARM Limited, All Rights Reserved.
  5  *
  6  * This program is free software; you can redistribute it and/or modify
  7  * it under the terms of the GNU General Public License version 2 as
  8  * published by the Free Software Foundation.
  9  */
 10 #include <linux/module.h>
 11 #include <linux/delay.h>
 12 #include <linux/init.h>
 13 #include <linux/spinlock.h>
 14 #include <linux/sched.h>
 15 #include <linux/interrupt.h>
 16 #include <linux/cache.h>
 17 #include <linux/profile.h>
 18 #include <linux/errno.h>
 19 #include <linux/mm.h>
 20 #include <linux/err.h>
 21 #include <linux/cpu.h>
 22 #include <linux/seq_file.h>
 23 #include <linux/irq.h>
 24 #include <linux/percpu.h>
 25 #include <linux/clockchips.h>
 26 #include <linux/completion.h>
 27 #include <linux/cpufreq.h>
 28 #include <linux/irq_work.h>
 29 
 30 #include <linux/atomic.h>
 31 #include <asm/smp.h>
 32 #include <asm/cacheflush.h>
 33 #include <asm/cpu.h>
 34 #include <asm/cputype.h>
 35 #include <asm/exception.h>
 36 #include <asm/idmap.h>
 37 #include <asm/topology.h>
 38 #include <asm/mmu_context.h>
 39 #include <asm/pgtable.h>
 40 #include <asm/pgalloc.h>
 41 #include <asm/processor.h>
 42 #include <asm/sections.h>
 43 #include <asm/tlbflush.h>
 44 #include <asm/ptrace.h>
 45 #include <asm/smp_plat.h>
 46 #include <asm/virt.h>
 47 #include <asm/mach/arch.h>
 48 #include <asm/mpu.h>
 49 
 50 /*
 51  * as from 2.5, kernels no longer have an init_tasks structure
 52  * so we need some other way of telling a new secondary core
 53  * where to place its SVC stack
 54  */
 55 struct secondary_data secondary_data;
 56 
 57 /*
 58  * control for which core is the next to come out of the secondary
 59  * boot "holding pen"
 60  */
 61 volatile int pen_release = -1;
 62 
 63 enum ipi_msg_type {
 64         IPI_WAKEUP,
 65         IPI_TIMER,
 66         IPI_RESCHEDULE,
 67         IPI_CALL_FUNC,
 68         IPI_CALL_FUNC_SINGLE,
 69         IPI_CPU_STOP,
 70         IPI_IRQ_WORK,
 71         IPI_COMPLETION,
 72 };
 73 
 74 static DECLARE_COMPLETION(cpu_running);
 75 
 76 static struct smp_operations smp_ops;
 77 
 78 void __init smp_set_ops(struct smp_operations *ops)
 79 {
 80         if (ops)
 81                 smp_ops = *ops;
 82 };
 83 
 84 static unsigned long get_arch_pgd(pgd_t *pgd)
 85 {
 86         phys_addr_t pgdir = virt_to_idmap(pgd);
 87         BUG_ON(pgdir & ARCH_PGD_MASK);
 88         return pgdir >> ARCH_PGD_SHIFT;
 89 }
 90 
 91 int __cpu_up(unsigned int cpu, struct task_struct *idle)
 92 {
 93         int ret;
 94 
 95         /*
 96          * We need to tell the secondary core where to find
 97          * its stack and the page tables.
 98          */
 99         secondary_data.stack = task_stack_page(idle) + THREAD_START_SP;
100 #ifdef CONFIG_ARM_MPU
101         secondary_data.mpu_rgn_szr = mpu_rgn_info.rgns[MPU_RAM_REGION].drsr;
102 #endif
103 
104 #ifdef CONFIG_MMU
105         secondary_data.pgdir = get_arch_pgd(idmap_pgd);
106         secondary_data.swapper_pg_dir = get_arch_pgd(swapper_pg_dir);
107 #endif
108         sync_cache_w(&secondary_data);
109 
110         /*
111          * Now bring the CPU into our world.
112          */
113         ret = boot_secondary(cpu, idle);
114         if (ret == 0) {
115                 /*
116                  * CPU was successfully started, wait for it
117                  * to come online or time out.
118                  */
119                 wait_for_completion_timeout(&cpu_running,
120                                                  msecs_to_jiffies(1000));
121 
122                 if (!cpu_online(cpu)) {
123                         pr_crit("CPU%u: failed to come online\n", cpu);
124                         ret = -EIO;
125                 }
126         } else {
127                 pr_err("CPU%u: failed to boot: %d\n", cpu, ret);
128         }
129 
130 
131         memset(&secondary_data, 0, sizeof(secondary_data));
132         return ret;
133 }
134 
135 /* platform specific SMP operations */
136 void __init smp_init_cpus(void)
137 {
138         if (smp_ops.smp_init_cpus)
139                 smp_ops.smp_init_cpus();
140 }
141 
142 int boot_secondary(unsigned int cpu, struct task_struct *idle)
143 {
144         if (smp_ops.smp_boot_secondary)
145                 return smp_ops.smp_boot_secondary(cpu, idle);
146         return -ENOSYS;
147 }
148 
149 int platform_can_cpu_hotplug(void)
150 {
151 #ifdef CONFIG_HOTPLUG_CPU
152         if (smp_ops.cpu_kill)
153                 return 1;
154 #endif
155 
156         return 0;
157 }
158 
159 #ifdef CONFIG_HOTPLUG_CPU
160 static int platform_cpu_kill(unsigned int cpu)
161 {
162         if (smp_ops.cpu_kill)
163                 return smp_ops.cpu_kill(cpu);
164         return 1;
165 }
166 
167 static int platform_cpu_disable(unsigned int cpu)
168 {
169         if (smp_ops.cpu_disable)
170                 return smp_ops.cpu_disable(cpu);
171 
172         /*
173          * By default, allow disabling all CPUs except the first one,
174          * since this is special on a lot of platforms, e.g. because
175          * of clock tick interrupts.
176          */
177         return cpu == 0 ? -EPERM : 0;
178 }
179 /*
180  * __cpu_disable runs on the processor to be shutdown.
181  */
182 int __cpu_disable(void)
183 {
184         unsigned int cpu = smp_processor_id();
185         int ret;
186 
187         ret = platform_cpu_disable(cpu);
188         if (ret)
189                 return ret;
190 
191         /*
192          * Take this CPU offline.  Once we clear this, we can't return,
193          * and we must not schedule until we're ready to give up the cpu.
194          */
195         set_cpu_online(cpu, false);
196 
197         /*
198          * OK - migrate IRQs away from this CPU
199          */
200         migrate_irqs();
201 
202         /*
203          * Flush user cache and TLB mappings, and then remove this CPU
204          * from the vm mask set of all processes.
205          *
206          * Caches are flushed to the Level of Unification Inner Shareable
207          * to write-back dirty lines to unified caches shared by all CPUs.
208          */
209         flush_cache_louis();
210         local_flush_tlb_all();
211 
212         clear_tasks_mm_cpumask(cpu);
213 
214         return 0;
215 }
216 
217 static DECLARE_COMPLETION(cpu_died);
218 
219 /*
220  * called on the thread which is asking for a CPU to be shutdown -
221  * waits until shutdown has completed, or it is timed out.
222  */
223 void __cpu_die(unsigned int cpu)
224 {
225         if (!wait_for_completion_timeout(&cpu_died, msecs_to_jiffies(5000))) {
226                 pr_err("CPU%u: cpu didn't die\n", cpu);
227                 return;
228         }
229         printk(KERN_NOTICE "CPU%u: shutdown\n", cpu);
230 
231         /*
232          * platform_cpu_kill() is generally expected to do the powering off
233          * and/or cutting of clocks to the dying CPU.  Optionally, this may
234          * be done by the CPU which is dying in preference to supporting
235          * this call, but that means there is _no_ synchronisation between
236          * the requesting CPU and the dying CPU actually losing power.
237          */
238         if (!platform_cpu_kill(cpu))
239                 printk("CPU%u: unable to kill\n", cpu);
240 }
241 
242 /*
243  * Called from the idle thread for the CPU which has been shutdown.
244  *
245  * Note that we disable IRQs here, but do not re-enable them
246  * before returning to the caller. This is also the behaviour
247  * of the other hotplug-cpu capable cores, so presumably coming
248  * out of idle fixes this.
249  */
250 void __ref cpu_die(void)
251 {
252         unsigned int cpu = smp_processor_id();
253 
254         idle_task_exit();
255 
256         local_irq_disable();
257 
258         /*
259          * Flush the data out of the L1 cache for this CPU.  This must be
260          * before the completion to ensure that data is safely written out
261          * before platform_cpu_kill() gets called - which may disable
262          * *this* CPU and power down its cache.
263          */
264         flush_cache_louis();
265 
266         /*
267          * Tell __cpu_die() that this CPU is now safe to dispose of.  Once
268          * this returns, power and/or clocks can be removed at any point
269          * from this CPU and its cache by platform_cpu_kill().
270          */
271         complete(&cpu_died);
272 
273         /*
274          * Ensure that the cache lines associated with that completion are
275          * written out.  This covers the case where _this_ CPU is doing the
276          * powering down, to ensure that the completion is visible to the
277          * CPU waiting for this one.
278          */
279         flush_cache_louis();
280 
281         /*
282          * The actual CPU shutdown procedure is at least platform (if not
283          * CPU) specific.  This may remove power, or it may simply spin.
284          *
285          * Platforms are generally expected *NOT* to return from this call,
286          * although there are some which do because they have no way to
287          * power down the CPU.  These platforms are the _only_ reason we
288          * have a return path which uses the fragment of assembly below.
289          *
290          * The return path should not be used for platforms which can
291          * power off the CPU.
292          */
293         if (smp_ops.cpu_die)
294                 smp_ops.cpu_die(cpu);
295 
296         pr_warn("CPU%u: smp_ops.cpu_die() returned, trying to resuscitate\n",
297                 cpu);
298 
299         /*
300          * Do not return to the idle loop - jump back to the secondary
301          * cpu initialisation.  There's some initialisation which needs
302          * to be repeated to undo the effects of taking the CPU offline.
303          */
304         __asm__("mov    sp, %0\n"
305         "       mov     fp, #0\n"
306         "       b       secondary_start_kernel"
307                 :
308                 : "r" (task_stack_page(current) + THREAD_SIZE - 8));
309 }
310 #endif /* CONFIG_HOTPLUG_CPU */
311 
312 /*
313  * Called by both boot and secondaries to move global data into
314  * per-processor storage.
315  */
316 static void smp_store_cpu_info(unsigned int cpuid)
317 {
318         struct cpuinfo_arm *cpu_info = &per_cpu(cpu_data, cpuid);
319 
320         cpu_info->loops_per_jiffy = loops_per_jiffy;
321         cpu_info->cpuid = read_cpuid_id();
322 
323         store_cpu_topology(cpuid);
324 }
325 
326 /*
327  * This is the secondary CPU boot entry.  We're using this CPUs
328  * idle thread stack, but a set of temporary page tables.
329  */
330 asmlinkage void secondary_start_kernel(void)
331 {
332         struct mm_struct *mm = &init_mm;
333         unsigned int cpu;
334 
335         /*
336          * The identity mapping is uncached (strongly ordered), so
337          * switch away from it before attempting any exclusive accesses.
338          */
339         cpu_switch_mm(mm->pgd, mm);
340         local_flush_bp_all();
341         enter_lazy_tlb(mm, current);
342         local_flush_tlb_all();
343 
344         /*
345          * All kernel threads share the same mm context; grab a
346          * reference and switch to it.
347          */
348         cpu = smp_processor_id();
349         atomic_inc(&mm->mm_count);
350         current->active_mm = mm;
351         cpumask_set_cpu(cpu, mm_cpumask(mm));
352 
353         cpu_init();
354 
355         printk("CPU%u: Booted secondary processor\n", cpu);
356 
357         preempt_disable();
358         trace_hardirqs_off();
359 
360         /*
361          * Give the platform a chance to do its own initialisation.
362          */
363         if (smp_ops.smp_secondary_init)
364                 smp_ops.smp_secondary_init(cpu);
365 
366         notify_cpu_starting(cpu);
367 
368         calibrate_delay();
369 
370         smp_store_cpu_info(cpu);
371 
372         /*
373          * OK, now it's safe to let the boot CPU continue.  Wait for
374          * the CPU migration code to notice that the CPU is online
375          * before we continue - which happens after __cpu_up returns.
376          */
377         set_cpu_online(cpu, true);
378         complete(&cpu_running);
379 
380         local_irq_enable();
381         local_fiq_enable();
382 
383         /*
384          * OK, it's off to the idle thread for us
385          */
386         cpu_startup_entry(CPUHP_ONLINE);
387 }
388 
389 void __init smp_cpus_done(unsigned int max_cpus)
390 {
391         printk(KERN_INFO "SMP: Total of %d processors activated.\n",
392                num_online_cpus());
393 
394         hyp_mode_check();
395 }
396 
397 void __init smp_prepare_boot_cpu(void)
398 {
399         set_my_cpu_offset(per_cpu_offset(smp_processor_id()));
400 }
401 
402 void __init smp_prepare_cpus(unsigned int max_cpus)
403 {
404         unsigned int ncores = num_possible_cpus();
405 
406         init_cpu_topology();
407 
408         smp_store_cpu_info(smp_processor_id());
409 
410         /*
411          * are we trying to boot more cores than exist?
412          */
413         if (max_cpus > ncores)
414                 max_cpus = ncores;
415         if (ncores > 1 && max_cpus) {
416                 /*
417                  * Initialise the present map, which describes the set of CPUs
418                  * actually populated at the present time. A platform should
419                  * re-initialize the map in the platforms smp_prepare_cpus()
420                  * if present != possible (e.g. physical hotplug).
421                  */
422                 init_cpu_present(cpu_possible_mask);
423 
424                 /*
425                  * Initialise the SCU if there are more than one CPU
426                  * and let them know where to start.
427                  */
428                 if (smp_ops.smp_prepare_cpus)
429                         smp_ops.smp_prepare_cpus(max_cpus);
430         }
431 }
432 
433 static void (*smp_cross_call)(const struct cpumask *, unsigned int);
434 
435 void __init set_smp_cross_call(void (*fn)(const struct cpumask *, unsigned int))
436 {
437         if (!smp_cross_call)
438                 smp_cross_call = fn;
439 }
440 
441 void arch_send_call_function_ipi_mask(const struct cpumask *mask)
442 {
443         smp_cross_call(mask, IPI_CALL_FUNC);
444 }
445 
446 void arch_send_wakeup_ipi_mask(const struct cpumask *mask)
447 {
448         smp_cross_call(mask, IPI_WAKEUP);
449 }
450 
451 void arch_send_call_function_single_ipi(int cpu)
452 {
453         smp_cross_call(cpumask_of(cpu), IPI_CALL_FUNC_SINGLE);
454 }
455 
456 #ifdef CONFIG_IRQ_WORK
457 void arch_irq_work_raise(void)
458 {
459         if (is_smp())
460                 smp_cross_call(cpumask_of(smp_processor_id()), IPI_IRQ_WORK);
461 }
462 #endif
463 
464 static const char *ipi_types[NR_IPI] = {
465 #define S(x,s)  [x] = s
466         S(IPI_WAKEUP, "CPU wakeup interrupts"),
467         S(IPI_TIMER, "Timer broadcast interrupts"),
468         S(IPI_RESCHEDULE, "Rescheduling interrupts"),
469         S(IPI_CALL_FUNC, "Function call interrupts"),
470         S(IPI_CALL_FUNC_SINGLE, "Single function call interrupts"),
471         S(IPI_CPU_STOP, "CPU stop interrupts"),
472         S(IPI_IRQ_WORK, "IRQ work interrupts"),
473         S(IPI_COMPLETION, "completion interrupts"),
474 };
475 
476 void show_ipi_list(struct seq_file *p, int prec)
477 {
478         unsigned int cpu, i;
479 
480         for (i = 0; i < NR_IPI; i++) {
481                 seq_printf(p, "%*s%u: ", prec - 1, "IPI", i);
482 
483                 for_each_online_cpu(cpu)
484                         seq_printf(p, "%10u ",
485                                    __get_irq_stat(cpu, ipi_irqs[i]));
486 
487                 seq_printf(p, " %s\n", ipi_types[i]);
488         }
489 }
490 
491 u64 smp_irq_stat_cpu(unsigned int cpu)
492 {
493         u64 sum = 0;
494         int i;
495 
496         for (i = 0; i < NR_IPI; i++)
497                 sum += __get_irq_stat(cpu, ipi_irqs[i]);
498 
499         return sum;
500 }
501 
502 #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
503 void tick_broadcast(const struct cpumask *mask)
504 {
505         smp_cross_call(mask, IPI_TIMER);
506 }
507 #endif
508 
509 static DEFINE_RAW_SPINLOCK(stop_lock);
510 
511 /*
512  * ipi_cpu_stop - handle IPI from smp_send_stop()
513  */
514 static void ipi_cpu_stop(unsigned int cpu)
515 {
516         if (system_state == SYSTEM_BOOTING ||
517             system_state == SYSTEM_RUNNING) {
518                 raw_spin_lock(&stop_lock);
519                 printk(KERN_CRIT "CPU%u: stopping\n", cpu);
520                 dump_stack();
521                 raw_spin_unlock(&stop_lock);
522         }
523 
524         set_cpu_online(cpu, false);
525 
526         local_fiq_disable();
527         local_irq_disable();
528 
529         while (1)
530                 cpu_relax();
531 }
532 
533 static DEFINE_PER_CPU(struct completion *, cpu_completion);
534 
535 int register_ipi_completion(struct completion *completion, int cpu)
536 {
537         per_cpu(cpu_completion, cpu) = completion;
538         return IPI_COMPLETION;
539 }
540 
541 static void ipi_complete(unsigned int cpu)
542 {
543         complete(per_cpu(cpu_completion, cpu));
544 }
545 
546 /*
547  * Main handler for inter-processor interrupts
548  */
549 asmlinkage void __exception_irq_entry do_IPI(int ipinr, struct pt_regs *regs)
550 {
551         handle_IPI(ipinr, regs);
552 }
553 
554 void handle_IPI(int ipinr, struct pt_regs *regs)
555 {
556         unsigned int cpu = smp_processor_id();
557         struct pt_regs *old_regs = set_irq_regs(regs);
558 
559         if (ipinr < NR_IPI)
560                 __inc_irq_stat(cpu, ipi_irqs[ipinr]);
561 
562         switch (ipinr) {
563         case IPI_WAKEUP:
564                 break;
565 
566 #ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
567         case IPI_TIMER:
568                 irq_enter();
569                 tick_receive_broadcast();
570                 irq_exit();
571                 break;
572 #endif
573 
574         case IPI_RESCHEDULE:
575                 scheduler_ipi();
576                 break;
577 
578         case IPI_CALL_FUNC:
579                 irq_enter();
580                 generic_smp_call_function_interrupt();
581                 irq_exit();
582                 break;
583 
584         case IPI_CALL_FUNC_SINGLE:
585                 irq_enter();
586                 generic_smp_call_function_single_interrupt();
587                 irq_exit();
588                 break;
589 
590         case IPI_CPU_STOP:
591                 irq_enter();
592                 ipi_cpu_stop(cpu);
593                 irq_exit();
594                 break;
595 
596 #ifdef CONFIG_IRQ_WORK
597         case IPI_IRQ_WORK:
598                 irq_enter();
599                 irq_work_run();
600                 irq_exit();
601                 break;
602 #endif
603 
604         case IPI_COMPLETION:
605                 irq_enter();
606                 ipi_complete(cpu);
607                 irq_exit();
608                 break;
609 
610         default:
611                 printk(KERN_CRIT "CPU%u: Unknown IPI message 0x%x\n",
612                        cpu, ipinr);
613                 break;
614         }
615         set_irq_regs(old_regs);
616 }
617 
618 void smp_send_reschedule(int cpu)
619 {
620         smp_cross_call(cpumask_of(cpu), IPI_RESCHEDULE);
621 }
622 
623 void smp_send_stop(void)
624 {
625         unsigned long timeout;
626         struct cpumask mask;
627 
628         cpumask_copy(&mask, cpu_online_mask);
629         cpumask_clear_cpu(smp_processor_id(), &mask);
630         if (!cpumask_empty(&mask))
631                 smp_cross_call(&mask, IPI_CPU_STOP);
632 
633         /* Wait up to one second for other CPUs to stop */
634         timeout = USEC_PER_SEC;
635         while (num_online_cpus() > 1 && timeout--)
636                 udelay(1);
637 
638         if (num_online_cpus() > 1)
639                 pr_warning("SMP: failed to stop secondary CPUs\n");
640 }
641 
642 /*
643  * not supported here
644  */
645 int setup_profiling_timer(unsigned int multiplier)
646 {
647         return -EINVAL;
648 }
649 
650 #ifdef CONFIG_CPU_FREQ
651 
652 static DEFINE_PER_CPU(unsigned long, l_p_j_ref);
653 static DEFINE_PER_CPU(unsigned long, l_p_j_ref_freq);
654 static unsigned long global_l_p_j_ref;
655 static unsigned long global_l_p_j_ref_freq;
656 
657 static int cpufreq_callback(struct notifier_block *nb,
658                                         unsigned long val, void *data)
659 {
660         struct cpufreq_freqs *freq = data;
661         int cpu = freq->cpu;
662 
663         if (freq->flags & CPUFREQ_CONST_LOOPS)
664                 return NOTIFY_OK;
665 
666         if (!per_cpu(l_p_j_ref, cpu)) {
667                 per_cpu(l_p_j_ref, cpu) =
668                         per_cpu(cpu_data, cpu).loops_per_jiffy;
669                 per_cpu(l_p_j_ref_freq, cpu) = freq->old;
670                 if (!global_l_p_j_ref) {
671                         global_l_p_j_ref = loops_per_jiffy;
672                         global_l_p_j_ref_freq = freq->old;
673                 }
674         }
675 
676         if ((val == CPUFREQ_PRECHANGE  && freq->old < freq->new) ||
677             (val == CPUFREQ_POSTCHANGE && freq->old > freq->new)) {
678                 loops_per_jiffy = cpufreq_scale(global_l_p_j_ref,
679                                                 global_l_p_j_ref_freq,
680                                                 freq->new);
681                 per_cpu(cpu_data, cpu).loops_per_jiffy =
682                         cpufreq_scale(per_cpu(l_p_j_ref, cpu),
683                                         per_cpu(l_p_j_ref_freq, cpu),
684                                         freq->new);
685         }
686         return NOTIFY_OK;
687 }
688 
689 static struct notifier_block cpufreq_notifier = {
690         .notifier_call  = cpufreq_callback,
691 };
692 
693 static int __init register_cpufreq_notifier(void)
694 {
695         return cpufreq_register_notifier(&cpufreq_notifier,
696                                                 CPUFREQ_TRANSITION_NOTIFIER);
697 }
698 core_initcall(register_cpufreq_notifier);
699 
700 #endif
701 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp