git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M4F_CEC1302_Keil_GCC/peripheral_library/pcr/pcr_perphl.c

   1 /*****************************************************************************\r
   2 * © 2015 Microchip Technology Inc. and its subsidiaries.\r
   3 * You may use this software and any derivatives exclusively with\r
   4 * Microchip products.\r
   5 * THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS".\r
   6 * NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE,\r
   7 * INCLUDING ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY,\r
   8 * AND FITNESS FOR A PARTICULAR PURPOSE, OR ITS INTERACTION WITH MICROCHIP\r
   9 * PRODUCTS, COMBINATION WITH ANY OTHER PRODUCTS, OR USE IN ANY APPLICATION.\r
  10 * IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE,\r
  11 * INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND\r
  12 * WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS\r
  13 * BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE.\r
  14 * TO THE FULLEST EXTENT ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL\r
  15 * CLAIMS IN ANY WAY RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT OF\r
  16 * FEES, IF ANY, THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.\r
  17 * MICROCHIP PROVIDES THIS SOFTWARE CONDITIONALLY UPON YOUR ACCEPTANCE\r
  18 * OF THESE TERMS.\r
  19 ******************************************************************************\r
  20 \r
  21 Version Control Information (Perforce)\r
  22 ******************************************************************************\r
  23 $Revision: #1 $ \r
  24 $DateTime: 2015/11/24 06:28:28 $ \r
  25 $Author: amohandas $\r
  26 Last Change:    Updated for tabs\r
  27 ******************************************************************************/\r
  28 /** @file pcr_perphl.c\r
  29 * \brief Power, Clocks, and Resets Peripheral Source file\r
  30 * \author jvasanth\r
  31 * \r
  32 * This file implements the PCR Peripheral functions  \r
  33 ******************************************************************************/\r
  34 \r
  35 /** @defgroup PCR\r
  36  *  @{\r
  37  */\r
  38 \r
  39 #include "common_lib.h"\r
  40 #include "pcr.h"\r
  41 \r
  42 /* ---------------------------------------------------------------------- */\r
  43 /* Generic functions to program and read 32-bit values from PCR Registers */\r
  44 /* ---------------------------------------------------------------------- */\r
  45 /** Writes 32-bit value in the PCR Register\r
  46  * @param pcr_reg_id - pcr register id \r
  47  * @param value - 32-bit value\r
  48  */\r
  49 void p_pcr_reg_write(uint8_t pcr_reg_id, uint32_t value)\r
  50 {\r
  51     __IO uint32_t *pPCR_Reg;\r
  52 \r
  53     pPCR_Reg = (uint32_t *)(PCR_BASE);          \r
  54 \r
  55     pPCR_Reg += pcr_reg_id;\r
  56 \r
  57     *pPCR_Reg = value;                  \r
  58 }\r
  59 \r
  60 /** Reads 32-bit value from the PCR Register\r
  61  * @param pcr_reg_id - pcr register id \r
  62  * @return value - 32-bit value\r
  63  */\r
  64 uint32_t p_pcr_reg_read(uint8_t pcr_reg_id)\r
  65 {\r
  66     __IO uint32_t *pPCR_Reg;\r
  67     uint32_t retVal;\r
  68 \r
  69     pPCR_Reg = (uint32_t *)(PCR_BASE);          \r
  70 \r
  71     pPCR_Reg += pcr_reg_id;     \r
  72 \r
  73     retVal = *pPCR_Reg;\r
  74 \r
  75     return retVal;\r
  76 }\r
  77 \r
  78 /* ---------------------------------------------------------------------- */\r
  79 /*          Functions to set, clr and get bits in PCR Registers           */\r
  80 /* ---------------------------------------------------------------------- */\r
  81 \r
  82 /** Sets bits in a PCR Register\r
  83  * @param pcr_reg_id - pcr register id \r
  84  * @param bit_mask - Bit mask of bits to set \r
  85  */\r
  86 void p_pcr_reg_set(uint8_t pcr_reg_id, uint32_t bit_mask)\r
  87 {\r
  88     __IO uint32_t *pPCR_Reg;\r
  89 \r
  90     pPCR_Reg = (uint32_t *)(PCR_BASE);          \r
  91 \r
  92     pPCR_Reg += pcr_reg_id;\r
  93 \r
  94     *pPCR_Reg |= bit_mask;                      \r
  95 }\r
  96 \r
  97 /** Clears bits in a PCR Register\r
  98  * @param pcr_reg_id - pcr register id \r
  99  * @param bit_mask - Bit mask of bits to clear \r
 100  */\r
 101 void p_pcr_reg_clr(uint8_t pcr_reg_id, uint32_t bit_mask)\r
 102 {\r
 103     __IO uint32_t *pPCR_Reg;\r
 104 \r
 105     pPCR_Reg = (uint32_t *)(PCR_BASE);          \r
 106 \r
 107     pPCR_Reg += pcr_reg_id;\r
 108 \r
 109     *pPCR_Reg &= ~bit_mask;                     \r
 110 }\r
 111 \r
 112 /** Read bits in a PCR Register\r
 113  * @param pcr_reg_id - pcr register id \r
 114  * @param bit_mask - Bit mask of bits to read \r
 115  * @return value - 32-bit value\r
 116  */\r
 117 uint32_t p_pcr_reg_get(uint8_t pcr_reg_id, uint32_t bit_mask)\r
 118 {\r
 119     __IO uint32_t *pPCR_Reg;\r
 120     uint32_t retVal;\r
 121 \r
 122     pPCR_Reg = (uint32_t *)(PCR_BASE);          \r
 123 \r
 124     pPCR_Reg += pcr_reg_id;             \r
 125 \r
 126     retVal = (*pPCR_Reg) & bit_mask;\r
 127 \r
 128     return retVal;\r
 129 }\r
 130 \r
 131 /** Sets or Clears bits in a PCR Register - Helper Function\r
 132  * @param pcr_reg_id - pcr register id \r
 133  * @param bit_mask - Bit mask of bits to set or clear\r
 134  * @param set_clr_flag - Flag to set (1) or clear (0) bits in the PCR Register\r
 135  */\r
 136 void p_pcr_reg_update(uint8_t pcr_reg_id, uint32_t bit_mask, uint8_t set_clr_flag)\r
 137 {\r
 138     if (set_clr_flag)\r
 139     {\r
 140             p_pcr_reg_set(pcr_reg_id, bit_mask);\r
 141     }\r
 142     else\r
 143     {\r
 144             p_pcr_reg_clr(pcr_reg_id, bit_mask);\r
 145     }        \r
 146 }\r
 147 \r
 148 /* ---------------------------------------------------------------------- */\r
 149 /*          Functions to operate on System Sleep Control Register         */\r
 150 /* ---------------------------------------------------------------------- */\r
 151 \r
 152 /**\r
 153  * Sets/Clears the Ring oscillator power down bit \r
 154  *         in System Sleep Control Register\r
 155  * @param set_clr_flag - 1 - Sets the bit, 0 - clears the bit\r
 156  */\r
 157 void p_pcr_system_sleep_ctrl_ring_osc_power_down(uint8_t set_clr_flag)\r
 158 {\r
 159         __IO uint32_t *pPCR_Reg;                \r
 160                 \r
 161     pPCR_Reg = (uint32_t *)(PCR_BASE)   + PCR_REG_SYSTEM_SLEEP_CTRL;\r
 162 \r
 163     if (set_clr_flag)\r
 164     {\r
 165             *pPCR_Reg |= PCR_SYS_SLP_CTRL_RING_OSC_PWR_DOWN_BITMASK;                    \r
 166     }\r
 167     else\r
 168     {\r
 169         *pPCR_Reg &= ~PCR_SYS_SLP_CTRL_RING_OSC_PWR_DOWN_BITMASK;                       \r
 170     }\r
 171 }\r
 172 \r
 173 /** Sets/Clears the Ring oscillator output gate bit \r
 174  *         in System Sleep Control Register\r
 175  * @param set_clr_flag - 1 - Sets the bit, 0 - clears the bit\r
 176  */\r
 177 void p_pcr_system_sleep_ctrl_ring_osc_output_gate(uint8_t set_clr_flag)\r
 178 {\r
 179         __IO uint32_t *pPCR_Reg;                \r
 180                 \r
 181     pPCR_Reg = (uint32_t *)(PCR_BASE)   + PCR_REG_SYSTEM_SLEEP_CTRL;\r
 182 \r
 183     if (set_clr_flag)\r
 184     {\r
 185             *pPCR_Reg |= PCR_SYS_SLP_CTRL_RING_OSC_OUTPUT_GATE_BITMASK;                 \r
 186     }\r
 187     else\r
 188     {\r
 189         *pPCR_Reg &= ~PCR_SYS_SLP_CTRL_RING_OSC_OUTPUT_GATE_BITMASK;                    \r
 190     }\r
 191 }\r
 192 \r
 193 /** Sets/Clears the Core regulator standby bit \r
 194  *         in System Sleep Control Register\r
 195  * @param set_clr_flag - 1 - Sets the bit, 0 - clears the bit\r
 196  */\r
 197 void p_pcr_system_sleep_ctrl_core_regulator_stdby(uint8_t set_clr_flag)\r
 198 {\r
 199         __IO uint32_t *pPCR_Reg;                \r
 200                 \r
 201     pPCR_Reg = (uint32_t *)(PCR_BASE)   + PCR_REG_SYSTEM_SLEEP_CTRL;\r
 202 \r
 203     if (set_clr_flag)\r
 204     {\r
 205             *pPCR_Reg |= PCR_SYS_SLP_CTRL_CORE_REGLTOR_STDBY_BITMASK;                   \r
 206     }\r
 207     else\r
 208     {\r
 209         *pPCR_Reg &= ~PCR_SYS_SLP_CTRL_CORE_REGLTOR_STDBY_BITMASK;                      \r
 210     }\r
 211 }\r
 212 \r
 213 /** Writes required sleep mode in System Sleep Control Register\r
 214  * @param sleep_value - System Sleep control value - [D2, D1, D0]\r
 215  */\r
 216 void p_pcr_system_sleep_ctrl_write(uint8_t sleep_value)\r
 217 {\r
 218     __IO uint32_t *pPCR_Reg;            \r
 219     \r
 220     pPCR_Reg = (uint32_t *)(PCR_BASE)   + PCR_REG_SYSTEM_SLEEP_CTRL;    \r
 221 \r
 222     *pPCR_Reg = (sleep_value & 0x7);            \r
 223 }\r
 224 \r
 225 /** Reads the System Sleep Control PCR Register\r
 226  * @return value - byte 0 of the system sleep control PCR register\r
 227  */\r
 228 uint8_t p_pcr_system_sleep_ctrl_read(void)\r
 229 {\r
 230     __IO uint32_t *pPCR_Reg;\r
 231     uint8_t retVal;\r
 232     \r
 233     pPCR_Reg = (uint32_t *)(PCR_BASE)   + PCR_REG_SYSTEM_SLEEP_CTRL;            \r
 234 \r
 235     retVal = (uint8_t)((*pPCR_Reg) & 0xFF);\r
 236 \r
 237     return retVal;\r
 238 }\r
 239 \r
 240 \r
 241 \r
 242 /* ---------------------------------------------------------------------- */\r
 243 /*          Function to program to CLK Divide Value                       */\r
 244 /* ---------------------------------------------------------------------- */\r
 245 \r
 246 /** Writes the clock divide value in the Processor Clock Control Register\r
 247  * @param clk_divide_value - clk divide values, valid values in enum PROCESSOR_CLK_DIVIDE_VALUE\r
 248  */\r
 249 void p_pcr_processor_clk_ctrl_write(uint8_t clk_divide_value)\r
 250 {\r
 251     __IO uint32_t *pPCR_Reg;            \r
 252 \r
 253     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PROCESSOR_CLK_CTRL;             \r
 254 \r
 255     *pPCR_Reg = (clk_divide_value & 0xFF);      \r
 256         \r
 257 }\r
 258 \r
 259 /* ---------------------------------------------------------------------- */\r
 260 /*          Function to program the slow clock divide value           */\r
 261 /* ---------------------------------------------------------------------- */\r
 262 \r
 263 /** Write the slow clock divide value in the Slow Clock Control Register\r
 264  * @param slow_clk_divide_value - slow clk divide value\r
 265  */\r
 266 void p_pcr_slow_clk_ctrl_write(uint8_t slow_clk_divide_value)\r
 267 {\r
 268     __IO uint32_t *pPCR_Reg;            \r
 269 \r
 270     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_SLOW_CLK_CTRL;          \r
 271 \r
 272     *pPCR_Reg = (slow_clk_divide_value & 0x3FF);        \r
 273 \r
 274 }\r
 275 \r
 276 /* ---------------------------------------------------------------------- */\r
 277 /*          Function to read the Oscillator Lock Status                   */\r
 278 /* ---------------------------------------------------------------------- */\r
 279 \r
 280 /** Reads the Oscillator Lock status bit in the Oscillator ID Register\r
 281  * @return 1 if Oscillator Lock Status bit is set, else 0\r
 282  */\r
 283 uint8_t p_pcr_oscillator_lock_sts_get(void)\r
 284 {\r
 285     __IO uint32_t *pPCR_Reg;\r
 286     uint8_t retVal;\r
 287 \r
 288     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_OSCILLATOR_ID;  \r
 289 \r
 290     retVal = 0;\r
 291     if (*pPCR_Reg & PCR_OSCILLATOR_LOCK_STATUS_BITMASK)\r
 292     {\r
 293             retVal = 1;\r
 294     }\r
 295     \r
 296     return retVal;\r
 297         \r
 298 }\r
 299 \r
 300 /* ---------------------------------------------------------------------- */\r
 301 /*  Functions to read various power status in Chip Sub-System register    */\r
 302 /* ---------------------------------------------------------------------- */\r
 303 \r
 304 /** Reads the VCC Reset Status bit \r
 305  *        in the Chip Subsystem Power Reset Status Register\r
 306  * @return 1 if VCC Reset Status bit is set, else 0\r
 307  */\r
 308 uint8_t p_pcr_chip_subsystem_vcc_reset_sts_get(void)\r
 309 {\r
 310     __IO uint32_t *pPCR_Reg;\r
 311     uint8_t retVal;\r
 312 \r
 313     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_CHIP_SUBSYSTEM_PWR_RESET_STS;   \r
 314 \r
 315     retVal = 0;\r
 316     if (*pPCR_Reg & PCR_CHIP_SUBSYSTEM_VCC_RESET_STS_BITMASK)\r
 317     {\r
 318             retVal = 1;\r
 319     }\r
 320     \r
 321     return retVal;      \r
 322 }\r
 323 \r
 324 /** Reads the SIO Reset Status bit \r
 325  *        in the Chip Subsystem Power Reset Status Register\r
 326  * @return 1 if SIO Reset Status bit is set, else 0\r
 327  */\r
 328 uint8_t p_pcr_chip_subsystem_sio_reset_sts_get(void)\r
 329 {\r
 330     __IO uint32_t *pPCR_Reg;\r
 331     uint8_t retVal;\r
 332 \r
 333     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_CHIP_SUBSYSTEM_PWR_RESET_STS;   \r
 334 \r
 335     retVal = 0;\r
 336     if (*pPCR_Reg & PCR_CHIP_SUBSYSTEM_SIO_RESET_STS_BITMASK)\r
 337     {\r
 338             retVal = 1;\r
 339     }\r
 340     \r
 341     return retVal;      \r
 342 }\r
 343 \r
 344 /** Reads the VBAT Reset Status bit \r
 345  *        in the Chip Subsystem Power Reset Status Register\r
 346  * @return 1 if VBAT Reset Status bit is set, else 0\r
 347  */\r
 348 uint8_t p_pcr_chip_subsystem_vbat_reset_sts_get(void)\r
 349 {\r
 350     __IO uint32_t *pPCR_Reg;\r
 351     uint8_t retVal;\r
 352 \r
 353     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_CHIP_SUBSYSTEM_PWR_RESET_STS;   \r
 354 \r
 355     retVal = 0;\r
 356     if (*pPCR_Reg & PCR_CHIP_SUBSYSTEM_VBAT_RESET_STS_BITMASK)\r
 357     {\r
 358             retVal = 1;\r
 359     }\r
 360     \r
 361     return retVal;      \r
 362 }\r
 363 \r
 364 /** Clears the VBAT Reset Status bit \r
 365  *        in the Chip Subsystem Power Reset Status Register \r
 366  */\r
 367 void p_pcr_chip_subsystem_vbat_reset_sts_clr(void)\r
 368 {\r
 369     __IO uint32_t *pPCR_Reg;            \r
 370 \r
 371     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_CHIP_SUBSYSTEM_PWR_RESET_STS;\r
 372 \r
 373     // Write to clear\r
 374     *pPCR_Reg = PCR_CHIP_SUBSYSTEM_VBAT_RESET_STS_BITMASK;\r
 375         \r
 376 }\r
 377 \r
 378 /** Reads the VCC1 Reset Status bit \r
 379  *        in the Chip Subsystem Power Reset Status Register\r
 380  * @return 1 if VCC1 Reset Status bit is set, else 0\r
 381  */\r
 382 uint8_t p_pcr_chip_subsystem_vcc1_reset_sts_get(void)\r
 383 {\r
 384     __IO uint32_t *pPCR_Reg;\r
 385     uint8_t retVal;\r
 386 \r
 387     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_CHIP_SUBSYSTEM_PWR_RESET_STS;   \r
 388 \r
 389     retVal = 0;\r
 390     if (*pPCR_Reg & PCR_CHIP_SUBSYSTEM_VCC1_RESET_STS_BITMASK)\r
 391     {\r
 392             retVal = 1;\r
 393     }\r
 394     \r
 395     return retVal;      \r
 396 }\r
 397 \r
 398 /** Clears the VCC1 Reset Status bit \r
 399  *        in the Chip Subsystem Power Reset Status Register \r
 400  */\r
 401 void p_pcr_chip_subsystem_vcc1_reset_sts_clr(void)\r
 402 {\r
 403     __IO uint32_t *pPCR_Reg;            \r
 404 \r
 405     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_CHIP_SUBSYSTEM_PWR_RESET_STS;\r
 406 \r
 407     // Write to clear\r
 408     *pPCR_Reg = PCR_CHIP_SUBSYSTEM_VCC1_RESET_STS_BITMASK;\r
 409         \r
 410 }\r
 411 \r
 412 /** Reads the 32K_ACTIVE status bit \r
 413  *        in the Chip Subsystem Power Reset Status Register\r
 414  * @return 1 if 32_ACTIVE bit is set, else 0\r
 415  */\r
 416 uint8_t p_pcr_chip_subsystem_32K_active_sts_get(void)\r
 417 {\r
 418     __IO uint32_t *pPCR_Reg;\r
 419     uint8_t retVal;\r
 420 \r
 421     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_CHIP_SUBSYSTEM_PWR_RESET_STS;   \r
 422 \r
 423     retVal = 0;\r
 424     if (*pPCR_Reg & PCR_CHIP_SUBSYSTEM_32K_ACTIVE_STS_BITMASK)\r
 425     {\r
 426             retVal = 1;\r
 427     }\r
 428     \r
 429     return retVal;      \r
 430 }\r
 431 \r
 432 /** Reads the PCICLK_ACTIVE status bit \r
 433  *        in the Chip Subsystem Power Reset Status Register\r
 434  * @return 1 if CICLK_ACTIVE bit is set, else 0\r
 435  */\r
 436 uint8_t p_pcr_chip_subsystem_pciclk_active_sts_get(void)\r
 437 {\r
 438     __IO uint32_t *pPCR_Reg;\r
 439     uint8_t retVal;\r
 440 \r
 441     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_CHIP_SUBSYSTEM_PWR_RESET_STS;   \r
 442 \r
 443     retVal = 0;\r
 444     if (*pPCR_Reg & PCR_CHIP_SUBSYSTEM_PCICLK_ACTIVE_STS_BITMASK)\r
 445     {\r
 446             retVal = 1;\r
 447     }           \r
 448     return retVal;      \r
 449 }\r
 450 \r
 451 /* ---------------------------------------------------------------------- */\r
 452 /*           Functions for Power Reset Control Register                   */\r
 453 /* ---------------------------------------------------------------------- */\r
 454 \r
 455 /** Reads the iRESET_OUT bit in the Power Reset Control Register\r
 456  * @return 1 if iRESET_OUT bit is set, else 0\r
 457  */\r
 458 uint8_t p_pcr_iReset_Out_get(void)\r
 459 {\r
 460     __IO uint32_t *pPCR_Reg;\r
 461     uint8_t retVal;\r
 462 \r
 463     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PWR_RESET_CTRL; \r
 464 \r
 465     retVal = 0;\r
 466     if (*pPCR_Reg & PCR_iRESET_OUT_BITMASK)\r
 467     {\r
 468             retVal = 1;\r
 469     }\r
 470     \r
 471     return retVal;\r
 472         \r
 473 }\r
 474 \r
 475 /** Sets/Clears the iRESET_OUT bit in the Power Reset Control Register\r
 476  * @param 1 Set iRESET_OUT bit; 0 - Clear the bit\r
 477  */\r
 478 void p_pcr_iReset_Out(uint8_t set_clr_flag)\r
 479 {\r
 480     __IO uint32_t *pPCR_Reg;            \r
 481 \r
 482     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PWR_RESET_CTRL;\r
 483 \r
 484     *pPCR_Reg    = (set_clr_flag & 0x1);                \r
 485 }\r
 486 \r
 487 \r
 488 /* end pcr_perphl.c */\r
 489 /**   @}\r
 490  */\r