; generated by Component: ARM Compiler 5.05 update 2 (build 169) Tool: ArmCC [4d0f38]
; commandline ArmCC [--c99 --list --split_sections --debug -c --asm --interleave -o..\..\..\..\build\bootloader\mico-fire_f429\obj_rvmdk\ymodem.o --asm_dir=..\..\..\..\Build\Bootloader\MICO-Fire_F429\list_RVMDK\ --list_dir=..\..\..\..\Build\Bootloader\MICO-Fire_F429\list_RVMDK\ --depend=..\..\..\..\build\bootloader\mico-fire_f429\obj_rvmdk\ymodem.d --cpu=Cortex-M4.fp --apcs=interwork --diag_suppress=9931,1,1293 -I..\..\..\..\Bootloader -I..\..\..\..\Board\fire_F429 -I..\..\..\..\include -I..\..\..\..\libraries\utilities -I..\..\..\..\libraries\utilities\json_c -I..\..\..\..\MICO\core -I..\..\..\..\MICO\security -I..\..\..\..\MICO\system -I..\..\..\..\MICO\system\command_console -I..\..\..\..\Platform\include -I..\..\..\..\Platform\Cortex-M4 -I..\..\..\..\Platform\Cortex-M4\CMSIS -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries\STM32F4xx_StdPeriph_Driver\inc -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries -I..\..\..\..\Platform\MCU\STM32F4xx\wlan_bus_driver -I..\..\..\..\Platform\Drivers\spi_flash -I..\..\..\..\Platform\Drivers -IG:\GIT_OSC\F429_OV2640_MICO_SDRAM\Projects\STM32F429\bootloader\RVMDK\RTE -ID:\work\keil5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0\Drivers\CMSIS\Device\ST\STM32F4xx\Include -ID:\work\keil5\ARM\CMSIS\Include -ID:\work\keil5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0 -D__MICROLIB -D__UVISION_VERSION=516 -DSTM32F429xx -DUSE_STDPERIPH_DRIVER -DBOOTLOADER -DNO_MICO_RTOS -DHSE_VALUE=25000000 --omf_browse=..\..\..\..\build\bootloader\mico-fire_f429\obj_rvmdk\ymodem.crf ..\..\..\..\Bootloader\ymodem.c]
                          THUMB

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

                  CalChecksum PROC
;;;378      */
;;;379    uint8_t CalChecksum(const uint8_t* data, uint32_t size)
000000  2200              MOVS     r2,#0
;;;380    {
;;;381      uint32_t sum = 0;
;;;382      const uint8_t* dataEnd = data+size;
000002  4401              ADD      r1,r1,r0
000004  e002              B        |L1.12|
                  |L1.6|
;;;383    
;;;384      while(data < dataEnd )
;;;385        sum += *data++;
000006  f8103b01          LDRB     r3,[r0],#1
00000a  441a              ADD      r2,r2,r3
                  |L1.12|
00000c  4288              CMP      r0,r1                 ;384
00000e  d3fa              BCC      |L1.6|
;;;386    
;;;387      return (sum & 0xffu);
000010  b2d0              UXTB     r0,r2
;;;388    }
000012  4770              BX       lr
;;;389    
                          ENDP


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

                  Cal_CRC16 PROC
;;;361      */
;;;362    uint16_t Cal_CRC16(const uint8_t* data, uint32_t size)
000000  b57c              PUSH     {r2-r6,lr}
;;;363    {
000002  4605              MOV      r5,r0
000004  460c              MOV      r4,r1
;;;364      CRC16_Context contex;
;;;365      uint16_t ret;
;;;366      
;;;367      CRC16_Init( &contex );
000006  4668              MOV      r0,sp
000008  f7fffffe          BL       CRC16_Init
;;;368      CRC16_Update( &contex, data, size );
00000c  4622              MOV      r2,r4
00000e  4629              MOV      r1,r5
000010  4668              MOV      r0,sp
000012  f7fffffe          BL       CRC16_Update
;;;369      CRC16_Final( &contex, &ret );
000016  a901              ADD      r1,sp,#4
000018  4668              MOV      r0,sp
00001a  f7fffffe          BL       CRC16_Final
;;;370      return ret;
00001e  f8bd0004          LDRH     r0,[sp,#4]
;;;371    }
000022  bd7c              POP      {r2-r6,pc}
;;;372    
                          ENDP


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

                  Receive_Byte PROC
;;;57       */
;;;58     static int32_t Receive_Byte (uint8_t *c, uint32_t timeout)
000000  460b              MOV      r3,r1
;;;59     {
000002  b510              PUSH     {r4,lr}
;;;60       if (MicoUartRecv( STDIO_UART, c, 1, timeout )!=kNoErr)
000004  4601              MOV      r1,r0
000006  2201              MOVS     r2,#1
000008  2000              MOVS     r0,#0
00000a  f7fffffe          BL       MicoUartRecv
00000e  2800              CMP      r0,#0
000010  d001              BEQ      |L3.22|
;;;61         return -1;
000012  f04f30ff          MOV      r0,#0xffffffff
                  |L3.22|
;;;62       else
;;;63         return 0;
;;;64     }
000016  bd10              POP      {r4,pc}
;;;65     
                          ENDP


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

                  Receive_Packet PROC
;;;88       */
;;;89     static int32_t Receive_Packet (uint8_t *data, int32_t *length, uint32_t timeout)
000000  e92d4ff8          PUSH     {r3-r11,lr}
;;;90     {
000004  4688              MOV      r8,r1
;;;91       uint16_t i, packet_size;
;;;92       uint8_t c;
;;;93       *length = 0;
000006  2100              MOVS     r1,#0
000008  4605              MOV      r5,r0                 ;90
;;;94       if (Receive_Byte(&c, timeout) != 0)
00000a  f8c81000          STR      r1,[r8,#0]
00000e  4692              MOV      r10,r2                ;90
000010  4611              MOV      r1,r2
000012  4668              MOV      r0,sp
000014  f7fffffe          BL       Receive_Byte
;;;95       {
;;;96         return -1;
000018  f04f39ff          MOV      r9,#0xffffffff
00001c  bbb0              CBNZ     r0,|L4.140|
;;;97       }
;;;98       switch (c)
00001e  f89d1000          LDRB     r1,[sp,#0]
000022  2918              CMP      r1,#0x18
000024  d014              BEQ      |L4.80|
000026  dc06              BGT      |L4.54|
000028  2901              CMP      r1,#1
00002a  d009              BEQ      |L4.64|
00002c  2902              CMP      r1,#2
00002e  d009              BEQ      |L4.68|
000030  2904              CMP      r1,#4
000032  d12b              BNE      |L4.140|
000034  e02e              B        |L4.148|
                  |L4.54|
000036  2941              CMP      r1,#0x41
000038  d016              BEQ      |L4.104|
00003a  2961              CMP      r1,#0x61
00003c  d126              BNE      |L4.140|
00003e  e013              B        |L4.104|
                  |L4.64|
;;;99       {
;;;100        case SOH:
;;;101          packet_size = PACKET_SIZE;
000040  2680              MOVS     r6,#0x80
;;;102          break;
000042  e001              B        |L4.72|
                  |L4.68|
;;;103        case STX:
;;;104          packet_size = PACKET_1K_SIZE;
000044  f44f6680          MOV      r6,#0x400
                  |L4.72|
;;;105          break;
;;;106        case EOT:
;;;107          return 0;
;;;108        case CA:
;;;109          if ((Receive_Byte(&c, timeout) == 0) && (c == CA))
;;;110          {
;;;111            *length = -1;
;;;112            return 0;
;;;113          }
;;;114          else
;;;115          {
;;;116            return -1;
;;;117          }
;;;118        case ABORT1:
;;;119        case ABORT2:
;;;120          return 1;
;;;121        default:
;;;122          return -1;
;;;123      }
;;;124      *data = c;
;;;125      for (i = 1; i < (packet_size + PACKET_OVERHEAD); i ++)
000048  2401              MOVS     r4,#1
00004a  7029              STRB     r1,[r5,#0]            ;124
00004c  1d77              ADDS     r7,r6,#5
00004e  e015              B        |L4.124|
                  |L4.80|
000050  4651              MOV      r1,r10                ;109
000052  4668              MOV      r0,sp                 ;109
000054  f7fffffe          BL       Receive_Byte
000058  b9c0              CBNZ     r0,|L4.140|
00005a  f89d0000          LDRB     r0,[sp,#0]            ;109
00005e  2818              CMP      r0,#0x18              ;109
000060  d114              BNE      |L4.140|
000062  f8c89000          STR      r9,[r8,#0]            ;112
000066  e015              B        |L4.148|
                  |L4.104|
000068  2001              MOVS     r0,#1                 ;120
                  |L4.106|
;;;126      {
;;;127        if (Receive_Byte(data + i, timeout) != 0)
;;;128        {
;;;129          return -1;
;;;130        }
;;;131      }
;;;132      if (data[PACKET_SEQNO_INDEX] != ((data[PACKET_SEQNO_COMP_INDEX] ^ 0xff) & 0xff))
;;;133      {
;;;134        return -1;
;;;135      }
;;;136      *length = packet_size;
;;;137      return 0;
;;;138    }
00006a  e8bd8ff8          POP      {r3-r11,pc}
                  |L4.110|
00006e  1928              ADDS     r0,r5,r4              ;127
000070  4651              MOV      r1,r10                ;127
000072  f7fffffe          BL       Receive_Byte
000076  b948              CBNZ     r0,|L4.140|
000078  1c64              ADDS     r4,r4,#1              ;127
00007a  b2a4              UXTH     r4,r4                 ;125
                  |L4.124|
00007c  42bc              CMP      r4,r7                 ;125
00007e  d3f6              BCC      |L4.110|
000080  78a9              LDRB     r1,[r5,#2]            ;132
000082  7868              LDRB     r0,[r5,#1]            ;132
000084  f08101ff          EOR      r1,r1,#0xff           ;132
000088  4288              CMP      r0,r1                 ;132
00008a  d001              BEQ      |L4.144|
                  |L4.140|
00008c  4648              MOV      r0,r9                 ;134
00008e  e7ec              B        |L4.106|
                  |L4.144|
000090  f8c86000          STR      r6,[r8,#0]            ;136
                  |L4.148|
000094  2000              MOVS     r0,#0                 ;137
000096  e7e8              B        |L4.106|
;;;139    
                          ENDP


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

                  Send_Byte PROC
;;;70       */
;;;71     static uint32_t Send_Byte (uint8_t c)
000000  b510              PUSH     {r4,lr}
;;;72     {
;;;73       putchar(c);
000002  4902              LDR      r1,|L5.12|
000004  f7fffffe          BL       putc
;;;74       return 0;
000008  2000              MOVS     r0,#0
;;;75     }
00000a  bd10              POP      {r4,pc}
;;;76     
                          ENDP

                  |L5.12|
                          DCD      __stdout

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

                  Ymodem_CheckResponse PROC
;;;279      */
;;;280    int32_t Ymodem_CheckResponse(uint8_t c)
000000  2000              MOVS     r0,#0
;;;281    {
;;;282      return 0;
;;;283    }
000002  4770              BX       lr
;;;284    
                          ENDP


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

                  Ymodem_PrepareIntialPacket PROC
;;;290      */
;;;291    void Ymodem_PrepareIntialPacket(uint8_t *data, const uint8_t* fileName, uint32_t *length)
000000  b5fe              PUSH     {r1-r7,lr}
;;;292    {
000002  4605              MOV      r5,r0
;;;293      uint16_t i, j;
;;;294      uint8_t file_ptr[10];
;;;295      
;;;296      /* Make first three packet */
;;;297      data[0] = SOH;
000004  2001              MOVS     r0,#1
;;;298      data[1] = 0x00;
000006  2600              MOVS     r6,#0
000008  7028              STRB     r0,[r5,#0]            ;297
00000a  706e              STRB     r6,[r5,#1]
;;;299      data[2] = 0xff;
00000c  20ff              MOVS     r0,#0xff
00000e  70a8              STRB     r0,[r5,#2]
;;;300      
;;;301      /* Filename packet has valid data */
;;;302      for (i = 0; (fileName[i] != '\0') && (i < FILE_NAME_LENGTH);i++)
000010  4634              MOV      r4,r6
000012  e003              B        |L7.28|
                  |L7.20|
;;;303      {
;;;304         data[i + PACKET_HEADER] = fileName[i];
000014  192b              ADDS     r3,r5,r4
000016  1c64              ADDS     r4,r4,#1
000018  70d8              STRB     r0,[r3,#3]
00001a  b2a4              UXTH     r4,r4                 ;302
                  |L7.28|
00001c  5d08              LDRB     r0,[r1,r4]            ;302
00001e  b108              CBZ      r0,|L7.36|
000020  2cff              CMP      r4,#0xff              ;302
000022  d9f7              BLS      |L7.20|
                  |L7.36|
;;;305      }
;;;306    
;;;307      data[i + PACKET_HEADER] = 0x00;
000024  1928              ADDS     r0,r5,r4
000026  70c6              STRB     r6,[r0,#3]
;;;308      
;;;309      Int2Str (file_ptr, *length);
000028  4668              MOV      r0,sp
00002a  6811              LDR      r1,[r2,#0]
00002c  f7fffffe          BL       Int2Str
;;;310      for (j =0, i = i + PACKET_HEADER + 1; file_ptr[j] != '\0' ; )
000030  2100              MOVS     r1,#0
000032  1d24              ADDS     r4,r4,#4
000034  b2a0              UXTH     r0,r4
000036  466b              MOV      r3,sp                 ;294
000038  e004              B        |L7.68|
                  |L7.58|
;;;311      {
;;;312         data[i++] = file_ptr[j++];
00003a  1c49              ADDS     r1,r1,#1
00003c  542a              STRB     r2,[r5,r0]
00003e  1c40              ADDS     r0,r0,#1
000040  b289              UXTH     r1,r1
000042  b280              UXTH     r0,r0
                  |L7.68|
000044  5c5a              LDRB     r2,[r3,r1]            ;310
000046  2a00              CMP      r2,#0                 ;310
000048  d1f7              BNE      |L7.58|
00004a  e002              B        |L7.82|
                  |L7.76|
;;;313      }
;;;314      
;;;315      for (j = i; j < PACKET_SIZE + PACKET_HEADER; j++)
;;;316      {
;;;317        data[j] = 0;
00004c  542e              STRB     r6,[r5,r0]
00004e  1c40              ADDS     r0,r0,#1
000050  b280              UXTH     r0,r0                 ;315
                  |L7.82|
000052  2883              CMP      r0,#0x83              ;315
000054  d3fa              BCC      |L7.76|
;;;318      }
;;;319    }
000056  bdfe              POP      {r1-r7,pc}
;;;320    
                          ENDP


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

                  Ymodem_PreparePacket PROC
;;;326      */
;;;327    void Ymodem_PreparePacket(mico_flash_t flash, uint32_t flashdestination, uint8_t *data, uint8_t pktNo, uint32_t sizeBlk)
000000  b57f              PUSH     {r0-r6,lr}
;;;328    {
000002  4614              MOV      r4,r2
;;;329      uint16_t i, size, packetSize;
;;;330      
;;;331      /* Make first three packet */
;;;332      packetSize = sizeBlk >= PACKET_1K_SIZE ? PACKET_1K_SIZE : PACKET_SIZE;
000004  9908              LDR      r1,[sp,#0x20]
000006  f44f6280          MOV      r2,#0x400
00000a  4291              CMP      r1,r2
00000c  d301              BCC      |L8.18|
00000e  4615              MOV      r5,r2
000010  e000              B        |L8.20|
                  |L8.18|
000012  2580              MOVS     r5,#0x80
                  |L8.20|
;;;333      size = sizeBlk < packetSize ? sizeBlk :packetSize;
000014  42a9              CMP      r1,r5
000016  d300              BCC      |L8.26|
000018  4629              MOV      r1,r5
                  |L8.26|
00001a  b28e              UXTH     r6,r1
;;;334      if (packetSize == PACKET_1K_SIZE)
00001c  4295              CMP      r5,r2
00001e  d101              BNE      |L8.36|
;;;335      {
;;;336         data[0] = STX;
000020  2102              MOVS     r1,#2
000022  e000              B        |L8.38|
                  |L8.36|
;;;337      }
;;;338      else
;;;339      {
;;;340         data[0] = SOH;
000024  2101              MOVS     r1,#1
                  |L8.38|
000026  7021              STRB     r1,[r4,#0]
;;;341      }
;;;342      data[1] = pktNo;
000028  7063              STRB     r3,[r4,#1]
;;;343      data[2] = (~pktNo);
00002a  43d9              MVNS     r1,r3
00002c  70a1              STRB     r1,[r4,#2]
;;;344    
;;;345      platform_flash_read( &platform_flash_peripherals[flash], &flashdestination, data + PACKET_HEADER, size );
00002e  490a              LDR      r1,|L8.88|
000030  4633              MOV      r3,r6
000032  eb011000          ADD      r0,r1,r0,LSL #4
000036  1ce2              ADDS     r2,r4,#3
000038  a901              ADD      r1,sp,#4
00003a  f7fffffe          BL       platform_flash_read
;;;346    
;;;347      if ( size  <= packetSize)
00003e  42ae              CMP      r6,r5
000040  d809              BHI      |L8.86|
000042  1cf6              ADDS     r6,r6,#3
;;;348      {
;;;349        for (i = size + PACKET_HEADER; i < packetSize + PACKET_HEADER; i++)
;;;350        {
;;;351          data[i] = 0x1A; /* EOF (0x1A) or 0x00 */
000044  211a              MOVS     r1,#0x1a
000046  b2b0              UXTH     r0,r6                 ;349
000048  1ced              ADDS     r5,r5,#3
00004a  e002              B        |L8.82|
                  |L8.76|
00004c  5421              STRB     r1,[r4,r0]
00004e  1c40              ADDS     r0,r0,#1
000050  b280              UXTH     r0,r0                 ;349
                  |L8.82|
000052  42a8              CMP      r0,r5                 ;349
000054  d3fa              BCC      |L8.76|
                  |L8.86|
;;;352        }
;;;353      }
;;;354    }
000056  bd7f              POP      {r0-r6,pc}
;;;355    
                          ENDP

                  |L8.88|
                          DCD      platform_flash_peripherals

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

                  Ymodem_Receive PROC
;;;144      */
;;;145    int32_t Ymodem_Receive (uint8_t *buf, mico_flash_t flash, uint32_t flashdestination, int32_t maxRecvSize)
000000  e92d4fff          PUSH     {r0-r11,lr}
;;;146    {
000004  f2ad4d24          SUB      sp,sp,#0x424
000008  4681              MOV      r9,r0
;;;147      uint8_t packet_data[PACKET_1K_SIZE + PACKET_OVERHEAD], file_size[FILE_SIZE_LENGTH], *file_ptr, *buf_ptr;
;;;148      int32_t i, packet_length, session_done, file_done, packets_received, errors, session_begin, size = 0;
00000a  2000              MOVS     r0,#0
;;;149      uint32_t  ramsource;
;;;150      platform_flash_init( &platform_flash_peripherals[flash] );
00000c  f8cd0418          STR      r0,[sp,#0x418]
000010  485c              LDR      r0,|L9.388|
000012  4698              MOV      r8,r3                 ;146
000014  eb001601          ADD      r6,r0,r1,LSL #4
000018  4630              MOV      r0,r6
00001a  f7fffffe          BL       platform_flash_init
;;;151    
;;;152      for (session_done = 0, errors = 0, session_begin = 0; ;)
00001e  2000              MOVS     r0,#0
000020  4605              MOV      r5,r0
000022  4607              MOV      r7,r0
000024  46eb              MOV      r11,sp                ;147
000026  f8cd0420          STR      r0,[sp,#0x420]        ;147
                  |L9.42|
;;;153      {
;;;154        for (packets_received = 0, file_done = 0, buf_ptr = buf; ;)
00002a  2400              MOVS     r4,#0
00002c  46a2              MOV      r10,r4
                  |L9.46|
;;;155        {
;;;156          switch (Receive_Packet(packet_data, &packet_length, NAK_TIMEOUT))
00002e  f44f727a          MOV      r2,#0x3e8
000032  f20d411c          ADD      r1,sp,#0x41c
000036  4668              MOV      r0,sp
000038  f7fffffe          BL       Receive_Packet
00003c  b188              CBZ      r0,|L9.98|
00003e  2801              CMP      r0,#1
000040  d06f              BEQ      |L9.290|
;;;157          {
;;;158            case 0:
;;;159              errors = 0;
;;;160              switch (packet_length)
;;;161              {
;;;162                /* Abort by sender */
;;;163                case - 1:
;;;164                  Send_Byte(ACK);
;;;165                  return 0;
;;;166                /* End of transmission */
;;;167                case 0:
;;;168                  Send_Byte(ACK);
;;;169                  file_done = 1;
;;;170                  break;
;;;171                /* Normal packet */
;;;172                default:
;;;173                  if ((packet_data[PACKET_SEQNO_INDEX] & 0xff) != (packets_received & 0xff))
;;;174                  {
;;;175                    Send_Byte(NAK);
;;;176                  }
;;;177                  else
;;;178                  {
;;;179                    if (packets_received == 0)
;;;180                    {
;;;181                      /* Filename packet */
;;;182                      if (packet_data[PACKET_HEADER] != 0)
;;;183                      {
;;;184                        /* Filename packet has valid data */
;;;185                        for (i = 0, file_ptr = packet_data + PACKET_HEADER; (*file_ptr != 0) && (i < FILE_NAME_LENGTH);)
;;;186                        {
;;;187                          FileName[i++] = *file_ptr++;
;;;188                        }
;;;189                        FileName[i++] = '\0';
;;;190                        for (i = 0, file_ptr ++; (*file_ptr != ' ') && (i < FILE_SIZE_LENGTH);)
;;;191                        {
;;;192                          file_size[i++] = *file_ptr++;
;;;193                        }
;;;194                        file_size[i++] = '\0';
;;;195                        Str2Int(file_size, &size);
;;;196    
;;;197                        /* Test the size of the image to be sent */
;;;198                        /* Image size is greater than Flash size */
;;;199                        if (size > (maxRecvSize + 1))
;;;200                        {
;;;201                          /* End session */
;;;202                          Send_Byte(CA);
;;;203                          Send_Byte(CA);
;;;204                          return -1;
;;;205                        }
;;;206                        /* erase user application area */
;;;207                        platform_flash_erase(&platform_flash_peripherals[flash], flashdestination, flashdestination + maxRecvSize - 1);
;;;208                        Send_Byte(ACK);
;;;209                        Send_Byte(CRC16);
;;;210                      }
;;;211                      /* Filename packet is empty, end session */
;;;212                      else
;;;213                      {
;;;214                        Send_Byte(ACK);
;;;215                        file_done = 1;
;;;216                        session_done = 1;
;;;217                        break;
;;;218                      }
;;;219                    }
;;;220                    /* Data packet */
;;;221                    else
;;;222                    {
;;;223                      memcpy(buf_ptr, packet_data + PACKET_HEADER, packet_length);
;;;224                      ramsource = (uint32_t)buf;
;;;225    
;;;226                      /* Write received data in Flash */
;;;227                      if (platform_flash_write(&platform_flash_peripherals[flash], &flashdestination, (uint8_t*) ramsource, (uint32_t) packet_length)  == 0)
;;;228                      {
;;;229                        Send_Byte(ACK);
;;;230                      }
;;;231                      else /* An error occurred while writing to Flash memory */
;;;232                      {
;;;233                        /* End session */
;;;234                        Send_Byte(CA);
;;;235                        Send_Byte(CA);
;;;236                        return -2;
;;;237                      }
;;;238                    }
;;;239                    packets_received ++;
;;;240                    session_begin = 1;
;;;241                  }
;;;242              }
;;;243              break;
;;;244            case 1:
;;;245              Send_Byte(CA);
;;;246              Send_Byte(CA);
;;;247              return -3;
;;;248            default:
;;;249              if (session_begin > 0)
000042  2f00              CMP      r7,#0
000044  dd00              BLE      |L9.72|
000046  1c6d              ADDS     r5,r5,#1
                  |L9.72|
;;;250              {
;;;251                errors ++;
;;;252              }
;;;253              if (errors > MAX_ERRORS)
000048  2d14              CMP      r5,#0x14
00004a  dd6b              BLE      |L9.292|
;;;254              {
;;;255                Send_Byte(CA);
00004c  2018              MOVS     r0,#0x18
00004e  f7fffffe          BL       Send_Byte
;;;256                Send_Byte(CA);
000052  2018              MOVS     r0,#0x18
                  |L9.84|
000054  f7fffffe          BL       Send_Byte
;;;257                return 0;
000058  2000              MOVS     r0,#0
                  |L9.90|
;;;258              }
;;;259              Send_Byte(CRC16);
;;;260              break;
;;;261          }
;;;262          if (file_done != 0)
;;;263          {
;;;264            break;
;;;265          }
;;;266        }
;;;267        if (session_done != 0)
;;;268        {
;;;269          break;
;;;270        }
;;;271      }
;;;272      return (int32_t)size;
;;;273    }
00005a  f20d4d34          ADD      sp,sp,#0x434
00005e  e8bd8ff0          POP      {r4-r11,pc}
                  |L9.98|
000062  f8dd241c          LDR      r2,[sp,#0x41c]        ;160
000066  2500              MOVS     r5,#0                 ;159
000068  f1b23fff          CMP      r2,#0xffffffff        ;160
00006c  d007              BEQ      |L9.126|
00006e  b142              CBZ      r2,|L9.130|
000070  f89d0001          LDRB     r0,[sp,#1]            ;173
000074  b2e1              UXTB     r1,r4                 ;173
000076  4288              CMP      r0,r1                 ;173
000078  d007              BEQ      |L9.138|
00007a  2015              MOVS     r0,#0x15              ;175
00007c  e074              B        |L9.360|
                  |L9.126|
00007e  2006              MOVS     r0,#6                 ;164
000080  e7e8              B        |L9.84|
                  |L9.130|
000082  2006              MOVS     r0,#6                 ;168
000084  f7fffffe          BL       Send_Byte
000088  e074              B        |L9.372|
                  |L9.138|
00008a  b1b4              CBZ      r4,|L9.186|
00008c  f10b0103          ADD      r1,r11,#3             ;223
000090  4648              MOV      r0,r9                 ;223
000092  f7fffffe          BL       __aeabi_memcpy
000096  464a              MOV      r2,r9                 ;224
000098  4630              MOV      r0,r6                 ;224
00009a  f20d412c          ADD      r1,sp,#0x42c          ;227
00009e  f8dd341c          LDR      r3,[sp,#0x41c]        ;227
0000a2  f7fffffe          BL       platform_flash_write
0000a6  b3d0              CBZ      r0,|L9.286|
0000a8  2018              MOVS     r0,#0x18              ;234
0000aa  f7fffffe          BL       Send_Byte
0000ae  2018              MOVS     r0,#0x18              ;235
0000b0  f7fffffe          BL       Send_Byte
0000b4  f06f0001          MVN      r0,#1                 ;236
0000b8  e7cf              B        |L9.90|
                  |L9.186|
0000ba  f89d0003          LDRB     r0,[sp,#3]            ;182
0000be  b378              CBZ      r0,|L9.288|
0000c0  2000              MOVS     r0,#0                 ;185
0000c2  f10b0103          ADD      r1,r11,#3             ;185
0000c6  4f30              LDR      r7,|L9.392|
0000c8  e002              B        |L9.208|
                  |L9.202|
0000ca  543a              STRB     r2,[r7,r0]            ;187
0000cc  1c40              ADDS     r0,r0,#1              ;187
0000ce  1c49              ADDS     r1,r1,#1              ;187
                  |L9.208|
0000d0  780a              LDRB     r2,[r1,#0]            ;185
0000d2  b10a              CBZ      r2,|L9.216|
0000d4  28ff              CMP      r0,#0xff              ;185
0000d6  ddf8              BLE      |L9.202|
                  |L9.216|
0000d8  2300              MOVS     r3,#0                 ;189
0000da  543b              STRB     r3,[r7,r0]            ;189
0000dc  4618              MOV      r0,r3                 ;190
0000de  f50d6781          ADD      r7,sp,#0x408          ;147
0000e2  e001              B        |L9.232|
                  |L9.228|
0000e4  543a              STRB     r2,[r7,r0]            ;192
0000e6  1c40              ADDS     r0,r0,#1              ;192
                  |L9.232|
0000e8  f8112f01          LDRB     r2,[r1,#1]!           ;190
0000ec  2a20              CMP      r2,#0x20              ;190
0000ee  d001              BEQ      |L9.244|
0000f0  2810              CMP      r0,#0x10              ;190
0000f2  dbf7              BLT      |L9.228|
                  |L9.244|
0000f4  543b              STRB     r3,[r7,r0]            ;194
0000f6  f50d6183          ADD      r1,sp,#0x418          ;195
0000fa  4638              MOV      r0,r7                 ;195
0000fc  f7fffffe          BL       Str2Int
000100  f8dd1418          LDR      r1,[sp,#0x418]        ;199
000104  f1080001          ADD      r0,r8,#1              ;199
000108  4281              CMP      r1,r0                 ;199
00010a  dd0c              BLE      |L9.294|
00010c  2018              MOVS     r0,#0x18              ;202
00010e  f7fffffe          BL       Send_Byte
000112  2018              MOVS     r0,#0x18              ;203
000114  f7fffffe          BL       Send_Byte
000118  f04f30ff          MOV      r0,#0xffffffff        ;204
00011c  e79d              B        |L9.90|
                  |L9.286|
00011e  e013              B        |L9.328|
                  |L9.288|
000120  e00e              B        |L9.320|
                  |L9.290|
000122  e017              B        |L9.340|
                  |L9.292|
000124  e01f              B        |L9.358|
                  |L9.294|
000126  f8dd142c          LDR      r1,[sp,#0x42c]        ;207
00012a  4630              MOV      r0,r6                 ;207
00012c  eb010208          ADD      r2,r1,r8              ;207
000130  1e52              SUBS     r2,r2,#1              ;207
000132  f7fffffe          BL       platform_flash_erase
000136  2006              MOVS     r0,#6                 ;208
000138  f7fffffe          BL       Send_Byte
00013c  2043              MOVS     r0,#0x43              ;209
00013e  e004              B        |L9.330|
                  |L9.320|
000140  2006              MOVS     r0,#6                 ;214
000142  f7fffffe          BL       Send_Byte
000146  e01a              B        |L9.382|
                  |L9.328|
000148  2006              MOVS     r0,#6                 ;229
                  |L9.330|
00014a  f7fffffe          BL       Send_Byte
00014e  2701              MOVS     r7,#1                 ;240
000150  1c64              ADDS     r4,r4,#1              ;240
000152  e00b              B        |L9.364|
                  |L9.340|
000154  2018              MOVS     r0,#0x18              ;245
000156  f7fffffe          BL       Send_Byte
00015a  2018              MOVS     r0,#0x18              ;246
00015c  f7fffffe          BL       Send_Byte
000160  f06f0002          MVN      r0,#2                 ;247
000164  e779              B        |L9.90|
                  |L9.358|
000166  2043              MOVS     r0,#0x43              ;259
                  |L9.360|
000168  f7fffffe          BL       Send_Byte
                  |L9.364|
00016c  f1ba0f00          CMP      r10,#0                ;262
000170  f43faf5d          BEQ      |L9.46|
                  |L9.372|
000174  f8dd0420          LDR      r0,[sp,#0x420]        ;267
000178  2800              CMP      r0,#0                 ;267
00017a  f43faf56          BEQ      |L9.42|
                  |L9.382|
00017e  f8dd0418          LDR      r0,[sp,#0x418]        ;272
000182  e76a              B        |L9.90|
;;;274    
                          ENDP

                  |L9.388|
                          DCD      platform_flash_peripherals
                  |L9.392|
                          DCD      FileName

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

                  Ymodem_SendPacket PROC
;;;395      */
;;;396    void Ymodem_SendPacket(uint8_t *data, uint16_t length)
000000  b570              PUSH     {r4-r6,lr}
;;;397    {
000002  460d              MOV      r5,r1
000004  4606              MOV      r6,r0
;;;398      uint16_t i;
;;;399      i = 0;
000006  2400              MOVS     r4,#0
000008  e004              B        |L10.20|
                  |L10.10|
;;;400      while (i < length)
;;;401      {
;;;402        Send_Byte(data[i]);
00000a  5d30              LDRB     r0,[r6,r4]
00000c  f7fffffe          BL       Send_Byte
000010  1c64              ADDS     r4,r4,#1
;;;403        i++;
000012  b2a4              UXTH     r4,r4
                  |L10.20|
000014  42ac              CMP      r4,r5                 ;400
000016  d3f8              BCC      |L10.10|
;;;404      }
;;;405    }
000018  bd70              POP      {r4-r6,pc}
;;;406    
                          ENDP


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

                  Ymodem_Transmit PROC
;;;411      */
;;;412    uint8_t Ymodem_Transmit (mico_flash_t flash, uint32_t flashdestination, const uint8_t* sendFileName, uint32_t sizeFile)
000000  e92d4fff          PUSH     {r0-r11,lr}
;;;413    {
;;;414      uint8_t packet_data[PACKET_1K_SIZE + PACKET_OVERHEAD];
;;;415      uint8_t filename[FILE_NAME_LENGTH];
;;;416      uint8_t tempCheckSum;
;;;417      uint32_t buf_ptr;
;;;418      uint16_t tempCRC;
;;;419      uint16_t blkNumber;
;;;420      uint8_t receivedC[2], CRC16_F = 0, i;
;;;421      uint32_t errors, ackReceived, size = 0, pktSize;
;;;422    
;;;423      errors = 0;
000004  2400              MOVS     r4,#0
000006  f2ad5d14          SUB      sp,sp,#0x514          ;413
00000a  460f              MOV      r7,r1                 ;413
;;;424      ackReceived = 0;
00000c  4625              MOV      r5,r4
;;;425      for (i = 0; i < (FILE_NAME_LENGTH - 1); i++)
00000e  4620              MOV      r0,r4
000010  f20d410c          ADD      r1,sp,#0x40c          ;415
                  |L11.20|
;;;426      {
;;;427        filename[i] = sendFileName[i];
000014  5c13              LDRB     r3,[r2,r0]
000016  540b              STRB     r3,[r1,r0]
000018  1c40              ADDS     r0,r0,#1
00001a  b2c0              UXTB     r0,r0                 ;425
00001c  28ff              CMP      r0,#0xff              ;425
00001e  d3f9              BCC      |L11.20|
;;;428      }
;;;429      CRC16_F = 1;
000020  f04f0a01          MOV      r10,#1
;;;430        
;;;431      /* Prepare first block */
;;;432      Ymodem_PrepareIntialPacket(&packet_data[0], filename, &sizeFile);
000024  f50d62a4          ADD      r2,sp,#0x520
000028  a801              ADD      r0,sp,#4
00002a  f7fffffe          BL       Ymodem_PrepareIntialPacket
;;;433      
;;;434      do 
;;;435      {
;;;436        /* Send Packet */
;;;437        Ymodem_SendPacket(packet_data, PACKET_SIZE + PACKET_HEADER);
;;;438    
;;;439        /* Send CRC or Check Sum based on CRC16_F */
;;;440        if (CRC16_F)
;;;441        {
;;;442           tempCRC = Cal_CRC16(&packet_data[3], PACKET_SIZE);
;;;443           Send_Byte(tempCRC >> 8);
;;;444           Send_Byte(tempCRC & 0xFF);
;;;445        }
;;;446        else
;;;447        {
;;;448           tempCheckSum = CalChecksum (&packet_data[3], PACKET_SIZE);
;;;449           Send_Byte(tempCheckSum);
;;;450        }
;;;451      
;;;452        /* Wait for Ack and 'C' */
;;;453        if (Receive_Byte(&receivedC[0], 1000) == 0)  
00002e  f44f797a          MOV      r9,#0x3e8
                  |L11.50|
000032  2183              MOVS     r1,#0x83              ;437
000034  a801              ADD      r0,sp,#4              ;437
000036  f7fffffe          BL       Ymodem_SendPacket
00003a  f1ba0f00          CMP      r10,#0                ;440
00003e  f04f0180          MOV      r1,#0x80              ;448
000042  f10d0007          ADD      r0,sp,#7              ;448
000046  d007              BEQ      |L11.88|
000048  f7fffffe          BL       Cal_CRC16
00004c  4606              MOV      r6,r0                 ;442
00004e  0a00              LSRS     r0,r0,#8              ;443
000050  f7fffffe          BL       Send_Byte
000054  b2f0              UXTB     r0,r6                 ;444
000056  e001              B        |L11.92|
                  |L11.88|
000058  f7fffffe          BL       CalChecksum
                  |L11.92|
00005c  f7fffffe          BL       Send_Byte
000060  4649              MOV      r1,r9
000062  f20d500c          ADD      r0,sp,#0x50c
000066  f7fffffe          BL       Receive_Byte
00006a  b110              CBZ      r0,|L11.114|
00006c  1c64              ADDS     r4,r4,#1
                  |L11.110|
;;;454        {
;;;455          if (receivedC[0] == ACK)
;;;456          { 
;;;457            /* Packet transferred correctly */
;;;458            ackReceived = 1;
;;;459          }
;;;460        }
;;;461        else
;;;462        {
;;;463            errors++;
;;;464        }
;;;465      }while (!ackReceived && (errors < 0x0A));
00006e  b185              CBZ      r5,|L11.146|
000070  e003              B        |L11.122|
                  |L11.114|
000072  f89d050c          LDRB     r0,[sp,#0x50c]        ;455
000076  2806              CMP      r0,#6                 ;455
000078  d1f9              BNE      |L11.110|
                  |L11.122|
;;;466      
;;;467      if (errors >=  0x0A)
00007a  2c0a              CMP      r4,#0xa
00007c  d20b              BCS      |L11.150|
;;;468      {
;;;469        return errors;
;;;470      }
;;;471      buf_ptr = flashdestination;
;;;472      size = sizeFile;
;;;473      blkNumber = 0x01;
00007e  f04f0801          MOV      r8,#1
;;;474      /* Here 1024 bytes package is used to send the packets */
;;;475      
;;;476      Receive_Byte(&receivedC[0], 1000);
000082  4649              MOV      r1,r9
000084  f20d500c          ADD      r0,sp,#0x50c
000088  f8dd5520          LDR      r5,[sp,#0x520]
00008c  f7fffffe          BL       Receive_Byte
;;;477      /* Resend packet if NAK  for a count of 10 else end of communication */
;;;478      while (size)
000090  e050              B        |L11.308|
                  |L11.146|
000092  2c0a              CMP      r4,#0xa               ;465
000094  d3cd              BCC      |L11.50|
                  |L11.150|
000096  e0b2              B        |L11.510|
                  |L11.152|
;;;479      {
;;;480        /* Prepare next packet */
;;;481        //Ymodem_PreparePacket(buf_ptr, &packet_data[0], blkNumber, size);
;;;482        Ymodem_PreparePacket(flash, buf_ptr, &packet_data[0], blkNumber, size);
000098  9500              STR      r5,[sp,#0]
00009a  f00803ff          AND      r3,r8,#0xff
00009e  aa01              ADD      r2,sp,#4
0000a0  4639              MOV      r1,r7
0000a2  f8dd0514          LDR      r0,[sp,#0x514]
0000a6  f7fffffe          BL       Ymodem_PreparePacket
;;;483        ackReceived = 0;
0000aa  f04f0b00          MOV      r11,#0
;;;484        receivedC[0]= 0;
0000ae  f88db50c          STRB     r11,[sp,#0x50c]
;;;485        errors = 0;
0000b2  465e              MOV      r6,r11
                  |L11.180|
;;;486        do
;;;487        {
;;;488          /* Send next packet */
;;;489          if (size >= PACKET_1K_SIZE)
0000b4  f44f6480          MOV      r4,#0x400
0000b8  42a5              CMP      r5,r4
0000ba  d200              BCS      |L11.190|
;;;490          {
;;;491            pktSize = PACKET_1K_SIZE;
;;;492           
;;;493          }
;;;494          else
;;;495          {
;;;496            pktSize = PACKET_SIZE;
0000bc  2480              MOVS     r4,#0x80
                  |L11.190|
;;;497          }
;;;498          Ymodem_SendPacket(packet_data, pktSize + PACKET_HEADER);
0000be  1ce1              ADDS     r1,r4,#3
0000c0  a801              ADD      r0,sp,#4
0000c2  f7fffffe          BL       Ymodem_SendPacket
;;;499          /* Send CRC or Check Sum based on CRC16_F */
;;;500          /* Send CRC or Check Sum based on CRC16_F */
;;;501          if (CRC16_F)
0000c6  f1ba0f00          CMP      r10,#0
;;;502          {
;;;503             tempCRC = Cal_CRC16(&packet_data[3], pktSize);
;;;504             Send_Byte(tempCRC >> 8);
;;;505             Send_Byte(tempCRC & 0xFF);
;;;506          }
;;;507          else
;;;508          {
;;;509            tempCheckSum = CalChecksum (&packet_data[3], pktSize);
0000ca  4621              MOV      r1,r4
0000cc  f10d0007          ADD      r0,sp,#7
0000d0  d008              BEQ      |L11.228|
0000d2  f7fffffe          BL       Cal_CRC16
0000d6  4681              MOV      r9,r0                 ;503
0000d8  0a00              LSRS     r0,r0,#8              ;504
0000da  f7fffffe          BL       Send_Byte
0000de  f00900ff          AND      r0,r9,#0xff           ;505
0000e2  e001              B        |L11.232|
                  |L11.228|
0000e4  f7fffffe          BL       CalChecksum
                  |L11.232|
;;;510            Send_Byte(tempCheckSum);
0000e8  f7fffffe          BL       Send_Byte
;;;511          }
;;;512          
;;;513          /* Wait for Ack */
;;;514          if ((Receive_Byte(&receivedC[0], 1000) == 0)  && (receivedC[0] == ACK))
0000ec  f44f717a          MOV      r1,#0x3e8
0000f0  f20d500c          ADD      r0,sp,#0x50c
0000f4  f7fffffe          BL       Receive_Byte
0000f8  b918              CBNZ     r0,|L11.258|
0000fa  f89d050c          LDRB     r0,[sp,#0x50c]
0000fe  2806              CMP      r0,#6
000100  d004              BEQ      |L11.268|
                  |L11.258|
000102  1c76              ADDS     r6,r6,#1
;;;515          {
;;;516            ackReceived = 1;  
;;;517            if (size > pktSize)
;;;518            {
;;;519               buf_ptr += pktSize;  
;;;520               size -= pktSize;
;;;521               blkNumber++;
;;;522            }
;;;523            else
;;;524            {
;;;525              buf_ptr += pktSize;
;;;526              size = 0;
;;;527            }
;;;528          }
;;;529          else
;;;530          {
;;;531            errors++;
;;;532          }
;;;533        }while(!ackReceived && (errors < 0x0A));
000104  f1bb0f00          CMP      r11,#0
000108  d011              BEQ      |L11.302|
00010a  e009              B        |L11.288|
                  |L11.268|
00010c  42a5              CMP      r5,r4                 ;517
00010e  4427              ADD      r7,r7,r4              ;525
000110  d905              BLS      |L11.286|
000112  f1080001          ADD      r0,r8,#1              ;521
000116  1b2d              SUBS     r5,r5,r4              ;520
000118  fa1ff880          UXTH     r8,r0                 ;521
00011c  e000              B        |L11.288|
                  |L11.286|
00011e  2500              MOVS     r5,#0                 ;526
                  |L11.288|
;;;534        /* Resend packet if NAK  for a count of 10 else end of communication */
;;;535        
;;;536        if (errors >=  0x0A)
000120  2e0a              CMP      r6,#0xa
000122  d307              BCC      |L11.308|
                  |L11.292|
;;;537        {
;;;538          return errors;
000124  b2f0              UXTB     r0,r6
                  |L11.294|
;;;539        }
;;;540        
;;;541      }
;;;542      ackReceived = 0;
;;;543      receivedC[0] = 0x00;
;;;544      errors = 0;
;;;545      do 
;;;546      {
;;;547        Send_Byte(EOT);
;;;548        /* Send (EOT); */
;;;549        /* Wait for Ack */
;;;550        if ((Receive_Byte(&receivedC[0], 1000) == 0)  && receivedC[0] == ACK)
;;;551        {
;;;552          ackReceived = 1;  
;;;553        }
;;;554        else
;;;555        {
;;;556          errors++;
;;;557        }
;;;558      }while (!ackReceived && (errors < 0x0A));
;;;559        
;;;560      if (errors >=  0x0A)
;;;561      {
;;;562        return errors;
;;;563      }
;;;564      
;;;565      /* Last packet preparation */
;;;566      ackReceived = 0;
;;;567      receivedC[0] = 0x00;
;;;568      errors = 0;
;;;569    
;;;570      packet_data[0] = SOH;
;;;571      packet_data[1] = 0;
;;;572      packet_data [2] = 0xFF;
;;;573    
;;;574      for (i = PACKET_HEADER; i < (PACKET_SIZE + PACKET_HEADER); i++)
;;;575      {
;;;576         packet_data [i] = 0x00;
;;;577      }
;;;578      
;;;579      do 
;;;580      {
;;;581        /* Send Packet */
;;;582        Ymodem_SendPacket(packet_data, PACKET_SIZE + PACKET_HEADER);
;;;583    
;;;584        /* Send CRC or Check Sum based on CRC16_F */
;;;585        tempCRC = Cal_CRC16(&packet_data[3], PACKET_SIZE);
;;;586        Send_Byte(tempCRC >> 8);
;;;587        Send_Byte(tempCRC & 0xFF);
;;;588      
;;;589        /* Wait for Ack and 'C' */
;;;590        if (Receive_Byte(&receivedC[0], 1000) == 0)  
;;;591        {
;;;592          if (receivedC[0] == ACK)
;;;593          { 
;;;594            /* Packet transferred correctly */
;;;595            ackReceived = 1;
;;;596          }
;;;597        }
;;;598        else
;;;599        {
;;;600            errors++;
;;;601        }
;;;602      }while (!ackReceived && (errors < 0x0A));
;;;603    
;;;604      /* Resend packet if NAK  for a count of 10  else end of communication */
;;;605      if (errors >=  0x0A)
;;;606      {
;;;607        return errors;
;;;608      }  
;;;609      
;;;610      do 
;;;611      {
;;;612        Send_Byte(EOT);
;;;613        /* Send (EOT); */
;;;614        /* Wait for Ack */
;;;615        if ((Receive_Byte(&receivedC[0], 10) == 0)  && receivedC[0] == ACK)
;;;616        {
;;;617          ackReceived = 1;  
;;;618        }
;;;619        else
;;;620        {
;;;621          errors++;
;;;622        }
;;;623      }while (!ackReceived && (errors < 0x0A));
;;;624    
;;;625      if (errors >=  0x0A)
;;;626      {
;;;627        return errors;
;;;628      }
;;;629      
;;;630      return 0; /* file transmitted successfully */
;;;631    }
000126  f20d5d24          ADD      sp,sp,#0x524
00012a  e8bd8ff0          POP      {r4-r11,pc}
                  |L11.302|
00012e  2e0a              CMP      r6,#0xa               ;533
000130  d3c0              BCC      |L11.180|
000132  e7f7              B        |L11.292|
                  |L11.308|
000134  2d00              CMP      r5,#0                 ;478
000136  d1af              BNE      |L11.152|
000138  46a8              MOV      r8,r5                 ;543
00013a  f88d550c          STRB     r5,[sp,#0x50c]        ;543
00013e  462c              MOV      r4,r5                 ;544
000140  f44f777a          MOV      r7,#0x3e8             ;453
                  |L11.324|
000144  2004              MOVS     r0,#4                 ;547
000146  f7fffffe          BL       Send_Byte
00014a  4639              MOV      r1,r7                 ;550
00014c  f20d500c          ADD      r0,sp,#0x50c          ;550
000150  f7fffffe          BL       Receive_Byte
000154  b918              CBNZ     r0,|L11.350|
000156  f89d050c          LDRB     r0,[sp,#0x50c]        ;550
00015a  2806              CMP      r0,#6                 ;550
00015c  d001              BEQ      |L11.354|
                  |L11.350|
00015e  1c64              ADDS     r4,r4,#1              ;550
000160  b375              CBZ      r5,|L11.448|
                  |L11.354|
000162  2c0a              CMP      r4,#0xa               ;560
000164  d24b              BCS      |L11.510|
000166  2001              MOVS     r0,#1                 ;570
000168  f88d0004          STRB     r0,[sp,#4]            ;570
00016c  2500              MOVS     r5,#0                 ;566
00016e  f88d8005          STRB     r8,[sp,#5]            ;571
000172  20ff              MOVS     r0,#0xff              ;572
000174  f88d0006          STRB     r0,[sp,#6]            ;572
000178  f88d850c          STRB     r8,[sp,#0x50c]        ;567
00017c  462c              MOV      r4,r5                 ;568
00017e  2003              MOVS     r0,#3                 ;574
000180  ae01              ADD      r6,sp,#4              ;414
                  |L11.386|
000182  f8068000          STRB     r8,[r6,r0]            ;576
000186  1c40              ADDS     r0,r0,#1              ;576
000188  b2c0              UXTB     r0,r0                 ;574
00018a  2883              CMP      r0,#0x83              ;574
00018c  d3f9              BCC      |L11.386|
00018e  46b8              MOV      r8,r7                 ;453
                  |L11.400|
000190  2183              MOVS     r1,#0x83              ;582
000192  a801              ADD      r0,sp,#4              ;582
000194  f7fffffe          BL       Ymodem_SendPacket
000198  2180              MOVS     r1,#0x80              ;585
00019a  1cf0              ADDS     r0,r6,#3              ;585
00019c  f7fffffe          BL       Cal_CRC16
0001a0  4607              MOV      r7,r0                 ;585
0001a2  0a00              LSRS     r0,r0,#8              ;586
0001a4  f7fffffe          BL       Send_Byte
0001a8  b2f8              UXTB     r0,r7                 ;587
0001aa  f7fffffe          BL       Send_Byte
0001ae  4641              MOV      r1,r8                 ;590
0001b0  f20d500c          ADD      r0,sp,#0x50c          ;590
0001b4  f7fffffe          BL       Receive_Byte
0001b8  b128              CBZ      r0,|L11.454|
0001ba  1c64              ADDS     r4,r4,#1              ;590
                  |L11.444|
0001bc  b1a5              CBZ      r5,|L11.488|
0001be  e007              B        |L11.464|
                  |L11.448|
0001c0  2c0a              CMP      r4,#0xa               ;558
0001c2  d3bf              BCC      |L11.324|
0001c4  e01b              B        |L11.510|
                  |L11.454|
0001c6  f89d050c          LDRB     r0,[sp,#0x50c]        ;592
0001ca  2806              CMP      r0,#6                 ;592
0001cc  d1f6              BNE      |L11.444|
0001ce  2501              MOVS     r5,#1                 ;595
                  |L11.464|
0001d0  2c0a              CMP      r4,#0xa               ;605
0001d2  d214              BCS      |L11.510|
                  |L11.468|
0001d4  2004              MOVS     r0,#4                 ;612
0001d6  f7fffffe          BL       Send_Byte
0001da  210a              MOVS     r1,#0xa               ;615
0001dc  f20d500c          ADD      r0,sp,#0x50c          ;615
0001e0  f7fffffe          BL       Receive_Byte
0001e4  b118              CBZ      r0,|L11.494|
0001e6  e006              B        |L11.502|
                  |L11.488|
0001e8  2c0a              CMP      r4,#0xa               ;602
0001ea  d3d1              BCC      |L11.400|
0001ec  e007              B        |L11.510|
                  |L11.494|
0001ee  f89d050c          LDRB     r0,[sp,#0x50c]        ;615
0001f2  2806              CMP      r0,#6                 ;615
0001f4  d001              BEQ      |L11.506|
                  |L11.502|
0001f6  1c64              ADDS     r4,r4,#1              ;615
0001f8  b11d              CBZ      r5,|L11.514|
                  |L11.506|
0001fa  2c0a              CMP      r4,#0xa               ;625
0001fc  d304              BCC      |L11.520|
                  |L11.510|
0001fe  b2e0              UXTB     r0,r4                 ;627
000200  e791              B        |L11.294|
                  |L11.514|
000202  2c0a              CMP      r4,#0xa               ;623
000204  d3e6              BCC      |L11.468|
000206  e7fa              B        |L11.510|
                  |L11.520|
000208  2000              MOVS     r0,#0                 ;630
00020a  e78c              B        |L11.294|
;;;632    
                          ENDP


;*** Start embedded assembler ***

#line 1 "..\\..\\..\\..\\Bootloader\\ymodem.c"
	AREA ||.rev16_text||, CODE
	THUMB
	EXPORT |__asm___8_ymodem_c_80b47e87____REV16|
#line 114 "..\\..\\..\\..\\Platform\\Cortex-M4\\CMSIS\\core_cmInstr.h"
|__asm___8_ymodem_c_80b47e87____REV16| PROC
#line 115

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

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
