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>
24 #define HAS_SECONDARY_PWM 0x10
26 static const struct platform_device_id pwm_id_table
[] = {
27 /* PWM has_secondary_pwm? */
29 { "pxa27x-pwm", HAS_SECONDARY_PWM
},
32 MODULE_DEVICE_TABLE(platform
, pwm_id_table
);
34 /* PWM registers and bits definitions */
39 #define PWMCR_SD (1 << 6)
40 #define PWMDCR_FD (1 << 10)
43 struct list_head node
;
44 struct pwm_device
*secondary
;
45 struct platform_device
*pdev
;
50 void __iomem
*mmio_base
;
52 unsigned int use_count
;
57 * period_ns = 10^9 * (PRESCALE + 1) * (PV + 1) / PWM_CLK_RATE
58 * duty_ns = 10^9 * (PRESCALE + 1) * DC / PWM_CLK_RATE
60 int pwm_config(struct pwm_device
*pwm
, int duty_ns
, int period_ns
)
63 unsigned long period_cycles
, prescale
, pv
, dc
;
65 if (pwm
== NULL
|| period_ns
== 0 || duty_ns
> period_ns
)
68 c
= clk_get_rate(pwm
->clk
);
70 do_div(c
, 1000000000);
73 if (period_cycles
< 1)
75 prescale
= (period_cycles
- 1) / 1024;
76 pv
= period_cycles
/ (prescale
+ 1) - 1;
81 if (duty_ns
== period_ns
)
84 dc
= (pv
+ 1) * duty_ns
/ period_ns
;
86 /* NOTE: the clock to PWM has to be enabled first
87 * before writing to the registers
90 __raw_writel(prescale
, pwm
->mmio_base
+ PWMCR
);
91 __raw_writel(dc
, pwm
->mmio_base
+ PWMDCR
);
92 __raw_writel(pv
, pwm
->mmio_base
+ PWMPCR
);
93 clk_disable(pwm
->clk
);
97 EXPORT_SYMBOL(pwm_config
);
99 int pwm_enable(struct pwm_device
*pwm
)
103 if (!pwm
->clk_enabled
) {
104 rc
= clk_enable(pwm
->clk
);
106 pwm
->clk_enabled
= 1;
110 EXPORT_SYMBOL(pwm_enable
);
112 void pwm_disable(struct pwm_device
*pwm
)
114 if (pwm
->clk_enabled
) {
115 clk_disable(pwm
->clk
);
116 pwm
->clk_enabled
= 0;
119 EXPORT_SYMBOL(pwm_disable
);
121 static DEFINE_MUTEX(pwm_lock
);
122 static LIST_HEAD(pwm_list
);
124 struct pwm_device
*pwm_request(int pwm_id
, const char *label
)
126 struct pwm_device
*pwm
;
129 mutex_lock(&pwm_lock
);
131 list_for_each_entry(pwm
, &pwm_list
, node
) {
132 if (pwm
->pwm_id
== pwm_id
) {
139 if (pwm
->use_count
== 0) {
143 pwm
= ERR_PTR(-EBUSY
);
145 pwm
= ERR_PTR(-ENOENT
);
147 mutex_unlock(&pwm_lock
);
150 EXPORT_SYMBOL(pwm_request
);
152 void pwm_free(struct pwm_device
*pwm
)
154 mutex_lock(&pwm_lock
);
156 if (pwm
->use_count
) {
160 pr_warning("PWM device already freed\n");
162 mutex_unlock(&pwm_lock
);
164 EXPORT_SYMBOL(pwm_free
);
166 static inline void __add_pwm(struct pwm_device
*pwm
)
168 mutex_lock(&pwm_lock
);
169 list_add_tail(&pwm
->node
, &pwm_list
);
170 mutex_unlock(&pwm_lock
);
173 static int __devinit
pwm_probe(struct platform_device
*pdev
)
175 struct platform_device_id
*id
= platform_get_device_id(pdev
);
176 struct pwm_device
*pwm
, *secondary
= NULL
;
180 pwm
= kzalloc(sizeof(struct pwm_device
), GFP_KERNEL
);
182 dev_err(&pdev
->dev
, "failed to allocate memory\n");
186 pwm
->clk
= clk_get(&pdev
->dev
, NULL
);
187 if (IS_ERR(pwm
->clk
)) {
188 ret
= PTR_ERR(pwm
->clk
);
191 pwm
->clk_enabled
= 0;
194 pwm
->pwm_id
= pdev
->id
;
197 r
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
199 dev_err(&pdev
->dev
, "no memory resource defined\n");
204 r
= request_mem_region(r
->start
, r
->end
- r
->start
+ 1, pdev
->name
);
206 dev_err(&pdev
->dev
, "failed to request memory resource\n");
211 pwm
->mmio_base
= ioremap(r
->start
, r
->end
- r
->start
+ 1);
212 if (pwm
->mmio_base
== NULL
) {
213 dev_err(&pdev
->dev
, "failed to ioremap() registers\n");
218 if (id
->driver_data
& HAS_SECONDARY_PWM
) {
219 secondary
= kzalloc(sizeof(struct pwm_device
), GFP_KERNEL
);
220 if (secondary
== NULL
) {
226 pwm
->secondary
= secondary
;
228 /* registers for the second PWM has offset of 0x10 */
229 secondary
->mmio_base
= pwm
->mmio_base
+ 0x10;
230 secondary
->pwm_id
= pdev
->id
+ 2;
235 __add_pwm(secondary
);
237 platform_set_drvdata(pdev
, pwm
);
241 release_mem_region(r
->start
, r
->end
- r
->start
+ 1);
249 static int __devexit
pwm_remove(struct platform_device
*pdev
)
251 struct pwm_device
*pwm
;
254 pwm
= platform_get_drvdata(pdev
);
258 mutex_lock(&pwm_lock
);
260 if (pwm
->secondary
) {
261 list_del(&pwm
->secondary
->node
);
262 kfree(pwm
->secondary
);
265 list_del(&pwm
->node
);
266 mutex_unlock(&pwm_lock
);
268 iounmap(pwm
->mmio_base
);
270 r
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
271 release_mem_region(r
->start
, r
->end
- r
->start
+ 1);
278 static struct platform_driver pwm_driver
= {
280 .name
= "pxa25x-pwm",
281 .owner
= THIS_MODULE
,
284 .remove
= __devexit_p(pwm_remove
),
285 .id_table
= pwm_id_table
,
288 static int __init
pwm_init(void)
290 return platform_driver_register(&pwm_driver
);
292 arch_initcall(pwm_init
);
294 static void __exit
pwm_exit(void)
296 platform_driver_unregister(&pwm_driver
);
298 module_exit(pwm_exit
);
300 MODULE_LICENSE("GPL v2");