git.sur5r.net Git - u-boot/blob - arch/arm/cpu/arm1136/mx35/generic.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2007
   4  * Sascha Hauer, Pengutronix
   5  *
   6  * (C) Copyright 2008-2010 Freescale Semiconductor, Inc.
   7  */
   8
   9 #include <common.h>
  10 #include <div64.h>
  11 #include <asm/io.h>
  12 #include <linux/errno.h>
  13 #include <asm/arch/imx-regs.h>
  14 #include <asm/arch/crm_regs.h>
  15 #include <asm/arch/clock.h>
  16 #include <asm/arch/sys_proto.h>
  17 #ifdef CONFIG_FSL_ESDHC
  18 #include <fsl_esdhc.h>
  19 #endif
  20 #include <netdev.h>
  21 #include <spl.h>
  22
  23 #define CLK_CODE(arm, ahb, sel) (((arm) << 16) + ((ahb) << 8) + (sel))
  24 #define CLK_CODE_ARM(c)         (((c) >> 16) & 0xFF)
  25 #define CLK_CODE_AHB(c)         (((c) >>  8) & 0xFF)
  26 #define CLK_CODE_PATH(c)        ((c) & 0xFF)
  27
  28 #define CCM_GET_DIVIDER(x, m, o) (((x) & (m)) >> (o))
  29
  30 #ifdef CONFIG_FSL_ESDHC
  31 DECLARE_GLOBAL_DATA_PTR;
  32 #endif
  33
  34 static int g_clk_mux_auto[8] = {
  35         CLK_CODE(1, 3, 0), CLK_CODE(1, 2, 1), CLK_CODE(2, 1, 1), -1,
  36         CLK_CODE(1, 6, 0), CLK_CODE(1, 4, 1), CLK_CODE(2, 2, 1), -1,
  37 };
  38
  39 static int g_clk_mux_consumer[16] = {
  40         CLK_CODE(1, 4, 0), CLK_CODE(1, 3, 1), CLK_CODE(1, 3, 1), -1,
  41         -1, -1, CLK_CODE(4, 1, 0), CLK_CODE(1, 5, 0),
  42         CLK_CODE(1, 8, 1), CLK_CODE(1, 6, 1), CLK_CODE(2, 4, 0), -1,
  43         -1, -1, CLK_CODE(4, 2, 0), -1,
  44 };
  45
  46 static int hsp_div_table[3][16] = {
  47         {4, 3, 2, -1, -1, -1, 1, 5, 4, 3, 2, -1, -1, -1, 1, -1},
  48         {-1, -1, -1, -1, -1, -1, -1, -1, 8, 6, 4, -1, -1, -1, 2, -1},
  49         {3, -1, -1, -1, -1, -1, -1, -1, 3, -1, -1, -1, -1, -1, -1, -1},
  50 };
  51
  52 u32 get_cpu_rev(void)
  53 {
  54         int reg;
  55         struct iim_regs *iim =
  56                 (struct iim_regs *)IIM_BASE_ADDR;
  57         reg = readl(&iim->iim_srev);
  58         if (!reg) {
  59                 reg = readw(ROMPATCH_REV);
  60                 reg <<= 4;
  61         } else {
  62                 reg += CHIP_REV_1_0;
  63         }
  64
  65         return 0x35000 + (reg & 0xFF);
  66 }
  67
  68 static u32 get_arm_div(u32 pdr0, u32 *fi, u32 *fd)
  69 {
  70         int *pclk_mux;
  71         if (pdr0 & MXC_CCM_PDR0_AUTO_CON) {
  72                 pclk_mux = g_clk_mux_consumer +
  73                         ((pdr0 & MXC_CCM_PDR0_CON_MUX_DIV_MASK) >>
  74                         MXC_CCM_PDR0_CON_MUX_DIV_OFFSET);
  75         } else {
  76                 pclk_mux = g_clk_mux_auto +
  77                         ((pdr0 & MXC_CCM_PDR0_AUTO_MUX_DIV_MASK) >>
  78                         MXC_CCM_PDR0_AUTO_MUX_DIV_OFFSET);
  79         }
  80
  81         if ((*pclk_mux) == -1)
  82                 return -1;
  83
  84         if (fi && fd) {
  85                 if (!CLK_CODE_PATH(*pclk_mux)) {
  86                         *fi = *fd = 1;
  87                         return CLK_CODE_ARM(*pclk_mux);
  88                 }
  89                 if (pdr0 & MXC_CCM_PDR0_AUTO_CON) {
  90                         *fi = 3;
  91                         *fd = 4;
  92                 } else {
  93                         *fi = 2;
  94                         *fd = 3;
  95                 }
  96         }
  97         return CLK_CODE_ARM(*pclk_mux);
  98 }
  99
 100 static int get_ahb_div(u32 pdr0)
 101 {
 102         int *pclk_mux;
 103
 104         pclk_mux = g_clk_mux_consumer +
 105                 ((pdr0 & MXC_CCM_PDR0_CON_MUX_DIV_MASK) >>
 106                 MXC_CCM_PDR0_CON_MUX_DIV_OFFSET);
 107
 108         if ((*pclk_mux) == -1)
 109                 return -1;
 110
 111         return CLK_CODE_AHB(*pclk_mux);
 112 }
 113
 114 static u32 decode_pll(u32 reg, u32 infreq)
 115 {
 116         u32 mfi = (reg >> 10) & 0xf;
 117         s32 mfn = reg & 0x3ff;
 118         u32 mfd = (reg >> 16) & 0x3ff;
 119         u32 pd = (reg >> 26) & 0xf;
 120
 121         mfi = mfi <= 5 ? 5 : mfi;
 122         mfn = mfn >= 512 ? mfn - 1024 : mfn;
 123         mfd += 1;
 124         pd += 1;
 125
 126         return lldiv(2 * (u64)infreq * (mfi * mfd + mfn),
 127                 mfd * pd);
 128 }
 129
 130 static u32 get_mcu_main_clk(void)
 131 {
 132         u32 arm_div = 0, fi = 0, fd = 0;
 133         struct ccm_regs *ccm =
 134                 (struct ccm_regs *)IMX_CCM_BASE;
 135         arm_div = get_arm_div(readl(&ccm->pdr0), &fi, &fd);
 136         fi *= decode_pll(readl(&ccm->mpctl), MXC_HCLK);
 137         return fi / (arm_div * fd);
 138 }
 139
 140 static u32 get_ipg_clk(void)
 141 {
 142         u32 freq = get_mcu_main_clk();
 143         struct ccm_regs *ccm =
 144                 (struct ccm_regs *)IMX_CCM_BASE;
 145         u32 pdr0 = readl(&ccm->pdr0);
 146
 147         return freq / (get_ahb_div(pdr0) * 2);
 148 }
 149
 150 static u32 get_ipg_per_clk(void)
 151 {
 152         u32 freq = get_mcu_main_clk();
 153         struct ccm_regs *ccm =
 154                 (struct ccm_regs *)IMX_CCM_BASE;
 155         u32 pdr0 = readl(&ccm->pdr0);
 156         u32 pdr4 = readl(&ccm->pdr4);
 157         u32 div;
 158         if (pdr0 & MXC_CCM_PDR0_PER_SEL) {
 159                 div = CCM_GET_DIVIDER(pdr4,
 160                         MXC_CCM_PDR4_PER0_PODF_MASK,
 161                         MXC_CCM_PDR4_PER0_PODF_OFFSET) + 1;
 162         } else {
 163                 div = CCM_GET_DIVIDER(pdr0,
 164                         MXC_CCM_PDR0_PER_PODF_MASK,
 165                         MXC_CCM_PDR0_PER_PODF_OFFSET) + 1;
 166                 div *= get_ahb_div(pdr0);
 167         }
 168         return freq / div;
 169 }
 170
 171 u32 imx_get_uartclk(void)
 172 {
 173         u32 freq;
 174         struct ccm_regs *ccm =
 175                 (struct ccm_regs *)IMX_CCM_BASE;
 176         u32 pdr4 = readl(&ccm->pdr4);
 177
 178         if (readl(&ccm->pdr3) & MXC_CCM_PDR3_UART_M_U)
 179                 freq = get_mcu_main_clk();
 180         else
 181                 freq = decode_pll(readl(&ccm->ppctl), MXC_HCLK);
 182         freq /= CCM_GET_DIVIDER(pdr4,
 183                         MXC_CCM_PDR4_UART_PODF_MASK,
 184                         MXC_CCM_PDR4_UART_PODF_OFFSET) + 1;
 185         return freq;
 186 }
 187
 188 unsigned int mxc_get_main_clock(enum mxc_main_clock clk)
 189 {
 190         u32 nfc_pdf, hsp_podf;
 191         u32 pll, ret_val = 0, usb_podf;
 192         struct ccm_regs *ccm =
 193                 (struct ccm_regs *)IMX_CCM_BASE;
 194
 195         u32 reg = readl(&ccm->pdr0);
 196         u32 reg4 = readl(&ccm->pdr4);
 197
 198         reg |= 0x1;
 199
 200         switch (clk) {
 201         case CPU_CLK:
 202                 ret_val = get_mcu_main_clk();
 203                 break;
 204         case AHB_CLK:
 205                 ret_val = get_mcu_main_clk();
 206                 break;
 207         case HSP_CLK:
 208                 if (reg & CLKMODE_CONSUMER) {
 209                         hsp_podf = (reg >> 20) & 0x3;
 210                         pll = get_mcu_main_clk();
 211                         hsp_podf = hsp_div_table[hsp_podf][(reg>>16)&0xF];
 212                         if (hsp_podf > 0) {
 213                                 ret_val = pll / hsp_podf;
 214                         } else {
 215                                 puts("mismatch HSP with ARM clock setting\n");
 216                                 ret_val = 0;
 217                         }
 218                 } else {
 219                         ret_val = get_mcu_main_clk();
 220                 }
 221                 break;
 222         case IPG_CLK:
 223                 ret_val = get_ipg_clk();
 224                 break;
 225         case IPG_PER_CLK:
 226                 ret_val = get_ipg_per_clk();
 227                 break;
 228         case NFC_CLK:
 229                 nfc_pdf = (reg4 >> 28) & 0xF;
 230                 pll = get_mcu_main_clk();
 231                 /* AHB/nfc_pdf */
 232                 ret_val = pll / (nfc_pdf + 1);
 233                 break;
 234         case USB_CLK:
 235                 usb_podf = (reg4 >> 22) & 0x3F;
 236                 if (reg4 & 0x200)
 237                         pll = get_mcu_main_clk();
 238                 else
 239                         pll = decode_pll(readl(&ccm->ppctl), MXC_HCLK);
 240
 241                 ret_val = pll / (usb_podf + 1);
 242                 break;
 243         default:
 244                 printf("Unknown clock: %d\n", clk);
 245                 break;
 246         }
 247
 248         return ret_val;
 249 }
 250 unsigned int mxc_get_peri_clock(enum mxc_peri_clock clk)
 251 {
 252         u32 ret_val = 0, pdf, pre_pdf, clk_sel;
 253         struct ccm_regs *ccm =
 254                 (struct ccm_regs *)IMX_CCM_BASE;
 255         u32 mpdr2 = readl(&ccm->pdr2);
 256         u32 mpdr3 = readl(&ccm->pdr3);
 257         u32 mpdr4 = readl(&ccm->pdr4);
 258
 259         switch (clk) {
 260         case UART1_BAUD:
 261         case UART2_BAUD:
 262         case UART3_BAUD:
 263                 clk_sel = mpdr3 & (1 << 14);
 264                 pdf = (mpdr4 >> 10) & 0x3F;
 265                 ret_val = ((clk_sel != 0) ? mxc_get_main_clock(CPU_CLK) :
 266                         decode_pll(readl(&ccm->ppctl), MXC_HCLK)) / (pdf + 1);
 267                 break;
 268         case SSI1_BAUD:
 269                 pre_pdf = (mpdr2 >> 24) & 0x7;
 270                 pdf = mpdr2 & 0x3F;
 271                 clk_sel = mpdr2 & (1 << 6);
 272                 ret_val = ((clk_sel != 0) ? mxc_get_main_clock(CPU_CLK) :
 273                         decode_pll(readl(&ccm->ppctl), MXC_HCLK)) /
 274                                 ((pre_pdf + 1) * (pdf + 1));
 275                 break;
 276         case SSI2_BAUD:
 277                 pre_pdf = (mpdr2 >> 27) & 0x7;
 278                 pdf = (mpdr2 >> 8) & 0x3F;
 279                 clk_sel = mpdr2 & (1 << 6);
 280                 ret_val = ((clk_sel != 0) ? mxc_get_main_clock(CPU_CLK) :
 281                         decode_pll(readl(&ccm->ppctl), MXC_HCLK)) /
 282                                 ((pre_pdf + 1) * (pdf + 1));
 283                 break;
 284         case CSI_BAUD:
 285                 clk_sel = mpdr2 & (1 << 7);
 286                 pdf = (mpdr2 >> 16) & 0x3F;
 287                 ret_val = ((clk_sel != 0) ? mxc_get_main_clock(CPU_CLK) :
 288                         decode_pll(readl(&ccm->ppctl), MXC_HCLK)) / (pdf + 1);
 289                 break;
 290         case MSHC_CLK:
 291                 pre_pdf = readl(&ccm->pdr1);
 292                 clk_sel = (pre_pdf & 0x80);
 293                 pdf = (pre_pdf >> 22) & 0x3F;
 294                 pre_pdf = (pre_pdf >> 28) & 0x7;
 295                 ret_val = ((clk_sel != 0) ? mxc_get_main_clock(CPU_CLK) :
 296                         decode_pll(readl(&ccm->ppctl), MXC_HCLK)) /
 297                                 ((pre_pdf + 1) * (pdf + 1));
 298                 break;
 299         case ESDHC1_CLK:
 300                 clk_sel = mpdr3 & 0x40;
 301                 pdf = mpdr3 & 0x3F;
 302                 ret_val = ((clk_sel != 0) ? mxc_get_main_clock(CPU_CLK) :
 303                         decode_pll(readl(&ccm->ppctl), MXC_HCLK)) / (pdf + 1);
 304                 break;
 305         case ESDHC2_CLK:
 306                 clk_sel = mpdr3 & 0x40;
 307                 pdf = (mpdr3 >> 8) & 0x3F;
 308                 ret_val = ((clk_sel != 0) ? mxc_get_main_clock(CPU_CLK) :
 309                         decode_pll(readl(&ccm->ppctl), MXC_HCLK)) / (pdf + 1);
 310                 break;
 311         case ESDHC3_CLK:
 312                 clk_sel = mpdr3 & 0x40;
 313                 pdf = (mpdr3 >> 16) & 0x3F;
 314                 ret_val = ((clk_sel != 0) ? mxc_get_main_clock(CPU_CLK) :
 315                         decode_pll(readl(&ccm->ppctl), MXC_HCLK)) / (pdf + 1);
 316                 break;
 317         case SPDIF_CLK:
 318                 clk_sel = mpdr3 & 0x400000;
 319                 pre_pdf = (mpdr3 >> 29) & 0x7;
 320                 pdf = (mpdr3 >> 23) & 0x3F;
 321                 ret_val = ((clk_sel != 0) ? mxc_get_main_clock(CPU_CLK) :
 322                         decode_pll(readl(&ccm->ppctl), MXC_HCLK)) /
 323                                 ((pre_pdf + 1) * (pdf + 1));
 324                 break;
 325         default:
 326                 printf("%s(): This clock: %d not supported yet\n",
 327                                 __func__, clk);
 328                 break;
 329         }
 330
 331         return ret_val;
 332 }
 333
 334 unsigned int mxc_get_clock(enum mxc_clock clk)
 335 {
 336         switch (clk) {
 337         case MXC_ARM_CLK:
 338                 return get_mcu_main_clk();
 339         case MXC_AHB_CLK:
 340                 break;
 341         case MXC_IPG_CLK:
 342                 return get_ipg_clk();
 343         case MXC_IPG_PERCLK:
 344         case MXC_I2C_CLK:
 345                 return get_ipg_per_clk();
 346         case MXC_UART_CLK:
 347                 return imx_get_uartclk();
 348         case MXC_ESDHC1_CLK:
 349                 return mxc_get_peri_clock(ESDHC1_CLK);
 350         case MXC_ESDHC2_CLK:
 351                 return mxc_get_peri_clock(ESDHC2_CLK);
 352         case MXC_ESDHC3_CLK:
 353                 return mxc_get_peri_clock(ESDHC3_CLK);
 354         case MXC_USB_CLK:
 355                 return mxc_get_main_clock(USB_CLK);
 356         case MXC_FEC_CLK:
 357                 return get_ipg_clk();
 358         case MXC_CSPI_CLK:
 359                 return get_ipg_clk();
 360         }
 361         return -1;
 362 }
 363
 364 #ifdef CONFIG_FEC_MXC
 365 /*
 366  * The MX35 has no fuse for MAC, return a NULL MAC
 367  */
 368 void imx_get_mac_from_fuse(int dev_id, unsigned char *mac)
 369 {
 370         memset(mac, 0, 6);
 371 }
 372
 373 u32 imx_get_fecclk(void)
 374 {
 375         return mxc_get_clock(MXC_IPG_CLK);
 376 }
 377 #endif
 378
 379 int do_mx35_showclocks(cmd_tbl_t *cmdtp,
 380         int flag, int argc, char * const argv[])
 381 {
 382         u32 cpufreq = get_mcu_main_clk();
 383         printf("mx35 cpu clock: %dMHz\n", cpufreq / 1000000);
 384         printf("ipg clock     : %dHz\n", get_ipg_clk());
 385         printf("ipg per clock : %dHz\n", get_ipg_per_clk());
 386         printf("uart clock    : %dHz\n", mxc_get_clock(MXC_UART_CLK));
 387
 388         return 0;
 389 }
 390
 391 U_BOOT_CMD(
 392         clocks, CONFIG_SYS_MAXARGS, 1, do_mx35_showclocks,
 393         "display clocks",
 394         ""
 395 );
 396
 397 #if defined(CONFIG_DISPLAY_CPUINFO)
 398 static char *get_reset_cause(void)
 399 {
 400         /* read RCSR register from CCM module */
 401         struct ccm_regs *ccm =
 402                 (struct ccm_regs *)IMX_CCM_BASE;
 403
 404         u32 cause = readl(&ccm->rcsr) & 0x0F;
 405
 406         switch (cause) {
 407         case 0x0000:
 408                 return "POR";
 409         case 0x0002:
 410                 return "JTAG";
 411         case 0x0004:
 412                 return "RST";
 413         case 0x0008:
 414                 return "WDOG";
 415         default:
 416                 return "unknown reset";
 417         }
 418 }
 419
 420 int print_cpuinfo(void)
 421 {
 422         u32 srev = get_cpu_rev();
 423
 424         printf("CPU:   Freescale i.MX35 rev %d.%d at %d MHz.\n",
 425                 (srev & 0xF0) >> 4, (srev & 0x0F),
 426                 get_mcu_main_clk() / 1000000);
 427
 428         printf("Reset cause: %s\n", get_reset_cause());
 429
 430         return 0;
 431 }
 432 #endif
 433
 434 /*
 435  * Initializes on-chip ethernet controllers.
 436  * to override, implement board_eth_init()
 437  */
 438 int cpu_eth_init(bd_t *bis)
 439 {
 440         int rc = -ENODEV;
 441
 442 #if defined(CONFIG_FEC_MXC)
 443         rc = fecmxc_initialize(bis);
 444 #endif
 445
 446         return rc;
 447 }
 448
 449 #ifdef CONFIG_FSL_ESDHC
 450 /*
 451  * Initializes on-chip MMC controllers.
 452  * to override, implement board_mmc_init()
 453  */
 454 int cpu_mmc_init(bd_t *bis)
 455 {
 456         return fsl_esdhc_mmc_init(bis);
 457 }
 458 #endif
 459
 460 int get_clocks(void)
 461 {
 462 #ifdef CONFIG_FSL_ESDHC
 463 #if CONFIG_SYS_FSL_ESDHC_ADDR == MMC_SDHC2_BASE_ADDR
 464         gd->arch.sdhc_clk = mxc_get_clock(MXC_ESDHC2_CLK);
 465 #elif CONFIG_SYS_FSL_ESDHC_ADDR == MMC_SDHC3_BASE_ADDR
 466         gd->arch.sdhc_clk = mxc_get_clock(MXC_ESDHC3_CLK);
 467 #else
 468         gd->arch.sdhc_clk = mxc_get_clock(MXC_ESDHC1_CLK);
 469 #endif
 470 #endif
 471         return 0;
 472 }
 473
 474 #define RCSR_MEM_CTL_WEIM       0
 475 #define RCSR_MEM_CTL_NAND       1
 476 #define RCSR_MEM_CTL_ATA        2
 477 #define RCSR_MEM_CTL_EXPANSION  3
 478 #define RCSR_MEM_TYPE_NOR       0
 479 #define RCSR_MEM_TYPE_ONENAND   2
 480 #define RCSR_MEM_TYPE_SD        0
 481 #define RCSR_MEM_TYPE_I2C       2
 482 #define RCSR_MEM_TYPE_SPI       3
 483
 484 u32 spl_boot_device(void)
 485 {
 486         struct ccm_regs *ccm =
 487                 (struct ccm_regs *)IMX_CCM_BASE;
 488
 489         u32 rcsr = readl(&ccm->rcsr);
 490         u32 mem_type, mem_ctl;
 491
 492         /* In external mode, no boot device is returned */
 493         if ((rcsr >> 10) & 0x03)
 494                 return BOOT_DEVICE_NONE;
 495
 496         mem_ctl = (rcsr >> 25) & 0x03;
 497         mem_type = (rcsr >> 23) & 0x03;
 498
 499         switch (mem_ctl) {
 500         case RCSR_MEM_CTL_WEIM:
 501                 switch (mem_type) {
 502                 case RCSR_MEM_TYPE_NOR:
 503                         return BOOT_DEVICE_NOR;
 504                 case RCSR_MEM_TYPE_ONENAND:
 505                         return BOOT_DEVICE_ONENAND;
 506                 default:
 507                         return BOOT_DEVICE_NONE;
 508                 }
 509         case RCSR_MEM_CTL_NAND:
 510                 return BOOT_DEVICE_NAND;
 511         case RCSR_MEM_CTL_EXPANSION:
 512                 switch (mem_type) {
 513                 case RCSR_MEM_TYPE_SD:
 514                         return BOOT_DEVICE_MMC1;
 515                 case RCSR_MEM_TYPE_I2C:
 516                         return BOOT_DEVICE_I2C;
 517                 case RCSR_MEM_TYPE_SPI:
 518                         return BOOT_DEVICE_SPI;
 519                 default:
 520                         return BOOT_DEVICE_NONE;
 521                 }
 522         }
 523
 524         return BOOT_DEVICE_NONE;
 525 }