void platform_uart_irq( platform_uart_driver_t* driver )
{
uint32_t status = usart_get_status( driver->peripheral->peripheral );
uint32_t mask = usart_get_interrupt_mask( driver->peripheral->peripheral );
Pdc* pdc_register = usart_get_pdc_base( driver->peripheral->peripheral );
/* ENDTX flag is set when Tx DMA transfer is done
*/
if ( ( mask & US_IMR_ENDTX ) && ( status & US_CSR_ENDTX ) )
{
pdc_packet_t dma_packet;
/* ENDTX is cleared when TCR or TNCR is set to a non-zero value, which effectively
* starts another Tx DMA transaction. To work around this, disable Tx before
* performing a dummy Tx init.
*/
pdc_disable_transfer( usart_get_pdc_base( driver->peripheral->peripheral ), PERIPH_PTCR_TXTDIS );
dma_packet.ul_addr = (uint32_t)0;
dma_packet.ul_size = (uint32_t)1;
pdc_tx_init( usart_get_pdc_base( USART1 ), &dma_packet, NULL );
/* Notifies waiting thread that Tx DMA transfer is complete */
host_rtos_set_semaphore( &driver->tx_dma_complete, WICED_TRUE );
}
/* ENDRX flag is set when RCR is 0. RNPR and RNCR values are then copied into
* RPR and RCR, respectively, while the Tx tranfer continues. We now need to
* prepare RNPR and RNCR for the next iteration.
*/
if ( ( mask & US_IMR_ENDRX ) && ( status & US_CSR_ENDRX ) )
{
pdc_register->PERIPH_RNPR = (uint32_t)driver->rx_ring_buffer->buffer;
pdc_register->PERIPH_RNCR = (uint32_t)driver->rx_ring_buffer->size;
}
/* RXRDY interrupt is triggered and flag is set when a new character has been
* received but not yet read from the US_RHR. When this interrupt executes,
* the DMA engine already read the character out from the US_RHR and RXRDY flag
* is no longer asserted. The code below updates the ring buffer parameters
* to keep them current
*/
if ( mask & US_CSR_RXRDY )
{
driver->rx_ring_buffer->tail = driver->rx_ring_buffer->size - pdc_register->PERIPH_RCR;
// Notify thread if sufficient data are available
if ( ( driver->rx_transfer_size > 0 ) && ( ring_buffer_used_space( driver->rx_ring_buffer ) >= driver->rx_transfer_size ) )
{
host_rtos_set_semaphore( &driver->rx_dma_complete, WICED_TRUE );
driver->rx_transfer_size = 0;
}
}
}
void wwd_thread_notify( void )
{
/* just wake up the main thread and let it deal with the data */
if ( wwd_inited == WICED_TRUE )
{
(void) host_rtos_set_semaphore( &wwd_transceive_semaphore, WICED_FALSE ); /* Ignore return - not much can be done about failure */
}
}
/**
* Informs WWD of an interrupt
*
* This function should be called from the SDIO/SPI interrupt function
* and usually indicates newly received data is available.
* It wakes the WWD Thread, forcing it to check the send/receive
*
*/
void wwd_thread_notify_irq( void )
{
wwd_bus_interrupt = WICED_TRUE;
/* just wake up the main thread and let it deal with the data */
if ( wwd_inited == WICED_TRUE )
{
(void) host_rtos_set_semaphore( &wwd_transceive_semaphore, WICED_TRUE ); /* ignore failure since there is nothing that can be done about it in a ISR */
}
}
/** Terminates the WWD Thread
*
* Sets a flag then wakes the WWD Thread to force it to terminate.
*
*/
void wwd_thread_quit( void )
{
wwd_result_t result;
/* signal main thread and wake it */
wwd_thread_quit_flag = WICED_TRUE;
result = host_rtos_set_semaphore( &wwd_transceive_semaphore, WICED_FALSE );
if ( result == WWD_SUCCESS )
{
/* Wait for the WWD thread to end */
host_rtos_join_thread( &wwd_thread );
(void) host_rtos_delete_terminated_thread( &wwd_thread ); /* Ignore return - not much can be done about failure */
}
}
wwd_result_t external_write_wifi_firmware_and_nvram_image( void )
{
if ( currently_downloading == 0 )
{
wwd_result_t result;
result = wwd_bus_write_wifi_firmware_image( );
if ( result != WWD_SUCCESS )
{
return result;
}
return wwd_bus_write_wifi_nvram_image( );
}
host_rtos_set_semaphore( &download_ready_semaphore, WICED_FALSE );
host_rtos_get_semaphore( &downloading_semaphore, NEVER_TIMEOUT, WICED_FALSE );
return WWD_SUCCESS;
}
void platform_uart_irq( platform_uart_driver_t* driver )
{
platform_uart_port_t* uart = (platform_uart_port_t*) driver->interface->uart_base;
uint8_t data=0;
while (Chip_UART_GetLineStatus(uart) & UART_LSR_RDR) {
Chip_UART_ReceiveByte(uart,&data);
ring_buffer_write( driver->rx_buffer,&data, 1 );
}
// Notify thread if sufficient data are available
if ( ( driver->rx_size > 0 ) && ( ring_buffer_used_space( driver->rx_buffer ) >= driver->rx_size ) )
{
host_rtos_set_semaphore( &driver->rx_complete, WICED_TRUE );
driver->rx_size = 0;
}
}
static void* wwd_handle_apsta_event( const wwd_event_header_t* event_header, const uint8_t* event_data, /*@returned@*/ void* handler_user_data )
{
UNUSED_PARAMETER( event_header );
UNUSED_PARAMETER( event_data );
UNUSED_PARAMETER( handler_user_data );
if ( (wwd_interface_t) event_header->interface != WWD_AP_INTERFACE)
{
return handler_user_data;
}
if ( ( ( event_header->event_type == (wwd_event_num_t) WLC_E_LINK ) &&
( event_header->interface == WWD_AP_INTERFACE ) ) ||
( event_header->event_type == WLC_E_IF ) )
{
wwd_result_t result;
result = host_rtos_set_semaphore( &wwd_wifi_sleep_flag, WICED_FALSE );
wiced_assert( "failed to post AP link semaphore", result == WWD_SUCCESS );
REFERENCE_DEBUG_ONLY_VARIABLE( result );
}
return handler_user_data;
}
void finish_download( void )
{
host_rtos_set_semaphore( &downloading_semaphore, WICED_FALSE );
host_rtos_deinit_semaphore( &downloading_semaphore );
currently_downloading = 0;
}
wiced_result_t wiced_rtos_set_semaphore( wiced_semaphore_t* semaphore )
{
return host_rtos_set_semaphore( (host_semaphore_type_t*) semaphore, host_platform_is_in_interrupt_context( ) );
}
