arch/arm/cpu/armv7/mx5/clock.c

   1 /*
   2  * (C) Copyright 2007
   3  * Sascha Hauer, Pengutronix
   4  *
   5  * (C) Copyright 2009 Freescale Semiconductor, Inc.
   6  *
   7  * SPDX-License-Identifier:     GPL-2.0+
   8  */
   9
  10 #include <common.h>
  11 #include <asm/io.h>
  12 #include <asm/errno.h>
  13 #include <asm/arch/imx-regs.h>
  14 #include <asm/arch/crm_regs.h>
  15 #include <asm/arch/clock.h>
  16 #include <div64.h>
  17 #include <asm/arch/sys_proto.h>
  18
  19 enum pll_clocks {
  20         PLL1_CLOCK = 0,
  21         PLL2_CLOCK,
  22         PLL3_CLOCK,
  23 #ifdef CONFIG_MX53
  24         PLL4_CLOCK,
  25 #endif
  26         PLL_CLOCKS,
  27 };
  28
  29 struct mxc_pll_reg *mxc_plls[PLL_CLOCKS] = {
  30         [PLL1_CLOCK] = (struct mxc_pll_reg *)PLL1_BASE_ADDR,
  31         [PLL2_CLOCK] = (struct mxc_pll_reg *)PLL2_BASE_ADDR,
  32         [PLL3_CLOCK] = (struct mxc_pll_reg *)PLL3_BASE_ADDR,
  33 #ifdef  CONFIG_MX53
  34         [PLL4_CLOCK] = (struct mxc_pll_reg *)PLL4_BASE_ADDR,
  35 #endif
  36 };
  37
  38 #define AHB_CLK_ROOT    133333333
  39 #define SZ_DEC_1M       1000000
  40 #define PLL_PD_MAX      16      /* Actual pd+1 */
  41 #define PLL_MFI_MAX     15
  42 #define PLL_MFI_MIN     5
  43 #define ARM_DIV_MAX     8
  44 #define IPG_DIV_MAX     4
  45 #define AHB_DIV_MAX     8
  46 #define EMI_DIV_MAX     8
  47 #define NFC_DIV_MAX     8
  48
  49 struct fixed_pll_mfd {
  50         u32 ref_clk_hz;
  51         u32 mfd;
  52 };
  53
  54 const struct fixed_pll_mfd fixed_mfd[] = {
  55         {MXC_HCLK, 24 * 16},
  56 };
  57
  58 struct pll_param {
  59         u32 pd;
  60         u32 mfi;
  61         u32 mfn;
  62         u32 mfd;
  63 };
  64
  65 #define PLL_FREQ_MAX(ref_clk)  (4 * (ref_clk) * PLL_MFI_MAX)
  66 #define PLL_FREQ_MIN(ref_clk) \
  67                 ((2 * (ref_clk) * (PLL_MFI_MIN - 1)) / PLL_PD_MAX)
  68 #define MAX_DDR_CLK     420000000
  69 #define NFC_CLK_MAX     34000000
  70
  71 struct mxc_ccm_reg *mxc_ccm = (struct mxc_ccm_reg *)MXC_CCM_BASE;
  72
  73 int clk_enable(struct clk *clk)
  74 {
  75         int ret = 0;
  76
  77         if (!clk)
  78                 return 0;
  79         if (clk->usecount++ == 0) {
  80                 ret = clk->enable(clk);
  81                 if (ret)
  82                         clk->usecount--;
  83         }
  84         return ret;
  85 }
  86
  87 void clk_disable(struct clk *clk)
  88 {
  89         if (!clk)
  90                 return;
  91
  92         if (!(--clk->usecount)) {
  93                 if (clk->disable)
  94                         clk->disable(clk);
  95         }
  96         if (clk->usecount < 0) {
  97                 printf("%s: clk %p underflow\n", __func__, clk);
  98                 hang();
  99         }
 100 }
 101
 102 int clk_get_usecount(struct clk *clk)
 103 {
 104         if (clk == NULL)
 105                 return 0;
 106
 107         return clk->usecount;
 108 }
 109
 110 u32 clk_get_rate(struct clk *clk)
 111 {
 112         if (!clk)
 113                 return 0;
 114
 115         return clk->rate;
 116 }
 117
 118 struct clk *clk_get_parent(struct clk *clk)
 119 {
 120         if (!clk)
 121                 return 0;
 122
 123         return clk->parent;
 124 }
 125
 126 int clk_set_rate(struct clk *clk, unsigned long rate)
 127 {
 128         if (clk && clk->set_rate)
 129                 clk->set_rate(clk, rate);
 130         return clk->rate;
 131 }
 132
 133 long clk_round_rate(struct clk *clk, unsigned long rate)
 134 {
 135         if (clk == NULL || !clk->round_rate)
 136                 return 0;
 137
 138         return clk->round_rate(clk, rate);
 139 }
 140
 141 int clk_set_parent(struct clk *clk, struct clk *parent)
 142 {
 143         debug("Setting parent of clk %p to %p (%p)\n", clk, parent,
 144                 clk ? clk->parent : NULL);
 145
 146         if (!clk || clk == parent)
 147                 return 0;
 148
 149         if (clk->set_parent) {
 150                 int ret;
 151
 152                 ret = clk->set_parent(clk, parent);
 153                 if (ret)
 154                         return ret;
 155         }
 156         clk->parent = parent;
 157         return 0;
 158 }
 159
 160 void set_usboh3_clk(void)
 161 {
 162         clrsetbits_le32(&mxc_ccm->cscmr1,
 163                         MXC_CCM_CSCMR1_USBOH3_CLK_SEL_MASK,
 164                         MXC_CCM_CSCMR1_USBOH3_CLK_SEL(1));
 165         clrsetbits_le32(&mxc_ccm->cscdr1,
 166                         MXC_CCM_CSCDR1_USBOH3_CLK_PODF_MASK |
 167                         MXC_CCM_CSCDR1_USBOH3_CLK_PRED_MASK,
 168                         MXC_CCM_CSCDR1_USBOH3_CLK_PRED(4) |
 169                         MXC_CCM_CSCDR1_USBOH3_CLK_PODF(1));
 170 }
 171
 172 void enable_usboh3_clk(unsigned char enable)
 173 {
 174         unsigned int cg = enable ? MXC_CCM_CCGR_CG_ON : MXC_CCM_CCGR_CG_OFF;
 175
 176         clrsetbits_le32(&mxc_ccm->CCGR2,
 177                         MXC_CCM_CCGR2_USBOH3_60M(MXC_CCM_CCGR_CG_MASK),
 178                         MXC_CCM_CCGR2_USBOH3_60M(cg));
 179 }
 180
 181 void ipu_clk_enable(void)
 182 {
 183         /* IPU root clock derived from AXI B */
 184         clrsetbits_le32(&mxc_ccm->cbcmr, MXC_CCM_CBCMR_IPU_HSP_CLK_SEL_MASK,
 185                         MXC_CCM_CBCMR_IPU_HSP_CLK_SEL(1));
 186
 187         setbits_le32(&mxc_ccm->CCGR5,
 188                 MXC_CCM_CCGR5_IPU(MXC_CCM_CCGR_CG_MASK));
 189
 190         /* Handshake with IPU when certain clock rates are changed. */
 191         clrbits_le32(&mxc_ccm->ccdr, MXC_CCM_CCDR_IPU_HS_MASK);
 192
 193         /* Handshake with IPU when LPM is entered as its enabled. */
 194         clrbits_le32(&mxc_ccm->clpcr, MXC_CCM_CLPCR_BYPASS_IPU_LPM_HS);
 195 }
 196
 197 void ipu_clk_disable(void)
 198 {
 199         clrbits_le32(&mxc_ccm->CCGR5,
 200                 MXC_CCM_CCGR5_IPU(MXC_CCM_CCGR_CG_MASK));
 201
 202         /* Handshake with IPU when certain clock rates are changed. */
 203         setbits_le32(&mxc_ccm->ccdr, MXC_CCM_CCDR_IPU_HS_MASK);
 204
 205         /* Handshake with IPU when LPM is entered as its enabled. */
 206         setbits_le32(&mxc_ccm->clpcr, MXC_CCM_CLPCR_BYPASS_IPU_LPM_HS);
 207 }
 208
 209 #ifdef CONFIG_I2C_MXC
 210 /* i2c_num can be from 0, to 1 for i.MX51 and 2 for i.MX53 */
 211 int enable_i2c_clk(unsigned char enable, unsigned i2c_num)
 212 {
 213         u32 mask;
 214
 215 #if defined(CONFIG_MX51)
 216         if (i2c_num > 1)
 217 #elif defined(CONFIG_MX53)
 218         if (i2c_num > 2)
 219 #endif
 220                 return -EINVAL;
 221         mask = MXC_CCM_CCGR_CG_MASK <<
 222                         (MXC_CCM_CCGR1_I2C1_OFFSET + (i2c_num << 1));
 223         if (enable)
 224                 setbits_le32(&mxc_ccm->CCGR1, mask);
 225         else
 226                 clrbits_le32(&mxc_ccm->CCGR1, mask);
 227         return 0;
 228 }
 229 #endif
 230
 231 void set_usb_phy_clk(void)
 232 {
 233         clrbits_le32(&mxc_ccm->cscmr1, MXC_CCM_CSCMR1_USB_PHY_CLK_SEL);
 234 }
 235
 236 #if defined(CONFIG_MX51)
 237 void enable_usb_phy1_clk(unsigned char enable)
 238 {
 239         unsigned int cg = enable ? MXC_CCM_CCGR_CG_ON : MXC_CCM_CCGR_CG_OFF;
 240
 241         clrsetbits_le32(&mxc_ccm->CCGR2,
 242                         MXC_CCM_CCGR2_USB_PHY(MXC_CCM_CCGR_CG_MASK),
 243                         MXC_CCM_CCGR2_USB_PHY(cg));
 244 }
 245
 246 void enable_usb_phy2_clk(unsigned char enable)
 247 {
 248         /* i.MX51 has a single USB PHY clock, so do nothing here. */
 249 }
 250 #elif defined(CONFIG_MX53)
 251 void enable_usb_phy1_clk(unsigned char enable)
 252 {
 253         unsigned int cg = enable ? MXC_CCM_CCGR_CG_ON : MXC_CCM_CCGR_CG_OFF;
 254
 255         clrsetbits_le32(&mxc_ccm->CCGR4,
 256                         MXC_CCM_CCGR4_USB_PHY1(MXC_CCM_CCGR_CG_MASK),
 257                         MXC_CCM_CCGR4_USB_PHY1(cg));
 258 }
 259
 260 void enable_usb_phy2_clk(unsigned char enable)
 261 {
 262         unsigned int cg = enable ? MXC_CCM_CCGR_CG_ON : MXC_CCM_CCGR_CG_OFF;
 263
 264         clrsetbits_le32(&mxc_ccm->CCGR4,
 265                         MXC_CCM_CCGR4_USB_PHY2(MXC_CCM_CCGR_CG_MASK),
 266                         MXC_CCM_CCGR4_USB_PHY2(cg));
 267 }
 268 #endif
 269
 270 /*
 271  * Calculate the frequency of PLLn.
 272  */
 273 static uint32_t decode_pll(struct mxc_pll_reg *pll, uint32_t infreq)
 274 {
 275         uint32_t ctrl, op, mfd, mfn, mfi, pdf, ret;
 276         uint64_t refclk, temp;
 277         int32_t mfn_abs;
 278
 279         ctrl = readl(&pll->ctrl);
 280
 281         if (ctrl & MXC_DPLLC_CTL_HFSM) {
 282                 mfn = readl(&pll->hfs_mfn);
 283                 mfd = readl(&pll->hfs_mfd);
 284                 op = readl(&pll->hfs_op);
 285         } else {
 286                 mfn = readl(&pll->mfn);
 287                 mfd = readl(&pll->mfd);
 288                 op = readl(&pll->op);
 289         }
 290
 291         mfd &= MXC_DPLLC_MFD_MFD_MASK;
 292         mfn &= MXC_DPLLC_MFN_MFN_MASK;
 293         pdf = op & MXC_DPLLC_OP_PDF_MASK;
 294         mfi = MXC_DPLLC_OP_MFI_RD(op);
 295
 296         /* 21.2.3 */
 297         if (mfi < 5)
 298                 mfi = 5;
 299
 300         /* Sign extend */
 301         if (mfn >= 0x04000000) {
 302                 mfn |= 0xfc000000;
 303                 mfn_abs = -mfn;
 304         } else
 305                 mfn_abs = mfn;
 306
 307         refclk = infreq * 2;
 308         if (ctrl & MXC_DPLLC_CTL_DPDCK0_2_EN)
 309                 refclk *= 2;
 310
 311         do_div(refclk, pdf + 1);
 312         temp = refclk * mfn_abs;
 313         do_div(temp, mfd + 1);
 314         ret = refclk * mfi;
 315
 316         if ((int)mfn < 0)
 317                 ret -= temp;
 318         else
 319                 ret += temp;
 320
 321         return ret;
 322 }
 323
 324 #ifdef CONFIG_MX51
 325 /*
 326  * This function returns the Frequency Pre-Multiplier clock.
 327  */
 328 static u32 get_fpm(void)
 329 {
 330         u32 mult;
 331         u32 ccr = readl(&mxc_ccm->ccr);
 332
 333         if (ccr & MXC_CCM_CCR_FPM_MULT)
 334                 mult = 1024;
 335         else
 336                 mult = 512;
 337
 338         return MXC_CLK32 * mult;
 339 }
 340 #endif
 341
 342 /*
 343  * This function returns the low power audio clock.
 344  */
 345 static u32 get_lp_apm(void)
 346 {
 347         u32 ret_val = 0;
 348         u32 ccsr = readl(&mxc_ccm->ccsr);
 349
 350         if (ccsr & MXC_CCM_CCSR_LP_APM)
 351 #if defined(CONFIG_MX51)
 352                 ret_val = get_fpm();
 353 #elif defined(CONFIG_MX53)
 354                 ret_val = decode_pll(mxc_plls[PLL4_CLOCK], MXC_HCLK);
 355 #endif
 356         else
 357                 ret_val = MXC_HCLK;
 358
 359         return ret_val;
 360 }
 361
 362 /*
 363  * Get mcu main rate
 364  */
 365 u32 get_mcu_main_clk(void)
 366 {
 367         u32 reg, freq;
 368
 369         reg = MXC_CCM_CACRR_ARM_PODF_RD(readl(&mxc_ccm->cacrr));
 370         freq = decode_pll(mxc_plls[PLL1_CLOCK], MXC_HCLK);
 371         return freq / (reg + 1);
 372 }
 373
 374 /*
 375  * Get the rate of peripheral's root clock.
 376  */
 377 u32 get_periph_clk(void)
 378 {
 379         u32 reg;
 380
 381         reg = readl(&mxc_ccm->cbcdr);
 382         if (!(reg & MXC_CCM_CBCDR_PERIPH_CLK_SEL))
 383                 return decode_pll(mxc_plls[PLL2_CLOCK], MXC_HCLK);
 384         reg = readl(&mxc_ccm->cbcmr);
 385         switch (MXC_CCM_CBCMR_PERIPH_CLK_SEL_RD(reg)) {
 386         case 0:
 387                 return decode_pll(mxc_plls[PLL1_CLOCK], MXC_HCLK);
 388         case 1:
 389                 return decode_pll(mxc_plls[PLL3_CLOCK], MXC_HCLK);
 390         case 2:
 391                 return get_lp_apm();
 392         default:
 393                 return 0;
 394         }
 395         /* NOTREACHED */
 396 }
 397
 398 /*
 399  * Get the rate of ipg clock.
 400  */
 401 static u32 get_ipg_clk(void)
 402 {
 403         uint32_t freq, reg, div;
 404
 405         freq = get_ahb_clk();
 406
 407         reg = readl(&mxc_ccm->cbcdr);
 408         div = MXC_CCM_CBCDR_IPG_PODF_RD(reg) + 1;
 409
 410         return freq / div;
 411 }
 412
 413 /*
 414  * Get the rate of ipg_per clock.
 415  */
 416 static u32 get_ipg_per_clk(void)
 417 {
 418         u32 freq, pred1, pred2, podf;
 419
 420         if (readl(&mxc_ccm->cbcmr) & MXC_CCM_CBCMR_PERCLK_IPG_CLK_SEL)
 421                 return get_ipg_clk();
 422
 423         if (readl(&mxc_ccm->cbcmr) & MXC_CCM_CBCMR_PERCLK_LP_APM_CLK_SEL)
 424                 freq = get_lp_apm();
 425         else
 426                 freq = get_periph_clk();
 427         podf = readl(&mxc_ccm->cbcdr);
 428         pred1 = MXC_CCM_CBCDR_PERCLK_PRED1_RD(podf);
 429         pred2 = MXC_CCM_CBCDR_PERCLK_PRED2_RD(podf);
 430         podf = MXC_CCM_CBCDR_PERCLK_PODF_RD(podf);
 431         return freq / ((pred1 + 1) * (pred2 + 1) * (podf + 1));
 432 }
 433
 434 /* Get the output clock rate of a standard PLL MUX for peripherals. */
 435 static u32 get_standard_pll_sel_clk(u32 clk_sel)
 436 {
 437         u32 freq = 0;
 438
 439         switch (clk_sel & 0x3) {
 440         case 0:
 441                 freq = decode_pll(mxc_plls[PLL1_CLOCK], MXC_HCLK);
 442                 break;
 443         case 1:
 444                 freq = decode_pll(mxc_plls[PLL2_CLOCK], MXC_HCLK);
 445                 break;
 446         case 2:
 447                 freq = decode_pll(mxc_plls[PLL3_CLOCK], MXC_HCLK);
 448                 break;
 449         case 3:
 450                 freq = get_lp_apm();
 451                 break;
 452         }
 453
 454         return freq;
 455 }
 456
 457 /*
 458  * Get the rate of uart clk.
 459  */
 460 static u32 get_uart_clk(void)
 461 {
 462         unsigned int clk_sel, freq, reg, pred, podf;
 463
 464         reg = readl(&mxc_ccm->cscmr1);
 465         clk_sel = MXC_CCM_CSCMR1_UART_CLK_SEL_RD(reg);
 466         freq = get_standard_pll_sel_clk(clk_sel);
 467
 468         reg = readl(&mxc_ccm->cscdr1);
 469         pred = MXC_CCM_CSCDR1_UART_CLK_PRED_RD(reg);
 470         podf = MXC_CCM_CSCDR1_UART_CLK_PODF_RD(reg);
 471         freq /= (pred + 1) * (podf + 1);
 472
 473         return freq;
 474 }
 475
 476 /*
 477  * get cspi clock rate.
 478  */
 479 static u32 imx_get_cspiclk(void)
 480 {
 481         u32 ret_val = 0, pdf, pre_pdf, clk_sel, freq;
 482         u32 cscmr1 = readl(&mxc_ccm->cscmr1);
 483         u32 cscdr2 = readl(&mxc_ccm->cscdr2);
 484
 485         pre_pdf = MXC_CCM_CSCDR2_CSPI_CLK_PRED_RD(cscdr2);
 486         pdf = MXC_CCM_CSCDR2_CSPI_CLK_PODF_RD(cscdr2);
 487         clk_sel = MXC_CCM_CSCMR1_CSPI_CLK_SEL_RD(cscmr1);
 488         freq = get_standard_pll_sel_clk(clk_sel);
 489         ret_val = freq / ((pre_pdf + 1) * (pdf + 1));
 490         return ret_val;
 491 }
 492
 493 /*
 494  * get esdhc clock rate.
 495  */
 496 static u32 get_esdhc_clk(u32 port)
 497 {
 498         u32 clk_sel = 0, pred = 0, podf = 0, freq = 0;
 499         u32 cscmr1 = readl(&mxc_ccm->cscmr1);
 500         u32 cscdr1 = readl(&mxc_ccm->cscdr1);
 501
 502         switch (port) {
 503         case 0:
 504                 clk_sel = MXC_CCM_CSCMR1_ESDHC1_MSHC1_CLK_SEL_RD(cscmr1);
 505                 pred = MXC_CCM_CSCDR1_ESDHC1_MSHC1_CLK_PRED_RD(cscdr1);
 506                 podf = MXC_CCM_CSCDR1_ESDHC1_MSHC1_CLK_PODF_RD(cscdr1);
 507                 break;
 508         case 1:
 509                 clk_sel = MXC_CCM_CSCMR1_ESDHC2_MSHC2_CLK_SEL_RD(cscmr1);
 510                 pred = MXC_CCM_CSCDR1_ESDHC2_MSHC2_CLK_PRED_RD(cscdr1);
 511                 podf = MXC_CCM_CSCDR1_ESDHC2_MSHC2_CLK_PODF_RD(cscdr1);
 512                 break;
 513         case 2:
 514                 if (cscmr1 & MXC_CCM_CSCMR1_ESDHC3_CLK_SEL)
 515                         return get_esdhc_clk(1);
 516                 else
 517                         return get_esdhc_clk(0);
 518         case 3:
 519                 if (cscmr1 & MXC_CCM_CSCMR1_ESDHC4_CLK_SEL)
 520                         return get_esdhc_clk(1);
 521                 else
 522                         return get_esdhc_clk(0);
 523         default:
 524                 break;
 525         }
 526
 527         freq = get_standard_pll_sel_clk(clk_sel) / ((pred + 1) * (podf + 1));
 528         return freq;
 529 }
 530
 531 static u32 get_axi_a_clk(void)
 532 {
 533         u32 cbcdr = readl(&mxc_ccm->cbcdr);
 534         u32 pdf = MXC_CCM_CBCDR_AXI_A_PODF_RD(cbcdr);
 535
 536         return  get_periph_clk() / (pdf + 1);
 537 }
 538
 539 static u32 get_axi_b_clk(void)
 540 {
 541         u32 cbcdr = readl(&mxc_ccm->cbcdr);
 542         u32 pdf = MXC_CCM_CBCDR_AXI_B_PODF_RD(cbcdr);
 543
 544         return  get_periph_clk() / (pdf + 1);
 545 }
 546
 547 static u32 get_emi_slow_clk(void)
 548 {
 549         u32 cbcdr = readl(&mxc_ccm->cbcdr);
 550         u32 emi_clk_sel = cbcdr & MXC_CCM_CBCDR_EMI_CLK_SEL;
 551         u32 pdf = MXC_CCM_CBCDR_EMI_PODF_RD(cbcdr);
 552
 553         if (emi_clk_sel)
 554                 return  get_ahb_clk() / (pdf + 1);
 555
 556         return  get_periph_clk() / (pdf + 1);
 557 }
 558
 559 static u32 get_ddr_clk(void)
 560 {
 561         u32 ret_val = 0;
 562         u32 cbcmr = readl(&mxc_ccm->cbcmr);
 563         u32 ddr_clk_sel = MXC_CCM_CBCMR_DDR_CLK_SEL_RD(cbcmr);
 564 #ifdef CONFIG_MX51
 565         u32 cbcdr = readl(&mxc_ccm->cbcdr);
 566         if (cbcdr & MXC_CCM_CBCDR_DDR_HIFREQ_SEL) {
 567                 u32 ddr_clk_podf = MXC_CCM_CBCDR_DDR_PODF_RD(cbcdr);
 568
 569                 ret_val = decode_pll(mxc_plls[PLL1_CLOCK], MXC_HCLK);
 570                 ret_val /= ddr_clk_podf + 1;
 571
 572                 return ret_val;
 573         }
 574 #endif
 575         switch (ddr_clk_sel) {
 576         case 0:
 577                 ret_val = get_axi_a_clk();
 578                 break;
 579         case 1:
 580                 ret_val = get_axi_b_clk();
 581                 break;
 582         case 2:
 583                 ret_val = get_emi_slow_clk();
 584                 break;
 585         case 3:
 586                 ret_val = get_ahb_clk();
 587                 break;
 588         default:
 589                 break;
 590         }
 591
 592         return ret_val;
 593 }
 594
 595 /*
 596  * The API of get mxc clocks.
 597  */
 598 unsigned int mxc_get_clock(enum mxc_clock clk)
 599 {
 600         switch (clk) {
 601         case MXC_ARM_CLK:
 602                 return get_mcu_main_clk();
 603         case MXC_AHB_CLK:
 604                 return get_ahb_clk();
 605         case MXC_IPG_CLK:
 606                 return get_ipg_clk();
 607         case MXC_IPG_PERCLK:
 608         case MXC_I2C_CLK:
 609                 return get_ipg_per_clk();
 610         case MXC_UART_CLK:
 611                 return get_uart_clk();
 612         case MXC_CSPI_CLK:
 613                 return imx_get_cspiclk();
 614         case MXC_ESDHC_CLK:
 615                 return get_esdhc_clk(0);
 616         case MXC_ESDHC2_CLK:
 617                 return get_esdhc_clk(1);
 618         case MXC_ESDHC3_CLK:
 619                 return get_esdhc_clk(2);
 620         case MXC_ESDHC4_CLK:
 621                 return get_esdhc_clk(3);
 622         case MXC_FEC_CLK:
 623                 return get_ipg_clk();
 624         case MXC_SATA_CLK:
 625                 return get_ahb_clk();
 626         case MXC_DDR_CLK:
 627                 return get_ddr_clk();
 628         default:
 629                 break;
 630         }
 631         return -EINVAL;
 632 }
 633
 634 u32 imx_get_uartclk(void)
 635 {
 636         return get_uart_clk();
 637 }
 638
 639 u32 imx_get_fecclk(void)
 640 {
 641         return get_ipg_clk();
 642 }
 643
 644 static int gcd(int m, int n)
 645 {
 646         int t;
 647         while (m > 0) {
 648                 if (n > m) {
 649                         t = m;
 650                         m = n;
 651                         n = t;
 652                 } /* swap */
 653                 m -= n;
 654         }
 655         return n;
 656 }
 657
 658 /*
 659  * This is to calculate various parameters based on reference clock and
 660  * targeted clock based on the equation:
 661  *      t_clk = 2*ref_freq*(mfi + mfn/(mfd+1))/(pd+1)
 662  * This calculation is based on a fixed MFD value for simplicity.
 663  */
 664 static int calc_pll_params(u32 ref, u32 target, struct pll_param *pll)
 665 {
 666         u64 pd, mfi = 1, mfn, mfd, t1;
 667         u32 n_target = target;
 668         u32 n_ref = ref, i;
 669
 670         /*
 671          * Make sure targeted freq is in the valid range.
 672          * Otherwise the following calculation might be wrong!!!
 673          */
 674         if (n_target < PLL_FREQ_MIN(ref) ||
 675                 n_target > PLL_FREQ_MAX(ref)) {
 676                 printf("Targeted peripheral clock should be within [%d - %d]\n",
 677                         PLL_FREQ_MIN(ref) / SZ_DEC_1M,
 678                         PLL_FREQ_MAX(ref) / SZ_DEC_1M);
 679                 return -EINVAL;
 680         }
 681
 682         for (i = 0; i < ARRAY_SIZE(fixed_mfd); i++) {
 683                 if (fixed_mfd[i].ref_clk_hz == ref) {
 684                         mfd = fixed_mfd[i].mfd;
 685                         break;
 686                 }
 687         }
 688
 689         if (i == ARRAY_SIZE(fixed_mfd))
 690                 return -EINVAL;
 691
 692         /* Use n_target and n_ref to avoid overflow */
 693         for (pd = 1; pd <= PLL_PD_MAX; pd++) {
 694                 t1 = n_target * pd;
 695                 do_div(t1, (4 * n_ref));
 696                 mfi = t1;
 697                 if (mfi > PLL_MFI_MAX)
 698                         return -EINVAL;
 699                 else if (mfi < 5)
 700                         continue;
 701                 break;
 702         }
 703         /*
 704          * Now got pd and mfi already
 705          *
 706          * mfn = (((n_target * pd) / 4 - n_ref * mfi) * mfd) / n_ref;
 707          */
 708         t1 = n_target * pd;
 709         do_div(t1, 4);
 710         t1 -= n_ref * mfi;
 711         t1 *= mfd;
 712         do_div(t1, n_ref);
 713         mfn = t1;
 714         debug("ref=%d, target=%d, pd=%d," "mfi=%d,mfn=%d, mfd=%d\n",
 715                 ref, n_target, (u32)pd, (u32)mfi, (u32)mfn, (u32)mfd);
 716         i = 1;
 717         if (mfn != 0)
 718                 i = gcd(mfd, mfn);
 719         pll->pd = (u32)pd;
 720         pll->mfi = (u32)mfi;
 721         do_div(mfn, i);
 722         pll->mfn = (u32)mfn;
 723         do_div(mfd, i);
 724         pll->mfd = (u32)mfd;
 725
 726         return 0;
 727 }
 728
 729 #define calc_div(tgt_clk, src_clk, limit) ({            \
 730                 u32 v = 0;                              \
 731                 if (((src_clk) % (tgt_clk)) <= 100)     \
 732                         v = (src_clk) / (tgt_clk);      \
 733                 else                                    \
 734                         v = ((src_clk) / (tgt_clk)) + 1;\
 735                 if (v > limit)                          \
 736                         v = limit;                      \
 737                 (v - 1);                                \
 738         })
 739
 740 #define CHANGE_PLL_SETTINGS(pll, pd, fi, fn, fd) \
 741         {       \
 742                 __raw_writel(0x1232, &pll->ctrl);               \
 743                 __raw_writel(0x2, &pll->config);                \
 744                 __raw_writel((((pd) - 1) << 0) | ((fi) << 4),   \
 745                         &pll->op);                              \
 746                 __raw_writel(fn, &(pll->mfn));                  \
 747                 __raw_writel((fd) - 1, &pll->mfd);              \
 748                 __raw_writel((((pd) - 1) << 0) | ((fi) << 4),   \
 749                         &pll->hfs_op);                          \
 750                 __raw_writel(fn, &pll->hfs_mfn);                \
 751                 __raw_writel((fd) - 1, &pll->hfs_mfd);          \
 752                 __raw_writel(0x1232, &pll->ctrl);               \
 753                 while (!__raw_readl(&pll->ctrl) & 0x1)          \
 754                         ;\
 755         }
 756
 757 static int config_pll_clk(enum pll_clocks index, struct pll_param *pll_param)
 758 {
 759         u32 ccsr = __raw_readl(&mxc_ccm->ccsr);
 760         struct mxc_pll_reg *pll = mxc_plls[index];
 761
 762         switch (index) {
 763         case PLL1_CLOCK:
 764                 /* Switch ARM to PLL2 clock */
 765                 __raw_writel(ccsr | 0x4, &mxc_ccm->ccsr);
 766                 CHANGE_PLL_SETTINGS(pll, pll_param->pd,
 767                                         pll_param->mfi, pll_param->mfn,
 768                                         pll_param->mfd);
 769                 /* Switch back */
 770                 __raw_writel(ccsr & ~0x4, &mxc_ccm->ccsr);
 771                 break;
 772         case PLL2_CLOCK:
 773                 /* Switch to pll2 bypass clock */
 774                 __raw_writel(ccsr | 0x2, &mxc_ccm->ccsr);
 775                 CHANGE_PLL_SETTINGS(pll, pll_param->pd,
 776                                         pll_param->mfi, pll_param->mfn,
 777                                         pll_param->mfd);
 778                 /* Switch back */
 779                 __raw_writel(ccsr & ~0x2, &mxc_ccm->ccsr);
 780                 break;
 781         case PLL3_CLOCK:
 782                 /* Switch to pll3 bypass clock */
 783                 __raw_writel(ccsr | 0x1, &mxc_ccm->ccsr);
 784                 CHANGE_PLL_SETTINGS(pll, pll_param->pd,
 785                                         pll_param->mfi, pll_param->mfn,
 786                                         pll_param->mfd);
 787                 /* Switch back */
 788                 __raw_writel(ccsr & ~0x1, &mxc_ccm->ccsr);
 789                 break;
 790 #ifdef CONFIG_MX53
 791         case PLL4_CLOCK:
 792                 /* Switch to pll4 bypass clock */
 793                 __raw_writel(ccsr | 0x20, &mxc_ccm->ccsr);
 794                 CHANGE_PLL_SETTINGS(pll, pll_param->pd,
 795                                         pll_param->mfi, pll_param->mfn,
 796                                         pll_param->mfd);
 797                 /* Switch back */
 798                 __raw_writel(ccsr & ~0x20, &mxc_ccm->ccsr);
 799                 break;
 800 #endif
 801         default:
 802                 return -EINVAL;
 803         }
 804
 805         return 0;
 806 }
 807
 808 /* Config CPU clock */
 809 static int config_core_clk(u32 ref, u32 freq)
 810 {
 811         int ret = 0;
 812         struct pll_param pll_param;
 813
 814         memset(&pll_param, 0, sizeof(struct pll_param));
 815
 816         /* The case that periph uses PLL1 is not considered here */
 817         ret = calc_pll_params(ref, freq, &pll_param);
 818         if (ret != 0) {
 819                 printf("Error: Can't find pll parameters for %u.%03uMHz ref %u.%03uMHz\n",
 820                         freq / 1000000, freq / 1000 % 1000,
 821                         ref / 1000000, ref / 1000 % 1000);
 822                 return ret;
 823         }
 824
 825         return config_pll_clk(PLL1_CLOCK, &pll_param);
 826 }
 827
 828 static int config_nfc_clk(u32 nfc_clk)
 829 {
 830         u32 parent_rate = get_emi_slow_clk();
 831         u32 div;
 832
 833         if (nfc_clk == 0)
 834                 return -EINVAL;
 835         div = parent_rate / nfc_clk;
 836         if (div == 0)
 837                 div++;
 838         if (parent_rate / div > NFC_CLK_MAX)
 839                 div++;
 840         clrsetbits_le32(&mxc_ccm->cbcdr,
 841                         MXC_CCM_CBCDR_NFC_PODF_MASK,
 842                         MXC_CCM_CBCDR_NFC_PODF(div - 1));
 843         while (readl(&mxc_ccm->cdhipr) != 0)
 844                 ;
 845         return 0;
 846 }
 847
 848 void enable_nfc_clk(unsigned char enable)
 849 {
 850         unsigned int cg = enable ? MXC_CCM_CCGR_CG_ON : MXC_CCM_CCGR_CG_OFF;
 851
 852         clrsetbits_le32(&mxc_ccm->CCGR5,
 853                 MXC_CCM_CCGR5_EMI_ENFC(MXC_CCM_CCGR_CG_MASK),
 854                 MXC_CCM_CCGR5_EMI_ENFC(cg));
 855 }
 856
 857 /* Config main_bus_clock for periphs */
 858 static int config_periph_clk(u32 ref, u32 freq)
 859 {
 860         int ret = 0;
 861         struct pll_param pll_param;
 862
 863         memset(&pll_param, 0, sizeof(struct pll_param));
 864
 865         if (readl(&mxc_ccm->cbcdr) & MXC_CCM_CBCDR_PERIPH_CLK_SEL) {
 866                 ret = calc_pll_params(ref, freq, &pll_param);
 867                 if (ret != 0) {
 868                         printf("Error:Can't find pll parameters: %d\n",
 869                                 ret);
 870                         return ret;
 871                 }
 872                 switch (MXC_CCM_CBCMR_PERIPH_CLK_SEL_RD(
 873                                 readl(&mxc_ccm->cbcmr))) {
 874                 case 0:
 875                         return config_pll_clk(PLL1_CLOCK, &pll_param);
 876                         break;
 877                 case 1:
 878                         return config_pll_clk(PLL3_CLOCK, &pll_param);
 879                         break;
 880                 default:
 881                         return -EINVAL;
 882                 }
 883         }
 884
 885         return 0;
 886 }
 887
 888 static int config_ddr_clk(u32 emi_clk)
 889 {
 890         u32 clk_src;
 891         s32 shift = 0, clk_sel, div = 1;
 892         u32 cbcmr = readl(&mxc_ccm->cbcmr);
 893
 894         if (emi_clk > MAX_DDR_CLK) {
 895                 printf("Warning:DDR clock should not exceed %d MHz\n",
 896                         MAX_DDR_CLK / SZ_DEC_1M);
 897                 emi_clk = MAX_DDR_CLK;
 898         }
 899
 900         clk_src = get_periph_clk();
 901         /* Find DDR clock input */
 902         clk_sel = MXC_CCM_CBCMR_DDR_CLK_SEL_RD(cbcmr);
 903         switch (clk_sel) {
 904         case 0:
 905                 shift = 16;
 906                 break;
 907         case 1:
 908                 shift = 19;
 909                 break;
 910         case 2:
 911                 shift = 22;
 912                 break;
 913         case 3:
 914                 shift = 10;
 915                 break;
 916         default:
 917                 return -EINVAL;
 918         }
 919
 920         if ((clk_src % emi_clk) < 10000000)
 921                 div = clk_src / emi_clk;
 922         else
 923                 div = (clk_src / emi_clk) + 1;
 924         if (div > 8)
 925                 div = 8;
 926
 927         clrsetbits_le32(&mxc_ccm->cbcdr, 0x7 << shift, (div - 1) << shift);
 928         while (readl(&mxc_ccm->cdhipr) != 0)
 929                 ;
 930         writel(0x0, &mxc_ccm->ccdr);
 931
 932         return 0;
 933 }
 934
 935 /*
 936  * This function assumes the expected core clock has to be changed by
 937  * modifying the PLL. This is NOT true always but for most of the times,
 938  * it is. So it assumes the PLL output freq is the same as the expected
 939  * core clock (presc=1) unless the core clock is less than PLL_FREQ_MIN.
 940  * In the latter case, it will try to increase the presc value until
 941  * (presc*core_clk) is greater than PLL_FREQ_MIN. It then makes call to
 942  * calc_pll_params() and obtains the values of PD, MFI,MFN, MFD based
 943  * on the targeted PLL and reference input clock to the PLL. Lastly,
 944  * it sets the register based on these values along with the dividers.
 945  * Note 1) There is no value checking for the passed-in divider values
 946  *         so the caller has to make sure those values are sensible.
 947  *      2) Also adjust the NFC divider such that the NFC clock doesn't
 948  *         exceed NFC_CLK_MAX.
 949  *      3) IPU HSP clock is independent of AHB clock. Even it can go up to
 950  *         177MHz for higher voltage, this function fixes the max to 133MHz.
 951  *      4) This function should not have allowed diag_printf() calls since
 952  *         the serial driver has been stoped. But leave then here to allow
 953  *         easy debugging by NOT calling the cyg_hal_plf_serial_stop().
 954  */
 955 int mxc_set_clock(u32 ref, u32 freq, enum mxc_clock clk)
 956 {
 957         freq *= SZ_DEC_1M;
 958
 959         switch (clk) {
 960         case MXC_ARM_CLK:
 961                 if (config_core_clk(ref, freq))
 962                         return -EINVAL;
 963                 break;
 964         case MXC_PERIPH_CLK:
 965                 if (config_periph_clk(ref, freq))
 966                         return -EINVAL;
 967                 break;
 968         case MXC_DDR_CLK:
 969                 if (config_ddr_clk(freq))
 970                         return -EINVAL;
 971                 break;
 972         case MXC_NFC_CLK:
 973                 if (config_nfc_clk(freq))
 974                         return -EINVAL;
 975                 break;
 976         default:
 977                 printf("Warning:Unsupported or invalid clock type\n");
 978         }
 979
 980         return 0;
 981 }
 982
 983 #ifdef CONFIG_MX53
 984 /*
 985  * The clock for the external interface can be set to use internal clock
 986  * if fuse bank 4, row 3, bit 2 is set.
 987  * This is an undocumented feature and it was confirmed by Freescale's support:
 988  * Fuses (but not pins) may be used to configure SATA clocks.
 989  * Particularly the i.MX53 Fuse_Map contains the next information
 990  * about configuring SATA clocks :  SATA_ALT_REF_CLK[1:0] (offset 0x180C)
 991  * '00' - 100MHz (External)
 992  * '01' - 50MHz (External)
 993  * '10' - 120MHz, internal (USB PHY)
 994  * '11' - Reserved
 995 */
 996 void mxc_set_sata_internal_clock(void)
 997 {
 998         u32 *tmp_base =
 999                 (u32 *)(IIM_BASE_ADDR + 0x180c);
1000
1001         set_usb_phy_clk();
1002
1003         clrsetbits_le32(tmp_base, 0x6, 0x4);
1004 }
1005 #endif
1006
1007 /*
1008  * Dump some core clockes.
1009  */
1010 #define pr_clk_val(c, v) {                                      \
1011         printf("%-11s %3lu.%03lu MHz\n", #c,                    \
1012                 (v) / 1000000, (v) / 1000 % 1000);              \
1013 }
1014
1015 #define pr_clk(c) {                                             \
1016         unsigned long __clk = mxc_get_clock(MXC_##c##_CLK);     \
1017         pr_clk_val(c, __clk);                                   \
1018 }
1019
1020 int do_mx5_showclocks(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1021 {
1022         unsigned long freq;
1023
1024         freq = decode_pll(mxc_plls[PLL1_CLOCK], MXC_HCLK);
1025         pr_clk_val(PLL1, freq);
1026         freq = decode_pll(mxc_plls[PLL2_CLOCK], MXC_HCLK);
1027         pr_clk_val(PLL2, freq);
1028         freq = decode_pll(mxc_plls[PLL3_CLOCK], MXC_HCLK);
1029         pr_clk_val(PLL3, freq);
1030 #ifdef  CONFIG_MX53
1031         freq = decode_pll(mxc_plls[PLL4_CLOCK], MXC_HCLK);
1032         pr_clk_val(PLL4, freq);
1033 #endif
1034
1035         printf("\n");
1036         pr_clk(AHB);
1037         pr_clk(IPG);
1038         pr_clk(IPG);
1039         pr_clk(DDR);
1040 #ifdef CONFIG_MXC_SPI
1041         pr_clk(CSPI);
1042 #endif
1043         return 0;
1044 }
1045
1046 /***************************************************/
1047
1048 U_BOOT_CMD(
1049         clocks, CONFIG_SYS_MAXARGS, 1, do_mx5_showclocks,
1050         "display clocks",
1051         ""
1052 );