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

   1 /*
   2  * Copyright (C) 2010-2011 Freescale Semiconductor, Inc.
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  */
   6
   7 #include <common.h>
   8 #include <div64.h>
   9 #include <asm/io.h>
  10 #include <asm/errno.h>
  11 #include <asm/arch/imx-regs.h>
  12 #include <asm/arch/crm_regs.h>
  13 #include <asm/arch/clock.h>
  14 #include <asm/arch/sys_proto.h>
  15
  16 enum pll_clocks {
  17         PLL_ARM,        /* PLL1: ARM PLL */
  18         PLL_528,        /* PLL2: System Bus PLL*/
  19         PLL_USBOTG,     /* PLL3: OTG USB PLL */
  20         PLL_AUDIO,      /* PLL4: Audio PLL */
  21         PLL_VIDEO,      /* PLL5: Video PLL */
  22         PLL_ENET,       /* PLL6: ENET PLL */
  23         PLL_USB2,       /* PLL7: USB2 PLL */
  24         PLL_MLB,        /* PLL8: MLB PLL */
  25 };
  26
  27 struct mxc_ccm_reg *const imx_ccm = (void *)CCM_BASE_ADDR;
  28 struct anatop_regs *const anatop = (void *)ANATOP_BASE_ADDR;
  29
  30 int clk_enable(struct clk *clk)
  31 {
  32         int ret = 0;
  33
  34         if (!clk)
  35                 return 0;
  36         if (clk->usecount == 0) {
  37                 debug("%s: Enabling %s clock\n", __func__, clk->name);
  38                 ret = clk->enable(clk);
  39                 if (ret)
  40                         return ret;
  41                 clk->usecount++;
  42         }
  43         assert(clk->usecount > 0);
  44         return ret;
  45 }
  46
  47 void clk_disable(struct clk *clk)
  48 {
  49         if (!clk)
  50                 return;
  51
  52         assert(clk->usecount > 0);
  53         if (!(--clk->usecount)) {
  54                 if (clk->disable) {
  55                         debug("%s: Disabling %s clock\n", __func__, clk->name);
  56                         clk->disable(clk);
  57                 }
  58         }
  59 }
  60
  61 int clk_get_usecount(struct clk *clk)
  62 {
  63         if (clk == NULL)
  64                 return 0;
  65
  66         return clk->usecount;
  67 }
  68
  69 u32 clk_get_rate(struct clk *clk)
  70 {
  71         if (!clk)
  72                 return 0;
  73
  74         return clk->rate;
  75 }
  76
  77 struct clk *clk_get_parent(struct clk *clk)
  78 {
  79         if (!clk)
  80                 return 0;
  81
  82         return clk->parent;
  83 }
  84
  85 int clk_set_rate(struct clk *clk, unsigned long rate)
  86 {
  87         if (clk && clk->set_rate)
  88                 clk->set_rate(clk, rate);
  89         return clk->rate;
  90 }
  91
  92 long clk_round_rate(struct clk *clk, unsigned long rate)
  93 {
  94         if (clk == NULL || !clk->round_rate)
  95                 return 0;
  96
  97         return clk->round_rate(clk, rate);
  98 }
  99
 100 int clk_set_parent(struct clk *clk, struct clk *parent)
 101 {
 102         debug("Setting parent of clk %p to %p (%p)\n", clk, parent,
 103                 clk ? clk->parent : NULL);
 104
 105         if (!clk || clk == parent)
 106                 return 0;
 107
 108         if (clk->set_parent) {
 109                 int ret;
 110
 111                 ret = clk->set_parent(clk, parent);
 112                 if (ret)
 113                         return ret;
 114         }
 115         clk->parent = parent;
 116         return 0;
 117 }
 118
 119 #ifdef CONFIG_MXC_OCOTP
 120 void enable_ocotp_clk(unsigned char enable)
 121 {
 122         u32 reg;
 123
 124         reg = __raw_readl(&imx_ccm->CCGR2);
 125         if (enable)
 126                 reg |= MXC_CCM_CCGR2_OCOTP_CTRL_MASK;
 127         else
 128                 reg &= ~MXC_CCM_CCGR2_OCOTP_CTRL_MASK;
 129         __raw_writel(reg, &imx_ccm->CCGR2);
 130 }
 131 #endif
 132
 133 #ifdef CONFIG_NAND_MXS
 134 void setup_gpmi_io_clk(u32 cfg)
 135 {
 136         /* Disable clocks per ERR007177 from MX6 errata */
 137         clrbits_le32(&imx_ccm->CCGR4,
 138                      MXC_CCM_CCGR4_RAWNAND_U_BCH_INPUT_APB_MASK |
 139                      MXC_CCM_CCGR4_RAWNAND_U_GPMI_BCH_INPUT_BCH_MASK |
 140                      MXC_CCM_CCGR4_RAWNAND_U_GPMI_BCH_INPUT_GPMI_IO_MASK |
 141                      MXC_CCM_CCGR4_RAWNAND_U_GPMI_INPUT_APB_MASK |
 142                      MXC_CCM_CCGR4_PL301_MX6QPER1_BCH_MASK);
 143
 144         clrbits_le32(&imx_ccm->CCGR2, MXC_CCM_CCGR2_IOMUX_IPT_CLK_IO_MASK);
 145
 146         clrsetbits_le32(&imx_ccm->cs2cdr,
 147                         MXC_CCM_CS2CDR_ENFC_CLK_PODF_MASK |
 148                         MXC_CCM_CS2CDR_ENFC_CLK_PRED_MASK |
 149                         MXC_CCM_CS2CDR_ENFC_CLK_SEL_MASK,
 150                         cfg);
 151
 152         setbits_le32(&imx_ccm->CCGR2, MXC_CCM_CCGR2_IOMUX_IPT_CLK_IO_MASK);
 153         setbits_le32(&imx_ccm->CCGR4,
 154                      MXC_CCM_CCGR4_RAWNAND_U_BCH_INPUT_APB_MASK |
 155                      MXC_CCM_CCGR4_RAWNAND_U_GPMI_BCH_INPUT_BCH_MASK |
 156                      MXC_CCM_CCGR4_RAWNAND_U_GPMI_BCH_INPUT_GPMI_IO_MASK |
 157                      MXC_CCM_CCGR4_RAWNAND_U_GPMI_INPUT_APB_MASK |
 158                      MXC_CCM_CCGR4_PL301_MX6QPER1_BCH_MASK);
 159 }
 160 #endif
 161
 162 void enable_usboh3_clk(unsigned char enable)
 163 {
 164         u32 reg;
 165
 166         reg = __raw_readl(&imx_ccm->CCGR6);
 167         if (enable)
 168                 reg |= MXC_CCM_CCGR6_USBOH3_MASK;
 169         else
 170                 reg &= ~(MXC_CCM_CCGR6_USBOH3_MASK);
 171         __raw_writel(reg, &imx_ccm->CCGR6);
 172
 173 }
 174
 175 #if defined(CONFIG_FEC_MXC) && !defined(CONFIG_SOC_MX6SX)
 176 void enable_enet_clk(unsigned char enable)
 177 {
 178         u32 mask = MXC_CCM_CCGR1_ENET_CLK_ENABLE_MASK;
 179
 180         if (enable)
 181                 setbits_le32(&imx_ccm->CCGR1, mask);
 182         else
 183                 clrbits_le32(&imx_ccm->CCGR1, mask);
 184 }
 185 #endif
 186
 187 #ifdef CONFIG_MXC_UART
 188 void enable_uart_clk(unsigned char enable)
 189 {
 190         u32 mask = MXC_CCM_CCGR5_UART_MASK | MXC_CCM_CCGR5_UART_SERIAL_MASK;
 191
 192         if (enable)
 193                 setbits_le32(&imx_ccm->CCGR5, mask);
 194         else
 195                 clrbits_le32(&imx_ccm->CCGR5, mask);
 196 }
 197 #endif
 198
 199 #ifdef CONFIG_SPI
 200 /* spi_num can be from 0 - 4 */
 201 int enable_cspi_clock(unsigned char enable, unsigned spi_num)
 202 {
 203         u32 mask;
 204
 205         if (spi_num > 4)
 206                 return -EINVAL;
 207
 208         mask = MXC_CCM_CCGR_CG_MASK << (spi_num * 2);
 209         if (enable)
 210                 setbits_le32(&imx_ccm->CCGR1, mask);
 211         else
 212                 clrbits_le32(&imx_ccm->CCGR1, mask);
 213
 214         return 0;
 215 }
 216 #endif
 217
 218 #ifdef CONFIG_MMC
 219 int enable_usdhc_clk(unsigned char enable, unsigned bus_num)
 220 {
 221         u32 mask;
 222
 223         if (bus_num > 3)
 224                 return -EINVAL;
 225
 226         mask = MXC_CCM_CCGR_CG_MASK << (bus_num * 2 + 2);
 227         if (enable)
 228                 setbits_le32(&imx_ccm->CCGR6, mask);
 229         else
 230                 clrbits_le32(&imx_ccm->CCGR6, mask);
 231
 232         return 0;
 233 }
 234 #endif
 235
 236 #ifdef CONFIG_SYS_I2C_MXC
 237 /* i2c_num can be from 0 - 2 */
 238 int enable_i2c_clk(unsigned char enable, unsigned i2c_num)
 239 {
 240         u32 reg;
 241         u32 mask;
 242
 243         if (i2c_num > 2)
 244                 return -EINVAL;
 245
 246         mask = MXC_CCM_CCGR_CG_MASK
 247                 << (MXC_CCM_CCGR2_I2C1_SERIAL_OFFSET + (i2c_num << 1));
 248         reg = __raw_readl(&imx_ccm->CCGR2);
 249         if (enable)
 250                 reg |= mask;
 251         else
 252                 reg &= ~mask;
 253         __raw_writel(reg, &imx_ccm->CCGR2);
 254         return 0;
 255 }
 256 #endif
 257
 258 /* spi_num can be from 0 - SPI_MAX_NUM */
 259 int enable_spi_clk(unsigned char enable, unsigned spi_num)
 260 {
 261         u32 reg;
 262         u32 mask;
 263
 264         if (spi_num > SPI_MAX_NUM)
 265                 return -EINVAL;
 266
 267         mask = MXC_CCM_CCGR_CG_MASK << (spi_num << 1);
 268         reg = __raw_readl(&imx_ccm->CCGR1);
 269         if (enable)
 270                 reg |= mask;
 271         else
 272                 reg &= ~mask;
 273         __raw_writel(reg, &imx_ccm->CCGR1);
 274         return 0;
 275 }
 276 static u32 decode_pll(enum pll_clocks pll, u32 infreq)
 277 {
 278         u32 div;
 279
 280         switch (pll) {
 281         case PLL_ARM:
 282                 div = __raw_readl(&anatop->pll_arm);
 283                 if (div & BM_ANADIG_PLL_ARM_BYPASS)
 284                         /* Assume the bypass clock is always derived from OSC */
 285                         return infreq;
 286                 div &= BM_ANADIG_PLL_ARM_DIV_SELECT;
 287
 288                 return infreq * div / 2;
 289         case PLL_528:
 290                 div = __raw_readl(&anatop->pll_528);
 291                 if (div & BM_ANADIG_PLL_528_BYPASS)
 292                         return infreq;
 293                 div &= BM_ANADIG_PLL_528_DIV_SELECT;
 294
 295                 return infreq * (20 + div * 2);
 296         case PLL_USBOTG:
 297                 div = __raw_readl(&anatop->usb1_pll_480_ctrl);
 298                 if (div & BM_ANADIG_USB_PLL_480_CTRL_BYPASS)
 299                         return infreq;
 300                 div &= BM_ANADIG_USB_PLL_480_CTRL_DIV_SELECT;
 301
 302                 return infreq * (20 + div * 2);
 303         case PLL_AUDIO:
 304                 div = __raw_readl(&anatop->pll_audio);
 305                 if (div & BM_ANADIG_PLL_AUDIO_BYPASS)
 306                         return infreq;
 307                 div &= BM_ANADIG_PLL_AUDIO_DIV_SELECT;
 308
 309                 return infreq * div;
 310         case PLL_VIDEO:
 311                 div = __raw_readl(&anatop->pll_video);
 312                 if (div & BM_ANADIG_PLL_VIDEO_BYPASS)
 313                         return infreq;
 314                 div &= BM_ANADIG_PLL_VIDEO_DIV_SELECT;
 315
 316                 return infreq * div;
 317         case PLL_ENET:
 318                 div = __raw_readl(&anatop->pll_enet);
 319                 if (div & BM_ANADIG_PLL_ENET_BYPASS)
 320                         return infreq;
 321                 div &= BM_ANADIG_PLL_ENET_DIV_SELECT;
 322
 323                 return 25000000 * (div + (div >> 1) + 1);
 324         case PLL_USB2:
 325                 div = __raw_readl(&anatop->usb2_pll_480_ctrl);
 326                 if (div & BM_ANADIG_USB_PLL_480_CTRL_BYPASS)
 327                         return infreq;
 328                 div &= BM_ANADIG_USB_PLL_480_CTRL_DIV_SELECT;
 329
 330                 return infreq * (20 + div * 2);
 331         case PLL_MLB:
 332                 div = __raw_readl(&anatop->pll_mlb);
 333                 if (div & BM_ANADIG_PLL_MLB_BYPASS)
 334                         return infreq;
 335                 /* unknown external clock provided on MLB_CLK pin */
 336                 return 0;
 337         }
 338         return 0;
 339 }
 340 static u32 mxc_get_pll_pfd(enum pll_clocks pll, int pfd_num)
 341 {
 342         u32 div;
 343         u64 freq;
 344         struct anatop_regs *anatop = (struct anatop_regs *)ANATOP_BASE_ADDR;
 345
 346         switch (pll) {
 347         case PLL_528:
 348                 if (pfd_num == 3) {
 349                         /* No PFD3 on PLL2 */
 350                         return 0;
 351                 }
 352                 div = __raw_readl(&anatop->pfd_528);
 353                 freq = (u64)decode_pll(PLL_528, MXC_HCLK);
 354                 break;
 355         case PLL_USBOTG:
 356                 div = __raw_readl(&anatop->pfd_480);
 357                 freq = (u64)decode_pll(PLL_USBOTG, MXC_HCLK);
 358                 break;
 359         default:
 360                 /* No PFD on other PLL */
 361                 return 0;
 362         }
 363
 364         return lldiv(freq * 18, (div & ANATOP_PFD_FRAC_MASK(pfd_num)) >>
 365                               ANATOP_PFD_FRAC_SHIFT(pfd_num));
 366 }
 367
 368 static u32 get_mcu_main_clk(void)
 369 {
 370         u32 reg, freq;
 371
 372         reg = __raw_readl(&imx_ccm->cacrr);
 373         reg &= MXC_CCM_CACRR_ARM_PODF_MASK;
 374         reg >>= MXC_CCM_CACRR_ARM_PODF_OFFSET;
 375         freq = decode_pll(PLL_ARM, MXC_HCLK);
 376
 377         return freq / (reg + 1);
 378 }
 379
 380 u32 get_periph_clk(void)
 381 {
 382         u32 reg, freq = 0;
 383
 384         reg = __raw_readl(&imx_ccm->cbcdr);
 385         if (reg & MXC_CCM_CBCDR_PERIPH_CLK_SEL) {
 386                 reg = __raw_readl(&imx_ccm->cbcmr);
 387                 reg &= MXC_CCM_CBCMR_PERIPH_CLK2_SEL_MASK;
 388                 reg >>= MXC_CCM_CBCMR_PERIPH_CLK2_SEL_OFFSET;
 389
 390                 switch (reg) {
 391                 case 0:
 392                         freq = decode_pll(PLL_USBOTG, MXC_HCLK);
 393                         break;
 394                 case 1:
 395                 case 2:
 396                         freq = MXC_HCLK;
 397                         break;
 398                 }
 399         } else {
 400                 reg = __raw_readl(&imx_ccm->cbcmr);
 401                 reg &= MXC_CCM_CBCMR_PRE_PERIPH_CLK_SEL_MASK;
 402                 reg >>= MXC_CCM_CBCMR_PRE_PERIPH_CLK_SEL_OFFSET;
 403
 404                 switch (reg) {
 405                 case 0:
 406                         freq = decode_pll(PLL_528, MXC_HCLK);
 407                         break;
 408                 case 1:
 409                         freq = mxc_get_pll_pfd(PLL_528, 2);
 410                         break;
 411                 case 2:
 412                         freq = mxc_get_pll_pfd(PLL_528, 0);
 413                         break;
 414                 case 3:
 415                         /* static / 2 divider */
 416                         freq = mxc_get_pll_pfd(PLL_528, 2) / 2;
 417                         break;
 418                 }
 419         }
 420
 421         return freq;
 422 }
 423
 424 static u32 get_ipg_clk(void)
 425 {
 426         u32 reg, ipg_podf;
 427
 428         reg = __raw_readl(&imx_ccm->cbcdr);
 429         reg &= MXC_CCM_CBCDR_IPG_PODF_MASK;
 430         ipg_podf = reg >> MXC_CCM_CBCDR_IPG_PODF_OFFSET;
 431
 432         return get_ahb_clk() / (ipg_podf + 1);
 433 }
 434
 435 static u32 get_ipg_per_clk(void)
 436 {
 437         u32 reg, perclk_podf;
 438
 439         reg = __raw_readl(&imx_ccm->cscmr1);
 440 #if (defined(CONFIG_SOC_MX6SL) || defined(CONFIG_SOC_MX6SX))
 441         if (reg & MXC_CCM_CSCMR1_PER_CLK_SEL_MASK)
 442                 return MXC_HCLK; /* OSC 24Mhz */
 443 #endif
 444         perclk_podf = reg & MXC_CCM_CSCMR1_PERCLK_PODF_MASK;
 445
 446         return get_ipg_clk() / (perclk_podf + 1);
 447 }
 448
 449 static u32 get_uart_clk(void)
 450 {
 451         u32 reg, uart_podf;
 452         u32 freq = decode_pll(PLL_USBOTG, MXC_HCLK) / 6; /* static divider */
 453         reg = __raw_readl(&imx_ccm->cscdr1);
 454 #if (defined(CONFIG_SOC_MX6SL) || defined(CONFIG_SOC_MX6SX))
 455         if (reg & MXC_CCM_CSCDR1_UART_CLK_SEL)
 456                 freq = MXC_HCLK;
 457 #endif
 458         reg &= MXC_CCM_CSCDR1_UART_CLK_PODF_MASK;
 459         uart_podf = reg >> MXC_CCM_CSCDR1_UART_CLK_PODF_OFFSET;
 460
 461         return freq / (uart_podf + 1);
 462 }
 463
 464 static u32 get_cspi_clk(void)
 465 {
 466         u32 reg, cspi_podf;
 467
 468         reg = __raw_readl(&imx_ccm->cscdr2);
 469         reg &= MXC_CCM_CSCDR2_ECSPI_CLK_PODF_MASK;
 470         cspi_podf = reg >> MXC_CCM_CSCDR2_ECSPI_CLK_PODF_OFFSET;
 471
 472         return  decode_pll(PLL_USBOTG, MXC_HCLK) / (8 * (cspi_podf + 1));
 473 }
 474
 475 static u32 get_axi_clk(void)
 476 {
 477         u32 root_freq, axi_podf;
 478         u32 cbcdr =  __raw_readl(&imx_ccm->cbcdr);
 479
 480         axi_podf = cbcdr & MXC_CCM_CBCDR_AXI_PODF_MASK;
 481         axi_podf >>= MXC_CCM_CBCDR_AXI_PODF_OFFSET;
 482
 483         if (cbcdr & MXC_CCM_CBCDR_AXI_SEL) {
 484                 if (cbcdr & MXC_CCM_CBCDR_AXI_ALT_SEL)
 485                         root_freq = mxc_get_pll_pfd(PLL_528, 2);
 486                 else
 487                         root_freq = mxc_get_pll_pfd(PLL_USBOTG, 1);
 488         } else
 489                 root_freq = get_periph_clk();
 490
 491         return  root_freq / (axi_podf + 1);
 492 }
 493
 494 static u32 get_emi_slow_clk(void)
 495 {
 496         u32 emi_clk_sel, emi_slow_podf, cscmr1, root_freq = 0;
 497
 498         cscmr1 =  __raw_readl(&imx_ccm->cscmr1);
 499         emi_clk_sel = cscmr1 & MXC_CCM_CSCMR1_ACLK_EMI_SLOW_MASK;
 500         emi_clk_sel >>= MXC_CCM_CSCMR1_ACLK_EMI_SLOW_OFFSET;
 501         emi_slow_podf = cscmr1 & MXC_CCM_CSCMR1_ACLK_EMI_SLOW_PODF_MASK;
 502         emi_slow_podf >>= MXC_CCM_CSCMR1_ACLK_EMI_SLOW_PODF_OFFSET;
 503
 504         switch (emi_clk_sel) {
 505         case 0:
 506                 root_freq = get_axi_clk();
 507                 break;
 508         case 1:
 509                 root_freq = decode_pll(PLL_USBOTG, MXC_HCLK);
 510                 break;
 511         case 2:
 512                 root_freq =  mxc_get_pll_pfd(PLL_528, 2);
 513                 break;
 514         case 3:
 515                 root_freq =  mxc_get_pll_pfd(PLL_528, 0);
 516                 break;
 517         }
 518
 519         return root_freq / (emi_slow_podf + 1);
 520 }
 521
 522 static u32 get_nfc_clk(void)
 523 {
 524         u32 cs2cdr = __raw_readl(&imx_ccm->cs2cdr);
 525         u32 podf = (cs2cdr & MXC_CCM_CS2CDR_ENFC_CLK_PODF_MASK) >> MXC_CCM_CS2CDR_ENFC_CLK_PODF_OFFSET;
 526         u32 pred = (cs2cdr & MXC_CCM_CS2CDR_ENFC_CLK_PRED_MASK) >> MXC_CCM_CS2CDR_ENFC_CLK_PRED_OFFSET;
 527         int nfc_clk_sel = (cs2cdr & MXC_CCM_CS2CDR_ENFC_CLK_SEL_MASK) >>
 528                 MXC_CCM_CS2CDR_ENFC_CLK_SEL_OFFSET;
 529         u32 root_freq;
 530
 531         switch (nfc_clk_sel) {
 532         case 0:
 533                 root_freq = mxc_get_pll_pfd(PLL_528, 0);
 534                 break;
 535         case 1:
 536                 root_freq = decode_pll(PLL_528, MXC_HCLK);
 537                 break;
 538         case 2:
 539                 root_freq = decode_pll(PLL_USBOTG, MXC_HCLK);
 540                 break;
 541         case 3:
 542                 root_freq = mxc_get_pll_pfd(PLL_528, 2);
 543                 break;
 544         }
 545
 546         return root_freq / (pred + 1) / (podf + 1);
 547 }
 548
 549 #define CS2CDR_ENFC_MASK        (MXC_CCM_CS2CDR_ENFC_CLK_PODF_MASK |    \
 550                                 MXC_CCM_CS2CDR_ENFC_CLK_PRED_MASK |     \
 551                                 MXC_CCM_CS2CDR_ENFC_CLK_SEL_MASK)
 552
 553 static int set_nfc_clk(u32 ref, u32 freq_khz)
 554 {
 555         u32 cs2cdr = __raw_readl(&imx_ccm->cs2cdr);
 556         u32 podf;
 557         u32 pred;
 558         int nfc_clk_sel;
 559         u32 root_freq;
 560         u32 min_err = ~0;
 561         u32 nfc_val = ~0;
 562         u32 freq = freq_khz * 1000;
 563
 564         for (nfc_clk_sel = 0; nfc_clk_sel < 4; nfc_clk_sel++) {
 565                 u32 act_freq;
 566                 u32 err;
 567
 568                 if (ref < 4 && ref != nfc_clk_sel)
 569                         continue;
 570
 571                 switch (nfc_clk_sel) {
 572                 case 0:
 573                         root_freq = mxc_get_pll_pfd(PLL_528, 0);
 574                         break;
 575                 case 1:
 576                         root_freq = decode_pll(PLL_528, MXC_HCLK);
 577                         break;
 578                 case 2:
 579                         root_freq = decode_pll(PLL_USBOTG, MXC_HCLK);
 580                         break;
 581                 case 3:
 582                         root_freq = mxc_get_pll_pfd(PLL_528, 2);
 583                         break;
 584                 }
 585                 if (root_freq < freq)
 586                         continue;
 587
 588                 podf = min(DIV_ROUND_UP(root_freq, freq), 1U << 6);
 589                 pred = min(DIV_ROUND_UP(root_freq / podf, freq), 8U);
 590                 act_freq = root_freq / pred / podf;
 591                 err = (freq - act_freq) * 100 / freq;
 592                 debug("root=%d[%u] freq=%u pred=%u podf=%u act=%u err=%d\n",
 593                         nfc_clk_sel, root_freq, freq, pred, podf, act_freq, err);
 594                 if (act_freq > freq)
 595                         continue;
 596                 if (err < min_err) {
 597                         nfc_val = (podf - 1) << MXC_CCM_CS2CDR_ENFC_CLK_PODF_OFFSET;
 598                         nfc_val |= (pred - 1) << MXC_CCM_CS2CDR_ENFC_CLK_PRED_OFFSET;
 599                         nfc_val |= nfc_clk_sel << MXC_CCM_CS2CDR_ENFC_CLK_SEL_OFFSET;
 600                         min_err = err;
 601                         if (err == 0)
 602                                 break;
 603                 }
 604         }
 605
 606         if (nfc_val == ~0 || min_err > 10)
 607                 return -EINVAL;
 608
 609         if ((cs2cdr & CS2CDR_ENFC_MASK) != nfc_val) {
 610                 debug("changing cs2cdr from %08x to %08x\n", cs2cdr,
 611                         (cs2cdr & ~CS2CDR_ENFC_MASK) | nfc_val);
 612                 __raw_writel((cs2cdr & ~CS2CDR_ENFC_MASK) | nfc_val,
 613                         &imx_ccm->cs2cdr);
 614         } else {
 615                 debug("Leaving cs2cdr unchanged [%08x]\n", cs2cdr);
 616         }
 617         return 0;
 618 }
 619
 620 #if (defined(CONFIG_SOC_MX6SL) || defined(CONFIG_SOC_MX6SX))
 621 static u32 get_mmdc_ch0_clk(void)
 622 {
 623         u32 cbcmr = __raw_readl(&imx_ccm->cbcmr);
 624         u32 cbcdr = __raw_readl(&imx_ccm->cbcdr);
 625         u32 freq, podf;
 626
 627         podf = (cbcdr & MXC_CCM_CBCDR_MMDC_CH1_PODF_MASK) \
 628                         >> MXC_CCM_CBCDR_MMDC_CH1_PODF_OFFSET;
 629
 630         switch ((cbcmr & MXC_CCM_CBCMR_PRE_PERIPH2_CLK_SEL_MASK) >>
 631                 MXC_CCM_CBCMR_PRE_PERIPH2_CLK_SEL_OFFSET) {
 632         case 0:
 633                 freq = decode_pll(PLL_528, MXC_HCLK);
 634                 break;
 635         case 1:
 636                 freq = mxc_get_pll_pfd(PLL_528, 2);
 637                 break;
 638         case 2:
 639                 freq = mxc_get_pll_pfd(PLL_528, 0);
 640                 break;
 641         case 3:
 642                 /* static / 2 divider */
 643                 freq =  mxc_get_pll_pfd(PLL_528, 2) / 2;
 644         }
 645
 646         return freq / (podf + 1);
 647
 648 }
 649 #else
 650 static u32 get_mmdc_ch0_clk(void)
 651 {
 652         u32 cbcdr = __raw_readl(&imx_ccm->cbcdr);
 653         u32 mmdc_ch0_podf = (cbcdr & MXC_CCM_CBCDR_MMDC_CH0_PODF_MASK) >>
 654                                 MXC_CCM_CBCDR_MMDC_CH0_PODF_OFFSET;
 655
 656         return get_periph_clk() / (mmdc_ch0_podf + 1);
 657 }
 658 #endif
 659
 660 #ifdef CONFIG_SOC_MX6SX
 661 /* qspi_num can be from 0 - 1 */
 662 void enable_qspi_clk(int qspi_num)
 663 {
 664         u32 reg = 0;
 665         /* Enable QuadSPI clock */
 666         switch (qspi_num) {
 667         case 0:
 668                 /* disable the clock gate */
 669                 clrbits_le32(&imx_ccm->CCGR3, MXC_CCM_CCGR3_QSPI1_MASK);
 670
 671                 /* set 50M  : (50 = 396 / 2 / 4) */
 672                 reg = readl(&imx_ccm->cscmr1);
 673                 reg &= ~(MXC_CCM_CSCMR1_QSPI1_PODF_MASK |
 674                          MXC_CCM_CSCMR1_QSPI1_CLK_SEL_MASK);
 675                 reg |= ((1 << MXC_CCM_CSCMR1_QSPI1_PODF_OFFSET) |
 676                         (2 << MXC_CCM_CSCMR1_QSPI1_CLK_SEL_OFFSET));
 677                 writel(reg, &imx_ccm->cscmr1);
 678
 679                 /* enable the clock gate */
 680                 setbits_le32(&imx_ccm->CCGR3, MXC_CCM_CCGR3_QSPI1_MASK);
 681                 break;
 682         case 1:
 683                 /*
 684                  * disable the clock gate
 685                  * QSPI2 and GPMI_BCH_INPUT_GPMI_IO share the same clock gate,
 686                  * disable both of them.
 687                  */
 688                 clrbits_le32(&imx_ccm->CCGR4, MXC_CCM_CCGR4_QSPI2_ENFC_MASK |
 689                              MXC_CCM_CCGR4_RAWNAND_U_GPMI_BCH_INPUT_GPMI_IO_MASK);
 690
 691                 /* set 50M  : (50 = 396 / 2 / 4) */
 692                 reg = readl(&imx_ccm->cs2cdr);
 693                 reg &= ~(MXC_CCM_CS2CDR_QSPI2_CLK_PODF_MASK |
 694                          MXC_CCM_CS2CDR_QSPI2_CLK_PRED_MASK |
 695                          MXC_CCM_CS2CDR_QSPI2_CLK_SEL_MASK);
 696                 reg |= (MXC_CCM_CS2CDR_QSPI2_CLK_PRED(0x1) |
 697                         MXC_CCM_CS2CDR_QSPI2_CLK_SEL(0x3));
 698                 writel(reg, &imx_ccm->cs2cdr);
 699
 700                 /*enable the clock gate*/
 701                 setbits_le32(&imx_ccm->CCGR4, MXC_CCM_CCGR4_QSPI2_ENFC_MASK |
 702                              MXC_CCM_CCGR4_RAWNAND_U_GPMI_BCH_INPUT_GPMI_IO_MASK);
 703                 break;
 704         default:
 705                 break;
 706         }
 707 }
 708 #endif
 709
 710 #ifdef CONFIG_FEC_MXC
 711 int enable_fec_anatop_clock(enum enet_freq freq)
 712 {
 713         u32 reg = 0;
 714         s32 timeout = 100000;
 715
 716         struct anatop_regs __iomem *anatop =
 717                 (struct anatop_regs __iomem *)ANATOP_BASE_ADDR;
 718
 719         if (freq < ENET_25MHZ || freq > ENET_125MHZ)
 720                 return -EINVAL;
 721
 722         reg = readl(&anatop->pll_enet);
 723         reg &= ~BM_ANADIG_PLL_ENET_DIV_SELECT;
 724         reg |= freq;
 725
 726         if ((reg & BM_ANADIG_PLL_ENET_POWERDOWN) ||
 727             (!(reg & BM_ANADIG_PLL_ENET_LOCK))) {
 728                 reg &= ~BM_ANADIG_PLL_ENET_POWERDOWN;
 729                 writel(reg, &anatop->pll_enet);
 730                 while (timeout--) {
 731                         if (readl(&anatop->pll_enet) & BM_ANADIG_PLL_ENET_LOCK)
 732                                 break;
 733                 }
 734                 if (timeout < 0)
 735                         return -ETIMEDOUT;
 736         }
 737
 738         /* Enable FEC clock */
 739         reg |= BM_ANADIG_PLL_ENET_ENABLE;
 740         reg &= ~BM_ANADIG_PLL_ENET_BYPASS;
 741         writel(reg, &anatop->pll_enet);
 742
 743 #ifdef CONFIG_SOC_MX6SX
 744         /*
 745          * Set enet ahb clock to 200MHz
 746          * pll2_pfd2_396m-> ENET_PODF-> ENET_AHB
 747          */
 748         reg = readl(&imx_ccm->chsccdr);
 749         reg &= ~(MXC_CCM_CHSCCDR_ENET_PRE_CLK_SEL_MASK
 750                  | MXC_CCM_CHSCCDR_ENET_PODF_MASK
 751                  | MXC_CCM_CHSCCDR_ENET_CLK_SEL_MASK);
 752         /* PLL2 PFD2 */
 753         reg |= (4 << MXC_CCM_CHSCCDR_ENET_PRE_CLK_SEL_OFFSET);
 754         /* Div = 2*/
 755         reg |= (1 << MXC_CCM_CHSCCDR_ENET_PODF_OFFSET);
 756         reg |= (0 << MXC_CCM_CHSCCDR_ENET_CLK_SEL_OFFSET);
 757         writel(reg, &imx_ccm->chsccdr);
 758
 759         /* Enable enet system clock */
 760         reg = readl(&imx_ccm->CCGR3);
 761         reg |= MXC_CCM_CCGR3_ENET_MASK;
 762         writel(reg, &imx_ccm->CCGR3);
 763 #endif
 764         return 0;
 765 }
 766 #endif
 767
 768 static u32 get_usdhc_clk(u32 port)
 769 {
 770         u32 root_freq = 0, usdhc_podf = 0, clk_sel = 0;
 771         u32 cscmr1 = __raw_readl(&imx_ccm->cscmr1);
 772         u32 cscdr1 = __raw_readl(&imx_ccm->cscdr1);
 773
 774         switch (port) {
 775         case 0:
 776                 usdhc_podf = (cscdr1 & MXC_CCM_CSCDR1_USDHC1_PODF_MASK) >>
 777                                         MXC_CCM_CSCDR1_USDHC1_PODF_OFFSET;
 778                 clk_sel = cscmr1 & MXC_CCM_CSCMR1_USDHC1_CLK_SEL;
 779
 780                 break;
 781         case 1:
 782                 usdhc_podf = (cscdr1 & MXC_CCM_CSCDR1_USDHC2_PODF_MASK) >>
 783                                         MXC_CCM_CSCDR1_USDHC2_PODF_OFFSET;
 784                 clk_sel = cscmr1 & MXC_CCM_CSCMR1_USDHC2_CLK_SEL;
 785
 786                 break;
 787         case 2:
 788                 usdhc_podf = (cscdr1 & MXC_CCM_CSCDR1_USDHC3_PODF_MASK) >>
 789                                         MXC_CCM_CSCDR1_USDHC3_PODF_OFFSET;
 790                 clk_sel = cscmr1 & MXC_CCM_CSCMR1_USDHC3_CLK_SEL;
 791
 792                 break;
 793         case 3:
 794                 usdhc_podf = (cscdr1 & MXC_CCM_CSCDR1_USDHC4_PODF_MASK) >>
 795                                         MXC_CCM_CSCDR1_USDHC4_PODF_OFFSET;
 796                 clk_sel = cscmr1 & MXC_CCM_CSCMR1_USDHC4_CLK_SEL;
 797
 798                 break;
 799         default:
 800                 break;
 801         }
 802
 803         if (clk_sel)
 804                 root_freq = mxc_get_pll_pfd(PLL_528, 0);
 805         else
 806                 root_freq = mxc_get_pll_pfd(PLL_528, 2);
 807
 808         return root_freq / (usdhc_podf + 1);
 809 }
 810
 811 u32 imx_get_uartclk(void)
 812 {
 813         return get_uart_clk();
 814 }
 815
 816 u32 imx_get_fecclk(void)
 817 {
 818         return mxc_get_clock(MXC_IPG_CLK);
 819 }
 820
 821 static int enable_enet_pll(uint32_t en)
 822 {
 823         u32 reg;
 824         s32 timeout = 100000;
 825
 826         /* Enable PLLs */
 827         reg = readl(&anatop->pll_enet);
 828         reg &= ~BM_ANADIG_PLL_ENET_POWERDOWN;
 829         writel(reg, &anatop->pll_enet);
 830         reg |= BM_ANADIG_PLL_ENET_ENABLE;
 831         while (timeout--) {
 832                 if (readl(&anatop->pll_enet) & BM_ANADIG_PLL_ENET_LOCK)
 833                         break;
 834         }
 835         if (timeout <= 0)
 836                 return -EIO;
 837         reg &= ~BM_ANADIG_PLL_ENET_BYPASS;
 838         writel(reg, &anatop->pll_enet);
 839         reg |= en;
 840         writel(reg, &anatop->pll_enet);
 841         return 0;
 842 }
 843
 844 #ifndef CONFIG_SOC_MX6SX
 845 static void ungate_sata_clock(void)
 846 {
 847         struct mxc_ccm_reg *const imx_ccm =
 848                 (struct mxc_ccm_reg *)CCM_BASE_ADDR;
 849
 850         /* Enable SATA clock. */
 851         setbits_le32(&imx_ccm->CCGR5, MXC_CCM_CCGR5_SATA_MASK);
 852 }
 853 #endif
 854
 855 static void ungate_pcie_clock(void)
 856 {
 857         struct mxc_ccm_reg *const imx_ccm =
 858                 (struct mxc_ccm_reg *)CCM_BASE_ADDR;
 859
 860         /* Enable PCIe clock. */
 861         setbits_le32(&imx_ccm->CCGR4, MXC_CCM_CCGR4_PCIE_MASK);
 862 }
 863
 864 #ifndef CONFIG_SOC_MX6SX
 865 int enable_sata_clock(void)
 866 {
 867         ungate_sata_clock();
 868         return enable_enet_pll(BM_ANADIG_PLL_ENET_ENABLE_SATA);
 869 }
 870
 871 void disable_sata_clock(void)
 872 {
 873         struct mxc_ccm_reg *const imx_ccm =
 874                 (struct mxc_ccm_reg *)CCM_BASE_ADDR;
 875
 876         clrbits_le32(&imx_ccm->CCGR5, MXC_CCM_CCGR5_SATA_MASK);
 877 }
 878 #endif
 879
 880 int enable_pcie_clock(void)
 881 {
 882         struct anatop_regs *anatop_regs =
 883                 (struct anatop_regs *)ANATOP_BASE_ADDR;
 884         struct mxc_ccm_reg *ccm_regs = (struct mxc_ccm_reg *)CCM_BASE_ADDR;
 885         u32 lvds1_clk_sel;
 886
 887         /*
 888          * Here be dragons!
 889          *
 890          * The register ANATOP_MISC1 is not documented in the Freescale
 891          * MX6RM. The register that is mapped in the ANATOP space and
 892          * marked as ANATOP_MISC1 is actually documented in the PMU section
 893          * of the datasheet as PMU_MISC1.
 894          *
 895          * Switch LVDS clock source to SATA (0xb) on mx6q/dl or PCI (0xa) on
 896          * mx6sx, disable clock INPUT and enable clock OUTPUT. This is important
 897          * for PCI express link that is clocked from the i.MX6.
 898          */
 899 #define ANADIG_ANA_MISC1_LVDSCLK1_IBEN          (1 << 12)
 900 #define ANADIG_ANA_MISC1_LVDSCLK1_OBEN          (1 << 10)
 901 #define ANADIG_ANA_MISC1_LVDS1_CLK_SEL_MASK     0x0000001F
 902 #define ANADIG_ANA_MISC1_LVDS1_CLK_SEL_PCIE_REF 0xa
 903 #define ANADIG_ANA_MISC1_LVDS1_CLK_SEL_SATA_REF 0xb
 904
 905         if (is_cpu_type(MXC_CPU_MX6SX))
 906                 lvds1_clk_sel = ANADIG_ANA_MISC1_LVDS1_CLK_SEL_PCIE_REF;
 907         else
 908                 lvds1_clk_sel = ANADIG_ANA_MISC1_LVDS1_CLK_SEL_SATA_REF;
 909
 910         clrsetbits_le32(&anatop_regs->ana_misc1,
 911                         ANADIG_ANA_MISC1_LVDSCLK1_IBEN |
 912                         ANADIG_ANA_MISC1_LVDS1_CLK_SEL_MASK,
 913                         ANADIG_ANA_MISC1_LVDSCLK1_OBEN | lvds1_clk_sel);
 914
 915         /* PCIe reference clock sourced from AXI. */
 916         clrbits_le32(&ccm_regs->cbcmr, MXC_CCM_CBCMR_PCIE_AXI_CLK_SEL);
 917
 918         /* Party time! Ungate the clock to the PCIe. */
 919 #ifndef CONFIG_SOC_MX6SX
 920         ungate_sata_clock();
 921 #endif
 922         ungate_pcie_clock();
 923
 924         return enable_enet_pll(BM_ANADIG_PLL_ENET_ENABLE_SATA |
 925                                BM_ANADIG_PLL_ENET_ENABLE_PCIE);
 926 }
 927
 928 #ifdef CONFIG_SECURE_BOOT
 929 void hab_caam_clock_enable(unsigned char enable)
 930 {
 931         u32 reg;
 932
 933         /* CG4 ~ CG6, CAAM clocks */
 934         reg = __raw_readl(&imx_ccm->CCGR0);
 935         if (enable)
 936                 reg |= (MXC_CCM_CCGR0_CAAM_WRAPPER_IPG_MASK |
 937                         MXC_CCM_CCGR0_CAAM_WRAPPER_ACLK_MASK |
 938                         MXC_CCM_CCGR0_CAAM_SECURE_MEM_MASK);
 939         else
 940                 reg &= ~(MXC_CCM_CCGR0_CAAM_WRAPPER_IPG_MASK |
 941                         MXC_CCM_CCGR0_CAAM_WRAPPER_ACLK_MASK |
 942                         MXC_CCM_CCGR0_CAAM_SECURE_MEM_MASK);
 943         __raw_writel(reg, &imx_ccm->CCGR0);
 944
 945         /* EMI slow clk */
 946         reg = __raw_readl(&imx_ccm->CCGR6);
 947         if (enable)
 948                 reg |= MXC_CCM_CCGR6_EMI_SLOW_MASK;
 949         else
 950                 reg &= ~MXC_CCM_CCGR6_EMI_SLOW_MASK;
 951         __raw_writel(reg, &imx_ccm->CCGR6);
 952 }
 953 #endif
 954
 955 static void enable_pll3(void)
 956 {
 957         struct anatop_regs __iomem *anatop =
 958                 (struct anatop_regs __iomem *)ANATOP_BASE_ADDR;
 959
 960         /* make sure pll3 is enabled */
 961         if ((readl(&anatop->usb1_pll_480_ctrl) &
 962                         BM_ANADIG_USB_PLL_480_CTRL_LOCK) == 0) {
 963                 /* enable pll's power */
 964                 writel(BM_ANADIG_USB_PLL_480_CTRL_POWER,
 965                        &anatop->usb1_pll_480_ctrl_set);
 966                 writel(0x80, &anatop->ana_misc2_clr);
 967                 /* wait for pll lock */
 968                 while ((readl(&anatop->usb1_pll_480_ctrl) &
 969                         BM_ANADIG_USB_PLL_480_CTRL_LOCK) == 0)
 970                         ;
 971                 /* disable bypass */
 972                 writel(BM_ANADIG_USB_PLL_480_CTRL_BYPASS,
 973                        &anatop->usb1_pll_480_ctrl_clr);
 974                 /* enable pll output */
 975                 writel(BM_ANADIG_USB_PLL_480_CTRL_ENABLE,
 976                        &anatop->usb1_pll_480_ctrl_set);
 977         }
 978 }
 979
 980 void enable_thermal_clk(void)
 981 {
 982         enable_pll3();
 983 }
 984
 985 void ipu_clk_enable(void)
 986 {
 987         u32 reg = readl(&imx_ccm->CCGR3);
 988         reg |= MXC_CCM_CCGR3_IPU1_IPU_MASK;
 989         writel(reg, &imx_ccm->CCGR3);
 990 }
 991
 992 void ipu_clk_disable(void)
 993 {
 994         u32 reg = readl(&imx_ccm->CCGR3);
 995         reg &= ~MXC_CCM_CCGR3_IPU1_IPU_MASK;
 996         writel(reg, &imx_ccm->CCGR3);
 997 }
 998
 999 void ipu_di_clk_enable(int di)
1000 {
1001         switch (di) {
1002         case 0:
1003                 setbits_le32(&imx_ccm->CCGR3,
1004                         MXC_CCM_CCGR3_IPU1_IPU_DI0_MASK);
1005                 break;
1006         case 1:
1007                 setbits_le32(&imx_ccm->CCGR3,
1008                         MXC_CCM_CCGR3_IPU1_IPU_DI1_MASK);
1009                 break;
1010         default:
1011                 printf("%s: Invalid DI index %d\n", __func__, di);
1012         }
1013 }
1014
1015 void ipu_di_clk_disable(int di)
1016 {
1017         switch (di) {
1018         case 0:
1019                 clrbits_le32(&imx_ccm->CCGR3,
1020                         MXC_CCM_CCGR3_IPU1_IPU_DI0_MASK);
1021                 break;
1022         case 1:
1023                 clrbits_le32(&imx_ccm->CCGR3,
1024                         MXC_CCM_CCGR3_IPU1_IPU_DI1_MASK);
1025                 break;
1026         default:
1027                 printf("%s: Invalid DI index %d\n", __func__, di);
1028         }
1029 }
1030
1031 void ldb_clk_enable(int ldb)
1032 {
1033         switch (ldb) {
1034         case 0:
1035                 setbits_le32(&imx_ccm->CCGR3,
1036                         MXC_CCM_CCGR3_LDB_DI0_MASK);
1037                 break;
1038         case 1:
1039                 setbits_le32(&imx_ccm->CCGR3,
1040                         MXC_CCM_CCGR3_LDB_DI1_MASK);
1041                 break;
1042         default:
1043                 printf("%s: Invalid LDB index %d\n", __func__, ldb);
1044         }
1045 }
1046
1047 void ldb_clk_disable(int ldb)
1048 {
1049         switch (ldb) {
1050         case 0:
1051                 clrbits_le32(&imx_ccm->CCGR3,
1052                         MXC_CCM_CCGR3_LDB_DI0_MASK);
1053                 break;
1054         case 1:
1055                 clrbits_le32(&imx_ccm->CCGR3,
1056                         MXC_CCM_CCGR3_LDB_DI1_MASK);
1057                 break;
1058         default:
1059                 printf("%s: Invalid LDB index %d\n", __func__, ldb);
1060         }
1061 }
1062
1063 void ocotp_clk_enable(void)
1064 {
1065         u32 reg = readl(&imx_ccm->CCGR2);
1066         reg |= MXC_CCM_CCGR2_OCOTP_CTRL_MASK;
1067         writel(reg, &imx_ccm->CCGR2);
1068 }
1069
1070 void ocotp_clk_disable(void)
1071 {
1072         u32 reg = readl(&imx_ccm->CCGR2);
1073         reg &= ~MXC_CCM_CCGR2_OCOTP_CTRL_MASK;
1074         writel(reg, &imx_ccm->CCGR2);
1075 }
1076
1077 unsigned int mxc_get_clock(enum mxc_clock clk)
1078 {
1079         switch (clk) {
1080         case MXC_ARM_CLK:
1081                 return get_mcu_main_clk();
1082         case MXC_PER_CLK:
1083                 return get_periph_clk();
1084         case MXC_AHB_CLK:
1085                 return get_ahb_clk();
1086         case MXC_IPG_CLK:
1087                 return get_ipg_clk();
1088         case MXC_IPG_PERCLK:
1089         case MXC_I2C_CLK:
1090                 return get_ipg_per_clk();
1091         case MXC_UART_CLK:
1092                 return get_uart_clk();
1093         case MXC_CSPI_CLK:
1094                 return get_cspi_clk();
1095         case MXC_AXI_CLK:
1096                 return get_axi_clk();
1097         case MXC_EMI_SLOW_CLK:
1098                 return get_emi_slow_clk();
1099         case MXC_DDR_CLK:
1100                 return get_mmdc_ch0_clk();
1101         case MXC_ESDHC_CLK:
1102                 return get_usdhc_clk(0);
1103         case MXC_ESDHC2_CLK:
1104                 return get_usdhc_clk(1);
1105         case MXC_ESDHC3_CLK:
1106                 return get_usdhc_clk(2);
1107         case MXC_ESDHC4_CLK:
1108                 return get_usdhc_clk(3);
1109         case MXC_SATA_CLK:
1110                 return get_ahb_clk();
1111         case MXC_NFC_CLK:
1112                 return get_nfc_clk();
1113         default:
1114                 printf("Unsupported MXC CLK: %d\n", clk);
1115         }
1116
1117         return 0;
1118 }
1119
1120 static inline int gcd(int m, int n)
1121 {
1122         int t;
1123         while (m > 0) {
1124                 if (n > m) {
1125                         t = m;
1126                         m = n;
1127                         n = t;
1128                 } /* swap */
1129                 m -= n;
1130         }
1131         return n;
1132 }
1133
1134 /* Config CPU clock */
1135 static int set_arm_clk(u32 ref, u32 freq_khz)
1136 {
1137         int d;
1138         int div = 0;
1139         int mul = 0;
1140         u32 min_err = ~0;
1141         u32 reg;
1142
1143         if (freq_khz > ref / 1000 * 108 / 2 || freq_khz < ref / 1000 * 54 / 8 / 2) {
1144                 printf("Frequency %u.%03uMHz is out of range: %u.%03u..%u.%03u\n",
1145                         freq_khz / 1000, freq_khz % 1000,
1146                         54 * ref / 1000000 / 8 / 2, 54 * ref / 1000 / 8 / 2 % 1000,
1147                         108 * ref / 1000000 / 2, 108 * ref / 1000 / 2 % 1000);
1148                 return -EINVAL;
1149         }
1150
1151         for (d = DIV_ROUND_UP(648000, freq_khz); d <= 8; d++) {
1152                 int m = freq_khz * 2 * d / (ref / 1000);
1153                 u32 f;
1154                 u32 err;
1155
1156                 if (m > 108) {
1157                         debug("%s@%d: d=%d m=%d\n", __func__, __LINE__,
1158                                 d, m);
1159                         break;
1160                 }
1161
1162                 f = ref * m / d / 2;
1163                 if (f > freq_khz * 1000) {
1164                         debug("%s@%d: d=%d m=%d f=%u freq=%u\n", __func__, __LINE__,
1165                                 d, m, f, freq_khz);
1166                         if (--m < 54)
1167                                 return -EINVAL;
1168                         f = ref * m / d / 2;
1169                 }
1170                 err = freq_khz * 1000 - f;
1171                 debug("%s@%d: d=%d m=%d f=%u freq=%u err=%d\n", __func__, __LINE__,
1172                         d, m, f, freq_khz, err);
1173                 if (err < min_err) {
1174                         mul = m;
1175                         div = d;
1176                         min_err = err;
1177                         if (err == 0)
1178                                 break;
1179                 }
1180         }
1181         if (min_err == ~0)
1182                 return -EINVAL;
1183         debug("Setting M=%3u D=%2u for %u.%03uMHz (actual: %u.%03uMHz)\n",
1184                 mul, div, freq_khz / 1000, freq_khz % 1000,
1185                 ref * mul / 2 / div / 1000000, ref * mul / 2 / div / 1000 % 1000);
1186
1187         reg = readl(&anatop->pll_arm);
1188         debug("anadig_pll_arm=%08x -> %08x\n",
1189                 reg, (reg & ~0x7f) | mul);
1190
1191         reg |= 1 << 16;
1192         writel(reg, &anatop->pll_arm); /* bypass PLL */
1193
1194         reg = (reg & ~0x7f) | mul;
1195         writel(reg, &anatop->pll_arm);
1196
1197         writel(div - 1, &imx_ccm->cacrr);
1198
1199         reg &= ~(1 << 16);
1200         writel(reg, &anatop->pll_arm); /* disable PLL bypass */
1201
1202         return 0;
1203 }
1204
1205 /*
1206  * This function assumes the expected core clock has to be changed by
1207  * modifying the PLL. This is NOT true always but for most of the times,
1208  * it is. So it assumes the PLL output freq is the same as the expected
1209  * core clock (presc=1) unless the core clock is less than PLL_FREQ_MIN.
1210  * In the latter case, it will try to increase the presc value until
1211  * (presc*core_clk) is greater than PLL_FREQ_MIN. It then makes call to
1212  * calc_pll_params() and obtains the values of PD, MFI,MFN, MFD based
1213  * on the targeted PLL and reference input clock to the PLL. Lastly,
1214  * it sets the register based on these values along with the dividers.
1215  * Note 1) There is no value checking for the passed-in divider values
1216  *         so the caller has to make sure those values are sensible.
1217  *      2) Also adjust the NFC divider such that the NFC clock doesn't
1218  *         exceed NFC_CLK_MAX.
1219  *      3) IPU HSP clock is independent of AHB clock. Even it can go up to
1220  *         177MHz for higher voltage, this function fixes the max to 133MHz.
1221  *      4) This function should not have allowed diag_printf() calls since
1222  *         the serial driver has been stoped. But leave then here to allow
1223  *         easy debugging by NOT calling the cyg_hal_plf_serial_stop().
1224  */
1225 int mxc_set_clock(u32 ref, u32 freq, enum mxc_clock clk)
1226 {
1227         int ret;
1228
1229         freq *= 1000;
1230
1231         switch (clk) {
1232         case MXC_ARM_CLK:
1233                 ret = set_arm_clk(ref, freq);
1234                 break;
1235
1236         case MXC_NFC_CLK:
1237                 ret = set_nfc_clk(ref, freq);
1238                 break;
1239
1240         default:
1241                 printf("Warning: Unsupported or invalid clock type: %d\n",
1242                         clk);
1243                 return -EINVAL;
1244         }
1245
1246         return ret;
1247 }
1248
1249 /*
1250  * Dump some core clocks.
1251  */
1252 #define print_pll(pll)  {                               \
1253         u32 __pll = decode_pll(pll, MXC_HCLK);          \
1254         printf("%-12s %4d.%03d MHz\n", #pll,            \
1255                 __pll / 1000000, __pll / 1000 % 1000);  \
1256         }
1257
1258 #define MXC_IPG_PER_CLK MXC_IPG_PERCLK
1259
1260 #define print_clk(clk)  {                               \
1261         u32 __clk = mxc_get_clock(MXC_##clk##_CLK);     \
1262         printf("%-12s %4d.%03d MHz\n", #clk,            \
1263                 __clk / 1000000, __clk / 1000 % 1000);  \
1264         }
1265
1266 #define print_pfd(pll, pfd)     {                                       \
1267         u32 __pfd = readl(&anatop->pfd_##pll);                          \
1268         if (__pfd & (0x80 << 8 * pfd)) {                                \
1269                 printf("PFD_%s[%d]      OFF\n", #pll, pfd);             \
1270         } else {                                                        \
1271                 __pfd = (__pfd >> 8 * pfd) & 0x3f;                      \
1272                 printf("PFD_%s[%d]   %4d.%03d MHz\n", #pll, pfd,        \
1273                         pll * 18 / __pfd,                               \
1274                         pll * 18 * 1000 / __pfd % 1000);                \
1275         }                                                               \
1276 }
1277
1278 static void do_mx6_showclocks(void)
1279 {
1280         print_pll(PLL_ARM);
1281         print_pll(PLL_528);
1282         print_pll(PLL_USBOTG);
1283         print_pll(PLL_AUDIO);
1284         print_pll(PLL_VIDEO);
1285         print_pll(PLL_ENET);
1286         print_pll(PLL_USB2);
1287         printf("\n");
1288
1289         print_pfd(480, 0);
1290         print_pfd(480, 1);
1291         print_pfd(480, 2);
1292         print_pfd(480, 3);
1293         print_pfd(528, 0);
1294         print_pfd(528, 1);
1295         print_pfd(528, 2);
1296         printf("\n");
1297
1298         print_clk(IPG);
1299         print_clk(UART);
1300         print_clk(CSPI);
1301         print_clk(AHB);
1302         print_clk(AXI);
1303         print_clk(DDR);
1304         print_clk(ESDHC);
1305         print_clk(ESDHC2);
1306         print_clk(ESDHC3);
1307         print_clk(ESDHC4);
1308         print_clk(EMI_SLOW);
1309         print_clk(NFC);
1310         print_clk(IPG_PER);
1311         print_clk(ARM);
1312 }
1313
1314 static struct clk_lookup {
1315         const char *name;
1316         unsigned int index;
1317 } mx6_clk_lookup[] = {
1318         { "arm", MXC_ARM_CLK, },
1319         { "nfc", MXC_NFC_CLK, },
1320 };
1321
1322 int do_clocks(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
1323 {
1324         int i;
1325         unsigned long freq;
1326         unsigned long ref = ~0UL;
1327
1328         if (argc < 2) {
1329                 do_mx6_showclocks();
1330                 return CMD_RET_SUCCESS;
1331         } else if (argc == 2 || argc > 4) {
1332                 return CMD_RET_USAGE;
1333         }
1334
1335         freq = simple_strtoul(argv[2], NULL, 0);
1336         if (freq == 0) {
1337                 printf("Invalid clock frequency %lu\n", freq);
1338                 return CMD_RET_FAILURE;
1339         }
1340         if (argc > 3) {
1341                 ref = simple_strtoul(argv[3], NULL, 0);
1342         }
1343         for (i = 0; i < ARRAY_SIZE(mx6_clk_lookup); i++) {
1344                 if (strcasecmp(argv[1], mx6_clk_lookup[i].name) == 0) {
1345                         switch (mx6_clk_lookup[i].index) {
1346                         case MXC_ARM_CLK:
1347                                 if (argc > 3)
1348                                         return CMD_RET_USAGE;
1349                                 ref = MXC_HCLK;
1350                                 break;
1351
1352                         case MXC_NFC_CLK:
1353                                 if (argc > 3 && ref > 3) {
1354                                         printf("Invalid clock selector value: %lu\n", ref);
1355                                         return CMD_RET_FAILURE;
1356                                 }
1357                                 break;
1358                         }
1359                         printf("Setting %s clock to %lu MHz\n",
1360                                 mx6_clk_lookup[i].name, freq);
1361                         if (mxc_set_clock(ref, freq, mx6_clk_lookup[i].index))
1362                                 break;
1363                         freq = mxc_get_clock(mx6_clk_lookup[i].index);
1364                         printf("%s clock set to %lu.%03lu MHz\n",
1365                                 mx6_clk_lookup[i].name,
1366                                 freq / 1000000, freq / 1000 % 1000);
1367                         return CMD_RET_SUCCESS;
1368                 }
1369         }
1370         if (i == ARRAY_SIZE(mx6_clk_lookup)) {
1371                 printf("clock %s not found; supported clocks are:\n", argv[1]);
1372                 for (i = 0; i < ARRAY_SIZE(mx6_clk_lookup); i++) {
1373                         printf("\t%s\n", mx6_clk_lookup[i].name);
1374                 }
1375         } else {
1376                 printf("Failed to set clock %s to %s MHz\n",
1377                         argv[1], argv[2]);
1378         }
1379         return CMD_RET_FAILURE;
1380 }
1381
1382 #ifndef CONFIG_SOC_MX6SX
1383 void enable_ipu_clock(void)
1384 {
1385         struct mxc_ccm_reg *mxc_ccm = (struct mxc_ccm_reg *)CCM_BASE_ADDR;
1386         int reg;
1387         reg = readl(&mxc_ccm->CCGR3);
1388         reg |= MXC_CCM_CCGR3_IPU1_IPU_MASK;
1389         writel(reg, &mxc_ccm->CCGR3);
1390 }
1391 #endif
1392 /***************************************************/
1393
1394 U_BOOT_CMD(
1395         clocks, 4, 0, do_clocks,
1396         "display/set clocks",
1397         "                    - display clock settings\n"
1398         "clocks <clkname> <freq>    - set clock <clkname> to <freq> MHz"
1399 );