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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.