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

TOMOYO Linux Cross Reference
Linux/kernel/cpu_pm.c

Version: ~ [ linux-6.12-rc7 ] ~ [ linux-6.11.7 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.60 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.116 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.171 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.229 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.285 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.323 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ 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.12 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /kernel/cpu_pm.c (Version linux-6.12-rc7) and /kernel/cpu_pm.c (Version linux-4.10.17)


  1 // SPDX-License-Identifier: GPL-2.0-only       << 
  2 /*                                                  1 /*
  3  * Copyright (C) 2011 Google, Inc.                  2  * Copyright (C) 2011 Google, Inc.
  4  *                                                  3  *
  5  * Author:                                          4  * Author:
  6  *      Colin Cross <ccross@android.com>            5  *      Colin Cross <ccross@android.com>
                                                   >>   6  *
                                                   >>   7  * This software is licensed under the terms of the GNU General Public
                                                   >>   8  * License version 2, as published by the Free Software Foundation, and
                                                   >>   9  * may be copied, distributed, and modified under those terms.
                                                   >>  10  *
                                                   >>  11  * This program is distributed in the hope that it will be useful,
                                                   >>  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
                                                   >>  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                                                   >>  14  * GNU General Public License for more details.
                                                   >>  15  *
  7  */                                                16  */
  8                                                    17 
  9 #include <linux/kernel.h>                          18 #include <linux/kernel.h>
 10 #include <linux/cpu_pm.h>                          19 #include <linux/cpu_pm.h>
 11 #include <linux/module.h>                          20 #include <linux/module.h>
 12 #include <linux/notifier.h>                        21 #include <linux/notifier.h>
 13 #include <linux/spinlock.h>                        22 #include <linux/spinlock.h>
 14 #include <linux/syscore_ops.h>                     23 #include <linux/syscore_ops.h>
 15                                                    24 
 16 /*                                             !!  25 static DEFINE_RWLOCK(cpu_pm_notifier_lock);
 17  * atomic_notifiers use a spinlock_t, which ca !!  26 static RAW_NOTIFIER_HEAD(cpu_pm_notifier_chain);
 18  * Notifications for cpu_pm will be issued by  << 
 19  * never block, IOW it requires using a raw_sp << 
 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_noti << 
 26         .lock  = __RAW_SPIN_LOCK_UNLOCKED(cpu_ << 
 27 };                                             << 
 28                                                << 
 29 static int cpu_pm_notify(enum cpu_pm_event eve << 
 30 {                                              << 
 31         int ret;                               << 
 32                                                << 
 33         rcu_read_lock();                       << 
 34         ret = raw_notifier_call_chain(&cpu_pm_ << 
 35         rcu_read_unlock();                     << 
 36                                                    27 
 37         return notifier_to_errno(ret);         !!  28 static int cpu_pm_notify(enum cpu_pm_event event, int nr_to_call, int *nr_calls)
 38 }                                              << 
 39                                                << 
 40 static int cpu_pm_notify_robust(enum cpu_pm_ev << 
 41 {                                                  29 {
 42         unsigned long flags;                   << 
 43         int ret;                                   30         int ret;
 44                                                    31 
 45         raw_spin_lock_irqsave(&cpu_pm_notifier !!  32         ret = __raw_notifier_call_chain(&cpu_pm_notifier_chain, event, NULL,
 46         ret = raw_notifier_call_chain_robust(& !!  33                 nr_to_call, nr_calls);
 47         raw_spin_unlock_irqrestore(&cpu_pm_not << 
 48                                                    34 
 49         return notifier_to_errno(ret);             35         return notifier_to_errno(ret);
 50 }                                                  36 }
 51                                                    37 
 52 /**                                                38 /**
 53  * cpu_pm_register_notifier - register a drive     39  * cpu_pm_register_notifier - register a driver with cpu_pm
 54  * @nb: notifier block to register                 40  * @nb: notifier block to register
 55  *                                                 41  *
 56  * Add a driver to a list of drivers that are      42  * Add a driver to a list of drivers that are notified about
 57  * CPU and CPU cluster low power entry and exi     43  * CPU and CPU cluster low power entry and exit.
 58  *                                                 44  *
 59  * This function has the same return condition !!  45  * This function may sleep, and has the same return conditions as
                                                   >>  46  * raw_notifier_chain_register.
 60  */                                                47  */
 61 int cpu_pm_register_notifier(struct notifier_b     48 int cpu_pm_register_notifier(struct notifier_block *nb)
 62 {                                                  49 {
 63         unsigned long flags;                       50         unsigned long flags;
 64         int ret;                                   51         int ret;
 65                                                    52 
 66         raw_spin_lock_irqsave(&cpu_pm_notifier !!  53         write_lock_irqsave(&cpu_pm_notifier_lock, flags);
 67         ret = raw_notifier_chain_register(&cpu !!  54         ret = raw_notifier_chain_register(&cpu_pm_notifier_chain, nb);
 68         raw_spin_unlock_irqrestore(&cpu_pm_not !!  55         write_unlock_irqrestore(&cpu_pm_notifier_lock, flags);
                                                   >>  56 
 69         return ret;                                57         return ret;
 70 }                                                  58 }
 71 EXPORT_SYMBOL_GPL(cpu_pm_register_notifier);       59 EXPORT_SYMBOL_GPL(cpu_pm_register_notifier);
 72                                                    60 
 73 /**                                                61 /**
 74  * cpu_pm_unregister_notifier - unregister a d     62  * cpu_pm_unregister_notifier - unregister a driver with cpu_pm
 75  * @nb: notifier block to be unregistered          63  * @nb: notifier block to be unregistered
 76  *                                                 64  *
 77  * Remove a driver from the CPU PM notifier li     65  * Remove a driver from the CPU PM notifier list.
 78  *                                                 66  *
 79  * This function has the same return condition !!  67  * This function may sleep, and has the same return conditions as
                                                   >>  68  * raw_notifier_chain_unregister.
 80  */                                                69  */
 81 int cpu_pm_unregister_notifier(struct notifier     70 int cpu_pm_unregister_notifier(struct notifier_block *nb)
 82 {                                                  71 {
 83         unsigned long flags;                       72         unsigned long flags;
 84         int ret;                                   73         int ret;
 85                                                    74 
 86         raw_spin_lock_irqsave(&cpu_pm_notifier !!  75         write_lock_irqsave(&cpu_pm_notifier_lock, flags);
 87         ret = raw_notifier_chain_unregister(&c !!  76         ret = raw_notifier_chain_unregister(&cpu_pm_notifier_chain, nb);
 88         raw_spin_unlock_irqrestore(&cpu_pm_not !!  77         write_unlock_irqrestore(&cpu_pm_notifier_lock, flags);
                                                   >>  78 
 89         return ret;                                79         return ret;
 90 }                                                  80 }
 91 EXPORT_SYMBOL_GPL(cpu_pm_unregister_notifier);     81 EXPORT_SYMBOL_GPL(cpu_pm_unregister_notifier);
 92                                                    82 
 93 /**                                                83 /**
 94  * cpu_pm_enter - CPU low power entry notifier     84  * cpu_pm_enter - CPU low power entry notifier
 95  *                                                 85  *
 96  * Notifies listeners that a single CPU is ent     86  * Notifies listeners that a single CPU is entering a low power state that may
 97  * cause some blocks in the same power domain      87  * cause some blocks in the same power domain as the cpu to reset.
 98  *                                                 88  *
 99  * Must be called on the affected CPU with int     89  * Must be called on the affected CPU with interrupts disabled.  Platform is
100  * responsible for ensuring that cpu_pm_enter      90  * responsible for ensuring that cpu_pm_enter is not called twice on the same
101  * CPU before cpu_pm_exit is called. Notified      91  * CPU before cpu_pm_exit is called. Notified drivers can include VFP
102  * co-processor, interrupt controller and its      92  * co-processor, interrupt controller and its PM extensions, local CPU
103  * timers context save/restore which shouldn't     93  * timers context save/restore which shouldn't be interrupted. Hence it
104  * must be called with interrupts disabled.        94  * must be called with interrupts disabled.
105  *                                                 95  *
106  * Return conditions are same as __raw_notifie     96  * Return conditions are same as __raw_notifier_call_chain.
107  */                                                97  */
108 int cpu_pm_enter(void)                             98 int cpu_pm_enter(void)
109 {                                                  99 {
110         return cpu_pm_notify_robust(CPU_PM_ENT !! 100         int nr_calls;
                                                   >> 101         int ret = 0;
                                                   >> 102 
                                                   >> 103         read_lock(&cpu_pm_notifier_lock);
                                                   >> 104         ret = cpu_pm_notify(CPU_PM_ENTER, -1, &nr_calls);
                                                   >> 105         if (ret)
                                                   >> 106                 /*
                                                   >> 107                  * Inform listeners (nr_calls - 1) about failure of CPU PM
                                                   >> 108                  * PM entry who are notified earlier to prepare for it.
                                                   >> 109                  */
                                                   >> 110                 cpu_pm_notify(CPU_PM_ENTER_FAILED, nr_calls - 1, NULL);
                                                   >> 111         read_unlock(&cpu_pm_notifier_lock);
                                                   >> 112 
                                                   >> 113         return ret;
111 }                                                 114 }
112 EXPORT_SYMBOL_GPL(cpu_pm_enter);                  115 EXPORT_SYMBOL_GPL(cpu_pm_enter);
113                                                   116 
114 /**                                               117 /**
115  * cpu_pm_exit - CPU low power exit notifier      118  * cpu_pm_exit - CPU low power exit notifier
116  *                                                119  *
117  * Notifies listeners that a single CPU is exi    120  * Notifies listeners that a single CPU is exiting a low power state that may
118  * have caused some blocks in the same power d    121  * have caused some blocks in the same power domain as the cpu to reset.
119  *                                                122  *
120  * Notified drivers can include VFP co-process    123  * Notified drivers can include VFP co-processor, interrupt controller
121  * and its PM extensions, local CPU timers con    124  * and its PM extensions, local CPU timers context save/restore which
122  * shouldn't be interrupted. Hence it must be     125  * shouldn't be interrupted. Hence it must be called with interrupts disabled.
123  *                                                126  *
124  * Return conditions are same as __raw_notifie    127  * Return conditions are same as __raw_notifier_call_chain.
125  */                                               128  */
126 int cpu_pm_exit(void)                             129 int cpu_pm_exit(void)
127 {                                                 130 {
128         return cpu_pm_notify(CPU_PM_EXIT);     !! 131         int ret;
                                                   >> 132 
                                                   >> 133         read_lock(&cpu_pm_notifier_lock);
                                                   >> 134         ret = cpu_pm_notify(CPU_PM_EXIT, -1, NULL);
                                                   >> 135         read_unlock(&cpu_pm_notifier_lock);
                                                   >> 136 
                                                   >> 137         return ret;
129 }                                                 138 }
130 EXPORT_SYMBOL_GPL(cpu_pm_exit);                   139 EXPORT_SYMBOL_GPL(cpu_pm_exit);
131                                                   140 
132 /**                                               141 /**
133  * cpu_cluster_pm_enter - CPU cluster low powe    142  * cpu_cluster_pm_enter - CPU cluster low power entry notifier
134  *                                                143  *
135  * Notifies listeners that all cpus in a power    144  * Notifies listeners that all cpus in a power domain are entering a low power
136  * state that may cause some blocks in the sam    145  * state that may cause some blocks in the same power domain to reset.
137  *                                                146  *
138  * Must be called after cpu_pm_enter has been     147  * 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 cal    148  * domain, and before cpu_pm_exit has been called on any cpu in the power
140  * domain. Notified drivers can include VFP co    149  * domain. Notified drivers can include VFP co-processor, interrupt controller
141  * and its PM extensions, local CPU timers con    150  * and its PM extensions, local CPU timers context save/restore which
142  * shouldn't be interrupted. Hence it must be     151  * shouldn't be interrupted. Hence it must be called with interrupts disabled.
143  *                                                152  *
144  * Must be called with interrupts disabled.       153  * Must be called with interrupts disabled.
145  *                                                154  *
146  * Return conditions are same as __raw_notifie    155  * Return conditions are same as __raw_notifier_call_chain.
147  */                                               156  */
148 int cpu_cluster_pm_enter(void)                    157 int cpu_cluster_pm_enter(void)
149 {                                                 158 {
150         return cpu_pm_notify_robust(CPU_CLUSTE !! 159         int nr_calls;
                                                   >> 160         int ret = 0;
                                                   >> 161 
                                                   >> 162         read_lock(&cpu_pm_notifier_lock);
                                                   >> 163         ret = cpu_pm_notify(CPU_CLUSTER_PM_ENTER, -1, &nr_calls);
                                                   >> 164         if (ret)
                                                   >> 165                 /*
                                                   >> 166                  * Inform listeners (nr_calls - 1) about failure of CPU cluster
                                                   >> 167                  * PM entry who are notified earlier to prepare for it.
                                                   >> 168                  */
                                                   >> 169                 cpu_pm_notify(CPU_CLUSTER_PM_ENTER_FAILED, nr_calls - 1, NULL);
                                                   >> 170         read_unlock(&cpu_pm_notifier_lock);
                                                   >> 171 
                                                   >> 172         return ret;
151 }                                                 173 }
152 EXPORT_SYMBOL_GPL(cpu_cluster_pm_enter);          174 EXPORT_SYMBOL_GPL(cpu_cluster_pm_enter);
153                                                   175 
154 /**                                               176 /**
155  * cpu_cluster_pm_exit - CPU cluster low power    177  * cpu_cluster_pm_exit - CPU cluster low power exit notifier
156  *                                                178  *
157  * Notifies listeners that all cpus in a power    179  * Notifies listeners that all cpus in a power domain are exiting form a
158  * low power state that may have caused some b    180  * low power state that may have caused some blocks in the same power domain
159  * to reset.                                      181  * to reset.
160  *                                                182  *
161  * Must be called after cpu_cluster_pm_enter h    183  * Must be called after cpu_cluster_pm_enter has been called for the power
162  * domain, and before cpu_pm_exit has been cal    184  * domain, and before cpu_pm_exit has been called on any cpu in the power
163  * domain. Notified drivers can include VFP co    185  * domain. Notified drivers can include VFP co-processor, interrupt controller
164  * and its PM extensions, local CPU timers con    186  * and its PM extensions, local CPU timers context save/restore which
165  * shouldn't be interrupted. Hence it must be     187  * shouldn't be interrupted. Hence it must be called with interrupts disabled.
166  *                                                188  *
167  * Return conditions are same as __raw_notifie    189  * Return conditions are same as __raw_notifier_call_chain.
168  */                                               190  */
169 int cpu_cluster_pm_exit(void)                     191 int cpu_cluster_pm_exit(void)
170 {                                                 192 {
171         return cpu_pm_notify(CPU_CLUSTER_PM_EX !! 193         int ret;
                                                   >> 194 
                                                   >> 195         read_lock(&cpu_pm_notifier_lock);
                                                   >> 196         ret = cpu_pm_notify(CPU_CLUSTER_PM_EXIT, -1, NULL);
                                                   >> 197         read_unlock(&cpu_pm_notifier_lock);
                                                   >> 198 
                                                   >> 199         return ret;
172 }                                                 200 }
173 EXPORT_SYMBOL_GPL(cpu_cluster_pm_exit);           201 EXPORT_SYMBOL_GPL(cpu_cluster_pm_exit);
174                                                   202 
175 #ifdef CONFIG_PM                                  203 #ifdef CONFIG_PM
176 static int cpu_pm_suspend(void)                   204 static int cpu_pm_suspend(void)
177 {                                                 205 {
178         int ret;                                  206         int ret;
179                                                   207 
180         ret = cpu_pm_enter();                     208         ret = cpu_pm_enter();
181         if (ret)                                  209         if (ret)
182                 return ret;                       210                 return ret;
183                                                   211 
184         ret = cpu_cluster_pm_enter();             212         ret = cpu_cluster_pm_enter();
185         return ret;                               213         return ret;
186 }                                                 214 }
187                                                   215 
188 static void cpu_pm_resume(void)                   216 static void cpu_pm_resume(void)
189 {                                                 217 {
190         cpu_cluster_pm_exit();                    218         cpu_cluster_pm_exit();
191         cpu_pm_exit();                            219         cpu_pm_exit();
192 }                                                 220 }
193                                                   221 
194 static struct syscore_ops cpu_pm_syscore_ops =    222 static struct syscore_ops cpu_pm_syscore_ops = {
195         .suspend = cpu_pm_suspend,                223         .suspend = cpu_pm_suspend,
196         .resume = cpu_pm_resume,                  224         .resume = cpu_pm_resume,
197 };                                                225 };
198                                                   226 
199 static int cpu_pm_init(void)                      227 static int cpu_pm_init(void)
200 {                                                 228 {
201         register_syscore_ops(&cpu_pm_syscore_o    229         register_syscore_ops(&cpu_pm_syscore_ops);
202         return 0;                                 230         return 0;
203 }                                                 231 }
204 core_initcall(cpu_pm_init);                       232 core_initcall(cpu_pm_init);
205 #endif                                            233 #endif
206                                                   234 

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

kernel.org | git.kernel.org | LWN.net | Project Home | 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.

sflogo.php