/*************************************************************************
* FUNCTION
* ipc_msgsvc_sendmsg_cb
*
* DESCRIPTION
* This function is the cb of sendmsg
*
* PARAMETERS
* bufp - ccci header
*
* RETURNS
* none
*
*************************************************************************/
void ccci_ipc_send_msg_cb(CCCI_CHANNEL_T channel, ccci_io_request_t* ior)
{
kal_uint32 i = 0;
ccci_io_request_t *current_ior = ior;
qbm_gpd *current_gpd;
ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_CB_FUNC_TRA);
while(current_ior != NULL){
current_gpd = current_ior->first_gpd ;
while( current_gpd != NULL){
CCCI_BUFF_T *bufp = CCCIDEV_GET_QBM_DATAPTR(current_gpd);
/* get task id from mapping table of ext queue id */
for (i = 0; i < MAX_CCCI_IPC_TASKS; i++)
{
if ( ccci_ipc_maptbl[i].extq_id == bufp->reserved )
{
break;
}
}
kal_set_eg_events(ccci_ipc_ch.event, (1 << i) , KAL_OR);
if (current_gpd == current_ior->last_gpd){
break;
}
else{
current_gpd = current_gpd->p_next;
}
}
qbmt_dest_q(ior->first_gpd, ior->last_gpd);
current_ior = current_ior->next_request;
}
ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_SEND_MSG_CB_FUNC_PASS_TRA);
}
/*!
* @function cccitty_ccci_ul_cb
* @brief uplink callback function register to CCCI, CCCI will callback during uplink process
* Context: HIF context e.x. MOD_SIODCORE
* process: <1> update the RGPD count in HIF
* <2> remove CCCI header, CCCI_BUFF_T
* <3> enqueue the RGPD to hif_ul_q_h
* or loopback, CCCITTY_LB_ENABLE
* <4> send MSG_ID_CCCI_TTY_UL_DEQUEUE_REQ, change to MOD_CCCITTY context for dequeue(MOD_CCCIDEV)
* <5> Error Handling: reload RGPD number error_reload_cnt
* Function might free RGPDs for the following cases
* case 1. CCCI header corrupts, CCCITTY_RM_CCCI_HEADERS return false
* case 2. cccitty device state != CCCI_TTY_DEV_OPEN, cccitty_dev_active return false
*
* @param channel [IN] ccci_channel id
* @param io_request [IN] pointer to uplink io request
*
* @return void
*/
void cccitty_ccci_ul_cb(CCCI_CHANNEL_T channel, ccci_io_request_t* io_request){
cccitty_inst_t *p_cccitty = cccitty_get_instance();
cccitty_dev_t *p_cccidev;
cccitty_device_id dev_id = cccitty_get_ul_devid(channel);
ccci_io_request_t *curr_ior;
ccci_io_request_t *next_ior;
kal_bool end_of_list;
qbm_gpd *first_gpd;
qbm_gpd *last_gpd;
qbm_gpd *prev_gpd;
qbm_gpd *curr_gpd;
qbm_gpd *next_gpd;
kal_int32 tmp;
kal_uint32 num_gpd;
kal_bool valid_gpd = KAL_FALSE;
kal_uint32 num_alloc;//, to_alloc;
CCCI_RETURNVAL_T ccci_ret;
kal_bool ttydev_deq_msg = KAL_FALSE;
cccitty_deq_req_t *cccitty_deq_req;
/* error RPGD handling */
ccci_io_request_t err_reload_ior;
kal_uint32 err_reload_cnt = 0;
qbm_gpd *err_gpd_h = NULL;
qbm_gpd *err_gpd_t = NULL;
kal_uint32 NBPS_GPD_NUM = 0;
CCCI_BUFF_T *pdata;
kal_int32 chkseqrtn = 0;
if(CCCI_TTY_DEV_CNT == dev_id){
/* cannot find dev_id for channel, please check g_cccitty_ccci_ch_mappping */
return;
}
if(NULL == io_request){
cccitty_trace(CCCI_TTY_ERR, CCCI_TTY_MOD_UL, CCCI_TTY_TR_UL_NULL_IOR, dev_id, channel);
return;
}
/* ASSERT if invalid channel number is received */
EXT_ASSERT(dev_id < CCCI_TTY_DEV_CNT, channel, 0, 0);
p_cccidev = cccitty_get_dev_instance(dev_id);
if(!cccitty_dev_active(p_cccidev)){
/* device is not at CCCI_TTY_DEV_OPEN state*/
cccitty_trace(CCCI_TTY_ERR, CCCI_TTY_MOD_UL, CCCI_TTY_TR_UL_DEV_NOT_OPEN,p_cccidev->dev_id, cccitty_get_dev_state(p_cccidev));
/*for drop packet case, need to check sequence number first*/
/*If there is mips issue, this action can be combined with reset function*/
cccitty_check_ul_gpd_list_sequence(io_request->first_gpd, io_request->last_gpd);
/* reset the gpds*/
num_alloc = cccitty_reset_ccci_comm_gpd_list(io_request->first_gpd, io_request->last_gpd);
//ASSERT (num_alloc == CCCITTY_GET_NONBPS_GPD_LIST_SIZE(io_request->first_gpd, io_request->last_gpd));
NBPS_GPD_NUM = CCCITTY_GET_NONBPS_GPD_LIST_SIZE(io_request->first_gpd, io_request->last_gpd);
EXT_ASSERT((num_alloc == NBPS_GPD_NUM), num_alloc, NBPS_GPD_NUM, 0);
io_request->num_gpd = num_alloc;
/* reload the gpds */
ccci_ret = p_cccitty->ccci_write_gpd(p_cccidev->ccci_ch.cccitty_ch_ul, io_request, NULL);
if(CCCI_SUCCESS != ccci_ret){
/* NOTE!! might cause RGPD leackage here */
cccitty_trace(CCCI_TTY_ERR, CCCI_TTY_MOD_UL, CCCI_TTY_TR_UL_CCCI_WRITE_FAIL,p_cccidev->dev_id, ccci_ret);
qbmt_dest_q(io_request->first_gpd, io_request->last_gpd);
}else{
CCCI_TTY_LOCK(p_cccidev->cccitty_mutex);
{
/* should not increase hwo_rgpd_cnt, since this is the RGPD belongs to other user */
//p_cccidev->hwo_rgpd_cnt += num_alloc;
/* to prevent interrupted by SDIOCORE context*/
tmp = p_cccidev->hwo_rgpd_cnt;
}
CCCI_TTY_UNLOCK(p_cccidev->cccitty_mutex);
cccitty_trace(CCCI_TTY_TRACE, CCCI_TTY_MOD_UL, CCCI_TTY_TR_HIF_RGPD_RELOAD5,p_cccidev->dev_id, num_alloc, tmp);
}
return;
}
for (curr_ior = io_request; curr_ior; curr_ior = next_ior) {
next_ior = curr_ior->next_request;
first_gpd = curr_ior->first_gpd;
last_gpd = curr_ior->last_gpd;
//3 Note that, because GPD might be freeed in the following loop, we shall not access curr_ior from now.
if (first_gpd && last_gpd){
//4 <1> update the RGPD count in HIF
num_gpd = CCCITTY_GET_GPD_LIST_SIZE(first_gpd, last_gpd);
/* NOT allow BPS GPD inside */
//ASSERT(num_gpd == CCCITTY_GET_NONBPS_GPD_LIST_SIZE(first_gpd, last_gpd));
NBPS_GPD_NUM = CCCITTY_GET_NONBPS_GPD_LIST_SIZE(first_gpd, last_gpd);
EXT_ASSERT((num_gpd == NBPS_GPD_NUM), num_gpd, NBPS_GPD_NUM, 0);
CCCI_TTY_LOCK(p_cccidev->cccitty_mutex);
{
p_cccidev->hwo_rgpd_cnt -= num_gpd;
tmp = p_cccidev->hwo_rgpd_cnt;
}
CCCI_TTY_UNLOCK(p_cccidev->cccitty_mutex);
cccitty_trace(CCCI_TTY_TRACE, CCCI_TTY_MOD_UL, CCCI_TTY_TR_UL_RCV_GPD, p_cccidev->dev_id, num_gpd, tmp);
if(p_cccidev->hwo_rgpd_cnt < 1){
cccitty_trace(CCCI_TTY_WARN, CCCI_TTY_MOD_UL, CCCI_TTY_TR_UL_RGPD_EMPTY, p_cccidev->dev_id, tmp);
}
prev_gpd = NULL;
end_of_list = KAL_FALSE;
for (curr_gpd = first_gpd; curr_gpd && !end_of_list; curr_gpd = next_gpd) {
next_gpd = QBM_DES_GET_NEXT(curr_gpd);
end_of_list = (curr_gpd == last_gpd);
/*Check sequence number here!*/
pdata = CCCIDEV_GET_QBM_DATAPTR(curr_gpd);
chkseqrtn = ccci_debug_check_seq(pdata);
if(chkseqrtn != CCCI_SUCCESS)
{
cccitty_trace(CCCI_TTY_ERR, CCCI_TTY_MOD_UL, CCCI_TTY_CHK_UL_SEQ_FAIL, chkseqrtn, channel);
}
//4 <2> remove CCCI header, CCCI_BUFF_T
valid_gpd = CCCITTY_RM_CCCI_HEADERS(channel, curr_gpd);
if(KAL_TRUE == valid_gpd){
prev_gpd = curr_gpd;
}else{
p_cccidev->ul_invalid_ttl_cnt++;
err_reload_cnt ++;
cccitty_trace(CCCI_TTY_ERR, CCCI_TTY_MOD_UL, CCCI_TTY_TR_UL_RPGD_ERR, err_reload_cnt, p_cccidev->ul_invalid_ttl_cnt);
if (curr_gpd == first_gpd) {
if (curr_gpd == last_gpd) {
first_gpd = NULL;
last_gpd = NULL;
EXT_ASSERT(end_of_list,0,0,0);
end_of_list = KAL_TRUE; /* All GPD's in the list are freed, exit the loop after curr_gpd released. */
} else {
EXT_ASSERT(next_gpd,0,0,0);
first_gpd = next_gpd;
}
prev_gpd = NULL;
} else {
EXT_ASSERT(prev_gpd,0,0,0);
if (curr_gpd == last_gpd) {
last_gpd = prev_gpd;
QBM_DES_SET_NEXT(prev_gpd, NULL);
EXT_ASSERT(end_of_list,0,0,0);
end_of_list = KAL_TRUE; /* To exit the loop after curr_gpd released. */
} else {
EXT_ASSERT(next_gpd,0,0,0);
QBM_DES_SET_NEXT(prev_gpd, next_gpd);
}
qbm_cal_set_checksum((kal_uint8 *)prev_gpd);
QBM_CACHE_FLUSH(prev_gpd, sizeof(qbm_gpd));
}
CCCITTY_QBM_ENQ(curr_gpd, curr_gpd, (void **)&err_gpd_h, (void **)&err_gpd_t);
}
} /* for (curr_gpd) */
//4 <3> enqueue the RGPD to hif_ul_q_h
if (first_gpd) {
EXT_ASSERT(last_gpd,0,0,0);
num_gpd = CCCITTY_GET_GPD_LIST_SIZE(first_gpd, last_gpd);
#if CCCITTY_LB_ENABLE
// TODO: Provide the loopback function
//4 nicc_ul2dl_loopback((ccci_io_request_t *)curr_ior, (nicc_dl_func)rndis_on_downlink, dev->ethc_inst);
#else
/*enqueue to hif_ul_q*/
CCCI_TTY_LOCK(p_cccidev->cccitty_mutex);
{
CCCITTY_QBM_ENQ(first_gpd, last_gpd, (void **)&p_cccidev->hif_ul_q_h, (void **)&p_cccidev->hif_ul_q_t);
p_cccidev->hif_ul_rgpd_cnt += num_gpd;
tmp = p_cccidev->hif_ul_rgpd_cnt;
}
CCCI_TTY_UNLOCK(p_cccidev->cccitty_mutex);
ttydev_deq_msg = KAL_TRUE;
#endif
} else {
EXT_ASSERT((NULL == last_gpd),0,0,0);
cccitty_trace(CCCI_TTY_ERR, CCCI_TTY_MOD_UL, CCCI_TTY_TR_UL_EMPTY_IOR, p_cccidev->dev_id);
}
} else {/* if (first_gpd && last_gpd) */
cccitty_trace(CCCI_TTY_ERR, CCCI_TTY_MOD_UL, CCCI_TTY_TR_UL_INVALID_IOR, p_cccidev->dev_id, curr_ior, first_gpd, last_gpd);
EXT_ASSERT(KAL_FALSE, (kal_uint32)first_gpd, (kal_uint32)last_gpd, 0); /* Invalid IOR */
}
} /*for (curr_ior...*/
//4 <4> send MSG_ID_CCCI_TTY_UL_DEQUEUE_REQ
if(KAL_TRUE == ttydev_deq_msg){
CCCI_TTY_LOCK(p_cccidev->cccitty_mutex);
if(KAL_FALSE == p_cccidev->dev_ul_processing){
{
p_cccidev->dev_ul_processing = KAL_TRUE;
}
CCCI_TTY_UNLOCK(p_cccidev->cccitty_mutex);
cccitty_deq_req = (cccitty_deq_req_t *)construct_local_para(sizeof(cccitty_deq_req_t), 0);
cccitty_deq_req->dev = p_cccidev;
msg_send6(MOD_CCCITTY, /* src_mod_id, depending on the HIF type */
MOD_CCCITTY, /* dest_mod_id */
0, /* sap_id */
MSG_ID_CCCI_TTY_UL_DEQUEUE_REQ, /* msg_id */
(struct local_para_struct *)cccitty_deq_req, /* local_para_ptr */
NULL); /* peer_buff_ptr */
cccitty_trace(CCCI_TTY_TRACE, CCCI_TTY_MOD_UL, CCCI_TTY_TR_UL_SEND_DEQ, p_cccidev->dev_id);
}else{
CCCI_TTY_UNLOCK(p_cccidev->cccitty_mutex);
/* there's MSG_ID_CCCI_TTY_UL_DEQUEUE_REQ message pending */
}
}
//4 <5> Error Handling: reload RGPD number err_reload_cnt
if (err_reload_cnt > 0){
cccitty_trace(CCCI_TTY_ERR, CCCI_TTY_MOD_UL, CCCI_TTY_TR_UL_INVALID_PKT, p_cccidev->dev_id, err_reload_cnt, p_cccidev->ul_invalid_ttl_cnt);
/* reset the rgpd content with HWO = 1*/
num_alloc = cccitty_reset_ccci_comm_gpd_list(err_gpd_h, err_gpd_t);
// num_alloc = CCCITTY_GET_GPD_LIST_SIZE(err_gpd_h, err_gpd_t);
if(num_alloc != err_reload_cnt){
cccitty_trace(CCCI_TTY_ERR, CCCI_TTY_MOD_UL, CCCI_TTY_TR_TTYC_ERR_RGPD_LEAK, p_cccidev->dev_id, num_alloc, err_reload_cnt);
EXT_ASSERT(num_alloc == err_reload_cnt, num_alloc, err_reload_cnt, 0);
}
err_reload_ior.next_request = NULL;
err_reload_ior.first_gpd = err_gpd_h;
err_reload_ior.last_gpd = err_gpd_t;
/* reload the gpds */
ccci_ret = p_cccitty->ccci_write_gpd(p_cccidev->ccci_ch.cccitty_ch_ul, &err_reload_ior, NULL);
if(CCCI_SUCCESS != ccci_ret){
/* NOTE!! might cause RGPD leackage here */
cccitty_trace(CCCI_TTY_ERR, CCCI_TTY_MOD_UL, CCCI_TTY_TR_UL_CCCI_WRITE_FAIL,p_cccidev->dev_id, ccci_ret);
qbmt_dest_q(err_reload_ior.first_gpd, err_reload_ior.last_gpd);
}else{
CCCI_TTY_LOCK(p_cccidev->cccitty_mutex);
{
/* should not increase hwo_rgpd_cnt, since this is the RGPD belongs to other user */
p_cccidev->hwo_rgpd_cnt += num_alloc;
/* to prevent interrupted by SDIOCORE context*/
tmp = p_cccidev->hwo_rgpd_cnt;
}
CCCI_TTY_UNLOCK(p_cccidev->cccitty_mutex);
cccitty_trace(CCCI_TTY_TRACE, CCCI_TTY_MOD_UL, CCCI_TTY_TR_HIF_RGPD_RELOAD4,p_cccidev->dev_id, num_alloc, tmp);
}
}
return;
}
/*!
* 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);
}
void ccci_ipc_receive_msg_cb(CCCI_CHANNEL_T channel, ccci_io_request_t* ior)
{
kal_uint32 i = 0;
ipc_ilm_t *temp_ipc_ilm = NULL;
void *local_param = NULL, *peer_buff = NULL;
kal_uint32 len = 0;
kal_uint32 gpd_num = 0;
ccci_io_request_t *current_ior = ior;
ccci_io_request_t *reload_ior = NULL;
qbm_gpd *current_gpd;
qbm_gpd *next_gpd;
kal_bool is_process_cb = KAL_FALSE;
ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_RECEIVE_MSG_FUNC_TRA);
while(current_ior != NULL){
current_gpd = current_ior->first_gpd ;
gpd_num = 0;
while( current_gpd != NULL){
CCCI_BUFF_T *bufp = CCCIDEV_GET_QBM_DATAPTR(current_gpd);
next_gpd = current_gpd->p_next;
local_param = NULL;
peer_buff = NULL;
ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_RECEIVE_MSG_TRA_CCCI,
bufp->data[0], bufp->data[1], bufp->channel, bufp->reserved);
ccci_debug_check_seq(bufp); // check ccci seq
/* get task id from mapping table of ext queue id */
for (i = 0; i < MAX_CCCI_IPC_TASKS; i++)
{
if ( ccci_ipc_maptbl[i].extq_id == bufp->reserved )
{
break;
}
}
/* check if the extquque id can not be found */
if (i >= MAX_CCCI_IPC_TASKS)
{
EXT_ASSERT(0, i, bufp->reserved, MAX_CCCI_IPC_TASKS);
}
/* check if the extquque id is to MD */
if ((ccci_ipc_maptbl[i].extq_id & AP_UINFY_ID_FLAG) != 0)
{
EXT_ASSERT(0, i, bufp->reserved, ccci_ipc_maptbl[i].extq_id);
}
temp_ipc_ilm = (ipc_ilm_t *)(bufp + 1);
ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_RECEIVE_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);
if(temp_ipc_ilm->local_para_ptr)
{
// copy local_para_struct
temp_ipc_ilm->local_para_ptr = (local_para_struct *)((char*)temp_ipc_ilm + sizeof(ipc_ilm_t));
len += temp_ipc_ilm->local_para_ptr->msg_len; // need 4 bytes alignment or not??
//assert if ilm size > CCCI_IPC_GPD size
EXT_ASSERT(len < CCCI_IPC_GPD_SIZE, len, CCCI_IPC_GPD_SIZE,0);
local_param = construct_local_para(temp_ipc_ilm->local_para_ptr->msg_len, 1);
kal_mem_cpy((kal_uint8 *)local_param, temp_ipc_ilm->local_para_ptr, temp_ipc_ilm->local_para_ptr->msg_len);
((local_para_struct *)local_param)->ref_count = 1 ;
temp_ipc_ilm->local_para_ptr = local_param;
}
if (temp_ipc_ilm->peer_buff_ptr)
{
//copy peer_buff_struct
if(temp_ipc_ilm->local_para_ptr)
{
temp_ipc_ilm->peer_buff_ptr = (peer_buff_struct *)((char*)temp_ipc_ilm->local_para_ptr
+ temp_ipc_ilm->local_para_ptr->msg_len);
}
else
{
temp_ipc_ilm->peer_buff_ptr = (peer_buff_struct *)((char*)temp_ipc_ilm + sizeof(ipc_ilm_t));
}
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);
peer_buff = construct_peer_buff(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, 1);
kal_mem_cpy((kal_uint8 *)peer_buff, 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);
temp_ipc_ilm->peer_buff_ptr = peer_buff;
}
CCCI_AP_MSG_TO_KAL_MSG(temp_ipc_ilm->msg_id, temp_ipc_ilm->msg_id);
if(ccci_ipc_ch.it_mode == CCCI_IPC_IT_DISABLE){ // if current is not IT mode, then need to send upper layer
//4 <1> process ccci ipc cb function
is_process_cb = ccci_ipc_process_cb_funp(temp_ipc_ilm);
//4 <2> Determine send ilm to upper layer or destroy ilm
if(!is_process_cb){ // no process cb, then send ilm to upper layer
msg_send6 (MOD_CCCIIPC, ccci_ipc_maptbl[i].task_id, temp_ipc_ilm->sap_id, temp_ipc_ilm->msg_id, local_param, peer_buff);
}
}
#ifdef CCCI_IT_MODE_CONTROL_CCCI_IPC
if(ccci_ipc_ch.it_mode == CCCI_IPC_IT_LB){
CCCI_KAL_MSG_TO_AP_MSG(temp_ipc_ilm->msg_id, temp_ipc_ilm->msg_id);
bufp->reserved |= (AP_UINFY_ID_FLAG | temp_ipc_ilm->src_mod_id ); // for Loopback to ccci ipc port 1
bufp->channel = ccci_ipc_ch.send_channel; // for Loopback
ccci_debug_add_seq(bufp, CCCI_DEBUG_ASSERT_BIT); // add ccci seq
}
#endif
QBM_CACHE_INVALID(temp_ipc_ilm,sizeof(temp_ipc_ilm)); // prevent cache co-herence problem
gpd_num++;
if (current_gpd == current_ior->last_gpd){
break;
}
else{
current_gpd = next_gpd;
}
}// process gpds
reload_ior = current_ior;
current_ior = current_ior->next_request;
reload_ior->next_request = NULL;
#ifdef __SDIOC_PULL_Q_ENH_DL__
reload_ior->num_gpd = gpd_num;
#endif
#ifdef __CCCI_IPC_UT__
qbmt_dest_q(reload_ior->first_gpd, reload_ior->last_gpd);
#else
#ifdef CCCI_IT_MODE_CONTROL_CCCI_IPC
if(ccci_ipc_ch.it_mode == CCCI_IPC_IT_LB){
ccci_ipc_ch.ccci_write_gpd(ccci_ipc_ch.send_channel, reload_ior, NULL);
ccci_ipc_ch.reload_rgpd_number -= gpd_num;
ccci_ipc_reload_rgpds();
}else
#endif
{
CCCIDEV_RST_CCCI_COMM_GPD_LIST(reload_ior->first_gpd, reload_ior->last_gpd);
ccci_ipc_ch.ccci_write_gpd(ccci_ipc_ch.receive_channel, reload_ior, NULL);
}
#endif
}//process iors
ccci_ipc_trace(CCCI_IPC_TRACE, CCCI_IPC_MOD_DATA, CCCI_RECEIVE_MSG_FUNC_PASS_TRA);
}
