git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_MPU_CEC_MEC_17xx_51xx_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: 2016/09/22 08:03:49 $ \r
  25 $Author: pramans $\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 /** Writes required sleep mode in System Sleep Control Register\r
 154  * @param sleep_value - System Sleep control value (Heavy/Light/Sleep All)\r
 155  */\r
 156 void p_pcr_system_sleep_ctrl_write(uint8_t sleep_value)\r
 157 {\r
 158     __IO uint32_t *pPCR_Reg;\r
 159         \r
 160    /* Check for valid value */\r
 161    if ((sleep_value == SYSTEM_LIGHT_SLEEP) || \r
 162                     (sleep_value == SYSTEM_LIGHT_SLEEP) ||\r
 163                (sleep_value == SYSTEM_LIGHT_SLEEP))\r
 164          {    \r
 165                         pPCR_Reg = (uint32_t *)(PCR_BASE)       + PCR_REG_SYSTEM_SLEEP_CTRL;    \r
 166 \r
 167                         *pPCR_Reg = (sleep_value & 0x7);                \r
 168          }\r
 169 }\r
 170 \r
 171 /** Reads the System Sleep Control PCR Register\r
 172  * @return value - byte 0 of the system sleep control PCR register\r
 173  */\r
 174 uint8_t p_pcr_system_sleep_ctrl_read(void)\r
 175 {\r
 176     __IO uint32_t *pPCR_Reg;\r
 177     uint8_t retVal;\r
 178     \r
 179     pPCR_Reg = (uint32_t *)(PCR_BASE)   + PCR_REG_SYSTEM_SLEEP_CTRL;            \r
 180 \r
 181     retVal = (uint8_t)((*pPCR_Reg) & 0xFF);\r
 182 \r
 183     return retVal;\r
 184 }\r
 185 \r
 186 \r
 187 \r
 188 /* ---------------------------------------------------------------------- */\r
 189 /*          Function to program to CLK Divide Value                       */\r
 190 /* ---------------------------------------------------------------------- */\r
 191 \r
 192 /** Writes the clock divide value in the Processor Clock Control Register\r
 193  * @param clk_divide_value - clk divide values, valid values in enum PROCESSOR_CLK_DIVIDE_VALUE\r
 194  */\r
 195 void p_pcr_processor_clk_ctrl_write(uint8_t clk_divide_value)\r
 196 {\r
 197     __IO uint32_t *pPCR_Reg;            \r
 198 \r
 199    /* Check for valid value */\r
 200    if (((clk_divide_value >= PCR_CPU_CLK_DIVIDE_1) && \r
 201                     (clk_divide_value <= PCR_CPU_CLK_DIVIDE_4)) ||\r
 202                (clk_divide_value == PCR_CPU_CLK_DIVIDE_16) ||\r
 203                 (clk_divide_value == PCR_CPU_CLK_DIVIDE_48))\r
 204          {      \r
 205                         pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PROCESSOR_CLK_CTRL;         \r
 206 \r
 207                         *pPCR_Reg = (clk_divide_value & 0xFF);\r
 208          }\r
 209         \r
 210 }\r
 211 \r
 212 /** Writes the clock divide value in the Processor Clock Control Register\r
 213  * @param none\r
 214  * @ return value - clk divide value, valid values in enum PROCESSOR_CLK_DIVIDE_VALUE\r
 215  */\r
 216 uint8_t p_pcr_processor_clk_ctrl_read(void)\r
 217 {\r
 218     __IO uint32_t *pPCR_Reg;\r
 219     uint8_t retVal;     \r
 220 \r
 221     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PROCESSOR_CLK_CTRL;             \r
 222 \r
 223           retVal = ((uint8_t)((*pPCR_Reg) & 0xFF));\r
 224         \r
 225     return retVal;\r
 226         \r
 227 }\r
 228 \r
 229 /* ---------------------------------------------------------------------- */\r
 230 /*          Function to program the slow clock divide value           */\r
 231 /* ---------------------------------------------------------------------- */\r
 232 \r
 233 /** Write the slow clock divide value in the Slow Clock Control Register\r
 234  * @param slow_clk_divide_value - slow clk divide value\r
 235  */\r
 236 void p_pcr_slow_clk_ctrl_write(uint16_t slow_clk_divide_value)\r
 237 {\r
 238     __IO uint32_t *pPCR_Reg;            \r
 239 \r
 240     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_SLOW_CLK_CTRL;          \r
 241 \r
 242     *pPCR_Reg = (slow_clk_divide_value & 0x3FF);        \r
 243 \r
 244 }\r
 245 \r
 246 /* ---------------------------------------------------------------------- */\r
 247 /*          Function to read the Oscillator Lock Status                   */\r
 248 /* ---------------------------------------------------------------------- */\r
 249 \r
 250 /** Reads the Oscillator Lock status bit in the Oscillator ID Register\r
 251  * @return 1 if Oscillator Lock Status bit is set, else 0\r
 252  */\r
 253 uint8_t p_pcr_oscillator_lock_sts_get(void)\r
 254 {\r
 255     __IO uint32_t *pPCR_Reg;\r
 256     uint8_t retVal;\r
 257 \r
 258     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_OSCILLATOR_ID;  \r
 259 \r
 260     retVal = 0;\r
 261     if (*pPCR_Reg & PCR_OSCILLATOR_LOCK_STATUS_BITMASK)\r
 262     {\r
 263             retVal = 1;\r
 264     }\r
 265     \r
 266     return retVal;\r
 267         \r
 268 }\r
 269 \r
 270 \r
 271 /** Reads the Oscillator ID Register\r
 272  * @return oscillator ID value\r
 273  */\r
 274 uint16_t p_pcr_oscillator_id_reg_read(void)\r
 275 {\r
 276     __IO uint32_t *pPCR_Reg;\r
 277     uint16_t retVal;\r
 278 \r
 279     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_OSCILLATOR_ID;  \r
 280 \r
 281     retVal = ((uint16_t)((*pPCR_Reg) & 0x1FFu));\r
 282     \r
 283     return retVal;\r
 284         \r
 285 }\r
 286 \r
 287 /* ---------------------------------------------------------------------- */\r
 288 /*  Functions to read various power status in Power Reset register    */\r
 289 /* ---------------------------------------------------------------------- */\r
 290 \r
 291 /** Reads the VCC PWRGD Status bit \r
 292  *        in the Power Reset Status Register\r
 293  * @return 1 if VCC PWRGD Status bit is set, else 0\r
 294  */\r
 295 uint8_t p_pcr_pwr_reset_vcc_pwrdg_sts_get(void)\r
 296 {\r
 297     __IO uint32_t *pPCR_Reg;\r
 298     uint8_t retVal;\r
 299 \r
 300     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PWR_RESET_STS;  \r
 301 \r
 302     retVal = 0;\r
 303     if (*pPCR_Reg & PCR_PWR_RESET_STS_VCC_PWRGD_RESET_STS_BITMASK)\r
 304     {\r
 305             retVal = 1;\r
 306     }\r
 307     \r
 308     return retVal;      \r
 309 }\r
 310 \r
 311 /** Reads the Host Reset Status bit \r
 312  *        in the Power Reset Status Register\r
 313  * @return 1 if Host Reset Status bit is set, else 0\r
 314  */\r
 315 uint8_t p_pcr_pwr_reset_host_reset_sts_get(void)\r
 316 {\r
 317     __IO uint32_t *pPCR_Reg;\r
 318     uint8_t retVal;\r
 319 \r
 320     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PWR_RESET_STS;  \r
 321 \r
 322     retVal = 0;\r
 323     if (*pPCR_Reg & PCR_PWR_RESET_STS_HOST_RESET_STS_BITMASK)\r
 324     {\r
 325             retVal = 1;\r
 326     }\r
 327     \r
 328     return retVal;      \r
 329 }\r
 330 \r
 331 /** Reads the VBAT Reset Status bit \r
 332  *        in the Power Reset Status Register\r
 333  * @return 1 if VBAT Reset Status bit is set, else 0\r
 334  */\r
 335 uint8_t p_pcr_pwr_reset_vbat_reset_sts_get(void)\r
 336 {\r
 337     __IO uint32_t *pPCR_Reg;\r
 338     uint8_t retVal;\r
 339 \r
 340     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PWR_RESET_STS;  \r
 341 \r
 342     retVal = 0;\r
 343     if (*pPCR_Reg & PCR_PWR_RESET_STS_VBAT_RESET_STS_BITMASK)\r
 344     {\r
 345             retVal = 1;\r
 346     }\r
 347     \r
 348     return retVal;      \r
 349 }\r
 350 \r
 351 /** Clears the VBAT Reset Status bit \r
 352  *        in the Power Reset Status Register \r
 353  */\r
 354 void p_pcr_pwr_reset_vbat_reset_sts_clr(void)\r
 355 {\r
 356     __IO uint32_t *pPCR_Reg;            \r
 357 \r
 358     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PWR_RESET_STS;\r
 359 \r
 360     // Write to clear\r
 361     *pPCR_Reg |= PCR_PWR_RESET_STS_VBAT_RESET_STS_BITMASK;\r
 362         \r
 363 }\r
 364 \r
 365 /** Reads the VTR Reset Status bit \r
 366  *        in the Power Reset Status Register\r
 367  * @return 1 if VTR Reset Status bit is set, else 0\r
 368  */\r
 369 uint8_t p_pcr_pwr_reset_vtr_reset_sts_get(void)\r
 370 {\r
 371     __IO uint32_t *pPCR_Reg;\r
 372     uint8_t retVal;\r
 373 \r
 374     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PWR_RESET_STS;  \r
 375 \r
 376     retVal = 0;\r
 377     if (*pPCR_Reg & PCR_PWR_RESET_STS_VTR_RESET_STS_BITMASK)\r
 378     {\r
 379             retVal = 1;\r
 380     }\r
 381     \r
 382     return retVal;      \r
 383 }\r
 384 \r
 385 /** Clears the VTR Reset Status bit \r
 386  *        in the Power Reset Status Register \r
 387  */\r
 388 void p_pcr_pwr_reset_vtr_reset_sts_clr(void)\r
 389 {\r
 390     __IO uint32_t *pPCR_Reg;            \r
 391 \r
 392     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PWR_RESET_STS;\r
 393 \r
 394     // Write to clear\r
 395     *pPCR_Reg |= PCR_PWR_RESET_STS_VTR_RESET_STS_BITMASK;\r
 396         \r
 397 }\r
 398 \r
 399 /** Reads the JTAG Reset Status bit \r
 400  *        in the Power Reset Status Register\r
 401  * @return 1 if JTAG Reset Status bit is set, else 0\r
 402  */\r
 403 uint8_t p_pcr_pwr_reset_jtag_reset_sts_get(void)\r
 404 {\r
 405     __IO uint32_t *pPCR_Reg;\r
 406     uint8_t retVal;\r
 407 \r
 408     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PWR_RESET_STS;  \r
 409 \r
 410     retVal = 0;\r
 411     if (*pPCR_Reg & PCR_PWR_RESET_STS_JTAG_RESET_STS_BITMASK)\r
 412     {\r
 413             retVal = 1;\r
 414     }\r
 415     \r
 416     return retVal;      \r
 417 }\r
 418 \r
 419 /** Clears the JTAG Reset Status bit \r
 420  *        in the Power Reset Status Register \r
 421  */\r
 422 void p_pcr_pwr_reset_jtag_reset_sts_clr(void)\r
 423 {\r
 424     __IO uint32_t *pPCR_Reg;            \r
 425 \r
 426     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PWR_RESET_STS;\r
 427 \r
 428     // Write to clear\r
 429     *pPCR_Reg |= PCR_PWR_RESET_STS_JTAG_RESET_STS_BITMASK;\r
 430         \r
 431 }\r
 432 \r
 433 /** Reads the 32K_ACTIVE status bit \r
 434  *        in the Chip Subsystem Power Reset Status Register\r
 435  * @return 1 if 32_ACTIVE bit is set, else 0\r
 436  */\r
 437 uint8_t p_pcr_pwr_reset_32K_active_sts_get(void)\r
 438 {\r
 439     __IO uint32_t *pPCR_Reg;\r
 440     uint8_t retVal;\r
 441 \r
 442     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PWR_RESET_STS;  \r
 443 \r
 444     retVal = 0;\r
 445     if (*pPCR_Reg & PCR_PWR_RESET_STS_32K_ACTIVE_STS_BITMASK)\r
 446     {\r
 447             retVal = 1;\r
 448     }\r
 449     \r
 450     return retVal;      \r
 451 }\r
 452 \r
 453 /** Reads the PCICLK_ACTIVE status bit \r
 454  *        in the Power Reset Status Register\r
 455  * @return 1 if PCICLK_ACTIVE bit is set, else 0\r
 456  */\r
 457 uint8_t p_pcr_pwr_reset_pciclk_active_sts_get(void)\r
 458 {\r
 459     __IO uint32_t *pPCR_Reg;\r
 460     uint8_t retVal;\r
 461 \r
 462     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PWR_RESET_STS;  \r
 463 \r
 464     retVal = 0;\r
 465     if (*pPCR_Reg & PCR_PWR_RESET_STS_PCICLK_ACTIVE_STS_BITMASK)\r
 466     {\r
 467             retVal = 1;\r
 468     }           \r
 469     return retVal;      \r
 470 }\r
 471 \r
 472 /** Reads the ESPI status bit \r
 473  *        in the Power Reset Status Register\r
 474  * @return 1 if ESPICLK_ACTIVE bit is set, else 0\r
 475  */\r
 476 uint8_t p_pcr_pwr_reset_espiclk_active_sts_get(void)\r
 477 {\r
 478     __IO uint32_t *pPCR_Reg;\r
 479     uint8_t retVal;\r
 480 \r
 481     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PWR_RESET_STS;  \r
 482 \r
 483     retVal = 0;\r
 484     if (*pPCR_Reg & PCR_PWR_RESET_STS_ESPICLK_ACTIVE_STS_BITMASK)\r
 485     {\r
 486             retVal = 1;\r
 487     }           \r
 488     return retVal;      \r
 489 }\r
 490 \r
 491 /** Reads the Power status reg\r
 492  * @return Power Status Reg value\r
 493  */\r
 494 uint16_t p_pcr_pwr_reset_sts_get(void)\r
 495 {\r
 496     __IO uint32_t *pPCR_Reg;\r
 497     uint16_t retVal;\r
 498 \r
 499     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PWR_RESET_STS;  \r
 500 \r
 501     retVal = (uint16_t)((*pPCR_Reg) & 0xFFF);\r
 502         \r
 503           return (retVal);    \r
 504 }\r
 505 \r
 506 /* ---------------------------------------------------------------------- */\r
 507 /*           Functions for Power Reset Control Register                   */\r
 508 /* ---------------------------------------------------------------------- */\r
 509 \r
 510 /** Reads the Power Reset Control Register\r
 511  * @return Power Reset Control Register value\r
 512  */\r
 513 uint16_t p_pcr_pwr_reset_ctrl_read(void)\r
 514 {\r
 515     __IO uint32_t *pPCR_Reg;\r
 516     uint16_t retVal;\r
 517 \r
 518     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PWR_RESET_CTRL; \r
 519 \r
 520     retVal = (uint16_t)((*pPCR_Reg) & 0x1FFUL);    \r
 521     \r
 522     return retVal;      \r
 523 }\r
 524 \r
 525 /** Set the PWR_INV bit in the Power Reset Control Register\r
 526  * @param set_clr value 1 or 0\r
 527  * @return none\r
 528  */\r
 529 void p_pcr_pwr_reset_ctrl_pwr_inv_set_clr(uint8_t set_clr)\r
 530 {\r
 531     __IO uint32_t *pPCR_Reg;    \r
 532 \r
 533     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PWR_RESET_CTRL; \r
 534 \r
 535           if (set_clr)\r
 536                 {\r
 537         *pPCR_Reg |= (PCR_PWR_RESET_CTRL_PWR_INV_BITMASK);\r
 538                 }\r
 539                 else\r
 540                 {\r
 541                     *pPCR_Reg &= ~(PCR_PWR_RESET_CTRL_PWR_INV_BITMASK);\r
 542                 }\r
 543 }\r
 544 \r
 545 /** Set the HOST RESET SELECT bit in the Power Reset Control Register\r
 546  * @param set_clr value 1 or 0\r
 547  * @return none\r
 548  */\r
 549 void p_pcr_pwr_reset_ctrl_host_rst_set_clr(uint8_t set_clr)\r
 550 {\r
 551     __IO uint32_t *pPCR_Reg;    \r
 552 \r
 553     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_PWR_RESET_CTRL; \r
 554 \r
 555           if (set_clr)\r
 556                 {\r
 557         *pPCR_Reg |= (PCR_PWR_RESET_CTRL_HOST_RST_SELECT_BITMASK);       \r
 558                 }\r
 559                 else\r
 560                 {\r
 561         *pPCR_Reg &= ~(PCR_PWR_RESET_CTRL_HOST_RST_SELECT_BITMASK);                             \r
 562                 }\r
 563 }\r
 564 \r
 565 \r
 566 /* ---------------------------------------------------------------------- */\r
 567 /*           Functions for System Reset Register                   */\r
 568 /* ---------------------------------------------------------------------- */\r
 569 /** Set the SOFT_SYS_RESET bit in the System Reset Register\r
 570  * @param none\r
 571  * @return none\r
 572  */\r
 573 void p_pcr_system_reset_set()\r
 574 {\r
 575     __IO uint32_t *pPCR_Reg;    \r
 576 \r
 577     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_REG_SYSTEM_RESET;   \r
 578 \r
 579     *pPCR_Reg |= (1<<8);       \r
 580 }\r
 581 \r
 582 /* ---------------------------------------------------------------------- */\r
 583 /*           Functions for PKE Clock Register                   */\r
 584 /* ---------------------------------------------------------------------- */\r
 585 /** Set the value in PKE CLOCK Register\r
 586  * @param PKE Clock value \r
 587  * @return none\r
 588  */\r
 589 void p_pcr_pke_clock_write(uint8_t pke_clk_val)\r
 590 {\r
 591     __IO uint32_t *pPCR_Reg;    \r
 592 \r
 593     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_TEST0;      \r
 594 \r
 595     *pPCR_Reg = pke_clk_val;\r
 596 }\r
 597 \r
 598 /** Read the value in PKE CLOCK Register\r
 599  * @none \r
 600  * @return PKE Clock value \r
 601  */\r
 602 uint8_t p_pcr_pke_clock_read(void)\r
 603 {\r
 604     __IO uint32_t *pPCR_Reg;    \r
 605 \r
 606     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_TEST0;      \r
 607 \r
 608     return ((uint8_t)(*pPCR_Reg & 0xFF));\r
 609 }\r
 610 \r
 611 /* ---------------------------------------------------------------------- */\r
 612 /*           Functions for Oscillator calibration Register                   */\r
 613 /* ---------------------------------------------------------------------- */\r
 614 /** Set the value in Oscillator calibration Register\r
 615  * @param Oscillator calibration value \r
 616  * @return none\r
 617  */\r
 618 void p_pcr_osc_cal_write(uint8_t osc_cal_val)\r
 619 {\r
 620     __IO uint32_t *pPCR_Reg;    \r
 621 \r
 622     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_TEST1;      \r
 623 \r
 624     *pPCR_Reg = osc_cal_val;\r
 625 }\r
 626 \r
 627 /** Read the value in Osc cal Register\r
 628  * @none \r
 629  * @return Osc cal value \r
 630  */\r
 631 uint8_t p_pcr_osc_cal_read(void)\r
 632 {\r
 633     __IO uint32_t *pPCR_Reg;    \r
 634 \r
 635     pPCR_Reg = (uint32_t *)(PCR_BASE) + PCR_TEST1;      \r
 636 \r
 637     return ((uint8_t)(*pPCR_Reg & 0xFF));\r
 638 }\r
 639 \r
 640 /* end pcr_perphl.c */\r
 641 /**   @}\r
 642  */\r