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

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

                  ADC_AnalogWatchdogCmd PROC
;;;454      */
;;;455    void ADC_AnalogWatchdogCmd(ADC_TypeDef* ADCx, uint32_t ADC_AnalogWatchdog)
000000  460a              MOV      r2,r1
;;;456    {
;;;457      uint32_t tmpreg = 0;
000002  2100              MOVS     r1,#0
;;;458      /* Check the parameters */
;;;459      assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;460      assert_param(IS_ADC_ANALOG_WATCHDOG(ADC_AnalogWatchdog));
;;;461      
;;;462      /* Get the old register value */
;;;463      tmpreg = ADCx->CR1;
000004  6841              LDR      r1,[r0,#4]
;;;464      
;;;465      /* Clear AWDEN, JAWDEN and AWDSGL bits */
;;;466      tmpreg &= CR1_AWDMode_RESET;
000006  4b02              LDR      r3,|L1.16|
000008  4019              ANDS     r1,r1,r3
;;;467      
;;;468      /* Set the analog watchdog enable mode */
;;;469      tmpreg |= ADC_AnalogWatchdog;
00000a  4311              ORRS     r1,r1,r2
;;;470      
;;;471      /* Store the new register value */
;;;472      ADCx->CR1 = tmpreg;
00000c  6041              STR      r1,[r0,#4]
;;;473    }
00000e  4770              BX       lr
;;;474    
                          ENDP

                  |L1.16|
                          DCD      0xff3ffdff

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

                  ADC_AnalogWatchdogSingleChannelConfig PROC
;;;524      */
;;;525    void ADC_AnalogWatchdogSingleChannelConfig(ADC_TypeDef* ADCx, uint8_t ADC_Channel)
000000  460a              MOV      r2,r1
;;;526    {
;;;527      uint32_t tmpreg = 0;
000002  2100              MOVS     r1,#0
;;;528      /* Check the parameters */
;;;529      assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;530      assert_param(IS_ADC_CHANNEL(ADC_Channel));
;;;531      
;;;532      /* Get the old register value */
;;;533      tmpreg = ADCx->CR1;
000004  6841              LDR      r1,[r0,#4]
;;;534      
;;;535      /* Clear the Analog watchdog channel select bits */
;;;536      tmpreg &= CR1_AWDCH_RESET;
000006  f021011f          BIC      r1,r1,#0x1f
;;;537      
;;;538      /* Set the Analog watchdog channel */
;;;539      tmpreg |= ADC_Channel;
00000a  4311              ORRS     r1,r1,r2
;;;540      
;;;541      /* Store the new register value */
;;;542      ADCx->CR1 = tmpreg;
00000c  6041              STR      r1,[r0,#4]
;;;543    }
00000e  4770              BX       lr
;;;544    /**
                          ENDP


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

                  ADC_AnalogWatchdogThresholdsConfig PROC
;;;483      */
;;;484    void ADC_AnalogWatchdogThresholdsConfig(ADC_TypeDef* ADCx, uint16_t HighThreshold,
000000  6241              STR      r1,[r0,#0x24]
;;;485                                            uint16_t LowThreshold)
;;;486    {
;;;487      /* Check the parameters */
;;;488      assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;489      assert_param(IS_ADC_THRESHOLD(HighThreshold));
;;;490      assert_param(IS_ADC_THRESHOLD(LowThreshold));
;;;491      
;;;492      /* Set the ADCx high threshold */
;;;493      ADCx->HTR = HighThreshold;
;;;494      
;;;495      /* Set the ADCx low threshold */
;;;496      ADCx->LTR = LowThreshold;
000002  6282              STR      r2,[r0,#0x28]
;;;497    }
000004  4770              BX       lr
;;;498    
                          ENDP


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

                  ADC_AutoInjectedConvCmd PROC
;;;1422     */
;;;1423   void ADC_AutoInjectedConvCmd(ADC_TypeDef* ADCx, FunctionalState NewState)
000000  b121              CBZ      r1,|L4.12|
;;;1424   {
;;;1425     /* Check the parameters */
;;;1426     assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;1427     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1428     if (NewState != DISABLE)
;;;1429     {
;;;1430       /* Enable the selected ADC automatic injected group conversion */
;;;1431       ADCx->CR1 |= (uint32_t)ADC_CR1_JAUTO;
000002  6842              LDR      r2,[r0,#4]
000004  f4426280          ORR      r2,r2,#0x400
000008  6042              STR      r2,[r0,#4]
00000a  e003              B        |L4.20|
                  |L4.12|
;;;1432     }
;;;1433     else
;;;1434     {
;;;1435       /* Disable the selected ADC automatic injected group conversion */
;;;1436       ADCx->CR1 &= (uint32_t)(~ADC_CR1_JAUTO);
00000c  6842              LDR      r2,[r0,#4]
00000e  f4226280          BIC      r2,r2,#0x400
000012  6042              STR      r2,[r0,#4]
                  |L4.20|
;;;1437     }
;;;1438   }
000014  4770              BX       lr
;;;1439   
                          ENDP


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

                  ADC_ClearFlag PROC
;;;1655     */
;;;1656   void ADC_ClearFlag(ADC_TypeDef* ADCx, uint8_t ADC_FLAG)
000000  43ca              MVNS     r2,r1
;;;1657   {
;;;1658     /* Check the parameters */
;;;1659     assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;1660     assert_param(IS_ADC_CLEAR_FLAG(ADC_FLAG));
;;;1661   
;;;1662     /* Clear the selected ADC flags */
;;;1663     ADCx->SR = ~(uint32_t)ADC_FLAG;
000002  6002              STR      r2,[r0,#0]
;;;1664   }
000004  4770              BX       lr
;;;1665   
                          ENDP


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

                  ADC_ClearITPendingBit PROC
;;;1717     */
;;;1718   void ADC_ClearITPendingBit(ADC_TypeDef* ADCx, uint16_t ADC_IT)
000000  2200              MOVS     r2,#0
;;;1719   {
;;;1720     uint8_t itmask = 0;
;;;1721     /* Check the parameters */
;;;1722     assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;1723     assert_param(IS_ADC_IT(ADC_IT)); 
;;;1724     /* Get the ADC IT index */
;;;1725     itmask = (uint8_t)(ADC_IT >> 8);
000002  120a              ASRS     r2,r1,#8
;;;1726     /* Clear the selected ADC interrupt pending bits */
;;;1727     ADCx->SR = ~(uint32_t)itmask;
000004  43d3              MVNS     r3,r2
000006  6003              STR      r3,[r0,#0]
;;;1728   }                    
000008  4770              BX       lr
;;;1729   /**
                          ENDP


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

                  ADC_Cmd PROC
;;;398      */
;;;399    void ADC_Cmd(ADC_TypeDef* ADCx, FunctionalState NewState)
000000  b121              CBZ      r1,|L7.12|
;;;400    {
;;;401      /* Check the parameters */
;;;402      assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;403      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;404      if (NewState != DISABLE)
;;;405      {
;;;406        /* Set the ADON bit to wake up the ADC from power down mode */
;;;407        ADCx->CR2 |= (uint32_t)ADC_CR2_ADON;
000002  6882              LDR      r2,[r0,#8]
000004  f0420201          ORR      r2,r2,#1
000008  6082              STR      r2,[r0,#8]
00000a  e003              B        |L7.20|
                  |L7.12|
;;;408      }
;;;409      else
;;;410      {
;;;411        /* Disable the selected ADC peripheral */
;;;412        ADCx->CR2 &= (uint32_t)(~ADC_CR2_ADON);
00000c  6882              LDR      r2,[r0,#8]
00000e  f0220201          BIC      r2,r2,#1
000012  6082              STR      r2,[r0,#8]
                  |L7.20|
;;;413      }
;;;414    }
000014  4770              BX       lr
;;;415    /**
                          ENDP


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

                  ADC_CommonInit PROC
;;;340      */
;;;341    void ADC_CommonInit(ADC_CommonInitTypeDef* ADC_CommonInitStruct)
000000  2100              MOVS     r1,#0
;;;342    {
;;;343      uint32_t tmpreg1 = 0;
;;;344      /* Check the parameters */
;;;345      assert_param(IS_ADC_MODE(ADC_CommonInitStruct->ADC_Mode));
;;;346      assert_param(IS_ADC_PRESCALER(ADC_CommonInitStruct->ADC_Prescaler));
;;;347      assert_param(IS_ADC_DMA_ACCESS_MODE(ADC_CommonInitStruct->ADC_DMAAccessMode));
;;;348      assert_param(IS_ADC_SAMPLING_DELAY(ADC_CommonInitStruct->ADC_TwoSamplingDelay));
;;;349      /*---------------------------- ADC CCR Configuration -----------------*/
;;;350      /* Get the ADC CCR value */
;;;351      tmpreg1 = ADC->CCR;
000002  4a08              LDR      r2,|L8.36|
000004  6811              LDR      r1,[r2,#0]
;;;352      
;;;353      /* Clear MULTI, DELAY, DMA and ADCPRE bits */
;;;354      tmpreg1 &= CR_CLEAR_MASK;
000006  4a08              LDR      r2,|L8.40|
000008  4011              ANDS     r1,r1,r2
;;;355      
;;;356      /* Configure ADCx: Multi mode, Delay between two sampling time, ADC prescaler,
;;;357         and DMA access mode for multimode */
;;;358      /* Set MULTI bits according to ADC_Mode value */
;;;359      /* Set ADCPRE bits according to ADC_Prescaler value */
;;;360      /* Set DMA bits according to ADC_DMAAccessMode value */
;;;361      /* Set DELAY bits according to ADC_TwoSamplingDelay value */    
;;;362      tmpreg1 |= (uint32_t)(ADC_CommonInitStruct->ADC_Mode | 
00000a  e9d02300          LDRD     r2,r3,[r0,#0]
00000e  431a              ORRS     r2,r2,r3
000010  6883              LDR      r3,[r0,#8]
000012  431a              ORRS     r2,r2,r3
000014  68c3              LDR      r3,[r0,#0xc]
000016  431a              ORRS     r2,r2,r3
000018  4311              ORRS     r1,r1,r2
;;;363                            ADC_CommonInitStruct->ADC_Prescaler | 
;;;364                            ADC_CommonInitStruct->ADC_DMAAccessMode | 
;;;365                            ADC_CommonInitStruct->ADC_TwoSamplingDelay);
;;;366                            
;;;367      /* Write to ADC CCR */
;;;368      ADC->CCR = tmpreg1;
00001a  4a04              LDR      r2,|L8.44|
00001c  f8c21304          STR      r1,[r2,#0x304]
;;;369    }
000020  4770              BX       lr
;;;370    
                          ENDP

000022  0000              DCW      0x0000
                  |L8.36|
                          DCD      0x40012304
                  |L8.40|
                          DCD      0xfffc30e0
                  |L8.44|
                          DCD      0x40012000

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

                  ADC_CommonStructInit PROC
;;;376      */
;;;377    void ADC_CommonStructInit(ADC_CommonInitTypeDef* ADC_CommonInitStruct)
000000  2100              MOVS     r1,#0
;;;378    {
;;;379      /* Initialize the ADC_Mode member */
;;;380      ADC_CommonInitStruct->ADC_Mode = ADC_Mode_Independent;
000002  6001              STR      r1,[r0,#0]
;;;381    
;;;382      /* initialize the ADC_Prescaler member */
;;;383      ADC_CommonInitStruct->ADC_Prescaler = ADC_Prescaler_Div2;
000004  6041              STR      r1,[r0,#4]
;;;384    
;;;385      /* Initialize the ADC_DMAAccessMode member */
;;;386      ADC_CommonInitStruct->ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
000006  6081              STR      r1,[r0,#8]
;;;387    
;;;388      /* Initialize the ADC_TwoSamplingDelay member */
;;;389      ADC_CommonInitStruct->ADC_TwoSamplingDelay = ADC_TwoSamplingDelay_5Cycles;
000008  60c1              STR      r1,[r0,#0xc]
;;;390    }
00000a  4770              BX       lr
;;;391    
                          ENDP


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

                  ADC_ContinuousModeCmd PROC
;;;903      */
;;;904    void ADC_ContinuousModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState)
000000  b121              CBZ      r1,|L10.12|
;;;905    {
;;;906      /* Check the parameters */
;;;907      assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;908      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;909      
;;;910      if (NewState != DISABLE)
;;;911      {
;;;912        /* Enable the selected ADC continuous conversion mode */
;;;913        ADCx->CR2 |= (uint32_t)ADC_CR2_CONT;
000002  6882              LDR      r2,[r0,#8]
000004  f0420202          ORR      r2,r2,#2
000008  6082              STR      r2,[r0,#8]
00000a  e003              B        |L10.20|
                  |L10.12|
;;;914      }
;;;915      else
;;;916      {
;;;917        /* Disable the selected ADC continuous conversion mode */
;;;918        ADCx->CR2 &= (uint32_t)(~ADC_CR2_CONT);
00000c  6882              LDR      r2,[r0,#8]
00000e  f0220202          BIC      r2,r2,#2
000012  6082              STR      r2,[r0,#8]
                  |L10.20|
;;;919      }
;;;920    }
000014  4770              BX       lr
;;;921    
                          ENDP


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

                  ADC_DMACmd PROC
;;;1051     */
;;;1052   void ADC_DMACmd(ADC_TypeDef* ADCx, FunctionalState NewState)
000000  b121              CBZ      r1,|L11.12|
;;;1053   {
;;;1054     /* Check the parameters */
;;;1055     assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;1056     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1057     if (NewState != DISABLE)
;;;1058     {
;;;1059       /* Enable the selected ADC DMA request */
;;;1060       ADCx->CR2 |= (uint32_t)ADC_CR2_DMA;
000002  6882              LDR      r2,[r0,#8]
000004  f4427280          ORR      r2,r2,#0x100
000008  6082              STR      r2,[r0,#8]
00000a  e003              B        |L11.20|
                  |L11.12|
;;;1061     }
;;;1062     else
;;;1063     {
;;;1064       /* Disable the selected ADC DMA request */
;;;1065       ADCx->CR2 &= (uint32_t)(~ADC_CR2_DMA);
00000c  6882              LDR      r2,[r0,#8]
00000e  f4227280          BIC      r2,r2,#0x100
000012  6082              STR      r2,[r0,#8]
                  |L11.20|
;;;1066     }
;;;1067   }
000014  4770              BX       lr
;;;1068   
                          ENDP


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

                  ADC_DMARequestAfterLastTransferCmd PROC
;;;1075     */
;;;1076   void ADC_DMARequestAfterLastTransferCmd(ADC_TypeDef* ADCx, FunctionalState NewState)
000000  b121              CBZ      r1,|L12.12|
;;;1077   {
;;;1078     /* Check the parameters */
;;;1079     assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;1080     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1081     if (NewState != DISABLE)
;;;1082     {
;;;1083       /* Enable the selected ADC DMA request after last transfer */
;;;1084       ADCx->CR2 |= (uint32_t)ADC_CR2_DDS;
000002  6882              LDR      r2,[r0,#8]
000004  f4427200          ORR      r2,r2,#0x200
000008  6082              STR      r2,[r0,#8]
00000a  e003              B        |L12.20|
                  |L12.12|
;;;1085     }
;;;1086     else
;;;1087     {
;;;1088       /* Disable the selected ADC DMA request after last transfer */
;;;1089       ADCx->CR2 &= (uint32_t)(~ADC_CR2_DDS);
00000c  6882              LDR      r2,[r0,#8]
00000e  f4227200          BIC      r2,r2,#0x200
000012  6082              STR      r2,[r0,#8]
                  |L12.20|
;;;1090     }
;;;1091   }
000014  4770              BX       lr
;;;1092   
                          ENDP


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

                  ADC_DeInit PROC
;;;212      */
;;;213    void ADC_DeInit(void)
000000  b510              PUSH     {r4,lr}
;;;214    {
;;;215      /* Enable all ADCs reset state */
;;;216      RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC, ENABLE);
000002  2101              MOVS     r1,#1
000004  0208              LSLS     r0,r1,#8
000006  f7fffffe          BL       RCC_APB2PeriphResetCmd
;;;217      
;;;218      /* Release all ADCs from reset state */
;;;219      RCC_APB2PeriphResetCmd(RCC_APB2Periph_ADC, DISABLE);
00000a  2100              MOVS     r1,#0
00000c  f44f7080          MOV      r0,#0x100
000010  f7fffffe          BL       RCC_APB2PeriphResetCmd
;;;220    }
000014  bd10              POP      {r4,pc}
;;;221    
                          ENDP


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

                  ADC_DiscModeChannelCountConfig PROC
;;;929      */
;;;930    void ADC_DiscModeChannelCountConfig(ADC_TypeDef* ADCx, uint8_t Number)
000000  b510              PUSH     {r4,lr}
;;;931    {
000002  460a              MOV      r2,r1
;;;932      uint32_t tmpreg1 = 0;
000004  2100              MOVS     r1,#0
;;;933      uint32_t tmpreg2 = 0;
000006  2300              MOVS     r3,#0
;;;934      
;;;935      /* Check the parameters */
;;;936      assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;937      assert_param(IS_ADC_REGULAR_DISC_NUMBER(Number));
;;;938      
;;;939      /* Get the old register value */
;;;940      tmpreg1 = ADCx->CR1;
000008  6841              LDR      r1,[r0,#4]
;;;941      
;;;942      /* Clear the old discontinuous mode channel count */
;;;943      tmpreg1 &= CR1_DISCNUM_RESET;
00000a  f4214160          BIC      r1,r1,#0xe000
;;;944      
;;;945      /* Set the discontinuous mode channel count */
;;;946      tmpreg2 = Number - 1;
00000e  1e53              SUBS     r3,r2,#1
;;;947      tmpreg1 |= tmpreg2 << 13;
000010  ea413143          ORR      r1,r1,r3,LSL #13
;;;948      
;;;949      /* Store the new register value */
;;;950      ADCx->CR1 = tmpreg1;
000014  6041              STR      r1,[r0,#4]
;;;951    }
000016  bd10              POP      {r4,pc}
;;;952    
                          ENDP


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

                  ADC_DiscModeCmd PROC
;;;961      */
;;;962    void ADC_DiscModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState)
000000  b121              CBZ      r1,|L15.12|
;;;963    {
;;;964      /* Check the parameters */
;;;965      assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;966      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;967      
;;;968      if (NewState != DISABLE)
;;;969      {
;;;970        /* Enable the selected ADC regular discontinuous mode */
;;;971        ADCx->CR1 |= (uint32_t)ADC_CR1_DISCEN;
000002  6842              LDR      r2,[r0,#4]
000004  f4426200          ORR      r2,r2,#0x800
000008  6042              STR      r2,[r0,#4]
00000a  e003              B        |L15.20|
                  |L15.12|
;;;972      }
;;;973      else
;;;974      {
;;;975        /* Disable the selected ADC regular discontinuous mode */
;;;976        ADCx->CR1 &= (uint32_t)(~ADC_CR1_DISCEN);
00000c  6842              LDR      r2,[r0,#4]
00000e  f4226200          BIC      r2,r2,#0x800
000012  6042              STR      r2,[r0,#4]
                  |L15.20|
;;;977      }
;;;978    }
000014  4770              BX       lr
;;;979    
                          ENDP


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

                  ADC_EOCOnEachRegularChannelCmd PROC
;;;878      */
;;;879    void ADC_EOCOnEachRegularChannelCmd(ADC_TypeDef* ADCx, FunctionalState NewState)
000000  b121              CBZ      r1,|L16.12|
;;;880    {
;;;881      /* Check the parameters */
;;;882      assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;883      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;884      
;;;885      if (NewState != DISABLE)
;;;886      {
;;;887        /* Enable the selected ADC EOC rising on each regular channel conversion */
;;;888        ADCx->CR2 |= (uint32_t)ADC_CR2_EOCS;
000002  6882              LDR      r2,[r0,#8]
000004  f4426280          ORR      r2,r2,#0x400
000008  6082              STR      r2,[r0,#8]
00000a  e003              B        |L16.20|
                  |L16.12|
;;;889      }
;;;890      else
;;;891      {
;;;892        /* Disable the selected ADC EOC rising on each regular channel conversion */
;;;893        ADCx->CR2 &= (uint32_t)(~ADC_CR2_EOCS);
00000c  6882              LDR      r2,[r0,#8]
00000e  f4226280          BIC      r2,r2,#0x400
000012  6082              STR      r2,[r0,#8]
                  |L16.20|
;;;894      }
;;;895    }
000014  4770              BX       lr
;;;896    
                          ENDP


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

                  ADC_ExternalTrigInjectedConvConfig PROC
;;;1325     */
;;;1326   void ADC_ExternalTrigInjectedConvConfig(ADC_TypeDef* ADCx, uint32_t ADC_ExternalTrigInjecConv)
000000  460a              MOV      r2,r1
;;;1327   {
;;;1328     uint32_t tmpreg = 0;
000002  2100              MOVS     r1,#0
;;;1329     /* Check the parameters */
;;;1330     assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;1331     assert_param(IS_ADC_EXT_INJEC_TRIG(ADC_ExternalTrigInjecConv));
;;;1332     
;;;1333     /* Get the old register value */
;;;1334     tmpreg = ADCx->CR2;
000004  6881              LDR      r1,[r0,#8]
;;;1335     
;;;1336     /* Clear the old external event selection for injected group */
;;;1337     tmpreg &= CR2_JEXTSEL_RESET;
000006  f4212170          BIC      r1,r1,#0xf0000
;;;1338     
;;;1339     /* Set the external event selection for injected group */
;;;1340     tmpreg |= ADC_ExternalTrigInjecConv;
00000a  4311              ORRS     r1,r1,r2
;;;1341     
;;;1342     /* Store the new register value */
;;;1343     ADCx->CR2 = tmpreg;
00000c  6081              STR      r1,[r0,#8]
;;;1344   }
00000e  4770              BX       lr
;;;1345   
                          ENDP


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

                  ADC_ExternalTrigInjectedConvEdgeConfig PROC
;;;1359     */
;;;1360   void ADC_ExternalTrigInjectedConvEdgeConfig(ADC_TypeDef* ADCx, uint32_t ADC_ExternalTrigInjecConvEdge)
000000  460a              MOV      r2,r1
;;;1361   {
;;;1362     uint32_t tmpreg = 0;
000002  2100              MOVS     r1,#0
;;;1363     /* Check the parameters */
;;;1364     assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;1365     assert_param(IS_ADC_EXT_INJEC_TRIG_EDGE(ADC_ExternalTrigInjecConvEdge));
;;;1366     /* Get the old register value */
;;;1367     tmpreg = ADCx->CR2;
000004  6881              LDR      r1,[r0,#8]
;;;1368     /* Clear the old external trigger edge for injected group */
;;;1369     tmpreg &= CR2_JEXTEN_RESET;
000006  f4211140          BIC      r1,r1,#0x300000
;;;1370     /* Set the new external trigger edge for injected group */
;;;1371     tmpreg |= ADC_ExternalTrigInjecConvEdge;
00000a  4311              ORRS     r1,r1,r2
;;;1372     /* Store the new register value */
;;;1373     ADCx->CR2 = tmpreg;
00000c  6081              STR      r1,[r0,#8]
;;;1374   }
00000e  4770              BX       lr
;;;1375   
                          ENDP


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

                  ADC_GetConversionValue PROC
;;;984      */
;;;985    uint16_t ADC_GetConversionValue(ADC_TypeDef* ADCx)
000000  4601              MOV      r1,r0
;;;986    {
;;;987      /* Check the parameters */
;;;988      assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;989      
;;;990      /* Return the selected ADC conversion value */
;;;991      return (uint16_t) ADCx->DR;
000002  6cc8              LDR      r0,[r1,#0x4c]
000004  b280              UXTH     r0,r0
;;;992    }
000006  4770              BX       lr
;;;993    
                          ENDP


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

                  ADC_GetFlagStatus PROC
;;;1620     */
;;;1621   FlagStatus ADC_GetFlagStatus(ADC_TypeDef* ADCx, uint8_t ADC_FLAG)
000000  4602              MOV      r2,r0
;;;1622   {
;;;1623     FlagStatus bitstatus = RESET;
000002  2000              MOVS     r0,#0
;;;1624     /* Check the parameters */
;;;1625     assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;1626     assert_param(IS_ADC_GET_FLAG(ADC_FLAG));
;;;1627   
;;;1628     /* Check the status of the specified ADC flag */
;;;1629     if ((ADCx->SR & ADC_FLAG) != (uint8_t)RESET)
000004  6813              LDR      r3,[r2,#0]
000006  400b              ANDS     r3,r3,r1
000008  b10b              CBZ      r3,|L20.14|
;;;1630     {
;;;1631       /* ADC_FLAG is set */
;;;1632       bitstatus = SET;
00000a  2001              MOVS     r0,#1
00000c  e000              B        |L20.16|
                  |L20.14|
;;;1633     }
;;;1634     else
;;;1635     {
;;;1636       /* ADC_FLAG is reset */
;;;1637       bitstatus = RESET;
00000e  2000              MOVS     r0,#0
                  |L20.16|
;;;1638     }
;;;1639     /* Return the ADC_FLAG status */
;;;1640     return  bitstatus;
;;;1641   }
000010  4770              BX       lr
;;;1642   
                          ENDP


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

                  ADC_GetITStatus PROC
;;;1676     */
;;;1677   ITStatus ADC_GetITStatus(ADC_TypeDef* ADCx, uint16_t ADC_IT)
000000  b570              PUSH     {r4-r6,lr}
;;;1678   {
000002  4602              MOV      r2,r0
;;;1679     ITStatus bitstatus = RESET;
000004  2000              MOVS     r0,#0
;;;1680     uint32_t itmask = 0, enablestatus = 0;
000006  2300              MOVS     r3,#0
000008  2400              MOVS     r4,#0
;;;1681   
;;;1682     /* Check the parameters */
;;;1683     assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;1684     assert_param(IS_ADC_IT(ADC_IT));
;;;1685   
;;;1686     /* Get the ADC IT index */
;;;1687     itmask = ADC_IT >> 8;
00000a  120b              ASRS     r3,r1,#8
;;;1688   
;;;1689     /* Get the ADC_IT enable bit status */
;;;1690     enablestatus = (ADCx->CR1 & ((uint32_t)0x01 << (uint8_t)ADC_IT)) ;
00000c  6855              LDR      r5,[r2,#4]
00000e  2601              MOVS     r6,#1
000010  408e              LSLS     r6,r6,r1
000012  ea050406          AND      r4,r5,r6
;;;1691   
;;;1692     /* Check the status of the specified ADC interrupt */
;;;1693     if (((ADCx->SR & itmask) != (uint32_t)RESET) && enablestatus)
000016  6815              LDR      r5,[r2,#0]
000018  401d              ANDS     r5,r5,r3
00001a  b115              CBZ      r5,|L21.34|
00001c  b10c              CBZ      r4,|L21.34|
;;;1694     {
;;;1695       /* ADC_IT is set */
;;;1696       bitstatus = SET;
00001e  2001              MOVS     r0,#1
000020  e000              B        |L21.36|
                  |L21.34|
;;;1697     }
;;;1698     else
;;;1699     {
;;;1700       /* ADC_IT is reset */
;;;1701       bitstatus = RESET;
000022  2000              MOVS     r0,#0
                  |L21.36|
;;;1702     }
;;;1703     /* Return the ADC_IT status */
;;;1704     return  bitstatus;
;;;1705   }
000024  bd70              POP      {r4-r6,pc}
;;;1706   
                          ENDP


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

                  ADC_GetInjectedConversionValue PROC
;;;1476     */
;;;1477   uint16_t ADC_GetInjectedConversionValue(ADC_TypeDef* ADCx, uint8_t ADC_InjectedChannel)
000000  b508              PUSH     {r3,lr}
;;;1478   {
000002  4602              MOV      r2,r0
;;;1479     __IO uint32_t tmp = 0;
000004  2000              MOVS     r0,#0
000006  9000              STR      r0,[sp,#0]
;;;1480     
;;;1481     /* Check the parameters */
;;;1482     assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;1483     assert_param(IS_ADC_INJECTED_CHANNEL(ADC_InjectedChannel));
;;;1484   
;;;1485     tmp = (uint32_t)ADCx;
000008  9200              STR      r2,[sp,#0]
;;;1486     tmp += ADC_InjectedChannel + JDR_OFFSET;
00000a  f1010028          ADD      r0,r1,#0x28
00000e  9b00              LDR      r3,[sp,#0]
000010  4418              ADD      r0,r0,r3
000012  9000              STR      r0,[sp,#0]
;;;1487     
;;;1488     /* Returns the selected injected channel conversion data value */
;;;1489     return (uint16_t) (*(__IO uint32_t*)  tmp); 
000014  9800              LDR      r0,[sp,#0]
000016  6800              LDR      r0,[r0,#0]
000018  b280              UXTH     r0,r0
;;;1490   }
00001a  bd08              POP      {r3,pc}
;;;1491   /**
                          ENDP


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

                  ADC_GetMultiModeConversionValue PROC
;;;1005     */
;;;1006   uint32_t ADC_GetMultiModeConversionValue(void)
000000  4801              LDR      r0,|L23.8|
;;;1007   {
;;;1008     /* Return the multi mode conversion value */
;;;1009     return (*(__IO uint32_t *) CDR_ADDRESS);
000002  6800              LDR      r0,[r0,#0]
;;;1010   }
000004  4770              BX       lr
;;;1011   /**
                          ENDP

000006  0000              DCW      0x0000
                  |L23.8|
                          DCD      0x40012308

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

                  ADC_GetSoftwareStartConvStatus PROC
;;;848      */
;;;849    FlagStatus ADC_GetSoftwareStartConvStatus(ADC_TypeDef* ADCx)
000000  4601              MOV      r1,r0
;;;850    {
;;;851      FlagStatus bitstatus = RESET;
000002  2000              MOVS     r0,#0
;;;852      /* Check the parameters */
;;;853      assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;854      
;;;855      /* Check the status of SWSTART bit */
;;;856      if ((ADCx->CR2 & ADC_CR2_SWSTART) != (uint32_t)RESET)
000004  688a              LDR      r2,[r1,#8]
000006  f0024280          AND      r2,r2,#0x40000000
00000a  b10a              CBZ      r2,|L24.16|
;;;857      {
;;;858        /* SWSTART bit is set */
;;;859        bitstatus = SET;
00000c  2001              MOVS     r0,#1
00000e  e000              B        |L24.18|
                  |L24.16|
;;;860      }
;;;861      else
;;;862      {
;;;863        /* SWSTART bit is reset */
;;;864        bitstatus = RESET;
000010  2000              MOVS     r0,#0
                  |L24.18|
;;;865      }
;;;866      
;;;867      /* Return the SWSTART bit status */
;;;868      return  bitstatus;
;;;869    }
000012  4770              BX       lr
;;;870    
                          ENDP


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

                  ADC_GetSoftwareStartInjectedConvCmdStatus PROC
;;;1393     */
;;;1394   FlagStatus ADC_GetSoftwareStartInjectedConvCmdStatus(ADC_TypeDef* ADCx)
000000  4601              MOV      r1,r0
;;;1395   {
;;;1396     FlagStatus bitstatus = RESET;
000002  2000              MOVS     r0,#0
;;;1397     /* Check the parameters */
;;;1398     assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;1399     
;;;1400     /* Check the status of JSWSTART bit */
;;;1401     if ((ADCx->CR2 & ADC_CR2_JSWSTART) != (uint32_t)RESET)
000004  688a              LDR      r2,[r1,#8]
000006  f4020280          AND      r2,r2,#0x400000
00000a  b10a              CBZ      r2,|L25.16|
;;;1402     {
;;;1403       /* JSWSTART bit is set */
;;;1404       bitstatus = SET;
00000c  2001              MOVS     r0,#1
00000e  e000              B        |L25.18|
                  |L25.16|
;;;1405     }
;;;1406     else
;;;1407     {
;;;1408       /* JSWSTART bit is reset */
;;;1409       bitstatus = RESET;
000010  2000              MOVS     r0,#0
                  |L25.18|
;;;1410     }
;;;1411     /* Return the JSWSTART bit status */
;;;1412     return  bitstatus;
;;;1413   }
000012  4770              BX       lr
;;;1414   
                          ENDP


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

                  ADC_ITConfig PROC
;;;1583     */
;;;1584   void ADC_ITConfig(ADC_TypeDef* ADCx, uint16_t ADC_IT, FunctionalState NewState)  
000000  b510              PUSH     {r4,lr}
;;;1585   {
000002  460b              MOV      r3,r1
;;;1586     uint32_t itmask = 0;
000004  2100              MOVS     r1,#0
;;;1587     /* Check the parameters */
;;;1588     assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;1589     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1590     assert_param(IS_ADC_IT(ADC_IT)); 
;;;1591   
;;;1592     /* Get the ADC IT index */
;;;1593     itmask = (uint8_t)ADC_IT;
000006  b2d9              UXTB     r1,r3
;;;1594     itmask = (uint32_t)0x01 << itmask;    
000008  2401              MOVS     r4,#1
00000a  fa04f101          LSL      r1,r4,r1
;;;1595   
;;;1596     if (NewState != DISABLE)
00000e  b11a              CBZ      r2,|L26.24|
;;;1597     {
;;;1598       /* Enable the selected ADC interrupts */
;;;1599       ADCx->CR1 |= itmask;
000010  6844              LDR      r4,[r0,#4]
000012  430c              ORRS     r4,r4,r1
000014  6044              STR      r4,[r0,#4]
000016  e002              B        |L26.30|
                  |L26.24|
;;;1600     }
;;;1601     else
;;;1602     {
;;;1603       /* Disable the selected ADC interrupts */
;;;1604       ADCx->CR1 &= (~(uint32_t)itmask);
000018  6844              LDR      r4,[r0,#4]
00001a  438c              BICS     r4,r4,r1
00001c  6044              STR      r4,[r0,#4]
                  |L26.30|
;;;1605     }
;;;1606   }
00001e  bd10              POP      {r4,pc}
;;;1607   
                          ENDP


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

                  ADC_Init PROC
;;;234      */
;;;235    void ADC_Init(ADC_TypeDef* ADCx, ADC_InitTypeDef* ADC_InitStruct)
000000  b530              PUSH     {r4,r5,lr}
;;;236    {
000002  4602              MOV      r2,r0
;;;237      uint32_t tmpreg1 = 0;
000004  2000              MOVS     r0,#0
;;;238      uint8_t tmpreg2 = 0;
000006  2300              MOVS     r3,#0
;;;239      /* Check the parameters */
;;;240      assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;241      assert_param(IS_ADC_RESOLUTION(ADC_InitStruct->ADC_Resolution)); 
;;;242      assert_param(IS_FUNCTIONAL_STATE(ADC_InitStruct->ADC_ScanConvMode));
;;;243      assert_param(IS_FUNCTIONAL_STATE(ADC_InitStruct->ADC_ContinuousConvMode)); 
;;;244      assert_param(IS_ADC_EXT_TRIG_EDGE(ADC_InitStruct->ADC_ExternalTrigConvEdge)); 
;;;245      assert_param(IS_ADC_EXT_TRIG(ADC_InitStruct->ADC_ExternalTrigConv));    
;;;246      assert_param(IS_ADC_DATA_ALIGN(ADC_InitStruct->ADC_DataAlign)); 
;;;247      assert_param(IS_ADC_REGULAR_LENGTH(ADC_InitStruct->ADC_NbrOfConversion));
;;;248      
;;;249      /*---------------------------- ADCx CR1 Configuration -----------------*/
;;;250      /* Get the ADCx CR1 value */
;;;251      tmpreg1 = ADCx->CR1;
000008  6850              LDR      r0,[r2,#4]
;;;252      
;;;253      /* Clear RES and SCAN bits */
;;;254      tmpreg1 &= CR1_CLEAR_MASK;
00000a  4c10              LDR      r4,|L27.76|
00000c  4020              ANDS     r0,r0,r4
;;;255      
;;;256      /* Configure ADCx: scan conversion mode and resolution */
;;;257      /* Set SCAN bit according to ADC_ScanConvMode value */
;;;258      /* Set RES bit according to ADC_Resolution value */ 
;;;259      tmpreg1 |= (uint32_t)(((uint32_t)ADC_InitStruct->ADC_ScanConvMode << 8) | \
00000e  790d              LDRB     r5,[r1,#4]
000010  680c              LDR      r4,[r1,#0]
000012  ea442405          ORR      r4,r4,r5,LSL #8
000016  4320              ORRS     r0,r0,r4
;;;260                                       ADC_InitStruct->ADC_Resolution);
;;;261      /* Write to ADCx CR1 */
;;;262      ADCx->CR1 = tmpreg1;
000018  6050              STR      r0,[r2,#4]
;;;263      /*---------------------------- ADCx CR2 Configuration -----------------*/
;;;264      /* Get the ADCx CR2 value */
;;;265      tmpreg1 = ADCx->CR2;
00001a  6890              LDR      r0,[r2,#8]
;;;266      
;;;267      /* Clear CONT, ALIGN, EXTEN and EXTSEL bits */
;;;268      tmpreg1 &= CR2_CLEAR_MASK;
00001c  4c0c              LDR      r4,|L27.80|
00001e  4020              ANDS     r0,r0,r4
;;;269      
;;;270      /* Configure ADCx: external trigger event and edge, data alignment and 
;;;271         continuous conversion mode */
;;;272      /* Set ALIGN bit according to ADC_DataAlign value */
;;;273      /* Set EXTEN bits according to ADC_ExternalTrigConvEdge value */ 
;;;274      /* Set EXTSEL bits according to ADC_ExternalTrigConv value */
;;;275      /* Set CONT bit according to ADC_ContinuousConvMode value */
;;;276      tmpreg1 |= (uint32_t)(ADC_InitStruct->ADC_DataAlign | \
000020  e9d15403          LDRD     r5,r4,[r1,#0xc]
000024  432c              ORRS     r4,r4,r5
000026  688d              LDR      r5,[r1,#8]
000028  432c              ORRS     r4,r4,r5
00002a  794d              LDRB     r5,[r1,#5]
00002c  ea440445          ORR      r4,r4,r5,LSL #1
000030  4320              ORRS     r0,r0,r4
;;;277                            ADC_InitStruct->ADC_ExternalTrigConv | 
;;;278                            ADC_InitStruct->ADC_ExternalTrigConvEdge | \
;;;279                            ((uint32_t)ADC_InitStruct->ADC_ContinuousConvMode << 1));
;;;280                            
;;;281      /* Write to ADCx CR2 */
;;;282      ADCx->CR2 = tmpreg1;
000032  6090              STR      r0,[r2,#8]
;;;283      /*---------------------------- ADCx SQR1 Configuration -----------------*/
;;;284      /* Get the ADCx SQR1 value */
;;;285      tmpreg1 = ADCx->SQR1;
000034  6ad0              LDR      r0,[r2,#0x2c]
;;;286      
;;;287      /* Clear L bits */
;;;288      tmpreg1 &= SQR1_L_RESET;
000036  f4200070          BIC      r0,r0,#0xf00000
;;;289      
;;;290      /* Configure ADCx: regular channel sequence length */
;;;291      /* Set L bits according to ADC_NbrOfConversion value */
;;;292      tmpreg2 |= (uint8_t)(ADC_InitStruct->ADC_NbrOfConversion - (uint8_t)1);
00003a  7d0c              LDRB     r4,[r1,#0x14]
00003c  1e64              SUBS     r4,r4,#1
00003e  b2e4              UXTB     r4,r4
000040  4323              ORRS     r3,r3,r4
;;;293      tmpreg1 |= ((uint32_t)tmpreg2 << 20);
000042  ea405003          ORR      r0,r0,r3,LSL #20
;;;294      
;;;295      /* Write to ADCx SQR1 */
;;;296      ADCx->SQR1 = tmpreg1;
000046  62d0              STR      r0,[r2,#0x2c]
;;;297    }
000048  bd30              POP      {r4,r5,pc}
;;;298    
                          ENDP

00004a  0000              DCW      0x0000
                  |L27.76|
                          DCD      0xfcfffeff
                  |L27.80|
                          DCD      0xc0fff7fd

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

                  ADC_InjectedChannelConfig PROC
;;;1189     */
;;;1190   void ADC_InjectedChannelConfig(ADC_TypeDef* ADCx, uint8_t ADC_Channel, uint8_t Rank, uint8_t ADC_SampleTime)
000000  b5f0              PUSH     {r4-r7,lr}
;;;1191   {
000002  4604              MOV      r4,r0
000004  4615              MOV      r5,r2
;;;1192     uint32_t tmpreg1 = 0, tmpreg2 = 0, tmpreg3 = 0;
000006  2000              MOVS     r0,#0
000008  2200              MOVS     r2,#0
00000a  2600              MOVS     r6,#0
;;;1193     /* Check the parameters */
;;;1194     assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;1195     assert_param(IS_ADC_CHANNEL(ADC_Channel));
;;;1196     assert_param(IS_ADC_INJECTED_RANK(Rank));
;;;1197     assert_param(IS_ADC_SAMPLE_TIME(ADC_SampleTime));
;;;1198     /* if ADC_Channel_10 ... ADC_Channel_18 is selected */
;;;1199     if (ADC_Channel > ADC_Channel_9)
00000c  2909              CMP      r1,#9
00000e  dd11              BLE      |L28.52|
;;;1200     {
;;;1201       /* Get the old register value */
;;;1202       tmpreg1 = ADCx->SMPR1;
000010  68e0              LDR      r0,[r4,#0xc]
;;;1203       /* Calculate the mask to clear */
;;;1204       tmpreg2 = SMPR1_SMP_SET << (3*(ADC_Channel - 10));
000012  f1a1070a          SUB      r7,r1,#0xa
000016  eb070c47          ADD      r12,r7,r7,LSL #1
00001a  2707              MOVS     r7,#7
00001c  fa07f20c          LSL      r2,r7,r12
;;;1205       /* Clear the old sample time */
;;;1206       tmpreg1 &= ~tmpreg2;
000020  4390              BICS     r0,r0,r2
;;;1207       /* Calculate the mask to set */
;;;1208       tmpreg2 = (uint32_t)ADC_SampleTime << (3*(ADC_Channel - 10));
000022  f1a1070a          SUB      r7,r1,#0xa
000026  eb070747          ADD      r7,r7,r7,LSL #1
00002a  fa03f207          LSL      r2,r3,r7
;;;1209       /* Set the new sample time */
;;;1210       tmpreg1 |= tmpreg2;
00002e  4310              ORRS     r0,r0,r2
;;;1211       /* Store the new register value */
;;;1212       ADCx->SMPR1 = tmpreg1;
000030  60e0              STR      r0,[r4,#0xc]
000032  e00c              B        |L28.78|
                  |L28.52|
;;;1213     }
;;;1214     else /* ADC_Channel include in ADC_Channel_[0..9] */
;;;1215     {
;;;1216       /* Get the old register value */
;;;1217       tmpreg1 = ADCx->SMPR2;
000034  6920              LDR      r0,[r4,#0x10]
;;;1218       /* Calculate the mask to clear */
;;;1219       tmpreg2 = SMPR2_SMP_SET << (3 * ADC_Channel);
000036  eb010c41          ADD      r12,r1,r1,LSL #1
00003a  2707              MOVS     r7,#7
00003c  fa07f20c          LSL      r2,r7,r12
;;;1220       /* Clear the old sample time */
;;;1221       tmpreg1 &= ~tmpreg2;
000040  4390              BICS     r0,r0,r2
;;;1222       /* Calculate the mask to set */
;;;1223       tmpreg2 = (uint32_t)ADC_SampleTime << (3 * ADC_Channel);
000042  eb010741          ADD      r7,r1,r1,LSL #1
000046  fa03f207          LSL      r2,r3,r7
;;;1224       /* Set the new sample time */
;;;1225       tmpreg1 |= tmpreg2;
00004a  4310              ORRS     r0,r0,r2
;;;1226       /* Store the new register value */
;;;1227       ADCx->SMPR2 = tmpreg1;
00004c  6120              STR      r0,[r4,#0x10]
                  |L28.78|
;;;1228     }
;;;1229     /* Rank configuration */
;;;1230     /* Get the old register value */
;;;1231     tmpreg1 = ADCx->JSQR;
00004e  6ba0              LDR      r0,[r4,#0x38]
;;;1232     /* Get JL value: Number = JL+1 */
;;;1233     tmpreg3 =  (tmpreg1 & JSQR_JL_SET)>> 20;
000050  f3c05601          UBFX     r6,r0,#20,#2
;;;1234     /* Calculate the mask to clear: ((Rank-1)+(4-JL-1)) */
;;;1235     tmpreg2 = JSQR_JSQ_SET << (5 * (uint8_t)((Rank + 3) - (tmpreg3 + 1)));
000054  1cef              ADDS     r7,r5,#3
000056  f1060c01          ADD      r12,r6,#1
00005a  eba7070c          SUB      r7,r7,r12
00005e  eb070c87          ADD      r12,r7,r7,LSL #2
000062  271f              MOVS     r7,#0x1f
000064  fa07f20c          LSL      r2,r7,r12
;;;1236     /* Clear the old JSQx bits for the selected rank */
;;;1237     tmpreg1 &= ~tmpreg2;
000068  4390              BICS     r0,r0,r2
;;;1238     /* Calculate the mask to set: ((Rank-1)+(4-JL-1)) */
;;;1239     tmpreg2 = (uint32_t)ADC_Channel << (5 * (uint8_t)((Rank + 3) - (tmpreg3 + 1)));
00006a  1cef              ADDS     r7,r5,#3
00006c  f1060c01          ADD      r12,r6,#1
000070  eba7070c          SUB      r7,r7,r12
000074  eb070787          ADD      r7,r7,r7,LSL #2
000078  fa01f207          LSL      r2,r1,r7
;;;1240     /* Set the JSQx bits for the selected rank */
;;;1241     tmpreg1 |= tmpreg2;
00007c  4310              ORRS     r0,r0,r2
;;;1242     /* Store the new register value */
;;;1243     ADCx->JSQR = tmpreg1;
00007e  63a0              STR      r0,[r4,#0x38]
;;;1244   }
000080  bdf0              POP      {r4-r7,pc}
;;;1245   
                          ENDP


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

                  ADC_InjectedDiscModeCmd PROC
;;;1448     */
;;;1449   void ADC_InjectedDiscModeCmd(ADC_TypeDef* ADCx, FunctionalState NewState)
000000  b121              CBZ      r1,|L29.12|
;;;1450   {
;;;1451     /* Check the parameters */
;;;1452     assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;1453     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1454     if (NewState != DISABLE)
;;;1455     {
;;;1456       /* Enable the selected ADC injected discontinuous mode */
;;;1457       ADCx->CR1 |= (uint32_t)ADC_CR1_JDISCEN;
000002  6842              LDR      r2,[r0,#4]
000004  f4425280          ORR      r2,r2,#0x1000
000008  6042              STR      r2,[r0,#4]
00000a  e003              B        |L29.20|
                  |L29.12|
;;;1458     }
;;;1459     else
;;;1460     {
;;;1461       /* Disable the selected ADC injected discontinuous mode */
;;;1462       ADCx->CR1 &= (uint32_t)(~ADC_CR1_JDISCEN);
00000c  6842              LDR      r2,[r0,#4]
00000e  f4225280          BIC      r2,r2,#0x1000
000012  6042              STR      r2,[r0,#4]
                  |L29.20|
;;;1463     }
;;;1464   }
000014  4770              BX       lr
;;;1465   
                          ENDP


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

                  ADC_InjectedSequencerLengthConfig PROC
;;;1252     */
;;;1253   void ADC_InjectedSequencerLengthConfig(ADC_TypeDef* ADCx, uint8_t Length)
000000  b510              PUSH     {r4,lr}
;;;1254   {
000002  460a              MOV      r2,r1
;;;1255     uint32_t tmpreg1 = 0;
000004  2100              MOVS     r1,#0
;;;1256     uint32_t tmpreg2 = 0;
000006  2300              MOVS     r3,#0
;;;1257     /* Check the parameters */
;;;1258     assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;1259     assert_param(IS_ADC_INJECTED_LENGTH(Length));
;;;1260     
;;;1261     /* Get the old register value */
;;;1262     tmpreg1 = ADCx->JSQR;
000008  6b81              LDR      r1,[r0,#0x38]
;;;1263     
;;;1264     /* Clear the old injected sequence length JL bits */
;;;1265     tmpreg1 &= JSQR_JL_RESET;
00000a  f4211140          BIC      r1,r1,#0x300000
;;;1266     
;;;1267     /* Set the injected sequence length JL bits */
;;;1268     tmpreg2 = Length - 1; 
00000e  1e53              SUBS     r3,r2,#1
;;;1269     tmpreg1 |= tmpreg2 << 20;
000010  ea415103          ORR      r1,r1,r3,LSL #20
;;;1270     
;;;1271     /* Store the new register value */
;;;1272     ADCx->JSQR = tmpreg1;
000014  6381              STR      r1,[r0,#0x38]
;;;1273   }
000016  bd10              POP      {r4,pc}
;;;1274   
                          ENDP


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

                  ADC_MultiModeDMARequestAfterLastTransferCmd PROC
;;;1102     */
;;;1103   void ADC_MultiModeDMARequestAfterLastTransferCmd(FunctionalState NewState)
000000  b138              CBZ      r0,|L31.18|
;;;1104   {
;;;1105     /* Check the parameters */
;;;1106     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1107     if (NewState != DISABLE)
;;;1108     {
;;;1109       /* Enable the selected ADC DMA request after last transfer */
;;;1110       ADC->CCR |= (uint32_t)ADC_CCR_DDS;
000002  4908              LDR      r1,|L31.36|
000004  6809              LDR      r1,[r1,#0]
000006  f4415100          ORR      r1,r1,#0x2000
00000a  4a07              LDR      r2,|L31.40|
00000c  f8c21304          STR      r1,[r2,#0x304]
000010  e006              B        |L31.32|
                  |L31.18|
;;;1111     }
;;;1112     else
;;;1113     {
;;;1114       /* Disable the selected ADC DMA request after last transfer */
;;;1115       ADC->CCR &= (uint32_t)(~ADC_CCR_DDS);
000012  4904              LDR      r1,|L31.36|
000014  6809              LDR      r1,[r1,#0]
000016  f4215100          BIC      r1,r1,#0x2000
00001a  4a03              LDR      r2,|L31.40|
00001c  f8c21304          STR      r1,[r2,#0x304]
                  |L31.32|
;;;1116     }
;;;1117   }
000020  4770              BX       lr
;;;1118   /**
                          ENDP

000022  0000              DCW      0x0000
                  |L31.36|
                          DCD      0x40012304
                  |L31.40|
                          DCD      0x40012000

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

                  ADC_RegularChannelConfig PROC
;;;714      */
;;;715    void ADC_RegularChannelConfig(ADC_TypeDef* ADCx, uint8_t ADC_Channel, uint8_t Rank, uint8_t ADC_SampleTime)
000000  b5f0              PUSH     {r4-r7,lr}
;;;716    {
000002  4604              MOV      r4,r0
000004  460d              MOV      r5,r1
;;;717      uint32_t tmpreg1 = 0, tmpreg2 = 0;
000006  2000              MOVS     r0,#0
000008  2100              MOVS     r1,#0
;;;718      /* Check the parameters */
;;;719      assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;720      assert_param(IS_ADC_CHANNEL(ADC_Channel));
;;;721      assert_param(IS_ADC_REGULAR_RANK(Rank));
;;;722      assert_param(IS_ADC_SAMPLE_TIME(ADC_SampleTime));
;;;723      
;;;724      /* if ADC_Channel_10 ... ADC_Channel_18 is selected */
;;;725      if (ADC_Channel > ADC_Channel_9)
00000a  2d09              CMP      r5,#9
00000c  dd11              BLE      |L32.50|
;;;726      {
;;;727        /* Get the old register value */
;;;728        tmpreg1 = ADCx->SMPR1;
00000e  68e0              LDR      r0,[r4,#0xc]
;;;729        
;;;730        /* Calculate the mask to clear */
;;;731        tmpreg2 = SMPR1_SMP_SET << (3 * (ADC_Channel - 10));
000010  f1a5060a          SUB      r6,r5,#0xa
000014  eb060746          ADD      r7,r6,r6,LSL #1
000018  2607              MOVS     r6,#7
00001a  fa06f107          LSL      r1,r6,r7
;;;732        
;;;733        /* Clear the old sample time */
;;;734        tmpreg1 &= ~tmpreg2;
00001e  4388              BICS     r0,r0,r1
;;;735        
;;;736        /* Calculate the mask to set */
;;;737        tmpreg2 = (uint32_t)ADC_SampleTime << (3 * (ADC_Channel - 10));
000020  f1a5060a          SUB      r6,r5,#0xa
000024  eb060646          ADD      r6,r6,r6,LSL #1
000028  fa03f106          LSL      r1,r3,r6
;;;738        
;;;739        /* Set the new sample time */
;;;740        tmpreg1 |= tmpreg2;
00002c  4308              ORRS     r0,r0,r1
;;;741        
;;;742        /* Store the new register value */
;;;743        ADCx->SMPR1 = tmpreg1;
00002e  60e0              STR      r0,[r4,#0xc]
000030  e00c              B        |L32.76|
                  |L32.50|
;;;744      }
;;;745      else /* ADC_Channel include in ADC_Channel_[0..9] */
;;;746      {
;;;747        /* Get the old register value */
;;;748        tmpreg1 = ADCx->SMPR2;
000032  6920              LDR      r0,[r4,#0x10]
;;;749        
;;;750        /* Calculate the mask to clear */
;;;751        tmpreg2 = SMPR2_SMP_SET << (3 * ADC_Channel);
000034  eb050745          ADD      r7,r5,r5,LSL #1
000038  2607              MOVS     r6,#7
00003a  fa06f107          LSL      r1,r6,r7
;;;752        
;;;753        /* Clear the old sample time */
;;;754        tmpreg1 &= ~tmpreg2;
00003e  4388              BICS     r0,r0,r1
;;;755        
;;;756        /* Calculate the mask to set */
;;;757        tmpreg2 = (uint32_t)ADC_SampleTime << (3 * ADC_Channel);
000040  eb050645          ADD      r6,r5,r5,LSL #1
000044  fa03f106          LSL      r1,r3,r6
;;;758        
;;;759        /* Set the new sample time */
;;;760        tmpreg1 |= tmpreg2;
000048  4308              ORRS     r0,r0,r1
;;;761        
;;;762        /* Store the new register value */
;;;763        ADCx->SMPR2 = tmpreg1;
00004a  6120              STR      r0,[r4,#0x10]
                  |L32.76|
;;;764      }
;;;765      /* For Rank 1 to 6 */
;;;766      if (Rank < 7)
00004c  2a07              CMP      r2,#7
00004e  da0f              BGE      |L32.112|
;;;767      {
;;;768        /* Get the old register value */
;;;769        tmpreg1 = ADCx->SQR3;
000050  6b60              LDR      r0,[r4,#0x34]
;;;770        
;;;771        /* Calculate the mask to clear */
;;;772        tmpreg2 = SQR3_SQ_SET << (5 * (Rank - 1));
000052  1e56              SUBS     r6,r2,#1
000054  eb060786          ADD      r7,r6,r6,LSL #2
000058  261f              MOVS     r6,#0x1f
00005a  fa06f107          LSL      r1,r6,r7
;;;773        
;;;774        /* Clear the old SQx bits for the selected rank */
;;;775        tmpreg1 &= ~tmpreg2;
00005e  4388              BICS     r0,r0,r1
;;;776        
;;;777        /* Calculate the mask to set */
;;;778        tmpreg2 = (uint32_t)ADC_Channel << (5 * (Rank - 1));
000060  1e56              SUBS     r6,r2,#1
000062  eb060686          ADD      r6,r6,r6,LSL #2
000066  fa05f106          LSL      r1,r5,r6
;;;779        
;;;780        /* Set the SQx bits for the selected rank */
;;;781        tmpreg1 |= tmpreg2;
00006a  4308              ORRS     r0,r0,r1
;;;782        
;;;783        /* Store the new register value */
;;;784        ADCx->SQR3 = tmpreg1;
00006c  6360              STR      r0,[r4,#0x34]
00006e  e022              B        |L32.182|
                  |L32.112|
;;;785      }
;;;786      /* For Rank 7 to 12 */
;;;787      else if (Rank < 13)
000070  2a0d              CMP      r2,#0xd
000072  da0f              BGE      |L32.148|
;;;788      {
;;;789        /* Get the old register value */
;;;790        tmpreg1 = ADCx->SQR2;
000074  6b20              LDR      r0,[r4,#0x30]
;;;791        
;;;792        /* Calculate the mask to clear */
;;;793        tmpreg2 = SQR2_SQ_SET << (5 * (Rank - 7));
000076  1fd6              SUBS     r6,r2,#7
000078  eb060786          ADD      r7,r6,r6,LSL #2
00007c  261f              MOVS     r6,#0x1f
00007e  fa06f107          LSL      r1,r6,r7
;;;794        
;;;795        /* Clear the old SQx bits for the selected rank */
;;;796        tmpreg1 &= ~tmpreg2;
000082  4388              BICS     r0,r0,r1
;;;797        
;;;798        /* Calculate the mask to set */
;;;799        tmpreg2 = (uint32_t)ADC_Channel << (5 * (Rank - 7));
000084  1fd6              SUBS     r6,r2,#7
000086  eb060686          ADD      r6,r6,r6,LSL #2
00008a  fa05f106          LSL      r1,r5,r6
;;;800        
;;;801        /* Set the SQx bits for the selected rank */
;;;802        tmpreg1 |= tmpreg2;
00008e  4308              ORRS     r0,r0,r1
;;;803        
;;;804        /* Store the new register value */
;;;805        ADCx->SQR2 = tmpreg1;
000090  6320              STR      r0,[r4,#0x30]
000092  e010              B        |L32.182|
                  |L32.148|
;;;806      }
;;;807      /* For Rank 13 to 16 */
;;;808      else
;;;809      {
;;;810        /* Get the old register value */
;;;811        tmpreg1 = ADCx->SQR1;
000094  6ae0              LDR      r0,[r4,#0x2c]
;;;812        
;;;813        /* Calculate the mask to clear */
;;;814        tmpreg2 = SQR1_SQ_SET << (5 * (Rank - 13));
000096  f1a2060d          SUB      r6,r2,#0xd
00009a  eb060786          ADD      r7,r6,r6,LSL #2
00009e  261f              MOVS     r6,#0x1f
0000a0  fa06f107          LSL      r1,r6,r7
;;;815        
;;;816        /* Clear the old SQx bits for the selected rank */
;;;817        tmpreg1 &= ~tmpreg2;
0000a4  4388              BICS     r0,r0,r1
;;;818        
;;;819        /* Calculate the mask to set */
;;;820        tmpreg2 = (uint32_t)ADC_Channel << (5 * (Rank - 13));
0000a6  f1a2060d          SUB      r6,r2,#0xd
0000aa  eb060686          ADD      r6,r6,r6,LSL #2
0000ae  fa05f106          LSL      r1,r5,r6
;;;821        
;;;822        /* Set the SQx bits for the selected rank */
;;;823        tmpreg1 |= tmpreg2;
0000b2  4308              ORRS     r0,r0,r1
;;;824        
;;;825        /* Store the new register value */
;;;826        ADCx->SQR1 = tmpreg1;
0000b4  62e0              STR      r0,[r4,#0x2c]
                  |L32.182|
;;;827      }
;;;828    }
0000b6  bdf0              POP      {r4-r7,pc}
;;;829    
                          ENDP


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

                  ADC_SetInjectedOffset PROC
;;;1287     */
;;;1288   void ADC_SetInjectedOffset(ADC_TypeDef* ADCx, uint8_t ADC_InjectedChannel, uint16_t Offset)
000000  b508              PUSH     {r3,lr}
;;;1289   {
;;;1290       __IO uint32_t tmp = 0;
000002  2300              MOVS     r3,#0
000004  9300              STR      r3,[sp,#0]
;;;1291     /* Check the parameters */
;;;1292     assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;1293     assert_param(IS_ADC_INJECTED_CHANNEL(ADC_InjectedChannel));
;;;1294     assert_param(IS_ADC_OFFSET(Offset));
;;;1295     
;;;1296     tmp = (uint32_t)ADCx;
000006  9000              STR      r0,[sp,#0]
;;;1297     tmp += ADC_InjectedChannel;
000008  9b00              LDR      r3,[sp,#0]
00000a  440b              ADD      r3,r3,r1
00000c  9300              STR      r3,[sp,#0]
;;;1298     
;;;1299     /* Set the selected injected channel data offset */
;;;1300    *(__IO uint32_t *) tmp = (uint32_t)Offset;
00000e  9b00              LDR      r3,[sp,#0]
000010  601a              STR      r2,[r3,#0]
;;;1301   }
000012  bd08              POP      {r3,pc}
;;;1302   
                          ENDP


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

                  ADC_SoftwareStartConv PROC
;;;834      */
;;;835    void ADC_SoftwareStartConv(ADC_TypeDef* ADCx)
000000  6881              LDR      r1,[r0,#8]
;;;836    {
;;;837      /* Check the parameters */
;;;838      assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;839      
;;;840      /* Enable the selected ADC conversion for regular group */
;;;841      ADCx->CR2 |= (uint32_t)ADC_CR2_SWSTART;
000002  f0414180          ORR      r1,r1,#0x40000000
000006  6081              STR      r1,[r0,#8]
;;;842    }
000008  4770              BX       lr
;;;843    
                          ENDP


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

                  ADC_SoftwareStartInjectedConv PROC
;;;1380     */
;;;1381   void ADC_SoftwareStartInjectedConv(ADC_TypeDef* ADCx)
000000  6881              LDR      r1,[r0,#8]
;;;1382   {
;;;1383     /* Check the parameters */
;;;1384     assert_param(IS_ADC_ALL_PERIPH(ADCx));
;;;1385     /* Enable the selected ADC conversion for injected group */
;;;1386     ADCx->CR2 |= (uint32_t)ADC_CR2_JSWSTART;
000002  f4410180          ORR      r1,r1,#0x400000
000006  6081              STR      r1,[r0,#8]
;;;1387   }
000008  4770              BX       lr
;;;1388   
                          ENDP


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

                  ADC_StructInit PROC
;;;309      */
;;;310    void ADC_StructInit(ADC_InitTypeDef* ADC_InitStruct)
000000  2100              MOVS     r1,#0
;;;311    {
;;;312      /* Initialize the ADC_Mode member */
;;;313      ADC_InitStruct->ADC_Resolution = ADC_Resolution_12b;
000002  6001              STR      r1,[r0,#0]
;;;314    
;;;315      /* initialize the ADC_ScanConvMode member */
;;;316      ADC_InitStruct->ADC_ScanConvMode = DISABLE;
000004  7101              STRB     r1,[r0,#4]
;;;317    
;;;318      /* Initialize the ADC_ContinuousConvMode member */
;;;319      ADC_InitStruct->ADC_ContinuousConvMode = DISABLE;
000006  7141              STRB     r1,[r0,#5]
;;;320    
;;;321      /* Initialize the ADC_ExternalTrigConvEdge member */
;;;322      ADC_InitStruct->ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;
000008  6081              STR      r1,[r0,#8]
;;;323    
;;;324      /* Initialize the ADC_ExternalTrigConv member */
;;;325      ADC_InitStruct->ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_CC1;
00000a  60c1              STR      r1,[r0,#0xc]
;;;326    
;;;327      /* Initialize the ADC_DataAlign member */
;;;328      ADC_InitStruct->ADC_DataAlign = ADC_DataAlign_Right;
00000c  6101              STR      r1,[r0,#0x10]
;;;329    
;;;330      /* Initialize the ADC_NbrOfConversion member */
;;;331      ADC_InitStruct->ADC_NbrOfConversion = 1;
00000e  2101              MOVS     r1,#1
000010  7501              STRB     r1,[r0,#0x14]
;;;332    }
000012  4770              BX       lr
;;;333    
                          ENDP


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

                  ADC_TempSensorVrefintCmd PROC
;;;588      */
;;;589    void ADC_TempSensorVrefintCmd(FunctionalState NewState)                
000000  b138              CBZ      r0,|L37.18|
;;;590    {
;;;591      /* Check the parameters */
;;;592      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;593      if (NewState != DISABLE)
;;;594      {
;;;595        /* Enable the temperature sensor and Vrefint channel*/
;;;596        ADC->CCR |= (uint32_t)ADC_CCR_TSVREFE;
000002  4908              LDR      r1,|L37.36|
000004  6809              LDR      r1,[r1,#0]
000006  f4410100          ORR      r1,r1,#0x800000
00000a  4a07              LDR      r2,|L37.40|
00000c  f8c21304          STR      r1,[r2,#0x304]
000010  e006              B        |L37.32|
                  |L37.18|
;;;597      }
;;;598      else
;;;599      {
;;;600        /* Disable the temperature sensor and Vrefint channel*/
;;;601        ADC->CCR &= (uint32_t)(~ADC_CCR_TSVREFE);
000012  4904              LDR      r1,|L37.36|
000014  6809              LDR      r1,[r1,#0]
000016  f4210100          BIC      r1,r1,#0x800000
00001a  4a03              LDR      r2,|L37.40|
00001c  f8c21304          STR      r1,[r2,#0x304]
                  |L37.32|
;;;602      }
;;;603    }
000020  4770              BX       lr
;;;604    
                          ENDP

000022  0000              DCW      0x0000
                  |L37.36|
                          DCD      0x40012304
                  |L37.40|
                          DCD      0x40012000

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

                  ADC_VBATCmd PROC
;;;614      */
;;;615    void ADC_VBATCmd(FunctionalState NewState)                             
000000  b138              CBZ      r0,|L38.18|
;;;616    {
;;;617      /* Check the parameters */
;;;618      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;619      if (NewState != DISABLE)
;;;620      {
;;;621        /* Enable the VBAT channel*/
;;;622        ADC->CCR |= (uint32_t)ADC_CCR_VBATE;
000002  4908              LDR      r1,|L38.36|
000004  6809              LDR      r1,[r1,#0]
000006  f4410180          ORR      r1,r1,#0x400000
00000a  4a07              LDR      r2,|L38.40|
00000c  f8c21304          STR      r1,[r2,#0x304]
000010  e006              B        |L38.32|
                  |L38.18|
;;;623      }
;;;624      else
;;;625      {
;;;626        /* Disable the VBAT channel*/
;;;627        ADC->CCR &= (uint32_t)(~ADC_CCR_VBATE);
000012  4904              LDR      r1,|L38.36|
000014  6809              LDR      r1,[r1,#0]
000016  f4210180          BIC      r1,r1,#0x400000
00001a  4a03              LDR      r2,|L38.40|
00001c  f8c21304          STR      r1,[r2,#0x304]
                  |L38.32|
;;;628      }
;;;629    }
000020  4770              BX       lr
;;;630    
                          ENDP

000022  0000              DCW      0x0000
                  |L38.36|
                          DCD      0x40012304
                  |L38.40|
                          DCD      0x40012000

;*** Start embedded assembler ***

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

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

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
