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

qcacmn: Enable converged scan component

Browse Source 
Update WMI layer to adopt to converged scan module
and enable converged scan component init/deinit

Change-Id: I4f9da95f90f737ac8bdcaa54f9eb4e154f37d3de
CRs-Fixed: 1095299
This commit is contained in:
Om Prakash Tripathi
2017-02-25 15:53:30 +05:30
committed by Sandeep Puligilla
parent 4150902921
commit 1d83e35883
3 changed files with 205 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
wmi_unified_api.c
View File

@@ -745,7 +745,7 @@ QDF_STATUS wmi_unified_peer_assoc_send(void *wmi_hdl,
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/ */
QDF_STATUS wmi_unified_scan_start_cmd_send(void *wmi_hdl, QDF_STATUS wmi_unified_scan_start_cmd_send(void *wmi_hdl,
struct scan_start_params *param) struct scan_req_params *param)
{ {
wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
@@ -765,7 +765,7 @@ QDF_STATUS wmi_unified_scan_start_cmd_send(void *wmi_hdl,
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/ */
QDF_STATUS wmi_unified_scan_stop_cmd_send(void *wmi_hdl, QDF_STATUS wmi_unified_scan_stop_cmd_send(void *wmi_hdl,
struct scan_stop_params *param) struct scan_cancel_param *param)
{ {
wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;
@@ -5158,7 +5158,7 @@ QDF_STATUS wmi_extract_vdev_roam_param(void *wmi_hdl, void *evt_buf,
* Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS_E_FAILURE for failure
*/ */
QDF_STATUS wmi_extract_vdev_scan_ev_param(void *wmi_hdl, void *evt_buf, QDF_STATUS wmi_extract_vdev_scan_ev_param(void *wmi_hdl, void *evt_buf,
wmi_host_scan_event *param) struct scan_event *param)
{ {
wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl; wmi_unified_t wmi_handle = (wmi_unified_t) wmi_hdl;

164
wmi_unified_non_tlv.c
View File

@@ -1825,7 +1825,7 @@ static QDF_STATUS send_peer_assoc_cmd_non_tlv(wmi_unified_t wmi_handle,
* @return QDF_STATUS_SUCCESS on success and -ve on failure. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
*/ */
static QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle, static QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
struct scan_start_params *param) struct scan_req_params *param)
{ {
wmi_start_scan_cmd *cmd; wmi_start_scan_cmd *cmd;
wmi_buf_t buf; wmi_buf_t buf;
@@ -1852,11 +1852,11 @@ static QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
len += sizeof(wmi_bssid_list) + (param->num_bssid - 1) len += sizeof(wmi_bssid_list) + (param->num_bssid - 1)
* sizeof(wmi_mac_addr); * sizeof(wmi_mac_addr);
} }
if (param->ie_len) { if (param->extraie.len) {
i = param->ie_len % sizeof(A_UINT32); i = param->extraie.len % sizeof(A_UINT32);
if (i) if (i)
len += sizeof(A_UINT32) - i; len += sizeof(A_UINT32) - i;
len += 2 * sizeof(A_UINT32) + param->ie_len; len += 2 * sizeof(A_UINT32) + param->extraie.len;
} }
buf = wmi_buf_alloc(wmi_handle, len); buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) { if (!buf) {
@@ -1869,16 +1869,30 @@ static QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
cmd->scan_priority = param->scan_priority; cmd->scan_priority = param->scan_priority;
cmd->scan_id = param->scan_id; cmd->scan_id = param->scan_id;
cmd->scan_req_id = param->scan_req_id; cmd->scan_req_id = param->scan_req_id;
/** Scan events subscription */
cmd->notify_scan_events = WMI_SCAN_EVENT_STARTED | /* Scan events subscription */
WMI_SCAN_EVENT_COMPLETED | if (param->scan_ev_started)
WMI_SCAN_EVENT_BSS_CHANNEL | cmd->notify_scan_events |= WMI_SCAN_EVENT_STARTED;
WMI_SCAN_EVENT_FOREIGN_CHANNEL | if (param->scan_ev_completed)
WMI_SCAN_EVENT_DEQUEUED cmd->notify_scan_events |= WMI_SCAN_EVENT_COMPLETED;
#if QCA_LTEU_SUPPORT if (param->scan_ev_bss_chan)
| WMI_SCAN_EVENT_GPIO_TIMEOUT; cmd->notify_scan_events |= WMI_SCAN_EVENT_BSS_CHANNEL;
#endif if (param->scan_ev_foreign_chan)
; cmd->notify_scan_events |= WMI_SCAN_EVENT_FOREIGN_CHANNEL;
if (param->scan_ev_dequeued)
cmd->notify_scan_events |= WMI_SCAN_EVENT_DEQUEUED;
if (param->scan_ev_preempted)
cmd->notify_scan_events |= WMI_SCAN_EVENT_PREEMPTED;
if (param->scan_ev_start_failed)
cmd->notify_scan_events |= WMI_SCAN_EVENT_START_FAILED;
if (param->scan_ev_restarted)
cmd->notify_scan_events |= WMI_SCAN_EVENT_RESTARTED;
if (param->scan_ev_foreign_chn_exit)
cmd->notify_scan_events |= WMI_SCAN_EVENT_FOREIGN_CHANNEL_EXIT;
if (param->scan_ev_invalid)
cmd->notify_scan_events |= WMI_SCAN_EVENT_INVALID;
if (param->scan_ev_gpio_timeout)
cmd->notify_scan_events |= WMI_SCAN_EVENT_GPIO_TIMEOUT;
/** Max. active channel dwell time */ /** Max. active channel dwell time */
cmd->dwell_time_active = param->dwell_time_active; cmd->dwell_time_active = param->dwell_time_active;
@@ -1886,24 +1900,31 @@ static QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
cmd->dwell_time_passive = param->dwell_time_passive; cmd->dwell_time_passive = param->dwell_time_passive;
/** Scan control flags */ /** Scan control flags */
cmd->scan_ctrl_flags = (param->passive_flag) ? cmd->scan_ctrl_flags = 0;
WMI_SCAN_FLAG_PASSIVE : 0; if (param->scan_f_passive)
cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
if (param->is_strict_pscan_en) { if (param->scan_f_strict_passive_pch)
cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_STRICT_PASSIVE_ON_PCHN; cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_STRICT_PASSIVE_ON_PCHN;
} if (param->scan_f_promisc_mode)
if (param->is_promiscous_mode)
cmd->scan_ctrl_flags |= WMI_SCAN_PROMISCOUS_MODE; cmd->scan_ctrl_flags |= WMI_SCAN_PROMISCOUS_MODE;
if (param->scan_f_capture_phy_err)
if (param->is_phy_error)
cmd->scan_ctrl_flags |= WMI_SCAN_CAPTURE_PHY_ERROR; cmd->scan_ctrl_flags |= WMI_SCAN_CAPTURE_PHY_ERROR;
if (param->scan_f_half_rate)
if (param->half_rate)
cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_HALF_RATE_SUPPORT; cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_HALF_RATE_SUPPORT;
if (param->scan_f_quarter_rate)
if (param->quarter_rate)
cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_QUARTER_RATE_SUPPORT; cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_QUARTER_RATE_SUPPORT;
if (param->scan_f_cck_rates)
cmd->scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
if (param->scan_f_chan_stat_evnt)
cmd->scan_ctrl_flags |= WMI_SCAN_CHAN_STAT_EVENT;
if (param->scan_f_bcast_probe)
cmd->scan_ctrl_flags |= WMI_SCAN_ADD_BCAST_PROBE_REQ;
if (param->scan_f_offchan_mgmt_tx)
cmd->scan_ctrl_flags |= WMI_SCAN_OFFCHAN_MGMT_TX;
if (param->scan_f_offchan_data_tx)
cmd->scan_ctrl_flags |= WMI_SCAN_OFFCHAN_DATA_TX;
/* Always enable ofdm rates */
cmd->scan_ctrl_flags |= WMI_SCAN_ADD_OFDM_RATES;
/** send multiple braodcast probe req with this delay in between */ /** send multiple braodcast probe req with this delay in between */
cmd->repeat_probe_time = param->repeat_probe_time; cmd->repeat_probe_time = param->repeat_probe_time;
@@ -1925,20 +1946,6 @@ static QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
#else #else
cmd->max_scan_time = param->max_scan_time; cmd->max_scan_time = param->max_scan_time;
#endif #endif
cmd->scan_ctrl_flags |= WMI_SCAN_ADD_OFDM_RATES;
/* add cck rates if required */
if (param->add_cck_rates)
cmd->scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
/** It enables the Channel stat event indication to host */
if (param->chan_stat_enable)
cmd->scan_ctrl_flags |= WMI_SCAN_CHAN_STAT_EVENT;
if (param->add_bcast_probe_reqd)
cmd->scan_ctrl_flags |= WMI_SCAN_ADD_BCAST_PROBE_REQ;
/* off channel TX control */
if (param->offchan_tx_mgmt)
cmd->scan_ctrl_flags |= WMI_SCAN_OFFCHAN_MGMT_TX;
if (param->offchan_tx_data)
cmd->scan_ctrl_flags |= WMI_SCAN_OFFCHAN_DATA_TX;
tmp_ptr = (A_UINT32 *) (cmd + 1); tmp_ptr = (A_UINT32 *) (cmd + 1);
#ifdef TEST_CODE #ifdef TEST_CODE
#define DEFAULT_TIME 150 #define DEFAULT_TIME 150
@@ -1972,7 +1979,7 @@ static QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
ssid_list->ssids[i].ssid_len = param->ssid[i].length; ssid_list->ssids[i].ssid_len = param->ssid[i].length;
WMI_HOST_IF_MSG_COPY_CHAR_ARRAY( WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(
ssid_list->ssids[i].ssid, ssid_list->ssids[i].ssid,
param->ssid[i].mac_ssid, param->ssid[i].ssid,
param->ssid[i].length); param->ssid[i].length);
} }
tmp_ptr += (2 + (sizeof(wmi_ssid) * tmp_ptr += (2 + (sizeof(wmi_ssid) *
@@ -1983,18 +1990,19 @@ static QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
bssid_list->tag = WMI_BSSID_LIST_TAG; bssid_list->tag = WMI_BSSID_LIST_TAG;
bssid_list->num_bssid = param->num_bssid; bssid_list->num_bssid = param->num_bssid;
for (i = 0; i < param->num_bssid; ++i) { for (i = 0; i < param->num_bssid; ++i) {
WMI_CHAR_ARRAY_TO_MAC_ADDR(&(param->bssid_list[i][0]), WMI_CHAR_ARRAY_TO_MAC_ADDR(
&bssid_list->bssid_list[i]); &(param->bssid_list[i].bytes[0]),
&bssid_list->bssid_list[i]);
} }
tmp_ptr += (2 + (sizeof(wmi_mac_addr) * tmp_ptr += (2 + (sizeof(wmi_mac_addr) *
param->num_bssid)/sizeof(A_UINT32)); param->num_bssid)/sizeof(A_UINT32));
} }
if (param->ie_len) { if (param->extraie.len) {
ie_data = (wmi_ie_data *) tmp_ptr; ie_data = (wmi_ie_data *) tmp_ptr;
ie_data->tag = WMI_IE_TAG; ie_data->tag = WMI_IE_TAG;
ie_data->ie_len = param->ie_len; ie_data->ie_len = param->extraie.len;
WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(ie_data->ie_data, WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(ie_data->ie_data,
param->ie_data, param->ie_len); param->extraie.ptr, param->extraie.len);
} }
qdf_print("Sending SCAN START cmd\n"); qdf_print("Sending SCAN START cmd\n");
return wmi_unified_cmd_send(wmi_handle, buf, len, WMI_START_SCAN_CMDID); return wmi_unified_cmd_send(wmi_handle, buf, len, WMI_START_SCAN_CMDID);
@@ -2008,12 +2016,11 @@ static QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
* @return QDF_STATUS_SUCCESS on success and -ve on failure. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
*/ */
static QDF_STATUS send_scan_stop_cmd_non_tlv(wmi_unified_t wmi_handle, static QDF_STATUS send_scan_stop_cmd_non_tlv(wmi_unified_t wmi_handle,
struct scan_stop_params *param) struct scan_cancel_param *param)
{ {
wmi_stop_scan_cmd *cmd = NULL; wmi_stop_scan_cmd *cmd = NULL;
wmi_buf_t buf; wmi_buf_t buf;
u_int32_t len = sizeof(wmi_stop_scan_cmd); u_int32_t len = sizeof(wmi_stop_scan_cmd);
wmi_scan_event wmi_scn_event;
buf = wmi_buf_alloc(wmi_handle, len); buf = wmi_buf_alloc(wmi_handle, len);
if (!buf) { if (!buf) {
@@ -2024,19 +2031,19 @@ static QDF_STATUS send_scan_stop_cmd_non_tlv(wmi_unified_t wmi_handle,
OS_MEMZERO(cmd, len); OS_MEMZERO(cmd, len);
/* scan scheduler is not supportd yet */ /* scan scheduler is not supportd yet */
cmd->scan_id = param->scan_id; cmd->scan_id = param->scan_id;
cmd->requestor = param->requestor; cmd->requestor = param->requester;
cmd->vdev_id = param->vdev_id; cmd->vdev_id = param->vdev_id;
if (param->all_scans) { if (param->req_type == WLAN_SCAN_CANCEL_PDEV_ALL) {
/* Cancelling all scans - always match scan id */ /* Cancelling all scans - always match scan id */
cmd->req_type = WMI_SCAN_STOP_ALL; cmd->req_type = WMI_SCAN_STOP_ALL;
} else if (param->vap_scans) { } else if (param->req_type == WLAN_SCAN_CANCEL_VDEV_ALL) {
/*- /*-
* Cancelling VAP scans - report a match if scan was requested * Cancelling VAP scans - report a match if scan was requested
* by the same VAP trying to cancel it. * by the same VAP trying to cancel it.
*/ */
cmd->req_type = WMI_SCN_STOP_VAP_ALL; cmd->req_type = WMI_SCN_STOP_VAP_ALL;
} else if (param->specific_scan) { } else if (param->req_type == WLAN_SCAN_CANCEL_SINGLE) {
/*- /*-
* Cancelling specific scan - report a match if specified scan * Cancelling specific scan - report a match if specified scan
* id matches the request's scan id. * id matches the request's scan id.
@@ -2045,14 +2052,7 @@ static QDF_STATUS send_scan_stop_cmd_non_tlv(wmi_unified_t wmi_handle,
} }
wmi_unified_cmd_send(wmi_handle, buf, len, WMI_STOP_SCAN_CMDID); wmi_unified_cmd_send(wmi_handle, buf, len, WMI_STOP_SCAN_CMDID);
/* send a synchronous cancel command */
if (param->flags) {
OS_MEMZERO(&wmi_scn_event, sizeof(wmi_scn_event));
wmi_scn_event.event = WMI_SCAN_EVENT_COMPLETED;
wmi_scn_event.reason = WMI_SCAN_REASON_CANCELLED;
wmi_scn_event.requestor = param->requestor;
wmi_scn_event.scan_id = param->ss_scan_id;
}
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;
} }
@@ -5983,75 +5983,75 @@ static QDF_STATUS extract_vdev_roam_param_non_tlv(wmi_unified_t wmi_handle,
*/ */
static QDF_STATUS extract_vdev_scan_ev_param_non_tlv(wmi_unified_t wmi_handle, static QDF_STATUS extract_vdev_scan_ev_param_non_tlv(wmi_unified_t wmi_handle,
void *evt_buf, void *evt_buf,
wmi_host_scan_event *param) struct scan_event *param)
{ {
wmi_scan_event *evt = (wmi_scan_event *)evt_buf; wmi_scan_event *evt = (wmi_scan_event *)evt_buf;
qdf_mem_zero(param, sizeof(*param)); qdf_mem_zero(param, sizeof(*param));
switch (evt->event) { switch (evt->event) {
case WMI_SCAN_EVENT_STARTED: case WMI_SCAN_EVENT_STARTED:
param->event = WMI_HOST_SCAN_EVENT_STARTED; param->type = SCAN_EVENT_TYPE_STARTED;
break; break;
case WMI_SCAN_EVENT_COMPLETED: case WMI_SCAN_EVENT_COMPLETED:
param->event = WMI_HOST_SCAN_EVENT_COMPLETED; param->type = SCAN_EVENT_TYPE_COMPLETED;
break; break;
case WMI_SCAN_EVENT_BSS_CHANNEL: case WMI_SCAN_EVENT_BSS_CHANNEL:
param->event = WMI_HOST_SCAN_EVENT_BSS_CHANNEL; param->type = SCAN_EVENT_TYPE_BSS_CHANNEL;
break; break;
case WMI_SCAN_EVENT_FOREIGN_CHANNEL: case WMI_SCAN_EVENT_FOREIGN_CHANNEL:
param->event = WMI_HOST_SCAN_EVENT_FOREIGN_CHANNEL; param->type = SCAN_EVENT_TYPE_FOREIGN_CHANNEL;
break; break;
case WMI_SCAN_EVENT_DEQUEUED: case WMI_SCAN_EVENT_DEQUEUED:
param->event = WMI_HOST_SCAN_EVENT_DEQUEUED; param->type = SCAN_EVENT_TYPE_DEQUEUED;
break; break;
case WMI_SCAN_EVENT_PREEMPTED: case WMI_SCAN_EVENT_PREEMPTED:
param->event = WMI_HOST_SCAN_EVENT_PREEMPTED; param->type = SCAN_EVENT_TYPE_PREEMPTED;
break; break;
case WMI_SCAN_EVENT_START_FAILED: case WMI_SCAN_EVENT_START_FAILED:
param->event = WMI_HOST_SCAN_EVENT_START_FAILED; param->type = SCAN_EVENT_TYPE_START_FAILED;
break; break;
case WMI_SCAN_EVENT_RESTARTED: case WMI_SCAN_EVENT_RESTARTED:
param->event = WMI_HOST_SCAN_EVENT_RESTARTED; param->type = SCAN_EVENT_TYPE_RESTARTED;
break; break;
case WMI_HOST_SCAN_EVENT_FOREIGN_CHANNEL_EXIT: case WMI_HOST_SCAN_EVENT_FOREIGN_CHANNEL_EXIT:
param->event = WMI_HOST_SCAN_EVENT_FOREIGN_CHANNEL_EXIT; param->type = SCAN_EVENT_TYPE_FOREIGN_CHANNEL_EXIT;
break; break;
case WMI_SCAN_EVENT_INVALID: case WMI_SCAN_EVENT_INVALID:
param->event = WMI_HOST_SCAN_EVENT_INVALID; param->type = SCAN_EVENT_TYPE_INVALID;
break; break;
case WMI_SCAN_EVENT_MAX: case WMI_SCAN_EVENT_MAX:
default: default:
param->event = WMI_HOST_SCAN_EVENT_MAX; param->type = SCAN_EVENT_TYPE_MAX;
break; break;
}; };
switch (evt->reason) { switch (evt->reason) {
case WMI_SCAN_REASON_NONE: case WMI_SCAN_REASON_NONE:
param->reason = WMI_HOST_SCAN_REASON_NONE; param->reason = SCAN_REASON_NONE;
break; break;
case WMI_SCAN_REASON_COMPLETED: case WMI_SCAN_REASON_COMPLETED:
param->reason = WMI_HOST_SCAN_REASON_COMPLETED; param->reason = SCAN_REASON_COMPLETED;
break; break;
case WMI_SCAN_REASON_CANCELLED: case WMI_SCAN_REASON_CANCELLED:
param->reason = WMI_HOST_SCAN_REASON_CANCELLED; param->reason = SCAN_REASON_CANCELLED;
break; break;
case WMI_SCAN_REASON_PREEMPTED: case WMI_SCAN_REASON_PREEMPTED:
param->reason = WMI_HOST_SCAN_REASON_PREEMPTED; param->reason = SCAN_REASON_PREEMPTED;
break; break;
case WMI_SCAN_REASON_TIMEDOUT: case WMI_SCAN_REASON_TIMEDOUT:
param->reason = WMI_HOST_SCAN_REASON_TIMEDOUT; param->reason = SCAN_REASON_TIMEDOUT;
break; break;
case WMI_SCAN_REASON_INTERNAL_FAILURE: case WMI_SCAN_REASON_INTERNAL_FAILURE:
param->reason = WMI_HOST_SCAN_REASON_INTERNAL_FAILURE; param->reason = SCAN_REASON_INTERNAL_FAILURE;
break; break;
case WMI_SCAN_REASON_MAX: case WMI_SCAN_REASON_MAX:
default: default:
param->reason = WMI_HOST_SCAN_REASON_MAX; param->reason = SCAN_REASON_MAX;
break; break;
}; };
param->channel_freq = evt->channel_freq; param->chan_freq = evt->channel_freq;
param->requestor = evt->requestor; param->requester = evt->requestor;
param->scan_id = evt->scan_id; param->scan_id = evt->scan_id;
param->vdev_id = evt->vdev_id; param->vdev_id = evt->vdev_id;
return QDF_STATUS_SUCCESS; return QDF_STATUS_SUCCESS;

216
wmi_unified_tlv.c
View File

@@ -1946,78 +1946,88 @@ static QDF_STATUS send_peer_assoc_cmd_tlv(wmi_unified_t wmi_handle,
/* copy_scan_notify_events() - Helper routine to copy scan notify events /* copy_scan_notify_events() - Helper routine to copy scan notify events
*/ */
#ifdef CONFIG_MCL static inline void copy_scan_event_cntrl_flags(
static inline void copy_scan_notify_ev_flags(
wmi_start_scan_cmd_fixed_param * cmd, wmi_start_scan_cmd_fixed_param * cmd,
struct scan_start_params *params) struct scan_req_params *param)
{ {
cmd->notify_scan_events = params->notify_scan_events;
cmd->scan_ctrl_flags = params->scan_ctrl_flags;
}
#else
static inline void copy_scan_notify_ev_flags(
wmi_start_scan_cmd_fixed_param * cmd,
struct scan_start_params *params)
{
cmd->notify_scan_events = WMI_SCAN_EVENT_STARTED |
WMI_SCAN_EVENT_COMPLETED |
WMI_SCAN_EVENT_BSS_CHANNEL |
WMI_SCAN_EVENT_FOREIGN_CHANNEL |
WMI_SCAN_EVENT_DEQUEUED
;
cmd->scan_ctrl_flags = (params->passive_flag) ? /* Scan events subscription */
WMI_SCAN_FLAG_PASSIVE : 0; if (param->scan_ev_started)
cmd->notify_scan_events |= WMI_SCAN_EVENT_STARTED;
if (param->scan_ev_completed)
cmd->notify_scan_events |= WMI_SCAN_EVENT_COMPLETED;
if (param->scan_ev_bss_chan)
cmd->notify_scan_events |= WMI_SCAN_EVENT_BSS_CHANNEL;
if (param->scan_ev_foreign_chan)
cmd->notify_scan_events |= WMI_SCAN_EVENT_FOREIGN_CHANNEL;
if (param->scan_ev_dequeued)
cmd->notify_scan_events |= WMI_SCAN_EVENT_DEQUEUED;
if (param->scan_ev_preempted)
cmd->notify_scan_events |= WMI_SCAN_EVENT_PREEMPTED;
if (param->scan_ev_start_failed)
cmd->notify_scan_events |= WMI_SCAN_EVENT_START_FAILED;
if (param->scan_ev_restarted)
cmd->notify_scan_events |= WMI_SCAN_EVENT_RESTARTED;
if (param->scan_ev_foreign_chn_exit)
cmd->notify_scan_events |= WMI_SCAN_EVENT_FOREIGN_CHANNEL_EXIT;
if (param->scan_ev_suspended)
cmd->notify_scan_events |= WMI_SCAN_EVENT_SUSPENDED;
if (param->scan_ev_resumed)
cmd->notify_scan_events |= WMI_SCAN_EVENT_RESUMED;
if (params->is_strict_pscan_en) /** Set scan control flags */
cmd->scan_ctrl_flags = 0;
if (param->scan_f_passive)
cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
if (param->scan_f_strict_passive_pch)
cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_STRICT_PASSIVE_ON_PCHN; cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_STRICT_PASSIVE_ON_PCHN;
if (param->scan_f_promisc_mode)
if (params->is_phy_error) cmd->scan_ctrl_flags |= WMI_SCAN_FILTER_PROMISCOUS;
if (param->scan_f_capture_phy_err)
cmd->scan_ctrl_flags |= WMI_SCAN_CAPTURE_PHY_ERROR; cmd->scan_ctrl_flags |= WMI_SCAN_CAPTURE_PHY_ERROR;
if (param->scan_f_half_rate)
if (params->half_rate)
cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_HALF_RATE_SUPPORT; cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_HALF_RATE_SUPPORT;
if (param->scan_f_quarter_rate)
if (params->quarter_rate)
cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_QUARTER_RATE_SUPPORT; cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_QUARTER_RATE_SUPPORT;
if (param->scan_f_cck_rates)
if (params->is_phy_error)
cmd->scan_ctrl_flags |= WMI_SCAN_CAPTURE_PHY_ERROR;
cmd->scan_ctrl_flags |= WMI_SCAN_ADD_OFDM_RATES;
/* add cck rates if required */
if (params->add_cck_rates)
cmd->scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES; cmd->scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
/** It enables the Channel stat event indication to host */ if (param->scan_f_ofdm_rates)
if (params->chan_stat_enable) cmd->scan_ctrl_flags |= WMI_SCAN_ADD_OFDM_RATES;
if (param->scan_f_chan_stat_evnt)
cmd->scan_ctrl_flags |= WMI_SCAN_CHAN_STAT_EVENT; cmd->scan_ctrl_flags |= WMI_SCAN_CHAN_STAT_EVENT;
if (params->add_bcast_probe_reqd) if (param->scan_f_filter_prb_req)
cmd->scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
if (param->scan_f_bcast_probe)
cmd->scan_ctrl_flags |= WMI_SCAN_ADD_BCAST_PROBE_REQ; cmd->scan_ctrl_flags |= WMI_SCAN_ADD_BCAST_PROBE_REQ;
/* off channel TX control */ if (param->scan_f_offchan_mgmt_tx)
if (params->offchan_tx_mgmt)
cmd->scan_ctrl_flags |= WMI_SCAN_OFFCHAN_MGMT_TX; cmd->scan_ctrl_flags |= WMI_SCAN_OFFCHAN_MGMT_TX;
if (params->offchan_tx_data) if (param->scan_f_offchan_data_tx)
cmd->scan_ctrl_flags |= WMI_SCAN_OFFCHAN_DATA_TX; cmd->scan_ctrl_flags |= WMI_SCAN_OFFCHAN_DATA_TX;
} if (param->scan_f_force_active_dfs_chn)
#endif cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_FORCE_ACTIVE_ON_DFS;
if (param->scan_f_add_tpc_ie_in_probe)
cmd->scan_ctrl_flags |= WMI_SCAN_ADD_TPC_IE_IN_PROBE_REQ;
if (param->scan_f_add_ds_ie_in_probe)
cmd->scan_ctrl_flags |= WMI_SCAN_ADD_DS_IE_IN_PROBE_REQ;
if (param->scan_f_add_spoofed_mac_in_probe)
cmd->scan_ctrl_flags |= WMI_SCAN_ADD_SPOOFED_MAC_IN_PROBE_REQ;
if (param->scan_f_add_rand_seq_in_probe)
cmd->scan_ctrl_flags |= WMI_SCAN_RANDOM_SEQ_NO_IN_PROBE_REQ;
if (param->scan_f_en_ie_whitelist_in_probe)
cmd->scan_ctrl_flags |=
WMI_SCAN_ENABLE_IE_WHTELIST_IN_PROBE_REQ;
/* for adaptive scan mode using 3 bits (21 - 23 bits) */
WMI_SCAN_SET_DWELL_MODE(cmd->scan_ctrl_flags,
param->adaptive_dwell_time_mode);
}
/* scan_copy_ie_buffer() - Copy scan ie_data */ /* scan_copy_ie_buffer() - Copy scan ie_data */
#ifndef CONFIG_MCL
static inline void scan_copy_ie_buffer(uint8_t *buf_ptr, static inline void scan_copy_ie_buffer(uint8_t *buf_ptr,
struct scan_start_params *params) struct scan_req_params *params)
{ {
qdf_mem_copy(buf_ptr, params->ie_data, params->ie_len); qdf_mem_copy(buf_ptr, params->extraie.ptr, params->extraie.len);
} }
#else
static inline void scan_copy_ie_buffer(uint8_t *buf_ptr,
struct scan_start_params *params)
{
qdf_mem_copy(buf_ptr,
(uint8_t *) params->ie_base +
(params->uie_fieldOffset), params->ie_len);
}
#endif
/** /**
* send_scan_start_cmd_tlv() - WMI scan start function * send_scan_start_cmd_tlv() - WMI scan start function
@@ -2027,7 +2037,7 @@ static inline void scan_copy_ie_buffer(uint8_t *buf_ptr,
* Return: 0 on success and -ve on failure. * Return: 0 on success and -ve on failure.
*/ */
static QDF_STATUS send_scan_start_cmd_tlv(wmi_unified_t wmi_handle, static QDF_STATUS send_scan_start_cmd_tlv(wmi_unified_t wmi_handle,
struct scan_start_params *params) struct scan_req_params *params)
{ {
int32_t ret = 0; int32_t ret = 0;
int32_t i; int32_t i;
@@ -2038,6 +2048,7 @@ static QDF_STATUS send_scan_start_cmd_tlv(wmi_unified_t wmi_handle,
wmi_ssid *ssid = NULL; wmi_ssid *ssid = NULL;
wmi_mac_addr *bssid; wmi_mac_addr *bssid;
int len = sizeof(*cmd); int len = sizeof(*cmd);
uint8_t extraie_len_with_pad = 0;
/* Length TLV placeholder for array of uint32_t */ /* Length TLV placeholder for array of uint32_t */
len += WMI_TLV_HDR_SIZE; len += WMI_TLV_HDR_SIZE;
@@ -2057,8 +2068,10 @@ static QDF_STATUS send_scan_start_cmd_tlv(wmi_unified_t wmi_handle,
/* Length TLV placeholder for array of bytes */ /* Length TLV placeholder for array of bytes */
len += WMI_TLV_HDR_SIZE; len += WMI_TLV_HDR_SIZE;
if (params->ie_len) if (params->extraie.len)
len += roundup(params->ie_len, sizeof(uint32_t)); extraie_len_with_pad =
roundup(params->extraie.len, sizeof(uint32_t));
len += extraie_len_with_pad;
/* Allocate the memory */ /* Allocate the memory */
wmi_buf = wmi_buf_alloc(wmi_handle, len); wmi_buf = wmi_buf_alloc(wmi_handle, len);
@@ -2078,7 +2091,9 @@ static QDF_STATUS send_scan_start_cmd_tlv(wmi_unified_t wmi_handle,
cmd->scan_req_id = params->scan_req_id; cmd->scan_req_id = params->scan_req_id;
cmd->vdev_id = params->vdev_id; cmd->vdev_id = params->vdev_id;
cmd->scan_priority = params->scan_priority; cmd->scan_priority = params->scan_priority;
copy_scan_notify_ev_flags(cmd, params);
copy_scan_event_cntrl_flags(cmd, params);
cmd->dwell_time_active = params->dwell_time_active; cmd->dwell_time_active = params->dwell_time_active;
cmd->dwell_time_passive = params->dwell_time_passive; cmd->dwell_time_passive = params->dwell_time_passive;
cmd->min_rest_time = params->min_rest_time; cmd->min_rest_time = params->min_rest_time;
@@ -2092,7 +2107,7 @@ static QDF_STATUS send_scan_start_cmd_tlv(wmi_unified_t wmi_handle,
cmd->num_chan = params->num_chan; cmd->num_chan = params->num_chan;
cmd->num_bssid = params->num_bssid; cmd->num_bssid = params->num_bssid;
cmd->num_ssids = params->num_ssids; cmd->num_ssids = params->num_ssids;
cmd->ie_len = params->ie_len; cmd->ie_len = params->extraie.len;
cmd->n_probes = params->n_probes; cmd->n_probes = params->n_probes;
buf_ptr += sizeof(*cmd); buf_ptr += sizeof(*cmd);
tmp_ptr = (uint32_t *) (buf_ptr + WMI_TLV_HDR_SIZE); tmp_ptr = (uint32_t *) (buf_ptr + WMI_TLV_HDR_SIZE);
@@ -2115,7 +2130,7 @@ static QDF_STATUS send_scan_start_cmd_tlv(wmi_unified_t wmi_handle,
ssid = (wmi_ssid *) (buf_ptr + WMI_TLV_HDR_SIZE); ssid = (wmi_ssid *) (buf_ptr + WMI_TLV_HDR_SIZE);
for (i = 0; i < params->num_ssids; ++i) { for (i = 0; i < params->num_ssids; ++i) {
ssid->ssid_len = params->ssid[i].length; ssid->ssid_len = params->ssid[i].length;
qdf_mem_copy(ssid->ssid, params->ssid[i].mac_ssid, qdf_mem_copy(ssid->ssid, params->ssid[i].ssid,
params->ssid[i].length); params->ssid[i].length);
ssid++; ssid++;
} }
@@ -2125,25 +2140,24 @@ static QDF_STATUS send_scan_start_cmd_tlv(wmi_unified_t wmi_handle,
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_FIXED_STRUC, WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_FIXED_STRUC,
(params->num_bssid * sizeof(wmi_mac_addr))); (params->num_bssid * sizeof(wmi_mac_addr)));
bssid = (wmi_mac_addr *) (buf_ptr + WMI_TLV_HDR_SIZE); bssid = (wmi_mac_addr *) (buf_ptr + WMI_TLV_HDR_SIZE);
#if CONFIG_MCL
WMI_CHAR_ARRAY_TO_MAC_ADDR(params->mac_add_bytes, bssid);
#else
if (params->num_bssid) { if (params->num_bssid) {
for (i = 0; i < params->num_bssid; ++i) { for (i = 0; i < params->num_bssid; ++i) {
WMI_CHAR_ARRAY_TO_MAC_ADDR(params->bssid_list[i], WMI_CHAR_ARRAY_TO_MAC_ADDR(
bssid); &params->bssid_list[i].bytes[0], bssid);
bssid++; bssid++;
} }
} }
#endif
buf_ptr += WMI_TLV_HDR_SIZE + (params->num_bssid * sizeof(wmi_mac_addr));
WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, buf_ptr += WMI_TLV_HDR_SIZE +
roundup(params->ie_len, sizeof(uint32_t))); (params->num_bssid * sizeof(wmi_mac_addr));
if (params->ie_len) {
scan_copy_ie_buffer(buf_ptr + WMI_TLV_HDR_SIZE, params); WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, extraie_len_with_pad);
} if (params->extraie.len)
buf_ptr += WMI_TLV_HDR_SIZE + roundup(params->ie_len, sizeof(uint32_t)); scan_copy_ie_buffer(buf_ptr + WMI_TLV_HDR_SIZE,
params);
buf_ptr += WMI_TLV_HDR_SIZE + extraie_len_with_pad;
ret = wmi_unified_cmd_send(wmi_handle, wmi_buf, ret = wmi_unified_cmd_send(wmi_handle, wmi_buf,
len, WMI_START_SCAN_CMDID); len, WMI_START_SCAN_CMDID);
@@ -2160,12 +2174,12 @@ error:
/** /**
* send_scan_stop_cmd_tlv() - WMI scan start function * send_scan_stop_cmd_tlv() - WMI scan start function
* @param wmi_handle : handle to WMI. * @param wmi_handle : handle to WMI.
* @param param : pointer to hold scan start cmd parameter * @param param : pointer to hold scan cancel cmd parameter
* *
* Return: 0 on success and -ve on failure. * Return: 0 on success and -ve on failure.
*/ */
static QDF_STATUS send_scan_stop_cmd_tlv(wmi_unified_t wmi_handle, static QDF_STATUS send_scan_stop_cmd_tlv(wmi_unified_t wmi_handle,
struct scan_stop_params *param) struct scan_cancel_param *param)
{ {
wmi_stop_scan_cmd_fixed_param *cmd; wmi_stop_scan_cmd_fixed_param *cmd;
int ret; int ret;
@@ -2186,11 +2200,21 @@ static QDF_STATUS send_scan_stop_cmd_tlv(wmi_unified_t wmi_handle,
WMITLV_TAG_STRUC_wmi_stop_scan_cmd_fixed_param, WMITLV_TAG_STRUC_wmi_stop_scan_cmd_fixed_param,
WMITLV_GET_STRUCT_TLVLEN(wmi_stop_scan_cmd_fixed_param)); WMITLV_GET_STRUCT_TLVLEN(wmi_stop_scan_cmd_fixed_param));
cmd->vdev_id = param->vdev_id; cmd->vdev_id = param->vdev_id;
cmd->requestor = param->requestor; cmd->requestor = param->requester;
cmd->scan_id = param->scan_id; cmd->scan_id = param->scan_id;
cmd->pdev_id = param->pdev_id; cmd->pdev_id = param->pdev_id;
/* stop the scan with the corresponding scan_id */ /* stop the scan with the corresponding scan_id */
cmd->req_type = param->req_type; if (param->req_type == WLAN_SCAN_CANCEL_PDEV_ALL) {
/* Cancelling all scans */
cmd->req_type = WMI_SCAN_STOP_ALL;
} else if (param->req_type == WLAN_SCAN_CANCEL_VDEV_ALL) {
/* Cancelling VAP scans */
cmd->req_type = WMI_SCN_STOP_VAP_ALL;
} else if (param->req_type == WLAN_SCAN_CANCEL_SINGLE) {
/* Cancelling specific scan */
cmd->req_type = WMI_SCAN_STOP_ONE;
}
ret = wmi_unified_cmd_send(wmi_handle, wmi_buf, ret = wmi_unified_cmd_send(wmi_handle, wmi_buf,
len, WMI_STOP_SCAN_CMDID); len, WMI_STOP_SCAN_CMDID);
if (ret) { if (ret) {
@@ -14557,7 +14581,7 @@ static QDF_STATUS extract_vdev_roam_param_tlv(wmi_unified_t wmi_handle,
* Return: QDF_STATUS_SUCCESS for success or error code * Return: QDF_STATUS_SUCCESS for success or error code
*/ */
static QDF_STATUS extract_vdev_scan_ev_param_tlv(wmi_unified_t wmi_handle, static QDF_STATUS extract_vdev_scan_ev_param_tlv(wmi_unified_t wmi_handle,
void *evt_buf, wmi_host_scan_event *param) void *evt_buf, struct scan_event *param)
{ {
WMI_SCAN_EVENTID_param_tlvs *param_buf = NULL; WMI_SCAN_EVENTID_param_tlvs *param_buf = NULL;
wmi_scan_event_fixed_param *evt = NULL; wmi_scan_event_fixed_param *evt = NULL;
@@ -14568,65 +14592,65 @@ static QDF_STATUS extract_vdev_scan_ev_param_tlv(wmi_unified_t wmi_handle,
qdf_mem_zero(param, sizeof(*param)); qdf_mem_zero(param, sizeof(*param));
switch (evt->event) { switch (evt->event) {
case WMI_SCAN_EVENT_STARTED: case WMI_SCAN_EVENT_STARTED:
param->event = WMI_HOST_SCAN_EVENT_STARTED; param->type = SCAN_EVENT_TYPE_STARTED;
break; break;
case WMI_SCAN_EVENT_COMPLETED: case WMI_SCAN_EVENT_COMPLETED:
param->event = WMI_HOST_SCAN_EVENT_COMPLETED; param->type = SCAN_EVENT_TYPE_COMPLETED;
break; break;
case WMI_SCAN_EVENT_BSS_CHANNEL: case WMI_SCAN_EVENT_BSS_CHANNEL:
param->event = WMI_HOST_SCAN_EVENT_BSS_CHANNEL; param->type = SCAN_EVENT_TYPE_BSS_CHANNEL;
break; break;
case WMI_SCAN_EVENT_FOREIGN_CHANNEL: case WMI_SCAN_EVENT_FOREIGN_CHANNEL:
param->event = WMI_HOST_SCAN_EVENT_FOREIGN_CHANNEL; param->type = SCAN_EVENT_TYPE_FOREIGN_CHANNEL;
break; break;
case WMI_SCAN_EVENT_DEQUEUED: case WMI_SCAN_EVENT_DEQUEUED:
param->event = WMI_HOST_SCAN_EVENT_DEQUEUED; param->type = SCAN_EVENT_TYPE_DEQUEUED;
break; break;
case WMI_SCAN_EVENT_PREEMPTED: case WMI_SCAN_EVENT_PREEMPTED:
param->event = WMI_HOST_SCAN_EVENT_PREEMPTED; param->type = SCAN_EVENT_TYPE_PREEMPTED;
break; break;
case WMI_SCAN_EVENT_START_FAILED: case WMI_SCAN_EVENT_START_FAILED:
param->event = WMI_HOST_SCAN_EVENT_START_FAILED; param->type = SCAN_EVENT_TYPE_START_FAILED;
break; break;
case WMI_SCAN_EVENT_RESTARTED: case WMI_SCAN_EVENT_RESTARTED:
param->event = WMI_HOST_SCAN_EVENT_RESTARTED; param->type = SCAN_EVENT_TYPE_RESTARTED;
break; break;
case WMI_HOST_SCAN_EVENT_FOREIGN_CHANNEL_EXIT: case WMI_HOST_SCAN_EVENT_FOREIGN_CHANNEL_EXIT:
param->event = WMI_HOST_SCAN_EVENT_FOREIGN_CHANNEL_EXIT; param->type = SCAN_EVENT_TYPE_FOREIGN_CHANNEL_EXIT;
break; break;
case WMI_SCAN_EVENT_MAX: case WMI_SCAN_EVENT_MAX:
default: default:
param->event = WMI_HOST_SCAN_EVENT_MAX; param->type = SCAN_EVENT_TYPE_MAX;
break; break;
}; };
switch (evt->reason) { switch (evt->reason) {
case WMI_SCAN_REASON_NONE: case WMI_SCAN_REASON_NONE:
param->reason = WMI_HOST_SCAN_REASON_NONE; param->reason = SCAN_REASON_NONE;
break; break;
case WMI_SCAN_REASON_COMPLETED: case WMI_SCAN_REASON_COMPLETED:
param->reason = WMI_HOST_SCAN_REASON_COMPLETED; param->reason = SCAN_REASON_COMPLETED;
break; break;
case WMI_SCAN_REASON_CANCELLED: case WMI_SCAN_REASON_CANCELLED:
param->reason = WMI_HOST_SCAN_REASON_CANCELLED; param->reason = SCAN_REASON_CANCELLED;
break; break;
case WMI_SCAN_REASON_PREEMPTED: case WMI_SCAN_REASON_PREEMPTED:
param->reason = WMI_HOST_SCAN_REASON_PREEMPTED; param->reason = SCAN_REASON_PREEMPTED;
break; break;
case WMI_SCAN_REASON_TIMEDOUT: case WMI_SCAN_REASON_TIMEDOUT:
param->reason = WMI_HOST_SCAN_REASON_TIMEDOUT; param->reason = SCAN_REASON_TIMEDOUT;
break; break;
case WMI_SCAN_REASON_INTERNAL_FAILURE: case WMI_SCAN_REASON_INTERNAL_FAILURE:
param->reason = WMI_HOST_SCAN_REASON_INTERNAL_FAILURE; param->reason = SCAN_REASON_INTERNAL_FAILURE;
break; break;
case WMI_SCAN_REASON_MAX: case WMI_SCAN_REASON_MAX:
default: default:
param->reason = WMI_HOST_SCAN_REASON_MAX; param->reason = SCAN_REASON_MAX;
break; break;
}; };
param->channel_freq = evt->channel_freq; param->chan_freq = evt->channel_freq;
param->requestor = evt->requestor; param->requester = evt->requestor;
param->scan_id = evt->scan_id; param->scan_id = evt->scan_id;
param->vdev_id = evt->vdev_id; param->vdev_id = evt->vdev_id;