; 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\bootloader\mico-fire_f429\obj_rvmdk\stm32f4xx_dma2d.o --asm_dir=..\..\..\..\Build\Bootloader\MICO-Fire_F429\list_RVMDK\ --list_dir=..\..\..\..\Build\Bootloader\MICO-Fire_F429\list_RVMDK\ --depend=..\..\..\..\build\bootloader\mico-fire_f429\obj_rvmdk\stm32f4xx_dma2d.d --cpu=Cortex-M4.fp --apcs=interwork --diag_suppress=9931,1,1293 -I..\..\..\..\Bootloader -I..\..\..\..\Board\fire_F429 -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 -IG:\GIT_OSC\F429_OV2640_MICO_SDRAM\Projects\STM32F429\bootloader\RVMDK\RTE -ID:\work\keil5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0\Drivers\CMSIS\Device\ST\STM32F4xx\Include -ID:\work\keil5\ARM\CMSIS\Include -ID:\work\keil5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0 -D__MICROLIB -D__UVISION_VERSION=516 -DSTM32F429xx -DUSE_STDPERIPH_DRIVER -DBOOTLOADER -DNO_MICO_RTOS -DHSE_VALUE=25000000 --omf_browse=..\..\..\..\build\bootloader\mico-fire_f429\obj_rvmdk\stm32f4xx_dma2d.crf ..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries\STM32F4xx_StdPeriph_Driver\src\stm32f4xx_dma2d.c]
                          THUMB

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

                  DMA2D_AbortTransfer PROC
;;;259    
;;;260    void DMA2D_AbortTransfer(void)
000000  4802              LDR      r0,|L1.12|
;;;261    {
;;;262        /* Start DMA2D transfer by setting START bit */
;;;263        DMA2D->CR |= (uint32_t)DMA2D_CR_ABORT;
000002  6801              LDR      r1,[r0,#0]
000004  f0410104          ORR      r1,r1,#4
000008  6001              STR      r1,[r0,#0]
;;;264    
;;;265    }
00000a  4770              BX       lr
;;;266    
                          ENDP

                  |L1.12|
                          DCD      0x4002b000

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

                  DMA2D_BGConfig PROC
;;;394      */
;;;395    void DMA2D_BGConfig(DMA2D_BG_InitTypeDef* DMA2D_BG_InitStruct)
000000  b570              PUSH     {r4-r6,lr}
;;;396    {
;;;397    
;;;398      uint32_t bg_clutcolormode = 0;
;;;399      uint32_t bg_clutsize = 0;
;;;400      uint32_t bg_alpha_mode = 0;
;;;401      uint32_t bg_alphavalue = 0;
;;;402      uint32_t bg_colorgreen = 0;
;;;403      uint32_t bg_colorred = 0;
;;;404    
;;;405      assert_param(IS_DMA2D_BGO(DMA2D_BG_InitStruct->DMA2D_BGO));
;;;406      assert_param(IS_DMA2D_BGCM(DMA2D_BG_InitStruct->DMA2D_BGCM));
;;;407      assert_param(IS_DMA2D_BG_CLUT_CM(DMA2D_BG_InitStruct->DMA2D_BG_CLUT_CM));
;;;408      assert_param(IS_DMA2D_BG_CLUT_SIZE(DMA2D_BG_InitStruct->DMA2D_BG_CLUT_SIZE));
;;;409      assert_param(IS_DMA2D_BG_ALPHA_MODE(DMA2D_BG_InitStruct->DMA2D_BGPFC_ALPHA_MODE));
;;;410      assert_param(IS_DMA2D_BG_ALPHA_VALUE(DMA2D_BG_InitStruct->DMA2D_BGPFC_ALPHA_VALUE));
;;;411      assert_param(IS_DMA2D_BGC_BLUE(DMA2D_BG_InitStruct->DMA2D_BGC_BLUE));
;;;412      assert_param(IS_DMA2D_BGC_GREEN(DMA2D_BG_InitStruct->DMA2D_BGC_GREEN));
;;;413      assert_param(IS_DMA2D_BGC_RED(DMA2D_BG_InitStruct->DMA2D_BGC_RED));
;;;414    
;;;415      /* Configures the BG memory address */
;;;416      DMA2D->BGMAR = (DMA2D_BG_InitStruct->DMA2D_BGMA);
000002  4918              LDR      r1,|L2.100|
000004  6802              LDR      r2,[r0,#0]
000006  614a              STR      r2,[r1,#0x14]
;;;417    
;;;418      /* Configures the BG offset */
;;;419      DMA2D->BGOR &= ~(uint32_t)DMA2D_BGOR_LO;
000008  698a              LDR      r2,[r1,#0x18]
00000a  f36f020d          BFC      r2,#0,#14
00000e  618a              STR      r2,[r1,#0x18]
;;;420      DMA2D->BGOR |= (DMA2D_BG_InitStruct->DMA2D_BGO);
000010  698a              LDR      r2,[r1,#0x18]
000012  6843              LDR      r3,[r0,#4]
000014  431a              ORRS     r2,r2,r3
000016  618a              STR      r2,[r1,#0x18]
;;;421    
;;;422      /* Configures background Pixel Format Convertor */
;;;423      DMA2D->BGPFCCR &= (uint32_t)PFCCR_MASK;
000018  6a4a              LDR      r2,[r1,#0x24]
00001a  4b13              LDR      r3,|L2.104|
00001c  401a              ANDS     r2,r2,r3
00001e  624a              STR      r2,[r1,#0x24]
;;;424      bg_clutcolormode = DMA2D_BG_InitStruct->DMA2D_BG_CLUT_CM << 4;
;;;425      bg_clutsize = DMA2D_BG_InitStruct->DMA2D_BG_CLUT_SIZE << 8;
;;;426      bg_alpha_mode = DMA2D_BG_InitStruct->DMA2D_BGPFC_ALPHA_MODE << 16;
000020  8a84              LDRH     r4,[r0,#0x14]
;;;427      bg_alphavalue = DMA2D_BG_InitStruct->DMA2D_BGPFC_ALPHA_VALUE << 24;
;;;428      DMA2D->BGPFCCR |= (DMA2D_BG_InitStruct->DMA2D_BGCM | bg_clutcolormode | bg_clutsize | \
000022  e9d06202          LDRD     r6,r2,[r0,#8]
000026  0425              LSLS     r5,r4,#16             ;426
000028  6903              LDR      r3,[r0,#0x10]
00002a  ea461602          ORR      r6,r6,r2,LSL #4
00002e  7e04              LDRB     r4,[r0,#0x18]         ;427
000030  ea452303          ORR      r3,r5,r3,LSL #8
000034  431e              ORRS     r6,r6,r3
000036  6a4a              LDR      r2,[r1,#0x24]
000038  ea466604          ORR      r6,r6,r4,LSL #24
00003c  4316              ORRS     r6,r6,r2
00003e  624e              STR      r6,[r1,#0x24]
;;;429                        bg_alpha_mode | bg_alphavalue);
;;;430    
;;;431      /* Configures background color */
;;;432      DMA2D->BGCOLR &= ~(DMA2D_BGCOLR_BLUE | DMA2D_BGCOLR_GREEN | DMA2D_BGCOLR_RED);
000040  6a8a              LDR      r2,[r1,#0x28]
000042  f002427f          AND      r2,r2,#0xff000000
000046  628a              STR      r2,[r1,#0x28]
;;;433      bg_colorgreen = DMA2D_BG_InitStruct->DMA2D_BGC_GREEN << 8;
000048  6a02              LDR      r2,[r0,#0x20]
;;;434      bg_colorred = DMA2D_BG_InitStruct->DMA2D_BGC_RED << 16;
00004a  8c83              LDRH     r3,[r0,#0x24]
;;;435      DMA2D->BGCOLR |= (DMA2D_BG_InitStruct->DMA2D_BGC_BLUE | bg_colorgreen | bg_colorred);
00004c  6a8c              LDR      r4,[r1,#0x28]
00004e  0212              LSLS     r2,r2,#8              ;433
000050  69c5              LDR      r5,[r0,#0x1c]
000052  ea424203          ORR      r2,r2,r3,LSL #16
000056  432c              ORRS     r4,r4,r5
000058  4314              ORRS     r4,r4,r2
00005a  628c              STR      r4,[r1,#0x28]
;;;436      
;;;437      /* Configures background CLUT memory address */
;;;438      DMA2D->BGCMAR = DMA2D_BG_InitStruct->DMA2D_BGCMAR;
00005c  6a80              LDR      r0,[r0,#0x28]
00005e  6308              STR      r0,[r1,#0x30]
;;;439    
;;;440    }
000060  bd70              POP      {r4-r6,pc}
;;;441    
                          ENDP

000062  0000              DCW      0x0000
                  |L2.100|
                          DCD      0x4002b000
                  |L2.104|
                          DCD      0x00fc00c0

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

                  DMA2D_BGStart PROC
;;;514      
;;;515    void DMA2D_BGStart(FunctionalState NewState) 
000000  4905              LDR      r1,|L3.24|
;;;516    {
;;;517      /* Check the parameters */
;;;518      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;519      
;;;520      if (NewState != DISABLE)
000002  2800              CMP      r0,#0
;;;521      {
;;;522        /* Start the automatic loading of the CLUT */
;;;523        DMA2D->BGPFCCR |= DMA2D_BGPFCCR_START;
;;;524      }
;;;525      else
;;;526      {
;;;527        /* abort the transfer */
;;;528        DMA2D->BGPFCCR &= (uint32_t)~DMA2D_BGPFCCR_START;
000004  6a48              LDR      r0,[r1,#0x24]
000006  d002              BEQ      |L3.14|
000008  f0400020          ORR      r0,r0,#0x20           ;523
00000c  e001              B        |L3.18|
                  |L3.14|
00000e  f0200020          BIC      r0,r0,#0x20
                  |L3.18|
000012  6248              STR      r0,[r1,#0x24]         ;523
;;;529      }
;;;530    }
000014  4770              BX       lr
;;;531    
                          ENDP

000016  0000              DCW      0x0000
                  |L3.24|
                          DCD      0x4002b000

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

                  DMA2D_BG_StructInit PROC
;;;447      */
;;;448    void DMA2D_BG_StructInit(DMA2D_BG_InitTypeDef* DMA2D_BG_InitStruct)
000000  2100              MOVS     r1,#0
;;;449    {
;;;450      /*!< Initialize the DMA2D background memory address */
;;;451      DMA2D_BG_InitStruct->DMA2D_BGMA = 0x00;
;;;452    
;;;453      /*!< Initialize the DMA2D background offset */
;;;454      DMA2D_BG_InitStruct->DMA2D_BGO = 0x00;
000002  6001              STR      r1,[r0,#0]
;;;455    
;;;456      /*!< Initialize the DMA2D background color mode */
;;;457      DMA2D_BG_InitStruct->DMA2D_BGCM = CM_ARGB8888;
000004  6041              STR      r1,[r0,#4]
;;;458    
;;;459      /*!< Initialize the DMA2D background CLUT color mode */
;;;460      DMA2D_BG_InitStruct->DMA2D_BG_CLUT_CM = CLUT_CM_ARGB8888;
000006  6081              STR      r1,[r0,#8]
;;;461    
;;;462      /*!< Initialize the DMA2D background CLUT size */
;;;463      DMA2D_BG_InitStruct->DMA2D_BG_CLUT_SIZE = 0x00;
000008  60c1              STR      r1,[r0,#0xc]
;;;464    
;;;465      /*!< Initialize the DMA2D background alpha mode */
;;;466      DMA2D_BG_InitStruct->DMA2D_BGPFC_ALPHA_MODE = NO_MODIF_ALPHA_VALUE;
00000a  6101              STR      r1,[r0,#0x10]
;;;467    
;;;468      /*!< Initialize the DMA2D background alpha value */
;;;469      DMA2D_BG_InitStruct->DMA2D_BGPFC_ALPHA_VALUE = 0x00;
00000c  6141              STR      r1,[r0,#0x14]
;;;470    
;;;471      /*!< Initialize the DMA2D background blue value */
;;;472      DMA2D_BG_InitStruct->DMA2D_BGC_BLUE = 0x00;
00000e  6181              STR      r1,[r0,#0x18]
;;;473    
;;;474      /*!< Initialize the DMA2D background green value */
;;;475      DMA2D_BG_InitStruct->DMA2D_BGC_GREEN = 0x00;
000010  61c1              STR      r1,[r0,#0x1c]
;;;476    
;;;477      /*!< Initialize the DMA2D background red value */
;;;478      DMA2D_BG_InitStruct->DMA2D_BGC_RED = 0x00;
000012  6201              STR      r1,[r0,#0x20]
;;;479    
;;;480      /*!< Initialize the DMA2D background CLUT memory address */
;;;481      DMA2D_BG_InitStruct->DMA2D_BGCMAR = 0x00;
000014  6241              STR      r1,[r0,#0x24]
000016  6281              STR      r1,[r0,#0x28]
;;;482    }
000018  4770              BX       lr
;;;483    
                          ENDP


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

                  DMA2D_ClearFlag PROC
;;;696      */
;;;697    void DMA2D_ClearFlag(uint32_t DMA2D_FLAG)
000000  4901              LDR      r1,|L5.8|
;;;698    {
;;;699      /* Check the parameters */
;;;700      assert_param(IS_DMA2D_GET_FLAG(DMA2D_FLAG));
;;;701        
;;;702      /* Clear the corresponding DMA2D flag */
;;;703      DMA2D->IFCR = (uint32_t)DMA2D_FLAG;
000002  6088              STR      r0,[r1,#8]
;;;704    }
000004  4770              BX       lr
;;;705    
                          ENDP

000006  0000              DCW      0x0000
                  |L5.8|
                          DCD      0x4002b000

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

                  DMA2D_ClearITPendingBit PROC
;;;757      */
;;;758    void DMA2D_ClearITPendingBit(uint32_t DMA2D_IT)
000000  4901              LDR      r1,|L6.8|
;;;759    {
;;;760      /* Check the parameters */
;;;761      assert_param(IS_DMA2D_IT(DMA2D_IT));
;;;762      DMA2D_IT = DMA2D_IT >> 8;
000002  0a00              LSRS     r0,r0,#8
;;;763        
;;;764      /* Clear the corresponding DMA2D Interrupt */
;;;765      DMA2D->IFCR = (uint32_t)DMA2D_IT;
000004  6088              STR      r0,[r1,#8]
;;;766    }
000006  4770              BX       lr
;;;767    
                          ENDP

                  |L6.8|
                          DCD      0x4002b000

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

                  DMA2D_DeInit PROC
;;;110    
;;;111    void DMA2D_DeInit(void)
000000  b510              PUSH     {r4,lr}
;;;112    {
;;;113      /* Enable DMA2D reset state */
;;;114      RCC_AHB1PeriphResetCmd(RCC_AHB1Periph_DMA2D, ENABLE);
000002  2101              MOVS     r1,#1
000004  05cc              LSLS     r4,r1,#23
000006  4620              MOV      r0,r4
000008  f7fffffe          BL       RCC_AHB1PeriphResetCmd
;;;115      /* Release DMA2D from reset state */
;;;116      RCC_AHB1PeriphResetCmd(RCC_AHB1Periph_DMA2D, DISABLE);
00000c  4620              MOV      r0,r4
00000e  e8bd4010          POP      {r4,lr}
000012  2100              MOVS     r1,#0
000014  f7ffbffe          B.W      RCC_AHB1PeriphResetCmd
;;;117    }
;;;118    
                          ENDP


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

                  DMA2D_DeadTimeConfig PROC
;;;537      */
;;;538    void DMA2D_DeadTimeConfig(uint32_t DMA2D_DeadTime, FunctionalState NewState)
000000  4a09              LDR      r2,|L8.40|
;;;539    {
000002  b159              CBZ      r1,|L8.28|
;;;540       uint32_t DeadTime;
;;;541    
;;;542      /* Check the parameters */
;;;543      assert_param(IS_DMA2D_DEAD_TIME(DMA2D_DeadTime));
;;;544      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;545    
;;;546      if (NewState != DISABLE)
;;;547      {
;;;548        /* Enable and Configures the dead time */
;;;549        DMA2D->AMTCR &= (uint32_t)DEAD_MASK;
000004  6cd1              LDR      r1,[r2,#0x4c]
000006  f64f7301          MOV      r3,#0xff01
00000a  4399              BICS     r1,r1,r3
00000c  64d1              STR      r1,[r2,#0x4c]
;;;550        DeadTime = DMA2D_DeadTime << 8;
;;;551        DMA2D->AMTCR |= (DeadTime | DMA2D_AMTCR_EN);
00000e  6cd1              LDR      r1,[r2,#0x4c]
000010  0200              LSLS     r0,r0,#8              ;550
000012  f0400001          ORR      r0,r0,#1
000016  4301              ORRS     r1,r1,r0
000018  64d1              STR      r1,[r2,#0x4c]
;;;552      }
;;;553      else
;;;554      {
;;;555         DMA2D->AMTCR &= ~(uint32_t)DMA2D_AMTCR_EN;
;;;556      }
;;;557    }
00001a  4770              BX       lr
                  |L8.28|
00001c  6cd0              LDR      r0,[r2,#0x4c]         ;555
00001e  f0200001          BIC      r0,r0,#1              ;555
000022  64d0              STR      r0,[r2,#0x4c]         ;555
000024  4770              BX       lr
;;;558    
                          ENDP

000026  0000              DCW      0x0000
                  |L8.40|
                          DCD      0x4002b000

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

                  DMA2D_FGConfig PROC
;;;297      */
;;;298    void DMA2D_FGConfig(DMA2D_FG_InitTypeDef* DMA2D_FG_InitStruct)
000000  b570              PUSH     {r4-r6,lr}
;;;299    {
;;;300    
;;;301      uint32_t fg_clutcolormode = 0;
;;;302      uint32_t fg_clutsize = 0;
;;;303      uint32_t fg_alpha_mode = 0;
;;;304      uint32_t fg_alphavalue = 0;
;;;305      uint32_t fg_colorgreen = 0;
;;;306      uint32_t fg_colorred = 0;
;;;307    
;;;308      assert_param(IS_DMA2D_FGO(DMA2D_FG_InitStruct->DMA2D_FGO));
;;;309      assert_param(IS_DMA2D_FGCM(DMA2D_FG_InitStruct->DMA2D_FGCM));
;;;310      assert_param(IS_DMA2D_FG_CLUT_CM(DMA2D_FG_InitStruct->DMA2D_FG_CLUT_CM));
;;;311      assert_param(IS_DMA2D_FG_CLUT_SIZE(DMA2D_FG_InitStruct->DMA2D_FG_CLUT_SIZE));
;;;312      assert_param(IS_DMA2D_FG_ALPHA_MODE(DMA2D_FG_InitStruct->DMA2D_FGPFC_ALPHA_MODE));
;;;313      assert_param(IS_DMA2D_FG_ALPHA_VALUE(DMA2D_FG_InitStruct->DMA2D_FGPFC_ALPHA_VALUE));
;;;314      assert_param(IS_DMA2D_FGC_BLUE(DMA2D_FG_InitStruct->DMA2D_FGC_BLUE));
;;;315      assert_param(IS_DMA2D_FGC_GREEN(DMA2D_FG_InitStruct->DMA2D_FGC_GREEN));
;;;316      assert_param(IS_DMA2D_FGC_RED(DMA2D_FG_InitStruct->DMA2D_FGC_RED));
;;;317    
;;;318      /* Configures the FG memory address */
;;;319      DMA2D->FGMAR = (DMA2D_FG_InitStruct->DMA2D_FGMA);
000002  4918              LDR      r1,|L9.100|
000004  6802              LDR      r2,[r0,#0]
000006  60ca              STR      r2,[r1,#0xc]
;;;320    
;;;321      /* Configures the FG offset */
;;;322      DMA2D->FGOR &= ~(uint32_t)DMA2D_FGOR_LO;
000008  690a              LDR      r2,[r1,#0x10]
00000a  f36f020d          BFC      r2,#0,#14
00000e  610a              STR      r2,[r1,#0x10]
;;;323      DMA2D->FGOR |= (DMA2D_FG_InitStruct->DMA2D_FGO);
000010  690a              LDR      r2,[r1,#0x10]
000012  6843              LDR      r3,[r0,#4]
000014  431a              ORRS     r2,r2,r3
000016  610a              STR      r2,[r1,#0x10]
;;;324    
;;;325      /* Configures foreground Pixel Format Convertor */
;;;326      DMA2D->FGPFCCR &= (uint32_t)PFCCR_MASK;
000018  69ca              LDR      r2,[r1,#0x1c]
00001a  4b13              LDR      r3,|L9.104|
00001c  401a              ANDS     r2,r2,r3
00001e  61ca              STR      r2,[r1,#0x1c]
;;;327      fg_clutcolormode = DMA2D_FG_InitStruct->DMA2D_FG_CLUT_CM << 4;
;;;328      fg_clutsize = DMA2D_FG_InitStruct->DMA2D_FG_CLUT_SIZE << 8;
;;;329      fg_alpha_mode = DMA2D_FG_InitStruct->DMA2D_FGPFC_ALPHA_MODE << 16;
000020  8a84              LDRH     r4,[r0,#0x14]
;;;330      fg_alphavalue = DMA2D_FG_InitStruct->DMA2D_FGPFC_ALPHA_VALUE << 24;
;;;331      DMA2D->FGPFCCR |= (DMA2D_FG_InitStruct->DMA2D_FGCM | fg_clutcolormode | fg_clutsize | \
000022  e9d06202          LDRD     r6,r2,[r0,#8]
000026  0425              LSLS     r5,r4,#16             ;329
000028  6903              LDR      r3,[r0,#0x10]
00002a  ea461602          ORR      r6,r6,r2,LSL #4
00002e  7e04              LDRB     r4,[r0,#0x18]         ;330
000030  ea452303          ORR      r3,r5,r3,LSL #8
000034  431e              ORRS     r6,r6,r3
000036  69ca              LDR      r2,[r1,#0x1c]
000038  ea466604          ORR      r6,r6,r4,LSL #24
00003c  4316              ORRS     r6,r6,r2
00003e  61ce              STR      r6,[r1,#0x1c]
;;;332                        fg_alpha_mode | fg_alphavalue);
;;;333    
;;;334      /* Configures foreground color */
;;;335      DMA2D->FGCOLR &= ~(DMA2D_FGCOLR_BLUE | DMA2D_FGCOLR_GREEN | DMA2D_FGCOLR_RED);
000040  6a0a              LDR      r2,[r1,#0x20]
000042  f002427f          AND      r2,r2,#0xff000000
000046  620a              STR      r2,[r1,#0x20]
;;;336      fg_colorgreen = DMA2D_FG_InitStruct->DMA2D_FGC_GREEN << 8;
000048  6a02              LDR      r2,[r0,#0x20]
;;;337      fg_colorred = DMA2D_FG_InitStruct->DMA2D_FGC_RED << 16;
00004a  8c83              LDRH     r3,[r0,#0x24]
;;;338      DMA2D->FGCOLR |= (DMA2D_FG_InitStruct->DMA2D_FGC_BLUE | fg_colorgreen | fg_colorred);
00004c  6a0c              LDR      r4,[r1,#0x20]
00004e  0212              LSLS     r2,r2,#8              ;336
000050  69c5              LDR      r5,[r0,#0x1c]
000052  ea424203          ORR      r2,r2,r3,LSL #16
000056  432c              ORRS     r4,r4,r5
000058  4314              ORRS     r4,r4,r2
00005a  620c              STR      r4,[r1,#0x20]
;;;339    
;;;340      /* Configures foreground CLUT memory address */
;;;341      DMA2D->FGCMAR = DMA2D_FG_InitStruct->DMA2D_FGCMAR;
00005c  6a80              LDR      r0,[r0,#0x28]
00005e  62c8              STR      r0,[r1,#0x2c]
;;;342    }
000060  bd70              POP      {r4-r6,pc}
;;;343    
                          ENDP

000062  0000              DCW      0x0000
                  |L9.100|
                          DCD      0x4002b000
                  |L9.104|
                          DCD      0x00fc00c0

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

                  DMA2D_FGStart PROC
;;;490    
;;;491    void DMA2D_FGStart(FunctionalState NewState) 
000000  4905              LDR      r1,|L10.24|
;;;492    {
;;;493      /* Check the parameters */
;;;494      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;495    
;;;496      if (NewState != DISABLE)
000002  2800              CMP      r0,#0
;;;497      {
;;;498        /* Start the automatic loading of the CLUT */
;;;499        DMA2D->FGPFCCR |= DMA2D_FGPFCCR_START;
;;;500      }
;;;501      else
;;;502      {
;;;503        /* abort the transfer */
;;;504        DMA2D->FGPFCCR &= (uint32_t)~DMA2D_FGPFCCR_START;
000004  69c8              LDR      r0,[r1,#0x1c]
000006  d002              BEQ      |L10.14|
000008  f0400020          ORR      r0,r0,#0x20           ;499
00000c  e001              B        |L10.18|
                  |L10.14|
00000e  f0200020          BIC      r0,r0,#0x20
                  |L10.18|
000012  61c8              STR      r0,[r1,#0x1c]         ;499
;;;505      }
;;;506    }
000014  4770              BX       lr
;;;507    
                          ENDP

000016  0000              DCW      0x0000
                  |L10.24|
                          DCD      0x4002b000

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

                  DMA2D_FG_StructInit PROC
;;;349      */
;;;350    void DMA2D_FG_StructInit(DMA2D_FG_InitTypeDef* DMA2D_FG_InitStruct)
000000  2100              MOVS     r1,#0
;;;351    {
;;;352      /*!< Initialize the DMA2D foreground memory address */
;;;353      DMA2D_FG_InitStruct->DMA2D_FGMA = 0x00;
;;;354    
;;;355      /*!< Initialize the DMA2D foreground offset */
;;;356      DMA2D_FG_InitStruct->DMA2D_FGO = 0x00;
000002  6001              STR      r1,[r0,#0]
;;;357    
;;;358      /*!< Initialize the DMA2D foreground color mode */
;;;359      DMA2D_FG_InitStruct->DMA2D_FGCM = CM_ARGB8888;
000004  6041              STR      r1,[r0,#4]
;;;360    
;;;361      /*!< Initialize the DMA2D foreground CLUT color mode */
;;;362      DMA2D_FG_InitStruct->DMA2D_FG_CLUT_CM = CLUT_CM_ARGB8888;
000006  6081              STR      r1,[r0,#8]
;;;363    
;;;364      /*!< Initialize the DMA2D foreground CLUT size */
;;;365      DMA2D_FG_InitStruct->DMA2D_FG_CLUT_SIZE = 0x00;
000008  60c1              STR      r1,[r0,#0xc]
;;;366    
;;;367      /*!< Initialize the DMA2D foreground alpha mode */
;;;368      DMA2D_FG_InitStruct->DMA2D_FGPFC_ALPHA_MODE = NO_MODIF_ALPHA_VALUE;
00000a  6101              STR      r1,[r0,#0x10]
;;;369    
;;;370      /*!< Initialize the DMA2D foreground alpha value */
;;;371      DMA2D_FG_InitStruct->DMA2D_FGPFC_ALPHA_VALUE = 0x00;
00000c  6141              STR      r1,[r0,#0x14]
;;;372    
;;;373      /*!< Initialize the DMA2D foreground blue value */
;;;374      DMA2D_FG_InitStruct->DMA2D_FGC_BLUE = 0x00;
00000e  6181              STR      r1,[r0,#0x18]
;;;375    
;;;376      /*!< Initialize the DMA2D foreground green value */
;;;377      DMA2D_FG_InitStruct->DMA2D_FGC_GREEN = 0x00;
000010  61c1              STR      r1,[r0,#0x1c]
;;;378    
;;;379      /*!< Initialize the DMA2D foreground red value */
;;;380      DMA2D_FG_InitStruct->DMA2D_FGC_RED = 0x00;
000012  6201              STR      r1,[r0,#0x20]
;;;381    
;;;382      /*!< Initialize the DMA2D foreground CLUT memory address */
;;;383      DMA2D_FG_InitStruct->DMA2D_FGCMAR = 0x00;
000014  6241              STR      r1,[r0,#0x24]
000016  6281              STR      r1,[r0,#0x28]
;;;384    }
000018  4770              BX       lr
;;;385    
                          ENDP


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

                  DMA2D_GetFlagStatus PROC
;;;662    
;;;663    FlagStatus DMA2D_GetFlagStatus(uint32_t DMA2D_FLAG)
000000  4a03              LDR      r2,|L12.16|
;;;664    {
000002  4601              MOV      r1,r0
;;;665      FlagStatus bitstatus = RESET;
000004  2000              MOVS     r0,#0
;;;666      
;;;667      /* Check the parameters */
;;;668      assert_param(IS_DMA2D_GET_FLAG(DMA2D_FLAG));
;;;669      
;;;670      /* Check the status of the specified DMA2D flag */
;;;671      if (((DMA2D->ISR) & DMA2D_FLAG) != (uint32_t)RESET)
000006  6852              LDR      r2,[r2,#4]
000008  420a              TST      r2,r1
00000a  d000              BEQ      |L12.14|
;;;672      {
;;;673        /* DMA2D_FLAG is set */
;;;674        bitstatus = SET;
00000c  2001              MOVS     r0,#1
                  |L12.14|
;;;675      }
;;;676      else
;;;677      {
;;;678        /* DMA2D_FLAG is reset */
;;;679        bitstatus = RESET;
;;;680      }
;;;681      /* Return the DMA2D_FLAG status */
;;;682      return bitstatus;
;;;683    }
00000e  4770              BX       lr
;;;684    
                          ENDP

                  |L12.16|
                          DCD      0x4002b000

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

                  DMA2D_GetITStatus PROC
;;;717      */
;;;718    ITStatus DMA2D_GetITStatus(uint32_t DMA2D_IT)
000000  4b07              LDR      r3,|L13.32|
;;;719    {
000002  b510              PUSH     {r4,lr}
;;;720      ITStatus bitstatus = RESET;
;;;721      uint32_t DMA2D_IT_FLAG = DMA2D_IT >> 8;
;;;722      
;;;723      /* Check the parameters */
;;;724      assert_param(IS_DMA2D_IT(DMA2D_IT));
;;;725    
;;;726      if ((DMA2D->ISR & DMA2D_IT_FLAG) != (uint32_t)RESET)
000004  685c              LDR      r4,[r3,#4]
000006  2100              MOVS     r1,#0                 ;720
000008  ea142f10          TST      r4,r0,LSR #8
00000c  d000              BEQ      |L13.16|
;;;727      {
;;;728        bitstatus = SET;
00000e  2101              MOVS     r1,#1
                  |L13.16|
;;;729      }
;;;730      else
;;;731      {
;;;732        bitstatus = RESET;
;;;733      }
;;;734      
;;;735      if (((DMA2D->CR & DMA2D_IT) != (uint32_t)RESET) && (bitstatus != (uint32_t)RESET))
000010  681a              LDR      r2,[r3,#0]
000012  4202              TST      r2,r0
000014  d002              BEQ      |L13.28|
000016  b109              CBZ      r1,|L13.28|
;;;736      {
;;;737        bitstatus = SET;
000018  2001              MOVS     r0,#1
;;;738      }
;;;739      else
;;;740      {
;;;741        bitstatus = RESET;
;;;742      }
;;;743      return bitstatus;
;;;744    }
00001a  bd10              POP      {r4,pc}
                  |L13.28|
00001c  2000              MOVS     r0,#0                 ;741
00001e  bd10              POP      {r4,pc}
;;;745    
                          ENDP

                  |L13.32|
                          DCD      0x4002b000

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

                  DMA2D_ITConfig PROC
;;;631    
;;;632    void DMA2D_ITConfig(uint32_t DMA2D_IT, FunctionalState NewState)
000000  4a04              LDR      r2,|L14.20|
;;;633    {
;;;634      /* Check the parameters */
;;;635      assert_param(IS_DMA2D_IT(DMA2D_IT));
;;;636      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;637    
;;;638      if (NewState != DISABLE)
000002  2900              CMP      r1,#0
;;;639      {
;;;640        /* Enable the selected DMA2D interrupts */
;;;641        DMA2D->CR |= DMA2D_IT;
;;;642      }
;;;643      else
;;;644      {
;;;645        /* Disable the selected DMA2D interrupts */
;;;646        DMA2D->CR &= (uint32_t)~DMA2D_IT;
000004  6811              LDR      r1,[r2,#0]
000006  d001              BEQ      |L14.12|
000008  4301              ORRS     r1,r1,r0              ;641
00000a  e000              B        |L14.14|
                  |L14.12|
00000c  4381              BICS     r1,r1,r0
                  |L14.14|
00000e  6011              STR      r1,[r2,#0]            ;641
;;;647      }
;;;648    }
000010  4770              BX       lr
;;;649    
                          ENDP

000012  0000              DCW      0x0000
                  |L14.20|
                          DCD      0x4002b000

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

                  DMA2D_Init PROC
;;;127      */
;;;128    void DMA2D_Init(DMA2D_InitTypeDef* DMA2D_InitStruct)
000000  b530              PUSH     {r4,r5,lr}
;;;129    {
;;;130    
;;;131      uint32_t outgreen = 0;
;;;132      uint32_t outred   = 0;
;;;133      uint32_t outalpha = 0;
;;;134      uint32_t pixline  = 0;
;;;135    
;;;136      /* Check the parameters */
;;;137      assert_param(IS_DMA2D_MODE(DMA2D_InitStruct->DMA2D_Mode));
;;;138      assert_param(IS_DMA2D_CMODE(DMA2D_InitStruct->DMA2D_CMode));
;;;139      assert_param(IS_DMA2D_OGREEN(DMA2D_InitStruct->DMA2D_OutputGreen));
;;;140      assert_param(IS_DMA2D_ORED(DMA2D_InitStruct->DMA2D_OutputRed));
;;;141      assert_param(IS_DMA2D_OBLUE(DMA2D_InitStruct->DMA2D_OutputBlue));
;;;142      assert_param(IS_DMA2D_OALPHA(DMA2D_InitStruct->DMA2D_OutputAlpha));
;;;143      assert_param(IS_DMA2D_OUTPUT_OFFSET(DMA2D_InitStruct->DMA2D_OutputOffset));
;;;144      assert_param(IS_DMA2D_LINE(DMA2D_InitStruct->DMA2D_NumberOfLine));
;;;145      assert_param(IS_DMA2D_PIXEL(DMA2D_InitStruct->DMA2D_PixelPerLine));
;;;146    
;;;147      /* Configures the DMA2D operation mode */
;;;148      DMA2D->CR &= (uint32_t)CR_MASK;
000002  4b2a              LDR      r3,|L15.172|
000004  2400              MOVS     r4,#0                 ;133
000006  6819              LDR      r1,[r3,#0]
000008  4a29              LDR      r2,|L15.176|
00000a  4011              ANDS     r1,r1,r2
00000c  6019              STR      r1,[r3,#0]
;;;149      DMA2D->CR |= (DMA2D_InitStruct->DMA2D_Mode);
00000e  6819              LDR      r1,[r3,#0]
000010  6802              LDR      r2,[r0,#0]
000012  4311              ORRS     r1,r1,r2
000014  6019              STR      r1,[r3,#0]
;;;150    
;;;151      /* Configures the color mode of the output image */
;;;152      DMA2D->OPFCCR &= ~(uint32_t)DMA2D_OPFCCR_CM;
000016  6b59              LDR      r1,[r3,#0x34]
000018  f0210107          BIC      r1,r1,#7
00001c  6359              STR      r1,[r3,#0x34]
;;;153      DMA2D->OPFCCR |= (DMA2D_InitStruct->DMA2D_CMode);
00001e  6b59              LDR      r1,[r3,#0x34]
000020  6842              LDR      r2,[r0,#4]
000022  4311              ORRS     r1,r1,r2
000024  6359              STR      r1,[r3,#0x34]
000026  6841              LDR      r1,[r0,#4]            ;129
000028  b341              CBZ      r1,|L15.124|
;;;154    
;;;155      /* Configures the output color */
;;;156    
;;;157      if (DMA2D_InitStruct->DMA2D_CMode == DMA2D_ARGB8888)
;;;158      {
;;;159        outgreen = DMA2D_InitStruct->DMA2D_OutputGreen << 8;
;;;160        outred = DMA2D_InitStruct->DMA2D_OutputRed << 16;
;;;161        outalpha = DMA2D_InitStruct->DMA2D_OutputAlpha << 24;
;;;162      }
;;;163      else
;;;164      
;;;165        if (DMA2D_InitStruct->DMA2D_CMode == DMA2D_RGB888)
00002a  2901              CMP      r1,#1
00002c  d02d              BEQ      |L15.138|
;;;166        {
;;;167          outgreen = DMA2D_InitStruct->DMA2D_OutputGreen << 8;
;;;168          outred = DMA2D_InitStruct->DMA2D_OutputRed << 16;
;;;169          outalpha = (uint32_t)0x00000000;
;;;170        }
;;;171         
;;;172      else
;;;173    
;;;174        if (DMA2D_InitStruct->DMA2D_CMode == DMA2D_RGB565)
00002e  2902              CMP      r1,#2
000030  d030              BEQ      |L15.148|
;;;175        {
;;;176          outgreen = DMA2D_InitStruct->DMA2D_OutputGreen << 5;
;;;177          outred = DMA2D_InitStruct->DMA2D_OutputRed << 11;
;;;178          outalpha = (uint32_t)0x00000000;
;;;179        }
;;;180    
;;;181      else
;;;182    
;;;183        if (DMA2D_InitStruct->DMA2D_CMode == DMA2D_ARGB1555)
000032  2903              CMP      r1,#3
000034  68c1              LDR      r1,[r0,#0xc]
000036  d032              BEQ      |L15.158|
;;;184        {  
;;;185          outgreen = DMA2D_InitStruct->DMA2D_OutputGreen << 5;
;;;186          outred = DMA2D_InitStruct->DMA2D_OutputRed << 10;
;;;187          outalpha = DMA2D_InitStruct->DMA2D_OutputAlpha << 15;
;;;188        }
;;;189    
;;;190      else /* DMA2D_CMode = DMA2D_ARGB4444 */
;;;191      {
;;;192        outgreen = DMA2D_InitStruct->DMA2D_OutputGreen << 4;
000038  010a              LSLS     r2,r1,#4
;;;193        outred = DMA2D_InitStruct->DMA2D_OutputRed << 8;
00003a  6901              LDR      r1,[r0,#0x10]
;;;194        outalpha = DMA2D_InitStruct->DMA2D_OutputAlpha << 12;
00003c  6944              LDR      r4,[r0,#0x14]
00003e  0209              LSLS     r1,r1,#8              ;193
000040  0324              LSLS     r4,r4,#12
                  |L15.66|
;;;195      }  
;;;196      DMA2D->OCOLR |= ((outgreen) | (outred) | (DMA2D_InitStruct->DMA2D_OutputBlue) | (outalpha));
000042  6885              LDR      r5,[r0,#8]
000044  4321              ORRS     r1,r1,r4
000046  4315              ORRS     r5,r5,r2
000048  430d              ORRS     r5,r5,r1
00004a  6b99              LDR      r1,[r3,#0x38]
00004c  430d              ORRS     r5,r5,r1
00004e  639d              STR      r5,[r3,#0x38]
;;;197    
;;;198      /* Configures the output memory address */
;;;199      DMA2D->OMAR = (DMA2D_InitStruct->DMA2D_OutputMemoryAdd);
000050  6981              LDR      r1,[r0,#0x18]
000052  63d9              STR      r1,[r3,#0x3c]
;;;200    
;;;201      /* Configure  the line Offset */
;;;202      DMA2D->OOR &= ~(uint32_t)DMA2D_OOR_LO;
000054  6c19              LDR      r1,[r3,#0x40]
000056  f36f010d          BFC      r1,#0,#14
00005a  6419              STR      r1,[r3,#0x40]
;;;203      DMA2D->OOR |= (DMA2D_InitStruct->DMA2D_OutputOffset);
00005c  6c19              LDR      r1,[r3,#0x40]
00005e  69c2              LDR      r2,[r0,#0x1c]
000060  4311              ORRS     r1,r1,r2
000062  6419              STR      r1,[r3,#0x40]
;;;204    
;;;205      /* Configure the number of line and pixel per line */
;;;206      pixline = DMA2D_InitStruct->DMA2D_PixelPerLine << 16; 
000064  8c81              LDRH     r1,[r0,#0x24]
;;;207      DMA2D->NLR &= ~(DMA2D_NLR_NL | DMA2D_NLR_PL);
000066  6c5a              LDR      r2,[r3,#0x44]
000068  f0024240          AND      r2,r2,#0xc0000000
00006c  645a              STR      r2,[r3,#0x44]
;;;208      DMA2D->NLR |= ((DMA2D_InitStruct->DMA2D_NumberOfLine) | (pixline));
00006e  6c5a              LDR      r2,[r3,#0x44]
000070  6a00              LDR      r0,[r0,#0x20]
000072  4302              ORRS     r2,r2,r0
000074  ea424201          ORR      r2,r2,r1,LSL #16
000078  645a              STR      r2,[r3,#0x44]
;;;209    
;;;210    /**
;;;211      * @brief  Fills each DMA2D_InitStruct member with its default value.
;;;212      * @param  DMA2D_InitStruct: pointer to a DMA2D_InitTypeDef structure which will
;;;213      *         be initialized.
;;;214      * @retval None
;;;215      */
;;;216    }
00007a  bd30              POP      {r4,r5,pc}
                  |L15.124|
00007c  68c1              LDR      r1,[r0,#0xc]          ;159
00007e  7d04              LDRB     r4,[r0,#0x14]         ;161
000080  020a              LSLS     r2,r1,#8              ;159
000082  8a01              LDRH     r1,[r0,#0x10]         ;160
000084  0409              LSLS     r1,r1,#16             ;160
000086  0624              LSLS     r4,r4,#24             ;161
000088  e7db              B        |L15.66|
                  |L15.138|
00008a  68c1              LDR      r1,[r0,#0xc]          ;167
00008c  020a              LSLS     r2,r1,#8              ;167
00008e  8a01              LDRH     r1,[r0,#0x10]         ;168
000090  0409              LSLS     r1,r1,#16             ;168
000092  e7d6              B        |L15.66|
                  |L15.148|
000094  68c1              LDR      r1,[r0,#0xc]          ;176
000096  014a              LSLS     r2,r1,#5              ;176
000098  6901              LDR      r1,[r0,#0x10]         ;177
00009a  02c9              LSLS     r1,r1,#11             ;177
00009c  e7d1              B        |L15.66|
                  |L15.158|
00009e  014a              LSLS     r2,r1,#5              ;185
0000a0  6901              LDR      r1,[r0,#0x10]         ;186
0000a2  6944              LDR      r4,[r0,#0x14]         ;187
0000a4  0289              LSLS     r1,r1,#10             ;186
0000a6  03e4              LSLS     r4,r4,#15             ;187
0000a8  e7cb              B        |L15.66|
;;;217    void DMA2D_StructInit(DMA2D_InitTypeDef* DMA2D_InitStruct)
                          ENDP

0000aa  0000              DCW      0x0000
                  |L15.172|
                          DCD      0x4002b000
                  |L15.176|
                          DCD      0xfffce0fc

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

                  DMA2D_LineWatermarkConfig PROC
;;;564    
;;;565    void DMA2D_LineWatermarkConfig(uint32_t DMA2D_LWatermarkConfig)
000000  4901              LDR      r1,|L16.8|
;;;566    {
;;;567      /* Check the parameters */
;;;568      assert_param(IS_DMA2D_LineWatermark(DMA2D_LWatermarkConfig));
;;;569    
;;;570      /* Sets the Line watermark configuration */
;;;571      DMA2D->LWR = (uint32_t)DMA2D_LWatermarkConfig;
000002  6488              STR      r0,[r1,#0x48]
;;;572    }
000004  4770              BX       lr
;;;573    
                          ENDP

000006  0000              DCW      0x0000
                  |L16.8|
                          DCD      0x4002b000

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

                  DMA2D_StartTransfer PROC
;;;247    
;;;248    void DMA2D_StartTransfer(void)
000000  4802              LDR      r0,|L17.12|
;;;249    {
;;;250        /* Start DMA2D transfer by setting START bit */
;;;251        DMA2D->CR |= (uint32_t)DMA2D_CR_START;
000002  6801              LDR      r1,[r0,#0]
000004  f0410101          ORR      r1,r1,#1
000008  6001              STR      r1,[r0,#0]
;;;252    }
00000a  4770              BX       lr
;;;253    
                          ENDP

                  |L17.12|
                          DCD      0x4002b000

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

                  DMA2D_StructInit PROC
;;;216    }
;;;217    void DMA2D_StructInit(DMA2D_InitTypeDef* DMA2D_InitStruct)
000000  2100              MOVS     r1,#0
;;;218    {
;;;219      /* Initialize the transfer mode member */
;;;220      DMA2D_InitStruct->DMA2D_Mode = DMA2D_M2M;
;;;221    
;;;222      /* Initialize the output color mode members */
;;;223      DMA2D_InitStruct->DMA2D_CMode = DMA2D_ARGB8888;
000002  6001              STR      r1,[r0,#0]
;;;224    
;;;225      /* Initialize the alpha and RGB values */
;;;226      DMA2D_InitStruct->DMA2D_OutputGreen = 0x00;
000004  6041              STR      r1,[r0,#4]
;;;227      DMA2D_InitStruct->DMA2D_OutputBlue = 0x00;
000006  60c1              STR      r1,[r0,#0xc]
;;;228      DMA2D_InitStruct->DMA2D_OutputRed = 0x00;
000008  6081              STR      r1,[r0,#8]
;;;229      DMA2D_InitStruct->DMA2D_OutputAlpha = 0x00;
00000a  6101              STR      r1,[r0,#0x10]
;;;230    
;;;231      /* Initialize the output memory address */
;;;232      DMA2D_InitStruct->DMA2D_OutputMemoryAdd = 0x00;
00000c  6141              STR      r1,[r0,#0x14]
;;;233    
;;;234      /* Initialize the output offset */
;;;235      DMA2D_InitStruct->DMA2D_OutputOffset = 0x00;
00000e  6181              STR      r1,[r0,#0x18]
;;;236    
;;;237      /* Initialize the number of line and the number of pixel per line */
;;;238      DMA2D_InitStruct->DMA2D_NumberOfLine = 0x00;
000010  61c1              STR      r1,[r0,#0x1c]
;;;239      DMA2D_InitStruct->DMA2D_PixelPerLine = 0x00;
000012  6201              STR      r1,[r0,#0x20]
000014  6241              STR      r1,[r0,#0x24]
;;;240    }
000016  4770              BX       lr
;;;241    
                          ENDP


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

                  DMA2D_Suspend PROC
;;;272      */
;;;273    void DMA2D_Suspend(FunctionalState NewState)
000000  4905              LDR      r1,|L19.24|
;;;274    {
;;;275      /* Check the parameters */
;;;276      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;277    
;;;278      if (NewState != DISABLE)
000002  2800              CMP      r0,#0
;;;279      {
;;;280        /* Suspend DMA2D transfer by setting STOP bit */
;;;281        DMA2D->CR |= (uint32_t)DMA2D_CR_SUSP;
;;;282      }
;;;283      else
;;;284      {
;;;285        /* Continue DMA2D transfer by clearing STOP bit */
;;;286        DMA2D->CR &= ~(uint32_t)DMA2D_CR_SUSP;
000004  6808              LDR      r0,[r1,#0]
000006  d002              BEQ      |L19.14|
000008  f0400002          ORR      r0,r0,#2              ;281
00000c  e001              B        |L19.18|
                  |L19.14|
00000e  f0200002          BIC      r0,r0,#2
                  |L19.18|
000012  6008              STR      r0,[r1,#0]            ;281
;;;287      }
;;;288    }
000014  4770              BX       lr
;;;289    
                          ENDP

000016  0000              DCW      0x0000
                  |L19.24|
                          DCD      0x4002b000

;*** Start embedded assembler ***

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

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

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
