; 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\demo\mico-fire_f429\obj_rvmdk\spi_flash.o --asm_dir=..\..\..\..\Build\demo\MICO-Fire_F429\list_RVMDK\ --list_dir=..\..\..\..\Build\demo\MICO-Fire_F429\list_RVMDK\ --depend=..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\spi_flash.d --cpu=Cortex-M4.fp --apcs=interwork -O0 --diag_suppress=9931,1,1293 -I..\..\..\..\Board\fire_F429 -I..\..\..\..\Demos\fire\ov2640 -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 -I..\..\..\..\libraries\daemons\homekit_server -I..\..\..\..\libraries\daemons\http_server -I..\..\..\..\Platform\Drivers\malloc -I..\..\..\..\Platform\Drivers\SDRAM -I..\..\..\..\Platform\Drivers\ov5640 -IG:\GIT_OSC\STM32_develop\F429-V2\develop\6-WIFI\STM32-WiFi\3.wifi_ov5640\Projects\STM32F429\demo\RVMDK\RTE -IC:\Keil_v5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0\Drivers\CMSIS\Device\ST\STM32F4xx\Include -IC:\Keil_v5\ARM\CMSIS\Include -IC:\Keil_v5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0 -D__UVISION_VERSION=515 -DSTM32F429xx -DUSE_STDPERIPH_DRIVER -DDEBUG -DHSE_VALUE=25000000 -DOV5640 --omf_browse=..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\spi_flash.crf ..\..\..\..\Platform\Drivers\spi_flash\spi_flash.c]
                          THUMB

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

                  generic_sflash_command PROC
;;;434    
;;;435    int generic_sflash_command(                                      const sflash_handle_t* const handle,
000000  e92d47ff          PUSH     {r0-r10,lr}
;;;436                                                                     sflash_command_t             cmd,
;;;437                                                                     unsigned long                num_initial_parameter_bytes,
;;;438                                /*@null@*/ /*@observer@*/            const void* const            parameter_bytes,
;;;439                                                                     unsigned long                num_data_bytes,
;;;440                                /*@null@*/ /*@observer@*/            const void* const            data_MOSI,
;;;441                                /*@null@*/ /*@out@*/ /*@dependent@*/ void* const                  data_MISO )
;;;442    {
000004  b08a              SUB      sp,sp,#0x28
000006  4605              MOV      r5,r0
000008  4616              MOV      r6,r2
00000a  461f              MOV      r7,r3
00000c  e9dd9a17          LDRD     r9,r10,[sp,#0x5c]
000010  f8dd8058          LDR      r8,[sp,#0x58]
;;;443        int status;
;;;444        
;;;445        sflash_platform_message_segment_t segments[3] =
000014  2224              MOVS     r2,#0x24
000016  491f              LDR      r1,|L1.148|
000018  a801              ADD      r0,sp,#4
00001a  f7fffffe          BL       __aeabi_memcpy4
00001e  a80b              ADD      r0,sp,#0x2c
000020  9001              STR      r0,[sp,#4]
000022  9704              STR      r7,[sp,#0x10]
000024  9606              STR      r6,[sp,#0x18]
000026  f8cd901c          STR      r9,[sp,#0x1c]
00002a  f8cda020          STR      r10,[sp,#0x20]
00002e  f8cd8024          STR      r8,[sp,#0x24]
;;;446        {
;;;447                { &cmd,            NULL,       (unsigned long) 1 },
;;;448                { parameter_bytes, NULL,       num_initial_parameter_bytes },
;;;449                /*@-compdef@*/ /* Lint: Tell lint that it is OK that data_MISO is not completely defined */
;;;450                { data_MOSI,       data_MISO,  num_data_bytes }
;;;451                /*@+compdef@*/
;;;452        };
;;;453    
;;;454    
;;;455        status = sflash_platform_send_recv( handle->platform_peripheral, segments, (unsigned int) 3  );
000032  2203              MOVS     r2,#3
000034  a901              ADD      r1,sp,#4
000036  6868              LDR      r0,[r5,#4]
000038  f7fffffe          BL       sflash_platform_send_recv
00003c  4604              MOV      r4,r0
;;;456    
;;;457        if ( status != 0 )
00003e  b11c              CBZ      r4,|L1.72|
;;;458        {
;;;459            /*@-mustdefine@*/ /* Lint: do not need to define data_MISO due to failure */
;;;460            return status;
000040  4620              MOV      r0,r4
                  |L1.66|
;;;461            /*@+mustdefine@*/
;;;462        }
;;;463    
;;;464        if ( is_write_command( cmd ) == 1 )
;;;465        {
;;;466            unsigned char status_register;
;;;467            /* write commands require waiting until chip is finished writing */
;;;468    
;;;469            do
;;;470            {
;;;471                status = sflash_read_status_register( handle, &status_register );
;;;472                if ( status != 0 )
;;;473                {
;;;474                    /*@-mustdefine@*/ /* Lint: do not need to define data_MISO due to failure */
;;;475                    return status;
;;;476                    /*@+mustdefine@*/
;;;477                }
;;;478            } while( ( status_register & SFLASH_STATUS_REGISTER_BUSY ) != (unsigned char) 0 );
;;;479    
;;;480        }
;;;481    
;;;482        /*@-mustdefine@*/ /* Lint: lint does not realise data_MISO was set by sflash_platform_send_recv */
;;;483        return 0;
;;;484        /*@+mustdefine@*/
;;;485    }
000042  b00e              ADD      sp,sp,#0x38
000044  e8bd87f0          POP      {r4-r10,pc}
                  |L1.72|
000048  f89d002c          LDRB     r0,[sp,#0x2c]         ;464
00004c  2802              CMP      r0,#2                 ;464
00004e  d009              BEQ      |L1.100|
000050  2860              CMP      r0,#0x60              ;464
000052  d007              BEQ      |L1.100|
000054  28c7              CMP      r0,#0xc7              ;464
000056  d005              BEQ      |L1.100|
000058  2820              CMP      r0,#0x20              ;464
00005a  d003              BEQ      |L1.100|
00005c  2852              CMP      r0,#0x52              ;464
00005e  d001              BEQ      |L1.100|
000060  28d8              CMP      r0,#0xd8              ;464
000062  d101              BNE      |L1.104|
                  |L1.100|
000064  2101              MOVS     r1,#1                 ;464
000066  e000              B        |L1.106|
                  |L1.104|
000068  2100              MOVS     r1,#0                 ;464
                  |L1.106|
00006a  2901              CMP      r1,#1                 ;464
00006c  d10f              BNE      |L1.142|
00006e  bf00              NOP                            ;469
                  |L1.112|
000070  4669              MOV      r1,sp                 ;471
000072  4628              MOV      r0,r5                 ;471
000074  f7fffffe          BL       sflash_read_status_register
000078  4604              MOV      r4,r0                 ;471
00007a  b10c              CBZ      r4,|L1.128|
00007c  4620              MOV      r0,r4                 ;475
00007e  e7e0              B        |L1.66|
                  |L1.128|
000080  f89d0000          LDRB     r0,[sp,#0]            ;478
000084  f0000001          AND      r0,r0,#1              ;478
000088  2800              CMP      r0,#0                 ;478
00008a  d1f1              BNE      |L1.112|
00008c  bf00              NOP                            ;480
                  |L1.142|
00008e  2000              MOVS     r0,#0                 ;483
000090  e7d7              B        |L1.66|
;;;486    
                          ENDP

000092  0000              DCW      0x0000
                  |L1.148|
                          DCD      ||.constdata||+0x48

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

                  init_sflash PROC
;;;386    
;;;387    int init_sflash( /*@out@*/ sflash_handle_t* const handle, /*@shared@*/ void* peripheral_id, sflash_write_allowed_t write_allowed_in )
000000  b5f8              PUSH     {r3-r7,lr}
;;;388    {
000002  4604              MOV      r4,r0
000004  460f              MOV      r7,r1
000006  4615              MOV      r5,r2
;;;389       int status;
;;;390        device_id_t tmp_device_id;
;;;391    
;;;392        status = sflash_platform_init( peripheral_id, &handle->platform_peripheral );
000008  1d21              ADDS     r1,r4,#4
00000a  4638              MOV      r0,r7
00000c  f7fffffe          BL       sflash_platform_init
000010  4606              MOV      r6,r0
;;;393        if ( status != 0 )
000012  b10e              CBZ      r6,|L2.24|
;;;394        {
;;;395            return status;
000014  4630              MOV      r0,r6
                  |L2.22|
;;;396        }
;;;397    
;;;398        handle->write_allowed = write_allowed_in;
;;;399        handle->device_id     = 0;
;;;400    
;;;401        status = sflash_read_ID( handle, &tmp_device_id );
;;;402        if ( status != 0 )
;;;403        {
;;;404            return status;
;;;405        }
;;;406    
;;;407        handle->device_id = ( ((uint32_t) tmp_device_id.id[0]) << 16 ) +
;;;408                            ( ((uint32_t) tmp_device_id.id[1]) <<  8 ) +
;;;409                            ( ((uint32_t) tmp_device_id.id[2]) <<  0 );
;;;410    
;;;411    
;;;412        if ( write_allowed_in == SFLASH_WRITE_ALLOWED )
;;;413        {
;;;414            /* Enable writing */
;;;415            if (0 != ( status = sflash_write_enable( handle ) ) )
;;;416            {
;;;417                return status;
;;;418            }
;;;419        }
;;;420    
;;;421        return 0;
;;;422    }
000016  bdf8              POP      {r3-r7,pc}
                  |L2.24|
000018  7225              STRB     r5,[r4,#8]            ;398
00001a  2000              MOVS     r0,#0                 ;399
00001c  6020              STR      r0,[r4,#0]            ;399
00001e  4669              MOV      r1,sp                 ;401
000020  4620              MOV      r0,r4                 ;401
000022  f7fffffe          BL       sflash_read_ID
000026  4606              MOV      r6,r0                 ;401
000028  b10e              CBZ      r6,|L2.46|
00002a  4630              MOV      r0,r6                 ;404
00002c  e7f3              B        |L2.22|
                  |L2.46|
00002e  f89d0000          LDRB     r0,[sp,#0]            ;407
000032  0400              LSLS     r0,r0,#16             ;407
000034  f89d1001          LDRB     r1,[sp,#1]            ;407
000038  eb002001          ADD      r0,r0,r1,LSL #8       ;407
00003c  f89d1002          LDRB     r1,[sp,#2]            ;407
000040  4408              ADD      r0,r0,r1              ;407
000042  6020              STR      r0,[r4,#0]            ;407
000044  2d01              CMP      r5,#1                 ;412
000046  d106              BNE      |L2.86|
000048  4620              MOV      r0,r4                 ;415
00004a  f7fffffe          BL       sflash_write_enable
00004e  0006              MOVS     r6,r0                 ;415
000050  d001              BEQ      |L2.86|
000052  4630              MOV      r0,r6                 ;417
000054  e7df              B        |L2.22|
                  |L2.86|
000056  2000              MOVS     r0,#0                 ;421
000058  e7dd              B        |L2.22|
;;;423    
                          ENDP


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

                  sflash_chip_erase PROC
;;;85     
;;;86     int sflash_chip_erase( const sflash_handle_t* const handle )
000000  b53e              PUSH     {r1-r5,lr}
;;;87     {
000002  4605              MOV      r5,r0
;;;88         int status = sflash_write_enable( handle );
000004  4628              MOV      r0,r5
000006  f7fffffe          BL       sflash_write_enable
00000a  4604              MOV      r4,r0
;;;89         if ( status != 0 )
00000c  b10c              CBZ      r4,|L3.18|
;;;90         {
;;;91             return status;
00000e  4620              MOV      r0,r4
                  |L3.16|
;;;92         }
;;;93         return generic_sflash_command( handle, SFLASH_CHIP_ERASE1, 0, NULL, 0, NULL, NULL );
;;;94     }
000010  bd3e              POP      {r1-r5,pc}
                  |L3.18|
000012  2000              MOVS     r0,#0                 ;93
000014  9000              STR      r0,[sp,#0]            ;93
000016  9001              STR      r0,[sp,#4]            ;93
000018  4603              MOV      r3,r0                 ;93
00001a  4602              MOV      r2,r0                 ;93
00001c  2160              MOVS     r1,#0x60              ;93
00001e  9002              STR      r0,[sp,#8]            ;93
000020  4628              MOV      r0,r5                 ;93
000022  f7fffffe          BL       generic_sflash_command
000026  e7f3              B        |L3.16|
;;;95     
                          ENDP


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

                  sflash_get_size PROC
;;;157    
;;;158    int sflash_get_size( const sflash_handle_t* const handle, /*@out@*/ unsigned long* const size )
000000  4602              MOV      r2,r0
;;;159    {
;;;160        *size = 0; /* Unknown size to start with */
000002  2000              MOVS     r0,#0
000004  6008              STR      r0,[r1,#0]
;;;161    
;;;162    #ifdef SFLASH_SUPPORT_MACRONIX_PARTS
;;;163        if ( handle->device_id == SFLASH_ID_MX25L8006E )
;;;164        {
;;;165            *size = (unsigned long) 0x100000; /* 1MByte */
;;;166        }
;;;167        else if ( handle->device_id == SFLASH_ID_MX25L1606E )
;;;168        {
;;;169            *size = (unsigned long) 0x200000; /* 2MByte */
;;;170        }
;;;171    #endif /* ifdef SFLASH_SUPPORT_MACRONIX_PARTS */
;;;172    #ifdef SFLASH_SUPPORT_SST_PARTS
;;;173        if ( handle->device_id == SFLASH_ID_SST25VF080B )
;;;174        {
;;;175            *size = (unsigned long) 0x100000; /* 1MByte */
;;;176        }
;;;177    #endif /* ifdef SFLASH_SUPPORT_SST_PARTS */
;;;178    #ifdef SFLASH_SUPPORT_EON_PARTS
;;;179        if ( handle->device_id == SFLASH_ID_EN25QH16 )
;;;180        {
;;;181            *size = (unsigned long) 0x200000; /* 2MByte */
;;;182        }
;;;183    #endif /* ifdef SFLASH_SUPPORT_EON_PARTS */
;;;184    #ifdef SFLASH_SUPPORT_WINBOND_PARTS
;;;185        if ( handle->device_id == SFLASH_ID_W25X80AVSIG )
;;;186        {
;;;187            *size = (unsigned long) 0x100000; /* 1MByte */
;;;188        }
;;;189    #endif /* ifdef SFLASH_SUPPORT_WINBOND_PARTS */
;;;190        return 0;
;;;191    }
000006  4770              BX       lr
;;;192    
                          ENDP


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

                  sflash_read PROC
;;;120    
;;;121    int sflash_read( const sflash_handle_t* const handle, unsigned long device_address, void* const data_addr, unsigned int size )
000000  e92d41ff          PUSH     {r0-r8,lr}
;;;122    {
000004  4607              MOV      r7,r0
000006  460c              MOV      r4,r1
000008  4615              MOV      r5,r2
00000a  461e              MOV      r6,r3
;;;123        char device_address_array[3] =  { ( ( device_address & 0x00FF0000 ) >> 16 ),
00000c  0c20              LSRS     r0,r4,#16
00000e  f88d000c          STRB     r0,[sp,#0xc]
000012  0a20              LSRS     r0,r4,#8
000014  f88d000d          STRB     r0,[sp,#0xd]
000018  b2e0              UXTB     r0,r4
00001a  f88d000e          STRB     r0,[sp,#0xe]
;;;124                                          ( ( device_address & 0x0000FF00 ) >>  8 ),
;;;125                                          ( ( device_address & 0x000000FF ) >>  0 ) };
;;;126    
;;;127        return generic_sflash_command( handle, SFLASH_READ, 3, device_address_array, size, NULL, data_addr );
00001e  2000              MOVS     r0,#0
000020  ab03              ADD      r3,sp,#0xc
000022  2203              MOVS     r2,#3
000024  4611              MOV      r1,r2
000026  e9cd6000          STRD     r6,r0,[sp,#0]
00002a  9502              STR      r5,[sp,#8]
00002c  4638              MOV      r0,r7
00002e  f7fffffe          BL       generic_sflash_command
;;;128    }
000032  b004              ADD      sp,sp,#0x10
000034  e8bd81f0          POP      {r4-r8,pc}
;;;129    
                          ENDP


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

                  sflash_read_ID PROC
;;;39     
;;;40     int sflash_read_ID( const sflash_handle_t* const handle, void* const data_addr )
000000  b53e              PUSH     {r1-r5,lr}
;;;41     {
000002  4605              MOV      r5,r0
000004  460c              MOV      r4,r1
;;;42         return generic_sflash_command( handle, SFLASH_READ_JEDEC_ID, 0, NULL, 3, NULL, data_addr );
000006  2000              MOVS     r0,#0
000008  2103              MOVS     r1,#3
00000a  4603              MOV      r3,r0
00000c  4602              MOV      r2,r0
00000e  e9cd0401          STRD     r0,r4,[sp,#4]
000012  9100              STR      r1,[sp,#0]
000014  219f              MOVS     r1,#0x9f
000016  4628              MOV      r0,r5
000018  f7fffffe          BL       generic_sflash_command
;;;43     }
00001c  bd3e              POP      {r1-r5,pc}
;;;44     
                          ENDP


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

                  sflash_read_status_register PROC
;;;113    
;;;114    int sflash_read_status_register( const sflash_handle_t* const handle, void* const dest_addr )
000000  b53e              PUSH     {r1-r5,lr}
;;;115    {
000002  4605              MOV      r5,r0
000004  460c              MOV      r4,r1
;;;116        return generic_sflash_command( handle, SFLASH_READ_STATUS_REGISTER, 0, NULL, 1, NULL, dest_addr );
000006  2000              MOVS     r0,#0
000008  2101              MOVS     r1,#1
00000a  4603              MOV      r3,r0
00000c  4602              MOV      r2,r0
00000e  e9cd0401          STRD     r0,r4,[sp,#4]
000012  9100              STR      r1,[sp,#0]
000014  2105              MOVS     r1,#5
000016  4628              MOV      r0,r5
000018  f7fffffe          BL       generic_sflash_command
;;;117    }
00001c  bd3e              POP      {r1-r5,pc}
;;;118    
                          ENDP


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

                          REQUIRE _printf_pre_padding
                          REQUIRE _printf_percent
                          REQUIRE _printf_widthprec
                          REQUIRE _printf_d
                          REQUIRE _printf_s
                          REQUIRE _printf_int_dec
                          REQUIRE _printf_str
                  sflash_sector_erase PROC
;;;95     
;;;96     int sflash_sector_erase ( const sflash_handle_t* const handle, unsigned long device_address )
000000  e92d47ff          PUSH     {r0-r10,lr}
;;;97     {
000004  4607              MOV      r7,r0
000006  460c              MOV      r4,r1
;;;98     
;;;99         char device_address_array[3] =  { ( ( device_address & 0x00FF0000 ) >> 16 ),
000008  0c20              LSRS     r0,r4,#16
00000a  f88d000c          STRB     r0,[sp,#0xc]
00000e  0a20              LSRS     r0,r4,#8
000010  f88d000d          STRB     r0,[sp,#0xd]
000014  b2e0              UXTB     r0,r4
000016  f88d000e          STRB     r0,[sp,#0xe]
;;;100                                          ( ( device_address & 0x0000FF00 ) >>  8 ),
;;;101                                          ( ( device_address & 0x000000FF ) >>  0 ) };
;;;102    
;;;103        int retval;
;;;104        int status = sflash_write_enable( handle );
00001a  4638              MOV      r0,r7
00001c  f7fffffe          BL       sflash_write_enable
000020  4606              MOV      r6,r0
;;;105        if ( status != 0 )
000022  b11e              CBZ      r6,|L8.44|
;;;106        {
;;;107            return status;
000024  4630              MOV      r0,r6
                  |L8.38|
;;;108        }
;;;109        retval = generic_sflash_command( handle, SFLASH_SECTOR_ERASE, 3, device_address_array, 0, NULL, NULL );
;;;110        check_string(retval == 0, "SPI Flash erase error");
;;;111        return retval;
;;;112    }
000026  b004              ADD      sp,sp,#0x10
000028  e8bd87f0          POP      {r4-r10,pc}
                  |L8.44|
00002c  2000              MOVS     r0,#0                 ;109
00002e  9000              STR      r0,[sp,#0]            ;109
000030  9001              STR      r0,[sp,#4]            ;109
000032  ab03              ADD      r3,sp,#0xc            ;109
000034  2203              MOVS     r2,#3                 ;109
000036  2120              MOVS     r1,#0x20              ;109
000038  9002              STR      r0,[sp,#8]            ;109
00003a  4638              MOV      r0,r7                 ;109
00003c  f7fffffe          BL       generic_sflash_command
000040  4605              MOV      r5,r0                 ;109
000042  bf00              NOP                            ;110
000044  2d00              CMP      r5,#0                 ;110
000046  d02b              BEQ      |L8.160|
000048  bf00              NOP                            ;110
00004a  4817              LDR      r0,|L8.168|
00004c  6800              LDR      r0,[r0,#0]            ;110  ; mico_debug_enabled
00004e  b900              CBNZ     r0,|L8.82|
000050  e024              B        |L8.156|
                  |L8.82|
000052  4816              LDR      r0,|L8.172|
000054  f7fffffe          BL       mico_rtos_lock_mutex
000058  215c              MOVS     r1,#0x5c              ;110
00005a  a015              ADR      r0,|L8.176|
00005c  f7fffffe          BL       strrchr
000060  b128              CBZ      r0,|L8.110|
000062  215c              MOVS     r1,#0x5c              ;110
000064  a012              ADR      r0,|L8.176|
000066  f7fffffe          BL       strrchr
00006a  1c40              ADDS     r0,r0,#1              ;110
00006c  e000              B        |L8.112|
                  |L8.110|
00006e  a010              ADR      r0,|L8.176|
                  |L8.112|
000070  4680              MOV      r8,r0                 ;110
000072  f7fffffe          BL       mico_get_time
000076  4681              MOV      r9,r0                 ;110
000078  a01a              ADR      r0,|L8.228|
00007a  b108              CBZ      r0,|L8.128|
00007c  a019              ADR      r0,|L8.228|
00007e  e000              B        |L8.130|
                  |L8.128|
000080  a01e              ADR      r0,|L8.252|
                  |L8.130|
000082  216e              MOVS     r1,#0x6e              ;110
000084  4b1e              LDR      r3,|L8.256|
000086  4642              MOV      r2,r8                 ;110
000088  e9cd1000          STRD     r1,r0,[sp,#0]         ;110
00008c  4649              MOV      r1,r9                 ;110
00008e  a01d              ADR      r0,|L8.260|
000090  f7fffffe          BL       __2printf
000094  4805              LDR      r0,|L8.172|
000096  f7fffffe          BL       mico_rtos_unlock_mutex
00009a  bf00              NOP                            ;110
                  |L8.156|
00009c  bf00              NOP                            ;110
00009e  be00              BKPT     #0                    ;110
                  |L8.160|
0000a0  bf00              NOP                            ;110
0000a2  4628              MOV      r0,r5                 ;111
0000a4  e7bf              B        |L8.38|
;;;113    
                          ENDP

0000a6  0000              DCW      0x0000
                  |L8.168|
                          DCD      mico_debug_enabled
                  |L8.172|
                          DCD      stdio_tx_mutex
                  |L8.176|
0000b0  2e2e5c2e          DCB      "..\\..\\..\\..\\Platform\\Drivers\\spi_flash\\spi_flash"
0000b4  2e5c2e2e
0000b8  5c2e2e5c
0000bc  506c6174
0000c0  666f726d
0000c4  5c447269
0000c8  76657273
0000cc  5c737069
0000d0  5f666c61
0000d4  73685c73
0000d8  70695f66
0000dc  6c617368
0000e0  2e6300            DCB      ".c",0
0000e3  00                DCB      0
                  |L8.228|
0000e4  53504920          DCB      "SPI Flash erase error",0
0000e8  466c6173
0000ec  68206572
0000f0  61736520
0000f4  6572726f
0000f8  7200    
0000fa  00                DCB      0
0000fb  00                DCB      0
                  |L8.252|
0000fc  00                DCB      0
0000fd  00                DCB      0
0000fe  00                DCB      0
0000ff  00                DCB      0
                  |L8.256|
                          DCD      __PRETTY_FUNCTION__
                  |L8.260|
000104  5b25645d          DCB      "[%d][MICO:%s:%s:%4d] **ASSERT** %s\r\n",0
000108  5b4d4943
00010c  4f3a2573
000110  3a25733a
000114  2534645d
000118  202a2a41
00011c  53534552
000120  542a2a20
000124  25730d0a
000128  00      
000129  00                DCB      0
00012a  00                DCB      0
00012b  00                DCB      0

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

                  sflash_write PROC
;;;288      */
;;;289    int sflash_write( const sflash_handle_t* const handle, unsigned long device_address, const void* const data_addr, unsigned int size )
000000  e92d4fff          PUSH     {r0-r11,lr}
;;;290    {
000004  b083              SUB      sp,sp,#0xc
000006  460d              MOV      r5,r1
000008  4693              MOV      r11,r2
00000a  461e              MOV      r6,r3
;;;291      int status;
;;;292      uint8_t NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0, temp = 0;
00000c  f04f0900          MOV      r9,#0
000010  46ca              MOV      r10,r9
000012  2000              MOVS     r0,#0
000014  9002              STR      r0,[sp,#8]
000016  2400              MOVS     r4,#0
000018  9001              STR      r0,[sp,#4]
;;;293      unsigned char* data_addr_ptr = (unsigned char*) data_addr;
00001a  46d8              MOV      r8,r11
;;;294    
;;;295      Addr = device_address % sFLASH_SPI_PAGESIZE;
00001c  b2e8              UXTB     r0,r5
00001e  9002              STR      r0,[sp,#8]
;;;296      count = sFLASH_SPI_PAGESIZE - Addr;
000020  9802              LDR      r0,[sp,#8]
000022  4240              RSBS     r0,r0,#0
000024  b2c4              UXTB     r4,r0
;;;297      NumOfPage =  size / sFLASH_SPI_PAGESIZE;
000026  f3c62907          UBFX     r9,r6,#8,#8
;;;298      NumOfSingle = size % sFLASH_SPI_PAGESIZE;
00002a  f0060aff          AND      r10,r6,#0xff
;;;299    
;;;300      if (Addr == 0) /*!< WriteAddr is sFLASH_PAGESIZE aligned  */
00002e  9802              LDR      r0,[sp,#8]
000030  bb30              CBNZ     r0,|L9.128|
;;;301      {
;;;302        if (NumOfPage == 0) /*!< NumByteToWrite < sFLASH_PAGESIZE */
000032  f1b90f00          CMP      r9,#0
000036  d107              BNE      |L9.72|
;;;303        {
;;;304          status = sflash_write_page( handle, device_address, data_addr_ptr, size );
000038  4633              MOV      r3,r6
00003a  4642              MOV      r2,r8
00003c  4629              MOV      r1,r5
00003e  9803              LDR      r0,[sp,#0xc]
000040  f7fffffe          BL       sflash_write_page
000044  4607              MOV      r7,r0
000046  e069              B        |L9.284|
                  |L9.72|
;;;305          //sFLASH_WritePage(pBuffer, WriteAddr, NumByteToWrite);
;;;306        }
;;;307        else /*!< NumByteToWrite > sFLASH_PAGESIZE */
;;;308        {
;;;309          while (NumOfPage--)
000048  e00b              B        |L9.98|
                  |L9.74|
;;;310          {
;;;311            status = sflash_write_page( handle, device_address, data_addr_ptr, sFLASH_SPI_PAGESIZE );
00004a  f44f7380          MOV      r3,#0x100
00004e  4642              MOV      r2,r8
000050  4629              MOV      r1,r5
000052  9803              LDR      r0,[sp,#0xc]
000054  f7fffffe          BL       sflash_write_page
000058  4607              MOV      r7,r0
;;;312            //sFLASH_WritePage(pBuffer, WriteAddr, sFLASH_SPI_PAGESIZE);
;;;313            device_address +=  sFLASH_SPI_PAGESIZE;
00005a  f5057580          ADD      r5,r5,#0x100
;;;314            data_addr_ptr += sFLASH_SPI_PAGESIZE;
00005e  f5087880          ADD      r8,r8,#0x100
                  |L9.98|
000062  ea5f0009          MOVS     r0,r9                 ;309
000066  f1a90101          SUB      r1,r9,#1              ;309
00006a  f00109ff          AND      r9,r1,#0xff           ;309
00006e  d1ec              BNE      |L9.74|
;;;315          }
;;;316    
;;;317          status = sflash_write_page( handle, device_address, data_addr_ptr, NumOfSingle);
000070  4653              MOV      r3,r10
000072  4642              MOV      r2,r8
000074  4629              MOV      r1,r5
000076  9803              LDR      r0,[sp,#0xc]
000078  f7fffffe          BL       sflash_write_page
00007c  4607              MOV      r7,r0
00007e  e04d              B        |L9.284|
                  |L9.128|
;;;318        }
;;;319      }
;;;320      else /*!< WriteAddr is not sFLASH_PAGESIZE aligned  */
;;;321      {
;;;322        if (NumOfPage == 0) /*!< NumByteToWrite < sFLASH_PAGESIZE */
000080  f1b90f00          CMP      r9,#0
000084  d11e              BNE      |L9.196|
;;;323        {
;;;324          if (NumOfSingle > count) /*!< (NumByteToWrite + WriteAddr) > sFLASH_PAGESIZE */
000086  45a2              CMP      r10,r4
000088  dd14              BLE      |L9.180|
;;;325          {
;;;326            temp = NumOfSingle - count;
00008a  ebaa0004          SUB      r0,r10,r4
00008e  b2c0              UXTB     r0,r0
000090  9001              STR      r0,[sp,#4]
;;;327    
;;;328            status = sflash_write_page( handle, device_address, data_addr_ptr, count );
000092  4623              MOV      r3,r4
000094  4642              MOV      r2,r8
000096  4629              MOV      r1,r5
000098  9803              LDR      r0,[sp,#0xc]
00009a  f7fffffe          BL       sflash_write_page
00009e  4607              MOV      r7,r0
;;;329            //sFLASH_WritePage(pBuffer, WriteAddr, count);
;;;330            device_address +=  count;
0000a0  4425              ADD      r5,r5,r4
;;;331            data_addr_ptr += count;
0000a2  44a0              ADD      r8,r8,r4
;;;332    
;;;333            status = sflash_write_page( handle, device_address, data_addr_ptr, temp);
0000a4  4642              MOV      r2,r8
0000a6  4629              MOV      r1,r5
0000a8  9b01              LDR      r3,[sp,#4]
0000aa  9803              LDR      r0,[sp,#0xc]
0000ac  f7fffffe          BL       sflash_write_page
0000b0  4607              MOV      r7,r0
0000b2  e033              B        |L9.284|
                  |L9.180|
;;;334          }
;;;335          else
;;;336          {
;;;337            status = sflash_write_page(handle, device_address, data_addr_ptr, size);
0000b4  4633              MOV      r3,r6
0000b6  4642              MOV      r2,r8
0000b8  4629              MOV      r1,r5
0000ba  9803              LDR      r0,[sp,#0xc]
0000bc  f7fffffe          BL       sflash_write_page
0000c0  4607              MOV      r7,r0
0000c2  e02b              B        |L9.284|
                  |L9.196|
;;;338          }
;;;339        }
;;;340        else /*!< NumByteToWrite > sFLASH_PAGESIZE */
;;;341        {
;;;342          size -= count;
0000c4  1b36              SUBS     r6,r6,r4
;;;343          NumOfPage =  size / sFLASH_SPI_PAGESIZE;
0000c6  f3c62907          UBFX     r9,r6,#8,#8
;;;344          NumOfSingle = size % sFLASH_SPI_PAGESIZE;
0000ca  f0060aff          AND      r10,r6,#0xff
;;;345    
;;;346          status = sflash_write_page( handle, device_address, data_addr_ptr, count );
0000ce  4623              MOV      r3,r4
0000d0  4642              MOV      r2,r8
0000d2  4629              MOV      r1,r5
0000d4  9803              LDR      r0,[sp,#0xc]
0000d6  f7fffffe          BL       sflash_write_page
0000da  4607              MOV      r7,r0
;;;347          //sFLASH_WritePage(pBuffer, WriteAddr, count);
;;;348          device_address +=  count;
0000dc  4425              ADD      r5,r5,r4
;;;349          data_addr_ptr += count;
0000de  44a0              ADD      r8,r8,r4
;;;350    
;;;351          while (NumOfPage--)
0000e0  e00b              B        |L9.250|
                  |L9.226|
;;;352          {
;;;353            status = sflash_write_page( handle, device_address, data_addr_ptr, sFLASH_SPI_PAGESIZE );
0000e2  f44f7380          MOV      r3,#0x100
0000e6  4642              MOV      r2,r8
0000e8  4629              MOV      r1,r5
0000ea  9803              LDR      r0,[sp,#0xc]
0000ec  f7fffffe          BL       sflash_write_page
0000f0  4607              MOV      r7,r0
;;;354            //sFLASH_WritePage(pBuffer, WriteAddr, sFLASH_SPI_PAGESIZE);
;;;355            device_address +=  sFLASH_SPI_PAGESIZE;
0000f2  f5057580          ADD      r5,r5,#0x100
;;;356            data_addr_ptr += sFLASH_SPI_PAGESIZE;
0000f6  f5087880          ADD      r8,r8,#0x100
                  |L9.250|
0000fa  ea5f0009          MOVS     r0,r9                 ;351
0000fe  f1a90101          SUB      r1,r9,#1              ;351
000102  f00109ff          AND      r9,r1,#0xff           ;351
000106  d1ec              BNE      |L9.226|
;;;357          }
;;;358    
;;;359          if (NumOfSingle != 0)
000108  f1ba0f00          CMP      r10,#0
00010c  d006              BEQ      |L9.284|
;;;360          {
;;;361            status = sflash_write_page( handle, device_address, data_addr_ptr, NumOfSingle );
00010e  4653              MOV      r3,r10
000110  4642              MOV      r2,r8
000112  4629              MOV      r1,r5
000114  9803              LDR      r0,[sp,#0xc]
000116  f7fffffe          BL       sflash_write_page
00011a  4607              MOV      r7,r0
                  |L9.284|
;;;362            //sFLASH_WritePage(pBuffer, WriteAddr, NumOfSingle);
;;;363          }
;;;364        }
;;;365      }
;;;366      return status;
00011c  4638              MOV      r0,r7
;;;367    }
00011e  b007              ADD      sp,sp,#0x1c
000120  e8bd8ff0          POP      {r4-r11,pc}
;;;368    
                          ENDP


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

                  sflash_write_enable PROC
;;;44     
;;;45     int sflash_write_enable( const sflash_handle_t* const handle )
000000  b57f              PUSH     {r0-r6,lr}
;;;46     {
000002  4604              MOV      r4,r0
;;;47         if ( handle->write_allowed == SFLASH_WRITE_ALLOWED )
000004  7a20              LDRB     r0,[r4,#8]
000006  2801              CMP      r0,#1
000008  d132              BNE      |L10.112|
;;;48         {
;;;49             /* Send write-enable command */
;;;50             int status = generic_sflash_command( handle, SFLASH_WRITE_ENABLE, 0, NULL, 0, NULL, NULL );
00000a  2000              MOVS     r0,#0
00000c  9000              STR      r0,[sp,#0]
00000e  9001              STR      r0,[sp,#4]
000010  4603              MOV      r3,r0
000012  4602              MOV      r2,r0
000014  2106              MOVS     r1,#6
000016  9002              STR      r0,[sp,#8]
000018  4620              MOV      r0,r4
00001a  f7fffffe          BL       generic_sflash_command
00001e  4605              MOV      r5,r0
;;;51             if ( status != 0 )
000020  b115              CBZ      r5,|L10.40|
;;;52             {
;;;53                 return status;
000022  4628              MOV      r0,r5
                  |L10.36|
;;;54             }
;;;55     
;;;56             /* Check status register */
;;;57             unsigned char status_register;
;;;58             if ( 0 != ( status = sflash_read_status_register( handle, &status_register ) ) )
;;;59             {
;;;60                 return status;
;;;61             }
;;;62     
;;;63             /* Check if Block protect bits are set */
;;;64             if ( status_register != SFLASH_STATUS_REGISTER_WRITE_ENABLED )
;;;65             {
;;;66                 /* Disable protection for all blocks */
;;;67                 if (0 != ( status = sflash_write_status_register( handle, 0 ) ) )
;;;68                 {
;;;69                     return status;
;;;70                 }
;;;71     
;;;72                 /* Re-Enable writing */
;;;73                 if (0 != ( status = generic_sflash_command( handle, SFLASH_WRITE_ENABLE, 0, NULL, 0, NULL, NULL ) ) )
;;;74                 {
;;;75                     return status;
;;;76                 }
;;;77             }
;;;78             return 0;
;;;79         }
;;;80         else
;;;81         {
;;;82             return -1;
;;;83         }
;;;84     }
000024  b004              ADD      sp,sp,#0x10
000026  bd70              POP      {r4-r6,pc}
                  |L10.40|
000028  a903              ADD      r1,sp,#0xc            ;58
00002a  4620              MOV      r0,r4                 ;58
00002c  f7fffffe          BL       sflash_read_status_register
000030  0005              MOVS     r5,r0                 ;58
000032  d001              BEQ      |L10.56|
000034  4628              MOV      r0,r5                 ;60
000036  e7f5              B        |L10.36|
                  |L10.56|
000038  f89d000c          LDRB     r0,[sp,#0xc]          ;64
00003c  2802              CMP      r0,#2                 ;64
00003e  d015              BEQ      |L10.108|
000040  2100              MOVS     r1,#0                 ;67
000042  4620              MOV      r0,r4                 ;67
000044  f7fffffe          BL       sflash_write_status_register
000048  0005              MOVS     r5,r0                 ;67
00004a  d001              BEQ      |L10.80|
00004c  4628              MOV      r0,r5                 ;69
00004e  e7e9              B        |L10.36|
                  |L10.80|
000050  2000              MOVS     r0,#0                 ;73
000052  9000              STR      r0,[sp,#0]            ;73
000054  9001              STR      r0,[sp,#4]            ;73
000056  4603              MOV      r3,r0                 ;73
000058  4602              MOV      r2,r0                 ;73
00005a  2106              MOVS     r1,#6                 ;73
00005c  9002              STR      r0,[sp,#8]            ;73
00005e  4620              MOV      r0,r4                 ;73
000060  f7fffffe          BL       generic_sflash_command
000064  0005              MOVS     r5,r0                 ;73
000066  d001              BEQ      |L10.108|
000068  4628              MOV      r0,r5                 ;75
00006a  e7db              B        |L10.36|
                  |L10.108|
00006c  2000              MOVS     r0,#0                 ;78
00006e  e7d9              B        |L10.36|
                  |L10.112|
000070  f04f30ff          MOV      r0,#0xffffffff        ;82
000074  e7d6              B        |L10.36|
;;;85     
                          ENDP


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

                  sflash_write_page PROC
;;;193    
;;;194    int sflash_write_page( const sflash_handle_t* const handle, unsigned long device_address, const void* const data_addr, int size )
000000  e92d4ff0          PUSH     {r4-r11,lr}
;;;195    {
000004  b085              SUB      sp,sp,#0x14
000006  4607              MOV      r7,r0
000008  460c              MOV      r4,r1
00000a  4690              MOV      r8,r2
00000c  461d              MOV      r5,r3
;;;196        int status;
;;;197        int write_size;
;;;198        int max_write_size = 256;
00000e  f44f7080          MOV      r0,#0x100
000012  9004              STR      r0,[sp,#0x10]
;;;199        unsigned char enable_before_every_write = 1;
000014  f04f0a01          MOV      r10,#1
;;;200        unsigned char* data_addr_ptr = (unsigned char*) data_addr;
000018  46c3              MOV      r11,r8
;;;201        unsigned char curr_device_address[3];
;;;202    
;;;203        if ( handle->write_allowed == SFLASH_WRITE_ALLOWED )
00001a  7a38              LDRB     r0,[r7,#8]
00001c  2801              CMP      r0,#1
00001e  d004              BEQ      |L11.42|
;;;204        {
;;;205        }
;;;206        else
;;;207        {
;;;208            return -1;
000020  f04f30ff          MOV      r0,#0xffffffff
                  |L11.36|
;;;209        }
;;;210    
;;;211        /* Some manufacturers support programming an entire page in one command. */
;;;212    
;;;213    #ifdef SFLASH_SUPPORT_MACRONIX_PARTS
;;;214        if ( SFLASH_MANUFACTURER( handle->device_id ) == SFLASH_MANUFACTURER_MACRONIX )
;;;215        {
;;;216            max_write_size = 256;  /* TODO: this should be 256, but that causes write errors */
;;;217            enable_before_every_write = 1;
;;;218        }
;;;219    #endif /* ifdef SFLASH_SUPPORT_MACRONIX_PARTS */
;;;220    
;;;221    #ifdef SFLASH_SUPPORT_WINBOND_PARTS
;;;222        if ( SFLASH_MANUFACTURER( handle->device_id ) == SFLASH_MANUFACTURER_WINBOND )
;;;223        {
;;;224            max_write_size = 256;  /* TODO: this should be 256, but that causes write errors */
;;;225            enable_before_every_write = 1;
;;;226        }
;;;227    #endif /* ifdef SFLASH_SUPPORT_MACRONIX_PARTS */
;;;228    
;;;229    #ifdef SFLASH_SUPPORT_SST_PARTS
;;;230        if ( SFLASH_MANUFACTURER( handle->device_id ) == SFLASH_MANUFACTURER_SST )
;;;231        {
;;;232            max_write_size = 1;
;;;233            enable_before_every_write = 1;
;;;234        }
;;;235    #endif /* ifdef SFLASH_SUPPORT_SST_PARTS */
;;;236    #ifdef SFLASH_SUPPORT_EON_PARTS
;;;237        if ( SFLASH_MANUFACTURER( handle->device_id ) == SFLASH_MANUFACTURER_EON )
;;;238        {
;;;239            max_write_size = (unsigned int) 1;
;;;240            enable_before_every_write = 1;
;;;241        }
;;;242    #endif /* ifdef SFLASH_SUPPORT_EON_PARTS */
;;;243    
;;;244    
;;;245        if ( ( enable_before_every_write == 0 ) &&
;;;246             ( 0 != ( status = sflash_write_enable( handle ) ) ) )
;;;247        {
;;;248            return status;
;;;249        }
;;;250    
;;;251        /* Generic x-bytes-at-a-time write */
;;;252    
;;;253        while ( size > 0 )
;;;254        {
;;;255            write_size = ( size > max_write_size )? max_write_size : size;
;;;256            curr_device_address[0] = ( ( device_address & 0x00FF0000 ) >> 16 );
;;;257            curr_device_address[1] = ( ( device_address & 0x0000FF00 ) >>  8 );
;;;258            curr_device_address[2] = ( ( device_address & 0x000000FF ) >>  0 );
;;;259    
;;;260            if ( ( enable_before_every_write == 1 ) &&
;;;261                 ( 0 != ( status = sflash_write_enable( handle ) ) ) )
;;;262            {
;;;263                return status;
;;;264            }
;;;265    
;;;266            if ( 0 != ( status = generic_sflash_command( handle, SFLASH_WRITE, 3, curr_device_address, write_size, data_addr_ptr, NULL ) ) )
;;;267            {
;;;268                return status;
;;;269            }
;;;270    
;;;271            data_addr_ptr += write_size;
;;;272            device_address += write_size;
;;;273            size -= write_size;
;;;274    
;;;275        }
;;;276    
;;;277        return 0;
;;;278    }
000024  b005              ADD      sp,sp,#0x14
000026  e8bd8ff0          POP      {r4-r11,pc}
                  |L11.42|
00002a  f1ba0f00          CMP      r10,#0                ;245
00002e  d107              BNE      |L11.64|
000030  4638              MOV      r0,r7                 ;246
000032  f7fffffe          BL       sflash_write_enable
000036  ea5f0900          MOVS     r9,r0                 ;246
00003a  d001              BEQ      |L11.64|
00003c  4648              MOV      r0,r9                 ;248
00003e  e7f1              B        |L11.36|
                  |L11.64|
000040  e02c              B        |L11.156|
                  |L11.66|
000042  9804              LDR      r0,[sp,#0x10]         ;255
000044  4285              CMP      r5,r0                 ;255
000046  dd01              BLE      |L11.76|
000048  9804              LDR      r0,[sp,#0x10]         ;255
00004a  e000              B        |L11.78|
                  |L11.76|
00004c  4628              MOV      r0,r5                 ;255
                  |L11.78|
00004e  4606              MOV      r6,r0                 ;255
000050  0c20              LSRS     r0,r4,#16             ;256
000052  f88d000c          STRB     r0,[sp,#0xc]          ;256
000056  0a20              LSRS     r0,r4,#8              ;257
000058  f88d000d          STRB     r0,[sp,#0xd]          ;257
00005c  b2e0              UXTB     r0,r4                 ;258
00005e  f88d000e          STRB     r0,[sp,#0xe]          ;258
000062  f1ba0f01          CMP      r10,#1                ;260
000066  d107              BNE      |L11.120|
000068  4638              MOV      r0,r7                 ;261
00006a  f7fffffe          BL       sflash_write_enable
00006e  ea5f0900          MOVS     r9,r0                 ;261
000072  d001              BEQ      |L11.120|
000074  4648              MOV      r0,r9                 ;263
000076  e7d5              B        |L11.36|
                  |L11.120|
000078  2000              MOVS     r0,#0                 ;266
00007a  ab03              ADD      r3,sp,#0xc            ;266
00007c  2203              MOVS     r2,#3                 ;266
00007e  2102              MOVS     r1,#2                 ;266
000080  e9cd6b00          STRD     r6,r11,[sp,#0]        ;266
000084  9002              STR      r0,[sp,#8]            ;266
000086  4638              MOV      r0,r7                 ;266
000088  f7fffffe          BL       generic_sflash_command
00008c  ea5f0900          MOVS     r9,r0                 ;266
000090  d001              BEQ      |L11.150|
000092  4648              MOV      r0,r9                 ;268
000094  e7c6              B        |L11.36|
                  |L11.150|
000096  44b3              ADD      r11,r11,r6            ;271
000098  4434              ADD      r4,r4,r6              ;272
00009a  1bad              SUBS     r5,r5,r6              ;273
                  |L11.156|
00009c  2d00              CMP      r5,#0                 ;253
00009e  dcd0              BGT      |L11.66|
0000a0  2000              MOVS     r0,#0                 ;277
0000a2  e7bf              B        |L11.36|
;;;279    
                          ENDP


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

                  sflash_write_status_register PROC
;;;368    
;;;369    int sflash_write_status_register( const sflash_handle_t* const handle, char value )
000000  b57f              PUSH     {r0-r6,lr}
;;;370    {
000002  4605              MOV      r5,r0
000004  460c              MOV      r4,r1
;;;371        char status_register_val = value;
000006  9403              STR      r4,[sp,#0xc]
;;;372    #ifdef SFLASH_SUPPORT_SST_PARTS
;;;373        /* SST parts require enabling writing to the status register */
;;;374        if ( SFLASH_MANUFACTURER( handle->device_id ) == SFLASH_MANUFACTURER_SST )
;;;375        {
;;;376            int status;
;;;377            if ( 0 != ( status = generic_sflash_command( handle, SFLASH_ENABLE_WRITE_STATUS_REGISTER, 0, NULL, 0, NULL, NULL ) ) )
;;;378            {
;;;379                return status;
;;;380            }
;;;381        }
;;;382    #endif /* ifdef SFLASH_SUPPORT_SST_PARTS */
;;;383    
;;;384        return generic_sflash_command( handle, SFLASH_WRITE_STATUS_REGISTER, 0, NULL, 1, &status_register_val, NULL );
000008  2000              MOVS     r0,#0
00000a  a903              ADD      r1,sp,#0xc
00000c  2201              MOVS     r2,#1
00000e  4603              MOV      r3,r0
000010  e9cd2100          STRD     r2,r1,[sp,#0]
000014  9002              STR      r0,[sp,#8]
000016  4602              MOV      r2,r0
000018  2101              MOVS     r1,#1
00001a  4628              MOV      r0,r5
00001c  f7fffffe          BL       generic_sflash_command
;;;385    }
000020  b004              ADD      sp,sp,#0x10
000022  bd70              POP      {r4-r6,pc}
;;;386    
                          ENDP


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

                  __PRETTY_FUNCTION__
000000  696e7420          DCB      0x69,0x6e,0x74,0x20
000004  73666c61          DCB      0x73,0x66,0x6c,0x61
000008  73685f73          DCB      0x73,0x68,0x5f,0x73
00000c  6563746f          DCB      0x65,0x63,0x74,0x6f
000010  725f6572          DCB      0x72,0x5f,0x65,0x72
000014  61736528          DCB      0x61,0x73,0x65,0x28
000018  636f6e73          DCB      0x63,0x6f,0x6e,0x73
00001c  74207374          DCB      0x74,0x20,0x73,0x74
000020  72756374          DCB      0x72,0x75,0x63,0x74
000024  203c756e          DCB      0x20,0x3c,0x75,0x6e
000028  6e616d65          DCB      0x6e,0x61,0x6d,0x65
00002c  643e202a          DCB      0x64,0x3e,0x20,0x2a
000030  636f6e73          DCB      0x63,0x6f,0x6e,0x73
000034  742c2075          DCB      0x74,0x2c,0x20,0x75
000038  6e736967          DCB      0x6e,0x73,0x69,0x67
00003c  6e656420          DCB      0x6e,0x65,0x64,0x20
000040  6c6f6e67          DCB      0x6c,0x6f,0x6e,0x67
000044  29000000          DCB      0x29,0x00,0x00,0x00
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000001
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
                          DCD      0x00000000
