; generated by ARM C/C++ Compiler, 5.03 [Build 24]
; commandline ArmCC [--list --debug -c --asm --interleave -o..\OBJ\stm32f10x_rcc.o --asm_dir=..\LIST\ --list_dir=..\LIST\ --depend=..\OBJ\stm32f10x_rcc.d --cpu=Cortex-M3 --apcs=interwork -O0 -I..\..\Libraries\STM32F10x_StdPeriph_Driver\inc -I..\..\Libraries\CMSIS\CM3\CoreSupport -I..\..\Libraries\CMSIS\CM3\DeviceSupport\ST\STM32F10x -I..\..\USER\INC -IC:\Keil\ARM\RV31\INC -IC:\Keil\ARM\CMSIS\Include -IC:\Keil\ARM\Inc\ST\STM32F10x -D__MICROLIB -DUSE_STDPERIPH_DRIVER -DSTM32F10X_HD --omf_browse=..\OBJ\stm32f10x_rcc.crf ..\..\Libraries\STM32F10x_StdPeriph_Driver\src\stm32f10x_rcc.c]
                          THUMB

                          AREA ||.text||, CODE, READONLY, ALIGN=2

                  RCC_DeInit PROC
;;;216      */
;;;217    void RCC_DeInit(void)
000000  48dd              LDR      r0,|L1.888|
;;;218    {
;;;219      /* Set HSION bit */
;;;220      RCC->CR |= (uint32_t)0x00000001;
000002  6800              LDR      r0,[r0,#0]
000004  f0400001          ORR      r0,r0,#1
000008  49db              LDR      r1,|L1.888|
00000a  6008              STR      r0,[r1,#0]
;;;221    
;;;222      /* Reset SW, HPRE, PPRE1, PPRE2, ADCPRE and MCO bits */
;;;223    #ifndef STM32F10X_CL
;;;224      RCC->CFGR &= (uint32_t)0xF8FF0000;
00000c  4608              MOV      r0,r1
00000e  6840              LDR      r0,[r0,#4]
000010  49da              LDR      r1,|L1.892|
000012  4008              ANDS     r0,r0,r1
000014  49d8              LDR      r1,|L1.888|
000016  6048              STR      r0,[r1,#4]
;;;225    #else
;;;226      RCC->CFGR &= (uint32_t)0xF0FF0000;
;;;227    #endif /* STM32F10X_CL */   
;;;228      
;;;229      /* Reset HSEON, CSSON and PLLON bits */
;;;230      RCC->CR &= (uint32_t)0xFEF6FFFF;
000018  4608              MOV      r0,r1
00001a  6800              LDR      r0,[r0,#0]
00001c  49d8              LDR      r1,|L1.896|
00001e  4008              ANDS     r0,r0,r1
000020  49d5              LDR      r1,|L1.888|
000022  6008              STR      r0,[r1,#0]
;;;231    
;;;232      /* Reset HSEBYP bit */
;;;233      RCC->CR &= (uint32_t)0xFFFBFFFF;
000024  4608              MOV      r0,r1
000026  6800              LDR      r0,[r0,#0]
000028  f4202080          BIC      r0,r0,#0x40000
00002c  6008              STR      r0,[r1,#0]
;;;234    
;;;235      /* Reset PLLSRC, PLLXTPRE, PLLMUL and USBPRE/OTGFSPRE bits */
;;;236      RCC->CFGR &= (uint32_t)0xFF80FFFF;
00002e  4608              MOV      r0,r1
000030  6840              LDR      r0,[r0,#4]
000032  f42000fe          BIC      r0,r0,#0x7f0000
000036  6048              STR      r0,[r1,#4]
;;;237    
;;;238    #ifdef STM32F10X_CL
;;;239      /* Reset PLL2ON and PLL3ON bits */
;;;240      RCC->CR &= (uint32_t)0xEBFFFFFF;
;;;241    
;;;242      /* Disable all interrupts and clear pending bits  */
;;;243      RCC->CIR = 0x00FF0000;
;;;244    
;;;245      /* Reset CFGR2 register */
;;;246      RCC->CFGR2 = 0x00000000;
;;;247    #elif defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || defined (STM32F10X_HD_VL)
;;;248      /* Disable all interrupts and clear pending bits  */
;;;249      RCC->CIR = 0x009F0000;
;;;250    
;;;251      /* Reset CFGR2 register */
;;;252      RCC->CFGR2 = 0x00000000;      
;;;253    #else
;;;254      /* Disable all interrupts and clear pending bits  */
;;;255      RCC->CIR = 0x009F0000;
000038  f44f001f          MOV      r0,#0x9f0000
00003c  6088              STR      r0,[r1,#8]
;;;256    #endif /* STM32F10X_CL */
;;;257    
;;;258    }
00003e  4770              BX       lr
;;;259    
                          ENDP

                  RCC_HSEConfig PROC
;;;269      */
;;;270    void RCC_HSEConfig(uint32_t RCC_HSE)
000040  49cd              LDR      r1,|L1.888|
;;;271    {
;;;272      /* Check the parameters */
;;;273      assert_param(IS_RCC_HSE(RCC_HSE));
;;;274      /* Reset HSEON and HSEBYP bits before configuring the HSE ------------------*/
;;;275      /* Reset HSEON bit */
;;;276      RCC->CR &= CR_HSEON_Reset;
000042  6809              LDR      r1,[r1,#0]
000044  f4213180          BIC      r1,r1,#0x10000
000048  4acb              LDR      r2,|L1.888|
00004a  6011              STR      r1,[r2,#0]
;;;277      /* Reset HSEBYP bit */
;;;278      RCC->CR &= CR_HSEBYP_Reset;
00004c  4611              MOV      r1,r2
00004e  6809              LDR      r1,[r1,#0]
000050  f4212180          BIC      r1,r1,#0x40000
000054  6011              STR      r1,[r2,#0]
;;;279      /* Configure HSE (RCC_HSE_OFF is already covered by the code section above) */
;;;280      switch(RCC_HSE)
000056  f5b03f80          CMP      r0,#0x10000
00005a  d003              BEQ      |L1.100|
00005c  f5b02f80          CMP      r0,#0x40000
000060  d10e              BNE      |L1.128|
000062  e006              B        |L1.114|
                  |L1.100|
;;;281      {
;;;282        case RCC_HSE_ON:
;;;283          /* Set HSEON bit */
;;;284          RCC->CR |= CR_HSEON_Set;
000064  49c4              LDR      r1,|L1.888|
000066  6809              LDR      r1,[r1,#0]
000068  f4413180          ORR      r1,r1,#0x10000
00006c  4ac2              LDR      r2,|L1.888|
00006e  6011              STR      r1,[r2,#0]
;;;285          break;
000070  e007              B        |L1.130|
                  |L1.114|
;;;286          
;;;287        case RCC_HSE_Bypass:
;;;288          /* Set HSEBYP and HSEON bits */
;;;289          RCC->CR |= CR_HSEBYP_Set | CR_HSEON_Set;
000072  49c1              LDR      r1,|L1.888|
000074  6809              LDR      r1,[r1,#0]
000076  f44121a0          ORR      r1,r1,#0x50000
00007a  4abf              LDR      r2,|L1.888|
00007c  6011              STR      r1,[r2,#0]
;;;290          break;
00007e  e000              B        |L1.130|
                  |L1.128|
;;;291          
;;;292        default:
;;;293          break;
000080  bf00              NOP      
                  |L1.130|
000082  bf00              NOP                            ;285
;;;294      }
;;;295    }
000084  4770              BX       lr
;;;296    
                          ENDP

                  RCC_GetFlagStatus PROC
;;;1325     */
;;;1326   FlagStatus RCC_GetFlagStatus(uint8_t RCC_FLAG)
000086  b510              PUSH     {r4,lr}
;;;1327   {
000088  4601              MOV      r1,r0
;;;1328     uint32_t tmp = 0;
00008a  2200              MOVS     r2,#0
;;;1329     uint32_t statusreg = 0;
00008c  2300              MOVS     r3,#0
;;;1330     FlagStatus bitstatus = RESET;
00008e  2000              MOVS     r0,#0
;;;1331     /* Check the parameters */
;;;1332     assert_param(IS_RCC_FLAG(RCC_FLAG));
;;;1333   
;;;1334     /* Get the RCC register index */
;;;1335     tmp = RCC_FLAG >> 5;
000090  114a              ASRS     r2,r1,#5
;;;1336     if (tmp == 1)               /* The flag to check is in CR register */
000092  2a01              CMP      r2,#1
000094  d102              BNE      |L1.156|
;;;1337     {
;;;1338       statusreg = RCC->CR;
000096  4cb8              LDR      r4,|L1.888|
000098  6823              LDR      r3,[r4,#0]
00009a  e006              B        |L1.170|
                  |L1.156|
;;;1339     }
;;;1340     else if (tmp == 2)          /* The flag to check is in BDCR register */
00009c  2a02              CMP      r2,#2
00009e  d102              BNE      |L1.166|
;;;1341     {
;;;1342       statusreg = RCC->BDCR;
0000a0  4cb5              LDR      r4,|L1.888|
0000a2  6a23              LDR      r3,[r4,#0x20]
0000a4  e001              B        |L1.170|
                  |L1.166|
;;;1343     }
;;;1344     else                       /* The flag to check is in CSR register */
;;;1345     {
;;;1346       statusreg = RCC->CSR;
0000a6  4cb4              LDR      r4,|L1.888|
0000a8  6a63              LDR      r3,[r4,#0x24]
                  |L1.170|
;;;1347     }
;;;1348   
;;;1349     /* Get the flag position */
;;;1350     tmp = RCC_FLAG & FLAG_Mask;
0000aa  f001021f          AND      r2,r1,#0x1f
;;;1351     if ((statusreg & ((uint32_t)1 << tmp)) != (uint32_t)RESET)
0000ae  2401              MOVS     r4,#1
0000b0  4094              LSLS     r4,r4,r2
0000b2  421c              TST      r4,r3
0000b4  d001              BEQ      |L1.186|
;;;1352     {
;;;1353       bitstatus = SET;
0000b6  2001              MOVS     r0,#1
0000b8  e000              B        |L1.188|
                  |L1.186|
;;;1354     }
;;;1355     else
;;;1356     {
;;;1357       bitstatus = RESET;
0000ba  2000              MOVS     r0,#0
                  |L1.188|
;;;1358     }
;;;1359   
;;;1360     /* Return the flag status */
;;;1361     return bitstatus;
;;;1362   }
0000bc  bd10              POP      {r4,pc}
;;;1363   
                          ENDP

                  RCC_WaitForHSEStartUp PROC
;;;303      */
;;;304    ErrorStatus RCC_WaitForHSEStartUp(void)
0000be  b538              PUSH     {r3-r5,lr}
;;;305    {
;;;306      __IO uint32_t StartUpCounter = 0;
0000c0  2000              MOVS     r0,#0
0000c2  9000              STR      r0,[sp,#0]
;;;307      ErrorStatus status = ERROR;
0000c4  2400              MOVS     r4,#0
;;;308      FlagStatus HSEStatus = RESET;
0000c6  2500              MOVS     r5,#0
;;;309      
;;;310      /* Wait till HSE is ready and if Time out is reached exit */
;;;311      do
0000c8  bf00              NOP      
                  |L1.202|
;;;312      {
;;;313        HSEStatus = RCC_GetFlagStatus(RCC_FLAG_HSERDY);
0000ca  2031              MOVS     r0,#0x31
0000cc  f7fffffe          BL       RCC_GetFlagStatus
0000d0  4605              MOV      r5,r0
;;;314        StartUpCounter++;  
0000d2  9800              LDR      r0,[sp,#0]
0000d4  1c40              ADDS     r0,r0,#1
0000d6  9000              STR      r0,[sp,#0]
;;;315      } while((StartUpCounter != HSE_STARTUP_TIMEOUT) && (HSEStatus == RESET));
0000d8  9800              LDR      r0,[sp,#0]
0000da  f5b06fa0          CMP      r0,#0x500
0000de  d001              BEQ      |L1.228|
0000e0  2d00              CMP      r5,#0
0000e2  d0f2              BEQ      |L1.202|
                  |L1.228|
;;;316      
;;;317      if (RCC_GetFlagStatus(RCC_FLAG_HSERDY) != RESET)
0000e4  2031              MOVS     r0,#0x31
0000e6  f7fffffe          BL       RCC_GetFlagStatus
0000ea  b108              CBZ      r0,|L1.240|
;;;318      {
;;;319        status = SUCCESS;
0000ec  2401              MOVS     r4,#1
0000ee  e000              B        |L1.242|
                  |L1.240|
;;;320      }
;;;321      else
;;;322      {
;;;323        status = ERROR;
0000f0  2400              MOVS     r4,#0
                  |L1.242|
;;;324      }  
;;;325      return (status);
0000f2  4620              MOV      r0,r4
;;;326    }
0000f4  bd38              POP      {r3-r5,pc}
;;;327    
                          ENDP

                  RCC_AdjustHSICalibrationValue PROC
;;;333      */
;;;334    void RCC_AdjustHSICalibrationValue(uint8_t HSICalibrationValue)
0000f6  4601              MOV      r1,r0
;;;335    {
;;;336      uint32_t tmpreg = 0;
0000f8  2000              MOVS     r0,#0
;;;337      /* Check the parameters */
;;;338      assert_param(IS_RCC_CALIBRATION_VALUE(HSICalibrationValue));
;;;339      tmpreg = RCC->CR;
0000fa  4a9f              LDR      r2,|L1.888|
0000fc  6810              LDR      r0,[r2,#0]
;;;340      /* Clear HSITRIM[4:0] bits */
;;;341      tmpreg &= CR_HSITRIM_Mask;
0000fe  f02000f8          BIC      r0,r0,#0xf8
;;;342      /* Set the HSITRIM[4:0] bits according to HSICalibrationValue value */
;;;343      tmpreg |= (uint32_t)HSICalibrationValue << 3;
000102  ea4000c1          ORR      r0,r0,r1,LSL #3
;;;344      /* Store the new value */
;;;345      RCC->CR = tmpreg;
000106  6010              STR      r0,[r2,#0]
;;;346    }
000108  4770              BX       lr
;;;347    
                          ENDP

                  RCC_HSICmd PROC
;;;353      */
;;;354    void RCC_HSICmd(FunctionalState NewState)
00010a  499e              LDR      r1,|L1.900|
;;;355    {
;;;356      /* Check the parameters */
;;;357      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;358      *(__IO uint32_t *) CR_HSION_BB = (uint32_t)NewState;
00010c  6008              STR      r0,[r1,#0]
;;;359    }
00010e  4770              BX       lr
;;;360    
                          ENDP

                  RCC_PLLConfig PROC
;;;377      */
;;;378    void RCC_PLLConfig(uint32_t RCC_PLLSource, uint32_t RCC_PLLMul)
000110  4602              MOV      r2,r0
;;;379    {
;;;380      uint32_t tmpreg = 0;
000112  2000              MOVS     r0,#0
;;;381    
;;;382      /* Check the parameters */
;;;383      assert_param(IS_RCC_PLL_SOURCE(RCC_PLLSource));
;;;384      assert_param(IS_RCC_PLL_MUL(RCC_PLLMul));
;;;385    
;;;386      tmpreg = RCC->CFGR;
000114  4b98              LDR      r3,|L1.888|
000116  6858              LDR      r0,[r3,#4]
;;;387      /* Clear PLLSRC, PLLXTPRE and PLLMUL[3:0] bits */
;;;388      tmpreg &= CFGR_PLL_Mask;
000118  f420107c          BIC      r0,r0,#0x3f0000
;;;389      /* Set the PLL configuration bits */
;;;390      tmpreg |= RCC_PLLSource | RCC_PLLMul;
00011c  ea420301          ORR      r3,r2,r1
000120  4318              ORRS     r0,r0,r3
;;;391      /* Store the new value */
;;;392      RCC->CFGR = tmpreg;
000122  4b95              LDR      r3,|L1.888|
000124  6058              STR      r0,[r3,#4]
;;;393    }
000126  4770              BX       lr
;;;394    
                          ENDP

                  RCC_PLLCmd PROC
;;;400      */
;;;401    void RCC_PLLCmd(FunctionalState NewState)
000128  4996              LDR      r1,|L1.900|
;;;402    {
;;;403      /* Check the parameters */
;;;404      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;405    
;;;406      *(__IO uint32_t *) CR_PLLON_BB = (uint32_t)NewState;
00012a  6608              STR      r0,[r1,#0x60]
;;;407    }
00012c  4770              BX       lr
;;;408    
                          ENDP

                  RCC_SYSCLKConfig PROC
;;;563      */
;;;564    void RCC_SYSCLKConfig(uint32_t RCC_SYSCLKSource)
00012e  4601              MOV      r1,r0
;;;565    {
;;;566      uint32_t tmpreg = 0;
000130  2000              MOVS     r0,#0
;;;567      /* Check the parameters */
;;;568      assert_param(IS_RCC_SYSCLK_SOURCE(RCC_SYSCLKSource));
;;;569      tmpreg = RCC->CFGR;
000132  4a91              LDR      r2,|L1.888|
000134  6850              LDR      r0,[r2,#4]
;;;570      /* Clear SW[1:0] bits */
;;;571      tmpreg &= CFGR_SW_Mask;
000136  f0200003          BIC      r0,r0,#3
;;;572      /* Set SW[1:0] bits according to RCC_SYSCLKSource value */
;;;573      tmpreg |= RCC_SYSCLKSource;
00013a  4308              ORRS     r0,r0,r1
;;;574      /* Store the new value */
;;;575      RCC->CFGR = tmpreg;
00013c  6050              STR      r0,[r2,#4]
;;;576    }
00013e  4770              BX       lr
;;;577    
                          ENDP

                  RCC_GetSYSCLKSource PROC
;;;586      */
;;;587    uint8_t RCC_GetSYSCLKSource(void)
000140  488d              LDR      r0,|L1.888|
;;;588    {
;;;589      return ((uint8_t)(RCC->CFGR & CFGR_SWS_Mask));
000142  6840              LDR      r0,[r0,#4]
000144  f000000c          AND      r0,r0,#0xc
;;;590    }
000148  4770              BX       lr
;;;591    
                          ENDP

                  RCC_HCLKConfig PROC
;;;607      */
;;;608    void RCC_HCLKConfig(uint32_t RCC_SYSCLK)
00014a  4601              MOV      r1,r0
;;;609    {
;;;610      uint32_t tmpreg = 0;
00014c  2000              MOVS     r0,#0
;;;611      /* Check the parameters */
;;;612      assert_param(IS_RCC_HCLK(RCC_SYSCLK));
;;;613      tmpreg = RCC->CFGR;
00014e  4a8a              LDR      r2,|L1.888|
000150  6850              LDR      r0,[r2,#4]
;;;614      /* Clear HPRE[3:0] bits */
;;;615      tmpreg &= CFGR_HPRE_Reset_Mask;
000152  f02000f0          BIC      r0,r0,#0xf0
;;;616      /* Set HPRE[3:0] bits according to RCC_SYSCLK value */
;;;617      tmpreg |= RCC_SYSCLK;
000156  4308              ORRS     r0,r0,r1
;;;618      /* Store the new value */
;;;619      RCC->CFGR = tmpreg;
000158  6050              STR      r0,[r2,#4]
;;;620    }
00015a  4770              BX       lr
;;;621    
                          ENDP

                  RCC_PCLK1Config PROC
;;;633      */
;;;634    void RCC_PCLK1Config(uint32_t RCC_HCLK)
00015c  4601              MOV      r1,r0
;;;635    {
;;;636      uint32_t tmpreg = 0;
00015e  2000              MOVS     r0,#0
;;;637      /* Check the parameters */
;;;638      assert_param(IS_RCC_PCLK(RCC_HCLK));
;;;639      tmpreg = RCC->CFGR;
000160  4a85              LDR      r2,|L1.888|
000162  6850              LDR      r0,[r2,#4]
;;;640      /* Clear PPRE1[2:0] bits */
;;;641      tmpreg &= CFGR_PPRE1_Reset_Mask;
000164  f42060e0          BIC      r0,r0,#0x700
;;;642      /* Set PPRE1[2:0] bits according to RCC_HCLK value */
;;;643      tmpreg |= RCC_HCLK;
000168  4308              ORRS     r0,r0,r1
;;;644      /* Store the new value */
;;;645      RCC->CFGR = tmpreg;
00016a  6050              STR      r0,[r2,#4]
;;;646    }
00016c  4770              BX       lr
;;;647    
                          ENDP

                  RCC_PCLK2Config PROC
;;;659      */
;;;660    void RCC_PCLK2Config(uint32_t RCC_HCLK)
00016e  4601              MOV      r1,r0
;;;661    {
;;;662      uint32_t tmpreg = 0;
000170  2000              MOVS     r0,#0
;;;663      /* Check the parameters */
;;;664      assert_param(IS_RCC_PCLK(RCC_HCLK));
;;;665      tmpreg = RCC->CFGR;
000172  4a81              LDR      r2,|L1.888|
000174  6850              LDR      r0,[r2,#4]
;;;666      /* Clear PPRE2[2:0] bits */
;;;667      tmpreg &= CFGR_PPRE2_Reset_Mask;
000176  f4205060          BIC      r0,r0,#0x3800
;;;668      /* Set PPRE2[2:0] bits according to RCC_HCLK value */
;;;669      tmpreg |= RCC_HCLK << 3;
00017a  ea4000c1          ORR      r0,r0,r1,LSL #3
;;;670      /* Store the new value */
;;;671      RCC->CFGR = tmpreg;
00017e  6050              STR      r0,[r2,#4]
;;;672    }
000180  4770              BX       lr
;;;673    
                          ENDP

                  RCC_ITConfig PROC
;;;699      */
;;;700    void RCC_ITConfig(uint8_t RCC_IT, FunctionalState NewState)
000182  b129              CBZ      r1,|L1.400|
;;;701    {
;;;702      /* Check the parameters */
;;;703      assert_param(IS_RCC_IT(RCC_IT));
;;;704      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;705      if (NewState != DISABLE)
;;;706      {
;;;707        /* Perform Byte access to RCC_CIR bits to enable the selected interrupts */
;;;708        *(__IO uint8_t *) CIR_BYTE2_ADDRESS |= RCC_IT;
000184  4a7c              LDR      r2,|L1.888|
000186  7a52              LDRB     r2,[r2,#9]
000188  4302              ORRS     r2,r2,r0
00018a  4b7b              LDR      r3,|L1.888|
00018c  725a              STRB     r2,[r3,#9]
00018e  e004              B        |L1.410|
                  |L1.400|
;;;709      }
;;;710      else
;;;711      {
;;;712        /* Perform Byte access to RCC_CIR bits to disable the selected interrupts */
;;;713        *(__IO uint8_t *) CIR_BYTE2_ADDRESS &= (uint8_t)~RCC_IT;
000190  4a79              LDR      r2,|L1.888|
000192  7a52              LDRB     r2,[r2,#9]
000194  4382              BICS     r2,r2,r0
000196  4b78              LDR      r3,|L1.888|
000198  725a              STRB     r2,[r3,#9]
                  |L1.410|
;;;714      }
;;;715    }
00019a  4770              BX       lr
;;;716    
                          ENDP

                  RCC_USBCLKConfig PROC
;;;727      */
;;;728    void RCC_USBCLKConfig(uint32_t RCC_USBCLKSource)
00019c  497a              LDR      r1,|L1.904|
;;;729    {
;;;730      /* Check the parameters */
;;;731      assert_param(IS_RCC_USBCLK_SOURCE(RCC_USBCLKSource));
;;;732    
;;;733      *(__IO uint32_t *) CFGR_USBPRE_BB = RCC_USBCLKSource;
00019e  6008              STR      r0,[r1,#0]
;;;734    }
0001a0  4770              BX       lr
;;;735    #else
                          ENDP

                  RCC_ADCCLKConfig PROC
;;;765      */
;;;766    void RCC_ADCCLKConfig(uint32_t RCC_PCLK2)
0001a2  4601              MOV      r1,r0
;;;767    {
;;;768      uint32_t tmpreg = 0;
0001a4  2000              MOVS     r0,#0
;;;769      /* Check the parameters */
;;;770      assert_param(IS_RCC_ADCCLK(RCC_PCLK2));
;;;771      tmpreg = RCC->CFGR;
0001a6  4a74              LDR      r2,|L1.888|
0001a8  6850              LDR      r0,[r2,#4]
;;;772      /* Clear ADCPRE[1:0] bits */
;;;773      tmpreg &= CFGR_ADCPRE_Reset_Mask;
0001aa  f4204040          BIC      r0,r0,#0xc000
;;;774      /* Set ADCPRE[1:0] bits according to RCC_PCLK2 value */
;;;775      tmpreg |= RCC_PCLK2;
0001ae  4308              ORRS     r0,r0,r1
;;;776      /* Store the new value */
;;;777      RCC->CFGR = tmpreg;
0001b0  6050              STR      r0,[r2,#4]
;;;778    }
0001b2  4770              BX       lr
;;;779    
                          ENDP

                  RCC_LSEConfig PROC
;;;828      */
;;;829    void RCC_LSEConfig(uint8_t RCC_LSE)
0001b4  2100              MOVS     r1,#0
;;;830    {
;;;831      /* Check the parameters */
;;;832      assert_param(IS_RCC_LSE(RCC_LSE));
;;;833      /* Reset LSEON and LSEBYP bits before configuring the LSE ------------------*/
;;;834      /* Reset LSEON bit */
;;;835      *(__IO uint8_t *) BDCR_ADDRESS = RCC_LSE_OFF;
0001b6  4a75              LDR      r2,|L1.908|
0001b8  7011              STRB     r1,[r2,#0]
;;;836      /* Reset LSEBYP bit */
;;;837      *(__IO uint8_t *) BDCR_ADDRESS = RCC_LSE_OFF;
0001ba  4a6f              LDR      r2,|L1.888|
0001bc  f8821020          STRB     r1,[r2,#0x20]
;;;838      /* Configure LSE (RCC_LSE_OFF is already covered by the code section above) */
;;;839      switch(RCC_LSE)
0001c0  2801              CMP      r0,#1
0001c2  d002              BEQ      |L1.458|
0001c4  2804              CMP      r0,#4
0001c6  d108              BNE      |L1.474|
0001c8  e003              B        |L1.466|
                  |L1.458|
;;;840      {
;;;841        case RCC_LSE_ON:
;;;842          /* Set LSEON bit */
;;;843          *(__IO uint8_t *) BDCR_ADDRESS = RCC_LSE_ON;
0001ca  2101              MOVS     r1,#1
0001cc  4a6f              LDR      r2,|L1.908|
0001ce  7011              STRB     r1,[r2,#0]
;;;844          break;
0001d0  e004              B        |L1.476|
                  |L1.466|
;;;845          
;;;846        case RCC_LSE_Bypass:
;;;847          /* Set LSEBYP and LSEON bits */
;;;848          *(__IO uint8_t *) BDCR_ADDRESS = RCC_LSE_Bypass | RCC_LSE_ON;
0001d2  2105              MOVS     r1,#5
0001d4  4a6d              LDR      r2,|L1.908|
0001d6  7011              STRB     r1,[r2,#0]
;;;849          break;            
0001d8  e000              B        |L1.476|
                  |L1.474|
;;;850          
;;;851        default:
;;;852          break;      
0001da  bf00              NOP      
                  |L1.476|
0001dc  bf00              NOP                            ;844
;;;853      }
;;;854    }
0001de  4770              BX       lr
;;;855    
                          ENDP

                  RCC_LSICmd PROC
;;;861      */
;;;862    void RCC_LSICmd(FunctionalState NewState)
0001e0  496b              LDR      r1,|L1.912|
;;;863    {
;;;864      /* Check the parameters */
;;;865      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;866      *(__IO uint32_t *) CSR_LSION_BB = (uint32_t)NewState;
0001e2  6008              STR      r0,[r1,#0]
;;;867    }
0001e4  4770              BX       lr
;;;868    
                          ENDP

                  RCC_RTCCLKConfig PROC
;;;878      */
;;;879    void RCC_RTCCLKConfig(uint32_t RCC_RTCCLKSource)
0001e6  4964              LDR      r1,|L1.888|
;;;880    {
;;;881      /* Check the parameters */
;;;882      assert_param(IS_RCC_RTCCLK_SOURCE(RCC_RTCCLKSource));
;;;883      /* Select the RTC clock source */
;;;884      RCC->BDCR |= RCC_RTCCLKSource;
0001e8  6a09              LDR      r1,[r1,#0x20]
0001ea  4301              ORRS     r1,r1,r0
0001ec  4a62              LDR      r2,|L1.888|
0001ee  6211              STR      r1,[r2,#0x20]
;;;885    }
0001f0  4770              BX       lr
;;;886    
                          ENDP

                  RCC_RTCCLKCmd PROC
;;;892      */
;;;893    void RCC_RTCCLKCmd(FunctionalState NewState)
0001f2  4967              LDR      r1,|L1.912|
;;;894    {
;;;895      /* Check the parameters */
;;;896      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;897      *(__IO uint32_t *) BDCR_RTCEN_BB = (uint32_t)NewState;
0001f4  3944              SUBS     r1,r1,#0x44
0001f6  6008              STR      r0,[r1,#0]
;;;898    }
0001f8  4770              BX       lr
;;;899    
                          ENDP

                  RCC_GetClocksFreq PROC
;;;907      */
;;;908    void RCC_GetClocksFreq(RCC_ClocksTypeDef* RCC_Clocks)
0001fa  b530              PUSH     {r4,r5,lr}
;;;909    {
;;;910      uint32_t tmp = 0, pllmull = 0, pllsource = 0, presc = 0;
0001fc  2100              MOVS     r1,#0
0001fe  2200              MOVS     r2,#0
000200  2400              MOVS     r4,#0
000202  2300              MOVS     r3,#0
;;;911    
;;;912    #ifdef  STM32F10X_CL
;;;913      uint32_t prediv1source = 0, prediv1factor = 0, prediv2factor = 0, pll2mull = 0;
;;;914    #endif /* STM32F10X_CL */
;;;915    
;;;916    #if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || defined (STM32F10X_HD_VL)
;;;917      uint32_t prediv1factor = 0;
;;;918    #endif
;;;919        
;;;920      /* Get SYSCLK source -------------------------------------------------------*/
;;;921      tmp = RCC->CFGR & CFGR_SWS_Mask;
000204  4d5c              LDR      r5,|L1.888|
000206  686d              LDR      r5,[r5,#4]
000208  f005010c          AND      r1,r5,#0xc
;;;922      
;;;923      switch (tmp)
00020c  b121              CBZ      r1,|L1.536|
00020e  2904              CMP      r1,#4
000210  d005              BEQ      |L1.542|
000212  2908              CMP      r1,#8
000214  d123              BNE      |L1.606|
000216  e005              B        |L1.548|
                  |L1.536|
;;;924      {
;;;925        case 0x00:  /* HSI used as system clock */
;;;926          RCC_Clocks->SYSCLK_Frequency = HSI_VALUE;
000218  4d5e              LDR      r5,|L1.916|
00021a  6005              STR      r5,[r0,#0]
;;;927          break;
00021c  e022              B        |L1.612|
                  |L1.542|
;;;928        case 0x04:  /* HSE used as system clock */
;;;929          RCC_Clocks->SYSCLK_Frequency = HSE_VALUE;
00021e  4d5d              LDR      r5,|L1.916|
000220  6005              STR      r5,[r0,#0]
;;;930          break;
000222  e01f              B        |L1.612|
                  |L1.548|
;;;931        case 0x08:  /* PLL used as system clock */
;;;932    
;;;933          /* Get PLL clock source and multiplication factor ----------------------*/
;;;934          pllmull = RCC->CFGR & CFGR_PLLMull_Mask;
000224  4d54              LDR      r5,|L1.888|
000226  686d              LDR      r5,[r5,#4]
000228  f4051270          AND      r2,r5,#0x3c0000
;;;935          pllsource = RCC->CFGR & CFGR_PLLSRC_Mask;
00022c  4d52              LDR      r5,|L1.888|
00022e  686d              LDR      r5,[r5,#4]
000230  f4053480          AND      r4,r5,#0x10000
;;;936          
;;;937    #ifndef STM32F10X_CL      
;;;938          pllmull = ( pllmull >> 18) + 2;
000234  2502              MOVS     r5,#2
000236  eb054292          ADD      r2,r5,r2,LSR #18
;;;939          
;;;940          if (pllsource == 0x00)
00023a  b91c              CBNZ     r4,|L1.580|
;;;941          {/* HSI oscillator clock divided by 2 selected as PLL clock entry */
;;;942            RCC_Clocks->SYSCLK_Frequency = (HSI_VALUE >> 1) * pllmull;
00023c  4d56              LDR      r5,|L1.920|
00023e  4355              MULS     r5,r2,r5
000240  6005              STR      r5,[r0,#0]
000242  e00b              B        |L1.604|
                  |L1.580|
;;;943          }
;;;944          else
;;;945          {
;;;946     #if defined (STM32F10X_LD_VL) || defined (STM32F10X_MD_VL) || defined (STM32F10X_HD_VL)
;;;947           prediv1factor = (RCC->CFGR2 & CFGR2_PREDIV1) + 1;
;;;948           /* HSE oscillator clock selected as PREDIV1 clock entry */
;;;949           RCC_Clocks->SYSCLK_Frequency = (HSE_VALUE / prediv1factor) * pllmull; 
;;;950     #else
;;;951            /* HSE selected as PLL clock entry */
;;;952            if ((RCC->CFGR & CFGR_PLLXTPRE_Mask) != (uint32_t)RESET)
000244  4d4c              LDR      r5,|L1.888|
000246  686d              LDR      r5,[r5,#4]
000248  f4153f00          TST      r5,#0x20000
00024c  d003              BEQ      |L1.598|
;;;953            {/* HSE oscillator clock divided by 2 */
;;;954              RCC_Clocks->SYSCLK_Frequency = (HSE_VALUE >> 1) * pllmull;
00024e  4d52              LDR      r5,|L1.920|
000250  4355              MULS     r5,r2,r5
000252  6005              STR      r5,[r0,#0]
000254  e002              B        |L1.604|
                  |L1.598|
;;;955            }
;;;956            else
;;;957            {
;;;958              RCC_Clocks->SYSCLK_Frequency = HSE_VALUE * pllmull;
000256  4d4f              LDR      r5,|L1.916|
000258  4355              MULS     r5,r2,r5
00025a  6005              STR      r5,[r0,#0]
                  |L1.604|
;;;959            }
;;;960     #endif
;;;961          }
;;;962    #else
;;;963          pllmull = pllmull >> 18;
;;;964          
;;;965          if (pllmull != 0x0D)
;;;966          {
;;;967             pllmull += 2;
;;;968          }
;;;969          else
;;;970          { /* PLL multiplication factor = PLL input clock * 6.5 */
;;;971            pllmull = 13 / 2; 
;;;972          }
;;;973                
;;;974          if (pllsource == 0x00)
;;;975          {/* HSI oscillator clock divided by 2 selected as PLL clock entry */
;;;976            RCC_Clocks->SYSCLK_Frequency = (HSI_VALUE >> 1) * pllmull;
;;;977          }
;;;978          else
;;;979          {/* PREDIV1 selected as PLL clock entry */
;;;980            
;;;981            /* Get PREDIV1 clock source and division factor */
;;;982            prediv1source = RCC->CFGR2 & CFGR2_PREDIV1SRC;
;;;983            prediv1factor = (RCC->CFGR2 & CFGR2_PREDIV1) + 1;
;;;984            
;;;985            if (prediv1source == 0)
;;;986            { /* HSE oscillator clock selected as PREDIV1 clock entry */
;;;987              RCC_Clocks->SYSCLK_Frequency = (HSE_VALUE / prediv1factor) * pllmull;          
;;;988            }
;;;989            else
;;;990            {/* PLL2 clock selected as PREDIV1 clock entry */
;;;991              
;;;992              /* Get PREDIV2 division factor and PLL2 multiplication factor */
;;;993              prediv2factor = ((RCC->CFGR2 & CFGR2_PREDIV2) >> 4) + 1;
;;;994              pll2mull = ((RCC->CFGR2 & CFGR2_PLL2MUL) >> 8 ) + 2; 
;;;995              RCC_Clocks->SYSCLK_Frequency = (((HSE_VALUE / prediv2factor) * pll2mull) / prediv1factor) * pllmull;                         
;;;996            }
;;;997          }
;;;998    #endif /* STM32F10X_CL */ 
;;;999          break;
00025c  e002              B        |L1.612|
                  |L1.606|
;;;1000   
;;;1001       default:
;;;1002         RCC_Clocks->SYSCLK_Frequency = HSI_VALUE;
00025e  4d4d              LDR      r5,|L1.916|
000260  6005              STR      r5,[r0,#0]
;;;1003         break;
000262  bf00              NOP      
                  |L1.612|
000264  bf00              NOP                            ;927
;;;1004     }
;;;1005   
;;;1006     /* Compute HCLK, PCLK1, PCLK2 and ADCCLK clocks frequencies ----------------*/
;;;1007     /* Get HCLK prescaler */
;;;1008     tmp = RCC->CFGR & CFGR_HPRE_Set_Mask;
000266  4d44              LDR      r5,|L1.888|
000268  686d              LDR      r5,[r5,#4]
00026a  f00501f0          AND      r1,r5,#0xf0
;;;1009     tmp = tmp >> 4;
00026e  0909              LSRS     r1,r1,#4
;;;1010     presc = APBAHBPrescTable[tmp];
000270  4d4a              LDR      r5,|L1.924|
000272  5c6b              LDRB     r3,[r5,r1]
;;;1011     /* HCLK clock frequency */
;;;1012     RCC_Clocks->HCLK_Frequency = RCC_Clocks->SYSCLK_Frequency >> presc;
000274  6805              LDR      r5,[r0,#0]
000276  40dd              LSRS     r5,r5,r3
000278  6045              STR      r5,[r0,#4]
;;;1013     /* Get PCLK1 prescaler */
;;;1014     tmp = RCC->CFGR & CFGR_PPRE1_Set_Mask;
00027a  4d3f              LDR      r5,|L1.888|
00027c  686d              LDR      r5,[r5,#4]
00027e  f40561e0          AND      r1,r5,#0x700
;;;1015     tmp = tmp >> 8;
000282  0a09              LSRS     r1,r1,#8
;;;1016     presc = APBAHBPrescTable[tmp];
000284  4d45              LDR      r5,|L1.924|
000286  5c6b              LDRB     r3,[r5,r1]
;;;1017     /* PCLK1 clock frequency */
;;;1018     RCC_Clocks->PCLK1_Frequency = RCC_Clocks->HCLK_Frequency >> presc;
000288  6845              LDR      r5,[r0,#4]
00028a  40dd              LSRS     r5,r5,r3
00028c  6085              STR      r5,[r0,#8]
;;;1019     /* Get PCLK2 prescaler */
;;;1020     tmp = RCC->CFGR & CFGR_PPRE2_Set_Mask;
00028e  4d3a              LDR      r5,|L1.888|
000290  686d              LDR      r5,[r5,#4]
000292  f4055160          AND      r1,r5,#0x3800
;;;1021     tmp = tmp >> 11;
000296  0ac9              LSRS     r1,r1,#11
;;;1022     presc = APBAHBPrescTable[tmp];
000298  4d40              LDR      r5,|L1.924|
00029a  5c6b              LDRB     r3,[r5,r1]
;;;1023     /* PCLK2 clock frequency */
;;;1024     RCC_Clocks->PCLK2_Frequency = RCC_Clocks->HCLK_Frequency >> presc;
00029c  6845              LDR      r5,[r0,#4]
00029e  40dd              LSRS     r5,r5,r3
0002a0  60c5              STR      r5,[r0,#0xc]
;;;1025     /* Get ADCCLK prescaler */
;;;1026     tmp = RCC->CFGR & CFGR_ADCPRE_Set_Mask;
0002a2  4d35              LDR      r5,|L1.888|
0002a4  686d              LDR      r5,[r5,#4]
0002a6  f4054140          AND      r1,r5,#0xc000
;;;1027     tmp = tmp >> 14;
0002aa  0b89              LSRS     r1,r1,#14
;;;1028     presc = ADCPrescTable[tmp];
0002ac  4d3c              LDR      r5,|L1.928|
0002ae  5c6b              LDRB     r3,[r5,r1]
;;;1029     /* ADCCLK clock frequency */
;;;1030     RCC_Clocks->ADCCLK_Frequency = RCC_Clocks->PCLK2_Frequency / presc;
0002b0  68c5              LDR      r5,[r0,#0xc]
0002b2  fbb5f5f3          UDIV     r5,r5,r3
0002b6  6105              STR      r5,[r0,#0x10]
;;;1031   }
0002b8  bd30              POP      {r4,r5,pc}
;;;1032   
                          ENDP

                  RCC_AHBPeriphClockCmd PROC
;;;1063     */
;;;1064   void RCC_AHBPeriphClockCmd(uint32_t RCC_AHBPeriph, FunctionalState NewState)
0002ba  b129              CBZ      r1,|L1.712|
;;;1065   {
;;;1066     /* Check the parameters */
;;;1067     assert_param(IS_RCC_AHB_PERIPH(RCC_AHBPeriph));
;;;1068     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1069   
;;;1070     if (NewState != DISABLE)
;;;1071     {
;;;1072       RCC->AHBENR |= RCC_AHBPeriph;
0002bc  4a2e              LDR      r2,|L1.888|
0002be  6952              LDR      r2,[r2,#0x14]
0002c0  4302              ORRS     r2,r2,r0
0002c2  4b2d              LDR      r3,|L1.888|
0002c4  615a              STR      r2,[r3,#0x14]
0002c6  e004              B        |L1.722|
                  |L1.712|
;;;1073     }
;;;1074     else
;;;1075     {
;;;1076       RCC->AHBENR &= ~RCC_AHBPeriph;
0002c8  4a2b              LDR      r2,|L1.888|
0002ca  6952              LDR      r2,[r2,#0x14]
0002cc  4382              BICS     r2,r2,r0
0002ce  4b2a              LDR      r3,|L1.888|
0002d0  615a              STR      r2,[r3,#0x14]
                  |L1.722|
;;;1077     }
;;;1078   }
0002d2  4770              BX       lr
;;;1079   
                          ENDP

                  RCC_APB2PeriphClockCmd PROC
;;;1094     */
;;;1095   void RCC_APB2PeriphClockCmd(uint32_t RCC_APB2Periph, FunctionalState NewState)
0002d4  b129              CBZ      r1,|L1.738|
;;;1096   {
;;;1097     /* Check the parameters */
;;;1098     assert_param(IS_RCC_APB2_PERIPH(RCC_APB2Periph));
;;;1099     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1100     if (NewState != DISABLE)
;;;1101     {
;;;1102       RCC->APB2ENR |= RCC_APB2Periph;
0002d6  4a28              LDR      r2,|L1.888|
0002d8  6992              LDR      r2,[r2,#0x18]
0002da  4302              ORRS     r2,r2,r0
0002dc  4b26              LDR      r3,|L1.888|
0002de  619a              STR      r2,[r3,#0x18]
0002e0  e004              B        |L1.748|
                  |L1.738|
;;;1103     }
;;;1104     else
;;;1105     {
;;;1106       RCC->APB2ENR &= ~RCC_APB2Periph;
0002e2  4a25              LDR      r2,|L1.888|
0002e4  6992              LDR      r2,[r2,#0x18]
0002e6  4382              BICS     r2,r2,r0
0002e8  4b23              LDR      r3,|L1.888|
0002ea  619a              STR      r2,[r3,#0x18]
                  |L1.748|
;;;1107     }
;;;1108   }
0002ec  4770              BX       lr
;;;1109   
                          ENDP

                  RCC_APB1PeriphClockCmd PROC
;;;1125     */
;;;1126   void RCC_APB1PeriphClockCmd(uint32_t RCC_APB1Periph, FunctionalState NewState)
0002ee  b129              CBZ      r1,|L1.764|
;;;1127   {
;;;1128     /* Check the parameters */
;;;1129     assert_param(IS_RCC_APB1_PERIPH(RCC_APB1Periph));
;;;1130     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1131     if (NewState != DISABLE)
;;;1132     {
;;;1133       RCC->APB1ENR |= RCC_APB1Periph;
0002f0  4a21              LDR      r2,|L1.888|
0002f2  69d2              LDR      r2,[r2,#0x1c]
0002f4  4302              ORRS     r2,r2,r0
0002f6  4b20              LDR      r3,|L1.888|
0002f8  61da              STR      r2,[r3,#0x1c]
0002fa  e004              B        |L1.774|
                  |L1.764|
;;;1134     }
;;;1135     else
;;;1136     {
;;;1137       RCC->APB1ENR &= ~RCC_APB1Periph;
0002fc  4a1e              LDR      r2,|L1.888|
0002fe  69d2              LDR      r2,[r2,#0x1c]
000300  4382              BICS     r2,r2,r0
000302  4b1d              LDR      r3,|L1.888|
000304  61da              STR      r2,[r3,#0x1c]
                  |L1.774|
;;;1138     }
;;;1139   }
000306  4770              BX       lr
;;;1140   
                          ENDP

                  RCC_APB2PeriphResetCmd PROC
;;;1184     */
;;;1185   void RCC_APB2PeriphResetCmd(uint32_t RCC_APB2Periph, FunctionalState NewState)
000308  b129              CBZ      r1,|L1.790|
;;;1186   {
;;;1187     /* Check the parameters */
;;;1188     assert_param(IS_RCC_APB2_PERIPH(RCC_APB2Periph));
;;;1189     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1190     if (NewState != DISABLE)
;;;1191     {
;;;1192       RCC->APB2RSTR |= RCC_APB2Periph;
00030a  4a1b              LDR      r2,|L1.888|
00030c  68d2              LDR      r2,[r2,#0xc]
00030e  4302              ORRS     r2,r2,r0
000310  4b19              LDR      r3,|L1.888|
000312  60da              STR      r2,[r3,#0xc]
000314  e004              B        |L1.800|
                  |L1.790|
;;;1193     }
;;;1194     else
;;;1195     {
;;;1196       RCC->APB2RSTR &= ~RCC_APB2Periph;
000316  4a18              LDR      r2,|L1.888|
000318  68d2              LDR      r2,[r2,#0xc]
00031a  4382              BICS     r2,r2,r0
00031c  4b16              LDR      r3,|L1.888|
00031e  60da              STR      r2,[r3,#0xc]
                  |L1.800|
;;;1197     }
;;;1198   }
000320  4770              BX       lr
;;;1199   
                          ENDP

                  RCC_APB1PeriphResetCmd PROC
;;;1215     */
;;;1216   void RCC_APB1PeriphResetCmd(uint32_t RCC_APB1Periph, FunctionalState NewState)
000322  b129              CBZ      r1,|L1.816|
;;;1217   {
;;;1218     /* Check the parameters */
;;;1219     assert_param(IS_RCC_APB1_PERIPH(RCC_APB1Periph));
;;;1220     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1221     if (NewState != DISABLE)
;;;1222     {
;;;1223       RCC->APB1RSTR |= RCC_APB1Periph;
000324  4a14              LDR      r2,|L1.888|
000326  6912              LDR      r2,[r2,#0x10]
000328  4302              ORRS     r2,r2,r0
00032a  4b13              LDR      r3,|L1.888|
00032c  611a              STR      r2,[r3,#0x10]
00032e  e004              B        |L1.826|
                  |L1.816|
;;;1224     }
;;;1225     else
;;;1226     {
;;;1227       RCC->APB1RSTR &= ~RCC_APB1Periph;
000330  4a11              LDR      r2,|L1.888|
000332  6912              LDR      r2,[r2,#0x10]
000334  4382              BICS     r2,r2,r0
000336  4b10              LDR      r3,|L1.888|
000338  611a              STR      r2,[r3,#0x10]
                  |L1.826|
;;;1228     }
;;;1229   }
00033a  4770              BX       lr
;;;1230   
                          ENDP

                  RCC_BackupResetCmd PROC
;;;1236     */
;;;1237   void RCC_BackupResetCmd(FunctionalState NewState)
00033c  4914              LDR      r1,|L1.912|
;;;1238   {
;;;1239     /* Check the parameters */
;;;1240     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1241     *(__IO uint32_t *) BDCR_BDRST_BB = (uint32_t)NewState;
00033e  3940              SUBS     r1,r1,#0x40
000340  6008              STR      r0,[r1,#0]
;;;1242   }
000342  4770              BX       lr
;;;1243   
                          ENDP

                  RCC_ClockSecuritySystemCmd PROC
;;;1249     */
;;;1250   void RCC_ClockSecuritySystemCmd(FunctionalState NewState)
000344  490f              LDR      r1,|L1.900|
;;;1251   {
;;;1252     /* Check the parameters */
;;;1253     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1254     *(__IO uint32_t *) CR_CSSON_BB = (uint32_t)NewState;
000346  64c8              STR      r0,[r1,#0x4c]
;;;1255   }
000348  4770              BX       lr
;;;1256   
                          ENDP

                  RCC_MCOConfig PROC
;;;1281     */
;;;1282   void RCC_MCOConfig(uint8_t RCC_MCO)
00034a  490b              LDR      r1,|L1.888|
;;;1283   {
;;;1284     /* Check the parameters */
;;;1285     assert_param(IS_RCC_MCO(RCC_MCO));
;;;1286   
;;;1287     /* Perform Byte access to MCO bits to select the MCO source */
;;;1288     *(__IO uint8_t *) CFGR_BYTE4_ADDRESS = RCC_MCO;
00034c  71c8              STRB     r0,[r1,#7]
;;;1289   }
00034e  4770              BX       lr
;;;1290   
                          ENDP

                  RCC_ClearFlag PROC
;;;1370     */
;;;1371   void RCC_ClearFlag(void)
000350  4809              LDR      r0,|L1.888|
;;;1372   {
;;;1373     /* Set RMVF bit to clear the reset flags */
;;;1374     RCC->CSR |= CSR_RMVF_Set;
000352  6a40              LDR      r0,[r0,#0x24]
000354  f0407080          ORR      r0,r0,#0x1000000
000358  4907              LDR      r1,|L1.888|
00035a  6248              STR      r0,[r1,#0x24]
;;;1375   }
00035c  4770              BX       lr
;;;1376   
                          ENDP

                  RCC_GetITStatus PROC
;;;1401     */
;;;1402   ITStatus RCC_GetITStatus(uint8_t RCC_IT)
00035e  4601              MOV      r1,r0
;;;1403   {
;;;1404     ITStatus bitstatus = RESET;
000360  2000              MOVS     r0,#0
;;;1405     /* Check the parameters */
;;;1406     assert_param(IS_RCC_GET_IT(RCC_IT));
;;;1407   
;;;1408     /* Check the status of the specified RCC interrupt */
;;;1409     if ((RCC->CIR & RCC_IT) != (uint32_t)RESET)
000362  4a05              LDR      r2,|L1.888|
000364  6892              LDR      r2,[r2,#8]
000366  420a              TST      r2,r1
000368  d001              BEQ      |L1.878|
;;;1410     {
;;;1411       bitstatus = SET;
00036a  2001              MOVS     r0,#1
00036c  e000              B        |L1.880|
                  |L1.878|
;;;1412     }
;;;1413     else
;;;1414     {
;;;1415       bitstatus = RESET;
00036e  2000              MOVS     r0,#0
                  |L1.880|
;;;1416     }
;;;1417   
;;;1418     /* Return the RCC_IT status */
;;;1419     return  bitstatus;
;;;1420   }
000370  4770              BX       lr
;;;1421   
                          ENDP

                  RCC_ClearITPendingBit PROC
;;;1447     */
;;;1448   void RCC_ClearITPendingBit(uint8_t RCC_IT)
000372  4901              LDR      r1,|L1.888|
;;;1449   {
;;;1450     /* Check the parameters */
;;;1451     assert_param(IS_RCC_CLEAR_IT(RCC_IT));
;;;1452   
;;;1453     /* Perform Byte access to RCC_CIR[23:16] bits to clear the selected interrupt
;;;1454        pending bits */
;;;1455     *(__IO uint8_t *) CIR_BYTE3_ADDRESS = RCC_IT;
000374  7288              STRB     r0,[r1,#0xa]
;;;1456   }
000376  4770              BX       lr
;;;1457   
                          ENDP

                  |L1.888|
                          DCD      0x40021000
                  |L1.892|
                          DCD      0xf8ff0000
                  |L1.896|
                          DCD      0xfef6ffff
                  |L1.900|
                          DCD      0x42420000
                  |L1.904|
                          DCD      0x424200d8
                  |L1.908|
                          DCD      0x40021020
                  |L1.912|
                          DCD      0x42420480
                  |L1.916|
                          DCD      0x007a1200
                  |L1.920|
                          DCD      0x003d0900
                  |L1.924|
                          DCD      APBAHBPrescTable
                  |L1.928|
                          DCD      ADCPrescTable

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

                  APBAHBPrescTable
000000  00000000          DCB      0x00,0x00,0x00,0x00
000004  01020304          DCB      0x01,0x02,0x03,0x04
000008  01020304          DCB      0x01,0x02,0x03,0x04
00000c  06070809          DCB      0x06,0x07,0x08,0x09
                  ADCPrescTable
000010  02040608          DCB      0x02,0x04,0x06,0x08
