AGV / agv_shengyiPPxiaoche · Files

; generated by Component: ARM Compiler 5.06 update 6 (build 750) Tool: ArmCC [4d3637]
; commandline ArmCC [--c99 --list --split_sections --debug -c --asm --interleave -o.\flash\obj\stm32f4xx_rtc.o --asm_dir=.\Flash\List\ --list_dir=.\Flash\List\ --depend=.\flash\obj\stm32f4xx_rtc.d --cpu=Cortex-M4.fp --apcs=interwork -O1 --diag_suppress=9931,870 -I..\..\Libraries\CMSIS\Include -I..\..\Libraries\CMSIS\Device\ST\STM32F4xx\Include -I..\..\Libraries\STM32F4xx_StdPeriph_Driver\inc -I..\..\uCOS-III\uC-CPU -I..\..\uCOS-III\uC-LIB -I..\..\uCOS-III\uCOS-III\Ports -I..\..\uCOS-III\uCOS-III\Source -I..\..\uCOS-III\uC-CPU\ARM-Cortex-M4\RealView -I..\..\uCOS-III\uC-LIB\Ports\ARM-Cortex-M4\RealView -I..\..\uCOS-III\uCOS-III\Ports\ARM-Cortex-M4\Generic\RealView -I..\..\User -I..\..\User\bsp -I..\..\User\bsp\inc -I..\..\User\libapp -I..\..\RL-ARM\Config -I..\..\RL-ARM\Driver -I..\..\RL-ARM\RL-RTX\inc -I..\..\User\bsp\BSP -I..\..\RL-ARM\RL-CAN -I..\..\Libraries\DSP_LIB\Include -I..\..\MODBUS\modbus\rtu -I..\..\MODBUS\BARE\port -I..\..\MODBUS\modbus\include -I..\..\User\bsp\BSP -I..\..\PLC -I..\..\Avoid -I..\..\User\parameter -I..\..\User\LaserMotionCtr -I..\..\User\W5100S -I..\..\User\bsp -I..\..\User\CHASSIS -I..\..\User\CONTROLFUNCTION -I..\..\User\DATAUPDATE -I..\..\User\HARAWARE -I..\..\User\MOTORDRIVER -I..\..\User\NAVAGATION -I..\..\User\PLATFORM -I..\..\User\SENSOR -I.\RTE\_Flash -IC:\Users\YDJ\AppData\Local\Arm\Packs\ARM\CMSIS\5.5.1\CMSIS\Core\Include -IC:\Users\YDJ\AppData\Local\Arm\Packs\Keil\STM32F4xx_DFP\2.13.0\Drivers\CMSIS\Device\ST\STM32F4xx\Include -D__UVISION_VERSION=527 -D_RTE_ -DSTM32F407xx -DUSE_STDPERIPH_DRIVER -DSTM32F40_41xxx -D__RTX -D__FPU_USED=1 --omf_browse=.\flash\obj\stm32f4xx_rtc.crf ..\..\Libraries\STM32F4xx_StdPeriph_Driver\src\stm32f4xx_rtc.c]
                          THUMB

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

                  RTC_AlarmCmd PROC
;;;1309     */
;;;1310   ErrorStatus RTC_AlarmCmd(uint32_t RTC_Alarm, FunctionalState NewState)
000000  b538              PUSH     {r3-r5,lr}
;;;1311   {
;;;1312     __IO uint32_t alarmcounter = 0x00;
000002  2200              MOVS     r2,#0
000004  9200              STR      r2,[sp,#0]
;;;1313     uint32_t alarmstatus = 0x00;
;;;1314     ErrorStatus status = ERROR;
;;;1315       
;;;1316     /* Check the parameters */
;;;1317     assert_param(IS_RTC_CMD_ALARM(RTC_Alarm));
;;;1318     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1319   
;;;1320     /* Disable the write protection for RTC registers */
;;;1321     RTC->WPR = 0xCA;
000006  4c14              LDR      r4,|L1.88|
000008  22ca              MOVS     r2,#0xca
00000a  6022              STR      r2,[r4,#0]
;;;1322     RTC->WPR = 0x53;
00000c  2253              MOVS     r2,#0x53
00000e  6022              STR      r2,[r4,#0]
;;;1323   
;;;1324     /* Configure the Alarm state */
;;;1325     if (NewState != DISABLE)
;;;1326     {
;;;1327       RTC->CR |= (uint32_t)RTC_Alarm;
000010  4a11              LDR      r2,|L1.88|
000012  3a1c              SUBS     r2,r2,#0x1c
000014  2900              CMP      r1,#0                 ;1325
000016  d004              BEQ      |L1.34|
000018  6811              LDR      r1,[r2,#0]
00001a  4301              ORRS     r1,r1,r0
00001c  6011              STR      r1,[r2,#0]
;;;1328   
;;;1329       status = SUCCESS;    
00001e  2001              MOVS     r0,#1
000020  e015              B        |L1.78|
                  |L1.34|
;;;1330     }
;;;1331     else
;;;1332     { 
;;;1333       /* Disable the Alarm in RTC_CR register */
;;;1334       RTC->CR &= (uint32_t)~RTC_Alarm;
000022  6811              LDR      r1,[r2,#0]
000024  4381              BICS     r1,r1,r0
000026  6011              STR      r1,[r2,#0]
;;;1335      
;;;1336       /* Wait till RTC ALRxWF flag is set and if Time out is reached exit */
;;;1337       do
;;;1338       {
;;;1339         alarmstatus = RTC->ISR & (RTC_Alarm >> 8);
000028  4a0b              LDR      r2,|L1.88|
00002a  3a18              SUBS     r2,r2,#0x18
;;;1340         alarmcounter++;  
;;;1341       } while((alarmcounter != INITMODE_TIMEOUT) && (alarmstatus == 0x00));
00002c  1395              ASRS     r5,r2,#14
                  |L1.46|
00002e  6811              LDR      r1,[r2,#0]            ;1339
000030  ea012110          AND      r1,r1,r0,LSR #8       ;1339
000034  9b00              LDR      r3,[sp,#0]            ;1340
000036  1c5b              ADDS     r3,r3,#1              ;1340
000038  9300              STR      r3,[sp,#0]            ;1340
00003a  9b00              LDR      r3,[sp,#0]
00003c  42ab              CMP      r3,r5
00003e  d001              BEQ      |L1.68|
000040  2900              CMP      r1,#0
000042  d0f4              BEQ      |L1.46|
                  |L1.68|
;;;1342       
;;;1343       if ((RTC->ISR & (RTC_Alarm >> 8)) == RESET)
000044  6811              LDR      r1,[r2,#0]
000046  ea112f10          TST      r1,r0,LSR #8
00004a  d003              BEQ      |L1.84|
;;;1344       {
;;;1345         status = ERROR;
;;;1346       } 
;;;1347       else
;;;1348       {
;;;1349         status = SUCCESS;
00004c  2001              MOVS     r0,#1
                  |L1.78|
;;;1350       }        
;;;1351     } 
;;;1352   
;;;1353     /* Enable the write protection for RTC registers */
;;;1354     RTC->WPR = 0xFF; 
00004e  21ff              MOVS     r1,#0xff
000050  6021              STR      r1,[r4,#0]
;;;1355     
;;;1356     return status;
;;;1357   }
000052  bd38              POP      {r3-r5,pc}
                  |L1.84|
000054  2000              MOVS     r0,#0                 ;1345
000056  e7fa              B        |L1.78|
;;;1358   
                          ENDP

                  |L1.88|
                          DCD      0x40002824

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

                  RTC_AlarmStructInit PROC
;;;1225     */
;;;1226   void RTC_AlarmStructInit(RTC_AlarmTypeDef* RTC_AlarmStruct)
000000  2100              MOVS     r1,#0
;;;1227   {
;;;1228     /* Alarm Time Settings : Time = 00h:00mn:00sec */
;;;1229     RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = RTC_H12_AM;
000002  70c1              STRB     r1,[r0,#3]
;;;1230     RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours = 0;
000004  7001              STRB     r1,[r0,#0]
;;;1231     RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes = 0;
000006  7041              STRB     r1,[r0,#1]
;;;1232     RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds = 0;
000008  7081              STRB     r1,[r0,#2]
;;;1233   
;;;1234     /* Alarm Date Settings : Date = 1st day of the month */
;;;1235     RTC_AlarmStruct->RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
00000a  6081              STR      r1,[r0,#8]
;;;1236     RTC_AlarmStruct->RTC_AlarmDateWeekDay = 1;
00000c  2201              MOVS     r2,#1
00000e  7302              STRB     r2,[r0,#0xc]
;;;1237   
;;;1238     /* Alarm Masks Settings : Mask =  all fields are not masked */
;;;1239     RTC_AlarmStruct->RTC_AlarmMask = RTC_AlarmMask_None;
000010  6041              STR      r1,[r0,#4]
;;;1240   }
000012  4770              BX       lr
;;;1241   
                          ENDP


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

                  RTC_AlarmSubSecondConfig PROC
;;;1403     */
;;;1404   void RTC_AlarmSubSecondConfig(uint32_t RTC_Alarm, uint32_t RTC_AlarmSubSecondValue, uint32_t RTC_AlarmSubSecondMask)
000000  b510              PUSH     {r4,lr}
;;;1405   {
;;;1406     uint32_t tmpreg = 0;
;;;1407   
;;;1408     /* Check the parameters */
;;;1409     assert_param(IS_RTC_ALARM(RTC_Alarm));
;;;1410     assert_param(IS_RTC_ALARM_SUB_SECOND_VALUE(RTC_AlarmSubSecondValue));
;;;1411     assert_param(IS_RTC_ALARM_SUB_SECOND_MASK(RTC_AlarmSubSecondMask));
;;;1412     
;;;1413     /* Disable the write protection for RTC registers */
;;;1414     RTC->WPR = 0xCA;
000002  4b09              LDR      r3,|L3.40|
000004  24ca              MOVS     r4,#0xca
000006  601c              STR      r4,[r3,#0]
;;;1415     RTC->WPR = 0x53;
000008  2453              MOVS     r4,#0x53
00000a  601c              STR      r4,[r3,#0]
;;;1416     
;;;1417     /* Configure the Alarm A or Alarm B Sub Second registers */
;;;1418     tmpreg = (uint32_t) (uint32_t)(RTC_AlarmSubSecondValue) | (uint32_t)(RTC_AlarmSubSecondMask);
00000c  4311              ORRS     r1,r1,r2
;;;1419     
;;;1420     if (RTC_Alarm == RTC_Alarm_A)
00000e  f5b07f80          CMP      r0,#0x100
000012  d005              BEQ      |L3.32|
;;;1421     {
;;;1422       /* Configure the Alarm A Sub Second register */
;;;1423       RTC->ALRMASSR = tmpreg;
;;;1424     }
;;;1425     else
;;;1426     {
;;;1427       /* Configure the Alarm B Sub Second register */
;;;1428       RTC->ALRMBSSR = tmpreg;
000014  4804              LDR      r0,|L3.40|
000016  3024              ADDS     r0,r0,#0x24
000018  6001              STR      r1,[r0,#0]
                  |L3.26|
;;;1429     }
;;;1430   
;;;1431     /* Enable the write protection for RTC registers */
;;;1432     RTC->WPR = 0xFF;
00001a  20ff              MOVS     r0,#0xff
00001c  6018              STR      r0,[r3,#0]
;;;1433   
;;;1434   }
00001e  bd10              POP      {r4,pc}
                  |L3.32|
000020  4801              LDR      r0,|L3.40|
000022  3020              ADDS     r0,r0,#0x20           ;1423
000024  6001              STR      r1,[r0,#0]            ;1423
000026  e7f8              B        |L3.26|
;;;1435   
                          ENDP

                  |L3.40|
                          DCD      0x40002824

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

                  RTC_Bcd2ToByte PROC
;;;2741     */
;;;2742   static uint8_t RTC_Bcd2ToByte(uint8_t Value)
000000  0901              LSRS     r1,r0,#4
;;;2743   {
;;;2744     uint8_t tmp = 0;
;;;2745     tmp = ((uint8_t)(Value & (uint8_t)0xF0) >> (uint8_t)0x4) * 10;
000002  eb010181          ADD      r1,r1,r1,LSL #2
000006  0049              LSLS     r1,r1,#1
;;;2746     return (tmp + (Value & (uint8_t)0x0F));
000008  f000000f          AND      r0,r0,#0xf
00000c  4408              ADD      r0,r0,r1
00000e  b2c0              UXTB     r0,r0
;;;2747   }
000010  4770              BX       lr
;;;2748   
                          ENDP


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

                  RTC_BypassShadowCmd PROC
;;;709    */
;;;710    void RTC_BypassShadowCmd(FunctionalState NewState)
000000  4a0a              LDR      r2,|L5.44|
;;;711    {
;;;712      /* Check the parameters */
;;;713      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;714    
;;;715      /* Disable the write protection for RTC registers */
;;;716      RTC->WPR = 0xCA;
000002  21ca              MOVS     r1,#0xca
000004  6011              STR      r1,[r2,#0]
;;;717      RTC->WPR = 0x53;
000006  2153              MOVS     r1,#0x53
000008  6011              STR      r1,[r2,#0]
;;;718      
;;;719      if (NewState != DISABLE)
;;;720      {
;;;721        /* Set the BYPSHAD bit */
;;;722        RTC->CR |= (uint8_t)RTC_CR_BYPSHAD;
00000a  4908              LDR      r1,|L5.44|
00000c  391c              SUBS     r1,r1,#0x1c
00000e  2800              CMP      r0,#0                 ;719
000010  d004              BEQ      |L5.28|
000012  6808              LDR      r0,[r1,#0]
000014  f0400020          ORR      r0,r0,#0x20
000018  6008              STR      r0,[r1,#0]
00001a  e003              B        |L5.36|
                  |L5.28|
;;;723      }
;;;724      else
;;;725      {
;;;726        /* Reset the BYPSHAD bit */
;;;727        RTC->CR &= (uint8_t)~RTC_CR_BYPSHAD;
00001c  6808              LDR      r0,[r1,#0]
00001e  f00000df          AND      r0,r0,#0xdf
000022  6008              STR      r0,[r1,#0]
                  |L5.36|
;;;728      }
;;;729    
;;;730      /* Enable the write protection for RTC registers */
;;;731      RTC->WPR = 0xFF;
000024  20ff              MOVS     r0,#0xff
000026  6010              STR      r0,[r2,#0]
;;;732    }
000028  4770              BX       lr
;;;733    
                          ENDP

00002a  0000              DCW      0x0000
                  |L5.44|
                          DCD      0x40002824

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

                  RTC_ByteToBcd2 PROC
;;;2723     */
;;;2724   static uint8_t RTC_ByteToBcd2(uint8_t Value)
000000  2100              MOVS     r1,#0
;;;2725   {
000002  e003              B        |L6.12|
                  |L6.4|
;;;2726     uint8_t bcdhigh = 0;
;;;2727     
;;;2728     while (Value >= 10)
;;;2729     {
;;;2730       bcdhigh++;
000004  1c49              ADDS     r1,r1,#1
000006  b2c9              UXTB     r1,r1
;;;2731       Value -= 10;
000008  380a              SUBS     r0,r0,#0xa
00000a  b2c0              UXTB     r0,r0
                  |L6.12|
00000c  280a              CMP      r0,#0xa               ;2728
00000e  d2f9              BCS      |L6.4|
;;;2732     }
;;;2733     
;;;2734     return  ((uint8_t)(bcdhigh << 4) | Value);
000010  0709              LSLS     r1,r1,#28
000012  ea406011          ORR      r0,r0,r1,LSR #24
;;;2735   }
000016  4770              BX       lr
;;;2736   
                          ENDP


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

                  RTC_CalibOutputCmd PROC
;;;1837     */
;;;1838   void RTC_CalibOutputCmd(FunctionalState NewState)
000000  4a0a              LDR      r2,|L7.44|
;;;1839   {
;;;1840     /* Check the parameters */
;;;1841     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1842     
;;;1843     /* Disable the write protection for RTC registers */
;;;1844     RTC->WPR = 0xCA;
000002  21ca              MOVS     r1,#0xca
000004  6011              STR      r1,[r2,#0]
;;;1845     RTC->WPR = 0x53;
000006  2153              MOVS     r1,#0x53
000008  6011              STR      r1,[r2,#0]
;;;1846     
;;;1847     if (NewState != DISABLE)
;;;1848     {
;;;1849       /* Enable the RTC clock output */
;;;1850       RTC->CR |= (uint32_t)RTC_CR_COE;
00000a  4908              LDR      r1,|L7.44|
00000c  391c              SUBS     r1,r1,#0x1c
00000e  2800              CMP      r0,#0                 ;1847
000010  d004              BEQ      |L7.28|
000012  6808              LDR      r0,[r1,#0]
000014  f4400000          ORR      r0,r0,#0x800000
000018  6008              STR      r0,[r1,#0]
00001a  e003              B        |L7.36|
                  |L7.28|
;;;1851     }
;;;1852     else
;;;1853     { 
;;;1854       /* Disable the RTC clock output */
;;;1855       RTC->CR &= (uint32_t)~RTC_CR_COE;
00001c  6808              LDR      r0,[r1,#0]
00001e  f4200000          BIC      r0,r0,#0x800000
000022  6008              STR      r0,[r1,#0]
                  |L7.36|
;;;1856     }
;;;1857     
;;;1858     /* Enable the write protection for RTC registers */
;;;1859     RTC->WPR = 0xFF; 
000024  20ff              MOVS     r0,#0xff
000026  6010              STR      r0,[r2,#0]
;;;1860   }
000028  4770              BX       lr
;;;1861   
                          ENDP

00002a  0000              DCW      0x0000
                  |L7.44|
                          DCD      0x40002824

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

                  RTC_CalibOutputConfig PROC
;;;1869   */
;;;1870   void RTC_CalibOutputConfig(uint32_t RTC_CalibOutput)
000000  4a08              LDR      r2,|L8.36|
;;;1871   {
;;;1872     /* Check the parameters */
;;;1873     assert_param(IS_RTC_CALIB_OUTPUT(RTC_CalibOutput));
;;;1874   
;;;1875     /* Disable the write protection for RTC registers */
;;;1876     RTC->WPR = 0xCA;
000002  21ca              MOVS     r1,#0xca
000004  6011              STR      r1,[r2,#0]
;;;1877     RTC->WPR = 0x53;
000006  2153              MOVS     r1,#0x53
000008  6011              STR      r1,[r2,#0]
;;;1878     
;;;1879     /*clear flags before configuration */
;;;1880     RTC->CR &= (uint32_t)~(RTC_CR_COSEL);
00000a  4906              LDR      r1,|L8.36|
00000c  391c              SUBS     r1,r1,#0x1c
00000e  680b              LDR      r3,[r1,#0]
000010  f4232300          BIC      r3,r3,#0x80000
000014  600b              STR      r3,[r1,#0]
;;;1881   
;;;1882     /* Configure the RTC_CR register */
;;;1883     RTC->CR |= (uint32_t)RTC_CalibOutput;
000016  680b              LDR      r3,[r1,#0]
000018  4303              ORRS     r3,r3,r0
00001a  600b              STR      r3,[r1,#0]
;;;1884   
;;;1885     /* Enable the write protection for RTC registers */
;;;1886     RTC->WPR = 0xFF;
00001c  20ff              MOVS     r0,#0xff
00001e  6010              STR      r0,[r2,#0]
;;;1887   }
000020  4770              BX       lr
;;;1888   
                          ENDP

000022  0000              DCW      0x0000
                  |L8.36|
                          DCD      0x40002824

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

                  RTC_ClearFlag PROC
;;;2640     */
;;;2641   void RTC_ClearFlag(uint32_t RTC_FLAG)
000000  b280              UXTH     r0,r0
;;;2642   {
;;;2643     /* Check the parameters */
;;;2644     assert_param(IS_RTC_CLEAR_FLAG(RTC_FLAG));
;;;2645   
;;;2646     /* Clear the Flags in the RTC_ISR register */
;;;2647     RTC->ISR = (uint32_t)((uint32_t)(~((RTC_FLAG | RTC_ISR_INIT)& 0x0000FFFF) | (uint32_t)(RTC->ISR & RTC_ISR_INIT)));  
000002  f0400080          ORR      r0,r0,#0x80
000006  43c1              MVNS     r1,r0
000008  4803              LDR      r0,|L9.24|
00000a  6802              LDR      r2,[r0,#0]
00000c  f0020280          AND      r2,r2,#0x80
000010  4311              ORRS     r1,r1,r2
000012  6001              STR      r1,[r0,#0]
;;;2648   }
000014  4770              BX       lr
;;;2649   
                          ENDP

000016  0000              DCW      0x0000
                  |L9.24|
                          DCD      0x4000280c

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

                  RTC_ClearITPendingBit PROC
;;;2700     */
;;;2701   void RTC_ClearITPendingBit(uint32_t RTC_IT)
000000  0900              LSRS     r0,r0,#4
;;;2702   {
;;;2703     uint32_t tmpreg = 0;
;;;2704   
;;;2705     /* Check the parameters */
;;;2706     assert_param(IS_RTC_CLEAR_IT(RTC_IT));
;;;2707   
;;;2708     /* Get the RTC_ISR Interrupt pending bits mask */
;;;2709     tmpreg = (uint32_t)(RTC_IT >> 4);
;;;2710   
;;;2711     /* Clear the interrupt pending bits in the RTC_ISR register */
;;;2712     RTC->ISR = (uint32_t)((uint32_t)(~((tmpreg | RTC_ISR_INIT)& 0x0000FFFF) | (uint32_t)(RTC->ISR & RTC_ISR_INIT))); 
000002  b280              UXTH     r0,r0
000004  f0400080          ORR      r0,r0,#0x80
000008  43c1              MVNS     r1,r0
00000a  4803              LDR      r0,|L10.24|
00000c  6802              LDR      r2,[r0,#0]
00000e  f0020280          AND      r2,r2,#0x80
000012  4311              ORRS     r1,r1,r2
000014  6001              STR      r1,[r0,#0]
;;;2713   }
000016  4770              BX       lr
;;;2714   
                          ENDP

                  |L10.24|
                          DCD      0x4000280c

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

                  RTC_CoarseCalibCmd PROC
;;;1791     */
;;;1792   ErrorStatus RTC_CoarseCalibCmd(FunctionalState NewState)
000000  b570              PUSH     {r4-r6,lr}
;;;1793   {
000002  4606              MOV      r6,r0
;;;1794     ErrorStatus status = ERROR;
000004  2400              MOVS     r4,#0
;;;1795     
;;;1796     /* Check the parameters */
;;;1797     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1798   
;;;1799     /* Disable the write protection for RTC registers */
;;;1800     RTC->WPR = 0xCA;
000006  4d0d              LDR      r5,|L11.60|
000008  20ca              MOVS     r0,#0xca
00000a  6028              STR      r0,[r5,#0]
;;;1801     RTC->WPR = 0x53;
00000c  2053              MOVS     r0,#0x53
00000e  6028              STR      r0,[r5,#0]
;;;1802     
;;;1803     /* Set Initialization mode */
;;;1804     if (RTC_EnterInitMode() == ERROR)
000010  f7fffffe          BL       RTC_EnterInitMode
000014  b170              CBZ      r0,|L11.52|
;;;1805     {
;;;1806       status =  ERROR;
;;;1807     }
;;;1808     else
;;;1809     {
;;;1810       if (NewState != DISABLE)
;;;1811       {
;;;1812         /* Enable the Coarse Calibration */
;;;1813         RTC->CR |= (uint32_t)RTC_CR_DCE;
000016  4809              LDR      r0,|L11.60|
000018  381c              SUBS     r0,r0,#0x1c
00001a  b126              CBZ      r6,|L11.38|
00001c  6801              LDR      r1,[r0,#0]
00001e  f0410180          ORR      r1,r1,#0x80
000022  6001              STR      r1,[r0,#0]
000024  e003              B        |L11.46|
                  |L11.38|
;;;1814       }
;;;1815       else
;;;1816       { 
;;;1817         /* Disable the Coarse Calibration */
;;;1818         RTC->CR &= (uint32_t)~RTC_CR_DCE;
000026  6801              LDR      r1,[r0,#0]
000028  f0210180          BIC      r1,r1,#0x80
00002c  6001              STR      r1,[r0,#0]
                  |L11.46|
;;;1819       }
;;;1820       /* Exit Initialization mode */
;;;1821       RTC_ExitInitMode();
00002e  f7fffffe          BL       RTC_ExitInitMode
;;;1822       
;;;1823       status = SUCCESS;
000032  2401              MOVS     r4,#1
                  |L11.52|
;;;1824     } 
;;;1825     
;;;1826     /* Enable the write protection for RTC registers */
;;;1827     RTC->WPR = 0xFF; 
000034  20ff              MOVS     r0,#0xff
000036  6028              STR      r0,[r5,#0]
;;;1828     
;;;1829     return status;
000038  4620              MOV      r0,r4
;;;1830   }
00003a  bd70              POP      {r4-r6,pc}
;;;1831   
                          ENDP

                  |L11.60|
                          DCD      0x40002824

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

                  RTC_CoarseCalibConfig PROC
;;;1750     */
;;;1751   ErrorStatus RTC_CoarseCalibConfig(uint32_t RTC_CalibSign, uint32_t Value)
000000  b5f0              PUSH     {r4-r7,lr}
;;;1752   {
000002  4606              MOV      r6,r0
000004  460f              MOV      r7,r1
;;;1753     ErrorStatus status = ERROR;
000006  2400              MOVS     r4,#0
;;;1754      
;;;1755     /* Check the parameters */
;;;1756     assert_param(IS_RTC_CALIB_SIGN(RTC_CalibSign));
;;;1757     assert_param(IS_RTC_CALIB_VALUE(Value)); 
;;;1758   
;;;1759     /* Disable the write protection for RTC registers */
;;;1760     RTC->WPR = 0xCA;
000008  4d09              LDR      r5,|L12.48|
00000a  20ca              MOVS     r0,#0xca
00000c  6028              STR      r0,[r5,#0]
;;;1761     RTC->WPR = 0x53;
00000e  2053              MOVS     r0,#0x53
000010  6028              STR      r0,[r5,#0]
;;;1762   
;;;1763     /* Set Initialization mode */
;;;1764     if (RTC_EnterInitMode() == ERROR)
000012  f7fffffe          BL       RTC_EnterInitMode
000016  b130              CBZ      r0,|L12.38|
;;;1765     {
;;;1766       status = ERROR;
;;;1767     } 
;;;1768     else
;;;1769     {
;;;1770       /* Set the coarse calibration value */
;;;1771       RTC->CALIBR = (uint32_t)(RTC_CalibSign | Value);
000018  4805              LDR      r0,|L12.48|
00001a  433e              ORRS     r6,r6,r7
00001c  380c              SUBS     r0,r0,#0xc
00001e  6006              STR      r6,[r0,#0]
;;;1772       /* Exit Initialization mode */
;;;1773       RTC_ExitInitMode();
000020  f7fffffe          BL       RTC_ExitInitMode
;;;1774       
;;;1775       status = SUCCESS;
000024  2401              MOVS     r4,#1
                  |L12.38|
;;;1776     } 
;;;1777   
;;;1778     /* Enable the write protection for RTC registers */
;;;1779     RTC->WPR = 0xFF; 
000026  20ff              MOVS     r0,#0xff
000028  6028              STR      r0,[r5,#0]
;;;1780     
;;;1781     return status;
00002a  4620              MOV      r0,r4
;;;1782   }
00002c  bdf0              POP      {r4-r7,pc}
;;;1783   
                          ENDP

00002e  0000              DCW      0x0000
                  |L12.48|
                          DCD      0x40002824

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

                  RTC_DateStructInit PROC
;;;1035     */
;;;1036   void RTC_DateStructInit(RTC_DateTypeDef* RTC_DateStruct)
000000  2101              MOVS     r1,#1
;;;1037   {
;;;1038     /* Monday, January 01 xx00 */
;;;1039     RTC_DateStruct->RTC_WeekDay = RTC_Weekday_Monday;
000002  7001              STRB     r1,[r0,#0]
;;;1040     RTC_DateStruct->RTC_Date = 1;
000004  7081              STRB     r1,[r0,#2]
;;;1041     RTC_DateStruct->RTC_Month = RTC_Month_January;
000006  7041              STRB     r1,[r0,#1]
;;;1042     RTC_DateStruct->RTC_Year = 0;
000008  2100              MOVS     r1,#0
00000a  70c1              STRB     r1,[r0,#3]
;;;1043   }
00000c  4770              BX       lr
;;;1044   
                          ENDP


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

                  RTC_DayLightSavingConfig PROC
;;;1630     */
;;;1631   void RTC_DayLightSavingConfig(uint32_t RTC_DayLightSaving, uint32_t RTC_StoreOperation)
000000  b510              PUSH     {r4,lr}
;;;1632   {
;;;1633     /* Check the parameters */
;;;1634     assert_param(IS_RTC_DAYLIGHT_SAVING(RTC_DayLightSaving));
;;;1635     assert_param(IS_RTC_STORE_OPERATION(RTC_StoreOperation));
;;;1636   
;;;1637     /* Disable the write protection for RTC registers */
;;;1638     RTC->WPR = 0xCA;
000002  4b09              LDR      r3,|L14.40|
000004  22ca              MOVS     r2,#0xca
000006  601a              STR      r2,[r3,#0]
;;;1639     RTC->WPR = 0x53;
000008  2253              MOVS     r2,#0x53
00000a  601a              STR      r2,[r3,#0]
;;;1640   
;;;1641     /* Clear the bits to be configured */
;;;1642     RTC->CR &= (uint32_t)~(RTC_CR_BCK);
00000c  4a06              LDR      r2,|L14.40|
00000e  3a1c              SUBS     r2,r2,#0x1c
000010  6814              LDR      r4,[r2,#0]
000012  f4242480          BIC      r4,r4,#0x40000
000016  6014              STR      r4,[r2,#0]
;;;1643   
;;;1644     /* Configure the RTC_CR register */
;;;1645     RTC->CR |= (uint32_t)(RTC_DayLightSaving | RTC_StoreOperation);
000018  6814              LDR      r4,[r2,#0]
00001a  4308              ORRS     r0,r0,r1
00001c  4304              ORRS     r4,r4,r0
00001e  6014              STR      r4,[r2,#0]
;;;1646   
;;;1647     /* Enable the write protection for RTC registers */
;;;1648     RTC->WPR = 0xFF; 
000020  20ff              MOVS     r0,#0xff
000022  6018              STR      r0,[r3,#0]
;;;1649   }
000024  bd10              POP      {r4,pc}
;;;1650   
                          ENDP

000026  0000              DCW      0x0000
                  |L14.40|
                          DCD      0x40002824

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

                  RTC_DeInit PROC
;;;374      */
;;;375    ErrorStatus RTC_DeInit(void)
000000  b578              PUSH     {r3-r6,lr}
;;;376    {
;;;377      __IO uint32_t wutcounter = 0x00;
000002  2400              MOVS     r4,#0
000004  9400              STR      r4,[sp,#0]
;;;378      uint32_t wutwfstatus = 0x00;
;;;379      ErrorStatus status = ERROR;
000006  2500              MOVS     r5,#0
;;;380      
;;;381      /* Disable the write protection for RTC registers */
;;;382      RTC->WPR = 0xCA;
000008  4e29              LDR      r6,|L15.176|
00000a  20ca              MOVS     r0,#0xca
00000c  6030              STR      r0,[r6,#0]
;;;383      RTC->WPR = 0x53;
00000e  2053              MOVS     r0,#0x53
000010  6030              STR      r0,[r6,#0]
;;;384    
;;;385      /* Set Initialization mode */
;;;386      if (RTC_EnterInitMode() == ERROR)
000012  f7fffffe          BL       RTC_EnterInitMode
000016  b3e8              CBZ      r0,|L15.148|
;;;387      {
;;;388        status = ERROR;
;;;389      }  
;;;390      else
;;;391      {
;;;392        /* Reset TR, DR and CR registers */
;;;393        RTC->TR = (uint32_t)0x00000000;
000018  4825              LDR      r0,|L15.176|
00001a  3824              SUBS     r0,r0,#0x24
00001c  6004              STR      r4,[r0,#0]
;;;394        RTC->DR = (uint32_t)0x00002101;
00001e  4924              LDR      r1,|L15.176|
000020  f2421001          MOV      r0,#0x2101
000024  3920              SUBS     r1,r1,#0x20
000026  6008              STR      r0,[r1,#0]
;;;395        /* Reset All CR bits except CR[2:0] */
;;;396        RTC->CR &= (uint32_t)0x00000007;
000028  1d0b              ADDS     r3,r1,#4
00002a  6818              LDR      r0,[r3,#0]
00002c  f0000007          AND      r0,r0,#7
000030  6018              STR      r0,[r3,#0]
;;;397      
;;;398        /* Wait till RTC WUTWF flag is set and if Time out is reached exit */
;;;399        do
;;;400        {
;;;401          wutwfstatus = RTC->ISR & RTC_ISR_WUTWF;
;;;402          wutcounter++;  
;;;403        } while((wutcounter != INITMODE_TIMEOUT) && (wutwfstatus == 0x00));
000032  138d              ASRS     r5,r1,#14
000034  1d19              ADDS     r1,r3,#4              ;401
                  |L15.54|
000036  6808              LDR      r0,[r1,#0]            ;401
000038  f0000004          AND      r0,r0,#4              ;401
00003c  9a00              LDR      r2,[sp,#0]            ;402
00003e  1c52              ADDS     r2,r2,#1              ;402
000040  9200              STR      r2,[sp,#0]            ;402
000042  9a00              LDR      r2,[sp,#0]
000044  42aa              CMP      r2,r5
000046  d001              BEQ      |L15.76|
000048  2800              CMP      r0,#0
00004a  d0f4              BEQ      |L15.54|
                  |L15.76|
;;;404        
;;;405        if ((RTC->ISR & RTC_ISR_WUTWF) == RESET)
00004c  6808              LDR      r0,[r1,#0]
00004e  0740              LSLS     r0,r0,#29
000050  d401              BMI      |L15.86|
;;;406        {
;;;407          status = ERROR;
000052  2500              MOVS     r5,#0
000054  e025              B        |L15.162|
                  |L15.86|
;;;408        }
;;;409        else
;;;410        {
;;;411          /* Reset all RTC CR register bits */
;;;412          RTC->CR &= (uint32_t)0x00000000;
000056  6818              LDR      r0,[r3,#0]
000058  601c              STR      r4,[r3,#0]
;;;413          RTC->WUTR = (uint32_t)0x0000FFFF;
00005a  4a15              LDR      r2,|L15.176|
00005c  f64f70ff          MOV      r0,#0xffff
000060  3a10              SUBS     r2,r2,#0x10
000062  6010              STR      r0,[r2,#0]
;;;414          RTC->PRER = (uint32_t)0x007F00FF;
000064  1f12              SUBS     r2,r2,#4
000066  4813              LDR      r0,|L15.180|
000068  6010              STR      r0,[r2,#0]
;;;415          RTC->CALIBR = (uint32_t)0x00000000;
00006a  4811              LDR      r0,|L15.176|
00006c  380c              SUBS     r0,r0,#0xc
00006e  6004              STR      r4,[r0,#0]
;;;416          RTC->ALRMAR = (uint32_t)0x00000000;        
000070  1d00              ADDS     r0,r0,#4
000072  6004              STR      r4,[r0,#0]
;;;417          RTC->ALRMBR = (uint32_t)0x00000000;
000074  1d00              ADDS     r0,r0,#4
000076  6004              STR      r4,[r0,#0]
;;;418          RTC->SHIFTR = (uint32_t)0x00000000;
000078  480d              LDR      r0,|L15.176|
00007a  3008              ADDS     r0,r0,#8
00007c  6004              STR      r4,[r0,#0]
;;;419          RTC->CALR = (uint32_t)0x00000000;
00007e  480c              LDR      r0,|L15.176|
000080  3018              ADDS     r0,r0,#0x18
000082  6004              STR      r4,[r0,#0]
;;;420          RTC->ALRMASSR = (uint32_t)0x00000000;
000084  480a              LDR      r0,|L15.176|
000086  3020              ADDS     r0,r0,#0x20
000088  6004              STR      r4,[r0,#0]
;;;421          RTC->ALRMBSSR = (uint32_t)0x00000000;
00008a  1d00              ADDS     r0,r0,#4
00008c  6004              STR      r4,[r0,#0]
;;;422          
;;;423          /* Reset ISR register and exit initialization mode */
;;;424          RTC->ISR = (uint32_t)0x00000000;
00008e  600c              STR      r4,[r1,#0]
;;;425          
;;;426          /* Reset Tamper and alternate functions configuration register */
;;;427          RTC->TAFCR = 0x00000000;
000090  4807              LDR      r0,|L15.176|
000092  e000              B        |L15.150|
                  |L15.148|
000094  e005              B        |L15.162|
                  |L15.150|
000096  301c              ADDS     r0,r0,#0x1c
000098  6004              STR      r4,[r0,#0]
;;;428      
;;;429          if(RTC_WaitForSynchro() == ERROR)
00009a  f7fffffe          BL       RTC_WaitForSynchro
00009e  b120              CBZ      r0,|L15.170|
;;;430          {
;;;431            status = ERROR;
;;;432          }
;;;433          else
;;;434          {
;;;435            status = SUCCESS;      
0000a0  2501              MOVS     r5,#1
                  |L15.162|
;;;436          }
;;;437        }
;;;438      }
;;;439      
;;;440      /* Enable the write protection for RTC registers */
;;;441      RTC->WPR = 0xFF;  
0000a2  20ff              MOVS     r0,#0xff
0000a4  6030              STR      r0,[r6,#0]
;;;442      
;;;443      return status;
0000a6  4628              MOV      r0,r5
;;;444    }
0000a8  bd78              POP      {r3-r6,pc}
                  |L15.170|
0000aa  2500              MOVS     r5,#0                 ;431
0000ac  e7f9              B        |L15.162|
;;;445    
                          ENDP

0000ae  0000              DCW      0x0000
                  |L15.176|
                          DCD      0x40002824
                  |L15.180|
                          DCD      0x007f00ff

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

                  RTC_EnterInitMode PROC
;;;551      */
;;;552    ErrorStatus RTC_EnterInitMode(void)
000000  b508              PUSH     {r3,lr}
;;;553    {
;;;554      __IO uint32_t initcounter = 0x00;
000002  2000              MOVS     r0,#0
000004  9000              STR      r0,[sp,#0]
;;;555      ErrorStatus status = ERROR;
;;;556      uint32_t initstatus = 0x00;
;;;557         
;;;558      /* Check if the Initialization mode is set */
;;;559      if ((RTC->ISR & RTC_ISR_INITF) == (uint32_t)RESET)
000006  490e              LDR      r1,|L16.64|
000008  6808              LDR      r0,[r1,#0]
00000a  0640              LSLS     r0,r0,#25
00000c  d415              BMI      |L16.58|
;;;560      {
;;;561        /* Set the Initialization mode */
;;;562        RTC->ISR = (uint32_t)RTC_INIT_MASK;
00000e  f04f30ff          MOV      r0,#0xffffffff
000012  6008              STR      r0,[r1,#0]
;;;563        
;;;564        /* Wait till RTC is in INIT state and if Time out is reached exit */
;;;565        do
;;;566        {
;;;567          initstatus = RTC->ISR & RTC_ISR_INITF;
;;;568          initcounter++;  
;;;569        } while((initcounter != INITMODE_TIMEOUT) && (initstatus == 0x00));
000014  138b              ASRS     r3,r1,#14
                  |L16.22|
000016  6808              LDR      r0,[r1,#0]            ;567
000018  f0000040          AND      r0,r0,#0x40           ;567
00001c  9a00              LDR      r2,[sp,#0]            ;568
00001e  1c52              ADDS     r2,r2,#1              ;568
000020  9200              STR      r2,[sp,#0]            ;568
000022  9a00              LDR      r2,[sp,#0]
000024  429a              CMP      r2,r3
000026  d001              BEQ      |L16.44|
000028  2800              CMP      r0,#0
00002a  d0f4              BEQ      |L16.22|
                  |L16.44|
;;;570        
;;;571        if ((RTC->ISR & RTC_ISR_INITF) != RESET)
00002c  6808              LDR      r0,[r1,#0]
00002e  0640              LSLS     r0,r0,#25
000030  d501              BPL      |L16.54|
;;;572        {
;;;573          status = SUCCESS;
000032  2001              MOVS     r0,#1
;;;574        }
;;;575        else
;;;576        {
;;;577          status = ERROR;
;;;578        }        
;;;579      }
;;;580      else
;;;581      {
;;;582        status = SUCCESS;  
;;;583      } 
;;;584        
;;;585      return (status);  
;;;586    }
000034  bd08              POP      {r3,pc}
                  |L16.54|
000036  2000              MOVS     r0,#0                 ;577
000038  bd08              POP      {r3,pc}
                  |L16.58|
00003a  2001              MOVS     r0,#1                 ;582
00003c  bd08              POP      {r3,pc}
;;;587    
                          ENDP

00003e  0000              DCW      0x0000
                  |L16.64|
                          DCD      0x4000280c

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

                  RTC_ExitInitMode PROC
;;;596      */
;;;597    void RTC_ExitInitMode(void)
000000  4802              LDR      r0,|L17.12|
;;;598    { 
;;;599      /* Exit Initialization mode */
;;;600      RTC->ISR &= (uint32_t)~RTC_ISR_INIT;  
000002  6801              LDR      r1,[r0,#0]
000004  f0210180          BIC      r1,r1,#0x80
000008  6001              STR      r1,[r0,#0]
;;;601    }
00000a  4770              BX       lr
;;;602    
                          ENDP

                  |L17.12|
                          DCD      0x4000280c

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

                  RTC_GetAlarm PROC
;;;1255     */
;;;1256   void RTC_GetAlarm(uint32_t RTC_Format, uint32_t RTC_Alarm, RTC_AlarmTypeDef* RTC_AlarmStruct)
000000  b510              PUSH     {r4,lr}
;;;1257   {
000002  4603              MOV      r3,r0
000004  4614              MOV      r4,r2
;;;1258     uint32_t tmpreg = 0;
;;;1259   
;;;1260     /* Check the parameters */
;;;1261     assert_param(IS_RTC_FORMAT(RTC_Format));
;;;1262     assert_param(IS_RTC_ALARM(RTC_Alarm)); 
;;;1263   
;;;1264     /* Get the RTC_ALRMxR register */
;;;1265     if (RTC_Alarm == RTC_Alarm_A)
000006  f5b17f80          CMP      r1,#0x100
00000a  d029              BEQ      |L18.96|
;;;1266     {
;;;1267       tmpreg = (uint32_t)(RTC->ALRMAR);
;;;1268     }
;;;1269     else
;;;1270     {
;;;1271       tmpreg = (uint32_t)(RTC->ALRMBR);
00000c  4816              LDR      r0,|L18.104|
00000e  6801              LDR      r1,[r0,#0]
                  |L18.16|
;;;1272     }
;;;1273   
;;;1274     /* Fill the structure with the read parameters */
;;;1275     RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours = (uint32_t)((tmpreg & (RTC_ALRMAR_HT | \
000010  f3c14005          UBFX     r0,r1,#16,#6
000014  7020              STRB     r0,[r4,#0]
;;;1276                                                        RTC_ALRMAR_HU)) >> 16);
;;;1277     RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes = (uint32_t)((tmpreg & (RTC_ALRMAR_MNT | \
000016  f3c12206          UBFX     r2,r1,#8,#7
00001a  7062              STRB     r2,[r4,#1]
;;;1278                                                        RTC_ALRMAR_MNU)) >> 8);
;;;1279     RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds = (uint32_t)(tmpreg & (RTC_ALRMAR_ST | \
00001c  f001027f          AND      r2,r1,#0x7f
000020  70a2              STRB     r2,[r4,#2]
;;;1280                                                        RTC_ALRMAR_SU));
;;;1281     RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = (uint32_t)((tmpreg & RTC_ALRMAR_PM) >> 16);
000022  f4010280          AND      r2,r1,#0x400000
000026  0c12              LSRS     r2,r2,#16
000028  70e2              STRB     r2,[r4,#3]
;;;1282     RTC_AlarmStruct->RTC_AlarmDateWeekDay = (uint32_t)((tmpreg & (RTC_ALRMAR_DT | RTC_ALRMAR_DU)) >> 24);
00002a  f3c16205          UBFX     r2,r1,#24,#6
00002e  7322              STRB     r2,[r4,#0xc]
;;;1283     RTC_AlarmStruct->RTC_AlarmDateWeekDaySel = (uint32_t)(tmpreg & RTC_ALRMAR_WDSEL);
000030  f0014280          AND      r2,r1,#0x40000000
000034  60a2              STR      r2,[r4,#8]
;;;1284     RTC_AlarmStruct->RTC_AlarmMask = (uint32_t)(tmpreg & RTC_AlarmMask_All);
000036  f0013180          AND      r1,r1,#0x80808080
00003a  6061              STR      r1,[r4,#4]
;;;1285   
;;;1286     if (RTC_Format == RTC_Format_BIN)
00003c  2b00              CMP      r3,#0
00003e  d10e              BNE      |L18.94|
;;;1287     {
;;;1288       RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours = RTC_Bcd2ToByte(RTC_AlarmStruct-> \
000040  f7fffffe          BL       RTC_Bcd2ToByte
000044  7020              STRB     r0,[r4,#0]
;;;1289                                                           RTC_AlarmTime.RTC_Hours);
;;;1290       RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes = RTC_Bcd2ToByte(RTC_AlarmStruct-> \
000046  7860              LDRB     r0,[r4,#1]
000048  f7fffffe          BL       RTC_Bcd2ToByte
00004c  7060              STRB     r0,[r4,#1]
;;;1291                                                           RTC_AlarmTime.RTC_Minutes);
;;;1292       RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds = RTC_Bcd2ToByte(RTC_AlarmStruct-> \
00004e  78a0              LDRB     r0,[r4,#2]
000050  f7fffffe          BL       RTC_Bcd2ToByte
000054  70a0              STRB     r0,[r4,#2]
;;;1293                                                           RTC_AlarmTime.RTC_Seconds);
;;;1294       RTC_AlarmStruct->RTC_AlarmDateWeekDay = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmDateWeekDay);
000056  7b20              LDRB     r0,[r4,#0xc]
000058  f7fffffe          BL       RTC_Bcd2ToByte
00005c  7320              STRB     r0,[r4,#0xc]
                  |L18.94|
;;;1295     }  
;;;1296   }
00005e  bd10              POP      {r4,pc}
                  |L18.96|
000060  4801              LDR      r0,|L18.104|
000062  1f00              SUBS     r0,r0,#4              ;1267
000064  6801              LDR      r1,[r0,#0]            ;1267
000066  e7d3              B        |L18.16|
;;;1297   
                          ENDP

                  |L18.104|
                          DCD      0x40002820

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

                  RTC_GetAlarmSubSecond PROC
;;;1444     */
;;;1445   uint32_t RTC_GetAlarmSubSecond(uint32_t RTC_Alarm)
000000  f5b07f80          CMP      r0,#0x100
;;;1446   {
000004  d004              BEQ      |L19.16|
;;;1447     uint32_t tmpreg = 0;
;;;1448     
;;;1449     /* Get the RTC_ALRMxR register */
;;;1450     if (RTC_Alarm == RTC_Alarm_A)
;;;1451     {
;;;1452       tmpreg = (uint32_t)((RTC->ALRMASSR) & RTC_ALRMASSR_SS);
;;;1453     }
;;;1454     else
;;;1455     {
;;;1456       tmpreg = (uint32_t)((RTC->ALRMBSSR) & RTC_ALRMBSSR_SS);
000006  4805              LDR      r0,|L19.28|
000008  6800              LDR      r0,[r0,#0]
00000a  f3c0000e          UBFX     r0,r0,#0,#15
;;;1457     } 
;;;1458     
;;;1459     return (tmpreg);
;;;1460   }
00000e  4770              BX       lr
                  |L19.16|
000010  4802              LDR      r0,|L19.28|
000012  1f00              SUBS     r0,r0,#4              ;1452
000014  6800              LDR      r0,[r0,#0]            ;1452
000016  f3c0000e          UBFX     r0,r0,#0,#15          ;1452
00001a  4770              BX       lr
;;;1461   
                          ENDP

                  |L19.28|
                          DCD      0x40002848

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

                  RTC_GetDate PROC
;;;1054     */
;;;1055   void RTC_GetDate(uint32_t RTC_Format, RTC_DateTypeDef* RTC_DateStruct)
000000  b510              PUSH     {r4,lr}
;;;1056   {
000002  4602              MOV      r2,r0
000004  460c              MOV      r4,r1
;;;1057     uint32_t tmpreg = 0;
;;;1058   
;;;1059     /* Check the parameters */
;;;1060     assert_param(IS_RTC_FORMAT(RTC_Format));
;;;1061     
;;;1062     /* Get the RTC_TR register */
;;;1063     tmpreg = (uint32_t)(RTC->DR & RTC_DR_RESERVED_MASK); 
000006  480e              LDR      r0,|L20.64|
000008  6801              LDR      r1,[r0,#0]
00000a  480e              LDR      r0,|L20.68|
00000c  4001              ANDS     r1,r1,r0
;;;1064   
;;;1065     /* Fill the structure fields with the read parameters */
;;;1066     RTC_DateStruct->RTC_Year = (uint8_t)((tmpreg & (RTC_DR_YT | RTC_DR_YU)) >> 16);
00000e  0c08              LSRS     r0,r1,#16
000010  70e0              STRB     r0,[r4,#3]
;;;1067     RTC_DateStruct->RTC_Month = (uint8_t)((tmpreg & (RTC_DR_MT | RTC_DR_MU)) >> 8);
000012  f3c12304          UBFX     r3,r1,#8,#5
000016  7063              STRB     r3,[r4,#1]
;;;1068     RTC_DateStruct->RTC_Date = (uint8_t)(tmpreg & (RTC_DR_DT | RTC_DR_DU));
000018  f001033f          AND      r3,r1,#0x3f
00001c  70a3              STRB     r3,[r4,#2]
;;;1069     RTC_DateStruct->RTC_WeekDay = (uint8_t)((tmpreg & (RTC_DR_WDU)) >> 13);
00001e  f3c13142          UBFX     r1,r1,#13,#3
000022  7021              STRB     r1,[r4,#0]
;;;1070   
;;;1071     /* Check the input parameters format */
;;;1072     if (RTC_Format == RTC_Format_BIN)
000024  2a00              CMP      r2,#0
000026  d10a              BNE      |L20.62|
;;;1073     {
;;;1074       /* Convert the structure parameters to Binary format */
;;;1075       RTC_DateStruct->RTC_Year = (uint8_t)RTC_Bcd2ToByte(RTC_DateStruct->RTC_Year);
000028  f7fffffe          BL       RTC_Bcd2ToByte
00002c  70e0              STRB     r0,[r4,#3]
;;;1076       RTC_DateStruct->RTC_Month = (uint8_t)RTC_Bcd2ToByte(RTC_DateStruct->RTC_Month);
00002e  7860              LDRB     r0,[r4,#1]
000030  f7fffffe          BL       RTC_Bcd2ToByte
000034  7060              STRB     r0,[r4,#1]
;;;1077       RTC_DateStruct->RTC_Date = (uint8_t)RTC_Bcd2ToByte(RTC_DateStruct->RTC_Date);
000036  78a0              LDRB     r0,[r4,#2]
000038  f7fffffe          BL       RTC_Bcd2ToByte
00003c  70a0              STRB     r0,[r4,#2]
                  |L20.62|
;;;1078     }
;;;1079   }
00003e  bd10              POP      {r4,pc}
;;;1080   
                          ENDP

                  |L20.64|
                          DCD      0x40002804
                  |L20.68|
                          DCD      0x00ffff3f

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

                  RTC_GetFlagStatus PROC
;;;2604     */
;;;2605   FlagStatus RTC_GetFlagStatus(uint32_t RTC_FLAG)
000000  4602              MOV      r2,r0
;;;2606   {
;;;2607     FlagStatus bitstatus = RESET;
000002  2000              MOVS     r0,#0
;;;2608     uint32_t tmpreg = 0;
;;;2609     
;;;2610     /* Check the parameters */
;;;2611     assert_param(IS_RTC_GET_FLAG(RTC_FLAG));
;;;2612     
;;;2613     /* Get all the flags */
;;;2614     tmpreg = (uint32_t)(RTC->ISR & RTC_FLAGS_MASK);
000004  4903              LDR      r1,|L21.20|
000006  6809              LDR      r1,[r1,#0]
000008  4b03              LDR      r3,|L21.24|
00000a  4019              ANDS     r1,r1,r3
;;;2615     
;;;2616     /* Return the status of the flag */
;;;2617     if ((tmpreg & RTC_FLAG) != (uint32_t)RESET)
00000c  4211              TST      r1,r2
00000e  d000              BEQ      |L21.18|
;;;2618     {
;;;2619       bitstatus = SET;
000010  2001              MOVS     r0,#1
                  |L21.18|
;;;2620     }
;;;2621     else
;;;2622     {
;;;2623       bitstatus = RESET;
;;;2624     }
;;;2625     return bitstatus;
;;;2626   }
000012  4770              BX       lr
;;;2627   
                          ENDP

                  |L21.20|
                          DCD      0x4000280c
                  |L21.24|
                          DCD      0x00013f7f

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

                  RTC_GetITStatus PROC
;;;2660     */
;;;2661   ITStatus RTC_GetITStatus(uint32_t RTC_IT)
000000  2100              MOVS     r1,#0
;;;2662   {
;;;2663     ITStatus bitstatus = RESET;
;;;2664     uint32_t tmpreg = 0, enablestatus = 0;
;;;2665    
;;;2666     /* Check the parameters */
;;;2667     assert_param(IS_RTC_GET_IT(RTC_IT));
;;;2668     
;;;2669     /* Get the TAMPER Interrupt enable bit and pending bit */
;;;2670     tmpreg = (uint32_t)(RTC->TAFCR & (RTC_TAFCR_TAMPIE));
000002  4a0c              LDR      r2,|L22.52|
000004  6812              LDR      r2,[r2,#0]
000006  f0020304          AND      r3,r2,#4
;;;2671    
;;;2672     /* Get the Interrupt enable Status */
;;;2673     enablestatus = (uint32_t)((RTC->CR & RTC_IT) | (tmpreg & (RTC_IT >> 15)));
00000a  4a0a              LDR      r2,|L22.52|
00000c  3a38              SUBS     r2,r2,#0x38
00000e  6812              LDR      r2,[r2,#0]
000010  ea0333d0          AND      r3,r3,r0,LSR #15
000014  4002              ANDS     r2,r2,r0
000016  431a              ORRS     r2,r2,r3
;;;2674     
;;;2675     /* Get the Interrupt pending bit */
;;;2676     tmpreg = (uint32_t)((RTC->ISR & (uint32_t)(RTC_IT >> 4)));
000018  4b06              LDR      r3,|L22.52|
00001a  3b34              SUBS     r3,r3,#0x34
00001c  681b              LDR      r3,[r3,#0]
00001e  ea031010          AND      r0,r3,r0,LSR #4
;;;2677     
;;;2678     /* Get the status of the Interrupt */
;;;2679     if ((enablestatus != (uint32_t)RESET) && ((tmpreg & 0x0000FFFF) != (uint32_t)RESET))
000022  2a00              CMP      r2,#0
000024  d003              BEQ      |L22.46|
000026  0400              LSLS     r0,r0,#16
000028  0c00              LSRS     r0,r0,#16
00002a  d000              BEQ      |L22.46|
;;;2680     {
;;;2681       bitstatus = SET;
00002c  2101              MOVS     r1,#1
                  |L22.46|
;;;2682     }
;;;2683     else
;;;2684     {
;;;2685       bitstatus = RESET;
;;;2686     }
;;;2687     return bitstatus;
00002e  4608              MOV      r0,r1
;;;2688   }
000030  4770              BX       lr
;;;2689   
                          ENDP

000032  0000              DCW      0x0000
                  |L22.52|
                          DCD      0x40002840

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

                  RTC_GetStoreOperation PROC
;;;1657     */
;;;1658   uint32_t RTC_GetStoreOperation(void)
000000  4802              LDR      r0,|L23.12|
;;;1659   {
;;;1660     return (RTC->CR & RTC_CR_BCK);
000002  6800              LDR      r0,[r0,#0]
000004  f4002080          AND      r0,r0,#0x40000
;;;1661   }
000008  4770              BX       lr
;;;1662   
                          ENDP

00000a  0000              DCW      0x0000
                  |L23.12|
                          DCD      0x40002808

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

                  RTC_GetSubSecond PROC
;;;919      */
;;;920    uint32_t RTC_GetSubSecond(void)
000000  4802              LDR      r0,|L24.12|
;;;921    {
;;;922      uint32_t tmpreg = 0;
;;;923      
;;;924      /* Get sub seconds values from the correspondent registers*/
;;;925      tmpreg = (uint32_t)(RTC->SSR);
000002  6800              LDR      r0,[r0,#0]
;;;926      
;;;927      /* Read DR register to unfroze calendar registers */
;;;928      (void) (RTC->DR);
000004  4901              LDR      r1,|L24.12|
000006  3924              SUBS     r1,r1,#0x24
000008  6809              LDR      r1,[r1,#0]
;;;929      
;;;930      return (tmpreg);
;;;931    }
00000a  4770              BX       lr
;;;932    
                          ENDP

                  |L24.12|
                          DCD      0x40002828

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

                  RTC_GetTime PROC
;;;886      */
;;;887    void RTC_GetTime(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_TimeStruct)
000000  b510              PUSH     {r4,lr}
;;;888    {
000002  4602              MOV      r2,r0
000004  460c              MOV      r4,r1
;;;889      uint32_t tmpreg = 0;
;;;890    
;;;891      /* Check the parameters */
;;;892      assert_param(IS_RTC_FORMAT(RTC_Format));
;;;893    
;;;894      /* Get the RTC_TR register */
;;;895      tmpreg = (uint32_t)(RTC->TR & RTC_TR_RESERVED_MASK); 
000006  480f              LDR      r0,|L25.68|
000008  6801              LDR      r1,[r0,#0]
00000a  480f              LDR      r0,|L25.72|
00000c  4001              ANDS     r1,r1,r0
;;;896      
;;;897      /* Fill the structure fields with the read parameters */
;;;898      RTC_TimeStruct->RTC_Hours = (uint8_t)((tmpreg & (RTC_TR_HT | RTC_TR_HU)) >> 16);
00000e  f3c14005          UBFX     r0,r1,#16,#6
000012  7020              STRB     r0,[r4,#0]
;;;899      RTC_TimeStruct->RTC_Minutes = (uint8_t)((tmpreg & (RTC_TR_MNT | RTC_TR_MNU)) >>8);
000014  f3c12306          UBFX     r3,r1,#8,#7
000018  7063              STRB     r3,[r4,#1]
;;;900      RTC_TimeStruct->RTC_Seconds = (uint8_t)(tmpreg & (RTC_TR_ST | RTC_TR_SU));
00001a  f001037f          AND      r3,r1,#0x7f
00001e  70a3              STRB     r3,[r4,#2]
;;;901      RTC_TimeStruct->RTC_H12 = (uint8_t)((tmpreg & (RTC_TR_PM)) >> 16);  
000020  f4010180          AND      r1,r1,#0x400000
000024  0c09              LSRS     r1,r1,#16
000026  70e1              STRB     r1,[r4,#3]
;;;902    
;;;903      /* Check the input parameters format */
;;;904      if (RTC_Format == RTC_Format_BIN)
000028  2a00              CMP      r2,#0
00002a  d10a              BNE      |L25.66|
;;;905      {
;;;906        /* Convert the structure parameters to Binary format */
;;;907        RTC_TimeStruct->RTC_Hours = (uint8_t)RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Hours);
00002c  f7fffffe          BL       RTC_Bcd2ToByte
000030  7020              STRB     r0,[r4,#0]
;;;908        RTC_TimeStruct->RTC_Minutes = (uint8_t)RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Minutes);
000032  7860              LDRB     r0,[r4,#1]
000034  f7fffffe          BL       RTC_Bcd2ToByte
000038  7060              STRB     r0,[r4,#1]
;;;909        RTC_TimeStruct->RTC_Seconds = (uint8_t)RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Seconds);   
00003a  78a0              LDRB     r0,[r4,#2]
00003c  f7fffffe          BL       RTC_Bcd2ToByte
000040  70a0              STRB     r0,[r4,#2]
                  |L25.66|
;;;910      }
;;;911    }
000042  bd10              POP      {r4,pc}
;;;912    
                          ENDP

                  |L25.68|
                          DCD      0x40002800
                  |L25.72|
                          DCD      0x007f7f7f

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

                  RTC_GetTimeStamp PROC
;;;2025     */
;;;2026   void RTC_GetTimeStamp(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_StampTimeStruct, 
000000  b570              PUSH     {r4-r6,lr}
;;;2027                                         RTC_DateTypeDef* RTC_StampDateStruct)
;;;2028   {
000002  460c              MOV      r4,r1
000004  4615              MOV      r5,r2
;;;2029     uint32_t tmptime = 0, tmpdate = 0;
;;;2030   
;;;2031     /* Check the parameters */
;;;2032     assert_param(IS_RTC_FORMAT(RTC_Format));
;;;2033   
;;;2034     /* Get the TimeStamp time and date registers values */
;;;2035     tmptime = (uint32_t)(RTC->TSTR & RTC_TR_RESERVED_MASK);
000006  491e              LDR      r1,|L26.128|
000008  6809              LDR      r1,[r1,#0]
00000a  4a1e              LDR      r2,|L26.132|
00000c  4011              ANDS     r1,r1,r2
;;;2036     tmpdate = (uint32_t)(RTC->TSDR & RTC_DR_RESERVED_MASK);
00000e  4a1c              LDR      r2,|L26.128|
000010  1d12              ADDS     r2,r2,#4
000012  6812              LDR      r2,[r2,#0]
000014  f64f733f          MOV      r3,#0xff3f
000018  401a              ANDS     r2,r2,r3
;;;2037   
;;;2038     /* Fill the Time structure fields with the read parameters */
;;;2039     RTC_StampTimeStruct->RTC_Hours = (uint8_t)((tmptime & (RTC_TR_HT | RTC_TR_HU)) >> 16);
00001a  f3c14305          UBFX     r3,r1,#16,#6
00001e  7023              STRB     r3,[r4,#0]
;;;2040     RTC_StampTimeStruct->RTC_Minutes = (uint8_t)((tmptime & (RTC_TR_MNT | RTC_TR_MNU)) >> 8);
000020  f3c12306          UBFX     r3,r1,#8,#7
000024  7063              STRB     r3,[r4,#1]
;;;2041     RTC_StampTimeStruct->RTC_Seconds = (uint8_t)(tmptime & (RTC_TR_ST | RTC_TR_SU));
000026  f001037f          AND      r3,r1,#0x7f
00002a  70a3              STRB     r3,[r4,#2]
;;;2042     RTC_StampTimeStruct->RTC_H12 = (uint8_t)((tmptime & (RTC_TR_PM)) >> 16);  
00002c  f4010180          AND      r1,r1,#0x400000
000030  0c09              LSRS     r1,r1,#16
000032  70e1              STRB     r1,[r4,#3]
;;;2043   
;;;2044     /* Fill the Date structure fields with the read parameters */
;;;2045     RTC_StampDateStruct->RTC_Year = 0;
000034  2100              MOVS     r1,#0
000036  70e9              STRB     r1,[r5,#3]
;;;2046     RTC_StampDateStruct->RTC_Month = (uint8_t)((tmpdate & (RTC_DR_MT | RTC_DR_MU)) >> 8);
000038  f3c22104          UBFX     r1,r2,#8,#5
00003c  7069              STRB     r1,[r5,#1]
;;;2047     RTC_StampDateStruct->RTC_Date = (uint8_t)(tmpdate & (RTC_DR_DT | RTC_DR_DU));
00003e  f002013f          AND      r1,r2,#0x3f
000042  70a9              STRB     r1,[r5,#2]
;;;2048     RTC_StampDateStruct->RTC_WeekDay = (uint8_t)((tmpdate & (RTC_DR_WDU)) >> 13);
000044  f3c23142          UBFX     r1,r2,#13,#3
000048  7029              STRB     r1,[r5,#0]
;;;2049   
;;;2050     /* Check the input parameters format */
;;;2051     if (RTC_Format == RTC_Format_BIN)
00004a  2800              CMP      r0,#0
00004c  d117              BNE      |L26.126|
;;;2052     {
;;;2053       /* Convert the Time structure parameters to Binary format */
;;;2054       RTC_StampTimeStruct->RTC_Hours = (uint8_t)RTC_Bcd2ToByte(RTC_StampTimeStruct->RTC_Hours);
00004e  7820              LDRB     r0,[r4,#0]
000050  f7fffffe          BL       RTC_Bcd2ToByte
000054  7020              STRB     r0,[r4,#0]
;;;2055       RTC_StampTimeStruct->RTC_Minutes = (uint8_t)RTC_Bcd2ToByte(RTC_StampTimeStruct->RTC_Minutes);
000056  7860              LDRB     r0,[r4,#1]
000058  f7fffffe          BL       RTC_Bcd2ToByte
00005c  7060              STRB     r0,[r4,#1]
;;;2056       RTC_StampTimeStruct->RTC_Seconds = (uint8_t)RTC_Bcd2ToByte(RTC_StampTimeStruct->RTC_Seconds);
00005e  78a0              LDRB     r0,[r4,#2]
000060  f7fffffe          BL       RTC_Bcd2ToByte
000064  70a0              STRB     r0,[r4,#2]
;;;2057   
;;;2058       /* Convert the Date structure parameters to Binary format */
;;;2059       RTC_StampDateStruct->RTC_Month = (uint8_t)RTC_Bcd2ToByte(RTC_StampDateStruct->RTC_Month);
000066  7868              LDRB     r0,[r5,#1]
000068  f7fffffe          BL       RTC_Bcd2ToByte
00006c  7068              STRB     r0,[r5,#1]
;;;2060       RTC_StampDateStruct->RTC_Date = (uint8_t)RTC_Bcd2ToByte(RTC_StampDateStruct->RTC_Date);
00006e  78a8              LDRB     r0,[r5,#2]
000070  f7fffffe          BL       RTC_Bcd2ToByte
000074  70a8              STRB     r0,[r5,#2]
;;;2061       RTC_StampDateStruct->RTC_WeekDay = (uint8_t)RTC_Bcd2ToByte(RTC_StampDateStruct->RTC_WeekDay);
000076  7828              LDRB     r0,[r5,#0]
000078  f7fffffe          BL       RTC_Bcd2ToByte
00007c  7028              STRB     r0,[r5,#0]
                  |L26.126|
;;;2062     }
;;;2063   }
00007e  bd70              POP      {r4-r6,pc}
;;;2064   
                          ENDP

                  |L26.128|
                          DCD      0x40002830
                  |L26.132|
                          DCD      0x007f7f7f

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

                  RTC_GetTimeStampSubSecond PROC
;;;2069     */
;;;2070   uint32_t RTC_GetTimeStampSubSecond(void)
000000  4801              LDR      r0,|L27.8|
;;;2071   {
;;;2072     /* Get timestamp sub seconds values from the correspondent registers */
;;;2073     return (uint32_t)(RTC->TSSSR);
000002  6800              LDR      r0,[r0,#0]
;;;2074   }
000004  4770              BX       lr
;;;2075   
                          ENDP

000006  0000              DCW      0x0000
                  |L27.8|
                          DCD      0x40002838

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

                  RTC_GetWakeUpCounter PROC
;;;1541     */
;;;1542   uint32_t RTC_GetWakeUpCounter(void)
000000  4801              LDR      r0,|L28.8|
;;;1543   {
;;;1544     /* Get the counter value */
;;;1545     return ((uint32_t)(RTC->WUTR & RTC_WUTR_WUT));
000002  6800              LDR      r0,[r0,#0]
000004  b280              UXTH     r0,r0
;;;1546   }
000006  4770              BX       lr
;;;1547   
                          ENDP

                  |L28.8|
                          DCD      0x40002814

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

                  RTC_ITConfig PROC
;;;2556     */
;;;2557   void RTC_ITConfig(uint32_t RTC_IT, FunctionalState NewState)
000000  b530              PUSH     {r4,r5,lr}
;;;2558   {
;;;2559     /* Check the parameters */
;;;2560     assert_param(IS_RTC_CONFIG_IT(RTC_IT));
;;;2561     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;2562   
;;;2563     /* Disable the write protection for RTC registers */
;;;2564     RTC->WPR = 0xCA;
000002  4d0f              LDR      r5,|L29.64|
000004  22ca              MOVS     r2,#0xca
000006  602a              STR      r2,[r5,#0]
;;;2565     RTC->WPR = 0x53;
000008  2253              MOVS     r2,#0x53
00000a  602a              STR      r2,[r5,#0]
;;;2566   
;;;2567     if (NewState != DISABLE)
;;;2568     {
;;;2569       /* Configure the Interrupts in the RTC_CR register */
;;;2570       RTC->CR |= (uint32_t)(RTC_IT & ~RTC_TAFCR_TAMPIE);
00000c  4c0c              LDR      r4,|L29.64|
;;;2571       /* Configure the Tamper Interrupt in the RTC_TAFCR */
;;;2572       RTC->TAFCR |= (uint32_t)(RTC_IT & RTC_TAFCR_TAMPIE);
00000e  4b0c              LDR      r3,|L29.64|
000010  3c1c              SUBS     r4,r4,#0x1c           ;2570
000012  f0200204          BIC      r2,r0,#4              ;2570
000016  331c              ADDS     r3,r3,#0x1c
000018  f0000004          AND      r0,r0,#4
00001c  2900              CMP      r1,#0                 ;2567
00001e  d006              BEQ      |L29.46|
000020  6821              LDR      r1,[r4,#0]            ;2570
000022  4311              ORRS     r1,r1,r2              ;2570
000024  6021              STR      r1,[r4,#0]            ;2570
000026  6819              LDR      r1,[r3,#0]
000028  4301              ORRS     r1,r1,r0
00002a  6019              STR      r1,[r3,#0]
00002c  e005              B        |L29.58|
                  |L29.46|
;;;2573     }
;;;2574     else
;;;2575     {
;;;2576       /* Configure the Interrupts in the RTC_CR register */
;;;2577       RTC->CR &= (uint32_t)~(RTC_IT & (uint32_t)~RTC_TAFCR_TAMPIE);
00002e  6821              LDR      r1,[r4,#0]
000030  4391              BICS     r1,r1,r2
000032  6021              STR      r1,[r4,#0]
;;;2578       /* Configure the Tamper Interrupt in the RTC_TAFCR */
;;;2579       RTC->TAFCR &= (uint32_t)~(RTC_IT & RTC_TAFCR_TAMPIE);
000034  6819              LDR      r1,[r3,#0]
000036  4381              BICS     r1,r1,r0
000038  6019              STR      r1,[r3,#0]
                  |L29.58|
;;;2580     }
;;;2581     /* Enable the write protection for RTC registers */
;;;2582     RTC->WPR = 0xFF; 
00003a  20ff              MOVS     r0,#0xff
00003c  6028              STR      r0,[r5,#0]
;;;2583   }
00003e  bd30              POP      {r4,r5,pc}
;;;2584   
                          ENDP

                  |L29.64|
                          DCD      0x40002824

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

                  RTC_Init PROC
;;;456      */
;;;457    ErrorStatus RTC_Init(RTC_InitTypeDef* RTC_InitStruct)
000000  b570              PUSH     {r4-r6,lr}
;;;458    {
000002  4604              MOV      r4,r0
;;;459      ErrorStatus status = ERROR;
000004  2500              MOVS     r5,#0
;;;460      
;;;461      /* Check the parameters */
;;;462      assert_param(IS_RTC_HOUR_FORMAT(RTC_InitStruct->RTC_HourFormat));
;;;463      assert_param(IS_RTC_ASYNCH_PREDIV(RTC_InitStruct->RTC_AsynchPrediv));
;;;464      assert_param(IS_RTC_SYNCH_PREDIV(RTC_InitStruct->RTC_SynchPrediv));
;;;465    
;;;466      /* Disable the write protection for RTC registers */
;;;467      RTC->WPR = 0xCA;
000006  4e11              LDR      r6,|L30.76|
000008  20ca              MOVS     r0,#0xca
00000a  6030              STR      r0,[r6,#0]
;;;468      RTC->WPR = 0x53;
00000c  2053              MOVS     r0,#0x53
00000e  6030              STR      r0,[r6,#0]
;;;469    
;;;470      /* Set Initialization mode */
;;;471      if (RTC_EnterInitMode() == ERROR)
000010  f7fffffe          BL       RTC_EnterInitMode
000014  b1a8              CBZ      r0,|L30.66|
;;;472      {
;;;473        status = ERROR;
;;;474      } 
;;;475      else
;;;476      {
;;;477        /* Clear RTC CR FMT Bit */
;;;478        RTC->CR &= ((uint32_t)~(RTC_CR_FMT));
000016  480d              LDR      r0,|L30.76|
000018  381c              SUBS     r0,r0,#0x1c
00001a  6801              LDR      r1,[r0,#0]
00001c  f0210140          BIC      r1,r1,#0x40
000020  6001              STR      r1,[r0,#0]
;;;479        /* Set RTC_CR register */
;;;480        RTC->CR |=  ((uint32_t)(RTC_InitStruct->RTC_HourFormat));
000022  6801              LDR      r1,[r0,#0]
000024  6822              LDR      r2,[r4,#0]
000026  4311              ORRS     r1,r1,r2
000028  6001              STR      r1,[r0,#0]
;;;481      
;;;482        /* Configure the RTC PRER */
;;;483        RTC->PRER = (uint32_t)(RTC_InitStruct->RTC_SynchPrediv);
00002a  4808              LDR      r0,|L30.76|
00002c  68a1              LDR      r1,[r4,#8]
00002e  3814              SUBS     r0,r0,#0x14
000030  6001              STR      r1,[r0,#0]
;;;484        RTC->PRER |= (uint32_t)(RTC_InitStruct->RTC_AsynchPrediv << 16);
000032  6801              LDR      r1,[r0,#0]
000034  88a2              LDRH     r2,[r4,#4]
000036  ea414102          ORR      r1,r1,r2,LSL #16
00003a  6001              STR      r1,[r0,#0]
;;;485    
;;;486        /* Exit Initialization mode */
;;;487        RTC_ExitInitMode();
00003c  f7fffffe          BL       RTC_ExitInitMode
;;;488    
;;;489        status = SUCCESS;    
000040  2501              MOVS     r5,#1
                  |L30.66|
;;;490      }
;;;491      /* Enable the write protection for RTC registers */
;;;492      RTC->WPR = 0xFF; 
000042  20ff              MOVS     r0,#0xff
000044  6030              STR      r0,[r6,#0]
;;;493      
;;;494      return status;
000046  4628              MOV      r0,r5
;;;495    }
000048  bd70              POP      {r4-r6,pc}
;;;496    
                          ENDP

00004a  0000              DCW      0x0000
                  |L30.76|
                          DCD      0x40002824

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

                  RTC_OutputConfig PROC
;;;1696     */
;;;1697   void RTC_OutputConfig(uint32_t RTC_Output, uint32_t RTC_OutputPolarity)
000000  b510              PUSH     {r4,lr}
;;;1698   {
;;;1699     /* Check the parameters */
;;;1700     assert_param(IS_RTC_OUTPUT(RTC_Output));
;;;1701     assert_param(IS_RTC_OUTPUT_POL(RTC_OutputPolarity));
;;;1702   
;;;1703     /* Disable the write protection for RTC registers */
;;;1704     RTC->WPR = 0xCA;
000002  4b09              LDR      r3,|L31.40|
000004  22ca              MOVS     r2,#0xca
000006  601a              STR      r2,[r3,#0]
;;;1705     RTC->WPR = 0x53;
000008  2253              MOVS     r2,#0x53
00000a  601a              STR      r2,[r3,#0]
;;;1706   
;;;1707     /* Clear the bits to be configured */
;;;1708     RTC->CR &= (uint32_t)~(RTC_CR_OSEL | RTC_CR_POL);
00000c  4a06              LDR      r2,|L31.40|
00000e  3a1c              SUBS     r2,r2,#0x1c
000010  6814              LDR      r4,[r2,#0]
000012  f42404e0          BIC      r4,r4,#0x700000
000016  6014              STR      r4,[r2,#0]
;;;1709   
;;;1710     /* Configure the output selection and polarity */
;;;1711     RTC->CR |= (uint32_t)(RTC_Output | RTC_OutputPolarity);
000018  6814              LDR      r4,[r2,#0]
00001a  4308              ORRS     r0,r0,r1
00001c  4304              ORRS     r4,r4,r0
00001e  6014              STR      r4,[r2,#0]
;;;1712   
;;;1713     /* Enable the write protection for RTC registers */
;;;1714     RTC->WPR = 0xFF; 
000020  20ff              MOVS     r0,#0xff
000022  6018              STR      r0,[r3,#0]
;;;1715   }
000024  bd10              POP      {r4,pc}
;;;1716   
                          ENDP

000026  0000              DCW      0x0000
                  |L31.40|
                          DCD      0x40002824

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

                  RTC_OutputTypeConfig PROC
;;;2398     */
;;;2399   void RTC_OutputTypeConfig(uint32_t RTC_OutputType)
000000  4904              LDR      r1,|L32.20|
;;;2400   {
;;;2401     /* Check the parameters */
;;;2402     assert_param(IS_RTC_OUTPUT_TYPE(RTC_OutputType));
;;;2403     
;;;2404     RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_ALARMOUTTYPE);
000002  680a              LDR      r2,[r1,#0]
000004  f4222280          BIC      r2,r2,#0x40000
000008  600a              STR      r2,[r1,#0]
;;;2405     RTC->TAFCR |= (uint32_t)(RTC_OutputType);  
00000a  680a              LDR      r2,[r1,#0]
00000c  4302              ORRS     r2,r2,r0
00000e  600a              STR      r2,[r1,#0]
;;;2406   }
000010  4770              BX       lr
;;;2407   
                          ENDP

000012  0000              DCW      0x0000
                  |L32.20|
                          DCD      0x40002840

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

                  RTC_ReadBackupRegister PROC
;;;2323     */
;;;2324   uint32_t RTC_ReadBackupRegister(uint32_t RTC_BKP_DR)
000000  b508              PUSH     {r3,lr}
;;;2325   {
;;;2326     __IO uint32_t tmp = 0;
;;;2327     
;;;2328     /* Check the parameters */
;;;2329     assert_param(IS_RTC_BKP(RTC_BKP_DR));
;;;2330   
;;;2331     tmp = RTC_BASE + 0x50;
000002  4903              LDR      r1,|L33.16|
;;;2332     tmp += (RTC_BKP_DR * 4);
000004  eb010080          ADD      r0,r1,r0,LSL #2
000008  9000              STR      r0,[sp,#0]
;;;2333     
;;;2334     /* Read the specified register */
;;;2335     return (*(__IO uint32_t *)tmp);
00000a  9800              LDR      r0,[sp,#0]
00000c  6800              LDR      r0,[r0,#0]
;;;2336   }
00000e  bd08              POP      {r3,pc}
;;;2337   
                          ENDP

                  |L33.16|
                          DCD      0x40002850

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

                  RTC_RefClockCmd PROC
;;;661      */
;;;662    ErrorStatus RTC_RefClockCmd(FunctionalState NewState)
000000  b570              PUSH     {r4-r6,lr}
;;;663    { 
000002  4606              MOV      r6,r0
;;;664      ErrorStatus status = ERROR;
000004  2400              MOVS     r4,#0
;;;665      
;;;666      /* Check the parameters */
;;;667      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;668      
;;;669      /* Disable the write protection for RTC registers */
;;;670      RTC->WPR = 0xCA;
000006  4d0d              LDR      r5,|L34.60|
000008  20ca              MOVS     r0,#0xca
00000a  6028              STR      r0,[r5,#0]
;;;671      RTC->WPR = 0x53;
00000c  2053              MOVS     r0,#0x53
00000e  6028              STR      r0,[r5,#0]
;;;672        
;;;673      /* Set Initialization mode */
;;;674      if (RTC_EnterInitMode() == ERROR)
000010  f7fffffe          BL       RTC_EnterInitMode
000014  b170              CBZ      r0,|L34.52|
;;;675      {
;;;676        status = ERROR;
;;;677      } 
;;;678      else
;;;679      {  
;;;680        if (NewState != DISABLE)
;;;681        {
;;;682          /* Enable the RTC reference clock detection */
;;;683          RTC->CR |= RTC_CR_REFCKON;   
000016  4809              LDR      r0,|L34.60|
000018  381c              SUBS     r0,r0,#0x1c
00001a  b126              CBZ      r6,|L34.38|
00001c  6801              LDR      r1,[r0,#0]
00001e  f0410110          ORR      r1,r1,#0x10
000022  6001              STR      r1,[r0,#0]
000024  e003              B        |L34.46|
                  |L34.38|
;;;684        }
;;;685        else
;;;686        {
;;;687          /* Disable the RTC reference clock detection */
;;;688          RTC->CR &= ~RTC_CR_REFCKON;    
000026  6801              LDR      r1,[r0,#0]
000028  f0210110          BIC      r1,r1,#0x10
00002c  6001              STR      r1,[r0,#0]
                  |L34.46|
;;;689        }
;;;690        /* Exit Initialization mode */
;;;691        RTC_ExitInitMode();
00002e  f7fffffe          BL       RTC_ExitInitMode
;;;692        
;;;693        status = SUCCESS;
000032  2401              MOVS     r4,#1
                  |L34.52|
;;;694      }
;;;695      
;;;696      /* Enable the write protection for RTC registers */
;;;697      RTC->WPR = 0xFF;  
000034  20ff              MOVS     r0,#0xff
000036  6028              STR      r0,[r5,#0]
;;;698      
;;;699      return status; 
000038  4620              MOV      r0,r4
;;;700    }
00003a  bd70              POP      {r4-r6,pc}
;;;701    
                          ENDP

                  |L34.60|
                          DCD      0x40002824

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

                  RTC_SetAlarm PROC
;;;1114     */
;;;1115   void RTC_SetAlarm(uint32_t RTC_Format, uint32_t RTC_Alarm, RTC_AlarmTypeDef* RTC_AlarmStruct)
000000  b570              PUSH     {r4-r6,lr}
;;;1116   {
000002  4605              MOV      r5,r0
000004  460e              MOV      r6,r1
000006  4614              MOV      r4,r2
;;;1117     uint32_t tmpreg = 0;
;;;1118     
;;;1119     /* Check the parameters */
;;;1120     assert_param(IS_RTC_FORMAT(RTC_Format));
;;;1121     assert_param(IS_RTC_ALARM(RTC_Alarm));
;;;1122     assert_param(IS_ALARM_MASK(RTC_AlarmStruct->RTC_AlarmMask));
;;;1123     assert_param(IS_RTC_ALARM_DATE_WEEKDAY_SEL(RTC_AlarmStruct->RTC_AlarmDateWeekDaySel));
;;;1124   
;;;1125     if (RTC_Format == RTC_Format_BIN)
000008  2000              MOVS     r0,#0
;;;1126     {
;;;1127       if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET)
00000a  492b              LDR      r1,|L35.184|
00000c  2d00              CMP      r5,#0                 ;1125
00000e  d006              BEQ      |L35.30|
;;;1128       {
;;;1129         assert_param(IS_RTC_HOUR12(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours));
;;;1130         assert_param(IS_RTC_H12(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12));
;;;1131       } 
;;;1132       else
;;;1133       {
;;;1134         RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = 0x00;
;;;1135         assert_param(IS_RTC_HOUR24(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours));
;;;1136       }
;;;1137       assert_param(IS_RTC_MINUTES(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes));
;;;1138       assert_param(IS_RTC_SECONDS(RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds));
;;;1139       
;;;1140       if(RTC_AlarmStruct->RTC_AlarmDateWeekDaySel == RTC_AlarmDateWeekDaySel_Date)
;;;1141       {
;;;1142         assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(RTC_AlarmStruct->RTC_AlarmDateWeekDay));
;;;1143       }
;;;1144       else
;;;1145       {
;;;1146         assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(RTC_AlarmStruct->RTC_AlarmDateWeekDay));
;;;1147       }
;;;1148     }
;;;1149     else
;;;1150     {
;;;1151       if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET)
000010  6809              LDR      r1,[r1,#0]
000012  0649              LSLS     r1,r1,#25
000014  d508              BPL      |L35.40|
;;;1152       {
;;;1153         tmpreg = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours);
000016  7820              LDRB     r0,[r4,#0]
000018  f7fffffe          BL       RTC_Bcd2ToByte
;;;1154         assert_param(IS_RTC_HOUR12(tmpreg));
;;;1155         assert_param(IS_RTC_H12(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12));
00001c  e005              B        |L35.42|
                  |L35.30|
00001e  6809              LDR      r1,[r1,#0]            ;1127
000020  0649              LSLS     r1,r1,#25             ;1127
000022  d407              BMI      |L35.52|
000024  70e0              STRB     r0,[r4,#3]            ;1134
000026  e005              B        |L35.52|
                  |L35.40|
;;;1156       } 
;;;1157       else
;;;1158       {
;;;1159         RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = 0x00;
000028  70e0              STRB     r0,[r4,#3]
                  |L35.42|
;;;1160         assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours)));
;;;1161       }
;;;1162       
;;;1163       assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes)));
;;;1164       assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds)));
;;;1165       
;;;1166       if(RTC_AlarmStruct->RTC_AlarmDateWeekDaySel == RTC_AlarmDateWeekDaySel_Date)
00002a  68a0              LDR      r0,[r4,#8]
00002c  b1a8              CBZ      r0,|L35.90|
;;;1167       {
;;;1168         tmpreg = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmDateWeekDay);
;;;1169         assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(tmpreg));    
;;;1170       }
;;;1171       else
;;;1172       {
;;;1173         tmpreg = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmDateWeekDay);
00002e  7b20              LDRB     r0,[r4,#0xc]
000030  f7fffffe          BL       RTC_Bcd2ToByte
                  |L35.52|
;;;1174         assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(tmpreg));      
;;;1175       }    
;;;1176     }
;;;1177   
;;;1178     /* Check the input parameters format */
;;;1179     if (RTC_Format != RTC_Format_BIN)
000034  b1ad              CBZ      r5,|L35.98|
;;;1180     {
;;;1181       tmpreg = (((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours) << 16) | \
000036  78a0              LDRB     r0,[r4,#2]
000038  7821              LDRB     r1,[r4,#0]
00003a  78e2              LDRB     r2,[r4,#3]
00003c  ea404001          ORR      r0,r0,r1,LSL #16
000040  7861              LDRB     r1,[r4,#1]
000042  0209              LSLS     r1,r1,#8
000044  ea414102          ORR      r1,r1,r2,LSL #16
000048  4308              ORRS     r0,r0,r1
00004a  7b21              LDRB     r1,[r4,#0xc]
00004c  ea406001          ORR      r0,r0,r1,LSL #24
000050  68a1              LDR      r1,[r4,#8]
000052  4308              ORRS     r0,r0,r1
000054  6861              LDR      r1,[r4,#4]
000056  4308              ORRS     r0,r0,r1
000058  e01c              B        |L35.148|
                  |L35.90|
00005a  7b20              LDRB     r0,[r4,#0xc]          ;1168
00005c  f7fffffe          BL       RTC_Bcd2ToByte
000060  e7e8              B        |L35.52|
                  |L35.98|
;;;1182                 ((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes) << 8) | \
;;;1183                 ((uint32_t)RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds) | \
;;;1184                 ((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12) << 16) | \
;;;1185                 ((uint32_t)(RTC_AlarmStruct->RTC_AlarmDateWeekDay) << 24) | \
;;;1186                 ((uint32_t)RTC_AlarmStruct->RTC_AlarmDateWeekDaySel) | \
;;;1187                 ((uint32_t)RTC_AlarmStruct->RTC_AlarmMask)); 
;;;1188     }  
;;;1189     else
;;;1190     {
;;;1191       tmpreg = (((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours) << 16) | \
000062  7820              LDRB     r0,[r4,#0]
000064  f7fffffe          BL       RTC_ByteToBcd2
000068  0405              LSLS     r5,r0,#16
00006a  7860              LDRB     r0,[r4,#1]
00006c  f7fffffe          BL       RTC_ByteToBcd2
000070  ea452500          ORR      r5,r5,r0,LSL #8
000074  78a0              LDRB     r0,[r4,#2]
000076  f7fffffe          BL       RTC_ByteToBcd2
00007a  4305              ORRS     r5,r5,r0
00007c  78e0              LDRB     r0,[r4,#3]
00007e  ea454500          ORR      r5,r5,r0,LSL #16
000082  7b20              LDRB     r0,[r4,#0xc]
000084  f7fffffe          BL       RTC_ByteToBcd2
000088  68a1              LDR      r1,[r4,#8]
00008a  ea456000          ORR      r0,r5,r0,LSL #24
00008e  4308              ORRS     r0,r0,r1
000090  6861              LDR      r1,[r4,#4]
000092  4308              ORRS     r0,r0,r1
                  |L35.148|
;;;1192                 ((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes) << 8) | \
;;;1193                 ((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds)) | \
;;;1194                 ((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12) << 16) | \
;;;1195                 ((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmDateWeekDay) << 24) | \
;;;1196                 ((uint32_t)RTC_AlarmStruct->RTC_AlarmDateWeekDaySel) | \
;;;1197                 ((uint32_t)RTC_AlarmStruct->RTC_AlarmMask)); 
;;;1198     } 
;;;1199   
;;;1200     /* Disable the write protection for RTC registers */
;;;1201     RTC->WPR = 0xCA;
000094  4908              LDR      r1,|L35.184|
000096  22ca              MOVS     r2,#0xca
000098  311c              ADDS     r1,r1,#0x1c
00009a  600a              STR      r2,[r1,#0]
;;;1202     RTC->WPR = 0x53;
00009c  2253              MOVS     r2,#0x53
00009e  600a              STR      r2,[r1,#0]
;;;1203   
;;;1204     /* Configure the Alarm register */
;;;1205     if (RTC_Alarm == RTC_Alarm_A)
0000a0  f5b67f80          CMP      r6,#0x100
0000a4  d004              BEQ      |L35.176|
;;;1206     {
;;;1207       RTC->ALRMAR = (uint32_t)tmpreg;
;;;1208     }
;;;1209     else
;;;1210     {
;;;1211       RTC->ALRMBR = (uint32_t)tmpreg;
0000a6  1f0a              SUBS     r2,r1,#4
0000a8  6010              STR      r0,[r2,#0]
                  |L35.170|
;;;1212     }
;;;1213   
;;;1214     /* Enable the write protection for RTC registers */
;;;1215     RTC->WPR = 0xFF;   
0000aa  20ff              MOVS     r0,#0xff
0000ac  6008              STR      r0,[r1,#0]
;;;1216   }
0000ae  bd70              POP      {r4-r6,pc}
                  |L35.176|
0000b0  4a01              LDR      r2,|L35.184|
0000b2  3214              ADDS     r2,r2,#0x14           ;1207
0000b4  6010              STR      r0,[r2,#0]            ;1207
0000b6  e7f8              B        |L35.170|
;;;1217   
                          ENDP

                  |L35.184|
                          DCD      0x40002808

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

                  RTC_SetDate PROC
;;;944      */
;;;945    ErrorStatus RTC_SetDate(uint32_t RTC_Format, RTC_DateTypeDef* RTC_DateStruct)
000000  b570              PUSH     {r4-r6,lr}
;;;946    {
000002  4605              MOV      r5,r0
000004  460c              MOV      r4,r1
;;;947      uint32_t tmpreg = 0;
;;;948      ErrorStatus status = ERROR;
000006  2600              MOVS     r6,#0
;;;949      
;;;950      /* Check the parameters */
;;;951      assert_param(IS_RTC_FORMAT(RTC_Format));
;;;952    
;;;953      if ((RTC_Format == RTC_Format_BIN) && ((RTC_DateStruct->RTC_Month & 0x10) == 0x10))
000008  2d00              CMP      r5,#0
00000a  d106              BNE      |L36.26|
00000c  7860              LDRB     r0,[r4,#1]
00000e  06c1              LSLS     r1,r0,#27
000010  d503              BPL      |L36.26|
;;;954      {
;;;955        RTC_DateStruct->RTC_Month = (RTC_DateStruct->RTC_Month & (uint32_t)~(0x10)) + 0x0A;
000012  f0200010          BIC      r0,r0,#0x10
000016  300a              ADDS     r0,r0,#0xa
000018  7060              STRB     r0,[r4,#1]
                  |L36.26|
;;;956      }  
;;;957      if (RTC_Format == RTC_Format_BIN)
00001a  b12d              CBZ      r5,|L36.40|
;;;958      {
;;;959        assert_param(IS_RTC_YEAR(RTC_DateStruct->RTC_Year));
;;;960        assert_param(IS_RTC_MONTH(RTC_DateStruct->RTC_Month));
;;;961        assert_param(IS_RTC_DATE(RTC_DateStruct->RTC_Date));
;;;962      }
;;;963      else
;;;964      {
;;;965        assert_param(IS_RTC_YEAR(RTC_Bcd2ToByte(RTC_DateStruct->RTC_Year)));
;;;966        tmpreg = RTC_Bcd2ToByte(RTC_DateStruct->RTC_Month);
00001c  7860              LDRB     r0,[r4,#1]
00001e  f7fffffe          BL       RTC_Bcd2ToByte
;;;967        assert_param(IS_RTC_MONTH(tmpreg));
;;;968        tmpreg = RTC_Bcd2ToByte(RTC_DateStruct->RTC_Date);
000022  78a0              LDRB     r0,[r4,#2]
000024  f7fffffe          BL       RTC_Bcd2ToByte
                  |L36.40|
;;;969        assert_param(IS_RTC_DATE(tmpreg));
;;;970      }
;;;971      assert_param(IS_RTC_WEEKDAY(RTC_DateStruct->RTC_WeekDay));
;;;972    
;;;973      /* Check the input parameters format */
;;;974      if (RTC_Format != RTC_Format_BIN)
000028  b155              CBZ      r5,|L36.64|
;;;975      {
;;;976        tmpreg = ((((uint32_t)RTC_DateStruct->RTC_Year) << 16) | \
00002a  78a0              LDRB     r0,[r4,#2]
00002c  78e1              LDRB     r1,[r4,#3]
00002e  ea404501          ORR      r5,r0,r1,LSL #16
000032  7860              LDRB     r0,[r4,#1]
000034  7821              LDRB     r1,[r4,#0]
000036  0200              LSLS     r0,r0,#8
000038  ea403041          ORR      r0,r0,r1,LSL #13
00003c  4305              ORRS     r5,r5,r0
00003e  e00f              B        |L36.96|
                  |L36.64|
;;;977                  (((uint32_t)RTC_DateStruct->RTC_Month) << 8) | \
;;;978                  ((uint32_t)RTC_DateStruct->RTC_Date) | \
;;;979                  (((uint32_t)RTC_DateStruct->RTC_WeekDay) << 13)); 
;;;980      }  
;;;981      else
;;;982      {
;;;983        tmpreg = (((uint32_t)RTC_ByteToBcd2(RTC_DateStruct->RTC_Year) << 16) | \
000040  78e0              LDRB     r0,[r4,#3]
000042  f7fffffe          BL       RTC_ByteToBcd2
000046  0405              LSLS     r5,r0,#16
000048  7860              LDRB     r0,[r4,#1]
00004a  f7fffffe          BL       RTC_ByteToBcd2
00004e  ea452500          ORR      r5,r5,r0,LSL #8
000052  78a0              LDRB     r0,[r4,#2]
000054  f7fffffe          BL       RTC_ByteToBcd2
000058  4305              ORRS     r5,r5,r0
00005a  7820              LDRB     r0,[r4,#0]
00005c  ea453540          ORR      r5,r5,r0,LSL #13
                  |L36.96|
;;;984                  ((uint32_t)RTC_ByteToBcd2(RTC_DateStruct->RTC_Month) << 8) | \
;;;985                  ((uint32_t)RTC_ByteToBcd2(RTC_DateStruct->RTC_Date)) | \
;;;986                  ((uint32_t)RTC_DateStruct->RTC_WeekDay << 13));
;;;987      }
;;;988    
;;;989      /* Disable the write protection for RTC registers */
;;;990      RTC->WPR = 0xCA;
000060  4c0e              LDR      r4,|L36.156|
000062  20ca              MOVS     r0,#0xca
000064  6020              STR      r0,[r4,#0]
;;;991      RTC->WPR = 0x53;
000066  2053              MOVS     r0,#0x53
000068  6020              STR      r0,[r4,#0]
;;;992    
;;;993      /* Set Initialization mode */
;;;994      if (RTC_EnterInitMode() == ERROR)
00006a  f7fffffe          BL       RTC_EnterInitMode
00006e  b188              CBZ      r0,|L36.148|
;;;995      {
;;;996        status = ERROR;
;;;997      } 
;;;998      else
;;;999      {
;;;1000       /* Set the RTC_DR register */
;;;1001       RTC->DR = (uint32_t)(tmpreg & RTC_DR_RESERVED_MASK);
000070  480b              LDR      r0,|L36.160|
000072  4005              ANDS     r5,r5,r0
000074  4809              LDR      r0,|L36.156|
000076  3820              SUBS     r0,r0,#0x20
000078  6005              STR      r5,[r0,#0]
;;;1002   
;;;1003       /* Exit Initialization mode */
;;;1004       RTC_ExitInitMode(); 
00007a  f7fffffe          BL       RTC_ExitInitMode
;;;1005   
;;;1006       /* If  RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
;;;1007       if ((RTC->CR & RTC_CR_BYPSHAD) == RESET)
00007e  4807              LDR      r0,|L36.156|
000080  381c              SUBS     r0,r0,#0x1c
000082  6800              LDR      r0,[r0,#0]
000084  0680              LSLS     r0,r0,#26
000086  d404              BMI      |L36.146|
;;;1008       {
;;;1009       if(RTC_WaitForSynchro() == ERROR)
000088  f7fffffe          BL       RTC_WaitForSynchro
00008c  b110              CBZ      r0,|L36.148|
;;;1010       {
;;;1011         status = ERROR;
;;;1012       }
;;;1013       else
;;;1014       {
;;;1015         status = SUCCESS;
00008e  2601              MOVS     r6,#1
000090  e000              B        |L36.148|
                  |L36.146|
;;;1016       }
;;;1017     }
;;;1018       else
;;;1019       {
;;;1020         status = SUCCESS;
000092  2601              MOVS     r6,#1
                  |L36.148|
;;;1021       }
;;;1022     }
;;;1023     /* Enable the write protection for RTC registers */
;;;1024     RTC->WPR = 0xFF;   
000094  20ff              MOVS     r0,#0xff
000096  6020              STR      r0,[r4,#0]
;;;1025     
;;;1026     return status;
000098  4630              MOV      r0,r6
;;;1027   }
00009a  bd70              POP      {r4-r6,pc}
;;;1028   
                          ENDP

                  |L36.156|
                          DCD      0x40002824
                  |L36.160|
                          DCD      0x00ffff3f

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

                  RTC_SetTime PROC
;;;764      */
;;;765    ErrorStatus RTC_SetTime(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_TimeStruct)
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;766    {
000004  4605              MOV      r5,r0
000006  460c              MOV      r4,r1
;;;767      uint32_t tmpreg = 0;
;;;768      ErrorStatus status = ERROR;
000008  2600              MOVS     r6,#0
;;;769        
;;;770      /* Check the parameters */
;;;771      assert_param(IS_RTC_FORMAT(RTC_Format));
;;;772      
;;;773      if (RTC_Format == RTC_Format_BIN)
00000a  2000              MOVS     r0,#0
;;;774      {
;;;775        if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET)
00000c  4f24              LDR      r7,|L37.160|
00000e  2d00              CMP      r5,#0                 ;773
000010  d006              BEQ      |L37.32|
;;;776        {
;;;777          assert_param(IS_RTC_HOUR12(RTC_TimeStruct->RTC_Hours));
;;;778          assert_param(IS_RTC_H12(RTC_TimeStruct->RTC_H12));
;;;779        } 
;;;780        else
;;;781        {
;;;782          RTC_TimeStruct->RTC_H12 = 0x00;
;;;783          assert_param(IS_RTC_HOUR24(RTC_TimeStruct->RTC_Hours));
;;;784        }
;;;785        assert_param(IS_RTC_MINUTES(RTC_TimeStruct->RTC_Minutes));
;;;786        assert_param(IS_RTC_SECONDS(RTC_TimeStruct->RTC_Seconds));
;;;787      }
;;;788      else
;;;789      {
;;;790        if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET)
000012  6839              LDR      r1,[r7,#0]
000014  0649              LSLS     r1,r1,#25
000016  d508              BPL      |L37.42|
;;;791        {
;;;792          tmpreg = RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Hours);
000018  7820              LDRB     r0,[r4,#0]
00001a  f7fffffe          BL       RTC_Bcd2ToByte
;;;793          assert_param(IS_RTC_HOUR12(tmpreg));
;;;794          assert_param(IS_RTC_H12(RTC_TimeStruct->RTC_H12)); 
00001e  e005              B        |L37.44|
                  |L37.32|
000020  6839              LDR      r1,[r7,#0]            ;775
000022  0649              LSLS     r1,r1,#25             ;775
000024  d402              BMI      |L37.44|
000026  70e0              STRB     r0,[r4,#3]            ;782
000028  e000              B        |L37.44|
                  |L37.42|
;;;795        } 
;;;796        else
;;;797        {
;;;798          RTC_TimeStruct->RTC_H12 = 0x00;
00002a  70e0              STRB     r0,[r4,#3]
                  |L37.44|
;;;799          assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Hours)));
;;;800        }
;;;801        assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Minutes)));
;;;802        assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Seconds)));
;;;803      }
;;;804      
;;;805      /* Check the input parameters format */
;;;806      if (RTC_Format != RTC_Format_BIN)
00002c  b155              CBZ      r5,|L37.68|
;;;807      {
;;;808        tmpreg = (((uint32_t)(RTC_TimeStruct->RTC_Hours) << 16) | \
00002e  78a0              LDRB     r0,[r4,#2]
000030  7821              LDRB     r1,[r4,#0]
000032  ea404501          ORR      r5,r0,r1,LSL #16
000036  7860              LDRB     r0,[r4,#1]
000038  78e1              LDRB     r1,[r4,#3]
00003a  0200              LSLS     r0,r0,#8
00003c  ea404001          ORR      r0,r0,r1,LSL #16
000040  4305              ORRS     r5,r5,r0
000042  e00f              B        |L37.100|
                  |L37.68|
;;;809                 ((uint32_t)(RTC_TimeStruct->RTC_Minutes) << 8) | \
;;;810                 ((uint32_t)RTC_TimeStruct->RTC_Seconds) | \
;;;811                 ((uint32_t)(RTC_TimeStruct->RTC_H12) << 16)); 
;;;812      }  
;;;813      else
;;;814      {
;;;815        tmpreg = (uint32_t)(((uint32_t)RTC_ByteToBcd2(RTC_TimeStruct->RTC_Hours) << 16) | \
000044  7820              LDRB     r0,[r4,#0]
000046  f7fffffe          BL       RTC_ByteToBcd2
00004a  0405              LSLS     r5,r0,#16
00004c  7860              LDRB     r0,[r4,#1]
00004e  f7fffffe          BL       RTC_ByteToBcd2
000052  ea452500          ORR      r5,r5,r0,LSL #8
000056  78a0              LDRB     r0,[r4,#2]
000058  f7fffffe          BL       RTC_ByteToBcd2
00005c  4305              ORRS     r5,r5,r0
00005e  78e0              LDRB     r0,[r4,#3]
000060  ea454500          ORR      r5,r5,r0,LSL #16
                  |L37.100|
;;;816                       ((uint32_t)RTC_ByteToBcd2(RTC_TimeStruct->RTC_Minutes) << 8) | \
;;;817                       ((uint32_t)RTC_ByteToBcd2(RTC_TimeStruct->RTC_Seconds)) | \
;;;818                       (((uint32_t)RTC_TimeStruct->RTC_H12) << 16));
;;;819      }  
;;;820    
;;;821      /* Disable the write protection for RTC registers */
;;;822      RTC->WPR = 0xCA;
000064  4c0e              LDR      r4,|L37.160|
000066  20ca              MOVS     r0,#0xca
000068  341c              ADDS     r4,r4,#0x1c
00006a  6020              STR      r0,[r4,#0]
;;;823      RTC->WPR = 0x53;
00006c  2053              MOVS     r0,#0x53
00006e  6020              STR      r0,[r4,#0]
;;;824    
;;;825      /* Set Initialization mode */
;;;826      if (RTC_EnterInitMode() == ERROR)
000070  f7fffffe          BL       RTC_EnterInitMode
000074  b178              CBZ      r0,|L37.150|
;;;827      {
;;;828        status = ERROR;
;;;829      } 
;;;830      else
;;;831      {
;;;832        /* Set the RTC_TR register */
;;;833        RTC->TR = (uint32_t)(tmpreg & RTC_TR_RESERVED_MASK);
000076  480b              LDR      r0,|L37.164|
000078  4005              ANDS     r5,r5,r0
00007a  4809              LDR      r0,|L37.160|
00007c  3808              SUBS     r0,r0,#8
00007e  6005              STR      r5,[r0,#0]
;;;834    
;;;835        /* Exit Initialization mode */
;;;836        RTC_ExitInitMode(); 
000080  f7fffffe          BL       RTC_ExitInitMode
;;;837    
;;;838        /* If  RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
;;;839        if ((RTC->CR & RTC_CR_BYPSHAD) == RESET)
000084  6838              LDR      r0,[r7,#0]
000086  0680              LSLS     r0,r0,#26
000088  d404              BMI      |L37.148|
;;;840        {
;;;841        if(RTC_WaitForSynchro() == ERROR)
00008a  f7fffffe          BL       RTC_WaitForSynchro
00008e  b110              CBZ      r0,|L37.150|
;;;842        {
;;;843          status = ERROR;
;;;844        }
;;;845        else
;;;846        {
;;;847          status = SUCCESS;
000090  2601              MOVS     r6,#1
000092  e000              B        |L37.150|
                  |L37.148|
;;;848        }
;;;849      }
;;;850        else
;;;851        {
;;;852          status = SUCCESS;
000094  2601              MOVS     r6,#1
                  |L37.150|
;;;853        }
;;;854      }
;;;855      /* Enable the write protection for RTC registers */
;;;856      RTC->WPR = 0xFF; 
000096  20ff              MOVS     r0,#0xff
000098  6020              STR      r0,[r4,#0]
;;;857        
;;;858      return status;
00009a  4630              MOV      r0,r6
;;;859    }
00009c  e8bd81f0          POP      {r4-r8,pc}
;;;860    
                          ENDP

                  |L37.160|
                          DCD      0x40002808
                  |L37.164|
                          DCD      0x007f7f7f

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

                  RTC_SetWakeUpCounter PROC
;;;1520     */
;;;1521   void RTC_SetWakeUpCounter(uint32_t RTC_WakeUpCounter)
000000  4905              LDR      r1,|L38.24|
;;;1522   {
;;;1523     /* Check the parameters */
;;;1524     assert_param(IS_RTC_WAKEUP_COUNTER(RTC_WakeUpCounter));
;;;1525     
;;;1526     /* Disable the write protection for RTC registers */
;;;1527     RTC->WPR = 0xCA;
000002  22ca              MOVS     r2,#0xca
000004  600a              STR      r2,[r1,#0]
;;;1528     RTC->WPR = 0x53;
000006  2253              MOVS     r2,#0x53
000008  600a              STR      r2,[r1,#0]
;;;1529     
;;;1530     /* Configure the Wakeup Timer counter */
;;;1531     RTC->WUTR = (uint32_t)RTC_WakeUpCounter;
00000a  4a03              LDR      r2,|L38.24|
00000c  3a10              SUBS     r2,r2,#0x10
00000e  6010              STR      r0,[r2,#0]
;;;1532     
;;;1533     /* Enable the write protection for RTC registers */
;;;1534     RTC->WPR = 0xFF; 
000010  20ff              MOVS     r0,#0xff
000012  6008              STR      r0,[r1,#0]
;;;1535   }
000014  4770              BX       lr
;;;1536   
                          ENDP

000016  0000              DCW      0x0000
                  |L38.24|
                          DCD      0x40002824

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

                  RTC_SmoothCalibConfig PROC
;;;1905   */
;;;1906   ErrorStatus RTC_SmoothCalibConfig(uint32_t RTC_SmoothCalibPeriod,
000000  b5f0              PUSH     {r4-r7,lr}
;;;1907                                     uint32_t RTC_SmoothCalibPlusPulses,
;;;1908                                     uint32_t RTC_SmouthCalibMinusPulsesValue)
;;;1909   {
;;;1910     ErrorStatus status = ERROR;
;;;1911     uint32_t recalpfcount = 0;
000002  2300              MOVS     r3,#0
;;;1912   
;;;1913     /* Check the parameters */
;;;1914     assert_param(IS_RTC_SMOOTH_CALIB_PERIOD(RTC_SmoothCalibPeriod));
;;;1915     assert_param(IS_RTC_SMOOTH_CALIB_PLUS(RTC_SmoothCalibPlusPulses));
;;;1916     assert_param(IS_RTC_SMOOTH_CALIB_MINUS(RTC_SmouthCalibMinusPulsesValue));
;;;1917   
;;;1918     /* Disable the write protection for RTC registers */
;;;1919     RTC->WPR = 0xCA;
000004  4e10              LDR      r6,|L39.72|
000006  24ca              MOVS     r4,#0xca
000008  6034              STR      r4,[r6,#0]
;;;1920     RTC->WPR = 0x53;
00000a  2453              MOVS     r4,#0x53
00000c  6034              STR      r4,[r6,#0]
;;;1921     
;;;1922     /* check if a calibration is pending*/
;;;1923     if ((RTC->ISR & RTC_ISR_RECALPF) != RESET)
00000e  4c0e              LDR      r4,|L39.72|
000010  3c18              SUBS     r4,r4,#0x18
000012  6825              LDR      r5,[r4,#0]
000014  03ed              LSLS     r5,r5,#15
000016  d508              BPL      |L39.42|
;;;1924     {
;;;1925       /* wait until the Calibration is completed*/
;;;1926       while (((RTC->ISR & RTC_ISR_RECALPF) != RESET) && (recalpfcount != RECALPF_TIMEOUT))
000018  f44f3700          MOV      r7,#0x20000
00001c  e000              B        |L39.32|
                  |L39.30|
;;;1927       {
;;;1928         recalpfcount++;
00001e  1c5b              ADDS     r3,r3,#1
                  |L39.32|
000020  6825              LDR      r5,[r4,#0]            ;1926
000022  03ed              LSLS     r5,r5,#15             ;1926
000024  d501              BPL      |L39.42|
000026  42bb              CMP      r3,r7                 ;1926
000028  d1f9              BNE      |L39.30|
                  |L39.42|
;;;1929       }
;;;1930     }
;;;1931   
;;;1932     /* check if the calibration pending is completed or if there is no calibration operation at all*/
;;;1933     if ((RTC->ISR & RTC_ISR_RECALPF) == RESET)
00002a  6823              LDR      r3,[r4,#0]
00002c  03db              LSLS     r3,r3,#15
00002e  d406              BMI      |L39.62|
;;;1934     {
;;;1935       /* Configure the Smooth calibration settings */
;;;1936       RTC->CALR = (uint32_t)((uint32_t)RTC_SmoothCalibPeriod | (uint32_t)RTC_SmoothCalibPlusPulses | (uint32_t)RTC_SmouthCalibMinusPulsesValue);
000030  4308              ORRS     r0,r0,r1
000032  4905              LDR      r1,|L39.72|
000034  4310              ORRS     r0,r0,r2
000036  3118              ADDS     r1,r1,#0x18
000038  6008              STR      r0,[r1,#0]
;;;1937   
;;;1938       status = SUCCESS;
00003a  2001              MOVS     r0,#1
00003c  e000              B        |L39.64|
                  |L39.62|
;;;1939     }
;;;1940     else
;;;1941     {
;;;1942       status = ERROR;
00003e  2000              MOVS     r0,#0
                  |L39.64|
;;;1943     }
;;;1944   
;;;1945     /* Enable the write protection for RTC registers */
;;;1946     RTC->WPR = 0xFF;
000040  21ff              MOVS     r1,#0xff
000042  6031              STR      r1,[r6,#0]
;;;1947     
;;;1948     return (ErrorStatus)(status);
;;;1949   }
000044  bdf0              POP      {r4-r7,pc}
;;;1950   
                          ENDP

000046  0000              DCW      0x0000
                  |L39.72|
                          DCD      0x40002824

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

                  RTC_StructInit PROC
;;;502      */
;;;503    void RTC_StructInit(RTC_InitTypeDef* RTC_InitStruct)
000000  2100              MOVS     r1,#0
;;;504    {
;;;505      /* Initialize the RTC_HourFormat member */
;;;506      RTC_InitStruct->RTC_HourFormat = RTC_HourFormat_24;
000002  6001              STR      r1,[r0,#0]
;;;507        
;;;508      /* Initialize the RTC_AsynchPrediv member */
;;;509      RTC_InitStruct->RTC_AsynchPrediv = (uint32_t)0x7F;
000004  217f              MOVS     r1,#0x7f
000006  6041              STR      r1,[r0,#4]
;;;510    
;;;511      /* Initialize the RTC_SynchPrediv member */
;;;512      RTC_InitStruct->RTC_SynchPrediv = (uint32_t)0xFF; 
000008  21ff              MOVS     r1,#0xff
00000a  6081              STR      r1,[r0,#8]
;;;513    }
00000c  4770              BX       lr
;;;514    
                          ENDP


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

                  RTC_SynchroShiftConfig PROC
;;;2436   */
;;;2437   ErrorStatus RTC_SynchroShiftConfig(uint32_t RTC_ShiftAdd1S, uint32_t RTC_ShiftSubFS)
000000  b570              PUSH     {r4-r6,lr}
;;;2438   {
;;;2439     ErrorStatus status = ERROR;
;;;2440     uint32_t shpfcount = 0;
000002  2200              MOVS     r2,#0
;;;2441   
;;;2442     /* Check the parameters */
;;;2443     assert_param(IS_RTC_SHIFT_ADD1S(RTC_ShiftAdd1S));
;;;2444     assert_param(IS_RTC_SHIFT_SUBFS(RTC_ShiftSubFS));
;;;2445   
;;;2446     /* Disable the write protection for RTC registers */
;;;2447     RTC->WPR = 0xCA;
000004  4d15              LDR      r5,|L41.92|
000006  23ca              MOVS     r3,#0xca
000008  602b              STR      r3,[r5,#0]
;;;2448     RTC->WPR = 0x53;
00000a  2353              MOVS     r3,#0x53
00000c  602b              STR      r3,[r5,#0]
;;;2449     
;;;2450     /* Check if a Shift is pending*/
;;;2451     if ((RTC->ISR & RTC_ISR_SHPF) != RESET)
00000e  4b13              LDR      r3,|L41.92|
000010  3b18              SUBS     r3,r3,#0x18
000012  681c              LDR      r4,[r3,#0]
000014  0724              LSLS     r4,r4,#28
000016  d507              BPL      |L41.40|
;;;2452     {
;;;2453       /* Wait until the shift is completed*/
;;;2454       while (((RTC->ISR & RTC_ISR_SHPF) != RESET) && (shpfcount != SHPF_TIMEOUT))
000018  149e              ASRS     r6,r3,#18
00001a  e000              B        |L41.30|
                  |L41.28|
;;;2455       {
;;;2456         shpfcount++;
00001c  1c52              ADDS     r2,r2,#1
                  |L41.30|
00001e  681c              LDR      r4,[r3,#0]            ;2454
000020  0724              LSLS     r4,r4,#28             ;2454
000022  d501              BPL      |L41.40|
000024  42b2              CMP      r2,r6                 ;2454
000026  d1f9              BNE      |L41.28|
                  |L41.40|
;;;2457       }
;;;2458     }
;;;2459   
;;;2460     /* Check if the Shift pending is completed or if there is no Shift operation at all*/
;;;2461     if ((RTC->ISR & RTC_ISR_SHPF) == RESET)
000028  681a              LDR      r2,[r3,#0]
00002a  0712              LSLS     r2,r2,#28
00002c  d411              BMI      |L41.82|
;;;2462     {
;;;2463       /* check if the reference clock detection is disabled */
;;;2464       if((RTC->CR & RTC_CR_REFCKON) == RESET)
00002e  4a0b              LDR      r2,|L41.92|
000030  3a1c              SUBS     r2,r2,#0x1c
000032  6812              LDR      r2,[r2,#0]
000034  06d2              LSLS     r2,r2,#27
000036  d40a              BMI      |L41.78|
;;;2465       {
;;;2466         /* Configure the Shift settings */
;;;2467         RTC->SHIFTR = (uint32_t)(uint32_t)(RTC_ShiftSubFS) | (uint32_t)(RTC_ShiftAdd1S);
000038  4301              ORRS     r1,r1,r0
00003a  4808              LDR      r0,|L41.92|
00003c  3008              ADDS     r0,r0,#8
00003e  6001              STR      r1,[r0,#0]
;;;2468       
;;;2469         if(RTC_WaitForSynchro() == ERROR)
000040  f7fffffe          BL       RTC_WaitForSynchro
000044  b108              CBZ      r0,|L41.74|
;;;2470         {
;;;2471           status = ERROR;
;;;2472         }
;;;2473         else
;;;2474         {
;;;2475           status = SUCCESS;
000046  2001              MOVS     r0,#1
000048  e004              B        |L41.84|
                  |L41.74|
00004a  2000              MOVS     r0,#0                 ;2471
00004c  e002              B        |L41.84|
                  |L41.78|
;;;2476         }
;;;2477       }
;;;2478       else
;;;2479       {
;;;2480         status = ERROR;
00004e  2000              MOVS     r0,#0
000050  e000              B        |L41.84|
                  |L41.82|
;;;2481       }
;;;2482     }
;;;2483     else
;;;2484     {
;;;2485       status = ERROR;
000052  2000              MOVS     r0,#0
                  |L41.84|
;;;2486     }
;;;2487   
;;;2488     /* Enable the write protection for RTC registers */
;;;2489     RTC->WPR = 0xFF;
000054  21ff              MOVS     r1,#0xff
000056  6029              STR      r1,[r5,#0]
;;;2490     
;;;2491     return (ErrorStatus)(status);
;;;2492   }
000058  bd70              POP      {r4-r6,pc}
;;;2493   
                          ENDP

00005a  0000              DCW      0x0000
                  |L41.92|
                          DCD      0x40002824

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

                  RTC_TamperCmd PROC
;;;2130     */
;;;2131   void RTC_TamperCmd(uint32_t RTC_Tamper, FunctionalState NewState)
000000  4a05              LDR      r2,|L42.24|
;;;2132   {
;;;2133     /* Check the parameters */
;;;2134     assert_param(IS_RTC_TAMPER(RTC_Tamper));  
;;;2135     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;2136     
;;;2137     if (NewState != DISABLE)
000002  2900              CMP      r1,#0
000004  d003              BEQ      |L42.14|
;;;2138     {
;;;2139       /* Enable the selected Tamper pin */
;;;2140       RTC->TAFCR |= (uint32_t)RTC_Tamper;
000006  6811              LDR      r1,[r2,#0]
000008  4301              ORRS     r1,r1,r0
00000a  6011              STR      r1,[r2,#0]
;;;2141     }
;;;2142     else
;;;2143     {
;;;2144       /* Disable the selected Tamper pin */
;;;2145       RTC->TAFCR &= (uint32_t)~RTC_Tamper;    
;;;2146     }  
;;;2147   }
00000c  4770              BX       lr
                  |L42.14|
00000e  6811              LDR      r1,[r2,#0]            ;2145
000010  4381              BICS     r1,r1,r0              ;2145
000012  6011              STR      r1,[r2,#0]            ;2145
000014  4770              BX       lr
;;;2148   
                          ENDP

000016  0000              DCW      0x0000
                  |L42.24|
                          DCD      0x40002840

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

                  RTC_TamperFilterConfig PROC
;;;2161     */
;;;2162   void RTC_TamperFilterConfig(uint32_t RTC_TamperFilter)
000000  4904              LDR      r1,|L43.20|
;;;2163   {
;;;2164     /* Check the parameters */
;;;2165     assert_param(IS_RTC_TAMPER_FILTER(RTC_TamperFilter));
;;;2166      
;;;2167     /* Clear TAMPFLT[1:0] bits in the RTC_TAFCR register */
;;;2168     RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TAMPFLT);
000002  680a              LDR      r2,[r1,#0]
000004  f42252c0          BIC      r2,r2,#0x1800
000008  600a              STR      r2,[r1,#0]
;;;2169   
;;;2170     /* Configure the RTC_TAFCR register */
;;;2171     RTC->TAFCR |= (uint32_t)RTC_TamperFilter;
00000a  680a              LDR      r2,[r1,#0]
00000c  4302              ORRS     r2,r2,r0
00000e  600a              STR      r2,[r1,#0]
;;;2172   }
000010  4770              BX       lr
;;;2173   
                          ENDP

000012  0000              DCW      0x0000
                  |L43.20|
                          DCD      0x40002840

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

                  RTC_TamperPinSelection PROC
;;;2362     */
;;;2363   void RTC_TamperPinSelection(uint32_t RTC_TamperPin)
000000  4904              LDR      r1,|L44.20|
;;;2364   {
;;;2365     /* Check the parameters */
;;;2366     assert_param(IS_RTC_TAMPER_PIN(RTC_TamperPin));
;;;2367     
;;;2368     RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TAMPINSEL);
000002  680a              LDR      r2,[r1,#0]
000004  f4223280          BIC      r2,r2,#0x10000
000008  600a              STR      r2,[r1,#0]
;;;2369     RTC->TAFCR |= (uint32_t)(RTC_TamperPin);  
00000a  680a              LDR      r2,[r1,#0]
00000c  4302              ORRS     r2,r2,r0
00000e  600a              STR      r2,[r1,#0]
;;;2370   }
000010  4770              BX       lr
;;;2371   
                          ENDP

000012  0000              DCW      0x0000
                  |L44.20|
                          DCD      0x40002840

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

                  RTC_TamperPinsPrechargeDuration PROC
;;;2218     */
;;;2219   void RTC_TamperPinsPrechargeDuration(uint32_t RTC_TamperPrechargeDuration)
000000  4904              LDR      r1,|L45.20|
;;;2220   {
;;;2221     /* Check the parameters */
;;;2222     assert_param(IS_RTC_TAMPER_PRECHARGE_DURATION(RTC_TamperPrechargeDuration));
;;;2223      
;;;2224     /* Clear TAMPPRCH[1:0] bits in the RTC_TAFCR register */
;;;2225     RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TAMPPRCH);
000002  680a              LDR      r2,[r1,#0]
000004  f42242c0          BIC      r2,r2,#0x6000
000008  600a              STR      r2,[r1,#0]
;;;2226   
;;;2227     /* Configure the RTC_TAFCR register */
;;;2228     RTC->TAFCR |= (uint32_t)RTC_TamperPrechargeDuration;
00000a  680a              LDR      r2,[r1,#0]
00000c  4302              ORRS     r2,r2,r0
00000e  600a              STR      r2,[r1,#0]
;;;2229   }
000010  4770              BX       lr
;;;2230   
                          ENDP

000012  0000              DCW      0x0000
                  |L45.20|
                          DCD      0x40002840

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

                  RTC_TamperPullUpCmd PROC
;;;2261     */
;;;2262   void RTC_TamperPullUpCmd(FunctionalState NewState)
000000  4906              LDR      r1,|L46.28|
;;;2263   {
;;;2264     /* Check the parameters */
;;;2265     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;2266     
;;;2267    if (NewState != DISABLE)
000002  2800              CMP      r0,#0
000004  d004              BEQ      |L46.16|
;;;2268     {
;;;2269       /* Enable precharge of the selected Tamper pin */
;;;2270       RTC->TAFCR &= (uint32_t)~RTC_TAFCR_TAMPPUDIS; 
000006  6808              LDR      r0,[r1,#0]
000008  f4204000          BIC      r0,r0,#0x8000
00000c  6008              STR      r0,[r1,#0]
;;;2271     }
;;;2272     else
;;;2273     {
;;;2274       /* Disable precharge of the selected Tamper pin */
;;;2275       RTC->TAFCR |= (uint32_t)RTC_TAFCR_TAMPPUDIS;    
;;;2276     } 
;;;2277   }
00000e  4770              BX       lr
                  |L46.16|
000010  6808              LDR      r0,[r1,#0]            ;2275
000012  f4404000          ORR      r0,r0,#0x8000         ;2275
000016  6008              STR      r0,[r1,#0]            ;2275
000018  4770              BX       lr
;;;2278   
                          ENDP

00001a  0000              DCW      0x0000
                  |L46.28|
                          DCD      0x40002840

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

                  RTC_TamperSamplingFreqConfig PROC
;;;2195     */
;;;2196   void RTC_TamperSamplingFreqConfig(uint32_t RTC_TamperSamplingFreq)
000000  4904              LDR      r1,|L47.20|
;;;2197   {
;;;2198     /* Check the parameters */
;;;2199     assert_param(IS_RTC_TAMPER_SAMPLING_FREQ(RTC_TamperSamplingFreq));
;;;2200    
;;;2201     /* Clear TAMPFREQ[2:0] bits in the RTC_TAFCR register */
;;;2202     RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TAMPFREQ);
000002  680a              LDR      r2,[r1,#0]
000004  f42262e0          BIC      r2,r2,#0x700
000008  600a              STR      r2,[r1,#0]
;;;2203   
;;;2204     /* Configure the RTC_TAFCR register */
;;;2205     RTC->TAFCR |= (uint32_t)RTC_TamperSamplingFreq;
00000a  680a              LDR      r2,[r1,#0]
00000c  4302              ORRS     r2,r2,r0
00000e  600a              STR      r2,[r1,#0]
;;;2206   }
000010  4770              BX       lr
;;;2207   
                          ENDP

000012  0000              DCW      0x0000
                  |L47.20|
                          DCD      0x40002840

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

                  RTC_TamperTriggerConfig PROC
;;;2104     */
;;;2105   void RTC_TamperTriggerConfig(uint32_t RTC_Tamper, uint32_t RTC_TamperTrigger)
000000  4a06              LDR      r2,|L48.28|
;;;2106   {
;;;2107     /* Check the parameters */
;;;2108     assert_param(IS_RTC_TAMPER(RTC_Tamper)); 
;;;2109     assert_param(IS_RTC_TAMPER_TRIGGER(RTC_TamperTrigger));
;;;2110    
;;;2111     if (RTC_TamperTrigger == RTC_TamperTrigger_RisingEdge)
000002  2900              CMP      r1,#0
000004  d004              BEQ      |L48.16|
;;;2112     {  
;;;2113       /* Configure the RTC_TAFCR register */
;;;2114       RTC->TAFCR &= (uint32_t)((uint32_t)~(RTC_Tamper << 1));	
;;;2115     }
;;;2116     else
;;;2117     { 
;;;2118       /* Configure the RTC_TAFCR register */
;;;2119       RTC->TAFCR |= (uint32_t)(RTC_Tamper << 1);  
000006  6811              LDR      r1,[r2,#0]
000008  ea410040          ORR      r0,r1,r0,LSL #1
00000c  6010              STR      r0,[r2,#0]
;;;2120     }  
;;;2121   }
00000e  4770              BX       lr
                  |L48.16|
000010  6811              LDR      r1,[r2,#0]            ;2114
000012  ea210040          BIC      r0,r1,r0,LSL #1       ;2114
000016  6010              STR      r0,[r2,#0]            ;2114
000018  4770              BX       lr
;;;2122   
                          ENDP

00001a  0000              DCW      0x0000
                  |L48.28|
                          DCD      0x40002840

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

                  RTC_TimeStampCmd PROC
;;;1981     */
;;;1982   void RTC_TimeStampCmd(uint32_t RTC_TimeStampEdge, FunctionalState NewState)
000000  b510              PUSH     {r4,lr}
;;;1983   {
;;;1984     uint32_t tmpreg = 0;
;;;1985   
;;;1986     /* Check the parameters */
;;;1987     assert_param(IS_RTC_TIMESTAMP_EDGE(RTC_TimeStampEdge));
;;;1988     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1989   
;;;1990     /* Get the RTC_CR register and clear the bits to be configured */
;;;1991     tmpreg = (uint32_t)(RTC->CR & (uint32_t)~(RTC_CR_TSEDGE | RTC_CR_TSE));
000002  4b0b              LDR      r3,|L49.48|
000004  681a              LDR      r2,[r3,#0]
000006  f6400408          MOV      r4,#0x808
00000a  43a2              BICS     r2,r2,r4
;;;1992   
;;;1993     /* Get the new configuration */
;;;1994     if (NewState != DISABLE)
00000c  2900              CMP      r1,#0
00000e  d003              BEQ      |L49.24|
;;;1995     {
;;;1996       tmpreg |= (uint32_t)(RTC_TimeStampEdge | RTC_CR_TSE);
000010  4302              ORRS     r2,r2,r0
000012  f4426200          ORR      r2,r2,#0x800
000016  e000              B        |L49.26|
                  |L49.24|
;;;1997     }
;;;1998     else
;;;1999     {
;;;2000       tmpreg |= (uint32_t)(RTC_TimeStampEdge);
000018  4302              ORRS     r2,r2,r0
                  |L49.26|
;;;2001     }
;;;2002   
;;;2003     /* Disable the write protection for RTC registers */
;;;2004     RTC->WPR = 0xCA;
00001a  4805              LDR      r0,|L49.48|
00001c  21ca              MOVS     r1,#0xca
00001e  301c              ADDS     r0,r0,#0x1c
000020  6001              STR      r1,[r0,#0]
;;;2005     RTC->WPR = 0x53;
000022  2153              MOVS     r1,#0x53
000024  6001              STR      r1,[r0,#0]
;;;2006   
;;;2007     /* Configure the Time Stamp TSEDGE and Enable bits */
;;;2008     RTC->CR = (uint32_t)tmpreg;
000026  601a              STR      r2,[r3,#0]
;;;2009   
;;;2010     /* Enable the write protection for RTC registers */
;;;2011     RTC->WPR = 0xFF; 
000028  21ff              MOVS     r1,#0xff
00002a  6001              STR      r1,[r0,#0]
;;;2012   }
00002c  bd10              POP      {r4,pc}
;;;2013   
                          ENDP

00002e  0000              DCW      0x0000
                  |L49.48|
                          DCD      0x40002808

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

                  RTC_TimeStampOnTamperDetectionCmd PROC
;;;2238     */
;;;2239   void RTC_TimeStampOnTamperDetectionCmd(FunctionalState NewState)
000000  4906              LDR      r1,|L50.28|
;;;2240   {
;;;2241     /* Check the parameters */
;;;2242     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;2243      
;;;2244     if (NewState != DISABLE)
000002  2800              CMP      r0,#0
000004  d004              BEQ      |L50.16|
;;;2245     {
;;;2246       /* Save timestamp on tamper detection event */
;;;2247       RTC->TAFCR |= (uint32_t)RTC_TAFCR_TAMPTS;
000006  6808              LDR      r0,[r1,#0]
000008  f0400080          ORR      r0,r0,#0x80
00000c  6008              STR      r0,[r1,#0]
;;;2248     }
;;;2249     else
;;;2250     {
;;;2251       /* Tamper detection does not cause a timestamp to be saved */
;;;2252       RTC->TAFCR &= (uint32_t)~RTC_TAFCR_TAMPTS;    
;;;2253     }
;;;2254   }
00000e  4770              BX       lr
                  |L50.16|
000010  6808              LDR      r0,[r1,#0]            ;2252
000012  f0200080          BIC      r0,r0,#0x80           ;2252
000016  6008              STR      r0,[r1,#0]            ;2252
000018  4770              BX       lr
;;;2255   
                          ENDP

00001a  0000              DCW      0x0000
                  |L50.28|
                          DCD      0x40002840

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

                  RTC_TimeStampPinSelection PROC
;;;2379     */
;;;2380   void RTC_TimeStampPinSelection(uint32_t RTC_TimeStampPin)
000000  4904              LDR      r1,|L51.20|
;;;2381   {
;;;2382     /* Check the parameters */
;;;2383     assert_param(IS_RTC_TIMESTAMP_PIN(RTC_TimeStampPin));
;;;2384     
;;;2385     RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TSINSEL);
000002  680a              LDR      r2,[r1,#0]
000004  f4223200          BIC      r2,r2,#0x20000
000008  600a              STR      r2,[r1,#0]
;;;2386     RTC->TAFCR |= (uint32_t)(RTC_TimeStampPin);  
00000a  680a              LDR      r2,[r1,#0]
00000c  4302              ORRS     r2,r2,r0
00000e  600a              STR      r2,[r1,#0]
;;;2387   }
000010  4770              BX       lr
;;;2388   
                          ENDP

000012  0000              DCW      0x0000
                  |L51.20|
                          DCD      0x40002840

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

                  RTC_TimeStructInit PROC
;;;867      */
;;;868    void RTC_TimeStructInit(RTC_TimeTypeDef* RTC_TimeStruct)
000000  2100              MOVS     r1,#0
;;;869    {
;;;870      /* Time = 00h:00min:00sec */
;;;871      RTC_TimeStruct->RTC_H12 = RTC_H12_AM;
000002  70c1              STRB     r1,[r0,#3]
;;;872      RTC_TimeStruct->RTC_Hours = 0;
000004  7001              STRB     r1,[r0,#0]
;;;873      RTC_TimeStruct->RTC_Minutes = 0;
000006  7041              STRB     r1,[r0,#1]
;;;874      RTC_TimeStruct->RTC_Seconds = 0; 
000008  7081              STRB     r1,[r0,#2]
;;;875    }
00000a  4770              BX       lr
;;;876    
                          ENDP


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

                  RTC_WaitForSynchro PROC
;;;618      */
;;;619    ErrorStatus RTC_WaitForSynchro(void)
000000  b518              PUSH     {r3,r4,lr}
;;;620    {
;;;621      __IO uint32_t synchrocounter = 0;
000002  2000              MOVS     r0,#0
000004  9000              STR      r0,[sp,#0]
;;;622      ErrorStatus status = ERROR;
;;;623      uint32_t synchrostatus = 0x00;
;;;624    
;;;625      /* Disable the write protection for RTC registers */
;;;626      RTC->WPR = 0xCA;
000006  4b10              LDR      r3,|L53.72|
000008  20ca              MOVS     r0,#0xca
00000a  6018              STR      r0,[r3,#0]
;;;627      RTC->WPR = 0x53;
00000c  2053              MOVS     r0,#0x53
00000e  6018              STR      r0,[r3,#0]
;;;628        
;;;629      /* Clear RSF flag */
;;;630      RTC->ISR &= (uint32_t)RTC_RSF_MASK;
000010  490d              LDR      r1,|L53.72|
000012  3918              SUBS     r1,r1,#0x18
000014  6808              LDR      r0,[r1,#0]
000016  f02000a0          BIC      r0,r0,#0xa0
00001a  6008              STR      r0,[r1,#0]
;;;631        
;;;632      /* Wait the registers to be synchronised */
;;;633      do
;;;634      {
;;;635        synchrostatus = RTC->ISR & RTC_ISR_RSF;
;;;636        synchrocounter++;  
;;;637      } while((synchrocounter != SYNCHRO_TIMEOUT) && (synchrostatus == 0x00));
00001c  f44f3400          MOV      r4,#0x20000
                  |L53.32|
000020  6808              LDR      r0,[r1,#0]            ;635
000022  f0000020          AND      r0,r0,#0x20           ;635
000026  9a00              LDR      r2,[sp,#0]            ;636
000028  1c52              ADDS     r2,r2,#1              ;636
00002a  9200              STR      r2,[sp,#0]            ;636
00002c  9a00              LDR      r2,[sp,#0]
00002e  42a2              CMP      r2,r4
000030  d001              BEQ      |L53.54|
000032  2800              CMP      r0,#0
000034  d0f4              BEQ      |L53.32|
                  |L53.54|
;;;638        
;;;639      if ((RTC->ISR & RTC_ISR_RSF) != RESET)
000036  6808              LDR      r0,[r1,#0]
000038  0680              LSLS     r0,r0,#26
00003a  d501              BPL      |L53.64|
;;;640      {
;;;641        status = SUCCESS;
00003c  2001              MOVS     r0,#1
00003e  e000              B        |L53.66|
                  |L53.64|
;;;642      }
;;;643      else
;;;644      {
;;;645        status = ERROR;
000040  2000              MOVS     r0,#0
                  |L53.66|
;;;646      }        
;;;647    
;;;648      /* Enable the write protection for RTC registers */
;;;649      RTC->WPR = 0xFF; 
000042  21ff              MOVS     r1,#0xff
000044  6019              STR      r1,[r3,#0]
;;;650        
;;;651      return (status); 
;;;652    }
000046  bd18              POP      {r3,r4,pc}
;;;653    
                          ENDP

                  |L53.72|
                          DCD      0x40002824

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

                  RTC_WakeUpClockConfig PROC
;;;1493     */
;;;1494   void RTC_WakeUpClockConfig(uint32_t RTC_WakeUpClock)
000000  4a08              LDR      r2,|L54.36|
;;;1495   {
;;;1496     /* Check the parameters */
;;;1497     assert_param(IS_RTC_WAKEUP_CLOCK(RTC_WakeUpClock));
;;;1498   
;;;1499     /* Disable the write protection for RTC registers */
;;;1500     RTC->WPR = 0xCA;
000002  21ca              MOVS     r1,#0xca
000004  6011              STR      r1,[r2,#0]
;;;1501     RTC->WPR = 0x53;
000006  2153              MOVS     r1,#0x53
000008  6011              STR      r1,[r2,#0]
;;;1502   
;;;1503     /* Clear the Wakeup Timer clock source bits in CR register */
;;;1504     RTC->CR &= (uint32_t)~RTC_CR_WUCKSEL;
00000a  4906              LDR      r1,|L54.36|
00000c  391c              SUBS     r1,r1,#0x1c
00000e  680b              LDR      r3,[r1,#0]
000010  f0230307          BIC      r3,r3,#7
000014  600b              STR      r3,[r1,#0]
;;;1505   
;;;1506     /* Configure the clock source */
;;;1507     RTC->CR |= (uint32_t)RTC_WakeUpClock;
000016  680b              LDR      r3,[r1,#0]
000018  4303              ORRS     r3,r3,r0
00001a  600b              STR      r3,[r1,#0]
;;;1508     
;;;1509     /* Enable the write protection for RTC registers */
;;;1510     RTC->WPR = 0xFF; 
00001c  20ff              MOVS     r0,#0xff
00001e  6010              STR      r0,[r2,#0]
;;;1511   }
000020  4770              BX       lr
;;;1512   
                          ENDP

000022  0000              DCW      0x0000
                  |L54.36|
                          DCD      0x40002824

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

                  RTC_WakeUpCmd PROC
;;;1553     */
;;;1554   ErrorStatus RTC_WakeUpCmd(FunctionalState NewState)
000000  b518              PUSH     {r3,r4,lr}
;;;1555   {
;;;1556     __IO uint32_t wutcounter = 0x00;
000002  2100              MOVS     r1,#0
000004  9100              STR      r1,[sp,#0]
;;;1557     uint32_t wutwfstatus = 0x00;
;;;1558     ErrorStatus status = ERROR;
;;;1559     
;;;1560     /* Check the parameters */
;;;1561     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1562   
;;;1563     /* Disable the write protection for RTC registers */
;;;1564     RTC->WPR = 0xCA;
000006  4b15              LDR      r3,|L55.92|
000008  21ca              MOVS     r1,#0xca
00000a  6019              STR      r1,[r3,#0]
;;;1565     RTC->WPR = 0x53;
00000c  2153              MOVS     r1,#0x53
00000e  6019              STR      r1,[r3,#0]
;;;1566   
;;;1567     if (NewState != DISABLE)
;;;1568     {
;;;1569       /* Enable the Wakeup Timer */
;;;1570       RTC->CR |= (uint32_t)RTC_CR_WUTE;
000010  4912              LDR      r1,|L55.92|
000012  391c              SUBS     r1,r1,#0x1c
000014  2800              CMP      r0,#0                 ;1567
000016  d005              BEQ      |L55.36|
000018  6808              LDR      r0,[r1,#0]
00001a  f4406080          ORR      r0,r0,#0x400
00001e  6008              STR      r0,[r1,#0]
;;;1571       status = SUCCESS;    
000020  2001              MOVS     r0,#1
000022  e017              B        |L55.84|
                  |L55.36|
;;;1572     }
;;;1573     else
;;;1574     {
;;;1575       /* Disable the Wakeup Timer */
;;;1576       RTC->CR &= (uint32_t)~RTC_CR_WUTE;
000024  6808              LDR      r0,[r1,#0]
000026  f4206080          BIC      r0,r0,#0x400
00002a  6008              STR      r0,[r1,#0]
;;;1577       /* Wait till RTC WUTWF flag is set and if Time out is reached exit */
;;;1578       do
;;;1579       {
;;;1580         wutwfstatus = RTC->ISR & RTC_ISR_WUTWF;
00002c  4a0b              LDR      r2,|L55.92|
00002e  3a18              SUBS     r2,r2,#0x18
;;;1581         wutcounter++;  
;;;1582       } while((wutcounter != INITMODE_TIMEOUT) && (wutwfstatus == 0x00));
000030  1394              ASRS     r4,r2,#14
                  |L55.50|
000032  6810              LDR      r0,[r2,#0]            ;1580
000034  f0000004          AND      r0,r0,#4              ;1580
000038  9900              LDR      r1,[sp,#0]            ;1581
00003a  1c49              ADDS     r1,r1,#1              ;1581
00003c  9100              STR      r1,[sp,#0]            ;1581
00003e  9900              LDR      r1,[sp,#0]
000040  42a1              CMP      r1,r4
000042  d001              BEQ      |L55.72|
000044  2800              CMP      r0,#0
000046  d0f4              BEQ      |L55.50|
                  |L55.72|
;;;1583       
;;;1584       if ((RTC->ISR & RTC_ISR_WUTWF) == RESET)
000048  6810              LDR      r0,[r2,#0]
00004a  0740              LSLS     r0,r0,#29
00004c  d401              BMI      |L55.82|
;;;1585       {
;;;1586         status = ERROR;
00004e  2000              MOVS     r0,#0
000050  e000              B        |L55.84|
                  |L55.82|
;;;1587       }
;;;1588       else
;;;1589       {
;;;1590         status = SUCCESS;
000052  2001              MOVS     r0,#1
                  |L55.84|
;;;1591       }    
;;;1592     }
;;;1593   
;;;1594     /* Enable the write protection for RTC registers */
;;;1595     RTC->WPR = 0xFF; 
000054  21ff              MOVS     r1,#0xff
000056  6019              STR      r1,[r3,#0]
;;;1596     
;;;1597     return status;
;;;1598   }
000058  bd18              POP      {r3,r4,pc}
;;;1599   
                          ENDP

00005a  0000              DCW      0x0000
                  |L55.92|
                          DCD      0x40002824

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

                  RTC_WriteBackupRegister PROC
;;;2302     */
;;;2303   void RTC_WriteBackupRegister(uint32_t RTC_BKP_DR, uint32_t Data)
000000  b508              PUSH     {r3,lr}
;;;2304   {
;;;2305     __IO uint32_t tmp = 0;
;;;2306     
;;;2307     /* Check the parameters */
;;;2308     assert_param(IS_RTC_BKP(RTC_BKP_DR));
;;;2309   
;;;2310     tmp = RTC_BASE + 0x50;
000002  4a03              LDR      r2,|L56.16|
;;;2311     tmp += (RTC_BKP_DR * 4);
000004  eb020080          ADD      r0,r2,r0,LSL #2
000008  9000              STR      r0,[sp,#0]
;;;2312   
;;;2313     /* Write the specified register */
;;;2314     *(__IO uint32_t *)tmp = (uint32_t)Data;
00000a  9800              LDR      r0,[sp,#0]
00000c  6001              STR      r1,[r0,#0]
;;;2315   }
00000e  bd08              POP      {r3,pc}
;;;2316   
                          ENDP

                  |L56.16|
                          DCD      0x40002850

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

                  RTC_WriteProtectionCmd PROC
;;;524      */
;;;525    void RTC_WriteProtectionCmd(FunctionalState NewState)
000000  4905              LDR      r1,|L57.24|
;;;526    {
;;;527      /* Check the parameters */
;;;528      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;529        
;;;530      if (NewState != DISABLE)
000002  2800              CMP      r0,#0
000004  d002              BEQ      |L57.12|
;;;531      {
;;;532        /* Enable the write protection for RTC registers */
;;;533        RTC->WPR = 0xFF;   
000006  20ff              MOVS     r0,#0xff
000008  6008              STR      r0,[r1,#0]
;;;534      }
;;;535      else
;;;536      {
;;;537        /* Disable the write protection for RTC registers */
;;;538        RTC->WPR = 0xCA;
;;;539        RTC->WPR = 0x53;    
;;;540      }
;;;541    }
00000a  4770              BX       lr
                  |L57.12|
00000c  20ca              MOVS     r0,#0xca              ;538
00000e  6008              STR      r0,[r1,#0]            ;538
000010  2053              MOVS     r0,#0x53              ;539
000012  6008              STR      r0,[r1,#0]            ;539
000014  4770              BX       lr
;;;542    
                          ENDP

000016  0000              DCW      0x0000
                  |L57.24|
                          DCD      0x40002824

;*** Start embedded assembler ***

#line 1 "..\\..\\Libraries\\STM32F4xx_StdPeriph_Driver\\src\\stm32f4xx_rtc.c"
	AREA ||.rev16_text||, CODE
	THUMB
	EXPORT |__asm___15_stm32f4xx_rtc_c_81435638____REV16|
#line 129 "..\\..\\Libraries\\CMSIS\\Include\\core_cmInstr.h"
|__asm___15_stm32f4xx_rtc_c_81435638____REV16| PROC
#line 130

 rev16 r0, r0
 bx lr
	ENDP
	AREA ||.revsh_text||, CODE
	THUMB
	EXPORT |__asm___15_stm32f4xx_rtc_c_81435638____REVSH|
#line 144
|__asm___15_stm32f4xx_rtc_c_81435638____REVSH| PROC
#line 145

 revsh r0, r0
 bx lr
	ENDP
	AREA ||.rrx_text||, CODE
	THUMB
	EXPORT |__asm___15_stm32f4xx_rtc_c_81435638____RRX|
#line 300
|__asm___15_stm32f4xx_rtc_c_81435638____RRX| PROC
#line 301

 rrx r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***