- 根目录:
- drivers
- staging
- csr
- sme_mgt.c
/*
* ---------------------------------------------------------------------------
* FILE: sme_mgt.c
*
* PURPOSE:
* This file contains the driver specific implementation of
* the SME MGT SAP.
* It is part of the porting exercise.
*
* Copyright (C) 2008-2009 by Cambridge Silicon Radio Ltd.
*
* Refer to LICENSE.txt included with this source code for details on
* the license terms.
*
* ---------------------------------------------------------------------------
*/
#include "csr_wifi_hip_unifiversion.h"
#include "unifi_priv.h"
#include "csr_wifi_hip_conversions.h"
/*
* This file implements the SME MGT API. It contains the following functions:
* CsrWifiSmeWifiFlightmodeCfmSend()
* CsrWifiSmeWifiOnCfmSend()
* CsrWifiSmeWifiOffCfmSend()
* CsrWifiSmeWifiOffIndSend()
* CsrWifiSmeScanFullCfmSend()
* CsrWifiSmeScanResultsGetCfmSend()
* CsrWifiSmeScanResultIndSend()
* CsrWifiSmeScanResultsFlushCfmSend()
* CsrWifiSmeConnectCfmSend()
* CsrWifiSmeMediaStatusIndSend()
* CsrWifiSmeDisconnectCfmSend()
* CsrWifiSmeKeyCfmSend()
* CsrWifiSmeMulticastAddressCfmSend()
* CsrWifiSmeSetValueCfmSend()
* CsrWifiSmeGetValueCfmSend()
* CsrWifiSmeMicFailureIndSend()
* CsrWifiSmePmkidCfmSend()
* CsrWifiSmePmkidCandidateListIndSend()
* CsrWifiSmeMibSetCfmSend()
* CsrWifiSmeMibGetCfmSend()
* CsrWifiSmeMibGetNextCfmSend()
* CsrWifiSmeConnectionQualityIndSend()
* CsrWifiSmePacketFilterSetCfmSend()
* CsrWifiSmeTspecCfmSend()
* CsrWifiSmeTspecIndSend()
* CsrWifiSmeBlacklistCfmSend()
* CsrWifiSmeEventMaskSetCfmSend()
* CsrWifiSmeRoamStartIndSend()
* CsrWifiSmeRoamCompleteIndSend()
* CsrWifiSmeAssociationStartIndSend()
* CsrWifiSmeAssociationCompleteIndSend()
* CsrWifiSmeIbssStationIndSend()
*/
void CsrWifiSmeMicFailureIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeMicFailureInd* ind = (CsrWifiSmeMicFailureInd*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeMicFailureIndSend: invalid priv\n");
return;
}
unifi_trace(priv, UDBG1,
"CsrWifiSmeMicFailureIndSend: count=%d, KeyType=%d\n",
ind->count, ind->keyType);
wext_send_michaelmicfailure_event(priv, ind->count, ind->address, ind->keyType, ind->interfaceTag);
#endif
}
void CsrWifiSmePmkidCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmePmkidCfm* cfm = (CsrWifiSmePmkidCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmePmkidCfmSend: Invalid ospriv.\n");
return;
}
/*
* WEXT never does a GET operation the PMKIDs, so we don't need
* handle data returned in pmkids.
*/
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmePmkidCandidateListIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmePmkidCandidateListInd* ind = (CsrWifiSmePmkidCandidateListInd*)msg;
int i;
if (priv->smepriv == NULL) {
unifi_error(priv, "CsrWifiSmePmkidCandidateListIndSend: invalid smepriv\n");
return;
}
for (i = 0; i < ind->pmkidCandidatesCount; i++)
{
wext_send_pmkid_candidate_event(priv, ind->pmkidCandidates[i].bssid, ind->pmkidCandidates[i].preAuthAllowed, ind->interfaceTag);
}
#endif
}
void CsrWifiSmeScanResultsFlushCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeScanResultsGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeScanResultsGetCfm* cfm = (CsrWifiSmeScanResultsGetCfm*)msg;
int bytesRequired = cfm->scanResultsCount * sizeof(CsrWifiSmeScanResult);
int i;
u8* current_buff;
CsrWifiSmeScanResult* scanCopy;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeScanResultsGetCfmSend: Invalid ospriv.\n");
return;
}
/* Calc the size of the buffer reuired */
for (i = 0; i < cfm->scanResultsCount; ++i) {
const CsrWifiSmeScanResult *scan_result = &cfm->scanResults[i];
bytesRequired += scan_result->informationElementsLength;
}
/* Take a Copy of the scan Results :-) */
scanCopy = kmalloc(bytesRequired, GFP_KERNEL);
memcpy(scanCopy, cfm->scanResults, sizeof(CsrWifiSmeScanResult) * cfm->scanResultsCount);
/* Take a Copy of the Info Elements AND update the scan result pointers */
current_buff = (u8*)&scanCopy[cfm->scanResultsCount];
for (i = 0; i < cfm->scanResultsCount; ++i)
{
CsrWifiSmeScanResult *scan_result = &scanCopy[i];
memcpy(current_buff, scan_result->informationElements, scan_result->informationElementsLength);
scan_result->informationElements = current_buff;
current_buff += scan_result->informationElementsLength;
}
priv->sme_reply.reply_scan_results_count = cfm->scanResultsCount;
priv->sme_reply.reply_scan_results = scanCopy;
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeScanFullCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeScanFullCfm* cfm = (CsrWifiSmeScanFullCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeScanFullCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeScanResultIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeConnectCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeConnectCfm* cfm = (CsrWifiSmeConnectCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeConnectCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeDisconnectCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeDisconnectCfm* cfm = (CsrWifiSmeDisconnectCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeDisconnectCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeKeyCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeKeyCfm* cfm = (CsrWifiSmeKeyCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeKeyCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeMulticastAddressCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeMulticastAddressCfm* cfm = (CsrWifiSmeMulticastAddressCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeMulticastAddressCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeWifiFlightmodeCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeWifiFlightmodeCfm* cfm = (CsrWifiSmeWifiFlightmodeCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeWifiFlightmodeCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeWifiOnCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeWifiOnCfm* cfm = (CsrWifiSmeWifiOnCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeWifiOnCfmSend: Invalid ospriv.\n");
return;
}
unifi_trace(priv, UDBG4,
"CsrWifiSmeWifiOnCfmSend: wake up status %d\n", cfm->status);
#ifdef CSR_SUPPORT_WEXT_AP
sme_complete_request(priv, cfm->status);
#endif
#endif
}
void CsrWifiSmeWifiOffCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeWifiOffCfm* cfm = (CsrWifiSmeWifiOffCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeWifiOffCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeWifiOffIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeWifiOffInd* ind = (CsrWifiSmeWifiOffInd*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiRouterCtrlStoppedReqSend: Invalid ospriv.\n");
return;
}
if (priv->smepriv == NULL) {
unifi_error(priv, "CsrWifiRouterCtrlStoppedReqSend: invalid smepriv\n");
return;
}
/*
* If the status indicates an error, the SME is in a stopped state.
* We need to start it again in order to reinitialise UniFi.
*/
switch (ind->reason) {
case CSR_WIFI_SME_CONTROL_INDICATION_ERROR:
unifi_trace(priv, UDBG1,
"CsrWifiRouterCtrlStoppedReqSend: Restarting SME (ind:%d)\n",
ind->reason);
/* On error, restart the SME */
sme_mgt_wifi_on(priv);
break;
case CSR_WIFI_SME_CONTROL_INDICATION_EXIT:
#ifdef CSR_SUPPORT_WEXT_AP
sme_complete_request(priv, 0);
#endif
break;
default:
break;
}
#endif
}
void CsrWifiSmeVersionsGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeVersionsGetCfm* cfm = (CsrWifiSmeVersionsGetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeVersionsGetCfmSend: Invalid ospriv.\n");
return;
}
priv->sme_reply.versions = cfm->versions;
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmePowerConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmePowerConfigGetCfm* cfm = (CsrWifiSmePowerConfigGetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmePowerConfigGetCfmSend: Invalid ospriv.\n");
return;
}
priv->sme_reply.powerConfig = cfm->powerConfig;
sme_complete_request(priv, cfm->status);
}
void CsrWifiSmeHostConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeHostConfigGetCfm* cfm = (CsrWifiSmeHostConfigGetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeHostConfigGetCfmSend: Invalid ospriv.\n");
return;
}
priv->sme_reply.hostConfig = cfm->hostConfig;
sme_complete_request(priv, cfm->status);
}
void CsrWifiSmeCoexInfoGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeCoexInfoGetCfm* cfm = (CsrWifiSmeCoexInfoGetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeCoexInfoGetCfmSend: Invalid ospriv.\n");
return;
}
priv->sme_reply.coexInfo = cfm->coexInfo;
sme_complete_request(priv, cfm->status);
}
void CsrWifiSmeCoexConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeCoexConfigGetCfm* cfm = (CsrWifiSmeCoexConfigGetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeCoexConfigGetCfmSend: Invalid ospriv.\n");
return;
}
priv->sme_reply.coexConfig = cfm->coexConfig;
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeMibConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeMibConfigGetCfm* cfm = (CsrWifiSmeMibConfigGetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeMibConfigGetCfmSend: Invalid ospriv.\n");
return;
}
priv->sme_reply.mibConfig = cfm->mibConfig;
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeConnectionInfoGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeConnectionInfoGetCfm* cfm = (CsrWifiSmeConnectionInfoGetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeConnectionInfoGetCfmSend: Invalid ospriv.\n");
return;
}
priv->sme_reply.connectionInfo = cfm->connectionInfo;
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeConnectionConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeConnectionConfigGetCfm* cfm = (CsrWifiSmeConnectionConfigGetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeConnectionConfigGetCfmSend: Invalid ospriv.\n");
return;
}
priv->sme_reply.connectionConfig = cfm->connectionConfig;
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeConnectionStatsGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeConnectionStatsGetCfm* cfm = (CsrWifiSmeConnectionStatsGetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeConnectionStatsGetCfmSend: Invalid ospriv.\n");
return;
}
priv->sme_reply.connectionStats = cfm->connectionStats;
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeMibSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeMibSetCfm* cfm = (CsrWifiSmeMibSetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeMibSetCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeMibGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeMibGetCfm* cfm = (CsrWifiSmeMibGetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeMibGetCfmSend: Invalid ospriv.\n");
return;
}
if (cfm->mibAttribute == NULL) {
unifi_error(priv, "CsrWifiSmeMibGetCfmSend: Empty reply.\n");
sme_complete_request(priv, cfm->status);
return;
}
if ((priv->mib_cfm_buffer != NULL) &&
(priv->mib_cfm_buffer_length >= cfm->mibAttributeLength)) {
memcpy(priv->mib_cfm_buffer, cfm->mibAttribute, cfm->mibAttributeLength);
priv->mib_cfm_buffer_length = cfm->mibAttributeLength;
} else {
unifi_error(priv,
"CsrWifiSmeMibGetCfmSend: No room to store MIB data (have=%d need=%d).\n",
priv->mib_cfm_buffer_length, cfm->mibAttributeLength);
}
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeMibGetNextCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeMibGetNextCfm* cfm = (CsrWifiSmeMibGetNextCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeMibGetNextCfmSend: Invalid ospriv.\n");
return;
}
/* Need to copy MIB data */
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeConnectionQualityIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeConnectionQualityInd* ind = (CsrWifiSmeConnectionQualityInd*)msg;
int signal, noise, snr;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeConnectionQualityIndSend: Invalid ospriv.\n");
return;
}
/*
* level and noise below are mapped into an unsigned 8 bit number,
* ranging from [-192; 63]. The way this is achieved is simply to
* add 0x100 onto the number if it is negative,
* once clipped to the correct range.
*/
signal = ind->linkQuality.unifiRssi;
/* Clip range of snr */
snr = (ind->linkQuality.unifiSnr > 0) ? ind->linkQuality.unifiSnr : 0; /* In dB relative, from 0 - 255 */
snr = (snr < 255) ? snr : 255;
noise = signal - snr;
/* Clip range of signal */
signal = (signal < 63) ? signal : 63;
signal = (signal > -192) ? signal : -192;
/* Clip range of noise */
noise = (noise < 63) ? noise : 63;
noise = (noise > -192) ? noise : -192;
/* Make u8 */
signal = ( signal < 0 ) ? signal + 0x100 : signal;
noise = ( noise < 0 ) ? noise + 0x100 : noise;
priv->wext_wireless_stats.qual.level = (u8)signal; /* -192 : 63 */
priv->wext_wireless_stats.qual.noise = (u8)noise; /* -192 : 63 */
priv->wext_wireless_stats.qual.qual = snr; /* 0 : 255 */
priv->wext_wireless_stats.qual.updated = 0;
#if WIRELESS_EXT > 16
priv->wext_wireless_stats.qual.updated |= IW_QUAL_LEVEL_UPDATED |
IW_QUAL_NOISE_UPDATED |
IW_QUAL_QUAL_UPDATED;
#if WIRELESS_EXT > 18
priv->wext_wireless_stats.qual.updated |= IW_QUAL_DBM;
#endif
#endif
#endif
}
void CsrWifiSmePacketFilterSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmePacketFilterSetCfmSend: Invalid ospriv.\n");
return;
}
/* The packet filter set request does not block for a reply */
}
void CsrWifiSmeTspecCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeTspecCfm* cfm = (CsrWifiSmeTspecCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeTspecCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
}
void CsrWifiSmeTspecIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeBlacklistCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeEventMaskSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeRoamStartIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeRoamCompleteIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
/* This is called when the association completes, before any 802.1x authentication */
}
void CsrWifiSmeAssociationStartIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeAssociationCompleteIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeIbssStationIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeWifiOnIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeRestrictedAccessEnableCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeRestrictedAccessDisableCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeAdhocConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeAdhocConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeAdhocConfigSetCfm* cfm = (CsrWifiSmeAdhocConfigSetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeCalibrationDataGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeCalibrationDataSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeCalibrationDataSetCfm* cfm = (CsrWifiSmeCalibrationDataSetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeCcxConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeCcxConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeCcxConfigSetCfm* cfm = (CsrWifiSmeCcxConfigSetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeCloakedSsidsGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeCloakedSsidsSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeCloakedSsidsSetCfm* cfm = (CsrWifiSmeCloakedSsidsSetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeCoexConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeCoexConfigSetCfm* cfm = (CsrWifiSmeCoexConfigSetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeHostConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeHostConfigSetCfm* cfm = (CsrWifiSmeHostConfigSetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
}
void CsrWifiSmeLinkQualityGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeMibConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeMibConfigSetCfm* cfm = (CsrWifiSmeMibConfigSetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmePermanentMacAddressGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmePowerConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmePowerConfigSetCfm* cfm = (CsrWifiSmePowerConfigSetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
}
void CsrWifiSmeRegulatoryDomainInfoGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeRoamingConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeMediaStatusIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeMediaStatusInd* ind = (CsrWifiSmeMediaStatusInd*)msg;
if (priv->smepriv == NULL) {
unifi_error(priv, "CsrWifiSmeMediaStatusIndSend: invalid smepriv\n");
return;
}
if (ind->mediaStatus == CSR_WIFI_SME_MEDIA_STATUS_CONNECTED) {
/*
* Send wireless-extension event up to userland to announce
* connection.
*/
wext_send_assoc_event(priv,
(unsigned char *)ind->connectionInfo.bssid.a,
(unsigned char *)ind->connectionInfo.assocReqInfoElements,
ind->connectionInfo.assocReqInfoElementsLength,
(unsigned char *)ind->connectionInfo.assocRspInfoElements,
ind->connectionInfo.assocRspInfoElementsLength,
(unsigned char *)ind->connectionInfo.assocScanInfoElements,
ind->connectionInfo.assocScanInfoElementsLength);
unifi_trace(priv, UDBG2, "CsrWifiSmeMediaStatusIndSend: IBSS=%pM\n",
ind->connectionInfo.bssid.a);
sme_mgt_packet_filter_set(priv);
} else {
/*
* Send wireless-extension event up to userland to announce
* connection lost to a BSS.
*/
wext_send_disassoc_event(priv);
}
#endif
}
void CsrWifiSmeRoamingConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeRoamingConfigSetCfm* cfm = (CsrWifiSmeRoamingConfigSetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeRoamingConfigSetCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
}
void CsrWifiSmeScanConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeScanConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
#ifdef CSR_SUPPORT_WEXT
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeScanConfigSetCfm* cfm = (CsrWifiSmeScanConfigSetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeSmeConfigSetCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
#endif
}
void CsrWifiSmeStationMacAddressGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeSmeCommonConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeSmeCommonConfigGetCfm* cfm = (CsrWifiSmeSmeCommonConfigGetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeSmeCommonConfigGetCfmSend: Invalid ospriv.\n");
return;
}
priv->sme_reply.deviceConfig = cfm->deviceConfig;
sme_complete_request(priv, cfm->status);
}
void CsrWifiSmeSmeStaConfigGetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeSmeStaConfigGetCfm* cfm = (CsrWifiSmeSmeStaConfigGetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeSmeStaConfigGetCfmSend: Invalid ospriv.\n");
return;
}
priv->sme_reply.staConfig = cfm->smeConfig;
sme_complete_request(priv, cfm->status);
}
void CsrWifiSmeSmeCommonConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeSmeCommonConfigSetCfm* cfm = (CsrWifiSmeSmeCommonConfigSetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeSmeCommonConfigGetCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
}
void CsrWifiSmeSmeStaConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiSmeSmeStaConfigSetCfm* cfm = (CsrWifiSmeSmeStaConfigSetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiSmeSmeStaConfigGetCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
}
void CsrWifiSmeGetInterfaceCapabilityCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeErrorIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeInfoIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeCoreDumpIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeAmpStatusChangeIndHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeActivateCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
void CsrWifiSmeDeactivateCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
}
#ifdef CSR_SUPPORT_WEXT
#ifdef CSR_SUPPORT_WEXT_AP
void CsrWifiNmeApStartCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiNmeApStartCfm* cfm = (CsrWifiNmeApStartCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiNmeApStartCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
}
void CsrWifiNmeApStopCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiNmeApStopCfm* cfm = (CsrWifiNmeApStopCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiNmeApStopCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
}
void CsrWifiNmeApConfigSetCfmHandler(void* drvpriv, CsrWifiFsmEvent* msg)
{
unifi_priv_t *priv = (unifi_priv_t*)drvpriv;
CsrWifiNmeApConfigSetCfm* cfm = (CsrWifiNmeApConfigSetCfm*)msg;
if (priv == NULL) {
unifi_error(NULL, "CsrWifiNmeApConfigSetCfmSend: Invalid ospriv.\n");
return;
}
sme_complete_request(priv, cfm->status);
}
#endif
#endif