1 /* 2 * IMX31 Clock Control Module 3 * 4 * Copyright (C) 2012 NICTA 5 * 6 * This work is licensed under the terms of the GNU GPL, version 2 or later. 7 * See the COPYING file in the top-level directory. 8 * 9 * To get the timer frequencies right, we need to emulate at least part of 10 * the CCM. 11 */ 12 13 #include "hw/hw.h" 14 #include "hw/sysbus.h" 15 #include "sysemu/sysemu.h" 16 #include "hw/arm/imx.h" 17 18 #define CKIH_FREQ 26000000 /* 26MHz crystal input */ 19 #define CKIL_FREQ 32768 /* nominal 32khz clock */ 20 21 22 //#define DEBUG_CCM 1 23 #ifdef DEBUG_CCM 24 #define DPRINTF(fmt, args...) \ 25 do { printf("imx_ccm: " fmt , ##args); } while (0) 26 #else 27 #define DPRINTF(fmt, args...) do {} while (0) 28 #endif 29 30 static int imx_ccm_post_load(void *opaque, int version_id); 31 32 typedef struct { 33 SysBusDevice busdev; 34 MemoryRegion iomem; 35 36 uint32_t ccmr; 37 uint32_t pdr0; 38 uint32_t pdr1; 39 uint32_t mpctl; 40 uint32_t spctl; 41 uint32_t cgr[3]; 42 uint32_t pmcr0; 43 uint32_t pmcr1; 44 45 /* Frequencies precalculated on register changes */ 46 uint32_t pll_refclk_freq; 47 uint32_t mcu_clk_freq; 48 uint32_t hsp_clk_freq; 49 uint32_t ipg_clk_freq; 50 } IMXCCMState; 51 52 static const VMStateDescription vmstate_imx_ccm = { 53 .name = "imx-ccm", 54 .version_id = 1, 55 .minimum_version_id = 1, 56 .minimum_version_id_old = 1, 57 .fields = (VMStateField[]) { 58 VMSTATE_UINT32(ccmr, IMXCCMState), 59 VMSTATE_UINT32(pdr0, IMXCCMState), 60 VMSTATE_UINT32(pdr1, IMXCCMState), 61 VMSTATE_UINT32(mpctl, IMXCCMState), 62 VMSTATE_UINT32(spctl, IMXCCMState), 63 VMSTATE_UINT32_ARRAY(cgr, IMXCCMState, 3), 64 VMSTATE_UINT32(pmcr0, IMXCCMState), 65 VMSTATE_UINT32(pmcr1, IMXCCMState), 66 VMSTATE_UINT32(pll_refclk_freq, IMXCCMState), 67 }, 68 .post_load = imx_ccm_post_load, 69 }; 70 71 /* CCMR */ 72 #define CCMR_FPME (1<<0) 73 #define CCMR_MPE (1<<3) 74 #define CCMR_MDS (1<<7) 75 #define CCMR_FPMF (1<<26) 76 #define CCMR_PRCS (3<<1) 77 78 /* PDR0 */ 79 #define PDR0_MCU_PODF_SHIFT (0) 80 #define PDR0_MCU_PODF_MASK (0x7) 81 #define PDR0_MAX_PODF_SHIFT (3) 82 #define PDR0_MAX_PODF_MASK (0x7) 83 #define PDR0_IPG_PODF_SHIFT (6) 84 #define PDR0_IPG_PODF_MASK (0x3) 85 #define PDR0_NFC_PODF_SHIFT (8) 86 #define PDR0_NFC_PODF_MASK (0x7) 87 #define PDR0_HSP_PODF_SHIFT (11) 88 #define PDR0_HSP_PODF_MASK (0x7) 89 #define PDR0_PER_PODF_SHIFT (16) 90 #define PDR0_PER_PODF_MASK (0x1f) 91 #define PDR0_CSI_PODF_SHIFT (23) 92 #define PDR0_CSI_PODF_MASK (0x1ff) 93 94 #define EXTRACT(value, name) (((value) >> PDR0_##name##_PODF_SHIFT) \ 95 & PDR0_##name##_PODF_MASK) 96 #define INSERT(value, name) (((value) & PDR0_##name##_PODF_MASK) << \ 97 PDR0_##name##_PODF_SHIFT) 98 /* PLL control registers */ 99 #define PD(v) (((v) >> 26) & 0xf) 100 #define MFD(v) (((v) >> 16) & 0x3ff) 101 #define MFI(v) (((v) >> 10) & 0xf); 102 #define MFN(v) ((v) & 0x3ff) 103 104 #define PLL_PD(x) (((x) & 0xf) << 26) 105 #define PLL_MFD(x) (((x) & 0x3ff) << 16) 106 #define PLL_MFI(x) (((x) & 0xf) << 10) 107 #define PLL_MFN(x) (((x) & 0x3ff) << 0) 108 109 uint32_t imx_clock_frequency(DeviceState *dev, IMXClk clock) 110 { 111 IMXCCMState *s = container_of(dev, IMXCCMState, busdev.qdev); 112 113 switch (clock) { 114 case NOCLK: 115 return 0; 116 case MCU: 117 return s->mcu_clk_freq; 118 case HSP: 119 return s->hsp_clk_freq; 120 case IPG: 121 return s->ipg_clk_freq; 122 case CLK_32k: 123 return CKIL_FREQ; 124 } 125 return 0; 126 } 127 128 /* 129 * Calculate PLL output frequency 130 */ 131 static uint32_t calc_pll(uint32_t pllreg, uint32_t base_freq) 132 { 133 int32_t mfn = MFN(pllreg); /* Numerator */ 134 uint32_t mfi = MFI(pllreg); /* Integer part */ 135 uint32_t mfd = 1 + MFD(pllreg); /* Denominator */ 136 uint32_t pd = 1 + PD(pllreg); /* Pre-divider */ 137 138 if (mfi < 5) { 139 mfi = 5; 140 } 141 /* mfn is 10-bit signed twos-complement */ 142 mfn <<= 32 - 10; 143 mfn >>= 32 - 10; 144 145 return ((2 * (base_freq >> 10) * (mfi * mfd + mfn)) / 146 (mfd * pd)) << 10; 147 } 148 149 static void update_clocks(IMXCCMState *s) 150 { 151 /* 152 * If we ever emulate more clocks, this should switch to a data-driven 153 * approach 154 */ 155 156 if ((s->ccmr & CCMR_PRCS) == 1) { 157 s->pll_refclk_freq = CKIL_FREQ * 1024; 158 } else { 159 s->pll_refclk_freq = CKIH_FREQ; 160 } 161 162 /* ipg_clk_arm aka MCU clock */ 163 if ((s->ccmr & CCMR_MDS) || !(s->ccmr & CCMR_MPE)) { 164 s->mcu_clk_freq = s->pll_refclk_freq; 165 } else { 166 s->mcu_clk_freq = calc_pll(s->mpctl, s->pll_refclk_freq); 167 } 168 169 /* High-speed clock */ 170 s->hsp_clk_freq = s->mcu_clk_freq / (1 + EXTRACT(s->pdr0, HSP)); 171 s->ipg_clk_freq = s->hsp_clk_freq / (1 + EXTRACT(s->pdr0, IPG)); 172 173 DPRINTF("Clocks: mcu %uMHz, HSP %uMHz, IPG %uHz\n", 174 s->mcu_clk_freq / 1000000, 175 s->hsp_clk_freq / 1000000, 176 s->ipg_clk_freq); 177 } 178 179 static void imx_ccm_reset(DeviceState *dev) 180 { 181 IMXCCMState *s = container_of(dev, IMXCCMState, busdev.qdev); 182 183 s->ccmr = 0x074b0b7b; 184 s->pdr0 = 0xff870b48; 185 s->pdr1 = 0x49fcfe7f; 186 s->mpctl = PLL_PD(1) | PLL_MFD(0) | PLL_MFI(6) | PLL_MFN(0); 187 s->cgr[0] = s->cgr[1] = s->cgr[2] = 0xffffffff; 188 s->spctl = PLL_PD(1) | PLL_MFD(4) | PLL_MFI(0xc) | PLL_MFN(1); 189 s->pmcr0 = 0x80209828; 190 191 update_clocks(s); 192 } 193 194 static uint64_t imx_ccm_read(void *opaque, hwaddr offset, 195 unsigned size) 196 { 197 IMXCCMState *s = (IMXCCMState *)opaque; 198 199 DPRINTF("read(offset=%x)", offset >> 2); 200 switch (offset >> 2) { 201 case 0: /* CCMR */ 202 DPRINTF(" ccmr = 0x%x\n", s->ccmr); 203 return s->ccmr; 204 case 1: 205 DPRINTF(" pdr0 = 0x%x\n", s->pdr0); 206 return s->pdr0; 207 case 2: 208 DPRINTF(" pdr1 = 0x%x\n", s->pdr1); 209 return s->pdr1; 210 case 4: 211 DPRINTF(" mpctl = 0x%x\n", s->mpctl); 212 return s->mpctl; 213 case 6: 214 DPRINTF(" spctl = 0x%x\n", s->spctl); 215 return s->spctl; 216 case 8: 217 DPRINTF(" cgr0 = 0x%x\n", s->cgr[0]); 218 return s->cgr[0]; 219 case 9: 220 DPRINTF(" cgr1 = 0x%x\n", s->cgr[1]); 221 return s->cgr[1]; 222 case 10: 223 DPRINTF(" cgr2 = 0x%x\n", s->cgr[2]); 224 return s->cgr[2]; 225 case 18: /* LTR1 */ 226 return 0x00004040; 227 case 23: 228 DPRINTF(" pcmr0 = 0x%x\n", s->pmcr0); 229 return s->pmcr0; 230 } 231 DPRINTF(" return 0\n"); 232 return 0; 233 } 234 235 static void imx_ccm_write(void *opaque, hwaddr offset, 236 uint64_t value, unsigned size) 237 { 238 IMXCCMState *s = (IMXCCMState *)opaque; 239 240 DPRINTF("write(offset=%x, value = %x)\n", 241 offset >> 2, (unsigned int)value); 242 switch (offset >> 2) { 243 case 0: 244 s->ccmr = CCMR_FPMF | (value & 0x3b6fdfff); 245 break; 246 case 1: 247 s->pdr0 = value & 0xff9f3fff; 248 break; 249 case 2: 250 s->pdr1 = value; 251 break; 252 case 4: 253 s->mpctl = value & 0xbfff3fff; 254 break; 255 case 6: 256 s->spctl = value & 0xbfff3fff; 257 break; 258 case 8: 259 s->cgr[0] = value; 260 return; 261 case 9: 262 s->cgr[1] = value; 263 return; 264 case 10: 265 s->cgr[2] = value; 266 return; 267 268 default: 269 return; 270 } 271 update_clocks(s); 272 } 273 274 static const struct MemoryRegionOps imx_ccm_ops = { 275 .read = imx_ccm_read, 276 .write = imx_ccm_write, 277 .endianness = DEVICE_NATIVE_ENDIAN, 278 }; 279 280 static int imx_ccm_init(SysBusDevice *dev) 281 { 282 IMXCCMState *s = FROM_SYSBUS(typeof(*s), dev); 283 284 memory_region_init_io(&s->iomem, &imx_ccm_ops, s, "imx_ccm", 0x1000); 285 sysbus_init_mmio(dev, &s->iomem); 286 287 return 0; 288 } 289 290 static int imx_ccm_post_load(void *opaque, int version_id) 291 { 292 IMXCCMState *s = (IMXCCMState *)opaque; 293 294 update_clocks(s); 295 return 0; 296 } 297 298 static void imx_ccm_class_init(ObjectClass *klass, void *data) 299 { 300 DeviceClass *dc = DEVICE_CLASS(klass); 301 SysBusDeviceClass *sbc = SYS_BUS_DEVICE_CLASS(klass); 302 303 sbc->init = imx_ccm_init; 304 dc->reset = imx_ccm_reset; 305 dc->vmsd = &vmstate_imx_ccm; 306 dc->desc = "i.MX Clock Control Module"; 307 } 308 309 static const TypeInfo imx_ccm_info = { 310 .name = "imx_ccm", 311 .parent = TYPE_SYS_BUS_DEVICE, 312 .instance_size = sizeof(IMXCCMState), 313 .class_init = imx_ccm_class_init, 314 }; 315 316 static void imx_ccm_register_types(void) 317 { 318 type_register_static(&imx_ccm_info); 319 } 320 321 type_init(imx_ccm_register_types) 322