; generated by Component: ARM Compiler 5.06 update 1 (build 61) Tool: ArmCC [4d35ad]
; commandline ArmCC [--list --debug -c --asm --interleave -o.\obj\isp_iap.o --asm_dir=.\Obj\ --list_dir=.\Obj\ --depend=.\obj\isp_iap.d --cpu=Cortex-M3 --apcs=interwork -O0 --diag_suppress=9931 -I. -I.\Core_CM3 -ID:\work\arm\lpc1769_eth_bootloader\RTE -I"C:\Program Files\Keil\ARM\PACK\Keil\LPC1700_DFP\2.2.0\Device\Include" -I"C:\Program Files\Keil\ARM\CMSIS\Include" -D__UVISION_VERSION=517 -DLPC175x_6x --omf_browse=.\obj\isp_iap.crf isp\isp_iap.c]
                          THUMB

                          AREA ||.text||, CODE, READONLY, ALIGN=2

                  is_div PROC
;;;39     
;;;40     int is_div(unsigned value,unsigned div)
000000  4602              MOV      r2,r0
;;;41     {
;;;42         if(value & (div -1))
000002  1e48              SUBS     r0,r1,#1
000004  4010              ANDS     r0,r0,r2
000006  b108              CBZ      r0,|L1.12|
;;;43         {
;;;44             return(1);
000008  2001              MOVS     r0,#1
                  |L1.10|
;;;45         }
;;;46         else
;;;47         {
;;;48             return(0);
;;;49         }
;;;50     }/* is_div */
00000a  4770              BX       lr
                  |L1.12|
00000c  2000              MOVS     r0,#0                 ;48
00000e  e7fc              B        |L1.10|
;;;51     
                          ENDP

                  __rt_div0 PROC
;;;52     void __rt_div0(void)
000010  4770              BX       lr
;;;53     {
;;;54     } /* __rt_div0 */
;;;55     
                          ENDP

                  str_cmp PROC
;;;56     int str_cmp(char * src, char * dst)
000012  b510              PUSH     {r4,lr}
;;;57     {
000014  4602              MOV      r2,r0
000016  460b              MOV      r3,r1
;;;58         int i = 0;
000018  2100              MOVS     r1,#0
;;;59         
;;;60         for(i=0;src[i] == dst[i];i++)
00001a  bf00              NOP      
00001c  e004              B        |L1.40|
                  |L1.30|
;;;61         {
;;;62             if(src[i] == NUL)
00001e  5c50              LDRB     r0,[r2,r1]
000020  b908              CBNZ     r0,|L1.38|
;;;63             {
;;;64                 return(NUL);
000022  2000              MOVS     r0,#0
                  |L1.36|
;;;65             }
;;;66         }
;;;67         return(src[i]-dst[i]);
;;;68     } /* str_cmp */
000024  bd10              POP      {r4,pc}
                  |L1.38|
000026  1c49              ADDS     r1,r1,#1              ;60
                  |L1.40|
000028  5c50              LDRB     r0,[r2,r1]            ;60
00002a  5c5c              LDRB     r4,[r3,r1]            ;60
00002c  42a0              CMP      r0,r4                 ;60
00002e  d0f6              BEQ      |L1.30|
000030  5c50              LDRB     r0,[r2,r1]            ;67
000032  5c5c              LDRB     r4,[r3,r1]            ;67
000034  1b00              SUBS     r0,r0,r4              ;67
000036  e7f5              B        |L1.36|
;;;69     
                          ENDP

                  a_to_i PROC
;;;70     int a_to_i(char * inbuf,unsigned * outint)
000038  b530              PUSH     {r4,r5,lr}
;;;71     {
00003a  4602              MOV      r2,r0
00003c  460b              MOV      r3,r1
;;;72         unsigned int value=0,i;
00003e  2400              MOVS     r4,#0
;;;73         
;;;74         for(i=0;inbuf[i] != 0;i++)
000040  2100              MOVS     r1,#0
000042  e00e              B        |L1.98|
                  |L1.68|
;;;75         {
;;;76             if(inbuf[i] >= '0' && inbuf[i] <= '9')
000044  5c50              LDRB     r0,[r2,r1]
000046  2830              CMP      r0,#0x30
000048  db08              BLT      |L1.92|
00004a  5c50              LDRB     r0,[r2,r1]
00004c  2839              CMP      r0,#0x39
00004e  dc05              BGT      |L1.92|
;;;77             {
;;;78                 value = 10 * value +(inbuf[i] - '0');
000050  5c50              LDRB     r0,[r2,r1]
000052  3830              SUBS     r0,r0,#0x30
000054  250a              MOVS     r5,#0xa
000056  fb040405          MLA      r4,r4,r5,r0
00005a  e001              B        |L1.96|
                  |L1.92|
;;;79             }
;;;80             else
;;;81             {
;;;82                 return(1);
00005c  2001              MOVS     r0,#1
                  |L1.94|
;;;83             }
;;;84         }
;;;85         *outint = value;
;;;86         return(0);
;;;87     } /* a_to_i */
00005e  bd30              POP      {r4,r5,pc}
                  |L1.96|
000060  1c49              ADDS     r1,r1,#1              ;74
                  |L1.98|
000062  5c50              LDRB     r0,[r2,r1]            ;74
000064  2800              CMP      r0,#0                 ;74
000066  d1ed              BNE      |L1.68|
000068  601c              STR      r4,[r3,#0]            ;85
00006a  bf00              NOP                            ;86
00006c  e7f7              B        |L1.94|
;;;88     
                          ENDP

                  i_to_a PROC
;;;89     
;;;90     char * i_to_a(unsigned i_num, char * str, unsigned str_len)
00006e  b530              PUSH     {r4,r5,lr}
;;;91     {
000070  4603              MOV      r3,r0
;;;92         char remainder;
;;;93     
;;;94         str[--str_len] = NUL;
000072  2500              MOVS     r5,#0
000074  1e50              SUBS     r0,r2,#1
000076  4602              MOV      r2,r0
000078  540d              STRB     r5,[r1,r0]
;;;95     
;;;96         if(i_num == 0)
00007a  b92b              CBNZ     r3,|L1.136|
;;;97         {
;;;98             str[--str_len] = '0';
00007c  2530              MOVS     r5,#0x30
00007e  1e50              SUBS     r0,r2,#1
000080  4602              MOV      r2,r0
000082  540d              STRB     r5,[r1,r0]
;;;99             return(str + str_len);
000084  1888              ADDS     r0,r1,r2
                  |L1.134|
;;;100        }
;;;101    
;;;102        while (((str_len>0) && (i_num!=0)))
;;;103        {
;;;104            str_len--;
;;;105            remainder = (char) (i_num % 10);
;;;106            if ( remainder <= 9 )
;;;107            {
;;;108                str[str_len] = remainder + '0';
;;;109            }
;;;110            else  
;;;111            {
;;;112                str[str_len] = remainder - 10 + 'A';
;;;113            }
;;;114            i_num = i_num/10;
;;;115        }
;;;116        return (str + str_len);
;;;117    } /* i_to_a */
000086  bd30              POP      {r4,r5,pc}
                  |L1.136|
000088  e011              B        |L1.174|
                  |L1.138|
00008a  1e52              SUBS     r2,r2,#1              ;104
00008c  200a              MOVS     r0,#0xa               ;105
00008e  fbb3f5f0          UDIV     r5,r3,r0              ;105
000092  fb003415          MLS      r4,r0,r5,r3           ;105
000096  2c09              CMP      r4,#9                 ;106
000098  dc03              BGT      |L1.162|
00009a  f1040030          ADD      r0,r4,#0x30           ;108
00009e  5488              STRB     r0,[r1,r2]            ;108
0000a0  e002              B        |L1.168|
                  |L1.162|
0000a2  f1040037          ADD      r0,r4,#0x37           ;112
0000a6  5488              STRB     r0,[r1,r2]            ;112
                  |L1.168|
0000a8  200a              MOVS     r0,#0xa               ;114
0000aa  fbb3f3f0          UDIV     r3,r3,r0              ;114
                  |L1.174|
0000ae  b10a              CBZ      r2,|L1.180|
0000b0  2b00              CMP      r3,#0                 ;102
0000b2  d1ea              BNE      |L1.138|
                  |L1.180|
0000b4  1888              ADDS     r0,r1,r2              ;116
0000b6  e7e6              B        |L1.134|
;;;118    
                          ENDP

                  run_isp PROC
;;;119    const char sync_str[] = "Synchronized";
;;;120    void run_isp(void)
0000b8  b508              PUSH     {r3,lr}
;;;121    {
;;;122        int count;
;;;123    
;;;124        /* wait for host to initiate communication */
;;;125    	getline(cmd_buf,CMD_SIZE,&count);
0000ba  466a              MOV      r2,sp
0000bc  2146              MOVS     r1,#0x46
0000be  48fd              LDR      r0,|L1.1204|
0000c0  f7fffffe          BL       getline
;;;126    
;;;127    	/* send "Synchronized" string response */
;;;128    	sendline_crlf((char *)sync_str);
0000c4  48fc              LDR      r0,|L1.1208|
0000c6  f7fffffe          BL       sendline_crlf
;;;129    
;;;130        /* wait for host to respond */
;;;131    	getline(cmd_buf,CMD_SIZE,&count);
0000ca  466a              MOV      r2,sp
0000cc  2146              MOVS     r1,#0x46
0000ce  48f9              LDR      r0,|L1.1204|
0000d0  f7fffffe          BL       getline
;;;132    
;;;133    	/* Compare HOST response with the original string */
;;;134    	if(str_cmp(cmd_buf,(char *)sync_str) == 0)
0000d4  49f8              LDR      r1,|L1.1208|
0000d6  48f7              LDR      r0,|L1.1204|
0000d8  f7fffffe          BL       str_cmp
;;;135    	{
;;;136    		/* Autobaud is successful. Get out of while loop. */
;;;137    	}
;;;138    	else
;;;139    	{
;;;140    	}
;;;141    }
0000dc  bd08              POP      {r3,pc}
;;;142    
                          ENDP

                  param_check PROC
;;;143    unsigned param_check(char * param_str,unsigned * param_ptr,int param_type,int count)
0000de  e92d4ff0          PUSH     {r4-r11,lr}
;;;144    {
0000e2  4682              MOV      r10,r0
0000e4  460d              MOV      r5,r1
0000e6  4614              MOV      r4,r2
0000e8  4698              MOV      r8,r3
;;;145        int rc,return_code,in_flash,in_ram;
;;;146        return_code = 0;
0000ea  f04f0b00          MOV      r11,#0
;;;147        /* check if conversion from str to integer is required */
;;;148        if(param_str != NUL)
0000ee  f1ba0f00          CMP      r10,#0
0000f2  d008              BEQ      |L1.262|
;;;149        {
;;;150            rc = a_to_i(param_str,param_ptr);
0000f4  4629              MOV      r1,r5
0000f6  4650              MOV      r0,r10
0000f8  f7fffffe          BL       a_to_i
0000fc  4606              MOV      r6,r0
;;;151            if(rc != 0)
0000fe  b116              CBZ      r6,|L1.262|
;;;152            {
;;;153                return(PARAM_ERROR);
000100  200c              MOVS     r0,#0xc
                  |L1.258|
;;;154            }
;;;155        }
;;;156    
;;;157        if(param_type == NO_PARAM_CHECK)
;;;158        {
;;;159            /* further testing is not required. Verification is done in  
;;;160               related commands */
;;;161            return(0);
;;;162        }
;;;163        
;;;164        rc = is_div(*param_ptr,BY_4);
;;;165        if( rc != 0)
;;;166        {   
;;;167            if(param_type == COUNT)
;;;168            {
;;;169                return_code = COUNT_ERROR;
;;;170            }
;;;171            else
;;;172            {
;;;173                return_code = ADDR_ERROR;
;;;174                /* Now distinguish between SRC & DST if required */
;;;175                if(param_type == RAM_ADDRESS)
;;;176                {
;;;177                    return_code = SRC_ADDR_ERROR;
;;;178                }
;;;179                if(param_type == FLASH_ADDRESS)
;;;180                {
;;;181                    return_code = DST_ADDR_ERROR;
;;;182                }
;;;183            } /* Address error */
;;;184        } /* is_div by 4 error */
;;;185    
;;;186        /* Check for address mapping if required. Each type of address requires a 
;;;187        different type of test. Do this testing only if previous test is ok */
;;;188        if(return_code == 0)
;;;189        {
;;;190            if( ((*param_ptr >= RAM_START) && ((*param_ptr+count) <= (RAM_END+1))) )
;;;191            {
;;;192                in_ram = TRUE;
;;;193            }
;;;194            else
;;;195            {
;;;196                in_ram = FALSE;
;;;197            }
;;;198            if( ((*param_ptr >= USER_START_SECTOR_ADDRESS) && ((*param_ptr+count) <= (USER_END_SECTOR_ADDRESS+1))) )
;;;199            {
;;;200                in_flash = TRUE;
;;;201            }
;;;202            else
;;;203            {
;;;204                in_flash = FALSE;
;;;205            }
;;;206            if(param_type == RAM_OR_FLASH_ADDRESS)
;;;207            {
;;;208                if( !(in_ram || in_flash) )
;;;209                {
;;;210                    return_code = ADDR_NOT_MAPPED;
;;;211                }
;;;212            }
;;;213            if(param_type == RAM_ADDRESS)
;;;214            {
;;;215                if( !(in_ram) )
;;;216                {
;;;217                    return_code = SRC_ADDR_NOT_MAPPED;
;;;218                }
;;;219            }
;;;220        }
;;;221        return(return_code);
;;;222    }/* param_check */
000102  e8bd8ff0          POP      {r4-r11,pc}
                  |L1.262|
000106  2c69              CMP      r4,#0x69              ;157
000108  d101              BNE      |L1.270|
00010a  2000              MOVS     r0,#0                 ;161
00010c  e7f9              B        |L1.258|
                  |L1.270|
00010e  2104              MOVS     r1,#4                 ;164
000110  6828              LDR      r0,[r5,#0]            ;164
000112  f7fffffe          BL       is_div
000116  4606              MOV      r6,r0                 ;164
000118  b176              CBZ      r6,|L1.312|
00011a  2c64              CMP      r4,#0x64              ;167
00011c  d102              BNE      |L1.292|
00011e  f04f0b06          MOV      r11,#6                ;169
000122  e009              B        |L1.312|
                  |L1.292|
000124  f04f0b0d          MOV      r11,#0xd              ;173
000128  2c67              CMP      r4,#0x67              ;175
00012a  d101              BNE      |L1.304|
00012c  f04f0b02          MOV      r11,#2                ;177
                  |L1.304|
000130  2c68              CMP      r4,#0x68              ;179
000132  d101              BNE      |L1.312|
000134  f04f0b03          MOV      r11,#3                ;181
                  |L1.312|
000138  f1bb0f00          CMP      r11,#0                ;188
00013c  d126              BNE      |L1.396|
00013e  6828              LDR      r0,[r5,#0]            ;190
000140  f1b05f80          CMP      r0,#0x10000000        ;190
000144  d306              BCC      |L1.340|
000146  6828              LDR      r0,[r5,#0]            ;190
000148  4440              ADD      r0,r0,r8              ;190
00014a  49dc              LDR      r1,|L1.1212|
00014c  4288              CMP      r0,r1                 ;190
00014e  d801              BHI      |L1.340|
000150  2701              MOVS     r7,#1                 ;192
000152  e000              B        |L1.342|
                  |L1.340|
000154  2700              MOVS     r7,#0                 ;196
                  |L1.342|
000156  6828              LDR      r0,[r5,#0]            ;198
000158  f5b05f00          CMP      r0,#0x2000            ;198
00015c  d307              BCC      |L1.366|
00015e  6828              LDR      r0,[r5,#0]            ;198
000160  4440              ADD      r0,r0,r8              ;198
000162  f5b02f00          CMP      r0,#0x80000           ;198
000166  d802              BHI      |L1.366|
000168  f04f0901          MOV      r9,#1                 ;200
00016c  e001              B        |L1.370|
                  |L1.366|
00016e  f04f0900          MOV      r9,#0                 ;204
                  |L1.370|
000172  2c66              CMP      r4,#0x66              ;206
000174  d105              BNE      |L1.386|
000176  b927              CBNZ     r7,|L1.386|
000178  f1b90f00          CMP      r9,#0                 ;208
00017c  d101              BNE      |L1.386|
00017e  f04f0b0e          MOV      r11,#0xe              ;210
                  |L1.386|
000182  2c67              CMP      r4,#0x67              ;213
000184  d102              BNE      |L1.396|
000186  b90f              CBNZ     r7,|L1.396|
000188  f04f0b04          MOV      r11,#4                ;217
                  |L1.396|
00018c  4658              MOV      r0,r11                ;221
00018e  e7b8              B        |L1.258|
;;;223    
                          ENDP

                  iap_entry PROC
;;;224    void iap_entry(unsigned param_tab[],unsigned result_tab[])
000190  b570              PUSH     {r4-r6,lr}
;;;225    {
000192  4604              MOV      r4,r0
000194  460d              MOV      r5,r1
;;;226        void (*iap)(unsigned [],unsigned []);
;;;227    
;;;228        iap = (void (*)(unsigned [],unsigned []))IAP_ADDRESS;
000196  4eca              LDR      r6,|L1.1216|
;;;229        iap(param_tab,result_tab);
000198  4629              MOV      r1,r5
00019a  4620              MOV      r0,r4
00019c  47b0              BLX      r6
;;;230    }
00019e  bd70              POP      {r4-r6,pc}
;;;231    
                          ENDP

                  decode PROC
;;;232    char decode(char c)
0001a0  4601              MOV      r1,r0
;;;233    {
;;;234        if(c == 0x60)
0001a2  2960              CMP      r1,#0x60
0001a4  d101              BNE      |L1.426|
;;;235        {
;;;236            return(0x00);
0001a6  2000              MOVS     r0,#0
                  |L1.424|
;;;237        }
;;;238        else
;;;239        {
;;;240            return(c - SP);
;;;241        }
;;;242    }
0001a8  4770              BX       lr
                  |L1.426|
0001aa  f1a10020          SUB      r0,r1,#0x20           ;240
0001ae  b2c0              UXTB     r0,r0                 ;240
0001b0  e7fa              B        |L1.424|
;;;243    
                          ENDP

                  uudecode PROC
;;;244    unsigned uudecode(char * inbuf, char * outbuf, int * count)
0001b2  e92d41f0          PUSH     {r4-r8,lr}
;;;245    {
0001b6  4603              MOV      r3,r0
0001b8  460c              MOV      r4,r1
0001ba  4617              MOV      r7,r2
;;;246        unsigned sum;
;;;247        int in_byte_count,out_byte_count;
;;;248        
;;;249        sum=0;
0001bc  2500              MOVS     r5,#0
;;;250        out_byte_count=0;
0001be  2600              MOVS     r6,#0
;;;251        in_byte_count = decode(*inbuf);
0001c0  7818              LDRB     r0,[r3,#0]
0001c2  f7fffffe          BL       decode
0001c6  4602              MOV      r2,r0
;;;252        /* Do not decode if byte count is > 45 */
;;;253        if( (in_byte_count > 0) && (in_byte_count <= UU_LINE) )
0001c8  2a00              CMP      r2,#0
0001ca  dd52              BLE      |L1.626|
0001cc  2a2d              CMP      r2,#0x2d
0001ce  dc50              BGT      |L1.626|
;;;254        {
;;;255            for (++inbuf; in_byte_count > 0; inbuf += 4, in_byte_count -= 3)
0001d0  1c5b              ADDS     r3,r3,#1
0001d2  e04c              B        |L1.622|
                  |L1.468|
;;;256            {
;;;257                /* !!! Test for valid printable character is not done !!! */
;;;258                if(in_byte_count >= 3)
0001d4  2a03              CMP      r2,#3
0001d6  db28              BLT      |L1.554|
;;;259                {
;;;260                    outbuf[0] = (decode(inbuf[0]) << 2) | (decode(inbuf[1]) >> 4);
0001d8  7818              LDRB     r0,[r3,#0]
0001da  f7fffffe          BL       decode
0001de  ea4f0880          LSL      r8,r0,#2
0001e2  7858              LDRB     r0,[r3,#1]
0001e4  f7fffffe          BL       decode
0001e8  ea481020          ORR      r0,r8,r0,ASR #4
0001ec  7020              STRB     r0,[r4,#0]
;;;261                    outbuf[1] = (decode(inbuf[1]) << 4) | (decode(inbuf[2]) >> 2);
0001ee  7858              LDRB     r0,[r3,#1]
0001f0  f7fffffe          BL       decode
0001f4  ea4f1800          LSL      r8,r0,#4
0001f8  7898              LDRB     r0,[r3,#2]
0001fa  f7fffffe          BL       decode
0001fe  ea4800a0          ORR      r0,r8,r0,ASR #2
000202  7060              STRB     r0,[r4,#1]
;;;262                    outbuf[2] = (decode(inbuf[2]) << 6) | (decode(inbuf[3]));
000204  78d8              LDRB     r0,[r3,#3]
000206  f7fffffe          BL       decode
00020a  4680              MOV      r8,r0
00020c  7898              LDRB     r0,[r3,#2]
00020e  f7fffffe          BL       decode
000212  ea481080          ORR      r0,r8,r0,LSL #6
000216  70a0              STRB     r0,[r4,#2]
;;;263                    out_byte_count += 3;
000218  1cf6              ADDS     r6,r6,#3
;;;264                    sum = sum + outbuf[0] + outbuf[1] + outbuf[2];
00021a  7820              LDRB     r0,[r4,#0]
00021c  4428              ADD      r0,r0,r5
00021e  7861              LDRB     r1,[r4,#1]
000220  4408              ADD      r0,r0,r1
000222  78a1              LDRB     r1,[r4,#2]
000224  1845              ADDS     r5,r0,r1
;;;265                    outbuf+=3;
000226  1ce4              ADDS     r4,r4,#3
000228  e01f              B        |L1.618|
                  |L1.554|
;;;266                }
;;;267                else
;;;268                {
;;;269                     if(in_byte_count >= 1)
00022a  2a01              CMP      r2,#1
00022c  db0d              BLT      |L1.586|
;;;270                    {
;;;271                        outbuf[0] = (decode(inbuf[0]) << 2) | (decode(inbuf[1]) >> 4);
00022e  7818              LDRB     r0,[r3,#0]
000230  f7fffffe          BL       decode
000234  ea4f0880          LSL      r8,r0,#2
000238  7858              LDRB     r0,[r3,#1]
00023a  f7fffffe          BL       decode
00023e  ea481020          ORR      r0,r8,r0,ASR #4
000242  7020              STRB     r0,[r4,#0]
;;;272                        out_byte_count++;
000244  1c76              ADDS     r6,r6,#1
;;;273                        sum = sum + outbuf[0];
000246  7820              LDRB     r0,[r4,#0]
000248  4405              ADD      r5,r5,r0
                  |L1.586|
;;;274                      /* No need to increment the outbuf as this is the last for loop iteration */
;;;275                    }
;;;276                    if(in_byte_count >= 2)
00024a  2a02              CMP      r2,#2
00024c  db0d              BLT      |L1.618|
;;;277                    {
;;;278                        outbuf[1] = (decode(inbuf[1]) << 4) | (decode(inbuf[2]) >> 2);
00024e  7858              LDRB     r0,[r3,#1]
000250  f7fffffe          BL       decode
000254  ea4f1800          LSL      r8,r0,#4
000258  7898              LDRB     r0,[r3,#2]
00025a  f7fffffe          BL       decode
00025e  ea4800a0          ORR      r0,r8,r0,ASR #2
000262  7060              STRB     r0,[r4,#1]
;;;279                        out_byte_count++;
000264  1c76              ADDS     r6,r6,#1
;;;280                        sum = sum + outbuf[1];
000266  7860              LDRB     r0,[r4,#1]
000268  4405              ADD      r5,r5,r0
                  |L1.618|
00026a  1d1b              ADDS     r3,r3,#4              ;255
00026c  1ed2              SUBS     r2,r2,#3              ;255
                  |L1.622|
00026e  2a00              CMP      r2,#0                 ;255
000270  dcb0              BGT      |L1.468|
                  |L1.626|
;;;281                      /* No need to increment the outbuf as this is the last for loop iteration */
;;;282                    }
;;;283                }
;;;284            } /* for loop */
;;;285        }
;;;286        *count = out_byte_count;
000272  603e              STR      r6,[r7,#0]
;;;287        return(sum);
000274  4628              MOV      r0,r5
;;;288    } /* uudecode */
000276  e8bd81f0          POP      {r4-r8,pc}
;;;289    
                          ENDP

                  encode PROC
;;;290    char encode(char c)
00027a  4601              MOV      r1,r0
;;;291    {
;;;292        if( c == 0x00)
00027c  b909              CBNZ     r1,|L1.642|
;;;293        {
;;;294            return(0x60);
00027e  2060              MOVS     r0,#0x60
                  |L1.640|
;;;295        }
;;;296        else
;;;297        {
;;;298            return(c+SP);
;;;299        }
;;;300    }
000280  4770              BX       lr
                  |L1.642|
000282  f1010020          ADD      r0,r1,#0x20           ;298
000286  b2c0              UXTB     r0,r0                 ;298
000288  e7fa              B        |L1.640|
;;;301    
                          ENDP

                  uuencode PROC
;;;302    unsigned uuencode(char * inbuf, char * outbuf, int count)
00028a  b5f0              PUSH     {r4-r7,lr}
;;;303    {
00028c  4603              MOV      r3,r0
00028e  460c              MOV      r4,r1
;;;304        unsigned sum;
;;;305        char byte1,byte2;
;;;306        sum = 0;
000290  2500              MOVS     r5,#0
;;;307        *outbuf = encode(count);
000292  b2d0              UXTB     r0,r2
000294  f7fffffe          BL       encode
000298  7020              STRB     r0,[r4,#0]
;;;308        outbuf++;
00029a  1c64              ADDS     r4,r4,#1
;;;309        while(count>0)
00029c  e033              B        |L1.774|
                  |L1.670|
;;;310        {
;;;311            if(count >= 3)
00029e  2a03              CMP      r2,#3
0002a0  db08              BLT      |L1.692|
;;;312            {
;;;313                byte1 = inbuf[1];
0002a2  785e              LDRB     r6,[r3,#1]
;;;314                byte2 = inbuf[2];
0002a4  789f              LDRB     r7,[r3,#2]
;;;315                sum = sum + inbuf[0] + inbuf[1] + inbuf[2];
0002a6  7818              LDRB     r0,[r3,#0]
0002a8  4428              ADD      r0,r0,r5
0002aa  7859              LDRB     r1,[r3,#1]
0002ac  4408              ADD      r0,r0,r1
0002ae  7899              LDRB     r1,[r3,#2]
0002b0  1845              ADDS     r5,r0,r1
0002b2  e00c              B        |L1.718|
                  |L1.692|
;;;316            }
;;;317            else
;;;318            {
;;;319                if(count == 2)
0002b4  2a02              CMP      r2,#2
0002b6  d106              BNE      |L1.710|
;;;320                {
;;;321                    byte1 = inbuf[1];
0002b8  785e              LDRB     r6,[r3,#1]
;;;322                    byte2 = inbuf[1];
0002ba  785f              LDRB     r7,[r3,#1]
;;;323                    sum = sum + inbuf[0] + inbuf[1];
0002bc  7818              LDRB     r0,[r3,#0]
0002be  4428              ADD      r0,r0,r5
0002c0  7859              LDRB     r1,[r3,#1]
0002c2  1845              ADDS     r5,r0,r1
0002c4  e003              B        |L1.718|
                  |L1.710|
;;;324                }
;;;325                else
;;;326                {
;;;327                    byte1 = inbuf[0];
0002c6  781e              LDRB     r6,[r3,#0]
;;;328                    byte2 = inbuf[0];
0002c8  781f              LDRB     r7,[r3,#0]
;;;329                    sum = sum + inbuf[0];
0002ca  7818              LDRB     r0,[r3,#0]
0002cc  4405              ADD      r5,r5,r0
                  |L1.718|
;;;330                }
;;;331            }
;;;332            outbuf[0] = encode(((inbuf[0] >> 2) & 0x3F));
0002ce  7819              LDRB     r1,[r3,#0]
0002d0  0888              LSRS     r0,r1,#2
0002d2  f7fffffe          BL       encode
0002d6  7020              STRB     r0,[r4,#0]
;;;333            outbuf[1] = encode(((inbuf[0] & 0x03) << 4) + ((byte1 & 0xF0) >> 4));
0002d8  7819              LDRB     r1,[r3,#0]
0002da  0789              LSLS     r1,r1,#30
0002dc  0e89              LSRS     r1,r1,#26
0002de  eb011016          ADD      r0,r1,r6,LSR #4
0002e2  f7fffffe          BL       encode
0002e6  7060              STRB     r0,[r4,#1]
;;;334            outbuf[2] = encode(((byte1 & 0x0F) << 2) + ((byte2 & 0xC0) >> 6));
0002e8  0731              LSLS     r1,r6,#28
0002ea  0e89              LSRS     r1,r1,#26
0002ec  eb011097          ADD      r0,r1,r7,LSR #6
0002f0  f7fffffe          BL       encode
0002f4  70a0              STRB     r0,[r4,#2]
;;;335            outbuf[3] = encode((byte2 & 0x3F));
0002f6  f007003f          AND      r0,r7,#0x3f
0002fa  f7fffffe          BL       encode
0002fe  70e0              STRB     r0,[r4,#3]
;;;336            outbuf+=4;
000300  1d24              ADDS     r4,r4,#4
;;;337            inbuf+=3;
000302  1cdb              ADDS     r3,r3,#3
;;;338            count-=3;
000304  1ed2              SUBS     r2,r2,#3
                  |L1.774|
000306  2a00              CMP      r2,#0                 ;309
000308  dcc9              BGT      |L1.670|
;;;339        } /* while loop */
;;;340        outbuf[0] = NUL;
00030a  2000              MOVS     r0,#0
00030c  7020              STRB     r0,[r4,#0]
;;;341        return(sum);
00030e  4628              MOV      r0,r5
;;;342    } /* uuencode */
000310  bdf0              POP      {r4-r7,pc}
;;;343    
                          ENDP

                  write_to_ram PROC
;;;347    
;;;348    void write_to_ram(void)
000312  e92d43f0          PUSH     {r4-r9,lr}
;;;349    {
000316  b085              SUB      sp,sp,#0x14
;;;350        unsigned dst,checksum,recvd_checksum;
;;;351        unsigned line_ctr,last_dst;
;;;352        int count,decode_count,last_cnt,char_cnt;
;;;353        unsigned rc;
;;;354        
;;;355        /* Check count validity first as mapping check requires count */
;;;356        rc = param_check(param_buf[ISP_PARAM_2],(unsigned *)&count,COUNT,count);
000318  496a              LDR      r1,|L1.1220|
00031a  6888              LDR      r0,[r1,#8]  ; param_buf
00031c  2264              MOVS     r2,#0x64
00031e  a902              ADD      r1,sp,#8
000320  9b02              LDR      r3,[sp,#8]
000322  f7fffffe          BL       param_check
000326  4604              MOV      r4,r0
;;;357        if(rc == 0)
000328  b96c              CBNZ     r4,|L1.838|
;;;358        {
;;;359            rc = param_check(param_buf[ISP_PARAM_1],&dst,RAM_ADDRESS,count);
00032a  4966              LDR      r1,|L1.1220|
00032c  6848              LDR      r0,[r1,#4]  ; param_buf
00032e  2267              MOVS     r2,#0x67
000330  a904              ADD      r1,sp,#0x10
000332  9b02              LDR      r3,[sp,#8]
000334  f7fffffe          BL       param_check
000338  4604              MOV      r4,r0
;;;360            if (rc == SRC_ADDR_NOT_MAPPED)
00033a  2c04              CMP      r4,#4
00033c  d100              BNE      |L1.832|
;;;361            {
;;;362                rc = ADDR_NOT_MAPPED;
00033e  240e              MOVS     r4,#0xe
                  |L1.832|
;;;363            }
;;;364            if (rc == SRC_ADDR_ERROR)
000340  2c02              CMP      r4,#2
000342  d100              BNE      |L1.838|
;;;365            {
;;;366                rc = ADDR_ERROR;
000344  240d              MOVS     r4,#0xd
                  |L1.838|
;;;367            }
;;;368        }
;;;369        /* Do not allow write to ISP RAM variable area */
;;;370        if( (crp_after_reset == CRP1) )
000346  4860              LDR      r0,|L1.1224|
000348  6800              LDR      r0,[r0,#0]  ; crp_after_reset
00034a  4960              LDR      r1,|L1.1228|
00034c  4288              CMP      r0,r1
00034e  d104              BNE      |L1.858|
;;;371        {
;;;372             if( ( dst < (RAM_START) ) )
000350  9804              LDR      r0,[sp,#0x10]
000352  f1b05f80          CMP      r0,#0x10000000
000356  d200              BCS      |L1.858|
;;;373             {
;;;374                 rc = CODE_READ_PROTECTION_ENABLED;
000358  2413              MOVS     r4,#0x13
                  |L1.858|
;;;375             }
;;;376         }
;;;377     
;;;378        /* Print command result on serial channel */
;;;379        sendline_crlf(i_to_a(rc,param_buf[ISP_PARAM_0],PARAM_SIZE));
00035a  485a              LDR      r0,|L1.1220|
00035c  220f              MOVS     r2,#0xf
00035e  6801              LDR      r1,[r0,#0]  ; param_buf
000360  4620              MOV      r0,r4
000362  f7fffffe          BL       i_to_a
000366  4681              MOV      r9,r0
000368  f7fffffe          BL       sendline_crlf
;;;380    
;;;381        /* execute command only if parameters are ok */
;;;382        if(rc != CMD_SUCCESS)
00036c  b114              CBZ      r4,|L1.884|
                  |L1.878|
;;;383        {
;;;384            return;
;;;385        }
;;;386        
;;;387        /* Initialize checksum related variables */
;;;388        checksum = 0;
;;;389    		line_ctr = 0;
;;;390        last_dst = dst;
;;;391        last_cnt = count;
;;;392        while(count>0)
;;;393        {
;;;394            if(getline(cmd_buf,CMD_SIZE,&char_cnt) != CMD_SUCCESS)
;;;395            {
;;;396                /* Abort command */
;;;397                break;
;;;398            }
;;;399            /* Keep track of number of lines decoded. Need to verify checksum
;;;400               once the LINE_CHECKSUM lines are receieved */
;;;401            if(char_cnt != 0) /* Ignore empty lines */
;;;402            {
;;;403                line_ctr++;
;;;404                checksum = checksum + uudecode(cmd_buf,(char *)dst,&decode_count);
;;;405                dst = dst + decode_count;
;;;406                count = count - decode_count;
;;;407            }
;;;408            /* Need checksum handshake ? */
;;;409            if( ((line_ctr == LINE_CHECKSUM) || (count == 0)) )
;;;410            {
;;;411                char_cnt = 0;
;;;412                /* Get checksum string (ASCII decimal) from host */
;;;413                while(char_cnt == 0)
;;;414                {
;;;415                    rc = getline(cmd_buf,CMD_SIZE,&char_cnt);
;;;416                }
;;;417                if( rc != CMD_SUCCESS)
;;;418                {
;;;419                    break;
;;;420                }
;;;421                /* No error check while conversion to integer. If there is an error
;;;422                it will be trapped by wrong checksum */
;;;423                a_to_i(cmd_buf,&recvd_checksum);
;;;424                if( checksum == recvd_checksum)
;;;425                {
;;;426                    last_cnt = count;
;;;427                    last_dst = dst;
;;;428                    sendline_crlf((char *)ok);
;;;429                }
;;;430                else
;;;431                {
;;;432                    count = last_cnt;
;;;433                    dst = last_dst;
;;;434                    sendline_crlf((char *)resend);
;;;435                }
;;;436                /* line counter and checksum has to be reset anyway */
;;;437                line_ctr = 0;
;;;438                checksum = 0;
;;;439            }
;;;440        }/* While loop */
;;;441    } /* write_to_ram */
00036e  b005              ADD      sp,sp,#0x14
000370  e8bd83f0          POP      {r4-r9,pc}
                  |L1.884|
000374  2500              MOVS     r5,#0                 ;388
000376  2600              MOVS     r6,#0                 ;389
000378  9f04              LDR      r7,[sp,#0x10]         ;390
00037a  f8dd8008          LDR      r8,[sp,#8]            ;391
00037e  e03f              B        |L1.1024|
                  |L1.896|
000380  466a              MOV      r2,sp                 ;394
000382  2146              MOVS     r1,#0x46              ;394
000384  484b              LDR      r0,|L1.1204|
000386  f7fffffe          BL       getline
00038a  b100              CBZ      r0,|L1.910|
00038c  e03b              B        |L1.1030|
                  |L1.910|
00038e  9800              LDR      r0,[sp,#0]            ;401
000390  b170              CBZ      r0,|L1.944|
000392  1c76              ADDS     r6,r6,#1              ;403
000394  aa01              ADD      r2,sp,#4              ;404
000396  4847              LDR      r0,|L1.1204|
000398  9904              LDR      r1,[sp,#0x10]         ;404
00039a  f7fffffe          BL       uudecode
00039e  4405              ADD      r5,r5,r0              ;404
0003a0  9901              LDR      r1,[sp,#4]            ;405
0003a2  9804              LDR      r0,[sp,#0x10]         ;405
0003a4  4408              ADD      r0,r0,r1              ;405
0003a6  9004              STR      r0,[sp,#0x10]         ;405
0003a8  e9dd1001          LDRD     r1,r0,[sp,#4]         ;406
0003ac  1a40              SUBS     r0,r0,r1              ;406
0003ae  9002              STR      r0,[sp,#8]            ;406
                  |L1.944|
0003b0  2e14              CMP      r6,#0x14              ;409
0003b2  d001              BEQ      |L1.952|
0003b4  9802              LDR      r0,[sp,#8]            ;409
0003b6  bb18              CBNZ     r0,|L1.1024|
                  |L1.952|
0003b8  2000              MOVS     r0,#0                 ;411
0003ba  9000              STR      r0,[sp,#0]            ;411
0003bc  e005              B        |L1.970|
                  |L1.958|
0003be  466a              MOV      r2,sp                 ;415
0003c0  2146              MOVS     r1,#0x46              ;415
0003c2  483c              LDR      r0,|L1.1204|
0003c4  f7fffffe          BL       getline
0003c8  4604              MOV      r4,r0                 ;415
                  |L1.970|
0003ca  9800              LDR      r0,[sp,#0]            ;413
0003cc  2800              CMP      r0,#0                 ;413
0003ce  d0f6              BEQ      |L1.958|
0003d0  b104              CBZ      r4,|L1.980|
0003d2  e018              B        |L1.1030|
                  |L1.980|
0003d4  a903              ADD      r1,sp,#0xc            ;423
0003d6  4837              LDR      r0,|L1.1204|
0003d8  f7fffffe          BL       a_to_i
0003dc  9803              LDR      r0,[sp,#0xc]          ;424
0003de  4285              CMP      r5,r0                 ;424
0003e0  d106              BNE      |L1.1008|
0003e2  f8dd8008          LDR      r8,[sp,#8]            ;426
0003e6  9f04              LDR      r7,[sp,#0x10]         ;427
0003e8  4839              LDR      r0,|L1.1232|
0003ea  f7fffffe          BL       sendline_crlf
0003ee  e005              B        |L1.1020|
                  |L1.1008|
0003f0  f8cd8008          STR      r8,[sp,#8]            ;432
0003f4  9704              STR      r7,[sp,#0x10]         ;433
0003f6  4837              LDR      r0,|L1.1236|
0003f8  f7fffffe          BL       sendline_crlf
                  |L1.1020|
0003fc  2600              MOVS     r6,#0                 ;437
0003fe  2500              MOVS     r5,#0                 ;438
                  |L1.1024|
000400  9802              LDR      r0,[sp,#8]            ;392
000402  2800              CMP      r0,#0                 ;392
000404  dcbc              BGT      |L1.896|
                  |L1.1030|
000406  bf00              NOP                            ;397
000408  bf00              NOP      
00040a  e7b0              B        |L1.878|
;;;442    
                          ENDP

                  read PROC
;;;443    void read(void)
00040c  e92d4ffe          PUSH     {r1-r11,lr}
;;;444    {
;;;445        unsigned src,checksum,last_src,line_ctr;
;;;446        int count,encode_count,last_cnt;
;;;447        unsigned rc;
;;;448    	int char_cnt;
;;;449    
;;;450        /* Check count validity first as address mapping check requires count */
;;;451        rc = param_check(param_buf[ISP_PARAM_2],(unsigned *)&count,COUNT,NUL);
000410  492c              LDR      r1,|L1.1220|
000412  2300              MOVS     r3,#0
000414  2264              MOVS     r2,#0x64
000416  6888              LDR      r0,[r1,#8]  ; param_buf
000418  a901              ADD      r1,sp,#4
00041a  f7fffffe          BL       param_check
00041e  4604              MOV      r4,r0
;;;452        if(rc == 0)
000420  b93c              CBNZ     r4,|L1.1074|
;;;453        {
;;;454            rc = param_check(param_buf[ISP_PARAM_1],&src,RAM_OR_FLASH_ADDRESS,count);
000422  4928              LDR      r1,|L1.1220|
000424  6848              LDR      r0,[r1,#4]  ; param_buf
000426  2266              MOVS     r2,#0x66
000428  a902              ADD      r1,sp,#8
00042a  9b01              LDR      r3,[sp,#4]
00042c  f7fffffe          BL       param_check
000430  4604              MOV      r4,r0
                  |L1.1074|
;;;455        }
;;;456        /* Print command result on serial channel */
;;;457        sendline_crlf(i_to_a(rc,param_buf[ISP_PARAM_0],PARAM_SIZE));
000432  4824              LDR      r0,|L1.1220|
000434  220f              MOVS     r2,#0xf
000436  6801              LDR      r1,[r0,#0]  ; param_buf
000438  4620              MOV      r0,r4
00043a  f7fffffe          BL       i_to_a
00043e  4682              MOV      r10,r0
000440  f7fffffe          BL       sendline_crlf
;;;458        /* execute command only if parameters are ok */
;;;459        if(rc != CMD_SUCCESS)
000444  b10c              CBZ      r4,|L1.1098|
                  |L1.1094|
;;;460        {
;;;461            return;
;;;462        }
;;;463        
;;;464        /* Initialize checksum related variables */
;;;465        checksum = 0;
;;;466        line_ctr = 0;
;;;467        last_src = src;
;;;468        last_cnt = count;
;;;469    
;;;470        while(count > 0)
;;;471        {
;;;472            if(count > UU_LINE)
;;;473            {
;;;474                encode_count = UU_LINE;
;;;475            }
;;;476            else
;;;477            {
;;;478                encode_count = count;
;;;479            }
;;;480            checksum = checksum + uuencode((char *)src,cmd_buf,encode_count);
;;;481            if(sendline_crlf(cmd_buf) != 1)
;;;482            {
;;;483                /* Abort command */
;;;484                break;
;;;485            }
;;;486            /* Keep track of number of lines encoded. Need to send checksum
;;;487               once the LINE_CHECKSUM lines are transmitted */
;;;488            line_ctr++;        
;;;489            src = src + encode_count;
;;;490            count = count - encode_count;
;;;491            if( ((line_ctr == LINE_CHECKSUM) || (count == 0)) )
;;;492            {
;;;493                /* Tranmitt checksum string (ASCII decimal) to host */
;;;494                sendline_crlf(i_to_a(checksum,cmd_buf,PARAM_SIZE));
;;;495                /* Read host response */
;;;496                rc = getline(cmd_buf,CMD_SIZE,&char_cnt);
;;;497                if( rc != CMD_SUCCESS)
;;;498                {
;;;499                    break;
;;;500                }
;;;501                if(str_cmp(cmd_buf,(char *)ok) == 0)
;;;502                {
;;;503                    last_cnt = count;
;;;504                    last_src = src;
;;;505                }
;;;506                else
;;;507                {
;;;508                    count = last_cnt;
;;;509                    src = last_src;
;;;510                }
;;;511                /* line counter and checksum has to be reset anyway */
;;;512                line_ctr = 0;
;;;513                checksum = 0;
;;;514            }
;;;515        } /* while count > 0 */
;;;516    } /* read */
000446  e8bd8ffe          POP      {r1-r11,pc}
                  |L1.1098|
00044a  2500              MOVS     r5,#0                 ;465
00044c  2600              MOVS     r6,#0                 ;466
00044e  f8dd8008          LDR      r8,[sp,#8]            ;467
000452  f8dd9004          LDR      r9,[sp,#4]            ;468
000456  e04f              B        |L1.1272|
                  |L1.1112|
000458  9801              LDR      r0,[sp,#4]            ;472
00045a  282d              CMP      r0,#0x2d              ;472
00045c  dd01              BLE      |L1.1122|
00045e  272d              MOVS     r7,#0x2d              ;474
000460  e000              B        |L1.1124|
                  |L1.1122|
000462  9f01              LDR      r7,[sp,#4]            ;478
                  |L1.1124|
000464  463a              MOV      r2,r7                 ;480
000466  4913              LDR      r1,|L1.1204|
000468  9802              LDR      r0,[sp,#8]            ;480
00046a  f7fffffe          BL       uuencode
00046e  4405              ADD      r5,r5,r0              ;480
000470  4810              LDR      r0,|L1.1204|
000472  f7fffffe          BL       sendline_crlf
000476  2801              CMP      r0,#1                 ;481
000478  d000              BEQ      |L1.1148|
00047a  e040              B        |L1.1278|
                  |L1.1148|
00047c  1c76              ADDS     r6,r6,#1              ;488
00047e  9802              LDR      r0,[sp,#8]            ;489
000480  4438              ADD      r0,r0,r7              ;489
000482  9002              STR      r0,[sp,#8]            ;489
000484  9801              LDR      r0,[sp,#4]            ;490
000486  1bc0              SUBS     r0,r0,r7              ;490
000488  9001              STR      r0,[sp,#4]            ;490
00048a  2e14              CMP      r6,#0x14              ;491
00048c  d001              BEQ      |L1.1170|
00048e  9801              LDR      r0,[sp,#4]            ;491
000490  b978              CBNZ     r0,|L1.1202|
                  |L1.1170|
000492  220f              MOVS     r2,#0xf               ;494
000494  4907              LDR      r1,|L1.1204|
000496  4628              MOV      r0,r5                 ;494
000498  f7fffffe          BL       i_to_a
00049c  4682              MOV      r10,r0                ;494
00049e  f7fffffe          BL       sendline_crlf
0004a2  466a              MOV      r2,sp                 ;496
0004a4  2146              MOVS     r1,#0x46              ;496
0004a6  4803              LDR      r0,|L1.1204|
0004a8  f7fffffe          BL       getline
0004ac  4604              MOV      r4,r0                 ;496
0004ae  b19c              CBZ      r4,|L1.1240|
0004b0  e025              B        |L1.1278|
                  |L1.1202|
0004b2  e021              B        |L1.1272|
                  |L1.1204|
                          DCD      cmd_buf
                  |L1.1208|
                          DCD      sync_str
                  |L1.1212|
                          DCD      0x10008000
                  |L1.1216|
                          DCD      0x1fff1ff1
                  |L1.1220|
                          DCD      param_buf
                  |L1.1224|
                          DCD      crp_after_reset
                  |L1.1228|
                          DCD      0x12345678
                  |L1.1232|
                          DCD      ||ok||
                  |L1.1236|
                          DCD      resend
                  |L1.1240|
0004d8  49fd              LDR      r1,|L1.2256|
0004da  48fe              LDR      r0,|L1.2260|
0004dc  f7fffffe          BL       str_cmp
0004e0  b920              CBNZ     r0,|L1.1260|
0004e2  f8dd9004          LDR      r9,[sp,#4]            ;503
0004e6  f8dd8008          LDR      r8,[sp,#8]            ;504
0004ea  e003              B        |L1.1268|
                  |L1.1260|
0004ec  f8cd9004          STR      r9,[sp,#4]            ;508
0004f0  f8cd8008          STR      r8,[sp,#8]            ;509
                  |L1.1268|
0004f4  2600              MOVS     r6,#0                 ;512
0004f6  2500              MOVS     r5,#0                 ;513
                  |L1.1272|
0004f8  9801              LDR      r0,[sp,#4]            ;470
0004fa  2800              CMP      r0,#0                 ;470
0004fc  dcac              BGT      |L1.1112|
                  |L1.1278|
0004fe  bf00              NOP                            ;484
000500  bf00              NOP      
000502  e7a0              B        |L1.1094|
;;;517    
                          ENDP

                  go_cmd PROC
;;;518    void go_cmd(void)
000504  b538              PUSH     {r3-r5,lr}
;;;519    {
;;;520        unsigned rc;
;;;521        uint32_t go;
;;;522        
;;;523        if(lock == FALSE)
000506  48f4              LDR      r0,|L1.2264|
000508  6800              LDR      r0,[r0,#0]  ; lock
00050a  b908              CBNZ     r0,|L1.1296|
;;;524        {
;;;525            rc = CMD_SUCCESS;
00050c  2400              MOVS     r4,#0
00050e  e000              B        |L1.1298|
                  |L1.1296|
;;;526        }
;;;527        else
;;;528        {
;;;529            rc = CMD_LOCKED;
000510  240f              MOVS     r4,#0xf
                  |L1.1298|
;;;530        }
;;;531            
;;;532        if(rc == CMD_SUCCESS)
000512  b93c              CBNZ     r4,|L1.1316|
;;;533        {
;;;534            /* Convert and check Go addres */
;;;535            rc = param_check(param_buf[ISP_PARAM_1],(unsigned *)&go, \
000514  49f1              LDR      r1,|L1.2268|
000516  2300              MOVS     r3,#0
000518  2266              MOVS     r2,#0x66
00051a  6848              LDR      r0,[r1,#4]  ; param_buf
00051c  4669              MOV      r1,sp
00051e  f7fffffe          BL       param_check
000522  4604              MOV      r4,r0
                  |L1.1316|
;;;536                 RAM_OR_FLASH_ADDRESS,NUL);
;;;537        }
;;;538    		
;;;539        /* 
;;;540         * Check that start address is aligned at 1024 byte (256 word) offset.
;;;541         * This is required for remapping the vector table later.
;;;542         */
;;;543        if ((uint32_t)go & 0x3FF)
000524  9800              LDR      r0,[sp,#0]
000526  f3c00009          UBFX     r0,r0,#0,#10
00052a  b100              CBZ      r0,|L1.1326|
;;;544          rc = ADDR_ERROR;
00052c  240d              MOVS     r4,#0xd
                  |L1.1326|
;;;545    		    
;;;546        /* Print command result on serial channel */
;;;547        sendline_crlf(i_to_a(rc,param_buf[ISP_PARAM_1],PARAM_SIZE));
00052e  48eb              LDR      r0,|L1.2268|
000530  220f              MOVS     r2,#0xf
000532  6841              LDR      r1,[r0,#4]  ; param_buf
000534  4620              MOV      r0,r4
000536  f7fffffe          BL       i_to_a
00053a  4605              MOV      r5,r0
00053c  f7fffffe          BL       sendline_crlf
;;;548        /* execute command only if all the parameters are ok */
;;;549        if(rc == CMD_SUCCESS)
000540  b944              CBNZ     r4,|L1.1364|
;;;550        {
;;;551    	  /* revert any peripheral changes */
;;;552          Timer_DeInit();
000542  f7fffffe          BL       Timer_DeInit
;;;553    	  /* Disable interrupts during vector table remap. */
;;;554          __disable_irq();
000546  b672              CPSID    i
;;;555          /*
;;;556           * Remap vector table by setting the Vector Table Offset Register (VTOR)
;;;557           * to the beginning of the application.
;;;558           */
;;;559          SCB->VTOR = go;
000548  49e5              LDR      r1,|L1.2272|
00054a  9800              LDR      r0,[sp,#0]
00054c  6008              STR      r0,[r1,#0]
;;;560    
;;;561          /* And here we go ... */
;;;562          boot_jump(go);
00054e  9800              LDR      r0,[sp,#0]
000550  f7fffffe          BL       boot_jump
                  |L1.1364|
;;;563        }
;;;564    } /* go */
000554  bd38              POP      {r3-r5,pc}
;;;565    
                          ENDP

                  unlock PROC
;;;566    
;;;567    void unlock(void)
000556  b538              PUSH     {r3-r5,lr}
;;;568    {
;;;569        int u_code;
;;;570        unsigned rc;
;;;571        rc = param_check(param_buf[ISP_PARAM_1],(unsigned *)&u_code,NO_PARAM_CHECK,NUL);
000558  49e0              LDR      r1,|L1.2268|
00055a  2300              MOVS     r3,#0
00055c  2269              MOVS     r2,#0x69
00055e  6848              LDR      r0,[r1,#4]  ; param_buf
000560  4669              MOV      r1,sp
000562  f7fffffe          BL       param_check
000566  4604              MOV      r4,r0
;;;572        /* execute command only if parameters are ok */
;;;573        if(rc == 0)
000568  b94c              CBNZ     r4,|L1.1406|
;;;574        {
;;;575            if(u_code == unlock_code)
00056a  f645215a          MOV      r1,#0x5a5a
00056e  9800              LDR      r0,[sp,#0]
000570  4288              CMP      r0,r1
000572  d103              BNE      |L1.1404|
;;;576            {
;;;577                lock = FALSE;    
000574  2000              MOVS     r0,#0
000576  49d8              LDR      r1,|L1.2264|
000578  6008              STR      r0,[r1,#0]  ; lock
00057a  e000              B        |L1.1406|
                  |L1.1404|
;;;578            }
;;;579            else
;;;580            {
;;;581                rc = INVALID_CODE;
00057c  2410              MOVS     r4,#0x10
                  |L1.1406|
;;;582            }
;;;583        }
;;;584        /* Print command result on serial channel */
;;;585        sendline_crlf(i_to_a(rc,param_buf[ISP_PARAM_1],PARAM_SIZE));
00057e  48d7              LDR      r0,|L1.2268|
000580  220f              MOVS     r2,#0xf
000582  6841              LDR      r1,[r0,#4]  ; param_buf
000584  4620              MOV      r0,r4
000586  f7fffffe          BL       i_to_a
00058a  4605              MOV      r5,r0
00058c  f7fffffe          BL       sendline_crlf
;;;586    } /* unlock */
000590  bd38              POP      {r3-r5,pc}
;;;587    
                          ENDP

                  prepare_sector PROC
;;;588    void prepare_sector(void)
000592  b510              PUSH     {r4,lr}
;;;589    {
;;;590        /* Convert ascii string to integer. Do not validate sector numbers as it is
;;;591           done in IAP prepare sector for write. Parameter type is deliberately 
;;;592           set to NO_PARAM_CHECK so that param_check function just converts ascii 
;;;593           to integer 
;;;594        */
;;;595        result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_1], \
000594  49d1              LDR      r1,|L1.2268|
000596  2300              MOVS     r3,#0
000598  2269              MOVS     r2,#0x69
00059a  6848              LDR      r0,[r1,#4]  ; param_buf
00059c  49d1              LDR      r1,|L1.2276|
00059e  f7fffffe          BL       param_check
0005a2  49d1              LDR      r1,|L1.2280|
0005a4  6008              STR      r0,[r1,#0]  ; result_table
;;;596        &param_table[IAP_PARAM_0],NO_PARAM_CHECK,NUL);
;;;597    
;;;598        if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
0005a6  4608              MOV      r0,r1
0005a8  6800              LDR      r0,[r0,#0]  ; result_table
0005aa  b948              CBNZ     r0,|L1.1472|
;;;599        {
;;;600            result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_2], \
0005ac  49cb              LDR      r1,|L1.2268|
0005ae  2300              MOVS     r3,#0
0005b0  2269              MOVS     r2,#0x69
0005b2  6888              LDR      r0,[r1,#8]  ; param_buf
0005b4  49cb              LDR      r1,|L1.2276|
0005b6  1d09              ADDS     r1,r1,#4
0005b8  f7fffffe          BL       param_check
0005bc  49ca              LDR      r1,|L1.2280|
0005be  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.1472|
;;;601            &param_table[IAP_PARAM_1],NO_PARAM_CHECK,NUL);
;;;602        }
;;;603            
;;;604        if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
0005c0  48c9              LDR      r0,|L1.2280|
0005c2  6800              LDR      r0,[r0,#0]  ; result_table
0005c4  b940              CBNZ     r0,|L1.1496|
;;;605        {
;;;606            param_table[IAP_CMD_CODE] = PREPARE_SECTOR_FOR_WRITE;
0005c6  2032              MOVS     r0,#0x32
0005c8  49c6              LDR      r1,|L1.2276|
0005ca  1f09              SUBS     r1,r1,#4
0005cc  6008              STR      r0,[r1,#0]  ; param_table
;;;607            iap_entry(param_table,result_table);
0005ce  49c6              LDR      r1,|L1.2280|
0005d0  48c4              LDR      r0,|L1.2276|
0005d2  1f00              SUBS     r0,r0,#4
0005d4  f7fffffe          BL       iap_entry
                  |L1.1496|
;;;608        }
;;;609        sendline_crlf(i_to_a(result_table[IAP_STAT_CODE],param_buf[ISP_PARAM_1], \
0005d8  4ac0              LDR      r2,|L1.2268|
0005da  6851              LDR      r1,[r2,#4]  ; param_buf
0005dc  4ac2              LDR      r2,|L1.2280|
0005de  6810              LDR      r0,[r2,#0]  ; result_table
0005e0  220f              MOVS     r2,#0xf
0005e2  f7fffffe          BL       i_to_a
0005e6  4604              MOV      r4,r0
0005e8  f7fffffe          BL       sendline_crlf
;;;610        PARAM_SIZE));
;;;611    } /* prepare_sector */
0005ec  bd10              POP      {r4,pc}
;;;612    
                          ENDP

                  copy PROC
;;;613    void copy(void)
0005ee  b510              PUSH     {r4,lr}
;;;614    {
;;;615        if(lock == TRUE)
0005f0  48b9              LDR      r0,|L1.2264|
0005f2  6800              LDR      r0,[r0,#0]  ; lock
0005f4  2801              CMP      r0,#1
0005f6  d109              BNE      |L1.1548|
;;;616        {
;;;617            sendline_crlf(i_to_a(CMD_LOCKED,param_buf[ISP_PARAM_1],PARAM_SIZE));
0005f8  48b8              LDR      r0,|L1.2268|
0005fa  220f              MOVS     r2,#0xf
0005fc  6841              LDR      r1,[r0,#4]  ; param_buf
0005fe  4610              MOV      r0,r2
000600  f7fffffe          BL       i_to_a
000604  4604              MOV      r4,r0
000606  f7fffffe          BL       sendline_crlf
00060a  e049              B        |L1.1696|
                  |L1.1548|
;;;618        }
;;;619        else
;;;620        {
;;;621        /* Convert ascii string to integer. Do not validate sector numbers as it is
;;;622        done in IAP copy RAM to FLASH.Parameter type is deliberately 
;;;623        set to NO_PARAM_CHECK so that param_check function just converts ascii to integer
;;;624        */
;;;625            result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_1], \
00060c  49b3              LDR      r1,|L1.2268|
00060e  2300              MOVS     r3,#0
000610  2269              MOVS     r2,#0x69
000612  6848              LDR      r0,[r1,#4]  ; param_buf
000614  49b3              LDR      r1,|L1.2276|
000616  f7fffffe          BL       param_check
00061a  49b3              LDR      r1,|L1.2280|
00061c  6008              STR      r0,[r1,#0]  ; result_table
;;;626            &param_table[IAP_PARAM_0],NO_PARAM_CHECK,NUL);
;;;627    
;;;628            if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
00061e  4608              MOV      r0,r1
000620  6800              LDR      r0,[r0,#0]  ; result_table
000622  b948              CBNZ     r0,|L1.1592|
;;;629            {
;;;630                result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_2], \
000624  49ad              LDR      r1,|L1.2268|
000626  2300              MOVS     r3,#0
000628  2269              MOVS     r2,#0x69
00062a  6888              LDR      r0,[r1,#8]  ; param_buf
00062c  49ad              LDR      r1,|L1.2276|
00062e  1d09              ADDS     r1,r1,#4
000630  f7fffffe          BL       param_check
000634  49ac              LDR      r1,|L1.2280|
000636  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.1592|
;;;631                &param_table[IAP_PARAM_1],NO_PARAM_CHECK,NUL);
;;;632            }
;;;633    
;;;634            if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
000638  48ab              LDR      r0,|L1.2280|
00063a  6800              LDR      r0,[r0,#0]  ; result_table
00063c  b948              CBNZ     r0,|L1.1618|
;;;635            {
;;;636                result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_3], \
00063e  49a7              LDR      r1,|L1.2268|
000640  2300              MOVS     r3,#0
000642  2269              MOVS     r2,#0x69
000644  68c8              LDR      r0,[r1,#0xc]  ; param_buf
000646  49a7              LDR      r1,|L1.2276|
000648  3108              ADDS     r1,r1,#8
00064a  f7fffffe          BL       param_check
00064e  49a6              LDR      r1,|L1.2280|
000650  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.1618|
;;;637                &param_table[IAP_PARAM_2],NO_PARAM_CHECK,NUL);
;;;638            }
;;;639    
;;;640            /* Do not allow write to USER Start sector */
;;;641            if( (crp_after_reset == CRP1) )
000652  48a6              LDR      r0,|L1.2284|
000654  6800              LDR      r0,[r0,#0]  ; crp_after_reset
000656  49a6              LDR      r1,|L1.2288|
000658  4288              CMP      r0,r1
00065a  d108              BNE      |L1.1646|
;;;642            {
;;;643                if( (param_table[IAP_PARAM_0] < (USER_START_SECTOR_ADDRESS+USER_START_SECTOR_SIZE)) )
00065c  48a1              LDR      r0,|L1.2276|
00065e  1f00              SUBS     r0,r0,#4
000660  6840              LDR      r0,[r0,#4]  ; param_table
000662  f5b05f40          CMP      r0,#0x3000
000666  d202              BCS      |L1.1646|
;;;644                {
;;;645                    result_table[IAP_STAT_CODE] = CODE_READ_PROTECTION_ENABLED;
000668  2013              MOVS     r0,#0x13
00066a  499f              LDR      r1,|L1.2280|
00066c  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.1646|
;;;646                }
;;;647            }
;;;648    
;;;649            if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
00066e  489e              LDR      r0,|L1.2280|
000670  6800              LDR      r0,[r0,#0]  ; result_table
000672  b958              CBNZ     r0,|L1.1676|
;;;650            {
;;;651                param_table[IAP_CMD_CODE] = COPY_RAM_TO_FLASH;
000674  2033              MOVS     r0,#0x33
000676  499b              LDR      r1,|L1.2276|
000678  1f09              SUBS     r1,r1,#4
00067a  6008              STR      r0,[r1,#0]  ; param_table
;;;652                param_table[IAP_PARAM_3] = fcclk_KHz;
00067c  f44f407a          MOV      r0,#0xfa00
000680  6108              STR      r0,[r1,#0x10]  ; param_table
;;;653                iap_entry(param_table,result_table);
000682  4999              LDR      r1,|L1.2280|
000684  4897              LDR      r0,|L1.2276|
000686  1f00              SUBS     r0,r0,#4
000688  f7fffffe          BL       iap_entry
                  |L1.1676|
;;;654            }
;;;655            sendline_crlf(i_to_a(result_table[IAP_STAT_CODE],param_buf[ISP_PARAM_1], \
00068c  4a93              LDR      r2,|L1.2268|
00068e  6851              LDR      r1,[r2,#4]  ; param_buf
000690  4a95              LDR      r2,|L1.2280|
000692  6810              LDR      r0,[r2,#0]  ; result_table
000694  220f              MOVS     r2,#0xf
000696  f7fffffe          BL       i_to_a
00069a  4604              MOV      r4,r0
00069c  f7fffffe          BL       sendline_crlf
                  |L1.1696|
;;;656            PARAM_SIZE));
;;;657        }
;;;658    } /* copy */
0006a0  bd10              POP      {r4,pc}
;;;659    
                          ENDP

                  erase PROC
;;;660    void erase(void)
0006a2  b510              PUSH     {r4,lr}
;;;661    {
;;;662        if(lock == TRUE)
0006a4  488c              LDR      r0,|L1.2264|
0006a6  6800              LDR      r0,[r0,#0]  ; lock
0006a8  2801              CMP      r0,#1
0006aa  d109              BNE      |L1.1728|
;;;663        {
;;;664            sendline_crlf(i_to_a(CMD_LOCKED,param_buf[ISP_PARAM_1],PARAM_SIZE));
0006ac  488b              LDR      r0,|L1.2268|
0006ae  220f              MOVS     r2,#0xf
0006b0  6841              LDR      r1,[r0,#4]  ; param_buf
0006b2  4610              MOV      r0,r2
0006b4  f7fffffe          BL       i_to_a
0006b8  4604              MOV      r4,r0
0006ba  f7fffffe          BL       sendline_crlf
0006be  e066              B        |L1.1934|
                  |L1.1728|
;;;665        }
;;;666        else
;;;667        {
;;;668        /* Convert ascii string to integer. Do not validate sector numbers as it is
;;;669           done in IAP erase sector. Parameter type is deliberately 
;;;670           set to NO_PARAM_CHECK so that param_check function just converts ascii to integer 
;;;671        */
;;;672            result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_1], \
0006c0  4986              LDR      r1,|L1.2268|
0006c2  2300              MOVS     r3,#0
0006c4  2269              MOVS     r2,#0x69
0006c6  6848              LDR      r0,[r1,#4]  ; param_buf
0006c8  4986              LDR      r1,|L1.2276|
0006ca  f7fffffe          BL       param_check
0006ce  4986              LDR      r1,|L1.2280|
0006d0  6008              STR      r0,[r1,#0]  ; result_table
;;;673            &param_table[IAP_PARAM_0],NO_PARAM_CHECK,NUL);
;;;674    
;;;675            if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
0006d2  4608              MOV      r0,r1
0006d4  6800              LDR      r0,[r0,#0]  ; result_table
0006d6  b948              CBNZ     r0,|L1.1772|
;;;676            {
;;;677                result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_2], \
0006d8  4980              LDR      r1,|L1.2268|
0006da  2300              MOVS     r3,#0
0006dc  2269              MOVS     r2,#0x69
0006de  6888              LDR      r0,[r1,#8]  ; param_buf
0006e0  4980              LDR      r1,|L1.2276|
0006e2  1d09              ADDS     r1,r1,#4
0006e4  f7fffffe          BL       param_check
0006e8  497f              LDR      r1,|L1.2280|
0006ea  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.1772|
;;;678                &param_table[IAP_PARAM_1],NO_PARAM_CHECK,NUL);
;;;679            }
;;;680    
;;;681            /* If code read protection level 2 or 3 is enabled allow erase command only when
;;;682               all sectors are selected for erase */
;;;683            if( (crp_after_reset == CRP2) ||                     \
0006ec  487f              LDR      r0,|L1.2284|
0006ee  6800              LDR      r0,[r0,#0]  ; crp_after_reset
0006f0  4980              LDR      r1,|L1.2292|
0006f2  4288              CMP      r0,r1
0006f4  d005              BEQ      |L1.1794|
;;;684                (crp_after_reset == CRP3) 
0006f6  487d              LDR      r0,|L1.2284|
0006f8  6800              LDR      r0,[r0,#0]  ; crp_after_reset
0006fa  ea4f4131          ROR      r1,r1,#16
0006fe  4288              CMP      r0,r1
000700  d10d              BNE      |L1.1822|
                  |L1.1794|
;;;685               )
;;;686            {
;;;687                if( (param_table[IAP_PARAM_0] != USER_START_SECTOR) ||                         \
000702  4878              LDR      r0,|L1.2276|
000704  1f00              SUBS     r0,r0,#4
000706  6840              LDR      r0,[r0,#4]  ; param_table
000708  2802              CMP      r0,#2
00070a  d104              BNE      |L1.1814|
;;;688                    (param_table[IAP_PARAM_1] != USER_END_SECTOR)
00070c  4875              LDR      r0,|L1.2276|
00070e  1f00              SUBS     r0,r0,#4
000710  6880              LDR      r0,[r0,#8]  ; param_table
000712  281d              CMP      r0,#0x1d
000714  d015              BEQ      |L1.1858|
                  |L1.1814|
;;;689                  )
;;;690                {
;;;691                    result_table[IAP_STAT_CODE] = CODE_READ_PROTECTION_ENABLED;
000716  2013              MOVS     r0,#0x13
000718  4973              LDR      r1,|L1.2280|
00071a  6008              STR      r0,[r1,#0]  ; result_table
00071c  e011              B        |L1.1858|
                  |L1.1822|
;;;692                }
;;;693            }
;;;694    
;;;695            /* If code read protection level 1 is enabled allow erase command only when
;;;696               user start sector is NOT selected for erase */
;;;697            else if( (crp_after_reset == CRP1) )
00071e  4873              LDR      r0,|L1.2284|
000720  6800              LDR      r0,[r0,#0]  ; crp_after_reset
000722  4973              LDR      r1,|L1.2288|
000724  4288              CMP      r0,r1
000726  d10c              BNE      |L1.1858|
;;;698            {
;;;699               if( (param_table[IAP_PARAM_0] == USER_START_SECTOR) &&                         \
000728  486e              LDR      r0,|L1.2276|
00072a  1f00              SUBS     r0,r0,#4
00072c  6840              LDR      r0,[r0,#4]  ; param_table
00072e  2802              CMP      r0,#2
000730  d107              BNE      |L1.1858|
;;;700                   (param_table[IAP_PARAM_1] != USER_END_SECTOR)
000732  486c              LDR      r0,|L1.2276|
000734  1f00              SUBS     r0,r0,#4
000736  6880              LDR      r0,[r0,#8]  ; param_table
000738  281d              CMP      r0,#0x1d
00073a  d002              BEQ      |L1.1858|
;;;701                 )
;;;702                {
;;;703                    result_table[IAP_STAT_CODE] = CODE_READ_PROTECTION_ENABLED;
00073c  2013              MOVS     r0,#0x13
00073e  496a              LDR      r1,|L1.2280|
000740  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.1858|
;;;704                }
;;;705            }
;;;706    
;;;707            if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
000742  4869              LDR      r0,|L1.2280|
000744  6800              LDR      r0,[r0,#0]  ; result_table
000746  b958              CBNZ     r0,|L1.1888|
;;;708            {
;;;709                param_table[IAP_CMD_CODE] = ERASE_SECTOR;
000748  2034              MOVS     r0,#0x34
00074a  4966              LDR      r1,|L1.2276|
00074c  1f09              SUBS     r1,r1,#4
00074e  6008              STR      r0,[r1,#0]  ; param_table
;;;710                param_table[IAP_PARAM_2] = fcclk_KHz;
000750  f44f407a          MOV      r0,#0xfa00
000754  60c8              STR      r0,[r1,#0xc]  ; param_table
;;;711                iap_entry(param_table,result_table);
000756  4964              LDR      r1,|L1.2280|
000758  4862              LDR      r0,|L1.2276|
00075a  1f00              SUBS     r0,r0,#4
00075c  f7fffffe          BL       iap_entry
                  |L1.1888|
;;;712            }
;;;713            /* Update code protection status if all sectors are erased */
;;;714            if( (param_table[IAP_PARAM_0] == USER_START_SECTOR) &&                         \
000760  4860              LDR      r0,|L1.2276|
000762  1f00              SUBS     r0,r0,#4
000764  6840              LDR      r0,[r0,#4]  ; param_table
000766  2802              CMP      r0,#2
000768  d107              BNE      |L1.1914|
;;;715                (param_table[IAP_PARAM_1] == USER_END_SECTOR)
00076a  485e              LDR      r0,|L1.2276|
00076c  1f00              SUBS     r0,r0,#4
00076e  6880              LDR      r0,[r0,#8]  ; param_table
000770  281d              CMP      r0,#0x1d
000772  d102              BNE      |L1.1914|
;;;716              )
;;;717            {
;;;718                crp_after_reset = NOCRP;       
000774  4860              LDR      r0,|L1.2296|
000776  495d              LDR      r1,|L1.2284|
000778  6008              STR      r0,[r1,#0]  ; crp_after_reset
                  |L1.1914|
;;;719            }
;;;720            sendline_crlf(i_to_a(result_table[IAP_STAT_CODE],param_buf[ISP_PARAM_1], \
00077a  4a58              LDR      r2,|L1.2268|
00077c  6851              LDR      r1,[r2,#4]  ; param_buf
00077e  4a5a              LDR      r2,|L1.2280|
000780  6810              LDR      r0,[r2,#0]  ; result_table
000782  220f              MOVS     r2,#0xf
000784  f7fffffe          BL       i_to_a
000788  4604              MOV      r4,r0
00078a  f7fffffe          BL       sendline_crlf
                  |L1.1934|
;;;721            PARAM_SIZE));
;;;722        }
;;;723    } /* erase */
00078e  bd10              POP      {r4,pc}
;;;724    
                          ENDP

                  blank_check PROC
;;;725    void blank_check(void)
000790  b510              PUSH     {r4,lr}
;;;726    {
;;;727        /* Convert ascii string to integer. Do not validate sector numbers as it is
;;;728           done in IAP blank check sector. Parameter type is deliberately 
;;;729           set to NO_PARAM_CHECK so that param_check function just converts ascii 
;;;730           to integer
;;;731        */
;;;732        result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_1], \
000792  4952              LDR      r1,|L1.2268|
000794  2300              MOVS     r3,#0
000796  2269              MOVS     r2,#0x69
000798  6848              LDR      r0,[r1,#4]  ; param_buf
00079a  4952              LDR      r1,|L1.2276|
00079c  f7fffffe          BL       param_check
0007a0  4951              LDR      r1,|L1.2280|
0007a2  6008              STR      r0,[r1,#0]  ; result_table
;;;733        &param_table[IAP_PARAM_0],NO_PARAM_CHECK,NUL);
;;;734        
;;;735        if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
0007a4  4608              MOV      r0,r1
0007a6  6800              LDR      r0,[r0,#0]  ; result_table
0007a8  b948              CBNZ     r0,|L1.1982|
;;;736        {
;;;737            result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_2], \
0007aa  494c              LDR      r1,|L1.2268|
0007ac  2300              MOVS     r3,#0
0007ae  2269              MOVS     r2,#0x69
0007b0  6888              LDR      r0,[r1,#8]  ; param_buf
0007b2  494c              LDR      r1,|L1.2276|
0007b4  1d09              ADDS     r1,r1,#4
0007b6  f7fffffe          BL       param_check
0007ba  494b              LDR      r1,|L1.2280|
0007bc  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.1982|
;;;738            &param_table[IAP_PARAM_1],NO_PARAM_CHECK,NUL);
;;;739        }    
;;;740        
;;;741        if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
0007be  484a              LDR      r0,|L1.2280|
0007c0  6800              LDR      r0,[r0,#0]  ; result_table
0007c2  b940              CBNZ     r0,|L1.2006|
;;;742        {
;;;743            param_table[IAP_CMD_CODE] = BLANK_CHECK_SECTOR;
0007c4  2035              MOVS     r0,#0x35
0007c6  4947              LDR      r1,|L1.2276|
0007c8  1f09              SUBS     r1,r1,#4
0007ca  6008              STR      r0,[r1,#0]  ; param_table
;;;744            iap_entry(param_table,result_table);
0007cc  4946              LDR      r1,|L1.2280|
0007ce  4845              LDR      r0,|L1.2276|
0007d0  1f00              SUBS     r0,r0,#4
0007d2  f7fffffe          BL       iap_entry
                  |L1.2006|
;;;745        }
;;;746        sendline_crlf(i_to_a(result_table[IAP_STAT_CODE],param_buf[ISP_PARAM_1], \
0007d6  4a41              LDR      r2,|L1.2268|
0007d8  6851              LDR      r1,[r2,#4]  ; param_buf
0007da  4a43              LDR      r2,|L1.2280|
0007dc  6810              LDR      r0,[r2,#0]  ; result_table
0007de  220f              MOVS     r2,#0xf
0007e0  f7fffffe          BL       i_to_a
0007e4  4604              MOV      r4,r0
0007e6  f7fffffe          BL       sendline_crlf
;;;747        PARAM_SIZE));
;;;748        if(result_table[IAP_STAT_CODE] == SECTOR_NOT_BLANK)
0007ea  483f              LDR      r0,|L1.2280|
0007ec  6800              LDR      r0,[r0,#0]  ; result_table
0007ee  2808              CMP      r0,#8
0007f0  d127              BNE      |L1.2114|
;;;749        {
;;;750            if( ( (crp_after_reset == CRP1)       ||       \
0007f2  483e              LDR      r0,|L1.2284|
0007f4  6800              LDR      r0,[r0,#0]  ; crp_after_reset
0007f6  493e              LDR      r1,|L1.2288|
0007f8  4288              CMP      r0,r1
0007fa  d00a              BEQ      |L1.2066|
;;;751                  (crp_after_reset == CRP2)       ||       \
0007fc  483b              LDR      r0,|L1.2284|
0007fe  6800              LDR      r0,[r0,#0]  ; crp_after_reset
000800  493c              LDR      r1,|L1.2292|
000802  4288              CMP      r0,r1
000804  d005              BEQ      |L1.2066|
;;;752                  (crp_after_reset == CRP3) )              \
000806  4839              LDR      r0,|L1.2284|
000808  6800              LDR      r0,[r0,#0]  ; crp_after_reset
00080a  ea4f4131          ROR      r1,r1,#16
00080e  4288              CMP      r0,r1
000810  d103              BNE      |L1.2074|
                  |L1.2066|
;;;753              )
;;;754            {
;;;755                result_table[IAP_RESULT_0]=0;
000812  2000              MOVS     r0,#0
000814  4934              LDR      r1,|L1.2280|
000816  6048              STR      r0,[r1,#4]  ; result_table
;;;756                result_table[IAP_RESULT_1]=0;
000818  6088              STR      r0,[r1,#8]  ; result_table
                  |L1.2074|
;;;757            }
;;;758            sendline_crlf(i_to_a(result_table[IAP_RESULT_0],param_buf[ISP_PARAM_1], \
00081a  4a30              LDR      r2,|L1.2268|
00081c  6851              LDR      r1,[r2,#4]  ; param_buf
00081e  4a32              LDR      r2,|L1.2280|
000820  6850              LDR      r0,[r2,#4]  ; result_table
000822  220f              MOVS     r2,#0xf
000824  f7fffffe          BL       i_to_a
000828  4604              MOV      r4,r0
00082a  f7fffffe          BL       sendline_crlf
;;;759            PARAM_SIZE));
;;;760            sendline_crlf(i_to_a(result_table[IAP_RESULT_1],param_buf[ISP_PARAM_1], \
00082e  4a2b              LDR      r2,|L1.2268|
000830  6851              LDR      r1,[r2,#4]  ; param_buf
000832  4a2d              LDR      r2,|L1.2280|
000834  6890              LDR      r0,[r2,#8]  ; result_table
000836  220f              MOVS     r2,#0xf
000838  f7fffffe          BL       i_to_a
00083c  4604              MOV      r4,r0
00083e  f7fffffe          BL       sendline_crlf
                  |L1.2114|
;;;761            PARAM_SIZE));
;;;762        }
;;;763    } /* blank_check */
000842  bd10              POP      {r4,pc}
;;;764    
                          ENDP

                  compare_mem PROC
;;;765    void compare_mem(void)
000844  b510              PUSH     {r4,lr}
;;;766    {
;;;767        /* Convert ascii string to integer. Do not validate address & count as it is
;;;768        done in IAP COMPARE command.Parameter type is deliberately 
;;;769        set to NO_PARAM_CHECK so that param_check function just converts ascii to integer
;;;770        */
;;;771        result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_1], \
000846  4925              LDR      r1,|L1.2268|
000848  2300              MOVS     r3,#0
00084a  2269              MOVS     r2,#0x69
00084c  6848              LDR      r0,[r1,#4]  ; param_buf
00084e  4925              LDR      r1,|L1.2276|
000850  f7fffffe          BL       param_check
000854  4924              LDR      r1,|L1.2280|
000856  6008              STR      r0,[r1,#0]  ; result_table
;;;772        &param_table[IAP_PARAM_0],NO_PARAM_CHECK,NUL);
;;;773    
;;;774        if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
000858  4608              MOV      r0,r1
00085a  6800              LDR      r0,[r0,#0]  ; result_table
00085c  b948              CBNZ     r0,|L1.2162|
;;;775        {
;;;776            result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_2], \
00085e  491f              LDR      r1,|L1.2268|
000860  2300              MOVS     r3,#0
000862  2269              MOVS     r2,#0x69
000864  6888              LDR      r0,[r1,#8]  ; param_buf
000866  491f              LDR      r1,|L1.2276|
000868  1d09              ADDS     r1,r1,#4
00086a  f7fffffe          BL       param_check
00086e  491e              LDR      r1,|L1.2280|
000870  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.2162|
;;;777            &param_table[IAP_PARAM_1],NO_PARAM_CHECK,NUL);
;;;778        }
;;;779    
;;;780        if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
000872  481d              LDR      r0,|L1.2280|
000874  6800              LDR      r0,[r0,#0]  ; result_table
000876  b948              CBNZ     r0,|L1.2188|
;;;781        {
;;;782            result_table[IAP_STAT_CODE] = param_check(param_buf[ISP_PARAM_3], \
000878  4918              LDR      r1,|L1.2268|
00087a  2300              MOVS     r3,#0
00087c  2269              MOVS     r2,#0x69
00087e  68c8              LDR      r0,[r1,#0xc]  ; param_buf
000880  4918              LDR      r1,|L1.2276|
000882  3108              ADDS     r1,r1,#8
000884  f7fffffe          BL       param_check
000888  4917              LDR      r1,|L1.2280|
00088a  6008              STR      r0,[r1,#0]  ; result_table
                  |L1.2188|
;;;783            &param_table[IAP_PARAM_2],NO_PARAM_CHECK,NUL);
;;;784        }
;;;785    
;;;786        if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
00088c  4816              LDR      r0,|L1.2280|
00088e  6800              LDR      r0,[r0,#0]  ; result_table
000890  b940              CBNZ     r0,|L1.2212|
;;;787        {
;;;788            param_table[IAP_CMD_CODE] = COMPARE;
000892  2038              MOVS     r0,#0x38
000894  4913              LDR      r1,|L1.2276|
000896  1f09              SUBS     r1,r1,#4
000898  6008              STR      r0,[r1,#0]  ; param_table
;;;789            iap_entry(param_table,result_table);
00089a  4913              LDR      r1,|L1.2280|
00089c  4811              LDR      r0,|L1.2276|
00089e  1f00              SUBS     r0,r0,#4
0008a0  f7fffffe          BL       iap_entry
                  |L1.2212|
;;;790        }
;;;791        sendline_crlf(i_to_a(result_table[IAP_STAT_CODE],param_buf[ISP_PARAM_1], \
0008a4  4a0d              LDR      r2,|L1.2268|
0008a6  6851              LDR      r1,[r2,#4]  ; param_buf
0008a8  4a0f              LDR      r2,|L1.2280|
0008aa  6810              LDR      r0,[r2,#0]  ; result_table
0008ac  220f              MOVS     r2,#0xf
0008ae  f7fffffe          BL       i_to_a
0008b2  4604              MOV      r4,r0
0008b4  f7fffffe          BL       sendline_crlf
;;;792        PARAM_SIZE));
;;;793        if(result_table[IAP_STAT_CODE] == COMPARE_ERROR)
0008b8  480b              LDR      r0,|L1.2280|
0008ba  6800              LDR      r0,[r0,#0]  ; result_table
0008bc  280a              CMP      r0,#0xa
0008be  d120              BNE      |L1.2306|
;;;794        {
;;;795            sendline_crlf(i_to_a(result_table[IAP_RESULT_0],param_buf[ISP_PARAM_1], \
0008c0  4a06              LDR      r2,|L1.2268|
0008c2  6851              LDR      r1,[r2,#4]  ; param_buf
0008c4  4a08              LDR      r2,|L1.2280|
0008c6  6850              LDR      r0,[r2,#4]  ; result_table
0008c8  220f              MOVS     r2,#0xf
0008ca  f7fffffe          BL       i_to_a
0008ce  e015              B        |L1.2300|
                  |L1.2256|
                          DCD      ||ok||
                  |L1.2260|
                          DCD      cmd_buf
                  |L1.2264|
                          DCD      lock
                  |L1.2268|
                          DCD      param_buf
                  |L1.2272|
                          DCD      0xe000ed08
                  |L1.2276|
                          DCD      param_table+0x4
                  |L1.2280|
                          DCD      result_table
                  |L1.2284|
                          DCD      crp_after_reset
                  |L1.2288|
                          DCD      0x12345678
                  |L1.2292|
                          DCD      0x87654321
                  |L1.2296|
                          DCD      0x11223344
                  |L1.2300|
0008fc  4604              MOV      r4,r0
0008fe  f7fffffe          BL       sendline_crlf
                  |L1.2306|
;;;796            PARAM_SIZE));
;;;797        }
;;;798    }
000902  bd10              POP      {r4,pc}
;;;799    
                          ENDP

                  tokenize PROC
;;;800    int tokenize(char * in_buf,int no_of_chars_in_inbuf,char * out_buf[],   \
000904  e92d43f0          PUSH     {r4-r9,lr}
;;;801                 int max_tokens,int max_chars_per_token )
;;;802    {
000908  4604              MOV      r4,r0
00090a  468c              MOV      r12,r1
00090c  4615              MOV      r5,r2
00090e  4698              MOV      r8,r3
000910  9f07              LDR      r7,[sp,#0x1c]
;;;803        int i,token_count=0,pos=0, chars_in_token=0;
000912  2200              MOVS     r2,#0
000914  2300              MOVS     r3,#0
000916  2600              MOVS     r6,#0
;;;804    
;;;805        if(in_buf[0] == NUL)
000918  7820              LDRB     r0,[r4,#0]
00091a  b910              CBNZ     r0,|L1.2338|
;;;806        {
;;;807            return(0);
00091c  2000              MOVS     r0,#0
                  |L1.2334|
;;;808        }
;;;809        for(i=0;i<=no_of_chars_in_inbuf;i++)
;;;810        {
;;;811            if( token_count+1 > max_tokens)
;;;812            {
;;;813                return(token_count+1);
;;;814            }
;;;815            
;;;816            if( (in_buf[i] != SP)  &&                                      \
;;;817                (chars_in_token < (max_chars_per_token -2)) )
;;;818            {
;;;819                *(out_buf[token_count]+pos) = in_buf[i];
;;;820                pos++;
;;;821                chars_in_token++;
;;;822            }
;;;823            else if( (in_buf[i+1] != SP) ||                                \
;;;824                     (chars_in_token == (max_chars_per_token -2)) )
;;;825            {
;;;826                *(out_buf[token_count]+pos) = NUL;
;;;827                token_count++;
;;;828                pos=0;
;;;829                chars_in_token=0;
;;;830            }            
;;;831        }
;;;832        return(token_count+1);
;;;833    } /* tokenize */
00091e  e8bd83f0          POP      {r4-r9,pc}
                  |L1.2338|
000922  2100              MOVS     r1,#0                 ;809
000924  e021              B        |L1.2410|
                  |L1.2342|
000926  1c50              ADDS     r0,r2,#1              ;811
000928  4540              CMP      r0,r8                 ;811
00092a  dd00              BLE      |L1.2350|
00092c  e7f7              B        |L1.2334|
                  |L1.2350|
00092e  5c60              LDRB     r0,[r4,r1]            ;816
000930  2820              CMP      r0,#0x20              ;816
000932  d00a              BEQ      |L1.2378|
000934  1eb8              SUBS     r0,r7,#2              ;817
000936  42b0              CMP      r0,r6                 ;817
000938  dd07              BLE      |L1.2378|
00093a  5c60              LDRB     r0,[r4,r1]            ;819
00093c  f8559022          LDR      r9,[r5,r2,LSL #2]     ;819
000940  f8090003          STRB     r0,[r9,r3]            ;819
000944  1c5b              ADDS     r3,r3,#1              ;820
000946  1c76              ADDS     r6,r6,#1              ;821
000948  e00e              B        |L1.2408|
                  |L1.2378|
00094a  1c48              ADDS     r0,r1,#1              ;823
00094c  5c20              LDRB     r0,[r4,r0]            ;823
00094e  2820              CMP      r0,#0x20              ;823
000950  d102              BNE      |L1.2392|
000952  1eb8              SUBS     r0,r7,#2              ;824
000954  42b0              CMP      r0,r6                 ;824
000956  d107              BNE      |L1.2408|
                  |L1.2392|
000958  2000              MOVS     r0,#0                 ;826
00095a  f8559022          LDR      r9,[r5,r2,LSL #2]     ;826
00095e  f8090003          STRB     r0,[r9,r3]            ;826
000962  1c52              ADDS     r2,r2,#1              ;827
000964  2300              MOVS     r3,#0                 ;828
000966  2600              MOVS     r6,#0                 ;829
                  |L1.2408|
000968  1c49              ADDS     r1,r1,#1              ;809
                  |L1.2410|
00096a  4561              CMP      r1,r12                ;809
00096c  dddb              BLE      |L1.2342|
00096e  1c50              ADDS     r0,r2,#1              ;832
000970  e7d5              B        |L1.2334|
;;;834    
                          ENDP

                  enable_interrupts PROC
;;;835    void enable_interrupts(unsigned interrupts)
000972  b662              CPSIE    i
;;;836    {
;;;837      __enable_irq();
;;;838    }
000974  4770              BX       lr
;;;839    
                          ENDP

                  disable_interrupts PROC
;;;840    void disable_interrupts(unsigned interrupts)
000976  b672              CPSID    i
;;;841    {
;;;842      __disable_irq();
;;;843    }
000978  4770              BX       lr
;;;844    
                          ENDP

                  execute_user_code PROC
;;;845    void execute_user_code(void)
00097a  b510              PUSH     {r4,lr}
;;;846    {
;;;847      __disable_irq();
00097c  b672              CPSID    i
;;;848      boot_jump(USER_START_SECTOR_ADDRESS);
00097e  f44f5000          MOV      r0,#0x2000
000982  f7fffffe          BL       boot_jump
;;;849    }
000986  bd10              POP      {r4,pc}
;;;850    
                          ENDP

                  user_code_present PROC
;;;851    unsigned user_code_present(void)
000988  b510              PUSH     {r4,lr}
;;;852    {
;;;853        param_table[IAP_CMD_CODE] = BLANK_CHECK_SECTOR;
00098a  2035              MOVS     r0,#0x35
00098c  49d0              LDR      r1,|L1.3280|
00098e  6008              STR      r0,[r1,#0]  ; param_table
;;;854        param_table[IAP_PARAM_0] = USER_START_SECTOR;
000990  2002              MOVS     r0,#2
000992  6048              STR      r0,[r1,#4]  ; param_table
;;;855        param_table[IAP_PARAM_1] = USER_START_SECTOR;
000994  6088              STR      r0,[r1,#8]  ; param_table
;;;856        iap_entry(param_table,result_table);
000996  49cf              LDR      r1,|L1.3284|
000998  48cd              LDR      r0,|L1.3280|
00099a  f7fffffe          BL       iap_entry
;;;857    	if( result_table[IAP_STAT_CODE] == CMD_SUCCESS )
00099e  48cd              LDR      r0,|L1.3284|
0009a0  6800              LDR      r0,[r0,#0]  ; result_table
0009a2  b908              CBNZ     r0,|L1.2472|
;;;858    	{
;;;859    	    return (FALSE);
0009a4  2000              MOVS     r0,#0
                  |L1.2470|
;;;860    	}
;;;861    	else
;;;862    	{
;;;863    	    return (TRUE);
;;;864    	}
;;;865    }
0009a6  bd10              POP      {r4,pc}
                  |L1.2472|
0009a8  2001              MOVS     r0,#1                 ;863
0009aa  e7fc              B        |L1.2470|
;;;866    
                          ENDP

                  check_isp_entry_pin PROC
;;;867    unsigned check_isp_entry_pin(void)
0009ac  48ca              LDR      r0,|L1.3288|
;;;868    {
;;;869      int i;
;;;870      /* disable internal pull-up */
;;;871      *(volatile unsigned *)ISP_ENTRY_GPIO_MODE_REG |= 0x3<<(ISP_ENTRY_PIN*2);
0009ae  6c00              LDR      r0,[r0,#0x40]
0009b0  f4401040          ORR      r0,r0,#0x300000
0009b4  4ac8              LDR      r2,|L1.3288|
0009b6  6410              STR      r0,[r2,#0x40]
;;;872      for (i = 0; i < 100; i++);
0009b8  2100              MOVS     r1,#0
0009ba  e000              B        |L1.2494|
                  |L1.2492|
0009bc  1c49              ADDS     r1,r1,#1
                  |L1.2494|
0009be  2964              CMP      r1,#0x64
0009c0  dbfc              BLT      |L1.2492|
;;;873    	  
;;;874      if( (*(volatile unsigned *)ISP_ENTRY_GPIO_REG) & (0x1<<ISP_ENTRY_PIN) )
0009c2  48c6              LDR      r0,|L1.3292|
0009c4  6940              LDR      r0,[r0,#0x14]
0009c6  f4006080          AND      r0,r0,#0x400
0009ca  b108              CBZ      r0,|L1.2512|
;;;875    	{
;;;876    	    return(TRUE);
0009cc  2001              MOVS     r0,#1
                  |L1.2510|
;;;877    	}
;;;878    	else
;;;879    	{
;;;880    	    return(FALSE);
;;;881    	}
;;;882    }
0009ce  4770              BX       lr
                  |L1.2512|
0009d0  2000              MOVS     r0,#0                 ;880
0009d2  e7fc              B        |L1.2510|
;;;883    
                          ENDP

                  is_LPC175x PROC
;;;885    /* returns TRUE if device is an LPC175x */
;;;886    int is_LPC175x(void)
0009d4  b510              PUSH     {r4,lr}
;;;887    {
;;;888      param_table[IAP_CMD_CODE] = READ_PART_ID;
0009d6  2036              MOVS     r0,#0x36
0009d8  49bd              LDR      r1,|L1.3280|
0009da  6008              STR      r0,[r1,#0]  ; param_table
;;;889      iap_entry(param_table,result_table);
0009dc  49bd              LDR      r1,|L1.3284|
0009de  48bc              LDR      r0,|L1.3280|
0009e0  f7fffffe          BL       iap_entry
;;;890      if ((result_table[ISP_PARAM_1] >> 24) == 0x25)
0009e4  48bb              LDR      r0,|L1.3284|
0009e6  6840              LDR      r0,[r0,#4]  ; result_table
0009e8  2125              MOVS     r1,#0x25
0009ea  ebb16f10          CMP      r1,r0,LSR #24
0009ee  d101              BNE      |L1.2548|
;;;891      {
;;;892        return TRUE;
0009f0  2001              MOVS     r0,#1
                  |L1.2546|
;;;893      }
;;;894    
;;;895      return FALSE;
;;;896    }
0009f2  bd10              POP      {r4,pc}
                  |L1.2548|
0009f4  2000              MOVS     r0,#0                 ;895
0009f6  e7fc              B        |L1.2546|
;;;897    
                          ENDP

                  reset_mcu PROC
;;;898    void reset_mcu(void)
0009f8  f44f707a          MOV      r0,#0x3e8
;;;899    {
;;;900    	/* Use the Watchdog Timer to intentionally reset the MCU */
;;;901        LPC_WDT->WDTC = 1000;      /* reset after a short waiting period */
0009fc  06c1              LSLS     r1,r0,#27
0009fe  6048              STR      r0,[r1,#4]
;;;902        LPC_WDT->WDMOD = 0x3;      /* WDEN | WDRESET */
000a00  2003              MOVS     r0,#3
000a02  7008              STRB     r0,[r1,#0]
;;;903        LPC_WDT->WDFEED = 0xAA;    /* Feeding sequence to start watchdog */
000a04  20aa              MOVS     r0,#0xaa
000a06  7208              STRB     r0,[r1,#8]
;;;904        LPC_WDT->WDFEED = 0x55;
000a08  2055              MOVS     r0,#0x55
000a0a  7208              STRB     r0,[r1,#8]
;;;905        while (1);
000a0c  bf00              NOP      
                  |L1.2574|
000a0e  e7fe              B        |L1.2574|
;;;906    }
;;;907        
                          ENDP

                  exec_isp_cmd PROC
;;;908    
;;;909    int exec_isp_cmd(int no_of_param)
000a10  b570              PUSH     {r4-r6,lr}
;;;910    {
000a12  4605              MOV      r5,r0
;;;911        int c;
;;;912    
;;;913        c = *(param_buf[ISP_CMD_CODE]);
000a14  48b2              LDR      r0,|L1.3296|
000a16  6800              LDR      r0,[r0,#0]  ; param_buf
000a18  7804              LDRB     r4,[r0,#0]
;;;914        if(c != NUL);
;;;915        {
;;;916            switch(c)
000a1a  f1a4003f          SUB      r0,r4,#0x3f
000a1e  2819              CMP      r0,#0x19
000a20  d272              BCS      |L1.2824|
000a22  e8dff000          TBB      [pc,r0]
000a26  0da9              DCB      0x0d,0xa9
000a28  a9a99da9          DCB      0xa9,0xa9,0x9d,0xa9
000a2c  a0a915a9          DCB      0xa0,0xa9,0x15,0xa9
000a30  a31b72a9          DCB      0xa3,0x1b,0x72,0xa9
000a34  a637a99a          DCB      0xa6,0x37,0xa9,0x9a
000a38  a912a9a9          DCB      0xa9,0x12,0xa9,0xa9
000a3c  18a90f00          DCB      0x18,0xa9,0x0f,0x00
;;;917            {
;;;918            /* We're getting a handshake in the middle of a session, reset. */
;;;919            case '?':
;;;920    			return (1);
000a40  2001              MOVS     r0,#1
                  |L1.2626|
;;;921                //reset_mcu();
;;;922            /* Write to RAM command */
;;;923            case 'W':
;;;924                write_to_ram();
;;;925                break;
;;;926            /* Read command */
;;;927            case 'R':
;;;928                read();
;;;929                break;
;;;930            /* Go command */
;;;931            case 'G':
;;;932                go_cmd();
;;;933                break;
;;;934            /* Unlock command */
;;;935            case 'U':
;;;936                unlock();
;;;937                break;
;;;938            /* Read Part Identification number command */
;;;939            case 'J':
;;;940                param_table[IAP_CMD_CODE] = READ_PART_ID;
;;;941                iap_entry(param_table,result_table);
;;;942                sendline_crlf(i_to_a(result_table[IAP_STAT_CODE],param_buf[ISP_PARAM_1], \
;;;943                PARAM_SIZE));
;;;944                sendline_crlf(i_to_a(result_table[IAP_RESULT_0],param_buf[ISP_PARAM_1], \
;;;945                PARAM_SIZE));
;;;946            break;
;;;947            /* read serial number command */
;;;948            case 'N':
;;;949                param_table[IAP_CMD_CODE] = READ_SERIAL_NUMBER;
;;;950                iap_entry(param_table, result_table);
;;;951                sendline_crlf(i_to_a(result_table[IAP_STAT_CODE],param_buf[ISP_PARAM_1], \
;;;952                PARAM_SIZE));
;;;953                sendline_crlf(i_to_a(result_table[IAP_RESULT_0],param_buf[ISP_PARAM_1], \
;;;954                PARAM_SIZE));
;;;955                sendline_crlf(i_to_a(result_table[IAP_RESULT_1],param_buf[ISP_PARAM_1], \
;;;956                PARAM_SIZE));
;;;957                sendline_crlf(i_to_a(result_table[IAP_RESULT_2],param_buf[ISP_PARAM_1], \
;;;958                PARAM_SIZE));
;;;959                sendline_crlf(i_to_a(result_table[IAP_RESULT_3],param_buf[ISP_PARAM_1], \
;;;960                PARAM_SIZE));
;;;961            break;
;;;962            /* Read Boot Code Version number command */
;;;963            case 'K':
;;;964                param_table[IAP_CMD_CODE] = READ_BOOT_VER;
;;;965                iap_entry(param_table,result_table);
;;;966                sendline_crlf(i_to_a(result_table[IAP_STAT_CODE],param_buf[ISP_PARAM_1], \
;;;967                PARAM_SIZE));
;;;968                sendline_crlf(i_to_a((char)result_table[IAP_RESULT_0],param_buf[ISP_PARAM_1], \
;;;969                PARAM_SIZE));
;;;970                sendline_crlf(i_to_a((char)(result_table[IAP_RESULT_0]>>8),param_buf[ISP_PARAM_1], \
;;;971                PARAM_SIZE));
;;;972                break;
;;;973            /* Prepare sector for write operation command */
;;;974            case 'P':
;;;975                prepare_sector();
;;;976                break;
;;;977            /* Copy RAM to FLASH command */
;;;978            case 'C':
;;;979                copy();
;;;980                break;
;;;981            /* Erase sector command */
;;;982            case 'E':
;;;983                erase();
;;;984                break;
;;;985            /* Blank check sector command */
;;;986            case 'I':
;;;987                blank_check();
;;;988                break;
;;;989            /* Compare Memory */
;;;990            case 'M':
;;;991                compare_mem();
;;;992                break;
;;;993            /* Invalid Command */
;;;994            default:
;;;995                sendline_crlf(i_to_a(INVALID_COMMAND,param_buf[ISP_PARAM_1], \
;;;996                PARAM_SIZE));
;;;997                break;
;;;998            } /* switch(c) */
;;;999        } /* if c != NUL */
;;;1000   	return (0);
;;;1001   } /* exec_isp_cmd */
000a42  bd70              POP      {r4-r6,pc}
000a44  f7fffffe          BL       write_to_ram
000a48  e0a0              B        |L1.2956|
000a4a  f7fffffe          BL       read
000a4e  e09d              B        |L1.2956|
000a50  f7fffffe          BL       go_cmd
000a54  e09a              B        |L1.2956|
000a56  f7fffffe          BL       unlock
000a5a  e097              B        |L1.2956|
000a5c  2036              MOVS     r0,#0x36              ;940
000a5e  499c              LDR      r1,|L1.3280|
000a60  6008              STR      r0,[r1,#0]            ;940  ; param_table
000a62  499c              LDR      r1,|L1.3284|
000a64  489a              LDR      r0,|L1.3280|
000a66  f7fffffe          BL       iap_entry
000a6a  4a9d              LDR      r2,|L1.3296|
000a6c  6851              LDR      r1,[r2,#4]            ;942  ; param_buf
000a6e  4a99              LDR      r2,|L1.3284|
000a70  6810              LDR      r0,[r2,#0]            ;942  ; result_table
000a72  220f              MOVS     r2,#0xf               ;942
000a74  f7fffffe          BL       i_to_a
000a78  4606              MOV      r6,r0                 ;942
000a7a  f7fffffe          BL       sendline_crlf
000a7e  4a98              LDR      r2,|L1.3296|
000a80  6851              LDR      r1,[r2,#4]            ;944  ; param_buf
000a82  4a94              LDR      r2,|L1.3284|
000a84  6850              LDR      r0,[r2,#4]            ;944  ; result_table
000a86  220f              MOVS     r2,#0xf               ;944
000a88  f7fffffe          BL       i_to_a
000a8c  4606              MOV      r6,r0                 ;944
000a8e  f7fffffe          BL       sendline_crlf
000a92  e07b              B        |L1.2956|
000a94  203a              MOVS     r0,#0x3a              ;949
000a96  498e              LDR      r1,|L1.3280|
000a98  6008              STR      r0,[r1,#0]            ;949  ; param_table
000a9a  498e              LDR      r1,|L1.3284|
000a9c  488c              LDR      r0,|L1.3280|
000a9e  f7fffffe          BL       iap_entry
000aa2  4a8f              LDR      r2,|L1.3296|
000aa4  6851              LDR      r1,[r2,#4]            ;951  ; param_buf
000aa6  4a8b              LDR      r2,|L1.3284|
000aa8  6810              LDR      r0,[r2,#0]            ;951  ; result_table
000aaa  220f              MOVS     r2,#0xf               ;951
000aac  f7fffffe          BL       i_to_a
000ab0  4606              MOV      r6,r0                 ;951
000ab2  f7fffffe          BL       sendline_crlf
000ab6  4a8a              LDR      r2,|L1.3296|
000ab8  6851              LDR      r1,[r2,#4]            ;953  ; param_buf
000aba  4a86              LDR      r2,|L1.3284|
000abc  6850              LDR      r0,[r2,#4]            ;953  ; result_table
000abe  220f              MOVS     r2,#0xf               ;953
000ac0  f7fffffe          BL       i_to_a
000ac4  4606              MOV      r6,r0                 ;953
000ac6  f7fffffe          BL       sendline_crlf
000aca  4a85              LDR      r2,|L1.3296|
000acc  6851              LDR      r1,[r2,#4]            ;955  ; param_buf
000ace  4a81              LDR      r2,|L1.3284|
000ad0  6890              LDR      r0,[r2,#8]            ;955  ; result_table
000ad2  220f              MOVS     r2,#0xf               ;955
000ad4  f7fffffe          BL       i_to_a
000ad8  4606              MOV      r6,r0                 ;955
000ada  f7fffffe          BL       sendline_crlf
000ade  4a80              LDR      r2,|L1.3296|
000ae0  6851              LDR      r1,[r2,#4]            ;957  ; param_buf
000ae2  4a7c              LDR      r2,|L1.3284|
000ae4  68d0              LDR      r0,[r2,#0xc]          ;957  ; result_table
000ae6  220f              MOVS     r2,#0xf               ;957
000ae8  f7fffffe          BL       i_to_a
000aec  4606              MOV      r6,r0                 ;957
000aee  f7fffffe          BL       sendline_crlf
000af2  4a7b              LDR      r2,|L1.3296|
000af4  6851              LDR      r1,[r2,#4]            ;959  ; param_buf
000af6  4a77              LDR      r2,|L1.3284|
000af8  6910              LDR      r0,[r2,#0x10]         ;959  ; result_table
000afa  220f              MOVS     r2,#0xf               ;959
000afc  f7fffffe          BL       i_to_a
000b00  4606              MOV      r6,r0                 ;959
000b02  f7fffffe          BL       sendline_crlf
000b06  e041              B        |L1.2956|
                  |L1.2824|
000b08  e036              B        |L1.2936|
000b0a  2037              MOVS     r0,#0x37              ;964
000b0c  4970              LDR      r1,|L1.3280|
000b0e  6008              STR      r0,[r1,#0]            ;964  ; param_table
000b10  4970              LDR      r1,|L1.3284|
000b12  486f              LDR      r0,|L1.3280|
000b14  f7fffffe          BL       iap_entry
000b18  4a71              LDR      r2,|L1.3296|
000b1a  6851              LDR      r1,[r2,#4]            ;966  ; param_buf
000b1c  4a6d              LDR      r2,|L1.3284|
000b1e  6810              LDR      r0,[r2,#0]            ;966  ; result_table
000b20  220f              MOVS     r2,#0xf               ;966
000b22  f7fffffe          BL       i_to_a
000b26  4606              MOV      r6,r0                 ;966
000b28  f7fffffe          BL       sendline_crlf
000b2c  4a6c              LDR      r2,|L1.3296|
000b2e  6851              LDR      r1,[r2,#4]            ;968  ; param_buf
000b30  4a68              LDR      r2,|L1.3284|
000b32  7910              LDRB     r0,[r2,#4]            ;968  ; result_table
000b34  220f              MOVS     r2,#0xf               ;968
000b36  f7fffffe          BL       i_to_a
000b3a  4606              MOV      r6,r0                 ;968
000b3c  f7fffffe          BL       sendline_crlf
000b40  4a67              LDR      r2,|L1.3296|
000b42  6851              LDR      r1,[r2,#4]            ;970  ; param_buf
000b44  4a63              LDR      r2,|L1.3284|
000b46  8892              LDRH     r2,[r2,#4]            ;970  ; result_table
000b48  f3c22007          UBFX     r0,r2,#8,#8           ;970
000b4c  220f              MOVS     r2,#0xf               ;970
000b4e  f7fffffe          BL       i_to_a
000b52  4606              MOV      r6,r0                 ;970
000b54  f7fffffe          BL       sendline_crlf
000b58  e018              B        |L1.2956|
000b5a  f7fffffe          BL       prepare_sector
000b5e  e015              B        |L1.2956|
000b60  f7fffffe          BL       copy
000b64  e012              B        |L1.2956|
000b66  f7fffffe          BL       erase
000b6a  e00f              B        |L1.2956|
000b6c  f7fffffe          BL       blank_check
000b70  e00c              B        |L1.2956|
000b72  f7fffffe          BL       compare_mem
000b76  e009              B        |L1.2956|
                  |L1.2936|
000b78  4859              LDR      r0,|L1.3296|
000b7a  220f              MOVS     r2,#0xf               ;995
000b7c  6841              LDR      r1,[r0,#4]            ;995  ; param_buf
000b7e  2001              MOVS     r0,#1                 ;995
000b80  f7fffffe          BL       i_to_a
000b84  4606              MOV      r6,r0                 ;995
000b86  f7fffffe          BL       sendline_crlf
000b8a  bf00              NOP                            ;997
                  |L1.2956|
000b8c  bf00              NOP                            ;925
000b8e  2000              MOVS     r0,#0                 ;1000
000b90  e757              B        |L1.2626|
;;;1002   
                          ENDP

                  isp_cmd_loop PROC
;;;1003   /* only returns if timeout occurred */
;;;1004   int isp_cmd_loop(void)
000b92  e92d41fc          PUSH     {r2-r8,lr}
;;;1005   {
;;;1006       int cmd_len,no_of_param,crp_block_common_cmd,crp_block_crp2_crp3_cmd;
;;;1007   	int result;
;;;1008       
;;;1009   	/* initialize to avoid compiler warning  */
;;;1010       /* Lock Flash Write/Erase/Go Commands */
;;;1011       lock = TRUE;
000b96  2001              MOVS     r0,#1
000b98  4952              LDR      r1,|L1.3300|
000b9a  6008              STR      r0,[r1,#0]  ; lock
;;;1012       
;;;1013       /* intialize parameter buffer */
;;;1014       param_buf[ISP_PARAM_0] = param0;
000b9c  4852              LDR      r0,|L1.3304|
000b9e  4950              LDR      r1,|L1.3296|
000ba0  6008              STR      r0,[r1,#0]  ; param_buf
;;;1015       param_buf[ISP_PARAM_1] = param1;
000ba2  4852              LDR      r0,|L1.3308|
000ba4  6048              STR      r0,[r1,#4]  ; param_buf
;;;1016       param_buf[ISP_PARAM_2] = param2;
000ba6  4852              LDR      r0,|L1.3312|
000ba8  6088              STR      r0,[r1,#8]  ; param_buf
;;;1017       param_buf[ISP_PARAM_3] = param3;
000baa  4852              LDR      r0,|L1.3316|
000bac  60c8              STR      r0,[r1,#0xc]  ; param_buf
;;;1018       param_buf[ISP_PARAM_4] = param4;
000bae  4852              LDR      r0,|L1.3320|
000bb0  6108              STR      r0,[r1,#0x10]  ; param_buf
;;;1019   
;;;1020       /* Initialize cp_after_reset variable to allow ISP session to program 
;;;1021          code protection enabled user application */
;;;1022   	crp_after_reset = crp;
000bb2  4852              LDR      r0,|L1.3324|
000bb4  6800              LDR      r0,[r0,#0]  ; crp
000bb6  4952              LDR      r1,|L1.3328|
000bb8  6008              STR      r0,[r1,#0]  ; crp_after_reset
;;;1023   
;;;1024   	crp_block_crp2_crp3_cmd = TRUE;
000bba  2701              MOVS     r7,#1
;;;1025   
;;;1026   	while(1)
000bbc  e087              B        |L1.3278|
                  |L1.3006|
;;;1027       {
;;;1028   	    result = getline(cmd_buf,CMD_SIZE,&cmd_len);
000bbe  aa01              ADD      r2,sp,#4
000bc0  2146              MOVS     r1,#0x46
000bc2  4850              LDR      r0,|L1.3332|
000bc4  f7fffffe          BL       getline
000bc8  4605              MOV      r5,r0
;;;1029           if(result == 0)
000bca  2d00              CMP      r5,#0
000bcc  d17c              BNE      |L1.3272|
;;;1030           {
;;;1031               /* To safegaurd against insufficient parameters fill parameter buffers with
;;;1032                  Non numeric ascii charcaters */
;;;1033               for(no_of_param=0;no_of_param<NO_OF_ISP_PARAMS;no_of_param++)
000bce  2400              MOVS     r4,#0
000bd0  e005              B        |L1.3038|
                  |L1.3026|
;;;1034               {
;;;1035                   *(param_buf[no_of_param]) = 'z';
000bd2  207a              MOVS     r0,#0x7a
000bd4  4942              LDR      r1,|L1.3296|
000bd6  f8511024          LDR      r1,[r1,r4,LSL #2]
000bda  7008              STRB     r0,[r1,#0]
000bdc  1c64              ADDS     r4,r4,#1              ;1033
                  |L1.3038|
000bde  2c05              CMP      r4,#5                 ;1033
000be0  dbf7              BLT      |L1.3026|
;;;1036               }
;;;1037   
;;;1038               /* received abort command from host, reset MCU */
;;;1039               if (cmd_buf[0] == 0x1b) {
000be2  4848              LDR      r0,|L1.3332|
000be4  7800              LDRB     r0,[r0,#0]  ; cmd_buf
000be6  281b              CMP      r0,#0x1b
000be8  d109              BNE      |L1.3070|
;;;1040                   sendline_crlf(i_to_a(CMD_SUCCESS, \
000bea  483d              LDR      r0,|L1.3296|
000bec  220f              MOVS     r2,#0xf
000bee  6841              LDR      r1,[r0,#4]  ; param_buf
000bf0  2000              MOVS     r0,#0
000bf2  f7fffffe          BL       i_to_a
000bf6  4680              MOV      r8,r0
000bf8  f7fffffe          BL       sendline_crlf
;;;1041                     param_buf[ISP_PARAM_1],PARAM_SIZE));
;;;1042                   continue;
000bfc  e067              B        |L1.3278|
                  |L1.3070|
;;;1043   			}
;;;1044   
;;;1045               no_of_param = tokenize(&cmd_buf[0],cmd_len,&param_buf[0],NO_OF_ISP_PARAMS,PARAM_SIZE);  
000bfe  200f              MOVS     r0,#0xf
000c00  2305              MOVS     r3,#5
000c02  4a37              LDR      r2,|L1.3296|
000c04  9000              STR      r0,[sp,#0]
000c06  483f              LDR      r0,|L1.3332|
000c08  9901              LDR      r1,[sp,#4]
000c0a  f7fffffe          BL       tokenize
000c0e  4604              MOV      r4,r0
;;;1046               if(no_of_param != 0)
000c10  2c00              CMP      r4,#0
000c12  d05b              BEQ      |L1.3276|
;;;1047               {
;;;1048                  /* Common ISP commands to be blocked for code read protection Level 1, 2 or 3 */
;;;1049                  if( ( (*(param_buf[ISP_CMD_CODE]) == 'R') ||              \
000c14  4832              LDR      r0,|L1.3296|
000c16  6800              LDR      r0,[r0,#0]  ; param_buf
000c18  7800              LDRB     r0,[r0,#0]
000c1a  2852              CMP      r0,#0x52
000c1c  d009              BEQ      |L1.3122|
;;;1050                        (*(param_buf[ISP_CMD_CODE]) == 'G') ||              \
000c1e  4830              LDR      r0,|L1.3296|
000c20  6800              LDR      r0,[r0,#0]  ; param_buf
000c22  7800              LDRB     r0,[r0,#0]
000c24  2847              CMP      r0,#0x47
000c26  d004              BEQ      |L1.3122|
;;;1051                        (*(param_buf[ISP_CMD_CODE]) == 'M') ) )
000c28  482d              LDR      r0,|L1.3296|
000c2a  6800              LDR      r0,[r0,#0]  ; param_buf
000c2c  7800              LDRB     r0,[r0,#0]
000c2e  284d              CMP      r0,#0x4d
000c30  d101              BNE      |L1.3126|
                  |L1.3122|
;;;1052                  {
;;;1053                     crp_block_common_cmd = TRUE;
000c32  2601              MOVS     r6,#1
000c34  e00d              B        |L1.3154|
                  |L1.3126|
;;;1054                  }
;;;1055                  else
;;;1056                  {
;;;1057                     crp_block_common_cmd = FALSE;
000c36  2600              MOVS     r6,#0
;;;1058                     /* ISP commands to be blocked for code read protection Level 2 and 3 */
;;;1059                     if( ( (*(param_buf[ISP_CMD_CODE]) == 'W') ||              \
000c38  4829              LDR      r0,|L1.3296|
000c3a  6800              LDR      r0,[r0,#0]  ; param_buf
000c3c  7800              LDRB     r0,[r0,#0]
000c3e  2857              CMP      r0,#0x57
000c40  d004              BEQ      |L1.3148|
;;;1060                           (*(param_buf[ISP_CMD_CODE]) == 'C') ) )
000c42  4827              LDR      r0,|L1.3296|
000c44  6800              LDR      r0,[r0,#0]  ; param_buf
000c46  7800              LDRB     r0,[r0,#0]
000c48  2843              CMP      r0,#0x43
000c4a  d101              BNE      |L1.3152|
                  |L1.3148|
;;;1061                     {
;;;1062                        crp_block_crp2_crp3_cmd = TRUE;
000c4c  2701              MOVS     r7,#1
000c4e  e000              B        |L1.3154|
                  |L1.3152|
;;;1063                     }
;;;1064                     else
;;;1065                     {
;;;1066                        crp_block_crp2_crp3_cmd = FALSE;
000c50  2700              MOVS     r7,#0
                  |L1.3154|
;;;1067                     }
;;;1068                  }
;;;1069   
;;;1070                  if( ( (crp_after_reset == CRP1) ||            \
000c52  482b              LDR      r0,|L1.3328|
000c54  6800              LDR      r0,[r0,#0]  ; crp_after_reset
000c56  492c              LDR      r1,|L1.3336|
000c58  4288              CMP      r0,r1
000c5a  d00a              BEQ      |L1.3186|
;;;1071                        (crp_after_reset == CRP2) ||     \
000c5c  4828              LDR      r0,|L1.3328|
000c5e  6800              LDR      r0,[r0,#0]  ; crp_after_reset
000c60  492a              LDR      r1,|L1.3340|
000c62  4288              CMP      r0,r1
000c64  d005              BEQ      |L1.3186|
;;;1072                        (crp_after_reset == CRP3) )      \
000c66  4826              LDR      r0,|L1.3328|
000c68  6800              LDR      r0,[r0,#0]  ; crp_after_reset
000c6a  ea4f4131          ROR      r1,r1,#16
000c6e  4288              CMP      r0,r1
000c70  d10b              BNE      |L1.3210|
                  |L1.3186|
;;;1073                                           &&                                 \
;;;1074                       ( crp_block_common_cmd == TRUE )
000c72  2e01              CMP      r6,#1
000c74  d109              BNE      |L1.3210|
;;;1075                     )
;;;1076                   {
;;;1077                       /* Code read protection Level 1, 2 or 3 enabled. Block Read,
;;;1078                          Go and Compare ISP commands */
;;;1079                       sendline_crlf(i_to_a(CODE_READ_PROTECTION_ENABLED, \
000c76  481a              LDR      r0,|L1.3296|
000c78  220f              MOVS     r2,#0xf
000c7a  6841              LDR      r1,[r0,#4]  ; param_buf
000c7c  2013              MOVS     r0,#0x13
000c7e  f7fffffe          BL       i_to_a
000c82  4680              MOV      r8,r0
000c84  f7fffffe          BL       sendline_crlf
000c88  e020              B        |L1.3276|
                  |L1.3210|
;;;1080                       param_buf[ISP_PARAM_1],PARAM_SIZE));
;;;1081                   }  
;;;1082                   else
;;;1083                   {
;;;1084                      if( ( (crp_after_reset == CRP2) ||            \
000c8a  481d              LDR      r0,|L1.3328|
000c8c  6800              LDR      r0,[r0,#0]  ; crp_after_reset
000c8e  491f              LDR      r1,|L1.3340|
000c90  4288              CMP      r0,r1
000c92  d005              BEQ      |L1.3232|
;;;1085                            (crp_after_reset == CRP3) )  
000c94  481a              LDR      r0,|L1.3328|
000c96  6800              LDR      r0,[r0,#0]  ; crp_after_reset
000c98  ea4f4131          ROR      r1,r1,#16
000c9c  4288              CMP      r0,r1
000c9e  d10c              BNE      |L1.3258|
                  |L1.3232|
;;;1086                                            &&                                   \
;;;1087                           ( crp_block_crp2_crp3_cmd == TRUE ) )
000ca0  2f01              CMP      r7,#1
000ca2  d10a              BNE      |L1.3258|
;;;1088                      {
;;;1089                       /* Code read protection Level 2 or 3 is enabled. Block Write
;;;1090                          and Copy ISP commands */
;;;1091                          sendline_crlf(i_to_a(CODE_READ_PROTECTION_ENABLED, \
000ca4  480e              LDR      r0,|L1.3296|
000ca6  220f              MOVS     r2,#0xf
000ca8  6841              LDR      r1,[r0,#4]  ; param_buf
000caa  2013              MOVS     r0,#0x13
000cac  f7fffffe          BL       i_to_a
000cb0  4680              MOV      r8,r0
000cb2  f7fffffe          BL       sendline_crlf
000cb6  e009              B        |L1.3276|
000cb8  e006              B        |L1.3272|
                  |L1.3258|
;;;1092                          param_buf[ISP_PARAM_1],PARAM_SIZE));
;;;1093                      }
;;;1094                      else
;;;1095                      {
;;;1096   					   if (exec_isp_cmd(no_of_param) == 1)
000cba  4620              MOV      r0,r4
000cbc  f7fffffe          BL       exec_isp_cmd
000cc0  2801              CMP      r0,#1
000cc2  d103              BNE      |L1.3276|
                  |L1.3268|
;;;1097   						   return (1);
;;;1098                      }
;;;1099                   }
;;;1100               } /* if(no_of_param != 0) */
;;;1101           } /* if(serial_getline(cmd_buf,CMD_SIZE,&cmd_len) == 0) */
;;;1102   		else
;;;1103   		{
;;;1104   		  /* timeout */
;;;1105   		  return 0;
;;;1106   		}
;;;1107   	} /* While(1) loop */
;;;1108   } /* isp_cmd_loop */
000cc4  e8bd81fc          POP      {r2-r8,pc}
                  |L1.3272|
000cc8  2000              MOVS     r0,#0                 ;1105
000cca  e7fb              B        |L1.3268|
                  |L1.3276|
000ccc  bf00              NOP                            ;1042
                  |L1.3278|
000cce  e776              B        |L1.3006|
                          ENDP

                  |L1.3280|
                          DCD      param_table
                  |L1.3284|
                          DCD      result_table
                  |L1.3288|
                          DCD      0x4002c000
                  |L1.3292|
                          DCD      0x2009c000
                  |L1.3296|
                          DCD      param_buf
                  |L1.3300|
                          DCD      lock
                  |L1.3304|
                          DCD      param0
                  |L1.3308|
                          DCD      param1
                  |L1.3312|
                          DCD      param2
                  |L1.3316|
                          DCD      param3
                  |L1.3320|
                          DCD      param4
                  |L1.3324|
                          DCD      ||crp||
                  |L1.3328|
                          DCD      crp_after_reset
                  |L1.3332|
                          DCD      cmd_buf
                  |L1.3336|
                          DCD      0x12345678
                  |L1.3340|
                          DCD      0x87654321

                          AREA ||.bss||, DATA, NOINIT, ALIGN=2

                  cmd_buf
                          %        70
                  param0
                          %        15
                  param1
                          %        15
                  param2
                          %        15
                  param3
                          %        15
                  param4
                          %        18
                  param_buf
                          %        20
                  param_table
                          %        20
                  result_table
                          %        20

                          AREA ||.constdata||, DATA, READONLY, ALIGN=2

                  unlock_code
                          DCD      0x00005a5a
                  sync_str
000004  53796e63          DCB      0x53,0x79,0x6e,0x63
000008  68726f6e          DCB      0x68,0x72,0x6f,0x6e
00000c  697a6564          DCB      0x69,0x7a,0x65,0x64
000010  00                DCB      0x00
                  ||ok||
000011  4f4b00            DCB      0x4f,0x4b,0x00
                  resend
000014  52455345          DCB      0x52,0x45,0x53,0x45
000018  4e4400            DCB      0x4e,0x44,0x00

                          AREA ||.data||, DATA, ALIGN=2

                  lock
                          DCD      0x00000000
                  crp_after_reset
                          DCD      0x00000000

;*** Start embedded assembler ***

#line 1 "isp\\isp_iap.c"
	AREA ||.emb_text||, CODE
	THUMB
	EXPORT |boot_jump|
#line 35
|boot_jump| PROC
#line 35

 LDR sp, [r0] 
 LDR pc, [r0, #4] 
	ENDP

;*** End   embedded assembler ***
