1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/module.h>
15#include <linux/kernel.h>
16#include <linux/platform_device.h>
17#include <linux/err.h>
18#include <linux/clk.h>
19#include <linux/io.h>
20#include <linux/pwm.h>
21
22#include <asm/div64.h>
23
24
25#define PWMCR (0x00)
26#define PWMDCR (0x04)
27#define PWMPCR (0x08)
28
29#define PWMCR_SD (1 << 6)
30#define PWMDCR_FD (1 << 10)
31
32struct pwm_device {
33 struct list_head node;
34 struct platform_device *pdev;
35
36 const char *label;
37 struct clk *clk;
38 int clk_enabled;
39 void __iomem *mmio_base;
40
41 unsigned int use_count;
42 unsigned int pwm_id;
43};
44
45
46
47
48
49int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns)
50{
51 unsigned long long c;
52 unsigned long period_cycles, prescale, pv, dc;
53
54 if (pwm == NULL || period_ns == 0 || duty_ns > period_ns)
55 return -EINVAL;
56
57 c = clk_get_rate(pwm->clk);
58 c = c * period_ns;
59 do_div(c, 1000000000);
60 period_cycles = c;
61
62 if (period_cycles < 1)
63 period_cycles = 1;
64 prescale = (period_cycles - 1) / 1024;
65 pv = period_cycles / (prescale + 1) - 1;
66
67 if (prescale > 63)
68 return -EINVAL;
69
70 if (duty_ns == period_ns)
71 dc = PWMDCR_FD;
72 else
73 dc = (pv + 1) * duty_ns / period_ns;
74
75
76
77
78 clk_enable(pwm->clk);
79 __raw_writel(prescale, pwm->mmio_base + PWMCR);
80 __raw_writel(dc, pwm->mmio_base + PWMDCR);
81 __raw_writel(pv, pwm->mmio_base + PWMPCR);
82 clk_disable(pwm->clk);
83
84 return 0;
85}
86EXPORT_SYMBOL(pwm_config);
87
88int pwm_enable(struct pwm_device *pwm)
89{
90 int rc = 0;
91
92 if (!pwm->clk_enabled) {
93 rc = clk_enable(pwm->clk);
94 if (!rc)
95 pwm->clk_enabled = 1;
96 }
97 return rc;
98}
99EXPORT_SYMBOL(pwm_enable);
100
101void pwm_disable(struct pwm_device *pwm)
102{
103 if (pwm->clk_enabled) {
104 clk_disable(pwm->clk);
105 pwm->clk_enabled = 0;
106 }
107}
108EXPORT_SYMBOL(pwm_disable);
109
110static DEFINE_MUTEX(pwm_lock);
111static LIST_HEAD(pwm_list);
112
113struct pwm_device *pwm_request(int pwm_id, const char *label)
114{
115 struct pwm_device *pwm;
116 int found = 0;
117
118 mutex_lock(&pwm_lock);
119
120 list_for_each_entry(pwm, &pwm_list, node) {
121 if (pwm->pwm_id == pwm_id) {
122 found = 1;
123 break;
124 }
125 }
126
127 if (found) {
128 if (pwm->use_count == 0) {
129 pwm->use_count++;
130 pwm->label = label;
131 } else
132 pwm = ERR_PTR(-EBUSY);
133 } else
134 pwm = ERR_PTR(-ENOENT);
135
136 mutex_unlock(&pwm_lock);
137 return pwm;
138}
139EXPORT_SYMBOL(pwm_request);
140
141void pwm_free(struct pwm_device *pwm)
142{
143 mutex_lock(&pwm_lock);
144
145 if (pwm->use_count) {
146 pwm->use_count--;
147 pwm->label = NULL;
148 } else
149 pr_warning("PWM device already freed\n");
150
151 mutex_unlock(&pwm_lock);
152}
153EXPORT_SYMBOL(pwm_free);
154
155static inline void __add_pwm(struct pwm_device *pwm)
156{
157 mutex_lock(&pwm_lock);
158 list_add_tail(&pwm->node, &pwm_list);
159 mutex_unlock(&pwm_lock);
160}
161
162static struct pwm_device *pwm_probe(struct platform_device *pdev,
163 unsigned int pwm_id, struct pwm_device *parent_pwm)
164{
165 struct pwm_device *pwm;
166 struct resource *r;
167 int ret = 0;
168
169 pwm = kzalloc(sizeof(struct pwm_device), GFP_KERNEL);
170 if (pwm == NULL) {
171 dev_err(&pdev->dev, "failed to allocate memory\n");
172 return ERR_PTR(-ENOMEM);
173 }
174
175 pwm->clk = clk_get(&pdev->dev, NULL);
176 if (IS_ERR(pwm->clk)) {
177 ret = PTR_ERR(pwm->clk);
178 goto err_free;
179 }
180 pwm->clk_enabled = 0;
181
182 pwm->use_count = 0;
183 pwm->pwm_id = pwm_id;
184 pwm->pdev = pdev;
185
186 if (parent_pwm != NULL) {
187
188 pwm->mmio_base = parent_pwm->mmio_base + 0x10;
189 __add_pwm(pwm);
190 return pwm;
191 }
192
193 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
194 if (r == NULL) {
195 dev_err(&pdev->dev, "no memory resource defined\n");
196 ret = -ENODEV;
197 goto err_free_clk;
198 }
199
200 r = request_mem_region(r->start, r->end - r->start + 1, pdev->name);
201 if (r == NULL) {
202 dev_err(&pdev->dev, "failed to request memory resource\n");
203 ret = -EBUSY;
204 goto err_free_clk;
205 }
206
207 pwm->mmio_base = ioremap(r->start, r->end - r->start + 1);
208 if (pwm->mmio_base == NULL) {
209 dev_err(&pdev->dev, "failed to ioremap() registers\n");
210 ret = -ENODEV;
211 goto err_free_mem;
212 }
213
214 __add_pwm(pwm);
215 platform_set_drvdata(pdev, pwm);
216 return pwm;
217
218err_free_mem:
219 release_mem_region(r->start, r->end - r->start + 1);
220err_free_clk:
221 clk_put(pwm->clk);
222err_free:
223 kfree(pwm);
224 return ERR_PTR(ret);
225}
226
227static int __devinit pxa25x_pwm_probe(struct platform_device *pdev)
228{
229 struct pwm_device *pwm = pwm_probe(pdev, pdev->id, NULL);
230
231 if (IS_ERR(pwm))
232 return PTR_ERR(pwm);
233
234 return 0;
235}
236
237static int __devinit pxa27x_pwm_probe(struct platform_device *pdev)
238{
239 struct pwm_device *pwm;
240
241 pwm = pwm_probe(pdev, pdev->id, NULL);
242 if (IS_ERR(pwm))
243 return PTR_ERR(pwm);
244
245 pwm = pwm_probe(pdev, pdev->id + 2, pwm);
246 if (IS_ERR(pwm))
247 return PTR_ERR(pwm);
248
249 return 0;
250}
251
252static int __devexit pwm_remove(struct platform_device *pdev)
253{
254 struct pwm_device *pwm;
255 struct resource *r;
256
257 pwm = platform_get_drvdata(pdev);
258 if (pwm == NULL)
259 return -ENODEV;
260
261 mutex_lock(&pwm_lock);
262 list_del(&pwm->node);
263 mutex_unlock(&pwm_lock);
264
265 iounmap(pwm->mmio_base);
266
267 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
268 release_mem_region(r->start, r->end - r->start + 1);
269
270 clk_put(pwm->clk);
271 kfree(pwm);
272 return 0;
273}
274
275static struct platform_driver pxa25x_pwm_driver = {
276 .driver = {
277 .name = "pxa25x-pwm",
278 },
279 .probe = pxa25x_pwm_probe,
280 .remove = __devexit_p(pwm_remove),
281};
282
283static struct platform_driver pxa27x_pwm_driver = {
284 .driver = {
285 .name = "pxa27x-pwm",
286 },
287 .probe = pxa27x_pwm_probe,
288 .remove = __devexit_p(pwm_remove),
289};
290
291static int __init pwm_init(void)
292{
293 int ret = 0;
294
295 ret = platform_driver_register(&pxa25x_pwm_driver);
296 if (ret) {
297 printk(KERN_ERR "failed to register pxa25x_pwm_driver\n");
298 return ret;
299 }
300
301 ret = platform_driver_register(&pxa27x_pwm_driver);
302 if (ret) {
303 printk(KERN_ERR "failed to register pxa27x_pwm_driver\n");
304 return ret;
305 }
306
307 return ret;
308}
309arch_initcall(pwm_init);
310
311static void __exit pwm_exit(void)
312{
313 platform_driver_unregister(&pxa25x_pwm_driver);
314 platform_driver_unregister(&pxa27x_pwm_driver);
315}
316module_exit(pwm_exit);
317
318MODULE_LICENSE("GPL v2");
319
