; generated by Component: ARM Compiler 5.06 update 7 (build 960) Tool: ArmCC [4d365d]
; commandline ArmCC [--c99 --list --split_sections --debug -c --asm --interleave -o..\output\sc32f1xxx_iap.o --asm_dir=..\List\ --list_dir=..\List\ --depend=..\output\sc32f1xxx_iap.d --cpu=Cortex-M0+ --apcs=interwork --diag_suppress=9931 -I..\FWLib\SC32F1XXX_Lib\inc -I..\User\HeadFiles -I..\User -I..\Drivers -I..\Apps -I..\CMSIS -IF:\Keil_ARMV5.36_pack\ARM\CMSIS\5.8.0\Device\ARM\ARMCM0plus\Include -D__UVISION_VERSION=536 -DARMCM0P -DSC32f10xx --omf_browse=..\output\sc32f1xxx_iap.crf ..\FWLib\SC32F1XXX_Lib\src\sc32f1xxx_iap.c]
                          THUMB

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

                  IAP_EraseSector PROC
;;;106      */
;;;107    void IAP_EraseSector ( uint32_t IAP_Sector )
000000  2113              MOVS     r1,#0x13
;;;108    {
;;;109        uint32_t tmpreg;
;;;110        IAP->IAP_SNB = 0x4C000000 | IAP_Sector;
000002  0689              LSLS     r1,r1,#26
000004  4308              ORRS     r0,r0,r1
000006  4906              LDR      r1,|L1.32|
000008  6048              STR      r0,[r1,#4]
;;;111        tmpreg = IAP->IAP_CON;
00000a  68c8              LDR      r0,[r1,#0xc]
;;;112        tmpreg &= ( uint32_t ) ~ ( IAP_CON_ERASE | IAP_CON_CMD | IAP_CON_PRG );
00000c  2293              MOVS     r2,#0x93
00000e  4390              BICS     r0,r0,r2
;;;113        tmpreg |= ( uint32_t ) ( IAP_CON_SERASE );
000010  2220              MOVS     r2,#0x20
000012  4310              ORRS     r0,r0,r2
;;;114        IAP->IAP_CON = tmpreg;
000014  60c8              STR      r0,[r1,#0xc]
;;;115        IAP->IAP_CON |= ( 0x02 << IAP_CON_CMD_Pos );
000016  68c8              LDR      r0,[r1,#0xc]
000018  2202              MOVS     r2,#2
00001a  4310              ORRS     r0,r0,r2
00001c  60c8              STR      r0,[r1,#0xc]
;;;116    }
00001e  4770              BX       lr
;;;117    
                          ENDP

                  |L1.32|
                          DCD      0x400003c0

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

                  IAP_Lock PROC
;;;70       */
;;;71     void IAP_Lock ( void )
000000  2001              MOVS     r0,#1
;;;72     {
;;;73         /* Set the LOCK Bit to lock the FLASH Registers access */
;;;74         IAP->IAP_CON = ( uint32_t ) IAP_CON_LOCK;
000002  4902              LDR      r1,|L2.12|
000004  07c0              LSLS     r0,r0,#31
000006  60c8              STR      r0,[r1,#0xc]
;;;75     }
000008  4770              BX       lr
;;;76     
                          ENDP

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

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

                  IAP_ProgramByte PROC
;;;188      */
;;;189    boolType IAP_ProgramByte ( uint32_t Address, uint8_t Data )
000000  7001              STRB     r1,[r0,#0]
;;;190    {
;;;191        assert_param ( IS_IAP_ADDRESS ( Address ) );
;;;192    
;;;193        * ( uint8_t* ) Address = Data;
;;;194        if ( Data == * ( uint8_t * ) Address )
;;;195            return TRUE;
000002  2001              MOVS     r0,#1
;;;196        else
;;;197            return FALSE;
;;;198    }
000004  4770              BX       lr
;;;199    #elif defined (SC32f12xx)
                          ENDP


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

                  IAP_ProgramByteArray PROC
;;;422      */
;;;423    uint8_t IAP_ProgramByteArray ( uint32_t Address, uint8_t* ByteArray, uint16_t ArraySize )
000000  b530              PUSH     {r4,r5,lr}
;;;424    {
000002  4603              MOV      r3,r0
;;;425        assert_param ( IS_IAP_ADDRESS ( Address ) );
;;;426    
;;;427        uint8_t tmpCnt = 0;
000004  2000              MOVS     r0,#0
                  |L4.6|
;;;428        do
;;;429        {
;;;430            * ( __IO uint8_t* ) Address = ByteArray[tmpCnt];
000006  5c0c              LDRB     r4,[r1,r0]
000008  701c              STRB     r4,[r3,#0]
;;;431    
;;;432            if ( ByteArray[tmpCnt] != * ( __IO uint8_t * ) Address )
00000a  5c0c              LDRB     r4,[r1,r0]
00000c  781d              LDRB     r5,[r3,#0]
00000e  42ac              CMP      r4,r5
000010  d104              BNE      |L4.28|
000012  1c40              ADDS     r0,r0,#1
;;;433                break;
;;;434    
;;;435            Address = Address + 1;
;;;436    
;;;437        } while ( ++tmpCnt < ArraySize );
000014  b2c0              UXTB     r0,r0
000016  1c5b              ADDS     r3,r3,#1
000018  4290              CMP      r0,r2
00001a  d3f4              BCC      |L4.6|
                  |L4.28|
;;;438    
;;;439        return tmpCnt;
;;;440    }
00001c  bd30              POP      {r4,r5,pc}
;;;441    
                          ENDP


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

                  IAP_ProgramHalfWord PROC
;;;168      */
;;;169    boolType IAP_ProgramHalfWord ( uint32_t Address, uint16_t Data )
000000  8001              STRH     r1,[r0,#0]
;;;170    {
;;;171        assert_param ( IS_IAP_ADDRESS ( Address ) );
;;;172    
;;;173        * ( __IO uint16_t* ) Address = Data;
;;;174        if ( Data == * ( __IO uint16_t * ) Address )
000002  8800              LDRH     r0,[r0,#0]
000004  4288              CMP      r0,r1
000006  d101              BNE      |L5.12|
;;;175            return TRUE;
000008  2001              MOVS     r0,#1
;;;176        else
;;;177            return FALSE;
;;;178    }
00000a  4770              BX       lr
                  |L5.12|
00000c  2000              MOVS     r0,#0                 ;177
00000e  4770              BX       lr
;;;179    
                          ENDP


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

                  IAP_ProgramHalfWordArray PROC
;;;392    
;;;393    uint8_t IAP_ProgramHalfWordArray ( uint32_t Address, uint16_t* ByteArray, uint16_t ArraySize )
000000  b530              PUSH     {r4,r5,lr}
;;;394    {
;;;395        assert_param ( IS_IAP_ADDRESS ( Address ) );
;;;396    
;;;397        uint8_t tmpCnt = 0;
000002  2300              MOVS     r3,#0
;;;398        if ( ( Address & 0x01 ) == 0 )
000004  07c4              LSLS     r4,r0,#31
000006  d10b              BNE      |L6.32|
                  |L6.8|
;;;399        {
;;;400            do
;;;401            {
;;;402    
;;;403                * ( __IO uint16_t* ) Address = ByteArray[tmpCnt];
000008  005c              LSLS     r4,r3,#1
00000a  5b0d              LDRH     r5,[r1,r4]
00000c  8005              STRH     r5,[r0,#0]
;;;404    
;;;405                if ( ByteArray[tmpCnt] != * ( __IO uint16_t * ) Address )
00000e  5b0c              LDRH     r4,[r1,r4]
000010  8805              LDRH     r5,[r0,#0]
000012  42ac              CMP      r4,r5
000014  d104              BNE      |L6.32|
000016  1c5b              ADDS     r3,r3,#1
;;;406                    break;
;;;407    
;;;408                Address = Address + 2;
;;;409    
;;;410            } while ( ++tmpCnt < ArraySize );
000018  b2db              UXTB     r3,r3
00001a  1c80              ADDS     r0,r0,#2
00001c  4293              CMP      r3,r2
00001e  d3f3              BCC      |L6.8|
                  |L6.32|
;;;411        }
;;;412        return tmpCnt;
000020  4618              MOV      r0,r3
;;;413    }
000022  bd30              POP      {r4,r5,pc}
;;;414    
                          ENDP


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

                  IAP_ProgramWord PROC
;;;147      */
;;;148    boolType IAP_ProgramWord ( uint32_t Address, uint32_t Data )
000000  6001              STR      r1,[r0,#0]
;;;149    {
;;;150        assert_param ( IS_IAP_ADDRESS ( Address ) );
;;;151    
;;;152        * ( __IO uint32_t* ) Address = Data;
;;;153        if ( Data == * ( __IO uint32_t * ) Address )
000002  6800              LDR      r0,[r0,#0]
000004  4288              CMP      r0,r1
000006  d101              BNE      |L7.12|
;;;154            return TRUE;
000008  2001              MOVS     r0,#1
;;;155        else
;;;156            return FALSE;
;;;157    
;;;158    }
00000a  4770              BX       lr
                  |L7.12|
00000c  2000              MOVS     r0,#0                 ;156
00000e  4770              BX       lr
;;;159    #if defined (SC32f10xx)
                          ENDP


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

                  IAP_ProgramWordArray PROC
;;;360      */
;;;361    uint8_t IAP_ProgramWordArray ( uint32_t Address, uint32_t* ByteArray, uint16_t ArraySize )
000000  b530              PUSH     {r4,r5,lr}
;;;362    {
;;;363        assert_param ( IS_IAP_ADDRESS ( Address ) );
;;;364    
;;;365        uint8_t tmpCnt = 0;
000002  2300              MOVS     r3,#0
;;;366    
;;;367        if ( ( Address & 0x03 ) == 0 )
000004  0784              LSLS     r4,r0,#30
000006  d10b              BNE      |L8.32|
                  |L8.8|
;;;368        {
;;;369            do
;;;370            {
;;;371                * ( __IO uint32_t* ) Address = ByteArray[tmpCnt];
000008  009c              LSLS     r4,r3,#2
00000a  590d              LDR      r5,[r1,r4]
00000c  6005              STR      r5,[r0,#0]
;;;372    
;;;373                if ( ByteArray[tmpCnt] != * ( __IO uint32_t * ) Address )
00000e  590c              LDR      r4,[r1,r4]
000010  6805              LDR      r5,[r0,#0]
000012  42ac              CMP      r4,r5
000014  d104              BNE      |L8.32|
000016  1c5b              ADDS     r3,r3,#1
;;;374                    break;
;;;375    
;;;376                Address = Address + 4;
;;;377    
;;;378            } while ( ++tmpCnt < ArraySize );
000018  b2db              UXTB     r3,r3
00001a  1d00              ADDS     r0,r0,#4
00001c  4293              CMP      r3,r2
00001e  d3f3              BCC      |L8.8|
                  |L8.32|
;;;379        }
;;;380        return tmpCnt;
000020  4618              MOV      r0,r3
;;;381    
;;;382    }
000022  bd30              POP      {r4,r5,pc}
;;;383    #if defined(SC32f10xx) 
                          ENDP


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

                  IAP_ReadByte PROC
;;;343      */
;;;344    uint8_t IAP_ReadByte ( uint32_t Address )
000000  7800              LDRB     r0,[r0,#0]
;;;345    {
;;;346        assert_param ( IS_IAP_ADDRESS ( Address ) );
;;;347    
;;;348        uint8_t Data;
;;;349        Data = * ( uint8_t* ) Address;
;;;350        return Data;
;;;351    }
000002  4770              BX       lr
;;;352    
                          ENDP


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

                  IAP_ReadByteArray PROC
;;;500      */
;;;501    uint8_t IAP_ReadByteArray ( uint32_t Address, uint8_t* ByteArray, uint16_t ArraySize )
000000  b510              PUSH     {r4,lr}
;;;502    {
000002  4603              MOV      r3,r0
;;;503        assert_param ( IS_IAP_ADDRESS ( Address ) );
;;;504    
;;;505        uint8_t tmpCnt = 0;
000004  2000              MOVS     r0,#0
                  |L10.6|
;;;506        do
;;;507        {
;;;508            ByteArray[tmpCnt] = * ( __IO uint8_t* ) Address;
000006  781c              LDRB     r4,[r3,#0]
000008  540c              STRB     r4,[r1,r0]
00000a  1c40              ADDS     r0,r0,#1
;;;509            Address = Address + 1;
;;;510    
;;;511        } while ( ++tmpCnt < ArraySize );
00000c  b2c0              UXTB     r0,r0
00000e  1c5b              ADDS     r3,r3,#1
000010  4290              CMP      r0,r2
000012  d3f8              BCC      |L10.6|
;;;512    
;;;513        return tmpCnt;
;;;514    }
000014  bd10              POP      {r4,pc}
;;;515    
                          ENDP


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

                  IAP_ReadHalfWord PROC
;;;328      */
;;;329    uint16_t IAP_ReadHalfWord ( uint32_t Address )
000000  8800              LDRH     r0,[r0,#0]
;;;330    {
;;;331        assert_param ( IS_IAP_ADDRESS ( Address ) );
;;;332    
;;;333        uint16_t Data;
;;;334        Data = * ( __IO uint16_t* ) Address;
;;;335        return Data;
;;;336    }
000002  4770              BX       lr
;;;337    
                          ENDP


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

                  IAP_ReadHalfWordArray PROC
;;;475      */
;;;476    uint8_t IAP_ReadHalfWordArray ( uint32_t Address, uint16_t* ByteArray, uint16_t ArraySize )
000000  b530              PUSH     {r4,r5,lr}
;;;477    {
000002  4603              MOV      r3,r0
;;;478        assert_param ( IS_IAP_ADDRESS ( Address ) );
;;;479    
;;;480        uint8_t tmpCnt = 0;
000004  2000              MOVS     r0,#0
;;;481        if ( ( Address & 0x01 ) == 0 )
000006  07dc              LSLS     r4,r3,#31
000008  d107              BNE      |L12.26|
                  |L12.10|
;;;482        {
;;;483            do
;;;484            {
;;;485                ByteArray[tmpCnt] = * ( __IO uint16_t* ) Address;
00000a  881c              LDRH     r4,[r3,#0]
00000c  0045              LSLS     r5,r0,#1
00000e  1c40              ADDS     r0,r0,#1
;;;486                Address = Address + 2;
;;;487    
;;;488            } while ( ++tmpCnt < ArraySize );
000010  b2c0              UXTB     r0,r0
000012  1c9b              ADDS     r3,r3,#2
000014  534c              STRH     r4,[r1,r5]            ;485
000016  4290              CMP      r0,r2
000018  d3f7              BCC      |L12.10|
                  |L12.26|
;;;489        }
;;;490        return tmpCnt;
;;;491    }
00001a  bd30              POP      {r4,r5,pc}
;;;492    
                          ENDP


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

                  IAP_ReadWord PROC
;;;313      */
;;;314    uint32_t IAP_ReadWord ( uint32_t Address )
000000  6800              LDR      r0,[r0,#0]
;;;315    {
;;;316        assert_param ( IS_IAP_ADDRESS ( Address ) );
;;;317    
;;;318        uint32_t Data;
;;;319        Data = * ( __IO uint32_t* ) Address;
;;;320        return Data;
;;;321    }
000002  4770              BX       lr
;;;322    
                          ENDP


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

                  IAP_ReadWordArray PROC
;;;450      */
;;;451    uint8_t IAP_ReadWordArray ( uint32_t Address, uint32_t* ByteArray, uint16_t ArraySize )
000000  b530              PUSH     {r4,r5,lr}
;;;452    {
000002  4603              MOV      r3,r0
;;;453        assert_param ( IS_IAP_ADDRESS ( Address ) );
;;;454    
;;;455        uint8_t tmpCnt = 0;
000004  2000              MOVS     r0,#0
;;;456        if ( ( Address & 0x03 ) == 0 )
000006  079c              LSLS     r4,r3,#30
000008  d106              BNE      |L14.24|
                  |L14.10|
;;;457        {
;;;458            do
;;;459            {
;;;460                ByteArray[tmpCnt] = * ( __IO uint32_t* ) Address;
00000a  cb10              LDM      r3!,{r4}
00000c  0085              LSLS     r5,r0,#2
00000e  1c40              ADDS     r0,r0,#1
;;;461                Address = Address + 4;
;;;462    
;;;463            } while ( ++tmpCnt < ArraySize );
000010  b2c0              UXTB     r0,r0
000012  514c              STR      r4,[r1,r5]            ;460
000014  4290              CMP      r0,r2
000016  d3f8              BCC      |L14.10|
                  |L14.24|
;;;464        }
;;;465        return tmpCnt;
;;;466    }
000018  bd30              POP      {r4,r5,pc}
;;;467    
                          ENDP


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

                  IAP_SoftwareReset PROC
;;;539      */
;;;540    void IAP_SoftwareReset ( IAP_BTLD_TypeDef IAP_BTLDType )
000000  21ff              MOVS     r1,#0xff
;;;541    {
;;;542        IAP->IAP_CON = ( IAP_BTLDType | IAP_CON_RST );
000002  3101              ADDS     r1,#1
000004  4308              ORRS     r0,r0,r1
000006  4901              LDR      r1,|L15.12|
000008  60c8              STR      r0,[r1,#0xc]
;;;543    }
00000a  4770              BX       lr
;;;544    
                          ENDP

                  |L15.12|
                          DCD      0x400003c0

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

                  IAP_Unlock PROC
;;;46       */
;;;47     boolType IAP_Unlock ( void )
000000  b510              PUSH     {r4,lr}
;;;48     {
;;;49     #if defined(SC32f10xx)
;;;50         /* HIRC must be enabled before IAP operation */
;;;51         RCC_Unlock ( 0xFF );
000002  20ff              MOVS     r0,#0xff
000004  f7fffffe          BL       RCC_Unlock
;;;52         RCC_HIRCCmd ( ENABLE );
000008  2001              MOVS     r0,#1
00000a  f7fffffe          BL       RCC_HIRCCmd
;;;53     #endif
;;;54         /* Authorize the FLASH Registers access */
;;;55         IAP->IAPKEY = IAP_KEY1;
00000e  4806              LDR      r0,|L16.40|
000010  4904              LDR      r1,|L16.36|
000012  6001              STR      r1,[r0,#0]
;;;56         IAP->IAPKEY = IAP_KEY2;
000014  4905              LDR      r1,|L16.44|
000016  6001              STR      r1,[r0,#0]
;;;57     
;;;58         if ( IAP->IAPKEY == 0x01 )
000018  6800              LDR      r0,[r0,#0]
00001a  2801              CMP      r0,#1
00001c  d000              BEQ      |L16.32|
;;;59             /* Unlock success */
;;;60             return TRUE;
;;;61         else
;;;62             /* Unlock Error */
;;;63             return FALSE;
00001e  2000              MOVS     r0,#0
                  |L16.32|
;;;64     }
000020  bd10              POP      {r4,pc}
;;;65     
                          ENDP

000022  0000              DCW      0x0000
                  |L16.36|
                          DCD      0x12345678
                  |L16.40|
                          DCD      0x400003c0
                  |L16.44|
                          DCD      0xa05f05fa

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

                  IAP_WriteCmd PROC
;;;83       */
;;;84     void IAP_WriteCmd ( FunctionalState NewState )
000000  4904              LDR      r1,|L17.20|
;;;85     {
;;;86         /* Check the parameters */
;;;87         assert_param ( IS_FUNCTIONAL_STATE ( NewState ) );
;;;88     
;;;89         if ( NewState != DISABLE )
;;;90         {
;;;91             IAP->IAP_CON |= ( uint32_t ) IAP_CON_PRG;
000002  2210              MOVS     r2,#0x10
000004  2800              CMP      r0,#0                 ;89
;;;92         }
;;;93         else
;;;94         {
;;;95             IAP->IAP_CON &= ~ ( uint32_t ) IAP_CON_PRG;
000006  68c8              LDR      r0,[r1,#0xc]
000008  d001              BEQ      |L17.14|
00000a  4310              ORRS     r0,r0,r2              ;91
00000c  e000              B        |L17.16|
                  |L17.14|
00000e  4390              BICS     r0,r0,r2
                  |L17.16|
000010  60c8              STR      r0,[r1,#0xc]          ;91
;;;96         }
;;;97     }
000012  4770              BX       lr
;;;98     
                          ENDP

                  |L17.20|
                          DCD      0x400003c0

;*** Start embedded assembler ***

#line 1 "..\\FWLib\\SC32F1XXX_Lib\\src\\sc32f1xxx_iap.c"
	AREA ||.rev16_text||, CODE
	THUMB
	EXPORT |__asm___15_sc32f1xxx_iap_c_14fd2dba____REV16|
#line 463 "..\\CMSIS\\cmsis_armcc.h"
|__asm___15_sc32f1xxx_iap_c_14fd2dba____REV16| PROC
#line 464

 rev16 r0, r0
 bx lr
	ENDP
	AREA ||.revsh_text||, CODE
	THUMB
	EXPORT |__asm___15_sc32f1xxx_iap_c_14fd2dba____REVSH|
#line 478
|__asm___15_sc32f1xxx_iap_c_14fd2dba____REVSH| PROC
#line 479

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
