/*==============================================================================
Copyright(c) 2017 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.
============================================================================*/
#pragma once

// GmmConst.h needed for GMM_MAX_NUMBER_MOCS_INDEXES
#include "GmmConst.h"
#include "../../../Platform/GmmPlatforms.h"

#ifdef GMM_LIB_DLL
#ifdef _WIN32
#define GMM_MUTEX_HANDLE    HANDLE
#else
#include <pthread.h>
#define GMM_MUTEX_HANDLE    pthread_mutex_t
#endif
#endif

// Set packing alignment
#pragma pack(push, 8)

//===========================================================================
// Forward Declaration: Defined in GmmResourceInfoExt.h
//---------------------------------------------------------------------------
struct GMM_CONTEXT_REC;
typedef struct GMM_CONTEXT_REC GMM_CONTEXT;

//===========================================================================
// typedef:
//      GMM_UMD_CONTEXT
//
// Description:
//      Struct defines user mode GMM context.
//----------------------------------------------------------------------------
typedef struct GMM_UMD_CONTEXT_REC
{
    uint32_t   TBD1;
    uint32_t   TBD2;
    uint32_t   TBD3;
} GMM_UMD_CONTEXT;


#if (!defined(__GMM_KMD__) && !defined(GMM_UNIFIED_LIB))
#include "GmmClientContext.h"
#endif

//===========================================================================
// typedef:
//      GMM_GLOBAL_CONTEXT
//
// Description:
//     Struct contains contexts for user mode and kernel mode. It also contains
//     platform information. This struct is initialized in user mode with
//     GmmInitGlobalContext().
//
//----------------------------------------------------------------------------

#ifdef __cplusplus
#include "GmmMemAllocator.hpp"

namespace GmmLib
{
    class NON_PAGED_SECTION Context : public GmmMemAllocator
    {
    private:
        static int32_t                   RefCount;
        GMM_CLIENT                       ClientType;
        GMM_PLATFORM_INFO_CLASS*         pPlatformInfo;

        GMM_TEXTURE_CALC*                pTextureCalc;
        SKU_FEATURE_TABLE                SkuTable;
        WA_TABLE                         WaTable;
        GT_SYSTEM_INFO                   GtSysInfo;

    #if(defined(__GMM_KMD__))
        GMM_GTT_CONTEXT              GttContext;
    #endif

        GMM_CONTEXT                      *pGmmKmdContext;
        GMM_UMD_CONTEXT                  *pGmmUmdContext;
        void                             *pKmdHwDev;
        void                             *pUmdAdapter;

        GMM_CACHE_POLICY_ELEMENT         CachePolicy[GMM_RESOURCE_USAGE_MAX];
        GMM_CACHE_POLICY_TBL_ELEMENT     CachePolicyTbl[GMM_MAX_NUMBER_MOCS_INDEXES];
        GMM_CACHE_POLICY                 *pGmmCachePolicy;

    #if(defined(__GMM_KMD__))
        uint64_t           IA32ePATTable;
        GMM_PRIVATE_PAT     PrivatePATTable[GMM_NUM_PAT_ENTRIES];
        int32_t                PrivatePATTableMemoryType[GMM_NUM_GFX_PAT_TYPES];
    #endif

        // Padding Percentage limit on 64KB paged resource
        uint32_t               AllowedPaddingFor64KbPagesPercentage;
        uint64_t              InternalGpuVaMax;

#ifdef GMM_LIB_DLL
        // Mutex Object used for synchronization of ProcessSingleton Context
        static GMM_MUTEX_HANDLE           SingletonContextSyncMutex;
#endif

    public :
        //Constructors and destructors
        Context();
        ~Context();

        static int32_t IncrementRefCount()  // Returns the current RefCount and then increment it
        {
#if defined(_WIN32)
            return(InterlockedIncrement((LONG *)&RefCount) - 1);  //InterLockedIncrement() returns incremented value
#elif defined(__linux__)
            return(__sync_fetch_and_add(&RefCount, 1));
#endif
        }

        static int32_t DecrementRefCount()
        {
            int CurrentValue = 0;
            int TargetValue = 0;
            do
            {
                CurrentValue = RefCount;
                if (CurrentValue > 0)
                {
                    TargetValue = CurrentValue - 1;
                }
                else
                {
                    break;
                }
#if defined(_WIN32)
            } while (!(InterlockedCompareExchange((LONG *)&RefCount, TargetValue, CurrentValue) == CurrentValue));
#elif defined(__linux__)
            } while (!__sync_bool_compare_and_swap(&RefCount, CurrentValue, TargetValue));
#endif

            return TargetValue;
        }

        GMM_STATUS GMM_STDCALL InitContext(
                                    const PLATFORM& Platform,
                                    const SKU_FEATURE_TABLE* pSkuTable,
                                    const WA_TABLE* pWaTable,
                                    const GT_SYSTEM_INFO* pGtSysInfo,
                                    GMM_CLIENT ClientType);

        void GMM_STDCALL DestroyContext();

#if (!defined(__GMM_KMD__) && !defined(GMM_UNIFIED_LIB))
        GMM_CLIENT_CONTEXT *pGmmGlobalClientContext;
#endif


        //Inline functions
        /////////////////////////////////////////////////////////////////////////
        /// Returns the client type e.g. DX, OCL, OGL etc.
        /// @return   client type
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE GMM_CLIENT  GMM_STDCALL  GetClientType()
        {
            return (ClientType);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns the PlatformInfo
        /// @return   PlatformInfo
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE GMM_PLATFORM_INFO&  GMM_STDCALL  GetPlatformInfo()
        {
            return (const_cast<GMM_PLATFORM_INFO&>(pPlatformInfo->GetData()));
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns the cache policy element array ptr
        /// @return   const cache policy elment ptr
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE GMM_CACHE_POLICY_ELEMENT*  GMM_STDCALL GetCachePolicyUsage()
        {
            return (&CachePolicy[0]);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns the cache policy tlb element array ptr
        /// @return   const cache policy elment ptr
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE GMM_CACHE_POLICY_TBL_ELEMENT*  GMM_STDCALL GetCachePolicyTlbElement()
        {
            return (&CachePolicyTbl[0]);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns the texture calculation object ptr
        /// @return   TextureCalc ptr
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE GMM_TEXTURE_CALC* GMM_STDCALL GetTextureCalc()
        {
            return (pTextureCalc);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns the platform info class object ptr
        /// @return   PlatformInfo class object ptr
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE GMM_PLATFORM_INFO_CLASS* GMM_STDCALL GetPlatformInfoObj()
        {
            return (pPlatformInfo);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns the cache policy object ptr
        /// @return   TextureCalc ptr
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE GMM_CACHE_POLICY* GMM_STDCALL GetCachePolicyObj()
        {
            return (pGmmCachePolicy);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns the sku table ptr
        /// @return   const SkuTable ptr
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE const SKU_FEATURE_TABLE& GMM_STDCALL GetSkuTable()
        {
            return (SkuTable);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns the Wa table ptr
        /// @return    WaTable ptr
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE const WA_TABLE& GMM_STDCALL GetWaTable()
        {
            return (WaTable);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns the GT system info ptr
        /// @return   const GtSysInfo ptr
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE const GT_SYSTEM_INFO* GMM_STDCALL GetGtSysInfoPtr()
        {
            return (&GtSysInfo);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns the GT system info ptr
        /// @return   GtSysInfo ptr
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE GT_SYSTEM_INFO* GMM_STDCALL GetGtSysInfo()
        {
            return (&GtSysInfo);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns Cache policy element for a given usage type
        /// @return   cache policy element
        ////////////////////////////////////////////////////////////////////////
        GMM_INLINE GMM_CACHE_POLICY_ELEMENT GetCachePolicyElement(GMM_RESOURCE_USAGE_TYPE Usage)
        {
            return (CachePolicy[Usage]);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Get padding percentage limit for 64kb pages
        /////////////////////////////////////////////////////////////////////////
        uint32_t GetAllowedPaddingFor64KbPagesPercentage()
        {
            return (AllowedPaddingFor64KbPagesPercentage);
        }

        uint64_t& GetInternalGpuVaRangeLimit()
        {
            return InternalGpuVaMax;
        }

    #ifdef GMM_LIB_DLL
        #ifdef _WIN32
            // ProcessHeapVA Singleton HeapObj
            GMM_HEAP            *pHeapObj;
            uint32_t            ProcessHeapCounter;
            // ProcessVA Partition Address space
            GMM_GFX_PARTITIONING ProcessVA;
            uint32_t            ProcessVACounter;

            /////////////////////////////////////////////////////////////////////////
            /// Get ProcessHeapVA Singleton HeapObj
            /////////////////////////////////////////////////////////////////////////
            GMM_HEAP* GetSharedHeapObject();

            /////////////////////////////////////////////////////////////////////////
            /// Set ProcessHeapVA Singleton HeapObj
            /////////////////////////////////////////////////////////////////////////
            uint32_t SetSharedHeapObject(GMM_HEAP **pProcessHeapObj);

            /////////////////////////////////////////////////////////////////////////
            /// Get or Sets ProcessGfxPartition VA
            /////////////////////////////////////////////////////////////////////////
            void GetProcessGfxPartition(GMM_GFX_PARTITIONING* pProcessVA);

            /////////////////////////////////////////////////////////////////////////
            /// Get or Sets ProcessGfxPartition VA
            /////////////////////////////////////////////////////////////////////////
            void SetProcessGfxPartition(GMM_GFX_PARTITIONING* pProcessVA);

            /////////////////////////////////////////////////////////////////////////
            /// Destroy Sync Mutex created for Singleton Context access
            /////////////////////////////////////////////////////////////////////////
            static void   DestroySingletonContextSyncMutex()
            {
                if (SingletonContextSyncMutex)
                {
                    ::CloseHandle(SingletonContextSyncMutex);
                    SingletonContextSyncMutex = NULL;
                }
            }

            /////////////////////////////////////////////////////////////////////////
            /// Acquire Sync Mutex for Singleton Context access
            /////////////////////////////////////////////////////////////////////////
            static GMM_STATUS   LockSingletonContextSyncMutex()
            {
                if (SingletonContextSyncMutex)
                {
                    while (WAIT_OBJECT_0 != ::WaitForSingleObject(SingletonContextSyncMutex, INFINITE));
                    return GMM_SUCCESS;
                }
                else
                {
                    return GMM_ERROR;
                }
            }

            /////////////////////////////////////////////////////////////////////////
            /// Release Sync Mutex for Singleton Context access
            /////////////////////////////////////////////////////////////////////////
            static GMM_STATUS   UnlockSingletonContextSyncMutex()
            {
                if (SingletonContextSyncMutex)
                {
                    ::ReleaseMutex(SingletonContextSyncMutex);
                    return GMM_SUCCESS;
                }
                else
                {
                    return GMM_ERROR;
                }
            }

        #else // Non Win OS

            /////////////////////////////////////////////////////////////////////////
            /// Destroy Sync Mutex created for Singleton Context access
            /////////////////////////////////////////////////////////////////////////
            static void   DestroySingletonContextSyncMutex()
            {
                pthread_mutex_destroy(&SingletonContextSyncMutex);
            }

            /////////////////////////////////////////////////////////////////////////
            /// Acquire Sync Mutex for Singleton Context access
            /////////////////////////////////////////////////////////////////////////
            static GMM_STATUS   LockSingletonContextSyncMutex()
            {
                pthread_mutex_lock(&SingletonContextSyncMutex);
                return GMM_SUCCESS;
            }

            /////////////////////////////////////////////////////////////////////////
            /// Release Sync Mutex for Singleton Context access
            /////////////////////////////////////////////////////////////////////////
            static GMM_STATUS   UnlockSingletonContextSyncMutex()
            {
                pthread_mutex_unlock(&SingletonContextSyncMutex);
                return GMM_SUCCESS;
            }

        #endif // _WIN32

    #endif // GMM_LIB_DLL

        // KMD specific inline functions
    #ifdef __GMM_KMD__

        /////////////////////////////////////////////////////////////////////////
        /// Returns private PAT table memory type for a given PAT type
        /// @return   PAT Memory type
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE int32_t  GMM_STDCALL GetPrivatePATTableMemoryType(GMM_GFX_PAT_TYPE PatType)
        {
            return (PrivatePATTableMemoryType[PatType]);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns private PAT table memory type array ptr
        /// @return   PAT Memory type array ptr
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE int32_t*  GMM_STDCALL GetPrivatePATTableMemoryType()
        {
            return (PrivatePATTableMemoryType);
        }


        /////////////////////////////////////////////////////////////////////////
        /// Returns private PAT table array ptr
        /// @return   PAT array ptr
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE GMM_PRIVATE_PAT* GMM_STDCALL  GetPrivatePATTable()
        {
            return (PrivatePATTable);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns private PAT table entry for a given PAT index
        /// @return   PAT entry
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE GMM_PRIVATE_PAT GMM_STDCALL  GetPrivatePATEntry(uint32_t  PatIndex)
        {
            return (PrivatePATTable[PatIndex]);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns gmm kmd context ptr
        /// @return   GmmKmdContext ptr
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE GMM_CONTEXT* GetGmmKmdContext()
        {
            return (pGmmKmdContext);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Sets gmm kmd context ptr
        /// @return   GmmKmdContext ptr
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE void SetGmmKmdContext(GMM_CONTEXT *pGmmKmdContext)
        {
            this->pGmmKmdContext = pGmmKmdContext;
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns gtt context ptr
        /// @return   GttContext ptr
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE GMM_GTT_CONTEXT* GetGttContext()
        {
            return (&GttContext);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns Cache policy tbl element for a given usage type
        /// @return   cache policy tbl element
        ////////////////////////////////////////////////////////////////////////
        GMM_INLINE GMM_CACHE_POLICY_TBL_ELEMENT GetCachePolicyTblElement(GMM_RESOURCE_USAGE_TYPE Usage)
        {
            return (CachePolicyTbl[Usage]);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Resets  the sku Table after  GmmInitContext() could have changed them
        /// since original latching
        ////////////////////////////////////////////////////////////////////////
        GMM_INLINE void SetSkuTable(SKU_FEATURE_TABLE SkuTable)
        {
            this->SkuTable = SkuTable;
        }

        /////////////////////////////////////////////////////////////////////////
        /// Resets  the Wa Table after  GmmInitContext() could have changed them
        /// since original latching
        ////////////////////////////////////////////////////////////////////////
        GMM_INLINE void SetWaTable(WA_TABLE WaTable)
        {
            this->WaTable = WaTable;
        }

    #if(_DEBUG || _RELEASE_INTERNAL)

        /////////////////////////////////////////////////////////////////////////
        /// Returns the override platform info class object ptr
        /// @return   PlatformInfo class object ptr
        /////////////////////////////////////////////////////////////////////////
        GMM_INLINE GMM_PLATFORM_INFO_CLASS* GMM_STDCALL GetOverridePlatformInfoObj()
        {
            return (Override.pPlatformInfo);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns the override Platform info ptr to kmd
        /// @return   override PlatformInfo ref
        ////////////////////////////////////////////////////////////////////////
        GMM_INLINE GMM_PLATFORM_INFO& GMM_STDCALL GetOverridePlatformInfo()
        {
            return (const_cast<GMM_PLATFORM_INFO&>(Override.pPlatformInfo->GetData()));
        }

        /////////////////////////////////////////////////////////////////////////
        /// Set the override platform info calc ptr
        ////////////////////////////////////////////////////////////////////////
        GMM_INLINE void SetOverridePlatformInfoObj(GMM_PLATFORM_INFO_CLASS *pPlatformInfoObj)
        {
            Override.pPlatformInfo = pPlatformInfoObj;
        }

        /////////////////////////////////////////////////////////////////////////
        /// Returns the override Texture calc ptr to kmd
        /// @return   override Texture calc ptr
        ////////////////////////////////////////////////////////////////////////
        GMM_INLINE GMM_TEXTURE_CALC* GetOverrideTextureCalc()
        {
            return (Override.pTextureCalc);
        }

        /////////////////////////////////////////////////////////////////////////
        /// Set the override Texture calc ptr
        ////////////////////////////////////////////////////////////////////////
        GMM_INLINE void SetOverrideTextureCalc(GMM_TEXTURE_CALC *pTextureCalc)
        {
            Override.pTextureCalc = pTextureCalc;
        }
    #endif


    #endif
    private: 
        void GMM_STDCALL OverrideSkuWa();
    };
} //namespace

typedef GmmLib::Context GMM_GLOBAL_CONTEXT;

#else
struct GmmLibContext;
typedef struct GmmLibContext GMM_GLOBAL_CONTEXT;
#endif


#ifdef __GMM_KMD__
void GMM_STDCALL GmmLinkKmdContextToGlobalInfo(GMM_GLOBAL_CONTEXT *pGmmLibContext, GMM_CONTEXT *pGmmKmdContext);
#endif /*__GMM_KMD__*/


//Declare all  GMM global context C interfaces.
#ifdef __cplusplus
extern "C" {
#endif /*__cplusplus*/

    const GMM_PLATFORM_INFO* GMM_STDCALL GmmGetPlatformInfo(GMM_GLOBAL_CONTEXT *pGmmLibContext);
    const GMM_CACHE_POLICY_ELEMENT* GmmGetCachePolicyUsage(GMM_GLOBAL_CONTEXT *pGmmLibContext);
          GMM_TEXTURE_CALC*         GmmGetTextureCalc(GMM_GLOBAL_CONTEXT *pGmmLibContext);
    const SKU_FEATURE_TABLE*        GmmGetSkuTable(GMM_GLOBAL_CONTEXT *pGmmLibContext);
    const WA_TABLE*                 GmmGetWaTable(GMM_GLOBAL_CONTEXT *pGmmLibContext);
    const GT_SYSTEM_INFO*           GmmGetGtSysInfo(GMM_GLOBAL_CONTEXT *pGmmLibContext);

#ifdef __GMM_KMD__
    int32_t             GmmGetPrivatePATTableMemoryType(GMM_GLOBAL_CONTEXT *pGmmLibContext, GMM_GFX_PAT_TYPE PatType);
    GMM_PRIVATE_PAT     GmmGetPrivatePATEntry(GMM_GLOBAL_CONTEXT *pGmmLibContext, uint32_t  PatIndex);
    GMM_CONTEXT*        GmmGetGmmKmdContext(GMM_GLOBAL_CONTEXT *pGmmLibContext);
    GMM_GTT_CONTEXT*    GmmGetGttContext(GMM_GLOBAL_CONTEXT *pGmmLibContext);
    GMM_CACHE_POLICY_TBL_ELEMENT GmmGetCachePolicyTblElement(GMM_GLOBAL_CONTEXT *pGmmLibContext, GMM_RESOURCE_USAGE_TYPE Usage);
    GMM_CACHE_POLICY_ELEMENT GmmGetCachePolicyElement(GMM_GLOBAL_CONTEXT *pGmmLibContext, GMM_RESOURCE_USAGE_TYPE Usage);
    void                GmmSetSkuTable(GMM_GLOBAL_CONTEXT *pGmmLibContext, SKU_FEATURE_TABLE SkuTable);
    void                GmmSetWaTable(GMM_GLOBAL_CONTEXT *pGmmLibContext, WA_TABLE WaTable);
    GMM_PLATFORM_INFO*  GmmKmdGetPlatformInfo(GMM_GLOBAL_CONTEXT *pGmmLibContext);

#if(_DEBUG || _RELEASE_INTERNAL)
    const GMM_PLATFORM_INFO* GmmGetOverridePlatformInfo(GMM_GLOBAL_CONTEXT *pGmmLibContext);
    GMM_TEXTURE_CALC*   GmmGetOverrideTextureCalc(GMM_GLOBAL_CONTEXT *pGmmLibContext);
#endif

#endif

#ifdef __cplusplus
}
#endif /*__cplusplus*/

    #define GMM_OVERRIDE_PLATFORM_INFO(pTexInfo)    (GmmGetPlatformInfo(pGmmGlobalContext))
    #define GMM_OVERRIDE_TEXTURE_CALC(pTexInfo)     (GmmGetTextureCalc(pGmmGlobalContext))

#ifdef __GMM_KMD__
    #define GMM_OVERRIDE_EXPORTED_PLATFORM_INFO(pTexInfo)    GMM_OVERRIDE_PLATFORM_INFO(pTexInfo)
    #define GMM_IS_PLANAR(Format)                            GmmIsPlanar(Format)
#else
    #define GMM_OVERRIDE_EXPORTED_PLATFORM_INFO(pTexInfo)    (&pClientContext->GetPlatformInfo())
    #define GMM_IS_PLANAR(Format)                            (pClientContext->IsPlanar(Format))
#endif

// Reset packing alignment to project default
#pragma pack(pop)