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