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,26 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* mddp_ctrl.h - Public API/structure provided by ctrl.
*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifndef __MDDP_CTRL_H
#define __MDDP_CTRL_H
#include "mddp_export.h"
//------------------------------------------------------------------------------
// Define marco.
// -----------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Struct definition.
// -----------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Public functions.
// -----------------------------------------------------------------------------
struct mddp_app_t *mddp_get_app_inst(enum mddp_app_type_e type);
#endif /* __MDDP_CTRL_H */
@@ -0,0 +1,103 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* mddp_debug.h - Public API/structure provided for logging.
*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifndef __MDDP_DEBUG_H
#define __MDDP_DEBUG_H
//------------------------------------------------------------------------------
// Define marco - log level/class.
// -----------------------------------------------------------------------------
extern uint32_t mddp_debug_log_class_s;
extern uint32_t mddp_debug_log_level_s;
#define _MDDP_DEBUG(_class, _lv, _fmt, _args...) \
do { \
if ((mddp_debug_log_class_s & _class) && \
(mddp_debug_log_level_s >= _lv)) \
pr_notice(_fmt, ##_args); \
} while (0)
#define MDDP_C_LOG(_lv, _fmt, _args...) \
_MDDP_DEBUG(MDDP_LC_CTRL, _lv, _fmt, _args)
#define MDDP_S_LOG(_lv, _fmt, _args...) \
_MDDP_DEBUG(MDDP_LC_SM, _lv, _fmt, _args)
#define MDDP_F_LOG(_lv, _fmt, _args...) \
_MDDP_DEBUG(MDDP_LC_FILTER, _lv, _fmt, _args)
#define MDDP_U_LOG(_lv, _fmt, _args...) \
_MDDP_DEBUG(MDDP_LC_USAGE, _lv, _fmt, _args)
//------------------------------------------------------------------------------
// Struct definition - log level/class.
// -----------------------------------------------------------------------------
#define MDDP_DEBUG_LOG_CLASS_MASK 0xF0
#define MDDP_IS_VALID_LOG_CLASS(_class) (_class <= MDDP_LC_ALL)
enum mddp_log_class_e {
MDDP_LC_OFF = 0, /* 0 */
MDDP_LC_CTRL = 0x1, /* 1 */
MDDP_LC_SM = 0x2, /* 2 */
MDDP_LC_FILTER = 0x4, /* 4 */
MDDP_LC_USAGE = 0x8, /* 8 */
MDDP_LC_ALL = 0xF, /* F */
};
#define MDDP_DEBUG_LOG_LV_MASK 0x0F
#define MDDP_IS_VALID_LOG_LEVEL(_level) (_level <= MDDP_LL_ALL)
enum mddp_log_level_e {
MDDP_LL_CRIT, /* 0 */
MDDP_LL_ERR, /* 1 */
MDDP_LL_WARN, /* 2 */
MDDP_LL_NOTICE, /* 3 */
MDDP_LL_INFO, /* 4 */
MDDP_LL_DEBUG, /* 5 */
MDDP_LL_ALL, /* 6 */
};
#define MDDP_LL_DEFAULT MDDP_LL_WARN
//------------------------------------------------------------------------------
// Define marco.
// -----------------------------------------------------------------------------
//------------------------------------------------------------------------------
// Struct definition.
// -----------------------------------------------------------------------------
enum mddp_dstate_id_e {
MDDP_DSTATE_ID_START,
MDDP_DSTATE_ID_STOP,
MDDP_DSTATE_ID_NEW_TAG,
MDDP_DSTATE_ID_SUSPEND_TAG,
MDDP_DSTATE_ID_RESUME_TAG,
MDDP_DSTATE_ID_GET_OFFLOAD_STATS,
MDDP_DSTATE_ID_NUM,
};
#define MDDP_DSTATE_STR_SZ 96
struct mddp_dstate_t {
enum mddp_dstate_id_e id;
uint8_t str[MDDP_DSTATE_STR_SZ];
};
static struct mddp_dstate_t mddp_dstate_temp_s[] = {
{MDDP_DSTATE_ID_START,
"==================== [%s] START DSTATE ===================="},
{MDDP_DSTATE_ID_STOP,
"==================== [%s] STOP DSTATE ===================="},
{MDDP_DSTATE_ID_NEW_TAG,
"[%s] New connection, ip(%x) port(%d)"},
{MDDP_DSTATE_ID_SUSPEND_TAG,
"[%s] Suspend tag"},
{MDDP_DSTATE_ID_RESUME_TAG,
"[%s] Resume tag"},
{MDDP_DSTATE_ID_GET_OFFLOAD_STATS,
"[%s] Get offload stats, rx(%08llu), tx(%08llu)"},
};
//------------------------------------------------------------------------------
// Public functions.
// -----------------------------------------------------------------------------
#endif /* __MDDP_DEBUG_H */
@@ -0,0 +1,30 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* mddp_dev.h - Structure/API of MDDP device node control.
*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifndef __MDDP_DEV_H
#define __MDDP_DEV_H
#include "mddp_export.h"
//------------------------------------------------------------------------------
// Struct definition.
// -----------------------------------------------------------------------------
#define MDDP_DETAILED_STATE_ENABLE 19283746
#define MDDP_DETAILED_STATE_DISABLE 0
#define MDDP_EM_SUPPORT 1 /**< Engineer mode support */
//------------------------------------------------------------------------------
// Public functions.
// -----------------------------------------------------------------------------
int32_t mddp_dev_init(void);
void mddp_dev_uninit(void);
void mddp_dev_response(enum mddp_app_type_e type,
enum mddp_ctrl_msg_e msg, bool is_success,
uint8_t *data, uint32_t data_len);
void mddp_enqueue_dstate(enum mddp_dstate_id_e id, ...);
#endif /* __MDDP_DEV_H */
@@ -0,0 +1,276 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* mddp_export.h - Public API/structure provided for external modules.
*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifndef __MDDP_EXPORT_H
#define __MDDP_EXPORT_H
#include <linux/if.h>
#include "mddp_wifi_def.h"
//------------------------------------------------------------------------------
// Struct definition.
// -----------------------------------------------------------------------------
#define __MDDP_VERSION__ 2
#define MDDP_TAG_PATTERN 0x4646
#define MDDP_MAX_GET_BUF_SZ 256
enum mddp_state_e {
MDDP_STATE_UNINIT = 0,
MDDP_STATE_ENABLING,
MDDP_STATE_DEACTIVATED,
MDDP_STATE_ACTIVATING,
MDDP_STATE_ACTIVATED,
MDDP_STATE_DEACTIVATING,
MDDP_STATE_DISABLING,
MDDP_STATE_DISABLED,
MDDP_STATE_CNT,
MDDP_STATE_DUMMY = 0x7fff /* Make it a 2-byte enum. */
};
enum mddp_app_type_e {
MDDP_APP_TYPE_RESERVED_1 = 0,
MDDP_APP_TYPE_WH,
MDDP_APP_TYPE_CNT,
MDDP_APP_TYPE_ALL = 0xff,
MDDP_APP_TYPE_DUMMY = 0x7fff /* Mark it a 2-byte enum. */
};
struct mddp_drv_conf_t {
enum mddp_app_type_e app_type;
};
typedef int32_t (*drv_cbf_change_state_t)(
enum mddp_state_e state, void *buf, uint32_t *buf_len);
struct mddp_drv_handle_t {
/* MDDP invokes these APIs provided by driver. */
drv_cbf_change_state_t change_state;
/* Application layer handler. */
union {
struct mddpw_drv_handle_t *wifi_handle;
};
};
//------------------------------------------------------------------------------
// Public function definition - For driver
// -----------------------------------------------------------------------------
int32_t mddp_drv_attach(
struct mddp_drv_conf_t *conf, struct mddp_drv_handle_t *handle);
void mddp_drv_detach(
struct mddp_drv_conf_t *conf, struct mddp_drv_handle_t *handle);
//------------------------------------------------------------------------------
// Public function definition - For HIDL
// -----------------------------------------------------------------------------
/*
* MDDP DEV control code.
*/
#define MDDP_CMCMD_MAGIC 'P'
#define MDDP_CMCMD_DEV_REQ _IORW(MDDP_CMCMD_MAGIC, 0)
#define MDDP_CTRL_MSG_MCODE 0x2454
#define MDDP_CTRL_MSG_VERSION 1
enum mddp_dev_evt_type_e {
MDDP_DEV_EVT_NONE = 0,
MDDP_DEV_EVT_STARTED = 1,
MDDP_DEV_EVT_STOPPED_ERROR = 2,
MDDP_DEV_EVT_STOPPED_UNSUPPORTED = 3,
MDDP_DEV_EVT_SUPPORT_AVAILABLE = 4,
MDDP_DEV_EVT_STOPPED_LIMIT_REACHED = 5,
MDDP_DEV_EVT_CONNECT_UPDATE = 6,
MDDP_DEV_EVT_WARNING_REACHED = 7,
MDDP_DEV_EVENT_CNT,
MDDP_DEV_EVENT_DUMMY = 0x7fff /* Mark it a 2-byte enum */
};
enum mddp_ctrl_msg_e {
/* CMCMD Request */
MDDP_CMCMD_ENABLE_REQ = 0,
MDDP_CMCMD_DISABLE_REQ,
MDDP_CMCMD_ACT_REQ,
MDDP_CMCMD_DEACT_REQ,
MDDP_CMCMD_GET_OFFLOAD_STATS_REQ,
MDDP_CMCMD_SET_DATA_LIMIT_REQ,
MDDP_CMCMD_SET_CT_VALUE_REQ,
MDDP_CMCMD_SET_WARNING_AND_DATA_LIMIT_REQ,
/* CMCMD Response */
MDDP_CMCMD_RSP_BEGIN = 0x100,
MDDP_CMCMD_ENABLE_RSP = MDDP_CMCMD_RSP_BEGIN,
MDDP_CMCMD_DISABLE_RSP,
MDDP_CMCMD_ACT_RSP,
MDDP_CMCMD_DEACT_RSP,
MDDP_CMCMD_LIMIT_IND,
MDDP_CMCMD_CT_IND,
MDDP_CMCMD_WARNING_IND,
MDDP_CMCMD_RSP_END,
MDDP_CMCMD_DUMMY = 0x7fff /* Mark it a 2-byte enum */
};
enum mddp_f_e_tag_type_e {
MDDP_E_TAG_NONE = 0,
MDDP_E_TAG_MAC = 1,
};
/*
* MDDP control request structure.
*/
struct mddp_dev_req_common_t {
uint16_t mcode;
uint16_t version;
enum mddp_app_type_e app_type;
enum mddp_ctrl_msg_e msg;
uint32_t data_len;
uint8_t data[0];
};
struct mddp_dev_req_enable_t {
uint32_t rsv;
};
struct mddp_dev_req_disable_t {
uint32_t rsv;
};
struct mddp_dev_req_act_t {
uint8_t ul_dev_name[IFNAMSIZ];
uint8_t dl_dev_name[IFNAMSIZ];
};
struct mddp_dev_req_deact_t {
uint32_t rsv;
};
struct mddp_dev_req_set_data_limit_t {
uint8_t ul_dev_name[IFNAMSIZ];
uint64_t limit_size; /* Bytes */
};
struct mddp_dev_req_set_warning_and_data_limit_t {
uint8_t ul_dev_name[IFNAMSIZ];
uint64_t limit_size; /* Bytes */
uint64_t warning_size; /* Bytes */
};
struct mddp_dev_req_set_ct_value_t {
uint32_t udp_ct_timeout;
uint32_t tcp_ct_timeout;
};
/*
* MDDP control response structure.
*/
struct mddp_dev_rsp_common_t {
uint16_t mcode;
uint16_t status;
enum mddp_app_type_e app_type;
enum mddp_ctrl_msg_e msg;
uint32_t data_len;
uint8_t data[0];
};
struct mddp_dev_rsp_enable_t {
uint32_t rsv;
};
struct mddp_dev_rsp_disable_t {
uint32_t rsv;
};
struct mddp_dev_rsp_act_t {
uint32_t rsv;
};
struct mddp_dev_rsp_deact_t {
uint32_t rsv;
};
/*
* MDDP data statistics structure.
*/
struct mddp_u_data_stats_t {
uint64_t total_tx_bytes;
uint64_t total_tx_pkts;
uint64_t tx_tcp_bytes;
uint64_t tx_tcp_pkts;
uint64_t tx_udp_bytes;
uint64_t tx_udp_pkts;
uint64_t tx_others_bytes;
uint64_t tx_others_pkts;
uint64_t total_rx_bytes;
uint64_t total_rx_pkts;
uint64_t rx_tcp_bytes;
uint64_t rx_tcp_pkts;
uint64_t rx_udp_bytes;
uint64_t rx_udp_pkts;
uint64_t rx_others_bytes;
uint64_t rx_others_pkts;
};
/*
* MDDP rule info. for connection track update
*/
struct mddp_ct_nat_table_t {
uint8_t private_ip[4];
uint8_t target_ip[4];
uint8_t public_ip[4];
uint16_t private_port;
uint16_t target_port;
uint16_t public_port;
uint8_t protocol;
uint8_t reserved;
uint32_t timestamp;
bool dst_nat;
};
#define MAX_CT_NAT_TABLE_NUM 64
struct mddp_ct_timeout_ind_t {
uint16_t entry_num;
struct mddp_ct_nat_table_t nat_table[MAX_CT_NAT_TABLE_NUM];
};
/*
* MDDP tag structure.
*/
struct mddp_f_tag_packet_t {
u_int16_t guard_pattern;
u_int8_t version;
u_int8_t tag_len; // extension tag included
struct {
u_int8_t tag_info;
u_int8_t reserved;
u_int16_t port;
u_int32_t lan_netif_id;
u_int32_t ip;
} v2;
};
/*
* Extended MDDP tag structure - COMMON
*/
struct mddp_f_e_tag_common_t {
u_int8_t type;
u_int8_t len;
u_int8_t value[0];
} __packed;
/*
* Extended MDDP tag structure - MAC
*/
struct mddp_f_e_tag_mac_t {
u_int8_t mac_addr[6];
u_int32_t access_cnt;
} __packed;
#endif /* __MDDP_EXPORT_H */
@@ -0,0 +1,30 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* mddp_filter.h - Public API/structure provided by filter.
*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifndef __MDDP_FILTER_H
#define __MDDP_FILTER_H
//------------------------------------------------------------------------------
// Public functions.
// -----------------------------------------------------------------------------
int32_t mddp_filter_init(void);
void mddp_filter_uninit(void);
int mddp_f_data_usage_wan_dev_name_to_id(char *dev_name);
bool mddp_f_dev_add_lan_dev(char *dev_name, int netif_id);
bool mddp_f_dev_add_wan_dev(char *dev_name);
void mddp_f_dev_del_lan_dev(char *dev_name);
void mddp_f_dev_del_wan_dev(char *dev_name);
struct net_device *mddp_f_is_support_lan_dev(int ifindex);
struct net_device *mddp_f_is_support_wan_dev(int ifindex);
int32_t mddp_f_msg_hdlr(uint32_t msg_id, void *buf, uint32_t buf_len);
int32_t mddp_f_set_ct_value(uint8_t *buf, uint32_t buf_len);
void mddp_netfilter_hook(void);
void mddp_netfilter_unhook(void);
#endif /* __MDDP_FILTER_H */
@@ -0,0 +1,123 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* mddp_ipc.h - Structure used for AP/MD communication.
*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifndef __MDDP_IPC_H
#define __MDDP_IPC_H
#include "mddp_wifi_def.h"
//------------------------------------------------------------------------------
// Configuration.
// -----------------------------------------------------------------------------
#define MDDP_IPC_TTY_NAME "ccci_0_200"
#define MDFPM_TTY_BUF_SZ 256
//------------------------------------------------------------------------------
// Enum. definition.
// -----------------------------------------------------------------------------
enum MDDP_MDFPM_MSG_ID_CODE {
IPC_MSG_ID_MDFPM_USER_MSG_BEGIN,
IPC_MSG_ID_DPFM_DATA_USAGE_CMD,
IPC_MSG_ID_DPFM_SET_CT_TIMEOUT_VALUE_REQ,
IPC_MSG_ID_DPFM_SET_CT_TIMEOUT_VALUE_RSP,
IPC_MSG_ID_DPFM_CT_TIMEOUT_IND,
IPC_MSG_ID_WFPM_ENABLE_MD_FAST_PATH_REQ,
IPC_MSG_ID_WFPM_ENABLE_MD_FAST_PATH_RSP,
IPC_MSG_ID_WFPM_DISABLE_MD_FAST_PATH_REQ,
IPC_MSG_ID_WFPM_DISABLE_MD_FAST_PATH_RSP,
IPC_MSG_ID_WFPM_DEACTIVATE_MD_FAST_PATH_REQ,
IPC_MSG_ID_WFPM_DEACTIVATE_MD_FAST_PATH_RSP,
IPC_MSG_ID_WFPM_DEACTIVATE_MD_FAST_PATH_IND,
IPC_MSG_ID_WFPM_ACTIVATE_MD_FAST_PATH_REQ,
IPC_MSG_ID_WFPM_ACTIVATE_MD_FAST_PATH_RSP,
IPC_MSG_ID_WFPM_SEND_MD_TXD_NOTIFY,
IPC_MSG_ID_WFPM_DRV_NOTIFY,
IPC_MSG_ID_WFPM_MD_NOTIFY,
IPC_MSG_ID_WFPM_RESET_IND,
IPC_MSG_ID_RESERVED_01,
IPC_MSG_ID_RESERVED_02,
IPC_MSG_ID_RESERVED_03,
IPC_MSG_ID_RESERVED_04,
IPC_MSG_ID_RESERVED_05,
IPC_MSG_ID_RESERVED_06,
IPC_MSG_ID_RESERVED_07,
IPC_MSG_ID_RESERVED_08,
IPC_MSG_ID_RESERVED_09,
IPC_MSG_ID_RESERVED_10,
IPC_MSG_ID_RESERVED_11,
IPC_MSG_ID_RESERVED_12,
IPC_MSG_ID_RESERVED_13,
IPC_MSG_ID_RESERVED_14,
IPC_MSG_ID_RESERVED_15,
IPC_MSG_ID_MDFPM_EM_TEST_REQ,
IPC_MSG_ID_MDFPM_SUSPEND_TAG_IND,
IPC_MSG_ID_MDFPM_SUSPEND_TAG_ACK,
IPC_MSG_ID_MDFPM_RESUME_TAG_IND,
IPC_MSG_ID_MDFPM_RESUME_TAG_ACK,
IPC_MSG_ID_WFPM_SEND_SMEM_LAYOUT_NOTIFY,
IPC_MSG_ID_MDFPM_REQ_RM,
IPC_MSG_ID_MDFPM_NO_TRAFFIC_NOTIFY,
IPC_MSG_ID_MDFPM_CHECK_FEATURE_REQ,
IPC_MSG_ID_MDFPM_CHECK_FEATURE_RSP,
};
#define MDFPM_AP_USER_ID 0x13578642
enum mdfpm_user_id_e {
MDFPM_USER_ID_RESERVED_1,
MDFPM_USER_ID_WFPM,
MDFPM_USER_ID_DPFM,
MDFPM_USER_ID_MDFPM,
MDFPM_USER_NUM,
MDFPM_USER_ID_NULL = 0x7fe,
MDFPM_USER_DUMMY = 0x7ff, /* Make it a 2-byte enum */
};
//------------------------------------------------------------------------------
// Struct definition.
// -----------------------------------------------------------------------------
#define MDFPM_CTRL_MSG_HEADER_SZ \
(sizeof(struct mdfpm_ctrl_msg_t) - MDFPM_TTY_BUF_SZ)
struct mdfpm_ctrl_msg_t {
uint32_t dest_user_id;
uint32_t msg_id;
uint32_t buf_len;
uint8_t buf[MDFPM_TTY_BUF_SZ];
} __packed;
struct mddp_md_msg_t {
struct list_head list;
uint32_t msg_id;
uint32_t data_len;
uint8_t data[0];
};
struct mddp_ipc_rx_msg_entry_t {
enum MDDP_MDFPM_MSG_ID_CODE msg_id;
uint32_t rx_msg_len;
};
//------------------------------------------------------------------------------
// Public functions.
// -----------------------------------------------------------------------------
int32_t mddp_ipc_init(void);
void mddp_ipc_uninit(void);
int32_t mddp_ipc_send_md(void *app, struct mddp_md_msg_t *msg,
enum mdfpm_user_id_e dest_user);
int32_t wfpm_ipc_get_smem_list(void **smem_info_base, uint32_t *smem_num);
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);
bool mddp_ipc_rx_msg_validation(enum MDDP_MDFPM_MSG_ID_CODE msg_id,
uint32_t msg_len);
#endif /* __MDDP_IPC_H */
@@ -0,0 +1,65 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifndef __MDDP_USAGE_H
#define __MDDP_USAGE_H
#include "mddp_export.h"
//------------------------------------------------------------------------------
// Struct definition.
// -----------------------------------------------------------------------------
enum mddp_data_usage_cmd_e {
MSG_ID_DPFM_SET_GLOBAL_ALERT_REQ,
MSG_ID_DPFM_ALERT_GLOBAL_ALERT_IND,
MSG_ID_DPFM_SET_IQUOTA_REQ,
MSG_ID_DPFM_ALERT_IQUOTA_IND,
MSG_ID_DPFM_DEL_IQUOTA_REQ,
MSG_ID_DPFM_SET_IQUOTA_V2_REQ,
MSG_ID_DPFM_ALERT_IQUOTA_WARNING_IND,
};
struct mddp_u_data_limit_t {
uint32_t cmd;
uint32_t trans_id;
uint32_t status; /*unused */
uint64_t limit_buffer_size;
int8_t id;
uint8_t rsv[3];
} __packed;
struct mddp_u_warning_and_data_limit_t {
uint32_t cmd;
uint32_t trans_id;
uint32_t status; /*unused */
uint64_t limit_buffer_size;
uint64_t warning_buffer_size;
int8_t id;
uint8_t rsv[3];
} __packed;
struct mddp_u_iq_entry_t {
uint32_t trans_id;
uint32_t status; /*unused */
uint64_t limit_buffer_size;
uint8_t dpfm_id;
uint8_t rsv[3];
} __packed;
struct mddp_u_iquota_ind_t {
uint32_t cmd;
struct mddp_u_iq_entry_t iq;
} __packed;
//------------------------------------------------------------------------------
// Public functions.
// -----------------------------------------------------------------------------
void mddp_u_set_wan_iface(uint8_t *devname);
void mddp_u_get_data_stats(void *buf, uint32_t *buf_len);
int32_t mddp_u_set_data_limit(uint8_t *buf, uint32_t buf_len);
int32_t mddp_u_set_warning_and_data_limit(uint8_t *buf, uint32_t buf_len);
int32_t mddp_u_msg_hdlr(uint32_t msg_id, void *buf, uint32_t buf_len);
#endif /* __MDDP_USAGE_H */
@@ -0,0 +1,235 @@
/* SPDX-License-Identifier: GPL-2.0 */
/*
* mddp_wifi_def.h -- Data structure of MD WiFi module.
*
* Copyright (c) 2020 MediaTek Inc.
*/
#ifndef __MDDP_WIFI_DEF_H
#define __MDDP_WIFI_DEF_H
enum wfpm_func_mode_e {
WFPM_FUNC_MODE_TETHER = 0,
WFPM_FUNC_MODE_MAX_NUM
};
#define WIFI_ONOFF_NOTIFICATION_LEN 1
#define MAC_ADDR_LEN 6
struct mddpw_txd_t {
uint8_t version;
uint8_t wlan_idx;
uint8_t sta_idx;
uint8_t aucMacAddr[MAC_ADDR_LEN];
uint8_t txd_length;
uint8_t txd[0];
} __packed;
struct mddpw_net_stat_t {
uint64_t tx_packets;
uint64_t rx_packets;
uint64_t tx_bytes;
uint64_t rx_bytes;
uint64_t tx_errors;
uint64_t rx_errors;
};
#define NW_IF_NAME_LEN_MAX 16
struct mddpw_net_stat_elem_ext_t {
uint8_t nw_if_name[NW_IF_NAME_LEN_MAX];
uint32_t reserved[2];
uint64_t tx_packets;
uint64_t rx_packets;
uint64_t tx_bytes;
uint64_t rx_bytes;
uint64_t tx_errors;
uint64_t rx_errors;
uint64_t tx_dropped;
uint64_t rx_dropped;
};
#define MDDP_DOUBLE_BUFFER 2
#define NW_IF_NUM_MAX 4
struct mddpw_net_stat_ext_t {
uint32_t version;
uint32_t reserved;
uint32_t check_flag[2];
struct mddpw_net_stat_elem_ext_t ifs[MDDP_DOUBLE_BUFFER][NW_IF_NUM_MAX];
};
struct mddpw_sys_stat_t {
uint32_t version[2];
uint32_t md_stat[4];
uint32_t ap_stat[4];
uint32_t reserved[2];
};
#define MAX_STAREC_NUM 32 // Max driver support station records
#define MAX_CLIENT_NUM 16 // AP client only support 16 station records
#define VIRTUAL_BUF_SIZE 512 // 4096 bits
#define TID_SIZE 8
/* Rx Reordering - AP to MD */
struct mddpw_ap_virtual_buf_t {
uint16_t start_idx;
uint16_t end_idx;
uint8_t virtual_buf[VIRTUAL_BUF_SIZE];
};
struct mddpw_ap_reorder_sync_table_t {
// Mapping station record and virtual buffer.
struct mddpw_ap_virtual_buf_t virtual_buf[MAX_CLIENT_NUM][TID_SIZE];
};
/* Rx Reordering - MD to AP */
struct mddpw_md_reorder_info_t {
uint8_t buf_idx;
uint8_t reserved[7];
};
struct mddpw_md_virtual_buf_t {
uint16_t start_idx;
uint16_t end_idx;
uint8_t virtual_buf[VIRTUAL_BUF_SIZE];
};
struct mddpw_md_reorder_sync_table_t {
// Mapping station record and virtual buffer.
struct mddpw_md_reorder_info_t reorder_info[MAX_STAREC_NUM];
struct mddpw_md_virtual_buf_t virtual_buf[MAX_CLIENT_NUM][TID_SIZE];
};
enum mddpw_drv_info_id {
MDDPW_DRV_INFO_NONE = 0,
MDDPW_DRV_INFO_DEVICE_MAC = 1,
MDDPW_DRV_INFO_NOTIFY_WIFI_ONOFF = 2,
};
struct mddpw_drv_info_t {
uint8_t info_id;
uint8_t info_len;
uint8_t info[0];
};
struct mddpw_drv_notify_info_t {
uint8_t version;
uint8_t buf_len;
uint8_t info_num;
uint8_t buf[0];
};
struct mddpw_md_notify_info_t {
uint8_t version; /* current ver = 0 */
uint8_t info_type; /* ref enum mddp_md_notify_info_type */
uint8_t buf_len; /* length start from buf[0] */
uint8_t buf[0]; /* content that MD need to send to DRV */
};
typedef int32_t (*drv_cbf_notify_md_info_t) (
struct mddpw_md_notify_info_t *);
typedef int32_t (*mddpw_cbf_add_txd_t)(struct mddpw_txd_t *);
typedef int32_t (*mddpw_cbf_get_net_stat_t)(struct mddpw_net_stat_t *);
typedef int32_t (*mddpw_cbf_get_ap_rx_reorder_buf_t)(
struct mddpw_ap_reorder_sync_table_t **);
typedef int32_t (*mddpw_cbf_get_md_rx_reorder_buf_t)(
struct mddpw_md_reorder_sync_table_t **);
typedef int32_t (*mddpw_cbf_notify_drv_info_t)(
struct mddpw_drv_notify_info_t *);
typedef int32_t (*mddpw_cbf_get_net_stat_ext_t)(struct mddpw_net_stat_ext_t *);
typedef int32_t (*mddpw_cbf_get_sys_stat_t)(struct mddpw_sys_stat_t **);
typedef int32_t (*mddpw_cbf_get_mddp_feature_t)(void);
struct mddpw_drv_handle_t {
/* MDDPW invokes these APIs provided by driver. */
drv_cbf_notify_md_info_t notify_md_info;
/* Driver invokes these APIs provided by MDDPW. */
mddpw_cbf_add_txd_t add_txd;
mddpw_cbf_get_net_stat_t get_net_stat;
mddpw_cbf_get_ap_rx_reorder_buf_t get_ap_rx_reorder_buf;
mddpw_cbf_get_md_rx_reorder_buf_t get_md_rx_reorder_buf;
mddpw_cbf_notify_drv_info_t notify_drv_info;
mddpw_cbf_get_net_stat_ext_t get_net_stat_ext;
mddpw_cbf_get_sys_stat_t get_sys_stat;
mddpw_cbf_get_mddp_feature_t get_mddp_feature;
};
enum mddp_md_smem_user_id_e {
MDDP_MD_SMEM_USER_RX_REORDER_TO_MD,
MDDP_MD_SMEM_USER_RX_REORDER_FROM_MD,
MDDP_MD_SMEM_USER_WIFI_STATISTICS,
MDDP_MD_SMEM_USER_WIFI_STATISTICS_EXT,
MDDP_MD_SMEM_USER_SYS_STAT_SYNC,
MDDP_MD_SMEM_USER_NUM,
};
enum wfpm_smem_entry_attri_e {
WFPM_SM_E_ATTRI_RO = (1 << 0),
WFPM_SM_E_ATTRI_WO = (1 << 1),
WFPM_SM_E_ATTRI_RW = (1 << 2),
};
struct wfpm_smem_info_t {
uint8_t user_id;
uint8_t reserved;
uint16_t attribute;
uint32_t offset;
uint32_t size;
};
struct wfpm_enable_md_func_req_t {
uint8_t mode;
uint8_t version;
uint16_t smem_num;
struct wfpm_smem_info_t smem_info[0];
} __packed;
struct wfpm_enable_md_func_rsp_t {
uint8_t mode;
uint8_t result;
uint8_t version;
uint8_t reserved;
} __packed;
struct wfpm_activate_md_func_req_t {
uint8_t mode;
uint8_t reserved[3];
} __packed;
struct wfpm_deactivate_md_func_rsp_t {
uint8_t mode;
uint8_t result;
uint8_t reserved[2];
} __packed;
struct wfpm_md_fast_path_common_req_t {
uint8_t mode;
uint8_t reserved[3];
} __packed;
struct wfpm_md_fast_path_common_rsp_t {
uint8_t mode;
uint8_t result;
uint8_t reserved[2];
} __packed;
enum mddp_drv_onoff_status {
MDDPW_DRV_INFO_WLAN_ON_START = 0,
MDDPW_DRV_INFO_WLAN_ON_END = 1,
MDDPW_DRV_INFO_WLAN_OFF_START = 2,
MDDPW_DRV_INFO_WLAN_OFF_END = 3,
MDDPW_DRV_INFO_WLAN_ON_END_QOS = 4,
};
enum mddp_md_notify_info_type {
MDDPW_MD_NOTIFY_NONE = 0,
MDDPW_MD_NOTIFY_MD_POWERON,
MDDPW_MD_NOTIFY_END,
};
#define MDDP_FEATURE_MCIF_WIFI (1<<1)
#define MDDP_FEATURE_MDDP_WH (1<<2)
#endif /* __MDDP_WIFI_DEF_H */