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

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

                  DMA_ClearFlag PROC
;;;1070     */
;;;1071   void DMA_ClearFlag(DMA_Stream_TypeDef* DMAy_Streamx, uint32_t DMA_FLAG)
000000  4602              MOV      r2,r0
;;;1072   {
;;;1073     DMA_TypeDef* DMAy;
;;;1074   
;;;1075     /* Check the parameters */
;;;1076     assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;1077     assert_param(IS_DMA_CLEAR_FLAG(DMA_FLAG));
;;;1078   
;;;1079     /* Determine the DMA to which belongs the stream */
;;;1080     if (DMAy_Streamx < DMA2_Stream0)
000002  4b09              LDR      r3,|L1.40|
000004  429a              CMP      r2,r3
000006  d201              BCS      |L1.12|
;;;1081     {
;;;1082       /* DMAy_Streamx belongs to DMA1 */
;;;1083       DMAy = DMA1; 
000008  4808              LDR      r0,|L1.44|
00000a  e001              B        |L1.16|
                  |L1.12|
;;;1084     } 
;;;1085     else 
;;;1086     {
;;;1087       /* DMAy_Streamx belongs to DMA2 */
;;;1088       DMAy = DMA2; 
00000c  4806              LDR      r0,|L1.40|
00000e  3810              SUBS     r0,r0,#0x10
                  |L1.16|
;;;1089     }
;;;1090   
;;;1091     /* Check if LIFCR or HIFCR register is targeted */
;;;1092     if ((DMA_FLAG & HIGH_ISR_MASK) != (uint32_t)RESET)
000010  f0015300          AND      r3,r1,#0x20000000
000014  b11b              CBZ      r3,|L1.30|
;;;1093     {
;;;1094       /* Set DMAy HIFCR register clear flag bits */
;;;1095       DMAy->HIFCR = (uint32_t)(DMA_FLAG & RESERVED_MASK);
000016  4b06              LDR      r3,|L1.48|
000018  400b              ANDS     r3,r3,r1
00001a  60c3              STR      r3,[r0,#0xc]
00001c  e002              B        |L1.36|
                  |L1.30|
;;;1096     }
;;;1097     else 
;;;1098     {
;;;1099       /* Set DMAy LIFCR register clear flag bits */
;;;1100       DMAy->LIFCR = (uint32_t)(DMA_FLAG & RESERVED_MASK);
00001e  4b04              LDR      r3,|L1.48|
000020  400b              ANDS     r3,r3,r1
000022  6083              STR      r3,[r0,#8]
                  |L1.36|
;;;1101     }    
;;;1102   }
000024  4770              BX       lr
;;;1103   
                          ENDP

000026  0000              DCW      0x0000
                  |L1.40|
                          DCD      0x40026410
                  |L1.44|
                          DCD      0x40026000
                  |L1.48|
                          DCD      0x0f7d0f7d

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

                  DMA_ClearITPendingBit PROC
;;;1251     */
;;;1252   void DMA_ClearITPendingBit(DMA_Stream_TypeDef* DMAy_Streamx, uint32_t DMA_IT)
000000  4602              MOV      r2,r0
;;;1253   {
;;;1254     DMA_TypeDef* DMAy;
;;;1255   
;;;1256     /* Check the parameters */
;;;1257     assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;1258     assert_param(IS_DMA_CLEAR_IT(DMA_IT));
;;;1259   
;;;1260     /* Determine the DMA to which belongs the stream */
;;;1261     if (DMAy_Streamx < DMA2_Stream0)
000002  4b09              LDR      r3,|L2.40|
000004  429a              CMP      r2,r3
000006  d201              BCS      |L2.12|
;;;1262     {
;;;1263       /* DMAy_Streamx belongs to DMA1 */
;;;1264       DMAy = DMA1; 
000008  4808              LDR      r0,|L2.44|
00000a  e001              B        |L2.16|
                  |L2.12|
;;;1265     } 
;;;1266     else 
;;;1267     {
;;;1268       /* DMAy_Streamx belongs to DMA2 */
;;;1269       DMAy = DMA2; 
00000c  4806              LDR      r0,|L2.40|
00000e  3810              SUBS     r0,r0,#0x10
                  |L2.16|
;;;1270     }
;;;1271   
;;;1272     /* Check if LIFCR or HIFCR register is targeted */
;;;1273     if ((DMA_IT & HIGH_ISR_MASK) != (uint32_t)RESET)
000010  f0015300          AND      r3,r1,#0x20000000
000014  b11b              CBZ      r3,|L2.30|
;;;1274     {
;;;1275       /* Set DMAy HIFCR register clear interrupt bits */
;;;1276       DMAy->HIFCR = (uint32_t)(DMA_IT & RESERVED_MASK);
000016  4b06              LDR      r3,|L2.48|
000018  400b              ANDS     r3,r3,r1
00001a  60c3              STR      r3,[r0,#0xc]
00001c  e002              B        |L2.36|
                  |L2.30|
;;;1277     }
;;;1278     else 
;;;1279     {
;;;1280       /* Set DMAy LIFCR register clear interrupt bits */
;;;1281       DMAy->LIFCR = (uint32_t)(DMA_IT & RESERVED_MASK);
00001e  4b04              LDR      r3,|L2.48|
000020  400b              ANDS     r3,r3,r1
000022  6083              STR      r3,[r0,#8]
                  |L2.36|
;;;1282     }   
;;;1283   }
000024  4770              BX       lr
;;;1284   
                          ENDP

000026  0000              DCW      0x0000
                  |L2.40|
                          DCD      0x40026410
                  |L2.44|
                          DCD      0x40026000
                  |L2.48|
                          DCD      0x0f7d0f7d

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

                  DMA_Cmd PROC
;;;477      */
;;;478    void DMA_Cmd(DMA_Stream_TypeDef* DMAy_Streamx, FunctionalState NewState)
000000  b121              CBZ      r1,|L3.12|
;;;479    {
;;;480      /* Check the parameters */
;;;481      assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;482      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;483    
;;;484      if (NewState != DISABLE)
;;;485      {
;;;486        /* Enable the selected DMAy Streamx by setting EN bit */
;;;487        DMAy_Streamx->CR |= (uint32_t)DMA_SxCR_EN;
000002  6802              LDR      r2,[r0,#0]
000004  f0420201          ORR      r2,r2,#1
000008  6002              STR      r2,[r0,#0]
00000a  e003              B        |L3.20|
                  |L3.12|
;;;488      }
;;;489      else
;;;490      {
;;;491        /* Disable the selected DMAy Streamx by clearing EN bit */
;;;492        DMAy_Streamx->CR &= ~(uint32_t)DMA_SxCR_EN;
00000c  6802              LDR      r2,[r0,#0]
00000e  f0220201          BIC      r2,r2,#1
000012  6002              STR      r2,[r0,#0]
                  |L3.20|
;;;493      }
;;;494    }
000014  4770              BX       lr
;;;495    
                          ENDP


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

                  DMA_DeInit PROC
;;;195      */
;;;196    void DMA_DeInit(DMA_Stream_TypeDef* DMAy_Streamx)
000000  6801              LDR      r1,[r0,#0]
;;;197    {
;;;198      /* Check the parameters */
;;;199      assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;200    
;;;201      /* Disable the selected DMAy Streamx */
;;;202      DMAy_Streamx->CR &= ~((uint32_t)DMA_SxCR_EN);
000002  f0210101          BIC      r1,r1,#1
000006  6001              STR      r1,[r0,#0]
;;;203    
;;;204      /* Reset DMAy Streamx control register */
;;;205      DMAy_Streamx->CR  = 0;
000008  2100              MOVS     r1,#0
00000a  6001              STR      r1,[r0,#0]
;;;206      
;;;207      /* Reset DMAy Streamx Number of Data to Transfer register */
;;;208      DMAy_Streamx->NDTR = 0;
00000c  6041              STR      r1,[r0,#4]
;;;209      
;;;210      /* Reset DMAy Streamx peripheral address register */
;;;211      DMAy_Streamx->PAR  = 0;
00000e  6081              STR      r1,[r0,#8]
;;;212      
;;;213      /* Reset DMAy Streamx memory 0 address register */
;;;214      DMAy_Streamx->M0AR = 0;
000010  60c1              STR      r1,[r0,#0xc]
;;;215    
;;;216      /* Reset DMAy Streamx memory 1 address register */
;;;217      DMAy_Streamx->M1AR = 0;
000012  6101              STR      r1,[r0,#0x10]
;;;218    
;;;219      /* Reset DMAy Streamx FIFO control register */
;;;220      DMAy_Streamx->FCR = (uint32_t)0x00000021; 
000014  2121              MOVS     r1,#0x21
000016  6141              STR      r1,[r0,#0x14]
;;;221    
;;;222      /* Reset interrupt pending bits for the selected stream */
;;;223      if (DMAy_Streamx == DMA1_Stream0)
000018  494a              LDR      r1,|L4.324|
00001a  4288              CMP      r0,r1
00001c  d104              BNE      |L4.40|
;;;224      {
;;;225        /* Reset interrupt pending bits for DMA1 Stream0 */
;;;226        DMA1->LIFCR = DMA_Stream0_IT_MASK;
00001e  213d              MOVS     r1,#0x3d
000020  4a48              LDR      r2,|L4.324|
000022  3a10              SUBS     r2,r2,#0x10
000024  6091              STR      r1,[r2,#8]
000026  e08c              B        |L4.322|
                  |L4.40|
;;;227      }
;;;228      else if (DMAy_Streamx == DMA1_Stream1)
000028  4946              LDR      r1,|L4.324|
00002a  3118              ADDS     r1,r1,#0x18
00002c  4288              CMP      r0,r1
00002e  d105              BNE      |L4.60|
;;;229      {
;;;230        /* Reset interrupt pending bits for DMA1 Stream1 */
;;;231        DMA1->LIFCR = DMA_Stream1_IT_MASK;
000030  f44f6174          MOV      r1,#0xf40
000034  4a43              LDR      r2,|L4.324|
000036  3a10              SUBS     r2,r2,#0x10
000038  6091              STR      r1,[r2,#8]
00003a  e082              B        |L4.322|
                  |L4.60|
;;;232      }
;;;233      else if (DMAy_Streamx == DMA1_Stream2)
00003c  4941              LDR      r1,|L4.324|
00003e  3130              ADDS     r1,r1,#0x30
000040  4288              CMP      r0,r1
000042  d105              BNE      |L4.80|
;;;234      {
;;;235        /* Reset interrupt pending bits for DMA1 Stream2 */
;;;236        DMA1->LIFCR = DMA_Stream2_IT_MASK;
000044  f44f1174          MOV      r1,#0x3d0000
000048  4a3e              LDR      r2,|L4.324|
00004a  3a10              SUBS     r2,r2,#0x10
00004c  6091              STR      r1,[r2,#8]
00004e  e078              B        |L4.322|
                  |L4.80|
;;;237      }
;;;238      else if (DMAy_Streamx == DMA1_Stream3)
000050  493c              LDR      r1,|L4.324|
000052  3148              ADDS     r1,r1,#0x48
000054  4288              CMP      r0,r1
000056  d105              BNE      |L4.100|
;;;239      {
;;;240        /* Reset interrupt pending bits for DMA1 Stream3 */
;;;241        DMA1->LIFCR = DMA_Stream3_IT_MASK;
000058  f04f6174          MOV      r1,#0xf400000
00005c  4a39              LDR      r2,|L4.324|
00005e  3a10              SUBS     r2,r2,#0x10
000060  6091              STR      r1,[r2,#8]
000062  e06e              B        |L4.322|
                  |L4.100|
;;;242      }
;;;243      else if (DMAy_Streamx == DMA1_Stream4)
000064  4937              LDR      r1,|L4.324|
000066  3160              ADDS     r1,r1,#0x60
000068  4288              CMP      r0,r1
00006a  d104              BNE      |L4.118|
;;;244      {
;;;245        /* Reset interrupt pending bits for DMA1 Stream4 */
;;;246        DMA1->HIFCR = DMA_Stream4_IT_MASK;
00006c  4936              LDR      r1,|L4.328|
00006e  4a35              LDR      r2,|L4.324|
000070  3a10              SUBS     r2,r2,#0x10
000072  60d1              STR      r1,[r2,#0xc]
000074  e065              B        |L4.322|
                  |L4.118|
;;;247      }
;;;248      else if (DMAy_Streamx == DMA1_Stream5)
000076  4933              LDR      r1,|L4.324|
000078  3178              ADDS     r1,r1,#0x78
00007a  4288              CMP      r0,r1
00007c  d104              BNE      |L4.136|
;;;249      {
;;;250        /* Reset interrupt pending bits for DMA1 Stream5 */
;;;251        DMA1->HIFCR = DMA_Stream5_IT_MASK;
00007e  4933              LDR      r1,|L4.332|
000080  4a30              LDR      r2,|L4.324|
000082  3a10              SUBS     r2,r2,#0x10
000084  60d1              STR      r1,[r2,#0xc]
000086  e05c              B        |L4.322|
                  |L4.136|
;;;252      }
;;;253      else if (DMAy_Streamx == DMA1_Stream6)
000088  492e              LDR      r1,|L4.324|
00008a  3190              ADDS     r1,r1,#0x90
00008c  4288              CMP      r0,r1
00008e  d104              BNE      |L4.154|
;;;254      {
;;;255        /* Reset interrupt pending bits for DMA1 Stream6 */
;;;256        DMA1->HIFCR = (uint32_t)DMA_Stream6_IT_MASK;
000090  492f              LDR      r1,|L4.336|
000092  4a2c              LDR      r2,|L4.324|
000094  3a10              SUBS     r2,r2,#0x10
000096  60d1              STR      r1,[r2,#0xc]
000098  e053              B        |L4.322|
                  |L4.154|
;;;257      }
;;;258      else if (DMAy_Streamx == DMA1_Stream7)
00009a  492a              LDR      r1,|L4.324|
00009c  31a8              ADDS     r1,r1,#0xa8
00009e  4288              CMP      r0,r1
0000a0  d105              BNE      |L4.174|
;;;259      {
;;;260        /* Reset interrupt pending bits for DMA1 Stream7 */
;;;261        DMA1->HIFCR = DMA_Stream7_IT_MASK;
0000a2  f04f513d          MOV      r1,#0x2f400000
0000a6  4a27              LDR      r2,|L4.324|
0000a8  3a10              SUBS     r2,r2,#0x10
0000aa  60d1              STR      r1,[r2,#0xc]
0000ac  e049              B        |L4.322|
                  |L4.174|
;;;262      }
;;;263      else if (DMAy_Streamx == DMA2_Stream0)
0000ae  4929              LDR      r1,|L4.340|
0000b0  4288              CMP      r0,r1
0000b2  d104              BNE      |L4.190|
;;;264      {
;;;265        /* Reset interrupt pending bits for DMA2 Stream0 */
;;;266        DMA2->LIFCR = DMA_Stream0_IT_MASK;
0000b4  213d              MOVS     r1,#0x3d
0000b6  4a27              LDR      r2,|L4.340|
0000b8  3a08              SUBS     r2,r2,#8
0000ba  6011              STR      r1,[r2,#0]
0000bc  e041              B        |L4.322|
                  |L4.190|
;;;267      }
;;;268      else if (DMAy_Streamx == DMA2_Stream1)
0000be  4925              LDR      r1,|L4.340|
0000c0  3118              ADDS     r1,r1,#0x18
0000c2  4288              CMP      r0,r1
0000c4  d105              BNE      |L4.210|
;;;269      {
;;;270        /* Reset interrupt pending bits for DMA2 Stream1 */
;;;271        DMA2->LIFCR = DMA_Stream1_IT_MASK;
0000c6  f44f6174          MOV      r1,#0xf40
0000ca  4a22              LDR      r2,|L4.340|
0000cc  3a08              SUBS     r2,r2,#8
0000ce  6011              STR      r1,[r2,#0]
0000d0  e037              B        |L4.322|
                  |L4.210|
;;;272      }
;;;273      else if (DMAy_Streamx == DMA2_Stream2)
0000d2  4920              LDR      r1,|L4.340|
0000d4  3130              ADDS     r1,r1,#0x30
0000d6  4288              CMP      r0,r1
0000d8  d105              BNE      |L4.230|
;;;274      {
;;;275        /* Reset interrupt pending bits for DMA2 Stream2 */
;;;276        DMA2->LIFCR = DMA_Stream2_IT_MASK;
0000da  f44f1174          MOV      r1,#0x3d0000
0000de  4a1d              LDR      r2,|L4.340|
0000e0  3a08              SUBS     r2,r2,#8
0000e2  6011              STR      r1,[r2,#0]
0000e4  e02d              B        |L4.322|
                  |L4.230|
;;;277      }
;;;278      else if (DMAy_Streamx == DMA2_Stream3)
0000e6  491b              LDR      r1,|L4.340|
0000e8  3148              ADDS     r1,r1,#0x48
0000ea  4288              CMP      r0,r1
0000ec  d105              BNE      |L4.250|
;;;279      {
;;;280        /* Reset interrupt pending bits for DMA2 Stream3 */
;;;281        DMA2->LIFCR = DMA_Stream3_IT_MASK;
0000ee  f04f6174          MOV      r1,#0xf400000
0000f2  4a18              LDR      r2,|L4.340|
0000f4  3a08              SUBS     r2,r2,#8
0000f6  6011              STR      r1,[r2,#0]
0000f8  e023              B        |L4.322|
                  |L4.250|
;;;282      }
;;;283      else if (DMAy_Streamx == DMA2_Stream4)
0000fa  4916              LDR      r1,|L4.340|
0000fc  3160              ADDS     r1,r1,#0x60
0000fe  4288              CMP      r0,r1
000100  d104              BNE      |L4.268|
;;;284      {
;;;285        /* Reset interrupt pending bits for DMA2 Stream4 */
;;;286        DMA2->HIFCR = DMA_Stream4_IT_MASK;
000102  4911              LDR      r1,|L4.328|
000104  4a13              LDR      r2,|L4.340|
000106  1f12              SUBS     r2,r2,#4
000108  6011              STR      r1,[r2,#0]
00010a  e01a              B        |L4.322|
                  |L4.268|
;;;287      }
;;;288      else if (DMAy_Streamx == DMA2_Stream5)
00010c  4911              LDR      r1,|L4.340|
00010e  3178              ADDS     r1,r1,#0x78
000110  4288              CMP      r0,r1
000112  d104              BNE      |L4.286|
;;;289      {
;;;290        /* Reset interrupt pending bits for DMA2 Stream5 */
;;;291        DMA2->HIFCR = DMA_Stream5_IT_MASK;
000114  490d              LDR      r1,|L4.332|
000116  4a0f              LDR      r2,|L4.340|
000118  1f12              SUBS     r2,r2,#4
00011a  6011              STR      r1,[r2,#0]
00011c  e011              B        |L4.322|
                  |L4.286|
;;;292      }
;;;293      else if (DMAy_Streamx == DMA2_Stream6)
00011e  490d              LDR      r1,|L4.340|
000120  3190              ADDS     r1,r1,#0x90
000122  4288              CMP      r0,r1
000124  d104              BNE      |L4.304|
;;;294      {
;;;295        /* Reset interrupt pending bits for DMA2 Stream6 */
;;;296        DMA2->HIFCR = DMA_Stream6_IT_MASK;
000126  490a              LDR      r1,|L4.336|
000128  4a0a              LDR      r2,|L4.340|
00012a  1f12              SUBS     r2,r2,#4
00012c  6011              STR      r1,[r2,#0]
00012e  e008              B        |L4.322|
                  |L4.304|
;;;297      }
;;;298      else 
;;;299      {
;;;300        if (DMAy_Streamx == DMA2_Stream7)
000130  4908              LDR      r1,|L4.340|
000132  31a8              ADDS     r1,r1,#0xa8
000134  4288              CMP      r0,r1
000136  d104              BNE      |L4.322|
;;;301        {
;;;302          /* Reset interrupt pending bits for DMA2 Stream7 */
;;;303          DMA2->HIFCR = DMA_Stream7_IT_MASK;
000138  f04f513d          MOV      r1,#0x2f400000
00013c  4a05              LDR      r2,|L4.340|
00013e  1f12              SUBS     r2,r2,#4
000140  6011              STR      r1,[r2,#0]
                  |L4.322|
;;;304        }
;;;305      }
;;;306    }
000142  4770              BX       lr
;;;307    
                          ENDP

                  |L4.324|
                          DCD      0x40026010
                  |L4.328|
                          DCD      0x2000003d
                  |L4.332|
                          DCD      0x20000f40
                  |L4.336|
                          DCD      0x203d0000
                  |L4.340|
                          DCD      0x40026410

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

                  DMA_DoubleBufferModeCmd PROC
;;;760      */
;;;761    void DMA_DoubleBufferModeCmd(DMA_Stream_TypeDef* DMAy_Streamx, FunctionalState NewState)
000000  b121              CBZ      r1,|L5.12|
;;;762    {  
;;;763      /* Check the parameters */
;;;764      assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;765      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;766    
;;;767      /* Configure the Double Buffer mode */
;;;768      if (NewState != DISABLE)
;;;769      {
;;;770        /* Enable the Double buffer mode */
;;;771        DMAy_Streamx->CR |= (uint32_t)DMA_SxCR_DBM;
000002  6802              LDR      r2,[r0,#0]
000004  f4422280          ORR      r2,r2,#0x40000
000008  6002              STR      r2,[r0,#0]
00000a  e003              B        |L5.20|
                  |L5.12|
;;;772      }
;;;773      else
;;;774      {
;;;775        /* Disable the Double buffer mode */
;;;776        DMAy_Streamx->CR &= ~(uint32_t)DMA_SxCR_DBM;
00000c  6802              LDR      r2,[r0,#0]
00000e  f4222280          BIC      r2,r2,#0x40000
000012  6002              STR      r2,[r0,#0]
                  |L5.20|
;;;777      }
;;;778    }
000014  4770              BX       lr
;;;779    
                          ENDP


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

                  DMA_DoubleBufferModeConfig PROC
;;;729      */
;;;730    void DMA_DoubleBufferModeConfig(DMA_Stream_TypeDef* DMAy_Streamx, uint32_t Memory1BaseAddr,
000000  b122              CBZ      r2,|L6.12|
;;;731                                    uint32_t DMA_CurrentMemory)
;;;732    {  
;;;733      /* Check the parameters */
;;;734      assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;735      assert_param(IS_DMA_CURRENT_MEM(DMA_CurrentMemory));
;;;736    
;;;737      if (DMA_CurrentMemory != DMA_Memory_0)
;;;738      {
;;;739        /* Set Memory 1 as current memory address */
;;;740        DMAy_Streamx->CR |= (uint32_t)(DMA_SxCR_CT);    
000002  6803              LDR      r3,[r0,#0]
000004  f4432300          ORR      r3,r3,#0x80000
000008  6003              STR      r3,[r0,#0]
00000a  e003              B        |L6.20|
                  |L6.12|
;;;741      }
;;;742      else
;;;743      {
;;;744        /* Set Memory 0 as current memory address */
;;;745        DMAy_Streamx->CR &= ~(uint32_t)(DMA_SxCR_CT);    
00000c  6803              LDR      r3,[r0,#0]
00000e  f4232300          BIC      r3,r3,#0x80000
000012  6003              STR      r3,[r0,#0]
                  |L6.20|
;;;746      }
;;;747    
;;;748      /* Write to DMAy Streamx M1AR */
;;;749      DMAy_Streamx->M1AR = Memory1BaseAddr;
000014  6101              STR      r1,[r0,#0x10]
;;;750    }
000016  4770              BX       lr
;;;751    
                          ENDP


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

                  DMA_FlowControllerConfig PROC
;;;549      */
;;;550    void DMA_FlowControllerConfig(DMA_Stream_TypeDef* DMAy_Streamx, uint32_t DMA_FlowCtrl)
000000  b121              CBZ      r1,|L7.12|
;;;551    {
;;;552      /* Check the parameters */
;;;553      assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;554      assert_param(IS_DMA_FLOW_CTRL(DMA_FlowCtrl));
;;;555    
;;;556      /* Check the needed flow controller  */
;;;557      if(DMA_FlowCtrl != DMA_FlowCtrl_Memory)
;;;558      {
;;;559        /* Configure DMA_SxCR_PFCTRL bit with the input parameter */
;;;560        DMAy_Streamx->CR |= (uint32_t)DMA_SxCR_PFCTRL;   
000002  6802              LDR      r2,[r0,#0]
000004  f0420220          ORR      r2,r2,#0x20
000008  6002              STR      r2,[r0,#0]
00000a  e003              B        |L7.20|
                  |L7.12|
;;;561      }
;;;562      else
;;;563      {
;;;564        /* Clear the PFCTRL bit: Memory is the flow controller */
;;;565        DMAy_Streamx->CR &= ~(uint32_t)DMA_SxCR_PFCTRL;    
00000c  6802              LDR      r2,[r0,#0]
00000e  f0220220          BIC      r2,r2,#0x20
000012  6002              STR      r2,[r0,#0]
                  |L7.20|
;;;566      }
;;;567    }
000014  4770              BX       lr
;;;568    /**
                          ENDP


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

                  DMA_GetCmdStatus PROC
;;;942      */
;;;943    FunctionalState DMA_GetCmdStatus(DMA_Stream_TypeDef* DMAy_Streamx)
000000  4601              MOV      r1,r0
;;;944    {
;;;945      FunctionalState state = DISABLE;
000002  2000              MOVS     r0,#0
;;;946    
;;;947      /* Check the parameters */
;;;948      assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;949    
;;;950      if ((DMAy_Streamx->CR & (uint32_t)DMA_SxCR_EN) != 0)
000004  680a              LDR      r2,[r1,#0]
000006  f0020201          AND      r2,r2,#1
00000a  b10a              CBZ      r2,|L8.16|
;;;951      {
;;;952        /* The selected DMAy Streamx EN bit is set (DMA is still transferring) */
;;;953        state = ENABLE;
00000c  2001              MOVS     r0,#1
00000e  e000              B        |L8.18|
                  |L8.16|
;;;954      }
;;;955      else
;;;956      {
;;;957        /* The selected DMAy Streamx EN bit is cleared (DMA is disabled and 
;;;958            all transfers are complete) */
;;;959        state = DISABLE;
000010  2000              MOVS     r0,#0
                  |L8.18|
;;;960      }
;;;961      return state;
;;;962    }
000012  4770              BX       lr
;;;963    
                          ENDP


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

                  DMA_GetCurrDataCounter PROC
;;;646      */
;;;647    uint16_t DMA_GetCurrDataCounter(DMA_Stream_TypeDef* DMAy_Streamx)
000000  4601              MOV      r1,r0
;;;648    {
;;;649      /* Check the parameters */
;;;650      assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;651    
;;;652      /* Return the number of remaining data units for DMAy Streamx */
;;;653      return ((uint16_t)(DMAy_Streamx->NDTR));
000002  6848              LDR      r0,[r1,#4]
000004  b280              UXTH     r0,r0
;;;654    }
000006  4770              BX       lr
;;;655    /**
                          ENDP


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

                  DMA_GetCurrentMemoryTarget PROC
;;;827      */
;;;828    uint32_t DMA_GetCurrentMemoryTarget(DMA_Stream_TypeDef* DMAy_Streamx)
000000  4601              MOV      r1,r0
;;;829    {
;;;830      uint32_t tmp = 0;
000002  2000              MOVS     r0,#0
;;;831      
;;;832      /* Check the parameters */
;;;833      assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;834    
;;;835      /* Get the current memory target */
;;;836      if ((DMAy_Streamx->CR & DMA_SxCR_CT) != 0)
000004  680a              LDR      r2,[r1,#0]
000006  f4022200          AND      r2,r2,#0x80000
00000a  b10a              CBZ      r2,|L10.16|
;;;837      {
;;;838        /* Current memory buffer used is Memory 1 */
;;;839        tmp = 1;
00000c  2001              MOVS     r0,#1
00000e  e000              B        |L10.18|
                  |L10.16|
;;;840      }  
;;;841      else
;;;842      {
;;;843        /* Current memory buffer used is Memory 0 */
;;;844        tmp = 0;    
000010  2000              MOVS     r0,#0
                  |L10.18|
;;;845      }
;;;846      return tmp;
;;;847    }
000012  4770              BX       lr
;;;848    /**
                          ENDP


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

                  DMA_GetFIFOStatus PROC
;;;976      */
;;;977    uint32_t DMA_GetFIFOStatus(DMA_Stream_TypeDef* DMAy_Streamx)
000000  4601              MOV      r1,r0
;;;978    {
;;;979      uint32_t tmpreg = 0;
000002  2000              MOVS     r0,#0
;;;980     
;;;981      /* Check the parameters */
;;;982      assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;983      
;;;984      /* Get the FIFO level bits */
;;;985      tmpreg = (uint32_t)((DMAy_Streamx->FCR & DMA_SxFCR_FS));
000004  694a              LDR      r2,[r1,#0x14]
000006  f0020038          AND      r0,r2,#0x38
;;;986      
;;;987      return tmpreg;
;;;988    }
00000a  4770              BX       lr
;;;989    
                          ENDP


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

                  DMA_GetFlagStatus PROC
;;;1003     */
;;;1004   FlagStatus DMA_GetFlagStatus(DMA_Stream_TypeDef* DMAy_Streamx, uint32_t DMA_FLAG)
000000  b530              PUSH     {r4,r5,lr}
;;;1005   {
000002  4603              MOV      r3,r0
000004  460a              MOV      r2,r1
;;;1006     FlagStatus bitstatus = RESET;
000006  2000              MOVS     r0,#0
;;;1007     DMA_TypeDef* DMAy;
;;;1008     uint32_t tmpreg = 0;
000008  2400              MOVS     r4,#0
;;;1009   
;;;1010     /* Check the parameters */
;;;1011     assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;1012     assert_param(IS_DMA_GET_FLAG(DMA_FLAG));
;;;1013   
;;;1014     /* Determine the DMA to which belongs the stream */
;;;1015     if (DMAy_Streamx < DMA2_Stream0)
00000a  4d0b              LDR      r5,|L12.56|
00000c  42ab              CMP      r3,r5
00000e  d201              BCS      |L12.20|
;;;1016     {
;;;1017       /* DMAy_Streamx belongs to DMA1 */
;;;1018       DMAy = DMA1; 
000010  490a              LDR      r1,|L12.60|
000012  e001              B        |L12.24|
                  |L12.20|
;;;1019     } 
;;;1020     else 
;;;1021     {
;;;1022       /* DMAy_Streamx belongs to DMA2 */
;;;1023       DMAy = DMA2; 
000014  4908              LDR      r1,|L12.56|
000016  3910              SUBS     r1,r1,#0x10
                  |L12.24|
;;;1024     }
;;;1025   
;;;1026     /* Check if the flag is in HISR or LISR */
;;;1027     if ((DMA_FLAG & HIGH_ISR_MASK) != (uint32_t)RESET)
000018  f0025500          AND      r5,r2,#0x20000000
00001c  b10d              CBZ      r5,|L12.34|
;;;1028     {
;;;1029       /* Get DMAy HISR register value */
;;;1030       tmpreg = DMAy->HISR;
00001e  684c              LDR      r4,[r1,#4]
000020  e000              B        |L12.36|
                  |L12.34|
;;;1031     }
;;;1032     else
;;;1033     {
;;;1034       /* Get DMAy LISR register value */
;;;1035       tmpreg = DMAy->LISR;
000022  680c              LDR      r4,[r1,#0]
                  |L12.36|
;;;1036     }   
;;;1037    
;;;1038     /* Mask the reserved bits */
;;;1039     tmpreg &= (uint32_t)RESERVED_MASK;
000024  4d06              LDR      r5,|L12.64|
000026  402c              ANDS     r4,r4,r5
;;;1040   
;;;1041     /* Check the status of the specified DMA flag */
;;;1042     if ((tmpreg & DMA_FLAG) != (uint32_t)RESET)
000028  ea040502          AND      r5,r4,r2
00002c  b10d              CBZ      r5,|L12.50|
;;;1043     {
;;;1044       /* DMA_FLAG is set */
;;;1045       bitstatus = SET;
00002e  2001              MOVS     r0,#1
000030  e000              B        |L12.52|
                  |L12.50|
;;;1046     }
;;;1047     else
;;;1048     {
;;;1049       /* DMA_FLAG is reset */
;;;1050       bitstatus = RESET;
000032  2000              MOVS     r0,#0
                  |L12.52|
;;;1051     }
;;;1052   
;;;1053     /* Return the DMA_FLAG status */
;;;1054     return  bitstatus;
;;;1055   }
000034  bd30              POP      {r4,r5,pc}
;;;1056   
                          ENDP

000036  0000              DCW      0x0000
                  |L12.56|
                          DCD      0x40026410
                  |L12.60|
                          DCD      0x40026000
                  |L12.64|
                          DCD      0x0f7d0f7d

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

                  DMA_GetITStatus PROC
;;;1169     */
;;;1170   ITStatus DMA_GetITStatus(DMA_Stream_TypeDef* DMAy_Streamx, uint32_t DMA_IT)
000000  b570              PUSH     {r4-r6,lr}
;;;1171   {
000002  4602              MOV      r2,r0
;;;1172     ITStatus bitstatus = RESET;
000004  2000              MOVS     r0,#0
;;;1173     DMA_TypeDef* DMAy;
;;;1174     uint32_t tmpreg = 0, enablestatus = 0;
000006  2400              MOVS     r4,#0
000008  2500              MOVS     r5,#0
;;;1175   
;;;1176     /* Check the parameters */
;;;1177     assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;1178     assert_param(IS_DMA_GET_IT(DMA_IT));
;;;1179    
;;;1180     /* Determine the DMA to which belongs the stream */
;;;1181     if (DMAy_Streamx < DMA2_Stream0)
00000a  4e12              LDR      r6,|L13.84|
00000c  42b2              CMP      r2,r6
00000e  d201              BCS      |L13.20|
;;;1182     {
;;;1183       /* DMAy_Streamx belongs to DMA1 */
;;;1184       DMAy = DMA1; 
000010  4b11              LDR      r3,|L13.88|
000012  e001              B        |L13.24|
                  |L13.20|
;;;1185     } 
;;;1186     else 
;;;1187     {
;;;1188       /* DMAy_Streamx belongs to DMA2 */
;;;1189       DMAy = DMA2; 
000014  4b0f              LDR      r3,|L13.84|
000016  3b10              SUBS     r3,r3,#0x10
                  |L13.24|
;;;1190     }
;;;1191   
;;;1192     /* Check if the interrupt enable bit is in the CR or FCR register */
;;;1193     if ((DMA_IT & TRANSFER_IT_MASK) != (uint32_t)RESET)
000018  4e10              LDR      r6,|L13.92|
00001a  400e              ANDS     r6,r6,r1
00001c  b136              CBZ      r6,|L13.44|
;;;1194     {
;;;1195       /* Get the interrupt enable position mask in CR register */
;;;1196       tmpreg = (uint32_t)((DMA_IT >> 11) & TRANSFER_IT_ENABLE_MASK);   
00001e  261e              MOVS     r6,#0x1e
000020  ea0624d1          AND      r4,r6,r1,LSR #11
;;;1197       
;;;1198       /* Check the enable bit in CR register */
;;;1199       enablestatus = (uint32_t)(DMAy_Streamx->CR & tmpreg);
000024  6816              LDR      r6,[r2,#0]
000026  ea060504          AND      r5,r6,r4
00002a  e002              B        |L13.50|
                  |L13.44|
;;;1200     }
;;;1201     else 
;;;1202     {
;;;1203       /* Check the enable bit in FCR register */
;;;1204       enablestatus = (uint32_t)(DMAy_Streamx->FCR & DMA_IT_FE); 
00002c  6956              LDR      r6,[r2,#0x14]
00002e  f0060580          AND      r5,r6,#0x80
                  |L13.50|
;;;1205     }
;;;1206    
;;;1207     /* Check if the interrupt pending flag is in LISR or HISR */
;;;1208     if ((DMA_IT & HIGH_ISR_MASK) != (uint32_t)RESET)
000032  f0015600          AND      r6,r1,#0x20000000
000036  b10e              CBZ      r6,|L13.60|
;;;1209     {
;;;1210       /* Get DMAy HISR register value */
;;;1211       tmpreg = DMAy->HISR ;
000038  685c              LDR      r4,[r3,#4]
00003a  e000              B        |L13.62|
                  |L13.60|
;;;1212     }
;;;1213     else
;;;1214     {
;;;1215       /* Get DMAy LISR register value */
;;;1216       tmpreg = DMAy->LISR ;
00003c  681c              LDR      r4,[r3,#0]
                  |L13.62|
;;;1217     } 
;;;1218   
;;;1219     /* mask all reserved bits */
;;;1220     tmpreg &= (uint32_t)RESERVED_MASK;
00003e  4e08              LDR      r6,|L13.96|
000040  4034              ANDS     r4,r4,r6
;;;1221   
;;;1222     /* Check the status of the specified DMA interrupt */
;;;1223     if (((tmpreg & DMA_IT) != (uint32_t)RESET) && (enablestatus != (uint32_t)RESET))
000042  ea040601          AND      r6,r4,r1
000046  b116              CBZ      r6,|L13.78|
000048  b10d              CBZ      r5,|L13.78|
;;;1224     {
;;;1225       /* DMA_IT is set */
;;;1226       bitstatus = SET;
00004a  2001              MOVS     r0,#1
00004c  e000              B        |L13.80|
                  |L13.78|
;;;1227     }
;;;1228     else
;;;1229     {
;;;1230       /* DMA_IT is reset */
;;;1231       bitstatus = RESET;
00004e  2000              MOVS     r0,#0
                  |L13.80|
;;;1232     }
;;;1233   
;;;1234     /* Return the DMA_IT status */
;;;1235     return  bitstatus;
;;;1236   }
000050  bd70              POP      {r4-r6,pc}
;;;1237   
                          ENDP

000052  0000              DCW      0x0000
                  |L13.84|
                          DCD      0x40026410
                  |L13.88|
                          DCD      0x40026000
                  |L13.92|
                          DCD      0x0f3c0f3c
                  |L13.96|
                          DCD      0x0f7d0f7d

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

                  DMA_ITConfig PROC
;;;1117     */
;;;1118   void DMA_ITConfig(DMA_Stream_TypeDef* DMAy_Streamx, uint32_t DMA_IT, FunctionalState NewState)
000000  b510              PUSH     {r4,lr}
;;;1119   {
;;;1120     /* Check the parameters */
;;;1121     assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;1122     assert_param(IS_DMA_CONFIG_IT(DMA_IT));
;;;1123     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1124   
;;;1125     /* Check if the DMA_IT parameter contains a FIFO interrupt */
;;;1126     if ((DMA_IT & DMA_IT_FE) != 0)
000002  f0010380          AND      r3,r1,#0x80
000006  b14b              CBZ      r3,|L14.28|
;;;1127     {
;;;1128       if (NewState != DISABLE)
000008  b122              CBZ      r2,|L14.20|
;;;1129       {
;;;1130         /* Enable the selected DMA FIFO interrupts */
;;;1131         DMAy_Streamx->FCR |= (uint32_t)DMA_IT_FE;
00000a  6943              LDR      r3,[r0,#0x14]
00000c  f0430380          ORR      r3,r3,#0x80
000010  6143              STR      r3,[r0,#0x14]
000012  e003              B        |L14.28|
                  |L14.20|
;;;1132       }    
;;;1133       else 
;;;1134       {
;;;1135         /* Disable the selected DMA FIFO interrupts */
;;;1136         DMAy_Streamx->FCR &= ~(uint32_t)DMA_IT_FE;  
000014  6943              LDR      r3,[r0,#0x14]
000016  f0230380          BIC      r3,r3,#0x80
00001a  6143              STR      r3,[r0,#0x14]
                  |L14.28|
;;;1137       }
;;;1138     }
;;;1139   
;;;1140     /* Check if the DMA_IT parameter contains a Transfer interrupt */
;;;1141     if (DMA_IT != DMA_IT_FE)
00001c  2980              CMP      r1,#0x80
00001e  d00b              BEQ      |L14.56|
;;;1142     {
;;;1143       if (NewState != DISABLE)
000020  b12a              CBZ      r2,|L14.46|
;;;1144       {
;;;1145         /* Enable the selected DMA transfer interrupts */
;;;1146         DMAy_Streamx->CR |= (uint32_t)(DMA_IT  & TRANSFER_IT_ENABLE_MASK);
000022  6803              LDR      r3,[r0,#0]
000024  f001041e          AND      r4,r1,#0x1e
000028  4323              ORRS     r3,r3,r4
00002a  6003              STR      r3,[r0,#0]
00002c  e004              B        |L14.56|
                  |L14.46|
;;;1147       }
;;;1148       else
;;;1149       {
;;;1150         /* Disable the selected DMA transfer interrupts */
;;;1151         DMAy_Streamx->CR &= ~(uint32_t)(DMA_IT & TRANSFER_IT_ENABLE_MASK);
00002e  6803              LDR      r3,[r0,#0]
000030  f001041e          AND      r4,r1,#0x1e
000034  43a3              BICS     r3,r3,r4
000036  6003              STR      r3,[r0,#0]
                  |L14.56|
;;;1152       }    
;;;1153     }
;;;1154   }
000038  bd10              POP      {r4,pc}
;;;1155   
                          ENDP


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

                  DMA_Init PROC
;;;318      */
;;;319    void DMA_Init(DMA_Stream_TypeDef* DMAy_Streamx, DMA_InitTypeDef* DMA_InitStruct)
000000  b510              PUSH     {r4,lr}
;;;320    {
;;;321      uint32_t tmpreg = 0;
000002  2200              MOVS     r2,#0
;;;322    
;;;323      /* Check the parameters */
;;;324      assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;325      assert_param(IS_DMA_CHANNEL(DMA_InitStruct->DMA_Channel));
;;;326      assert_param(IS_DMA_DIRECTION(DMA_InitStruct->DMA_DIR));
;;;327      assert_param(IS_DMA_BUFFER_SIZE(DMA_InitStruct->DMA_BufferSize));
;;;328      assert_param(IS_DMA_PERIPHERAL_INC_STATE(DMA_InitStruct->DMA_PeripheralInc));
;;;329      assert_param(IS_DMA_MEMORY_INC_STATE(DMA_InitStruct->DMA_MemoryInc));
;;;330      assert_param(IS_DMA_PERIPHERAL_DATA_SIZE(DMA_InitStruct->DMA_PeripheralDataSize));
;;;331      assert_param(IS_DMA_MEMORY_DATA_SIZE(DMA_InitStruct->DMA_MemoryDataSize));
;;;332      assert_param(IS_DMA_MODE(DMA_InitStruct->DMA_Mode));
;;;333      assert_param(IS_DMA_PRIORITY(DMA_InitStruct->DMA_Priority));
;;;334      assert_param(IS_DMA_FIFO_MODE_STATE(DMA_InitStruct->DMA_FIFOMode));
;;;335      assert_param(IS_DMA_FIFO_THRESHOLD(DMA_InitStruct->DMA_FIFOThreshold));
;;;336      assert_param(IS_DMA_MEMORY_BURST(DMA_InitStruct->DMA_MemoryBurst));
;;;337      assert_param(IS_DMA_PERIPHERAL_BURST(DMA_InitStruct->DMA_PeripheralBurst));
;;;338    
;;;339      /*------------------------- DMAy Streamx CR Configuration ------------------*/
;;;340      /* Get the DMAy_Streamx CR value */
;;;341      tmpreg = DMAy_Streamx->CR;
000004  6802              LDR      r2,[r0,#0]
;;;342    
;;;343      /* Clear CHSEL, MBURST, PBURST, PL, MSIZE, PSIZE, MINC, PINC, CIRC and DIR bits */
;;;344      tmpreg &= ((uint32_t)~(DMA_SxCR_CHSEL | DMA_SxCR_MBURST | DMA_SxCR_PBURST | \
000006  4b13              LDR      r3,|L15.84|
000008  401a              ANDS     r2,r2,r3
;;;345                             DMA_SxCR_PL | DMA_SxCR_MSIZE | DMA_SxCR_PSIZE | \
;;;346                             DMA_SxCR_MINC | DMA_SxCR_PINC | DMA_SxCR_CIRC | \
;;;347                             DMA_SxCR_DIR));
;;;348    
;;;349      /* Configure DMAy Streamx: */
;;;350      /* Set CHSEL bits according to DMA_CHSEL value */
;;;351      /* Set DIR bits according to DMA_DIR value */
;;;352      /* Set PINC bit according to DMA_PeripheralInc value */
;;;353      /* Set MINC bit according to DMA_MemoryInc value */
;;;354      /* Set PSIZE bits according to DMA_PeripheralDataSize value */
;;;355      /* Set MSIZE bits according to DMA_MemoryDataSize value */
;;;356      /* Set CIRC bit according to DMA_Mode value */
;;;357      /* Set PL bits according to DMA_Priority value */
;;;358      /* Set MBURST bits according to DMA_MemoryBurst value */
;;;359      /* Set PBURST bits according to DMA_PeripheralBurst value */
;;;360      tmpreg |= DMA_InitStruct->DMA_Channel | DMA_InitStruct->DMA_DIR |
00000a  68cc              LDR      r4,[r1,#0xc]
00000c  680b              LDR      r3,[r1,#0]
00000e  4323              ORRS     r3,r3,r4
000010  694c              LDR      r4,[r1,#0x14]
000012  4323              ORRS     r3,r3,r4
000014  698c              LDR      r4,[r1,#0x18]
000016  4323              ORRS     r3,r3,r4
000018  69cc              LDR      r4,[r1,#0x1c]
00001a  4323              ORRS     r3,r3,r4
00001c  6a0c              LDR      r4,[r1,#0x20]
00001e  4323              ORRS     r3,r3,r4
000020  6a4c              LDR      r4,[r1,#0x24]
000022  4323              ORRS     r3,r3,r4
000024  6a8c              LDR      r4,[r1,#0x28]
000026  4323              ORRS     r3,r3,r4
000028  6b4c              LDR      r4,[r1,#0x34]
00002a  4323              ORRS     r3,r3,r4
00002c  6b8c              LDR      r4,[r1,#0x38]
00002e  4323              ORRS     r3,r3,r4
000030  431a              ORRS     r2,r2,r3
;;;361                DMA_InitStruct->DMA_PeripheralInc | DMA_InitStruct->DMA_MemoryInc |
;;;362                DMA_InitStruct->DMA_PeripheralDataSize | DMA_InitStruct->DMA_MemoryDataSize |
;;;363                DMA_InitStruct->DMA_Mode | DMA_InitStruct->DMA_Priority |
;;;364                DMA_InitStruct->DMA_MemoryBurst | DMA_InitStruct->DMA_PeripheralBurst;
;;;365    
;;;366      /* Write to DMAy Streamx CR register */
;;;367      DMAy_Streamx->CR = tmpreg;
000032  6002              STR      r2,[r0,#0]
;;;368    
;;;369      /*------------------------- DMAy Streamx FCR Configuration -----------------*/
;;;370      /* Get the DMAy_Streamx FCR value */
;;;371      tmpreg = DMAy_Streamx->FCR;
000034  6942              LDR      r2,[r0,#0x14]
;;;372    
;;;373      /* Clear DMDIS and FTH bits */
;;;374      tmpreg &= (uint32_t)~(DMA_SxFCR_DMDIS | DMA_SxFCR_FTH);
000036  f0220207          BIC      r2,r2,#7
;;;375    
;;;376      /* Configure DMAy Streamx FIFO: 
;;;377        Set DMDIS bits according to DMA_FIFOMode value 
;;;378        Set FTH bits according to DMA_FIFOThreshold value */
;;;379      tmpreg |= DMA_InitStruct->DMA_FIFOMode | DMA_InitStruct->DMA_FIFOThreshold;
00003a  e9d1340b          LDRD     r3,r4,[r1,#0x2c]
00003e  4323              ORRS     r3,r3,r4
000040  431a              ORRS     r2,r2,r3
;;;380    
;;;381      /* Write to DMAy Streamx CR */
;;;382      DMAy_Streamx->FCR = tmpreg;
000042  6142              STR      r2,[r0,#0x14]
;;;383    
;;;384      /*------------------------- DMAy Streamx NDTR Configuration ----------------*/
;;;385      /* Write to DMAy Streamx NDTR register */
;;;386      DMAy_Streamx->NDTR = DMA_InitStruct->DMA_BufferSize;
000044  690b              LDR      r3,[r1,#0x10]
000046  6043              STR      r3,[r0,#4]
;;;387    
;;;388      /*------------------------- DMAy Streamx PAR Configuration -----------------*/
;;;389      /* Write to DMAy Streamx PAR */
;;;390      DMAy_Streamx->PAR = DMA_InitStruct->DMA_PeripheralBaseAddr;
000048  684b              LDR      r3,[r1,#4]
00004a  6083              STR      r3,[r0,#8]
;;;391    
;;;392      /*------------------------- DMAy Streamx M0AR Configuration ----------------*/
;;;393      /* Write to DMAy Streamx M0AR */
;;;394      DMAy_Streamx->M0AR = DMA_InitStruct->DMA_Memory0BaseAddr;
00004c  688b              LDR      r3,[r1,#8]
00004e  60c3              STR      r3,[r0,#0xc]
;;;395    }
000050  bd10              POP      {r4,pc}
;;;396    
                          ENDP

000052  0000              DCW      0x0000
                  |L15.84|
                          DCD      0xf01c803f

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

                  DMA_MemoryTargetConfig PROC
;;;801      */
;;;802    void DMA_MemoryTargetConfig(DMA_Stream_TypeDef* DMAy_Streamx, uint32_t MemoryBaseAddr,
000000  b10a              CBZ      r2,|L16.6|
;;;803                               uint32_t DMA_MemoryTarget)
;;;804    {
;;;805      /* Check the parameters */
;;;806      assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;807      assert_param(IS_DMA_CURRENT_MEM(DMA_MemoryTarget));
;;;808        
;;;809      /* Check the Memory target to be configured */
;;;810      if (DMA_MemoryTarget != DMA_Memory_0)
;;;811      {
;;;812        /* Write to DMAy Streamx M1AR */
;;;813        DMAy_Streamx->M1AR = MemoryBaseAddr;    
000002  6101              STR      r1,[r0,#0x10]
000004  e000              B        |L16.8|
                  |L16.6|
;;;814      }  
;;;815      else
;;;816      {
;;;817        /* Write to DMAy Streamx M0AR */
;;;818        DMAy_Streamx->M0AR = MemoryBaseAddr;  
000006  60c1              STR      r1,[r0,#0xc]
                  |L16.8|
;;;819      }
;;;820    }
000008  4770              BX       lr
;;;821    
                          ENDP


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

                  DMA_PeriphIncOffsetSizeConfig PROC
;;;513      */
;;;514    void DMA_PeriphIncOffsetSizeConfig(DMA_Stream_TypeDef* DMAy_Streamx, uint32_t DMA_Pincos)
000000  b121              CBZ      r1,|L17.12|
;;;515    {
;;;516      /* Check the parameters */
;;;517      assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;518      assert_param(IS_DMA_PINCOS_SIZE(DMA_Pincos));
;;;519    
;;;520      /* Check the needed Peripheral increment offset */
;;;521      if(DMA_Pincos != DMA_PINCOS_Psize)
;;;522      {
;;;523        /* Configure DMA_SxCR_PINCOS bit with the input parameter */
;;;524        DMAy_Streamx->CR |= (uint32_t)DMA_SxCR_PINCOS;     
000002  6802              LDR      r2,[r0,#0]
000004  f4424200          ORR      r2,r2,#0x8000
000008  6002              STR      r2,[r0,#0]
00000a  e003              B        |L17.20|
                  |L17.12|
;;;525      }
;;;526      else
;;;527      {
;;;528        /* Clear the PINCOS bit: Peripheral address incremented according to PSIZE */
;;;529        DMAy_Streamx->CR &= ~(uint32_t)DMA_SxCR_PINCOS;    
00000c  6802              LDR      r2,[r0,#0]
00000e  f4224200          BIC      r2,r2,#0x8000
000012  6002              STR      r2,[r0,#0]
                  |L17.20|
;;;530      }
;;;531    }
000014  4770              BX       lr
;;;532    
                          ENDP


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

                  DMA_SetCurrDataCounter PROC
;;;631      */
;;;632    void DMA_SetCurrDataCounter(DMA_Stream_TypeDef* DMAy_Streamx, uint16_t Counter)
000000  6041              STR      r1,[r0,#4]
;;;633    {
;;;634      /* Check the parameters */
;;;635      assert_param(IS_DMA_ALL_PERIPH(DMAy_Streamx));
;;;636    
;;;637      /* Write the number of data units to be transferred */
;;;638      DMAy_Streamx->NDTR = (uint16_t)Counter;
;;;639    }
000002  4770              BX       lr
;;;640    
                          ENDP


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

                  DMA_StructInit PROC
;;;402      */
;;;403    void DMA_StructInit(DMA_InitTypeDef* DMA_InitStruct)
000000  2100              MOVS     r1,#0
;;;404    {
;;;405      /*-------------- Reset DMA init structure parameters values ----------------*/
;;;406      /* Initialize the DMA_Channel member */
;;;407      DMA_InitStruct->DMA_Channel = 0;
000002  6001              STR      r1,[r0,#0]
;;;408    
;;;409      /* Initialize the DMA_PeripheralBaseAddr member */
;;;410      DMA_InitStruct->DMA_PeripheralBaseAddr = 0;
000004  6041              STR      r1,[r0,#4]
;;;411    
;;;412      /* Initialize the DMA_Memory0BaseAddr member */
;;;413      DMA_InitStruct->DMA_Memory0BaseAddr = 0;
000006  6081              STR      r1,[r0,#8]
;;;414    
;;;415      /* Initialize the DMA_DIR member */
;;;416      DMA_InitStruct->DMA_DIR = DMA_DIR_PeripheralToMemory;
000008  60c1              STR      r1,[r0,#0xc]
;;;417    
;;;418      /* Initialize the DMA_BufferSize member */
;;;419      DMA_InitStruct->DMA_BufferSize = 0;
00000a  6101              STR      r1,[r0,#0x10]
;;;420    
;;;421      /* Initialize the DMA_PeripheralInc member */
;;;422      DMA_InitStruct->DMA_PeripheralInc = DMA_PeripheralInc_Disable;
00000c  6141              STR      r1,[r0,#0x14]
;;;423    
;;;424      /* Initialize the DMA_MemoryInc member */
;;;425      DMA_InitStruct->DMA_MemoryInc = DMA_MemoryInc_Disable;
00000e  6181              STR      r1,[r0,#0x18]
;;;426    
;;;427      /* Initialize the DMA_PeripheralDataSize member */
;;;428      DMA_InitStruct->DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
000010  61c1              STR      r1,[r0,#0x1c]
;;;429    
;;;430      /* Initialize the DMA_MemoryDataSize member */
;;;431      DMA_InitStruct->DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
000012  6201              STR      r1,[r0,#0x20]
;;;432    
;;;433      /* Initialize the DMA_Mode member */
;;;434      DMA_InitStruct->DMA_Mode = DMA_Mode_Normal;
000014  6241              STR      r1,[r0,#0x24]
;;;435    
;;;436      /* Initialize the DMA_Priority member */
;;;437      DMA_InitStruct->DMA_Priority = DMA_Priority_Low;
000016  6281              STR      r1,[r0,#0x28]
;;;438    
;;;439      /* Initialize the DMA_FIFOMode member */
;;;440      DMA_InitStruct->DMA_FIFOMode = DMA_FIFOMode_Disable;
000018  62c1              STR      r1,[r0,#0x2c]
;;;441    
;;;442      /* Initialize the DMA_FIFOThreshold member */
;;;443      DMA_InitStruct->DMA_FIFOThreshold = DMA_FIFOThreshold_1QuarterFull;
00001a  6301              STR      r1,[r0,#0x30]
;;;444    
;;;445      /* Initialize the DMA_MemoryBurst member */
;;;446      DMA_InitStruct->DMA_MemoryBurst = DMA_MemoryBurst_Single;
00001c  6341              STR      r1,[r0,#0x34]
;;;447    
;;;448      /* Initialize the DMA_PeripheralBurst member */
;;;449      DMA_InitStruct->DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
00001e  6381              STR      r1,[r0,#0x38]
;;;450    }
000020  4770              BX       lr
;;;451    
                          ENDP


;*** Start embedded assembler ***

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

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

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
