xref: /utopia/UTPA2-700.0.x/mxlib/include/drvMIU.h (revision 53ee8cc121a030b8d368113ac3e966b4705770ef)

//<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-2007 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   drvMIU.h
/// @brief  MIU Driver Interface
/// @author MStar Semiconductor Inc.
///////////////////////////////////////////////////////////////////////////////////////////////////

/*! \defgroup G_MIU MIU interface
    \ingroup  G_PERIPHERAL

    \brief
    MIU is an IP used to manage DRAM, and it supports DRAM Protection, IP Selection, and IP Mask.

    <b>Features</b>

    - MIU Protect: Enable/Disable IPs to read/write a specific memory range.
    - IP Select: To change IPs used in MIU0/MIU1
    - IP Mask: To disable IPs using DRAM.

    <b> MIU Block Diagram: </b> \n
    \image html drvMIU_pic1.png

     \defgroup G_MIU_INIT Initialization Task relative
     \ingroup  G_MIU
     \defgroup G_MIU_COMMON Common Task relative
     \ingroup  G_MIU
     \defgroup G_MIU_CONTROL Control relative
     \ingroup  G_MIU
     \defgroup G_MIU_PROTECT Protect Task relative
     \ingroup  G_MIU
     \defgroup G_MIU_ToBeModified MIU api to be modified
     \ingroup  G_MIU
     \defgroup G_MIU_ToBeRemove MIU api to be removed
     \ingroup  G_MIU
*/

#ifndef _DRV_MIU_H_
#define _DRV_MIU_H_

#ifdef __cplusplus
extern "C"
{
#endif

#include "MsTypes.h"
#include "MsDevice.h"
#include "UFO.h"

//-------------------------------------------------------------------------------------------------
// Defines
//-------------------------------------------------------------------------------------------------
#ifdef STELLAR
#define _MIU_INTERNEL_USE 1
#endif
//-------------------------------------------------------------------------------------------------
// Macros
//-------------------------------------------------------------------------------------------------
#define MIU_DRV_VERSION                 /* Character String for DRV/API version             */  \
    MSIF_TAG,                           /* 'MSIF'                                           */  \
    MSIF_CLASS,                         /* '00'                                             */  \
    MSIF_CUS,                           /* 0x0000                                           */  \
    MSIF_MOD,                           /* 0x0000                                           */  \
    MSIF_CHIP,                                                                                  \
    MSIF_CPU,                                                                                   \
    {'M','I','U','_'},                  /* IP__                                             */  \
    {'0','1'},                          /* 0.0 ~ Z.Z                                        */  \
    {'0','2'},                          /* 00 ~ 99                                          */  \
    {'0','0','2','6','4','8','8','5'},  /* CL#                                              */  \
    MSIF_OS

#define MIU_CLIENT_MAX  0x30


#define bit_check(x,bit_pos)  ((x & bit_pos) != 0) ? TRUE : FALSE


#define set_req_mask_info(reg_addr,base_addr,bEnable,id_pos)  \
    MST_MACRO_START                                                     \
    reg_addr = base_addr;                                               \
    reg_addr = reg_addr + (MS_U16)((id_pos >> 4) * 0x20);                  \
    if(reg_addr == 0x1286)                                              \
        reg_addr = 0x06F6;                                              \
    else if(reg_addr == 0x0686)                                         \
        reg_addr = 0x0628;                                              \
    reg_addr = reg_addr + (MS_U16)(bit_check(id_pos,BIT3));                \
    HAL_MIU_WriteRegBit(reg_addr, bEnable , (1 << (id_pos & (BIT2|BIT1|BIT0)))); \
    MST_MACRO_END

#ifdef ALIGN
#undef ALIGN
#define ALIGN(_val_,_shift_) (((_val_) >> _shift_) << _shift_)
#else
#define ALIGN(_val_,_shift_) (((_val_) >> _shift_) << _shift_)
#endif

//#define _MIU_INTERNEL_USE         //for internel test only
#define _ALIGN(_val_,_shift_) (((_val_) >> _shift_) << _shift_)

//-------------------------------------------------------------------------------------------------
// Type and Structure Declaration
//-------------------------------------------------------------------------------------------------
typedef enum
{
    CLIENT_TSPIWB,          // orz
    CLIENT_STRLD,
    CLIENT_HK51_ICACHE,    // MAU0
    CLIENT_AEON_I,          // MAU0
    CLIENT_FLH_W,           // MAU1
    CLIENT_HK51_XDATA,     // MAU1
    CLIENT_AEON,            // MAU1
    CLIENT_OD_LSB,
    CLIENT_GOP2,
    CLIENT_VE,
    CLIENT_FDSEICH,
    CLIENT_TSP,
    CLIENT_TTXSK,
    CLIENT_SVD_DB,
    CLIENT_FDDECICH,
    CLIENT_OPM,
    CLIENT_DC,
    CLIENT_GOP,
    CLIENT_GOP0,
    CLIENT_GOP1,
    CLIENT_DNRB,    // DNR
    CLIENT_COMB,
    CLIENT_OD,
    CLIENT_MADDMA2,   // DMA2
    CLIENT_MAD,
    CLIENT_SVD_EN,
    CLIENT_GE,
    CLIENT_BDMA,   // MIU_DMA
    CLIENT_NFC,
    CLIENT_USBP1,  // USB20 ??
    CLIENT_USBP2,  //USB20_1 ??
    CLIENT_RVD,
    CLIENT_SVDINTP,
    CLIENT_MVD,
    CLIENT_AESDMA,
    CLIENT_TTX,
    CLIENT_JPD,
    CLIENT_EMAC,
    CLIENT_MAX
} euMIUClientIDTYPE;

typedef struct
{
    MS_U8 miu;
    MS_U8 protect_id;
} stMIUClientID_t;

typedef enum
{
    MIU_CLIENT_NONE,    //none can access
    MIU_CLIENT_DUMMY,
    MIU_CLIENT_ADCDVIPLL_W,
    MIU_CLIENT_AESDMA_RW,
    MIU_CLIENT_AU_R2_RW,
    MIU_CLIENT_BDMA_RW,
    MIU_CLIENT_DC_R,                //same as MIU_CLIENT_MVOP_64BIT_R
    MIU_CLIENT_DISP_IPATH_DI_W,
    MIU_CLIENT_DISP_IPATH_MR_RW,
    MIU_CLIENT_DISP_IPATH_NR_RW,
    MIU_CLIENT_DMA2_RW,
    MIU_CLIENT_DNRA_RW,
    MIU_CLIENT_DSCRMB_RW,
    MIU_CLIENT_DVBC_ADC_RW,
    MIU_CLIENT_EMAC_RW,
    MIU_CLIENT_FCIE_RW,
    MIU_CLIENT_FDDECICH_R,
    MIU_CLIENT_FDSEICH_R,
    MIU_CLIENT_G3D_RW,
    MIU_CLIENT_GE_RW,
    MIU_CLIENT_GOP_W,
    MIU_CLIENT_GOP0_R,
    MIU_CLIENT_GOP1_R,
    MIU_CLIENT_GOP2_R,
    MIU_CLIENT_GOP3_R,
    MIU_CLIENT_HISPEED_UART_RW,
    MIU_CLIENT_HVD_RW,
    MIU_CLIENT_HVD_BBU_R,
    MIU_CLIENT_JPD_RW,
    MIU_CLIENT_M4VE_ME_R,
    MIU_CLIENT_M4VE0_RW,
    MIU_CLIENT_M4VE2_RW,
    MIU_CLIENT_MAU_RW,
    MIU_CLIENT_MAU0_W,
    MIU_CLIENT_MAU1_R,
    MIU_CLIENT_MFE0_W,
    MIU_CLIENT_MFE1_R,
    MIU_CLIENT_MHEG5_DCACHE_RW,
    MIU_CLIENT_MHEG5_ICACHE_R,
    MIU_CLIENT_MHEG5_ICACHE_RW,
    MIU_CLIENT_MHEG5_GDMA_RW,
    MIU_CLIENT_MIPS_R,
    MIU_CLIENT_MIPS_W,
    MIU_CLIENT_MIPS_RW,
    MIU_CLIENT_MOBF_RW,
    MIU_CLIENT_MPIF_RW,
    MIU_CLIENT_MVD_RW,
    MIU_CLIENT_MVD_BBU_RW,
    MIU_CLIENT_MVOP_64BIT_R,
    MIU_CLIENT_MVOP_128BIT_R,
    MIU_CLIENT_NAND_RW,
    MIU_CLIENT_OD_R,
    MIU_CLIENT_OD_W,
    MIU_CLIENT_OD_LSB_W,
    MIU_CLIENT_OD_LSB_R,
    MIU_CLIENT_OPW_W,
    MIU_CLIENT_OTG_RW,
    MIU_CLIENT_PM51_RW,
    MIU_CLIENT_PVR_W,
    MIU_CLIENT_PVR2_W,
    MIU_CLIENT_R2M_R,
    MIU_CLIENT_R2M_W,
    MIU_CLIENT_RASP0_W,
    MIU_CLIENT_RASP1_W,
    MIU_CLIENT_RVD_BBU_R,
    MIU_CLIENT_RVD_RW,
    MIU_CLIENT_SC_DNR_R,
    MIU_CLIENT_SC_DNR_W,
    MIU_CLIENT_SC_IPMAIN_R,
    MIU_CLIENT_SC_IPMAIN_W,
    MIU_CLIENT_SC_IPSUB_R,
    MIU_CLIENT_SC_IPSUB_W,
    MIU_CLIENT_SC_OP_R,
    MIU_CLIENT_SC_OPM_R,
    MIU_CLIENT_SC_TNR_R,
    MIU_CLIENT_SC_TNR_W,
    MIU_CLIENT_STRLD_RW,
    MIU_CLIENT_TSP_R,
    MIU_CLIENT_TSP_W,
    MIU_CLIENT_TSP_ORZ_R,
    MIU_CLIENT_TSP_ORZ_W,
    MIU_CLIENT_USB20_RW,
    MIU_CLIENT_USB_UHC0_RW,
    MIU_CLIENT_USB_UHC1_RW,
    MIU_CLIENT_USB_UHC2_RW,
    MIU_CLIENT_VD_COMB_R,
    MIU_CLIENT_VD_COMB_W,
    MIU_CLIENT_VD_TTX_RW,
    MIU_CLIENT_VD_TTXSL_W,
    MIU_CLIENT_VD_TTXSK_W,
    MIU_CLIENT_VE_W,
    MIU_CLIENT_VE_R,
    MIU_CLIENT_VIF_ADC_W,
    MIU_CLIENT_VIVALDI9_AUDMA_RW,
    MIU_CLIENT_VIVALDI9_DECODER_R,
    MIU_CLIENT_VIVALDI9_DMA_RW,
    MIU_CLIENT_VIVALDI9_LNKLST_R,
    MIU_CLIENT_VIVALDI9_MAD_RW,
    MIU_CLIENT_VIVALDI9_SE_R,
    MIU_CLIENT_MSP_ICACHE_RW,
    MIU_CLIENT_DISP_IPATH_DI_RW,
    MIU_CLIENT_MVOP1_R,
    MIU_CLIENT_LDM_W,
    MIU_CLIENT_LDM_R,
    MIU_CLIENT_T3D_W,
    MIU_CLIENT_T3D_R,
    MIU_CLIENT_MIIC0_RW,
    MIU_CLIENT_MIIC1_RW,
    MIU_CLIENT_MIIC2_W,
    MIU_CLIENT_MAXID,
    MIU_CLIENT_SC_IPMAIN_RW,
    MIU_CLIENT_SC_IPSUB_RW,
    MIU_CLIENT_SC_OPMAIN_RW,
    MIU_CLIENT_FRC_OSD_RW,
    MIU_CLIENT_FRC_IP_R,
    MIU_CLIENT_FRC_IP_W,
    MIU_CLIENT_FRC_OD_R,
    MIU_CLIENT_FRC_OD_W,
    MIU_CLIENT_FRC_OPM_R,
    MIU_CLIENT_FRC_R2_RW,
    MIU_CLIENT_FRC_SC_RW,
    MIU_CLIENT_SC_OP_W,
    MIU_CLIENT_SECURE_R2_RW,
    MIU_CLIENT_SC_2D3D_RW,
    MIU_CLIENT_SC_OD_W,
    MIU_CLIENT_SC_OD_R,
    MIU_CLIENT_SC_LD_RW,
    MIU_CLIENT_GPD_RW,
    MIU_CLIENT_VP6_RW,
    MIU_CLIENT_SDIO_RW,
    MIU_CLIENT_G3D0_RW,
    MIU_CLIENT_G3D1_RW,
    MIU_CLIENT_SECEMAC_RW,
    MIU_CLIENT_USB_UHC3_RW,
    MIU_CLIENT_TSP_PVR0_W,
    MIU_CLIENT_TSP_PVR1_W,
    MIU_CLIENT_MAU0_RW,
    MIU_CLIENT_MAU1_RW,
    MIU_CLIENT_TSP_SEC_W,
    MIU_CLIENT_OPM_R,
    MIU_CLIENT_USB3_RW,
    MIU_CLIENT_SC_DIPW_RW,
    MIU_CLIENT_CMD_QUEUE_RW,
    MIU_CLIENT_TSO_RW,
    MIU_CLIENT_VE_2DMCDI_RW,
    MIU_CLIENT_SC_IPSUB2_R,
    MIU_CLIENT_SC_IPSUB2_W,
    MIU_CLIENT_MIIC_DMA_RW,
    MIU_CLIENT_UART_DMA_RW,
    MIU_CLIENT_NJPD_RW,
    MIU_CLIENT_XD2MIU_RW,
    MIU_CLIENT_VD_R2D_RW,
    MIU_CLIENT_VD_R2I_R,
    MIU_CLIENT_TSP_ORZ_RW,
    MIU_CLIENT_MVOP_SUB_R,
    MIU_CLIENT_SC_DIPW_W,
    MIU_CLIENT_T3D_RW,
    MIU_CLIENT_BT_RW,
    MIU_CLIENT_VE_VBI_R,
    MIU_CLIENT_ARM_RW,
    MIU_CLIENT_SC1_OP_R,
    MIU_CLIENT_SC1_IPMAIN_RW,
    MIU_CLIENT_GOP4_R,
    MIU_CLIENT_GOP5_R,
    MIU_CLIENT_GMAC_RW,
    MIU_CLIENT_SATA_RW,
    MIU_CLIENT_SC_LOCALDIMING_RW,
    MIU_CLIENT_JPD720P_RW,
    MIU_CLIENT_SC_IPM2_R,
    MIU_CLIENT_VIVALDI_DSC_R,
    MIU_CLIENT_TSP_JPD_RW,
    MIU_CLIENT_DEMOD_W,
    MIU_CLIENT_DEMOD_R,
    MIU_CLIENT_DEMOD_ADCDMA_W,
    MIU_CLIENT_GPU_RW,
    MIU_CLIENT_PDW1_RW,
    MIU_CLIENT_GPO0_PDW0_RW,
    MIU_CLIENT_EVD_R,
    MIU_CLIENT_EVD_RW,
    MIU_CLIENT_SC_FRCL_R,
    MIU_CLIENT_SC_FRCR_R,
    MIU_CLIENT_VD_VBI_RW, // do not use this client; use MIU_CLIENT_VD_TTXSL_W instead
    MIU_CLIENT_VD_MHEG5_ICACHE_RW,
    MIU_CLIENT_TSP00_RW,
    MIU_CLIENT_TSP01_RW,
    MIU_CLIENT_TSP02_RW,
    MIU_CLIENT_TSP03_RW,
    MIU_CLIENT_TSP04_RW,
    MIU_CLIENT_TSP05_RW,
    MIU_CLIENT_TSP06_RW,
    MIU_CLIENT_VIVALDI9_COMBINE_RW,
    MIU_CLIENT_TSP07_RW,
    MIU_CLIENT_ISDBT_TDI_R,
    MIU_CLIENT_ISDBT_TDI_W,
    MIU_CLIENT_FI_Queue0_WR,
    MIU_CLIENT_FI_Queue1_WR,
    MIU_CLIENT_SWDC_RW,
    MIU_CLIENT_ISDB1_RW,
    MIU_CLIENT_ISDB2_RW,
    MIU_CLIENT_MIIC3_RW,
    MIU_CLIENT_SECAU_R2_RW,
    MIU_CLIENT_SC_LOCALDIMING_R_RW,
    MIU_CLIENT_SC_LOCALDIMING_L_RW,
    MIU_CLIENT_SC0_L_RW,
    MIU_CLIENT_SC0_R_RW,
    MIU_CLIENT_TSP_FIQ_RW,
    MIU_CLIENT_EVD_R2D_RW,
    MIU_CLIENT_EVD_R2I_R,
    MIU_CLIENT_SECHVD_RW,
    MIU_CLIENT_SECEVD_RW,
    MIU_CLIENT_MFDEC_R,
    MIU_CLIENT_SECMFDEC_R,
    MIU_CLIENT_MIUTEST_R,
    MIU_CLIENT_GOP3_PDW0_RW,
    MIU_CLIENT_SC1_OPMAIN_RW,
    MIU_CLIENT_SC2_IPSUB_RW,
    MIU_CLIENT_SC_IPMAIN2_RW,
    MIU_CLIENT_SC2_OPMAIN_RW,
    MIU_CLIENT_SC_ODL_RW,
    MIU_CLIENT_SC_ODR_RW,
    MIU_CLIENT_SC1_IPSUB_RW,
    MIU_CLIENT_EVD_BBU_R,
    MIU_CLIENT_SC_DWIN_W,
    MIU_CLIENT_ZDEC_RW,
    MIU_CLIENT_ZDEC_ACP_RW,
    MIU_CLIENT_USB30_1_RW,
    MIU_CLIENT_USB30_2_RW,
    MIU_CLIENT_3RDHVD_RW,
    MIU_CLIENT_VP9_RW,
    MIU_CLIENT_FRC_R,
    MIU_CLIENT_FRCM_W,
    MIU_CLIENT_SC_OD_RW,
    MIU_CLIENT_SC_OPSUB_W,
    MIU_CLIENT_FRCS_W,
    MIU_CLIENT_EVD_MTFC_W,
    MIU_CLIENT_EVD_MTFY_W,
    MIU_CLIENT_ZDEC2_RW,
    MIU_CLIENT_SC2_IPMAIN_RW,
    MIU_CLIENT_MTF_W,
    MIU_CLIENT_DBG_R,
    MIU_CLIENT_DS_R,
    MIU_CLIENT_FRC_R2,
    MIU_CLIENT_MVD_RTO_RW,
    MIU_CLIENT_FRC_FSCM2_RW,
    MIU_CLIENT_FRC_FSCM3_RW,
    MIU_CLIENT_FRC_IPM0_W,
    MIU_CLIENT_FRC_IPM1_W,
    MIU_CLIENT_FRC_OPM0_R,
    MIU_CLIENT_FRC_OPM1_R,
    MIU_CLIENT_FRC_OPME0_R,
    MIU_CLIENT_FRC_OPME1_R,
    MIU_CLIENT_FRC_OPMI0_R,
    MIU_CLIENT_FRC_OPMI1_R,
    MIU_CLIENT_FRC_ME_W,
    MIU_CLIENT_FRC_ME_R,
    MIU_CLIENT_FRC_HR_W,
    MIU_CLIENT_FRC_HR_R,
    MIU_CLIENT_FRC_MI_MERGE_RW,
    MIU_CLIENT_MC2D_RW,
    MIU_CLIENT_CMD_QUEUE1_RW,
    MIU_CLIENT_USB_UHC4_RW,
    MIU_CLIENT_DEMOD_RW,
    MIU_CLIENT_VE_RW,
    MIU_CLIENT_SC_PDW_W,
    MIU_CLIENT_VIVALDI9_R2_ARB_RW,
    MIU_CLIENT_MCU51_DB_TOOL_RW,
    MIU_CLIENT_TSP_RW,
    MIU_CLIENT_TSP_ORZ2_RW,
    MIU_CLIENT_EVD_BBU_RW,
    MIU_CLIENT_DVBC_ADC_W,
    MIU_CLIENT_GMAC1_RW,
    MIU_CLIENT_MFE_RW,
    MIU_CLIENT_VD_R2_L_I_R,
    MIU_CLIENT_VD_R2_L_D_RW,
    MIU_CLIENT_CA_MIU_CROSSBAR_2_RW,
    MIU_CLIENT_TSP08_RW,
    MIU_CLIENT_ZDEC_LZDMA_RW,
    MIU_CLIENT_EVD2_BBU_R,
    MIU_CLIENT_GOP3_DWIN_RW,
    MIU_CLIENT_MVOP_256BIT_R,
    MIU_CLIENT_MFDEC1_R,
    MIU_CLIENT_SC_DYN_SCL_R,
    MIU_CLIENT_SC1_OPM_R,
    MIU_CLIENT_ZDEC_ACP_W,
    MIU_CLIENT_CMD_QUEUE_R,
    MIU_CLIENT_VIVALDI9_DECODER_RW,
    MIU_CLIENT_DEMOD_ADCDMA_RW,
    MIU_CLIENT_MIU_BIST,
    MIU_CLIENT_CA_MIU_CROSSBAR_0_RW,
    MIU_CLIENT_CA_MIU_CROSSBAR_1_RW,
    MIU_CLIENT_SECGMAC_RW,
    MIU_CLIENT_AU_R2_1_RW,
    MIU_CLIENT_TSO_1_RW,
    MIU_CLIENT_TSIO_RW,
    MIU_CLIENT_PCIE_OUTBOUND_RW,
    MIU_CLIENT_PCIE_INBOUND_RW,
    MIU_CLIENT_DDI_0_RW,
    MIU_CLIENT_SC_DIPW_1_RW,
    MIU_CLIENT_EVD_ENGINE1_RW,
    MIU_CLIENT_HVD_ENGINE1_RW,
    MIU_CLIENT_DDI_1_RW,
    MIU_CLIENT_MFDEC0_1_R,
    MIU_CLIENT_MFDEC1_1_R,
    MIU_CLIENT_AUTO_DOWNLOAD_R,
    MIU_CLIENT_MFEH_R,
    MIU_CLIENT_AUDIO_RW,
    MIU_CLIENT_OD_RW,
    MIU_CLIENT_MVOP1_256BIT_R,
    MIU_CLIENT_MVD_256BIT_RW,
    MIU_CLIENT_TSP_FILEIN_RW,
    MIU_CLIENT_TSP_SEC_RW,
    MIU_CLIENT_HDR_L_RW,
    MIU_CLIENT_HDR_R_RW,
    MIU_CLIENT_MIU_CMD_RW,
    MIU_CLIENT_G256_POST_ARB_RW,
    MIU_CLIENT_G128_POST_ARB_RW,
    MIU_CLIENT_G3_PRE_ARB_RW,
    MIU_CLIENT_EVD_2_MIU0_RW,
    MIU_CLIENT_EVD_2_MIU1_RW,
    MIU_CLIENT_DEMOD_MCU51_WR,
    MIU_CLIENT_DEMOD1_WR,
    MIU_CLIENT_DEMOD2_WR,
    MIU_CLIENT_DEMOD3_WR,
    MIU_CLIENT_DEMOD4_WR,
    MIU_CLIENT_DEMOD5_WR,
    MIU_CLIENT_DEMOD6_WR,
    MIU_CLIENT_TSO_TX_RW,
    MIU_CLIENT_TSO_RX_RW,
    MIU_CLIENT_SC_DIP_RW,
    MIU_CLIENT_SC_DIP_DI_RW,
    MIU_CLIENT_ADL_RW,
    //Add new after here
}eMIUClientID;

typedef enum
{
    //IP Access MIU0 only
    MIU_SELTYPE_MIU0 = 0,
    //IP Access MIU1 only
    MIU_SELTYPE_MIU1,
    //IP can access MIU0 & MIU1
    MIU_SELTYPE_MIU_ALL,
    //IP Access MIU2 only
    MIU_SELTYPE_MIU2,
    //IP Access MIU3 only
    MIU_SELTYPE_MIU3

}eMIU_SelType;

typedef struct
{
    MS_U8 u8Gp:4;
    MS_U8 u8BitPos:4;
}MIU_ClientInfo;

typedef struct DLL_PACKED
{
    MS_BOOL bHit;
    MS_U8   u8Group;
    MS_U8   u8ClientID;
    MS_U8   u8Block;
}MIU_PortectInfo;

typedef struct
{
    MS_U8   u81st;
    MS_U8   u82nd;
    MS_U8   u83rd;
    MS_U8   u84th;
}MIU_GroupPriority;

typedef enum
{
  E_MIU_0 = 0,
  E_MIU_1,
  E_MIU_2,
  E_MIU_3,
  E_MIU_NUM,
} MIU_ID;

typedef enum
{
  E_MIU_DDR_32MB = 0,
  E_MIU_DDR_64MB,
  E_MIU_DDR_128MB,
  E_MIU_DDR_256MB,
  E_MIU_DDR_512MB,
  E_MIU_DDR_1024MB,
  E_MIU_DDR_2048MB,
  E_MIU_DDR_4096MB,
  E_MIU_DDR_8192MB,
}MIU_DDR_SIZE;

typedef enum
{
  E_MIU_DDR3,
  E_MIU_DDR4
}MIU_DDR_TYPE;

typedef enum
{
  E_MIU_CLIENT_64BIT = 0,
  E_MIU_CLIENT_128BIT,
  E_MIU_CLIENT_256BIT,
}eMIU_ClientWidth;

#define MST_MACRO_START     do {
#define MST_MACRO_END       } while (0)


#define set_client_info(client_data,miu_pos,id_code)         \
        MST_MACRO_START                                      \
        client_data->miu = miu_pos;                          \
        client_data->protect_id = id_code;                   \
        MST_MACRO_END


//-------------------------------------------------------------------------------------------------
// Extern Global Variabls
//-------------------------------------------------------------------------------------------------

////////////////////////////////////////////////////////////////////////////////
// include utopia v2  header files here
////////////////////////////////////////////////////////////////////////////////
#include "drvMIU_v2.h"

//-------------------------------------------------------------------------------------------------
// Extern Functions
//-------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_ToBeRemove
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
void    MDrv_MIU_Mask_Req_OPM_R(MS_U8 u8Mask, MS_U8 u8Miu);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_ToBeRemove
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
void    MDrv_MIU_Mask_Req_DNRB_R(MS_U8 u8Mask, MS_U8 u8Miu);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_ToBeRemove
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
void    MDrv_MIU_Mask_Req_DNRB_W(MS_U8 u8Mask, MS_U8 u8Miu);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_ToBeRemove
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
void    MDrv_MIU_Mask_Req_DNRB_RW(MS_U8 u8Mask, MS_U8 u8Miu);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_ToBeRemove
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
void    MDrv_MIU_Mask_Req_SC_RW(MS_U8 u8Mask, MS_U8 u8Miu);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_ToBeRemove
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
void    MDrv_MIU_Mask_Req_MVOP_R(MS_U8 u8Mask, MS_U8 u8Miu);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_ToBeRemove
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
void    MDrv_MIU_Mask_Req_MVD_R(MS_U8 u8Mask, MS_U8 u8Miu);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_ToBeRemove
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
void    MDrv_MIU_Mask_Req_MVD_W(MS_U8 u8Mask, MS_U8 u8Miu);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_ToBeRemove
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
void    MDrv_MIU_Mask_Req_MVD_RW(MS_U8 u8Mask, MS_U8 u8Miu);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_ToBeRemove
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
void    MDrv_MIU_Mask_Req_AUDIO_RW(MS_U8 u8Mask, MS_U8 u8Miu);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_CONTROL
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
void    MDrv_MIU_MaskReq(MS_U8 u8Miu, eMIUClientID eClientID);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_CONTROL
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
void    MDrv_MIU_UnMaskReq(MS_U8 u8Miu, eMIUClientID eClientID);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_INIT
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
void    MDrv_MIU_InitCounter(void);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_ToBeRemove
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
void    MDrv_MIU_VOP_SwitchMIU(MS_U8 u8MiuID);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_PROTECT
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
void    MDrv_MIU_PrintMIUProtectInfo(void);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_PROTECT
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_U8*  MDrv_MIU_GetDefaultClientID_KernelProtect(void);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_CONTROL
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_U16  MDrv_MIU_GetBusWidth(void);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_CONTROL
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_SetSsc(MS_U16 u16Fmodulation, MS_U16 u16FDeviation,MS_BOOL bEnable);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_CONTROL
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_SetSscValue(MS_U8 u8MiuDev, MS_U16 u16Fmodulation, MS_U16 u16FDeviation, MS_BOOL bEnable);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_COMMON
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_GetClientID(euMIUClientIDTYPE client_name, stMIUClientID_t *client_read, stMIUClientID_t *client_write);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_CONTROL
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_Mask(euMIUClientIDTYPE client_name);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_CONTROL
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_Unmask(euMIUClientIDTYPE client_name);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_CONTROL
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_MaskByPort(euMIUClientIDTYPE client_name,stMIUClientID_t *ByPort);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_CONTROL
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_UnmaskByPort(euMIUClientIDTYPE client_name,stMIUClientID_t *ByPort);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_ToBeRemove
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_SetIOMapBase(void);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_PROTECT
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_ProtectAlign(MS_U32 *u32PageShift);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_COMMON
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_Dram_Size(MS_U8 MiuID, MS_U8 DramSize);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_COMMON
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_Dram_ReadSize(MS_U8 MiuID, MIU_DDR_SIZE *pDramSize);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_COMMON
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_U8 MDrv_MIU_ClinetNumber(MS_U8 u8Blockx);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_PROTECT
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_Protect( MS_U8 u8Blockx, MS_U8 *pu8ProtectId, MS_PHY phyStart, MS_PHY phyEnd, MS_BOOL bSetFlag );

MS_BOOL MDrv_MIU_ProtectEx( MS_U8 u8Blockx, MS_U32 *pu32ProtectId, MS_PHY phy64Start, MS_PHY phy64End, MS_BOOL bSetFlag );
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_COMMON
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_IsSupportMIU1(void);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_CONTROL
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_SelMIU(eMIUClientID eClientID, eMIU_SelType eType);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_COMMON
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_GetClientInfo(MS_U8 u8MiuDev, eMIUClientID eClientID, MIU_ClientInfo *pInfo);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_PROTECT
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_GetProtectInfo(MS_U8 u8MiuDev, MIU_PortectInfo *pInfo);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_COMMON
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_SetGroupPriority(MS_U8 u8MiuDev, MIU_GroupPriority sPriority);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_COMMON
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_SetHPriorityMask(MS_U8 u8MiuDev, eMIUClientID eClientID, MS_BOOL bMask);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_COMMON
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_GetLibVer(const MSIF_Version **ppVersion);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_CONTROL
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_EnableScramble(MS_BOOL bEnable);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_CONTROL
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_IsScrambleEnabled(void);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_COMMON
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_GetLoading(MS_U8 u8MiuDev, MS_U32 *Loading);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_INIT
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_Init(void);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_COMMON
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_U32 MDrv_MIU_SetPowerState(EN_POWER_MODE u16PowerState);
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_COMMON
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
MS_BOOL MDrv_MIU_GetClientWidth(MS_U8 u8MiuDevi, eMIUClientID eClientID, eMIU_ClientWidth *pClientWidth);

MS_BOOL MDrv_MIU_GetDramType(MIU_ID eMiu, MIU_DDR_TYPE* pType);

#ifdef _MIU_INTERNEL_USE
//-------------------------------------------------------------------------------------------------
/// MOBF Encrypt
/// @ingroup G_MIU_COMMON
/// @param u32Key \b IN: Key
/// @param bEnable \b IN: TRUE/FLASE
/// @return DRVAESDMA_OK : Success
/// @return Others : Fail
//-------------------------------------------------------------------------------------------------
DLL_PUBLIC MS_BOOL MDrv_MIU_GetLoading(MS_U8 u8MiuDev, MS_U32 *Loading);
#endif

#ifdef __cplusplus
}
#endif

#endif // _DRV_MIU_H_