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
  34 enum pll_clocks {
  35         PLL1_CLOCK = 0,
  36         PLL2_CLOCK,
  37         PLL3_CLOCK,
  38         PLL4_CLOCK,
  39         PLL_CLOCKS,
  40 };
  41
  42 struct mxc_pll_reg *mxc_plls[PLL_CLOCKS] = {
  43         [PLL1_CLOCK] = (struct mxc_pll_reg *)PLL1_BASE_ADDR,
  44         [PLL2_CLOCK] = (struct mxc_pll_reg *)PLL2_BASE_ADDR,
  45         [PLL3_CLOCK] = (struct mxc_pll_reg *)PLL3_BASE_ADDR,
  46 #ifdef  CONFIG_MX53
  47         [PLL4_CLOCK] = (struct mxc_pll_reg *)PLL4_BASE_ADDR,
  48 #endif
  49 };
  50
  51 struct mxc_ccm_reg *mxc_ccm = (struct mxc_ccm_reg *)MXC_CCM_BASE;
  52
  53 /*
  54  * Calculate the frequency of PLLn.
  55  */
  56 static uint32_t decode_pll(struct mxc_pll_reg *pll, uint32_t infreq)
  57 {
  58         uint32_t ctrl, op, mfd, mfn, mfi, pdf, ret;
  59         uint64_t refclk, temp;
  60         int32_t mfn_abs;
  61
  62         ctrl = readl(&pll->ctrl);
  63
  64         if (ctrl & MXC_DPLLC_CTL_HFSM) {
  65                 mfn = __raw_readl(&pll->hfs_mfn);
  66                 mfd = __raw_readl(&pll->hfs_mfd);
  67                 op = __raw_readl(&pll->hfs_op);
  68         } else {
  69                 mfn = __raw_readl(&pll->mfn);
  70                 mfd = __raw_readl(&pll->mfd);
  71                 op = __raw_readl(&pll->op);
  72         }
  73
  74         mfd &= MXC_DPLLC_MFD_MFD_MASK;
  75         mfn &= MXC_DPLLC_MFN_MFN_MASK;
  76         pdf = op & MXC_DPLLC_OP_PDF_MASK;
  77         mfi = (op & MXC_DPLLC_OP_MFI_MASK) >> MXC_DPLLC_OP_MFI_OFFSET;
  78
  79         /* 21.2.3 */
  80         if (mfi < 5)
  81                 mfi = 5;
  82
  83         /* Sign extend */
  84         if (mfn >= 0x04000000) {
  85                 mfn |= 0xfc000000;
  86                 mfn_abs = -mfn;
  87         } else
  88                 mfn_abs = mfn;
  89
  90         refclk = infreq * 2;
  91         if (ctrl & MXC_DPLLC_CTL_DPDCK0_2_EN)
  92                 refclk *= 2;
  93
  94         do_div(refclk, pdf + 1);
  95         temp = refclk * mfn_abs;
  96         do_div(temp, mfd + 1);
  97         ret = refclk * mfi;
  98
  99         if ((int)mfn < 0)
 100                 ret -= temp;
 101         else
 102                 ret += temp;
 103
 104         return ret;
 105 }
 106
 107 /*
 108  * Get mcu main rate
 109  */
 110 u32 get_mcu_main_clk(void)
 111 {
 112         u32 reg, freq;
 113
 114         reg = (__raw_readl(&mxc_ccm->cacrr) & MXC_CCM_CACRR_ARM_PODF_MASK) >>
 115                 MXC_CCM_CACRR_ARM_PODF_OFFSET;
 116         freq = decode_pll(mxc_plls[PLL1_CLOCK], CONFIG_SYS_MX5_HCLK);
 117         return freq / (reg + 1);
 118 }
 119
 120 /*
 121  * Get the rate of peripheral's root clock.
 122  */
 123 static u32 get_periph_clk(void)
 124 {
 125         u32 reg;
 126
 127         reg = __raw_readl(&mxc_ccm->cbcdr);
 128         if (!(reg & MXC_CCM_CBCDR_PERIPH_CLK_SEL))
 129                 return decode_pll(mxc_plls[PLL2_CLOCK], CONFIG_SYS_MX5_HCLK);
 130         reg = __raw_readl(&mxc_ccm->cbcmr);
 131         switch ((reg & MXC_CCM_CBCMR_PERIPH_CLK_SEL_MASK) >>
 132                 MXC_CCM_CBCMR_PERIPH_CLK_SEL_OFFSET) {
 133         case 0:
 134                 return decode_pll(mxc_plls[PLL1_CLOCK], CONFIG_SYS_MX5_HCLK);
 135         case 1:
 136                 return decode_pll(mxc_plls[PLL3_CLOCK], CONFIG_SYS_MX5_HCLK);
 137         default:
 138                 return 0;
 139         }
 140         /* NOTREACHED */
 141 }
 142
 143 /*
 144  * Get the rate of ahb clock.
 145  */
 146 static u32 get_ahb_clk(void)
 147 {
 148         uint32_t freq, div, reg;
 149
 150         freq = get_periph_clk();
 151
 152         reg = __raw_readl(&mxc_ccm->cbcdr);
 153         div = ((reg & MXC_CCM_CBCDR_AHB_PODF_MASK) >>
 154                         MXC_CCM_CBCDR_AHB_PODF_OFFSET) + 1;
 155
 156         return freq / div;
 157 }
 158
 159 /*
 160  * Get the rate of ipg clock.
 161  */
 162 static u32 get_ipg_clk(void)
 163 {
 164         uint32_t freq, reg, div;
 165
 166         freq = get_ahb_clk();
 167
 168         reg = __raw_readl(&mxc_ccm->cbcdr);
 169         div = ((reg & MXC_CCM_CBCDR_IPG_PODF_MASK) >>
 170                         MXC_CCM_CBCDR_IPG_PODF_OFFSET) + 1;
 171
 172         return freq / div;
 173 }
 174
 175 /*
 176  * Get the rate of ipg_per clock.
 177  */
 178 static u32 get_ipg_per_clk(void)
 179 {
 180         u32 pred1, pred2, podf;
 181
 182         if (__raw_readl(&mxc_ccm->cbcmr) & MXC_CCM_CBCMR_PERCLK_IPG_CLK_SEL)
 183                 return get_ipg_clk();
 184         /* Fixme: not handle what about lpm*/
 185         podf = __raw_readl(&mxc_ccm->cbcdr);
 186         pred1 = (podf & MXC_CCM_CBCDR_PERCLK_PRED1_MASK) >>
 187                 MXC_CCM_CBCDR_PERCLK_PRED1_OFFSET;
 188         pred2 = (podf & MXC_CCM_CBCDR_PERCLK_PRED2_MASK) >>
 189                 MXC_CCM_CBCDR_PERCLK_PRED2_OFFSET;
 190         podf = (podf & MXC_CCM_CBCDR_PERCLK_PODF_MASK) >>
 191                 MXC_CCM_CBCDR_PERCLK_PODF_OFFSET;
 192
 193         return get_periph_clk() / ((pred1 + 1) * (pred2 + 1) * (podf + 1));
 194 }
 195
 196 /*
 197  * Get the rate of uart clk.
 198  */
 199 static u32 get_uart_clk(void)
 200 {
 201         unsigned int freq, reg, pred, podf;
 202
 203         reg = __raw_readl(&mxc_ccm->cscmr1);
 204         switch ((reg & MXC_CCM_CSCMR1_UART_CLK_SEL_MASK) >>
 205                 MXC_CCM_CSCMR1_UART_CLK_SEL_OFFSET) {
 206         case 0x0:
 207                 freq = decode_pll(mxc_plls[PLL1_CLOCK],
 208                                     CONFIG_SYS_MX5_HCLK);
 209                 break;
 210         case 0x1:
 211                 freq = decode_pll(mxc_plls[PLL2_CLOCK],
 212                                     CONFIG_SYS_MX5_HCLK);
 213                 break;
 214         case 0x2:
 215                 freq = decode_pll(mxc_plls[PLL3_CLOCK],
 216                                     CONFIG_SYS_MX5_HCLK);
 217                 break;
 218         default:
 219                 return 66500000;
 220         }
 221
 222         reg = __raw_readl(&mxc_ccm->cscdr1);
 223
 224         pred = (reg & MXC_CCM_CSCDR1_UART_CLK_PRED_MASK) >>
 225                 MXC_CCM_CSCDR1_UART_CLK_PRED_OFFSET;
 226
 227         podf = (reg & MXC_CCM_CSCDR1_UART_CLK_PODF_MASK) >>
 228                 MXC_CCM_CSCDR1_UART_CLK_PODF_OFFSET;
 229         freq /= (pred + 1) * (podf + 1);
 230
 231         return freq;
 232 }
 233
 234 /*
 235  * This function returns the low power audio clock.
 236  */
 237 u32 get_lp_apm(void)
 238 {
 239         u32 ret_val = 0;
 240         u32 ccsr = __raw_readl(&mxc_ccm->ccsr);
 241
 242         if (((ccsr >> 9) & 1) == 0)
 243                 ret_val = CONFIG_SYS_MX5_HCLK;
 244         else
 245                 ret_val = ((32768 * 1024));
 246
 247         return ret_val;
 248 }
 249
 250 /*
 251  * get cspi clock rate.
 252  */
 253 u32 imx_get_cspiclk(void)
 254 {
 255         u32 ret_val = 0, pdf, pre_pdf, clk_sel;
 256         u32 cscmr1 = __raw_readl(&mxc_ccm->cscmr1);
 257         u32 cscdr2 = __raw_readl(&mxc_ccm->cscdr2);
 258
 259         pre_pdf = (cscdr2 & MXC_CCM_CSCDR2_CSPI_CLK_PRED_MASK) \
 260                         >> MXC_CCM_CSCDR2_CSPI_CLK_PRED_OFFSET;
 261         pdf = (cscdr2 & MXC_CCM_CSCDR2_CSPI_CLK_PODF_MASK) \
 262                         >> MXC_CCM_CSCDR2_CSPI_CLK_PODF_OFFSET;
 263         clk_sel = (cscmr1 & MXC_CCM_CSCMR1_CSPI_CLK_SEL_MASK) \
 264                         >> MXC_CCM_CSCMR1_CSPI_CLK_SEL_OFFSET;
 265
 266         switch (clk_sel) {
 267         case 0:
 268                 ret_val = decode_pll(mxc_plls[PLL1_CLOCK],
 269                                         CONFIG_SYS_MX5_HCLK) /
 270                                         ((pre_pdf + 1) * (pdf + 1));
 271                 break;
 272         case 1:
 273                 ret_val = decode_pll(mxc_plls[PLL2_CLOCK],
 274                                         CONFIG_SYS_MX5_HCLK) /
 275                                         ((pre_pdf + 1) * (pdf + 1));
 276                 break;
 277         case 2:
 278                 ret_val = decode_pll(mxc_plls[PLL3_CLOCK],
 279                                         CONFIG_SYS_MX5_HCLK) /
 280                                         ((pre_pdf + 1) * (pdf + 1));
 281                 break;
 282         default:
 283                 ret_val = get_lp_apm() / ((pre_pdf + 1) * (pdf + 1));
 284                 break;
 285         }
 286
 287         return ret_val;
 288 }
 289
 290 /*
 291  * The API of get mxc clockes.
 292  */
 293 unsigned int mxc_get_clock(enum mxc_clock clk)
 294 {
 295         switch (clk) {
 296         case MXC_ARM_CLK:
 297                 return get_mcu_main_clk();
 298         case MXC_AHB_CLK:
 299                 return get_ahb_clk();
 300         case MXC_IPG_CLK:
 301                 return get_ipg_clk();
 302         case MXC_IPG_PERCLK:
 303                 return get_ipg_per_clk();
 304         case MXC_UART_CLK:
 305                 return get_uart_clk();
 306         case MXC_CSPI_CLK:
 307                 return imx_get_cspiclk();
 308         case MXC_FEC_CLK:
 309                 return decode_pll(mxc_plls[PLL1_CLOCK],
 310                                     CONFIG_SYS_MX5_HCLK);
 311         default:
 312                 break;
 313         }
 314         return -1;
 315 }
 316
 317 u32 imx_get_uartclk(void)
 318 {
 319         return get_uart_clk();
 320 }
 321
 322
 323 u32 imx_get_fecclk(void)
 324 {
 325         return mxc_get_clock(MXC_IPG_CLK);
 326 }
 327
 328 /*
 329  * Dump some core clockes.
 330  */
 331 int do_mx5_showclocks(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 332 {
 333         u32 freq;
 334
 335         freq = decode_pll(mxc_plls[PLL1_CLOCK], CONFIG_SYS_MX5_HCLK);
 336         printf("PLL1       %8d MHz\n", freq / 1000000);
 337         freq = decode_pll(mxc_plls[PLL2_CLOCK], CONFIG_SYS_MX5_HCLK);
 338         printf("PLL2       %8d MHz\n", freq / 1000000);
 339         freq = decode_pll(mxc_plls[PLL3_CLOCK], CONFIG_SYS_MX5_HCLK);
 340         printf("PLL3       %8d MHz\n", freq / 1000000);
 341 #ifdef  CONFIG_MX53
 342         freq = decode_pll(mxc_plls[PLL4_CLOCK], CONFIG_SYS_MX5_HCLK);
 343         printf("PLL4       %8d MHz\n", freq / 1000000);
 344 #endif
 345
 346         printf("\n");
 347         printf("AHB        %8d kHz\n", mxc_get_clock(MXC_AHB_CLK) / 1000);
 348         printf("IPG        %8d kHz\n", mxc_get_clock(MXC_IPG_CLK) / 1000);
 349         printf("IPG PERCLK %8d kHz\n", mxc_get_clock(MXC_IPG_PERCLK) / 1000);
 350
 351         return 0;
 352 }
 353
 354 /***************************************************/
 355
 356 U_BOOT_CMD(
 357         clocks, CONFIG_SYS_MAXARGS, 1, do_mx5_showclocks,
 358         "display clocks",
 359         ""
 360 );