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

   1 /*
   2  * SH7372 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 /* SH7372 registers */
  27 #define FRQCRA          0xe6150000
  28 #define FRQCRB          0xe6150004
  29 #define FRQCRC          0xe61500e0
  30 #define FRQCRD          0xe61500e4
  31 #define VCLKCR1         0xe6150008
  32 #define VCLKCR2         0xe615000c
  33 #define VCLKCR3         0xe615001c
  34 #define FMSICKCR        0xe6150010
  35 #define FMSOCKCR        0xe6150014
  36 #define FSIACKCR        0xe6150018
  37 #define FSIBCKCR        0xe6150090
  38 #define SUBCKCR         0xe6150080
  39 #define SPUCKCR         0xe6150084
  40 #define VOUCKCR         0xe6150088
  41 #define HDMICKCR        0xe6150094
  42 #define DSITCKCR        0xe6150060
  43 #define DSI0PCKCR       0xe6150064
  44 #define DSI1PCKCR       0xe6150098
  45 #define PLLC01CR        0xe6150028
  46 #define PLLC2CR         0xe615002c
  47 #define SMSTPCR0        0xe6150130
  48 #define SMSTPCR1        0xe6150134
  49 #define SMSTPCR2        0xe6150138
  50 #define SMSTPCR3        0xe615013c
  51 #define SMSTPCR4        0xe6150140
  52
  53 #define FSIDIVA         0xFE1F8000
  54 #define FSIDIVB         0xFE1F8008
  55
  56 /* Platforms must set frequency on their DV_CLKI pin */
  57 struct clk sh7372_dv_clki_clk = {
  58 };
  59
  60 /* Fixed 32 KHz root clock from EXTALR pin */
  61 static struct clk r_clk = {
  62         .rate           = 32768,
  63 };
  64
  65 /*
  66  * 26MHz default rate for the EXTAL1 root input clock.
  67  * If needed, reset this with clk_set_rate() from the platform code.
  68  */
  69 struct clk sh7372_extal1_clk = {
  70         .rate           = 26000000,
  71 };
  72
  73 /*
  74  * 48MHz default rate for the EXTAL2 root input clock.
  75  * If needed, reset this with clk_set_rate() from the platform code.
  76  */
  77 struct clk sh7372_extal2_clk = {
  78         .rate           = 48000000,
  79 };
  80
  81 /* A fixed divide-by-2 block */
  82 static unsigned long div2_recalc(struct clk *clk)
  83 {
  84         return clk->parent->rate / 2;
  85 }
  86
  87 static struct clk_ops div2_clk_ops = {
  88         .recalc         = div2_recalc,
  89 };
  90
  91 /* Divide dv_clki by two */
  92 struct clk sh7372_dv_clki_div2_clk = {
  93         .ops            = &div2_clk_ops,
  94         .parent         = &sh7372_dv_clki_clk,
  95 };
  96
  97 /* Divide extal1 by two */
  98 static struct clk extal1_div2_clk = {
  99         .ops            = &div2_clk_ops,
 100         .parent         = &sh7372_extal1_clk,
 101 };
 102
 103 /* Divide extal2 by two */
 104 static struct clk extal2_div2_clk = {
 105         .ops            = &div2_clk_ops,
 106         .parent         = &sh7372_extal2_clk,
 107 };
 108
 109 /* Divide extal2 by four */
 110 static struct clk extal2_div4_clk = {
 111         .ops            = &div2_clk_ops,
 112         .parent         = &extal2_div2_clk,
 113 };
 114
 115 /* PLLC0 and PLLC1 */
 116 static unsigned long pllc01_recalc(struct clk *clk)
 117 {
 118         unsigned long mult = 1;
 119
 120         if (__raw_readl(PLLC01CR) & (1 << 14))
 121                 mult = (((__raw_readl(clk->enable_reg) >> 24) & 0x3f) + 1) * 2;
 122
 123         return clk->parent->rate * mult;
 124 }
 125
 126 static struct clk_ops pllc01_clk_ops = {
 127         .recalc         = pllc01_recalc,
 128 };
 129
 130 static struct clk pllc0_clk = {
 131         .ops            = &pllc01_clk_ops,
 132         .flags          = CLK_ENABLE_ON_INIT,
 133         .parent         = &extal1_div2_clk,
 134         .enable_reg     = (void __iomem *)FRQCRC,
 135 };
 136
 137 static struct clk pllc1_clk = {
 138         .ops            = &pllc01_clk_ops,
 139         .flags          = CLK_ENABLE_ON_INIT,
 140         .parent         = &extal1_div2_clk,
 141         .enable_reg     = (void __iomem *)FRQCRA,
 142 };
 143
 144 /* Divide PLLC1 by two */
 145 static struct clk pllc1_div2_clk = {
 146         .ops            = &div2_clk_ops,
 147         .parent         = &pllc1_clk,
 148 };
 149
 150 /* PLLC2 */
 151
 152 /* Indices are important - they are the actual src selecting values */
 153 static struct clk *pllc2_parent[] = {
 154         [0] = &extal1_div2_clk,
 155         [1] = &extal2_div2_clk,
 156         [2] = &sh7372_dv_clki_div2_clk,
 157 };
 158
 159 /* Only multipliers 20 * 2 to 46 * 2 are valid, last entry for CPUFREQ_TABLE_END */
 160 static struct cpufreq_frequency_table pllc2_freq_table[29];
 161
 162 static void pllc2_table_rebuild(struct clk *clk)
 163 {
 164         int i;
 165
 166         /* Initialise PLLC2 frequency table */
 167         for (i = 0; i < ARRAY_SIZE(pllc2_freq_table) - 2; i++) {
 168                 pllc2_freq_table[i].frequency = clk->parent->rate * (i + 20) * 2;
 169                 pllc2_freq_table[i].index = i;
 170         }
 171
 172         /* This is a special entry - switching PLL off makes it a repeater */
 173         pllc2_freq_table[i].frequency = clk->parent->rate;
 174         pllc2_freq_table[i].index = i;
 175
 176         pllc2_freq_table[++i].frequency = CPUFREQ_TABLE_END;
 177         pllc2_freq_table[i].index = i;
 178 }
 179
 180 static unsigned long pllc2_recalc(struct clk *clk)
 181 {
 182         unsigned long mult = 1;
 183
 184         pllc2_table_rebuild(clk);
 185
 186         /*
 187          * If the PLL is off, mult == 1, clk->rate will be updated in
 188          * pllc2_enable().
 189          */
 190         if (__raw_readl(PLLC2CR) & (1 << 31))
 191                 mult = (((__raw_readl(PLLC2CR) >> 24) & 0x3f) + 1) * 2;
 192
 193         return clk->parent->rate * mult;
 194 }
 195
 196 static long pllc2_round_rate(struct clk *clk, unsigned long rate)
 197 {
 198         return clk_rate_table_round(clk, clk->freq_table, rate);
 199 }
 200
 201 static int pllc2_enable(struct clk *clk)
 202 {
 203         int i;
 204
 205         __raw_writel(__raw_readl(PLLC2CR) | 0x80000000, PLLC2CR);
 206
 207         for (i = 0; i < 100; i++)
 208                 if (__raw_readl(PLLC2CR) & 0x80000000) {
 209                         clk->rate = pllc2_recalc(clk);
 210                         return 0;
 211                 }
 212
 213         pr_err("%s(): timeout!\n", __func__);
 214
 215         return -ETIMEDOUT;
 216 }
 217
 218 static void pllc2_disable(struct clk *clk)
 219 {
 220         __raw_writel(__raw_readl(PLLC2CR) & ~0x80000000, PLLC2CR);
 221 }
 222
 223 static int pllc2_set_rate(struct clk *clk, unsigned long rate)
 224 {
 225         unsigned long value;
 226         int idx;
 227
 228         idx = clk_rate_table_find(clk, clk->freq_table, rate);
 229         if (idx < 0)
 230                 return idx;
 231
 232         if (rate == clk->parent->rate)
 233                 return -EINVAL;
 234
 235         value = __raw_readl(PLLC2CR) & ~(0x3f << 24);
 236
 237         __raw_writel(value | ((idx + 19) << 24), PLLC2CR);
 238
 239         clk->rate = clk->freq_table[idx].frequency;
 240
 241         return 0;
 242 }
 243
 244 static int pllc2_set_parent(struct clk *clk, struct clk *parent)
 245 {
 246         u32 value;
 247         int ret, i;
 248
 249         if (!clk->parent_table || !clk->parent_num)
 250                 return -EINVAL;
 251
 252         /* Search the parent */
 253         for (i = 0; i < clk->parent_num; i++)
 254                 if (clk->parent_table[i] == parent)
 255                         break;
 256
 257         if (i == clk->parent_num)
 258                 return -ENODEV;
 259
 260         ret = clk_reparent(clk, parent);
 261         if (ret < 0)
 262                 return ret;
 263
 264         value = __raw_readl(PLLC2CR) & ~(3 << 6);
 265
 266         __raw_writel(value | (i << 6), PLLC2CR);
 267
 268         /* Rebiuld the frequency table */
 269         pllc2_table_rebuild(clk);
 270
 271         return 0;
 272 }
 273
 274 static struct clk_ops pllc2_clk_ops = {
 275         .recalc         = pllc2_recalc,
 276         .round_rate     = pllc2_round_rate,
 277         .set_rate       = pllc2_set_rate,
 278         .enable         = pllc2_enable,
 279         .disable        = pllc2_disable,
 280         .set_parent     = pllc2_set_parent,
 281 };
 282
 283 struct clk sh7372_pllc2_clk = {
 284         .ops            = &pllc2_clk_ops,
 285         .parent         = &extal1_div2_clk,
 286         .freq_table     = pllc2_freq_table,
 287         .nr_freqs       = ARRAY_SIZE(pllc2_freq_table) - 1,
 288         .parent_table   = pllc2_parent,
 289         .parent_num     = ARRAY_SIZE(pllc2_parent),
 290 };
 291
 292 /* External input clock (pin name: FSIACK/FSIBCK ) */
 293 struct clk sh7372_fsiack_clk = {
 294 };
 295
 296 struct clk sh7372_fsibck_clk = {
 297 };
 298
 299 static struct clk *main_clks[] = {
 300         &sh7372_dv_clki_clk,
 301         &r_clk,
 302         &sh7372_extal1_clk,
 303         &sh7372_extal2_clk,
 304         &sh7372_dv_clki_div2_clk,
 305         &extal1_div2_clk,
 306         &extal2_div2_clk,
 307         &extal2_div4_clk,
 308         &pllc0_clk,
 309         &pllc1_clk,
 310         &pllc1_div2_clk,
 311         &sh7372_pllc2_clk,
 312         &sh7372_fsiack_clk,
 313         &sh7372_fsibck_clk,
 314 };
 315
 316 static void div4_kick(struct clk *clk)
 317 {
 318         unsigned long value;
 319
 320         /* set KICK bit in FRQCRB to update hardware setting */
 321         value = __raw_readl(FRQCRB);
 322         value |= (1 << 31);
 323         __raw_writel(value, FRQCRB);
 324 }
 325
 326 static int divisors[] = { 2, 3, 4, 6, 8, 12, 16, 18,
 327                           24, 32, 36, 48, 0, 72, 96, 0 };
 328
 329 static struct clk_div_mult_table div4_div_mult_table = {
 330         .divisors = divisors,
 331         .nr_divisors = ARRAY_SIZE(divisors),
 332 };
 333
 334 static struct clk_div4_table div4_table = {
 335         .div_mult_table = &div4_div_mult_table,
 336         .kick = div4_kick,
 337 };
 338
 339 enum { DIV4_I, DIV4_ZG, DIV4_B, DIV4_M1, DIV4_CSIR,
 340        DIV4_ZTR, DIV4_ZT, DIV4_ZX, DIV4_HP,
 341        DIV4_ISPB, DIV4_S, DIV4_ZB, DIV4_ZB3, DIV4_CP,
 342        DIV4_DDRP, DIV4_NR };
 343
 344 #define DIV4(_reg, _bit, _mask, _flags) \
 345   SH_CLK_DIV4(&pllc1_clk, _reg, _bit, _mask, _flags)
 346
 347 static struct clk div4_clks[DIV4_NR] = {
 348         [DIV4_I] = DIV4(FRQCRA, 20, 0x6fff, CLK_ENABLE_ON_INIT),
 349         [DIV4_ZG] = DIV4(FRQCRA, 16, 0x6fff, CLK_ENABLE_ON_INIT),
 350         [DIV4_B] = DIV4(FRQCRA, 8, 0x6fff, CLK_ENABLE_ON_INIT),
 351         [DIV4_M1] = DIV4(FRQCRA, 4, 0x6fff, CLK_ENABLE_ON_INIT),
 352         [DIV4_CSIR] = DIV4(FRQCRA, 0, 0x6fff, 0),
 353         [DIV4_ZTR] = DIV4(FRQCRB, 20, 0x6fff, 0),
 354         [DIV4_ZT] = DIV4(FRQCRB, 16, 0x6fff, 0),
 355         [DIV4_ZX] = DIV4(FRQCRB, 12, 0x6fff, 0),
 356         [DIV4_HP] = DIV4(FRQCRB, 4, 0x6fff, 0),
 357         [DIV4_ISPB] = DIV4(FRQCRC, 20, 0x6fff, 0),
 358         [DIV4_S] = DIV4(FRQCRC, 12, 0x6fff, 0),
 359         [DIV4_ZB] = DIV4(FRQCRC, 8, 0x6fff, 0),
 360         [DIV4_ZB3] = DIV4(FRQCRC, 4, 0x6fff, 0),
 361         [DIV4_CP] = DIV4(FRQCRC, 0, 0x6fff, 0),
 362         [DIV4_DDRP] = DIV4(FRQCRD, 0, 0x677c, 0),
 363 };
 364
 365 enum { DIV6_VCK1, DIV6_VCK2, DIV6_VCK3, DIV6_FMSI, DIV6_FMSO,
 366        DIV6_SUB, DIV6_SPU,
 367        DIV6_VOU, DIV6_DSIT, DIV6_DSI0P, DIV6_DSI1P,
 368        DIV6_NR };
 369
 370 static struct clk div6_clks[DIV6_NR] = {
 371         [DIV6_VCK1] = SH_CLK_DIV6(&pllc1_div2_clk, VCLKCR1, 0),
 372         [DIV6_VCK2] = SH_CLK_DIV6(&pllc1_div2_clk, VCLKCR2, 0),
 373         [DIV6_VCK3] = SH_CLK_DIV6(&pllc1_div2_clk, VCLKCR3, 0),
 374         [DIV6_FMSI] = SH_CLK_DIV6(&pllc1_div2_clk, FMSICKCR, 0),
 375         [DIV6_FMSO] = SH_CLK_DIV6(&pllc1_div2_clk, FMSOCKCR, 0),
 376         [DIV6_SUB] = SH_CLK_DIV6(&sh7372_extal2_clk, SUBCKCR, 0),
 377         [DIV6_SPU] = SH_CLK_DIV6(&pllc1_div2_clk, SPUCKCR, 0),
 378         [DIV6_VOU] = SH_CLK_DIV6(&pllc1_div2_clk, VOUCKCR, 0),
 379         [DIV6_DSIT] = SH_CLK_DIV6(&pllc1_div2_clk, DSITCKCR, 0),
 380         [DIV6_DSI0P] = SH_CLK_DIV6(&pllc1_div2_clk, DSI0PCKCR, 0),
 381         [DIV6_DSI1P] = SH_CLK_DIV6(&pllc1_div2_clk, DSI1PCKCR, 0),
 382 };
 383
 384 enum { DIV6_HDMI, DIV6_FSIA, DIV6_FSIB, DIV6_REPARENT_NR };
 385
 386 /* Indices are important - they are the actual src selecting values */
 387 static struct clk *hdmi_parent[] = {
 388         [0] = &pllc1_div2_clk,
 389         [1] = &sh7372_pllc2_clk,
 390         [2] = &sh7372_dv_clki_clk,
 391         [3] = NULL,     /* pllc2_div4 not implemented yet */
 392 };
 393
 394 static struct clk *fsiackcr_parent[] = {
 395         [0] = &pllc1_div2_clk,
 396         [1] = &sh7372_pllc2_clk,
 397         [2] = &sh7372_fsiack_clk, /* external input for FSI A */
 398         [3] = NULL,     /* setting prohibited */
 399 };
 400
 401 static struct clk *fsibckcr_parent[] = {
 402         [0] = &pllc1_div2_clk,
 403         [1] = &sh7372_pllc2_clk,
 404         [2] = &sh7372_fsibck_clk, /* external input for FSI B */
 405         [3] = NULL,     /* setting prohibited */
 406 };
 407
 408 static struct clk div6_reparent_clks[DIV6_REPARENT_NR] = {
 409         [DIV6_HDMI] = SH_CLK_DIV6_EXT(&pllc1_div2_clk, HDMICKCR, 0,
 410                                       hdmi_parent, ARRAY_SIZE(hdmi_parent), 6, 2),
 411         [DIV6_FSIA] = SH_CLK_DIV6_EXT(&pllc1_div2_clk, FSIACKCR, 0,
 412                                       fsiackcr_parent, ARRAY_SIZE(fsiackcr_parent), 6, 2),
 413         [DIV6_FSIB] = SH_CLK_DIV6_EXT(&pllc1_div2_clk, FSIBCKCR, 0,
 414                                       fsibckcr_parent, ARRAY_SIZE(fsibckcr_parent), 6, 2),
 415 };
 416
 417 /* FSI DIV */
 418 static unsigned long fsidiv_recalc(struct clk *clk)
 419 {
 420         unsigned long value;
 421
 422         value = __raw_readl(clk->mapping->base);
 423
 424         value >>= 16;
 425         if (value < 2)
 426                 return 0;
 427
 428         return clk->parent->rate / value;
 429 }
 430
 431 static long fsidiv_round_rate(struct clk *clk, unsigned long rate)
 432 {
 433         return clk_rate_div_range_round(clk, 2, 0xffff, rate);
 434 }
 435
 436 static void fsidiv_disable(struct clk *clk)
 437 {
 438         __raw_writel(0, clk->mapping->base);
 439 }
 440
 441 static int fsidiv_enable(struct clk *clk)
 442 {
 443         unsigned long value;
 444
 445         value  = __raw_readl(clk->mapping->base) >> 16;
 446         if (value < 2)
 447                 return -EIO;
 448
 449         __raw_writel((value << 16) | 0x3, clk->mapping->base);
 450
 451         return 0;
 452 }
 453
 454 static int fsidiv_set_rate(struct clk *clk, unsigned long rate)
 455 {
 456         int idx;
 457
 458         idx = (clk->parent->rate / rate) & 0xffff;
 459         if (idx < 2)
 460                 return -EINVAL;
 461
 462         __raw_writel(idx << 16, clk->mapping->base);
 463         return 0;
 464 }
 465
 466 static struct clk_ops fsidiv_clk_ops = {
 467         .recalc         = fsidiv_recalc,
 468         .round_rate     = fsidiv_round_rate,
 469         .set_rate       = fsidiv_set_rate,
 470         .enable         = fsidiv_enable,
 471         .disable        = fsidiv_disable,
 472 };
 473
 474 static struct clk_mapping sh7372_fsidiva_clk_mapping = {
 475         .phys   = FSIDIVA,
 476         .len    = 8,
 477 };
 478
 479 struct clk sh7372_fsidiva_clk = {
 480         .ops            = &fsidiv_clk_ops,
 481         .parent         = &div6_reparent_clks[DIV6_FSIA], /* late install */
 482         .mapping        = &sh7372_fsidiva_clk_mapping,
 483 };
 484
 485 static struct clk_mapping sh7372_fsidivb_clk_mapping = {
 486         .phys   = FSIDIVB,
 487         .len    = 8,
 488 };
 489
 490 struct clk sh7372_fsidivb_clk = {
 491         .ops            = &fsidiv_clk_ops,
 492         .parent         = &div6_reparent_clks[DIV6_FSIB],  /* late install */
 493         .mapping        = &sh7372_fsidivb_clk_mapping,
 494 };
 495
 496 static struct clk *late_main_clks[] = {
 497         &sh7372_fsidiva_clk,
 498         &sh7372_fsidivb_clk,
 499 };
 500
 501 enum { MSTP001,
 502        MSTP131, MSTP130,
 503        MSTP129, MSTP128, MSTP127, MSTP126, MSTP125,
 504        MSTP118, MSTP117, MSTP116, MSTP113,
 505        MSTP106, MSTP101, MSTP100,
 506        MSTP223,
 507        MSTP207, MSTP206, MSTP204, MSTP203, MSTP202, MSTP201, MSTP200,
 508        MSTP329, MSTP328, MSTP323, MSTP322, MSTP314, MSTP313, MSTP312,
 509        MSTP423, MSTP415, MSTP413, MSTP411, MSTP410, MSTP406, MSTP403,
 510        MSTP_NR };
 511
 512 #define MSTP(_parent, _reg, _bit, _flags) \
 513   SH_CLK_MSTP32(_parent, _reg, _bit, _flags)
 514
 515 static struct clk mstp_clks[MSTP_NR] = {
 516         [MSTP001] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR0, 1, 0), /* IIC2 */
 517         [MSTP131] = MSTP(&div4_clks[DIV4_B], SMSTPCR1, 31, 0), /* VEU3 */
 518         [MSTP130] = MSTP(&div4_clks[DIV4_B], SMSTPCR1, 30, 0), /* VEU2 */
 519         [MSTP129] = MSTP(&div4_clks[DIV4_B], SMSTPCR1, 29, 0), /* VEU1 */
 520         [MSTP128] = MSTP(&div4_clks[DIV4_B], SMSTPCR1, 28, 0), /* VEU0 */
 521         [MSTP127] = MSTP(&div4_clks[DIV4_B], SMSTPCR1, 27, 0), /* CEU */
 522         [MSTP126] = MSTP(&div4_clks[DIV4_B], SMSTPCR1, 26, 0), /* CSI2 */
 523         [MSTP125] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR1, 25, 0), /* TMU0 */
 524         [MSTP118] = MSTP(&div4_clks[DIV4_B], SMSTPCR1, 18, 0), /* DSITX */
 525         [MSTP117] = MSTP(&div4_clks[DIV4_B], SMSTPCR1, 17, 0), /* LCDC1 */
 526         [MSTP116] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR1, 16, 0), /* IIC0 */
 527         [MSTP113] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR1, 13, 0), /* MERAM */
 528         [MSTP106] = MSTP(&div4_clks[DIV4_B], SMSTPCR1, 6, 0), /* JPU */
 529         [MSTP101] = MSTP(&div4_clks[DIV4_M1], SMSTPCR1, 1, 0), /* VPU */
 530         [MSTP100] = MSTP(&div4_clks[DIV4_B], SMSTPCR1, 0, 0), /* LCDC0 */
 531         [MSTP223] = MSTP(&div6_clks[DIV6_SPU], SMSTPCR2, 23, 0), /* SPU2 */
 532         [MSTP207] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 7, 0), /* SCIFA5 */
 533         [MSTP206] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 6, 0), /* SCIFB */
 534         [MSTP204] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 4, 0), /* SCIFA0 */
 535         [MSTP203] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 3, 0), /* SCIFA1 */
 536         [MSTP202] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 2, 0), /* SCIFA2 */
 537         [MSTP201] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 1, 0), /* SCIFA3 */
 538         [MSTP200] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR2, 0, 0), /* SCIFA4 */
 539         [MSTP329] = MSTP(&r_clk, SMSTPCR3, 29, 0), /* CMT10 */
 540         [MSTP328] = MSTP(&div6_clks[DIV6_SPU], SMSTPCR3, 28, 0), /* FSI2 */
 541         [MSTP323] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR3, 23, 0), /* IIC1 */
 542         [MSTP322] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR3, 22, 0), /* USB0 */
 543         [MSTP314] = MSTP(&div4_clks[DIV4_HP], SMSTPCR3, 14, 0), /* SDHI0 */
 544         [MSTP313] = MSTP(&div4_clks[DIV4_HP], SMSTPCR3, 13, 0), /* SDHI1 */
 545         [MSTP312] = MSTP(&div4_clks[DIV4_HP], SMSTPCR3, 12, 0), /* MMC */
 546         [MSTP423] = MSTP(&div4_clks[DIV4_B], SMSTPCR4, 23, 0), /* DSITX1 */
 547         [MSTP415] = MSTP(&div4_clks[DIV4_HP], SMSTPCR4, 15, 0), /* SDHI2 */
 548         [MSTP413] = MSTP(&pllc1_div2_clk, SMSTPCR4, 13, 0), /* HDMI */
 549         [MSTP411] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR4, 11, 0), /* IIC3 */
 550         [MSTP410] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR4, 10, 0), /* IIC4 */
 551         [MSTP406] = MSTP(&div6_clks[DIV6_SUB], SMSTPCR4, 6, 0), /* USB1 */
 552         [MSTP403] = MSTP(&r_clk, SMSTPCR4, 3, 0), /* KEYSC */
 553 };
 554
 555 #define CLKDEV_CON_ID(_id, _clk) { .con_id = _id, .clk = _clk }
 556 #define CLKDEV_DEV_ID(_id, _clk) { .dev_id = _id, .clk = _clk }
 557 #define CLKDEV_ICK_ID(_cid, _did, _clk) { .con_id = _cid, .dev_id = _did, .clk = _clk }
 558
 559 static struct clk_lookup lookups[] = {
 560         /* main clocks */
 561         CLKDEV_CON_ID("dv_clki_div2_clk", &sh7372_dv_clki_div2_clk),
 562         CLKDEV_CON_ID("r_clk", &r_clk),
 563         CLKDEV_CON_ID("extal1", &sh7372_extal1_clk),
 564         CLKDEV_CON_ID("extal2", &sh7372_extal2_clk),
 565         CLKDEV_CON_ID("extal1_div2_clk", &extal1_div2_clk),
 566         CLKDEV_CON_ID("extal2_div2_clk", &extal2_div2_clk),
 567         CLKDEV_CON_ID("extal2_div4_clk", &extal2_div4_clk),
 568         CLKDEV_CON_ID("pllc0_clk", &pllc0_clk),
 569         CLKDEV_CON_ID("pllc1_clk", &pllc1_clk),
 570         CLKDEV_CON_ID("pllc1_div2_clk", &pllc1_div2_clk),
 571         CLKDEV_CON_ID("pllc2_clk", &sh7372_pllc2_clk),
 572
 573         /* DIV4 clocks */
 574         CLKDEV_CON_ID("i_clk", &div4_clks[DIV4_I]),
 575         CLKDEV_CON_ID("zg_clk", &div4_clks[DIV4_ZG]),
 576         CLKDEV_CON_ID("b_clk", &div4_clks[DIV4_B]),
 577         CLKDEV_CON_ID("m1_clk", &div4_clks[DIV4_M1]),
 578         CLKDEV_CON_ID("csir_clk", &div4_clks[DIV4_CSIR]),
 579         CLKDEV_CON_ID("ztr_clk", &div4_clks[DIV4_ZTR]),
 580         CLKDEV_CON_ID("zt_clk", &div4_clks[DIV4_ZT]),
 581         CLKDEV_CON_ID("zx_clk", &div4_clks[DIV4_ZX]),
 582         CLKDEV_CON_ID("hp_clk", &div4_clks[DIV4_HP]),
 583         CLKDEV_CON_ID("ispb_clk", &div4_clks[DIV4_ISPB]),
 584         CLKDEV_CON_ID("s_clk", &div4_clks[DIV4_S]),
 585         CLKDEV_CON_ID("zb_clk", &div4_clks[DIV4_ZB]),
 586         CLKDEV_CON_ID("zb3_clk", &div4_clks[DIV4_ZB3]),
 587         CLKDEV_CON_ID("cp_clk", &div4_clks[DIV4_CP]),
 588         CLKDEV_CON_ID("ddrp_clk", &div4_clks[DIV4_DDRP]),
 589
 590         /* DIV6 clocks */
 591         CLKDEV_CON_ID("vck1_clk", &div6_clks[DIV6_VCK1]),
 592         CLKDEV_CON_ID("vck2_clk", &div6_clks[DIV6_VCK2]),
 593         CLKDEV_CON_ID("vck3_clk", &div6_clks[DIV6_VCK3]),
 594         CLKDEV_CON_ID("fmsi_clk", &div6_clks[DIV6_FMSI]),
 595         CLKDEV_CON_ID("fmso_clk", &div6_clks[DIV6_FMSO]),
 596         CLKDEV_CON_ID("sub_clk", &div6_clks[DIV6_SUB]),
 597         CLKDEV_CON_ID("spu_clk", &div6_clks[DIV6_SPU]),
 598         CLKDEV_CON_ID("vou_clk", &div6_clks[DIV6_VOU]),
 599         CLKDEV_CON_ID("hdmi_clk", &div6_reparent_clks[DIV6_HDMI]),
 600         CLKDEV_ICK_ID("dsit_clk", "sh-mipi-dsi.0", &div6_clks[DIV6_DSIT]),
 601         CLKDEV_ICK_ID("dsit_clk", "sh-mipi-dsi.1", &div6_clks[DIV6_DSIT]),
 602         CLKDEV_ICK_ID("dsi0p_clk", "sh-mipi-dsi.0", &div6_clks[DIV6_DSI0P]),
 603         CLKDEV_ICK_ID("dsi1p_clk", "sh-mipi-dsi.1", &div6_clks[DIV6_DSI1P]),
 604
 605         /* MSTP32 clocks */
 606         CLKDEV_DEV_ID("i2c-sh_mobile.2", &mstp_clks[MSTP001]), /* IIC2 */
 607         CLKDEV_DEV_ID("uio_pdrv_genirq.4", &mstp_clks[MSTP131]), /* VEU3 */
 608         CLKDEV_DEV_ID("uio_pdrv_genirq.3", &mstp_clks[MSTP130]), /* VEU2 */
 609         CLKDEV_DEV_ID("uio_pdrv_genirq.2", &mstp_clks[MSTP129]), /* VEU1 */
 610         CLKDEV_DEV_ID("uio_pdrv_genirq.1", &mstp_clks[MSTP128]), /* VEU0 */
 611         CLKDEV_DEV_ID("sh_mobile_ceu.0", &mstp_clks[MSTP127]), /* CEU */
 612         CLKDEV_DEV_ID("sh-mobile-csi2.0", &mstp_clks[MSTP126]), /* CSI2 */
 613         CLKDEV_DEV_ID("sh_tmu.0", &mstp_clks[MSTP125]), /* TMU00 */
 614         CLKDEV_DEV_ID("sh_tmu.1", &mstp_clks[MSTP125]), /* TMU01 */
 615         CLKDEV_DEV_ID("sh-mipi-dsi.0", &mstp_clks[MSTP118]), /* DSITX0 */
 616         CLKDEV_DEV_ID("sh_mobile_lcdc_fb.1", &mstp_clks[MSTP117]), /* LCDC1 */
 617         CLKDEV_DEV_ID("i2c-sh_mobile.0", &mstp_clks[MSTP116]), /* IIC0 */
 618         CLKDEV_DEV_ID("sh_mobile_meram.0", &mstp_clks[MSTP113]), /* MERAM */
 619         CLKDEV_DEV_ID("uio_pdrv_genirq.5", &mstp_clks[MSTP106]), /* JPU */
 620         CLKDEV_DEV_ID("uio_pdrv_genirq.0", &mstp_clks[MSTP101]), /* VPU */
 621         CLKDEV_DEV_ID("sh_mobile_lcdc_fb.0", &mstp_clks[MSTP100]), /* LCDC0 */
 622         CLKDEV_DEV_ID("uio_pdrv_genirq.6", &mstp_clks[MSTP223]), /* SPU2DSP0 */
 623         CLKDEV_DEV_ID("uio_pdrv_genirq.7", &mstp_clks[MSTP223]), /* SPU2DSP1 */
 624         CLKDEV_DEV_ID("sh-sci.5", &mstp_clks[MSTP207]), /* SCIFA5 */
 625         CLKDEV_DEV_ID("sh-sci.6", &mstp_clks[MSTP206]), /* SCIFB */
 626         CLKDEV_DEV_ID("sh-sci.0", &mstp_clks[MSTP204]), /* SCIFA0 */
 627         CLKDEV_DEV_ID("sh-sci.1", &mstp_clks[MSTP203]), /* SCIFA1 */
 628         CLKDEV_DEV_ID("sh-sci.2", &mstp_clks[MSTP202]), /* SCIFA2 */
 629         CLKDEV_DEV_ID("sh-sci.3", &mstp_clks[MSTP201]), /* SCIFA3 */
 630         CLKDEV_DEV_ID("sh-sci.4", &mstp_clks[MSTP200]), /* SCIFA4 */
 631         CLKDEV_DEV_ID("sh_cmt.10", &mstp_clks[MSTP329]), /* CMT10 */
 632         CLKDEV_DEV_ID("sh_fsi2", &mstp_clks[MSTP328]), /* FSI2 */
 633         CLKDEV_DEV_ID("i2c-sh_mobile.1", &mstp_clks[MSTP323]), /* IIC1 */
 634         CLKDEV_DEV_ID("r8a66597_hcd.0", &mstp_clks[MSTP322]), /* USB0 */
 635         CLKDEV_DEV_ID("r8a66597_udc.0", &mstp_clks[MSTP322]), /* USB0 */
 636         CLKDEV_DEV_ID("sh_mobile_sdhi.0", &mstp_clks[MSTP314]), /* SDHI0 */
 637         CLKDEV_DEV_ID("sh_mobile_sdhi.1", &mstp_clks[MSTP313]), /* SDHI1 */
 638         CLKDEV_DEV_ID("sh_mmcif.0", &mstp_clks[MSTP312]), /* MMC */
 639         CLKDEV_DEV_ID("sh-mipi-dsi.1", &mstp_clks[MSTP423]), /* DSITX1 */
 640         CLKDEV_DEV_ID("sh_mobile_sdhi.2", &mstp_clks[MSTP415]), /* SDHI2 */
 641         CLKDEV_DEV_ID("sh-mobile-hdmi", &mstp_clks[MSTP413]), /* HDMI */
 642         CLKDEV_DEV_ID("i2c-sh_mobile.3", &mstp_clks[MSTP411]), /* IIC3 */
 643         CLKDEV_DEV_ID("i2c-sh_mobile.4", &mstp_clks[MSTP410]), /* IIC4 */
 644         CLKDEV_DEV_ID("r8a66597_hcd.1", &mstp_clks[MSTP406]), /* USB1 */
 645         CLKDEV_DEV_ID("r8a66597_udc.1", &mstp_clks[MSTP406]), /* USB1 */
 646         CLKDEV_DEV_ID("sh_keysc.0", &mstp_clks[MSTP403]), /* KEYSC */
 647
 648         CLKDEV_ICK_ID("ick", "sh-mobile-hdmi", &div6_reparent_clks[DIV6_HDMI]),
 649         CLKDEV_ICK_ID("icka", "sh_fsi2", &div6_reparent_clks[DIV6_FSIA]),
 650         CLKDEV_ICK_ID("ickb", "sh_fsi2", &div6_reparent_clks[DIV6_FSIB]),
 651 };
 652
 653 void __init sh7372_clock_init(void)
 654 {
 655         int k, ret = 0;
 656
 657         for (k = 0; !ret && (k < ARRAY_SIZE(main_clks)); k++)
 658                 ret = clk_register(main_clks[k]);
 659
 660         if (!ret)
 661                 ret = sh_clk_div4_register(div4_clks, DIV4_NR, &div4_table);
 662
 663         if (!ret)
 664                 ret = sh_clk_div6_register(div6_clks, DIV6_NR);
 665
 666         if (!ret)
 667                 ret = sh_clk_div6_reparent_register(div6_reparent_clks, DIV6_REPARENT_NR);
 668
 669         if (!ret)
 670                 ret = sh_clk_mstp32_register(mstp_clks, MSTP_NR);
 671
 672         for (k = 0; !ret && (k < ARRAY_SIZE(late_main_clks)); k++)
 673                 ret = clk_register(late_main_clks[k]);
 674
 675         clkdev_add_table(lookups, ARRAY_SIZE(lookups));
 676
 677         if (!ret)
 678                 clk_init();
 679         else
 680                 panic("failed to setup sh7372 clocks\n");
 681
 682 }