; generated by ARM C/C++ Compiler, 4.1 [Build 894]
; commandline ArmCC [--list --split_sections --debug -c --asm --interleave -o.\STM324xG_EVAL\stm32f4xx_rtc.o --asm_dir=.\STM324xG_EVAL\ --list_dir=.\STM324xG_EVAL\ --depend=.\STM324xG_EVAL\stm32f4xx_rtc.d --cpu=Cortex-M4.fp --apcs=interwork -O0 -Otime -I..\ -I..\..\..\Libraries\CMSIS\Device\ST\STM32F4xx\Include -I..\..\..\Libraries\STM32F4xx_StdPeriph_Driver\inc -I..\..\..\Utilities\STM32_EVAL\Common -I..\..\..\Utilities\STM32_EVAL\STM3240_41_G_EVAL -IC:\Keil\ARM\RV31\Inc -IC:\Keil\ARM\CMSIS\Include -IC:\Keil\ARM\Inc\ST\STM32F4xx -D__MICROLIB -DUSE_STM324xG_EVAL -DSTM32F4XX -DUSE_STDPERIPH_DRIVER --omf_browse=.\STM324xG_EVAL\stm32f4xx_rtc.crf ..\..\..\Libraries\STM32F4xx_StdPeriph_Driver\src\stm32f4xx_rtc.c]
                          THUMB

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

                  RTC_AlarmCmd PROC
;;;1282     */
;;;1283   ErrorStatus RTC_AlarmCmd(uint32_t RTC_Alarm, FunctionalState NewState)
000000  b530              PUSH     {r4,r5,lr}
;;;1284   {
000002  4602              MOV      r2,r0
;;;1285     __IO uint32_t alarmcounter = 0x00;
000004  2300              MOVS     r3,#0
;;;1286     uint32_t alarmstatus = 0x00;
000006  469c              MOV      r12,r3
;;;1287     ErrorStatus status = ERROR;
000008  2000              MOVS     r0,#0
;;;1288       
;;;1289     /* Check the parameters */
;;;1290     assert_param(IS_RTC_CMD_ALARM(RTC_Alarm));
;;;1291     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1292   
;;;1293     /* Disable the write protection for RTC registers */
;;;1294     RTC->WPR = 0xCA;
00000a  24ca              MOVS     r4,#0xca
00000c  4d17              LDR      r5,|L1.108|
00000e  602c              STR      r4,[r5,#0]
;;;1295     RTC->WPR = 0x53;
000010  2453              MOVS     r4,#0x53
000012  602c              STR      r4,[r5,#0]
;;;1296   
;;;1297     /* Configure the Alarm state */
;;;1298     if (NewState != DISABLE)
000014  b141              CBZ      r1,|L1.40|
;;;1299     {
;;;1300       RTC->CR |= (uint32_t)RTC_Alarm;
000016  4c15              LDR      r4,|L1.108|
000018  3c1c              SUBS     r4,r4,#0x1c
00001a  6824              LDR      r4,[r4,#0]
00001c  4314              ORRS     r4,r4,r2
00001e  4d13              LDR      r5,|L1.108|
000020  3d1c              SUBS     r5,r5,#0x1c
000022  602c              STR      r4,[r5,#0]
;;;1301   
;;;1302       status = SUCCESS;    
000024  2001              MOVS     r0,#1
000026  e01c              B        |L1.98|
                  |L1.40|
;;;1303     }
;;;1304     else
;;;1305     { 
;;;1306       /* Disable the Alarm in RTC_CR register */
;;;1307       RTC->CR &= (uint32_t)~RTC_Alarm;
000028  4c10              LDR      r4,|L1.108|
00002a  3c1c              SUBS     r4,r4,#0x1c
00002c  6824              LDR      r4,[r4,#0]
00002e  4394              BICS     r4,r4,r2
000030  4d0e              LDR      r5,|L1.108|
000032  3d1c              SUBS     r5,r5,#0x1c
000034  602c              STR      r4,[r5,#0]
;;;1308      
;;;1309       /* Wait till RTC ALRxWF flag is set and if Time out is reached exit */
;;;1310       do
000036  bf00              NOP      
                  |L1.56|
;;;1311       {
;;;1312         alarmstatus = RTC->ISR & (RTC_Alarm >> 8);
000038  4c0c              LDR      r4,|L1.108|
00003a  3c18              SUBS     r4,r4,#0x18
00003c  6824              LDR      r4,[r4,#0]
00003e  ea042c12          AND      r12,r4,r2,LSR #8
;;;1313         alarmcounter++;  
000042  1c5b              ADDS     r3,r3,#1
;;;1314       } while((alarmcounter != INITMODE_TIMEOUT) && (alarmstatus == 0x00));
000044  f5b33f80          CMP      r3,#0x10000
000048  d002              BEQ      |L1.80|
00004a  f1bc0f00          CMP      r12,#0
00004e  d0f3              BEQ      |L1.56|
                  |L1.80|
;;;1315       
;;;1316       if ((RTC->ISR & (RTC_Alarm >> 8)) == RESET)
000050  4c06              LDR      r4,|L1.108|
000052  3c18              SUBS     r4,r4,#0x18
000054  6824              LDR      r4,[r4,#0]
000056  ea142f12          TST      r4,r2,LSR #8
00005a  d101              BNE      |L1.96|
;;;1317       {
;;;1318         status = ERROR;
00005c  2000              MOVS     r0,#0
00005e  e000              B        |L1.98|
                  |L1.96|
;;;1319       } 
;;;1320       else
;;;1321       {
;;;1322         status = SUCCESS;
000060  2001              MOVS     r0,#1
                  |L1.98|
;;;1323       }        
;;;1324     } 
;;;1325   
;;;1326     /* Enable the write protection for RTC registers */
;;;1327     RTC->WPR = 0xFF; 
000062  24ff              MOVS     r4,#0xff
000064  4d01              LDR      r5,|L1.108|
000066  602c              STR      r4,[r5,#0]
;;;1328     
;;;1329     return status;
;;;1330   }
000068  bd30              POP      {r4,r5,pc}
;;;1331   
                          ENDP

00006a  0000              DCW      0x0000
                  |L1.108|
                          DCD      0x40002824

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

                  RTC_AlarmStructInit PROC
;;;1198     */
;;;1199   void RTC_AlarmStructInit(RTC_AlarmTypeDef* RTC_AlarmStruct)
000000  2100              MOVS     r1,#0
;;;1200   {
;;;1201     /* Alarm Time Settings : Time = 00h:00mn:00sec */
;;;1202     RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = RTC_H12_AM;
000002  70c1              STRB     r1,[r0,#3]
;;;1203     RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours = 0;
000004  7001              STRB     r1,[r0,#0]
;;;1204     RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes = 0;
000006  7041              STRB     r1,[r0,#1]
;;;1205     RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds = 0;
000008  7081              STRB     r1,[r0,#2]
;;;1206   
;;;1207     /* Alarm Date Settings : Date = 1st day of the month */
;;;1208     RTC_AlarmStruct->RTC_AlarmDateWeekDaySel = RTC_AlarmDateWeekDaySel_Date;
00000a  6081              STR      r1,[r0,#8]
;;;1209     RTC_AlarmStruct->RTC_AlarmDateWeekDay = 1;
00000c  2101              MOVS     r1,#1
00000e  7301              STRB     r1,[r0,#0xc]
;;;1210   
;;;1211     /* Alarm Masks Settings : Mask =  all fields are not masked */
;;;1212     RTC_AlarmStruct->RTC_AlarmMask = RTC_AlarmMask_None;
000010  2100              MOVS     r1,#0
000012  6041              STR      r1,[r0,#4]
;;;1213   }
000014  4770              BX       lr
;;;1214   
                          ENDP


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

                  RTC_AlarmSubSecondConfig PROC
;;;1376     */
;;;1377   void RTC_AlarmSubSecondConfig(uint32_t RTC_Alarm, uint32_t RTC_AlarmSubSecondValue, uint32_t RTC_AlarmSubSecondMask)
000000  b530              PUSH     {r4,r5,lr}
;;;1378   {
;;;1379     uint32_t tmpreg = 0;
000002  2300              MOVS     r3,#0
;;;1380   
;;;1381     /* Check the parameters */
;;;1382     assert_param(IS_RTC_ALARM(RTC_Alarm));
;;;1383     assert_param(IS_RTC_ALARM_SUB_SECOND_VALUE(RTC_AlarmSubSecondValue));
;;;1384     assert_param(IS_RTC_ALARM_SUB_SECOND_MASK(RTC_AlarmSubSecondMask));
;;;1385     
;;;1386     /* Disable the write protection for RTC registers */
;;;1387     RTC->WPR = 0xCA;
000004  24ca              MOVS     r4,#0xca
000006  4d0a              LDR      r5,|L3.48|
000008  602c              STR      r4,[r5,#0]
;;;1388     RTC->WPR = 0x53;
00000a  2453              MOVS     r4,#0x53
00000c  602c              STR      r4,[r5,#0]
;;;1389     
;;;1390     /* Configure the Alarm A or Alarm B SubSecond registers */
;;;1391     tmpreg = (uint32_t) (uint32_t)(RTC_AlarmSubSecondValue) | (uint32_t)(RTC_AlarmSubSecondMask);
00000e  ea410302          ORR      r3,r1,r2
;;;1392     
;;;1393     if (RTC_Alarm == RTC_Alarm_A)
000012  f5b07f80          CMP      r0,#0x100
000016  d103              BNE      |L3.32|
;;;1394     {
;;;1395       /* Configure the AlarmA SubSecond register */
;;;1396       RTC->ALRMASSR = tmpreg;
000018  4c05              LDR      r4,|L3.48|
00001a  3420              ADDS     r4,r4,#0x20
00001c  6023              STR      r3,[r4,#0]
00001e  e002              B        |L3.38|
                  |L3.32|
;;;1397     }
;;;1398     else
;;;1399     {
;;;1400       /* Configure the Alarm B SubSecond register */
;;;1401       RTC->ALRMBSSR = tmpreg;
000020  4c03              LDR      r4,|L3.48|
000022  3424              ADDS     r4,r4,#0x24
000024  6023              STR      r3,[r4,#0]
                  |L3.38|
;;;1402     }
;;;1403   
;;;1404     /* Enable the write protection for RTC registers */
;;;1405     RTC->WPR = 0xFF;
000026  24ff              MOVS     r4,#0xff
000028  4d01              LDR      r5,|L3.48|
00002a  602c              STR      r4,[r5,#0]
;;;1406   
;;;1407   }
00002c  bd30              POP      {r4,r5,pc}
;;;1408   
                          ENDP

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

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

                  RTC_Bcd2ToByte PROC
;;;2712     */
;;;2713   static uint8_t RTC_Bcd2ToByte(uint8_t Value)
000000  4601              MOV      r1,r0
;;;2714   {
;;;2715     uint8_t tmp = 0;
000002  bf00              NOP      
;;;2716     tmp = ((uint8_t)(Value & (uint8_t)0xF0) >> (uint8_t)0x4) * 10;
000004  0908              LSRS     r0,r1,#4
000006  eb000080          ADD      r0,r0,r0,LSL #2
00000a  0042              LSLS     r2,r0,#1
;;;2717     return (tmp + (Value & (uint8_t)0x0F));
00000c  f001000f          AND      r0,r1,#0xf
000010  4410              ADD      r0,r0,r2
000012  b2c0              UXTB     r0,r0
;;;2718   }
000014  4770              BX       lr
;;;2719   
                          ENDP


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

                  RTC_BypassShadowCmd PROC
;;;697    */
;;;698    void RTC_BypassShadowCmd(FunctionalState NewState)
000000  21ca              MOVS     r1,#0xca
;;;699    {
;;;700      /* Check the parameters */
;;;701      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;702    
;;;703      /* Disable the write protection for RTC registers */
;;;704      RTC->WPR = 0xCA;
000002  4a0d              LDR      r2,|L5.56|
000004  6011              STR      r1,[r2,#0]
;;;705      RTC->WPR = 0x53;
000006  2153              MOVS     r1,#0x53
000008  6011              STR      r1,[r2,#0]
;;;706      
;;;707      if (NewState != DISABLE)
00000a  b140              CBZ      r0,|L5.30|
;;;708      {
;;;709        /* Set the BYPSHAD bit */
;;;710        RTC->CR |= (uint8_t)RTC_CR_BYPSHAD;
00000c  490a              LDR      r1,|L5.56|
00000e  391c              SUBS     r1,r1,#0x1c
000010  6809              LDR      r1,[r1,#0]
000012  f0410120          ORR      r1,r1,#0x20
000016  4a08              LDR      r2,|L5.56|
000018  3a1c              SUBS     r2,r2,#0x1c
00001a  6011              STR      r1,[r2,#0]
00001c  e007              B        |L5.46|
                  |L5.30|
;;;711      }
;;;712      else
;;;713      {
;;;714        /* Reset the BYPSHAD bit */
;;;715        RTC->CR &= (uint8_t)~RTC_CR_BYPSHAD;
00001e  4906              LDR      r1,|L5.56|
000020  391c              SUBS     r1,r1,#0x1c
000022  6809              LDR      r1,[r1,#0]
000024  f00101df          AND      r1,r1,#0xdf
000028  4a03              LDR      r2,|L5.56|
00002a  3a1c              SUBS     r2,r2,#0x1c
00002c  6011              STR      r1,[r2,#0]
                  |L5.46|
;;;716      }
;;;717    
;;;718      /* Enable the write protection for RTC registers */
;;;719      RTC->WPR = 0xFF;
00002e  21ff              MOVS     r1,#0xff
000030  4a01              LDR      r2,|L5.56|
000032  6011              STR      r1,[r2,#0]
;;;720    }
000034  4770              BX       lr
;;;721    
                          ENDP

000036  0000              DCW      0x0000
                  |L5.56|
                          DCD      0x40002824

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

                  RTC_ByteToBcd2 PROC
;;;2694     */
;;;2695   static uint8_t RTC_ByteToBcd2(uint8_t Value)
000000  4601              MOV      r1,r0
;;;2696   {
;;;2697     uint8_t bcdhigh = 0;
000002  2200              MOVS     r2,#0
;;;2698     
;;;2699     while (Value >= 10)
000004  e004              B        |L6.16|
                  |L6.6|
;;;2700     {
;;;2701       bcdhigh++;
000006  1c50              ADDS     r0,r2,#1
000008  b2c2              UXTB     r2,r0
;;;2702       Value -= 10;
00000a  f1a1000a          SUB      r0,r1,#0xa
00000e  b2c1              UXTB     r1,r0
                  |L6.16|
000010  290a              CMP      r1,#0xa               ;2699
000012  daf8              BGE      |L6.6|
;;;2703     }
;;;2704     
;;;2705     return  ((uint8_t)(bcdhigh << 4) | Value);
000014  0710              LSLS     r0,r2,#28
000016  ea416010          ORR      r0,r1,r0,LSR #24
;;;2706   }
00001a  4770              BX       lr
;;;2707   
                          ENDP


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

                  RTC_CalibOutputCmd PROC
;;;1810     */
;;;1811   void RTC_CalibOutputCmd(FunctionalState NewState)
000000  21ca              MOVS     r1,#0xca
;;;1812   {
;;;1813     /* Check the parameters */
;;;1814     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1815     
;;;1816     /* Disable the write protection for RTC registers */
;;;1817     RTC->WPR = 0xCA;
000002  4a0d              LDR      r2,|L7.56|
000004  6011              STR      r1,[r2,#0]
;;;1818     RTC->WPR = 0x53;
000006  2153              MOVS     r1,#0x53
000008  6011              STR      r1,[r2,#0]
;;;1819     
;;;1820     if (NewState != DISABLE)
00000a  b140              CBZ      r0,|L7.30|
;;;1821     {
;;;1822       /* Enable the RTC clock output */
;;;1823       RTC->CR |= (uint32_t)RTC_CR_COE;
00000c  490a              LDR      r1,|L7.56|
00000e  391c              SUBS     r1,r1,#0x1c
000010  6809              LDR      r1,[r1,#0]
000012  f4410100          ORR      r1,r1,#0x800000
000016  4a08              LDR      r2,|L7.56|
000018  3a1c              SUBS     r2,r2,#0x1c
00001a  6011              STR      r1,[r2,#0]
00001c  e007              B        |L7.46|
                  |L7.30|
;;;1824     }
;;;1825     else
;;;1826     { 
;;;1827       /* Disable the RTC clock output */
;;;1828       RTC->CR &= (uint32_t)~RTC_CR_COE;
00001e  4906              LDR      r1,|L7.56|
000020  391c              SUBS     r1,r1,#0x1c
000022  6809              LDR      r1,[r1,#0]
000024  f4210100          BIC      r1,r1,#0x800000
000028  4a03              LDR      r2,|L7.56|
00002a  3a1c              SUBS     r2,r2,#0x1c
00002c  6011              STR      r1,[r2,#0]
                  |L7.46|
;;;1829     }
;;;1830     
;;;1831     /* Enable the write protection for RTC registers */
;;;1832     RTC->WPR = 0xFF; 
00002e  21ff              MOVS     r1,#0xff
000030  4a01              LDR      r2,|L7.56|
000032  6011              STR      r1,[r2,#0]
;;;1833   }
000034  4770              BX       lr
;;;1834   
                          ENDP

000036  0000              DCW      0x0000
                  |L7.56|
                          DCD      0x40002824

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

                  RTC_CalibOutputConfig PROC
;;;1842   */
;;;1843   void RTC_CalibOutputConfig(uint32_t RTC_CalibOutput)
000000  21ca              MOVS     r1,#0xca
;;;1844   {
;;;1845     /* Check the parameters */
;;;1846     assert_param(IS_RTC_CALIB_OUTPUT(RTC_CalibOutput));
;;;1847   
;;;1848     /* Disable the write protection for RTC registers */
;;;1849     RTC->WPR = 0xCA;
000002  4a0a              LDR      r2,|L8.44|
000004  6011              STR      r1,[r2,#0]
;;;1850     RTC->WPR = 0x53;
000006  2153              MOVS     r1,#0x53
000008  6011              STR      r1,[r2,#0]
;;;1851     
;;;1852     /*clear flags before config*/
;;;1853     RTC->CR &= (uint32_t)~(RTC_CR_COSEL);
00000a  4908              LDR      r1,|L8.44|
00000c  391c              SUBS     r1,r1,#0x1c
00000e  6809              LDR      r1,[r1,#0]
000010  f4212100          BIC      r1,r1,#0x80000
000014  4a05              LDR      r2,|L8.44|
000016  3a1c              SUBS     r2,r2,#0x1c
000018  6011              STR      r1,[r2,#0]
;;;1854   
;;;1855     /* Configure the RTC_CR register */
;;;1856     RTC->CR |= (uint32_t)RTC_CalibOutput;
00001a  4611              MOV      r1,r2
00001c  6809              LDR      r1,[r1,#0]
00001e  4301              ORRS     r1,r1,r0
000020  6011              STR      r1,[r2,#0]
;;;1857   
;;;1858     /* Enable the write protection for RTC registers */
;;;1859     RTC->WPR = 0xFF;
000022  21ff              MOVS     r1,#0xff
000024  4a01              LDR      r2,|L8.44|
000026  6011              STR      r1,[r2,#0]
;;;1860   }
000028  4770              BX       lr
;;;1861   
                          ENDP

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

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

                  RTC_ClearFlag PROC
;;;2611     */
;;;2612   void RTC_ClearFlag(uint32_t RTC_FLAG)
000000  b281              UXTH     r1,r0
;;;2613   {
;;;2614     /* Check the parameters */
;;;2615     assert_param(IS_RTC_CLEAR_FLAG(RTC_FLAG));
;;;2616   
;;;2617     /* Clear the Flags in the RTC_ISR register */
;;;2618     RTC->ISR = (uint32_t)((uint32_t)(~((RTC_FLAG | RTC_ISR_INIT)& 0x0000FFFF) | (uint32_t)(RTC->ISR & RTC_ISR_INIT)));  
000002  f0410180          ORR      r1,r1,#0x80
000006  4a04              LDR      r2,|L9.24|
000008  6812              LDR      r2,[r2,#0]
00000a  f0020280          AND      r2,r2,#0x80
00000e  ea620101          ORN      r1,r2,r1
000012  4a01              LDR      r2,|L9.24|
000014  6011              STR      r1,[r2,#0]
;;;2619   }
000016  4770              BX       lr
;;;2620   
                          ENDP

                  |L9.24|
                          DCD      0x4000280c

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

                  RTC_ClearITPendingBit PROC
;;;2671     */
;;;2672   void RTC_ClearITPendingBit(uint32_t RTC_IT)
000000  2100              MOVS     r1,#0
;;;2673   {
;;;2674     uint32_t tmpreg = 0;
;;;2675   
;;;2676     /* Check the parameters */
;;;2677     assert_param(IS_RTC_CLEAR_IT(RTC_IT));
;;;2678   
;;;2679     /* Get the RTC_ISR Interrupt pending bits mask */
;;;2680     tmpreg = (uint32_t)(RTC_IT >> 4);
000002  0901              LSRS     r1,r0,#4
;;;2681   
;;;2682     /* Clear the interrupt pending bits in the RTC_ISR register */
;;;2683     RTC->ISR = (uint32_t)((uint32_t)(~((tmpreg | RTC_ISR_INIT)& 0x0000FFFF) | (uint32_t)(RTC->ISR & RTC_ISR_INIT))); 
000004  b28a              UXTH     r2,r1
000006  f0420280          ORR      r2,r2,#0x80
00000a  4b04              LDR      r3,|L10.28|
00000c  681b              LDR      r3,[r3,#0]
00000e  f0030380          AND      r3,r3,#0x80
000012  ea630202          ORN      r2,r3,r2
000016  4b01              LDR      r3,|L10.28|
000018  601a              STR      r2,[r3,#0]
;;;2684   }
00001a  4770              BX       lr
;;;2685   
                          ENDP

                  |L10.28|
                          DCD      0x4000280c

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

                  RTC_CoarseCalibCmd PROC
;;;1764     */
;;;1765   ErrorStatus RTC_CoarseCalibCmd(FunctionalState NewState)
000000  b530              PUSH     {r4,r5,lr}
;;;1766   {
000002  4604              MOV      r4,r0
;;;1767     ErrorStatus status = ERROR;
000004  2500              MOVS     r5,#0
;;;1768     
;;;1769     /* Check the parameters */
;;;1770     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1771   
;;;1772     /* Disable the write protection for RTC registers */
;;;1773     RTC->WPR = 0xCA;
000006  20ca              MOVS     r0,#0xca
000008  4910              LDR      r1,|L11.76|
00000a  6008              STR      r0,[r1,#0]
;;;1774     RTC->WPR = 0x53;
00000c  2053              MOVS     r0,#0x53
00000e  6008              STR      r0,[r1,#0]
;;;1775     
;;;1776     /* Set Initialization mode */
;;;1777     if (RTC_EnterInitMode() == ERROR)
000010  f7fffffe          BL       RTC_EnterInitMode
000014  b900              CBNZ     r0,|L11.24|
;;;1778     {
;;;1779       status =  ERROR;
000016  e014              B        |L11.66|
                  |L11.24|
;;;1780     }
;;;1781     else
;;;1782     {
;;;1783       if (NewState != DISABLE)
000018  b144              CBZ      r4,|L11.44|
;;;1784       {
;;;1785         /* Enable the Coarse Calibration */
;;;1786         RTC->CR |= (uint32_t)RTC_CR_DCE;
00001a  480c              LDR      r0,|L11.76|
00001c  381c              SUBS     r0,r0,#0x1c
00001e  6800              LDR      r0,[r0,#0]
000020  f0400080          ORR      r0,r0,#0x80
000024  4909              LDR      r1,|L11.76|
000026  391c              SUBS     r1,r1,#0x1c
000028  6008              STR      r0,[r1,#0]
00002a  e007              B        |L11.60|
                  |L11.44|
;;;1787       }
;;;1788       else
;;;1789       { 
;;;1790         /* Disable the Coarse Calibration */
;;;1791         RTC->CR &= (uint32_t)~RTC_CR_DCE;
00002c  4807              LDR      r0,|L11.76|
00002e  381c              SUBS     r0,r0,#0x1c
000030  6800              LDR      r0,[r0,#0]
000032  f0200080          BIC      r0,r0,#0x80
000036  4905              LDR      r1,|L11.76|
000038  391c              SUBS     r1,r1,#0x1c
00003a  6008              STR      r0,[r1,#0]
                  |L11.60|
;;;1792       }
;;;1793       /* Exit Initialization mode */
;;;1794       RTC_ExitInitMode();
00003c  f7fffffe          BL       RTC_ExitInitMode
;;;1795       
;;;1796       status = SUCCESS;
000040  2501              MOVS     r5,#1
                  |L11.66|
;;;1797     } 
;;;1798     
;;;1799     /* Enable the write protection for RTC registers */
;;;1800     RTC->WPR = 0xFF; 
000042  20ff              MOVS     r0,#0xff
000044  4901              LDR      r1,|L11.76|
000046  6008              STR      r0,[r1,#0]
;;;1801     
;;;1802     return status;
000048  4628              MOV      r0,r5
;;;1803   }
00004a  bd30              POP      {r4,r5,pc}
;;;1804   
                          ENDP

                  |L11.76|
                          DCD      0x40002824

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

                  RTC_CoarseCalibConfig PROC
;;;1723     */
;;;1724   ErrorStatus RTC_CoarseCalibConfig(uint32_t RTC_CalibSign, uint32_t Value)
000000  b570              PUSH     {r4-r6,lr}
;;;1725   {
000002  4604              MOV      r4,r0
000004  460d              MOV      r5,r1
;;;1726     ErrorStatus status = ERROR;
000006  2600              MOVS     r6,#0
;;;1727      
;;;1728     /* Check the parameters */
;;;1729     assert_param(IS_RTC_CALIB_SIGN(RTC_CalibSign));
;;;1730     assert_param(IS_RTC_CALIB_VALUE(Value)); 
;;;1731   
;;;1732     /* Disable the write protection for RTC registers */
;;;1733     RTC->WPR = 0xCA;
000008  20ca              MOVS     r0,#0xca
00000a  490a              LDR      r1,|L12.52|
00000c  6008              STR      r0,[r1,#0]
;;;1734     RTC->WPR = 0x53;
00000e  2053              MOVS     r0,#0x53
000010  6008              STR      r0,[r1,#0]
;;;1735   
;;;1736     /* Set Initialization mode */
;;;1737     if (RTC_EnterInitMode() == ERROR)
000012  f7fffffe          BL       RTC_EnterInitMode
000016  b900              CBNZ     r0,|L12.26|
;;;1738     {
;;;1739       status = ERROR;
000018  e007              B        |L12.42|
                  |L12.26|
;;;1740     } 
;;;1741     else
;;;1742     {
;;;1743       /* Set the coarse calibration value */
;;;1744       RTC->CALIBR = (uint32_t)(RTC_CalibSign | Value);
00001a  ea440005          ORR      r0,r4,r5
00001e  4905              LDR      r1,|L12.52|
000020  390c              SUBS     r1,r1,#0xc
000022  6008              STR      r0,[r1,#0]
;;;1745       /* Exit Initialization mode */
;;;1746       RTC_ExitInitMode();
000024  f7fffffe          BL       RTC_ExitInitMode
;;;1747       
;;;1748       status = SUCCESS;
000028  2601              MOVS     r6,#1
                  |L12.42|
;;;1749     } 
;;;1750   
;;;1751     /* Enable the write protection for RTC registers */
;;;1752     RTC->WPR = 0xFF; 
00002a  20ff              MOVS     r0,#0xff
00002c  4901              LDR      r1,|L12.52|
00002e  6008              STR      r0,[r1,#0]
;;;1753     
;;;1754     return status;
000030  4630              MOV      r0,r6
;;;1755   }
000032  bd70              POP      {r4-r6,pc}
;;;1756   
                          ENDP

                  |L12.52|
                          DCD      0x40002824

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

                  RTC_DateStructInit PROC
;;;1008     */
;;;1009   void RTC_DateStructInit(RTC_DateTypeDef* RTC_DateStruct)
000000  2101              MOVS     r1,#1
;;;1010   {
;;;1011     /* Monday, January 01 xx00 */
;;;1012     RTC_DateStruct->RTC_WeekDay = RTC_Weekday_Monday;
000002  7001              STRB     r1,[r0,#0]
;;;1013     RTC_DateStruct->RTC_Date = 1;
000004  7081              STRB     r1,[r0,#2]
;;;1014     RTC_DateStruct->RTC_Month = RTC_Month_January;
000006  7041              STRB     r1,[r0,#1]
;;;1015     RTC_DateStruct->RTC_Year = 0;
000008  2100              MOVS     r1,#0
00000a  70c1              STRB     r1,[r0,#3]
;;;1016   }
00000c  4770              BX       lr
;;;1017   
                          ENDP


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

                  RTC_DayLightSavingConfig PROC
;;;1603     */
;;;1604   void RTC_DayLightSavingConfig(uint32_t RTC_DayLightSaving, uint32_t RTC_StoreOperation)
000000  22ca              MOVS     r2,#0xca
;;;1605   {
;;;1606     /* Check the parameters */
;;;1607     assert_param(IS_RTC_DAYLIGHT_SAVING(RTC_DayLightSaving));
;;;1608     assert_param(IS_RTC_STORE_OPERATION(RTC_StoreOperation));
;;;1609   
;;;1610     /* Disable the write protection for RTC registers */
;;;1611     RTC->WPR = 0xCA;
000002  4b0c              LDR      r3,|L14.52|
000004  601a              STR      r2,[r3,#0]
;;;1612     RTC->WPR = 0x53;
000006  2253              MOVS     r2,#0x53
000008  601a              STR      r2,[r3,#0]
;;;1613   
;;;1614     /* Clear the bits to be configured */
;;;1615     RTC->CR &= (uint32_t)~(RTC_CR_BCK);
00000a  4a0a              LDR      r2,|L14.52|
00000c  3a1c              SUBS     r2,r2,#0x1c
00000e  6812              LDR      r2,[r2,#0]
000010  f4222280          BIC      r2,r2,#0x40000
000014  4b07              LDR      r3,|L14.52|
000016  3b1c              SUBS     r3,r3,#0x1c
000018  601a              STR      r2,[r3,#0]
;;;1616   
;;;1617     /* Configure the RTC_CR register */
;;;1618     RTC->CR |= (uint32_t)(RTC_DayLightSaving | RTC_StoreOperation);
00001a  461a              MOV      r2,r3
00001c  6812              LDR      r2,[r2,#0]
00001e  ea400301          ORR      r3,r0,r1
000022  431a              ORRS     r2,r2,r3
000024  4b03              LDR      r3,|L14.52|
000026  3b1c              SUBS     r3,r3,#0x1c
000028  601a              STR      r2,[r3,#0]
;;;1619   
;;;1620     /* Enable the write protection for RTC registers */
;;;1621     RTC->WPR = 0xFF; 
00002a  22ff              MOVS     r2,#0xff
00002c  4b01              LDR      r3,|L14.52|
00002e  601a              STR      r2,[r3,#0]
;;;1622   }
000030  4770              BX       lr
;;;1623   
                          ENDP

000032  0000              DCW      0x0000
                  |L14.52|
                          DCD      0x40002824

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

                  RTC_DeInit PROC
;;;366      */
;;;367    ErrorStatus RTC_DeInit(void)
000000  b570              PUSH     {r4-r6,lr}
;;;368    {
;;;369      __IO uint32_t wutcounter = 0x00;
000002  2400              MOVS     r4,#0
;;;370      uint32_t wutwfstatus = 0x00;
000004  2500              MOVS     r5,#0
;;;371      ErrorStatus status = ERROR;
000006  2600              MOVS     r6,#0
;;;372      
;;;373      /* Disable the write protection for RTC registers */
;;;374      RTC->WPR = 0xCA;
000008  20ca              MOVS     r0,#0xca
00000a  4929              LDR      r1,|L15.176|
00000c  6008              STR      r0,[r1,#0]
;;;375      RTC->WPR = 0x53;
00000e  2053              MOVS     r0,#0x53
000010  6008              STR      r0,[r1,#0]
;;;376    
;;;377      /* Set Initialization mode */
;;;378      if (RTC_EnterInitMode() == ERROR)
000012  f7fffffe          BL       RTC_EnterInitMode
000016  b900              CBNZ     r0,|L15.26|
;;;379      {
;;;380        status = ERROR;
000018  e044              B        |L15.164|
                  |L15.26|
;;;381      }  
;;;382      else
;;;383      {
;;;384        /* Reset TR, DR and CR registers */
;;;385        RTC->TR = (uint32_t)0x00000000;
00001a  2000              MOVS     r0,#0
00001c  4924              LDR      r1,|L15.176|
00001e  3924              SUBS     r1,r1,#0x24
000020  6008              STR      r0,[r1,#0]
;;;386        RTC->DR = (uint32_t)0x00002101;
000022  f2421001          MOV      r0,#0x2101
000026  1d09              ADDS     r1,r1,#4
000028  6008              STR      r0,[r1,#0]
;;;387        /* Reset All CR bits except CR[2:0] */
;;;388        RTC->CR &= (uint32_t)0x00000007;
00002a  1d08              ADDS     r0,r1,#4
00002c  6800              LDR      r0,[r0,#0]
00002e  f0000007          AND      r0,r0,#7
000032  1d09              ADDS     r1,r1,#4
000034  6008              STR      r0,[r1,#0]
;;;389      
;;;390        /* Wait till RTC WUTWF flag is set and if Time out is reached exit */
;;;391        do
000036  bf00              NOP      
                  |L15.56|
;;;392        {
;;;393          wutwfstatus = RTC->ISR & RTC_ISR_WUTWF;
000038  481d              LDR      r0,|L15.176|
00003a  3818              SUBS     r0,r0,#0x18
00003c  6800              LDR      r0,[r0,#0]
00003e  f0000504          AND      r5,r0,#4
;;;394          wutcounter++;  
000042  1c64              ADDS     r4,r4,#1
;;;395        } while((wutcounter != INITMODE_TIMEOUT) && (wutwfstatus == 0x00));
000044  f5b43f80          CMP      r4,#0x10000
000048  d001              BEQ      |L15.78|
00004a  2d00              CMP      r5,#0
00004c  d0f4              BEQ      |L15.56|
                  |L15.78|
;;;396        
;;;397        if ((RTC->ISR & RTC_ISR_WUTWF) == RESET)
00004e  4818              LDR      r0,|L15.176|
000050  3818              SUBS     r0,r0,#0x18
000052  6800              LDR      r0,[r0,#0]
000054  f0100f04          TST      r0,#4
000058  d101              BNE      |L15.94|
;;;398        {
;;;399          status = ERROR;
00005a  2600              MOVS     r6,#0
00005c  e022              B        |L15.164|
                  |L15.94|
;;;400        }
;;;401        else
;;;402        {
;;;403          /* Reset all RTC CR register bits */
;;;404          RTC->CR &= (uint32_t)0x00000000;
00005e  4814              LDR      r0,|L15.176|
000060  381c              SUBS     r0,r0,#0x1c
000062  6800              LDR      r0,[r0,#0]
000064  2000              MOVS     r0,#0
000066  4912              LDR      r1,|L15.176|
000068  391c              SUBS     r1,r1,#0x1c
00006a  6008              STR      r0,[r1,#0]
;;;405          RTC->WUTR = (uint32_t)0x0000FFFF;
00006c  f64f70ff          MOV      r0,#0xffff
000070  490f              LDR      r1,|L15.176|
000072  3910              SUBS     r1,r1,#0x10
000074  6008              STR      r0,[r1,#0]
;;;406          RTC->PRER = (uint32_t)0x007F00FF;
000076  480f              LDR      r0,|L15.180|
000078  1f09              SUBS     r1,r1,#4
00007a  6008              STR      r0,[r1,#0]
;;;407          RTC->CALIBR = (uint32_t)0x00000000;
00007c  2000              MOVS     r0,#0
00007e  490c              LDR      r1,|L15.176|
000080  390c              SUBS     r1,r1,#0xc
000082  6008              STR      r0,[r1,#0]
;;;408          RTC->ALRMAR = (uint32_t)0x00000000;        
000084  1d09              ADDS     r1,r1,#4
000086  6008              STR      r0,[r1,#0]
;;;409          RTC->ALRMBR = (uint32_t)0x00000000;
000088  1d09              ADDS     r1,r1,#4
00008a  6008              STR      r0,[r1,#0]
;;;410          
;;;411          /* Reset ISR register and exit initialization mode */
;;;412          RTC->ISR = (uint32_t)0x00000000;
00008c  4908              LDR      r1,|L15.176|
00008e  3918              SUBS     r1,r1,#0x18
000090  6008              STR      r0,[r1,#0]
;;;413          
;;;414          /* Reset Tamper and alternate functions configuration register */
;;;415          RTC->TAFCR = 0x00000000;
000092  4907              LDR      r1,|L15.176|
000094  311c              ADDS     r1,r1,#0x1c
000096  6008              STR      r0,[r1,#0]
;;;416      
;;;417          if(RTC_WaitForSynchro() == ERROR)
000098  f7fffffe          BL       RTC_WaitForSynchro
00009c  b908              CBNZ     r0,|L15.162|
;;;418          {
;;;419            status = ERROR;
00009e  2600              MOVS     r6,#0
0000a0  e000              B        |L15.164|
                  |L15.162|
;;;420          }
;;;421          else
;;;422          {
;;;423            status = SUCCESS;      
0000a2  2601              MOVS     r6,#1
                  |L15.164|
;;;424          }
;;;425        }
;;;426      }
;;;427      
;;;428      /* Enable the write protection for RTC registers */
;;;429      RTC->WPR = 0xFF;  
0000a4  20ff              MOVS     r0,#0xff
0000a6  4902              LDR      r1,|L15.176|
0000a8  6008              STR      r0,[r1,#0]
;;;430      
;;;431      return status;
0000aa  4630              MOV      r0,r6
;;;432    }
0000ac  bd70              POP      {r4-r6,pc}
;;;433    
                          ENDP

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

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

                  RTC_EnterInitMode PROC
;;;539      */
;;;540    ErrorStatus RTC_EnterInitMode(void)
000000  b510              PUSH     {r4,lr}
;;;541    {
;;;542      __IO uint32_t initcounter = 0x00;
000002  2100              MOVS     r1,#0
;;;543      ErrorStatus status = ERROR;
000004  2000              MOVS     r0,#0
;;;544      uint32_t initstatus = 0x00;
000006  2200              MOVS     r2,#0
;;;545         
;;;546      /* Check if the Initialization mode is set */
;;;547      if ((RTC->ISR & RTC_ISR_INITF) == (uint32_t)RESET)
000008  4b0e              LDR      r3,|L16.68|
00000a  681b              LDR      r3,[r3,#0]
00000c  f0130f40          TST      r3,#0x40
000010  d116              BNE      |L16.64|
;;;548      {
;;;549        /* Set the Initialization mode */
;;;550        RTC->ISR = (uint32_t)RTC_INIT_MASK;
000012  1e43              SUBS     r3,r0,#1
000014  4c0b              LDR      r4,|L16.68|
000016  6023              STR      r3,[r4,#0]
;;;551        
;;;552        /* Wait till RTC is in INIT state and if Time out is reached exit */
;;;553        do
000018  bf00              NOP      
                  |L16.26|
;;;554        {
;;;555          initstatus = RTC->ISR & RTC_ISR_INITF;
00001a  4b0a              LDR      r3,|L16.68|
00001c  681b              LDR      r3,[r3,#0]
00001e  f0030240          AND      r2,r3,#0x40
;;;556          initcounter++;  
000022  1c49              ADDS     r1,r1,#1
;;;557        } while((initcounter != INITMODE_TIMEOUT) && (initstatus == 0x00));
000024  f5b13f80          CMP      r1,#0x10000
000028  d001              BEQ      |L16.46|
00002a  2a00              CMP      r2,#0
00002c  d0f5              BEQ      |L16.26|
                  |L16.46|
;;;558        
;;;559        if ((RTC->ISR & RTC_ISR_INITF) != RESET)
00002e  4b05              LDR      r3,|L16.68|
000030  681b              LDR      r3,[r3,#0]
000032  f0130f40          TST      r3,#0x40
000036  d001              BEQ      |L16.60|
;;;560        {
;;;561          status = SUCCESS;
000038  2001              MOVS     r0,#1
00003a  e002              B        |L16.66|
                  |L16.60|
;;;562        }
;;;563        else
;;;564        {
;;;565          status = ERROR;
00003c  2000              MOVS     r0,#0
00003e  e000              B        |L16.66|
                  |L16.64|
;;;566        }        
;;;567      }
;;;568      else
;;;569      {
;;;570        status = SUCCESS;  
000040  2001              MOVS     r0,#1
                  |L16.66|
;;;571      } 
;;;572        
;;;573      return (status);  
;;;574    }
000042  bd10              POP      {r4,pc}
;;;575    
                          ENDP

                  |L16.68|
                          DCD      0x4000280c

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

                  RTC_ExitInitMode PROC
;;;584      */
;;;585    void RTC_ExitInitMode(void)
000000  4803              LDR      r0,|L17.16|
;;;586    { 
;;;587      /* Exit Initialization mode */
;;;588      RTC->ISR &= (uint32_t)~RTC_ISR_INIT;  
000002  6800              LDR      r0,[r0,#0]
000004  f0200080          BIC      r0,r0,#0x80
000008  4901              LDR      r1,|L17.16|
00000a  6008              STR      r0,[r1,#0]
;;;589    }
00000c  4770              BX       lr
;;;590    
                          ENDP

00000e  0000              DCW      0x0000
                  |L17.16|
                          DCD      0x4000280c

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

                  RTC_GetAlarm PROC
;;;1228     */
;;;1229   void RTC_GetAlarm(uint32_t RTC_Format, uint32_t RTC_Alarm, RTC_AlarmTypeDef* RTC_AlarmStruct)
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;1230   {
000004  4606              MOV      r6,r0
000006  460f              MOV      r7,r1
000008  4614              MOV      r4,r2
;;;1231     uint32_t tmpreg = 0;
00000a  2500              MOVS     r5,#0
;;;1232   
;;;1233     /* Check the parameters */
;;;1234     assert_param(IS_RTC_FORMAT(RTC_Format));
;;;1235     assert_param(IS_RTC_ALARM(RTC_Alarm)); 
;;;1236   
;;;1237     /* Get the RTC_ALRMxR register */
;;;1238     if (RTC_Alarm == RTC_Alarm_A)
00000c  f5b77f80          CMP      r7,#0x100
000010  d102              BNE      |L18.24|
;;;1239     {
;;;1240       tmpreg = (uint32_t)(RTC->ALRMAR);
000012  4817              LDR      r0,|L18.112|
000014  6805              LDR      r5,[r0,#0]
000016  e002              B        |L18.30|
                  |L18.24|
;;;1241     }
;;;1242     else
;;;1243     {
;;;1244       tmpreg = (uint32_t)(RTC->ALRMBR);
000018  4815              LDR      r0,|L18.112|
00001a  1d00              ADDS     r0,r0,#4
00001c  6805              LDR      r5,[r0,#0]
                  |L18.30|
;;;1245     }
;;;1246   
;;;1247     /* Fill the structure with the read parameters */
;;;1248     RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours = (uint32_t)((tmpreg & (RTC_ALRMAR_HT | \
00001e  f3c54005          UBFX     r0,r5,#16,#6
000022  7020              STRB     r0,[r4,#0]
;;;1249                                                        RTC_ALRMAR_HU)) >> 16);
;;;1250     RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes = (uint32_t)((tmpreg & (RTC_ALRMAR_MNT | \
000024  f3c52006          UBFX     r0,r5,#8,#7
000028  7060              STRB     r0,[r4,#1]
;;;1251                                                        RTC_ALRMAR_MNU)) >> 8);
;;;1252     RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds = (uint32_t)(tmpreg & (RTC_ALRMAR_ST | \
00002a  f005007f          AND      r0,r5,#0x7f
00002e  70a0              STRB     r0,[r4,#2]
;;;1253                                                        RTC_ALRMAR_SU));
;;;1254     RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = (uint32_t)((tmpreg & RTC_ALRMAR_PM) >> 16);
000030  f4050080          AND      r0,r5,#0x400000
000034  0c00              LSRS     r0,r0,#16
000036  70e0              STRB     r0,[r4,#3]
;;;1255     RTC_AlarmStruct->RTC_AlarmDateWeekDay = (uint32_t)((tmpreg & (RTC_ALRMAR_DT | RTC_ALRMAR_DU)) >> 24);
000038  f3c56005          UBFX     r0,r5,#24,#6
00003c  7320              STRB     r0,[r4,#0xc]
;;;1256     RTC_AlarmStruct->RTC_AlarmDateWeekDaySel = (uint32_t)(tmpreg & RTC_ALRMAR_WDSEL);
00003e  f0054080          AND      r0,r5,#0x40000000
000042  60a0              STR      r0,[r4,#8]
;;;1257     RTC_AlarmStruct->RTC_AlarmMask = (uint32_t)(tmpreg & RTC_AlarmMask_All);
000044  f0053080          AND      r0,r5,#0x80808080
000048  6060              STR      r0,[r4,#4]
;;;1258   
;;;1259     if (RTC_Format == RTC_Format_BIN)
00004a  b97e              CBNZ     r6,|L18.108|
;;;1260     {
;;;1261       RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours = RTC_Bcd2ToByte(RTC_AlarmStruct-> \
00004c  7820              LDRB     r0,[r4,#0]
00004e  f7fffffe          BL       RTC_Bcd2ToByte
000052  7020              STRB     r0,[r4,#0]
;;;1262                                                           RTC_AlarmTime.RTC_Hours);
;;;1263       RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes = RTC_Bcd2ToByte(RTC_AlarmStruct-> \
000054  7860              LDRB     r0,[r4,#1]
000056  f7fffffe          BL       RTC_Bcd2ToByte
00005a  7060              STRB     r0,[r4,#1]
;;;1264                                                           RTC_AlarmTime.RTC_Minutes);
;;;1265       RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds = RTC_Bcd2ToByte(RTC_AlarmStruct-> \
00005c  78a0              LDRB     r0,[r4,#2]
00005e  f7fffffe          BL       RTC_Bcd2ToByte
000062  70a0              STRB     r0,[r4,#2]
;;;1266                                                           RTC_AlarmTime.RTC_Seconds);
;;;1267       RTC_AlarmStruct->RTC_AlarmDateWeekDay = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmDateWeekDay);
000064  7b20              LDRB     r0,[r4,#0xc]
000066  f7fffffe          BL       RTC_Bcd2ToByte
00006a  7320              STRB     r0,[r4,#0xc]
                  |L18.108|
;;;1268     }  
;;;1269   }
00006c  e8bd81f0          POP      {r4-r8,pc}
;;;1270   
                          ENDP

                  |L18.112|
                          DCD      0x4000281c

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

                  RTC_GetAlarmSubSecond PROC
;;;1417     */
;;;1418   uint32_t RTC_GetAlarmSubSecond(uint32_t RTC_Alarm)
000000  4601              MOV      r1,r0
;;;1419   {
;;;1420     uint32_t tmpreg = 0;
000002  2000              MOVS     r0,#0
;;;1421     
;;;1422     /* Get the RTC_ALRMxR register */
;;;1423     if (RTC_Alarm == RTC_Alarm_A)
000004  f5b17f80          CMP      r1,#0x100
000008  d104              BNE      |L19.20|
;;;1424     {
;;;1425       tmpreg = (uint32_t)((RTC->ALRMASSR) & RTC_ALRMASSR_SS);
00000a  4a05              LDR      r2,|L19.32|
00000c  6812              LDR      r2,[r2,#0]
00000e  f3c2000e          UBFX     r0,r2,#0,#15
000012  e004              B        |L19.30|
                  |L19.20|
;;;1426     }
;;;1427     else
;;;1428     {
;;;1429       tmpreg = (uint32_t)((RTC->ALRMBSSR) & RTC_ALRMBSSR_SS);
000014  4a02              LDR      r2,|L19.32|
000016  1d12              ADDS     r2,r2,#4
000018  6812              LDR      r2,[r2,#0]
00001a  f3c2000e          UBFX     r0,r2,#0,#15
                  |L19.30|
;;;1430     } 
;;;1431     
;;;1432     return (tmpreg);
;;;1433   }
00001e  4770              BX       lr
;;;1434   
                          ENDP

                  |L19.32|
                          DCD      0x40002844

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

                  RTC_GetDate PROC
;;;1027     */
;;;1028   void RTC_GetDate(uint32_t RTC_Format, RTC_DateTypeDef* RTC_DateStruct)
000000  b570              PUSH     {r4-r6,lr}
;;;1029   {
000002  4606              MOV      r6,r0
000004  460c              MOV      r4,r1
;;;1030     uint32_t tmpreg = 0;
000006  2500              MOVS     r5,#0
;;;1031   
;;;1032     /* Check the parameters */
;;;1033     assert_param(IS_RTC_FORMAT(RTC_Format));
;;;1034     
;;;1035     /* Get the RTC_TR register */
;;;1036     tmpreg = (uint32_t)(RTC->DR & RTC_DR_RESERVED_MASK); 
000008  480e              LDR      r0,|L20.68|
00000a  6800              LDR      r0,[r0,#0]
00000c  490e              LDR      r1,|L20.72|
00000e  ea000501          AND      r5,r0,r1
;;;1037   
;;;1038     /* Fill the structure fields with the read parameters */
;;;1039     RTC_DateStruct->RTC_Year = (uint8_t)((tmpreg & (RTC_DR_YT | RTC_DR_YU)) >> 16);
000012  0c28              LSRS     r0,r5,#16
000014  70e0              STRB     r0,[r4,#3]
;;;1040     RTC_DateStruct->RTC_Month = (uint8_t)((tmpreg & (RTC_DR_MT | RTC_DR_MU)) >> 8);
000016  f3c52004          UBFX     r0,r5,#8,#5
00001a  7060              STRB     r0,[r4,#1]
;;;1041     RTC_DateStruct->RTC_Date = (uint8_t)(tmpreg & (RTC_DR_DT | RTC_DR_DU));
00001c  f005003f          AND      r0,r5,#0x3f
000020  70a0              STRB     r0,[r4,#2]
;;;1042     RTC_DateStruct->RTC_WeekDay = (uint8_t)((tmpreg & (RTC_DR_WDU)) >> 13);
000022  f3c53042          UBFX     r0,r5,#13,#3
000026  7020              STRB     r0,[r4,#0]
;;;1043   
;;;1044     /* Check the input parameters format */
;;;1045     if (RTC_Format == RTC_Format_BIN)
000028  b95e              CBNZ     r6,|L20.66|
;;;1046     {
;;;1047       /* Convert the structure parameters to Binary format */
;;;1048       RTC_DateStruct->RTC_Year = (uint8_t)RTC_Bcd2ToByte(RTC_DateStruct->RTC_Year);
00002a  78e0              LDRB     r0,[r4,#3]
00002c  f7fffffe          BL       RTC_Bcd2ToByte
000030  70e0              STRB     r0,[r4,#3]
;;;1049       RTC_DateStruct->RTC_Month = (uint8_t)RTC_Bcd2ToByte(RTC_DateStruct->RTC_Month);
000032  7860              LDRB     r0,[r4,#1]
000034  f7fffffe          BL       RTC_Bcd2ToByte
000038  7060              STRB     r0,[r4,#1]
;;;1050       RTC_DateStruct->RTC_Date = (uint8_t)RTC_Bcd2ToByte(RTC_DateStruct->RTC_Date);
00003a  78a0              LDRB     r0,[r4,#2]
00003c  f7fffffe          BL       RTC_Bcd2ToByte
000040  70a0              STRB     r0,[r4,#2]
                  |L20.66|
;;;1051     }
;;;1052   }
000042  bd70              POP      {r4-r6,pc}
;;;1053   
                          ENDP

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

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

                  RTC_GetFlagStatus PROC
;;;2575     */
;;;2576   FlagStatus RTC_GetFlagStatus(uint32_t RTC_FLAG)
000000  b510              PUSH     {r4,lr}
;;;2577   {
000002  4601              MOV      r1,r0
;;;2578     FlagStatus bitstatus = RESET;
000004  2000              MOVS     r0,#0
;;;2579     uint32_t tmpreg = 0;
000006  2200              MOVS     r2,#0
;;;2580     
;;;2581     /* Check the parameters */
;;;2582     assert_param(IS_RTC_GET_FLAG(RTC_FLAG));
;;;2583     
;;;2584     /* Get all the flags */
;;;2585     tmpreg = (uint32_t)(RTC->ISR & RTC_FLAGS_MASK);
000008  4b05              LDR      r3,|L21.32|
00000a  681b              LDR      r3,[r3,#0]
00000c  f6437477          MOV      r4,#0x3f77
000010  ea030204          AND      r2,r3,r4
;;;2586     
;;;2587     /* Return the status of the flag */
;;;2588     if ((tmpreg & RTC_FLAG) != (uint32_t)RESET)
000014  420a              TST      r2,r1
000016  d001              BEQ      |L21.28|
;;;2589     {
;;;2590       bitstatus = SET;
000018  2001              MOVS     r0,#1
00001a  e000              B        |L21.30|
                  |L21.28|
;;;2591     }
;;;2592     else
;;;2593     {
;;;2594       bitstatus = RESET;
00001c  2000              MOVS     r0,#0
                  |L21.30|
;;;2595     }
;;;2596     return bitstatus;
;;;2597   }
00001e  bd10              POP      {r4,pc}
;;;2598   
                          ENDP

                  |L21.32|
                          DCD      0x4000280c

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

                  RTC_GetITStatus PROC
;;;2631     */
;;;2632   ITStatus RTC_GetITStatus(uint32_t RTC_IT)
000000  b530              PUSH     {r4,r5,lr}
;;;2633   {
000002  4601              MOV      r1,r0
;;;2634     ITStatus bitstatus = RESET;
000004  2000              MOVS     r0,#0
;;;2635     uint32_t tmpreg = 0, enablestatus = 0;
000006  2200              MOVS     r2,#0
000008  2300              MOVS     r3,#0
;;;2636    
;;;2637     /* Check the parameters */
;;;2638     assert_param(IS_RTC_GET_IT(RTC_IT));
;;;2639     
;;;2640     /* Get the TAMPER Interrupt enable bit and pending bit */
;;;2641     tmpreg = (uint32_t)(RTC->TAFCR & (RTC_TAFCR_TAMPIE));
00000a  4c0c              LDR      r4,|L22.60|
00000c  6824              LDR      r4,[r4,#0]
00000e  f0040204          AND      r2,r4,#4
;;;2642    
;;;2643     /* Get the Interrupt enable Status */
;;;2644     enablestatus = (uint32_t)((RTC->CR & RTC_IT) | (tmpreg & (RTC_IT >> 15)));
000012  4c0a              LDR      r4,|L22.60|
000014  3c38              SUBS     r4,r4,#0x38
000016  6824              LDR      r4,[r4,#0]
000018  400c              ANDS     r4,r4,r1
00001a  ea0235d1          AND      r5,r2,r1,LSR #15
00001e  ea440305          ORR      r3,r4,r5
;;;2645     
;;;2646     /* Get the Interrupt pending bit */
;;;2647     tmpreg = (uint32_t)((RTC->ISR & (uint32_t)(RTC_IT >> 4)));
000022  4c06              LDR      r4,|L22.60|
000024  3c34              SUBS     r4,r4,#0x34
000026  6824              LDR      r4,[r4,#0]
000028  ea041211          AND      r2,r4,r1,LSR #4
;;;2648     
;;;2649     /* Get the status of the Interrupt */
;;;2650     if ((enablestatus != (uint32_t)RESET) && ((tmpreg & 0x0000FFFF) != (uint32_t)RESET))
00002c  b123              CBZ      r3,|L22.56|
00002e  0414              LSLS     r4,r2,#16
000030  0c24              LSRS     r4,r4,#16
000032  d001              BEQ      |L22.56|
;;;2651     {
;;;2652       bitstatus = SET;
000034  2001              MOVS     r0,#1
000036  e000              B        |L22.58|
                  |L22.56|
;;;2653     }
;;;2654     else
;;;2655     {
;;;2656       bitstatus = RESET;
000038  2000              MOVS     r0,#0
                  |L22.58|
;;;2657     }
;;;2658     return bitstatus;
;;;2659   }
00003a  bd30              POP      {r4,r5,pc}
;;;2660   
                          ENDP

                  |L22.60|
                          DCD      0x40002840

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

                  RTC_GetStoreOperation PROC
;;;1630     */
;;;1631   uint32_t RTC_GetStoreOperation(void)
000000  4802              LDR      r0,|L23.12|
;;;1632   {
;;;1633     return (RTC->CR & RTC_CR_BCK);
000002  6800              LDR      r0,[r0,#0]
000004  f4002080          AND      r0,r0,#0x40000
;;;1634   }
000008  4770              BX       lr
;;;1635   
                          ENDP

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

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

                  RTC_GetSubSecond PROC
;;;900      */
;;;901    uint32_t RTC_GetSubSecond(void)
000000  2000              MOVS     r0,#0
;;;902    {
;;;903      uint32_t tmpreg = 0;
;;;904      
;;;905      /* Get subseconds values from the correspondent registers*/
;;;906      tmpreg = (uint32_t)(RTC->SSR);
000002  4903              LDR      r1,|L24.16|
000004  6808              LDR      r0,[r1,#0]
;;;907      
;;;908      /* Read DR register to unfroze calendar registers */
;;;909      (void) (RTC->DR);
000006  4902              LDR      r1,|L24.16|
000008  3924              SUBS     r1,r1,#0x24
00000a  6809              LDR      r1,[r1,#0]
;;;910      
;;;911      return (tmpreg);
;;;912    }
00000c  4770              BX       lr
;;;913    
                          ENDP

00000e  0000              DCW      0x0000
                  |L24.16|
                          DCD      0x40002828

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

                  RTC_GetTime PROC
;;;867      */
;;;868    void RTC_GetTime(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_TimeStruct)
000000  b570              PUSH     {r4-r6,lr}
;;;869    {
000002  4606              MOV      r6,r0
000004  460c              MOV      r4,r1
;;;870      uint32_t tmpreg = 0;
000006  2500              MOVS     r5,#0
;;;871    
;;;872      /* Check the parameters */
;;;873      assert_param(IS_RTC_FORMAT(RTC_Format));
;;;874    
;;;875      /* Get the RTC_TR register */
;;;876      tmpreg = (uint32_t)(RTC->TR & RTC_TR_RESERVED_MASK); 
000008  480f              LDR      r0,|L25.72|
00000a  6800              LDR      r0,[r0,#0]
00000c  490f              LDR      r1,|L25.76|
00000e  ea000501          AND      r5,r0,r1
;;;877      
;;;878      /* Fill the structure fields with the read parameters */
;;;879      RTC_TimeStruct->RTC_Hours = (uint8_t)((tmpreg & (RTC_TR_HT | RTC_TR_HU)) >> 16);
000012  f3c54005          UBFX     r0,r5,#16,#6
000016  7020              STRB     r0,[r4,#0]
;;;880      RTC_TimeStruct->RTC_Minutes = (uint8_t)((tmpreg & (RTC_TR_MNT | RTC_TR_MNU)) >>8);
000018  f3c52006          UBFX     r0,r5,#8,#7
00001c  7060              STRB     r0,[r4,#1]
;;;881      RTC_TimeStruct->RTC_Seconds = (uint8_t)(tmpreg & (RTC_TR_ST | RTC_TR_SU));
00001e  f005007f          AND      r0,r5,#0x7f
000022  70a0              STRB     r0,[r4,#2]
;;;882      RTC_TimeStruct->RTC_H12 = (uint8_t)((tmpreg & (RTC_TR_PM)) >> 16);  
000024  f4050080          AND      r0,r5,#0x400000
000028  0c00              LSRS     r0,r0,#16
00002a  70e0              STRB     r0,[r4,#3]
;;;883    
;;;884      /* Check the input parameters format */
;;;885      if (RTC_Format == RTC_Format_BIN)
00002c  b95e              CBNZ     r6,|L25.70|
;;;886      {
;;;887        /* Convert the structure parameters to Binary format */
;;;888        RTC_TimeStruct->RTC_Hours = (uint8_t)RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Hours);
00002e  7820              LDRB     r0,[r4,#0]
000030  f7fffffe          BL       RTC_Bcd2ToByte
000034  7020              STRB     r0,[r4,#0]
;;;889        RTC_TimeStruct->RTC_Minutes = (uint8_t)RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Minutes);
000036  7860              LDRB     r0,[r4,#1]
000038  f7fffffe          BL       RTC_Bcd2ToByte
00003c  7060              STRB     r0,[r4,#1]
;;;890        RTC_TimeStruct->RTC_Seconds = (uint8_t)RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Seconds);   
00003e  78a0              LDRB     r0,[r4,#2]
000040  f7fffffe          BL       RTC_Bcd2ToByte
000044  70a0              STRB     r0,[r4,#2]
                  |L25.70|
;;;891      }
;;;892    }
000046  bd70              POP      {r4-r6,pc}
;;;893    
                          ENDP

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

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

                  RTC_GetTimeStamp PROC
;;;1998     */
;;;1999   void RTC_GetTimeStamp(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_StampTimeStruct, 
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;2000                                         RTC_DateTypeDef* RTC_StampDateStruct)
;;;2001   {
000004  4680              MOV      r8,r0
000006  460c              MOV      r4,r1
000008  4615              MOV      r5,r2
;;;2002     uint32_t tmptime = 0, tmpdate = 0;
00000a  2600              MOVS     r6,#0
00000c  2700              MOVS     r7,#0
;;;2003   
;;;2004     /* Check the parameters */
;;;2005     assert_param(IS_RTC_FORMAT(RTC_Format));
;;;2006   
;;;2007     /* Get the TimeStamp time and date registers values */
;;;2008     tmptime = (uint32_t)(RTC->TSTR & RTC_TR_RESERVED_MASK);
00000e  4820              LDR      r0,|L26.144|
000010  6800              LDR      r0,[r0,#0]
000012  4920              LDR      r1,|L26.148|
000014  ea000601          AND      r6,r0,r1
;;;2009     tmpdate = (uint32_t)(RTC->TSDR & RTC_DR_RESERVED_MASK);
000018  481d              LDR      r0,|L26.144|
00001a  1d00              ADDS     r0,r0,#4
00001c  6800              LDR      r0,[r0,#0]
00001e  491e              LDR      r1,|L26.152|
000020  ea000701          AND      r7,r0,r1
;;;2010   
;;;2011     /* Fill the Time structure fields with the read parameters */
;;;2012     RTC_StampTimeStruct->RTC_Hours = (uint8_t)((tmptime & (RTC_TR_HT | RTC_TR_HU)) >> 16);
000024  f3c64005          UBFX     r0,r6,#16,#6
000028  7020              STRB     r0,[r4,#0]
;;;2013     RTC_StampTimeStruct->RTC_Minutes = (uint8_t)((tmptime & (RTC_TR_MNT | RTC_TR_MNU)) >> 8);
00002a  f3c62006          UBFX     r0,r6,#8,#7
00002e  7060              STRB     r0,[r4,#1]
;;;2014     RTC_StampTimeStruct->RTC_Seconds = (uint8_t)(tmptime & (RTC_TR_ST | RTC_TR_SU));
000030  f006007f          AND      r0,r6,#0x7f
000034  70a0              STRB     r0,[r4,#2]
;;;2015     RTC_StampTimeStruct->RTC_H12 = (uint8_t)((tmptime & (RTC_TR_PM)) >> 16);  
000036  f4060080          AND      r0,r6,#0x400000
00003a  0c00              LSRS     r0,r0,#16
00003c  70e0              STRB     r0,[r4,#3]
;;;2016   
;;;2017     /* Fill the Date structure fields with the read parameters */
;;;2018     RTC_StampDateStruct->RTC_Year = 0;
00003e  2000              MOVS     r0,#0
000040  70e8              STRB     r0,[r5,#3]
;;;2019     RTC_StampDateStruct->RTC_Month = (uint8_t)((tmpdate & (RTC_DR_MT | RTC_DR_MU)) >> 8);
000042  f3c72004          UBFX     r0,r7,#8,#5
000046  7068              STRB     r0,[r5,#1]
;;;2020     RTC_StampDateStruct->RTC_Date = (uint8_t)(tmpdate & (RTC_DR_DT | RTC_DR_DU));
000048  f007003f          AND      r0,r7,#0x3f
00004c  70a8              STRB     r0,[r5,#2]
;;;2021     RTC_StampDateStruct->RTC_WeekDay = (uint8_t)((tmpdate & (RTC_DR_WDU)) >> 13);
00004e  f3c73042          UBFX     r0,r7,#13,#3
000052  7028              STRB     r0,[r5,#0]
;;;2022   
;;;2023     /* Check the input parameters format */
;;;2024     if (RTC_Format == RTC_Format_BIN)
000054  f1b80f00          CMP      r8,#0
000058  d117              BNE      |L26.138|
;;;2025     {
;;;2026       /* Convert the Time structure parameters to Binary format */
;;;2027       RTC_StampTimeStruct->RTC_Hours = (uint8_t)RTC_Bcd2ToByte(RTC_StampTimeStruct->RTC_Hours);
00005a  7820              LDRB     r0,[r4,#0]
00005c  f7fffffe          BL       RTC_Bcd2ToByte
000060  7020              STRB     r0,[r4,#0]
;;;2028       RTC_StampTimeStruct->RTC_Minutes = (uint8_t)RTC_Bcd2ToByte(RTC_StampTimeStruct->RTC_Minutes);
000062  7860              LDRB     r0,[r4,#1]
000064  f7fffffe          BL       RTC_Bcd2ToByte
000068  7060              STRB     r0,[r4,#1]
;;;2029       RTC_StampTimeStruct->RTC_Seconds = (uint8_t)RTC_Bcd2ToByte(RTC_StampTimeStruct->RTC_Seconds);
00006a  78a0              LDRB     r0,[r4,#2]
00006c  f7fffffe          BL       RTC_Bcd2ToByte
000070  70a0              STRB     r0,[r4,#2]
;;;2030   
;;;2031       /* Convert the Date structure parameters to Binary format */
;;;2032       RTC_StampDateStruct->RTC_Month = (uint8_t)RTC_Bcd2ToByte(RTC_StampDateStruct->RTC_Month);
000072  7868              LDRB     r0,[r5,#1]
000074  f7fffffe          BL       RTC_Bcd2ToByte
000078  7068              STRB     r0,[r5,#1]
;;;2033       RTC_StampDateStruct->RTC_Date = (uint8_t)RTC_Bcd2ToByte(RTC_StampDateStruct->RTC_Date);
00007a  78a8              LDRB     r0,[r5,#2]
00007c  f7fffffe          BL       RTC_Bcd2ToByte
000080  70a8              STRB     r0,[r5,#2]
;;;2034       RTC_StampDateStruct->RTC_WeekDay = (uint8_t)RTC_Bcd2ToByte(RTC_StampDateStruct->RTC_WeekDay);
000082  7828              LDRB     r0,[r5,#0]
000084  f7fffffe          BL       RTC_Bcd2ToByte
000088  7028              STRB     r0,[r5,#0]
                  |L26.138|
;;;2035     }
;;;2036   }
00008a  e8bd81f0          POP      {r4-r8,pc}
;;;2037   
                          ENDP

00008e  0000              DCW      0x0000
                  |L26.144|
                          DCD      0x40002830
                  |L26.148|
                          DCD      0x007f7f7f
                  |L26.152|
                          DCD      0x00ffff3f

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

                  RTC_GetTimeStampSubSecond PROC
;;;2042     */
;;;2043   uint32_t RTC_GetTimeStampSubSecond(void)
000000  4801              LDR      r0,|L27.8|
;;;2044   {
;;;2045     /* Get timestamp subseconds values from the correspondent registers */
;;;2046     return (uint32_t)(RTC->TSSSR);
000002  6800              LDR      r0,[r0,#0]
;;;2047   }
000004  4770              BX       lr
;;;2048   
                          ENDP

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

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

                  RTC_GetWakeUpCounter PROC
;;;1514     */
;;;1515   uint32_t RTC_GetWakeUpCounter(void)
000000  4801              LDR      r0,|L28.8|
;;;1516   {
;;;1517     /* Get the counter value */
;;;1518     return ((uint32_t)(RTC->WUTR & RTC_WUTR_WUT));
000002  6800              LDR      r0,[r0,#0]
000004  b280              UXTH     r0,r0
;;;1519   }
000006  4770              BX       lr
;;;1520   
                          ENDP

                  |L28.8|
                          DCD      0x40002814

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

                  RTC_ITConfig PROC
;;;2529     */
;;;2530   void RTC_ITConfig(uint32_t RTC_IT, FunctionalState NewState)
000000  22ca              MOVS     r2,#0xca
;;;2531   {
;;;2532     /* Check the parameters */
;;;2533     assert_param(IS_RTC_CONFIG_IT(RTC_IT));
;;;2534     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;2535   
;;;2536     /* Disable the write protection for RTC registers */
;;;2537     RTC->WPR = 0xCA;
000002  4b17              LDR      r3,|L29.96|
000004  601a              STR      r2,[r3,#0]
;;;2538     RTC->WPR = 0x53;
000006  2253              MOVS     r2,#0x53
000008  601a              STR      r2,[r3,#0]
;;;2539   
;;;2540     if (NewState != DISABLE)
00000a  b191              CBZ      r1,|L29.50|
;;;2541     {
;;;2542       /* Configure the Interrupts in the RTC_CR register */
;;;2543       RTC->CR |= (uint32_t)(RTC_IT & ~RTC_TAFCR_TAMPIE);
00000c  4a14              LDR      r2,|L29.96|
00000e  3a1c              SUBS     r2,r2,#0x1c
000010  6812              LDR      r2,[r2,#0]
000012  f0200304          BIC      r3,r0,#4
000016  431a              ORRS     r2,r2,r3
000018  4b11              LDR      r3,|L29.96|
00001a  3b1c              SUBS     r3,r3,#0x1c
00001c  601a              STR      r2,[r3,#0]
;;;2544       /* Configure the Tamper Interrupt in the RTC_TAFCR */
;;;2545       RTC->TAFCR |= (uint32_t)(RTC_IT & RTC_TAFCR_TAMPIE);
00001e  4a10              LDR      r2,|L29.96|
000020  321c              ADDS     r2,r2,#0x1c
000022  6812              LDR      r2,[r2,#0]
000024  f0000304          AND      r3,r0,#4
000028  431a              ORRS     r2,r2,r3
00002a  4b0d              LDR      r3,|L29.96|
00002c  331c              ADDS     r3,r3,#0x1c
00002e  601a              STR      r2,[r3,#0]
000030  e011              B        |L29.86|
                  |L29.50|
;;;2546     }
;;;2547     else
;;;2548     {
;;;2549       /* Configure the Interrupts in the RTC_CR register */
;;;2550       RTC->CR &= (uint32_t)~(RTC_IT & (uint32_t)~RTC_TAFCR_TAMPIE);
000032  4a0b              LDR      r2,|L29.96|
000034  3a1c              SUBS     r2,r2,#0x1c
000036  6812              LDR      r2,[r2,#0]
000038  f0200304          BIC      r3,r0,#4
00003c  439a              BICS     r2,r2,r3
00003e  4b08              LDR      r3,|L29.96|
000040  3b1c              SUBS     r3,r3,#0x1c
000042  601a              STR      r2,[r3,#0]
;;;2551       /* Configure the Tamper Interrupt in the RTC_TAFCR */
;;;2552       RTC->TAFCR &= (uint32_t)~(RTC_IT & RTC_TAFCR_TAMPIE);
000044  4a06              LDR      r2,|L29.96|
000046  321c              ADDS     r2,r2,#0x1c
000048  6812              LDR      r2,[r2,#0]
00004a  f0000304          AND      r3,r0,#4
00004e  439a              BICS     r2,r2,r3
000050  4b03              LDR      r3,|L29.96|
000052  331c              ADDS     r3,r3,#0x1c
000054  601a              STR      r2,[r3,#0]
                  |L29.86|
;;;2553     }
;;;2554     /* Enable the write protection for RTC registers */
;;;2555     RTC->WPR = 0xFF; 
000056  22ff              MOVS     r2,#0xff
000058  4b01              LDR      r3,|L29.96|
00005a  601a              STR      r2,[r3,#0]
;;;2556   }
00005c  4770              BX       lr
;;;2557   
                          ENDP

00005e  0000              DCW      0x0000
                  |L29.96|
                          DCD      0x40002824

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

                  RTC_Init PROC
;;;444      */
;;;445    ErrorStatus RTC_Init(RTC_InitTypeDef* RTC_InitStruct)
000000  b530              PUSH     {r4,r5,lr}
;;;446    {
000002  4604              MOV      r4,r0
;;;447      ErrorStatus status = ERROR;
000004  2500              MOVS     r5,#0
;;;448      
;;;449      /* Check the parameters */
;;;450      assert_param(IS_RTC_HOUR_FORMAT(RTC_InitStruct->RTC_HourFormat));
;;;451      assert_param(IS_RTC_ASYNCH_PREDIV(RTC_InitStruct->RTC_AsynchPrediv));
;;;452      assert_param(IS_RTC_SYNCH_PREDIV(RTC_InitStruct->RTC_SynchPrediv));
;;;453    
;;;454      /* Disable the write protection for RTC registers */
;;;455      RTC->WPR = 0xCA;
000006  20ca              MOVS     r0,#0xca
000008  4915              LDR      r1,|L30.96|
00000a  6008              STR      r0,[r1,#0]
;;;456      RTC->WPR = 0x53;
00000c  2053              MOVS     r0,#0x53
00000e  6008              STR      r0,[r1,#0]
;;;457    
;;;458      /* Set Initialization mode */
;;;459      if (RTC_EnterInitMode() == ERROR)
000010  f7fffffe          BL       RTC_EnterInitMode
000014  b900              CBNZ     r0,|L30.24|
;;;460      {
;;;461        status = ERROR;
000016  e01d              B        |L30.84|
                  |L30.24|
;;;462      } 
;;;463      else
;;;464      {
;;;465        /* Clear RTC CR FMT Bit */
;;;466        RTC->CR &= ((uint32_t)~(RTC_CR_FMT));
000018  4811              LDR      r0,|L30.96|
00001a  381c              SUBS     r0,r0,#0x1c
00001c  6800              LDR      r0,[r0,#0]
00001e  f0200040          BIC      r0,r0,#0x40
000022  490f              LDR      r1,|L30.96|
000024  391c              SUBS     r1,r1,#0x1c
000026  6008              STR      r0,[r1,#0]
;;;467        /* Set RTC_CR register */
;;;468        RTC->CR |=  ((uint32_t)(RTC_InitStruct->RTC_HourFormat));
000028  4608              MOV      r0,r1
00002a  6800              LDR      r0,[r0,#0]
00002c  6821              LDR      r1,[r4,#0]
00002e  4308              ORRS     r0,r0,r1
000030  490b              LDR      r1,|L30.96|
000032  391c              SUBS     r1,r1,#0x1c
000034  6008              STR      r0,[r1,#0]
;;;469      
;;;470        /* Configure the RTC PRER */
;;;471        RTC->PRER = (uint32_t)(RTC_InitStruct->RTC_SynchPrediv);
000036  490a              LDR      r1,|L30.96|
000038  3914              SUBS     r1,r1,#0x14
00003a  68a0              LDR      r0,[r4,#8]
00003c  6008              STR      r0,[r1,#0]
;;;472        RTC->PRER |= (uint32_t)(RTC_InitStruct->RTC_AsynchPrediv << 16);
00003e  4608              MOV      r0,r1
000040  6800              LDR      r0,[r0,#0]
000042  6861              LDR      r1,[r4,#4]
000044  ea404001          ORR      r0,r0,r1,LSL #16
000048  4905              LDR      r1,|L30.96|
00004a  3914              SUBS     r1,r1,#0x14
00004c  6008              STR      r0,[r1,#0]
;;;473    
;;;474        /* Exit Initialization mode */
;;;475        RTC_ExitInitMode();
00004e  f7fffffe          BL       RTC_ExitInitMode
;;;476    
;;;477        status = SUCCESS;    
000052  2501              MOVS     r5,#1
                  |L30.84|
;;;478      }
;;;479      /* Enable the write protection for RTC registers */
;;;480      RTC->WPR = 0xFF; 
000054  20ff              MOVS     r0,#0xff
000056  4902              LDR      r1,|L30.96|
000058  6008              STR      r0,[r1,#0]
;;;481      
;;;482      return status;
00005a  4628              MOV      r0,r5
;;;483    }
00005c  bd30              POP      {r4,r5,pc}
;;;484    
                          ENDP

00005e  0000              DCW      0x0000
                  |L30.96|
                          DCD      0x40002824

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

                  RTC_OutputConfig PROC
;;;1669     */
;;;1670   void RTC_OutputConfig(uint32_t RTC_Output, uint32_t RTC_OutputPolarity)
000000  22ca              MOVS     r2,#0xca
;;;1671   {
;;;1672     /* Check the parameters */
;;;1673     assert_param(IS_RTC_OUTPUT(RTC_Output));
;;;1674     assert_param(IS_RTC_OUTPUT_POL(RTC_OutputPolarity));
;;;1675   
;;;1676     /* Disable the write protection for RTC registers */
;;;1677     RTC->WPR = 0xCA;
000002  4b0c              LDR      r3,|L31.52|
000004  601a              STR      r2,[r3,#0]
;;;1678     RTC->WPR = 0x53;
000006  2253              MOVS     r2,#0x53
000008  601a              STR      r2,[r3,#0]
;;;1679   
;;;1680     /* Clear the bits to be configured */
;;;1681     RTC->CR &= (uint32_t)~(RTC_CR_OSEL | RTC_CR_POL);
00000a  4a0a              LDR      r2,|L31.52|
00000c  3a1c              SUBS     r2,r2,#0x1c
00000e  6812              LDR      r2,[r2,#0]
000010  f42202e0          BIC      r2,r2,#0x700000
000014  4b07              LDR      r3,|L31.52|
000016  3b1c              SUBS     r3,r3,#0x1c
000018  601a              STR      r2,[r3,#0]
;;;1682   
;;;1683     /* Configure the output selection and polarity */
;;;1684     RTC->CR |= (uint32_t)(RTC_Output | RTC_OutputPolarity);
00001a  461a              MOV      r2,r3
00001c  6812              LDR      r2,[r2,#0]
00001e  ea400301          ORR      r3,r0,r1
000022  431a              ORRS     r2,r2,r3
000024  4b03              LDR      r3,|L31.52|
000026  3b1c              SUBS     r3,r3,#0x1c
000028  601a              STR      r2,[r3,#0]
;;;1685   
;;;1686     /* Enable the write protection for RTC registers */
;;;1687     RTC->WPR = 0xFF; 
00002a  22ff              MOVS     r2,#0xff
00002c  4b01              LDR      r3,|L31.52|
00002e  601a              STR      r2,[r3,#0]
;;;1688   }
000030  4770              BX       lr
;;;1689   
                          ENDP

000032  0000              DCW      0x0000
                  |L31.52|
                          DCD      0x40002824

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

                  RTC_OutputTypeConfig PROC
;;;2372     */
;;;2373   void RTC_OutputTypeConfig(uint32_t RTC_OutputType)
000000  4905              LDR      r1,|L32.24|
;;;2374   {
;;;2375     /* Check the parameters */
;;;2376     assert_param(IS_RTC_OUTPUT_TYPE(RTC_OutputType));
;;;2377     
;;;2378     RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_ALARMOUTTYPE);
000002  6809              LDR      r1,[r1,#0]
000004  f4212180          BIC      r1,r1,#0x40000
000008  4a03              LDR      r2,|L32.24|
00000a  6011              STR      r1,[r2,#0]
;;;2379     RTC->TAFCR |= (uint32_t)(RTC_OutputType);  
00000c  4611              MOV      r1,r2
00000e  6809              LDR      r1,[r1,#0]
000010  4301              ORRS     r1,r1,r0
000012  6011              STR      r1,[r2,#0]
;;;2380   }
000014  4770              BX       lr
;;;2381   
                          ENDP

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

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

                  RTC_ReadBackupRegister PROC
;;;2296     */
;;;2297   uint32_t RTC_ReadBackupRegister(uint32_t RTC_BKP_DR)
000000  4601              MOV      r1,r0
;;;2298   {
;;;2299     __IO uint32_t tmp = 0;
000002  2200              MOVS     r2,#0
;;;2300     
;;;2301     /* Check the parameters */
;;;2302     assert_param(IS_RTC_BKP(RTC_BKP_DR));
;;;2303   
;;;2304     tmp = RTC_BASE + 0x50;
000004  4a02              LDR      r2,|L33.16|
;;;2305     tmp += (RTC_BKP_DR * 4);
000006  eb020281          ADD      r2,r2,r1,LSL #2
;;;2306     
;;;2307     /* Read the specified register */
;;;2308     return (*(__IO uint32_t *)tmp);
00000a  6810              LDR      r0,[r2,#0]
;;;2309   }
00000c  4770              BX       lr
;;;2310   
                          ENDP

00000e  0000              DCW      0x0000
                  |L33.16|
                          DCD      0x40002850

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

                  RTC_RefClockCmd PROC
;;;649      */
;;;650    ErrorStatus RTC_RefClockCmd(FunctionalState NewState)
000000  b530              PUSH     {r4,r5,lr}
;;;651    { 
000002  4604              MOV      r4,r0
;;;652      ErrorStatus status = ERROR;
000004  2500              MOVS     r5,#0
;;;653      
;;;654      /* Check the parameters */
;;;655      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;656      
;;;657      /* Disable the write protection for RTC registers */
;;;658      RTC->WPR = 0xCA;
000006  20ca              MOVS     r0,#0xca
000008  4910              LDR      r1,|L34.76|
00000a  6008              STR      r0,[r1,#0]
;;;659      RTC->WPR = 0x53;
00000c  2053              MOVS     r0,#0x53
00000e  6008              STR      r0,[r1,#0]
;;;660        
;;;661      /* Set Initialization mode */
;;;662      if (RTC_EnterInitMode() == ERROR)
000010  f7fffffe          BL       RTC_EnterInitMode
000014  b900              CBNZ     r0,|L34.24|
;;;663      {
;;;664        status = ERROR;
000016  e014              B        |L34.66|
                  |L34.24|
;;;665      } 
;;;666      else
;;;667      {  
;;;668        if (NewState != DISABLE)
000018  b144              CBZ      r4,|L34.44|
;;;669        {
;;;670          /* Enable the RTC reference clock detection */
;;;671          RTC->CR |= RTC_CR_REFCKON;   
00001a  480c              LDR      r0,|L34.76|
00001c  381c              SUBS     r0,r0,#0x1c
00001e  6800              LDR      r0,[r0,#0]
000020  f0400010          ORR      r0,r0,#0x10
000024  4909              LDR      r1,|L34.76|
000026  391c              SUBS     r1,r1,#0x1c
000028  6008              STR      r0,[r1,#0]
00002a  e007              B        |L34.60|
                  |L34.44|
;;;672        }
;;;673        else
;;;674        {
;;;675          /* Disable the RTC reference clock detection */
;;;676          RTC->CR &= ~RTC_CR_REFCKON;    
00002c  4807              LDR      r0,|L34.76|
00002e  381c              SUBS     r0,r0,#0x1c
000030  6800              LDR      r0,[r0,#0]
000032  f0200010          BIC      r0,r0,#0x10
000036  4905              LDR      r1,|L34.76|
000038  391c              SUBS     r1,r1,#0x1c
00003a  6008              STR      r0,[r1,#0]
                  |L34.60|
;;;677        }
;;;678        /* Exit Initialization mode */
;;;679        RTC_ExitInitMode();
00003c  f7fffffe          BL       RTC_ExitInitMode
;;;680        
;;;681        status = SUCCESS;
000040  2501              MOVS     r5,#1
                  |L34.66|
;;;682      }
;;;683      
;;;684      /* Enable the write protection for RTC registers */
;;;685      RTC->WPR = 0xFF;  
000042  20ff              MOVS     r0,#0xff
000044  4901              LDR      r1,|L34.76|
000046  6008              STR      r0,[r1,#0]
;;;686      
;;;687      return status; 
000048  4628              MOV      r0,r5
;;;688    }
00004a  bd30              POP      {r4,r5,pc}
;;;689    
                          ENDP

                  |L34.76|
                          DCD      0x40002824

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

                  RTC_SetAlarm PROC
;;;1087     */
;;;1088   void RTC_SetAlarm(uint32_t RTC_Format, uint32_t RTC_Alarm, RTC_AlarmTypeDef* RTC_AlarmStruct)
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;1089   {
000004  4605              MOV      r5,r0
000006  460f              MOV      r7,r1
000008  4614              MOV      r4,r2
;;;1090     uint32_t tmpreg = 0;
00000a  2600              MOVS     r6,#0
;;;1091     
;;;1092     /* Check the parameters */
;;;1093     assert_param(IS_RTC_FORMAT(RTC_Format));
;;;1094     assert_param(IS_RTC_ALARM(RTC_Alarm));
;;;1095     assert_param(IS_ALARM_MASK(RTC_AlarmStruct->RTC_AlarmMask));
;;;1096     assert_param(IS_RTC_ALARM_DATE_WEEKDAY_SEL(RTC_AlarmStruct->RTC_AlarmDateWeekDaySel));
;;;1097   
;;;1098     if (RTC_Format == RTC_Format_BIN)
00000c  b965              CBNZ     r5,|L35.40|
;;;1099     {
;;;1100       if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET)
00000e  4836              LDR      r0,|L35.232|
000010  6800              LDR      r0,[r0,#0]
000012  f0100f40          TST      r0,#0x40
000016  d000              BEQ      |L35.26|
;;;1101       {
;;;1102         assert_param(IS_RTC_HOUR12(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours));
;;;1103         assert_param(IS_RTC_H12(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12));
000018  e002              B        |L35.32|
                  |L35.26|
;;;1104       } 
;;;1105       else
;;;1106       {
;;;1107         RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = 0x00;
00001a  2000              MOVS     r0,#0
00001c  70e0              STRB     r0,[r4,#3]
;;;1108         assert_param(IS_RTC_HOUR24(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours));
00001e  bf00              NOP      
                  |L35.32|
;;;1109       }
;;;1110       assert_param(IS_RTC_MINUTES(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes));
;;;1111       assert_param(IS_RTC_SECONDS(RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds));
;;;1112       
;;;1113       if(RTC_AlarmStruct->RTC_AlarmDateWeekDaySel == RTC_AlarmDateWeekDaySel_Date)
000020  68a0              LDR      r0,[r4,#8]
000022  b900              CBNZ     r0,|L35.38|
;;;1114       {
;;;1115         assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(RTC_AlarmStruct->RTC_AlarmDateWeekDay));
000024  e019              B        |L35.90|
                  |L35.38|
;;;1116       }
;;;1117       else
;;;1118       {
;;;1119         assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(RTC_AlarmStruct->RTC_AlarmDateWeekDay));
000026  e018              B        |L35.90|
                  |L35.40|
;;;1120       }
;;;1121     }
;;;1122     else
;;;1123     {
;;;1124       if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET)
000028  482f              LDR      r0,|L35.232|
00002a  6800              LDR      r0,[r0,#0]
00002c  f0100f40          TST      r0,#0x40
000030  d004              BEQ      |L35.60|
;;;1125       {
;;;1126         tmpreg = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours);
000032  7820              LDRB     r0,[r4,#0]
000034  f7fffffe          BL       RTC_Bcd2ToByte
000038  4606              MOV      r6,r0
;;;1127         assert_param(IS_RTC_HOUR12(tmpreg));
;;;1128         assert_param(IS_RTC_H12(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12));
00003a  e002              B        |L35.66|
                  |L35.60|
;;;1129       } 
;;;1130       else
;;;1131       {
;;;1132         RTC_AlarmStruct->RTC_AlarmTime.RTC_H12 = 0x00;
00003c  2000              MOVS     r0,#0
00003e  70e0              STRB     r0,[r4,#3]
;;;1133         assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours)));
000040  bf00              NOP      
                  |L35.66|
;;;1134       }
;;;1135       
;;;1136       assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes)));
;;;1137       assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds)));
;;;1138       
;;;1139       if(RTC_AlarmStruct->RTC_AlarmDateWeekDaySel == RTC_AlarmDateWeekDaySel_Date)
000042  68a0              LDR      r0,[r4,#8]
000044  b920              CBNZ     r0,|L35.80|
;;;1140       {
;;;1141         tmpreg = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmDateWeekDay);
000046  7b20              LDRB     r0,[r4,#0xc]
000048  f7fffffe          BL       RTC_Bcd2ToByte
00004c  4606              MOV      r6,r0
;;;1142         assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(tmpreg));    
00004e  e004              B        |L35.90|
                  |L35.80|
;;;1143       }
;;;1144       else
;;;1145       {
;;;1146         tmpreg = RTC_Bcd2ToByte(RTC_AlarmStruct->RTC_AlarmDateWeekDay);
000050  7b20              LDRB     r0,[r4,#0xc]
000052  f7fffffe          BL       RTC_Bcd2ToByte
000056  4606              MOV      r6,r0
;;;1147         assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(tmpreg));      
000058  bf00              NOP      
                  |L35.90|
;;;1148       }    
;;;1149     }
;;;1150   
;;;1151     /* Check the input parameters format */
;;;1152     if (RTC_Format != RTC_Format_BIN)
00005a  b195              CBZ      r5,|L35.130|
;;;1153     {
;;;1154       tmpreg = (((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours) << 16) | \
00005c  7820              LDRB     r0,[r4,#0]
00005e  0400              LSLS     r0,r0,#16
000060  7861              LDRB     r1,[r4,#1]
000062  ea402001          ORR      r0,r0,r1,LSL #8
000066  78a1              LDRB     r1,[r4,#2]
000068  4308              ORRS     r0,r0,r1
00006a  78e1              LDRB     r1,[r4,#3]
00006c  ea404001          ORR      r0,r0,r1,LSL #16
000070  7b21              LDRB     r1,[r4,#0xc]
000072  ea406001          ORR      r0,r0,r1,LSL #24
000076  68a1              LDR      r1,[r4,#8]
000078  4308              ORRS     r0,r0,r1
00007a  6861              LDR      r1,[r4,#4]
00007c  ea400601          ORR      r6,r0,r1
000080  e01b              B        |L35.186|
                  |L35.130|
;;;1155                 ((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes) << 8) | \
;;;1156                 ((uint32_t)RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds) | \
;;;1157                 ((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12) << 16) | \
;;;1158                 ((uint32_t)(RTC_AlarmStruct->RTC_AlarmDateWeekDay) << 24) | \
;;;1159                 ((uint32_t)RTC_AlarmStruct->RTC_AlarmDateWeekDaySel) | \
;;;1160                 ((uint32_t)RTC_AlarmStruct->RTC_AlarmMask)); 
;;;1161     }  
;;;1162     else
;;;1163     {
;;;1164       tmpreg = (((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmTime.RTC_Hours) << 16) | \
000082  7820              LDRB     r0,[r4,#0]
000084  f7fffffe          BL       RTC_ByteToBcd2
000088  ea4f4800          LSL      r8,r0,#16
00008c  7860              LDRB     r0,[r4,#1]
00008e  f7fffffe          BL       RTC_ByteToBcd2
000092  ea482800          ORR      r8,r8,r0,LSL #8
000096  78a0              LDRB     r0,[r4,#2]
000098  f7fffffe          BL       RTC_ByteToBcd2
00009c  ea480800          ORR      r8,r8,r0
0000a0  78e0              LDRB     r0,[r4,#3]
0000a2  ea484800          ORR      r8,r8,r0,LSL #16
0000a6  7b20              LDRB     r0,[r4,#0xc]
0000a8  f7fffffe          BL       RTC_ByteToBcd2
0000ac  ea486000          ORR      r0,r8,r0,LSL #24
0000b0  68a1              LDR      r1,[r4,#8]
0000b2  4308              ORRS     r0,r0,r1
0000b4  6861              LDR      r1,[r4,#4]
0000b6  ea400601          ORR      r6,r0,r1
                  |L35.186|
;;;1165                 ((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmTime.RTC_Minutes) << 8) | \
;;;1166                 ((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmTime.RTC_Seconds)) | \
;;;1167                 ((uint32_t)(RTC_AlarmStruct->RTC_AlarmTime.RTC_H12) << 16) | \
;;;1168                 ((uint32_t)RTC_ByteToBcd2(RTC_AlarmStruct->RTC_AlarmDateWeekDay) << 24) | \
;;;1169                 ((uint32_t)RTC_AlarmStruct->RTC_AlarmDateWeekDaySel) | \
;;;1170                 ((uint32_t)RTC_AlarmStruct->RTC_AlarmMask)); 
;;;1171     } 
;;;1172   
;;;1173     /* Disable the write protection for RTC registers */
;;;1174     RTC->WPR = 0xCA;
0000ba  20ca              MOVS     r0,#0xca
0000bc  490a              LDR      r1,|L35.232|
0000be  311c              ADDS     r1,r1,#0x1c
0000c0  6008              STR      r0,[r1,#0]
;;;1175     RTC->WPR = 0x53;
0000c2  2053              MOVS     r0,#0x53
0000c4  6008              STR      r0,[r1,#0]
;;;1176   
;;;1177     /* Configure the Alarm register */
;;;1178     if (RTC_Alarm == RTC_Alarm_A)
0000c6  f5b77f80          CMP      r7,#0x100
0000ca  d103              BNE      |L35.212|
;;;1179     {
;;;1180       RTC->ALRMAR = (uint32_t)tmpreg;
0000cc  4806              LDR      r0,|L35.232|
0000ce  3014              ADDS     r0,r0,#0x14
0000d0  6006              STR      r6,[r0,#0]
0000d2  e002              B        |L35.218|
                  |L35.212|
;;;1181     }
;;;1182     else
;;;1183     {
;;;1184       RTC->ALRMBR = (uint32_t)tmpreg;
0000d4  4804              LDR      r0,|L35.232|
0000d6  3018              ADDS     r0,r0,#0x18
0000d8  6006              STR      r6,[r0,#0]
                  |L35.218|
;;;1185     }
;;;1186   
;;;1187     /* Enable the write protection for RTC registers */
;;;1188     RTC->WPR = 0xFF;   
0000da  20ff              MOVS     r0,#0xff
0000dc  4902              LDR      r1,|L35.232|
0000de  311c              ADDS     r1,r1,#0x1c
0000e0  6008              STR      r0,[r1,#0]
;;;1189   }
0000e2  e8bd81f0          POP      {r4-r8,pc}
;;;1190   
                          ENDP

0000e6  0000              DCW      0x0000
                  |L35.232|
                          DCD      0x40002808

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

                  RTC_SetDate PROC
;;;925      */
;;;926    ErrorStatus RTC_SetDate(uint32_t RTC_Format, RTC_DateTypeDef* RTC_DateStruct)
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;927    {
000004  4605              MOV      r5,r0
000006  460c              MOV      r4,r1
;;;928      uint32_t tmpreg = 0;
000008  2600              MOVS     r6,#0
;;;929      ErrorStatus status = ERROR;
00000a  2700              MOVS     r7,#0
;;;930      
;;;931      /* Check the parameters */
;;;932      assert_param(IS_RTC_FORMAT(RTC_Format));
;;;933    
;;;934      if ((RTC_Format == RTC_Format_BIN) && ((RTC_DateStruct->RTC_Month & 0x10) == 0x10))
00000c  b94d              CBNZ     r5,|L36.34|
00000e  7860              LDRB     r0,[r4,#1]
000010  f0000010          AND      r0,r0,#0x10
000014  2810              CMP      r0,#0x10
000016  d104              BNE      |L36.34|
;;;935      {
;;;936        RTC_DateStruct->RTC_Month = (RTC_DateStruct->RTC_Month & (uint32_t)~(0x10)) + 0x0A;
000018  7860              LDRB     r0,[r4,#1]
00001a  f0200010          BIC      r0,r0,#0x10
00001e  300a              ADDS     r0,r0,#0xa
000020  7060              STRB     r0,[r4,#1]
                  |L36.34|
;;;937      }  
;;;938      if (RTC_Format == RTC_Format_BIN)
000022  b905              CBNZ     r5,|L36.38|
;;;939      {
;;;940        assert_param(IS_RTC_YEAR(RTC_DateStruct->RTC_Year));
;;;941        assert_param(IS_RTC_MONTH(RTC_DateStruct->RTC_Month));
;;;942        assert_param(IS_RTC_DATE(RTC_DateStruct->RTC_Date));
000024  e008              B        |L36.56|
                  |L36.38|
;;;943      }
;;;944      else
;;;945      {
;;;946        assert_param(IS_RTC_YEAR(RTC_Bcd2ToByte(RTC_DateStruct->RTC_Year)));
;;;947        tmpreg = RTC_Bcd2ToByte(RTC_DateStruct->RTC_Month);
000026  7860              LDRB     r0,[r4,#1]
000028  f7fffffe          BL       RTC_Bcd2ToByte
00002c  4606              MOV      r6,r0
;;;948        assert_param(IS_RTC_MONTH(tmpreg));
;;;949        tmpreg = RTC_Bcd2ToByte(RTC_DateStruct->RTC_Date);
00002e  78a0              LDRB     r0,[r4,#2]
000030  f7fffffe          BL       RTC_Bcd2ToByte
000034  4606              MOV      r6,r0
;;;950        assert_param(IS_RTC_DATE(tmpreg));
000036  bf00              NOP      
                  |L36.56|
;;;951      }
;;;952      assert_param(IS_RTC_WEEKDAY(RTC_DateStruct->RTC_WeekDay));
;;;953    
;;;954      /* Check the input parameters format */
;;;955      if (RTC_Format != RTC_Format_BIN)
000038  b155              CBZ      r5,|L36.80|
;;;956      {
;;;957        tmpreg = ((((uint32_t)RTC_DateStruct->RTC_Year) << 16) | \
00003a  78e0              LDRB     r0,[r4,#3]
00003c  0400              LSLS     r0,r0,#16
00003e  7861              LDRB     r1,[r4,#1]
000040  ea402001          ORR      r0,r0,r1,LSL #8
000044  78a1              LDRB     r1,[r4,#2]
000046  4308              ORRS     r0,r0,r1
000048  7821              LDRB     r1,[r4,#0]
00004a  ea403641          ORR      r6,r0,r1,LSL #13
00004e  e011              B        |L36.116|
                  |L36.80|
;;;958                  (((uint32_t)RTC_DateStruct->RTC_Month) << 8) | \
;;;959                  ((uint32_t)RTC_DateStruct->RTC_Date) | \
;;;960                  (((uint32_t)RTC_DateStruct->RTC_WeekDay) << 13)); 
;;;961      }  
;;;962      else
;;;963      {
;;;964        tmpreg = (((uint32_t)RTC_ByteToBcd2(RTC_DateStruct->RTC_Year) << 16) | \
000050  78e0              LDRB     r0,[r4,#3]
000052  f7fffffe          BL       RTC_ByteToBcd2
000056  ea4f4800          LSL      r8,r0,#16
00005a  7860              LDRB     r0,[r4,#1]
00005c  f7fffffe          BL       RTC_ByteToBcd2
000060  ea482800          ORR      r8,r8,r0,LSL #8
000064  78a0              LDRB     r0,[r4,#2]
000066  f7fffffe          BL       RTC_ByteToBcd2
00006a  ea480800          ORR      r8,r8,r0
00006e  7820              LDRB     r0,[r4,#0]
000070  ea483640          ORR      r6,r8,r0,LSL #13
                  |L36.116|
;;;965                  ((uint32_t)RTC_ByteToBcd2(RTC_DateStruct->RTC_Month) << 8) | \
;;;966                  ((uint32_t)RTC_ByteToBcd2(RTC_DateStruct->RTC_Date)) | \
;;;967                  ((uint32_t)RTC_DateStruct->RTC_WeekDay << 13));
;;;968      }
;;;969    
;;;970      /* Disable the write protection for RTC registers */
;;;971      RTC->WPR = 0xCA;
000074  20ca              MOVS     r0,#0xca
000076  490e              LDR      r1,|L36.176|
000078  6008              STR      r0,[r1,#0]
;;;972      RTC->WPR = 0x53;
00007a  2053              MOVS     r0,#0x53
00007c  6008              STR      r0,[r1,#0]
;;;973    
;;;974      /* Set Initialization mode */
;;;975      if (RTC_EnterInitMode() == ERROR)
00007e  f7fffffe          BL       RTC_EnterInitMode
000082  b908              CBNZ     r0,|L36.136|
;;;976      {
;;;977        status = ERROR;
000084  2700              MOVS     r7,#0
000086  e00c              B        |L36.162|
                  |L36.136|
;;;978      } 
;;;979      else
;;;980      {
;;;981        /* Set the RTC_DR register */
;;;982        RTC->DR = (uint32_t)(tmpreg & RTC_DR_RESERVED_MASK);
000088  480a              LDR      r0,|L36.180|
00008a  4030              ANDS     r0,r0,r6
00008c  4908              LDR      r1,|L36.176|
00008e  3920              SUBS     r1,r1,#0x20
000090  6008              STR      r0,[r1,#0]
;;;983    
;;;984        /* Exit Initialization mode */
;;;985        RTC_ExitInitMode(); 
000092  f7fffffe          BL       RTC_ExitInitMode
;;;986    
;;;987        if(RTC_WaitForSynchro() == ERROR)
000096  f7fffffe          BL       RTC_WaitForSynchro
00009a  b908              CBNZ     r0,|L36.160|
;;;988        {
;;;989          status = ERROR;
00009c  2700              MOVS     r7,#0
00009e  e000              B        |L36.162|
                  |L36.160|
;;;990        }
;;;991        else
;;;992        {
;;;993          status = SUCCESS;
0000a0  2701              MOVS     r7,#1
                  |L36.162|
;;;994        }
;;;995      }
;;;996      /* Enable the write protection for RTC registers */
;;;997      RTC->WPR = 0xFF;   
0000a2  20ff              MOVS     r0,#0xff
0000a4  4902              LDR      r1,|L36.176|
0000a6  6008              STR      r0,[r1,#0]
;;;998      
;;;999      return status;
0000a8  4638              MOV      r0,r7
;;;1000   }
0000aa  e8bd81f0          POP      {r4-r8,pc}
;;;1001   
                          ENDP

0000ae  0000              DCW      0x0000
                  |L36.176|
                          DCD      0x40002824
                  |L36.180|
                          DCD      0x00ffff3f

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

                  RTC_SetTime PROC
;;;752      */
;;;753    ErrorStatus RTC_SetTime(uint32_t RTC_Format, RTC_TimeTypeDef* RTC_TimeStruct)
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;754    {
000004  4605              MOV      r5,r0
000006  460c              MOV      r4,r1
;;;755      uint32_t tmpreg = 0;
000008  2600              MOVS     r6,#0
;;;756      ErrorStatus status = ERROR;
00000a  2700              MOVS     r7,#0
;;;757        
;;;758      /* Check the parameters */
;;;759      assert_param(IS_RTC_FORMAT(RTC_Format));
;;;760      
;;;761      if (RTC_Format == RTC_Format_BIN)
00000c  b94d              CBNZ     r5,|L37.34|
;;;762      {
;;;763        if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET)
00000e  482a              LDR      r0,|L37.184|
000010  6800              LDR      r0,[r0,#0]
000012  f0100f40          TST      r0,#0x40
000016  d000              BEQ      |L37.26|
;;;764        {
;;;765          assert_param(IS_RTC_HOUR12(RTC_TimeStruct->RTC_Hours));
;;;766          assert_param(IS_RTC_H12(RTC_TimeStruct->RTC_H12));
000018  e002              B        |L37.32|
                  |L37.26|
;;;767        } 
;;;768        else
;;;769        {
;;;770          RTC_TimeStruct->RTC_H12 = 0x00;
00001a  2000              MOVS     r0,#0
00001c  70e0              STRB     r0,[r4,#3]
;;;771          assert_param(IS_RTC_HOUR24(RTC_TimeStruct->RTC_Hours));
00001e  bf00              NOP      
                  |L37.32|
;;;772        }
;;;773        assert_param(IS_RTC_MINUTES(RTC_TimeStruct->RTC_Minutes));
;;;774        assert_param(IS_RTC_SECONDS(RTC_TimeStruct->RTC_Seconds));
000020  e00d              B        |L37.62|
                  |L37.34|
;;;775      }
;;;776      else
;;;777      {
;;;778        if ((RTC->CR & RTC_CR_FMT) != (uint32_t)RESET)
000022  4825              LDR      r0,|L37.184|
000024  6800              LDR      r0,[r0,#0]
000026  f0100f40          TST      r0,#0x40
00002a  d004              BEQ      |L37.54|
;;;779        {
;;;780          tmpreg = RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Hours);
00002c  7820              LDRB     r0,[r4,#0]
00002e  f7fffffe          BL       RTC_Bcd2ToByte
000032  4606              MOV      r6,r0
;;;781          assert_param(IS_RTC_HOUR12(tmpreg));
;;;782          assert_param(IS_RTC_H12(RTC_TimeStruct->RTC_H12)); 
000034  e002              B        |L37.60|
                  |L37.54|
;;;783        } 
;;;784        else
;;;785        {
;;;786          RTC_TimeStruct->RTC_H12 = 0x00;
000036  2000              MOVS     r0,#0
000038  70e0              STRB     r0,[r4,#3]
;;;787          assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Hours)));
00003a  bf00              NOP      
                  |L37.60|
;;;788        }
;;;789        assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Minutes)));
;;;790        assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(RTC_TimeStruct->RTC_Seconds)));
00003c  bf00              NOP      
                  |L37.62|
;;;791      }
;;;792      
;;;793      /* Check the input parameters format */
;;;794      if (RTC_Format != RTC_Format_BIN)
00003e  b155              CBZ      r5,|L37.86|
;;;795      {
;;;796        tmpreg = (((uint32_t)(RTC_TimeStruct->RTC_Hours) << 16) | \
000040  7820              LDRB     r0,[r4,#0]
000042  0400              LSLS     r0,r0,#16
000044  7861              LDRB     r1,[r4,#1]
000046  ea402001          ORR      r0,r0,r1,LSL #8
00004a  78a1              LDRB     r1,[r4,#2]
00004c  4308              ORRS     r0,r0,r1
00004e  78e1              LDRB     r1,[r4,#3]
000050  ea404601          ORR      r6,r0,r1,LSL #16
000054  e011              B        |L37.122|
                  |L37.86|
;;;797                 ((uint32_t)(RTC_TimeStruct->RTC_Minutes) << 8) | \
;;;798                 ((uint32_t)RTC_TimeStruct->RTC_Seconds) | \
;;;799                 ((uint32_t)(RTC_TimeStruct->RTC_H12) << 16)); 
;;;800      }  
;;;801      else
;;;802      {
;;;803        tmpreg = (uint32_t)(((uint32_t)RTC_ByteToBcd2(RTC_TimeStruct->RTC_Hours) << 16) | \
000056  7820              LDRB     r0,[r4,#0]
000058  f7fffffe          BL       RTC_ByteToBcd2
00005c  ea4f4800          LSL      r8,r0,#16
000060  7860              LDRB     r0,[r4,#1]
000062  f7fffffe          BL       RTC_ByteToBcd2
000066  ea482800          ORR      r8,r8,r0,LSL #8
00006a  78a0              LDRB     r0,[r4,#2]
00006c  f7fffffe          BL       RTC_ByteToBcd2
000070  ea480800          ORR      r8,r8,r0
000074  78e0              LDRB     r0,[r4,#3]
000076  ea484600          ORR      r6,r8,r0,LSL #16
                  |L37.122|
;;;804                       ((uint32_t)RTC_ByteToBcd2(RTC_TimeStruct->RTC_Minutes) << 8) | \
;;;805                       ((uint32_t)RTC_ByteToBcd2(RTC_TimeStruct->RTC_Seconds)) | \
;;;806                       (((uint32_t)RTC_TimeStruct->RTC_H12) << 16));
;;;807      }  
;;;808    
;;;809      /* Disable the write protection for RTC registers */
;;;810      RTC->WPR = 0xCA;
00007a  20ca              MOVS     r0,#0xca
00007c  490e              LDR      r1,|L37.184|
00007e  311c              ADDS     r1,r1,#0x1c
000080  6008              STR      r0,[r1,#0]
;;;811      RTC->WPR = 0x53;
000082  2053              MOVS     r0,#0x53
000084  6008              STR      r0,[r1,#0]
;;;812    
;;;813      /* Set Initialization mode */
;;;814      if (RTC_EnterInitMode() == ERROR)
000086  f7fffffe          BL       RTC_EnterInitMode
00008a  b908              CBNZ     r0,|L37.144|
;;;815      {
;;;816        status = ERROR;
00008c  2700              MOVS     r7,#0
00008e  e00c              B        |L37.170|
                  |L37.144|
;;;817      } 
;;;818      else
;;;819      {
;;;820        /* Set the RTC_TR register */
;;;821        RTC->TR = (uint32_t)(tmpreg & RTC_TR_RESERVED_MASK);
000090  480a              LDR      r0,|L37.188|
000092  4030              ANDS     r0,r0,r6
000094  4908              LDR      r1,|L37.184|
000096  3908              SUBS     r1,r1,#8
000098  6008              STR      r0,[r1,#0]
;;;822    
;;;823        /* Exit Initialization mode */
;;;824        RTC_ExitInitMode(); 
00009a  f7fffffe          BL       RTC_ExitInitMode
;;;825    
;;;826        if(RTC_WaitForSynchro() == ERROR)
00009e  f7fffffe          BL       RTC_WaitForSynchro
0000a2  b908              CBNZ     r0,|L37.168|
;;;827        {
;;;828          status = ERROR;
0000a4  2700              MOVS     r7,#0
0000a6  e000              B        |L37.170|
                  |L37.168|
;;;829        }
;;;830        else
;;;831        {
;;;832          status = SUCCESS;
0000a8  2701              MOVS     r7,#1
                  |L37.170|
;;;833        }
;;;834      
;;;835      }
;;;836      /* Enable the write protection for RTC registers */
;;;837      RTC->WPR = 0xFF; 
0000aa  20ff              MOVS     r0,#0xff
0000ac  4902              LDR      r1,|L37.184|
0000ae  311c              ADDS     r1,r1,#0x1c
0000b0  6008              STR      r0,[r1,#0]
;;;838        
;;;839      return status;
0000b2  4638              MOV      r0,r7
;;;840    }
0000b4  e8bd81f0          POP      {r4-r8,pc}
;;;841    
                          ENDP

                  |L37.184|
                          DCD      0x40002808
                  |L37.188|
                          DCD      0x007f7f7f

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

                  RTC_SetWakeUpCounter PROC
;;;1493     */
;;;1494   void RTC_SetWakeUpCounter(uint32_t RTC_WakeUpCounter)
000000  21ca              MOVS     r1,#0xca
;;;1495   {
;;;1496     /* Check the parameters */
;;;1497     assert_param(IS_RTC_WAKEUP_COUNTER(RTC_WakeUpCounter));
;;;1498     
;;;1499     /* Disable the write protection for RTC registers */
;;;1500     RTC->WPR = 0xCA;
000002  4a05              LDR      r2,|L38.24|
000004  6011              STR      r1,[r2,#0]
;;;1501     RTC->WPR = 0x53;
000006  2153              MOVS     r1,#0x53
000008  6011              STR      r1,[r2,#0]
;;;1502     
;;;1503     /* Configure the Wakeup Timer counter */
;;;1504     RTC->WUTR = (uint32_t)RTC_WakeUpCounter;
00000a  4903              LDR      r1,|L38.24|
00000c  3910              SUBS     r1,r1,#0x10
00000e  6008              STR      r0,[r1,#0]
;;;1505     
;;;1506     /* Enable the write protection for RTC registers */
;;;1507     RTC->WPR = 0xFF; 
000010  21ff              MOVS     r1,#0xff
000012  6011              STR      r1,[r2,#0]
;;;1508   }
000014  4770              BX       lr
;;;1509   
                          ENDP

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

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

                  RTC_SmoothCalibConfig PROC
;;;1878   */
;;;1879   ErrorStatus RTC_SmoothCalibConfig(uint32_t RTC_SmoothCalibPeriod,
000000  b530              PUSH     {r4,r5,lr}
;;;1880                                     uint32_t RTC_SmoothCalibPlusPulses,
;;;1881                                     uint32_t RTC_SmouthCalibMinusPulsesValue)
;;;1882   {
000002  4603              MOV      r3,r0
;;;1883     ErrorStatus status = ERROR;
000004  2000              MOVS     r0,#0
;;;1884     uint32_t recalpfcount = 0;
000006  4684              MOV      r12,r0
;;;1885   
;;;1886     /* Check the parameters */
;;;1887     assert_param(IS_RTC_SMOOTH_CALIB_PERIOD(RTC_SmoothCalibPeriod));
;;;1888     assert_param(IS_RTC_SMOOTH_CALIB_PLUS(RTC_SmoothCalibPlusPulses));
;;;1889     assert_param(IS_RTC_SMOOTH_CALIB_MINUS(RTC_SmouthCalibMinusPulsesValue));
;;;1890   
;;;1891     /* Disable the write protection for RTC registers */
;;;1892     RTC->WPR = 0xCA;
000008  24ca              MOVS     r4,#0xca
00000a  4d14              LDR      r5,|L39.92|
00000c  602c              STR      r4,[r5,#0]
;;;1893     RTC->WPR = 0x53;
00000e  2453              MOVS     r4,#0x53
000010  602c              STR      r4,[r5,#0]
;;;1894     
;;;1895     /* check if a calibration is pending*/
;;;1896     if ((RTC->ISR & RTC_ISR_RECALPF) != RESET)
000012  4c12              LDR      r4,|L39.92|
000014  3c18              SUBS     r4,r4,#0x18
000016  6824              LDR      r4,[r4,#0]
000018  f4143f80          TST      r4,#0x10000
00001c  d00b              BEQ      |L39.54|
;;;1897     {
;;;1898       /* wait until the Calibration is completed*/
;;;1899       while (((RTC->ISR & RTC_ISR_RECALPF) != RESET) && (recalpfcount != RECALPF_TIMEOUT))
00001e  e001              B        |L39.36|
                  |L39.32|
;;;1900       {
;;;1901         recalpfcount++;
000020  f10c0c01          ADD      r12,r12,#1
                  |L39.36|
000024  4c0d              LDR      r4,|L39.92|
000026  3c18              SUBS     r4,r4,#0x18           ;1899
000028  6824              LDR      r4,[r4,#0]            ;1899
00002a  f4143f80          TST      r4,#0x10000           ;1899
00002e  d002              BEQ      |L39.54|
000030  f5bc3f00          CMP      r12,#0x20000          ;1899
000034  d1f4              BNE      |L39.32|
                  |L39.54|
;;;1902       }
;;;1903     }
;;;1904   
;;;1905     /* check if the calibration pending is completed or if there is no calibration operation at all*/
;;;1906     if ((RTC->ISR & RTC_ISR_RECALPF) == RESET)
000036  4c09              LDR      r4,|L39.92|
000038  3c18              SUBS     r4,r4,#0x18
00003a  6824              LDR      r4,[r4,#0]
00003c  f4143f80          TST      r4,#0x10000
000040  d107              BNE      |L39.82|
;;;1907     {
;;;1908       /* Configure the Smooth calibration settings */
;;;1909       RTC->CALR = (uint32_t)((uint32_t)RTC_SmoothCalibPeriod | (uint32_t)RTC_SmoothCalibPlusPulses | (uint32_t)RTC_SmouthCalibMinusPulsesValue);
000042  ea430401          ORR      r4,r3,r1
000046  4314              ORRS     r4,r4,r2
000048  4d04              LDR      r5,|L39.92|
00004a  3518              ADDS     r5,r5,#0x18
00004c  602c              STR      r4,[r5,#0]
;;;1910   
;;;1911       status = SUCCESS;
00004e  2001              MOVS     r0,#1
000050  e000              B        |L39.84|
                  |L39.82|
;;;1912     }
;;;1913     else
;;;1914     {
;;;1915       status = ERROR;
000052  2000              MOVS     r0,#0
                  |L39.84|
;;;1916     }
;;;1917   
;;;1918     /* Enable the write protection for RTC registers */
;;;1919     RTC->WPR = 0xFF;
000054  24ff              MOVS     r4,#0xff
000056  4d01              LDR      r5,|L39.92|
000058  602c              STR      r4,[r5,#0]
;;;1920     
;;;1921     return (ErrorStatus)(status);
;;;1922   }
00005a  bd30              POP      {r4,r5,pc}
;;;1923   
                          ENDP

                  |L39.92|
                          DCD      0x40002824

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

                  RTC_StructInit PROC
;;;490      */
;;;491    void RTC_StructInit(RTC_InitTypeDef* RTC_InitStruct)
000000  2100              MOVS     r1,#0
;;;492    {
;;;493      /* Initialize the RTC_HourFormat member */
;;;494      RTC_InitStruct->RTC_HourFormat = RTC_HourFormat_24;
000002  6001              STR      r1,[r0,#0]
;;;495        
;;;496      /* Initialize the RTC_AsynchPrediv member */
;;;497      RTC_InitStruct->RTC_AsynchPrediv = (uint32_t)0x7F;
000004  217f              MOVS     r1,#0x7f
000006  6041              STR      r1,[r0,#4]
;;;498    
;;;499      /* Initialize the RTC_SynchPrediv member */
;;;500      RTC_InitStruct->RTC_SynchPrediv = (uint32_t)0xFF; 
000008  21ff              MOVS     r1,#0xff
00000a  6081              STR      r1,[r0,#8]
;;;501    }
00000c  4770              BX       lr
;;;502    
                          ENDP


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

                  RTC_SynchroShiftConfig PROC
;;;2410   */
;;;2411   ErrorStatus RTC_SynchroShiftConfig(uint32_t RTC_ShiftAdd1S, uint32_t RTC_ShiftSubFS)
000000  b5f0              PUSH     {r4-r7,lr}
;;;2412   {
000002  4604              MOV      r4,r0
000004  460d              MOV      r5,r1
;;;2413     ErrorStatus status = ERROR;
000006  2700              MOVS     r7,#0
;;;2414     uint32_t shpfcount = 0;
000008  2600              MOVS     r6,#0
;;;2415   
;;;2416     /* Check the parameters */
;;;2417     assert_param(IS_RTC_SHIFT_ADD1S(RTC_ShiftAdd1S));
;;;2418     assert_param(IS_RTC_SHIFT_SUBFS(RTC_ShiftSubFS));
;;;2419   
;;;2420     /* Disable the write protection for RTC registers */
;;;2421     RTC->WPR = 0xCA;
00000a  20ca              MOVS     r0,#0xca
00000c  491a              LDR      r1,|L41.120|
00000e  6008              STR      r0,[r1,#0]
;;;2422     RTC->WPR = 0x53;
000010  2053              MOVS     r0,#0x53
000012  6008              STR      r0,[r1,#0]
;;;2423     
;;;2424     /* Check if a Shift is pending*/
;;;2425     if ((RTC->ISR & RTC_ISR_SHPF) != RESET)
000014  4818              LDR      r0,|L41.120|
000016  3818              SUBS     r0,r0,#0x18
000018  6800              LDR      r0,[r0,#0]
00001a  f0100f08          TST      r0,#8
00001e  d00a              BEQ      |L41.54|
;;;2426     {
;;;2427       /* Wait until the shift is completed*/
;;;2428       while (((RTC->ISR & RTC_ISR_SHPF) != RESET) && (shpfcount != SHPF_TIMEOUT))
000020  e000              B        |L41.36|
                  |L41.34|
;;;2429       {
;;;2430         shpfcount++;
000022  1c76              ADDS     r6,r6,#1
                  |L41.36|
000024  4814              LDR      r0,|L41.120|
000026  3818              SUBS     r0,r0,#0x18           ;2428
000028  6800              LDR      r0,[r0,#0]            ;2428
00002a  f0100f08          TST      r0,#8                 ;2428
00002e  d002              BEQ      |L41.54|
000030  f5b65f80          CMP      r6,#0x1000            ;2428
000034  d1f5              BNE      |L41.34|
                  |L41.54|
;;;2431       }
;;;2432     }
;;;2433   
;;;2434     /* Check if the Shift pending is completed or if there is no Shift operation at all*/
;;;2435     if ((RTC->ISR & RTC_ISR_SHPF) == RESET)
000036  4810              LDR      r0,|L41.120|
000038  3818              SUBS     r0,r0,#0x18
00003a  6800              LDR      r0,[r0,#0]
00003c  f0100f08          TST      r0,#8
000040  d113              BNE      |L41.106|
;;;2436     {
;;;2437       /* check if the reference clock detection is disabled */
;;;2438       if((RTC->CR & RTC_CR_REFCKON) == RESET)
000042  480d              LDR      r0,|L41.120|
000044  381c              SUBS     r0,r0,#0x1c
000046  6800              LDR      r0,[r0,#0]
000048  f0100f10          TST      r0,#0x10
00004c  d10b              BNE      |L41.102|
;;;2439       {
;;;2440         /* Configure the Shift settings */
;;;2441         RTC->SHIFTR = (uint32_t)(uint32_t)(RTC_ShiftSubFS) | (uint32_t)(RTC_ShiftAdd1S);
00004e  ea450004          ORR      r0,r5,r4
000052  4909              LDR      r1,|L41.120|
000054  3108              ADDS     r1,r1,#8
000056  6008              STR      r0,[r1,#0]
;;;2442       
;;;2443         if(RTC_WaitForSynchro() == ERROR)
000058  f7fffffe          BL       RTC_WaitForSynchro
00005c  b908              CBNZ     r0,|L41.98|
;;;2444         {
;;;2445           status = ERROR;
00005e  2700              MOVS     r7,#0
000060  e004              B        |L41.108|
                  |L41.98|
;;;2446         }
;;;2447         else
;;;2448         {
;;;2449           status = SUCCESS;
000062  2701              MOVS     r7,#1
000064  e002              B        |L41.108|
                  |L41.102|
;;;2450         }
;;;2451       }
;;;2452       else
;;;2453       {
;;;2454         status = ERROR;
000066  2700              MOVS     r7,#0
000068  e000              B        |L41.108|
                  |L41.106|
;;;2455       }
;;;2456     }
;;;2457     else
;;;2458     {
;;;2459       status = ERROR;
00006a  2700              MOVS     r7,#0
                  |L41.108|
;;;2460     }
;;;2461   
;;;2462     /* Enable the write protection for RTC registers */
;;;2463     RTC->WPR = 0xFF;
00006c  20ff              MOVS     r0,#0xff
00006e  4902              LDR      r1,|L41.120|
000070  6008              STR      r0,[r1,#0]
;;;2464     
;;;2465     return (ErrorStatus)(status);
000072  4638              MOV      r0,r7
;;;2466   }
000074  bdf0              POP      {r4-r7,pc}
;;;2467   
                          ENDP

000076  0000              DCW      0x0000
                  |L41.120|
                          DCD      0x40002824

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

                  RTC_TamperCmd PROC
;;;2103     */
;;;2104   void RTC_TamperCmd(uint32_t RTC_Tamper, FunctionalState NewState)
000000  b129              CBZ      r1,|L42.14|
;;;2105   {
;;;2106     /* Check the parameters */
;;;2107     assert_param(IS_RTC_TAMPER(RTC_Tamper));  
;;;2108     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;2109     
;;;2110     if (NewState != DISABLE)
;;;2111     {
;;;2112       /* Enable the selected Tamper pin */
;;;2113       RTC->TAFCR |= (uint32_t)RTC_Tamper;
000002  4a06              LDR      r2,|L42.28|
000004  6812              LDR      r2,[r2,#0]
000006  4302              ORRS     r2,r2,r0
000008  4b04              LDR      r3,|L42.28|
00000a  601a              STR      r2,[r3,#0]
00000c  e004              B        |L42.24|
                  |L42.14|
;;;2114     }
;;;2115     else
;;;2116     {
;;;2117       /* Disable the selected Tamper pin */
;;;2118       RTC->TAFCR &= (uint32_t)~RTC_Tamper;    
00000e  4a03              LDR      r2,|L42.28|
000010  6812              LDR      r2,[r2,#0]
000012  4382              BICS     r2,r2,r0
000014  4b01              LDR      r3,|L42.28|
000016  601a              STR      r2,[r3,#0]
                  |L42.24|
;;;2119     }  
;;;2120   }
000018  4770              BX       lr
;;;2121   
                          ENDP

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

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

                  RTC_TamperFilterConfig PROC
;;;2134     */
;;;2135   void RTC_TamperFilterConfig(uint32_t RTC_TamperFilter)
000000  4905              LDR      r1,|L43.24|
;;;2136   {
;;;2137     /* Check the parameters */
;;;2138     assert_param(IS_RTC_TAMPER_FILTER(RTC_TamperFilter));
;;;2139      
;;;2140     /* Clear TAMPFLT[1:0] bits in the RTC_TAFCR register */
;;;2141     RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TAMPFLT);
000002  6809              LDR      r1,[r1,#0]
000004  f42151c0          BIC      r1,r1,#0x1800
000008  4a03              LDR      r2,|L43.24|
00000a  6011              STR      r1,[r2,#0]
;;;2142   
;;;2143     /* Configure the RTC_TAFCR register */
;;;2144     RTC->TAFCR |= (uint32_t)RTC_TamperFilter;
00000c  4611              MOV      r1,r2
00000e  6809              LDR      r1,[r1,#0]
000010  4301              ORRS     r1,r1,r0
000012  6011              STR      r1,[r2,#0]
;;;2145   }
000014  4770              BX       lr
;;;2146   
                          ENDP

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

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

                  RTC_TamperPinSelection PROC
;;;2336     */
;;;2337   void RTC_TamperPinSelection(uint32_t RTC_TamperPin)
000000  4905              LDR      r1,|L44.24|
;;;2338   {
;;;2339     /* Check the parameters */
;;;2340     assert_param(IS_RTC_TAMPER_PIN(RTC_TamperPin));
;;;2341     
;;;2342     RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TAMPINSEL);
000002  6809              LDR      r1,[r1,#0]
000004  f4213180          BIC      r1,r1,#0x10000
000008  4a03              LDR      r2,|L44.24|
00000a  6011              STR      r1,[r2,#0]
;;;2343     RTC->TAFCR |= (uint32_t)(RTC_TamperPin);  
00000c  4611              MOV      r1,r2
00000e  6809              LDR      r1,[r1,#0]
000010  4301              ORRS     r1,r1,r0
000012  6011              STR      r1,[r2,#0]
;;;2344   }
000014  4770              BX       lr
;;;2345   
                          ENDP

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

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

                  RTC_TamperPinsPrechargeDuration PROC
;;;2191     */
;;;2192   void RTC_TamperPinsPrechargeDuration(uint32_t RTC_TamperPrechargeDuration)
000000  4905              LDR      r1,|L45.24|
;;;2193   {
;;;2194     /* Check the parameters */
;;;2195     assert_param(IS_RTC_TAMPER_PRECHARGE_DURATION(RTC_TamperPrechargeDuration));
;;;2196      
;;;2197     /* Clear TAMPPRCH[1:0] bits in the RTC_TAFCR register */
;;;2198     RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TAMPPRCH);
000002  6809              LDR      r1,[r1,#0]
000004  f42141c0          BIC      r1,r1,#0x6000
000008  4a03              LDR      r2,|L45.24|
00000a  6011              STR      r1,[r2,#0]
;;;2199   
;;;2200     /* Configure the RTC_TAFCR register */
;;;2201     RTC->TAFCR |= (uint32_t)RTC_TamperPrechargeDuration;
00000c  4611              MOV      r1,r2
00000e  6809              LDR      r1,[r1,#0]
000010  4301              ORRS     r1,r1,r0
000012  6011              STR      r1,[r2,#0]
;;;2202   }
000014  4770              BX       lr
;;;2203   
                          ENDP

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

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

                  RTC_TamperPullUpCmd PROC
;;;2234     */
;;;2235   void RTC_TamperPullUpCmd(FunctionalState NewState)
000000  b130              CBZ      r0,|L46.16|
;;;2236   {
;;;2237     /* Check the parameters */
;;;2238     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;2239     
;;;2240    if (NewState != DISABLE)
;;;2241     {
;;;2242       /* Enable precharge of the selected Tamper pin */
;;;2243       RTC->TAFCR &= (uint32_t)~RTC_TAFCR_TAMPPUDIS; 
000002  4907              LDR      r1,|L46.32|
000004  6809              LDR      r1,[r1,#0]
000006  f4214100          BIC      r1,r1,#0x8000
00000a  4a05              LDR      r2,|L46.32|
00000c  6011              STR      r1,[r2,#0]
00000e  e005              B        |L46.28|
                  |L46.16|
;;;2244     }
;;;2245     else
;;;2246     {
;;;2247       /* Disable precharge of the selected Tamper pin */
;;;2248       RTC->TAFCR |= (uint32_t)RTC_TAFCR_TAMPPUDIS;    
000010  4903              LDR      r1,|L46.32|
000012  6809              LDR      r1,[r1,#0]
000014  f4414100          ORR      r1,r1,#0x8000
000018  4a01              LDR      r2,|L46.32|
00001a  6011              STR      r1,[r2,#0]
                  |L46.28|
;;;2249     } 
;;;2250   }
00001c  4770              BX       lr
;;;2251   
                          ENDP

00001e  0000              DCW      0x0000
                  |L46.32|
                          DCD      0x40002840

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

                  RTC_TamperSamplingFreqConfig PROC
;;;2168     */
;;;2169   void RTC_TamperSamplingFreqConfig(uint32_t RTC_TamperSamplingFreq)
000000  4905              LDR      r1,|L47.24|
;;;2170   {
;;;2171     /* Check the parameters */
;;;2172     assert_param(IS_RTC_TAMPER_SAMPLING_FREQ(RTC_TamperSamplingFreq));
;;;2173    
;;;2174     /* Clear TAMPFREQ[2:0] bits in the RTC_TAFCR register */
;;;2175     RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TAMPFREQ);
000002  6809              LDR      r1,[r1,#0]
000004  f42161e0          BIC      r1,r1,#0x700
000008  4a03              LDR      r2,|L47.24|
00000a  6011              STR      r1,[r2,#0]
;;;2176   
;;;2177     /* Configure the RTC_TAFCR register */
;;;2178     RTC->TAFCR |= (uint32_t)RTC_TamperSamplingFreq;
00000c  4611              MOV      r1,r2
00000e  6809              LDR      r1,[r1,#0]
000010  4301              ORRS     r1,r1,r0
000012  6011              STR      r1,[r2,#0]
;;;2179   }
000014  4770              BX       lr
;;;2180   
                          ENDP

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

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

                  RTC_TamperTriggerConfig PROC
;;;2077     */
;;;2078   void RTC_TamperTriggerConfig(uint32_t RTC_Tamper, uint32_t RTC_TamperTrigger)
000000  b931              CBNZ     r1,|L48.16|
;;;2079   {
;;;2080     /* Check the parameters */
;;;2081     assert_param(IS_RTC_TAMPER(RTC_Tamper)); 
;;;2082     assert_param(IS_RTC_TAMPER_TRIGGER(RTC_TamperTrigger));
;;;2083    
;;;2084     if (RTC_TamperTrigger == RTC_TamperTrigger_RisingEdge)
;;;2085     {  
;;;2086       /* Configure the RTC_TAFCR register */
;;;2087       RTC->TAFCR &= (uint32_t)((uint32_t)~(RTC_Tamper << 1));	
000002  4a07              LDR      r2,|L48.32|
000004  6812              LDR      r2,[r2,#0]
000006  ea220240          BIC      r2,r2,r0,LSL #1
00000a  4b05              LDR      r3,|L48.32|
00000c  601a              STR      r2,[r3,#0]
00000e  e005              B        |L48.28|
                  |L48.16|
;;;2088     }
;;;2089     else
;;;2090     { 
;;;2091       /* Configure the RTC_TAFCR register */
;;;2092       RTC->TAFCR |= (uint32_t)(RTC_Tamper << 1);  
000010  4a03              LDR      r2,|L48.32|
000012  6812              LDR      r2,[r2,#0]
000014  ea420240          ORR      r2,r2,r0,LSL #1
000018  4b01              LDR      r3,|L48.32|
00001a  601a              STR      r2,[r3,#0]
                  |L48.28|
;;;2093     }  
;;;2094   }
00001c  4770              BX       lr
;;;2095   
                          ENDP

00001e  0000              DCW      0x0000
                  |L48.32|
                          DCD      0x40002840

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

                  RTC_TimeStampCmd PROC
;;;1954     */
;;;1955   void RTC_TimeStampCmd(uint32_t RTC_TimeStampEdge, FunctionalState NewState)
000000  b510              PUSH     {r4,lr}
;;;1956   {
000002  460a              MOV      r2,r1
;;;1957     uint32_t tmpreg = 0;
000004  2100              MOVS     r1,#0
;;;1958   
;;;1959     /* Check the parameters */
;;;1960     assert_param(IS_RTC_TIMESTAMP_EDGE(RTC_TimeStampEdge));
;;;1961     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1962   
;;;1963     /* Get the RTC_CR register and clear the bits to be configured */
;;;1964     tmpreg = (uint32_t)(RTC->CR & (uint32_t)~(RTC_CR_TSEDGE | RTC_CR_TSE));
000006  4b0b              LDR      r3,|L49.52|
000008  681b              LDR      r3,[r3,#0]
00000a  f6400408          MOV      r4,#0x808
00000e  ea230104          BIC      r1,r3,r4
;;;1965   
;;;1966     /* Get the new configuration */
;;;1967     if (NewState != DISABLE)
000012  b11a              CBZ      r2,|L49.28|
;;;1968     {
;;;1969       tmpreg |= (uint32_t)(RTC_TimeStampEdge | RTC_CR_TSE);
000014  f4406300          ORR      r3,r0,#0x800
000018  4319              ORRS     r1,r1,r3
00001a  e000              B        |L49.30|
                  |L49.28|
;;;1970     }
;;;1971     else
;;;1972     {
;;;1973       tmpreg |= (uint32_t)(RTC_TimeStampEdge);
00001c  4301              ORRS     r1,r1,r0
                  |L49.30|
;;;1974     }
;;;1975   
;;;1976     /* Disable the write protection for RTC registers */
;;;1977     RTC->WPR = 0xCA;
00001e  23ca              MOVS     r3,#0xca
000020  4c04              LDR      r4,|L49.52|
000022  341c              ADDS     r4,r4,#0x1c
000024  6023              STR      r3,[r4,#0]
;;;1978     RTC->WPR = 0x53;
000026  2353              MOVS     r3,#0x53
000028  6023              STR      r3,[r4,#0]
;;;1979   
;;;1980     /* Configure the Time Stamp TSEDGE and Enable bits */
;;;1981     RTC->CR = (uint32_t)tmpreg;
00002a  4b02              LDR      r3,|L49.52|
00002c  6019              STR      r1,[r3,#0]
;;;1982   
;;;1983     /* Enable the write protection for RTC registers */
;;;1984     RTC->WPR = 0xFF; 
00002e  23ff              MOVS     r3,#0xff
000030  6023              STR      r3,[r4,#0]
;;;1985   }
000032  bd10              POP      {r4,pc}
;;;1986   
                          ENDP

                  |L49.52|
                          DCD      0x40002808

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

                  RTC_TimeStampOnTamperDetectionCmd PROC
;;;2211     */
;;;2212   void RTC_TimeStampOnTamperDetectionCmd(FunctionalState NewState)
000000  b130              CBZ      r0,|L50.16|
;;;2213   {
;;;2214     /* Check the parameters */
;;;2215     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;2216      
;;;2217     if (NewState != DISABLE)
;;;2218     {
;;;2219       /* Save timestamp on tamper detection event */
;;;2220       RTC->TAFCR |= (uint32_t)RTC_TAFCR_TAMPTS;
000002  4907              LDR      r1,|L50.32|
000004  6809              LDR      r1,[r1,#0]
000006  f0410180          ORR      r1,r1,#0x80
00000a  4a05              LDR      r2,|L50.32|
00000c  6011              STR      r1,[r2,#0]
00000e  e005              B        |L50.28|
                  |L50.16|
;;;2221     }
;;;2222     else
;;;2223     {
;;;2224       /* Tamper detection does not cause a timestamp to be saved */
;;;2225       RTC->TAFCR &= (uint32_t)~RTC_TAFCR_TAMPTS;    
000010  4903              LDR      r1,|L50.32|
000012  6809              LDR      r1,[r1,#0]
000014  f0210180          BIC      r1,r1,#0x80
000018  4a01              LDR      r2,|L50.32|
00001a  6011              STR      r1,[r2,#0]
                  |L50.28|
;;;2226     }
;;;2227   }
00001c  4770              BX       lr
;;;2228   
                          ENDP

00001e  0000              DCW      0x0000
                  |L50.32|
                          DCD      0x40002840

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

                  RTC_TimeStampPinSelection PROC
;;;2353     */
;;;2354   void RTC_TimeStampPinSelection(uint32_t RTC_TimeStampPin)
000000  4905              LDR      r1,|L51.24|
;;;2355   {
;;;2356     /* Check the parameters */
;;;2357     assert_param(IS_RTC_TIMESTAMP_PIN(RTC_TimeStampPin));
;;;2358     
;;;2359     RTC->TAFCR &= (uint32_t)~(RTC_TAFCR_TSINSEL);
000002  6809              LDR      r1,[r1,#0]
000004  f4213100          BIC      r1,r1,#0x20000
000008  4a03              LDR      r2,|L51.24|
00000a  6011              STR      r1,[r2,#0]
;;;2360     RTC->TAFCR |= (uint32_t)(RTC_TimeStampPin);  
00000c  4611              MOV      r1,r2
00000e  6809              LDR      r1,[r1,#0]
000010  4301              ORRS     r1,r1,r0
000012  6011              STR      r1,[r2,#0]
;;;2361   }
000014  4770              BX       lr
;;;2362   
                          ENDP

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

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

                  RTC_TimeStructInit PROC
;;;848      */
;;;849    void RTC_TimeStructInit(RTC_TimeTypeDef* RTC_TimeStruct)
000000  2100              MOVS     r1,#0
;;;850    {
;;;851      /* Time = 00h:00min:00sec */
;;;852      RTC_TimeStruct->RTC_H12 = RTC_H12_AM;
000002  70c1              STRB     r1,[r0,#3]
;;;853      RTC_TimeStruct->RTC_Hours = 0;
000004  7001              STRB     r1,[r0,#0]
;;;854      RTC_TimeStruct->RTC_Minutes = 0;
000006  7041              STRB     r1,[r0,#1]
;;;855      RTC_TimeStruct->RTC_Seconds = 0; 
000008  7081              STRB     r1,[r0,#2]
;;;856    }
00000a  4770              BX       lr
;;;857    
                          ENDP


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

                  RTC_WaitForSynchro PROC
;;;606      */
;;;607    ErrorStatus RTC_WaitForSynchro(void)
000000  b510              PUSH     {r4,lr}
;;;608    {
;;;609      __IO uint32_t synchrocounter = 0;
000002  2100              MOVS     r1,#0
;;;610      ErrorStatus status = ERROR;
000004  2000              MOVS     r0,#0
;;;611      uint32_t synchrostatus = 0x00;
000006  2200              MOVS     r2,#0
;;;612    
;;;613      /* Disable the write protection for RTC registers */
;;;614      RTC->WPR = 0xCA;
000008  23ca              MOVS     r3,#0xca
00000a  4c12              LDR      r4,|L53.84|
00000c  6023              STR      r3,[r4,#0]
;;;615      RTC->WPR = 0x53;
00000e  2353              MOVS     r3,#0x53
000010  6023              STR      r3,[r4,#0]
;;;616        
;;;617      /* Clear RSF flag */
;;;618      RTC->ISR &= (uint32_t)RTC_RSF_MASK;
000012  4b10              LDR      r3,|L53.84|
000014  3b18              SUBS     r3,r3,#0x18
000016  681b              LDR      r3,[r3,#0]
000018  f02303a0          BIC      r3,r3,#0xa0
00001c  4c0d              LDR      r4,|L53.84|
00001e  3c18              SUBS     r4,r4,#0x18
000020  6023              STR      r3,[r4,#0]
;;;619        
;;;620      /* Wait the registers to be synchronised */
;;;621      do
000022  bf00              NOP      
                  |L53.36|
;;;622      {
;;;623        synchrostatus = RTC->ISR & RTC_ISR_RSF;
000024  4b0b              LDR      r3,|L53.84|
000026  3b18              SUBS     r3,r3,#0x18
000028  681b              LDR      r3,[r3,#0]
00002a  f0030220          AND      r2,r3,#0x20
;;;624        synchrocounter++;  
00002e  1c49              ADDS     r1,r1,#1
;;;625      } while((synchrocounter != SYNCHRO_TIMEOUT) && (synchrostatus == 0x00));
000030  f5b13f00          CMP      r1,#0x20000
000034  d001              BEQ      |L53.58|
000036  2a00              CMP      r2,#0
000038  d0f4              BEQ      |L53.36|
                  |L53.58|
;;;626        
;;;627      if ((RTC->ISR & RTC_ISR_RSF) != RESET)
00003a  4b06              LDR      r3,|L53.84|
00003c  3b18              SUBS     r3,r3,#0x18
00003e  681b              LDR      r3,[r3,#0]
000040  f0130f20          TST      r3,#0x20
000044  d001              BEQ      |L53.74|
;;;628      {
;;;629        status = SUCCESS;
000046  2001              MOVS     r0,#1
000048  e000              B        |L53.76|
                  |L53.74|
;;;630      }
;;;631      else
;;;632      {
;;;633        status = ERROR;
00004a  2000              MOVS     r0,#0
                  |L53.76|
;;;634      }        
;;;635    
;;;636      /* Enable the write protection for RTC registers */
;;;637      RTC->WPR = 0xFF; 
00004c  23ff              MOVS     r3,#0xff
00004e  4c01              LDR      r4,|L53.84|
000050  6023              STR      r3,[r4,#0]
;;;638        
;;;639      return (status); 
;;;640    }
000052  bd10              POP      {r4,pc}
;;;641    
                          ENDP

                  |L53.84|
                          DCD      0x40002824

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

                  RTC_WakeUpClockConfig PROC
;;;1466     */
;;;1467   void RTC_WakeUpClockConfig(uint32_t RTC_WakeUpClock)
000000  21ca              MOVS     r1,#0xca
;;;1468   {
;;;1469     /* Check the parameters */
;;;1470     assert_param(IS_RTC_WAKEUP_CLOCK(RTC_WakeUpClock));
;;;1471   
;;;1472     /* Disable the write protection for RTC registers */
;;;1473     RTC->WPR = 0xCA;
000002  4a0a              LDR      r2,|L54.44|
000004  6011              STR      r1,[r2,#0]
;;;1474     RTC->WPR = 0x53;
000006  2153              MOVS     r1,#0x53
000008  6011              STR      r1,[r2,#0]
;;;1475   
;;;1476     /* Clear the Wakeup Timer clock source bits in CR register */
;;;1477     RTC->CR &= (uint32_t)~RTC_CR_WUCKSEL;
00000a  4908              LDR      r1,|L54.44|
00000c  391c              SUBS     r1,r1,#0x1c
00000e  6809              LDR      r1,[r1,#0]
000010  f0210107          BIC      r1,r1,#7
000014  4a05              LDR      r2,|L54.44|
000016  3a1c              SUBS     r2,r2,#0x1c
000018  6011              STR      r1,[r2,#0]
;;;1478   
;;;1479     /* Configure the clock source */
;;;1480     RTC->CR |= (uint32_t)RTC_WakeUpClock;
00001a  4611              MOV      r1,r2
00001c  6809              LDR      r1,[r1,#0]
00001e  4301              ORRS     r1,r1,r0
000020  6011              STR      r1,[r2,#0]
;;;1481     
;;;1482     /* Enable the write protection for RTC registers */
;;;1483     RTC->WPR = 0xFF; 
000022  21ff              MOVS     r1,#0xff
000024  4a01              LDR      r2,|L54.44|
000026  6011              STR      r1,[r2,#0]
;;;1484   }
000028  4770              BX       lr
;;;1485   
                          ENDP

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

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

                  RTC_WakeUpCmd PROC
;;;1526     */
;;;1527   ErrorStatus RTC_WakeUpCmd(FunctionalState NewState)
000000  b530              PUSH     {r4,r5,lr}
;;;1528   {
000002  4601              MOV      r1,r0
;;;1529     __IO uint32_t wutcounter = 0x00;
000004  2200              MOVS     r2,#0
;;;1530     uint32_t wutwfstatus = 0x00;
000006  2300              MOVS     r3,#0
;;;1531     ErrorStatus status = ERROR;
000008  2000              MOVS     r0,#0
;;;1532     
;;;1533     /* Check the parameters */
;;;1534     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1535   
;;;1536     /* Disable the write protection for RTC registers */
;;;1537     RTC->WPR = 0xCA;
00000a  24ca              MOVS     r4,#0xca
00000c  4d17              LDR      r5,|L55.108|
00000e  602c              STR      r4,[r5,#0]
;;;1538     RTC->WPR = 0x53;
000010  2453              MOVS     r4,#0x53
000012  602c              STR      r4,[r5,#0]
;;;1539   
;;;1540     if (NewState != DISABLE)
000014  b149              CBZ      r1,|L55.42|
;;;1541     {
;;;1542       /* Enable the Wakeup Timer */
;;;1543       RTC->CR |= (uint32_t)RTC_CR_WUTE;
000016  4c15              LDR      r4,|L55.108|
000018  3c1c              SUBS     r4,r4,#0x1c
00001a  6824              LDR      r4,[r4,#0]
00001c  f4446480          ORR      r4,r4,#0x400
000020  4d12              LDR      r5,|L55.108|
000022  3d1c              SUBS     r5,r5,#0x1c
000024  602c              STR      r4,[r5,#0]
;;;1544       status = SUCCESS;    
000026  2001              MOVS     r0,#1
000028  e01c              B        |L55.100|
                  |L55.42|
;;;1545     }
;;;1546     else
;;;1547     {
;;;1548       /* Disable the Wakeup Timer */
;;;1549       RTC->CR &= (uint32_t)~RTC_CR_WUTE;
00002a  4c10              LDR      r4,|L55.108|
00002c  3c1c              SUBS     r4,r4,#0x1c
00002e  6824              LDR      r4,[r4,#0]
000030  f4246480          BIC      r4,r4,#0x400
000034  4d0d              LDR      r5,|L55.108|
000036  3d1c              SUBS     r5,r5,#0x1c
000038  602c              STR      r4,[r5,#0]
;;;1550       /* Wait till RTC WUTWF flag is set and if Time out is reached exit */
;;;1551       do
00003a  bf00              NOP      
                  |L55.60|
;;;1552       {
;;;1553         wutwfstatus = RTC->ISR & RTC_ISR_WUTWF;
00003c  4c0b              LDR      r4,|L55.108|
00003e  3c18              SUBS     r4,r4,#0x18
000040  6824              LDR      r4,[r4,#0]
000042  f0040304          AND      r3,r4,#4
;;;1554         wutcounter++;  
000046  1c52              ADDS     r2,r2,#1
;;;1555       } while((wutcounter != INITMODE_TIMEOUT) && (wutwfstatus == 0x00));
000048  f5b23f80          CMP      r2,#0x10000
00004c  d001              BEQ      |L55.82|
00004e  2b00              CMP      r3,#0
000050  d0f4              BEQ      |L55.60|
                  |L55.82|
;;;1556       
;;;1557       if ((RTC->ISR & RTC_ISR_WUTWF) == RESET)
000052  4c06              LDR      r4,|L55.108|
000054  3c18              SUBS     r4,r4,#0x18
000056  6824              LDR      r4,[r4,#0]
000058  f0140f04          TST      r4,#4
00005c  d101              BNE      |L55.98|
;;;1558       {
;;;1559         status = ERROR;
00005e  2000              MOVS     r0,#0
000060  e000              B        |L55.100|
                  |L55.98|
;;;1560       }
;;;1561       else
;;;1562       {
;;;1563         status = SUCCESS;
000062  2001              MOVS     r0,#1
                  |L55.100|
;;;1564       }    
;;;1565     }
;;;1566   
;;;1567     /* Enable the write protection for RTC registers */
;;;1568     RTC->WPR = 0xFF; 
000064  24ff              MOVS     r4,#0xff
000066  4d01              LDR      r5,|L55.108|
000068  602c              STR      r4,[r5,#0]
;;;1569     
;;;1570     return status;
;;;1571   }
00006a  bd30              POP      {r4,r5,pc}
;;;1572   
                          ENDP

                  |L55.108|
                          DCD      0x40002824

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

                  RTC_WriteBackupRegister PROC
;;;2275     */
;;;2276   void RTC_WriteBackupRegister(uint32_t RTC_BKP_DR, uint32_t Data)
000000  2200              MOVS     r2,#0
;;;2277   {
;;;2278     __IO uint32_t tmp = 0;
;;;2279     
;;;2280     /* Check the parameters */
;;;2281     assert_param(IS_RTC_BKP(RTC_BKP_DR));
;;;2282   
;;;2283     tmp = RTC_BASE + 0x50;
000002  4a02              LDR      r2,|L56.12|
;;;2284     tmp += (RTC_BKP_DR * 4);
000004  eb020280          ADD      r2,r2,r0,LSL #2
;;;2285   
;;;2286     /* Write the specified register */
;;;2287     *(__IO uint32_t *)tmp = (uint32_t)Data;
000008  6011              STR      r1,[r2,#0]
;;;2288   }
00000a  4770              BX       lr
;;;2289   
                          ENDP

                  |L56.12|
                          DCD      0x40002850

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

                  RTC_WriteProtectionCmd PROC
;;;512      */
;;;513    void RTC_WriteProtectionCmd(FunctionalState NewState)
000000  b118              CBZ      r0,|L57.10|
;;;514    {
;;;515      /* Check the parameters */
;;;516      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;517        
;;;518      if (NewState != DISABLE)
;;;519      {
;;;520        /* Enable the write protection for RTC registers */
;;;521        RTC->WPR = 0xFF;   
000002  21ff              MOVS     r1,#0xff
000004  4a04              LDR      r2,|L57.24|
000006  6011              STR      r1,[r2,#0]
000008  e004              B        |L57.20|
                  |L57.10|
;;;522      }
;;;523      else
;;;524      {
;;;525        /* Disable the write protection for RTC registers */
;;;526        RTC->WPR = 0xCA;
00000a  21ca              MOVS     r1,#0xca
00000c  4a02              LDR      r2,|L57.24|
00000e  6011              STR      r1,[r2,#0]
;;;527        RTC->WPR = 0x53;    
000010  2153              MOVS     r1,#0x53
000012  6011              STR      r1,[r2,#0]
                  |L57.20|
;;;528      }
;;;529    }
000014  4770              BX       lr
;;;530    
                          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, READONLY
	THUMB
	EXPORT |__asm___15_stm32f4xx_rtc_c_81435638____REV16|
#line 114 "C:\\Keil\\ARM\\CMSIS\\Include\\core_cmInstr.h"
|__asm___15_stm32f4xx_rtc_c_81435638____REV16| PROC
#line 115

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

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
