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