/*
 * Copyright (c) 2011-2014, 2016-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 schApi.cc contains functions related to the API exposed
 * by scheduler module
 *
 * Author:      Sandesh Goel
 * Date:        02/25/02
 * History:-
 * Date            Modified by    Modification Information
 * --------------------------------------------------------------------
 *
 */
#include "palTypes.h"
#include "aniGlobal.h"
#include "wni_cfg.h"
#include "sirMacProtDef.h"
#include "sirMacPropExts.h"
#include "sirCommon.h"


#include "cfgApi.h"
#include "pmmApi.h"

#include "limApi.h"

#include "schApi.h"
#include "schDebug.h"

#include "schSysParams.h"
#include "limTrace.h"
#include "limTypes.h"
#include "limUtils.h"

#include "wlan_qct_wda.h"

//--------------------------------------------------------------------
//
//                          Static Variables
//
//-------------------------------------------------------------------

// --------------------------------------------------------------------
/**
 * schGetCFPCount
 *
 * FUNCTION:
 * Function used by other Sirius modules to read CFPcount
 *
 * LOGIC:
 *
 * ASSUMPTIONS:
 *
 * NOTE:
 *
 * @param None
 * @return None
 */

tANI_U8
schGetCFPCount(tpAniSirGlobal pMac)
{
    return pMac->sch.schObject.gSchCFPCount;
}

// --------------------------------------------------------------------
/**
 * schGetCFPDurRemaining
 *
 * FUNCTION:
 * Function used by other Sirius modules to read CFPDuration remaining
 *
 * LOGIC:
 *
 * ASSUMPTIONS:
 *
 * NOTE:
 *
 * @param None
 * @return None
 */

tANI_U16
schGetCFPDurRemaining(tpAniSirGlobal pMac)
{
    return pMac->sch.schObject.gSchCFPDurRemaining;
}


// --------------------------------------------------------------------
/**
 * schInitialize
 *
 * FUNCTION:
 * Initialize
 *
 * LOGIC:
 *
 * ASSUMPTIONS:
 *
 * NOTE:
 *
 * @param None
 * @return None
 */

void
schInitialize(tpAniSirGlobal pMac)
{
    pmmInitialize(pMac);
}

// --------------------------------------------------------------------
/**
 * schInitGlobals
 *
 * FUNCTION:
 * Initialize globals
 *
 * LOGIC:
 *
 * ASSUMPTIONS:
 *
 * NOTE:
 *
 * @param None
 * @return None
 */

void
schInitGlobals(tpAniSirGlobal pMac)
{
    pMac->sch.gSchHcfEnabled = false;

    pMac->sch.gSchScanRequested = false;
    pMac->sch.gSchScanReqRcvd = false;

    pMac->sch.gSchGenBeacon = 1;
    pMac->sch.gSchBeaconsSent = 0;
    pMac->sch.gSchBeaconsWritten = 0;
    pMac->sch.gSchBcnParseErrorCnt = 0;
    pMac->sch.gSchBcnIgnored = 0;
    pMac->sch.gSchBBXportRcvCnt = 0;
    pMac->sch.gSchUnknownRcvCnt = 0;
    pMac->sch.gSchBcnRcvCnt = 0;
    pMac->sch.gSchRRRcvCnt = 0;
    pMac->sch.qosNullCnt = 0;
    pMac->sch.numData = 0;
    pMac->sch.numPoll = 0;
    pMac->sch.numCorrupt = 0;
    pMac->sch.numBogusInt = 0;
    pMac->sch.numTxAct0 = 0;
    pMac->sch.rrTimeout = SCH_RR_TIMEOUT;
    pMac->sch.pollPeriod = SCH_POLL_PERIOD;
    pMac->sch.keepAlive = 0;
    pMac->sch.multipleSched = 1;
    pMac->sch.maxPollTimeouts = 20;
    pMac->sch.checkCfbFlagStuck = 0;
}

// --------------------------------------------------------------------
/**
 * schPostMessage
 *
 * FUNCTION:
 * Post the beacon message to the scheduler message queue
 *
 * LOGIC:
 *
 * ASSUMPTIONS:
 *
 * NOTE:
 *
 * @param pMsg pointer to message
 * @return None
 */

tSirRetStatus
schPostMessage(tpAniSirGlobal pMac, tpSirMsgQ pMsg)
{
    schProcessMessage(pMac, pMsg);

    return eSIR_SUCCESS;
}


// ---------------------------------------------------------------------------
/**
 * schSendStartScanRsp
 *
 * FUNCTION:
 *
 * LOGIC:
 *
 * ASSUMPTIONS:
 *
 * NOTE:
 *
 * @param None
 * @return None
 */

void
schSendStartScanRsp(tpAniSirGlobal pMac)
{
    tSirMsgQ        msgQ;
    tANI_U32        retCode;

    PELOG1(schLog(pMac, LOG1, FL("Sending LIM message to go into scan"));)
    msgQ.type = SIR_SCH_START_SCAN_RSP;
    if ((retCode = limPostMsgApi(pMac, &msgQ)) != eSIR_SUCCESS)
        schLog(pMac, LOGE,
               FL("Posting START_SCAN_RSP to LIM failed, reason=%X"), retCode);
}

/**
 * schSendBeaconReq
 *
 * FUNCTION:
 *
 * LOGIC:
 * 1) SCH received SIR_SCH_BEACON_GEN_IND
 * 2) SCH updates TIM IE and other beacon related IE's
 * 3) SCH sends WDA_SEND_BEACON_REQ to HAL. HAL then copies the beacon
 *    template to memory
 *
 * ASSUMPTIONS:
 * Memory allocation is reqd to send this message and SCH allocates memory.
 * The assumption is that HAL will "free" this memory.
 *
 * NOTE:
 *
 * @param pMac global
 *
 * @param beaconPayload
 *
 * @param size - Length of the beacon
 *
 * @return eHalStatus
 */
tSirRetStatus schSendBeaconReq( tpAniSirGlobal pMac, tANI_U8 *beaconPayload, tANI_U16 size, tpPESession psessionEntry)
{
  tSirMsgQ msgQ;
  tpSendbeaconParams beaconParams = NULL;
  tSirRetStatus retCode;

  schLog( pMac, LOG2,
         FL( "Indicating HAL to copy the beacon template [%d bytes] to memory" ),
         size );

  beaconParams = vos_mem_malloc(sizeof(tSendbeaconParams));
  if ( NULL == beaconParams )
      return eSIR_FAILURE;

  msgQ.type = WDA_SEND_BEACON_REQ;

  // No Dialog Token reqd, as a response is not solicited
  msgQ.reserved = 0;

  // Fill in tSendbeaconParams members
  vos_mem_copy(beaconParams->bssId, psessionEntry->bssId, sizeof(psessionEntry->bssId));

  if (LIM_IS_IBSS_ROLE(psessionEntry)) {
      beaconParams->timIeOffset = 0;
  } else {
      beaconParams->timIeOffset = psessionEntry->schBeaconOffsetBegin;
  }

  /* p2pIeOffset should be at-least greater than timIeOffset */
  if ((pMac->sch.schObject.p2pIeOffset != 0) &&
          (pMac->sch.schObject.p2pIeOffset <
           psessionEntry->schBeaconOffsetBegin))
  {
      schLog(pMac, LOGE,FL("Invalid p2pIeOffset:[%d]"),
              pMac->sch.schObject.p2pIeOffset);
      VOS_ASSERT( 0 );
      vos_mem_free(beaconParams);
      return eSIR_FAILURE;
  }
  beaconParams->p2pIeOffset = pMac->sch.schObject.p2pIeOffset;
#ifdef WLAN_SOFTAP_FW_BEACON_TX_PRNT_LOG
  schLog(pMac, LOGE,FL("TimIeOffset:[%d]"),beaconParams->TimIeOffset );
#endif

  beaconParams->beacon = beaconPayload;
  beaconParams->beaconLength = (tANI_U32) size;
  msgQ.bodyptr = beaconParams;
  msgQ.bodyval = 0;

  // Keep a copy of recent beacon frame sent

  // free previous copy of the beacon
  if (psessionEntry->beacon )
  {
    vos_mem_free(psessionEntry->beacon);
  }

  psessionEntry->bcnLen = 0;
  psessionEntry->beacon = NULL;

  psessionEntry->beacon = vos_mem_malloc(size);
  if ( psessionEntry->beacon != NULL )
  {
    vos_mem_copy(psessionEntry->beacon, beaconPayload, size);
    psessionEntry->bcnLen = size;
  }

  MTRACE(macTraceMsgTx(pMac, psessionEntry->peSessionId, msgQ.type));
  if( eSIR_SUCCESS != (retCode = wdaPostCtrlMsg( pMac, &msgQ )))
  {
    schLog( pMac, LOGE,
        FL("Posting SEND_BEACON_REQ to HAL failed, reason=%X"),
        retCode );
  } else
  {
    schLog( pMac, LOG2,
        FL("Successfully posted WDA_SEND_BEACON_REQ to HAL"));

    if (LIM_IS_AP_ROLE(psessionEntry) &&
        pMac->sch.schObject.fBeaconChanged &&
        vos_is_probe_rsp_offload_enabled()) {
        if(eSIR_SUCCESS != (retCode = limSendProbeRspTemplateToHal(pMac,psessionEntry,
                                    &psessionEntry->DefProbeRspIeBitmap[0])))
        {
            /* check whether we have to free any memory */
            schLog(pMac, LOGE, FL("FAILED to send probe response template with retCode %d"), retCode);
        }
    }
  }

  return retCode;
}

tANI_U32 limRemoveP2pIeFromAddIe(tpAniSirGlobal pMac,
                                 tpPESession psessionEntry,
                                 tANI_U8 *addIeWoP2pIe,
                                 tANI_U32 *addnIELenWoP2pIe)
{
    tANI_U32 left = psessionEntry->addIeParams.probeRespDataLen;
    v_U8_t *ptr = psessionEntry->addIeParams.probeRespData_buff;
    v_U8_t elem_id,elem_len;
    tANI_U32 offset=0;
    v_U8_t eid = 0xDD;

    vos_mem_copy(addIeWoP2pIe, ptr, left);
    *addnIELenWoP2pIe = left;

    if (addIeWoP2pIe != NULL)
    {
        while (left >= 2)
        {
            elem_id  = ptr[0];
            elem_len = ptr[1];
            left -= 2;
            if(elem_len > left)
            {
                schLog(pMac, LOGE, FL("Invalid IEs"));
                return eSIR_FAILURE;
            }
            if ((elem_id == eid) &&
                (vos_mem_compare( &ptr[2], "\x50\x6f\x9a\x09", 4)==VOS_TRUE))
            {
                left -= elem_len;
                ptr += (elem_len + 2);
                vos_mem_copy(&addIeWoP2pIe[offset], ptr, left);
                *addnIELenWoP2pIe -= (2 + elem_len);
            }
            else
            {
                left -= elem_len;
                ptr += (elem_len + 2);
                offset += 2 + elem_len;
            }
        }
    }
    return eSIR_SUCCESS;
}

tANI_U32 limSendProbeRspTemplateToHal(tpAniSirGlobal pMac,tpPESession psessionEntry
                                  ,tANI_U32* IeBitmap)
{
    tSirMsgQ  msgQ;
    tANI_U8 *pFrame2Hal = psessionEntry->pSchProbeRspTemplate;
    tpSendProbeRespParams pprobeRespParams=NULL;
    tANI_U32  retCode = eSIR_FAILURE;
    tANI_U32             nPayload, nBytes = 0, nStatus;
    tpSirMacMgmtHdr      pMacHdr;
    tANI_U32             addnIEPresent = VOS_FALSE;
    tSirRetStatus        nSirStatus;
    tANI_U8              *addIE = NULL;
    tANI_U8              *addIeWoP2pIe = NULL;
    tANI_U32             addnIELenWoP2pIe = 0;
    tANI_U32             retStatus;
    tDot11fIEExtCap extracted_extcap;
    bool extcap_present = false;
    tDot11fProbeResponse *prb_rsp_frm;
    tSirRetStatus status;
    uint16_t addn_ielen = 0;

    //Check if probe response IE is present or not
    addnIEPresent = (psessionEntry->addIeParams.probeRespDataLen != 0);
    if (addnIEPresent)
    {
        /*
         * probe response template should not have P2P IE.
         * In case probe request has P2P IE or WPS IE, the
         * probe request will be forwarded to the Host and
         * Host will send the probe response. In other cases
         * FW will send the probe response. So, if the template
         * has P2P IE, the probe response sent to non P2P devices
         * by the FW, may also have P2P IE which will fail
         * P2P cert case 6.1.3
         */
        addIeWoP2pIe = vos_mem_malloc(psessionEntry->addIeParams.probeRespDataLen);
        if ( NULL == addIeWoP2pIe )
        {
            schLog(pMac, LOGE, FL("FAILED to alloc memory when removing P2P IE"));
            return eSIR_FAILURE;
        }

        retStatus = limRemoveP2pIeFromAddIe(pMac, psessionEntry,
                                            addIeWoP2pIe, &addnIELenWoP2pIe);
        if (retStatus != eSIR_SUCCESS)
        {
            vos_mem_free(addIeWoP2pIe);
            return eSIR_FAILURE;
        }

        //Probe rsp IE available
        /*need to check the data length*/
        addIE = vos_mem_malloc(addnIELenWoP2pIe);

        if ( NULL == addIE )
        {
             schLog(pMac, LOGE,
                 FL("Unable to get WNI_CFG_PROBE_RSP_ADDNIE_DATA1 length"));
             vos_mem_free(addIeWoP2pIe);
             return retCode;
        }
        addn_ielen = addnIELenWoP2pIe;

        if (addn_ielen <= WNI_CFG_PROBE_RSP_ADDNIE_DATA1_LEN && addn_ielen &&
                                 (nBytes + addn_ielen) <= SIR_MAX_PACKET_SIZE)
        {
            vos_mem_copy(addIE, addIeWoP2pIe, addnIELenWoP2pIe);
        }
        vos_mem_free(addIeWoP2pIe);

        vos_mem_set((uint8_t *)&extracted_extcap, sizeof(tDot11fIEExtCap), 0);
        status = lim_strip_extcap_update_struct(pMac, addIE, &addn_ielen,
                                                   &extracted_extcap);
        if (eSIR_SUCCESS != status) {
            limLog(pMac, LOG1, FL("extcap not extracted"));
        } else {
            extcap_present = true;
        }

    }

    if (addnIEPresent)
    {
        if ((nBytes + addn_ielen) <= SIR_MAX_PACKET_SIZE )
            nBytes += addn_ielen;
        else
            addnIEPresent = false; //Dont include the IE.
    }

    /* merge extcap IE */
    prb_rsp_frm = &psessionEntry->probeRespFrame;
    if (extcap_present)
        lim_merge_extcap_struct(&prb_rsp_frm->ExtCap, &extracted_extcap, true);

    nStatus = dot11fGetPackedProbeResponseSize(pMac, &psessionEntry->probeRespFrame, &nPayload);
    if (DOT11F_FAILED(nStatus))
    {
        schLog(pMac, LOGE,
             FL("Failed to calculate the packed size for a Probe Response (0x%08x)."),
             nStatus);
        /* We'll fall back on the worst case scenario: */
        nPayload = sizeof(tDot11fProbeResponse);
    }
    else if (DOT11F_WARNED(nStatus))
    {
        schLog(pMac, LOGE,
             FL("There were warnings while calculating the packed size for a Probe Response (0x%08x)."),
             nStatus);
    }

    nBytes += nPayload + sizeof(tSirMacMgmtHdr);

    // Paranoia:
    vos_mem_set(pFrame2Hal, nBytes, 0);

    // Next, we fill out the buffer descriptor:
    nSirStatus = limPopulateMacHeader( pMac, pFrame2Hal, SIR_MAC_MGMT_FRAME,
                                SIR_MAC_MGMT_PROBE_RSP, psessionEntry->selfMacAddr,psessionEntry->selfMacAddr);

    if ( eSIR_SUCCESS != nSirStatus )
    {
        schLog( pMac, LOGE, FL("Failed to populate the buffer descrip"
                               "tor for a Probe Response (%d)."),
                nSirStatus );

        vos_mem_free(addIE);
        return retCode;
    }

    pMacHdr = ( tpSirMacMgmtHdr ) pFrame2Hal;

    sirCopyMacAddr(pMacHdr->bssId,psessionEntry->bssId);

    // That done, pack the Probe Response:
    nStatus = dot11fPackProbeResponse( pMac, &psessionEntry->probeRespFrame, pFrame2Hal + sizeof(tSirMacMgmtHdr),
                                       nPayload, &nPayload );

    if ( DOT11F_FAILED( nStatus ) )
    {
        schLog( pMac, LOGE, FL("Failed to pack a Probe Response (0x%08x)."),
                nStatus );

        vos_mem_free(addIE);
        return retCode;                 // allocated!
    }
    else if ( DOT11F_WARNED( nStatus ) )
    {
        schLog( pMac, LOGE, FL("There were warnings while packing a P"
                               "robe Response (0x%08x)."), nStatus );
    }

    if (addnIEPresent)
        vos_mem_copy(&pFrame2Hal[nBytes - addn_ielen], &addIE[0], addn_ielen);

    /* free the allocated Memory */
    vos_mem_free(addIE);

    pprobeRespParams = vos_mem_malloc(sizeof( tSendProbeRespParams ));
    if ( NULL == pprobeRespParams )
    {
        schLog( pMac, LOGE, FL("limSendProbeRspTemplateToHal: HAL probe response params malloc failed for bytes %d"), nBytes );
    }
    else
    {
        sirCopyMacAddr( pprobeRespParams->bssId, psessionEntry->bssId);
        pprobeRespParams->pProbeRespTemplate   = pFrame2Hal;
        pprobeRespParams->probeRespTemplateLen = nBytes;
        vos_mem_copy(pprobeRespParams->ucProxyProbeReqValidIEBmap,IeBitmap,(sizeof(tANI_U32) * 8));
        msgQ.type     = WDA_SEND_PROBE_RSP_TMPL;
        msgQ.reserved = 0;
        msgQ.bodyptr  = pprobeRespParams;
        msgQ.bodyval  = 0;

        if( eSIR_SUCCESS != (retCode = wdaPostCtrlMsg( pMac, &msgQ )))
        {
            /* free the allocated Memory */
            schLog( pMac,LOGE, FL("limSendProbeRspTemplateToHal: FAIL bytes %d retcode[%X]"), nBytes, retCode );
            vos_mem_free(pprobeRespParams);
        }
        else
        {
            schLog( pMac,LOG1, FL("limSendProbeRspTemplateToHal: Probe response template msg posted to HAL of bytes %d"),nBytes );
        }
    }

    return retCode;
}

/**
 * schGenTimingAdvertFrame() - Generate the TA frame and populate the buffer
 * @pMac: the global MAC context
 * @self_addr: the self MAC address
 * @buf: the buffer that will contain the frame
 * @timestamp_offset: return for the offset of the timestamp field
 * @time_value_offset: return for the time_value field in the TA IE
 *
 * Return: the length of the buffer.
 */
int schGenTimingAdvertFrame(tpAniSirGlobal mac_ctx, tSirMacAddr self_addr,
    uint8_t **buf, uint32_t *timestamp_offset, uint32_t *time_value_offset)
{
    tDot11fTimingAdvertisementFrame frame;
    uint32_t payload_size, buf_size;
    int status;
    v_MACADDR_t wildcard_bssid = {
        {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
    };

    vos_mem_zero((uint8_t*)&frame, sizeof(tDot11fTimingAdvertisementFrame));

    /* Populate the TA fields */
    status = PopulateDot11fTimingAdvertFrame(mac_ctx, &frame);
    if (status) {
      schLog(mac_ctx, LOGE, FL("Error populating TA frame %x"), status);
      return status;
    }

    status = dot11fGetPackedTimingAdvertisementFrameSize(mac_ctx, &frame,
        &payload_size);
    if (DOT11F_FAILED(status)) {
        schLog(mac_ctx, LOGE, FL("Error getting packed frame size %x"), status);
        return status;
    } else if (DOT11F_WARNED(status)) {
        schLog(mac_ctx, LOGW, FL("Warning getting packed frame size"));
    }

    buf_size = sizeof(tSirMacMgmtHdr) + payload_size;
    *buf = vos_mem_malloc(buf_size);
    if (*buf == NULL) {
        schLog(mac_ctx, LOGE, FL("Cannot allocate memory"));
        return eSIR_FAILURE;
    }
    vos_mem_zero(*buf, buf_size);

    payload_size = 0;
    status = dot11fPackTimingAdvertisementFrame(mac_ctx, &frame,
        *buf + sizeof(tSirMacMgmtHdr), buf_size - sizeof(tSirMacMgmtHdr),
        &payload_size);
    schLog(mac_ctx, LOGE, FL("TA payload size2 = %d"), payload_size);
    if (DOT11F_FAILED(status)) {
        schLog(mac_ctx, LOGE, FL("Error packing frame %x"), status);
        goto fail;
    } else if (DOT11F_WARNED(status)) {
        schLog(mac_ctx, LOGE, FL("Warning packing frame"));
    }

    limPopulateMacHeader(mac_ctx, *buf, SIR_MAC_MGMT_FRAME,
        SIR_MAC_MGMT_TIME_ADVERT, wildcard_bssid.bytes, self_addr);

    /* The timestamp field is right after the header */
    *timestamp_offset = sizeof(tSirMacMgmtHdr);

    *time_value_offset = sizeof(tSirMacMgmtHdr) + sizeof(tDot11fFfTimeStamp) +
        sizeof(tDot11fFfCapabilities);

    /* Add the Country IE length */
    dot11fGetPackedIECountry(mac_ctx, &frame.Country, time_value_offset);
    /* Add 2 for Country IE EID and Length fields */
    *time_value_offset += 2;

    /* Add the PowerConstraint IE size */
    if (frame.Country.present == 1)
        *time_value_offset += 3;

    /* Add the offset inside TA IE */
    *time_value_offset += 3;

    return payload_size + sizeof(tSirMacMgmtHdr);

fail:
    if (*buf)
        vos_mem_free(*buf);
    return status;
}