From 2926b2b8d0a51c821c5e3aafb29f60b122ead5a3 Mon Sep 17 00:00:00 2001 From: Amir Levy Date: Mon, 18 May 2020 15:20:48 +0300 Subject: [PATCH] msm: ipa: Add more ipa API to ipa framework Add IPA framework support for the following ipa clients: ipa_wdi3 ipa_gsb ipa_uc_offload ipa_mhi ipa_wigig this comes as an addition to ipa_usb support. Add all remaining IPA core driver API functions. remove internal functions from ipa.h header file. Change-Id: I03ac94c351649c7c59a3894e6e18bb504d488af9 Signed-off-by: Amir Levy --- drivers/platform/msm/ipa_fmwk/ipa_fmwk.c | 1513 +++++++++++++++++++++- include/linux/ipa.h | 1488 ++++++++------------- include/linux/ipa_fmwk.h | 261 ++++ include/linux/ipa_odu_bridge.h | 17 +- include/linux/ipa_wigig.h | 4 +- 5 files changed, 2286 insertions(+), 997 deletions(-) diff --git a/drivers/platform/msm/ipa_fmwk/ipa_fmwk.c b/drivers/platform/msm/ipa_fmwk/ipa_fmwk.c index 3858e206b49d..9459dff2a648 100644 --- a/drivers/platform/msm/ipa_fmwk/ipa_fmwk.c +++ b/drivers/platform/msm/ipa_fmwk/ipa_fmwk.c @@ -3,15 +3,7 @@ * Copyright (c) 2015-2020, The Linux Foundation. All rights reserved. */ -#include -#include -#include -#include -#include -#include -#include #include - #include #include #include @@ -19,6 +11,27 @@ #include #define IPA_FMWK_DISPATCH_RETURN(api, p...) \ + do { \ + if (!ipa_fmwk_ctx) { \ + pr_err("%s:%d IPA framework was not inited\n", \ + __func__, __LINE__); \ + ret = -EPERM; \ + } \ + else { \ + if (ipa_fmwk_ctx->api) { \ + pr_debug("enter %s\n", __func__);\ + ret = ipa_fmwk_ctx->api(p); \ + pr_debug("exit %s\n", __func__);\ + } else { \ + WARN(1, \ + "%s was not registered on ipa_fmwk\n", \ + __func__); \ + ret = -EPERM; \ + } \ + } \ + } while (0) + +#define IPA_FMWK_DISPATCH_RETURN_DP(api, p...) \ do { \ if (!ipa_fmwk_ctx) { \ pr_err("%s:%d IPA framework was not inited\n", \ @@ -37,6 +50,45 @@ } \ } while (0) +#define IPA_FMWK_DISPATCH(api, p...) \ + do { \ + if (!ipa_fmwk_ctx) \ + pr_err("%s:%d IPA framework is not supported\n", \ + __func__, __LINE__); \ + else { \ + if (ipa_fmwk_ctx->api) { \ + pr_debug("enter %s\n", __func__);\ + ipa_fmwk_ctx->api(p); \ + pr_debug("exit %s\n", __func__);\ + } else { \ + WARN(1, \ + "%s was not registered on ipa_fmwk\n", \ + __func__); \ + } \ + } \ + } while (0) + +#define IPA_FMWK_RETURN_BOOL(api, p...) \ + do { \ + if (!ipa_fmwk_ctx) { \ + pr_err("%s:%d IPA framework is not supported\n", \ + __func__, __LINE__); \ + ret = false; \ + } \ + else { \ + if (ipa_fmwk_ctx->api) { \ + pr_debug("enter %s\n", __func__);\ + ret = ipa_fmwk_ctx->api(p); \ + pr_debug("exit %s\n", __func__);\ + } else { \ + WARN(1, \ + "%s was not registered on ipa_fmwk\n", \ + __func__); \ + ret = false; \ + } \ + } \ + } while (0) + /** * struct ipa_ready_cb_info - A list of all the registrations * for an indication of IPA driver readiness @@ -56,11 +108,100 @@ struct ipa_fmwk_contex { bool ipa_ready; struct list_head ipa_ready_cb_list; struct mutex lock; + ipa_uc_ready_cb uc_ready_cb; + void *uc_ready_priv; + enum ipa_uc_offload_proto proto; /* ipa core driver APIs */ int (*ipa_tx_dp)(enum ipa_client_type dst, struct sk_buff *skb, struct ipa_tx_meta *metadata); + enum ipa_hw_type (*ipa_get_hw_type)(void); + + int (*ipa_get_smmu_params)(struct ipa_smmu_in_params *in, + struct ipa_smmu_out_params *out); + + int (*ipa_is_vlan_mode)(enum ipa_vlan_ifaces iface, bool *res); + + bool (*ipa_get_lan_rx_napi)(void); + + int (*ipa_dma_init)(void); + + int (*ipa_dma_enable)(void); + + int (*ipa_dma_disable)(void); + + int (*ipa_dma_sync_memcpy)(u64 dest, u64 src, int len); + + int (*ipa_dma_async_memcpy)(u64 dest, u64 src, int len, + void (*user_cb)(void *user1), void *user_param); + + void (*ipa_dma_destroy)(void); + + int (*ipa_get_ep_mapping)(enum ipa_client_type client); + + int (*ipa_send_msg)(struct ipa_msg_meta *meta, void *buff, + ipa_msg_free_fn callback); + + void (*ipa_free_skb)(struct ipa_rx_data *data); + + int (*ipa_setup_sys_pipe)(struct ipa_sys_connect_params *sys_in, + u32 *clnt_hdl); + + int (*ipa_teardown_sys_pipe)(u32 clnt_hdl); + + int (*ipa_get_wdi_stats)(struct IpaHwStatsWDIInfoData_t *stats); + + + int (*ipa_uc_bw_monitor)(struct ipa_wdi_bw_info *info); + + int (*ipa_broadcast_wdi_quota_reach_ind)(uint32_t fid, + uint64_t num_bytes); + + int (*ipa_uc_wdi_get_dbpa)(struct ipa_wdi_db_params *out); + + int (*ipa_cfg_ep_ctrl)(u32 clnt_hdl, + const struct ipa_ep_cfg_ctrl *ep_ctrl); + + int (*ipa_add_rt_rule)(struct ipa_ioc_add_rt_rule *rules); + + int (*ipa_put_rt_tbl)(u32 rt_tbl_hdl); + + int (*ipa_register_intf)(const char *name, + const struct ipa_tx_intf *tx, + const struct ipa_rx_intf *rx); + + int (*ipa_set_aggr_mode)(enum ipa_aggr_mode mode); + + int (*ipa_set_qcncm_ndp_sig)(char sig[3]); + + int (*ipa_set_single_ndp_per_mbim)(bool enable); + + int (*ipa_add_interrupt_handler)(enum ipa_irq_type interrupt, + ipa_irq_handler_t handler, + bool deferred_flag, + void *private_data); + + int (*ipa_restore_suspend_handler)(void); + + const struct ipa_gsi_ep_config *(*ipa_get_gsi_ep_info)( + enum ipa_client_type client); + + int (*ipa_stop_gsi_channel)(u32 clnt_hdl); + + int (*ipa_rmnet_ctl_xmit)(struct sk_buff *skb); + + int (*ipa_register_rmnet_ctl_cb)( + void (*ipa_rmnet_ctl_ready_cb)(void *user_data1), + void *user_data1, + void (*ipa_rmnet_ctl_stop_cb)(void *user_data2), + void *user_data2, + void (*ipa_rmnet_ctl_rx_notify_cb)( + void *user_data3, void *rx_data), + void *user_data3); + + int (*ipa_unregister_rmnet_ctl_cb)(void); + /* ipa_usb APIs */ int (*ipa_usb_init_teth_prot)(enum ipa_usb_teth_prot teth_prot, struct ipa_usb_teth_params *teth_params, @@ -86,6 +227,135 @@ struct ipa_fmwk_contex { int (*ipa_usb_xdci_resume)(u32 ul_clnt_hdl, u32 dl_clnt_hdl, enum ipa_usb_teth_prot teth_prot); + + /* ipa_wdi3 APIs */ + int (*ipa_wdi_init)(struct ipa_wdi_init_in_params *in, + struct ipa_wdi_init_out_params *out); + + int (*ipa_wdi_cleanup)(void); + + int (*ipa_wdi_reg_intf)( + struct ipa_wdi_reg_intf_in_params *in); + + int (*ipa_wdi_dereg_intf)(const char *netdev_name); + + int (*ipa_wdi_conn_pipes)(struct ipa_wdi_conn_in_params *in, + struct ipa_wdi_conn_out_params *out); + + int (*ipa_wdi_disconn_pipes)(void); + + int (*ipa_wdi_enable_pipes)(void); + + int (*ipa_wdi_disable_pipes)(void); + + int (*ipa_wdi_set_perf_profile)(struct ipa_wdi_perf_profile *profile); + + int (*ipa_wdi_create_smmu_mapping)(u32 num_buffers, + struct ipa_wdi_buffer_info *info); + + int (*ipa_wdi_release_smmu_mapping)(u32 num_buffers, + struct ipa_wdi_buffer_info *info); + + int (*ipa_wdi_get_stats)(struct IpaHwStatsWDIInfoData_t *stats); + + int (*ipa_wdi_bw_monitor)(struct ipa_wdi_bw_info *info); + + int (*ipa_wdi_sw_stats)(struct ipa_wdi_tx_info *info); + + /* ipa_gsb APIs*/ + int (*ipa_bridge_init)(struct ipa_bridge_init_params *params, u32 *hdl); + + int (*ipa_bridge_connect)(u32 hdl); + + int (*ipa_bridge_set_perf_profile)(u32 hdl, u32 bandwidth); + + int (*ipa_bridge_disconnect)(u32 hdl); + + int (*ipa_bridge_suspend)(u32 hdl); + + int (*ipa_bridge_resume)(u32 hdl); + + int (*ipa_bridge_tx_dp)(u32 hdl, struct sk_buff *skb, + struct ipa_tx_meta *metadata); + + int (*ipa_bridge_cleanup)(u32 hdl); + + /* ipa_uc_offload APIs */ + + int (*ipa_uc_offload_reg_intf)( + struct ipa_uc_offload_intf_params *in, + struct ipa_uc_offload_out_params *out); + + int (*ipa_uc_offload_cleanup)(u32 clnt_hdl); + + int (*ipa_uc_offload_conn_pipes)( + struct ipa_uc_offload_conn_in_params *in, + struct ipa_uc_offload_conn_out_params *out); + + int (*ipa_uc_offload_disconn_pipes)(u32 clnt_hdl); + + int (*ipa_set_perf_profile)(struct ipa_perf_profile *profile); + + int (*ipa_uc_offload_reg_rdyCB)(struct ipa_uc_ready_params *param); + + void (*ipa_uc_offload_dereg_rdyCB)(enum ipa_uc_offload_proto proto); + + /* ipa_mhi APIs */ + int (*ipa_mhi_init)(struct ipa_mhi_init_params *params); + + int (*ipa_mhi_start)(struct ipa_mhi_start_params *params); + + int (*ipa_mhi_connect_pipe)(struct ipa_mhi_connect_params *in, + u32 *clnt_hdl); + + int (*ipa_mhi_disconnect_pipe)(u32 clnt_hdl); + + int (*ipa_mhi_suspend)(bool force); + + int (*ipa_mhi_resume)(void); + + void (*ipa_mhi_destroy)(void); + + int (*ipa_mhi_handle_ipa_config_req)( + struct ipa_config_req_msg_v01 *config_req); + + /* ipa_wigig APIs */ + int (*ipa_wigig_init)(struct ipa_wigig_init_in_params *in, + struct ipa_wigig_init_out_params *out); + + int (*ipa_wigig_cleanup)(void); + + bool (*ipa_wigig_is_smmu_enabled)(void); + + int (*ipa_wigig_reg_intf)(struct ipa_wigig_reg_intf_in_params *in); + + int (*ipa_wigig_dereg_intf)(const char *netdev_name); + + int (*ipa_wigig_conn_rx_pipe)(struct ipa_wigig_conn_rx_in_params *in, + struct ipa_wigig_conn_out_params *out); + + int (*ipa_wigig_conn_rx_pipe_smmu)( + struct ipa_wigig_conn_rx_in_params_smmu *in, + struct ipa_wigig_conn_out_params *out); + + int (*ipa_wigig_conn_client)(struct ipa_wigig_conn_tx_in_params *in, + struct ipa_wigig_conn_out_params *out); + + int (*ipa_wigig_conn_client_smmu)( + struct ipa_wigig_conn_tx_in_params_smmu *in, + struct ipa_wigig_conn_out_params *out); + + int (*ipa_wigig_disconn_pipe)(enum ipa_client_type client); + + int (*ipa_wigig_enable_pipe)(enum ipa_client_type client); + + int (*ipa_wigig_disable_pipe)(enum ipa_client_type client); + + int (*ipa_wigig_tx_dp)(enum ipa_client_type dst, struct sk_buff *skb); + + int (*ipa_wigig_set_perf_profile)(u32 max_supported_bw_mbps); + + int (*ipa_wigig_save_regs)(void); }; static struct ipa_fmwk_contex *ipa_fmwk_ctx; @@ -106,6 +376,25 @@ static inline void ipa_trigger_ipa_ready_cbs(void) } } +static inline void ipa_register_uc_ready_cb(void) +{ + int ret; + struct ipa_uc_ready_params param; + + if (ipa_fmwk_ctx->uc_ready_cb) { + param.notify = ipa_fmwk_ctx->uc_ready_cb; + param.priv = ipa_fmwk_ctx->uc_ready_priv; + param.proto = ipa_fmwk_ctx->proto; + + ret = ipa_fmwk_ctx->ipa_uc_offload_reg_rdyCB(¶m); + /* if uc is already ready, client expects cb to be called */ + if (param.is_uC_ready) { + ipa_fmwk_ctx->uc_ready_cb( + ipa_fmwk_ctx->uc_ready_priv); + } + } +} + /* registration API for IPA core module */ int ipa_fmwk_register_ipa(const struct ipa_core_data *in) { @@ -122,9 +411,48 @@ int ipa_fmwk_register_ipa(const struct ipa_core_data *in) } ipa_fmwk_ctx->ipa_tx_dp = in->ipa_tx_dp; + ipa_fmwk_ctx->ipa_get_hw_type = in->ipa_get_hw_type; + ipa_fmwk_ctx->ipa_is_vlan_mode = in->ipa_is_vlan_mode; + ipa_fmwk_ctx->ipa_get_smmu_params = in->ipa_get_smmu_params; + ipa_fmwk_ctx->ipa_get_lan_rx_napi = in->ipa_get_lan_rx_napi; + ipa_fmwk_ctx->ipa_dma_init = in->ipa_dma_init; + ipa_fmwk_ctx->ipa_dma_enable = in->ipa_dma_enable; + ipa_fmwk_ctx->ipa_dma_disable = in->ipa_dma_disable; + ipa_fmwk_ctx->ipa_dma_sync_memcpy = in->ipa_dma_sync_memcpy; + ipa_fmwk_ctx->ipa_dma_async_memcpy = in->ipa_dma_async_memcpy; + ipa_fmwk_ctx->ipa_dma_destroy = in->ipa_dma_destroy; + ipa_fmwk_ctx->ipa_get_ep_mapping = in->ipa_get_ep_mapping; + ipa_fmwk_ctx->ipa_send_msg = in->ipa_send_msg; + ipa_fmwk_ctx->ipa_free_skb = in->ipa_free_skb; + ipa_fmwk_ctx->ipa_setup_sys_pipe = in->ipa_setup_sys_pipe; + ipa_fmwk_ctx->ipa_teardown_sys_pipe = in->ipa_teardown_sys_pipe; + ipa_fmwk_ctx->ipa_get_wdi_stats = in->ipa_get_wdi_stats; + ipa_fmwk_ctx->ipa_uc_bw_monitor = in->ipa_uc_bw_monitor; + ipa_fmwk_ctx->ipa_broadcast_wdi_quota_reach_ind = + in->ipa_broadcast_wdi_quota_reach_ind; + ipa_fmwk_ctx->ipa_uc_wdi_get_dbpa = in->ipa_uc_wdi_get_dbpa; + ipa_fmwk_ctx->ipa_cfg_ep_ctrl = in->ipa_cfg_ep_ctrl; + ipa_fmwk_ctx->ipa_add_rt_rule = in->ipa_add_rt_rule; + ipa_fmwk_ctx->ipa_put_rt_tbl = in->ipa_put_rt_tbl; + ipa_fmwk_ctx->ipa_register_intf = in->ipa_register_intf; + ipa_fmwk_ctx->ipa_set_aggr_mode = in->ipa_set_aggr_mode; + ipa_fmwk_ctx->ipa_set_qcncm_ndp_sig = in->ipa_set_qcncm_ndp_sig; + ipa_fmwk_ctx->ipa_set_single_ndp_per_mbim = + in->ipa_set_single_ndp_per_mbim; + ipa_fmwk_ctx->ipa_add_interrupt_handler = in->ipa_add_interrupt_handler; + ipa_fmwk_ctx->ipa_restore_suspend_handler = + in->ipa_restore_suspend_handler; + ipa_fmwk_ctx->ipa_get_gsi_ep_info = in->ipa_get_gsi_ep_info; + ipa_fmwk_ctx->ipa_stop_gsi_channel = in->ipa_stop_gsi_channel; + ipa_fmwk_ctx->ipa_rmnet_ctl_xmit = in->ipa_rmnet_ctl_xmit; + ipa_fmwk_ctx->ipa_register_rmnet_ctl_cb = in->ipa_register_rmnet_ctl_cb; + ipa_fmwk_ctx->ipa_unregister_rmnet_ctl_cb = + in->ipa_unregister_rmnet_ctl_cb; ipa_fmwk_ctx->ipa_ready = true; ipa_trigger_ipa_ready_cbs(); + + ipa_register_uc_ready_cb(); mutex_unlock(&ipa_fmwk_ctx->lock); pr_info("IPA driver is now in ready state\n"); @@ -132,6 +460,15 @@ int ipa_fmwk_register_ipa(const struct ipa_core_data *in) } EXPORT_SYMBOL(ipa_fmwk_register_ipa); +bool ipa_is_ready(void) +{ + if (!ipa_fmwk_ctx) + return false; + + return ipa_fmwk_ctx->ipa_ready; +} +EXPORT_SYMBOL(ipa_is_ready); + int ipa_register_ipa_ready_cb(void(*ipa_ready_cb)(void *user_data), void *user_data) { @@ -172,13 +509,363 @@ int ipa_tx_dp(enum ipa_client_type dst, struct sk_buff *skb, { int ret; - IPA_FMWK_DISPATCH_RETURN(ipa_tx_dp, + IPA_FMWK_DISPATCH_RETURN_DP(ipa_tx_dp, dst, skb, metadata); return ret; } EXPORT_SYMBOL(ipa_tx_dp); +enum ipa_hw_type ipa_get_hw_type(void) +{ + enum ipa_hw_type ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_get_hw_type); + + return ret; +} +EXPORT_SYMBOL(ipa_get_hw_type); + +int ipa_is_vlan_mode(enum ipa_vlan_ifaces iface, bool *res) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_is_vlan_mode, + iface, res); + + return ret; +} +EXPORT_SYMBOL(ipa_is_vlan_mode); + +int ipa_get_smmu_params(struct ipa_smmu_in_params *in, + struct ipa_smmu_out_params *out) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_get_smmu_params, + in, out); + + return ret; +} +EXPORT_SYMBOL(ipa_get_smmu_params); + +bool ipa_get_lan_rx_napi(void) +{ + int ret; + + IPA_FMWK_RETURN_BOOL(ipa_get_lan_rx_napi); + + return ret; +} +EXPORT_SYMBOL(ipa_get_lan_rx_napi); + +int ipa_dma_init(void) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_dma_init); + + return ret; +} +EXPORT_SYMBOL(ipa_dma_init); + +int ipa_dma_enable(void) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_dma_enable); + + return ret; +} +EXPORT_SYMBOL(ipa_dma_enable); + +int ipa_dma_disable(void) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_dma_disable); + + return ret; +} +EXPORT_SYMBOL(ipa_dma_disable); + +int ipa_dma_sync_memcpy(u64 dest, u64 src, int len) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_dma_sync_memcpy, + dest, src, len); + + return ret; +} +EXPORT_SYMBOL(ipa_dma_sync_memcpy); + +int ipa_dma_async_memcpy(u64 dest, u64 src, int len, + void (*user_cb)(void *user1), void *user_param) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_dma_async_memcpy, + dest, src, len, user_cb, user_param); + + return ret; +} +EXPORT_SYMBOL(ipa_dma_async_memcpy); + +void ipa_dma_destroy(void) +{ + IPA_FMWK_DISPATCH(ipa_dma_destroy); +} +EXPORT_SYMBOL(ipa_dma_destroy); + +int ipa_get_ep_mapping(enum ipa_client_type client) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_get_ep_mapping, + client); + + return ret; +} +EXPORT_SYMBOL(ipa_get_ep_mapping); + +int ipa_send_msg(struct ipa_msg_meta *meta, void *buff, + ipa_msg_free_fn callback) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_send_msg, + meta, buff, callback); + + return ret; +} +EXPORT_SYMBOL(ipa_send_msg); + +void ipa_free_skb(struct ipa_rx_data *data) +{ + IPA_FMWK_DISPATCH(ipa_free_skb, data); +} +EXPORT_SYMBOL(ipa_free_skb); + +int ipa_setup_sys_pipe(struct ipa_sys_connect_params *sys_in, u32 *clnt_hdl) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_setup_sys_pipe, sys_in, clnt_hdl); + + return ret; +} +EXPORT_SYMBOL(ipa_setup_sys_pipe); + +int ipa_teardown_sys_pipe(u32 clnt_hdl) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_teardown_sys_pipe, clnt_hdl); + + return ret; +} +EXPORT_SYMBOL(ipa_teardown_sys_pipe); + +int ipa_get_wdi_stats(struct IpaHwStatsWDIInfoData_t *stats) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_get_wdi_stats, stats); + + return ret; +} +EXPORT_SYMBOL(ipa_get_wdi_stats); + +int ipa_uc_bw_monitor(struct ipa_wdi_bw_info *info) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_uc_bw_monitor, info); + + return ret; +} +EXPORT_SYMBOL(ipa_uc_bw_monitor); + +int ipa_broadcast_wdi_quota_reach_ind(uint32_t fid, + uint64_t num_bytes) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_broadcast_wdi_quota_reach_ind, + fid, num_bytes); + + return ret; +} +EXPORT_SYMBOL(ipa_broadcast_wdi_quota_reach_ind); + +int ipa_uc_wdi_get_dbpa( + struct ipa_wdi_db_params *param) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_uc_wdi_get_dbpa, param); + + return ret; +} +EXPORT_SYMBOL(ipa_uc_wdi_get_dbpa); + +int ipa_cfg_ep_ctrl(u32 clnt_hdl, const struct ipa_ep_cfg_ctrl *ep_ctrl) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_cfg_ep_ctrl, clnt_hdl, ep_ctrl); + + return ret; +} +EXPORT_SYMBOL(ipa_cfg_ep_ctrl); + +int ipa_add_rt_rule(struct ipa_ioc_add_rt_rule *rules) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_add_rt_rule, rules); + + return ret; +} +EXPORT_SYMBOL(ipa_add_rt_rule); + +int ipa_put_rt_tbl(u32 rt_tbl_hdl) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_put_rt_tbl, rt_tbl_hdl); + + return ret; +} +EXPORT_SYMBOL(ipa_put_rt_tbl); + +int ipa_register_intf(const char *name, + const struct ipa_tx_intf *tx, + const struct ipa_rx_intf *rx) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_register_intf, name, tx, rx); + + return ret; +} +EXPORT_SYMBOL(ipa_register_intf); + +int ipa_set_aggr_mode(enum ipa_aggr_mode mode) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_set_aggr_mode, mode); + + return ret; +} +EXPORT_SYMBOL(ipa_set_aggr_mode); + +int ipa_set_qcncm_ndp_sig(char sig[3]) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_set_qcncm_ndp_sig, sig); + + return ret; +} +EXPORT_SYMBOL(ipa_set_qcncm_ndp_sig); + +int ipa_set_single_ndp_per_mbim(bool enable) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_set_single_ndp_per_mbim, enable); + + return ret; +} +EXPORT_SYMBOL(ipa_set_single_ndp_per_mbim); + +int ipa_add_interrupt_handler(enum ipa_irq_type interrupt, + ipa_irq_handler_t handler, + bool deferred_flag, + void *private_data) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_add_interrupt_handler, + interrupt, handler, deferred_flag, private_data); + + return ret; +} +EXPORT_SYMBOL(ipa_add_interrupt_handler); + +int ipa_restore_suspend_handler(void) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_restore_suspend_handler); + + return ret; +} +EXPORT_SYMBOL(ipa_restore_suspend_handler); + +const struct ipa_gsi_ep_config *ipa_get_gsi_ep_info( + enum ipa_client_type client) +{ + if (!ipa_fmwk_ctx || !ipa_fmwk_ctx->ipa_get_gsi_ep_info) + return NULL; + + return ipa_fmwk_ctx->ipa_get_gsi_ep_info(client); +} +EXPORT_SYMBOL(ipa_get_gsi_ep_info); + +int ipa_stop_gsi_channel(u32 clnt_hdl) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_stop_gsi_channel, clnt_hdl); + + return ret; +} +EXPORT_SYMBOL(ipa_stop_gsi_channel); + +int ipa_rmnet_ctl_xmit(struct sk_buff *skb) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_rmnet_ctl_xmit, skb); + + return ret; +} +EXPORT_SYMBOL(ipa_rmnet_ctl_xmit); + +int ipa_register_rmnet_ctl_cb( + void (*ipa_rmnet_ctl_ready_cb)(void *user_data1), + void *user_data1, + void (*ipa_rmnet_ctl_stop_cb)(void *user_data2), + void *user_data2, + void (*ipa_rmnet_ctl_rx_notify_cb)( + void *user_data3, void *rx_data), + void *user_data3) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_register_rmnet_ctl_cb, + ipa_rmnet_ctl_ready_cb, user_data1, + ipa_rmnet_ctl_stop_cb, user_data2, + ipa_rmnet_ctl_rx_notify_cb, user_data3); + + return ret; +} +EXPORT_SYMBOL(ipa_register_rmnet_ctl_cb); + +int ipa_unregister_rmnet_ctl_cb(void) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_unregister_rmnet_ctl_cb); + + return ret; +} +EXPORT_SYMBOL(ipa_unregister_rmnet_ctl_cb); + /* registration API for IPA usb module */ int ipa_fmwk_register_ipa_usb(const struct ipa_usb_data *in) { @@ -203,6 +890,8 @@ int ipa_fmwk_register_ipa_usb(const struct ipa_usb_data *in) ipa_fmwk_ctx->ipa_usb_xdci_suspend = in->ipa_usb_xdci_suspend; ipa_fmwk_ctx->ipa_usb_xdci_resume = in->ipa_usb_xdci_resume; + pr_info("ipa_usb registered successfully\n"); + return 0; } EXPORT_SYMBOL(ipa_fmwk_register_ipa_usb); @@ -287,6 +976,812 @@ int ipa_usb_xdci_resume(u32 ul_clnt_hdl, u32 dl_clnt_hdl, } EXPORT_SYMBOL(ipa_usb_xdci_resume); +/* registration API for IPA wdi3 module */ +int ipa_fmwk_register_ipa_wdi3(const struct ipa_wdi3_data *in) +{ + if (!ipa_fmwk_ctx) { + pr_err("ipa framework hasn't been initialized yet\n"); + return -EPERM; + } + + if (ipa_fmwk_ctx->ipa_wdi_bw_monitor + || ipa_fmwk_ctx->ipa_wdi_init + || ipa_fmwk_ctx->ipa_wdi_cleanup + || ipa_fmwk_ctx->ipa_wdi_reg_intf + || ipa_fmwk_ctx->ipa_wdi_dereg_intf + || ipa_fmwk_ctx->ipa_wdi_conn_pipes + || ipa_fmwk_ctx->ipa_wdi_disconn_pipes + || ipa_fmwk_ctx->ipa_wdi_enable_pipes + || ipa_fmwk_ctx->ipa_wdi_disable_pipes + || ipa_fmwk_ctx->ipa_wdi_set_perf_profile + || ipa_fmwk_ctx->ipa_wdi_create_smmu_mapping + || ipa_fmwk_ctx->ipa_wdi_release_smmu_mapping + || ipa_fmwk_ctx->ipa_wdi_get_stats + || ipa_fmwk_ctx->ipa_wdi_sw_stats) { + pr_err("ipa_wdi3 APIs were already initialized\n"); + return -EPERM; + } + + ipa_fmwk_ctx->ipa_wdi_bw_monitor = in->ipa_wdi_bw_monitor; + ipa_fmwk_ctx->ipa_wdi_init = in->ipa_wdi_init; + ipa_fmwk_ctx->ipa_wdi_cleanup = in->ipa_wdi_cleanup; + ipa_fmwk_ctx->ipa_wdi_reg_intf = in->ipa_wdi_reg_intf; + ipa_fmwk_ctx->ipa_wdi_dereg_intf = in->ipa_wdi_dereg_intf; + ipa_fmwk_ctx->ipa_wdi_conn_pipes = in->ipa_wdi_conn_pipes; + ipa_fmwk_ctx->ipa_wdi_disconn_pipes = in->ipa_wdi_disconn_pipes; + ipa_fmwk_ctx->ipa_wdi_enable_pipes = in->ipa_wdi_enable_pipes; + ipa_fmwk_ctx->ipa_wdi_disable_pipes = in->ipa_wdi_disable_pipes; + ipa_fmwk_ctx->ipa_wdi_set_perf_profile = in->ipa_wdi_set_perf_profile; + ipa_fmwk_ctx->ipa_wdi_create_smmu_mapping = + in->ipa_wdi_create_smmu_mapping; + ipa_fmwk_ctx->ipa_wdi_release_smmu_mapping = + in->ipa_wdi_release_smmu_mapping; + ipa_fmwk_ctx->ipa_wdi_get_stats = in->ipa_wdi_get_stats; + ipa_fmwk_ctx->ipa_wdi_sw_stats = in->ipa_wdi_sw_stats; + + pr_info("ipa_wdi3 registered successfully\n"); + + return 0; +} +EXPORT_SYMBOL(ipa_fmwk_register_ipa_wdi3); + +/* ipa_wdi3 APIs */ +int ipa_wdi_init(struct ipa_wdi_init_in_params *in, + struct ipa_wdi_init_out_params *out) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wdi_init, + in, out); + + return ret; +} +EXPORT_SYMBOL(ipa_wdi_init); + +int ipa_wdi_cleanup(void) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wdi_cleanup); + + return ret; +} +EXPORT_SYMBOL(ipa_wdi_cleanup); + +int ipa_wdi_reg_intf( + struct ipa_wdi_reg_intf_in_params *in) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wdi_reg_intf, + in); + + return ret; +} +EXPORT_SYMBOL(ipa_wdi_reg_intf); + +int ipa_wdi_dereg_intf(const char *netdev_name) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wdi_dereg_intf, + netdev_name); + + return ret; +} +EXPORT_SYMBOL(ipa_wdi_dereg_intf); + +int ipa_wdi_conn_pipes(struct ipa_wdi_conn_in_params *in, + struct ipa_wdi_conn_out_params *out) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wdi_conn_pipes, + in, out); + + return ret; +} +EXPORT_SYMBOL(ipa_wdi_conn_pipes); + +int ipa_wdi_disconn_pipes(void) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wdi_disconn_pipes); + + return ret; +} +EXPORT_SYMBOL(ipa_wdi_disconn_pipes); + +int ipa_wdi_enable_pipes(void) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wdi_enable_pipes); + + return ret; +} +EXPORT_SYMBOL(ipa_wdi_enable_pipes); + +int ipa_wdi_disable_pipes(void) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wdi_disable_pipes); + + return ret; +} +EXPORT_SYMBOL(ipa_wdi_disable_pipes); + +int ipa_wdi_set_perf_profile(struct ipa_wdi_perf_profile *profile) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wdi_set_perf_profile, + profile); + + return ret; +} +EXPORT_SYMBOL(ipa_wdi_set_perf_profile); + +int ipa_wdi_create_smmu_mapping(u32 num_buffers, + struct ipa_wdi_buffer_info *info) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN_DP(ipa_wdi_create_smmu_mapping, + num_buffers, info); + + return ret; +} +EXPORT_SYMBOL(ipa_wdi_create_smmu_mapping); + +int ipa_wdi_release_smmu_mapping(u32 num_buffers, + struct ipa_wdi_buffer_info *info) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN_DP(ipa_wdi_release_smmu_mapping, + num_buffers, info); + + return ret; +} +EXPORT_SYMBOL(ipa_wdi_release_smmu_mapping); + +int ipa_wdi_get_stats(struct IpaHwStatsWDIInfoData_t *stats) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wdi_get_stats, + stats); + + return ret; +} +EXPORT_SYMBOL(ipa_wdi_get_stats); + +int ipa_wdi_bw_monitor(struct ipa_wdi_bw_info *info) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wdi_bw_monitor, + info); + + return ret; +} +EXPORT_SYMBOL(ipa_wdi_bw_monitor); + +int ipa_wdi_sw_stats(struct ipa_wdi_tx_info *info) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wdi_sw_stats, + info); + + return ret; +} +EXPORT_SYMBOL(ipa_wdi_sw_stats); + +/* registration API for IPA gsb module */ +int ipa_fmwk_register_gsb(const struct ipa_gsb_data *in) +{ + if (!ipa_fmwk_ctx) { + pr_err("ipa framework hasn't been initialized yet\n"); + return -EPERM; + } + + if (ipa_fmwk_ctx->ipa_bridge_init + || ipa_fmwk_ctx->ipa_bridge_connect + || ipa_fmwk_ctx->ipa_bridge_set_perf_profile + || ipa_fmwk_ctx->ipa_bridge_disconnect + || ipa_fmwk_ctx->ipa_bridge_suspend + || ipa_fmwk_ctx->ipa_bridge_resume + || ipa_fmwk_ctx->ipa_bridge_tx_dp + || ipa_fmwk_ctx->ipa_bridge_cleanup) { + pr_err("ipa_gsb APIs were already initialized\n"); + return -EPERM; + } + + ipa_fmwk_ctx->ipa_bridge_init = in->ipa_bridge_init; + ipa_fmwk_ctx->ipa_bridge_connect = in->ipa_bridge_connect; + ipa_fmwk_ctx->ipa_bridge_set_perf_profile = + in->ipa_bridge_set_perf_profile; + ipa_fmwk_ctx->ipa_bridge_disconnect = in->ipa_bridge_disconnect; + ipa_fmwk_ctx->ipa_bridge_suspend = in->ipa_bridge_suspend; + ipa_fmwk_ctx->ipa_bridge_resume = in->ipa_bridge_resume; + ipa_fmwk_ctx->ipa_bridge_tx_dp = in->ipa_bridge_tx_dp; + ipa_fmwk_ctx->ipa_bridge_cleanup = in->ipa_bridge_cleanup; + + pr_info("ipa_gsb registered successfully\n"); + + return 0; +} +EXPORT_SYMBOL(ipa_fmwk_register_gsb); + +/* ipa_gsb APIs */ +int ipa_bridge_init(struct ipa_bridge_init_params *params, u32 *hdl) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_bridge_init, + params, hdl); + + return ret; +} +EXPORT_SYMBOL(ipa_bridge_init); + +int ipa_bridge_connect(u32 hdl) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_bridge_connect, + hdl); + + return ret; +} +EXPORT_SYMBOL(ipa_bridge_connect); + +int ipa_bridge_set_perf_profile(u32 hdl, u32 bandwidth) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_bridge_set_perf_profile, + hdl, bandwidth); + + return ret; +} +EXPORT_SYMBOL(ipa_bridge_set_perf_profile); + +int ipa_bridge_disconnect(u32 hdl) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_bridge_disconnect, + hdl); + + return ret; +} +EXPORT_SYMBOL(ipa_bridge_disconnect); + +int ipa_bridge_suspend(u32 hdl) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_bridge_suspend, + hdl); + + return ret; +} +EXPORT_SYMBOL(ipa_bridge_suspend); + +int ipa_bridge_resume(u32 hdl) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_bridge_resume, + hdl); + + return ret; +} +EXPORT_SYMBOL(ipa_bridge_resume); + +int ipa_bridge_tx_dp(u32 hdl, struct sk_buff *skb, + struct ipa_tx_meta *metadata) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN_DP(ipa_bridge_tx_dp, + hdl, skb, metadata); + + return ret; +} +EXPORT_SYMBOL(ipa_bridge_tx_dp); + +int ipa_bridge_cleanup(u32 hdl) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_bridge_cleanup, + hdl); + + return ret; +} +EXPORT_SYMBOL(ipa_bridge_cleanup); + +/* registration API for IPA uc_offload module */ +int ipa_fmwk_register_uc_offload(const struct ipa_uc_offload_data *in) +{ + if (!ipa_fmwk_ctx) { + pr_err("ipa framework hasn't been initialized yet\n"); + return -EPERM; + } + + if (ipa_fmwk_ctx->ipa_uc_offload_reg_intf + || ipa_fmwk_ctx->ipa_uc_offload_cleanup + || ipa_fmwk_ctx->ipa_uc_offload_conn_pipes + || ipa_fmwk_ctx->ipa_uc_offload_disconn_pipes + || ipa_fmwk_ctx->ipa_set_perf_profile + || ipa_fmwk_ctx->ipa_uc_offload_reg_rdyCB + || ipa_fmwk_ctx->ipa_uc_offload_dereg_rdyCB) { + pr_err("ipa_uc_offload APIs were already initialized\n"); + return -EPERM; + } + + ipa_fmwk_ctx->ipa_uc_offload_reg_intf = in->ipa_uc_offload_reg_intf; + ipa_fmwk_ctx->ipa_uc_offload_cleanup = in->ipa_uc_offload_cleanup; + ipa_fmwk_ctx->ipa_uc_offload_conn_pipes = in->ipa_uc_offload_conn_pipes; + ipa_fmwk_ctx->ipa_uc_offload_disconn_pipes = + in->ipa_uc_offload_disconn_pipes; + ipa_fmwk_ctx->ipa_set_perf_profile = in->ipa_set_perf_profile; + ipa_fmwk_ctx->ipa_uc_offload_reg_rdyCB = in->ipa_uc_offload_reg_rdyCB; + ipa_fmwk_ctx->ipa_uc_offload_dereg_rdyCB = + in->ipa_uc_offload_dereg_rdyCB; + + pr_info("ipa_uc_offload registered successfully\n"); + + return 0; +} +EXPORT_SYMBOL(ipa_fmwk_register_uc_offload); + +/* uc_offload APIs */ +int ipa_uc_offload_reg_intf( + struct ipa_uc_offload_intf_params *in, + struct ipa_uc_offload_out_params *out) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_uc_offload_reg_intf, + in, out); + + return ret; +} +EXPORT_SYMBOL(ipa_uc_offload_reg_intf); + +int ipa_uc_offload_cleanup(u32 clnt_hdl) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_uc_offload_cleanup, + clnt_hdl); + + return ret; +} +EXPORT_SYMBOL(ipa_uc_offload_cleanup); + +int ipa_uc_offload_conn_pipes(struct ipa_uc_offload_conn_in_params *in, + struct ipa_uc_offload_conn_out_params *out) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_uc_offload_conn_pipes, + in, out); + + return ret; +} +EXPORT_SYMBOL(ipa_uc_offload_conn_pipes); + +int ipa_uc_offload_disconn_pipes(u32 clnt_hdl) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_uc_offload_disconn_pipes, + clnt_hdl); + + return ret; +} +EXPORT_SYMBOL(ipa_uc_offload_disconn_pipes); + +int ipa_set_perf_profile(struct ipa_perf_profile *profile) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_set_perf_profile, + profile); + + return ret; +} +EXPORT_SYMBOL(ipa_set_perf_profile); + +int ipa_uc_offload_reg_rdyCB(struct ipa_uc_ready_params *param) +{ + int ret; + + if (!ipa_fmwk_ctx) { + pr_err("ipa framework hasn't been initialized yet\n"); + return -EPERM; + } + + mutex_lock(&ipa_fmwk_ctx->lock); + if (ipa_fmwk_ctx->ipa_ready) { + /* call real func, unlock and return */ + ret = ipa_fmwk_ctx->ipa_uc_offload_reg_rdyCB(param); + mutex_unlock(&ipa_fmwk_ctx->lock); + return ret; + } + + ipa_fmwk_ctx->uc_ready_cb = param->notify; + ipa_fmwk_ctx->uc_ready_priv = param->priv; + ipa_fmwk_ctx->proto = param->proto; + param->is_uC_ready = false; + + mutex_unlock(&ipa_fmwk_ctx->lock); + + return 0; +} +EXPORT_SYMBOL(ipa_uc_offload_reg_rdyCB); + +void ipa_uc_offload_dereg_rdyCB(enum ipa_uc_offload_proto proto) +{ + IPA_FMWK_DISPATCH(ipa_uc_offload_dereg_rdyCB, + proto); +} +EXPORT_SYMBOL(ipa_uc_offload_dereg_rdyCB); + +/* registration API for IPA mhi module */ +int ipa_fmwk_register_ipa_mhi(const struct ipa_mhi_data *in) +{ + if (!ipa_fmwk_ctx) { + pr_err("ipa framework hasn't been initialized yet\n"); + return -EPERM; + } + + if (ipa_fmwk_ctx->ipa_mhi_init + || ipa_fmwk_ctx->ipa_mhi_start + || ipa_fmwk_ctx->ipa_mhi_connect_pipe + || ipa_fmwk_ctx->ipa_mhi_disconnect_pipe + || ipa_fmwk_ctx->ipa_mhi_suspend + || ipa_fmwk_ctx->ipa_mhi_resume + || ipa_fmwk_ctx->ipa_mhi_destroy + || ipa_fmwk_ctx->ipa_mhi_handle_ipa_config_req) { + pr_err("ipa_mhi APIs were already initialized\n"); + return -EPERM; + } + + ipa_fmwk_ctx->ipa_mhi_init = in->ipa_mhi_init; + ipa_fmwk_ctx->ipa_mhi_start = in->ipa_mhi_start; + ipa_fmwk_ctx->ipa_mhi_connect_pipe = in->ipa_mhi_connect_pipe; + ipa_fmwk_ctx->ipa_mhi_disconnect_pipe = in->ipa_mhi_disconnect_pipe; + ipa_fmwk_ctx->ipa_mhi_suspend = in->ipa_mhi_suspend; + ipa_fmwk_ctx->ipa_mhi_resume = in->ipa_mhi_resume; + ipa_fmwk_ctx->ipa_mhi_destroy = in->ipa_mhi_destroy; + ipa_fmwk_ctx->ipa_mhi_handle_ipa_config_req = + in->ipa_mhi_handle_ipa_config_req; + + pr_info("ipa_mhi registered successfully\n"); + + return 0; +} +EXPORT_SYMBOL(ipa_fmwk_register_ipa_mhi); + +/* ipa_mhi APIs */ +int ipa_mhi_init(struct ipa_mhi_init_params *params) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_mhi_init, + params); + + return ret; +} +EXPORT_SYMBOL(ipa_mhi_init); + +int ipa_mhi_start(struct ipa_mhi_start_params *params) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_mhi_start, + params); + + return ret; +} +EXPORT_SYMBOL(ipa_mhi_start); + +int ipa_mhi_connect_pipe(struct ipa_mhi_connect_params *in, u32 *clnt_hdl) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_mhi_connect_pipe, + in, clnt_hdl); + + return ret; +} +EXPORT_SYMBOL(ipa_mhi_connect_pipe); + +int ipa_mhi_disconnect_pipe(u32 clnt_hdl) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_mhi_disconnect_pipe, + clnt_hdl); + + return ret; +} +EXPORT_SYMBOL(ipa_mhi_disconnect_pipe); + +int ipa_mhi_suspend(bool force) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_mhi_suspend, + force); + + return ret; +} +EXPORT_SYMBOL(ipa_mhi_suspend); + +int ipa_mhi_resume(void) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_mhi_resume); + + return ret; +} +EXPORT_SYMBOL(ipa_mhi_resume); + +void ipa_mhi_destroy(void) +{ + IPA_FMWK_DISPATCH(ipa_mhi_destroy); +} +EXPORT_SYMBOL(ipa_mhi_destroy); + +int ipa_mhi_handle_ipa_config_req(struct ipa_config_req_msg_v01 *config_req) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_mhi_handle_ipa_config_req, + config_req); + + return ret; +} +EXPORT_SYMBOL(ipa_mhi_handle_ipa_config_req); + +/* registration API for IPA wigig module */ +int ipa_fmwk_register_ipa_wigig(const struct ipa_wigig_data *in) +{ + if (!ipa_fmwk_ctx) { + pr_err("ipa framework hasn't been initialized yet\n"); + return -EPERM; + } + + if (ipa_fmwk_ctx->ipa_wigig_init + || ipa_fmwk_ctx->ipa_wigig_cleanup + || ipa_fmwk_ctx->ipa_wigig_is_smmu_enabled + || ipa_fmwk_ctx->ipa_wigig_reg_intf + || ipa_fmwk_ctx->ipa_wigig_dereg_intf + || ipa_fmwk_ctx->ipa_wigig_conn_rx_pipe + || ipa_fmwk_ctx->ipa_wigig_conn_rx_pipe_smmu + || ipa_fmwk_ctx->ipa_wigig_conn_client + || ipa_fmwk_ctx->ipa_wigig_conn_client_smmu + || ipa_fmwk_ctx->ipa_wigig_disconn_pipe + || ipa_fmwk_ctx->ipa_wigig_enable_pipe + || ipa_fmwk_ctx->ipa_wigig_disable_pipe + || ipa_fmwk_ctx->ipa_wigig_tx_dp + || ipa_fmwk_ctx->ipa_wigig_set_perf_profile + || ipa_fmwk_ctx->ipa_wigig_save_regs) { + pr_err("ipa_wigig APIs were already initialized\n"); + return -EPERM; + } + + ipa_fmwk_ctx->ipa_wigig_init = in->ipa_wigig_init; + ipa_fmwk_ctx->ipa_wigig_cleanup = in->ipa_wigig_cleanup; + ipa_fmwk_ctx->ipa_wigig_is_smmu_enabled = in->ipa_wigig_is_smmu_enabled; + ipa_fmwk_ctx->ipa_wigig_reg_intf = in->ipa_wigig_reg_intf; + ipa_fmwk_ctx->ipa_wigig_dereg_intf = in->ipa_wigig_dereg_intf; + ipa_fmwk_ctx->ipa_wigig_conn_rx_pipe = in->ipa_wigig_conn_rx_pipe; + ipa_fmwk_ctx->ipa_wigig_conn_rx_pipe_smmu = + in->ipa_wigig_conn_rx_pipe_smmu; + ipa_fmwk_ctx->ipa_wigig_conn_client = in->ipa_wigig_conn_client; + ipa_fmwk_ctx->ipa_wigig_conn_client_smmu = + in->ipa_wigig_conn_client_smmu; + ipa_fmwk_ctx->ipa_wigig_disconn_pipe = in->ipa_wigig_disconn_pipe; + ipa_fmwk_ctx->ipa_wigig_enable_pipe = in->ipa_wigig_enable_pipe; + ipa_fmwk_ctx->ipa_wigig_disable_pipe = in->ipa_wigig_disable_pipe; + ipa_fmwk_ctx->ipa_wigig_tx_dp = in->ipa_wigig_tx_dp; + ipa_fmwk_ctx->ipa_wigig_set_perf_profile = + in->ipa_wigig_set_perf_profile; + ipa_fmwk_ctx->ipa_wigig_save_regs = + in->ipa_wigig_save_regs; + + pr_info("ipa_wigig registered successfully\n"); + + return 0; +} +EXPORT_SYMBOL(ipa_fmwk_register_ipa_wigig); + +/* ipa_wigig APIs */ +int ipa_wigig_init(struct ipa_wigig_init_in_params *in, + struct ipa_wigig_init_out_params *out) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wigig_init, + in, out); + + return ret; +} +EXPORT_SYMBOL(ipa_wigig_init); + +int ipa_wigig_cleanup(void) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wigig_cleanup); + + return ret; +} +EXPORT_SYMBOL(ipa_wigig_cleanup); + +bool ipa_wigig_is_smmu_enabled(void) +{ + int ret; + + IPA_FMWK_RETURN_BOOL(ipa_wigig_is_smmu_enabled); + + return ret; +} +EXPORT_SYMBOL(ipa_wigig_is_smmu_enabled); + +int ipa_wigig_reg_intf(struct ipa_wigig_reg_intf_in_params *in) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wigig_reg_intf, + in); + + return ret; +} +EXPORT_SYMBOL(ipa_wigig_reg_intf); + +int ipa_wigig_dereg_intf(const char *netdev_name) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wigig_dereg_intf, + netdev_name); + + return ret; +} +EXPORT_SYMBOL(ipa_wigig_dereg_intf); + +int ipa_wigig_conn_rx_pipe( + struct ipa_wigig_conn_rx_in_params *in, + struct ipa_wigig_conn_out_params *out) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wigig_conn_rx_pipe, + in, out); + + return ret; +} +EXPORT_SYMBOL(ipa_wigig_conn_rx_pipe); + +int ipa_wigig_conn_rx_pipe_smmu( + struct ipa_wigig_conn_rx_in_params_smmu *in, + struct ipa_wigig_conn_out_params *out) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wigig_conn_rx_pipe_smmu, + in, out); + + return ret; +} +EXPORT_SYMBOL(ipa_wigig_conn_rx_pipe_smmu); + +int ipa_wigig_conn_client( + struct ipa_wigig_conn_tx_in_params *in, + struct ipa_wigig_conn_out_params *out) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wigig_conn_client, + in, out); + + return ret; +} +EXPORT_SYMBOL(ipa_wigig_conn_client); + +int ipa_wigig_conn_client_smmu( + struct ipa_wigig_conn_tx_in_params_smmu *in, + struct ipa_wigig_conn_out_params *out) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wigig_conn_client_smmu, + in, out); + + return ret; +} +EXPORT_SYMBOL(ipa_wigig_conn_client_smmu); + +int ipa_wigig_disconn_pipe(enum ipa_client_type client) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wigig_disconn_pipe, + client); + + return ret; +} +EXPORT_SYMBOL(ipa_wigig_disconn_pipe); + +int ipa_wigig_enable_pipe(enum ipa_client_type client) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wigig_enable_pipe, + client); + + return ret; +} +EXPORT_SYMBOL(ipa_wigig_enable_pipe); + +int ipa_wigig_disable_pipe(enum ipa_client_type client) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wigig_disable_pipe, + client); + + return ret; +} +EXPORT_SYMBOL(ipa_wigig_disable_pipe); + +int ipa_wigig_tx_dp(enum ipa_client_type dst, + struct sk_buff *skb) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN_DP(ipa_wigig_tx_dp, + dst, skb); + + return ret; +} +EXPORT_SYMBOL(ipa_wigig_tx_dp); + +int ipa_wigig_set_perf_profile(u32 max_supported_bw_mbps) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wigig_set_perf_profile, + max_supported_bw_mbps); + + return ret; +} +EXPORT_SYMBOL(ipa_wigig_set_perf_profile); + +int ipa_wigig_save_regs(void) +{ + int ret; + + IPA_FMWK_DISPATCH_RETURN(ipa_wigig_save_regs); + + return ret; +} +EXPORT_SYMBOL(ipa_wigig_save_regs); + +/* module functions */ static int __init ipa_fmwk_init(void) { pr_info("IPA framework init\n"); diff --git a/include/linux/ipa.h b/include/linux/ipa.h index 91ae371d852f..cf3326a13349 100644 --- a/include/linux/ipa.h +++ b/include/linux/ipa.h @@ -10,6 +10,7 @@ #include #include #include +#include #include "linux/msm_gsi.h" #define IPA_APPS_MAX_BW_IN_MBPS 700 @@ -1307,182 +1308,139 @@ struct ipa_smmu_out_params { }; #if IS_ENABLED(CONFIG_IPA3) - -/* - * Resume / Suspend - */ -int ipa_reset_endpoint(u32 clnt_hdl); - -/* - * Remove ep delay - */ -int ipa_clear_endpoint_delay(u32 clnt_hdl); - -/* - * Disable ep - */ -int ipa_disable_endpoint(u32 clnt_hdl); - /* * Configuration */ -int ipa_cfg_ep(u32 clnt_hdl, const struct ipa_ep_cfg *ipa_ep_cfg); - -int ipa_cfg_ep_nat(u32 clnt_hdl, const struct ipa_ep_cfg_nat *ipa_ep_cfg); - -int ipa_cfg_ep_conn_track(u32 clnt_hdl, - const struct ipa_ep_cfg_conn_track *ep_conn_track); - -int ipa_cfg_ep_hdr(u32 clnt_hdl, const struct ipa_ep_cfg_hdr *ipa_ep_cfg); - -int ipa_cfg_ep_hdr_ext(u32 clnt_hdl, - const struct ipa_ep_cfg_hdr_ext *ipa_ep_cfg); - -int ipa_cfg_ep_mode(u32 clnt_hdl, const struct ipa_ep_cfg_mode *ipa_ep_cfg); - -int ipa_cfg_ep_aggr(u32 clnt_hdl, const struct ipa_ep_cfg_aggr *ipa_ep_cfg); - -int ipa_cfg_ep_deaggr(u32 clnt_hdl, - const struct ipa_ep_cfg_deaggr *ipa_ep_cfg); - -int ipa_cfg_ep_route(u32 clnt_hdl, const struct ipa_ep_cfg_route *ipa_ep_cfg); - -int ipa_cfg_ep_holb(u32 clnt_hdl, const struct ipa_ep_cfg_holb *ipa_ep_cfg); - -int ipa_cfg_ep_cfg(u32 clnt_hdl, const struct ipa_ep_cfg_cfg *ipa_ep_cfg); - -int ipa_cfg_ep_metadata_mask(u32 clnt_hdl, const struct ipa_ep_cfg_metadata_mask - *ipa_ep_cfg); - -int ipa_cfg_ep_holb_by_client(enum ipa_client_type client, - const struct ipa_ep_cfg_holb *ipa_ep_cfg); +/** + * ipa_cfg_ep_ctrl() - IPA end-point Control configuration + * @clnt_hdl: [in] opaque client handle assigned by IPA to client + * @ipa_ep_cfg_ctrl: [in] IPA end-point configuration params + * + * Returns: 0 on success, negative on failure + */ int ipa_cfg_ep_ctrl(u32 clnt_hdl, const struct ipa_ep_cfg_ctrl *ep_ctrl); -/* - * Header removal / addition - */ -int ipa_add_hdr(struct ipa_ioc_add_hdr *hdrs); - -int ipa_add_hdr_usr(struct ipa_ioc_add_hdr *hdrs, bool user_only); - -int ipa_del_hdr(struct ipa_ioc_del_hdr *hdls); - -int ipa_commit_hdr(void); - -int ipa_reset_hdr(bool user_only); - -int ipa_get_hdr(struct ipa_ioc_get_hdr *lookup); - -int ipa_put_hdr(u32 hdr_hdl); - -int ipa_copy_hdr(struct ipa_ioc_copy_hdr *copy); - -/* - * Header Processing Context - */ -int ipa_add_hdr_proc_ctx(struct ipa_ioc_add_hdr_proc_ctx *proc_ctxs, - bool user_only); - -int ipa_del_hdr_proc_ctx(struct ipa_ioc_del_hdr_proc_ctx *hdls); - /* * Routing */ + +/** + * ipa_add_rt_rule() - Add the specified routing rules to SW and optionally + * commit to IPA HW + * @rules: [inout] set of routing rules to add + * + * Returns: 0 on success, negative on failure + * + * Note: Should not be called from atomic context + */ int ipa_add_rt_rule(struct ipa_ioc_add_rt_rule *rules); -int ipa_add_rt_rule_v2(struct ipa_ioc_add_rt_rule_v2 *rules); - -int ipa_add_rt_rule_usr(struct ipa_ioc_add_rt_rule *rules, bool user_only); - -int ipa_add_rt_rule_usr_v2(struct ipa_ioc_add_rt_rule_v2 *rules, - bool user_only); - -int ipa_del_rt_rule(struct ipa_ioc_del_rt_rule *hdls); - -int ipa_commit_rt(enum ipa_ip_type ip); - -int ipa_reset_rt(enum ipa_ip_type ip, bool user_only); - -int ipa_get_rt_tbl(struct ipa_ioc_get_rt_tbl *lookup); - +/** + * ipa_put_rt_tbl() - Release the specified routing table handle + * @rt_tbl_hdl: [in] the routing table handle to release + * + * Returns: 0 on success, negative on failure + * + * Note: Should not be called from atomic context + */ int ipa_put_rt_tbl(u32 rt_tbl_hdl); -int ipa_query_rt_index(struct ipa_ioc_get_rt_tbl_indx *in); - -int ipa_mdfy_rt_rule(struct ipa_ioc_mdfy_rt_rule *rules); - -int ipa_mdfy_rt_rule_v2(struct ipa_ioc_mdfy_rt_rule_v2 *rules); - -/* - * Filtering - */ -int ipa_add_flt_rule(struct ipa_ioc_add_flt_rule *rules); - -int ipa_add_flt_rule_v2(struct ipa_ioc_add_flt_rule_v2 *rules); - -int ipa_add_flt_rule_usr(struct ipa_ioc_add_flt_rule *rules, bool user_only); - -int ipa_add_flt_rule_usr_v2(struct ipa_ioc_add_flt_rule_v2 *rules, - bool user_only); - -int ipa_del_flt_rule(struct ipa_ioc_del_flt_rule *hdls); - -int ipa_mdfy_flt_rule(struct ipa_ioc_mdfy_flt_rule *rules); - -int ipa_mdfy_flt_rule_v2(struct ipa_ioc_mdfy_flt_rule_v2 *rules); - -int ipa_commit_flt(enum ipa_ip_type ip); - -int ipa_reset_flt(enum ipa_ip_type ip, bool user_only); - -/* - * NAT\IPv6CT - */ -int ipa_allocate_nat_device(struct ipa_ioc_nat_alloc_mem *mem); -int ipa_allocate_nat_table(struct ipa_ioc_nat_ipv6ct_table_alloc *table_alloc); -int ipa_allocate_ipv6ct_table( - struct ipa_ioc_nat_ipv6ct_table_alloc *table_alloc); - -int ipa_nat_init_cmd(struct ipa_ioc_v4_nat_init *init); -int ipa_ipv6ct_init_cmd(struct ipa_ioc_ipv6ct_init *init); - -int ipa_nat_dma_cmd(struct ipa_ioc_nat_dma_cmd *dma); -int ipa_table_dma_cmd(struct ipa_ioc_nat_dma_cmd *dma); - -int ipa_nat_del_cmd(struct ipa_ioc_v4_nat_del *del); -int ipa_del_nat_table(struct ipa_ioc_nat_ipv6ct_table_del *del); -int ipa_del_ipv6ct_table(struct ipa_ioc_nat_ipv6ct_table_del *del); - -int ipa_nat_mdfy_pdn(struct ipa_ioc_nat_pdn_entry *mdfy_pdn); - -/* - * Messaging - */ -int ipa_send_msg(struct ipa_msg_meta *meta, void *buff, - ipa_msg_free_fn callback); -int ipa_register_pull_msg(struct ipa_msg_meta *meta, ipa_msg_pull_fn callback); -int ipa_deregister_pull_msg(struct ipa_msg_meta *meta); - /* * Interface */ -int ipa_register_intf(const char *name, const struct ipa_tx_intf *tx, - const struct ipa_rx_intf *rx); -int ipa_register_intf_ext(const char *name, const struct ipa_tx_intf *tx, - const struct ipa_rx_intf *rx, - const struct ipa_ext_intf *ext); -int ipa_deregister_intf(const char *name); +int ipa_register_intf(const char *name, + const struct ipa_tx_intf *tx, + const struct ipa_rx_intf *rx); /* * Aggregation */ + +/** + * ipa_set_aggr_mode() - Set the aggregation mode which is a global setting + * @mode: [in] the desired aggregation mode for e.g. straight MBIM, QCNCM, + * etc + * + * Returns: 0 on success + */ + int ipa_set_aggr_mode(enum ipa_aggr_mode mode); +/** + * ipa_set_qcncm_ndp_sig() - Set the NDP signature used for QCNCM aggregation + * mode + * @sig: [in] the first 3 bytes of QCNCM NDP signature (expected to be + * "QND") + * + * Set the NDP signature used for QCNCM aggregation mode. The fourth byte + * (expected to be 'P') needs to be set using the header addition mechanism + * + * Returns: 0 on success, negative on failure + */ int ipa_set_qcncm_ndp_sig(char sig[3]); +/** + * ipa_set_single_ndp_per_mbim() - Enable/disable single NDP per MBIM frame + * configuration + * @enable: [in] true for single NDP/MBIM; false otherwise + * + * Returns: 0 on success + */ int ipa_set_single_ndp_per_mbim(bool enable); +/* + * interrupts + */ + +/** + * ipa_add_interrupt_handler() - Adds handler to an interrupt type + * @interrupt: Interrupt type + * @handler: The handler to be added + * @deferred_flag: whether the handler processing should be deferred in + * a workqueue + * @private_data: the client's private data + * + * Adds handler to an interrupt type and enable the specific bit + * in IRQ_EN register, associated interrupt in IRQ_STTS register will be enabled + */ + +int ipa_add_interrupt_handler(enum ipa_irq_type interrupt, + ipa_irq_handler_t handler, + bool deferred_flag, + void *private_data); + +/** + * ipa_restore_suspend_handler() - restores the original suspend IRQ handler + * as it was registered in the IPA init sequence. + * Return codes: + * 0: success + * -EPERM: failed to remove current handler or failed to add original handler + */ +int ipa_restore_suspend_handler(void); + +/* + * Messaging + */ + +/** + * ipa_send_msg() - Send "message" from kernel client to IPA driver + * @meta: [in] message meta-data + * @buff: [in] the payload for message + * @callback: [in] free callback + * + * Client supplies the message meta-data and payload which IPA driver buffers + * till read by user-space. After read from user space IPA driver invokes the + * callback supplied to free the message payload. Client must not touch/free + * the message payload after calling this API. + * + * Returns: 0 on success, negative on failure + * + * Note: Should not be called from atomic context + */ +int ipa_send_msg(struct ipa_msg_meta *meta, void *buff, + ipa_msg_free_fn callback); + /* * Data path */ @@ -1529,23 +1487,36 @@ int ipa_tx_dp(enum ipa_client_type dst, struct sk_buff *skb, */ int ipa_rmnet_ctl_xmit(struct sk_buff *skb); -/* - * To transfer multiple data packets - * While passing the data descriptor list, the anchor node - * should be of type struct ipa_tx_data_desc not list_head - */ -int ipa_tx_dp_mul(enum ipa_client_type dst, - struct ipa_tx_data_desc *data_desc); - void ipa_free_skb(struct ipa_rx_data *data); -int ipa_rx_poll(u32 clnt_hdl, int budget); -void ipa_recycle_wan_skb(struct sk_buff *skb); /* * System pipes */ + +/** + * ipa_setup_sys_pipe() - Setup an IPA end-point in system-BAM mode and perform + * IPA EP configuration + * @sys_in: [in] input needed to setup BAM pipe and configure EP + * @clnt_hdl: [out] client handle + * + * - configure the end-point registers with the supplied + * parameters from the user. + * - call SPS APIs to create a system-to-bam connection with IPA. + * - allocate descriptor FIFO + * - register callback function(ipa_sps_irq_rx_notify or + * ipa_sps_irq_tx_notify - depends on client type) in case the driver is + * not configured to pulling mode + * + * Returns: 0 on success, negative on failure + */ int ipa_setup_sys_pipe(struct ipa_sys_connect_params *sys_in, u32 *clnt_hdl); +/** + * ipa_teardown_sys_pipe() - Teardown the system-BAM pipe and cleanup IPA EP + * @clnt_hdl: [in] the handle obtained from ipa_setup_sys_pipe + * + * Returns: 0 on success, negative on failure + */ int ipa_teardown_sys_pipe(u32 clnt_hdl); int ipa_connect_wdi_pipe(struct ipa_wdi_in_params *in, @@ -1555,10 +1526,26 @@ int ipa_enable_wdi_pipe(u32 clnt_hdl); int ipa_disable_wdi_pipe(u32 clnt_hdl); int ipa_resume_wdi_pipe(u32 clnt_hdl); int ipa_suspend_wdi_pipe(u32 clnt_hdl); + +/** + * ipa_get_wdi_stats() - Query WDI statistics from uc + * @stats: [inout] stats blob from client populated by driver + * + * Returns: 0 on success, negative on failure + * + * @note Cannot be called from atomic context + * + */ int ipa_get_wdi_stats(struct IpaHwStatsWDIInfoData_t *stats); int ipa_uc_bw_monitor(struct ipa_wdi_bw_info *info); -int ipa_set_wlan_tx_info(struct ipa_wdi_tx_info *info); -u16 ipa_get_smem_restr_bytes(void); + +/** + * ipa_broadcast_wdi_quota_reach_ind() - quota reach + * @uint32_t fid: [in] input netdev ID + * @uint64_t num_bytes: [in] used bytes + * + * Returns: 0 on success, negative on failure + */ int ipa_broadcast_wdi_quota_reach_ind(uint32_t fid, uint64_t num_bytes); @@ -1568,154 +1555,103 @@ int ipa_broadcast_wdi_quota_reach_ind(uint32_t fid, */ int ipa_uc_wdi_get_dbpa(struct ipa_wdi_db_params *out); -/* - * To register uC ready callback if uC not ready - * and also check uC readiness - * if uC not ready only, register callback - */ -int ipa_uc_reg_rdyCB(struct ipa_wdi_uc_ready_params *param); -/* - * To de-register uC ready callback - */ -int ipa_uc_dereg_rdyCB(void); - -int ipa_create_wdi_mapping(u32 num_buffers, struct ipa_wdi_buffer_info *info); -int ipa_release_wdi_mapping(u32 num_buffers, struct ipa_wdi_buffer_info *info); - -/* - * Resource manager - */ -int ipa_rm_create_resource(struct ipa_rm_create_params *create_params); - -int ipa_rm_delete_resource(enum ipa_rm_resource_name resource_name); - -int ipa_rm_register(enum ipa_rm_resource_name resource_name, - struct ipa_rm_register_params *reg_params); - -int ipa_rm_deregister(enum ipa_rm_resource_name resource_name, - struct ipa_rm_register_params *reg_params); - -int ipa_rm_set_perf_profile(enum ipa_rm_resource_name resource_name, - struct ipa_rm_perf_profile *profile); - -int ipa_rm_add_dependency(enum ipa_rm_resource_name resource_name, - enum ipa_rm_resource_name depends_on_name); - -int ipa_rm_add_dependency_sync(enum ipa_rm_resource_name resource_name, - enum ipa_rm_resource_name depends_on_name); - -int ipa_rm_delete_dependency(enum ipa_rm_resource_name resource_name, - enum ipa_rm_resource_name depends_on_name); - -int ipa_rm_request_resource(enum ipa_rm_resource_name resource_name); - -int ipa_rm_release_resource(enum ipa_rm_resource_name resource_name); - -int ipa_rm_notify_completion(enum ipa_rm_event event, - enum ipa_rm_resource_name resource_name); - -int ipa_rm_inactivity_timer_init(enum ipa_rm_resource_name resource_name, - unsigned long msecs); - -int ipa_rm_inactivity_timer_destroy(enum ipa_rm_resource_name resource_name); - -int ipa_rm_inactivity_timer_request_resource( - enum ipa_rm_resource_name resource_name); - -int ipa_rm_inactivity_timer_release_resource( - enum ipa_rm_resource_name resource_name); - -/* - * Tethering bridge (Rmnet / MBIM) - */ -int teth_bridge_init(struct teth_bridge_init_params *params); - -int teth_bridge_disconnect(enum ipa_client_type client); - -int teth_bridge_connect(struct teth_bridge_connect_params *connect_params); - -/* - * Tethering client info - */ -void ipa_set_client(int index, enum ipacm_client_enum client, bool uplink); - -enum ipacm_client_enum ipa_get_client(int pipe_idx); - -bool ipa_get_client_uplink(int pipe_idx); - /* * IPADMA */ + /** + * ipa_dma_init() -Initialize IPADMA. + * + * This function initialize all IPADMA internal data and connect in dma: + * MEMCPY_DMA_SYNC_PROD ->MEMCPY_DMA_SYNC_CONS + * MEMCPY_DMA_ASYNC_PROD->MEMCPY_DMA_SYNC_CONS + * + * Return codes: 0: success + * -EFAULT: IPADMA is already initialized + * -ENOMEM: allocating memory error + * -EPERM: pipe connection failed + */ int ipa_dma_init(void); +/** + * ipa_dma_enable() -Vote for IPA clocks. + * + *Return codes: 0: success + * -EINVAL: IPADMA is not initialized + * -EPERM: Operation not permitted as ipa_dma is already + * enabled + */ int ipa_dma_enable(void); + +/** + * ipa_dma_disable()- Unvote for IPA clocks. + * + * enter to power save mode. + * + * Return codes: 0: success + * -EINVAL: IPADMA is not initialized + * -EPERM: Operation not permitted as ipa_dma is already + * diabled + * -EFAULT: can not disable ipa_dma as there are pending + * memcopy works + */ int ipa_dma_disable(void); +/** + * ipa_dma_sync_memcpy()- Perform synchronous memcpy using IPA. + * + * @dest: physical address to store the copied data. + * @src: physical address of the source data to copy. + * @len: number of bytes to copy. + * + * Return codes: 0: success + * -EINVAL: invalid params + * -EPERM: operation not permitted as ipa_dma isn't enable or + * initialized + * -SPS_ERROR: on sps faliures + * -EFAULT: other + */ int ipa_dma_sync_memcpy(u64 dest, u64 src, int len); +/** + * ipa_dma_async_memcpy()- Perform asynchronous memcpy using IPA. + * + * @dest: physical address to store the copied data. + * @src: physical address of the source data to copy. + * @len: number of bytes to copy. + * @user_cb: callback function to notify the client when the copy was done. + * @user_param: cookie for user_cb. + * + * Return codes: 0: success + * -EINVAL: invalid params + * -EPERM: operation not permitted as ipa_dma isn't enable or + * initialized + * -SPS_ERROR: on sps faliures + * -EFAULT: descr fifo is full. + */ int ipa_dma_async_memcpy(u64 dest, u64 src, int len, void (*user_cb)(void *user1), void *user_param); -int ipa_dma_uc_memcpy(phys_addr_t dest, phys_addr_t src, int len); +/** + * ipa_dma_destroy() -teardown IPADMA pipes and release ipadma. + * + * this is a blocking function, returns just after destroying IPADMA. + */ void ipa_dma_destroy(void); -/* - * mux id - */ -int ipa_write_qmap_id(struct ipa_ioc_write_qmapid *param_in); - -/* - * interrupts - */ -int ipa_add_interrupt_handler(enum ipa_irq_type interrupt, - ipa_irq_handler_t handler, - bool deferred_flag, - void *private_data); - -int ipa_remove_interrupt_handler(enum ipa_irq_type interrupt); - -int ipa_restore_suspend_handler(void); - /* * Miscellaneous */ -void ipa_bam_reg_dump(void); int ipa_get_ep_mapping(enum ipa_client_type client); bool ipa_is_ready(void); -void ipa_proxy_clk_vote(void); -void ipa_proxy_clk_unvote(void); - enum ipa_hw_type ipa_get_hw_type(void); -bool ipa_is_client_handle_valid(u32 clnt_hdl); - -enum ipa_client_type ipa_get_client_mapping(int pipe_idx); - -enum ipa_rm_resource_name ipa_get_rm_resource_from_ep(int pipe_idx); - -bool ipa_get_modem_cfg_emb_pipe_flt(void); - -enum ipa_transport_type ipa_get_transport_type(void); - -struct device *ipa_get_dma_dev(void); -struct iommu_domain *ipa_get_smmu_domain(void); - -int ipa_uc_debug_stats_alloc( - struct IpaHwOffloadStatsAllocCmdData_t cmdinfo); -int ipa_uc_debug_stats_dealloc(uint32_t protocol); -void ipa_get_gsi_stats(int prot_id, - struct ipa_uc_dbg_ring_stats *stats); -int ipa_get_prot_id(enum ipa_client_type client); - -int ipa_disable_apps_wan_cons_deaggr(uint32_t agg_size, uint32_t agg_count); - -const struct ipa_gsi_ep_config *ipa_get_gsi_ep_info - (enum ipa_client_type client); +const struct ipa_gsi_ep_config *ipa_get_gsi_ep_info( + enum ipa_client_type client); int ipa_stop_gsi_channel(u32 clnt_hdl); @@ -1788,20 +1724,6 @@ int ipa_register_rmnet_ctl_cb( */ int ipa_unregister_rmnet_ctl_cb(void); -/** - * ipa_tz_unlock_reg - Unlocks memory regions so that they become accessible - * from AP. - * @reg_info - Pointer to array of memory regions to unlock - * @num_regs - Number of elements in the array - * - * Converts the input array of regions to a struct that TZ understands and - * issues an SCM call. - * Also flushes the memory cache to DDR in order to make sure that TZ sees the - * correct data structure. - * - * Returns: 0 on success, negative on failure - */ -int ipa_tz_unlock_reg(struct ipa_tz_unlock_reg_info *reg_info, u16 num_regs); int ipa_get_smmu_params(struct ipa_smmu_in_params *in, struct ipa_smmu_out_params *out); /** @@ -1820,177 +1742,30 @@ int ipa_is_vlan_mode(enum ipa_vlan_ifaces iface, bool *res); */ bool ipa_get_lan_rx_napi(void); +int ipa_mhi_handle_ipa_config_req(struct ipa_config_req_msg_v01 *config_req); +int ipa_wigig_save_regs(void); + +/* + * this function needs to be removed, but wlan driver is checking return value + * to see if IPA is present, so we can't return -EPERM + */ +static inline int ipa_uc_reg_rdyCB( + struct ipa_wdi_uc_ready_params *inout) +{ + return -EFAULT; +} + #else /* IS_ENABLED(CONFIG_IPA3) */ -/* - * Resume / Suspend - */ -static inline int ipa_reset_endpoint(u32 clnt_hdl) -{ - return -EPERM; -} - -/* - * Remove ep delay - */ -static inline int ipa_clear_endpoint_delay(u32 clnt_hdl) -{ - return -EPERM; -} - -/* - * Disable ep - */ -static inline int ipa_disable_endpoint(u32 clnt_hdl) -{ - return -EPERM; -} - /* * Configuration */ -static inline int ipa_cfg_ep(u32 clnt_hdl, - const struct ipa_ep_cfg *ipa_ep_cfg) -{ - return -EPERM; -} - -static inline int ipa_cfg_ep_nat(u32 clnt_hdl, - const struct ipa_ep_cfg_nat *ipa_ep_cfg) -{ - return -EPERM; -} - -static inline int ipa_cfg_ep_conn_track(u32 clnt_hdl, - const struct ipa_ep_cfg_conn_track *ep_conn_track) -{ - return -EPERM; -} - -static inline int ipa_cfg_ep_hdr(u32 clnt_hdl, - const struct ipa_ep_cfg_hdr *ipa_ep_cfg) -{ - return -EPERM; -} - -static inline int ipa_cfg_ep_hdr_ext(u32 clnt_hdl, - const struct ipa_ep_cfg_hdr_ext *ipa_ep_cfg) -{ - return -EPERM; -} - -static inline int ipa_cfg_ep_mode(u32 clnt_hdl, - const struct ipa_ep_cfg_mode *ipa_ep_cfg) -{ - return -EPERM; -} - -static inline int ipa_cfg_ep_aggr(u32 clnt_hdl, - const struct ipa_ep_cfg_aggr *ipa_ep_cfg) -{ - return -EPERM; -} - -static inline int ipa_cfg_ep_deaggr(u32 clnt_hdl, - const struct ipa_ep_cfg_deaggr *ipa_ep_cfg) -{ - return -EPERM; -} - -static inline int ipa_cfg_ep_route(u32 clnt_hdl, - const struct ipa_ep_cfg_route *ipa_ep_cfg) -{ - return -EPERM; -} - -static inline int ipa_cfg_ep_holb(u32 clnt_hdl, - const struct ipa_ep_cfg_holb *ipa_ep_cfg) -{ - return -EPERM; -} - -static inline int ipa_cfg_ep_holb_by_client(enum ipa_client_type client, - const struct ipa_ep_cfg_holb *ep_holb) -{ - return -EPERM; -} - -static inline int ipa_cfg_ep_cfg(u32 clnt_hdl, - const struct ipa_ep_cfg_cfg *ipa_ep_cfg) -{ - return -EPERM; -} - -static inline int ipa_cfg_ep_metadata_mask(u32 clnt_hdl, - const struct ipa_ep_cfg_metadata_mask *ipa_ep_cfg) -{ - return -EPERM; -} - static inline int ipa_cfg_ep_ctrl(u32 clnt_hdl, - const struct ipa_ep_cfg_ctrl *ep_ctrl) + const struct ipa_ep_cfg_ctrl *ep_ctrl) { return -EPERM; } -/* - * Header removal / addition - */ -static inline int ipa_add_hdr(struct ipa_ioc_add_hdr *hdrs) -{ - return -EPERM; -} - -static inline int ipa_add_hdr_usr(struct ipa_ioc_add_hdr *hdrs, - bool user_only) -{ - return -EPERM; -} - -static inline int ipa_del_hdr(struct ipa_ioc_del_hdr *hdls) -{ - return -EPERM; -} - -static inline int ipa_commit_hdr(void) -{ - return -EPERM; -} - -static inline int ipa_reset_hdr(bool user_only) -{ - return -EPERM; -} - -static inline int ipa_get_hdr(struct ipa_ioc_get_hdr *lookup) -{ - return -EPERM; -} - -static inline int ipa_put_hdr(u32 hdr_hdl) -{ - return -EPERM; -} - -static inline int ipa_copy_hdr(struct ipa_ioc_copy_hdr *copy) -{ - return -EPERM; -} - -/* - * Header Processing Context - */ -static inline int ipa_add_hdr_proc_ctx( - struct ipa_ioc_add_hdr_proc_ctx *proc_ctxs, - bool user_only) -{ - return -EPERM; -} - -static inline int ipa_del_hdr_proc_ctx(struct ipa_ioc_del_hdr_proc_ctx *hdls) -{ - return -EPERM; -} /* * Routing */ @@ -1999,215 +1774,17 @@ static inline int ipa_add_rt_rule(struct ipa_ioc_add_rt_rule *rules) return -EPERM; } -static inline int ipa_add_rt_rule_v2(struct ipa_ioc_add_rt_rule_v2 *rules) -{ - return -EPERM; -} - -static inline int ipa_add_rt_rule_usr(struct ipa_ioc_add_rt_rule *rules, - bool user_only) -{ - return -EPERM; -} - -static inline int ipa_add_rt_rule_usr_v2( - struct ipa_ioc_add_rt_rule_v2 *rules, bool user_only) -{ - return -EPERM; -} - -static inline int ipa_del_rt_rule(struct ipa_ioc_del_rt_rule *hdls) -{ - return -EPERM; -} - -static inline int ipa_commit_rt(enum ipa_ip_type ip) -{ - return -EPERM; -} - -static inline int ipa_reset_rt(enum ipa_ip_type ip, bool user_only) -{ - return -EPERM; -} - -static inline int ipa_get_rt_tbl(struct ipa_ioc_get_rt_tbl *lookup) -{ - return -EPERM; -} - static inline int ipa_put_rt_tbl(u32 rt_tbl_hdl) { return -EPERM; } -static inline int ipa_query_rt_index(struct ipa_ioc_get_rt_tbl_indx *in) -{ - return -EPERM; -} - -static inline int ipa_mdfy_rt_rule(struct ipa_ioc_mdfy_rt_rule *rules) -{ - return -EPERM; -} - -static inline int ipa_mdfy_rt_rule_v2(struct ipa_ioc_mdfy_rt_rule_v2 *rules) -{ - return -EPERM; -} - -/* - * Filtering - */ -static inline int ipa_add_flt_rule(struct ipa_ioc_add_flt_rule *rules) -{ - return -EPERM; -} - -static inline int ipa_add_flt_rule_v2(struct ipa_ioc_add_flt_rule_v2 *rules) -{ - return -EPERM; -} - -static inline int ipa_add_flt_rule_usr(struct ipa_ioc_add_flt_rule *rules, - bool user_only) -{ - return -EPERM; -} - -static inline int ipa_add_flt_rule_usr_v2( - struct ipa_ioc_add_flt_rule_v2 *rules, bool user_only) -{ - return -EPERM; -} - -static inline int ipa_del_flt_rule(struct ipa_ioc_del_flt_rule *hdls) -{ - return -EPERM; -} - -static inline int ipa_mdfy_flt_rule(struct ipa_ioc_mdfy_flt_rule *rules) -{ - return -EPERM; -} - -static inline int ipa_mdfy_flt_rule_v2( - struct ipa_ioc_mdfy_flt_rule_v2 *rules) -{ - return -EPERM; -} - - -static inline int ipa_commit_flt(enum ipa_ip_type ip) -{ - return -EPERM; -} - -static inline int ipa_reset_flt(enum ipa_ip_type ip, bool user_only) -{ - return -EPERM; -} - -/* - * NAT - */ -static inline int ipa_allocate_nat_device(struct ipa_ioc_nat_alloc_mem *mem) -{ - return -EPERM; -} - -static inline int ipa_allocate_nat_table( - struct ipa_ioc_nat_ipv6ct_table_alloc *table_alloc) -{ - return -EPERM; -} - -static inline int ipa_allocate_ipv6ct_table( - struct ipa_ioc_nat_ipv6ct_table_alloc *table_alloc) -{ - return -EPERM; -} - -static inline int ipa_nat_init_cmd(struct ipa_ioc_v4_nat_init *init) -{ - return -EPERM; -} - -static inline int ipa_ipv6ct_init_cmd(struct ipa_ioc_ipv6ct_init *init) -{ - return -EPERM; -} - -static inline int ipa_nat_dma_cmd(struct ipa_ioc_nat_dma_cmd *dma) -{ - return -EPERM; -} - -static inline int ipa_table_dma_cmd(struct ipa_ioc_nat_dma_cmd *dma) -{ - return -EPERM; -} - -static inline int ipa_nat_del_cmd(struct ipa_ioc_v4_nat_del *del) -{ - return -EPERM; -} - -static inline int ipa_del_nat_table(struct ipa_ioc_nat_ipv6ct_table_del *del) -{ - return -EPERM; -} - -static inline int ipa_del_ipv6ct_table( - struct ipa_ioc_nat_ipv6ct_table_del *del) -{ - return -EPERM; -} - -static inline int ipa_nat_mdfy_pdn(struct ipa_ioc_nat_pdn_entry *mdfy_pdn) -{ - return -EPERM; -} - -/* - * Messaging - */ -static inline int ipa_send_msg(struct ipa_msg_meta *meta, void *buff, - ipa_msg_free_fn callback) -{ - return -EPERM; -} - -static inline int ipa_register_pull_msg(struct ipa_msg_meta *meta, - ipa_msg_pull_fn callback) -{ - return -EPERM; -} - -static inline int ipa_deregister_pull_msg(struct ipa_msg_meta *meta) -{ - return -EPERM; -} - /* * Interface */ static inline int ipa_register_intf(const char *name, - const struct ipa_tx_intf *tx, - const struct ipa_rx_intf *rx) -{ - return -EPERM; -} - -static inline int ipa_register_intf_ext(const char *name, - const struct ipa_tx_intf *tx, - const struct ipa_rx_intf *rx, - const struct ipa_ext_intf *ext) -{ - return -EPERM; -} - -static inline int ipa_deregister_intf(const char *name) + const struct ipa_tx_intf *tx, + const struct ipa_rx_intf *rx) { return -EPERM; } @@ -2230,6 +1807,31 @@ static inline int ipa_set_single_ndp_per_mbim(bool enable) return -EPERM; } +/* + * interrupts + */ +static inline int ipa_add_interrupt_handler(enum ipa_irq_type interrupt, + ipa_irq_handler_t handler, + bool deferred_flag, + void *private_data) +{ + return -EPERM; +} + +static inline int ipa_restore_suspend_handler(void) +{ + return -EPERM; +} + +/* + * Messaging + */ +static inline int ipa_send_msg(struct ipa_msg_meta *meta, void *buff, + ipa_msg_free_fn callback) +{ + return -EPERM; +} + /* * Data path */ @@ -2247,36 +1849,13 @@ static inline int ipa_rmnet_ctl_xmit(struct sk_buff *skb) return -EPERM; } -/* - * To transfer multiple data packets - */ -static inline int ipa_tx_dp_mul( - enum ipa_client_type dst, - struct ipa_tx_data_desc *data_desc) -{ - return -EPERM; -} - static inline void ipa_free_skb(struct ipa_rx_data *rx_in) { } -static inline int ipa_rx_poll(u32 clnt_hdl, int budget) -{ - return -EPERM; -} - -static inline void ipa_recycle_wan_skb(struct sk_buff *skb) -{ -} - /* * System pipes */ -static inline u16 ipa_get_smem_restr_bytes(void) -{ - return -EPERM; -} static inline int ipa_setup_sys_pipe(struct ipa_sys_connect_params *sys_in, u32 *clnt_hdl) @@ -2332,153 +1911,6 @@ static inline int ipa_uc_wdi_get_dbpa( return -EPERM; } -static inline int ipa_uc_reg_rdyCB( - struct ipa_wdi_uc_ready_params *param) -{ - return -EPERM; -} - -static inline int ipa_uc_dereg_rdyCB(void) -{ - return -EPERM; -} - - -/* - * Resource manager - */ -static inline int ipa_rm_create_resource( - struct ipa_rm_create_params *create_params) -{ - return -EPERM; -} - -static inline int ipa_rm_delete_resource( - enum ipa_rm_resource_name resource_name) -{ - return -EPERM; -} - -static inline int ipa_rm_register(enum ipa_rm_resource_name resource_name, - struct ipa_rm_register_params *reg_params) -{ - return -EPERM; -} - -static inline int ipa_rm_set_perf_profile( - enum ipa_rm_resource_name resource_name, - struct ipa_rm_perf_profile *profile) -{ - return -EPERM; -} - -static inline int ipa_rm_deregister(enum ipa_rm_resource_name resource_name, - struct ipa_rm_register_params *reg_params) -{ - return -EPERM; -} - -static inline int ipa_rm_add_dependency( - enum ipa_rm_resource_name resource_name, - enum ipa_rm_resource_name depends_on_name) -{ - return -EPERM; -} - -static inline int ipa_rm_add_dependency_sync( - enum ipa_rm_resource_name resource_name, - enum ipa_rm_resource_name depends_on_name) -{ - return -EPERM; -} - -static inline int ipa_rm_delete_dependency( - enum ipa_rm_resource_name resource_name, - enum ipa_rm_resource_name depends_on_name) -{ - return -EPERM; -} - -static inline int ipa_rm_request_resource( - enum ipa_rm_resource_name resource_name) -{ - return -EPERM; -} - -static inline int ipa_rm_release_resource( - enum ipa_rm_resource_name resource_name) -{ - return -EPERM; -} - -static inline int ipa_rm_notify_completion(enum ipa_rm_event event, - enum ipa_rm_resource_name resource_name) -{ - return -EPERM; -} - -static inline int ipa_rm_inactivity_timer_init( - enum ipa_rm_resource_name resource_name, - unsigned long msecs) -{ - return -EPERM; -} - -static inline int ipa_rm_inactivity_timer_destroy( - enum ipa_rm_resource_name resource_name) -{ - return -EPERM; -} - -static inline int ipa_rm_inactivity_timer_request_resource( - enum ipa_rm_resource_name resource_name) -{ - return -EPERM; -} - -static inline int ipa_rm_inactivity_timer_release_resource( - enum ipa_rm_resource_name resource_name) -{ - return -EPERM; -} - -/* - * Tethering bridge (Rmnet / MBIM) - */ -static inline int teth_bridge_init(struct teth_bridge_init_params *params) -{ - return -EPERM; -} - -static inline int teth_bridge_disconnect(enum ipa_client_type client) -{ - return -EPERM; -} - -static inline int teth_bridge_connect(struct teth_bridge_connect_params - *connect_params) -{ - return -EPERM; -} - -/* - * Tethering client info - */ -static inline void ipa_set_client(int index, enum ipacm_client_enum client, - bool uplink) -{ -} - -static inline enum ipacm_client_enum ipa_get_client(int pipe_idx) -{ - return -EPERM; -} - -static inline bool ipa_get_client_uplink(int pipe_idx) -{ - return -EPERM; -} - /* * IPADMA */ @@ -2510,51 +1942,13 @@ static inline int ipa_dma_async_memcpy(phys_addr_t dest, phys_addr_t src return -EPERM; } -static inline int ipa_dma_uc_memcpy(phys_addr_t dest, phys_addr_t src, int len) -{ - return -EPERM; -} - static inline void ipa_dma_destroy(void) { } -/* - * mux id - */ -static inline int ipa_write_qmap_id(struct ipa_ioc_write_qmapid *param_in) -{ - return -EPERM; -} - -/* - * interrupts - */ -static inline int ipa_add_interrupt_handler(enum ipa_irq_type interrupt, - ipa_irq_handler_t handler, - bool deferred_flag, - void *private_data) -{ - return -EPERM; -} - -static inline int ipa_remove_interrupt_handler(enum ipa_irq_type interrupt) -{ - return -EPERM; -} - -static inline int ipa_restore_suspend_handler(void) -{ - return -EPERM; -} - /* * Miscellaneous */ -static inline void ipa_bam_reg_dump(void) -{ -} - static inline int ipa_get_wdi_stats(struct IpaHwStatsWDIInfoData_t *stats) { return -EPERM; @@ -2565,11 +1959,6 @@ static inline int ipa_uc_bw_monitor(struct ipa_wdi_bw_info *info) return -EPERM; } -static inline int ipa_set_wlan_tx_info(struct ipa_wdi_tx_info *info) -{ - return -EPERM; -} - static inline int ipa_get_ep_mapping(enum ipa_client_type client) { return -EPERM; @@ -2580,75 +1969,36 @@ static inline bool ipa_is_ready(void) return false; } -static inline void ipa_proxy_clk_vote(void) -{ -} - -static inline void ipa_proxy_clk_unvote(void) -{ -} - static inline enum ipa_hw_type ipa_get_hw_type(void) { return IPA_HW_None; } -static inline bool ipa_is_client_handle_valid(u32 clnt_hdl) +static inline int ipa_register_ipa_ready_cb( + void (*ipa_ready_cb)(void *user_data), + void *user_data) { - return -EINVAL; + return -EPERM; } -static inline enum ipa_client_type ipa_get_client_mapping(int pipe_idx) +static inline int ipa_get_smmu_params(struct ipa_smmu_in_params *in, + struct ipa_smmu_out_params *out) { - return -EINVAL; + return -EPERM; } -static inline enum ipa_rm_resource_name ipa_get_rm_resource_from_ep( - int pipe_idx) +static inline int ipa_is_vlan_mode(enum ipa_vlan_ifaces iface, bool *res) { - return -EFAULT; + return -EPERM; } -static inline bool ipa_get_modem_cfg_emb_pipe_flt(void) +static inline bool ipa_get_lan_rx_napi(void) { - return -EINVAL; + return false; } -static inline enum ipa_transport_type ipa_get_transport_type(void) -{ - return -EFAULT; -} - -static inline struct device *ipa_get_dma_dev(void) -{ - return NULL; -} - -static inline struct iommu_domain *ipa_get_smmu_domain(void) -{ - return NULL; -} - -static inline int ipa_create_wdi_mapping(u32 num_buffers, - struct ipa_wdi_buffer_info *info) -{ - return -EINVAL; -} - -static inline int ipa_release_wdi_mapping(u32 num_buffers, - struct ipa_wdi_buffer_info *info) -{ - return -EINVAL; -} - -static inline int ipa_disable_apps_wan_cons_deaggr(uint32_t agg_size, - uint32_t agg_count) -{ - return -EINVAL; -} - -static inline const struct ipa_gsi_ep_config *ipa_get_gsi_ep_info - (enum ipa_client_type client) +static inline const struct ipa_gsi_ep_config *ipa_get_gsi_ep_info( + enum ipa_client_type client) { return NULL; } @@ -2658,13 +2008,6 @@ static inline int ipa_stop_gsi_channel(u32 clnt_hdl) return -EPERM; } -static inline int ipa_register_ipa_ready_cb( - void (*ipa_ready_cb)(void *user_data), - void *user_data) -{ - return -EPERM; -} - static inline int ipa_register_rmnet_ctl_cb( void (*ipa_rmnet_ctl_ready_cb)(void *user_data1), void *user_data1, @@ -2681,50 +2024,255 @@ static inline int ipa_unregister_rmnet_ctl_cb(void) return -EPERM; } -static inline int ipa_tz_unlock_reg(struct ipa_tz_unlock_reg_info *reg_info, - u16 num_regs) -{ - return -EPERM; -} - - -static inline int ipa_get_smmu_params(struct ipa_smmu_in_params *in, - struct ipa_smmu_out_params *out) -{ - return -EPERM; -} - -static inline int ipa_is_vlan_mode(enum ipa_vlan_ifaces iface, bool *res) -{ - return -EPERM; -} - -static inline bool ipa_get_lan_rx_napi(void) -{ - return false; -} - -static inline int ipa_uc_debug_stats_alloc( - struct IpaHwOffloadStatsAllocCmdData_t cmdinfo) -{ - return -EPERM; -} - -static inline int ipa_uc_debug_stats_dealloc(uint32_t protocol) -{ - return -EPERM; -} - -static inline void ipa_get_gsi_stats(int prot_id, - struct ipa_uc_dbg_ring_stats *stats) -{ -} - -static inline int ipa_get_prot_id(enum ipa_client_type client) +static inline int ipa_uc_reg_rdyCB( + struct ipa_wdi_uc_ready_params *inout) { return -EPERM; } #endif /* IS_ENABLED(CONFIG_IPA3) */ +/* stubs - to be removed once dependent drivers remove references */ +static inline int ipa_reset_endpoint(u32 clnt_hdl) +{ + return -EPERM; +} + +static inline int ipa_clear_endpoint_delay(u32 clnt_hdl) +{ + return -EPERM; +} + +static inline int ipa_commit_hdr(void) +{ + return -EPERM; +} + +static inline int ipa_put_hdr(u32 hdr_hdl) +{ + return -EPERM; +} + +static inline int ipa_copy_hdr(struct ipa_ioc_copy_hdr *copy) +{ + return -EPERM; +} + +static inline int ipa_register_pull_msg(struct ipa_msg_meta *meta, + ipa_msg_pull_fn callback) +{ + return -EPERM; +} + +static inline int ipa_deregister_pull_msg(struct ipa_msg_meta *meta) +{ + return -EPERM; +} + +static inline int ipa_register_intf_ext(const char *name, + const struct ipa_tx_intf *tx, + const struct ipa_rx_intf *rx, + const struct ipa_ext_intf *ext) +{ + return -EPERM; +} + +static inline int ipa_tx_dp_mul(enum ipa_client_type src, + struct ipa_tx_data_desc *data_desc) +{ + return -EPERM; +} + +static inline u16 ipa_get_smem_restr_bytes(void) +{ + return -EPERM; +} + +static inline int ipa_create_wdi_mapping(u32 num_buffers, + struct ipa_wdi_buffer_info *info) +{ + return -EPERM; +} + +static inline int ipa_release_wdi_mapping(u32 num_buffers, + struct ipa_wdi_buffer_info *info) +{ + return -EPERM; +} + +static inline int ipa_rm_create_resource( + struct ipa_rm_create_params *create_params) +{ + return -EPERM; +} + +static inline int ipa_rm_delete_resource( + enum ipa_rm_resource_name resource_name) +{ + return -EPERM; +} + +static inline int ipa_rm_register(enum ipa_rm_resource_name resource_name, + struct ipa_rm_register_params *reg_params) +{ + return -EPERM; +} + +static inline int ipa_rm_deregister( + enum ipa_rm_resource_name resource_name, + struct ipa_rm_register_params *reg_params) +{ + return -EPERM; +} + +static inline int ipa_rm_set_perf_profile( + enum ipa_rm_resource_name resource_name, + struct ipa_rm_perf_profile *profile) +{ + return -EPERM; +} + +static inline int ipa_rm_add_dependency( + enum ipa_rm_resource_name resource_name, + enum ipa_rm_resource_name depends_on_name) +{ + return -EPERM; +} + +static inline int ipa_rm_add_dependency_sync( + enum ipa_rm_resource_name resource_name, + enum ipa_rm_resource_name depends_on_name) +{ + return -EPERM; +} + +static inline int ipa_rm_delete_dependency( + enum ipa_rm_resource_name resource_name, + enum ipa_rm_resource_name depends_on_name) +{ + return -EPERM; +} + +static inline int ipa_rm_request_resource( + enum ipa_rm_resource_name resource_name) +{ + return -EPERM; +} + +static inline int ipa_rm_inactivity_timer_init( + enum ipa_rm_resource_name resource_name, + unsigned long msecs) +{ + return -EPERM; +} + +static inline int ipa_rm_release_resource( + enum ipa_rm_resource_name resource_name) +{ + return -EPERM; +} + +static inline int ipa_rm_notify_completion(enum ipa_rm_event event, + enum ipa_rm_resource_name resource_name) +{ + return -EPERM; +} + +static inline int ipa_rm_inactivity_timer_destroy( + enum ipa_rm_resource_name resource_name) +{ + return -EPERM; +} + +static inline int ipa_rm_inactivity_timer_request_resource( + enum ipa_rm_resource_name resource_name) +{ + return -EPERM; +} + +static inline int ipa_rm_inactivity_timer_release_resource( + enum ipa_rm_resource_name resource_name) +{ + return -EPERM; +} + +static inline enum ipa_rm_resource_name ipa_get_rm_resource_from_ep( + int pipe_idx) +{ + return -EPERM; +} + +static inline void ipa_bam_reg_dump(void) +{ +} + +static inline void ipa_proxy_clk_vote(void) +{ +} + +static inline void ipa_proxy_clk_unvote(void) +{ +} + +static inline bool ipa_is_client_handle_valid(u32 clnt_hdl) +{ + return false; +} + +static inline enum ipa_client_type ipa_get_client_mapping(int pipe_idx) +{ + return -EPERM; +} + +static inline bool ipa_get_modem_cfg_emb_pipe_flt(void) +{ + return false; +} + +static inline enum ipa_transport_type ipa_get_transport_type(void) +{ + return IPA_TRANSPORT_TYPE_GSI; +} + +static inline struct device *ipa_get_dma_dev(void) +{ + return NULL; +} + +static inline struct iommu_domain *ipa_get_smmu_domain(void) +{ + return NULL; +} + +static inline int ipa_disable_apps_wan_cons_deaggr( + uint32_t agg_size, uint32_t agg_count) +{ + return -EPERM; +} + +static inline int ipa_add_hdr(struct ipa_ioc_add_hdr *hdrs) +{ + return -EPERM; +} + +static inline int ipa_del_hdr(struct ipa_ioc_del_hdr *hdls) +{ + return -EPERM; +} + +static inline int ipa_get_hdr(struct ipa_ioc_get_hdr *lookup) +{ + return -EPERM; +} + +static inline int ipa_deregister_intf(const char *name) +{ + return -EPERM; +} + +static inline int ipa_uc_dereg_rdyCB(void) +{ + return -EPERM; +} + #endif /* _IPA_H_ */ diff --git a/include/linux/ipa_fmwk.h b/include/linux/ipa_fmwk.h index 91de1f44605e..d70a49cfdd23 100644 --- a/include/linux/ipa_fmwk.h +++ b/include/linux/ipa_fmwk.h @@ -7,11 +7,103 @@ #define _IPA_FMWK_H_ #include +#include +#include +#include +#include +#include #include +#include +#include struct ipa_core_data { int (*ipa_tx_dp)(enum ipa_client_type dst, struct sk_buff *skb, struct ipa_tx_meta *metadata); + + enum ipa_hw_type (*ipa_get_hw_type)(void); + + int (*ipa_get_smmu_params)(struct ipa_smmu_in_params *in, + struct ipa_smmu_out_params *out); + + int (*ipa_is_vlan_mode)(enum ipa_vlan_ifaces iface, bool *res); + + bool (*ipa_get_lan_rx_napi)(void); + + int (*ipa_dma_init)(void); + + int (*ipa_dma_enable)(void); + + int (*ipa_dma_disable)(void); + + int (*ipa_dma_sync_memcpy)(u64 dest, u64 src, int len); + + int (*ipa_dma_async_memcpy)(u64 dest, u64 src, int len, + void (*user_cb)(void *user1), void *user_param); + + void (*ipa_dma_destroy)(void); + + int (*ipa_get_ep_mapping)(enum ipa_client_type client); + + int (*ipa_send_msg)(struct ipa_msg_meta *meta, void *buff, + ipa_msg_free_fn callback); + + void (*ipa_free_skb)(struct ipa_rx_data *data); + + int (*ipa_setup_sys_pipe)(struct ipa_sys_connect_params *sys_in, + u32 *clnt_hdl); + + int (*ipa_teardown_sys_pipe)(u32 clnt_hdl); + + int (*ipa_get_wdi_stats)(struct IpaHwStatsWDIInfoData_t *stats); + + int (*ipa_uc_bw_monitor)(struct ipa_wdi_bw_info *info); + + int (*ipa_broadcast_wdi_quota_reach_ind)(uint32_t fid, + uint64_t num_bytes); + + int (*ipa_uc_wdi_get_dbpa)(struct ipa_wdi_db_params *out); + + int (*ipa_cfg_ep_ctrl)(u32 clnt_hdl, + const struct ipa_ep_cfg_ctrl *ep_ctrl); + + int (*ipa_add_rt_rule)(struct ipa_ioc_add_rt_rule *rules); + + int (*ipa_put_rt_tbl)(u32 rt_tbl_hdl); + + int (*ipa_register_intf)(const char *name, + const struct ipa_tx_intf *tx, + const struct ipa_rx_intf *rx); + + int (*ipa_set_aggr_mode)(enum ipa_aggr_mode mode); + + int (*ipa_set_qcncm_ndp_sig)(char sig[3]); + + int (*ipa_set_single_ndp_per_mbim)(bool enable); + + int (*ipa_add_interrupt_handler)(enum ipa_irq_type interrupt, + ipa_irq_handler_t handler, + bool deferred_flag, + void *private_data); + + int (*ipa_restore_suspend_handler)(void); + + const struct ipa_gsi_ep_config *(*ipa_get_gsi_ep_info)( + enum ipa_client_type client); + + int (*ipa_stop_gsi_channel)(u32 clnt_hdl); + + int (*ipa_rmnet_ctl_xmit)(struct sk_buff *skb); + + int (*ipa_register_rmnet_ctl_cb)( + void (*ipa_rmnet_ctl_ready_cb)(void *user_data1), + void *user_data1, + void (*ipa_rmnet_ctl_stop_cb)(void *user_data2), + void *user_data2, + void (*ipa_rmnet_ctl_rx_notify_cb)( + void *user_data3, void *rx_data), + void *user_data3); + + int (*ipa_unregister_rmnet_ctl_cb)(void); }; struct ipa_usb_data { @@ -41,23 +133,192 @@ struct ipa_usb_data { enum ipa_usb_teth_prot teth_prot); }; +struct ipa_wdi3_data { + int (*ipa_wdi_init)(struct ipa_wdi_init_in_params *in, + struct ipa_wdi_init_out_params *out); + + int (*ipa_wdi_cleanup)(void); + + int (*ipa_wdi_reg_intf)( + struct ipa_wdi_reg_intf_in_params *in); + + int (*ipa_wdi_dereg_intf)(const char *netdev_name); + + int (*ipa_wdi_conn_pipes)(struct ipa_wdi_conn_in_params *in, + struct ipa_wdi_conn_out_params *out); + + int (*ipa_wdi_disconn_pipes)(void); + + int (*ipa_wdi_enable_pipes)(void); + + int (*ipa_wdi_disable_pipes)(void); + + int (*ipa_wdi_set_perf_profile)(struct ipa_wdi_perf_profile *profile); + + int (*ipa_wdi_create_smmu_mapping)(u32 num_buffers, + struct ipa_wdi_buffer_info *info); + + int (*ipa_wdi_release_smmu_mapping)(u32 num_buffers, + struct ipa_wdi_buffer_info *info); + + int (*ipa_wdi_get_stats)(struct IpaHwStatsWDIInfoData_t *stats); + + int (*ipa_wdi_bw_monitor)(struct ipa_wdi_bw_info *info); + + int (*ipa_wdi_sw_stats)(struct ipa_wdi_tx_info *info); +}; + +struct ipa_gsb_data { + int (*ipa_bridge_init)(struct ipa_bridge_init_params *params, u32 *hdl); + + int (*ipa_bridge_connect)(u32 hdl); + + int (*ipa_bridge_set_perf_profile)(u32 hdl, u32 bandwidth); + + int (*ipa_bridge_disconnect)(u32 hdl); + + int (*ipa_bridge_suspend)(u32 hdl); + + int (*ipa_bridge_resume)(u32 hdl); + + int (*ipa_bridge_tx_dp)(u32 hdl, struct sk_buff *skb, + struct ipa_tx_meta *metadata); + + int (*ipa_bridge_cleanup)(u32 hdl); +}; + +struct ipa_uc_offload_data { + int (*ipa_uc_offload_reg_intf)( + struct ipa_uc_offload_intf_params *in, + struct ipa_uc_offload_out_params *out); + + int (*ipa_uc_offload_cleanup)(u32 clnt_hdl); + + int (*ipa_uc_offload_conn_pipes)( + struct ipa_uc_offload_conn_in_params *in, + struct ipa_uc_offload_conn_out_params *out); + + int (*ipa_uc_offload_disconn_pipes)(u32 clnt_hdl); + + int (*ipa_set_perf_profile)(struct ipa_perf_profile *profile); + + int (*ipa_uc_offload_reg_rdyCB)(struct ipa_uc_ready_params *param); + + void (*ipa_uc_offload_dereg_rdyCB)(enum ipa_uc_offload_proto proto); +}; + +struct ipa_mhi_data { + int (*ipa_mhi_init)(struct ipa_mhi_init_params *params); + + int (*ipa_mhi_start)(struct ipa_mhi_start_params *params); + + int (*ipa_mhi_connect_pipe)(struct ipa_mhi_connect_params *in, + u32 *clnt_hdl); + + int (*ipa_mhi_disconnect_pipe)(u32 clnt_hdl); + + int (*ipa_mhi_suspend)(bool force); + + int (*ipa_mhi_resume)(void); + + void (*ipa_mhi_destroy)(void); + + int (*ipa_mhi_handle_ipa_config_req)( + struct ipa_config_req_msg_v01 *config_req); +}; + +struct ipa_wigig_data { + int (*ipa_wigig_init)(struct ipa_wigig_init_in_params *in, + struct ipa_wigig_init_out_params *out); + + int (*ipa_wigig_cleanup)(void); + + bool (*ipa_wigig_is_smmu_enabled)(void); + + int (*ipa_wigig_reg_intf)(struct ipa_wigig_reg_intf_in_params *in); + + int (*ipa_wigig_dereg_intf)(const char *netdev_name); + + int (*ipa_wigig_conn_rx_pipe)(struct ipa_wigig_conn_rx_in_params *in, + struct ipa_wigig_conn_out_params *out); + + int (*ipa_wigig_conn_rx_pipe_smmu)( + struct ipa_wigig_conn_rx_in_params_smmu *in, + struct ipa_wigig_conn_out_params *out); + + int (*ipa_wigig_conn_client)(struct ipa_wigig_conn_tx_in_params *in, + struct ipa_wigig_conn_out_params *out); + + int (*ipa_wigig_conn_client_smmu)( + struct ipa_wigig_conn_tx_in_params_smmu *in, + struct ipa_wigig_conn_out_params *out); + + int (*ipa_wigig_disconn_pipe)(enum ipa_client_type client); + + int (*ipa_wigig_enable_pipe)(enum ipa_client_type client); + + int (*ipa_wigig_disable_pipe)(enum ipa_client_type client); + + int (*ipa_wigig_tx_dp)(enum ipa_client_type dst, struct sk_buff *skb); + + int (*ipa_wigig_set_perf_profile)(u32 max_supported_bw_mbps); + + int (*ipa_wigig_save_regs)(void); +}; + #if IS_ENABLED(CONFIG_IPA3) int ipa_fmwk_register_ipa(const struct ipa_core_data *in); int ipa_fmwk_register_ipa_usb(const struct ipa_usb_data *in); +int ipa_fmwk_register_ipa_wdi3(const struct ipa_wdi3_data *in); + +int ipa_fmwk_register_gsb(const struct ipa_gsb_data *in); + +int ipa_fmwk_register_uc_offload(const struct ipa_uc_offload_data *in); + +int ipa_fmwk_register_ipa_mhi(const struct ipa_mhi_data *in); + +int ipa_fmwk_register_ipa_wigig(const struct ipa_wigig_data *in); + #else /* IS_ENABLED(CONFIG_IPA3) */ int ipa_fmwk_register_ipa(const struct ipa_core_data *in) { return -EPERM; } + int ipa_fmwk_register_ipa_usb(const struct ipa_usb_data *in) { return -EPERM; } +int ipa_fmwk_register_ipa_wdi3(const struct ipa_wdi3_data *in) +{ + return -EPERM; +} + +int ipa_fmwk_register_gsb(const struct ipa_gsb_data *in) +{ + return -EPERM; +} + +int ipa_fmwk_register_uc_offload(const struct ipa_uc_offload_data *in) +{ + return -EPERM; +} + +int ipa_fmwk_register_ipa_mhi(const struct ipa_mhi_data *in) +{ + return -EPERM; +} + +int ipa_fmwk_register_ipa_wigig(const struct ipa_wigig_data *in) +{ + return -EPERM; +} + #endif /* IS_ENABLED(CONFIG_IPA3) */ #endif /* _IPA_FMWK_H_ */ diff --git a/include/linux/ipa_odu_bridge.h b/include/linux/ipa_odu_bridge.h index db2ed9b61bd6..688b964e043f 100644 --- a/include/linux/ipa_odu_bridge.h +++ b/include/linux/ipa_odu_bridge.h @@ -1,6 +1,6 @@ /* SPDX-License-Identifier: GPL-2.0-only */ /* - * Copyright (c) 2012-2019, The Linux Foundation. All rights reserved. + * Copyright (c) 2012-2020, The Linux Foundation. All rights reserved. */ #ifndef _IPA_ODO_BRIDGE_H_ @@ -110,19 +110,6 @@ static inline int ipa_bridge_cleanup(u32 hdl) #endif /* IS_ENABLED(CONFIG_IPA3) */ /* Below API is deprecated. Please use the API above */ -#if IS_ENABLED(CONFIG_IPA3) - -int odu_bridge_init(struct odu_bridge_params *params); - -int odu_bridge_connect(void); - -int odu_bridge_disconnect(void); - -int odu_bridge_tx_dp(struct sk_buff *skb, struct ipa_tx_meta *metadata); - -int odu_bridge_cleanup(void); - -#else /* IS_ENABLED(CONFIG_IPA3) */ static inline int odu_bridge_init(struct odu_bridge_params *params) { @@ -150,6 +137,4 @@ static inline int odu_bridge_cleanup(void) return -EPERM; } -#endif /* IS_ENABLED(CONFIG_IPA3) */ - #endif /* _IPA_ODO_BRIDGE_H */ diff --git a/include/linux/ipa_wigig.h b/include/linux/ipa_wigig.h index d3be69ca6336..9a96899ddb66 100644 --- a/include/linux/ipa_wigig.h +++ b/include/linux/ipa_wigig.h @@ -1,6 +1,6 @@ /* SPDX-License-Identifier: GPL-2.0-only */ /* - * Copyright (c) 2018-2019, The Linux Foundation. All rights reserved. + * Copyright (c) 2018-2020, The Linux Foundation. All rights reserved. */ #ifndef _IPA_WIGIG_H_ @@ -478,7 +478,7 @@ static inline int ipa_wigig_tx_dp(enum ipa_client_type dst, return -EPERM; } -int ipa_wigig_set_perf_profile(u32 max_supported_bw_mbps) +static inline int ipa_wigig_set_perf_profile(u32 max_supported_bw_mbps) { return -EPERM; }