Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f0325825 authored by Skylar Chang's avatar Skylar Chang
Browse files

msm: ipa: wan driver change for new qmi in mdmcalifornimum 



Adapt wan driver to new qmi in mdmcalifornimum

Change-Id: I8009e348e0bcaedf495a49e957fa9a33c5b9c82d
Signed-off-by: default avatarSkylar Chang <chiaweic@codeaurora.org>
parent 95f6c543

drivers/platform/msm/ipa/ipa_v3/ipa_qmi_service.c

+65 −46
Original line number Diff line number Diff line
@@ -70,17 +70,17 @@ static struct msg_desc ipa3_master_driver_complete_indication_desc = { 
	.ei_array = ipa3_master_driver_init_complt_ind_msg_data_v01_ei,

};

static struct msg_desc ipa3_install_fltr_rule_req_desc = {

	.max_msg_len = QMI_IPA_INSTALL_FILTER_RULE_REQ_MAX_MSG_LEN_V01,

	.max_msg_len = QMI3_IPA_INSTALL_FILTER_RULE_REQ_MAX_MSG_LEN_V01,

	.msg_id = QMI_IPA_INSTALL_FILTER_RULE_REQ_V01,

	.ei_array = ipa3_install_fltr_rule_req_msg_data_v01_ei,

};

static struct msg_desc ipa3_install_fltr_rule_resp_desc = {

	.max_msg_len = QMI_IPA_INSTALL_FILTER_RULE_RESP_MAX_MSG_LEN_V01,

	.max_msg_len = QMI3_IPA_INSTALL_FILTER_RULE_RESP_MAX_MSG_LEN_V01,

	.msg_id = QMI_IPA_INSTALL_FILTER_RULE_RESP_V01,

	.ei_array = ipa3_install_fltr_rule_resp_msg_data_v01_ei,

};

static struct msg_desc ipa3_filter_installed_notif_req_desc = {

	.max_msg_len = QMI_IPA_FILTER_INSTALLED_NOTIF_REQ_MAX_MSG_LEN_V01,

	.max_msg_len = QMI3_IPA_FILTER_INSTALLED_NOTIF_REQ_MAX_MSG_LEN_V01,

	.msg_id = QMI_IPA_FILTER_INSTALLED_NOTIF_REQ_V01,

	.ei_array = ipa3_fltr_installed_notif_req_msg_data_v01_ei,

};
@@ -136,43 +136,41 @@ static int ipa3_handle_indication_req(void *req_h, void *req) 


static int ipa3_handle_install_filter_rule_req(void *req_h, void *req)

{

	struct ipa_install_fltr_rule_req_msg_v01 *rule_req;

	struct ipa_install_fltr_rule_resp_msg_v01 resp;

	struct ipa3_install_fltr_rule_req_msg_v01 *rule_req;

	struct ipa3_install_fltr_rule_resp_msg_v01 resp;

	uint32_t rule_hdl[MAX_NUM_Q6_RULE];

	int rc = 0, i;



	rule_req = (struct ipa_install_fltr_rule_req_msg_v01 *)req;

	rule_req = (struct ipa3_install_fltr_rule_req_msg_v01 *)req;

	memset(rule_hdl, 0, sizeof(rule_hdl));

	memset(&resp, 0, sizeof(struct ipa_install_fltr_rule_resp_msg_v01));

	memset(&resp, 0, sizeof(struct ipa3_install_fltr_rule_resp_msg_v01));

	IPAWANDBG("Received install filter Request\n");



	rc = ipa3_copy_ul_filter_rule_to_ipa((struct

		ipa_install_fltr_rule_req_msg_v01*)req, rule_hdl);

		ipa3_install_fltr_rule_req_msg_v01*)req);

	if (rc)

		IPAWANERR("copy UL rules from modem is failed\n");



	resp.resp.result = IPA_QMI_RESULT_SUCCESS_V01;

	if (rule_req->filter_spec_list_valid == true) {

		resp.filter_handle_list_valid = true;

		if (rule_req->filter_spec_list_len > MAX_NUM_Q6_RULE) {

			resp.filter_handle_list_len = MAX_NUM_Q6_RULE;

			resp.rule_id_len = MAX_NUM_Q6_RULE;

			IPAWANERR("installed (%d) max Q6-UL rules ",

			MAX_NUM_Q6_RULE);

			IPAWANERR("but modem gives total (%d)\n",

			rule_req->filter_spec_list_len);

		} else {

			resp.filter_handle_list_len =

			resp.rule_id_len =

				rule_req->filter_spec_list_len;

		}

	} else {

		resp.filter_handle_list_valid = false;

		resp.rule_id_len = 0;

	}



	/* construct UL filter rules response to Modem*/

	for (i = 0; i < resp.filter_handle_list_len; i++) {

		resp.filter_handle_list[i].filter_spec_identifier =

			rule_req->filter_spec_list[i].filter_spec_identifier;

		resp.filter_handle_list[i].filter_handle = rule_hdl[i];

	for (i = 0; i < resp.rule_id_len; i++) {

		resp.rule_id[i] =

			rule_req->filter_spec_list[i].rule_id;

	}



	rc = qmi_send_resp_from_cb(ipa3_svc_handle, curr_conn, req_h,
@@ -257,11 +255,11 @@ static int ipa3_a5_svc_req_desc_cb(unsigned int msg_id, 


	case QMI_IPA_INSTALL_FILTER_RULE_REQ_V01:

		*req_desc = &ipa3_install_fltr_rule_req_desc;

		rc = sizeof(struct ipa_install_fltr_rule_req_msg_v01);

		rc = sizeof(struct ipa3_install_fltr_rule_req_msg_v01);

		break;

	case QMI_IPA_FILTER_INSTALLED_NOTIF_REQ_V01:

		*req_desc = &ipa3_filter_installed_notif_req_desc;

		rc = sizeof(struct ipa_fltr_installed_notif_req_msg_v01);

		rc = sizeof(struct ipa3_fltr_installed_notif_req_msg_v01);

		break;

	case QMI_IPA_CONFIG_REQ_V01:

		*req_desc = &ipa3_config_req_desc;
@@ -388,13 +386,13 @@ static int ipa3_check_qmi_response(int rc, 


static int ipa3_qmi_init_modem_send_sync_msg(void)

{

	struct ipa_init_modem_driver_req_msg_v01 req;

	struct ipa3_init_modem_driver_req_msg_v01 req;

	struct ipa_init_modem_driver_resp_msg_v01 resp;

	struct msg_desc req_desc, resp_desc;

	int rc;

	u16 smem_restr_bytes = ipa3_get_smem_restr_bytes();



	memset(&req, 0, sizeof(struct ipa_init_modem_driver_req_msg_v01));

	memset(&req, 0, sizeof(struct ipa3_init_modem_driver_req_msg_v01));

	memset(&resp, 0, sizeof(struct ipa_init_modem_driver_resp_msg_v01));



	req.platform_type_valid = true;
@@ -450,6 +448,26 @@ static int ipa3_qmi_init_modem_send_sync_msg(void) 
		IPA_MEM_PART(modem_comp_decomp_ofst) +

		IPA_MEM_PART(modem_comp_decomp_size) + smem_restr_bytes - 1;



	req.v4_hash_route_tbl_info_valid = true;

	req.v4_hash_route_tbl_info.route_tbl_start_addr =

		IPA_MEM_PART(v4_rt_hash_ofst) + smem_restr_bytes;

	req.v4_hash_route_tbl_info.num_indices =

		IPA_MEM_PART(v4_modem_rt_index_hi);



	req.v6_hash_route_tbl_info_valid = true;

	req.v6_hash_route_tbl_info.route_tbl_start_addr =

		IPA_MEM_PART(v6_rt_hash_ofst) + smem_restr_bytes;

	req.v6_hash_route_tbl_info.num_indices =

		IPA_MEM_PART(v6_modem_rt_index_hi);



	req.v4_hash_filter_tbl_start_addr_valid = true;

	req.v4_hash_filter_tbl_start_addr =

		IPA_MEM_PART(v4_flt_hash_ofst) + smem_restr_bytes;



	req.v6_hash_filter_tbl_start_addr_valid = true;

	req.v6_hash_filter_tbl_start_addr =

		IPA_MEM_PART(v6_flt_hash_ofst) + smem_restr_bytes;



	if (is_load_uc) {  /* First time boot */

		req.is_ssr_bootup_valid = false;

		req.is_ssr_bootup = 0;
@@ -483,8 +501,20 @@ static int ipa3_qmi_init_modem_send_sync_msg(void) 
			req.ctrl_comm_dest_end_pt);

	IPAWANDBG("is_ssr_bootup %d\n",

			req.is_ssr_bootup);



	req_desc.max_msg_len = QMI_IPA_INIT_MODEM_DRIVER_REQ_MAX_MSG_LEN_V01;

	IPAWANDBG("v4_hash_route_tbl_info.route_tbl_start_addr %d\n",

		req.v4_hash_route_tbl_info.route_tbl_start_addr);

	IPAWANDBG("v4_hash_route_tbl_info.num_indices %d\n",

		req.v4_hash_route_tbl_info.num_indices);

	IPAWANDBG("v6_hash_route_tbl_info.route_tbl_start_addr %d\n",

		req.v6_hash_route_tbl_info.route_tbl_start_addr);

	IPAWANDBG("v6_hash_route_tbl_info.num_indices %d\n",

		req.v6_hash_route_tbl_info.num_indices);

	IPAWANDBG("v4_hash_filter_tbl_start_addr %d\n",

		req.v4_hash_filter_tbl_start_addr);

	IPAWANDBG("v6_hash_filter_tbl_start_addr %d\n",

		req.v6_hash_filter_tbl_start_addr);



	req_desc.max_msg_len = QMI3_IPA_INIT_MODEM_DRIVER_REQ_MAX_MSG_LEN_V01;

	req_desc.msg_id = QMI_IPA_INIT_MODEM_DRIVER_REQ_V01;

	req_desc.ei_array = ipa3_init_modem_driver_req_msg_data_v01_ei;
@@ -503,9 +533,9 @@ static int ipa3_qmi_init_modem_send_sync_msg(void) 
}



/* sending filter-install-request to modem*/

int ipa3_qmi_filter_request_send(struct ipa_install_fltr_rule_req_msg_v01 *req)

int ipa3_qmi_filter_request_send(struct ipa3_install_fltr_rule_req_msg_v01 *req)

{

	struct ipa_install_fltr_rule_resp_msg_v01 resp;

	struct ipa3_install_fltr_rule_resp_msg_v01 resp;

	struct msg_desc req_desc, resp_desc;

	int rc;
@@ -520,23 +550,23 @@ int ipa3_qmi_filter_request_send(struct ipa_install_fltr_rule_req_msg_v01 *req) 
	/* cache the qmi_filter_request */

	memcpy(&(ipa3_qmi_ctx->ipa_install_fltr_rule_req_msg_cache[

		ipa3_qmi_ctx->num_ipa_install_fltr_rule_req_msg]),

			req, sizeof(struct ipa_install_fltr_rule_req_msg_v01));

			req, sizeof(struct ipa3_install_fltr_rule_req_msg_v01));

	ipa3_qmi_ctx->num_ipa_install_fltr_rule_req_msg++;

	ipa3_qmi_ctx->num_ipa_install_fltr_rule_req_msg %= 10;



	req_desc.max_msg_len = QMI_IPA_INSTALL_FILTER_RULE_REQ_MAX_MSG_LEN_V01;

	req_desc.max_msg_len = QMI3_IPA_INSTALL_FILTER_RULE_REQ_MAX_MSG_LEN_V01;

	req_desc.msg_id = QMI_IPA_INSTALL_FILTER_RULE_REQ_V01;

	req_desc.ei_array = ipa3_install_fltr_rule_req_msg_data_v01_ei;



	memset(&resp, 0, sizeof(struct ipa_install_fltr_rule_resp_msg_v01));

	memset(&resp, 0, sizeof(struct ipa3_install_fltr_rule_resp_msg_v01));

	resp_desc.max_msg_len =

		QMI_IPA_INSTALL_FILTER_RULE_RESP_MAX_MSG_LEN_V01;

		QMI3_IPA_INSTALL_FILTER_RULE_RESP_MAX_MSG_LEN_V01;

	resp_desc.msg_id = QMI_IPA_INSTALL_FILTER_RULE_RESP_V01;

	resp_desc.ei_array = ipa3_install_fltr_rule_resp_msg_data_v01_ei;



	rc = qmi_send_req_wait(ipa_q6_clnt, &req_desc,

			req,

			sizeof(struct ipa_install_fltr_rule_req_msg_v01),

			sizeof(struct ipa3_install_fltr_rule_req_msg_v01),

			&resp_desc, &resp, sizeof(resp),

			QMI_SEND_REQ_TIMEOUT_MS);

	return ipa3_check_qmi_response(rc,
@@ -635,39 +665,28 @@ int ipa3_qmi_disable_force_clear_datapath_send( 


/* sending filter-installed-notify-request to modem*/

int ipa3_qmi_filter_notify_send(

		struct ipa_fltr_installed_notif_req_msg_v01 *req)

		struct ipa3_fltr_installed_notif_req_msg_v01 *req)

{

	struct ipa_fltr_installed_notif_resp_msg_v01 resp;

	struct msg_desc req_desc, resp_desc;

	int rc = 0, i = 0;

	int rc = 0;



	/* check if the filter rules from IPACM is valid */

	if (req->filter_index_list_len == 0) {

	if (req->rule_id_len == 0) {

		IPAWANERR(" delete UL filter rule for pipe %d\n",

		req->source_pipe_index);

		return -EINVAL;

	} else if (req->filter_index_list[0].filter_index == 0 &&

		req->source_pipe_index !=

		ipa3_get_ep_mapping(IPA_CLIENT_APPS_LAN_WAN_PROD)) {

		IPAWANERR(" get index wrong for pipe %d\n",

			req->source_pipe_index);

		for (i = 0; i < req->filter_index_list_len; i++)

			IPAWANERR(" %d-st handle %d index %d\n",

				i,

				req->filter_index_list[i].filter_handle,

				req->filter_index_list[i].filter_index);

		return -EINVAL;

	}



	/* cache the qmi_filter_request */

	memcpy(&(ipa3_qmi_ctx->ipa_fltr_installed_notif_req_msg_cache[

		ipa3_qmi_ctx->num_ipa_fltr_installed_notif_req_msg]),

		req, sizeof(struct ipa_fltr_installed_notif_req_msg_v01));

		req, sizeof(struct ipa3_fltr_installed_notif_req_msg_v01));

	ipa3_qmi_ctx->num_ipa_fltr_installed_notif_req_msg++;

	ipa3_qmi_ctx->num_ipa_fltr_installed_notif_req_msg %= 10;



	req_desc.max_msg_len =

	QMI_IPA_FILTER_INSTALLED_NOTIF_REQ_MAX_MSG_LEN_V01;

	QMI3_IPA_FILTER_INSTALLED_NOTIF_REQ_MAX_MSG_LEN_V01;

	req_desc.msg_id = QMI_IPA_FILTER_INSTALLED_NOTIF_REQ_V01;

	req_desc.ei_array = ipa3_fltr_installed_notif_req_msg_data_v01_ei;
@@ -680,7 +699,7 @@ int ipa3_qmi_filter_notify_send( 
	rc = qmi_send_req_wait(ipa_q6_clnt,

			&req_desc,

			req,

			sizeof(struct ipa_fltr_installed_notif_req_msg_v01),

			sizeof(struct ipa3_fltr_installed_notif_req_msg_v01),

			&resp_desc, &resp, sizeof(resp),

			QMI_SEND_REQ_TIMEOUT_MS);

	return ipa3_check_qmi_response(rc,

drivers/platform/msm/ipa/ipa_v3/ipa_qmi_service.h

+11 −10
Original line number Diff line number Diff line
@@ -41,10 +41,10 @@ struct ipa3_qmi_context { 
struct ipa_ioc_ext_intf_prop q6_ul_filter_rule[MAX_NUM_Q6_RULE];

u32 q6_ul_filter_rule_hdl[MAX_NUM_Q6_RULE];

int num_ipa_install_fltr_rule_req_msg;

struct ipa_install_fltr_rule_req_msg_v01

struct ipa3_install_fltr_rule_req_msg_v01

		ipa_install_fltr_rule_req_msg_cache[MAX_NUM_QMI_RULE_CACHE];

int num_ipa_fltr_installed_notif_req_msg;

struct ipa_fltr_installed_notif_req_msg_v01

struct ipa3_fltr_installed_notif_req_msg_v01

		ipa_fltr_installed_notif_req_msg_cache[MAX_NUM_QMI_RULE_CACHE];

bool modem_cfg_emb_pipe_flt;

};
@@ -105,10 +105,11 @@ int ipa3_qmi_service_init(bool load_uc, uint32_t wan_platform_type); 
void ipa3_qmi_service_exit(void);



/* sending filter-install-request to modem*/

int ipa3_qmi_filter_request_send(struct ipa_install_fltr_rule_req_msg_v01 *req);

int ipa3_qmi_filter_request_send(

	struct ipa3_install_fltr_rule_req_msg_v01 *req);



/* sending filter-installed-notify-request to modem*/

int ipa3_qmi_filter_notify_send(struct ipa_fltr_installed_notif_req_msg_v01

int ipa3_qmi_filter_notify_send(struct ipa3_fltr_installed_notif_req_msg_v01

		*req);



/* voting for bus BW to ipa_rm*/
@@ -120,8 +121,8 @@ int ipa3_qmi_enable_force_clear_datapath_send( 
int ipa3_qmi_disable_force_clear_datapath_send(

	struct ipa_disable_force_clear_datapath_req_msg_v01 *req);



int ipa3_copy_ul_filter_rule_to_ipa(struct ipa_install_fltr_rule_req_msg_v01

	*rule_req, uint32_t *rule_hdl);

int ipa3_copy_ul_filter_rule_to_ipa(struct ipa3_install_fltr_rule_req_msg_v01

	*rule_req);



int ipa3_wwan_update_mux_channel_prop(void);
@@ -166,14 +167,14 @@ static inline void ipa3_qmi_service_exit(void) { } 


/* sending filter-install-request to modem*/

static inline int ipa3_qmi_filter_request_send(

	struct ipa_install_fltr_rule_req_msg_v01 *req)

	struct ipa3_install_fltr_rule_req_msg_v01 *req)

{

	return -EPERM;

}



/* sending filter-installed-notify-request to modem*/

static inline int ipa3_qmi_filter_notify_send(

	struct ipa_fltr_installed_notif_req_msg_v01 *req)

	struct ipa3_fltr_installed_notif_req_msg_v01 *req)

{

	return -EPERM;

}
@@ -191,7 +192,7 @@ static inline int ipa3_qmi_disable_force_clear_datapath_send( 
}



static inline int ipa3_copy_ul_filter_rule_to_ipa(

	struct ipa_install_fltr_rule_req_msg_v01 *rule_req, uint32_t *rule_hdl)

	struct ipa3_install_fltr_rule_req_msg_v01 *rule_req)

{

	return -EPERM;

}
@@ -260,6 +261,6 @@ static inline int ipa3_qmi_stop_data_qouta(void) 


static inline void ipa3_q6_handshake_complete(bool ssr_bootup) { }



#endif /* CONFIG_RMNET_IPA */

#endif /* CONFIG_RMNET_IPA3 */



#endif /* IPA_QMI_SERVICE_H */

drivers/platform/msm/ipa/ipa_v3/rmnet_ipa.c

+16 −20
Original line number Diff line number Diff line
@@ -384,8 +384,8 @@ static void ipa3_del_dflt_wan_rt_tables(void) 
	kfree(rt_rule);

}



int ipa3_copy_ul_filter_rule_to_ipa(struct ipa_install_fltr_rule_req_msg_v01

		*rule_req, uint32_t *rule_hdl)

int ipa3_copy_ul_filter_rule_to_ipa(struct ipa3_install_fltr_rule_req_msg_v01

		*rule_req)

{

	int i, j;
@@ -408,10 +408,6 @@ int ipa3_copy_ul_filter_rule_to_ipa(struct ipa_install_fltr_rule_req_msg_v01 
				ipa3_num_q6_rule);

			goto failure;

		}

		/* construct UL_filter_rule handler QMI use-cas */

		ipa3_qmi_ctx->q6_ul_filter_rule[i].filter_hdl =

			UL_FILTER_RULE_HANDLE_START + i;

		rule_hdl[i] = ipa3_qmi_ctx->q6_ul_filter_rule[i].filter_hdl;

		ipa3_qmi_ctx->q6_ul_filter_rule[i].ip =

			rule_req->filter_spec_list[i].ip_type;

		ipa3_qmi_ctx->q6_ul_filter_rule[i].action =
@@ -423,6 +419,10 @@ int ipa3_copy_ul_filter_rule_to_ipa(struct ipa_install_fltr_rule_req_msg_v01 
		if (rule_req->filter_spec_list[i].is_mux_id_valid == true)

			ipa3_qmi_ctx->q6_ul_filter_rule[i].mux_id =

			rule_req->filter_spec_list[i].mux_id;

		ipa3_qmi_ctx->q6_ul_filter_rule[i].rule_id =

			rule_req->filter_spec_list[i].rule_id;

		ipa3_qmi_ctx->q6_ul_filter_rule[i].is_rule_hashable =

			rule_req->filter_spec_list[i].is_rule_hashable;

		ipa3_qmi_ctx->q6_ul_filter_rule[i].eq_attrib.rule_eq_bitmap =

			rule_req->filter_spec_list[i].filter_rule.

			rule_eq_bitmap;
@@ -599,10 +599,9 @@ static int ipa3_wwan_add_ul_flt_rule_to_ipa(void) 
{

	u32 pyld_sz;

	int i, retval = 0;

	int num_v4_rule = 0, num_v6_rule = 0;

	struct ipa_ioc_add_flt_rule *param;

	struct ipa_flt_rule_add flt_rule_entry;

	struct ipa_fltr_installed_notif_req_msg_v01 req;

	struct ipa3_fltr_installed_notif_req_msg_v01 req;



	pyld_sz = sizeof(struct ipa_ioc_add_flt_rule) +

	   sizeof(struct ipa_flt_rule_add);
@@ -624,6 +623,10 @@ static int ipa3_wwan_add_ul_flt_rule_to_ipa(void) 
		flt_rule_entry.rule.rt_tbl_idx

		= ipa3_qmi_ctx->q6_ul_filter_rule[i].rt_tbl_idx;

		flt_rule_entry.rule.retain_hdr = true;

		flt_rule_entry.rule.hashable =

			ipa3_qmi_ctx->q6_ul_filter_rule[i].is_rule_hashable;

		flt_rule_entry.rule.rule_id =

			ipa3_qmi_ctx->q6_ul_filter_rule[i].rule_id;



		/* debug rt-hdl*/

		IPAWANDBG("install-IPA index(%d),rt-tbl:(%d)\n",
@@ -644,22 +647,15 @@ static int ipa3_wwan_add_ul_flt_rule_to_ipa(void) 
		}

	}



	/* send ipa_fltr_installed_notif_req_msg_v01 to Q6*/

	memset(&req, 0, sizeof(struct ipa_fltr_installed_notif_req_msg_v01));

	/* send ipa3_fltr_installed_notif_req_msg_v01 to Q6*/

	memset(&req, 0, sizeof(struct ipa3_fltr_installed_notif_req_msg_v01));

	req.source_pipe_index =

		ipa3_get_ep_mapping(IPA_CLIENT_APPS_LAN_WAN_PROD);

	req.install_status = QMI_RESULT_SUCCESS_V01;

	req.filter_index_list_len = ipa3_num_q6_rule;

	req.rule_id_len = ipa3_num_q6_rule;

	for (i = 0; i < ipa3_num_q6_rule; i++) {

		if (ipa3_qmi_ctx->q6_ul_filter_rule[i].ip == IPA_IP_v4) {

			req.filter_index_list[i].filter_index = num_v4_rule;

			num_v4_rule++;

		} else {

			req.filter_index_list[i].filter_index = num_v6_rule;

			num_v6_rule++;

		}

		req.filter_index_list[i].filter_handle =

			ipa3_qmi_ctx->q6_ul_filter_rule[i].filter_hdl;

		req.rule_id[i] =

			ipa3_qmi_ctx->q6_ul_filter_rule[i].rule_id;

	}

	if (ipa3_qmi_filter_notify_send(&req)) {

		IPAWANDBG("add filter rule index on A7-RX failed\n");

include/uapi/linux/msm_ipa.h

+2 −0
Original line number Diff line number Diff line
@@ -1170,6 +1170,8 @@ struct ipa_ioc_ext_intf_prop { 
	uint8_t mux_id;

	uint32_t filter_hdl;

	uint8_t is_xlat_rule;

	uint32_t rule_id;

	uint8_t is_rule_hashable;

};



/**