Initial commit: Linux kernel 4.19 for Unplugged OS

This commit is contained in:
ziv committed 2025-10-06 13:52:42 +00:00
commit d30235b04c
80519 files changed
+35800681

No files matched your search

@@ -0,0 +1,9 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* mddp_app_config.h - Configuration of MDDP applications.
*
* Copyright (c) 2020 MediaTek Inc.
*/
MDDP_MODULE_ID(MDDP_APP_TYPE_WH)
MDDP_MODULE_PREFIX(mddpwh)
File diff suppressed because it is too large. Load diff
+340
View File
@@ -0,0 +1,340 @@
// SPDX-License-Identifier: GPL-2.0
/*
* mddp_if.c - Interface API between MDDP and other kernel module.
*
* Copyright (c) 2020 MediaTek Inc.
*/
#include <linux/module.h>
#include <linux/netdevice.h>
#include "mddp_ctrl.h"
#include "mddp_debug.h"
#include "mddp_dev.h"
#include "mddp_filter.h"
#include "mddp_sm.h"
#include "mddp_usage.h"
#define MDDP_WIFI_NETIF_ID 0x500 /* copy from MD IPC_NETIF_ID_MCIF_BEGIN */
//------------------------------------------------------------------------------
// Struct definition.
// -----------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Private helper macro.
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Private variables.
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Private helper macro.
//------------------------------------------------------------------------------
#define MDDP_CHECK_APP_TYPE(_type) ((_type < MDDP_APP_TYPE_CNT) ? (1) : (0))
//------------------------------------------------------------------------------
// Private functions.
//------------------------------------------------------------------------------
static uint32_t mddp_netdev_notifier_is_init;
static int mddp_netdev_notify_cb(struct notifier_block *nb,
unsigned long event, void *data)
{
struct mddp_app_t *app;
struct net_device *dev = netdev_notifier_info_to_dev(data);
if (!mddp_netdev_notifier_is_init)
return NOTIFY_DONE;
if (event == NETDEV_UNREGISTER) {
if (mddp_f_is_support_lan_dev(dev->ifindex) ||
mddp_f_is_support_wan_dev(dev->ifindex)) {
app = mddp_get_app_inst(MDDP_APP_TYPE_WH);
mddp_sm_on_event(app, MDDP_EVT_FUNC_DEACT);
}
}
return NOTIFY_DONE;
}
static struct notifier_block mddp_netdev_notifier __read_mostly = {
.notifier_call = mddp_netdev_notify_cb,
};
void mddp_netdev_notifier_init(void)
{
if (register_netdevice_notifier(&mddp_netdev_notifier) == 0)
mddp_netdev_notifier_is_init = 1;
}
void mddp_netdev_notifier_exit(void)
{
if (mddp_netdev_notifier_is_init) {
mddp_netdev_notifier_is_init = 0;
unregister_netdevice_notifier(&mddp_netdev_notifier);
}
}
//------------------------------------------------------------------------------
// Public functions.
//------------------------------------------------------------------------------
int32_t mddp_drv_attach(
struct mddp_drv_conf_t *conf,
struct mddp_drv_handle_t *handle)
{
if (MDDP_CHECK_APP_TYPE(conf->app_type) && handle)
return mddp_sm_reg_callback(conf, handle);
MDDP_C_LOG(MDDP_LL_WARN,
"%s: Failed to drv_attach, type(%d), handle(%p)!\n",
__func__, conf->app_type, handle);
return -EINVAL;
}
EXPORT_SYMBOL(mddp_drv_attach);
void mddp_drv_detach(
struct mddp_drv_conf_t *conf,
struct mddp_drv_handle_t *handle)
{
if (MDDP_CHECK_APP_TYPE(conf->app_type))
mddp_sm_dereg_callback(conf, handle);
}
EXPORT_SYMBOL(mddp_drv_detach);
int32_t mddp_on_enable(enum mddp_app_type_e in_type)
{
struct mddp_app_t *app;
uint32_t type;
uint8_t idx;
if (in_type != MDDP_APP_TYPE_ALL)
return -EINVAL;
/*
* MDDP ENABLE command.
*/
for (idx = 0; idx < MDDP_MOD_CNT; idx++) {
type = mddp_sm_module_list_s[idx];
app = mddp_get_app_inst(type);
mddp_sm_wait_pre(app);
mddp_sm_on_event(app, MDDP_EVT_FUNC_ENABLE);
mddp_sm_wait(app, MDDP_EVT_FUNC_ENABLE);
}
return 0;
}
int32_t mddp_on_disable(enum mddp_app_type_e in_type)
{
struct mddp_app_t *app;
uint32_t type;
uint8_t idx;
if (in_type != MDDP_APP_TYPE_ALL)
return -EINVAL;
/*
* MDDP DISABLE command.
*/
for (idx = 0; idx < MDDP_MOD_CNT; idx++) {
type = mddp_sm_module_list_s[idx];
app = mddp_get_app_inst(type);
mddp_sm_wait_pre(app);
mddp_sm_on_event(app, MDDP_EVT_FUNC_DISABLE);
mddp_sm_wait(app, MDDP_EVT_FUNC_DISABLE);
}
return 0;
}
int32_t mddp_on_activate(enum mddp_app_type_e type,
uint8_t *ul_dev_name, uint8_t *dl_dev_name)
{
struct mddp_app_t *app;
// NG. app_type is unknown!
if (!MDDP_CHECK_APP_TYPE(type))
return -EINVAL;
// NG. app is not configured!
app = mddp_get_app_inst(type);
if (!app->is_config)
return -EINVAL;
if (!mddp_f_dev_add_wan_dev(ul_dev_name))
return -EINVAL;
if (!mddp_f_dev_add_lan_dev(dl_dev_name, MDDP_WIFI_NETIF_ID)) {
mddp_f_dev_del_wan_dev(ul_dev_name);
return -EINVAL;
}
mddp_netdev_notifier_init();
/*
* MDDP ACTIVATE command.
*/
strlcpy(app->ap_cfg.ul_dev_name, ul_dev_name,
sizeof(app->ap_cfg.ul_dev_name));
strlcpy(app->ap_cfg.dl_dev_name, dl_dev_name,
sizeof(app->ap_cfg.dl_dev_name));
MDDP_C_LOG(MDDP_LL_INFO,
"%s: type(%d), app(%p), ul(%s), dl(%s).\n",
__func__, type, app,
app->ap_cfg.ul_dev_name, app->ap_cfg.dl_dev_name);
mddp_sm_wait_pre(app);
mddp_sm_on_event(app, MDDP_EVT_FUNC_ACT);
mddp_sm_wait(app, MDDP_EVT_FUNC_ACT);
mddp_u_set_wan_iface(ul_dev_name);
return 0;
}
int32_t mddp_on_deactivate(enum mddp_app_type_e type)
{
struct mddp_app_t *app;
// NG. app_type is unknown!
if (!MDDP_CHECK_APP_TYPE(type))
return -EINVAL;
// NG. app is not configured!
app = mddp_get_app_inst(type);
if (!app->is_config)
return -EINVAL;
mddp_netdev_notifier_exit();
/*
* MDDP DEACTIVATE command.
*/
mddp_sm_wait_pre(app);
mddp_sm_on_event(app, MDDP_EVT_FUNC_DEACT);
mddp_sm_wait(app, MDDP_EVT_FUNC_DEACT);
return 0;
}
int32_t mddp_on_get_offload_stats(
enum mddp_app_type_e type,
uint8_t *buf,
uint32_t *buf_len)
{
if (type != MDDP_APP_TYPE_ALL)
return -EINVAL;
/*
* MDDP GET_OFFLOAD_STATISTICS command.
*/
mddp_u_get_data_stats(buf, buf_len);
return 0;
}
int32_t mddp_on_set_data_limit(
enum mddp_app_type_e type,
uint8_t *buf,
uint32_t buf_len)
{
int32_t ret;
if (type != MDDP_APP_TYPE_ALL)
return -EINVAL;
ret = mddp_u_set_data_limit(buf, buf_len);
return ret;
}
int32_t mddp_on_set_warning_and_data_limit(
enum mddp_app_type_e type,
uint8_t *buf,
uint32_t buf_len)
{
int32_t ret;
if (type != MDDP_APP_TYPE_ALL)
return -EINVAL;
ret = mddp_u_set_warning_and_data_limit(buf, buf_len);
return ret;
}
int32_t mddp_on_set_ct_value(
enum mddp_app_type_e type,
uint8_t *buf,
uint32_t buf_len)
{
int32_t ret;
if (type != MDDP_APP_TYPE_ALL)
return -EINVAL;
/*
* MDDP GET_OFFLOAD_STATISTICS command.
*/
ret = mddp_f_set_ct_value(buf, buf_len);
return ret;
}
//------------------------------------------------------------------------------
// Kernel functions.
//------------------------------------------------------------------------------
static int mddp_init_steps;
static void mddp_exit(void)
{
synchronize_net();
switch (mddp_init_steps) {
case 4:
mddp_filter_uninit();
/* fallthrough */
case 3:
mddp_dev_uninit();
/* fallthrough */
case 2:
mddp_ipc_uninit();
/* fallthrough */
case 1:
mddp_sm_uninit();
/* fallthrough */
default:
break;
}
}
static int __init mddp_init(void)
{
int32_t ret = 0;
ret = mddp_sm_init();
if (ret < 0)
goto _init_fail;
mddp_init_steps++;
ret = mddp_ipc_init();
if (ret < 0)
goto _init_fail;
mddp_init_steps++;
ret = mddp_dev_init();
if (ret < 0)
goto _init_fail;
mddp_init_steps++;
ret = mddp_filter_init();
if (ret < 0)
goto _init_fail;
mddp_init_steps++;
return 0;
_init_fail:
mddp_exit();
return 0;
}
module_init(mddp_init);
module_exit(mddp_exit);
MODULE_LICENSE("GPL v2");
+32
View File
@@ -0,0 +1,32 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* mddp_if.h - Structure/API provided by mddp_if.c
*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifndef __MDDP_IF_H
#define __MDDP_IF_H
//------------------------------------------------------------------------------
// Struct definition.
// -----------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Public functions.
// -----------------------------------------------------------------------------
uint32_t mddp_on_enable(enum mddp_app_type_e type);
uint32_t mddp_on_disable(enum mddp_app_type_e type);
int32_t mddp_on_activate(enum mddp_app_type_e type,
uint8_t *ul_dev_name, uint8_t *dl_dev_name);
bool mddp_on_deactivate(enum mddp_app_type_e type);
int32_t mddp_on_get_offload_stats(enum mddp_app_type_e type,
uint8_t *buf, uint32_t *buf_len);
int32_t mddp_on_set_data_limit(enum mddp_app_type_e type,
uint8_t *buf, uint32_t buf_len);
int32_t mddp_on_set_warning_and_data_limit(enum mddp_app_type_e type,
uint8_t *buf, uint32_t buf_len);
int32_t mddp_on_set_ct_value(enum mddp_app_type_e type,
uint8_t *buf, uint32_t buf_len);
#endif /* __MDDP_IF_H */
+293
View File
@@ -0,0 +1,293 @@
// SPDX-License-Identifier: GPL-2.0
/*
* mddp_ipc.c - MDDP IPC API between AP and MD.
*
* Copyright (c) 2020 MediaTek Inc.
*/
#include <linux/delay.h>
#include <linux/kthread.h>
#include <linux/sched/signal.h>
#include "mddp_debug.h"
#include "mddp_ipc.h"
#include "mddp_sm.h"
#include "mtk_ccci_common.h"
//------------------------------------------------------------------------------
// Struct definition.
// -----------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Global variables.
//------------------------------------------------------------------------------
static int32_t mddp_ipc_tty_port_s = -1;
static struct task_struct *rx_task;
static struct wfpm_smem_info_t smem_info_s[] = {
{MDDP_MD_SMEM_USER_RX_REORDER_TO_MD, 0, WFPM_SM_E_ATTRI_WO,
0,
0},
{MDDP_MD_SMEM_USER_RX_REORDER_FROM_MD, 0, WFPM_SM_E_ATTRI_RO,
0,
0},
{MDDP_MD_SMEM_USER_WIFI_STATISTICS, 0, WFPM_SM_E_ATTRI_RO,
0,
sizeof(struct mddpw_net_stat_t)},
{MDDP_MD_SMEM_USER_WIFI_STATISTICS_EXT, 0, WFPM_SM_E_ATTRI_RO,
sizeof(struct mddpw_net_stat_t),
sizeof(struct mddpw_net_stat_ext_t)},
{MDDP_MD_SMEM_USER_SYS_STAT_SYNC, 0, WFPM_SM_E_ATTRI_RW,
sizeof(struct mddpw_net_stat_t) + sizeof(struct mddpw_net_stat_ext_t),
sizeof(struct mddpw_sys_stat_t)},
};
static struct mddp_ipc_rx_msg_entry_t mddp_rx_msg_table_s[] = {
/* msg_id */
/* rx_msg_len */
{ IPC_MSG_ID_WFPM_ENABLE_MD_FAST_PATH_RSP,
sizeof(struct wfpm_enable_md_func_rsp_t) },
{ IPC_MSG_ID_WFPM_DEACTIVATE_MD_FAST_PATH_RSP,
sizeof(struct wfpm_deactivate_md_func_rsp_t) },
{ IPC_MSG_ID_WFPM_MD_NOTIFY,
sizeof(struct mddpw_md_notify_info_t) },
{ IPC_MSG_ID_MDFPM_SUSPEND_TAG_IND,
0 },
{ IPC_MSG_ID_MDFPM_RESUME_TAG_IND,
0 },
};
static uint32_t mddp_rx_msg_table_cnt = ARRAY_SIZE(mddp_rx_msg_table_s);
//------------------------------------------------------------------------------
// Private variables.
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Private helper macro.
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Private functions.
//------------------------------------------------------------------------------
static int32_t mddp_ipc_md_smem_layout_config(void)
{
struct wfpm_smem_info_t *entry;
uint32_t i;
uint32_t total_len = 0;
uint32_t size;
uint8_t *addr;
uint8_t attr;
// Adjust offset of wfpm share memory
for (i = 0; i < MDDP_MD_SMEM_USER_NUM; i++) {
entry = &smem_info_s[i];
entry->offset = total_len;
total_len += entry->size;
size = 0;
if (!mddp_ipc_get_md_smem_by_id(entry->user_id,
(void **)&addr, &attr, &size) && size > 0) {
memset(addr, 0, size);
}
}
MDDP_C_LOG(MDDP_LL_INFO,
"%s: smem total_len(%d)!\n", __func__, total_len);
return 0;
}
static int32_t mddp_ipc_open_port(void)
{
int32_t ret;
mddp_ipc_tty_port_s = mtk_ccci_request_port(MDDP_IPC_TTY_NAME);
if (mddp_ipc_tty_port_s < 0) {
MDDP_C_LOG(MDDP_LL_WARN,
"%s: Failed to request port(%s, %d)!\n",
__func__,
MDDP_IPC_TTY_NAME, mddp_ipc_tty_port_s);
return -ENODEV;
}
ret = mtk_ccci_open_port(mddp_ipc_tty_port_s);
if (ret < 0) {
MDDP_C_LOG(MDDP_LL_WARN,
"%s: Failed to open port(%d)!\n",
__func__, mddp_ipc_tty_port_s);
return -ENODEV;
}
return 0;
}
//------------------------------------------------------------------------------
// Public functions.
//------------------------------------------------------------------------------
/*
* Rx kthread used to receive ctrl_msg from MD.
*/
static int32_t mddp_md_msg_hdlr(void *arg)
{
struct mdfpm_ctrl_msg_t ctrl_msg;
int32_t rx_count;
allow_signal(SIGTERM);
while (!kthread_should_stop()) {
if (mddp_ipc_tty_port_s < 0) {
MDDP_C_LOG(MDDP_LL_WARN,
"%s: ipc_tty_port is invalid(%d)!\n",
__func__, mddp_ipc_tty_port_s);
msleep(5000);
continue;
}
rx_count = mtk_ccci_read_data(mddp_ipc_tty_port_s,
(char *)&(ctrl_msg), sizeof(ctrl_msg));
if (signal_pending(current))
break;
if (rx_count > 0 && rx_count >= MDFPM_CTRL_MSG_HEADER_SZ) {
// OK. Forward to dest_user.
mddp_sm_msg_hdlr(ctrl_msg.dest_user_id, ctrl_msg.msg_id,
&(ctrl_msg.buf), ctrl_msg.buf_len);
} else {
// NG. Error to read TTY port!
MDDP_C_LOG(MDDP_LL_DEBUG,
"%s: Failed to read TTY (%d), count(%d)!\n",
__func__,
mddp_ipc_tty_port_s, rx_count);
msleep(1000);
continue;
}
}
return 0;
}
/*
* Tx API used to send ctrl_msg to MD.
*/
int32_t mddp_ipc_send_md(
void *in_app,
struct mddp_md_msg_t *msg,
enum mdfpm_user_id_e dest_user)
{
struct mddp_app_t *app;
int32_t ret;
struct mdfpm_ctrl_msg_t ctrl_msg;
if (!in_app)
app = mddp_get_default_app_inst();
else
app = (struct mddp_app_t *) in_app;
if (app->state == MDDP_STATE_UNINIT) {
kfree(msg);
return -ENODEV;
}
ctrl_msg.dest_user_id = (dest_user == MDFPM_USER_ID_NULL)
? (app->md_cfg.ipc_md_user_id) : (dest_user);
ctrl_msg.msg_id = msg->msg_id;
ctrl_msg.buf_len = msg->data_len;
if (msg->data_len > 0)
memcpy(ctrl_msg.buf, msg->data, msg->data_len);
ret = mtk_ccci_send_data(mddp_ipc_tty_port_s, (char *)&ctrl_msg,
sizeof(struct mddp_md_msg_t) + msg->data_len);
kfree(msg);
if (unlikely(ret < 0)) {
MDDP_C_LOG(MDDP_LL_WARN,
"%s: mtk_ccci_send_data error(%d)!\n",
__func__, ret);
app->abnormal_flags |= MDDP_ABNORMAL_CCCI_SEND_FAILED;
return -EAGAIN;
}
return 0;
}
int32_t wfpm_ipc_get_smem_list(void **smem_info_base, uint32_t *smem_num)
{
*smem_info_base = &smem_info_s;
*smem_num = MDDP_MD_SMEM_USER_NUM;
return 0;
}
int32_t mddp_ipc_get_md_smem_by_id(enum mddp_md_smem_user_id_e app_id,
void **smem_addr, uint8_t *smem_attr, uint32_t *smem_size)
{
struct wfpm_smem_info_t *smem_entry;
uint32_t smem_total_len;
smem_entry = &smem_info_s[app_id];
*smem_attr = smem_entry->attribute;
*smem_size = smem_entry->size;
*smem_addr = (uint8_t *)get_smem_start_addr(MD_SYS1,
SMEM_USER_RAW_USB, &smem_total_len);
if (!(*smem_addr))
return -EINVAL;
*smem_addr += smem_entry->offset;
return 0;
}
int32_t mddp_ipc_init(void)
{
int32_t ret = 0;
mddp_ipc_md_smem_layout_config();
ret = mddp_ipc_open_port();
if (ret)
return ret;
rx_task = kthread_run(mddp_md_msg_hdlr, NULL, "mddp_rx");
if (IS_ERR(rx_task)) {
MDDP_C_LOG(MDDP_LL_ERR,
"%s: kthread_run fail(%li)!\n",
__func__, PTR_ERR(rx_task));
rx_task = NULL;
ret = -ECHILD;
mtk_ccci_release_port(mddp_ipc_tty_port_s);
}
return ret;
}
void mddp_ipc_uninit(void)
{
if (rx_task) {
send_sig(SIGTERM, rx_task, 1);
kthread_stop(rx_task);
rx_task = NULL;
mtk_ccci_release_port(mddp_ipc_tty_port_s);
}
}
bool mddp_ipc_rx_msg_validation(enum MDDP_MDFPM_MSG_ID_CODE msg_id,
uint32_t msg_len)
{
uint32_t i;
for (i = 0; i < mddp_rx_msg_table_cnt; i++)
if (mddp_rx_msg_table_s[i].msg_id == msg_id)
return (mddp_rx_msg_table_s[i].rx_msg_len <= msg_len)
? (true) : (false);
return true;
}
+421
View File
@@ -0,0 +1,421 @@
// SPDX-License-Identifier: GPL-2.0
/*
* mddp_sm.c - MDDP state machine.
*
* Copyright (c) 2020 MediaTek Inc.
*/
#include <linux/slab.h>
#include <linux/mutex.h>
#include "mddp_ctrl.h"
#include "mddp_debug.h"
#include "mddp_filter.h"
#include "mddp_sm.h"
#include "mddp_usage.h"
//------------------------------------------------------------------------------
// Struct definition.
// -----------------------------------------------------------------------------
typedef int32_t (*mddp_sm_init_func_t)(struct mddp_app_t *app);
//------------------------------------------------------------------------------
// Global variables.
//------------------------------------------------------------------------------
static const mddp_sm_init_func_t mddp_sm_init_func_list_s[] = {
#undef MDDP_MODULE_ID
#undef MDDP_MODULE_PREFIX
#define MDDP_MODULE_ID(_id)
#define MDDP_MODULE_PREFIX(_prefix) _prefix ## _sm_init,
#include "mddp_app_config.h"
};
//------------------------------------------------------------------------------
// Private helper macro.
//------------------------------------------------------------------------------
#define MDDP_SM_LOCK_FLAG unsigned long flags
#define MDDP_SM_LOCK_INIT(_locker) spin_lock_init(&(_locker))
#define MDDP_SM_LOCK(_locker) spin_lock_irqsave(&(_locker), flags)
#define MDDP_SM_UNLOCK(_locker) spin_unlock_irqrestore(&(_locker), flags)
//------------------------------------------------------------------------------
// Private variables.
//------------------------------------------------------------------------------
static struct mddp_app_t mddp_app_inst_s[MDDP_APP_TYPE_CNT];
static struct mutex mddp_state_handler_mtx;
//------------------------------------------------------------------------------
// Private functions.
//------------------------------------------------------------------------------
static void _mddp_set_state(struct mddp_app_t *app, enum mddp_state_e new_state)
{
MDDP_SM_LOCK_FLAG;
MDDP_SM_LOCK(app->locker);
app->state = new_state;
MDDP_SM_UNLOCK(app->locker);
}
void mddp_check_feature(void)
{
struct mddp_md_msg_t *md_msg;
struct mddp_app_t *app;
md_msg = kzalloc(sizeof(struct mddp_md_msg_t), GFP_ATOMIC);
if (unlikely(!md_msg)) {
MDDP_F_LOG(MDDP_LL_NOTICE,
"%s: failed to alloc md_msg bug!\n", __func__);
return;
}
md_msg->msg_id = IPC_MSG_ID_MDFPM_CHECK_FEATURE_REQ;
md_msg->data_len = 0;
app = mddp_get_app_inst(MDDP_APP_TYPE_WH);
app->abnormal_flags |= MDDP_ABNORMAL_CHECK_FEATURE_ABSENT;
mddp_ipc_send_md(app, md_msg, MDFPM_USER_ID_MDFPM);
}
static void mddp_handshake_done(uint32_t feature)
{
struct mddp_app_t *app;
app = mddp_get_app_inst(MDDP_APP_TYPE_WH);
atomic_set(&app->feature, feature);
app->abnormal_flags &= ~MDDP_ABNORMAL_CHECK_FEATURE_ABSENT;
}
static int32_t mddp_sm_ctrl_msg_hdlr(
uint32_t msg_id,
void *buf,
uint32_t buf_len)
{
int32_t ret = 0;
switch (msg_id) {
case IPC_MSG_ID_MDFPM_CHECK_FEATURE_RSP:
mddp_handshake_done(*(uint32_t *)buf);
break;
default:
MDDP_S_LOG(MDDP_LL_ERR,
"%s: Unaccepted msg_id(%d)!\n",
__func__, msg_id);
ret = -EINVAL;
break;
}
return ret;
}
//------------------------------------------------------------------------------
// Public functions.
//------------------------------------------------------------------------------
int32_t mddp_sm_init(void)
{
struct mddp_app_t *app;
uint32_t type;
uint32_t idx;
memset(&mddp_app_inst_s, 0, sizeof(mddp_app_inst_s));
for (idx = 0; idx < MDDP_MOD_CNT; idx++) {
type = mddp_sm_module_list_s[idx];
app = mddp_get_app_inst(type);
app->type = type;
MDDP_SM_LOCK_INIT(app->locker);
_mddp_set_state(app, MDDP_STATE_UNINIT);
mddp_sm_init_func_list_s[idx](app);
atomic_set(&app->feature, 0);
}
mutex_init(&mddp_state_handler_mtx);
return 0;
}
void mddp_sm_uninit(void)
{
struct mddp_app_t *app;
uint32_t type;
uint32_t idx;
for (idx = 0; idx < MDDP_MOD_CNT; idx++) {
type = mddp_sm_module_list_s[idx];
app = mddp_get_app_inst(type);
mddp_sm_on_event(app, MDDP_EVT_FUNC_DISABLE);
}
memset(mddp_app_inst_s, 0, sizeof(mddp_app_inst_s));
}
struct mddp_app_t *mddp_get_default_app_inst(void)
{
return &mddp_app_inst_s[0];
}
struct mddp_app_t *mddp_get_app_inst(enum mddp_app_type_e type)
{
struct mddp_app_t *app;
app = &mddp_app_inst_s[type];
return app;
}
static enum mddp_state_e mddp_get_state(struct mddp_app_t *app)
{
return app->state;
}
enum mddp_state_e mddp_sm_set_state_by_md_rsp(struct mddp_app_t *app,
enum mddp_state_e prev_state,
bool md_rsp_result)
{
enum mddp_state_e curr_state;
enum mddp_state_e new_state = MDDP_STATE_DUMMY;
enum mddp_event_e event;
complete(&app->md_resp_comp);
curr_state = mddp_get_state(app);
event = (md_rsp_result) ? MDDP_EVT_MD_RSP_OK : MDDP_EVT_MD_RSP_FAIL;
if (curr_state == prev_state) {
/* OK.
* There is no interrupt event from upper module
* when MD handles this request.
*/
new_state = mddp_sm_on_event(app, event);
MDDP_S_LOG(MDDP_LL_NOTICE,
"%s: OK. event(%d), prev_state(%d) -> new_state(%d).\n",
__func__, event, prev_state, new_state);
return new_state;
}
/* DC (Don't Care).
* There are interrupt events from upper module
* when MD handles this request.
*/
MDDP_S_LOG(MDDP_LL_WARN,
"%s: DC. event(%d), prev_state(%d) -> new_state(%d).\n",
__func__, event, prev_state, new_state);
return MDDP_STATE_DUMMY;
}
#ifdef __MDDP_DEBUG__
void mddp_dump_sm_table(struct mddp_app_t *app)
{
uint32_t i, j;
struct mddp_sm_entry_t *state_machine;
struct mddp_sm_entry_t *entry;
MDDP_S_LOG(MDDP_LL_DEBUG,
"\n\n\t%s:\n==============================\n",
__func__);
for (i = 0; i < MDDP_STATE_CNT; i++) {
state_machine = app->state_machines[i];
MDDP_S_LOG(MDDP_LL_DEBUG, "\n=====(%d)=====\n", i);
for (j = 0; j < MDDP_EVT_CNT; j++) {
entry = state_machine + j;
if (entry->event == MDDP_EVT_DUMMY)
break;
MDDP_S_LOG(MDDP_LL_DEBUG,
"\tevt(%d), new_state(%d)\n",
entry->event, entry->new_state);
}
}
MDDP_S_LOG(MDDP_LL_DEBUG,
"\n ==============================\n\n");
}
#endif
enum mddp_state_e mddp_sm_on_event(struct mddp_app_t *app,
enum mddp_event_e event)
{
uint32_t idx;
enum mddp_state_e old_state;
enum mddp_state_e new_state;
struct mddp_sm_entry_t *state_machine;
struct mddp_sm_entry_t *entry;
mutex_lock(&mddp_state_handler_mtx);
new_state = old_state = mddp_get_state(app);
state_machine = app->state_machines[old_state];
for (idx = 0; idx < MDDP_EVT_CNT; idx++) {
entry = state_machine + idx;
if (event == entry->event) {
/*
* OK. Valid event for this state.
*/
new_state = entry->new_state;
if (new_state != MDDP_STATE_DUMMY)
_mddp_set_state(app, new_state);
mddp_dump_sm_table(app);
MDDP_S_LOG(MDDP_LL_WARN,
"%s: event(%d), old_state(%d) -> new_state(%d).\n",
__func__, event, old_state, new_state);
if (entry->action)
entry->action(app);
break;
} else if (entry->event == MDDP_EVT_DUMMY) {
/*
* NG. Unexpected event for this state!
*/
MDDP_S_LOG(MDDP_LL_WARN,
"%s: Invalid event(%d) for current state(%d)!\n",
__func__, event, old_state);
break;
}
}
mutex_unlock(&mddp_state_handler_mtx);
return new_state;
}
void mddp_sm_wait_pre(struct mddp_app_t *app)
{
init_completion(&app->md_resp_comp);
}
void mddp_sm_wait(struct mddp_app_t *app, enum mddp_event_e event)
{
enum mddp_state_e state;
state = mddp_get_state(app);
if ((state == MDDP_STATE_DISABLED) && (event != MDDP_EVT_FUNC_ENABLE))
return;
if ((state == MDDP_STATE_DEACTIVATED) && (event == MDDP_EVT_FUNC_DEACT))
return;
if (wait_for_completion_timeout(&app->md_resp_comp, msecs_to_jiffies(150)) == 0)
mddp_sm_on_event(app, MDDP_EVT_MD_RSP_TIMEOUT);
}
int32_t mddp_sm_msg_hdlr(
uint32_t user_id,
uint32_t msg_id,
void *buf,
uint32_t buf_len)
{
struct mddp_app_t *app = NULL;
int32_t ret = -ENODEV;
switch (user_id) {
case MDFPM_USER_ID_MDFPM:
ret = mddp_sm_ctrl_msg_hdlr(msg_id, buf, buf_len);
goto _done;
case MDFPM_USER_ID_WFPM:
app = mddp_get_app_inst(MDDP_APP_TYPE_WH);
break;
case MDFPM_USER_ID_DPFM:
ret = mddp_f_msg_hdlr(msg_id, buf, buf_len);
if (ret)
ret = mddp_u_msg_hdlr(msg_id, buf, buf_len);
goto _done;
default:
/*
* NG. Receive invalid ctrl_msg!
*/
MDDP_S_LOG(MDDP_LL_WARN,
"%s: Unaccepted user_id(%d)!\n",
__func__, user_id);
ret = -EINVAL;
goto _done;
}
/*
* OK. This app_type is configured.
*/
if (app && app->is_config) {
ret = app->md_recv_msg_hdlr(msg_id, buf, buf_len);
goto _done;
}
/*
* NG. This app_type is not configured!
*/
MDDP_S_LOG(MDDP_LL_ERR,
"%s: app is not configured, app(%p), user_id(%d), msg_id(%d)!\n",
__func__, app, user_id, msg_id);
_done:
return ret;
}
int32_t mddp_sm_reg_callback(
struct mddp_drv_conf_t *conf,
struct mddp_drv_handle_t *handle)
{
struct mddp_app_t *app;
app = mddp_get_app_inst(conf->app_type);
/*
* OK. This app_type is configured.
*/
if (app->is_config && app->reg_drv_callback) {
app->reg_drv_callback(handle);
memcpy(&app->drv_hdlr,
handle, sizeof(struct mddp_drv_handle_t));
app->drv_reg = 1;
app->abnormal_flags &= ~MDDP_ABNORMAL_WIFI_DRV_GET_FEATURE_BEFORE_MD_READY;
return 0;
}
/*
* NG. MDDP is not ready!
*/
MDDP_S_LOG(MDDP_LL_ERR,
"%s: Failed to reg callback, type(%d), config(%d)!\n",
__func__, conf->app_type, app->is_config);
return -EPERM;
}
void mddp_sm_dereg_callback(
struct mddp_drv_conf_t *conf,
struct mddp_drv_handle_t *handle)
{
struct mddp_app_t *app;
app = mddp_get_app_inst(conf->app_type);
/*
* OK. This app_type is configured.
*/
if (app->is_config && app->dereg_drv_callback) {
app->dereg_drv_callback(handle);
memset(&app->drv_hdlr,
0, sizeof(struct mddp_drv_handle_t));
app->drv_reg = 0;
return;
}
/*
* NG. MDDP is not ready!
*/
MDDP_S_LOG(MDDP_LL_ERR,
"%s: Failed to dereg callback, type(%d), config(%d)!\n",
__func__, conf->app_type, app->is_config);
return;
}
+162
View File
@@ -0,0 +1,162 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* mddp_sm.h - Structure/API provided by MDDP state machine.
*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifndef __MDDP_SM_H
#define __MDDP_SM_H
#include <linux/completion.h>
#include <linux/workqueue.h>
#include "mddp_export.h"
#include "mddp_ipc.h"
#define MDDP_ABNORMAL_CCCI_SEND_FAILED (1U << 0)
#define MDDP_ABNORMAL_CHECK_FEATURE_ABSENT (1U << 1)
#define MDDP_ABNORMAL_WIFI_DRV_GET_FEATURE_BEFORE_MD_READY (1U << 2)
//------------------------------------------------------------------------------
// Struct definition.
// -----------------------------------------------------------------------------
/*!
* Event for MDDP state machine.
*/
enum mddp_event_e {
MDDP_EVT_FUNC_ENABLE, /**< Enable MDDP. */
MDDP_EVT_FUNC_DISABLE, /**< Disable MDDP. */
MDDP_EVT_FUNC_ACT, /**< Activate MDDP. */
MDDP_EVT_FUNC_DEACT, /**< Deactivate MDDP. */
MDDP_EVT_MD_RSP_OK, /**< MD Response OK. */
MDDP_EVT_MD_RSP_FAIL, /**< MD Response FAIL. */
MDDP_EVT_MD_RSP_TIMEOUT, /**<MD Response timeout. */
MDDP_EVT_MD_RESET, /**<MD send RESET. */
MDDP_EVT_CNT,
MDDP_EVT_DUMMY = 0x7fff /* Make it a 2-byte enum */
};
enum mddp_sysfs_cmd_e {
MDDP_SYSFS_CMD_ENABLE_READ, /* User read ENABLE sysfs */
MDDP_SYSFS_CMD_ENABLE_WRITE, /* User write ENABLE sysfs */
MDDP_SYSFS_CMD_STATISTIC_READ, /* User read STATISTIC sysfs */
#ifdef MDDP_EM_SUPPORT
MDDP_SYSFS_EM_CMD_TEST_READ,
MDDP_SYSFS_EM_CMD_TEST_WRITE,
#endif
};
/*!
* Structure of state machine entry.
*/
struct mddp_app_t;
typedef void (*mddp_sm_action_t)(struct mddp_app_t *);
typedef int32_t (*mddp_md_recv_msg_hdlr_t)(uint32_t msg_id,
void *buf, uint32_t buf_len);
typedef int32_t (*mddp_reg_drv_cbf_t)(struct mddp_drv_handle_t *);
typedef ssize_t (*mddp_sysfs_cbf_t)(struct mddp_app_t *app,
enum mddp_sysfs_cmd_e,
char *buf, size_t buf_len);
struct mddp_sm_entry_t {
enum mddp_event_e event;
enum mddp_state_e new_state;
mddp_sm_action_t action;
};
struct mddp_ap_cfg_t {
uint8_t ul_dev_name[IFNAMSIZ];
uint8_t dl_dev_name[IFNAMSIZ];
};
struct mddp_md_cfg_t {
uint32_t ipc_ap_mod_id;
enum mdfpm_user_id_e ipc_md_user_id;
};
/*!
* MDDP application structure.
*/
struct mddp_app_t {
uint32_t is_config; /**< app is configured or not. */
enum mddp_app_type_e type; /**< app type. */
enum mddp_state_e state; /**< app status. */
spinlock_t locker; /**< spin locker. */
struct mddp_ap_cfg_t ap_cfg; /**< AP config. */
struct mddp_md_cfg_t md_cfg; /**< MD config. */
mddp_md_recv_msg_hdlr_t md_recv_msg_hdlr; /**< Recv msg from MD. */
mddp_reg_drv_cbf_t reg_drv_callback; /**< Register callback. */
mddp_reg_drv_cbf_t dereg_drv_callback; /**< DeReg callback. */
struct mddp_drv_handle_t drv_hdlr; /**< Driver handler. */
mddp_sysfs_cbf_t sysfs_callback; /**< Sysfs callback. */
struct mddp_sm_entry_t *state_machines[MDDP_STATE_CNT];
uint32_t drv_reg;
atomic_t feature;
uint32_t abnormal_flags;
uint32_t reset_cnt;
struct completion md_resp_comp;
};
//------------------------------------------------------------------------------
// Constant variable.
// -----------------------------------------------------------------------------
typedef uint16_t MDDP_MOD_TYPE;
static const MDDP_MOD_TYPE mddp_sm_module_list_s[] = {
#undef MDDP_MODULE_ID
#undef MDDP_MODULE_PREFIX
#define MDDP_MODULE_ID(_id) _id,
#define MDDP_MODULE_PREFIX(_prefix)
#include "mddp_app_config.h"
};
//------------------------------------------------------------------------------
// Helper macro.
// -----------------------------------------------------------------------------
#define MDDP_MOD_CNT (sizeof(mddp_sm_module_list_s) / sizeof(MDDP_MOD_TYPE))
//------------------------------------------------------------------------------
// External functions.
// -----------------------------------------------------------------------------
int32_t mddpu_sm_init(struct mddp_app_t *app);
int32_t mddpwh_sm_init(struct mddp_app_t *app);
//------------------------------------------------------------------------------
// Public functions.
// -----------------------------------------------------------------------------
int32_t mddp_sm_init(void);
void mddp_sm_uninit(void);
struct mddp_app_t *mddp_get_default_app_inst(void);
enum mddp_state_e mddp_sm_set_state_by_md_rsp(struct mddp_app_t *app,
enum mddp_state_e new_state, bool md_rsp_result);
#ifdef __MDDP_DEBUG__
void mddp_dump_sm_table(struct mddp_app_t *app);
#else
#define mddp_dump_sm_table(...)
#endif
enum mddp_state_e mddp_sm_on_event(struct mddp_app_t *app, enum mddp_event_e event);
void mddp_sm_wait_pre(struct mddp_app_t *app);
void mddp_sm_wait(struct mddp_app_t *app, enum mddp_event_e event);
void mddp_check_feature(void);
int32_t mddp_sm_msg_hdlr(uint32_t user_id,
uint32_t msg_id, void *buf, uint32_t buf_len);
int32_t mddp_sm_reg_callback(
struct mddp_drv_conf_t *conf,
struct mddp_drv_handle_t *handle);
void mddp_sm_dereg_callback(
struct mddp_drv_conf_t *conf,
struct mddp_drv_handle_t *handle);
void mddp_netdev_notifier_exit(void);
#endif /* __MDDP_SM_H */
+935
View File
@@ -0,0 +1,935 @@
// SPDX-License-Identifier: GPL-2.0
/*
* mddpwh_sm.c - MDDPWH (WiFi Hotspot) state machine.
*
* Copyright (c) 2020 MediaTek Inc.
*/
#include <linux/slab.h>
#include <linux/delay.h>
#include "mddp_ctrl.h"
#include "mddp_debug.h"
#include "mddp_dev.h"
#include "mddp_filter.h"
#include "mddp_sm.h"
#define MDDP_RESET_READY_TIME_MS (100)
static struct work_struct wfpm_reset_work;
static struct work_struct md_rsp_fail_work;
//------------------------------------------------------------------------------
// Struct definition.
// -----------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Global variables.
//------------------------------------------------------------------------------
static struct wfpm_deactivate_md_func_rsp_t deact_rsp_metadata_s;
//------------------------------------------------------------------------------
// Private variables.
//------------------------------------------------------------------------------
static struct mddp_md_cfg_t mddpw_md_cfg_s = {
MDFPM_AP_USER_ID,
MDFPM_USER_ID_WFPM,
};
//------------------------------------------------------------------------------
// Private helper macro.
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Private functions.
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// External functions.
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Public functions - MDDPWH (WiFi) state machine functions
//------------------------------------------------------------------------------
static void mddpwh_sm_enable(struct mddp_app_t *app)
{
struct mddp_md_msg_t *md_msg;
struct wfpm_enable_md_func_req_t *enable_req;
struct wfpm_smem_info_t *smem_info;
uint32_t smem_num;
// 1. Send ENABLE to WiFi
if (app->drv_hdlr.change_state != NULL)
app->drv_hdlr.change_state(MDDP_STATE_ENABLING, NULL, NULL);
// 2. Send ENABLE to MD
if (wfpm_ipc_get_smem_list((void **)&smem_info, &smem_num)) {
MDDP_S_LOG(MDDP_LL_NOTICE,
"%s: Failed to get smem info!\n", __func__);
smem_num = 0;
}
md_msg = kzalloc(sizeof(struct mddp_md_msg_t) +
sizeof(struct wfpm_enable_md_func_req_t) +
smem_num * sizeof(struct wfpm_smem_info_t), GFP_ATOMIC);
if (unlikely(!md_msg)) {
return;
}
md_msg->msg_id = IPC_MSG_ID_WFPM_ENABLE_MD_FAST_PATH_REQ;
md_msg->data_len = sizeof(struct wfpm_enable_md_func_req_t) +
smem_num * sizeof(struct wfpm_smem_info_t);
enable_req = (struct wfpm_enable_md_func_req_t *)&(md_msg->data);
enable_req->mode = WFPM_FUNC_MODE_TETHER;
enable_req->version = __MDDP_VERSION__;
enable_req->smem_num = smem_num;
memcpy(&(enable_req->smem_info), smem_info,
smem_num * sizeof(struct wfpm_smem_info_t));
mddp_ipc_send_md(app, md_msg, MDFPM_USER_ID_NULL);
}
static void mddpwh_sm_rsp_enable_ok(struct mddp_app_t *app)
{
struct mddp_dev_rsp_enable_t enable = {0};
atomic_or(MDDP_FEATURE_MDDP_WH, &app->feature);
// 1. Send RSP to WiFi
if (app->drv_hdlr.change_state != NULL)
app->drv_hdlr.change_state(app->state, NULL, NULL);
// 2. Send RSP to upper module.
mddp_dev_response(app->type, MDDP_CMCMD_ENABLE_RSP,
true, (uint8_t *)&enable, sizeof(enable));
}
static void mddpwh_sm_rsp_enable_fail(struct mddp_app_t *app)
{
struct mddp_dev_rsp_enable_t enable = {0};
// 1. Send RSP to WiFi
if (app->drv_hdlr.change_state != NULL)
app->drv_hdlr.change_state(app->state, NULL, NULL);
// 2. Send RSP to upper module.
mddp_dev_response(app->type, MDDP_CMCMD_ENABLE_RSP,
false, (uint8_t *)&enable, sizeof(enable));
}
static void mddpwh_sm_disable(struct mddp_app_t *app)
{
struct mddp_md_msg_t *md_msg;
struct wfpm_md_fast_path_common_req_t *disable_req;
// 1. Send DISABLE to WiFi
if (app->drv_hdlr.change_state != NULL)
app->drv_hdlr.change_state(MDDP_STATE_DISABLING, NULL, NULL);
// 2. Send DISABLE to MD
md_msg = kzalloc(sizeof(struct mddp_md_msg_t) +
sizeof(struct wfpm_md_fast_path_common_req_t),
GFP_ATOMIC);
if (unlikely(!md_msg)) {
MDDP_S_LOG(MDDP_LL_ERR,
"%s: Failed to alloc md_msg bug!\n", __func__);
return;
}
disable_req = (struct wfpm_md_fast_path_common_req_t *)&(md_msg->data);
disable_req->mode = WFPM_FUNC_MODE_TETHER;
md_msg->msg_id = IPC_MSG_ID_WFPM_DISABLE_MD_FAST_PATH_REQ;
md_msg->data_len = sizeof(struct wfpm_md_fast_path_common_req_t);
mddp_ipc_send_md(app, md_msg, MDFPM_USER_ID_NULL);
}
static void mddpwh_sm_rsp_disable(struct mddp_app_t *app)
{
// 1. Send RSP to WiFi
if (app->drv_hdlr.change_state != NULL)
app->drv_hdlr.change_state(app->state, NULL, NULL);
// 2. NO NEED to send RSP to upper module.
}
static void mddpwh_sm_act(struct mddp_app_t *app)
{
struct mddp_md_msg_t *md_msg;
struct wfpm_activate_md_func_req_t *act_req;
// 2. Send ACTIVATING to WiFi
if (app->drv_hdlr.change_state != NULL)
app->drv_hdlr.change_state(MDDP_STATE_ACTIVATING, NULL, NULL);
// 3. Send ACTIVATING to MD
md_msg = kzalloc(sizeof(struct mddp_md_msg_t) +
sizeof(struct wfpm_activate_md_func_req_t), GFP_ATOMIC);
if (unlikely(!md_msg)) {
return;
}
act_req = (struct wfpm_activate_md_func_req_t *)&(md_msg->data);
act_req->mode = WFPM_FUNC_MODE_TETHER;
md_msg->msg_id = IPC_MSG_ID_WFPM_ACTIVATE_MD_FAST_PATH_REQ;
md_msg->data_len = sizeof(struct wfpm_activate_md_func_req_t);
mddp_ipc_send_md(app, md_msg, MDFPM_USER_ID_NULL);
}
static void mddpwh_sm_rsp_act_ok(struct mddp_app_t *app)
{
struct mddp_dev_rsp_act_t act = {0};
// 1. Send RSP to WiFi
if (app->drv_hdlr.change_state != NULL)
app->drv_hdlr.change_state(app->state, NULL, NULL);
// 2. Send RSP to upper module.
mddp_dev_response(app->type, MDDP_CMCMD_ACT_RSP,
true, (uint8_t *)&act, sizeof(act));
mddp_netfilter_hook();
}
static void mddpwh_sm_deact(struct mddp_app_t *app)
{
struct mddp_md_msg_t *md_msg;
struct wfpm_activate_md_func_req_t *deact_req;
// 1. Send ACTIVATING to WiFi
if (app->drv_hdlr.change_state != NULL)
app->drv_hdlr.change_state(MDDP_STATE_DEACTIVATING, NULL, NULL);
// 2. Send ACTIVATING to MD
md_msg = kzalloc(sizeof(struct mddp_md_msg_t) +
sizeof(struct wfpm_activate_md_func_req_t), GFP_ATOMIC);
if (unlikely(!md_msg)) {
return;
}
deact_req = (struct wfpm_activate_md_func_req_t *)&(md_msg->data);
deact_req->mode = WFPM_FUNC_MODE_TETHER;
md_msg->msg_id = IPC_MSG_ID_WFPM_DEACTIVATE_MD_FAST_PATH_REQ;
md_msg->data_len = sizeof(struct wfpm_activate_md_func_req_t);
if (mddp_ipc_send_md(app, md_msg, MDFPM_USER_ID_NULL) < 0)
schedule_work(&md_rsp_fail_work);
}
static void mddpwh_sm_rsp_deact(struct mddp_app_t *app)
{
struct mddp_dev_rsp_deact_t deact = {0};
mddp_netfilter_unhook();
mddp_f_dev_del_wan_dev(app->ap_cfg.ul_dev_name);
mddp_f_dev_del_lan_dev(app->ap_cfg.dl_dev_name);
// 2. Send RSP to WiFi
if (app->drv_hdlr.change_state != NULL)
app->drv_hdlr.change_state(app->state, NULL, NULL);
// 3. Send RSP to upper module.
mddp_dev_response(app->type, MDDP_CMCMD_DEACT_RSP,
true, (uint8_t *)&deact, sizeof(deact));
}
static void mddpwh_sm_md_reset(struct mddp_app_t *app)
{
schedule_work(&wfpm_reset_work);
}
static void mddpwh_sm_dummy_act(struct mddp_app_t *app)
{
mddp_netdev_notifier_exit();
mddp_f_dev_del_wan_dev(app->ap_cfg.ul_dev_name);
mddp_f_dev_del_lan_dev(app->ap_cfg.dl_dev_name);
}
//------------------------------------------------------------------------------
// MDDPWH State machine.
//------------------------------------------------------------------------------
static struct mddp_sm_entry_t mddpwh_uninit_state_machine_s[] = {
/* event new_state action */
{MDDP_EVT_MD_RESET, MDDP_STATE_DISABLED, mddpwh_sm_md_reset},
{MDDP_EVT_FUNC_ENABLE, MDDP_STATE_UNINIT, NULL},
{MDDP_EVT_FUNC_DISABLE, MDDP_STATE_UNINIT, NULL},
{MDDP_EVT_FUNC_ACT, MDDP_STATE_UNINIT, NULL},
{MDDP_EVT_FUNC_DEACT, MDDP_STATE_UNINIT, NULL},
{MDDP_EVT_DUMMY, MDDP_STATE_UNINIT, NULL} /* End of SM. */
};
static struct mddp_sm_entry_t mddpwh_disabled_state_machine_s[] = {
/* event new_state action */
{MDDP_EVT_MD_RESET, MDDP_STATE_DISABLED, mddpwh_sm_md_reset},
{MDDP_EVT_FUNC_ENABLE, MDDP_STATE_ENABLING, mddpwh_sm_enable},
{MDDP_EVT_FUNC_DISABLE, MDDP_STATE_DISABLED, NULL},
{MDDP_EVT_FUNC_ACT, MDDP_STATE_DISABLED, mddpwh_sm_dummy_act},
{MDDP_EVT_FUNC_DEACT, MDDP_STATE_DISABLED, NULL},
{MDDP_EVT_MD_RSP_OK, MDDP_STATE_DISABLED, NULL},
{MDDP_EVT_MD_RSP_FAIL, MDDP_STATE_DISABLED, NULL},
{MDDP_EVT_DUMMY, MDDP_STATE_DISABLED, NULL} /* End of SM. */
};
static struct mddp_sm_entry_t mddpwh_enabling_state_machine_s[] = {
/* event new_state action */
{MDDP_EVT_MD_RESET, MDDP_STATE_DISABLED, mddpwh_sm_md_reset},
{MDDP_EVT_MD_RSP_OK, MDDP_STATE_DEACTIVATED, mddpwh_sm_rsp_enable_ok},
{MDDP_EVT_MD_RSP_FAIL, MDDP_STATE_DISABLED, mddpwh_sm_rsp_enable_fail},
{MDDP_EVT_MD_RSP_TIMEOUT, MDDP_STATE_DISABLED, mddpwh_sm_rsp_enable_fail},
{MDDP_EVT_DUMMY, MDDP_STATE_ENABLING, NULL} /* End of SM. */
};
static struct mddp_sm_entry_t mddpwh_disabling_state_machine_s[] = {
/* event new_state action */
{MDDP_EVT_MD_RESET, MDDP_STATE_DISABLED, mddpwh_sm_md_reset},
{MDDP_EVT_MD_RSP_OK, MDDP_STATE_DISABLED, mddpwh_sm_rsp_disable},
{MDDP_EVT_MD_RSP_FAIL, MDDP_STATE_DISABLED, NULL},
{MDDP_EVT_MD_RSP_TIMEOUT, MDDP_STATE_DISABLED, mddpwh_sm_rsp_disable},
{MDDP_EVT_DUMMY, MDDP_STATE_DISABLING, NULL} /* End of SM. */
};
static struct mddp_sm_entry_t mddpwh_deactivated_state_machine_s[] = {
/* event new_state action */
{MDDP_EVT_MD_RESET, MDDP_STATE_DEACTIVATED, mddpwh_sm_md_reset},
{MDDP_EVT_FUNC_ENABLE, MDDP_STATE_ENABLING, mddpwh_sm_enable},
{MDDP_EVT_FUNC_DISABLE, MDDP_STATE_DISABLING, mddpwh_sm_disable},
{MDDP_EVT_FUNC_ACT, MDDP_STATE_ACTIVATING, mddpwh_sm_act},
{MDDP_EVT_FUNC_DEACT, MDDP_STATE_DEACTIVATED, NULL},
{MDDP_EVT_MD_RSP_OK, MDDP_STATE_DEACTIVATED, NULL},
{MDDP_EVT_MD_RSP_FAIL, MDDP_STATE_DEACTIVATED, NULL},
{MDDP_EVT_DUMMY, MDDP_STATE_DEACTIVATED, NULL} /* End of SM. */
};
static struct mddp_sm_entry_t mddpwh_activating_state_machine_s[] = {
/* event new_state action */
{MDDP_EVT_MD_RESET, MDDP_STATE_DEACTIVATED, mddpwh_sm_md_reset},
{MDDP_EVT_FUNC_DEACT, MDDP_STATE_DEACTIVATING, mddpwh_sm_deact},
{MDDP_EVT_MD_RSP_OK, MDDP_STATE_ACTIVATED, mddpwh_sm_rsp_act_ok},
{MDDP_EVT_MD_RSP_FAIL, MDDP_STATE_ACTIVATED, NULL},
{MDDP_EVT_MD_RSP_TIMEOUT, MDDP_STATE_ACTIVATED, mddpwh_sm_rsp_act_ok},
{MDDP_EVT_DUMMY, MDDP_STATE_ACTIVATING, NULL} /* End of SM. */
};
static struct mddp_sm_entry_t mddpwh_activated_state_machine_s[] = {
/* event new_state action */
{MDDP_EVT_MD_RESET, MDDP_STATE_ACTIVATED, mddpwh_sm_md_reset},
{MDDP_EVT_FUNC_ENABLE, MDDP_STATE_ENABLING, mddpwh_sm_enable},
{MDDP_EVT_FUNC_DISABLE, MDDP_STATE_DISABLING, mddpwh_sm_disable},
{MDDP_EVT_FUNC_DEACT, MDDP_STATE_DEACTIVATING, mddpwh_sm_deact},
{MDDP_EVT_MD_RSP_OK, MDDP_STATE_ACTIVATED, NULL},
{MDDP_EVT_MD_RSP_FAIL, MDDP_STATE_ACTIVATED, NULL},
{MDDP_EVT_DUMMY, MDDP_STATE_ACTIVATED, NULL} /* End of SM. */
};
static struct mddp_sm_entry_t mddpwh_deactivating_state_machine_s[] = {
/* event new_state action */
{MDDP_EVT_MD_RESET, MDDP_STATE_DEACTIVATED, mddpwh_sm_md_reset},
{MDDP_EVT_FUNC_ACT, MDDP_STATE_ACTIVATING, mddpwh_sm_act},
{MDDP_EVT_FUNC_DEACT, MDDP_STATE_DEACTIVATING, NULL},
{MDDP_EVT_MD_RSP_OK, MDDP_STATE_DEACTIVATED, mddpwh_sm_rsp_deact},
{MDDP_EVT_MD_RSP_FAIL, MDDP_STATE_DEACTIVATED, mddpwh_sm_rsp_deact},
{MDDP_EVT_MD_RSP_TIMEOUT, MDDP_STATE_DEACTIVATED, mddpwh_sm_rsp_deact},
{MDDP_EVT_DUMMY, MDDP_STATE_DEACTIVATING, NULL} /* End of SM. */
};
static struct mddp_sm_entry_t mddpwh_dead_state_machine_s[] = {
/* event new_state action */
{MDDP_EVT_FUNC_ENABLE, MDDP_STATE_DISABLED, NULL},
{MDDP_EVT_FUNC_DISABLE, MDDP_STATE_DISABLED, NULL},
{MDDP_EVT_FUNC_ACT, MDDP_STATE_DISABLED, NULL},
{MDDP_EVT_FUNC_DEACT, MDDP_STATE_DISABLED, NULL},
{MDDP_EVT_DUMMY, MDDP_STATE_DISABLED, NULL} /* End of SM. */
};
struct mddp_sm_entry_t *mddpwh_state_machines_s[MDDP_STATE_CNT] = {
mddpwh_uninit_state_machine_s, /* UNINIT */
mddpwh_enabling_state_machine_s, /* ENABLING */
mddpwh_deactivated_state_machine_s, /* DEACTIVATED */
mddpwh_activating_state_machine_s, /* ACTIVATING */
mddpwh_activated_state_machine_s, /* ACTIVATED */
mddpwh_deactivating_state_machine_s, /* DEACTIVATING */
mddpwh_disabling_state_machine_s, /* DISABLING */
mddpwh_disabled_state_machine_s, /* DISABLED */
};
//------------------------------------------------------------------------------
// Public functions.
//------------------------------------------------------------------------------
static void mddpw_wfpm_send_smem_layout(void)
{
struct mddp_app_t *app;
struct mddp_md_msg_t *md_msg;
struct mddpw_md_notify_info_t md_info;
struct wfpm_enable_md_func_req_t *enable_req;
struct wfpm_smem_info_t *smem_info;
uint32_t smem_num;
app = mddp_get_app_inst(MDDP_APP_TYPE_WH);
if (!app->is_config) {
MDDP_S_LOG(MDDP_LL_ERR,
"%s: app_type(MDDP_APP_TYPE_WH) not configured!\n",
__func__);
return;
}
// 2. Send SMEM_LAYOUT to MD
if (wfpm_ipc_get_smem_list((void **)&smem_info, &smem_num)) {
MDDP_S_LOG(MDDP_LL_NOTICE,
"%s: Failed to get smem info!\n",
__func__);
smem_num = 0;
}
MDDP_S_LOG(MDDP_LL_INFO,
"%s: smem_info(%llx), smem_num(%u)\n",
__func__, (unsigned long long)smem_info, smem_num);
md_msg = kzalloc(sizeof(struct mddp_md_msg_t) +
sizeof(struct wfpm_enable_md_func_req_t) +
smem_num * sizeof(struct wfpm_smem_info_t),
GFP_ATOMIC);
if (unlikely(!md_msg)) {
return;
}
md_msg->msg_id = IPC_MSG_ID_WFPM_SEND_SMEM_LAYOUT_NOTIFY;
md_msg->data_len = sizeof(struct wfpm_enable_md_func_req_t) +
smem_num * sizeof(struct wfpm_smem_info_t);
enable_req = (struct wfpm_enable_md_func_req_t *)
&(md_msg->data);
enable_req->mode = WFPM_FUNC_MODE_TETHER;
enable_req->version = __MDDP_VERSION__;
enable_req->smem_num = smem_num;
memcpy(&(enable_req->smem_info), smem_info,
smem_num * sizeof(struct wfpm_smem_info_t));
mddp_ipc_send_md(app, md_msg, MDFPM_USER_ID_NULL);
if (app->drv_hdlr.wifi_handle != NULL) {
struct mddpw_drv_handle_t *wifi_handle =
app->drv_hdlr.wifi_handle;
if (wifi_handle->notify_md_info != NULL) {
md_info.version = 0;
md_info.info_type = 1;
md_info.buf_len = 0;
wifi_handle->notify_md_info(&md_info);
}
}
}
static int32_t mddpw_wfpm_msg_hdlr(uint32_t msg_id, void *buf, uint32_t buf_len)
{
struct mddp_app_t *app;
struct wfpm_md_fast_path_common_rsp_t *rsp;
struct wfpm_enable_md_func_rsp_t *enable_rsp;
struct mddpw_md_notify_info_t *md_info;
// NG. The length of rx_msg is incorrect!
if (!mddp_ipc_rx_msg_validation(msg_id, buf_len))
return -EINVAL;
rsp = (struct wfpm_md_fast_path_common_rsp_t *) buf;
app = mddp_get_app_inst(MDDP_APP_TYPE_WH);
switch (msg_id) {
case IPC_MSG_ID_WFPM_ENABLE_MD_FAST_PATH_RSP:
enable_rsp = (struct wfpm_enable_md_func_rsp_t *) buf;
MDDP_S_LOG(MDDP_LL_INFO,
"%s: set (%u), (%u), MD version(%u), (%u).\n",
__func__, enable_rsp->mode, enable_rsp->result,
enable_rsp->version, enable_rsp->reserved);
if (rsp->result) {
/* ENABLE OK. */
MDDP_S_LOG(MDDP_LL_INFO,
"%s: ENABLE RSP OK, result(%d).\n",
__func__, rsp->result);
mddp_sm_set_state_by_md_rsp(app,
MDDP_STATE_ENABLING, true);
} else {
/* ENABLE FAIL. */
MDDP_S_LOG(MDDP_LL_NOTICE,
"%s: ENABLE RSP FAIL, result(%d)!\n",
__func__, rsp->result);
mddp_sm_set_state_by_md_rsp(app,
MDDP_STATE_ENABLING, false);
}
break;
case IPC_MSG_ID_WFPM_DISABLE_MD_FAST_PATH_RSP:
if (rsp->result) {
/* DISABLE OK. */
MDDP_S_LOG(MDDP_LL_INFO,
"%s: DISABLE RSP OK, result(%d).\n",
__func__, rsp->result);
mddp_sm_set_state_by_md_rsp(app,
MDDP_STATE_DISABLING, true);
} else {
/* DISABLE FAIL. */
MDDP_S_LOG(MDDP_LL_NOTICE,
"%s: DISABLE RSP FAIL, result(%d)!\n",
__func__, rsp->result);
mddp_sm_set_state_by_md_rsp(app,
MDDP_STATE_DISABLING, false);
}
break;
case IPC_MSG_ID_WFPM_ACTIVATE_MD_FAST_PATH_RSP:
if (rsp->result) {
/* ACT OK. */
MDDP_S_LOG(MDDP_LL_INFO,
"%s: ACT RSP OK, result(%d).\n",
__func__, rsp->result);
mddp_sm_set_state_by_md_rsp(app,
MDDP_STATE_ACTIVATING, true);
} else {
/* ACT FAIL. */
MDDP_S_LOG(MDDP_LL_NOTICE,
"%s: ACT RSP FAIL, result(%d)!\n",
__func__, rsp->result);
mddp_sm_set_state_by_md_rsp(app,
MDDP_STATE_ACTIVATING, false);
}
break;
case IPC_MSG_ID_WFPM_DEACTIVATE_MD_FAST_PATH_RSP:
if (rsp->result) {
/* DEACT OK. */
MDDP_S_LOG(MDDP_LL_INFO,
"%s: DEACT RSP OK, result(%d)\n",
__func__, rsp->result);
mddp_sm_set_state_by_md_rsp(app,
MDDP_STATE_DEACTIVATING, true);
memcpy(&deact_rsp_metadata_s,
buf,
sizeof(deact_rsp_metadata_s));
} else {
/* DEACT FAIL. */
MDDP_S_LOG(MDDP_LL_NOTICE,
"%s: DEACT RSP FAIL, result(%d)\n",
__func__, rsp->result);
mddp_sm_set_state_by_md_rsp(app,
MDDP_STATE_DEACTIVATING, false);
memcpy(&deact_rsp_metadata_s,
buf,
sizeof(deact_rsp_metadata_s));
}
break;
case IPC_MSG_ID_WFPM_RESET_IND:
MDDP_S_LOG(MDDP_LL_WARN,
"%s: Received WFPM RESET IND\n", __func__);
msleep(MDDP_RESET_READY_TIME_MS);
mddp_sm_on_event(app, MDDP_EVT_MD_RESET);
break;
case IPC_MSG_ID_WFPM_MD_NOTIFY:
MDDP_S_LOG(MDDP_LL_DEBUG,
"%s: Received WFPM MD NOTIFY\n", __func__);
md_info = (struct mddpw_md_notify_info_t *) buf;
if (app->drv_hdlr.wifi_handle != NULL)
if (app->drv_hdlr.wifi_handle->notify_md_info) {
MDDP_S_LOG(MDDP_LL_NOTICE,
"%s: MD NOTIFY info_type[%d] len[%d]\n",
__func__, md_info->info_type,
md_info->buf_len);
app->drv_hdlr.wifi_handle->notify_md_info(
md_info);
}
break;
default:
MDDP_S_LOG(MDDP_LL_NOTICE,
"%s: Unsupported RSP MSG_ID[%d] from WFPM.\n",
__func__, msg_id);
break;
}
return 0;
}
static int32_t mddpw_drv_add_txd(struct mddpw_txd_t *txd)
{
struct mddp_md_msg_t *md_msg;
struct mddp_app_t *app;
// Send TXD to MD
app = mddp_get_app_inst(MDDP_APP_TYPE_WH);
if (!app->is_config) {
MDDP_S_LOG(MDDP_LL_ERR,
"%s: app_type(MDDP_APP_TYPE_WH) not configured!\n",
__func__);
return -ENODEV;
}
md_msg = kzalloc(sizeof(struct mddp_md_msg_t) +
sizeof(struct mddpw_txd_t) + txd->txd_length, GFP_ATOMIC);
if (unlikely(!md_msg)) {
return -ENOMEM;
}
md_msg->msg_id = IPC_MSG_ID_WFPM_SEND_MD_TXD_NOTIFY;
md_msg->data_len = sizeof(struct mddpw_txd_t) + txd->txd_length;
memcpy(md_msg->data, txd, md_msg->data_len);
mddp_ipc_send_md(app, md_msg, MDFPM_USER_ID_NULL);
return 0;
}
static int32_t mddpw_drv_get_net_stat(struct mddpw_net_stat_t *usage)
{
// Use global variable to cache previous statistics,
// and return delta value each call.
static struct mddpw_net_stat_t cur_stats = {0};
struct mddpw_net_stat_t *md_stats;
uint8_t smem_attr;
uint32_t smem_size;
if (!usage) {
MDDP_S_LOG(MDDP_LL_ERR, "%s: usage is NULL!\n", __func__);
return -EINVAL;
}
memset(usage, 0, sizeof(struct mddpw_net_stat_t));
if (mddp_ipc_get_md_smem_by_id(MDDP_MD_SMEM_USER_WIFI_STATISTICS,
(void **)&md_stats, &smem_attr, &smem_size)) {
MDDP_S_LOG(MDDP_LL_ERR,
"%s: Failed to get smem_id (%d)!\n",
__func__, MDDP_MD_SMEM_USER_WIFI_STATISTICS);
return -EFAULT;
}
if (md_stats && smem_size > 0) {
#define DIFF_FROM_SMEM(x) (usage->x = \
(md_stats->x > cur_stats.x) ? (md_stats->x - cur_stats.x) : 0)
DIFF_FROM_SMEM(tx_packets);
DIFF_FROM_SMEM(rx_packets);
DIFF_FROM_SMEM(tx_bytes);
DIFF_FROM_SMEM(rx_bytes);
DIFF_FROM_SMEM(tx_errors);
DIFF_FROM_SMEM(rx_errors);
memcpy(&cur_stats, md_stats, sizeof(struct mddpw_net_stat_t));
}
return 0;
}
static int32_t mddpw_drv_get_net_stat_ext(struct mddpw_net_stat_ext_t *usage)
{
struct mddpw_net_stat_ext_t *md_stats = NULL;
uint8_t smem_attr;
uint32_t smem_size;
if (!usage) {
MDDP_S_LOG(MDDP_LL_ERR, "%s: usage is NULL!\n", __func__);
return -EINVAL;
}
memset(usage, 0, sizeof(struct mddpw_net_stat_ext_t));
if (mddp_ipc_get_md_smem_by_id(MDDP_MD_SMEM_USER_WIFI_STATISTICS_EXT,
(void **)&md_stats, &smem_attr, &smem_size)) {
MDDP_S_LOG(MDDP_LL_ERR,
"%s: Failed to get smem_id (%d)!\n",
__func__,
MDDP_MD_SMEM_USER_WIFI_STATISTICS_EXT);
return -EFAULT;
}
if (!md_stats || smem_size != sizeof(struct mddpw_net_stat_ext_t)) {
MDDP_S_LOG(MDDP_LL_ERR,
"%s: Invalid share memory data, md_stats(%llx), smem_size(%u)!\n",
__func__, (unsigned long long)md_stats, smem_size);
return -EFAULT;
}
/* OK */
memcpy(usage, md_stats, smem_size);
return 0;
}
static int32_t mddpw_drv_get_sys_stat(struct mddpw_sys_stat_t **sys_stat)
{
uint8_t smem_attr;
uint32_t smem_size;
if (mddp_ipc_get_md_smem_by_id(MDDP_MD_SMEM_USER_SYS_STAT_SYNC,
(void **)sys_stat, &smem_attr, &smem_size)) {
MDDP_S_LOG(MDDP_LL_ERR,
"%s: Failed to get smem_id (%d)!\n",
__func__, MDDP_MD_SMEM_USER_SYS_STAT_SYNC);
return -EINVAL;
}
return 0;
}
static int32_t mddpw_drv_get_ap_rx_reorder_buf(
struct mddpw_ap_reorder_sync_table_t **ap_table)
{
uint8_t smem_attr;
uint32_t smem_size;
if (mddp_ipc_get_md_smem_by_id(MDDP_MD_SMEM_USER_RX_REORDER_TO_MD,
(void **)ap_table, &smem_attr, &smem_size)) {
MDDP_S_LOG(MDDP_LL_ERR,
"%s: Failed to get smem_id (%d)!\n",
__func__, MDDP_MD_SMEM_USER_RX_REORDER_TO_MD);
return -EINVAL;
}
return 0;
}
static int32_t mddpw_drv_get_md_rx_reorder_buf(
struct mddpw_md_reorder_sync_table_t **md_table)
{
uint8_t smem_attr;
uint32_t smem_size;
if (mddp_ipc_get_md_smem_by_id(MDDP_MD_SMEM_USER_RX_REORDER_FROM_MD,
(void **)md_table, &smem_attr, &smem_size)) {
MDDP_S_LOG(MDDP_LL_ERR,
"%s: Failed to get smem_id (%d)!\n",
__func__, MDDP_MD_SMEM_USER_RX_REORDER_FROM_MD);
return -EINVAL;
}
return 0;
}
static int32_t mddpw_drv_notify_info(
struct mddpw_drv_notify_info_t *wifi_notify)
{
struct mddp_md_msg_t *md_msg;
struct mddp_app_t *app;
// Send WIFI Notify to MD
app = mddp_get_app_inst(MDDP_APP_TYPE_WH);
if (!app->is_config) {
MDDP_S_LOG(MDDP_LL_ERR,
"%s: app_type(MDDP_APP_TYPE_WH) not configured!\n",
__func__);
return -ENODEV;
}
md_msg = kzalloc(sizeof(struct mddp_md_msg_t) +
sizeof(struct mddpw_drv_notify_info_t) +
wifi_notify->buf_len, GFP_ATOMIC);
if (unlikely(!md_msg)) {
return -ENOMEM;
}
md_msg->msg_id = IPC_MSG_ID_WFPM_DRV_NOTIFY;
md_msg->data_len = sizeof(struct mddpw_drv_notify_info_t) +
wifi_notify->buf_len;
memcpy(md_msg->data, wifi_notify, md_msg->data_len);
mddp_ipc_send_md(app, md_msg, MDFPM_USER_ID_NULL);
return 0;
}
static int32_t mddpw_drv_get_mddp_feature(void)
{
struct mddp_app_t *app;
int feature;
app = mddp_get_app_inst(MDDP_APP_TYPE_WH);
if (!app->is_config) {
MDDP_S_LOG(MDDP_LL_ERR,
"%s: app_type(MDDP_APP_TYPE_WH) not configured!\n",
__func__);
return -ENODEV;
}
feature = atomic_read(&app->feature);
if (!app->reset_cnt) {
MDDP_S_LOG(MDDP_LL_ERR, "%s before MD ready!\n", __func__);
app->abnormal_flags |= MDDP_ABNORMAL_WIFI_DRV_GET_FEATURE_BEFORE_MD_READY;
}
return feature;
}
static int32_t mddpw_drv_reg_callback(struct mddp_drv_handle_t *handle)
{
struct mddpw_drv_handle_t *wifi_handle;
if (handle->wifi_handle == NULL) {
MDDP_S_LOG(MDDP_LL_ERR, "%s: handle NULL\n", __func__);
return -EINVAL;
}
wifi_handle = handle->wifi_handle;
wifi_handle->add_txd = mddpw_drv_add_txd;
wifi_handle->get_net_stat = mddpw_drv_get_net_stat;
wifi_handle->get_ap_rx_reorder_buf = mddpw_drv_get_ap_rx_reorder_buf;
wifi_handle->get_md_rx_reorder_buf = mddpw_drv_get_md_rx_reorder_buf;
wifi_handle->notify_drv_info = mddpw_drv_notify_info;
wifi_handle->get_net_stat_ext = mddpw_drv_get_net_stat_ext;
wifi_handle->get_sys_stat = mddpw_drv_get_sys_stat;
wifi_handle->get_mddp_feature = mddpw_drv_get_mddp_feature;
return 0;
}
static int32_t mddpw_drv_dereg_callback(struct mddp_drv_handle_t *handle)
{
struct mddpw_drv_handle_t *wifi_handle;
if (handle->wifi_handle == NULL) {
MDDP_S_LOG(MDDP_LL_ERR, "%s: handle NULL\n", __func__);
return -EINVAL;
}
wifi_handle = handle->wifi_handle;
wifi_handle->add_txd = NULL;
wifi_handle->get_net_stat = NULL;
wifi_handle->get_ap_rx_reorder_buf = NULL;
wifi_handle->get_md_rx_reorder_buf = NULL;
wifi_handle->notify_drv_info = NULL;
wifi_handle->get_net_stat_ext = NULL;
wifi_handle->get_sys_stat = NULL;
wifi_handle->get_mddp_feature = NULL;
return 0;
}
static ssize_t mddpwh_sysfs_callback(
struct mddp_app_t *app,
enum mddp_sysfs_cmd_e cmd,
char *buf,
size_t buf_len)
{
static uint8_t mddpwh_state = 1;
struct mddpw_net_stat_t *md_stats;
uint8_t smem_attr;
uint32_t smem_size;
uint32_t show_cnt = 0;
#ifdef MDDP_EM_SUPPORT
struct mddp_md_msg_t *md_msg;
#endif
if (cmd == MDDP_SYSFS_CMD_STATISTIC_READ) {
if (mddp_ipc_get_md_smem_by_id(
MDDP_MD_SMEM_USER_WIFI_STATISTICS,
(void **)&md_stats, &smem_attr, &smem_size)) {
MDDP_S_LOG(MDDP_LL_NOTICE,
"%s: Failed to get smem_id (%d)!\n",
__func__,
MDDP_MD_SMEM_USER_WIFI_STATISTICS);
return -EINVAL;
}
show_cnt += scnprintf(buf, PAGE_SIZE, "\n[MDDP-WH State]\n%d\n",
mddpwh_state);
show_cnt += scnprintf(buf + show_cnt, PAGE_SIZE - show_cnt,
"[MDDP-WH Statistics]\n");
show_cnt += scnprintf(buf + show_cnt, PAGE_SIZE - show_cnt,
"%s\t\t%s\t\t%s\t%s\t%s\t%s\n",
"tx_pkts", "rx_pkts",
"tx_bytes", "rx_bytes",
"tx_error", "rx_error");
show_cnt += scnprintf(buf + show_cnt, PAGE_SIZE - show_cnt,
"%lld\t\t%lld\t\t%lld\t\t%lld\t\t%lld\t\t%lld\n",
md_stats->tx_packets, md_stats->rx_packets,
md_stats->tx_bytes, md_stats->rx_bytes,
md_stats->tx_errors, md_stats->rx_errors);
return show_cnt;
}
if (cmd == MDDP_SYSFS_CMD_ENABLE_WRITE) {
if (sysfs_streq(buf, "1")) {
app->state_machines[MDDP_STATE_DISABLED] =
mddpwh_disabled_state_machine_s;
mddpwh_state = 1;
MDDP_S_LOG(MDDP_LL_NOTICE, "%s: enable!\n", __func__);
} else if (sysfs_streq(buf, "0")) {
app->state_machines[MDDP_STATE_DISABLED] =
mddpwh_dead_state_machine_s;
mddpwh_state = 0;
MDDP_S_LOG(MDDP_LL_NOTICE, "%s: disable!\n", __func__);
} else
buf_len = 0;
return buf_len;
} else if (cmd == MDDP_SYSFS_CMD_ENABLE_READ)
return scnprintf(buf, PAGE_SIZE,
"wh_enable(%d)\n", mddpwh_state);
#ifdef MDDP_EM_SUPPORT
if (cmd == MDDP_SYSFS_EM_CMD_TEST_WRITE) {
md_msg = kzalloc(sizeof(struct mddp_md_msg_t) +
buf_len + 4, GFP_ATOMIC);
if (md_msg) {
md_msg->msg_id = IPC_MSG_ID_MDFPM_EM_TEST_REQ;
md_msg->data_len = buf_len;
memcpy(&(md_msg->data), buf, buf_len);
mddp_ipc_send_md(app, md_msg, MDFPM_USER_ID_MDFPM);
}
return buf_len;
}
#endif
return 0;
}
static void wfpm_reset_work_func(struct work_struct *work)
{
struct mddp_app_t *app;
app = mddp_get_app_inst(MDDP_APP_TYPE_WH);
atomic_set(&app->feature, 0x0);
atomic_or(MDDP_FEATURE_MCIF_WIFI, &app->feature);
app->abnormal_flags &= ~MDDP_ABNORMAL_CCCI_SEND_FAILED;
app->reset_cnt++;
mddp_check_feature();
mddpw_wfpm_send_smem_layout();
if (app->state != MDDP_STATE_DISABLED) {
mddp_sm_on_event(app, MDDP_EVT_FUNC_ENABLE);
}
}
static void md_rsp_fail_work_func(struct work_struct *work)
{
struct mddp_app_t *app;
app = mddp_get_app_inst(MDDP_APP_TYPE_WH);
mddp_sm_on_event(app, MDDP_EVT_MD_RSP_FAIL);
}
int32_t mddpwh_sm_init(struct mddp_app_t *app)
{
memcpy(&app->state_machines,
&mddpwh_state_machines_s,
sizeof(mddpwh_state_machines_s));
MDDP_S_LOG(MDDP_LL_INFO,
"%s: %p, %p\n",
__func__,
&(app->state_machines), &mddpwh_state_machines_s);
mddp_dump_sm_table(app);
app->md_recv_msg_hdlr = mddpw_wfpm_msg_hdlr;
app->reg_drv_callback = mddpw_drv_reg_callback;
app->dereg_drv_callback = mddpw_drv_dereg_callback;
app->sysfs_callback = mddpwh_sysfs_callback;
memcpy(&app->md_cfg, &mddpw_md_cfg_s, sizeof(struct mddp_md_cfg_t));
app->is_config = 1;
INIT_WORK(&wfpm_reset_work, wfpm_reset_work_func);
INIT_WORK(&md_rsp_fail_work, md_rsp_fail_work_func);
return 0;
}