git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_A9_Cyclone_V_SoC_DK/Altera_Code/HardwareLibrary/alt_clock_manager.c

   1 /******************************************************************************\r
   2  *\r
   3  * Copyright 2013 Altera Corporation. All Rights Reserved.\r
   4  *\r
   5  * Redistribution and use in source and binary forms, with or without\r
   6  * modification, are permitted provided that the following conditions are met:\r
   7  *\r
   8  * 1. Redistributions of source code must retain the above copyright notice,\r
   9  * this list of conditions and the following disclaimer.\r
  10  *\r
  11  * 2. Redistributions in binary form must reproduce the above copyright notice,\r
  12  * this list of conditions and the following disclaimer in the documentation\r
  13  * and/or other materials provided with the distribution.\r
  14  *\r
  15  * 3. The name of the author may not be used to endorse or promote products\r
  16  * derived from this software without specific prior written permission.\r
  17  *\r
  18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER "AS IS" AND ANY EXPRESS OR\r
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF\r
  20  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE DISCLAIMED. IN NO\r
  21  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,\r
  22  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT\r
  23  * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\r
  24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\r
  25  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING\r
  26  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY\r
  27  * OF SUCH DAMAGE.\r
  28  *\r
  29  ******************************************************************************/\r
  30 \r
  31 #include <stdint.h>\r
  32 #include <stdlib.h>\r
  33 #include <stdbool.h>\r
  34 #include <stdio.h>\r
  35 \r
  36 #include "socal/hps.h"\r
  37 #include "socal/socal.h"\r
  38 #include "socal/alt_sysmgr.h"\r
  39 #include "hwlib.h"\r
  40 #include "alt_clock_manager.h"\r
  41 #include "alt_mpu_registers.h"\r
  42 \r
  43 #define UINT12_MAX              (4096)\r
  44 \r
  45 #define printf( ... )\r
  46 \r
  47 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/\r
  48 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Useful Structures ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/\r
  49 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/\r
  50 \r
  51 \r
  52         /* General structure used to hold parameters of various clock entities, */\r
  53 typedef struct ALT_CLK_PARAMS_s\r
  54 {\r
  55     alt_freq_t      freqcur;                   // current frequency of the clock\r
  56     alt_freq_t      freqmin;                   // minimum allowed frequency for this clock\r
  57     alt_freq_t      freqmax;                   // maximum allowed frequency for this clock\r
  58     uint32_t        guardband : 7;             // guardband percentage (0-100) if this clock\r
  59                                                //    is a PLL, ignored otherwise\r
  60     uint32_t        active    : 1;             // current state of activity of this clock\r
  61 } ALT_CLK_PARAMS_t;\r
  62 \r
  63 \r
  64 typedef struct ALT_EXT_CLK_PARAMBLOK_s\r
  65 {\r
  66     ALT_CLK_PARAMS_t        clkosc1;        // ALT_CLK_OSC1\r
  67     ALT_CLK_PARAMS_t        clkosc2;        // ALT_CLK_OSC2\r
  68     ALT_CLK_PARAMS_t        periph;         // ALT_CLK_F2H_PERIPH_REF\r
  69     ALT_CLK_PARAMS_t        sdram;          // ALT_CLK_F2H_SDRAM_REF\r
  70 } ALT_EXT_CLK_PARAMBLOK_t;\r
  71 \r
  72 \r
  73         /* Initializes the External Clock Frequency Limits block                        */\r
  74         /* The first field is the current external clock frequency, and can be set by   */\r
  75         /* alt_clk_ext_clk_freq_set(), the second and third fields are the minimum and  */\r
  76         /* maximum frequencies, the fourth field is ignored, and the fifth field        */\r
  77         /* contains the current activity state of the clock, 1=active, 0=inactive.      */\r
  78         /* Values taken from Section 2.3 and Section 2.7.1 of the HHP HPS-Clocking      */\r
  79         /* NPP specification.                                                           */\r
  80 static ALT_EXT_CLK_PARAMBLOK_t alt_ext_clk_paramblok =\r
  81 {\r
  82     { 25000000, 10000000, 50000000, 0, 1 },\r
  83     { 25000000, 10000000, 50000000, 0, 1 },\r
  84     {        0, 10000000, 50000000, 0, 1 },\r
  85     {        0, 10000000, 50000000, 0, 1 }\r
  86 };\r
  87 \r
  88 \r
  89         /* PLL frequency limits */\r
  90 typedef struct ALT_PLL_CLK_PARAMBLOK_s\r
  91 {\r
  92     ALT_CLK_PARAMS_t       MainPLL_600;         // Main PLL values for 600 MHz SoC\r
  93     ALT_CLK_PARAMS_t       PeriphPLL_600;       // Peripheral PLL values for 600 MHz SoC\r
  94     ALT_CLK_PARAMS_t       SDRAMPLL_600;        // SDRAM PLL values for 600 MHz SoC\r
  95     ALT_CLK_PARAMS_t       MainPLL_800;         // Main PLL values for 800 MHz SoC\r
  96     ALT_CLK_PARAMS_t       PeriphPLL_800;       // Peripheral PLL values for 800 MHz SoC\r
  97     ALT_CLK_PARAMS_t       SDRAMPLL_800;        // SDRAM PLL values for 800 MHz SoC\r
  98 } ALT_PLL_CLK_PARAMBLOK_t;\r
  99 \r
 100 \r
 101     /* Initializes the PLL frequency limits block                               */\r
 102     /* The first field is the current frequency, the second and third fields    */\r
 103     /* are the design limits of the PLLs as listed in Section 3.2.1.2 of the    */\r
 104     /* HHP HPS-Clocking NPP document. The fourth field of each line is the      */\r
 105     /* guardband percentage, and the fifth field of each line is the current    */\r
 106     /* state of the PLL, 1=active, 0=inactive.                                  */\r
 107 #define     ALT_ORIGINAL_GUARDBAND_VAL      20\r
 108 #define     ALT_GUARDBAND_LIMIT             20\r
 109 \r
 110 static ALT_PLL_CLK_PARAMBLOK_t alt_pll_clk_paramblok =\r
 111 {\r
 112     { 0, 320000000, 1200000000, ALT_ORIGINAL_GUARDBAND_VAL, 0 },\r
 113     { 0, 320000000,  900000000, ALT_ORIGINAL_GUARDBAND_VAL, 0 },\r
 114     { 0, 320000000,  800000000, ALT_ORIGINAL_GUARDBAND_VAL, 0 },\r
 115     { 0, 320000000, 1600000000, ALT_ORIGINAL_GUARDBAND_VAL, 1 },\r
 116     { 0, 320000000, 1250000000, ALT_ORIGINAL_GUARDBAND_VAL, 1 },\r
 117     { 0, 320000000, 1066000000, ALT_ORIGINAL_GUARDBAND_VAL, 1 }\r
 118 };\r
 119 \r
 120 \r
 121         /* PLL counter frequency limits */\r
 122 typedef struct ALT_PLL_CNTR_FREQMAX_s\r
 123 {\r
 124     alt_freq_t       MainPLL_C0;         // Main PLL Counter 0 parameter block\r
 125     alt_freq_t       MainPLL_C1;         // Main PLL Counter 1 parameter block\r
 126     alt_freq_t       MainPLL_C2;         // Main PLL Counter 2 parameter block\r
 127     alt_freq_t       MainPLL_C3;         // Main PLL Counter 3 parameter block\r
 128     alt_freq_t       MainPLL_C4;         // Main PLL Counter 4 parameter block\r
 129     alt_freq_t       MainPLL_C5;         // Main PLL Counter 5 parameter block\r
 130     alt_freq_t       PeriphPLL_C0;       // Peripheral PLL Counter 0 parameter block\r
 131     alt_freq_t       PeriphPLL_C1;       // Peripheral PLL Counter 1 parameter block\r
 132     alt_freq_t       PeriphPLL_C2;       // Peripheral PLL Counter 2 parameter block\r
 133     alt_freq_t       PeriphPLL_C3;       // Peripheral PLL Counter 3 parameter block\r
 134     alt_freq_t       PeriphPLL_C4;       // Peripheral PLL Counter 4 parameter block\r
 135     alt_freq_t       PeriphPLL_C5;       // Peripheral PLL Counter 5 parameter block\r
 136     alt_freq_t       SDRAMPLL_C0;        // SDRAM PLL Counter 0 parameter block\r
 137     alt_freq_t       SDRAMPLL_C1;        // SDRAM PLL Counter 1 parameter block\r
 138     alt_freq_t       SDRAMPLL_C2;        // SDRAM PLL Counter 2 parameter block\r
 139     alt_freq_t       SDRAMPLL_C5;        // SDRAM PLL Counter 5 parameter block\r
 140 } ALT_PLL_CNTR_FREQMAX_t;\r
 141 \r
 142 //\r
 143 // The following pll max frequency array statically defined must be recalculated each time\r
 144 // when powering up, by calling alt_clk_clkmgr_init()\r
 145 //\r
 146 // for 14.1 uboot preloader, the following values are calculated dynamically.\r
 147 //\r
 148 // Arrial 5\r
 149 // alt_pll_cntr_maxfreq.MainPLL_C0   = 1050000000\r
 150 // alt_pll_cntr_maxfreq.MainPLL_C1   =  350000000\r
 151 // alt_pll_cntr_maxfreq.MainPLL_C2   =  262500000\r
 152 // alt_pll_cntr_maxfreq.MainPLL_C3   =  350000000\r
 153 // alt_pll_cntr_maxfreq.MainPLL_C4   =    2050781\r
 154 // alt_pll_cntr_maxfreq.MainPLL_C5   =  116666666\r
 155 // alt_pll_cntr_maxfreq.PeriphPLL_C0 =    1953125\r
 156 // alt_pll_cntr_maxfreq.PeriphPLL_C1 =  250000000\r
 157 // alt_pll_cntr_maxfreq.PeriphPLL_C2 =    1953125\r
 158 // alt_pll_cntr_maxfreq.PeriphPLL_C3 =  200000000\r
 159 // alt_pll_cntr_maxfreq.PeriphPLL_C4 =  200000000\r
 160 // alt_pll_cntr_maxfreq.PeriphPLL_C5 =    1953125\r
 161 // alt_pll_cntr_maxfreq.SDRAMPLL_C0  =  533333333\r
 162 // alt_pll_cntr_maxfreq.SDRAMPLL_C1  = 1066666666\r
 163 // alt_pll_cntr_maxfreq.SDRAMPLL_C2  =  533333333\r
 164 // alt_pll_cntr_maxfreq.SDRAMPLL_C5  =  177777777\r
 165 \r
 166 // Cyclone V\r
 167 // alt_pll_cntr_maxfreq.MainPLL_C0   =  925000000\r
 168 // alt_pll_cntr_maxfreq.MainPLL_C1   =  370000000\r
 169 // alt_pll_cntr_maxfreq.MainPLL_C2   =  462500000\r
 170 // alt_pll_cntr_maxfreq.MainPLL_C3   =  370000000\r
 171 // alt_pll_cntr_maxfreq.MainPLL_C4   =    3613281\r
 172 // alt_pll_cntr_maxfreq.MainPLL_C5   =  123333333\r
 173 // alt_pll_cntr_maxfreq.PeriphPLL_C0 =    1953125\r
 174 // alt_pll_cntr_maxfreq.PeriphPLL_C1 =  250000000\r
 175 // alt_pll_cntr_maxfreq.PeriphPLL_C2 =    1953125\r
 176 // alt_pll_cntr_maxfreq.PeriphPLL_C3 =  200000000\r
 177 // alt_pll_cntr_maxfreq.PeriphPLL_C4 =  200000000\r
 178 // alt_pll_cntr_maxfreq.PeriphPLL_C5 =    1953125\r
 179 // alt_pll_cntr_maxfreq.SDRAMPLL_C0  =  400000000\r
 180 // alt_pll_cntr_maxfreq.SDRAMPLL_C1  =  800000000\r
 181 // alt_pll_cntr_maxfreq.SDRAMPLL_C2  =  400000000\r
 182 // alt_pll_cntr_maxfreq.SDRAMPLL_C5  =  133333333\r
 183 \r
 184 \r
 185 /* Initializes the PLL Counter output maximum frequency block  */\r
 186 static ALT_PLL_CNTR_FREQMAX_t alt_pll_cntr_maxfreq =\r
 187 {\r
 188     800000000,    /* Main PLL Outputs */\r
 189     400000000,\r
 190     400000000,\r
 191     432000000,\r
 192     250000000,\r
 193     125000000,\r
 194     250000000,    /* Peripheral PLL Outputs */\r
 195     250000000,\r
 196     432000000,\r
 197     250000000,\r
 198     200000000,\r
 199     100000000,    /* SDRAM PLL Outputs */\r
 200     533000000,\r
 201     1066000000,\r
 202     533000000,\r
 203     200000000\r
 204 };\r
 205 \r
 206 \r
 207 \r
 208         /* Maximum multiply, divide, and counter divisor values for each PLL */\r
 209 #define     ALT_CLK_PLL_MULT_MAX        4095\r
 210 #define     ALT_CLK_PLL_DIV_MAX         63\r
 211 #define     ALT_CLK_PLL_CNTR_MAX        511\r
 212 \r
 213 \r
 214         /* Definitions for the reset request and reset acknowledge bits    */\r
 215         /* for each of the output counters for each of the PLLS            */\r
 216 #define     ALT_CLK_PLL_RST_BIT_C0      0x00000001\r
 217 #define     ALT_CLK_PLL_RST_BIT_C1      0x00000002\r
 218 #define     ALT_CLK_PLL_RST_BIT_C2      0x00000004\r
 219 #define     ALT_CLK_PLL_RST_BIT_C3      0x00000008\r
 220 #define     ALT_CLK_PLL_RST_BIT_C4      0x00000010\r
 221 #define     ALT_CLK_PLL_RST_BIT_C5      0x00000020\r
 222 \r
 223 \r
 224         /* These are the bits that deal with PLL lock and this macro */\r
 225         /* defines a mask to test for bits outside of these */\r
 226 #define ALT_CLK_MGR_PLL_LOCK_BITS  (ALT_CLKMGR_INTREN_MAINPLLACHIEVED_CLR_MSK \\r
 227                                   & ALT_CLKMGR_INTREN_PERPLLACHIEVED_CLR_MSK \\r
 228                                   & ALT_CLKMGR_INTREN_SDRPLLACHIEVED_CLR_MSK \\r
 229                                   & ALT_CLKMGR_INTREN_MAINPLLLOST_CLR_MSK \\r
 230                                   & ALT_CLKMGR_INTREN_PERPLLLOST_CLR_MSK \\r
 231                                   & ALT_CLKMGR_INTREN_SDRPLLLOST_CLR_MSK)\r
 232 \r
 233 \r
 234 // Undocumented register which determines clock dividers for main PLL C0, C1, and C2. These should be considered RO.\r
 235 #define ALT_CLKMGR_ALTERA_OFST           0xe0\r
 236 #define ALT_CLKMGR_ALTERA_MPUCLK_OFST    0x0\r
 237 #define ALT_CLKMGR_ALTERA_MAINCLK_OFST   0x4\r
 238 #define ALT_CLKMGR_ALTERA_DBGATCLK_OFST  0x8\r
 239 #define ALT_CLKMGR_ALTERA_ADDR           ALT_CAST(void *, (ALT_CAST(char *, ALT_CLKMGR_ADDR) + ALT_CLKMGR_ALTERA_OFST))\r
 240 #define ALT_CLKMGR_ALTERA_MPUCLK_ADDR    ALT_CAST(void *, (ALT_CAST(char *, ALT_CLKMGR_ALTERA_ADDR) + ALT_CLKMGR_ALTERA_MPUCLK_OFST))\r
 241 #define ALT_CLKMGR_ALTERA_MAINCLK_ADDR   ALT_CAST(void *, (ALT_CAST(char *, ALT_CLKMGR_ALTERA_ADDR) + ALT_CLKMGR_ALTERA_MAINCLK_OFST))\r
 242 #define ALT_CLKMGR_ALTERA_DBGATCLK_ADDR  ALT_CAST(void *, (ALT_CAST(char *, ALT_CLKMGR_ALTERA_ADDR) + ALT_CLKMGR_ALTERA_DBGATCLK_OFST))\r
 243 #define ALT_CLKMGR_ALTERA_MPUCLK_CNT_GET(value)   (((value) & 0x000001ff) >> 0)\r
 244 #define ALT_CLKMGR_ALTERA_MAINCLK_CNT_GET(value)  (((value) & 0x000001ff) >> 0)\r
 245 #define ALT_CLKMGR_ALTERA_DBGATCLK_CNT_GET(value) (((value) & 0x000001ff) >> 0)\r
 246 \r
 247 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/\r
 248 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Utility functions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/\r
 249 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/\r
 250 \r
 251 \r
 252 /****************************************************************************************/\r
 253 /* alt_clk_mgr_wait() introduces a delay, not very exact, but very light in             */\r
 254 /* implementation. Depending upon the optinization level, it will wait at least the     */\r
 255 /* number of clock cycles specified in the cnt parameter, sometimes many more. The      */\r
 256 /* reg parameter is set to a register or a memory location that was recently used (so   */\r
 257 /* as to avoid accidently evicting a register and a recently-used cache line in favor   */\r
 258 /* of one whose values are not actually needed.). The cnt parameter sets the number of  */\r
 259 /* repeated volatile memory reads and so sets a minimum time delay measured in          */\r
 260 /* mpu_clk cycles. If mpu_clk = osc1 clock (as in bypass mode), then this gives a       */\r
 261 /* minimum osc1 clock cycle delay.                                                      */\r
 262 /****************************************************************************************/\r
 263 \r
 264 inline static void alt_clk_mgr_wait(void* reg, uint32_t cnt)\r
 265 {\r
 266     for (; cnt ; cnt--)\r
 267     {\r
 268         (void) alt_read_word(reg);\r
 269     }\r
 270 }\r
 271 \r
 272     /* Wait time constants */\r
 273     /* These values came from Section 4.9.4 of the HHP HPS-Clocking NPP document */\r
 274 #define ALT_SW_MANAGED_CLK_WAIT_CTRDIV          30      /* 30 or more MPU clock cycles */\r
 275 #define ALT_SW_MANAGED_CLK_WAIT_HWCTRDIV        40\r
 276 #define ALT_SW_MANAGED_CLK_WAIT_BYPASS          30\r
 277 #define ALT_SW_MANAGED_CLK_WAIT_SAFEREQ         30\r
 278 #define ALT_SW_MANAGED_CLK_WAIT_SAFEEXIT        30\r
 279 #define ALT_SW_MANAGED_CLK_WAIT_NANDCLK         8       /* 8 or more MPU clock cycles */\r
 280 \r
 281 \r
 282 #define ALT_BYPASS_TIMEOUT_CNT      50\r
 283         // arbitrary number until i find more info\r
 284 #define ALT_TIMEOUT_PHASE_SYNC      300\r
 285         // how many loops to wait for the SDRAM clock to come around\r
 286         // to zero and allow for writing a new divisor ratio to it\r
 287 \r
 288 ALT_STATUS_CODE alt_clk_plls_settle_wait(void)\r
 289 {\r
 290     int32_t     i = ALT_BYPASS_TIMEOUT_CNT;\r
 291     bool        nofini;\r
 292 \r
 293     do\r
 294     {\r
 295         nofini = alt_read_word(ALT_CLKMGR_STAT_ADDR) & ALT_CLKMGR_STAT_BUSY_SET_MSK;\r
 296     } while (nofini && i--);\r
 297             // wait until clocks finish transitioning and become stable again\r
 298     return (i > 0) ? ALT_E_SUCCESS : ALT_E_ERROR;\r
 299 }\r
 300 \r
 301 static ALT_STATUS_CODE alt_clk_pll_lock_wait(ALT_CLK_t pll, uint32_t timeout)\r
 302 {\r
 303     uint32_t locked_mask = 0;\r
 304 \r
 305     if      (pll == ALT_CLK_MAIN_PLL)       { locked_mask = ALT_CLKMGR_INTER_MAINPLLLOCKED_SET_MSK; }\r
 306     else if (pll == ALT_CLK_PERIPHERAL_PLL) { locked_mask = ALT_CLKMGR_INTER_PERPLLLOCKED_SET_MSK; }\r
 307     else if (pll == ALT_CLK_SDRAM_PLL)      { locked_mask = ALT_CLKMGR_INTER_SDRPLLLOCKED_SET_MSK; }\r
 308     else\r
 309     {\r
 310         return ALT_E_BAD_ARG;\r
 311     }\r
 312 \r
 313     do\r
 314     {\r
 315         uint32_t int_status = alt_read_word(ALT_CLKMGR_INTER_ADDR);\r
 316         if (int_status & locked_mask)\r
 317         {\r
 318             return ALT_E_SUCCESS;\r
 319         }\r
 320 \r
 321     } while (timeout--);\r
 322 \r
 323     return ALT_E_TMO;\r
 324 }\r
 325 \r
 326         /* Useful utility macro for checking if two values  */\r
 327         /* are within a certain percentage of each other    */\r
 328 #define  alt_within_delta(ref, neu, prcnt)  (((((neu) * 100)/(ref)) < (100 + (prcnt))) \\r
 329                                             && ((((neu) * 100)/(ref)) > (100 - (prcnt))))\r
 330 \r
 331 \r
 332         /* Flags to include or omit code sections */\r
 333 // There are four cases where there is a small possibility of producing clock\r
 334 // glitches. Code has been added from an abundance of caution to prevent\r
 335 // these glitches. If further testing shows that this extra code is not necessary\r
 336 // under any conditions, it may be easily eliminated by clearing these flags.\r
 337 \r
 338 #define ALT_PREVENT_GLITCH_BYP              true\r
 339 // for PLL entering or leaving bypass\r
 340 #define ALT_PREVENT_GLITCH_EXSAFE           true\r
 341 // for PLL exiting safe mode\r
 342 #define ALT_PREVENT_GLITCH_CNTRRST          true\r
 343 // resets counter phase\r
 344 #define ALT_PREVENT_GLITCH_CHGC1            true\r
 345 // for changing Main PLL C1 counter\r
 346 \r
 347 \r
 348 \r
 349 /****************************************************************************************/\r
 350 /* Bare-bones utility function used to make the somewhat complex writes to the PLL      */\r
 351 /* counter registers (the clock dividers) easier. No parameter-checking or              */\r
 352 /* error-checking, this is a static to this file and invisible to Doxygen.              */\r
 353 /****************************************************************************************/\r
 354 \r
 355 static void alt_clk_pllcounter_write(void* vcoaddr, void* stataddr, void* cntraddr,\r
 356         uint32_t val, uint32_t msk, uint32_t shift)\r
 357 {\r
 358 #if ALT_PREVENT_GLITCH_CNTRRST\r
 359     // this is here from an abundance of caution and it may not be necessary\r
 360     // to put the counter in reset for this write\r
 361     volatile uint32_t   temp;\r
 362 \r
 363     alt_setbits_word(vcoaddr, msk << shift);                // put the counter in reset\r
 364     do\r
 365     {\r
 366         temp = alt_read_word(stataddr);\r
 367     } while (!(temp & msk));\r
 368 \r
 369     alt_write_word(cntraddr, val);\r
 370     alt_clrbits_word(vcoaddr, msk << shift);                // release counter reset\r
 371 \r
 372 #else       // should we find out that resetting the counters as above is unnecessary\r
 373     alt_write_word(cntraddr, val);\r
 374 #endif\r
 375 }\r
 376 \r
 377 \r
 378 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/\r
 379 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Main Functions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/\r
 380 /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/\r
 381 \r
 382 \r
 383 /****************************************************************************************/\r
 384 /* alt_clk_lock_status_clear() clears assertions of one or more of the PLL lock status  */\r
 385 /* conditions.                                                                          */\r
 386 /****************************************************************************************/\r
 387 \r
 388 ALT_STATUS_CODE alt_clk_lock_status_clear(ALT_CLK_PLL_LOCK_STATUS_t lock_stat_mask)\r
 389 {\r
 390     if (lock_stat_mask & (  ALT_CLKMGR_INTER_MAINPLLACHIEVED_CLR_MSK\r
 391                           & ALT_CLKMGR_INTER_PERPLLACHIEVED_CLR_MSK\r
 392                           & ALT_CLKMGR_INTER_SDRPLLACHIEVED_CLR_MSK\r
 393                           & ALT_CLKMGR_INTER_MAINPLLLOST_CLR_MSK\r
 394                           & ALT_CLKMGR_INTER_PERPLLLOST_CLR_MSK\r
 395                           & ALT_CLKMGR_INTER_SDRPLLLOST_CLR_MSK)\r
 396         )\r
 397     {\r
 398         return ALT_E_BAD_ARG;\r
 399     }\r
 400     else\r
 401     {\r
 402         alt_setbits_word(ALT_CLKMGR_INTER_ADDR, lock_stat_mask);\r
 403         return ALT_E_SUCCESS;\r
 404     }\r
 405 }\r
 406 \r
 407 \r
 408 /****************************************************************************************/\r
 409 /* alt_clk_lock_status_get() returns the value of the PLL lock status conditions.       */\r
 410 /****************************************************************************************/\r
 411 \r
 412 uint32_t alt_clk_lock_status_get(void)\r
 413 {\r
 414     return alt_read_word(ALT_CLKMGR_INTER_ADDR) & (  ALT_CLKMGR_INTER_MAINPLLACHIEVED_SET_MSK\r
 415                                                    | ALT_CLKMGR_INTER_PERPLLACHIEVED_SET_MSK\r
 416                                                    | ALT_CLKMGR_INTER_SDRPLLACHIEVED_SET_MSK\r
 417                                                    | ALT_CLKMGR_INTER_MAINPLLLOST_SET_MSK\r
 418                                                    | ALT_CLKMGR_INTER_PERPLLLOST_SET_MSK\r
 419                                                    | ALT_CLKMGR_INTER_SDRPLLLOST_SET_MSK\r
 420                                                    | ALT_CLKMGR_INTER_MAINPLLLOCKED_SET_MSK\r
 421                                                    | ALT_CLKMGR_INTER_PERPLLLOCKED_SET_MSK\r
 422                                                    | ALT_CLKMGR_INTER_SDRPLLLOCKED_SET_MSK );\r
 423 }\r
 424 \r
 425 \r
 426 /****************************************************************************************/\r
 427 /* alt_clk_pll_is_locked() returns ALT_E_TRUE if the designated PLL is currently        */\r
 428 /* locked and ALT_E_FALSE if not.                                                       */\r
 429 /****************************************************************************************/\r
 430 \r
 431 ALT_STATUS_CODE alt_clk_pll_is_locked(ALT_CLK_t pll)\r
 432 {\r
 433     ALT_STATUS_CODE status = ALT_E_BAD_ARG;\r
 434 \r
 435     if (pll == ALT_CLK_MAIN_PLL)\r
 436     {\r
 437         status = (alt_read_word(ALT_CLKMGR_INTER_ADDR) & ALT_CLKMGR_INTER_MAINPLLLOCKED_SET_MSK)\r
 438                 ? ALT_E_TRUE : ALT_E_FALSE;\r
 439     }\r
 440     else if (pll == ALT_CLK_PERIPHERAL_PLL)\r
 441     {\r
 442         status = (alt_read_word(ALT_CLKMGR_INTER_ADDR) & ALT_CLKMGR_INTER_PERPLLLOCKED_SET_MSK)\r
 443                 ? ALT_E_TRUE : ALT_E_FALSE;\r
 444     }\r
 445     else if (pll == ALT_CLK_SDRAM_PLL)\r
 446     {\r
 447         status = (alt_read_word(ALT_CLKMGR_INTER_ADDR) & ALT_CLKMGR_INTER_SDRPLLLOCKED_SET_MSK)\r
 448                 ? ALT_E_TRUE : ALT_E_FALSE;\r
 449     }\r
 450     return status;\r
 451 }\r
 452 \r
 453 \r
 454 /****************************************************************************************/\r
 455 /* alt_clk_safe_mode_clear() clears the safe mode status of the Clock Manager following */\r
 456 /* a reset.                                                                             */\r
 457 /****************************************************************************************/\r
 458 \r
 459 ALT_STATUS_CODE alt_clk_safe_mode_clear(void)\r
 460 {\r
 461     ALT_STATUS_CODE status = ALT_E_ERROR;\r
 462 #if ALT_PREVENT_GLITCH_EXSAFE\r
 463     uint32_t        temp;\r
 464 \r
 465     temp = alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR);\r
 466     alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp &\r
 467             (ALT_CLKMGR_MAINPLL_EN_L4MPCLK_CLR_MSK & ALT_CLKMGR_MAINPLL_EN_L4SPCLK_CLR_MSK));\r
 468                     // gate off l4MP and L4SP clocks (no matter their source)\r
 469 \r
 470     alt_setbits_word(ALT_CLKMGR_CTL_ADDR, ALT_CLKMGR_CTL_SAFEMOD_SET_MSK);\r
 471                     // clear safe mode bit\r
 472     status = alt_clk_plls_settle_wait();\r
 473     alt_replbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR,\r
 474             ALT_CLKMGR_MAINPLL_EN_L4MPCLK_SET_MSK | ALT_CLKMGR_MAINPLL_EN_L4SPCLK_SET_MSK,\r
 475             temp);\r
 476                     // gate l4MP and L4SP clocks back on if they were on previously\r
 477 \r
 478 #else\r
 479     alt_setbits_word(ALT_CLKMGR_CTL_ADDR, ALT_CLKMGR_CTL_SAFEMOD_SET_MSK);\r
 480                     // clear safe mode bit\r
 481     status = alt_clk_plls_settle_wait();\r
 482 \r
 483 #endif\r
 484     return status;\r
 485 }\r
 486 \r
 487 \r
 488 /****************************************************************************************/\r
 489 /* alt_clk_is_in_safe_mode() returns whether the specified safe mode clock domain is in */\r
 490 /* safe mode or not.                                                                    */\r
 491 /****************************************************************************************/\r
 492 \r
 493 bool alt_clk_is_in_safe_mode(ALT_CLK_SAFE_DOMAIN_t clk_domain)\r
 494 {\r
 495     bool        ret = false;\r
 496     uint32_t    temp;\r
 497 \r
 498     if (clk_domain == ALT_CLK_DOMAIN_NORMAL)\r
 499     {\r
 500         ret = alt_read_word(ALT_CLKMGR_CTL_ADDR) & ALT_CLKMGR_CTL_SAFEMOD_SET_MSK;\r
 501                 // is the main clock domain in safe mode?\r
 502     }\r
 503     else if (clk_domain == ALT_CLK_DOMAIN_DEBUG)\r
 504     {\r
 505         temp = alt_read_word(ALT_CLKMGR_DBCTL_ADDR);\r
 506         if (temp & ALT_CLKMGR_DBCTL_STAYOSC1_SET_MSK)\r
 507         {\r
 508             ret = true;                // is the debug clock domain in safe mode?\r
 509         }\r
 510         else if (temp & ALT_CLKMGR_DBCTL_ENSFMDWR_SET_MSK)\r
 511         {\r
 512             ret = alt_read_word(ALT_CLKMGR_CTL_ADDR) & ALT_CLKMGR_CTL_SAFEMOD_SET_MSK;\r
 513                     // is the debug clock domain following the main clock domain\r
 514                     // AND is the main clock domain in safe mode?\r
 515         }\r
 516     }\r
 517     return ret;\r
 518 }\r
 519 \r
 520 /****************************************************************************************/\r
 521 /* alt_clk_pll_bypass_disable() disables bypass mode for the specified PLL, removing    */\r
 522 /* it from bypass mode and allowing it to provide the output of the PLL to drive the    */\r
 523 /* six main clocks.                                                                     */\r
 524 /****************************************************************************************/\r
 525 \r
 526 ALT_STATUS_CODE alt_clk_pll_bypass_disable(ALT_CLK_t pll)\r
 527 {\r
 528     ALT_STATUS_CODE status = ALT_E_BAD_ARG;\r
 529     uint32_t        temp;\r
 530 #if  ALT_PREVENT_GLITCH_BYP\r
 531     uint32_t        temp1;\r
 532     bool            restore_0 = false;\r
 533     bool            restore_1 = false;\r
 534 #endif\r
 535 \r
 536     // this function should only be called after the selected PLL is locked\r
 537     if (alt_clk_pll_is_locked(pll) == ALT_E_TRUE)\r
 538     {\r
 539         if (pll == ALT_CLK_MAIN_PLL)\r
 540         {\r
 541 #if  ALT_PREVENT_GLITCH_BYP\r
 542             // if L4MP or L4SP source is set to Main PLL C1, gate it off before changing\r
 543             // bypass state, then gate clock back on. FogBugz #63778\r
 544             temp  = alt_read_word(ALT_CLKMGR_MAINPLL_L4SRC_ADDR);\r
 545             temp1 = alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR);\r
 546 \r
 547             if ((temp1 & ALT_CLKMGR_MAINPLL_EN_L4MPCLK_SET_MSK) && (!(temp & ALT_CLKMGR_MAINPLL_L4SRC_L4MP_SET_MSK)))\r
 548             {\r
 549                 restore_0 = true;\r
 550             }\r
 551             if ((temp1 & ALT_CLKMGR_MAINPLL_EN_L4SPCLK_SET_MSK) && (!(temp & ALT_CLKMGR_MAINPLL_L4SRC_L4SP_SET_MSK)))\r
 552             {\r
 553                 restore_1 = true;\r
 554             }\r
 555             temp = temp1;\r
 556             if (restore_0) { temp &= ALT_CLKMGR_MAINPLL_EN_L4MPCLK_CLR_MSK; }\r
 557             if (restore_1) { temp &= ALT_CLKMGR_MAINPLL_EN_L4SPCLK_CLR_MSK; }\r
 558             if (restore_0 || restore_1) { alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp); }\r
 559 #endif\r
 560 \r
 561             // assert outresetall of main PLL\r
 562             temp = alt_read_word(ALT_CLKMGR_MAINPLL_VCO_ADDR);\r
 563             alt_write_word(ALT_CLKMGR_MAINPLL_VCO_ADDR, temp | ALT_CLKMGR_MAINPLL_VCO_OUTRSTALL_SET_MSK);\r
 564 \r
 565             // deassert outresetall of main PLL\r
 566             alt_write_word(ALT_CLKMGR_MAINPLL_VCO_ADDR, temp & ALT_CLKMGR_MAINPLL_VCO_OUTRSTALL_CLR_MSK);\r
 567 \r
 568             alt_clk_plls_settle_wait();\r
 569 \r
 570             // remove bypass\r
 571             alt_clrbits_word(ALT_CLKMGR_BYPASS_ADDR, ALT_CLKMGR_BYPASS_MAINPLL_SET_MSK);\r
 572             status = alt_clk_plls_settle_wait();\r
 573 \r
 574 #if  ALT_PREVENT_GLITCH_BYP\r
 575             if (restore_0 || restore_1)\r
 576             {\r
 577                 alt_clk_mgr_wait(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
 578                             // wait a bit more before reenabling the L4MP and L4SP clocks\r
 579                 alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp1);\r
 580             }\r
 581 #endif\r
 582         }\r
 583 \r
 584         else if (pll == ALT_CLK_PERIPHERAL_PLL)\r
 585         {\r
 586 #if  ALT_PREVENT_GLITCH_BYP\r
 587             // if L4MP or L4SP source is set to Main PLL C1, gate it off before changing\r
 588             // bypass state, then gate clock back on. FogBugz #63778\r
 589             temp = alt_read_word(ALT_CLKMGR_MAINPLL_L4SRC_ADDR);\r
 590             temp1 = alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR);\r
 591 \r
 592             if ((temp1 & ALT_CLKMGR_MAINPLL_EN_L4MPCLK_SET_MSK) && (temp & ALT_CLKMGR_MAINPLL_L4SRC_L4MP_SET_MSK))\r
 593             {\r
 594                     restore_0 = true;\r
 595             }\r
 596             if ((temp1 & ALT_CLKMGR_MAINPLL_EN_L4SPCLK_SET_MSK) && (temp & ALT_CLKMGR_MAINPLL_L4SRC_L4SP_SET_MSK))\r
 597             {\r
 598                     restore_1 = true;\r
 599             }\r
 600             temp = temp1;\r
 601             if (restore_0)  { temp &= ALT_CLKMGR_MAINPLL_EN_L4MPCLK_CLR_MSK; }\r
 602             if (restore_1)  { temp &= ALT_CLKMGR_MAINPLL_EN_L4SPCLK_CLR_MSK; }\r
 603             if (restore_0 || restore_1) { alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp); }\r
 604 #endif\r
 605 \r
 606             // assert outresetall of Peripheral PLL\r
 607             temp = alt_read_word(ALT_CLKMGR_PERPLL_VCO_ADDR);\r
 608             alt_write_word(ALT_CLKMGR_PERPLL_VCO_ADDR, temp | ALT_CLKMGR_PERPLL_VCO_OUTRSTALL_SET_MSK);\r
 609             alt_clk_plls_settle_wait();\r
 610 \r
 611             // deassert outresetall of main PLL\r
 612             alt_write_word(ALT_CLKMGR_PERPLL_VCO_ADDR, temp & ALT_CLKMGR_PERPLL_VCO_OUTRSTALL_CLR_MSK);\r
 613 \r
 614             // remove bypass - don't think that there's any need to touch the bypass clock source\r
 615             alt_clrbits_word(ALT_CLKMGR_BYPASS_ADDR, ALT_CLKMGR_BYPASS_PERPLL_SET_MSK);\r
 616             status = alt_clk_plls_settle_wait();\r
 617 \r
 618 #if  ALT_PREVENT_GLITCH_BYP\r
 619             if (restore_0 || restore_1)\r
 620             {\r
 621                 alt_clk_mgr_wait(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
 622                             // wait a bit more before reenabling the L4MP and L4SP clocks\r
 623                 alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp1);\r
 624             }\r
 625 #endif\r
 626         }\r
 627 \r
 628         else if (pll == ALT_CLK_SDRAM_PLL)\r
 629         {\r
 630             // assert outresetall of SDRAM PLL\r
 631             temp = alt_read_word(ALT_CLKMGR_SDRPLL_VCO_ADDR);\r
 632             alt_write_word(ALT_CLKMGR_SDRPLL_VCO_ADDR, temp | ALT_CLKMGR_SDRPLL_VCO_OUTRSTALL_SET_MSK);\r
 633 \r
 634             // deassert outresetall of main PLL\r
 635             alt_write_word(ALT_CLKMGR_SDRPLL_VCO_ADDR, temp & ALT_CLKMGR_SDRPLL_VCO_OUTRSTALL_CLR_MSK);\r
 636             alt_clk_plls_settle_wait();\r
 637 \r
 638             // remove bypass - don't think that there's any need to touch the bypass clock source\r
 639             alt_clrbits_word(ALT_CLKMGR_BYPASS_ADDR, ALT_CLKMGR_BYPASS_SDRPLLSRC_SET_MSK);\r
 640             status = alt_clk_plls_settle_wait();\r
 641         }\r
 642     }\r
 643     else\r
 644     {\r
 645         status = ALT_E_ERROR;\r
 646     }\r
 647 \r
 648     return status;\r
 649 }\r
 650 \r
 651 \r
 652 /****************************************************************************************/\r
 653 /* alt_clk_pll_bypass_enable() enable bypass mode for the specified PLL.                */\r
 654 /****************************************************************************************/\r
 655 \r
 656 ALT_STATUS_CODE alt_clk_pll_bypass_enable(ALT_CLK_t pll, bool use_input_mux)\r
 657 {\r
 658     ALT_STATUS_CODE status = ALT_E_BAD_ARG;\r
 659     uint32_t        temp;\r
 660 #ifdef  ALT_PREVENT_GLITCH_BYP\r
 661     uint32_t        temp1;\r
 662     bool            restore_0 = false;\r
 663     bool            restore_1 = false;\r
 664 #endif\r
 665 \r
 666     if (pll == ALT_CLK_MAIN_PLL)\r
 667     {\r
 668         if (!use_input_mux)\r
 669         {\r
 670 #ifdef  ALT_PREVENT_GLITCH_BYP\r
 671             // if L4MP or L4SP source is set to Main PLL C1, gate it off before changing\r
 672             // bypass state, then gate clock back on. FogBugz #63778\r
 673             temp  = alt_read_word(ALT_CLKMGR_MAINPLL_L4SRC_ADDR);\r
 674             temp1 = alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR);\r
 675 \r
 676             if ((temp1 & ALT_CLKMGR_MAINPLL_EN_L4MPCLK_SET_MSK) && (!(temp & ALT_CLKMGR_MAINPLL_L4SRC_L4MP_SET_MSK)))\r
 677             {\r
 678                 restore_0 = true;\r
 679             }\r
 680             if ((temp1 & ALT_CLKMGR_MAINPLL_EN_L4SPCLK_SET_MSK) && (!(temp & ALT_CLKMGR_MAINPLL_L4SRC_L4SP_SET_MSK)))\r
 681             {\r
 682                 restore_1 = true;\r
 683             }\r
 684             temp = temp1;\r
 685             if (restore_0) { temp &= ALT_CLKMGR_MAINPLL_EN_L4MPCLK_CLR_MSK; }\r
 686             if (restore_1) { temp &= ALT_CLKMGR_MAINPLL_EN_L4SPCLK_CLR_MSK; }\r
 687             if (restore_0 || restore_1) { alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp); }\r
 688 \r
 689             alt_setbits_word(ALT_CLKMGR_BYPASS_ADDR, ALT_CLKMGR_BYPASS_MAINPLL_SET_MSK);\r
 690                         // no input mux select on main PLL\r
 691 \r
 692             status = alt_clk_plls_settle_wait();\r
 693                         // wait before reenabling the L4MP and L4SP clocks\r
 694             if (restore_0 || restore_1) { alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp1); }\r
 695 \r
 696 #else\r
 697             alt_setbits_word(ALT_CLKMGR_BYPASS_ADDR, ALT_CLKMGR_BYPASS_MAINPLL_SET_MSK);\r
 698                         // no input mux select on main PLL\r
 699             status = alt_clk_plls_settle_wait();\r
 700 \r
 701 #endif\r
 702             status = ALT_E_SUCCESS;\r
 703         }\r
 704         else\r
 705         {\r
 706             status =  ALT_E_BAD_ARG;\r
 707         }\r
 708     }\r
 709     else if (pll == ALT_CLK_PERIPHERAL_PLL)\r
 710     {\r
 711 #ifdef  ALT_PREVENT_GLITCH_BYP\r
 712         // if L4MP or L4SP source is set to Peripheral PLL C1, gate it off before changing\r
 713         // bypass state, then gate clock back on. FogBugz #63778\r
 714         temp  = alt_read_word(ALT_CLKMGR_MAINPLL_L4SRC_ADDR);\r
 715         temp1 = alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR);\r
 716 \r
 717         if ((temp1 & ALT_CLKMGR_MAINPLL_EN_L4MPCLK_SET_MSK) && (temp & ALT_CLKMGR_MAINPLL_L4SRC_L4MP_SET_MSK))\r
 718         {\r
 719             restore_0 = true;\r
 720         }\r
 721         if ((temp1 & ALT_CLKMGR_MAINPLL_EN_L4SPCLK_SET_MSK) && (temp & ALT_CLKMGR_MAINPLL_L4SRC_L4SP_SET_MSK))\r
 722         {\r
 723             restore_1 = true;\r
 724         }\r
 725         temp = temp1;\r
 726         if (restore_0) { temp &= ALT_CLKMGR_MAINPLL_EN_L4MPCLK_CLR_MSK; }\r
 727         if (restore_1) { temp &= ALT_CLKMGR_MAINPLL_EN_L4SPCLK_CLR_MSK; }\r
 728         if (restore_0 || restore_1) { alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp); }\r
 729 \r
 730         temp = alt_read_word(ALT_CLKMGR_BYPASS_ADDR) &\r
 731                 (ALT_CLKMGR_BYPASS_PERPLL_CLR_MSK & ALT_CLKMGR_BYPASS_PERPLLSRC_CLR_MSK);\r
 732         temp |= (use_input_mux) ? ALT_CLKMGR_BYPASS_PERPLL_SET_MSK |\r
 733                 ALT_CLKMGR_BYPASS_PERPLLSRC_SET_MSK : ALT_CLKMGR_BYPASS_PERPLL_SET_MSK;\r
 734                     // set bypass bit and optionally the source select bit\r
 735 \r
 736         alt_write_word(ALT_CLKMGR_BYPASS_ADDR, temp);\r
 737         alt_clk_mgr_wait(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
 738                     // wait a bit before reenabling the L4MP and L4SP clocks\r
 739         if (restore_0 || restore_1) { alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp1); }\r
 740 \r
 741 #else\r
 742         temp = alt_read_word(ALT_CLKMGR_BYPASS_ADDR) &\r
 743                 (ALT_CLKMGR_BYPASS_PERPLL_CLR_MSK & ALT_CLKMGR_BYPASS_PERPLLSRC_CLR_MSK);\r
 744         temp |= (use_input_mux) ? ALT_CLKMGR_BYPASS_PERPLL_SET_MSK |\r
 745                 ALT_CLKMGR_BYPASS_PERPLLSRC_SET_MSK : ALT_CLKMGR_BYPASS_PERPLL_SET_MSK;\r
 746                     // set bypass bit and optionally the source select bit\r
 747 #endif\r
 748         status = ALT_E_SUCCESS;\r
 749     }\r
 750 \r
 751     else if (pll == ALT_CLK_SDRAM_PLL)\r
 752     {\r
 753         temp = alt_read_word(ALT_CLKMGR_BYPASS_ADDR) &\r
 754                 (ALT_CLKMGR_BYPASS_SDRPLL_CLR_MSK & ALT_CLKMGR_BYPASS_SDRPLLSRC_CLR_MSK);\r
 755         temp |= (use_input_mux) ? ALT_CLKMGR_BYPASS_SDRPLL_SET_MSK |\r
 756                 ALT_CLKMGR_BYPASS_SDRPLLSRC_SET_MSK : ALT_CLKMGR_BYPASS_SDRPLL_SET_MSK;\r
 757                     // set bypass bit and optionally the source select bit\r
 758         alt_write_word(ALT_CLKMGR_BYPASS_ADDR, temp);\r
 759         status = ALT_E_SUCCESS;\r
 760     }\r
 761     return status;\r
 762 }\r
 763 \r
 764 \r
 765 /****************************************************************************************/\r
 766 /* alt_clk_pll_is_bypassed() returns whether the specified PLL is in bypass or not.     */\r
 767 /* Bypass is a special state where the PLL VCO and the C0-C5 counters are bypassed      */\r
 768 /* and not in the circuit. Either the Osc1 clock input or the input chosen by the       */\r
 769 /* input mux may be selected to be operational in the bypass state. All changes to      */\r
 770 /* the PLL VCO must be made in bypass mode to avoid the potential of producing clock    */\r
 771 /* glitches which may affect downstream clock dividers and peripherals.                 */\r
 772 /****************************************************************************************/\r
 773 \r
 774 ALT_STATUS_CODE alt_clk_pll_is_bypassed(ALT_CLK_t pll)\r
 775 {\r
 776     ALT_STATUS_CODE status = ALT_E_BAD_ARG;\r
 777 \r
 778     if (pll == ALT_CLK_MAIN_PLL)\r
 779     {\r
 780         status = (ALT_CLKMGR_CTL_SAFEMOD_GET(alt_read_word(ALT_CLKMGR_CTL_ADDR))\r
 781                 || ALT_CLKMGR_BYPASS_MAINPLL_GET(alt_read_word(ALT_CLKMGR_BYPASS_ADDR)))\r
 782                 ? ALT_E_TRUE : ALT_E_FALSE;\r
 783     }\r
 784     else if (pll == ALT_CLK_PERIPHERAL_PLL)\r
 785     {\r
 786         status = (ALT_CLKMGR_CTL_SAFEMOD_GET(alt_read_word(ALT_CLKMGR_CTL_ADDR))\r
 787                 || ALT_CLKMGR_BYPASS_PERPLL_GET(alt_read_word(ALT_CLKMGR_BYPASS_ADDR)))\r
 788                 ? ALT_E_TRUE : ALT_E_FALSE;\r
 789     }\r
 790     else if (pll == ALT_CLK_SDRAM_PLL)\r
 791     {\r
 792         status = (ALT_CLKMGR_CTL_SAFEMOD_GET(alt_read_word(ALT_CLKMGR_CTL_ADDR))\r
 793                 || ALT_CLKMGR_BYPASS_SDRPLL_GET(alt_read_word(ALT_CLKMGR_BYPASS_ADDR)))\r
 794                 ? ALT_E_TRUE : ALT_E_FALSE;\r
 795     }\r
 796     return status;\r
 797 }\r
 798 \r
 799 \r
 800 /****************************************************************************************/\r
 801 /* alt_clk_pll_source_get() returns the current input of the specified PLL.             */\r
 802 /****************************************************************************************/\r
 803 \r
 804 ALT_CLK_t alt_clk_pll_source_get(ALT_CLK_t pll)\r
 805 {\r
 806     ALT_CLK_t      ret = ALT_CLK_UNKNOWN;\r
 807     uint32_t       temp;\r
 808 \r
 809 \r
 810     if (pll == ALT_CLK_MAIN_PLL)\r
 811     {\r
 812         ret = ALT_CLK_IN_PIN_OSC1;\r
 813     }\r
 814     else if (pll == ALT_CLK_PERIPHERAL_PLL)\r
 815     {\r
 816         // three possible clock sources for the peripheral PLL\r
 817         temp = ALT_CLKMGR_PERPLL_VCO_PSRC_GET(alt_read_word(ALT_CLKMGR_PERPLL_VCO_ADDR));\r
 818         if (temp == ALT_CLKMGR_PERPLL_VCO_PSRC_E_EOSC1)\r
 819         {\r
 820             ret = ALT_CLK_IN_PIN_OSC1;\r
 821         }\r
 822         else if (temp == ALT_CLKMGR_PERPLL_VCO_PSRC_E_EOSC2)\r
 823         {\r
 824             ret = ALT_CLK_IN_PIN_OSC2;\r
 825         }\r
 826         else if (temp == ALT_CLKMGR_PERPLL_VCO_PSRC_E_F2S_PERIPH_REF)\r
 827         {\r
 828             ret = ALT_CLK_F2H_PERIPH_REF;\r
 829         }\r
 830     }\r
 831     else if (pll == ALT_CLK_SDRAM_PLL)\r
 832     {\r
 833         // three possible clock sources for the SDRAM PLL\r
 834         temp = ALT_CLKMGR_SDRPLL_VCO_SSRC_GET(alt_read_word(ALT_CLKMGR_SDRPLL_VCO_ADDR));\r
 835         if (temp == ALT_CLKMGR_SDRPLL_VCO_SSRC_E_EOSC1)\r
 836         {\r
 837             ret = ALT_CLK_IN_PIN_OSC1;\r
 838         }\r
 839         else if (temp == ALT_CLKMGR_SDRPLL_VCO_SSRC_E_EOSC2)\r
 840         {\r
 841             ret = ALT_CLK_IN_PIN_OSC2;\r
 842         }\r
 843         else if (temp == ALT_CLKMGR_SDRPLL_VCO_SSRC_E_F2S_SDRAM_REF)\r
 844         {\r
 845             ret = ALT_CLK_F2H_SDRAM_REF;\r
 846         }\r
 847     }\r
 848     return ret;\r
 849 }\r
 850 \r
 851 //\r
 852 // alt_clk_clock_disable() disables the specified clock. Once the clock is disabled,\r
 853 // its clock signal does not propagate to its clocked elements.\r
 854 //\r
 855 ALT_STATUS_CODE alt_clk_clock_disable(ALT_CLK_t clk)\r
 856 {\r
 857     ALT_STATUS_CODE status = ALT_E_SUCCESS;\r
 858 \r
 859     switch (clk)\r
 860     {\r
 861         // For PLLs, put them in bypass mode.\r
 862     case ALT_CLK_MAIN_PLL:\r
 863     case ALT_CLK_PERIPHERAL_PLL:\r
 864     case ALT_CLK_SDRAM_PLL:\r
 865         status = alt_clk_pll_bypass_enable(clk, false);\r
 866         break;\r
 867 \r
 868         // Clocks that originate at the Main PLL.\r
 869     case ALT_CLK_L4_MAIN:\r
 870         alt_clrbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_L4MAINCLK_SET_MSK);\r
 871         break;\r
 872     case ALT_CLK_L3_MP:\r
 873         alt_clrbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_L3MPCLK_SET_MSK);\r
 874         break;\r
 875     case ALT_CLK_L4_MP:\r
 876         alt_clrbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_L4MPCLK_SET_MSK);\r
 877         break;\r
 878     case ALT_CLK_L4_SP:\r
 879         alt_clrbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_L4SPCLK_SET_MSK);\r
 880         break;\r
 881     case ALT_CLK_DBG_AT:\r
 882         alt_clrbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_DBGATCLK_SET_MSK);\r
 883         break;\r
 884     case ALT_CLK_DBG:\r
 885         alt_clrbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_DBGCLK_SET_MSK);\r
 886         break;\r
 887     case ALT_CLK_DBG_TRACE:\r
 888         alt_clrbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_DBGTRACECLK_SET_MSK);\r
 889         break;\r
 890     case ALT_CLK_DBG_TIMER:\r
 891         alt_clrbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_DBGTMRCLK_SET_MSK);\r
 892         break;\r
 893     case ALT_CLK_CFG:\r
 894         alt_clrbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_CFGCLK_SET_MSK);\r
 895         break;\r
 896     case ALT_CLK_H2F_USER0:\r
 897         alt_clrbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_S2FUSER0CLK_SET_MSK);\r
 898         break;\r
 899 \r
 900         // Clocks that originate at the Peripheral PLL.\r
 901     case ALT_CLK_EMAC0:\r
 902         alt_clrbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_EMAC0CLK_SET_MSK);\r
 903         break;\r
 904     case ALT_CLK_EMAC1:\r
 905         alt_clrbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_EMAC1CLK_SET_MSK);\r
 906         break;\r
 907     case ALT_CLK_USB_MP:\r
 908         alt_clrbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_USBCLK_SET_MSK);\r
 909         break;\r
 910     case ALT_CLK_SPI_M:\r
 911         alt_clrbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_SPIMCLK_SET_MSK);\r
 912         break;\r
 913     case ALT_CLK_CAN0:\r
 914         alt_clrbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_CAN0CLK_SET_MSK);\r
 915         break;\r
 916     case ALT_CLK_CAN1:\r
 917         alt_clrbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_CAN1CLK_SET_MSK);\r
 918         break;\r
 919     case ALT_CLK_GPIO_DB:\r
 920         alt_clrbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_GPIOCLK_SET_MSK);\r
 921         break;\r
 922     case ALT_CLK_H2F_USER1:\r
 923         alt_clrbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_S2FUSER1CLK_SET_MSK);\r
 924         break;\r
 925     case ALT_CLK_SDMMC:\r
 926         alt_clrbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_SDMMCCLK_SET_MSK);\r
 927         break;\r
 928     case ALT_CLK_NAND_X:\r
 929         alt_clrbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_NANDCLK_SET_MSK);\r
 930         alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_SW_MANAGED_CLK_WAIT_NANDCLK);\r
 931         // gate nand_clk off before nand_x_clk.\r
 932         alt_clrbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_NANDXCLK_SET_MSK);\r
 933         break;\r
 934     case ALT_CLK_NAND:\r
 935         alt_clrbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_NANDCLK_SET_MSK);\r
 936         break;\r
 937     case ALT_CLK_QSPI:\r
 938         alt_clrbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_QSPICLK_SET_MSK);\r
 939         break;\r
 940 \r
 941         // Clocks that originate at the SDRAM PLL.\r
 942     case ALT_CLK_DDR_DQS:\r
 943         alt_clrbits_word(ALT_CLKMGR_SDRPLL_EN_ADDR, ALT_CLKMGR_SDRPLL_EN_DDRDQSCLK_SET_MSK);\r
 944         break;\r
 945     case ALT_CLK_DDR_2X_DQS:\r
 946         alt_clrbits_word(ALT_CLKMGR_SDRPLL_EN_ADDR, ALT_CLKMGR_SDRPLL_EN_DDR2XDQSCLK_SET_MSK);\r
 947         break;\r
 948     case ALT_CLK_DDR_DQ:\r
 949         alt_clrbits_word(ALT_CLKMGR_SDRPLL_EN_ADDR, ALT_CLKMGR_SDRPLL_EN_DDRDQCLK_SET_MSK);\r
 950         break;\r
 951     case ALT_CLK_H2F_USER2:\r
 952         alt_clrbits_word(ALT_CLKMGR_SDRPLL_EN_ADDR, ALT_CLKMGR_SDRPLL_EN_S2FUSER2CLK_SET_MSK);\r
 953         break;\r
 954 \r
 955     default:\r
 956         status = ALT_E_BAD_ARG;\r
 957         break;\r
 958     }\r
 959 \r
 960     return status;\r
 961 }\r
 962 \r
 963 \r
 964 //\r
 965 // alt_clk_clock_enable() enables the specified clock. Once the clock is enabled, its\r
 966 // clock signal propagates to its elements.\r
 967 //\r
 968 ALT_STATUS_CODE alt_clk_clock_enable(ALT_CLK_t clk)\r
 969 {\r
 970     ALT_STATUS_CODE status = ALT_E_SUCCESS;\r
 971 \r
 972     switch (clk)\r
 973     {\r
 974         // For PLLs, take them out of bypass mode.\r
 975     case ALT_CLK_MAIN_PLL:\r
 976     case ALT_CLK_PERIPHERAL_PLL:\r
 977     case ALT_CLK_SDRAM_PLL:\r
 978         status = alt_clk_pll_bypass_disable(clk);\r
 979         break;\r
 980 \r
 981         // Clocks that originate at the Main PLL.\r
 982     case ALT_CLK_L4_MAIN:\r
 983         alt_setbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_L4MAINCLK_SET_MSK);\r
 984         break;\r
 985     case ALT_CLK_L3_MP:\r
 986         alt_setbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_L3MPCLK_SET_MSK);\r
 987         break;\r
 988     case ALT_CLK_L4_MP:\r
 989         alt_setbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_L4MPCLK_SET_MSK);\r
 990         break;\r
 991     case ALT_CLK_L4_SP:\r
 992         alt_setbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_L4SPCLK_SET_MSK);\r
 993         break;\r
 994     case ALT_CLK_DBG_AT:\r
 995         alt_setbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_DBGATCLK_SET_MSK);\r
 996         break;\r
 997     case ALT_CLK_DBG:\r
 998         alt_setbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_DBGCLK_SET_MSK);\r
 999         break;\r
1000     case ALT_CLK_DBG_TRACE:\r
1001         alt_setbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_DBGTRACECLK_SET_MSK);\r
1002         break;\r
1003     case ALT_CLK_DBG_TIMER:\r
1004         alt_setbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_DBGTMRCLK_SET_MSK);\r
1005         break;\r
1006     case ALT_CLK_CFG:\r
1007         alt_setbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_CFGCLK_SET_MSK);\r
1008         break;\r
1009     case ALT_CLK_H2F_USER0:\r
1010         alt_setbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_CLKMGR_MAINPLL_EN_S2FUSER0CLK_SET_MSK);\r
1011         break;\r
1012 \r
1013         // Clocks that originate at the Peripheral PLL.\r
1014     case ALT_CLK_EMAC0:\r
1015         alt_setbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_EMAC0CLK_SET_MSK);\r
1016         break;\r
1017     case ALT_CLK_EMAC1:\r
1018         alt_setbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_EMAC1CLK_SET_MSK);\r
1019         break;\r
1020     case ALT_CLK_USB_MP:\r
1021         alt_setbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_USBCLK_SET_MSK);\r
1022         break;\r
1023     case ALT_CLK_SPI_M:\r
1024         alt_setbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_SPIMCLK_SET_MSK);\r
1025         break;\r
1026     case ALT_CLK_CAN0:\r
1027         alt_setbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_CAN0CLK_SET_MSK);\r
1028         break;\r
1029     case ALT_CLK_CAN1:\r
1030         alt_setbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_CAN1CLK_SET_MSK);\r
1031         break;\r
1032     case ALT_CLK_GPIO_DB:\r
1033         alt_setbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_GPIOCLK_SET_MSK);\r
1034         break;\r
1035     case ALT_CLK_H2F_USER1:\r
1036         alt_setbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_S2FUSER1CLK_SET_MSK);\r
1037         break;\r
1038     case ALT_CLK_SDMMC:\r
1039         alt_setbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_SDMMCCLK_SET_MSK);\r
1040         break;\r
1041     case ALT_CLK_NAND_X:\r
1042         // implementation detail - should ALK_CLK_NAND be gated off here before enabling ALT_CLK_NAND_X?\r
1043         alt_setbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_NANDXCLK_SET_MSK);\r
1044         // implementation detail - should this wait be enforced here?\r
1045         alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_SW_MANAGED_CLK_WAIT_NANDCLK);\r
1046         break;\r
1047     case ALT_CLK_NAND:\r
1048         // enabling ALT_CLK_NAND always implies enabling ALT_CLK_NAND_X first\r
1049         alt_setbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_NANDXCLK_SET_MSK);\r
1050         alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_SW_MANAGED_CLK_WAIT_NANDCLK);\r
1051         // gate nand_x_clk on at least 8 MCU clocks before nand_clk\r
1052         alt_setbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_NANDCLK_SET_MSK);\r
1053         break;\r
1054     case ALT_CLK_QSPI:\r
1055         alt_setbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_QSPICLK_SET_MSK);\r
1056         break;\r
1057 \r
1058         // Clocks that originate at the SDRAM PLL.\r
1059     case ALT_CLK_DDR_DQS:\r
1060         alt_setbits_word(ALT_CLKMGR_SDRPLL_EN_ADDR, ALT_CLKMGR_SDRPLL_EN_DDRDQSCLK_SET_MSK);\r
1061         break;\r
1062     case ALT_CLK_DDR_2X_DQS:\r
1063         alt_setbits_word(ALT_CLKMGR_SDRPLL_EN_ADDR, ALT_CLKMGR_SDRPLL_EN_DDR2XDQSCLK_SET_MSK);\r
1064         break;\r
1065     case ALT_CLK_DDR_DQ:\r
1066         alt_setbits_word(ALT_CLKMGR_SDRPLL_EN_ADDR, ALT_CLKMGR_SDRPLL_EN_DDRDQCLK_SET_MSK);\r
1067         break;\r
1068     case ALT_CLK_H2F_USER2:\r
1069         alt_setbits_word(ALT_CLKMGR_SDRPLL_EN_ADDR, ALT_CLKMGR_SDRPLL_EN_S2FUSER2CLK_SET_MSK);\r
1070         break;\r
1071 \r
1072     default:\r
1073         status = ALT_E_BAD_ARG;\r
1074         break;\r
1075     }\r
1076 \r
1077     return status;\r
1078 }\r
1079 \r
1080 //\r
1081 // alt_clk_is_enabled() returns whether the specified clock is enabled or not.\r
1082 //\r
1083 ALT_STATUS_CODE alt_clk_is_enabled(ALT_CLK_t clk)\r
1084 {\r
1085     ALT_STATUS_CODE status = ALT_E_BAD_ARG;\r
1086 \r
1087     switch (clk)\r
1088     {\r
1089         // For PLLs, this function checks if the PLL is bypassed or not.\r
1090     case ALT_CLK_MAIN_PLL:\r
1091     case ALT_CLK_PERIPHERAL_PLL:\r
1092     case ALT_CLK_SDRAM_PLL:\r
1093         status = (alt_clk_pll_is_bypassed(clk) != ALT_E_TRUE);\r
1094         break;\r
1095 \r
1096         // These clocks are not gated, so must return a ALT_E_BAD_ARG type error.\r
1097     case ALT_CLK_MAIN_PLL_C0:\r
1098     case ALT_CLK_MAIN_PLL_C1:\r
1099     case ALT_CLK_MAIN_PLL_C2:\r
1100     case ALT_CLK_MAIN_PLL_C3:\r
1101     case ALT_CLK_MAIN_PLL_C4:\r
1102     case ALT_CLK_MAIN_PLL_C5:\r
1103     case ALT_CLK_MPU:\r
1104     case ALT_CLK_MPU_L2_RAM:\r
1105     case ALT_CLK_MPU_PERIPH:\r
1106     case ALT_CLK_L3_MAIN:\r
1107     case ALT_CLK_L3_SP:\r
1108     case ALT_CLK_DBG_BASE:\r
1109     case ALT_CLK_MAIN_QSPI:\r
1110     case ALT_CLK_MAIN_NAND_SDMMC:\r
1111     case ALT_CLK_PERIPHERAL_PLL_C0:\r
1112     case ALT_CLK_PERIPHERAL_PLL_C1:\r
1113     case ALT_CLK_PERIPHERAL_PLL_C2:\r
1114     case ALT_CLK_PERIPHERAL_PLL_C3:\r
1115     case ALT_CLK_PERIPHERAL_PLL_C4:\r
1116     case ALT_CLK_PERIPHERAL_PLL_C5:\r
1117     case ALT_CLK_SDRAM_PLL_C0:\r
1118     case ALT_CLK_SDRAM_PLL_C1:\r
1119     case ALT_CLK_SDRAM_PLL_C2:\r
1120     case ALT_CLK_SDRAM_PLL_C5:\r
1121         status = ALT_E_BAD_ARG;\r
1122         break;\r
1123 \r
1124         // Clocks that originate at the Main PLL.\r
1125     case ALT_CLK_L4_MAIN:\r
1126         status = (ALT_CLKMGR_MAINPLL_EN_L4MAINCLK_GET(alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR)))\r
1127             ? ALT_E_TRUE : ALT_E_FALSE;\r
1128         break;\r
1129     case ALT_CLK_L3_MP:\r
1130         status = (ALT_CLKMGR_MAINPLL_EN_L3MPCLK_GET(alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR)))\r
1131             ? ALT_E_TRUE : ALT_E_FALSE;\r
1132         break;\r
1133     case ALT_CLK_L4_MP:\r
1134         status = (ALT_CLKMGR_MAINPLL_EN_L4MPCLK_GET(alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR)))\r
1135             ? ALT_E_TRUE : ALT_E_FALSE;\r
1136         break;\r
1137     case ALT_CLK_L4_SP:\r
1138         status = (ALT_CLKMGR_MAINPLL_EN_L4SPCLK_GET(alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR)))\r
1139             ? ALT_E_TRUE : ALT_E_FALSE;\r
1140         break;\r
1141     case ALT_CLK_DBG_AT:\r
1142         status = (ALT_CLKMGR_MAINPLL_EN_DBGATCLK_GET(alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR)))\r
1143             ? ALT_E_TRUE : ALT_E_FALSE;\r
1144         break;\r
1145     case ALT_CLK_DBG:\r
1146         status = (ALT_CLKMGR_MAINPLL_EN_DBGCLK_GET(alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR)))\r
1147             ? ALT_E_TRUE : ALT_E_FALSE;\r
1148         break;\r
1149     case ALT_CLK_DBG_TRACE:\r
1150         status = (ALT_CLKMGR_MAINPLL_EN_DBGTRACECLK_GET(alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR)))\r
1151             ? ALT_E_TRUE : ALT_E_FALSE;\r
1152         break;\r
1153     case ALT_CLK_DBG_TIMER:\r
1154         status = (ALT_CLKMGR_MAINPLL_EN_DBGTMRCLK_GET(alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR)))\r
1155             ? ALT_E_TRUE : ALT_E_FALSE;\r
1156         break;\r
1157     case ALT_CLK_CFG:\r
1158         status = (ALT_CLKMGR_MAINPLL_EN_CFGCLK_GET(alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR)))\r
1159             ? ALT_E_TRUE : ALT_E_FALSE;\r
1160         break;\r
1161     case ALT_CLK_H2F_USER0:\r
1162         status = (ALT_CLKMGR_MAINPLL_EN_S2FUSER0CLK_GET(alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR)))\r
1163             ? ALT_E_TRUE : ALT_E_FALSE;\r
1164         break;\r
1165 \r
1166         // Clocks that originate at the Peripheral PLL.\r
1167     case ALT_CLK_EMAC0:\r
1168         status = (ALT_CLKMGR_PERPLL_EN_EMAC0CLK_GET(alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR)))\r
1169             ? ALT_E_TRUE : ALT_E_FALSE;\r
1170         break;\r
1171     case ALT_CLK_EMAC1:\r
1172         status = (ALT_CLKMGR_PERPLL_EN_EMAC1CLK_GET(alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR)))\r
1173             ? ALT_E_TRUE : ALT_E_FALSE;\r
1174         break;\r
1175     case ALT_CLK_USB_MP:\r
1176         status = (ALT_CLKMGR_PERPLL_EN_USBCLK_GET(alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR)))\r
1177             ? ALT_E_TRUE : ALT_E_FALSE;\r
1178         break;\r
1179     case ALT_CLK_SPI_M:\r
1180         status = (ALT_CLKMGR_PERPLL_EN_SPIMCLK_GET(alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR)))\r
1181             ? ALT_E_TRUE : ALT_E_FALSE;\r
1182         break;\r
1183     case ALT_CLK_CAN0:\r
1184         status = (ALT_CLKMGR_PERPLL_EN_CAN0CLK_GET(alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR)))\r
1185             ? ALT_E_TRUE : ALT_E_FALSE;\r
1186         break;\r
1187     case ALT_CLK_CAN1:\r
1188         status = (ALT_CLKMGR_PERPLL_EN_CAN1CLK_GET(alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR)))\r
1189             ? ALT_E_TRUE : ALT_E_FALSE;\r
1190         break;\r
1191     case ALT_CLK_GPIO_DB:\r
1192         status = (ALT_CLKMGR_PERPLL_EN_GPIOCLK_GET(alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR)))\r
1193             ? ALT_E_TRUE : ALT_E_FALSE;\r
1194         break;\r
1195     case ALT_CLK_H2F_USER1:\r
1196         status = (ALT_CLKMGR_PERPLL_EN_S2FUSER1CLK_GET(alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR)))\r
1197             ? ALT_E_TRUE : ALT_E_FALSE;\r
1198         break;\r
1199 \r
1200         // Clocks that may originate at the Main PLL, the Peripheral PLL, or the FPGA.\r
1201     case ALT_CLK_SDMMC:\r
1202         status = (ALT_CLKMGR_PERPLL_EN_SDMMCCLK_GET(alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR)))\r
1203             ? ALT_E_TRUE : ALT_E_FALSE;\r
1204         break;\r
1205     case ALT_CLK_NAND_X:\r
1206         status = (ALT_CLKMGR_PERPLL_EN_NANDXCLK_GET(alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR)))\r
1207             ? ALT_E_TRUE : ALT_E_FALSE;\r
1208         break;\r
1209     case ALT_CLK_NAND:\r
1210         status = (ALT_CLKMGR_PERPLL_EN_NANDCLK_GET(alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR)))\r
1211             ? ALT_E_TRUE : ALT_E_FALSE;\r
1212         break;\r
1213     case ALT_CLK_QSPI:\r
1214         status = (ALT_CLKMGR_PERPLL_EN_QSPICLK_GET(alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR)))\r
1215             ? ALT_E_TRUE : ALT_E_FALSE;\r
1216         break;\r
1217 \r
1218         // Clocks that originate at the SDRAM PLL.\r
1219     case ALT_CLK_DDR_DQS:\r
1220         status = (ALT_CLKMGR_SDRPLL_EN_DDRDQSCLK_GET(alt_read_word(ALT_CLKMGR_SDRPLL_EN_ADDR)))\r
1221             ? ALT_E_TRUE : ALT_E_FALSE;\r
1222         break;\r
1223     case ALT_CLK_DDR_2X_DQS:\r
1224         status = (ALT_CLKMGR_SDRPLL_EN_DDR2XDQSCLK_GET(alt_read_word(ALT_CLKMGR_SDRPLL_EN_ADDR)))\r
1225             ? ALT_E_TRUE : ALT_E_FALSE;\r
1226         break;\r
1227     case ALT_CLK_DDR_DQ:\r
1228         status = (ALT_CLKMGR_SDRPLL_EN_DDRDQCLK_GET(alt_read_word(ALT_CLKMGR_SDRPLL_EN_ADDR)))\r
1229             ? ALT_E_TRUE : ALT_E_FALSE;\r
1230         break;\r
1231     case ALT_CLK_H2F_USER2:\r
1232         status = (ALT_CLKMGR_SDRPLL_EN_S2FUSER2CLK_GET(alt_read_word(ALT_CLKMGR_SDRPLL_EN_ADDR)))\r
1233             ? ALT_E_TRUE : ALT_E_FALSE;\r
1234         break;\r
1235 \r
1236     default:\r
1237         status = ALT_E_BAD_ARG;\r
1238         break;\r
1239 \r
1240     }\r
1241 \r
1242     return status;\r
1243 }\r
1244 \r
1245 //\r
1246 // alt_clk_source_get() gets the input reference clock source selection value for the\r
1247 // specified clock or PLL.\r
1248 //\r
1249 ALT_CLK_t alt_clk_source_get(ALT_CLK_t clk)\r
1250 {\r
1251     ALT_CLK_t ret = ALT_CLK_UNKNOWN;\r
1252     uint32_t  temp;\r
1253 \r
1254     switch (clk)\r
1255     {\r
1256         // Potential external clock sources.\r
1257         // these clock entities are their own source\r
1258     case ALT_CLK_IN_PIN_OSC1:\r
1259     case ALT_CLK_IN_PIN_OSC2:\r
1260     case ALT_CLK_F2H_PERIPH_REF:\r
1261     case ALT_CLK_F2H_SDRAM_REF:\r
1262     case ALT_CLK_IN_PIN_JTAG:\r
1263     case ALT_CLK_IN_PIN_ULPI0:\r
1264     case ALT_CLK_IN_PIN_ULPI1:\r
1265     case ALT_CLK_IN_PIN_EMAC0_RX:\r
1266     case ALT_CLK_IN_PIN_EMAC1_RX:\r
1267         ret = clk;\r
1268         break;\r
1269 \r
1270         // Phase-Locked Loops.\r
1271     case ALT_CLK_MAIN_PLL:\r
1272     case ALT_CLK_OSC1:\r
1273         ret = ALT_CLK_IN_PIN_OSC1;\r
1274         break;\r
1275     case ALT_CLK_PERIPHERAL_PLL:\r
1276         ret = alt_clk_pll_source_get(ALT_CLK_PERIPHERAL_PLL);\r
1277         break;\r
1278     case ALT_CLK_SDRAM_PLL:\r
1279         ret = alt_clk_pll_source_get(ALT_CLK_SDRAM_PLL);\r
1280         break;\r
1281 \r
1282         // Main Clock Group.\r
1283     case ALT_CLK_MAIN_PLL_C0:\r
1284     case ALT_CLK_MAIN_PLL_C1:\r
1285     case ALT_CLK_MAIN_PLL_C2:\r
1286     case ALT_CLK_MAIN_PLL_C3:\r
1287     case ALT_CLK_MAIN_PLL_C4:\r
1288     case ALT_CLK_MAIN_PLL_C5:\r
1289         // check bypass, return either osc1 or PLL ID\r
1290         ret = (alt_clk_pll_is_bypassed(ALT_CLK_MAIN_PLL) == ALT_E_TRUE) ?\r
1291             ALT_CLK_IN_PIN_OSC1 : ALT_CLK_MAIN_PLL;\r
1292         break;\r
1293 \r
1294     case ALT_CLK_MPU_PERIPH:\r
1295     case ALT_CLK_MPU_L2_RAM:\r
1296     case ALT_CLK_MPU:\r
1297         ret = (alt_clk_pll_is_bypassed(ALT_CLK_MAIN_PLL) == ALT_E_TRUE) ?\r
1298             ALT_CLK_IN_PIN_OSC1 : ALT_CLK_MAIN_PLL_C0;\r
1299         break;\r
1300 \r
1301     case ALT_CLK_L4_MAIN:\r
1302     case ALT_CLK_L3_MAIN:\r
1303     case ALT_CLK_L3_MP:\r
1304     case ALT_CLK_L3_SP:\r
1305         ret = (alt_clk_pll_is_bypassed(ALT_CLK_MAIN_PLL) == ALT_E_TRUE) ?\r
1306             ALT_CLK_IN_PIN_OSC1 : ALT_CLK_MAIN_PLL_C1;\r
1307         break;\r
1308 \r
1309     case ALT_CLK_L4_MP:\r
1310         // read the state of the L4_mp source bit\r
1311         if ((ALT_CLKMGR_MAINPLL_L4SRC_L4MP_GET(alt_read_word(ALT_CLKMGR_MAINPLL_L4SRC_ADDR)))\r
1312             == ALT_CLKMGR_MAINPLL_L4SRC_L4MP_E_MAINPLL)\r
1313         {\r
1314             ret = (alt_clk_pll_is_bypassed(ALT_CLK_MAIN_PLL) == ALT_E_TRUE) ?\r
1315                 ALT_CLK_IN_PIN_OSC1 : ALT_CLK_MAIN_PLL_C1;\r
1316         }\r
1317         else\r
1318         {\r
1319             // if the clock comes from periph_base_clk\r
1320             ret = (alt_clk_pll_is_bypassed(ALT_CLK_PERIPHERAL_PLL) == ALT_E_TRUE) ?\r
1321                 alt_clk_pll_source_get(ALT_CLK_PERIPHERAL_PLL) : ALT_CLK_PERIPHERAL_PLL_C4;\r
1322         }\r
1323         break;\r
1324 \r
1325     case ALT_CLK_L4_SP:\r
1326         // read the state of the source bit\r
1327         if ((ALT_CLKMGR_MAINPLL_L4SRC_L4SP_GET(alt_read_word(ALT_CLKMGR_MAINPLL_L4SRC_ADDR)))\r
1328             == ALT_CLKMGR_MAINPLL_L4SRC_L4SP_E_MAINPLL)\r
1329         {\r
1330             ret = (alt_clk_pll_is_bypassed(ALT_CLK_MAIN_PLL) == ALT_E_TRUE) ?\r
1331                 ALT_CLK_IN_PIN_OSC1 : ALT_CLK_MAIN_PLL_C1;\r
1332         }\r
1333         else\r
1334         {\r
1335             // if the clock comes from periph_base_clk\r
1336             ret = (alt_clk_pll_is_bypassed(ALT_CLK_PERIPHERAL_PLL) == ALT_E_TRUE) ?\r
1337                 alt_clk_pll_source_get(ALT_CLK_PERIPHERAL_PLL) : ALT_CLK_PERIPHERAL_PLL_C4;\r
1338         }\r
1339         break;\r
1340 \r
1341     case ALT_CLK_DBG_BASE:\r
1342     case ALT_CLK_DBG_AT:\r
1343     case ALT_CLK_DBG_TRACE:\r
1344     case ALT_CLK_DBG_TIMER:\r
1345     case ALT_CLK_DBG:\r
1346         ret = (alt_clk_pll_is_bypassed(ALT_CLK_MAIN_PLL) == ALT_E_TRUE) ?\r
1347             ALT_CLK_OSC1 : ALT_CLK_MAIN_PLL_C2;\r
1348         break;\r
1349     case ALT_CLK_MAIN_QSPI:\r
1350         ret = (alt_clk_pll_is_bypassed(ALT_CLK_MAIN_PLL) == ALT_E_TRUE) ?\r
1351             ALT_CLK_OSC1 : ALT_CLK_MAIN_PLL_C3;\r
1352         break;\r
1353     case ALT_CLK_MAIN_NAND_SDMMC:\r
1354         ret = (alt_clk_pll_is_bypassed(ALT_CLK_MAIN_PLL) == ALT_E_TRUE) ?\r
1355             ALT_CLK_OSC1 : ALT_CLK_MAIN_PLL_C4;\r
1356         break;\r
1357     case ALT_CLK_CFG:\r
1358     case ALT_CLK_H2F_USER0:\r
1359         ret = (alt_clk_pll_is_bypassed(ALT_CLK_MAIN_PLL) == ALT_E_TRUE) ?\r
1360             ALT_CLK_OSC1 : ALT_CLK_MAIN_PLL_C5;\r
1361         break;\r
1362 \r
1363         // Peripherals Clock Group\r
1364     case ALT_CLK_PERIPHERAL_PLL_C0:\r
1365     case ALT_CLK_PERIPHERAL_PLL_C1:\r
1366     case ALT_CLK_PERIPHERAL_PLL_C2:\r
1367     case ALT_CLK_PERIPHERAL_PLL_C3:\r
1368     case ALT_CLK_PERIPHERAL_PLL_C4:\r
1369     case ALT_CLK_PERIPHERAL_PLL_C5:\r
1370         // if the clock comes from periph_base_clk\r
1371         ret = (alt_clk_pll_is_bypassed(ALT_CLK_PERIPHERAL_PLL) == ALT_E_TRUE) ?\r
1372             alt_clk_pll_source_get(ALT_CLK_PERIPHERAL_PLL) : ALT_CLK_PERIPHERAL_PLL;\r
1373         break;\r
1374 \r
1375     case ALT_CLK_EMAC0:\r
1376         ret = (alt_clk_pll_is_bypassed(ALT_CLK_PERIPHERAL_PLL) == ALT_E_TRUE) ?\r
1377             alt_clk_pll_source_get(ALT_CLK_PERIPHERAL_PLL) :  ALT_CLK_PERIPHERAL_PLL_C0;\r
1378         break;\r
1379 \r
1380     case ALT_CLK_EMAC1:\r
1381         ret = (alt_clk_pll_is_bypassed(ALT_CLK_PERIPHERAL_PLL) == ALT_E_TRUE) ?\r
1382             alt_clk_pll_source_get(ALT_CLK_PERIPHERAL_PLL) :  ALT_CLK_PERIPHERAL_PLL_C1;\r
1383         break;\r
1384 \r
1385     case ALT_CLK_USB_MP:\r
1386     case ALT_CLK_SPI_M:\r
1387     case ALT_CLK_CAN0:\r
1388     case ALT_CLK_CAN1:\r
1389     case ALT_CLK_GPIO_DB:\r
1390         ret = (alt_clk_pll_is_bypassed(ALT_CLK_PERIPHERAL_PLL) == ALT_E_TRUE) ?\r
1391             alt_clk_pll_source_get(ALT_CLK_PERIPHERAL_PLL) :  ALT_CLK_PERIPHERAL_PLL_C4;\r
1392         break;\r
1393 \r
1394     case ALT_CLK_H2F_USER1:\r
1395         ret = (alt_clk_pll_is_bypassed(ALT_CLK_PERIPHERAL_PLL) == ALT_E_TRUE) ?\r
1396             alt_clk_pll_source_get(ALT_CLK_PERIPHERAL_PLL) :  ALT_CLK_PERIPHERAL_PLL_C5;\r
1397         break;\r
1398 \r
1399     case ALT_CLK_SDMMC:\r
1400         temp = ALT_CLKMGR_PERPLL_SRC_SDMMC_GET(alt_read_word(ALT_CLKMGR_PERPLL_SRC_ADDR));\r
1401         if (temp == ALT_CLKMGR_PERPLL_SRC_SDMMC_E_F2S_PERIPH_REF_CLK)\r
1402         {\r
1403             ret = ALT_CLK_F2H_PERIPH_REF;\r
1404         }\r
1405         else if (temp == ALT_CLKMGR_PERPLL_SRC_SDMMC_E_MAIN_NAND_CLK)\r
1406         {\r
1407             ret = (alt_clk_pll_is_bypassed(ALT_CLK_MAIN_PLL) == ALT_E_TRUE) ?\r
1408                 ALT_CLK_IN_PIN_OSC1 : ALT_CLK_MAIN_PLL_C4;\r
1409         }\r
1410         else if (temp == ALT_CLKMGR_PERPLL_SRC_SDMMC_E_PERIPH_NAND_CLK)\r
1411         {\r
1412             ret = (alt_clk_pll_is_bypassed(ALT_CLK_PERIPHERAL_PLL) == ALT_E_TRUE) ?\r
1413                 alt_clk_pll_source_get(ALT_CLK_PERIPHERAL_PLL) :  ALT_CLK_PERIPHERAL_PLL_C3;\r
1414         }\r
1415         break;\r
1416 \r
1417     case ALT_CLK_NAND_X:\r
1418     case ALT_CLK_NAND:\r
1419         temp = ALT_CLKMGR_PERPLL_SRC_NAND_GET(alt_read_word(ALT_CLKMGR_PERPLL_SRC_ADDR));\r
1420         if (temp == ALT_CLKMGR_PERPLL_SRC_NAND_E_F2S_PERIPH_REF_CLK)\r
1421         {\r
1422             ret = ALT_CLK_F2H_PERIPH_REF;\r
1423         }\r
1424         else if (temp == ALT_CLKMGR_PERPLL_SRC_NAND_E_MAIN_NAND_CLK)\r
1425         {\r
1426             ret = (alt_clk_pll_is_bypassed(ALT_CLK_MAIN_PLL) == ALT_E_TRUE) ?\r
1427                 ALT_CLK_IN_PIN_OSC1 : ALT_CLK_MAIN_PLL_C4;\r
1428         }\r
1429         else if (temp == ALT_CLKMGR_PERPLL_SRC_NAND_E_PERIPH_NAND_CLK)\r
1430         {\r
1431             ret = (alt_clk_pll_is_bypassed(ALT_CLK_PERIPHERAL_PLL) == ALT_E_TRUE) ?\r
1432                 alt_clk_pll_source_get(ALT_CLK_PERIPHERAL_PLL) :  ALT_CLK_PERIPHERAL_PLL_C3;\r
1433         }\r
1434         break;\r
1435 \r
1436     case ALT_CLK_QSPI:\r
1437         temp = ALT_CLKMGR_PERPLL_SRC_QSPI_GET(alt_read_word(ALT_CLKMGR_PERPLL_SRC_ADDR));\r
1438         if (temp == ALT_CLKMGR_PERPLL_SRC_QSPI_E_F2S_PERIPH_REF_CLK)\r
1439         {\r
1440             ret = ALT_CLK_F2H_PERIPH_REF;\r
1441         }\r
1442         else if (temp == ALT_CLKMGR_PERPLL_SRC_QSPI_E_MAIN_QSPI_CLK)\r
1443         {\r
1444             ret = (alt_clk_pll_is_bypassed(ALT_CLK_MAIN_PLL) == ALT_E_TRUE) ?\r
1445                 ALT_CLK_IN_PIN_OSC1 : ALT_CLK_MAIN_PLL_C3;\r
1446         }\r
1447         else if (temp == ALT_CLKMGR_PERPLL_SRC_QSPI_E_PERIPH_QSPI_CLK)\r
1448         {\r
1449             ret = (alt_clk_pll_is_bypassed(ALT_CLK_PERIPHERAL_PLL) == ALT_E_TRUE) ?\r
1450                 alt_clk_pll_source_get(ALT_CLK_PERIPHERAL_PLL) :  ALT_CLK_PERIPHERAL_PLL_C2;\r
1451         }\r
1452         break;\r
1453 \r
1454         // SDRAM Clock Group\r
1455     case ALT_CLK_SDRAM_PLL_C0:\r
1456     case ALT_CLK_SDRAM_PLL_C1:\r
1457     case ALT_CLK_SDRAM_PLL_C2:\r
1458     case ALT_CLK_SDRAM_PLL_C3:\r
1459     case ALT_CLK_SDRAM_PLL_C4:\r
1460     case ALT_CLK_SDRAM_PLL_C5:\r
1461         ret = (alt_clk_pll_is_bypassed(ALT_CLK_SDRAM_PLL) == ALT_E_TRUE) ?\r
1462             alt_clk_pll_source_get(ALT_CLK_SDRAM_PLL) :  ALT_CLK_SDRAM_PLL;\r
1463         break;\r
1464     case ALT_CLK_DDR_DQS:\r
1465         ret = (alt_clk_pll_is_bypassed(ALT_CLK_SDRAM_PLL) == ALT_E_TRUE) ?\r
1466             alt_clk_pll_source_get(ALT_CLK_SDRAM_PLL) :  ALT_CLK_SDRAM_PLL_C0;\r
1467         break;\r
1468     case ALT_CLK_DDR_2X_DQS:\r
1469         ret = (alt_clk_pll_is_bypassed(ALT_CLK_SDRAM_PLL) == ALT_E_TRUE) ?\r
1470             alt_clk_pll_source_get(ALT_CLK_SDRAM_PLL) :  ALT_CLK_SDRAM_PLL_C1;\r
1471         break;\r
1472     case ALT_CLK_DDR_DQ:\r
1473         ret = (alt_clk_pll_is_bypassed(ALT_CLK_SDRAM_PLL) == ALT_E_TRUE) ?\r
1474             alt_clk_pll_source_get(ALT_CLK_SDRAM_PLL) :  ALT_CLK_SDRAM_PLL_C2;\r
1475         break;\r
1476     case ALT_CLK_H2F_USER2:\r
1477         ret = (alt_clk_pll_is_bypassed(ALT_CLK_SDRAM_PLL) == ALT_E_TRUE) ?\r
1478             alt_clk_pll_source_get(ALT_CLK_SDRAM_PLL) :  ALT_CLK_SDRAM_PLL_C5;\r
1479         break;\r
1480 \r
1481         // Clock Output Pins\r
1482     case ALT_CLK_OUT_PIN_EMAC0_TX:\r
1483     case ALT_CLK_OUT_PIN_EMAC1_TX:\r
1484     case ALT_CLK_OUT_PIN_SDMMC:\r
1485     case ALT_CLK_OUT_PIN_I2C0_SCL:\r
1486     case ALT_CLK_OUT_PIN_I2C1_SCL:\r
1487     case ALT_CLK_OUT_PIN_I2C2_SCL:\r
1488     case ALT_CLK_OUT_PIN_I2C3_SCL:\r
1489     case ALT_CLK_OUT_PIN_SPIM0:\r
1490     case ALT_CLK_OUT_PIN_SPIM1:\r
1491     case ALT_CLK_OUT_PIN_QSPI:\r
1492         ret = ALT_CLK_UNKNOWN;\r
1493         break;\r
1494 \r
1495     default:\r
1496         ret = ALT_CLK_UNKNOWN;\r
1497         break;\r
1498     }\r
1499 \r
1500     return ret;\r
1501 }\r
1502 \r
1503 //\r
1504 // alt_clk_source_set() sets the specified clock's input reference clock source\r
1505 // selection to the specified input. It does not handle gating the specified clock\r
1506 // off and back on, those are covered in other functions in this API, but it does\r
1507 // verify that the clock is off before changing the divider or PLL. Note that the PLL\r
1508 // must have regained phase-lock before being the bypass is disabled.\r
1509 //\r
1510 ALT_STATUS_CODE alt_clk_source_set(ALT_CLK_t clk, ALT_CLK_t ref_clk)\r
1511 {\r
1512     ALT_STATUS_CODE status = ALT_E_SUCCESS;\r
1513     uint32_t        temp;\r
1514 \r
1515     if (ALT_CLK_MAIN_PLL == clk)\r
1516     {\r
1517         if ((ref_clk == ALT_CLK_IN_PIN_OSC1) || (ref_clk == ALT_CLK_OSC1))\r
1518         {\r
1519             // ret = ALT_E_SUCCESS;\r
1520         }\r
1521         else\r
1522         {\r
1523             status = ALT_E_BAD_ARG;\r
1524         }\r
1525     }\r
1526     else if (ALT_CLK_PERIPHERAL_PLL == clk)\r
1527     {\r
1528         // the PLL must be bypassed before getting here\r
1529         temp  = alt_read_word(ALT_CLKMGR_PERPLL_VCO_ADDR);\r
1530         temp &= ALT_CLKMGR_PERPLL_VCO_PSRC_CLR_MSK;\r
1531 \r
1532         if ((ref_clk == ALT_CLK_IN_PIN_OSC1) || (ref_clk == ALT_CLK_OSC1))\r
1533         {\r
1534             temp |= ALT_CLKMGR_PERPLL_VCO_PSRC_SET(ALT_CLKMGR_PERPLL_VCO_PSRC_E_EOSC1);\r
1535             alt_write_word(ALT_CLKMGR_PERPLL_VCO_ADDR, temp);\r
1536         }\r
1537         else if (ref_clk == ALT_CLK_IN_PIN_OSC2)\r
1538         {\r
1539             temp |= ALT_CLKMGR_PERPLL_VCO_PSRC_SET(ALT_CLKMGR_PERPLL_VCO_PSRC_E_EOSC2);\r
1540             alt_write_word(ALT_CLKMGR_PERPLL_VCO_ADDR, temp);\r
1541         }\r
1542         else if (ref_clk == ALT_CLK_F2H_PERIPH_REF)\r
1543         {\r
1544             temp |= ALT_CLKMGR_PERPLL_VCO_PSRC_SET(ALT_CLKMGR_PERPLL_VCO_PSRC_E_F2S_PERIPH_REF);\r
1545             alt_write_word(ALT_CLKMGR_PERPLL_VCO_ADDR, temp);\r
1546         }\r
1547         else\r
1548         {\r
1549             status = ALT_E_INV_OPTION;\r
1550         }\r
1551     }\r
1552     else if (ALT_CLK_SDRAM_PLL == clk)\r
1553     {\r
1554         temp  = alt_read_word(ALT_CLKMGR_SDRPLL_VCO_ADDR);\r
1555         temp &= ALT_CLKMGR_SDRPLL_VCO_SSRC_CLR_MSK;\r
1556 \r
1557         if ((ref_clk == ALT_CLK_IN_PIN_OSC1) || (ref_clk == ALT_CLK_OSC1))\r
1558         {\r
1559             temp |= ALT_CLKMGR_SDRPLL_VCO_SSRC_SET(ALT_CLKMGR_SDRPLL_VCO_SSRC_E_EOSC1);\r
1560             alt_write_word(ALT_CLKMGR_SDRPLL_VCO_ADDR, temp);\r
1561         }\r
1562         else if (ref_clk == ALT_CLK_IN_PIN_OSC2)\r
1563         {\r
1564             temp |= ALT_CLKMGR_SDRPLL_VCO_SSRC_SET(ALT_CLKMGR_SDRPLL_VCO_SSRC_E_EOSC2);\r
1565             alt_write_word(ALT_CLKMGR_SDRPLL_VCO_ADDR, temp);\r
1566         }\r
1567         else if (ref_clk == ALT_CLK_F2H_SDRAM_REF)\r
1568         {\r
1569             temp |= ALT_CLKMGR_SDRPLL_VCO_SSRC_SET(ALT_CLKMGR_SDRPLL_VCO_SSRC_E_F2S_SDRAM_REF);\r
1570             alt_write_word(ALT_CLKMGR_SDRPLL_VCO_ADDR, temp);\r
1571         }\r
1572         else\r
1573         {\r
1574             status = ALT_E_INV_OPTION;\r
1575         }\r
1576     }\r
1577     else if ( ALT_CLK_L4_MP == clk)\r
1578     {\r
1579         // clock is gated off\r
1580         if (ref_clk == ALT_CLK_MAIN_PLL_C1)\r
1581         {\r
1582             alt_clrbits_word(ALT_CLKMGR_MAINPLL_L4SRC_ADDR, ALT_CLKMGR_MAINPLL_L4SRC_L4MP_SET_MSK);\r
1583         }\r
1584         else if (ref_clk == ALT_CLK_PERIPHERAL_PLL_C4)\r
1585         {\r
1586             alt_setbits_word(ALT_CLKMGR_MAINPLL_L4SRC_ADDR, ALT_CLKMGR_MAINPLL_L4SRC_L4MP_SET_MSK);\r
1587         }\r
1588         else\r
1589         {\r
1590             status = ALT_E_INV_OPTION;\r
1591         }\r
1592     }\r
1593     else if ( ALT_CLK_L4_SP == clk)\r
1594     {\r
1595         if (ref_clk == ALT_CLK_MAIN_PLL_C1)\r
1596         {\r
1597             alt_clrbits_word(ALT_CLKMGR_MAINPLL_L4SRC_ADDR, ALT_CLKMGR_MAINPLL_L4SRC_L4SP_SET_MSK);\r
1598         }\r
1599         else if (ref_clk == ALT_CLK_PERIPHERAL_PLL_C4)\r
1600         {\r
1601             alt_setbits_word(ALT_CLKMGR_MAINPLL_L4SRC_ADDR, ALT_CLKMGR_MAINPLL_L4SRC_L4SP_SET_MSK);\r
1602         }\r
1603         else\r
1604         {\r
1605             status = ALT_E_INV_OPTION;\r
1606         }\r
1607     }\r
1608     else if (ALT_CLK_SDMMC == clk)\r
1609     {\r
1610         temp  = alt_read_word(ALT_CLKMGR_PERPLL_SRC_ADDR);\r
1611         temp &= ALT_CLKMGR_PERPLL_SRC_SDMMC_CLR_MSK;\r
1612 \r
1613         if (ref_clk == ALT_CLK_F2H_PERIPH_REF)\r
1614         {\r
1615             temp |= ALT_CLKMGR_PERPLL_SRC_SDMMC_SET(ALT_CLKMGR_PERPLL_SRC_SDMMC_E_F2S_PERIPH_REF_CLK);\r
1616             alt_write_word(ALT_CLKMGR_PERPLL_SRC_ADDR, temp);\r
1617         }\r
1618         else if ((ref_clk == ALT_CLK_MAIN_PLL_C4) || (ref_clk == ALT_CLK_MAIN_NAND_SDMMC))\r
1619         {\r
1620             temp |= ALT_CLKMGR_PERPLL_SRC_SDMMC_SET(ALT_CLKMGR_PERPLL_SRC_SDMMC_E_MAIN_NAND_CLK);\r
1621             alt_write_word(ALT_CLKMGR_PERPLL_SRC_ADDR, temp);\r
1622         }\r
1623         else if (ref_clk == ALT_CLK_PERIPHERAL_PLL_C3)\r
1624         {\r
1625             temp |= ALT_CLKMGR_PERPLL_SRC_SDMMC_SET(ALT_CLKMGR_PERPLL_SRC_SDMMC_E_PERIPH_NAND_CLK);\r
1626             alt_write_word(ALT_CLKMGR_PERPLL_SRC_ADDR, temp);\r
1627         }\r
1628         else\r
1629         {\r
1630             status = ALT_E_INV_OPTION;\r
1631         }\r
1632     }\r
1633     else if ((ALT_CLK_NAND_X == clk) || ( ALT_CLK_NAND == clk))\r
1634     {\r
1635         temp = alt_read_word(ALT_CLKMGR_PERPLL_SRC_ADDR);\r
1636         temp &= ALT_CLKMGR_PERPLL_SRC_NAND_CLR_MSK;\r
1637 \r
1638         if (ref_clk == ALT_CLK_F2H_PERIPH_REF)\r
1639         {\r
1640             temp |= ALT_CLKMGR_PERPLL_SRC_NAND_SET(ALT_CLKMGR_PERPLL_SRC_NAND_E_F2S_PERIPH_REF_CLK);\r
1641             alt_write_word(ALT_CLKMGR_PERPLL_SRC_ADDR, temp);\r
1642         }\r
1643         else if ((ref_clk == ALT_CLK_MAIN_PLL_C4) || (ref_clk == ALT_CLK_MAIN_NAND_SDMMC))\r
1644         {\r
1645             temp |= ALT_CLKMGR_PERPLL_SRC_NAND_SET(ALT_CLKMGR_PERPLL_SRC_NAND_E_MAIN_NAND_CLK);\r
1646             alt_write_word(ALT_CLKMGR_PERPLL_SRC_ADDR, temp);\r
1647         }\r
1648         else if (ref_clk == ALT_CLK_PERIPHERAL_PLL_C3)\r
1649         {\r
1650             temp |= ALT_CLKMGR_PERPLL_SRC_NAND_SET(ALT_CLKMGR_PERPLL_SRC_NAND_E_PERIPH_NAND_CLK);\r
1651             alt_write_word(ALT_CLKMGR_PERPLL_SRC_ADDR, temp);\r
1652         }\r
1653         else\r
1654         {\r
1655             status = ALT_E_INV_OPTION;\r
1656         }\r
1657     }\r
1658     else if (ALT_CLK_QSPI == clk)\r
1659     {\r
1660         temp  = alt_read_word(ALT_CLKMGR_PERPLL_SRC_ADDR);\r
1661         temp &= ALT_CLKMGR_PERPLL_SRC_QSPI_CLR_MSK;\r
1662 \r
1663         if (ref_clk == ALT_CLK_F2H_PERIPH_REF)\r
1664         {\r
1665             temp |= ALT_CLKMGR_PERPLL_SRC_QSPI_SET(ALT_CLKMGR_PERPLL_SRC_QSPI_E_F2S_PERIPH_REF_CLK);\r
1666             alt_write_word(ALT_CLKMGR_PERPLL_SRC_ADDR, temp);\r
1667         }\r
1668         else if ((ref_clk == ALT_CLK_MAIN_PLL_C3) || (ref_clk == ALT_CLK_MAIN_QSPI))\r
1669         {\r
1670             temp |= ALT_CLKMGR_PERPLL_SRC_QSPI_SET(ALT_CLKMGR_PERPLL_SRC_QSPI_E_MAIN_QSPI_CLK);\r
1671             alt_write_word(ALT_CLKMGR_PERPLL_SRC_ADDR, temp);\r
1672         }\r
1673         else if (ref_clk == ALT_CLK_PERIPHERAL_PLL_C2)\r
1674         {\r
1675             temp |= ALT_CLKMGR_PERPLL_SRC_QSPI_SET(ALT_CLKMGR_PERPLL_SRC_QSPI_E_PERIPH_QSPI_CLK);\r
1676             alt_write_word(ALT_CLKMGR_PERPLL_SRC_ADDR, temp);\r
1677         }\r
1678         else\r
1679         {\r
1680             status = ALT_E_INV_OPTION;\r
1681         }\r
1682     }\r
1683 \r
1684     return status;\r
1685 }\r
1686 \r
1687 //\r
1688 // alt_clk_ext_clk_freq_set() specifies the frequency of the external clock source as\r
1689 // a measure of Hz. This value is stored in a static array and used for calculations.\r
1690 // The supplied frequency should be within the Fmin and Fmax values allowed for the\r
1691 // external clock source.\r
1692 //\r
1693 ALT_STATUS_CODE alt_clk_ext_clk_freq_set(ALT_CLK_t clk, alt_freq_t freq)\r
1694 {\r
1695     ALT_STATUS_CODE status = ALT_E_BAD_ARG;\r
1696 \r
1697     if ((clk == ALT_CLK_IN_PIN_OSC1) || (clk == ALT_CLK_OSC1))      // two names for one input\r
1698     {\r
1699         if ((freq >= alt_ext_clk_paramblok.clkosc1.freqmin) && (freq <= alt_ext_clk_paramblok.clkosc1.freqmax))\r
1700         {\r
1701             alt_ext_clk_paramblok.clkosc1.freqcur = freq;\r
1702             status = ALT_E_SUCCESS;\r
1703         }\r
1704         else\r
1705         {\r
1706             status = ALT_E_ARG_RANGE;\r
1707         }\r
1708     }\r
1709     else if (clk == ALT_CLK_IN_PIN_OSC2)                            // the other clock input pin\r
1710     {\r
1711         if ((freq >= alt_ext_clk_paramblok.clkosc2.freqmin) && (freq <= alt_ext_clk_paramblok.clkosc2.freqmax))\r
1712         {\r
1713             alt_ext_clk_paramblok.clkosc2.freqcur = freq;\r
1714             status = ALT_E_SUCCESS;\r
1715         }\r
1716         else\r
1717         {\r
1718             status = ALT_E_ARG_RANGE;\r
1719         }\r
1720     }\r
1721     else if (clk == ALT_CLK_F2H_PERIPH_REF)                         // clock from the FPGA\r
1722     {\r
1723         if ((freq >= alt_ext_clk_paramblok.periph.freqmin) && (freq <= alt_ext_clk_paramblok.periph.freqmax))\r
1724         {\r
1725             alt_ext_clk_paramblok.periph.freqcur = freq;\r
1726             status = ALT_E_SUCCESS;\r
1727         }\r
1728         else\r
1729         {\r
1730             status = ALT_E_ARG_RANGE;\r
1731         }\r
1732     }\r
1733     else if (clk == ALT_CLK_F2H_SDRAM_REF)                          // clock from the FPGA SDRAM\r
1734     {\r
1735         if ((freq >= alt_ext_clk_paramblok.sdram.freqmin) && (freq <= alt_ext_clk_paramblok.sdram.freqmax))\r
1736         {\r
1737             alt_ext_clk_paramblok.sdram.freqcur = freq;\r
1738             status = ALT_E_SUCCESS;\r
1739         }\r
1740         else\r
1741         {\r
1742             status = ALT_E_ARG_RANGE;\r
1743         }\r
1744     }\r
1745     else\r
1746     {\r
1747         status = ALT_E_BAD_ARG;\r
1748     }\r
1749 \r
1750     return status;\r
1751 }\r
1752 \r
1753 \r
1754 //\r
1755 // alt_clk_ext_clk_freq_get returns the frequency of the external clock source as\r
1756 // a measure of Hz. This value is stored in a static array.\r
1757 //\r
1758 alt_freq_t alt_clk_ext_clk_freq_get(ALT_CLK_t clk)\r
1759 {\r
1760     uint32_t ret = 0;\r
1761 \r
1762     if ((clk == ALT_CLK_IN_PIN_OSC1) || (clk == ALT_CLK_OSC1))      // two names for one input\r
1763     {\r
1764         ret = alt_ext_clk_paramblok.clkosc1.freqcur;\r
1765     }\r
1766     else if (clk == ALT_CLK_IN_PIN_OSC2)\r
1767     {\r
1768         ret = alt_ext_clk_paramblok.clkosc2.freqcur;\r
1769     }\r
1770     else if (clk == ALT_CLK_F2H_PERIPH_REF)                         // clock from the FPGA\r
1771     {\r
1772         ret = alt_ext_clk_paramblok.periph.freqcur;\r
1773     }\r
1774     else if (clk == ALT_CLK_F2H_SDRAM_REF)                         // clock from the FPGA\r
1775     {\r
1776         ret = alt_ext_clk_paramblok.sdram.freqcur;\r
1777     }\r
1778     return ret;\r
1779 }\r
1780 \r
1781 \r
1782 //\r
1783 // alt_clk_pll_cfg_get() returns the current PLL configuration.\r
1784 //\r
1785 ALT_STATUS_CODE alt_clk_pll_cfg_get(ALT_CLK_t pll, ALT_CLK_PLL_CFG_t * pll_cfg)\r
1786 {\r
1787     ALT_STATUS_CODE        ret = ALT_E_ERROR;                  // return value\r
1788     uint32_t               temp;                               // temp variable\r
1789 \r
1790     if (pll_cfg == NULL)\r
1791     {\r
1792                 ret = ALT_E_BAD_ARG;\r
1793                 return ret;\r
1794     }\r
1795 \r
1796     if (pll == ALT_CLK_MAIN_PLL)\r
1797     {\r
1798         temp = alt_read_word(ALT_CLKMGR_MAINPLL_VCO_ADDR);\r
1799         pll_cfg->ref_clk = ALT_CLK_IN_PIN_OSC1;\r
1800         pll_cfg->mult = ALT_CLKMGR_MAINPLL_VCO_NUMER_GET(temp);\r
1801         pll_cfg->div = ALT_CLKMGR_MAINPLL_VCO_DENOM_GET(temp);\r
1802 \r
1803         // Get the C0-C5 divider values:\r
1804         pll_cfg->cntrs[0] = ALT_CLKMGR_MAINPLL_MPUCLK_CNT_GET(alt_read_word(ALT_CLKMGR_ALTERA_MPUCLK_ADDR));\r
1805         // C0 - mpu_clk\r
1806 \r
1807         pll_cfg->cntrs[1] = ALT_CLKMGR_MAINPLL_MAINCLK_CNT_GET(alt_read_word(ALT_CLKMGR_ALTERA_MAINCLK_ADDR));\r
1808         // C1 - main_clk\r
1809 \r
1810         pll_cfg->cntrs[2] = ALT_CLKMGR_MAINPLL_DBGATCLK_CNT_GET(alt_read_word(ALT_CLKMGR_MAINPLL_DBGATCLK_ADDR));\r
1811         // C2 - dbg_base_clk\r
1812 \r
1813         pll_cfg->cntrs[3] = ALT_CLKMGR_MAINPLL_MAINQSPICLK_CNT_GET(alt_read_word(ALT_CLKMGR_MAINPLL_MAINQSPICLK_ADDR));\r
1814         // C3 - main_qspi_clk\r
1815 \r
1816         pll_cfg->cntrs[4] = ALT_CLKMGR_MAINPLL_MAINNANDSDMMCCLK_CNT_GET(alt_read_word(ALT_CLKMGR_MAINPLL_MAINNANDSDMMCCLK_ADDR));\r
1817         // C4 - main_nand_sdmmc_clk\r
1818 \r
1819         pll_cfg->cntrs[5] = ALT_CLKMGR_MAINPLL_CFGS2FUSER0CLK_CNT_GET(alt_read_word(ALT_CLKMGR_MAINPLL_CFGS2FUSER0CLK_ADDR));\r
1820         // C5 - cfg_s2f_user0_clk aka cfg_h2f_user0_clk\r
1821 \r
1822         // The Main PLL C0-C5 outputs have no phase shift capabilities :\r
1823         pll_cfg->pshift[0] = pll_cfg->pshift[1] = pll_cfg->pshift[2] =\r
1824             pll_cfg->pshift[3] = pll_cfg->pshift[4] = pll_cfg->pshift[5] = 0;\r
1825         ret = ALT_E_SUCCESS;\r
1826     }\r
1827     else if (pll == ALT_CLK_PERIPHERAL_PLL)\r
1828     {\r
1829         temp = ALT_CLKMGR_PERPLL_VCO_PSRC_GET(alt_read_word(ALT_CLKMGR_PERPLL_VCO_ADDR));\r
1830         if (temp <= 2)\r
1831         {\r
1832             if (temp == ALT_CLKMGR_PERPLL_VCO_PSRC_E_EOSC1)\r
1833             {\r
1834                 pll_cfg->ref_clk = ALT_CLK_IN_PIN_OSC1;\r
1835             }\r
1836             else if (temp == ALT_CLKMGR_PERPLL_VCO_PSRC_E_EOSC2)\r
1837             {\r
1838                 pll_cfg->ref_clk = ALT_CLK_IN_PIN_OSC2;\r
1839             }\r
1840             else if (temp == ALT_CLKMGR_PERPLL_VCO_PSRC_E_F2S_PERIPH_REF)\r
1841             {\r
1842                 pll_cfg->ref_clk = ALT_CLK_F2H_PERIPH_REF;\r
1843             }\r
1844 \r
1845             temp = alt_read_word(ALT_CLKMGR_PERPLL_VCO_ADDR);\r
1846             pll_cfg->mult = ALT_CLKMGR_PERPLL_VCO_NUMER_GET(temp);\r
1847             pll_cfg->div = ALT_CLKMGR_PERPLL_VCO_DENOM_GET(temp);\r
1848 \r
1849             // Get the C0-C5 divider values:\r
1850             pll_cfg->cntrs[0] = ALT_CLKMGR_PERPLL_EMAC0CLK_CNT_GET(alt_read_word(ALT_CLKMGR_PERPLL_EMAC0CLK_ADDR));\r
1851             // C0 - emac0_clk\r
1852 \r
1853             pll_cfg->cntrs[1] = ALT_CLKMGR_PERPLL_EMAC1CLK_CNT_GET(alt_read_word(ALT_CLKMGR_PERPLL_EMAC1CLK_ADDR));\r
1854             // C1 - emac1_clk\r
1855 \r
1856             pll_cfg->cntrs[2] = ALT_CLKMGR_PERPLL_PERQSPICLK_CNT_GET(alt_read_word(ALT_CLKMGR_PERPLL_PERQSPICLK_ADDR));\r
1857             // C2 - periph_qspi_clk\r
1858 \r
1859             pll_cfg->cntrs[3] = ALT_CLKMGR_PERPLL_PERNANDSDMMCCLK_CNT_GET(alt_read_word(ALT_CLKMGR_PERPLL_PERNANDSDMMCCLK_ADDR));\r
1860             // C3 - periph_nand_sdmmc_clk\r
1861 \r
1862             pll_cfg->cntrs[4] = ALT_CLKMGR_PERPLL_PERBASECLK_CNT_GET(alt_read_word(ALT_CLKMGR_PERPLL_PERBASECLK_ADDR));\r
1863             // C4 - periph_base_clk\r
1864 \r
1865             pll_cfg->cntrs[5] = ALT_CLKMGR_PERPLL_S2FUSER1CLK_CNT_GET(alt_read_word(ALT_CLKMGR_PERPLL_S2FUSER1CLK_ADDR));\r
1866             // C5 - s2f_user1_clk\r
1867 \r
1868             // The Peripheral PLL C0-C5 outputs have no phase shift capabilities :\r
1869             pll_cfg->pshift[0] = pll_cfg->pshift[1] = pll_cfg->pshift[2] =\r
1870                 pll_cfg->pshift[3] = pll_cfg->pshift[4] = pll_cfg->pshift[5] = 0;\r
1871             ret = ALT_E_SUCCESS;\r
1872         }\r
1873     }\r
1874     else if (pll == ALT_CLK_SDRAM_PLL)\r
1875     {\r
1876         temp = ALT_CLKMGR_SDRPLL_VCO_SSRC_GET(alt_read_word(ALT_CLKMGR_SDRPLL_VCO_ADDR));\r
1877         if (temp <= 2)\r
1878         {\r
1879             if (temp == ALT_CLKMGR_SDRPLL_VCO_SSRC_E_EOSC1)\r
1880             {\r
1881                 pll_cfg->ref_clk = ALT_CLK_IN_PIN_OSC1;\r
1882             }\r
1883             else if (temp == ALT_CLKMGR_SDRPLL_VCO_SSRC_E_EOSC2)\r
1884             {\r
1885                 pll_cfg->ref_clk = ALT_CLK_IN_PIN_OSC2;\r
1886             }\r
1887             else if (temp == ALT_CLKMGR_SDRPLL_VCO_SSRC_E_F2S_SDRAM_REF)\r
1888             {\r
1889                 pll_cfg->ref_clk = ALT_CLK_F2H_SDRAM_REF;\r
1890             }\r
1891 \r
1892             pll_cfg->mult = ALT_CLKMGR_SDRPLL_VCO_NUMER_GET(alt_read_word(ALT_CLKMGR_SDRPLL_VCO_ADDR));\r
1893             pll_cfg->div = ALT_CLKMGR_SDRPLL_VCO_DENOM_GET(alt_read_word(ALT_CLKMGR_SDRPLL_VCO_ADDR));\r
1894 \r
1895             // Get the C0-C5 divider values:\r
1896             pll_cfg->cntrs[0]  = ALT_CLKMGR_SDRPLL_DDRDQSCLK_CNT_GET(alt_read_word(ALT_CLKMGR_SDRPLL_DDRDQSCLK_ADDR));\r
1897             pll_cfg->pshift[0] = ALT_CLKMGR_SDRPLL_DDRDQSCLK_PHASE_GET(alt_read_word(ALT_CLKMGR_SDRPLL_DDRDQSCLK_ADDR));\r
1898             // C0  - ddr_dqs_clk\r
1899 \r
1900             pll_cfg->cntrs[1]  = ALT_CLKMGR_SDRPLL_DDR2XDQSCLK_CNT_GET(alt_read_word(ALT_CLKMGR_SDRPLL_DDR2XDQSCLK_ADDR));\r
1901             pll_cfg->pshift[1] = ALT_CLKMGR_SDRPLL_DDR2XDQSCLK_PHASE_GET(alt_read_word(ALT_CLKMGR_SDRPLL_DDR2XDQSCLK_ADDR));\r
1902             // C1  - ddr_2x_dqs_clk\r
1903 \r
1904             pll_cfg->cntrs[2]  = ALT_CLKMGR_SDRPLL_DDRDQCLK_CNT_GET(alt_read_word(ALT_CLKMGR_SDRPLL_DDRDQCLK_ADDR));\r
1905             pll_cfg->pshift[2] = ALT_CLKMGR_SDRPLL_DDRDQCLK_PHASE_GET(alt_read_word(ALT_CLKMGR_SDRPLL_DDRDQCLK_ADDR));\r
1906             // C2  - ddr_dq_clk\r
1907 \r
1908             pll_cfg->cntrs[3]  = pll_cfg->cntrs[4] = pll_cfg->pshift[3] = pll_cfg->pshift[4] = 0;\r
1909             // C3  & C4 outputs don't exist on the SDRAM PLL\r
1910 \r
1911             pll_cfg->cntrs[5]  = ALT_CLKMGR_SDRPLL_S2FUSER2CLK_CNT_GET(alt_read_word(ALT_CLKMGR_SDRPLL_S2FUSER2CLK_ADDR));\r
1912             pll_cfg->pshift[5] = ALT_CLKMGR_SDRPLL_S2FUSER2CLK_PHASE_GET(alt_read_word(ALT_CLKMGR_SDRPLL_S2FUSER2CLK_ADDR));\r
1913             // C5  - s2f_user2_clk or h2f_user2_clk\r
1914 \r
1915             ret = ALT_E_SUCCESS;\r
1916         }\r
1917     }\r
1918 \r
1919     return ret;\r
1920 }\r
1921 \r
1922 \r
1923 //\r
1924 // alt_clk_pll_cfg_set() sets the PLL configuration using the configuration parameters\r
1925 // specified in pll_cfg.\r
1926 //\r
1927 ALT_STATUS_CODE alt_clk_pll_cfg_set(ALT_CLK_t pll, const ALT_CLK_PLL_CFG_t * pll_cfg)\r
1928 {\r
1929     if (pll_cfg == NULL)\r
1930     {\r
1931                 return ALT_E_BAD_ARG;\r
1932     }\r
1933 \r
1934     if (alt_clk_pll_is_bypassed(pll) != ALT_E_TRUE)         // safe to write the PLL registers?\r
1935     {\r
1936         return ALT_E_ERROR;\r
1937     }\r
1938 \r
1939     ALT_STATUS_CODE ret = ALT_E_ERROR;\r
1940     uint32_t        temp;\r
1941 \r
1942     if (pll == ALT_CLK_MAIN_PLL)\r
1943     {\r
1944         temp  = (ALT_CLKMGR_MAINPLL_VCO_NUMER_CLR_MSK & ALT_CLKMGR_MAINPLL_VCO_DENOM_CLR_MSK)\r
1945             & alt_read_word(ALT_CLKMGR_MAINPLL_VCO_ADDR);\r
1946         temp |= ALT_CLKMGR_MAINPLL_VCO_NUMER_SET(pll_cfg->mult) |\r
1947             ALT_CLKMGR_MAINPLL_VCO_DENOM_SET(pll_cfg->div);\r
1948 \r
1949         alt_write_word(ALT_CLKMGR_MAINPLL_VCO_ADDR, temp);\r
1950         alt_write_word(ALT_CLKMGR_ALTERA_MPUCLK_ADDR,           pll_cfg->cntrs[0]);\r
1951         alt_write_word(ALT_CLKMGR_ALTERA_MAINCLK_ADDR,          pll_cfg->cntrs[1]);\r
1952         alt_write_word(ALT_CLKMGR_MAINPLL_DBGATCLK_ADDR,         pll_cfg->cntrs[2]);\r
1953         alt_write_word(ALT_CLKMGR_MAINPLL_MAINQSPICLK_ADDR,      pll_cfg->cntrs[3]);\r
1954         alt_write_word(ALT_CLKMGR_MAINPLL_MAINNANDSDMMCCLK_ADDR, pll_cfg->cntrs[4]);\r
1955         alt_write_word(ALT_CLKMGR_MAINPLL_CFGS2FUSER0CLK_ADDR,   pll_cfg->cntrs[5]);\r
1956         ret = ALT_E_SUCCESS;\r
1957     }\r
1958     else if (pll == ALT_CLK_PERIPHERAL_PLL)\r
1959     {\r
1960         temp =  ALT_CLKMGR_PERPLL_VCO_NUMER_CLR_MSK & ALT_CLKMGR_PERPLL_VCO_DENOM_CLR_MSK\r
1961             & ALT_CLKMGR_PERPLL_VCO_PSRC_CLR_MSK;\r
1962         temp &= alt_read_word(ALT_CLKMGR_PERPLL_VCO_ADDR);\r
1963         temp |= ALT_CLKMGR_PERPLL_VCO_NUMER_SET(pll_cfg->mult)\r
1964             | ALT_CLKMGR_PERPLL_VCO_DENOM_SET(pll_cfg->div);\r
1965 \r
1966         if ((pll_cfg->ref_clk == ALT_CLK_IN_PIN_OSC1) || (pll_cfg->ref_clk == ALT_CLK_OSC1))\r
1967         {\r
1968             temp |= ALT_CLKMGR_PERPLL_VCO_PSRC_SET(ALT_CLKMGR_PERPLL_VCO_PSRC_E_EOSC1);\r
1969         }\r
1970         else if (pll_cfg->ref_clk == ALT_CLK_IN_PIN_OSC2)\r
1971         {\r
1972             temp |= ALT_CLKMGR_PERPLL_VCO_PSRC_SET(ALT_CLKMGR_PERPLL_VCO_PSRC_E_EOSC2);\r
1973         }\r
1974         else if (pll_cfg->ref_clk == ALT_CLK_F2H_PERIPH_REF)\r
1975         {\r
1976             temp |= ALT_CLKMGR_PERPLL_VCO_PSRC_SET(ALT_CLKMGR_PERPLL_VCO_PSRC_E_F2S_PERIPH_REF);\r
1977         }\r
1978         else\r
1979         {\r
1980             return ret;\r
1981         }\r
1982 \r
1983         alt_write_word(ALT_CLKMGR_PERPLL_VCO_ADDR, temp);\r
1984         alt_write_word(ALT_CLKMGR_PERPLL_EMAC0CLK_ADDR,        pll_cfg->cntrs[0]);\r
1985         alt_write_word(ALT_CLKMGR_PERPLL_EMAC1CLK_ADDR,        pll_cfg->cntrs[1]);\r
1986         alt_write_word(ALT_CLKMGR_PERPLL_PERQSPICLK_ADDR,      pll_cfg->cntrs[2]);\r
1987         alt_write_word(ALT_CLKMGR_PERPLL_PERNANDSDMMCCLK_ADDR, pll_cfg->cntrs[3]);\r
1988         alt_write_word(ALT_CLKMGR_PERPLL_PERBASECLK_ADDR,      pll_cfg->cntrs[4]);\r
1989         alt_write_word(ALT_CLKMGR_PERPLL_S2FUSER1CLK_ADDR,     pll_cfg->cntrs[5]);\r
1990         ret = ALT_E_SUCCESS;\r
1991     }\r
1992     else if (pll == ALT_CLK_SDRAM_PLL)\r
1993     {\r
1994         // write the SDRAM PLL VCO Counter -----------------------------\r
1995         temp =  ALT_CLKMGR_SDRPLL_VCO_NUMER_CLR_MSK & ALT_CLKMGR_SDRPLL_VCO_DENOM_CLR_MSK\r
1996             & ALT_CLKMGR_SDRPLL_VCO_SSRC_CLR_MSK;           // make a mask\r
1997         temp &= alt_read_word(ALT_CLKMGR_SDRPLL_VCO_ADDR);\r
1998         temp |= ALT_CLKMGR_SDRPLL_VCO_NUMER_SET(pll_cfg->mult)\r
1999             | ALT_CLKMGR_SDRPLL_VCO_DENOM_SET(pll_cfg->div)\r
2000             | ALT_CLKMGR_SDRPLL_VCO_OUTRSTALL_SET_MSK;\r
2001         // setting this bit aligns the output phase of the counters and prevents\r
2002         // glitches and too-short clock periods when restarting.\r
2003         // this bit is cleared at the end of this routine\r
2004 \r
2005         if ((pll_cfg->ref_clk == ALT_CLK_IN_PIN_OSC1) || (pll_cfg->ref_clk == ALT_CLK_OSC1))\r
2006         {\r
2007             temp |= ALT_CLKMGR_SDRPLL_VCO_SSRC_SET(ALT_CLKMGR_SDRPLL_VCO_SSRC_E_EOSC1);\r
2008         }\r
2009         else if (pll_cfg->ref_clk == ALT_CLK_IN_PIN_OSC2)\r
2010         {\r
2011             temp |= ALT_CLKMGR_SDRPLL_VCO_SSRC_SET(ALT_CLKMGR_SDRPLL_VCO_SSRC_E_EOSC2);\r
2012         }\r
2013         else if (pll_cfg->ref_clk == ALT_CLK_F2H_PERIPH_REF)\r
2014         {\r
2015             temp |= ALT_CLKMGR_SDRPLL_VCO_SSRC_SET(ALT_CLKMGR_SDRPLL_VCO_SSRC_E_F2S_SDRAM_REF);\r
2016         }\r
2017         else\r
2018         {\r
2019             return ret;\r
2020         }\r
2021 \r
2022         alt_write_word(ALT_CLKMGR_SDRPLL_VCO_ADDR, temp);\r
2023 \r
2024         // write the SDRAM PLL C0 Divide Counter -----------------------------\r
2025         temp =  ALT_CLKMGR_SDRPLL_DDRDQSCLK_CNT_SET(pll_cfg->cntrs[0])\r
2026             | ALT_CLKMGR_SDRPLL_DDRDQSCLK_PHASE_SET(pll_cfg->pshift[0]);\r
2027 \r
2028         alt_clk_pllcounter_write(ALT_CLKMGR_SDRPLL_VCO_ADDR, ALT_CLKMGR_STAT_ADDR,\r
2029                                  ALT_CLKMGR_SDRPLL_DDRDQSCLK_ADDR, temp,\r
2030                                  ALT_CLKMGR_SDRPLL_DDRDQSCLK_CNT_SET_MSK | ALT_CLKMGR_SDRPLL_DDRDQSCLK_PHASE_SET_MSK,\r
2031                                  ALT_CLKMGR_SDRPLL_DDRDQSCLK_CNT_LSB);\r
2032 \r
2033         // write the SDRAM PLL C1 Divide Counter -----------------------------\r
2034         if (ret == ALT_E_SUCCESS)\r
2035         {\r
2036             temp =  ALT_CLKMGR_SDRPLL_DDR2XDQSCLK_CNT_SET(pll_cfg->cntrs[1])\r
2037                 | ALT_CLKMGR_SDRPLL_DDR2XDQSCLK_PHASE_SET(pll_cfg->pshift[1]);\r
2038             alt_clk_pllcounter_write(ALT_CLKMGR_SDRPLL_VCO_ADDR, ALT_CLKMGR_STAT_ADDR,\r
2039                                      ALT_CLKMGR_SDRPLL_DDR2XDQSCLK_ADDR, temp,\r
2040                                      ALT_CLKMGR_SDRPLL_DDR2XDQSCLK_CNT_SET_MSK | ALT_CLKMGR_SDRPLL_DDR2XDQSCLK_PHASE_SET_MSK,\r
2041                                      ALT_CLKMGR_SDRPLL_DDR2XDQSCLK_CNT_LSB);\r
2042         }\r
2043 \r
2044         // write the SDRAM PLL C2 Divide Counter -----------------------------\r
2045         if (ret == ALT_E_SUCCESS)\r
2046         {\r
2047             temp =  ALT_CLKMGR_SDRPLL_DDRDQCLK_CNT_SET(pll_cfg->cntrs[2])\r
2048                 | ALT_CLKMGR_SDRPLL_DDRDQCLK_PHASE_SET(pll_cfg->pshift[2]);\r
2049             alt_clk_pllcounter_write(ALT_CLKMGR_SDRPLL_VCO_ADDR, ALT_CLKMGR_STAT_ADDR,\r
2050                                      ALT_CLKMGR_SDRPLL_DDRDQCLK_ADDR, temp,\r
2051                                      ALT_CLKMGR_SDRPLL_DDRDQCLK_CNT_SET_MSK | ALT_CLKMGR_SDRPLL_DDRDQCLK_PHASE_SET_MSK,\r
2052                                      ALT_CLKMGR_SDRPLL_DDRDQCLK_CNT_LSB);\r
2053         }\r
2054 \r
2055         // write the SDRAM PLL C5 Divide Counter -----------------------------\r
2056         if (ret == ALT_E_SUCCESS)\r
2057         {\r
2058             temp =  ALT_CLKMGR_SDRPLL_S2FUSER2CLK_CNT_SET(pll_cfg->cntrs[2])\r
2059                 | ALT_CLKMGR_SDRPLL_S2FUSER2CLK_PHASE_SET(pll_cfg->pshift[2]);\r
2060             alt_clk_pllcounter_write(ALT_CLKMGR_SDRPLL_VCO_ADDR, ALT_CLKMGR_STAT_ADDR,\r
2061                                      ALT_CLKMGR_SDRPLL_S2FUSER2CLK_ADDR, temp,\r
2062                                      ALT_CLKMGR_SDRPLL_S2FUSER2CLK_CNT_SET_MSK | ALT_CLKMGR_SDRPLL_S2FUSER2CLK_PHASE_SET_MSK,\r
2063                                      ALT_CLKMGR_SDRPLL_S2FUSER2CLK_CNT_LSB);\r
2064         }\r
2065 \r
2066         if (ret == ALT_E_SUCCESS)\r
2067         {\r
2068             alt_clrbits_word(ALT_CLKMGR_SDRPLL_VCO_ADDR, ALT_CLKMGR_SDRPLL_VCO_OUTRSTALL_SET_MSK);\r
2069             // allow the phase multiplexer and output counter to leave reset\r
2070         }\r
2071     }\r
2072 \r
2073     return ret;\r
2074 }\r
2075 \r
2076 \r
2077 //\r
2078 // alt_clk_pll_vco_cfg_get() returns the current PLL VCO frequency configuration.\r
2079 //\r
2080 ALT_STATUS_CODE alt_clk_pll_vco_cfg_get(ALT_CLK_t pll, uint32_t * mult, uint32_t * div)\r
2081 {\r
2082     ALT_STATUS_CODE status = ALT_E_SUCCESS;\r
2083     uint32_t        temp;\r
2084 \r
2085     if ( (mult == NULL) || (div == NULL) )\r
2086     {\r
2087                 return ALT_E_BAD_ARG;\r
2088     }\r
2089 \r
2090     if (pll == ALT_CLK_MAIN_PLL)\r
2091     {\r
2092         temp = alt_read_word(ALT_CLKMGR_MAINPLL_VCO_ADDR);\r
2093         *mult = ALT_CLKMGR_MAINPLL_VCO_NUMER_GET(temp) + 1;\r
2094         *div  = ALT_CLKMGR_MAINPLL_VCO_DENOM_GET(temp) + 1;\r
2095     }\r
2096     else if (pll == ALT_CLK_PERIPHERAL_PLL)\r
2097     {\r
2098         temp = alt_read_word(ALT_CLKMGR_PERPLL_VCO_ADDR);\r
2099         *mult = ALT_CLKMGR_PERPLL_VCO_NUMER_GET(temp) + 1;\r
2100         *div  = ALT_CLKMGR_PERPLL_VCO_DENOM_GET(temp) + 1;\r
2101     }\r
2102     else if (pll == ALT_CLK_SDRAM_PLL)\r
2103     {\r
2104         temp = alt_read_word(ALT_CLKMGR_SDRPLL_VCO_ADDR);\r
2105         *mult = ALT_CLKMGR_SDRPLL_VCO_NUMER_GET(temp) + 1;\r
2106         *div  = ALT_CLKMGR_SDRPLL_VCO_DENOM_GET(temp) + 1;\r
2107     }\r
2108     else\r
2109     {\r
2110         status = ALT_E_ERROR;\r
2111     }\r
2112 \r
2113     return status;\r
2114 }\r
2115 \r
2116 \r
2117 /****************************************************************************************/\r
2118 /* This enum enumerates a set of possible change methods that are available for use by  */\r
2119 /* alt_clk_pll_vco_cfg_set() to change VCO parameter settings.                          */\r
2120 /****************************************************************************************/\r
2121 \r
2122 typedef enum ALT_CLK_PLL_VCO_CHG_METHOD_e\r
2123 {\r
2124     ALT_VCO_CHG_NONE_VALID      = 0,            /*  No valid method to  change PLL\r
2125                                                  *  VCO was found                       */\r
2126     ALT_VCO_CHG_NOCHANGE        = 0x00000001,   /*  Proposed new VCO values are the\r
2127                                                  *  same as the old values              */\r
2128     ALT_VCO_CHG_NUM             = 0x00000002,   /*  Can change the VCO multiplier\r
2129                                                  *  alone                               */\r
2130     ALT_VCO_CHG_NUM_BYP         = 0x00000004,   /*  A VCO multiplier-only change will\r
2131                                                  *  require putting the PLL in bypass   */\r
2132     ALT_VCO_CHG_DENOM           = 0x00000008,   /*  Can change the VCO divider\r
2133                                                  *  alone                               */\r
2134     ALT_VCO_CHG_DENOM_BYP       = 0x00000010,   /*  A VCO divider-only change will\r
2135                                                  *  require putting the PLL in bypass   */\r
2136     ALT_VCO_CHG_NUM_DENOM       = 0x00000020,   /*  Can change the clock multiplier\r
2137                                                  *  first. then the clock divider       */\r
2138     ALT_VCO_CHG_NUM_DENOM_BYP   = 0x00000040,   /*  Changing the clock multiplier first.\r
2139                                                  *  then the clock divider will\r
2140                                                  *  require putting the PLL in bypass   */\r
2141     ALT_VCO_CHG_DENOM_NUM       = 0x00000080,   /*  Can change the clock divider first.\r
2142                                                  *  then the clock multiplier           */\r
2143     ALT_VCO_CHG_DENOM_NUM_BYP   = 0x00000100    /*  Changing the clock divider first.\r
2144                                                  *  then the clock multiplier will\r
2145                                                  *  require putting the PLL in bypass   */\r
2146 } ALT_CLK_PLL_VCO_CHG_METHOD_t;\r
2147 \r
2148 \r
2149 \r
2150 /****************************************************************************************/\r
2151 /* alt_clk_pll_vco_chg_methods_get() determines which possible methods to change the    */\r
2152 /* VCO are allowed within the limits set by the maximum PLL multiplier and divider      */\r
2153 /* values and by the upper and lower frequency limits of the PLL, and also determines   */\r
2154 /* whether each of these changes can be made without the PLL losing lock, which         */\r
2155 /* requires the PLL to be bypassed before making changes, and removed from bypass state */\r
2156 /* afterwards.                                                                          */\r
2157 /****************************************************************************************/\r
2158 \r
2159 \r
2160 #define ALT_CLK_PLL_VCO_CHG_METHOD_TEST_MODE        false\r
2161     // used for testing writes to the PLL VCOs\r
2162 \r
2163 \r
2164 \r
2165 static ALT_CLK_PLL_VCO_CHG_METHOD_t alt_clk_pll_vco_chg_methods_get(ALT_CLK_t pll,\r
2166         uint32_t mult, uint32_t div )\r
2167 {\r
2168 #if ALT_CLK_PLL_VCO_CHG_METHOD_TEST_MODE\r
2169 \r
2170     // used for testing\r
2171     return ALT_VCO_CHG_NOCHANGE;\r
2172 \r
2173 #else\r
2174 \r
2175     // check PLL max value limits\r
2176     if (   (mult == 0) || (mult > ALT_CLK_PLL_MULT_MAX)\r
2177         || (div  == 0) || (div  > ALT_CLK_PLL_DIV_MAX)\r
2178        )\r
2179     {\r
2180         return ALT_VCO_CHG_NONE_VALID;\r
2181     }\r
2182 \r
2183     ALT_CLK_PLL_VCO_CHG_METHOD_t    ret = ALT_VCO_CHG_NONE_VALID;\r
2184     uint32_t                        temp;\r
2185     uint32_t                        numer;\r
2186     uint32_t                        denom;\r
2187     uint32_t                        freqmax;\r
2188     uint32_t                        freqmin;\r
2189     uint32_t                        inputfreq;\r
2190     uint32_t                        guardband;\r
2191     bool                            numerchg = false;\r
2192     bool                            denomchg = false;\r
2193     bool                            within_gb;\r
2194 \r
2195     // gather data values according to PLL\r
2196     if (pll == ALT_CLK_MAIN_PLL)\r
2197     {\r
2198         temp = alt_read_word(ALT_CLKMGR_MAINPLL_VCO_ADDR);\r
2199 \r
2200         numer = ALT_CLKMGR_MAINPLL_VCO_NUMER_GET(temp);\r
2201         denom = ALT_CLKMGR_MAINPLL_VCO_DENOM_GET(temp);\r
2202 \r
2203         freqmax   = alt_pll_clk_paramblok.MainPLL_800.freqmax;\r
2204         freqmin   = alt_pll_clk_paramblok.MainPLL_800.freqmin;\r
2205         guardband = alt_pll_clk_paramblok.MainPLL_800.guardband;\r
2206 \r
2207         inputfreq = alt_ext_clk_paramblok.clkosc1.freqcur;\r
2208     }\r
2209 \r
2210     else if (pll == ALT_CLK_PERIPHERAL_PLL)\r
2211     {\r
2212         temp = alt_read_word(ALT_CLKMGR_PERPLL_VCO_ADDR);\r
2213 \r
2214         numer = ALT_CLKMGR_PERPLL_VCO_NUMER_GET(temp);\r
2215         denom = ALT_CLKMGR_PERPLL_VCO_DENOM_GET(temp);\r
2216 \r
2217         freqmax   = alt_pll_clk_paramblok.PeriphPLL_800.freqmax;\r
2218         freqmin   = alt_pll_clk_paramblok.PeriphPLL_800.freqmin;\r
2219         guardband = alt_pll_clk_paramblok.PeriphPLL_800.guardband;\r
2220 \r
2221         temp = ALT_CLKMGR_PERPLL_VCO_PSRC_GET(temp);\r
2222         if (temp == ALT_CLKMGR_PERPLL_VCO_PSRC_E_EOSC1)\r
2223         {\r
2224             inputfreq = alt_ext_clk_paramblok.clkosc1.freqcur;\r
2225         }\r
2226         else if (temp == ALT_CLKMGR_PERPLL_VCO_PSRC_E_EOSC2)\r
2227         {\r
2228             inputfreq = alt_ext_clk_paramblok.clkosc2.freqcur;\r
2229         }\r
2230         else if (temp == ALT_CLKMGR_PERPLL_VCO_PSRC_E_F2S_PERIPH_REF)\r
2231         {\r
2232             inputfreq = alt_ext_clk_paramblok.periph.freqcur;\r
2233         }\r
2234         else\r
2235         {\r
2236             return ret;\r
2237         }\r
2238     }\r
2239 \r
2240     else if (pll == ALT_CLK_SDRAM_PLL)\r
2241     {\r
2242         temp = alt_read_word(ALT_CLKMGR_SDRPLL_VCO_ADDR);\r
2243 \r
2244         numer = ALT_CLKMGR_SDRPLL_VCO_NUMER_GET(temp);\r
2245         denom = ALT_CLKMGR_SDRPLL_VCO_DENOM_GET(temp);\r
2246 \r
2247         freqmax   = alt_pll_clk_paramblok.SDRAMPLL_800.freqmax;\r
2248         freqmin   = alt_pll_clk_paramblok.SDRAMPLL_800.freqmin;\r
2249         guardband = alt_pll_clk_paramblok.SDRAMPLL_800.guardband;\r
2250 \r
2251         temp = ALT_CLKMGR_SDRPLL_VCO_SSRC_GET(temp);\r
2252         if (temp == ALT_CLKMGR_SDRPLL_VCO_SSRC_E_EOSC1)\r
2253         {\r
2254             inputfreq = alt_ext_clk_paramblok.clkosc1.freqcur;\r
2255         }\r
2256         else if (temp == ALT_CLKMGR_SDRPLL_VCO_SSRC_E_EOSC2)\r
2257         {\r
2258             inputfreq = alt_ext_clk_paramblok.clkosc2.freqcur;\r
2259         }\r
2260         else if (temp == ALT_CLKMGR_SDRPLL_VCO_SSRC_E_F2S_SDRAM_REF)\r
2261         {\r
2262             inputfreq = alt_ext_clk_paramblok.sdram.freqcur;\r
2263         }\r
2264         else\r
2265         {\r
2266             return ret;\r
2267         }\r
2268     }\r
2269     else\r
2270     {\r
2271         return ret;\r
2272     }\r
2273 \r
2274     temp = mult * (inputfreq / div);\r
2275     if ((temp <= freqmax) && (temp >= freqmin))     // are the final values within frequency limits?\r
2276     {\r
2277         numer++;\r
2278         denom++;\r
2279         numerchg = (mult != numer);\r
2280         denomchg = (div != denom);\r
2281 \r
2282         if (!numerchg && !denomchg)\r
2283         {\r
2284             ret = ALT_VCO_CHG_NOCHANGE;\r
2285         }\r
2286         else if (numerchg && !denomchg)\r
2287         {\r
2288             within_gb = alt_within_delta(numer, mult, guardband);\r
2289             // check if change is within the guardband limits\r
2290             temp = mult * (inputfreq / denom);\r
2291             if ((temp <= freqmax) && (temp >= freqmin))\r
2292             {\r
2293                 ret = ALT_VCO_CHG_NUM;\r
2294                 if (!within_gb) ret |= ALT_VCO_CHG_NUM_BYP;\r
2295             }\r
2296         }\r
2297         else if (!numerchg && denomchg)\r
2298         {\r
2299             within_gb = alt_within_delta(denom, div, guardband);\r
2300             temp = numer * (inputfreq / div);\r
2301             if ((temp <= freqmax) && (temp >= freqmin))\r
2302             {\r
2303                 ret = ALT_VCO_CHG_DENOM;\r
2304                 if (!within_gb)\r
2305                 {\r
2306                     ret |= ALT_VCO_CHG_DENOM_BYP;\r
2307                 }\r
2308             }\r
2309         }\r
2310         else    //numerchg && denomchg\r
2311         {\r
2312             within_gb = alt_within_delta(numer, mult, guardband);\r
2313             temp = mult * (inputfreq / denom);\r
2314             if ((temp <= freqmax) && (temp >= freqmin))\r
2315             {\r
2316                 ret = ALT_VCO_CHG_NUM_DENOM;\r
2317                 if (!within_gb)\r
2318                 {\r
2319                     ret |= ALT_VCO_CHG_NUM_DENOM_BYP;\r
2320                 }\r
2321             }\r
2322             within_gb = alt_within_delta(denom, div, guardband);\r
2323             temp = numer * (inputfreq / div);\r
2324             if ((temp <= freqmax) && (temp >= freqmin))\r
2325             {\r
2326                 ret = ALT_VCO_CHG_DENOM_NUM;\r
2327                 if (!within_gb)\r
2328                 {\r
2329                     ret |= ALT_VCO_CHG_DENOM_NUM_BYP;\r
2330                 }\r
2331             }\r
2332         }\r
2333     }\r
2334 \r
2335     return ret;\r
2336 #endif\r
2337 }\r
2338 \r
2339 \r
2340 /****************************************************************************************/\r
2341 /* alt_clk_pll_vco_cfg_set() sets the PLL VCO frequency configuration using the         */\r
2342 /* supplied multiplier and divider arguments. alt_clk_pll_vco_chg_methods_get()         */\r
2343 /* determines which methods are allowed by the limits set by the maximum multiplier     */\r
2344 /* and divider values and by the upper and lower frequency limits of the PLL, and also  */\r
2345 /* determines whether these changes can be made without requiring the PLL to be         */\r
2346 /* bypassed. alt_clk_pll_vco_cfg_set() then carries out the actions required to effect  */\r
2347 /* the method chosen to change the VCO settings.                                        */\r
2348 /****************************************************************************************/\r
2349 \r
2350 ALT_STATUS_CODE alt_clk_pll_vco_cfg_set(ALT_CLK_t pll, uint32_t mult, uint32_t div)\r
2351 {\r
2352     ALT_STATUS_CODE                 ret = ALT_E_ERROR;\r
2353     ALT_CLK_PLL_VCO_CHG_METHOD_t    method;\r
2354     bool                            byp = false;\r
2355     void                            *vaddr;\r
2356     uint32_t                        numermask, denommask;\r
2357     uint32_t                        numershift, denomshift;\r
2358 \r
2359 \r
2360     method = alt_clk_pll_vco_chg_methods_get(pll, mult, div);\r
2361 \r
2362     if (method == ALT_VCO_CHG_NONE_VALID)\r
2363     {\r
2364         ret = ALT_E_BAD_CLK;\r
2365     }\r
2366     else if (method == ALT_VCO_CHG_NOCHANGE)\r
2367     {\r
2368         ret = ALT_E_INV_OPTION;\r
2369     }\r
2370     else\r
2371     {\r
2372         if (pll == ALT_CLK_MAIN_PLL)\r
2373         {\r
2374             vaddr = ALT_CLKMGR_MAINPLL_VCO_ADDR;\r
2375             numermask = ALT_CLKMGR_MAINPLL_VCO_NUMER_SET_MSK;\r
2376             denommask = ALT_CLKMGR_MAINPLL_VCO_DENOM_SET_MSK;\r
2377             numershift = ALT_CLKMGR_MAINPLL_VCO_NUMER_LSB;\r
2378             denomshift = ALT_CLKMGR_MAINPLL_VCO_DENOM_LSB;\r
2379         }\r
2380         else if (pll == ALT_CLK_PERIPHERAL_PLL)\r
2381         {\r
2382             vaddr = ALT_CLKMGR_PERPLL_VCO_ADDR;\r
2383             numermask = ALT_CLKMGR_PERPLL_VCO_NUMER_SET_MSK;\r
2384             denommask = ALT_CLKMGR_PERPLL_VCO_DENOM_SET_MSK;\r
2385             numershift = ALT_CLKMGR_PERPLL_VCO_NUMER_LSB;\r
2386             denomshift = ALT_CLKMGR_PERPLL_VCO_DENOM_LSB;\r
2387         }\r
2388         else if (pll == ALT_CLK_SDRAM_PLL)\r
2389         {\r
2390             vaddr = ALT_CLKMGR_SDRPLL_VCO_ADDR;\r
2391             numermask = ALT_CLKMGR_SDRPLL_VCO_NUMER_SET_MSK;\r
2392             denommask = ALT_CLKMGR_SDRPLL_VCO_DENOM_SET_MSK;\r
2393             numershift = ALT_CLKMGR_SDRPLL_VCO_NUMER_LSB;\r
2394             denomshift = ALT_CLKMGR_SDRPLL_VCO_DENOM_LSB;\r
2395         }\r
2396         else { return ALT_E_BAD_ARG; }\r
2397 \r
2398         mult--;\r
2399         div--;\r
2400 \r
2401         if (method & ALT_VCO_CHG_NUM)\r
2402         {\r
2403             if (method & ALT_VCO_CHG_NUM_BYP)\r
2404             {\r
2405                 alt_clk_pll_bypass_enable(pll, 0);\r
2406                 byp = true;\r
2407                 alt_clk_mgr_wait(vaddr, ALT_SW_MANAGED_CLK_WAIT_BYPASS);\r
2408             }\r
2409             alt_replbits_word(vaddr, numermask, mult << numershift);\r
2410         }\r
2411 \r
2412         else if (method & ALT_VCO_CHG_DENOM)\r
2413         {\r
2414             if (method & ALT_VCO_CHG_DENOM_BYP)\r
2415             {\r
2416                 alt_clk_pll_bypass_enable(pll, 0);\r
2417                 byp = true;\r
2418             }\r
2419             alt_replbits_word(vaddr, denommask, div << denomshift);\r
2420         }\r
2421 \r
2422         else if (method & ALT_VCO_CHG_NUM_DENOM)\r
2423         {\r
2424             if (method & ALT_VCO_CHG_NUM_DENOM_BYP)\r
2425             {\r
2426                 alt_clk_pll_bypass_enable(pll, 0);\r
2427                 byp = true;\r
2428             }\r
2429             alt_replbits_word(vaddr, numermask, mult << numershift);\r
2430             if (!byp)       // if PLL is not bypassed\r
2431             {\r
2432                 ret = alt_clk_pll_lock_wait(ALT_CLK_MAIN_PLL, 1000);\r
2433                       // verify PLL is still locked or wait for it to lock again\r
2434             }\r
2435             alt_replbits_word(vaddr, denommask, div << denomshift);\r
2436         }\r
2437 \r
2438         else if (method & ALT_VCO_CHG_DENOM_NUM)\r
2439         {\r
2440             if (method & ALT_VCO_CHG_DENOM_NUM_BYP)\r
2441             {\r
2442                 alt_clk_pll_bypass_enable(pll, 0);\r
2443                 byp = true;\r
2444             }\r
2445             alt_replbits_word(vaddr, numermask, mult << numershift);\r
2446             if (!byp)       // if PLL is not bypassed\r
2447             {\r
2448                 ret = alt_clk_pll_lock_wait(ALT_CLK_MAIN_PLL, 1000);\r
2449                       // verify PLL is still locked or wait for it to lock again\r
2450             }\r
2451             alt_replbits_word(vaddr, denommask, div << denomshift);\r
2452         }\r
2453 \r
2454         ret = alt_clk_pll_lock_wait(ALT_CLK_MAIN_PLL, 1000);\r
2455               // verify PLL is still locked or wait for it to lock again\r
2456         if (byp)\r
2457         {\r
2458             alt_clk_pll_bypass_disable(pll);\r
2459             alt_clk_mgr_wait(vaddr, ALT_SW_MANAGED_CLK_WAIT_BYPASS);\r
2460                 // wait for PLL to come out of bypass mode completely\r
2461         }\r
2462     }\r
2463     return ret;\r
2464 }\r
2465 \r
2466 \r
2467 //\r
2468 // alt_clk_pll_vco_freq_get() gets the VCO frequency of the specified PLL.\r
2469 // Note that since there is at present no known way for software to obtain the speed\r
2470 // bin of the SoC or MPU that it is running on, the function below only deals with the\r
2471 // 800 MHz part. This may need to be revised in the future.\r
2472 //\r
2473 ALT_STATUS_CODE alt_clk_pll_vco_freq_get(ALT_CLK_t pll, alt_freq_t * freq)\r
2474 {\r
2475     uint64_t            temp1 = 0;\r
2476     uint32_t            temp;\r
2477     uint32_t            numer;\r
2478     uint32_t            denom;\r
2479     ALT_STATUS_CODE     ret = ALT_E_BAD_ARG;\r
2480 \r
2481     if (freq == NULL)\r
2482     {\r
2483                 return ret;\r
2484     }\r
2485 \r
2486     if (pll == ALT_CLK_MAIN_PLL)\r
2487     {\r
2488         temp = alt_read_word(ALT_CLKMGR_MAINPLL_VCO_ADDR);\r
2489         numer = ALT_CLKMGR_MAINPLL_VCO_NUMER_GET(temp);\r
2490         denom = ALT_CLKMGR_MAINPLL_VCO_DENOM_GET(temp);\r
2491         temp1 = (uint64_t) alt_ext_clk_paramblok.clkosc1.freqcur;\r
2492         temp1 *= (numer + 1);\r
2493         temp1 /= (denom + 1);\r
2494 \r
2495         if (temp1 <= UINT32_MAX)\r
2496         {\r
2497             temp = (alt_freq_t) temp1;\r
2498             alt_pll_clk_paramblok.MainPLL_800.freqcur = temp;\r
2499             // store this value in the parameter block table\r
2500              *freq = temp;\r
2501             // should NOT check value against PLL frequency limits\r
2502             ret = ALT_E_SUCCESS;\r
2503         }\r
2504         else\r
2505         {\r
2506             ret = ALT_E_ERROR;\r
2507         }\r
2508     }\r
2509     else if (pll == ALT_CLK_PERIPHERAL_PLL)\r
2510     {\r
2511         temp = alt_read_word(ALT_CLKMGR_PERPLL_VCO_ADDR);\r
2512         numer = ALT_CLKMGR_PERPLL_VCO_NUMER_GET(temp);\r
2513         denom = ALT_CLKMGR_PERPLL_VCO_DENOM_GET(temp);\r
2514         temp = ALT_CLKMGR_PERPLL_VCO_PSRC_GET(temp);\r
2515         if (temp == ALT_CLKMGR_PERPLL_VCO_PSRC_E_EOSC1)\r
2516         {\r
2517             temp1 = (uint64_t) alt_ext_clk_paramblok.clkosc1.freqcur;\r
2518         }\r
2519         else if (temp == ALT_CLKMGR_PERPLL_VCO_PSRC_E_EOSC2)\r
2520         {\r
2521             temp1 = (uint64_t) alt_ext_clk_paramblok.clkosc2.freqcur;\r
2522         }\r
2523         else if (temp == ALT_CLKMGR_PERPLL_VCO_PSRC_E_F2S_PERIPH_REF)\r
2524         {\r
2525             temp1 = (uint64_t) alt_ext_clk_paramblok.periph.freqcur;\r
2526         }\r
2527 \r
2528         if (temp1 != 0)\r
2529         {\r
2530             temp1 *= (numer + 1);\r
2531             temp1 /= (denom + 1);\r
2532             if (temp1 <= UINT32_MAX)\r
2533             {\r
2534                 temp = (alt_freq_t) temp1;\r
2535                 alt_pll_clk_paramblok.PeriphPLL_800.freqcur = temp;\r
2536                 // store this value in the parameter block table\r
2537 \r
2538                 *freq = temp;\r
2539                 ret = ALT_E_SUCCESS;\r
2540             }\r
2541             else\r
2542             {\r
2543                 ret = ALT_E_ERROR;\r
2544             }\r
2545         }       // this returns ALT_BAD_ARG if the source isn't known\r
2546     }\r
2547     else if (pll == ALT_CLK_SDRAM_PLL)\r
2548     {\r
2549         temp = alt_read_word(ALT_CLKMGR_SDRPLL_VCO_ADDR);\r
2550         numer = ALT_CLKMGR_SDRPLL_VCO_NUMER_GET(temp);\r
2551         denom = ALT_CLKMGR_SDRPLL_VCO_DENOM_GET(temp);\r
2552         temp = ALT_CLKMGR_SDRPLL_VCO_SSRC_GET(temp);\r
2553         if (temp == ALT_CLKMGR_SDRPLL_VCO_SSRC_E_EOSC1)\r
2554         {\r
2555             temp1 = (uint64_t) alt_ext_clk_paramblok.clkosc1.freqcur;\r
2556         }\r
2557         else if (temp == ALT_CLKMGR_SDRPLL_VCO_SSRC_E_EOSC2)\r
2558         {\r
2559             temp1 = (uint64_t) alt_ext_clk_paramblok.clkosc2.freqcur;\r
2560         }\r
2561         else if (temp == ALT_CLKMGR_SDRPLL_VCO_SSRC_E_F2S_SDRAM_REF)\r
2562         {\r
2563             temp1 = (uint64_t) alt_ext_clk_paramblok.sdram.freqcur;\r
2564         }\r
2565 \r
2566         if (temp1 != 0)\r
2567         {\r
2568             temp1 *= (numer + 1);\r
2569             temp1 /= (denom + 1);\r
2570             if (temp1 <= UINT32_MAX)\r
2571             {\r
2572                 temp = (alt_freq_t) temp1;\r
2573                 alt_pll_clk_paramblok.SDRAMPLL_800.freqcur = temp;\r
2574                 // store this value in the parameter block table\r
2575 \r
2576                 *freq = temp;\r
2577                 ret = ALT_E_SUCCESS;\r
2578             }\r
2579             else\r
2580             {\r
2581                 ret = ALT_E_ERROR;\r
2582             }\r
2583         }\r
2584     }       // which returns ALT_BAD_ARG if the source isn't known\r
2585 \r
2586     return ret;\r
2587 }\r
2588 \r
2589 //\r
2590 // Returns the current guard band range in effect for the PLL.\r
2591 //\r
2592 uint32_t alt_clk_pll_guard_band_get(ALT_CLK_t pll)\r
2593 {\r
2594     uint32_t ret = 0;\r
2595 \r
2596     if (pll == ALT_CLK_MAIN_PLL)\r
2597     {\r
2598         ret = alt_pll_clk_paramblok.MainPLL_800.guardband;\r
2599     }\r
2600     else if (pll == ALT_CLK_PERIPHERAL_PLL)\r
2601     {\r
2602         ret = alt_pll_clk_paramblok.PeriphPLL_800.guardband;\r
2603     }\r
2604     else if (pll == ALT_CLK_SDRAM_PLL)\r
2605     {\r
2606         ret = alt_pll_clk_paramblok.SDRAMPLL_800.guardband;\r
2607     }\r
2608     return ret;\r
2609 }\r
2610 \r
2611 //\r
2612 // clk_mgr_pll_guard_band_set() changes the guard band from its current value to permit\r
2613 // a more lenient or stringent policy to be in effect for the implementation of the\r
2614 // functions configuring PLL VCO frequency.\r
2615 //\r
2616 ALT_STATUS_CODE alt_clk_pll_guard_band_set(ALT_CLK_t pll, uint32_t guard_band)\r
2617 {\r
2618     if (   (guard_band > UINT12_MAX) || (guard_band <= 0)\r
2619         || (guard_band > ALT_GUARDBAND_LIMIT)\r
2620        )\r
2621     {\r
2622         return ALT_E_ARG_RANGE;\r
2623     }\r
2624 \r
2625     ALT_STATUS_CODE status = ALT_E_SUCCESS;\r
2626 \r
2627     if (pll == ALT_CLK_MAIN_PLL)\r
2628     {\r
2629         alt_pll_clk_paramblok.MainPLL_800.guardband = guard_band;\r
2630         //alt_pll_clk_paramblok.MainPLL_600.guardband = guard_band;\r
2631         // ??? Don't know how to check the MPU speed bin yet, so only 800 MHz struct is used\r
2632     }\r
2633     else if (pll == ALT_CLK_PERIPHERAL_PLL)\r
2634     {\r
2635         alt_pll_clk_paramblok.PeriphPLL_800.guardband = guard_band;\r
2636         //alt_pll_clk_paramblok.PeriphPLL_600.guardband = guard_band;\r
2637     }\r
2638     else if (pll == ALT_CLK_SDRAM_PLL)\r
2639     {\r
2640         alt_pll_clk_paramblok.SDRAMPLL_800.guardband = guard_band;\r
2641         //alt_pll_clk_paramblok.SDRAMPLL_600.guardband = guard_band;\r
2642     }\r
2643     else\r
2644     {\r
2645         status = ALT_E_ERROR;\r
2646     }\r
2647 \r
2648     return status;\r
2649 }\r
2650 \r
2651 //\r
2652 // alt_clk_divider_get() gets configured divider value for the specified clock.\r
2653 //\r
2654 ALT_STATUS_CODE alt_clk_divider_get(ALT_CLK_t clk, uint32_t * div)\r
2655 {\r
2656     ALT_STATUS_CODE status = ALT_E_SUCCESS;\r
2657     uint32_t        temp;\r
2658 \r
2659     if (div == NULL)\r
2660     {\r
2661                 return ALT_E_BAD_ARG;\r
2662     }\r
2663 \r
2664     switch (clk)\r
2665     {\r
2666         // Main PLL outputs\r
2667     case ALT_CLK_MAIN_PLL_C0:\r
2668     case ALT_CLK_MPU:\r
2669         *div = (ALT_CLKMGR_MAINPLL_MPUCLK_CNT_GET(alt_read_word(ALT_CLKMGR_MAINPLL_MPUCLK_ADDR)) + 1) *\r
2670                (ALT_CLKMGR_ALTERA_MPUCLK_CNT_GET(alt_read_word(ALT_CLKMGR_ALTERA_MPUCLK_ADDR)) + 1);\r
2671         break;\r
2672 \r
2673     case ALT_CLK_MAIN_PLL_C1:\r
2674     case ALT_CLK_L4_MAIN:\r
2675     case ALT_CLK_L3_MAIN:\r
2676         *div = (ALT_CLKMGR_MAINPLL_MAINCLK_CNT_GET(alt_read_word(ALT_CLKMGR_MAINPLL_MAINCLK_ADDR)) + 1) *\r
2677                (ALT_CLKMGR_ALTERA_MAINCLK_CNT_GET(alt_read_word(ALT_CLKMGR_ALTERA_MAINCLK_ADDR)) + 1);\r
2678         break;\r
2679 \r
2680     case ALT_CLK_MAIN_PLL_C2:\r
2681     case ALT_CLK_DBG_BASE:\r
2682     case ALT_CLK_DBG_TIMER:\r
2683         *div = (ALT_CLKMGR_MAINPLL_DBGATCLK_CNT_GET(alt_read_word(ALT_CLKMGR_MAINPLL_DBGATCLK_ADDR)) + 1) *\r
2684                (ALT_CLKMGR_ALTERA_DBGATCLK_CNT_GET(alt_read_word(ALT_CLKMGR_ALTERA_DBGATCLK_ADDR)) + 1);\r
2685         break;\r
2686 \r
2687     case ALT_CLK_MAIN_PLL_C3:\r
2688     case ALT_CLK_MAIN_QSPI:\r
2689         *div = (ALT_CLKMGR_MAINPLL_MAINQSPICLK_CNT_GET(alt_read_word(ALT_CLKMGR_MAINPLL_MAINQSPICLK_ADDR))) + 1;\r
2690         break;\r
2691 \r
2692     case ALT_CLK_MAIN_PLL_C4:\r
2693     case ALT_CLK_MAIN_NAND_SDMMC:\r
2694         *div = (ALT_CLKMGR_MAINPLL_MAINNANDSDMMCCLK_CNT_GET(alt_read_word(ALT_CLKMGR_MAINPLL_MAINNANDSDMMCCLK_ADDR))) + 1;\r
2695         break;\r
2696 \r
2697     case ALT_CLK_MAIN_PLL_C5:\r
2698     case ALT_CLK_CFG:\r
2699     case ALT_CLK_H2F_USER0:\r
2700         *div = (ALT_CLKMGR_MAINPLL_CFGS2FUSER0CLK_CNT_GET(alt_read_word(ALT_CLKMGR_MAINPLL_CFGS2FUSER0CLK_ADDR))) + 1;\r
2701         break;\r
2702 \r
2703         /////\r
2704 \r
2705         // Peripheral PLL outputs\r
2706     case ALT_CLK_PERIPHERAL_PLL_C0:\r
2707     case ALT_CLK_EMAC0:\r
2708         *div = (ALT_CLKMGR_PERPLL_EMAC0CLK_CNT_GET(alt_read_word(ALT_CLKMGR_PERPLL_EMAC0CLK_ADDR))) + 1;\r
2709         break;\r
2710 \r
2711     case ALT_CLK_PERIPHERAL_PLL_C1:\r
2712     case ALT_CLK_EMAC1:\r
2713         *div = (ALT_CLKMGR_PERPLL_EMAC1CLK_CNT_GET(alt_read_word(ALT_CLKMGR_PERPLL_EMAC1CLK_ADDR))) + 1;\r
2714         break;\r
2715 \r
2716     case ALT_CLK_PERIPHERAL_PLL_C2:\r
2717         *div = (ALT_CLKMGR_PERPLL_PERQSPICLK_CNT_GET(alt_read_word(ALT_CLKMGR_PERPLL_PERQSPICLK_ADDR))) + 1;\r
2718         break;\r
2719 \r
2720     case ALT_CLK_PERIPHERAL_PLL_C3:\r
2721         *div = (ALT_CLKMGR_PERPLL_PERNANDSDMMCCLK_CNT_GET(alt_read_word(ALT_CLKMGR_PERPLL_PERNANDSDMMCCLK_ADDR))) + 1;\r
2722         break;\r
2723 \r
2724     case ALT_CLK_PERIPHERAL_PLL_C4:\r
2725         *div = (ALT_CLKMGR_PERPLL_PERBASECLK_CNT_GET(alt_read_word(ALT_CLKMGR_PERPLL_PERBASECLK_ADDR))) + 1;\r
2726         break;\r
2727 \r
2728     case ALT_CLK_PERIPHERAL_PLL_C5:\r
2729     case ALT_CLK_H2F_USER1:\r
2730         *div = (ALT_CLKMGR_PERPLL_S2FUSER1CLK_CNT_GET(alt_read_word(ALT_CLKMGR_PERPLL_S2FUSER1CLK_ADDR))) + 1;\r
2731         break;\r
2732 \r
2733         /////\r
2734 \r
2735         // SDRAM PLL outputs\r
2736     case ALT_CLK_SDRAM_PLL_C0:\r
2737     case ALT_CLK_DDR_DQS:\r
2738         *div = (ALT_CLKMGR_SDRPLL_DDRDQSCLK_CNT_GET(alt_read_word(ALT_CLKMGR_SDRPLL_DDRDQSCLK_ADDR))) + 1;\r
2739         break;\r
2740 \r
2741     case ALT_CLK_SDRAM_PLL_C1:\r
2742     case ALT_CLK_DDR_2X_DQS:\r
2743         *div = (ALT_CLKMGR_SDRPLL_DDR2XDQSCLK_CNT_GET(alt_read_word(ALT_CLKMGR_SDRPLL_DDR2XDQSCLK_ADDR))) + 1;\r
2744         break;\r
2745 \r
2746     case ALT_CLK_SDRAM_PLL_C2:\r
2747     case ALT_CLK_DDR_DQ:\r
2748         *div = (ALT_CLKMGR_SDRPLL_DDRDQCLK_CNT_GET(alt_read_word(ALT_CLKMGR_SDRPLL_DDRDQCLK_ADDR))) + 1;\r
2749         break;\r
2750 \r
2751     case ALT_CLK_SDRAM_PLL_C5:\r
2752     case ALT_CLK_H2F_USER2:\r
2753         *div = (ALT_CLKMGR_SDRPLL_S2FUSER2CLK_CNT_GET(alt_read_word(ALT_CLKMGR_SDRPLL_S2FUSER2CLK_ADDR))) + 1;\r
2754         break;\r
2755 \r
2756         /////\r
2757 \r
2758         // Other clock dividers\r
2759     case ALT_CLK_L3_MP:\r
2760         temp = ALT_CLKMGR_MAINPLL_MAINDIV_L3MPCLK_GET(alt_read_word(ALT_CLKMGR_MAINPLL_MAINDIV_ADDR));\r
2761         if (temp <= ALT_CLKMGR_MAINPLL_MAINDIV_L3MPCLK_E_DIV2)\r
2762         {\r
2763             *div = temp + 1;\r
2764         }\r
2765         else\r
2766         {\r
2767             status = ALT_E_ERROR;\r
2768         }\r
2769         break;\r
2770 \r
2771     case ALT_CLK_L3_SP:\r
2772         temp = ALT_CLKMGR_MAINPLL_MAINDIV_L3SPCLK_GET(alt_read_word(ALT_CLKMGR_MAINPLL_MAINDIV_ADDR));\r
2773         if (temp <= ALT_CLKMGR_MAINPLL_MAINDIV_L3SPCLK_E_DIV2)\r
2774         {\r
2775             *div = temp + 1;\r
2776         }\r
2777         else\r
2778         {\r
2779             status = ALT_E_ERROR;\r
2780         }\r
2781         // note that this value does not include the additional effect\r
2782         // of the L3_MP divider that is upchain from this one\r
2783         break;\r
2784 \r
2785     case ALT_CLK_L4_MP:\r
2786         temp = ALT_CLKMGR_MAINPLL_MAINDIV_L4MPCLK_GET(alt_read_word(ALT_CLKMGR_MAINPLL_MAINDIV_ADDR));\r
2787         if (temp <= ALT_CLKMGR_MAINPLL_MAINDIV_L4MPCLK_E_DIV16)\r
2788         {\r
2789             *div = 1 << temp;\r
2790         }\r
2791         else\r
2792         {\r
2793             status = ALT_E_ERROR;\r
2794         }\r
2795         break;\r
2796 \r
2797     case ALT_CLK_L4_SP:\r
2798         temp = ALT_CLKMGR_MAINPLL_MAINDIV_L4SPCLK_GET(alt_read_word(ALT_CLKMGR_MAINPLL_MAINDIV_ADDR));\r
2799         if (temp <= ALT_CLKMGR_MAINPLL_MAINDIV_L4SPCLK_E_DIV16)\r
2800         {\r
2801             *div = 1 << temp;\r
2802         }\r
2803         else\r
2804         {\r
2805             status = ALT_E_ERROR;\r
2806         }\r
2807         break;\r
2808 \r
2809     case ALT_CLK_DBG_AT:\r
2810         temp = ALT_CLKMGR_MAINPLL_DBGDIV_DBGATCLK_GET(alt_read_word(ALT_CLKMGR_MAINPLL_DBGDIV_ADDR));\r
2811         if (temp <= ALT_CLKMGR_MAINPLL_DBGDIV_DBGATCLK_E_DIV4)\r
2812         {\r
2813             *div = 1 << temp;\r
2814         }\r
2815         else\r
2816         {\r
2817             status = ALT_E_ERROR;\r
2818         }\r
2819         break;\r
2820 \r
2821     case ALT_CLK_DBG:\r
2822         temp = ALT_CLKMGR_MAINPLL_DBGDIV_DBGCLK_GET(alt_read_word(ALT_CLKMGR_MAINPLL_DBGDIV_ADDR));\r
2823         if (temp <= ALT_CLKMGR_MAINPLL_DBGDIV_DBGCLK_E_DIV4)\r
2824         {\r
2825             *div =  1 << temp;\r
2826         }\r
2827         else\r
2828         {\r
2829             status = ALT_E_ERROR;\r
2830         }\r
2831         // note that this value does not include the value of the upstream dbg_at_clk divder\r
2832         break;\r
2833 \r
2834     case ALT_CLK_DBG_TRACE:\r
2835         temp = ALT_CLKMGR_MAINPLL_TRACEDIV_TRACECLK_GET(alt_read_word(ALT_CLKMGR_MAINPLL_TRACEDIV_ADDR));\r
2836         if (temp <= ALT_CLKMGR_MAINPLL_TRACEDIV_TRACECLK_E_DIV16)\r
2837         {\r
2838             *div =  1 << temp;\r
2839         }\r
2840         else\r
2841         {\r
2842             status = ALT_E_ERROR;\r
2843         }\r
2844         break;\r
2845 \r
2846     case ALT_CLK_USB_MP:\r
2847         temp = ALT_CLKMGR_PERPLL_DIV_USBCLK_GET(alt_read_word(ALT_CLKMGR_PERPLL_DIV_ADDR));\r
2848         if (temp <= ALT_CLKMGR_PERPLL_DIV_USBCLK_E_DIV16)\r
2849         {\r
2850             *div = 1 << temp;\r
2851         }\r
2852         else\r
2853         {\r
2854             status = ALT_E_ERROR;\r
2855         }\r
2856         break;\r
2857 \r
2858     case ALT_CLK_SPI_M:\r
2859         temp = ALT_CLKMGR_PERPLL_DIV_SPIMCLK_GET(alt_read_word(ALT_CLKMGR_PERPLL_DIV_ADDR));\r
2860         if (temp <= ALT_CLKMGR_PERPLL_DIV_SPIMCLK_E_DIV16)\r
2861         {\r
2862             *div = 1 << temp;\r
2863         }\r
2864         else\r
2865         {\r
2866             status = ALT_E_ERROR;\r
2867         }\r
2868         break;\r
2869 \r
2870     case ALT_CLK_CAN0:\r
2871         temp = ALT_CLKMGR_PERPLL_DIV_CAN0CLK_GET(alt_read_word(ALT_CLKMGR_PERPLL_DIV_ADDR));\r
2872         if (temp <= ALT_CLKMGR_PERPLL_DIV_CAN0CLK_E_DIV16)\r
2873         {\r
2874             *div = 1 << temp;\r
2875         }\r
2876         else\r
2877         {\r
2878             status = ALT_E_ERROR;\r
2879         }\r
2880         break;\r
2881 \r
2882     case ALT_CLK_CAN1:\r
2883         temp = ALT_CLKMGR_PERPLL_DIV_CAN1CLK_GET(alt_read_word(ALT_CLKMGR_PERPLL_DIV_ADDR));\r
2884         if (temp <= ALT_CLKMGR_PERPLL_DIV_CAN1CLK_E_DIV16)\r
2885         {\r
2886             *div = 1 << temp;\r
2887         }\r
2888         else\r
2889         {\r
2890             status = ALT_E_ERROR;\r
2891         }\r
2892         break;\r
2893 \r
2894     case ALT_CLK_GPIO_DB:\r
2895         temp = ALT_CLKMGR_PERPLL_GPIODIV_GPIODBCLK_GET(alt_read_word(ALT_CLKMGR_PERPLL_GPIODIV_ADDR));\r
2896         *div = temp + 1;\r
2897         break;\r
2898 \r
2899     case ALT_CLK_MPU_PERIPH:\r
2900         *div = 4;                           // set by hardware\r
2901         break;\r
2902 \r
2903     case ALT_CLK_MPU_L2_RAM:\r
2904         *div = 2;                           // set by hardware\r
2905         break;\r
2906 \r
2907     case ALT_CLK_NAND:\r
2908         *div = 4;                           // set by hardware\r
2909         break;\r
2910 \r
2911     default:\r
2912         status = ALT_E_BAD_ARG;\r
2913         break;\r
2914     }\r
2915 \r
2916     return status;\r
2917 }\r
2918 \r
2919 /////\r
2920 \r
2921 #define ALT_CLK_WITHIN_FREQ_LIMITS_TEST_MODE        false\r
2922     // used for testing writes to the the full range of counters without\r
2923     // regard to the usual output frequency upper and lower limits\r
2924 \r
2925 \r
2926 static ALT_STATUS_CODE alt_clk_within_freq_limits(ALT_CLK_t clk, uint32_t div)\r
2927 {\r
2928 #if ALT_CLK_WITHIN_FREQ_LIMITS_TEST_MODE\r
2929     return ALT_E_TRUE;\r
2930 #else\r
2931 \r
2932     if (div == 0)\r
2933     {\r
2934         return ALT_E_BAD_ARG;\r
2935     }\r
2936 \r
2937     ALT_STATUS_CODE status = ALT_E_SUCCESS;\r
2938     uint32_t        numer = 0;\r
2939     uint32_t        hilimit;\r
2940     uint32_t        lolimit;\r
2941 \r
2942     switch (clk)\r
2943     {\r
2944         // Counters of the Main PLL\r
2945     case ALT_CLK_MAIN_PLL_C0:\r
2946         hilimit = alt_pll_cntr_maxfreq.MainPLL_C0;\r
2947         lolimit = alt_ext_clk_paramblok.clkosc1.freqcur;\r
2948         status = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &numer);\r
2949         break;\r
2950     case  ALT_CLK_MAIN_PLL_C1:\r
2951         hilimit = alt_pll_cntr_maxfreq.MainPLL_C1;\r
2952         lolimit = alt_ext_clk_paramblok.clkosc1.freqcur;\r
2953         status = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &numer);\r
2954         break;\r
2955     case ALT_CLK_MAIN_PLL_C2:\r
2956         hilimit = alt_pll_cntr_maxfreq.MainPLL_C2;\r
2957         lolimit = alt_ext_clk_paramblok.clkosc1.freqcur;\r
2958         status = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &numer);\r
2959         break;\r
2960     case ALT_CLK_MAIN_PLL_C3:\r
2961         hilimit = alt_pll_cntr_maxfreq.MainPLL_C3;\r
2962         lolimit = 0;\r
2963         status = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &numer);\r
2964         break;\r
2965     case ALT_CLK_MAIN_PLL_C4:\r
2966         hilimit = alt_pll_cntr_maxfreq.MainPLL_C4;\r
2967         lolimit = alt_ext_clk_paramblok.clkosc1.freqcur;\r
2968         status = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &numer);\r
2969         break;\r
2970     case ALT_CLK_MAIN_PLL_C5:\r
2971         hilimit = alt_pll_cntr_maxfreq.MainPLL_C5;\r
2972         lolimit = alt_ext_clk_paramblok.clkosc1.freqcur;\r
2973         status = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &numer);\r
2974         break;\r
2975 \r
2976     // Counters of the Peripheral PLL\r
2977     case ALT_CLK_PERIPHERAL_PLL_C0:\r
2978         hilimit = alt_pll_cntr_maxfreq.PeriphPLL_C0;\r
2979         lolimit = 0;\r
2980         status = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &numer);\r
2981         break;\r
2982     case ALT_CLK_PERIPHERAL_PLL_C1:\r
2983         hilimit = alt_pll_cntr_maxfreq.PeriphPLL_C1;\r
2984         lolimit = 0;\r
2985         status = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &numer);\r
2986         break;\r
2987     case ALT_CLK_PERIPHERAL_PLL_C2:\r
2988         hilimit = alt_pll_cntr_maxfreq.PeriphPLL_C2;\r
2989         lolimit = 0;\r
2990         status = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &numer);\r
2991         break;\r
2992     case ALT_CLK_PERIPHERAL_PLL_C3:\r
2993         hilimit = alt_pll_cntr_maxfreq.PeriphPLL_C3;\r
2994         lolimit = 0;\r
2995         status = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &numer);\r
2996         break;\r
2997     case ALT_CLK_PERIPHERAL_PLL_C4:\r
2998         hilimit = alt_pll_cntr_maxfreq.PeriphPLL_C4;\r
2999         lolimit = 0;\r
3000         status = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &numer);\r
3001         break;\r
3002     case ALT_CLK_PERIPHERAL_PLL_C5:\r
3003         hilimit = alt_pll_cntr_maxfreq.PeriphPLL_C5;\r
3004         lolimit = alt_ext_clk_paramblok.clkosc1.freqcur;\r
3005         status = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &numer);\r
3006         break;\r
3007 \r
3008     // Counters of the SDRAM PLL\r
3009     case ALT_CLK_SDRAM_PLL_C0:\r
3010         hilimit = alt_pll_cntr_maxfreq.SDRAMPLL_C0;\r
3011         lolimit = 0;\r
3012         status = alt_clk_pll_vco_freq_get(ALT_CLK_SDRAM_PLL, &numer);\r
3013         break;\r
3014     case ALT_CLK_SDRAM_PLL_C1:\r
3015         hilimit = alt_pll_cntr_maxfreq.SDRAMPLL_C1;\r
3016         lolimit = 0;\r
3017         status = alt_clk_pll_vco_freq_get(ALT_CLK_SDRAM_PLL, &numer);\r
3018         break;\r
3019     case ALT_CLK_SDRAM_PLL_C2:\r
3020         hilimit = alt_pll_cntr_maxfreq.SDRAMPLL_C2;\r
3021         lolimit = 0;\r
3022         status = alt_clk_pll_vco_freq_get(ALT_CLK_SDRAM_PLL, &numer);\r
3023         break;\r
3024     case ALT_CLK_SDRAM_PLL_C5:\r
3025         hilimit = alt_pll_cntr_maxfreq.SDRAMPLL_C5;\r
3026         lolimit = alt_ext_clk_paramblok.clkosc1.freqcur;\r
3027         status = alt_clk_pll_vco_freq_get(ALT_CLK_SDRAM_PLL, &numer);\r
3028         break;\r
3029 \r
3030     default:\r
3031         status = ALT_E_BAD_ARG;\r
3032         break;\r
3033     }\r
3034 \r
3035     if (status == ALT_E_SUCCESS)\r
3036     {\r
3037         numer = numer / div;\r
3038         if ((numer <= hilimit) && (numer >= lolimit))\r
3039         {\r
3040             status = ALT_E_TRUE;\r
3041         }\r
3042         else\r
3043         {\r
3044             status = ALT_E_FALSE;\r
3045         }\r
3046     }\r
3047 \r
3048     return status;\r
3049 #endif\r
3050 }\r
3051 \r
3052 static bool alt_clkmgr_is_val_modulo_n(uint32_t div, uint32_t mod)\r
3053 {\r
3054     if (mod == 1)\r
3055     {\r
3056         return true;\r
3057     }\r
3058     else if (mod == 2)\r
3059     {\r
3060         return (div & 0x1) == 0;\r
3061     }\r
3062     else if (mod == 4)\r
3063     {\r
3064         return (div & 0x3) == 0;\r
3065     }\r
3066     else\r
3067     {\r
3068         return (div % mod) == 0;\r
3069     }\r
3070 }\r
3071 \r
3072 //\r
3073 // alt_clk_divider_set() sets the divider value for the specified clock.\r
3074 //\r
3075 // See pages 38, 44, 45, and 46 of the HPS-Clocking NPP for a map of the\r
3076 // HPS clocking architecture and hierarchy of connections.\r
3077 //\r
3078 ALT_STATUS_CODE alt_clk_divider_set(ALT_CLK_t clk, uint32_t div)\r
3079 {\r
3080     ALT_STATUS_CODE     ret = ALT_E_BAD_ARG;\r
3081     volatile uint32_t   temp, temp1;\r
3082     uint32_t            wrval = UINT32_MAX;              // value to be written\r
3083     bool                restore_0 = false;\r
3084     bool                restore_1 = false;\r
3085     bool                restore_2 = false;\r
3086 \r
3087     switch (clk)\r
3088     {\r
3089         // Main PLL outputs\r
3090     case ALT_CLK_MAIN_PLL_C0:\r
3091     case ALT_CLK_MPU:\r
3092         {\r
3093             uint32_t prediv = (ALT_CLKMGR_ALTERA_MPUCLK_CNT_GET(alt_read_word(ALT_CLKMGR_ALTERA_MPUCLK_ADDR)) + 1);\r
3094 \r
3095             if (   (div <= ((ALT_CLKMGR_MAINPLL_MPUCLK_CNT_SET_MSK + 1) * prediv))\r
3096                 && alt_clkmgr_is_val_modulo_n(div, prediv)\r
3097                 && (alt_clk_within_freq_limits(ALT_CLK_MAIN_PLL_C0, div) == ALT_E_TRUE) )\r
3098             {\r
3099                 wrval = (div / prediv) - 1;\r
3100 \r
3101                 // HW managed clock, change by writing to the external counter,  no need to gate clock\r
3102                 // or match phase or wait for transistion time. No other field in the register to mask off either.\r
3103                 alt_write_word(ALT_CLKMGR_MAINPLL_MPUCLK_ADDR, wrval);\r
3104                 ret = ALT_E_SUCCESS;\r
3105             }\r
3106             else\r
3107             {\r
3108                 ret = ALT_E_ARG_RANGE;\r
3109             }\r
3110         }\r
3111         break;\r
3112 \r
3113     case ALT_CLK_MAIN_PLL_C1:\r
3114     case ALT_CLK_L3_MAIN:\r
3115         {\r
3116             uint32_t prediv = (ALT_CLKMGR_ALTERA_MAINCLK_CNT_GET(alt_read_word(ALT_CLKMGR_ALTERA_MAINCLK_ADDR)) + 1);\r
3117 \r
3118             if (   (div <= ((ALT_CLKMGR_MAINPLL_MAINCLK_CNT_SET_MSK + 1) * prediv))\r
3119                 && alt_clkmgr_is_val_modulo_n(div, prediv)\r
3120                 && (alt_clk_within_freq_limits(ALT_CLK_MAIN_PLL_C1, div) == ALT_E_TRUE) )\r
3121             {\r
3122                 // HW managed clock, change by writing to the external counter, no need to gate clock\r
3123                 // or match phase or wait for transistion time. No other field in the register to mask off either.\r
3124 \r
3125                 wrval = (div / prediv) - 1;\r
3126 \r
3127 #if ALT_PREVENT_GLITCH_CHGC1\r
3128                 // if L4MP or L4SP source is set to Main PLL C1, gate it off before changing\r
3129                 // bypass state, then gate clock back on. FogBugz #63778\r
3130                 temp  = alt_read_word(ALT_CLKMGR_MAINPLL_L4SRC_ADDR);\r
3131                 temp1 = alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR);\r
3132 \r
3133                 if ((temp1 & ALT_CLKMGR_MAINPLL_EN_L4MPCLK_SET_MSK) && (!(temp & ALT_CLKMGR_MAINPLL_L4SRC_L4MP_SET_MSK)))\r
3134                 {\r
3135                     restore_0 = true;\r
3136                 }\r
3137                 if ((temp1 & ALT_CLKMGR_MAINPLL_EN_L4SPCLK_SET_MSK) && (!(temp & ALT_CLKMGR_MAINPLL_L4SRC_L4SP_SET_MSK)))\r
3138                 {\r
3139                     restore_1 = true;\r
3140                 }\r
3141                 temp = temp1;\r
3142                 if (restore_0) { temp &= ALT_CLKMGR_MAINPLL_EN_L4MPCLK_CLR_MSK; }\r
3143                 if (restore_1) { temp &= ALT_CLKMGR_MAINPLL_EN_L4SPCLK_CLR_MSK; }\r
3144                 if (restore_0 || restore_1) { alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp); }\r
3145 \r
3146                 alt_write_word(ALT_CLKMGR_MAINPLL_MAINCLK_ADDR, wrval);\r
3147 \r
3148                 alt_clk_mgr_wait(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
3149                 // wait a bit before reenabling the L4MP and L4SP clocks\r
3150                 if (restore_0 || restore_1) { alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp1); }\r
3151 #else\r
3152                 alt_write_word(ALT_CLKMGR_MAINPLL_MAINCLK_ADDR, wrval);\r
3153 #endif\r
3154                 ret = ALT_E_SUCCESS;\r
3155             }\r
3156             else\r
3157             {\r
3158                 ret = ALT_E_ARG_RANGE;\r
3159             }\r
3160         }\r
3161         break;\r
3162 \r
3163     case ALT_CLK_MAIN_PLL_C2:\r
3164     case ALT_CLK_DBG_BASE:\r
3165         {\r
3166             uint32_t prediv = (ALT_CLKMGR_ALTERA_DBGATCLK_CNT_GET(alt_read_word(ALT_CLKMGR_ALTERA_DBGATCLK_ADDR)) + 1);\r
3167 \r
3168             if (   (div <= ((ALT_CLKMGR_MAINPLL_DBGATCLK_CNT_SET_MSK + 1) * prediv))\r
3169                    && alt_clkmgr_is_val_modulo_n(div, prediv)\r
3170                 && (alt_clk_within_freq_limits(ALT_CLK_MAIN_PLL_C2, div) == ALT_E_TRUE) )\r
3171             {\r
3172                 wrval = (div / prediv) - 1;\r
3173                 // HW managed clock, change by writing to the external counter,  no need to gate clock\r
3174                 // or match phase or wait for transistion time. No other field in the register to mask off either.\r
3175                 alt_write_word(ALT_CLKMGR_MAINPLL_DBGATCLK_ADDR, wrval);\r
3176 \r
3177                 ret = ALT_E_SUCCESS;\r
3178             }\r
3179             else\r
3180             {\r
3181                 ret = ALT_E_ARG_RANGE;\r
3182             }\r
3183         }\r
3184         break;\r
3185 \r
3186     case ALT_CLK_MAIN_PLL_C3:\r
3187         // The rest of the PLL outputs do not have external counters, but\r
3188         // their internal counters are programmable rather than fixed\r
3189         if (   (div <= (ALT_CLKMGR_MAINPLL_MAINQSPICLK_CNT_SET_MSK + 1))\r
3190             && (alt_clk_within_freq_limits(ALT_CLK_MAIN_PLL_C3, div) == ALT_E_TRUE) )\r
3191         {\r
3192             // if the main_qspi_clk input is selected for the qspi_clk\r
3193             if (ALT_CLKMGR_PERPLL_SRC_QSPI_GET(alt_read_word(ALT_CLKMGR_PERPLL_SRC_ADDR)) ==\r
3194                 ALT_CLKMGR_PERPLL_SRC_QSPI_E_MAIN_QSPI_CLK)\r
3195             {\r
3196                 restore_0 = (temp = alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR)) & ALT_CLKMGR_PERPLL_EN_QSPICLK_SET_MSK;\r
3197                 if (restore_0)             // AND if the QSPI clock is currently enabled\r
3198                 {\r
3199                     alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp & ALT_CLKMGR_PERPLL_EN_QSPICLK_CLR_MSK);\r
3200                     // gate off the QSPI clock\r
3201                 }\r
3202 \r
3203                 wrval = div - 1;\r
3204                 // the rest are software-managed clocks and require a reset sequence to write to\r
3205                 alt_clk_pllcounter_write(ALT_CLKMGR_MAINPLL_VCO_ADDR,\r
3206                                          ALT_CLKMGR_MAINPLL_STAT_ADDR,\r
3207                                          ALT_CLKMGR_MAINPLL_MAINQSPICLK_ADDR,\r
3208                                          wrval,\r
3209                                          ALT_CLK_PLL_RST_BIT_C3,\r
3210                                          ALT_CLKMGR_MAINPLL_VCO_OUTRST_LSB);\r
3211 \r
3212                 alt_clk_mgr_wait(ALT_CLKMGR_MAINPLL_MAINQSPICLK_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
3213                 if (restore_0)\r
3214                 {\r
3215                     alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp);\r
3216                     // if the QSPI clock was gated on (enabled) before, return it to that state\r
3217                 }\r
3218                 ret = ALT_E_SUCCESS;\r
3219             }\r
3220         }\r
3221         else\r
3222         {\r
3223             ret = ALT_E_ARG_RANGE;\r
3224         }\r
3225         break;\r
3226 \r
3227     case ALT_CLK_MAIN_PLL_C4:\r
3228     case ALT_CLK_MAIN_NAND_SDMMC:\r
3229         if (   (div <= (ALT_CLKMGR_MAINPLL_MAINNANDSDMMCCLK_CNT_SET_MSK + 1))\r
3230             && (alt_clk_within_freq_limits(ALT_CLK_MAIN_PLL_C4, div) == ALT_E_TRUE) )\r
3231         {\r
3232             temp  = alt_read_word(ALT_CLKMGR_PERPLL_SRC_ADDR);\r
3233             temp1 = alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR);\r
3234 \r
3235             // do we need to gate off the SDMMC clock ?\r
3236             if (ALT_CLKMGR_PERPLL_SRC_SDMMC_GET(temp) == ALT_CLKMGR_PERPLL_SRC_SDMMC_E_MAIN_NAND_CLK)\r
3237             {\r
3238                 if (temp1 & ALT_CLKMGR_PERPLL_EN_SDMMCCLK_SET_MSK) { restore_0 = true; }\r
3239             }\r
3240 \r
3241             // do we need to gate off the NAND clock and/or the NANDX clock?\r
3242             if (ALT_CLKMGR_PERPLL_SRC_NAND_GET(temp) == ALT_CLKMGR_PERPLL_SRC_NAND_E_MAIN_NAND_CLK)\r
3243             {\r
3244                 if (temp1 & ALT_CLKMGR_PERPLL_EN_NANDXCLK_SET_MSK) { restore_1 = true; }\r
3245                 if (temp1 & ALT_CLKMGR_PERPLL_EN_NANDCLK_SET_MSK)  { restore_2 = true; }\r
3246             }\r
3247 \r
3248             temp = temp1;\r
3249             if (restore_1 && restore_2)\r
3250             {\r
3251                 temp &= ALT_CLKMGR_PERPLL_EN_NANDCLK_CLR_MSK;\r
3252                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp);\r
3253                 alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_SW_MANAGED_CLK_WAIT_NANDCLK);\r
3254                 // gate nand_clk off at least 8 MPU clock cycles before before nand_x_clk\r
3255             }\r
3256 \r
3257             if (restore_0 || restore_1)\r
3258             {\r
3259                 if (restore_0) { temp &= ALT_CLKMGR_PERPLL_EN_SDMMCCLK_CLR_MSK; }\r
3260                 if (restore_1) { temp &= ALT_CLKMGR_PERPLL_EN_NANDXCLK_CLR_MSK; }\r
3261                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp);\r
3262                 // gate off sdmmc_clk and/or nand_x_clk\r
3263             }\r
3264 \r
3265             // now write the new divisor ratio\r
3266             wrval = div - 1;\r
3267             alt_clk_pllcounter_write(ALT_CLKMGR_MAINPLL_VCO_ADDR,\r
3268                                      ALT_CLKMGR_MAINPLL_STAT_ADDR,\r
3269                                      ALT_CLKMGR_MAINPLL_MAINNANDSDMMCCLK_ADDR,\r
3270                                      wrval,\r
3271                                      ALT_CLK_PLL_RST_BIT_C4,\r
3272                                      ALT_CLKMGR_MAINPLL_VCO_OUTRST_LSB);\r
3273             alt_clk_mgr_wait(ALT_CLKMGR_MAINPLL_MAINNANDSDMMCCLK_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
3274 \r
3275             if (restore_0 || restore_1)\r
3276             {\r
3277                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp1 & ALT_CLKMGR_PERPLL_EN_NANDCLK_CLR_MSK);\r
3278                 // if the NANDX and/or SDMMC clock was gated on (enabled) before, return it to that state\r
3279                 if (restore_1 && restore_2)\r
3280                 {\r
3281                     // wait at least 8 clock cycles to turn the nand_clk on\r
3282                     alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_SW_MANAGED_CLK_WAIT_NANDCLK);\r
3283                     alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp1);\r
3284                 }\r
3285             }\r
3286             ret = ALT_E_SUCCESS;\r
3287         }\r
3288         else\r
3289         {\r
3290             ret = ALT_E_ARG_RANGE;\r
3291         }\r
3292         break;\r
3293 \r
3294     case ALT_CLK_MAIN_PLL_C5:\r
3295     case ALT_CLK_CFG:\r
3296     case ALT_CLK_H2F_USER0:\r
3297         if (   (div <= (ALT_CLKMGR_MAINPLL_CFGS2FUSER0CLK_CNT_SET_MSK + 1))\r
3298             && (alt_clk_within_freq_limits(ALT_CLK_MAIN_PLL_C5, div) == ALT_E_TRUE) )\r
3299         {\r
3300             temp = alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR);\r
3301             restore_0 = ((temp & ALT_CLKMGR_MAINPLL_EN_CFGCLK_SET_MSK) ||\r
3302                          (temp & ALT_CLKMGR_MAINPLL_EN_S2FUSER0CLK_SET_MSK));\r
3303             if (restore_0)\r
3304             {\r
3305                 alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp & (ALT_CLKMGR_MAINPLL_EN_CFGCLK_CLR_MSK &\r
3306                                                                    ALT_CLKMGR_MAINPLL_EN_S2FUSER0CLK_CLR_MSK)); // clear both\r
3307             }\r
3308 \r
3309             // now write the new divisor ratio\r
3310             wrval = div - 1;\r
3311             alt_clk_pllcounter_write(ALT_CLKMGR_MAINPLL_VCO_ADDR,\r
3312                                      ALT_CLKMGR_MAINPLL_STAT_ADDR,\r
3313                                      ALT_CLKMGR_MAINPLL_CFGS2FUSER0CLK_ADDR,\r
3314                                      wrval,\r
3315                                      ALT_CLK_PLL_RST_BIT_C5,\r
3316                                      ALT_CLKMGR_MAINPLL_VCO_OUTRST_LSB);\r
3317 \r
3318             alt_clk_mgr_wait(ALT_CLKMGR_MAINPLL_CFGS2FUSER0CLK_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
3319 \r
3320             if (restore_0)\r
3321             {\r
3322                 alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp);\r
3323             }\r
3324             ret = ALT_E_SUCCESS;\r
3325         }\r
3326         else\r
3327         {\r
3328             ret = ALT_E_ARG_RANGE;\r
3329         }\r
3330         break;\r
3331 \r
3332         /////\r
3333 \r
3334         // Peripheral PLL outputs\r
3335     case ALT_CLK_PERIPHERAL_PLL_C0:\r
3336     case ALT_CLK_EMAC0:\r
3337         if (   (div <= (ALT_CLKMGR_PERPLL_EMAC0CLK_CNT_SET_MSK + 1))\r
3338             && (alt_clk_within_freq_limits(ALT_CLK_PERIPHERAL_PLL_C0, div) == ALT_E_TRUE) )\r
3339         {\r
3340             temp = alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR);\r
3341             restore_0 = temp & ALT_CLKMGR_PERPLL_EN_EMAC0CLK_SET_MSK;\r
3342 \r
3343             if (restore_0)\r
3344             {\r
3345                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp & ALT_CLKMGR_PERPLL_EN_EMAC0CLK_CLR_MSK);\r
3346             }\r
3347 \r
3348             // now write the new divisor ratio\r
3349             wrval = div - 1;\r
3350             alt_clk_pllcounter_write(ALT_CLKMGR_PERPLL_VCO_ADDR,\r
3351                                      ALT_CLKMGR_PERPLL_STAT_ADDR,\r
3352                                      ALT_CLKMGR_PERPLL_EMAC0CLK_ADDR,\r
3353                                      wrval,\r
3354                                      ALT_CLK_PLL_RST_BIT_C0,\r
3355                                      ALT_CLKMGR_PERPLL_VCO_OUTRST_LSB);\r
3356 \r
3357             alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_EMAC0CLK_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
3358             if (restore_0)\r
3359             {\r
3360                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp);\r
3361             }\r
3362             ret = ALT_E_SUCCESS;\r
3363         }\r
3364         else\r
3365         {\r
3366             ret = ALT_E_ARG_RANGE;\r
3367         }\r
3368         break;\r
3369 \r
3370     case ALT_CLK_PERIPHERAL_PLL_C1:\r
3371     case ALT_CLK_EMAC1:\r
3372         if (   (div <= (ALT_CLKMGR_PERPLL_EMAC1CLK_CNT_SET_MSK + 1))\r
3373             && (alt_clk_within_freq_limits(ALT_CLK_PERIPHERAL_PLL_C1, div) == ALT_E_TRUE) )\r
3374         {\r
3375             temp = alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR);\r
3376             restore_0 = temp & ALT_CLKMGR_PERPLL_EN_EMAC1CLK_SET_MSK;\r
3377 \r
3378             if (restore_0)\r
3379             {\r
3380                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp & ALT_CLKMGR_PERPLL_EN_EMAC1CLK_CLR_MSK);\r
3381             }\r
3382             // now write the new divisor ratio\r
3383             wrval = div - 1;\r
3384             alt_clk_pllcounter_write(ALT_CLKMGR_PERPLL_VCO_ADDR,\r
3385                                      ALT_CLKMGR_PERPLL_STAT_ADDR,\r
3386                                      ALT_CLKMGR_PERPLL_EMAC1CLK_ADDR,\r
3387                                      wrval,\r
3388                                      ALT_CLK_PLL_RST_BIT_C1,\r
3389                                      ALT_CLKMGR_PERPLL_VCO_OUTRST_LSB);\r
3390 \r
3391             alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_EMAC1CLK_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
3392             if (restore_0)\r
3393             {\r
3394                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp);\r
3395             }\r
3396             ret = ALT_E_SUCCESS;\r
3397         }\r
3398         else\r
3399         {\r
3400             ret = ALT_E_ARG_RANGE;\r
3401         }\r
3402         break;\r
3403 \r
3404     case ALT_CLK_PERIPHERAL_PLL_C2:\r
3405         if (   (div <= (ALT_CLKMGR_PERPLL_PERQSPICLK_CNT_SET_MSK + 1))\r
3406             && (alt_clk_within_freq_limits(ALT_CLK_PERIPHERAL_PLL_C2, div) == ALT_E_TRUE) )\r
3407         {\r
3408             temp = ALT_CLKMGR_PERPLL_SRC_QSPI_GET(alt_read_word(ALT_CLKMGR_PERPLL_SRC_ADDR));\r
3409             if (temp == ALT_CLKMGR_PERPLL_SRC_QSPI_E_PERIPH_QSPI_CLK)\r
3410             {\r
3411                 // if qspi source is set to Peripheral PLL C2\r
3412                 temp = alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR);\r
3413                 // and if qspi_clk is enabled\r
3414                 restore_0 = temp & ALT_CLKMGR_PERPLL_EN_QSPICLK_SET_MSK;\r
3415                 if (restore_0)\r
3416                 {\r
3417                     alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp & ALT_CLKMGR_PERPLL_EN_QSPICLK_CLR_MSK);\r
3418                     // gate it off\r
3419                 }\r
3420             }\r
3421 \r
3422             // now write the new divisor ratio\r
3423             wrval = div - 1;\r
3424             alt_clk_pllcounter_write(ALT_CLKMGR_PERPLL_VCO_ADDR,\r
3425                                      ALT_CLKMGR_PERPLL_STAT_ADDR,\r
3426                                      ALT_CLKMGR_PERPLL_PERQSPICLK_ADDR,\r
3427                                      wrval,\r
3428                                      ALT_CLK_PLL_RST_BIT_C2,\r
3429                                      ALT_CLKMGR_PERPLL_VCO_OUTRST_LSB);\r
3430 \r
3431             alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_PERQSPICLK_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
3432             if (restore_0)\r
3433             {\r
3434                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp);\r
3435                 // if the clock was gated on (enabled) before, return it to that state\r
3436             }\r
3437             ret = ALT_E_SUCCESS;\r
3438         }\r
3439         else\r
3440         {\r
3441             ret = ALT_E_ARG_RANGE;\r
3442         }\r
3443         break;\r
3444 \r
3445     case ALT_CLK_PERIPHERAL_PLL_C3:\r
3446         if (   (div <= (ALT_CLKMGR_PERPLL_PERNANDSDMMCCLK_CNT_SET_MSK + 1))\r
3447             && (alt_clk_within_freq_limits(ALT_CLK_PERIPHERAL_PLL_C3, div) == ALT_E_TRUE) )\r
3448         {\r
3449             // first, are the clock MUX input selections currently set to use the clock we want to change?\r
3450             temp = alt_read_word(ALT_CLKMGR_PERPLL_SRC_ADDR);\r
3451             restore_0 = (ALT_CLKMGR_PERPLL_SRC_SDMMC_GET(temp) == ALT_CLKMGR_PERPLL_SRC_SDMMC_E_PERIPH_NAND_CLK);\r
3452             restore_1 = restore_2 = (ALT_CLKMGR_PERPLL_SRC_NAND_GET(temp) == ALT_CLKMGR_PERPLL_SRC_NAND_E_PERIPH_NAND_CLK);\r
3453 \r
3454             // now AND those with the current state of the three gate enables\r
3455             // to get the clocks which must be gated off and then back on\r
3456             temp1 = temp = alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR);\r
3457             restore_0 = restore_0 && (temp & ALT_CLKMGR_PERPLL_EN_SDMMCCLK_SET_MSK);\r
3458             restore_1 = restore_1 && (temp & ALT_CLKMGR_PERPLL_EN_NANDXCLK_SET_MSK);\r
3459             restore_2 = restore_2 && (temp & ALT_CLKMGR_PERPLL_EN_NANDCLK_SET_MSK);\r
3460 \r
3461             // gate off the clocks that depend on the clock divider that we want to change\r
3462             if (restore_2) { temp &= ALT_CLKMGR_PERPLL_EN_NANDCLK_CLR_MSK; }\r
3463             if (restore_0) { temp &= ALT_CLKMGR_PERPLL_EN_SDMMCCLK_CLR_MSK; }\r
3464             alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp);\r
3465 \r
3466             // the NAND clock must be gated off before the NANDX clock,\r
3467             if (restore_1)\r
3468             {\r
3469                 alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_PERNANDSDMMCCLK_ADDR, ALT_SW_MANAGED_CLK_WAIT_NANDCLK);\r
3470                 temp &= ALT_CLKMGR_PERPLL_EN_NANDXCLK_CLR_MSK;\r
3471                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp);\r
3472             }\r
3473 \r
3474             // now write the new divisor ratio\r
3475             wrval = div - 1;\r
3476             alt_clk_pllcounter_write(ALT_CLKMGR_PERPLL_VCO_ADDR,\r
3477                                      ALT_CLKMGR_PERPLL_STAT_ADDR,\r
3478                                      ALT_CLKMGR_PERPLL_PERNANDSDMMCCLK_ADDR,\r
3479                                      wrval,\r
3480                                      ALT_CLK_PLL_RST_BIT_C3,\r
3481                                      ALT_CLKMGR_PERPLL_VCO_OUTRST_LSB);\r
3482 \r
3483             alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_PERNANDSDMMCCLK_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV );\r
3484 \r
3485             // NAND clock and NAND_X clock cannot be written together, must be a set sequence with a delay\r
3486             alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp1 & ALT_CLKMGR_PERPLL_EN_NANDCLK_CLR_MSK);\r
3487             if (restore_2)\r
3488             {\r
3489                 // the NANDX clock must be gated on before the NAND clock.\r
3490                 alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_PERNANDSDMMCCLK_ADDR, ALT_SW_MANAGED_CLK_WAIT_NANDCLK );\r
3491                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp1);\r
3492             }\r
3493             ret = ALT_E_SUCCESS;\r
3494         }\r
3495         else\r
3496         {\r
3497             ret = ALT_E_ARG_RANGE;\r
3498         }\r
3499         break;\r
3500 \r
3501     case ALT_CLK_PERIPHERAL_PLL_C4:\r
3502         if (   (div <= (ALT_CLKMGR_PERPLL_PERBASECLK_CNT_SET_MSK + 1))\r
3503             && (alt_clk_within_freq_limits(ALT_CLK_PERIPHERAL_PLL_C4, div) == ALT_E_TRUE) )\r
3504         {\r
3505             // look at the L4 set of clock gates first\r
3506             temp1 = alt_read_word(ALT_CLKMGR_MAINPLL_L4SRC_ADDR);\r
3507             restore_0 = (ALT_CLKMGR_MAINPLL_L4SRC_L4MP_GET(temp1) == ALT_CLKMGR_MAINPLL_L4SRC_L4MP_E_PERIPHPLL);\r
3508             restore_1 = (ALT_CLKMGR_MAINPLL_L4SRC_L4SP_GET(temp1) == ALT_CLKMGR_MAINPLL_L4SRC_L4SP_E_PERIPHPLL);\r
3509             temp1 = alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR);\r
3510             restore_0 = restore_0 && (temp1 & ALT_CLKMGR_MAINPLL_EN_L4MPCLK_SET_MSK);\r
3511             restore_1 = restore_1 && (temp1 & ALT_CLKMGR_MAINPLL_EN_L4SPCLK_SET_MSK);\r
3512 \r
3513             // if the l4_sp and l4_mp clocks are not set to use the periph_base_clk\r
3514             // from the Peripheral PLL C4 clock divider output, or if they are\r
3515             // not currently gated on, don't change their gates\r
3516             temp = alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR);\r
3517             if (restore_0) { temp &= ALT_CLKMGR_MAINPLL_EN_L4MPCLK_CLR_MSK; }\r
3518             if (restore_1) { temp &= ALT_CLKMGR_MAINPLL_EN_L4SPCLK_CLR_MSK; }\r
3519             alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp);\r
3520 \r
3521             // now look at the C4 direct set of clock gates\r
3522             // first, create a mask of the C4 direct set of clock gate enables\r
3523             temp = (  ALT_CLKMGR_PERPLL_EN_USBCLK_SET_MSK\r
3524                     | ALT_CLKMGR_PERPLL_EN_SPIMCLK_SET_MSK\r
3525                     | ALT_CLKMGR_PERPLL_EN_CAN0CLK_SET_MSK\r
3526                     | ALT_CLKMGR_PERPLL_EN_CAN1CLK_SET_MSK\r
3527                     | ALT_CLKMGR_PERPLL_EN_GPIOCLK_SET_MSK );\r
3528 \r
3529             // gate off all the C4 Direct set of clocks\r
3530             alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp1 & ~temp);\r
3531 \r
3532             // change the clock divider ratio - the reason we're here\r
3533             wrval = div - 1;\r
3534             alt_clk_pllcounter_write(ALT_CLKMGR_PERPLL_VCO_ADDR,\r
3535                                      ALT_CLKMGR_PERPLL_STAT_ADDR,\r
3536                                      ALT_CLKMGR_PERPLL_PERBASECLK_ADDR,\r
3537                                      wrval,\r
3538                                      ALT_CLK_PLL_RST_BIT_C4,\r
3539                                      ALT_CLKMGR_PERPLL_VCO_OUTRST_LSB);\r
3540 \r
3541             alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_PERBASECLK_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV );\r
3542 \r
3543             // gate the affected clocks that were on before back on - both sets of gates\r
3544             temp = (restore_0) ? ALT_CLKMGR_MAINPLL_EN_L4MPCLK_SET_MSK : 0;\r
3545             if (restore_1) { temp |= ALT_CLKMGR_MAINPLL_EN_L4SPCLK_SET_MSK; }\r
3546             alt_setbits_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp);\r
3547             alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp1);\r
3548             ret = ALT_E_SUCCESS;\r
3549         }\r
3550         else\r
3551         {\r
3552             ret = ALT_E_ARG_RANGE;\r
3553         }\r
3554         break;\r
3555 \r
3556     case ALT_CLK_PERIPHERAL_PLL_C5:\r
3557     case ALT_CLK_H2F_USER1:\r
3558         if (   (div <= (ALT_CLKMGR_PERPLL_S2FUSER1CLK_CNT_SET_MSK + 1))\r
3559             && (alt_clk_within_freq_limits(ALT_CLK_PERIPHERAL_PLL_C5, div) == ALT_E_TRUE) )\r
3560         {\r
3561             temp = alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR);\r
3562             restore_0 = temp & ALT_CLKMGR_PERPLL_EN_S2FUSER1CLK_SET_MSK;\r
3563             if (restore_0)\r
3564             {\r
3565                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp & ALT_CLKMGR_PERPLL_EN_S2FUSER1CLK_CLR_MSK);\r
3566             }\r
3567 \r
3568             // now write the new divisor ratio\r
3569             wrval = div - 1;\r
3570             alt_clk_pllcounter_write(ALT_CLKMGR_PERPLL_VCO_ADDR,\r
3571                                      ALT_CLKMGR_PERPLL_STAT_ADDR,\r
3572                                      ALT_CLKMGR_PERPLL_S2FUSER1CLK_ADDR,\r
3573                                      wrval,\r
3574                                      ALT_CLK_PLL_RST_BIT_C5,\r
3575                                      ALT_CLKMGR_PERPLL_VCO_OUTRST_LSB);\r
3576 \r
3577             alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV );\r
3578             if (restore_0) { alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp); }\r
3579             ret = ALT_E_SUCCESS;\r
3580         }\r
3581         else\r
3582         {\r
3583             ret = ALT_E_ARG_RANGE;\r
3584         }\r
3585         break;\r
3586 \r
3587         /////\r
3588 \r
3589         // SDRAM PLL outputs\r
3590     case ALT_CLK_SDRAM_PLL_C0:\r
3591     case ALT_CLK_DDR_DQS:\r
3592         if (   (div <= (ALT_CLKMGR_SDRPLL_DDRDQSCLK_CNT_SET_MSK + 1))\r
3593             && (alt_clk_within_freq_limits(ALT_CLK_SDRAM_PLL_C0, div) == ALT_E_TRUE) )\r
3594         {\r
3595             wrval = div - 1;\r
3596             temp = alt_read_word(ALT_CLKMGR_SDRPLL_EN_ADDR);\r
3597             if (temp & ALT_CLKMGR_SDRPLL_EN_DDRDQSCLK_SET_MSK)\r
3598             {\r
3599                 // if clock is currently on, gate it off\r
3600                 alt_write_word(ALT_CLKMGR_SDRPLL_EN_ADDR, temp & ALT_CLKMGR_SDRPLL_EN_DDRDQSCLK_CLR_MSK);\r
3601                 restore_0 = true;\r
3602             }\r
3603 \r
3604             alt_clk_pllcounter_write(ALT_CLKMGR_SDRPLL_VCO_ADDR,\r
3605                                      ALT_CLKMGR_SDRPLL_STAT_ADDR,\r
3606                                      ALT_CLKMGR_SDRPLL_DDRDQSCLK_ADDR,\r
3607                                      wrval,\r
3608                                      ALT_CLK_PLL_RST_BIT_C0,\r
3609                                      ALT_CLKMGR_SDRPLL_DDRDQSCLK_CNT_LSB);\r
3610             if (restore_0)\r
3611             {\r
3612                 alt_write_word(ALT_CLKMGR_SDRPLL_EN_ADDR, temp);         // which has the enable bit set\r
3613             }\r
3614             ret = ALT_E_SUCCESS;\r
3615         }\r
3616         else\r
3617         {\r
3618             ret = ALT_E_ARG_RANGE;\r
3619         }\r
3620         break;\r
3621 \r
3622     case ALT_CLK_SDRAM_PLL_C1:\r
3623     case ALT_CLK_DDR_2X_DQS:\r
3624         if (   (div <= (ALT_CLKMGR_SDRPLL_DDR2XDQSCLK_CNT_SET_MSK + 1))\r
3625             && (alt_clk_within_freq_limits(ALT_CLK_SDRAM_PLL_C1, div) == ALT_E_TRUE) )\r
3626         {\r
3627             wrval = div - 1;\r
3628             temp = alt_read_word(ALT_CLKMGR_SDRPLL_EN_ADDR);\r
3629             if (temp & ALT_CLKMGR_SDRPLL_EN_DDR2XDQSCLK_SET_MSK)\r
3630             {\r
3631                 // if clock is currently on, gate it off\r
3632                 alt_write_word(ALT_CLKMGR_SDRPLL_EN_ADDR, temp & ALT_CLKMGR_SDRPLL_EN_DDR2XDQSCLK_CLR_MSK);\r
3633                 restore_0 = true;\r
3634             }\r
3635 \r
3636             alt_clk_pllcounter_write(ALT_CLKMGR_SDRPLL_VCO_ADDR,\r
3637                                      ALT_CLKMGR_SDRPLL_STAT_ADDR,\r
3638                                      ALT_CLKMGR_SDRPLL_DDR2XDQSCLK_ADDR,\r
3639                                      wrval,\r
3640                                      ALT_CLK_PLL_RST_BIT_C1,\r
3641                                      ALT_CLKMGR_SDRPLL_VCO_OUTRST_LSB);\r
3642             if (restore_0)\r
3643             {\r
3644                 alt_write_word(ALT_CLKMGR_SDRPLL_EN_ADDR, temp);         // which has the enable bit set\r
3645             }\r
3646             ret = ALT_E_SUCCESS;\r
3647         }\r
3648         else\r
3649         {\r
3650             ret = ALT_E_ARG_RANGE;\r
3651         }\r
3652         break;\r
3653 \r
3654     case ALT_CLK_SDRAM_PLL_C2:\r
3655     case ALT_CLK_DDR_DQ:\r
3656         if (   (div <= (ALT_CLKMGR_SDRPLL_DDRDQCLK_CNT_SET_MSK + 1))\r
3657             && (alt_clk_within_freq_limits(ALT_CLK_SDRAM_PLL_C2, div) == ALT_E_TRUE) )\r
3658         {\r
3659             wrval = div - 1;\r
3660             temp = alt_read_word(ALT_CLKMGR_SDRPLL_EN_ADDR);\r
3661             if (temp & ALT_CLKMGR_SDRPLL_EN_DDRDQCLK_SET_MSK)\r
3662             {\r
3663                 // if clock is currently on, gate it off\r
3664                 alt_write_word(ALT_CLKMGR_SDRPLL_EN_ADDR, temp & ALT_CLKMGR_SDRPLL_EN_DDRDQCLK_CLR_MSK);\r
3665                 restore_0 = true;\r
3666             }\r
3667 \r
3668             alt_clk_pllcounter_write(ALT_CLKMGR_SDRPLL_VCO_ADDR,\r
3669                                      ALT_CLKMGR_SDRPLL_STAT_ADDR,\r
3670                                      ALT_CLKMGR_SDRPLL_DDRDQCLK_ADDR,\r
3671                                      wrval,\r
3672                                      ALT_CLK_PLL_RST_BIT_C2,\r
3673                                      ALT_CLKMGR_SDRPLL_VCO_OUTRST_LSB);\r
3674             if (restore_0)\r
3675             {\r
3676                 alt_write_word(ALT_CLKMGR_SDRPLL_EN_ADDR, temp);         // which has the enable bit set\r
3677             }\r
3678             ret = ALT_E_SUCCESS;\r
3679         }\r
3680         else\r
3681         {\r
3682             ret = ALT_E_ARG_RANGE;\r
3683         }\r
3684         break;\r
3685 \r
3686     case ALT_CLK_SDRAM_PLL_C5:\r
3687     case ALT_CLK_H2F_USER2:\r
3688         if (   (div <= (ALT_CLKMGR_SDRPLL_S2FUSER2CLK_CNT_SET_MSK + 1))\r
3689             && (alt_clk_within_freq_limits(ALT_CLK_SDRAM_PLL_C5, div) == ALT_E_TRUE) )\r
3690         {\r
3691             wrval = div - 1;\r
3692             temp = alt_read_word(ALT_CLKMGR_SDRPLL_EN_ADDR);\r
3693             if (temp & ALT_CLKMGR_SDRPLL_EN_S2FUSER2CLK_SET_MSK)\r
3694             {\r
3695                 // if clock is currently on, gate it off\r
3696                 alt_write_word(ALT_CLKMGR_SDRPLL_EN_ADDR, temp & ALT_CLKMGR_SDRPLL_EN_S2FUSER2CLK_CLR_MSK);\r
3697                 restore_0 = true;\r
3698             }\r
3699 \r
3700             alt_clk_pllcounter_write(ALT_CLKMGR_SDRPLL_VCO_ADDR,\r
3701                                      ALT_CLKMGR_SDRPLL_STAT_ADDR,\r
3702                                      ALT_CLKMGR_SDRPLL_S2FUSER2CLK_ADDR,\r
3703                                      wrval,\r
3704                                      ALT_CLK_PLL_RST_BIT_C5,\r
3705                                      ALT_CLKMGR_SDRPLL_VCO_OUTRST_LSB);\r
3706             if (restore_0)\r
3707             {\r
3708                 alt_write_word(ALT_CLKMGR_SDRPLL_EN_ADDR, temp);         // which has the enable bit set\r
3709             }\r
3710             ret = ALT_E_SUCCESS;\r
3711         }\r
3712         else\r
3713         {\r
3714             ret = ALT_E_ARG_RANGE;\r
3715         }\r
3716         break;\r
3717 \r
3718         /////\r
3719 \r
3720         // Other clock dividers\r
3721     case ALT_CLK_L3_MP:\r
3722         if      (div == 1) { wrval = ALT_CLKMGR_MAINPLL_MAINDIV_L3MPCLK_E_DIV1; }\r
3723         else if (div == 2) { wrval = ALT_CLKMGR_MAINPLL_MAINDIV_L3MPCLK_E_DIV2; }\r
3724 \r
3725         if (wrval != UINT32_MAX)\r
3726         {\r
3727             temp = alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR);\r
3728             if (temp & ALT_CLKMGR_MAINPLL_EN_L3MPCLK_SET_MSK)\r
3729             {\r
3730                 // if clock is currently on, gate it off\r
3731                 alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp & ALT_CLKMGR_MAINPLL_EN_L3MPCLK_CLR_MSK);\r
3732                 restore_0 = true;\r
3733             }\r
3734             alt_replbits_word(ALT_CLKMGR_MAINPLL_MAINDIV_ADDR, ALT_CLKMGR_MAINPLL_MAINDIV_L3MPCLK_SET_MSK,\r
3735                               wrval << ALT_CLKMGR_MAINPLL_MAINDIV_L3MPCLK_LSB);\r
3736             alt_clk_mgr_wait(ALT_CLKMGR_MAINPLL_EN_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV );\r
3737             if (restore_0)\r
3738             {\r
3739                 alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp);         // which has the enable bit set\r
3740             }\r
3741             ret = ALT_E_SUCCESS;\r
3742         }\r
3743         else\r
3744         {\r
3745             ret = ALT_E_ARG_RANGE;\r
3746         }\r
3747         break;\r
3748 \r
3749     case ALT_CLK_L3_SP:\r
3750         // note that the L3MP divider is upstream from the L3SP divider\r
3751         // and any changes to the former will affect the output of both\r
3752         if      (div == 1) { wrval = ALT_CLKMGR_MAINPLL_MAINDIV_L3SPCLK_E_DIV1; }\r
3753         else if (div == 2) { wrval = ALT_CLKMGR_MAINPLL_MAINDIV_L3SPCLK_E_DIV2; }\r
3754 \r
3755         if (wrval != UINT32_MAX)\r
3756         {\r
3757             alt_replbits_word(ALT_CLKMGR_MAINPLL_MAINDIV_ADDR, ALT_CLKMGR_MAINPLL_MAINDIV_L3SPCLK_SET_MSK,\r
3758                               wrval << ALT_CLKMGR_MAINPLL_MAINDIV_L3SPCLK_LSB);\r
3759             // no clock gate to close and reopen\r
3760             alt_clk_mgr_wait(ALT_CLKMGR_MAINPLL_MAINDIV_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV );\r
3761             ret = ALT_E_SUCCESS;\r
3762         }\r
3763         else\r
3764         {\r
3765             ret = ALT_E_ARG_RANGE;\r
3766         }\r
3767         break;\r
3768 \r
3769     case ALT_CLK_L4_MP:\r
3770         if      (div ==  1) { wrval = ALT_CLKMGR_MAINPLL_MAINDIV_L4MPCLK_E_DIV1; }\r
3771         else if (div ==  2) { wrval = ALT_CLKMGR_MAINPLL_MAINDIV_L4MPCLK_E_DIV2; }\r
3772         else if (div ==  4) { wrval = ALT_CLKMGR_MAINPLL_MAINDIV_L4MPCLK_E_DIV4; }\r
3773         else if (div ==  8) { wrval = ALT_CLKMGR_MAINPLL_MAINDIV_L4MPCLK_E_DIV8; }\r
3774         else if (div == 16) { wrval = ALT_CLKMGR_MAINPLL_MAINDIV_L4MPCLK_E_DIV16; }\r
3775 \r
3776         if (wrval != UINT32_MAX)\r
3777         {\r
3778             temp = alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR);\r
3779             if (temp & ALT_CLKMGR_MAINPLL_EN_L4MPCLK_SET_MSK)\r
3780             {\r
3781                 // if clock is currently on, gate it off\r
3782                 alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp & ALT_CLKMGR_MAINPLL_EN_L4MPCLK_CLR_MSK);\r
3783                 restore_0 = true;\r
3784             }\r
3785             alt_replbits_word(ALT_CLKMGR_MAINPLL_MAINDIV_ADDR, ALT_CLKMGR_MAINPLL_MAINDIV_L4MPCLK_SET_MSK,\r
3786                               wrval << ALT_CLKMGR_MAINPLL_MAINDIV_L4MPCLK_LSB);\r
3787             alt_clk_mgr_wait(ALT_CLKMGR_MAINPLL_MAINDIV_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
3788             if (restore_0)\r
3789             {\r
3790                 alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp);         // which has the enable bit set\r
3791             }\r
3792             ret = ALT_E_SUCCESS;\r
3793         }\r
3794         else\r
3795         {\r
3796             ret = ALT_E_ARG_RANGE;\r
3797         }\r
3798         break;\r
3799 \r
3800     case ALT_CLK_L4_SP:\r
3801         if      (div ==  1) { wrval = ALT_CLKMGR_MAINPLL_MAINDIV_L4SPCLK_E_DIV1; }\r
3802         else if (div ==  2) { wrval = ALT_CLKMGR_MAINPLL_MAINDIV_L4SPCLK_E_DIV2; }\r
3803         else if (div ==  4) { wrval = ALT_CLKMGR_MAINPLL_MAINDIV_L4SPCLK_E_DIV4; }\r
3804         else if (div ==  8) { wrval = ALT_CLKMGR_MAINPLL_MAINDIV_L4SPCLK_E_DIV8; }\r
3805         else if (div == 16) { wrval = ALT_CLKMGR_MAINPLL_MAINDIV_L4SPCLK_E_DIV16; }\r
3806 \r
3807         if (wrval != UINT32_MAX)\r
3808         {\r
3809             temp = alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR);\r
3810             if (temp & ALT_CLKMGR_MAINPLL_EN_L4SPCLK_SET_MSK)\r
3811             {\r
3812                 // if clock is currently on, gate it off\r
3813                 alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp & ALT_CLKMGR_MAINPLL_EN_L4SPCLK_CLR_MSK);\r
3814                 restore_0 = true;\r
3815             }\r
3816             alt_replbits_word(ALT_CLKMGR_MAINPLL_MAINDIV_ADDR, ALT_CLKMGR_MAINPLL_MAINDIV_L4SPCLK_SET_MSK,\r
3817                               wrval << ALT_CLKMGR_MAINPLL_MAINDIV_L4SPCLK_LSB);\r
3818             alt_clk_mgr_wait(ALT_CLKMGR_MAINPLL_MAINDIV_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
3819             if (restore_0)\r
3820             {\r
3821                 alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp);\r
3822             }\r
3823             ret = ALT_E_SUCCESS;\r
3824         }\r
3825         else\r
3826         {\r
3827             ret = ALT_E_ARG_RANGE;\r
3828         }\r
3829         break;\r
3830 \r
3831     case ALT_CLK_DBG_AT:\r
3832         if      (div == 1) { wrval = ALT_CLKMGR_MAINPLL_DBGDIV_DBGATCLK_E_DIV1; }\r
3833         else if (div == 2) { wrval = ALT_CLKMGR_MAINPLL_DBGDIV_DBGATCLK_E_DIV2; }\r
3834         else if (div == 4) { wrval = ALT_CLKMGR_MAINPLL_DBGDIV_DBGATCLK_E_DIV4; }\r
3835 \r
3836         if (wrval != UINT32_MAX)\r
3837         {\r
3838             temp = alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR);\r
3839             if (temp & ALT_CLKMGR_MAINPLL_EN_DBGATCLK_SET_MSK)\r
3840             {\r
3841                 // if clock is currently on, gate it off\r
3842                 alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp & ALT_CLKMGR_MAINPLL_EN_DBGATCLK_CLR_MSK);\r
3843                 restore_0 = true;\r
3844             }\r
3845             alt_replbits_word(ALT_CLKMGR_MAINPLL_DBGDIV_ADDR, ALT_CLKMGR_MAINPLL_DBGDIV_DBGATCLK_SET_MSK,\r
3846                               wrval << ALT_CLKMGR_MAINPLL_DBGDIV_DBGATCLK_LSB);\r
3847             alt_clk_mgr_wait(ALT_CLKMGR_MAINPLL_DBGDIV_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
3848             if (restore_0)\r
3849             {\r
3850                 alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp);\r
3851             }\r
3852             ret = ALT_E_SUCCESS;\r
3853         }\r
3854         else\r
3855         {\r
3856             ret = ALT_E_ARG_RANGE;\r
3857         }\r
3858         break;\r
3859 \r
3860     case ALT_CLK_DBG:\r
3861         if      (div == 2) { wrval = ALT_CLKMGR_MAINPLL_DBGDIV_DBGCLK_E_DIV2; }\r
3862         else if (div == 4) { wrval = ALT_CLKMGR_MAINPLL_DBGDIV_DBGCLK_E_DIV4; }\r
3863 \r
3864         if (wrval != UINT32_MAX)\r
3865         {\r
3866             temp = alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR);\r
3867             if (temp & ALT_CLKMGR_MAINPLL_EN_DBGCLK_SET_MSK)\r
3868             {\r
3869                 // if clock is currently on, gate it off\r
3870                 alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp & ALT_CLKMGR_MAINPLL_EN_DBGCLK_CLR_MSK);\r
3871                 restore_0 = true;\r
3872             }\r
3873             alt_replbits_word(ALT_CLKMGR_MAINPLL_DBGDIV_ADDR, ALT_CLKMGR_MAINPLL_DBGDIV_DBGCLK_SET_MSK,\r
3874                               wrval << (ALT_CLKMGR_MAINPLL_DBGDIV_DBGCLK_LSB - 1));\r
3875             // account for the fact that the divisor ratios are 2x the value\r
3876             alt_clk_mgr_wait(ALT_CLKMGR_MAINPLL_DBGDIV_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
3877             if (restore_0)\r
3878             {\r
3879                 alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp);\r
3880             }\r
3881             ret = ALT_E_SUCCESS;\r
3882         }\r
3883         else\r
3884         {\r
3885             ret = ALT_E_ARG_RANGE;\r
3886         }\r
3887         break;\r
3888 \r
3889     case ALT_CLK_DBG_TRACE:\r
3890         if      (div ==  1) { wrval = ALT_CLKMGR_MAINPLL_TRACEDIV_TRACECLK_E_DIV1; }\r
3891         else if (div ==  2) { wrval = ALT_CLKMGR_MAINPLL_TRACEDIV_TRACECLK_E_DIV2; }\r
3892         else if (div ==  4) { wrval = ALT_CLKMGR_MAINPLL_TRACEDIV_TRACECLK_E_DIV4; }\r
3893         else if (div ==  8) { wrval = ALT_CLKMGR_MAINPLL_TRACEDIV_TRACECLK_E_DIV8; }\r
3894         else if (div == 16) { wrval = ALT_CLKMGR_MAINPLL_TRACEDIV_TRACECLK_E_DIV16; }\r
3895 \r
3896         if (wrval != UINT32_MAX)\r
3897         {\r
3898             temp = alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR);\r
3899             if (temp & ALT_CLKMGR_MAINPLL_EN_DBGTRACECLK_SET_MSK)\r
3900             {\r
3901                 // if clock is currently on, gate it off\r
3902                 alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp & ALT_CLKMGR_MAINPLL_EN_DBGTRACECLK_CLR_MSK);\r
3903                 restore_0 = true;\r
3904             }\r
3905             alt_replbits_word(ALT_CLKMGR_MAINPLL_TRACEDIV_ADDR, ALT_CLKMGR_MAINPLL_TRACEDIV_TRACECLK_SET_MSK,\r
3906                               wrval << ALT_CLKMGR_MAINPLL_TRACEDIV_TRACECLK_LSB);\r
3907             alt_clk_mgr_wait(ALT_CLKMGR_MAINPLL_TRACEDIV_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
3908             if (restore_0)\r
3909             {\r
3910                 alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, temp);\r
3911             }\r
3912             ret = ALT_E_SUCCESS;\r
3913         }\r
3914         else\r
3915         {\r
3916             ret = ALT_E_ARG_RANGE;\r
3917         }\r
3918         break;\r
3919 \r
3920     case ALT_CLK_USB_MP:\r
3921         if      (div ==  1) { wrval = ALT_CLKMGR_PERPLL_DIV_USBCLK_E_DIV1; }\r
3922         else if (div ==  2) { wrval = ALT_CLKMGR_PERPLL_DIV_USBCLK_E_DIV2; }\r
3923         else if (div ==  4) { wrval = ALT_CLKMGR_PERPLL_DIV_USBCLK_E_DIV4; }\r
3924         else if (div ==  8) { wrval = ALT_CLKMGR_PERPLL_DIV_USBCLK_E_DIV8; }\r
3925         else if (div == 16) { wrval = ALT_CLKMGR_PERPLL_DIV_USBCLK_E_DIV16; }\r
3926 \r
3927         if (wrval != UINT32_MAX)\r
3928         {\r
3929             temp = alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR);\r
3930             if (temp & ALT_CLKMGR_PERPLL_EN_USBCLK_SET_MSK)\r
3931             {\r
3932                 // if clock is currently on, gate it off\r
3933                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp & ALT_CLKMGR_PERPLL_EN_USBCLK_CLR_MSK);\r
3934                 restore_0 = true;\r
3935             }\r
3936             alt_replbits_word(ALT_CLKMGR_PERPLL_DIV_ADDR, ALT_CLKMGR_PERPLL_DIV_USBCLK_SET_MSK,\r
3937                               wrval << ALT_CLKMGR_PERPLL_DIV_USBCLK_LSB);\r
3938             alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_DIV_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
3939             if (restore_0)\r
3940             {\r
3941                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp);\r
3942             }\r
3943             ret = ALT_E_SUCCESS;\r
3944         }\r
3945         else\r
3946         {\r
3947             ret = ALT_E_ARG_RANGE;\r
3948         }\r
3949         break;\r
3950 \r
3951     case ALT_CLK_SPI_M:\r
3952         if      (div ==  1) { wrval = ALT_CLKMGR_PERPLL_DIV_SPIMCLK_E_DIV1; }\r
3953         else if (div ==  2) { wrval = ALT_CLKMGR_PERPLL_DIV_SPIMCLK_E_DIV2; }\r
3954         else if (div ==  4) { wrval = ALT_CLKMGR_PERPLL_DIV_SPIMCLK_E_DIV4; }\r
3955         else if (div ==  8) { wrval = ALT_CLKMGR_PERPLL_DIV_SPIMCLK_E_DIV8; }\r
3956         else if (div == 16) { wrval = ALT_CLKMGR_PERPLL_DIV_SPIMCLK_E_DIV16; }\r
3957 \r
3958         if (wrval != UINT32_MAX)\r
3959         {\r
3960             temp = alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR);\r
3961             if (temp & ALT_CLKMGR_PERPLL_EN_SPIMCLK_SET_MSK)\r
3962             {\r
3963                 // if clock is currently on, gate it off\r
3964                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp & ALT_CLKMGR_PERPLL_EN_SPIMCLK_CLR_MSK);\r
3965                 restore_0 = true;\r
3966             }\r
3967             alt_replbits_word(ALT_CLKMGR_PERPLL_DIV_ADDR, ALT_CLKMGR_PERPLL_DIV_SPIMCLK_SET_MSK,\r
3968                               wrval << ALT_CLKMGR_PERPLL_DIV_SPIMCLK_LSB);\r
3969             alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_DIV_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
3970             if (restore_0)\r
3971             {\r
3972                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp);\r
3973             }\r
3974             ret = ALT_E_SUCCESS;\r
3975         }\r
3976         else\r
3977         {\r
3978             ret = ALT_E_ARG_RANGE;\r
3979         }\r
3980         break;\r
3981 \r
3982     case ALT_CLK_CAN0:\r
3983         if      (div ==  1) { wrval = ALT_CLKMGR_PERPLL_DIV_CAN0CLK_E_DIV1; }\r
3984         else if (div ==  2) { wrval = ALT_CLKMGR_PERPLL_DIV_CAN0CLK_E_DIV2; }\r
3985         else if (div ==  4) { wrval = ALT_CLKMGR_PERPLL_DIV_CAN0CLK_E_DIV4; }\r
3986         else if (div ==  8) { wrval = ALT_CLKMGR_PERPLL_DIV_CAN0CLK_E_DIV8; }\r
3987         else if (div == 16) { wrval = ALT_CLKMGR_PERPLL_DIV_CAN0CLK_E_DIV16; }\r
3988 \r
3989         if (wrval != UINT32_MAX)\r
3990         {\r
3991             temp = alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR);\r
3992             if (temp & ALT_CLKMGR_PERPLL_EN_CAN0CLK_SET_MSK)\r
3993             {\r
3994                 // if clock is currently on, gate it off\r
3995                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp & ALT_CLKMGR_PERPLL_EN_CAN0CLK_CLR_MSK);\r
3996                 restore_0 = true;\r
3997             }\r
3998             alt_replbits_word(ALT_CLKMGR_PERPLL_DIV_ADDR, ALT_CLKMGR_PERPLL_DIV_CAN0CLK_SET_MSK,\r
3999                               wrval << ALT_CLKMGR_PERPLL_DIV_CAN0CLK_LSB);\r
4000             alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_DIV_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
4001             if (restore_0)\r
4002             {\r
4003                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp);\r
4004             }\r
4005             ret = ALT_E_SUCCESS;\r
4006         }\r
4007         else\r
4008         {\r
4009             ret = ALT_E_ARG_RANGE;\r
4010         }\r
4011         break;\r
4012 \r
4013     case ALT_CLK_CAN1:\r
4014         if      (div ==  1) { wrval = ALT_CLKMGR_PERPLL_DIV_CAN1CLK_E_DIV1; }\r
4015         else if (div ==  2) { wrval = ALT_CLKMGR_PERPLL_DIV_CAN1CLK_E_DIV2; }\r
4016         else if (div ==  4) { wrval = ALT_CLKMGR_PERPLL_DIV_CAN1CLK_E_DIV4; }\r
4017         else if (div ==  8) { wrval = ALT_CLKMGR_PERPLL_DIV_CAN1CLK_E_DIV8; }\r
4018         else if (div == 16) { wrval = ALT_CLKMGR_PERPLL_DIV_CAN1CLK_E_DIV16; }\r
4019 \r
4020         if (wrval != UINT32_MAX)\r
4021         {\r
4022             temp = alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR);\r
4023             if (temp & ALT_CLKMGR_PERPLL_EN_CAN1CLK_SET_MSK)\r
4024             {\r
4025                 // if clock is currently on, gate it off\r
4026                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp & ALT_CLKMGR_PERPLL_EN_CAN1CLK_CLR_MSK);\r
4027                 restore_0 = true;\r
4028             }\r
4029             alt_replbits_word(ALT_CLKMGR_PERPLL_DIV_ADDR, ALT_CLKMGR_PERPLL_DIV_CAN1CLK_SET_MSK,\r
4030                               wrval << ALT_CLKMGR_PERPLL_DIV_CAN1CLK_LSB);\r
4031             alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_DIV_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
4032             if (restore_0)\r
4033             {\r
4034                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp);\r
4035             }\r
4036             ret = ALT_E_SUCCESS;\r
4037         }\r
4038         else\r
4039         {\r
4040             ret = ALT_E_ARG_RANGE;\r
4041         }\r
4042         break;\r
4043 \r
4044     case ALT_CLK_GPIO_DB:           // GPIO debounce clock\r
4045         if (div <= ALT_CLKMGR_PERPLL_GPIODIV_GPIODBCLK_SET_MSK)\r
4046         {\r
4047             temp = alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR);\r
4048             if (temp & ALT_CLKMGR_PERPLL_EN_GPIOCLK_SET_MSK)\r
4049             {\r
4050                 // if clock is currently on, gate it off\r
4051                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp & ALT_CLKMGR_PERPLL_EN_GPIOCLK_CLR_MSK);\r
4052                 restore_0 = true;\r
4053             }\r
4054             wrval = div - 1;\r
4055             alt_replbits_word(ALT_CLKMGR_PERPLL_GPIODIV_ADDR, ALT_CLKMGR_PERPLL_GPIODIV_GPIODBCLK_SET_MSK,\r
4056                               wrval << ALT_CLKMGR_PERPLL_GPIODIV_GPIODBCLK_LSB);\r
4057             alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_GPIODIV_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
4058             if (restore_0)\r
4059             {\r
4060                 alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, temp);\r
4061             }\r
4062             ret = ALT_E_SUCCESS;\r
4063         }\r
4064         else\r
4065         {\r
4066             ret = ALT_E_ARG_RANGE;\r
4067         }\r
4068         break;\r
4069 \r
4070     case ALT_CLK_MAIN_QSPI:\r
4071         temp = ALT_CLKMGR_PERPLL_SRC_QSPI_GET(alt_read_word(ALT_CLKMGR_PERPLL_SRC_ADDR));\r
4072         // get the QSPI clock source\r
4073         restore_0 = alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR) & ALT_CLKMGR_PERPLL_EN_QSPICLK_SET_MSK;\r
4074         // and the current enable state\r
4075         wrval = div - 1;\r
4076 \r
4077         if (temp == ALT_CLKMGR_PERPLL_SRC_QSPI_E_MAIN_QSPI_CLK)\r
4078         {           // if the main_qspi_clk (Main PLL C3 Ouput) input is selected\r
4079             if (div <= ALT_CLKMGR_MAINPLL_MAINQSPICLK_CNT_SET_MSK)\r
4080             {\r
4081                 if (restore_0)\r
4082                 {\r
4083                     alt_clrbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_QSPICLK_SET_MSK);\r
4084                 }                // gate off the QSPI clock\r
4085 \r
4086                 alt_clk_pllcounter_write(ALT_CLKMGR_MAINPLL_VCO_ADDR,\r
4087                                          ALT_CLKMGR_MAINPLL_STAT_ADDR,\r
4088                                          ALT_CLKMGR_MAINPLL_MAINQSPICLK_ADDR,\r
4089                                          wrval,\r
4090                                          ALT_CLK_PLL_RST_BIT_C3,\r
4091                                          ALT_CLKMGR_MAINPLL_VCO_OUTRST_LSB);\r
4092 \r
4093                 alt_clk_mgr_wait(ALT_CLKMGR_MAINPLL_MAINQSPICLK_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
4094                 if (restore_0)\r
4095                 {\r
4096                     alt_setbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_QSPICLK_SET_MSK);\r
4097                     // if the QSPI clock was gated on (enabled) before, return it to that state\r
4098                 }\r
4099                 ret = ALT_E_SUCCESS;\r
4100             }\r
4101             else\r
4102             {\r
4103                 ret = ALT_E_ARG_RANGE;\r
4104             }\r
4105         }\r
4106         else if (temp == ALT_CLKMGR_PERPLL_SRC_QSPI_E_PERIPH_QSPI_CLK)\r
4107         {\r
4108             if (div <= ALT_CLKMGR_PERPLL_PERQSPICLK_CNT_SET_MSK)\r
4109             {\r
4110                 if (restore_0)\r
4111                 {\r
4112                     alt_clrbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_QSPICLK_SET_MSK);\r
4113                 }                // gate off the QSPI clock\r
4114 \r
4115                 alt_clk_pllcounter_write(ALT_CLKMGR_PERPLL_VCO_ADDR,\r
4116                                          ALT_CLKMGR_PERPLL_STAT_ADDR,\r
4117                                          ALT_CLKMGR_PERPLL_PERQSPICLK_ADDR,\r
4118                                          wrval,\r
4119                                          ALT_CLK_PLL_RST_BIT_C2,\r
4120                                          ALT_CLKMGR_PERPLL_VCO_OUTRST_LSB);\r
4121 \r
4122                 alt_clk_mgr_wait(ALT_CLKMGR_PERPLL_PERQSPICLK_ADDR, ALT_SW_MANAGED_CLK_WAIT_CTRDIV);\r
4123                 if (restore_0)\r
4124                 {\r
4125                     alt_setbits_word(ALT_CLKMGR_PERPLL_EN_ADDR, ALT_CLKMGR_PERPLL_EN_QSPICLK_SET_MSK);\r
4126                     // if the QSPI clock was gated on (enabled) before, return it to that state\r
4127                 }\r
4128                 ret = ALT_E_SUCCESS;\r
4129             }\r
4130             else\r
4131             {\r
4132                 ret = ALT_E_ARG_RANGE;\r
4133             }\r
4134         }\r
4135         break;\r
4136 \r
4137         /////\r
4138 \r
4139     default:\r
4140         ret = ALT_E_BAD_ARG;\r
4141         break;\r
4142     }\r
4143 \r
4144     return ret;\r
4145 }\r
4146 \r
4147 //\r
4148 // alt_clk_freq_get() returns the output frequency of the specified clock.\r
4149 //\r
4150 ALT_STATUS_CODE alt_clk_freq_get(ALT_CLK_t clk, alt_freq_t* freq)\r
4151 {\r
4152     ALT_STATUS_CODE ret = ALT_E_BAD_ARG;\r
4153     uint32_t        temp = 0;\r
4154     uint64_t        numer = 0;\r
4155     uint64_t        denom = 1;\r
4156 \r
4157     if (freq == NULL)\r
4158         {\r
4159                 return ret;\r
4160         }\r
4161 \r
4162     switch (clk)\r
4163     {\r
4164         // External Inputs\r
4165     case ALT_CLK_IN_PIN_OSC1:\r
4166     case ALT_CLK_OSC1:\r
4167         numer = alt_ext_clk_paramblok.clkosc1.freqcur;\r
4168         // denom = 1 by default\r
4169         ret = ALT_E_SUCCESS;\r
4170         break;\r
4171 \r
4172     case ALT_CLK_IN_PIN_OSC2:\r
4173         numer = alt_ext_clk_paramblok.clkosc2.freqcur;\r
4174         // denom = 1 by default\r
4175         ret = ALT_E_SUCCESS;\r
4176         break;\r
4177 \r
4178     case ALT_CLK_F2H_PERIPH_REF:\r
4179         numer = alt_ext_clk_paramblok.periph.freqcur;\r
4180         // denom = 1 by default\r
4181         ret = ALT_E_SUCCESS;\r
4182         break;\r
4183 \r
4184     case ALT_CLK_F2H_SDRAM_REF:\r
4185         numer = alt_ext_clk_paramblok.sdram.freqcur;\r
4186         // denom = 1 by default\r
4187         ret = ALT_E_SUCCESS;\r
4188         break;\r
4189 \r
4190         /////\r
4191 \r
4192         // PLLs\r
4193     case ALT_CLK_MAIN_PLL:\r
4194         if (alt_clk_pll_is_bypassed(ALT_CLK_MAIN_PLL) == ALT_E_TRUE)\r
4195         {\r
4196             temp = alt_ext_clk_paramblok.clkosc1.freqcur;\r
4197             ret = ALT_E_SUCCESS;\r
4198         }\r
4199         else\r
4200         {\r
4201             ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4202         }\r
4203         numer = (uint64_t) temp;\r
4204         // denom = 1 by default\r
4205         break;\r
4206 \r
4207     case ALT_CLK_PERIPHERAL_PLL:\r
4208         if (alt_clk_pll_is_bypassed(ALT_CLK_PERIPHERAL_PLL) == ALT_E_TRUE)\r
4209         {\r
4210             temp = ALT_CLKMGR_PERPLL_VCO_PSRC_GET(alt_read_word(ALT_CLKMGR_PERPLL_VCO_ADDR));\r
4211             if (temp == ALT_CLKMGR_PERPLL_VCO_PSRC_E_EOSC1)\r
4212             {\r
4213                 temp = alt_ext_clk_paramblok.clkosc1.freqcur;\r
4214                 ret = ALT_E_SUCCESS;\r
4215             }\r
4216             else if (temp == ALT_CLKMGR_PERPLL_VCO_PSRC_E_EOSC2)\r
4217             {\r
4218                 temp = alt_ext_clk_paramblok.clkosc2.freqcur;\r
4219                 ret = ALT_E_SUCCESS;\r
4220             }\r
4221             else if (temp == ALT_CLKMGR_PERPLL_VCO_PSRC_E_F2S_PERIPH_REF)\r
4222             {\r
4223                 temp = alt_ext_clk_paramblok.periph.freqcur;\r
4224                 ret = ALT_E_SUCCESS;\r
4225             }\r
4226             else\r
4227             {\r
4228                 ret = ALT_E_ERROR;\r
4229             }\r
4230         }\r
4231         else\r
4232         {\r
4233             ret = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &temp);\r
4234         }\r
4235         numer = (uint64_t) temp;\r
4236         // denom = 1 by default\r
4237         break;\r
4238 \r
4239     case ALT_CLK_SDRAM_PLL:\r
4240         if (alt_clk_pll_is_bypassed(ALT_CLK_SDRAM_PLL) == ALT_E_TRUE)\r
4241         {\r
4242             temp = ALT_CLKMGR_SDRPLL_VCO_SSRC_GET(alt_read_word(ALT_CLKMGR_SDRPLL_VCO_ADDR));\r
4243             if (temp == ALT_CLKMGR_SDRPLL_VCO_SSRC_E_EOSC1)\r
4244             {\r
4245                 temp = alt_ext_clk_paramblok.clkosc1.freqcur;\r
4246                 ret = ALT_E_SUCCESS;\r
4247             }\r
4248             else if (temp == ALT_CLKMGR_SDRPLL_VCO_SSRC_E_EOSC2)\r
4249             {\r
4250                 temp = alt_ext_clk_paramblok.clkosc2.freqcur;\r
4251                 ret = ALT_E_SUCCESS;\r
4252             }\r
4253             else if (temp == ALT_CLKMGR_SDRPLL_VCO_SSRC_E_F2S_SDRAM_REF)\r
4254             {\r
4255                 temp = alt_ext_clk_paramblok.sdram.freqcur;\r
4256                 ret = ALT_E_SUCCESS;\r
4257             }\r
4258             else\r
4259             {\r
4260                 ret = ALT_E_ERROR;\r
4261             }\r
4262         }\r
4263         else\r
4264         {\r
4265             ret = alt_clk_pll_vco_freq_get(ALT_CLK_SDRAM_PLL, &temp);\r
4266         }\r
4267         numer = (uint64_t) temp;\r
4268         // denom = 1 by default\r
4269         break;\r
4270 \r
4271         /////\r
4272 \r
4273         // Main Clock Group\r
4274     case ALT_CLK_MAIN_PLL_C0:\r
4275     case ALT_CLK_MAIN_PLL_C1:\r
4276     case ALT_CLK_MAIN_PLL_C2:\r
4277     case ALT_CLK_MAIN_PLL_C3:\r
4278     case ALT_CLK_MAIN_PLL_C4:\r
4279     case ALT_CLK_MAIN_PLL_C5:\r
4280         ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4281         if (ret == ALT_E_SUCCESS)\r
4282         {\r
4283             numer = (uint64_t) temp;\r
4284             ret = alt_clk_divider_get(clk, &temp);\r
4285             denom = (uint64_t) temp;\r
4286         }\r
4287         break;\r
4288 \r
4289     case ALT_CLK_MPU:\r
4290         ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4291         if (ret == ALT_E_SUCCESS)\r
4292         {\r
4293             numer = (uint64_t) temp;\r
4294             ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C0, &temp);\r
4295             denom = (uint64_t) temp;\r
4296         }\r
4297         break;\r
4298 \r
4299     case ALT_CLK_MPU_PERIPH:\r
4300         ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4301         if (ret == ALT_E_SUCCESS)\r
4302         {\r
4303             numer = (uint64_t) temp;\r
4304             ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C0, &temp);\r
4305         }\r
4306         if (ret == ALT_E_SUCCESS)\r
4307         {\r
4308             denom = (uint64_t) temp;\r
4309             ret = alt_clk_divider_get(ALT_CLK_MPU_PERIPH, &temp);\r
4310             denom = denom * (uint64_t) temp;\r
4311         }\r
4312         break;\r
4313 \r
4314     case ALT_CLK_MPU_L2_RAM:\r
4315         ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4316         if (ret == ALT_E_SUCCESS)\r
4317         {\r
4318             numer = (uint64_t) temp;\r
4319             ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C0, &temp);\r
4320         }\r
4321         if (ret == ALT_E_SUCCESS)\r
4322         {\r
4323             denom = (uint64_t) temp;\r
4324             ret = alt_clk_divider_get(ALT_CLK_MPU_L2_RAM, &temp);\r
4325             denom = denom * (uint64_t) temp;\r
4326         }\r
4327         break;\r
4328 \r
4329     case ALT_CLK_L4_MAIN:\r
4330     case ALT_CLK_L3_MAIN:\r
4331         ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4332         if (ret == ALT_E_SUCCESS)\r
4333         {\r
4334             numer = (uint64_t) temp;\r
4335             ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C1, &temp);\r
4336             denom = (uint64_t) temp;\r
4337         }\r
4338         break;\r
4339 \r
4340     case ALT_CLK_L3_MP:\r
4341         ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4342         if (ret == ALT_E_SUCCESS)\r
4343         {\r
4344             numer = (uint64_t) temp;\r
4345             ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C1, &temp);\r
4346         }\r
4347         if (ret == ALT_E_SUCCESS)\r
4348         {\r
4349             denom = (uint64_t) temp;\r
4350             ret = alt_clk_divider_get(ALT_CLK_L3_MP, &temp);\r
4351             denom = denom * (uint64_t) temp;\r
4352         }\r
4353         break;\r
4354 \r
4355     case ALT_CLK_L3_SP:\r
4356         ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4357         if (ret == ALT_E_SUCCESS)\r
4358         {\r
4359             numer = (uint64_t) temp;\r
4360             ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C1, &temp);\r
4361         }\r
4362         if (ret == ALT_E_SUCCESS)\r
4363         {\r
4364             denom = (uint64_t) temp;\r
4365             ret = alt_clk_divider_get(ALT_CLK_L3_MP, &temp);\r
4366         }\r
4367         if (ret == ALT_E_SUCCESS)\r
4368         {\r
4369             denom = denom * (uint64_t) temp;\r
4370             ret = alt_clk_divider_get(ALT_CLK_L3_SP, &temp);\r
4371             denom = denom * (uint64_t) temp;\r
4372         }\r
4373         break;\r
4374 \r
4375     case ALT_CLK_L4_MP:\r
4376         ret = alt_clk_divider_get(ALT_CLK_L4_MP, &temp);\r
4377         if (ret == ALT_E_SUCCESS)\r
4378         {\r
4379             denom = (uint64_t) temp;\r
4380             temp = ALT_CLKMGR_MAINPLL_L4SRC_L4MP_GET(alt_read_word(ALT_CLKMGR_MAINPLL_L4SRC_ADDR));\r
4381             if (temp == ALT_CLKMGR_MAINPLL_L4SRC_L4MP_E_MAINPLL)\r
4382             {\r
4383                 ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4384                 if (ret == ALT_E_SUCCESS)\r
4385                 {\r
4386                     numer = (uint64_t) temp;\r
4387                     ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C1, &temp);\r
4388                     denom = denom * (uint64_t) temp;        // no real harm if temp is garbage data\r
4389                 }\r
4390             }\r
4391             else if (temp == ALT_CLKMGR_MAINPLL_L4SRC_L4MP_E_PERIPHPLL)\r
4392             {\r
4393                 ret = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &temp);\r
4394                 if (ret == ALT_E_SUCCESS)\r
4395                 {\r
4396                     numer = (uint64_t) temp;\r
4397                     ret = alt_clk_divider_get(ALT_CLK_PERIPHERAL_PLL_C4, &temp);\r
4398                     denom = denom * (uint64_t) temp;\r
4399                 }\r
4400             }\r
4401         }\r
4402         break;\r
4403 \r
4404     case ALT_CLK_L4_SP:\r
4405         ret = alt_clk_divider_get(ALT_CLK_L4_SP, &temp);\r
4406         if (ret == ALT_E_SUCCESS)\r
4407         {\r
4408             denom = (uint64_t) temp;\r
4409             temp = ALT_CLKMGR_MAINPLL_L4SRC_L4SP_GET(alt_read_word(ALT_CLKMGR_MAINPLL_L4SRC_ADDR));\r
4410             if (temp == ALT_CLKMGR_MAINPLL_L4SRC_L4SP_E_MAINPLL)\r
4411             {\r
4412                 ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4413                 if (ret == ALT_E_SUCCESS)\r
4414                 {\r
4415                     numer = (uint64_t) temp;\r
4416                     ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C1, &temp);\r
4417                     denom = denom * (uint64_t) temp;\r
4418                 }\r
4419             }\r
4420             else if (temp == ALT_CLKMGR_MAINPLL_L4SRC_L4SP_E_PERIPHPLL)         // periph_base_clk\r
4421             {\r
4422                 ret = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &temp);\r
4423                 if (ret == ALT_E_SUCCESS)\r
4424                 {\r
4425                     numer = (uint64_t) temp;\r
4426                     ret = alt_clk_divider_get(ALT_CLK_PERIPHERAL_PLL_C4, &temp);\r
4427                     denom = denom * (uint64_t) temp;\r
4428                 }\r
4429             }\r
4430         }\r
4431         break;\r
4432 \r
4433     case ALT_CLK_DBG_BASE:\r
4434     case ALT_CLK_DBG_TIMER:\r
4435         ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4436         if (ret == ALT_E_SUCCESS)\r
4437         {\r
4438             numer = (uint64_t) temp;\r
4439             ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C2, &temp);\r
4440             denom = (uint64_t) temp;\r
4441         }\r
4442         break;\r
4443 \r
4444     case ALT_CLK_DBG_AT:\r
4445         ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4446         if (ret == ALT_E_SUCCESS)\r
4447         {\r
4448             numer = (uint64_t) temp;\r
4449             ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C2, &temp);\r
4450         }\r
4451         if (ret == ALT_E_SUCCESS)\r
4452         {\r
4453             denom = (uint64_t) temp;\r
4454             ret = alt_clk_divider_get(ALT_CLK_DBG_AT, &temp);\r
4455             denom = denom * (uint64_t) temp;\r
4456         }\r
4457         break;\r
4458 \r
4459     case ALT_CLK_DBG:\r
4460         ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4461         if (ret == ALT_E_SUCCESS)\r
4462         {\r
4463             numer = (uint64_t) temp;\r
4464             ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C2, &temp);\r
4465         }\r
4466         if (ret == ALT_E_SUCCESS)\r
4467         {\r
4468             denom = (uint64_t) temp;\r
4469             ret = alt_clk_divider_get(ALT_CLK_DBG_AT, &temp);\r
4470         }\r
4471         if (ret == ALT_E_SUCCESS)\r
4472         {\r
4473             denom = denom * (uint64_t) temp;\r
4474             ret = alt_clk_divider_get(ALT_CLK_DBG, &temp);\r
4475             denom = denom * (uint64_t) temp;\r
4476         }\r
4477         break;\r
4478 \r
4479     case ALT_CLK_DBG_TRACE:\r
4480         ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4481         if (ret == ALT_E_SUCCESS)\r
4482         {\r
4483             numer = (uint64_t) temp;\r
4484             ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C2, &temp);\r
4485         }\r
4486         if (ret == ALT_E_SUCCESS)\r
4487         {\r
4488             denom = (uint64_t) temp;\r
4489             ret = alt_clk_divider_get(ALT_CLK_DBG_TRACE, &temp);\r
4490             denom = denom * (uint64_t) temp;\r
4491         }\r
4492         break;\r
4493 \r
4494     case ALT_CLK_MAIN_QSPI:\r
4495         ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4496         if (ret == ALT_E_SUCCESS)\r
4497         {\r
4498             numer = (uint64_t) temp;\r
4499             ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C3, &temp);\r
4500             denom = (uint64_t) temp;\r
4501         }\r
4502         break;\r
4503 \r
4504     case ALT_CLK_MAIN_NAND_SDMMC:\r
4505         ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4506         if (ret == ALT_E_SUCCESS)\r
4507         {\r
4508             numer = (uint64_t) temp;\r
4509             ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C4, &temp);\r
4510             denom = (uint64_t) temp;\r
4511         }\r
4512         break;\r
4513 \r
4514     case ALT_CLK_CFG:\r
4515     case ALT_CLK_H2F_USER0:\r
4516         ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4517         if (ret == ALT_E_SUCCESS)\r
4518         {\r
4519             numer = (uint64_t) temp;\r
4520             ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C5, &temp);\r
4521             denom = (uint64_t) temp;\r
4522         }\r
4523         break;\r
4524 \r
4525         /////\r
4526 \r
4527         // Peripheral Clock Group\r
4528     case ALT_CLK_PERIPHERAL_PLL_C0:\r
4529     case ALT_CLK_PERIPHERAL_PLL_C1:\r
4530     case ALT_CLK_PERIPHERAL_PLL_C2:\r
4531     case ALT_CLK_PERIPHERAL_PLL_C3:\r
4532     case ALT_CLK_PERIPHERAL_PLL_C4:\r
4533     case ALT_CLK_PERIPHERAL_PLL_C5:\r
4534         ret = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &temp);\r
4535         if (ret == ALT_E_SUCCESS)\r
4536         {\r
4537             numer = (uint64_t) temp;\r
4538             ret = alt_clk_divider_get(clk, &temp);\r
4539             denom = (uint64_t) temp;\r
4540         }\r
4541         break;\r
4542 \r
4543     case ALT_CLK_EMAC0:\r
4544         ret = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &temp);\r
4545         if (ret == ALT_E_SUCCESS)\r
4546         {\r
4547             numer = (uint64_t) temp;\r
4548             ret = alt_clk_divider_get(ALT_CLK_PERIPHERAL_PLL_C0, &temp);\r
4549             denom = (uint64_t) temp;\r
4550         }\r
4551         break;\r
4552 \r
4553     case ALT_CLK_EMAC1:\r
4554         ret = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &temp);\r
4555         if (ret == ALT_E_SUCCESS)\r
4556         {\r
4557             numer = (uint64_t) temp;\r
4558             ret = alt_clk_divider_get(ALT_CLK_PERIPHERAL_PLL_C1, &temp);\r
4559             denom = (uint64_t) temp;\r
4560         }\r
4561         break;\r
4562 \r
4563     case ALT_CLK_USB_MP:\r
4564         ret = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &temp);\r
4565         if (ret == ALT_E_SUCCESS)\r
4566         {\r
4567             numer = (uint64_t) temp;\r
4568             ret = alt_clk_divider_get(ALT_CLK_PERIPHERAL_PLL_C4, &temp);\r
4569             if (ret == ALT_E_SUCCESS)\r
4570             {\r
4571                 denom = (uint64_t) temp;\r
4572                 ret = alt_clk_divider_get(ALT_CLK_USB_MP, &temp);\r
4573                 denom = denom * (uint64_t) temp;\r
4574             }\r
4575         }\r
4576         break;\r
4577 \r
4578     case ALT_CLK_SPI_M:\r
4579         ret = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &temp);\r
4580         if (ret == ALT_E_SUCCESS)\r
4581         {\r
4582             numer = (uint64_t) temp;\r
4583             ret = alt_clk_divider_get(ALT_CLK_PERIPHERAL_PLL_C4, &temp);\r
4584         }\r
4585         if (ret == ALT_E_SUCCESS)\r
4586         {\r
4587             denom = (uint64_t) temp;\r
4588             ret = alt_clk_divider_get(ALT_CLK_SPI_M, &temp);\r
4589             denom = denom * (uint64_t) temp;\r
4590         }\r
4591         break;\r
4592 \r
4593     case ALT_CLK_CAN0:\r
4594         ret = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &temp);\r
4595         if (ret == ALT_E_SUCCESS)\r
4596         {\r
4597             numer = (uint64_t) temp;\r
4598             ret = alt_clk_divider_get(ALT_CLK_PERIPHERAL_PLL_C4, &temp);\r
4599         }\r
4600         if (ret == ALT_E_SUCCESS)\r
4601         {\r
4602             denom = (uint64_t) temp;\r
4603             ret = alt_clk_divider_get(ALT_CLK_CAN0, &temp);\r
4604             denom = denom * (uint64_t) temp;\r
4605         }\r
4606         break;\r
4607 \r
4608     case ALT_CLK_CAN1:\r
4609         ret = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &temp);\r
4610         if (ret == ALT_E_SUCCESS)\r
4611         {\r
4612             numer = (uint64_t) temp;\r
4613             ret = alt_clk_divider_get(ALT_CLK_PERIPHERAL_PLL_C4, &temp);\r
4614         }\r
4615         if (ret == ALT_E_SUCCESS)\r
4616         {\r
4617             denom = (uint64_t) temp;\r
4618             ret = alt_clk_divider_get(ALT_CLK_CAN1, &temp);\r
4619             denom = denom * (uint64_t) temp;\r
4620         }\r
4621         break;\r
4622 \r
4623     case ALT_CLK_GPIO_DB:\r
4624         ret = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &temp);\r
4625         if (ret == ALT_E_SUCCESS)\r
4626         {\r
4627             numer = (uint64_t) temp;\r
4628             ret = alt_clk_divider_get(ALT_CLK_PERIPHERAL_PLL_C4, &temp);\r
4629         }\r
4630         if (ret == ALT_E_SUCCESS)\r
4631         {\r
4632             denom = (uint64_t) temp;\r
4633             ret = alt_clk_divider_get(ALT_CLK_GPIO_DB, &temp);\r
4634             denom = denom * (uint64_t) temp;\r
4635         }\r
4636         break;\r
4637 \r
4638     case ALT_CLK_H2F_USER1:\r
4639         ret = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &temp);\r
4640         if (ret == ALT_E_SUCCESS)\r
4641         {\r
4642             numer = (uint64_t) temp;\r
4643             ret = alt_clk_divider_get(ALT_CLK_PERIPHERAL_PLL_C5, &temp);\r
4644             denom = (uint64_t) temp;\r
4645         }\r
4646         break;\r
4647 \r
4648         /* Clocks That Can Switch Between Different Clock Groups */\r
4649     case ALT_CLK_SDMMC:\r
4650         temp = ALT_CLKMGR_PERPLL_SRC_SDMMC_GET(alt_read_word(ALT_CLKMGR_PERPLL_SRC_ADDR));\r
4651         if (temp == ALT_CLKMGR_PERPLL_SRC_SDMMC_E_F2S_PERIPH_REF_CLK)\r
4652         {\r
4653             numer = (uint64_t) alt_ext_clk_paramblok.periph.freqcur;\r
4654             // denom = 1 by default\r
4655             ret = ALT_E_SUCCESS;\r
4656         }\r
4657         else if (temp == ALT_CLKMGR_PERPLL_SRC_SDMMC_E_MAIN_NAND_CLK)\r
4658         {\r
4659             ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4660             if (ret == ALT_E_SUCCESS)\r
4661             {\r
4662                 numer = (uint64_t) temp;\r
4663                 ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C4, &temp);\r
4664                 denom = (uint64_t) temp;\r
4665             }\r
4666         }\r
4667         else if (temp == ALT_CLKMGR_PERPLL_SRC_SDMMC_E_PERIPH_NAND_CLK)\r
4668         {\r
4669             ret = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &temp);\r
4670             if (ret == ALT_E_SUCCESS)\r
4671             {\r
4672                 numer = (uint64_t) temp;\r
4673                 ret = alt_clk_divider_get(ALT_CLK_PERIPHERAL_PLL_C3, &temp);\r
4674                 denom = (uint64_t) temp;\r
4675             }\r
4676         }\r
4677         else\r
4678         {\r
4679             ret = ALT_E_ERROR;\r
4680         }\r
4681         break;\r
4682 \r
4683     case ALT_CLK_NAND:\r
4684         denom = 4;\r
4685         // the absence of a break statement here is not a mistake\r
4686     case ALT_CLK_NAND_X:\r
4687         temp = ALT_CLKMGR_PERPLL_SRC_NAND_GET(alt_read_word(ALT_CLKMGR_PERPLL_SRC_ADDR));\r
4688         if (temp == ALT_CLKMGR_PERPLL_SRC_NAND_E_F2S_PERIPH_REF_CLK)\r
4689         {\r
4690             numer = (uint64_t) alt_ext_clk_paramblok.periph.freqcur;\r
4691             // denom = 1 or 4 by default;\r
4692             ret = ALT_E_SUCCESS;\r
4693         }\r
4694         else if (temp == ALT_CLKMGR_PERPLL_SRC_NAND_E_MAIN_NAND_CLK)\r
4695         {\r
4696             ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4697             if (ret == ALT_E_SUCCESS)\r
4698             {\r
4699                 numer = (uint64_t) temp;\r
4700                 ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C4, &temp);\r
4701                 denom = denom * (uint64_t) temp;\r
4702             }\r
4703         }\r
4704         else if (temp == ALT_CLKMGR_PERPLL_SRC_NAND_E_PERIPH_NAND_CLK)\r
4705         {\r
4706             ret = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &temp);\r
4707             if (ret == ALT_E_SUCCESS)\r
4708             {\r
4709                 numer = (uint64_t) temp;\r
4710                 ret = alt_clk_divider_get(ALT_CLK_PERIPHERAL_PLL_C3, &temp);\r
4711                 denom = denom * (uint64_t) temp;\r
4712             }\r
4713         }\r
4714         else\r
4715         {\r
4716             ret = ALT_E_ERROR;\r
4717         }\r
4718         break;\r
4719 \r
4720     case ALT_CLK_QSPI:\r
4721         temp = ALT_CLKMGR_PERPLL_SRC_QSPI_GET(alt_read_word(ALT_CLKMGR_PERPLL_SRC_ADDR));\r
4722         if (temp == ALT_CLKMGR_PERPLL_SRC_QSPI_E_F2S_PERIPH_REF_CLK)\r
4723         {\r
4724             numer = (uint64_t) alt_ext_clk_paramblok.periph.freqcur;\r
4725             // denom = 1 by default;\r
4726             ret = ALT_E_SUCCESS;\r
4727         }\r
4728         else if (temp == ALT_CLKMGR_PERPLL_SRC_QSPI_E_MAIN_QSPI_CLK)\r
4729         {\r
4730             ret = alt_clk_pll_vco_freq_get(ALT_CLK_MAIN_PLL, &temp);\r
4731             if (ret == ALT_E_SUCCESS)\r
4732             {\r
4733                 numer = (uint64_t) temp;\r
4734                 ret = alt_clk_divider_get(ALT_CLK_MAIN_PLL_C3, &temp);\r
4735                 denom = (uint64_t) temp;\r
4736             }\r
4737         }\r
4738         else if (temp == ALT_CLKMGR_PERPLL_SRC_QSPI_E_PERIPH_QSPI_CLK)\r
4739         {\r
4740             ret = alt_clk_pll_vco_freq_get(ALT_CLK_PERIPHERAL_PLL, &temp);\r
4741             if (ret == ALT_E_SUCCESS)\r
4742             {\r
4743                 numer = (uint64_t) temp;\r
4744                 ret = alt_clk_divider_get(ALT_CLK_PERIPHERAL_PLL_C2, &temp);\r
4745                 denom = (uint64_t) temp;\r
4746             }\r
4747         }\r
4748         else\r
4749         {\r
4750             ret = ALT_E_ERROR;\r
4751         }\r
4752         break;\r
4753 \r
4754         /////\r
4755 \r
4756         // SDRAM Clock Group\r
4757     case ALT_CLK_SDRAM_PLL_C0:\r
4758     case ALT_CLK_DDR_DQS:\r
4759         ret = alt_clk_pll_vco_freq_get(ALT_CLK_SDRAM_PLL, &temp);\r
4760         if (ret == ALT_E_SUCCESS)\r
4761         {\r
4762             numer = (uint64_t) temp;\r
4763             ret = alt_clk_divider_get(ALT_CLK_SDRAM_PLL_C0, &temp);\r
4764             denom = (uint64_t) temp;\r
4765         }\r
4766         break;\r
4767 \r
4768     case ALT_CLK_SDRAM_PLL_C1:\r
4769     case ALT_CLK_DDR_2X_DQS:\r
4770         ret = alt_clk_pll_vco_freq_get(ALT_CLK_SDRAM_PLL, &temp);\r
4771         if (ret == ALT_E_SUCCESS)\r
4772         {\r
4773             numer = (uint64_t) temp;\r
4774             ret = alt_clk_divider_get(ALT_CLK_SDRAM_PLL_C1, &temp);\r
4775             denom = (uint64_t) temp;\r
4776         }\r
4777         break;\r
4778 \r
4779     case ALT_CLK_SDRAM_PLL_C2:\r
4780     case ALT_CLK_DDR_DQ:\r
4781         ret = alt_clk_pll_vco_freq_get(ALT_CLK_SDRAM_PLL, &temp);\r
4782         if (ret == ALT_E_SUCCESS)\r
4783         {\r
4784             numer = (uint64_t) temp;\r
4785             ret = alt_clk_divider_get(ALT_CLK_SDRAM_PLL_C2, &temp);\r
4786             denom = (uint64_t) temp;\r
4787         }\r
4788         break;\r
4789 \r
4790     case ALT_CLK_SDRAM_PLL_C5:\r
4791     case ALT_CLK_H2F_USER2:\r
4792         ret = alt_clk_pll_vco_freq_get(ALT_CLK_SDRAM_PLL, &temp);\r
4793         if (ret == ALT_E_SUCCESS)\r
4794         {\r
4795             numer = (uint64_t) temp;\r
4796             ret = alt_clk_divider_get(ALT_CLK_SDRAM_PLL_C5, &temp);\r
4797             denom = (uint64_t) temp;\r
4798         }\r
4799         break;\r
4800 \r
4801     default:\r
4802         ret = ALT_E_BAD_ARG;\r
4803         break;\r
4804 \r
4805     }   // end of switch-case construct\r
4806 \r
4807     if (ret == ALT_E_SUCCESS)\r
4808     {\r
4809         // will not get here if none of above cases match\r
4810         if (denom > 0)\r
4811         {\r
4812             numer /= denom;\r
4813             if (numer <= UINT32_MAX)\r
4814             {\r
4815                 *freq = (uint32_t) numer;\r
4816             }\r
4817             else\r
4818             {\r
4819                 ret = ALT_E_ERROR;\r
4820             }\r
4821         }\r
4822         else\r
4823         {\r
4824             ret = ALT_E_ERROR;\r
4825         }\r
4826     }\r
4827 \r
4828     return ret;\r
4829 }\r
4830 \r
4831 //\r
4832 // alt_clk_irq_disable() disables one or more of the lock status conditions as\r
4833 // contributors to the clkmgr_IRQ interrupt signal state.\r
4834 //\r
4835 ALT_STATUS_CODE alt_clk_irq_disable(ALT_CLK_PLL_LOCK_STATUS_t lock_stat_mask)\r
4836 {\r
4837     if (!(lock_stat_mask & ALT_CLK_MGR_PLL_LOCK_BITS))\r
4838     {\r
4839         alt_clrbits_word(ALT_CLKMGR_INTREN_ADDR, lock_stat_mask);\r
4840         return ALT_E_SUCCESS;\r
4841     }\r
4842     else\r
4843     {\r
4844         return ALT_E_BAD_ARG;\r
4845     }\r
4846 }\r
4847 \r
4848 //\r
4849 // alt_clk_irq_enable() enables one or more of the lock status conditions as\r
4850 // contributors to the clkmgr_IRQ interrupt signal state.\r
4851 //\r
4852 ALT_STATUS_CODE alt_clk_irq_enable(ALT_CLK_PLL_LOCK_STATUS_t lock_stat_mask)\r
4853 {\r
4854     if (!(lock_stat_mask & ALT_CLK_MGR_PLL_LOCK_BITS))\r
4855     {\r
4856         alt_setbits_word(ALT_CLKMGR_INTREN_ADDR, lock_stat_mask);\r
4857         return ALT_E_SUCCESS;\r
4858     }\r
4859     else\r
4860     {\r
4861         return ALT_E_BAD_ARG;\r
4862     }\r
4863 }\r
4864 \r
4865 /////\r
4866 \r
4867 //\r
4868 // alt_clk_group_cfg_raw_get() gets the raw configuration state of the designated\r
4869 // clock group.\r
4870 //\r
4871 ALT_STATUS_CODE alt_clk_group_cfg_raw_get(ALT_CLK_GRP_t clk_group,\r
4872                                           ALT_CLK_GROUP_RAW_CFG_t * clk_group_raw_cfg)\r
4873 {\r
4874     clk_group_raw_cfg->verid     = alt_read_word(ALT_SYSMGR_SILICONID1_ADDR);\r
4875     clk_group_raw_cfg->siliid2   = alt_read_word(ALT_SYSMGR_SILICONID2_ADDR);\r
4876     clk_group_raw_cfg->clkgrpsel = clk_group;\r
4877 \r
4878     if (clk_group == ALT_MAIN_PLL_CLK_GRP)\r
4879     {\r
4880         // Main PLL VCO register\r
4881         clk_group_raw_cfg->clkgrp.mainpllgrp.raw.vco = alt_read_word(ALT_CLKMGR_MAINPLL_VCO_ADDR);\r
4882 \r
4883         // Main PLL Misc register\r
4884         clk_group_raw_cfg->clkgrp.mainpllgrp.raw.misc = alt_read_word(ALT_CLKMGR_MAINPLL_MISC_ADDR);\r
4885 \r
4886         // Main PLL C0-C5 Counter registers\r
4887         clk_group_raw_cfg->clkgrp.mainpllgrp.raw.mpuclk = alt_read_word(ALT_CLKMGR_MAINPLL_MPUCLK_ADDR);\r
4888         // doing these as 32-bit reads and writes avoids unnecessary masking operations\r
4889 \r
4890         clk_group_raw_cfg->clkgrp.mainpllgrp.raw.mainclk          = alt_read_word(ALT_CLKMGR_MAINPLL_MAINCLK_ADDR);\r
4891         clk_group_raw_cfg->clkgrp.mainpllgrp.raw.dbgatclk         = alt_read_word(ALT_CLKMGR_MAINPLL_DBGATCLK_ADDR);\r
4892         clk_group_raw_cfg->clkgrp.mainpllgrp.raw.mainqspiclk      = alt_read_word(ALT_CLKMGR_MAINPLL_MAINQSPICLK_ADDR);\r
4893         clk_group_raw_cfg->clkgrp.mainpllgrp.raw.mainnandsdmmcclk = alt_read_word(ALT_CLKMGR_MAINPLL_MAINNANDSDMMCCLK_ADDR);\r
4894         clk_group_raw_cfg->clkgrp.mainpllgrp.raw.cfgs2fuser0clk   = alt_read_word(ALT_CLKMGR_MAINPLL_CFGS2FUSER0CLK_ADDR);\r
4895 \r
4896         // Main PLL Enable register\r
4897         clk_group_raw_cfg->clkgrp.mainpllgrp.raw.en = alt_read_word(ALT_CLKMGR_MAINPLL_EN_ADDR);\r
4898 \r
4899         // Main PLL Maindiv register\r
4900         clk_group_raw_cfg->clkgrp.mainpllgrp.raw.maindiv = alt_read_word(ALT_CLKMGR_MAINPLL_MAINDIV_ADDR);\r
4901 \r
4902         // Main PLL Debugdiv register\r
4903         clk_group_raw_cfg->clkgrp.mainpllgrp.raw.dbgdiv = alt_read_word(ALT_CLKMGR_MAINPLL_DBGDIV_ADDR);\r
4904 \r
4905         // Main PLL Tracediv register\r
4906         clk_group_raw_cfg->clkgrp.mainpllgrp.raw.tracediv = alt_read_word(ALT_CLKMGR_MAINPLL_TRACEDIV_ADDR);\r
4907 \r
4908         // Main PLL L4 Source register\r
4909         clk_group_raw_cfg->clkgrp.mainpllgrp.raw.l4src = alt_read_word(ALT_CLKMGR_MAINPLL_L4SRC_ADDR);\r
4910 \r
4911         // Main PLL Status register\r
4912         clk_group_raw_cfg->clkgrp.mainpllgrp.raw.stat = alt_read_word(ALT_CLKMGR_MAINPLL_STAT_ADDR);\r
4913         // clkgrp.mainpllgrp.stat.outresetack is defined in the ALT_CLKMGR_MAINPLL_STAT_s declaration\r
4914         // as a const but alt_indwrite_word() overrides that restriction.\r
4915 \r
4916         // padding ...\r
4917         clk_group_raw_cfg->clkgrp.mainpllgrp.raw._pad_0x38_0x40[0] = 0;\r
4918         clk_group_raw_cfg->clkgrp.mainpllgrp.raw._pad_0x38_0x40[1] = 0;\r
4919 \r
4920         return ALT_E_SUCCESS;\r
4921     }\r
4922     else if (clk_group == ALT_PERIPH_PLL_CLK_GRP)\r
4923     {\r
4924         // Peripheral PLL VCO register\r
4925         clk_group_raw_cfg->clkgrp.perpllgrp.raw.vco = alt_read_word(ALT_CLKMGR_PERPLL_VCO_ADDR);\r
4926 \r
4927         // Peripheral PLL Misc register\r
4928         clk_group_raw_cfg->clkgrp.perpllgrp.raw.misc = alt_read_word(ALT_CLKMGR_PERPLL_MISC_ADDR);\r
4929 \r
4930         // Peripheral PLL C0-C5 Counters\r
4931         clk_group_raw_cfg->clkgrp.perpllgrp.raw.emac0clk = alt_read_word(ALT_CLKMGR_PERPLL_EMAC0CLK_ADDR);\r
4932         // doing these as 32-bit reads and writes avoids unnecessary masking operations\r
4933 \r
4934         clk_group_raw_cfg->clkgrp.perpllgrp.raw.emac1clk        = alt_read_word(ALT_CLKMGR_PERPLL_EMAC1CLK_ADDR);\r
4935         clk_group_raw_cfg->clkgrp.perpllgrp.raw.perqspiclk      = alt_read_word(ALT_CLKMGR_PERPLL_PERQSPICLK_ADDR);\r
4936         clk_group_raw_cfg->clkgrp.perpllgrp.raw.pernandsdmmcclk = alt_read_word(ALT_CLKMGR_PERPLL_PERNANDSDMMCCLK_ADDR);\r
4937         clk_group_raw_cfg->clkgrp.perpllgrp.raw.perbaseclk      = alt_read_word(ALT_CLKMGR_PERPLL_PERBASECLK_ADDR);\r
4938         clk_group_raw_cfg->clkgrp.perpllgrp.raw.s2fuser1clk     = alt_read_word(ALT_CLKMGR_PERPLL_S2FUSER1CLK_ADDR);\r
4939 \r
4940         // Peripheral PLL Enable register\r
4941         clk_group_raw_cfg->clkgrp.perpllgrp.raw.en = alt_read_word(ALT_CLKMGR_PERPLL_EN_ADDR);\r
4942 \r
4943         // Peripheral PLL Divider register\r
4944         clk_group_raw_cfg->clkgrp.perpllgrp.raw.div = alt_read_word(ALT_CLKMGR_PERPLL_DIV_ADDR);\r
4945 \r
4946         // Peripheral PLL GPIO Divider register\r
4947         clk_group_raw_cfg->clkgrp.perpllgrp.raw.gpiodiv = alt_read_word(ALT_CLKMGR_PERPLL_GPIODIV_ADDR);\r
4948 \r
4949         // Peripheral PLL Source register\r
4950         clk_group_raw_cfg->clkgrp.perpllgrp.raw.src = alt_read_word(ALT_CLKMGR_PERPLL_SRC_ADDR);\r
4951 \r
4952         // Peripheral PLL Status register\r
4953         clk_group_raw_cfg->clkgrp.perpllgrp.raw.stat = alt_read_word(ALT_CLKMGR_PERPLL_STAT_ADDR);\r
4954 \r
4955         // padding ...\r
4956         clk_group_raw_cfg->clkgrp.perpllgrp.raw._pad_0x34_0x40[0] = 0;\r
4957         clk_group_raw_cfg->clkgrp.perpllgrp.raw._pad_0x34_0x40[1] = 0;\r
4958         clk_group_raw_cfg->clkgrp.perpllgrp.raw._pad_0x34_0x40[2] = 0;\r
4959 \r
4960         return ALT_E_SUCCESS;\r
4961     }\r
4962     else if (clk_group == ALT_SDRAM_PLL_CLK_GRP)\r
4963     {\r
4964         // SDRAM PLL VCO register\r
4965         clk_group_raw_cfg->clkgrp.sdrpllgrp.raw.vco = alt_read_word(ALT_CLKMGR_SDRPLL_VCO_ADDR);\r
4966 \r
4967         // SDRAM PLL Control register\r
4968         clk_group_raw_cfg->clkgrp.sdrpllgrp.raw.ctrl = alt_read_word(ALT_CLKMGR_SDRPLL_CTL_ADDR);\r
4969 \r
4970         // SDRAM PLL C0-C2 & C5 Counters\r
4971         clk_group_raw_cfg->clkgrp.sdrpllgrp.raw.ddrdqsclk = alt_read_word(ALT_CLKMGR_SDRPLL_DDRDQSCLK_ADDR);\r
4972         // doing these as 32-bit reads and writes avoids unnecessary masking operations\r
4973 \r
4974         clk_group_raw_cfg->clkgrp.sdrpllgrp.raw.ddr2xdqsclk = alt_read_word(ALT_CLKMGR_SDRPLL_DDR2XDQSCLK_ADDR);\r
4975         clk_group_raw_cfg->clkgrp.sdrpllgrp.raw.ddrdqclk    = alt_read_word(ALT_CLKMGR_SDRPLL_DDRDQCLK_ADDR);\r
4976         clk_group_raw_cfg->clkgrp.sdrpllgrp.raw.s2fuser2clk = alt_read_word(ALT_CLKMGR_SDRPLL_S2FUSER2CLK_ADDR);\r
4977 \r
4978         // SDRAM PLL Enable register\r
4979         clk_group_raw_cfg->clkgrp.sdrpllgrp.raw.en = alt_read_word(ALT_CLKMGR_SDRPLL_EN_ADDR);\r
4980 \r
4981         // SDRAM PLL Status register\r
4982         clk_group_raw_cfg->clkgrp.sdrpllgrp.raw.stat = alt_read_word(ALT_CLKMGR_SDRPLL_STAT_ADDR);\r
4983 \r
4984         return ALT_E_SUCCESS;\r
4985     }\r
4986     else\r
4987     {\r
4988         return ALT_E_BAD_ARG;\r
4989     }\r
4990 }\r
4991 \r
4992 //\r
4993 // alt_clk_group_cfg_raw_set() sets the clock group configuration.\r
4994 //\r
4995 ALT_STATUS_CODE alt_clk_group_cfg_raw_set(const ALT_CLK_GROUP_RAW_CFG_t * clk_group_raw_cfg)\r
4996 {\r
4997     // test for matching silicon ID, but not for matching silicon revision number\r
4998     if (ALT_SYSMGR_SILICONID1_ID_GET(alt_read_word(ALT_SYSMGR_SILICONID1_ADDR)) !=\r
4999         ALT_SYSMGR_SILICONID1_ID_GET(clk_group_raw_cfg->verid))\r
5000     {\r
5001         return ALT_E_BAD_VERSION;\r
5002     }\r
5003 \r
5004     // get the PLL ID\r
5005     ALT_CLK_GRP_t clk_group = clk_group_raw_cfg->clkgrpsel;\r
5006     ALT_CLK_t     pll;\r
5007 \r
5008     if      (clk_group == ALT_MAIN_PLL_CLK_GRP)   { pll = ALT_CLK_MAIN_PLL; }\r
5009     else if (clk_group == ALT_PERIPH_PLL_CLK_GRP) { pll = ALT_CLK_PERIPHERAL_PLL; }\r
5010     else if (clk_group == ALT_SDRAM_PLL_CLK_GRP)  { pll = ALT_CLK_SDRAM_PLL; }\r
5011     else\r
5012     {\r
5013         return ALT_E_ERROR;\r
5014     }\r
5015 \r
5016     ALT_STATUS_CODE status = ALT_E_SUCCESS;\r
5017 \r
5018     // if the PLL isn't in bypass mode, put it in bypass mode\r
5019     bool byp = false;\r
5020     if (alt_clk_pll_is_bypassed(pll) == ALT_E_FALSE)\r
5021     {\r
5022         status = alt_clk_pll_bypass_enable(pll, false);\r
5023         if (status != ALT_E_SUCCESS)\r
5024         {\r
5025             return status;\r
5026         }\r
5027 \r
5028         byp = true;\r
5029     }\r
5030 \r
5031     // now write the values in the ALT_CLK_GROUP_RAW_CFG_t structure to the registers\r
5032     if (clk_group == ALT_MAIN_PLL_CLK_GRP)\r
5033     {\r
5034         // Main PLL VCO register\r
5035         alt_write_word(ALT_CLKMGR_MAINPLL_VCO_ADDR, clk_group_raw_cfg->clkgrp.mainpllgrp.raw.vco &\r
5036                        ALT_CLKMGR_MAINPLL_VCO_OUTRSTALL_CLR_MSK & ALT_CLKMGR_MAINPLL_VCO_OUTRST_CLR_MSK);\r
5037         // the outreset and outresetall bits were probably clear when the\r
5038         // state was saved, but make sure they're clear now\r
5039 \r
5040         // Main PLL Misc register\r
5041         alt_write_word(ALT_CLKMGR_MAINPLL_MISC_ADDR, clk_group_raw_cfg->clkgrp.mainpllgrp.raw.misc);\r
5042 \r
5043         // Main PLL C0-C5 Counter registers\r
5044         alt_write_word(ALT_CLKMGR_MAINPLL_MPUCLK_ADDR,           clk_group_raw_cfg->clkgrp.mainpllgrp.raw.mpuclk);\r
5045         alt_write_word(ALT_CLKMGR_MAINPLL_MAINCLK_ADDR,          clk_group_raw_cfg->clkgrp.mainpllgrp.raw.mainclk);\r
5046         alt_write_word(ALT_CLKMGR_MAINPLL_DBGATCLK_ADDR,         clk_group_raw_cfg->clkgrp.mainpllgrp.raw.dbgatclk);\r
5047         alt_write_word(ALT_CLKMGR_MAINPLL_MAINQSPICLK_ADDR,      clk_group_raw_cfg->clkgrp.mainpllgrp.raw.mainqspiclk);\r
5048         alt_write_word(ALT_CLKMGR_MAINPLL_MAINNANDSDMMCCLK_ADDR, clk_group_raw_cfg->clkgrp.mainpllgrp.raw.mainnandsdmmcclk);\r
5049         alt_write_word(ALT_CLKMGR_MAINPLL_CFGS2FUSER0CLK_ADDR,   clk_group_raw_cfg->clkgrp.mainpllgrp.raw.cfgs2fuser0clk);\r
5050 \r
5051         // Main PLL Counter Enable register\r
5052         alt_write_word(ALT_CLKMGR_MAINPLL_EN_ADDR, clk_group_raw_cfg->clkgrp.mainpllgrp.raw.en);\r
5053 \r
5054         // Main PLL Maindiv register\r
5055         alt_write_word(ALT_CLKMGR_MAINPLL_MAINDIV_ADDR, clk_group_raw_cfg->clkgrp.mainpllgrp.raw.maindiv);\r
5056 \r
5057         // Main PLL Debugdiv register\r
5058         alt_write_word(ALT_CLKMGR_MAINPLL_DBGDIV_ADDR, clk_group_raw_cfg->clkgrp.mainpllgrp.raw.dbgdiv);\r
5059 \r
5060         // Main PLL Tracediv register\r
5061         alt_write_word(ALT_CLKMGR_MAINPLL_TRACEDIV_ADDR, clk_group_raw_cfg->clkgrp.mainpllgrp.raw.tracediv);\r
5062 \r
5063         // Main PLL L4 Source register\r
5064         alt_write_word(ALT_CLKMGR_MAINPLL_L4SRC_ADDR, clk_group_raw_cfg->clkgrp.mainpllgrp.raw.l4src);\r
5065     }\r
5066     else if (clk_group == ALT_PERIPH_PLL_CLK_GRP)\r
5067     {\r
5068         // Peripheral PLL VCO register\r
5069         alt_write_word(ALT_CLKMGR_PERPLL_VCO_ADDR, clk_group_raw_cfg->clkgrp.perpllgrp.raw.vco &\r
5070                        ALT_CLKMGR_PERPLL_VCO_OUTRST_CLR_MSK & ALT_CLKMGR_PERPLL_VCO_OUTRSTALL_CLR_MSK);\r
5071         // the outreset and outresetall bits were probably clear when the\r
5072         // state was saved, but make sure they're clear now\r
5073 \r
5074         // Peripheral PLL Misc register\r
5075         alt_write_word(ALT_CLKMGR_PERPLL_MISC_ADDR, clk_group_raw_cfg->clkgrp.perpllgrp.raw.misc);\r
5076 \r
5077         // Peripheral PLL C0-C5 Counters\r
5078         alt_write_word(ALT_CLKMGR_PERPLL_EMAC0CLK_ADDR,        clk_group_raw_cfg->clkgrp.perpllgrp.raw.emac0clk);\r
5079         alt_write_word(ALT_CLKMGR_PERPLL_EMAC1CLK_ADDR,        clk_group_raw_cfg->clkgrp.perpllgrp.raw.emac1clk);\r
5080         alt_write_word(ALT_CLKMGR_PERPLL_PERQSPICLK_ADDR,      clk_group_raw_cfg->clkgrp.perpllgrp.raw.perqspiclk);\r
5081         alt_write_word(ALT_CLKMGR_PERPLL_PERNANDSDMMCCLK_ADDR, clk_group_raw_cfg->clkgrp.perpllgrp.raw.pernandsdmmcclk);\r
5082         alt_write_word(ALT_CLKMGR_PERPLL_PERBASECLK_ADDR,      clk_group_raw_cfg->clkgrp.perpllgrp.raw.perbaseclk);\r
5083         alt_write_word(ALT_CLKMGR_PERPLL_S2FUSER1CLK_ADDR,     clk_group_raw_cfg->clkgrp.perpllgrp.raw.s2fuser1clk);\r
5084 \r
5085         // Peripheral PLL Counter Enable register\r
5086         alt_write_word(ALT_CLKMGR_PERPLL_EN_ADDR, clk_group_raw_cfg->clkgrp.perpllgrp.raw.en);\r
5087 \r
5088         // Peripheral PLL Divider register\r
5089         alt_write_word(ALT_CLKMGR_PERPLL_DIV_ADDR, clk_group_raw_cfg->clkgrp.perpllgrp.raw.div);\r
5090 \r
5091         // Peripheral PLL GPIO Divider register\r
5092         alt_write_word(ALT_CLKMGR_PERPLL_GPIODIV_ADDR, clk_group_raw_cfg->clkgrp.perpllgrp.raw.gpiodiv);\r
5093 \r
5094         // Peripheral PLL Source register\r
5095         alt_write_word(ALT_CLKMGR_PERPLL_SRC_ADDR, clk_group_raw_cfg->clkgrp.perpllgrp.raw.src);\r
5096     }\r
5097     else if (clk_group == ALT_SDRAM_PLL_CLK_GRP)\r
5098     {\r
5099         // SDRAM PLL VCO register\r
5100         alt_write_word(ALT_CLKMGR_SDRPLL_VCO_ADDR, clk_group_raw_cfg->clkgrp.sdrpllgrp.raw.vco &\r
5101                        ALT_CLKMGR_SDRPLL_VCO_OUTRST_CLR_MSK & ALT_CLKMGR_SDRPLL_VCO_OUTRSTALL_CLR_MSK);\r
5102         // the outreset and outresetall bits were probably clear when the\r
5103         // state was saved, but make sure they're clear now\r
5104 \r
5105         // SDRAM PLL Control register\r
5106         alt_write_word(ALT_CLKMGR_SDRPLL_CTL_ADDR, clk_group_raw_cfg->clkgrp.sdrpllgrp.raw.ctrl);\r
5107 \r
5108         // SDRAM PLL C0-C2 & C5 Counters\r
5109         alt_write_word(ALT_CLKMGR_SDRPLL_DDRDQSCLK_ADDR,   clk_group_raw_cfg->clkgrp.sdrpllgrp.raw.ddrdqsclk);\r
5110         alt_write_word(ALT_CLKMGR_SDRPLL_DDR2XDQSCLK_ADDR, clk_group_raw_cfg->clkgrp.sdrpllgrp.raw.ddr2xdqsclk);\r
5111         alt_write_word(ALT_CLKMGR_SDRPLL_DDRDQCLK_ADDR,    clk_group_raw_cfg->clkgrp.sdrpllgrp.raw.ddrdqclk);\r
5112         alt_write_word(ALT_CLKMGR_SDRPLL_S2FUSER2CLK_ADDR, clk_group_raw_cfg->clkgrp.sdrpllgrp.raw.s2fuser2clk);\r
5113 \r
5114         // SDRAM PLL Counter Enable register\r
5115         alt_write_word(ALT_CLKMGR_SDRPLL_EN_ADDR, clk_group_raw_cfg->clkgrp.sdrpllgrp.raw.en);\r
5116     }\r
5117 \r
5118     // if PLL was not bypassed before, restore that state\r
5119     if (byp)\r
5120     {\r
5121         status = alt_clk_pll_bypass_disable(pll);\r
5122     }\r
5123 \r
5124     return status;\r
5125 }\r
5126 \r
5127 //\r
5128 // alt_clk_id_to_string() converts a clock ID to a text string.\r
5129 //\r
5130 ALT_STATUS_CODE alt_clk_id_to_string(ALT_CLK_t clk_id, char * output, size_t size)\r
5131 {\r
5132     char * name = NULL;\r
5133 \r
5134     switch (clk_id)\r
5135     {\r
5136     case ALT_CLK_IN_PIN_OSC1:\r
5137         name =  "IN_PIN_OSC1";\r
5138         break;\r
5139     case ALT_CLK_IN_PIN_OSC2:\r
5140         name =  "IN_PIN_OSC2";\r
5141         break;\r
5142 \r
5143         // FPGA Clock Sources External to HPS\r
5144     case ALT_CLK_F2H_PERIPH_REF:\r
5145         name =  "F2H_PERIPH_REF";\r
5146         break;\r
5147     case ALT_CLK_F2H_SDRAM_REF:\r
5148         name =  "F2H_SDRAM_REF";\r
5149         break;\r
5150 \r
5151         // Other Clock Sources External to HPS\r
5152     case ALT_CLK_IN_PIN_JTAG:\r
5153         name =  "IN_PIN_JTAG";\r
5154         break;\r
5155     case ALT_CLK_IN_PIN_ULPI0:\r
5156         name =  "IN_PIN_ULPI0";\r
5157         break;\r
5158     case ALT_CLK_IN_PIN_ULPI1:\r
5159         name =  "IN_PIN_ULPI1";\r
5160         break;\r
5161     case ALT_CLK_IN_PIN_EMAC0_RX:\r
5162         name =  "IN_PIN_EMAC0_RX";\r
5163         break;\r
5164     case ALT_CLK_IN_PIN_EMAC1_RX:\r
5165         name =  "IN_PIN_EMAC1_RX";\r
5166         break;\r
5167 \r
5168         // PLLs\r
5169     case ALT_CLK_MAIN_PLL:\r
5170         name =  "MAIN_PLL";\r
5171         break;\r
5172     case ALT_CLK_PERIPHERAL_PLL:\r
5173         name =  "PERIPHERAL_PLL";\r
5174         break;\r
5175     case ALT_CLK_SDRAM_PLL:\r
5176         name =  "SDRAM_PLL";\r
5177         break;\r
5178 \r
5179         // OSC1 Clock Group - The OSC1 clock group contains those clocks which are derived\r
5180         // directly from the osc_clk_1_HPS pin\r
5181     case ALT_CLK_OSC1:\r
5182         name =  "OSC1";\r
5183         break;\r
5184 \r
5185         // Main Clock Group - The following clocks are derived from the Main PLL.\r
5186     case ALT_CLK_MAIN_PLL_C0:\r
5187         name =  "MAIN_PLL_C0";\r
5188         break;\r
5189     case ALT_CLK_MAIN_PLL_C1:\r
5190         name =  "MAIN_PLL_C1";\r
5191         break;\r
5192     case ALT_CLK_MAIN_PLL_C2:\r
5193         name =  "MAIN_PLL_C2";\r
5194         break;\r
5195     case ALT_CLK_MAIN_PLL_C3:\r
5196         name =  "MAIN_PLL_C3";\r
5197         break;\r
5198     case ALT_CLK_MAIN_PLL_C4:\r
5199         name =  "MAIN_PLL_C4";\r
5200         break;\r
5201     case ALT_CLK_MAIN_PLL_C5:\r
5202         name =  "MAIN_PLL_C5";\r
5203         break;\r
5204     case ALT_CLK_MPU:\r
5205         name =  "MPU";\r
5206         break;\r
5207     case ALT_CLK_MPU_L2_RAM:\r
5208         name =  "MPU_L2_RAM";\r
5209         break;\r
5210     case ALT_CLK_MPU_PERIPH:\r
5211         name =  "MPU_PERIPH";\r
5212         break;\r
5213     case ALT_CLK_L3_MAIN:\r
5214         name =  "L3_MAIN";\r
5215         break;\r
5216     case ALT_CLK_L3_MP:\r
5217         name =  "L3_MP";\r
5218         break;\r
5219     case ALT_CLK_L3_SP:\r
5220         name =  "L3_SP";\r
5221         break;\r
5222     case ALT_CLK_L4_MAIN:\r
5223         name =  "L4_MAIN";\r
5224         break;\r
5225     case ALT_CLK_L4_MP:\r
5226         name =  "L4_MP";\r
5227         break;\r
5228     case ALT_CLK_L4_SP:\r
5229         name =  "L4_SP";\r
5230         break;\r
5231     case ALT_CLK_DBG_BASE:\r
5232         name =  "DBG_BASE";\r
5233         break;\r
5234     case ALT_CLK_DBG_AT:\r
5235         name =  "DBG_AT";\r
5236         break;\r
5237     case ALT_CLK_DBG_TRACE:\r
5238         name =  "DBG_TRACE";\r
5239         break;\r
5240     case ALT_CLK_DBG_TIMER:\r
5241         name =  "DBG_TIMER";\r
5242         break;\r
5243     case ALT_CLK_DBG:\r
5244         name =  "DBG";\r
5245         break;\r
5246     case ALT_CLK_MAIN_QSPI:\r
5247         name =  "MAIN_QSPI";\r
5248         break;\r
5249     case ALT_CLK_MAIN_NAND_SDMMC:\r
5250         name =  "MAIN_NAND_SDMMC";\r
5251         break;\r
5252     case ALT_CLK_CFG:\r
5253         name =  "CFG";\r
5254         break;\r
5255     case ALT_CLK_H2F_USER0:\r
5256         name =  "H2F_USER0";\r
5257         break;\r
5258 \r
5259         // Peripherals Clock Group - The following clocks are derived from the Peripheral PLL.\r
5260     case ALT_CLK_PERIPHERAL_PLL_C0:\r
5261         name =  "PERIPHERAL_PLL_C0";\r
5262         break;\r
5263     case ALT_CLK_PERIPHERAL_PLL_C1:\r
5264         name =  "PERIPHERAL_PLL_C1";\r
5265         break;\r
5266     case ALT_CLK_PERIPHERAL_PLL_C2:\r
5267         name =  "PERIPHERAL_PLL_C2";\r
5268         break;\r
5269     case ALT_CLK_PERIPHERAL_PLL_C3:\r
5270         name =  "PERIPHERAL_PLL_C3";\r
5271         break;\r
5272     case ALT_CLK_PERIPHERAL_PLL_C4:\r
5273         name =  "PERIPHERAL_PLL_C4";\r
5274         break;\r
5275     case ALT_CLK_PERIPHERAL_PLL_C5:\r
5276         name =  "PERIPHERAL_PLL_C5";\r
5277         break;\r
5278     case ALT_CLK_USB_MP:\r
5279         name =  "USB_MP";\r
5280         break;\r
5281     case ALT_CLK_SPI_M:\r
5282         name =  "SPI_M";\r
5283         break;\r
5284     case ALT_CLK_QSPI:\r
5285         name =  "QSPI";\r
5286         break;\r
5287     case ALT_CLK_NAND_X:\r
5288         name =  "NAND_X";\r
5289         break;\r
5290     case ALT_CLK_NAND:\r
5291         name =  "NAND";\r
5292         break;\r
5293     case ALT_CLK_SDMMC:\r
5294         name =  "SDMMC";\r
5295         break;\r
5296     case ALT_CLK_EMAC0:\r
5297         name =  "EMAC0";\r
5298         break;\r
5299     case ALT_CLK_EMAC1:\r
5300         name =  "EMAC1";\r
5301         break;\r
5302     case ALT_CLK_CAN0:\r
5303         name =  "CAN0";\r
5304         break;\r
5305     case ALT_CLK_CAN1:\r
5306         name =  "CAN1";\r
5307         break;\r
5308     case ALT_CLK_GPIO_DB:\r
5309         name =  "GPIO_DB";\r
5310         break;\r
5311     case ALT_CLK_H2F_USER1:\r
5312         name =  "H2F_USER1";\r
5313         break;\r
5314 \r
5315         // SDRAM Clock Group - The following clocks are derived from the SDRAM PLL.\r
5316     case ALT_CLK_SDRAM_PLL_C0:\r
5317         name =  "SDRAM_PLL_C0";\r
5318         break;\r
5319     case ALT_CLK_SDRAM_PLL_C1:\r
5320         name =  "SDRAM_PLL_C1";\r
5321         break;\r
5322     case ALT_CLK_SDRAM_PLL_C2:\r
5323         name =  "SDRAM_PLL_C2";\r
5324         break;\r
5325     case ALT_CLK_SDRAM_PLL_C3:\r
5326         name =  "SDRAM_PLL_C3";\r
5327         break;\r
5328     case ALT_CLK_SDRAM_PLL_C4:\r
5329         name =  "SDRAM_PLL_C4";\r
5330         break;\r
5331     case ALT_CLK_SDRAM_PLL_C5:\r
5332         name =  "SDRAM_PLL_C5";\r
5333         break;\r
5334     case ALT_CLK_DDR_DQS:\r
5335         name =  "DDR_DQS";\r
5336         break;\r
5337     case ALT_CLK_DDR_2X_DQS:\r
5338         name =  "DDR_2X_DQS";\r
5339         break;\r
5340     case ALT_CLK_DDR_DQ:\r
5341         name =  "DDR_DQ";\r
5342         break;\r
5343     case ALT_CLK_H2F_USER2:\r
5344         name =  "H2F_USER2";\r
5345         break;\r
5346 \r
5347         // Clock Output Pins\r
5348     case ALT_CLK_OUT_PIN_EMAC0_TX:\r
5349         name =  "OUT_PIN_EMAC0_TX";\r
5350         break;\r
5351     case ALT_CLK_OUT_PIN_EMAC1_TX:\r
5352         name =  "OUT_PIN_EMAC1_TX";\r
5353         break;\r
5354     case ALT_CLK_OUT_PIN_SDMMC:\r
5355         name =  "OUT_PIN_SDMMC";\r
5356         break;\r
5357     case ALT_CLK_OUT_PIN_I2C0_SCL:\r
5358         name =  "OUT_PIN_I2C0_SCL";\r
5359         break;\r
5360     case ALT_CLK_OUT_PIN_I2C1_SCL:\r
5361         name =  "OUT_PIN_I2C1_SCL";\r
5362         break;\r
5363     case ALT_CLK_OUT_PIN_I2C2_SCL:\r
5364         name =  "OUT_PIN_I2C2_SCL";\r
5365         break;\r
5366     case ALT_CLK_OUT_PIN_I2C3_SCL:\r
5367         name =  "OUT_PIN_I2C3_SCL";\r
5368         break;\r
5369     case ALT_CLK_OUT_PIN_SPIM0:\r
5370         name =  "OUT_PIN_SPIM0";\r
5371         break;\r
5372     case ALT_CLK_OUT_PIN_SPIM1:\r
5373         name =  "OUT_PIN_SPIM1";\r
5374         break;\r
5375     case ALT_CLK_OUT_PIN_QSPI:\r
5376         name =  "OUT_PIN_QSPI";\r
5377         break;\r
5378     case ALT_CLK_UNKNOWN:\r
5379         name =  "UNKNOWN";\r
5380         break;\r
5381 \r
5382         // do *not* put a 'default' statement here. Then the compiler will throw\r
5383         // an error if another clock id enum is added if the corresponding\r
5384         // string is not added to this function.\r
5385     }\r
5386 \r
5387     if (name != NULL)\r
5388     {\r
5389         snprintf(output, size, "ALT_CLK_%s", name);\r
5390         return ALT_E_SUCCESS;\r
5391     }\r
5392     else\r
5393     {\r
5394         return ALT_E_BAD_ARG;\r
5395     }\r
5396 }\r
5397 \r
5398 \r
5399 //\r
5400 // alt_clk_pll_cntr_maxfreq_recalc() recalculate the maxmum frequency of the specified clock.\r
5401 //\r
5402 ALT_STATUS_CODE alt_clk_pll_cntr_maxfreq_recalc(ALT_CLK_t clk, ALT_PLL_CNTR_FREQMAX_t * maxfreq)\r
5403 {\r
5404     ALT_STATUS_CODE ret = ALT_E_BAD_ARG;\r
5405         alt_freq_t freq;\r
5406 \r
5407         ret = alt_clk_freq_get(clk, &freq);\r
5408 \r
5409         if (ret == ALT_E_SUCCESS)\r
5410     {\r
5411 \r
5412         switch (clk)\r
5413         {\r
5414             // Main Clock Group\r
5415         case ALT_CLK_MAIN_PLL_C0:\r
5416             maxfreq->MainPLL_C0 = freq;\r
5417                         printf("alt_pll_cntr_maxfreq.MainPLL_C0   = %10d\n", (unsigned int)freq);\r
5418             break;\r
5419         case ALT_CLK_MAIN_PLL_C1:\r
5420             maxfreq->MainPLL_C1 = freq;\r
5421                         printf("alt_pll_cntr_maxfreq.MainPLL_C1   = %10d\n", (unsigned int)freq);\r
5422             break;\r
5423         case ALT_CLK_MAIN_PLL_C2:\r
5424             maxfreq->MainPLL_C2 = freq;\r
5425                         printf("alt_pll_cntr_maxfreq.MainPLL_C2   = %10d\n", (unsigned int)freq);\r
5426             break;\r
5427         case ALT_CLK_MAIN_PLL_C3:\r
5428             maxfreq->MainPLL_C3 = freq;\r
5429                         printf("alt_pll_cntr_maxfreq.MainPLL_C3   = %10d\n", (unsigned int)freq);\r
5430             break;\r
5431         case ALT_CLK_MAIN_PLL_C4:\r
5432             maxfreq->MainPLL_C4 = freq;\r
5433                         printf("alt_pll_cntr_maxfreq.MainPLL_C4   = %10d\n", (unsigned int)freq);\r
5434             break;\r
5435         case ALT_CLK_MAIN_PLL_C5:\r
5436             maxfreq->MainPLL_C5 = freq;\r
5437                         printf("alt_pll_cntr_maxfreq.MainPLL_C5   = %10d\n", (unsigned int)freq);\r
5438             break;\r
5439 \r
5440             // Peripheral Clock Group\r
5441         case ALT_CLK_PERIPHERAL_PLL_C0:\r
5442             maxfreq->PeriphPLL_C0 = freq;\r
5443                         printf("alt_pll_cntr_maxfreq.PeriphPLL_C0 = %10d\n", (unsigned int)freq);\r
5444             break;\r
5445         case ALT_CLK_PERIPHERAL_PLL_C1:\r
5446             maxfreq->PeriphPLL_C1 = freq;\r
5447                         printf("alt_pll_cntr_maxfreq.PeriphPLL_C1 = %10d\n", (unsigned int)freq);\r
5448             break;\r
5449         case ALT_CLK_PERIPHERAL_PLL_C2:\r
5450             maxfreq->PeriphPLL_C2 = freq;\r
5451                         printf("alt_pll_cntr_maxfreq.PeriphPLL_C2 = %10d\n", (unsigned int)freq);\r
5452             break;\r
5453         case ALT_CLK_PERIPHERAL_PLL_C3:\r
5454             maxfreq->PeriphPLL_C3 = freq;\r
5455                         printf("alt_pll_cntr_maxfreq.PeriphPLL_C3 = %10d\n", (unsigned int)freq);\r
5456             break;\r
5457         case ALT_CLK_PERIPHERAL_PLL_C4:\r
5458             maxfreq->PeriphPLL_C4 = freq;\r
5459                         printf("alt_pll_cntr_maxfreq.PeriphPLL_C4 = %10d\n", (unsigned int)freq);\r
5460             break;\r
5461         case ALT_CLK_PERIPHERAL_PLL_C5:\r
5462             maxfreq->PeriphPLL_C5 = freq;\r
5463                         printf("alt_pll_cntr_maxfreq.PeriphPLL_C5 = %10d\n", (unsigned int)freq);\r
5464             break;\r
5465 \r
5466             // SDRAM Clock Group\r
5467         case ALT_CLK_SDRAM_PLL_C0:\r
5468             maxfreq->SDRAMPLL_C0 = freq;\r
5469                         printf("alt_pll_cntr_maxfreq.SDRAMPLL_C0  = %10d\n", (unsigned int)freq);\r
5470             break;\r
5471         case ALT_CLK_SDRAM_PLL_C1:\r
5472             maxfreq->SDRAMPLL_C1 = freq;\r
5473                         printf("alt_pll_cntr_maxfreq.SDRAMPLL_C1  = %10d\n", (unsigned int)freq);\r
5474             break;\r
5475         case ALT_CLK_SDRAM_PLL_C2:\r
5476             maxfreq->SDRAMPLL_C2 = freq;\r
5477                         printf("alt_pll_cntr_maxfreq.SDRAMPLL_C2  = %10d\n", (unsigned int)freq);\r
5478             break;\r
5479         case ALT_CLK_SDRAM_PLL_C5:\r
5480             maxfreq->SDRAMPLL_C5 = freq;\r
5481                         printf("alt_pll_cntr_maxfreq.SDRAMPLL_C5  = %10d\n", (unsigned int)freq);\r
5482             break;\r
5483         default:\r
5484             ret = ALT_E_BAD_ARG;\r
5485                         printf("bad max frequency parameter\n");\r
5486             break;\r
5487         }   // end of switch-case construct\r
5488     }\r
5489 \r
5490     return ret;\r
5491 }\r
5492 \r
5493 //\r
5494 //  u-boot preloader actually initialize clock manager circuitry\r
5495 //\r
5496 //  alt_clk_clkmgr_init() attempt to fix the pll counter max frequencies, since\r
5497 //  thses frequencies are not known in advance until u-boot programmed clock manager.\r
5498 //\r
5499 ALT_STATUS_CODE alt_clk_clkmgr_init(void)\r
5500 {\r
5501     ALT_STATUS_CODE ret = ALT_E_SUCCESS;\r
5502     ALT_STATUS_CODE status ;\r
5503 \r
5504         status = alt_clk_pll_cntr_maxfreq_recalc(ALT_CLK_MAIN_PLL_C0,&alt_pll_cntr_maxfreq );\r
5505         if (status != ALT_E_SUCCESS) ret = ALT_E_ERROR;\r
5506 \r
5507         status = alt_clk_pll_cntr_maxfreq_recalc(ALT_CLK_MAIN_PLL_C1,&alt_pll_cntr_maxfreq );\r
5508         if (status != ALT_E_SUCCESS) ret = ALT_E_ERROR;\r
5509 \r
5510         status = alt_clk_pll_cntr_maxfreq_recalc(ALT_CLK_MAIN_PLL_C2,&alt_pll_cntr_maxfreq );\r
5511         if (status != ALT_E_SUCCESS) ret = ALT_E_ERROR;\r
5512 \r
5513         status = alt_clk_pll_cntr_maxfreq_recalc(ALT_CLK_MAIN_PLL_C3,&alt_pll_cntr_maxfreq );\r
5514         if (status != ALT_E_SUCCESS) ret = ALT_E_ERROR;\r
5515 \r
5516         status = alt_clk_pll_cntr_maxfreq_recalc(ALT_CLK_MAIN_PLL_C4,&alt_pll_cntr_maxfreq );\r
5517         if (status != ALT_E_SUCCESS) ret = ALT_E_ERROR;\r
5518 \r
5519         status = alt_clk_pll_cntr_maxfreq_recalc(ALT_CLK_MAIN_PLL_C5,&alt_pll_cntr_maxfreq );\r
5520         if (status != ALT_E_SUCCESS) ret = ALT_E_ERROR;\r
5521 \r
5522         status = alt_clk_pll_cntr_maxfreq_recalc(ALT_CLK_PERIPHERAL_PLL_C0,&alt_pll_cntr_maxfreq );\r
5523         if (status != ALT_E_SUCCESS) ret = ALT_E_ERROR;\r
5524 \r
5525         status = alt_clk_pll_cntr_maxfreq_recalc(ALT_CLK_PERIPHERAL_PLL_C1,&alt_pll_cntr_maxfreq );\r
5526         if (status != ALT_E_SUCCESS) ret = ALT_E_ERROR;\r
5527 \r
5528         status = alt_clk_pll_cntr_maxfreq_recalc(ALT_CLK_PERIPHERAL_PLL_C2,&alt_pll_cntr_maxfreq );\r
5529         if (status != ALT_E_SUCCESS) ret = ALT_E_ERROR;\r
5530 \r
5531         status = alt_clk_pll_cntr_maxfreq_recalc(ALT_CLK_PERIPHERAL_PLL_C3,&alt_pll_cntr_maxfreq );\r
5532         if (status != ALT_E_SUCCESS) ret = ALT_E_ERROR;\r
5533 \r
5534         status = alt_clk_pll_cntr_maxfreq_recalc(ALT_CLK_PERIPHERAL_PLL_C4,&alt_pll_cntr_maxfreq );\r
5535         if (status != ALT_E_SUCCESS) ret = ALT_E_ERROR;\r
5536 \r
5537         status = alt_clk_pll_cntr_maxfreq_recalc(ALT_CLK_PERIPHERAL_PLL_C5,&alt_pll_cntr_maxfreq );\r
5538         if (status != ALT_E_SUCCESS) ret = ALT_E_ERROR;\r
5539 \r
5540 \r
5541         status = alt_clk_pll_cntr_maxfreq_recalc(ALT_CLK_SDRAM_PLL_C0,&alt_pll_cntr_maxfreq );\r
5542         if (status != ALT_E_SUCCESS) ret = ALT_E_ERROR;\r
5543 \r
5544         status = alt_clk_pll_cntr_maxfreq_recalc(ALT_CLK_SDRAM_PLL_C1,&alt_pll_cntr_maxfreq );\r
5545         if (status != ALT_E_SUCCESS) ret = ALT_E_ERROR;\r
5546 \r
5547         status = alt_clk_pll_cntr_maxfreq_recalc(ALT_CLK_SDRAM_PLL_C2,&alt_pll_cntr_maxfreq );\r
5548         if (status != ALT_E_SUCCESS) ret = ALT_E_ERROR;\r
5549 \r
5550         status = alt_clk_pll_cntr_maxfreq_recalc(ALT_CLK_SDRAM_PLL_C5,&alt_pll_cntr_maxfreq );\r
5551         if (status != ALT_E_SUCCESS) ret = ALT_E_ERROR;\r
5552 \r
5553 \r
5554         return ret;\r
5555 }\r
5556 \r