; 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\mico_platform_common.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\mico_platform_common.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\mico_platform_common.crf ..\..\..\..\Platform\MCU\mico_platform_common.c]
                          THUMB

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

                  MicoAdcFinalize PROC
;;;139    
;;;140    OSStatus  MicoAdcFinalize( mico_adc_t adc )
000000  2803              CMP      r0,#3
;;;141    {
000002  d301              BCC      |L1.8|
;;;142      if ( adc >= MICO_ADC_NONE )
;;;143        return kUnsupportedErr;
000004  4804              LDR      r0,|L1.24|
;;;144      return (OSStatus) platform_adc_deinit( &platform_adc_peripherals[adc] );
;;;145    }
000006  4770              BX       lr
                  |L1.8|
000008  4904              LDR      r1,|L1.28|
00000a  eb000080          ADD      r0,r0,r0,LSL #2       ;144
00000e  eb010080          ADD      r0,r1,r0,LSL #2       ;144
000012  f7ffbffe          B.W      platform_adc_deinit
;;;146    
                          ENDP

000016  0000              DCW      0x0000
                  |L1.24|
                          DCD      0xffffe5b1
                  |L1.28|
                          DCD      platform_adc_peripherals

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

                  MicoAdcInitialize PROC
;;;132    
;;;133    OSStatus MicoAdcInitialize( mico_adc_t adc, uint32_t sampling_cycle )
000000  2803              CMP      r0,#3
;;;134    {
000002  d301              BCC      |L2.8|
;;;135      if ( adc >= MICO_ADC_NONE )
;;;136        return kUnsupportedErr;
000004  4804              LDR      r0,|L2.24|
;;;137      return (OSStatus) platform_adc_init( &platform_adc_peripherals[adc], sampling_cycle );
;;;138    }
000006  4770              BX       lr
                  |L2.8|
000008  4a04              LDR      r2,|L2.28|
00000a  eb000080          ADD      r0,r0,r0,LSL #2       ;137
00000e  eb020080          ADD      r0,r2,r0,LSL #2       ;137
000012  f7ffbffe          B.W      platform_adc_init
;;;139    
                          ENDP

000016  0000              DCW      0x0000
                  |L2.24|
                          DCD      0xffffe5b1
                  |L2.28|
                          DCD      platform_adc_peripherals

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

                  MicoAdcTakeSample PROC
;;;146    
;;;147    OSStatus MicoAdcTakeSample( mico_adc_t adc, uint16_t* output )
000000  2803              CMP      r0,#3
;;;148    {
000002  d301              BCC      |L3.8|
;;;149      if ( adc >= MICO_ADC_NONE )
;;;150        return kUnsupportedErr;
000004  4804              LDR      r0,|L3.24|
;;;151      return (OSStatus) platform_adc_take_sample( &platform_adc_peripherals[adc], output );
;;;152    }
000006  4770              BX       lr
                  |L3.8|
000008  4a04              LDR      r2,|L3.28|
00000a  eb000080          ADD      r0,r0,r0,LSL #2       ;151
00000e  eb020080          ADD      r0,r2,r0,LSL #2       ;151
000012  f7ffbffe          B.W      platform_adc_take_sample
;;;153    
                          ENDP

000016  0000              DCW      0x0000
                  |L3.24|
                          DCD      0xffffe5b1
                  |L3.28|
                          DCD      platform_adc_peripherals

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

                  MicoAdcTakeSampleStreram PROC
;;;153    
;;;154    OSStatus MicoAdcTakeSampleStreram( mico_adc_t adc, void* buffer, uint16_t buffer_length )
000000  2803              CMP      r0,#3
;;;155    {
000002  d301              BCC      |L4.8|
;;;156      if ( adc >= MICO_ADC_NONE )
;;;157        return kUnsupportedErr;
000004  4804              LDR      r0,|L4.24|
;;;158      return (OSStatus) platform_adc_take_sample_stream( &platform_adc_peripherals[adc], buffer, buffer_length );
;;;159    }
000006  4770              BX       lr
                  |L4.8|
000008  4b04              LDR      r3,|L4.28|
00000a  eb000080          ADD      r0,r0,r0,LSL #2       ;158
00000e  eb030080          ADD      r0,r3,r0,LSL #2       ;158
000012  f7ffbffe          B.W      platform_adc_take_sample_stream
;;;160    
                          ENDP

000016  0000              DCW      0x0000
                  |L4.24|
                          DCD      0xffffe5b1
                  |L4.28|
                          DCD      platform_adc_peripherals

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

                  MicoFlashDisableSecurity PROC
;;;739    
;;;740    OSStatus MicoFlashDisableSecurity( mico_partition_t partition, uint32_t off_set, uint32_t size )
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;741    {
000004  0003              MOVS     r3,r0
;;;742      OSStatus err = kNoErr;
;;;743      uint32_t start_addr = mico_partitions[ partition ].partition_start_addr + off_set;
000006  4f1c              LDR      r7,|L5.120|
000008  eb030483          ADD      r4,r3,r3,LSL #2
00000c  eb070e84          ADD      lr,r7,r4,LSL #2
000010  f1a20201          SUB      r2,r2,#1
000014  f8dec008          LDR      r12,[lr,#8]
;;;744      uint32_t end_addr = mico_partitions[ partition ].partition_start_addr + off_set + size - 1;
;;;745    
;;;746      require_action_quiet( partition > MICO_PARTITION_ERROR, exit, err = kParamErr );
000018  4818              LDR      r0,|L5.124|
00001a  eb0c0501          ADD      r5,r12,r1             ;743
00001e  eb050602          ADD      r6,r5,r2              ;744
000022  d416              BMI      |L5.82|
;;;747      require_action_quiet( partition < MICO_PARTITION_MAX, exit, err = kParamErr );
000024  2b07              CMP      r3,#7
000026  da14              BGE      |L5.82|
;;;748      require_action_quiet( mico_partitions[ partition ].partition_owner != MICO_FLASH_NONE, exit, err = kNotFoundErr );
000028  f8171024          LDRB     r1,[r7,r4,LSL #2]
00002c  2903              CMP      r1,#3
00002e  d00e              BEQ      |L5.78|
;;;749      require_action_quiet( start_addr >= mico_partitions[ partition ].partition_start_addr, exit, err = kParamErr );
000030  45ac              CMP      r12,r5
000032  d80e              BHI      |L5.82|
;;;750      require_action_quiet( end_addr < mico_partitions[ partition ].partition_start_addr + mico_partitions[ partition ].partition_length, exit, err = kParamErr );
000034  f8de200c          LDR      r2,[lr,#0xc]
000038  4462              ADD      r2,r2,r12
00003a  42b2              CMP      r2,r6
00003c  d909              BLS      |L5.82|
;;;751    
;;;752      if( platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].initialized == false )
00003e  4810              LDR      r0,|L5.128|
000040  eb010141          ADD      r1,r1,r1,LSL #1
000044  eb000081          ADD      r0,r0,r1,LSL #2
000048  7a00              LDRB     r0,[r0,#8]
00004a  b120              CBZ      r0,|L5.86|
00004c  e008              B        |L5.96|
                  |L5.78|
00004e  480b              LDR      r0,|L5.124|
000050  3816              SUBS     r0,r0,#0x16           ;748
                  |L5.82|
;;;753      {
;;;754        err =  MicoFlashInitialize( partition );
;;;755        require_noerr_quiet( err, exit );
;;;756      }
;;;757    
;;;758      mico_rtos_lock_mutex( &platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].flash_mutex );
;;;759      err = platform_flash_disable_protect( &platform_flash_peripherals[ mico_partitions[ partition ].partition_owner ], start_addr, end_addr);
;;;760      mico_rtos_unlock_mutex( &platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].flash_mutex );
;;;761      
;;;762    exit:
;;;763      return err;
;;;764    }
000052  e8bd81f0          POP      {r4-r8,pc}
                  |L5.86|
000056  4618              MOV      r0,r3                 ;754
000058  f7fffffe          BL       MicoFlashInitialize
00005c  2800              CMP      r0,#0                 ;755
00005e  d1f8              BNE      |L5.82|
                  |L5.96|
000060  f8170024          LDRB     r0,[r7,r4,LSL #2]     ;758
000064  4907              LDR      r1,|L5.132|
000066  4632              MOV      r2,r6                 ;759
000068  eb011000          ADD      r0,r1,r0,LSL #4       ;759
00006c  4629              MOV      r1,r5                 ;759
00006e  e8bd41f0          POP      {r4-r8,lr}            ;759
000072  f7ffbffe          B.W      platform_flash_disable_protect
;;;765    
                          ENDP

000076  0000              DCW      0x0000
                  |L5.120|
                          DCD      mico_partitions
                  |L5.124|
                          DCD      0xffffe5cf
                  |L5.128|
                          DCD      platform_flash_drivers
                  |L5.132|
                          DCD      platform_flash_peripherals

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

                  MicoFlashEnableSecurity PROC
;;;672    
;;;673    OSStatus MicoFlashEnableSecurity( mico_partition_t partition, uint32_t off_set, uint32_t size )
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;674    {
000004  4694              MOV      r12,r2
000006  4602              MOV      r2,r0
;;;675      OSStatus err = kNoErr;
;;;676      uint32_t start_addr = mico_partitions[ partition ].partition_start_addr + off_set;
000008  4f1c              LDR      r7,|L6.124|
00000a  eb020482          ADD      r4,r2,r2,LSL #2
00000e  eb070e84          ADD      lr,r7,r4,LSL #2
000012  2000              MOVS     r0,#0                 ;675
000014  f8de3008          LDR      r3,[lr,#8]
000018  185d              ADDS     r5,r3,r1
;;;677      uint32_t end_addr = mico_partitions[ partition ].partition_start_addr + off_set + size - 1;
00001a  f1bc0101          SUBS     r1,r12,#1
00001e  eb050601          ADD      r6,r5,r1
000022  d319              BCC      |L6.88|
;;;678    
;;;679      if (size == 0)
;;;680        goto exit;
;;;681      require_action_quiet( partition > MICO_PARTITION_ERROR, exit, err = kParamErr );
000024  4816              LDR      r0,|L6.128|
000026  2a00              CMP      r2,#0
000028  db16              BLT      |L6.88|
;;;682      require_action_quiet( partition < MICO_PARTITION_MAX, exit, err = kParamErr );
00002a  2a07              CMP      r2,#7
00002c  da14              BGE      |L6.88|
;;;683    
;;;684      require_action_quiet( mico_partitions[ partition ].partition_owner != MICO_FLASH_NONE, exit, err = kNotFoundErr );
00002e  f8171024          LDRB     r1,[r7,r4,LSL #2]
000032  2903              CMP      r1,#3
000034  d00e              BEQ      |L6.84|
;;;685      require_action_quiet( start_addr >= mico_partitions[ partition ].partition_start_addr, exit, err = kParamErr );
000036  42ab              CMP      r3,r5
000038  d80e              BHI      |L6.88|
;;;686      require_action_quiet( end_addr < mico_partitions[ partition ].partition_start_addr + mico_partitions[ partition ].partition_length, exit, err = kParamErr );
00003a  f8dec00c          LDR      r12,[lr,#0xc]
00003e  4463              ADD      r3,r3,r12
000040  42b3              CMP      r3,r6
000042  d909              BLS      |L6.88|
;;;687    
;;;688      if( platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].initialized == false )
000044  480f              LDR      r0,|L6.132|
000046  eb010141          ADD      r1,r1,r1,LSL #1
00004a  eb000081          ADD      r0,r0,r1,LSL #2
00004e  7a00              LDRB     r0,[r0,#8]
000050  b120              CBZ      r0,|L6.92|
000052  e008              B        |L6.102|
                  |L6.84|
000054  480a              LDR      r0,|L6.128|
000056  3816              SUBS     r0,r0,#0x16           ;684
                  |L6.88|
;;;689      {
;;;690        err =  MicoFlashInitialize( partition );
;;;691        require_noerr_quiet( err, exit );
;;;692      }
;;;693    
;;;694      mico_rtos_lock_mutex( &platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].flash_mutex );
;;;695      err = platform_flash_enable_protect( &platform_flash_peripherals[ mico_partitions[ partition ].partition_owner ], start_addr, end_addr);
;;;696      mico_rtos_unlock_mutex( &platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].flash_mutex );
;;;697      
;;;698    exit:
;;;699      return err;
;;;700    }
000058  e8bd81f0          POP      {r4-r8,pc}
                  |L6.92|
00005c  4610              MOV      r0,r2                 ;690
00005e  f7fffffe          BL       MicoFlashInitialize
000062  2800              CMP      r0,#0                 ;691
000064  d1f8              BNE      |L6.88|
                  |L6.102|
000066  f8170024          LDRB     r0,[r7,r4,LSL #2]     ;694
00006a  4907              LDR      r1,|L6.136|
00006c  4632              MOV      r2,r6                 ;695
00006e  eb011000          ADD      r0,r1,r0,LSL #4       ;695
000072  4629              MOV      r1,r5                 ;695
000074  e8bd41f0          POP      {r4-r8,lr}            ;695
000078  f7ffbffe          B.W      platform_flash_enable_protect
;;;701    
                          ENDP

                  |L6.124|
                          DCD      mico_partitions
                  |L6.128|
                          DCD      0xffffe5cf
                  |L6.132|
                          DCD      platform_flash_drivers
                  |L6.136|
                          DCD      platform_flash_peripherals

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

                  MicoFlashErase PROC
;;;571    
;;;572    OSStatus MicoFlashErase(mico_partition_t partition, uint32_t off_set, uint32_t size)
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;573    {
000004  4694              MOV      r12,r2
000006  4602              MOV      r2,r0
;;;574      OSStatus err = kNoErr;
;;;575      uint32_t start_addr = mico_partitions[ partition ].partition_start_addr + off_set;
000008  4f1c              LDR      r7,|L7.124|
00000a  eb020482          ADD      r4,r2,r2,LSL #2
00000e  eb070e84          ADD      lr,r7,r4,LSL #2
000012  2000              MOVS     r0,#0                 ;574
000014  f8de3008          LDR      r3,[lr,#8]
000018  185d              ADDS     r5,r3,r1
;;;576      uint32_t end_addr = mico_partitions[ partition ].partition_start_addr + off_set + size - 1;
00001a  f1bc0101          SUBS     r1,r12,#1
00001e  eb050601          ADD      r6,r5,r1
000022  d319              BCC      |L7.88|
;;;577    
;;;578      if (size == 0)
;;;579        goto exit;
;;;580      require_action_quiet( partition > MICO_PARTITION_ERROR, exit, err = kParamErr );
000024  4816              LDR      r0,|L7.128|
000026  2a00              CMP      r2,#0
000028  db16              BLT      |L7.88|
;;;581      require_action_quiet( partition < MICO_PARTITION_MAX, exit, err = kParamErr );  
00002a  2a07              CMP      r2,#7
00002c  da14              BGE      |L7.88|
;;;582    
;;;583      require_action_quiet( mico_partitions[ partition ].partition_owner != MICO_FLASH_NONE, exit, err = kNotFoundErr );
00002e  f8171024          LDRB     r1,[r7,r4,LSL #2]
000032  2903              CMP      r1,#3
000034  d00e              BEQ      |L7.84|
;;;584    #ifndef BOOTLOADER
;;;585      require_action_quiet( ( mico_partitions[ partition ].partition_options & PAR_OPT_WRITE_MASK ) == PAR_OPT_WRITE_EN, exit, err = kPermissionErr );
;;;586    #endif
;;;587    
;;;588      require_action_quiet( start_addr >= mico_partitions[ partition ].partition_start_addr, exit, err = kParamErr );
000036  42ab              CMP      r3,r5
000038  d80e              BHI      |L7.88|
;;;589      require_action_quiet( end_addr < mico_partitions[ partition ].partition_start_addr + mico_partitions[ partition ].partition_length, exit, err = kParamErr );
00003a  f8dec00c          LDR      r12,[lr,#0xc]
00003e  4463              ADD      r3,r3,r12
000040  42b3              CMP      r3,r6
000042  d909              BLS      |L7.88|
;;;590    
;;;591      if( platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].initialized == false )
000044  480f              LDR      r0,|L7.132|
000046  eb010141          ADD      r1,r1,r1,LSL #1
00004a  eb000081          ADD      r0,r0,r1,LSL #2
00004e  7a00              LDRB     r0,[r0,#8]
000050  b120              CBZ      r0,|L7.92|
000052  e008              B        |L7.102|
                  |L7.84|
000054  480a              LDR      r0,|L7.128|
000056  3816              SUBS     r0,r0,#0x16           ;583
                  |L7.88|
;;;592      {
;;;593        err =  MicoFlashInitialize( partition );
;;;594        require_noerr_quiet( err, exit );
;;;595      }
;;;596    
;;;597      mico_rtos_lock_mutex( &platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].flash_mutex );
;;;598      err = platform_flash_erase( &platform_flash_peripherals[ mico_partitions[ partition ].partition_owner ], start_addr, end_addr );
;;;599      mico_rtos_unlock_mutex( &platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].flash_mutex );
;;;600    
;;;601    exit:
;;;602      return err;
;;;603    }
000058  e8bd81f0          POP      {r4-r8,pc}
                  |L7.92|
00005c  4610              MOV      r0,r2                 ;593
00005e  f7fffffe          BL       MicoFlashInitialize
000062  2800              CMP      r0,#0                 ;594
000064  d1f8              BNE      |L7.88|
                  |L7.102|
000066  f8170024          LDRB     r0,[r7,r4,LSL #2]     ;597
00006a  4907              LDR      r1,|L7.136|
00006c  4632              MOV      r2,r6                 ;598
00006e  eb011000          ADD      r0,r1,r0,LSL #4       ;598
000072  4629              MOV      r1,r5                 ;598
000074  e8bd41f0          POP      {r4-r8,lr}            ;598
000078  f7ffbffe          B.W      platform_flash_erase
;;;604    
                          ENDP

                  |L7.124|
                          DCD      mico_partitions
                  |L7.128|
                          DCD      0xffffe5cf
                  |L7.132|
                          DCD      platform_flash_drivers
                  |L7.136|
                          DCD      platform_flash_peripherals

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

                  MicoFlashGetInfo PROC
;;;538    
;;;539    mico_logic_partition_t* MicoFlashGetInfo( mico_partition_t inPartition )
000000  2807              CMP      r0,#7
;;;540    {
000002  d301              BCC      |L8.8|
;;;541      if( (inPartition < 0) || (inPartition >= MICO_PARTITION_MAX))
;;;542        return NULL;
000004  2000              MOVS     r0,#0
;;;543      else
;;;544        return (mico_logic_partition_t *)&mico_partitions[ inPartition ];
;;;545    }
000006  4770              BX       lr
                  |L8.8|
000008  4902              LDR      r1,|L8.20|
00000a  eb000080          ADD      r0,r0,r0,LSL #2       ;544
00000e  eb010080          ADD      r0,r1,r0,LSL #2       ;544
000012  4770              BX       lr
;;;546    
                          ENDP

                  |L8.20|
                          DCD      mico_partitions

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

                  MicoFlashInitialize PROC
;;;547    
;;;548    static OSStatus MicoFlashInitialize( mico_partition_t partition )
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;549    {
000004  0001              MOVS     r1,r0
;;;550      OSStatus err = kNoErr;
;;;551      
;;;552      require_action_quiet( partition > MICO_PARTITION_ERROR, exit, err = kParamErr );
000006  4811              LDR      r0,|L9.76|
000008  d41a              BMI      |L9.64|
;;;553      require_action_quiet( partition < MICO_PARTITION_MAX, exit, err = kParamErr );
00000a  2907              CMP      r1,#7
00000c  da18              BGE      |L9.64|
;;;554      require_action_quiet( mico_partitions[ partition ].partition_owner != MICO_FLASH_NONE, exit, err = kNotFoundErr );
00000e  4f10              LDR      r7,|L9.80|
000010  eb010481          ADD      r4,r1,r1,LSL #2
000014  f8170024          LDRB     r0,[r7,r4,LSL #2]
000018  2803              CMP      r0,#3
00001a  d013              BEQ      |L9.68|
;;;555      
;;;556      if( platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].flash_mutex == NULL){
;;;557        err = mico_rtos_init_mutex( &platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].flash_mutex );
;;;558        require_noerr( err, exit );
;;;559      }
;;;560      
;;;561      mico_rtos_lock_mutex( &platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].flash_mutex );
;;;562      
;;;563      err = platform_flash_init( &platform_flash_peripherals[ mico_partitions[ partition ].partition_owner ] );
00001c  4e0e              LDR      r6,|L9.88|
00001e  4d0d              LDR      r5,|L9.84|
000020  eb061000          ADD      r0,r6,r0,LSL #4
000024  f7fffffe          BL       platform_flash_init
;;;564      platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].peripheral = (platform_flash_t *)&platform_flash_peripherals[ mico_partitions[ partition ].partition_owner ];
000028  f8171024          LDRB     r1,[r7,r4,LSL #2]
00002c  eb061201          ADD      r2,r6,r1,LSL #4
000030  eb010141          ADD      r1,r1,r1,LSL #1
000034  f8452021          STR      r2,[r5,r1,LSL #2]
;;;565      platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].initialized = true;
000038  eb050181          ADD      r1,r5,r1,LSL #2
00003c  2201              MOVS     r2,#1
00003e  720a              STRB     r2,[r1,#8]
                  |L9.64|
;;;566      mico_rtos_unlock_mutex( &platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].flash_mutex );
;;;567      
;;;568    exit: 
;;;569      return err;
;;;570    }
000040  e8bd81f0          POP      {r4-r8,pc}
                  |L9.68|
000044  4801              LDR      r0,|L9.76|
000046  3816              SUBS     r0,r0,#0x16           ;554
000048  e7fa              B        |L9.64|
;;;571    
                          ENDP

00004a  0000              DCW      0x0000
                  |L9.76|
                          DCD      0xffffe5cf
                  |L9.80|
                          DCD      mico_partitions
                  |L9.84|
                          DCD      platform_flash_drivers
                  |L9.88|
                          DCD      platform_flash_peripherals

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

                  MicoFlashRead PROC
;;;638    
;;;639    OSStatus MicoFlashRead( mico_partition_t partition, volatile uint32_t* off_set, uint8_t* outBuffer ,uint32_t inBufferLength)
000000  e92d4ff8          PUSH     {r3-r11,lr}
;;;640    {
;;;641      OSStatus err = kNoErr;
;;;642      uint32_t start_addr = mico_partitions[ partition ].partition_start_addr + *off_set;
000004  f8df908c          LDR      r9,|L10.148|
000008  eb000680          ADD      r6,r0,r0,LSL #2
00000c  460c              MOV      r4,r1                 ;640
00000e  eb090586          ADD      r5,r9,r6,LSL #2
000012  461f              MOV      r7,r3                 ;640
000014  4692              MOV      r10,r2                ;640
000016  68a9              LDR      r1,[r5,#8]
000018  6823              LDR      r3,[r4,#0]
00001a  2200              MOVS     r2,#0                 ;641
00001c  eb010803          ADD      r8,r1,r3
;;;643      uint32_t  end_addr = mico_partitions[ partition ].partition_start_addr + *off_set + inBufferLength - 1;
000020  f8cd8000          STR      r8,[sp,#0]
000024  6823              LDR      r3,[r4,#0]
000026  f1b70c01          SUBS     r12,r7,#1
00002a  440b              ADD      r3,r3,r1
00002c  449c              ADD      r12,r12,r3
00002e  d32d              BCC      |L10.140|
;;;644    
;;;645      if (inBufferLength == 0)
;;;646        goto exit;
;;;647      require_action_quiet( partition > MICO_PARTITION_ERROR, exit, err = kParamErr );
000030  4a19              LDR      r2,|L10.152|
000032  2800              CMP      r0,#0
000034  db2a              BLT      |L10.140|
;;;648      require_action_quiet( partition < MICO_PARTITION_MAX, exit, err = kParamErr );
000036  2807              CMP      r0,#7
000038  da28              BGE      |L10.140|
;;;649      
;;;650      require_action_quiet( mico_partitions[ partition ].partition_owner != MICO_FLASH_NONE, exit, err = kNotFoundErr );
00003a  f8193026          LDRB     r3,[r9,r6,LSL #2]
00003e  2b03              CMP      r3,#3
000040  d00e              BEQ      |L10.96|
;;;651    #ifndef BOOTLOADER
;;;652      require_action_quiet( ( mico_partitions[ partition ].partition_options & PAR_OPT_READ_MASK ) == PAR_OPT_READ_EN, exit, err = kPermissionErr );
;;;653    #endif
;;;654    
;;;655      require_action_quiet( start_addr >= mico_partitions[ partition ].partition_start_addr, exit, err = kParamErr );
000042  4541              CMP      r1,r8
000044  d822              BHI      |L10.140|
;;;656      require_action_quiet( end_addr < mico_partitions[ partition ].partition_start_addr + mico_partitions[ partition ].partition_length , exit, err = kParamErr );
000046  f8d5800c          LDR      r8,[r5,#0xc]
00004a  4441              ADD      r1,r1,r8
00004c  4561              CMP      r1,r12
00004e  d91d              BLS      |L10.140|
;;;657    
;;;658      if( platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].initialized == false )
000050  4912              LDR      r1,|L10.156|
000052  eb030243          ADD      r2,r3,r3,LSL #1
000056  eb010182          ADD      r1,r1,r2,LSL #2
00005a  7a09              LDRB     r1,[r1,#8]
00005c  b119              CBZ      r1,|L10.102|
00005e  e006              B        |L10.110|
                  |L10.96|
000060  4a0d              LDR      r2,|L10.152|
000062  3a16              SUBS     r2,r2,#0x16           ;650
000064  e012              B        |L10.140|
                  |L10.102|
;;;659      {
;;;660        err =  MicoFlashInitialize( partition );
000066  f7fffffe          BL       MicoFlashInitialize
00006a  0002              MOVS     r2,r0
;;;661        require_noerr_quiet( err, exit );
00006c  d10e              BNE      |L10.140|
                  |L10.110|
;;;662      }
;;;663    
;;;664      mico_rtos_lock_mutex( &platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].flash_mutex );
00006e  f8190026          LDRB     r0,[r9,r6,LSL #2]
;;;665      err = platform_flash_read( &platform_flash_peripherals[ mico_partitions[ partition ].partition_owner ], &start_addr, outBuffer, inBufferLength );
000072  490b              LDR      r1,|L10.160|
000074  463b              MOV      r3,r7
000076  eb011000          ADD      r0,r1,r0,LSL #4
00007a  4652              MOV      r2,r10
00007c  4669              MOV      r1,sp
00007e  f7fffffe          BL       platform_flash_read
000082  4602              MOV      r2,r0
;;;666      *off_set = start_addr - mico_partitions[ partition ].partition_start_addr;
000084  68a8              LDR      r0,[r5,#8]
000086  9900              LDR      r1,[sp,#0]
000088  1a08              SUBS     r0,r1,r0
00008a  6020              STR      r0,[r4,#0]
                  |L10.140|
;;;667      mico_rtos_unlock_mutex( &platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].flash_mutex );
;;;668    
;;;669    exit:
;;;670      return err;
00008c  4610              MOV      r0,r2
;;;671    }
00008e  e8bd8ff8          POP      {r3-r11,pc}
;;;672    
                          ENDP

000092  0000              DCW      0x0000
                  |L10.148|
                          DCD      mico_partitions
                  |L10.152|
                          DCD      0xffffe5cf
                  |L10.156|
                          DCD      platform_flash_drivers
                  |L10.160|
                          DCD      platform_flash_peripherals

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

                  MicoFlashWrite PROC
;;;604    
;;;605    OSStatus MicoFlashWrite( mico_partition_t partition, volatile uint32_t* off_set, uint8_t* inBuffer ,uint32_t inBufferLength)
000000  e92d4ff8          PUSH     {r3-r11,lr}
;;;606    {
;;;607      OSStatus err = kNoErr;
;;;608      uint32_t start_addr = mico_partitions[ partition ].partition_start_addr + *off_set;
000004  f8df908c          LDR      r9,|L11.148|
000008  eb000680          ADD      r6,r0,r0,LSL #2
00000c  460c              MOV      r4,r1                 ;606
00000e  eb090586          ADD      r5,r9,r6,LSL #2
000012  461f              MOV      r7,r3                 ;606
000014  4692              MOV      r10,r2                ;606
000016  68a9              LDR      r1,[r5,#8]
000018  6823              LDR      r3,[r4,#0]
00001a  2200              MOVS     r2,#0                 ;607
00001c  eb010803          ADD      r8,r1,r3
;;;609      uint32_t end_addr = mico_partitions[ partition ].partition_start_addr + *off_set + inBufferLength - 1;
000020  f8cd8000          STR      r8,[sp,#0]
000024  6823              LDR      r3,[r4,#0]
000026  f1b70c01          SUBS     r12,r7,#1
00002a  440b              ADD      r3,r3,r1
00002c  449c              ADD      r12,r12,r3
00002e  d32d              BCC      |L11.140|
;;;610    
;;;611      if (inBufferLength == 0)
;;;612        goto exit;
;;;613      require_action_quiet( partition > MICO_PARTITION_ERROR, exit, err = kParamErr );
000030  4a19              LDR      r2,|L11.152|
000032  2800              CMP      r0,#0
000034  db2a              BLT      |L11.140|
;;;614      require_action_quiet( partition < MICO_PARTITION_MAX, exit, err = kParamErr );
000036  2807              CMP      r0,#7
000038  da28              BGE      |L11.140|
;;;615      
;;;616      require_action_quiet( mico_partitions[ partition ].partition_owner != MICO_FLASH_NONE, exit, err = kNotFoundErr );
00003a  f8193026          LDRB     r3,[r9,r6,LSL #2]
00003e  2b03              CMP      r3,#3
000040  d00e              BEQ      |L11.96|
;;;617    #ifndef BOOTLOADER
;;;618      require_action_quiet( ( mico_partitions[ partition ].partition_options & PAR_OPT_WRITE_MASK ) == PAR_OPT_WRITE_EN, exit, err = kPermissionErr );
;;;619    #endif
;;;620    
;;;621      require_action_quiet( start_addr >= mico_partitions[ partition ].partition_start_addr, exit, err = kParamErr );
000042  4541              CMP      r1,r8
000044  d822              BHI      |L11.140|
;;;622      require_action_quiet( end_addr < mico_partitions[ partition ].partition_start_addr + mico_partitions[ partition ].partition_length , exit, err = kParamErr );
000046  f8d5800c          LDR      r8,[r5,#0xc]
00004a  4441              ADD      r1,r1,r8
00004c  4561              CMP      r1,r12
00004e  d91d              BLS      |L11.140|
;;;623      
;;;624      if( platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].initialized == false )
000050  4912              LDR      r1,|L11.156|
000052  eb030243          ADD      r2,r3,r3,LSL #1
000056  eb010182          ADD      r1,r1,r2,LSL #2
00005a  7a09              LDRB     r1,[r1,#8]
00005c  b119              CBZ      r1,|L11.102|
00005e  e006              B        |L11.110|
                  |L11.96|
000060  4a0d              LDR      r2,|L11.152|
000062  3a16              SUBS     r2,r2,#0x16           ;616
000064  e012              B        |L11.140|
                  |L11.102|
;;;625      {
;;;626        err =  MicoFlashInitialize( partition );
000066  f7fffffe          BL       MicoFlashInitialize
00006a  0002              MOVS     r2,r0
;;;627        require_noerr_quiet( err, exit );
00006c  d10e              BNE      |L11.140|
                  |L11.110|
;;;628      }
;;;629    
;;;630      mico_rtos_lock_mutex( &platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].flash_mutex );
00006e  f8190026          LDRB     r0,[r9,r6,LSL #2]
;;;631      err = platform_flash_write( &platform_flash_peripherals[ mico_partitions[ partition ].partition_owner ], &start_addr, inBuffer, inBufferLength );
000072  490b              LDR      r1,|L11.160|
000074  463b              MOV      r3,r7
000076  eb011000          ADD      r0,r1,r0,LSL #4
00007a  4652              MOV      r2,r10
00007c  4669              MOV      r1,sp
00007e  f7fffffe          BL       platform_flash_write
000082  4602              MOV      r2,r0
;;;632      *off_set = start_addr - mico_partitions[ partition ].partition_start_addr;
000084  68a8              LDR      r0,[r5,#8]
000086  9900              LDR      r1,[sp,#0]
000088  1a08              SUBS     r0,r1,r0
00008a  6020              STR      r0,[r4,#0]
                  |L11.140|
;;;633      mico_rtos_unlock_mutex( &platform_flash_drivers[ mico_partitions[ partition ].partition_owner ].flash_mutex );
;;;634      
;;;635    exit:
;;;636      return err;
00008c  4610              MOV      r0,r2
;;;637    }
00008e  e8bd8ff8          POP      {r3-r11,pc}
;;;638    
                          ENDP

000092  0000              DCW      0x0000
                  |L11.148|
                          DCD      mico_partitions
                  |L11.152|
                          DCD      0xffffe5cf
                  |L11.156|
                          DCD      platform_flash_drivers
                  |L11.160|
                          DCD      platform_flash_peripherals

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

                  MicoGpioDisableIRQ PROC
;;;209    
;;;210    OSStatus MicoGpioDisableIRQ( mico_gpio_t gpio )
000000  280d              CMP      r0,#0xd
;;;211    {
000002  d301              BCC      |L12.8|
;;;212      if ( gpio >= MICO_GPIO_NONE )
;;;213        return kUnsupportedErr;
000004  4803              LDR      r0,|L12.20|
;;;214      return (OSStatus) platform_gpio_irq_disable( &platform_gpio_pins[gpio] );
;;;215    }
000006  4770              BX       lr
                  |L12.8|
000008  4903              LDR      r1,|L12.24|
00000a  eb0100c0          ADD      r0,r1,r0,LSL #3       ;214
00000e  f7ffbffe          B.W      platform_gpio_irq_disable
;;;216    
                          ENDP

000012  0000              DCW      0x0000
                  |L12.20|
                          DCD      0xffffe5b1
                  |L12.24|
                          DCD      platform_gpio_pins

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

                  MicoGpioEnableIRQ PROC
;;;202    
;;;203    OSStatus MicoGpioEnableIRQ( mico_gpio_t gpio, mico_gpio_irq_trigger_t trigger, mico_gpio_irq_handler_t handler, void* arg )
000000  b430              PUSH     {r4,r5}
;;;204    {
;;;205      if ( gpio >= MICO_GPIO_NONE )
000002  280d              CMP      r0,#0xd
000004  d302              BCC      |L13.12|
;;;206        return kUnsupportedErr;
;;;207      return (OSStatus) platform_gpio_irq_enable( &platform_gpio_pins[gpio], trigger, handler, arg );
;;;208    }
000006  bc30              POP      {r4,r5}
000008  4803              LDR      r0,|L13.24|
00000a  4770              BX       lr
                  |L13.12|
00000c  4c03              LDR      r4,|L13.28|
00000e  eb0400c0          ADD      r0,r4,r0,LSL #3       ;207
000012  bc30              POP      {r4,r5}               ;207
000014  f7ffbffe          B.W      platform_gpio_irq_enable
;;;209    
                          ENDP

                  |L13.24|
                          DCD      0xffffe5b1
                  |L13.28|
                          DCD      platform_gpio_pins

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

                  MicoGpioFinalize PROC
;;;188    
;;;189    OSStatus MicoGpioFinalize( mico_gpio_t gpio )
000000  280d              CMP      r0,#0xd
;;;190    {
000002  d301              BCC      |L14.8|
;;;191      if ( gpio >= MICO_GPIO_NONE )
;;;192        return kUnsupportedErr;
000004  4803              LDR      r0,|L14.20|
;;;193      return (OSStatus) platform_gpio_deinit( &platform_gpio_pins[gpio] );
;;;194    }
000006  4770              BX       lr
                  |L14.8|
000008  4903              LDR      r1,|L14.24|
00000a  eb0100c0          ADD      r0,r1,r0,LSL #3       ;193
00000e  f7ffbffe          B.W      platform_gpio_deinit
;;;195    
                          ENDP

000012  0000              DCW      0x0000
                  |L14.20|
                          DCD      0xffffe5b1
                  |L14.24|
                          DCD      platform_gpio_pins

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

                  MicoGpioInitialize PROC
;;;160    
;;;161    OSStatus MicoGpioInitialize( mico_gpio_t gpio, mico_gpio_config_t configuration )
000000  280d              CMP      r0,#0xd
;;;162    {
000002  d301              BCC      |L15.8|
;;;163      if ( gpio >= MICO_GPIO_NONE )
;;;164        return kUnsupportedErr;
000004  4803              LDR      r0,|L15.20|
;;;165      return (OSStatus) platform_gpio_init( &platform_gpio_pins[gpio], configuration );
;;;166    }
000006  4770              BX       lr
                  |L15.8|
000008  4a03              LDR      r2,|L15.24|
00000a  eb0200c0          ADD      r0,r2,r0,LSL #3       ;165
00000e  f7ffbffe          B.W      platform_gpio_init
;;;167    
                          ENDP

000012  0000              DCW      0x0000
                  |L15.20|
                          DCD      0xffffe5b1
                  |L15.24|
                          DCD      platform_gpio_pins

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

                  MicoGpioOutputHigh PROC
;;;167    
;;;168    OSStatus MicoGpioOutputHigh( mico_gpio_t gpio )
000000  280d              CMP      r0,#0xd
;;;169    {
000002  d301              BCC      |L16.8|
;;;170      if ( gpio >= MICO_GPIO_NONE )
;;;171        return kUnsupportedErr;
000004  4803              LDR      r0,|L16.20|
;;;172      return (OSStatus) platform_gpio_output_high( &platform_gpio_pins[gpio] );
;;;173    }
000006  4770              BX       lr
                  |L16.8|
000008  4903              LDR      r1,|L16.24|
00000a  eb0100c0          ADD      r0,r1,r0,LSL #3       ;172
00000e  f7ffbffe          B.W      platform_gpio_output_high
;;;174    
                          ENDP

000012  0000              DCW      0x0000
                  |L16.20|
                          DCD      0xffffe5b1
                  |L16.24|
                          DCD      platform_gpio_pins

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

                  MicoGpioOutputLow PROC
;;;174    
;;;175    OSStatus MicoGpioOutputLow( mico_gpio_t gpio )
000000  280d              CMP      r0,#0xd
;;;176    {
000002  d301              BCC      |L17.8|
;;;177      if ( gpio >= MICO_GPIO_NONE )
;;;178        return kUnsupportedErr;
000004  4803              LDR      r0,|L17.20|
;;;179      return (OSStatus) platform_gpio_output_low( &platform_gpio_pins[gpio] );
;;;180    }
000006  4770              BX       lr
                  |L17.8|
000008  4903              LDR      r1,|L17.24|
00000a  eb0100c0          ADD      r0,r1,r0,LSL #3       ;179
00000e  f7ffbffe          B.W      platform_gpio_output_low
;;;181    
                          ENDP

000012  0000              DCW      0x0000
                  |L17.20|
                          DCD      0xffffe5b1
                  |L17.24|
                          DCD      platform_gpio_pins

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

                  MicoGpioOutputTrigger PROC
;;;181    
;;;182    OSStatus MicoGpioOutputTrigger( mico_gpio_t gpio )
000000  280d              CMP      r0,#0xd
;;;183    {
000002  d301              BCC      |L18.8|
;;;184      if ( gpio >= MICO_GPIO_NONE )
;;;185        return kUnsupportedErr;
000004  4803              LDR      r0,|L18.20|
;;;186      return (OSStatus) platform_gpio_output_trigger( &platform_gpio_pins[gpio] );
;;;187    }
000006  4770              BX       lr
                  |L18.8|
000008  4903              LDR      r1,|L18.24|
00000a  eb0100c0          ADD      r0,r1,r0,LSL #3       ;186
00000e  f7ffbffe          B.W      platform_gpio_output_trigger
;;;188    
                          ENDP

000012  0000              DCW      0x0000
                  |L18.20|
                          DCD      0xffffe5b1
                  |L18.24|
                          DCD      platform_gpio_pins

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

                  MicoI2cBuildCombinedMessage PROC
;;;289    
;;;290    OSStatus MicoI2cBuildCombinedMessage( mico_i2c_message_t* message, const void* tx_buffer, void* rx_buffer, uint16_t tx_buffer_length, uint16_t rx_buffer_length, uint16_t retries )
000000  b57c              PUSH     {r2-r6,lr}
;;;291    {
000002  e9dd4506          LDRD     r4,r5,[sp,#0x18]
000006  e9cd4500          STRD     r4,r5,[sp,#0]
;;;292      return (OSStatus) platform_i2c_init_combined_message( message, tx_buffer, rx_buffer, tx_buffer_length, rx_buffer_length, retries );
00000a  f7fffffe          BL       platform_i2c_init_combined_message
;;;293    }
00000e  bd7c              POP      {r2-r6,pc}
;;;294    
                          ENDP


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

                  MicoI2cBuildRxMessage PROC
;;;284    
;;;285    OSStatus MicoI2cBuildRxMessage( mico_i2c_message_t* message, void* rx_buffer, uint16_t rx_buffer_length, uint16_t retries )
000000  f7ffbffe          B.W      platform_i2c_init_rx_message
;;;286    {
;;;287      return (OSStatus) platform_i2c_init_rx_message( message, rx_buffer, rx_buffer_length, retries );
;;;288    }
;;;289    
                          ENDP


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

                  MicoI2cBuildTxMessage PROC
;;;279    
;;;280    OSStatus MicoI2cBuildTxMessage( mico_i2c_message_t* message, const void* tx_buffer, uint16_t  tx_buffer_length, uint16_t retries )
000000  f7ffbffe          B.W      platform_i2c_init_tx_message
;;;281    {
;;;282      return (OSStatus) platform_i2c_init_tx_message( message, tx_buffer, tx_buffer_length, retries );
;;;283    }
;;;284    
                          ENDP


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

                  MicoI2cFinalize PROC
;;;239    
;;;240    OSStatus MicoI2cFinalize( mico_i2c_device_t* device )
000000  b51c              PUSH     {r2-r4,lr}
;;;241    {
;;;242      platform_i2c_config_t config;
;;;243    
;;;244      if ( device->port >= MICO_I2C_NONE )
000002  7801              LDRB     r1,[r0,#0]
000004  2902              CMP      r1,#2
000006  d301              BCC      |L22.12|
;;;245        return kUnsupportedErr;
000008  4812              LDR      r0,|L22.84|
;;;246      
;;;247      config.address       = device->address;
;;;248      config.address_width = device->address_width;
;;;249      config.flags         &= ~I2C_DEVICE_USE_DMA ;
;;;250      config.speed_mode    = device->speed_mode;
;;;251    
;;;252      if( platform_i2c_drivers[device->port].i2c_mutex != NULL){
;;;253        mico_rtos_deinit_mutex( &platform_i2c_drivers[device->port].i2c_mutex );
;;;254        platform_i2c_drivers[device->port].i2c_mutex = NULL;
;;;255      }
;;;256        
;;;257      return (OSStatus) platform_i2c_deinit( &platform_i2c_peripherals[device->port], &config );
;;;258    }
00000a  bd1c              POP      {r2-r4,pc}
                  |L22.12|
00000c  8841              LDRH     r1,[r0,#2]            ;247
00000e  f8ad1000          STRH     r1,[sp,#0]            ;247
000012  7901              LDRB     r1,[r0,#4]            ;248
000014  f88d1002          STRB     r1,[sp,#2]            ;248
000018  f89d1003          LDRB     r1,[sp,#3]            ;249
00001c  4a0e              LDR      r2,|L22.88|
00001e  f0210101          BIC      r1,r1,#1              ;249
000022  f88d1003          STRB     r1,[sp,#3]            ;249
000026  7941              LDRB     r1,[r0,#5]            ;250
000028  f88d1004          STRB     r1,[sp,#4]            ;250
00002c  7801              LDRB     r1,[r0,#0]            ;252
00002e  f8523021          LDR      r3,[r2,r1,LSL #2]     ;252
000032  b113              CBZ      r3,|L22.58|
000034  2300              MOVS     r3,#0                 ;254
000036  f8423021          STR      r3,[r2,r1,LSL #2]     ;254
                  |L22.58|
00003a  7800              LDRB     r0,[r0,#0]            ;257
00003c  eb000180          ADD      r1,r0,r0,LSL #2       ;257
000040  eb0100c0          ADD      r0,r1,r0,LSL #3       ;257
000044  4905              LDR      r1,|L22.92|
000046  eb010080          ADD      r0,r1,r0,LSL #2       ;257
00004a  4669              MOV      r1,sp                 ;257
00004c  f7fffffe          BL       platform_i2c_deinit
000050  bd1c              POP      {r2-r4,pc}
;;;259    
                          ENDP

000052  0000              DCW      0x0000
                  |L22.84|
                          DCD      0xffffe5b1
                  |L22.88|
                          DCD      platform_i2c_drivers
                  |L22.92|
                          DCD      platform_i2c_peripherals

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

                  MicoI2cInitialize PROC
;;;216    
;;;217    OSStatus MicoI2cInitialize( mico_i2c_device_t* device )
000000  b51c              PUSH     {r2-r4,lr}
;;;218    {
;;;219      platform_i2c_config_t config;
;;;220      OSStatus result;
;;;221    
;;;222      if ( device->port >= MICO_I2C_NONE )
000002  7801              LDRB     r1,[r0,#0]
000004  2902              CMP      r1,#2
000006  d301              BCC      |L23.12|
;;;223        return kUnsupportedErr;
000008  480e              LDR      r0,|L23.68|
;;;224     
;;;225      config.address       = device->address;
;;;226      config.address_width = device->address_width;
;;;227      config.flags         &= ~I2C_DEVICE_USE_DMA ;
;;;228      config.speed_mode    = device->speed_mode;
;;;229    
;;;230      if( platform_i2c_drivers[device->port].i2c_mutex == NULL)
;;;231        mico_rtos_init_mutex( &platform_i2c_drivers[device->port].i2c_mutex );
;;;232      
;;;233      mico_rtos_lock_mutex( &platform_i2c_drivers[device->port].i2c_mutex );
;;;234      result = (OSStatus) platform_i2c_init( &platform_i2c_peripherals[device->port], &config );
;;;235      mico_rtos_unlock_mutex( &platform_i2c_drivers[device->port].i2c_mutex );
;;;236    
;;;237      return result;
;;;238    }
00000a  bd1c              POP      {r2-r4,pc}
                  |L23.12|
00000c  8841              LDRH     r1,[r0,#2]            ;225
00000e  f8ad1000          STRH     r1,[sp,#0]            ;225
000012  7901              LDRB     r1,[r0,#4]            ;226
000014  f88d1002          STRB     r1,[sp,#2]            ;226
000018  f89d1003          LDRB     r1,[sp,#3]            ;227
00001c  f0210101          BIC      r1,r1,#1              ;227
000020  f88d1003          STRB     r1,[sp,#3]            ;227
000024  7941              LDRB     r1,[r0,#5]            ;228
000026  f88d1004          STRB     r1,[sp,#4]            ;228
00002a  7800              LDRB     r0,[r0,#0]            ;230
00002c  eb000180          ADD      r1,r0,r0,LSL #2       ;234
000030  eb0100c0          ADD      r0,r1,r0,LSL #3       ;234
000034  4904              LDR      r1,|L23.72|
000036  eb010080          ADD      r0,r1,r0,LSL #2       ;234
00003a  4669              MOV      r1,sp                 ;234
00003c  f7fffffe          BL       platform_i2c_init
000040  bd1c              POP      {r2-r4,pc}
;;;239    
                          ENDP

000042  0000              DCW      0x0000
                  |L23.68|
                          DCD      0xffffe5b1
                  |L23.72|
                          DCD      platform_i2c_peripherals

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

                  MicoI2cProbeDevice PROC
;;;259    
;;;260    bool MicoI2cProbeDevice( mico_i2c_device_t* device, int retries )
000000  b51c              PUSH     {r2-r4,lr}
;;;261    {
;;;262      bool ret;
;;;263      platform_i2c_config_t config;
;;;264    
;;;265      if ( device->port >= MICO_I2C_NONE )
000002  7802              LDRB     r2,[r0,#0]
000004  2a02              CMP      r2,#2
000006  d301              BCC      |L24.12|
;;;266        return kUnsupportedErr;
000008  2001              MOVS     r0,#1
;;;267      
;;;268      config.address       = device->address;
;;;269      config.address_width = device->address_width;
;;;270      config.flags         &= ~I2C_DEVICE_USE_DMA ;
;;;271      config.speed_mode    = device->speed_mode;
;;;272    
;;;273      mico_rtos_lock_mutex( &platform_i2c_drivers[device->port].i2c_mutex );
;;;274      ret = platform_i2c_probe_device( &platform_i2c_peripherals[device->port], &config, retries );
;;;275      mico_rtos_unlock_mutex( &platform_i2c_drivers[device->port].i2c_mutex );
;;;276    
;;;277      return ret;
;;;278    }
00000a  bd1c              POP      {r2-r4,pc}
                  |L24.12|
00000c  8842              LDRH     r2,[r0,#2]            ;268
00000e  f8ad2000          STRH     r2,[sp,#0]            ;268
000012  7902              LDRB     r2,[r0,#4]            ;269
000014  f88d2002          STRB     r2,[sp,#2]            ;269
000018  f89d2003          LDRB     r2,[sp,#3]            ;270
00001c  f0220201          BIC      r2,r2,#1              ;270
000020  f88d2003          STRB     r2,[sp,#3]            ;270
000024  7942              LDRB     r2,[r0,#5]            ;271
000026  f88d2004          STRB     r2,[sp,#4]            ;271
00002a  7800              LDRB     r0,[r0,#0]            ;273
00002c  eb000280          ADD      r2,r0,r0,LSL #2       ;274
000030  eb0200c0          ADD      r0,r2,r0,LSL #3       ;274
000034  4a03              LDR      r2,|L24.68|
000036  eb020080          ADD      r0,r2,r0,LSL #2       ;274
00003a  460a              MOV      r2,r1                 ;274
00003c  4669              MOV      r1,sp                 ;274
00003e  f7fffffe          BL       platform_i2c_probe_device
000042  bd1c              POP      {r2-r4,pc}
;;;279    
                          ENDP

                  |L24.68|
                          DCD      platform_i2c_peripherals

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

                  MicoI2cTransfer PROC
;;;294    
;;;295    OSStatus MicoI2cTransfer( mico_i2c_device_t* device, mico_i2c_message_t* messages, uint16_t number_of_messages )
000000  b51c              PUSH     {r2-r4,lr}
;;;296    {
;;;297      OSStatus err = kNoErr;
;;;298      platform_i2c_config_t config;
;;;299      
;;;300      if ( device->port >= MICO_I2C_NONE )
000002  7803              LDRB     r3,[r0,#0]
000004  2b02              CMP      r3,#2
000006  d301              BCC      |L25.12|
;;;301        return kUnsupportedErr;
000008  480f              LDR      r0,|L25.72|
;;;302    
;;;303      config.address       = device->address;
;;;304      config.address_width = device->address_width;
;;;305      config.flags         &= ~I2C_DEVICE_USE_DMA ;
;;;306      config.speed_mode    = device->speed_mode;
;;;307      
;;;308      mico_rtos_lock_mutex( &platform_i2c_drivers[device->port].i2c_mutex );
;;;309      err = platform_i2c_transfer( &platform_i2c_peripherals[device->port], &config, messages, number_of_messages );
;;;310      mico_rtos_unlock_mutex( &platform_i2c_drivers[device->port].i2c_mutex );
;;;311    
;;;312      return err;
;;;313    }
00000a  bd1c              POP      {r2-r4,pc}
                  |L25.12|
00000c  8843              LDRH     r3,[r0,#2]            ;303
00000e  f8ad3000          STRH     r3,[sp,#0]            ;303
000012  7903              LDRB     r3,[r0,#4]            ;304
000014  f88d3002          STRB     r3,[sp,#2]            ;304
000018  f89d3003          LDRB     r3,[sp,#3]            ;305
00001c  f0230301          BIC      r3,r3,#1              ;305
000020  f88d3003          STRB     r3,[sp,#3]            ;305
000024  7943              LDRB     r3,[r0,#5]            ;306
000026  f88d3004          STRB     r3,[sp,#4]            ;306
00002a  7800              LDRB     r0,[r0,#0]            ;308
00002c  eb000380          ADD      r3,r0,r0,LSL #2       ;309
000030  eb0300c0          ADD      r0,r3,r0,LSL #3       ;309
000034  4b05              LDR      r3,|L25.76|
000036  eb030080          ADD      r0,r3,r0,LSL #2       ;309
00003a  4613              MOV      r3,r2                 ;309
00003c  460a              MOV      r2,r1                 ;309
00003e  4669              MOV      r1,sp                 ;309
000040  f7fffffe          BL       platform_i2c_transfer
000044  bd1c              POP      {r2-r4,pc}
;;;314    
                          ENDP

000046  0000              DCW      0x0000
                  |L25.72|
                          DCD      0xffffe5b1
                  |L25.76|
                          DCD      platform_i2c_peripherals

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

                  MicoMcuPowerSaveConfig PROC
;;;314    
;;;315    void MicoMcuPowerSaveConfig( int enable )
000000  2801              CMP      r0,#1
;;;316    {
000002  d001              BEQ      |L26.8|
;;;317      if (enable == 1)
;;;318        platform_mcu_powersave_enable( );
;;;319      else
;;;320        platform_mcu_powersave_disable( );
000004  f7ffbffe          B.W      platform_mcu_powersave_disable
                  |L26.8|
000008  f7ffbffe          B.W      platform_mcu_powersave_enable
;;;321    }
;;;322    
                          ENDP


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

                  MicoNanosendDelay PROC
;;;701    
;;;702    void MicoNanosendDelay( uint64_t delayns )
000000  f7ffbffe          B.W      platform_nanosecond_delay
;;;703    {
;;;704      platform_nanosecond_delay( delayns );
;;;705    }
;;;706    
                          ENDP


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

                  MicoPwmInitialize PROC
;;;328    
;;;329    OSStatus MicoPwmInitialize(mico_pwm_t pwm, uint32_t frequency, float duty_cycle)
000000  b108              CBZ      r0,|L28.6|
;;;330    {
;;;331      if ( pwm >= MICO_PWM_NONE )
;;;332        return kUnsupportedErr;
000002  4802              LDR      r0,|L28.12|
;;;333      return (OSStatus) platform_pwm_init( &platform_pwm_peripherals[pwm], frequency, duty_cycle );
;;;334    }
000004  4770              BX       lr
                  |L28.6|
000006  4802              LDR      r0,|L28.16|
000008  f7ffbffe          B.W      platform_pwm_init
;;;335    
                          ENDP

                  |L28.12|
                          DCD      0xffffe5b1
                  |L28.16|
                          DCD      platform_pwm_peripherals

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

                  MicoPwmStart PROC
;;;335    
;;;336    OSStatus MicoPwmStart( mico_pwm_t pwm )
000000  b108              CBZ      r0,|L29.6|
;;;337    {
;;;338      if ( pwm >= MICO_PWM_NONE )
;;;339        return kUnsupportedErr;
000002  4802              LDR      r0,|L29.12|
;;;340      return (OSStatus) platform_pwm_start( &platform_pwm_peripherals[pwm] );
;;;341    }
000004  4770              BX       lr
                  |L29.6|
000006  4802              LDR      r0,|L29.16|
000008  f7ffbffe          B.W      platform_pwm_start
;;;342    
                          ENDP

                  |L29.12|
                          DCD      0xffffe5b1
                  |L29.16|
                          DCD      platform_pwm_peripherals

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

                  MicoPwmStop PROC
;;;342    
;;;343    OSStatus MicoPwmStop( mico_pwm_t pwm )
000000  b108              CBZ      r0,|L30.6|
;;;344    {
;;;345      if ( pwm >= MICO_PWM_NONE )
;;;346        return kUnsupportedErr;
000002  4802              LDR      r0,|L30.12|
;;;347      return (OSStatus) platform_pwm_stop( &platform_pwm_peripherals[pwm] );
;;;348    }
000004  4770              BX       lr
                  |L30.6|
000006  4802              LDR      r0,|L30.16|
000008  f7ffbffe          B.W      platform_pwm_stop
;;;349    
                          ENDP

                  |L30.12|
                          DCD      0xffffe5b1
                  |L30.16|
                          DCD      platform_pwm_peripherals

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

                  MicoRandomNumberRead PROC
;;;519    
;;;520    OSStatus MicoRandomNumberRead( void *inBuffer, int inByteCount )
000000  f7ffbffe          B.W      platform_random_number_read
;;;521    {
;;;522      return (OSStatus) platform_random_number_read( inBuffer, inByteCount );
;;;523    }
;;;524    
                          ENDP


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

                  MicoRtcGetTime PROC
;;;349    
;;;350    OSStatus MicoRtcGetTime(mico_rtc_time_t* time)
000000  f7ffbffe          B.W      platform_rtc_get_time
;;;351    {
;;;352      return (OSStatus) platform_rtc_get_time( time );
;;;353    }
;;;354    
                          ENDP


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

                  MicoRtcSetTime PROC
;;;354    
;;;355    OSStatus MicoRtcSetTime(mico_rtc_time_t* time)
000000  f7ffbffe          B.W      platform_rtc_set_time
;;;356    {
;;;357      return (OSStatus) platform_rtc_set_time( time );
;;;358    }
;;;359    
                          ENDP


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

                  MicoSpiFinalize PROC
;;;382    
;;;383    OSStatus MicoSpiFinalize( const mico_spi_device_t* spi )
000000  7800              LDRB     r0,[r0,#0]
;;;384    {
;;;385      OSStatus err = kNoErr;
;;;386    
;;;387      if ( spi->port >= MICO_SPI_NONE )
000002  2802              CMP      r0,#2
000004  d301              BCC      |L34.10|
;;;388        return kUnsupportedErr;
000006  4803              LDR      r0,|L34.20|
;;;389    
;;;390      if( platform_spi_drivers[spi->port].spi_mutex == NULL)
;;;391        mico_rtos_init_mutex( &platform_spi_drivers[spi->port].spi_mutex );
;;;392      
;;;393      mico_rtos_lock_mutex( &platform_spi_drivers[spi->port].spi_mutex );
;;;394      err = platform_spi_deinit( &platform_spi_drivers[spi->port] );
;;;395      mico_rtos_unlock_mutex( &platform_spi_drivers[spi->port].spi_mutex );
;;;396    
;;;397      return err;
;;;398    }
000008  4770              BX       lr
                  |L34.10|
00000a  4903              LDR      r1,|L34.24|
00000c  eb0100c0          ADD      r0,r1,r0,LSL #3       ;390
000010  f7ffbffe          B.W      platform_spi_deinit
;;;399    
                          ENDP

                  |L34.20|
                          DCD      0xffffe5b1
                  |L34.24|
                          DCD      platform_spi_drivers

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

                  MicoSpiInitialize PROC
;;;359    
;;;360    OSStatus MicoSpiInitialize( const mico_spi_device_t* spi )
000000  b50e              PUSH     {r1-r3,lr}
;;;361    {
;;;362      platform_spi_config_t config;
;;;363      OSStatus              err = kNoErr;
;;;364    
;;;365      if ( spi->port >= MICO_SPI_NONE )
000002  7801              LDRB     r1,[r0,#0]
000004  2902              CMP      r1,#2
000006  d301              BCC      |L35.12|
;;;366        return kUnsupportedErr;
000008  480e              LDR      r0,|L35.68|
;;;367    
;;;368      if( platform_spi_drivers[spi->port].spi_mutex == NULL)
;;;369        mico_rtos_init_mutex( &platform_spi_drivers[spi->port].spi_mutex );
;;;370      
;;;371      config.chip_select = &platform_gpio_pins[spi->chip_select];
;;;372      config.speed       = spi->speed;
;;;373      config.mode        = spi->mode;
;;;374      config.bits        = spi->bits;
;;;375      
;;;376      mico_rtos_lock_mutex( &platform_spi_drivers[spi->port].spi_mutex );
;;;377      err = platform_spi_init( &platform_spi_drivers[spi->port], &platform_spi_peripherals[spi->port], &config );
;;;378      mico_rtos_unlock_mutex( &platform_spi_drivers[spi->port].spi_mutex );
;;;379    
;;;380      return err;
;;;381    }
00000a  bd0e              POP      {r1-r3,pc}
                  |L35.12|
00000c  7841              LDRB     r1,[r0,#1]            ;371
00000e  4b0f              LDR      r3,|L35.76|
000010  4a0d              LDR      r2,|L35.72|
000012  eb0301c1          ADD      r1,r3,r1,LSL #3       ;371
000016  9102              STR      r1,[sp,#8]            ;372
000018  6841              LDR      r1,[r0,#4]            ;372
00001a  9100              STR      r1,[sp,#0]            ;373
00001c  7a01              LDRB     r1,[r0,#8]            ;373
00001e  f88d1004          STRB     r1,[sp,#4]            ;373
000022  7a41              LDRB     r1,[r0,#9]            ;374
000024  f88d1005          STRB     r1,[sp,#5]            ;374
000028  7801              LDRB     r1,[r0,#0]            ;376
00002a  eb0200c1          ADD      r0,r2,r1,LSL #3       ;376
00002e  eb010241          ADD      r2,r1,r1,LSL #1       ;377
000032  eb021101          ADD      r1,r2,r1,LSL #4       ;377
000036  4a06              LDR      r2,|L35.80|
000038  eb020181          ADD      r1,r2,r1,LSL #2       ;377
00003c  466a              MOV      r2,sp                 ;377
00003e  f7fffffe          BL       platform_spi_init
000042  bd0e              POP      {r1-r3,pc}
;;;382    
                          ENDP

                  |L35.68|
                          DCD      0xffffe5b1
                  |L35.72|
                          DCD      platform_spi_drivers
                  |L35.76|
                          DCD      platform_gpio_pins
                  |L35.80|
                          DCD      platform_spi_peripherals

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

                  MicoSpiSlaveFinalize PROC
;;;431    
;;;432    OSStatus MicoSpiSlaveFinalize( mico_spi_t spi )
000000  b510              PUSH     {r4,lr}
;;;433    {
;;;434      if ( spi >= MICO_SPI_NONE )
000002  2802              CMP      r0,#2
000004  d301              BCC      |L36.10|
;;;435        return kUnsupportedErr;
000006  4803              LDR      r0,|L36.20|
;;;436    
;;;437      return (OSStatus) platform_spi_slave_deinit( &platform_spi_slave_drivers[spi] );
;;;438    }
000008  bd10              POP      {r4,pc}
                  |L36.10|
00000a  4903              LDR      r1,|L36.24|
00000c  4408              ADD      r0,r0,r1              ;437
00000e  f7fffffe          BL       platform_spi_slave_deinit
000012  bd10              POP      {r4,pc}
;;;439    
                          ENDP

                  |L36.20|
                          DCD      0xffffe5b1
                  |L36.24|
                          DCD      platform_spi_slave_drivers

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

                  MicoSpiSlaveGenerateInterrupt PROC
;;;463    
;;;464    OSStatus MicoSpiSlaveGenerateInterrupt( mico_spi_t spi, uint32_t pulse_duration_ms )
000000  b510              PUSH     {r4,lr}
;;;465    {
;;;466      if ( spi >= MICO_SPI_NONE )
000002  2802              CMP      r0,#2
000004  d301              BCC      |L37.10|
;;;467        return kUnsupportedErr;
000006  4803              LDR      r0,|L37.20|
;;;468    
;;;469      return (OSStatus) platform_spi_slave_generate_interrupt( &platform_spi_slave_drivers[spi], pulse_duration_ms );
;;;470    }
000008  bd10              POP      {r4,pc}
                  |L37.10|
00000a  4a03              LDR      r2,|L37.24|
00000c  4410              ADD      r0,r0,r2              ;469
00000e  f7fffffe          BL       platform_spi_slave_generate_interrupt
000012  bd10              POP      {r4,pc}
;;;471    
                          ENDP

                  |L37.20|
                          DCD      0xffffe5b1
                  |L37.24|
                          DCD      platform_spi_slave_drivers

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

                  MicoSpiSlaveInitialize PROC
;;;423    
;;;424    OSStatus MicoSpiSlaveInitialize( mico_spi_t spi, const mico_spi_slave_config_t* config )
000000  b510              PUSH     {r4,lr}
;;;425    {
000002  460a              MOV      r2,r1
;;;426      if ( spi >= MICO_SPI_NONE )
000004  2802              CMP      r0,#2
000006  d301              BCC      |L38.12|
;;;427        return kUnsupportedErr;
000008  4806              LDR      r0,|L38.36|
;;;428    
;;;429      return (OSStatus) platform_spi_slave_init( &platform_spi_slave_drivers[spi], &platform_spi_peripherals[spi], config );
;;;430    }
00000a  bd10              POP      {r4,pc}
                  |L38.12|
00000c  eb000140          ADD      r1,r0,r0,LSL #1       ;429
000010  4b05              LDR      r3,|L38.40|
000012  eb011100          ADD      r1,r1,r0,LSL #4       ;429
000016  eb030181          ADD      r1,r3,r1,LSL #2       ;429
00001a  4b04              LDR      r3,|L38.44|
00001c  4418              ADD      r0,r0,r3              ;429
00001e  f7fffffe          BL       platform_spi_slave_init
000022  bd10              POP      {r4,pc}
;;;431    
                          ENDP

                  |L38.36|
                          DCD      0xffffe5b1
                  |L38.40|
                          DCD      platform_spi_peripherals
                  |L38.44|
                          DCD      platform_spi_slave_drivers

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

                  MicoSpiSlaveReceiveCommand PROC
;;;447    
;;;448    OSStatus MicoSpiSlaveReceiveCommand( mico_spi_t spi, mico_spi_slave_command_t* command, uint32_t timeout_ms )
000000  b510              PUSH     {r4,lr}
;;;449    {
;;;450      if ( spi >= MICO_SPI_NONE )
000002  2802              CMP      r0,#2
000004  d301              BCC      |L39.10|
;;;451        return kUnsupportedErr;  
000006  4803              LDR      r0,|L39.20|
;;;452    
;;;453      return (OSStatus) platform_spi_slave_receive_command( &platform_spi_slave_drivers[spi], command, timeout_ms );
;;;454    }
000008  bd10              POP      {r4,pc}
                  |L39.10|
00000a  4b03              LDR      r3,|L39.24|
00000c  4418              ADD      r0,r0,r3              ;453
00000e  f7fffffe          BL       platform_spi_slave_receive_command
000012  bd10              POP      {r4,pc}
;;;455    
                          ENDP

                  |L39.20|
                          DCD      0xffffe5b1
                  |L39.24|
                          DCD      platform_spi_slave_drivers

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

                  MicoSpiSlaveSendErrorStatus PROC
;;;439    
;;;440    OSStatus  MicoSpiSlaveSendErrorStatus( mico_spi_t spi, mico_spi_slave_transfer_status_t error_status )
000000  b510              PUSH     {r4,lr}
;;;441    {
;;;442      if ( spi >= MICO_SPI_NONE )
000002  2802              CMP      r0,#2
000004  d301              BCC      |L40.10|
;;;443        return kUnsupportedErr;
000006  4803              LDR      r0,|L40.20|
;;;444    
;;;445      return (OSStatus) platform_spi_slave_send_error_status( &platform_spi_slave_drivers[spi], error_status );
;;;446    }
000008  bd10              POP      {r4,pc}
                  |L40.10|
00000a  4a03              LDR      r2,|L40.24|
00000c  4410              ADD      r0,r0,r2              ;445
00000e  f7fffffe          BL       platform_spi_slave_send_error_status
000012  bd10              POP      {r4,pc}
;;;447    
                          ENDP

                  |L40.20|
                          DCD      0xffffe5b1
                  |L40.24|
                          DCD      platform_spi_slave_drivers

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

                  MicoSpiSlaveTransferData PROC
;;;455    
;;;456    OSStatus MicoSpiSlaveTransferData( mico_spi_t spi, mico_spi_slave_transfer_direction_t direction, mico_spi_slave_data_buffer_t* buffer, uint32_t timeout_ms )
000000  b510              PUSH     {r4,lr}
;;;457    {
;;;458      if ( spi >= MICO_SPI_NONE )
000002  2802              CMP      r0,#2
000004  d301              BCC      |L41.10|
;;;459        return kUnsupportedErr;  
000006  4803              LDR      r0,|L41.20|
;;;460    
;;;461      return (OSStatus) platform_spi_slave_transfer_data( &platform_spi_slave_drivers[spi], direction, buffer, timeout_ms );
;;;462    }
000008  bd10              POP      {r4,pc}
                  |L41.10|
00000a  4c03              LDR      r4,|L41.24|
00000c  4420              ADD      r0,r0,r4              ;461
00000e  f7fffffe          BL       platform_spi_slave_transfer_data
000012  bd10              POP      {r4,pc}
;;;463    
                          ENDP

                  |L41.20|
                          DCD      0xffffe5b1
                  |L41.24|
                          DCD      platform_spi_slave_drivers

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

                  MicoSpiTransfer PROC
;;;399    
;;;400    OSStatus MicoSpiTransfer( const mico_spi_device_t* spi, const mico_spi_message_segment_t* segments, uint16_t number_of_segments )
000000  b5fe              PUSH     {r1-r7,lr}
;;;401    {
000002  4604              MOV      r4,r0
;;;402      platform_spi_config_t config;
;;;403      OSStatus err = kNoErr;
;;;404    
;;;405      if ( spi->port >= MICO_SPI_NONE )
000004  7800              LDRB     r0,[r0,#0]
000006  4616              MOV      r6,r2                 ;401
000008  460f              MOV      r7,r1                 ;401
00000a  2802              CMP      r0,#2
00000c  d301              BCC      |L42.18|
;;;406        return kUnsupportedErr;
00000e  4813              LDR      r0,|L42.92|
;;;407      
;;;408      if( platform_spi_drivers[spi->port].spi_mutex == NULL)
;;;409        mico_rtos_init_mutex( &platform_spi_drivers[spi->port].spi_mutex );
;;;410      
;;;411      config.chip_select = &platform_gpio_pins[spi->chip_select];
;;;412      config.speed       = spi->speed;
;;;413      config.mode        = spi->mode;
;;;414      config.bits        = spi->bits;
;;;415      
;;;416      mico_rtos_lock_mutex( &platform_spi_drivers[spi->port].spi_mutex );
;;;417      err = platform_spi_init( &platform_spi_drivers[spi->port], &platform_spi_peripherals[spi->port], &config );
;;;418      err = platform_spi_transfer( &platform_spi_drivers[spi->port], &config, segments, number_of_segments );
;;;419      mico_rtos_unlock_mutex( &platform_spi_drivers[spi->port].spi_mutex );
;;;420    
;;;421      return err;
;;;422    }
000010  bdfe              POP      {r1-r7,pc}
                  |L42.18|
000012  7860              LDRB     r0,[r4,#1]            ;411
000014  4913              LDR      r1,|L42.100|
000016  4d12              LDR      r5,|L42.96|
000018  eb0100c0          ADD      r0,r1,r0,LSL #3       ;411
00001c  9002              STR      r0,[sp,#8]            ;412
00001e  6860              LDR      r0,[r4,#4]            ;412
000020  9000              STR      r0,[sp,#0]            ;413
000022  7a20              LDRB     r0,[r4,#8]            ;413
000024  f88d0004          STRB     r0,[sp,#4]            ;413
000028  7a60              LDRB     r0,[r4,#9]            ;414
00002a  f88d0005          STRB     r0,[sp,#5]            ;414
00002e  7820              LDRB     r0,[r4,#0]            ;416
000030  466a              MOV      r2,sp                 ;417
000032  eb0503c0          ADD      r3,r5,r0,LSL #3       ;416
000036  eb000140          ADD      r1,r0,r0,LSL #1       ;417
00003a  eb011000          ADD      r0,r1,r0,LSL #4       ;417
00003e  490a              LDR      r1,|L42.104|
000040  eb010180          ADD      r1,r1,r0,LSL #2       ;417
000044  4618              MOV      r0,r3                 ;417
000046  f7fffffe          BL       platform_spi_init
00004a  7820              LDRB     r0,[r4,#0]            ;418
00004c  4633              MOV      r3,r6                 ;418
00004e  eb0500c0          ADD      r0,r5,r0,LSL #3       ;418
000052  463a              MOV      r2,r7                 ;418
000054  4669              MOV      r1,sp                 ;418
000056  f7fffffe          BL       platform_spi_transfer
00005a  bdfe              POP      {r1-r7,pc}
;;;423    
                          ENDP

                  |L42.92|
                          DCD      0xffffe5b1
                  |L42.96|
                          DCD      platform_spi_drivers
                  |L42.100|
                          DCD      platform_gpio_pins
                  |L42.104|
                          DCD      platform_spi_peripherals

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

                  MicoSystemReboot PROC
;;;524    
;;;525    void MicoSystemReboot( void )
000000  f7ffbffe          B.W      platform_mcu_reset
;;;526    {
;;;527      platform_mcu_reset();
;;;528    }
;;;529    OSStatus MicoWdgInitialize( uint32_t timeout )
                          ENDP


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

                  MicoSystemStandBy PROC
;;;322    
;;;323    void MicoSystemStandBy( uint32_t secondsToWakeup )
000000  f7ffbffe          B.W      platform_mcu_enter_standby
;;;324    {
;;;325      platform_mcu_enter_standby( secondsToWakeup );
;;;326    }
;;;327    
                          ENDP


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

                  MicoUartFinalize PROC
;;;487    
;;;488    OSStatus MicoUartFinalize( mico_uart_t uart )
000000  2802              CMP      r0,#2
;;;489    {
000002  d301              BCC      |L45.8|
;;;490      if ( uart >= MICO_UART_NONE )
;;;491        return kUnsupportedErr;
000004  4804              LDR      r0,|L45.24|
;;;492    
;;;493      return (OSStatus) platform_uart_deinit( &platform_uart_drivers[uart] );
;;;494    }
000006  4770              BX       lr
                  |L45.8|
000008  4904              LDR      r1,|L45.28|
00000a  ebc000c0          RSB      r0,r0,r0,LSL #3       ;493
00000e  eb010080          ADD      r0,r1,r0,LSL #2       ;493
000012  f7ffbffe          B.W      platform_uart_deinit
;;;495    
                          ENDP

000016  0000              DCW      0x0000
                  |L45.24|
                          DCD      0xffffe5b1
                  |L45.28|
                          DCD      platform_uart_drivers

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

                  MicoUartGetLengthInBuffer PROC
;;;511    
;;;512    uint32_t MicoUartGetLengthInBuffer( mico_uart_t uart )
000000  2802              CMP      r0,#2
;;;513    {
000002  d301              BCC      |L46.8|
;;;514      if ( uart >= MICO_UART_NONE )
;;;515        return 0;
000004  2000              MOVS     r0,#0
;;;516      
;;;517      return (OSStatus) platform_uart_get_length_in_buffer( &platform_uart_drivers[uart] );
;;;518    }
000006  4770              BX       lr
                  |L46.8|
000008  4903              LDR      r1,|L46.24|
00000a  ebc000c0          RSB      r0,r0,r0,LSL #3       ;517
00000e  eb010080          ADD      r0,r1,r0,LSL #2       ;517
000012  f7ffbffe          B.W      platform_uart_get_length_in_buffer
;;;519    
                          ENDP

000016  0000              DCW      0x0000
                  |L46.24|
                          DCD      platform_uart_drivers

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

                  MicoUartInitialize PROC
;;;471    
;;;472    OSStatus MicoUartInitialize( mico_uart_t uart, const mico_uart_config_t* config, ring_buffer_t* optional_rx_buffer )
000000  b430              PUSH     {r4,r5}
;;;473    {
000002  460c              MOV      r4,r1
;;;474      if ( uart >= MICO_UART_NONE )
000004  2802              CMP      r0,#2
000006  d302              BCC      |L47.14|
;;;475        return kUnsupportedErr;
000008  480a              LDR      r0,|L47.52|
                  |L47.10|
;;;476    
;;;477    #ifndef MICO_DISABLE_STDIO
;;;478      /* Interface is used by STDIO. Uncomment MICO_DISABLE_STDIO to overcome this */
;;;479      if ( uart == STDIO_UART )
;;;480      {
;;;481        return kGeneralErr;
;;;482      }
;;;483    #endif
;;;484      
;;;485      return (OSStatus) platform_uart_init( &platform_uart_drivers[uart], &platform_uart_peripherals[uart], config, optional_rx_buffer );
;;;486    }
00000a  bc30              POP      {r4,r5}
00000c  4770              BX       lr
                  |L47.14|
00000e  b170              CBZ      r0,|L47.46|
000010  4b09              LDR      r3,|L47.56|
000012  eb001100          ADD      r1,r0,r0,LSL #4       ;485
000016  eb030181          ADD      r1,r3,r1,LSL #2       ;485
00001a  4b08              LDR      r3,|L47.60|
00001c  ebc000c0          RSB      r0,r0,r0,LSL #3       ;485
000020  eb030080          ADD      r0,r3,r0,LSL #2       ;485
000024  4613              MOV      r3,r2                 ;485
000026  4622              MOV      r2,r4                 ;485
000028  bc30              POP      {r4,r5}               ;485
00002a  f7ffbffe          B.W      platform_uart_init
                  |L47.46|
00002e  f04f30ff          MOV      r0,#0xffffffff        ;481
000032  e7ea              B        |L47.10|
;;;487    
                          ENDP

                  |L47.52|
                          DCD      0xffffe5b1
                  |L47.56|
                          DCD      platform_uart_peripherals
                  |L47.60|
                          DCD      platform_uart_drivers

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

                  MicoUartRecv PROC
;;;503    
;;;504    OSStatus MicoUartRecv( mico_uart_t uart, void* data, uint32_t size, uint32_t timeout )
000000  b430              PUSH     {r4,r5}
;;;505    {
;;;506      if ( uart >= MICO_UART_NONE )
000002  2802              CMP      r0,#2
000004  d302              BCC      |L48.12|
;;;507        return kUnsupportedErr;
;;;508    
;;;509      return (OSStatus) platform_uart_receive_bytes( &platform_uart_drivers[uart], (uint8_t*)data, size, timeout );
;;;510    }
000006  bc30              POP      {r4,r5}
000008  4804              LDR      r0,|L48.28|
00000a  4770              BX       lr
                  |L48.12|
00000c  4c04              LDR      r4,|L48.32|
00000e  ebc000c0          RSB      r0,r0,r0,LSL #3       ;509
000012  eb040080          ADD      r0,r4,r0,LSL #2       ;509
000016  bc30              POP      {r4,r5}               ;509
000018  f7ffbffe          B.W      platform_uart_receive_bytes
;;;511    
                          ENDP

                  |L48.28|
                          DCD      0xffffe5b1
                  |L48.32|
                          DCD      platform_uart_drivers

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

                  MicoUartSend PROC
;;;495    
;;;496    OSStatus MicoUartSend( mico_uart_t uart, const void* data, uint32_t size )
000000  2802              CMP      r0,#2
;;;497    {
000002  d301              BCC      |L49.8|
;;;498      if ( uart >= MICO_UART_NONE )
;;;499        return kUnsupportedErr;
000004  4804              LDR      r0,|L49.24|
;;;500    
;;;501      return (OSStatus) platform_uart_transmit_bytes( &platform_uart_drivers[uart], (const uint8_t*) data, size );
;;;502    }
000006  4770              BX       lr
                  |L49.8|
000008  4b04              LDR      r3,|L49.28|
00000a  ebc000c0          RSB      r0,r0,r0,LSL #3       ;501
00000e  eb030080          ADD      r0,r3,r0,LSL #2       ;501
000012  f7ffbffe          B.W      platform_uart_transmit_bytes
;;;503    
                          ENDP

000016  0000              DCW      0x0000
                  |L49.24|
                          DCD      0xffffe5b1
                  |L49.28|
                          DCD      platform_uart_drivers

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

                  MicoWdgInitialize PROC
;;;528    }
;;;529    OSStatus MicoWdgInitialize( uint32_t timeout )
000000  f7ffbffe          B.W      platform_watchdog_init
;;;530    {
;;;531        return (OSStatus) platform_watchdog_init( timeout );
;;;532    }
;;;533    
                          ENDP


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

                  MicoWdgReload PROC
;;;533    
;;;534    void MicoWdgReload( void )
000000  f7ffbffe          B.W      platform_watchdog_kick
;;;535    {
;;;536        platform_watchdog_kick( );
;;;537    }
;;;538    
                          ENDP


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

                  mico_get_bootloader_ver PROC
;;;706    
;;;707    char *mico_get_bootloader_ver(void)
000000  4808              LDR      r0,|L52.36|
;;;708    {
000002  b508              PUSH     {r3,lr}
;;;709        static char ver[33];
;;;710        const mico_logic_partition_t* bootloader_partition = &mico_partitions[ MICO_PARTITION_BOOTLOADER ];
;;;711        uint32_t version_offset = bootloader_partition->partition_length - 0x20;
000004  68c0              LDR      r0,[r0,#0xc]
;;;712    
;;;713        memset(ver, 0, sizeof(ver));
000006  2121              MOVS     r1,#0x21
000008  3820              SUBS     r0,r0,#0x20           ;711
00000a  9000              STR      r0,[sp,#0]
00000c  4806              LDR      r0,|L52.40|
00000e  f7fffffe          BL       __aeabi_memclr
;;;714        MicoFlashRead( MICO_PARTITION_BOOTLOADER, &version_offset, (uint8_t *)ver , 32);
000012  2320              MOVS     r3,#0x20
000014  4a04              LDR      r2,|L52.40|
000016  4669              MOV      r1,sp
000018  2000              MOVS     r0,#0
00001a  f7fffffe          BL       MicoFlashRead
;;;715        return ver;
00001e  4802              LDR      r0,|L52.40|
;;;716    }
000020  bd08              POP      {r3,pc}
;;;717    
                          ENDP

000022  0000              DCW      0x0000
                  |L52.36|
                          DCD      mico_partitions
                  |L52.40|
                          DCD      ||.bss||

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

                  mico_gpio_input_get PROC
;;;195    
;;;196    bool MicoGpioInputGet( mico_gpio_t gpio )
000000  280d              CMP      r0,#0xd
;;;197    {
000002  d301              BCC      |L53.8|
;;;198      if ( gpio >= MICO_GPIO_NONE )
;;;199        return kUnsupportedErr;
000004  2001              MOVS     r0,#1
;;;200      return platform_gpio_input_get( &platform_gpio_pins[gpio] );
;;;201    }
000006  4770              BX       lr
                  |L53.8|
000008  4902              LDR      r1,|L53.20|
00000a  eb0100c0          ADD      r0,r1,r0,LSL #3       ;200
00000e  f7ffbffe          B.W      platform_gpio_input_get
;;;202    
                          ENDP

000012  0000              DCW      0x0000
                  |L53.20|
                          DCD      platform_gpio_pins

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

                  mico_platform_init PROC
;;;100    
;;;101    OSStatus mico_platform_init( void )
000000  b510              PUSH     {r4,lr}
;;;102    {
;;;103    #if defined(__CC_ARM)
;;;104      platform_log("Platform initialised, build by RVMDK");
;;;105    #elif defined (__IAR_SYSTEMS_ICC__)
;;;106      platform_log("Platform initialised, build by IAR");
;;;107    #endif
;;;108      
;;;109      if ( true == platform_watchdog_check_last_reset() )
000002  f7fffffe          BL       platform_watchdog_check_last_reset
;;;110      {
;;;111        platform_log( "WARNING: Watchdog reset occured previously. Please see platform_watchdog.c for debugging instructions." );
;;;112      }
;;;113    
;;;114    #ifdef USES_RESOURCE_FILESYSTEM
;;;115      platform_filesystem_init();
;;;116    #endif
;;;117     
;;;118    #ifndef BOOTLOADER
;;;119      
;;;120    #ifdef USE_MiCOKit_EXT
;;;121      micokit_ext_init();
;;;122    #endif
;;;123      
;;;124    #ifdef USE_MiCOKit_STMEMS
;;;125      micokit_STmems_init();
;;;126    #endif
;;;127      
;;;128    #endif
;;;129      
;;;130      return kNoErr;
000006  2000              MOVS     r0,#0
;;;131    }
000008  bd10              POP      {r4,pc}
;;;132    
                          ENDP


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

                  mico_rtos_deinit_mutex PROC
;;;788    
;;;789    OSStatus mico_rtos_deinit_mutex( mico_mutex_t* mutex )
000000  2000              MOVS     r0,#0
;;;790    {
;;;791      UNUSED_PARAMETER( mutex );
;;;792      return kNoErr;
;;;793    }
000002  4770              BX       lr
;;;794    
                          ENDP


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

                  mico_rtos_init_mutex PROC
;;;770    
;;;771    OSStatus mico_rtos_init_mutex( mico_mutex_t* mutex )
000000  2000              MOVS     r0,#0
;;;772    {
;;;773      UNUSED_PARAMETER( mutex );
;;;774      return kNoErr;
;;;775    }
000002  4770              BX       lr
;;;776    
                          ENDP


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

                  mico_rtos_lock_mutex PROC
;;;776    
;;;777    OSStatus mico_rtos_lock_mutex( mico_mutex_t* mutex )
000000  2000              MOVS     r0,#0
;;;778    {
;;;779      UNUSED_PARAMETER( mutex );
;;;780      return kNoErr;
;;;781    }
000002  4770              BX       lr
;;;782    
                          ENDP


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

                  mico_rtos_unlock_mutex PROC
;;;782    
;;;783    OSStatus mico_rtos_unlock_mutex( mico_mutex_t* mutex )
000000  2000              MOVS     r0,#0
;;;784    {
;;;785      UNUSED_PARAMETER( mutex );
;;;786      return kNoErr;
;;;787    }
000002  4770              BX       lr
;;;788    
                          ENDP


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

                          REQUIRE _printf_percent
                          REQUIRE _printf_d
                          REQUIRE _printf_s
                          REQUIRE _printf_int_dec
                          REQUIRE _printf_str
                  mico_set_bootload_ver PROC
;;;720    
;;;721    void mico_set_bootload_ver(void)
000000  b510              PUSH     {r4,lr}
;;;722    {
000002  b08c              SUB      sp,sp,#0x30
;;;723       char ver[33];
;;;724       mico_logic_partition_t *boot_partition = MicoFlashGetInfo( MICO_PARTITION_BOOTLOADER );
000004  2000              MOVS     r0,#0
000006  f7fffffe          BL       MicoFlashGetInfo
00000a  4604              MOV      r4,r0
;;;725       uint32_t flashaddr =  boot_partition->partition_length - 0x20;
00000c  68c0              LDR      r0,[r0,#0xc]
;;;726       int i;
;;;727    
;;;728       memset(ver, 0, sizeof(ver));
00000e  2124              MOVS     r1,#0x24
000010  3820              SUBS     r0,r0,#0x20           ;725
000012  900b              STR      r0,[sp,#0x2c]
000014  a802              ADD      r0,sp,#8
000016  f7fffffe          BL       __aeabi_memclr4
;;;729       MicoFlashRead( MICO_PARTITION_BOOTLOADER, &flashaddr, (uint8_t *)ver , 32);
00001a  2320              MOVS     r3,#0x20
00001c  aa02              ADD      r2,sp,#8
00001e  a90b              ADD      r1,sp,#0x2c
000020  2000              MOVS     r0,#0
000022  f7fffffe          BL       MicoFlashRead
;;;730       for(i=0;i<32;i++) {
000026  2100              MOVS     r1,#0
000028  a802              ADD      r0,sp,#8              ;723
                  |L59.42|
;;;731           if (ver[i] != 0xFF)
00002a  5c42              LDRB     r2,[r0,r1]
00002c  2aff              CMP      r2,#0xff
00002e  d11b              BNE      |L59.104|
000030  1c49              ADDS     r1,r1,#1
000032  2920              CMP      r1,#0x20              ;730
000034  dbf9              BLT      |L59.42|
;;;732               return;
;;;733       }
;;;734       snprintf(ver, 33, "%s %s %d", MODEL, Bootloader_REVISION , STDIO_UART_BAUDRATE);
000036  f44f2161          MOV      r1,#0xe1000
00003a  a00c              ADR      r0,|L59.108|
00003c  e9cd0100          STRD     r0,r1,[sp,#0]
000040  a30c              ADR      r3,|L59.116|
000042  a20f              ADR      r2,|L59.128|
000044  2121              MOVS     r1,#0x21
000046  a802              ADD      r0,sp,#8
000048  f7fffffe          BL       __2snprintf
;;;735       flashaddr =  boot_partition->partition_length - 0x20;
00004c  68e2              LDR      r2,[r4,#0xc]
;;;736       MicoFlashDisableSecurity( MICO_PARTITION_BOOTLOADER, 0x0, boot_partition->partition_length );
00004e  2100              MOVS     r1,#0
000050  f1a20020          SUB      r0,r2,#0x20           ;735
000054  900b              STR      r0,[sp,#0x2c]
000056  4608              MOV      r0,r1
000058  f7fffffe          BL       MicoFlashDisableSecurity
;;;737       MicoFlashWrite( MICO_PARTITION_BOOTLOADER, &flashaddr, (uint8_t *)ver , 32);
00005c  2320              MOVS     r3,#0x20
00005e  aa02              ADD      r2,sp,#8
000060  a90b              ADD      r1,sp,#0x2c
000062  2000              MOVS     r0,#0
000064  f7fffffe          BL       MicoFlashWrite
                  |L59.104|
;;;738    }
000068  b00c              ADD      sp,sp,#0x30
00006a  bd10              POP      {r4,pc}
;;;739    
                          ENDP

                  |L59.108|
00006c  76322e31          DCB      "v2.1",0
000070  00      
000071  00                DCB      0
000072  00                DCB      0
000073  00                DCB      0
                  |L59.116|
000074  46495245          DCB      "FIRE-F429",0
000078  2d463432
00007c  3900    
00007e  00                DCB      0
00007f  00                DCB      0
                  |L59.128|
000080  25732025          DCB      "%s %s %d",0
000084  73202564
000088  00      
000089  00                DCB      0
00008a  00                DCB      0
00008b  00                DCB      0

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

                  ver
                          %        33

;*** Start embedded assembler ***

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

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

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
