1 /* arch/arm/plat-s3c/pwm.c
3 * Copyright (c) 2007 Ben Dooks
4 * Copyright (c) 2008 Simtec Electronics
5 * Ben Dooks <ben@simtec.co.uk>, <ben-linux@fluff.org>
7 * S3C series PWM device core
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License.
14 #include <linux/export.h>
15 #include <linux/kernel.h>
16 #include <linux/platform_device.h>
17 #include <linux/slab.h>
18 #include <linux/err.h>
19 #include <linux/clk.h>
21 #include <linux/pwm.h>
25 #include <plat/regs-timer.h>
28 struct list_head list
;
29 struct platform_device
*pdev
;
35 unsigned int period_ns
;
38 unsigned char tcon_base
;
39 unsigned char use_count
;
43 #define pwm_dbg(_pwm, msg...) dev_dbg(&(_pwm)->pdev->dev, msg)
45 static struct clk
*clk_scaler
[2];
47 static inline int pwm_is_tdiv(struct pwm_device
*pwm
)
49 return clk_get_parent(pwm
->clk
) == pwm
->clk_div
;
52 static DEFINE_MUTEX(pwm_lock
);
53 static LIST_HEAD(pwm_list
);
55 struct pwm_device
*pwm_request(int pwm_id
, const char *label
)
57 struct pwm_device
*pwm
;
60 mutex_lock(&pwm_lock
);
62 list_for_each_entry(pwm
, &pwm_list
, list
) {
63 if (pwm
->pwm_id
== pwm_id
) {
70 if (pwm
->use_count
== 0) {
74 pwm
= ERR_PTR(-EBUSY
);
76 pwm
= ERR_PTR(-ENOENT
);
78 mutex_unlock(&pwm_lock
);
82 EXPORT_SYMBOL(pwm_request
);
85 void pwm_free(struct pwm_device
*pwm
)
87 mutex_lock(&pwm_lock
);
93 printk(KERN_ERR
"PWM%d device already freed\n", pwm
->pwm_id
);
95 mutex_unlock(&pwm_lock
);
98 EXPORT_SYMBOL(pwm_free
);
100 #define pwm_tcon_start(pwm) (1 << (pwm->tcon_base + 0))
101 #define pwm_tcon_invert(pwm) (1 << (pwm->tcon_base + 2))
102 #define pwm_tcon_autoreload(pwm) (1 << (pwm->tcon_base + 3))
103 #define pwm_tcon_manulupdate(pwm) (1 << (pwm->tcon_base + 1))
105 int pwm_enable(struct pwm_device
*pwm
)
110 local_irq_save(flags
);
112 tcon
= __raw_readl(S3C2410_TCON
);
113 tcon
|= pwm_tcon_start(pwm
);
114 __raw_writel(tcon
, S3C2410_TCON
);
116 local_irq_restore(flags
);
121 EXPORT_SYMBOL(pwm_enable
);
123 void pwm_disable(struct pwm_device
*pwm
)
128 local_irq_save(flags
);
130 tcon
= __raw_readl(S3C2410_TCON
);
131 tcon
&= ~pwm_tcon_start(pwm
);
132 __raw_writel(tcon
, S3C2410_TCON
);
134 local_irq_restore(flags
);
137 EXPORT_SYMBOL(pwm_disable
);
139 static unsigned long pwm_calc_tin(struct pwm_device
*pwm
, unsigned long freq
)
141 unsigned long tin_parent_rate
;
144 tin_parent_rate
= clk_get_rate(clk_get_parent(pwm
->clk_div
));
145 pwm_dbg(pwm
, "tin parent at %lu\n", tin_parent_rate
);
147 for (div
= 2; div
<= 16; div
*= 2) {
148 if ((tin_parent_rate
/ (div
<< 16)) < freq
)
149 return tin_parent_rate
/ div
;
152 return tin_parent_rate
/ 16;
155 #define NS_IN_HZ (1000000000UL)
157 int pwm_config(struct pwm_device
*pwm
, int duty_ns
, int period_ns
)
159 unsigned long tin_rate
;
160 unsigned long tin_ns
;
161 unsigned long period
;
167 /* We currently avoid using 64bit arithmetic by using the
168 * fact that anything faster than 1Hz is easily representable
171 if (period_ns
> NS_IN_HZ
|| duty_ns
> NS_IN_HZ
)
174 if (duty_ns
> period_ns
)
177 if (period_ns
== pwm
->period_ns
&&
178 duty_ns
== pwm
->duty_ns
)
181 /* The TCMP and TCNT can be read without a lock, they're not
182 * shared between the timers. */
184 tcmp
= __raw_readl(S3C2410_TCMPB(pwm
->pwm_id
));
185 tcnt
= __raw_readl(S3C2410_TCNTB(pwm
->pwm_id
));
187 period
= NS_IN_HZ
/ period_ns
;
189 pwm_dbg(pwm
, "duty_ns=%d, period_ns=%d (%lu)\n",
190 duty_ns
, period_ns
, period
);
192 /* Check to see if we are changing the clock rate of the PWM */
194 if (pwm
->period_ns
!= period_ns
) {
195 if (pwm_is_tdiv(pwm
)) {
196 tin_rate
= pwm_calc_tin(pwm
, period
);
197 clk_set_rate(pwm
->clk_div
, tin_rate
);
199 tin_rate
= clk_get_rate(pwm
->clk
);
201 pwm
->period_ns
= period_ns
;
203 pwm_dbg(pwm
, "tin_rate=%lu\n", tin_rate
);
205 tin_ns
= NS_IN_HZ
/ tin_rate
;
206 tcnt
= period_ns
/ tin_ns
;
208 tin_ns
= NS_IN_HZ
/ clk_get_rate(pwm
->clk
);
210 /* Note, counters count down */
212 tcmp
= duty_ns
/ tin_ns
;
214 /* the pwm hw only checks the compare register after a decrement,
215 so the pin never toggles if tcmp = tcnt */
219 pwm_dbg(pwm
, "tin_ns=%lu, tcmp=%ld/%lu\n", tin_ns
, tcmp
, tcnt
);
224 /* Update the PWM register block. */
226 local_irq_save(flags
);
228 __raw_writel(tcmp
, S3C2410_TCMPB(pwm
->pwm_id
));
229 __raw_writel(tcnt
, S3C2410_TCNTB(pwm
->pwm_id
));
231 tcon
= __raw_readl(S3C2410_TCON
);
232 tcon
|= pwm_tcon_manulupdate(pwm
);
233 tcon
|= pwm_tcon_autoreload(pwm
);
234 __raw_writel(tcon
, S3C2410_TCON
);
236 tcon
&= ~pwm_tcon_manulupdate(pwm
);
237 __raw_writel(tcon
, S3C2410_TCON
);
239 local_irq_restore(flags
);
244 EXPORT_SYMBOL(pwm_config
);
246 static int pwm_register(struct pwm_device
*pwm
)
251 mutex_lock(&pwm_lock
);
252 list_add_tail(&pwm
->list
, &pwm_list
);
253 mutex_unlock(&pwm_lock
);
258 static int s3c_pwm_probe(struct platform_device
*pdev
)
260 struct device
*dev
= &pdev
->dev
;
261 struct pwm_device
*pwm
;
264 unsigned int id
= pdev
->id
;
268 dev_err(dev
, "TIMER4 is currently not supported\n");
272 pwm
= kzalloc(sizeof(struct pwm_device
), GFP_KERNEL
);
274 dev_err(dev
, "failed to allocate pwm_device\n");
281 /* calculate base of control bits in TCON */
282 pwm
->tcon_base
= id
== 0 ? 0 : (id
* 4) + 4;
284 pwm
->clk
= clk_get(dev
, "pwm-tin");
285 if (IS_ERR(pwm
->clk
)) {
286 dev_err(dev
, "failed to get pwm tin clk\n");
287 ret
= PTR_ERR(pwm
->clk
);
291 pwm
->clk_div
= clk_get(dev
, "pwm-tdiv");
292 if (IS_ERR(pwm
->clk_div
)) {
293 dev_err(dev
, "failed to get pwm tdiv clk\n");
294 ret
= PTR_ERR(pwm
->clk_div
);
298 clk_enable(pwm
->clk
);
299 clk_enable(pwm
->clk_div
);
301 local_irq_save(flags
);
303 tcon
= __raw_readl(S3C2410_TCON
);
304 tcon
|= pwm_tcon_invert(pwm
);
305 __raw_writel(tcon
, S3C2410_TCON
);
307 local_irq_restore(flags
);
310 ret
= pwm_register(pwm
);
312 dev_err(dev
, "failed to register pwm\n");
316 pwm_dbg(pwm
, "config bits %02x\n",
317 (__raw_readl(S3C2410_TCON
) >> pwm
->tcon_base
) & 0x0f);
319 dev_info(dev
, "tin at %lu, tdiv at %lu, tin=%sclk, base %d\n",
320 clk_get_rate(pwm
->clk
),
321 clk_get_rate(pwm
->clk_div
),
322 pwm_is_tdiv(pwm
) ? "div" : "ext", pwm
->tcon_base
);
324 platform_set_drvdata(pdev
, pwm
);
328 clk_disable(pwm
->clk_div
);
329 clk_disable(pwm
->clk
);
330 clk_put(pwm
->clk_div
);
340 static int __devexit
s3c_pwm_remove(struct platform_device
*pdev
)
342 struct pwm_device
*pwm
= platform_get_drvdata(pdev
);
344 clk_disable(pwm
->clk_div
);
345 clk_disable(pwm
->clk
);
346 clk_put(pwm
->clk_div
);
354 static int s3c_pwm_suspend(struct platform_device
*pdev
, pm_message_t state
)
356 struct pwm_device
*pwm
= platform_get_drvdata(pdev
);
358 /* No one preserve these values during suspend so reset them
359 * Otherwise driver leaves PWM unconfigured if same values
360 * passed to pwm_config
368 static int s3c_pwm_resume(struct platform_device
*pdev
)
370 struct pwm_device
*pwm
= platform_get_drvdata(pdev
);
373 /* Restore invertion */
374 tcon
= __raw_readl(S3C2410_TCON
);
375 tcon
|= pwm_tcon_invert(pwm
);
376 __raw_writel(tcon
, S3C2410_TCON
);
382 #define s3c_pwm_suspend NULL
383 #define s3c_pwm_resume NULL
386 static struct platform_driver s3c_pwm_driver
= {
388 .name
= "s3c24xx-pwm",
389 .owner
= THIS_MODULE
,
391 .probe
= s3c_pwm_probe
,
392 .remove
= __devexit_p(s3c_pwm_remove
),
393 .suspend
= s3c_pwm_suspend
,
394 .resume
= s3c_pwm_resume
,
397 static int __init
pwm_init(void)
401 clk_scaler
[0] = clk_get(NULL
, "pwm-scaler0");
402 clk_scaler
[1] = clk_get(NULL
, "pwm-scaler1");
404 if (IS_ERR(clk_scaler
[0]) || IS_ERR(clk_scaler
[1])) {
405 printk(KERN_ERR
"%s: failed to get scaler clocks\n", __func__
);
409 ret
= platform_driver_register(&s3c_pwm_driver
);
411 printk(KERN_ERR
"%s: failed to add pwm driver\n", __func__
);
416 arch_initcall(pwm_init
);