/*
 * ---------------------------------------------------------------------------
 * 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