Merge branches 'core/softlockup', 'core/softirq', 'core/resources', 'core/printk...
[linux-2.6] / arch / arm / mach-pxa / clock.c
1 /*
2  *  linux/arch/arm/mach-sa1100/clock.c
3  */
4 #include <linux/module.h>
5 #include <linux/kernel.h>
6 #include <linux/list.h>
7 #include <linux/errno.h>
8 #include <linux/err.h>
9 #include <linux/string.h>
10 #include <linux/clk.h>
11 #include <linux/spinlock.h>
12 #include <linux/platform_device.h>
13 #include <linux/delay.h>
14
15 #include <mach/pxa2xx-regs.h>
16 #include <mach/pxa2xx-gpio.h>
17 #include <mach/hardware.h>
18
19 #include "devices.h"
20 #include "generic.h"
21 #include "clock.h"
22
23 static LIST_HEAD(clocks);
24 static DEFINE_MUTEX(clocks_mutex);
25 static DEFINE_SPINLOCK(clocks_lock);
26
27 static struct clk *clk_lookup(struct device *dev, const char *id)
28 {
29         struct clk *p;
30
31         list_for_each_entry(p, &clocks, node)
32                 if (strcmp(id, p->name) == 0 && p->dev == dev)
33                         return p;
34
35         return NULL;
36 }
37
38 struct clk *clk_get(struct device *dev, const char *id)
39 {
40         struct clk *p, *clk = ERR_PTR(-ENOENT);
41
42         mutex_lock(&clocks_mutex);
43         p = clk_lookup(dev, id);
44         if (!p)
45                 p = clk_lookup(NULL, id);
46         if (p)
47                 clk = p;
48         mutex_unlock(&clocks_mutex);
49
50         if (!IS_ERR(clk) && clk->ops == NULL)
51                 clk = clk->other;
52
53         return clk;
54 }
55 EXPORT_SYMBOL(clk_get);
56
57 void clk_put(struct clk *clk)
58 {
59 }
60 EXPORT_SYMBOL(clk_put);
61
62 int clk_enable(struct clk *clk)
63 {
64         unsigned long flags;
65
66         spin_lock_irqsave(&clocks_lock, flags);
67         if (clk->enabled++ == 0)
68                 clk->ops->enable(clk);
69         spin_unlock_irqrestore(&clocks_lock, flags);
70
71         if (clk->delay)
72                 udelay(clk->delay);
73
74         return 0;
75 }
76 EXPORT_SYMBOL(clk_enable);
77
78 void clk_disable(struct clk *clk)
79 {
80         unsigned long flags;
81
82         WARN_ON(clk->enabled == 0);
83
84         spin_lock_irqsave(&clocks_lock, flags);
85         if (--clk->enabled == 0)
86                 clk->ops->disable(clk);
87         spin_unlock_irqrestore(&clocks_lock, flags);
88 }
89 EXPORT_SYMBOL(clk_disable);
90
91 unsigned long clk_get_rate(struct clk *clk)
92 {
93         unsigned long rate;
94
95         rate = clk->rate;
96         if (clk->ops->getrate)
97                 rate = clk->ops->getrate(clk);
98
99         return rate;
100 }
101 EXPORT_SYMBOL(clk_get_rate);
102
103
104 void clk_cken_enable(struct clk *clk)
105 {
106         CKEN |= 1 << clk->cken;
107 }
108
109 void clk_cken_disable(struct clk *clk)
110 {
111         CKEN &= ~(1 << clk->cken);
112 }
113
114 const struct clkops clk_cken_ops = {
115         .enable         = clk_cken_enable,
116         .disable        = clk_cken_disable,
117 };
118
119 void clks_register(struct clk *clks, size_t num)
120 {
121         int i;
122
123         mutex_lock(&clocks_mutex);
124         for (i = 0; i < num; i++)
125                 list_add(&clks[i].node, &clocks);
126         mutex_unlock(&clocks_mutex);
127 }
128
129 int clk_add_alias(char *alias, struct device *alias_dev, char *id,
130         struct device *dev)
131 {
132         struct clk *r = clk_lookup(dev, id);
133         struct clk *new;
134
135         if (!r)
136                 return -ENODEV;
137
138         new = kzalloc(sizeof(struct clk), GFP_KERNEL);
139
140         if (!new)
141                 return -ENOMEM;
142
143         new->name = alias;
144         new->dev = alias_dev;
145         new->other = r;
146
147         mutex_lock(&clocks_mutex);
148         list_add(&new->node, &clocks);
149         mutex_unlock(&clocks_mutex);
150
151         return 0;
152 }