struct op_sample *op_cpu_buffer_read_entry(struct op_entry *entry, int cpu)
{
struct ring_buffer_event *e;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35)
e = ring_buffer_consume(op_ring_buffer_read, cpu, NULL, NULL);
#else
e = ring_buffer_consume(op_ring_buffer_read, cpu, NULL);
#endif
if (e)
goto event;
if (ring_buffer_swap_cpu(op_ring_buffer_read,
op_ring_buffer_write,
cpu))
return NULL;
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,35)
e = ring_buffer_consume(op_ring_buffer_read, cpu, NULL, NULL);
#else
e = ring_buffer_consume(op_ring_buffer_read, cpu, NULL);
#endif
if (e)
goto event;
return NULL;
event:
entry->event = e;
entry->sample = ring_buffer_event_data(e);
entry->size = (ring_buffer_event_length(e) - sizeof(struct op_sample))
/ sizeof(entry->sample->data[0]);
entry->data = entry->sample->data;
return entry->sample;
}
static void _stp_ring_buffer_consume(struct _stp_iterator *iter)
{
_stp_ring_buffer_iterator_increment(iter);
_stp_ring_buffer_disable_cpu();
#ifdef STAPCONF_RING_BUFFER_LOST_EVENTS
ring_buffer_consume(_stp_relay_data.rb, iter->cpu, &iter->ts, NULL);
#else
ring_buffer_consume(_stp_relay_data.rb, iter->cpu, &iter->ts);
#endif
_stp_ring_buffer_enable_cpu();
atomic_dec(&iter->nr_events);
}
static int trace_test_buffer_cpu(struct trace_buffer *buf, int cpu)
{
struct ring_buffer_event *event;
struct trace_entry *entry;
unsigned int loops = 0;
while ((event = ring_buffer_consume(buf->buffer, cpu, NULL, NULL))) {
entry = ring_buffer_event_data(event);
/*
* The ring buffer is a size of trace_buf_size, if
* we loop more than the size, there's something wrong
* with the ring buffer.
*/
if (loops++ > trace_buf_size) {
printk(KERN_CONT ".. bad ring buffer ");
goto failed;
}
if (!trace_valid_entry(entry)) {
printk(KERN_CONT ".. invalid entry %d ",
entry->type);
goto failed;
}
}
return 0;
failed:
/* disable tracing */
tracing_disabled = 1;
printk(KERN_CONT ".. corrupted trace buffer .. ");
return -1;
}
static int trace_test_buffer_cpu(struct trace_array *tr, int cpu)
{
struct ring_buffer_event *event;
struct trace_entry *entry;
unsigned int loops = 0;
while ((event = ring_buffer_consume(tr->buffer, cpu, NULL))) {
entry = ring_buffer_event_data(event);
if (loops++ > trace_buf_size) {
printk(KERN_CONT ".. bad ring buffer ");
goto failed;
}
if (!trace_valid_entry(entry)) {
printk(KERN_CONT ".. invalid entry %d ",
entry->type);
goto failed;
}
}
return 0;
failed:
tracing_disabled = 1;
printk(KERN_CONT ".. corrupted trace buffer .. ");
return -1;
}
/**
* buffer_get_sample - remove a hardware latency sample from the ring buffer
* @sample: Pre-allocated storage for the sample
*
* This retrieves a hardware latency sample from the global circular buffer
*/
static struct sample *buffer_get_sample(struct sample *sample)
{
struct ring_buffer_event *e = NULL;
struct sample *s = NULL;
unsigned int cpu = 0;
if (!sample)
return NULL;
mutex_lock(&ring_buffer_mutex);
for_each_online_cpu(cpu) {
e = ring_buffer_consume(ring_buffer, cpu, NULL);
if (e)
break;
}
if (e) {
s = ring_buffer_event_data(e);
memcpy(sample, s, sizeof(struct sample));
} else
sample = NULL;
mutex_unlock(&ring_buffer_mutex);
return sample;
}
OSStatus platform_uart_receive_bytes( platform_uart_driver_t* driver, uint8_t* data_in, uint32_t expected_data_size, uint32_t timeout_ms )
{
OSStatus err = kNoErr;
//platform_mcu_powersave_disable();
require_action_quiet( ( driver != NULL ) && ( data_in != NULL ) && ( expected_data_size != 0 ), exit, err = kParamErr);
mico_rtos_get_semaphore( &driver->rx_complete, 0 );
if ( driver->rx_buffer != NULL)
{
while ( expected_data_size != 0 )
{
uint32_t transfer_size = MIN( driver->rx_buffer->size / 2, expected_data_size );
/* Set rx_size and wait in rx_complete semaphore until data reaches rx_size or timeout occurs */
driver->last_receive_result = kNoErr;
driver->rx_size = transfer_size;
/* Check if ring buffer already contains the required amount of data. */
if ( transfer_size > ring_buffer_used_space( driver->rx_buffer ) )
{
err = mico_rtos_get_semaphore( &driver->rx_complete, timeout_ms );
/* Reset rx_size to prevent semaphore being set while nothing waits for the data */
driver->rx_size = 0;
if( err != kNoErr )
goto exit;
}else {
driver->rx_size = 0;
}
err = driver->last_receive_result;
expected_data_size -= transfer_size;
// Grab data from the buffer
do
{
uint8_t* available_data;
uint32_t bytes_available;
ring_buffer_get_data( driver->rx_buffer, &available_data, &bytes_available );
bytes_available = MIN( bytes_available, transfer_size );
memcpy( data_in, available_data, bytes_available );
transfer_size -= bytes_available;
data_in = ( (uint8_t*) data_in + bytes_available );
ring_buffer_consume( driver->rx_buffer, bytes_available );
} while ( transfer_size != 0 );
}
}
else
{
err = receive_bytes( driver, data_in, expected_data_size, timeout_ms );
}
exit:
//platform_mcu_powersave_enable();
return err;
}
struct op_sample *op_cpu_buffer_read_entry(struct op_entry *entry, int cpu)
{
struct ring_buffer_event *e;
e = ring_buffer_consume(op_ring_buffer, cpu, NULL, NULL);
if (!e)
return NULL;
entry->event = e;
entry->sample = ring_buffer_event_data(e);
entry->size = (ring_buffer_event_length(e) - sizeof(struct op_sample))
/ sizeof(entry->sample->data[0]);
entry->data = entry->sample->data;
return entry->sample;
}
int UART_Recv(u8 *recvBuf, u32 bufLen, u32 timeOut)
{
while (bufLen != 0){
uint32_t transfer_size = MIN(rx_buffer.size / 2, bufLen);
/* Check if ring buffer already contains the required amount of data. */
if ( transfer_size > ring_buffer_used_space( &rx_buffer ) ) {
/* Set rx_size and wait in rx_complete semaphore until data reaches rx_size or timeout occurs */
rx_size = transfer_size;
if ( mico_rtos_get_semaphore( &rx_complete, timeOut ) != 0 ){
rx_size = 0;
return -1;
}
/* Reset rx_size to prevent semaphore being set while nothing waits for the data */
rx_size = 0;
}
bufLen -= transfer_size;
// Grab data from the buffer
do
{
uint8_t* available_data;
uint32_t bytes_available;
ring_buffer_get_data( &rx_buffer, &available_data, &bytes_available );
bytes_available = MIN( bytes_available, transfer_size );
memcpy( recvBuf, available_data, bytes_available );
transfer_size -= bytes_available;
recvBuf = ( (uint8_t*) recvBuf + bytes_available );
ring_buffer_consume( &rx_buffer, bytes_available );
} while ( transfer_size != 0 );
}
if ( bufLen != 0 ) {
return -1;
}
else{
return 0;
}
}
wiced_result_t ring_buffer_read( wiced_ring_buffer_t* ring_buffer, uint8_t* data, uint32_t data_length, uint32_t* number_of_bytes_read )
{
uint32_t max_bytes_to_read;
uint32_t i;
uint32_t head = ring_buffer->head;
wiced_assert("Bad args", ring_buffer != NULL && data != NULL && number_of_bytes_read != NULL);
max_bytes_to_read = MIN(data_length, ring_buffer_used_space(ring_buffer));
if ( max_bytes_to_read != 0 )
{
for ( i = 0; i != max_bytes_to_read; i++, ( head = ( head + 1 ) % ring_buffer->size ) )
{
data[ i ] = ring_buffer->buffer[ head ];
}
ring_buffer_consume( ring_buffer, max_bytes_to_read );
}
*number_of_bytes_read = max_bytes_to_read;
return WICED_SUCCESS;
}
int ring_buffer_read( ring_buffer_t* ring_buffer, uint8_t* data, uint32_t data_length, uint32_t* number_of_bytes_read )
{
uint32_t max_bytes_to_read;
uint32_t i;
uint32_t head;
head = ring_buffer->head;
max_bytes_to_read = MIN(data_length, ring_buffer_used_space(ring_buffer));
if ( max_bytes_to_read != 0 )
{
for ( i = 0; i != max_bytes_to_read; i++, ( head = ( head + 1 ) % ring_buffer->size ) )
{
data[ i ] = ring_buffer->buffer[ head ];
}
ring_buffer_consume( ring_buffer, max_bytes_to_read );
}
*number_of_bytes_read = max_bytes_to_read;
return 0;
}
OSStatus MicoUartRecv( mico_uart_t uart, void* data, uint32_t size, uint32_t timeout )
{
#if RING_BUFF_ON
if (uart_interfaces[uart].rx_buffer != NULL)
{
while (size != 0)
{
uint32_t transfer_size = MIN(uart_interfaces[uart].rx_buffer->size / 2, size);
/* Check if ring buffer already contains the required amount of data. */
if ( transfer_size > ring_buffer_used_space( uart_interfaces[uart].rx_buffer ) )
{
/* Set rx_size and wait in rx_complete semaphore until data reaches rx_size or timeout occurs */
uart_interfaces[uart].rx_size = transfer_size;
#ifndef NO_MICO_RTOS
if ( mico_rtos_get_semaphore( &uart_interfaces[uart].rx_complete, timeout) != kNoErr )
{
uart_interfaces[uart].rx_size = 0;
return kTimeoutErr;
}
#else
uart_interfaces[uart].rx_complete = false;
int delay_start = mico_get_time_no_os();
while(uart_interfaces[uart].rx_complete == false){
if(mico_get_time_no_os() >= delay_start + timeout && timeout != MICO_NEVER_TIMEOUT){
uart_interfaces[uart].rx_size = 0;
return kTimeoutErr;
}
}
#endif
/* Reset rx_size to prevent semaphore being set while nothing waits for the data */
uart_interfaces[uart].rx_size = 0;
}
size -= transfer_size;
// Grab data from the buffer
do
{
uint8_t* available_data;
uint32_t bytes_available;
//platform_log("uart receive 03");
ring_buffer_get_data( uart_interfaces[uart].rx_buffer, &available_data, &bytes_available );
bytes_available = MIN( bytes_available, transfer_size );
memcpy( data, available_data, bytes_available );
transfer_size -= bytes_available;
data = ( (uint8_t*) data + bytes_available );
ring_buffer_consume( uart_interfaces[uart].rx_buffer, bytes_available );
} while ( transfer_size != 0 );
}
if ( size != 0 )
{
return kGeneralErr;
}
else
{
return kNoErr;
}
}
else
{
return platform_uart_receive_bytes( uart, data, size, timeout );
}
#else
return platform_uart_receive_bytes( uart, data, size, timeout );
#endif
// return kNoErr;
}
platform_result_t platform_uart_receive_bytes( platform_uart_driver_t* driver, uint8_t* data_in, uint32_t expected_data_size, uint32_t timeout_ms )
{
/*The following is a temporary implemenration of the UART*/
platform_result_t result = PLATFORM_SUCCESS;
wiced_assert( "bad argument", ( driver != NULL ) && ( data_in != NULL ) && ( expected_data_size != 0 ) );
if ( driver->rx_buffer != NULL )
{
while ( expected_data_size != 0 )
{
uint32_t transfer_size = MIN( driver->rx_buffer->size / 2, expected_data_size );
/* Check if ring buffer already contains the required amount of data. */
if ( transfer_size > ring_buffer_used_space( driver->rx_buffer ) )
{
wwd_result_t wwd_result;
/* Set rx_size and wait in rx_complete semaphore until data reaches rx_size or timeout occurs */
WICED_DISABLE_INTERRUPTS( );
driver->last_receive_result = PLATFORM_SUCCESS;
driver->rx_size = transfer_size;
WICED_ENABLE_INTERRUPTS( );
wwd_result = host_rtos_get_semaphore( &driver->rx_complete, timeout_ms, WICED_TRUE );
/* Reset rx_size to prevent semaphore being set while nothing waits for the data */
WICED_DISABLE_INTERRUPTS( );
driver->rx_size = 0;
WICED_ENABLE_INTERRUPTS( );
if ( wwd_result == WWD_TIMEOUT )
{
/* Semaphore timeout. breaks from the while loop */
result = PLATFORM_TIMEOUT;
break;
}
else
{
/* No timeout. retrieve result */
result = driver->last_receive_result;
}
}
expected_data_size -= transfer_size;
// Grab data from the buffer
do
{
uint8_t* available_data;
uint32_t bytes_available;
ring_buffer_get_data( driver->rx_buffer, &available_data, &bytes_available );
bytes_available = MIN( bytes_available, transfer_size );
memcpy( data_in, available_data, bytes_available );
transfer_size -= bytes_available;
data_in = ( (uint8_t*) data_in + bytes_available );
ring_buffer_consume( driver->rx_buffer, bytes_available );
} while ( transfer_size != 0 );
}
return result;
}
else
{
return result;
}
}
OSStatus platform_uart_receive_bytes( platform_uart_driver_t* driver, uint8_t* data_in, uint32_t expected_data_size, uint32_t timeout_ms )
{
OSStatus err = kNoErr;
uint32_t transfer_size;
//platform_mcu_powersave_disable();
require_action_quiet( ( driver != NULL ) && ( data_in != NULL ) && ( expected_data_size != 0 ), exit, err = kParamErr);
require_action_quiet( driver->rx_ring_buffer != NULL , exit, err = kUnsupportedErr);
while ( expected_data_size != 0 )
{
transfer_size = MIN(driver->rx_ring_buffer->size / 2, expected_data_size);
/* Check if ring buffer already contains the required amount of data. */
if ( transfer_size > ring_buffer_used_space( driver->rx_ring_buffer ) )
{
/* Set rx_size and wait in rx_complete semaphore until data reaches rx_size or timeout occurs */
driver->rx_size = transfer_size;
#ifndef NO_MICO_RTOS
if ( mico_rtos_get_semaphore( &driver->rx_complete, timeout_ms ) != kNoErr )
{
driver->rx_size = 0;
err = kTimeoutErr;
goto exit;
}
/* Reset rx_size to prevent semaphore being set while nothing waits for the data */
driver->rx_size = 0;
#else
driver->rx_complete = false;
int delay_start = mico_get_time_no_os();
while(driver->rx_complete == false) {
if(mico_get_time_no_os() >= delay_start + timeout_ms && timeout_ms != MICO_NEVER_TIMEOUT) {
driver->rx_size = 0;
err = kTimeoutErr;
goto exit;
}
}
driver->rx_size = 0;
#endif
}
expected_data_size -= transfer_size;
// Grab data from the buffer
do
{
uint8_t* available_data;
uint32_t bytes_available;
ring_buffer_get_data( driver->rx_ring_buffer, &available_data, &bytes_available );
bytes_available = MIN( bytes_available, transfer_size );
memcpy( data_in, available_data, bytes_available );
transfer_size -= bytes_available;
data_in = ( (uint8_t*)data_in + bytes_available );
ring_buffer_consume( driver->rx_ring_buffer, bytes_available );
}
while ( transfer_size != 0 );
}
require_action( expected_data_size == 0, exit, err = kReadErr);
exit:
//platform_mcu_powersave_enable();
return err;
}
platform_result_t platform_uart_receive_bytes( platform_uart_driver_t* driver, uint8_t* data_in, uint32_t expected_data_size, uint32_t timeout_ms )
{
UNUSED_PARAMETER(driver);
UNUSED_PARAMETER(data_in);
UNUSED_PARAMETER(expected_data_size);
UNUSED_PARAMETER(timeout_ms);
if ( driver->rx_ring_buffer != NULL )
{
while ( expected_data_size != 0 )
{
uint32_t transfer_size = MIN(driver->rx_ring_buffer->size / 2, expected_data_size);
/* Check if ring buffer already contains the required amount of data. */
if ( transfer_size > ring_buffer_used_space( driver->rx_ring_buffer ) )
{
/* Set rx_size and wait in rx_complete semaphore until data reaches rx_size or timeout occurs */
driver->rx_transfer_size = transfer_size;
if ( host_rtos_get_semaphore( &driver->rx_dma_complete, timeout_ms, WICED_FALSE ) != WWD_SUCCESS )
{
driver->rx_transfer_size = 0;
return PLATFORM_TIMEOUT;
}
/* Reset rx_size to prevent semaphore being set while nothing waits for the data */
driver->rx_transfer_size = 0;
}
expected_data_size -= transfer_size;
// Grab data from the buffer
do
{
uint8_t* available_data;
uint32_t bytes_available;
ring_buffer_get_data( driver->rx_ring_buffer, &available_data, &bytes_available );
bytes_available = MIN( bytes_available, transfer_size );
memcpy( data_in, available_data, bytes_available );
transfer_size -= bytes_available;
data_in = ( (uint8_t*)data_in + bytes_available );
ring_buffer_consume( driver->rx_ring_buffer, bytes_available );
}
while ( transfer_size != 0 );
}
if ( expected_data_size != 0 )
{
return PLATFORM_ERROR;
}
else
{
return PLATFORM_SUCCESS;
}
}
else
{
/* TODO: need to implement this */
return PLATFORM_UNSUPPORTED;
}
}
static OSStatus FUartRecv( platform_uart_driver_t* driver, void* data, uint32_t size, uint32_t timeout )
{
if ( driver->rx_buffer != NULL )
{
while (size != 0)
{
uint32_t transfer_size = MIN( driver->rx_buffer->size/2, size );
/* Check if ring buffer already contains the required amount of data. */
if ( transfer_size > ring_buffer_used_space( driver->rx_buffer ) )
{
/* Set rx_size and wait in rx_complete semaphore until data reaches rx_size or timeout occurs */
driver->rx_size = transfer_size;
#ifndef NO_MICO_RTOS
if ( mico_rtos_get_semaphore( &driver->rx_complete, timeout) != kNoErr )
{
driver->rx_size = 0;
return kTimeoutErr;
}
#else
driver->rx_complete = false;
int delay_start = mico_get_time_no_os();
while(driver->rx_complete == false){
if(mico_get_time_no_os() >= delay_start + timeout && timeout != MICO_NEVER_TIMEOUT){
driver->rx_size = 0;
return kTimeoutErr;
}
}
#endif
/* Reset rx_size to prevent semaphore being set while nothing waits for the data */
driver->rx_size = 0;
}
size -= transfer_size;
// Grab data from the buffer
do
{
uint8_t* available_data;
uint32_t bytes_available;
ring_buffer_get_data( driver->rx_buffer, &available_data, &bytes_available );
bytes_available = MIN( bytes_available, transfer_size );
memcpy( data, available_data, bytes_available );
transfer_size -= bytes_available;
data = ( (uint8_t*) data + bytes_available );
ring_buffer_consume( driver->rx_buffer, bytes_available );
} while ( transfer_size != 0 );
}
if ( size != 0 )
{
return kGeneralErr;
}
else
{
return kNoErr;
}
}
else
{
mico_thread_msleep(timeout);
return kNoMemoryErr;
}
}
