Commit | Line | Data |
---|---|---|
85eb8c8d RW |
1 | /* |
2 | * drivers/base/power/clock_ops.c - Generic clock manipulation PM callbacks | |
3 | * | |
4 | * Copyright (c) 2011 Rafael J. Wysocki <rjw@sisk.pl>, Renesas Electronics Corp. | |
5 | * | |
6 | * This file is released under the GPLv2. | |
7 | */ | |
8 | ||
9 | #include <linux/init.h> | |
10 | #include <linux/kernel.h> | |
11 | #include <linux/io.h> | |
12 | #include <linux/pm.h> | |
13 | #include <linux/pm_runtime.h> | |
14 | #include <linux/clk.h> | |
15 | #include <linux/slab.h> | |
16 | #include <linux/err.h> | |
17 | ||
b7b95920 | 18 | #ifdef CONFIG_PM |
85eb8c8d | 19 | |
3d5c3036 | 20 | struct pm_clk_data { |
85eb8c8d | 21 | struct list_head clock_list; |
b7ab83ed | 22 | spinlock_t lock; |
85eb8c8d RW |
23 | }; |
24 | ||
25 | enum pce_status { | |
26 | PCE_STATUS_NONE = 0, | |
27 | PCE_STATUS_ACQUIRED, | |
28 | PCE_STATUS_ENABLED, | |
29 | PCE_STATUS_ERROR, | |
30 | }; | |
31 | ||
32 | struct pm_clock_entry { | |
33 | struct list_head node; | |
34 | char *con_id; | |
35 | struct clk *clk; | |
36 | enum pce_status status; | |
37 | }; | |
38 | ||
3d5c3036 | 39 | static struct pm_clk_data *__to_pcd(struct device *dev) |
85eb8c8d RW |
40 | { |
41 | return dev ? dev->power.subsys_data : NULL; | |
42 | } | |
43 | ||
44 | /** | |
3d5c3036 RW |
45 | * pm_clk_add - Start using a device clock for power management. |
46 | * @dev: Device whose clock is going to be used for power management. | |
85eb8c8d RW |
47 | * @con_id: Connection ID of the clock. |
48 | * | |
49 | * Add the clock represented by @con_id to the list of clocks used for | |
3d5c3036 | 50 | * the power management of @dev. |
85eb8c8d | 51 | */ |
3d5c3036 | 52 | int pm_clk_add(struct device *dev, const char *con_id) |
85eb8c8d | 53 | { |
3d5c3036 | 54 | struct pm_clk_data *pcd = __to_pcd(dev); |
85eb8c8d RW |
55 | struct pm_clock_entry *ce; |
56 | ||
3d5c3036 | 57 | if (!pcd) |
85eb8c8d RW |
58 | return -EINVAL; |
59 | ||
60 | ce = kzalloc(sizeof(*ce), GFP_KERNEL); | |
61 | if (!ce) { | |
62 | dev_err(dev, "Not enough memory for clock entry.\n"); | |
63 | return -ENOMEM; | |
64 | } | |
65 | ||
66 | if (con_id) { | |
67 | ce->con_id = kstrdup(con_id, GFP_KERNEL); | |
68 | if (!ce->con_id) { | |
69 | dev_err(dev, | |
70 | "Not enough memory for clock connection ID.\n"); | |
71 | kfree(ce); | |
72 | return -ENOMEM; | |
73 | } | |
74 | } | |
75 | ||
b7ab83ed | 76 | spin_lock_irq(&pcd->lock); |
3d5c3036 | 77 | list_add_tail(&ce->node, &pcd->clock_list); |
b7ab83ed | 78 | spin_unlock_irq(&pcd->lock); |
85eb8c8d RW |
79 | return 0; |
80 | } | |
81 | ||
82 | /** | |
3d5c3036 RW |
83 | * __pm_clk_remove - Destroy PM clock entry. |
84 | * @ce: PM clock entry to destroy. | |
85eb8c8d | 85 | * |
b7ab83ed RW |
86 | * This routine must be called under the spinlock protecting the PM list of |
87 | * clocks corresponding the the @ce's device. | |
85eb8c8d | 88 | */ |
3d5c3036 | 89 | static void __pm_clk_remove(struct pm_clock_entry *ce) |
85eb8c8d RW |
90 | { |
91 | if (!ce) | |
92 | return; | |
93 | ||
94 | list_del(&ce->node); | |
95 | ||
96 | if (ce->status < PCE_STATUS_ERROR) { | |
97 | if (ce->status == PCE_STATUS_ENABLED) | |
98 | clk_disable(ce->clk); | |
99 | ||
100 | if (ce->status >= PCE_STATUS_ACQUIRED) | |
101 | clk_put(ce->clk); | |
102 | } | |
103 | ||
104 | if (ce->con_id) | |
105 | kfree(ce->con_id); | |
106 | ||
107 | kfree(ce); | |
108 | } | |
109 | ||
110 | /** | |
3d5c3036 RW |
111 | * pm_clk_remove - Stop using a device clock for power management. |
112 | * @dev: Device whose clock should not be used for PM any more. | |
85eb8c8d RW |
113 | * @con_id: Connection ID of the clock. |
114 | * | |
115 | * Remove the clock represented by @con_id from the list of clocks used for | |
3d5c3036 | 116 | * the power management of @dev. |
85eb8c8d | 117 | */ |
3d5c3036 | 118 | void pm_clk_remove(struct device *dev, const char *con_id) |
85eb8c8d | 119 | { |
3d5c3036 | 120 | struct pm_clk_data *pcd = __to_pcd(dev); |
85eb8c8d RW |
121 | struct pm_clock_entry *ce; |
122 | ||
3d5c3036 | 123 | if (!pcd) |
85eb8c8d RW |
124 | return; |
125 | ||
b7ab83ed | 126 | spin_lock_irq(&pcd->lock); |
85eb8c8d | 127 | |
3d5c3036 | 128 | list_for_each_entry(ce, &pcd->clock_list, node) { |
85eb8c8d | 129 | if (!con_id && !ce->con_id) { |
3d5c3036 | 130 | __pm_clk_remove(ce); |
85eb8c8d RW |
131 | break; |
132 | } else if (!con_id || !ce->con_id) { | |
133 | continue; | |
134 | } else if (!strcmp(con_id, ce->con_id)) { | |
3d5c3036 | 135 | __pm_clk_remove(ce); |
85eb8c8d RW |
136 | break; |
137 | } | |
138 | } | |
139 | ||
b7ab83ed | 140 | spin_unlock_irq(&pcd->lock); |
85eb8c8d RW |
141 | } |
142 | ||
143 | /** | |
3d5c3036 RW |
144 | * pm_clk_init - Initialize a device's list of power management clocks. |
145 | * @dev: Device to initialize the list of PM clocks for. | |
85eb8c8d | 146 | * |
3d5c3036 | 147 | * Allocate a struct pm_clk_data object, initialize its lock member and |
85eb8c8d RW |
148 | * make the @dev's power.subsys_data field point to it. |
149 | */ | |
3d5c3036 | 150 | int pm_clk_init(struct device *dev) |
85eb8c8d | 151 | { |
3d5c3036 | 152 | struct pm_clk_data *pcd; |
85eb8c8d | 153 | |
3d5c3036 RW |
154 | pcd = kzalloc(sizeof(*pcd), GFP_KERNEL); |
155 | if (!pcd) { | |
156 | dev_err(dev, "Not enough memory for PM clock data.\n"); | |
85eb8c8d RW |
157 | return -ENOMEM; |
158 | } | |
159 | ||
3d5c3036 | 160 | INIT_LIST_HEAD(&pcd->clock_list); |
b7ab83ed | 161 | spin_lock_init(&pcd->lock); |
3d5c3036 | 162 | dev->power.subsys_data = pcd; |
85eb8c8d RW |
163 | return 0; |
164 | } | |
165 | ||
166 | /** | |
3d5c3036 RW |
167 | * pm_clk_destroy - Destroy a device's list of power management clocks. |
168 | * @dev: Device to destroy the list of PM clocks for. | |
85eb8c8d RW |
169 | * |
170 | * Clear the @dev's power.subsys_data field, remove the list of clock entries | |
3d5c3036 | 171 | * from the struct pm_clk_data object pointed to by it before and free |
85eb8c8d RW |
172 | * that object. |
173 | */ | |
3d5c3036 | 174 | void pm_clk_destroy(struct device *dev) |
85eb8c8d | 175 | { |
3d5c3036 | 176 | struct pm_clk_data *pcd = __to_pcd(dev); |
85eb8c8d RW |
177 | struct pm_clock_entry *ce, *c; |
178 | ||
3d5c3036 | 179 | if (!pcd) |
85eb8c8d RW |
180 | return; |
181 | ||
182 | dev->power.subsys_data = NULL; | |
183 | ||
b7ab83ed | 184 | spin_lock_irq(&pcd->lock); |
85eb8c8d | 185 | |
3d5c3036 RW |
186 | list_for_each_entry_safe_reverse(ce, c, &pcd->clock_list, node) |
187 | __pm_clk_remove(ce); | |
85eb8c8d | 188 | |
b7ab83ed | 189 | spin_unlock_irq(&pcd->lock); |
85eb8c8d | 190 | |
3d5c3036 | 191 | kfree(pcd); |
85eb8c8d RW |
192 | } |
193 | ||
b7b95920 RW |
194 | #endif /* CONFIG_PM */ |
195 | ||
196 | #ifdef CONFIG_PM_RUNTIME | |
197 | ||
85eb8c8d | 198 | /** |
3d5c3036 | 199 | * pm_clk_acquire - Acquire a device clock. |
85eb8c8d RW |
200 | * @dev: Device whose clock is to be acquired. |
201 | * @con_id: Connection ID of the clock. | |
202 | */ | |
3d5c3036 | 203 | static void pm_clk_acquire(struct device *dev, |
85eb8c8d RW |
204 | struct pm_clock_entry *ce) |
205 | { | |
206 | ce->clk = clk_get(dev, ce->con_id); | |
207 | if (IS_ERR(ce->clk)) { | |
208 | ce->status = PCE_STATUS_ERROR; | |
209 | } else { | |
210 | ce->status = PCE_STATUS_ACQUIRED; | |
211 | dev_dbg(dev, "Clock %s managed by runtime PM.\n", ce->con_id); | |
212 | } | |
213 | } | |
214 | ||
215 | /** | |
3d5c3036 | 216 | * pm_clk_suspend - Disable clocks in a device's PM clock list. |
85eb8c8d RW |
217 | * @dev: Device to disable the clocks for. |
218 | */ | |
3d5c3036 | 219 | int pm_clk_suspend(struct device *dev) |
85eb8c8d | 220 | { |
3d5c3036 | 221 | struct pm_clk_data *pcd = __to_pcd(dev); |
85eb8c8d | 222 | struct pm_clock_entry *ce; |
b7ab83ed | 223 | unsigned long flags; |
85eb8c8d RW |
224 | |
225 | dev_dbg(dev, "%s()\n", __func__); | |
226 | ||
3d5c3036 | 227 | if (!pcd) |
85eb8c8d RW |
228 | return 0; |
229 | ||
b7ab83ed | 230 | spin_lock_irqsave(&pcd->lock, flags); |
85eb8c8d | 231 | |
3d5c3036 | 232 | list_for_each_entry_reverse(ce, &pcd->clock_list, node) { |
85eb8c8d | 233 | if (ce->status == PCE_STATUS_NONE) |
3d5c3036 | 234 | pm_clk_acquire(dev, ce); |
85eb8c8d RW |
235 | |
236 | if (ce->status < PCE_STATUS_ERROR) { | |
237 | clk_disable(ce->clk); | |
238 | ce->status = PCE_STATUS_ACQUIRED; | |
239 | } | |
240 | } | |
241 | ||
b7ab83ed | 242 | spin_unlock_irqrestore(&pcd->lock, flags); |
85eb8c8d RW |
243 | |
244 | return 0; | |
245 | } | |
246 | ||
247 | /** | |
3d5c3036 | 248 | * pm_clk_resume - Enable clocks in a device's PM clock list. |
85eb8c8d RW |
249 | * @dev: Device to enable the clocks for. |
250 | */ | |
3d5c3036 | 251 | int pm_clk_resume(struct device *dev) |
85eb8c8d | 252 | { |
3d5c3036 | 253 | struct pm_clk_data *pcd = __to_pcd(dev); |
85eb8c8d | 254 | struct pm_clock_entry *ce; |
b7ab83ed | 255 | unsigned long flags; |
85eb8c8d RW |
256 | |
257 | dev_dbg(dev, "%s()\n", __func__); | |
258 | ||
3d5c3036 | 259 | if (!pcd) |
85eb8c8d RW |
260 | return 0; |
261 | ||
b7ab83ed | 262 | spin_lock_irqsave(&pcd->lock, flags); |
85eb8c8d | 263 | |
3d5c3036 | 264 | list_for_each_entry(ce, &pcd->clock_list, node) { |
85eb8c8d | 265 | if (ce->status == PCE_STATUS_NONE) |
3d5c3036 | 266 | pm_clk_acquire(dev, ce); |
85eb8c8d RW |
267 | |
268 | if (ce->status < PCE_STATUS_ERROR) { | |
269 | clk_enable(ce->clk); | |
270 | ce->status = PCE_STATUS_ENABLED; | |
271 | } | |
272 | } | |
273 | ||
b7ab83ed | 274 | spin_unlock_irqrestore(&pcd->lock, flags); |
85eb8c8d RW |
275 | |
276 | return 0; | |
277 | } | |
278 | ||
279 | /** | |
3d5c3036 | 280 | * pm_clk_notify - Notify routine for device addition and removal. |
85eb8c8d RW |
281 | * @nb: Notifier block object this function is a member of. |
282 | * @action: Operation being carried out by the caller. | |
283 | * @data: Device the routine is being run for. | |
284 | * | |
285 | * For this function to work, @nb must be a member of an object of type | |
286 | * struct pm_clk_notifier_block containing all of the requisite data. | |
564b905a RW |
287 | * Specifically, the pm_domain member of that object is copied to the device's |
288 | * pm_domain field and its con_ids member is used to populate the device's list | |
3d5c3036 | 289 | * of PM clocks, depending on @action. |
85eb8c8d | 290 | * |
564b905a | 291 | * If the device's pm_domain field is already populated with a value different |
85eb8c8d RW |
292 | * from the one stored in the struct pm_clk_notifier_block object, the function |
293 | * does nothing. | |
294 | */ | |
3d5c3036 | 295 | static int pm_clk_notify(struct notifier_block *nb, |
85eb8c8d RW |
296 | unsigned long action, void *data) |
297 | { | |
298 | struct pm_clk_notifier_block *clknb; | |
299 | struct device *dev = data; | |
3b3eca31 | 300 | char **con_id; |
85eb8c8d RW |
301 | int error; |
302 | ||
303 | dev_dbg(dev, "%s() %ld\n", __func__, action); | |
304 | ||
305 | clknb = container_of(nb, struct pm_clk_notifier_block, nb); | |
306 | ||
307 | switch (action) { | |
308 | case BUS_NOTIFY_ADD_DEVICE: | |
564b905a | 309 | if (dev->pm_domain) |
85eb8c8d RW |
310 | break; |
311 | ||
3d5c3036 | 312 | error = pm_clk_init(dev); |
85eb8c8d RW |
313 | if (error) |
314 | break; | |
315 | ||
564b905a | 316 | dev->pm_domain = clknb->pm_domain; |
85eb8c8d | 317 | if (clknb->con_ids[0]) { |
3b3eca31 | 318 | for (con_id = clknb->con_ids; *con_id; con_id++) |
3d5c3036 | 319 | pm_clk_add(dev, *con_id); |
85eb8c8d | 320 | } else { |
3d5c3036 | 321 | pm_clk_add(dev, NULL); |
85eb8c8d RW |
322 | } |
323 | ||
324 | break; | |
325 | case BUS_NOTIFY_DEL_DEVICE: | |
564b905a | 326 | if (dev->pm_domain != clknb->pm_domain) |
85eb8c8d RW |
327 | break; |
328 | ||
564b905a | 329 | dev->pm_domain = NULL; |
3d5c3036 | 330 | pm_clk_destroy(dev); |
85eb8c8d RW |
331 | break; |
332 | } | |
333 | ||
334 | return 0; | |
335 | } | |
336 | ||
337 | #else /* !CONFIG_PM_RUNTIME */ | |
338 | ||
b7b95920 RW |
339 | #ifdef CONFIG_PM |
340 | ||
341 | /** | |
3d5c3036 | 342 | * pm_clk_suspend - Disable clocks in a device's PM clock list. |
b7b95920 RW |
343 | * @dev: Device to disable the clocks for. |
344 | */ | |
3d5c3036 | 345 | int pm_clk_suspend(struct device *dev) |
b7b95920 | 346 | { |
3d5c3036 | 347 | struct pm_clk_data *pcd = __to_pcd(dev); |
b7b95920 | 348 | struct pm_clock_entry *ce; |
b7ab83ed | 349 | unsigned long flags; |
b7b95920 RW |
350 | |
351 | dev_dbg(dev, "%s()\n", __func__); | |
352 | ||
353 | /* If there is no driver, the clocks are already disabled. */ | |
3d5c3036 | 354 | if (!pcd || !dev->driver) |
b7b95920 RW |
355 | return 0; |
356 | ||
b7ab83ed | 357 | spin_lock_irqsave(&pcd->lock, flags); |
b7b95920 | 358 | |
3d5c3036 | 359 | list_for_each_entry_reverse(ce, &pcd->clock_list, node) |
b7b95920 RW |
360 | clk_disable(ce->clk); |
361 | ||
b7ab83ed | 362 | spin_unlock_irqrestore(&pcd->lock, flags); |
b7b95920 RW |
363 | |
364 | return 0; | |
365 | } | |
366 | ||
367 | /** | |
3d5c3036 | 368 | * pm_clk_resume - Enable clocks in a device's PM clock list. |
b7b95920 RW |
369 | * @dev: Device to enable the clocks for. |
370 | */ | |
3d5c3036 | 371 | int pm_clk_resume(struct device *dev) |
b7b95920 | 372 | { |
3d5c3036 | 373 | struct pm_clk_data *pcd = __to_pcd(dev); |
b7b95920 | 374 | struct pm_clock_entry *ce; |
b7ab83ed | 375 | unsigned long flags; |
b7b95920 RW |
376 | |
377 | dev_dbg(dev, "%s()\n", __func__); | |
378 | ||
379 | /* If there is no driver, the clocks should remain disabled. */ | |
3d5c3036 | 380 | if (!pcd || !dev->driver) |
b7b95920 RW |
381 | return 0; |
382 | ||
b7ab83ed | 383 | spin_lock_irqsave(&pcd->lock, flags); |
b7b95920 | 384 | |
3d5c3036 | 385 | list_for_each_entry(ce, &pcd->clock_list, node) |
b7b95920 RW |
386 | clk_enable(ce->clk); |
387 | ||
b7ab83ed | 388 | spin_unlock_irqrestore(&pcd->lock, flags); |
b7b95920 RW |
389 | |
390 | return 0; | |
391 | } | |
392 | ||
393 | #endif /* CONFIG_PM */ | |
394 | ||
85eb8c8d RW |
395 | /** |
396 | * enable_clock - Enable a device clock. | |
397 | * @dev: Device whose clock is to be enabled. | |
398 | * @con_id: Connection ID of the clock. | |
399 | */ | |
400 | static void enable_clock(struct device *dev, const char *con_id) | |
401 | { | |
402 | struct clk *clk; | |
403 | ||
404 | clk = clk_get(dev, con_id); | |
405 | if (!IS_ERR(clk)) { | |
406 | clk_enable(clk); | |
407 | clk_put(clk); | |
408 | dev_info(dev, "Runtime PM disabled, clock forced on.\n"); | |
409 | } | |
410 | } | |
411 | ||
412 | /** | |
413 | * disable_clock - Disable a device clock. | |
414 | * @dev: Device whose clock is to be disabled. | |
415 | * @con_id: Connection ID of the clock. | |
416 | */ | |
417 | static void disable_clock(struct device *dev, const char *con_id) | |
418 | { | |
419 | struct clk *clk; | |
420 | ||
421 | clk = clk_get(dev, con_id); | |
422 | if (!IS_ERR(clk)) { | |
423 | clk_disable(clk); | |
424 | clk_put(clk); | |
425 | dev_info(dev, "Runtime PM disabled, clock forced off.\n"); | |
426 | } | |
427 | } | |
428 | ||
429 | /** | |
3d5c3036 | 430 | * pm_clk_notify - Notify routine for device addition and removal. |
85eb8c8d RW |
431 | * @nb: Notifier block object this function is a member of. |
432 | * @action: Operation being carried out by the caller. | |
433 | * @data: Device the routine is being run for. | |
434 | * | |
435 | * For this function to work, @nb must be a member of an object of type | |
436 | * struct pm_clk_notifier_block containing all of the requisite data. | |
437 | * Specifically, the con_ids member of that object is used to enable or disable | |
438 | * the device's clocks, depending on @action. | |
439 | */ | |
3d5c3036 | 440 | static int pm_clk_notify(struct notifier_block *nb, |
85eb8c8d RW |
441 | unsigned long action, void *data) |
442 | { | |
443 | struct pm_clk_notifier_block *clknb; | |
444 | struct device *dev = data; | |
3b3eca31 | 445 | char **con_id; |
85eb8c8d RW |
446 | |
447 | dev_dbg(dev, "%s() %ld\n", __func__, action); | |
448 | ||
449 | clknb = container_of(nb, struct pm_clk_notifier_block, nb); | |
450 | ||
451 | switch (action) { | |
4d1518f5 | 452 | case BUS_NOTIFY_BIND_DRIVER: |
85eb8c8d | 453 | if (clknb->con_ids[0]) { |
3b3eca31 RW |
454 | for (con_id = clknb->con_ids; *con_id; con_id++) |
455 | enable_clock(dev, *con_id); | |
85eb8c8d RW |
456 | } else { |
457 | enable_clock(dev, NULL); | |
458 | } | |
459 | break; | |
4d1518f5 | 460 | case BUS_NOTIFY_UNBOUND_DRIVER: |
85eb8c8d | 461 | if (clknb->con_ids[0]) { |
3b3eca31 RW |
462 | for (con_id = clknb->con_ids; *con_id; con_id++) |
463 | disable_clock(dev, *con_id); | |
85eb8c8d RW |
464 | } else { |
465 | disable_clock(dev, NULL); | |
466 | } | |
467 | break; | |
468 | } | |
469 | ||
470 | return 0; | |
471 | } | |
472 | ||
473 | #endif /* !CONFIG_PM_RUNTIME */ | |
474 | ||
475 | /** | |
3d5c3036 | 476 | * pm_clk_add_notifier - Add bus type notifier for power management clocks. |
85eb8c8d RW |
477 | * @bus: Bus type to add the notifier to. |
478 | * @clknb: Notifier to be added to the given bus type. | |
479 | * | |
480 | * The nb member of @clknb is not expected to be initialized and its | |
3d5c3036 | 481 | * notifier_call member will be replaced with pm_clk_notify(). However, |
85eb8c8d RW |
482 | * the remaining members of @clknb should be populated prior to calling this |
483 | * routine. | |
484 | */ | |
3d5c3036 | 485 | void pm_clk_add_notifier(struct bus_type *bus, |
85eb8c8d RW |
486 | struct pm_clk_notifier_block *clknb) |
487 | { | |
488 | if (!bus || !clknb) | |
489 | return; | |
490 | ||
3d5c3036 | 491 | clknb->nb.notifier_call = pm_clk_notify; |
85eb8c8d RW |
492 | bus_register_notifier(bus, &clknb->nb); |
493 | } |