//<MStar Software>
//******************************************************************************
// MStar Software
// Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
// All software, firmware and related documentation herein ("MStar Software") are
// intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
// law, including, but not limited to, copyright law and international treaties.
// Any use, modification, reproduction, retransmission, or republication of all
// or part of MStar Software is expressly prohibited, unless prior written
// permission has been granted by MStar.
//
// By accessing, browsing and/or using MStar Software, you acknowledge that you
// have read, understood, and agree, to be bound by below terms ("Terms") and to
// comply with all applicable laws and regulations:
//
// 1. MStar shall retain any and all right, ownership and interest to MStar
//    Software and any modification/derivatives thereof.
//    No right, ownership, or interest to MStar Software and any
//    modification/derivatives thereof is transferred to you under Terms.
//
// 2. You understand that MStar Software might include, incorporate or be
//    supplied together with third party`s software and the use of MStar
//    Software may require additional licenses from third parties.
//    Therefore, you hereby agree it is your sole responsibility to separately
//    obtain any and all third party right and license necessary for your use of
//    such third party`s software.
//
// 3. MStar Software and any modification/derivatives thereof shall be deemed as
//    MStar`s confidential information and you agree to keep MStar`s
//    confidential information in strictest confidence and not disclose to any
//    third party.
//
// 4. MStar Software is provided on an "AS IS" basis without warranties of any
//    kind. Any warranties are hereby expressly disclaimed by MStar, including
//    without limitation, any warranties of merchantability, non-infringement of
//    intellectual property rights, fitness for a particular purpose, error free
//    and in conformity with any international standard.  You agree to waive any
//    claim against MStar for any loss, damage, cost or expense that you may
//    incur related to your use of MStar Software.
//    In no event shall MStar be liable for any direct, indirect, incidental or
//    consequential damages, including without limitation, lost of profit or
//    revenues, lost or damage of data, and unauthorized system use.
//    You agree that this Section 4 shall still apply without being affected
//    even if MStar Software has been modified by MStar in accordance with your
//    request or instruction for your use, except otherwise agreed by both
//    parties in writing.
//
// 5. If requested, MStar may from time to time provide technical supports or
//    services in relation with MStar Software to you for your use of
//    MStar Software in conjunction with your or your customer`s product
//    ("Services").
//    You understand and agree that, except otherwise agreed by both parties in
//    writing, Services are provided on an "AS IS" basis and the warranty
//    disclaimer set forth in Section 4 above shall apply.
//
// 6. Nothing contained herein shall be construed as by implication, estoppels
//    or otherwise:
//    (a) conferring any license or right to use MStar name, trademark, service
//        mark, symbol or any other identification;
//    (b) obligating MStar or any of its affiliates to furnish any person,
//        including without limitation, you and your customers, any assistance
//        of any kind whatsoever, or any information; or
//    (c) conferring any license or right under any intellectual property right.
//
// 7. These terms shall be governed by and construed in accordance with the laws
//    of Taiwan, R.O.C., excluding its conflict of law rules.
//    Any and all dispute arising out hereof or related hereto shall be finally
//    settled by arbitration referred to the Chinese Arbitration Association,
//    Taipei in accordance with the ROC Arbitration Law and the Arbitration
//    Rules of the Association by three (3) arbitrators appointed in accordance
//    with the said Rules.
//    The place of arbitration shall be in Taipei, Taiwan and the language shall
//    be English.
//    The arbitration award shall be final and binding to both parties.
//
//******************************************************************************
//<MStar Software>
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2006-2009 MStar Semiconductor, Inc.
// All rights reserved.
//
// Unless otherwise stipulated in writing, any and all information contained
// herein regardless in any format shall remain the sole proprietary of
// MStar Semiconductor Inc. and be kept in strict confidence
// ("MStar Confidential Information") by the recipient.
// Any unauthorized act including without limitation unauthorized disclosure,
// copying, use, reproduction, sale, distribution, modification, disassembling,
// reverse engineering and compiling of the contents of MStar Confidential
// Information is unlawful and strictly prohibited. MStar hereby reserves the
// rights to any and all damages, losses, costs and expenses resulting therefrom.
//
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////
///
/// @file   drvMMA.h
/// @brief  System Control Interface
/// @author MStar Semiconductor,Inc.
///
////////////////////////////////////////////////////////////////////////////////////////////////////
#ifndef _DRVMMA_H_
#define _DRVMMA_H_

#ifdef __cplusplus
extern "C" {
#endif

//
// Definition
//
#define MSOS_HAL_IOVA_START_ADDR 0x200000000
#define MSOS_MMA_PIPE_ID_MAX_LEN 16
#define MSOS_MMA_BUFTAG_MAX_LEN  32

//
// Macros
//
#define MSOS_isIOVA(x) ((MS_U64)x & MSOS_HAL_IOVA_START_ADDR) > 0

//
// Structures
//
enum eMSOS_MMA_FEATURE {
    MSOS_MMA_NOT_SUPPORT,
    MSOS_MMA_SUPPORT,
};

typedef struct {
    MS_U32 u32support;  // enum eMSOS_MMA_FEATURE
    MS_U32 version;
} MSOS_MMA_FEATURE;

struct msos_mma_meminfo_t {
      MS_U64 addr;      // buffer start addr
      MS_U32 size;      // buffer size
      MS_S32 dmabuf_fd; // buffer fd
      char iova;        // is iova or not
      char secure;      // is secure buffer or not
      char miu_select;  // which miu the buffer located
};

struct msos_mma_heapinfo_t {
    MS_U64 base_addr;                   // heap base addr
    MS_U64 size;                        // heap buffer size.
    char name[MSOS_MMA_BUFTAG_MAX_LEN]; // heap name
    void* buf_handle;                   // pointer to buf_handle
};

struct msos_mma_buftag_info_t {
    char name[MSOS_MMA_BUFTAG_MAX_LEN];
    MS_U32 max_buf_size;
    MS_U32 miu;
    MS_U32 type; // 0:MMA-IOMMU, 1:MMA-CMA
};
//
// Public APIs
//

//-------------------------------------------------------------------------------------------------
/// Feature query function for MMA driver
//  @param  feature      \b OUT: Information for whether or not MMA is supported
/// @return TRUE : support
/// @return FALSE : not support
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MSOS_MMA_query_feature(MSOS_MMA_FEATURE* feature);

//-------------------------------------------------------------------------------------------------
/// Buffer tag query function
//  @param  u8bufTag      \b IN: buffer tag
//  @param  buf_info      \b OUT: information of this buffer
/// @return TRUE : support
/// @return FALSE : not support
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MSOS_MMA_buf_tag_check(const MS_U8* u8bufTag, struct msos_mma_buftag_info_t* buf_info);

//-------------------------------------------------------------------------------------------------
/// Initialize MMA driver
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MsOS_MMA_Init(void);

//-------------------------------------------------------------------------------------------------
/// Exit MMA driver
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MsOS_MMA_Exit(void);

//-------------------------------------------------------------------------------------------------
/// Allocates buffer
/// @param  u8bufTag      \b IN:  buffer tag
/// @param  u32size       \b IN:  buffer size
/// @param  pPhy          \b OUT: ms_phy address of the allocated buffer
/// @param  ppBufHandle   \b OUT: not used
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MsOS_MMA_Alloc(const MS_U8* u8bufTag, MS_U32 u32size, MS_PHY* pPhy, void** ppBufHandle);

//-------------------------------------------------------------------------------------------------
/// Allocates secure buffer
/// @param  u8bufTag      \b IN:  buffer tag
/// @param  u32size       \b IN:  buffer size
/// @param  pPhy          \b OUT: ms_phy address of the allocated buffer
/// @param  ppBufHandle   \b OUT: not used
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MsOS_MMA_Sec_Alloc(const MS_U8* u8bufTag, MS_U32 u32size, MS_PHY* pPhy, void** ppBufHandle);

//-------------------------------------------------------------------------------------------------
/// Map pa to va
/// @param  pPhy          \b IN:  pa
/// @param  size          \b IN:  buffer size
/// @param  cached        \b IN:  cached or not
/// @param  vaddr         \b OUT: maaped va
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MsOS_MMA_map(MS_PHY pPhy, MS_U32 size, MS_U8 cached, MS_VIRT *vaddr);

//-------------------------------------------------------------------------------------------------
/// Reverse action of MsOS_MMA_map
/// @param  vaddr         \b IN:  va
/// @param  size          \b IN:  buffer size
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MsOS_MMA_unmap(MS_VIRT vaddr, MS_U32 size);

//-------------------------------------------------------------------------------------------------
/// Clean & Invalid cache
/// @param  vaddr         \b IN:  va
/// @param  size          \b IN:  buffer size
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MsOS_MMA_flush(MS_VIRT vaddr, MS_U32 size);

//-------------------------------------------------------------------------------------------------
/// Allocates pipe ID
/// @param  u32pipeID     \b OUT: pipe ID
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MsOS_MMA_Pipeid_Alloc(MS_U32* u32pipeID);

//-------------------------------------------------------------------------------------------------
/// Release allocated pipe ID
/// @param  u32pipeID     \b IN: pipe ID
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MsOS_MMA_Pipeid_Release(MS_U32* u32pipeID);

//-------------------------------------------------------------------------------------------------
/// Authorize allocated secure buffer from pipe config
/// @param  pPhy          \b IN: ms_phy address of the allocated buffer
/// @param  u32pipeID     \b IN: pipe ID
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MsOS_MMA_Sec_AuthorizeFromPipeConfig(MS_PHY pPhy, MS_U32 u32pipeID);

//-------------------------------------------------------------------------------------------------
/// Unauthorize allocated secure buffer
/// @param  pPhy          \b IN: ms_phy address of the allocated buffer
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MsOS_MMA_Sec_Unauthorize(MS_PHY pPhy);

//-------------------------------------------------------------------------------------------------
/// Reserve a specific range of ms_phy address for the specified buffer tags
/// @param  pu8space_tag  \b IN: space tag
/// @param  u64size       \b IN: address range
/// @param  pphyBaseAddr  \b IN: base address of space tag (ms_phy)
/// @param  u32tagNum     \b IN: number of buffer tag
/// @param  ...           \b IN: buffer tags
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MsOS_MMA_Reserve_Iova(const MS_U8 *pu8space_tag, MS_U64 u64size, MS_PHY* pphyBaseAddr, MS_U32 u32tagNum, ...);

//-------------------------------------------------------------------------------------------------
/// Free buffer
/// @param  pPhy          \b IN: ms_phy address of the allocated buffer
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MsOS_MMA_free(MS_PHY pPhy);

//-------------------------------------------------------------------------------------------------
/// Get Buffer info
/// @param  pPhy          \b IN: buffer start address
/// @param  pMem_info     \b OUT: buffer infomation
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MsOS_MMA_getinfo(MS_PHY pPhy, struct msos_mma_meminfo_t* pMem_info);

//-------------------------------------------------------------------------------------------------
/// Get Buffer fd
/// @param  pPhy          \b IN: buffer start address
/// @param  pFd           \b OUT: buffer fd
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MsOS_MMA_getfd(MS_PHY pPhy, MS_S32 *pFd);

//-------------------------------------------------------------------------------------------------
/// Free Buffer fd
/// @param  fd            \b IN: buffer fd
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------
MS_U32 __attribute__((weak)) MsOS_MMA_putfd(MS_S32 fd);

//-------------------------------------------------------------------------------------------------
/// BDMA memory copy
/// @param  phySrc        \b IN: source address
/// @param  phyDst        \b IN: destination address
/// @param  u32Len        \b IN: size of memory block to copy
//-------------------------------------------------------------------------------------------------
void __attribute__((weak)) MsOS_MMA_debugBdmacpy(MS_PHY phySrc, MS_PHY phyDst, MS_U32 u32Len);

//-------------------------------------------------------------------------------------------------
/// Authorize CMA buffer
/// @param  buf_tag      \b IN:  buffer tag
/// @param  pPhy         \b IN:  buffer PA
/// @param  size          \b IN: buffer size
/// @param  pipeid       \b IN:  pipe ID
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------

MS_U32 __attribute__((weak)) MsOS_MMA_CMA_Authorize(const char* buf_tag, MS_PHY pPhy, MS_U32 size, MS_U32 pipeid);

//-------------------------------------------------------------------------------------------------
/// Unauthorize CMA buffer
/// @param  pPhy          \b IN: buffer PA
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------

MS_U32 __attribute__((weak)) MsOS_MMA_CMA_Unauthorize(MS_PHY pPhy);

//-------------------------------------------------------------------------------------------------
/// VA TO IOVA
/// @param  buf_tag       \b IN:  buffer tag
/// @param  pPhy          \b OUT: address of the allocated buffer
/// @param  va            \b IN : VA
/// @param  size          \b IN:  buffer size
/// @return TRUE : succeed
/// @return FALSE : fail
//-------------------------------------------------------------------------------------------------

MS_U32 __attribute__((weak)) MsOS_MMA_VA2IOVA(char* buf_tag, MS_PHY* pPhy, MS_VIRT va, MS_U32 size);

#ifdef __cplusplus
};  /* end of extern "C" */
#endif

#endif /* _DRVMMA_H_ */
