; 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\bootloader\mico-fire_f429\obj_rvmdk\platform_mcu_powersave.o --asm_dir=..\..\..\..\Build\Bootloader\MICO-Fire_F429\list_RVMDK\ --list_dir=..\..\..\..\Build\Bootloader\MICO-Fire_F429\list_RVMDK\ --depend=..\..\..\..\build\bootloader\mico-fire_f429\obj_rvmdk\platform_mcu_powersave.d --cpu=Cortex-M4.fp --apcs=interwork --diag_suppress=9931,1,1293 -I..\..\..\..\Bootloader -I..\..\..\..\Board\fire_F429 -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 -IG:\GIT_OSC\F429_OV2640_MICO_SDRAM\Projects\STM32F429\bootloader\RVMDK\RTE -ID:\work\keil5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0\Drivers\CMSIS\Device\ST\STM32F4xx\Include -ID:\work\keil5\ARM\CMSIS\Include -ID:\work\keil5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0 -D__MICROLIB -D__UVISION_VERSION=516 -DSTM32F429xx -DUSE_STDPERIPH_DRIVER -DBOOTLOADER -DNO_MICO_RTOS -DHSE_VALUE=25000000 --omf_browse=..\..\..\..\build\bootloader\mico-fire_f429\obj_rvmdk\platform_mcu_powersave.crf ..\..\..\..\Platform\MCU\STM32F4xx\peripherals\platform_mcu_powersave.c]
                          THUMB

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

                  RTC_WKUP_irq PROC
                  ||__tagsym$$used||
;;;466    //#ifndef MICO_DISABLE_MCU_POWERSAVE
;;;467    MICO_RTOS_DEFINE_ISR( RTC_WKUP_irq )
000000  f44f0080          MOV      r0,#0x400000
;;;468    {
;;;469        EXTI_ClearITPendingBit( RTC_INTERRUPT_EXTI_LINE );
000004  f7ffbffe          B.W      EXTI_ClearITPendingBit
;;;470    }
;;;471    //#endif
                          ENDP


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

                  platform_idle_hook PROC
;;;307    
;;;308    void platform_idle_hook( void )
000000  bf30              WFI      
;;;309    {
;;;310        __asm("wfi");
;;;311    }
000002  4770              BX       lr
;;;312    
                          ENDP


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

                  platform_mcu_enter_standby PROC
;;;417    
;;;418    void platform_mcu_enter_standby(uint32_t secondsToWakeup)
000000  b530              PUSH     {r4,r5,lr}
;;;419    { 
000002  4604              MOV      r4,r0
000004  b087              SUB      sp,sp,#0x1c
;;;420      platform_rtc_time_t time;
;;;421      uint32_t currentSecond;
;;;422      RTC_AlarmTypeDef  RTC_AlarmStructure;
;;;423    
;;;424      PWR_WakeUpPinCmd(ENABLE);
000006  2001              MOVS     r0,#1
000008  f7fffffe          BL       PWR_WakeUpPinCmd
;;;425    
;;;426      if(secondsToWakeup == MICO_WAIT_FOREVER)
00000c  1c60              ADDS     r0,r4,#1
00000e  d101              BNE      |L3.20|
;;;427        PWR_EnterSTANDBYMode();
000010  f7fffffe          BL       PWR_EnterSTANDBYMode
                  |L3.20|
;;;428    
;;;429      platform_log("Wake up in %d seconds", secondsToWakeup);
;;;430     
;;;431      platform_rtc_get_time(&time);
000014  a804              ADD      r0,sp,#0x10
000016  f7fffffe          BL       platform_rtc_get_time
;;;432      currentSecond = time.hr*3600 + time.min*60 + time.sec;
00001a  f89d0012          LDRB     r0,[sp,#0x12]
00001e  f44f6161          MOV      r1,#0xe10
000022  fb10f101          SMULBB   r1,r0,r1
000026  f89d0011          LDRB     r0,[sp,#0x11]
;;;433      currentSecond += secondsToWakeup;
;;;434      RTC_AlarmStructure.RTC_AlarmTime.RTC_H12     = RTC_HourFormat_24;
;;;435      RTC_AlarmStructure.RTC_AlarmTime.RTC_Hours   = currentSecond/3600%24;
00002a  2218              MOVS     r2,#0x18
00002c  ebc01000          RSB      r0,r0,r0,LSL #4       ;432
000030  eb010080          ADD      r0,r1,r0,LSL #2       ;432
000034  f89d1010          LDRB     r1,[sp,#0x10]         ;432
000038  2300              MOVS     r3,#0                 ;434
00003a  4408              ADD      r0,r0,r1              ;432
00003c  4420              ADD      r0,r0,r4              ;433
00003e  f44f6161          MOV      r1,#0xe10
000042  fbb0f1f1          UDIV     r1,r0,r1
000046  fbb1f4f2          UDIV     r4,r1,r2
00004a  fb021114          MLS      r1,r2,r4,r1
00004e  f88d3003          STRB     r3,[sp,#3]            ;434
000052  f88d1000          STRB     r1,[sp,#0]
;;;436      RTC_AlarmStructure.RTC_AlarmTime.RTC_Minutes = currentSecond/60%60;
000056  213c              MOVS     r1,#0x3c
000058  fbb0f2f1          UDIV     r2,r0,r1
00005c  fbb2f4f1          UDIV     r4,r2,r1
000060  fb012214          MLS      r2,r1,r4,r2
000064  f88d2001          STRB     r2,[sp,#1]
;;;437      RTC_AlarmStructure.RTC_AlarmTime.RTC_Seconds = currentSecond%60;
000068  fbb0f2f1          UDIV     r2,r0,r1
00006c  fb010012          MLS      r0,r1,r2,r0
000070  f88d0002          STRB     r0,[sp,#2]
;;;438      RTC_AlarmStructure.RTC_AlarmDateWeekDay = 0x31;
000074  2031              MOVS     r0,#0x31
000076  f88d000c          STRB     r0,[sp,#0xc]
;;;439      RTC_AlarmStructure.RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
;;;440      RTC_AlarmStructure.RTC_AlarmMask = RTC_AlarmMask_DateWeekDay ;
00007a  07c0              LSLS     r0,r0,#31
;;;441    
;;;442      RTC_AlarmCmd(RTC_Alarm_A, DISABLE);
00007c  e9cd0301          STRD     r0,r3,[sp,#4]
000080  0dc4              LSRS     r4,r0,#23
000082  2100              MOVS     r1,#0
000084  4620              MOV      r0,r4
000086  f7fffffe          BL       RTC_AlarmCmd
;;;443      /* Disable the Alarm A */
;;;444      RTC_ITConfig(RTC_IT_ALRA, DISABLE);
00008a  0125              LSLS     r5,r4,#4
00008c  2100              MOVS     r1,#0
00008e  4628              MOV      r0,r5
000090  f7fffffe          BL       RTC_ITConfig
;;;445    
;;;446      /* Clear RTC Alarm Flag */ 
;;;447      RTC_ClearFlag(RTC_FLAG_ALRAF);
000094  4620              MOV      r0,r4
000096  f7fffffe          BL       RTC_ClearFlag
;;;448    
;;;449      RTC_SetAlarm(RTC_Format_BIN, RTC_Alarm_A, &RTC_AlarmStructure);
00009a  466a              MOV      r2,sp
00009c  4621              MOV      r1,r4
00009e  2000              MOVS     r0,#0
0000a0  f7fffffe          BL       RTC_SetAlarm
;;;450    
;;;451      /* Enable RTC Alarm A Interrupt: this Interrupt will wake-up the system from
;;;452         STANDBY mode (RTC Alarm IT not enabled in NVIC) */
;;;453      RTC_ITConfig(RTC_IT_ALRA, ENABLE);
0000a4  2101              MOVS     r1,#1
0000a6  4628              MOV      r0,r5
0000a8  f7fffffe          BL       RTC_ITConfig
;;;454    
;;;455      /* Enable the Alarm A */
;;;456      RTC_AlarmCmd(RTC_Alarm_A, ENABLE);
0000ac  2101              MOVS     r1,#1
0000ae  4620              MOV      r0,r4
0000b0  f7fffffe          BL       RTC_AlarmCmd
;;;457    
;;;458      PWR_EnterSTANDBYMode();
0000b4  f7fffffe          BL       PWR_EnterSTANDBYMode
;;;459    }
0000b8  b007              ADD      sp,sp,#0x1c
0000ba  bd30              POP      {r4,r5,pc}
;;;460    
                          ENDP


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

                  platform_mcu_powersave_disable PROC
;;;197    
;;;198    OSStatus platform_mcu_powersave_disable( void )
000000  b672              CPSID    i
;;;199    {
;;;200    #ifndef MICO_DISABLE_MCU_POWERSAVE
;;;201        DISABLE_INTERRUPTS;
;;;202        if ( stm32f2_clock_needed_counter <= 0 )
000002  4808              LDR      r0,|L4.36|
000004  6881              LDR      r1,[r0,#8]  ; stm32f2_clock_needed_counter
000006  2900              CMP      r1,#0
000008  dc06              BGT      |L4.24|
;;;203        {
;;;204            SCB->SCR &= (~((unsigned long)SCB_SCR_SLEEPDEEP_Msk));
00000a  4907              LDR      r1,|L4.40|
00000c  680a              LDR      r2,[r1,#0]
00000e  f0220204          BIC      r2,r2,#4
000012  600a              STR      r2,[r1,#0]
;;;205            stm32f2_clock_needed_counter = 0;
000014  2100              MOVS     r1,#0
000016  6081              STR      r1,[r0,#8]  ; stm32f2_clock_needed_counter
                  |L4.24|
000018  1c49              ADDS     r1,r1,#1
;;;206        }
;;;207        stm32f2_clock_needed_counter++;
;;;208        ENABLE_INTERRUPTS;
;;;209    
;;;210        return kNoErr;
00001a  6081              STR      r1,[r0,#8]  ; stm32f2_clock_needed_counter
00001c  b662              CPSIE    i                     ;208
00001e  2000              MOVS     r0,#0
;;;211    #else
;;;212        return kUnsupportedErr;
;;;213    #endif
;;;214    }
000020  4770              BX       lr
;;;215    
                          ENDP

000022  0000              DCW      0x0000
                  |L4.36|
                          DCD      ||.data||
                  |L4.40|
                          DCD      0xe000ed10

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

                  platform_mcu_powersave_enable PROC
;;;215    
;;;216    OSStatus platform_mcu_powersave_enable( void )
000000  4908              LDR      r1,|L5.36|
;;;217    {
;;;218    #ifndef MICO_DISABLE_MCU_POWERSAVE
;;;219        DISABLE_INTERRUPTS;
000002  b672              CPSID    i
;;;220        stm32f2_clock_needed_counter--;
000004  6888              LDR      r0,[r1,#8]  ; stm32f2_clock_needed_counter
000006  1e40              SUBS     r0,r0,#1
;;;221        if ( stm32f2_clock_needed_counter <= 0 )
000008  6088              STR      r0,[r1,#8]  ; stm32f2_clock_needed_counter
00000a  2800              CMP      r0,#0
00000c  dc06              BGT      |L5.28|
;;;222        {
;;;223            SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
00000e  4806              LDR      r0,|L5.40|
000010  6802              LDR      r2,[r0,#0]
000012  f0420204          ORR      r2,r2,#4
000016  6002              STR      r2,[r0,#0]
;;;224            stm32f2_clock_needed_counter = 0;
000018  2000              MOVS     r0,#0
00001a  6088              STR      r0,[r1,#8]  ; stm32f2_clock_needed_counter
                  |L5.28|
;;;225        }
;;;226        ENABLE_INTERRUPTS;
00001c  b662              CPSIE    i
;;;227    
;;;228        return kNoErr;
00001e  2000              MOVS     r0,#0
;;;229    #else
;;;230        return kUnsupportedErr;
;;;231    #endif
;;;232    }
000020  4770              BX       lr
;;;233    
                          ENDP

000022  0000              DCW      0x0000
                  |L5.36|
                          DCD      ||.data||
                  |L5.40|
                          DCD      0xe000ed10

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

                  platform_mcu_powersave_exit_notify PROC
;;;233    
;;;234    void platform_mcu_powersave_exit_notify( void )
000000  4901              LDR      r1,|L6.8|
;;;235    {
;;;236    #ifndef MICO_DISABLE_MCU_POWERSAVE
;;;237      UNUSED_PARAMETER( wake_up_interrupt_triggered );
;;;238      wake_up_interrupt_triggered = true;
000002  2001              MOVS     r0,#1
000004  7008              STRB     r0,[r1,#0]
;;;239    #endif
;;;240    }
000006  4770              BX       lr
;;;241    
                          ENDP

                  |L6.8|
                          DCD      ||.data||

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

                  platform_mcu_powersave_init PROC
;;;112    
;;;113    OSStatus platform_mcu_powersave_init(void)
000000  b530              PUSH     {r4,r5,lr}
;;;114    {
000002  b085              SUB      sp,sp,#0x14
;;;115    #ifndef MICO_DISABLE_MCU_POWERSAVE
;;;116      EXTI_InitTypeDef EXTI_InitStructure;
;;;117      RTC_InitTypeDef RTC_InitStruct;
;;;118      
;;;119      //RTC_DeInit( );
;;;120    
;;;121      RTC_InitStruct.RTC_HourFormat = RTC_HourFormat_24;
000004  2400              MOVS     r4,#0
;;;122      
;;;123      /* RTC ticks every second */
;;;124      RTC_InitStruct.RTC_AsynchPrediv = 0x7F;
000006  207f              MOVS     r0,#0x7f
000008  e9cd4002          STRD     r4,r0,[sp,#8]
;;;125      RTC_InitStruct.RTC_SynchPrediv = 0xFF;
00000c  20ff              MOVS     r0,#0xff
;;;126      
;;;127      RTC_Init( &RTC_InitStruct );
00000e  9004              STR      r0,[sp,#0x10]
000010  a802              ADD      r0,sp,#8
000012  f7fffffe          BL       RTC_Init
;;;128      
;;;129      /* Enable the PWR clock */
;;;130      RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
000016  2101              MOVS     r1,#1
000018  0708              LSLS     r0,r1,#28
00001a  f7fffffe          BL       RCC_APB1PeriphClockCmd
;;;131      
;;;132      /* RTC clock source configuration ------------------------------------------*/
;;;133      /* Allow access to BKP Domain */
;;;134      PWR_BackupAccessCmd(ENABLE);
00001e  2001              MOVS     r0,#1
000020  f7fffffe          BL       PWR_BackupAccessCmd
;;;135      PWR_BackupRegulatorCmd(ENABLE);
000024  2001              MOVS     r0,#1
000026  f7fffffe          BL       PWR_BackupRegulatorCmd
;;;136      
;;;137      /* Enable the LSE OSC */
;;;138      RCC_LSEConfig(RCC_LSE_ON);
00002a  2001              MOVS     r0,#1
00002c  f7fffffe          BL       RCC_LSEConfig
                  |L7.48|
;;;139      /* Wait till LSE is ready */
;;;140      while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
000030  2041              MOVS     r0,#0x41
000032  f7fffffe          BL       RCC_GetFlagStatus
000036  2800              CMP      r0,#0
000038  d0fa              BEQ      |L7.48|
;;;141      {
;;;142      }
;;;143      
;;;144      /* Select the RTC Clock Source */
;;;145      RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
00003a  f44f7080          MOV      r0,#0x100
00003e  f7fffffe          BL       RCC_RTCCLKConfig
;;;146      
;;;147      /* Enable the RTC Clock */
;;;148      RCC_RTCCLKCmd(ENABLE);
000042  2001              MOVS     r0,#1
000044  f7fffffe          BL       RCC_RTCCLKCmd
;;;149      
;;;150      
;;;151      /* RTC configuration -------------------------------------------------------*/
;;;152      /* Wait for RTC APB registers synchronisation */
;;;153      RTC_WaitForSynchro();
000048  f7fffffe          BL       RTC_WaitForSynchro
;;;154      
;;;155      RTC_WakeUpCmd( DISABLE );
00004c  2000              MOVS     r0,#0
00004e  f7fffffe          BL       RTC_WakeUpCmd
;;;156      EXTI_ClearITPendingBit( RTC_INTERRUPT_EXTI_LINE );
000052  f44f0580          MOV      r5,#0x400000
000056  4628              MOV      r0,r5
000058  f7fffffe          BL       EXTI_ClearITPendingBit
;;;157      PWR_ClearFlag(PWR_FLAG_WU);
00005c  2001              MOVS     r0,#1
00005e  f7fffffe          BL       PWR_ClearFlag
;;;158      RTC_ClearFlag(RTC_FLAG_WUTF);
000062  1328              ASRS     r0,r5,#12
000064  f7fffffe          BL       RTC_ClearFlag
;;;159      
;;;160      RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div2);
000068  2003              MOVS     r0,#3
00006a  f7fffffe          BL       RTC_WakeUpClockConfig
;;;161      
;;;162      EXTI_ClearITPendingBit( RTC_INTERRUPT_EXTI_LINE );
00006e  4628              MOV      r0,r5
000070  f7fffffe          BL       EXTI_ClearITPendingBit
;;;163      EXTI_InitStructure.EXTI_Line = RTC_INTERRUPT_EXTI_LINE;
;;;164      EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
000074  f88d4004          STRB     r4,[sp,#4]
;;;165      EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
000078  2408              MOVS     r4,#8
00007a  f88d4005          STRB     r4,[sp,#5]
;;;166      EXTI_InitStructure.EXTI_LineCmd = ENABLE;
00007e  2001              MOVS     r0,#1
000080  f88d0006          STRB     r0,[sp,#6]
000084  9500              STR      r5,[sp,#0]            ;164
;;;167      EXTI_Init(&EXTI_InitStructure);
000086  4668              MOV      r0,sp
000088  f7fffffe          BL       EXTI_Init
00008c  f04f20e0          MOV      r0,#0xe000e000
000090  f8c04100          STR      r4,[r0,#0x100]
;;;168      
;;;169      NVIC_EnableIRQ( RTC_WKUP_IRQn );
;;;170    
;;;171      RTC_ITConfig(RTC_IT_WUT, DISABLE);
000094  2100              MOVS     r1,#0
000096  02e0              LSLS     r0,r4,#11
000098  f7fffffe          BL       RTC_ITConfig
;;;172      
;;;173      /* Prepare Stop-Mode but leave disabled */
;;;174      //PWR_ClearFlag(PWR_FLAG_WU);
;;;175      PWR->CR  |= PWR_CR_LPDS;
00009c  480e              LDR      r0,|L7.216|
00009e  6801              LDR      r1,[r0,#0]
0000a0  f0410101          ORR      r1,r1,#1
0000a4  6001              STR      r1,[r0,#0]
;;;176      PWR->CR  &= (unsigned long)(~(PWR_CR_PDDS));
0000a6  6801              LDR      r1,[r0,#0]
0000a8  f0210102          BIC      r1,r1,#2
0000ac  6001              STR      r1,[r0,#0]
;;;177      SCB->SCR |= ((unsigned long)SCB_SCR_SLEEPDEEP_Msk);
0000ae  480b              LDR      r0,|L7.220|
0000b0  6801              LDR      r1,[r0,#0]
0000b2  f0410104          ORR      r1,r1,#4
0000b6  6001              STR      r1,[r0,#0]
;;;178      
;;;179    #ifdef USE_RTC_BKP
;;;180      if (RTC_ReadBackupRegister(RTC_BKP_DR0) != USE_RTC_BKP) {
0000b8  2000              MOVS     r0,#0
0000ba  f7fffffe          BL       RTC_ReadBackupRegister
0000be  4c08              LDR      r4,|L7.224|
0000c0  42a0              CMP      r0,r4
0000c2  d006              BEQ      |L7.210|
;;;181        /* set it to 12:20:30 08/04/2013 monday */
;;;182        platform_rtc_set_time(&default_rtc_time);
0000c4  4807              LDR      r0,|L7.228|
0000c6  f7fffffe          BL       platform_rtc_set_time
;;;183        RTC_WriteBackupRegister(RTC_BKP_DR0, USE_RTC_BKP);
0000ca  4621              MOV      r1,r4
0000cc  2000              MOVS     r0,#0
0000ce  f7fffffe          BL       RTC_WriteBackupRegister
                  |L7.210|
;;;184      }
;;;185    #else
;;;186      //#ifdef RTC_ENABLED
;;;187      /* application must have mico_application_default_time structure declared somewhere, otherwise it wont compile */
;;;188      /* write default application time inside rtc */
;;;189      platform_rtc_set_time( &default_rtc_time );
;;;190      //#endif /* RTC_ENABLED */
;;;191    #endif
;;;192      return kNoErr;
;;;193    #else
;;;194      return kUnsupportedErr;
;;;195    #endif
;;;196    }
0000d2  b005              ADD      sp,sp,#0x14
0000d4  2000              MOVS     r0,#0                 ;192
0000d6  bd30              POP      {r4,r5,pc}
;;;197    
                          ENDP

                  |L7.216|
                          DCD      0x40007000
                  |L7.220|
                          DCD      0xe000ed10
                  |L7.224|
                          DCD      0x00bb32f2
                  |L7.228|
                          DCD      ||.constdata||

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

                  platform_power_down_hook PROC
;;;312    
;;;313    uint32_t platform_power_down_hook( uint32_t sleep_ms )
000000  f7ffbffe          B.W      stop_mode_power_down_hook
;;;314    {
;;;315    #ifdef MICO_DISABLE_MCU_POWERSAVE
;;;316        /* If MCU powersave feature is disabled, enter idle mode when powerdown hook is called by the RTOS */
;;;317        return idle_power_down_hook( sleep_ms );
;;;318    
;;;319    #else
;;;320        /* If MCU powersave feature is enabled, enter STOP mode when powerdown hook is called by the RTOS */
;;;321        return stop_mode_power_down_hook( sleep_ms );
;;;322    
;;;323    #endif
;;;324    }
;;;325    
                          ENDP


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

                  select_wut_prescaler_calculate_wakeup_time PROC
;;;243    #ifndef MICO_DISABLE_MCU_POWERSAVE
;;;244    static OSStatus select_wut_prescaler_calculate_wakeup_time( unsigned long* wakeup_time, unsigned long sleep_ms, unsigned long* scale_factor )
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;245    {
000004  4615              MOV      r5,r2
;;;246      unsigned long temp;
;;;247      bool scale_factor_is_found = false;
000006  2200              MOVS     r2,#0
000008  460c              MOV      r4,r1                 ;245
00000a  4606              MOV      r6,r0                 ;245
;;;248      int i                              = 0;
;;;249      
;;;250      static unsigned long int available_wut_prescalers[] =
;;;251      {
;;;252        RTC_WakeUpClock_RTCCLK_Div2,
;;;253        RTC_WakeUpClock_RTCCLK_Div4,
;;;254        RTC_WakeUpClock_RTCCLK_Div8,
;;;255        RTC_WakeUpClock_RTCCLK_Div16
;;;256      };
;;;257      static unsigned long scale_factor_values[] = { 2, 4, 8, 16 };
;;;258      
;;;259      if ( sleep_ms == 0xFFFFFFFF )
;;;260      {
;;;261        /* wake up in a 100ms, since currently there may be no tasks to run, but after a few milliseconds */
;;;262        /* some of them can get unblocked( for example a task is blocked on mutex with unspecified ) */
;;;263        *scale_factor = 2;
;;;264        RTC_WakeUpClockConfig( RTC_WakeUpClock_RTCCLK_Div2 );
;;;265        *wakeup_time = NUMBER_OF_LSE_TICKS_PER_MILLISECOND( scale_factor_values[0] ) * 100;
00000c  f8df8078          LDR      r8,|L9.136|
000010  4610              MOV      r0,r2                 ;248
000012  1c49              ADDS     r1,r1,#1              ;259
000014  f04f0720          MOV      r7,#0x20
000018  d00e              BEQ      |L9.56|
00001a  463b              MOV      r3,r7
;;;266      }
;;;267      else
;;;268      {
;;;269        for ( i = 0; i < 4; i++ )
;;;270        {
;;;271          temp = NUMBER_OF_LSE_TICKS_PER_MILLISECOND( scale_factor_values[i] ) * sleep_ms;
;;;272          if ( temp < WUT_COUNTER_MAX )
00001c  f64f77ff          MOV      r7,#0xffff
                  |L9.32|
000020  f8581020          LDR      r1,[r8,r0,LSL #2]     ;271
000024  fbb3f1f1          UDIV     r1,r3,r1              ;271
000028  4361              MULS     r1,r4,r1              ;271
00002a  42b9              CMP      r1,r7
00002c  d211              BCS      |L9.82|
;;;273          {
;;;274            scale_factor_is_found = true;
;;;275            *wakeup_time = temp;
;;;276            *scale_factor = scale_factor_values[i];
00002e  6031              STR      r1,[r6,#0]
000030  f8581020          LDR      r1,[r8,r0,LSL #2]
;;;277            break;
000034  6029              STR      r1,[r5,#0]
000036  e010              B        |L9.90|
                  |L9.56|
000038  2002              MOVS     r0,#2                 ;263
00003a  6028              STR      r0,[r5,#0]            ;264
00003c  2003              MOVS     r0,#3                 ;264
00003e  f7fffffe          BL       RTC_WakeUpClockConfig
000042  f8d81000          LDR      r1,[r8,#0]            ;265  ; scale_factor_values
000046  fbb7f0f1          UDIV     r0,r7,r1              ;265
00004a  2164              MOVS     r1,#0x64              ;265
00004c  4348              MULS     r0,r1,r0              ;265
00004e  6030              STR      r0,[r6,#0]            ;265
000050  e009              B        |L9.102|
                  |L9.82|
000052  1c40              ADDS     r0,r0,#1              ;265
000054  2804              CMP      r0,#4                 ;269
000056  dbe3              BLT      |L9.32|
;;;278          }
;;;279        }
;;;280        if ( scale_factor_is_found )
000058  b142              CBZ      r2,|L9.108|
                  |L9.90|
;;;281        {
;;;282          /* set new prescaler for wakeup timer */
;;;283          RTC_WakeUpClockConfig( available_wut_prescalers[i] );
00005a  490b              LDR      r1,|L9.136|
00005c  3910              SUBS     r1,r1,#0x10
00005e  f8510020          LDR      r0,[r1,r0,LSL #2]
000062  f7fffffe          BL       RTC_WakeUpClockConfig
                  |L9.102|
;;;284        }
;;;285        else
;;;286        {
;;;287          /* scale factor can not be picked up for delays more that 32 seconds when RTCLK is selected as a clock source for the wakeup timer
;;;288          * for delays more than 32 seconds change from RTCCLK to 1Hz ck_spre clock source( used to update calendar registers ) */
;;;289          RTC_WakeUpClockConfig( RTC_WakeUpClock_CK_SPRE_16bits );
;;;290          
;;;291          /* with 1Hz ck_spre clock source the resolution changes to seconds  */
;;;292          *wakeup_time = ( sleep_ms / 1000 ) + 1;
;;;293          *scale_factor = CK_SPRE_CLOCK_SOURCE_SELECTED;
;;;294          
;;;295          return kGeneralErr;
;;;296        }
;;;297      }
;;;298      
;;;299      return kNoErr;
000066  2000              MOVS     r0,#0
                  |L9.104|
;;;300    }
000068  e8bd81f0          POP      {r4-r8,pc}
                  |L9.108|
00006c  2004              MOVS     r0,#4                 ;289
00006e  f7fffffe          BL       RTC_WakeUpClockConfig
000072  f44f707a          MOV      r0,#0x3e8             ;292
000076  fbb4f0f0          UDIV     r0,r4,r0              ;292
00007a  1c40              ADDS     r0,r0,#1              ;292
00007c  6030              STR      r0,[r6,#0]            ;293
00007e  f04f30ff          MOV      r0,#0xffffffff        ;295
000082  602f              STR      r7,[r5,#0]            ;295
000084  e7f0              B        |L9.104|
;;;301    #endif
                          ENDP

000086  0000              DCW      0x0000
                  |L9.136|
                          DCD      ||.data||+0x1c

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

                  stop_mode_power_down_hook PROC
;;;335    #else
;;;336    static unsigned long stop_mode_power_down_hook( unsigned long sleep_ms )
000000  e92d41fc          PUSH     {r2-r8,lr}
;;;337    {
;;;338      unsigned long retval;
;;;339      unsigned long wut_ticks_passed;
;;;340      unsigned long scale_factor = 0;
;;;341      UNUSED_PARAMETER(sleep_ms);
;;;342      UNUSED_PARAMETER(rtc_timeout_start_time);
;;;343      UNUSED_PARAMETER(scale_factor);
;;;344      
;;;345      if ( ( ( SCB->SCR & (unsigned long)SCB_SCR_SLEEPDEEP_Msk) != 0) && sleep_ms < 5 ){
000004  4a2f              LDR      r2,|L10.196|
000006  2600              MOVS     r6,#0                 ;340
000008  4605              MOV      r5,r0                 ;337
00000a  9601              STR      r6,[sp,#4]
00000c  6810              LDR      r0,[r2,#0]
00000e  0740              LSLS     r0,r0,#29
000010  d50c              BPL      |L10.44|
000012  2d05              CMP      r5,#5
000014  d20a              BCS      |L10.44|
;;;346        SCB->SCR &= (~((unsigned long)SCB_SCR_SLEEPDEEP_Msk));
000016  6810              LDR      r0,[r2,#0]
000018  f0200004          BIC      r0,r0,#4
00001c  6010              STR      r0,[r2,#0]
;;;347        __asm("wfi");
00001e  bf30              WFI      
;;;348        SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
000020  6810              LDR      r0,[r2,#0]
000022  f0400004          ORR      r0,r0,#4
000026  6010              STR      r0,[r2,#0]
;;;349        /* Note: We return 0 ticks passed because system tick is still going when wfi instruction gets executed */
;;;350        ENABLE_INTERRUPTS;
000028  b662              CPSIE    i
;;;351        return 0;
00002a  e049              B        |L10.192|
                  |L10.44|
;;;352      }
;;;353      
;;;354      if ( ( ( SCB->SCR & (unsigned long)SCB_SCR_SLEEPDEEP_Msk) ) != 0 )
00002c  6810              LDR      r0,[r2,#0]
00002e  0740              LSLS     r0,r0,#29
000030  d544              BPL      |L10.188|
;;;355      {
;;;356        /* pick up the appropriate prescaler for a requested delay */
;;;357        select_wut_prescaler_calculate_wakeup_time(&rtc_timeout_start_time, sleep_ms, &scale_factor );
000032  aa01              ADD      r2,sp,#4
000034  4629              MOV      r1,r5
000036  4824              LDR      r0,|L10.200|
000038  f7fffffe          BL       select_wut_prescaler_calculate_wakeup_time
;;;358    
;;;359        DISABLE_INTERRUPTS;
;;;360        
;;;361        SysTick->CTRL &= (~(SysTick_CTRL_TICKINT_Msk|SysTick_CTRL_ENABLE_Msk)); /* systick IRQ off */
00003c  f04f24e0          MOV      r4,#0xe000e000
000040  b672              CPSID    i                     ;359
000042  6920              LDR      r0,[r4,#0x10]
000044  f0200003          BIC      r0,r0,#3
000048  6120              STR      r0,[r4,#0x10]
;;;362        RTC_ITConfig(RTC_IT_WUT, ENABLE);
00004a  f44f4880          MOV      r8,#0x4000
00004e  2101              MOVS     r1,#1
000050  4640              MOV      r0,r8
000052  f7fffffe          BL       RTC_ITConfig
;;;363        
;;;364        EXTI_ClearITPendingBit( RTC_INTERRUPT_EXTI_LINE );
000056  f44f0080          MOV      r0,#0x400000
00005a  f7fffffe          BL       EXTI_ClearITPendingBit
;;;365        PWR_ClearFlag(PWR_FLAG_WU);
00005e  2001              MOVS     r0,#1
000060  f7fffffe          BL       PWR_ClearFlag
;;;366        RTC_ClearFlag(RTC_FLAG_WUTF);
000064  f44f6080          MOV      r0,#0x400
000068  f7fffffe          BL       RTC_ClearFlag
;;;367        
;;;368        RTC_SetWakeUpCounter( rtc_timeout_start_time );
00006c  4f16              LDR      r7,|L10.200|
00006e  1f3f              SUBS     r7,r7,#4
000070  6878              LDR      r0,[r7,#4]  ; rtc_timeout_start_time
000072  f7fffffe          BL       RTC_SetWakeUpCounter
;;;369        RTC_WakeUpCmd( ENABLE );
000076  2001              MOVS     r0,#1
000078  f7fffffe          BL       RTC_WakeUpCmd
;;;370        platform_rtc_enter_powersave();
00007c  f7fffffe          BL       platform_rtc_enter_powersave
;;;371        
;;;372        DBGMCU->CR |= 0x03; /* Enable debug in stop mode */
000080  4812              LDR      r0,|L10.204|
000082  6841              LDR      r1,[r0,#4]
000084  f0410103          ORR      r1,r1,#3
000088  6041              STR      r1,[r0,#4]
;;;373        
;;;374        /* This code will be running with BASEPRI register value set to 0, the main intention behind that is that */
;;;375        /* all interrupts must be allowed to wake the CPU from the power-down mode */
;;;376        /* the PRIMASK is set to 1( see DISABLE_INTERRUPTS), thus we disable all interrupts before entering the power-down mode */
;;;377        /* This may sound contradictory, however according to the ARM CM3 documentation power-management unit */
;;;378        /* takes into account only the contents of the BASEPRI register and it is an external from the CPU core unit */
;;;379        /* PRIMASK register value doesn't affect its operation. */
;;;380        /* So, if the interrupt has been triggered just before the wfi instruction */
;;;381        /* it remains pending and wfi instruction will be treated as a nop  */
;;;382        __asm("wfi");
00008a  bf30              WFI      
;;;383        
;;;384        /* After CPU exits powerdown mode, the processer will not execute the interrupt handler(PRIMASK is set to 1) */
;;;385        /* Disable rtc for now */
;;;386        RTC_WakeUpCmd( DISABLE );
00008c  2000              MOVS     r0,#0
00008e  f7fffffe          BL       RTC_WakeUpCmd
;;;387        RTC_ITConfig(RTC_IT_WUT, DISABLE);
000092  2100              MOVS     r1,#0
000094  4640              MOV      r0,r8
000096  f7fffffe          BL       RTC_ITConfig
;;;388        
;;;389        /* Initialise the clocks again */
;;;390        init_clocks( );
00009a  f7fffffe          BL       init_clocks
;;;391        
;;;392        /* Enable CPU ticks */
;;;393        SysTick->CTRL |= (SysTick_CTRL_TICKINT_Msk|SysTick_CTRL_ENABLE_Msk);
00009e  6920              LDR      r0,[r4,#0x10]
0000a0  f0400003          ORR      r0,r0,#3
0000a4  6120              STR      r0,[r4,#0x10]
;;;394        
;;;395        /* Get the time of how long the sleep lasted */
;;;396        wut_ticks_passed = rtc_timeout_start_time - RTC_GetWakeUpCounter();
0000a6  f7fffffe          BL       RTC_GetWakeUpCounter
;;;397        UNUSED_VARIABLE(wut_ticks_passed);
;;;398        platform_rtc_exit_powersave( sleep_ms, (uint32_t *)&retval );
0000aa  4669              MOV      r1,sp
0000ac  4628              MOV      r0,r5
0000ae  f7fffffe          BL       platform_rtc_exit_powersave
;;;399        /* as soon as interrupts are enabled, we will go and execute the interrupt handler */
;;;400        /* which triggered a wake up event */
;;;401        ENABLE_INTERRUPTS;
;;;402        wake_up_interrupt_triggered = false;
0000b2  703e              STRB     r6,[r7,#0]
0000b4  b662              CPSIE    i                     ;401
;;;403        return retval;
0000b6  9800              LDR      r0,[sp,#0]
                  |L10.184|
;;;404      }
;;;405      else
;;;406      {
;;;407        UNUSED_PARAMETER(wut_ticks_passed);
;;;408        ENABLE_INTERRUPTS;
;;;409        __asm("wfi");
;;;410        
;;;411        /* Note: We return 0 ticks passed because system tick is still going when wfi instruction gets executed */
;;;412        return 0;
;;;413      }
;;;414    }
0000b8  e8bd81fc          POP      {r2-r8,pc}
                  |L10.188|
0000bc  b662              CPSIE    i                     ;408
0000be  bf30              WFI                            ;409
                  |L10.192|
0000c0  2000              MOVS     r0,#0                 ;412
0000c2  e7f9              B        |L10.184|
;;;415    #endif /* MICO_DISABLE_MCU_POWERSAVE */
                          ENDP

                  |L10.196|
                          DCD      0xe000ed10
                  |L10.200|
                          DCD      ||.data||+0x4
                  |L10.204|
                          DCD      0xe0042000

                          AREA ||.constdata||, DATA, READONLY, ALIGN=0

                  default_rtc_time
000000  1e140c01          DCB      0x1e,0x14,0x0c,0x01
000004  08040d            DCB      0x08,0x04,0x0d

                          AREA ||.data||, DATA, ALIGN=2

                  wake_up_interrupt_triggered
000000  00000000          DCB      0x00,0x00,0x00,0x00
                  rtc_timeout_start_time
                          DCD      0x00000000
                  stm32f2_clock_needed_counter
                          DCD      0x00000000
                  available_wut_prescalers
                          DCD      0x00000003
                          DCD      0x00000002
                          DCD      0x00000001
                          DCD      0x00000000
                  scale_factor_values
                          DCD      0x00000002
                          DCD      0x00000004
                          DCD      0x00000008
                          DCD      0x00000010

;*** Start embedded assembler ***

#line 1 "..\\..\\..\\..\\Platform\\MCU\\STM32F4xx\\peripherals\\platform_mcu_powersave.c"
	AREA ||.rev16_text||, CODE
	THUMB
	EXPORT |__asm___24_platform_mcu_powersave_c_669374f9____REV16|
#line 114 "..\\..\\..\\..\\Platform\\Cortex-M4\\CMSIS\\core_cmInstr.h"
|__asm___24_platform_mcu_powersave_c_669374f9____REV16| PROC
#line 115

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

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
