2 * linux/arch/arm/mach-pxa/pwm.c
4 * simple driver for PWM (Pulse Width Modulator) controller
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 * 2008-02-13 initial version
11 * eric miao <eric.miao@marvell.com>
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>
20 #include <linux/pwm.h>
22 #include <asm/div64.h>
23 #include <asm/arch/pxa-regs.h>
25 /* PWM registers and bits definitions */
30 #define PWMCR_SD (1 << 6)
31 #define PWMDCR_FD (1 << 10)
34 struct list_head node;
35 struct platform_device *pdev;
39 void __iomem *mmio_base;
41 unsigned int use_count;
46 * period_ns = 10^9 * (PRESCALE + 1) * (PV + 1) / PWM_CLK_RATE
47 * duty_ns = 10^9 * (PRESCALE + 1) * DC / PWM_CLK_RATE
49 int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns)
52 unsigned long period_cycles, prescale, pv, dc;
54 if (pwm == NULL || period_ns == 0 || duty_ns > period_ns)
57 c = clk_get_rate(pwm->clk);
59 do_div(c, 1000000000);
62 if (period_cycles < 0)
64 prescale = (period_cycles - 1) / 1024;
65 pv = period_cycles / (prescale + 1) - 1;
70 if (duty_ns == period_ns)
73 dc = (pv + 1) * duty_ns / period_ns;
75 /* NOTE: the clock to PWM has to be enabled first
76 * before writing to the registers
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);
86 EXPORT_SYMBOL(pwm_config);
88 int pwm_enable(struct pwm_device *pwm)
90 return clk_enable(pwm->clk);
92 EXPORT_SYMBOL(pwm_enable);
94 void pwm_disable(struct pwm_device *pwm)
96 clk_disable(pwm->clk);
98 EXPORT_SYMBOL(pwm_disable);
100 static DEFINE_MUTEX(pwm_lock);
101 static LIST_HEAD(pwm_list);
103 struct pwm_device *pwm_request(int pwm_id, const char *label)
105 struct pwm_device *pwm;
108 mutex_lock(&pwm_lock);
110 list_for_each_entry(pwm, &pwm_list, node) {
111 if (pwm->pwm_id == pwm_id && pwm->use_count == 0) {
119 mutex_unlock(&pwm_lock);
121 return (found) ? pwm : NULL;
123 EXPORT_SYMBOL(pwm_request);
125 void pwm_free(struct pwm_device *pwm)
127 mutex_lock(&pwm_lock);
129 if (pwm->use_count) {
133 pr_warning("PWM device already freed\n");
135 mutex_unlock(&pwm_lock);
137 EXPORT_SYMBOL(pwm_free);
139 static inline void __add_pwm(struct pwm_device *pwm)
141 mutex_lock(&pwm_lock);
142 list_add_tail(&pwm->node, &pwm_list);
143 mutex_unlock(&pwm_lock);
146 static struct pwm_device *pwm_probe(struct platform_device *pdev,
147 unsigned int pwm_id, struct pwm_device *parent_pwm)
149 struct pwm_device *pwm;
153 pwm = kzalloc(sizeof(struct pwm_device), GFP_KERNEL);
155 dev_err(&pdev->dev, "failed to allocate memory\n");
156 return ERR_PTR(-ENOMEM);
159 pwm->clk = clk_get(&pdev->dev, "PWMCLK");
160 if (IS_ERR(pwm->clk)) {
161 ret = PTR_ERR(pwm->clk);
166 pwm->pwm_id = pwm_id;
169 if (parent_pwm != NULL) {
170 /* registers for the second PWM has offset of 0x10 */
171 pwm->mmio_base = parent_pwm->mmio_base + 0x10;
176 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
178 dev_err(&pdev->dev, "no memory resource defined\n");
183 r = request_mem_region(r->start, r->end - r->start + 1, pdev->name);
185 dev_err(&pdev->dev, "failed to request memory resource\n");
190 pwm->mmio_base = ioremap(r->start, r->end - r->start + 1);
191 if (pwm->mmio_base == NULL) {
192 dev_err(&pdev->dev, "failed to ioremap() registers\n");
198 platform_set_drvdata(pdev, pwm);
202 release_mem_region(r->start, r->end - r->start + 1);
210 static int __devinit pxa25x_pwm_probe(struct platform_device *pdev)
212 struct pwm_device *pwm = pwm_probe(pdev, pdev->id, NULL);
220 static int __devinit pxa27x_pwm_probe(struct platform_device *pdev)
222 struct pwm_device *pwm;
224 pwm = pwm_probe(pdev, pdev->id, NULL);
228 pwm = pwm_probe(pdev, pdev->id + 2, pwm);
235 static int __devexit pwm_remove(struct platform_device *pdev)
237 struct pwm_device *pwm;
240 pwm = platform_get_drvdata(pdev);
244 mutex_lock(&pwm_lock);
245 list_del(&pwm->node);
246 mutex_unlock(&pwm_lock);
248 iounmap(pwm->mmio_base);
250 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
251 release_mem_region(r->start, r->end - r->start + 1);
258 static struct platform_driver pxa25x_pwm_driver = {
260 .name = "pxa25x-pwm",
262 .probe = pxa25x_pwm_probe,
263 .remove = __devexit_p(pwm_remove),
266 static struct platform_driver pxa27x_pwm_driver = {
268 .name = "pxa27x-pwm",
270 .probe = pxa27x_pwm_probe,
271 .remove = __devexit_p(pwm_remove),
274 static int __init pwm_init(void)
278 ret = platform_driver_register(&pxa25x_pwm_driver);
280 printk(KERN_ERR "failed to register pxa25x_pwm_driver\n");
284 ret = platform_driver_register(&pxa27x_pwm_driver);
286 printk(KERN_ERR "failed to register pxa27x_pwm_driver\n");
292 arch_initcall(pwm_init);
294 static void __exit pwm_exit(void)
296 platform_driver_unregister(&pxa25x_pwm_driver);
297 platform_driver_unregister(&pxa27x_pwm_driver);
299 module_exit(pwm_exit);
301 MODULE_LICENSE("GPL v2");