kernel/cpu_pm.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2011 Google, Inc.
   4  *
   5  * Author:
   6  *      Colin Cross <ccross@android.com>
   7  */
   8
   9 #include <linux/kernel.h>
  10 #include <linux/cpu_pm.h>
  11 #include <linux/module.h>
  12 #include <linux/notifier.h>
  13 #include <linux/spinlock.h>
  14 #include <linux/syscore_ops.h>
  15
  16 /*
  17  * atomic_notifiers use a spinlock_t, which can block under PREEMPT_RT.
  18  * Notifications for cpu_pm will be issued by the idle task itself, which can
  19  * never block, IOW it requires using a raw_spinlock_t.
  20  */
  21 static struct {
  22         struct raw_notifier_head chain;
  23         raw_spinlock_t lock;
  24 } cpu_pm_notifier = {
  25         .chain = RAW_NOTIFIER_INIT(cpu_pm_notifier.chain),
  26         .lock  = __RAW_SPIN_LOCK_UNLOCKED(cpu_pm_notifier.lock),
  27 };
  28
  29 static int cpu_pm_notify(enum cpu_pm_event event)
  30 {
  31         int ret;
  32
  33         rcu_read_lock();
  34         ret = raw_notifier_call_chain(&cpu_pm_notifier.chain, event, NULL);
  35         rcu_read_unlock();
  36
  37         return notifier_to_errno(ret);
  38 }
  39
  40 static int cpu_pm_notify_robust(enum cpu_pm_event event_up, enum cpu_pm_event event_down)
  41 {
  42         unsigned long flags;
  43         int ret;
  44
  45         raw_spin_lock_irqsave(&cpu_pm_notifier.lock, flags);
  46         ret = raw_notifier_call_chain_robust(&cpu_pm_notifier.chain, event_up, event_down, NULL);
  47         raw_spin_unlock_irqrestore(&cpu_pm_notifier.lock, flags);
  48
  49         return notifier_to_errno(ret);
  50 }
  51
  52 /**
  53  * cpu_pm_register_notifier - register a driver with cpu_pm
  54  * @nb: notifier block to register
  55  *
  56  * Add a driver to a list of drivers that are notified about
  57  * CPU and CPU cluster low power entry and exit.
  58  *
  59  * This function has the same return conditions as raw_notifier_chain_register.
  60  */
  61 int cpu_pm_register_notifier(struct notifier_block *nb)
  62 {
  63         unsigned long flags;
  64         int ret;
  65
  66         raw_spin_lock_irqsave(&cpu_pm_notifier.lock, flags);
  67         ret = raw_notifier_chain_register(&cpu_pm_notifier.chain, nb);
  68         raw_spin_unlock_irqrestore(&cpu_pm_notifier.lock, flags);
  69         return ret;
  70 }
  71 EXPORT_SYMBOL_GPL(cpu_pm_register_notifier);
  72
  73 /**
  74  * cpu_pm_unregister_notifier - unregister a driver with cpu_pm
  75  * @nb: notifier block to be unregistered
  76  *
  77  * Remove a driver from the CPU PM notifier list.
  78  *
  79  * This function has the same return conditions as raw_notifier_chain_unregister.
  80  */
  81 int cpu_pm_unregister_notifier(struct notifier_block *nb)
  82 {
  83         unsigned long flags;
  84         int ret;
  85
  86         raw_spin_lock_irqsave(&cpu_pm_notifier.lock, flags);
  87         ret = raw_notifier_chain_unregister(&cpu_pm_notifier.chain, nb);
  88         raw_spin_unlock_irqrestore(&cpu_pm_notifier.lock, flags);
  89         return ret;
  90 }
  91 EXPORT_SYMBOL_GPL(cpu_pm_unregister_notifier);
  92
  93 /**
  94  * cpu_pm_enter - CPU low power entry notifier
  95  *
  96  * Notifies listeners that a single CPU is entering a low power state that may
  97  * cause some blocks in the same power domain as the cpu to reset.
  98  *
  99  * Must be called on the affected CPU with interrupts disabled.  Platform is
 100  * responsible for ensuring that cpu_pm_enter is not called twice on the same
 101  * CPU before cpu_pm_exit is called. Notified drivers can include VFP
 102  * co-processor, interrupt controller and its PM extensions, local CPU
 103  * timers context save/restore which shouldn't be interrupted. Hence it
 104  * must be called with interrupts disabled.
 105  *
 106  * Return conditions are same as __raw_notifier_call_chain.
 107  */
 108 int cpu_pm_enter(void)
 109 {
 110         return cpu_pm_notify_robust(CPU_PM_ENTER, CPU_PM_ENTER_FAILED);
 111 }
 112 EXPORT_SYMBOL_GPL(cpu_pm_enter);
 113
 114 /**
 115  * cpu_pm_exit - CPU low power exit notifier
 116  *
 117  * Notifies listeners that a single CPU is exiting a low power state that may
 118  * have caused some blocks in the same power domain as the cpu to reset.
 119  *
 120  * Notified drivers can include VFP co-processor, interrupt controller
 121  * and its PM extensions, local CPU timers context save/restore which
 122  * shouldn't be interrupted. Hence it must be called with interrupts disabled.
 123  *
 124  * Return conditions are same as __raw_notifier_call_chain.
 125  */
 126 int cpu_pm_exit(void)
 127 {
 128         return cpu_pm_notify(CPU_PM_EXIT);
 129 }
 130 EXPORT_SYMBOL_GPL(cpu_pm_exit);
 131
 132 /**
 133  * cpu_cluster_pm_enter - CPU cluster low power entry notifier
 134  *
 135  * Notifies listeners that all cpus in a power domain are entering a low power
 136  * state that may cause some blocks in the same power domain to reset.
 137  *
 138  * Must be called after cpu_pm_enter has been called on all cpus in the power
 139  * domain, and before cpu_pm_exit has been called on any cpu in the power
 140  * domain. Notified drivers can include VFP co-processor, interrupt controller
 141  * and its PM extensions, local CPU timers context save/restore which
 142  * shouldn't be interrupted. Hence it must be called with interrupts disabled.
 143  *
 144  * Must be called with interrupts disabled.
 145  *
 146  * Return conditions are same as __raw_notifier_call_chain.
 147  */
 148 int cpu_cluster_pm_enter(void)
 149 {
 150         return cpu_pm_notify_robust(CPU_CLUSTER_PM_ENTER, CPU_CLUSTER_PM_ENTER_FAILED);
 151 }
 152 EXPORT_SYMBOL_GPL(cpu_cluster_pm_enter);
 153
 154 /**
 155  * cpu_cluster_pm_exit - CPU cluster low power exit notifier
 156  *
 157  * Notifies listeners that all cpus in a power domain are exiting form a
 158  * low power state that may have caused some blocks in the same power domain
 159  * to reset.
 160  *
 161  * Must be called after cpu_cluster_pm_enter has been called for the power
 162  * domain, and before cpu_pm_exit has been called on any cpu in the power
 163  * domain. Notified drivers can include VFP co-processor, interrupt controller
 164  * and its PM extensions, local CPU timers context save/restore which
 165  * shouldn't be interrupted. Hence it must be called with interrupts disabled.
 166  *
 167  * Return conditions are same as __raw_notifier_call_chain.
 168  */
 169 int cpu_cluster_pm_exit(void)
 170 {
 171         return cpu_pm_notify(CPU_CLUSTER_PM_EXIT);
 172 }
 173 EXPORT_SYMBOL_GPL(cpu_cluster_pm_exit);
 174
 175 #ifdef CONFIG_PM
 176 static int cpu_pm_suspend(void)
 177 {
 178         int ret;
 179
 180         ret = cpu_pm_enter();
 181         if (ret)
 182                 return ret;
 183
 184         ret = cpu_cluster_pm_enter();
 185         return ret;
 186 }
 187
 188 static void cpu_pm_resume(void)
 189 {
 190         cpu_cluster_pm_exit();
 191         cpu_pm_exit();
 192 }
 193
 194 static struct syscore_ops cpu_pm_syscore_ops = {
 195         .suspend = cpu_pm_suspend,
 196         .resume = cpu_pm_resume,
 197 };
 198
 199 static int cpu_pm_init(void)
 200 {
 201         register_syscore_ops(&cpu_pm_syscore_ops);
 202         return 0;
 203 }
 204 core_initcall(cpu_pm_init);
 205 #endif