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