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

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

                  NVIC_DisableIRQ PROC
;;;1464    */
;;;1465   __STATIC_INLINE void NVIC_DisableIRQ(IRQn_Type IRQn)
000000  f000021f          AND      r2,r0,#0x1f
;;;1466   {
;;;1467     NVIC->ICER[((uint32_t)(IRQn) >> 5)] = ((uint32_t)1 << ((uint32_t)(IRQn) & (uint32_t)0x1F)); /* disable interrupt */
000004  2101              MOVS     r1,#1
000006  4091              LSLS     r1,r1,r2
000008  0940              LSRS     r0,r0,#5
00000a  0080              LSLS     r0,r0,#2
00000c  f10020e0          ADD      r0,r0,#0xe000e000
000010  f8c01180          STR      r1,[r0,#0x180]
;;;1468   }
000014  4770              BX       lr
;;;1469   
                          ENDP


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

                  NVIC_EnableIRQ PROC
;;;1451    */
;;;1452   __STATIC_INLINE void NVIC_EnableIRQ(IRQn_Type IRQn)
000000  f000021f          AND      r2,r0,#0x1f
;;;1453   {
;;;1454   /*  NVIC->ISER[((uint32_t)(IRQn) >> 5)] = (1 << ((uint32_t)(IRQn) & 0x1F));  enable interrupt */
;;;1455     NVIC->ISER[(uint32_t)((int32_t)IRQn) >> 5] = (uint32_t)(1 << ((uint32_t)((int32_t)IRQn) & (uint32_t)0x1F)); /* enable interrupt */
000004  2101              MOVS     r1,#1
000006  4091              LSLS     r1,r1,r2
000008  0940              LSRS     r0,r0,#5
00000a  0080              LSLS     r0,r0,#2
00000c  f10020e0          ADD      r0,r0,#0xe000e000
000010  f8c01100          STR      r1,[r0,#0x100]
;;;1456   }
000014  4770              BX       lr
;;;1457   
                          ENDP


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

                  clear_dma_interrupts PROC
;;;561    
;;;562    static void clear_dma_interrupts( DMA_Stream_TypeDef* stream, uint32_t flags )
000000  4a0e              LDR      r2,|L3.60|
;;;563    {
;;;564        if ( stream <= DMA1_Stream3 )
000002  4b0e              LDR      r3,|L3.60|
;;;565        {
;;;566            DMA1->LIFCR |= flags;
000004  3a58              SUBS     r2,r2,#0x58
000006  4298              CMP      r0,r3                 ;564
000008  d803              BHI      |L3.18|
00000a  6890              LDR      r0,[r2,#8]
00000c  4308              ORRS     r0,r0,r1
00000e  6090              STR      r0,[r2,#8]
;;;567        }
;;;568        else if ( stream <= DMA1_Stream7 )
;;;569        {
;;;570            DMA1->HIFCR |= flags;
;;;571        }
;;;572        else if ( stream <= DMA2_Stream3 )
;;;573        {
;;;574            DMA2->LIFCR |= flags;
;;;575        }
;;;576        else
;;;577        {
;;;578            DMA2->HIFCR |= flags;
;;;579        }
;;;580    }
000010  4770              BX       lr
                  |L3.18|
000012  4b0a              LDR      r3,|L3.60|
000014  3360              ADDS     r3,r3,#0x60           ;568
000016  4298              CMP      r0,r3                 ;568
000018  d803              BHI      |L3.34|
00001a  68d0              LDR      r0,[r2,#0xc]          ;570
00001c  4308              ORRS     r0,r0,r1              ;570
00001e  60d0              STR      r0,[r2,#0xc]          ;570
000020  4770              BX       lr
                  |L3.34|
000022  4a07              LDR      r2,|L3.64|
000024  4290              CMP      r0,r2                 ;572
000026  d802              BHI      |L3.46|
000028  4805              LDR      r0,|L3.64|
00002a  3850              SUBS     r0,r0,#0x50           ;574
00002c  e001              B        |L3.50|
                  |L3.46|
00002e  4804              LDR      r0,|L3.64|
000030  384c              SUBS     r0,r0,#0x4c           ;578
                  |L3.50|
000032  6802              LDR      r2,[r0,#0]            ;578
000034  430a              ORRS     r2,r2,r1              ;578
000036  6002              STR      r2,[r0,#0]            ;578
000038  4770              BX       lr
;;;581    
                          ENDP

00003a  0000              DCW      0x0000
                  |L3.60|
                          DCD      0x40026058
                  |L3.64|
                          DCD      0x40026458

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

                  get_dma_irq_status PROC
;;;581    
;;;582    static uint32_t get_dma_irq_status( DMA_Stream_TypeDef* stream )
000000  490b              LDR      r1,|L4.48|
;;;583    {
;;;584        if ( stream <= DMA1_Stream3 )
000002  4a0b              LDR      r2,|L4.48|
;;;585        {
;;;586            return DMA1->LISR;
000004  3958              SUBS     r1,r1,#0x58
000006  4290              CMP      r0,r2                 ;584
000008  d801              BHI      |L4.14|
00000a  6808              LDR      r0,[r1,#0]
;;;587        }
;;;588        else if ( stream <= DMA1_Stream7 )
;;;589        {
;;;590            return DMA1->HISR;
;;;591        }
;;;592        else if ( stream <= DMA2_Stream3 )
;;;593        {
;;;594            return DMA2->LISR;
;;;595        }
;;;596        else
;;;597        {
;;;598            return DMA2->HISR;
;;;599        }
;;;600    }
00000c  4770              BX       lr
                  |L4.14|
00000e  4a08              LDR      r2,|L4.48|
000010  3260              ADDS     r2,r2,#0x60           ;588
000012  4290              CMP      r0,r2                 ;588
000014  d801              BHI      |L4.26|
000016  6848              LDR      r0,[r1,#4]            ;590
000018  4770              BX       lr
                  |L4.26|
00001a  4906              LDR      r1,|L4.52|
00001c  4288              CMP      r0,r1                 ;592
00001e  d802              BHI      |L4.38|
000020  4804              LDR      r0,|L4.52|
000022  3858              SUBS     r0,r0,#0x58           ;594
000024  e001              B        |L4.42|
                  |L4.38|
000026  4803              LDR      r0,|L4.52|
000028  3854              SUBS     r0,r0,#0x54           ;598
                  |L4.42|
00002a  6800              LDR      r0,[r0,#0]            ;598
00002c  4770              BX       lr
;;;601    
                          ENDP

00002e  0000              DCW      0x0000
                  |L4.48|
                          DCD      0x40026058
                  |L4.52|
                          DCD      0x40026458

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

                  platform_uart_deinit PROC
;;;332    
;;;333    OSStatus platform_uart_deinit( platform_uart_driver_t* driver )
000000  b570              PUSH     {r4-r6,lr}
;;;334    {
000002  4604              MOV      r4,r0
;;;335      uint8_t          uart_number;
;;;336      OSStatus          err = kNoErr;
000004  2600              MOVS     r6,#0
;;;337    
;;;338      platform_mcu_powersave_disable();
000006  f7fffffe          BL       platform_mcu_powersave_disable
;;;339    
;;;340      require_action_quiet( ( driver != NULL ), exit, err = kParamErr);
00000a  b3ec              CBZ      r4,|L5.136|
;;;341    
;;;342      uart_number = platform_uart_get_port_number( driver->peripheral->port );
00000c  6820              LDR      r0,[r4,#0]
00000e  6800              LDR      r0,[r0,#0]
000010  f7fffffe          BL       platform_uart_get_port_number
000014  4605              MOV      r5,r0
;;;343    
;;;344      /* Disable USART */
;;;345      USART_Cmd( driver->peripheral->port, DISABLE );
000016  6820              LDR      r0,[r4,#0]
000018  2100              MOVS     r1,#0
00001a  6800              LDR      r0,[r0,#0]
00001c  f7fffffe          BL       USART_Cmd
;;;346    
;;;347      /* Deinitialise USART */
;;;348      USART_DeInit( driver->peripheral->port );
000020  6820              LDR      r0,[r4,#0]
000022  6800              LDR      r0,[r0,#0]
000024  f7fffffe          BL       USART_DeInit
;;;349    
;;;350      /**************************************************************************
;;;351       * De-initialise STM32 DMA and interrupt
;;;352       **************************************************************************/
;;;353    
;;;354      /* Deinitialise DMA streams */
;;;355      DMA_DeInit( driver->peripheral->tx_dma_config.stream );
000028  6820              LDR      r0,[r4,#0]
00002a  6980              LDR      r0,[r0,#0x18]
00002c  f7fffffe          BL       DMA_DeInit
;;;356      DMA_DeInit( driver->peripheral->rx_dma_config.stream );
000030  6820              LDR      r0,[r4,#0]
000032  6b00              LDR      r0,[r0,#0x30]
000034  f7fffffe          BL       DMA_DeInit
;;;357    
;;;358      /* Disable TC (transfer complete) interrupt at the source */
;;;359      DMA_ITConfig( driver->peripheral->tx_dma_config.stream, DMA_INTERRUPT_FLAGS, DISABLE );
000038  6820              LDR      r0,[r4,#0]
00003a  2200              MOVS     r2,#0
00003c  2196              MOVS     r1,#0x96
00003e  6980              LDR      r0,[r0,#0x18]
000040  f7fffffe          BL       DMA_ITConfig
;;;360      DMA_ITConfig( driver->peripheral->rx_dma_config.stream, DMA_INTERRUPT_FLAGS, DISABLE );
000044  6820              LDR      r0,[r4,#0]
000046  2200              MOVS     r2,#0
000048  2196              MOVS     r1,#0x96
00004a  6b00              LDR      r0,[r0,#0x30]
00004c  f7fffffe          BL       DMA_ITConfig
;;;361    
;;;362      /* Disable transmit DMA interrupt at Cortex-M3 */
;;;363      NVIC_DisableIRQ( driver->peripheral->tx_dma_config.irq_vector );
000050  6820              LDR      r0,[r4,#0]
000052  f9900020          LDRSB    r0,[r0,#0x20]
000056  f7fffffe          BL       NVIC_DisableIRQ
;;;364    
;;;365      /**************************************************************************
;;;366       * De-initialise STM32 USART interrupt
;;;367       **************************************************************************/
;;;368    
;;;369      USART_ITConfig( driver->peripheral->port, USART_IT_RXNE, DISABLE );
00005a  6820              LDR      r0,[r4,#0]
00005c  2200              MOVS     r2,#0
00005e  f2405125          MOV      r1,#0x525
000062  6800              LDR      r0,[r0,#0]
000064  f7fffffe          BL       USART_ITConfig
;;;370    
;;;371      /* Disable UART interrupt vector on Cortex-M3 */
;;;372      NVIC_DisableIRQ( driver->peripheral->rx_dma_config.irq_vector );
000068  6820              LDR      r0,[r4,#0]
00006a  f9900038          LDRSB    r0,[r0,#0x38]
00006e  f7fffffe          BL       NVIC_DisableIRQ
;;;373    
;;;374      /* Disable registers clocks */
;;;375      uart_peripheral_clock_functions[uart_number]( uart_peripheral_clocks[uart_number], DISABLE );
000072  490c              LDR      r1,|L5.164|
000074  480b              LDR      r0,|L5.164|
000076  3918              SUBS     r1,r1,#0x18
000078  f8512025          LDR      r2,[r1,r5,LSL #2]
00007c  f8500025          LDR      r0,[r0,r5,LSL #2]
000080  2100              MOVS     r1,#0
000082  4790              BLX      r2
;;;376    
;;;377    #ifndef NO_MICO_RTOS
;;;378      mico_rtos_deinit_semaphore( &driver->rx_complete );
;;;379      mico_rtos_deinit_semaphore( &driver->tx_complete );
;;;380      mico_rtos_deinit_mutex( &driver->tx_mutex );
;;;381    #else
;;;382      driver->rx_complete = false;
000084  2000              MOVS     r0,#0
000086  e000              B        |L5.138|
                  |L5.136|
000088  e009              B        |L5.158|
                  |L5.138|
00008a  7220              STRB     r0,[r4,#8]
;;;383      driver->tx_complete = false;
00008c  7260              STRB     r0,[r4,#9]
;;;384    #endif
;;;385      driver->rx_size              = 0;
00008e  6120              STR      r0,[r4,#0x10]
;;;386      driver->tx_size              = 0;
000090  60e0              STR      r0,[r4,#0xc]
;;;387      driver->last_transmit_result = kNoErr;
000092  61a0              STR      r0,[r4,#0x18]
;;;388      driver->last_receive_result  = kNoErr;
000094  6160              STR      r0,[r4,#0x14]
                  |L5.150|
;;;389    
;;;390    exit:
;;;391        platform_mcu_powersave_enable();
000096  f7fffffe          BL       platform_mcu_powersave_enable
;;;392        return err;
00009a  4630              MOV      r0,r6
;;;393    }
00009c  bd70              POP      {r4-r6,pc}
                  |L5.158|
00009e  4e02              LDR      r6,|L5.168|
0000a0  e7f9              B        |L5.150|
;;;394    
                          ENDP

0000a2  0000              DCW      0x0000
                  |L5.164|
                          DCD      ||.constdata||+0x24
                  |L5.168|
                          DCD      0xffffe5cf

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

                  platform_uart_get_length_in_buffer PROC
;;;556    
;;;557    OSStatus platform_uart_get_length_in_buffer( platform_uart_driver_t* driver )
000000  6840              LDR      r0,[r0,#4]
;;;558    {  
;;;559      return ring_buffer_used_space( driver->rx_buffer );
000002  f7ffbffe          B.W      ring_buffer_used_space
;;;560    }
;;;561    
                          ENDP


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

                  platform_uart_get_port_number PROC
;;;601    
;;;602    uint8_t platform_uart_get_port_number( USART_TypeDef* uart )
000000  490f              LDR      r1,|L7.64|
;;;603    {
;;;604        if ( uart == USART1 )
000002  4288              CMP      r0,r1
000004  d101              BNE      |L7.10|
;;;605        {
;;;606            return 0;
000006  2000              MOVS     r0,#0
;;;607        }
;;;608        else if ( uart == USART2 )
;;;609        {
;;;610            return 1;
;;;611        }
;;;612        else if ( uart == USART3 )
;;;613        {
;;;614            return 2;
;;;615        }
;;;616        else if ( uart == UART4 )
;;;617        {
;;;618            return 3;
;;;619        }
;;;620        else if ( uart == UART5 )
;;;621        {
;;;622            return 4;
;;;623        }
;;;624        else if ( uart == USART6 )
;;;625        {
;;;626            return 5;
;;;627        }
;;;628        else
;;;629        {
;;;630            return 0xff;
;;;631        }
;;;632    }
000008  4770              BX       lr
                  |L7.10|
00000a  490e              LDR      r1,|L7.68|
00000c  4288              CMP      r0,r1                 ;608
00000e  d101              BNE      |L7.20|
000010  2001              MOVS     r0,#1                 ;610
000012  4770              BX       lr
                  |L7.20|
000014  490c              LDR      r1,|L7.72|
000016  4288              CMP      r0,r1                 ;612
000018  d101              BNE      |L7.30|
00001a  2002              MOVS     r0,#2                 ;614
00001c  4770              BX       lr
                  |L7.30|
00001e  490b              LDR      r1,|L7.76|
000020  4288              CMP      r0,r1                 ;616
000022  d101              BNE      |L7.40|
000024  2003              MOVS     r0,#3                 ;618
000026  4770              BX       lr
                  |L7.40|
000028  4909              LDR      r1,|L7.80|
00002a  4288              CMP      r0,r1                 ;620
00002c  d101              BNE      |L7.50|
00002e  2004              MOVS     r0,#4                 ;622
000030  4770              BX       lr
                  |L7.50|
000032  4908              LDR      r1,|L7.84|
000034  4288              CMP      r0,r1                 ;624
000036  d101              BNE      |L7.60|
000038  2005              MOVS     r0,#5                 ;626
00003a  4770              BX       lr
                  |L7.60|
00003c  20ff              MOVS     r0,#0xff              ;630
00003e  4770              BX       lr
;;;633    
                          ENDP

                  |L7.64|
                          DCD      0x40011000
                  |L7.68|
                          DCD      0x40004400
                  |L7.72|
                          DCD      0x40004800
                  |L7.76|
                          DCD      0x40004c00
                  |L7.80|
                          DCD      0x40005000
                  |L7.84|
                          DCD      0x40011400

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

                  platform_uart_init PROC
;;;128    
;;;129    OSStatus platform_uart_init( platform_uart_driver_t* driver, const platform_uart_t* peripheral, const platform_uart_config_t* config, ring_buffer_t* optional_ring_buffer )
000000  e92d4ff0          PUSH     {r4-r11,lr}
;;;130    {
000004  b095              SUB      sp,sp,#0x54
000006  4698              MOV      r8,r3
000008  4616              MOV      r6,r2
00000a  460c              MOV      r4,r1
00000c  4605              MOV      r5,r0
;;;131      DMA_InitTypeDef   dma_init_structure;
;;;132      USART_InitTypeDef uart_init_structure;
;;;133      uint32_t          uart_number;
;;;134      OSStatus          err = kNoErr;
00000e  f04f0900          MOV      r9,#0
;;;135    
;;;136      platform_mcu_powersave_disable();
000012  f7fffffe          BL       platform_mcu_powersave_disable
;;;137    
;;;138      require_action_quiet( ( driver != NULL ) && ( peripheral != NULL ) && ( config != NULL ), exit, err = kParamErr);
000016  f8dfb280          LDR      r11,|L8.664|
00001a  2d00              CMP      r5,#0
00001c  d07e              BEQ      |L8.284|
00001e  2c00              CMP      r4,#0
000020  d07c              BEQ      |L8.284|
000022  2e00              CMP      r6,#0
000024  d07a              BEQ      |L8.284|
;;;139      require_action_quiet( (optional_ring_buffer == NULL) || ((optional_ring_buffer->buffer != NULL ) && (optional_ring_buffer->size != 0)), exit, err = kParamErr);
000026  f1b80f00          CMP      r8,#0
00002a  d007              BEQ      |L8.60|
00002c  f8d8000c          LDR      r0,[r8,#0xc]
000030  2800              CMP      r0,#0
000032  d073              BEQ      |L8.284|
000034  f8d80000          LDR      r0,[r8,#0]
000038  2800              CMP      r0,#0
00003a  d06f              BEQ      |L8.284|
                  |L8.60|
;;;140      
;;;141      uart_number = platform_uart_get_port_number( peripheral->port );
00003c  6820              LDR      r0,[r4,#0]
00003e  f7fffffe          BL       platform_uart_get_port_number
;;;142      
;;;143      driver->rx_size              = 0;
000042  f04f0a00          MOV      r10,#0
000046  4607              MOV      r7,r0                 ;141
000048  f8c5a010          STR      r10,[r5,#0x10]
;;;144      driver->tx_size              = 0;
00004c  f8c5a00c          STR      r10,[r5,#0xc]
;;;145      driver->last_transmit_result = kNoErr;
000050  f8c5a018          STR      r10,[r5,#0x18]
;;;146      driver->last_receive_result  = kNoErr;
000054  f8c5a014          STR      r10,[r5,#0x14]
;;;147      driver->peripheral           = (platform_uart_t*)peripheral;
;;;148    #ifndef NO_MICO_RTOS
;;;149      mico_rtos_init_semaphore( &driver->tx_complete, 1 );
;;;150      mico_rtos_init_semaphore( &driver->rx_complete, 1 );
;;;151      mico_rtos_init_semaphore( &driver->sem_wakeup,  1 );
;;;152      mico_rtos_init_mutex    ( &driver->tx_mutex );
;;;153    #else
;;;154      driver->tx_complete = false;
000058  602c              STR      r4,[r5,#0]
00005a  f885a009          STRB     r10,[r5,#9]
;;;155      driver->rx_complete = false;
00005e  f885a008          STRB     r10,[r5,#8]
;;;156    #endif
;;;157        
;;;158      /* Configure TX and RX pin_mapping */
;;;159      platform_gpio_set_alternate_function( peripheral->pin_tx->port, peripheral->pin_tx->pin_number, GPIO_OType_PP, GPIO_PuPd_UP, uart_alternate_functions[ uart_number ] );
000062  488e              LDR      r0,|L8.668|
000064  2301              MOVS     r3,#1
000066  4652              MOV      r2,r10
000068  5dc0              LDRB     r0,[r0,r7]
00006a  9000              STR      r0,[sp,#0]
00006c  6860              LDR      r0,[r4,#4]
00006e  7901              LDRB     r1,[r0,#4]
000070  6800              LDR      r0,[r0,#0]
000072  f7fffffe          BL       platform_gpio_set_alternate_function
;;;160      platform_gpio_set_alternate_function( peripheral->pin_rx->port, peripheral->pin_rx->pin_number, GPIO_OType_PP, GPIO_PuPd_UP, uart_alternate_functions[ uart_number ] );
000076  4889              LDR      r0,|L8.668|
000078  2301              MOVS     r3,#1
00007a  2200              MOVS     r2,#0
00007c  5dc0              LDRB     r0,[r0,r7]
00007e  9000              STR      r0,[sp,#0]
000080  68a0              LDR      r0,[r4,#8]
000082  7901              LDRB     r1,[r0,#4]
000084  6800              LDR      r0,[r0,#0]
000086  f7fffffe          BL       platform_gpio_set_alternate_function
;;;161    
;;;162      if ( ( peripheral->pin_cts != NULL ) && ( config->flow_control == FLOW_CONTROL_CTS || config->flow_control == FLOW_CONTROL_CTS_RTS ) )
00008a  68e0              LDR      r0,[r4,#0xc]
00008c  b168              CBZ      r0,|L8.170|
00008e  79f1              LDRB     r1,[r6,#7]
000090  2901              CMP      r1,#1
000092  d001              BEQ      |L8.152|
000094  2903              CMP      r1,#3
000096  d108              BNE      |L8.170|
                  |L8.152|
;;;163      {
;;;164          platform_gpio_set_alternate_function( peripheral->pin_cts->port, peripheral->pin_cts->pin_number, GPIO_OType_PP, GPIO_PuPd_NOPULL, uart_alternate_functions[ uart_number ] );
000098  4980              LDR      r1,|L8.668|
00009a  2300              MOVS     r3,#0
00009c  461a              MOV      r2,r3
00009e  5dc9              LDRB     r1,[r1,r7]
0000a0  9100              STR      r1,[sp,#0]
0000a2  7901              LDRB     r1,[r0,#4]
0000a4  6800              LDR      r0,[r0,#0]
0000a6  f7fffffe          BL       platform_gpio_set_alternate_function
                  |L8.170|
;;;165      }
;;;166    
;;;167      if ( ( peripheral->pin_rts != NULL ) && ( config->flow_control == FLOW_CONTROL_RTS || config->flow_control == FLOW_CONTROL_CTS_RTS ) )
0000aa  6920              LDR      r0,[r4,#0x10]
0000ac  b168              CBZ      r0,|L8.202|
0000ae  79f1              LDRB     r1,[r6,#7]
0000b0  2902              CMP      r1,#2
0000b2  d001              BEQ      |L8.184|
0000b4  2903              CMP      r1,#3
0000b6  d108              BNE      |L8.202|
                  |L8.184|
;;;168      {
;;;169          platform_gpio_set_alternate_function( peripheral->pin_rts->port, peripheral->pin_rts->pin_number, GPIO_OType_PP, GPIO_PuPd_NOPULL, uart_alternate_functions[ uart_number ] );
0000b8  4978              LDR      r1,|L8.668|
0000ba  2300              MOVS     r3,#0
0000bc  461a              MOV      r2,r3
0000be  5dc9              LDRB     r1,[r1,r7]
0000c0  9100              STR      r1,[sp,#0]
0000c2  7901              LDRB     r1,[r0,#4]
0000c4  6800              LDR      r0,[r0,#0]
0000c6  f7fffffe          BL       platform_gpio_set_alternate_function
                  |L8.202|
;;;170      }
;;;171      
;;;172    #ifndef NO_MICO_RTOS
;;;173      if(config->flags & UART_WAKEUP_ENABLE){
;;;174        mico_rtos_init_semaphore( driver->sem_wakeup, 1 );
;;;175        mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "UART_WAKEUP", thread_wakeup, 0x100, driver);
;;;176      }
;;;177    #endif
;;;178      
;;;179    /* Enable UART peripheral clock */
;;;180      uart_peripheral_clock_functions[ uart_number ]( uart_peripheral_clocks[ uart_number ], ENABLE );
0000ca  4874              LDR      r0,|L8.668|
0000cc  4973              LDR      r1,|L8.668|
0000ce  3024              ADDS     r0,r0,#0x24
0000d0  310c              ADDS     r1,r1,#0xc
0000d2  f8500027          LDR      r0,[r0,r7,LSL #2]
0000d6  f8512027          LDR      r2,[r1,r7,LSL #2]
0000da  2101              MOVS     r1,#1
0000dc  4790              BLX      r2
;;;181    
;;;182      uart_init_structure.USART_Mode       = USART_Mode_Rx | USART_Mode_Tx;
0000de  200c              MOVS     r0,#0xc
0000e0  f8ad004a          STRH     r0,[sp,#0x4a]
;;;183      uart_init_structure.USART_BaudRate   = config->baud_rate;
0000e4  6830              LDR      r0,[r6,#0]
;;;184      uart_init_structure.USART_WordLength = ( ( config->data_width == DATA_WIDTH_9BIT ) || ( ( config->data_width == DATA_WIDTH_8BIT ) && ( config->parity != NO_PARITY ) ) ) ? USART_WordLength_9b : USART_WordLength_8b;
0000e6  9010              STR      r0,[sp,#0x40]
0000e8  7930              LDRB     r0,[r6,#4]
0000ea  2804              CMP      r0,#4
0000ec  d003              BEQ      |L8.246|
0000ee  2803              CMP      r0,#3
0000f0  d104              BNE      |L8.252|
0000f2  7970              LDRB     r0,[r6,#5]
0000f4  b110              CBZ      r0,|L8.252|
                  |L8.246|
0000f6  f44f5080          MOV      r0,#0x1000
0000fa  e000              B        |L8.254|
                  |L8.252|
0000fc  2000              MOVS     r0,#0
                  |L8.254|
0000fe  f8ad0044          STRH     r0,[sp,#0x44]
;;;185      uart_init_structure.USART_StopBits   = ( config->stop_bits == STOP_BITS_1 ) ? USART_StopBits_1 : USART_StopBits_2;
000102  79b0              LDRB     r0,[r6,#6]
000104  b108              CBZ      r0,|L8.266|
000106  f44f5000          MOV      r0,#0x2000
                  |L8.266|
00010a  f8ad0046          STRH     r0,[sp,#0x46]
;;;186    
;;;187      switch ( config->parity )
00010e  7970              LDRB     r0,[r6,#5]
000110  b128              CBZ      r0,|L8.286|
000112  2801              CMP      r0,#1
000114  d009              BEQ      |L8.298|
000116  2802              CMP      r0,#2
000118  d113              BNE      |L8.322|
00011a  e003              B        |L8.292|
                  |L8.284|
00011c  e011              B        |L8.322|
                  |L8.286|
;;;188      {
;;;189        case NO_PARITY:
;;;190          uart_init_structure.USART_Parity = USART_Parity_No;
00011e  f8ada048          STRH     r10,[sp,#0x48]
;;;191          break;
000122  e006              B        |L8.306|
                  |L8.292|
;;;192    
;;;193        case EVEN_PARITY:
;;;194          uart_init_structure.USART_Parity = USART_Parity_Even;
000124  f44f6080          MOV      r0,#0x400
;;;195          break;
000128  e001              B        |L8.302|
                  |L8.298|
;;;196    
;;;197        case ODD_PARITY:
;;;198          uart_init_structure.USART_Parity = USART_Parity_Odd;
00012a  f44f60c0          MOV      r0,#0x600
                  |L8.302|
00012e  f8ad0048          STRH     r0,[sp,#0x48]         ;194
                  |L8.306|
;;;199          break;
;;;200    
;;;201        default:
;;;202          err = kParamErr;
;;;203          goto exit;
;;;204      }
;;;205    
;;;206      switch ( config->flow_control )
000132  79f0              LDRB     r0,[r6,#7]
000134  b138              CBZ      r0,|L8.326|
000136  2801              CMP      r0,#1
000138  d008              BEQ      |L8.332|
00013a  2802              CMP      r0,#2
00013c  d009              BEQ      |L8.338|
00013e  2803              CMP      r0,#3
000140  d01b              BEQ      |L8.378|
                  |L8.322|
;;;207      {
;;;208        case FLOW_CONTROL_DISABLED:
;;;209          uart_init_structure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
;;;210          break;
;;;211    
;;;212        case FLOW_CONTROL_CTS:
;;;213          uart_init_structure.USART_HardwareFlowControl = USART_HardwareFlowControl_CTS;
;;;214          break;
;;;215    
;;;216        case FLOW_CONTROL_RTS:
;;;217          uart_init_structure.USART_HardwareFlowControl = USART_HardwareFlowControl_RTS;
;;;218          break;
;;;219    
;;;220        case FLOW_CONTROL_CTS_RTS:
;;;221          uart_init_structure.USART_HardwareFlowControl = USART_HardwareFlowControl_RTS_CTS;
;;;222          break;
;;;223    
;;;224        default:
;;;225          err = kParamErr;
000142  46d9              MOV      r9,r11
;;;226          goto exit;
000144  e0a2              B        |L8.652|
                  |L8.326|
000146  f8ada04c          STRH     r10,[sp,#0x4c]        ;209
00014a  e006              B        |L8.346|
                  |L8.332|
00014c  f44f7000          MOV      r0,#0x200             ;213
000150  e001              B        |L8.342|
                  |L8.338|
000152  f44f7080          MOV      r0,#0x100             ;217
                  |L8.342|
000156  f8ad004c          STRH     r0,[sp,#0x4c]         ;213
                  |L8.346|
;;;227      }
;;;228    
;;;229    
;;;230      /* Initialise USART peripheral */
;;;231      USART_DeInit( peripheral->port );
00015a  6820              LDR      r0,[r4,#0]
00015c  f7fffffe          BL       USART_DeInit
;;;232      USART_Init( peripheral->port, &uart_init_structure );
000160  a910              ADD      r1,sp,#0x40
000162  6820              LDR      r0,[r4,#0]
000164  f7fffffe          BL       USART_Init
;;;233      
;;;234      /**************************************************************************
;;;235      * Initialise STM32 DMA registers
;;;236      * Note: If DMA is used, USART interrupt isn't enabled.
;;;237      **************************************************************************/
;;;238      /* Enable DMA peripheral clock */
;;;239      if ( peripheral->tx_dma_config.controller == DMA1 )
000168  4a4d              LDR      r2,|L8.672|
;;;240      {
;;;241          RCC->AHB1ENR |= RCC_AHB1Periph_DMA1;
00016a  484e              LDR      r0,|L8.676|
00016c  6961              LDR      r1,[r4,#0x14]         ;239
00016e  4291              CMP      r1,r2                 ;239
;;;242      }
;;;243      else
;;;244      {
;;;245          RCC->AHB1ENR |= RCC_AHB1Periph_DMA2;
000170  6801              LDR      r1,[r0,#0]
000172  d105              BNE      |L8.384|
000174  f4411100          ORR      r1,r1,#0x200000       ;241
000178  e004              B        |L8.388|
                  |L8.378|
00017a  f44f7040          MOV      r0,#0x300             ;221
00017e  e7ea              B        |L8.342|
                  |L8.384|
000180  f4410180          ORR      r1,r1,#0x400000
                  |L8.388|
000184  6001              STR      r1,[r0,#0]
;;;246      }
;;;247      
;;;248      /* Fill init structure with common DMA settings */
;;;249      dma_init_structure.DMA_PeripheralInc   = DMA_PeripheralInc_Disable;
;;;250      dma_init_structure.DMA_MemoryInc       = DMA_MemoryInc_Enable;
000186  f44f6180          MOV      r1,#0x400
00018a  e9cda106          STRD     r10,r1,[sp,#0x18]
;;;251      dma_init_structure.DMA_Priority        = DMA_Priority_VeryHigh;
00018e  f44f3140          MOV      r1,#0x30000
000192  e9cd1a0b          STRD     r1,r10,[sp,#0x2c]
;;;252      dma_init_structure.DMA_FIFOMode        = DMA_FIFOMode_Disable;
;;;253      dma_init_structure.DMA_FIFOThreshold   = DMA_FIFOThreshold_Full;
000196  2103              MOVS     r1,#3
000198  e9cd1a0d          STRD     r1,r10,[sp,#0x34]
;;;254      dma_init_structure.DMA_MemoryBurst     = DMA_MemoryBurst_Single;
;;;255      dma_init_structure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
;;;256    
;;;257      if ( config->data_width == DATA_WIDTH_9BIT )
00019c  f8cda03c          STR      r10,[sp,#0x3c]
0001a0  7930              LDRB     r0,[r6,#4]
0001a2  2804              CMP      r0,#4
0001a4  d05e              BEQ      |L8.612|
;;;258      {
;;;259        dma_init_structure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
;;;260        dma_init_structure.DMA_MemoryDataSize     = DMA_MemoryDataSize_HalfWord;
;;;261      }
;;;262      else
;;;263      {
;;;264        dma_init_structure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
0001a6  4650              MOV      r0,r10
0001a8  f8cda020          STR      r10,[sp,#0x20]
                  |L8.428|
;;;265        dma_init_structure.DMA_MemoryDataSize     = DMA_MemoryDataSize_Byte;
;;;266      }
;;;267    
;;;268      /* Initialise TX DMA */
;;;269      DMA_DeInit( peripheral->tx_dma_config.stream );
0001ac  9009              STR      r0,[sp,#0x24]
0001ae  69a0              LDR      r0,[r4,#0x18]
0001b0  f7fffffe          BL       DMA_DeInit
;;;270      dma_init_structure.DMA_Channel            = peripheral->tx_dma_config.channel;
0001b4  69e0              LDR      r0,[r4,#0x1c]
;;;271      dma_init_structure.DMA_PeripheralBaseAddr = (uint32_t) &peripheral->port->DR;
0001b6  9001              STR      r0,[sp,#4]
;;;272      dma_init_structure.DMA_Memory0BaseAddr    = (uint32_t) 0;
0001b8  6820              LDR      r0,[r4,#0]
0001ba  4656              MOV      r6,r10
0001bc  1d00              ADDS     r0,r0,#4
0001be  e9cd0a02          STRD     r0,r10,[sp,#8]
;;;273      dma_init_structure.DMA_DIR                = DMA_DIR_MemoryToPeripheral;
0001c2  2040              MOVS     r0,#0x40
;;;274      dma_init_structure.DMA_BufferSize         = 0xFFFF;                     // This parameter will be configured during communication
0001c4  f64f7aff          MOV      r10,#0xffff
;;;275      dma_init_structure.DMA_Mode               = DMA_Mode_Normal;
0001c8  960a              STR      r6,[sp,#0x28]
0001ca  e9cd0a04          STRD     r0,r10,[sp,#0x10]
;;;276      DMA_Init( peripheral->tx_dma_config.stream, &dma_init_structure );
0001ce  a901              ADD      r1,sp,#4
0001d0  69a0              LDR      r0,[r4,#0x18]
0001d2  f7fffffe          BL       DMA_Init
;;;277    
;;;278      /* Initialise RX DMA */
;;;279      DMA_DeInit( peripheral->rx_dma_config.stream );
0001d6  6b20              LDR      r0,[r4,#0x30]
0001d8  f7fffffe          BL       DMA_DeInit
;;;280      dma_init_structure.DMA_Channel            = peripheral->rx_dma_config.channel;
0001dc  6b60              LDR      r0,[r4,#0x34]
;;;281      dma_init_structure.DMA_PeripheralBaseAddr = (uint32_t) &peripheral->port->DR;
0001de  9001              STR      r0,[sp,#4]
0001e0  6820              LDR      r0,[r4,#0]
0001e2  e9cd6a04          STRD     r6,r10,[sp,#0x10]
0001e6  1d00              ADDS     r0,r0,#4
0001e8  e9cd0602          STRD     r0,r6,[sp,#8]
;;;282      dma_init_structure.DMA_Memory0BaseAddr    = (uint32_t) 0;
;;;283      dma_init_structure.DMA_DIR                = DMA_DIR_PeripheralToMemory;
;;;284      dma_init_structure.DMA_BufferSize         = 0xFFFF;                     // This parameter will be configured during communication
;;;285      dma_init_structure.DMA_Mode               = DMA_Mode_Normal;
;;;286      DMA_Init( peripheral->rx_dma_config.stream, &dma_init_structure );
0001ec  960a              STR      r6,[sp,#0x28]
0001ee  a901              ADD      r1,sp,#4
0001f0  6b20              LDR      r0,[r4,#0x30]
0001f2  f7fffffe          BL       DMA_Init
;;;287      
;;;288      /**************************************************************************
;;;289      * Initialise STM32 DMA interrupts
;;;290      **************************************************************************/
;;;291      
;;;292      /* Configure TX DMA interrupt on Cortex-M3 */
;;;293      NVIC_EnableIRQ( peripheral->tx_dma_config.irq_vector );
0001f6  f9940020          LDRSB    r0,[r4,#0x20]
0001fa  f7fffffe          BL       NVIC_EnableIRQ
0001fe  e9d41009          LDRD     r1,r0,[r4,#0x24]
;;;294    
;;;295      /* Enable TC (transfer complete) and TE (transfer error) interrupts on source */
;;;296      clear_dma_interrupts( peripheral->tx_dma_config.stream, peripheral->tx_dma_config.complete_flags | peripheral->tx_dma_config.error_flags );
000202  4301              ORRS     r1,r1,r0
000204  69a0              LDR      r0,[r4,#0x18]
000206  f7fffffe          BL       clear_dma_interrupts
;;;297      DMA_ITConfig( peripheral->tx_dma_config.stream, DMA_INTERRUPT_FLAGS, ENABLE );
00020a  2201              MOVS     r2,#1
00020c  2196              MOVS     r1,#0x96
00020e  69a0              LDR      r0,[r4,#0x18]
000210  f7fffffe          BL       DMA_ITConfig
;;;298    
;;;299      /* Enable USART interrupt vector in Cortex-M3 */
;;;300      NVIC_EnableIRQ( uart_irq_vectors[uart_number] );
000214  4821              LDR      r0,|L8.668|
000216  1d80              ADDS     r0,r0,#6
000218  57c0              LDRSB    r0,[r0,r7]
00021a  f7fffffe          BL       NVIC_EnableIRQ
;;;301      USART_DMACmd( driver->peripheral->port, USART_DMAReq_Tx, DISABLE );
00021e  6828              LDR      r0,[r5,#0]
000220  2200              MOVS     r2,#0
000222  2180              MOVS     r1,#0x80
000224  6800              LDR      r0,[r0,#0]
000226  f7fffffe          BL       USART_DMACmd
;;;302    
;;;303      /* Enable USART */
;;;304      USART_Cmd( peripheral->port, ENABLE );
00022a  2101              MOVS     r1,#1
00022c  6820              LDR      r0,[r4,#0]
00022e  f7fffffe          BL       USART_Cmd
;;;305    
;;;306      /* Enable both transmit and receive */
;;;307      peripheral->port->CR1 |= USART_CR1_TE;
000232  6820              LDR      r0,[r4,#0]
000234  8981              LDRH     r1,[r0,#0xc]
000236  f0410108          ORR      r1,r1,#8
00023a  8181              STRH     r1,[r0,#0xc]
;;;308      peripheral->port->CR1 |= USART_CR1_RE;
00023c  6820              LDR      r0,[r4,#0]
00023e  8981              LDRH     r1,[r0,#0xc]
000240  f0410104          ORR      r1,r1,#4
000244  8181              STRH     r1,[r0,#0xc]
;;;309    
;;;310      /* Setup ring buffer */
;;;311      if ( optional_ring_buffer != NULL )
000246  f1b80f00          CMP      r8,#0
00024a  d010              BEQ      |L8.622|
;;;312      {
;;;313        /* Note that the ring_buffer should've been initialised first */
;;;314        driver->rx_buffer = optional_ring_buffer;
;;;315        driver->rx_size   = 0;
00024c  f8c58004          STR      r8,[r5,#4]
000250  612e              STR      r6,[r5,#0x10]
;;;316        receive_bytes( driver, optional_ring_buffer->buffer, optional_ring_buffer->size, 0 );
000252  2300              MOVS     r3,#0
000254  4628              MOV      r0,r5
000256  f8d82000          LDR      r2,[r8,#0]
00025a  f8d8100c          LDR      r1,[r8,#0xc]
00025e  f7fffffe          BL       receive_bytes
000262  e013              B        |L8.652|
                  |L8.612|
000264  f44f6000          MOV      r0,#0x800             ;259
000268  9008              STR      r0,[sp,#0x20]         ;260
00026a  0080              LSLS     r0,r0,#2              ;260
00026c  e79e              B        |L8.428|
                  |L8.622|
;;;317      }
;;;318      else
;;;319      {
;;;320        /* Not using ring buffer. Configure RX DMA interrupt on Cortex-M3 */
;;;321        NVIC_EnableIRQ( peripheral->rx_dma_config.irq_vector );
00026e  f9940038          LDRSB    r0,[r4,#0x38]
000272  f7fffffe          BL       NVIC_EnableIRQ
000276  e9d4100f          LDRD     r1,r0,[r4,#0x3c]
;;;322    
;;;323        /* Enable TC (transfer complete) and TE (transfer error) interrupts on source */
;;;324        clear_dma_interrupts( peripheral->rx_dma_config.stream, peripheral->rx_dma_config.complete_flags | peripheral->rx_dma_config.error_flags );
00027a  4301              ORRS     r1,r1,r0
00027c  6b20              LDR      r0,[r4,#0x30]
00027e  f7fffffe          BL       clear_dma_interrupts
;;;325        DMA_ITConfig( peripheral->rx_dma_config.stream, DMA_INTERRUPT_FLAGS, ENABLE );
000282  2201              MOVS     r2,#1
000284  2196              MOVS     r1,#0x96
000286  6b20              LDR      r0,[r4,#0x30]
000288  f7fffffe          BL       DMA_ITConfig
                  |L8.652|
;;;326      }
;;;327    
;;;328    exit:
;;;329      platform_mcu_powersave_enable();
00028c  f7fffffe          BL       platform_mcu_powersave_enable
;;;330      return err;
;;;331    }
000290  b015              ADD      sp,sp,#0x54
000292  4648              MOV      r0,r9                 ;330
000294  e8bd8ff0          POP      {r4-r11,pc}
;;;332    
                          ENDP

                  |L8.664|
                          DCD      0xffffe5cf
                  |L8.668|
                          DCD      ||.constdata||
                  |L8.672|
                          DCD      0x40026000
                  |L8.676|
                          DCD      0x40023830

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

                  platform_uart_irq PROC
;;;682    
;;;683    void platform_uart_irq( platform_uart_driver_t* driver )
000000  b510              PUSH     {r4,lr}
;;;684    {
000002  4604              MOV      r4,r0
;;;685      platform_uart_port_t* uart = (platform_uart_port_t*) driver->peripheral->port;
000004  6800              LDR      r0,[r0,#0]
000006  6800              LDR      r0,[r0,#0]
;;;686    
;;;687      // Clear all interrupts. It's safe to do so because only RXNE interrupt is enabled
;;;688      uart->SR = (uint16_t) ( uart->SR | 0xffff );
000008  8801              LDRH     r1,[r0,#0]
00000a  f64f72ff          MOV      r2,#0xffff
00000e  4311              ORRS     r1,r1,r2
000010  8001              STRH     r1,[r0,#0]
;;;689    
;;;690      // Update tail
;;;691      driver->rx_buffer->tail = driver->rx_buffer->size - driver->peripheral->rx_dma_config.stream->NDTR;
000012  6822              LDR      r2,[r4,#0]
000014  6860              LDR      r0,[r4,#4]
000016  6b12              LDR      r2,[r2,#0x30]
000018  6801              LDR      r1,[r0,#0]
00001a  6852              LDR      r2,[r2,#4]
00001c  1a89              SUBS     r1,r1,r2
;;;692    
;;;693      // Notify thread if sufficient data are available
;;;694      if ( ( driver->rx_size > 0 ) && ( ring_buffer_used_space( driver->rx_buffer ) >= driver->rx_size ) )
00001e  6081              STR      r1,[r0,#8]
000020  6920              LDR      r0,[r4,#0x10]
000022  2800              CMP      r0,#0                 ;684
000024  d009              BEQ      |L9.58|
000026  6860              LDR      r0,[r4,#4]
000028  f7fffffe          BL       ring_buffer_used_space
00002c  6921              LDR      r1,[r4,#0x10]
00002e  4288              CMP      r0,r1
000030  d303              BCC      |L9.58|
;;;695      {
;;;696          #ifndef NO_MICO_RTOS
;;;697          mico_rtos_set_semaphore( &driver->rx_complete );
;;;698          #else
;;;699          driver->rx_complete = true;
000032  2001              MOVS     r0,#1
000034  7220              STRB     r0,[r4,#8]
;;;700          #endif
;;;701          driver->rx_size = 0;
000036  2000              MOVS     r0,#0
000038  6120              STR      r0,[r4,#0x10]
                  |L9.58|
;;;702      }
;;;703    #ifndef NO_MICO_RTOS
;;;704      if( driver->sem_wakeup )
;;;705        mico_rtos_set_semaphore( &driver->sem_wakeup );
;;;706    #endif
;;;707    }
00003a  bd10              POP      {r4,pc}
;;;708    
                          ENDP


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

                  platform_uart_receive_bytes PROC
;;;445    
;;;446    OSStatus platform_uart_receive_bytes( platform_uart_driver_t* driver, uint8_t* data_in, uint32_t expected_data_size, uint32_t timeout_ms )
000000  e92d47fc          PUSH     {r2-r10,lr}
;;;447    {
000004  0004              MOVS     r4,r0
000006  4698              MOV      r8,r3
000008  4616              MOV      r6,r2
00000a  460f              MOV      r7,r1
00000c  d00c              BEQ      |L10.40|
;;;448      OSStatus err = kNoErr;
;;;449    
;;;450      //platform_mcu_powersave_disable();
;;;451    
;;;452      require_action_quiet( ( driver != NULL ) && ( data_in != NULL ) && ( expected_data_size != 0 ), exit, err = kParamErr);
00000e  b15f              CBZ      r7,|L10.40|
000010  b156              CBZ      r6,|L10.40|
;;;453    
;;;454      if ( driver->rx_buffer != NULL)
000012  6860              LDR      r0,[r4,#4]
000014  b3f0              CBZ      r0,|L10.148|
000016  f04f0a00          MOV      r10,#0
                  |L10.26|
;;;455      {
;;;456        while ( expected_data_size != 0 )
;;;457        {
;;;458          uint32_t transfer_size = MIN( driver->rx_buffer->size / 2, expected_data_size );
00001a  6860              LDR      r0,[r4,#4]
00001c  6801              LDR      r1,[r0,#0]
00001e  ebb60f51          CMP      r6,r1,LSR #1
000022  d903              BLS      |L10.44|
000024  084d              LSRS     r5,r1,#1
000026  e002              B        |L10.46|
                  |L10.40|
000028  4823              LDR      r0,|L10.184|
00002a  e019              B        |L10.96|
                  |L10.44|
00002c  4635              MOV      r5,r6
                  |L10.46|
;;;459          
;;;460          /* Check if ring buffer already contains the required amount of data. */
;;;461          if ( transfer_size > ring_buffer_used_space( driver->rx_buffer ) )
00002e  f7fffffe          BL       ring_buffer_used_space
000032  42a8              CMP      r0,r5
000034  d21b              BCS      |L10.110|
;;;462          {
;;;463            /* Set rx_size and wait in rx_complete semaphore until data reaches rx_size or timeout occurs */
;;;464            driver->last_receive_result = kNoErr;
000036  f8c4a014          STR      r10,[r4,#0x14]
;;;465            driver->rx_size             = transfer_size;
00003a  6125              STR      r5,[r4,#0x10]
;;;466            
;;;467    #ifndef NO_MICO_RTOS
;;;468            err = mico_rtos_get_semaphore( &driver->rx_complete, timeout_ms );
;;;469    
;;;470            /* Reset rx_size to prevent semaphore being set while nothing waits for the data */
;;;471            driver->rx_size = 0;
;;;472    
;;;473            if( err != kNoErr )
;;;474              goto exit;
;;;475    #else
;;;476            driver->rx_complete = false;
00003c  f884a008          STRB     r10,[r4,#8]
;;;477            int delay_start = mico_get_time_no_os();
000040  f7fffffe          BL       mico_get_time_no_os
;;;478            while(driver->rx_complete == false){
;;;479              if(mico_get_time_no_os() >= delay_start + timeout_ms && timeout_ms != MICO_NEVER_TIMEOUT){
000044  eb000908          ADD      r9,r0,r8
000048  e00c              B        |L10.100|
                  |L10.74|
00004a  f7fffffe          BL       mico_get_time_no_os
00004e  4548              CMP      r0,r9
000050  d308              BCC      |L10.100|
000052  f1b83fff          CMP      r8,#0xffffffff
000056  d005              BEQ      |L10.100|
;;;480                driver->rx_size = 0;
000058  f8c4a010          STR      r10,[r4,#0x10]
;;;481                err = kTimeoutErr;
00005c  4816              LDR      r0,|L10.184|
00005e  3811              SUBS     r0,r0,#0x11
                  |L10.96|
;;;482                goto exit;
;;;483              }
;;;484            }
;;;485            driver->rx_size = 0;
;;;486    #endif
;;;487          }
;;;488          err = driver->last_receive_result;
;;;489          expected_data_size -= transfer_size;
;;;490          
;;;491          // Grab data from the buffer
;;;492          do
;;;493          {
;;;494            uint8_t* available_data;
;;;495            uint32_t bytes_available;
;;;496            
;;;497            ring_buffer_get_data( driver->rx_buffer, &available_data, &bytes_available );
;;;498            bytes_available = MIN( bytes_available, transfer_size );
;;;499            memcpy( data_in, available_data, bytes_available );
;;;500            transfer_size -= bytes_available;
;;;501            data_in = ( (uint8_t*) data_in + bytes_available );
;;;502            ring_buffer_consume( driver->rx_buffer, bytes_available );
;;;503          } while ( transfer_size != 0 );
;;;504        }
;;;505      }
;;;506      else
;;;507      {
;;;508        err = receive_bytes( driver, data_in, expected_data_size, timeout_ms );
000060  4681              MOV      r9,r0
000062  e021              B        |L10.168|
                  |L10.100|
000064  7a20              LDRB     r0,[r4,#8]            ;478
000066  2800              CMP      r0,#0                 ;478
000068  d0ef              BEQ      |L10.74|
00006a  f8c4a010          STR      r10,[r4,#0x10]        ;485
                  |L10.110|
00006e  f8d49014          LDR      r9,[r4,#0x14]         ;488
000072  1b76              SUBS     r6,r6,r5              ;489
                  |L10.116|
000074  466a              MOV      r2,sp                 ;497
000076  a901              ADD      r1,sp,#4              ;497
000078  6860              LDR      r0,[r4,#4]            ;497
00007a  f7fffffe          BL       ring_buffer_get_data
00007e  9a00              LDR      r2,[sp,#0]            ;498
000080  42aa              CMP      r2,r5                 ;498
000082  d300              BCC      |L10.134|
000084  462a              MOV      r2,r5                 ;498
                  |L10.134|
000086  9200              STR      r2,[sp,#0]            ;499
000088  4638              MOV      r0,r7                 ;499
00008a  9901              LDR      r1,[sp,#4]            ;499
00008c  f7fffffe          BL       __aeabi_memcpy
000090  9900              LDR      r1,[sp,#0]            ;500
000092  e000              B        |L10.150|
                  |L10.148|
000094  e00b              B        |L10.174|
                  |L10.150|
000096  1a6d              SUBS     r5,r5,r1              ;500
000098  440f              ADD      r7,r7,r1              ;501
00009a  6860              LDR      r0,[r4,#4]            ;502
00009c  f7fffffe          BL       ring_buffer_consume
0000a0  2d00              CMP      r5,#0                 ;503
0000a2  d1e7              BNE      |L10.116|
0000a4  2e00              CMP      r6,#0                 ;456
0000a6  d1b8              BNE      |L10.26|
                  |L10.168|
;;;509      }
;;;510    exit:
;;;511      //platform_mcu_powersave_enable();
;;;512      return err;
0000a8  4648              MOV      r0,r9
;;;513    }
0000aa  e8bd87fc          POP      {r2-r10,pc}
                  |L10.174|
0000ae  4620              MOV      r0,r4                 ;508
0000b0  f7fffffe          BL       receive_bytes
0000b4  e7d4              B        |L10.96|
;;;514    
                          ENDP

0000b6  0000              DCW      0x0000
                  |L10.184|
                          DCD      0xffffe5cf

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

                  platform_uart_rx_dma_irq PROC
;;;733    
;;;734    void platform_uart_rx_dma_irq( platform_uart_driver_t* driver )
000000  b510              PUSH     {r4,lr}
;;;735    {
000002  4604              MOV      r4,r0
;;;736        if ( ( get_dma_irq_status( driver->peripheral->rx_dma_config.stream ) & driver->peripheral->rx_dma_config.complete_flags ) != 0 )
000004  6800              LDR      r0,[r0,#0]
000006  6b00              LDR      r0,[r0,#0x30]
000008  f7fffffe          BL       get_dma_irq_status
00000c  4602              MOV      r2,r0
00000e  6820              LDR      r0,[r4,#0]
000010  6bc1              LDR      r1,[r0,#0x3c]
000012  420a              TST      r2,r1
000014  d004              BEQ      |L11.32|
;;;737        {
;;;738            clear_dma_interrupts( driver->peripheral->rx_dma_config.stream, driver->peripheral->rx_dma_config.complete_flags );
000016  6b00              LDR      r0,[r0,#0x30]
000018  f7fffffe          BL       clear_dma_interrupts
;;;739            driver->last_receive_result = kNoErr;
00001c  2000              MOVS     r0,#0
00001e  6160              STR      r0,[r4,#0x14]
                  |L11.32|
;;;740        }
;;;741    
;;;742        if ( ( get_dma_irq_status( driver->peripheral->rx_dma_config.stream ) & driver->peripheral->rx_dma_config.error_flags ) != 0 )
000020  6820              LDR      r0,[r4,#0]
000022  6b00              LDR      r0,[r0,#0x30]
000024  f7fffffe          BL       get_dma_irq_status
000028  4602              MOV      r2,r0
00002a  6820              LDR      r0,[r4,#0]
00002c  6c01              LDR      r1,[r0,#0x40]
00002e  420a              TST      r2,r1
000030  d005              BEQ      |L11.62|
;;;743        {
;;;744            clear_dma_interrupts( driver->peripheral->rx_dma_config.stream, driver->peripheral->rx_dma_config.error_flags );
000032  6b00              LDR      r0,[r0,#0x30]
000034  f7fffffe          BL       clear_dma_interrupts
;;;745            driver->last_receive_result = kGeneralErr;
000038  f04f30ff          MOV      r0,#0xffffffff
00003c  6160              STR      r0,[r4,#0x14]
                  |L11.62|
;;;746        }
;;;747    
;;;748        if ( driver->rx_size > 0 )
00003e  6920              LDR      r0,[r4,#0x10]
000040  2800              CMP      r0,#0
000042  d001              BEQ      |L11.72|
;;;749        {
;;;750            /* Set semaphore regardless of result to prevent waiting thread from locking up */
;;;751            #ifndef NO_MICO_RTOS
;;;752            mico_rtos_set_semaphore( &driver->rx_complete );
;;;753            #else
;;;754            driver->rx_complete = true;
000044  2001              MOVS     r0,#1
000046  7220              STRB     r0,[r4,#8]
                  |L11.72|
;;;755            #endif
;;;756        }
;;;757    }
000048  bd10              POP      {r4,pc}
;;;758    
                          ENDP


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

                  platform_uart_transmit_bytes PROC
;;;394    
;;;395    OSStatus platform_uart_transmit_bytes( platform_uart_driver_t* driver, const uint8_t* data_out, uint32_t size )
000000  b570              PUSH     {r4-r6,lr}
;;;396    {
000002  4615              MOV      r5,r2
000004  460e              MOV      r6,r1
000006  4604              MOV      r4,r0
;;;397      OSStatus err = kNoErr;
;;;398    
;;;399      platform_mcu_powersave_disable();
000008  f7fffffe          BL       platform_mcu_powersave_disable
;;;400      
;;;401    #ifndef NO_MICO_RTOS
;;;402      mico_rtos_lock_mutex( &driver->tx_mutex );
;;;403    #endif
;;;404    
;;;405      require_action_quiet( ( driver != NULL ) && ( data_out != NULL ) && ( size != 0 ), exit, err = kParamErr);
00000c  b3ec              CBZ      r4,|L12.138|
00000e  b3e6              CBZ      r6,|L12.138|
000010  b3dd              CBZ      r5,|L12.138|
;;;406    
;;;407      /* Clear interrupt status before enabling DMA otherwise error occurs immediately */
;;;408      clear_dma_interrupts( driver->peripheral->tx_dma_config.stream, driver->peripheral->tx_dma_config.complete_flags | driver->peripheral->tx_dma_config.error_flags );
000012  6820              LDR      r0,[r4,#0]
000014  e9d01209          LDRD     r1,r2,[r0,#0x24]
000018  4311              ORRS     r1,r1,r2
00001a  6980              LDR      r0,[r0,#0x18]
00001c  f7fffffe          BL       clear_dma_interrupts
;;;409    
;;;410      /* Init DMA parameters and variables */
;;;411      driver->last_transmit_result                    = kGeneralErr;
000020  f04f30ff          MOV      r0,#0xffffffff
000024  61a0              STR      r0,[r4,#0x18]
;;;412      driver->tx_size                                 = size;
000026  60e5              STR      r5,[r4,#0xc]
;;;413      driver->peripheral->tx_dma_config.stream->CR   &= ~(uint32_t) DMA_SxCR_CIRC;
000028  6820              LDR      r0,[r4,#0]
00002a  6980              LDR      r0,[r0,#0x18]
00002c  6801              LDR      r1,[r0,#0]
00002e  f4217180          BIC      r1,r1,#0x100
000032  6001              STR      r1,[r0,#0]
;;;414      driver->peripheral->tx_dma_config.stream->NDTR  = size;
000034  6820              LDR      r0,[r4,#0]
000036  6980              LDR      r0,[r0,#0x18]
000038  6045              STR      r5,[r0,#4]
;;;415      driver->peripheral->tx_dma_config.stream->M0AR  = (uint32_t)data_out;
00003a  6820              LDR      r0,[r4,#0]
00003c  6980              LDR      r0,[r0,#0x18]
00003e  60c6              STR      r6,[r0,#0xc]
;;;416      
;;;417      USART_DMACmd( driver->peripheral->port, USART_DMAReq_Tx, ENABLE );
000040  6820              LDR      r0,[r4,#0]
000042  2201              MOVS     r2,#1
000044  2180              MOVS     r1,#0x80
000046  6800              LDR      r0,[r0,#0]
000048  f7fffffe          BL       USART_DMACmd
;;;418      USART_ClearFlag( driver->peripheral->port, USART_FLAG_TC );
00004c  6820              LDR      r0,[r4,#0]
00004e  2140              MOVS     r1,#0x40
000050  6800              LDR      r0,[r0,#0]
000052  f7fffffe          BL       USART_ClearFlag
;;;419      driver->peripheral->tx_dma_config.stream->CR   |= DMA_SxCR_EN;
000056  6820              LDR      r0,[r4,#0]
000058  6980              LDR      r0,[r0,#0x18]
00005a  6801              LDR      r1,[r0,#0]
00005c  f0410101          ORR      r1,r1,#1
000060  6001              STR      r1,[r0,#0]
                  |L12.98|
;;;420      
;;;421    /* Wait for transmission complete */
;;;422    #ifndef NO_MICO_RTOS
;;;423      mico_rtos_get_semaphore( &driver->tx_complete, MICO_NEVER_TIMEOUT );
;;;424    #else 
;;;425      while( driver->tx_complete == false );
000062  7a60              LDRB     r0,[r4,#9]
000064  2800              CMP      r0,#0
000066  d0fc              BEQ      |L12.98|
;;;426      driver->tx_complete = false;
000068  2500              MOVS     r5,#0
00006a  7265              STRB     r5,[r4,#9]
00006c  6820              LDR      r0,[r4,#0]            ;417
00006e  6800              LDR      r0,[r0,#0]            ;417
                  |L12.112|
;;;427    #endif
;;;428    
;;;429      while ( ( driver->peripheral->port->SR & USART_SR_TC ) == 0 )
000070  8801              LDRH     r1,[r0,#0]
000072  0649              LSLS     r1,r1,#25
000074  d5fc              BPL      |L12.112|
;;;430      {
;;;431      }
;;;432    
;;;433      /* Disable DMA and clean up */
;;;434      USART_DMACmd( driver->peripheral->port, USART_DMAReq_Tx, DISABLE );
000076  2200              MOVS     r2,#0
000078  2180              MOVS     r1,#0x80
00007a  f7fffffe          BL       USART_DMACmd
;;;435      driver->tx_size = 0;
00007e  60e5              STR      r5,[r4,#0xc]
;;;436      err = driver->last_transmit_result;
000080  69a4              LDR      r4,[r4,#0x18]
                  |L12.130|
;;;437    
;;;438    exit:  
;;;439    #ifndef NO_MICO_RTOS  
;;;440      mico_rtos_unlock_mutex( &driver->tx_mutex );
;;;441    #endif
;;;442      platform_mcu_powersave_enable();
000082  f7fffffe          BL       platform_mcu_powersave_enable
;;;443      return err;
000086  4620              MOV      r0,r4
;;;444    }
000088  bd70              POP      {r4-r6,pc}
                  |L12.138|
00008a  e7ff              B        |L12.140|
                  |L12.140|
00008c  4c00              LDR      r4,|L12.144|
00008e  e7f8              B        |L12.130|
;;;445    
                          ENDP

                  |L12.144|
                          DCD      0xffffe5cf

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

                  platform_uart_tx_dma_irq PROC
;;;708    
;;;709    void platform_uart_tx_dma_irq( platform_uart_driver_t* driver )
000000  b510              PUSH     {r4,lr}
;;;710    {
000002  4604              MOV      r4,r0
;;;711        if ( ( get_dma_irq_status( driver->peripheral->tx_dma_config.stream ) & driver->peripheral->tx_dma_config.complete_flags ) != 0 )
000004  6800              LDR      r0,[r0,#0]
000006  6980              LDR      r0,[r0,#0x18]
000008  f7fffffe          BL       get_dma_irq_status
00000c  4602              MOV      r2,r0
00000e  6820              LDR      r0,[r4,#0]
000010  6a41              LDR      r1,[r0,#0x24]
000012  420a              TST      r2,r1
000014  d004              BEQ      |L13.32|
;;;712        {
;;;713            clear_dma_interrupts( driver->peripheral->tx_dma_config.stream, driver->peripheral->tx_dma_config.complete_flags );
000016  6980              LDR      r0,[r0,#0x18]
000018  f7fffffe          BL       clear_dma_interrupts
;;;714            driver->last_transmit_result = kNoErr;
00001c  2000              MOVS     r0,#0
00001e  61a0              STR      r0,[r4,#0x18]
                  |L13.32|
;;;715        }
;;;716    
;;;717        if ( ( get_dma_irq_status( driver->peripheral->tx_dma_config.stream ) & driver->peripheral->tx_dma_config.error_flags ) != 0 )
000020  6820              LDR      r0,[r4,#0]
000022  6980              LDR      r0,[r0,#0x18]
000024  f7fffffe          BL       get_dma_irq_status
000028  4602              MOV      r2,r0
00002a  6820              LDR      r0,[r4,#0]
00002c  6a81              LDR      r1,[r0,#0x28]
00002e  420a              TST      r2,r1
000030  d005              BEQ      |L13.62|
;;;718        {
;;;719            clear_dma_interrupts( driver->peripheral->tx_dma_config.stream, driver->peripheral->tx_dma_config.error_flags );
000032  6980              LDR      r0,[r0,#0x18]
000034  f7fffffe          BL       clear_dma_interrupts
;;;720            driver->last_transmit_result = kGeneralErr;
000038  f04f30ff          MOV      r0,#0xffffffff
00003c  61a0              STR      r0,[r4,#0x18]
                  |L13.62|
;;;721        }
;;;722    
;;;723        if ( driver->tx_size > 0 )
00003e  68e0              LDR      r0,[r4,#0xc]
000040  2800              CMP      r0,#0
000042  d001              BEQ      |L13.72|
;;;724        {
;;;725            #ifndef NO_MICO_RTOS
;;;726            /* Set semaphore regardless of result to prevent waiting thread from locking up */
;;;727            mico_rtos_set_semaphore( &driver->tx_complete );
;;;728            #else
;;;729            driver->tx_complete = true;
000044  2001              MOVS     r0,#1
000046  7260              STRB     r0,[r4,#9]
                  |L13.72|
;;;730            #endif
;;;731        }
;;;732    }
000048  bd10              POP      {r4,pc}
;;;733    
                          ENDP


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

                  receive_bytes PROC
;;;514    
;;;515    static OSStatus receive_bytes( platform_uart_driver_t* driver, void* data, uint32_t size, uint32_t timeout )
000000  e92d47f0          PUSH     {r4-r10,lr}
;;;516    {
000004  4604              MOV      r4,r0
000006  4688              MOV      r8,r1
;;;517      OSStatus err = kNoErr;
000008  e9d40100          LDRD     r0,r1,[r4,#0]
00000c  461d              MOV      r5,r3                 ;516
00000e  4616              MOV      r6,r2                 ;516
000010  f04f0900          MOV      r9,#0
000014  b191              CBZ      r1,|L14.60|
;;;518    
;;;519      if ( driver->rx_buffer != NULL )
;;;520      {
;;;521        driver->peripheral->rx_dma_config.stream->CR |= DMA_SxCR_CIRC;
000016  6b00              LDR      r0,[r0,#0x30]
000018  6801              LDR      r1,[r0,#0]
00001a  f4417180          ORR      r1,r1,#0x100
00001e  6001              STR      r1,[r0,#0]
;;;522        
;;;523        // Enabled individual byte interrupts so progress can be updated
;;;524        USART_ClearITPendingBit( driver->peripheral->port, USART_IT_RXNE );
000020  6820              LDR      r0,[r4,#0]
000022  f2405725          MOV      r7,#0x525
000026  4639              MOV      r1,r7
000028  6800              LDR      r0,[r0,#0]
00002a  f7fffffe          BL       USART_ClearITPendingBit
;;;525        USART_ITConfig( driver->peripheral->port, USART_IT_RXNE, ENABLE );
00002e  6820              LDR      r0,[r4,#0]
000030  2201              MOVS     r2,#1
000032  4639              MOV      r1,r7
000034  6800              LDR      r0,[r0,#0]
000036  f7fffffe          BL       USART_ITConfig
00003a  e005              B        |L14.72|
                  |L14.60|
;;;526      }
;;;527      else
;;;528      {
;;;529        driver->rx_size = size;
00003c  6126              STR      r6,[r4,#0x10]
;;;530        driver->peripheral->rx_dma_config.stream->CR &= ~(uint32_t) DMA_SxCR_CIRC;
00003e  6b00              LDR      r0,[r0,#0x30]
000040  6801              LDR      r1,[r0,#0]
000042  f4217180          BIC      r1,r1,#0x100
000046  6001              STR      r1,[r0,#0]
                  |L14.72|
;;;531      }
;;;532      
;;;533      clear_dma_interrupts( driver->peripheral->rx_dma_config.stream, driver->peripheral->rx_dma_config.complete_flags | driver->peripheral->rx_dma_config.error_flags );
000048  6820              LDR      r0,[r4,#0]
00004a  e9d0120f          LDRD     r1,r2,[r0,#0x3c]
00004e  4311              ORRS     r1,r1,r2
000050  6b00              LDR      r0,[r0,#0x30]
000052  f7fffffe          BL       clear_dma_interrupts
;;;534    
;;;535      driver->peripheral->rx_dma_config.stream->NDTR  = size;
000056  6820              LDR      r0,[r4,#0]
000058  6b00              LDR      r0,[r0,#0x30]
00005a  6046              STR      r6,[r0,#4]
;;;536      driver->peripheral->rx_dma_config.stream->M0AR  = (uint32_t)data;
00005c  6821              LDR      r1,[r4,#0]
00005e  6b09              LDR      r1,[r1,#0x30]
000060  f8c1800c          STR      r8,[r1,#0xc]
;;;537      driver->peripheral->rx_dma_config.stream->CR   |= DMA_SxCR_EN;
000064  6820              LDR      r0,[r4,#0]
000066  6b00              LDR      r0,[r0,#0x30]
000068  6801              LDR      r1,[r0,#0]
00006a  f0410101          ORR      r1,r1,#1
00006e  6001              STR      r1,[r0,#0]
;;;538      USART_DMACmd( driver->peripheral->port, USART_DMAReq_Rx, ENABLE );
000070  6820              LDR      r0,[r4,#0]
000072  2201              MOVS     r2,#1
000074  2140              MOVS     r1,#0x40
000076  6800              LDR      r0,[r0,#0]
000078  f7fffffe          BL       USART_DMACmd
;;;539      
;;;540      if ( timeout > 0 )
00007c  b18d              CBZ      r5,|L14.162|
;;;541      {
;;;542    #ifndef NO_MICO_RTOS
;;;543        err = mico_rtos_get_semaphore( &driver->rx_complete, timeout );
;;;544    #else
;;;545        driver->rx_complete = false;
00007e  2000              MOVS     r0,#0
000080  7220              STRB     r0,[r4,#8]
;;;546        int delay_start = mico_get_time_no_os();
000082  f7fffffe          BL       mico_get_time_no_os
;;;547        while( driver->rx_complete == false ){
;;;548          if(mico_get_time_no_os() >= delay_start + timeout && timeout != MICO_NEVER_TIMEOUT){
000086  1946              ADDS     r6,r0,r5
000088  e008              B        |L14.156|
                  |L14.138|
00008a  f7fffffe          BL       mico_get_time_no_os
00008e  42b0              CMP      r0,r6
000090  d304              BCC      |L14.156|
000092  1c68              ADDS     r0,r5,#1
000094  d002              BEQ      |L14.156|
;;;549            return kTimeoutErr;
000096  4804              LDR      r0,|L14.168|
                  |L14.152|
;;;550          }
;;;551        }    
;;;552    #endif
;;;553      }
;;;554      return err;
;;;555    }
000098  e8bd87f0          POP      {r4-r10,pc}
                  |L14.156|
00009c  7a20              LDRB     r0,[r4,#8]            ;547
00009e  2800              CMP      r0,#0                 ;547
0000a0  d0f3              BEQ      |L14.138|
                  |L14.162|
0000a2  4648              MOV      r0,r9                 ;554
0000a4  e7f8              B        |L14.152|
;;;556    
                          ENDP

0000a6  0000              DCW      0x0000
                  |L14.168|
                          DCD      0xffffe5be

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

                  uart_alternate_functions
000000  07070708          DCB      0x07,0x07,0x07,0x08
000004  0808              DCB      0x08,0x08
                  uart_irq_vectors
000006  2526              DCB      0x25,0x26
000008  27343547          DCB      0x27,0x34,0x35,0x47
                  uart_peripheral_clock_functions
                          DCD      RCC_APB2PeriphClockCmd
                          DCD      RCC_APB1PeriphClockCmd
                          DCD      RCC_APB1PeriphClockCmd
                          DCD      RCC_APB1PeriphClockCmd
                          DCD      RCC_APB1PeriphClockCmd
                          DCD      RCC_APB2PeriphClockCmd
                  uart_peripheral_clocks
                          DCD      0x00000010
                          DCD      0x00020000
                          DCD      0x00040000
                          DCD      0x00080000
                          DCD      0x00100000
                          DCD      0x00000020

;*** Start embedded assembler ***

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

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

 revsh r0, r0
 bx lr
	ENDP

;*** End   embedded assembler ***
