/*----------------------------------------------------------------------------
\brief vos_wait_events() - Waits for the first event(s) to be set.
This API waits for any event in the input array of events to be
set. The caller is blocked waiting any event in the array to be
set or for the timeout to occur.
If multiple events in the array are set, only one event is identified
in the return from this call as satisfying the wait condition. The
caller is responsible for calling \a vos_wait_events() again to find
the other events that are set.
\param events - pointer to an array of events to wait on.
\param numEvents - Number of events in the events array to wait on.
\param timeout - Timeout value (in milliseconds). This function returns
if this interval elapses, regardless if any of the events have
been set. An input value of 0 for this timeout parameter means
to wait infinitely, meaning a timeout will never occur.
\param pEventIndex - This is a pointer to the location where the index of
the event in the event array that satisfied the wait because
the event was set.
\return VOS_STATUS_SUCCESS - the wait was satisifed by one of the events
in the event array being set. The index into the event arry
that satisfied the wait can be found at *pEventIndex.
VOS_STATUS_E_TIMEOUT - the timeout interval elapsed before any of
the events were set.
VOS_STATUS_E_INVAL - At least one of the values specified in the
event array refers to an uninitialized event object.
VOS_STATUS_E_ABORTED - The event due to which the wait was aborted
is identified by the index in *pEventIndex.
VOS_STATUS_E_EMPTY - the events array is empty. This condition
is detected by numEvents being 0 on input.
VOS_STATUS_E_FAULT - event or pEventIndex is an invalid pointer.
VOS_STATUS_E_FAILURE - default return value if it fails due to
unknown reasons
\sa
--------------------------------------------------------------------------*/
VOS_STATUS vos_wait_events ( vos_event_t* events,
v_U8_t numEvents, v_U32_t timeout,
v_U8_t *pEventIndex )
{
return vos_wait_single_event(events,timeout);
}
VOS_STATUS vos_stop( v_CONTEXT_t vosContext )
{
VOS_STATUS vosStatus;
vos_event_reset( &(gpVosContext->wdaCompleteEvent) );
vosStatus = WDA_stop( vosContext, HAL_STOP_TYPE_RF_KILL );
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to stop WDA", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
WDA_setNeedShutdown(vosContext);
}
else
{
vosStatus = vos_wait_single_event( &(gpVosContext->wdaCompleteEvent),
VOS_WDA_STOP_TIMEOUT );
if ( vosStatus != VOS_STATUS_SUCCESS )
{
if ( vosStatus == VOS_STATUS_E_TIMEOUT )
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Timeout occurred before WDA complete", __func__);
}
else
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: WDA_stop reporting other error", __func__ );
}
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Test MC thread by posting a probe message to SYS", __func__);
wlan_sys_probe();
WDA_setNeedShutdown(vosContext);
}
}
vosStatus = sysStop( vosContext);
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to stop SYS", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
vosStatus = WLANTL_Stop( vosContext );
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to stop TL", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
return VOS_STATUS_SUCCESS;
}
wpt_status wpalEventWait(wpt_event *pEvent, wpt_uint32 timeout)
{
wpt_status status = eWLAN_PAL_STATUS_E_FAILURE;
VOS_STATUS vos_status = VOS_STATUS_E_FAILURE;
timeout = ( timeout == WLAN_PAL_WAIT_INFINITE ? 0 : timeout );
vos_status = vos_wait_single_event( (vos_event_t*)pEvent, timeout );
status = WPAL_VOS_TO_WPAL_STATUS( vos_status );
return status;
}
/*---------------------------------------------------------------------------
@brief wpalEventWait – Wait on an event object
\param
pEvent – a pointer to caller allocated object of wpt_event
timeout - timeout value at unit of milli-seconds.
0xffffffff means infinite wait
\return eWLAN_PAL_STATUS_SUCCESS - the wait was satisifed by one of the events
in the event array being set. The index into the event arry
that satisfied the wait can be found at *pEventIndex.
eWLAN_PALSTATUS_E_TIMEOUT - the timeout interval elapsed before any of
the events were set.
eWLAN_PAL_STATUS_E_INVAL - At least one of the values specified in
the event array refers to an uninitialized event object. The
invalid event is identified by the index in *pEventIndex. Note
that only the first uninitialized event is detected when this error
is returned.
eWLAN_PAL_STATUS_E_EMPTY - the events array is empty. This condition
is detected by numEvents being 0 on input.
eWLAN_PAL_STATUS_E_FAULT - event or pEventIndex is an invalid pointer.
---------------------------------------------------------------------------*/
wpt_status wpalEventWait(wpt_event *pEvent, wpt_uint32 timeout)
{
/* Not doing sanity checks since VOS does them anyways */
wpt_status status = eWLAN_PAL_STATUS_E_FAILURE;
VOS_STATUS vos_status = VOS_STATUS_E_FAILURE;
/* In VOS timeout = 0 corresponds to infinite wait */
timeout = ( timeout == WLAN_PAL_WAIT_INFINITE ? 0 : timeout );
vos_status = vos_wait_single_event( (vos_event_t*)pEvent, timeout );
status = WPAL_VOS_TO_WPAL_STATUS( vos_status );
return status;
}
int iw_set_cscan(struct net_device *dev, struct iw_request_info *info,
union iwreq_data *wrqu, char *extra)
{
hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev) ;
hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
hdd_wext_state_t *pwextBuf = WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter);
tCsrScanRequest scanRequest;
v_U32_t scanId = 0;
eHalStatus status = eHAL_STATUS_SUCCESS;
v_U8_t channelIdx;
ENTER();
VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "%s: enter !!!",__func__);
#ifdef WLAN_BTAMP_FEATURE
if( VOS_TRUE == WLANBAP_AmpSessionOn() )
{
VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "%s: No scanning when AMP is on",__func__);
return eHAL_STATUS_SUCCESS;
}
#endif
if ((WLAN_HDD_GET_CTX(pAdapter))->isLogpInProgress)
{
VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL, "%s:LOGP in Progress. Ignore!!!",__func__);
return eHAL_STATUS_SUCCESS;
}
vos_mem_zero( &scanRequest, sizeof(scanRequest));
if (NULL != wrqu->data.pointer)
{
char *str_ptr = NULL;
tCsrSSIDInfo *SsidInfo = NULL;
int num_ssid = 0;
int i, j, ssid_start;
hdd_scan_pending_option_e scanPendingOption = WEXT_SCAN_PENDING_GIVEUP;
str_ptr = extra;
i = WEXT_CSCAN_HEADER_SIZE;
if( WEXT_CSCAN_PENDING_SECTION == str_ptr[i] )
{
scanPendingOption = (hdd_scan_pending_option_e)str_ptr[++i];
++i;
}
pHddCtx->scan_info.scan_pending_option = scanPendingOption;
if(pHddCtx->scan_info.mScanPending == TRUE)
{
hddLog(LOG1,"%s: mScanPending is TRUE",__func__);
if(WEXT_SCAN_PENDING_GIVEUP == scanPendingOption)
{
pHddCtx->scan_info.waitScanResult = FALSE;
return eHAL_STATUS_SUCCESS;
}
else if(WEXT_SCAN_PENDING_DELAY == scanPendingOption)
{
pHddCtx->scan_info.waitScanResult = TRUE;
vos_event_reset(&pHddCtx->scan_info.scan_finished_event);
if(vos_wait_single_event(&pHddCtx->scan_info.scan_finished_event,
WEXT_CSCAN_SCAN_DONE_WAIT_TIME))
{
hddLog(LOG1,"%s: Previous SCAN does not finished on time",__func__);
return eHAL_STATUS_SUCCESS;
}
}
else if(WEXT_SCAN_PENDING_PIGGYBACK == scanPendingOption)
{
pHddCtx->scan_info.waitScanResult = TRUE;
return eHAL_STATUS_SUCCESS;
}
}
pHddCtx->scan_info.waitScanResult = FALSE;
while( WEXT_CSCAN_SSID_SECTION == str_ptr[i] )
{
if(str_ptr[++i] != WEXT_CSCAN_CHANNEL_SECTION)
{
num_ssid++;
i += str_ptr[i] + 1;
}
}
VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "%s: numSsid %d !!!",__func__, num_ssid);
if( num_ssid )
{
scanRequest.SSIDs.numOfSSIDs = num_ssid;
SsidInfo = scanRequest.SSIDs.SSIDList =( tCsrSSIDInfo *)vos_mem_malloc(num_ssid*sizeof(tCsrSSIDInfo));
if(NULL == scanRequest.SSIDs.SSIDList) {
hddLog(VOS_TRACE_LEVEL_ERROR, "memory alloc failed SSIDInfo buffer");
return -ENOMEM;
}
ssid_start = WEXT_CSCAN_HEADER_SIZE + 1;
for(j = 0; j < num_ssid; j++) {
if( SIR_MAC_MAX_SSID_LENGTH < str_ptr[ssid_start]){
scanRequest.SSIDs.numOfSSIDs -= 1;
} else{
SsidInfo->SSID.length = str_ptr[ssid_start++];
vos_mem_copy(SsidInfo->SSID.ssId, &str_ptr[ssid_start], SsidInfo->SSID.length);
hddLog(VOS_TRACE_LEVEL_INFO_HIGH, "SSID number %d: %s\n", j, SsidInfo->SSID.ssId);
}
ssid_start += str_ptr[ssid_start - 1] + 1;
SsidInfo++;
}
}
if ( WEXT_CSCAN_CHANNEL_SECTION == str_ptr[i])
{
if( str_ptr[++i] == 0 )
{
scanRequest.ChannelInfo.numOfChannels = 0;
scanRequest.ChannelInfo.ChannelList = NULL;
i++;
}
else {
scanRequest.ChannelInfo.numOfChannels = str_ptr[i++];
scanRequest.ChannelInfo.ChannelList = vos_mem_malloc(scanRequest.ChannelInfo.numOfChannels * sizeof(v_U8_t));
if(NULL == scanRequest.ChannelInfo.ChannelList)
{
hddLog(VOS_TRACE_LEVEL_INFO_HIGH, "memory alloc failed for channel list creation");
status = -ENOMEM;
goto exit_point;
}
for(channelIdx = 0; channelIdx < scanRequest.ChannelInfo.numOfChannels; channelIdx++)
{
scanRequest.ChannelInfo.ChannelList[channelIdx] = (v_U8_t)str_ptr[i];
i += sizeof(v_U16_t);
}
}
}
scanRequest.scanType = eSIR_ACTIVE_SCAN;
scanRequest.minChnTime = 0;
scanRequest.maxChnTime = 0;
if( WEXT_CSCAN_PASV_DWELL_SECTION == (str_ptr[i]) )
{
if (!num_ssid || (eSIR_PASSIVE_SCAN == pHddCtx->scan_info.scan_mode))
{
scanRequest.scanType = eSIR_PASSIVE_SCAN;
scanRequest.minChnTime = (v_U8_t)str_ptr[++i];
scanRequest.maxChnTime = (v_U8_t)str_ptr[++i];
i++;
}
else
{
i += 3;
}
}
if( WEXT_CSCAN_HOME_DWELL_SECTION == (str_ptr[i]) )
{
if (num_ssid || (eSIR_ACTIVE_SCAN == pHddCtx->scan_info.scan_mode))
{
scanRequest.scanType = eSIR_ACTIVE_SCAN;
scanRequest.minChnTime = str_ptr[++i];
scanRequest.maxChnTime = str_ptr[++i];
i++;
}
else
{
i +=3;
}
}
scanRequest.BSSType = eCSR_BSS_TYPE_ANY;
scanRequest.requestType = eCSR_SCAN_REQUEST_FULL_SCAN;
pHddCtx->scan_info.mScanPending = TRUE;
if(0 != pwextBuf->genIE.length)
{
memset( &pHddCtx->scan_info.scanAddIE, 0, sizeof(pHddCtx->scan_info.scanAddIE) );
memcpy( pHddCtx->scan_info.scanAddIE.addIEdata, pwextBuf->genIE.addIEdata,
pwextBuf->genIE.length );
pHddCtx->scan_info.scanAddIE.length = pwextBuf->genIE.length;
if (SIR_MAC_MAX_IE_LENGTH >= pwextBuf->genIE.length)
{
memcpy( pwextBuf->roamProfile.addIEScan,
pHddCtx->scan_info.scanAddIE.addIEdata,
pHddCtx->scan_info.scanAddIE.length);
pwextBuf->roamProfile.nAddIEScanLength =
pHddCtx->scan_info.scanAddIE.length;
}
else
{
VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
"Invalid ScanIE, Length is %d",
pwextBuf->genIE.length);
}
memset( &pwextBuf->genIE, 0, sizeof(pwextBuf->genIE) );
}
if (pHddCtx->scan_info.scanAddIE.addIEdata &&
pHddCtx->scan_info.scanAddIE.length)
{
scanRequest.uIEFieldLen = pHddCtx->scan_info.scanAddIE.length;
scanRequest.pIEField = pHddCtx->scan_info.scanAddIE.addIEdata;
}
status = sme_ScanRequest( (WLAN_HDD_GET_CTX(pAdapter))->hHal,
pAdapter->sessionId,&scanRequest, &scanId, &hdd_ScanRequestCallback, dev );
if( !HAL_STATUS_SUCCESS(status) )
{
VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL, "%s: SME scan fail status %d !!!",__func__, status);
pHddCtx->scan_info.mScanPending = FALSE;
status = -EINVAL;
goto exit_point;
}
pHddCtx->scan_info.scanId = scanId;
}
else {
status = -1;
}
exit_point:
if (scanRequest.SSIDs.SSIDList)
{
vos_mem_free(scanRequest.SSIDs.SSIDList);
}
if(scanRequest.ChannelInfo.ChannelList)
{
vos_mem_free((void*)scanRequest.ChannelInfo.ChannelList);
}
EXIT();
VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "%s: exit !!!",__func__);
return status;
}
int iw_set_cscan(struct net_device *dev, struct iw_request_info *info,
union iwreq_data *wrqu, char *extra)
{
hdd_adapter_t *pAdapter = WLAN_HDD_GET_PRIV_PTR(dev) ;
hdd_context_t *pHddCtx = WLAN_HDD_GET_CTX(pAdapter);
hdd_wext_state_t *pwextBuf = WLAN_HDD_GET_WEXT_STATE_PTR(pAdapter);
tCsrScanRequest scanRequest;
v_U32_t scanId = 0;
eHalStatus status = eHAL_STATUS_SUCCESS;
v_U8_t channelIdx;
ENTER();
VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "%s: enter !!!",__func__);
#ifdef WLAN_BTAMP_FEATURE
//Scan not supported when AMP traffic is on.
if( VOS_TRUE == WLANBAP_AmpSessionOn() )
{
VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "%s: No scanning when AMP is on",__func__);
return eHAL_STATUS_SUCCESS;
}
#endif
if ((WLAN_HDD_GET_CTX(pAdapter))->isLogpInProgress)
{
VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL, "%s:LOGP in Progress. Ignore!!!",__func__);
return eHAL_STATUS_SUCCESS;
}
vos_mem_zero( &scanRequest, sizeof(scanRequest));
if (NULL != wrqu->data.pointer)
{
char *str_ptr = NULL;
tCsrSSIDInfo *SsidInfo = NULL;
int num_ssid = 0;
int i, j, ssid_start;
hdd_scan_pending_option_e scanPendingOption = WEXT_SCAN_PENDING_GIVEUP;
str_ptr = extra;
i = WEXT_CSCAN_HEADER_SIZE;
if( WEXT_CSCAN_PENDING_SECTION == str_ptr[i] )
{
scanPendingOption = (hdd_scan_pending_option_e)str_ptr[++i];
++i;
}
pHddCtx->scan_info.scan_pending_option = scanPendingOption;
if(pHddCtx->scan_info.mScanPending == TRUE)
{
hddLog(LOG1,"%s: mScanPending is TRUE",__func__);
/* If any scan is pending, just giveup this scan request */
if(WEXT_SCAN_PENDING_GIVEUP == scanPendingOption)
{
pHddCtx->scan_info.waitScanResult = FALSE;
return eHAL_STATUS_SUCCESS;
}
/* If any scan pending, wait till finish current scan,
and try this scan request when previous scan finish */
else if(WEXT_SCAN_PENDING_DELAY == scanPendingOption)
{
pHddCtx->scan_info.waitScanResult = TRUE;
vos_event_reset(&pHddCtx->scan_info.scan_finished_event);
if(vos_wait_single_event(&pHddCtx->scan_info.scan_finished_event,
WEXT_CSCAN_SCAN_DONE_WAIT_TIME))
{
hddLog(LOG1,"%s: Previous SCAN does not finished on time",__func__);
return eHAL_STATUS_SUCCESS;
}
}
/* Piggyback previous scan result */
else if(WEXT_SCAN_PENDING_PIGGYBACK == scanPendingOption)
{
pHddCtx->scan_info.waitScanResult = TRUE;
return eHAL_STATUS_SUCCESS;
}
}
pHddCtx->scan_info.waitScanResult = FALSE;
/* Check for scan IE */
while( WEXT_CSCAN_SSID_SECTION == str_ptr[i] )
{
/* ssid_len */
if(str_ptr[++i] != WEXT_CSCAN_CHANNEL_SECTION)
{
/* total number of ssid's */
num_ssid++;
/* increment length filed */
i += str_ptr[i] + 1;
}
/* i should be saved and it will be pointing to 'C' */
}
VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "%s: numSsid %d !!!",__func__, num_ssid);
if( num_ssid )
{
/* To be fixed in SME and PE: override the number of ssid with 1,
* as SME and PE does not handle multiple SSID in scan request
* */
scanRequest.SSIDs.numOfSSIDs = num_ssid;
/* Allocate num_ssid tCsrSSIDInfo structure */
SsidInfo = scanRequest.SSIDs.SSIDList =( tCsrSSIDInfo *)vos_mem_malloc(num_ssid*sizeof(tCsrSSIDInfo));
if(NULL == scanRequest.SSIDs.SSIDList) {
hddLog(VOS_TRACE_LEVEL_ERROR, "memory alloc failed SSIDInfo buffer");
return -ENOMEM;
}
/* copy all the ssid's and their length */
ssid_start = WEXT_CSCAN_HEADER_SIZE + 1;/* skipping 'S' */
for(j = 0; j < num_ssid; j++) {
if( SIR_MAC_MAX_SSID_LENGTH < str_ptr[ssid_start]){
scanRequest.SSIDs.numOfSSIDs -= 1;
} else{
/* get the ssid length */
SsidInfo->SSID.length = str_ptr[ssid_start++];
vos_mem_copy(SsidInfo->SSID.ssId, &str_ptr[ssid_start], SsidInfo->SSID.length);
hddLog(VOS_TRACE_LEVEL_INFO_HIGH, "SSID number %d: %s", j, SsidInfo->SSID.ssId);
}
/* skipping length */
ssid_start += str_ptr[ssid_start - 1] + 1;
/* Store next ssid info */
SsidInfo++;
}
}
/* Check for Channel IE */
if ( WEXT_CSCAN_CHANNEL_SECTION == str_ptr[i])
{
if( str_ptr[++i] == 0 )
{
scanRequest.ChannelInfo.numOfChannels = 0;
scanRequest.ChannelInfo.ChannelList = NULL;
i++;
}
else {
/* increment the counter */
scanRequest.ChannelInfo.numOfChannels = str_ptr[i++];
/* store temp channel list */
/* SME expects 1 byte channel content */
scanRequest.ChannelInfo.ChannelList = vos_mem_malloc(scanRequest.ChannelInfo.numOfChannels * sizeof(v_U8_t));
if(NULL == scanRequest.ChannelInfo.ChannelList)
{
hddLog(VOS_TRACE_LEVEL_INFO_HIGH, "memory alloc failed for channel list creation");
status = -ENOMEM;
goto exit_point;
}
for(channelIdx = 0; channelIdx < scanRequest.ChannelInfo.numOfChannels; channelIdx++)
{
/* SCAN request from upper layer has 2 bytes channel */
scanRequest.ChannelInfo.ChannelList[channelIdx] = (v_U8_t)str_ptr[i];
i += sizeof(v_U16_t);
}
}
}
/* Set default */
scanRequest.scanType = eSIR_ACTIVE_SCAN;
scanRequest.minChnTime = 0;
scanRequest.maxChnTime = 0;
/* Now i is pointing to passive dwell dwell time */
/* 'P',min dwell time, max dwell time */
/* next two offsets contain min and max channel time */
if( WEXT_CSCAN_PASV_DWELL_SECTION == (str_ptr[i]) )
{
/* No SSID specified, num_ssid == 0, then start paasive scan */
if (!num_ssid || (eSIR_PASSIVE_SCAN == pHddCtx->scan_info.scan_mode))
{
scanRequest.scanType = eSIR_PASSIVE_SCAN;
scanRequest.minChnTime = (v_U8_t)str_ptr[++i];//scanReq->min_channel_time;
scanRequest.maxChnTime = (v_U8_t)str_ptr[++i];//scanReq->max_channel_time;
i++;
}
else
{
i += 3;
}
}
/* H indicates active channel time */
if( WEXT_CSCAN_HOME_DWELL_SECTION == (str_ptr[i]) )
{
if (num_ssid || (eSIR_ACTIVE_SCAN == pHddCtx->scan_info.scan_mode))
{
scanRequest.scanType = eSIR_ACTIVE_SCAN;
scanRequest.minChnTime = str_ptr[++i];//scanReq->min_channel_time;
scanRequest.maxChnTime = str_ptr[++i];//scanReq->max_channel_time;
i++;
}
else
{
i +=3;
}
}
scanRequest.BSSType = eCSR_BSS_TYPE_ANY;
/* set requestType to full scan */
scanRequest.requestType = eCSR_SCAN_REQUEST_FULL_SCAN;
pHddCtx->scan_info.mScanPending = TRUE;
/* if previous genIE is not NULL, update ScanIE */
if(0 != pwextBuf->genIE.length)
{
memset( &pHddCtx->scan_info.scanAddIE, 0, sizeof(pHddCtx->scan_info.scanAddIE) );
memcpy( pHddCtx->scan_info.scanAddIE.addIEdata, pwextBuf->genIE.addIEdata,
pwextBuf->genIE.length );
pHddCtx->scan_info.scanAddIE.length = pwextBuf->genIE.length;
pwextBuf->roamProfile.pAddIEScan = pHddCtx->scan_info.scanAddIE.addIEdata;
pwextBuf->roamProfile.nAddIEScanLength = pHddCtx->scan_info.scanAddIE.length;
/* clear previous genIE after use it */
memset( &pwextBuf->genIE, 0, sizeof(pwextBuf->genIE) );
}
/* push addIEScan in scanRequset if exist */
if (pHddCtx->scan_info.scanAddIE.addIEdata &&
pHddCtx->scan_info.scanAddIE.length)
{
scanRequest.uIEFieldLen = pHddCtx->scan_info.scanAddIE.length;
scanRequest.pIEField = pHddCtx->scan_info.scanAddIE.addIEdata;
}
status = sme_ScanRequest( (WLAN_HDD_GET_CTX(pAdapter))->hHal,
pAdapter->sessionId,&scanRequest, &scanId, &hdd_ScanRequestCallback, dev );
if( !HAL_STATUS_SUCCESS(status) )
{
VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL, "%s: SME scan fail status %d !!!",__func__, status);
pHddCtx->scan_info.mScanPending = FALSE;
status = -EINVAL;
goto exit_point;
}
pHddCtx->scan_info.scanId = scanId;
} //end of data->pointer
else {
status = -1;
}
exit_point:
/* free ssidlist */
if (scanRequest.SSIDs.SSIDList)
{
vos_mem_free(scanRequest.SSIDs.SSIDList);
}
/* free the channel list */
if(scanRequest.ChannelInfo.ChannelList)
{
vos_mem_free((void*)scanRequest.ChannelInfo.ChannelList);
}
EXIT();
VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO, "%s: exit !!!",__func__);
return status;
}
VOS_STATUS vos_start( v_CONTEXT_t vosContext )
{
VOS_STATUS vStatus = VOS_STATUS_SUCCESS;
tSirRetStatus sirStatus = eSIR_SUCCESS;
pVosContextType pVosContext = (pVosContextType)vosContext;
tHalMacStartParameters halStartParams;
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"%s: Starting Libra SW", __func__);
if (gpVosContext != pVosContext)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: mismatch in context", __func__);
return VOS_STATUS_E_FAILURE;
}
if (( pVosContext->pWDAContext == NULL) || ( pVosContext->pMACContext == NULL)
|| ( pVosContext->pTLContext == NULL))
{
if (pVosContext->pWDAContext == NULL)
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: WDA NULL context", __func__);
else if (pVosContext->pMACContext == NULL)
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: MAC NULL context", __func__);
else
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: TL NULL context", __func__);
return VOS_STATUS_E_FAILURE;
}
vos_event_reset( &(gpVosContext->wdaCompleteEvent) );
vStatus = WDA_NVDownload_Start(pVosContext);
if ( vStatus != VOS_STATUS_SUCCESS )
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to start NV Download", __func__);
return VOS_STATUS_E_FAILURE;
}
vStatus = vos_wait_single_event( &(gpVosContext->wdaCompleteEvent),
VOS_WDA_TIMEOUT );
if ( vStatus != VOS_STATUS_SUCCESS )
{
if ( vStatus == VOS_STATUS_E_TIMEOUT )
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Timeout occurred before WDA_NVDownload_start complete", __func__);
}
else
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: WDA_NVDownload_start reporting other error", __func__);
}
VOS_ASSERT(0);
vos_event_reset( &(gpVosContext->wdaCompleteEvent) );
if (vos_is_logp_in_progress(VOS_MODULE_ID_VOSS, NULL))
{
VOS_BUG(0);
}
WDA_setNeedShutdown(vosContext);
return VOS_STATUS_E_FAILURE;
}
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"%s: WDA_NVDownload_start correctly started", __func__);
vStatus = WDA_start(pVosContext);
if ( vStatus != VOS_STATUS_SUCCESS )
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to start WDA", __func__);
return VOS_STATUS_E_FAILURE;
}
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"%s: WDA correctly started", __func__);
vos_mem_zero((v_PVOID_t)&halStartParams, sizeof(tHalMacStartParameters));
sirStatus = macStart(pVosContext->pMACContext,(v_PVOID_t)&halStartParams);
if (eSIR_SUCCESS != sirStatus)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Failed to start MAC", __func__);
goto err_wda_stop;
}
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"%s: MAC correctly started", __func__);
vStatus = sme_Start(pVosContext->pMACContext);
if (!VOS_IS_STATUS_SUCCESS(vStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Failed to start SME", __func__);
goto err_mac_stop;
}
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"%s: SME correctly started", __func__);
vStatus = WLANTL_Start(pVosContext);
if (!VOS_IS_STATUS_SUCCESS(vStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Failed to start TL", __func__);
goto err_sme_stop;
}
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"TL correctly started");
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"%s: VOSS Start is successful!!", __func__);
return VOS_STATUS_SUCCESS;
err_sme_stop:
sme_Stop(pVosContext->pMACContext, HAL_STOP_TYPE_SYS_RESET);
err_mac_stop:
macStop( pVosContext->pMACContext, HAL_STOP_TYPE_SYS_RESET );
err_wda_stop:
vos_event_reset( &(gpVosContext->wdaCompleteEvent) );
vStatus = WDA_stop( pVosContext, HAL_STOP_TYPE_RF_KILL);
if (!VOS_IS_STATUS_SUCCESS(vStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to stop WDA", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vStatus ) );
WDA_setNeedShutdown(vosContext);
}
else
{
vStatus = vos_wait_single_event( &(gpVosContext->wdaCompleteEvent),
VOS_WDA_TIMEOUT );
if( vStatus != VOS_STATUS_SUCCESS )
{
if( vStatus == VOS_STATUS_E_TIMEOUT )
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Timeout occurred before WDA_stop complete", __func__);
}
else
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: WDA_stop reporting other error", __func__);
}
VOS_ASSERT( 0 );
WDA_setNeedShutdown(vosContext);
}
}
return VOS_STATUS_E_FAILURE;
}
VOS_STATUS vos_preStart( v_CONTEXT_t vosContext )
{
VOS_STATUS vStatus = VOS_STATUS_SUCCESS;
pVosContextType pVosContext = (pVosContextType)vosContext;
VOS_TRACE(VOS_MODULE_ID_SYS, VOS_TRACE_LEVEL_INFO,
"vos prestart");
if (gpVosContext != pVosContext)
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Context mismatch", __func__);
VOS_ASSERT(0);
return VOS_STATUS_E_INVAL;
}
if (pVosContext->pMACContext == NULL)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: MAC NULL context", __func__);
VOS_ASSERT(0);
return VOS_STATUS_E_INVAL;
}
if (pVosContext->pWDAContext == NULL)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: WDA NULL context", __func__);
VOS_ASSERT(0);
return VOS_STATUS_E_INVAL;
}
vStatus = macPreStart(gpVosContext->pMACContext);
if ( !VOS_IS_STATUS_SUCCESS(vStatus) )
{
VOS_TRACE(VOS_MODULE_ID_SYS, VOS_TRACE_LEVEL_FATAL,
"Failed at macPreStart ");
return VOS_STATUS_E_FAILURE;
}
ccmStart(gpVosContext->pMACContext);
vos_event_reset(&gpVosContext->wdaCompleteEvent);
vStatus = WDA_preStart(gpVosContext);
if (!VOS_IS_STATUS_SUCCESS(vStatus))
{
VOS_TRACE(VOS_MODULE_ID_SYS, VOS_TRACE_LEVEL_FATAL,
"Failed to WDA prestart");
macStop(gpVosContext->pMACContext, HAL_STOP_TYPE_SYS_DEEP_SLEEP);
ccmStop(gpVosContext->pMACContext);
VOS_ASSERT(0);
return VOS_STATUS_E_FAILURE;
}
vStatus = vos_wait_single_event( &gpVosContext->wdaCompleteEvent,
VOS_WDA_TIMEOUT );
if ( vStatus != VOS_STATUS_SUCCESS )
{
if ( vStatus == VOS_STATUS_E_TIMEOUT )
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Timeout occurred before WDA complete", __func__);
}
else
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: WDA_preStart reporting other error", __func__);
}
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Test MC thread by posting a probe message to SYS", __func__);
wlan_sys_probe();
macStop(gpVosContext->pMACContext, HAL_STOP_TYPE_SYS_DEEP_SLEEP);
ccmStop(gpVosContext->pMACContext);
VOS_ASSERT( 0 );
return VOS_STATUS_E_FAILURE;
}
return VOS_STATUS_SUCCESS;
}
