Merge branches 'release', 'acpica', 'bugzilla-10224', 'bugzilla-9772', 'bugzilla...
[linux-2.6] / arch / arm / mach-omap2 / clock.c
1 /*
2  *  linux/arch/arm/mach-omap2/clock.c
3  *
4  *  Copyright (C) 2005-2008 Texas Instruments, Inc.
5  *  Copyright (C) 2004-2008 Nokia Corporation
6  *
7  *  Contacts:
8  *  Richard Woodruff <r-woodruff2@ti.com>
9  *  Paul Walmsley
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License version 2 as
13  * published by the Free Software Foundation.
14  */
15 #undef DEBUG
16
17 #include <linux/module.h>
18 #include <linux/kernel.h>
19 #include <linux/device.h>
20 #include <linux/list.h>
21 #include <linux/errno.h>
22 #include <linux/delay.h>
23 #include <linux/clk.h>
24 #include <asm/bitops.h>
25
26 #include <asm/io.h>
27
28 #include <asm/arch/clock.h>
29 #include <asm/arch/sram.h>
30 #include <asm/arch/cpu.h>
31 #include <asm/div64.h>
32
33 #include "memory.h"
34 #include "sdrc.h"
35 #include "clock.h"
36 #include "prm.h"
37 #include "prm-regbits-24xx.h"
38 #include "cm.h"
39 #include "cm-regbits-24xx.h"
40 #include "cm-regbits-34xx.h"
41
42 #define MAX_CLOCK_ENABLE_WAIT           100000
43
44 u8 cpu_mask;
45
46 /*-------------------------------------------------------------------------
47  * Omap2 specific clock functions
48  *-------------------------------------------------------------------------*/
49
50 /**
51  * omap2_init_clksel_parent - set a clksel clk's parent field from the hardware
52  * @clk: OMAP clock struct ptr to use
53  *
54  * Given a pointer to a source-selectable struct clk, read the hardware
55  * register and determine what its parent is currently set to.  Update the
56  * clk->parent field with the appropriate clk ptr.
57  */
58 void omap2_init_clksel_parent(struct clk *clk)
59 {
60         const struct clksel *clks;
61         const struct clksel_rate *clkr;
62         u32 r, found = 0;
63
64         if (!clk->clksel)
65                 return;
66
67         r = __raw_readl(clk->clksel_reg) & clk->clksel_mask;
68         r >>= __ffs(clk->clksel_mask);
69
70         for (clks = clk->clksel; clks->parent && !found; clks++) {
71                 for (clkr = clks->rates; clkr->div && !found; clkr++) {
72                         if ((clkr->flags & cpu_mask) && (clkr->val == r)) {
73                                 if (clk->parent != clks->parent) {
74                                         pr_debug("clock: inited %s parent "
75                                                  "to %s (was %s)\n",
76                                                  clk->name, clks->parent->name,
77                                                  ((clk->parent) ?
78                                                   clk->parent->name : "NULL"));
79                                         clk->parent = clks->parent;
80                                 };
81                                 found = 1;
82                         }
83                 }
84         }
85
86         if (!found)
87                 printk(KERN_ERR "clock: init parent: could not find "
88                        "regval %0x for clock %s\n", r,  clk->name);
89
90         return;
91 }
92
93 /* Returns the DPLL rate */
94 u32 omap2_get_dpll_rate(struct clk *clk)
95 {
96         long long dpll_clk;
97         u32 dpll_mult, dpll_div, dpll;
98         const struct dpll_data *dd;
99
100         dd = clk->dpll_data;
101         /* REVISIT: What do we return on error? */
102         if (!dd)
103                 return 0;
104
105         dpll = __raw_readl(dd->mult_div1_reg);
106         dpll_mult = dpll & dd->mult_mask;
107         dpll_mult >>= __ffs(dd->mult_mask);
108         dpll_div = dpll & dd->div1_mask;
109         dpll_div >>= __ffs(dd->div1_mask);
110
111         dpll_clk = (long long)clk->parent->rate * dpll_mult;
112         do_div(dpll_clk, dpll_div + 1);
113
114         return dpll_clk;
115 }
116
117 /*
118  * Used for clocks that have the same value as the parent clock,
119  * divided by some factor
120  */
121 void omap2_fixed_divisor_recalc(struct clk *clk)
122 {
123         WARN_ON(!clk->fixed_div);
124
125         clk->rate = clk->parent->rate / clk->fixed_div;
126
127         if (clk->flags & RATE_PROPAGATES)
128                 propagate_rate(clk);
129 }
130
131 /**
132  * omap2_wait_clock_ready - wait for clock to enable
133  * @reg: physical address of clock IDLEST register
134  * @mask: value to mask against to determine if the clock is active
135  * @name: name of the clock (for printk)
136  *
137  * Returns 1 if the clock enabled in time, or 0 if it failed to enable
138  * in roughly MAX_CLOCK_ENABLE_WAIT microseconds.
139  */
140 int omap2_wait_clock_ready(void __iomem *reg, u32 mask, const char *name)
141 {
142         int i = 0;
143         int ena = 0;
144
145         /*
146          * 24xx uses 0 to indicate not ready, and 1 to indicate ready.
147          * 34xx reverses this, just to keep us on our toes
148          */
149         if (cpu_mask & (RATE_IN_242X | RATE_IN_243X)) {
150                 ena = mask;
151         } else if (cpu_mask & RATE_IN_343X) {
152                 ena = 0;
153         }
154
155         /* Wait for lock */
156         while (((__raw_readl(reg) & mask) != ena) &&
157                (i++ < MAX_CLOCK_ENABLE_WAIT)) {
158                 udelay(1);
159         }
160
161         if (i < MAX_CLOCK_ENABLE_WAIT)
162                 pr_debug("Clock %s stable after %d loops\n", name, i);
163         else
164                 printk(KERN_ERR "Clock %s didn't enable in %d tries\n",
165                        name, MAX_CLOCK_ENABLE_WAIT);
166
167
168         return (i < MAX_CLOCK_ENABLE_WAIT) ? 1 : 0;
169 };
170
171
172 /*
173  * Note: We don't need special code here for INVERT_ENABLE
174  * for the time being since INVERT_ENABLE only applies to clocks enabled by
175  * CM_CLKEN_PLL
176  */
177 static void omap2_clk_wait_ready(struct clk *clk)
178 {
179         void __iomem *reg, *other_reg, *st_reg;
180         u32 bit;
181
182         /*
183          * REVISIT: This code is pretty ugly.  It would be nice to generalize
184          * it and pull it into struct clk itself somehow.
185          */
186         reg = clk->enable_reg;
187         if ((((u32)reg & 0xff) >= CM_FCLKEN1) &&
188             (((u32)reg & 0xff) <= OMAP24XX_CM_FCLKEN2))
189                 other_reg = (void __iomem *)(((u32)reg & ~0xf0) | 0x10); /* CM_ICLKEN* */
190         else if ((((u32)reg & 0xff) >= CM_ICLKEN1) &&
191                  (((u32)reg & 0xff) <= OMAP24XX_CM_ICLKEN4))
192                 other_reg = (void __iomem *)(((u32)reg & ~0xf0) | 0x00); /* CM_FCLKEN* */
193         else
194                 return;
195
196         /* REVISIT: What are the appropriate exclusions for 34XX? */
197         /* No check for DSS or cam clocks */
198         if (cpu_is_omap24xx() && ((u32)reg & 0x0f) == 0) { /* CM_{F,I}CLKEN1 */
199                 if (clk->enable_bit == OMAP24XX_EN_DSS2_SHIFT ||
200                     clk->enable_bit == OMAP24XX_EN_DSS1_SHIFT ||
201                     clk->enable_bit == OMAP24XX_EN_CAM_SHIFT)
202                         return;
203         }
204
205         /* REVISIT: What are the appropriate exclusions for 34XX? */
206         /* OMAP3: ignore DSS-mod clocks */
207         if (cpu_is_omap34xx() &&
208             (((u32)reg & ~0xff) == (u32)OMAP_CM_REGADDR(OMAP3430_DSS_MOD, 0)))
209                 return;
210
211         /* Check if both functional and interface clocks
212          * are running. */
213         bit = 1 << clk->enable_bit;
214         if (!(__raw_readl(other_reg) & bit))
215                 return;
216         st_reg = (void __iomem *)(((u32)other_reg & ~0xf0) | 0x20); /* CM_IDLEST* */
217
218         omap2_wait_clock_ready(st_reg, bit, clk->name);
219 }
220
221 /* Enables clock without considering parent dependencies or use count
222  * REVISIT: Maybe change this to use clk->enable like on omap1?
223  */
224 int _omap2_clk_enable(struct clk *clk)
225 {
226         u32 regval32;
227
228         if (clk->flags & (ALWAYS_ENABLED | PARENT_CONTROLS_CLOCK))
229                 return 0;
230
231         if (clk->enable)
232                 return clk->enable(clk);
233
234         if (unlikely(clk->enable_reg == 0)) {
235                 printk(KERN_ERR "clock.c: Enable for %s without enable code\n",
236                        clk->name);
237                 return 0; /* REVISIT: -EINVAL */
238         }
239
240         regval32 = __raw_readl(clk->enable_reg);
241         if (clk->flags & INVERT_ENABLE)
242                 regval32 &= ~(1 << clk->enable_bit);
243         else
244                 regval32 |= (1 << clk->enable_bit);
245         __raw_writel(regval32, clk->enable_reg);
246         wmb();
247
248         omap2_clk_wait_ready(clk);
249
250         return 0;
251 }
252
253 /* Disables clock without considering parent dependencies or use count */
254 void _omap2_clk_disable(struct clk *clk)
255 {
256         u32 regval32;
257
258         if (clk->flags & (ALWAYS_ENABLED | PARENT_CONTROLS_CLOCK))
259                 return;
260
261         if (clk->disable) {
262                 clk->disable(clk);
263                 return;
264         }
265
266         if (clk->enable_reg == 0) {
267                 /*
268                  * 'Independent' here refers to a clock which is not
269                  * controlled by its parent.
270                  */
271                 printk(KERN_ERR "clock: clk_disable called on independent "
272                        "clock %s which has no enable_reg\n", clk->name);
273                 return;
274         }
275
276         regval32 = __raw_readl(clk->enable_reg);
277         if (clk->flags & INVERT_ENABLE)
278                 regval32 |= (1 << clk->enable_bit);
279         else
280                 regval32 &= ~(1 << clk->enable_bit);
281         __raw_writel(regval32, clk->enable_reg);
282         wmb();
283 }
284
285 void omap2_clk_disable(struct clk *clk)
286 {
287         if (clk->usecount > 0 && !(--clk->usecount)) {
288                 _omap2_clk_disable(clk);
289                 if (likely((u32)clk->parent))
290                         omap2_clk_disable(clk->parent);
291         }
292 }
293
294 int omap2_clk_enable(struct clk *clk)
295 {
296         int ret = 0;
297
298         if (clk->usecount++ == 0) {
299                 if (likely((u32)clk->parent))
300                         ret = omap2_clk_enable(clk->parent);
301
302                 if (unlikely(ret != 0)) {
303                         clk->usecount--;
304                         return ret;
305                 }
306
307                 ret = _omap2_clk_enable(clk);
308
309                 if (unlikely(ret != 0) && clk->parent) {
310                         omap2_clk_disable(clk->parent);
311                         clk->usecount--;
312                 }
313         }
314
315         return ret;
316 }
317
318 /*
319  * Used for clocks that are part of CLKSEL_xyz governed clocks.
320  * REVISIT: Maybe change to use clk->enable() functions like on omap1?
321  */
322 void omap2_clksel_recalc(struct clk *clk)
323 {
324         u32 div = 0;
325
326         pr_debug("clock: recalc'ing clksel clk %s\n", clk->name);
327
328         div = omap2_clksel_get_divisor(clk);
329         if (div == 0)
330                 return;
331
332         if (unlikely(clk->rate == clk->parent->rate / div))
333                 return;
334         clk->rate = clk->parent->rate / div;
335
336         pr_debug("clock: new clock rate is %ld (div %d)\n", clk->rate, div);
337
338         if (unlikely(clk->flags & RATE_PROPAGATES))
339                 propagate_rate(clk);
340 }
341
342 /**
343  * omap2_get_clksel_by_parent - return clksel struct for a given clk & parent
344  * @clk: OMAP struct clk ptr to inspect
345  * @src_clk: OMAP struct clk ptr of the parent clk to search for
346  *
347  * Scan the struct clksel array associated with the clock to find
348  * the element associated with the supplied parent clock address.
349  * Returns a pointer to the struct clksel on success or NULL on error.
350  */
351 const struct clksel *omap2_get_clksel_by_parent(struct clk *clk,
352                                                 struct clk *src_clk)
353 {
354         const struct clksel *clks;
355
356         if (!clk->clksel)
357                 return NULL;
358
359         for (clks = clk->clksel; clks->parent; clks++) {
360                 if (clks->parent == src_clk)
361                         break; /* Found the requested parent */
362         }
363
364         if (!clks->parent) {
365                 printk(KERN_ERR "clock: Could not find parent clock %s in "
366                        "clksel array of clock %s\n", src_clk->name,
367                        clk->name);
368                 return NULL;
369         }
370
371         return clks;
372 }
373
374 /**
375  * omap2_clksel_round_rate_div - find divisor for the given clock and rate
376  * @clk: OMAP struct clk to use
377  * @target_rate: desired clock rate
378  * @new_div: ptr to where we should store the divisor
379  *
380  * Finds 'best' divider value in an array based on the source and target
381  * rates.  The divider array must be sorted with smallest divider first.
382  * Note that this will not work for clocks which are part of CONFIG_PARTICIPANT,
383  * they are only settable as part of virtual_prcm set.
384  *
385  * Returns the rounded clock rate or returns 0xffffffff on error.
386  */
387 u32 omap2_clksel_round_rate_div(struct clk *clk, unsigned long target_rate,
388                                 u32 *new_div)
389 {
390         unsigned long test_rate;
391         const struct clksel *clks;
392         const struct clksel_rate *clkr;
393         u32 last_div = 0;
394
395         printk(KERN_INFO "clock: clksel_round_rate_div: %s target_rate %ld\n",
396                clk->name, target_rate);
397
398         *new_div = 1;
399
400         clks = omap2_get_clksel_by_parent(clk, clk->parent);
401         if (clks == NULL)
402                 return ~0;
403
404         for (clkr = clks->rates; clkr->div; clkr++) {
405                 if (!(clkr->flags & cpu_mask))
406                     continue;
407
408                 /* Sanity check */
409                 if (clkr->div <= last_div)
410                         printk(KERN_ERR "clock: clksel_rate table not sorted "
411                                "for clock %s", clk->name);
412
413                 last_div = clkr->div;
414
415                 test_rate = clk->parent->rate / clkr->div;
416
417                 if (test_rate <= target_rate)
418                         break; /* found it */
419         }
420
421         if (!clkr->div) {
422                 printk(KERN_ERR "clock: Could not find divisor for target "
423                        "rate %ld for clock %s parent %s\n", target_rate,
424                        clk->name, clk->parent->name);
425                 return ~0;
426         }
427
428         *new_div = clkr->div;
429
430         printk(KERN_INFO "clock: new_div = %d, new_rate = %ld\n", *new_div,
431                (clk->parent->rate / clkr->div));
432
433         return (clk->parent->rate / clkr->div);
434 }
435
436 /**
437  * omap2_clksel_round_rate - find rounded rate for the given clock and rate
438  * @clk: OMAP struct clk to use
439  * @target_rate: desired clock rate
440  *
441  * Compatibility wrapper for OMAP clock framework
442  * Finds best target rate based on the source clock and possible dividers.
443  * rates. The divider array must be sorted with smallest divider first.
444  * Note that this will not work for clocks which are part of CONFIG_PARTICIPANT,
445  * they are only settable as part of virtual_prcm set.
446  *
447  * Returns the rounded clock rate or returns 0xffffffff on error.
448  */
449 long omap2_clksel_round_rate(struct clk *clk, unsigned long target_rate)
450 {
451         u32 new_div;
452
453         return omap2_clksel_round_rate_div(clk, target_rate, &new_div);
454 }
455
456
457 /* Given a clock and a rate apply a clock specific rounding function */
458 long omap2_clk_round_rate(struct clk *clk, unsigned long rate)
459 {
460         if (clk->round_rate != 0)
461                 return clk->round_rate(clk, rate);
462
463         if (clk->flags & RATE_FIXED)
464                 printk(KERN_ERR "clock: generic omap2_clk_round_rate called "
465                        "on fixed-rate clock %s\n", clk->name);
466
467         return clk->rate;
468 }
469
470 /**
471  * omap2_clksel_to_divisor() - turn clksel field value into integer divider
472  * @clk: OMAP struct clk to use
473  * @field_val: register field value to find
474  *
475  * Given a struct clk of a rate-selectable clksel clock, and a register field
476  * value to search for, find the corresponding clock divisor.  The register
477  * field value should be pre-masked and shifted down so the LSB is at bit 0
478  * before calling.  Returns 0 on error
479  */
480 u32 omap2_clksel_to_divisor(struct clk *clk, u32 field_val)
481 {
482         const struct clksel *clks;
483         const struct clksel_rate *clkr;
484
485         clks = omap2_get_clksel_by_parent(clk, clk->parent);
486         if (clks == NULL)
487                 return 0;
488
489         for (clkr = clks->rates; clkr->div; clkr++) {
490                 if ((clkr->flags & cpu_mask) && (clkr->val == field_val))
491                         break;
492         }
493
494         if (!clkr->div) {
495                 printk(KERN_ERR "clock: Could not find fieldval %d for "
496                        "clock %s parent %s\n", field_val, clk->name,
497                        clk->parent->name);
498                 return 0;
499         }
500
501         return clkr->div;
502 }
503
504 /**
505  * omap2_divisor_to_clksel() - turn clksel integer divisor into a field value
506  * @clk: OMAP struct clk to use
507  * @div: integer divisor to search for
508  *
509  * Given a struct clk of a rate-selectable clksel clock, and a clock divisor,
510  * find the corresponding register field value.  The return register value is
511  * the value before left-shifting.  Returns 0xffffffff on error
512  */
513 u32 omap2_divisor_to_clksel(struct clk *clk, u32 div)
514 {
515         const struct clksel *clks;
516         const struct clksel_rate *clkr;
517
518         /* should never happen */
519         WARN_ON(div == 0);
520
521         clks = omap2_get_clksel_by_parent(clk, clk->parent);
522         if (clks == NULL)
523                 return 0;
524
525         for (clkr = clks->rates; clkr->div; clkr++) {
526                 if ((clkr->flags & cpu_mask) && (clkr->div == div))
527                         break;
528         }
529
530         if (!clkr->div) {
531                 printk(KERN_ERR "clock: Could not find divisor %d for "
532                        "clock %s parent %s\n", div, clk->name,
533                        clk->parent->name);
534                 return 0;
535         }
536
537         return clkr->val;
538 }
539
540 /**
541  * omap2_get_clksel - find clksel register addr & field mask for a clk
542  * @clk: struct clk to use
543  * @field_mask: ptr to u32 to store the register field mask
544  *
545  * Returns the address of the clksel register upon success or NULL on error.
546  */
547 void __iomem *omap2_get_clksel(struct clk *clk, u32 *field_mask)
548 {
549         if (unlikely((clk->clksel_reg == 0) || (clk->clksel_mask == 0)))
550                 return NULL;
551
552         *field_mask = clk->clksel_mask;
553
554         return clk->clksel_reg;
555 }
556
557 /**
558  * omap2_clksel_get_divisor - get current divider applied to parent clock.
559  * @clk: OMAP struct clk to use.
560  *
561  * Returns the integer divisor upon success or 0 on error.
562  */
563 u32 omap2_clksel_get_divisor(struct clk *clk)
564 {
565         u32 field_mask, field_val;
566         void __iomem *div_addr;
567
568         div_addr = omap2_get_clksel(clk, &field_mask);
569         if (div_addr == 0)
570                 return 0;
571
572         field_val = __raw_readl(div_addr) & field_mask;
573         field_val >>= __ffs(field_mask);
574
575         return omap2_clksel_to_divisor(clk, field_val);
576 }
577
578 int omap2_clksel_set_rate(struct clk *clk, unsigned long rate)
579 {
580         u32 field_mask, field_val, reg_val, validrate, new_div = 0;
581         void __iomem *div_addr;
582
583         validrate = omap2_clksel_round_rate_div(clk, rate, &new_div);
584         if (validrate != rate)
585                 return -EINVAL;
586
587         div_addr = omap2_get_clksel(clk, &field_mask);
588         if (div_addr == 0)
589                 return -EINVAL;
590
591         field_val = omap2_divisor_to_clksel(clk, new_div);
592         if (field_val == ~0)
593                 return -EINVAL;
594
595         reg_val = __raw_readl(div_addr);
596         reg_val &= ~field_mask;
597         reg_val |= (field_val << __ffs(field_mask));
598         __raw_writel(reg_val, div_addr);
599         wmb();
600
601         clk->rate = clk->parent->rate / new_div;
602
603         if (clk->flags & DELAYED_APP && cpu_is_omap24xx()) {
604                 __raw_writel(OMAP24XX_VALID_CONFIG, OMAP24XX_PRCM_CLKCFG_CTRL);
605                 wmb();
606         }
607
608         return 0;
609 }
610
611
612 /* Set the clock rate for a clock source */
613 int omap2_clk_set_rate(struct clk *clk, unsigned long rate)
614 {
615         int ret = -EINVAL;
616
617         pr_debug("clock: set_rate for clock %s to rate %ld\n", clk->name, rate);
618
619         /* CONFIG_PARTICIPANT clocks are changed only in sets via the
620            rate table mechanism, driven by mpu_speed  */
621         if (clk->flags & CONFIG_PARTICIPANT)
622                 return -EINVAL;
623
624         /* dpll_ck, core_ck, virt_prcm_set; plus all clksel clocks */
625         if (clk->set_rate != 0)
626                 ret = clk->set_rate(clk, rate);
627
628         if (unlikely(ret == 0 && (clk->flags & RATE_PROPAGATES)))
629                 propagate_rate(clk);
630
631         return ret;
632 }
633
634 /*
635  * Converts encoded control register address into a full address
636  * On error, *src_addr will be returned as 0.
637  */
638 static u32 omap2_clksel_get_src_field(void __iomem **src_addr,
639                                       struct clk *src_clk, u32 *field_mask,
640                                       struct clk *clk, u32 *parent_div)
641 {
642         const struct clksel *clks;
643         const struct clksel_rate *clkr;
644
645         *parent_div = 0;
646         *src_addr = 0;
647
648         clks = omap2_get_clksel_by_parent(clk, src_clk);
649         if (clks == NULL)
650                 return 0;
651
652         for (clkr = clks->rates; clkr->div; clkr++) {
653                 if (clkr->flags & (cpu_mask | DEFAULT_RATE))
654                         break; /* Found the default rate for this platform */
655         }
656
657         if (!clkr->div) {
658                 printk(KERN_ERR "clock: Could not find default rate for "
659                        "clock %s parent %s\n", clk->name,
660                        src_clk->parent->name);
661                 return 0;
662         }
663
664         /* Should never happen.  Add a clksel mask to the struct clk. */
665         WARN_ON(clk->clksel_mask == 0);
666
667         *field_mask = clk->clksel_mask;
668         *src_addr = clk->clksel_reg;
669         *parent_div = clkr->div;
670
671         return clkr->val;
672 }
673
674 int omap2_clk_set_parent(struct clk *clk, struct clk *new_parent)
675 {
676         void __iomem *src_addr;
677         u32 field_val, field_mask, reg_val, parent_div;
678
679         if (unlikely(clk->flags & CONFIG_PARTICIPANT))
680                 return -EINVAL;
681
682         if (!clk->clksel)
683                 return -EINVAL;
684
685         field_val = omap2_clksel_get_src_field(&src_addr, new_parent,
686                                                &field_mask, clk, &parent_div);
687         if (src_addr == 0)
688                 return -EINVAL;
689
690         if (clk->usecount > 0)
691                 _omap2_clk_disable(clk);
692
693         /* Set new source value (previous dividers if any in effect) */
694         reg_val = __raw_readl(src_addr) & ~field_mask;
695         reg_val |= (field_val << __ffs(field_mask));
696         __raw_writel(reg_val, src_addr);
697         wmb();
698
699         if (clk->flags & DELAYED_APP && cpu_is_omap24xx()) {
700                 __raw_writel(OMAP24XX_VALID_CONFIG, OMAP24XX_PRCM_CLKCFG_CTRL);
701                 wmb();
702         }
703
704         if (clk->usecount > 0)
705                 _omap2_clk_enable(clk);
706
707         clk->parent = new_parent;
708
709         /* CLKSEL clocks follow their parents' rates, divided by a divisor */
710         clk->rate = new_parent->rate;
711
712         if (parent_div > 0)
713                 clk->rate /= parent_div;
714
715         pr_debug("clock: set parent of %s to %s (new rate %ld)\n",
716                  clk->name, clk->parent->name, clk->rate);
717
718         if (unlikely(clk->flags & RATE_PROPAGATES))
719                 propagate_rate(clk);
720
721         return 0;
722 }
723
724 /*-------------------------------------------------------------------------
725  * Omap2 clock reset and init functions
726  *-------------------------------------------------------------------------*/
727
728 #ifdef CONFIG_OMAP_RESET_CLOCKS
729 void omap2_clk_disable_unused(struct clk *clk)
730 {
731         u32 regval32, v;
732
733         v = (clk->flags & INVERT_ENABLE) ? (1 << clk->enable_bit) : 0;
734
735         regval32 = __raw_readl(clk->enable_reg);
736         if ((regval32 & (1 << clk->enable_bit)) == v)
737                 return;
738
739         printk(KERN_INFO "Disabling unused clock \"%s\"\n", clk->name);
740         _omap2_clk_disable(clk);
741 }
742 #endif