PM / Domains: Add OF support
[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_clock.h>
14 #include <linux/clk.h>
15 #include <linux/slab.h>
16 #include <linux/err.h>
17
18 #ifdef CONFIG_PM
19
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
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
50 /**
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.
53  * @con_id: Connection ID of the clock.
54  *
55  * Add the clock represented by @con_id to the list of clocks used for
56  * the power management of @dev.
57  */
58 int pm_clk_add(struct device *dev, const char *con_id)
59 {
60         struct pm_subsys_data *psd = dev_to_psd(dev);
61         struct pm_clock_entry *ce;
62
63         if (!psd)
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
82         pm_clk_acquire(dev, ce);
83
84         spin_lock_irq(&psd->lock);
85         list_add_tail(&ce->node, &psd->clock_list);
86         spin_unlock_irq(&psd->lock);
87         return 0;
88 }
89
90 /**
91  * __pm_clk_remove - Destroy PM clock entry.
92  * @ce: PM clock entry to destroy.
93  */
94 static void __pm_clk_remove(struct pm_clock_entry *ce)
95 {
96         if (!ce)
97                 return;
98
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
107         kfree(ce->con_id);
108         kfree(ce);
109 }
110
111 /**
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.
114  * @con_id: Connection ID of the clock.
115  *
116  * Remove the clock represented by @con_id from the list of clocks used for
117  * the power management of @dev.
118  */
119 void pm_clk_remove(struct device *dev, const char *con_id)
120 {
121         struct pm_subsys_data *psd = dev_to_psd(dev);
122         struct pm_clock_entry *ce;
123
124         if (!psd)
125                 return;
126
127         spin_lock_irq(&psd->lock);
128
129         list_for_each_entry(ce, &psd->clock_list, node) {
130                 if (!con_id && !ce->con_id)
131                         goto remove;
132                 else if (!con_id || !ce->con_id)
133                         continue;
134                 else if (!strcmp(con_id, ce->con_id))
135                         goto remove;
136         }
137
138         spin_unlock_irq(&psd->lock);
139         return;
140
141  remove:
142         list_del(&ce->node);
143         spin_unlock_irq(&psd->lock);
144
145         __pm_clk_remove(ce);
146 }
147
148 /**
149  * pm_clk_init - Initialize a device's list of power management clocks.
150  * @dev: Device to initialize the list of PM clocks for.
151  *
152  * Initialize the lock and clock_list members of the device's pm_subsys_data
153  * object.
154  */
155 void pm_clk_init(struct device *dev)
156 {
157         struct pm_subsys_data *psd = dev_to_psd(dev);
158         if (psd)
159                 INIT_LIST_HEAD(&psd->clock_list);
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 {
171         int ret = dev_pm_get_subsys_data(dev);
172         return ret < 0 ? ret : 0;
173 }
174
175 /**
176  * pm_clk_destroy - Destroy a device's list of power management clocks.
177  * @dev: Device to destroy the list of PM clocks for.
178  *
179  * Clear the @dev's power.subsys_data field, remove the list of clock entries
180  * from the struct pm_subsys_data object pointed to by it before and free
181  * that object.
182  */
183 void pm_clk_destroy(struct device *dev)
184 {
185         struct pm_subsys_data *psd = dev_to_psd(dev);
186         struct pm_clock_entry *ce, *c;
187         struct list_head list;
188
189         if (!psd)
190                 return;
191
192         INIT_LIST_HEAD(&list);
193
194         spin_lock_irq(&psd->lock);
195
196         list_for_each_entry_safe_reverse(ce, c, &psd->clock_list, node)
197                 list_move(&ce->node, &list);
198
199         spin_unlock_irq(&psd->lock);
200
201         dev_pm_put_subsys_data(dev);
202
203         list_for_each_entry_safe_reverse(ce, c, &list, node) {
204                 list_del(&ce->node);
205                 __pm_clk_remove(ce);
206         }
207 }
208
209 #endif /* CONFIG_PM */
210
211 #ifdef CONFIG_PM_RUNTIME
212
213 /**
214  * pm_clk_suspend - Disable clocks in a device's PM clock list.
215  * @dev: Device to disable the clocks for.
216  */
217 int pm_clk_suspend(struct device *dev)
218 {
219         struct pm_subsys_data *psd = dev_to_psd(dev);
220         struct pm_clock_entry *ce;
221         unsigned long flags;
222
223         dev_dbg(dev, "%s()\n", __func__);
224
225         if (!psd)
226                 return 0;
227
228         spin_lock_irqsave(&psd->lock, flags);
229
230         list_for_each_entry_reverse(ce, &psd->clock_list, node) {
231                 if (ce->status < PCE_STATUS_ERROR) {
232                         if (ce->status == PCE_STATUS_ENABLED)
233                                 clk_disable(ce->clk);
234                         ce->status = PCE_STATUS_ACQUIRED;
235                 }
236         }
237
238         spin_unlock_irqrestore(&psd->lock, flags);
239
240         return 0;
241 }
242
243 /**
244  * pm_clk_resume - Enable clocks in a device's PM clock list.
245  * @dev: Device to enable the clocks for.
246  */
247 int pm_clk_resume(struct device *dev)
248 {
249         struct pm_subsys_data *psd = dev_to_psd(dev);
250         struct pm_clock_entry *ce;
251         unsigned long flags;
252
253         dev_dbg(dev, "%s()\n", __func__);
254
255         if (!psd)
256                 return 0;
257
258         spin_lock_irqsave(&psd->lock, flags);
259
260         list_for_each_entry(ce, &psd->clock_list, node) {
261                 if (ce->status < PCE_STATUS_ERROR) {
262                         clk_enable(ce->clk);
263                         ce->status = PCE_STATUS_ENABLED;
264                 }
265         }
266
267         spin_unlock_irqrestore(&psd->lock, flags);
268
269         return 0;
270 }
271
272 /**
273  * pm_clk_notify - Notify routine for device addition and removal.
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.
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
282  * of PM clocks, depending on @action.
283  *
284  * If the device's pm_domain field is already populated with a value different
285  * from the one stored in the struct pm_clk_notifier_block object, the function
286  * does nothing.
287  */
288 static int pm_clk_notify(struct notifier_block *nb,
289                                  unsigned long action, void *data)
290 {
291         struct pm_clk_notifier_block *clknb;
292         struct device *dev = data;
293         char **con_id;
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:
302                 if (dev->pm_domain)
303                         break;
304
305                 error = pm_clk_create(dev);
306                 if (error)
307                         break;
308
309                 dev->pm_domain = clknb->pm_domain;
310                 if (clknb->con_ids[0]) {
311                         for (con_id = clknb->con_ids; *con_id; con_id++)
312                                 pm_clk_add(dev, *con_id);
313                 } else {
314                         pm_clk_add(dev, NULL);
315                 }
316
317                 break;
318         case BUS_NOTIFY_DEL_DEVICE:
319                 if (dev->pm_domain != clknb->pm_domain)
320                         break;
321
322                 dev->pm_domain = NULL;
323                 pm_clk_destroy(dev);
324                 break;
325         }
326
327         return 0;
328 }
329
330 #else /* !CONFIG_PM_RUNTIME */
331
332 #ifdef CONFIG_PM
333
334 /**
335  * pm_clk_suspend - Disable clocks in a device's PM clock list.
336  * @dev: Device to disable the clocks for.
337  */
338 int pm_clk_suspend(struct device *dev)
339 {
340         struct pm_subsys_data *psd = dev_to_psd(dev);
341         struct pm_clock_entry *ce;
342         unsigned long flags;
343
344         dev_dbg(dev, "%s()\n", __func__);
345
346         /* If there is no driver, the clocks are already disabled. */
347         if (!psd || !dev->driver)
348                 return 0;
349
350         spin_lock_irqsave(&psd->lock, flags);
351
352         list_for_each_entry_reverse(ce, &psd->clock_list, node)
353                 clk_disable(ce->clk);
354
355         spin_unlock_irqrestore(&psd->lock, flags);
356
357         return 0;
358 }
359
360 /**
361  * pm_clk_resume - Enable clocks in a device's PM clock list.
362  * @dev: Device to enable the clocks for.
363  */
364 int pm_clk_resume(struct device *dev)
365 {
366         struct pm_subsys_data *psd = dev_to_psd(dev);
367         struct pm_clock_entry *ce;
368         unsigned long flags;
369
370         dev_dbg(dev, "%s()\n", __func__);
371
372         /* If there is no driver, the clocks should remain disabled. */
373         if (!psd || !dev->driver)
374                 return 0;
375
376         spin_lock_irqsave(&psd->lock, flags);
377
378         list_for_each_entry(ce, &psd->clock_list, node)
379                 clk_enable(ce->clk);
380
381         spin_unlock_irqrestore(&psd->lock, flags);
382
383         return 0;
384 }
385
386 #endif /* CONFIG_PM */
387
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 /**
423  * pm_clk_notify - Notify routine for device addition and removal.
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  */
433 static int pm_clk_notify(struct notifier_block *nb,
434                                  unsigned long action, void *data)
435 {
436         struct pm_clk_notifier_block *clknb;
437         struct device *dev = data;
438         char **con_id;
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) {
445         case BUS_NOTIFY_BIND_DRIVER:
446                 if (clknb->con_ids[0]) {
447                         for (con_id = clknb->con_ids; *con_id; con_id++)
448                                 enable_clock(dev, *con_id);
449                 } else {
450                         enable_clock(dev, NULL);
451                 }
452                 break;
453         case BUS_NOTIFY_UNBOUND_DRIVER:
454                 if (clknb->con_ids[0]) {
455                         for (con_id = clknb->con_ids; *con_id; con_id++)
456                                 disable_clock(dev, *con_id);
457                 } else {
458                         disable_clock(dev, NULL);
459                 }
460                 break;
461         }
462
463         return 0;
464 }
465
466 #endif /* !CONFIG_PM_RUNTIME */
467
468 /**
469  * pm_clk_add_notifier - Add bus type notifier for power management clocks.
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
474  * notifier_call member will be replaced with pm_clk_notify().  However,
475  * the remaining members of @clknb should be populated prior to calling this
476  * routine.
477  */
478 void pm_clk_add_notifier(struct bus_type *bus,
479                                  struct pm_clk_notifier_block *clknb)
480 {
481         if (!bus || !clknb)
482                 return;
483
484         clknb->nb.notifier_call = pm_clk_notify;
485         bus_register_notifier(bus, &clknb->nb);
486 }