; generated by Component: ARM Compiler 5.05 update 2 (build 169) Tool: ArmCC [4d0f38]
; commandline ArmCC [--c99 --list --split_sections --debug -c --asm --interleave -o..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\platform_uart.o --asm_dir=..\..\..\..\Build\demo\MICO-Fire_F429\list_RVMDK\ --list_dir=..\..\..\..\Build\demo\MICO-Fire_F429\list_RVMDK\ --depend=..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\platform_uart.d --cpu=Cortex-M4.fp --apcs=interwork -O0 --diag_suppress=9931,1,1293 -I..\..\..\..\Board\fire_F429 -I..\..\..\..\Demos\fire\ov2640 -I..\..\..\..\include -I..\..\..\..\libraries\utilities -I..\..\..\..\libraries\utilities\json_c -I..\..\..\..\MICO\core -I..\..\..\..\MICO\security -I..\..\..\..\MICO\system -I..\..\..\..\MICO\system\command_console -I..\..\..\..\Platform\include -I..\..\..\..\Platform\Cortex-M4 -I..\..\..\..\Platform\Cortex-M4\CMSIS -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries\STM32F4xx_StdPeriph_Driver\inc -I..\..\..\..\Platform\MCU\STM32F4xx\peripherals\Libraries -I..\..\..\..\Platform\MCU\STM32F4xx\wlan_bus_driver -I..\..\..\..\Platform\Drivers\spi_flash -I..\..\..\..\Platform\Drivers -I..\..\..\..\libraries\daemons\homekit_server -I..\..\..\..\libraries\daemons\http_server -I..\..\..\..\Platform\Drivers\malloc -I..\..\..\..\Platform\Drivers\SDRAM -I..\..\..\..\Platform\Drivers\ov5640 -IG:\GIT_OSC\STM32_develop\F429-V2\develop\6-WIFI\STM32-WiFi\3.wifi_ov5640\Projects\STM32F429\demo\RVMDK\RTE -IC:\Keil_v5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0\Drivers\CMSIS\Device\ST\STM32F4xx\Include -IC:\Keil_v5\ARM\CMSIS\Include -IC:\Keil_v5\ARM\PACK\Keil\STM32F4xx_DFP\2.5.0 -D__UVISION_VERSION=515 -DSTM32F429xx -DUSE_STDPERIPH_DRIVER -DDEBUG -DHSE_VALUE=25000000 -DOV5640 --omf_browse=..\..\..\..\build\demo\mico-fire_f429\obj_rvmdk\platform_uart.crf ..\..\..\..\Platform\MCU\STM32F4xx\peripherals\platform_uart.c]
                          THUMB

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

                  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  4a02              LDR      r2,|L1.20|
00000a  0943              LSRS     r3,r0,#5
00000c  f8421023          STR      r1,[r2,r3,LSL #2]
;;;1468   }
000010  4770              BX       lr
;;;1469   
                          ENDP

000012  0000              DCW      0x0000
                  |L1.20|
                          DCD      0xe000e180

                          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  0942              LSRS     r2,r0,#5
00000a  0092              LSLS     r2,r2,#2
00000c  f10222e0          ADD      r2,r2,#0xe000e000
000010  f8c21100          STR      r1,[r2,#0x100]
;;;1456   }
000014  4770              BX       lr
;;;1457   
                          ENDP


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

                  RX_PIN_WAKEUP_handler PROC
;;;652    #ifndef NO_MICO_RTOS
;;;653    void RX_PIN_WAKEUP_handler(void *arg)
000000  b570              PUSH     {r4-r6,lr}
;;;654    {
000002  4604              MOV      r4,r0
;;;655      (void)arg;
;;;656      platform_uart_driver_t* driver = arg;
000004  4625              MOV      r5,r4
;;;657      uint32_t uart_number;
;;;658      
;;;659      platform_gpio_enable_clock( driver->peripheral->pin_rx );
000006  6829              LDR      r1,[r5,#0]
000008  6888              LDR      r0,[r1,#8]
00000a  f7fffffe          BL       platform_gpio_enable_clock
;;;660    
;;;661      uart_number = platform_uart_get_port_number( driver->peripheral->port );
00000e  6829              LDR      r1,[r5,#0]
000010  6808              LDR      r0,[r1,#0]
000012  f7fffffe          BL       platform_uart_get_port_number
000016  4606              MOV      r6,r0
;;;662    
;;;663      uart_peripheral_clock_functions[ uart_number ]( uart_peripheral_clocks[ uart_number ], ENABLE );
000018  4912              LDR      r1,|L3.100|
00001a  f8510026          LDR      r0,[r1,r6,LSL #2]
00001e  4912              LDR      r1,|L3.104|
000020  f8512026          LDR      r2,[r1,r6,LSL #2]
000024  2101              MOVS     r1,#1
000026  4790              BLX      r2
;;;664    
;;;665      /* Enable DMA peripheral clock */
;;;666      if ( driver->peripheral->tx_dma_config.controller == DMA1 )
000028  6828              LDR      r0,[r5,#0]
00002a  6940              LDR      r0,[r0,#0x14]
00002c  490f              LDR      r1,|L3.108|
00002e  4288              CMP      r0,r1
000030  d106              BNE      |L3.64|
;;;667      {
;;;668          RCC->AHB1ENR |= RCC_AHB1Periph_DMA1;
000032  480f              LDR      r0,|L3.112|
000034  6800              LDR      r0,[r0,#0]
000036  f4401000          ORR      r0,r0,#0x200000
00003a  490d              LDR      r1,|L3.112|
00003c  6008              STR      r0,[r1,#0]
00003e  e005              B        |L3.76|
                  |L3.64|
;;;669      }
;;;670      else
;;;671      {
;;;672          RCC->AHB1ENR |= RCC_AHB1Periph_DMA2;
000040  480b              LDR      r0,|L3.112|
000042  6800              LDR      r0,[r0,#0]
000044  f4400080          ORR      r0,r0,#0x400000
000048  4909              LDR      r1,|L3.112|
00004a  6008              STR      r0,[r1,#0]
                  |L3.76|
;;;673      }
;;;674    
;;;675      platform_gpio_irq_disable( driver->peripheral->pin_rx );
00004c  6829              LDR      r1,[r5,#0]
00004e  6888              LDR      r0,[r1,#8]
000050  f7fffffe          BL       platform_gpio_irq_disable
;;;676      platform_mcu_powersave_disable( );
000054  f7fffffe          BL       platform_mcu_powersave_disable
;;;677      mico_rtos_set_semaphore( &driver->sem_wakeup );
000058  f1050014          ADD      r0,r5,#0x14
00005c  f7fffffe          BL       mico_rtos_set_semaphore
;;;678    
;;;679    }
000060  bd70              POP      {r4-r6,pc}
;;;680    #endif
                          ENDP

000062  0000              DCW      0x0000
                  |L3.100|
                          DCD      uart_peripheral_clocks
                  |L3.104|
                          DCD      uart_peripheral_clock_functions
                  |L3.108|
                          DCD      0x40026000
                  |L3.112|
                          DCD      0x40023830

                          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  4a14              LDR      r2,|L4.84|
;;;563    {
;;;564        if ( stream <= DMA1_Stream3 )
000002  4290              CMP      r0,r2
000004  d807              BHI      |L4.22|
;;;565        {
;;;566            DMA1->LIFCR |= flags;
000006  4a13              LDR      r2,|L4.84|
000008  3a58              SUBS     r2,r2,#0x58
00000a  6892              LDR      r2,[r2,#8]
00000c  430a              ORRS     r2,r2,r1
00000e  4b11              LDR      r3,|L4.84|
000010  3b58              SUBS     r3,r3,#0x58
000012  609a              STR      r2,[r3,#8]
000014  e01d              B        |L4.82|
                  |L4.22|
;;;567        }
;;;568        else if ( stream <= DMA1_Stream7 )
000016  4a0f              LDR      r2,|L4.84|
000018  3260              ADDS     r2,r2,#0x60
00001a  4290              CMP      r0,r2
00001c  d807              BHI      |L4.46|
;;;569        {
;;;570            DMA1->HIFCR |= flags;
00001e  4a0d              LDR      r2,|L4.84|
000020  3a58              SUBS     r2,r2,#0x58
000022  68d2              LDR      r2,[r2,#0xc]
000024  430a              ORRS     r2,r2,r1
000026  4b0b              LDR      r3,|L4.84|
000028  3b58              SUBS     r3,r3,#0x58
00002a  60da              STR      r2,[r3,#0xc]
00002c  e011              B        |L4.82|
                  |L4.46|
;;;571        }
;;;572        else if ( stream <= DMA2_Stream3 )
00002e  4a0a              LDR      r2,|L4.88|
000030  4290              CMP      r0,r2
000032  d807              BHI      |L4.68|
;;;573        {
;;;574            DMA2->LIFCR |= flags;
000034  4a08              LDR      r2,|L4.88|
000036  3a50              SUBS     r2,r2,#0x50
000038  6812              LDR      r2,[r2,#0]
00003a  430a              ORRS     r2,r2,r1
00003c  4b06              LDR      r3,|L4.88|
00003e  3b50              SUBS     r3,r3,#0x50
000040  601a              STR      r2,[r3,#0]
000042  e006              B        |L4.82|
                  |L4.68|
;;;575        }
;;;576        else
;;;577        {
;;;578            DMA2->HIFCR |= flags;
000044  4a04              LDR      r2,|L4.88|
000046  3a4c              SUBS     r2,r2,#0x4c
000048  6812              LDR      r2,[r2,#0]
00004a  430a              ORRS     r2,r2,r1
00004c  4b02              LDR      r3,|L4.88|
00004e  3b4c              SUBS     r3,r3,#0x4c
000050  601a              STR      r2,[r3,#0]
                  |L4.82|
;;;579        }
;;;580    }
000052  4770              BX       lr
;;;581    
                          ENDP

                  |L4.84|
                          DCD      0x40026058
                  |L4.88|
                          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  4601              MOV      r1,r0
;;;583    {
;;;584        if ( stream <= DMA1_Stream3 )
000002  480d              LDR      r0,|L5.56|
000004  4281              CMP      r1,r0
000006  d803              BHI      |L5.16|
;;;585        {
;;;586            return DMA1->LISR;
000008  480b              LDR      r0,|L5.56|
00000a  3858              SUBS     r0,r0,#0x58
00000c  6800              LDR      r0,[r0,#0]
                  |L5.14|
;;;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    }
00000e  4770              BX       lr
                  |L5.16|
000010  4809              LDR      r0,|L5.56|
000012  3060              ADDS     r0,r0,#0x60           ;588
000014  4281              CMP      r1,r0                 ;588
000016  d803              BHI      |L5.32|
000018  4807              LDR      r0,|L5.56|
00001a  3858              SUBS     r0,r0,#0x58           ;590
00001c  6840              LDR      r0,[r0,#4]            ;590
00001e  e7f6              B        |L5.14|
                  |L5.32|
000020  4806              LDR      r0,|L5.60|
000022  4281              CMP      r1,r0                 ;592
000024  d803              BHI      |L5.46|
000026  4805              LDR      r0,|L5.60|
000028  3858              SUBS     r0,r0,#0x58           ;594
00002a  6800              LDR      r0,[r0,#0]            ;594
00002c  e7ef              B        |L5.14|
                  |L5.46|
00002e  4803              LDR      r0,|L5.60|
000030  3854              SUBS     r0,r0,#0x54           ;598
000032  6800              LDR      r0,[r0,#0]            ;598
000034  e7eb              B        |L5.14|
;;;601    
                          ENDP

000036  0000              DCW      0x0000
                  |L5.56|
                          DCD      0x40026058
                  |L5.60|
                          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  bf00              NOP      
00000c  b90c              CBNZ     r4,|L6.18|
00000e  4e2a              LDR      r6,|L6.184|
000010  e04d              B        |L6.174|
                  |L6.18|
000012  bf00              NOP      
;;;341    
;;;342      uart_number = platform_uart_get_port_number( driver->peripheral->port );
000014  6821              LDR      r1,[r4,#0]
000016  6808              LDR      r0,[r1,#0]
000018  f7fffffe          BL       platform_uart_get_port_number
00001c  4605              MOV      r5,r0
;;;343    
;;;344      /* Disable USART */
;;;345      USART_Cmd( driver->peripheral->port, DISABLE );
00001e  6821              LDR      r1,[r4,#0]
000020  6808              LDR      r0,[r1,#0]
000022  2100              MOVS     r1,#0
000024  f7fffffe          BL       USART_Cmd
;;;346    
;;;347      /* Deinitialise USART */
;;;348      USART_DeInit( driver->peripheral->port );
000028  6821              LDR      r1,[r4,#0]
00002a  6808              LDR      r0,[r1,#0]
00002c  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 );
000030  6821              LDR      r1,[r4,#0]
000032  6988              LDR      r0,[r1,#0x18]
000034  f7fffffe          BL       DMA_DeInit
;;;356      DMA_DeInit( driver->peripheral->rx_dma_config.stream );
000038  6821              LDR      r1,[r4,#0]
00003a  6b08              LDR      r0,[r1,#0x30]
00003c  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 );
000040  6821              LDR      r1,[r4,#0]
000042  2200              MOVS     r2,#0
000044  6988              LDR      r0,[r1,#0x18]
000046  2196              MOVS     r1,#0x96
000048  f7fffffe          BL       DMA_ITConfig
;;;360      DMA_ITConfig( driver->peripheral->rx_dma_config.stream, DMA_INTERRUPT_FLAGS, DISABLE );
00004c  6821              LDR      r1,[r4,#0]
00004e  2200              MOVS     r2,#0
000050  6b08              LDR      r0,[r1,#0x30]
000052  2196              MOVS     r1,#0x96
000054  f7fffffe          BL       DMA_ITConfig
;;;361    
;;;362      /* Disable transmit DMA interrupt at Cortex-M3 */
;;;363      NVIC_DisableIRQ( driver->peripheral->tx_dma_config.irq_vector );
000058  6821              LDR      r1,[r4,#0]
00005a  f9910020          LDRSB    r0,[r1,#0x20]
00005e  f7fffffe          BL       NVIC_DisableIRQ
;;;364    
;;;365      /**************************************************************************
;;;366       * De-initialise STM32 USART interrupt
;;;367       **************************************************************************/
;;;368    
;;;369      USART_ITConfig( driver->peripheral->port, USART_IT_RXNE, DISABLE );
000062  6821              LDR      r1,[r4,#0]
000064  2200              MOVS     r2,#0
000066  6808              LDR      r0,[r1,#0]
000068  f2405125          MOV      r1,#0x525
00006c  f7fffffe          BL       USART_ITConfig
;;;370    
;;;371      /* Disable UART interrupt vector on Cortex-M3 */
;;;372      NVIC_DisableIRQ( driver->peripheral->rx_dma_config.irq_vector );
000070  6821              LDR      r1,[r4,#0]
000072  f9910038          LDRSB    r0,[r1,#0x38]
000076  f7fffffe          BL       NVIC_DisableIRQ
;;;373    
;;;374      /* Disable registers clocks */
;;;375      uart_peripheral_clock_functions[uart_number]( uart_peripheral_clocks[uart_number], DISABLE );
00007a  4910              LDR      r1,|L6.188|
00007c  f8510025          LDR      r0,[r1,r5,LSL #2]
000080  490f              LDR      r1,|L6.192|
000082  f8512025          LDR      r2,[r1,r5,LSL #2]
000086  2100              MOVS     r1,#0
000088  4790              BLX      r2
;;;376    
;;;377    #ifndef NO_MICO_RTOS
;;;378      mico_rtos_deinit_semaphore( &driver->rx_complete );
00008a  f1040008          ADD      r0,r4,#8
00008e  f7fffffe          BL       mico_rtos_deinit_semaphore
;;;379      mico_rtos_deinit_semaphore( &driver->tx_complete );
000092  f104000c          ADD      r0,r4,#0xc
000096  f7fffffe          BL       mico_rtos_deinit_semaphore
;;;380      mico_rtos_deinit_mutex( &driver->tx_mutex );
00009a  f1040010          ADD      r0,r4,#0x10
00009e  f7fffffe          BL       mico_rtos_deinit_mutex
;;;381    #else
;;;382      driver->rx_complete = false;
;;;383      driver->tx_complete = false;
;;;384    #endif
;;;385      driver->rx_size              = 0;
0000a2  2000              MOVS     r0,#0
0000a4  61e0              STR      r0,[r4,#0x1c]
;;;386      driver->tx_size              = 0;
0000a6  61a0              STR      r0,[r4,#0x18]
;;;387      driver->last_transmit_result = kNoErr;
0000a8  6260              STR      r0,[r4,#0x24]
;;;388      driver->last_receive_result  = kNoErr;
0000aa  6220              STR      r0,[r4,#0x20]
;;;389    
;;;390    exit:
0000ac  bf00              NOP      
                  |L6.174|
;;;391        platform_mcu_powersave_enable();
0000ae  f7fffffe          BL       platform_mcu_powersave_enable
;;;392        return err;
0000b2  4630              MOV      r0,r6
;;;393    }
0000b4  bd70              POP      {r4-r6,pc}
;;;394    
                          ENDP

0000b6  0000              DCW      0x0000
                  |L6.184|
                          DCD      0xffffe5cf
                  |L6.188|
                          DCD      uart_peripheral_clocks
                  |L6.192|
                          DCD      uart_peripheral_clock_functions

                          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  b510              PUSH     {r4,lr}
;;;558    {  
000002  4604              MOV      r4,r0
;;;559      return ring_buffer_used_space( driver->rx_buffer );
000004  6860              LDR      r0,[r4,#4]
000006  f7fffffe          BL       ring_buffer_used_space
;;;560    }
00000a  bd10              POP      {r4,pc}
;;;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  4601              MOV      r1,r0
;;;603    {
;;;604        if ( uart == USART1 )
000002  4810              LDR      r0,|L8.68|
000004  4281              CMP      r1,r0
000006  d101              BNE      |L8.12|
;;;605        {
;;;606            return 0;
000008  2000              MOVS     r0,#0
                  |L8.10|
;;;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    }
00000a  4770              BX       lr
                  |L8.12|
00000c  480e              LDR      r0,|L8.72|
00000e  4281              CMP      r1,r0                 ;608
000010  d101              BNE      |L8.22|
000012  2001              MOVS     r0,#1                 ;610
000014  e7f9              B        |L8.10|
                  |L8.22|
000016  480d              LDR      r0,|L8.76|
000018  4281              CMP      r1,r0                 ;612
00001a  d101              BNE      |L8.32|
00001c  2002              MOVS     r0,#2                 ;614
00001e  e7f4              B        |L8.10|
                  |L8.32|
000020  480b              LDR      r0,|L8.80|
000022  4281              CMP      r1,r0                 ;616
000024  d101              BNE      |L8.42|
000026  2003              MOVS     r0,#3                 ;618
000028  e7ef              B        |L8.10|
                  |L8.42|
00002a  480a              LDR      r0,|L8.84|
00002c  4281              CMP      r1,r0                 ;620
00002e  d101              BNE      |L8.52|
000030  2004              MOVS     r0,#4                 ;622
000032  e7ea              B        |L8.10|
                  |L8.52|
000034  4808              LDR      r0,|L8.88|
000036  4281              CMP      r1,r0                 ;624
000038  d101              BNE      |L8.62|
00003a  2005              MOVS     r0,#5                 ;626
00003c  e7e5              B        |L8.10|
                  |L8.62|
00003e  20ff              MOVS     r0,#0xff              ;630
000040  e7e3              B        |L8.10|
;;;633    
                          ENDP

000042  0000              DCW      0x0000
                  |L8.68|
                          DCD      0x40011000
                  |L8.72|
                          DCD      0x40004400
                  |L8.76|
                          DCD      0x40004800
                  |L8.80|
                          DCD      0x40004c00
                  |L8.84|
                          DCD      0x40005000
                  |L8.88|
                          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  e92d43f0          PUSH     {r4-r9,lr}
;;;130    {
000004  b095              SUB      sp,sp,#0x54
000006  4605              MOV      r5,r0
000008  460c              MOV      r4,r1
00000a  4616              MOV      r6,r2
00000c  461f              MOV      r7,r3
;;;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  bf00              NOP      
000018  b10d              CBZ      r5,|L9.30|
00001a  b104              CBZ      r4,|L9.30|
00001c  b916              CBNZ     r6,|L9.36|
                  |L9.30|
00001e  f8df92f8          LDR      r9,|L9.792|
000022  e173              B        |L9.780|
                  |L9.36|
000024  bf00              NOP      
;;;139      require_action_quiet( (optional_ring_buffer == NULL) || ((optional_ring_buffer->buffer != NULL ) && (optional_ring_buffer->size != 0)), exit, err = kParamErr);
000026  bf00              NOP      
000028  b137              CBZ      r7,|L9.56|
00002a  68f8              LDR      r0,[r7,#0xc]
00002c  b108              CBZ      r0,|L9.50|
00002e  6838              LDR      r0,[r7,#0]
000030  b910              CBNZ     r0,|L9.56|
                  |L9.50|
000032  f8df92e4          LDR      r9,|L9.792|
000036  e169              B        |L9.780|
                  |L9.56|
000038  bf00              NOP      
;;;140      
;;;141      uart_number = platform_uart_get_port_number( peripheral->port );
00003a  6820              LDR      r0,[r4,#0]
00003c  f7fffffe          BL       platform_uart_get_port_number
000040  4680              MOV      r8,r0
;;;142      
;;;143      driver->rx_size              = 0;
000042  2000              MOVS     r0,#0
000044  61e8              STR      r0,[r5,#0x1c]
;;;144      driver->tx_size              = 0;
000046  61a8              STR      r0,[r5,#0x18]
;;;145      driver->last_transmit_result = kNoErr;
000048  6268              STR      r0,[r5,#0x24]
;;;146      driver->last_receive_result  = kNoErr;
00004a  6228              STR      r0,[r5,#0x20]
;;;147      driver->peripheral           = (platform_uart_t*)peripheral;
00004c  602c              STR      r4,[r5,#0]
;;;148    #ifndef NO_MICO_RTOS
;;;149      mico_rtos_init_semaphore( &driver->tx_complete, 1 );
00004e  2101              MOVS     r1,#1
000050  f105000c          ADD      r0,r5,#0xc
000054  f7fffffe          BL       mico_rtos_init_semaphore
;;;150      mico_rtos_init_semaphore( &driver->rx_complete, 1 );
000058  2101              MOVS     r1,#1
00005a  f1050008          ADD      r0,r5,#8
00005e  f7fffffe          BL       mico_rtos_init_semaphore
;;;151      mico_rtos_init_semaphore( &driver->sem_wakeup,  1 );
000062  2101              MOVS     r1,#1
000064  f1050014          ADD      r0,r5,#0x14
000068  f7fffffe          BL       mico_rtos_init_semaphore
;;;152      mico_rtos_init_mutex    ( &driver->tx_mutex );
00006c  f1050010          ADD      r0,r5,#0x10
000070  f7fffffe          BL       mico_rtos_init_mutex
;;;153    #else
;;;154      driver->tx_complete = false;
;;;155      driver->rx_complete = false;
;;;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 ] );
000074  48a9              LDR      r0,|L9.796|
000076  f8100008          LDRB     r0,[r0,r8]
00007a  9000              STR      r0,[sp,#0]
00007c  6862              LDR      r2,[r4,#4]
00007e  7911              LDRB     r1,[r2,#4]
000080  2301              MOVS     r3,#1
000082  6810              LDR      r0,[r2,#0]
000084  2200              MOVS     r2,#0
000086  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 ] );
00008a  48a4              LDR      r0,|L9.796|
00008c  f8100008          LDRB     r0,[r0,r8]
000090  9000              STR      r0,[sp,#0]
000092  68a2              LDR      r2,[r4,#8]
000094  7911              LDRB     r1,[r2,#4]
000096  2301              MOVS     r3,#1
000098  6810              LDR      r0,[r2,#0]
00009a  2200              MOVS     r2,#0
00009c  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 ) )
0000a0  68e0              LDR      r0,[r4,#0xc]
0000a2  b180              CBZ      r0,|L9.198|
0000a4  79f0              LDRB     r0,[r6,#7]
0000a6  2801              CMP      r0,#1
0000a8  d002              BEQ      |L9.176|
0000aa  79f0              LDRB     r0,[r6,#7]
0000ac  2803              CMP      r0,#3
0000ae  d10a              BNE      |L9.198|
                  |L9.176|
;;;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 ] );
0000b0  489a              LDR      r0,|L9.796|
0000b2  f8100008          LDRB     r0,[r0,r8]
0000b6  9000              STR      r0,[sp,#0]
0000b8  68e2              LDR      r2,[r4,#0xc]
0000ba  7911              LDRB     r1,[r2,#4]
0000bc  2300              MOVS     r3,#0
0000be  6810              LDR      r0,[r2,#0]
0000c0  461a              MOV      r2,r3
0000c2  f7fffffe          BL       platform_gpio_set_alternate_function
                  |L9.198|
;;;165      }
;;;166    
;;;167      if ( ( peripheral->pin_rts != NULL ) && ( config->flow_control == FLOW_CONTROL_RTS || config->flow_control == FLOW_CONTROL_CTS_RTS ) )
0000c6  6920              LDR      r0,[r4,#0x10]
0000c8  b180              CBZ      r0,|L9.236|
0000ca  79f0              LDRB     r0,[r6,#7]
0000cc  2802              CMP      r0,#2
0000ce  d002              BEQ      |L9.214|
0000d0  79f0              LDRB     r0,[r6,#7]
0000d2  2803              CMP      r0,#3
0000d4  d10a              BNE      |L9.236|
                  |L9.214|
;;;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 ] );
0000d6  4891              LDR      r0,|L9.796|
0000d8  f8100008          LDRB     r0,[r0,r8]
0000dc  9000              STR      r0,[sp,#0]
0000de  6922              LDR      r2,[r4,#0x10]
0000e0  7911              LDRB     r1,[r2,#4]
0000e2  2300              MOVS     r3,#0
0000e4  6810              LDR      r0,[r2,#0]
0000e6  461a              MOV      r2,r3
0000e8  f7fffffe          BL       platform_gpio_set_alternate_function
                  |L9.236|
;;;170      }
;;;171      
;;;172    #ifndef NO_MICO_RTOS
;;;173      if(config->flags & UART_WAKEUP_ENABLE){
0000ec  7a30              LDRB     r0,[r6,#8]
0000ee  f0000001          AND      r0,r0,#1
0000f2  b168              CBZ      r0,|L9.272|
;;;174        mico_rtos_init_semaphore( driver->sem_wakeup, 1 );
0000f4  2101              MOVS     r1,#1
0000f6  6968              LDR      r0,[r5,#0x14]
0000f8  f7fffffe          BL       mico_rtos_init_semaphore
;;;175        mico_rtos_create_thread(NULL, MICO_APPLICATION_PRIORITY, "UART_WAKEUP", thread_wakeup, 0x100, driver);
0000fc  f44f7080          MOV      r0,#0x100
000100  4b87              LDR      r3,|L9.800|
000102  a288              ADR      r2,|L9.804|
000104  2107              MOVS     r1,#7
000106  e9cd0500          STRD     r0,r5,[sp,#0]
00010a  2000              MOVS     r0,#0
00010c  f7fffffe          BL       mico_rtos_create_thread
                  |L9.272|
;;;176      }
;;;177    #endif
;;;178      
;;;179    /* Enable UART peripheral clock */
;;;180      uart_peripheral_clock_functions[ uart_number ]( uart_peripheral_clocks[ uart_number ], ENABLE );
000110  4987              LDR      r1,|L9.816|
000112  f8510028          LDR      r0,[r1,r8,LSL #2]
000116  4987              LDR      r1,|L9.820|
000118  f8512028          LDR      r2,[r1,r8,LSL #2]
00011c  2101              MOVS     r1,#1
00011e  4790              BLX      r2
;;;181    
;;;182      uart_init_structure.USART_Mode       = USART_Mode_Rx | USART_Mode_Tx;
000120  200c              MOVS     r0,#0xc
000122  f8ad0012          STRH     r0,[sp,#0x12]
;;;183      uart_init_structure.USART_BaudRate   = config->baud_rate;
000126  6830              LDR      r0,[r6,#0]
000128  9002              STR      r0,[sp,#8]
;;;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;
00012a  7930              LDRB     r0,[r6,#4]
00012c  2804              CMP      r0,#4
00012e  d004              BEQ      |L9.314|
000130  7930              LDRB     r0,[r6,#4]
000132  2803              CMP      r0,#3
000134  d104              BNE      |L9.320|
000136  7970              LDRB     r0,[r6,#5]
000138  b110              CBZ      r0,|L9.320|
                  |L9.314|
00013a  f44f5080          MOV      r0,#0x1000
00013e  e000              B        |L9.322|
                  |L9.320|
000140  2000              MOVS     r0,#0
                  |L9.322|
000142  f8ad000c          STRH     r0,[sp,#0xc]
;;;185      uart_init_structure.USART_StopBits   = ( config->stop_bits == STOP_BITS_1 ) ? USART_StopBits_1 : USART_StopBits_2;
000146  79b0              LDRB     r0,[r6,#6]
000148  b908              CBNZ     r0,|L9.334|
00014a  2000              MOVS     r0,#0
00014c  e001              B        |L9.338|
                  |L9.334|
00014e  f44f5000          MOV      r0,#0x2000
                  |L9.338|
000152  f8ad000e          STRH     r0,[sp,#0xe]
;;;186    
;;;187      switch ( config->parity )
000156  7970              LDRB     r0,[r6,#5]
000158  b120              CBZ      r0,|L9.356|
00015a  2801              CMP      r0,#1
00015c  d00b              BEQ      |L9.374|
00015e  2802              CMP      r0,#2
000160  d10e              BNE      |L9.384|
000162  e003              B        |L9.364|
                  |L9.356|
;;;188      {
;;;189        case NO_PARITY:
;;;190          uart_init_structure.USART_Parity = USART_Parity_No;
000164  2000              MOVS     r0,#0
000166  f8ad0010          STRH     r0,[sp,#0x10]
;;;191          break;
00016a  e00c              B        |L9.390|
                  |L9.364|
;;;192    
;;;193        case EVEN_PARITY:
;;;194          uart_init_structure.USART_Parity = USART_Parity_Even;
00016c  f44f6080          MOV      r0,#0x400
000170  f8ad0010          STRH     r0,[sp,#0x10]
;;;195          break;
000174  e007              B        |L9.390|
                  |L9.374|
;;;196    
;;;197        case ODD_PARITY:
;;;198          uart_init_structure.USART_Parity = USART_Parity_Odd;
000176  f44f60c0          MOV      r0,#0x600
00017a  f8ad0010          STRH     r0,[sp,#0x10]
;;;199          break;
00017e  e002              B        |L9.390|
                  |L9.384|
;;;200    
;;;201        default:
;;;202          err = kParamErr;
000180  f8df9194          LDR      r9,|L9.792|
;;;203          goto exit;
000184  e0c2              B        |L9.780|
                  |L9.390|
000186  bf00              NOP                            ;191
;;;204      }
;;;205    
;;;206      switch ( config->flow_control )
000188  79f0              LDRB     r0,[r6,#7]
00018a  b130              CBZ      r0,|L9.410|
00018c  2801              CMP      r0,#1
00018e  d008              BEQ      |L9.418|
000190  2802              CMP      r0,#2
000192  d00b              BEQ      |L9.428|
000194  2803              CMP      r0,#3
000196  d113              BNE      |L9.448|
000198  e00d              B        |L9.438|
                  |L9.410|
;;;207      {
;;;208        case FLOW_CONTROL_DISABLED:
;;;209          uart_init_structure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
00019a  2000              MOVS     r0,#0
00019c  f8ad0014          STRH     r0,[sp,#0x14]
;;;210          break;
0001a0  e011              B        |L9.454|
                  |L9.418|
;;;211    
;;;212        case FLOW_CONTROL_CTS:
;;;213          uart_init_structure.USART_HardwareFlowControl = USART_HardwareFlowControl_CTS;
0001a2  f44f7000          MOV      r0,#0x200
0001a6  f8ad0014          STRH     r0,[sp,#0x14]
;;;214          break;
0001aa  e00c              B        |L9.454|
                  |L9.428|
;;;215    
;;;216        case FLOW_CONTROL_RTS:
;;;217          uart_init_structure.USART_HardwareFlowControl = USART_HardwareFlowControl_RTS;
0001ac  f44f7080          MOV      r0,#0x100
0001b0  f8ad0014          STRH     r0,[sp,#0x14]
;;;218          break;
0001b4  e007              B        |L9.454|
                  |L9.438|
;;;219    
;;;220        case FLOW_CONTROL_CTS_RTS:
;;;221          uart_init_structure.USART_HardwareFlowControl = USART_HardwareFlowControl_RTS_CTS;
0001b6  f44f7040          MOV      r0,#0x300
0001ba  f8ad0014          STRH     r0,[sp,#0x14]
;;;222          break;
0001be  e002              B        |L9.454|
                  |L9.448|
;;;223    
;;;224        default:
;;;225          err = kParamErr;
0001c0  f8df9154          LDR      r9,|L9.792|
;;;226          goto exit;
0001c4  e0a2              B        |L9.780|
                  |L9.454|
0001c6  bf00              NOP                            ;210
;;;227      }
;;;228    
;;;229    
;;;230      /* Initialise USART peripheral */
;;;231      USART_DeInit( peripheral->port );
0001c8  6820              LDR      r0,[r4,#0]
0001ca  f7fffffe          BL       USART_DeInit
;;;232      USART_Init( peripheral->port, &uart_init_structure );
0001ce  a902              ADD      r1,sp,#8
0001d0  6820              LDR      r0,[r4,#0]
0001d2  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 )
0001d6  4958              LDR      r1,|L9.824|
0001d8  6960              LDR      r0,[r4,#0x14]
0001da  4288              CMP      r0,r1
0001dc  d106              BNE      |L9.492|
;;;240      {
;;;241          RCC->AHB1ENR |= RCC_AHB1Periph_DMA1;
0001de  4857              LDR      r0,|L9.828|
0001e0  6800              LDR      r0,[r0,#0]
0001e2  f4401000          ORR      r0,r0,#0x200000
0001e6  4955              LDR      r1,|L9.828|
0001e8  6008              STR      r0,[r1,#0]
0001ea  e005              B        |L9.504|
                  |L9.492|
;;;242      }
;;;243      else
;;;244      {
;;;245          RCC->AHB1ENR |= RCC_AHB1Periph_DMA2;
0001ec  4853              LDR      r0,|L9.828|
0001ee  6800              LDR      r0,[r0,#0]
0001f0  f4400080          ORR      r0,r0,#0x400000
0001f4  4951              LDR      r1,|L9.828|
0001f6  6008              STR      r0,[r1,#0]
                  |L9.504|
;;;246      }
;;;247      
;;;248      /* Fill init structure with common DMA settings */
;;;249      dma_init_structure.DMA_PeripheralInc   = DMA_PeripheralInc_Disable;
0001f8  2000              MOVS     r0,#0
0001fa  900b              STR      r0,[sp,#0x2c]
;;;250      dma_init_structure.DMA_MemoryInc       = DMA_MemoryInc_Enable;
0001fc  f44f6080          MOV      r0,#0x400
000200  900c              STR      r0,[sp,#0x30]
;;;251      dma_init_structure.DMA_Priority        = DMA_Priority_VeryHigh;
000202  f44f3040          MOV      r0,#0x30000
000206  9010              STR      r0,[sp,#0x40]
;;;252      dma_init_structure.DMA_FIFOMode        = DMA_FIFOMode_Disable;
000208  2000              MOVS     r0,#0
00020a  9011              STR      r0,[sp,#0x44]
;;;253      dma_init_structure.DMA_FIFOThreshold   = DMA_FIFOThreshold_Full;
00020c  2003              MOVS     r0,#3
00020e  9012              STR      r0,[sp,#0x48]
;;;254      dma_init_structure.DMA_MemoryBurst     = DMA_MemoryBurst_Single;
000210  2000              MOVS     r0,#0
000212  9013              STR      r0,[sp,#0x4c]
;;;255      dma_init_structure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
000214  9014              STR      r0,[sp,#0x50]
;;;256    
;;;257      if ( config->data_width == DATA_WIDTH_9BIT )
000216  7930              LDRB     r0,[r6,#4]
000218  2804              CMP      r0,#4
00021a  d104              BNE      |L9.550|
;;;258      {
;;;259        dma_init_structure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
00021c  0240              LSLS     r0,r0,#9
00021e  900d              STR      r0,[sp,#0x34]
;;;260        dma_init_structure.DMA_MemoryDataSize     = DMA_MemoryDataSize_HalfWord;
000220  0080              LSLS     r0,r0,#2
000222  900e              STR      r0,[sp,#0x38]
000224  e002              B        |L9.556|
                  |L9.550|
;;;261      }
;;;262      else
;;;263      {
;;;264        dma_init_structure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
000226  2000              MOVS     r0,#0
000228  900d              STR      r0,[sp,#0x34]
;;;265        dma_init_structure.DMA_MemoryDataSize     = DMA_MemoryDataSize_Byte;
00022a  900e              STR      r0,[sp,#0x38]
                  |L9.556|
;;;266      }
;;;267    
;;;268      /* Initialise TX DMA */
;;;269      DMA_DeInit( peripheral->tx_dma_config.stream );
00022c  69a0              LDR      r0,[r4,#0x18]
00022e  f7fffffe          BL       DMA_DeInit
;;;270      dma_init_structure.DMA_Channel            = peripheral->tx_dma_config.channel;
000232  69e0              LDR      r0,[r4,#0x1c]
000234  9006              STR      r0,[sp,#0x18]
;;;271      dma_init_structure.DMA_PeripheralBaseAddr = (uint32_t) &peripheral->port->DR;
000236  6820              LDR      r0,[r4,#0]
000238  1d00              ADDS     r0,r0,#4
00023a  9007              STR      r0,[sp,#0x1c]
;;;272      dma_init_structure.DMA_Memory0BaseAddr    = (uint32_t) 0;
00023c  2000              MOVS     r0,#0
00023e  9008              STR      r0,[sp,#0x20]
;;;273      dma_init_structure.DMA_DIR                = DMA_DIR_MemoryToPeripheral;
000240  2040              MOVS     r0,#0x40
000242  9009              STR      r0,[sp,#0x24]
;;;274      dma_init_structure.DMA_BufferSize         = 0xFFFF;                     // This parameter will be configured during communication
000244  f64f70ff          MOV      r0,#0xffff
000248  900a              STR      r0,[sp,#0x28]
;;;275      dma_init_structure.DMA_Mode               = DMA_Mode_Normal;
00024a  2000              MOVS     r0,#0
00024c  900f              STR      r0,[sp,#0x3c]
;;;276      DMA_Init( peripheral->tx_dma_config.stream, &dma_init_structure );
00024e  a906              ADD      r1,sp,#0x18
000250  69a0              LDR      r0,[r4,#0x18]
000252  f7fffffe          BL       DMA_Init
;;;277    
;;;278      /* Initialise RX DMA */
;;;279      DMA_DeInit( peripheral->rx_dma_config.stream );
000256  6b20              LDR      r0,[r4,#0x30]
000258  f7fffffe          BL       DMA_DeInit
;;;280      dma_init_structure.DMA_Channel            = peripheral->rx_dma_config.channel;
00025c  6b60              LDR      r0,[r4,#0x34]
00025e  9006              STR      r0,[sp,#0x18]
;;;281      dma_init_structure.DMA_PeripheralBaseAddr = (uint32_t) &peripheral->port->DR;
000260  6820              LDR      r0,[r4,#0]
000262  1d00              ADDS     r0,r0,#4
000264  9007              STR      r0,[sp,#0x1c]
;;;282      dma_init_structure.DMA_Memory0BaseAddr    = (uint32_t) 0;
000266  2000              MOVS     r0,#0
000268  9008              STR      r0,[sp,#0x20]
;;;283      dma_init_structure.DMA_DIR                = DMA_DIR_PeripheralToMemory;
00026a  9009              STR      r0,[sp,#0x24]
;;;284      dma_init_structure.DMA_BufferSize         = 0xFFFF;                     // This parameter will be configured during communication
00026c  f64f70ff          MOV      r0,#0xffff
000270  900a              STR      r0,[sp,#0x28]
;;;285      dma_init_structure.DMA_Mode               = DMA_Mode_Normal;
000272  2000              MOVS     r0,#0
000274  900f              STR      r0,[sp,#0x3c]
;;;286      DMA_Init( peripheral->rx_dma_config.stream, &dma_init_structure );
000276  a906              ADD      r1,sp,#0x18
000278  6b20              LDR      r0,[r4,#0x30]
00027a  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 );
00027e  f9940020          LDRSB    r0,[r4,#0x20]
000282  f7fffffe          BL       NVIC_EnableIRQ
;;;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 );
000286  e9d42309          LDRD     r2,r3,[r4,#0x24]
00028a  ea420103          ORR      r1,r2,r3
00028e  69a0              LDR      r0,[r4,#0x18]
000290  f7fffffe          BL       clear_dma_interrupts
;;;297      DMA_ITConfig( peripheral->tx_dma_config.stream, DMA_INTERRUPT_FLAGS, ENABLE );
000294  2201              MOVS     r2,#1
000296  2196              MOVS     r1,#0x96
000298  69a0              LDR      r0,[r4,#0x18]
00029a  f7fffffe          BL       DMA_ITConfig
;;;298    
;;;299      /* Enable USART interrupt vector in Cortex-M3 */
;;;300      NVIC_EnableIRQ( uart_irq_vectors[uart_number] );
00029e  4928              LDR      r1,|L9.832|
0002a0  f9110008          LDRSB    r0,[r1,r8]
0002a4  f7fffffe          BL       NVIC_EnableIRQ
;;;301      USART_DMACmd( driver->peripheral->port, USART_DMAReq_Tx, DISABLE );
0002a8  6829              LDR      r1,[r5,#0]
0002aa  2200              MOVS     r2,#0
0002ac  6808              LDR      r0,[r1,#0]
0002ae  2180              MOVS     r1,#0x80
0002b0  f7fffffe          BL       USART_DMACmd
;;;302    
;;;303      /* Enable USART */
;;;304      USART_Cmd( peripheral->port, ENABLE );
0002b4  2101              MOVS     r1,#1
0002b6  6820              LDR      r0,[r4,#0]
0002b8  f7fffffe          BL       USART_Cmd
;;;305    
;;;306      /* Enable both transmit and receive */
;;;307      peripheral->port->CR1 |= USART_CR1_TE;
0002bc  6820              LDR      r0,[r4,#0]
0002be  8980              LDRH     r0,[r0,#0xc]
0002c0  f0400008          ORR      r0,r0,#8
0002c4  6821              LDR      r1,[r4,#0]
0002c6  8188              STRH     r0,[r1,#0xc]
;;;308      peripheral->port->CR1 |= USART_CR1_RE;
0002c8  6820              LDR      r0,[r4,#0]
0002ca  8980              LDRH     r0,[r0,#0xc]
0002cc  f0400004          ORR      r0,r0,#4
0002d0  6821              LDR      r1,[r4,#0]
0002d2  8188              STRH     r0,[r1,#0xc]
;;;309    
;;;310      /* Setup ring buffer */
;;;311      if ( optional_ring_buffer != NULL )
0002d4  b14f              CBZ      r7,|L9.746|
;;;312      {
;;;313        /* Note that the ring_buffer should've been initialised first */
;;;314        driver->rx_buffer = optional_ring_buffer;
0002d6  606f              STR      r7,[r5,#4]
;;;315        driver->rx_size   = 0;
0002d8  2000              MOVS     r0,#0
0002da  61e8              STR      r0,[r5,#0x1c]
;;;316        receive_bytes( driver, optional_ring_buffer->buffer, optional_ring_buffer->size, 0 );
0002dc  2300              MOVS     r3,#0
0002de  4628              MOV      r0,r5
0002e0  683a              LDR      r2,[r7,#0]
0002e2  68f9              LDR      r1,[r7,#0xc]
0002e4  f7fffffe          BL       receive_bytes
0002e8  e00f              B        |L9.778|
                  |L9.746|
;;;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 );
0002ea  f9940038          LDRSB    r0,[r4,#0x38]
0002ee  f7fffffe          BL       NVIC_EnableIRQ
;;;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 );
0002f2  e9d4230f          LDRD     r2,r3,[r4,#0x3c]
0002f6  ea420103          ORR      r1,r2,r3
0002fa  6b20              LDR      r0,[r4,#0x30]
0002fc  f7fffffe          BL       clear_dma_interrupts
;;;325        DMA_ITConfig( peripheral->rx_dma_config.stream, DMA_INTERRUPT_FLAGS, ENABLE );
000300  2201              MOVS     r2,#1
000302  2196              MOVS     r1,#0x96
000304  6b20              LDR      r0,[r4,#0x30]
000306  f7fffffe          BL       DMA_ITConfig
                  |L9.778|
;;;326      }
;;;327    
;;;328    exit:
00030a  bf00              NOP      
                  |L9.780|
;;;329      platform_mcu_powersave_enable();
00030c  f7fffffe          BL       platform_mcu_powersave_enable
;;;330      return err;
000310  4648              MOV      r0,r9
;;;331    }
000312  b015              ADD      sp,sp,#0x54
000314  e8bd83f0          POP      {r4-r9,pc}
;;;332    
                          ENDP

                  |L9.792|
                          DCD      0xffffe5cf
                  |L9.796|
                          DCD      uart_alternate_functions
                  |L9.800|
                          DCD      thread_wakeup
                  |L9.804|
000324  55415254          DCB      "UART_WAKEUP",0
000328  5f57414b
00032c  45555000
                  |L9.816|
                          DCD      uart_peripheral_clocks
                  |L9.820|
                          DCD      uart_peripheral_clock_functions
                  |L9.824|
                          DCD      0x40026000
                  |L9.828|
                          DCD      0x40023830
                  |L9.832|
                          DCD      uart_irq_vectors

                          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  b570              PUSH     {r4-r6,lr}
;;;684    {
000002  4604              MOV      r4,r0
;;;685      platform_uart_port_t* uart = (platform_uart_port_t*) driver->peripheral->port;
000004  6820              LDR      r0,[r4,#0]
000006  6805              LDR      r5,[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  8828              LDRH     r0,[r5,#0]
00000a  f64f71ff          MOV      r1,#0xffff
00000e  4308              ORRS     r0,r0,r1
000010  8028              STRH     r0,[r5,#0]
;;;689    
;;;690      // Update tail
;;;691      driver->rx_buffer->tail = driver->rx_buffer->size - driver->peripheral->rx_dma_config.stream->NDTR;
000012  6860              LDR      r0,[r4,#4]
000014  6801              LDR      r1,[r0,#0]
000016  6820              LDR      r0,[r4,#0]
000018  6b00              LDR      r0,[r0,#0x30]
00001a  6840              LDR      r0,[r0,#4]
00001c  1a08              SUBS     r0,r1,r0
00001e  6861              LDR      r1,[r4,#4]
000020  6088              STR      r0,[r1,#8]
;;;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 ) )
000022  69e0              LDR      r0,[r4,#0x1c]
000024  b158              CBZ      r0,|L10.62|
000026  6860              LDR      r0,[r4,#4]
000028  f7fffffe          BL       ring_buffer_used_space
00002c  69e1              LDR      r1,[r4,#0x1c]
00002e  4288              CMP      r0,r1
000030  d305              BCC      |L10.62|
;;;695      {
;;;696          #ifndef NO_MICO_RTOS
;;;697          mico_rtos_set_semaphore( &driver->rx_complete );
000032  f1040008          ADD      r0,r4,#8
000036  f7fffffe          BL       mico_rtos_set_semaphore
;;;698          #else
;;;699          driver->rx_complete = true;
;;;700          #endif
;;;701          driver->rx_size = 0;
00003a  2000              MOVS     r0,#0
00003c  61e0              STR      r0,[r4,#0x1c]
                  |L10.62|
;;;702      }
;;;703    #ifndef NO_MICO_RTOS
;;;704      if( driver->sem_wakeup )
00003e  6960              LDR      r0,[r4,#0x14]
000040  b118              CBZ      r0,|L10.74|
;;;705        mico_rtos_set_semaphore( &driver->sem_wakeup );
000042  f1040014          ADD      r0,r4,#0x14
000046  f7fffffe          BL       mico_rtos_set_semaphore
                  |L10.74|
;;;706    #endif
;;;707    }
00004a  bd70              POP      {r4-r6,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  4604              MOV      r4,r0
000006  460f              MOV      r7,r1
000008  4616              MOV      r6,r2
00000a  4698              MOV      r8,r3
;;;448      OSStatus err = kNoErr;
00000c  f04f0900          MOV      r9,#0
;;;449    
;;;450      //platform_mcu_powersave_disable();
;;;451    
;;;452      require_action_quiet( ( driver != NULL ) && ( data_in != NULL ) && ( expected_data_size != 0 ), exit, err = kParamErr);
000010  bf00              NOP      
000012  b10c              CBZ      r4,|L11.24|
000014  b107              CBZ      r7,|L11.24|
000016  b916              CBNZ     r6,|L11.30|
                  |L11.24|
000018  f8df90a8          LDR      r9,|L11.196|
00001c  e04e              B        |L11.188|
                  |L11.30|
00001e  bf00              NOP      
;;;453    
;;;454      if ( driver->rx_buffer != NULL)
000020  6860              LDR      r0,[r4,#4]
000022  2800              CMP      r0,#0
000024  d042              BEQ      |L11.172|
;;;455      {
;;;456        while ( expected_data_size != 0 )
000026  e03e              B        |L11.166|
                  |L11.40|
;;;457        {
;;;458          uint32_t transfer_size = MIN( driver->rx_buffer->size / 2, expected_data_size );
000028  6860              LDR      r0,[r4,#4]
00002a  6800              LDR      r0,[r0,#0]
00002c  ebb60f50          CMP      r6,r0,LSR #1
000030  d903              BLS      |L11.58|
000032  6860              LDR      r0,[r4,#4]
000034  6800              LDR      r0,[r0,#0]
000036  0840              LSRS     r0,r0,#1
000038  e000              B        |L11.60|
                  |L11.58|
00003a  4630              MOV      r0,r6
                  |L11.60|
00003c  4605              MOV      r5,r0
;;;459          
;;;460          /* Check if ring buffer already contains the required amount of data. */
;;;461          if ( transfer_size > ring_buffer_used_space( driver->rx_buffer ) )
00003e  6860              LDR      r0,[r4,#4]
000040  f7fffffe          BL       ring_buffer_used_space
000044  42a8              CMP      r0,r5
000046  d20e              BCS      |L11.102|
;;;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;
000048  2000              MOVS     r0,#0
00004a  6220              STR      r0,[r4,#0x20]
;;;465            driver->rx_size             = transfer_size;
00004c  61e5              STR      r5,[r4,#0x1c]
;;;466            
;;;467    #ifndef NO_MICO_RTOS
;;;468            err = mico_rtos_get_semaphore( &driver->rx_complete, timeout_ms );
00004e  4641              MOV      r1,r8
000050  f1040008          ADD      r0,r4,#8
000054  f7fffffe          BL       mico_rtos_get_semaphore
000058  4681              MOV      r9,r0
;;;469    
;;;470            /* Reset rx_size to prevent semaphore being set while nothing waits for the data */
;;;471            driver->rx_size = 0;
00005a  2000              MOVS     r0,#0
00005c  61e0              STR      r0,[r4,#0x1c]
;;;472    
;;;473            if( err != kNoErr )
00005e  f1b90f00          CMP      r9,#0
000062  d000              BEQ      |L11.102|
;;;474              goto exit;
000064  e02a              B        |L11.188|
                  |L11.102|
;;;475    #else
;;;476            driver->rx_complete = false;
;;;477            int delay_start = 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){
;;;480                driver->rx_size = 0;
;;;481                err = kTimeoutErr;
;;;482                goto exit;
;;;483              }
;;;484            }
;;;485            driver->rx_size = 0;
;;;486    #endif
;;;487          }
;;;488          err = driver->last_receive_result;
000066  f8d49020          LDR      r9,[r4,#0x20]
;;;489          expected_data_size -= transfer_size;
00006a  1b76              SUBS     r6,r6,r5
;;;490          
;;;491          // Grab data from the buffer
;;;492          do
00006c  bf00              NOP      
                  |L11.110|
;;;493          {
;;;494            uint8_t* available_data;
;;;495            uint32_t bytes_available;
;;;496            
;;;497            ring_buffer_get_data( driver->rx_buffer, &available_data, &bytes_available );
00006e  466a              MOV      r2,sp
000070  a901              ADD      r1,sp,#4
000072  6860              LDR      r0,[r4,#4]
000074  f7fffffe          BL       ring_buffer_get_data
;;;498            bytes_available = MIN( bytes_available, transfer_size );
000078  9800              LDR      r0,[sp,#0]
00007a  42a8              CMP      r0,r5
00007c  d201              BCS      |L11.130|
00007e  9800              LDR      r0,[sp,#0]
000080  e000              B        |L11.132|
                  |L11.130|
000082  4628              MOV      r0,r5
                  |L11.132|
000084  9000              STR      r0,[sp,#0]
;;;499            memcpy( data_in, available_data, bytes_available );
000086  4638              MOV      r0,r7
000088  e9dd2100          LDRD     r2,r1,[sp,#0]
00008c  f7fffffe          BL       __aeabi_memcpy
;;;500            transfer_size -= bytes_available;
000090  9800              LDR      r0,[sp,#0]
000092  1a2d              SUBS     r5,r5,r0
;;;501            data_in = ( (uint8_t*) data_in + bytes_available );
000094  9800              LDR      r0,[sp,#0]
000096  4407              ADD      r7,r7,r0
;;;502            ring_buffer_consume( driver->rx_buffer, bytes_available );
000098  6860              LDR      r0,[r4,#4]
00009a  9900              LDR      r1,[sp,#0]
00009c  f7fffffe          BL       ring_buffer_consume
;;;503          } while ( transfer_size != 0 );
0000a0  2d00              CMP      r5,#0
0000a2  d1e4              BNE      |L11.110|
;;;504        }
0000a4  bf00              NOP      
                  |L11.166|
0000a6  2e00              CMP      r6,#0                 ;456
0000a8  d1be              BNE      |L11.40|
0000aa  e006              B        |L11.186|
                  |L11.172|
;;;505      }
;;;506      else
;;;507      {
;;;508        err = receive_bytes( driver, data_in, expected_data_size, timeout_ms );
0000ac  4643              MOV      r3,r8
0000ae  4632              MOV      r2,r6
0000b0  4639              MOV      r1,r7
0000b2  4620              MOV      r0,r4
0000b4  f7fffffe          BL       receive_bytes
0000b8  4681              MOV      r9,r0
                  |L11.186|
;;;509      }
;;;510    exit:
0000ba  bf00              NOP      
                  |L11.188|
;;;511      //platform_mcu_powersave_enable();
;;;512      return err;
0000bc  4648              MOV      r0,r9
;;;513    }
0000be  e8bd87fc          POP      {r2-r10,pc}
;;;514    
                          ENDP

0000c2  0000              DCW      0x0000
                  |L11.196|
                          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  6821              LDR      r1,[r4,#0]
000006  6b08              LDR      r0,[r1,#0x30]
000008  f7fffffe          BL       get_dma_irq_status
00000c  6821              LDR      r1,[r4,#0]
00000e  6bc9              LDR      r1,[r1,#0x3c]
000010  4008              ANDS     r0,r0,r1
000012  b130              CBZ      r0,|L12.34|
;;;737        {
;;;738            clear_dma_interrupts( driver->peripheral->rx_dma_config.stream, driver->peripheral->rx_dma_config.complete_flags );
000014  6822              LDR      r2,[r4,#0]
000016  6bd1              LDR      r1,[r2,#0x3c]
000018  6b10              LDR      r0,[r2,#0x30]
00001a  f7fffffe          BL       clear_dma_interrupts
;;;739            driver->last_receive_result = kNoErr;
00001e  2000              MOVS     r0,#0
000020  6220              STR      r0,[r4,#0x20]
                  |L12.34|
;;;740        }
;;;741    
;;;742        if ( ( get_dma_irq_status( driver->peripheral->rx_dma_config.stream ) & driver->peripheral->rx_dma_config.error_flags ) != 0 )
000022  6821              LDR      r1,[r4,#0]
000024  6b08              LDR      r0,[r1,#0x30]
000026  f7fffffe          BL       get_dma_irq_status
00002a  6821              LDR      r1,[r4,#0]
00002c  6c09              LDR      r1,[r1,#0x40]
00002e  4008              ANDS     r0,r0,r1
000030  b138              CBZ      r0,|L12.66|
;;;743        {
;;;744            clear_dma_interrupts( driver->peripheral->rx_dma_config.stream, driver->peripheral->rx_dma_config.error_flags );
000032  6822              LDR      r2,[r4,#0]
000034  6c11              LDR      r1,[r2,#0x40]
000036  6b10              LDR      r0,[r2,#0x30]
000038  f7fffffe          BL       clear_dma_interrupts
;;;745            driver->last_receive_result = kGeneralErr;
00003c  f04f30ff          MOV      r0,#0xffffffff
000040  6220              STR      r0,[r4,#0x20]
                  |L12.66|
;;;746        }
;;;747    
;;;748        if ( driver->rx_size > 0 )
000042  69e0              LDR      r0,[r4,#0x1c]
000044  b118              CBZ      r0,|L12.78|
;;;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 );
000046  f1040008          ADD      r0,r4,#8
00004a  f7fffffe          BL       mico_rtos_set_semaphore
                  |L12.78|
;;;753            #else
;;;754            driver->rx_complete = true;
;;;755            #endif
;;;756        }
;;;757    }
00004e  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  e92d41f0          PUSH     {r4-r8,lr}
;;;396    {
000004  4604              MOV      r4,r0
000006  460e              MOV      r6,r1
000008  4615              MOV      r5,r2
;;;397      OSStatus err = kNoErr;
00000a  2700              MOVS     r7,#0
;;;398    
;;;399      platform_mcu_powersave_disable();
00000c  f7fffffe          BL       platform_mcu_powersave_disable
;;;400      
;;;401    #ifndef NO_MICO_RTOS
;;;402      mico_rtos_lock_mutex( &driver->tx_mutex );
000010  f1040010          ADD      r0,r4,#0x10
000014  f7fffffe          BL       mico_rtos_lock_mutex
;;;403    #endif
;;;404    
;;;405      require_action_quiet( ( driver != NULL ) && ( data_out != NULL ) && ( size != 0 ), exit, err = kParamErr);
000018  bf00              NOP      
00001a  b10c              CBZ      r4,|L13.32|
00001c  b106              CBZ      r6,|L13.32|
00001e  b90d              CBNZ     r5,|L13.36|
                  |L13.32|
000020  4f29              LDR      r7,|L13.200|
000022  e047              B        |L13.180|
                  |L13.36|
000024  bf00              NOP      
;;;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 );
000026  6822              LDR      r2,[r4,#0]
000028  6a52              LDR      r2,[r2,#0x24]
00002a  6823              LDR      r3,[r4,#0]
00002c  6a9b              LDR      r3,[r3,#0x28]
00002e  ea420103          ORR      r1,r2,r3
000032  6822              LDR      r2,[r4,#0]
000034  6990              LDR      r0,[r2,#0x18]
000036  f7fffffe          BL       clear_dma_interrupts
;;;409    
;;;410      /* Init DMA parameters and variables */
;;;411      driver->last_transmit_result                    = kGeneralErr;
00003a  f04f30ff          MOV      r0,#0xffffffff
00003e  6260              STR      r0,[r4,#0x24]
;;;412      driver->tx_size                                 = size;
000040  61a5              STR      r5,[r4,#0x18]
;;;413      driver->peripheral->tx_dma_config.stream->CR   &= ~(uint32_t) DMA_SxCR_CIRC;
000042  6820              LDR      r0,[r4,#0]
000044  6980              LDR      r0,[r0,#0x18]
000046  6800              LDR      r0,[r0,#0]
000048  f4207180          BIC      r1,r0,#0x100
00004c  6820              LDR      r0,[r4,#0]
00004e  6980              LDR      r0,[r0,#0x18]
000050  6001              STR      r1,[r0,#0]
;;;414      driver->peripheral->tx_dma_config.stream->NDTR  = size;
000052  6820              LDR      r0,[r4,#0]
000054  6980              LDR      r0,[r0,#0x18]
000056  6045              STR      r5,[r0,#4]
;;;415      driver->peripheral->tx_dma_config.stream->M0AR  = (uint32_t)data_out;
000058  6820              LDR      r0,[r4,#0]
00005a  6980              LDR      r0,[r0,#0x18]
00005c  60c6              STR      r6,[r0,#0xc]
;;;416      
;;;417      USART_DMACmd( driver->peripheral->port, USART_DMAReq_Tx, ENABLE );
00005e  6821              LDR      r1,[r4,#0]
000060  2201              MOVS     r2,#1
000062  6808              LDR      r0,[r1,#0]
000064  2180              MOVS     r1,#0x80
000066  f7fffffe          BL       USART_DMACmd
;;;418      USART_ClearFlag( driver->peripheral->port, USART_FLAG_TC );
00006a  6821              LDR      r1,[r4,#0]
00006c  6808              LDR      r0,[r1,#0]
00006e  2140              MOVS     r1,#0x40
000070  f7fffffe          BL       USART_ClearFlag
;;;419      driver->peripheral->tx_dma_config.stream->CR   |= DMA_SxCR_EN;
000074  6820              LDR      r0,[r4,#0]
000076  6980              LDR      r0,[r0,#0x18]
000078  6800              LDR      r0,[r0,#0]
00007a  f0400101          ORR      r1,r0,#1
00007e  6820              LDR      r0,[r4,#0]
000080  6980              LDR      r0,[r0,#0x18]
000082  6001              STR      r1,[r0,#0]
;;;420      
;;;421    /* Wait for transmission complete */
;;;422    #ifndef NO_MICO_RTOS
;;;423      mico_rtos_get_semaphore( &driver->tx_complete, MICO_NEVER_TIMEOUT );
000084  f04f31ff          MOV      r1,#0xffffffff
000088  f104000c          ADD      r0,r4,#0xc
00008c  f7fffffe          BL       mico_rtos_get_semaphore
;;;424    #else 
;;;425      while( driver->tx_complete == false );
;;;426      driver->tx_complete = false;
;;;427    #endif
;;;428    
;;;429      while ( ( driver->peripheral->port->SR & USART_SR_TC ) == 0 )
000090  bf00              NOP      
                  |L13.146|
000092  6820              LDR      r0,[r4,#0]
000094  6800              LDR      r0,[r0,#0]
000096  8800              LDRH     r0,[r0,#0]
000098  f0000040          AND      r0,r0,#0x40
00009c  2800              CMP      r0,#0
00009e  d0f8              BEQ      |L13.146|
;;;430      {
;;;431      }
;;;432    
;;;433      /* Disable DMA and clean up */
;;;434      USART_DMACmd( driver->peripheral->port, USART_DMAReq_Tx, DISABLE );
0000a0  6821              LDR      r1,[r4,#0]
0000a2  2200              MOVS     r2,#0
0000a4  6808              LDR      r0,[r1,#0]
0000a6  2180              MOVS     r1,#0x80
0000a8  f7fffffe          BL       USART_DMACmd
;;;435      driver->tx_size = 0;
0000ac  2000              MOVS     r0,#0
0000ae  61a0              STR      r0,[r4,#0x18]
;;;436      err = driver->last_transmit_result;
0000b0  6a67              LDR      r7,[r4,#0x24]
;;;437    
;;;438    exit:  
0000b2  bf00              NOP      
                  |L13.180|
;;;439    #ifndef NO_MICO_RTOS  
;;;440      mico_rtos_unlock_mutex( &driver->tx_mutex );
0000b4  f1040010          ADD      r0,r4,#0x10
0000b8  f7fffffe          BL       mico_rtos_unlock_mutex
;;;441    #endif
;;;442      platform_mcu_powersave_enable();
0000bc  f7fffffe          BL       platform_mcu_powersave_enable
;;;443      return err;
0000c0  4638              MOV      r0,r7
;;;444    }
0000c2  e8bd81f0          POP      {r4-r8,pc}
;;;445    
                          ENDP

0000c6  0000              DCW      0x0000
                  |L13.200|
                          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  6821              LDR      r1,[r4,#0]
000006  6988              LDR      r0,[r1,#0x18]
000008  f7fffffe          BL       get_dma_irq_status
00000c  6821              LDR      r1,[r4,#0]
00000e  6a49              LDR      r1,[r1,#0x24]
000010  4008              ANDS     r0,r0,r1
000012  b130              CBZ      r0,|L14.34|
;;;712        {
;;;713            clear_dma_interrupts( driver->peripheral->tx_dma_config.stream, driver->peripheral->tx_dma_config.complete_flags );
000014  6822              LDR      r2,[r4,#0]
000016  6a51              LDR      r1,[r2,#0x24]
000018  6990              LDR      r0,[r2,#0x18]
00001a  f7fffffe          BL       clear_dma_interrupts
;;;714            driver->last_transmit_result = kNoErr;
00001e  2000              MOVS     r0,#0
000020  6260              STR      r0,[r4,#0x24]
                  |L14.34|
;;;715        }
;;;716    
;;;717        if ( ( get_dma_irq_status( driver->peripheral->tx_dma_config.stream ) & driver->peripheral->tx_dma_config.error_flags ) != 0 )
000022  6821              LDR      r1,[r4,#0]
000024  6988              LDR      r0,[r1,#0x18]
000026  f7fffffe          BL       get_dma_irq_status
00002a  6821              LDR      r1,[r4,#0]
00002c  6a89              LDR      r1,[r1,#0x28]
00002e  4008              ANDS     r0,r0,r1
000030  b138              CBZ      r0,|L14.66|
;;;718        {
;;;719            clear_dma_interrupts( driver->peripheral->tx_dma_config.stream, driver->peripheral->tx_dma_config.error_flags );
000032  6822              LDR      r2,[r4,#0]
000034  6a91              LDR      r1,[r2,#0x28]
000036  6990              LDR      r0,[r2,#0x18]
000038  f7fffffe          BL       clear_dma_interrupts
;;;720            driver->last_transmit_result = kGeneralErr;
00003c  f04f30ff          MOV      r0,#0xffffffff
000040  6260              STR      r0,[r4,#0x24]
                  |L14.66|
;;;721        }
;;;722    
;;;723        if ( driver->tx_size > 0 )
000042  69a0              LDR      r0,[r4,#0x18]
000044  b118              CBZ      r0,|L14.78|
;;;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 );
000046  f104000c          ADD      r0,r4,#0xc
00004a  f7fffffe          BL       mico_rtos_set_semaphore
                  |L14.78|
;;;728            #else
;;;729            driver->tx_complete = true;
;;;730            #endif
;;;731        }
;;;732    }
00004e  bd10              POP      {r4,pc}
;;;733    
                          ENDP


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

                  receive_bytes PROC
;;;514    
;;;515    static OSStatus receive_bytes( platform_uart_driver_t* driver, void* data, uint32_t size, uint32_t timeout )
000000  e92d41f0          PUSH     {r4-r8,lr}
;;;516    {
000004  4604              MOV      r4,r0
000006  460f              MOV      r7,r1
000008  4615              MOV      r5,r2
00000a  461e              MOV      r6,r3
;;;517      OSStatus err = kNoErr;
00000c  f04f0800          MOV      r8,#0
;;;518    
;;;519      if ( driver->rx_buffer != NULL )
000010  6860              LDR      r0,[r4,#4]
000012  b1a8              CBZ      r0,|L15.64|
;;;520      {
;;;521        driver->peripheral->rx_dma_config.stream->CR |= DMA_SxCR_CIRC;
000014  6820              LDR      r0,[r4,#0]
000016  6b00              LDR      r0,[r0,#0x30]
000018  6800              LDR      r0,[r0,#0]
00001a  f4407180          ORR      r1,r0,#0x100
00001e  6820              LDR      r0,[r4,#0]
000020  6b00              LDR      r0,[r0,#0x30]
000022  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 );
000024  6821              LDR      r1,[r4,#0]
000026  6808              LDR      r0,[r1,#0]
000028  f2405125          MOV      r1,#0x525
00002c  f7fffffe          BL       USART_ClearITPendingBit
;;;525        USART_ITConfig( driver->peripheral->port, USART_IT_RXNE, ENABLE );
000030  6821              LDR      r1,[r4,#0]
000032  2201              MOVS     r2,#1
000034  6808              LDR      r0,[r1,#0]
000036  f2405125          MOV      r1,#0x525
00003a  f7fffffe          BL       USART_ITConfig
00003e  e008              B        |L15.82|
                  |L15.64|
;;;526      }
;;;527      else
;;;528      {
;;;529        driver->rx_size = size;
000040  61e5              STR      r5,[r4,#0x1c]
;;;530        driver->peripheral->rx_dma_config.stream->CR &= ~(uint32_t) DMA_SxCR_CIRC;
000042  6820              LDR      r0,[r4,#0]
000044  6b00              LDR      r0,[r0,#0x30]
000046  6800              LDR      r0,[r0,#0]
000048  f4207180          BIC      r1,r0,#0x100
00004c  6820              LDR      r0,[r4,#0]
00004e  6b00              LDR      r0,[r0,#0x30]
000050  6001              STR      r1,[r0,#0]
                  |L15.82|
;;;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 );
000052  6822              LDR      r2,[r4,#0]
000054  6bd2              LDR      r2,[r2,#0x3c]
000056  6823              LDR      r3,[r4,#0]
000058  6c1b              LDR      r3,[r3,#0x40]
00005a  ea420103          ORR      r1,r2,r3
00005e  6822              LDR      r2,[r4,#0]
000060  6b10              LDR      r0,[r2,#0x30]
000062  f7fffffe          BL       clear_dma_interrupts
;;;534    
;;;535      driver->peripheral->rx_dma_config.stream->NDTR  = size;
000066  6820              LDR      r0,[r4,#0]
000068  6b00              LDR      r0,[r0,#0x30]
00006a  6045              STR      r5,[r0,#4]
;;;536      driver->peripheral->rx_dma_config.stream->M0AR  = (uint32_t)data;
00006c  6820              LDR      r0,[r4,#0]
00006e  6b00              LDR      r0,[r0,#0x30]
000070  60c7              STR      r7,[r0,#0xc]
;;;537      driver->peripheral->rx_dma_config.stream->CR   |= DMA_SxCR_EN;
000072  6820              LDR      r0,[r4,#0]
000074  6b00              LDR      r0,[r0,#0x30]
000076  6800              LDR      r0,[r0,#0]
000078  f0400101          ORR      r1,r0,#1
00007c  6820              LDR      r0,[r4,#0]
00007e  6b00              LDR      r0,[r0,#0x30]
000080  6001              STR      r1,[r0,#0]
;;;538      USART_DMACmd( driver->peripheral->port, USART_DMAReq_Rx, ENABLE );
000082  6821              LDR      r1,[r4,#0]
000084  2201              MOVS     r2,#1
000086  6808              LDR      r0,[r1,#0]
000088  2140              MOVS     r1,#0x40
00008a  f7fffffe          BL       USART_DMACmd
;;;539      
;;;540      if ( timeout > 0 )
00008e  b12e              CBZ      r6,|L15.156|
;;;541      {
;;;542    #ifndef NO_MICO_RTOS
;;;543        err = mico_rtos_get_semaphore( &driver->rx_complete, timeout );
000090  4631              MOV      r1,r6
000092  f1040008          ADD      r0,r4,#8
000096  f7fffffe          BL       mico_rtos_get_semaphore
00009a  4680              MOV      r8,r0
                  |L15.156|
;;;544    #else
;;;545        driver->rx_complete = false;
;;;546        int delay_start = 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){
;;;549            return kTimeoutErr;
;;;550          }
;;;551        }    
;;;552    #endif
;;;553      }
;;;554      return err;
00009c  4640              MOV      r0,r8
;;;555    }
00009e  e8bd81f0          POP      {r4-r8,pc}
;;;556    
                          ENDP


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

                  thread_wakeup PROC
;;;634    #ifndef NO_MICO_RTOS
;;;635    static void thread_wakeup(void *arg)
000000  4605              MOV      r5,r0
;;;636    {
;;;637      platform_uart_driver_t* driver = arg;
000002  462c              MOV      r4,r5
;;;638      
;;;639      while(1){
000004  e00e              B        |L16.36|
                  |L16.6|
;;;640        if( mico_rtos_get_semaphore( driver->sem_wakeup, 1000) != kNoErr )
000006  f44f717a          MOV      r1,#0x3e8
00000a  6960              LDR      r0,[r4,#0x14]
00000c  f7fffffe          BL       mico_rtos_get_semaphore
000010  b140              CBZ      r0,|L16.36|
;;;641        {
;;;642          platform_gpio_irq_enable( driver->peripheral->pin_rx, IRQ_TRIGGER_FALLING_EDGE, RX_PIN_WAKEUP_handler, driver );
000012  6821              LDR      r1,[r4,#0]
000014  4623              MOV      r3,r4
000016  4a04              LDR      r2,|L16.40|
000018  6888              LDR      r0,[r1,#8]
00001a  2102              MOVS     r1,#2
00001c  f7fffffe          BL       platform_gpio_irq_enable
;;;643          platform_mcu_powersave_enable( );
000020  f7fffffe          BL       platform_mcu_powersave_enable
                  |L16.36|
000024  e7ef              B        |L16.6|
;;;644        }
;;;645      }
;;;646    }
;;;647    #endif
                          ENDP

000026  0000              DCW      0x0000
                  |L16.40|
                          DCD      RX_PIN_WAKEUP_handler

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

                  uart_alternate_functions
000000  07070708          DCB      0x07,0x07,0x07,0x08
000004  08080000          DCB      0x08,0x08,0x00,0x00
                  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
                  uart_irq_vectors
000038  25262734          DCB      0x25,0x26,0x27,0x34
00003c  3547              DCB      0x35,0x47

;*** 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 ***
