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