include/hw/misc/bcm2835_cprman_internals.h

   1 /*
   2  * BCM2835 CPRMAN clock manager
   3  *
   4  * Copyright (c) 2020 Luc Michel <luc@lmichel.fr>
   5  *
   6  * SPDX-License-Identifier: GPL-2.0-or-later
   7  */
   8
   9 #ifndef HW_MISC_CPRMAN_INTERNALS_H
  10 #define HW_MISC_CPRMAN_INTERNALS_H
  11
  12 #include "hw/registerfields.h"
  13 #include "hw/misc/bcm2835_cprman.h"
  14
  15 #define TYPE_CPRMAN_PLL "bcm2835-cprman-pll"
  16 #define TYPE_CPRMAN_PLL_CHANNEL "bcm2835-cprman-pll-channel"
  17 #define TYPE_CPRMAN_CLOCK_MUX "bcm2835-cprman-clock-mux"
  18 #define TYPE_CPRMAN_DSI0HSCK_MUX "bcm2835-cprman-dsi0hsck-mux"
  19
  20 DECLARE_INSTANCE_CHECKER(CprmanPllState, CPRMAN_PLL,
  21                          TYPE_CPRMAN_PLL)
  22 DECLARE_INSTANCE_CHECKER(CprmanPllChannelState, CPRMAN_PLL_CHANNEL,
  23                          TYPE_CPRMAN_PLL_CHANNEL)
  24 DECLARE_INSTANCE_CHECKER(CprmanClockMuxState, CPRMAN_CLOCK_MUX,
  25                          TYPE_CPRMAN_CLOCK_MUX)
  26 DECLARE_INSTANCE_CHECKER(CprmanDsi0HsckMuxState, CPRMAN_DSI0HSCK_MUX,
  27                          TYPE_CPRMAN_DSI0HSCK_MUX)
  28
  29 /* Register map */
  30
  31 /* PLLs */
  32 REG32(CM_PLLA, 0x104)
  33     FIELD(CM_PLLA, LOADDSI0, 0, 1)
  34     FIELD(CM_PLLA, HOLDDSI0, 1, 1)
  35     FIELD(CM_PLLA, LOADCCP2, 2, 1)
  36     FIELD(CM_PLLA, HOLDCCP2, 3, 1)
  37     FIELD(CM_PLLA, LOADCORE, 4, 1)
  38     FIELD(CM_PLLA, HOLDCORE, 5, 1)
  39     FIELD(CM_PLLA, LOADPER, 6, 1)
  40     FIELD(CM_PLLA, HOLDPER, 7, 1)
  41     FIELD(CM_PLLx, ANARST, 8, 1)
  42 REG32(CM_PLLC, 0x108)
  43     FIELD(CM_PLLC, LOADCORE0, 0, 1)
  44     FIELD(CM_PLLC, HOLDCORE0, 1, 1)
  45     FIELD(CM_PLLC, LOADCORE1, 2, 1)
  46     FIELD(CM_PLLC, HOLDCORE1, 3, 1)
  47     FIELD(CM_PLLC, LOADCORE2, 4, 1)
  48     FIELD(CM_PLLC, HOLDCORE2, 5, 1)
  49     FIELD(CM_PLLC, LOADPER, 6, 1)
  50     FIELD(CM_PLLC, HOLDPER, 7, 1)
  51 REG32(CM_PLLD, 0x10c)
  52     FIELD(CM_PLLD, LOADDSI0, 0, 1)
  53     FIELD(CM_PLLD, HOLDDSI0, 1, 1)
  54     FIELD(CM_PLLD, LOADDSI1, 2, 1)
  55     FIELD(CM_PLLD, HOLDDSI1, 3, 1)
  56     FIELD(CM_PLLD, LOADCORE, 4, 1)
  57     FIELD(CM_PLLD, HOLDCORE, 5, 1)
  58     FIELD(CM_PLLD, LOADPER, 6, 1)
  59     FIELD(CM_PLLD, HOLDPER, 7, 1)
  60 REG32(CM_PLLH, 0x110)
  61     FIELD(CM_PLLH, LOADPIX, 0, 1)
  62     FIELD(CM_PLLH, LOADAUX, 1, 1)
  63     FIELD(CM_PLLH, LOADRCAL, 2, 1)
  64 REG32(CM_PLLB, 0x170)
  65     FIELD(CM_PLLB, LOADARM, 0, 1)
  66     FIELD(CM_PLLB, HOLDARM, 1, 1)
  67
  68 REG32(A2W_PLLA_CTRL, 0x1100)
  69     FIELD(A2W_PLLx_CTRL, NDIV, 0, 10)
  70     FIELD(A2W_PLLx_CTRL, PDIV, 12, 3)
  71     FIELD(A2W_PLLx_CTRL, PWRDN, 16, 1)
  72     FIELD(A2W_PLLx_CTRL, PRST_DISABLE, 17, 1)
  73 REG32(A2W_PLLC_CTRL, 0x1120)
  74 REG32(A2W_PLLD_CTRL, 0x1140)
  75 REG32(A2W_PLLH_CTRL, 0x1160)
  76 REG32(A2W_PLLB_CTRL, 0x11e0)
  77
  78 REG32(A2W_PLLA_ANA0, 0x1010)
  79 REG32(A2W_PLLA_ANA1, 0x1014)
  80     FIELD(A2W_PLLx_ANA1, FB_PREDIV, 14, 1)
  81 REG32(A2W_PLLA_ANA2, 0x1018)
  82 REG32(A2W_PLLA_ANA3, 0x101c)
  83
  84 REG32(A2W_PLLC_ANA0, 0x1030)
  85 REG32(A2W_PLLC_ANA1, 0x1034)
  86 REG32(A2W_PLLC_ANA2, 0x1038)
  87 REG32(A2W_PLLC_ANA3, 0x103c)
  88
  89 REG32(A2W_PLLD_ANA0, 0x1050)
  90 REG32(A2W_PLLD_ANA1, 0x1054)
  91 REG32(A2W_PLLD_ANA2, 0x1058)
  92 REG32(A2W_PLLD_ANA3, 0x105c)
  93
  94 REG32(A2W_PLLH_ANA0, 0x1070)
  95 REG32(A2W_PLLH_ANA1, 0x1074)
  96     FIELD(A2W_PLLH_ANA1, FB_PREDIV, 11, 1)
  97 REG32(A2W_PLLH_ANA2, 0x1078)
  98 REG32(A2W_PLLH_ANA3, 0x107c)
  99
 100 REG32(A2W_PLLB_ANA0, 0x10f0)
 101 REG32(A2W_PLLB_ANA1, 0x10f4)
 102 REG32(A2W_PLLB_ANA2, 0x10f8)
 103 REG32(A2W_PLLB_ANA3, 0x10fc)
 104
 105 REG32(A2W_PLLA_FRAC, 0x1200)
 106     FIELD(A2W_PLLx_FRAC, FRAC, 0, 20)
 107 REG32(A2W_PLLC_FRAC, 0x1220)
 108 REG32(A2W_PLLD_FRAC, 0x1240)
 109 REG32(A2W_PLLH_FRAC, 0x1260)
 110 REG32(A2W_PLLB_FRAC, 0x12e0)
 111
 112 /* PLL channels */
 113 REG32(A2W_PLLA_DSI0, 0x1300)
 114     FIELD(A2W_PLLx_CHANNELy, DIV, 0, 8)
 115     FIELD(A2W_PLLx_CHANNELy, DISABLE, 8, 1)
 116 REG32(A2W_PLLA_CORE, 0x1400)
 117 REG32(A2W_PLLA_PER, 0x1500)
 118 REG32(A2W_PLLA_CCP2, 0x1600)
 119
 120 REG32(A2W_PLLC_CORE2, 0x1320)
 121 REG32(A2W_PLLC_CORE1, 0x1420)
 122 REG32(A2W_PLLC_PER, 0x1520)
 123 REG32(A2W_PLLC_CORE0, 0x1620)
 124
 125 REG32(A2W_PLLD_DSI0, 0x1340)
 126 REG32(A2W_PLLD_CORE, 0x1440)
 127 REG32(A2W_PLLD_PER, 0x1540)
 128 REG32(A2W_PLLD_DSI1, 0x1640)
 129
 130 REG32(A2W_PLLH_AUX, 0x1360)
 131 REG32(A2W_PLLH_RCAL, 0x1460)
 132 REG32(A2W_PLLH_PIX, 0x1560)
 133 REG32(A2W_PLLH_STS, 0x1660)
 134
 135 REG32(A2W_PLLB_ARM, 0x13e0)
 136
 137 /* Clock muxes */
 138 REG32(CM_GNRICCTL, 0x000)
 139     FIELD(CM_CLOCKx_CTL, SRC, 0, 4)
 140     FIELD(CM_CLOCKx_CTL, ENABLE, 4, 1)
 141     FIELD(CM_CLOCKx_CTL, KILL, 5, 1)
 142     FIELD(CM_CLOCKx_CTL, GATE, 6, 1)
 143     FIELD(CM_CLOCKx_CTL, BUSY, 7, 1)
 144     FIELD(CM_CLOCKx_CTL, BUSYD, 8, 1)
 145     FIELD(CM_CLOCKx_CTL, MASH, 9, 2)
 146     FIELD(CM_CLOCKx_CTL, FLIP, 11, 1)
 147 REG32(CM_GNRICDIV, 0x004)
 148     FIELD(CM_CLOCKx_DIV, FRAC, 0, 12)
 149 REG32(CM_VPUCTL, 0x008)
 150 REG32(CM_VPUDIV, 0x00c)
 151 REG32(CM_SYSCTL, 0x010)
 152 REG32(CM_SYSDIV, 0x014)
 153 REG32(CM_PERIACTL, 0x018)
 154 REG32(CM_PERIADIV, 0x01c)
 155 REG32(CM_PERIICTL, 0x020)
 156 REG32(CM_PERIIDIV, 0x024)
 157 REG32(CM_H264CTL, 0x028)
 158 REG32(CM_H264DIV, 0x02c)
 159 REG32(CM_ISPCTL, 0x030)
 160 REG32(CM_ISPDIV, 0x034)
 161 REG32(CM_V3DCTL, 0x038)
 162 REG32(CM_V3DDIV, 0x03c)
 163 REG32(CM_CAM0CTL, 0x040)
 164 REG32(CM_CAM0DIV, 0x044)
 165 REG32(CM_CAM1CTL, 0x048)
 166 REG32(CM_CAM1DIV, 0x04c)
 167 REG32(CM_CCP2CTL, 0x050)
 168 REG32(CM_CCP2DIV, 0x054)
 169 REG32(CM_DSI0ECTL, 0x058)
 170 REG32(CM_DSI0EDIV, 0x05c)
 171 REG32(CM_DSI0PCTL, 0x060)
 172 REG32(CM_DSI0PDIV, 0x064)
 173 REG32(CM_DPICTL, 0x068)
 174 REG32(CM_DPIDIV, 0x06c)
 175 REG32(CM_GP0CTL, 0x070)
 176 REG32(CM_GP0DIV, 0x074)
 177 REG32(CM_GP1CTL, 0x078)
 178 REG32(CM_GP1DIV, 0x07c)
 179 REG32(CM_GP2CTL, 0x080)
 180 REG32(CM_GP2DIV, 0x084)
 181 REG32(CM_HSMCTL, 0x088)
 182 REG32(CM_HSMDIV, 0x08c)
 183 REG32(CM_OTPCTL, 0x090)
 184 REG32(CM_OTPDIV, 0x094)
 185 REG32(CM_PCMCTL, 0x098)
 186 REG32(CM_PCMDIV, 0x09c)
 187 REG32(CM_PWMCTL, 0x0a0)
 188 REG32(CM_PWMDIV, 0x0a4)
 189 REG32(CM_SLIMCTL, 0x0a8)
 190 REG32(CM_SLIMDIV, 0x0ac)
 191 REG32(CM_SMICTL, 0x0b0)
 192 REG32(CM_SMIDIV, 0x0b4)
 193 REG32(CM_TCNTCTL, 0x0c0)
 194 REG32(CM_TCNTCNT, 0x0c4)
 195 REG32(CM_TECCTL, 0x0c8)
 196 REG32(CM_TECDIV, 0x0cc)
 197 REG32(CM_TD0CTL, 0x0d0)
 198 REG32(CM_TD0DIV, 0x0d4)
 199 REG32(CM_TD1CTL, 0x0d8)
 200 REG32(CM_TD1DIV, 0x0dc)
 201 REG32(CM_TSENSCTL, 0x0e0)
 202 REG32(CM_TSENSDIV, 0x0e4)
 203 REG32(CM_TIMERCTL, 0x0e8)
 204 REG32(CM_TIMERDIV, 0x0ec)
 205 REG32(CM_UARTCTL, 0x0f0)
 206 REG32(CM_UARTDIV, 0x0f4)
 207 REG32(CM_VECCTL, 0x0f8)
 208 REG32(CM_VECDIV, 0x0fc)
 209 REG32(CM_PULSECTL, 0x190)
 210 REG32(CM_PULSEDIV, 0x194)
 211 REG32(CM_SDCCTL, 0x1a8)
 212 REG32(CM_SDCDIV, 0x1ac)
 213 REG32(CM_ARMCTL, 0x1b0)
 214 REG32(CM_AVEOCTL, 0x1b8)
 215 REG32(CM_AVEODIV, 0x1bc)
 216 REG32(CM_EMMCCTL, 0x1c0)
 217 REG32(CM_EMMCDIV, 0x1c4)
 218 REG32(CM_EMMC2CTL, 0x1d0)
 219 REG32(CM_EMMC2DIV, 0x1d4)
 220
 221 /* misc registers */
 222 REG32(CM_LOCK, 0x114)
 223     FIELD(CM_LOCK, FLOCKH, 12, 1)
 224     FIELD(CM_LOCK, FLOCKD, 11, 1)
 225     FIELD(CM_LOCK, FLOCKC, 10, 1)
 226     FIELD(CM_LOCK, FLOCKB, 9, 1)
 227     FIELD(CM_LOCK, FLOCKA, 8, 1)
 228
 229 REG32(CM_DSI0HSCK, 0x120)
 230     FIELD(CM_DSI0HSCK, SELPLLD, 0, 1)
 231
 232 /*
 233  * This field is common to all registers. Each register write value must match
 234  * the CPRMAN_PASSWORD magic value in its 8 MSB.
 235  */
 236 FIELD(CPRMAN, PASSWORD, 24, 8)
 237 #define CPRMAN_PASSWORD 0x5a
 238
 239 /* PLL init info */
 240 typedef struct PLLInitInfo {
 241     const char *name;
 242     size_t cm_offset;
 243     size_t a2w_ctrl_offset;
 244     size_t a2w_ana_offset;
 245     uint32_t prediv_mask; /* Prediv bit in ana[1] */
 246     size_t a2w_frac_offset;
 247 } PLLInitInfo;
 248
 249 #define FILL_PLL_INIT_INFO(pll_)                \
 250     .cm_offset = R_CM_ ## pll_,                 \
 251     .a2w_ctrl_offset = R_A2W_ ## pll_ ## _CTRL, \
 252     .a2w_ana_offset = R_A2W_ ## pll_ ## _ANA0,  \
 253     .a2w_frac_offset = R_A2W_ ## pll_ ## _FRAC
 254
 255 static const PLLInitInfo PLL_INIT_INFO[] = {
 256     [CPRMAN_PLLA] = {
 257         .name = "plla",
 258         .prediv_mask = R_A2W_PLLx_ANA1_FB_PREDIV_MASK,
 259         FILL_PLL_INIT_INFO(PLLA),
 260     },
 261     [CPRMAN_PLLC] = {
 262         .name = "pllc",
 263         .prediv_mask = R_A2W_PLLx_ANA1_FB_PREDIV_MASK,
 264         FILL_PLL_INIT_INFO(PLLC),
 265     },
 266     [CPRMAN_PLLD] = {
 267         .name = "plld",
 268         .prediv_mask = R_A2W_PLLx_ANA1_FB_PREDIV_MASK,
 269         FILL_PLL_INIT_INFO(PLLD),
 270     },
 271     [CPRMAN_PLLH] = {
 272         .name = "pllh",
 273         .prediv_mask = R_A2W_PLLH_ANA1_FB_PREDIV_MASK,
 274         FILL_PLL_INIT_INFO(PLLH),
 275     },
 276     [CPRMAN_PLLB] = {
 277         .name = "pllb",
 278         .prediv_mask = R_A2W_PLLx_ANA1_FB_PREDIV_MASK,
 279         FILL_PLL_INIT_INFO(PLLB),
 280     },
 281 };
 282
 283 #undef FILL_PLL_CHANNEL_INIT_INFO
 284
 285 static inline void set_pll_init_info(BCM2835CprmanState *s,
 286                                      CprmanPllState *pll,
 287                                      CprmanPll id)
 288 {
 289     pll->id = id;
 290     pll->reg_cm = &s->regs[PLL_INIT_INFO[id].cm_offset];
 291     pll->reg_a2w_ctrl = &s->regs[PLL_INIT_INFO[id].a2w_ctrl_offset];
 292     pll->reg_a2w_ana = &s->regs[PLL_INIT_INFO[id].a2w_ana_offset];
 293     pll->prediv_mask = PLL_INIT_INFO[id].prediv_mask;
 294     pll->reg_a2w_frac = &s->regs[PLL_INIT_INFO[id].a2w_frac_offset];
 295 }
 296
 297
 298 /* PLL channel init info */
 299 typedef struct PLLChannelInitInfo {
 300     const char *name;
 301     CprmanPll parent;
 302     size_t cm_offset;
 303     uint32_t cm_hold_mask;
 304     uint32_t cm_load_mask;
 305     size_t a2w_ctrl_offset;
 306     unsigned int fixed_divider;
 307 } PLLChannelInitInfo;
 308
 309 #define FILL_PLL_CHANNEL_INIT_INFO_common(pll_, channel_)            \
 310     .parent = CPRMAN_ ## pll_,                                       \
 311     .cm_offset = R_CM_ ## pll_,                                      \
 312     .cm_load_mask = R_CM_ ## pll_ ## _ ## LOAD ## channel_ ## _MASK, \
 313     .a2w_ctrl_offset = R_A2W_ ## pll_ ## _ ## channel_
 314
 315 #define FILL_PLL_CHANNEL_INIT_INFO(pll_, channel_)                   \
 316     FILL_PLL_CHANNEL_INIT_INFO_common(pll_, channel_),               \
 317     .cm_hold_mask = R_CM_ ## pll_ ## _ ## HOLD ## channel_ ## _MASK, \
 318     .fixed_divider = 1
 319
 320 #define FILL_PLL_CHANNEL_INIT_INFO_nohold(pll_, channel_) \
 321     FILL_PLL_CHANNEL_INIT_INFO_common(pll_, channel_),    \
 322     .cm_hold_mask = 0
 323
 324 static PLLChannelInitInfo PLL_CHANNEL_INIT_INFO[] = {
 325     [CPRMAN_PLLA_CHANNEL_DSI0] = {
 326         .name = "plla-dsi0",
 327         FILL_PLL_CHANNEL_INIT_INFO(PLLA, DSI0),
 328     },
 329     [CPRMAN_PLLA_CHANNEL_CORE] = {
 330         .name = "plla-core",
 331         FILL_PLL_CHANNEL_INIT_INFO(PLLA, CORE),
 332     },
 333     [CPRMAN_PLLA_CHANNEL_PER] = {
 334         .name = "plla-per",
 335         FILL_PLL_CHANNEL_INIT_INFO(PLLA, PER),
 336     },
 337     [CPRMAN_PLLA_CHANNEL_CCP2] = {
 338         .name = "plla-ccp2",
 339         FILL_PLL_CHANNEL_INIT_INFO(PLLA, CCP2),
 340     },
 341
 342     [CPRMAN_PLLC_CHANNEL_CORE2] = {
 343         .name = "pllc-core2",
 344         FILL_PLL_CHANNEL_INIT_INFO(PLLC, CORE2),
 345     },
 346     [CPRMAN_PLLC_CHANNEL_CORE1] = {
 347         .name = "pllc-core1",
 348         FILL_PLL_CHANNEL_INIT_INFO(PLLC, CORE1),
 349     },
 350     [CPRMAN_PLLC_CHANNEL_PER] = {
 351         .name = "pllc-per",
 352         FILL_PLL_CHANNEL_INIT_INFO(PLLC, PER),
 353     },
 354     [CPRMAN_PLLC_CHANNEL_CORE0] = {
 355         .name = "pllc-core0",
 356         FILL_PLL_CHANNEL_INIT_INFO(PLLC, CORE0),
 357     },
 358
 359     [CPRMAN_PLLD_CHANNEL_DSI0] = {
 360         .name = "plld-dsi0",
 361         FILL_PLL_CHANNEL_INIT_INFO(PLLD, DSI0),
 362     },
 363     [CPRMAN_PLLD_CHANNEL_CORE] = {
 364         .name = "plld-core",
 365         FILL_PLL_CHANNEL_INIT_INFO(PLLD, CORE),
 366     },
 367     [CPRMAN_PLLD_CHANNEL_PER] = {
 368         .name = "plld-per",
 369         FILL_PLL_CHANNEL_INIT_INFO(PLLD, PER),
 370     },
 371     [CPRMAN_PLLD_CHANNEL_DSI1] = {
 372         .name = "plld-dsi1",
 373         FILL_PLL_CHANNEL_INIT_INFO(PLLD, DSI1),
 374     },
 375
 376     [CPRMAN_PLLH_CHANNEL_AUX] = {
 377         .name = "pllh-aux",
 378         .fixed_divider = 1,
 379         FILL_PLL_CHANNEL_INIT_INFO_nohold(PLLH, AUX),
 380     },
 381     [CPRMAN_PLLH_CHANNEL_RCAL] = {
 382         .name = "pllh-rcal",
 383         .fixed_divider = 10,
 384         FILL_PLL_CHANNEL_INIT_INFO_nohold(PLLH, RCAL),
 385     },
 386     [CPRMAN_PLLH_CHANNEL_PIX] = {
 387         .name = "pllh-pix",
 388         .fixed_divider = 10,
 389         FILL_PLL_CHANNEL_INIT_INFO_nohold(PLLH, PIX),
 390     },
 391
 392     [CPRMAN_PLLB_CHANNEL_ARM] = {
 393         .name = "pllb-arm",
 394         FILL_PLL_CHANNEL_INIT_INFO(PLLB, ARM),
 395     },
 396 };
 397
 398 #undef FILL_PLL_CHANNEL_INIT_INFO_nohold
 399 #undef FILL_PLL_CHANNEL_INIT_INFO
 400 #undef FILL_PLL_CHANNEL_INIT_INFO_common
 401
 402 static inline void set_pll_channel_init_info(BCM2835CprmanState *s,
 403                                              CprmanPllChannelState *channel,
 404                                              CprmanPllChannel id)
 405 {
 406     channel->id = id;
 407     channel->parent = PLL_CHANNEL_INIT_INFO[id].parent;
 408     channel->reg_cm = &s->regs[PLL_CHANNEL_INIT_INFO[id].cm_offset];
 409     channel->hold_mask = PLL_CHANNEL_INIT_INFO[id].cm_hold_mask;
 410     channel->load_mask = PLL_CHANNEL_INIT_INFO[id].cm_load_mask;
 411     channel->reg_a2w_ctrl = &s->regs[PLL_CHANNEL_INIT_INFO[id].a2w_ctrl_offset];
 412     channel->fixed_divider = PLL_CHANNEL_INIT_INFO[id].fixed_divider;
 413 }
 414
 415 /* Clock mux init info */
 416 typedef struct ClockMuxInitInfo {
 417     const char *name;
 418     size_t cm_offset; /* cm_offset[0]->CM_CTL, cm_offset[1]->CM_DIV */
 419     int int_bits;
 420     int frac_bits;
 421
 422     CprmanPllChannel src_mapping[CPRMAN_NUM_CLOCK_MUX_SRC];
 423 } ClockMuxInitInfo;
 424
 425 /*
 426  * Each clock mux can have up to 10 sources. Sources 0 to 3 are always the
 427  * same (ground, xosc, td0, td1). Sources 4 to 9 are mux specific, and are not
 428  * always populated. The following macros catch all those cases.
 429  */
 430
 431 /* Unknown mapping. Connect everything to ground */
 432 #define SRC_MAPPING_INFO_unknown                          \
 433     .src_mapping = {                                      \
 434         CPRMAN_CLOCK_SRC_FORCE_GROUND, /* gnd */          \
 435         CPRMAN_CLOCK_SRC_FORCE_GROUND, /* xosc */         \
 436         CPRMAN_CLOCK_SRC_FORCE_GROUND, /* test debug 0 */ \
 437         CPRMAN_CLOCK_SRC_FORCE_GROUND, /* test debug 1 */ \
 438         CPRMAN_CLOCK_SRC_FORCE_GROUND, /* pll a */        \
 439         CPRMAN_CLOCK_SRC_FORCE_GROUND, /* pll c */        \
 440         CPRMAN_CLOCK_SRC_FORCE_GROUND, /* pll d */        \
 441         CPRMAN_CLOCK_SRC_FORCE_GROUND, /* pll h */        \
 442         CPRMAN_CLOCK_SRC_FORCE_GROUND, /* pll c, core1 */ \
 443         CPRMAN_CLOCK_SRC_FORCE_GROUND, /* pll c, core2 */ \
 444     }
 445
 446 /* Only the oscillator and the two test debug clocks */
 447 #define SRC_MAPPING_INFO_xosc          \
 448     .src_mapping = {                   \
 449         CPRMAN_CLOCK_SRC_NORMAL,       \
 450         CPRMAN_CLOCK_SRC_NORMAL,       \
 451         CPRMAN_CLOCK_SRC_NORMAL,       \
 452         CPRMAN_CLOCK_SRC_NORMAL,       \
 453         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 454         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 455         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 456         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 457         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 458         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 459     }
 460
 461 /* All the PLL "core" channels */
 462 #define SRC_MAPPING_INFO_core      \
 463     .src_mapping = {               \
 464         CPRMAN_CLOCK_SRC_NORMAL,   \
 465         CPRMAN_CLOCK_SRC_NORMAL,   \
 466         CPRMAN_CLOCK_SRC_NORMAL,   \
 467         CPRMAN_CLOCK_SRC_NORMAL,   \
 468         CPRMAN_PLLA_CHANNEL_CORE,  \
 469         CPRMAN_PLLC_CHANNEL_CORE0, \
 470         CPRMAN_PLLD_CHANNEL_CORE,  \
 471         CPRMAN_PLLH_CHANNEL_AUX,   \
 472         CPRMAN_PLLC_CHANNEL_CORE1, \
 473         CPRMAN_PLLC_CHANNEL_CORE2, \
 474     }
 475
 476 /* All the PLL "per" channels */
 477 #define SRC_MAPPING_INFO_periph        \
 478     .src_mapping = {                   \
 479         CPRMAN_CLOCK_SRC_NORMAL,       \
 480         CPRMAN_CLOCK_SRC_NORMAL,       \
 481         CPRMAN_CLOCK_SRC_NORMAL,       \
 482         CPRMAN_CLOCK_SRC_NORMAL,       \
 483         CPRMAN_PLLA_CHANNEL_PER,       \
 484         CPRMAN_PLLC_CHANNEL_PER,       \
 485         CPRMAN_PLLD_CHANNEL_PER,       \
 486         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 487         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 488         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 489     }
 490
 491 /*
 492  * The DSI0 channels. This one got an intermediate mux between the PLL channels
 493  * and the clock input.
 494  */
 495 #define SRC_MAPPING_INFO_dsi0          \
 496     .src_mapping = {                   \
 497         CPRMAN_CLOCK_SRC_NORMAL,       \
 498         CPRMAN_CLOCK_SRC_NORMAL,       \
 499         CPRMAN_CLOCK_SRC_NORMAL,       \
 500         CPRMAN_CLOCK_SRC_NORMAL,       \
 501         CPRMAN_CLOCK_SRC_DSI0HSCK,     \
 502         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 503         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 504         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 505         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 506         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 507     }
 508
 509 /* The DSI1 channel */
 510 #define SRC_MAPPING_INFO_dsi1          \
 511     .src_mapping = {                   \
 512         CPRMAN_CLOCK_SRC_NORMAL,       \
 513         CPRMAN_CLOCK_SRC_NORMAL,       \
 514         CPRMAN_CLOCK_SRC_NORMAL,       \
 515         CPRMAN_CLOCK_SRC_NORMAL,       \
 516         CPRMAN_PLLD_CHANNEL_DSI1,      \
 517         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 518         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 519         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 520         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 521         CPRMAN_CLOCK_SRC_FORCE_GROUND, \
 522     }
 523
 524 #define FILL_CLOCK_MUX_SRC_MAPPING_INIT_INFO(kind_) \
 525     SRC_MAPPING_INFO_ ## kind_
 526
 527 #define FILL_CLOCK_MUX_INIT_INFO(clock_, kind_) \
 528     .cm_offset = R_CM_ ## clock_ ## CTL,        \
 529     FILL_CLOCK_MUX_SRC_MAPPING_INIT_INFO(kind_)
 530
 531 static ClockMuxInitInfo CLOCK_MUX_INIT_INFO[] = {
 532     [CPRMAN_CLOCK_GNRIC] = {
 533         .name = "gnric",
 534         FILL_CLOCK_MUX_INIT_INFO(GNRIC, unknown),
 535     },
 536     [CPRMAN_CLOCK_VPU] = {
 537         .name = "vpu",
 538         .int_bits = 12,
 539         .frac_bits = 8,
 540         FILL_CLOCK_MUX_INIT_INFO(VPU, core),
 541     },
 542     [CPRMAN_CLOCK_SYS] = {
 543         .name = "sys",
 544         FILL_CLOCK_MUX_INIT_INFO(SYS, unknown),
 545     },
 546     [CPRMAN_CLOCK_PERIA] = {
 547         .name = "peria",
 548         FILL_CLOCK_MUX_INIT_INFO(PERIA, unknown),
 549     },
 550     [CPRMAN_CLOCK_PERII] = {
 551         .name = "perii",
 552         FILL_CLOCK_MUX_INIT_INFO(PERII, unknown),
 553     },
 554     [CPRMAN_CLOCK_H264] = {
 555         .name = "h264",
 556         .int_bits = 4,
 557         .frac_bits = 8,
 558         FILL_CLOCK_MUX_INIT_INFO(H264, core),
 559     },
 560     [CPRMAN_CLOCK_ISP] = {
 561         .name = "isp",
 562         .int_bits = 4,
 563         .frac_bits = 8,
 564         FILL_CLOCK_MUX_INIT_INFO(ISP, core),
 565     },
 566     [CPRMAN_CLOCK_V3D] = {
 567         .name = "v3d",
 568         FILL_CLOCK_MUX_INIT_INFO(V3D, core),
 569     },
 570     [CPRMAN_CLOCK_CAM0] = {
 571         .name = "cam0",
 572         .int_bits = 4,
 573         .frac_bits = 8,
 574         FILL_CLOCK_MUX_INIT_INFO(CAM0, periph),
 575     },
 576     [CPRMAN_CLOCK_CAM1] = {
 577         .name = "cam1",
 578         .int_bits = 4,
 579         .frac_bits = 8,
 580         FILL_CLOCK_MUX_INIT_INFO(CAM1, periph),
 581     },
 582     [CPRMAN_CLOCK_CCP2] = {
 583         .name = "ccp2",
 584         FILL_CLOCK_MUX_INIT_INFO(CCP2, unknown),
 585     },
 586     [CPRMAN_CLOCK_DSI0E] = {
 587         .name = "dsi0e",
 588         .int_bits = 4,
 589         .frac_bits = 8,
 590         FILL_CLOCK_MUX_INIT_INFO(DSI0E, dsi0),
 591     },
 592     [CPRMAN_CLOCK_DSI0P] = {
 593         .name = "dsi0p",
 594         .int_bits = 0,
 595         .frac_bits = 0,
 596         FILL_CLOCK_MUX_INIT_INFO(DSI0P, dsi0),
 597     },
 598     [CPRMAN_CLOCK_DPI] = {
 599         .name = "dpi",
 600         .int_bits = 4,
 601         .frac_bits = 8,
 602         FILL_CLOCK_MUX_INIT_INFO(DPI, periph),
 603     },
 604     [CPRMAN_CLOCK_GP0] = {
 605         .name = "gp0",
 606         .int_bits = 12,
 607         .frac_bits = 12,
 608         FILL_CLOCK_MUX_INIT_INFO(GP0, periph),
 609     },
 610     [CPRMAN_CLOCK_GP1] = {
 611         .name = "gp1",
 612         .int_bits = 12,
 613         .frac_bits = 12,
 614         FILL_CLOCK_MUX_INIT_INFO(GP1, periph),
 615     },
 616     [CPRMAN_CLOCK_GP2] = {
 617         .name = "gp2",
 618         .int_bits = 12,
 619         .frac_bits = 12,
 620         FILL_CLOCK_MUX_INIT_INFO(GP2, periph),
 621     },
 622     [CPRMAN_CLOCK_HSM] = {
 623         .name = "hsm",
 624         .int_bits = 4,
 625         .frac_bits = 8,
 626         FILL_CLOCK_MUX_INIT_INFO(HSM, periph),
 627     },
 628     [CPRMAN_CLOCK_OTP] = {
 629         .name = "otp",
 630         .int_bits = 4,
 631         .frac_bits = 0,
 632         FILL_CLOCK_MUX_INIT_INFO(OTP, xosc),
 633     },
 634     [CPRMAN_CLOCK_PCM] = {
 635         .name = "pcm",
 636         .int_bits = 12,
 637         .frac_bits = 12,
 638         FILL_CLOCK_MUX_INIT_INFO(PCM, periph),
 639     },
 640     [CPRMAN_CLOCK_PWM] = {
 641         .name = "pwm",
 642         .int_bits = 12,
 643         .frac_bits = 12,
 644         FILL_CLOCK_MUX_INIT_INFO(PWM, periph),
 645     },
 646     [CPRMAN_CLOCK_SLIM] = {
 647         .name = "slim",
 648         .int_bits = 12,
 649         .frac_bits = 12,
 650         FILL_CLOCK_MUX_INIT_INFO(SLIM, periph),
 651     },
 652     [CPRMAN_CLOCK_SMI] = {
 653         .name = "smi",
 654         .int_bits = 4,
 655         .frac_bits = 8,
 656         FILL_CLOCK_MUX_INIT_INFO(SMI, periph),
 657     },
 658     [CPRMAN_CLOCK_TEC] = {
 659         .name = "tec",
 660         .int_bits = 6,
 661         .frac_bits = 0,
 662         FILL_CLOCK_MUX_INIT_INFO(TEC, xosc),
 663     },
 664     [CPRMAN_CLOCK_TD0] = {
 665         .name = "td0",
 666         FILL_CLOCK_MUX_INIT_INFO(TD0, unknown),
 667     },
 668     [CPRMAN_CLOCK_TD1] = {
 669         .name = "td1",
 670         FILL_CLOCK_MUX_INIT_INFO(TD1, unknown),
 671     },
 672     [CPRMAN_CLOCK_TSENS] = {
 673         .name = "tsens",
 674         .int_bits = 5,
 675         .frac_bits = 0,
 676         FILL_CLOCK_MUX_INIT_INFO(TSENS, xosc),
 677     },
 678     [CPRMAN_CLOCK_TIMER] = {
 679         .name = "timer",
 680         .int_bits = 6,
 681         .frac_bits = 12,
 682         FILL_CLOCK_MUX_INIT_INFO(TIMER, xosc),
 683     },
 684     [CPRMAN_CLOCK_UART] = {
 685         .name = "uart",
 686         .int_bits = 10,
 687         .frac_bits = 12,
 688         FILL_CLOCK_MUX_INIT_INFO(UART, periph),
 689     },
 690     [CPRMAN_CLOCK_VEC] = {
 691         .name = "vec",
 692         .int_bits = 4,
 693         .frac_bits = 0,
 694         FILL_CLOCK_MUX_INIT_INFO(VEC, periph),
 695     },
 696     [CPRMAN_CLOCK_PULSE] = {
 697         .name = "pulse",
 698         FILL_CLOCK_MUX_INIT_INFO(PULSE, xosc),
 699     },
 700     [CPRMAN_CLOCK_SDC] = {
 701         .name = "sdram",
 702         .int_bits = 6,
 703         .frac_bits = 0,
 704         FILL_CLOCK_MUX_INIT_INFO(SDC, core),
 705     },
 706     [CPRMAN_CLOCK_ARM] = {
 707         .name = "arm",
 708         FILL_CLOCK_MUX_INIT_INFO(ARM, unknown),
 709     },
 710     [CPRMAN_CLOCK_AVEO] = {
 711         .name = "aveo",
 712         .int_bits = 4,
 713         .frac_bits = 0,
 714         FILL_CLOCK_MUX_INIT_INFO(AVEO, periph),
 715     },
 716     [CPRMAN_CLOCK_EMMC] = {
 717         .name = "emmc",
 718         .int_bits = 4,
 719         .frac_bits = 8,
 720         FILL_CLOCK_MUX_INIT_INFO(EMMC, periph),
 721     },
 722     [CPRMAN_CLOCK_EMMC2] = {
 723         .name = "emmc2",
 724         .int_bits = 4,
 725         .frac_bits = 8,
 726         FILL_CLOCK_MUX_INIT_INFO(EMMC2, unknown),
 727     },
 728 };
 729
 730 #undef FILL_CLOCK_MUX_INIT_INFO
 731 #undef FILL_CLOCK_MUX_SRC_MAPPING_INIT_INFO
 732 #undef SRC_MAPPING_INFO_dsi1
 733 #undef SRC_MAPPING_INFO_dsi0
 734 #undef SRC_MAPPING_INFO_periph
 735 #undef SRC_MAPPING_INFO_core
 736 #undef SRC_MAPPING_INFO_xosc
 737 #undef SRC_MAPPING_INFO_unknown
 738
 739 static inline void set_clock_mux_init_info(BCM2835CprmanState *s,
 740                                            CprmanClockMuxState *mux,
 741                                            CprmanClockMux id)
 742 {
 743     mux->id = id;
 744     mux->reg_ctl = &s->regs[CLOCK_MUX_INIT_INFO[id].cm_offset];
 745     mux->reg_div = &s->regs[CLOCK_MUX_INIT_INFO[id].cm_offset + 1];
 746     mux->int_bits = CLOCK_MUX_INIT_INFO[id].int_bits;
 747     mux->frac_bits = CLOCK_MUX_INIT_INFO[id].frac_bits;
 748 }
 749
 750
 751 /*
 752  * Object reset info
 753  * Those values have been dumped from a Raspberry Pi 3 Model B v1.2 using the
 754  * clk debugfs interface in Linux.
 755  */
 756 typedef struct PLLResetInfo {
 757     uint32_t cm;
 758     uint32_t a2w_ctrl;
 759     uint32_t a2w_ana[4];
 760     uint32_t a2w_frac;
 761 } PLLResetInfo;
 762
 763 static const PLLResetInfo PLL_RESET_INFO[] = {
 764     [CPRMAN_PLLA] = {
 765         .cm = 0x0000008a,
 766         .a2w_ctrl = 0x0002103a,
 767         .a2w_frac = 0x00098000,
 768         .a2w_ana = { 0x00000000, 0x00144000, 0x00000000, 0x00000100 }
 769     },
 770
 771     [CPRMAN_PLLC] = {
 772         .cm = 0x00000228,
 773         .a2w_ctrl = 0x0002103e,
 774         .a2w_frac = 0x00080000,
 775         .a2w_ana = { 0x00000000, 0x00144000, 0x00000000, 0x00000100 }
 776     },
 777
 778     [CPRMAN_PLLD] = {
 779         .cm = 0x0000020a,
 780         .a2w_ctrl = 0x00021034,
 781         .a2w_frac = 0x00015556,
 782         .a2w_ana = { 0x00000000, 0x00144000, 0x00000000, 0x00000100 }
 783     },
 784
 785     [CPRMAN_PLLH] = {
 786         .cm = 0x00000000,
 787         .a2w_ctrl = 0x0002102d,
 788         .a2w_frac = 0x00000000,
 789         .a2w_ana = { 0x00900000, 0x0000000c, 0x00000000, 0x00000000 }
 790     },
 791
 792     [CPRMAN_PLLB] = {
 793         /* unknown */
 794         .cm = 0x00000000,
 795         .a2w_ctrl = 0x00000000,
 796         .a2w_frac = 0x00000000,
 797         .a2w_ana = { 0x00000000, 0x00000000, 0x00000000, 0x00000000 }
 798     }
 799 };
 800
 801 typedef struct PLLChannelResetInfo {
 802     /*
 803      * Even though a PLL channel has a CM register, it shares it with its
 804      * parent PLL. The parent already takes care of the reset value.
 805      */
 806     uint32_t a2w_ctrl;
 807 } PLLChannelResetInfo;
 808
 809 static const PLLChannelResetInfo PLL_CHANNEL_RESET_INFO[] = {
 810     [CPRMAN_PLLA_CHANNEL_DSI0] = { .a2w_ctrl = 0x00000100 },
 811     [CPRMAN_PLLA_CHANNEL_CORE] = { .a2w_ctrl = 0x00000003 },
 812     [CPRMAN_PLLA_CHANNEL_PER] = { .a2w_ctrl = 0x00000000 }, /* unknown */
 813     [CPRMAN_PLLA_CHANNEL_CCP2] = { .a2w_ctrl = 0x00000100 },
 814
 815     [CPRMAN_PLLC_CHANNEL_CORE2] = { .a2w_ctrl = 0x00000100 },
 816     [CPRMAN_PLLC_CHANNEL_CORE1] = { .a2w_ctrl = 0x00000100 },
 817     [CPRMAN_PLLC_CHANNEL_PER] = { .a2w_ctrl = 0x00000002 },
 818     [CPRMAN_PLLC_CHANNEL_CORE0] = { .a2w_ctrl = 0x00000002 },
 819
 820     [CPRMAN_PLLD_CHANNEL_DSI0] = { .a2w_ctrl = 0x00000100 },
 821     [CPRMAN_PLLD_CHANNEL_CORE] = { .a2w_ctrl = 0x00000004 },
 822     [CPRMAN_PLLD_CHANNEL_PER] = { .a2w_ctrl = 0x00000004 },
 823     [CPRMAN_PLLD_CHANNEL_DSI1] = { .a2w_ctrl = 0x00000100 },
 824
 825     [CPRMAN_PLLH_CHANNEL_AUX] = { .a2w_ctrl = 0x00000004 },
 826     [CPRMAN_PLLH_CHANNEL_RCAL] = { .a2w_ctrl = 0x00000000 },
 827     [CPRMAN_PLLH_CHANNEL_PIX] = { .a2w_ctrl = 0x00000000 },
 828
 829     [CPRMAN_PLLB_CHANNEL_ARM] = { .a2w_ctrl = 0x00000000 }, /* unknown */
 830 };
 831
 832 typedef struct ClockMuxResetInfo {
 833     uint32_t cm_ctl;
 834     uint32_t cm_div;
 835 } ClockMuxResetInfo;
 836
 837 static const ClockMuxResetInfo CLOCK_MUX_RESET_INFO[] = {
 838     [CPRMAN_CLOCK_GNRIC] = {
 839         .cm_ctl = 0, /* unknown */
 840         .cm_div = 0
 841     },
 842
 843     [CPRMAN_CLOCK_VPU] = {
 844         .cm_ctl = 0x00000245,
 845         .cm_div = 0x00003000,
 846     },
 847
 848     [CPRMAN_CLOCK_SYS] = {
 849         .cm_ctl = 0, /* unknown */
 850         .cm_div = 0
 851     },
 852
 853     [CPRMAN_CLOCK_PERIA] = {
 854         .cm_ctl = 0, /* unknown */
 855         .cm_div = 0
 856     },
 857
 858     [CPRMAN_CLOCK_PERII] = {
 859         .cm_ctl = 0, /* unknown */
 860         .cm_div = 0
 861     },
 862
 863     [CPRMAN_CLOCK_H264] = {
 864         .cm_ctl = 0x00000244,
 865         .cm_div = 0x00003000,
 866     },
 867
 868     [CPRMAN_CLOCK_ISP] = {
 869         .cm_ctl = 0x00000244,
 870         .cm_div = 0x00003000,
 871     },
 872
 873     [CPRMAN_CLOCK_V3D] = {
 874         .cm_ctl = 0, /* unknown */
 875         .cm_div = 0
 876     },
 877
 878     [CPRMAN_CLOCK_CAM0] = {
 879         .cm_ctl = 0x00000000,
 880         .cm_div = 0x00000000,
 881     },
 882
 883     [CPRMAN_CLOCK_CAM1] = {
 884         .cm_ctl = 0x00000000,
 885         .cm_div = 0x00000000,
 886     },
 887
 888     [CPRMAN_CLOCK_CCP2] = {
 889         .cm_ctl = 0, /* unknown */
 890         .cm_div = 0
 891     },
 892
 893     [CPRMAN_CLOCK_DSI0E] = {
 894         .cm_ctl = 0x00000000,
 895         .cm_div = 0x00000000,
 896     },
 897
 898     [CPRMAN_CLOCK_DSI0P] = {
 899         .cm_ctl = 0x00000000,
 900         .cm_div = 0x00000000,
 901     },
 902
 903     [CPRMAN_CLOCK_DPI] = {
 904         .cm_ctl = 0x00000000,
 905         .cm_div = 0x00000000,
 906     },
 907
 908     [CPRMAN_CLOCK_GP0] = {
 909         .cm_ctl = 0x00000200,
 910         .cm_div = 0x00000000,
 911     },
 912
 913     [CPRMAN_CLOCK_GP1] = {
 914         .cm_ctl = 0x00000096,
 915         .cm_div = 0x00014000,
 916     },
 917
 918     [CPRMAN_CLOCK_GP2] = {
 919         .cm_ctl = 0x00000291,
 920         .cm_div = 0x00249f00,
 921     },
 922
 923     [CPRMAN_CLOCK_HSM] = {
 924         .cm_ctl = 0x00000000,
 925         .cm_div = 0x00000000,
 926     },
 927
 928     [CPRMAN_CLOCK_OTP] = {
 929         .cm_ctl = 0x00000091,
 930         .cm_div = 0x00004000,
 931     },
 932
 933     [CPRMAN_CLOCK_PCM] = {
 934         .cm_ctl = 0x00000200,
 935         .cm_div = 0x00000000,
 936     },
 937
 938     [CPRMAN_CLOCK_PWM] = {
 939         .cm_ctl = 0x00000200,
 940         .cm_div = 0x00000000,
 941     },
 942
 943     [CPRMAN_CLOCK_SLIM] = {
 944         .cm_ctl = 0x00000200,
 945         .cm_div = 0x00000000,
 946     },
 947
 948     [CPRMAN_CLOCK_SMI] = {
 949         .cm_ctl = 0x00000000,
 950         .cm_div = 0x00000000,
 951     },
 952
 953     [CPRMAN_CLOCK_TEC] = {
 954         .cm_ctl = 0x00000000,
 955         .cm_div = 0x00000000,
 956     },
 957
 958     [CPRMAN_CLOCK_TD0] = {
 959         .cm_ctl = 0, /* unknown */
 960         .cm_div = 0
 961     },
 962
 963     [CPRMAN_CLOCK_TD1] = {
 964         .cm_ctl = 0, /* unknown */
 965         .cm_div = 0
 966     },
 967
 968     [CPRMAN_CLOCK_TSENS] = {
 969         .cm_ctl = 0x00000091,
 970         .cm_div = 0x0000a000,
 971     },
 972
 973     [CPRMAN_CLOCK_TIMER] = {
 974         .cm_ctl = 0x00000291,
 975         .cm_div = 0x00013333,
 976     },
 977
 978     [CPRMAN_CLOCK_UART] = {
 979         .cm_ctl = 0x00000296,
 980         .cm_div = 0x0000a6ab,
 981     },
 982
 983     [CPRMAN_CLOCK_VEC] = {
 984         .cm_ctl = 0x00000097,
 985         .cm_div = 0x00002000,
 986     },
 987
 988     [CPRMAN_CLOCK_PULSE] = {
 989         .cm_ctl = 0, /* unknown */
 990         .cm_div = 0
 991     },
 992
 993     [CPRMAN_CLOCK_SDC] = {
 994         .cm_ctl = 0x00004006,
 995         .cm_div = 0x00003000,
 996     },
 997
 998     [CPRMAN_CLOCK_ARM] = {
 999         .cm_ctl = 0, /* unknown */
1000         .cm_div = 0
1001     },
1002
1003     [CPRMAN_CLOCK_AVEO] = {
1004         .cm_ctl = 0x00000000,
1005         .cm_div = 0x00000000,
1006     },
1007
1008     [CPRMAN_CLOCK_EMMC] = {
1009         .cm_ctl = 0x00000295,
1010         .cm_div = 0x00006000,
1011     },
1012
1013     [CPRMAN_CLOCK_EMMC2] = {
1014         .cm_ctl = 0, /* unknown */
1015         .cm_div = 0
1016     },
1017 };
1018
1019 #endif