CORE/MAC/src/pe/lim/limRMC.c

/*
 * Copyright (c) 2013-2017 The Linux Foundation. All rights reserved.
 *
 * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
 *
 *
 * Permission to use, copy, modify, and/or distribute this software for
 * any purpose with or without fee is hereby granted, provided that the
 * above copyright notice and this permission notice appear in all
 * copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 */

/*
 * This file was originally distributed by Qualcomm Atheros, Inc.
 * under proprietary terms before Copyright ownership was assigned
 * to the Linux Foundation.
 */

/*
 * This file limRMC.c contains the code
 * for processing RMC messages
 *
 */
#include "wniApi.h"
#include "wniCfg.h"
#include "cfgApi.h"
#include "sirApi.h"
#include "schApi.h"
#include "utilsApi.h"
#include "limUtils.h"
#include "limTimerUtils.h"
#include "limSendMessages.h"
#include "limSendMessages.h"
#include "limSession.h"
#include "limSessionUtils.h"
#include "wlan_qct_wda.h"
#include "wlan_qct_tli.h"
#include "limRMC.h"

#ifdef WLAN_FEATURE_RMC

static tANI_U8
__rmcGroupHashFunction(tSirMacAddr transmitter)
{
    tANI_U16 hash;

    /*
     * Generate a hash using transmitter address
     */
    hash = transmitter[0] + transmitter[1] + transmitter[2] +
            transmitter[3] + transmitter[4] + transmitter[5];

    return hash & (RMC_MCAST_GROUPS_HASH_SIZE - 1);
}


static tLimRmcGroupContext *
__rmcGroupLookupHashEntry(tpAniSirGlobal pMac, tSirMacAddr transmitter)
{
    tANI_U8 index;
    tLimRmcGroupContext *entry;

    index = __rmcGroupHashFunction(transmitter);

    /* Pick the correct hash table based on role */
    entry = pMac->rmcContext.rmcGroupRxHashTable[index];

    PELOG1(limLog(pMac, LOG1, FL("RMC: Hash Lookup:[%d] transmitter "
                         MAC_ADDRESS_STR ), index,
                         MAC_ADDR_ARRAY(transmitter));)
    while (entry)
    {
        if (vos_mem_compare(transmitter, entry->transmitter,
             sizeof(v_MACADDR_t)))
        {
            return entry;
        }

        entry = entry->next;
    }

    return NULL;
}

static tLimRmcGroupContext *
__rmcGroupInsertHashEntry(tpAniSirGlobal pMac, tSirMacAddr transmitter)
{
    tANI_U8 index;
    tLimRmcGroupContext *entry;
    tLimRmcGroupContext **head;

    index = __rmcGroupHashFunction(transmitter);

    PELOG1(limLog(pMac, LOG1, FL("RMC: Hash Insert:[%d] group " MAC_ADDRESS_STR
                             " transmitter " MAC_ADDRESS_STR), index,
                             MAC_ADDR_ARRAY(mcastGroupAddr),
                             MAC_ADDR_ARRAY(transmitter));)

    head = &pMac->rmcContext.rmcGroupRxHashTable[index];

    entry = __rmcGroupLookupHashEntry(pMac, transmitter);

    if (entry)
    {
        /* If the entry exists, return it at the end */
        PELOGE(limLog(pMac, LOGE, FL("RMC: Hash Insert:"
                 MAC_ADDRESS_STR "exists"), MAC_ADDR_ARRAY(transmitter));)
    }
    else
    {
        entry = (tLimRmcGroupContext *)vos_mem_malloc(sizeof(*entry));

        PELOG1(limLog(pMac, LOG1, FL("RMC: Hash Insert:new entry %pK"), entry);)

        if (entry)
        {
            vos_mem_copy(entry->transmitter, transmitter, sizeof(tSirMacAddr));
            entry->isRuler = eRMC_IS_NOT_A_RULER;

            /* chain this entry */
            entry->next = *head;
            *head = entry;
        }
        else
        {
            PELOGE(limLog(pMac, LOGE, FL("RMC: Hash Insert:" MAC_ADDRESS_STR
                             " alloc failed"), MAC_ADDR_ARRAY(transmitter));)
        }
    }

    return entry;
}

/**
 *  __rmcGroupDeleteHashEntry()
 *
 *FUNCTION:
 * This function is called to delete a RMC group entry
 *
 *LOGIC:
 *
 *ASSUMPTIONS:
 *  Should be called with lkRmcLock held.
 *
 *NOTE:
 * Make sure (for the transmitter role) that the entry is
 * not in the Pending Response queue.
 *
 * @param  transmitter - address of multicast transmitter
 *
 * @return status
 */
static tSirRetStatus
__rmcGroupDeleteHashEntry(tpAniSirGlobal pMac, tSirMacAddr transmitter)
{
    tSirRetStatus status = eSIR_FAILURE;
    tANI_U8 index;
    tLimRmcGroupContext *entry, *prev, **head;

    index = __rmcGroupHashFunction(transmitter);

    head = &pMac->rmcContext.rmcGroupRxHashTable[index];
    entry = *head;
    prev = NULL;

    while (entry)
    {
        if (vos_mem_compare(transmitter, entry->transmitter,
             sizeof(v_MACADDR_t)))
        {
            if (*head == entry)
            {
                *head = entry->next;
            }
            else
            {
                prev->next = entry->next;
            }

            PELOG1(limLog(pMac, LOG1, FL("RMC: Hash Delete: entry %pK "
                         " transmitter " MAC_ADDRESS_STR), entry
                             MAC_ADDR_ARRAY(transmitter));)

            /* free the group entry */
            vos_mem_free(entry);

            status = eSIR_SUCCESS;
            break;
        }

        prev = entry;
        entry = entry->next;
    }

    return status;
}

static void
__rmcGroupDeleteAllEntries(tpAniSirGlobal pMac)
{
    tLimRmcGroupContext *entry, **head;
    int index;

    PELOG1(limLog(pMac, LOG1, FL("RMC: Hash_Delete_All"),);)

    for (index = 0; index < RMC_MCAST_GROUPS_HASH_SIZE; index++)
    {
        head = &pMac->rmcContext.rmcGroupRxHashTable[index];

        entry = *head;

        while (entry)
        {
            *head = entry->next;
            /* free the group entry */
            vos_mem_free(entry);
            entry = *head;
        }
    }
}

static void
__limPostMsgRulerReq ( tpAniSirGlobal pMac,
                        tANI_U8 cmd,
                        tSirMacAddr mcastTransmitter)
{
    tSirMsgQ msg;
    tSirRmcRulerReq *pRulerReq;

    pRulerReq = vos_mem_malloc(sizeof(*pRulerReq));
    if (NULL == pRulerReq)
    {
       limLog(pMac, LOGE, FL("AllocateMemory() failed"));
       return;
    }

    pRulerReq->cmd = cmd;

    vos_mem_copy(pRulerReq->mcastTransmitter, mcastTransmitter,
                 sizeof(tSirMacAddr));

    /* Initialize black list */
    vos_mem_zero(pRulerReq->blacklist, sizeof(pRulerReq->blacklist));

    if (eRMC_SUGGEST_RULER_CMD == cmd)
    {
        /* TODO - Set the black list. */
    }

    msg.type = WDA_RMC_RULER_REQ;
    msg.bodyptr = pRulerReq;
    msg.bodyval = 0;

    MTRACE(macTraceMsgTx(pMac, NO_SESSION, msg.type));
    if (eSIR_SUCCESS != wdaPostCtrlMsg(pMac, &msg))
    {
        vos_mem_free(pRulerReq);
        limLog(pMac, LOGE, FL("wdaPostCtrlMsg() failed"));
    }

    return;
}

static void
__limPostMsgUpdateInd ( tpAniSirGlobal pMac,
                        tANI_U8 indication,
                        tANI_U8 role,
                        tSirMacAddr mcastTransmitter,
                        tSirMacAddr mcastRuler)
{
    tSirMsgQ msg;
    tSirRmcUpdateInd *pUpdateInd;

    pUpdateInd = vos_mem_malloc(sizeof(*pUpdateInd));
    if ( NULL == pUpdateInd )
    {
       limLog(pMac, LOGE, FL("AllocateMemory() failed"));
       return;
    }

    vos_mem_zero(pUpdateInd, sizeof(*pUpdateInd));

    pUpdateInd->indication = indication;
    pUpdateInd->role = role;

    vos_mem_copy(pUpdateInd->mcastTransmitter,
            mcastTransmitter, sizeof(tSirMacAddr));

    vos_mem_copy(pUpdateInd->mcastRuler,
            mcastRuler, sizeof(tSirMacAddr));

    msg.type = WDA_RMC_UPDATE_IND;
    msg.bodyptr = pUpdateInd;
    msg.bodyval = 0;

    MTRACE(macTraceMsgTx(pMac, NO_SESSION, msg.type));
    if (eSIR_SUCCESS != wdaPostCtrlMsg(pMac, &msg))
    {
        vos_mem_free(pUpdateInd);
        limLog(pMac, LOGE, FL("wdaPostCtrlMsg() failed"));
    }

    return;
}

static char *
__limRulerMessageToString(eRmcMessageType msgType)
{
    switch (msgType)
    {
        default:
            return "Invalid";
        case eLIM_RMC_ENABLE_REQ:
            return "RMC_ENABLE_REQ";
        case eLIM_RMC_DISABLE_REQ:
            return "RMC_DISABLE_REQ";
        case eLIM_RMC_RULER_SELECT_RESP:
            return "RMC_RULER_SELECT_RESP";
        case eLIM_RMC_RULER_PICK_NEW:
            return "RMC_RULER_PICK_NEW";
        case eLIM_RMC_OTA_RULER_INFORM_ACK:
            return "RMC_OTA_RULER_INFORM_ACK";
        case eLIM_RMC_OTA_RULER_INFORM_SELECTED:
            return "RMC_OTA_RULER_INFORM_SELECTED";
        case eLIM_RMC_BECOME_RULER_RESP:
            return "RMC_BECOME_RULER_RESP";
        case eLIM_RMC_OTA_RULER_INFORM_CANCELLED:
            return "RMC_OTA_RULER_INFORM_CANCELLED";
    }
}

static char *
__limRulerStateToString(eRmcRulerState state)
{
    switch (state)
    {
        default:
            return "Invalid";
        case eRMC_IS_NOT_A_RULER:
            return "Device Not a Ruler";
        case eRMC_RULER_PENDING:
            return "Pending firmware resp";
        case eRMC_IS_A_RULER:
            return "Device is Ruler";
    }
}

static char *
__limMcastTxStateToString(eRmcMcastTxState state)
{
    switch (state)
    {
        default:
            return "Invalid";
        case eRMC_RULER_NOT_SELECTED:
            return "Not Selected";
        case eRMC_RULER_ENABLE_REQUESTED:
            return "Enable Requested";
        case eRMC_RULER_OTA_REQUEST_SENT:
            return "OTA Request Sent";
        case eRMC_RULER_ACTIVE:
            return "Active";
    }
}

/**
 * __rmcRulerSelectTimerHandler()
 *
 *FUNCTION:
 * This function is called upon timer expiry.
 *
 *
 *ASSUMPTIONS:
 * NA
 *
 *NOTE:
 * Only one entry is processed for every invocation if this routine.
 * This allows us to use a single timer and makes sure we do not
 * timeout a request too early.
 *
 * @param  param - Message corresponding to the timer that expired
 *
 * @return None
 */

void
__rmcRulerSelectTimerHandler(void *pMacGlobal, tANI_U32 param)
{
    tpAniSirGlobal pMac = (tpAniSirGlobal)pMacGlobal;
    tSirMacAddr zeroMacAddr = { 0, 0, 0, 0, 0, 0 };
    tSirRetStatus status;
    tSirRMCInfo RMC;
    tpPESession psessionEntry;
    tANI_U32 cfgValue;

    /*
     * This API relies on a single active IBSS session.
     */
    psessionEntry = limIsIBSSSessionActive(pMac);
    if (NULL == psessionEntry)
    {
        PELOGE(limLog(pMac, LOGE,
             FL("RMC:__rmcRulerSelectTimerHandler:No active IBSS"));)
        return;
    }

    if (wlan_cfgGetInt(pMac, WNI_CFG_RMC_ACTION_PERIOD_FREQUENCY,
                  &cfgValue) != eSIR_SUCCESS)
    {
        /**
         * Could not get Action Period Frequency value
         * from CFG. Log error.
         */
        limLog(pMac, LOGE, FL("could not retrieve ActionPeriodFrequency"));
    }

    cfgValue = SYS_MS_TO_TICKS(cfgValue);

    if (pMac->rmcContext.rmcTimerValInTicks != cfgValue)
    {
        limLog(pMac, LOG1, FL("RMC RulerSelect timer value changed"));
        if (tx_timer_change(&pMac->rmcContext.gRmcRulerSelectTimer,
                 cfgValue, 0) != TX_SUCCESS)
        {
            limLog(pMac, LOGE,
                FL("Unable to change RulerSelect Timer val"));
        }
        pMac->rmcContext.rmcTimerValInTicks = cfgValue;
    }

    /*
     * If we are in the scanning state then we need to return
     * from this function without any further processing
     */
    if (eLIM_HAL_SCANNING_STATE == pMac->lim.gLimHalScanState)
    {
        limLog(pMac, LOG1, FL("In scanning state, can't send action frm"));
        if (tx_timer_activate(&pMac->rmcContext.gRmcRulerSelectTimer) !=
            TX_SUCCESS)
        {
            limLog(pMac, LOGE, FL("In scanning state, "
                                  "couldn't activate RMC RulerSelect timer"));
        }
        return;
    }

    if (!VOS_IS_STATUS_SUCCESS(vos_lock_acquire(&pMac->rmcContext.lkRmcLock)))
    {
        limLog(pMac, LOGE,
             FL("__rmcRulerSelectTimerHandler lock acquire failed"));
        if (tx_timer_activate(&pMac->rmcContext.gRmcRulerSelectTimer)!= TX_SUCCESS)
        {
            limLog(pMac, LOGE, FL("could not activate RMC RulerSelect timer"));
        }
        return;
    }

    vos_mem_copy(&RMC.mcastRuler, &pMac->rmcContext.ruler,
                     sizeof(tSirMacAddr));

    if (VOS_FALSE == vos_mem_compare(&zeroMacAddr,
                            &pMac->rmcContext.ruler, sizeof(tSirMacAddr)))
    {
        limLog(pMac, LOG1,
               FL("RMC Periodic Ruler_Select Ruler " MAC_ADDRESS_STR),
                   MAC_ADDR_ARRAY(pMac->rmcContext.ruler));
        /*
         * Re-arm timer
         */
        if (tx_timer_activate(&pMac->rmcContext.gRmcRulerSelectTimer)!=
            TX_SUCCESS)
        {
            limLog(pMac, LOGE, FL("could not activate RMC Response timer"));
        }

        if (!VOS_IS_STATUS_SUCCESS
                (vos_lock_release(&pMac->rmcContext.lkRmcLock)))
        {
            limLog(pMac, LOGE,
                FL("RMC: __rmcRulerSelectTimerHandler lock release failed"));
        }
    }
    else
    {
        limLog(pMac, LOGE,
               FL("RMC Deactivating timer because no ruler was selected"));

        if (!VOS_IS_STATUS_SUCCESS
                (vos_lock_release(&pMac->rmcContext.lkRmcLock)))
        {
            limLog(pMac, LOGE,
                FL("RMC: __rmcRulerSelectTimerHandler lock release failed"));
        }

        return;
    }

    RMC.dialogToken = 0;
    RMC.action = SIR_MAC_RMC_RULER_INFORM_SELECTED;

    status = limSendRMCActionFrame(pMac,
                          SIR_MAC_RMC_MCAST_ADDRESS,
                          &RMC,
                          psessionEntry);

    if (eSIR_FAILURE == status)
    {
        PELOGE(limLog(pMac, LOGE,
         FL("RMC:__rmcRulerSelectTimerHandler Action frame send failed"));)
    }

    return;
}

static void
__limProcessRMCEnableRequest(tpAniSirGlobal pMac, tANI_U32 *pMsgBuf)
{
    tSirSetRMCReq *setRmcReq = (tSirSetRMCReq *)pMsgBuf;
    tpPESession psessionEntry;

    if (!setRmcReq)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC: Enable:NULL message") );)
        return;
    }

    pMac->rmcContext.rmcEnabled = TRUE;

    /*
     * This API relies on a single active IBSS session.
     */
    psessionEntry = limIsIBSSSessionActive(pMac);
    if (NULL == psessionEntry)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC:Enable RMC request no active IBSS"));)
        pMac->rmcContext.state = eRMC_RULER_NOT_SELECTED;
        return;
    }

    /* Send RULER_REQ to f/w */
    __limPostMsgRulerReq(pMac, eRMC_SUGGEST_RULER_CMD,
                        setRmcReq->mcastTransmitter);

    pMac->rmcContext.state = eRMC_RULER_ENABLE_REQUESTED;
}

static void
__limProcessRMCDisableRequest(tpAniSirGlobal pMac, tANI_U32 *pMsgBuf)
{
    tpPESession psessionEntry;
    tSirRMCInfo RMC;
    tSirSetRMCReq *setRmcReq = (tSirSetRMCReq *)pMsgBuf;
    tSirRetStatus status;
    v_PVOID_t pvosGCtx;
    VOS_STATUS vos_status;
    v_MACADDR_t vosMcastTransmitter;

    pMac->rmcContext.rmcEnabled = FALSE;

    /*
     * This API relies on a single active IBSS session.
     */
    psessionEntry = limIsIBSSSessionActive(pMac);
    if (NULL == psessionEntry)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC: Disable:No active IBSS"));)
        return;
    }

    if (!setRmcReq)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC: Disable:NULL message") );)
        return;
    }

    /* Cancel pending timer */
    tx_timer_deactivate(&pMac->rmcContext.gRmcRulerSelectTimer);

    vosMcastTransmitter.bytes[0] = psessionEntry->selfMacAddr[0];
    vosMcastTransmitter.bytes[1] = psessionEntry->selfMacAddr[1];
    vosMcastTransmitter.bytes[2] = psessionEntry->selfMacAddr[2];
    vosMcastTransmitter.bytes[3] = psessionEntry->selfMacAddr[3];
    vosMcastTransmitter.bytes[4] = psessionEntry->selfMacAddr[4];
    vosMcastTransmitter.bytes[5] = psessionEntry->selfMacAddr[5];

    pvosGCtx = vos_get_global_context(VOS_MODULE_ID_PE, (v_VOID_t *) pMac);
    vos_status = WLANTL_DisableRMC(pvosGCtx, &vosMcastTransmitter);

    if (VOS_STATUS_SUCCESS != vos_status)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC:Disable: TL disable failed"));)
    }

    if (pMac->rmcContext.state == eRMC_RULER_ACTIVE)
    {
        RMC.dialogToken = 0;
        RMC.action = SIR_MAC_RMC_RULER_INFORM_CANCELLED;
        vos_mem_copy(&RMC.mcastRuler, &pMac->rmcContext.ruler, sizeof(tSirMacAddr));

        status = limSendRMCActionFrame(pMac, pMac->rmcContext.ruler,
                             &RMC, psessionEntry);
        if (eSIR_FAILURE == status)
        {
            PELOGE(limLog(pMac, LOGE, FL("RMC:Disable: Action frame send failed"));)
        }

        pMac->rmcContext.state = eRMC_RULER_NOT_SELECTED;
    }

    __limPostMsgUpdateInd(pMac, eRMC_RULER_CANCELLED, eRMC_TRANSMITTER_ROLE,
                         setRmcReq->mcastTransmitter, pMac->rmcContext.ruler);

    vos_mem_zero(pMac->rmcContext.ruler, sizeof(tSirMacAddr));

}

static void
__limProcessRMCRulerSelectResponse(tpAniSirGlobal pMac, tANI_U32 *pMsgBuf)
{
    tSirRmcRulerSelectInd *pRmcRulerSelectInd;
    tpPESession psessionEntry;
    tSirRetStatus status;
    v_PVOID_t pvosGCtx;
    VOS_STATUS vos_status;
    v_MACADDR_t vosMcastTransmitter;
    tSirRMCInfo RMC;

    if (NULL == pMsgBuf)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC: Ruler_Select_Resp:NULL message"));)
        return;
    }

    /*
     * This API relies on a single active IBSS session.
     */
    psessionEntry = limIsIBSSSessionActive(pMac);
    if (NULL == psessionEntry)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC:Ruler_Select_Resp:No active IBSS"));)
        pMac->rmcContext.state = eRMC_RULER_NOT_SELECTED;
        return;
    }

    pRmcRulerSelectInd = (tSirRmcRulerSelectInd *)pMsgBuf;

    if (pMac->rmcContext.state != eRMC_RULER_ENABLE_REQUESTED)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC: Ruler_Select_Resp:Bad state %s"),
                        __limMcastTxStateToString(pMac->rmcContext.state) );)
        return;
    }

    if (pRmcRulerSelectInd->status)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC:Ruler_Select_Resp:FW Status %d"),
                        pRmcRulerSelectInd->status);)
        pMac->rmcContext.state = eRMC_RULER_NOT_SELECTED;
        return;
    }

    if (!VOS_IS_STATUS_SUCCESS(vos_lock_acquire(&pMac->rmcContext.lkRmcLock)))
    {
        limLog(pMac, LOGE, FL("RMC:Ruler_Select_Resp:lock acquire failed"));
        pMac->rmcContext.state = eRMC_RULER_NOT_SELECTED;
        return;
    }

    vos_mem_copy(&pMac->rmcContext.ruler, &pRmcRulerSelectInd->ruler[0],
                 sizeof(tSirMacAddr));

    if (!VOS_IS_STATUS_SUCCESS
            (vos_lock_release(&pMac->rmcContext.lkRmcLock)))
    {
        limLog(pMac, LOGE, FL("RMC: Ruler_Select_Resp: lock release failed"));
    }

    RMC.dialogToken = 0;
    RMC.action = SIR_MAC_RMC_RULER_INFORM_SELECTED;
    vos_mem_copy(&RMC.mcastRuler, &pRmcRulerSelectInd->ruler[0],
                 sizeof(tSirMacAddr));

    PELOG1(limLog(pMac, LOG1, FL("RMC: Ruler_Select :ruler " MAC_ADDRESS_STR),
             MAC_ADDR_ARRAY(pRmcRulerSelectInd->ruler[0]));)

    status = limSendRMCActionFrame(pMac,
                          SIR_MAC_RMC_MCAST_ADDRESS,
                          &RMC,
                          psessionEntry);

    if (eSIR_FAILURE == status)
    {
        PELOGE(limLog(pMac, LOGE,
         FL("RMC: Ruler_Select_Resp: Action send failed"));)
    }

    __limPostMsgUpdateInd(pMac, eRMC_RULER_ACCEPTED, eRMC_TRANSMITTER_ROLE,
                 psessionEntry->selfMacAddr, pMac->rmcContext.ruler);

    vosMcastTransmitter.bytes[0] = psessionEntry->selfMacAddr[0];
    vosMcastTransmitter.bytes[1] = psessionEntry->selfMacAddr[1];
    vosMcastTransmitter.bytes[2] = psessionEntry->selfMacAddr[2];
    vosMcastTransmitter.bytes[3] = psessionEntry->selfMacAddr[3];
    vosMcastTransmitter.bytes[4] = psessionEntry->selfMacAddr[4];
    vosMcastTransmitter.bytes[5] = psessionEntry->selfMacAddr[5];

    /* Enable TL */
    pvosGCtx = vos_get_global_context(VOS_MODULE_ID_PE, (v_VOID_t *) pMac);
    vos_status = WLANTL_EnableRMC(pvosGCtx, &vosMcastTransmitter);

    pMac->rmcContext.state = eRMC_RULER_ACTIVE;

    if (tx_timer_activate(&pMac->rmcContext.gRmcRulerSelectTimer)!= TX_SUCCESS)
    {
        limLog(pMac, LOGE,
         FL("Ruler_Select_Resp:Activate RMC Response timer failed"));
    }
}

static void
__limProcessRMCRulerPickNew(tpAniSirGlobal pMac, tANI_U32 *pMsgBuf)
{
    tSirRmcUpdateInd *pRmcUpdateInd;
    tpPESession psessionEntry;
    tSirRetStatus status;
    tSirRMCInfo RMC;
    v_PVOID_t pvosGCtx;
    VOS_STATUS vos_status;
    v_MACADDR_t vosMcastTransmitter;
    tSirMacAddr zeroMacAddr = { 0, 0, 0, 0, 0, 0 };

    if (NULL == pMsgBuf)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC: Ruler_Pick_New:NULL message"));)
        return;
    }

    /*
     * This API relies on a single active IBSS session.
     */
    psessionEntry = limIsIBSSSessionActive(pMac);
    if (NULL == psessionEntry)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC: Ruler_Pick_New:No active IBSS"));)
        return;
    }

    pvosGCtx = vos_get_global_context(VOS_MODULE_ID_PE, (v_VOID_t *) pMac);

    pRmcUpdateInd = (tSirRmcUpdateInd *)pMsgBuf;

    if (!VOS_IS_STATUS_SUCCESS(vos_lock_acquire(&pMac->rmcContext.lkRmcLock)))
    {
        limLog(pMac, LOGE, FL("RMC:Ruler_Pick_New:lock acquire failed"));
        return;
    }


    /* Fill out Action frame parameters */
    RMC.dialogToken = 0;

    if (VOS_FALSE == vos_mem_compare(&zeroMacAddr,
                        &pRmcUpdateInd->mcastRuler,
                        sizeof(tSirMacAddr)))
    {

        vos_mem_copy(&RMC.mcastRuler, &pRmcUpdateInd->mcastRuler,
                     sizeof(tSirMacAddr));

        RMC.action = SIR_MAC_RMC_RULER_INFORM_CANCELLED;
        status = limSendRMCActionFrame(pMac,
                         pRmcUpdateInd->mcastRuler,
                         &RMC, psessionEntry);
        if (eSIR_FAILURE == status)
        {
            PELOGE(limLog(pMac, LOGE,
                FL("RMC:Ruler_Pick_New: Inform_Cancel Action send failed"));)
            goto done;
        }

        vosMcastTransmitter.bytes[0] = psessionEntry->selfMacAddr[0];
        vosMcastTransmitter.bytes[1] = psessionEntry->selfMacAddr[1];
        vosMcastTransmitter.bytes[2] = psessionEntry->selfMacAddr[2];
        vosMcastTransmitter.bytes[3] = psessionEntry->selfMacAddr[3];
        vosMcastTransmitter.bytes[4] = psessionEntry->selfMacAddr[4];
        vosMcastTransmitter.bytes[5] = psessionEntry->selfMacAddr[5];

        vos_status = WLANTL_DisableRMC(pvosGCtx, &vosMcastTransmitter);

        if (VOS_STATUS_SUCCESS != vos_status)
        {
            PELOGE(limLog(pMac, LOGE,
                 FL("RMC:Ruler_Pick_New: TL disable failed"));)
        }
    }

    vos_mem_copy(pMac->rmcContext.ruler, pRmcUpdateInd->ruler[0],
                 sizeof(tSirMacAddr));

    pMac->rmcContext.state = eRMC_RULER_NOT_SELECTED;

    if (VOS_TRUE == vos_mem_compare(&zeroMacAddr,
                        pMac->rmcContext.ruler,
                        sizeof(tSirMacAddr)))
    {
        PELOGE(limLog(pMac, LOGE,
           FL("RMC:Ruler_Pick_New: No candidate rulers available"));)
        goto done;
    }


    RMC.action = SIR_MAC_RMC_RULER_INFORM_SELECTED;
    vos_mem_copy(&RMC.mcastRuler, &pMac->rmcContext.ruler,
                     sizeof(tSirMacAddr));
    status = limSendRMCActionFrame(pMac, SIR_MAC_RMC_MCAST_ADDRESS,
                         &RMC, psessionEntry);
    if (eSIR_FAILURE == status)
    {
        PELOGE(limLog(pMac, LOGE,
           FL("RMC:Ruler_Pick_New: Inform_Selected Action send failed"));)
        goto done;
    }

    __limPostMsgUpdateInd(pMac, eRMC_RULER_ACCEPTED, eRMC_TRANSMITTER_ROLE,
                         psessionEntry->selfMacAddr, pMac->rmcContext.ruler);

    vosMcastTransmitter.bytes[0] = psessionEntry->selfMacAddr[0];
    vosMcastTransmitter.bytes[1] = psessionEntry->selfMacAddr[1];
    vosMcastTransmitter.bytes[2] = psessionEntry->selfMacAddr[2];
    vosMcastTransmitter.bytes[3] = psessionEntry->selfMacAddr[3];
    vosMcastTransmitter.bytes[4] = psessionEntry->selfMacAddr[4];
    vosMcastTransmitter.bytes[5] = psessionEntry->selfMacAddr[5];

    /* Enable TL */
    vos_status = WLANTL_EnableRMC(pvosGCtx, &vosMcastTransmitter);

    if (VOS_STATUS_SUCCESS != vos_status)
    {
        PELOGE(limLog(pMac, LOGE,
            FL("RMC:Ruler_Pick_New: TL enable failed"));)
        goto done;
    }

    pMac->rmcContext.state = eRMC_RULER_ACTIVE;

    if (tx_timer_activate(&pMac->rmcContext.gRmcRulerSelectTimer)!= TX_SUCCESS)
    {
        limLog(pMac, LOGE,
         FL("Ruler_Pick_New:Activate RMC Response timer failed"));
    }

done:
    if (!VOS_IS_STATUS_SUCCESS(vos_lock_release(&pMac->rmcContext.lkRmcLock)))
    {
        limLog(pMac, LOGE,
            FL("RMC: Ruler_Pick_New: lock release failed"));
    }
}

static void
__limProcessRMCRulerInformSelected(tpAniSirGlobal pMac, tANI_U32 *pMsgBuf)
{
    tpSirMacMgmtHdr pHdr;
    tANI_U8 *pFrameData;
    tANI_U32 frameLen;
    tLimRmcGroupContext *entry;
    tpPESession psessionEntry;
    tSirRetStatus status;

    if (!pMsgBuf)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC: Ruler_Inform:NULL msg"));)
        return;
    }

    /*
     * This API relies on a single active IBSS session.
     */
    psessionEntry = limIsIBSSSessionActive(pMac);
    if (NULL == psessionEntry)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC:Become_Ruler_Resp:No active IBSS"));)
        return;
    }

    /*
     * Get the frame header
     */
    pHdr = WDA_GET_RX_MAC_HEADER((tANI_U8 *)pMsgBuf);

    frameLen = WDA_GET_RX_PAYLOAD_LEN((tANI_U8 *)pMsgBuf);
    if (frameLen < sizeof(tSirMacIbssExtNetworkFrameHdr))
    {
        PELOGE(limLog(pMac, LOGE,
             FL("RMC: Ruler_Inform:Bad length %d "), frameLen);)
        return;
    }

    pFrameData = WDA_GET_RX_MPDU_DATA((tANI_U8 *)pMsgBuf) +
                    sizeof(tSirMacIbssExtNetworkFrameHdr);

    if (!pFrameData)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC: Ruler_Inform:NULL data"));)
        return;
    }

    if (!VOS_IS_STATUS_SUCCESS(vos_lock_acquire(&pMac->rmcContext.lkRmcLock)))
    {
        limLog(pMac, LOGE, FL("RMC:Become_Ruler_Resp:lock acquire failed"));
        return;
    }

    /*
     * Check if this transmitter exists in our database.
     */
    entry = __rmcGroupLookupHashEntry(pMac, pHdr->sa);

    if (VOS_FALSE == vos_mem_compare(pFrameData, psessionEntry->selfMacAddr,
                                     sizeof(tSirMacAddr)))
    {
        if (entry)
        {
            PELOG1(limLog(pMac, LOG1,
                 FL("RMC: Ruler_Inform: Ruler Cancelled"));)

            __limPostMsgUpdateInd(pMac, eRMC_RULER_CANCELLED,
                      eRMC_RULER_ROLE, pHdr->sa, psessionEntry->selfMacAddr);

            /*
             * Delete hash entry for this Group address.
             */
            status = __rmcGroupDeleteHashEntry(pMac, pHdr->sa);
            if (eSIR_FAILURE == status)
            {
                PELOGE(limLog(pMac, LOGE,
                      FL("RMC: Ruler_Inform:hash delete failed"));)
            }
        }
    }
    else
    {
        if (NULL == entry)
        {
            /* Add the transmitter address to the hash */
            entry = __rmcGroupInsertHashEntry(pMac, pHdr->sa);
            if (entry)
            {
                if (entry->isRuler != eRMC_RULER_PENDING)
                {
                    __limPostMsgRulerReq(pMac, eRMC_BECOME_RULER_CMD,
                                         pHdr->sa);
                    entry->isRuler = eRMC_RULER_PENDING;
                }
            }
            else
            {
                PELOGE(limLog(pMac, LOGE,
                         FL("RMC: Ruler_Inform:Hash insert failed"));)
            }

        }
    }

    if (!VOS_IS_STATUS_SUCCESS(vos_lock_release(&pMac->rmcContext.lkRmcLock)))
    {
        limLog(pMac, LOGE,
            FL("RMC: Ruler_Inform: lock release failed"));
    }

}

static void
__limProcessRMCBecomeRulerResp(tpAniSirGlobal pMac, tANI_U32 *pMsgBuf)
{
    tSirRmcBecomeRulerInd *pRmcBecomeRulerInd;
    tLimRmcGroupContext *entry;
    tSirRetStatus status = eSIR_SUCCESS;

    if (NULL == pMsgBuf)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC: Become_Ruler_Resp:NULL message"));)
        return;
    }

    pRmcBecomeRulerInd = (tSirRmcBecomeRulerInd *)pMsgBuf;

    if (!VOS_IS_STATUS_SUCCESS(vos_lock_acquire(&pMac->rmcContext.lkRmcLock)))
    {
        limLog(pMac, LOGE, FL("RMC:Become_Ruler_Resp:lock acquire failed"));
        return;
    }

    /*
     * Find the entry for this Group Address.
     */
    entry = __rmcGroupLookupHashEntry(pMac,
                  pRmcBecomeRulerInd->mcastTransmitter);
    if (NULL == entry)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC: Become_Ruler_Resp: No entry"));)
        goto done;
    }

    if (pRmcBecomeRulerInd->status)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC:Become_Ruler_Resp:FW Status %d"),
                        pRmcBecomeRulerInd->status);)
        status = eSIR_FAILURE;
        goto done;
    }

    if (entry->isRuler != eRMC_RULER_PENDING)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC: Become_Ruler_Resp:Bad state: %s"),
                        __limRulerStateToString(entry->isRuler) );)
        status = eSIR_FAILURE;
        goto done;
    }

    entry->isRuler = eRMC_IS_A_RULER;

done:
    if (eSIR_FAILURE == status)
    {
        status = __rmcGroupDeleteHashEntry(pMac,
                       pRmcBecomeRulerInd->mcastTransmitter);
        if (eSIR_FAILURE == status)
        {
            PELOGE(limLog(pMac, LOGE,
                      FL("RMC: Become_Ruler_Resp:hash delete failed"));)
        }
    }

    if (!VOS_IS_STATUS_SUCCESS(vos_lock_release(&pMac->rmcContext.lkRmcLock)))
    {
        limLog(pMac, LOGE,
            FL("RMC: Become_Ruler_Resp: lock release failed"));
    }

    return;
}

static void
__limProcessRMCRulerInformCancelled(tpAniSirGlobal pMac, tANI_U32 *pMsgBuf)
{
    tpSirMacMgmtHdr pHdr;
    tANI_U8 *pFrameData;
    tANI_U32 frameLen;
    tSirRetStatus status;
    tLimRmcGroupContext *entry;
    tpPESession psessionEntry;

    if (!pMsgBuf)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC: Ruler_Inform_Cancel:NULL msg"));)
        return;
    }

    /*
     * This API relies on a single active IBSS session.
     */
    psessionEntry = limIsIBSSSessionActive(pMac);
    if (NULL == psessionEntry)
    {
        PELOGE(limLog(pMac, LOGE,
             FL("RMC:Ruler_Inform_Cancel:No active IBSS"));)
        return;
    }

    pHdr = WDA_GET_RX_MAC_HEADER((tANI_U8 *)pMsgBuf);

    frameLen = WDA_GET_RX_PAYLOAD_LEN((tANI_U8 *)pMsgBuf);
    if (frameLen < sizeof(tSirMacIbssExtNetworkFrameHdr))
    {
        PELOGE(limLog(pMac, LOGE,
             FL("RMC: Ruler_Inform:Bad length %d "), frameLen);)
        return;
    }

    pFrameData = WDA_GET_RX_MPDU_DATA((tANI_U8 *)pMsgBuf) +
                    sizeof(tSirMacIbssExtNetworkFrameHdr);

    if (!pFrameData)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC: Ruler_Inform_Cancel:NULL data"));)
        return;
    }

    if (!VOS_IS_STATUS_SUCCESS(vos_lock_acquire(&pMac->rmcContext.lkRmcLock)))
    {
        limLog(pMac, LOGE, FL("RMC:Ruler_Inform_Cancel lock acquire failed"));
        return;
    }

    /*
     * Find the entry for this Group Address.
     */
    entry = __rmcGroupLookupHashEntry(pMac, pHdr->sa);
    if (NULL == entry)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC: Ruler_Inform_Cancel: No entry"));)
        goto done;
    }

    __limPostMsgUpdateInd(pMac, eRMC_RULER_CANCELLED,
                     eRMC_RULER_ROLE, pHdr->sa, psessionEntry->selfMacAddr);

    /*
     * Delete hash entry for this Group address.
     */
    status = __rmcGroupDeleteHashEntry(pMac, pHdr->sa);
    if (eSIR_FAILURE == status)
    {
        PELOGE(limLog(pMac, LOGE,
                  FL("RMC: Ruler_Inform_Cancel:hash delete failed"));)
    }

done:
    if (!VOS_IS_STATUS_SUCCESS(vos_lock_release(&pMac->rmcContext.lkRmcLock)))
    {
        limLog(pMac, LOGE,
            FL("RMC: Ruler_Inform_Cancel: lock release failed"));
    }
    return;
}

void
limProcessRMCMessages(tpAniSirGlobal pMac, eRmcMessageType msgType,
                      tANI_U32 *pMsgBuf)
{

    if (pMsgBuf == NULL)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC: Buffer is Pointing to NULL"));)
        return;
    }

    limLog(pMac, LOG1, FL("RMC: limProcessRMCMessages: %s"),
                        __limRulerMessageToString(msgType));

    switch (msgType)
    {
        case eLIM_RMC_ENABLE_REQ:
            __limProcessRMCEnableRequest(pMac, pMsgBuf);
            break;

        case eLIM_RMC_DISABLE_REQ:
            __limProcessRMCDisableRequest(pMac, pMsgBuf);
            break;

        case eLIM_RMC_RULER_SELECT_RESP:
            __limProcessRMCRulerSelectResponse(pMac, pMsgBuf);
            break;

        case eLIM_RMC_RULER_PICK_NEW:
            __limProcessRMCRulerPickNew(pMac, pMsgBuf);
            break;

        case eLIM_RMC_OTA_RULER_INFORM_SELECTED:
            __limProcessRMCRulerInformSelected(pMac, pMsgBuf);
            break;

        case eLIM_RMC_BECOME_RULER_RESP:
            __limProcessRMCBecomeRulerResp(pMac, pMsgBuf);
            break;

        case eLIM_RMC_OTA_RULER_INFORM_CANCELLED:
            __limProcessRMCRulerInformCancelled(pMac, pMsgBuf);
            break;


        default:
            break;
    } // switch (msgType)
    return;
} /*** end limProcessRMCMessages() ***/

void
limRmcInit(tpAniSirGlobal pMac)
{
    tANI_U32 cfgValue;

    if (wlan_cfgGetInt(pMac, WNI_CFG_RMC_ACTION_PERIOD_FREQUENCY,
                  &cfgValue) != eSIR_SUCCESS)
    {
        /**
         * Could not get Action Period Frequency value
         * from CFG. Log error.
         */
        limLog(pMac, LOGP, FL("could not retrieve ActionPeriodFrequency"));
    }

    cfgValue = SYS_MS_TO_TICKS(cfgValue);

    vos_mem_zero(&pMac->rmcContext, sizeof(pMac->rmcContext));

    if (!VOS_IS_STATUS_SUCCESS(vos_lock_init(&pMac->rmcContext.lkRmcLock)))
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC lock init failed!"));)
    }

    if (tx_timer_create(&pMac->rmcContext.gRmcRulerSelectTimer,
                            "RMC RSP TIMEOUT",
                            __rmcRulerSelectTimerHandler,
                            0 /* param */,
                            cfgValue, 0,
                            TX_NO_ACTIVATE) != TX_SUCCESS)
    {
        limLog(pMac, LOGE, FL("could not create RMC response timer"));
    }

    pMac->rmcContext.rmcTimerValInTicks = cfgValue;
}

void
limRmcCleanup(tpAniSirGlobal pMac)
{
    limRmcIbssDelete(pMac);

    if (!VOS_IS_STATUS_SUCCESS(vos_lock_destroy(&pMac->rmcContext.lkRmcLock)))
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC lock destroy failed!"));)
    }

    tx_timer_delete(&pMac->rmcContext.gRmcRulerSelectTimer);
}

void
limRmcTransmitterDelete(tpAniSirGlobal pMac, tSirMacAddr transmitter)
{
    if (!VOS_IS_STATUS_SUCCESS(vos_lock_acquire(&pMac->rmcContext.lkRmcLock)))
    {
        limLog(pMac, LOGE,
             FL("RMC: limRMCTransmitterDelete lock acquire failed"));
        return;
    }

    __rmcGroupDeleteHashEntry(pMac, transmitter);

    if (!VOS_IS_STATUS_SUCCESS(vos_lock_release(&pMac->rmcContext.lkRmcLock)))
    {
        limLog(pMac, LOGE,
            FL("RMC: limRMCTransmitterDelete lock release failed"));
    }

    limLog(pMac, LOG1, FL("RMC: limRmcTransmitterDelete complete"));
}

void
limRmcIbssDelete(tpAniSirGlobal pMac)
{
    tpPESession psessionEntry;
    tSirMacAddr zeroMacAddr = { 0, 0, 0, 0, 0, 0 };

    /*
     * This API relies on a single active IBSS session.
     */
    psessionEntry = limIsIBSSSessionActive(pMac);
    if (NULL == psessionEntry)
    {
        PELOGE(limLog(pMac, LOGE, FL("RMC: limRmcIbssDelete:No active IBSS"));)
        return;
    }

    if (VOS_FALSE == vos_mem_compare(&zeroMacAddr,
                            &pMac->rmcContext.ruler, sizeof(tSirMacAddr)))
    {
        __limPostMsgUpdateInd(pMac, eRMC_RULER_CANCELLED,
                         eRMC_TRANSMITTER_ROLE, psessionEntry->selfMacAddr,
                         pMac->rmcContext.ruler);
    }

    if (!VOS_IS_STATUS_SUCCESS(vos_lock_acquire(&pMac->rmcContext.lkRmcLock)))
    {
        limLog(pMac, LOGE,
             FL("RMC: limRmcIbssDelete lock acquire failed"));
        return;
    }

    /* Cancel pending timer */
    tx_timer_deactivate(&pMac->rmcContext.gRmcRulerSelectTimer);

    /* Delete all entries from Ruler database. */
    __rmcGroupDeleteAllEntries(pMac);

    if (!VOS_IS_STATUS_SUCCESS(vos_lock_release(&pMac->rmcContext.lkRmcLock)))
    {
        limLog(pMac, LOGE,
            FL("RMC: limRmcIbssDelete lock release failed"));
    }

    limLog(pMac, LOG1, FL("RMC: limRmcIbssDelete complete"));
}

void
limRmcDumpStatus(tpAniSirGlobal pMac)
{
    tLimRmcGroupContext *entry;
    int index, count;

    if (!VOS_IS_STATUS_SUCCESS(vos_lock_acquire(&pMac->rmcContext.lkRmcLock)))
    {
        limLog(pMac, LOGE,
             FL("RMC: limRmcDumpStatus lock acquire failed"));
        return;
    }


    limLog(pMac, LOGE, FL(" ----- RMC Transmitter Information ----- \n"));
    limLog(pMac, LOGE,
         FL("   Ruler Address   |  RMC State \n"));

    if (pMac->rmcContext.state != eRMC_RULER_NOT_SELECTED)
    {
        limLog(pMac,LOGE, FL( MAC_ADDRESS_STR " | %s\n"),
                         MAC_ADDR_ARRAY(pMac->rmcContext.ruler),
                        __limMcastTxStateToString(pMac->rmcContext.state));
    }

    limLog( pMac,LOGE, FL(" ----- RMC Ruler Information ----- \n"));
    limLog( pMac,LOGE, FL("  Transmitter Address\n"));

    count = 0;
    for (index = 0; index < RMC_MCAST_GROUPS_HASH_SIZE; index++)
    {
        entry = pMac->rmcContext.rmcGroupRxHashTable[index];

        while (entry)
        {
            count++;
            limLog( pMac,LOGE, FL("%d. " MAC_ADDRESS_STR " \n"),
                    count, MAC_ADDR_ARRAY(entry->transmitter));
            entry = entry->next;
        }
    }

    if (!VOS_IS_STATUS_SUCCESS(vos_lock_release(&pMac->rmcContext.lkRmcLock)))
    {
        limLog(pMac, LOGE,
            FL("RMC: limRmcDumpStatus lock release failed"));
    }

    return;

}

VOS_STATUS
limRmcTriggerRulerSelection(tpAniSirGlobal pMac, tSirMacAddr macAddr)
{
    if ((TRUE == pMac->rmcContext.rmcEnabled) &&
        (eRMC_RULER_NOT_SELECTED == pMac->rmcContext.state))
    {
        limLog(pMac, LOG1,
          FL("Ruler selection trigerred in FW"));

        __limPostMsgRulerReq(pMac, eRMC_SUGGEST_RULER_CMD, macAddr);

        pMac->rmcContext.state = eRMC_RULER_ENABLE_REQUESTED;

        return VOS_STATUS_SUCCESS;
    }
    else
    {
        limLog(pMac, LOG1,
          FL("Could not trigger ruler selection: RMC state %d rmcEnabled %d"),
          pMac->rmcContext.state, pMac->rmcContext.rmcEnabled);

        return VOS_STATUS_E_FAILURE;
    }
}

#endif /* WLAN_FEATURE_RMC */