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