/*
* Copyright (c) 2017-2018, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*/

//! \file     mhw_vdbox_huc_generic.h
//! \brief    MHW interface for constructing HUC commands for the Vdbox engine
//! \details  Impelements shared Vdbox HUC command construction functions across all platforms as templates
//!

#ifndef _MHW_VDBOX_HUC_GENERIC_H_
#define _MHW_VDBOX_HUC_GENERIC_H_

#include "mhw_vdbox_huc_interface.h"

//!  MHW Vdbox Huc generic interface
/*!
This class defines the shared Huc command construction functions across all platforms as templates
*/
template <class THucCmds, class TMiCmds>
class MhwVdboxHucInterfaceGeneric : public MhwVdboxHucInterface
{
protected:
    #define PATCH_LIST_COMMAND(x)  (x##_NUMBER_OF_ADDRESSES)
    //!
    //! \enum     CommandsNumberOfAddresses
    //! \brief    Commands number of addresses
    //!
    enum CommandsNumberOfAddresses
    {
        MI_STORE_DATA_IMM_CMD_NUMBER_OF_ADDRESSES                  =  1, //  2 DW for  1 address field
        MI_FLUSH_DW_CMD_NUMBER_OF_ADDRESSES                        =  1, //  2 DW for  1 address field
        MI_CONDITIONAL_BATCH_BUFFER_END_CMD_NUMBER_OF_ADDRESSES    =  1, //  2 DW for  1 address field
        MI_STORE_REGISTER_MEM_CMD_NUMBER_OF_ADDRESSES              =  1, //  2 DW for  1 address field
        MI_COPY_MEM_MEM_CMD_NUMBER_OF_ADDRESSES                    =  2, //  4 DW for  2 address fields

        VD_PIPELINE_FLUSH_CMD_NUMBER_OF_ADDRESSES                  =  0,  //  0 DW for  0 address fields

        HUC_PIPE_MODE_SELECT_CMD_NUMBER_OF_ADDRESSES               =  0, //  0 DW for    address fields
        HUC_IMEM_STATE_CMD_NUMBER_OF_ADDRESSES                     =  0, //  0 DW for    address fields
        HUC_DMEM_STATE_CMD_NUMBER_OF_ADDRESSES                     =  2, //  3 DW for  2 address fields
        HUC_VIRTUAL_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES             = 16, // 32 DW for 16 address fields
        HUC_IND_OBJ_BASE_ADDR_STATE_CMD_NUMBER_OF_ADDRESSES        =  4, //  8 DW for  4 address fields
        HUC_STREAM_OBJECT_CMD_NUMBER_OF_ADDRESSES                  =  0, //  0 DW for    address fields
        HUC_START_CMD_NUMBER_OF_ADDRESSES                          =  0, //  0 DW for    address fields
    };

    //!
    //! \brief    Constructor
    //!
    MhwVdboxHucInterfaceGeneric(
        PMOS_INTERFACE osInterface,
        MhwMiInterface *miInterface,
        MhwCpInterface *cpInterface) :
        MhwVdboxHucInterface(osInterface, miInterface, cpInterface)
    {
        MHW_FUNCTION_ENTER;
    }

    //!
    //! \brief   Destructor
    //!
    virtual ~MhwVdboxHucInterfaceGeneric() {}

protected:
    MOS_STATUS GetHucStateCommandSize(
        uint32_t                        mode,
        uint32_t                        *commandsSize,
        uint32_t                        *patchListSize,
        PMHW_VDBOX_STATE_CMDSIZE_PARAMS params)
    {
        MHW_FUNCTION_ENTER;

        uint32_t maxSize = 0;
        uint32_t patchListMaxSize = 0;
        uint32_t standard = CodecHal_GetStandardFromMode(mode);
        uint32_t numSlices = 1;
        uint32_t numStoreDataImm = 1;
        uint32_t numStoreReg = 1;

        MHW_MI_CHK_NULL(commandsSize);
        MHW_MI_CHK_NULL(patchListSize);
        MHW_MI_CHK_NULL(params);

        if(params->uNumStoreDataImm)
        {
            numStoreDataImm = params->uNumStoreDataImm;
        }
        if(params->uNumStoreReg)
        {
            numStoreReg = params->uNumStoreReg;
        }

        if (mode == CODECHAL_DECODE_MODE_HEVCVLD && params->bShortFormat)
        {
            numSlices       = CODECHAL_HEVC_MAX_NUM_SLICES_LVL_6;
            numStoreDataImm = 2;
            numStoreReg     = 2;

            maxSize +=
                2 * TMiCmds::MI_CONDITIONAL_BATCH_BUFFER_END_CMD::byteSize;

            patchListMaxSize +=
                2 * PATCH_LIST_COMMAND(MI_CONDITIONAL_BATCH_BUFFER_END_CMD);
        }
        else if (standard == CODECHAL_CENC)
        {
            numStoreDataImm = 3;
            numStoreReg     = 3;

            maxSize +=
                TMiCmds::MI_FLUSH_DW_CMD::byteSize * 2 +
                TMiCmds::MI_BATCH_BUFFER_END_CMD::byteSize;

            patchListMaxSize +=
                PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD) * 2;

        }
        else if (mode == CODECHAL_ENCODE_MODE_VP9)
        {
            // for huc status 2 register and semaphore signal and reset
            numStoreDataImm = 3;

            maxSize +=
                TMiCmds::MI_BATCH_BUFFER_END_CMD::byteSize +
                TMiCmds::MI_FLUSH_DW_CMD::byteSize;

            patchListMaxSize +=
                PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD);
        }
        else if (mode == CODECHAL_ENCODE_MODE_AVC)
        {
            numStoreDataImm = 2;
            numStoreReg     = 2;

            maxSize +=
                2 * TMiCmds::MI_CONDITIONAL_BATCH_BUFFER_END_CMD::byteSize;

            patchListMaxSize +=
                2 * PATCH_LIST_COMMAND(MI_CONDITIONAL_BATCH_BUFFER_END_CMD);
        }

        maxSize +=
            THucCmds::HUC_PIPE_MODE_SELECT_CMD::byteSize +
            THucCmds::HUC_IMEM_STATE_CMD::byteSize +
            THucCmds::HUC_DMEM_STATE_CMD::byteSize +
            THucCmds::HUC_VIRTUAL_ADDR_STATE_CMD::byteSize +
            THucCmds::HUC_IND_OBJ_BASE_ADDR_STATE_CMD::byteSize +
            numSlices       * THucCmds::HUC_STREAM_OBJECT_CMD::byteSize +
            numSlices       * THucCmds::HUC_START_CMD::byteSize +
            numStoreDataImm * TMiCmds::MI_STORE_DATA_IMM_CMD::byteSize +
            numStoreReg     * TMiCmds::MI_STORE_REGISTER_MEM_CMD::byteSize;

        if(params->uNumMfxWait)
        {
            maxSize +=
                params->uNumMfxWait * TMiCmds::MFX_WAIT_CMD::byteSize;
        }

        patchListMaxSize +=
            PATCH_LIST_COMMAND(HUC_PIPE_MODE_SELECT_CMD) +
            PATCH_LIST_COMMAND(HUC_IMEM_STATE_CMD) +
            PATCH_LIST_COMMAND(HUC_DMEM_STATE_CMD) +
            PATCH_LIST_COMMAND(HUC_VIRTUAL_ADDR_STATE_CMD) +
            PATCH_LIST_COMMAND(HUC_IND_OBJ_BASE_ADDR_STATE_CMD) +
            numSlices       * PATCH_LIST_COMMAND(HUC_STREAM_OBJECT_CMD) +
            numSlices       * PATCH_LIST_COMMAND(HUC_START_CMD) +
            numStoreDataImm * PATCH_LIST_COMMAND(MI_STORE_DATA_IMM_CMD) +
            numStoreReg     * PATCH_LIST_COMMAND(MI_STORE_REGISTER_MEM_CMD);

        if(params->uNumAddConBBEnd)
        {
            maxSize +=
                params->uNumAddConBBEnd * TMiCmds::MI_CONDITIONAL_BATCH_BUFFER_END_CMD::byteSize;

            patchListMaxSize +=
                params->uNumAddConBBEnd * PATCH_LIST_COMMAND(MI_CONDITIONAL_BATCH_BUFFER_END_CMD);
        }
        if(params->uNumMiCopy)
        {
            maxSize +=
                params->uNumMiCopy * TMiCmds::MI_COPY_MEM_MEM_CMD::byteSize;

            patchListMaxSize +=
                params->uNumMiCopy * PATCH_LIST_COMMAND(MI_COPY_MEM_MEM_CMD);
        }
        if(params->uNumMiFlush)
        {
            maxSize +=
                params->uNumMiFlush * TMiCmds::MI_FLUSH_DW_CMD::byteSize;

            patchListMaxSize +=
                params->uNumMiFlush * PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD);
        }

        if (params->bHucDummyStream || params->bPerformHucStreamOut)
        {
            uint32_t dummyTimes = params->bPerformHucStreamOut ? 2: 1;
            for (uint32_t i = 0; i < dummyTimes; i++)
            {
                maxSize +=
                    THucCmds::HUC_PIPE_MODE_SELECT_CMD::byteSize +
                    THucCmds::HUC_IMEM_STATE_CMD::byteSize +
                    THucCmds::HUC_DMEM_STATE_CMD::byteSize +
                    THucCmds::HUC_VIRTUAL_ADDR_STATE_CMD::byteSize +
                    THucCmds::HUC_IND_OBJ_BASE_ADDR_STATE_CMD::byteSize +
                    THucCmds::HUC_STREAM_OBJECT_CMD::byteSize +
                    THucCmds::HUC_START_CMD::byteSize +
                    TMiCmds::MI_FLUSH_DW_CMD::byteSize;

                patchListMaxSize +=
                    PATCH_LIST_COMMAND(HUC_PIPE_MODE_SELECT_CMD) +
                    PATCH_LIST_COMMAND(HUC_IMEM_STATE_CMD) +
                    PATCH_LIST_COMMAND(HUC_DMEM_STATE_CMD) +
                    PATCH_LIST_COMMAND(HUC_VIRTUAL_ADDR_STATE_CMD) +
                    PATCH_LIST_COMMAND(HUC_IND_OBJ_BASE_ADDR_STATE_CMD) +
                    PATCH_LIST_COMMAND(HUC_STREAM_OBJECT_CMD) +
                    PATCH_LIST_COMMAND(HUC_START_CMD) +
                    PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD);
            }
            if (params->bPerformHucStreamOut)
            {
                maxSize +=
                    THucCmds::HUC_PIPE_MODE_SELECT_CMD::byteSize +
                    THucCmds::HUC_IND_OBJ_BASE_ADDR_STATE_CMD::byteSize +
                    THucCmds::HUC_STREAM_OBJECT_CMD::byteSize +
                    4 * TMiCmds::MI_FLUSH_DW_CMD::byteSize;

                patchListMaxSize +=
                    PATCH_LIST_COMMAND(HUC_PIPE_MODE_SELECT_CMD) +
                    PATCH_LIST_COMMAND(HUC_IND_OBJ_BASE_ADDR_STATE_CMD) +
                    PATCH_LIST_COMMAND(HUC_STREAM_OBJECT_CMD) +
                    4 * PATCH_LIST_COMMAND(MI_FLUSH_DW_CMD);
            }
        }

        *commandsSize  = maxSize;
        *patchListSize = patchListMaxSize;

        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS GetHucPrimitiveCommandSize(
        uint32_t                        mode,
        uint32_t                        *commandsSize,
        uint32_t                        *patchListSize)
    {
        MOS_STATUS eStatus = MOS_STATUS_SUCCESS;

        MHW_FUNCTION_ENTER;

        uint32_t            maxSize = 0;
        uint32_t            patchListMaxSize = 0;

        // Hal will handling the multiplication of cmd size instead of MHW

        *commandsSize = maxSize;
        *patchListSize = patchListMaxSize;

        return eStatus;
    }

    MOS_STATUS AddHucPipeModeSelectCmd(
        MOS_COMMAND_BUFFER                  *cmdBuffer,
        MHW_VDBOX_PIPE_MODE_SELECT_PARAMS   *params)
    {
        MHW_MI_CHK_NULL(cmdBuffer);
        MHW_MI_CHK_NULL(params);

        typename THucCmds::HUC_PIPE_MODE_SELECT_CMD cmd;

        if (!params->disableProtectionSetting)
        {
            MHW_MI_CHK_STATUS(m_cpInterface->SetProtectionSettingsForHucPipeModeSelect((uint32_t*)&cmd));
        }

        cmd.DW1.IndirectStreamOutEnable = params->bStreamOutEnabled;
        cmd.DW2.MediaSoftResetCounterPer1000Clocks = params->dwMediaSoftResetCounterValue;

        MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize));

        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS AddHucImemStateCmd(
        MOS_COMMAND_BUFFER                  *cmdBuffer,
        MHW_VDBOX_HUC_IMEM_STATE_PARAMS     *params)
    {
        MHW_MI_CHK_NULL(cmdBuffer);
        MHW_MI_CHK_NULL(params);

        typename THucCmds::HUC_IMEM_STATE_CMD cmd;

        cmd.DW4.HucFirmwareDescriptor = params->dwKernelDescriptor;

        MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize));

        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS AddHucDmemStateCmd(
        MOS_COMMAND_BUFFER                  *cmdBuffer,
        MHW_VDBOX_HUC_DMEM_STATE_PARAMS     *params)
    {

        MHW_MI_CHK_NULL(cmdBuffer);
        MHW_MI_CHK_NULL(params);

        MHW_RESOURCE_PARAMS                         resourceParams;
        MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
        resourceParams.dwLsbNum = MHW_VDBOX_HUC_GENERAL_STATE_SHIFT;
        resourceParams.HwCommandType = MOS_HUC_DMEM;

        typename THucCmds::HUC_DMEM_STATE_CMD cmd;

        if (params->presHucDataSource)
        {
            resourceParams.presResource = params->presHucDataSource;
            resourceParams.dwOffset = 0;
            resourceParams.pdwCmd = (cmd.HucDataSourceBaseAddress.DW0_1.Value);
            resourceParams.dwLocationInCmd = 1;
            resourceParams.bIsWritable = false;

            MHW_MI_CHK_STATUS(AddResourceToCmd(
                m_osInterface,
                cmdBuffer,
                &resourceParams));

            // set HuC data destination address
            cmd.DW4.HucDataDestinationBaseAddress = params->dwDmemOffset >> MHW_VDBOX_HUC_GENERAL_STATE_SHIFT;

            // set data length
            cmd.DW5.HucDataLength = params->dwDataLength >> MHW_VDBOX_HUC_GENERAL_STATE_SHIFT;
        }

        MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize));

        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS AddHucVirtualAddrStateCmd(
        MOS_COMMAND_BUFFER                  *cmdBuffer,
        MHW_VDBOX_HUC_VIRTUAL_ADDR_PARAMS   *params)
    {
        MHW_MI_CHK_NULL(cmdBuffer);
        MHW_MI_CHK_NULL(params);

        MHW_RESOURCE_PARAMS                                     resourceParams;

        // set up surface 0~15
        MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
        resourceParams.dwLsbNum = MHW_VDBOX_HUC_UPPER_BOUND_STATE_SHIFT;
        resourceParams.HwCommandType = MOS_HUC_VIRTUAL_ADDR;

        typename THucCmds::HUC_VIRTUAL_ADDR_STATE_CMD cmd;

        for (int i = 0; i < 16; i++)
        {
            if (params->regionParams[i].presRegion)
            {
                cmd.HucVirtualAddressRegion[i].HucSurfaceVirtualaddrregion015.DW0.Value |=
                    m_cacheabilitySettings[MOS_CODEC_RESOURCE_USAGE_HUC_VIRTUAL_ADDR_REGION_BUFFER_CODEC].Value;
                resourceParams.presResource = params->regionParams[i].presRegion;
                resourceParams.dwOffset = params->regionParams[i].dwOffset;
                resourceParams.bIsWritable = params->regionParams[i].isWritable;
                resourceParams.pdwCmd = cmd.HucVirtualAddressRegion[i].HucSurfaceBaseAddressVirtualaddrregion015.DW0_1.Value;
                resourceParams.dwLocationInCmd = 1 + (i * 3);

                MHW_MI_CHK_STATUS(AddResourceToCmd(
                    m_osInterface,
                    cmdBuffer,
                    &resourceParams));
            }
        }

        MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize));

        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS AddHucIndObjBaseAddrStateCmd(
        MOS_COMMAND_BUFFER                  *cmdBuffer,
        MHW_VDBOX_IND_OBJ_BASE_ADDR_PARAMS  *params)
    {
        MHW_MI_CHK_NULL(cmdBuffer);
        MHW_MI_CHK_NULL(params);

        MHW_RESOURCE_PARAMS                                     resourceParams;

        // base address of the bit-stream buffer
        MOS_ZeroMemory(&resourceParams, sizeof(resourceParams));
        resourceParams.dwLsbNum = MHW_VDBOX_HUC_UPPER_BOUND_STATE_SHIFT;
        resourceParams.dwUpperBoundLocationOffsetFromCmd = 3;
        resourceParams.HwCommandType = MOS_HUC_IND_OBJ_BASE_ADDR;

        typename THucCmds::HUC_IND_OBJ_BASE_ADDR_STATE_CMD cmd;

        if (params->presDataBuffer)
        {
            resourceParams.presResource = params->presDataBuffer;
            resourceParams.dwOffset = params->dwDataOffset;
            resourceParams.pdwCmd = cmd.HucIndirectStreamInObjectbaseAddress.DW0_1.Value;
            resourceParams.dwLocationInCmd = 1;
            resourceParams.bIsWritable = false;
            resourceParams.dwSize = params->dwDataSize;

            MHW_MI_CHK_STATUS(AddResourceToCmd(
                m_osInterface,
                cmdBuffer,
                &resourceParams));
        }

        if (params->presStreamOutObjectBuffer)
        {
            // base address of the stream out buffer
            resourceParams.presResource = params->presStreamOutObjectBuffer;
            resourceParams.dwOffset = params->dwStreamOutObjectOffset;
            resourceParams.pdwCmd = cmd.HucIndirectStreamOutObjectbaseAddress.DW0_1.Value;
            resourceParams.dwLocationInCmd = 6;
            resourceParams.bIsWritable = true;
            resourceParams.dwSize = params->dwStreamOutObjectSize;

            MHW_MI_CHK_STATUS(AddResourceToCmd(
                m_osInterface,
                cmdBuffer,
                &resourceParams));
        }

        MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize));

        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS AddHucStreamObjectCmd(
        MOS_COMMAND_BUFFER                  *cmdBuffer,
        MHW_VDBOX_HUC_STREAM_OBJ_PARAMS     *params)
    {
        MHW_MI_CHK_NULL(cmdBuffer);
        MHW_MI_CHK_NULL(params);

        typename THucCmds::HUC_STREAM_OBJECT_CMD cmd;

        cmd.DW1.IndirectStreamInDataLength = params->dwIndStreamInLength;
        cmd.DW2.IndirectStreamInStartAddress = params->dwIndStreamInStartAddrOffset;
        cmd.DW2.HucProcessing = params->bHucProcessing;
        cmd.DW3.IndirectStreamOutStartAddress = params->dwIndStreamOutStartAddrOffset;
        cmd.DW4.HucBitstreamEnable = params->bStreamInEnable;
        cmd.DW4.StreamOut = params->bStreamOutEnable;
        cmd.DW4.EmulationPreventionByteRemoval = params->bEmulPreventionByteRemoval;
        cmd.DW4.StartCodeSearchEngine = params->bStartCodeSearchEngine;
        cmd.DW4.Drmlengthmode = params->bLengthModeEnabled;
        cmd.DW4.StartCodeByte2 = params->ucStartCodeByte2;
        cmd.DW4.StartCodeByte1 = params->ucStartCodeByte1;
        cmd.DW4.StartCodeByte0 = params->ucStartCodeByte0;

        MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize));

        return MOS_STATUS_SUCCESS;
    }

    MOS_STATUS AddHucStartCmd(
        MOS_COMMAND_BUFFER             *cmdBuffer,
        bool                            lastStreamObject)
    {
        MHW_MI_CHK_NULL(cmdBuffer);

        typename THucCmds::HUC_START_CMD cmd;

        // set last stream object or not
        cmd.DW1.Laststreamobject = (lastStreamObject != 0);

        MHW_MI_CHK_STATUS(Mos_AddCommand(cmdBuffer, &cmd, cmd.byteSize));

        return MOS_STATUS_SUCCESS;
    }
};

#endif