arch/arm/mach-shmobile/clock-sh73a0.c

   1 /*
   2  * sh73a0 clock framework support
   3  *
   4  * Copyright (C) 2010 Magnus Damm
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  */
  19 #include <linux/init.h>
  20 #include <linux/kernel.h>
  21 #include <linux/io.h>
  22 #include <linux/sh_clk.h>
  23 #include <linux/clkdev.h>
  24 #include <mach/common.h>
  25
  26 #define FRQCRA          0xe6150000
  27 #define FRQCRB          0xe6150004
  28 #define FRQCRD          0xe61500e4
  29 #define VCLKCR1         0xe6150008
  30 #define VCLKCR2         0xe615000C
  31 #define VCLKCR3         0xe615001C
  32 #define ZBCKCR          0xe6150010
  33 #define FLCKCR          0xe6150014
  34 #define SD0CKCR         0xe6150074
  35 #define SD1CKCR         0xe6150078
  36 #define SD2CKCR         0xe615007C
  37 #define FSIACKCR        0xe6150018
  38 #define FSIBCKCR        0xe6150090
  39 #define SUBCKCR         0xe6150080
  40 #define SPUACKCR        0xe6150084
  41 #define SPUVCKCR        0xe6150094
  42 #define MSUCKCR         0xe6150088
  43 #define HSICKCR         0xe615008C
  44 #define MFCK1CR         0xe6150098
  45 #define MFCK2CR         0xe615009C
  46 #define DSITCKCR        0xe6150060
  47 #define DSI0PCKCR       0xe6150064
  48 #define DSI1PCKCR       0xe6150068
  49 #define DSI0PHYCR       0xe615006C
  50 #define DSI1PHYCR       0xe6150070
  51 #define PLLECR          0xe61500d0
  52 #define PLL0CR          0xe61500d8
  53 #define PLL1CR          0xe6150028
  54 #define PLL2CR          0xe615002c
  55 #define PLL3CR          0xe61500dc
  56 #define SMSTPCR0        0xe6150130
  57 #define SMSTPCR1        0xe6150134
  58 #define SMSTPCR2        0xe6150138
  59 #define SMSTPCR3        0xe615013c
  60 #define SMSTPCR4        0xe6150140
  61 #define SMSTPCR5        0xe6150144
  62 #define CKSCR           0xe61500c0
  63
  64 /* Fixed 32 KHz root clock from EXTALR pin */
  65 static struct clk r_clk = {
  66         .rate           = 32768,
  67 };
  68
  69 /*
  70  * 26MHz default rate for the EXTAL1 root input clock.
  71  * If needed, reset this with clk_set_rate() from the platform code.
  72  */
  73 struct clk sh73a0_extal1_clk = {
  74         .rate           = 26000000,
  75 };
  76
  77 /*
  78  * 48MHz default rate for the EXTAL2 root input clock.
  79  * If needed, reset this with clk_set_rate() from the platform code.
  80  */
  81 struct clk sh73a0_extal2_clk = {
  82         .rate           = 48000000,
  83 };
  84
  85 /* A fixed divide-by-2 block */
  86 static unsigned long div2_recalc(struct clk *clk)
  87 {
  88         return clk->parent->rate / 2;
  89 }
  90
  91 static struct clk_ops div2_clk_ops = {
  92         .recalc         = div2_recalc,
  93 };
  94
  95 static unsigned long div7_recalc(struct clk *clk)
  96 {
  97         return clk->parent->rate / 7;
  98 }
  99
 100 static struct clk_ops div7_clk_ops = {
 101         .recalc         = div7_recalc,
 102 };
 103
 104 static unsigned long div13_recalc(struct clk *clk)
 105 {
 106         return clk->parent->rate / 13;
 107 }
 108
 109 static struct clk_ops div13_clk_ops = {
 110         .recalc         = div13_recalc,
 111 };
 112
 113 /* Divide extal1 by two */
 114 static struct clk extal1_div2_clk = {
 115         .ops            = &div2_clk_ops,
 116         .parent         = &sh73a0_extal1_clk,
 117 };
 118
 119 /* Divide extal2 by two */
 120 static struct clk extal2_div2_clk = {
 121         .ops            = &div2_clk_ops,
 122         .parent         = &sh73a0_extal2_clk,
 123 };
 124
 125 static struct clk_ops main_clk_ops = {
 126         .recalc         = followparent_recalc,
 127 };
 128
 129 /* Main clock */
 130 static struct clk main_clk = {
 131         .ops            = &main_clk_ops,
 132 };
 133
 134 static struct clk main_div2_clk = {
 135         .ops            = &div2_clk_ops,
 136         .parent         = &main_clk,
 137 };
 138
 139 /* PLL0, PLL1, PLL2, PLL3 */
 140 static unsigned long pll_recalc(struct clk *clk)
 141 {
 142         unsigned long mult = 1;
 143
 144         if (__raw_readl(PLLECR) & (1 << clk->enable_bit)) {
 145                 mult = (((__raw_readl(clk->enable_reg) >> 24) & 0x3f) + 1);
 146                 /* handle CFG bit for PLL1 and PLL2 */
 147                 switch (clk->enable_bit) {
 148                 case 1:
 149                 case 2:
 150                         if (__raw_readl(clk->enable_reg) & (1 << 20))
 151                                 mult *= 2;
 152                 }
 153         }
 154
 155         return clk->parent->rate * mult;
 156 }
 157
 158 static struct clk_ops pll_clk_ops = {
 159         .recalc         = pll_recalc,
 160 };
 161
 162 static struct clk pll0_clk = {
 163         .ops            = &pll_clk_ops,
 164         .flags          = CLK_ENABLE_ON_INIT,
 165         .parent         = &main_clk,
 166         .enable_reg     = (void __iomem *)PLL0CR,
 167         .enable_bit     = 0,
 168 };
 169
 170 static struct clk pll1_clk = {
 171         .ops            = &pll_clk_ops,
 172         .flags          = CLK_ENABLE_ON_INIT,
 173         .parent         = &main_clk,
 174         .enable_reg     = (void __iomem *)PLL1CR,
 175         .enable_bit     = 1,
 176 };
 177
 178 static struct clk pll2_clk = {
 179         .ops            = &pll_clk_ops,
 180         .flags          = CLK_ENABLE_ON_INIT,
 181         .parent         = &main_clk,
 182         .enable_reg     = (void __iomem *)PLL2CR,
 183         .enable_bit     = 2,
 184 };
 185
 186 static struct clk pll3_clk = {
 187         .ops            = &pll_clk_ops,
 188         .flags          = CLK_ENABLE_ON_INIT,
 189         .parent         = &main_clk,
 190         .enable_reg     = (void __iomem *)PLL3CR,
 191         .enable_bit     = 3,
 192 };
 193
 194 /* Divide PLL */
 195 static struct clk pll1_div2_clk = {
 196         .ops            = &div2_clk_ops,
 197         .parent         = &pll1_clk,
 198 };
 199
 200 static struct clk pll1_div7_clk = {
 201         .ops            = &div7_clk_ops,
 202         .parent         = &pll1_clk,
 203 };
 204
 205 static struct clk pll1_div13_clk = {
 206         .ops            = &div13_clk_ops,
 207         .parent         = &pll1_clk,
 208 };
 209
 210 /* External input clock */
 211 struct clk sh73a0_extcki_clk = {
 212 };
 213
 214 struct clk sh73a0_extalr_clk = {
 215 };
 216
 217 static struct clk *main_clks[] = {
 218         &r_clk,
 219         &sh73a0_extal1_clk,
 220         &sh73a0_extal2_clk,
 221         &extal1_div2_clk,
 222         &extal2_div2_clk,
 223         &main_clk,
 224         &main_div2_clk,
 225         &pll0_clk,
 226         &pll1_clk,
 227         &pll2_clk,
 228         &pll3_clk,
 229         &pll1_div2_clk,
 230         &pll1_div7_clk,
 231         &pll1_div13_clk,
 232         &sh73a0_extcki_clk,
 233         &sh73a0_extalr_clk,
 234 };
 235
 236 static void div4_kick(struct clk *clk)
 237 {
 238         unsigned long value;
 239
 240         /* set KICK bit in FRQCRB to update hardware setting */
 241         value = __raw_readl(FRQCRB);
 242         value |= (1 << 31);
 243         __raw_writel(value, FRQCRB);
 244 }
 245
 246 static int divisors[] = { 2, 3, 4, 6, 8, 12, 16, 18,
 247                           24, 0, 36, 48, 7 };
 248
 249 static struct clk_div_mult_table div4_div_mult_table = {
 250         .divisors = divisors,
 251         .nr_divisors = ARRAY_SIZE(divisors),
 252 };
 253
 254 static struct clk_div4_table div4_table = {
 255         .div_mult_table = &div4_div_mult_table,
 256         .kick = div4_kick,
 257 };
 258
 259 enum { DIV4_I, DIV4_ZG, DIV4_M3, DIV4_B, DIV4_M1, DIV4_M2,
 260         DIV4_Z, DIV4_ZTR, DIV4_ZT, DIV4_ZX, DIV4_HP, DIV4_NR };
 261
 262 #define DIV4(_reg, _bit, _mask, _flags) \
 263         SH_CLK_DIV4(&pll1_clk, _reg, _bit, _mask, _flags)
 264
 265 static struct clk div4_clks[DIV4_NR] = {
 266         [DIV4_I] = DIV4(FRQCRA, 20, 0xfff, CLK_ENABLE_ON_INIT),
 267         [DIV4_ZG] = DIV4(FRQCRA, 16, 0xbff, CLK_ENABLE_ON_INIT),
 268         [DIV4_M3] = DIV4(FRQCRA, 12, 0xfff, CLK_ENABLE_ON_INIT),
 269         [DIV4_B] = DIV4(FRQCRA, 8, 0xfff, CLK_ENABLE_ON_INIT),
 270         [DIV4_M1] = DIV4(FRQCRA, 4, 0xfff, 0),
 271         [DIV4_M2] = DIV4(FRQCRA, 0, 0xfff, 0),
 272         [DIV4_Z] = DIV4(FRQCRB, 24, 0xbff, 0),
 273         [DIV4_ZTR] = DIV4(FRQCRB, 20, 0xfff, 0),
 274         [DIV4_ZT] = DIV4(FRQCRB, 16, 0xfff, 0),
 275         [DIV4_ZX] = DIV4(FRQCRB, 12, 0xfff, 0),
 276         [DIV4_HP] = DIV4(FRQCRB, 4, 0xfff, 0),
 277 };
 278
 279 enum { DIV6_VCK1, DIV6_VCK2, DIV6_VCK3, DIV6_ZB1,
 280         DIV6_FLCTL, DIV6_SDHI0, DIV6_SDHI1, DIV6_SDHI2,
 281         DIV6_FSIA, DIV6_FSIB, DIV6_SUB,
 282         DIV6_SPUA, DIV6_SPUV, DIV6_MSU,
 283         DIV6_HSI,  DIV6_MFG1, DIV6_MFG2,
 284         DIV6_DSIT, DIV6_DSI0P, DIV6_DSI1P,
 285         DIV6_NR };
 286
 287 static struct clk *vck_parent[8] = {
 288         [0] = &pll1_div2_clk,
 289         [1] = &pll2_clk,
 290         [2] = &sh73a0_extcki_clk,
 291         [3] = &sh73a0_extal2_clk,
 292         [4] = &main_div2_clk,
 293         [5] = &sh73a0_extalr_clk,
 294         [6] = &main_clk,
 295 };
 296
 297 static struct clk *pll_parent[4] = {
 298         [0] = &pll1_div2_clk,
 299         [1] = &pll2_clk,
 300         [2] = &pll1_div13_clk,
 301 };
 302
 303 static struct clk *hsi_parent[4] = {
 304         [0] = &pll1_div2_clk,
 305         [1] = &pll2_clk,
 306         [2] = &pll1_div7_clk,
 307 };
 308
 309 static struct clk *pll_extal2_parent[] = {
 310         [0] = &pll1_div2_clk,
 311         [1] = &pll2_clk,
 312         [2] = &sh73a0_extal2_clk,
 313         [3] = &sh73a0_extal2_clk,
 314 };
 315
 316 static struct clk *dsi_parent[8] = {
 317         [0] = &pll1_div2_clk,
 318         [1] = &pll2_clk,
 319         [2] = &main_clk,
 320         [3] = &sh73a0_extal2_clk,
 321         [4] = &sh73a0_extcki_clk,
 322 };
 323
 324 static struct clk div6_clks[DIV6_NR] = {
 325         [DIV6_VCK1] = SH_CLK_DIV6_EXT(VCLKCR1, 0,
 326                         vck_parent, ARRAY_SIZE(vck_parent), 12, 3),
 327         [DIV6_VCK2] = SH_CLK_DIV6_EXT(VCLKCR2, 0,
 328                         vck_parent, ARRAY_SIZE(vck_parent), 12, 3),
 329         [DIV6_VCK3] = SH_CLK_DIV6_EXT(VCLKCR3, 0,
 330                         vck_parent, ARRAY_SIZE(vck_parent), 12, 3),
 331         [DIV6_ZB1] = SH_CLK_DIV6_EXT(ZBCKCR, 0,
 332                         pll_parent, ARRAY_SIZE(pll_parent), 7, 1),
 333         [DIV6_FLCTL] = SH_CLK_DIV6_EXT(FLCKCR, 0,
 334                         pll_parent, ARRAY_SIZE(pll_parent), 7, 1),
 335         [DIV6_SDHI0] = SH_CLK_DIV6_EXT(SD0CKCR, 0,
 336                         pll_parent, ARRAY_SIZE(pll_parent), 6, 2),
 337         [DIV6_SDHI1] = SH_CLK_DIV6_EXT(SD1CKCR, 0,
 338                         pll_parent, ARRAY_SIZE(pll_parent), 6, 2),
 339         [DIV6_SDHI2] = SH_CLK_DIV6_EXT(SD2CKCR, 0,
 340                         pll_parent, ARRAY_SIZE(pll_parent), 6, 2),
 341         [DIV6_FSIA] = SH_CLK_DIV6_EXT(FSIACKCR, 0,
 342                         pll_parent, ARRAY_SIZE(pll_parent), 6, 1),
 343         [DIV6_FSIB] = SH_CLK_DIV6_EXT(FSIBCKCR, 0,
 344                         pll_parent, ARRAY_SIZE(pll_parent), 6, 1),
 345         [DIV6_SUB] = SH_CLK_DIV6_EXT(SUBCKCR, 0,
 346                         pll_extal2_parent, ARRAY_SIZE(pll_extal2_parent), 6, 2),
 347         [DIV6_SPUA] = SH_CLK_DIV6_EXT(SPUACKCR, 0,
 348                         pll_extal2_parent, ARRAY_SIZE(pll_extal2_parent), 6, 2),
 349         [DIV6_SPUV] = SH_CLK_DIV6_EXT(SPUVCKCR, 0,
 350                         pll_extal2_parent, ARRAY_SIZE(pll_extal2_parent), 6, 2),
 351         [DIV6_MSU] = SH_CLK_DIV6_EXT(MSUCKCR, 0,
 352                         pll_parent, ARRAY_SIZE(pll_parent), 7, 1),
 353         [DIV6_HSI] = SH_CLK_DIV6_EXT(HSICKCR, 0,
 354                         hsi_parent, ARRAY_SIZE(hsi_parent), 6, 2),
 355         [DIV6_MFG1] = SH_CLK_DIV6_EXT(MFCK1CR, 0,
 356                         pll_parent, ARRAY_SIZE(pll_parent), 7, 1),
 357         [DIV6_MFG2] = SH_CLK_DIV6_EXT(MFCK2CR, 0,
 358                         pll_parent, ARRAY_SIZE(pll_parent), 7, 1),
 359         [DIV6_DSIT] = SH_CLK_DIV6_EXT(DSITCKCR, 0,
 360                         pll_parent, ARRAY_SIZE(pll_parent), 7, 1),
 361         [DIV6_DSI0P] = SH_CLK_DIV6_EXT(DSI0PCKCR, 0,
 362                         dsi_parent, ARRAY_SIZE(dsi_parent), 12, 3),
 363         [DIV6_DSI1P] = SH_CLK_DIV6_EXT(DSI1PCKCR, 0,
 364                         dsi_parent, ARRAY_SIZE(dsi_parent), 12, 3),
 365 };
 366
 367 enum { MSTP001,
 368         MSTP129, MSTP128, MSTP127, MSTP126, MSTP125, MSTP118, MSTP116, MSTP100,
 369         MSTP219,
 370         MSTP207, MSTP206, MSTP204, MSTP203, MSTP202, MSTP201, MSTP200,
 371         MSTP331, MSTP329, MSTP325, MSTP323, MSTP318,
 372         MSTP314, MSTP313, MSTP312, MSTP311,
 373         MSTP411, MSTP410, MSTP403,
 374         MSTP_NR };
 375
 376 #define MSTP(_parent, _reg, _bit, _flags) \
 377         SH_CLK_MSTP32(_parent, _reg, _bit, _flags)
 378
 379 static struct clk mstp_clks[MSTP_NR] = {
 380         [MSTP001] = MSTP(&div4_clks[DIV4_HP], SMSTPCR0, 1, 0), /* IIC2 */
 381         [MSTP129] = MSTP(&div4_clks[DIV4_B], SMSTPCR1, 29, 0), /* CEU1 */
 382         [MSTP128] = MSTP(&div4_clks[DIV4_B], SMSTPCR1, 28, 0), /* CSI2-RX1 */
 383         [MSTP127] = MSTP(&div4_clks[DIV4_B], SMSTPCR1, 27, 0), /* CEU0 */
 384         [MSTP126] = MSTP(&div4_clks[DIV4_B], SMSTPCR1, 26, 0), /* CSI2-RX0 */
 385         [MSTP125] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR1, 25, 0), /* TMU0 */
 386         [MSTP118] = MSTP(&div4_clks[DIV4_B], SMSTPCR1, 18, 0), /* DSITX0 */
 387         [MSTP116] = MSTP(&div4_clks[DIV4_HP], SMSTPCR1, 16, 0), /* IIC0 */
 388         [MSTP100] = MSTP(&div4_clks[DIV4_B], SMSTPCR1, 0, 0), /* LCDC0 */
 389         [MSTP219] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 19, 0), /* SCIFA7 */
 390         [MSTP207] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 7, 0), /* SCIFA5 */
 391         [MSTP206] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 6, 0), /* SCIFB */
 392         [MSTP204] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 4, 0), /* SCIFA0 */
 393         [MSTP203] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 3, 0), /* SCIFA1 */
 394         [MSTP202] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 2, 0), /* SCIFA2 */
 395         [MSTP201] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 1, 0), /* SCIFA3 */
 396         [MSTP200] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 0, 0), /* SCIFA4 */
 397         [MSTP331] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR3, 31, 0), /* SCIFA6 */
 398         [MSTP329] = MSTP(&r_clk, SMSTPCR3, 29, 0), /* CMT10 */
 399         [MSTP325] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR3, 25, 0), /* IrDA */
 400         [MSTP323] = MSTP(&div4_clks[DIV4_HP], SMSTPCR3, 23, 0), /* IIC1 */
 401         [MSTP318] = MSTP(&div4_clks[DIV4_HP], SMSTPCR3, 18, 0), /* SY-DMAC */
 402         [MSTP314] = MSTP(&div6_clks[DIV6_SDHI0], SMSTPCR3, 14, 0), /* SDHI0 */
 403         [MSTP313] = MSTP(&div6_clks[DIV6_SDHI1], SMSTPCR3, 13, 0), /* SDHI1 */
 404         [MSTP312] = MSTP(&div4_clks[DIV4_HP], SMSTPCR3, 12, 0), /* MMCIF0 */
 405         [MSTP311] = MSTP(&div6_clks[DIV6_SDHI2], SMSTPCR3, 11, 0), /* SDHI2 */
 406         [MSTP411] = MSTP(&div4_clks[DIV4_HP], SMSTPCR4, 11, 0), /* IIC3 */
 407         [MSTP410] = MSTP(&div4_clks[DIV4_HP], SMSTPCR4, 10, 0), /* IIC4 */
 408         [MSTP403] = MSTP(&r_clk, SMSTPCR4, 3, 0), /* KEYSC */
 409 };
 410
 411 static struct clk_lookup lookups[] = {
 412         /* main clocks */
 413         CLKDEV_CON_ID("r_clk", &r_clk),
 414
 415         /* DIV6 clocks */
 416         CLKDEV_CON_ID("vck1_clk", &div6_clks[DIV6_VCK1]),
 417         CLKDEV_CON_ID("vck2_clk", &div6_clks[DIV6_VCK2]),
 418         CLKDEV_CON_ID("vck3_clk", &div6_clks[DIV6_VCK3]),
 419         CLKDEV_CON_ID("sdhi0_clk", &div6_clks[DIV6_SDHI0]),
 420         CLKDEV_CON_ID("sdhi1_clk", &div6_clks[DIV6_SDHI1]),
 421         CLKDEV_CON_ID("sdhi2_clk", &div6_clks[DIV6_SDHI2]),
 422         CLKDEV_ICK_ID("dsit_clk", "sh-mipi-dsi.0", &div6_clks[DIV6_DSIT]),
 423         CLKDEV_ICK_ID("dsit_clk", "sh-mipi-dsi.1", &div6_clks[DIV6_DSIT]),
 424         CLKDEV_ICK_ID("dsi0p_clk", "sh-mipi-dsi.0", &div6_clks[DIV6_DSI0P]),
 425         CLKDEV_ICK_ID("dsi1p_clk", "sh-mipi-dsi.1", &div6_clks[DIV6_DSI1P]),
 426
 427         /* MSTP32 clocks */
 428         CLKDEV_DEV_ID("i2c-sh_mobile.2", &mstp_clks[MSTP001]), /* I2C2 */
 429         CLKDEV_DEV_ID("sh_mobile_ceu.1", &mstp_clks[MSTP129]), /* CEU1 */
 430         CLKDEV_DEV_ID("sh-mobile-csi2.1", &mstp_clks[MSTP128]), /* CSI2-RX1 */
 431         CLKDEV_DEV_ID("sh_mobile_ceu.0", &mstp_clks[MSTP127]), /* CEU0 */
 432         CLKDEV_DEV_ID("sh-mobile-csi2.0", &mstp_clks[MSTP126]), /* CSI2-RX0 */
 433         CLKDEV_DEV_ID("sh_tmu.0", &mstp_clks[MSTP125]), /* TMU00 */
 434         CLKDEV_DEV_ID("sh_tmu.1", &mstp_clks[MSTP125]), /* TMU01 */
 435         CLKDEV_DEV_ID("sh-mipi-dsi.0", &mstp_clks[MSTP118]), /* DSITX */
 436         CLKDEV_DEV_ID("i2c-sh_mobile.0", &mstp_clks[MSTP116]), /* I2C0 */
 437         CLKDEV_DEV_ID("sh_mobile_lcdc_fb.0", &mstp_clks[MSTP100]), /* LCDC0 */
 438         CLKDEV_DEV_ID("sh-sci.7", &mstp_clks[MSTP219]), /* SCIFA7 */
 439         CLKDEV_DEV_ID("sh-sci.5", &mstp_clks[MSTP207]), /* SCIFA5 */
 440         CLKDEV_DEV_ID("sh-sci.8", &mstp_clks[MSTP206]), /* SCIFB */
 441         CLKDEV_DEV_ID("sh-sci.0", &mstp_clks[MSTP204]), /* SCIFA0 */
 442         CLKDEV_DEV_ID("sh-sci.1", &mstp_clks[MSTP203]), /* SCIFA1 */
 443         CLKDEV_DEV_ID("sh-sci.2", &mstp_clks[MSTP202]), /* SCIFA2 */
 444         CLKDEV_DEV_ID("sh-sci.3", &mstp_clks[MSTP201]), /* SCIFA3 */
 445         CLKDEV_DEV_ID("sh-sci.4", &mstp_clks[MSTP200]), /* SCIFA4 */
 446         CLKDEV_DEV_ID("sh-sci.6", &mstp_clks[MSTP331]), /* SCIFA6 */
 447         CLKDEV_DEV_ID("sh_cmt.10", &mstp_clks[MSTP329]), /* CMT10 */
 448         CLKDEV_DEV_ID("sh_irda.0", &mstp_clks[MSTP325]), /* IrDA */
 449         CLKDEV_DEV_ID("i2c-sh_mobile.1", &mstp_clks[MSTP323]), /* I2C1 */
 450         CLKDEV_DEV_ID("sh-dma-engine.0", &mstp_clks[MSTP318]), /* SY-DMAC */
 451         CLKDEV_DEV_ID("sh_mobile_sdhi.0", &mstp_clks[MSTP314]), /* SDHI0 */
 452         CLKDEV_DEV_ID("sh_mobile_sdhi.1", &mstp_clks[MSTP313]), /* SDHI1 */
 453         CLKDEV_DEV_ID("sh_mmcif.0", &mstp_clks[MSTP312]), /* MMCIF0 */
 454         CLKDEV_DEV_ID("sh_mobile_sdhi.2", &mstp_clks[MSTP311]), /* SDHI2 */
 455         CLKDEV_DEV_ID("i2c-sh_mobile.3", &mstp_clks[MSTP411]), /* I2C3 */
 456         CLKDEV_DEV_ID("i2c-sh_mobile.4", &mstp_clks[MSTP410]), /* I2C4 */
 457         CLKDEV_DEV_ID("sh_keysc.0", &mstp_clks[MSTP403]), /* KEYSC */
 458 };
 459
 460 void __init sh73a0_clock_init(void)
 461 {
 462         int k, ret = 0;
 463
 464         /* Set SDHI clocks to a known state */
 465         __raw_writel(0x108, SD0CKCR);
 466         __raw_writel(0x108, SD1CKCR);
 467         __raw_writel(0x108, SD2CKCR);
 468
 469         /* detect main clock parent */
 470         switch ((__raw_readl(CKSCR) >> 28) & 0x03) {
 471         case 0:
 472                 main_clk.parent = &sh73a0_extal1_clk;
 473                 break;
 474         case 1:
 475                 main_clk.parent = &extal1_div2_clk;
 476                 break;
 477         case 2:
 478                 main_clk.parent = &sh73a0_extal2_clk;
 479                 break;
 480         case 3:
 481                 main_clk.parent = &extal2_div2_clk;
 482                 break;
 483         }
 484
 485         for (k = 0; !ret && (k < ARRAY_SIZE(main_clks)); k++)
 486                 ret = clk_register(main_clks[k]);
 487
 488         if (!ret)
 489                 ret = sh_clk_div4_register(div4_clks, DIV4_NR, &div4_table);
 490
 491         if (!ret)
 492                 ret = sh_clk_div6_reparent_register(div6_clks, DIV6_NR);
 493
 494         if (!ret)
 495                 ret = sh_clk_mstp32_register(mstp_clks, MSTP_NR);
 496
 497         clkdev_add_table(lookups, ARRAY_SIZE(lookups));
 498
 499         if (!ret)
 500                 clk_init();
 501         else
 502                 panic("failed to setup sh73a0 clocks\n");
 503 }