samsung-sm8650/android_kernel_samsung_sm8650-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcacld-3.0: Rename pAdapter in wlan_hdd_hostapd.[ch]

Browse Source 
The Linux Coding Style frowns upon mixed-case names and
so-called Hungarian notation, so rename pAdapter to align
with the Coding Style.

Change-Id: I29e0573d41628692838037c79007ef983a0cbf9f
CRs-Fixed: 2119855
This commit is contained in:
Jeff Johnson
2017-10-02 13:28:39 -07:00
committed by snandini
parent eaa91ef6ed
commit fd33cce7fb
2 changed files with 170 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

336
core/hdd/src/wlan_hdd_hostapd.c
View File

@@ -220,18 +220,18 @@ int hdd_sap_context_init(struct hdd_context *hdd_ctx)
* hdd_hostapd_channel_allow_suspend() - allow suspend in a channel. * hdd_hostapd_channel_allow_suspend() - allow suspend in a channel.
* Called when, 1. bss stopped, 2. channel switch * Called when, 1. bss stopped, 2. channel switch
* *
* @pAdapter: pointer to hdd adapter * @adapter: pointer to hdd adapter
* @channel: current channel * @channel: current channel
* *
* Return: None * Return: None
*/ */
static void hdd_hostapd_channel_allow_suspend(struct hdd_adapter *pAdapter, static void hdd_hostapd_channel_allow_suspend(struct hdd_adapter *adapter,
uint8_t channel) uint8_t channel)
{ {
struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(pAdapter); struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
struct hdd_hostapd_state *pHostapdState = struct hdd_hostapd_state *pHostapdState =
WLAN_HDD_GET_HOSTAP_STATE_PTR(pAdapter); WLAN_HDD_GET_HOSTAP_STATE_PTR(adapter);
hdd_debug("bssState: %d, channel: %d, dfs_ref_cnt: %d", hdd_debug("bssState: %d, channel: %d, dfs_ref_cnt: %d",
pHostapdState->bssState, channel, pHostapdState->bssState, channel,
@@ -259,17 +259,17 @@ static void hdd_hostapd_channel_allow_suspend(struct hdd_adapter *pAdapter,
* hdd_hostapd_channel_prevent_suspend() - prevent suspend in a channel. * hdd_hostapd_channel_prevent_suspend() - prevent suspend in a channel.
* Called when, 1. bss started, 2. channel switch * Called when, 1. bss started, 2. channel switch
* *
* @pAdapter: pointer to hdd adapter * @adapter: pointer to hdd adapter
* @channel: current channel * @channel: current channel
* *
* Return - None * Return - None
*/ */
static void hdd_hostapd_channel_prevent_suspend(struct hdd_adapter *pAdapter, static void hdd_hostapd_channel_prevent_suspend(struct hdd_adapter *adapter,
uint8_t channel) uint8_t channel)
{ {
struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(pAdapter); struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
struct hdd_hostapd_state *pHostapdState = struct hdd_hostapd_state *pHostapdState =
WLAN_HDD_GET_HOSTAP_STATE_PTR(pAdapter); WLAN_HDD_GET_HOSTAP_STATE_PTR(adapter);
hdd_debug("bssState: %d, channel: %d, dfs_ref_cnt: %d", hdd_debug("bssState: %d, channel: %d, dfs_ref_cnt: %d",
pHostapdState->bssState, channel, pHostapdState->bssState, channel,
@@ -330,8 +330,8 @@ void hdd_sap_context_destroy(struct hdd_context *hdd_ctx)
*/ */
static int __hdd_hostapd_open(struct net_device *dev) static int __hdd_hostapd_open(struct net_device *dev)
{ {
struct hdd_adapter *pAdapter = netdev_priv(dev); struct hdd_adapter *adapter = netdev_priv(dev);
struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(pAdapter); struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
int ret; int ret;
ENTER_DEV(dev); ENTER_DEV(dev);
@@ -345,17 +345,17 @@ static int __hdd_hostapd_open(struct net_device *dev)
/* /*
* Check statemachine state and also stop iface change timer if running * Check statemachine state and also stop iface change timer if running
*/ */
ret = hdd_wlan_start_modules(hdd_ctx, pAdapter, false); ret = hdd_wlan_start_modules(hdd_ctx, adapter, false);
if (ret) { if (ret) {
hdd_err("Failed to start WLAN modules return"); hdd_err("Failed to start WLAN modules return");
return ret; return ret;
} }
set_bit(DEVICE_IFACE_OPENED, &pAdapter->event_flags); set_bit(DEVICE_IFACE_OPENED, &adapter->event_flags);
/* Enable all Tx queues */ /* Enable all Tx queues */
hdd_debug("Enabling queues"); hdd_debug("Enabling queues");
wlan_hdd_netif_queue_control(pAdapter, wlan_hdd_netif_queue_control(adapter,
WLAN_START_ALL_NETIF_QUEUE_N_CARRIER, WLAN_START_ALL_NETIF_QUEUE_N_CARRIER,
WLAN_CONTROL_PATH); WLAN_CONTROL_PATH);
EXIT(); EXIT();
@@ -6071,7 +6071,7 @@ const struct net_device_ops net_ops_struct = {
.ndo_select_queue = hdd_hostapd_select_queue, .ndo_select_queue = hdd_hostapd_select_queue,
}; };
static int hdd_set_hostapd(struct hdd_adapter *pAdapter) static int hdd_set_hostapd(struct hdd_adapter *adapter)
{ {
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
@@ -6081,11 +6081,11 @@ void hdd_set_ap_ops(struct net_device *pWlanHostapdDev)
pWlanHostapdDev->netdev_ops = &net_ops_struct; pWlanHostapdDev->netdev_ops = &net_ops_struct;
} }
QDF_STATUS hdd_init_ap_mode(struct hdd_adapter *pAdapter, bool reinit) QDF_STATUS hdd_init_ap_mode(struct hdd_adapter *adapter, bool reinit)
{ {
struct hdd_hostapd_state *phostapdBuf; struct hdd_hostapd_state *phostapdBuf;
struct net_device *dev = pAdapter->dev; struct net_device *dev = adapter->dev;
struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(pAdapter); struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter);
QDF_STATUS status; QDF_STATUS status;
struct sap_context *sapContext = NULL; struct sap_context *sapContext = NULL;
int ret; int ret;
@@ -6097,7 +6097,7 @@ QDF_STATUS hdd_init_ap_mode(struct hdd_adapter *pAdapter, bool reinit)
hdd_info("SSR in progress: %d", reinit); hdd_info("SSR in progress: %d", reinit);
if (reinit) if (reinit)
sapContext = pAdapter->sessionCtx.ap.sapContext; sapContext = adapter->sessionCtx.ap.sapContext;
else { else {
sapContext = wlansap_open(); sapContext = wlansap_open();
if (sapContext == NULL) { if (sapContext == NULL) {
@@ -6105,20 +6105,20 @@ QDF_STATUS hdd_init_ap_mode(struct hdd_adapter *pAdapter, bool reinit)
return QDF_STATUS_E_FAULT; return QDF_STATUS_E_FAULT;
} }
pAdapter->sessionCtx.ap.sapContext = sapContext; adapter->sessionCtx.ap.sapContext = sapContext;
pAdapter->sessionCtx.ap.sapConfig.channel = adapter->sessionCtx.ap.sapConfig.channel =
hdd_ctx->acs_policy.acs_channel; hdd_ctx->acs_policy.acs_channel;
acs_dfs_mode = hdd_ctx->acs_policy.acs_dfs_mode; acs_dfs_mode = hdd_ctx->acs_policy.acs_dfs_mode;
pAdapter->sessionCtx.ap.sapConfig.acs_dfs_mode = adapter->sessionCtx.ap.sapConfig.acs_dfs_mode =
wlan_hdd_get_dfs_mode(acs_dfs_mode); wlan_hdd_get_dfs_mode(acs_dfs_mode);
} }
if (pAdapter->device_mode == QDF_P2P_GO_MODE) { if (adapter->device_mode == QDF_P2P_GO_MODE) {
mode = QDF_P2P_GO_MODE; mode = QDF_P2P_GO_MODE;
} else if (pAdapter->device_mode == QDF_SAP_MODE) { } else if (adapter->device_mode == QDF_SAP_MODE) {
mode = QDF_SAP_MODE; mode = QDF_SAP_MODE;
} else { } else {
hdd_err("Invalid mode for AP: %d", pAdapter->device_mode); hdd_err("Invalid mode for AP: %d", adapter->device_mode);
return QDF_STATUS_E_FAULT; return QDF_STATUS_E_FAULT;
} }
@@ -6126,48 +6126,48 @@ QDF_STATUS hdd_init_ap_mode(struct hdd_adapter *pAdapter, bool reinit)
* This is a special case of hdd_vdev_create(). In phase 4 convergence, * This is a special case of hdd_vdev_create(). In phase 4 convergence,
* this special case will be properly addressed. * this special case will be properly addressed.
*/ */
ret = hdd_objmgr_create_and_store_vdev(hdd_ctx->hdd_pdev, pAdapter); ret = hdd_objmgr_create_and_store_vdev(hdd_ctx->hdd_pdev, adapter);
if (ret) { if (ret) {
hdd_err("failed to create objmgr vdev: %d", ret); hdd_err("failed to create objmgr vdev: %d", ret);
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
status = wlansap_start(sapContext, mode, status = wlansap_start(sapContext, mode,
pAdapter->macAddressCurrent.bytes, adapter->macAddressCurrent.bytes,
pAdapter->sessionId); adapter->sessionId);
if (QDF_IS_STATUS_ERROR(status)) { if (QDF_IS_STATUS_ERROR(status)) {
hdd_err("wlansap_start failed!! status: %d", status); hdd_err("wlansap_start failed!! status: %d", status);
pAdapter->sessionCtx.ap.sapContext = NULL; adapter->sessionCtx.ap.sapContext = NULL;
/* /*
* In this case, we need to cleanup in the same order as create. * In this case, we need to cleanup in the same order as create.
* See hdd_vdev_create() for more details. * See hdd_vdev_create() for more details.
*/ */
QDF_BUG(!hdd_objmgr_release_and_destroy_vdev(pAdapter)); QDF_BUG(!hdd_objmgr_release_and_destroy_vdev(adapter));
return status; return status;
} }
/* set SME_SESSION_OPENED since sap session started */ /* set SME_SESSION_OPENED since sap session started */
set_bit(SME_SESSION_OPENED, &pAdapter->event_flags); set_bit(SME_SESSION_OPENED, &adapter->event_flags);
ret = hdd_vdev_ready(pAdapter); ret = hdd_vdev_ready(adapter);
if (ret) { if (ret) {
hdd_err("failed to raise vdev ready event: %d", ret); hdd_err("failed to raise vdev ready event: %d", ret);
goto error_init_ap_mode; goto error_init_ap_mode;
} }
/* Allocate the Wireless Extensions state structure */ /* Allocate the Wireless Extensions state structure */
phostapdBuf = WLAN_HDD_GET_HOSTAP_STATE_PTR(pAdapter); phostapdBuf = WLAN_HDD_GET_HOSTAP_STATE_PTR(adapter);
sme_set_curr_device_mode(hdd_ctx->hHal, pAdapter->device_mode); sme_set_curr_device_mode(hdd_ctx->hHal, adapter->device_mode);
/* Zero the memory. This zeros the profile structure. */ /* Zero the memory. This zeros the profile structure. */
memset(phostapdBuf, 0, sizeof(struct hdd_hostapd_state)); memset(phostapdBuf, 0, sizeof(struct hdd_hostapd_state));
/* Set up the pointer to the Wireless Extensions state structure */ /* Set up the pointer to the Wireless Extensions state structure */
/* NOP */ /* NOP */
status = hdd_set_hostapd(pAdapter); status = hdd_set_hostapd(adapter);
if (!QDF_IS_STATUS_SUCCESS(status)) { if (!QDF_IS_STATUS_SUCCESS(status)) {
hdd_err("hdd_set_hostapd failed!!"); hdd_err("hdd_set_hostapd failed!!");
goto error_init_ap_mode; goto error_init_ap_mode;
@@ -6189,33 +6189,33 @@ QDF_STATUS hdd_init_ap_mode(struct hdd_adapter *pAdapter, bool reinit)
if (!QDF_IS_STATUS_SUCCESS(status)) { if (!QDF_IS_STATUS_SUCCESS(status)) {
hdd_err("Hostapd HDD sta disassoc event init failed!!"); hdd_err("Hostapd HDD sta disassoc event init failed!!");
wlansap_close(sapContext); wlansap_close(sapContext);
pAdapter->sessionCtx.ap.sapContext = NULL; adapter->sessionCtx.ap.sapContext = NULL;
return status; return status;
} }
init_completion(&pAdapter->session_close_comp_var); init_completion(&adapter->session_close_comp_var);
init_completion(&pAdapter->session_open_comp_var); init_completion(&adapter->session_open_comp_var);
sema_init(&(WLAN_HDD_GET_AP_CTX_PTR(pAdapter))->semWpsPBCOverlapInd, 1); sema_init(&(WLAN_HDD_GET_AP_CTX_PTR(adapter))->semWpsPBCOverlapInd, 1);
/* Register as a wireless device */ /* Register as a wireless device */
dev->wireless_handlers = (struct iw_handler_def *)&hostapd_handler_def; dev->wireless_handlers = (struct iw_handler_def *)&hostapd_handler_def;
/* Initialize the data path module */ /* Initialize the data path module */
status = hdd_softap_init_tx_rx(pAdapter); status = hdd_softap_init_tx_rx(adapter);
if (!QDF_IS_STATUS_SUCCESS(status)) if (!QDF_IS_STATUS_SUCCESS(status))
hdd_err("hdd_softap_init_tx_rx failed"); hdd_err("hdd_softap_init_tx_rx failed");
status = hdd_wmm_adapter_init(pAdapter); status = hdd_wmm_adapter_init(adapter);
if (!QDF_IS_STATUS_SUCCESS(status)) { if (!QDF_IS_STATUS_SUCCESS(status)) {
hdd_err("hdd_wmm_adapter_init() failed code: %08d [x%08x]", hdd_err("hdd_wmm_adapter_init() failed code: %08d [x%08x]",
status, status); status, status);
goto error_wmm_init; goto error_wmm_init;
} }
set_bit(WMM_INIT_DONE, &pAdapter->event_flags); set_bit(WMM_INIT_DONE, &adapter->event_flags);
ret = wma_cli_set_command(pAdapter->sessionId, ret = wma_cli_set_command(adapter->sessionId,
WMI_PDEV_PARAM_BURST_ENABLE, WMI_PDEV_PARAM_BURST_ENABLE,
hdd_ctx->config->enableSifsBurst, hdd_ctx->config->enableSifsBurst,
PDEV_CMD); PDEV_CMD);
@@ -6224,9 +6224,9 @@ QDF_STATUS hdd_init_ap_mode(struct hdd_adapter *pAdapter, bool reinit)
hdd_err("WMI_PDEV_PARAM_BURST_ENABLE set failed: %d", ret); hdd_err("WMI_PDEV_PARAM_BURST_ENABLE set failed: %d", ret);
if (!reinit) { if (!reinit) {
pAdapter->sessionCtx.ap.sapConfig.acs_cfg.acs_mode = false; adapter->sessionCtx.ap.sapConfig.acs_cfg.acs_mode = false;
qdf_mem_free(pAdapter->sessionCtx.ap.sapConfig.acs_cfg.ch_list); qdf_mem_free(adapter->sessionCtx.ap.sapConfig.acs_cfg.ch_list);
qdf_mem_zero(&pAdapter->sessionCtx.ap.sapConfig.acs_cfg, qdf_mem_zero(&adapter->sessionCtx.ap.sapConfig.acs_cfg,
sizeof(struct sap_acs_cfg)); sizeof(struct sap_acs_cfg));
} }
@@ -6235,13 +6235,13 @@ QDF_STATUS hdd_init_ap_mode(struct hdd_adapter *pAdapter, bool reinit)
return status; return status;
error_wmm_init: error_wmm_init:
hdd_softap_deinit_tx_rx(pAdapter); hdd_softap_deinit_tx_rx(adapter);
error_init_ap_mode: error_init_ap_mode:
QDF_BUG(!hdd_objmgr_destroy_vdev(pAdapter)); QDF_BUG(!hdd_objmgr_destroy_vdev(adapter));
wlansap_close(sapContext); wlansap_close(sapContext);
QDF_BUG(!hdd_objmgr_release_vdev(pAdapter)); QDF_BUG(!hdd_objmgr_release_vdev(adapter));
pAdapter->sessionCtx.ap.sapContext = NULL; adapter->sessionCtx.ap.sapContext = NULL;
EXIT(); EXIT();
return status; return status;
@@ -6340,32 +6340,32 @@ struct hdd_adapter *hdd_wlan_create_ap_dev(struct hdd_context *hdd_ctx,
/** /**
* hdd_unregister_hostapd() - unregister hostapd * hdd_unregister_hostapd() - unregister hostapd
* @pAdapter: Pointer to hostapd adapter * @adapter: Pointer to hostapd adapter
* @rtnl_held: true if rtnl lock held; false otherwise * @rtnl_held: true if rtnl lock held; false otherwise
* *
* Return: QDF_STATUS enumaration * Return: QDF_STATUS enumaration
*/ */
QDF_STATUS hdd_unregister_hostapd(struct hdd_adapter *pAdapter, bool rtnl_held) QDF_STATUS hdd_unregister_hostapd(struct hdd_adapter *adapter, bool rtnl_held)
{ {
int ret; int ret;
QDF_STATUS status; QDF_STATUS status;
void *sapContext = WLAN_HDD_GET_SAP_CTX_PTR(pAdapter); void *sapContext = WLAN_HDD_GET_SAP_CTX_PTR(adapter);
ENTER(); ENTER();
hdd_softap_deinit_tx_rx(pAdapter); hdd_softap_deinit_tx_rx(adapter);
/* if we are being called during driver unload, /* if we are being called during driver unload,
* then the dev has already been invalidated. * then the dev has already been invalidated.
* if we are being called at other times, then we can * if we are being called at other times, then we can
* detach the wireless device handlers * detach the wireless device handlers
*/ */
if (pAdapter->dev) { if (adapter->dev) {
if (rtnl_held) if (rtnl_held)
pAdapter->dev->wireless_handlers = NULL; adapter->dev->wireless_handlers = NULL;
else { else {
rtnl_lock(); rtnl_lock();
pAdapter->dev->wireless_handlers = NULL; adapter->dev->wireless_handlers = NULL;
rtnl_unlock(); rtnl_unlock();
} }
} }
@@ -6374,16 +6374,16 @@ QDF_STATUS hdd_unregister_hostapd(struct hdd_adapter *pAdapter, bool rtnl_held)
if (!QDF_IS_STATUS_SUCCESS(status)) if (!QDF_IS_STATUS_SUCCESS(status))
hdd_err("Failed:wlansap_stop"); hdd_err("Failed:wlansap_stop");
ret = hdd_objmgr_destroy_vdev(pAdapter); ret = hdd_objmgr_destroy_vdev(adapter);
if (ret) if (ret)
hdd_err("objmgr vdev destroy failed"); hdd_err("objmgr vdev destroy failed");
status = wlansap_close(sapContext); status = wlansap_close(sapContext);
if (!QDF_IS_STATUS_SUCCESS(status)) if (!QDF_IS_STATUS_SUCCESS(status))
hdd_err("Failed:WLANSAP_close"); hdd_err("Failed:WLANSAP_close");
pAdapter->sessionCtx.ap.sapContext = NULL; adapter->sessionCtx.ap.sapContext = NULL;
ret = hdd_objmgr_release_vdev(pAdapter); ret = hdd_objmgr_release_vdev(adapter);
if (ret) if (ret)
hdd_err("objmgr vdev release failed"); hdd_err("objmgr vdev release failed");
@@ -6457,7 +6457,7 @@ int wlan_hdd_set_channel(struct wiphy *wiphy,
struct cfg80211_chan_def *chandef, struct cfg80211_chan_def *chandef,
enum nl80211_channel_type channel_type) enum nl80211_channel_type channel_type)
{ {
struct hdd_adapter *pAdapter = NULL; struct hdd_adapter *adapter = NULL;
uint32_t num_ch = 0; uint32_t num_ch = 0;
int channel = 0; int channel = 0;
int channel_seg2 = 0; int channel_seg2 = 0;
@@ -6474,17 +6474,17 @@ int wlan_hdd_set_channel(struct wiphy *wiphy,
hdd_err("Called with dev = NULL"); hdd_err("Called with dev = NULL");
return -ENODEV; return -ENODEV;
} }
pAdapter = WLAN_HDD_GET_PRIV_PTR(dev); adapter = WLAN_HDD_GET_PRIV_PTR(dev);
MTRACE(qdf_trace(QDF_MODULE_ID_HDD, MTRACE(qdf_trace(QDF_MODULE_ID_HDD,
TRACE_CODE_HDD_CFG80211_SET_CHANNEL, TRACE_CODE_HDD_CFG80211_SET_CHANNEL,
pAdapter->sessionId, channel_type)); adapter->sessionId, channel_type));
hdd_debug("Device_mode %s(%d) freq = %d", hdd_debug("Device_mode %s(%d) freq = %d",
hdd_device_mode_to_string(pAdapter->device_mode), hdd_device_mode_to_string(adapter->device_mode),
pAdapter->device_mode, chandef->chan->center_freq); adapter->device_mode, chandef->chan->center_freq);
hdd_ctx = WLAN_HDD_GET_CTX(pAdapter); hdd_ctx = WLAN_HDD_GET_CTX(adapter);
status = wlan_hdd_validate_context(hdd_ctx); status = wlan_hdd_validate_context(hdd_ctx);
if (status) if (status)
return status; return status;
@@ -6527,27 +6527,27 @@ int wlan_hdd_set_channel(struct wiphy *wiphy,
num_ch = WNI_CFG_VALID_CHANNEL_LIST_LEN; num_ch = WNI_CFG_VALID_CHANNEL_LIST_LEN;
if ((QDF_SAP_MODE != pAdapter->device_mode) && if ((QDF_SAP_MODE != adapter->device_mode) &&
(QDF_P2P_GO_MODE != pAdapter->device_mode)) { (QDF_P2P_GO_MODE != adapter->device_mode)) {
if (QDF_STATUS_SUCCESS != if (QDF_STATUS_SUCCESS !=
wlan_hdd_validate_operation_channel(pAdapter, channel)) { wlan_hdd_validate_operation_channel(adapter, channel)) {
hdd_err("Invalid Channel: %d", channel); hdd_err("Invalid Channel: %d", channel);
return -EINVAL; return -EINVAL;
} }
hdd_debug("set channel to [%d] for device mode %s(%d)", hdd_debug("set channel to [%d] for device mode %s(%d)",
channel, channel,
hdd_device_mode_to_string(pAdapter->device_mode), hdd_device_mode_to_string(adapter->device_mode),
pAdapter->device_mode); adapter->device_mode);
} }
if ((pAdapter->device_mode == QDF_STA_MODE) if ((adapter->device_mode == QDF_STA_MODE)
|| (pAdapter->device_mode == QDF_P2P_CLIENT_MODE) || (adapter->device_mode == QDF_P2P_CLIENT_MODE)
) { ) {
struct hdd_wext_state *pWextState = struct hdd_wext_state *pWextState =
WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter); WLAN_HDD_GET_WEXT_STATE_PTR(adapter);
tCsrRoamProfile *pRoamProfile = &pWextState->roamProfile; tCsrRoamProfile *pRoamProfile = &pWextState->roamProfile;
struct hdd_station_ctx *pHddStaCtx = struct hdd_station_ctx *pHddStaCtx =
WLAN_HDD_GET_STATION_CTX_PTR(pAdapter); WLAN_HDD_GET_STATION_CTX_PTR(adapter);
if (eConnectionState_IbssConnected == if (eConnectionState_IbssConnected ==
pHddStaCtx->conn_info.connState) { pHddStaCtx->conn_info.connState) {
@@ -6560,13 +6560,13 @@ int wlan_hdd_set_channel(struct wiphy *wiphy,
pHddStaCtx->conn_info.operationChannel = channel; pHddStaCtx->conn_info.operationChannel = channel;
pRoamProfile->ChannelInfo.ChannelList = pRoamProfile->ChannelInfo.ChannelList =
&pHddStaCtx->conn_info.operationChannel; &pHddStaCtx->conn_info.operationChannel;
} else if ((pAdapter->device_mode == QDF_SAP_MODE) } else if ((adapter->device_mode == QDF_SAP_MODE)
|| (pAdapter->device_mode == QDF_P2P_GO_MODE) || (adapter->device_mode == QDF_P2P_GO_MODE)
) { ) {
sap_config = &((WLAN_HDD_GET_AP_CTX_PTR(pAdapter))->sapConfig); sap_config = &((WLAN_HDD_GET_AP_CTX_PTR(adapter))->sapConfig);
if (QDF_P2P_GO_MODE == pAdapter->device_mode) { if (QDF_P2P_GO_MODE == adapter->device_mode) {
if (QDF_STATUS_SUCCESS != if (QDF_STATUS_SUCCESS !=
wlan_hdd_validate_operation_channel(pAdapter, wlan_hdd_validate_operation_channel(adapter,
channel)) { channel)) {
hdd_err("Invalid Channel: %d", channel); hdd_err("Invalid Channel: %d", channel);
return -EINVAL; return -EINVAL;
@@ -6576,7 +6576,7 @@ int wlan_hdd_set_channel(struct wiphy *wiphy,
} else { } else {
/* set channel to what hostapd configured */ /* set channel to what hostapd configured */
if (QDF_STATUS_SUCCESS != if (QDF_STATUS_SUCCESS !=
wlan_hdd_validate_operation_channel(pAdapter, wlan_hdd_validate_operation_channel(adapter,
channel)) { channel)) {
hdd_err("Invalid Channel: %d", channel); hdd_err("Invalid Channel: %d", channel);
return -EINVAL; return -EINVAL;
@@ -6610,7 +6610,7 @@ int wlan_hdd_set_channel(struct wiphy *wiphy,
return -EINVAL; return -EINVAL;
} }
sme_config->csrConfig.obssEnabled = sme_config->csrConfig.obssEnabled =
wlan_hdd_get_sap_obss(pAdapter); wlan_hdd_get_sap_obss(adapter);
sme_update_config(hdd_ctx->hHal, sme_config); sme_update_config(hdd_ctx->hHal, sme_config);
qdf_mem_free(sme_config); qdf_mem_free(sme_config);
@@ -6784,7 +6784,7 @@ static void wlan_hdd_add_extra_ie(struct hdd_adapter *pHostapdAdapter,
/** /**
* wlan_hdd_cfg80211_alloc_new_beacon() - alloc beacon in ap mode * wlan_hdd_cfg80211_alloc_new_beacon() - alloc beacon in ap mode
* @pAdapter: Pointer to hostapd adapter * @adapter: Pointer to hostapd adapter
* @ppBeacon: Pointer to pointer to beacon data * @ppBeacon: Pointer to pointer to beacon data
* @params: Pointer to beacon parameters * @params: Pointer to beacon parameters
* @dtim_period: DTIM period * @dtim_period: DTIM period
@@ -6792,7 +6792,7 @@ static void wlan_hdd_add_extra_ie(struct hdd_adapter *pHostapdAdapter,
* Return: 0 for success non-zero for failure * Return: 0 for success non-zero for failure
*/ */
static int static int
wlan_hdd_cfg80211_alloc_new_beacon(struct hdd_adapter *pAdapter, wlan_hdd_cfg80211_alloc_new_beacon(struct hdd_adapter *adapter,
struct hdd_beacon_data **ppBeacon, struct hdd_beacon_data **ppBeacon,
struct cfg80211_beacon_data *params, struct cfg80211_beacon_data *params,
int dtim_period) int dtim_period)
@@ -6809,11 +6809,11 @@ wlan_hdd_cfg80211_alloc_new_beacon(struct hdd_adapter *pAdapter,
return -EINVAL; return -EINVAL;
} }
old = pAdapter->sessionCtx.ap.beacon; old = adapter->sessionCtx.ap.beacon;
if (!params->head && !old) { if (!params->head && !old) {
hdd_err("session: %d old and new heads points to NULL", hdd_err("session: %d old and new heads points to NULL",
pAdapter->sessionId); adapter->sessionId);
return -EINVAL; return -EINVAL;
} }
@@ -6887,7 +6887,7 @@ wlan_hdd_cfg80211_alloc_new_beacon(struct hdd_adapter *pAdapter,
*ppBeacon = beacon; *ppBeacon = beacon;
pAdapter->sessionCtx.ap.beacon = NULL; adapter->sessionCtx.ap.beacon = NULL;
qdf_mem_free(old); qdf_mem_free(old);
return 0; return 0;
@@ -8075,7 +8075,7 @@ int hdd_destroy_acs_timer(struct hdd_adapter *adapter)
static int __wlan_hdd_cfg80211_stop_ap(struct wiphy *wiphy, static int __wlan_hdd_cfg80211_stop_ap(struct wiphy *wiphy,
struct net_device *dev) struct net_device *dev)
{ {
struct hdd_adapter *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev); struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(dev);
struct hdd_context *hdd_ctx = wiphy_priv(wiphy); struct hdd_context *hdd_ctx = wiphy_priv(wiphy);
struct hdd_scan_info *pScanInfo = NULL; struct hdd_scan_info *pScanInfo = NULL;
struct hdd_adapter *staAdapter = NULL; struct hdd_adapter *staAdapter = NULL;
@@ -8099,17 +8099,17 @@ static int __wlan_hdd_cfg80211_stop_ap(struct wiphy *wiphy,
return -EINVAL; return -EINVAL;
} }
if (wlan_hdd_validate_session_id(pAdapter->sessionId)) { if (wlan_hdd_validate_session_id(adapter->sessionId)) {
hdd_err("Invalid session id: %d", pAdapter->sessionId); hdd_err("Invalid session id: %d", adapter->sessionId);
return -EINVAL; return -EINVAL;
} }
MTRACE(qdf_trace(QDF_MODULE_ID_HDD, MTRACE(qdf_trace(QDF_MODULE_ID_HDD,
TRACE_CODE_HDD_CFG80211_STOP_AP, TRACE_CODE_HDD_CFG80211_STOP_AP,
pAdapter->sessionId, pAdapter->device_mode)); adapter->sessionId, adapter->device_mode));
if (!(pAdapter->device_mode == QDF_SAP_MODE || if (!(adapter->device_mode == QDF_SAP_MODE ||
pAdapter->device_mode == QDF_P2P_GO_MODE)) { adapter->device_mode == QDF_P2P_GO_MODE)) {
return -EOPNOTSUPP; return -EOPNOTSUPP;
} }
@@ -8118,17 +8118,17 @@ static int __wlan_hdd_cfg80211_stop_ap(struct wiphy *wiphy,
* This update is moved to start of this function to resolve stop_ap * This update is moved to start of this function to resolve stop_ap
* call during SSR case. Adapter gets cleaned up as part of SSR. * call during SSR case. Adapter gets cleaned up as part of SSR.
*/ */
clear_bit(SOFTAP_INIT_DONE, &pAdapter->event_flags); clear_bit(SOFTAP_INIT_DONE, &adapter->event_flags);
hdd_debug("Device_mode %s(%d)", hdd_debug("Device_mode %s(%d)",
hdd_device_mode_to_string(pAdapter->device_mode), hdd_device_mode_to_string(adapter->device_mode),
pAdapter->device_mode); adapter->device_mode);
ret = wlan_hdd_validate_context(hdd_ctx); ret = wlan_hdd_validate_context(hdd_ctx);
if (0 != ret) if (0 != ret)
return ret; return ret;
if (pAdapter->device_mode == QDF_SAP_MODE) { if (adapter->device_mode == QDF_SAP_MODE) {
wlan_hdd_del_station(pAdapter); wlan_hdd_del_station(adapter);
hdd_green_ap_stop_bss(hdd_ctx); hdd_green_ap_stop_bss(hdd_ctx);
} }
@@ -8158,39 +8158,39 @@ static int __wlan_hdd_cfg80211_stop_ap(struct wiphy *wiphy,
* then lets finish it and go ahead from there. * then lets finish it and go ahead from there.
*/ */
if (hdd_ctx->config->conc_custom_rule1 && if (hdd_ctx->config->conc_custom_rule1 &&
(QDF_SAP_MODE == pAdapter->device_mode)) { (QDF_SAP_MODE == adapter->device_mode)) {
cds_flush_work(&hdd_ctx->sap_start_work); cds_flush_work(&hdd_ctx->sap_start_work);
hdd_debug("Canceled the pending restart work"); hdd_debug("Canceled the pending restart work");
qdf_spin_lock(&hdd_ctx->sap_update_info_lock); qdf_spin_lock(&hdd_ctx->sap_update_info_lock);
hdd_ctx->is_sap_restart_required = false; hdd_ctx->is_sap_restart_required = false;
qdf_spin_unlock(&hdd_ctx->sap_update_info_lock); qdf_spin_unlock(&hdd_ctx->sap_update_info_lock);
} }
pAdapter->sessionCtx.ap.sapConfig.acs_cfg.acs_mode = false; adapter->sessionCtx.ap.sapConfig.acs_cfg.acs_mode = false;
wlan_hdd_undo_acs(pAdapter); wlan_hdd_undo_acs(adapter);
qdf_mem_zero(&pAdapter->sessionCtx.ap.sapConfig.acs_cfg, qdf_mem_zero(&adapter->sessionCtx.ap.sapConfig.acs_cfg,
sizeof(struct sap_acs_cfg)); sizeof(struct sap_acs_cfg));
hdd_debug("Disabling queues"); hdd_debug("Disabling queues");
wlan_hdd_netif_queue_control(pAdapter, wlan_hdd_netif_queue_control(adapter,
WLAN_STOP_ALL_NETIF_QUEUE_N_CARRIER, WLAN_STOP_ALL_NETIF_QUEUE_N_CARRIER,
WLAN_CONTROL_PATH); WLAN_CONTROL_PATH);
old = pAdapter->sessionCtx.ap.beacon; old = adapter->sessionCtx.ap.beacon;
if (!old) { if (!old) {
hdd_err("Session id: %d beacon data points to NULL", hdd_err("Session id: %d beacon data points to NULL",
pAdapter->sessionId); adapter->sessionId);
return -EINVAL; return -EINVAL;
} }
hdd_cleanup_actionframe(hdd_ctx, pAdapter); hdd_cleanup_actionframe(hdd_ctx, adapter);
wlan_hdd_cleanup_remain_on_channel_ctx(pAdapter); wlan_hdd_cleanup_remain_on_channel_ctx(adapter);
mutex_lock(&hdd_ctx->sap_lock); mutex_lock(&hdd_ctx->sap_lock);
if (test_bit(SOFTAP_BSS_STARTED, &pAdapter->event_flags)) { if (test_bit(SOFTAP_BSS_STARTED, &adapter->event_flags)) {
struct hdd_hostapd_state *pHostapdState = struct hdd_hostapd_state *pHostapdState =
WLAN_HDD_GET_HOSTAP_STATE_PTR(pAdapter); WLAN_HDD_GET_HOSTAP_STATE_PTR(adapter);
qdf_event_reset(&pHostapdState->qdf_stop_bss_event); qdf_event_reset(&pHostapdState->qdf_stop_bss_event);
status = wlansap_stop_bss(WLAN_HDD_GET_SAP_CTX_PTR(pAdapter)); status = wlansap_stop_bss(WLAN_HDD_GET_SAP_CTX_PTR(adapter));
if (QDF_IS_STATUS_SUCCESS(status)) { if (QDF_IS_STATUS_SUCCESS(status)) {
qdf_status = qdf_status =
qdf_wait_single_event(&pHostapdState-> qdf_wait_single_event(&pHostapdState->
@@ -8202,12 +8202,12 @@ static int __wlan_hdd_cfg80211_stop_ap(struct wiphy *wiphy,
QDF_ASSERT(0); QDF_ASSERT(0);
} }
} }
clear_bit(SOFTAP_BSS_STARTED, &pAdapter->event_flags); clear_bit(SOFTAP_BSS_STARTED, &adapter->event_flags);
/*BSS stopped, clear the active sessions for this device mode*/ /*BSS stopped, clear the active sessions for this device mode*/
policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc, policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc,
pAdapter->device_mode, adapter->device_mode,
pAdapter->sessionId); adapter->sessionId);
pAdapter->sessionCtx.ap.beacon = NULL; adapter->sessionCtx.ap.beacon = NULL;
qdf_mem_free(old); qdf_mem_free(old);
} }
mutex_unlock(&hdd_ctx->sap_lock); mutex_unlock(&hdd_ctx->sap_lock);
@@ -8220,28 +8220,28 @@ static int __wlan_hdd_cfg80211_stop_ap(struct wiphy *wiphy,
return -EINVAL; return -EINVAL;
} }
qdf_copy_macaddr(&updateIE.bssid, &pAdapter->macAddressCurrent); qdf_copy_macaddr(&updateIE.bssid, &adapter->macAddressCurrent);
updateIE.smeSessionId = pAdapter->sessionId; updateIE.smeSessionId = adapter->sessionId;
updateIE.ieBufferlength = 0; updateIE.ieBufferlength = 0;
updateIE.pAdditionIEBuffer = NULL; updateIE.pAdditionIEBuffer = NULL;
updateIE.append = true; updateIE.append = true;
updateIE.notify = true; updateIE.notify = true;
if (sme_update_add_ie(WLAN_HDD_GET_HAL_CTX(pAdapter), if (sme_update_add_ie(WLAN_HDD_GET_HAL_CTX(adapter),
&updateIE, &updateIE,
eUPDATE_IE_PROBE_BCN) == QDF_STATUS_E_FAILURE) { eUPDATE_IE_PROBE_BCN) == QDF_STATUS_E_FAILURE) {
hdd_err("Could not pass on PROBE_RSP_BCN data to PE"); hdd_err("Could not pass on PROBE_RSP_BCN data to PE");
} }
if (sme_update_add_ie(WLAN_HDD_GET_HAL_CTX(pAdapter), if (sme_update_add_ie(WLAN_HDD_GET_HAL_CTX(adapter),
&updateIE, &updateIE,
eUPDATE_IE_ASSOC_RESP) == QDF_STATUS_E_FAILURE) { eUPDATE_IE_ASSOC_RESP) == QDF_STATUS_E_FAILURE) {
hdd_err("Could not pass on ASSOC_RSP data to PE"); hdd_err("Could not pass on ASSOC_RSP data to PE");
} }
/* Reset WNI_CFG_PROBE_RSP Flags */ /* Reset WNI_CFG_PROBE_RSP Flags */
wlan_hdd_reset_prob_rspies(pAdapter); wlan_hdd_reset_prob_rspies(adapter);
hdd_destroy_acs_timer(pAdapter); hdd_destroy_acs_timer(adapter);
#ifdef WLAN_FEATURE_P2P_DEBUG #ifdef WLAN_FEATURE_P2P_DEBUG
if ((pAdapter->device_mode == QDF_P2P_GO_MODE) && if ((adapter->device_mode == QDF_P2P_GO_MODE) &&
(global_p2p_connection_status == P2P_GO_COMPLETED_STATE)) { (global_p2p_connection_status == P2P_GO_COMPLETED_STATE)) {
hdd_debug("[P2P State] From GO completed to Inactive state GO got removed"); hdd_debug("[P2P State] From GO completed to Inactive state GO got removed");
global_p2p_connection_status = P2P_NOT_ACTIVE; global_p2p_connection_status = P2P_NOT_ACTIVE;
@@ -8344,7 +8344,7 @@ static uint16_t hdd_get_data_rate_from_rate_mask(struct wiphy *wiphy,
/** /**
* hdd_update_beacon_rate() - Update beacon tx rate * hdd_update_beacon_rate() - Update beacon tx rate
* @pAdapter: Pointer to hdd_adapter_t * @adapter: Pointer to hdd_adapter_t
* @wiphy: Pointer to wiphy * @wiphy: Pointer to wiphy
* @params: Pointet to cfg80211_ap_settings * @params: Pointet to cfg80211_ap_settings
* *
@@ -8393,7 +8393,7 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
struct net_device *dev, struct net_device *dev,
struct cfg80211_ap_settings *params) struct cfg80211_ap_settings *params)
{ {
struct hdd_adapter *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev); struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(dev);
struct hdd_context *hdd_ctx; struct hdd_context *hdd_ctx;
enum hw_mode_bandwidth channel_width; enum hw_mode_bandwidth channel_width;
int status; int status;
@@ -8402,33 +8402,33 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
ENTER(); ENTER();
clear_bit(SOFTAP_INIT_DONE, &pAdapter->event_flags); clear_bit(SOFTAP_INIT_DONE, &adapter->event_flags);
if (QDF_GLOBAL_FTM_MODE == hdd_get_conparam()) { if (QDF_GLOBAL_FTM_MODE == hdd_get_conparam()) {
hdd_err("Command not allowed in FTM mode"); hdd_err("Command not allowed in FTM mode");
return -EINVAL; return -EINVAL;
} }
if (wlan_hdd_validate_session_id(pAdapter->sessionId)) { if (wlan_hdd_validate_session_id(adapter->sessionId)) {
hdd_err("Invalid session id: %d", pAdapter->sessionId); hdd_err("Invalid session id: %d", adapter->sessionId);
return -EINVAL; return -EINVAL;
} }
MTRACE(qdf_trace(QDF_MODULE_ID_HDD, MTRACE(qdf_trace(QDF_MODULE_ID_HDD,
TRACE_CODE_HDD_CFG80211_START_AP, pAdapter->sessionId, TRACE_CODE_HDD_CFG80211_START_AP, adapter->sessionId,
params->beacon_interval)); params->beacon_interval));
if (WLAN_HDD_ADAPTER_MAGIC != pAdapter->magic) { if (WLAN_HDD_ADAPTER_MAGIC != adapter->magic) {
hdd_err("HDD adapter magic is invalid"); hdd_err("HDD adapter magic is invalid");
return -ENODEV; return -ENODEV;
} }
hdd_ctx = WLAN_HDD_GET_CTX(pAdapter); hdd_ctx = WLAN_HDD_GET_CTX(adapter);
status = wlan_hdd_validate_context(hdd_ctx); status = wlan_hdd_validate_context(hdd_ctx);
if (0 != status) if (0 != status)
return status; return status;
hdd_debug("pAdapter = %pK, Device mode %s(%d) sub20 %d", hdd_debug("adapter = %pK, Device mode %s(%d) sub20 %d",
pAdapter, hdd_device_mode_to_string(pAdapter->device_mode), adapter, hdd_device_mode_to_string(adapter->device_mode),
pAdapter->device_mode, cds_is_sub_20_mhz_enabled()); adapter->device_mode, cds_is_sub_20_mhz_enabled());
if (hdd_is_connection_in_progress(NULL, NULL)) { if (hdd_is_connection_in_progress(NULL, NULL)) {
@@ -8452,7 +8452,7 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
if (cds_is_sub_20_mhz_enabled()) { if (cds_is_sub_20_mhz_enabled()) {
enum channel_state ch_state; enum channel_state ch_state;
enum phy_ch_width sub_20_ch_width = CH_WIDTH_INVALID; enum phy_ch_width sub_20_ch_width = CH_WIDTH_INVALID;
tsap_Config_t *sap_cfg = &pAdapter->sessionCtx.ap.sapConfig; tsap_Config_t *sap_cfg = &adapter->sessionCtx.ap.sapConfig;
/* Avoid ACS/DFS, and overwrite ch wd to 20 */ /* Avoid ACS/DFS, and overwrite ch wd to 20 */
if (channel == 0) { if (channel == 0) {
@@ -8491,7 +8491,7 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
/* check if concurrency is allowed */ /* check if concurrency is allowed */
if (!policy_mgr_allow_concurrency(hdd_ctx->hdd_psoc, if (!policy_mgr_allow_concurrency(hdd_ctx->hdd_psoc,
policy_mgr_convert_device_mode_to_qdf_type( policy_mgr_convert_device_mode_to_qdf_type(
pAdapter->device_mode), adapter->device_mode),
channel, channel,
channel_width)) { channel_width)) {
hdd_err("Connection failed due to concurrency check failure"); hdd_err("Connection failed due to concurrency check failure");
@@ -8503,7 +8503,7 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
hdd_err("ERR: clear event failed"); hdd_err("ERR: clear event failed");
status = policy_mgr_current_connections_update(hdd_ctx->hdd_psoc, status = policy_mgr_current_connections_update(hdd_ctx->hdd_psoc,
pAdapter->sessionId, channel, adapter->sessionId, channel,
SIR_UPDATE_REASON_START_AP); SIR_UPDATE_REASON_START_AP);
if (QDF_STATUS_E_FAILURE == status) { if (QDF_STATUS_E_FAILURE == status) {
hdd_err("ERROR: connections update failed!!"); hdd_err("ERROR: connections update failed!!");
@@ -8518,10 +8518,10 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
} }
} }
if (QDF_SAP_MODE == pAdapter->device_mode) if (QDF_SAP_MODE == adapter->device_mode)
hdd_green_ap_start_bss(hdd_ctx); hdd_green_ap_start_bss(hdd_ctx);
if (pAdapter->device_mode == QDF_P2P_GO_MODE) { if (adapter->device_mode == QDF_P2P_GO_MODE) {
struct hdd_adapter *p2p_adapter; struct hdd_adapter *p2p_adapter;
p2p_adapter = hdd_get_adapter(hdd_ctx, QDF_P2P_DEVICE_MODE); p2p_adapter = hdd_get_adapter(hdd_ctx, QDF_P2P_DEVICE_MODE);
@@ -8532,21 +8532,21 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
} }
} }
if ((pAdapter->device_mode == QDF_SAP_MODE) if ((adapter->device_mode == QDF_SAP_MODE)
|| (pAdapter->device_mode == QDF_P2P_GO_MODE) || (adapter->device_mode == QDF_P2P_GO_MODE)
) { ) {
struct hdd_beacon_data *old, *new; struct hdd_beacon_data *old, *new;
enum nl80211_channel_type channel_type; enum nl80211_channel_type channel_type;
tsap_Config_t *sap_config = tsap_Config_t *sap_config =
&((WLAN_HDD_GET_AP_CTX_PTR(pAdapter))->sapConfig); &((WLAN_HDD_GET_AP_CTX_PTR(adapter))->sapConfig);
old = pAdapter->sessionCtx.ap.beacon; old = adapter->sessionCtx.ap.beacon;
if (old) if (old)
return -EALREADY; return -EALREADY;
status = status =
wlan_hdd_cfg80211_alloc_new_beacon(pAdapter, &new, wlan_hdd_cfg80211_alloc_new_beacon(adapter, &new,
&params->beacon, &params->beacon,
params->dtim_period); params->dtim_period);
@@ -8554,7 +8554,7 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
hdd_err("Error!!! Allocating the new beacon"); hdd_err("Error!!! Allocating the new beacon");
return -EINVAL; return -EINVAL;
} }
pAdapter->sessionCtx.ap.beacon = new; adapter->sessionCtx.ap.beacon = new;
if (params->chandef.width < NL80211_CHAN_WIDTH_80) if (params->chandef.width < NL80211_CHAN_WIDTH_80)
channel_type = cfg80211_get_chandef_type( channel_type = cfg80211_get_chandef_type(
@@ -8567,26 +8567,26 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
&params->chandef, &params->chandef,
channel_type); channel_type);
hdd_update_beacon_rate(pAdapter, wiphy, params); hdd_update_beacon_rate(adapter, wiphy, params);
/* set authentication type */ /* set authentication type */
switch (params->auth_type) { switch (params->auth_type) {
case NL80211_AUTHTYPE_OPEN_SYSTEM: case NL80211_AUTHTYPE_OPEN_SYSTEM:
pAdapter->sessionCtx.ap.sapConfig.authType = adapter->sessionCtx.ap.sapConfig.authType =
eSAP_OPEN_SYSTEM; eSAP_OPEN_SYSTEM;
break; break;
case NL80211_AUTHTYPE_SHARED_KEY: case NL80211_AUTHTYPE_SHARED_KEY:
pAdapter->sessionCtx.ap.sapConfig.authType = adapter->sessionCtx.ap.sapConfig.authType =
eSAP_SHARED_KEY; eSAP_SHARED_KEY;
break; break;
default: default:
pAdapter->sessionCtx.ap.sapConfig.authType = adapter->sessionCtx.ap.sapConfig.authType =
eSAP_AUTO_SWITCH; eSAP_AUTO_SWITCH;
} }
pAdapter->sessionCtx.ap.sapConfig.ch_width_orig = adapter->sessionCtx.ap.sapConfig.ch_width_orig =
params->chandef.width; params->chandef.width;
status = status =
wlan_hdd_cfg80211_start_bss(pAdapter, wlan_hdd_cfg80211_start_bss(adapter,
&params->beacon, &params->beacon,
params->ssid, params->ssid_len, params->ssid, params->ssid_len,
params->hidden_ssid, true, false); params->hidden_ssid, true, false);
@@ -8600,7 +8600,7 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
* If Do_Not_Break_Stream enabled send avoid channel list * If Do_Not_Break_Stream enabled send avoid channel list
* to application. * to application.
*/ */
if (policy_mgr_is_dnsc_set(pAdapter->hdd_vdev) && if (policy_mgr_is_dnsc_set(adapter->hdd_vdev) &&
sap_config->channel) { sap_config->channel) {
wlan_hdd_send_avoid_freq_for_dnbs(hdd_ctx, wlan_hdd_send_avoid_freq_for_dnbs(hdd_ctx,
sap_config->channel); sap_config->channel);
@@ -8612,11 +8612,11 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
hdd_err("Failed to allocate Memory"); hdd_err("Failed to allocate Memory");
return QDF_STATUS_E_FAILURE; return QDF_STATUS_E_FAILURE;
} }
sta_inactivity_timer->session_id = pAdapter->sessionId; sta_inactivity_timer->session_id = adapter->sessionId;
sta_inactivity_timer->sta_inactivity_timeout = sta_inactivity_timer->sta_inactivity_timeout =
params->inactivity_timeout; params->inactivity_timeout;
sme_update_sta_inactivity_timeout(WLAN_HDD_GET_HAL_CTX sme_update_sta_inactivity_timeout(WLAN_HDD_GET_HAL_CTX
(pAdapter), sta_inactivity_timer); (adapter), sta_inactivity_timer);
qdf_mem_free(sta_inactivity_timer); qdf_mem_free(sta_inactivity_timer);
} }
} }
@@ -8624,9 +8624,9 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy,
goto success; goto success;
err_start_bss: err_start_bss:
if (pAdapter->sessionCtx.ap.beacon) if (adapter->sessionCtx.ap.beacon)
qdf_mem_free(pAdapter->sessionCtx.ap.beacon); qdf_mem_free(adapter->sessionCtx.ap.beacon);
pAdapter->sessionCtx.ap.beacon = NULL; adapter->sessionCtx.ap.beacon = NULL;
success: success:
EXIT(); EXIT();
@@ -8666,7 +8666,7 @@ static int __wlan_hdd_cfg80211_change_beacon(struct wiphy *wiphy,
struct net_device *dev, struct net_device *dev,
struct cfg80211_beacon_data *params) struct cfg80211_beacon_data *params)
{ {
struct hdd_adapter *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev); struct hdd_adapter *adapter = WLAN_HDD_GET_PRIV_PTR(dev);
struct hdd_context *hdd_ctx; struct hdd_context *hdd_ctx;
struct hdd_beacon_data *old, *new; struct hdd_beacon_data *old, *new;
int status; int status;
@@ -8678,47 +8678,47 @@ static int __wlan_hdd_cfg80211_change_beacon(struct wiphy *wiphy,
return -EINVAL; return -EINVAL;
} }
if (wlan_hdd_validate_session_id(pAdapter->sessionId)) { if (wlan_hdd_validate_session_id(adapter->sessionId)) {
hdd_err("invalid session id: %d", pAdapter->sessionId); hdd_err("invalid session id: %d", adapter->sessionId);
return -EINVAL; return -EINVAL;
} }
MTRACE(qdf_trace(QDF_MODULE_ID_HDD, MTRACE(qdf_trace(QDF_MODULE_ID_HDD,
TRACE_CODE_HDD_CFG80211_CHANGE_BEACON, TRACE_CODE_HDD_CFG80211_CHANGE_BEACON,
pAdapter->sessionId, pAdapter->device_mode)); adapter->sessionId, adapter->device_mode));
hdd_debug("Device_mode %s(%d)", hdd_debug("Device_mode %s(%d)",
hdd_device_mode_to_string(pAdapter->device_mode), hdd_device_mode_to_string(adapter->device_mode),
pAdapter->device_mode); adapter->device_mode);
hdd_ctx = WLAN_HDD_GET_CTX(pAdapter); hdd_ctx = WLAN_HDD_GET_CTX(adapter);
status = wlan_hdd_validate_context(hdd_ctx); status = wlan_hdd_validate_context(hdd_ctx);
if (0 != status) if (0 != status)
return status; return status;
if (!(pAdapter->device_mode == QDF_SAP_MODE || if (!(adapter->device_mode == QDF_SAP_MODE ||
pAdapter->device_mode == QDF_P2P_GO_MODE)) { adapter->device_mode == QDF_P2P_GO_MODE)) {
return -EOPNOTSUPP; return -EOPNOTSUPP;
} }
old = pAdapter->sessionCtx.ap.beacon; old = adapter->sessionCtx.ap.beacon;
if (!old) { if (!old) {
hdd_err("session id: %d beacon data points to NULL", hdd_err("session id: %d beacon data points to NULL",
pAdapter->sessionId); adapter->sessionId);
return -EINVAL; return -EINVAL;
} }
status = wlan_hdd_cfg80211_alloc_new_beacon(pAdapter, &new, params, 0); status = wlan_hdd_cfg80211_alloc_new_beacon(adapter, &new, params, 0);
if (status != QDF_STATUS_SUCCESS) { if (status != QDF_STATUS_SUCCESS) {
hdd_err("new beacon alloc failed"); hdd_err("new beacon alloc failed");
return -EINVAL; return -EINVAL;
} }
pAdapter->sessionCtx.ap.beacon = new; adapter->sessionCtx.ap.beacon = new;
hdd_debug("update beacon for P2P GO/SAP"); hdd_debug("update beacon for P2P GO/SAP");
status = wlan_hdd_cfg80211_start_bss(pAdapter, params, NULL, status = wlan_hdd_cfg80211_start_bss(adapter, params, NULL,
0, 0, false, true); 0, 0, false, true);
EXIT(); EXIT();

4
core/hdd/src/wlan_hdd_hostapd.h
View File

@@ -52,7 +52,7 @@ struct hdd_adapter *hdd_wlan_create_ap_dev(struct hdd_context *hdd_ctx,
unsigned char name_assign_type, unsigned char name_assign_type,
uint8_t *name); uint8_t *name);
QDF_STATUS hdd_unregister_hostapd(struct hdd_adapter *pAdapter, bool rtnl_held); QDF_STATUS hdd_unregister_hostapd(struct hdd_adapter *adapter, bool rtnl_held);
eCsrAuthType eCsrAuthType
hdd_translate_rsn_to_csr_auth_type(uint8_t auth_suite[4]); hdd_translate_rsn_to_csr_auth_type(uint8_t auth_suite[4]);
@@ -125,7 +125,7 @@ int hdd_softap_unpack_ie(tHalHandle halHandle,
QDF_STATUS hdd_hostapd_sap_event_cb(tpSap_Event pSapEvent, QDF_STATUS hdd_hostapd_sap_event_cb(tpSap_Event pSapEvent,
void *usrDataForCallback); void *usrDataForCallback);
QDF_STATUS hdd_init_ap_mode(struct hdd_adapter *pAdapter, bool reinit); QDF_STATUS hdd_init_ap_mode(struct hdd_adapter *adapter, bool reinit);
void hdd_set_ap_ops(struct net_device *pWlanHostapdDev); void hdd_set_ap_ops(struct net_device *pWlanHostapdDev);
int hdd_hostapd_stop(struct net_device *dev); int hdd_hostapd_stop(struct net_device *dev);
int hdd_sap_context_init(struct hdd_context *hdd_ctx); int hdd_sap_context_init(struct hdd_context *hdd_ctx);