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

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

                  FLASH_ClearFlag PROC
;;;1512     */
;;;1513   void FLASH_ClearFlag(uint32_t FLASH_FLAG)
000000  4901              LDR      r1,|L1.8|
;;;1514   {
;;;1515     /* Check the parameters */
;;;1516     assert_param(IS_FLASH_CLEAR_FLAG(FLASH_FLAG));
;;;1517     
;;;1518     /* Clear the flags */
;;;1519     FLASH->SR = FLASH_FLAG;
000002  6008              STR      r0,[r1,#0]
;;;1520   }
000004  4770              BX       lr
;;;1521   
                          ENDP

000006  0000              DCW      0x0000
                  |L1.8|
                          DCD      0x40023c0c

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

                  FLASH_DataCacheCmd PROC
;;;334      */
;;;335    void FLASH_DataCacheCmd(FunctionalState NewState)
000000  4905              LDR      r1,|L2.24|
;;;336    {
;;;337      /* Check the parameters */
;;;338      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;339      
;;;340      if(NewState != DISABLE)
000002  2800              CMP      r0,#0
;;;341      {
;;;342        FLASH->ACR |= FLASH_ACR_DCEN;
;;;343      }
;;;344      else
;;;345      {
;;;346        FLASH->ACR &= (~FLASH_ACR_DCEN);
000004  6808              LDR      r0,[r1,#0]
000006  d002              BEQ      |L2.14|
000008  f4406080          ORR      r0,r0,#0x400          ;342
00000c  e001              B        |L2.18|
                  |L2.14|
00000e  f4206080          BIC      r0,r0,#0x400
                  |L2.18|
000012  6008              STR      r0,[r1,#0]            ;342
;;;347      }
;;;348    }
000014  4770              BX       lr
;;;349    
                          ENDP

000016  0000              DCW      0x0000
                  |L2.24|
                          DCD      0x40023c00

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

                  FLASH_DataCacheReset PROC
;;;366      */
;;;367    void FLASH_DataCacheReset(void)
000000  4802              LDR      r0,|L3.12|
;;;368    {
;;;369      FLASH->ACR |= FLASH_ACR_DCRST;
000002  6801              LDR      r1,[r0,#0]
000004  f4415180          ORR      r1,r1,#0x1000
000008  6001              STR      r1,[r0,#0]
;;;370    }
00000a  4770              BX       lr
;;;371    
                          ENDP

                  |L3.12|
                          DCD      0x40023c00

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

                  FLASH_EraseAllBank1Sectors PROC
;;;617      */
;;;618    FLASH_Status FLASH_EraseAllBank1Sectors(uint8_t VoltageRange)
000000  b530              PUSH     {r4,r5,lr}
;;;619    {
000002  4604              MOV      r4,r0
;;;620      uint32_t tmp_psize = 0x0;
000004  2500              MOVS     r5,#0
;;;621      FLASH_Status status = FLASH_COMPLETE;
;;;622      
;;;623      /* Wait for last operation to be completed */
;;;624      status = FLASH_WaitForLastOperation();
000006  f7fffffe          BL       FLASH_WaitForLastOperation
;;;625      assert_param(IS_VOLTAGERANGE(VoltageRange));
;;;626      
;;;627      if(VoltageRange == VoltageRange_1)
00000a  b12c              CBZ      r4,|L4.24|
;;;628      {
;;;629         tmp_psize = FLASH_PSIZE_BYTE;
;;;630      }
;;;631      else if(VoltageRange == VoltageRange_2)
00000c  2c01              CMP      r4,#1
00000e  d01c              BEQ      |L4.74|
;;;632      {
;;;633        tmp_psize = FLASH_PSIZE_HALF_WORD;
;;;634      }
;;;635      else if(VoltageRange == VoltageRange_3)
000010  2c02              CMP      r4,#2
000012  d01d              BEQ      |L4.80|
;;;636      {
;;;637        tmp_psize = FLASH_PSIZE_WORD;
;;;638      }
;;;639      else
;;;640      {
;;;641        tmp_psize = FLASH_PSIZE_DOUBLE_WORD;
000014  f44f7540          MOV      r5,#0x300
                  |L4.24|
;;;642      }  
;;;643      if(status == FLASH_COMPLETE)
000018  2809              CMP      r0,#9
00001a  d115              BNE      |L4.72|
;;;644      {
;;;645        /* if the previous operation is completed, proceed to erase all sectors */
;;;646         FLASH->CR &= CR_PSIZE_MASK;
00001c  4c0e              LDR      r4,|L4.88|
00001e  6820              LDR      r0,[r4,#0]
000020  f4207040          BIC      r0,r0,#0x300
000024  6020              STR      r0,[r4,#0]
;;;647         FLASH->CR |= tmp_psize;
000026  6820              LDR      r0,[r4,#0]
000028  4328              ORRS     r0,r0,r5
00002a  6020              STR      r0,[r4,#0]
;;;648         FLASH->CR |= FLASH_CR_MER1;
00002c  6820              LDR      r0,[r4,#0]
00002e  f0400004          ORR      r0,r0,#4
000032  6020              STR      r0,[r4,#0]
;;;649         FLASH->CR |= FLASH_CR_STRT;
000034  6820              LDR      r0,[r4,#0]
000036  f4403080          ORR      r0,r0,#0x10000
00003a  6020              STR      r0,[r4,#0]
;;;650        
;;;651        /* Wait for last operation to be completed */
;;;652        status = FLASH_WaitForLastOperation();
00003c  f7fffffe          BL       FLASH_WaitForLastOperation
;;;653    
;;;654        /* if the erase operation is completed, disable the MER Bit */
;;;655        FLASH->CR &= (~FLASH_CR_MER1);
000040  6821              LDR      r1,[r4,#0]
000042  f0210104          BIC      r1,r1,#4
000046  6021              STR      r1,[r4,#0]
                  |L4.72|
;;;656    
;;;657      }   
;;;658      /* Return the Erase Status */
;;;659      return status;
;;;660    }
000048  bd30              POP      {r4,r5,pc}
                  |L4.74|
00004a  f44f7580          MOV      r5,#0x100             ;633
00004e  e7e3              B        |L4.24|
                  |L4.80|
000050  f44f7500          MOV      r5,#0x200             ;637
000054  e7e0              B        |L4.24|
;;;661    
                          ENDP

000056  0000              DCW      0x0000
                  |L4.88|
                          DCD      0x40023c10

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

                  FLASH_EraseAllBank2Sectors PROC
;;;684      */
;;;685    FLASH_Status FLASH_EraseAllBank2Sectors(uint8_t VoltageRange)
000000  b530              PUSH     {r4,r5,lr}
;;;686    {
000002  4604              MOV      r4,r0
;;;687      uint32_t tmp_psize = 0x0;
000004  2500              MOVS     r5,#0
;;;688      FLASH_Status status = FLASH_COMPLETE;
;;;689      
;;;690      /* Wait for last operation to be completed */
;;;691      status = FLASH_WaitForLastOperation();
000006  f7fffffe          BL       FLASH_WaitForLastOperation
;;;692      assert_param(IS_VOLTAGERANGE(VoltageRange));
;;;693      
;;;694      if(VoltageRange == VoltageRange_1)
00000a  b12c              CBZ      r4,|L5.24|
;;;695      {
;;;696         tmp_psize = FLASH_PSIZE_BYTE;
;;;697      }
;;;698      else if(VoltageRange == VoltageRange_2)
00000c  2c01              CMP      r4,#1
00000e  d01c              BEQ      |L5.74|
;;;699      {
;;;700        tmp_psize = FLASH_PSIZE_HALF_WORD;
;;;701      }
;;;702      else if(VoltageRange == VoltageRange_3)
000010  2c02              CMP      r4,#2
000012  d01d              BEQ      |L5.80|
;;;703      {
;;;704        tmp_psize = FLASH_PSIZE_WORD;
;;;705      }
;;;706      else
;;;707      {
;;;708        tmp_psize = FLASH_PSIZE_DOUBLE_WORD;
000014  f44f7540          MOV      r5,#0x300
                  |L5.24|
;;;709      }  
;;;710      if(status == FLASH_COMPLETE)
000018  2809              CMP      r0,#9
00001a  d115              BNE      |L5.72|
;;;711      {
;;;712        /* if the previous operation is completed, proceed to erase all sectors */
;;;713         FLASH->CR &= CR_PSIZE_MASK;
00001c  4c0e              LDR      r4,|L5.88|
00001e  6820              LDR      r0,[r4,#0]
000020  f4207040          BIC      r0,r0,#0x300
000024  6020              STR      r0,[r4,#0]
;;;714         FLASH->CR |= tmp_psize;
000026  6820              LDR      r0,[r4,#0]
000028  4328              ORRS     r0,r0,r5
00002a  6020              STR      r0,[r4,#0]
;;;715         FLASH->CR |= FLASH_CR_MER2;
00002c  6820              LDR      r0,[r4,#0]
00002e  f4404000          ORR      r0,r0,#0x8000
000032  6020              STR      r0,[r4,#0]
;;;716         FLASH->CR |= FLASH_CR_STRT;
000034  6820              LDR      r0,[r4,#0]
000036  f4403080          ORR      r0,r0,#0x10000
00003a  6020              STR      r0,[r4,#0]
;;;717        
;;;718        /* Wait for last operation to be completed */
;;;719        status = FLASH_WaitForLastOperation();
00003c  f7fffffe          BL       FLASH_WaitForLastOperation
;;;720    
;;;721        /* if the erase operation is completed, disable the MER Bit */
;;;722        FLASH->CR &= (~FLASH_CR_MER2);
000040  6821              LDR      r1,[r4,#0]
000042  f4214100          BIC      r1,r1,#0x8000
000046  6021              STR      r1,[r4,#0]
                  |L5.72|
;;;723    
;;;724      }   
;;;725      /* Return the Erase Status */
;;;726      return status;
;;;727    }
000048  bd30              POP      {r4,r5,pc}
                  |L5.74|
00004a  f44f7580          MOV      r5,#0x100             ;700
00004e  e7e3              B        |L5.24|
                  |L5.80|
000050  f44f7500          MOV      r5,#0x200             ;704
000054  e7e0              B        |L5.24|
;;;728    
                          ENDP

000056  0000              DCW      0x0000
                  |L5.88|
                          DCD      0x40023c10

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

                  FLASH_EraseAllSectors PROC
;;;536      */
;;;537    FLASH_Status FLASH_EraseAllSectors(uint8_t VoltageRange)
000000  b530              PUSH     {r4,r5,lr}
;;;538    {
000002  4604              MOV      r4,r0
;;;539      uint32_t tmp_psize = 0x0;
000004  2500              MOVS     r5,#0
;;;540      FLASH_Status status = FLASH_COMPLETE;
;;;541      
;;;542      /* Wait for last operation to be completed */
;;;543      status = FLASH_WaitForLastOperation();
000006  f7fffffe          BL       FLASH_WaitForLastOperation
;;;544      assert_param(IS_VOLTAGERANGE(VoltageRange));
;;;545      
;;;546      if(VoltageRange == VoltageRange_1)
00000a  b12c              CBZ      r4,|L6.24|
;;;547      {
;;;548         tmp_psize = FLASH_PSIZE_BYTE;
;;;549      }
;;;550      else if(VoltageRange == VoltageRange_2)
00000c  2c01              CMP      r4,#1
00000e  d01b              BEQ      |L6.72|
;;;551      {
;;;552        tmp_psize = FLASH_PSIZE_HALF_WORD;
;;;553      }
;;;554      else if(VoltageRange == VoltageRange_3)
000010  2c02              CMP      r4,#2
000012  d01c              BEQ      |L6.78|
;;;555      {
;;;556        tmp_psize = FLASH_PSIZE_WORD;
;;;557      }
;;;558      else
;;;559      {
;;;560        tmp_psize = FLASH_PSIZE_DOUBLE_WORD;
000014  f44f7540          MOV      r5,#0x300
                  |L6.24|
;;;561      }  
;;;562      if(status == FLASH_COMPLETE)
000018  2809              CMP      r0,#9
00001a  d114              BNE      |L6.70|
;;;563      {
;;;564        /* if the previous operation is completed, proceed to erase all sectors */
;;;565    #if defined (STM32F427_437xx) || defined (STM32F429_439xx)    
;;;566        FLASH->CR &= CR_PSIZE_MASK;
00001c  4c0d              LDR      r4,|L6.84|
00001e  6820              LDR      r0,[r4,#0]
000020  f4207040          BIC      r0,r0,#0x300
000024  6020              STR      r0,[r4,#0]
;;;567        FLASH->CR |= tmp_psize;
000026  6820              LDR      r0,[r4,#0]
000028  4328              ORRS     r0,r0,r5
00002a  6020              STR      r0,[r4,#0]
;;;568        FLASH->CR |= (FLASH_CR_MER1 | FLASH_CR_MER2);
00002c  6820              LDR      r0,[r4,#0]
00002e  13e5              ASRS     r5,r4,#15
000030  4328              ORRS     r0,r0,r5
000032  6020              STR      r0,[r4,#0]
;;;569        FLASH->CR |= FLASH_CR_STRT;
000034  6820              LDR      r0,[r4,#0]
000036  f4403080          ORR      r0,r0,#0x10000
00003a  6020              STR      r0,[r4,#0]
;;;570        
;;;571        /* Wait for last operation to be completed */
;;;572        status = FLASH_WaitForLastOperation();
00003c  f7fffffe          BL       FLASH_WaitForLastOperation
;;;573    
;;;574        /* if the erase operation is completed, disable the MER Bit */
;;;575        FLASH->CR &= ~(FLASH_CR_MER1 | FLASH_CR_MER2);
000040  6821              LDR      r1,[r4,#0]
000042  43a9              BICS     r1,r1,r5
000044  6021              STR      r1,[r4,#0]
                  |L6.70|
;;;576    #endif /* STM32F427_437xx ||  STM32F429_439xx */
;;;577    
;;;578    #if defined (STM32F40_41xxx) || defined (STM32F401xx) || defined (STM32F411xE) 
;;;579        FLASH->CR &= CR_PSIZE_MASK;
;;;580        FLASH->CR |= tmp_psize;
;;;581        FLASH->CR |= FLASH_CR_MER;
;;;582        FLASH->CR |= FLASH_CR_STRT;
;;;583        
;;;584        /* Wait for last operation to be completed */
;;;585        status = FLASH_WaitForLastOperation();
;;;586    
;;;587        /* if the erase operation is completed, disable the MER Bit */
;;;588        FLASH->CR &= (~FLASH_CR_MER);
;;;589    #endif /* STM32F40_41xxx || STM32F401xx || STM32F411xE */
;;;590    
;;;591      }   
;;;592      /* Return the Erase Status */
;;;593      return status;
;;;594    }
000046  bd30              POP      {r4,r5,pc}
                  |L6.72|
000048  f44f7580          MOV      r5,#0x100             ;552
00004c  e7e4              B        |L6.24|
                  |L6.78|
00004e  f44f7500          MOV      r5,#0x200             ;556
000052  e7e1              B        |L6.24|
;;;595    
                          ENDP

                  |L6.84|
                          DCD      0x40023c10

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

                  FLASH_EraseSector PROC
;;;468      */
;;;469    FLASH_Status FLASH_EraseSector(uint32_t FLASH_Sector, uint8_t VoltageRange)
000000  b570              PUSH     {r4-r6,lr}
;;;470    {
000002  4606              MOV      r6,r0
;;;471      uint32_t tmp_psize = 0x0;
000004  2500              MOVS     r5,#0
000006  b129              CBZ      r1,|L7.20|
;;;472      FLASH_Status status = FLASH_COMPLETE;
;;;473    
;;;474      /* Check the parameters */
;;;475      assert_param(IS_FLASH_SECTOR(FLASH_Sector));
;;;476      assert_param(IS_VOLTAGERANGE(VoltageRange));
;;;477      
;;;478      if(VoltageRange == VoltageRange_1)
;;;479      {
;;;480         tmp_psize = FLASH_PSIZE_BYTE;
;;;481      }
;;;482      else if(VoltageRange == VoltageRange_2)
000008  2901              CMP      r1,#1
00000a  d027              BEQ      |L7.92|
;;;483      {
;;;484        tmp_psize = FLASH_PSIZE_HALF_WORD;
;;;485      }
;;;486      else if(VoltageRange == VoltageRange_3)
00000c  2902              CMP      r1,#2
00000e  d028              BEQ      |L7.98|
;;;487      {
;;;488        tmp_psize = FLASH_PSIZE_WORD;
;;;489      }
;;;490      else
;;;491      {
;;;492        tmp_psize = FLASH_PSIZE_DOUBLE_WORD;
000010  f44f7540          MOV      r5,#0x300
                  |L7.20|
;;;493      }
;;;494      /* Wait for last operation to be completed */
;;;495      status = FLASH_WaitForLastOperation();
000014  f7fffffe          BL       FLASH_WaitForLastOperation
;;;496      
;;;497      if(status == FLASH_COMPLETE)
000018  2809              CMP      r0,#9
00001a  d11e              BNE      |L7.90|
;;;498      { 
;;;499        /* if the previous operation is completed, proceed to erase the sector */
;;;500        FLASH->CR &= CR_PSIZE_MASK;
00001c  4c12              LDR      r4,|L7.104|
00001e  6820              LDR      r0,[r4,#0]
000020  f4207040          BIC      r0,r0,#0x300
000024  6020              STR      r0,[r4,#0]
;;;501        FLASH->CR |= tmp_psize;
000026  6820              LDR      r0,[r4,#0]
000028  4328              ORRS     r0,r0,r5
00002a  6020              STR      r0,[r4,#0]
;;;502        FLASH->CR &= SECTOR_MASK;
00002c  6820              LDR      r0,[r4,#0]
00002e  f02000f8          BIC      r0,r0,#0xf8
000032  6020              STR      r0,[r4,#0]
;;;503        FLASH->CR |= FLASH_CR_SER | FLASH_Sector;
000034  6820              LDR      r0,[r4,#0]
000036  f0460102          ORR      r1,r6,#2
00003a  4308              ORRS     r0,r0,r1
00003c  6020              STR      r0,[r4,#0]
;;;504        FLASH->CR |= FLASH_CR_STRT;
00003e  6820              LDR      r0,[r4,#0]
000040  f4403080          ORR      r0,r0,#0x10000
000044  6020              STR      r0,[r4,#0]
;;;505        
;;;506        /* Wait for last operation to be completed */
;;;507        status = FLASH_WaitForLastOperation();
000046  f7fffffe          BL       FLASH_WaitForLastOperation
;;;508        
;;;509        /* if the erase operation is completed, disable the SER Bit */
;;;510        FLASH->CR &= (~FLASH_CR_SER);
00004a  6821              LDR      r1,[r4,#0]
00004c  f0210102          BIC      r1,r1,#2
000050  6021              STR      r1,[r4,#0]
;;;511        FLASH->CR &= SECTOR_MASK; 
000052  6821              LDR      r1,[r4,#0]
000054  f02101f8          BIC      r1,r1,#0xf8
000058  6021              STR      r1,[r4,#0]
                  |L7.90|
;;;512      }
;;;513      /* Return the Erase Status */
;;;514      return status;
;;;515    }
00005a  bd70              POP      {r4-r6,pc}
                  |L7.92|
00005c  f44f7580          MOV      r5,#0x100             ;484
000060  e7d8              B        |L7.20|
                  |L7.98|
000062  f44f7500          MOV      r5,#0x200             ;488
000066  e7d5              B        |L7.20|
;;;516    
                          ENDP

                  |L7.104|
                          DCD      0x40023c10

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

                  FLASH_GetFlagStatus PROC
;;;1481     */
;;;1482   FlagStatus FLASH_GetFlagStatus(uint32_t FLASH_FLAG)
000000  4a03              LDR      r2,|L8.16|
;;;1483   {
000002  4601              MOV      r1,r0
;;;1484     FlagStatus bitstatus = RESET;
000004  2000              MOVS     r0,#0
;;;1485     /* Check the parameters */
;;;1486     assert_param(IS_FLASH_GET_FLAG(FLASH_FLAG));
;;;1487   
;;;1488     if((FLASH->SR & FLASH_FLAG) != (uint32_t)RESET)
000006  6812              LDR      r2,[r2,#0]
000008  420a              TST      r2,r1
00000a  d000              BEQ      |L8.14|
;;;1489     {
;;;1490       bitstatus = SET;
00000c  2001              MOVS     r0,#1
                  |L8.14|
;;;1491     }
;;;1492     else
;;;1493     {
;;;1494       bitstatus = RESET;
;;;1495     }
;;;1496     /* Return the new state of FLASH_FLAG (SET or RESET) */
;;;1497     return bitstatus; 
;;;1498   }
00000e  4770              BX       lr
;;;1499   
                          ENDP

                  |L8.16|
                          DCD      0x40023c0c

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

                  FLASH_GetStatus PROC
;;;1527     */
;;;1528   FLASH_Status FLASH_GetStatus(void)
000000  490d              LDR      r1,|L9.56|
;;;1529   {
;;;1530     FLASH_Status flashstatus = FLASH_COMPLETE;
000002  2009              MOVS     r0,#9
;;;1531     
;;;1532     if((FLASH->SR & FLASH_FLAG_BSY) == FLASH_FLAG_BSY) 
000004  680a              LDR      r2,[r1,#0]
000006  03d2              LSLS     r2,r2,#15
000008  d501              BPL      |L9.14|
;;;1533     {
;;;1534       flashstatus = FLASH_BUSY;
00000a  2001              MOVS     r0,#1
;;;1535     }
;;;1536     else 
;;;1537     {  
;;;1538       if((FLASH->SR & FLASH_FLAG_WRPERR) != (uint32_t)0x00)
;;;1539       { 
;;;1540         flashstatus = FLASH_ERROR_WRP;
;;;1541       }
;;;1542       else
;;;1543       {
;;;1544         if((FLASH->SR & FLASH_FLAG_RDERR) != (uint32_t)0x00)
;;;1545         { 
;;;1546           flashstatus = FLASH_ERROR_RD;
;;;1547         } 
;;;1548         else 
;;;1549         {
;;;1550           if((FLASH->SR & (uint32_t)0xEF) != (uint32_t)0x00)
;;;1551           {
;;;1552             flashstatus = FLASH_ERROR_PROGRAM; 
;;;1553           }
;;;1554           else
;;;1555           {
;;;1556             if((FLASH->SR & FLASH_FLAG_OPERR) != (uint32_t)0x00)
;;;1557             {
;;;1558               flashstatus = FLASH_ERROR_OPERATION;
;;;1559             }
;;;1560             else
;;;1561             {
;;;1562               flashstatus = FLASH_COMPLETE;
;;;1563             }
;;;1564           }
;;;1565         }
;;;1566       }
;;;1567     }
;;;1568     /* Return the FLASH Status */
;;;1569     return flashstatus;
;;;1570   }
00000c  4770              BX       lr
                  |L9.14|
00000e  680a              LDR      r2,[r1,#0]            ;1538
000010  06d2              LSLS     r2,r2,#27             ;1538
000012  d501              BPL      |L9.24|
000014  2006              MOVS     r0,#6                 ;1540
000016  4770              BX       lr
                  |L9.24|
000018  680a              LDR      r2,[r1,#0]            ;1544
00001a  05d2              LSLS     r2,r2,#23             ;1544
00001c  d501              BPL      |L9.34|
00001e  2002              MOVS     r0,#2                 ;1546
000020  4770              BX       lr
                  |L9.34|
000022  680a              LDR      r2,[r1,#0]            ;1550
000024  f0120fef          TST      r2,#0xef              ;1550
000028  d001              BEQ      |L9.46|
00002a  2007              MOVS     r0,#7                 ;1552
                  |L9.44|
00002c  4770              BX       lr
                  |L9.46|
00002e  6809              LDR      r1,[r1,#0]            ;1556
000030  0789              LSLS     r1,r1,#30             ;1556
000032  d5fb              BPL      |L9.44|
000034  2008              MOVS     r0,#8                 ;1558
000036  4770              BX       lr
;;;1571   
                          ENDP

                  |L9.56|
                          DCD      0x40023c0c

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

                  FLASH_ITConfig PROC
;;;1449     */
;;;1450   void FLASH_ITConfig(uint32_t FLASH_IT, FunctionalState NewState)
000000  4a04              LDR      r2,|L10.20|
;;;1451   {
;;;1452     /* Check the parameters */
;;;1453     assert_param(IS_FLASH_IT(FLASH_IT)); 
;;;1454     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1455   
;;;1456     if(NewState != DISABLE)
000002  2900              CMP      r1,#0
;;;1457     {
;;;1458       /* Enable the interrupt sources */
;;;1459       FLASH->CR |= FLASH_IT;
;;;1460     }
;;;1461     else
;;;1462     {
;;;1463       /* Disable the interrupt sources */
;;;1464       FLASH->CR &= ~(uint32_t)FLASH_IT;
000004  6811              LDR      r1,[r2,#0]
000006  d001              BEQ      |L10.12|
000008  4301              ORRS     r1,r1,r0              ;1459
00000a  e000              B        |L10.14|
                  |L10.12|
00000c  4381              BICS     r1,r1,r0
                  |L10.14|
00000e  6011              STR      r1,[r2,#0]            ;1459
;;;1465     }
;;;1466   }
000010  4770              BX       lr
;;;1467   
                          ENDP

000012  0000              DCW      0x0000
                  |L10.20|
                          DCD      0x40023c10

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

                  FLASH_InstructionCacheCmd PROC
;;;313      */
;;;314    void FLASH_InstructionCacheCmd(FunctionalState NewState)
000000  4905              LDR      r1,|L11.24|
;;;315    {
;;;316      /* Check the parameters */
;;;317      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;318      
;;;319      if(NewState != DISABLE)
000002  2800              CMP      r0,#0
;;;320      {
;;;321        FLASH->ACR |= FLASH_ACR_ICEN;
;;;322      }
;;;323      else
;;;324      {
;;;325        FLASH->ACR &= (~FLASH_ACR_ICEN);
000004  6808              LDR      r0,[r1,#0]
000006  d002              BEQ      |L11.14|
000008  f4407000          ORR      r0,r0,#0x200          ;321
00000c  e001              B        |L11.18|
                  |L11.14|
00000e  f4207000          BIC      r0,r0,#0x200
                  |L11.18|
000012  6008              STR      r0,[r1,#0]            ;321
;;;326      }
;;;327    }
000014  4770              BX       lr
;;;328    
                          ENDP

000016  0000              DCW      0x0000
                  |L11.24|
                          DCD      0x40023c00

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

                  FLASH_InstructionCacheReset PROC
;;;355      */
;;;356    void FLASH_InstructionCacheReset(void)
000000  4802              LDR      r0,|L12.12|
;;;357    {
;;;358      FLASH->ACR |= FLASH_ACR_ICRST;
000002  6801              LDR      r1,[r0,#0]
000004  f4416100          ORR      r1,r1,#0x800
000008  6001              STR      r1,[r0,#0]
;;;359    }
00000a  4770              BX       lr
;;;360    
                          ENDP

                  |L12.12|
                          DCD      0x40023c00

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

                  FLASH_Lock PROC
;;;428      */
;;;429    void FLASH_Lock(void)
000000  4802              LDR      r0,|L13.12|
;;;430    {
;;;431      /* Set the LOCK Bit to lock the FLASH Registers access */
;;;432      FLASH->CR |= FLASH_CR_LOCK;
000002  6801              LDR      r1,[r0,#0]
000004  f0414100          ORR      r1,r1,#0x80000000
000008  6001              STR      r1,[r0,#0]
;;;433    }
00000a  4770              BX       lr
;;;434    
                          ENDP

                  |L13.12|
                          DCD      0x40023c10

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

                  FLASH_OB_BORConfig PROC
;;;1294     */
;;;1295   void FLASH_OB_BORConfig(uint8_t OB_BOR)
000000  4904              LDR      r1,|L14.20|
;;;1296   {
;;;1297     /* Check the parameters */
;;;1298     assert_param(IS_OB_BOR(OB_BOR));
;;;1299   
;;;1300     /* Set the BOR Level */
;;;1301     *(__IO uint8_t *)OPTCR_BYTE0_ADDRESS &= (~FLASH_OPTCR_BOR_LEV);
000002  780a              LDRB     r2,[r1,#0]
000004  f022020c          BIC      r2,r2,#0xc
000008  700a              STRB     r2,[r1,#0]
;;;1302     *(__IO uint8_t *)OPTCR_BYTE0_ADDRESS |= OB_BOR;
00000a  780a              LDRB     r2,[r1,#0]
00000c  4302              ORRS     r2,r2,r0
00000e  700a              STRB     r2,[r1,#0]
;;;1303   
;;;1304   }
000010  4770              BX       lr
;;;1305   
                          ENDP

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

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

                  FLASH_OB_BootConfig PROC
;;;1273     */
;;;1274   void FLASH_OB_BootConfig(uint8_t OB_BOOT)
000000  4904              LDR      r1,|L15.20|
;;;1275   {
;;;1276     /* Check the parameters */
;;;1277     assert_param(IS_OB_BOOT(OB_BOOT));
;;;1278   
;;;1279     /* Set Dual Bank Boot */
;;;1280     *(__IO uint8_t *)OPTCR_BYTE0_ADDRESS &= (~FLASH_OPTCR_BFB2);
000002  780a              LDRB     r2,[r1,#0]
000004  f0220210          BIC      r2,r2,#0x10
000008  700a              STRB     r2,[r1,#0]
;;;1281     *(__IO uint8_t *)OPTCR_BYTE0_ADDRESS |= OB_BOOT;
00000a  780a              LDRB     r2,[r1,#0]
00000c  4302              ORRS     r2,r2,r0
00000e  700a              STRB     r2,[r1,#0]
;;;1282   
;;;1283   }
000010  4770              BX       lr
;;;1284   
                          ENDP

000012  0000              DCW      0x0000
                  |L15.20|
                          DCD      0x40023c14

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

                  FLASH_OB_GetBOR PROC
;;;1420     */
;;;1421   uint8_t FLASH_OB_GetBOR(void)
000000  4802              LDR      r0,|L16.12|
;;;1422   {
;;;1423     /* Return the FLASH BOR level */
;;;1424     return (uint8_t)(*(__IO uint8_t *)(OPTCR_BYTE0_ADDRESS) & (uint8_t)0x0C);
000002  7800              LDRB     r0,[r0,#0]
000004  f000000c          AND      r0,r0,#0xc
;;;1425   }
000008  4770              BX       lr
;;;1426   
                          ENDP

00000a  0000              DCW      0x0000
                  |L16.12|
                          DCD      0x40023c14

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

                  FLASH_OB_GetPCROP PROC
;;;1369     */
;;;1370   uint16_t FLASH_OB_GetPCROP(void)
000000  4801              LDR      r0,|L17.8|
;;;1371   {
;;;1372     /* Return the FLASH PC Read/write protection Register value */
;;;1373     return (*(__IO uint16_t *)(OPTCR_BYTE2_ADDRESS));
000002  8800              LDRH     r0,[r0,#0]
;;;1374   }
000004  4770              BX       lr
;;;1375   
                          ENDP

000006  0000              DCW      0x0000
                  |L17.8|
                          DCD      0x40023c16

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

                  FLASH_OB_GetPCROP1 PROC
;;;1383     */
;;;1384   uint16_t FLASH_OB_GetPCROP1(void)
000000  4801              LDR      r0,|L18.8|
;;;1385   {
;;;1386     /* Return the FLASH write protection Register value */
;;;1387     return (*(__IO uint16_t *)(OPTCR1_BYTE2_ADDRESS));
000002  8800              LDRH     r0,[r0,#0]
;;;1388   }
000004  4770              BX       lr
;;;1389   
                          ENDP

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

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

                  FLASH_OB_GetRDP PROC
;;;1396     */
;;;1397   FlagStatus FLASH_OB_GetRDP(void)
000000  4903              LDR      r1,|L19.16|
;;;1398   {
;;;1399     FlagStatus readstatus = RESET;
000002  2000              MOVS     r0,#0
;;;1400   
;;;1401     if ((*(__IO uint8_t*)(OPTCR_BYTE1_ADDRESS) != (uint8_t)OB_RDP_Level_0))
000004  7809              LDRB     r1,[r1,#0]
000006  29aa              CMP      r1,#0xaa
000008  d000              BEQ      |L19.12|
;;;1402     {
;;;1403       readstatus = SET;
00000a  2001              MOVS     r0,#1
                  |L19.12|
;;;1404     }
;;;1405     else
;;;1406     {
;;;1407       readstatus = RESET;
;;;1408     }
;;;1409     return readstatus;
;;;1410   }
00000c  4770              BX       lr
;;;1411   
                          ENDP

00000e  0000              DCW      0x0000
                  |L19.16|
                          DCD      0x40023c15

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

                  FLASH_OB_GetUser PROC
;;;1330     */
;;;1331   uint8_t FLASH_OB_GetUser(void)
000000  4802              LDR      r0,|L20.12|
;;;1332   {
;;;1333     /* Return the User Option Byte */
;;;1334     return (uint8_t)(FLASH->OPTCR >> 5);
000002  6800              LDR      r0,[r0,#0]
000004  f3c01047          UBFX     r0,r0,#5,#8
;;;1335   }
000008  4770              BX       lr
;;;1336   
                          ENDP

00000a  0000              DCW      0x0000
                  |L20.12|
                          DCD      0x40023c14

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

                  FLASH_OB_GetWRP PROC
;;;1341     */
;;;1342   uint16_t FLASH_OB_GetWRP(void)
000000  4801              LDR      r0,|L21.8|
;;;1343   {
;;;1344     /* Return the FLASH write protection Register value */
;;;1345     return (*(__IO uint16_t *)(OPTCR_BYTE2_ADDRESS));
000002  8800              LDRH     r0,[r0,#0]
;;;1346   }
000004  4770              BX       lr
;;;1347   
                          ENDP

000006  0000              DCW      0x0000
                  |L21.8|
                          DCD      0x40023c16

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

                  FLASH_OB_GetWRP1 PROC
;;;1355     */
;;;1356   uint16_t FLASH_OB_GetWRP1(void)
000000  4801              LDR      r0,|L22.8|
;;;1357   {
;;;1358     /* Return the FLASH write protection Register value */
;;;1359     return (*(__IO uint16_t *)(OPTCR1_BYTE2_ADDRESS));
000002  8800              LDRH     r0,[r0,#0]
;;;1360   }
000004  4770              BX       lr
;;;1361   
                          ENDP

000006  0000              DCW      0x0000
                  |L22.8|
                          DCD      0x40023c1a

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

                  FLASH_OB_Launch PROC
;;;1311     */
;;;1312   FLASH_Status FLASH_OB_Launch(void)
000000  4803              LDR      r0,|L23.16|
;;;1313   {
;;;1314     FLASH_Status status = FLASH_COMPLETE;
;;;1315   
;;;1316     /* Set the OPTSTRT bit in OPTCR register */
;;;1317     *(__IO uint8_t *)OPTCR_BYTE0_ADDRESS |= FLASH_OPTCR_OPTSTRT;
000002  7801              LDRB     r1,[r0,#0]
000004  f0410102          ORR      r1,r1,#2
000008  7001              STRB     r1,[r0,#0]
;;;1318   
;;;1319     /* Wait for last operation to be completed */
;;;1320     status = FLASH_WaitForLastOperation();
00000a  f7ffbffe          B.W      FLASH_WaitForLastOperation
;;;1321   
;;;1322     return status;
;;;1323   }
;;;1324   
                          ENDP

00000e  0000              DCW      0x0000
                  |L23.16|
                          DCD      0x40023c14

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

                  FLASH_OB_Lock PROC
;;;982      */
;;;983    void FLASH_OB_Lock(void)
000000  4802              LDR      r0,|L24.12|
;;;984    {
;;;985      /* Set the OPTLOCK Bit to lock the FLASH Option Byte Registers access */
;;;986      FLASH->OPTCR |= FLASH_OPTCR_OPTLOCK;
000002  6801              LDR      r1,[r0,#0]
000004  f0410101          ORR      r1,r1,#1
000008  6001              STR      r1,[r0,#0]
;;;987    }
00000a  4770              BX       lr
;;;988    
                          ENDP

                  |L24.12|
                          DCD      0x40023c14

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

                  FLASH_OB_PCROP1Config PROC
;;;1164     */
;;;1165   void FLASH_OB_PCROP1Config(uint32_t OB_PCROP, FunctionalState NewState)
000000  b530              PUSH     {r4,r5,lr}
;;;1166   { 
000002  460d              MOV      r5,r1
000004  4604              MOV      r4,r0
;;;1167     FLASH_Status status = FLASH_COMPLETE;
;;;1168     
;;;1169     /* Check the parameters */
;;;1170     assert_param(IS_OB_PCROP(OB_PCROP));
;;;1171     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1172       
;;;1173     status = FLASH_WaitForLastOperation();
000006  f7fffffe          BL       FLASH_WaitForLastOperation
;;;1174   
;;;1175     if(status == FLASH_COMPLETE)
00000a  2809              CMP      r0,#9
00000c  d106              BNE      |L25.28|
;;;1176     { 
;;;1177       if(NewState != DISABLE)
;;;1178       {
;;;1179         *(__IO uint16_t*)OPTCR1_BYTE2_ADDRESS |= (uint16_t)OB_PCROP;
00000e  4804              LDR      r0,|L25.32|
;;;1180       }
;;;1181       else
;;;1182       {
;;;1183         *(__IO uint16_t*)OPTCR1_BYTE2_ADDRESS &= (~OB_PCROP);
000010  8801              LDRH     r1,[r0,#0]
000012  b10d              CBZ      r5,|L25.24|
000014  4321              ORRS     r1,r1,r4              ;1179
000016  e000              B        |L25.26|
                  |L25.24|
000018  43a1              BICS     r1,r1,r4
                  |L25.26|
00001a  8001              STRH     r1,[r0,#0]
                  |L25.28|
;;;1184       }
;;;1185     }
;;;1186   }
00001c  bd30              POP      {r4,r5,pc}
;;;1187   
                          ENDP

00001e  0000              DCW      0x0000
                  |L25.32|
                          DCD      0x40023c1a

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

                  FLASH_OB_PCROPConfig PROC
;;;1127     */
;;;1128   void FLASH_OB_PCROPConfig(uint32_t OB_PCROP, FunctionalState NewState)
000000  b530              PUSH     {r4,r5,lr}
;;;1129   { 
000002  460d              MOV      r5,r1
000004  4604              MOV      r4,r0
;;;1130     FLASH_Status status = FLASH_COMPLETE;
;;;1131     
;;;1132     /* Check the parameters */
;;;1133     assert_param(IS_OB_PCROP(OB_PCROP));
;;;1134     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1135       
;;;1136     status = FLASH_WaitForLastOperation();
000006  f7fffffe          BL       FLASH_WaitForLastOperation
;;;1137   
;;;1138     if(status == FLASH_COMPLETE)
00000a  2809              CMP      r0,#9
00000c  d106              BNE      |L26.28|
;;;1139     { 
;;;1140       if(NewState != DISABLE)
;;;1141       {
;;;1142         *(__IO uint16_t*)OPTCR_BYTE2_ADDRESS |= (uint16_t)OB_PCROP;    
00000e  4804              LDR      r0,|L26.32|
;;;1143       }
;;;1144       else
;;;1145       {
;;;1146         *(__IO uint16_t*)OPTCR_BYTE2_ADDRESS &= (~OB_PCROP);
000010  8801              LDRH     r1,[r0,#0]
000012  b10d              CBZ      r5,|L26.24|
000014  4321              ORRS     r1,r1,r4              ;1142
000016  e000              B        |L26.26|
                  |L26.24|
000018  43a1              BICS     r1,r1,r4
                  |L26.26|
00001a  8001              STRH     r1,[r0,#0]
                  |L26.28|
;;;1147       }
;;;1148     }
;;;1149   }
00001c  bd30              POP      {r4,r5,pc}
;;;1150   
                          ENDP

00001e  0000              DCW      0x0000
                  |L26.32|
                          DCD      0x40023c16

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

                  FLASH_OB_PCROPSelectionConfig PROC
;;;1097     */
;;;1098   void FLASH_OB_PCROPSelectionConfig(uint8_t OB_PcROP)
000000  4a03              LDR      r2,|L27.16|
;;;1099   {  
;;;1100     uint8_t optiontmp = 0xFF;
;;;1101         
;;;1102     /* Check the parameters */
;;;1103     assert_param(IS_OB_PCROP_SELECT(OB_PcROP));
;;;1104     
;;;1105     /* Mask SPRMOD bit */
;;;1106     optiontmp =  (uint8_t)((*(__IO uint8_t *)OPTCR_BYTE3_ADDRESS) & (uint8_t)0x7F); 
000002  7811              LDRB     r1,[r2,#0]
000004  f001017f          AND      r1,r1,#0x7f
;;;1107     /* Update Option Byte */
;;;1108     *(__IO uint8_t *)OPTCR_BYTE3_ADDRESS = (uint8_t)(OB_PcROP | optiontmp); 
000008  4308              ORRS     r0,r0,r1
00000a  7010              STRB     r0,[r2,#0]
;;;1109       
;;;1110   }
00000c  4770              BX       lr
;;;1111   
                          ENDP

00000e  0000              DCW      0x0000
                  |L27.16|
                          DCD      0x40023c17

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

                  FLASH_OB_RDPConfig PROC
;;;1200     */
;;;1201   void FLASH_OB_RDPConfig(uint8_t OB_RDP)
000000  b510              PUSH     {r4,lr}
;;;1202   {
000002  4604              MOV      r4,r0
;;;1203     FLASH_Status status = FLASH_COMPLETE;
;;;1204   
;;;1205     /* Check the parameters */
;;;1206     assert_param(IS_OB_RDP(OB_RDP));
;;;1207   
;;;1208     status = FLASH_WaitForLastOperation();
000004  f7fffffe          BL       FLASH_WaitForLastOperation
;;;1209   
;;;1210     if(status == FLASH_COMPLETE)
000008  2809              CMP      r0,#9
00000a  d101              BNE      |L28.16|
;;;1211     {
;;;1212       *(__IO uint8_t*)OPTCR_BYTE1_ADDRESS = OB_RDP;
00000c  4801              LDR      r0,|L28.20|
00000e  7004              STRB     r4,[r0,#0]
                  |L28.16|
;;;1213   
;;;1214     }
;;;1215   }
000010  bd10              POP      {r4,pc}
;;;1216   
                          ENDP

000012  0000              DCW      0x0000
                  |L28.20|
                          DCD      0x40023c15

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

                  FLASH_OB_Unlock PROC
;;;967      */
;;;968    void FLASH_OB_Unlock(void)
000000  4805              LDR      r0,|L29.24|
;;;969    {
;;;970      if((FLASH->OPTCR & FLASH_OPTCR_OPTLOCK) != RESET)
000002  6800              LDR      r0,[r0,#0]
000004  07c0              LSLS     r0,r0,#31
000006  d005              BEQ      |L29.20|
;;;971      {
;;;972        /* Authorizes the Option Byte register programming */
;;;973        FLASH->OPTKEYR = FLASH_OPT_KEY1;
000008  4803              LDR      r0,|L29.24|
00000a  4904              LDR      r1,|L29.28|
00000c  380c              SUBS     r0,r0,#0xc
00000e  6001              STR      r1,[r0,#0]
;;;974        FLASH->OPTKEYR = FLASH_OPT_KEY2;
000010  4903              LDR      r1,|L29.32|
000012  6001              STR      r1,[r0,#0]
                  |L29.20|
;;;975      }  
;;;976    }
000014  4770              BX       lr
;;;977    
                          ENDP

000016  0000              DCW      0x0000
                  |L29.24|
                          DCD      0x40023c14
                  |L29.28|
                          DCD      0x08192a3b
                  |L29.32|
                          DCD      0x4c5d6e7f

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

                  FLASH_OB_UserConfig PROC
;;;1232     */
;;;1233   void FLASH_OB_UserConfig(uint8_t OB_IWDG, uint8_t OB_STOP, uint8_t OB_STDBY)
000000  b570              PUSH     {r4-r6,lr}
;;;1234   {
000002  4615              MOV      r5,r2
000004  460c              MOV      r4,r1
000006  4606              MOV      r6,r0
;;;1235     uint8_t optiontmp = 0xFF;
;;;1236     FLASH_Status status = FLASH_COMPLETE; 
;;;1237   
;;;1238     /* Check the parameters */
;;;1239     assert_param(IS_OB_IWDG_SOURCE(OB_IWDG));
;;;1240     assert_param(IS_OB_STOP_SOURCE(OB_STOP));
;;;1241     assert_param(IS_OB_STDBY_SOURCE(OB_STDBY));
;;;1242   
;;;1243     /* Wait for last operation to be completed */
;;;1244     status = FLASH_WaitForLastOperation();
000008  f7fffffe          BL       FLASH_WaitForLastOperation
;;;1245     
;;;1246     if(status == FLASH_COMPLETE)
00000c  2809              CMP      r0,#9
00000e  d107              BNE      |L30.32|
;;;1247     { 
;;;1248   #if defined (STM32F427_437xx) || defined (STM32F429_439xx)
;;;1249       /* Mask OPTLOCK, OPTSTRT, BOR_LEV and BFB2 bits */
;;;1250       optiontmp =  (uint8_t)((*(__IO uint8_t *)OPTCR_BYTE0_ADDRESS) & (uint8_t)0x1F);
000010  4904              LDR      r1,|L30.36|
000012  7808              LDRB     r0,[r1,#0]
000014  f000001f          AND      r0,r0,#0x1f
;;;1251   #endif /* STM32F427_437xx ||  STM32F429_439xx */
;;;1252   
;;;1253   #if defined (STM32F40_41xxx) || defined (STM32F401xx) || defined (STM32F411xE)
;;;1254       /* Mask OPTLOCK, OPTSTRT and BOR_LEV bits */
;;;1255       optiontmp =  (uint8_t)((*(__IO uint8_t *)OPTCR_BYTE0_ADDRESS) & (uint8_t)0x0F); 
;;;1256   #endif /* STM32F40_41xxx || STM32F401xx || STM32F411xE */ 
;;;1257   
;;;1258       /* Update User Option Byte */
;;;1259       *(__IO uint8_t *)OPTCR_BYTE0_ADDRESS = OB_IWDG | (uint8_t)(OB_STDBY | (uint8_t)(OB_STOP | ((uint8_t)optiontmp))); 
000018  4304              ORRS     r4,r4,r0
00001a  432c              ORRS     r4,r4,r5
00001c  4334              ORRS     r4,r4,r6
00001e  700c              STRB     r4,[r1,#0]
                  |L30.32|
;;;1260     }  
;;;1261   }
000020  bd70              POP      {r4-r6,pc}
;;;1262   
                          ENDP

000022  0000              DCW      0x0000
                  |L30.36|
                          DCD      0x40023c14

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

                  FLASH_OB_WRP1Config PROC
;;;1047     */
;;;1048   void FLASH_OB_WRP1Config(uint32_t OB_WRP, FunctionalState NewState)
000000  b530              PUSH     {r4,r5,lr}
;;;1049   { 
000002  460d              MOV      r5,r1
000004  4604              MOV      r4,r0
;;;1050     FLASH_Status status = FLASH_COMPLETE;
;;;1051     
;;;1052     /* Check the parameters */
;;;1053     assert_param(IS_OB_WRP(OB_WRP));
;;;1054     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1055       
;;;1056     status = FLASH_WaitForLastOperation();
000006  f7fffffe          BL       FLASH_WaitForLastOperation
;;;1057   
;;;1058     if(status == FLASH_COMPLETE)
00000a  2809              CMP      r0,#9
00000c  d106              BNE      |L31.28|
;;;1059     { 
;;;1060       if(NewState != DISABLE)
;;;1061       {
;;;1062         *(__IO uint16_t*)OPTCR1_BYTE2_ADDRESS &= (~OB_WRP);
00000e  4804              LDR      r0,|L31.32|
;;;1063       }
;;;1064       else
;;;1065       {
;;;1066         *(__IO uint16_t*)OPTCR1_BYTE2_ADDRESS |= (uint16_t)OB_WRP;
000010  8801              LDRH     r1,[r0,#0]
000012  b10d              CBZ      r5,|L31.24|
000014  43a1              BICS     r1,r1,r4              ;1062
000016  e000              B        |L31.26|
                  |L31.24|
000018  4321              ORRS     r1,r1,r4
                  |L31.26|
00001a  8001              STRH     r1,[r0,#0]
                  |L31.28|
;;;1067       }
;;;1068     }
;;;1069   }
00001c  bd30              POP      {r4,r5,pc}
;;;1070   
                          ENDP

00001e  0000              DCW      0x0000
                  |L31.32|
                          DCD      0x40023c1a

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

                  FLASH_OB_WRPConfig PROC
;;;1005     */
;;;1006   void FLASH_OB_WRPConfig(uint32_t OB_WRP, FunctionalState NewState)
000000  b530              PUSH     {r4,r5,lr}
;;;1007   { 
000002  460d              MOV      r5,r1
000004  4604              MOV      r4,r0
;;;1008     FLASH_Status status = FLASH_COMPLETE;
;;;1009     
;;;1010     /* Check the parameters */
;;;1011     assert_param(IS_OB_WRP(OB_WRP));
;;;1012     assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;1013       
;;;1014     status = FLASH_WaitForLastOperation();
000006  f7fffffe          BL       FLASH_WaitForLastOperation
;;;1015   
;;;1016     if(status == FLASH_COMPLETE)
00000a  2809              CMP      r0,#9
00000c  d106              BNE      |L32.28|
;;;1017     { 
;;;1018       if(NewState != DISABLE)
;;;1019       {
;;;1020         *(__IO uint16_t*)OPTCR_BYTE2_ADDRESS &= (~OB_WRP);
00000e  4804              LDR      r0,|L32.32|
;;;1021       }
;;;1022       else
;;;1023       {
;;;1024         *(__IO uint16_t*)OPTCR_BYTE2_ADDRESS |= (uint16_t)OB_WRP;
000010  8801              LDRH     r1,[r0,#0]
000012  b10d              CBZ      r5,|L32.24|
000014  43a1              BICS     r1,r1,r4              ;1020
000016  e000              B        |L32.26|
                  |L32.24|
000018  4321              ORRS     r1,r1,r4
                  |L32.26|
00001a  8001              STRH     r1,[r0,#0]
                  |L32.28|
;;;1025       }
;;;1026     }
;;;1027   }
00001c  bd30              POP      {r4,r5,pc}
;;;1028   
                          ENDP

00001e  0000              DCW      0x0000
                  |L32.32|
                          DCD      0x40023c16

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

                  FLASH_PrefetchBufferCmd PROC
;;;291      */
;;;292    void FLASH_PrefetchBufferCmd(FunctionalState NewState)
000000  4905              LDR      r1,|L33.24|
;;;293    {
;;;294      /* Check the parameters */
;;;295      assert_param(IS_FUNCTIONAL_STATE(NewState));
;;;296      
;;;297      /* Enable or disable the Prefetch Buffer */
;;;298      if(NewState != DISABLE)
000002  2800              CMP      r0,#0
;;;299      {
;;;300        FLASH->ACR |= FLASH_ACR_PRFTEN;
;;;301      }
;;;302      else
;;;303      {
;;;304        FLASH->ACR &= (~FLASH_ACR_PRFTEN);
000004  6808              LDR      r0,[r1,#0]
000006  d002              BEQ      |L33.14|
000008  f4407080          ORR      r0,r0,#0x100          ;300
00000c  e001              B        |L33.18|
                  |L33.14|
00000e  f4207080          BIC      r0,r0,#0x100
                  |L33.18|
000012  6008              STR      r0,[r1,#0]            ;300
;;;305      }
;;;306    }
000014  4770              BX       lr
;;;307    
                          ENDP

000016  0000              DCW      0x0000
                  |L33.24|
                          DCD      0x40023c00

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

                  FLASH_ProgramByte PROC
;;;868      */
;;;869    FLASH_Status FLASH_ProgramByte(uint32_t Address, uint8_t Data)
000000  b570              PUSH     {r4-r6,lr}
;;;870    {
000002  460d              MOV      r5,r1
000004  4606              MOV      r6,r0
;;;871      FLASH_Status status = FLASH_COMPLETE;
;;;872    
;;;873      /* Check the parameters */
;;;874      assert_param(IS_FLASH_ADDRESS(Address));
;;;875    
;;;876      /* Wait for last operation to be completed */
;;;877      status = FLASH_WaitForLastOperation();
000006  f7fffffe          BL       FLASH_WaitForLastOperation
;;;878      
;;;879      if(status == FLASH_COMPLETE)
00000a  2809              CMP      r0,#9
00000c  d111              BNE      |L34.50|
;;;880      {
;;;881        /* if the previous operation is completed, proceed to program the new data */
;;;882        FLASH->CR &= CR_PSIZE_MASK;
00000e  4c09              LDR      r4,|L34.52|
000010  6820              LDR      r0,[r4,#0]
000012  f4207040          BIC      r0,r0,#0x300
000016  6020              STR      r0,[r4,#0]
;;;883        FLASH->CR |= FLASH_PSIZE_BYTE;
000018  6820              LDR      r0,[r4,#0]
00001a  6020              STR      r0,[r4,#0]
;;;884        FLASH->CR |= FLASH_CR_PG;
00001c  6820              LDR      r0,[r4,#0]
00001e  f0400001          ORR      r0,r0,#1
000022  6020              STR      r0,[r4,#0]
;;;885      
;;;886        *(__IO uint8_t*)Address = Data;
000024  7035              STRB     r5,[r6,#0]
;;;887            
;;;888        /* Wait for last operation to be completed */
;;;889        status = FLASH_WaitForLastOperation();
000026  f7fffffe          BL       FLASH_WaitForLastOperation
;;;890    
;;;891        /* if the program operation is completed, disable the PG Bit */
;;;892        FLASH->CR &= (~FLASH_CR_PG);
00002a  6821              LDR      r1,[r4,#0]
00002c  f0210101          BIC      r1,r1,#1
000030  6021              STR      r1,[r4,#0]
                  |L34.50|
;;;893      } 
;;;894    
;;;895      /* Return the Program Status */
;;;896      return status;
;;;897    }
000032  bd70              POP      {r4-r6,pc}
;;;898    
                          ENDP

                  |L34.52|
                          DCD      0x40023c10

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

                  FLASH_ProgramDoubleWord PROC
;;;741      */
;;;742    FLASH_Status FLASH_ProgramDoubleWord(uint32_t Address, uint64_t Data)
000000  b5f0              PUSH     {r4-r7,lr}
;;;743    {
000002  4615              MOV      r5,r2
000004  461e              MOV      r6,r3
000006  4607              MOV      r7,r0
;;;744      FLASH_Status status = FLASH_COMPLETE;
;;;745    
;;;746      /* Check the parameters */
;;;747      assert_param(IS_FLASH_ADDRESS(Address));
;;;748    
;;;749      /* Wait for last operation to be completed */
;;;750      status = FLASH_WaitForLastOperation();
000008  f7fffffe          BL       FLASH_WaitForLastOperation
;;;751      
;;;752      if(status == FLASH_COMPLETE)
00000c  2809              CMP      r0,#9
00000e  d114              BNE      |L35.58|
;;;753      {
;;;754        /* if the previous operation is completed, proceed to program the new data */
;;;755        FLASH->CR &= CR_PSIZE_MASK;
000010  4c0a              LDR      r4,|L35.60|
000012  6820              LDR      r0,[r4,#0]
000014  f4207040          BIC      r0,r0,#0x300
000018  6020              STR      r0,[r4,#0]
;;;756        FLASH->CR |= FLASH_PSIZE_DOUBLE_WORD;
00001a  6820              LDR      r0,[r4,#0]
00001c  f4407040          ORR      r0,r0,#0x300
000020  6020              STR      r0,[r4,#0]
;;;757        FLASH->CR |= FLASH_CR_PG;
000022  6820              LDR      r0,[r4,#0]
000024  f0400001          ORR      r0,r0,#1
000028  6020              STR      r0,[r4,#0]
;;;758      
;;;759        *(__IO uint64_t*)Address = Data;
00002a  603d              STR      r5,[r7,#0]
00002c  607e              STR      r6,[r7,#4]
;;;760            
;;;761        /* Wait for last operation to be completed */
;;;762        status = FLASH_WaitForLastOperation();
00002e  f7fffffe          BL       FLASH_WaitForLastOperation
;;;763    
;;;764        /* if the program operation is completed, disable the PG Bit */
;;;765        FLASH->CR &= (~FLASH_CR_PG);
000032  6821              LDR      r1,[r4,#0]
000034  f0210101          BIC      r1,r1,#1
000038  6021              STR      r1,[r4,#0]
                  |L35.58|
;;;766      } 
;;;767      /* Return the Program Status */
;;;768      return status;
;;;769    }
00003a  bdf0              POP      {r4-r7,pc}
;;;770    
                          ENDP

                  |L35.60|
                          DCD      0x40023c10

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

                  FLASH_ProgramHalfWord PROC
;;;826      */
;;;827    FLASH_Status FLASH_ProgramHalfWord(uint32_t Address, uint16_t Data)
000000  b570              PUSH     {r4-r6,lr}
;;;828    {
000002  460d              MOV      r5,r1
000004  4606              MOV      r6,r0
;;;829      FLASH_Status status = FLASH_COMPLETE;
;;;830    
;;;831      /* Check the parameters */
;;;832      assert_param(IS_FLASH_ADDRESS(Address));
;;;833    
;;;834      /* Wait for last operation to be completed */
;;;835      status = FLASH_WaitForLastOperation();
000006  f7fffffe          BL       FLASH_WaitForLastOperation
;;;836      
;;;837      if(status == FLASH_COMPLETE)
00000a  2809              CMP      r0,#9
00000c  d113              BNE      |L36.54|
;;;838      {
;;;839        /* if the previous operation is completed, proceed to program the new data */
;;;840        FLASH->CR &= CR_PSIZE_MASK;
00000e  4c0a              LDR      r4,|L36.56|
000010  6820              LDR      r0,[r4,#0]
000012  f4207040          BIC      r0,r0,#0x300
000016  6020              STR      r0,[r4,#0]
;;;841        FLASH->CR |= FLASH_PSIZE_HALF_WORD;
000018  6820              LDR      r0,[r4,#0]
00001a  f4407080          ORR      r0,r0,#0x100
00001e  6020              STR      r0,[r4,#0]
;;;842        FLASH->CR |= FLASH_CR_PG;
000020  6820              LDR      r0,[r4,#0]
000022  f0400001          ORR      r0,r0,#1
000026  6020              STR      r0,[r4,#0]
;;;843      
;;;844        *(__IO uint16_t*)Address = Data;
000028  8035              STRH     r5,[r6,#0]
;;;845            
;;;846        /* Wait for last operation to be completed */
;;;847        status = FLASH_WaitForLastOperation();
00002a  f7fffffe          BL       FLASH_WaitForLastOperation
;;;848    
;;;849        /* if the program operation is completed, disable the PG Bit */
;;;850        FLASH->CR &= (~FLASH_CR_PG);
00002e  6821              LDR      r1,[r4,#0]
000030  f0210101          BIC      r1,r1,#1
000034  6021              STR      r1,[r4,#0]
                  |L36.54|
;;;851      } 
;;;852      /* Return the Program Status */
;;;853      return status;
;;;854    }
000036  bd70              POP      {r4-r6,pc}
;;;855    
                          ENDP

                  |L36.56|
                          DCD      0x40023c10

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

                  FLASH_ProgramWord PROC
;;;784      */
;;;785    FLASH_Status FLASH_ProgramWord(uint32_t Address, uint32_t Data)
000000  b570              PUSH     {r4-r6,lr}
;;;786    {
000002  460d              MOV      r5,r1
000004  4606              MOV      r6,r0
;;;787      FLASH_Status status = FLASH_COMPLETE;
;;;788    
;;;789      /* Check the parameters */
;;;790      assert_param(IS_FLASH_ADDRESS(Address));
;;;791    
;;;792      /* Wait for last operation to be completed */
;;;793      status = FLASH_WaitForLastOperation();
000006  f7fffffe          BL       FLASH_WaitForLastOperation
;;;794      
;;;795      if(status == FLASH_COMPLETE)
00000a  2809              CMP      r0,#9
00000c  d113              BNE      |L37.54|
;;;796      {
;;;797        /* if the previous operation is completed, proceed to program the new data */
;;;798        FLASH->CR &= CR_PSIZE_MASK;
00000e  4c0a              LDR      r4,|L37.56|
000010  6820              LDR      r0,[r4,#0]
000012  f4207040          BIC      r0,r0,#0x300
000016  6020              STR      r0,[r4,#0]
;;;799        FLASH->CR |= FLASH_PSIZE_WORD;
000018  6820              LDR      r0,[r4,#0]
00001a  f4407000          ORR      r0,r0,#0x200
00001e  6020              STR      r0,[r4,#0]
;;;800        FLASH->CR |= FLASH_CR_PG;
000020  6820              LDR      r0,[r4,#0]
000022  f0400001          ORR      r0,r0,#1
000026  6020              STR      r0,[r4,#0]
;;;801      
;;;802        *(__IO uint32_t*)Address = Data;
000028  6035              STR      r5,[r6,#0]
;;;803            
;;;804        /* Wait for last operation to be completed */
;;;805        status = FLASH_WaitForLastOperation();
00002a  f7fffffe          BL       FLASH_WaitForLastOperation
;;;806    
;;;807        /* if the program operation is completed, disable the PG Bit */
;;;808        FLASH->CR &= (~FLASH_CR_PG);
00002e  6821              LDR      r1,[r4,#0]
000030  f0210101          BIC      r1,r1,#1
000034  6021              STR      r1,[r4,#0]
                  |L37.54|
;;;809      } 
;;;810      /* Return the Program Status */
;;;811      return status;
;;;812    }
000036  bd70              POP      {r4-r6,pc}
;;;813    
                          ENDP

                  |L37.56|
                          DCD      0x40023c10

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

                  FLASH_SetLatency PROC
;;;276      */
;;;277    void FLASH_SetLatency(uint32_t FLASH_Latency)
000000  4901              LDR      r1,|L38.8|
;;;278    {
;;;279      /* Check the parameters */
;;;280      assert_param(IS_FLASH_LATENCY(FLASH_Latency));
;;;281      
;;;282      /* Perform Byte access to FLASH_ACR[8:0] to set the Latency value */
;;;283      *(__IO uint8_t *)ACR_BYTE0_ADDRESS = (uint8_t)FLASH_Latency;
000002  7008              STRB     r0,[r1,#0]
;;;284    }
000004  4770              BX       lr
;;;285    
                          ENDP

000006  0000              DCW      0x0000
                  |L38.8|
                          DCD      0x40023c00

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

                  FLASH_Unlock PROC
;;;413      */
;;;414    void FLASH_Unlock(void)
000000  4805              LDR      r0,|L39.24|
;;;415    {
;;;416      if((FLASH->CR & FLASH_CR_LOCK) != RESET)
000002  6800              LDR      r0,[r0,#0]
000004  2800              CMP      r0,#0
000006  da05              BGE      |L39.20|
;;;417      {
;;;418        /* Authorize the FLASH Registers access */
;;;419        FLASH->KEYR = FLASH_KEY1;
000008  4803              LDR      r0,|L39.24|
00000a  4904              LDR      r1,|L39.28|
00000c  380c              SUBS     r0,r0,#0xc
00000e  6001              STR      r1,[r0,#0]
;;;420        FLASH->KEYR = FLASH_KEY2;
000010  4903              LDR      r1,|L39.32|
000012  6001              STR      r1,[r0,#0]
                  |L39.20|
;;;421      }  
;;;422    }
000014  4770              BX       lr
;;;423    
                          ENDP

000016  0000              DCW      0x0000
                  |L39.24|
                          DCD      0x40023c10
                  |L39.28|
                          DCD      0x45670123
                  |L39.32|
                          DCD      0xcdef89ab

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

                  FLASH_WaitForLastOperation PROC
;;;1577     */
;;;1578   FLASH_Status FLASH_WaitForLastOperation(void)
000000  b508              PUSH     {r3,lr}
;;;1579   { 
;;;1580     __IO FLASH_Status status = FLASH_COMPLETE;
000002  2009              MOVS     r0,#9
000004  f88d0000          STRB     r0,[sp,#0]
                  |L40.8|
;;;1581      
;;;1582     /* Check for the FLASH Status */
;;;1583     status = FLASH_GetStatus();
;;;1584   
;;;1585     /* Wait for the FLASH operation to complete by polling on BUSY flag to be reset.
;;;1586        Even if the FLASH operation fails, the BUSY flag will be reset and an error
;;;1587        flag will be set */
;;;1588     while(status == FLASH_BUSY)
;;;1589     {
;;;1590       status = FLASH_GetStatus();
000008  f7fffffe          BL       FLASH_GetStatus
00000c  f88d0000          STRB     r0,[sp,#0]
000010  f89d0000          LDRB     r0,[sp,#0]            ;1588
000014  2801              CMP      r0,#1                 ;1588
000016  d0f7              BEQ      |L40.8|
;;;1591     }
;;;1592     /* Return the operation status */
;;;1593     return status;
000018  f89d0000          LDRB     r0,[sp,#0]
;;;1594   }
00001c  bd08              POP      {r3,pc}
;;;1595   
                          ENDP


;*** Start embedded assembler ***

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

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

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
