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