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

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

                  LTDC_CLUTCmd PROC
;;;630    
;;;631    void LTDC_CLUTCmd(LTDC_Layer_TypeDef* LTDC_Layerx, FunctionalState NewState)
000000  2900              CMP      r1,#0
;;;632    {
;;;633      /* Check the parameters */
;;;634      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;635    
;;;636      if (NewState != DISABLE)
;;;637      {
;;;638        /* Enable CLUT by setting CLUTEN bit */
;;;639        LTDC_Layerx->CR |= (uint32_t)LTDC_LxCR_CLUTEN;
;;;640      }
;;;641      else
;;;642      {
;;;643        /* Disable CLUT by clearing CLUTEN bit */
;;;644        LTDC_Layerx->CR &= ~(uint32_t)LTDC_LxCR_CLUTEN;
000002  6801              LDR      r1,[r0,#0]
000004  d002              BEQ      |L1.12|
000006  f0410110          ORR      r1,r1,#0x10           ;639
00000a  e001              B        |L1.16|
                  |L1.12|
00000c  f0210110          BIC      r1,r1,#0x10
                  |L1.16|
000010  6001              STR      r1,[r0,#0]
;;;645      }
;;;646      
;;;647      /* Reload shadow register */
;;;648      LTDC->SRCR = LTDC_IMReload;
000012  4902              LDR      r1,|L1.28|
000014  2001              MOVS     r0,#1
000016  6008              STR      r0,[r1,#0]
;;;649    }
000018  4770              BX       lr
;;;650    
                          ENDP

00001a  0000              DCW      0x0000
                  |L1.28|
                          DCD      0x40016824

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

                  LTDC_CLUTInit PROC
;;;659    
;;;660    void LTDC_CLUTInit(LTDC_Layer_TypeDef* LTDC_Layerx, LTDC_CLUT_InitTypeDef* LTDC_CLUT_InitStruct)
000000  b510              PUSH     {r4,lr}
;;;661    {  
;;;662      uint32_t green = 0;
;;;663      uint32_t red = 0;
;;;664      uint32_t clutadd = 0;
;;;665    
;;;666      /* Check the parameters */
;;;667      assert_param(IS_LTDC_CLUTWR(LTDC_CLUT_InitStruct->LTDC_CLUTAdress));
;;;668      assert_param(IS_LTDC_CLUTWR(LTDC_CLUT_InitStruct->LTDC_RedValue));
;;;669      assert_param(IS_LTDC_CLUTWR(LTDC_CLUT_InitStruct->LTDC_GreenValue));
;;;670      assert_param(IS_LTDC_CLUTWR(LTDC_CLUT_InitStruct->LTDC_BlueValue));
;;;671        
;;;672      /* Specifies the CLUT address and RGB value */
;;;673      green = (LTDC_CLUT_InitStruct->LTDC_GreenValue << 8);
000002  688a              LDR      r2,[r1,#8]
000004  0214              LSLS     r4,r2,#8
;;;674      red = (LTDC_CLUT_InitStruct->LTDC_RedValue << 16);
000006  898a              LDRH     r2,[r1,#0xc]
000008  0413              LSLS     r3,r2,#16
;;;675      clutadd = (LTDC_CLUT_InitStruct->LTDC_CLUTAdress << 24);
00000a  780a              LDRB     r2,[r1,#0]
;;;676      LTDC_Layerx->CLUTWR  = (clutadd | LTDC_CLUT_InitStruct->LTDC_BlueValue | \
00000c  6849              LDR      r1,[r1,#4]
00000e  431c              ORRS     r4,r4,r3
000010  ea416102          ORR      r1,r1,r2,LSL #24
000014  4321              ORRS     r1,r1,r4
000016  6401              STR      r1,[r0,#0x40]
;;;677                                  green | red);
;;;678    }
000018  bd10              POP      {r4,pc}
;;;679    
                          ENDP


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

                  LTDC_CLUTStructInit PROC
;;;686    
;;;687    void LTDC_CLUTStructInit(LTDC_CLUT_InitTypeDef* LTDC_CLUT_InitStruct)
000000  2100              MOVS     r1,#0
;;;688    {
;;;689      /*!< Initialize the CLUT adress and RGB values */
;;;690      LTDC_CLUT_InitStruct->LTDC_CLUTAdress = 0x00;
;;;691      LTDC_CLUT_InitStruct->LTDC_BlueValue = 0x00;
000002  6001              STR      r1,[r0,#0]
;;;692      LTDC_CLUT_InitStruct->LTDC_GreenValue = 0x00;
000004  6041              STR      r1,[r0,#4]
;;;693      LTDC_CLUT_InitStruct->LTDC_RedValue = 0x00;
000006  6081              STR      r1,[r0,#8]
000008  60c1              STR      r1,[r0,#0xc]
;;;694    }
00000a  4770              BX       lr
;;;695    
                          ENDP


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

                  LTDC_ClearFlag PROC
;;;1028     */
;;;1029   void LTDC_ClearFlag(uint32_t LTDC_FLAG)
000000  4901              LDR      r1,|L4.8|
;;;1030   {
;;;1031     /* Check the parameters */
;;;1032     assert_param(IS_LTDC_FLAG(LTDC_FLAG));
;;;1033   
;;;1034     /* Clear the corresponding LTDC flag */
;;;1035     LTDC->ICR = (uint32_t)LTDC_FLAG;
000002  6008              STR      r0,[r1,#0]
;;;1036   }
000004  4770              BX       lr
;;;1037   
                          ENDP

000006  0000              DCW      0x0000
                  |L4.8|
                          DCD      0x4001683c

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

                  LTDC_ClearITPendingBit PROC
;;;1085     */
;;;1086   void LTDC_ClearITPendingBit(uint32_t LTDC_IT)
000000  4901              LDR      r1,|L5.8|
;;;1087   {
;;;1088     /* Check the parameters */
;;;1089     assert_param(IS_LTDC_IT(LTDC_IT));
;;;1090   
;;;1091     /* Clear the corresponding LTDC Interrupt */
;;;1092     LTDC->ICR = (uint32_t)LTDC_IT;
000002  6008              STR      r0,[r1,#0]
;;;1093   }
000004  4770              BX       lr
;;;1094   /**
                          ENDP

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

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

                  LTDC_Cmd PROC
;;;237    
;;;238    void LTDC_Cmd(FunctionalState NewState)
000000  4905              LDR      r1,|L6.24|
;;;239    {
;;;240      /* Check the parameters */
;;;241      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;242    
;;;243      if (NewState != DISABLE)
000002  2800              CMP      r0,#0
;;;244      {
;;;245        /* Enable LTDC by setting LTDCEN bit */
;;;246        LTDC->GCR |= (uint32_t)LTDC_GCR_LTDCEN;
;;;247      }
;;;248      else
;;;249      {
;;;250        /* Disable LTDC by clearing LTDCEN bit */
;;;251        LTDC->GCR &= ~(uint32_t)LTDC_GCR_LTDCEN;
000004  6808              LDR      r0,[r1,#0]
000006  d002              BEQ      |L6.14|
000008  f0400001          ORR      r0,r0,#1              ;246
00000c  e001              B        |L6.18|
                  |L6.14|
00000e  f0200001          BIC      r0,r0,#1
                  |L6.18|
000012  6008              STR      r0,[r1,#0]            ;246
;;;252      }
;;;253    }
000014  4770              BX       lr
;;;254    
                          ENDP

000016  0000              DCW      0x0000
                  |L6.24|
                          DCD      0x40016818

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

                  LTDC_ColorKeyingConfig PROC
;;;573    
;;;574    void LTDC_ColorKeyingConfig(LTDC_Layer_TypeDef* LTDC_Layerx, LTDC_ColorKeying_InitTypeDef* LTDC_colorkeying_InitStruct, FunctionalState NewState)
000000  b510              PUSH     {r4,lr}
;;;575    { 
000002  b192              CBZ      r2,|L7.42|
;;;576      uint32_t ckgreen = 0;
;;;577      uint32_t ckred = 0;
;;;578    
;;;579      /* Check the parameters */
;;;580      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;581      assert_param(IS_LTDC_CKEYING(LTDC_colorkeying_InitStruct->LTDC_ColorKeyBlue));
;;;582      assert_param(IS_LTDC_CKEYING(LTDC_colorkeying_InitStruct->LTDC_ColorKeyGreen));
;;;583      assert_param(IS_LTDC_CKEYING(LTDC_colorkeying_InitStruct->LTDC_ColorKeyRed));
;;;584      
;;;585      if (NewState != DISABLE)
;;;586      {
;;;587        /* Enable LTDC color keying by setting COLKEN bit */
;;;588        LTDC_Layerx->CR |= (uint32_t)LTDC_LxCR_COLKEN;
000004  6802              LDR      r2,[r0,#0]
000006  f0420202          ORR      r2,r2,#2
00000a  6002              STR      r2,[r0,#0]
;;;589        
;;;590        /* Sets the color keying values */
;;;591        ckgreen = (LTDC_colorkeying_InitStruct->LTDC_ColorKeyGreen << 8);
00000c  684a              LDR      r2,[r1,#4]
;;;592        ckred = (LTDC_colorkeying_InitStruct->LTDC_ColorKeyRed << 16);
;;;593        LTDC_Layerx->CKCR  &= ~(LTDC_LxCKCR_CKBLUE | LTDC_LxCKCR_CKGREEN | LTDC_LxCKCR_CKRED);
00000e  68c4              LDR      r4,[r0,#0xc]
000010  0213              LSLS     r3,r2,#8              ;591
000012  890a              LDRH     r2,[r1,#8]            ;592
000014  f004447f          AND      r4,r4,#0xff000000
000018  60c4              STR      r4,[r0,#0xc]
;;;594        LTDC_Layerx->CKCR |= (LTDC_colorkeying_InitStruct->LTDC_ColorKeyBlue | ckgreen | ckred);
00001a  68c4              LDR      r4,[r0,#0xc]
00001c  6809              LDR      r1,[r1,#0]
00001e  ea434302          ORR      r3,r3,r2,LSL #16
000022  430c              ORRS     r4,r4,r1
000024  431c              ORRS     r4,r4,r3
000026  60c4              STR      r4,[r0,#0xc]
000028  e003              B        |L7.50|
                  |L7.42|
;;;595      }
;;;596      else
;;;597      {
;;;598        /* Disable LTDC color keying by clearing COLKEN bit */
;;;599        LTDC_Layerx->CR &= ~(uint32_t)LTDC_LxCR_COLKEN;
00002a  6801              LDR      r1,[r0,#0]
00002c  f0210102          BIC      r1,r1,#2
000030  6001              STR      r1,[r0,#0]
                  |L7.50|
;;;600      }
;;;601      
;;;602      /* Reload shadow register */
;;;603      LTDC->SRCR = LTDC_IMReload;
000032  4902              LDR      r1,|L7.60|
000034  2001              MOVS     r0,#1
000036  6008              STR      r0,[r1,#0]
;;;604    }
000038  bd10              POP      {r4,pc}
;;;605    
                          ENDP

00003a  0000              DCW      0x0000
                  |L7.60|
                          DCD      0x40016824

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

                  LTDC_ColorKeyingStructInit PROC
;;;612    
;;;613    void LTDC_ColorKeyingStructInit(LTDC_ColorKeying_InitTypeDef* LTDC_colorkeying_InitStruct)
000000  2100              MOVS     r1,#0
;;;614    {
;;;615      /*!< Initialize the color keying values */
;;;616      LTDC_colorkeying_InitStruct->LTDC_ColorKeyBlue = 0x00;
;;;617      LTDC_colorkeying_InitStruct->LTDC_ColorKeyGreen = 0x00;
000002  6001              STR      r1,[r0,#0]
;;;618      LTDC_colorkeying_InitStruct->LTDC_ColorKeyRed = 0x00;
000004  6041              STR      r1,[r0,#4]
000006  6081              STR      r1,[r0,#8]
;;;619    }
000008  4770              BX       lr
;;;620    
                          ENDP


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

                  LTDC_DeInit PROC
;;;128    
;;;129    void LTDC_DeInit(void)
000000  b510              PUSH     {r4,lr}
;;;130    {
;;;131      /* Enable LTDC reset state */
;;;132      RCC_APB2PeriphResetCmd(RCC_APB2Periph_LTDC, ENABLE);
000002  2101              MOVS     r1,#1
000004  068c              LSLS     r4,r1,#26
000006  4620              MOV      r0,r4
000008  f7fffffe          BL       RCC_APB2PeriphResetCmd
;;;133      /* Release LTDC from reset state */
;;;134      RCC_APB2PeriphResetCmd(RCC_APB2Periph_LTDC, DISABLE);
00000c  4620              MOV      r0,r4
00000e  e8bd4010          POP      {r4,lr}
000012  2100              MOVS     r1,#0
000014  f7ffbffe          B.W      RCC_APB2PeriphResetCmd
;;;135    }
;;;136    
                          ENDP


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

                  LTDC_DitherCmd PROC
;;;261    
;;;262    void LTDC_DitherCmd(FunctionalState NewState)
000000  4905              LDR      r1,|L10.24|
;;;263    {
;;;264      /* Check the parameters */
;;;265      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;266    
;;;267      if (NewState != DISABLE)
000002  2800              CMP      r0,#0
;;;268      {
;;;269        /* Enable Dither by setting DTEN bit */
;;;270        LTDC->GCR |= (uint32_t)LTDC_GCR_DTEN;
;;;271      }
;;;272      else
;;;273      {
;;;274        /* Disable Dither by clearing DTEN bit */
;;;275        LTDC->GCR &= ~(uint32_t)LTDC_GCR_DTEN;
000004  6808              LDR      r0,[r1,#0]
000006  d002              BEQ      |L10.14|
000008  f4403080          ORR      r0,r0,#0x10000        ;270
00000c  e001              B        |L10.18|
                  |L10.14|
00000e  f4203080          BIC      r0,r0,#0x10000
                  |L10.18|
000012  6008              STR      r0,[r1,#0]            ;270
;;;276      }
;;;277    }
000014  4770              BX       lr
;;;278    
                          ENDP

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

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

                  LTDC_GetCDStatus PROC
;;;546    
;;;547    FlagStatus LTDC_GetCDStatus(uint32_t LTDC_CD)
000000  4903              LDR      r1,|L11.16|
;;;548    {
;;;549      FlagStatus bitstatus;
;;;550    
;;;551      /* Check the parameters */
;;;552      assert_param(IS_LTDC_GET_CD(LTDC_CD));
;;;553    
;;;554      if ((LTDC->CDSR & LTDC_CD) != (uint32_t)RESET)
000002  6809              LDR      r1,[r1,#0]
000004  4201              TST      r1,r0
000006  d001              BEQ      |L11.12|
;;;555      {
;;;556        bitstatus = SET;
000008  2001              MOVS     r0,#1
;;;557      }
;;;558      else
;;;559      {
;;;560        bitstatus = RESET;
;;;561      }
;;;562      return bitstatus;
;;;563    }
00000a  4770              BX       lr
                  |L11.12|
00000c  2000              MOVS     r0,#0                 ;560
00000e  4770              BX       lr
;;;564    
                          ENDP

                  |L11.16|
                          DCD      0x40016848

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

                  LTDC_GetFlagStatus PROC
;;;1000     */
;;;1001   FlagStatus LTDC_GetFlagStatus(uint32_t LTDC_FLAG)
000000  4a03              LDR      r2,|L12.16|
;;;1002   {
000002  4601              MOV      r1,r0
;;;1003     FlagStatus bitstatus = RESET;
000004  2000              MOVS     r0,#0
;;;1004   
;;;1005     /* Check the parameters */
;;;1006     assert_param(IS_LTDC_FLAG(LTDC_FLAG));
;;;1007   
;;;1008     if ((LTDC->ISR & LTDC_FLAG) != (uint32_t)RESET)
000006  6812              LDR      r2,[r2,#0]
000008  420a              TST      r2,r1
00000a  d000              BEQ      |L12.14|
;;;1009     {
;;;1010       bitstatus = SET;
00000c  2001              MOVS     r0,#1
                  |L12.14|
;;;1011     }
;;;1012     else
;;;1013     {
;;;1014       bitstatus = RESET;
;;;1015     }
;;;1016     return bitstatus;
;;;1017   }
00000e  4770              BX       lr
;;;1018   
                          ENDP

                  |L12.16|
                          DCD      0x40016838

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

                  LTDC_GetITStatus PROC
;;;1047     */
;;;1048   ITStatus LTDC_GetITStatus(uint32_t LTDC_IT)
000000  4a07              LDR      r2,|L13.32|
;;;1049   {
;;;1050     ITStatus bitstatus = RESET;
000002  2100              MOVS     r1,#0
;;;1051   
;;;1052     /* Check the parameters */
;;;1053     assert_param(IS_LTDC_IT(LTDC_IT));
;;;1054   
;;;1055     if ((LTDC->ISR & LTDC_IT) != (uint32_t)RESET)
000004  6812              LDR      r2,[r2,#0]
000006  4202              TST      r2,r0
000008  d000              BEQ      |L13.12|
;;;1056     {
;;;1057       bitstatus = SET;
00000a  2101              MOVS     r1,#1
                  |L13.12|
;;;1058     }
;;;1059     else
;;;1060     {
;;;1061       bitstatus = RESET;
;;;1062     }
;;;1063   
;;;1064     if (((LTDC->IER & LTDC_IT) != (uint32_t)RESET) && (bitstatus != (uint32_t)RESET))
00000c  4a04              LDR      r2,|L13.32|
00000e  1f12              SUBS     r2,r2,#4
000010  6812              LDR      r2,[r2,#0]
000012  4202              TST      r2,r0
000014  d002              BEQ      |L13.28|
000016  b109              CBZ      r1,|L13.28|
;;;1065     {
;;;1066       bitstatus = SET;
000018  2001              MOVS     r0,#1
;;;1067     }
;;;1068     else
;;;1069     {
;;;1070       bitstatus = RESET;
;;;1071     }
;;;1072     return bitstatus;
;;;1073   }
00001a  4770              BX       lr
                  |L13.28|
00001c  2000              MOVS     r0,#0                 ;1070
00001e  4770              BX       lr
;;;1074   
                          ENDP

                  |L13.32|
                          DCD      0x40016838

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

                  LTDC_GetPosStatus PROC
;;;510    
;;;511    LTDC_PosTypeDef LTDC_GetPosStatus(void)
000000  4905              LDR      r1,|L14.24|
;;;512    {
;;;513      LTDC_PosTypeDef LTDC_Pos_InitStruct;
;;;514    
;;;515      LTDC->CPSR &= ~(LTDC_CPSR_CYPOS | LTDC_CPSR_CXPOS);
000002  680a              LDR      r2,[r1,#0]
000004  2200              MOVS     r2,#0
000006  600a              STR      r2,[r1,#0]
;;;516    
;;;517      LTDC_Pos_InitStruct.LTDC_POSX = (uint32_t)(LTDC->CPSR >> 16);
000008  680a              LDR      r2,[r1,#0]
;;;518      LTDC_Pos_InitStruct.LTDC_POSY = (uint32_t)(LTDC->CPSR & 0xFFFF);
00000a  6809              LDR      r1,[r1,#0]
00000c  0c12              LSRS     r2,r2,#16             ;517
00000e  b289              UXTH     r1,r1
000010  e9c02100          STRD     r2,r1,[r0,#0]
;;;519    
;;;520      return LTDC_Pos_InitStruct;
;;;521    }
000014  4770              BX       lr
;;;522    
                          ENDP

000016  0000              DCW      0x0000
                  |L14.24|
                          DCD      0x40016844

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

                  LTDC_GetRGBWidth PROC
;;;285    
;;;286    LTDC_RGBTypeDef LTDC_GetRGBWidth(void)
000000  4908              LDR      r1,|L15.36|
;;;287    {
;;;288      LTDC_RGBTypeDef LTDC_RGB_InitStruct;
;;;289    
;;;290      LTDC->GCR &= (uint32_t)GCR_MASK;
000002  680a              LDR      r2,[r1,#0]
000004  4b08              LDR      r3,|L15.40|
000006  401a              ANDS     r2,r2,r3
000008  600a              STR      r2,[r1,#0]
;;;291    
;;;292      LTDC_RGB_InitStruct.LTDC_BlueWidth = (uint32_t)((LTDC->GCR >> 4) & 0x7);
00000a  680a              LDR      r2,[r1,#0]
;;;293      LTDC_RGB_InitStruct.LTDC_GreenWidth = (uint32_t)((LTDC->GCR >> 8) & 0x7);
00000c  680b              LDR      r3,[r1,#0]
00000e  f3c21202          UBFX     r2,r2,#4,#3           ;292
;;;294      LTDC_RGB_InitStruct.LTDC_RedWidth = (uint32_t)((LTDC->GCR >> 12) & 0x7);
000012  6809              LDR      r1,[r1,#0]
000014  f3c32302          UBFX     r3,r3,#8,#3           ;293
000018  f3c13102          UBFX     r1,r1,#12,#3
;;;295    
;;;296      return LTDC_RGB_InitStruct;
00001c  6002              STR      r2,[r0,#0]
00001e  e9c03101          STRD     r3,r1,[r0,#4]
;;;297    }
000022  4770              BX       lr
;;;298    
                          ENDP

                  |L15.36|
                          DCD      0x40016818
                  |L15.40|
                          DCD      0x0ffe888f

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

                  LTDC_ITConfig PROC
;;;974      */
;;;975    void LTDC_ITConfig(uint32_t LTDC_IT, FunctionalState NewState)
000000  4a04              LDR      r2,|L16.20|
;;;976    {
;;;977      /* Check the parameters */
;;;978      assert_param(IS_LTDC_IT(LTDC_IT));
;;;979      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;980    
;;;981      if (NewState != DISABLE)
000002  2900              CMP      r1,#0
;;;982      {
;;;983        LTDC->IER |= LTDC_IT;
;;;984      }
;;;985      else
;;;986      {
;;;987        LTDC->IER &= (uint32_t)~LTDC_IT;
000004  6811              LDR      r1,[r2,#0]
000006  d001              BEQ      |L16.12|
000008  4301              ORRS     r1,r1,r0              ;983
00000a  e000              B        |L16.14|
                  |L16.12|
00000c  4381              BICS     r1,r1,r0
                  |L16.14|
00000e  6011              STR      r1,[r2,#0]            ;983
;;;988      }
;;;989    }
000010  4770              BX       lr
;;;990    
                          ENDP

000012  0000              DCW      0x0000
                  |L16.20|
                          DCD      0x40016834

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

                  LTDC_Init PROC
;;;145    
;;;146    void LTDC_Init(LTDC_InitTypeDef* LTDC_InitStruct)
000000  b530              PUSH     {r4,r5,lr}
;;;147    {
;;;148      uint32_t horizontalsync = 0;
;;;149      uint32_t accumulatedHBP = 0;
;;;150      uint32_t accumulatedactiveW = 0;
;;;151      uint32_t totalwidth = 0;
;;;152      uint32_t backgreen = 0;
;;;153      uint32_t backred = 0;
;;;154    
;;;155      /* Check function parameters */
;;;156      assert_param(IS_LTDC_HSYNC(LTDC_InitStruct->LTDC_HorizontalSync));
;;;157      assert_param(IS_LTDC_VSYNC(LTDC_InitStruct->LTDC_VerticalSync));
;;;158      assert_param(IS_LTDC_AHBP(LTDC_InitStruct->LTDC_AccumulatedHBP));
;;;159      assert_param(IS_LTDC_AVBP(LTDC_InitStruct->LTDC_AccumulatedVBP));
;;;160      assert_param(IS_LTDC_AAH(LTDC_InitStruct->LTDC_AccumulatedActiveH));
;;;161      assert_param(IS_LTDC_AAW(LTDC_InitStruct->LTDC_AccumulatedActiveW));
;;;162      assert_param(IS_LTDC_TOTALH(LTDC_InitStruct->LTDC_TotalHeigh));
;;;163      assert_param(IS_LTDC_TOTALW(LTDC_InitStruct->LTDC_TotalWidth));
;;;164      assert_param(IS_LTDC_HSPOL(LTDC_InitStruct->LTDC_HSPolarity));
;;;165      assert_param(IS_LTDC_VSPOL(LTDC_InitStruct->LTDC_VSPolarity));
;;;166      assert_param(IS_LTDC_DEPOL(LTDC_InitStruct->LTDC_DEPolarity));
;;;167      assert_param(IS_LTDC_PCPOL(LTDC_InitStruct->LTDC_PCPolarity));
;;;168      assert_param(IS_LTDC_BackBlueValue(LTDC_InitStruct->LTDC_BackgroundBlueValue));
;;;169      assert_param(IS_LTDC_BackGreenValue(LTDC_InitStruct->LTDC_BackgroundGreenValue));
;;;170      assert_param(IS_LTDC_BackRedValue(LTDC_InitStruct->LTDC_BackgroundRedValue));
;;;171    
;;;172      /* Sets Synchronization size */
;;;173      LTDC->SSCR &= ~(LTDC_SSCR_VSH | LTDC_SSCR_HSW);
000002  4a26              LDR      r2,|L17.156|
000004  6813              LDR      r3,[r2,#0]
000006  4926              LDR      r1,|L17.160|
000008  400b              ANDS     r3,r3,r1
00000a  6013              STR      r3,[r2,#0]
;;;174      horizontalsync = (LTDC_InitStruct->LTDC_HorizontalSync << 16);
00000c  8a03              LDRH     r3,[r0,#0x10]
;;;175      LTDC->SSCR |= (horizontalsync | LTDC_InitStruct->LTDC_VerticalSync);
00000e  6814              LDR      r4,[r2,#0]
000010  6945              LDR      r5,[r0,#0x14]
000012  432c              ORRS     r4,r4,r5
000014  ea444403          ORR      r4,r4,r3,LSL #16
000018  6014              STR      r4,[r2,#0]
;;;176    
;;;177      /* Sets Accumulated Back porch */
;;;178      LTDC->BPCR &= ~(LTDC_BPCR_AVBP | LTDC_BPCR_AHBP);
00001a  1d12              ADDS     r2,r2,#4
00001c  6813              LDR      r3,[r2,#0]
00001e  400b              ANDS     r3,r3,r1
000020  6013              STR      r3,[r2,#0]
;;;179      accumulatedHBP = (LTDC_InitStruct->LTDC_AccumulatedHBP << 16);
000022  8b03              LDRH     r3,[r0,#0x18]
;;;180      LTDC->BPCR |= (accumulatedHBP | LTDC_InitStruct->LTDC_AccumulatedVBP);
000024  6814              LDR      r4,[r2,#0]
000026  69c5              LDR      r5,[r0,#0x1c]
000028  432c              ORRS     r4,r4,r5
00002a  ea444403          ORR      r4,r4,r3,LSL #16
00002e  6014              STR      r4,[r2,#0]
;;;181    
;;;182      /* Sets Accumulated Active Width */
;;;183      LTDC->AWCR &= ~(LTDC_AWCR_AAH | LTDC_AWCR_AAW);
000030  1d12              ADDS     r2,r2,#4
000032  6813              LDR      r3,[r2,#0]
000034  400b              ANDS     r3,r3,r1
000036  6013              STR      r3,[r2,#0]
;;;184      accumulatedactiveW = (LTDC_InitStruct->LTDC_AccumulatedActiveW << 16);
000038  8c03              LDRH     r3,[r0,#0x20]
;;;185      LTDC->AWCR |= (accumulatedactiveW | LTDC_InitStruct->LTDC_AccumulatedActiveH);
00003a  6814              LDR      r4,[r2,#0]
00003c  6a45              LDR      r5,[r0,#0x24]
00003e  432c              ORRS     r4,r4,r5
000040  ea444403          ORR      r4,r4,r3,LSL #16
000044  6014              STR      r4,[r2,#0]
;;;186    
;;;187      /* Sets Total Width */
;;;188      LTDC->TWCR &= ~(LTDC_TWCR_TOTALH | LTDC_TWCR_TOTALW);
000046  1d12              ADDS     r2,r2,#4
000048  6813              LDR      r3,[r2,#0]
00004a  400b              ANDS     r3,r3,r1
00004c  6013              STR      r3,[r2,#0]
;;;189      totalwidth = (LTDC_InitStruct->LTDC_TotalWidth << 16);
00004e  8d01              LDRH     r1,[r0,#0x28]
;;;190      LTDC->TWCR |= (totalwidth | LTDC_InitStruct->LTDC_TotalHeigh);
000050  6813              LDR      r3,[r2,#0]
000052  6ac4              LDR      r4,[r0,#0x2c]
000054  4323              ORRS     r3,r3,r4
000056  ea434301          ORR      r3,r3,r1,LSL #16
00005a  6013              STR      r3,[r2,#0]
;;;191    
;;;192      LTDC->GCR &= (uint32_t)GCR_MASK;
00005c  1d11              ADDS     r1,r2,#4
00005e  680a              LDR      r2,[r1,#0]
000060  4b10              LDR      r3,|L17.164|
000062  401a              ANDS     r2,r2,r3
000064  600a              STR      r2,[r1,#0]
000066  e9d02300          LDRD     r2,r3,[r0,#0]
;;;193      LTDC->GCR |=  (uint32_t)(LTDC_InitStruct->LTDC_HSPolarity | LTDC_InitStruct->LTDC_VSPolarity | \
00006a  431a              ORRS     r2,r2,r3
00006c  e9d03402          LDRD     r3,r4,[r0,#8]
000070  4323              ORRS     r3,r3,r4
000072  431a              ORRS     r2,r2,r3
000074  680b              LDR      r3,[r1,#0]
000076  431a              ORRS     r2,r2,r3
000078  600a              STR      r2,[r1,#0]
;;;194                               LTDC_InitStruct->LTDC_DEPolarity | LTDC_InitStruct->LTDC_PCPolarity);
;;;195    
;;;196      /* sets the background color value */
;;;197      backgreen = (LTDC_InitStruct->LTDC_BackgroundGreenValue << 8);
00007a  6b41              LDR      r1,[r0,#0x34]
00007c  020a              LSLS     r2,r1,#8
;;;198      backred = (LTDC_InitStruct->LTDC_BackgroundRedValue << 16);
00007e  8e01              LDRH     r1,[r0,#0x30]
000080  040b              LSLS     r3,r1,#16
;;;199    
;;;200      LTDC->BCCR &= ~(LTDC_BCCR_BCBLUE | LTDC_BCCR_BCGREEN | LTDC_BCCR_BCRED);
000082  4906              LDR      r1,|L17.156|
000084  3124              ADDS     r1,r1,#0x24
000086  680c              LDR      r4,[r1,#0]
000088  f004447f          AND      r4,r4,#0xff000000
00008c  600c              STR      r4,[r1,#0]
;;;201      LTDC->BCCR |= (backred | backgreen | LTDC_InitStruct->LTDC_BackgroundBlueValue);
00008e  680c              LDR      r4,[r1,#0]
000090  6b80              LDR      r0,[r0,#0x38]
000092  4313              ORRS     r3,r3,r2
000094  4304              ORRS     r4,r4,r0
000096  431c              ORRS     r4,r4,r3
000098  600c              STR      r4,[r1,#0]
;;;202    }
00009a  bd30              POP      {r4,r5,pc}
;;;203    
                          ENDP

                  |L17.156|
                          DCD      0x40016808
                  |L17.160|
                          DCD      0xf000f800
                  |L17.164|
                          DCD      0x0ffe888f

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

                  LTDC_LIPConfig PROC
;;;319    
;;;320    void LTDC_LIPConfig(uint32_t LTDC_LIPositionConfig)
000000  4901              LDR      r1,|L18.8|
;;;321    {
;;;322      /* Check the parameters */
;;;323      assert_param(IS_LTDC_LIPOS(LTDC_LIPositionConfig));
;;;324    
;;;325      /* Sets the Line Interrupt position */
;;;326      LTDC->LIPCR = (uint32_t)LTDC_LIPositionConfig;
000002  6008              STR      r0,[r1,#0]
;;;327    }
000004  4770              BX       lr
;;;328    
                          ENDP

000006  0000              DCW      0x0000
                  |L18.8|
                          DCD      0x40016840

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

                  LTDC_LayerAddress PROC
;;;782    
;;;783    void LTDC_LayerAddress(LTDC_Layer_TypeDef* LTDC_Layerx, uint32_t Address)
000000  6281              STR      r1,[r0,#0x28]
;;;784    {
;;;785      /* Reconfigures the color frame buffer start address */
;;;786      LTDC_Layerx->CFBAR = Address;
;;;787    }
000002  4770              BX       lr
;;;788      
                          ENDP


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

                  LTDC_LayerAlpha PROC
;;;767    
;;;768    void LTDC_LayerAlpha(LTDC_Layer_TypeDef* LTDC_Layerx, uint8_t ConstantAlpha)
000000  6141              STR      r1,[r0,#0x14]
;;;769    {  
;;;770      /* reconfigure the constant alpha value */      
;;;771      LTDC_Layerx->CACR = ConstantAlpha;
;;;772    }
000002  4770              BX       lr
;;;773    
                          ENDP


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

                  LTDC_LayerCmd PROC
;;;485    
;;;486    void LTDC_LayerCmd(LTDC_Layer_TypeDef* LTDC_Layerx, FunctionalState NewState)
000000  2900              CMP      r1,#0
;;;487    {
;;;488      /* Check the parameters */
;;;489      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;490    
;;;491      if (NewState != DISABLE)
;;;492      {
;;;493        /* Enable LTDC_Layer by setting LEN bit */
;;;494        LTDC_Layerx->CR |= (uint32_t)LTDC_LxCR_LEN;
;;;495      }
;;;496      else
;;;497      {
;;;498        /* Disable LTDC_Layer by clearing LEN bit */
;;;499        LTDC_Layerx->CR &= ~(uint32_t)LTDC_LxCR_LEN;
000002  6801              LDR      r1,[r0,#0]
000004  d002              BEQ      |L21.12|
000006  f0410101          ORR      r1,r1,#1              ;494
00000a  e001              B        |L21.16|
                  |L21.12|
00000c  f0210101          BIC      r1,r1,#1
                  |L21.16|
000010  6001              STR      r1,[r0,#0]            ;494
;;;500      }
;;;501    }
000012  4770              BX       lr
;;;502    
                          ENDP


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

                  LTDC_LayerInit PROC
;;;358    
;;;359    void LTDC_LayerInit(LTDC_Layer_TypeDef* LTDC_Layerx, LTDC_Layer_InitTypeDef* LTDC_Layer_InitStruct)
000000  b570              PUSH     {r4-r6,lr}
;;;360    {
;;;361    
;;;362      uint32_t whsppos = 0;
;;;363      uint32_t wvsppos = 0;
;;;364      uint32_t dcgreen = 0;
;;;365      uint32_t dcred = 0;
;;;366      uint32_t dcalpha = 0;
;;;367      uint32_t cfbp = 0;
;;;368    
;;;369    /* Check the parameters */
;;;370      assert_param(IS_LTDC_Pixelformat(LTDC_Layer_InitStruct->LTDC_PixelFormat));
;;;371      assert_param(IS_LTDC_BlendingFactor1(LTDC_Layer_InitStruct->LTDC_BlendingFactor_1));
;;;372      assert_param(IS_LTDC_BlendingFactor2(LTDC_Layer_InitStruct->LTDC_BlendingFactor_2));
;;;373      assert_param(IS_LTDC_HCONFIGST(LTDC_Layer_InitStruct->LTDC_HorizontalStart));
;;;374      assert_param(IS_LTDC_HCONFIGSP(LTDC_Layer_InitStruct->LTDC_HorizontalStop));
;;;375      assert_param(IS_LTDC_VCONFIGST(LTDC_Layer_InitStruct->LTDC_VerticalStart));
;;;376      assert_param(IS_LTDC_VCONFIGSP(LTDC_Layer_InitStruct->LTDC_VerticalStop));  
;;;377      assert_param(IS_LTDC_DEFAULTCOLOR(LTDC_Layer_InitStruct->LTDC_DefaultColorBlue));
;;;378      assert_param(IS_LTDC_DEFAULTCOLOR(LTDC_Layer_InitStruct->LTDC_DefaultColorGreen));
;;;379      assert_param(IS_LTDC_DEFAULTCOLOR(LTDC_Layer_InitStruct->LTDC_DefaultColorRed));
;;;380      assert_param(IS_LTDC_DEFAULTCOLOR(LTDC_Layer_InitStruct->LTDC_DefaultColorAlpha));
;;;381      assert_param(IS_LTDC_CFBP(LTDC_Layer_InitStruct->LTDC_CFBPitch));
;;;382      assert_param(IS_LTDC_CFBLL(LTDC_Layer_InitStruct->LTDC_CFBLineLength));
;;;383      assert_param(IS_LTDC_CFBLNBR(LTDC_Layer_InitStruct->LTDC_CFBLineNumber));
;;;384    
;;;385      /* Configures the horizontal start and stop position */
;;;386      whsppos = LTDC_Layer_InitStruct->LTDC_HorizontalStop << 16;
000002  888a              LDRH     r2,[r1,#4]
;;;387      LTDC_Layerx->WHPCR &= ~(LTDC_LxWHPCR_WHSTPOS | LTDC_LxWHPCR_WHSPPOS);
000004  6843              LDR      r3,[r0,#4]
000006  f4034370          AND      r3,r3,#0xf000
00000a  6043              STR      r3,[r0,#4]
;;;388      LTDC_Layerx->WHPCR = (LTDC_Layer_InitStruct->LTDC_HorizontalStart | whsppos);
00000c  680b              LDR      r3,[r1,#0]
00000e  ea434302          ORR      r3,r3,r2,LSL #16
000012  6043              STR      r3,[r0,#4]
;;;389    
;;;390      /* Configures the vertical start and stop position */
;;;391      wvsppos = LTDC_Layer_InitStruct->LTDC_VerticalStop << 16;
000014  898a              LDRH     r2,[r1,#0xc]
;;;392      LTDC_Layerx->WVPCR &= ~(LTDC_LxWVPCR_WVSTPOS | LTDC_LxWVPCR_WVSPPOS);
000016  6883              LDR      r3,[r0,#8]
000018  f4034370          AND      r3,r3,#0xf000
00001c  6083              STR      r3,[r0,#8]
;;;393      LTDC_Layerx->WVPCR  = (LTDC_Layer_InitStruct->LTDC_VerticalStart | wvsppos);
00001e  688b              LDR      r3,[r1,#8]
000020  ea434302          ORR      r3,r3,r2,LSL #16
000024  6083              STR      r3,[r0,#8]
;;;394    
;;;395      /* Specifies the pixel format */
;;;396      LTDC_Layerx->PFCR &= ~(LTDC_LxPFCR_PF);
000026  6902              LDR      r2,[r0,#0x10]
000028  f0220207          BIC      r2,r2,#7
00002c  6102              STR      r2,[r0,#0x10]
;;;397      LTDC_Layerx->PFCR = (LTDC_Layer_InitStruct->LTDC_PixelFormat);
00002e  690a              LDR      r2,[r1,#0x10]
000030  6102              STR      r2,[r0,#0x10]
;;;398    
;;;399      /* Configures the default color values */
;;;400      dcgreen = (LTDC_Layer_InitStruct->LTDC_DefaultColorGreen << 8);
000032  69ca              LDR      r2,[r1,#0x1c]
;;;401      dcred = (LTDC_Layer_InitStruct->LTDC_DefaultColorRed << 16);
;;;402      dcalpha = (LTDC_Layer_InitStruct->LTDC_DefaultColorAlpha << 24);
000034  f8913024          LDRB     r3,[r1,#0x24]
000038  0214              LSLS     r4,r2,#8              ;400
00003a  8c0a              LDRH     r2,[r1,#0x20]         ;401
;;;403      LTDC_Layerx->DCCR &=  ~(LTDC_LxDCCR_DCBLUE | LTDC_LxDCCR_DCGREEN | LTDC_LxDCCR_DCRED | LTDC_LxDCCR_DCALPHA);
00003c  6985              LDR      r5,[r0,#0x18]
00003e  0412              LSLS     r2,r2,#16             ;401
000040  2600              MOVS     r6,#0
000042  6186              STR      r6,[r0,#0x18]
;;;404      LTDC_Layerx->DCCR = (LTDC_Layer_InitStruct->LTDC_DefaultColorBlue | dcgreen | \
000044  698d              LDR      r5,[r1,#0x18]
000046  ea426203          ORR      r2,r2,r3,LSL #24
00004a  4325              ORRS     r5,r5,r4
00004c  4315              ORRS     r5,r5,r2
00004e  6185              STR      r5,[r0,#0x18]
;;;405                            dcred | dcalpha);
;;;406    
;;;407      /* Specifies the constant alpha value */      
;;;408      LTDC_Layerx->CACR &= ~(LTDC_LxCACR_CONSTA);
000050  6942              LDR      r2,[r0,#0x14]
000052  f02202ff          BIC      r2,r2,#0xff
000056  6142              STR      r2,[r0,#0x14]
;;;409      LTDC_Layerx->CACR = (LTDC_Layer_InitStruct->LTDC_ConstantAlpha);
000058  694a              LDR      r2,[r1,#0x14]
00005a  6142              STR      r2,[r0,#0x14]
;;;410    
;;;411      /* Specifies the blending factors */
;;;412      LTDC_Layerx->BFCR &= ~(LTDC_LxBFCR_BF2 | LTDC_LxBFCR_BF1);
00005c  69c2              LDR      r2,[r0,#0x1c]
00005e  f2407307          MOV      r3,#0x707
000062  439a              BICS     r2,r2,r3
000064  61c2              STR      r2,[r0,#0x1c]
000066  e9d1230a          LDRD     r2,r3,[r1,#0x28]
;;;413      LTDC_Layerx->BFCR = (LTDC_Layer_InitStruct->LTDC_BlendingFactor_1 | LTDC_Layer_InitStruct->LTDC_BlendingFactor_2);
00006a  431a              ORRS     r2,r2,r3
00006c  61c2              STR      r2,[r0,#0x1c]
;;;414    
;;;415      /* Configures the color frame buffer start address */
;;;416      LTDC_Layerx->CFBAR &= ~(LTDC_LxCFBAR_CFBADD);
00006e  6a82              LDR      r2,[r0,#0x28]
000070  6286              STR      r6,[r0,#0x28]
;;;417      LTDC_Layerx->CFBAR = (LTDC_Layer_InitStruct->LTDC_CFBStartAdress);
000072  6b0a              LDR      r2,[r1,#0x30]
000074  6282              STR      r2,[r0,#0x28]
;;;418    
;;;419      /* Configures the color frame buffer pitch in byte */
;;;420      cfbp = (LTDC_Layer_InitStruct->LTDC_CFBPitch << 16);
000076  8f0a              LDRH     r2,[r1,#0x38]
;;;421      LTDC_Layerx->CFBLR  &= ~(LTDC_LxCFBLR_CFBLL | LTDC_LxCFBLR_CFBP);
000078  6ac3              LDR      r3,[r0,#0x2c]
00007a  f00323e0          AND      r3,r3,#0xe000e000
00007e  62c3              STR      r3,[r0,#0x2c]
;;;422      LTDC_Layerx->CFBLR  = (LTDC_Layer_InitStruct->LTDC_CFBLineLength | cfbp);
000080  6b4b              LDR      r3,[r1,#0x34]
000082  ea434302          ORR      r3,r3,r2,LSL #16
000086  62c3              STR      r3,[r0,#0x2c]
;;;423    
;;;424      /* Configures the frame buffer line number */
;;;425      LTDC_Layerx->CFBLNR  &= ~(LTDC_LxCFBLNR_CFBLNBR);
000088  6b02              LDR      r2,[r0,#0x30]
00008a  f36f020a          BFC      r2,#0,#11
00008e  6302              STR      r2,[r0,#0x30]
;;;426      LTDC_Layerx->CFBLNR  = (LTDC_Layer_InitStruct->LTDC_CFBLineNumber);
000090  6bc9              LDR      r1,[r1,#0x3c]
000092  6301              STR      r1,[r0,#0x30]
;;;427    
;;;428    }
000094  bd70              POP      {r4-r6,pc}
;;;429    
                          ENDP


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

                  LTDC_LayerPixelFormat PROC
;;;860    
;;;861    void LTDC_LayerPixelFormat(LTDC_Layer_TypeDef* LTDC_Layerx, uint32_t PixelFormat)
000000  6902              LDR      r2,[r0,#0x10]
;;;862    {
000002  b30a              CBZ      r2,|L23.72|
;;;863    
;;;864      uint8_t temp;
;;;865      uint32_t tempreg;
;;;866      
;;;867      tempreg = LTDC_Layerx->PFCR;
;;;868      
;;;869      if (tempreg == LTDC_Pixelformat_ARGB8888)
;;;870      {
;;;871        temp = 4;
;;;872      }
;;;873      else if (tempreg == LTDC_Pixelformat_RGB888)
000004  2a01              CMP      r2,#1
000006  d021              BEQ      |L23.76|
;;;874      {
;;;875        temp = 3;
;;;876      }
;;;877      else if ((tempreg == LTDC_Pixelformat_ARGB4444) || \
000008  2a04              CMP      r2,#4
00000a  d021              BEQ      |L23.80|
;;;878              (tempreg == LTDC_Pixelformat_RGB565)    || \
00000c  2a02              CMP      r2,#2
00000e  d01f              BEQ      |L23.80|
;;;879              (tempreg == LTDC_Pixelformat_ARGB1555)  || \
000010  2a03              CMP      r2,#3
000012  d01d              BEQ      |L23.80|
;;;880              (tempreg == LTDC_Pixelformat_AL88))  
000014  2a07              CMP      r2,#7
000016  d01b              BEQ      |L23.80|
;;;881      {
;;;882        temp = 2;  
;;;883      }
;;;884      else
;;;885      {
;;;886        temp = 1;
000018  2201              MOVS     r2,#1
                  |L23.26|
;;;887      }
;;;888      
;;;889      tempreg = (LTDC_Layerx->CFBLR >> 16);
00001a  6ac3              LDR      r3,[r0,#0x2c]
00001c  0c1b              LSRS     r3,r3,#16
;;;890      tempreg = (tempreg / temp); 
00001e  fbb3f3f2          UDIV     r3,r3,r2
;;;891      
;;;892      if (PixelFormat == LTDC_Pixelformat_ARGB8888)
000022  b1b9              CBZ      r1,|L23.84|
;;;893      {
;;;894        temp = 4;
;;;895      }
;;;896      else if (PixelFormat == LTDC_Pixelformat_RGB888)
000024  2901              CMP      r1,#1
000026  d017              BEQ      |L23.88|
;;;897      {
;;;898        temp = 3;
;;;899      }
;;;900      else if ((PixelFormat == LTDC_Pixelformat_ARGB4444) || \
000028  2904              CMP      r1,#4
00002a  d017              BEQ      |L23.92|
;;;901              (PixelFormat == LTDC_Pixelformat_RGB565)    || \
00002c  2902              CMP      r1,#2
00002e  d015              BEQ      |L23.92|
;;;902              (PixelFormat == LTDC_Pixelformat_ARGB1555)  || \
000030  2903              CMP      r1,#3
000032  d013              BEQ      |L23.92|
;;;903              (PixelFormat == LTDC_Pixelformat_AL88))
000034  2907              CMP      r1,#7
000036  d011              BEQ      |L23.92|
;;;904      {
;;;905        temp = 2;  
;;;906      }
;;;907      else
;;;908      {
;;;909        temp = 1;
000038  2201              MOVS     r2,#1
                  |L23.58|
;;;910      }
;;;911      
;;;912      /* Reconfigures the color frame buffer pitch in byte */
;;;913      LTDC_Layerx->CFBLR  = ((tempreg * temp) << 16) | ((tempreg * temp) + 3);  
00003a  4353              MULS     r3,r2,r3
00003c  1cda              ADDS     r2,r3,#3
00003e  ea424203          ORR      r2,r2,r3,LSL #16
000042  62c2              STR      r2,[r0,#0x2c]
;;;914    
;;;915      /* Reconfigures the color frame buffer start address */
;;;916      LTDC_Layerx->PFCR = PixelFormat;
000044  6101              STR      r1,[r0,#0x10]
;;;917        
;;;918    }
000046  4770              BX       lr
                  |L23.72|
000048  2204              MOVS     r2,#4                 ;871
00004a  e7e6              B        |L23.26|
                  |L23.76|
00004c  2203              MOVS     r2,#3                 ;875
00004e  e7e4              B        |L23.26|
                  |L23.80|
000050  2202              MOVS     r2,#2                 ;882
000052  e7e2              B        |L23.26|
                  |L23.84|
000054  2204              MOVS     r2,#4                 ;894
000056  e7f0              B        |L23.58|
                  |L23.88|
000058  2203              MOVS     r2,#3                 ;898
00005a  e7ee              B        |L23.58|
                  |L23.92|
00005c  2202              MOVS     r2,#2                 ;905
00005e  e7ec              B        |L23.58|
;;;919        
                          ENDP


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

                  LTDC_LayerPosition PROC
;;;706    
;;;707    void LTDC_LayerPosition(LTDC_Layer_TypeDef* LTDC_Layerx, uint16_t OffsetX, uint16_t OffsetY)
000000  b510              PUSH     {r4,lr}
;;;708    {
;;;709      
;;;710      uint32_t tempreg, temp;
;;;711      uint32_t horizontal_start;
;;;712      uint32_t horizontal_stop;
;;;713      uint32_t vertical_start;
;;;714      uint32_t vertical_stop;
;;;715      
;;;716      LTDC_Layerx->WHPCR &= ~(LTDC_LxWHPCR_WHSTPOS | LTDC_LxWHPCR_WHSPPOS);
000002  6843              LDR      r3,[r0,#4]
000004  f4034370          AND      r3,r3,#0xf000
000008  6043              STR      r3,[r0,#4]
;;;717      LTDC_Layerx->WVPCR &= ~(LTDC_LxWVPCR_WVSTPOS | LTDC_LxWVPCR_WVSPPOS);
00000a  6883              LDR      r3,[r0,#8]
00000c  f4034370          AND      r3,r3,#0xf000
000010  6083              STR      r3,[r0,#8]
;;;718      
;;;719      /* Reconfigures the horizontal and vertical start position */
;;;720      tempreg = LTDC->BPCR;
000012  4b17              LDR      r3,|L24.112|
000014  681c              LDR      r4,[r3,#0]
;;;721      horizontal_start = (tempreg >> 16) + 1 + OffsetX;
000016  eb014314          ADD      r3,r1,r4,LSR #16
;;;722      vertical_start = (tempreg & 0xFFFF) + 1 + OffsetY;
;;;723      
;;;724      /* Reconfigures the horizontal and vertical stop position */
;;;725      /* Get the number of byte per pixel */
;;;726      
;;;727      tempreg = LTDC_Layerx->PFCR;
;;;728      
;;;729      if (tempreg == LTDC_Pixelformat_ARGB8888)
;;;730      {
;;;731        temp = 4;
;;;732      }
;;;733      else if (tempreg == LTDC_Pixelformat_RGB888)
;;;734      {
;;;735        temp = 3;
;;;736      }
;;;737      else if ((tempreg == LTDC_Pixelformat_ARGB4444) || 
;;;738              (tempreg == LTDC_Pixelformat_RGB565)    ||  
;;;739              (tempreg == LTDC_Pixelformat_ARGB1555)  ||
;;;740              (tempreg == LTDC_Pixelformat_AL88))
;;;741      {
;;;742        temp = 2;  
;;;743      }
;;;744      else
;;;745      {
;;;746        temp = 1;
;;;747      }  
;;;748        
;;;749      tempreg = LTDC_Layerx->CFBLR;
;;;750      horizontal_stop = (((tempreg & 0x1FFF) - 3)/temp) + horizontal_start - 1;
;;;751      
;;;752      tempreg = LTDC_Layerx->CFBLNR;
;;;753      vertical_stop = (tempreg & 0x7FF) + vertical_start - 1;  
;;;754      
;;;755      LTDC_Layerx->WHPCR = horizontal_start | (horizontal_stop << 16);
;;;756      LTDC_Layerx->WVPCR = vertical_start | (vertical_stop << 16);  
;;;757    }
00001a  fa12f284          UXTAH    r2,r2,r4
00001e  6901              LDR      r1,[r0,#0x10]         ;727
000020  1c52              ADDS     r2,r2,#1              ;727
000022  1c5b              ADDS     r3,r3,#1              ;727
000024  b1f1              CBZ      r1,|L24.100|
000026  2901              CMP      r1,#1                 ;733
000028  d01e              BEQ      |L24.104|
00002a  2904              CMP      r1,#4                 ;737
00002c  d01e              BEQ      |L24.108|
00002e  2902              CMP      r1,#2                 ;738
000030  d01c              BEQ      |L24.108|
000032  2903              CMP      r1,#3                 ;739
000034  d01a              BEQ      |L24.108|
000036  2907              CMP      r1,#7                 ;740
000038  d018              BEQ      |L24.108|
00003a  2101              MOVS     r1,#1                 ;746
                  |L24.60|
00003c  6ac4              LDR      r4,[r0,#0x2c]         ;749
00003e  f3c4040c          UBFX     r4,r4,#0,#13          ;750
000042  1ee4              SUBS     r4,r4,#3              ;750
000044  fbb4f1f1          UDIV     r1,r4,r1              ;750
000048  6b04              LDR      r4,[r0,#0x30]         ;752
00004a  4419              ADD      r1,r1,r3              ;750
00004c  1e49              SUBS     r1,r1,#1              ;753
00004e  f3c4040a          UBFX     r4,r4,#0,#11          ;753
000052  ea434101          ORR      r1,r3,r1,LSL #16      ;755
000056  4414              ADD      r4,r4,r2              ;753
000058  6041              STR      r1,[r0,#4]            ;755
00005a  1e64              SUBS     r4,r4,#1              ;755
00005c  ea424104          ORR      r1,r2,r4,LSL #16      ;756
000060  6081              STR      r1,[r0,#8]            ;756
000062  bd10              POP      {r4,pc}
                  |L24.100|
000064  2104              MOVS     r1,#4                 ;731
000066  e7e9              B        |L24.60|
                  |L24.104|
000068  2103              MOVS     r1,#3                 ;735
00006a  e7e7              B        |L24.60|
                  |L24.108|
00006c  2102              MOVS     r1,#2                 ;742
00006e  e7e5              B        |L24.60|
;;;758      
                          ENDP

                  |L24.112|
                          DCD      0x4001680c

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

                  LTDC_LayerSize PROC
;;;798    
;;;799    void LTDC_LayerSize(LTDC_Layer_TypeDef* LTDC_Layerx, uint32_t Width, uint32_t Height)
000000  b5f0              PUSH     {r4-r7,lr}
;;;800    {
;;;801    
;;;802      uint8_t temp;
;;;803      uint32_t tempreg;
;;;804      uint32_t horizontal_start;
;;;805      uint32_t horizontal_stop;
;;;806      uint32_t vertical_start;
;;;807      uint32_t vertical_stop;  
;;;808      
;;;809      tempreg = LTDC_Layerx->PFCR;
000002  6903              LDR      r3,[r0,#0x10]
000004  b30b              CBZ      r3,|L25.74|
;;;810      
;;;811      if (tempreg == LTDC_Pixelformat_ARGB8888)
;;;812      {
;;;813        temp = 4;
;;;814      }
;;;815      else if (tempreg == LTDC_Pixelformat_RGB888)
000006  2b01              CMP      r3,#1
000008  d021              BEQ      |L25.78|
;;;816      {
;;;817        temp = 3;
;;;818      }
;;;819      else if ((tempreg == LTDC_Pixelformat_ARGB4444) || \
00000a  2b04              CMP      r3,#4
00000c  d021              BEQ      |L25.82|
;;;820              (tempreg == LTDC_Pixelformat_RGB565)    || \
00000e  2b02              CMP      r3,#2
000010  d01f              BEQ      |L25.82|
;;;821              (tempreg == LTDC_Pixelformat_ARGB1555)  || \
000012  2b03              CMP      r3,#3
000014  d01d              BEQ      |L25.82|
;;;822              (tempreg == LTDC_Pixelformat_AL88))
000016  2b07              CMP      r3,#7
000018  d01b              BEQ      |L25.82|
;;;823      {
;;;824        temp = 2;  
;;;825      }
;;;826      else
;;;827      {
;;;828        temp = 1;
00001a  2301              MOVS     r3,#1
                  |L25.28|
;;;829      }
;;;830    
;;;831      /* update horizontal and vertical stop */
;;;832      tempreg = LTDC_Layerx->WHPCR;
00001c  6844              LDR      r4,[r0,#4]
;;;833      horizontal_start = (tempreg & 0x1FFF);
00001e  f3c4050c          UBFX     r5,r4,#0,#13
;;;834      horizontal_stop = Width + horizontal_start - 1;  
;;;835    
;;;836      tempreg = LTDC_Layerx->WVPCR;
000022  6884              LDR      r4,[r0,#8]
000024  194e              ADDS     r6,r1,r5              ;834
;;;837      vertical_start = (tempreg & 0x1FFF);
000026  f3c4040c          UBFX     r4,r4,#0,#13
;;;838      vertical_stop = Height + vertical_start - 1;  
00002a  1917              ADDS     r7,r2,r4
00002c  1e76              SUBS     r6,r6,#1
;;;839      
;;;840      LTDC_Layerx->WHPCR = horizontal_start | (horizontal_stop << 16);
00002e  ea454506          ORR      r5,r5,r6,LSL #16
000032  6045              STR      r5,[r0,#4]
000034  1e7f              SUBS     r7,r7,#1
;;;841      LTDC_Layerx->WVPCR = vertical_start | (vertical_stop << 16);  
000036  ea444407          ORR      r4,r4,r7,LSL #16
00003a  6084              STR      r4,[r0,#8]
;;;842    
;;;843      /* Reconfigures the color frame buffer pitch in byte */
;;;844      LTDC_Layerx->CFBLR  = ((Width * temp) << 16) | ((Width * temp) + 3);  
00003c  4359              MULS     r1,r3,r1
00003e  1ccb              ADDS     r3,r1,#3
000040  ea434101          ORR      r1,r3,r1,LSL #16
000044  62c1              STR      r1,[r0,#0x2c]
;;;845    
;;;846      /* Reconfigures the frame buffer line number */
;;;847      LTDC_Layerx->CFBLNR  = Height;  
000046  6302              STR      r2,[r0,#0x30]
;;;848      
;;;849    }
000048  bdf0              POP      {r4-r7,pc}
                  |L25.74|
00004a  2304              MOVS     r3,#4                 ;813
00004c  e7e6              B        |L25.28|
                  |L25.78|
00004e  2303              MOVS     r3,#3                 ;817
000050  e7e4              B        |L25.28|
                  |L25.82|
000052  2302              MOVS     r3,#2                 ;824
000054  e7e2              B        |L25.28|
;;;850    
                          ENDP


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

                  LTDC_LayerStructInit PROC
;;;436    
;;;437    void LTDC_LayerStructInit(LTDC_Layer_InitTypeDef * LTDC_Layer_InitStruct)
000000  2100              MOVS     r1,#0
;;;438    {
;;;439      /*--------------- Reset Layer structure parameters values -------------------*/
;;;440    
;;;441      /*!< Initialize the horizontal limit member */
;;;442      LTDC_Layer_InitStruct->LTDC_HorizontalStart = 0x00;
;;;443      LTDC_Layer_InitStruct->LTDC_HorizontalStop = 0x00;
000002  6001              STR      r1,[r0,#0]
;;;444    
;;;445      /*!< Initialize the vertical limit member */
;;;446      LTDC_Layer_InitStruct->LTDC_VerticalStart = 0x00;
000004  6041              STR      r1,[r0,#4]
;;;447      LTDC_Layer_InitStruct->LTDC_VerticalStop = 0x00;
000006  6081              STR      r1,[r0,#8]
;;;448    
;;;449      /*!< Initialize the pixel format member */
;;;450      LTDC_Layer_InitStruct->LTDC_PixelFormat = LTDC_Pixelformat_ARGB8888;
;;;451    
;;;452      /*!< Initialize the constant alpha value */
;;;453      LTDC_Layer_InitStruct->LTDC_ConstantAlpha = 0xFF;
000008  22ff              MOVS     r2,#0xff
00000a  60c1              STR      r1,[r0,#0xc]
00000c  e9c01204          STRD     r1,r2,[r0,#0x10]
;;;454    
;;;455      /*!< Initialize the default color values */
;;;456      LTDC_Layer_InitStruct->LTDC_DefaultColorBlue = 0x00;
;;;457      LTDC_Layer_InitStruct->LTDC_DefaultColorGreen = 0x00;
000010  6181              STR      r1,[r0,#0x18]
;;;458      LTDC_Layer_InitStruct->LTDC_DefaultColorRed = 0x00;
000012  61c1              STR      r1,[r0,#0x1c]
;;;459      LTDC_Layer_InitStruct->LTDC_DefaultColorAlpha = 0x00;
;;;460    
;;;461      /*!< Initialize the blending factors */
;;;462      LTDC_Layer_InitStruct->LTDC_BlendingFactor_1 = LTDC_BlendingFactor1_PAxCA;
000014  f44f62c0          MOV      r2,#0x600
000018  6201              STR      r1,[r0,#0x20]
00001a  e9c01209          STRD     r1,r2,[r0,#0x24]
;;;463      LTDC_Layer_InitStruct->LTDC_BlendingFactor_2 = LTDC_BlendingFactor2_PAxCA;
00001e  2207              MOVS     r2,#7
000020  e9c0210b          STRD     r2,r1,[r0,#0x2c]
;;;464    
;;;465      /*!< Initialize the frame buffer start address */
;;;466      LTDC_Layer_InitStruct->LTDC_CFBStartAdress = 0x00;
;;;467    
;;;468      /*!< Initialize the frame buffer pitch and line length */
;;;469      LTDC_Layer_InitStruct->LTDC_CFBLineLength = 0x00;
;;;470      LTDC_Layer_InitStruct->LTDC_CFBPitch = 0x00;
000024  6341              STR      r1,[r0,#0x34]
;;;471    
;;;472      /*!< Initialize the frame buffer line number */
;;;473      LTDC_Layer_InitStruct->LTDC_CFBLineNumber = 0x00;
000026  6381              STR      r1,[r0,#0x38]
000028  63c1              STR      r1,[r0,#0x3c]
;;;474    }
00002a  4770              BX       lr
;;;475    
                          ENDP


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

                  LTDC_PosStructInit PROC
;;;529    
;;;530    void LTDC_PosStructInit(LTDC_PosTypeDef* LTDC_Pos_InitStruct)
000000  2100              MOVS     r1,#0
;;;531    {
;;;532      LTDC_Pos_InitStruct->LTDC_POSX = 0x00;
;;;533      LTDC_Pos_InitStruct->LTDC_POSY = 0x00;
000002  6001              STR      r1,[r0,#0]
000004  6041              STR      r1,[r0,#4]
;;;534    }
000006  4770              BX       lr
;;;535    
                          ENDP


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

                  LTDC_RGBStructInit PROC
;;;305    
;;;306    void LTDC_RGBStructInit(LTDC_RGBTypeDef* LTDC_RGB_InitStruct)
000000  2102              MOVS     r1,#2
;;;307    {
;;;308      LTDC_RGB_InitStruct->LTDC_BlueWidth = 0x02;
;;;309      LTDC_RGB_InitStruct->LTDC_GreenWidth = 0x02;
000002  6001              STR      r1,[r0,#0]
;;;310      LTDC_RGB_InitStruct->LTDC_RedWidth = 0x02;
000004  6041              STR      r1,[r0,#4]
000006  6081              STR      r1,[r0,#8]
;;;311    }
000008  4770              BX       lr
;;;312    
                          ENDP


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

                  LTDC_ReloadConfig PROC
;;;337    
;;;338    void LTDC_ReloadConfig(uint32_t LTDC_Reload)
000000  4901              LDR      r1,|L29.8|
;;;339    {
;;;340      /* Check the parameters */
;;;341      assert_param(IS_LTDC_RELOAD(LTDC_Reload));
;;;342    
;;;343      /* Sets the Reload type */
;;;344      LTDC->SRCR = (uint32_t)LTDC_Reload;
000002  6008              STR      r0,[r1,#0]
;;;345    }
000004  4770              BX       lr
;;;346    
                          ENDP

000006  0000              DCW      0x0000
                  |L29.8|
                          DCD      0x40016824

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

                  LTDC_StructInit PROC
;;;210    
;;;211    void LTDC_StructInit(LTDC_InitTypeDef* LTDC_InitStruct)
000000  2100              MOVS     r1,#0
;;;212    {
;;;213      /*--------------- Reset LTDC init structure parameters values ----------------*/
;;;214      LTDC_InitStruct->LTDC_HSPolarity = LTDC_HSPolarity_AL;      /*!< Initialize the LTDC_HSPolarity member */ 
;;;215      LTDC_InitStruct->LTDC_VSPolarity = LTDC_VSPolarity_AL;      /*!< Initialize the LTDC_VSPolarity member */
000002  6001              STR      r1,[r0,#0]
;;;216      LTDC_InitStruct->LTDC_DEPolarity = LTDC_DEPolarity_AL;      /*!< Initialize the LTDC_DEPolarity member */
000004  6041              STR      r1,[r0,#4]
;;;217      LTDC_InitStruct->LTDC_PCPolarity = LTDC_PCPolarity_IPC;     /*!< Initialize the LTDC_PCPolarity member */
000006  6081              STR      r1,[r0,#8]
;;;218      LTDC_InitStruct->LTDC_HorizontalSync = 0x00;                /*!< Initialize the LTDC_HorizontalSync member */
000008  60c1              STR      r1,[r0,#0xc]
;;;219      LTDC_InitStruct->LTDC_VerticalSync = 0x00;                  /*!< Initialize the LTDC_VerticalSync member */
00000a  6101              STR      r1,[r0,#0x10]
;;;220      LTDC_InitStruct->LTDC_AccumulatedHBP = 0x00;                /*!< Initialize the LTDC_AccumulatedHBP member */
00000c  6141              STR      r1,[r0,#0x14]
;;;221      LTDC_InitStruct->LTDC_AccumulatedVBP = 0x00;                /*!< Initialize the LTDC_AccumulatedVBP member */
00000e  6181              STR      r1,[r0,#0x18]
;;;222      LTDC_InitStruct->LTDC_AccumulatedActiveW = 0x00;            /*!< Initialize the LTDC_AccumulatedActiveW member */
000010  61c1              STR      r1,[r0,#0x1c]
;;;223      LTDC_InitStruct->LTDC_AccumulatedActiveH = 0x00;            /*!< Initialize the LTDC_AccumulatedActiveH member */
000012  6201              STR      r1,[r0,#0x20]
;;;224      LTDC_InitStruct->LTDC_TotalWidth = 0x00;                    /*!< Initialize the LTDC_TotalWidth member */
000014  6241              STR      r1,[r0,#0x24]
;;;225      LTDC_InitStruct->LTDC_TotalHeigh = 0x00;                    /*!< Initialize the LTDC_TotalHeigh member */
000016  6281              STR      r1,[r0,#0x28]
;;;226      LTDC_InitStruct->LTDC_BackgroundRedValue = 0x00;            /*!< Initialize the LTDC_BackgroundRedValue member */
000018  62c1              STR      r1,[r0,#0x2c]
;;;227      LTDC_InitStruct->LTDC_BackgroundGreenValue = 0x00;          /*!< Initialize the LTDC_BackgroundGreenValue member */
00001a  6301              STR      r1,[r0,#0x30]
;;;228      LTDC_InitStruct->LTDC_BackgroundBlueValue = 0x00;           /*!< Initialize the LTDC_BackgroundBlueValue member */
00001c  6341              STR      r1,[r0,#0x34]
00001e  6381              STR      r1,[r0,#0x38]
;;;229    }
000020  4770              BX       lr
;;;230    
                          ENDP


;*** Start embedded assembler ***

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

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

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
