sh: Merge sh7343 and sh7722 clock code
[linux-2.6.git] / arch / sh / kernel / cpu / sh4a / clock-sh7722.c
1 /*
2  * arch/sh/kernel/cpu/sh4a/clock-sh7722.c
3  *
4  * SH7343, SH7722, SH7723 & SH7366 support for the clock framework
5  *
6  * Copyright (c) 2006-2007 Nomad Global Solutions Inc
7  * Based on code for sh7343 by Paul Mundt
8  *
9  * This file is subject to the terms and conditions of the GNU General Public
10  * License.  See the file "COPYING" in the main directory of this archive
11  * for more details.
12  */
13 #include <linux/init.h>
14 #include <linux/kernel.h>
15 #include <linux/io.h>
16 #include <linux/errno.h>
17 #include <linux/stringify.h>
18 #include <asm/clock.h>
19 #include <asm/freq.h>
20
21 #define N  (-1)
22 #define NM (-2)
23 #define ROUND_NEAREST 0
24 #define ROUND_DOWN -1
25 #define ROUND_UP   +1
26
27 static int adjust_algos[][3] = {
28         {},     /* NO_CHANGE */
29         { NM, N, 1 },   /* N:1, N:1 */
30         { 3, 2, 2 },    /* 3:2:2 */
31         { 5, 2, 2 },    /* 5:2:2 */
32         { N, 1, 1 },    /* N:1:1 */
33
34         { N, 1 },       /* N:1 */
35
36         { N, 1 },       /* N:1 */
37         { 3, 2 },
38         { 4, 3 },
39         { 5, 4 },
40
41         { N, 1 }
42 };
43
44 static unsigned long adjust_pair_of_clocks(unsigned long r1, unsigned long r2,
45                         int m1, int m2, int round_flag)
46 {
47         unsigned long rem, div;
48         int the_one = 0;
49
50         pr_debug( "Actual values: r1 = %ld\n", r1);
51         pr_debug( "...............r2 = %ld\n", r2);
52
53         if (m1 == m2) {
54                 r2 = r1;
55                 pr_debug( "setting equal rates: r2 now %ld\n", r2);
56         } else if ((m2 == N  && m1 == 1) ||
57                    (m2 == NM && m1 == N)) { /* N:1 or NM:N */
58                 pr_debug( "Setting rates as 1:N (N:N*M)\n");
59                 rem = r2 % r1;
60                 pr_debug( "...remainder = %ld\n", rem);
61                 if (rem) {
62                         div = r2 / r1;
63                         pr_debug( "...div = %ld\n", div);
64                         switch (round_flag) {
65                         case ROUND_NEAREST:
66                                 the_one = rem >= r1/2 ? 1 : 0; break;
67                         case ROUND_UP:
68                                 the_one = 1; break;
69                         case ROUND_DOWN:
70                                 the_one = 0; break;
71                         }
72
73                         r2 = r1 * (div + the_one);
74                         pr_debug( "...setting r2 to %ld\n", r2);
75                 }
76         } else if ((m2 == 1  && m1 == N) ||
77                    (m2 == N && m1 == NM)) { /* 1:N or N:NM */
78                 pr_debug( "Setting rates as N:1 (N*M:N)\n");
79                 rem = r1 % r2;
80                 pr_debug( "...remainder = %ld\n", rem);
81                 if (rem) {
82                         div = r1 / r2;
83                         pr_debug( "...div = %ld\n", div);
84                         switch (round_flag) {
85                         case ROUND_NEAREST:
86                                 the_one = rem > r2/2 ? 1 : 0; break;
87                         case ROUND_UP:
88                                 the_one = 0; break;
89                         case ROUND_DOWN:
90                                 the_one = 1; break;
91                         }
92
93                         r2 = r1 / (div + the_one);
94                         pr_debug( "...setting r2 to %ld\n", r2);
95                 }
96         } else { /* value:value */
97                 pr_debug( "Setting rates as %d:%d\n", m1, m2);
98                 div = r1 / m1;
99                 r2 = div * m2;
100                 pr_debug( "...div = %ld\n", div);
101                 pr_debug( "...setting r2 to %ld\n", r2);
102         }
103
104         return r2;
105 }
106
107 static void adjust_clocks(int originate, int *l, unsigned long v[],
108                           int n_in_line)
109 {
110         int x;
111
112         pr_debug( "Go down from %d...\n", originate);
113         /* go up recalculation clocks */
114         for (x = originate; x>0; x -- )
115                 v[x-1] = adjust_pair_of_clocks(v[x], v[x-1],
116                                         l[x], l[x-1],
117                                         ROUND_UP);
118
119         pr_debug( "Go up from %d...\n", originate);
120         /* go down recalculation clocks */
121         for (x = originate; x<n_in_line - 1; x ++ )
122                 v[x+1] = adjust_pair_of_clocks(v[x], v[x+1],
123                                         l[x], l[x+1],
124                                         ROUND_UP);
125 }
126
127
128 /*
129  * SH7722 uses a common set of multipliers and divisors, so this
130  * is quite simple..
131  */
132
133 /*
134  * Instead of having two separate multipliers/divisors set, like this:
135  *
136  * static int multipliers[] = { 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
137  * static int divisors[] = { 1, 3, 2, 5, 3, 4, 5, 6, 8, 10, 12, 16, 20 };
138  *
139  * I created the divisors2 array, which is used to calculate rate like
140  *   rate = parent * 2 / divisors2[ divisor ];
141 */
142 static int divisors2[] = { 2, 3, 4, 5, 6, 8, 10, 12, 16, 20, 24, 32, 40 };
143
144 static void master_clk_recalc(struct clk *clk)
145 {
146         unsigned frqcr = ctrl_inl(FRQCR);
147
148         clk->rate = CONFIG_SH_PCLK_FREQ * (((frqcr >> 24) & 0x1f) + 1);
149 }
150
151 static void master_clk_init(struct clk *clk)
152 {
153         clk->parent = NULL;
154         clk->flags |= CLK_RATE_PROPAGATES;
155         clk->rate = CONFIG_SH_PCLK_FREQ;
156         master_clk_recalc(clk);
157 }
158
159
160 static void module_clk_recalc(struct clk *clk)
161 {
162         unsigned long frqcr = ctrl_inl(FRQCR);
163
164         clk->rate = clk->parent->rate / (((frqcr >> 24) & 0x1f) + 1);
165 }
166
167 static int master_clk_setrate(struct clk *clk, unsigned long rate, int id)
168 {
169         int div = rate / clk->rate;
170         int master_divs[] = { 2, 3, 4, 6, 8, 16 };
171         int index;
172         unsigned long frqcr;
173
174         for (index = 1; index < ARRAY_SIZE(master_divs); index++)
175                 if (div >= master_divs[index - 1] && div < master_divs[index])
176                         break;
177
178         if (index >= ARRAY_SIZE(master_divs))
179                 index = ARRAY_SIZE(master_divs);
180         div = master_divs[index - 1];
181
182         frqcr = ctrl_inl(FRQCR);
183         frqcr &= ~(0xF << 24);
184         frqcr |= ( (div-1) << 24);
185         ctrl_outl(frqcr, FRQCR);
186
187         return 0;
188 }
189
190 static struct clk_ops sh7722_master_clk_ops = {
191         .init = master_clk_init,
192         .recalc = master_clk_recalc,
193         .set_rate = master_clk_setrate,
194 };
195
196 static struct clk_ops sh7722_module_clk_ops = {
197        .recalc = module_clk_recalc,
198 };
199
200 struct frqcr_context {
201         unsigned mask;
202         unsigned shift;
203 };
204
205 struct frqcr_context sh7722_get_clk_context(const char *name)
206 {
207         struct frqcr_context ctx = { 0, };
208
209         if (!strcmp(name, "peripheral_clk")) {
210                 ctx.shift = 0;
211                 ctx.mask = 0xF;
212         } else if (!strcmp(name, "sdram_clk")) {
213                 ctx.shift = 4;
214                 ctx.mask = 0xF;
215         } else if (!strcmp(name, "bus_clk")) {
216                 ctx.shift = 8;
217                 ctx.mask = 0xF;
218         } else if (!strcmp(name, "sh_clk")) {
219                 ctx.shift = 12;
220                 ctx.mask = 0xF;
221         } else if (!strcmp(name, "umem_clk")) {
222                 ctx.shift = 16;
223                 ctx.mask = 0xF;
224         } else if (!strcmp(name, "cpu_clk")) {
225                 ctx.shift = 20;
226                 ctx.mask = 7;
227         }
228         return ctx;
229 }
230
231 /**
232  * sh7722_find_divisors - find divisor for setting rate
233  *
234  * All sh7722 clocks use the same set of multipliers/divisors. This function
235  * chooses correct divisor to set the rate of clock with parent clock that
236  * generates frequency of 'parent_rate'
237  *
238  * @parent_rate: rate of parent clock
239  * @rate: requested rate to be set
240  */
241 static int sh7722_find_divisors(unsigned long parent_rate, unsigned rate)
242 {
243         unsigned div2 = parent_rate * 2 / rate;
244         int index;
245
246         if (rate > parent_rate)
247                 return -EINVAL;
248
249         for (index = 1; index < ARRAY_SIZE(divisors2); index++) {
250                 if (div2 > divisors2[index] && div2 <= divisors2[index])
251                         break;
252         }
253         if (index >= ARRAY_SIZE(divisors2))
254                 index = ARRAY_SIZE(divisors2) - 1;
255         return divisors2[index];
256 }
257
258 static void sh7722_frqcr_recalc(struct clk *clk)
259 {
260         struct frqcr_context ctx = sh7722_get_clk_context(clk->name);
261         unsigned long frqcr = ctrl_inl(FRQCR);
262         int index;
263
264         index = (frqcr >> ctx.shift) & ctx.mask;
265         clk->rate = clk->parent->rate * 2 / divisors2[index];
266 }
267
268 static int sh7722_frqcr_set_rate(struct clk *clk, unsigned long rate,
269                                  int algo_id)
270 {
271         struct frqcr_context ctx = sh7722_get_clk_context(clk->name);
272         unsigned long parent_rate = clk->parent->rate;
273         int div;
274         unsigned long frqcr;
275         int err = 0;
276
277         /* pretty invalid */
278         if (parent_rate < rate)
279                 return -EINVAL;
280
281         /* look for multiplier/divisor pair */
282         div = sh7722_find_divisors(parent_rate, rate);
283         if (div<0)
284                 return div;
285
286         /* calculate new value of clock rate */
287         clk->rate = parent_rate * 2 / div;
288         frqcr = ctrl_inl(FRQCR);
289
290         /* FIXME: adjust as algo_id specifies */
291         if (algo_id != NO_CHANGE) {
292                 int originator;
293                 char *algo_group_1[] = { "cpu_clk", "umem_clk", "sh_clk" };
294                 char *algo_group_2[] = { "sh_clk", "bus_clk" };
295                 char *algo_group_3[] = { "sh_clk", "sdram_clk" };
296                 char *algo_group_4[] = { "bus_clk", "peripheral_clk" };
297                 char *algo_group_5[] = { "cpu_clk", "peripheral_clk" };
298                 char **algo_current = NULL;
299                 /* 3 is the maximum number of clocks in relation */
300                 struct clk *ck[3];
301                 unsigned long values[3]; /* the same comment as above */
302                 int part_length = -1;
303                 int i;
304
305                 /*
306                  * all the steps below only required if adjustion was
307                  * requested
308                  */
309                 if (algo_id == IUS_N1_N1 ||
310                     algo_id == IUS_322 ||
311                     algo_id == IUS_522 ||
312                     algo_id == IUS_N11) {
313                         algo_current = algo_group_1;
314                         part_length = 3;
315                 }
316                 if (algo_id == SB_N1) {
317                         algo_current = algo_group_2;
318                         part_length = 2;
319                 }
320                 if (algo_id == SB3_N1 ||
321                     algo_id == SB3_32 ||
322                     algo_id == SB3_43 ||
323                     algo_id == SB3_54) {
324                         algo_current = algo_group_3;
325                         part_length = 2;
326                 }
327                 if (algo_id == BP_N1) {
328                         algo_current = algo_group_4;
329                         part_length = 2;
330                 }
331                 if (algo_id == IP_N1) {
332                         algo_current = algo_group_5;
333                         part_length = 2;
334                 }
335                 if (!algo_current)
336                         goto incorrect_algo_id;
337
338                 originator = -1;
339                 for (i = 0; i < part_length; i ++ ) {
340                         if (originator >= 0 && !strcmp(clk->name,
341                                                        algo_current[i]))
342                                 originator = i;
343                         ck[i] = clk_get(NULL, algo_current[i]);
344                         values[i] = clk_get_rate(ck[i]);
345                 }
346
347                 if (originator >= 0)
348                         adjust_clocks(originator, adjust_algos[algo_id],
349                                       values, part_length);
350
351                 for (i = 0; i < part_length; i ++ ) {
352                         struct frqcr_context part_ctx;
353                         int part_div;
354
355                         if (likely(!err)) {
356                                 part_div = sh7722_find_divisors(parent_rate,
357                                                                 rate);
358                                 if (part_div > 0) {
359                                         part_ctx = sh7722_get_clk_context(
360                                                                 ck[i]->name);
361                                         frqcr &= ~(part_ctx.mask <<
362                                                    part_ctx.shift);
363                                         frqcr |= part_div << part_ctx.shift;
364                                 } else
365                                         err = part_div;
366                         }
367
368                         ck[i]->ops->recalc(ck[i]);
369                         clk_put(ck[i]);
370                 }
371         }
372
373         /* was there any error during recalculation ? If so, bail out.. */
374         if (unlikely(err!=0))
375                 goto out_err;
376
377         /* clear FRQCR bits */
378         frqcr &= ~(ctx.mask << ctx.shift);
379         frqcr |= div << ctx.shift;
380
381         /* ...and perform actual change */
382         ctrl_outl(frqcr, FRQCR);
383         return 0;
384
385 incorrect_algo_id:
386         return -EINVAL;
387 out_err:
388         return err;
389 }
390
391 static long sh7722_frqcr_round_rate(struct clk *clk, unsigned long rate)
392 {
393         unsigned long parent_rate = clk->parent->rate;
394         int div;
395
396         /* look for multiplier/divisor pair */
397         div = sh7722_find_divisors(parent_rate, rate);
398         if (div < 0)
399                 return clk->rate;
400
401         /* calculate new value of clock rate */
402         return parent_rate * 2 / div;
403 }
404
405 static struct clk_ops sh7722_frqcr_clk_ops = {
406         .recalc = sh7722_frqcr_recalc,
407         .set_rate = sh7722_frqcr_set_rate,
408         .round_rate = sh7722_frqcr_round_rate,
409 };
410
411 /*
412  * clock ops methods for SIU A/B and IrDA clock
413  *
414  */
415
416 #ifndef CONFIG_CPU_SUBTYPE_SH7343
417
418 static int sh7722_siu_set_rate(struct clk *clk, unsigned long rate, int algo_id)
419 {
420         unsigned long r;
421         int div;
422
423         r = ctrl_inl(clk->arch_flags);
424         div = sh7722_find_divisors(clk->parent->rate, rate);
425         if (div < 0)
426                 return div;
427         r = (r & ~0xF) | div;
428         ctrl_outl(r, clk->arch_flags);
429         return 0;
430 }
431
432 static void sh7722_siu_recalc(struct clk *clk)
433 {
434         unsigned long r;
435
436         r = ctrl_inl(clk->arch_flags);
437         clk->rate = clk->parent->rate * 2 / divisors2[r & 0xF];
438 }
439
440 static int sh7722_siu_start_stop(struct clk *clk, int enable)
441 {
442         unsigned long r;
443
444         r = ctrl_inl(clk->arch_flags);
445         if (enable)
446                 ctrl_outl(r & ~(1 << 8), clk->arch_flags);
447         else
448                 ctrl_outl(r | (1 << 8), clk->arch_flags);
449         return 0;
450 }
451
452 static void sh7722_siu_enable(struct clk *clk)
453 {
454         sh7722_siu_start_stop(clk, 1);
455 }
456
457 static void sh7722_siu_disable(struct clk *clk)
458 {
459         sh7722_siu_start_stop(clk, 0);
460 }
461
462 static struct clk_ops sh7722_siu_clk_ops = {
463         .recalc = sh7722_siu_recalc,
464         .set_rate = sh7722_siu_set_rate,
465         .enable = sh7722_siu_enable,
466         .disable = sh7722_siu_disable,
467 };
468
469 #endif /* CONFIG_CPU_SUBTYPE_SH7343 */
470
471 static void sh7722_video_enable(struct clk *clk)
472 {
473         unsigned long r;
474
475         r = ctrl_inl(VCLKCR);
476         ctrl_outl( r & ~(1<<8), VCLKCR);
477 }
478
479 static void sh7722_video_disable(struct clk *clk)
480 {
481         unsigned long r;
482
483         r = ctrl_inl(VCLKCR);
484         ctrl_outl( r | (1<<8), VCLKCR);
485 }
486
487 static int sh7722_video_set_rate(struct clk *clk, unsigned long rate,
488                                  int algo_id)
489 {
490         unsigned long r;
491
492         r = ctrl_inl(VCLKCR);
493         r &= ~0x3F;
494         r |= ((clk->parent->rate / rate - 1) & 0x3F);
495         ctrl_outl(r, VCLKCR);
496         return 0;
497 }
498
499 static void sh7722_video_recalc(struct clk *clk)
500 {
501         unsigned long r;
502
503         r = ctrl_inl(VCLKCR);
504         clk->rate = clk->parent->rate / ((r & 0x3F) + 1);
505 }
506
507 static struct clk_ops sh7722_video_clk_ops = {
508         .recalc = sh7722_video_recalc,
509         .set_rate = sh7722_video_set_rate,
510         .enable = sh7722_video_enable,
511         .disable = sh7722_video_disable,
512 };
513 /*
514  * and at last, clock definitions themselves
515  */
516 static struct clk sh7722_umem_clock = {
517         .name = "umem_clk",
518         .ops = &sh7722_frqcr_clk_ops,
519 };
520
521 static struct clk sh7722_sh_clock = {
522         .name = "sh_clk",
523         .ops = &sh7722_frqcr_clk_ops,
524 };
525
526 static struct clk sh7722_peripheral_clock = {
527         .name = "peripheral_clk",
528         .ops = &sh7722_frqcr_clk_ops,
529 };
530
531 static struct clk sh7722_sdram_clock = {
532         .name = "sdram_clk",
533         .ops = &sh7722_frqcr_clk_ops,
534 };
535
536
537 #ifndef CONFIG_CPU_SUBTYPE_SH7343
538
539 /*
540  * these three clocks - SIU A, SIU B, IrDA - share the same clk_ops
541  * methods of clk_ops determine which register they should access by
542  * examining clk->name field
543  */
544 static struct clk sh7722_siu_a_clock = {
545         .name = "siu_a_clk",
546         .arch_flags = SCLKACR,
547         .ops = &sh7722_siu_clk_ops,
548 };
549
550 static struct clk sh7722_siu_b_clock = {
551         .name = "siu_b_clk",
552         .arch_flags = SCLKBCR,
553         .ops = &sh7722_siu_clk_ops,
554 };
555
556 #if defined(CONFIG_CPU_SUBTYPE_SH7722)
557 static struct clk sh7722_irda_clock = {
558         .name = "irda_clk",
559         .arch_flags = IrDACLKCR,
560         .ops = &sh7722_siu_clk_ops,
561 };
562 #endif
563 #endif /* CONFIG_CPU_SUBTYPE_SH7343 */
564
565 static struct clk sh7722_video_clock = {
566         .name = "video_clk",
567         .ops = &sh7722_video_clk_ops,
568 };
569
570 static int sh7722_mstpcr_start_stop(struct clk *clk, unsigned long reg,
571                                     int enable)
572 {
573         unsigned long bit = clk->arch_flags;
574         unsigned long r;
575
576         r = ctrl_inl(reg);
577
578         if (enable)
579                 r &= ~(1 << bit);
580         else
581                 r |= (1 << bit);
582
583         ctrl_outl(r, reg);
584         return 0;
585 }
586
587 static void sh7722_mstpcr0_enable(struct clk *clk)
588 {
589         sh7722_mstpcr_start_stop(clk, MSTPCR0, 1);
590 }
591
592 static void sh7722_mstpcr0_disable(struct clk *clk)
593 {
594         sh7722_mstpcr_start_stop(clk, MSTPCR0, 0);
595 }
596
597 static void sh7722_mstpcr1_enable(struct clk *clk)
598 {
599         sh7722_mstpcr_start_stop(clk, MSTPCR1, 1);
600 }
601
602 static void sh7722_mstpcr1_disable(struct clk *clk)
603 {
604         sh7722_mstpcr_start_stop(clk, MSTPCR1, 0);
605 }
606
607 static void sh7722_mstpcr2_enable(struct clk *clk)
608 {
609         sh7722_mstpcr_start_stop(clk, MSTPCR2, 1);
610 }
611
612 static void sh7722_mstpcr2_disable(struct clk *clk)
613 {
614         sh7722_mstpcr_start_stop(clk, MSTPCR2, 0);
615 }
616
617 static struct clk_ops sh7722_mstpcr0_clk_ops = {
618         .enable = sh7722_mstpcr0_enable,
619         .disable = sh7722_mstpcr0_disable,
620 };
621
622 static struct clk_ops sh7722_mstpcr1_clk_ops = {
623         .enable = sh7722_mstpcr1_enable,
624         .disable = sh7722_mstpcr1_disable,
625 };
626
627 static struct clk_ops sh7722_mstpcr2_clk_ops = {
628         .enable = sh7722_mstpcr2_enable,
629         .disable = sh7722_mstpcr2_disable,
630 };
631
632 #define DECLARE_MSTPCRN(regnr, bitnr, bitstr)           \
633 {                                                       \
634         .name = "mstp" __stringify(regnr) bitstr,       \
635         .arch_flags = bitnr,                            \
636         .ops = &sh7722_mstpcr ## regnr ## _clk_ops,     \
637 }
638
639 #define DECLARE_MSTPCR(regnr) \
640         DECLARE_MSTPCRN(regnr, 31, "31"), \
641         DECLARE_MSTPCRN(regnr, 30, "30"), \
642         DECLARE_MSTPCRN(regnr, 29, "29"), \
643         DECLARE_MSTPCRN(regnr, 28, "28"), \
644         DECLARE_MSTPCRN(regnr, 27, "27"), \
645         DECLARE_MSTPCRN(regnr, 26, "26"), \
646         DECLARE_MSTPCRN(regnr, 25, "25"), \
647         DECLARE_MSTPCRN(regnr, 24, "24"), \
648         DECLARE_MSTPCRN(regnr, 23, "23"), \
649         DECLARE_MSTPCRN(regnr, 22, "22"), \
650         DECLARE_MSTPCRN(regnr, 21, "21"), \
651         DECLARE_MSTPCRN(regnr, 20, "20"), \
652         DECLARE_MSTPCRN(regnr, 19, "19"), \
653         DECLARE_MSTPCRN(regnr, 18, "18"), \
654         DECLARE_MSTPCRN(regnr, 17, "17"), \
655         DECLARE_MSTPCRN(regnr, 16, "16"), \
656         DECLARE_MSTPCRN(regnr, 15, "15"), \
657         DECLARE_MSTPCRN(regnr, 14, "14"), \
658         DECLARE_MSTPCRN(regnr, 13, "13"), \
659         DECLARE_MSTPCRN(regnr, 12, "12"), \
660         DECLARE_MSTPCRN(regnr, 11, "11"), \
661         DECLARE_MSTPCRN(regnr, 10, "10"), \
662         DECLARE_MSTPCRN(regnr, 9, "09"), \
663         DECLARE_MSTPCRN(regnr, 8, "08"), \
664         DECLARE_MSTPCRN(regnr, 7, "07"), \
665         DECLARE_MSTPCRN(regnr, 6, "06"), \
666         DECLARE_MSTPCRN(regnr, 5, "05"), \
667         DECLARE_MSTPCRN(regnr, 4, "04"), \
668         DECLARE_MSTPCRN(regnr, 3, "03"), \
669         DECLARE_MSTPCRN(regnr, 2, "02"), \
670         DECLARE_MSTPCRN(regnr, 1, "01"), \
671         DECLARE_MSTPCRN(regnr, 0, "00")
672
673 static struct clk sh7722_mstpcr[] = {
674         DECLARE_MSTPCR(0),
675         DECLARE_MSTPCR(1),
676         DECLARE_MSTPCR(2),
677 };
678
679 static struct clk *sh7722_clocks[] = {
680         &sh7722_umem_clock,
681         &sh7722_sh_clock,
682         &sh7722_peripheral_clock,
683         &sh7722_sdram_clock,
684 #ifndef CONFIG_CPU_SUBTYPE_SH7343
685         &sh7722_siu_a_clock,
686         &sh7722_siu_b_clock,
687 #if defined(CONFIG_CPU_SUBTYPE_SH7722)
688         &sh7722_irda_clock,
689 #endif
690 #endif
691         &sh7722_video_clock,
692 };
693
694 /*
695  * init in order: master, module, bus, cpu
696  */
697 struct clk_ops *onchip_ops[] = {
698         &sh7722_master_clk_ops,
699         &sh7722_module_clk_ops,
700         &sh7722_frqcr_clk_ops,
701         &sh7722_frqcr_clk_ops,
702 };
703
704 void __init
705 arch_init_clk_ops(struct clk_ops **ops, int type)
706 {
707         BUG_ON(type < 0 || type > ARRAY_SIZE(onchip_ops));
708         *ops = onchip_ops[type];
709 }
710
711 int __init arch_clk_init(void)
712 {
713         struct clk *master;
714         int i;
715
716         master = clk_get(NULL, "master_clk");
717         for (i = 0; i < ARRAY_SIZE(sh7722_clocks); i++) {
718                 pr_debug( "Registering clock '%s'\n", sh7722_clocks[i]->name);
719                 sh7722_clocks[i]->parent = master;
720                 clk_register(sh7722_clocks[i]);
721         }
722         clk_put(master);
723
724         for (i = 0; i < ARRAY_SIZE(sh7722_mstpcr); i++) {
725                 pr_debug( "Registering mstpcr '%s'\n", sh7722_mstpcr[i].name);
726                 clk_register(&sh7722_mstpcr[i]);
727         }
728
729         return 0;
730 }