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 | ||
85eb8c8d | 9 | #include <linux/kernel.h> |
51990e82 | 10 | #include <linux/device.h> |
85eb8c8d RW |
11 | #include <linux/io.h> |
12 | #include <linux/pm.h> | |
b5e8d269 | 13 | #include <linux/pm_clock.h> |
85eb8c8d | 14 | #include <linux/clk.h> |
245bd6f6 | 15 | #include <linux/clkdev.h> |
85eb8c8d RW |
16 | #include <linux/slab.h> |
17 | #include <linux/err.h> | |
989561de | 18 | #include <linux/pm_domain.h> |
75f50400 | 19 | #include <linux/pm_runtime.h> |
85eb8c8d | 20 | |
a6175616 | 21 | #ifdef CONFIG_PM_CLK |
85eb8c8d | 22 | |
85eb8c8d RW |
23 | enum pce_status { |
24 | PCE_STATUS_NONE = 0, | |
25 | PCE_STATUS_ACQUIRED, | |
26 | PCE_STATUS_ENABLED, | |
27 | PCE_STATUS_ERROR, | |
28 | }; | |
29 | ||
30 | struct pm_clock_entry { | |
31 | struct list_head node; | |
32 | char *con_id; | |
33 | struct clk *clk; | |
34 | enum pce_status status; | |
35 | }; | |
36 | ||
5cda3fbb BD |
37 | /** |
38 | * pm_clk_enable - Enable a clock, reporting any errors | |
39 | * @dev: The device for the given clock | |
471f7707 | 40 | * @ce: PM clock entry corresponding to the clock. |
5cda3fbb | 41 | */ |
f4745a92 | 42 | static inline void __pm_clk_enable(struct device *dev, struct pm_clock_entry *ce) |
5cda3fbb | 43 | { |
471f7707 SG |
44 | int ret; |
45 | ||
46 | if (ce->status < PCE_STATUS_ERROR) { | |
47 | ret = clk_enable(ce->clk); | |
48 | if (!ret) | |
49 | ce->status = PCE_STATUS_ENABLED; | |
50 | else | |
51 | dev_err(dev, "%s: failed to enable clk %p, error %d\n", | |
52 | __func__, ce->clk, ret); | |
53 | } | |
5cda3fbb BD |
54 | } |
55 | ||
e8b364b8 RW |
56 | /** |
57 | * pm_clk_acquire - Acquire a device clock. | |
58 | * @dev: Device whose clock is to be acquired. | |
59 | * @ce: PM clock entry corresponding to the clock. | |
60 | */ | |
61 | static void pm_clk_acquire(struct device *dev, struct pm_clock_entry *ce) | |
62 | { | |
245bd6f6 GU |
63 | if (!ce->clk) |
64 | ce->clk = clk_get(dev, ce->con_id); | |
e8b364b8 RW |
65 | if (IS_ERR(ce->clk)) { |
66 | ce->status = PCE_STATUS_ERROR; | |
67 | } else { | |
8a6720ec | 68 | clk_prepare(ce->clk); |
e8b364b8 | 69 | ce->status = PCE_STATUS_ACQUIRED; |
f17f4adf GU |
70 | dev_dbg(dev, "Clock %pC con_id %s managed by runtime PM.\n", |
71 | ce->clk, ce->con_id); | |
e8b364b8 RW |
72 | } |
73 | } | |
74 | ||
245bd6f6 GU |
75 | static int __pm_clk_add(struct device *dev, const char *con_id, |
76 | struct clk *clk) | |
85eb8c8d | 77 | { |
5c095a0e | 78 | struct pm_subsys_data *psd = dev_to_psd(dev); |
85eb8c8d RW |
79 | struct pm_clock_entry *ce; |
80 | ||
5c095a0e | 81 | if (!psd) |
85eb8c8d RW |
82 | return -EINVAL; |
83 | ||
84 | ce = kzalloc(sizeof(*ce), GFP_KERNEL); | |
59d84ca8 | 85 | if (!ce) |
85eb8c8d | 86 | return -ENOMEM; |
85eb8c8d RW |
87 | |
88 | if (con_id) { | |
89 | ce->con_id = kstrdup(con_id, GFP_KERNEL); | |
90 | if (!ce->con_id) { | |
91 | dev_err(dev, | |
92 | "Not enough memory for clock connection ID.\n"); | |
93 | kfree(ce); | |
94 | return -ENOMEM; | |
95 | } | |
245bd6f6 | 96 | } else { |
772b0508 | 97 | if (IS_ERR(clk)) { |
245bd6f6 GU |
98 | kfree(ce); |
99 | return -ENOENT; | |
100 | } | |
101 | ce->clk = clk; | |
85eb8c8d RW |
102 | } |
103 | ||
e8b364b8 RW |
104 | pm_clk_acquire(dev, ce); |
105 | ||
5c095a0e RW |
106 | spin_lock_irq(&psd->lock); |
107 | list_add_tail(&ce->node, &psd->clock_list); | |
108 | spin_unlock_irq(&psd->lock); | |
85eb8c8d RW |
109 | return 0; |
110 | } | |
111 | ||
245bd6f6 GU |
112 | /** |
113 | * pm_clk_add - Start using a device clock for power management. | |
114 | * @dev: Device whose clock is going to be used for power management. | |
115 | * @con_id: Connection ID of the clock. | |
116 | * | |
117 | * Add the clock represented by @con_id to the list of clocks used for | |
118 | * the power management of @dev. | |
119 | */ | |
120 | int pm_clk_add(struct device *dev, const char *con_id) | |
121 | { | |
122 | return __pm_clk_add(dev, con_id, NULL); | |
123 | } | |
29b968b2 | 124 | EXPORT_SYMBOL_GPL(pm_clk_add); |
245bd6f6 GU |
125 | |
126 | /** | |
127 | * pm_clk_add_clk - Start using a device clock for power management. | |
128 | * @dev: Device whose clock is going to be used for power management. | |
129 | * @clk: Clock pointer | |
130 | * | |
131 | * Add the clock to the list of clocks used for the power management of @dev. | |
772b0508 SB |
132 | * The power-management code will take control of the clock reference, so |
133 | * callers should not call clk_put() on @clk after this function sucessfully | |
134 | * returned. | |
245bd6f6 GU |
135 | */ |
136 | int pm_clk_add_clk(struct device *dev, struct clk *clk) | |
137 | { | |
138 | return __pm_clk_add(dev, NULL, clk); | |
139 | } | |
29b968b2 | 140 | EXPORT_SYMBOL_GPL(pm_clk_add_clk); |
245bd6f6 | 141 | |
02113ba9 | 142 | |
498b5fdd JH |
143 | /** |
144 | * of_pm_clk_add_clk - Start using a device clock for power management. | |
145 | * @dev: Device whose clock is going to be used for power management. | |
146 | * @name: Name of clock that is going to be used for power management. | |
147 | * | |
148 | * Add the clock described in the 'clocks' device-tree node that matches | |
149 | * with the 'name' provided, to the list of clocks used for the power | |
150 | * management of @dev. On success, returns 0. Returns a negative error | |
151 | * code if the clock is not found or cannot be added. | |
152 | */ | |
153 | int of_pm_clk_add_clk(struct device *dev, const char *name) | |
154 | { | |
155 | struct clk *clk; | |
156 | int ret; | |
157 | ||
158 | if (!dev || !dev->of_node || !name) | |
159 | return -EINVAL; | |
160 | ||
161 | clk = of_clk_get_by_name(dev->of_node, name); | |
162 | if (IS_ERR(clk)) | |
163 | return PTR_ERR(clk); | |
164 | ||
165 | ret = pm_clk_add_clk(dev, clk); | |
166 | if (ret) { | |
167 | clk_put(clk); | |
168 | return ret; | |
169 | } | |
170 | ||
171 | return 0; | |
172 | } | |
173 | EXPORT_SYMBOL_GPL(of_pm_clk_add_clk); | |
174 | ||
02113ba9 JH |
175 | /** |
176 | * of_pm_clk_add_clks - Start using device clock(s) for power management. | |
177 | * @dev: Device whose clock(s) is going to be used for power management. | |
178 | * | |
179 | * Add a series of clocks described in the 'clocks' device-tree node for | |
180 | * a device to the list of clocks used for the power management of @dev. | |
181 | * On success, returns the number of clocks added. Returns a negative | |
182 | * error code if there are no clocks in the device node for the device | |
183 | * or if adding a clock fails. | |
184 | */ | |
185 | int of_pm_clk_add_clks(struct device *dev) | |
186 | { | |
187 | struct clk **clks; | |
5e2e2f9f | 188 | int i, count; |
02113ba9 JH |
189 | int ret; |
190 | ||
191 | if (!dev || !dev->of_node) | |
192 | return -EINVAL; | |
193 | ||
194 | count = of_count_phandle_with_args(dev->of_node, "clocks", | |
195 | "#clock-cells"); | |
0b26985a | 196 | if (count <= 0) |
02113ba9 JH |
197 | return -ENODEV; |
198 | ||
199 | clks = kcalloc(count, sizeof(*clks), GFP_KERNEL); | |
200 | if (!clks) | |
201 | return -ENOMEM; | |
202 | ||
203 | for (i = 0; i < count; i++) { | |
204 | clks[i] = of_clk_get(dev->of_node, i); | |
205 | if (IS_ERR(clks[i])) { | |
206 | ret = PTR_ERR(clks[i]); | |
207 | goto error; | |
208 | } | |
209 | ||
210 | ret = pm_clk_add_clk(dev, clks[i]); | |
211 | if (ret) { | |
212 | clk_put(clks[i]); | |
213 | goto error; | |
214 | } | |
215 | } | |
216 | ||
217 | kfree(clks); | |
218 | ||
219 | return i; | |
220 | ||
221 | error: | |
222 | while (i--) | |
223 | pm_clk_remove_clk(dev, clks[i]); | |
224 | ||
225 | kfree(clks); | |
226 | ||
227 | return ret; | |
228 | } | |
29b968b2 | 229 | EXPORT_SYMBOL_GPL(of_pm_clk_add_clks); |
02113ba9 | 230 | |
85eb8c8d | 231 | /** |
3d5c3036 RW |
232 | * __pm_clk_remove - Destroy PM clock entry. |
233 | * @ce: PM clock entry to destroy. | |
85eb8c8d | 234 | */ |
3d5c3036 | 235 | static void __pm_clk_remove(struct pm_clock_entry *ce) |
85eb8c8d RW |
236 | { |
237 | if (!ce) | |
238 | return; | |
239 | ||
85eb8c8d RW |
240 | if (ce->status < PCE_STATUS_ERROR) { |
241 | if (ce->status == PCE_STATUS_ENABLED) | |
8a6720ec | 242 | clk_disable(ce->clk); |
85eb8c8d | 243 | |
8a6720ec BD |
244 | if (ce->status >= PCE_STATUS_ACQUIRED) { |
245 | clk_unprepare(ce->clk); | |
85eb8c8d | 246 | clk_put(ce->clk); |
8a6720ec | 247 | } |
85eb8c8d RW |
248 | } |
249 | ||
0ab1e79b | 250 | kfree(ce->con_id); |
85eb8c8d RW |
251 | kfree(ce); |
252 | } | |
253 | ||
254 | /** | |
3d5c3036 RW |
255 | * pm_clk_remove - Stop using a device clock for power management. |
256 | * @dev: Device whose clock should not be used for PM any more. | |
85eb8c8d RW |
257 | * @con_id: Connection ID of the clock. |
258 | * | |
259 | * Remove the clock represented by @con_id from the list of clocks used for | |
3d5c3036 | 260 | * the power management of @dev. |
85eb8c8d | 261 | */ |
3d5c3036 | 262 | void pm_clk_remove(struct device *dev, const char *con_id) |
85eb8c8d | 263 | { |
5c095a0e | 264 | struct pm_subsys_data *psd = dev_to_psd(dev); |
85eb8c8d RW |
265 | struct pm_clock_entry *ce; |
266 | ||
5c095a0e | 267 | if (!psd) |
85eb8c8d RW |
268 | return; |
269 | ||
5c095a0e | 270 | spin_lock_irq(&psd->lock); |
85eb8c8d | 271 | |
5c095a0e | 272 | list_for_each_entry(ce, &psd->clock_list, node) { |
e8b364b8 RW |
273 | if (!con_id && !ce->con_id) |
274 | goto remove; | |
275 | else if (!con_id || !ce->con_id) | |
85eb8c8d | 276 | continue; |
e8b364b8 RW |
277 | else if (!strcmp(con_id, ce->con_id)) |
278 | goto remove; | |
85eb8c8d RW |
279 | } |
280 | ||
5c095a0e | 281 | spin_unlock_irq(&psd->lock); |
e8b364b8 RW |
282 | return; |
283 | ||
284 | remove: | |
285 | list_del(&ce->node); | |
0d41da2e | 286 | spin_unlock_irq(&psd->lock); |
e8b364b8 RW |
287 | |
288 | __pm_clk_remove(ce); | |
85eb8c8d | 289 | } |
29b968b2 | 290 | EXPORT_SYMBOL_GPL(pm_clk_remove); |
85eb8c8d | 291 | |
02113ba9 JH |
292 | /** |
293 | * pm_clk_remove_clk - Stop using a device clock for power management. | |
294 | * @dev: Device whose clock should not be used for PM any more. | |
295 | * @clk: Clock pointer | |
296 | * | |
297 | * Remove the clock pointed to by @clk from the list of clocks used for | |
298 | * the power management of @dev. | |
299 | */ | |
300 | void pm_clk_remove_clk(struct device *dev, struct clk *clk) | |
301 | { | |
302 | struct pm_subsys_data *psd = dev_to_psd(dev); | |
303 | struct pm_clock_entry *ce; | |
304 | ||
305 | if (!psd || !clk) | |
306 | return; | |
307 | ||
308 | spin_lock_irq(&psd->lock); | |
309 | ||
310 | list_for_each_entry(ce, &psd->clock_list, node) { | |
311 | if (clk == ce->clk) | |
312 | goto remove; | |
313 | } | |
314 | ||
315 | spin_unlock_irq(&psd->lock); | |
316 | return; | |
317 | ||
318 | remove: | |
319 | list_del(&ce->node); | |
320 | spin_unlock_irq(&psd->lock); | |
321 | ||
322 | __pm_clk_remove(ce); | |
323 | } | |
29b968b2 | 324 | EXPORT_SYMBOL_GPL(pm_clk_remove_clk); |
02113ba9 | 325 | |
85eb8c8d | 326 | /** |
3d5c3036 RW |
327 | * pm_clk_init - Initialize a device's list of power management clocks. |
328 | * @dev: Device to initialize the list of PM clocks for. | |
85eb8c8d | 329 | * |
5c095a0e RW |
330 | * Initialize the lock and clock_list members of the device's pm_subsys_data |
331 | * object. | |
85eb8c8d | 332 | */ |
5c095a0e | 333 | void pm_clk_init(struct device *dev) |
85eb8c8d | 334 | { |
5c095a0e | 335 | struct pm_subsys_data *psd = dev_to_psd(dev); |
ef27bed1 RW |
336 | if (psd) |
337 | INIT_LIST_HEAD(&psd->clock_list); | |
5c095a0e | 338 | } |
29b968b2 | 339 | EXPORT_SYMBOL_GPL(pm_clk_init); |
5c095a0e RW |
340 | |
341 | /** | |
342 | * pm_clk_create - Create and initialize a device's list of PM clocks. | |
343 | * @dev: Device to create and initialize the list of PM clocks for. | |
344 | * | |
345 | * Allocate a struct pm_subsys_data object, initialize its lock and clock_list | |
346 | * members and make the @dev's power.subsys_data field point to it. | |
347 | */ | |
348 | int pm_clk_create(struct device *dev) | |
349 | { | |
77254950 | 350 | return dev_pm_get_subsys_data(dev); |
85eb8c8d | 351 | } |
29b968b2 | 352 | EXPORT_SYMBOL_GPL(pm_clk_create); |
85eb8c8d RW |
353 | |
354 | /** | |
3d5c3036 RW |
355 | * pm_clk_destroy - Destroy a device's list of power management clocks. |
356 | * @dev: Device to destroy the list of PM clocks for. | |
85eb8c8d RW |
357 | * |
358 | * Clear the @dev's power.subsys_data field, remove the list of clock entries | |
5c095a0e | 359 | * from the struct pm_subsys_data object pointed to by it before and free |
85eb8c8d RW |
360 | * that object. |
361 | */ | |
3d5c3036 | 362 | void pm_clk_destroy(struct device *dev) |
85eb8c8d | 363 | { |
5c095a0e | 364 | struct pm_subsys_data *psd = dev_to_psd(dev); |
85eb8c8d | 365 | struct pm_clock_entry *ce, *c; |
e8b364b8 | 366 | struct list_head list; |
85eb8c8d | 367 | |
5c095a0e | 368 | if (!psd) |
85eb8c8d RW |
369 | return; |
370 | ||
e8b364b8 | 371 | INIT_LIST_HEAD(&list); |
85eb8c8d | 372 | |
5c095a0e | 373 | spin_lock_irq(&psd->lock); |
85eb8c8d | 374 | |
5c095a0e | 375 | list_for_each_entry_safe_reverse(ce, c, &psd->clock_list, node) |
e8b364b8 | 376 | list_move(&ce->node, &list); |
85eb8c8d | 377 | |
5c095a0e | 378 | spin_unlock_irq(&psd->lock); |
85eb8c8d | 379 | |
ef27bed1 | 380 | dev_pm_put_subsys_data(dev); |
e8b364b8 RW |
381 | |
382 | list_for_each_entry_safe_reverse(ce, c, &list, node) { | |
383 | list_del(&ce->node); | |
384 | __pm_clk_remove(ce); | |
385 | } | |
85eb8c8d | 386 | } |
29b968b2 | 387 | EXPORT_SYMBOL_GPL(pm_clk_destroy); |
85eb8c8d | 388 | |
85eb8c8d | 389 | /** |
3d5c3036 | 390 | * pm_clk_suspend - Disable clocks in a device's PM clock list. |
85eb8c8d RW |
391 | * @dev: Device to disable the clocks for. |
392 | */ | |
3d5c3036 | 393 | int pm_clk_suspend(struct device *dev) |
85eb8c8d | 394 | { |
5c095a0e | 395 | struct pm_subsys_data *psd = dev_to_psd(dev); |
85eb8c8d | 396 | struct pm_clock_entry *ce; |
b7ab83ed | 397 | unsigned long flags; |
85eb8c8d RW |
398 | |
399 | dev_dbg(dev, "%s()\n", __func__); | |
400 | ||
5c095a0e | 401 | if (!psd) |
85eb8c8d RW |
402 | return 0; |
403 | ||
5c095a0e | 404 | spin_lock_irqsave(&psd->lock, flags); |
85eb8c8d | 405 | |
5c095a0e | 406 | list_for_each_entry_reverse(ce, &psd->clock_list, node) { |
85eb8c8d | 407 | if (ce->status < PCE_STATUS_ERROR) { |
24050956 MD |
408 | if (ce->status == PCE_STATUS_ENABLED) |
409 | clk_disable(ce->clk); | |
85eb8c8d RW |
410 | ce->status = PCE_STATUS_ACQUIRED; |
411 | } | |
412 | } | |
413 | ||
5c095a0e | 414 | spin_unlock_irqrestore(&psd->lock, flags); |
85eb8c8d RW |
415 | |
416 | return 0; | |
417 | } | |
29b968b2 | 418 | EXPORT_SYMBOL_GPL(pm_clk_suspend); |
85eb8c8d RW |
419 | |
420 | /** | |
3d5c3036 | 421 | * pm_clk_resume - Enable clocks in a device's PM clock list. |
85eb8c8d RW |
422 | * @dev: Device to enable the clocks for. |
423 | */ | |
3d5c3036 | 424 | int pm_clk_resume(struct device *dev) |
85eb8c8d | 425 | { |
5c095a0e | 426 | struct pm_subsys_data *psd = dev_to_psd(dev); |
85eb8c8d | 427 | struct pm_clock_entry *ce; |
b7ab83ed | 428 | unsigned long flags; |
85eb8c8d RW |
429 | |
430 | dev_dbg(dev, "%s()\n", __func__); | |
431 | ||
5c095a0e | 432 | if (!psd) |
85eb8c8d RW |
433 | return 0; |
434 | ||
5c095a0e | 435 | spin_lock_irqsave(&psd->lock, flags); |
85eb8c8d | 436 | |
471f7707 SG |
437 | list_for_each_entry(ce, &psd->clock_list, node) |
438 | __pm_clk_enable(dev, ce); | |
85eb8c8d | 439 | |
5c095a0e | 440 | spin_unlock_irqrestore(&psd->lock, flags); |
85eb8c8d RW |
441 | |
442 | return 0; | |
443 | } | |
29b968b2 | 444 | EXPORT_SYMBOL_GPL(pm_clk_resume); |
85eb8c8d RW |
445 | |
446 | /** | |
3d5c3036 | 447 | * pm_clk_notify - Notify routine for device addition and removal. |
85eb8c8d RW |
448 | * @nb: Notifier block object this function is a member of. |
449 | * @action: Operation being carried out by the caller. | |
450 | * @data: Device the routine is being run for. | |
451 | * | |
452 | * For this function to work, @nb must be a member of an object of type | |
453 | * struct pm_clk_notifier_block containing all of the requisite data. | |
564b905a RW |
454 | * Specifically, the pm_domain member of that object is copied to the device's |
455 | * pm_domain field and its con_ids member is used to populate the device's list | |
3d5c3036 | 456 | * of PM clocks, depending on @action. |
85eb8c8d | 457 | * |
564b905a | 458 | * If the device's pm_domain field is already populated with a value different |
85eb8c8d RW |
459 | * from the one stored in the struct pm_clk_notifier_block object, the function |
460 | * does nothing. | |
461 | */ | |
3d5c3036 | 462 | static int pm_clk_notify(struct notifier_block *nb, |
85eb8c8d RW |
463 | unsigned long action, void *data) |
464 | { | |
465 | struct pm_clk_notifier_block *clknb; | |
466 | struct device *dev = data; | |
3b3eca31 | 467 | char **con_id; |
85eb8c8d RW |
468 | int error; |
469 | ||
470 | dev_dbg(dev, "%s() %ld\n", __func__, action); | |
471 | ||
472 | clknb = container_of(nb, struct pm_clk_notifier_block, nb); | |
473 | ||
474 | switch (action) { | |
475 | case BUS_NOTIFY_ADD_DEVICE: | |
564b905a | 476 | if (dev->pm_domain) |
85eb8c8d RW |
477 | break; |
478 | ||
5c095a0e | 479 | error = pm_clk_create(dev); |
85eb8c8d RW |
480 | if (error) |
481 | break; | |
482 | ||
989561de | 483 | dev_pm_domain_set(dev, clknb->pm_domain); |
85eb8c8d | 484 | if (clknb->con_ids[0]) { |
3b3eca31 | 485 | for (con_id = clknb->con_ids; *con_id; con_id++) |
3d5c3036 | 486 | pm_clk_add(dev, *con_id); |
85eb8c8d | 487 | } else { |
3d5c3036 | 488 | pm_clk_add(dev, NULL); |
85eb8c8d RW |
489 | } |
490 | ||
491 | break; | |
492 | case BUS_NOTIFY_DEL_DEVICE: | |
564b905a | 493 | if (dev->pm_domain != clknb->pm_domain) |
85eb8c8d RW |
494 | break; |
495 | ||
989561de | 496 | dev_pm_domain_set(dev, NULL); |
3d5c3036 | 497 | pm_clk_destroy(dev); |
85eb8c8d RW |
498 | break; |
499 | } | |
500 | ||
501 | return 0; | |
502 | } | |
503 | ||
75f50400 RN |
504 | int pm_clk_runtime_suspend(struct device *dev) |
505 | { | |
506 | int ret; | |
507 | ||
508 | dev_dbg(dev, "%s\n", __func__); | |
509 | ||
510 | ret = pm_generic_runtime_suspend(dev); | |
511 | if (ret) { | |
512 | dev_err(dev, "failed to suspend device\n"); | |
513 | return ret; | |
514 | } | |
515 | ||
516 | ret = pm_clk_suspend(dev); | |
517 | if (ret) { | |
518 | dev_err(dev, "failed to suspend clock\n"); | |
519 | pm_generic_runtime_resume(dev); | |
520 | return ret; | |
521 | } | |
522 | ||
523 | return 0; | |
524 | } | |
29b968b2 | 525 | EXPORT_SYMBOL_GPL(pm_clk_runtime_suspend); |
75f50400 RN |
526 | |
527 | int pm_clk_runtime_resume(struct device *dev) | |
528 | { | |
529 | int ret; | |
530 | ||
531 | dev_dbg(dev, "%s\n", __func__); | |
532 | ||
533 | ret = pm_clk_resume(dev); | |
534 | if (ret) { | |
535 | dev_err(dev, "failed to resume clock\n"); | |
536 | return ret; | |
537 | } | |
538 | ||
539 | return pm_generic_runtime_resume(dev); | |
540 | } | |
29b968b2 | 541 | EXPORT_SYMBOL_GPL(pm_clk_runtime_resume); |
75f50400 | 542 | |
a6175616 | 543 | #else /* !CONFIG_PM_CLK */ |
b7b95920 | 544 | |
85eb8c8d RW |
545 | /** |
546 | * enable_clock - Enable a device clock. | |
547 | * @dev: Device whose clock is to be enabled. | |
548 | * @con_id: Connection ID of the clock. | |
549 | */ | |
550 | static void enable_clock(struct device *dev, const char *con_id) | |
551 | { | |
552 | struct clk *clk; | |
553 | ||
554 | clk = clk_get(dev, con_id); | |
555 | if (!IS_ERR(clk)) { | |
c122f27e | 556 | clk_prepare_enable(clk); |
85eb8c8d RW |
557 | clk_put(clk); |
558 | dev_info(dev, "Runtime PM disabled, clock forced on.\n"); | |
559 | } | |
560 | } | |
561 | ||
562 | /** | |
563 | * disable_clock - Disable a device clock. | |
564 | * @dev: Device whose clock is to be disabled. | |
565 | * @con_id: Connection ID of the clock. | |
566 | */ | |
567 | static void disable_clock(struct device *dev, const char *con_id) | |
568 | { | |
569 | struct clk *clk; | |
570 | ||
571 | clk = clk_get(dev, con_id); | |
572 | if (!IS_ERR(clk)) { | |
c122f27e | 573 | clk_disable_unprepare(clk); |
85eb8c8d RW |
574 | clk_put(clk); |
575 | dev_info(dev, "Runtime PM disabled, clock forced off.\n"); | |
576 | } | |
577 | } | |
578 | ||
579 | /** | |
3d5c3036 | 580 | * pm_clk_notify - Notify routine for device addition and removal. |
85eb8c8d RW |
581 | * @nb: Notifier block object this function is a member of. |
582 | * @action: Operation being carried out by the caller. | |
583 | * @data: Device the routine is being run for. | |
584 | * | |
585 | * For this function to work, @nb must be a member of an object of type | |
586 | * struct pm_clk_notifier_block containing all of the requisite data. | |
587 | * Specifically, the con_ids member of that object is used to enable or disable | |
588 | * the device's clocks, depending on @action. | |
589 | */ | |
3d5c3036 | 590 | static int pm_clk_notify(struct notifier_block *nb, |
85eb8c8d RW |
591 | unsigned long action, void *data) |
592 | { | |
593 | struct pm_clk_notifier_block *clknb; | |
594 | struct device *dev = data; | |
3b3eca31 | 595 | char **con_id; |
85eb8c8d RW |
596 | |
597 | dev_dbg(dev, "%s() %ld\n", __func__, action); | |
598 | ||
599 | clknb = container_of(nb, struct pm_clk_notifier_block, nb); | |
600 | ||
601 | switch (action) { | |
4d1518f5 | 602 | case BUS_NOTIFY_BIND_DRIVER: |
85eb8c8d | 603 | if (clknb->con_ids[0]) { |
3b3eca31 RW |
604 | for (con_id = clknb->con_ids; *con_id; con_id++) |
605 | enable_clock(dev, *con_id); | |
85eb8c8d RW |
606 | } else { |
607 | enable_clock(dev, NULL); | |
608 | } | |
609 | break; | |
d35818a9 | 610 | case BUS_NOTIFY_DRIVER_NOT_BOUND: |
4d1518f5 | 611 | case BUS_NOTIFY_UNBOUND_DRIVER: |
85eb8c8d | 612 | if (clknb->con_ids[0]) { |
3b3eca31 RW |
613 | for (con_id = clknb->con_ids; *con_id; con_id++) |
614 | disable_clock(dev, *con_id); | |
85eb8c8d RW |
615 | } else { |
616 | disable_clock(dev, NULL); | |
617 | } | |
618 | break; | |
619 | } | |
620 | ||
621 | return 0; | |
622 | } | |
623 | ||
a6175616 | 624 | #endif /* !CONFIG_PM_CLK */ |
85eb8c8d RW |
625 | |
626 | /** | |
3d5c3036 | 627 | * pm_clk_add_notifier - Add bus type notifier for power management clocks. |
85eb8c8d RW |
628 | * @bus: Bus type to add the notifier to. |
629 | * @clknb: Notifier to be added to the given bus type. | |
630 | * | |
631 | * The nb member of @clknb is not expected to be initialized and its | |
3d5c3036 | 632 | * notifier_call member will be replaced with pm_clk_notify(). However, |
85eb8c8d RW |
633 | * the remaining members of @clknb should be populated prior to calling this |
634 | * routine. | |
635 | */ | |
3d5c3036 | 636 | void pm_clk_add_notifier(struct bus_type *bus, |
85eb8c8d RW |
637 | struct pm_clk_notifier_block *clknb) |
638 | { | |
639 | if (!bus || !clknb) | |
640 | return; | |
641 | ||
3d5c3036 | 642 | clknb->nb.notifier_call = pm_clk_notify; |
85eb8c8d RW |
643 | bus_register_notifier(bus, &clknb->nb); |
644 | } | |
29b968b2 | 645 | EXPORT_SYMBOL_GPL(pm_clk_add_notifier); |