/************************************************************************* * 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); }