/**
* This function is for deregistering the client for logging algo tuning
* variable
*
* @param[in] client_handle_ptr client handle pointer
* @return ADSPResult, retuns success or failure
*
*/
ADSPResult algo_data_logging_deregister(algo_data_logging_t *algo_data_logging_ptr,
uint32_t client_handle)
{
client_list_t *cur_client_list_ptr = NULL;
client_list_t *prev_client_list_ptr = NULL;
algo_log_client_info_t *log_info_ptr = NULL;
bool_t is_dereg_done = FALSE;
cur_client_list_ptr = (client_list_t *)algo_data_logging_ptr->client_list_ptr;
if(NULL == cur_client_list_ptr)
{
MSG_1(MSG_SSID_QDSP6, DBG_ERROR_PRIO, "Algo Log: client list ptr is NULL, failed to dereg client :0x%lx",
client_handle);
return ADSP_EFAILED;
}
//find the client and remove the same
while(cur_client_list_ptr)
{
log_info_ptr = (algo_log_client_info_t *)cur_client_list_ptr->element;
if(log_info_ptr->client_handle == client_handle)
{
if(NULL == prev_client_list_ptr) // If first node is removed
{
algo_data_logging_ptr->client_list_ptr = cur_client_list_ptr->next;
}
else
{
prev_client_list_ptr->next = cur_client_list_ptr->next;
}
// commit the existing log buffer
algo_log_commit_buf(log_info_ptr);
qurt_elite_memory_free(log_info_ptr->log_buf_ptr);
qurt_elite_memory_free(log_info_ptr);
qurt_elite_memory_free(cur_client_list_ptr);
is_dereg_done = TRUE;
break;
}
prev_client_list_ptr = cur_client_list_ptr;
cur_client_list_ptr = cur_client_list_ptr->next;
}
if(!is_dereg_done)
{
MSG_1(MSG_SSID_QDSP6, DBG_ERROR_PRIO, "Algo Log: failed to dereg client :0x%lx, not in client list",
client_handle);
return ADSP_EFAILED;
}
algo_data_logging_ptr->client_counter--;
return ADSP_EOK;
}
ADSPResult HwdDevCfg_GetVirtAddress(qurt_mem_region_t *pQmem_region, uint32 phyAddr, uint32 regSize, uint32 *pVirtAddr)
{
ADSPResult status = ADSP_EOK;
qurt_mem_pool_t hwio_pool;
memset((void *)pQmem_region,0,sizeof(qurt_mem_region_t));
size_t page_size = (size_t) regSize;
qurt_mem_cache_mode_t cache_attribs = QURT_MEM_CACHE_NONE;
qurt_perm_t perm = (qurt_perm_t) (QURT_PERM_READ | QURT_PERM_WRITE | QURT_PERM_EXECUTE);
if ( ADSP_EOK != (status = qurt_mem_map_static_query((qurt_addr_t *)pVirtAddr,
phyAddr,
page_size,
cache_attribs,
perm)))
{
if(ADSP_EOK != (status = qurt_mem_pool_attach("ADSP_DRIVER_POOL", &hwio_pool)))
{
MSG(MSG_SSID_QDSP6, DBG_ERROR_PRIO, "HwdDevCfg_GetVirtAddress: attach to driver pool failed\n");
}
else
{
qurt_mem_region_attr_t hwio_attr;
qurt_mem_region_attr_init( &hwio_attr);
qurt_mem_region_attr_set_cache_mode( &hwio_attr, QURT_MEM_CACHE_NONE);
qurt_mem_region_attr_set_mapping ( &hwio_attr, QURT_MEM_MAPPING_PHYS_CONTIGUOUS );
qurt_mem_region_attr_set_physaddr ( &hwio_attr, phyAddr );
/* create the memory region */
if (ADSP_EOK != (status = qurt_mem_region_create(pQmem_region,
regSize,
hwio_pool,
&hwio_attr )))
{
MSG(MSG_SSID_QDSP6, DBG_ERROR_PRIO, "HwdDevCfg_GetVirtAddress: create mem region failed\n");
return status;
}
if (ADSP_EOK != (status = qurt_mem_region_attr_get(*pQmem_region, &hwio_attr)))
{
MSG(MSG_SSID_QDSP6, DBG_ERROR_PRIO, "HwdDevCfg_GetVirtAddress: get mem region attr failed\n");
}
else
{
unsigned int addr = 0;
qurt_mem_region_attr_get_virtaddr(&hwio_attr, &addr);
*pVirtAddr = (uint32) addr;
}
}
}
else
{
MSG_1(MSG_SSID_QDSP6, DBG_HIGH_PRIO, "HwdDevCfg_GetVirtAddress: already mampped statically 0x%x\n", (unsigned int)phyAddr);
}
return status;
}
/*===========================================================================
FUNCTION DSMBIT_BIT_COPY
DESCRIPTION
Copies bitwise from one item into another.
DEPENDENCIES
Only copies from one item into one item are supported.
PARAMETERS
src_ptr - DSM item to copy from
dst_ptr - DSM item to copy into
src_offset - Bit offset to start copying from
dst_offset - Bit offset to start copying into
len - Number of bits to copy
RETURN VALUE
Number of bits copied
SIDE_EFFECTS
===========================================================================*/
uint16 dsmbiti_bit_copy
(
dsm_item_type* src_ptr,
dsm_item_type* dst_ptr,
uint16 src_offset,
uint16 dst_offset,
uint16 len,
const char * file,
uint32 line
)
{
int i;
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/* Sanity check on the item pointers */
if ( (src_ptr == NULL) || (dst_ptr == NULL) )
{
MSG(MSG_SSID_DFLT, MSG_LEGACY_ERROR,"NULL dsm item pointer");
return 0;
}
/* Sanity chack that we copy within the items */
if ( ((((src_offset + len) / 8) + 1) > src_ptr->used)
||
((((dst_offset + len) / 8) + 1) > DSMI_SIZE(dst_ptr) ) )
{
MSG_1(MSG_SSID_DFLT, MSG_LEGACY_ERROR,"Copy length %d exceeds item size", len);
return 0;
}
/* Copy each bit */
for ( i=0; i<len; i++ )
{
/* Null out destination bit */
*(dst_ptr->data_ptr + ((dst_offset + i) / 8)) &=
~dsmbit_bit_copy_mask[(dst_offset + i) % 8];
/* Or source bit into the very spot */
*(dst_ptr->data_ptr + ((dst_offset + i) / 8)) |=
((*(src_ptr->data_ptr + ((src_offset + i) / 8))
& dsmbit_bit_copy_mask[(src_offset + i) % 8])
>> (7 - ((src_offset + i) % 8)))
<< (7 - ((dst_offset + i) % 8));
}
/* Update the destination item's used field */
dst_ptr->used = ((dst_offset + len) / 8) + (((dst_offset + len) % 8) * 1);
#ifdef FEATURE_DSM_MEM_CHK
dsmi_touch_item(dst_ptr,file,line);
#endif
return len;
}
/**
* This function deinitializes logging for algo tuning variables
*
*
*/
void algo_data_logging_deinit(algo_data_logging_t **algo_data_logging_pptr)
{
if(!(algo_data_logging_pptr && *algo_data_logging_pptr))
{
MSG(MSG_SSID_QDSP6, DBG_ERROR_PRIO, "Algo Log: Null pointer!");
}
else
{
if((*algo_data_logging_pptr)->client_counter)
{
MSG_1(MSG_SSID_QDSP6, DBG_ERROR_PRIO, "Algo Log: %u clients not yet deregistered, failed!",
(*algo_data_logging_pptr)->client_counter);
}
qurt_elite_memory_free(*algo_data_logging_pptr);
*algo_data_logging_pptr = NULL;
}
}
ADSPResult HwdDevCfg_DestoryVirtAddress(qurt_mem_region_t qmem_region)
{
ADSPResult status = ADSP_EOK;
if(qmem_region)
{
if(QURT_EOK != (status = qurt_mem_region_delete(qmem_region)))
{
MSG_1(MSG_SSID_QDSP6, DBG_ERROR_PRIO, "HwdDevCfg_DestoryVirtAddress: Failed to delete memory region [status:%d]", status);
}
}
else
{
MSG(MSG_SSID_QDSP6, DBG_ERROR_PRIO, "HwdDevCfg_DestoryVirtAddress: no qmem_region to destory");
}
return status;
}
/*=========================================================================*/
static void sns_init_once( void )
{
int i;
INT8U err;
OS_FLAGS flags = 0;
const sns_init_fcn init_ptrs[] = SNS_INIT_FUNCTIONS;
if ( SNS_SUCCESS != sns_heap_init()) {
MSG(MSG_SSID_SNS, DBG_ERROR_PRIO, "Sensors Heap Init failed, using Default heap ID");
sns_heap_id = QURT_ELITE_HEAP_DEFAULT;
}
sns_init_flag_grp = sns_os_sigs_create( SNS_INIT_FLAG_DONE, &err );
SNS_ASSERT(NULL != sns_init_flag_grp);
for( i = 0; NULL != init_ptrs[i]; i++ ) {
//MSG_1(MSG_SSID_QDSP6, DBG_HIGH_PRIO, "Sensors Init : %d", i);
if( SNS_SUCCESS != init_ptrs[i]() ) {
/* Handle error */
//MSG_1(MSG_SSID_QDSP6, DBG_HIGH_PRIO, "Sensors Init FAIL: %d", i);
sns_init_done();
}
while( !(SNS_INIT_FLAG_DONE & flags) ) {
/* Continue polling for the flag until module init is done */
flags = sns_os_sigs_pend( sns_init_flag_grp,
SNS_INIT_FLAG_DONE,
OS_FLAG_WAIT_SET_ANY,
0,
&err );
MSG_1(MSG_SSID_QDSP6, DBG_HIGH_PRIO, "Sensors Init : waiting(%x)", flags);
}
flags = 0;
}
MSG(MSG_SSID_QDSP6, DBG_HIGH_PRIO, "Sensors Init : ///////////init once completed///////////");
}
/*===========================================================================
FUNCTION diagcomm_smd_dsm_high_mem_event_cb
DESCRIPTION
This function gets triggered and disables flow, when the high item count
for DSM_DIAG_SMD_TX_ITEM_POOL is reached.
(DSM_DIAG_SMD_TX_ITEM_POOL is used by smd, to receive data.)
===========================================================================*/
static void diagcomm_smd_dsm_high_mem_event_cb (dsm_mempool_id_type pool_id,
dsm_mem_level_enum_type mem_level,
dsm_mem_op_enum_type mem_op)
{
uint32 flow_cnt = 0;
/* Check to be defensive */
if(pool_id != DSM_DIAG_SMD_TX_ITEM_POOL ||
mem_level != DSM_MEM_LEVEL_MANY ||
mem_op != DSM_MEM_OP_NEW)
return;
if (TRUE == bAllowFlow)
{
diagcomm_io_disable_flow( &diagcomm_io_conn[DIAGCOMM_PORT_SMD][DIAGCOMM_PORT_1] );
diagcomm_io_disable_flow( &diagcomm_io_conn[DIAGCOMM_PORT_SMD][DIAGCOMM_PORT_2] );
bAllowFlow = FALSE;
flow_cnt = diagcomm_incr_flow_ctrl_count(DIAGCOMM_PORT_SMD);
MSG_1(MSG_SSID_DIAG, MSG_LEGACY_HIGH, "diagcomm_smd_dsm_high_mem_event_cb: disabled flow (cnt=%d)", flow_cnt);
}
} /* diagcomm_smd_dsm_high_mem_event_cb */
/*===========================================================================
FUNCTION RFLL1X_SLEEP
DESCRIPTION
This function completes transition of RF hardware to sleep state by
turning off the Rx and Tx LDOs.
DEPENDENCIES
rfll1x_sleep() must have already been called.
RETURN VALUE
None
SIDE EFFECTS
None
===========================================================================*/
uint32 rfll1x_sleep //TODO_7600
(
rfll_device_desc_type *dev_desc, /*lint -e818 Device descriptor
could be declared as const */
const void *user_data_ptr, /* Pointer to user data passed into
callback */
rfcom_cb_handler_type cb_handler /* Call back handler or NULL */
)
{
rf_chain_state_type *rf_chain_0 = &rf_chain_status[rfcom_to_path[RFCOM_TRANSCEIVER_0]];
rf_chain_state_type *rf_chain_1 = &rf_chain_status[rfcom_to_path[RFCOM_RECEIVER_1]];
rf_chain_state_type *dev_chain = &rf_chain_status[ rfcom_to_path[dev_desc->device]];
if (user_data_ptr==NULL)
{
// TODO_7600: CDMA 1X flag parameter (FALSE do nothing)
return 0;
}
/* Put RF to sleep */
if( dev_desc->device == RFCOM_RECEIVER_DIV || dev_desc->device == RFCOM_RECEIVER_DUAL)
{
if(rf_chain_0->rf_state == RF_STATE_CDMA_RX)
rf_sleep_cdma1x(RFCOM_TRANSCEIVER_0);
else
MSG_1( MSG_SSID_RF, MSG_LEGACY_ERROR,
"rfll1x_sleep, RF Primary Chain in invalid state: %d",
rf_chain_0->rf_state );
if(rf_chain_1->rf_state == RF_STATE_CDMA_RX ||
#ifndef RF_HAS_BYPASS_RF_STATE_GPS_CHECK
rf_chain_1->rf_state == RF_STATE_GPS ||
#endif
rf_chain_1->rf_state == RF_STATE_DIVERSITY)
rf_sleep_cdma1x(RFCOM_RECEIVER_1);
else
MSG_1( MSG_SSID_RF, MSG_LEGACY_ERROR,
"rfll1x_sleep, RF Secondary Chain in invalid state: %d",
rf_chain_1->rf_state);
}
else if(dev_desc->device == RFCOM_TRANSCEIVER_0)
{
if(dev_chain->rf_state == RF_STATE_CDMA_RXTX)
{
rf_tx_shutdown();
rf_sleep_cdma1x(dev_desc->device);
}
else if(dev_chain->rf_state == RF_STATE_CDMA_RX)
{
rf_sleep_cdma1x(dev_desc->device);
}
else
MSG_2( MSG_SSID_RF, MSG_LEGACY_ERROR,
"rfll1x_sleep, RF Chain:%d in invalid state: %d",
dev_desc->device,dev_chain->rf_state);
}
else
{
if(dev_chain->rf_state == RF_STATE_CDMA_RX)
rf_sleep_cdma1x(dev_desc->device);
else
MSG_2( MSG_SSID_RF, MSG_LEGACY_ERROR,
"rfll1x_sleep, RF Chain:%d in invalid state: %d",
dev_desc->device,dev_chain->rf_state);
}
return 0;
} /* rfll1x_stay_asleep() */
/**
* This function does the logging for algo tuning variables
*
* @param[in] log_buffer Ptr to the buffer to be logged.
* @param[in] log_size logging size in bytes
* @param[in] client_handle_ptr client handle pointer
*
*/
ADSPResult algo_data_log_now(algo_data_logging_t *algo_data_logging_ptr,
int8_t *log_buffer,
uint32_t log_size,
uint32_t client_handle)
{
uint32_t log_buf_size;
uint32_t log_size_used = 0;
int8_t *log_buf_ptr = NULL;
algo_log_client_info_t *algo_log_client_info_ptr = NULL;
if(NULL == (algo_log_client_info_ptr = algo_find_client_info(algo_data_logging_ptr, client_handle)))
{
MSG_1(MSG_SSID_QDSP6, DBG_ERROR_PRIO, "Algo Log: algo client is not found 0x%lx", client_handle);
return ADSP_EFAILED;
}
/* Validate the log size */
if(log_size != algo_log_client_info_ptr->log_size)
{
MSG_2(MSG_SSID_QDSP6, DBG_ERROR_PRIO,
"Algo Log: log size registered %ld is different from log size %ld being logged",
algo_log_client_info_ptr->log_size, log_size);
return ADSP_EFAILED;
}
if(NULL != algo_log_client_info_ptr->log_buf_ptr)
{
log_buf_size = algo_log_client_info_ptr->log_buf_size;
log_size_used = algo_log_client_info_ptr->log_size_used;
log_buf_ptr = algo_log_client_info_ptr->log_buf_ptr;
if((log_size_used + log_size) <= log_buf_size)
{
//dest buffer will have the free space of (log_buf_size-log_size_used)
memscpy(log_buf_ptr + (log_size_used), (log_buf_size - log_size_used), log_buffer,
log_size);
/* Update used log buffer size */
algo_log_client_info_ptr->log_size_used += log_size;
/* If all the log buffer size has been used, do commit the log buffer. */
if(algo_log_client_info_ptr->log_size_used >= (log_buf_size))
{
algo_log_commit_buf(algo_log_client_info_ptr);
}
}
else
{
algo_log_commit_buf(algo_log_client_info_ptr);
//dest buffer will have the free space of (log_buf_size-log_size_used)
/* algo_log_client_info_ptr->log_size_used is reset to 0 inside commit func */
memscpy(log_buf_ptr, log_buf_size, log_buffer, log_size);
/* Update used log buffer size */
algo_log_client_info_ptr->log_size_used += log_size;
}
}
return ADSP_EOK;
}
/**
* This function is for registering for logging algo tuning variabls
*
* @param[in] log_interval_in_ms logging interval in milli sec
* @param[in] log_size logging size in bytes
* @param[in] client_handle_ptr pointer to the client handle
* pointer
* @return ADSPResult, retuns success or failure
*
*/
ADSPResult algo_data_logging_register(algo_data_logging_t *algo_data_logging_ptr,
uint16_t log_interval_in_ms,
uint16_t log_commit_interval_in_ms,
uint32_t log_size,
uint32_t log_code,
uint32_t *client_handle_ptr)
{
client_list_t *list_node = NULL;
algo_log_client_info_t *algo_log_client_info_ptr = NULL;
int8_t *log_buf_ptr = NULL;
client_list_t **client_list_pptr = NULL;
uint32_t log_size_for_max_algo_interval;
// return failure if log size is zero
if(!log_size)
{
MSG_1(MSG_SSID_QDSP6, DBG_ERROR_PRIO, "Algo Log: Non zero logging size need to be provided %ld",
log_size);
return ADSP_EUNSUPPORTED;
}
// return failure if the log interval size exceeds max log interval
if(log_interval_in_ms > log_commit_interval_in_ms)
{
MSG_1(MSG_SSID_QDSP6, DBG_ERROR_PRIO, "Algo Log: log interval is greater than the max log interval allowed %d",
log_interval_in_ms);
return ADSP_EUNSUPPORTED;
}
log_size_for_max_algo_interval = ((log_commit_interval_in_ms / log_interval_in_ms) * log_size);
// Adding client node
list_node = (client_list_t *)qurt_elite_memory_malloc((sizeof(client_list_t)), QURT_ELITE_HEAP_DEFAULT);
if(NULL == list_node)
{
MSG(MSG_SSID_QDSP6, DBG_ERROR_PRIO, "Out of memory creating client list node.");
return ADSP_ENOMEMORY;
}
//update the client info here
algo_log_client_info_ptr = (algo_log_client_info_t *)qurt_elite_memory_malloc(
sizeof(algo_log_client_info_t), QURT_ELITE_HEAP_DEFAULT);
if(NULL == algo_log_client_info_ptr)
{
MSG(MSG_SSID_QDSP6, DBG_ERROR_PRIO, "Out of memory creating afe algo client list node.");
qurt_elite_memory_free(list_node);
return ADSP_ENOMEMORY;
}
list_node->element = (void*)algo_log_client_info_ptr;
list_node->next = NULL;
memset(algo_log_client_info_ptr, 0, sizeof(algo_log_client_info_t));
log_buf_ptr = (int8_t *)qurt_elite_memory_malloc(log_size_for_max_algo_interval, QURT_ELITE_HEAP_DEFAULT);
if(NULL == log_buf_ptr)
{
MSG(MSG_SSID_QDSP6, DBG_ERROR_PRIO, " Error allocating memory for algo log buffer");
qurt_elite_memory_free(list_node);
qurt_elite_memory_free(algo_log_client_info_ptr);
return ADSP_ENOMEMORY;
}
algo_log_client_info_ptr->client_handle = (uint32_t)algo_log_client_info_ptr;
algo_log_client_info_ptr->log_buf_ptr = log_buf_ptr;
algo_log_client_info_ptr->log_buf_size = log_size_for_max_algo_interval;
algo_log_client_info_ptr->log_interval_in_ms = log_interval_in_ms;
algo_log_client_info_ptr->log_size = log_size;
algo_log_client_info_ptr->log_size_used = 0;
algo_log_client_info_ptr->log_code = (elite_qxdm_log_code)log_code;
client_list_pptr = (client_list_t **)&algo_data_logging_ptr->client_list_ptr;
// Adding the client to the front
if(*client_list_pptr)
{
list_node->next = *client_list_pptr;
}
*client_list_pptr = list_node;
*client_handle_ptr = algo_log_client_info_ptr->client_handle;
algo_data_logging_ptr->client_counter++;
return ADSP_EOK;
}
/*===========================================================================
FUNCTION DIAGCOMM_BUFFER_ENQUEUE_STREAM
DESCRIPTION
This function enqueues data onto the sio_tx_wmq depending on the current mode.
PARAMETERS
item_ptr - pointer to the DSM item that has to be enqueued
port_type - Control channel port type (SIO/SMD)
stream_id - Specifies which stream should the data be enqueued
RETURN VALUE
None
===========================================================================*/
void diagcomm_buffer_enqueue_stream( dsm_item_type ** item_ptr,
diagcomm_port_type port_type,
uint8 stream_id )
{
dsm_item_type * dsm_dequeue_item_ptr = NULL;
dsm_item_type * dsm_chained_ptr = NULL;
uint32 dsm_cnt = 0;
uint32 dsm_dropped_cnt = 0;
uint32 bytes_dropped_cnt = 0;
uint32 dsm_alloc_cnt = 0;
uint32 bytes_alloc_cnt = 0;
uint8 stream_index = 0;
if( (stream_id < DIAG_MIN_STREAM_ID) || (stream_id > DIAG_MAX_STREAM_ID) )
{
MSG_1(MSG_SSID_DIAG, MSG_LEGACY_ERROR, "diagcomm_buffer_enqueue_stream - Invalid stream_id (%d)", stream_id);
return;
}
stream_index = DIAG_ID_TO_INDEX(stream_id);
/* Dequeue and count dropped DSMs only in Buffered Cir mode. */
if( diag_tx_mode[stream_index].mode == DIAG_TX_MODE_BUFFERED_CIR )
{
dsm_cnt = diag_buffering_pool_used_cnt( stream_id );
diag_tx_mode[stream_index].cur_dsm_cnt[port_type] = dsm_cnt; //Save dsm count read
if( DIAG_BUFFERED_DSM_CNT_TO_BYTES(dsm_cnt) >= diag_tx_mode[stream_index].buffered_many_bytes_mark )
{
if( port_type == DIAGCOMM_PORT_SMD )
dsm_dequeue_item_ptr = diagcomm_io_dequeue_rx_wmq( &diagcomm_io_conn[port_type][DIAGCOMM_PORT_1] );
else if( port_type == DIAGCOMM_PORT_SIO )
dsm_dequeue_item_ptr = diagcomm_io_dequeue_tx_wmq( &diagcomm_io_conn[port_type][DIAGCOMM_PORT_1], 0 );
ASSERT( dsm_dequeue_item_ptr != NULL );
//bytes_dropped_cnt += dsm_length_packet( dsm_dequeue_item_ptr );
dsm_chained_ptr = dsm_dequeue_item_ptr;
do
{
dsm_dropped_cnt += 1;
bytes_dropped_cnt += dsm_chained_ptr->used;
// Point to next DSM in the chain
dsm_chained_ptr = dsm_chained_ptr->pkt_ptr;
// Continue to count chained DSMs
} while( dsm_chained_ptr != NULL );
//} while( (dsm_chained_ptr != NULL) && (dsm_chained_ptr->data_ptr != NULL) && (dsm_chained_ptr->used > 0) );
// Update dropped count health statistics
if( (diag_tx_mode[stream_index].dsm_dropped_cnt + dsm_dropped_cnt) >= MAX_VALUE_UINT32 )
diag_tx_mode[stream_index].dsm_dropped_cnt = MAX_VALUE_UINT32;
else
diag_tx_mode[stream_index].dsm_dropped_cnt += dsm_dropped_cnt;
if( (diag_tx_mode[stream_index].byte_dropped_cnt + bytes_dropped_cnt) >= MAX_VALUE_UINT32 )
diag_tx_mode[stream_index].byte_dropped_cnt = MAX_VALUE_UINT32;
else
diag_tx_mode[stream_index].byte_dropped_cnt += bytes_dropped_cnt;
// Free the dequeued DSM item, including it's chained items
dsm_free_packet( &dsm_dequeue_item_ptr );
}
}
/* We don't drop/dequeue DSMs in Buffered Threshold mode. Just count alloc
counts and enqueue. */
if( (diag_tx_mode[stream_index].mode == DIAG_TX_MODE_BUFFERED_THRESH) ||
(diag_tx_mode[stream_index].mode == DIAG_TX_MODE_BUFFERED_CIR) )
{
//bytes_alloc_cnt += dsm_length_packet( *item_ptr );
dsm_chained_ptr = *item_ptr;
do
{
dsm_alloc_cnt += 1;
bytes_alloc_cnt += dsm_chained_ptr->used;
// Point to next DSM in the chain
dsm_chained_ptr = dsm_chained_ptr->pkt_ptr;
// Continue to count chained DSMs
} while( dsm_chained_ptr != NULL );
// Update alloc count health statistics
if( (diag_tx_mode[stream_index].dsm_alloc_cnt + dsm_alloc_cnt) >= MAX_VALUE_UINT32 )
diag_tx_mode[stream_index].dsm_alloc_cnt = MAX_VALUE_UINT32;
else
diag_tx_mode[stream_index].dsm_alloc_cnt += dsm_alloc_cnt;
if( (diag_tx_mode[stream_index].byte_alloc_cnt + bytes_alloc_cnt) >= MAX_VALUE_UINT32 )
diag_tx_mode[stream_index].byte_alloc_cnt = MAX_VALUE_UINT32;
else
diag_tx_mode[stream_index].byte_alloc_cnt += bytes_alloc_cnt;
#ifdef DIAG_SIO_SUPPORT
if( port_type == DIAGCOMM_PORT_SMD )
dsm_enqueue (diagcomm_io_conn[port_type][DIAGCOMM_PORT_1].open_params.sio_params.params.rx_queue, item_ptr);
else if( port_type == DIAGCOMM_PORT_SIO )
dsm_enqueue (diagcomm_io_conn[port_type][DIAGCOMM_PORT_1].open_params.sio_params.params.tx_queue, item_ptr);
#elif defined (DIAG_SMDL_SUPPORT)
dsm_enqueue (diagcomm_io_conn[port_type][DIAGCOMM_PORT_1].open_params.smdl_params.tx_queue, item_ptr);
#endif
}
else
{
/* Streaming mode; Just enqueue it. */
#ifdef DIAG_SIO_SUPPORT
if( port_type == DIAGCOMM_PORT_SMD )
dsm_enqueue (diagcomm_io_conn[port_type][DIAGCOMM_PORT_1].open_params.sio_params.params.rx_queue, item_ptr);
else if( port_type == DIAGCOMM_PORT_SIO )
dsm_enqueue (diagcomm_io_conn[port_type][DIAGCOMM_PORT_1].open_params.sio_params.params.tx_queue, item_ptr);
#elif defined (DIAG_SMDL_SUPPORT)
dsm_enqueue (diagcomm_io_conn[port_type][DIAGCOMM_PORT_1].open_params.smdl_params.tx_queue, item_ptr);
#endif
}
} /* diagcomm_buffer_enqueue_stream */
