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

qcacld-3.0: TDLS: remove remaining legacy code

Browse Source 
Clear up tdls legacy init/deini, helper functions and structures.
Also remove legacy code in vendor nl80211 and iwpriv commands.

Change-Id: I983851d8cc0d3605c3d6bd0d8975c72844f71740
CRs-Fixed: 2105075
This commit is contained in:
Frank Liu
2017-09-07 14:49:05 +08:00
committed by snandini
parent 1b8212057d
commit 5c63dc8f82
10 changed files with 39 additions and 2784 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
core/hdd/inc/wlan_hdd_main.h
View File

@@ -128,7 +128,6 @@
#define WMM_INIT_DONE (3) #define WMM_INIT_DONE (3)
#define SOFTAP_BSS_STARTED (4) #define SOFTAP_BSS_STARTED (4)
#define DEVICE_IFACE_OPENED (5) #define DEVICE_IFACE_OPENED (5)
#define TDLS_INIT_DONE (6)
#define ACS_PENDING (7) #define ACS_PENDING (7)
#define SOFTAP_INIT_DONE (8) #define SOFTAP_INIT_DONE (8)
@@ -726,10 +725,6 @@ struct hdd_station_ctx {
/* Handle to the Wireless Extension State */ /* Handle to the Wireless Extension State */
hdd_wext_state_t WextState; hdd_wext_state_t WextState;
#ifdef FEATURE_WLAN_TDLS
tdlsCtx_t *pHddTdlsCtx;
#endif
/* Connection information*/ /* Connection information*/
struct hdd_connection_info conn_info; struct hdd_connection_info conn_info;
@@ -1157,13 +1152,6 @@ struct hdd_adapter {
struct completion rem_on_chan_ready_event; struct completion rem_on_chan_ready_event;
struct completion sta_authorized_event; struct completion sta_authorized_event;
#ifdef FEATURE_WLAN_TDLS
struct completion tdls_add_station_comp;
struct completion tdls_del_station_comp;
struct completion tdls_mgmt_comp;
struct completion tdls_link_establish_req_comp;
QDF_STATUS tdlsAddStaStatus;
#endif
struct completion ibss_peer_info_comp; struct completion ibss_peer_info_comp;
@@ -1338,14 +1326,6 @@ struct hdd_adapter {
#define WLAN_HDD_GET_HOSTAP_STATE_PTR(pAdapter) (&(pAdapter)->sessionCtx.ap.HostapdState) #define WLAN_HDD_GET_HOSTAP_STATE_PTR(pAdapter) (&(pAdapter)->sessionCtx.ap.HostapdState)
#define WLAN_HDD_GET_CFG_STATE_PTR(pAdapter) (&(pAdapter)->cfg80211State) #define WLAN_HDD_GET_CFG_STATE_PTR(pAdapter) (&(pAdapter)->cfg80211State)
#define WLAN_HDD_GET_SAP_CTX_PTR(pAdapter) (pAdapter->sessionCtx.ap.sapContext) #define WLAN_HDD_GET_SAP_CTX_PTR(pAdapter) (pAdapter->sessionCtx.ap.sapContext)
#ifdef FEATURE_WLAN_TDLS
#define WLAN_HDD_IS_TDLS_SUPPORTED_ADAPTER(pAdapter) \
(((QDF_STA_MODE != pAdapter->device_mode) && \
(QDF_P2P_CLIENT_MODE != pAdapter->device_mode)) ? 0 : 1)
#define WLAN_HDD_GET_TDLS_CTX_PTR(pAdapter) \
((WLAN_HDD_IS_TDLS_SUPPORTED_ADAPTER(pAdapter)) ? \
(tdlsCtx_t *)(pAdapter)->sessionCtx.station.pHddTdlsCtx : NULL)
#endif
#ifdef WLAN_FEATURE_NAN_DATAPATH #ifdef WLAN_FEATURE_NAN_DATAPATH
#ifndef WLAN_FEATURE_NAN_CONVERGENCE #ifndef WLAN_FEATURE_NAN_CONVERGENCE
@@ -1630,32 +1610,6 @@ struct hdd_context {
qdf_wake_lock_t rx_wake_lock; qdf_wake_lock_t rx_wake_lock;
qdf_wake_lock_t sap_wake_lock; qdf_wake_lock_t sap_wake_lock;
#ifdef FEATURE_WLAN_TDLS
enum tdls_support_mode tdls_mode;
enum tdls_support_mode tdls_mode_last;
tdlsConnInfo_t tdlsConnInfo[HDD_MAX_NUM_TDLS_STA];
/* maximum TDLS station number allowed upon runtime condition */
uint16_t max_num_tdls_sta;
/* TDLS peer connected count */
uint16_t connected_peer_count;
/* Lock to avoid race condition during TDLS operations */
qdf_spinlock_t tdls_ct_spinlock;
/* linear mac address table for counting the packets */
struct tdls_ct_mac_table ct_peer_mac_table[TDLS_CT_MAC_MAX_TABLE_SIZE];
/* number of valid mac entry in @ct_peer_mac_table */
uint8_t valid_mac_entries;
struct mutex tdls_lock;
uint8_t tdls_off_channel;
uint16_t tdls_channel_offset;
int32_t tdls_fw_off_chan_mode;
uint8_t tdls_external_peer_count;
bool tdls_nss_switch_in_progress;
bool tdls_nss_teardown_complete;
enum tdls_nss_transition_type tdls_nss_transition_mode;
int32_t tdls_teardown_peers_cnt;
struct tdls_set_state_info set_state_info;
#endif
void *hdd_ipa; void *hdd_ipa;
/* Use below lock to protect access to isSchedScanUpdatePending /* Use below lock to protect access to isSchedScanUpdatePending

459
core/hdd/inc/wlan_hdd_tdls.h
View File

@@ -34,25 +34,6 @@
struct hdd_context; struct hdd_context;
/*
* enum tdls_support_mode - TDLS support modes
* @eTDLS_SUPPORT_NOT_ENABLED: TDLS support not enabled
* @eTDLS_SUPPORT_DISABLED: suppress implicit trigger and not respond
* to the peer
* @eTDLS_SUPPORT_EXPLICIT_TRIGGER_ONLY: suppress implicit trigger,
* but respond to the peer
* @eTDLS_SUPPORT_ENABLED: implicit trigger
* @eTDLS_SUPPORT_EXTERNAL_CONTROL: implicit trigger but only to a
* peer mac configured by user space.
*/
enum tdls_support_mode {
eTDLS_SUPPORT_NOT_ENABLED = 0,
eTDLS_SUPPORT_DISABLED,
eTDLS_SUPPORT_EXPLICIT_TRIGGER_ONLY,
eTDLS_SUPPORT_ENABLED,
eTDLS_SUPPORT_EXTERNAL_CONTROL,
};
/** /**
* enum tdls_concerned_external_events - External events that affect TDLS * enum tdls_concerned_external_events - External events that affect TDLS
* @P2P_ROC_START: P2P remain on channel starts * @P2P_ROC_START: P2P remain on channel starts
@@ -65,60 +46,10 @@ enum tdls_concerned_external_events {
#ifdef FEATURE_WLAN_TDLS #ifdef FEATURE_WLAN_TDLS
/*
* Before UpdateTimer expires, we want to timeout discovery response
* should not be more than 2000.
*/
#define TDLS_DISCOVERY_TIMEOUT_BEFORE_UPDATE 1000
#define TDLS_CTX_MAGIC 0x54444c53 /* "TDLS" */
#define TDLS_MAX_SCAN_SCHEDULE 10
#define TDLS_MAX_SCAN_REJECT 5
#define TDLS_DELAY_SCAN_PER_CONNECTION 100
#define TDLS_MAX_CONNECTED_PEERS_TO_ALLOW_SCAN 1
#define TDLS_IS_CONNECTED(peer) \
((eTDLS_LINK_CONNECTED == (peer)->link_status) || \
(eTDLS_LINK_TEARING == (peer)->link_status))
/* Bit mask flag for tdls_option to FW */ /* Bit mask flag for tdls_option to FW */
#define ENA_TDLS_OFFCHAN (1 << 0) /* TDLS Off Channel support */ #define ENA_TDLS_OFFCHAN (1 << 0) /* TDLS Off Channel support */
#define ENA_TDLS_BUFFER_STA (1 << 1) /* TDLS Buffer STA support */ #define ENA_TDLS_BUFFER_STA (1 << 1) /* TDLS Buffer STA support */
#define ENA_TDLS_SLEEP_STA (1 << 2) /* TDLS Sleep STA support */ #define ENA_TDLS_SLEEP_STA (1 << 2) /* TDLS Sleep STA support */
#define TDLS_SEC_OFFCHAN_OFFSET_0 0
#define TDLS_SEC_OFFCHAN_OFFSET_40PLUS 40
#define TDLS_SEC_OFFCHAN_OFFSET_40MINUS (-40)
#define TDLS_SEC_OFFCHAN_OFFSET_80 80
#define TDLS_SEC_OFFCHAN_OFFSET_160 160
#define TDLS_PEER_LIST_SIZE 256
#define TDLS_CT_MAC_AGE_OUT_TIME (30*60*1000) /* Age out time is 30 mins */
#define EXTTDLS_EVENT_BUF_SIZE (4096)
#define TDLS_CT_MAC_MAX_TABLE_SIZE 8
/* Define the interval for 5 minutes */
#define TDLS_ENABLE_CDS_FLUSH_INTERVAL 300000000
/**
* enum tdls_disable_source - TDLS disable sources
* @HDD_SET_TDLS_MODE_SOURCE_USER: disable from user
* @HDD_SET_TDLS_MODE_SOURCE_SCAN: disable during scan
* @HDD_SET_TDLS_MODE_SOURCE_OFFCHANNEL: disable during offchannel
* @HDD_SET_TDLS_MODE_SOURCE_BTC: disable during bluetooth
* @HDD_SET_TDLS_MODE_SOURCE_P2P: disable during p2p
*/
enum tdls_disable_source {
HDD_SET_TDLS_MODE_SOURCE_USER = 0,
HDD_SET_TDLS_MODE_SOURCE_SCAN,
HDD_SET_TDLS_MODE_SOURCE_OFFCHANNEL,
HDD_SET_TDLS_MODE_SOURCE_BTC,
HDD_SET_TDLS_MODE_SOURCE_P2P,
};
/** /**
* struct tdls_config_params_t - tdls config params * struct tdls_config_params_t - tdls config params
* *
@@ -144,310 +75,12 @@ typedef struct {
int32_t rssi_delta; int32_t rssi_delta;
} tdls_config_params_t; } tdls_config_params_t;
/**
* enum tdls_spatial_streams - TDLS spatial streams
* @TDLS_NSS_1x1_MODE: TDLS tx/rx spatial streams = 1
* @TDLS_NSS_2x2_MODE: TDLS tx/rx spatial streams = 2
*/
enum tdls_spatial_streams {
TDLS_NSS_1x1_MODE = 0,
TDLS_NSS_2x2_MODE = 0xff,
};
/**
* enum tdls_nss_transition_type - TDLS NSS transition states
* @TDLS_NSS_TRANSITION_UNKNOWN: default state
* @TDLS_NSS_TRANSITION_2x2_to_1x1: transition from 2x2 to 1x1 stream
* @TDLS_NSS_TRANSITION_1x1_to_2x2: transition from 1x1 to 2x2 stream
*/
enum tdls_nss_transition_type {
TDLS_NSS_TRANSITION_UNKNOWN = 0,
TDLS_NSS_TRANSITION_2x2_to_1x1,
TDLS_NSS_TRANSITION_1x1_to_2x2,
};
/**
* enum tdls_cap_type - tdls capability type
*
* @eTDLS_CAP_NOT_SUPPORTED: tdls not supported
* @eTDLS_CAP_UNKNOWN: unknown capability
* @eTDLS_CAP_SUPPORTED: tdls capability supported
*/
enum tdls_cap_type {
eTDLS_CAP_NOT_SUPPORTED = -1,
eTDLS_CAP_UNKNOWN = 0,
eTDLS_CAP_SUPPORTED = 1,
};
/**
* enum tdls_link_status - tdls link status
*
* @eTDLS_LINK_IDLE: tdls link idle
* @eTDLS_LINK_DISCOVERING: tdls link discovering
* @eTDLS_LINK_DISCOVERED: tdls link discovered
* @eTDLS_LINK_CONNECTING: tdls link connecting
* @eTDLS_LINK_CONNECTED: tdls link connected
* @eTDLS_LINK_TEARING: tdls link tearing
*/
enum tdls_link_status {
eTDLS_LINK_IDLE = 0,
eTDLS_LINK_DISCOVERING,
eTDLS_LINK_DISCOVERED,
eTDLS_LINK_CONNECTING,
eTDLS_LINK_CONNECTED,
eTDLS_LINK_TEARING,
};
/**
* enum tdls_teardown_reason - Reason for TDLS teardown
* @eTDLS_TEARDOWN_EXT_CTRL: Reason ext ctrl.
* @eTDLS_TEARDOWN_CONCURRENCY: Reason concurrency.
* @eTDLS_TEARDOWN_RSSI_THRESHOLD: Reason rssi threshold.
* @eTDLS_TEARDOWN_TXRX_THRESHOLD: Reason txrx threshold.
* @eTDLS_TEARDOWN_BTCOEX: Reason BTCOEX.
* @eTDLS_TEARDOWN_SCAN: Reason scan.
* @eTDLS_TEARDOWN_BSS_DISCONNECT: Reason bss disconnected.
* @eTDLS_TEARDOWN_ANTENNA_SWITCH: Disconnected due to antenna switch
*
* Reason to indicate in diag event of tdls teardown.
*/
enum tdls_teardown_reason {
eTDLS_TEARDOWN_EXT_CTRL,
eTDLS_TEARDOWN_CONCURRENCY,
eTDLS_TEARDOWN_RSSI_THRESHOLD,
eTDLS_TEARDOWN_TXRX_THRESHOLD,
eTDLS_TEARDOWN_BTCOEX,
eTDLS_TEARDOWN_SCAN,
eTDLS_TEARDOWN_BSS_DISCONNECT,
eTDLS_TEARDOWN_ANTENNA_SWITCH,
};
/**
* enum tdls_link_reason - tdls link reason
*
* @eTDLS_LINK_SUCCESS: Success
* @eTDLS_LINK_UNSPECIFIED: Unspecified reason
* @eTDLS_LINK_NOT_SUPPORTED: Remote side doesn't support TDLS
* @eTDLS_LINK_UNSUPPORTED_BAND: Remote side doesn't support this band
* @eTDLS_LINK_NOT_BENEFICIAL: Going to AP is better than direct
* @eTDLS_LINK_DROPPED_BY_REMOTE: Remote side doesn't want it anymore
*/
enum tdls_link_reason {
eTDLS_LINK_SUCCESS,
eTDLS_LINK_UNSPECIFIED = -1,
eTDLS_LINK_NOT_SUPPORTED = -2,
eTDLS_LINK_UNSUPPORTED_BAND = -3,
eTDLS_LINK_NOT_BENEFICIAL = -4,
eTDLS_LINK_DROPPED_BY_REMOTE = -5
};
/**
* struct tdls_req_params_t - tdls request parameters
*
* @channel: channel hint, in channel number (NOT frequency)
* @global_operating_class: operating class to use
* @max_latency_ms: max latency that can be tolerated by apps
* @min_bandwidth_kbps: bandwidth required by apps, in kilo bits per second
*/
typedef struct {
int channel;
int global_operating_class;
int max_latency_ms;
int min_bandwidth_kbps;
} tdls_req_params_t;
/**
* enum tdls_state - tdls state
*
* @QCA_WIFI_HAL_TDLS_DISABLED: TDLS is not enabled, or is disabled now
* @QCA_WIFI_HAL_TDLS_ENABLED: TDLS is enabled, but not yet tried
* @QCA_WIFI_HAL_TDLS_ESTABLISHED: Direct link is established
* @QCA_WIFI_HAL_TDLS_ESTABLISHED_OFF_CHANNEL: Direct link established using MCC
* @QCA_WIFI_HAL_TDLS_DROPPED: Direct link was established, but is now dropped
* @QCA_WIFI_HAL_TDLS_FAILED: Direct link failed
*/
enum tdls_state {
QCA_WIFI_HAL_TDLS_DISABLED = 1,
QCA_WIFI_HAL_TDLS_ENABLED,
QCA_WIFI_HAL_TDLS_ESTABLISHED,
QCA_WIFI_HAL_TDLS_ESTABLISHED_OFF_CHANNEL,
QCA_WIFI_HAL_TDLS_DROPPED,
QCA_WIFI_HAL_TDLS_FAILED
};
typedef int (*cfg80211_exttdls_callback)(const uint8_t *mac, typedef int (*cfg80211_exttdls_callback)(const uint8_t *mac,
uint32_t opclass, uint32_t opclass,
uint32_t channel, uint32_t channel,
uint32_t state, uint32_t state,
int32_t reason, void *ctx); int32_t reason, void *ctx);
/**
* struct tdls_tx_tput_config_t - tdls tx throughput config
*
* @period: period
* @bytes: bytes
*/
typedef struct {
uint16_t period;
uint16_t bytes;
} tdls_tx_tput_config_t;
/**
* struct tdls_discovery_config_t - tdls discovery config
*
* @period: period
* @tries: number of tries
*/
typedef struct {
uint16_t period;
uint16_t tries;
} tdls_discovery_config_t;
/**
* struct tdls_rx_idle_config_t - tdls rx idle config
*
* @timeout: timeout
*/
typedef struct {
uint16_t timeout;
} tdls_rx_idle_config_t;
/**
* struct tdls_rssi_config_t - tdls rssi config
*
* @rssi_thres: rssi_thres
*/
typedef struct {
uint16_t rssi_thres;
} tdls_rssi_config_t;
struct _hddTdlsPeer_t;
/**
* struct tdls_ct_mac_table - connection tracker peer mac address table
* @mac_address: peer mac address
* @tx_packet_cnt: number of tx pkts
* @rx_packet_cnt: number of rx pkts
* @peer_timestamp_ms: time stamp of latest peer traffic
*/
struct tdls_ct_mac_table {
struct qdf_mac_addr mac_address;
uint32_t tx_packet_cnt;
uint32_t rx_packet_cnt;
uint32_t peer_timestamp_ms;
};
/**
* struct tdls_set_state_db - set state command data base
* @set_state_cnt: tdls set state count
* @vdev_id: vdev id of last set state command
*/
struct tdls_set_state_info {
uint8_t set_state_cnt;
uint8_t vdev_id;
};
/**
* struct tdlsCtx_t - tdls context
*
* @peer_list: peer list
* @pAdapter: pointer to adapter
* @peerDiscoverTimer: peer discovery timer
* @threshold_config: threshold config
* @discovery_peer_cnt: discovery peer count
* @discovery_sent_cnt: discovery sent count
* @ap_rssi: ap rssi
* @curr_candidate: current candidate
* @magic: magic
* @last_flush_ts: last timestamp when flush logs was displayed.
*
*/
typedef struct {
struct list_head peer_list[TDLS_PEER_LIST_SIZE];
struct hdd_adapter *pAdapter;
tdls_config_params_t threshold_config;
int32_t discovery_peer_cnt;
uint32_t discovery_sent_cnt;
int8_t ap_rssi;
struct _hddTdlsPeer_t *curr_candidate;
uint32_t magic;
uint64_t last_flush_ts;
} tdlsCtx_t;
/**
* struct hddTdlsPeer_t - tdls peer data
*
* @node: node
* @pHddTdlsCtx: pointer to tdls context
* @peerMac: peer mac address
* @staId: station identifier
* @rssi: rssi
* @tdls_support: tdls support
* @link_status: tdls link status
* @signature: signature
* @is_responder: is responder
* @discovery_processed: discovery processed flag
* @discovery_attempt: discovery attempt
* @uapsdQueues: uapsd queues
* @maxSp: max sp
* @isBufSta: is buffer sta
* @isOffChannelSupported: is offchannel supported flag
* @supported_channels_len: supported channels length
* @supported_channels: supported channels
* @supported_oper_classes_len: supported operation classes length
* @supported_oper_classes: supported operation classes
* @isForcedPeer: is forced peer
* @op_class_for_pref_off_chan: op class for preferred off channel
* @pref_off_chan_num: preferred off channel number
* @op_class_for_pref_off_chan_is_set: op class for preferred off channel set
* @spatial_streams: Number of TX/RX spatial streams for TDLS
* @reason: reason
* @state_change_notification: state change notification
* @qos: QOS capability of TDLS link
*/
typedef struct _hddTdlsPeer_t {
struct list_head node;
tdlsCtx_t *pHddTdlsCtx;
tSirMacAddr peerMac;
uint16_t staId;
int8_t rssi;
enum tdls_cap_type tdls_support;
enum tdls_link_status link_status;
uint8_t signature;
uint8_t is_responder;
uint8_t discovery_processed;
uint16_t discovery_attempt;
uint8_t uapsdQueues;
uint8_t maxSp;
uint8_t isBufSta;
uint8_t isOffChannelSupported;
uint8_t supported_channels_len;
uint8_t supported_channels[SIR_MAC_MAX_SUPP_CHANNELS];
uint8_t supported_oper_classes_len;
uint8_t supported_oper_classes[REG_MAX_SUPP_OPER_CLASSES];
bool isForcedPeer;
uint8_t op_class_for_pref_off_chan;
uint8_t pref_off_chan_num;
uint8_t op_class_for_pref_off_chan_is_set;
uint8_t spatial_streams;
enum tdls_link_reason reason;
cfg80211_exttdls_callback state_change_notification;
uint8_t qos;
} hddTdlsPeer_t;
/**
* struct tdlsConnInfo_t - tdls connection info
*
* @sessionId: Session ID
* @staId: TDLS peer station id
* @peerMac: peer mac address
*/
typedef struct {
uint8_t sessionId;
uint8_t staId;
struct qdf_mac_addr peerMac;
} tdlsConnInfo_t;
/** /**
* struct tdlsInfo_t - tdls info * struct tdlsInfo_t - tdls info
* *
@@ -486,50 +119,12 @@ typedef struct {
uint32_t tdls_peer_kickout_threshold; uint32_t tdls_peer_kickout_threshold;
} tdlsInfo_t; } tdlsInfo_t;
int wlan_hdd_tdls_init(struct hdd_adapter *pAdapter);
void wlan_hdd_tdls_exit(struct hdd_adapter *pAdapter);
void wlan_hdd_tdls_extract_sa(struct sk_buff *skb, uint8_t *mac);
hddTdlsPeer_t *wlan_hdd_tdls_find_peer(struct hdd_adapter *pAdapter,
const uint8_t *mac);
hddTdlsPeer_t *wlan_hdd_tdls_find_all_peer(struct hdd_context *hdd_ctx,
const uint8_t *mac);
hddTdlsPeer_t *wlan_hdd_tdls_get_peer(struct hdd_adapter *pAdapter,
const uint8_t *mac);
void wlan_hdd_tdls_set_peer_link_status(hddTdlsPeer_t *curr_peer,
enum tdls_link_status status,
enum tdls_link_reason reason);
int wlan_hdd_tdls_set_params(struct net_device *dev, int wlan_hdd_tdls_set_params(struct net_device *dev,
tdls_config_params_t *config); tdls_config_params_t *config);
uint16_t wlan_hdd_tdls_connected_peers(struct hdd_adapter *pAdapter);
int wlan_hdd_tdls_get_all_peers(struct hdd_adapter *pAdapter, char *buf, int wlan_hdd_tdls_get_all_peers(struct hdd_adapter *pAdapter, char *buf,
int buflen); int buflen);
void wlan_hdd_tdls_indicate_teardown(struct hdd_adapter *pAdapter,
hddTdlsPeer_t *curr_peer,
uint16_t reason);
int wlan_hdd_tdls_set_extctrl_param(struct hdd_adapter *pAdapter,
const uint8_t *mac,
uint32_t chan,
uint32_t max_latency,
uint32_t op_class, uint32_t min_bandwidth);
int wlan_hdd_tdls_set_force_peer(struct hdd_adapter *pAdapter,
const uint8_t *mac,
bool forcePeer);
int wlan_hdd_tdls_update_peer_mac(struct hdd_adapter *adapter,
const uint8_t *mac,
uint32_t peer_state);
int wlan_hdd_tdls_extctrl_deconfig_peer(struct hdd_adapter *pAdapter, int wlan_hdd_tdls_extctrl_deconfig_peer(struct hdd_adapter *pAdapter,
const uint8_t *peer); const uint8_t *peer);
int wlan_hdd_tdls_extctrl_config_peer(struct hdd_adapter *pAdapter, int wlan_hdd_tdls_extctrl_config_peer(struct hdd_adapter *pAdapter,
@@ -539,14 +134,6 @@ int wlan_hdd_tdls_extctrl_config_peer(struct hdd_adapter *pAdapter,
uint32_t max_latency, uint32_t max_latency,
uint32_t op_class, uint32_t op_class,
uint32_t min_bandwidth); uint32_t min_bandwidth);
int wlan_hdd_tdls_get_status(struct hdd_adapter *pAdapter,
const uint8_t *mac, uint32_t *opclass,
uint32_t *channel, uint32_t *state,
int32_t *reason);
void wlan_hdd_tdls_get_wifi_hal_state(hddTdlsPeer_t *curr_peer,
uint32_t *state, int32_t *reason);
int wlan_hdd_set_callback(hddTdlsPeer_t *curr_peer,
cfg80211_exttdls_callback callback);
int wlan_hdd_cfg80211_exttdls_enable(struct wiphy *wiphy, int wlan_hdd_cfg80211_exttdls_enable(struct wiphy *wiphy,
struct wireless_dev *wdev, struct wireless_dev *wdev,
@@ -610,15 +197,10 @@ int wlan_hdd_cfg80211_tdls_mgmt(struct wiphy *wiphy,
#endif #endif
#endif #endif
hddTdlsPeer_t *
wlan_hdd_tdls_find_first_connected_peer(struct hdd_adapter *adapter);
int hdd_set_tdls_offchannel(struct hdd_context *hdd_ctx, int offchannel); int hdd_set_tdls_offchannel(struct hdd_context *hdd_ctx, int offchannel);
int hdd_set_tdls_secoffchanneloffset(struct hdd_context *hdd_ctx, int hdd_set_tdls_secoffchanneloffset(struct hdd_context *hdd_ctx, int offchanoffset);
int offchanoffset);
int hdd_set_tdls_offchannelmode(struct hdd_adapter *adapter, int offchanmode); int hdd_set_tdls_offchannelmode(struct hdd_adapter *adapter, int offchanmode);
int hdd_set_tdls_scan_type(struct hdd_context *hdd_ctx, int val); int hdd_set_tdls_scan_type(struct hdd_context *hdd_ctx, int val);
void hdd_tdls_context_init(struct hdd_context *hdd_ctx, bool ssr);
void hdd_tdls_context_destroy(struct hdd_context *hdd_ctx);
int wlan_hdd_tdls_antenna_switch(struct hdd_context *hdd_ctx, int wlan_hdd_tdls_antenna_switch(struct hdd_context *hdd_ctx,
struct hdd_adapter *adapter, struct hdd_adapter *adapter,
uint32_t mode); uint32_t mode);
@@ -645,12 +227,6 @@ QDF_STATUS hdd_tdls_deregister_tdl_peer(void *userdata,
uint32_t vdev_id, uint8_t sta_id); uint32_t vdev_id, uint8_t sta_id);
#else #else
static inline void hdd_update_tdls_ct_and_teardown_links(struct hdd_context *hdd_ctx)
{
}
static inline void wlan_hdd_tdls_exit(struct hdd_adapter *adapter)
{
}
static inline int wlan_hdd_tdls_antenna_switch(struct hdd_context *hdd_ctx, static inline int wlan_hdd_tdls_antenna_switch(struct hdd_context *hdd_ctx,
struct hdd_adapter *adapter, struct hdd_adapter *adapter,
@@ -658,15 +234,6 @@ static inline int wlan_hdd_tdls_antenna_switch(struct hdd_context *hdd_ctx,
{ {
return 0; return 0;
} }
static inline void wlan_hdd_update_tdls_info(struct hdd_adapter *adapter,
bool tdls_prohibited,
bool tdls_chan_swit_prohibited)
{
}
static inline void wlan_hdd_tdls_notify_disconnect(struct hdd_adapter *adapter,
bool lfr_roam)
{
}
static inline int wlan_hdd_cfg80211_configure_tdls_mode(struct wiphy *wiphy, static inline int wlan_hdd_cfg80211_configure_tdls_mode(struct wiphy *wiphy,
struct wireless_dev *wdev, struct wireless_dev *wdev,
@@ -676,9 +243,6 @@ static inline int wlan_hdd_cfg80211_configure_tdls_mode(struct wiphy *wiphy,
return 0; return 0;
} }
static inline void wlan_hdd_change_tdls_mode(void *hdd_ctx)
{
}
static inline void static inline void
hdd_tdls_notify_p2p_roc(struct hdd_context *hdd_ctx, hdd_tdls_notify_p2p_roc(struct hdd_context *hdd_ctx,
enum tdls_concerned_external_events event) enum tdls_concerned_external_events event)
@@ -700,25 +264,4 @@ static QDF_STATUS hdd_tdls_deregister_tdl_peer(void *userdata,
{ {
} }
#endif /* End of FEATURE_WLAN_TDLS */ #endif /* End of FEATURE_WLAN_TDLS */
#ifdef FEATURE_WLAN_DIAG_SUPPORT
void hdd_send_wlan_tdls_teardown_event(uint32_t reason,
uint8_t *peer_mac);
void hdd_wlan_tdls_enable_link_event(const uint8_t *peer_mac,
uint8_t is_off_chan_supported,
uint8_t is_off_chan_configured,
uint8_t is_off_chan_established);
void hdd_wlan_block_scan_by_tdls_event(void);
#else
static inline
void hdd_send_wlan_tdls_teardown_event(uint32_t reason,
uint8_t *peer_mac) {}
static inline
void hdd_wlan_tdls_enable_link_event(const uint8_t *peer_mac,
uint8_t is_off_chan_supported,
uint8_t is_off_chan_configured,
uint8_t is_off_chan_established) {}
static inline void hdd_wlan_block_scan_by_tdls_event(void) {}
#endif /* FEATURE_WLAN_DIAG_SUPPORT */
bool cds_check_is_tdls_allowed(enum tQDF_ADAPTER_MODE device_mode);
#endif /* __HDD_TDLS_H */ #endif /* __HDD_TDLS_H */

14
core/hdd/src/wlan_hdd_cfg80211.c
View File

@@ -707,6 +707,7 @@ static int __wlan_hdd_cfg80211_get_tdls_capabilities(struct wiphy *wiphy,
struct hdd_context *hdd_ctx = wiphy_priv(wiphy); struct hdd_context *hdd_ctx = wiphy_priv(wiphy);
struct sk_buff *skb; struct sk_buff *skb;
uint32_t set = 0; uint32_t set = 0;
uint32_t max_num_tdls_sta = 0;
ENTER_DEV(wdev->netdev); ENTER_DEV(wdev->netdev);
@@ -739,11 +740,17 @@ static int __wlan_hdd_cfg80211_get_tdls_capabilities(struct wiphy *wiphy,
WIFI_TDLS_EXTERNAL_CONTROL_SUPPORT : 0); WIFI_TDLS_EXTERNAL_CONTROL_SUPPORT : 0);
set = set | (hdd_ctx->config->fEnableTDLSOffChannel ? set = set | (hdd_ctx->config->fEnableTDLSOffChannel ?
WIIF_TDLS_OFFCHANNEL_SUPPORT : 0); WIIF_TDLS_OFFCHANNEL_SUPPORT : 0);
if (hdd_ctx->config->fEnableTDLSSleepSta ||
hdd_ctx->config->fEnableTDLSBufferSta ||
hdd_ctx->config->fEnableTDLSOffChannel)
max_num_tdls_sta = HDD_MAX_NUM_TDLS_STA_P_UAPSD_OFFCHAN;
else
max_num_tdls_sta = HDD_MAX_NUM_TDLS_STA;
hdd_debug("TDLS Feature supported value %x", set); hdd_debug("TDLS Feature supported value %x", set);
if (nla_put_u32(skb, PARAM_MAX_TDLS_SESSION, if (nla_put_u32(skb, PARAM_MAX_TDLS_SESSION,
hdd_ctx->max_num_tdls_sta) || max_num_tdls_sta) ||
nla_put_u32(skb, PARAM_TDLS_FEATURE_SUPPORT, nla_put_u32(skb, PARAM_TDLS_FEATURE_SUPPORT, set)) {
set)) {
hdd_err("nla put fail"); hdd_err("nla put fail");
goto fail; goto fail;
} }
@@ -13458,7 +13465,6 @@ static int __wlan_hdd_cfg80211_change_iface(struct wiphy *wiphy,
case NL80211_IFTYPE_P2P_CLIENT: case NL80211_IFTYPE_P2P_CLIENT:
case NL80211_IFTYPE_ADHOC: case NL80211_IFTYPE_ADHOC:
if (type == NL80211_IFTYPE_ADHOC) { if (type == NL80211_IFTYPE_ADHOC) {
wlan_hdd_tdls_exit(pAdapter);
hdd_deregister_tx_flow_control(pAdapter); hdd_deregister_tx_flow_control(pAdapter);
hdd_debug("Setting interface Type to ADHOC"); hdd_debug("Setting interface Type to ADHOC");
} }

11
core/hdd/src/wlan_hdd_ioctl.c
View File

@@ -6513,17 +6513,6 @@ static int drv_cmd_set_antenna_mode(struct hdd_adapter *adapter,
} }
ret = 0; ret = 0;
exit: exit:
#ifdef FEATURE_WLAN_TDLS
/* Reset tdls NSS flags */
if (hdd_ctx->tdls_nss_switch_in_progress &&
hdd_ctx->tdls_nss_teardown_complete) {
hdd_ctx->tdls_nss_switch_in_progress = false;
hdd_ctx->tdls_nss_teardown_complete = false;
}
hdd_debug("tdls_nss_switch_in_progress: %d tdls_nss_teardown_complete: %d",
hdd_ctx->tdls_nss_switch_in_progress,
hdd_ctx->tdls_nss_teardown_complete);
#endif
hdd_debug("Set antenna status: %d current mode: %d", hdd_debug("Set antenna status: %d current mode: %d",
ret, hdd_ctx->current_antenna_mode); ret, hdd_ctx->current_antenna_mode);
return ret; return ret;

49
core/hdd/src/wlan_hdd_main.c
View File

@@ -3126,12 +3126,6 @@ static struct hdd_adapter *hdd_alloc_station_adapter(struct hdd_context *hdd_ctx
init_completion(&adapter->sta_authorized_event); init_completion(&adapter->sta_authorized_event);
init_completion(&adapter->offchannel_tx_event); init_completion(&adapter->offchannel_tx_event);
init_completion(&adapter->tx_action_cnf_event); init_completion(&adapter->tx_action_cnf_event);
#ifdef FEATURE_WLAN_TDLS
init_completion(&adapter->tdls_add_station_comp);
init_completion(&adapter->tdls_del_station_comp);
init_completion(&adapter->tdls_mgmt_comp);
init_completion(&adapter->tdls_link_establish_req_comp);
#endif
init_completion(&adapter->ibss_peer_info_comp); init_completion(&adapter->ibss_peer_info_comp);
init_completion(&adapter->change_country_code); init_completion(&adapter->change_country_code);
@@ -3252,36 +3246,6 @@ QDF_STATUS hdd_sme_close_session_callback(void *pContext)
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
/**
* hdd_check_and_init_tdls() - check and init TDLS operation for desired mode
* @adapter: pointer to device adapter
*
* This routine will check the mode of adapter and if it is required then it
* will initialize the TDLS operations
*
* Return: QDF_STATUS
*/
#ifdef FEATURE_WLAN_TDLS
static QDF_STATUS hdd_check_and_init_tdls(struct hdd_adapter *adapter)
{
if (adapter->device_mode == QDF_IBSS_MODE)
return QDF_STATUS_SUCCESS;
if (wlan_hdd_tdls_init(adapter)) {
hdd_err("wlan_hdd_tdls_init failed");
return QDF_STATUS_E_FAILURE;
}
set_bit(TDLS_INIT_DONE, &adapter->event_flags);
return QDF_STATUS_SUCCESS;
}
#else
static QDF_STATUS hdd_check_and_init_tdls(struct hdd_adapter *adapter)
{
return QDF_STATUS_SUCCESS;
}
#endif
int hdd_vdev_ready(struct hdd_adapter *adapter) int hdd_vdev_ready(struct hdd_adapter *adapter)
{ {
QDF_STATUS status; QDF_STATUS status;
@@ -3504,16 +3468,9 @@ QDF_STATUS hdd_init_station_mode(struct hdd_adapter *adapter)
if (ret_val) if (ret_val)
hdd_err("WMI_PDEV_PARAM_BURST_ENABLE set failed %d", ret_val); hdd_err("WMI_PDEV_PARAM_BURST_ENABLE set failed %d", ret_val);
status = hdd_check_and_init_tdls(adapter);
if (status != QDF_STATUS_SUCCESS)
goto error_tdls_init;
adapter->dev->features |= NETIF_F_LRO; adapter->dev->features |= NETIF_F_LRO;
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
error_tdls_init:
clear_bit(WMM_INIT_DONE, &adapter->event_flags);
hdd_wmm_adapter_close(adapter);
error_wmm_init: error_wmm_init:
clear_bit(INIT_TX_RX_SUCCESS, &adapter->event_flags); clear_bit(INIT_TX_RX_SUCCESS, &adapter->event_flags);
hdd_deinit_tx_rx(adapter); hdd_deinit_tx_rx(adapter);
@@ -3586,7 +3543,6 @@ static void hdd_station_adapter_deinit(struct hdd_context *hdd_ctx,
} }
hdd_cleanup_actionframe(hdd_ctx, adapter); hdd_cleanup_actionframe(hdd_ctx, adapter);
wlan_hdd_tdls_exit(adapter);
EXIT(); EXIT();
} }
@@ -5900,8 +5856,6 @@ static int hdd_context_deinit(struct hdd_context *hdd_ctx)
hdd_rx_wake_lock_destroy(hdd_ctx); hdd_rx_wake_lock_destroy(hdd_ctx);
hdd_tdls_context_destroy(hdd_ctx);
hdd_scan_context_destroy(hdd_ctx); hdd_scan_context_destroy(hdd_ctx);
qdf_list_destroy(&hdd_ctx->hddAdapters); qdf_list_destroy(&hdd_ctx->hddAdapters);
@@ -7713,8 +7667,6 @@ static int hdd_context_init(struct hdd_context *hdd_ctx)
if (ret) if (ret)
goto list_destroy; goto list_destroy;
hdd_tdls_context_init(hdd_ctx, false);
hdd_rx_wake_lock_create(hdd_ctx); hdd_rx_wake_lock_create(hdd_ctx);
ret = hdd_sap_context_init(hdd_ctx); ret = hdd_sap_context_init(hdd_ctx);
@@ -7745,7 +7697,6 @@ sap_destroy:
scan_destroy: scan_destroy:
hdd_scan_context_destroy(hdd_ctx); hdd_scan_context_destroy(hdd_ctx);
hdd_rx_wake_lock_destroy(hdd_ctx); hdd_rx_wake_lock_destroy(hdd_ctx);
hdd_tdls_context_destroy(hdd_ctx);
list_destroy: list_destroy:
qdf_list_destroy(&hdd_ctx->hddAdapters); qdf_list_destroy(&hdd_ctx->hddAdapters);

1981
core/hdd/src/wlan_hdd_tdls.c
View File

File diff suppressed because it is too large Load Diff

4
core/mac/inc/ani_global.h
View File

@@ -927,10 +927,6 @@ typedef struct sAniSirGlobal {
tp2pContext p2pContext; tp2pContext p2pContext;
#endif #endif
#ifdef FEATURE_WLAN_TDLS
bool is_tdls_power_save_prohibited;
#endif
uint8_t isCoalesingInIBSSAllowed; uint8_t isCoalesingInIBSSAllowed;
bool imps_enabled; bool imps_enabled;

9
core/sme/inc/sme_api.h
View File

@@ -678,13 +678,6 @@ bool sme_get_is_ft_feature_enabled(tHalHandle hHal);
QDF_STATUS sme_update_roam_scan_offload_enabled(tHalHandle hHal, QDF_STATUS sme_update_roam_scan_offload_enabled(tHalHandle hHal,
bool nRoamScanOffloadEnabled); bool nRoamScanOffloadEnabled);
bool sme_is_feature_supported_by_fw(enum cap_bitmap feature); bool sme_is_feature_supported_by_fw(enum cap_bitmap feature);
#ifdef FEATURE_WLAN_TDLS
void sme_set_tdls_power_save_prohibited(tHalHandle hHal, uint32_t sessionId,
bool val);
QDF_STATUS sme_send_tdls_chan_switch_req(
tHalHandle hal,
sme_tdls_chan_switch_params *ch_switch_params);
#endif
/* /*
* SME API to enable/disable WLAN driver initiated SSR * SME API to enable/disable WLAN driver initiated SSR
@@ -739,8 +732,6 @@ QDF_STATUS sme_get_reg_info(tHalHandle hHal, uint8_t chanId,
#ifdef FEATURE_WLAN_TDLS #ifdef FEATURE_WLAN_TDLS
QDF_STATUS sme_update_fw_tdls_state(tHalHandle hHal, void *psmeTdlsParams, QDF_STATUS sme_update_fw_tdls_state(tHalHandle hHal, void *psmeTdlsParams,
bool useSmeLock); bool useSmeLock);
QDF_STATUS sme_update_tdls_peer_state(tHalHandle hHal,
tSmeTdlsPeerStateParams *pPeerStateParams);
#endif /* FEATURE_WLAN_TDLS */ #endif /* FEATURE_WLAN_TDLS */
QDF_STATUS sme_ch_avoid_update_req(tHalHandle hHal); QDF_STATUS sme_ch_avoid_update_req(tHalHandle hHal);
#ifdef FEATURE_WLAN_AUTO_SHUTDOWN #ifdef FEATURE_WLAN_AUTO_SHUTDOWN

4
core/sme/inc/sme_power_save.h
View File

@@ -103,9 +103,7 @@ struct ps_params {
tpSirWakeReasonInd wake_reason_ind); tpSirWakeReasonInd wake_reason_ind);
void *wake_reason_ind_cb_ctx; void *wake_reason_ind_cb_ctx;
#endif /* WLAN_WAKEUP_EVENTS */ #endif /* WLAN_WAKEUP_EVENTS */
#ifdef FEATURE_WLAN_TDLS
bool is_tdls_power_save_prohibited;
#endif
/* /*
* Auto Sta Ps Enable Timer * Auto Sta Ps Enable Timer
* Upon expiration of this timer * Upon expiration of this timer

246
core/sme/src/common/sme_api.c
View File

@@ -763,9 +763,6 @@ QDF_STATUS sme_open(tHalHandle hHal)
sme_err("sme_ps_open failed with status: %d", status); sme_err("sme_ps_open failed with status: %d", status);
return status; return status;
} }
#ifdef FEATURE_WLAN_TDLS
pMac->is_tdls_power_save_prohibited = 0;
#endif
#ifndef WLAN_MDM_CODE_REDUCTION_OPT #ifndef WLAN_MDM_CODE_REDUCTION_OPT
status = sme_qos_open(pMac); status = sme_qos_open(pMac);
@@ -8985,22 +8982,6 @@ bool sme_is_feature_supported_by_fw(enum cap_bitmap feature)
} }
#ifdef FEATURE_WLAN_TDLS #ifdef FEATURE_WLAN_TDLS
/* ---------------------------------------------------------------------------
\fn sme_set_tdls_power_save_prohibited
\API to set/reset the is_tdls_power_save_prohibited.
\- return void
-------------------------------------------------------------------------*/
void sme_set_tdls_power_save_prohibited(tHalHandle hHal, uint32_t sessionId,
bool val)
{
tpAniSirGlobal pMac = PMAC_STRUCT(hHal);
struct ps_global_info *ps_global_info = &pMac->sme.ps_global_info;
struct ps_params *ps_param = &ps_global_info->ps_params[sessionId];
ps_param->is_tdls_power_save_prohibited = val;
}
/* /*
* sme_update_fw_tdls_state() - * sme_update_fw_tdls_state() -
* SME will send message to WMA to set TDLS state in f/w * SME will send message to WMA to set TDLS state in f/w
@@ -9045,233 +9026,6 @@ QDF_STATUS sme_update_fw_tdls_state(tHalHandle hHal, void *psmeTdlsParams,
return status; return status;
} }
/**
* sme_update_tdls_peer_state() - to update the state of TDLS peer
* @hHal: The handle returned by mac_open
* @peerStateParams: TDLS Peer state info to update in f/w
*
* SME will send message to WMA to set TDLS Peer state in f/w
*
* Return: QDF_STATUS
*/
QDF_STATUS sme_update_tdls_peer_state(tHalHandle hHal,
tSmeTdlsPeerStateParams *peerStateParams)
{
QDF_STATUS status = QDF_STATUS_SUCCESS;
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
tpAniSirGlobal pMac = PMAC_STRUCT(hHal);
tTdlsPeerStateParams *pTdlsPeerStateParams = NULL;
tTdlsPeerCapParams *peer_cap = NULL;
struct scheduler_msg message = {0};
uint8_t num;
uint8_t peer_chan_len;
uint8_t chanId;
uint8_t i;
status = sme_acquire_global_lock(&pMac->sme);
if (!QDF_IS_STATUS_SUCCESS(status))
return status;
pTdlsPeerStateParams = qdf_mem_malloc(sizeof(*pTdlsPeerStateParams));
if (NULL == pTdlsPeerStateParams) {
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
FL("failed to allocate mem for tdls peer state param"));
sme_release_global_lock(&pMac->sme);
return QDF_STATUS_E_NOMEM;
}
qdf_mem_copy(&pTdlsPeerStateParams->peerMacAddr,
&peerStateParams->peerMacAddr, sizeof(tSirMacAddr));
pTdlsPeerStateParams->vdevId = peerStateParams->vdevId;
pTdlsPeerStateParams->peerState = peerStateParams->peerState;
switch (peerStateParams->peerState) {
case eSME_TDLS_PEER_STATE_PEERING:
pTdlsPeerStateParams->peerState =
WMA_TDLS_PEER_STATE_PEERING;
break;
case eSME_TDLS_PEER_STATE_CONNECTED:
pTdlsPeerStateParams->peerState =
WMA_TDLS_PEER_STATE_CONNECTED;
break;
case eSME_TDLS_PEER_STATE_TEARDOWN:
pTdlsPeerStateParams->peerState =
WMA_TDLS_PEER_STATE_TEARDOWN;
pTdlsPeerStateParams->resp_reqd = false;
break;
case eSME_TDLS_PEER_ADD_MAC_ADDR:
pTdlsPeerStateParams->peerState = WMA_TDLS_PEER_ADD_MAC_ADDR;
break;
case eSME_TDLS_PEER_REMOVE_MAC_ADDR:
pTdlsPeerStateParams->peerState = WMA_TDLS_PEER_REMOVE_MAC_ADDR;
break;
default:
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
FL("invalid peer state param (%d)"),
peerStateParams->peerState);
goto error_return;
}
peer_cap = &(pTdlsPeerStateParams->peerCap);
peer_cap->isPeerResponder =
peerStateParams->peerCap.isPeerResponder;
peer_cap->peerUapsdQueue =
peerStateParams->peerCap.peerUapsdQueue;
peer_cap->peerMaxSp =
peerStateParams->peerCap.peerMaxSp;
peer_cap->peerBuffStaSupport =
peerStateParams->peerCap.peerBuffStaSupport;
peer_cap->peerOffChanSupport =
peerStateParams->peerCap.peerOffChanSupport;
peer_cap->peerCurrOperClass =
peerStateParams->peerCap.peerCurrOperClass;
peer_cap->selfCurrOperClass =
peerStateParams->peerCap.selfCurrOperClass;
num = 0;
peer_chan_len = peerStateParams->peerCap.peerChanLen;
if (peer_chan_len <= SME_TDLS_MAX_SUPP_CHANNELS) {
for (i = 0; i < peerStateParams->peerCap.peerChanLen; i++) {
chanId = peerStateParams->peerCap.peerChan[i];
if (csr_roam_is_channel_valid(pMac, chanId) &&
!(wlan_reg_get_channel_state(pMac->pdev, chanId) ==
CHANNEL_STATE_DFS) &&
!WLAN_REG_IS_11P_CH(chanId)) {
peer_cap->peerChan[num].chanId = chanId;
peer_cap->peerChan[num].pwr =
csr_get_cfg_max_tx_power(pMac, chanId);
peer_cap->peerChan[num].dfsSet = false;
num++;
}
}
} else {
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
FL("invalid peer channel len (%d)"),
peer_chan_len);
goto error_return;
}
peer_cap->peerChanLen = num;
peer_cap->peerOperClassLen =
peerStateParams->peerCap.peerOperClassLen;
for (i = 0; i < HAL_TDLS_MAX_SUPP_OPER_CLASSES; i++) {
peer_cap->peerOperClass[i] =
peerStateParams->peerCap.peerOperClass[i];
}
peer_cap->prefOffChanNum =
peerStateParams->peerCap.prefOffChanNum;
peer_cap->prefOffChanBandwidth =
peerStateParams->peerCap.prefOffChanBandwidth;
peer_cap->opClassForPrefOffChan =
peerStateParams->peerCap.opClassForPrefOffChan;
message.type = WMA_UPDATE_TDLS_PEER_STATE;
message.reserved = 0;
message.bodyptr = pTdlsPeerStateParams;
qdf_status = scheduler_post_msg(QDF_MODULE_ID_WMA, &message);
if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
FL("scheduler_post_msg failed "));
goto error_return;
} else {
goto success_return;
}
error_return:
status = QDF_STATUS_E_FAILURE;
qdf_mem_free(pTdlsPeerStateParams);
success_return:
sme_release_global_lock(&pMac->sme);
return status;
}
/**
* sme_send_tdls_chan_switch_req() - send tdls channel switch request
* @hal: UMAC handler
* @ch_switch_params: Pointer to the chan switch parameter structure
*
* API to set tdls channel switch parameters.
*
* Return: QDF_STATUS_SUCCESS on success; another QDF_STATUS_** code otherwise
*/
QDF_STATUS sme_send_tdls_chan_switch_req(tHalHandle hal,
sme_tdls_chan_switch_params *ch_switch_params)
{
QDF_STATUS status = QDF_STATUS_SUCCESS;
QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
tpAniSirGlobal mac = PMAC_STRUCT(hal);
tdls_chan_switch_params *chan_switch_params = NULL;
struct scheduler_msg message = {0};
MTRACE(qdf_trace(QDF_MODULE_ID_SME,
TRACE_CODE_SME_RX_HDD_TDLS_CHAN_SWITCH_REQ,
NO_SESSION, ch_switch_params->tdls_off_channel));
status = sme_acquire_global_lock(&mac->sme);
if (QDF_STATUS_SUCCESS != status)
return status;
chan_switch_params = qdf_mem_malloc(sizeof(*chan_switch_params));
if (NULL == chan_switch_params) {
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
FL("fail to alloc mem for tdls chan switch param"));
sme_release_global_lock(&mac->sme);
return QDF_STATUS_E_FAILURE;
}
switch (ch_switch_params->tdls_off_ch_mode) {
case ENABLE_CHANSWITCH:
chan_switch_params->tdls_sw_mode = WMA_TDLS_ENABLE_OFFCHANNEL;
break;
case DISABLE_CHANSWITCH:
chan_switch_params->tdls_sw_mode = WMA_TDLS_DISABLE_OFFCHANNEL;
break;
default:
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
FL("invalid off channel command (%d)"),
ch_switch_params->tdls_off_ch_mode);
qdf_mem_free(chan_switch_params);
sme_release_global_lock(&mac->sme);
return QDF_STATUS_E_FAILURE;
}
qdf_mem_copy(&chan_switch_params->peer_mac_addr,
&ch_switch_params->peer_mac_addr, sizeof(tSirMacAddr));
chan_switch_params->vdev_id = ch_switch_params->vdev_id;
chan_switch_params->tdls_off_ch = ch_switch_params->tdls_off_channel;
chan_switch_params->tdls_off_ch_bw_offset =
ch_switch_params->tdls_off_ch_bw_offset;
chan_switch_params->is_responder = ch_switch_params->is_responder;
chan_switch_params->oper_class = ch_switch_params->opclass;
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_DEBUG,
FL("Country Code=%s, Req offset=%d, Selected Operate Class=%d"),
mac->scan.countryCodeCurrent,
chan_switch_params->tdls_off_ch_bw_offset,
chan_switch_params->oper_class);
message.type = WMA_TDLS_SET_OFFCHAN_MODE;
message.reserved = 0;
message.bodyptr = chan_switch_params;
qdf_status = scheduler_post_msg(QDF_MODULE_ID_WMA, &message);
if (!QDF_IS_STATUS_SUCCESS(qdf_status)) {
QDF_TRACE(QDF_MODULE_ID_SME, QDF_TRACE_LEVEL_ERROR,
FL("Message Post failed status=%d"),
qdf_status);
qdf_mem_free(chan_switch_params);
status = QDF_STATUS_E_FAILURE;
}
sme_release_global_lock(&mac->sme);
return status;
}
#endif /* FEATURE_WLAN_TDLS */ #endif /* FEATURE_WLAN_TDLS */
QDF_STATUS sme_get_link_speed(tHalHandle hHal, tSirLinkSpeedInfo *lsReq, QDF_STATUS sme_get_link_speed(tHalHandle hHal, tSirLinkSpeedInfo *lsReq,