; 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_dac.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_dac.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_dac.crf ..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries\STM32F4xx_StdPeriph_Driver\src\stm32f4xx_dac.c]
                          THUMB

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

                  DAC_ClearFlag PROC
;;;624      */
;;;625    void DAC_ClearFlag(uint32_t DAC_Channel, uint32_t DAC_FLAG)
000000  fa01f200          LSL      r2,r1,r0
;;;626    {
;;;627      /* Check the parameters */
;;;628      assert_param(IS_DAC_CHANNEL(DAC_Channel));
;;;629      assert_param(IS_DAC_FLAG(DAC_FLAG));
;;;630    
;;;631      /* Clear the selected DAC flags */
;;;632      DAC->SR = (DAC_FLAG << DAC_Channel);
000004  4b01              LDR      r3,|L1.12|
000006  601a              STR      r2,[r3,#0]
;;;633    }
000008  4770              BX       lr
;;;634    
                          ENDP

00000a  0000              DCW      0x0000
                  |L1.12|
                          DCD      0x40007434

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

                  DAC_ClearITPendingBit PROC
;;;687      */
;;;688    void DAC_ClearITPendingBit(uint32_t DAC_Channel, uint32_t DAC_IT)
000000  fa01f200          LSL      r2,r1,r0
;;;689    {
;;;690      /* Check the parameters */
;;;691      assert_param(IS_DAC_CHANNEL(DAC_Channel));
;;;692      assert_param(IS_DAC_IT(DAC_IT)); 
;;;693    
;;;694      /* Clear the selected DAC interrupt pending bits */
;;;695      DAC->SR = (DAC_IT << DAC_Channel);
000004  4b01              LDR      r3,|L2.12|
000006  601a              STR      r2,[r3,#0]
;;;696    }
000008  4770              BX       lr
;;;697    
                          ENDP

00000a  0000              DCW      0x0000
                  |L2.12|
                          DCD      0x40007434

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

                  DAC_Cmd PROC
;;;265      */
;;;266    void DAC_Cmd(uint32_t DAC_Channel, FunctionalState NewState)
000000  b139              CBZ      r1,|L3.18|
;;;267    {
;;;268      /* Check the parameters */
;;;269      assert_param(IS_DAC_CHANNEL(DAC_Channel));
;;;270      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;271    
;;;272      if (NewState != DISABLE)
;;;273      {
;;;274        /* Enable the selected DAC channel */
;;;275        DAC->CR |= (DAC_CR_EN1 << DAC_Channel);
000002  4a08              LDR      r2,|L3.36|
000004  6812              LDR      r2,[r2,#0]
000006  2301              MOVS     r3,#1
000008  4083              LSLS     r3,r3,r0
00000a  431a              ORRS     r2,r2,r3
00000c  4b05              LDR      r3,|L3.36|
00000e  601a              STR      r2,[r3,#0]
000010  e006              B        |L3.32|
                  |L3.18|
;;;276      }
;;;277      else
;;;278      {
;;;279        /* Disable the selected DAC channel */
;;;280        DAC->CR &= (~(DAC_CR_EN1 << DAC_Channel));
000012  4a04              LDR      r2,|L3.36|
000014  6812              LDR      r2,[r2,#0]
000016  2301              MOVS     r3,#1
000018  4083              LSLS     r3,r3,r0
00001a  439a              BICS     r2,r2,r3
00001c  4b01              LDR      r3,|L3.36|
00001e  601a              STR      r2,[r3,#0]
                  |L3.32|
;;;281      }
;;;282    }
000020  4770              BX       lr
;;;283    
                          ENDP

000022  0000              DCW      0x0000
                  |L3.36|
                          DCD      0x40007400

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

                  DAC_DMACmd PROC
;;;509      */
;;;510    void DAC_DMACmd(uint32_t DAC_Channel, FunctionalState NewState)
000000  b141              CBZ      r1,|L4.20|
;;;511    {
;;;512      /* Check the parameters */
;;;513      assert_param(IS_DAC_CHANNEL(DAC_Channel));
;;;514      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;515    
;;;516      if (NewState != DISABLE)
;;;517      {
;;;518        /* Enable the selected DAC channel DMA request */
;;;519        DAC->CR |= (DAC_CR_DMAEN1 << DAC_Channel);
000002  4a09              LDR      r2,|L4.40|
000004  6812              LDR      r2,[r2,#0]
000006  f44f5380          MOV      r3,#0x1000
00000a  4083              LSLS     r3,r3,r0
00000c  431a              ORRS     r2,r2,r3
00000e  4b06              LDR      r3,|L4.40|
000010  601a              STR      r2,[r3,#0]
000012  e007              B        |L4.36|
                  |L4.20|
;;;520      }
;;;521      else
;;;522      {
;;;523        /* Disable the selected DAC channel DMA request */
;;;524        DAC->CR &= (~(DAC_CR_DMAEN1 << DAC_Channel));
000014  4a04              LDR      r2,|L4.40|
000016  6812              LDR      r2,[r2,#0]
000018  f44f5380          MOV      r3,#0x1000
00001c  4083              LSLS     r3,r3,r0
00001e  439a              BICS     r2,r2,r3
000020  4b01              LDR      r3,|L4.40|
000022  601a              STR      r2,[r3,#0]
                  |L4.36|
;;;525      }
;;;526    }
000024  4770              BX       lr
;;;527    /**
                          ENDP

000026  0000              DCW      0x0000
                  |L4.40|
                          DCD      0x40007400

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

                  DAC_DeInit PROC
;;;186      */
;;;187    void DAC_DeInit(void)
000000  b510              PUSH     {r4,lr}
;;;188    {
;;;189      /* Enable DAC reset state */
;;;190      RCC_APB1PeriphResetCmd(RCC_APB1Periph_DAC, ENABLE);
000002  2101              MOVS     r1,#1
000004  0748              LSLS     r0,r1,#29
000006  f7fffffe          BL       RCC_APB1PeriphResetCmd
;;;191      /* Release DAC from reset state */
;;;192      RCC_APB1PeriphResetCmd(RCC_APB1Periph_DAC, DISABLE);
00000a  2100              MOVS     r1,#0
00000c  f04f5000          MOV      r0,#0x20000000
000010  f7fffffe          BL       RCC_APB1PeriphResetCmd
;;;193    }
000014  bd10              POP      {r4,pc}
;;;194    
                          ENDP


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

                  DAC_DualSoftwareTriggerCmd PROC
;;;317      */
;;;318    void DAC_DualSoftwareTriggerCmd(FunctionalState NewState)
000000  b130              CBZ      r0,|L6.16|
;;;319    {
;;;320      /* Check the parameters */
;;;321      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;322    
;;;323      if (NewState != DISABLE)
;;;324      {
;;;325        /* Enable software trigger for both DAC channels */
;;;326        DAC->SWTRIGR |= DUAL_SWTRIG_SET;
000002  4907              LDR      r1,|L6.32|
000004  6809              LDR      r1,[r1,#0]
000006  f0410103          ORR      r1,r1,#3
00000a  4a05              LDR      r2,|L6.32|
00000c  6011              STR      r1,[r2,#0]
00000e  e005              B        |L6.28|
                  |L6.16|
;;;327      }
;;;328      else
;;;329      {
;;;330        /* Disable software trigger for both DAC channels */
;;;331        DAC->SWTRIGR &= DUAL_SWTRIG_RESET;
000010  4903              LDR      r1,|L6.32|
000012  6809              LDR      r1,[r1,#0]
000014  f0210103          BIC      r1,r1,#3
000018  4a01              LDR      r2,|L6.32|
00001a  6011              STR      r1,[r2,#0]
                  |L6.28|
;;;332      }
;;;333    }
00001c  4770              BX       lr
;;;334    
                          ENDP

00001e  0000              DCW      0x0000
                  |L6.32|
                          DCD      0x40007404

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

                  DAC_GetDataOutputValue PROC
;;;464      */
;;;465    uint16_t DAC_GetDataOutputValue(uint32_t DAC_Channel)
000000  b508              PUSH     {r3,lr}
;;;466    {
000002  4601              MOV      r1,r0
;;;467      __IO uint32_t tmp = 0;
000004  2000              MOVS     r0,#0
000006  9000              STR      r0,[sp,#0]
;;;468      
;;;469      /* Check the parameters */
;;;470      assert_param(IS_DAC_CHANNEL(DAC_Channel));
;;;471      
;;;472      tmp = (uint32_t) DAC_BASE ;
000008  4805              LDR      r0,|L7.32|
00000a  9000              STR      r0,[sp,#0]
;;;473      tmp += DOR_OFFSET + ((uint32_t)DAC_Channel >> 2);
00000c  202c              MOVS     r0,#0x2c
00000e  eb000091          ADD      r0,r0,r1,LSR #2
000012  9a00              LDR      r2,[sp,#0]
000014  4410              ADD      r0,r0,r2
000016  9000              STR      r0,[sp,#0]
;;;474      
;;;475      /* Returns the DAC channel data output register value */
;;;476      return (uint16_t) (*(__IO uint32_t*) tmp);
000018  9800              LDR      r0,[sp,#0]
00001a  6800              LDR      r0,[r0,#0]
00001c  b280              UXTH     r0,r0
;;;477    }
00001e  bd08              POP      {r3,pc}
;;;478    /**
                          ENDP

                  |L7.32|
                          DCD      0x40007400

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

                  DAC_GetFlagStatus PROC
;;;589      */
;;;590    FlagStatus DAC_GetFlagStatus(uint32_t DAC_Channel, uint32_t DAC_FLAG)
000000  b510              PUSH     {r4,lr}
;;;591    {
000002  4602              MOV      r2,r0
;;;592      FlagStatus bitstatus = RESET;
000004  2000              MOVS     r0,#0
;;;593      /* Check the parameters */
;;;594      assert_param(IS_DAC_CHANNEL(DAC_Channel));
;;;595      assert_param(IS_DAC_FLAG(DAC_FLAG));
;;;596    
;;;597      /* Check the status of the specified DAC flag */
;;;598      if ((DAC->SR & (DAC_FLAG << DAC_Channel)) != (uint8_t)RESET)
000006  4b05              LDR      r3,|L8.28|
000008  681b              LDR      r3,[r3,#0]
00000a  fa01f402          LSL      r4,r1,r2
00000e  4023              ANDS     r3,r3,r4
000010  b10b              CBZ      r3,|L8.22|
;;;599      {
;;;600        /* DAC_FLAG is set */
;;;601        bitstatus = SET;
000012  2001              MOVS     r0,#1
000014  e000              B        |L8.24|
                  |L8.22|
;;;602      }
;;;603      else
;;;604      {
;;;605        /* DAC_FLAG is reset */
;;;606        bitstatus = RESET;
000016  2000              MOVS     r0,#0
                  |L8.24|
;;;607      }
;;;608      /* Return the DAC_FLAG status */
;;;609      return  bitstatus;
;;;610    }
000018  bd10              POP      {r4,pc}
;;;611    
                          ENDP

00001a  0000              DCW      0x0000
                  |L8.28|
                          DCD      0x40007434

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

                  DAC_GetITStatus PROC
;;;647      */
;;;648    ITStatus DAC_GetITStatus(uint32_t DAC_Channel, uint32_t DAC_IT)
000000  b530              PUSH     {r4,r5,lr}
;;;649    {
000002  4602              MOV      r2,r0
;;;650      ITStatus bitstatus = RESET;
000004  2000              MOVS     r0,#0
;;;651      uint32_t enablestatus = 0;
000006  2300              MOVS     r3,#0
;;;652      
;;;653      /* Check the parameters */
;;;654      assert_param(IS_DAC_CHANNEL(DAC_Channel));
;;;655      assert_param(IS_DAC_IT(DAC_IT));
;;;656    
;;;657      /* Get the DAC_IT enable bit status */
;;;658      enablestatus = (DAC->CR & (DAC_IT << DAC_Channel)) ;
000008  4c08              LDR      r4,|L9.44|
00000a  6824              LDR      r4,[r4,#0]
00000c  fa01f502          LSL      r5,r1,r2
000010  ea040305          AND      r3,r4,r5
;;;659      
;;;660      /* Check the status of the specified DAC interrupt */
;;;661      if (((DAC->SR & (DAC_IT << DAC_Channel)) != (uint32_t)RESET) && enablestatus)
000014  4c05              LDR      r4,|L9.44|
000016  3434              ADDS     r4,r4,#0x34
000018  6824              LDR      r4,[r4,#0]
00001a  fa01f502          LSL      r5,r1,r2
00001e  402c              ANDS     r4,r4,r5
000020  b114              CBZ      r4,|L9.40|
000022  b10b              CBZ      r3,|L9.40|
;;;662      {
;;;663        /* DAC_IT is set */
;;;664        bitstatus = SET;
000024  2001              MOVS     r0,#1
000026  e000              B        |L9.42|
                  |L9.40|
;;;665      }
;;;666      else
;;;667      {
;;;668        /* DAC_IT is reset */
;;;669        bitstatus = RESET;
000028  2000              MOVS     r0,#0
                  |L9.42|
;;;670      }
;;;671      /* Return the DAC_IT status */
;;;672      return  bitstatus;
;;;673    }
00002a  bd30              POP      {r4,r5,pc}
;;;674    
                          ENDP

                  |L9.44|
                          DCD      0x40007400

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

                  DAC_ITConfig PROC
;;;557      */ 
;;;558    void DAC_ITConfig(uint32_t DAC_Channel, uint32_t DAC_IT, FunctionalState NewState)  
000000  b510              PUSH     {r4,lr}
;;;559    {
;;;560      /* Check the parameters */
;;;561      assert_param(IS_DAC_CHANNEL(DAC_Channel));
;;;562      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;563      assert_param(IS_DAC_IT(DAC_IT)); 
;;;564    
;;;565      if (NewState != DISABLE)
000002  b13a              CBZ      r2,|L10.20|
;;;566      {
;;;567        /* Enable the selected DAC interrupts */
;;;568        DAC->CR |=  (DAC_IT << DAC_Channel);
000004  4b07              LDR      r3,|L10.36|
000006  681b              LDR      r3,[r3,#0]
000008  fa01f400          LSL      r4,r1,r0
00000c  4323              ORRS     r3,r3,r4
00000e  4c05              LDR      r4,|L10.36|
000010  6023              STR      r3,[r4,#0]
000012  e006              B        |L10.34|
                  |L10.20|
;;;569      }
;;;570      else
;;;571      {
;;;572        /* Disable the selected DAC interrupts */
;;;573        DAC->CR &= (~(uint32_t)(DAC_IT << DAC_Channel));
000014  4b03              LDR      r3,|L10.36|
000016  681b              LDR      r3,[r3,#0]
000018  fa01f400          LSL      r4,r1,r0
00001c  43a3              BICS     r3,r3,r4
00001e  4c01              LDR      r4,|L10.36|
000020  6023              STR      r3,[r4,#0]
                  |L10.34|
;;;574      }
;;;575    }
000022  bd10              POP      {r4,pc}
;;;576    
                          ENDP

                  |L10.36|
                          DCD      0x40007400

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

                  DAC_Init PROC
;;;205      */
;;;206    void DAC_Init(uint32_t DAC_Channel, DAC_InitTypeDef* DAC_InitStruct)
000000  b530              PUSH     {r4,r5,lr}
;;;207    {
;;;208      uint32_t tmpreg1 = 0, tmpreg2 = 0;
000002  2200              MOVS     r2,#0
000004  2300              MOVS     r3,#0
;;;209    
;;;210      /* Check the DAC parameters */
;;;211      assert_param(IS_DAC_TRIGGER(DAC_InitStruct->DAC_Trigger));
;;;212      assert_param(IS_DAC_GENERATE_WAVE(DAC_InitStruct->DAC_WaveGeneration));
;;;213      assert_param(IS_DAC_LFSR_UNMASK_TRIANGLE_AMPLITUDE(DAC_InitStruct->DAC_LFSRUnmask_TriangleAmplitude));
;;;214      assert_param(IS_DAC_OUTPUT_BUFFER_STATE(DAC_InitStruct->DAC_OutputBuffer));
;;;215    
;;;216    /*---------------------------- DAC CR Configuration --------------------------*/
;;;217      /* Get the DAC CR value */
;;;218      tmpreg1 = DAC->CR;
000006  4c0a              LDR      r4,|L11.48|
000008  6822              LDR      r2,[r4,#0]
;;;219      /* Clear BOFFx, TENx, TSELx, WAVEx and MAMPx bits */
;;;220      tmpreg1 &= ~(CR_CLEAR_MASK << DAC_Channel);
00000a  f64074fe          MOV      r4,#0xffe
00000e  4084              LSLS     r4,r4,r0
000010  43a2              BICS     r2,r2,r4
;;;221      /* Configure for the selected DAC channel: buffer output, trigger, 
;;;222         wave generation, mask/amplitude for wave generation */
;;;223      /* Set TSELx and TENx bits according to DAC_Trigger value */
;;;224      /* Set WAVEx bits according to DAC_WaveGeneration value */
;;;225      /* Set MAMPx bits according to DAC_LFSRUnmask_TriangleAmplitude value */ 
;;;226      /* Set BOFFx bit according to DAC_OutputBuffer value */   
;;;227      tmpreg2 = (DAC_InitStruct->DAC_Trigger | DAC_InitStruct->DAC_WaveGeneration |
000012  e9d14500          LDRD     r4,r5,[r1,#0]
000016  432c              ORRS     r4,r4,r5
000018  688d              LDR      r5,[r1,#8]
00001a  432c              ORRS     r4,r4,r5
00001c  68cd              LDR      r5,[r1,#0xc]
00001e  ea440305          ORR      r3,r4,r5
;;;228                 DAC_InitStruct->DAC_LFSRUnmask_TriangleAmplitude | \
;;;229                 DAC_InitStruct->DAC_OutputBuffer);
;;;230      /* Calculate CR register value depending on DAC_Channel */
;;;231      tmpreg1 |= tmpreg2 << DAC_Channel;
000022  fa03f400          LSL      r4,r3,r0
000026  4322              ORRS     r2,r2,r4
;;;232      /* Write to DAC CR */
;;;233      DAC->CR = tmpreg1;
000028  4c01              LDR      r4,|L11.48|
00002a  6022              STR      r2,[r4,#0]
;;;234    }
00002c  bd30              POP      {r4,r5,pc}
;;;235    
                          ENDP

00002e  0000              DCW      0x0000
                  |L11.48|
                          DCD      0x40007400

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

                  DAC_SetChannel1Data PROC
;;;377      */
;;;378    void DAC_SetChannel1Data(uint32_t DAC_Align, uint16_t Data)
000000  b508              PUSH     {r3,lr}
;;;379    {  
;;;380      __IO uint32_t tmp = 0;
000002  2200              MOVS     r2,#0
000004  9200              STR      r2,[sp,#0]
;;;381      
;;;382      /* Check the parameters */
;;;383      assert_param(IS_DAC_ALIGN(DAC_Align));
;;;384      assert_param(IS_DAC_DATA(Data));
;;;385      
;;;386      tmp = (uint32_t)DAC_BASE; 
000006  4a05              LDR      r2,|L12.28|
000008  9200              STR      r2,[sp,#0]
;;;387      tmp += DHR12R1_OFFSET + DAC_Align;
00000a  f1000208          ADD      r2,r0,#8
00000e  9b00              LDR      r3,[sp,#0]
000010  441a              ADD      r2,r2,r3
000012  9200              STR      r2,[sp,#0]
;;;388    
;;;389      /* Set the DAC channel1 selected data holding register */
;;;390      *(__IO uint32_t *) tmp = Data;
000014  9a00              LDR      r2,[sp,#0]
000016  6011              STR      r1,[r2,#0]
;;;391    }
000018  bd08              POP      {r3,pc}
;;;392    
                          ENDP

00001a  0000              DCW      0x0000
                  |L12.28|
                          DCD      0x40007400

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

                  DAC_SetChannel2Data PROC
;;;402      */
;;;403    void DAC_SetChannel2Data(uint32_t DAC_Align, uint16_t Data)
000000  b508              PUSH     {r3,lr}
;;;404    {
;;;405      __IO uint32_t tmp = 0;
000002  2200              MOVS     r2,#0
000004  9200              STR      r2,[sp,#0]
;;;406    
;;;407      /* Check the parameters */
;;;408      assert_param(IS_DAC_ALIGN(DAC_Align));
;;;409      assert_param(IS_DAC_DATA(Data));
;;;410      
;;;411      tmp = (uint32_t)DAC_BASE;
000006  4a05              LDR      r2,|L13.28|
000008  9200              STR      r2,[sp,#0]
;;;412      tmp += DHR12R2_OFFSET + DAC_Align;
00000a  f1000214          ADD      r2,r0,#0x14
00000e  9b00              LDR      r3,[sp,#0]
000010  441a              ADD      r2,r2,r3
000012  9200              STR      r2,[sp,#0]
;;;413    
;;;414      /* Set the DAC channel2 selected data holding register */
;;;415      *(__IO uint32_t *)tmp = Data;
000014  9a00              LDR      r2,[sp,#0]
000016  6011              STR      r1,[r2,#0]
;;;416    }
000018  bd08              POP      {r3,pc}
;;;417    
                          ENDP

00001a  0000              DCW      0x0000
                  |L13.28|
                          DCD      0x40007400

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

                  DAC_SetDualChannelData PROC
;;;430      */
;;;431    void DAC_SetDualChannelData(uint32_t DAC_Align, uint16_t Data2, uint16_t Data1)
000000  b530              PUSH     {r4,r5,lr}
;;;432    {
;;;433      uint32_t data = 0, tmp = 0;
000002  2400              MOVS     r4,#0
000004  2300              MOVS     r3,#0
;;;434      
;;;435      /* Check the parameters */
;;;436      assert_param(IS_DAC_ALIGN(DAC_Align));
;;;437      assert_param(IS_DAC_DATA(Data1));
;;;438      assert_param(IS_DAC_DATA(Data2));
;;;439      
;;;440      /* Calculate and set dual DAC data holding register value */
;;;441      if (DAC_Align == DAC_Align_8b_R)
000006  2808              CMP      r0,#8
000008  d102              BNE      |L14.16|
;;;442      {
;;;443        data = ((uint32_t)Data2 << 8) | Data1; 
00000a  ea422401          ORR      r4,r2,r1,LSL #8
00000e  e001              B        |L14.20|
                  |L14.16|
;;;444      }
;;;445      else
;;;446      {
;;;447        data = ((uint32_t)Data2 << 16) | Data1;
000010  ea424401          ORR      r4,r2,r1,LSL #16
                  |L14.20|
;;;448      }
;;;449      
;;;450      tmp = (uint32_t)DAC_BASE;
000014  4b02              LDR      r3,|L14.32|
;;;451      tmp += DHR12RD_OFFSET + DAC_Align;
000016  f1000520          ADD      r5,r0,#0x20
00001a  442b              ADD      r3,r3,r5
;;;452    
;;;453      /* Set the dual DAC selected data holding register */
;;;454      *(__IO uint32_t *)tmp = data;
00001c  601c              STR      r4,[r3,#0]
;;;455    }
00001e  bd30              POP      {r4,r5,pc}
;;;456    
                          ENDP

                  |L14.32|
                          DCD      0x40007400

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

                  DAC_SoftwareTriggerCmd PROC
;;;293      */
;;;294    void DAC_SoftwareTriggerCmd(uint32_t DAC_Channel, FunctionalState NewState)
000000  b510              PUSH     {r4,lr}
;;;295    {
;;;296      /* Check the parameters */
;;;297      assert_param(IS_DAC_CHANNEL(DAC_Channel));
;;;298      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;299    
;;;300      if (NewState != DISABLE)
000002  b141              CBZ      r1,|L15.22|
;;;301      {
;;;302        /* Enable software trigger for the selected DAC channel */
;;;303        DAC->SWTRIGR |= (uint32_t)DAC_SWTRIGR_SWTRIG1 << (DAC_Channel >> 4);
000004  4a08              LDR      r2,|L15.40|
000006  6812              LDR      r2,[r2,#0]
000008  0904              LSRS     r4,r0,#4
00000a  2301              MOVS     r3,#1
00000c  40a3              LSLS     r3,r3,r4
00000e  431a              ORRS     r2,r2,r3
000010  4b05              LDR      r3,|L15.40|
000012  601a              STR      r2,[r3,#0]
000014  e007              B        |L15.38|
                  |L15.22|
;;;304      }
;;;305      else
;;;306      {
;;;307        /* Disable software trigger for the selected DAC channel */
;;;308        DAC->SWTRIGR &= ~((uint32_t)DAC_SWTRIGR_SWTRIG1 << (DAC_Channel >> 4));
000016  4a04              LDR      r2,|L15.40|
000018  6812              LDR      r2,[r2,#0]
00001a  0904              LSRS     r4,r0,#4
00001c  2301              MOVS     r3,#1
00001e  40a3              LSLS     r3,r3,r4
000020  439a              BICS     r2,r2,r3
000022  4b01              LDR      r3,|L15.40|
000024  601a              STR      r2,[r3,#0]
                  |L15.38|
;;;309      }
;;;310    }
000026  bd10              POP      {r4,pc}
;;;311    
                          ENDP

                  |L15.40|
                          DCD      0x40007404

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

                  DAC_StructInit PROC
;;;241      */
;;;242    void DAC_StructInit(DAC_InitTypeDef* DAC_InitStruct)
000000  2100              MOVS     r1,#0
;;;243    {
;;;244    /*--------------- Reset DAC init structure parameters values -----------------*/
;;;245      /* Initialize the DAC_Trigger member */
;;;246      DAC_InitStruct->DAC_Trigger = DAC_Trigger_None;
000002  6001              STR      r1,[r0,#0]
;;;247      /* Initialize the DAC_WaveGeneration member */
;;;248      DAC_InitStruct->DAC_WaveGeneration = DAC_WaveGeneration_None;
000004  6041              STR      r1,[r0,#4]
;;;249      /* Initialize the DAC_LFSRUnmask_TriangleAmplitude member */
;;;250      DAC_InitStruct->DAC_LFSRUnmask_TriangleAmplitude = DAC_LFSRUnmask_Bit0;
000006  6081              STR      r1,[r0,#8]
;;;251      /* Initialize the DAC_OutputBuffer member */
;;;252      DAC_InitStruct->DAC_OutputBuffer = DAC_OutputBuffer_Enable;
000008  60c1              STR      r1,[r0,#0xc]
;;;253    }
00000a  4770              BX       lr
;;;254    
                          ENDP


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

                  DAC_WaveGenerationCmd PROC
;;;348      */
;;;349    void DAC_WaveGenerationCmd(uint32_t DAC_Channel, uint32_t DAC_Wave, FunctionalState NewState)
000000  b510              PUSH     {r4,lr}
;;;350    {
;;;351      /* Check the parameters */
;;;352      assert_param(IS_DAC_CHANNEL(DAC_Channel));
;;;353      assert_param(IS_DAC_WAVE(DAC_Wave)); 
;;;354      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;355    
;;;356      if (NewState != DISABLE)
000002  b13a              CBZ      r2,|L17.20|
;;;357      {
;;;358        /* Enable the selected wave generation for the selected DAC channel */
;;;359        DAC->CR |= DAC_Wave << DAC_Channel;
000004  4b07              LDR      r3,|L17.36|
000006  681b              LDR      r3,[r3,#0]
000008  fa01f400          LSL      r4,r1,r0
00000c  4323              ORRS     r3,r3,r4
00000e  4c05              LDR      r4,|L17.36|
000010  6023              STR      r3,[r4,#0]
000012  e006              B        |L17.34|
                  |L17.20|
;;;360      }
;;;361      else
;;;362      {
;;;363        /* Disable the selected wave generation for the selected DAC channel */
;;;364        DAC->CR &= ~(DAC_Wave << DAC_Channel);
000014  4b03              LDR      r3,|L17.36|
000016  681b              LDR      r3,[r3,#0]
000018  fa01f400          LSL      r4,r1,r0
00001c  43a3              BICS     r3,r3,r4
00001e  4c01              LDR      r4,|L17.36|
000020  6023              STR      r3,[r4,#0]
                  |L17.34|
;;;365      }
;;;366    }
000022  bd10              POP      {r4,pc}
;;;367    
                          ENDP

                  |L17.36|
                          DCD      0x40007400

;*** Start embedded assembler ***

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

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

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
