; generated by Component: ARM Compiler 5.05 update 2 (build 169) Tool: ArmCC [4d0f38]
; commandline ArmCC [--c99 --list --split_sections --debug -c --asm --interleave -o..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\stm32f4xx_pwr.o --asm_dir=..\..\..\..\Build\demo\MICO-Fire_F429\list_RVMDK\ --list_dir=..\..\..\..\Build\demo\MICO-Fire_F429\list_RVMDK\ --depend=..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\stm32f4xx_pwr.d --cpu=Cortex-M4.fp --apcs=interwork -O0 --diag_suppress=9931,1,1293 -I..\..\..\..\Board\fire_F429 -I..\..\..\..\Demos\fire\ov2640 -I..\..\..\..\include -I..\..\..\..\libraries\utilities -I..\..\..\..\libraries\utilities\json_c -I..\..\..\..\MICO\core -I..\..\..\..\MICO\security -I..\..\..\..\MICO\system -I..\..\..\..\MICO\system\command_console -I..\..\..\..\Platform\include -I..\..\..\..\Platform\Cortex-M4 -I..\..\..\..\Platform\Cortex-M4\CMSIS -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries\STM32F4xx_StdPeriph_Driver\inc -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries -I..\..\..\..\Platform\MCU\STM32F4xx\wlan_bus_driver -I..\..\..\..\Platform\Drivers\spi_flash -I..\..\..\..\Platform\Drivers -I..\..\..\..\libraries\daemons\homekit_server -I..\..\..\..\libraries\daemons\http_server -I..\..\..\..\Platform\Drivers\malloc -I..\..\..\..\Platform\Drivers\SDRAM -I..\..\..\..\Platform\Drivers\ov5640 -IG:\GIT_OSC\STM32_develop\F429-V2\develop\6-WIFI\STM32-WiFi\3.wifi_ov5640\Projects\STM32F429\demo\RVMDK\RTE -IC:\Keil_v5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0\Drivers\CMSIS\Device\ST\STM32F4xx\Include -IC:\Keil_v5\ARM\CMSIS\Include -IC:\Keil_v5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0 -D__UVISION_VERSION=515 -DSTM32F429xx -DUSE_STDPERIPH_DRIVER -DDEBUG -DHSE_VALUE=25000000 -DOV5640 --omf_browse=..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\stm32f4xx_pwr.crf ..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries\STM32F4xx_StdPeriph_Driver\src\stm32f4xx_pwr.c]
                          THUMB

                          AREA ||i.PWR_BackupAccessCmd||, CODE, READONLY, ALIGN=2

                  PWR_BackupAccessCmd PROC
;;;156      */
;;;157    void PWR_BackupAccessCmd(FunctionalState NewState)
000000  4901              LDR      r1,|L1.8|
;;;158    {
;;;159      /* Check the parameters */
;;;160      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;161      
;;;162      *(__IO uint32_t *) CR_DBP_BB = (uint32_t)NewState;
000002  6208              STR      r0,[r1,#0x20]
;;;163    }
000004  4770              BX       lr
;;;164    
                          ENDP

000006  0000              DCW      0x0000
                  |L1.8|
                          DCD      0x420e0000

                          AREA ||i.PWR_BackupRegulatorCmd||, CODE, READONLY, ALIGN=2

                  PWR_BackupRegulatorCmd PROC
;;;360      */
;;;361    void PWR_BackupRegulatorCmd(FunctionalState NewState)
000000  4901              LDR      r1,|L2.8|
;;;362    {
;;;363      /* Check the parameters */
;;;364      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;365    
;;;366      *(__IO uint32_t *) CSR_BRE_BB = (uint32_t)NewState;
000002  6008              STR      r0,[r1,#0]
;;;367    }
000004  4770              BX       lr
;;;368    
                          ENDP

000006  0000              DCW      0x0000
                  |L2.8|
                          DCD      0x420e00a4

                          AREA ||i.PWR_ClearFlag||, CODE, READONLY, ALIGN=2

                  PWR_ClearFlag PROC
;;;901      */
;;;902    void PWR_ClearFlag(uint32_t PWR_FLAG)
000000  f5b02f40          CMP      r0,#0xc0000
;;;903    {
;;;904      /* Check the parameters */
;;;905      assert_param(IS_PWR_CLEAR_FLAG(PWR_FLAG));
;;;906      
;;;907    #if defined (STM32F427_437xx) || defined (STM32F429_439xx)
;;;908      if (PWR_FLAG != PWR_FLAG_UDRDY)
000004  d006              BEQ      |L3.20|
;;;909      {
;;;910        PWR->CR |=  PWR_FLAG << 2;
000006  4907              LDR      r1,|L3.36|
000008  6809              LDR      r1,[r1,#0]
00000a  ea410180          ORR      r1,r1,r0,LSL #2
00000e  4a05              LDR      r2,|L3.36|
000010  6011              STR      r1,[r2,#0]
000012  e005              B        |L3.32|
                  |L3.20|
;;;911      }
;;;912      else
;;;913      {
;;;914        PWR->CSR |= PWR_FLAG_UDRDY;
000014  4903              LDR      r1,|L3.36|
000016  6849              LDR      r1,[r1,#4]
000018  f4412140          ORR      r1,r1,#0xc0000
00001c  4a01              LDR      r2,|L3.36|
00001e  6051              STR      r1,[r2,#4]
                  |L3.32|
;;;915      }
;;;916    #endif /* STM32F427_437xx ||  STM32F429_439xx */
;;;917    
;;;918    #if defined (STM32F40_41xxx) || defined (STM32F401xx) || defined (STM32F411xE) 
;;;919      PWR->CR |=  PWR_FLAG << 2;
;;;920    #endif /* STM32F40_41xxx  || STM32F401xx || STM32F411xE */
;;;921    }
000020  4770              BX       lr
;;;922    
                          ENDP

000022  0000              DCW      0x0000
                  |L3.36|
                          DCD      0x40007000

                          AREA ||i.PWR_DeInit||, CODE, READONLY, ALIGN=1

                  PWR_DeInit PROC
;;;141      */
;;;142    void PWR_DeInit(void)
000000  b510              PUSH     {r4,lr}
;;;143    {
;;;144      RCC_APB1PeriphResetCmd(RCC_APB1Periph_PWR, ENABLE);
000002  2101              MOVS     r1,#1
000004  0708              LSLS     r0,r1,#28
000006  f7fffffe          BL       RCC_APB1PeriphResetCmd
;;;145      RCC_APB1PeriphResetCmd(RCC_APB1Periph_PWR, DISABLE);
00000a  2100              MOVS     r1,#0
00000c  f04f5080          MOV      r0,#0x10000000
000010  f7fffffe          BL       RCC_APB1PeriphResetCmd
;;;146    }
000014  bd10              POP      {r4,pc}
;;;147    
                          ENDP


                          AREA ||i.PWR_EnterSTANDBYMode||, CODE, READONLY, ALIGN=2

                  PWR_EnterSTANDBYMode PROC
;;;813      */
;;;814    void PWR_EnterSTANDBYMode(void)
000000  4807              LDR      r0,|L5.32|
;;;815    {
;;;816      /* Select STANDBY mode */
;;;817      PWR->CR |= PWR_CR_PDDS;
000002  6800              LDR      r0,[r0,#0]
000004  f0400002          ORR      r0,r0,#2
000008  4905              LDR      r1,|L5.32|
00000a  6008              STR      r0,[r1,#0]
;;;818      
;;;819      /* Set SLEEPDEEP bit of Cortex System Control Register */
;;;820      SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
00000c  4805              LDR      r0,|L5.36|
00000e  6800              LDR      r0,[r0,#0]
000010  f0400004          ORR      r0,r0,#4
000014  4903              LDR      r1,|L5.36|
000016  6008              STR      r0,[r1,#0]
;;;821      
;;;822      /* This option is used to ensure that store operations are completed */
;;;823    #if defined ( __CC_ARM   )
;;;824      __force_stores();
000018  bf00              NOP      
00001a  bf00              NOP      
;;;825    #endif
;;;826      /* Request Wait For Interrupt */
;;;827      __WFI();
00001c  bf30              WFI      
;;;828    }
00001e  4770              BX       lr
;;;829    
                          ENDP

                  |L5.32|
                          DCD      0x40007000
                  |L5.36|
                          DCD      0xe000ed10

                          AREA ||i.PWR_EnterSTOPMode||, CODE, READONLY, ALIGN=2

                  PWR_EnterSTOPMode PROC
;;;700      */
;;;701    void PWR_EnterSTOPMode(uint32_t PWR_Regulator, uint8_t PWR_STOPEntry)
000000  b510              PUSH     {r4,lr}
;;;702    {
000002  4602              MOV      r2,r0
;;;703      uint32_t tmpreg = 0;
000004  2000              MOVS     r0,#0
;;;704      
;;;705      /* Check the parameters */
;;;706      assert_param(IS_PWR_REGULATOR(PWR_Regulator));
;;;707      assert_param(IS_PWR_STOP_ENTRY(PWR_STOPEntry));
;;;708      
;;;709      /* Select the regulator state in STOP mode ---------------------------------*/
;;;710      tmpreg = PWR->CR;
000006  4b0d              LDR      r3,|L6.60|
000008  6818              LDR      r0,[r3,#0]
;;;711      /* Clear PDDS and LPDS bits */
;;;712      tmpreg &= CR_DS_MASK;
00000a  f6404303          MOV      r3,#0xc03
00000e  4398              BICS     r0,r0,r3
;;;713      
;;;714      /* Set LPDS, MRLVDS and LPLVDS bits according to PWR_Regulator value */
;;;715      tmpreg |= PWR_Regulator;
000010  4310              ORRS     r0,r0,r2
;;;716      
;;;717      /* Store the new value */
;;;718      PWR->CR = tmpreg;
000012  4b0a              LDR      r3,|L6.60|
000014  6018              STR      r0,[r3,#0]
;;;719      
;;;720      /* Set SLEEPDEEP bit of Cortex System Control Register */
;;;721      SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
000016  4b0a              LDR      r3,|L6.64|
000018  681b              LDR      r3,[r3,#0]
00001a  f0430304          ORR      r3,r3,#4
00001e  4c08              LDR      r4,|L6.64|
000020  6023              STR      r3,[r4,#0]
;;;722      
;;;723      /* Select STOP mode entry --------------------------------------------------*/
;;;724      if(PWR_STOPEntry == PWR_STOPEntry_WFI)
000022  2901              CMP      r1,#1
000024  d101              BNE      |L6.42|
;;;725      {   
;;;726        /* Request Wait For Interrupt */
;;;727        __WFI();
000026  bf30              WFI      
000028  e000              B        |L6.44|
                  |L6.42|
;;;728      }
;;;729      else
;;;730      {
;;;731        /* Request Wait For Event */
;;;732        __WFE();
00002a  bf20              WFE      
                  |L6.44|
;;;733      }
;;;734      /* Reset SLEEPDEEP bit of Cortex System Control Register */
;;;735      SCB->SCR &= (uint32_t)~((uint32_t)SCB_SCR_SLEEPDEEP_Msk);  
00002c  4b04              LDR      r3,|L6.64|
00002e  681b              LDR      r3,[r3,#0]
000030  f0230304          BIC      r3,r3,#4
000034  4c02              LDR      r4,|L6.64|
000036  6023              STR      r3,[r4,#0]
;;;736    }
000038  bd10              POP      {r4,pc}
;;;737    
                          ENDP

00003a  0000              DCW      0x0000
                  |L6.60|
                          DCD      0x40007000
                  |L6.64|
                          DCD      0xe000ed10

                          AREA ||i.PWR_EnterUnderDriveSTOPMode||, CODE, READONLY, ALIGN=2

                  PWR_EnterUnderDriveSTOPMode PROC
;;;764      */
;;;765    void PWR_EnterUnderDriveSTOPMode(uint32_t PWR_Regulator, uint8_t PWR_STOPEntry)
000000  b510              PUSH     {r4,lr}
;;;766    {
000002  4602              MOV      r2,r0
;;;767      uint32_t tmpreg = 0;
000004  2000              MOVS     r0,#0
;;;768      
;;;769      /* Check the parameters */
;;;770      assert_param(IS_PWR_REGULATOR_UNDERDRIVE(PWR_Regulator));
;;;771      assert_param(IS_PWR_STOP_ENTRY(PWR_STOPEntry));
;;;772      
;;;773      /* Select the regulator state in STOP mode ---------------------------------*/
;;;774      tmpreg = PWR->CR;
000006  4b0d              LDR      r3,|L7.60|
000008  6818              LDR      r0,[r3,#0]
;;;775      /* Clear PDDS and LPDS bits */
;;;776      tmpreg &= CR_DS_MASK;
00000a  f6404303          MOV      r3,#0xc03
00000e  4398              BICS     r0,r0,r3
;;;777      
;;;778      /* Set LPDS, MRLUDS and LPLUDS bits according to PWR_Regulator value */
;;;779      tmpreg |= PWR_Regulator;
000010  4310              ORRS     r0,r0,r2
;;;780      
;;;781      /* Store the new value */
;;;782      PWR->CR = tmpreg;
000012  4b0a              LDR      r3,|L7.60|
000014  6018              STR      r0,[r3,#0]
;;;783      
;;;784      /* Set SLEEPDEEP bit of Cortex System Control Register */
;;;785      SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
000016  4b0a              LDR      r3,|L7.64|
000018  681b              LDR      r3,[r3,#0]
00001a  f0430304          ORR      r3,r3,#4
00001e  4c08              LDR      r4,|L7.64|
000020  6023              STR      r3,[r4,#0]
;;;786      
;;;787      /* Select STOP mode entry --------------------------------------------------*/
;;;788      if(PWR_STOPEntry == PWR_STOPEntry_WFI)
000022  2901              CMP      r1,#1
000024  d101              BNE      |L7.42|
;;;789      {   
;;;790        /* Request Wait For Interrupt */
;;;791        __WFI();
000026  bf30              WFI      
000028  e000              B        |L7.44|
                  |L7.42|
;;;792      }
;;;793      else
;;;794      {
;;;795        /* Request Wait For Event */
;;;796        __WFE();
00002a  bf20              WFE      
                  |L7.44|
;;;797      }
;;;798      /* Reset SLEEPDEEP bit of Cortex System Control Register */
;;;799      SCB->SCR &= (uint32_t)~((uint32_t)SCB_SCR_SLEEPDEEP_Msk);  
00002c  4b04              LDR      r3,|L7.64|
00002e  681b              LDR      r3,[r3,#0]
000030  f0230304          BIC      r3,r3,#4
000034  4c02              LDR      r4,|L7.64|
000036  6023              STR      r3,[r4,#0]
;;;800    }
000038  bd10              POP      {r4,pc}
;;;801    
                          ENDP

00003a  0000              DCW      0x0000
                  |L7.60|
                          DCD      0x40007000
                  |L7.64|
                          DCD      0xe000ed10

                          AREA ||i.PWR_FlashPowerDownCmd||, CODE, READONLY, ALIGN=2

                  PWR_FlashPowerDownCmd PROC
;;;554      */
;;;555    void PWR_FlashPowerDownCmd(FunctionalState NewState)
000000  4901              LDR      r1,|L8.8|
;;;556    {
;;;557      /* Check the parameters */
;;;558      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;559    
;;;560      *(__IO uint32_t *) CR_FPDS_BB = (uint32_t)NewState;
000002  6248              STR      r0,[r1,#0x24]
;;;561    }
000004  4770              BX       lr
;;;562    
                          ENDP

000006  0000              DCW      0x0000
                  |L8.8|
                          DCD      0x420e0000

                          AREA ||i.PWR_GetFlagStatus||, CODE, READONLY, ALIGN=2

                  PWR_GetFlagStatus PROC
;;;873      */
;;;874    FlagStatus PWR_GetFlagStatus(uint32_t PWR_FLAG)
000000  4601              MOV      r1,r0
;;;875    {
;;;876      FlagStatus bitstatus = RESET;
000002  2000              MOVS     r0,#0
;;;877      
;;;878      /* Check the parameters */
;;;879      assert_param(IS_PWR_GET_FLAG(PWR_FLAG));
;;;880      
;;;881      if ((PWR->CSR & PWR_FLAG) != (uint32_t)RESET)
000004  4a03              LDR      r2,|L9.20|
000006  6852              LDR      r2,[r2,#4]
000008  400a              ANDS     r2,r2,r1
00000a  b10a              CBZ      r2,|L9.16|
;;;882      {
;;;883        bitstatus = SET;
00000c  2001              MOVS     r0,#1
00000e  e000              B        |L9.18|
                  |L9.16|
;;;884      }
;;;885      else
;;;886      {
;;;887        bitstatus = RESET;
000010  2000              MOVS     r0,#0
                  |L9.18|
;;;888      }
;;;889      /* Return the flag status */
;;;890      return bitstatus;
;;;891    }
000012  4770              BX       lr
;;;892    
                          ENDP

                  |L9.20|
                          DCD      0x40007000

                          AREA ||i.PWR_LowRegulatorLowVoltageCmd||, CODE, READONLY, ALIGN=2

                  PWR_LowRegulatorLowVoltageCmd PROC
;;;512      */
;;;513    void PWR_LowRegulatorLowVoltageCmd(FunctionalState NewState)
000000  b118              CBZ      r0,|L10.10|
;;;514    {
;;;515      /* Check the parameters */
;;;516      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;517      
;;;518      if (NewState != DISABLE)
;;;519      {
;;;520        *(__IO uint32_t *) CR_LPLVDS_BB = (uint32_t)ENABLE;
000002  2101              MOVS     r1,#1
000004  4a03              LDR      r2,|L10.20|
000006  6291              STR      r1,[r2,#0x28]
000008  e002              B        |L10.16|
                  |L10.10|
;;;521      }
;;;522      else
;;;523      {
;;;524        *(__IO uint32_t *) CR_LPLVDS_BB = (uint32_t)DISABLE;
00000a  2100              MOVS     r1,#0
00000c  4a01              LDR      r2,|L10.20|
00000e  6291              STR      r1,[r2,#0x28]
                  |L10.16|
;;;525      }
;;;526    }
000010  4770              BX       lr
;;;527    
                          ENDP

000012  0000              DCW      0x0000
                  |L10.20|
                          DCD      0x420e0000

                          AREA ||i.PWR_MainRegulatorLowVoltageCmd||, CODE, READONLY, ALIGN=2

                  PWR_MainRegulatorLowVoltageCmd PROC
;;;488      */
;;;489    void PWR_MainRegulatorLowVoltageCmd(FunctionalState NewState)
000000  b118              CBZ      r0,|L11.10|
;;;490    { 
;;;491      /* Check the parameters */
;;;492      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;493      
;;;494      if (NewState != DISABLE)
;;;495      {
;;;496        *(__IO uint32_t *) CR_MRLVDS_BB = (uint32_t)ENABLE;
000002  2101              MOVS     r1,#1
000004  4a03              LDR      r2,|L11.20|
000006  62d1              STR      r1,[r2,#0x2c]
000008  e002              B        |L11.16|
                  |L11.10|
;;;497      }
;;;498      else
;;;499      {
;;;500        *(__IO uint32_t *) CR_MRLVDS_BB = (uint32_t)DISABLE;
00000a  2100              MOVS     r1,#0
00000c  4a01              LDR      r2,|L11.20|
00000e  62d1              STR      r1,[r2,#0x2c]
                  |L11.16|
;;;501      }
;;;502    }
000010  4770              BX       lr
;;;503    
                          ENDP

000012  0000              DCW      0x0000
                  |L11.20|
                          DCD      0x420e0000

                          AREA ||i.PWR_MainRegulatorModeConfig||, CODE, READONLY, ALIGN=2

                  PWR_MainRegulatorModeConfig PROC
;;;382      */
;;;383    void PWR_MainRegulatorModeConfig(uint32_t PWR_Regulator_Voltage)
000000  4601              MOV      r1,r0
;;;384    {
;;;385      uint32_t tmpreg = 0;
000002  2000              MOVS     r0,#0
;;;386    	
;;;387      /* Check the parameters */
;;;388      assert_param(IS_PWR_REGULATOR_VOLTAGE(PWR_Regulator_Voltage));
;;;389    
;;;390      tmpreg = PWR->CR;
000004  4a03              LDR      r2,|L12.20|
000006  6810              LDR      r0,[r2,#0]
;;;391      
;;;392      /* Clear VOS[15:14] bits */
;;;393      tmpreg &= CR_VOS_MASK;
000008  f4204040          BIC      r0,r0,#0xc000
;;;394      
;;;395      /* Set VOS[15:14] bits according to PWR_Regulator_Voltage value */
;;;396      tmpreg |= PWR_Regulator_Voltage;
00000c  4308              ORRS     r0,r0,r1
;;;397      
;;;398      /* Store the new value */
;;;399      PWR->CR = tmpreg;
00000e  6010              STR      r0,[r2,#0]
;;;400    }
000010  4770              BX       lr
;;;401    
                          ENDP

000012  0000              DCW      0x0000
                  |L12.20|
                          DCD      0x40007000

                          AREA ||i.PWR_OverDriveCmd||, CODE, READONLY, ALIGN=2

                  PWR_OverDriveCmd PROC
;;;417      */
;;;418    void PWR_OverDriveCmd(FunctionalState NewState)
000000  4901              LDR      r1,|L13.8|
;;;419    {
;;;420      /* Check the parameters */
;;;421      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;422      
;;;423      /* Set/Reset the ODEN bit to enable/disable the Over Drive mode */
;;;424      *(__IO uint32_t *) CR_ODEN_BB = (uint32_t)NewState;
000002  6408              STR      r0,[r1,#0x40]
;;;425    }
000004  4770              BX       lr
;;;426    
                          ENDP

000006  0000              DCW      0x0000
                  |L13.8|
                          DCD      0x420e0000

                          AREA ||i.PWR_OverDriveSWCmd||, CODE, READONLY, ALIGN=2

                  PWR_OverDriveSWCmd PROC
;;;435      */
;;;436    void PWR_OverDriveSWCmd(FunctionalState NewState)
000000  4901              LDR      r1,|L14.8|
;;;437    {
;;;438      /* Check the parameters */
;;;439      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;440    
;;;441      /* Set/Reset the ODSWEN bit to enable/disable the Over Drive switching mode */
;;;442      *(__IO uint32_t *) CR_ODSWEN_BB = (uint32_t)NewState;
000002  6448              STR      r0,[r1,#0x44]
;;;443    }
000004  4770              BX       lr
;;;444    
                          ENDP

000006  0000              DCW      0x0000
                  |L14.8|
                          DCD      0x420e0000

                          AREA ||i.PWR_PVDCmd||, CODE, READONLY, ALIGN=2

                  PWR_PVDCmd PROC
;;;229      */
;;;230    void PWR_PVDCmd(FunctionalState NewState)
000000  4901              LDR      r1,|L15.8|
;;;231    {
;;;232      /* Check the parameters */
;;;233      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;234      
;;;235      *(__IO uint32_t *) CR_PVDE_BB = (uint32_t)NewState;
000002  6108              STR      r0,[r1,#0x10]
;;;236    }
000004  4770              BX       lr
;;;237    
                          ENDP

000006  0000              DCW      0x0000
                  |L15.8|
                          DCD      0x420e0000

                          AREA ||i.PWR_PVDLevelConfig||, CODE, READONLY, ALIGN=2

                  PWR_PVDLevelConfig PROC
;;;204      */
;;;205    void PWR_PVDLevelConfig(uint32_t PWR_PVDLevel)
000000  4601              MOV      r1,r0
;;;206    {
;;;207      uint32_t tmpreg = 0;
000002  2000              MOVS     r0,#0
;;;208      
;;;209      /* Check the parameters */
;;;210      assert_param(IS_PWR_PVD_LEVEL(PWR_PVDLevel));
;;;211      
;;;212      tmpreg = PWR->CR;
000004  4a03              LDR      r2,|L16.20|
000006  6810              LDR      r0,[r2,#0]
;;;213      
;;;214      /* Clear PLS[7:5] bits */
;;;215      tmpreg &= CR_PLS_MASK;
000008  f02000e0          BIC      r0,r0,#0xe0
;;;216      
;;;217      /* Set PLS[7:5] bits according to PWR_PVDLevel value */
;;;218      tmpreg |= PWR_PVDLevel;
00000c  4308              ORRS     r0,r0,r1
;;;219      
;;;220      /* Store the new value */
;;;221      PWR->CR = tmpreg;
00000e  6010              STR      r0,[r2,#0]
;;;222    }
000010  4770              BX       lr
;;;223    
                          ENDP

000012  0000              DCW      0x0000
                  |L16.20|
                          DCD      0x40007000

                          AREA ||i.PWR_UnderDriveCmd||, CODE, READONLY, ALIGN=2

                  PWR_UnderDriveCmd PROC
;;;462      */
;;;463    void PWR_UnderDriveCmd(FunctionalState NewState)
000000  b130              CBZ      r0,|L17.16|
;;;464    {
;;;465      /* Check the parameters */
;;;466      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;467    
;;;468      if (NewState != DISABLE)
;;;469      {
;;;470        /* Set the UDEN[1:0] bits to enable the Under Drive mode */
;;;471        PWR->CR |= (uint32_t)PWR_CR_UDEN;
000002  4907              LDR      r1,|L17.32|
000004  6809              LDR      r1,[r1,#0]
000006  f4412140          ORR      r1,r1,#0xc0000
00000a  4a05              LDR      r2,|L17.32|
00000c  6011              STR      r1,[r2,#0]
00000e  e005              B        |L17.28|
                  |L17.16|
;;;472      }
;;;473      else
;;;474      {
;;;475        /* Reset the UDEN[1:0] bits to disable the Under Drive mode */
;;;476        PWR->CR &= (uint32_t)(~PWR_CR_UDEN);
000010  4903              LDR      r1,|L17.32|
000012  6809              LDR      r1,[r1,#0]
000014  f4212140          BIC      r1,r1,#0xc0000
000018  4a01              LDR      r2,|L17.32|
00001a  6011              STR      r1,[r2,#0]
                  |L17.28|
;;;477      }
;;;478    }
00001c  4770              BX       lr
;;;479    
                          ENDP

00001e  0000              DCW      0x0000
                  |L17.32|
                          DCD      0x40007000

                          AREA ||i.PWR_WakeUpPinCmd||, CODE, READONLY, ALIGN=2

                  PWR_WakeUpPinCmd PROC
;;;263      */
;;;264    void PWR_WakeUpPinCmd(FunctionalState NewState)
000000  4901              LDR      r1,|L18.8|
;;;265    {
;;;266      /* Check the parameters */  
;;;267      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;268    
;;;269      *(__IO uint32_t *) CSR_EWUP_BB = (uint32_t)NewState;
000002  6008              STR      r0,[r1,#0]
;;;270    }
000004  4770              BX       lr
;;;271    
                          ENDP

000006  0000              DCW      0x0000
                  |L18.8|
                          DCD      0x420e00a0

;*** Start embedded assembler ***

#line 1 "..\\..\\..\\..\\Platform\\MCU\\STM32F4xx\\peripherals\\Libraries\\STM32F4xx_StdPeriph_Driver\\src\\stm32f4xx_pwr.c"
	AREA ||.rev16_text||, CODE
	THUMB
	EXPORT |__asm___15_stm32f4xx_pwr_c_0c2a8b75____REV16|
#line 114 "..\\..\\..\\..\\Platform\\Cortex-M4\\CMSIS\\core_cmInstr.h"
|__asm___15_stm32f4xx_pwr_c_0c2a8b75____REV16| PROC
#line 115

 rev16 r0, r0
 bx lr
	ENDP
	AREA ||.revsh_text||, CODE
	THUMB
	EXPORT |__asm___15_stm32f4xx_pwr_c_0c2a8b75____REVSH|
#line 128
|__asm___15_stm32f4xx_pwr_c_0c2a8b75____REVSH| PROC
#line 129

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
