void ccci_exception_info_passed_pre(void)
{
#if defined(__MODEM_CCCI_EXIST__)&& !defined(__MODEM_CARD__)
CCCI_BUFF_T *buff;
qbm_gpd *p_first_gpd, *p_last_gpd;
kal_uint32 gpd_num;
// ensure in the exception state
if(INT_QueryExceptionStatus() == KAL_FALSE) return;
//- Already init in ccci_exception_handshake
//- ccci_init(CCCI_CONTROL_CHANNEL, ccci_except_ack);
//- ccci_init(CCCI_CONTROL_CHANNEL_ACK, ccci_except_ack);
buff = CCCIDEV_GET_QBM_DATAPTR(ccci_except_polling_gpd_tx);
buff->data[0] = MD_EX_MAGIC;
buff->data[1] = CCMSG_ID_EXCEPTION_REC_OK;
buff->channel = CCCI_CONTROL_CHANNEL;
buff->reserved = MD_EX_REC_OK_CHK_ID;
ccci_debug_add_seq(buff, CCCI_DEBUG_ASSERT_BIT); // add ccci seq
kal_mem_cpy((void*)(buff+1), ex_log_ptr, sizeof(EX_LOG_T));
QBM_DES_SET_DATALEN(ccci_except_polling_gpd_tx, sizeof(CCCI_BUFF_T) + sizeof(EX_LOG_T));
QBM_DES_SET_DATALEN(ccci_except_polling_gpd_tx->p_data_tbd, sizeof(CCCI_BUFF_T) + sizeof(EX_LOG_T));
qbm_cal_set_checksum((kal_uint8 *)ccci_except_polling_gpd_tx);
qbm_cal_set_checksum((kal_uint8 *)ccci_except_polling_gpd_tx->p_data_tbd);
QBM_CACHE_FLUSH(ccci_except_polling_gpd_tx, sizeof(qbm_gpd));
QBM_CACHE_FLUSH(ccci_except_polling_gpd_tx->p_data_tbd, sizeof(qbm_gpd));
QBM_CACHE_FLUSH(buff, sizeof(CCCI_BUFF_T) + sizeof(EX_LOG_T));
// TODO:Need to revise the API, shall use exception API (after channle reset flow is done)
#ifdef SWITCH_TO_EXCEPTION_IO
p_first_gpd = p_last_gpd = ccci_except_polling_gpd_tx;
ccci_except_set_gpd(CCCI_CONTROL_CHANNEL, p_first_gpd, p_last_gpd);
gpd_num = 0;
do{
ccci_except_hif_st(CCCI_CONTROL_CHANNEL);
ccci_except_poll_gpd(CCCI_CONTROL_CHANNEL, (void **)&p_first_gpd, (void **)&p_last_gpd, &gpd_num);
}while(0 == gpd_num);
ex_set_step_logging(EX_AUTO_STEP); //0x45
CCCIDEV_RST_CCCI_COMM_GPD_LIST(p_first_gpd, p_last_gpd);
#else
ccci_exception_info_write_result = ccci_polling_io(CCCI_CONTROL_CHANNEL, ccci_except_polling_gpd_tx, KAL_TRUE);
CCCIDEV_RST_CCCI_COMM_GPD_LIST(ccci_except_polling_gpd_tx, ccci_except_polling_gpd_tx);
#endif
ccci_exception_state = CCCI_EXPT_INFO_PASS_PRE_ST;
#ifdef WDT_ISR_TEST
wdt_test();
#endif
#endif
}
/*************************************************************************
* FUNCTION
* void ccci_exception_handshake
*
* DESCRIPTION
* This function .
*
* PARAMETERS
* channel - logical channel
* *
* RETURNS
* The address of the share memory of the input logical channel
*
*************************************************************************/
void ccci_exception_handshake(void){
#if defined(__MODEM_CCCI_EXIST__)&& !defined(__MODEM_CARD__)
CCCI_BUFF_T *buff;
kal_uint32 p_cache_aligned;
kal_uint32 gpd_num;
qbm_gpd *p_first_gpd, *p_last_gpd;
//kal_uint32 rcv_size = 0;
// ensure in the exception state
if(INT_QueryExceptionStatus() == KAL_FALSE)
return;
//we block here for debuging
//if(ccci_exception_state != CCCI_EXPT_CLEAR_CH_ST) while(1);
//- Avoid to use kal_mem_cpy
//- HW bug
ccci_init(CCCI_CONTROL_CHANNEL, ccci_except_ack);
ccci_init(CCCI_CONTROL_CHANNEL_ACK, ccci_except_ack);
// exception only have single thread, need to do polling mode
/* initialize polling mode GPD */
ASSERT(CCCI_EXCEPT_POLLING_MODE_BUF_SZ >= 2*CPU_CACHE_LINE_SIZE);
/*make p_gpd aligned to CPU_CACHE_LINE_SIZE_MASK*/
p_cache_aligned = (kal_uint32)g_ccci_expect_polling_buf_tx;
if(p_cache_aligned&CPU_CACHE_LINE_SIZE_MASK) {
p_cache_aligned = ((kal_uint32)(g_ccci_expect_polling_buf_tx)&~CPU_CACHE_LINE_SIZE_MASK);
p_cache_aligned += CPU_CACHE_LINE_SIZE;
}
// The reason + QBM_HEAD_SIZE is for ROME E1, cldma needs to record this buff whether is cacheable or non-cacheable
ccci_except_polling_gpd_tx = (qbm_gpd *)(p_cache_aligned + QBM_HEAD_SIZE);
CCCIDEV_RST_CCCI_COMM_GPD_LIST(ccci_except_polling_gpd_tx, ccci_except_polling_gpd_tx);
//format Rx GPD
p_cache_aligned = (kal_uint32)g_ccci_expect_polling_buf_rx;
if(p_cache_aligned&CPU_CACHE_LINE_SIZE_MASK) {
p_cache_aligned = ((kal_uint32)(g_ccci_expect_polling_buf_rx)&~CPU_CACHE_LINE_SIZE_MASK);
p_cache_aligned += CPU_CACHE_LINE_SIZE;
}
// The reason + QBM_HEAD_SIZE is for ROME E1, cldma needs to record this buff whether is cacheable or non-cacheable
ccci_except_polling_gpd_rx = (qbm_gpd *)(p_cache_aligned + QBM_HEAD_SIZE);
CCCIDEV_RST_CCCI_COMM_GPD_LIST(ccci_except_polling_gpd_rx, ccci_except_polling_gpd_rx);
//format Rx 2nd GPD
p_cache_aligned = (kal_uint32)g_ccci_expect_polling_buf_rx2;
if(p_cache_aligned&CPU_CACHE_LINE_SIZE_MASK) {
p_cache_aligned = ((kal_uint32)(g_ccci_expect_polling_buf_rx2)&~CPU_CACHE_LINE_SIZE_MASK);
p_cache_aligned += CPU_CACHE_LINE_SIZE;
}
// The reason + QBM_HEAD_SIZE is for ROME E1, cldma needs to record this buff whether is cacheable or non-cacheable
ccci_except_polling_gpd_rx2 = (qbm_gpd *)(p_cache_aligned + QBM_HEAD_SIZE);
CCCIDEV_RST_CCCI_COMM_GPD_LIST(ccci_except_polling_gpd_rx2, ccci_except_polling_gpd_rx2);
//step 0. config rx gpd next pointer
QBM_DES_SET_NEXT(ccci_except_polling_gpd_rx, ccci_except_polling_gpd_rx2);
//step 1. send TX handshake pkt
buff = CCCIDEV_GET_QBM_DATAPTR(ccci_except_polling_gpd_tx);
buff->data[0] = MD_EX_MAGIC;
buff->data[1] = CCMSG_ID_EXCEPTION_CHECK;
buff->channel = CCCI_CONTROL_CHANNEL;
buff->reserved = MD_EX_CHK_ID;
ccci_debug_add_seq(buff, CCCI_DEBUG_ASSERT_BIT); // add ccci seq
QBM_DES_SET_DATALEN(ccci_except_polling_gpd_tx, sizeof(CCCI_BUFF_T));
QBM_DES_SET_DATALEN(ccci_except_polling_gpd_tx->p_data_tbd, sizeof(CCCI_BUFF_T));
qbm_cal_set_checksum((kal_uint8 *)ccci_except_polling_gpd_tx);
qbm_cal_set_checksum((kal_uint8 *)ccci_except_polling_gpd_tx->p_data_tbd);
QBM_CACHE_FLUSH(ccci_except_polling_gpd_tx, sizeof(qbm_gpd));
QBM_CACHE_FLUSH(ccci_except_polling_gpd_tx->p_data_tbd, sizeof(qbm_gpd));
QBM_CACHE_FLUSH(buff, sizeof(CCCI_BUFF_T));
ex_set_step_logging(EX_AUTO_STEP); //0x41
//step 2. polling echoed rx handshake pkt (need two GPD, one for tail)
// TODO:Need to revise the API, shall use exception API (after channle reset flow is done)
#ifdef SWITCH_TO_EXCEPTION_IO
p_first_gpd = p_last_gpd = ccci_except_polling_gpd_tx;
ccci_except_set_gpd(CCCI_CONTROL_CHANNEL, p_first_gpd, p_last_gpd);
gpd_num = 0;
do{
ccci_except_hif_st(CCCI_CONTROL_CHANNEL);
ccci_except_poll_gpd(CCCI_CONTROL_CHANNEL, (void **)&p_first_gpd, (void **)&p_last_gpd, &gpd_num);
}while(0 == gpd_num);
CCCIDEV_RST_CCCI_COMM_GPD_LIST(p_first_gpd, p_last_gpd);
ex_set_step_logging(EX_AUTO_STEP); //0x42
p_first_gpd = ccci_except_polling_gpd_rx;
p_last_gpd = ccci_except_polling_gpd_rx2;
do{
ccci_except_set_gpd(CCCI_CONTROL_CHANNEL_ACK, p_first_gpd, p_last_gpd);
gpd_num = 0;
do{
ccci_except_hif_st(CCCI_CONTROL_CHANNEL_ACK);
ccci_except_poll_gpd(CCCI_CONTROL_CHANNEL_ACK, (void **)&p_first_gpd, (void **)&p_last_gpd, &gpd_num);
}while(0 == gpd_num);
buff = CCCIDEV_GET_QBM_DATAPTR(ccci_except_polling_gpd_rx);
//rcv_size = CCCIDEV_GET_QBM_DATALEN(ccci_except_polling_gpd_rx); // FIXME
QBM_CACHE_INVALID(buff, sizeof(CCCI_BUFF_T));
ccci_debug_check_seq(buff); // check ccci seq
if (buff->reserved == MD_EX_CHK_ID){
ex_set_step_logging(EX_AUTO_STEP); //0x43
ccci_exception_handshake_done = KAL_TRUE;
CCCIDEV_RST_CCCI_COMM_GPD_LIST(p_first_gpd, p_last_gpd);
ccci_except_set_gpd(CCCI_CONTROL_CHANNEL_ACK, p_first_gpd, p_last_gpd); //reload to CCCI_CONTROL_CHANNEL_ACK
break;
}
else
{
//dump date
ex_fire_extern_step_logging(0xFFFFFFFF);
ex_fire_extern_step_logging(buff->data[0]);
ex_fire_extern_step_logging(buff->data[1]);
ex_fire_extern_step_logging(buff->channel);
ex_fire_extern_step_logging(buff->reserved);
ex_fire_extern_step_logging(0xFFFFFFFF);
}
CCCIDEV_RST_CCCI_COMM_GPD_LIST(p_first_gpd, p_last_gpd);
}while(1);
#else
ccci_exception_check_write_result = ccci_polling_io(CCCI_CONTROL_CHANNEL, ccci_except_polling_gpd_tx, KAL_TRUE);
CCCIDEV_RST_CCCI_COMM_GPD_LIST(ccci_except_polling_gpd_tx, ccci_except_polling_gpd_tx);
while(CCCI_SUCCESS == (ccci_exception_handshake_done = ccci_polling_io(CCCI_CONTROL_CHANNEL_ACK, ccci_except_polling_gpd_tx, KAL_FALSE))){
buff = CCCIDEV_GET_QBM_DATAPTR(ccci_except_polling_gpd_tx);
QBM_CACHE_INVALID(buff, sizeof(CCCI_BUFF_T));
ccci_debug_check_seq(buff); // check ccci seq
if (buff->reserved == MD_EX_CHK_ID){
CCCIDEV_RST_CCCI_COMM_GPD_LIST(ccci_except_polling_gpd_tx, ccci_except_polling_gpd_tx);
break;
}
CCCIDEV_RST_CCCI_COMM_GPD_LIST(ccci_except_polling_gpd_tx, ccci_except_polling_gpd_tx);
}
#endif
ex_set_step_logging(EX_AUTO_STEP); //0x44
ccci_exception_state = CCCI_EXPT_HANDSHAKE_ST;
#ifdef CCCI_EXCETION_PRE_TEST
ccci_exception_info_passed_pre();
#endif
#endif
}
/*!
* Callback function with packet information to process the IP datagram filtered.
* Reply TCP RST packet to the sender of the garbage TCP SYN packet.
*
* @param info_p [IN] Related information of filtered out GPDs.
* @param context [IN] A context specified while registering the filter.
* @param filter_id [IN] Corresponding registered filter ID.
* @param head_gpd [IN] Pointer head of the GPD list for the IP datagram filtered.
* @param tail_gpd [IN] Pointer tail of the GPD list for the IP datagram filtered.
* @param length [IN] Bytes of buffers used in the GPD list.
*/
void pfm_ipc_dl_filter_with_info_cb(
ipc_filter_info_t *info_p,
void *context,
kal_int32 filter_id,
qbm_gpd *head_gpd,
qbm_gpd *tail_gpd,
kal_uint32 length)
{
ipc_pkt_t ipc_pkt;
qbm_gpd *ul_gpd;
qbm_gpd *bd;
kal_uint8 *p_data;
kal_uint8 next_header;
kal_uint8 *p_packet;
kal_uint8 *src_addr;
kal_uint8 *dst_addr;
kal_uint8 *p_tcp_header;
kal_uint32 ip_header_len;
kal_bool is_ipv4;
if (QBM_DES_GET_BDP(head_gpd)) {
bd = QBM_DES_GET_DATAPTR(head_gpd);
p_packet = QBM_DES_GET_DATAPTR(bd);
} else {
p_packet = QBM_DES_GET_DATAPTR(head_gpd);
}
if (IPC_HDR_IS_V4(p_packet)) {
is_ipv4 = KAL_TRUE;
if (IPC_HDR_PROT_TCP != IPC_HDR_V4_GET_PROTOCOL(p_packet)) {
/* Only For TCP packet */
goto free_gpd;
}
/* Send IPv4 TCP RST */
ip_header_len = (kal_uint32)IPC_HDR_V4_GET_IHL(p_packet);
p_tcp_header = p_packet + ip_header_len;
src_addr = IPC_HDR_V4_GET_DST_ADDR(p_packet);
dst_addr = IPC_HDR_V4_GET_SRC_ADDR(p_packet);
} else if (IPC_HDR_IS_V6(p_packet)) {
is_ipv4 = KAL_FALSE;
/* Check if it's TCP or not */
ip_header_len = IPC_HDR_V6_HEADER_SIZE; // fix
next_header = IPC_HDR_V6_GET_NH_TYPE(p_packet);
p_tcp_header = p_packet + ip_header_len;
while (1) {
if ((next_header == IPC_HDR_PROT_IPV6_HOP) ||
(next_header == IPC_HDR_PROT_IPV6_ROUTE) ||
(next_header == IPC_HDR_PROT_IPV6_DEST)) {
// next header
next_header = IPC_NE_GET_1B(p_tcp_header);
// move pointer to next ext header
p_tcp_header += (IPC_NE_GET_1B(p_tcp_header + 1) + 1)*8;
} else if (next_header == IPC_HDR_PROT_AH) {
// next header
next_header = IPC_NE_GET_1B(p_tcp_header);
// move pointer to next ext header
p_tcp_header += (IPC_NE_GET_1B(p_tcp_header + 1) + 2)*4;
} else if (next_header == IPC_HDR_PROT_TCP) {
/* Found TCP header ! */
break;
} else {
goto free_gpd;
}
}
src_addr = IPC_HDR_V6_GET_DST_ADDR(p_packet);
dst_addr = IPC_HDR_V6_GET_SRC_ADDR(p_packet);
} else {
goto free_gpd;
}
/* Allocate a UL GPD */
ul_gpd = QBM_ALLOC_ONE(QBM_TYPE_HIF_UL_TYPE);
if (!ul_gpd) {
PFM_ASSERT(KAL_FALSE);
}
bd = QBM_DES_GET_DATAPTR(ul_gpd);
p_data = QBM_DES_GET_DATAPTR(bd);
/* Fill IP/TCP header */
{
kal_uint16 sum16;
kal_uint32 tcp_header_len;
kal_uint32 total_len;
kal_uint8 *ip_header; // ip_header for output packet
kal_uint8 *tcp_header; // tcp_header for output packet
ip_header_len = ((is_ipv4) ? IPC_HDR_V4_HEADER_SIZE : IPC_HDR_V6_HEADER_SIZE);
tcp_header_len = IPC_HDR_TCP_HEADER_SIZE;
total_len = ip_header_len + tcp_header_len;
ip_header = p_data;
tcp_header = ip_header + ip_header_len;
/* Fill TCP header */
IPC_HDR_TCP_SET_SRC_PORT(tcp_header, IPC_HDR_TCP_GET_DST_PORT(p_tcp_header));
IPC_HDR_TCP_SET_DST_PORT(tcp_header, IPC_HDR_TCP_GET_SRC_PORT(p_tcp_header));
IPC_HDR_TCP_SET_SEQ_NUM(tcp_header, IPC_HDR_TCP_GET_ACK_NUM(p_tcp_header));
IPC_HDR_TCP_SET_ACK_NUM(tcp_header, IPC_HDR_TCP_GET_SEQ_NUM(p_tcp_header) + 1);
IPC_HDR_TCP_SET_OFFSET(tcp_header, IPC_HDR_TCP_HEADER_SIZE);
IPC_HDR_TCP_SET_RESERVED(tcp_header, 0);
IPC_HDR_TCP_SET_FLAGS(tcp_header, IPC_HDR_TCP_FLAG_RST | IPC_HDR_TCP_FLAG_ACK);
IPC_HDR_TCP_SET_WINDOW(tcp_header, 0);
IPC_HDR_TCP_SET_CHECKSUM(tcp_header, 0);
IPC_HDR_TCP_SET_URGENT_PTR(tcp_header, 0);
sum16 = ipc_calc_tcp_checksum( is_ipv4,
src_addr,
dst_addr,
tcp_header,
tcp_header_len);
IPC_HDR_TCP_SET_CHECKSUM(tcp_header, sum16);
if (is_ipv4) {
IPC_HDR_V4_RESET_VER_IHL_DSCP_ECN(ip_header);
IPC_HDR_V4_SET_DSCP(ip_header, IPC_HDR_V4_GET_DSCP(p_packet));
IPC_HDR_V4_SET_TOTAL_LENGTH(ip_header, total_len);
IPC_HDR_V4_SET_IDENTITY(ip_header, 0);
IPC_HDR_V4_SET_FLAGS(ip_header, 0);
IPC_HDR_V4_SET_FRAG_OFFSET(ip_header, 0);
IPC_HDR_V4_SET_TTL(ip_header, IPC_DEF_TTL);
IPC_HDR_V4_SET_PROTOCOL(ip_header, IPC_HDR_PROT_TCP);
IPC_HDR_V4_SET_HEADER_CHECKSUM(ip_header, 0);
IPC_HDR_V4_SET_SRC_ADDR(ip_header, src_addr);
IPC_HDR_V4_SET_DST_ADDR(ip_header, dst_addr);
sum16 = ipc_calc_ipv4_checksum(ip_header);
IPC_HDR_V4_SET_HEADER_CHECKSUM(ip_header, sum16);
} else {
IPC_HDR_V6_RESET_VER_TC_FL(ip_header);
IPC_HDR_V6_SET_TC(ip_header, IPC_HDR_V6_GET_TC(p_packet));
IPC_HDR_V6_SET_LENGTH(ip_header, total_len - ip_header_len/* TCP length */);
IPC_HDR_V6_SET_NH_TYPE(ip_header, IPC_HDR_PROT_TCP);
IPC_HDR_V6_SET_HOP_LIMIT(ip_header, IPC_DEF_TTL);
IPC_HDR_V6_SET_SRC_ADDR(ip_header, src_addr);
IPC_HDR_V6_SET_DST_ADDR(ip_header, dst_addr);
}
QBM_CACHE_FLUSH(ip_header, total_len);
QBM_DES_SET_DATALEN(bd, total_len);
qbm_cal_set_checksum(bd);
QBM_DES_SET_DATALEN(ul_gpd, total_len);
qbm_cal_set_checksum(ul_gpd);
}
kal_mem_set(&ipc_pkt, 0, sizeof(ipc_pkt));
ipc_pkt.isGPD = KAL_TRUE;
ipc_pkt.head = ul_gpd;
ipc_pkt.tail = ul_gpd;
ipc_send_ul_pkt(&ipc_pkt, NULL, info_p->ebi);
hif_trace_info(PFM_TR_GARBAGE_FILTER_REPLY_RST, 0, IPC_HDR_TCP_GET_DST_PORT(p_tcp_header));
free_gpd:
pfm_drop_packet_trace(info_p->ebi, p_packet, PFM_DROP_PACKET_DUMP_SIZE);
qbmt_dest_q(head_gpd, tail_gpd);
}
/*************************************************************************
* FUNCTION
* void ccci_boottrc_send_log
*
* DESCRIPTION
* This function is exported API to write bootup trace log in shared buffer.
*
* PARAMETERS
* index - bootup trace log key.
* value - bootup trace log value.
*
* RETURNS
* NA
*
*************************************************************************/
void ccci_boottrc_send_log(kal_uint32 index, kal_uint32 value)
{
#if defined(__MTK_TARGET__)
#ifdef __boottrc_performance_measurement__
kal_uint32 ccci_boottrc_start_time =0;
kal_uint32 ccci_boottrc_end_time =0;
kal_uint32 ccci_boottrc_dur_time =0;
ccci_boottrc_start_time = ccci_get_current_time();
#endif
qbm_gpd *p_gpd;
void *p_cache_aligned;
CCCI_BUFF_T *ccci_buff;
kal_bool hif_ret;
p_cache_aligned = ccci_boottrc_gpd;
if((kal_uint32)p_cache_aligned&CPU_CACHE_LINE_SIZE_MASK) {
p_cache_aligned = (void *)((kal_uint32)(ccci_boottrc_gpd)&~CPU_CACHE_LINE_SIZE_MASK);
p_cache_aligned += CPU_CACHE_LINE_SIZE;
}
p_gpd = (qbm_gpd *)p_cache_aligned;
//kal_mem_set(ccci_hs_buff, 0, CCCI_POLLING_MODE_BUF_SZ);
/* CCCI polling mode, QMU_BM is not ready yet*/
/* format ccci_hs_buff as GPD->BUFF format */
CCCI_INIT_RESET_DATALEN_EXTLEN((kal_uint32 *)p_gpd);
CCCI_INIT_RESET_COMMON_DATA((kal_uint32 *)p_gpd);
ccci_buff = QBM_DES_GET_DATAPTR(p_gpd);
ccci_buff->data[0] = 0x43525442; // pattern : "BTRC"
ccci_buff->data[1] = index;
ccci_buff->channel = CCCI_CONTROL_CHANNEL;
ccci_buff->reserved = value;
ccci_debug_add_seq(ccci_buff, CCCI_DEBUG_ASSERT_BIT); // add ccci seq
QBM_DES_SET_DATALEN(p_gpd, sizeof(CCCI_BUFF_T));
QBM_CACHE_FLUSH(ccci_buff, sizeof(CCCI_BUFF_T));
#if defined(__HIF_SDIO_SUPPORT__)
hif_ret = hifsdio_simple_send_gpd(0, p_gpd, CCCI_HS_POLLING_TIMEOUT);
#elif defined(__HIF_CLDMA_SUPPORT__)
hif_ret = hifcldma_simple_send_gpd(0, p_gpd, CCCI_HS_POLLING_TIMEOUT);
#elif defined(__CCIFCORE_SUPPORT__)
hif_ret = ccifc_simple_send_gpd(0, p_gpd, CCCI_HS_POLLING_TIMEOUT);
#endif
if(!hif_ret){
EXT_ASSERT(KAL_FALSE, hif_ret,0,0);
}
#ifdef __boottrc_performance_measurement__
ccci_boottrc_end_time = ccci_get_current_time();
ccci_boottrc_dur_time = ccci_get_duration(ccci_boottrc_start_time,ccci_boottrc_end_time);
ccci_boottrc_max_transmit_time = (ccci_boottrc_dur_time > ccci_boottrc_max_transmit_time)? ccci_boottrc_dur_time : ccci_boottrc_max_transmit_time;
ccci_boottrc_min_transmit_time = (ccci_boottrc_dur_time < ccci_boottrc_min_transmit_time)? ccci_boottrc_dur_time : ccci_boottrc_min_transmit_time;
ccci_boottrc_total_transmit_time += ccci_boottrc_dur_time;
ccci_boottrc_transmit_count++;
ccci_boottrc_avg_transmit_time = ccci_boottrc_total_transmit_time / ccci_boottrc_transmit_count;
// write to share memory
ccci_excep_dbg_logging_InHS2(CCCI_EXCEP_DBG_HS_BOOTTRC_WAIT_TIME, (void *)&ccci_boottrc_total_transmit_time);
#endif
#endif
}
/*************************************************************************
* FUNCTION
* ccci_ipc_send_msg
*
* DESCRIPTION
* This function is the internal api to send message
*
* PARAMETERS
* ipc_task_id -
* buffer_ptr -
* msg_size -
* wait_mode -
* message_to_head -
*
* RETURNS
* status - success/fail
*
*************************************************************************/
kal_bool ccci_ipc_send_msg(kal_uint32 ipc_task_id, void *buffer_ptr, kal_uint16 msg_size, kal_wait_mode wait_mode, kal_bool message_to_head)
{
kal_uint32 i, j ;
kal_uint32 retrieved_events = 0, orig_local_addr = 0 , orig_peer_addr = 0, update_buff_addr=0;
kal_int32 result = CCCI_SUCCESS;
ipc_ilm_t *temp_ipc_ilm = (ipc_ilm_t *)buffer_ptr;
ccci_io_request_t ior = {0};
CCCI_BUFF_T *p_ccci_buff;
kal_uint32 len = 0;
ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_TRA);
ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_TRA_ILM,
temp_ipc_ilm, temp_ipc_ilm->src_mod_id, temp_ipc_ilm->dest_mod_id,
temp_ipc_ilm->sap_id, temp_ipc_ilm->msg_id,
temp_ipc_ilm->local_para_ptr, temp_ipc_ilm->peer_buff_ptr);
/* get ext queue id from mapping table of task id - destnation*/
for (i = 0; i < MAX_CCCI_IPC_TASKS; i++)
{
if ( ccci_ipc_maptbl[i].task_id == ipc_task_id )
{
break;
}
}
/* get ext queue id from mapping table of task id - source*/
for (j = 0; j < MAX_CCCI_IPC_TASKS; j++)
{
if ( ccci_ipc_maptbl[j].task_id == temp_ipc_ilm->src_mod_id )
{
break;
}
}
/* check src mod id, if it's not defined in CCCI IPC, don't set used bit */
if(j >= MAX_CCCI_IPC_TASKS)
{
ccci_ipc_trace(CCCI_IPC_ERR, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_TASKID_ERROR, ipc_task_id, temp_ipc_ilm->src_mod_id);
return KAL_FALSE;
}
/* check if the extquque id can not be found */
if (i >= MAX_CCCI_IPC_TASKS)
{
ccci_ipc_trace(CCCI_IPC_ERR, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_TASKID_ERROR, ipc_task_id, temp_ipc_ilm->src_mod_id);
((CCCI_IPC_ILM_T*)buffer_ptr)->used = 0;
return KAL_FALSE;
}
/* check if the extquque id is to AP */
if ((ccci_ipc_maptbl[i].extq_id & AP_UINFY_ID_FLAG) == 0)
{
ccci_ipc_trace(CCCI_IPC_ERR, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_DESTID_ERROR, ipc_task_id);
((CCCI_IPC_ILM_T*)buffer_ptr)->used = 0;
return KAL_FALSE;
}
/* check if the ilm buffer is from ipc_msgsvc_allocate_ilm or not */
if (buffer_ptr != &ccci_ipc_ilm_arr[j].ipc_ilm){
ccci_ipc_trace(CCCI_IPC_ERR, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_ILM_ERROR);
return KAL_FALSE;
}
len = sizeof(CCCI_BUFF_T) + sizeof(ipc_ilm_t);
if (temp_ipc_ilm->local_para_ptr != NULL){
len+= temp_ipc_ilm->local_para_ptr->msg_len ;
}
if( temp_ipc_ilm->peer_buff_ptr != NULL){
len+= sizeof(peer_buff_struct)
+ temp_ipc_ilm->peer_buff_ptr->pdu_len
+ temp_ipc_ilm->peer_buff_ptr->free_header_space
+ temp_ipc_ilm->peer_buff_ptr->free_tail_space;
}
//assert if ilm size > CCCI_IPC_GPD size
EXT_ASSERT(len < CCCI_IPC_GPD_SIZE, len, CCCI_IPC_GPD_SIZE, 0);
/* Use critical section to protect ENTER */
CCCI_IPC_ENTER_CRITICAL_SECTION
if (KAL_TRUE == kal_query_systemInit()){ // polling mode
ior.first_gpd = ccci_ipc_ch.p_polling_gpd;
ior.last_gpd = ccci_ipc_ch.p_polling_gpd;
}
else{
#ifdef __SDIOC_PULL_Q_ENH_DL__
ior.num_gpd =
#endif
qbmt_alloc_q_no_tail(
CCCI_IPC_GPD_TYPE, /* type */
1, /* buff_num */
(void **)(&ior.first_gpd), /* pp_head */
(void **)(&ior.last_gpd)); /* pp_tail */
if(ior.first_gpd == NULL){
ccci_ipc_trace(CCCI_IPC_ERR, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_ALLOC_GPD_ERROR);
return KAL_FALSE;
}
}
//initialize GPD CCCI_Header content
p_ccci_buff = CCCIDEV_GET_QBM_DATAPTR(ior.first_gpd);
p_ccci_buff->data[1] = (kal_uint32)len;
p_ccci_buff->channel = (kal_uint32)ccci_ipc_ch.send_channel;
p_ccci_buff->reserved = (kal_uint32)ccci_ipc_maptbl[i].extq_id;
ccci_debug_add_seq(p_ccci_buff, CCCI_DEBUG_ASSERT_BIT); // add ccci seq
QBM_DES_SET_DATALEN(ior.first_gpd, p_ccci_buff->data[1]);
QBM_DES_SET_DATALEN(ior.first_gpd->p_data_tbd, p_ccci_buff->data[1]);
qbm_cal_set_checksum((kal_uint8 *)ior.first_gpd);
qbm_cal_set_checksum((kal_uint8 *)ior.first_gpd->p_data_tbd);
QBM_CACHE_FLUSH(ior.first_gpd, sizeof(qbm_gpd));
QBM_CACHE_FLUSH(ior.first_gpd->p_data_tbd, sizeof(qbm_gpd));
//copy ilm to GPD
temp_ipc_ilm->src_mod_id = ccci_ipc_maptbl[j].extq_id;
update_buff_addr = (kal_uint32)p_ccci_buff;
update_buff_addr += sizeof(CCCI_BUFF_T);
CCCI_KAL_MSG_TO_AP_MSG(temp_ipc_ilm->msg_id, temp_ipc_ilm->msg_id);
kal_mem_cpy((kal_uint8 *)update_buff_addr ,(kal_uint8 *)temp_ipc_ilm, sizeof(ipc_ilm_t));
if (temp_ipc_ilm->local_para_ptr != NULL){
//copy loca_para_struct to GPD
update_buff_addr += sizeof(ipc_ilm_t); //24 bytes
orig_local_addr = update_buff_addr;
kal_mem_cpy((kal_uint8 *)update_buff_addr,(kal_uint8 *)temp_ipc_ilm->local_para_ptr, temp_ipc_ilm->local_para_ptr->msg_len);
}
if( temp_ipc_ilm->peer_buff_ptr != NULL){
//copy peer buff_struct to GPD
if (temp_ipc_ilm->local_para_ptr != NULL){
update_buff_addr += temp_ipc_ilm->local_para_ptr->msg_len;//should be 4 bytes alignment??
}
else{
update_buff_addr += sizeof(ipc_ilm_t); //24 bytes
}
orig_peer_addr = update_buff_addr;
kal_mem_cpy((kal_uint8 *)update_buff_addr,(kal_uint8 *)temp_ipc_ilm->peer_buff_ptr,
sizeof(peer_buff_struct)
+ temp_ipc_ilm->peer_buff_ptr->pdu_len
+ temp_ipc_ilm->peer_buff_ptr->free_header_space
+ temp_ipc_ilm->peer_buff_ptr->free_tail_space);
}
free_local_para(temp_ipc_ilm->local_para_ptr);
temp_ipc_ilm->local_para_ptr = (local_para_struct *)orig_local_addr;//assign not NULL ptr to indicate there have content
free_peer_buff(temp_ipc_ilm->peer_buff_ptr);
temp_ipc_ilm->peer_buff_ptr = (peer_buff_struct *)orig_peer_addr;//assign not NULL ptr to indicate there have content
QBM_CACHE_FLUSH(p_ccci_buff, len);
if (KAL_TRUE == kal_query_systemInit()){ // polling mode
result = ccci_polling_io(ccci_ipc_ch.send_channel, ccci_ipc_ch.p_polling_gpd, KAL_TRUE);
CCCIDEV_RST_CCCI_COMM_GPD_LIST(ccci_ipc_ch.p_polling_gpd,ccci_ipc_ch.p_polling_gpd);
}
else{
result = ccci_ipc_ch.ccci_write_gpd(ccci_ipc_ch.send_channel, &ior, NULL);
if (KAL_INFINITE_WAIT == wait_mode && CCCI_SUCCESS == result){
/* Wait for feedabck by retrieve event */
kal_retrieve_eg_events(ccci_ipc_ch.event, 1 << i, KAL_AND_CONSUME, &retrieved_events, KAL_SUSPEND);
}
}
/* Exit critical section */
CCCI_IPC_EXIT_CRITICAL_SECTION
((CCCI_IPC_ILM_T*)buffer_ptr)->used = 0;
ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_TRA_CCCI,
p_ccci_buff->data[0], p_ccci_buff->data[1], p_ccci_buff->channel, p_ccci_buff->reserved);
ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_FUNC_PASS_TRA);
/* Finish */
if (result == CCCI_SUCCESS){
return KAL_TRUE;
}
else{
return KAL_FALSE;
}
}
