arch/arm/cpu/armv8/s32v234/generic.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2013-2016, Freescale Semiconductor, Inc.
   4  */
   5
   6 #include <common.h>
   7 #include <clock_legacy.h>
   8 #include <cpu_func.h>
   9 #include <net.h>
  10 #include <asm/io.h>
  11 #include <asm/arch/imx-regs.h>
  12 #include <asm/arch/clock.h>
  13 #include <asm/arch/mc_cgm_regs.h>
  14 #include <asm/arch/mc_me_regs.h>
  15 #include <asm/arch/mc_rgm_regs.h>
  16 #include <netdev.h>
  17 #include <div64.h>
  18 #include <errno.h>
  19
  20 u32 get_cpu_rev(void)
  21 {
  22         struct mscm_ir *mscmir = (struct mscm_ir *)MSCM_BASE_ADDR;
  23         u32 cpu = readl(&mscmir->cpxtype);
  24
  25         return cpu;
  26 }
  27
  28 DECLARE_GLOBAL_DATA_PTR;
  29
  30 static uintptr_t get_pllfreq(u32 pll, u32 refclk_freq, u32 plldv,
  31                              u32 pllfd, u32 selected_output)
  32 {
  33         u32 vco = 0, plldv_prediv = 0, plldv_mfd = 0, pllfd_mfn = 0;
  34         u32 plldv_rfdphi_div = 0, fout = 0;
  35         u32 dfs_portn = 0, dfs_mfn = 0, dfs_mfi = 0;
  36
  37         if (selected_output > DFS_MAXNUMBER) {
  38                 return -1;
  39         }
  40
  41         plldv_prediv =
  42             (plldv & PLLDIG_PLLDV_PREDIV_MASK) >> PLLDIG_PLLDV_PREDIV_OFFSET;
  43         plldv_mfd = (plldv & PLLDIG_PLLDV_MFD_MASK);
  44
  45         pllfd_mfn = (pllfd & PLLDIG_PLLFD_MFN_MASK);
  46
  47         plldv_prediv = plldv_prediv == 0 ? 1 : plldv_prediv;
  48
  49         /* The formula for VCO is from TR manual, rev. D */
  50         vco = refclk_freq / plldv_prediv * (plldv_mfd + pllfd_mfn / 20481);
  51
  52         if (selected_output != 0) {
  53                 /* Determine the RFDPHI for PHI1 */
  54                 plldv_rfdphi_div =
  55                     (plldv & PLLDIG_PLLDV_RFDPHI1_MASK) >>
  56                     PLLDIG_PLLDV_RFDPHI1_OFFSET;
  57                 plldv_rfdphi_div = plldv_rfdphi_div == 0 ? 1 : plldv_rfdphi_div;
  58                 if (pll == ARM_PLL || pll == ENET_PLL || pll == DDR_PLL) {
  59                         dfs_portn =
  60                             readl(DFS_DVPORTn(pll, selected_output - 1));
  61                         dfs_mfi =
  62                             (dfs_portn & DFS_DVPORTn_MFI_MASK) >>
  63                             DFS_DVPORTn_MFI_OFFSET;
  64                         dfs_mfn =
  65                             (dfs_portn & DFS_DVPORTn_MFI_MASK) >>
  66                             DFS_DVPORTn_MFI_OFFSET;
  67                         fout = vco / (dfs_mfi + (dfs_mfn / 256));
  68                 } else {
  69                         fout = vco / plldv_rfdphi_div;
  70                 }
  71
  72         } else {
  73                 /* Determine the RFDPHI for PHI0 */
  74                 plldv_rfdphi_div =
  75                     (plldv & PLLDIG_PLLDV_RFDPHI_MASK) >>
  76                     PLLDIG_PLLDV_RFDPHI_OFFSET;
  77                 fout = vco / plldv_rfdphi_div;
  78         }
  79
  80         return fout;
  81
  82 }
  83
  84 /* Implemented for ARMPLL, PERIPH_PLL, ENET_PLL, DDR_PLL, VIDEO_LL */
  85 static uintptr_t decode_pll(enum pll_type pll, u32 refclk_freq,
  86                             u32 selected_output)
  87 {
  88         u32 plldv, pllfd;
  89
  90         plldv = readl(PLLDIG_PLLDV(pll));
  91         pllfd = readl(PLLDIG_PLLFD(pll));
  92
  93         return get_pllfreq(pll, refclk_freq, plldv, pllfd, selected_output);
  94 }
  95
  96 static u32 get_mcu_main_clk(void)
  97 {
  98         u32 coreclk_div;
  99         u32 sysclk_sel;
 100         u32 freq = 0;
 101
 102         sysclk_sel = readl(CGM_SC_SS(MC_CGM1_BASE_ADDR)) & MC_CGM_SC_SEL_MASK;
 103         sysclk_sel >>= MC_CGM_SC_SEL_OFFSET;
 104
 105         coreclk_div =
 106             readl(CGM_SC_DCn(MC_CGM1_BASE_ADDR, 0)) & MC_CGM_SC_DCn_PREDIV_MASK;
 107         coreclk_div >>= MC_CGM_SC_DCn_PREDIV_OFFSET;
 108         coreclk_div += 1;
 109
 110         switch (sysclk_sel) {
 111         case MC_CGM_SC_SEL_FIRC:
 112                 freq = FIRC_CLK_FREQ;
 113                 break;
 114         case MC_CGM_SC_SEL_XOSC:
 115                 freq = XOSC_CLK_FREQ;
 116                 break;
 117         case MC_CGM_SC_SEL_ARMPLL:
 118                 /* ARMPLL has as source XOSC and CORE_CLK has as input PHI0 */
 119                 freq = decode_pll(ARM_PLL, XOSC_CLK_FREQ, 0);
 120                 break;
 121         case MC_CGM_SC_SEL_CLKDISABLE:
 122                 printf("Sysclk is disabled\n");
 123                 break;
 124         default:
 125                 printf("unsupported system clock select\n");
 126         }
 127
 128         return freq / coreclk_div;
 129 }
 130
 131 static u32 get_sys_clk(u32 number)
 132 {
 133         u32 sysclk_div, sysclk_div_number;
 134         u32 sysclk_sel;
 135         u32 freq = 0;
 136
 137         switch (number) {
 138         case 3:
 139                 sysclk_div_number = 0;
 140                 break;
 141         case 6:
 142                 sysclk_div_number = 1;
 143                 break;
 144         default:
 145                 printf("unsupported system clock \n");
 146                 return -1;
 147         }
 148         sysclk_sel = readl(CGM_SC_SS(MC_CGM0_BASE_ADDR)) & MC_CGM_SC_SEL_MASK;
 149         sysclk_sel >>= MC_CGM_SC_SEL_OFFSET;
 150
 151         sysclk_div =
 152             readl(CGM_SC_DCn(MC_CGM1_BASE_ADDR, sysclk_div_number)) &
 153             MC_CGM_SC_DCn_PREDIV_MASK;
 154         sysclk_div >>= MC_CGM_SC_DCn_PREDIV_OFFSET;
 155         sysclk_div += 1;
 156
 157         switch (sysclk_sel) {
 158         case MC_CGM_SC_SEL_FIRC:
 159                 freq = FIRC_CLK_FREQ;
 160                 break;
 161         case MC_CGM_SC_SEL_XOSC:
 162                 freq = XOSC_CLK_FREQ;
 163                 break;
 164         case MC_CGM_SC_SEL_ARMPLL:
 165                 /* ARMPLL has as source XOSC and SYSn_CLK has as input DFS1 */
 166                 freq = decode_pll(ARM_PLL, XOSC_CLK_FREQ, 1);
 167                 break;
 168         case MC_CGM_SC_SEL_CLKDISABLE:
 169                 printf("Sysclk is disabled\n");
 170                 break;
 171         default:
 172                 printf("unsupported system clock select\n");
 173         }
 174
 175         return freq / sysclk_div;
 176 }
 177
 178 static u32 get_peripherals_clk(void)
 179 {
 180         u32 aux5clk_div;
 181         u32 freq = 0;
 182
 183         aux5clk_div =
 184             readl(CGM_ACn_DCm(MC_CGM0_BASE_ADDR, 5, 0)) &
 185             MC_CGM_ACn_DCm_PREDIV_MASK;
 186         aux5clk_div >>= MC_CGM_ACn_DCm_PREDIV_OFFSET;
 187         aux5clk_div += 1;
 188
 189         freq = decode_pll(PERIPH_PLL, XOSC_CLK_FREQ, 0);
 190
 191         return freq / aux5clk_div;
 192
 193 }
 194
 195 static u32 get_uart_clk(void)
 196 {
 197         u32 auxclk3_div, auxclk3_sel, freq = 0;
 198
 199         auxclk3_sel =
 200             readl(CGM_ACn_SS(MC_CGM0_BASE_ADDR, 3)) & MC_CGM_ACn_SEL_MASK;
 201         auxclk3_sel >>= MC_CGM_ACn_SEL_OFFSET;
 202
 203         auxclk3_div =
 204             readl(CGM_ACn_DCm(MC_CGM0_BASE_ADDR, 3, 0)) &
 205             MC_CGM_ACn_DCm_PREDIV_MASK;
 206         auxclk3_div >>= MC_CGM_ACn_DCm_PREDIV_OFFSET;
 207         auxclk3_div += 1;
 208
 209         switch (auxclk3_sel) {
 210         case MC_CGM_ACn_SEL_FIRC:
 211                 freq = FIRC_CLK_FREQ;
 212                 break;
 213         case MC_CGM_ACn_SEL_XOSC:
 214                 freq = XOSC_CLK_FREQ;
 215                 break;
 216         case MC_CGM_ACn_SEL_PERPLLDIVX:
 217                 freq = get_peripherals_clk() / 3;
 218                 break;
 219         case MC_CGM_ACn_SEL_SYSCLK:
 220                 freq = get_sys_clk(6);
 221                 break;
 222         default:
 223                 printf("unsupported system clock select\n");
 224         }
 225
 226         return freq / auxclk3_div;
 227 }
 228
 229 static u32 get_fec_clk(void)
 230 {
 231         u32 aux2clk_div;
 232         u32 freq = 0;
 233
 234         aux2clk_div =
 235             readl(CGM_ACn_DCm(MC_CGM0_BASE_ADDR, 2, 0)) &
 236             MC_CGM_ACn_DCm_PREDIV_MASK;
 237         aux2clk_div >>= MC_CGM_ACn_DCm_PREDIV_OFFSET;
 238         aux2clk_div += 1;
 239
 240         freq = decode_pll(ENET_PLL, XOSC_CLK_FREQ, 0);
 241
 242         return freq / aux2clk_div;
 243 }
 244
 245 static u32 get_usdhc_clk(void)
 246 {
 247         u32 aux15clk_div;
 248         u32 freq = 0;
 249
 250         aux15clk_div =
 251             readl(CGM_ACn_DCm(MC_CGM0_BASE_ADDR, 15, 0)) &
 252             MC_CGM_ACn_DCm_PREDIV_MASK;
 253         aux15clk_div >>= MC_CGM_ACn_DCm_PREDIV_OFFSET;
 254         aux15clk_div += 1;
 255
 256         freq = decode_pll(ENET_PLL, XOSC_CLK_FREQ, 4);
 257
 258         return freq / aux15clk_div;
 259 }
 260
 261 static u32 get_i2c_clk(void)
 262 {
 263         return get_peripherals_clk();
 264 }
 265
 266 /* return clocks in Hz */
 267 unsigned int mxc_get_clock(enum mxc_clock clk)
 268 {
 269         switch (clk) {
 270         case MXC_ARM_CLK:
 271                 return get_mcu_main_clk();
 272         case MXC_PERIPHERALS_CLK:
 273                 return get_peripherals_clk();
 274         case MXC_UART_CLK:
 275                 return get_uart_clk();
 276         case MXC_FEC_CLK:
 277                 return get_fec_clk();
 278         case MXC_I2C_CLK:
 279                 return get_i2c_clk();
 280         case MXC_USDHC_CLK:
 281                 return get_usdhc_clk();
 282         default:
 283                 break;
 284         }
 285         printf("Error: Unsupported function to read the frequency! \
 286                         Please define it correctly!");
 287         return -1;
 288 }
 289
 290 /* Not yet implemented - int soc_clk_dump(); */
 291
 292 #if defined(CONFIG_DISPLAY_CPUINFO)
 293 static char *get_reset_cause(void)
 294 {
 295         u32 cause = readl(MC_RGM_BASE_ADDR + 0x300);
 296
 297         switch (cause) {
 298         case F_SWT4:
 299                 return "WDOG";
 300         case F_JTAG:
 301                 return "JTAG";
 302         case F_FCCU_SOFT:
 303                 return "FCCU soft reaction";
 304         case F_FCCU_HARD:
 305                 return "FCCU hard reaction";
 306         case F_SOFT_FUNC:
 307                 return "Software Functional reset";
 308         case F_ST_DONE:
 309                 return "Self Test done reset";
 310         case F_EXT_RST:
 311                 return "External reset";
 312         default:
 313                 return "unknown reset";
 314         }
 315
 316 }
 317
 318 #define SRC_SCR_SW_RST                                  (1<<12)
 319
 320 void reset_cpu(ulong addr)
 321 {
 322         printf("Feature not supported.\n");
 323 };
 324
 325 int print_cpuinfo(void)
 326 {
 327         printf("CPU:   Freescale Treerunner S32V234 at %d MHz\n",
 328                mxc_get_clock(MXC_ARM_CLK) / 1000000);
 329         printf("Reset cause: %s\n", get_reset_cause());
 330
 331         return 0;
 332 }
 333 #endif
 334
 335 int cpu_eth_init(bd_t * bis)
 336 {
 337         int rc = -ENODEV;
 338
 339 #if defined(CONFIG_FEC_MXC)
 340         rc = fecmxc_initialize(bis);
 341 #endif
 342
 343         return rc;
 344 }
 345
 346 int get_clocks(void)
 347 {
 348 #ifdef CONFIG_FSL_ESDHC_IMX
 349         gd->arch.sdhc_clk = mxc_get_clock(MXC_USDHC_CLK);
 350 #endif
 351         return 0;
 352 }