From fd33cce7fbf74020e5d73c9f1032760fb29809de Mon Sep 17 00:00:00 2001 From: Jeff Johnson Date: Mon, 2 Oct 2017 13:28:39 -0700 Subject: [PATCH] qcacld-3.0: Rename pAdapter in wlan_hdd_hostapd.[ch] 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 --- core/hdd/src/wlan_hdd_hostapd.c | 336 ++++++++++++++++---------------- core/hdd/src/wlan_hdd_hostapd.h | 4 +- 2 files changed, 170 insertions(+), 170 deletions(-) diff --git a/core/hdd/src/wlan_hdd_hostapd.c b/core/hdd/src/wlan_hdd_hostapd.c index 1db25eb88a..1ea35e90a3 100644 --- a/core/hdd/src/wlan_hdd_hostapd.c +++ b/core/hdd/src/wlan_hdd_hostapd.c @@ -220,18 +220,18 @@ int hdd_sap_context_init(struct hdd_context *hdd_ctx) * hdd_hostapd_channel_allow_suspend() - allow suspend in a channel. * Called when, 1. bss stopped, 2. channel switch * - * @pAdapter: pointer to hdd adapter + * @adapter: pointer to hdd adapter * @channel: current channel * * 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) { - 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 = - WLAN_HDD_GET_HOSTAP_STATE_PTR(pAdapter); + WLAN_HDD_GET_HOSTAP_STATE_PTR(adapter); hdd_debug("bssState: %d, channel: %d, dfs_ref_cnt: %d", 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. * Called when, 1. bss started, 2. channel switch * - * @pAdapter: pointer to hdd adapter + * @adapter: pointer to hdd adapter * @channel: current channel * * 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) { - 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 = - WLAN_HDD_GET_HOSTAP_STATE_PTR(pAdapter); + WLAN_HDD_GET_HOSTAP_STATE_PTR(adapter); hdd_debug("bssState: %d, channel: %d, dfs_ref_cnt: %d", 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) { - struct hdd_adapter *pAdapter = netdev_priv(dev); - struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(pAdapter); + struct hdd_adapter *adapter = netdev_priv(dev); + struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter); int ret; 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 */ - ret = hdd_wlan_start_modules(hdd_ctx, pAdapter, false); + ret = hdd_wlan_start_modules(hdd_ctx, adapter, false); if (ret) { hdd_err("Failed to start WLAN modules return"); return ret; } - set_bit(DEVICE_IFACE_OPENED, &pAdapter->event_flags); + set_bit(DEVICE_IFACE_OPENED, &adapter->event_flags); /* Enable all Tx 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_CONTROL_PATH); EXIT(); @@ -6071,7 +6071,7 @@ const struct net_device_ops net_ops_struct = { .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; } @@ -6081,11 +6081,11 @@ void hdd_set_ap_ops(struct net_device *pWlanHostapdDev) 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 net_device *dev = pAdapter->dev; - struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(pAdapter); + struct net_device *dev = adapter->dev; + struct hdd_context *hdd_ctx = WLAN_HDD_GET_CTX(adapter); QDF_STATUS status; struct sap_context *sapContext = NULL; 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); if (reinit) - sapContext = pAdapter->sessionCtx.ap.sapContext; + sapContext = adapter->sessionCtx.ap.sapContext; else { sapContext = wlansap_open(); if (sapContext == NULL) { @@ -6105,20 +6105,20 @@ QDF_STATUS hdd_init_ap_mode(struct hdd_adapter *pAdapter, bool reinit) return QDF_STATUS_E_FAULT; } - pAdapter->sessionCtx.ap.sapContext = sapContext; - pAdapter->sessionCtx.ap.sapConfig.channel = + adapter->sessionCtx.ap.sapContext = sapContext; + adapter->sessionCtx.ap.sapConfig.channel = hdd_ctx->acs_policy.acs_channel; 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); } - if (pAdapter->device_mode == QDF_P2P_GO_MODE) { + if (adapter->device_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; } 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; } @@ -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 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) { hdd_err("failed to create objmgr vdev: %d", ret); return QDF_STATUS_E_FAILURE; } status = wlansap_start(sapContext, mode, - pAdapter->macAddressCurrent.bytes, - pAdapter->sessionId); + adapter->macAddressCurrent.bytes, + adapter->sessionId); if (QDF_IS_STATUS_ERROR(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. * 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; } /* 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) { hdd_err("failed to raise vdev ready event: %d", ret); goto error_init_ap_mode; } /* 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. */ memset(phostapdBuf, 0, sizeof(struct hdd_hostapd_state)); /* Set up the pointer to the Wireless Extensions state structure */ /* NOP */ - status = hdd_set_hostapd(pAdapter); + status = hdd_set_hostapd(adapter); if (!QDF_IS_STATUS_SUCCESS(status)) { hdd_err("hdd_set_hostapd failed!!"); 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)) { hdd_err("Hostapd HDD sta disassoc event init failed!!"); wlansap_close(sapContext); - pAdapter->sessionCtx.ap.sapContext = NULL; + adapter->sessionCtx.ap.sapContext = NULL; return status; } - init_completion(&pAdapter->session_close_comp_var); - init_completion(&pAdapter->session_open_comp_var); + init_completion(&adapter->session_close_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 */ dev->wireless_handlers = (struct iw_handler_def *)&hostapd_handler_def; /* 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)) 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)) { hdd_err("hdd_wmm_adapter_init() failed code: %08d [x%08x]", status, status); 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, hdd_ctx->config->enableSifsBurst, 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); if (!reinit) { - pAdapter->sessionCtx.ap.sapConfig.acs_cfg.acs_mode = false; - qdf_mem_free(pAdapter->sessionCtx.ap.sapConfig.acs_cfg.ch_list); - qdf_mem_zero(&pAdapter->sessionCtx.ap.sapConfig.acs_cfg, + adapter->sessionCtx.ap.sapConfig.acs_cfg.acs_mode = false; + qdf_mem_free(adapter->sessionCtx.ap.sapConfig.acs_cfg.ch_list); + qdf_mem_zero(&adapter->sessionCtx.ap.sapConfig.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; error_wmm_init: - hdd_softap_deinit_tx_rx(pAdapter); + hdd_softap_deinit_tx_rx(adapter); error_init_ap_mode: - QDF_BUG(!hdd_objmgr_destroy_vdev(pAdapter)); + QDF_BUG(!hdd_objmgr_destroy_vdev(adapter)); wlansap_close(sapContext); - QDF_BUG(!hdd_objmgr_release_vdev(pAdapter)); - pAdapter->sessionCtx.ap.sapContext = NULL; + QDF_BUG(!hdd_objmgr_release_vdev(adapter)); + adapter->sessionCtx.ap.sapContext = NULL; EXIT(); return status; @@ -6340,32 +6340,32 @@ struct hdd_adapter *hdd_wlan_create_ap_dev(struct hdd_context *hdd_ctx, /** * hdd_unregister_hostapd() - unregister hostapd - * @pAdapter: Pointer to hostapd adapter + * @adapter: Pointer to hostapd adapter * @rtnl_held: true if rtnl lock held; false otherwise * * 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; QDF_STATUS status; - void *sapContext = WLAN_HDD_GET_SAP_CTX_PTR(pAdapter); + void *sapContext = WLAN_HDD_GET_SAP_CTX_PTR(adapter); ENTER(); - hdd_softap_deinit_tx_rx(pAdapter); + hdd_softap_deinit_tx_rx(adapter); /* if we are being called during driver unload, * then the dev has already been invalidated. * if we are being called at other times, then we can * detach the wireless device handlers */ - if (pAdapter->dev) { + if (adapter->dev) { if (rtnl_held) - pAdapter->dev->wireless_handlers = NULL; + adapter->dev->wireless_handlers = NULL; else { rtnl_lock(); - pAdapter->dev->wireless_handlers = NULL; + adapter->dev->wireless_handlers = NULL; rtnl_unlock(); } } @@ -6374,16 +6374,16 @@ QDF_STATUS hdd_unregister_hostapd(struct hdd_adapter *pAdapter, bool rtnl_held) if (!QDF_IS_STATUS_SUCCESS(status)) hdd_err("Failed:wlansap_stop"); - ret = hdd_objmgr_destroy_vdev(pAdapter); + ret = hdd_objmgr_destroy_vdev(adapter); if (ret) hdd_err("objmgr vdev destroy failed"); status = wlansap_close(sapContext); if (!QDF_IS_STATUS_SUCCESS(status)) 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) hdd_err("objmgr vdev release failed"); @@ -6457,7 +6457,7 @@ int wlan_hdd_set_channel(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, enum nl80211_channel_type channel_type) { - struct hdd_adapter *pAdapter = NULL; + struct hdd_adapter *adapter = NULL; uint32_t num_ch = 0; int channel = 0; int channel_seg2 = 0; @@ -6474,17 +6474,17 @@ int wlan_hdd_set_channel(struct wiphy *wiphy, hdd_err("Called with dev = NULL"); return -ENODEV; } - pAdapter = WLAN_HDD_GET_PRIV_PTR(dev); + adapter = WLAN_HDD_GET_PRIV_PTR(dev); MTRACE(qdf_trace(QDF_MODULE_ID_HDD, TRACE_CODE_HDD_CFG80211_SET_CHANNEL, - pAdapter->sessionId, channel_type)); + adapter->sessionId, channel_type)); hdd_debug("Device_mode %s(%d) freq = %d", - hdd_device_mode_to_string(pAdapter->device_mode), - pAdapter->device_mode, chandef->chan->center_freq); + hdd_device_mode_to_string(adapter->device_mode), + 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); if (status) return status; @@ -6527,27 +6527,27 @@ int wlan_hdd_set_channel(struct wiphy *wiphy, num_ch = WNI_CFG_VALID_CHANNEL_LIST_LEN; - if ((QDF_SAP_MODE != pAdapter->device_mode) && - (QDF_P2P_GO_MODE != pAdapter->device_mode)) { + if ((QDF_SAP_MODE != adapter->device_mode) && + (QDF_P2P_GO_MODE != adapter->device_mode)) { if (QDF_STATUS_SUCCESS != - wlan_hdd_validate_operation_channel(pAdapter, channel)) { + wlan_hdd_validate_operation_channel(adapter, channel)) { hdd_err("Invalid Channel: %d", channel); return -EINVAL; } hdd_debug("set channel to [%d] for device mode %s(%d)", channel, - hdd_device_mode_to_string(pAdapter->device_mode), - pAdapter->device_mode); + hdd_device_mode_to_string(adapter->device_mode), + adapter->device_mode); } - if ((pAdapter->device_mode == QDF_STA_MODE) - || (pAdapter->device_mode == QDF_P2P_CLIENT_MODE) + if ((adapter->device_mode == QDF_STA_MODE) + || (adapter->device_mode == QDF_P2P_CLIENT_MODE) ) { struct hdd_wext_state *pWextState = - WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter); + WLAN_HDD_GET_WEXT_STATE_PTR(adapter); tCsrRoamProfile *pRoamProfile = &pWextState->roamProfile; struct hdd_station_ctx *pHddStaCtx = - WLAN_HDD_GET_STATION_CTX_PTR(pAdapter); + WLAN_HDD_GET_STATION_CTX_PTR(adapter); if (eConnectionState_IbssConnected == pHddStaCtx->conn_info.connState) { @@ -6560,13 +6560,13 @@ int wlan_hdd_set_channel(struct wiphy *wiphy, pHddStaCtx->conn_info.operationChannel = channel; pRoamProfile->ChannelInfo.ChannelList = &pHddStaCtx->conn_info.operationChannel; - } else if ((pAdapter->device_mode == QDF_SAP_MODE) - || (pAdapter->device_mode == QDF_P2P_GO_MODE) + } else if ((adapter->device_mode == QDF_SAP_MODE) + || (adapter->device_mode == QDF_P2P_GO_MODE) ) { - sap_config = &((WLAN_HDD_GET_AP_CTX_PTR(pAdapter))->sapConfig); - if (QDF_P2P_GO_MODE == pAdapter->device_mode) { + sap_config = &((WLAN_HDD_GET_AP_CTX_PTR(adapter))->sapConfig); + if (QDF_P2P_GO_MODE == adapter->device_mode) { if (QDF_STATUS_SUCCESS != - wlan_hdd_validate_operation_channel(pAdapter, + wlan_hdd_validate_operation_channel(adapter, channel)) { hdd_err("Invalid Channel: %d", channel); return -EINVAL; @@ -6576,7 +6576,7 @@ int wlan_hdd_set_channel(struct wiphy *wiphy, } else { /* set channel to what hostapd configured */ if (QDF_STATUS_SUCCESS != - wlan_hdd_validate_operation_channel(pAdapter, + wlan_hdd_validate_operation_channel(adapter, channel)) { hdd_err("Invalid Channel: %d", channel); return -EINVAL; @@ -6610,7 +6610,7 @@ int wlan_hdd_set_channel(struct wiphy *wiphy, return -EINVAL; } sme_config->csrConfig.obssEnabled = - wlan_hdd_get_sap_obss(pAdapter); + wlan_hdd_get_sap_obss(adapter); sme_update_config(hdd_ctx->hHal, 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 - * @pAdapter: Pointer to hostapd adapter + * @adapter: Pointer to hostapd adapter * @ppBeacon: Pointer to pointer to beacon data * @params: Pointer to beacon parameters * @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 */ 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 cfg80211_beacon_data *params, int dtim_period) @@ -6809,11 +6809,11 @@ wlan_hdd_cfg80211_alloc_new_beacon(struct hdd_adapter *pAdapter, return -EINVAL; } - old = pAdapter->sessionCtx.ap.beacon; + old = adapter->sessionCtx.ap.beacon; if (!params->head && !old) { hdd_err("session: %d old and new heads points to NULL", - pAdapter->sessionId); + adapter->sessionId); return -EINVAL; } @@ -6887,7 +6887,7 @@ wlan_hdd_cfg80211_alloc_new_beacon(struct hdd_adapter *pAdapter, *ppBeacon = beacon; - pAdapter->sessionCtx.ap.beacon = NULL; + adapter->sessionCtx.ap.beacon = NULL; qdf_mem_free(old); 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, 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_scan_info *pScanInfo = NULL; struct hdd_adapter *staAdapter = NULL; @@ -8099,17 +8099,17 @@ static int __wlan_hdd_cfg80211_stop_ap(struct wiphy *wiphy, return -EINVAL; } - if (wlan_hdd_validate_session_id(pAdapter->sessionId)) { - hdd_err("Invalid session id: %d", pAdapter->sessionId); + if (wlan_hdd_validate_session_id(adapter->sessionId)) { + hdd_err("Invalid session id: %d", adapter->sessionId); return -EINVAL; } MTRACE(qdf_trace(QDF_MODULE_ID_HDD, TRACE_CODE_HDD_CFG80211_STOP_AP, - pAdapter->sessionId, pAdapter->device_mode)); + adapter->sessionId, adapter->device_mode)); - if (!(pAdapter->device_mode == QDF_SAP_MODE || - pAdapter->device_mode == QDF_P2P_GO_MODE)) { + if (!(adapter->device_mode == QDF_SAP_MODE || + adapter->device_mode == QDF_P2P_GO_MODE)) { 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 * 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_device_mode_to_string(pAdapter->device_mode), - pAdapter->device_mode); + hdd_device_mode_to_string(adapter->device_mode), + adapter->device_mode); ret = wlan_hdd_validate_context(hdd_ctx); if (0 != ret) return ret; - if (pAdapter->device_mode == QDF_SAP_MODE) { - wlan_hdd_del_station(pAdapter); + if (adapter->device_mode == QDF_SAP_MODE) { + wlan_hdd_del_station(adapter); 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. */ 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); hdd_debug("Canceled the pending restart work"); qdf_spin_lock(&hdd_ctx->sap_update_info_lock); hdd_ctx->is_sap_restart_required = false; qdf_spin_unlock(&hdd_ctx->sap_update_info_lock); } - pAdapter->sessionCtx.ap.sapConfig.acs_cfg.acs_mode = false; - wlan_hdd_undo_acs(pAdapter); - qdf_mem_zero(&pAdapter->sessionCtx.ap.sapConfig.acs_cfg, + adapter->sessionCtx.ap.sapConfig.acs_cfg.acs_mode = false; + wlan_hdd_undo_acs(adapter); + qdf_mem_zero(&adapter->sessionCtx.ap.sapConfig.acs_cfg, sizeof(struct sap_acs_cfg)); hdd_debug("Disabling queues"); - wlan_hdd_netif_queue_control(pAdapter, + wlan_hdd_netif_queue_control(adapter, WLAN_STOP_ALL_NETIF_QUEUE_N_CARRIER, WLAN_CONTROL_PATH); - old = pAdapter->sessionCtx.ap.beacon; + old = adapter->sessionCtx.ap.beacon; if (!old) { hdd_err("Session id: %d beacon data points to NULL", - pAdapter->sessionId); + adapter->sessionId); return -EINVAL; } - hdd_cleanup_actionframe(hdd_ctx, pAdapter); - wlan_hdd_cleanup_remain_on_channel_ctx(pAdapter); + hdd_cleanup_actionframe(hdd_ctx, adapter); + wlan_hdd_cleanup_remain_on_channel_ctx(adapter); 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 = - WLAN_HDD_GET_HOSTAP_STATE_PTR(pAdapter); + WLAN_HDD_GET_HOSTAP_STATE_PTR(adapter); 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)) { qdf_status = qdf_wait_single_event(&pHostapdState-> @@ -8202,12 +8202,12 @@ static int __wlan_hdd_cfg80211_stop_ap(struct wiphy *wiphy, 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*/ policy_mgr_decr_session_set_pcl(hdd_ctx->hdd_psoc, - pAdapter->device_mode, - pAdapter->sessionId); - pAdapter->sessionCtx.ap.beacon = NULL; + adapter->device_mode, + adapter->sessionId); + adapter->sessionCtx.ap.beacon = NULL; qdf_mem_free(old); } mutex_unlock(&hdd_ctx->sap_lock); @@ -8220,28 +8220,28 @@ static int __wlan_hdd_cfg80211_stop_ap(struct wiphy *wiphy, return -EINVAL; } - qdf_copy_macaddr(&updateIE.bssid, &pAdapter->macAddressCurrent); - updateIE.smeSessionId = pAdapter->sessionId; + qdf_copy_macaddr(&updateIE.bssid, &adapter->macAddressCurrent); + updateIE.smeSessionId = adapter->sessionId; updateIE.ieBufferlength = 0; updateIE.pAdditionIEBuffer = NULL; updateIE.append = 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, eUPDATE_IE_PROBE_BCN) == QDF_STATUS_E_FAILURE) { 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, eUPDATE_IE_ASSOC_RESP) == QDF_STATUS_E_FAILURE) { hdd_err("Could not pass on ASSOC_RSP data to PE"); } /* Reset WNI_CFG_PROBE_RSP Flags */ - wlan_hdd_reset_prob_rspies(pAdapter); - hdd_destroy_acs_timer(pAdapter); + wlan_hdd_reset_prob_rspies(adapter); + hdd_destroy_acs_timer(adapter); #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)) { hdd_debug("[P2P State] From GO completed to Inactive state GO got removed"); 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 - * @pAdapter: Pointer to hdd_adapter_t + * @adapter: Pointer to hdd_adapter_t * @wiphy: Pointer to wiphy * @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 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; enum hw_mode_bandwidth channel_width; int status; @@ -8402,33 +8402,33 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy, 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()) { hdd_err("Command not allowed in FTM mode"); return -EINVAL; } - if (wlan_hdd_validate_session_id(pAdapter->sessionId)) { - hdd_err("Invalid session id: %d", pAdapter->sessionId); + if (wlan_hdd_validate_session_id(adapter->sessionId)) { + hdd_err("Invalid session id: %d", adapter->sessionId); return -EINVAL; } 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)); - if (WLAN_HDD_ADAPTER_MAGIC != pAdapter->magic) { + if (WLAN_HDD_ADAPTER_MAGIC != adapter->magic) { hdd_err("HDD adapter magic is invalid"); return -ENODEV; } - hdd_ctx = WLAN_HDD_GET_CTX(pAdapter); + hdd_ctx = WLAN_HDD_GET_CTX(adapter); status = wlan_hdd_validate_context(hdd_ctx); if (0 != status) return status; - hdd_debug("pAdapter = %pK, Device mode %s(%d) sub20 %d", - pAdapter, hdd_device_mode_to_string(pAdapter->device_mode), - pAdapter->device_mode, cds_is_sub_20_mhz_enabled()); + hdd_debug("adapter = %pK, Device mode %s(%d) sub20 %d", + adapter, hdd_device_mode_to_string(adapter->device_mode), + adapter->device_mode, cds_is_sub_20_mhz_enabled()); 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()) { enum channel_state ch_state; 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 */ if (channel == 0) { @@ -8491,7 +8491,7 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy, /* check if concurrency is allowed */ if (!policy_mgr_allow_concurrency(hdd_ctx->hdd_psoc, policy_mgr_convert_device_mode_to_qdf_type( - pAdapter->device_mode), + adapter->device_mode), channel, channel_width)) { 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"); status = policy_mgr_current_connections_update(hdd_ctx->hdd_psoc, - pAdapter->sessionId, channel, + adapter->sessionId, channel, SIR_UPDATE_REASON_START_AP); if (QDF_STATUS_E_FAILURE == status) { 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); - if (pAdapter->device_mode == QDF_P2P_GO_MODE) { + if (adapter->device_mode == QDF_P2P_GO_MODE) { struct hdd_adapter *p2p_adapter; 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) - || (pAdapter->device_mode == QDF_P2P_GO_MODE) + if ((adapter->device_mode == QDF_SAP_MODE) + || (adapter->device_mode == QDF_P2P_GO_MODE) ) { struct hdd_beacon_data *old, *new; enum nl80211_channel_type channel_type; 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) return -EALREADY; status = - wlan_hdd_cfg80211_alloc_new_beacon(pAdapter, &new, + wlan_hdd_cfg80211_alloc_new_beacon(adapter, &new, ¶ms->beacon, params->dtim_period); @@ -8554,7 +8554,7 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy, hdd_err("Error!!! Allocating the new beacon"); return -EINVAL; } - pAdapter->sessionCtx.ap.beacon = new; + adapter->sessionCtx.ap.beacon = new; if (params->chandef.width < NL80211_CHAN_WIDTH_80) channel_type = cfg80211_get_chandef_type( @@ -8567,26 +8567,26 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy, ¶ms->chandef, channel_type); - hdd_update_beacon_rate(pAdapter, wiphy, params); + hdd_update_beacon_rate(adapter, wiphy, params); /* set authentication type */ switch (params->auth_type) { case NL80211_AUTHTYPE_OPEN_SYSTEM: - pAdapter->sessionCtx.ap.sapConfig.authType = + adapter->sessionCtx.ap.sapConfig.authType = eSAP_OPEN_SYSTEM; break; case NL80211_AUTHTYPE_SHARED_KEY: - pAdapter->sessionCtx.ap.sapConfig.authType = + adapter->sessionCtx.ap.sapConfig.authType = eSAP_SHARED_KEY; break; default: - pAdapter->sessionCtx.ap.sapConfig.authType = + adapter->sessionCtx.ap.sapConfig.authType = eSAP_AUTO_SWITCH; } - pAdapter->sessionCtx.ap.sapConfig.ch_width_orig = + adapter->sessionCtx.ap.sapConfig.ch_width_orig = params->chandef.width; status = - wlan_hdd_cfg80211_start_bss(pAdapter, + wlan_hdd_cfg80211_start_bss(adapter, ¶ms->beacon, params->ssid, params->ssid_len, 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 * to application. */ - if (policy_mgr_is_dnsc_set(pAdapter->hdd_vdev) && + if (policy_mgr_is_dnsc_set(adapter->hdd_vdev) && sap_config->channel) { wlan_hdd_send_avoid_freq_for_dnbs(hdd_ctx, sap_config->channel); @@ -8612,11 +8612,11 @@ static int __wlan_hdd_cfg80211_start_ap(struct wiphy *wiphy, hdd_err("Failed to allocate Memory"); 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 = params->inactivity_timeout; sme_update_sta_inactivity_timeout(WLAN_HDD_GET_HAL_CTX - (pAdapter), sta_inactivity_timer); + (adapter), 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; err_start_bss: - if (pAdapter->sessionCtx.ap.beacon) - qdf_mem_free(pAdapter->sessionCtx.ap.beacon); - pAdapter->sessionCtx.ap.beacon = NULL; + if (adapter->sessionCtx.ap.beacon) + qdf_mem_free(adapter->sessionCtx.ap.beacon); + adapter->sessionCtx.ap.beacon = NULL; success: EXIT(); @@ -8666,7 +8666,7 @@ static int __wlan_hdd_cfg80211_change_beacon(struct wiphy *wiphy, struct net_device *dev, 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_beacon_data *old, *new; int status; @@ -8678,47 +8678,47 @@ static int __wlan_hdd_cfg80211_change_beacon(struct wiphy *wiphy, return -EINVAL; } - if (wlan_hdd_validate_session_id(pAdapter->sessionId)) { - hdd_err("invalid session id: %d", pAdapter->sessionId); + if (wlan_hdd_validate_session_id(adapter->sessionId)) { + hdd_err("invalid session id: %d", adapter->sessionId); return -EINVAL; } MTRACE(qdf_trace(QDF_MODULE_ID_HDD, TRACE_CODE_HDD_CFG80211_CHANGE_BEACON, - pAdapter->sessionId, pAdapter->device_mode)); + adapter->sessionId, adapter->device_mode)); hdd_debug("Device_mode %s(%d)", - hdd_device_mode_to_string(pAdapter->device_mode), - pAdapter->device_mode); + hdd_device_mode_to_string(adapter->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); if (0 != status) return status; - if (!(pAdapter->device_mode == QDF_SAP_MODE || - pAdapter->device_mode == QDF_P2P_GO_MODE)) { + if (!(adapter->device_mode == QDF_SAP_MODE || + adapter->device_mode == QDF_P2P_GO_MODE)) { return -EOPNOTSUPP; } - old = pAdapter->sessionCtx.ap.beacon; + old = adapter->sessionCtx.ap.beacon; if (!old) { hdd_err("session id: %d beacon data points to NULL", - pAdapter->sessionId); + adapter->sessionId); 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) { hdd_err("new beacon alloc failed"); return -EINVAL; } - pAdapter->sessionCtx.ap.beacon = new; + adapter->sessionCtx.ap.beacon = new; 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); EXIT(); diff --git a/core/hdd/src/wlan_hdd_hostapd.h b/core/hdd/src/wlan_hdd_hostapd.h index 6034966658..641eb12398 100644 --- a/core/hdd/src/wlan_hdd_hostapd.h +++ b/core/hdd/src/wlan_hdd_hostapd.h @@ -52,7 +52,7 @@ struct hdd_adapter *hdd_wlan_create_ap_dev(struct hdd_context *hdd_ctx, unsigned char name_assign_type, 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 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, 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); int hdd_hostapd_stop(struct net_device *dev); int hdd_sap_context_init(struct hdd_context *hdd_ctx);