samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull-Requests Actions Pakete Projekte Releases Wiki Aktivität

qcacld-3.0: Removed FEATURE_WLAN_RMC feature

Quellcode durchsuchen 
Removed all the API realted to  FEATURE_WLAN_RMC
as well as related SME/WMA code.

Change-Id: Id471ccabcfd183fbcc7ff4e4953991f9e1551526
CRs-Fixed: 2686364
Dieser Commit ist enthalten in:
Utkarsh Bhatnagar
2020-05-14 19:32:25 +05:30
committet von nshrivas
Ursprung d00d63fedd
Commit b0bf5ddb1b
22 geänderte Dateien mit 14 neuen und 1176 gelöschten Zeilen
Patch-Datei herunterladen Vergleichs-Datei herunterladen Alle Dateien ausklappen Alle Dateien einklappen

1
Kbuild
Datei anzeigen

@@ -2631,7 +2631,6 @@ cppflags-$(CONFIG_DFS_FCC_TYPE4_DURATION_CHECK) += -DDFS_FCC_TYPE4_DURATION_CHEC
endif
cppflags-$(CONFIG_WLAN_SYSFS) += -DWLAN_SYSFS
cppflags-$(CONFIG_FEATURE_WLAN_RMC) += -DFEATURE_WLAN_RMC
cppflags-$(CONFIG_FEATURE_BECN_STATS) += -DWLAN_FEATURE_BEACON_RECEPTION_STATS
cppflags-$(CONFIG_WLAN_SYSFS_CONNECT_INFO) += -DWLAN_SYSFS_CONNECT_INFO

1
configs/default_defconfig
Datei anzeigen

@@ -613,7 +613,6 @@ endif
CONFIG_FEATURE_AP_MCC_CH_AVOIDANCE := y
else
CONFIG_QCOM_ESE := y
CONFIG_FEATURE_WLAN_RMC := y
CONFIG_WLAN_OPEN_P2P_INTERFACE := y
CONFIG_WLAN_ENABLE_SOCIAL_CHANNELS_5G_ONLY := y
endif

1
configs/genoa.common
Datei anzeigen

@@ -8,7 +8,6 @@ CONFIG_FEATURE_WLAN_FT_IEEE8021X := y
CONFIG_FEATURE_WLAN_FT_PSK := y
#required features
CONFIG_FEATURE_WLAN_RMC := n
CONFIG_QCACLD_WLAN_LFR2 := y
CONFIG_QCACLD_WLAN_LFR3 := n
CONFIG_QCOM_TDLS := y

1
configs/qca6174_defconfig
Datei anzeigen

@@ -419,7 +419,6 @@ CONFIG_FEATURE_WLAN_STA_AP_MODE_DFS_DISABLE := y
CONFIG_FEATURE_AP_MCC_CH_AVOIDANCE := y
else
CONFIG_QCOM_ESE := y
CONFIG_FEATURE_WLAN_RMC := y
CONFIG_WLAN_OPEN_P2P_INTERFACE := y
CONFIG_WLAN_ENABLE_SOCIAL_CHANNELS_5G_ONLY := y
endif

1
configs/qca6390_defconfig
Datei anzeigen

@@ -456,7 +456,6 @@ CONFIG_FEATURE_AP_MCC_CH_AVOIDANCE := y
else
CONFIG_QCOM_ESE := y
CONFIG_QCA_IBSS_SUPPORT := y
CONFIG_FEATURE_WLAN_RMC := y
CONFIG_WLAN_OPEN_P2P_INTERFACE := y
CONFIG_WLAN_ENABLE_SOCIAL_CHANNELS_5G_ONLY := y
endif

309
core/hdd/src/wlan_hdd_ioctl.c
Datei anzeigen

@@ -4593,310 +4593,6 @@ exit:
return ret;
}
#ifdef FEATURE_WLAN_RMC
/* Function header is left blank intentionally */
static int hdd_parse_setrmcenable_command(uint8_t *command,
uint8_t *rmc_enable)
{
uint8_t *in_ptr = command;
int temp_int;
int v = 0;
char buf[32];
*rmc_enable = 0;
in_ptr = strnchr(command, strlen(command), SPACE_ASCII_VALUE);
if (!in_ptr)
return 0;
else if (SPACE_ASCII_VALUE != *in_ptr)
return 0;
while ((SPACE_ASCII_VALUE == *in_ptr) && ('\0' != *in_ptr))
in_ptr++;
if ('\0' == *in_ptr)
return 0;
v = sscanf(in_ptr, "%31s ", buf);
if (1 != v)
return -EINVAL;
v = kstrtos32(buf, 10, &temp_int);
if (v < 0)
return -EINVAL;
*rmc_enable = temp_int;
hdd_debug("rmc_enable: %d", *rmc_enable);
return 0;
}
/* Function header is left blank intentionally */
static int hdd_parse_setrmcactionperiod_command(uint8_t *pvalue,
uint32_t *paction_period)
{
uint8_t *inptr = pvalue;
int temp_int;
int v = 0;
char buf[32];
*paction_period = 0;
inptr = strnchr(pvalue, strlen(pvalue), SPACE_ASCII_VALUE);
if (!inptr)
return -EINVAL;
else if (SPACE_ASCII_VALUE != *inptr)
return -EINVAL;
while ((SPACE_ASCII_VALUE == *inptr) && ('\0' != *inptr))
inptr++;
if ('\0' == *inptr)
return 0;
v = sscanf(inptr, "%31s ", buf);
if (1 != v)
return -EINVAL;
v = kstrtos32(buf, 10, &temp_int);
if (v < 0)
return -EINVAL;
if (!cfg_in_range(CFG_RMC_ACTION_PERIOD_FREQUENCY, temp_int))
return -EINVAL;
*paction_period = temp_int;
hdd_debug("action_period: %d", *paction_period);
return 0;
}
/* Function header is left blank intentionally */
static int hdd_parse_setrmcrate_command(uint8_t *command,
uint32_t *rate,
enum tx_rate_info *tx_flags)
{
uint8_t *in_ptr = command;
int temp_int;
int v = 0;
char buf[32];
*rate = 0;
*tx_flags = 0;
in_ptr = strnchr(command, strlen(command), SPACE_ASCII_VALUE);
if (!in_ptr)
return -EINVAL;
else if (SPACE_ASCII_VALUE != *in_ptr)
return -EINVAL;
while ((SPACE_ASCII_VALUE == *in_ptr) && ('\0' != *in_ptr))
in_ptr++;
if ('\0' == *in_ptr)
return 0;
v = sscanf(in_ptr, "%31s ", buf);
if (1 != v)
return -EINVAL;
v = kstrtos32(buf, 10, &temp_int);
if (v < 0)
return -EINVAL;
switch (temp_int) {
default:
hdd_warn("Unsupported rate: %d", temp_int);
return -EINVAL;
case 0:
case 6:
case 9:
case 12:
case 18:
case 24:
case 36:
case 48:
case 54:
*tx_flags = TX_RATE_LEGACY;
*rate = temp_int * 10;
break;
case 65:
*tx_flags = TX_RATE_HT20;
*rate = temp_int * 10;
break;
case 72:
*tx_flags = TX_RATE_HT20 | TX_RATE_SGI;
*rate = 722;
break;
}
hdd_debug("Rate: %d", *rate);
return 0;
}
static int drv_cmd_set_rmc_enable(struct hdd_adapter *adapter,
struct hdd_context *hdd_ctx,
uint8_t *command,
uint8_t command_len,
struct hdd_priv_data *priv_data)
{
int ret = 0;
uint8_t *value = command;
uint8_t rmc_enable = 0;
int status;
mac_handle_t mac_handle;
if (QDF_SAP_MODE != adapter->device_mode) {
hdd_err("Received SETRMCENABLE cmd in invalid mode %s(%d)",
qdf_opmode_str(adapter->device_mode),
adapter->device_mode);
hdd_err("SETRMCENABLE cmd is allowed only in SOFTAP mode");
ret = -EINVAL;
goto exit;
}
status = hdd_parse_setrmcenable_command(value, &rmc_enable);
if (status) {
hdd_err("Invalid SETRMCENABLE command");
ret = -EINVAL;
goto exit;
}
hdd_debug("rmc_enable %d", rmc_enable);
mac_handle = hdd_ctx->mac_handle;
if (true == rmc_enable) {
status = sme_enable_rmc(mac_handle, adapter->vdev_id);
} else if (false == rmc_enable) {
status = sme_disable_rmc(mac_handle, adapter->vdev_id);
} else {
hdd_err("Invalid SETRMCENABLE command %d", rmc_enable);
ret = -EINVAL;
goto exit;
}
if (QDF_STATUS_SUCCESS != status) {
hdd_err("SETRMC %d failed status %d", rmc_enable, status);
ret = -EINVAL;
goto exit;
}
exit:
return ret;
}
static int drv_cmd_set_rmc_action_period(struct hdd_adapter *adapter,
struct hdd_context *hdd_ctx,
uint8_t *command,
uint8_t command_len,
struct hdd_priv_data *priv_data)
{
int ret = 0;
uint8_t *value = command;
uint32_t action_period = 0;
int status;
mac_handle_t mac_handle;
if (QDF_SAP_MODE != adapter->device_mode) {
hdd_err("Received SETRMC cmd in invalid mode %s(%d)",
qdf_opmode_str(adapter->device_mode),
adapter->device_mode);
hdd_err("SETRMC cmd is allowed only in SOFTAP mode");
ret = -EINVAL;
goto exit;
}
status = hdd_parse_setrmcactionperiod_command(value, &action_period);
if (status) {
hdd_err("Invalid SETRMCACTIONPERIOD command");
ret = -EINVAL;
goto exit;
}
hdd_debug("action_period %d", action_period);
mac_handle = hdd_ctx->mac_handle;
if (ucfg_mlme_set_rmc_action_period_freq(hdd_ctx->psoc,
action_period) !=
QDF_STATUS_SUCCESS) {
hdd_err("Could not set SETRMCACTIONPERIOD %d", action_period);
ret = -EINVAL;
goto exit;
}
status = sme_send_rmc_action_period(mac_handle,
adapter->vdev_id);
if (QDF_STATUS_SUCCESS != status) {
hdd_err("Could not send cesium enable indication %d",
status);
ret = -EINVAL;
goto exit;
}
exit:
return ret;
}
static int drv_cmd_set_rmc_tx_rate(struct hdd_adapter *adapter,
struct hdd_context *hdd_ctx,
uint8_t *command,
uint8_t command_len,
struct hdd_priv_data *priv_data)
{
int ret = 0;
uint8_t *value = command;
uint32_t rate = 0;
enum tx_rate_info tx_flags = 0;
tSirRateUpdateInd params = {0};
int status;
bool bval = false;
if (QDF_SAP_MODE != adapter->device_mode) {
hdd_err("Received SETRMCTXRATE cmd in invalid mode %s(%d)",
qdf_opmode_str(adapter->device_mode),
adapter->device_mode);
hdd_err("SETRMCTXRATE cmd is allowed only in SOFTAP mode");
ret = -EINVAL;
goto exit;
}
status = hdd_parse_setrmcrate_command(value, &rate, &tx_flags);
if (status) {
hdd_err("Invalid SETRMCTXRATE command");
ret = -EINVAL;
goto exit;
}
hdd_debug("rate %d", rate);
/*
* Fill the user specifieed RMC rate param
* and the derived tx flags.
*/
status = ucfg_mlme_get_vht_enable2x2(hdd_ctx->psoc, &bval);
if (!QDF_IS_STATUS_SUCCESS(status)) {
hdd_err("unable to get vht_enable2x2");
ret = -EINVAL;
goto exit;
}
params.nss = (bval == 0) ? 0 : 1;
params.reliableMcastDataRate = rate;
params.reliableMcastDataRateTxFlag = tx_flags;
params.dev_mode = adapter->device_mode;
params.bcastDataRate = -1;
memcpy(params.bssid.bytes,
adapter->mac_addr.bytes,
sizeof(params.bssid));
status = sme_send_rate_update_ind(hdd_ctx->mac_handle,
&params);
exit:
return ret;
}
#endif /* FEATURE_WLAN_RMC */
#ifdef FEATURE_WLAN_ESE
static int drv_cmd_set_ccx_roam_scan_channels(struct hdd_adapter *adapter,
struct hdd_context *hdd_ctx,
@@ -7173,11 +6869,6 @@ static const struct hdd_drv_cmd hdd_drv_cmds[] = {
{"GETDWELLTIME", drv_cmd_get_dwell_time, false},
{"SETDWELLTIME", drv_cmd_set_dwell_time, true},
{"MIRACAST", drv_cmd_miracast, true},
#ifdef FEATURE_WLAN_RMC
{"SETRMCENABLE", drv_cmd_set_rmc_enable, true},
{"SETRMCACTIONPERIOD", drv_cmd_set_rmc_action_period, true},
{"SETRMCTXRATE", drv_cmd_set_rmc_tx_rate, true},
#endif
#ifdef FEATURE_WLAN_ESE
{"SETCCXROAMSCANCHANNELS", drv_cmd_set_ccx_roam_scan_channels, true},
{"GETTSMSTATS", drv_cmd_get_tsm_stats, true},

46
core/mac/inc/sir_api.h
Datei anzeigen

@@ -1433,14 +1433,6 @@ typedef struct sAniDHCPStopInd {
struct qdf_mac_addr peerMacAddr;
} tAniDHCPInd, *tpAniDHCPInd;
typedef struct sAniTXFailMonitorInd {
uint16_t msgType; /* message type is same as the request type */
uint16_t msgLen; /* length of the entire request */
uint8_t tx_fail_count;
void *txFailIndCallback;
} tAniTXFailMonitorInd, *tpAniTXFailMonitorInd;
/**********************PE Statistics end*************************/
typedef struct sSirP2PNoaAttr {
@@ -2671,44 +2663,6 @@ typedef struct sSirDelPeriodicTxPtrn {
uint8_t ucPtrnId; /* Pattern ID */
} tSirDelPeriodicTxPtrn, *tpSirDelPeriodicTxPtrn;
/*---------------------------------------------------------------------------
* tSirIbssGetPeerInfoReqParams
*--------------------------------------------------------------------------*/
typedef struct {
bool allPeerInfoReqd; /* If set, all IBSS peers stats are reported */
struct qdf_mac_addr peer_mac;
/* of peer with staIdx is reported */
} tSirIbssGetPeerInfoReqParams, *tpSirIbssGetPeerInfoReqParams;
/**
* typedef struct - tSirIbssGetPeerInfoParams
* @mac_addr: mac address received from target
* @txRate: TX rate
* @mcsIndex: MCS index
* @rssi: RSSI
*/
typedef struct {
uint8_t mac_addr[QDF_MAC_ADDR_SIZE];
uint32_t txRate;
uint32_t mcsIndex;
int8_t rssi;
} tSirIbssPeerInfoParams;
typedef struct {
uint32_t status;
uint8_t numPeers;
tSirIbssPeerInfoParams peerInfoParams[32];
} tSirPeerInfoRspParams, *tpSirIbssPeerInfoRspParams;
/*---------------------------------------------------------------------------
* tSirIbssGetPeerInfoRspParams
*--------------------------------------------------------------------------*/
typedef struct {
uint16_t mesgType;
uint16_t mesgLen;
tSirPeerInfoRspParams ibssPeerInfoRspParams;
} tSirIbssGetPeerInfoRspParams, *tpSirIbssGetPeerInfoRspParams;
#ifdef WLAN_FEATURE_EXTWOW_SUPPORT
typedef struct {
uint16_t mesgType;

1
core/mac/inc/wni_api.h
Datei anzeigen

@@ -136,7 +136,6 @@ enum eWniMsgTypes {
eWNI_SME_HANDOFF_REQ = SIR_SME_MSG_TYPES_BEGIN + 77,
/*Fwd the LFR scan offload rsp from FW to SME */
eWNI_SME_ROAM_SCAN_OFFLOAD_RSP = SIR_SME_MSG_TYPES_BEGIN + 78,
eWNI_SME_IBSS_PEER_INFO_RSP = SIR_SME_MSG_TYPES_BEGIN + 79,
eWNI_SME_GET_TSM_STATS_REQ = SIR_SME_MSG_TYPES_BEGIN + 80,
eWNI_SME_GET_TSM_STATS_RSP = SIR_SME_MSG_TYPES_BEGIN + 81,
eWNI_SME_TSM_IE_IND = SIR_SME_MSG_TYPES_BEGIN + 82,

12
core/mac/src/include/sir_params.h
Datei anzeigen

@@ -96,7 +96,6 @@ typedef enum {
* DOT11AX - indicate 11ax
* WOW - indicate WOW
* WLAN_ROAM_SCAN_OFFLOAD - indicate Roam scan offload
* IBSS_HEARTBEAT_OFFLOAD - indicate IBSS HB offload
* WLAN_PERIODIC_TX_PTRN - indicate WLAN_PERIODIC_TX_PTRN
* ADVANCE_TDLS - indicate advanced TDLS
* TDLS_OFF_CHANNEL - indicate TDLS off channel
@@ -126,7 +125,6 @@ enum cap_bitmap {
DOT11AX = 13,
WOW = 22,
WLAN_ROAM_SCAN_OFFLOAD = 23,
IBSS_HEARTBEAT_OFFLOAD = 26,
WLAN_PERIODIC_TX_PTRN = 28,
#ifdef FEATURE_WLAN_TDLS
ADVANCE_TDLS = 29,
@@ -380,9 +378,6 @@ struct sir_cfg_action_frm_tb_ppdu {
#define SIR_HAL_PDEV_DUAL_MAC_CFG_REQ (SIR_HAL_ITC_MSG_TYPES_BEGIN + 154)
#define SIR_HAL_PDEV_MAC_CFG_RESP (SIR_HAL_ITC_MSG_TYPES_BEGIN + 155)
/* For IBSS peer info related messages */
#define SIR_HAL_IBSS_PEER_INFO_REQ (SIR_HAL_ITC_MSG_TYPES_BEGIN + 158)
#define SIR_HAL_RATE_UPDATE_IND (SIR_HAL_ITC_MSG_TYPES_BEGIN + 159)
#define SIR_HAL_FLUSH_LOG_TO_FW (SIR_HAL_ITC_MSG_TYPES_BEGIN + 160)
@@ -404,8 +399,6 @@ struct sir_cfg_action_frm_tb_ppdu {
#define SIR_HAL_SET_MAX_TX_POWER_PER_BAND_REQ \
(SIR_HAL_ITC_MSG_TYPES_BEGIN + 170)
#define SIR_HAL_TX_FAIL_MONITOR_IND (SIR_HAL_ITC_MSG_TYPES_BEGIN + 171)
#define SIR_HAL_UPDATE_MEMBERSHIP (SIR_HAL_ITC_MSG_TYPES_BEGIN + 172)
#define SIR_HAL_UPDATE_USERPOS (SIR_HAL_ITC_MSG_TYPES_BEGIN + 173)
@@ -421,11 +414,6 @@ struct sir_cfg_action_frm_tb_ppdu {
#define SIR_HAL_BEACON_TX_SUCCESS_IND (SIR_HAL_ITC_MSG_TYPES_BEGIN + 179)
/* (SIR_HAL_ITC_MSG_TYPES_BEGIN + 180) is unused */
#define SIR_HAL_IBSS_CESIUM_ENABLE_IND (SIR_HAL_ITC_MSG_TYPES_BEGIN + 181)
#define SIR_HAL_RMC_ENABLE_IND (SIR_HAL_ITC_MSG_TYPES_BEGIN + 182)
#define SIR_HAL_RMC_DISABLE_IND (SIR_HAL_ITC_MSG_TYPES_BEGIN + 183)
#define SIR_HAL_RMC_ACTION_PERIOD_IND (SIR_HAL_ITC_MSG_TYPES_BEGIN + 184)
#define SIR_HAL_INIT_THERMAL_INFO_CMD (SIR_HAL_ITC_MSG_TYPES_BEGIN + 185)
#define SIR_HAL_SET_THERMAL_LEVEL (SIR_HAL_ITC_MSG_TYPES_BEGIN + 186)

9
core/mac/src/sys/legacy/src/utils/src/mac_trace.c
Datei anzeigen

@@ -270,7 +270,6 @@ uint8_t *mac_trace_get_sme_msg_string(uint16_t sme_msg)
CASE_RETURN_STRING(eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP);
#endif /* WLAN_FEATURE_GTK_OFFLOAD */
CASE_RETURN_STRING(eWNI_SME_ROAM_SCAN_OFFLOAD_RSP);
CASE_RETURN_STRING(eWNI_SME_IBSS_PEER_INFO_RSP);
CASE_RETURN_STRING(eWNI_SME_DFS_RADAR_FOUND);
CASE_RETURN_STRING(eWNI_SME_CHANNEL_CHANGE_REQ);
CASE_RETURN_STRING(eWNI_SME_CHANNEL_CHANGE_RSP);
@@ -494,14 +493,6 @@ uint8_t *mac_trace_get_wma_msg_string(uint16_t wma_msg)
#endif
#ifdef FEATURE_WLAN_AUTO_SHUTDOWN
CASE_RETURN_STRING(WMA_SET_AUTO_SHUTDOWN_TIMER_REQ);
#endif
CASE_RETURN_STRING(WMA_IBSS_CESIUM_ENABLE_IND);
CASE_RETURN_STRING(WMA_GET_IBSS_PEER_INFO_REQ);
CASE_RETURN_STRING(WMA_TX_FAIL_MONITOR_IND);
#ifdef FEATURE_WLAN_RMC
CASE_RETURN_STRING(WMA_RMC_ENABLE_IND);
CASE_RETURN_STRING(WMA_RMC_DISABLE_IND);
CASE_RETURN_STRING(WMA_RMC_ACTION_PERIOD_IND);
#endif
CASE_RETURN_STRING(WMA_INIT_THERMAL_INFO_CMD);
CASE_RETURN_STRING(WMA_SET_THERMAL_LEVEL);

3
core/sme/inc/csr_api.h
Datei anzeigen

@@ -318,8 +318,7 @@ typedef enum {
*/
eCSR_ROAM_MIC_ERROR_IND,
/*
* Update the connection status, useful for IBSS: new peer added,
* network is active etc.
* Update the connection status network is active etc.
*/
eCSR_ROAM_CONNECT_STATUS_UPDATE,
eCSR_ROAM_GEN_INFO,

10
core/sme/inc/csr_internal.h
Datei anzeigen

@@ -39,7 +39,7 @@
#define CSR_ROAM_SCAN_CHANNEL_SWITCH_TIME 3
/* No of sessions to be supported, and a session is for Infra, IBSS or BT-AMP */
/* No of sessions to be supported, and a session is for Infra, BT-AMP */
#define CSR_IS_SESSION_VALID(mac, sessionId) \
((sessionId) < WLAN_MAX_VDEVS && \
(mac)->roam.roamSession[(sessionId)].sessionActive)
@@ -220,7 +220,7 @@ struct csr_roamstart_bssparams {
/*
* This is the BSSID for the party we want to
* join (only use for IBSS or WDS).
* join (only use for WDS).
*/
struct qdf_mac_addr bssid;
tSirNwType sirNwType;
@@ -540,12 +540,12 @@ struct csr_roam_session {
bool fRoaming;
/*
* to remember some parameters needed for START_BSS.
* All member must be set every time we try to join or start an IBSS
* All member must be set every time we try to join
*/
struct csr_roamstart_bssparams bssParams;
/* the byte count of pWpaRsnIE; */
uint32_t nWpaRsnReqIeLength;
/* contain the WPA/RSN IE in assoc req or one sent in beacon(IBSS) */
/* contain the WPA/RSN IE in assoc req */
uint8_t *pWpaRsnReqIE;
/* the byte count for pWpaRsnRspIE */
uint32_t nWpaRsnRspIeLength;
@@ -554,7 +554,7 @@ struct csr_roam_session {
#ifdef FEATURE_WLAN_WAPI
/* the byte count of pWapiReqIE; */
uint32_t nWapiReqIeLength;
/* this contain the WAPI IE in assoc req or one sent in beacon (IBSS) */
/* this contain the WAPI IE in assoc req */
uint8_t *pWapiReqIE;
/* the byte count for pWapiRspIE */
uint32_t nWapiRspIeLength;

13
core/sme/inc/sme_api.h
Datei anzeigen

@@ -753,9 +753,6 @@ QDF_STATUS sme_generic_change_country_code(mac_handle_t mac_handle,
*/
QDF_STATUS sme_update_channel_list(mac_handle_t mac_handle);
QDF_STATUS sme_tx_fail_monitor_start_stop_ind(mac_handle_t mac_handle,
uint8_t tx_fail_count,
void *txFailIndCallback);
QDF_STATUS sme_dhcp_start_ind(mac_handle_t mac_handle,
uint8_t device_mode,
uint8_t *macAddr, uint8_t sessionId);
@@ -1205,16 +1202,6 @@ QDF_STATUS sme_roam_del_pmkid_from_cache(mac_handle_t mac_handle,
void sme_get_command_q_status(mac_handle_t mac_handle);
#ifdef FEATURE_WLAN_RMC
QDF_STATUS sme_enable_rmc(mac_handle_t mac_handle, uint32_t sessionId);
QDF_STATUS sme_disable_rmc(mac_handle_t mac_handle, uint32_t sessionId);
QDF_STATUS sme_send_rmc_action_period(mac_handle_t mac_handle,
uint32_t sessionId);
#endif
QDF_STATUS sme_send_cesium_enable_ind(mac_handle_t mac_handle,
uint32_t sessionId);
/**
* sme_set_wlm_latency_level_ind() - Used to set the latency level to fw
* @mac_handle

181
core/sme/src/common/sme_api.c
Datei anzeigen

@@ -3650,58 +3650,6 @@ QDF_STATUS sme_dhcp_stop_ind(mac_handle_t mac_handle,
return status;
}
/*
* sme_TXFailMonitorStopInd() -
* API to signal the FW to start monitoring TX failures
*
* Return QDF_STATUS SUCCESS.
* FAILURE or RESOURCES The API finished and failed.
*/
QDF_STATUS sme_tx_fail_monitor_start_stop_ind(mac_handle_t mac_handle,
uint8_t tx_fail_count,
void *txFailIndCallback)
{
QDF_STATUS status;
QDF_STATUS qdf_status;
struct mac_context *mac = MAC_CONTEXT(mac_handle);
struct scheduler_msg message = {0};
tAniTXFailMonitorInd *pMsg;
status = sme_acquire_global_lock(&mac->sme);
if (QDF_STATUS_SUCCESS == status) {
pMsg = qdf_mem_malloc(sizeof(tAniTXFailMonitorInd));
if (!pMsg) {
sme_release_global_lock(&mac->sme);
return QDF_STATUS_E_NOMEM;
}
pMsg->msgType = WMA_TX_FAIL_MONITOR_IND;
pMsg->msgLen = (uint16_t) sizeof(tAniTXFailMonitorInd);
/* tx_fail_count = 0 should disable the Monitoring in FW */
pMsg->tx_fail_count = tx_fail_count;
pMsg->txFailIndCallback = txFailIndCallback;
message.type = WMA_TX_FAIL_MONITOR_IND;
message.bodyptr = pMsg;
message.reserved = 0;
qdf_status = scheduler_post_message(QDF_MODULE_ID_SME,
QDF_MODULE_ID_WMA,
QDF_MODULE_ID_WMA,
&message);
if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
"%s: Post TX Fail monitor Start MSG fail",
__func__);
qdf_mem_free(pMsg);
status = QDF_STATUS_E_FAILURE;
}
sme_release_global_lock(&mac->sme);
}
return status;
}
/*
* sme_neighbor_report_request() -
* API to request neighbor report.
@@ -4695,7 +4643,7 @@ QDF_STATUS sme_set_keep_alive(mac_handle_t mac_handle, uint8_t session_id,
/*
* sme_get_operation_channel() -
* API to get current channel on which STA is parked his function gives
* channel information only of infra station or IBSS station
* channel information only of infra station
*
* mac_handle, pointer to memory location and sessionId
* Returns QDF_STATUS_SUCCESS
@@ -8010,133 +7958,6 @@ sme_del_periodic_tx_ptrn(mac_handle_t mac_handle,
return status;
}
#ifdef FEATURE_WLAN_RMC
/*
* sme_enable_rmc() - enables RMC
* @mac_handle: Opaque handle to the global MAC context
* @sessionId : Session ID
*
* Return: QDF_STATUS
*/
QDF_STATUS sme_enable_rmc(mac_handle_t mac_handle, uint32_t sessionId)
{
QDF_STATUS status = QDF_STATUS_E_FAILURE;
struct mac_context *mac = MAC_CONTEXT(mac_handle);
struct scheduler_msg message = {0};
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
SME_ENTER();
status = sme_acquire_global_lock(&mac->sme);
if (QDF_IS_STATUS_SUCCESS(status)) {
message.bodyptr = NULL;
message.type = WMA_RMC_ENABLE_IND;
qdf_status = scheduler_post_message(QDF_MODULE_ID_SME,
QDF_MODULE_ID_WMA,
QDF_MODULE_ID_WMA,
&message);
if (!QDF_IS_STATUS_SUCCESS(qdf_status))
status = QDF_STATUS_E_FAILURE;
sme_release_global_lock(&mac->sme);
}
return status;
}
/*
* sme_disable_rmc() - disables RMC
* @mac_handle: Opaque handle to the global MAC context
* @sessionId : Session ID
*
* Return: QDF_STATUS
*/
QDF_STATUS sme_disable_rmc(mac_handle_t mac_handle, uint32_t sessionId)
{
QDF_STATUS status = QDF_STATUS_E_FAILURE;
struct mac_context *mac = MAC_CONTEXT(mac_handle);
struct scheduler_msg message = {0};
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
SME_ENTER();
status = sme_acquire_global_lock(&mac->sme);
if (QDF_IS_STATUS_SUCCESS(status)) {
message.bodyptr = NULL;
message.type = WMA_RMC_DISABLE_IND;
qdf_status = scheduler_post_message(QDF_MODULE_ID_SME,
QDF_MODULE_ID_WMA,
QDF_MODULE_ID_WMA,
&message);
if (!QDF_IS_STATUS_SUCCESS(qdf_status))
status = QDF_STATUS_E_FAILURE;
sme_release_global_lock(&mac->sme);
}
return status;
}
/*
* sme_send_rmc_action_period() - sends RMC action period param to target
* @mac_handle: Opaque handle to the global MAC context
* @sessionId : Session ID
*
* Return: QDF_STATUS
*/
QDF_STATUS sme_send_rmc_action_period(mac_handle_t mac_handle,
uint32_t sessionId)
{
QDF_STATUS status = QDF_STATUS_SUCCESS;
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
struct mac_context *mac = MAC_CONTEXT(mac_handle);
struct scheduler_msg message = {0};
status = sme_acquire_global_lock(&mac->sme);
if (QDF_STATUS_SUCCESS == status) {
message.bodyptr = NULL;
message.type = WMA_RMC_ACTION_PERIOD_IND;
qdf_status = scheduler_post_message(QDF_MODULE_ID_SME,
QDF_MODULE_ID_WMA,
QDF_MODULE_ID_WMA,
&message);
if (!QDF_IS_STATUS_SUCCESS(qdf_status))
status = QDF_STATUS_E_FAILURE;
sme_release_global_lock(&mac->sme);
}
return status;
}
#endif /* FEATURE_WLAN_RMC */
/*
* sme_send_cesium_enable_ind() -
* Used to send proprietary cesium enable indication to fw
*
* mac_handle
* sessionId
* Return QDF_STATUS
*/
QDF_STATUS sme_send_cesium_enable_ind(mac_handle_t mac_handle,
uint32_t sessionId)
{
QDF_STATUS status = QDF_STATUS_SUCCESS;
struct mac_context *mac = MAC_CONTEXT(mac_handle);
struct scheduler_msg message = {0};
status = sme_acquire_global_lock(&mac->sme);
if (QDF_STATUS_SUCCESS == status) {
message.bodyptr = NULL;
message.type = WMA_IBSS_CESIUM_ENABLE_IND;
status = scheduler_post_message(QDF_MODULE_ID_SME,
QDF_MODULE_ID_WMA,
QDF_MODULE_ID_WMA,
&message);
sme_release_global_lock(&mac->sme);
}
return status;
}
QDF_STATUS sme_set_wlm_latency_level(mac_handle_t mac_handle,
uint16_t session_id,
uint16_t latency_level)

16
core/sme/src/csr/csr_api_roam.c
Datei anzeigen

@@ -3935,7 +3935,7 @@ QDF_STATUS csr_roam_save_connected_bss_desc(struct mac_context *mac,
return QDF_STATUS_E_FAILURE;
}
/* If no BSS description was found in this connection
* (happens with start IBSS), then nix the BSS description
* , then nix the BSS description
* that we keep around for the connected BSS) and get out.
*/
if (!bss_desc) {
@@ -4219,7 +4219,6 @@ QDF_STATUS csr_roam_prepare_bss_config_from_profile(
} else {
pBssConfig->uShortSlotTime = 0;
}
/* power constraint. We don't support 11h on IBSS */
pBssConfig->f11hSupport = false;
pBssConfig->uPowerLimit = 0;
/* heartbeat */
@@ -5069,7 +5068,7 @@ QDF_STATUS csr_roam_stop_network(struct mac_context *mac, uint32_t sessionId,
false);
} else if (bss_desc || CSR_IS_INFRA_AP(roam_profile)) {
/*
* Neither in IBSS nor in Infra. We can go ahead and set
* Not in Infra. We can go ahead and set
* the cfg for tne new network... nothing to stop.
*/
bool is_11r_roaming = false;
@@ -6944,7 +6943,6 @@ static void csr_roam_process_start_bss_success(struct mac_context *mac_ctx,
roam_info->status_code =
session->joinFailStatusCode.status_code;
roam_info->reasonCode = session->joinFailStatusCode.reasonCode;
/* We start the IBSS (didn't find any matched IBSS out there) */
roam_info->bss_desc = bss_desc;
if (bss_desc)
qdf_mem_copy(roam_info->bssid.bytes, bss_desc->bssId,
@@ -10008,11 +10006,7 @@ void csr_roam_roaming_state_disassoc_rsp_processor(struct mac_context *mac,
/*
* Successfully disassociated from the 'old' Bss.
* We get Disassociate response in three conditions.
* 1) The case where we are disasociating from an Infra
* Bss to start an IBSS.
* 2) When we are disassociating from an Infra Bss to
* join an IBSS or a new infra network.
* 3) Where we are doing an Infra to Infra roam between
* Where we are doing an Infra to Infra roam between
* networks with different SSIDs.
* In all cases, we set the new Bss configuration here
* and attempt to join
@@ -13063,7 +13057,7 @@ csr_compute_mode_and_band(struct mac_context *mac_ctx,
* Auto=Global. dot11Mode && profile->channel is < 14,
* then start the IBSS in b mode.
*
* Note: we used to have this start as an 11g IBSS for
* Note: we used to have this start as for
* best performance. now to specify that the user will
* have to set the do11Mode in the property page to 11g
* to force it.
@@ -13969,7 +13963,7 @@ void csr_roam_prepare_bss_params(struct mac_context *mac, uint32_t sessionId,
pProfile->op_freq = pSession->bssParams.operation_chan_freq;
if (pProfile->op_freq == 0)
sme_err("CSR cannot find a channel to start IBSS");
sme_err("CSR cannot find a channel to start");
else {
csr_roam_determine_max_rate_for_ad_hoc(mac,
&pSession->bssParams.

4
core/sme/src/csr/csr_cmd_process.c
Datei anzeigen

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2011-2019 The Linux Foundation. All rights reserved.
* Copyright (c) 2011-2020 The Linux Foundation. All rights reserved.
*
* Permission to use, copy, modify, and/or distribute this software for
* any purpose with or without fee is hereby granted, provided that the
@@ -78,7 +78,7 @@ QDF_STATUS csr_msg_processor(struct mac_context *mac_ctx, void *msg_buf)
* To work-around an issue where checking for set/remove
* key base on connection state is no longer workable
* due to failure or finding the condition meets both
* SAP and infra/IBSS requirement.
* SAP and infra requirement.
*/
if (eWNI_SME_SETCONTEXT_RSP == sme_rsp->messageType ||
eWNI_SME_DISCONNECT_DONE_IND ==

4
core/wma/inc/wma.h
Datei anzeigen

@@ -410,9 +410,6 @@
*/
#define PROBE_REQ_TX_TIME_GAP 20
typedef void (*txFailIndCallback)(uint8_t *peer_mac, uint8_t seqNo);
/**
* enum wma_rx_exec_ctx - wma rx execution context
* @WMA_RX_WORK_CTX: work queue context execution
@@ -1007,7 +1004,6 @@ typedef struct {
bool enable_mc_list;
uint8_t ibss_started;
tSetBssKeyParams ibsskey_info;
txFailIndCallback hddTxFailCb;
#ifdef FEATURE_WLAN_EXTSCAN
qdf_wake_lock_t extscan_wake_lock;
#endif

65
core/wma/inc/wma_internal.h
Datei anzeigen

@@ -680,18 +680,6 @@ void wma_adjust_ibss_heart_beat_timer(tp_wma_handle wma,
QDF_STATUS
wma_set_ibss_pwrsave_params(tp_wma_handle wma, uint8_t vdev_id);
/**
* wma_ibss_peer_info_event_handler() - IBSS peer info event handler
* @handle: wma handle
* @data: event data
* @len: length of data
*
* This function handles IBSS peer info event from FW.
*
* Return: 0 for success or error code
*/
int wma_ibss_peer_info_event_handler(void *handle, uint8_t *data,
uint32_t len);
#else
/**
* wma_is_vdev_in_ibss_mode(): dummy function
@@ -723,22 +711,6 @@ wma_adjust_ibss_heart_beat_timer(tp_wma_handle wma,
{
}
/**
* wma_ibss_peer_info_event_handler() - IBSS peer info event handler
* @handle: wma handle
* @data: event data
* @len: length of data
*
* This function is dummy
*
* Return: 0 for success or error code
*/
static inline int
wma_ibss_peer_info_event_handler(void *handle, uint8_t *data,
uint32_t len)
{
return 0;
}
/**
* wma_set_ibss_pwrsave_params() - set ibss power save parameter to fw
@@ -1216,10 +1188,6 @@ QDF_STATUS wma_set_thermal_mgmt(tp_wma_handle wma_handle,
int wma_thermal_mgmt_evt_handler(void *handle, uint8_t *event,
uint32_t len);
int wma_fast_tx_fail_event_handler(void *handle, uint8_t *data,
uint32_t len);
/*
* wma_utils.c functions declarations
*/
@@ -1443,39 +1411,6 @@ void wma_config_plm(tp_wma_handle wma, struct plm_req_params *plm);
QDF_STATUS wma_process_mcbc_set_filter_req(tp_wma_handle wma_handle,
tSirRcvFltMcAddrList * mcbc_param);
QDF_STATUS wma_process_cesium_enable_ind(tp_wma_handle wma);
QDF_STATUS wma_process_get_peer_info_req
(tp_wma_handle wma, tSirIbssGetPeerInfoReqParams *pReq);
QDF_STATUS wma_process_tx_fail_monitor_ind
(tp_wma_handle wma, tAniTXFailMonitorInd *pReq);
#ifdef FEATURE_WLAN_RMC
QDF_STATUS wma_process_rmc_enable_ind(tp_wma_handle wma);
QDF_STATUS wma_process_rmc_disable_ind(tp_wma_handle wma);
QDF_STATUS wma_process_rmc_action_period_ind(tp_wma_handle wma);
#else
static inline
QDF_STATUS wma_process_rmc_enable_ind(tp_wma_handle wma)
{
return QDF_STATUS_SUCCESS;
}
static inline
QDF_STATUS wma_process_rmc_disable_ind(tp_wma_handle wma)
{
return QDF_STATUS_SUCCESS;
}
static inline
QDF_STATUS wma_process_rmc_action_period_ind(tp_wma_handle wma)
{
return QDF_STATUS_SUCCESS;
}
#endif
QDF_STATUS wma_process_add_periodic_tx_ptrn_ind(WMA_HANDLE handle,
tSirAddPeriodicTxPtrn *pattern);

10
core/wma/inc/wma_types.h
Datei anzeigen

@@ -241,8 +241,6 @@
#define WMA_DHCP_START_IND SIR_HAL_DHCP_START_IND
#define WMA_DHCP_STOP_IND SIR_HAL_DHCP_STOP_IND
#define WMA_TX_FAIL_MONITOR_IND SIR_HAL_TX_FAIL_MONITOR_IND
#ifdef WLAN_FEATURE_GTK_OFFLOAD
#define WMA_GTK_OFFLOAD_REQ SIR_HAL_GTK_OFFLOAD_REQ
#define WMA_GTK_OFFLOAD_GETINFO_REQ SIR_HAL_GTK_OFFLOAD_GETINFO_REQ
@@ -295,14 +293,6 @@
#define WMA_SEND_ADDBA_REQ SIR_HAL_SEND_ADDBA_REQ
#define WMA_INIT_THERMAL_INFO_CMD SIR_HAL_INIT_THERMAL_INFO_CMD
#define WMA_SET_THERMAL_LEVEL SIR_HAL_SET_THERMAL_LEVEL
#define WMA_RMC_ENABLE_IND SIR_HAL_RMC_ENABLE_IND
#define WMA_RMC_DISABLE_IND SIR_HAL_RMC_DISABLE_IND
#define WMA_RMC_ACTION_PERIOD_IND SIR_HAL_RMC_ACTION_PERIOD_IND
/* IBSS peer info related message */
#define WMA_GET_IBSS_PEER_INFO_REQ SIR_HAL_IBSS_PEER_INFO_REQ
#define WMA_IBSS_CESIUM_ENABLE_IND SIR_HAL_IBSS_CESIUM_ENABLE_IND
#define WMA_INIT_BAD_PEER_TX_CTL_INFO_CMD SIR_HAL_BAD_PEER_TX_CTL_INI_CMD

134
core/wma/src/wma_data.c
Datei anzeigen

@@ -2060,140 +2060,6 @@ int wma_thermal_mgmt_evt_handler(void *handle, uint8_t *event, uint32_t len)
return 0;
}
#ifdef QCA_IBSS_SUPPORT
int wma_ibss_peer_info_event_handler(void *handle, uint8_t *data,
uint32_t len)
{
struct scheduler_msg cds_msg = {0};
wmi_peer_info *peer_info;
tSirIbssPeerInfoParams *pSmeRsp;
uint32_t count, num_peers, status;
tSirIbssGetPeerInfoRspParams *pRsp;
WMI_PEER_INFO_EVENTID_param_tlvs *param_tlvs;
wmi_peer_info_event_fixed_param *fix_param;
uint8_t peer_mac[QDF_MAC_ADDR_SIZE];
tp_wma_handle wma = (tp_wma_handle)handle;
if (!wma) {
WMA_LOGE("Invalid wma");
return 0;
}
param_tlvs = (WMI_PEER_INFO_EVENTID_param_tlvs *) data;
fix_param = param_tlvs->fixed_param;
peer_info = param_tlvs->peer_info;
num_peers = fix_param->num_peers;
status = 0;
WMA_LOGE("%s: num_peers %d", __func__, num_peers);
pRsp = qdf_mem_malloc(sizeof(tSirIbssGetPeerInfoRspParams));
if (!pRsp)
return 0;
/*sanity check */
if (!(num_peers) || (num_peers > 32) ||
(num_peers > param_tlvs->num_peer_info) ||
(!peer_info)) {
WMA_LOGE("%s: Invalid event data from target num_peers %d peer_info %pK",
__func__, num_peers, peer_info);
status = 1;
goto send_response;
}
/*
*For displaying only connected IBSS peer info, iterate till
*last but one entry only as last entry is used for IBSS creator
*/
for (count = 0; count < num_peers-1; count++) {
pSmeRsp = &pRsp->ibssPeerInfoRspParams.peerInfoParams[count];
WMI_MAC_ADDR_TO_CHAR_ARRAY(&peer_info->peer_mac_address,
peer_mac);
qdf_mem_copy(pSmeRsp->mac_addr, peer_mac,
sizeof(pSmeRsp->mac_addr));
pSmeRsp->mcsIndex = 0;
if (wmi_service_enabled(wma->wmi_handle,
wmi_service_hw_db2dbm_support))
pSmeRsp->rssi = peer_info->rssi;
else
pSmeRsp->rssi = peer_info->rssi +
WMA_TGT_NOISE_FLOOR_DBM;
pSmeRsp->txRate = peer_info->data_rate;
wma_err("peer " QDF_MAC_ADDR_STR "rssi %d txRate %d",
QDF_MAC_ADDR_ARRAY(peer_mac),
pSmeRsp->rssi, pSmeRsp->txRate);
peer_info++;
}
send_response:
/* message header */
pRsp->mesgType = eWNI_SME_IBSS_PEER_INFO_RSP;
pRsp->mesgLen = sizeof(tSirIbssGetPeerInfoRspParams);
pRsp->ibssPeerInfoRspParams.status = status;
pRsp->ibssPeerInfoRspParams.numPeers = num_peers;
/* cds message wrapper */
cds_msg.type = eWNI_SME_IBSS_PEER_INFO_RSP;
cds_msg.bodyptr = (void *)pRsp;
cds_msg.bodyval = 0;
if (QDF_STATUS_SUCCESS !=
scheduler_post_message(QDF_MODULE_ID_WMA,
QDF_MODULE_ID_SME,
QDF_MODULE_ID_SME, &cds_msg)) {
WMA_LOGE("%s: could not post peer info rsp msg to SME",
__func__);
/* free the mem and return */
qdf_mem_free((void *)pRsp);
}
return 0;
}
#endif
/**
* wma_fast_tx_fail_event_handler() -tx failure event handler
* @handle: wma handle
* @data: event data
* @len: data length
*
* Handle fast tx failure indication event from FW
*
* Return: 0 for success or error code.
*/
int wma_fast_tx_fail_event_handler(void *handle, uint8_t *data,
uint32_t len)
{
uint8_t tx_fail_cnt;
uint8_t peer_mac[QDF_MAC_ADDR_SIZE];
tp_wma_handle wma = (tp_wma_handle) handle;
WMI_PEER_TX_FAIL_CNT_THR_EVENTID_param_tlvs *param_tlvs;
wmi_peer_tx_fail_cnt_thr_event_fixed_param *fix_param;
param_tlvs = (WMI_PEER_TX_FAIL_CNT_THR_EVENTID_param_tlvs *) data;
fix_param = param_tlvs->fixed_param;
WMI_MAC_ADDR_TO_CHAR_ARRAY(&fix_param->peer_mac_address, peer_mac);
WMA_LOGE("%s: received fast tx failure event for peer 0x:%2x:0x%2x:0x%2x:0x%2x:0x%2x:0x%2x seq No %d",
__func__,
peer_mac[0], peer_mac[1], peer_mac[2], peer_mac[3],
peer_mac[4], peer_mac[5], fix_param->seq_no);
tx_fail_cnt = fix_param->seq_no;
/*call HDD callback */
if (wma->hddTxFailCb)
wma->hddTxFailCb(peer_mac, tx_fail_cnt);
else
WMA_LOGE("%s: HDD callback is %pK", __func__, wma->hddTxFailCb);
return 0;
}
/**
* wma_decap_to_8023() - Decapsulate to 802.3 format
* @msdu: skb buffer

315
core/wma/src/wma_features.c
Datei anzeigen

@@ -2989,321 +2989,6 @@ QDF_STATUS wma_process_mcbc_set_filter_req(tp_wma_handle wma_handle,
return QDF_STATUS_SUCCESS;
}
/**
* wma_process_cesium_enable_ind() - enables cesium functionality in target
* @wma: wma handle
*
* Return: QDF status
*/
QDF_STATUS wma_process_cesium_enable_ind(tp_wma_handle wma)
{
QDF_STATUS ret;
int32_t vdev_id;
vdev_id = wma_find_vdev_by_type(wma, WMI_VDEV_TYPE_IBSS);
if (vdev_id < 0) {
WMA_LOGE("%s: IBSS vdev does not exist could not enable cesium",
__func__);
return QDF_STATUS_E_FAILURE;
}
/* Send enable cesium command to target */
WMA_LOGE("Enable cesium in target for vdevId %d ", vdev_id);
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_ENABLE_RMC, 1);
if (ret) {
WMA_LOGE("Enable cesium failed for vdevId %d", vdev_id);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
/**
* wma_process_get_peer_info_req() - sends get peer info cmd to target
* @wma: wma handle
* @preq: get peer info request
*
* Return: QDF status
*/
QDF_STATUS wma_process_get_peer_info_req
(tp_wma_handle wma, tSirIbssGetPeerInfoReqParams *pReq)
{
int32_t ret;
uint8_t *p;
uint16_t len;
wmi_buf_t buf;
int32_t vdev_id;
uint8_t pdev_id;
void *soc = cds_get_context(QDF_MODULE_ID_SOC);
uint8_t peer_mac[QDF_MAC_ADDR_SIZE];
wmi_peer_info_req_cmd_fixed_param *p_get_peer_info_cmd;
uint8_t bcast_mac[QDF_MAC_ADDR_SIZE] = { 0xff, 0xff, 0xff,
0xff, 0xff, 0xff };
if (!soc) {
WMA_LOGE("%s: SOC context is NULL", __func__);
return QDF_STATUS_E_FAILURE;
}
vdev_id = wma_find_vdev_by_type(wma, WMI_VDEV_TYPE_IBSS);
if (vdev_id < 0) {
WMA_LOGE("%s: IBSS vdev does not exist could not get peer info",
__func__);
return QDF_STATUS_E_FAILURE;
}
pdev_id = WMI_PDEV_ID_SOC;
if (pdev_id == OL_TXRX_INVALID_PDEV_ID) {
WMA_LOGE("%s: Failed to get pdev id", __func__);
return QDF_STATUS_E_FAILURE;
}
if (qdf_is_macaddr_broadcast(&pReq->peer_mac)) {
/*get info for all peers */
qdf_mem_copy(peer_mac, bcast_mac, QDF_MAC_ADDR_SIZE);
} else {
/*get info for a single peer */
if (!cdp_find_peer_exist(soc, pdev_id, pReq->peer_mac.bytes)) {
WMA_LOGE("%s: Failed to get peer handle using peer "
QDF_MAC_ADDR_STR, __func__,
QDF_MAC_ADDR_ARRAY(pReq->peer_mac.bytes));
return QDF_STATUS_E_FAILURE;
}
WMA_LOGE("%s: peer mac: " QDF_MAC_ADDR_STR, __func__,
QDF_MAC_ADDR_ARRAY(pReq->peer_mac.bytes));
qdf_mem_copy(peer_mac, pReq->peer_mac.bytes, QDF_MAC_ADDR_SIZE);
}
len = sizeof(wmi_peer_info_req_cmd_fixed_param);
buf = wmi_buf_alloc(wma->wmi_handle, len);
if (!buf)
return QDF_STATUS_E_FAILURE;
p = (uint8_t *) wmi_buf_data(buf);
qdf_mem_zero(p, len);
p_get_peer_info_cmd = (wmi_peer_info_req_cmd_fixed_param *) p;
WMITLV_SET_HDR(&p_get_peer_info_cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_peer_info_req_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_peer_info_req_cmd_fixed_param));
p_get_peer_info_cmd->vdev_id = vdev_id;
WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_mac,
&p_get_peer_info_cmd->peer_mac_address);
ret = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
WMI_PEER_INFO_REQ_CMDID);
if (ret != QDF_STATUS_SUCCESS)
wmi_buf_free(buf);
WMA_LOGE("IBSS get peer info cmd sent len: %d, vdev %d command id: %d, status: %d",
len, vdev_id, WMI_PEER_INFO_REQ_CMDID, ret);
return QDF_STATUS_SUCCESS;
}
/**
* wma_process_tx_fail_monitor_ind() - sends tx fail monitor cmd to target
* @wma: wma handle
* @pReq: tx fail monitor command params
*
* Return: QDF status
*/
QDF_STATUS wma_process_tx_fail_monitor_ind(tp_wma_handle wma,
tAniTXFailMonitorInd *pReq)
{
QDF_STATUS ret;
int32_t vdev_id;
vdev_id = wma_find_vdev_by_type(wma, WMI_VDEV_TYPE_IBSS);
if (vdev_id < 0) {
WMA_LOGE("%s: IBSS vdev does not exist could not send fast tx fail monitor indication message to target",
__func__);
return QDF_STATUS_E_FAILURE;
}
/* Send enable cesium command to target */
WMA_LOGE("send fast tx fail monitor ind cmd target for vdevId %d val %d",
vdev_id, pReq->tx_fail_count);
if (pReq->tx_fail_count == 0)
wma->hddTxFailCb = NULL;
else
wma->hddTxFailCb = pReq->txFailIndCallback;
ret = wma_vdev_set_param(wma->wmi_handle, vdev_id,
WMI_VDEV_PARAM_SET_IBSS_TX_FAIL_CNT_THR,
pReq->tx_fail_count);
if (ret) {
WMA_LOGE("tx fail monitor failed for vdevId %d", vdev_id);
return QDF_STATUS_E_FAILURE;
}
return QDF_STATUS_SUCCESS;
}
#ifdef FEATURE_WLAN_RMC
/**
* wma_process_rmc_enable_ind() - enables RMC functionality in target
* @wma: wma handle
*
* Return: QDF status
*/
QDF_STATUS wma_process_rmc_enable_ind(tp_wma_handle wma)
{
int ret;
uint8_t *p;
uint16_t len;
wmi_buf_t buf;
int32_t vdev_id;
wmi_rmc_set_mode_cmd_fixed_param *p_rmc_enable_cmd;
vdev_id = wma_find_vdev_by_type(wma, WMI_VDEV_TYPE_IBSS);
if (vdev_id < 0) {
WMA_LOGE("%s: IBSS vdev does not exist could not enable RMC",
__func__);
return QDF_STATUS_E_FAILURE;
}
len = sizeof(wmi_rmc_set_mode_cmd_fixed_param);
buf = wmi_buf_alloc(wma->wmi_handle, len);
if (!buf)
return QDF_STATUS_E_FAILURE;
p = (uint8_t *) wmi_buf_data(buf);
qdf_mem_zero(p, len);
p_rmc_enable_cmd = (wmi_rmc_set_mode_cmd_fixed_param *) p;
WMITLV_SET_HDR(&p_rmc_enable_cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_rmc_set_mode_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_rmc_set_mode_cmd_fixed_param));
p_rmc_enable_cmd->vdev_id = vdev_id;
p_rmc_enable_cmd->enable_rmc = WMI_RMC_MODE_ENABLED;
ret = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
WMI_RMC_SET_MODE_CMDID);
if (ret != QDF_STATUS_SUCCESS)
wmi_buf_free(buf);
WMA_LOGE("Enable RMC cmd sent len: %d, vdev %d command id: %d, status: %d",
len, vdev_id, WMI_RMC_SET_MODE_CMDID, ret);
return QDF_STATUS_SUCCESS;
}
/**
* wma_process_rmc_disable_ind() - disables rmc functionality in target
* @wma: wma handle
*
* Return: QDF status
*/
QDF_STATUS wma_process_rmc_disable_ind(tp_wma_handle wma)
{
int ret;
uint8_t *p;
uint16_t len;
wmi_buf_t buf;
int32_t vdev_id;
wmi_rmc_set_mode_cmd_fixed_param *p_rmc_disable_cmd;
vdev_id = wma_find_vdev_by_type(wma, WMI_VDEV_TYPE_IBSS);
if (vdev_id < 0) {
WMA_LOGE("%s: IBSS vdev does not exist could not disable RMC",
__func__);
return QDF_STATUS_E_FAILURE;
}
len = sizeof(wmi_rmc_set_mode_cmd_fixed_param);
buf = wmi_buf_alloc(wma->wmi_handle, len);
if (!buf)
return QDF_STATUS_E_FAILURE;
p = (uint8_t *) wmi_buf_data(buf);
qdf_mem_zero(p, len);
p_rmc_disable_cmd = (wmi_rmc_set_mode_cmd_fixed_param *) p;
WMITLV_SET_HDR(&p_rmc_disable_cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_rmc_set_mode_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_rmc_set_mode_cmd_fixed_param));
p_rmc_disable_cmd->vdev_id = vdev_id;
p_rmc_disable_cmd->enable_rmc = WMI_RMC_MODE_DISABLED;
ret = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
WMI_RMC_SET_MODE_CMDID);
if (ret != QDF_STATUS_SUCCESS)
wmi_buf_free(buf);
WMA_LOGE("Disable RMC cmd sent len: %d, vdev %d command id: %d, status: %d",
len, vdev_id, WMI_RMC_SET_MODE_CMDID, ret);
return QDF_STATUS_SUCCESS;
}
/**
* wma_process_rmc_action_period_ind() - sends RMC action period to target
* @wma: wma handle
*
* Return: QDF status
*/
QDF_STATUS wma_process_rmc_action_period_ind(tp_wma_handle wma)
{
int ret;
uint8_t *p;
uint16_t len;
uint32_t periodicity_msec;
wmi_buf_t buf;
int32_t vdev_id;
wmi_rmc_set_action_period_cmd_fixed_param *p_rmc_cmd;
struct mac_context *mac = cds_get_context(QDF_MODULE_ID_PE);
if (!mac) {
WMA_LOGE("%s: MAC mac does not exist", __func__);
return QDF_STATUS_E_FAILURE;
}
vdev_id = wma_find_vdev_by_type(wma, WMI_VDEV_TYPE_IBSS);
if (vdev_id < 0) {
WMA_LOGE("%s: IBSS vdev does not exist could not send RMC action period to target",
__func__);
return QDF_STATUS_E_FAILURE;
}
len = sizeof(wmi_rmc_set_action_period_cmd_fixed_param);
buf = wmi_buf_alloc(wma->wmi_handle, len);
if (!buf)
return QDF_STATUS_E_FAILURE;
p = (uint8_t *) wmi_buf_data(buf);
qdf_mem_zero(p, len);
p_rmc_cmd = (wmi_rmc_set_action_period_cmd_fixed_param *) p;
WMITLV_SET_HDR(&p_rmc_cmd->tlv_header,
WMITLV_TAG_STRUC_wmi_rmc_set_action_period_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN
(wmi_rmc_set_action_period_cmd_fixed_param));
periodicity_msec = mac->mlme_cfg->sap_cfg.rmc_action_period_freq;
p_rmc_cmd->vdev_id = vdev_id;
p_rmc_cmd->periodicity_msec = periodicity_msec;
ret = wmi_unified_cmd_send(wma->wmi_handle, buf, len,
WMI_RMC_SET_ACTION_PERIOD_CMDID);
if (ret != QDF_STATUS_SUCCESS)
wmi_buf_free(buf);
WMA_LOGE("RMC action period %d cmd sent len: %d, vdev %d command id: %d, status: %d",
periodicity_msec, len, vdev_id, WMI_RMC_SET_ACTION_PERIOD_CMDID,
ret);
return QDF_STATUS_SUCCESS;
}
#endif /* FEATURE_WLAN_RMC */
/**
* wma_process_add_periodic_tx_ptrn_ind() - add periodic tx pattern
* @handle: wma handle

53
core/wma/src/wma_main.c
Datei anzeigen

@@ -4145,34 +4145,6 @@ QDF_STATUS wma_start(void)
goto end;
#endif /* QCA_WIFI_FTM */
if (wmi_service_enabled(wmi_handle, wmi_service_rmc)) {
WMA_LOGD("FW supports cesium network, registering event handlers");
status = wmi_unified_register_event_handler(
wmi_handle,
wmi_peer_info_event_id,
wma_ibss_peer_info_event_handler,
WMA_RX_SERIALIZER_CTX);
if (status) {
WMA_LOGE("Failed to register ibss peer info event cb");
qdf_status = QDF_STATUS_E_FAILURE;
goto end;
}
status = wmi_unified_register_event_handler(
wmi_handle,
wmi_peer_tx_fail_cnt_thr_event_id,
wma_fast_tx_fail_event_handler,
WMA_RX_SERIALIZER_CTX);
if (status) {
WMA_LOGE("Failed to register peer fast tx failure event cb");
qdf_status = QDF_STATUS_E_FAILURE;
goto end;
}
} else {
WMA_LOGD("Target does not support cesium network");
}
qdf_status = wma_tx_attach(wma_handle);
if (qdf_status != QDF_STATUS_SUCCESS) {
WMA_LOGE("%s: Failed to register tx management", __func__);
@@ -8615,31 +8587,6 @@ static QDF_STATUS wma_mc_process_msg(struct scheduler_msg *msg)
wma_process_dhcp_ind(wma_handle, (tAniDHCPInd *) msg->bodyptr);
qdf_mem_free(msg->bodyptr);
break;
case WMA_IBSS_CESIUM_ENABLE_IND:
wma_process_cesium_enable_ind(wma_handle);
break;
case WMA_GET_IBSS_PEER_INFO_REQ:
wma_process_get_peer_info_req(wma_handle,
(tSirIbssGetPeerInfoReqParams *)
msg->bodyptr);
qdf_mem_free(msg->bodyptr);
break;
case WMA_TX_FAIL_MONITOR_IND:
wma_process_tx_fail_monitor_ind(wma_handle,
(tAniTXFailMonitorInd *) msg->bodyptr);
qdf_mem_free(msg->bodyptr);
break;
case WMA_RMC_ENABLE_IND:
wma_process_rmc_enable_ind(wma_handle);
break;
case WMA_RMC_DISABLE_IND:
wma_process_rmc_disable_ind(wma_handle);
break;
case WMA_RMC_ACTION_PERIOD_IND:
wma_process_rmc_action_period_ind(wma_handle);
break;
case WMA_INIT_THERMAL_INFO_CMD:
wma_process_init_thermal_info(wma_handle,
(t_thermal_mgmt *) msg->bodyptr);