projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[package] udev: bump to 173
[openwrt.git] / target / linux / s3c24xx / patches-2.6.30 / 011-s3c-pwm.patch
1 --- /dev/null
2 +++ b/arch/arm/plat-s3c/include/plat/pwm.h
3 @@ -0,0 +1,45 @@
4 +#ifndef __S3C2410_PWM_H
5 +#define __S3C2410_PWM_H
6 +
7 +#include <linux/err.h>
8 +#include <linux/platform_device.h>
9 +#include <linux/clk.h>
10 +
11 +#include <mach/io.h>
12 +#include <mach/hardware.h>
13 +#include <asm/mach-types.h>
14 +#include <plat/regs-timer.h>
15 +
16 +enum pwm_timer {
17 + PWM0,
18 + PWM1,
19 + PWM2,
20 + PWM3,
21 + PWM4
22 +};
23 +
24 +struct s3c2410_pwm {
25 + enum pwm_timer timerid;
26 + struct clk *pclk;
27 + unsigned long pclk_rate;
28 + unsigned long prescaler;
29 + unsigned long divider;
30 + unsigned long counter;
31 + unsigned long comparer;
32 +};
33 +
34 +struct s3c24xx_pwm_platform_data{
35 + /* callback to attach platform children (to enforce suspend / resume
36 + * ordering */
37 + void (*attach_child_devices)(struct device *parent_device);
38 +};
39 +
40 +int s3c2410_pwm_init(struct s3c2410_pwm *s3c2410_pwm);
41 +int s3c2410_pwm_enable(struct s3c2410_pwm *s3c2410_pwm);
42 +int s3c2410_pwm_disable(struct s3c2410_pwm *s3c2410_pwm);
43 +int s3c2410_pwm_start(struct s3c2410_pwm *s3c2410_pwm);
44 +int s3c2410_pwm_stop(struct s3c2410_pwm *s3c2410_pwm);
45 +int s3c2410_pwm_duty_cycle(int reg_value, struct s3c2410_pwm *s3c2410_pwm);
46 +int s3c2410_pwm_dumpregs(void);
47 +
48 +#endif /* __S3C2410_PWM_H */
49 --- a/arch/arm/plat-s3c/Kconfig
50 +++ b/arch/arm/plat-s3c/Kconfig
51 @@ -157,6 +157,11 @@ config S3C_DMA
52 help
53 Internal configuration for S3C DMA core
54
55 +config S3C_PWM
56 + bool
57 + help
58 + PWM timer code for the S3C2410, and similar processors
59 +
60 # device definitions to compile in
61
62 config S3C_DEV_HSMMC
63 --- a/arch/arm/plat-s3c/Makefile
64 +++ b/arch/arm/plat-s3c/Makefile
65 @@ -35,5 +35,6 @@ obj-$(CONFIG_S3C_DEV_HSMMC1) += dev-hsmm
66 obj-y += dev-i2c0.o
67 obj-$(CONFIG_S3C_DEV_I2C1) += dev-i2c1.o
68 obj-$(CONFIG_S3C_DEV_FB) += dev-fb.o
69 +obj-$(CONFIG_S3C_PWM) += pwm.o
70 obj-$(CONFIG_S3C_DMA) += dma.o
71
72 --- /dev/null
73 +++ b/arch/arm/plat-s3c/pwm.c
74 @@ -0,0 +1,288 @@
75 +/*
76 + * arch/arm/plat-s3c/pwm.c
77 + *
78 + * Copyright (c) by Javi Roman <javiroman@kernel-labs.org>
79 + * for the Openmoko Project.
80 + *
81 + * S3C2410A SoC PWM support
82 + *
83 + * This program is free software; you can redistribute it and/or modify
84 + * it under the terms of the GNU General Public License as published by
85 + * the Free Software Foundation; either version 2 of the License, or
86 + * (at your option) any later version.
87 + *
88 + * You should have received a copy of the GNU General Public License
89 + * along with this program; if not, write to the Free Software
90 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
91 + *
92 + */
93 +
94 +#include <linux/kernel.h>
95 +#include <linux/init.h>
96 +#include <linux/clk.h>
97 +#include <linux/device.h>
98 +#include <mach/hardware.h>
99 +#include <plat/regs-timer.h>
100 +#include <plat/pwm.h>
101 +#include <asm/io.h>
102 +
103 +#ifdef CONFIG_PM
104 + static unsigned long standby_reg_tcon;
105 + static unsigned long standby_reg_tcfg0;
106 + static unsigned long standby_reg_tcfg1;
107 +#endif
108 +
109 +int s3c2410_pwm_disable(struct s3c2410_pwm *pwm)
110 +{
111 + unsigned long tcon;
112 +
113 + /* stop timer */
114 + tcon = __raw_readl(S3C2410_TCON);
115 + tcon &= 0xffffff00;
116 + __raw_writel(tcon, S3C2410_TCON);
117 +
118 + clk_disable(pwm->pclk);
119 + clk_put(pwm->pclk);
120 +
121 + return 0;
122 +}
123 +EXPORT_SYMBOL_GPL(s3c2410_pwm_disable);
124 +
125 +int s3c2410_pwm_init(struct s3c2410_pwm *pwm)
126 +{
127 + pwm->pclk = clk_get(NULL, "timers");
128 + if (IS_ERR(pwm->pclk))
129 + return PTR_ERR(pwm->pclk);
130 +
131 + clk_enable(pwm->pclk);
132 + pwm->pclk_rate = clk_get_rate(pwm->pclk);
133 + return 0;
134 +}
135 +EXPORT_SYMBOL_GPL(s3c2410_pwm_init);
136 +
137 +int s3c2410_pwm_enable(struct s3c2410_pwm *pwm)
138 +{
139 + unsigned long tcfg0, tcfg1, tcnt, tcmp;
140 +
141 + /* control registers bits */
142 + tcfg1 = __raw_readl(S3C2410_TCFG1);
143 + tcfg0 = __raw_readl(S3C2410_TCFG0);
144 +
145 + /* divider & scaler slection */
146 + switch (pwm->timerid) {
147 + case PWM0:
148 + tcfg1 &= ~S3C2410_TCFG1_MUX0_MASK;
149 + tcfg0 &= ~S3C2410_TCFG_PRESCALER0_MASK;
150 + break;
151 + case PWM1:
152 + tcfg1 &= ~S3C2410_TCFG1_MUX1_MASK;
153 + tcfg0 &= ~S3C2410_TCFG_PRESCALER0_MASK;
154 + break;
155 + case PWM2:
156 + tcfg1 &= ~S3C2410_TCFG1_MUX2_MASK;
157 + tcfg0 &= ~S3C2410_TCFG_PRESCALER1_MASK;
158 + break;
159 + case PWM3:
160 + tcfg1 &= ~S3C2410_TCFG1_MUX3_MASK;
161 + tcfg0 &= ~S3C2410_TCFG_PRESCALER1_MASK;
162 + break;
163 + case PWM4:
164 + /* timer four is not capable of doing PWM */
165 + break;
166 + default:
167 + clk_disable(pwm->pclk);
168 + clk_put(pwm->pclk);
169 + return -1;
170 + }
171 +
172 + /* divider & scaler values */
173 + tcfg1 |= pwm->divider;
174 + __raw_writel(tcfg1, S3C2410_TCFG1);
175 +
176 + switch (pwm->timerid) {
177 + case PWM0:
178 + case PWM1:
179 + tcfg0 |= pwm->prescaler;
180 + __raw_writel(tcfg0, S3C2410_TCFG0);
181 + break;
182 + default:
183 + if ((tcfg0 | pwm->prescaler) != tcfg0) {
184 + printk(KERN_WARNING "not changing prescaler of PWM %u,"
185 + " since it's shared with timer4 (clock tick)\n",
186 + pwm->timerid);
187 + }
188 + break;
189 + }
190 +
191 + /* timer count and compare buffer initial values */
192 + tcnt = pwm->counter;
193 + tcmp = pwm->comparer;
194 +
195 + __raw_writel(tcnt, S3C2410_TCNTB(pwm->timerid));
196 + __raw_writel(tcmp, S3C2410_TCMPB(pwm->timerid));
197 +
198 + /* ensure timer is stopped */
199 + s3c2410_pwm_stop(pwm);
200 +
201 + return 0;
202 +}
203 +EXPORT_SYMBOL_GPL(s3c2410_pwm_enable);
204 +
205 +int s3c2410_pwm_start(struct s3c2410_pwm *pwm)
206 +{
207 + unsigned long tcon;
208 +
209 + tcon = __raw_readl(S3C2410_TCON);
210 +
211 + switch (pwm->timerid) {
212 + case PWM0:
213 + tcon |= S3C2410_TCON_T0START;
214 + tcon &= ~S3C2410_TCON_T0MANUALUPD;
215 + break;
216 + case PWM1:
217 + tcon |= S3C2410_TCON_T1START;
218 + tcon &= ~S3C2410_TCON_T1MANUALUPD;
219 + break;
220 + case PWM2:
221 + tcon |= S3C2410_TCON_T2START;
222 + tcon &= ~S3C2410_TCON_T2MANUALUPD;
223 + break;
224 + case PWM3:
225 + tcon |= S3C2410_TCON_T3START;
226 + tcon &= ~S3C2410_TCON_T3MANUALUPD;
227 + break;
228 + case PWM4:
229 + /* timer four is not capable of doing PWM */
230 + default:
231 + return -ENODEV;
232 + }
233 +
234 + __raw_writel(tcon, S3C2410_TCON);
235 +
236 + return 0;
237 +}
238 +EXPORT_SYMBOL_GPL(s3c2410_pwm_start);
239 +
240 +int s3c2410_pwm_stop(struct s3c2410_pwm *pwm)
241 +{
242 + unsigned long tcon;
243 +
244 + tcon = __raw_readl(S3C2410_TCON);
245 +
246 + switch (pwm->timerid) {
247 + case PWM0:
248 + tcon &= ~0x00000000;
249 + tcon |= S3C2410_TCON_T0RELOAD;
250 + tcon |= S3C2410_TCON_T0MANUALUPD;
251 + break;
252 + case PWM1:
253 + tcon &= ~0x00000080;
254 + tcon |= S3C2410_TCON_T1RELOAD;
255 + tcon |= S3C2410_TCON_T1MANUALUPD;
256 + break;
257 + case PWM2:
258 + tcon &= ~0x00000800;
259 + tcon |= S3C2410_TCON_T2RELOAD;
260 + tcon |= S3C2410_TCON_T2MANUALUPD;
261 + break;
262 + case PWM3:
263 + tcon &= ~0x00008000;
264 + tcon |= S3C2410_TCON_T3RELOAD;
265 + tcon |= S3C2410_TCON_T3MANUALUPD;
266 + break;
267 + case PWM4:
268 + /* timer four is not capable of doing PWM */
269 + default:
270 + return -ENODEV;
271 + }
272 +
273 + __raw_writel(tcon, S3C2410_TCON);
274 +
275 + return 0;
276 +}
277 +EXPORT_SYMBOL_GPL(s3c2410_pwm_stop);
278 +
279 +int s3c2410_pwm_duty_cycle(int reg_value, struct s3c2410_pwm *pwm)
280 +{
281 + __raw_writel(reg_value, S3C2410_TCMPB(pwm->timerid));
282 +
283 + return 0;
284 +}
285 +EXPORT_SYMBOL_GPL(s3c2410_pwm_duty_cycle);
286 +
287 +int s3c2410_pwm_dumpregs(void)
288 +{
289 + printk(KERN_INFO "TCON: %08lx, TCFG0: %08lx, TCFG1: %08lx\n",
290 + (unsigned long) __raw_readl(S3C2410_TCON),
291 + (unsigned long) __raw_readl(S3C2410_TCFG0),
292 + (unsigned long) __raw_readl(S3C2410_TCFG1));
293 +
294 + return 0;
295 +}
296 +EXPORT_SYMBOL_GPL(s3c2410_pwm_dumpregs);
297 +
298 +static int __init s3c24xx_pwm_probe(struct platform_device *pdev)
299 +{
300 + struct s3c24xx_pwm_platform_data *pdata = pdev->dev.platform_data;
301 +
302 + dev_info(&pdev->dev, "s3c24xx_pwm is registered \n");
303 +
304 + /* if platform was interested, give him a chance to register
305 + * platform devices that switch power with us as the parent
306 + * at registration time -- ensures suspend / resume ordering
307 + */
308 + if (pdata)
309 + if (pdata->attach_child_devices)
310 + (pdata->attach_child_devices)(&pdev->dev);
311 +
312 + return 0;
313 +}
314 +
315 +#ifdef CONFIG_PM
316 +static int s3c24xx_pwm_suspend(struct platform_device *pdev, pm_message_t state)
317 +{
318 + /* PWM config should be kept in suspending */
319 + standby_reg_tcon = __raw_readl(S3C2410_TCON);
320 + standby_reg_tcfg0 = __raw_readl(S3C2410_TCFG0);
321 + standby_reg_tcfg1 = __raw_readl(S3C2410_TCFG1);
322 +
323 + return 0;
324 +}
325 +
326 +static int s3c24xx_pwm_resume(struct platform_device *pdev)
327 +{
328 + __raw_writel(standby_reg_tcon, S3C2410_TCON);
329 + __raw_writel(standby_reg_tcfg0, S3C2410_TCFG0);
330 + __raw_writel(standby_reg_tcfg1, S3C2410_TCFG1);
331 +
332 + return 0;
333 +}
334 +#else
335 +#define s3c24xx_pwm_suspend NULL
336 +#define s3c24xx_pwm_resume NULL
337 +#endif
338 +
339 +static struct platform_driver s3c24xx_pwm_driver = {
340 + .driver = {
341 + .name = "s3c24xx_pwm",
342 + .owner = THIS_MODULE,
343 + },
344 + .probe = s3c24xx_pwm_probe,
345 + .suspend = s3c24xx_pwm_suspend,
346 + .resume = s3c24xx_pwm_resume,
347 +};
348 +
349 +static int __init s3c24xx_pwm_init(void)
350 +{
351 + return platform_driver_register(&s3c24xx_pwm_driver);
352 +}
353 +
354 +static void __exit s3c24xx_pwm_exit(void)
355 +{
356 +}
357 +
358 +MODULE_AUTHOR("Javi Roman <javiroman@kernel-labs.org>");
359 +MODULE_LICENSE("GPL");
360 +
361 +module_init(s3c24xx_pwm_init);
362 +module_exit(s3c24xx_pwm_exit);
363 --- /dev/null
364 +++ b/arch/arm/plat-s3c24xx/pwm-clock.c
365 @@ -0,0 +1,437 @@
366 +/* linux/arch/arm/plat-s3c24xx/pwm-clock.c
367 + *
368 + * Copyright (c) 2007 Simtec Electronics
369 + * Copyright (c) 2007, 2008 Ben Dooks
370 + * Ben Dooks <ben-linux@fluff.org>
371 + *
372 + * This program is free software; you can redistribute it and/or modify
373 + * it under the terms of the GNU General Public License as published by
374 + * the Free Software Foundation; either version 2 of the License.
375 +*/
376 +
377 +#include <linux/init.h>
378 +#include <linux/module.h>
379 +#include <linux/kernel.h>
380 +#include <linux/list.h>
381 +#include <linux/errno.h>
382 +#include <linux/clk.h>
383 +#include <linux/err.h>
384 +#include <linux/io.h>
385 +
386 +#include <mach/hardware.h>
387 +#include <asm/irq.h>
388 +
389 +#include <mach/regs-clock.h>
390 +#include <mach/regs-gpio.h>
391 +
392 +#include <asm/plat-s3c24xx/clock.h>
393 +#include <asm/plat-s3c24xx/cpu.h>
394 +
395 +#include <asm/plat-s3c/regs-timer.h>
396 +
397 +/* Each of the timers 0 through 5 go through the following
398 + * clock tree, with the inputs depending on the timers.
399 + *
400 + * pclk ---- [ prescaler 0 ] -+---> timer 0
401 + * +---> timer 1
402 + *
403 + * pclk ---- [ prescaler 1 ] -+---> timer 2
404 + * +---> timer 3
405 + * \---> timer 4
406 + *
407 + * Which are fed into the timers as so:
408 + *
409 + * prescaled 0 ---- [ div 2,4,8,16 ] ---\
410 + * [mux] -> timer 0
411 + * tclk 0 ------------------------------/
412 + *
413 + * prescaled 0 ---- [ div 2,4,8,16 ] ---\
414 + * [mux] -> timer 1
415 + * tclk 0 ------------------------------/
416 + *
417 + *
418 + * prescaled 1 ---- [ div 2,4,8,16 ] ---\
419 + * [mux] -> timer 2
420 + * tclk 1 ------------------------------/
421 + *
422 + * prescaled 1 ---- [ div 2,4,8,16 ] ---\
423 + * [mux] -> timer 3
424 + * tclk 1 ------------------------------/
425 + *
426 + * prescaled 1 ---- [ div 2,4,8, 16 ] --\
427 + * [mux] -> timer 4
428 + * tclk 1 ------------------------------/
429 + *
430 + * Since the mux and the divider are tied together in the
431 + * same register space, it is impossible to set the parent
432 + * and the rate at the same time. To avoid this, we add an
433 + * intermediate 'prescaled-and-divided' clock to select
434 + * as the parent for the timer input clock called tdiv.
435 + *
436 + * prescaled clk --> pwm-tdiv ---\
437 + * [ mux ] --> timer X
438 + * tclk -------------------------/
439 +*/
440 +
441 +static unsigned long clk_pwm_scaler_getrate(struct clk *clk)
442 +{
443 + unsigned long tcfg0 = __raw_readl(S3C2410_TCFG0);
444 +
445 + if (clk->id == 1) {
446 + tcfg0 &= S3C2410_TCFG_PRESCALER1_MASK;
447 + tcfg0 >>= S3C2410_TCFG_PRESCALER1_SHIFT;
448 + } else {
449 + tcfg0 &= S3C2410_TCFG_PRESCALER0_MASK;
450 + }
451 +
452 + return clk_get_rate(clk->parent) / (tcfg0 + 1);
453 +}
454 +
455 +/* TODO - add set rate calls. */
456 +
457 +static struct clk clk_timer_scaler[] = {
458 + [0] = {
459 + .name = "pwm-scaler0",
460 + .id = -1,
461 + .get_rate = clk_pwm_scaler_getrate,
462 + },
463 + [1] = {
464 + .name = "pwm-scaler1",
465 + .id = -1,
466 + .get_rate = clk_pwm_scaler_getrate,
467 + },
468 +};
469 +
470 +static struct clk clk_timer_tclk[] = {
471 + [0] = {
472 + .name = "pwm-tclk0",
473 + .id = -1,
474 + },
475 + [1] = {
476 + .name = "pwm-tclk1",
477 + .id = -1,
478 + },
479 +};
480 +
481 +struct pwm_tdiv_clk {
482 + struct clk clk;
483 + unsigned int divisor;
484 +};
485 +
486 +static inline struct pwm_tdiv_clk *to_tdiv(struct clk *clk)
487 +{
488 + return container_of(clk, struct pwm_tdiv_clk, clk);
489 +}
490 +
491 +static inline unsigned long tcfg_to_divisor(unsigned long tcfg1)
492 +{
493 + return 1 << (1 + tcfg1);
494 +}
495 +
496 +static unsigned long clk_pwm_tdiv_get_rate(struct clk *clk)
497 +{
498 + unsigned long tcfg1 = __raw_readl(S3C2410_TCFG1);
499 + unsigned int divisor;
500 +
501 + tcfg1 >>= S3C2410_TCFG1_SHIFT(clk->id);
502 + tcfg1 &= S3C2410_TCFG1_MUX_MASK;
503 +
504 + if (tcfg1 == S3C2410_TCFG1_MUX_TCLK)
505 + divisor = to_tdiv(clk)->divisor;
506 + else
507 + divisor = tcfg_to_divisor(tcfg1);
508 +
509 + return clk_get_rate(clk->parent) / divisor;
510 +}
511 +
512 +static unsigned long clk_pwm_tdiv_round_rate(struct clk *clk,
513 + unsigned long rate)
514 +{
515 + unsigned long parent_rate;
516 + unsigned long divisor;
517 +
518 + parent_rate = clk_get_rate(clk->parent);
519 + divisor = parent_rate / rate;
520 +
521 + if (divisor <= 2)
522 + divisor = 2;
523 + else if (divisor <= 4)
524 + divisor = 4;
525 + else if (divisor <= 8)
526 + divisor = 8;
527 + else
528 + divisor = 16;
529 +
530 + return parent_rate / divisor;
531 +}
532 +
533 +static unsigned long clk_pwm_tdiv_bits(struct pwm_tdiv_clk *divclk)
534 +{
535 + unsigned long bits;
536 +
537 + switch (divclk->divisor) {
538 + case 2:
539 + bits = S3C2410_TCFG1_MUX_DIV2;
540 + break;
541 + case 4:
542 + bits = S3C2410_TCFG1_MUX_DIV4;
543 + break;
544 + case 8:
545 + bits = S3C2410_TCFG1_MUX_DIV8;
546 + break;
547 + case 16:
548 + default:
549 + bits = S3C2410_TCFG1_MUX_DIV16;
550 + break;
551 + }
552 +
553 + return bits;
554 +}
555 +
556 +static void clk_pwm_tdiv_update(struct pwm_tdiv_clk *divclk)
557 +{
558 + unsigned long tcfg1 = __raw_readl(S3C2410_TCFG1);
559 + unsigned long bits = clk_pwm_tdiv_bits(divclk);
560 + unsigned long flags;
561 + unsigned long shift = S3C2410_TCFG1_SHIFT(divclk->clk.id);
562 +
563 + local_irq_save(flags);
564 +
565 + tcfg1 = __raw_readl(S3C2410_TCFG1);
566 + tcfg1 &= ~(S3C2410_TCFG1_MUX_MASK << shift);
567 + tcfg1 |= bits << shift;
568 + __raw_writel(tcfg1, S3C2410_TCFG1);
569 +
570 + local_irq_restore(flags);
571 +}
572 +
573 +static int clk_pwm_tdiv_set_rate(struct clk *clk, unsigned long rate)
574 +{
575 + struct pwm_tdiv_clk *divclk = to_tdiv(clk);
576 + unsigned long tcfg1 = __raw_readl(S3C2410_TCFG1);
577 + unsigned long parent_rate = clk_get_rate(clk->parent);
578 + unsigned long divisor;
579 +
580 + tcfg1 >>= S3C2410_TCFG1_SHIFT(clk->id);
581 + tcfg1 &= S3C2410_TCFG1_MUX_MASK;
582 +
583 + rate = clk_round_rate(clk, rate);
584 + divisor = parent_rate / rate;
585 +
586 + if (divisor > 16)
587 + return -EINVAL;
588 +
589 + divclk->divisor = divisor;
590 +
591 + /* Update the current MUX settings if we are currently
592 + * selected as the clock source for this clock. */
593 +
594 + if (tcfg1 != S3C2410_TCFG1_MUX_TCLK)
595 + clk_pwm_tdiv_update(divclk);
596 +
597 + return 0;
598 +}
599 +
600 +static struct pwm_tdiv_clk clk_timer_tdiv[] = {
601 + [0] = {
602 + .clk = {
603 + .name = "pwm-tdiv",
604 + .parent = &clk_timer_scaler[0],
605 + .get_rate = clk_pwm_tdiv_get_rate,
606 + .set_rate = clk_pwm_tdiv_set_rate,
607 + .round_rate = clk_pwm_tdiv_round_rate,
608 + },
609 + },
610 + [1] = {
611 + .clk = {
612 + .name = "pwm-tdiv",
613 + .parent = &clk_timer_scaler[0],
614 + .get_rate = clk_pwm_tdiv_get_rate,
615 + .set_rate = clk_pwm_tdiv_set_rate,
616 + .round_rate = clk_pwm_tdiv_round_rate,
617 + }
618 + },
619 + [2] = {
620 + .clk = {
621 + .name = "pwm-tdiv",
622 + .parent = &clk_timer_scaler[1],
623 + .get_rate = clk_pwm_tdiv_get_rate,
624 + .set_rate = clk_pwm_tdiv_set_rate,
625 + .round_rate = clk_pwm_tdiv_round_rate,
626 + },
627 + },
628 + [3] = {
629 + .clk = {
630 + .name = "pwm-tdiv",
631 + .parent = &clk_timer_scaler[1],
632 + .get_rate = clk_pwm_tdiv_get_rate,
633 + .set_rate = clk_pwm_tdiv_set_rate,
634 + .round_rate = clk_pwm_tdiv_round_rate,
635 + },
636 + },
637 + [4] = {
638 + .clk = {
639 + .name = "pwm-tdiv",
640 + .parent = &clk_timer_scaler[1],
641 + .get_rate = clk_pwm_tdiv_get_rate,
642 + .set_rate = clk_pwm_tdiv_set_rate,
643 + .round_rate = clk_pwm_tdiv_round_rate,
644 + },
645 + },
646 +};
647 +
648 +static int __init clk_pwm_tdiv_register(unsigned int id)
649 +{
650 + struct pwm_tdiv_clk *divclk = &clk_timer_tdiv[id];
651 + unsigned long tcfg1 = __raw_readl(S3C2410_TCFG1);
652 +
653 + tcfg1 >>= S3C2410_TCFG1_SHIFT(id);
654 + tcfg1 &= S3C2410_TCFG1_MUX_MASK;
655 +
656 + divclk->clk.id = id;
657 + divclk->divisor = tcfg_to_divisor(tcfg1);
658 +
659 + return s3c24xx_register_clock(&divclk->clk);
660 +}
661 +
662 +static inline struct clk *s3c24xx_pwmclk_tclk(unsigned int id)
663 +{
664 + return (id >= 2) ? &clk_timer_tclk[1] : &clk_timer_tclk[0];
665 +}
666 +
667 +static inline struct clk *s3c24xx_pwmclk_tdiv(unsigned int id)
668 +{
669 + return &clk_timer_tdiv[id].clk;
670 +}
671 +
672 +static int clk_pwm_tin_set_parent(struct clk *clk, struct clk *parent)
673 +{
674 + unsigned int id = clk->id;
675 + unsigned long tcfg1;
676 + unsigned long flags;
677 + unsigned long bits;
678 + unsigned long shift = S3C2410_TCFG1_SHIFT(id);
679 +
680 + if (parent == s3c24xx_pwmclk_tclk(id))
681 + bits = S3C2410_TCFG1_MUX_TCLK << shift;
682 + else if (parent == s3c24xx_pwmclk_tdiv(id))
683 + bits = clk_pwm_tdiv_bits(to_tdiv(parent)) << shift;
684 + else
685 + return -EINVAL;
686 +
687 + clk->parent = parent;
688 +
689 + local_irq_save(flags);
690 +
691 + tcfg1 = __raw_readl(S3C2410_TCFG1);
692 + tcfg1 &= ~(S3C2410_TCFG1_MUX_MASK << shift);
693 + __raw_writel(tcfg1 | bits, S3C2410_TCFG1);
694 +
695 + local_irq_restore(flags);
696 +
697 + return 0;
698 +}
699 +
700 +static struct clk clk_tin[] = {
701 + [0] = {
702 + .name = "pwm-tin",
703 + .id = 0,
704 + .set_parent = clk_pwm_tin_set_parent,
705 + },
706 + [1] = {
707 + .name = "pwm-tin",
708 + .id = 1,
709 + .set_parent = clk_pwm_tin_set_parent,
710 + },
711 + [2] = {
712 + .name = "pwm-tin",
713 + .id = 2,
714 + .set_parent = clk_pwm_tin_set_parent,
715 + },
716 + [3] = {
717 + .name = "pwm-tin",
718 + .id = 3,
719 + .set_parent = clk_pwm_tin_set_parent,
720 + },
721 + [4] = {
722 + .name = "pwm-tin",
723 + .id = 4,
724 + .set_parent = clk_pwm_tin_set_parent,
725 + },
726 +};
727 +
728 +static __init int clk_pwm_tin_register(struct clk *pwm)
729 +{
730 + unsigned long tcfg1 = __raw_readl(S3C2410_TCFG1);
731 + unsigned int id = pwm->id;
732 +
733 + struct clk *parent;
734 + int ret;
735 +
736 + ret = s3c24xx_register_clock(pwm);
737 + if (ret < 0)
738 + return ret;
739 +
740 + tcfg1 >>= S3C2410_TCFG1_SHIFT(id);
741 + tcfg1 &= S3C2410_TCFG1_MUX_MASK;
742 +
743 + if (tcfg1 == S3C2410_TCFG1_MUX_TCLK)
744 + parent = s3c24xx_pwmclk_tclk(id);
745 + else
746 + parent = s3c24xx_pwmclk_tdiv(id);
747 +
748 + return clk_set_parent(pwm, parent);
749 +}
750 +
751 +static __init int s3c24xx_pwmclk_init(void)
752 +{
753 + struct clk *clk_timers;
754 + unsigned int clk;
755 + int ret;
756 +
757 + clk_timers = clk_get(NULL, "timers");
758 + if (IS_ERR(clk_timers)) {
759 + printk(KERN_ERR "%s: no parent clock\n", __func__);
760 + return -EINVAL;
761 + }
762 +
763 + for (clk = 0; clk < ARRAY_SIZE(clk_timer_scaler); clk++) {
764 + clk_timer_scaler[clk].parent = clk_timers;
765 + ret = s3c24xx_register_clock(&clk_timer_scaler[clk]);
766 + if (ret < 0) {
767 + printk(KERN_ERR "error adding pwm scaler%d clock\n", clk);
768 + goto err;
769 + }
770 + }
771 +
772 + for (clk = 0; clk < ARRAY_SIZE(clk_timer_tclk); clk++) {
773 + ret = s3c24xx_register_clock(&clk_timer_tclk[clk]);
774 + if (ret < 0) {
775 + printk(KERN_ERR "error adding pww tclk%d\n", clk);
776 + goto err;
777 + }
778 + }
779 +
780 + for (clk = 0; clk < ARRAY_SIZE(clk_timer_tdiv); clk++) {
781 + ret = clk_pwm_tdiv_register(clk);
782 + if (ret < 0) {
783 + printk(KERN_ERR "error adding pwm%d tdiv clock\n", clk);
784 + goto err;
785 + }
786 + }
787 +
788 + for (clk = 0; clk < ARRAY_SIZE(clk_tin); clk++) {
789 + ret = clk_pwm_tin_register(&clk_tin[clk]);
790 + if (ret < 0) {
791 + printk(KERN_ERR "error adding pwm%d tin clock\n", clk);
792 + goto err;
793 + }
794 + }
795 +
796 + return 0;
797 +
798 + err:
799 + return ret;
800 +}
801 +
802 +arch_initcall(s3c24xx_pwmclk_init);
Personal OpenWRT clone
This page took 0.090244 seconds and 5 git commands to generate.