packages/hal/arm/mxc91321/var/v2_0/src/cmds.c

   1 //==========================================================================
   2 //
   3 //      cmds.c
   4 //
   5 //      SoC [platform] specific RedBoot commands
   6 //
   7 //==========================================================================
   8 //####ECOSGPLCOPYRIGHTBEGIN####
   9 // -------------------------------------------
  10 // This file is part of eCos, the Embedded Configurable Operating System.
  11 // Copyright (C) 1998, 1999, 2000, 2001, 2002 Red Hat, Inc.
  12 //
  13 // eCos is free software; you can redistribute it and/or modify it under
  14 // the terms of the GNU General Public License as published by the Free
  15 // Software Foundation; either version 2 or (at your option) any later version.
  16 //
  17 // eCos is distributed in the hope that it will be useful, but WITHOUT ANY
  18 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  19 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  20 // for more details.
  21 //
  22 // You should have received a copy of the GNU General Public License along
  23 // with eCos; if not, write to the Free Software Foundation, Inc.,
  24 // 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  25 //
  26 // As a special exception, if other files instantiate templates or use macros
  27 // or inline functions from this file, or you compile this file and link it
  28 // with other works to produce a work based on this file, this file does not
  29 // by itself cause the resulting work to be covered by the GNU General Public
  30 // License. However the source code for this file must still be made available
  31 // in accordance with section (3) of the GNU General Public License.
  32 //
  33 // This exception does not invalidate any other reasons why a work based on
  34 // this file might be covered by the GNU General Public License.
  35 //
  36 // Alternative licenses for eCos may be arranged by contacting Red Hat, Inc.
  37 // at http://sources.redhat.com/ecos/ecos-license/
  38 // -------------------------------------------
  39 //####ECOSGPLCOPYRIGHTEND####
  40 //==========================================================================
  41 #include <redboot.h>
  42 #include <cyg/hal/hal_intr.h>
  43 #include <cyg/hal/plf_mmap.h>
  44 #include <cyg/hal/hal_soc.h>         // Hardware definitions
  45 #include <cyg/hal/hal_cache.h>
  46
  47 typedef unsigned long long  u64;
  48 typedef unsigned int        u32;
  49 typedef unsigned short      u16;
  50 typedef unsigned char       u8;
  51
  52 #define SZ_DEC_1M       1000000
  53 #define PLL_PD_MAX      16      //actual pd+1
  54 #define PLL_MFI_MAX     15
  55 #define PLL_MFI_MIN     5
  56 #define PLL_MFD_MAX     1024    //actual mfd+1
  57 #define PLL_MFN_MAX     511
  58 #define IPG_DIV_MAX     4
  59 #define AHB_DIV_MAX     8
  60 #define HSP_PODF_MAX    8
  61 #define NFC_PODF_MAX    8
  62
  63 #if (PLL_REF_CLK == FREQ_32768HZ) || (PLL_REF_CLK == FREQ_32000HZ)
  64 #define PLL_MFD_FIXED   1024
  65 #endif
  66 #if (PLL_REF_CLK == FREQ_26MHZ)
  67 #define PLL_MFD_FIXED   (26 * 16)       // =416
  68 #endif
  69
  70 #define PLL_FREQ_MAX    (2 * PLL_REF_CLK * PLL_MFI_MAX)
  71 #define TPLL_FREQ_MAX   534000000
  72 #define PLL_FREQ_MIN    ((2 * PLL_REF_CLK * (PLL_MFI_MIN - 1)) / PLL_PD_MAX)
  73 #define AHB_CLK_MAX     133333333
  74 #define IPG_CLK_MAX     (AHB_CLK_MAX / 2)
  75 #define NFC_CLK_MAX     25000000
  76 // IPU-HSP clock is independent of the HCLK and can go up to 177MHz but requires
  77 // higher voltage support. For simplicity, limit it to 133MHz
  78 #define HSP_CLK_MAX     133333333
  79
  80 #define ERR_WRONG_CLK   -1
  81 #define ERR_NO_MFI      -2
  82 #define ERR_NO_MFN      -3
  83 #define ERR_NO_PD       -4
  84 #define ERR_NO_AHB_DIV  -6
  85
  86 u32 pll_clock(enum plls pll);
  87 u32 get_main_clock(enum main_clocks clk);
  88 u32 get_peri_clock(enum peri_clocks clk);
  89 int poll_fuse_set(void);
  90 int gcd(int m, int n);
  91
  92 static void clock_setup(int argc, char *argv[]);
  93 static void ckol(int argc, char *argv[]);
  94 static void ckoh(int argc, char *argv[]);
  95
  96 RedBoot_cmd("clock",
  97             "Setup/Display clock (max AHB=133MHz, max IPG=66.5MHz)\nSyntax:",
  98             "[<core clock in MHz> [:<AHB-to-core divider>[:<IPG-to-AHB divider>]]] \n\n\
  99 If a divider is zero or no divider is specified, the optimal divider values \n\
 100 will be chosen. It does NOT do integer freq scaling so no brmm value changes.\n\
 101 Instead, it always adjusts the PLL settings. \n\
 102 Examples:\n\
 103    [clock]         -> Show various clocks\n\
 104    [clock 399]     -> Core=399  AHB=133           IPG=66.5\n\
 105    [clock 200]     -> Core=200  AHB=100           IPG=50\n\
 106    [clock 399:6]   -> Core=399  AHB=66.5(Core/6)  IPG=66.5\n\
 107    [clock 399:6:2] -> Core=399  AHB=66.5(Core/6)  IPG=33.25(AHB/2)\n",
 108             clock_setup
 109            );
 110
 111 /*!
 112  * This is to calculate various parameters based on reference clock and
 113  * targeted clock based on the equation:
 114  *      t_clk = 2*ref_freq*(mfi + mfn/(mfd+1))/(pd+1)
 115  * This calculation is based on a fixed MFD value for simplicity.
 116  *
 117  * @param ref       reference clock freq
 118  * @param target    targeted clock in HZ
 119  * @param p_pd      calculated pd value (pd value from register + 1) upon return
 120  * @param p_mfi     calculated actual mfi value upon return
 121  * @param p_mfn     calculated actual mfn value upon return
 122  * @param p_mfd     fixed mfd value (mfd value from register + 1) upon return
 123  *
 124  * @return          0 if successful; non-zero otherwise.
 125  */
 126 int calc_pll_params(u32 ref, u32 target, u32 *p_pd,
 127                     u32 *p_mfi, u32 *p_mfn, u32 *p_mfd)
 128 {
 129     u64 pd, mfi, mfn, n_target = (u64)target, n_ref = (u64)ref;
 130
 131     // Make sure targeted freq is in the valid range. Otherwise the
 132     // following calculation might be wrong!!!
 133     if (target < PLL_FREQ_MIN || target > PLL_FREQ_MAX) {
 134         return ERR_WRONG_CLK;
 135     }
 136     // Use n_target and n_ref to avoid overflow
 137     for (pd = 1; pd <= PLL_PD_MAX; pd++) {
 138         mfi = (n_target * pd) / (2 * n_ref);
 139         if (mfi > PLL_MFI_MAX) {
 140             return ERR_NO_MFI;
 141         } else if (mfi < 5) {
 142             continue;
 143         }
 144         break;
 145     }
 146     // Now got pd and mfi already
 147     mfn = (((n_target * pd) / 2 - n_ref * mfi) * PLL_MFD_FIXED) / n_ref;
 148     // Check mfn within limit and mfn < denominator
 149     if (mfn > PLL_MFN_MAX || mfn >= PLL_MFD_FIXED) {
 150         return ERR_NO_MFN;
 151     }
 152
 153     if (pd > PLL_PD_MAX) {
 154         return ERR_NO_PD;
 155     }
 156     *p_pd = (u32)pd;
 157     *p_mfi = (u32)mfi;
 158     *p_mfn = (u32)mfn;
 159     *p_mfd = PLL_MFD_FIXED;
 160     return 0;
 161 }
 162
 163 /*!
 164  * This function assumes the expected core clock has to be changed by
 165  * modifying the PLL. This is NOT true always but for most of the times,
 166  * it is. So it assumes the PLL output freq is the same as the expected
 167  * core clock (presc=1) unless the core clock is less than PLL_FREQ_MIN.
 168  * In the latter case, it will try to increase the presc value until
 169  * (presc*core_clk) is greater than PLL_FREQ_MIN. It then makes call to
 170  * calc_pll_params() and obtains the values of PD, MFI,MFN, MFD based
 171  * on the targeted PLL and reference input clock to the PLL. Lastly,
 172  * it sets the register based on these values along with the dividers.
 173  * Note 1) There is no value checking for the passed-in divider values
 174  *         so the caller has to make sure those values are sensible.
 175  *      2) Also adjust the NFC divider such that the NFC clock doesn't
 176  *         exceed NFC_CLK_MAX.
 177  *      3) IPU HSP clock is independent of AHB clock. Even it can go up to
 178  *         177MHz for higher voltage, this function fixes the max to 133MHz.
 179  *      4) This function should not have allowed diag_printf() calls since
 180  *         the serial driver has been stoped. But leave then here to allow
 181  *         easy debugging by NOT calling the cyg_hal_plf_serial_stop().
 182  *
 183  * @param ref       pll input reference clock (32KHz or 26MHz)
 184  * @param core_clk  core clock in Hz
 185  * @param ahb_div   ahb divider to divide the core clock to get ahb clock
 186  *                  (ahb_div - 1) needs to be set in the register
 187  * @param ipg_div   ipg divider to divide the ahb clock to get ipg clock
 188  *                  (ipg_div - 1) needs to be set in the register
 189  # @return          0 if successful; non-zero otherwise
 190  */
 191 int configure_clock(u32 ref, u32 core_clk, u32 ahb_div, u32 ipg_div)
 192 {
 193     u32 pll, pd, mfi, mfn, mfd, brmo = 0, pctl0;
 194     u32 pdr0, nfc_div, ahb_clk = core_clk / ahb_div;
 195     int ret, i;
 196
 197     // assume pll default to core clock first
 198     pll = core_clk;
 199     // when core_clk >= PLL_FREQ_MIN, the presc can be 1.
 200     // Otherwise, need to calculate presc value below and adjust the targeted pll
 201     if (core_clk < PLL_FREQ_MIN) {
 202         diag_printf("can't make core_clk=%d\n", core_clk);
 203         return ERR_WRONG_CLK;
 204     }
 205
 206     // get nfc_div - make sure optimal NFC clock but less than NFC_CLK_MAX
 207     for (nfc_div = 1; nfc_div <= NFC_PODF_MAX; nfc_div++) {
 208         if ((pll / (ahb_div * nfc_div)) <= NFC_CLK_MAX) {
 209             break;
 210         }
 211     }
 212
 213     // pll is now the targeted pll output. Use it along with ref input clock
 214     // to get pd, mfi, mfn, mfd
 215     if ((ret = calc_pll_params(ref, pll, &pd, &mfi, &mfn, &mfd)) != 0) {
 216         diag_printf("can't find pll parameters: %d\n", ret);
 217         return ret;
 218     }
 219 #ifdef CMD_CLOCK_DEBUG
 220     diag_printf("ref=%d, pll=%d, pd=%d, mfi=%d,mfn=%d, mfd=%d\n",
 221                 ref, pll, pd, mfi, mfn, mfd);
 222 #endif
 223
 224     // blindly increase divider first to avoid too fast ahbclk and ipgclk
 225     // in case the core clock increases too much
 226     pdr0 = readl(CRM_MCU_BASE_ADDR + CLKCTL_PDR0);
 227     pdr0 &= ~0x000007F8;
 228     // increase the dividers. should work even when core clock is 832 (26*2*16)MHz
 229     // which is unlikely true.
 230     pdr0 |= (1 << 6) | (6 << 3);
 231     writel(pdr0, CRM_MCU_BASE_ADDR + CLKCTL_PDR0);
 232     // calculate new pdr0. Also clear the brmm bits
 233     pdr0 &= ~0x000007FF;
 234     pdr0 |= ((nfc_div - 1) << 8) | ((ipg_div - 1) << 6) | ((ahb_div - 1) << 3);
 235
 236     // update PLL register
 237     if ((mfd >= (10 * mfn)) || ((10 * mfn) >= (9 * mfd)))
 238         brmo = 1;
 239
 240     pctl0 = readl(CRM_MCU_BASE_ADDR + CLKCTL_MPCTL);
 241     pctl0 = (pctl0 & 0x40008000)  |
 242             (brmo << 31)           |
 243             ((pd - 1) << 26)       |
 244             ((mfd - 1) << 16)      |
 245             (mfi << 11)            |
 246             mfn;
 247     writel(pctl0, CRM_MCU_BASE_ADDR + CLKCTL_MPCTL);
 248     writel(pdr0, CRM_MCU_BASE_ADDR + CLKCTL_PDR0);
 249     // add some delay for new values to take effect
 250     for (i = 0; i < 10000; i++);
 251
 252     // --------------- now adjust for TPLL ---------------------------
 253     pll = (TPLL_FREQ_MAX / ahb_clk) * ahb_clk;
 254     if ((ret = calc_pll_params(ref, pll, &pd, &mfi, &mfn, &mfd)) != 0) {
 255         diag_printf("can't find tpll parameters: %d\n", ret);
 256         return ret;
 257     }
 258 #ifdef CMD_CLOCK_DEBUG
 259     diag_printf("ref=%d, pll=%d, pd=%d, mfi=%d,mfn=%d, mfd=%d\n",
 260                 ref, pll, pd, mfi, mfn, mfd);
 261 #endif
 262
 263     // update PLL register
 264     if ((mfd >= (10 * mfn)) || ((10 * mfn) >= (9 * mfd)))
 265         brmo = 1;
 266
 267     pctl0 = readl(CRM_MCU_BASE_ADDR + CLKCTL_TPCTL);
 268     pctl0 = (pctl0 & 0x40008000)  |
 269             (brmo << 31)           |
 270             ((pd - 1) << 26)       |
 271             ((mfd - 1) << 16)      |
 272             (mfi << 11)            |
 273             mfn;
 274     writel(pctl0, CRM_MCU_BASE_ADDR + CLKCTL_TPCTL);
 275
 276     return 0;
 277 }
 278
 279 static void clock_setup(int argc,char *argv[])
 280 {
 281     u32 i, core_clk, ipg_div, data[3],
 282     ahb_div, ahb_clk, ipg_clk;
 283     int ret;
 284
 285     if (argc == 1)
 286         goto print_clock;
 287     for (i = 0;  i < 3;  i++) {
 288         unsigned long temp;
 289         if (!parse_num(*(&argv[1]), &temp, &argv[1], ":")) {
 290             diag_printf("Error: Invalid parameter\n");
 291             return;
 292         }
 293         data[i] = temp;
 294     }
 295
 296     core_clk = data[0] * SZ_DEC_1M;
 297     ahb_div = data[1];  // actual register field + 1
 298     ipg_div = data[2];  // actual register field + 1
 299
 300     if (core_clk < PLL_FREQ_MIN || core_clk > PLL_FREQ_MAX) {
 301         diag_printf("Targeted core clock should be within [%d - %d]\n",
 302                     PLL_FREQ_MIN, PLL_FREQ_MAX);
 303         return;
 304     }
 305
 306     // find the ahb divider
 307     if (ahb_div > AHB_DIV_MAX) {
 308         diag_printf("Invalid AHB divider: %d. Maximum value is %d\n",
 309                     ahb_div, AHB_DIV_MAX);
 310         return;
 311     }
 312     if (ahb_div == 0) {
 313         // no HCLK divider specified
 314         for (ahb_div = 1; ; ahb_div++) {
 315             if ((core_clk / ahb_div) <= AHB_CLK_MAX) {
 316                 break;
 317             }
 318         }
 319     }
 320     if (ahb_div > AHB_DIV_MAX || (core_clk / ahb_div) > AHB_CLK_MAX) {
 321         diag_printf("Can't make AHB=%d since max=%d\n",
 322                     core_clk / ahb_div, AHB_CLK_MAX);
 323         return;
 324     }
 325
 326     // find the ipg divider
 327     ahb_clk = core_clk / ahb_div;
 328     if (ipg_div > IPG_DIV_MAX) {
 329         diag_printf("Invalid IPG divider: %d. Maximum value is %d\n",
 330                     ipg_div, IPG_DIV_MAX);
 331         return;
 332     }
 333     if (ipg_div == 0) {
 334         ipg_div++;          // At least =1
 335         if (ahb_clk > IPG_CLK_MAX)
 336             ipg_div++;      // Make it =2
 337     }
 338     if (ipg_div > IPG_DIV_MAX || (ahb_clk / ipg_div) > IPG_CLK_MAX) {
 339         diag_printf("Can't make IPG=%d since max=%d\n",
 340                     (ahb_clk / ipg_div), IPG_CLK_MAX);
 341         return;
 342     }
 343     ipg_clk = ahb_clk / ipg_div;
 344
 345     diag_printf("Trying to set core=%d ahb=%d ipg=%d...\n",
 346                 core_clk, ahb_clk, ipg_clk);
 347
 348     // stop the serial to be ready to adjust the clock
 349     hal_delay_us(100000);
 350     cyg_hal_plf_serial_stop();
 351     // adjust the clock
 352     ret = configure_clock(PLL_REF_CLK, core_clk, ahb_div, ipg_div);
 353     // restart the serial driver
 354     cyg_hal_plf_serial_init();
 355     hal_delay_us(100000);
 356
 357     if (ret != 0) {
 358         diag_printf("Failed to setup clock: %d\n", ret);
 359         return;
 360     }
 361     diag_printf("\n<<<New clock setting>>>\n");
 362
 363     // Now printing clocks
 364 print_clock:
 365 #ifdef CYGPKG_HAL_ARM_MXC91321_CHIP
 366     diag_printf("\nMPLL\t\tUPLL\t\tTPLL\n");
 367     diag_printf("================================================\n");
 368     diag_printf("%-16d%-16d%-16d\n\n",
 369                 pll_clock(MCU_PLL), pll_clock(USB_PLL), pll_clock(TUR_PLL));
 370 #endif
 371
 372     diag_printf("CPU\t\tAHB\t\tIPG\t\tNFC\t\tUSB\n");
 373     diag_printf("===========================================");
 374     diag_printf("=============================\n");
 375     diag_printf("%-16d%-16d%-16d%-16d%-16d\n\n",
 376                 get_main_clock(CPU_CLK),
 377                 get_main_clock(AHB_CLK),
 378                 get_main_clock(IPG_CLK),
 379                 get_main_clock(NFC_CLK),
 380                 get_main_clock(USB_CLK));
 381
 382     diag_printf("UART1/2/3/4\tSSI1\t\tSSI2\t\tCSI\t\tFIRI\n");
 383     diag_printf("===========================================");
 384     diag_printf("=============================\n");
 385
 386     diag_printf("%-16d%-16d%-16d%-16d%-16d\n\n",
 387                 get_peri_clock(UART1_BAUD),
 388                 get_peri_clock(SSI1_BAUD),
 389                 get_peri_clock(SSI2_BAUD),
 390                 get_peri_clock(CSI_BAUD),
 391                 get_peri_clock(FIRI_BAUD));
 392 }
 393
 394 /*!
 395  * This function returns the PLL output value in Hz based on pll.
 396  */
 397 u32 pll_clock(enum plls pll)
 398 {
 399     u64 mfi, mfn, mfd, pdf, ref_clk, pll_out, sign;
 400     u64 reg = readl(pll);
 401
 402     pdf = (reg >> 26) & 0xF;
 403     mfd = (reg >> 16) & 0x3FF;
 404     if (pll == MCU_PLL || pll == TUR_PLL) {
 405         mfi = (reg >> 11) & 0xF;
 406         mfi = (mfi <= 5) ? 5: mfi;
 407         mfn = reg & 0x7FF;
 408         sign = (mfn < 1024) ? 0: 1;
 409         mfn = (mfn <= 0x400) ? mfn: (0x800 - mfn);
 410     } else {
 411         sign = 0;
 412         mfi = (reg >> 10) & 0xF;
 413         mfi = (mfi <= 5) ? 5: mfi;
 414         mfn = reg & 0x3FF;
 415     }
 416
 417     /* Scale down to avoid overflow */
 418     ref_clk = PLL_REF_CLK;
 419     if (ref_clk == 0) {
 420         diag_printf("Error: fix input clock first for %s() to work\n",
 421                     __FUNCTION__);
 422         return 0;
 423     }
 424
 425     if (sign == 0) {
 426         pll_out = (2 * ref_clk * mfi + ((2 * ref_clk * mfn) / (mfd + 1))) /
 427                   (pdf + 1);
 428     } else {
 429         pll_out = (2 * ref_clk * mfi - ((2 * ref_clk * mfn) / (mfd + 1))) /
 430                   (pdf + 1);
 431     }
 432
 433     return (u32)pll_out;
 434 }
 435
 436 #define NORMALIZE_FACTOR    10
 437
 438 void clock_spi_enable(unsigned int spi_clk)
 439 {
 440     if (spi_clk == SPI1_CLK) {
 441         // do nothing now as it is already enabled by default
 442     } else if (spi_clk == SPI2_CLK) {
 443         // do nothing now as it is already enabled by default
 444     }
 445 }
 446
 447 /*!
 448  * This function returns the main clock value in Hz.
 449  */
 450 u32 get_main_clock(enum main_clocks clk)
 451 {
 452     u32 brmm, max_pdf, ipg_pdf, nfc_pdf, csi_pdf;
 453     u32 pll, ret_val = 0, hclk, usb_pdf, div;
 454     enum plls CORE_PLL_SEL = MCU_PLL;
 455
 456     volatile u32 reg = readl(CRM_MCU_BASE_ADDR + CLKCTL_PDR0);
 457     volatile u32 reg1 = readl(CRM_MCU_BASE_ADDR + CLKCTL_PDR1);
 458     brmm = reg & 0x7;
 459     max_pdf = (reg >> 3) & 0x7;
 460     ipg_pdf = (reg >> 6) & 0x3;
 461     nfc_pdf = (reg >> 8) & 0x7;
 462     csi_pdf = reg >> 23;
 463     usb_pdf = (reg1 >> 27) & 0x7;
 464
 465 #ifdef CYGPKG_HAL_ARM_MXC91321_CHIP
 466     if ((readl(CRM_MCU_BASE_ADDR + CLKCTL_PDR0) & (1 << 11)) != 0) {
 467         CORE_PLL_SEL = TUR_PLL;
 468     }
 469 #endif
 470
 471     switch (clk) {
 472     case CPU_CLK:
 473         pll = pll_clock(CORE_PLL_SEL);
 474         if (brmm >= 5) {
 475             diag_printf("Wrong BRMM value in the CRM_AP, MPDR0 reg \n");
 476             return 0;
 477         }
 478         hclk = pll / (max_pdf + 1);
 479         div = (pll * NORMALIZE_FACTOR) / hclk;
 480         switch (brmm) {
 481         case 0:
 482             ret_val = pll;
 483             break;
 484         case 1:
 485             // new period = (2*MCU_period + 1*AHB_period)/3
 486             // => new freq = (3*pll*hclk)/(2*hclk+pll)
 487             // => new frq = (3*pll)/(2+pll/hclk). Also normalize it.
 488             ret_val = (3* pll * NORMALIZE_FACTOR) /
 489                 ((2 * NORMALIZE_FACTOR) + ((pll * NORMALIZE_FACTOR) / hclk));
 490             break;
 491         case 2:
 492             // new period = (1*MCU_period + 1*AHB_period)/2
 493             // => new freq = (2*pll*hclk)/(hclk+pll)
 494             // => new frq = (2*pll)/(1+pll/hclk). Also normalize it.
 495             ret_val = (2* pll * NORMALIZE_FACTOR) /
 496                 ((1 * NORMALIZE_FACTOR) + ((pll * NORMALIZE_FACTOR) / hclk));
 497             break;
 498         case 3:
 499             // new period = (1*MCU_period + 2*AHB_period)/3
 500             // => new freq = (3*pll*hclk)/(hclk+2*pll)
 501             // => new frq = (3*pll)/(1+(2*pll)/hclk). Also normalize it.
 502             ret_val = (3* pll * NORMALIZE_FACTOR) /
 503                 ((1 * NORMALIZE_FACTOR) + ((2 * pll * NORMALIZE_FACTOR) / hclk));
 504             break;
 505         case 4:
 506             ret_val = hclk;
 507             break;
 508         default:
 509             break;
 510         }
 511         break;
 512     case AHB_CLK:
 513         pll = pll_clock(CORE_PLL_SEL);
 514         ret_val = pll / (max_pdf + 1);
 515         break;
 516     case IPG_CLK:
 517         pll = pll_clock(CORE_PLL_SEL);
 518         ret_val = pll / ((max_pdf + 1) * (ipg_pdf + 1));
 519         break;
 520     case NFC_CLK:
 521         pll = pll_clock(CORE_PLL_SEL);
 522         ret_val = pll / ((max_pdf + 1) * (nfc_pdf + 1));
 523         break;
 524     case USB_CLK:
 525         pll = pll_clock(USB_PLL);
 526         ret_val = pll / (usb_pdf + 1);
 527         break;
 528     default:
 529         diag_printf("%s(): This clock: %d not supported yet \n",
 530                     __FUNCTION__, clk);
 531         break;
 532     }
 533
 534     return ret_val;
 535 }
 536
 537 #ifdef CYGPKG_HAL_ARM_MXC91321_CHIP
 538 static u32 csi_sdhc_clock_src(u32 clksrc)
 539 {
 540     u32 val = 0;
 541
 542     switch (clksrc) {
 543     case 0:
 544         val = pll_clock(USB_PLL);
 545         break;
 546     case 1:
 547         val = pll_clock(MCU_PLL);
 548         break;
 549     case 2:
 550         val = pll_clock(TUR_PLL);
 551         break;
 552     case 3:
 553         val = FREQ_26MHZ;
 554         break;
 555     }
 556
 557     return val;
 558 }
 559 #endif
 560 /*!
 561  * This function returns the peripheral clock value in Hz.
 562  */
 563 u32 get_peri_clock(enum peri_clocks clk)
 564 {
 565     volatile u32 mcr = readl(CRM_MCU_BASE_ADDR + CLKCTL_MCR);
 566     volatile u32 mpdr0 = readl(CRM_MCU_BASE_ADDR + CLKCTL_PDR0);
 567     volatile u32 mpdr1 = readl(CRM_MCU_BASE_ADDR + CLKCTL_PDR1);
 568     u32 clk_sel, pre_pdf, pdf, ref_clk, ret_val = 0;
 569
 570     switch (clk) {
 571     case UART1_BAUD:
 572     case UART2_BAUD:
 573     case UART3_BAUD:
 574     case UART4_BAUD:
 575         return get_main_clock(IPG_CLK);
 576         break;
 577     case SSI1_BAUD:
 578         pre_pdf = (mpdr1 >> 6) & 0x7;
 579         pdf = (mpdr1 >> 1) & 0x1F;
 580         clk_sel = mcr & (1 << 28);
 581         ref_clk = (clk_sel != 0) ? pll_clock(USB_PLL) : pll_clock(MCU_PLL);
 582         ret_val = ref_clk / ((pre_pdf + 1) * (pdf + 1));
 583         break;
 584     case SSI2_BAUD:
 585         pre_pdf = (mpdr1 >> 15) & 0x7;
 586         pdf = (mpdr1 >> 10) & 0x1F;
 587         clk_sel = mcr & (1 << 27);
 588         ref_clk = (clk_sel != 0) ? pll_clock(USB_PLL) : pll_clock(MCU_PLL);
 589         ret_val = ref_clk / ((pre_pdf + 1) * (pdf + 1));
 590         break;
 591
 592 #ifdef CYGPKG_HAL_ARM_MXC91321_CHIP
 593         clk_sel = (mcr >> 25) & 0x3;
 594         pdf = ((mpdr0 >> 23) & 0x1FF) + 1;
 595         pdf = (2 * pdf) + (mpdr0 & (1 << 22)); //multiplied by 2
 596         pdf *= (1 + (mpdr0 & (1 << 21)));
 597
 598         ret_val = (2 * csi_sdhc_clock_src(clk_sel)) / pdf;
 599 #endif
 600         break;
 601     case FIRI_BAUD:
 602         pre_pdf = (mpdr1 >> 24) & 0x7;
 603         pdf = (mpdr1 >> 19) & 0x1F;
 604         clk_sel = mcr & (1 << 11);
 605         ref_clk = (clk_sel != 0) ? pll_clock(USB_PLL) : pll_clock(MCU_PLL);
 606         ret_val = ref_clk / ((pre_pdf + 1) * (pdf + 1));
 607         break;
 608     case SPI1_CLK:
 609     case SPI2_CLK:
 610         ret_val = get_main_clock(IPG_CLK);
 611         break;
 612     default:
 613         diag_printf("%s(): This clock: %d not supported yet \n",
 614                     __FUNCTION__, clk);
 615         break;
 616     }
 617
 618     return ret_val;
 619 }
 620
 621 RedBoot_cmd("ckol",
 622             "Select clock source for CKO1 (AKA CKO) (J10 on the EVB CPU daughter card)",
 623             " The output is 1/8 of actual clock. Default is MCU_PLL\n\
 624           <0> - display current cko selection\n\
 625           <1> - MCU_PLL \n\
 626           <2> - CKIH \n\
 627           <3> - USB_PLL \n\
 628           <4} - DSP_PLL \n\
 629           <5> - WB_PAT_REF \n\
 630           <6> - RESERVED \n\
 631           <7> - RESERVED \n\
 632           <8> - MB_PAT_REF \n",
 633             ckol
 634            );
 635
 636 static u8* cko_name[] = {
 637     "NULL",
 638     "MCU_PLL",
 639     "CKIH",
 640     "USB_PLL",
 641     "DSP_PLL",
 642     "WB_PAT_REF",
 643     "RESERVED",
 644     "RESERVED",
 645     "MB_PAT_REF",
 646 };
 647
 648 #define CKO_MAX_INDEX           (sizeof(cko_name) / sizeof(u8*))
 649 #define CKO_DIV                 3  // default divide by 8
 650 #define CKOH_DIV                3  // default divide by 8
 651
 652 static void ckol(int argc,char *argv[])
 653 {
 654     u32 action = 0, cosr;
 655
 656     if (!scan_opts(argc, argv, 1, 0, 0, (void*) &action,
 657                    OPTION_ARG_TYPE_NUM, "action"))
 658         return;
 659
 660     if (action >= CKO_MAX_INDEX) {
 661         diag_printf("%d is not supported\n\n", action);
 662         return;
 663     }
 664
 665     cosr = readl(CRM_MCU_BASE_ADDR + CLKCTL_COSR);
 666
 667     if (action != 0) {
 668         cosr = (cosr & (~0x7F)) + (1 << 6) + (CKO_DIV << 3) + action - 1;
 669         writel(cosr, CRM_MCU_BASE_ADDR + CLKCTL_COSR);
 670         diag_printf("Set clko to ");
 671     }
 672
 673     cosr = readl(CRM_MCU_BASE_ADDR + CLKCTL_COSR);
 674     diag_printf("%s\n", cko_name[(cosr & 0x7) + 1]);
 675     diag_printf("COSR register[0x%x] = 0x%x\n",
 676                 (CRM_MCU_BASE_ADDR + CLKCTL_COSR), cosr);
 677 }
 678
 679 RedBoot_cmd("ckoh",
 680             "Select clock source for CKO2 (J9 on the EVB CPU daughter card)",
 681             " The default is 1/8 of IPG_CLK_ARM (core clock)\n\
 682           <0> - display current cko selection\n\
 683           <1> - MCU_PLL \n\
 684           <2> - REC_64KHZ \n\
 685           <3> - USB_PLL \n\
 686           <4} - DSP_PLL \n\
 687           <5> - WB_PLL \n\
 688           <6> - RESERVED \n\
 689           <7> - RESERVED \n\
 690           <8> - WCSI_RX \n\
 691           <9> - NFC_CLK \n\
 692           <10> - MCU_AHB_CLK \n\
 693           <11> - IPG_CLK_S \n\
 694           <12> - IPG_CLK \n\
 695           <13> - DSP_AHB_CLK \n\
 696           <14> - IPG_CLK_ARM (Core) \n\
 697           <15> - PAT_REF_CLK_SYNC \n\
 698           <16> - WB_PAT_REF_CLK_SYNC \n\
 699           <17> - TURBO_PLL (MXC91321 only)\n\
 700           <18> - AFC_PLL (MXC91321 only) \n",
 701             ckoh
 702            );
 703
 704 static u8* div_str[] = {
 705     "original ",
 706     "1/2 of ",
 707     "1/4 of ",
 708     "1/8 of ",
 709     "1/16 of ",
 710     "unknown of ",
 711     "unknown of ",
 712     "unknown of ",
 713 };
 714
 715 static u8* ckoh_name[] ={
 716     "NULL",
 717     "MCU_PLL",
 718     "REC_64KHZ",
 719     "USB_PLL",
 720     "DSP_PLL",
 721     "WB_PLL",
 722     "RESERVED",
 723     "RESERVED",
 724     "WCSI_RX",
 725     "NFC_CLK",
 726     "MCU_AHB_CLK",
 727     "IPG_CLK_S",
 728     "IPG_CLK",
 729     "DSP_AHB_CLK",
 730     "IPG_CLK_ARM (Core)",
 731     "PAT_REF_CLK_SYNC",
 732     "WB_PAT_REF_CLK_SYNC",
 733 #ifdef CYGPKG_HAL_ARM_MXC91321_CHIP
 734     "TURBO_PLL",
 735     "AFC_PLL",
 736 #endif
 737 };
 738
 739 #define CKOH_MAX_INDEX           (sizeof(ckoh_name) / sizeof(u8*))
 740
 741 static void ckoh(int argc,char *argv[])
 742 {
 743     u32 action = 0, cosr, div = 0, i, j;
 744
 745     if (!scan_opts(argc, argv, 1, 0, 0, (void*) &action,
 746                    OPTION_ARG_TYPE_NUM, "action"))
 747         return;
 748
 749     if (action >= CKOH_MAX_INDEX) {
 750         diag_printf("%d is not supported\n\n", action);
 751         return;
 752     }
 753
 754     cosr = readl(CRM_MCU_BASE_ADDR + CLKCTL_COSR);
 755
 756     if (action != 0) {
 757         if (action == 1 || action == 3 || action == 4 || action == 5 || action == 14 || action == 17)
 758             div = CKOH_DIV;
 759         cosr = (cosr & (~0x0007FC00)) + (div << 10) + (1 << 13) +
 760                ((action - 1) << 14);
 761         writel(cosr, CRM_MCU_BASE_ADDR + CLKCTL_COSR);
 762         diag_printf("Set clko to ");
 763     }
 764
 765     cosr = readl(CRM_MCU_BASE_ADDR + CLKCTL_COSR);
 766     i = (cosr >> 10) & 0x7;
 767     j = (cosr >> 14) & 0x1F;
 768     diag_printf("%s%s\n", div_str[i], ckoh_name[j + 1]);
 769     diag_printf("COSR register[0x%x] = 0x%x\n",
 770                 (CRM_MCU_BASE_ADDR + CLKCTL_COSR), cosr);
 771 }
 772
 773 #ifdef L2CC_ENABLED
 774 /*
 775  * This command is added for some simple testing only. It turns on/off
 776  * L2 cache regardless of L1 cache state. The side effect of this is
 777  * when doing any flash operations such as "fis init", the L2
 778  * will be turned back on along with L1 caches even though it is off
 779  * by using this command.
 780  */
 781 RedBoot_cmd("L2",
 782             "L2 cache",
 783             "[ON | OFF]",
 784             do_L2_caches
 785            );
 786
 787 void do_L2_caches(int argc, char *argv[])
 788 {
 789     u32 oldints;
 790     int L2cache_on=0;
 791
 792     if (argc == 2) {
 793         if (strcasecmp(argv[1], "on") == 0) {
 794             HAL_DISABLE_INTERRUPTS(oldints);
 795             HAL_ENABLE_L2();
 796             HAL_RESTORE_INTERRUPTS(oldints);
 797         } else if (strcasecmp(argv[1], "off") == 0) {
 798             HAL_DISABLE_INTERRUPTS(oldints);
 799             HAL_CLEAN_INVALIDATE_L2();
 800             HAL_DISABLE_L2();
 801             HAL_RESTORE_INTERRUPTS(oldints);
 802         } else {
 803             diag_printf("Invalid L2 cache mode: %s\n", argv[1]);
 804         }
 805     } else {
 806         HAL_L2CACHE_IS_ENABLED(L2cache_on);
 807         diag_printf("L2 cache: %s\n", L2cache_on?"On":"Off");
 808     }
 809 }
 810 #endif //L2CC_ENABLED
 811
 812 #define IIM_ERR_SHIFT       8
 813 #define POLL_FUSE_PRGD      (IIM_STAT_PRGD | (IIM_ERR_PRGE << IIM_ERR_SHIFT))
 814 #define POLL_FUSE_SNSD      (IIM_STAT_SNSD | (IIM_ERR_SNSE << IIM_ERR_SHIFT))
 815
 816 static void fuse_op_start(void)
 817 {
 818     /* Do not generate interrupt */
 819     writel(0, IIM_BASE_ADDR + IIM_STATM_OFF);
 820     // clear the status bits and error bits
 821     writel(0x3, IIM_BASE_ADDR + IIM_STAT_OFF);
 822     writel(0xFE, IIM_BASE_ADDR + IIM_ERR_OFF);
 823 }
 824
 825 /*
 826  * The action should be either:
 827  *          POLL_FUSE_PRGD
 828  * or:
 829  *          POLL_FUSE_SNSD
 830  */
 831 static int poll_fuse_op_done(int action)
 832 {
 833
 834     u32 status, error;
 835
 836     if (action != POLL_FUSE_PRGD && action != POLL_FUSE_SNSD) {
 837         diag_printf("%s(%d) invalid operation\n", __FUNCTION__, action);
 838         return -1;
 839     }
 840
 841     /* Poll busy bit till it is NOT set */
 842     while ((readl(IIM_BASE_ADDR + IIM_STAT_OFF) & IIM_STAT_BUSY) != 0 ) {
 843     }
 844
 845     /* Test for successful write */
 846     status = readl(IIM_BASE_ADDR + IIM_STAT_OFF);
 847     error = readl(IIM_BASE_ADDR + IIM_ERR_OFF);
 848
 849     if ((status & action) != 0 && (error & (action >> IIM_ERR_SHIFT)) == 0) {
 850         if (error) {
 851             diag_printf("Even though the operation seems successful...\n");
 852             diag_printf("There are some error(s) at addr=0x%x: 0x%x\n",
 853                         (IIM_BASE_ADDR + IIM_ERR_OFF), error);
 854         }
 855         return 0;
 856     }
 857     diag_printf("%s(%d) failed\n", __FUNCTION__, action);
 858     diag_printf("status address=0x%x, value=0x%x\n",
 859                 (IIM_BASE_ADDR + IIM_STAT_OFF), status);
 860     diag_printf("There are some error(s) at addr=0x%x: 0x%x\n",
 861                 (IIM_BASE_ADDR + IIM_ERR_OFF), error);
 862     return -1;
 863 }
 864
 865 static void sense_fuse(int bank, int row, int bit)
 866 {
 867     int addr, addr_l, addr_h, reg_addr;
 868
 869     fuse_op_start();
 870
 871     addr = ((bank << 11) | (row << 3) | (bit & 0x7));
 872     /* Set IIM Program Upper Address */
 873     addr_h = (addr >> 8) & 0x000000FF;
 874     /* Set IIM Program Lower Address */
 875     addr_l = (addr & 0x000000FF);
 876
 877 #ifdef IIM_FUSE_DEBUG
 878     diag_printf("%s: addr_h=0x%x, addr_l=0x%x\n",
 879                 __FUNCTION__, addr_h, addr_l);
 880 #endif
 881     writel(addr_h, IIM_BASE_ADDR + IIM_UA_OFF);
 882     writel(addr_l, IIM_BASE_ADDR + IIM_LA_OFF);
 883     /* Start sensing */
 884     writel(0x8, IIM_BASE_ADDR + IIM_FCTL_OFF);
 885     if (poll_fuse_op_done(POLL_FUSE_SNSD) != 0) {
 886         diag_printf("%s(bank: %d, row: %d, bit: %d failed\n",
 887                     __FUNCTION__, bank, row, bit);
 888     }
 889     reg_addr = IIM_BASE_ADDR + IIM_SDAT_OFF;
 890     diag_printf("fuses at (bank:%d, row:%d) = 0x%x\n", bank, row, readl(reg_addr));
 891 }
 892
 893 void do_fuse_read(int argc, char *argv[])
 894 {
 895     int bank, row;
 896
 897     if (argc == 1) {
 898         diag_printf("Useage: fuse_read <bank> <row>\n");
 899         return;
 900     } else if (argc == 3) {
 901         if (!parse_num(*(&argv[1]), (unsigned long *)&bank, &argv[1], " ")) {
 902                 diag_printf("Error: Invalid parameter\n");
 903             return;
 904         }
 905         if (!parse_num(*(&argv[2]), (unsigned long *)&row, &argv[2], " ")) {
 906                 diag_printf("Error: Invalid parameter\n");
 907                 return;
 908             }
 909
 910         diag_printf("Read fuse at bank:%d row:%d\n", bank, row);
 911         sense_fuse(bank, row, 0);
 912
 913     } else {
 914         diag_printf("Passing in wrong arguments: %d\n", argc);
 915         diag_printf("Useage: fuse_read <bank> <row>\n");
 916     }
 917 }
 918
 919 /* Blow fuses based on the bank, row and bit positions (all 0-based)
 920 */
 921 static int fuse_blow(int bank,int row,int bit)
 922 {
 923     int addr, addr_l, addr_h, ret = -1;
 924
 925     fuse_op_start();
 926
 927     /* Disable IIM Program Protect */
 928     writel(0xAA, IIM_BASE_ADDR + IIM_PREG_P_OFF);
 929
 930     addr = ((bank << 11) | (row << 3) | (bit & 0x7));
 931     /* Set IIM Program Upper Address */
 932     addr_h = (addr >> 8) & 0x000000FF;
 933     /* Set IIM Program Lower Address */
 934     addr_l = (addr & 0x000000FF);
 935
 936 #ifdef IIM_FUSE_DEBUG
 937     diag_printf("blowing addr_h=0x%x, addr_l=0x%x\n", addr_h, addr_l);
 938 #endif
 939
 940     writel(addr_h, IIM_BASE_ADDR + IIM_UA_OFF);
 941     writel(addr_l, IIM_BASE_ADDR + IIM_LA_OFF);
 942     /* Start Programming */
 943     writel(0x31, IIM_BASE_ADDR + IIM_FCTL_OFF);
 944     if (poll_fuse_op_done(POLL_FUSE_PRGD) == 0) {
 945         ret = 0;
 946     }
 947
 948     /* Enable IIM Program Protect */
 949     writel(0x0, IIM_BASE_ADDR + IIM_PREG_P_OFF);
 950     return ret;
 951 }
 952
 953 /*
 954  * This command is added for burning IIM fuses
 955  */
 956 RedBoot_cmd("fuse_read",
 957             "read some fuses",
 958             "<bank> <row>",
 959             do_fuse_read
 960            );
 961
 962 RedBoot_cmd("fuse_blow",
 963             "blow some fuses",
 964             "<bank> <row> <value>",
 965             do_fuse_blow
 966            );
 967
 968 #define         INIT_STRING              "12345678"
 969 static char ready_to_blow[] = INIT_STRING;
 970
 971 void quick_itoa(u32 num, char *a)
 972 {
 973     int i, j, k;
 974     for (i = 0; i <= 7; i++) {
 975         j = (num >> (4 * i)) & 0xF;
 976         k = (j < 10) ? '0' : ('a' - 0xa);
 977         a[i] = j + k;
 978     }
 979 }
 980
 981 void do_fuse_blow(int argc, char *argv[])
 982 {
 983     int bank, row, value, i;
 984
 985     if (argc == 1) {
 986         diag_printf("It is too dangeous for you to use this command.\n");
 987         return;
 988     } else if (argc == 2) {
 989         if (strcasecmp(argv[1], "nandboot") == 0) {
 990             quick_itoa(readl(EPIT_BASE_ADDR + EPITCNR), ready_to_blow);
 991             diag_printf("%s\n", ready_to_blow);
 992         }
 993         return;
 994     } else if (argc == 3) {
 995         if (strcasecmp(argv[1], "nandboot") == 0 &&
 996             strcasecmp(argv[2], ready_to_blow) == 0) {
 997 #if defined(CYGPKG_HAL_ARM_MX21) || defined(CYGPKG_HAL_ARM_MX27) || defined(CYGPKG_HAL_ARM_MX31)
 998             diag_printf("No need to blow any fuses for NAND boot on this platform\n\n");
 999 #else
1000             diag_printf("Ready to burn NAND boot fuses\n");
1001             if (fuse_blow(0, 16, 1) != 0 || fuse_blow(0, 16, 7) != 0) {
1002                 diag_printf("NAND BOOT fuse blown failed miserably ...\n");
1003             } else {
1004                 diag_printf("NAND BOOT fuse blown successfully ...\n");
1005             }
1006         } else {
1007             diag_printf("Not ready: %s, %s\n", argv[1], argv[2]);
1008 #endif
1009         }
1010     } else if (argc == 4) {
1011         if (!parse_num(*(&argv[1]), (unsigned long *)&bank, &argv[1], " ")) {
1012                 diag_printf("Error: Invalid parameter\n");
1013             return;
1014         }
1015         if (!parse_num(*(&argv[2]), (unsigned long *)&row, &argv[2], " ")) {
1016                 diag_printf("Error: Invalid parameter\n");
1017                 return;
1018         }
1019         if (!parse_num(*(&argv[3]), (unsigned long *)&value, &argv[3], " ")) {
1020                 diag_printf("Error: Invalid parameter\n");
1021                 return;
1022         }
1023
1024         diag_printf("Blowing fuse at bank:%d row:%d value:%d\n",
1025                     bank, row, value);
1026         for (i = 0; i < 8; i++) {
1027             if (((value >> i) & 0x1) == 0) {
1028                 continue;
1029             }
1030             if (fuse_blow(bank, row, i) != 0) {
1031                 diag_printf("fuse_blow(bank: %d, row: %d, bit: %d failed\n",
1032                             bank, row, i);
1033             } else {
1034                 diag_printf("fuse_blow(bank: %d, row: %d, bit: %d successful\n",
1035                             bank, row, i);
1036             }
1037         }
1038         sense_fuse(bank, row, 0);
1039
1040     } else {
1041         diag_printf("Passing in wrong arguments: %d\n", argc);
1042     }
1043     /* Reset to default string */
1044     strcpy(ready_to_blow, INIT_STRING);;
1045 }
1046
1047 /* precondition: m>0 and n>0.  Let g=gcd(m,n). */
1048 int gcd(int m, int n)
1049 {
1050     int t;
1051     while(m > 0) {
1052         if(n > m) {t = m; m = n; n = t;} /* swap */
1053         m -= n;
1054     }
1055     return n;
1056  }