forked from mirror/qemu
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
939 lines
27 KiB
C
939 lines
27 KiB
C
/*
|
|
* IMX6UL Clock Control Module
|
|
*
|
|
* Copyright (c) 2018 Jean-Christophe Dubois <jcd@tribudubois.net>
|
|
*
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
* See the COPYING file in the top-level directory.
|
|
*
|
|
* To get the timer frequencies right, we need to emulate at least part of
|
|
* the CCM.
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
#include "hw/registerfields.h"
|
|
#include "migration/vmstate.h"
|
|
#include "hw/misc/imx6ul_ccm.h"
|
|
#include "qemu/log.h"
|
|
#include "qemu/module.h"
|
|
|
|
#include "trace.h"
|
|
|
|
static const uint32_t ccm_mask[CCM_MAX] = {
|
|
[CCM_CCR] = 0xf01fef80,
|
|
[CCM_CCDR] = 0xfffeffff,
|
|
[CCM_CSR] = 0xffffffff,
|
|
[CCM_CCSR] = 0xfffffef2,
|
|
[CCM_CACRR] = 0xfffffff8,
|
|
[CCM_CBCDR] = 0xc1f8e000,
|
|
[CCM_CBCMR] = 0xfc03cfff,
|
|
[CCM_CSCMR1] = 0x80700000,
|
|
[CCM_CSCMR2] = 0xe01ff003,
|
|
[CCM_CSCDR1] = 0xfe00c780,
|
|
[CCM_CS1CDR] = 0xfe00fe00,
|
|
[CCM_CS2CDR] = 0xf8007000,
|
|
[CCM_CDCDR] = 0xf00fffff,
|
|
[CCM_CHSCCDR] = 0xfffc01ff,
|
|
[CCM_CSCDR2] = 0xfe0001ff,
|
|
[CCM_CSCDR3] = 0xffffc1ff,
|
|
[CCM_CDHIPR] = 0xffffffff,
|
|
[CCM_CTOR] = 0x00000000,
|
|
[CCM_CLPCR] = 0xf39ff01c,
|
|
[CCM_CISR] = 0xfb85ffbe,
|
|
[CCM_CIMR] = 0xfb85ffbf,
|
|
[CCM_CCOSR] = 0xfe00fe00,
|
|
[CCM_CGPR] = 0xfffc3fea,
|
|
[CCM_CCGR0] = 0x00000000,
|
|
[CCM_CCGR1] = 0x00000000,
|
|
[CCM_CCGR2] = 0x00000000,
|
|
[CCM_CCGR3] = 0x00000000,
|
|
[CCM_CCGR4] = 0x00000000,
|
|
[CCM_CCGR5] = 0x00000000,
|
|
[CCM_CCGR6] = 0x00000000,
|
|
[CCM_CMEOR] = 0xafffff1f,
|
|
};
|
|
|
|
static const uint32_t analog_mask[CCM_ANALOG_MAX] = {
|
|
[CCM_ANALOG_PLL_ARM] = 0xfff60f80,
|
|
[CCM_ANALOG_PLL_USB1] = 0xfffe0fbc,
|
|
[CCM_ANALOG_PLL_USB2] = 0xfffe0fbc,
|
|
[CCM_ANALOG_PLL_SYS] = 0xfffa0ffe,
|
|
[CCM_ANALOG_PLL_SYS_SS] = 0x00000000,
|
|
[CCM_ANALOG_PLL_SYS_NUM] = 0xc0000000,
|
|
[CCM_ANALOG_PLL_SYS_DENOM] = 0xc0000000,
|
|
[CCM_ANALOG_PLL_AUDIO] = 0xffe20f80,
|
|
[CCM_ANALOG_PLL_AUDIO_NUM] = 0xc0000000,
|
|
[CCM_ANALOG_PLL_AUDIO_DENOM] = 0xc0000000,
|
|
[CCM_ANALOG_PLL_VIDEO] = 0xffe20f80,
|
|
[CCM_ANALOG_PLL_VIDEO_NUM] = 0xc0000000,
|
|
[CCM_ANALOG_PLL_VIDEO_DENOM] = 0xc0000000,
|
|
[CCM_ANALOG_PLL_ENET] = 0xffc20ff0,
|
|
[CCM_ANALOG_PFD_480] = 0x40404040,
|
|
[CCM_ANALOG_PFD_528] = 0x40404040,
|
|
[PMU_MISC0] = 0x01fe8306,
|
|
[PMU_MISC1] = 0x07fcede0,
|
|
[PMU_MISC2] = 0x005f5f5f,
|
|
};
|
|
|
|
static const char *imx6ul_ccm_reg_name(uint32_t reg)
|
|
{
|
|
static char unknown[20];
|
|
|
|
switch (reg) {
|
|
case CCM_CCR:
|
|
return "CCR";
|
|
case CCM_CCDR:
|
|
return "CCDR";
|
|
case CCM_CSR:
|
|
return "CSR";
|
|
case CCM_CCSR:
|
|
return "CCSR";
|
|
case CCM_CACRR:
|
|
return "CACRR";
|
|
case CCM_CBCDR:
|
|
return "CBCDR";
|
|
case CCM_CBCMR:
|
|
return "CBCMR";
|
|
case CCM_CSCMR1:
|
|
return "CSCMR1";
|
|
case CCM_CSCMR2:
|
|
return "CSCMR2";
|
|
case CCM_CSCDR1:
|
|
return "CSCDR1";
|
|
case CCM_CS1CDR:
|
|
return "CS1CDR";
|
|
case CCM_CS2CDR:
|
|
return "CS2CDR";
|
|
case CCM_CDCDR:
|
|
return "CDCDR";
|
|
case CCM_CHSCCDR:
|
|
return "CHSCCDR";
|
|
case CCM_CSCDR2:
|
|
return "CSCDR2";
|
|
case CCM_CSCDR3:
|
|
return "CSCDR3";
|
|
case CCM_CDHIPR:
|
|
return "CDHIPR";
|
|
case CCM_CTOR:
|
|
return "CTOR";
|
|
case CCM_CLPCR:
|
|
return "CLPCR";
|
|
case CCM_CISR:
|
|
return "CISR";
|
|
case CCM_CIMR:
|
|
return "CIMR";
|
|
case CCM_CCOSR:
|
|
return "CCOSR";
|
|
case CCM_CGPR:
|
|
return "CGPR";
|
|
case CCM_CCGR0:
|
|
return "CCGR0";
|
|
case CCM_CCGR1:
|
|
return "CCGR1";
|
|
case CCM_CCGR2:
|
|
return "CCGR2";
|
|
case CCM_CCGR3:
|
|
return "CCGR3";
|
|
case CCM_CCGR4:
|
|
return "CCGR4";
|
|
case CCM_CCGR5:
|
|
return "CCGR5";
|
|
case CCM_CCGR6:
|
|
return "CCGR6";
|
|
case CCM_CMEOR:
|
|
return "CMEOR";
|
|
default:
|
|
sprintf(unknown, "%u ?", reg);
|
|
return unknown;
|
|
}
|
|
}
|
|
|
|
static const char *imx6ul_analog_reg_name(uint32_t reg)
|
|
{
|
|
static char unknown[20];
|
|
|
|
switch (reg) {
|
|
case CCM_ANALOG_PLL_ARM:
|
|
return "PLL_ARM";
|
|
case CCM_ANALOG_PLL_ARM_SET:
|
|
return "PLL_ARM_SET";
|
|
case CCM_ANALOG_PLL_ARM_CLR:
|
|
return "PLL_ARM_CLR";
|
|
case CCM_ANALOG_PLL_ARM_TOG:
|
|
return "PLL_ARM_TOG";
|
|
case CCM_ANALOG_PLL_USB1:
|
|
return "PLL_USB1";
|
|
case CCM_ANALOG_PLL_USB1_SET:
|
|
return "PLL_USB1_SET";
|
|
case CCM_ANALOG_PLL_USB1_CLR:
|
|
return "PLL_USB1_CLR";
|
|
case CCM_ANALOG_PLL_USB1_TOG:
|
|
return "PLL_USB1_TOG";
|
|
case CCM_ANALOG_PLL_USB2:
|
|
return "PLL_USB2";
|
|
case CCM_ANALOG_PLL_USB2_SET:
|
|
return "PLL_USB2_SET";
|
|
case CCM_ANALOG_PLL_USB2_CLR:
|
|
return "PLL_USB2_CLR";
|
|
case CCM_ANALOG_PLL_USB2_TOG:
|
|
return "PLL_USB2_TOG";
|
|
case CCM_ANALOG_PLL_SYS:
|
|
return "PLL_SYS";
|
|
case CCM_ANALOG_PLL_SYS_SET:
|
|
return "PLL_SYS_SET";
|
|
case CCM_ANALOG_PLL_SYS_CLR:
|
|
return "PLL_SYS_CLR";
|
|
case CCM_ANALOG_PLL_SYS_TOG:
|
|
return "PLL_SYS_TOG";
|
|
case CCM_ANALOG_PLL_SYS_SS:
|
|
return "PLL_SYS_SS";
|
|
case CCM_ANALOG_PLL_SYS_NUM:
|
|
return "PLL_SYS_NUM";
|
|
case CCM_ANALOG_PLL_SYS_DENOM:
|
|
return "PLL_SYS_DENOM";
|
|
case CCM_ANALOG_PLL_AUDIO:
|
|
return "PLL_AUDIO";
|
|
case CCM_ANALOG_PLL_AUDIO_SET:
|
|
return "PLL_AUDIO_SET";
|
|
case CCM_ANALOG_PLL_AUDIO_CLR:
|
|
return "PLL_AUDIO_CLR";
|
|
case CCM_ANALOG_PLL_AUDIO_TOG:
|
|
return "PLL_AUDIO_TOG";
|
|
case CCM_ANALOG_PLL_AUDIO_NUM:
|
|
return "PLL_AUDIO_NUM";
|
|
case CCM_ANALOG_PLL_AUDIO_DENOM:
|
|
return "PLL_AUDIO_DENOM";
|
|
case CCM_ANALOG_PLL_VIDEO:
|
|
return "PLL_VIDEO";
|
|
case CCM_ANALOG_PLL_VIDEO_SET:
|
|
return "PLL_VIDEO_SET";
|
|
case CCM_ANALOG_PLL_VIDEO_CLR:
|
|
return "PLL_VIDEO_CLR";
|
|
case CCM_ANALOG_PLL_VIDEO_TOG:
|
|
return "PLL_VIDEO_TOG";
|
|
case CCM_ANALOG_PLL_VIDEO_NUM:
|
|
return "PLL_VIDEO_NUM";
|
|
case CCM_ANALOG_PLL_VIDEO_DENOM:
|
|
return "PLL_VIDEO_DENOM";
|
|
case CCM_ANALOG_PLL_ENET:
|
|
return "PLL_ENET";
|
|
case CCM_ANALOG_PLL_ENET_SET:
|
|
return "PLL_ENET_SET";
|
|
case CCM_ANALOG_PLL_ENET_CLR:
|
|
return "PLL_ENET_CLR";
|
|
case CCM_ANALOG_PLL_ENET_TOG:
|
|
return "PLL_ENET_TOG";
|
|
case CCM_ANALOG_PFD_480:
|
|
return "PFD_480";
|
|
case CCM_ANALOG_PFD_480_SET:
|
|
return "PFD_480_SET";
|
|
case CCM_ANALOG_PFD_480_CLR:
|
|
return "PFD_480_CLR";
|
|
case CCM_ANALOG_PFD_480_TOG:
|
|
return "PFD_480_TOG";
|
|
case CCM_ANALOG_PFD_528:
|
|
return "PFD_528";
|
|
case CCM_ANALOG_PFD_528_SET:
|
|
return "PFD_528_SET";
|
|
case CCM_ANALOG_PFD_528_CLR:
|
|
return "PFD_528_CLR";
|
|
case CCM_ANALOG_PFD_528_TOG:
|
|
return "PFD_528_TOG";
|
|
case CCM_ANALOG_MISC0:
|
|
return "MISC0";
|
|
case CCM_ANALOG_MISC0_SET:
|
|
return "MISC0_SET";
|
|
case CCM_ANALOG_MISC0_CLR:
|
|
return "MISC0_CLR";
|
|
case CCM_ANALOG_MISC0_TOG:
|
|
return "MISC0_TOG";
|
|
case CCM_ANALOG_MISC2:
|
|
return "MISC2";
|
|
case CCM_ANALOG_MISC2_SET:
|
|
return "MISC2_SET";
|
|
case CCM_ANALOG_MISC2_CLR:
|
|
return "MISC2_CLR";
|
|
case CCM_ANALOG_MISC2_TOG:
|
|
return "MISC2_TOG";
|
|
case PMU_REG_1P1:
|
|
return "PMU_REG_1P1";
|
|
case PMU_REG_3P0:
|
|
return "PMU_REG_3P0";
|
|
case PMU_REG_2P5:
|
|
return "PMU_REG_2P5";
|
|
case PMU_REG_CORE:
|
|
return "PMU_REG_CORE";
|
|
case PMU_MISC1:
|
|
return "PMU_MISC1";
|
|
case PMU_MISC1_SET:
|
|
return "PMU_MISC1_SET";
|
|
case PMU_MISC1_CLR:
|
|
return "PMU_MISC1_CLR";
|
|
case PMU_MISC1_TOG:
|
|
return "PMU_MISC1_TOG";
|
|
case USB_ANALOG_DIGPROG:
|
|
return "USB_ANALOG_DIGPROG";
|
|
default:
|
|
sprintf(unknown, "%u ?", reg);
|
|
return unknown;
|
|
}
|
|
}
|
|
|
|
#define CKIH_FREQ 24000000 /* 24MHz crystal input */
|
|
|
|
static const VMStateDescription vmstate_imx6ul_ccm = {
|
|
.name = TYPE_IMX6UL_CCM,
|
|
.version_id = 1,
|
|
.minimum_version_id = 1,
|
|
.fields = (VMStateField[]) {
|
|
VMSTATE_UINT32_ARRAY(ccm, IMX6ULCCMState, CCM_MAX),
|
|
VMSTATE_UINT32_ARRAY(analog, IMX6ULCCMState, CCM_ANALOG_MAX),
|
|
VMSTATE_END_OF_LIST()
|
|
},
|
|
};
|
|
|
|
static uint64_t imx6ul_analog_get_osc_clk(IMX6ULCCMState *dev)
|
|
{
|
|
uint64_t freq = CKIH_FREQ;
|
|
|
|
trace_ccm_freq((uint32_t)freq);
|
|
|
|
return freq;
|
|
}
|
|
|
|
static uint64_t imx6ul_analog_get_pll2_clk(IMX6ULCCMState *dev)
|
|
{
|
|
uint64_t freq = imx6ul_analog_get_osc_clk(dev);
|
|
|
|
if (FIELD_EX32(dev->analog[CCM_ANALOG_PLL_SYS],
|
|
ANALOG_PLL_SYS, DIV_SELECT)) {
|
|
freq *= 22;
|
|
} else {
|
|
freq *= 20;
|
|
}
|
|
|
|
trace_ccm_freq((uint32_t)freq);
|
|
|
|
return freq;
|
|
}
|
|
|
|
static uint64_t imx6ul_analog_get_pll3_clk(IMX6ULCCMState *dev)
|
|
{
|
|
uint64_t freq = imx6ul_analog_get_osc_clk(dev) * 20;
|
|
|
|
trace_ccm_freq((uint32_t)freq);
|
|
|
|
return freq;
|
|
}
|
|
|
|
static uint64_t imx6ul_analog_get_pll2_pfd0_clk(IMX6ULCCMState *dev)
|
|
{
|
|
uint64_t freq = 0;
|
|
|
|
freq = imx6ul_analog_get_pll2_clk(dev) * 18
|
|
/ FIELD_EX32(dev->analog[CCM_ANALOG_PFD_528],
|
|
ANALOG_PFD_528, PFD0_FRAC);
|
|
|
|
trace_ccm_freq((uint32_t)freq);
|
|
|
|
return freq;
|
|
}
|
|
|
|
static uint64_t imx6ul_analog_get_pll2_pfd2_clk(IMX6ULCCMState *dev)
|
|
{
|
|
uint64_t freq = 0;
|
|
|
|
freq = imx6ul_analog_get_pll2_clk(dev) * 18
|
|
/ FIELD_EX32(dev->analog[CCM_ANALOG_PFD_528],
|
|
ANALOG_PFD_528, PFD2_FRAC);
|
|
|
|
trace_ccm_freq((uint32_t)freq);
|
|
|
|
return freq;
|
|
}
|
|
|
|
static uint64_t imx6ul_analog_pll2_bypass_clk(IMX6ULCCMState *dev)
|
|
{
|
|
uint64_t freq = 0;
|
|
|
|
trace_ccm_freq((uint32_t)freq);
|
|
|
|
return freq;
|
|
}
|
|
|
|
static uint64_t imx6ul_ccm_get_periph_clk2_sel_clk(IMX6ULCCMState *dev)
|
|
{
|
|
uint64_t freq = 0;
|
|
|
|
switch (FIELD_EX32(dev->ccm[CCM_CBCMR], CBCMR, PERIPH_CLK2_SEL)) {
|
|
case 0:
|
|
freq = imx6ul_analog_get_pll3_clk(dev);
|
|
break;
|
|
case 1:
|
|
freq = imx6ul_analog_get_osc_clk(dev);
|
|
break;
|
|
case 2:
|
|
freq = imx6ul_analog_pll2_bypass_clk(dev);
|
|
break;
|
|
case 3:
|
|
/* We should never get there as 3 is a reserved value */
|
|
qemu_log_mask(LOG_GUEST_ERROR,
|
|
"[%s]%s: unsupported PERIPH_CLK2_SEL value 3\n",
|
|
TYPE_IMX6UL_CCM, __func__);
|
|
/* freq is set to 0 as we don't know what it should be */
|
|
break;
|
|
default:
|
|
g_assert_not_reached();
|
|
}
|
|
|
|
trace_ccm_freq((uint32_t)freq);
|
|
|
|
return freq;
|
|
}
|
|
|
|
static uint64_t imx6ul_ccm_get_periph_clk_sel_clk(IMX6ULCCMState *dev)
|
|
{
|
|
uint64_t freq = 0;
|
|
|
|
switch (FIELD_EX32(dev->ccm[CCM_CBCMR], CBCMR, PRE_PERIPH_CLK_SEL)) {
|
|
case 0:
|
|
freq = imx6ul_analog_get_pll2_clk(dev);
|
|
break;
|
|
case 1:
|
|
freq = imx6ul_analog_get_pll2_pfd2_clk(dev);
|
|
break;
|
|
case 2:
|
|
freq = imx6ul_analog_get_pll2_pfd0_clk(dev);
|
|
break;
|
|
case 3:
|
|
freq = imx6ul_analog_get_pll2_pfd2_clk(dev) / 2;
|
|
break;
|
|
default:
|
|
g_assert_not_reached();
|
|
}
|
|
|
|
trace_ccm_freq((uint32_t)freq);
|
|
|
|
return freq;
|
|
}
|
|
|
|
static uint64_t imx6ul_ccm_get_periph_clk2_clk(IMX6ULCCMState *dev)
|
|
{
|
|
uint64_t freq = 0;
|
|
|
|
freq = imx6ul_ccm_get_periph_clk2_sel_clk(dev)
|
|
/ (1 + FIELD_EX32(dev->ccm[CCM_CBCDR], CBCDR, PERIPH_CLK2_PODF));
|
|
|
|
trace_ccm_freq((uint32_t)freq);
|
|
|
|
return freq;
|
|
}
|
|
|
|
static uint64_t imx6ul_ccm_get_periph_sel_clk(IMX6ULCCMState *dev)
|
|
{
|
|
uint64_t freq = 0;
|
|
|
|
switch (FIELD_EX32(dev->ccm[CCM_CBCDR], CBCDR, PERIPH_CLK_SEL)) {
|
|
case 0:
|
|
freq = imx6ul_ccm_get_periph_clk_sel_clk(dev);
|
|
break;
|
|
case 1:
|
|
freq = imx6ul_ccm_get_periph_clk2_clk(dev);
|
|
break;
|
|
default:
|
|
g_assert_not_reached();
|
|
}
|
|
|
|
trace_ccm_freq((uint32_t)freq);
|
|
|
|
return freq;
|
|
}
|
|
|
|
static uint64_t imx6ul_ccm_get_ahb_clk(IMX6ULCCMState *dev)
|
|
{
|
|
uint64_t freq = 0;
|
|
|
|
freq = imx6ul_ccm_get_periph_sel_clk(dev)
|
|
/ (1 + FIELD_EX32(dev->ccm[CCM_CBCDR], CBCDR, AHB_PODF));
|
|
|
|
trace_ccm_freq((uint32_t)freq);
|
|
|
|
return freq;
|
|
}
|
|
|
|
static uint64_t imx6ul_ccm_get_ipg_clk(IMX6ULCCMState *dev)
|
|
{
|
|
uint64_t freq = 0;
|
|
|
|
freq = imx6ul_ccm_get_ahb_clk(dev)
|
|
/ (1 + FIELD_EX32(dev->ccm[CCM_CBCDR], CBCDR, IPG_PODF));
|
|
|
|
trace_ccm_freq((uint32_t)freq);
|
|
|
|
return freq;
|
|
}
|
|
|
|
static uint64_t imx6ul_ccm_get_per_sel_clk(IMX6ULCCMState *dev)
|
|
{
|
|
uint64_t freq = 0;
|
|
|
|
switch (FIELD_EX32(dev->ccm[CCM_CSCMR1], CSCMR1, PERCLK_CLK_SEL)) {
|
|
case 0:
|
|
freq = imx6ul_ccm_get_ipg_clk(dev);
|
|
break;
|
|
case 1:
|
|
freq = imx6ul_analog_get_osc_clk(dev);
|
|
break;
|
|
default:
|
|
g_assert_not_reached();
|
|
}
|
|
|
|
trace_ccm_freq((uint32_t)freq);
|
|
|
|
return freq;
|
|
}
|
|
|
|
static uint64_t imx6ul_ccm_get_per_clk(IMX6ULCCMState *dev)
|
|
{
|
|
uint64_t freq = 0;
|
|
|
|
freq = imx6ul_ccm_get_per_sel_clk(dev)
|
|
/ (1 + FIELD_EX32(dev->ccm[CCM_CSCMR1], CSCMR1, PERCLK_PODF));
|
|
|
|
trace_ccm_freq((uint32_t)freq);
|
|
|
|
return freq;
|
|
}
|
|
|
|
static uint32_t imx6ul_ccm_get_clock_frequency(IMXCCMState *dev, IMXClk clock)
|
|
{
|
|
uint32_t freq = 0;
|
|
IMX6ULCCMState *s = IMX6UL_CCM(dev);
|
|
|
|
switch (clock) {
|
|
case CLK_NONE:
|
|
break;
|
|
case CLK_IPG:
|
|
freq = imx6ul_ccm_get_ipg_clk(s);
|
|
break;
|
|
case CLK_IPG_HIGH:
|
|
freq = imx6ul_ccm_get_per_clk(s);
|
|
break;
|
|
case CLK_32k:
|
|
freq = CKIL_FREQ;
|
|
break;
|
|
case CLK_HIGH:
|
|
freq = CKIH_FREQ;
|
|
break;
|
|
case CLK_HIGH_DIV:
|
|
freq = CKIH_FREQ / 8;
|
|
break;
|
|
default:
|
|
qemu_log_mask(LOG_GUEST_ERROR, "[%s]%s: unsupported clock %d\n",
|
|
TYPE_IMX6UL_CCM, __func__, clock);
|
|
break;
|
|
}
|
|
|
|
trace_ccm_clock_freq(clock, freq);
|
|
|
|
return freq;
|
|
}
|
|
|
|
static void imx6ul_ccm_reset(DeviceState *dev)
|
|
{
|
|
IMX6ULCCMState *s = IMX6UL_CCM(dev);
|
|
|
|
trace_ccm_entry();
|
|
|
|
s->ccm[CCM_CCR] = 0x0401167F;
|
|
s->ccm[CCM_CCDR] = 0x00000000;
|
|
s->ccm[CCM_CSR] = 0x00000010;
|
|
s->ccm[CCM_CCSR] = 0x00000100;
|
|
s->ccm[CCM_CACRR] = 0x00000000;
|
|
s->ccm[CCM_CBCDR] = 0x00018D00;
|
|
s->ccm[CCM_CBCMR] = 0x24860324;
|
|
s->ccm[CCM_CSCMR1] = 0x04900080;
|
|
s->ccm[CCM_CSCMR2] = 0x03192F06;
|
|
s->ccm[CCM_CSCDR1] = 0x00490B00;
|
|
s->ccm[CCM_CS1CDR] = 0x0EC102C1;
|
|
s->ccm[CCM_CS2CDR] = 0x000336C1;
|
|
s->ccm[CCM_CDCDR] = 0x33F71F92;
|
|
s->ccm[CCM_CHSCCDR] = 0x000248A4;
|
|
s->ccm[CCM_CSCDR2] = 0x00029B48;
|
|
s->ccm[CCM_CSCDR3] = 0x00014841;
|
|
s->ccm[CCM_CDHIPR] = 0x00000000;
|
|
s->ccm[CCM_CTOR] = 0x00000000;
|
|
s->ccm[CCM_CLPCR] = 0x00000079;
|
|
s->ccm[CCM_CISR] = 0x00000000;
|
|
s->ccm[CCM_CIMR] = 0xFFFFFFFF;
|
|
s->ccm[CCM_CCOSR] = 0x000A0001;
|
|
s->ccm[CCM_CGPR] = 0x0000FE62;
|
|
s->ccm[CCM_CCGR0] = 0xFFFFFFFF;
|
|
s->ccm[CCM_CCGR1] = 0xFFFFFFFF;
|
|
s->ccm[CCM_CCGR2] = 0xFC3FFFFF;
|
|
s->ccm[CCM_CCGR3] = 0xFFFFFFFF;
|
|
s->ccm[CCM_CCGR4] = 0xFFFFFFFF;
|
|
s->ccm[CCM_CCGR5] = 0xFFFFFFFF;
|
|
s->ccm[CCM_CCGR6] = 0xFFFFFFFF;
|
|
s->ccm[CCM_CMEOR] = 0xFFFFFFFF;
|
|
|
|
s->analog[CCM_ANALOG_PLL_ARM] = 0x00013063;
|
|
s->analog[CCM_ANALOG_PLL_USB1] = 0x00012000;
|
|
s->analog[CCM_ANALOG_PLL_USB2] = 0x00012000;
|
|
s->analog[CCM_ANALOG_PLL_SYS] = 0x00013001;
|
|
s->analog[CCM_ANALOG_PLL_SYS_SS] = 0x00000000;
|
|
s->analog[CCM_ANALOG_PLL_SYS_NUM] = 0x00000000;
|
|
s->analog[CCM_ANALOG_PLL_SYS_DENOM] = 0x00000012;
|
|
s->analog[CCM_ANALOG_PLL_AUDIO] = 0x00011006;
|
|
s->analog[CCM_ANALOG_PLL_AUDIO_NUM] = 0x05F5E100;
|
|
s->analog[CCM_ANALOG_PLL_AUDIO_DENOM] = 0x2964619C;
|
|
s->analog[CCM_ANALOG_PLL_VIDEO] = 0x0001100C;
|
|
s->analog[CCM_ANALOG_PLL_VIDEO_NUM] = 0x05F5E100;
|
|
s->analog[CCM_ANALOG_PLL_VIDEO_DENOM] = 0x10A24447;
|
|
s->analog[CCM_ANALOG_PLL_ENET] = 0x00011001;
|
|
s->analog[CCM_ANALOG_PFD_480] = 0x1311100C;
|
|
s->analog[CCM_ANALOG_PFD_528] = 0x1018101B;
|
|
|
|
s->analog[PMU_REG_1P1] = 0x00001073;
|
|
s->analog[PMU_REG_3P0] = 0x00000F74;
|
|
s->analog[PMU_REG_2P5] = 0x00001073;
|
|
s->analog[PMU_REG_CORE] = 0x00482012;
|
|
s->analog[PMU_MISC0] = 0x04000000;
|
|
s->analog[PMU_MISC1] = 0x00000000;
|
|
s->analog[PMU_MISC2] = 0x00272727;
|
|
s->analog[PMU_LOWPWR_CTRL] = 0x00004009;
|
|
|
|
s->analog[USB_ANALOG_USB1_VBUS_DETECT] = 0x01000004;
|
|
s->analog[USB_ANALOG_USB1_CHRG_DETECT] = 0x00000000;
|
|
s->analog[USB_ANALOG_USB1_VBUS_DETECT_STAT] = 0x00000000;
|
|
s->analog[USB_ANALOG_USB1_CHRG_DETECT_STAT] = 0x00000000;
|
|
s->analog[USB_ANALOG_USB1_MISC] = 0x00000002;
|
|
s->analog[USB_ANALOG_USB2_VBUS_DETECT] = 0x01000004;
|
|
s->analog[USB_ANALOG_USB2_CHRG_DETECT] = 0x00000000;
|
|
s->analog[USB_ANALOG_USB2_MISC] = 0x00000002;
|
|
s->analog[USB_ANALOG_DIGPROG] = 0x00640000;
|
|
|
|
/* all PLLs need to be locked */
|
|
s->analog[CCM_ANALOG_PLL_ARM] |= CCM_ANALOG_PLL_LOCK;
|
|
s->analog[CCM_ANALOG_PLL_USB1] |= CCM_ANALOG_PLL_LOCK;
|
|
s->analog[CCM_ANALOG_PLL_USB2] |= CCM_ANALOG_PLL_LOCK;
|
|
s->analog[CCM_ANALOG_PLL_SYS] |= CCM_ANALOG_PLL_LOCK;
|
|
s->analog[CCM_ANALOG_PLL_AUDIO] |= CCM_ANALOG_PLL_LOCK;
|
|
s->analog[CCM_ANALOG_PLL_VIDEO] |= CCM_ANALOG_PLL_LOCK;
|
|
s->analog[CCM_ANALOG_PLL_ENET] |= CCM_ANALOG_PLL_LOCK;
|
|
|
|
s->analog[TEMPMON_TEMPSENSE0] = 0x00000001;
|
|
s->analog[TEMPMON_TEMPSENSE1] = 0x00000001;
|
|
s->analog[TEMPMON_TEMPSENSE2] = 0x00000000;
|
|
}
|
|
|
|
static uint64_t imx6ul_ccm_read(void *opaque, hwaddr offset, unsigned size)
|
|
{
|
|
uint32_t value = 0;
|
|
uint32_t index = offset >> 2;
|
|
IMX6ULCCMState *s = (IMX6ULCCMState *)opaque;
|
|
|
|
assert(index < CCM_MAX);
|
|
|
|
value = s->ccm[index];
|
|
|
|
trace_ccm_read_reg(imx6ul_ccm_reg_name(index), (uint32_t)value);
|
|
|
|
return (uint64_t)value;
|
|
}
|
|
|
|
static void imx6ul_ccm_write(void *opaque, hwaddr offset, uint64_t value,
|
|
unsigned size)
|
|
{
|
|
uint32_t index = offset >> 2;
|
|
IMX6ULCCMState *s = (IMX6ULCCMState *)opaque;
|
|
|
|
assert(index < CCM_MAX);
|
|
|
|
trace_ccm_write_reg(imx6ul_ccm_reg_name(index), (uint32_t)value);
|
|
|
|
s->ccm[index] = (s->ccm[index] & ccm_mask[index]) |
|
|
((uint32_t)value & ~ccm_mask[index]);
|
|
}
|
|
|
|
static uint64_t imx6ul_analog_read(void *opaque, hwaddr offset, unsigned size)
|
|
{
|
|
uint32_t value;
|
|
uint32_t index = offset >> 2;
|
|
IMX6ULCCMState *s = (IMX6ULCCMState *)opaque;
|
|
|
|
assert(index < CCM_ANALOG_MAX);
|
|
|
|
switch (index) {
|
|
case CCM_ANALOG_PLL_ARM_SET:
|
|
case CCM_ANALOG_PLL_USB1_SET:
|
|
case CCM_ANALOG_PLL_USB2_SET:
|
|
case CCM_ANALOG_PLL_SYS_SET:
|
|
case CCM_ANALOG_PLL_AUDIO_SET:
|
|
case CCM_ANALOG_PLL_VIDEO_SET:
|
|
case CCM_ANALOG_PLL_ENET_SET:
|
|
case CCM_ANALOG_PFD_480_SET:
|
|
case CCM_ANALOG_PFD_528_SET:
|
|
case CCM_ANALOG_MISC0_SET:
|
|
case PMU_MISC1_SET:
|
|
case CCM_ANALOG_MISC2_SET:
|
|
case USB_ANALOG_USB1_VBUS_DETECT_SET:
|
|
case USB_ANALOG_USB1_CHRG_DETECT_SET:
|
|
case USB_ANALOG_USB1_MISC_SET:
|
|
case USB_ANALOG_USB2_VBUS_DETECT_SET:
|
|
case USB_ANALOG_USB2_CHRG_DETECT_SET:
|
|
case USB_ANALOG_USB2_MISC_SET:
|
|
case TEMPMON_TEMPSENSE0_SET:
|
|
case TEMPMON_TEMPSENSE1_SET:
|
|
case TEMPMON_TEMPSENSE2_SET:
|
|
/*
|
|
* All REG_NAME_SET register access are in fact targeting
|
|
* the REG_NAME register.
|
|
*/
|
|
value = s->analog[index - 1];
|
|
break;
|
|
case CCM_ANALOG_PLL_ARM_CLR:
|
|
case CCM_ANALOG_PLL_USB1_CLR:
|
|
case CCM_ANALOG_PLL_USB2_CLR:
|
|
case CCM_ANALOG_PLL_SYS_CLR:
|
|
case CCM_ANALOG_PLL_AUDIO_CLR:
|
|
case CCM_ANALOG_PLL_VIDEO_CLR:
|
|
case CCM_ANALOG_PLL_ENET_CLR:
|
|
case CCM_ANALOG_PFD_480_CLR:
|
|
case CCM_ANALOG_PFD_528_CLR:
|
|
case CCM_ANALOG_MISC0_CLR:
|
|
case PMU_MISC1_CLR:
|
|
case CCM_ANALOG_MISC2_CLR:
|
|
case USB_ANALOG_USB1_VBUS_DETECT_CLR:
|
|
case USB_ANALOG_USB1_CHRG_DETECT_CLR:
|
|
case USB_ANALOG_USB1_MISC_CLR:
|
|
case USB_ANALOG_USB2_VBUS_DETECT_CLR:
|
|
case USB_ANALOG_USB2_CHRG_DETECT_CLR:
|
|
case USB_ANALOG_USB2_MISC_CLR:
|
|
case TEMPMON_TEMPSENSE0_CLR:
|
|
case TEMPMON_TEMPSENSE1_CLR:
|
|
case TEMPMON_TEMPSENSE2_CLR:
|
|
/*
|
|
* All REG_NAME_CLR register access are in fact targeting
|
|
* the REG_NAME register.
|
|
*/
|
|
value = s->analog[index - 2];
|
|
break;
|
|
case CCM_ANALOG_PLL_ARM_TOG:
|
|
case CCM_ANALOG_PLL_USB1_TOG:
|
|
case CCM_ANALOG_PLL_USB2_TOG:
|
|
case CCM_ANALOG_PLL_SYS_TOG:
|
|
case CCM_ANALOG_PLL_AUDIO_TOG:
|
|
case CCM_ANALOG_PLL_VIDEO_TOG:
|
|
case CCM_ANALOG_PLL_ENET_TOG:
|
|
case CCM_ANALOG_PFD_480_TOG:
|
|
case CCM_ANALOG_PFD_528_TOG:
|
|
case CCM_ANALOG_MISC0_TOG:
|
|
case PMU_MISC1_TOG:
|
|
case CCM_ANALOG_MISC2_TOG:
|
|
case USB_ANALOG_USB1_VBUS_DETECT_TOG:
|
|
case USB_ANALOG_USB1_CHRG_DETECT_TOG:
|
|
case USB_ANALOG_USB1_MISC_TOG:
|
|
case USB_ANALOG_USB2_VBUS_DETECT_TOG:
|
|
case USB_ANALOG_USB2_CHRG_DETECT_TOG:
|
|
case USB_ANALOG_USB2_MISC_TOG:
|
|
case TEMPMON_TEMPSENSE0_TOG:
|
|
case TEMPMON_TEMPSENSE1_TOG:
|
|
case TEMPMON_TEMPSENSE2_TOG:
|
|
/*
|
|
* All REG_NAME_TOG register access are in fact targeting
|
|
* the REG_NAME register.
|
|
*/
|
|
value = s->analog[index - 3];
|
|
break;
|
|
default:
|
|
value = s->analog[index];
|
|
break;
|
|
}
|
|
|
|
trace_ccm_read_reg(imx6ul_analog_reg_name(index), (uint32_t)value);
|
|
|
|
return (uint64_t)value;
|
|
}
|
|
|
|
static void imx6ul_analog_write(void *opaque, hwaddr offset, uint64_t value,
|
|
unsigned size)
|
|
{
|
|
uint32_t index = offset >> 2;
|
|
IMX6ULCCMState *s = (IMX6ULCCMState *)opaque;
|
|
|
|
assert(index < CCM_ANALOG_MAX);
|
|
|
|
trace_ccm_write_reg(imx6ul_analog_reg_name(index), (uint32_t)value);
|
|
|
|
switch (index) {
|
|
case CCM_ANALOG_PLL_ARM_SET:
|
|
case CCM_ANALOG_PLL_USB1_SET:
|
|
case CCM_ANALOG_PLL_USB2_SET:
|
|
case CCM_ANALOG_PLL_SYS_SET:
|
|
case CCM_ANALOG_PLL_AUDIO_SET:
|
|
case CCM_ANALOG_PLL_VIDEO_SET:
|
|
case CCM_ANALOG_PLL_ENET_SET:
|
|
case CCM_ANALOG_PFD_480_SET:
|
|
case CCM_ANALOG_PFD_528_SET:
|
|
case CCM_ANALOG_MISC0_SET:
|
|
case PMU_MISC1_SET:
|
|
case CCM_ANALOG_MISC2_SET:
|
|
case USB_ANALOG_USB1_VBUS_DETECT_SET:
|
|
case USB_ANALOG_USB1_CHRG_DETECT_SET:
|
|
case USB_ANALOG_USB1_MISC_SET:
|
|
case USB_ANALOG_USB2_VBUS_DETECT_SET:
|
|
case USB_ANALOG_USB2_CHRG_DETECT_SET:
|
|
case USB_ANALOG_USB2_MISC_SET:
|
|
/*
|
|
* All REG_NAME_SET register access are in fact targeting
|
|
* the REG_NAME register. So we change the value of the
|
|
* REG_NAME register, setting bits passed in the value.
|
|
*/
|
|
s->analog[index - 1] |= (value & ~analog_mask[index - 1]);
|
|
break;
|
|
case CCM_ANALOG_PLL_ARM_CLR:
|
|
case CCM_ANALOG_PLL_USB1_CLR:
|
|
case CCM_ANALOG_PLL_USB2_CLR:
|
|
case CCM_ANALOG_PLL_SYS_CLR:
|
|
case CCM_ANALOG_PLL_AUDIO_CLR:
|
|
case CCM_ANALOG_PLL_VIDEO_CLR:
|
|
case CCM_ANALOG_PLL_ENET_CLR:
|
|
case CCM_ANALOG_PFD_480_CLR:
|
|
case CCM_ANALOG_PFD_528_CLR:
|
|
case CCM_ANALOG_MISC0_CLR:
|
|
case PMU_MISC1_CLR:
|
|
case CCM_ANALOG_MISC2_CLR:
|
|
case USB_ANALOG_USB1_VBUS_DETECT_CLR:
|
|
case USB_ANALOG_USB1_CHRG_DETECT_CLR:
|
|
case USB_ANALOG_USB1_MISC_CLR:
|
|
case USB_ANALOG_USB2_VBUS_DETECT_CLR:
|
|
case USB_ANALOG_USB2_CHRG_DETECT_CLR:
|
|
case USB_ANALOG_USB2_MISC_CLR:
|
|
/*
|
|
* All REG_NAME_CLR register access are in fact targeting
|
|
* the REG_NAME register. So we change the value of the
|
|
* REG_NAME register, unsetting bits passed in the value.
|
|
*/
|
|
s->analog[index - 2] &= ~(value & ~analog_mask[index - 2]);
|
|
break;
|
|
case CCM_ANALOG_PLL_ARM_TOG:
|
|
case CCM_ANALOG_PLL_USB1_TOG:
|
|
case CCM_ANALOG_PLL_USB2_TOG:
|
|
case CCM_ANALOG_PLL_SYS_TOG:
|
|
case CCM_ANALOG_PLL_AUDIO_TOG:
|
|
case CCM_ANALOG_PLL_VIDEO_TOG:
|
|
case CCM_ANALOG_PLL_ENET_TOG:
|
|
case CCM_ANALOG_PFD_480_TOG:
|
|
case CCM_ANALOG_PFD_528_TOG:
|
|
case CCM_ANALOG_MISC0_TOG:
|
|
case PMU_MISC1_TOG:
|
|
case CCM_ANALOG_MISC2_TOG:
|
|
case USB_ANALOG_USB1_VBUS_DETECT_TOG:
|
|
case USB_ANALOG_USB1_CHRG_DETECT_TOG:
|
|
case USB_ANALOG_USB1_MISC_TOG:
|
|
case USB_ANALOG_USB2_VBUS_DETECT_TOG:
|
|
case USB_ANALOG_USB2_CHRG_DETECT_TOG:
|
|
case USB_ANALOG_USB2_MISC_TOG:
|
|
/*
|
|
* All REG_NAME_TOG register access are in fact targeting
|
|
* the REG_NAME register. So we change the value of the
|
|
* REG_NAME register, toggling bits passed in the value.
|
|
*/
|
|
s->analog[index - 3] ^= (value & ~analog_mask[index - 3]);
|
|
break;
|
|
default:
|
|
s->analog[index] = (s->analog[index] & analog_mask[index]) |
|
|
(value & ~analog_mask[index]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static const struct MemoryRegionOps imx6ul_ccm_ops = {
|
|
.read = imx6ul_ccm_read,
|
|
.write = imx6ul_ccm_write,
|
|
.endianness = DEVICE_NATIVE_ENDIAN,
|
|
.valid = {
|
|
/*
|
|
* Our device would not work correctly if the guest was doing
|
|
* unaligned access. This might not be a limitation on the real
|
|
* device but in practice there is no reason for a guest to access
|
|
* this device unaligned.
|
|
*/
|
|
.min_access_size = 4,
|
|
.max_access_size = 4,
|
|
.unaligned = false,
|
|
},
|
|
};
|
|
|
|
static const struct MemoryRegionOps imx6ul_analog_ops = {
|
|
.read = imx6ul_analog_read,
|
|
.write = imx6ul_analog_write,
|
|
.endianness = DEVICE_NATIVE_ENDIAN,
|
|
.valid = {
|
|
/*
|
|
* Our device would not work correctly if the guest was doing
|
|
* unaligned access. This might not be a limitation on the real
|
|
* device but in practice there is no reason for a guest to access
|
|
* this device unaligned.
|
|
*/
|
|
.min_access_size = 4,
|
|
.max_access_size = 4,
|
|
.unaligned = false,
|
|
},
|
|
};
|
|
|
|
static void imx6ul_ccm_init(Object *obj)
|
|
{
|
|
DeviceState *dev = DEVICE(obj);
|
|
SysBusDevice *sd = SYS_BUS_DEVICE(obj);
|
|
IMX6ULCCMState *s = IMX6UL_CCM(obj);
|
|
|
|
/* initialize a container for the all memory range */
|
|
memory_region_init(&s->container, OBJECT(dev), TYPE_IMX6UL_CCM, 0x8000);
|
|
|
|
/* We initialize an IO memory region for the CCM part */
|
|
memory_region_init_io(&s->ioccm, OBJECT(dev), &imx6ul_ccm_ops, s,
|
|
TYPE_IMX6UL_CCM ".ccm", CCM_MAX * sizeof(uint32_t));
|
|
|
|
/* Add the CCM as a subregion at offset 0 */
|
|
memory_region_add_subregion(&s->container, 0, &s->ioccm);
|
|
|
|
/* We initialize an IO memory region for the ANALOG part */
|
|
memory_region_init_io(&s->ioanalog, OBJECT(dev), &imx6ul_analog_ops, s,
|
|
TYPE_IMX6UL_CCM ".analog",
|
|
CCM_ANALOG_MAX * sizeof(uint32_t));
|
|
|
|
/* Add the ANALOG as a subregion at offset 0x4000 */
|
|
memory_region_add_subregion(&s->container, 0x4000, &s->ioanalog);
|
|
|
|
sysbus_init_mmio(sd, &s->container);
|
|
}
|
|
|
|
static void imx6ul_ccm_class_init(ObjectClass *klass, void *data)
|
|
{
|
|
DeviceClass *dc = DEVICE_CLASS(klass);
|
|
IMXCCMClass *ccm = IMX_CCM_CLASS(klass);
|
|
|
|
dc->reset = imx6ul_ccm_reset;
|
|
dc->vmsd = &vmstate_imx6ul_ccm;
|
|
dc->desc = "i.MX6UL Clock Control Module";
|
|
|
|
ccm->get_clock_frequency = imx6ul_ccm_get_clock_frequency;
|
|
}
|
|
|
|
static const TypeInfo imx6ul_ccm_info = {
|
|
.name = TYPE_IMX6UL_CCM,
|
|
.parent = TYPE_IMX_CCM,
|
|
.instance_size = sizeof(IMX6ULCCMState),
|
|
.instance_init = imx6ul_ccm_init,
|
|
.class_init = imx6ul_ccm_class_init,
|
|
};
|
|
|
|
static void imx6ul_ccm_register_types(void)
|
|
{
|
|
type_register_static(&imx6ul_ccm_info);
|
|
}
|
|
|
|
type_init(imx6ul_ccm_register_types)
|