static int handle_indication_req(void *req_h, void *req) { struct ipa_indication_reg_req_msg_v01 *indication_req; struct ipa_indication_reg_resp_msg_v01 resp; struct ipa_master_driver_init_complt_ind_msg_v01 ind; int rc; indication_req = (struct ipa_indication_reg_req_msg_v01 *)req; IPAWANDBG("Received INDICATION Request\n"); memset(&resp, 0, sizeof(struct ipa_indication_reg_resp_msg_v01)); resp.resp.result = IPA_QMI_RESULT_SUCCESS_V01; rc = qmi_send_resp_from_cb(ipa_svc_handle, curr_conn, req_h, &ipa_indication_reg_resp_desc, &resp, sizeof(resp)); qmi_indication_fin = true; /* check if need sending indication to modem */ if (qmi_modem_init_fin) { IPAWANDBG("send indication to modem (%d)\n", qmi_modem_init_fin); memset(&ind, 0, sizeof(struct ipa_master_driver_init_complt_ind_msg_v01)); ind.master_driver_init_status.result = IPA_QMI_RESULT_SUCCESS_V01; rc = qmi_send_ind_from_cb(ipa_svc_handle, curr_conn, &ipa_master_driver_complete_indication_desc, &ind, sizeof(ind)); } else { IPAWANERR("not send indication\n"); } return rc; }
/* sending filter-install-request to modem*/ int qmi_filter_request_send(struct ipa_install_fltr_rule_req_msg_v01 *req) { struct ipa_install_fltr_rule_resp_msg_v01 resp; struct msg_desc req_desc, resp_desc; int rc; /* check if the filter rules from IPACM is valid */ if (req->filter_spec_list_len == 0) { IPAWANDBG("IPACM pass zero rules to Q6\n"); } else { IPAWANDBG("IPACM pass %d rules to Q6\n", req->filter_spec_list_len); } req_desc.max_msg_len = QMI_IPA_INSTALL_FILTER_RULE_REQ_MAX_MSG_LEN_V01; req_desc.msg_id = QMI_IPA_INSTALL_FILTER_RULE_REQ_V01; req_desc.ei_array = ipa_install_fltr_rule_req_msg_data_v01_ei; memset(&resp, 0, sizeof(struct ipa_install_fltr_rule_resp_msg_v01)); resp_desc.max_msg_len = QMI_IPA_INSTALL_FILTER_RULE_RESP_MAX_MSG_LEN_V01; resp_desc.msg_id = QMI_IPA_INSTALL_FILTER_RULE_RESP_V01; resp_desc.ei_array = ipa_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), &resp_desc, &resp, sizeof(resp), QMI_SEND_REQ_TIMEOUT_MS); return ipa_check_qmi_response(rc, QMI_IPA_INSTALL_FILTER_RULE_REQ_V01, resp.resp.result, resp.resp.error, "ipa_install_filter"); }
static void ipa_q6_clnt_ind_cb(struct qmi_handle *handle, unsigned int msg_id, void *msg, unsigned int msg_len, void *ind_cb_priv) { struct ipa_data_usage_quota_reached_ind_msg_v01 qmi_ind; struct msg_desc qmi_ind_desc; int rc = 0; if (handle != ipa_q6_clnt) { IPAWANERR("Wrong client\n"); return; } if (QMI_IPA_DATA_USAGE_QUOTA_REACHED_IND_V01 == msg_id) { memset(&qmi_ind, 0, sizeof( struct ipa_data_usage_quota_reached_ind_msg_v01)); qmi_ind_desc.max_msg_len = QMI_IPA_DATA_USAGE_QUOTA_REACHED_IND_MAX_MSG_LEN_V01; qmi_ind_desc.msg_id = QMI_IPA_DATA_USAGE_QUOTA_REACHED_IND_V01; qmi_ind_desc.ei_array = ipa_data_usage_quota_reached_ind_msg_data_v01_ei; rc = qmi_kernel_decode(&qmi_ind_desc, &qmi_ind, msg, msg_len); if (rc < 0) { IPAWANERR("Error decoding msg_id %d\n", msg_id); return; } IPAWANDBG("Quota reached indication on qmux(%d) Mbytes(%lu)\n", qmi_ind.apn.mux_id, (long unsigned int) qmi_ind.apn.num_Mbytes); ipa_broadcast_quota_reach_ind(qmi_ind.apn.mux_id); } }
static int handle_filter_installed_notify_req(void *req_h, void *req) { struct ipa_fltr_installed_notif_resp_msg_v01 resp; int rc = 0; memset(&resp, 0, sizeof(struct ipa_fltr_installed_notif_resp_msg_v01)); IPAWANDBG("Received filter_install_notify Request\n"); resp.resp.result = IPA_QMI_RESULT_SUCCESS_V01; rc = qmi_send_resp_from_cb(ipa_svc_handle, curr_conn, req_h, &ipa_filter_installed_notif_resp_desc, &resp, sizeof(resp)); IPAWANDBG("Responsed filter_install_notify Request\n"); return rc; }
static int ipa_check_qmi_response(int rc, int req_id, enum ipa_qmi_result_type_v01 result, enum ipa_qmi_error_type_v01 error, char *resp_type) { if (rc < 0) { if (rc == -ETIMEDOUT && ipa_rmnet_ctx.ipa_rmnet_ssr) { IPAWANERR( "Timeout for qmi request id %d\n", req_id); return rc; } if (rc == -ENETRESET) { IPAWANERR( "SSR while waiting for qmi request id %d\n", req_id); return rc; } IPAWANERR("Error sending qmi request id %d, rc = %d\n", req_id, rc); return rc; } if (result != IPA_QMI_RESULT_SUCCESS_V01 && ipa_rmnet_ctx.ipa_rmnet_ssr) { IPAWANERR( "Got bad response %d from request id %d (error %d)\n", req_id, result, error); return result; } IPAWANDBG("Received %s successfully\n", resp_type); return 0; }
static int 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; uint32_t rule_hdl[MAX_NUM_Q6_RULE]; int rc = 0, i; rule_req = (struct ipa_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)); IPAWANDBG("Received install filter Request\n"); rc = copy_ul_filter_rule_to_ipa((struct ipa_install_fltr_rule_req_msg_v01*)req, rule_hdl); 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; 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 = rule_req->filter_spec_list_len; } } else { resp.filter_handle_list_valid = false; } /* 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]; } rc = qmi_send_resp_from_cb(ipa_svc_handle, curr_conn, req_h, &ipa_install_fltr_rule_resp_desc, &resp, sizeof(resp)); IPAWANDBG("Replied to install filter request\n"); return rc; }
static int handle_ipa_config_req(void *req_h, void *req) { struct ipa_config_resp_msg_v01 resp; int rc; memset(&resp, 0, sizeof(struct ipa_config_resp_msg_v01)); resp.resp.result = IPA_QMI_RESULT_SUCCESS_V01; IPAWANDBG("Received IPA CONFIG Request\n"); rc = ipa_mhi_handle_ipa_config_req( (struct ipa_config_req_msg_v01 *)req); if (rc) { IPAERR("ipa_mhi_handle_ipa_config_req failed %d\n", rc); resp.resp.result = IPA_QMI_RESULT_FAILURE_V01; } rc = qmi_send_resp_from_cb(ipa_svc_handle, curr_conn, req_h, &ipa_config_resp_desc, &resp, sizeof(resp)); IPAWANDBG("Responsed IPA CONFIG Request\n"); return rc; }
static void ipa_a5_svc_recv_msg(struct work_struct *work) { int rc; do { IPAWANDBG("Notified about a Receive Event"); rc = qmi_recv_msg(ipa_svc_handle); } while (rc == 0); if (rc != -ENOMSG) IPAWANERR("Error receiving message\n"); }
static void ipa_q6_clnt_notify(struct qmi_handle *handle, enum qmi_event_type event, void *notify_priv) { switch (event) { case QMI_RECV_MSG: IPAWANDBG("client qmi recv message called"); queue_delayed_work(ipa_clnt_resp_workqueue, &work_recv_msg_client, 0); break; default: break; } }
int wan_ioctl_init(void) { unsigned int wan_ioctl_major = 0; int ret; struct device *dev; device = MKDEV(wan_ioctl_major, 0); ret = alloc_chrdev_region(&device, 0, dev_num, DRIVER_NAME); if (ret) { IPAWANERR(":device_alloc err.\n"); goto dev_alloc_err; } wan_ioctl_major = MAJOR(device); class = class_create(THIS_MODULE, DRIVER_NAME); if (IS_ERR(class)) { IPAWANERR(":class_create err.\n"); goto class_err; } dev = device_create(class, NULL, device, NULL, DRIVER_NAME); if (IS_ERR(dev)) { IPAWANERR(":device_create err.\n"); goto device_err; } cdev_init(&wan_ioctl_cdev, &fops); ret = cdev_add(&wan_ioctl_cdev, device, dev_num); if (ret) { IPAWANERR(":cdev_add err.\n"); goto cdev_add_err; } process_ioctl = 1; IPAWANDBG("IPA %s major(%d) initial ok :>>>>\n", DRIVER_NAME, wan_ioctl_major); return 0; cdev_add_err: device_destroy(class, device); device_err: class_destroy(class); class_err: unregister_chrdev_region(device, dev_num); dev_alloc_err: return -ENODEV; }
int qmi_disable_force_clear_datapath_send( struct ipa_disable_force_clear_datapath_req_msg_v01 *req) { struct ipa_disable_force_clear_datapath_resp_msg_v01 resp; struct msg_desc req_desc, resp_desc; int rc = 0; if (!req) { IPAWANERR("invalid params\n"); return -EINVAL; } req_desc.max_msg_len = QMI_IPA_DISABLE_FORCE_CLEAR_DATAPATH_REQ_MAX_MSG_LEN_V01; req_desc.msg_id = QMI_IPA_DISABLE_FORCE_CLEAR_DATAPATH_REQ_V01; req_desc.ei_array = ipa_disable_force_clear_datapath_req_msg_data_v01_ei; memset(&resp, 0, sizeof(struct ipa_fltr_installed_notif_resp_msg_v01)); resp_desc.max_msg_len = QMI_IPA_DISABLE_FORCE_CLEAR_DATAPATH_RESP_MAX_MSG_LEN_V01; resp_desc.msg_id = QMI_IPA_DISABLE_FORCE_CLEAR_DATAPATH_RESP_V01; resp_desc.ei_array = ipa_disable_force_clear_datapath_resp_msg_data_v01_ei; rc = qmi_send_req_wait(ipa_q6_clnt, &req_desc, req, sizeof(*req), &resp_desc, &resp, sizeof(resp), 0); if (rc < 0) { IPAWANERR("send req failed %d\n", rc); return rc; } if (resp.resp.result != IPA_QMI_RESULT_SUCCESS_V01) { IPAWANERR("filter_notify failed %d\n", resp.resp.result); return resp.resp.result; } IPAWANDBG("SUCCESS\n"); return rc; }
int wan_ioctl_init(void) { unsigned int wan_ioctl_major = 0; dev_t device = MKDEV(wan_ioctl_major, 0); int alloc_ret = 0; int cdev_ret = 0; struct class *class; struct device *dev; alloc_ret = alloc_chrdev_region(&device, 0, dev_num, DRIVER_NAME); if (alloc_ret) { IPAWANERR(":device_alloc err.\n"); goto error; } wan_ioctl_major = MAJOR(device); class = class_create(THIS_MODULE, DRIVER_NAME); dev = device_create(class, NULL, device, NULL, DRIVER_NAME); if (IS_ERR(dev)) { IPAWANERR(":device_create err.\n"); goto error; } cdev_init(&wan_ioctl_cdev, &fops); cdev_ret = cdev_add(&wan_ioctl_cdev, device, dev_num); if (cdev_ret) { IPAWANERR(":cdev_add err.\n"); goto error; } IPAWANDBG("IPA %s major(%d) initial ok :>>>>\n", DRIVER_NAME, wan_ioctl_major); return 0; error: if (cdev_ret == 0) cdev_del(&wan_ioctl_cdev); if (alloc_ret == 0) unregister_chrdev_region(device, dev_num); return -ENODEV; }
static long wan_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { int retval = 0; u32 pyld_sz; u8 *param = NULL; IPAWANDBG("device %s got ioctl events :>>>\n", DRIVER_NAME); switch (cmd) { case WAN_IOC_ADD_FLT_RULE: IPAWANDBG("device %s got WAN_IOC_ADD_FLT_RULE :>>>\n", DRIVER_NAME); pyld_sz = sizeof(struct ipa_install_fltr_rule_req_msg_v01); param = kzalloc(pyld_sz, GFP_KERNEL); if (!param) { retval = -ENOMEM; break; } if (copy_from_user(param, (u8 *)arg, pyld_sz)) { retval = -EFAULT; break; } if (qmi_filter_request_send( (struct ipa_install_fltr_rule_req_msg_v01 *)param)) { IPAWANDBG("IPACM->Q6 add filter rule failed\n"); retval = -EFAULT; break; } if (copy_to_user((u8 *)arg, param, pyld_sz)) { retval = -EFAULT; break; } break; case WAN_IOC_ADD_FLT_RULE_INDEX: IPAWANDBG("device %s got WAN_IOC_ADD_FLT_RULE_INDEX :>>>\n", DRIVER_NAME); pyld_sz = sizeof(struct ipa_fltr_installed_notif_req_msg_v01); param = kzalloc(pyld_sz, GFP_KERNEL); if (!param) { retval = -ENOMEM; break; } if (copy_from_user(param, (u8 *)arg, pyld_sz)) { retval = -EFAULT; break; } if (qmi_filter_notify_send( (struct ipa_fltr_installed_notif_req_msg_v01 *)param)) { IPAWANDBG("IPACM->Q6 rule index fail\n"); retval = -EFAULT; break; } if (copy_to_user((u8 *)arg, param, pyld_sz)) { retval = -EFAULT; break; } break; default: retval = -ENOTTY; } kfree(param); return retval; }
static int wan_ioctl_open(struct inode *inode, struct file *filp) { IPAWANDBG("\n IPA A7 wan_ioctl open OK :>>>> "); return 0; }
static void ipa_q6_clnt_svc_arrive(struct work_struct *work) { int rc; struct ipa_master_driver_init_complt_ind_msg_v01 ind; /* Create a Local client port for QMI communication */ ipa_q6_clnt = qmi_handle_create(ipa_q6_clnt_notify, NULL); if (!ipa_q6_clnt) { IPAWANERR("QMI client handle alloc failed\n"); return; } IPAWANDBG("Lookup server name, get client-hdl(%p)\n", ipa_q6_clnt); rc = qmi_connect_to_service(ipa_q6_clnt, IPA_Q6_SERVICE_SVC_ID, IPA_Q6_SVC_VERS, IPA_Q6_SERVICE_INS_ID); if (rc < 0) { IPAWANERR("Server not found\n"); qmi_handle_destroy(ipa_q6_clnt); ipa_q6_clnt = NULL; return; } rc = qmi_register_ind_cb(ipa_q6_clnt, ipa_q6_clnt_ind_cb, NULL); if (rc < 0) IPAWANERR("Unable to register for indications\n"); ipa_q6_clnt_reset = 0; IPAWANDBG("Q6 QMI service available now\n"); /* Initialize modem IPA-driver */ IPAWANDBG("send qmi_init_modem_send_sync_msg to modem\n"); rc = qmi_init_modem_send_sync_msg(); if (rc == -ENETRESET) { IPAWANERR("qmi_init_modem_send_sync_msg failed due to SSR!\n"); /* Cleanup will take place when ipa_wwan_remove is called */ return; } if (rc != 0) { IPAWANERR("qmi_init_modem_send_sync_msg failed\n"); /* * This is a very unexpected scenario, which requires a kernel * panic in order to force dumps for QMI/Q6 side analysis. */ BUG(); return; } qmi_modem_init_fin = true; ipa_proxy_clk_unvote(); /* is_load_uc=FALSE indicates that SSR has occured */ ipa_q6_handshake_complete(!is_load_uc); IPAWANDBG("complete, qmi_modem_init_fin : %d\n", qmi_modem_init_fin); if (qmi_indication_fin) { IPAWANDBG("send indication to modem (%d)\n", qmi_indication_fin); memset(&ind, 0, sizeof(struct ipa_master_driver_init_complt_ind_msg_v01)); ind.master_driver_init_status.result = IPA_QMI_RESULT_SUCCESS_V01; rc = qmi_send_ind(ipa_svc_handle, curr_conn, &ipa_master_driver_complete_indication_desc, &ind, sizeof(ind)); IPAWANDBG("ipa_qmi_service_client good\n"); } else { IPAWANERR("not send indication (%d)\n", qmi_indication_fin); } }
static long wan_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { int retval = 0; u32 pyld_sz; u8 *param = NULL; IPAWANDBG("device %s got ioctl events :>>>\n", DRIVER_NAME); if (!process_ioctl) { IPAWANDBG("modem is in SSR, ignoring ioctl\n"); return -EAGAIN; } switch (cmd) { case WAN_IOC_ADD_FLT_RULE: IPAWANDBG("device %s got WAN_IOC_ADD_FLT_RULE :>>>\n", DRIVER_NAME); pyld_sz = sizeof(struct ipa_install_fltr_rule_req_msg_v01); param = kzalloc(pyld_sz, GFP_KERNEL); if (!param) { retval = -ENOMEM; break; } if (copy_from_user(param, (u8 *)arg, pyld_sz)) { retval = -EFAULT; break; } if (qmi_filter_request_send( (struct ipa_install_fltr_rule_req_msg_v01 *)param)) { IPAWANDBG("IPACM->Q6 add filter rule failed\n"); retval = -EFAULT; break; } if (copy_to_user((u8 *)arg, param, pyld_sz)) { retval = -EFAULT; break; } break; case WAN_IOC_ADD_FLT_RULE_INDEX: IPAWANDBG("device %s got WAN_IOC_ADD_FLT_RULE_INDEX :>>>\n", DRIVER_NAME); pyld_sz = sizeof(struct ipa_fltr_installed_notif_req_msg_v01); param = kzalloc(pyld_sz, GFP_KERNEL); if (!param) { retval = -ENOMEM; break; } if (copy_from_user(param, (u8 *)arg, pyld_sz)) { retval = -EFAULT; break; } if (qmi_filter_notify_send( (struct ipa_fltr_installed_notif_req_msg_v01 *)param)) { IPAWANDBG("IPACM->Q6 rule index fail\n"); retval = -EFAULT; break; } if (copy_to_user((u8 *)arg, param, pyld_sz)) { retval = -EFAULT; break; } break; case WAN_IOC_VOTE_FOR_BW_MBPS: IPAWANDBG("device %s got WAN_IOC_VOTE_FOR_BW_MBPS :>>>\n", DRIVER_NAME); pyld_sz = sizeof(uint32_t); param = kzalloc(pyld_sz, GFP_KERNEL); if (!param) { retval = -ENOMEM; break; } if (copy_from_user(param, (u8 *)arg, pyld_sz)) { retval = -EFAULT; break; } if (vote_for_bus_bw((uint32_t *)param)) { IPAWANERR("Failed to vote for bus BW\n"); retval = -EFAULT; break; } if (copy_to_user((u8 *)arg, param, pyld_sz)) { retval = -EFAULT; break; } break; case WAN_IOC_POLL_TETHERING_STATS: IPAWANDBG("device %s got WAN_IOCTL_POLL_TETHERING_STATS :>>>\n", DRIVER_NAME); pyld_sz = sizeof(struct wan_ioctl_poll_tethering_stats); param = kzalloc(pyld_sz, GFP_KERNEL); if (!param) { retval = -ENOMEM; break; } if (copy_from_user(param, (u8 *)arg, pyld_sz)) { retval = -EFAULT; break; } if (rmnet_ipa_poll_tethering_stats( (struct wan_ioctl_poll_tethering_stats *)param)) { IPAWANERR("WAN_IOCTL_POLL_TETHERING_STATS failed\n"); retval = -EFAULT; break; } if (copy_to_user((u8 *)arg, param, pyld_sz)) { retval = -EFAULT; break; } break; case WAN_IOC_SET_DATA_QUOTA: IPAWANDBG("device %s got WAN_IOCTL_SET_DATA_QUOTA :>>>\n", DRIVER_NAME); pyld_sz = sizeof(struct wan_ioctl_set_data_quota); param = kzalloc(pyld_sz, GFP_KERNEL); if (!param) { retval = -ENOMEM; break; } if (copy_from_user(param, (u8 *)arg, pyld_sz)) { retval = -EFAULT; break; } if (rmnet_ipa_set_data_quota( (struct wan_ioctl_set_data_quota *)param)) { IPAWANERR("WAN_IOC_SET_DATA_QUOTA failed\n"); retval = -EFAULT; break; } if (copy_to_user((u8 *)arg, param, pyld_sz)) { retval = -EFAULT; break; } break; default: retval = -ENOTTY; } kfree(param); return retval; }
static int qmi_init_modem_send_sync_msg(void) { struct ipa_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 = ipa_get_smem_restr_bytes(); memset(&req, 0, sizeof(struct ipa_init_modem_driver_req_msg_v01)); memset(&resp, 0, sizeof(struct ipa_init_modem_driver_resp_msg_v01)); req.platform_type_valid = true; req.platform_type = ipa_wan_platform; req.hdr_tbl_info_valid = true; req.hdr_tbl_info.modem_offset_start = IPA_MEM_PART(modem_hdr_ofst) + smem_restr_bytes; req.hdr_tbl_info.modem_offset_end = IPA_MEM_PART(modem_hdr_ofst) + smem_restr_bytes + IPA_MEM_PART(modem_hdr_size) - 1; req.v4_route_tbl_info_valid = true; req.v4_route_tbl_info.route_tbl_start_addr = IPA_MEM_PART(v4_rt_ofst) + smem_restr_bytes; req.v4_route_tbl_info.num_indices = IPA_MEM_PART(v4_modem_rt_index_hi); req.v6_route_tbl_info_valid = true; req.v6_route_tbl_info.route_tbl_start_addr = IPA_MEM_PART(v6_rt_ofst) + smem_restr_bytes; req.v6_route_tbl_info.num_indices = IPA_MEM_PART(v6_modem_rt_index_hi); req.v4_filter_tbl_start_addr_valid = true; req.v4_filter_tbl_start_addr = IPA_MEM_PART(v4_flt_ofst) + smem_restr_bytes; req.v6_filter_tbl_start_addr_valid = true; req.v6_filter_tbl_start_addr = IPA_MEM_PART(v6_flt_ofst) + smem_restr_bytes; req.modem_mem_info_valid = true; req.modem_mem_info.block_start_addr = IPA_MEM_PART(modem_ofst) + smem_restr_bytes; req.modem_mem_info.size = IPA_MEM_PART(modem_size); req.ctrl_comm_dest_end_pt_valid = true; req.ctrl_comm_dest_end_pt = ipa_get_ep_mapping(IPA_CLIENT_APPS_WAN_CONS); req.hdr_proc_ctx_tbl_info_valid = true; req.hdr_proc_ctx_tbl_info.modem_offset_start = IPA_MEM_PART(modem_hdr_proc_ctx_ofst) + smem_restr_bytes; req.hdr_proc_ctx_tbl_info.modem_offset_end = IPA_MEM_PART(modem_hdr_proc_ctx_ofst) + IPA_MEM_PART(modem_hdr_proc_ctx_size) + smem_restr_bytes - 1; if (is_load_uc) { /* First time boot */ req.is_ssr_bootup_valid = false; req.is_ssr_bootup = 0; } else { /* After SSR boot */ req.is_ssr_bootup_valid = true; req.is_ssr_bootup = 1; } IPAWANDBG("platform_type %d\n", req.platform_type); IPAWANDBG("hdr_tbl_info.modem_offset_start %d\n", req.hdr_tbl_info.modem_offset_start); IPAWANDBG("hdr_tbl_info.modem_offset_end %d\n", req.hdr_tbl_info.modem_offset_end); IPAWANDBG("v4_route_tbl_info.route_tbl_start_addr %d\n", req.v4_route_tbl_info.route_tbl_start_addr); IPAWANDBG("v4_route_tbl_info.num_indices %d\n", req.v4_route_tbl_info.num_indices); IPAWANDBG("v6_route_tbl_info.route_tbl_start_addr %d\n", req.v6_route_tbl_info.route_tbl_start_addr); IPAWANDBG("v6_route_tbl_info.num_indices %d\n", req.v6_route_tbl_info.num_indices); IPAWANDBG("v4_filter_tbl_start_addr %d\n", req.v4_filter_tbl_start_addr); IPAWANDBG("v6_filter_tbl_start_addr %d\n", req.v6_filter_tbl_start_addr); IPAWANDBG("modem_mem_info.block_start_addr %d\n", req.modem_mem_info.block_start_addr); IPAWANDBG("modem_mem_info.size %d\n", req.modem_mem_info.size); IPAWANDBG("ctrl_comm_dest_end_pt %d\n", 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; req_desc.msg_id = QMI_IPA_INIT_MODEM_DRIVER_REQ_V01; req_desc.ei_array = ipa_init_modem_driver_req_msg_data_v01_ei; resp_desc.max_msg_len = QMI_IPA_INIT_MODEM_DRIVER_RESP_MAX_MSG_LEN_V01; resp_desc.msg_id = QMI_IPA_INIT_MODEM_DRIVER_RESP_V01; resp_desc.ei_array = ipa_init_modem_driver_resp_msg_data_v01_ei; pr_info("Sending QMI_IPA_INIT_MODEM_DRIVER_REQ_V01\n"); rc = qmi_send_req_wait(ipa_q6_clnt, &req_desc, &req, sizeof(req), &resp_desc, &resp, sizeof(resp), QMI_SEND_REQ_TIMEOUT_MS); pr_info("QMI_IPA_INIT_MODEM_DRIVER_REQ_V01 response received\n"); return ipa_check_qmi_response(rc, QMI_IPA_INIT_MODEM_DRIVER_REQ_V01, resp.resp.result, resp.resp.error, "ipa_init_modem_driver_resp_msg_v01"); }