//<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>
///////////////////////////////////////////////////////////////////////////////////////////////////
///
/// file    adpCEC.c
/// @author MStar Semiconductor Inc.
/// @brief  CEC driver Function
///////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef _ADP_CEC_C_
#define _ADP_CEC_C_

//-------------------------------------------------------------------------------------------------
//  Include Files
//-------------------------------------------------------------------------------------------------
// Common Definition
#include "MsCommon.h"
#include "MsVersion.h"
#include "MsDevice.h"
#include <linux/kernel.h>
#include <linux/sched.h>

#ifdef MSOS_TYPE_LINUX_KERNEL
#include <linux/string.h>
#else
#include <string.h>
#endif

#include <linux/slab.h>
#include <asm/uaccess.h>
#include <linux/compat.h>

#include "utopia.h"
#include "utopia_dapi.h"
#include "utopia_adp.h"

#include "adpCEC.h"
#include "apiCEC.h"

//-------------------------------------------------------------------------------------------------
//  Local Defines
//-------------------------------------------------------------------------------------------------
#if(defined(CONFIG_MLOG))
#include "ULog.h"

#define MADP_CEC_MSG_INFO(format, args...)      ULOGI("CEC", format, ##args)
#define MADP_CEC_MSG_WARNING(format, args...)   ULOGW("CEC", format, ##args)
#define MADP_CEC_MSG_DEBUG(format, args...)     ULOGD("CEC", format, ##args)
#define MADP_CEC_MSG_ERROR(format, args...)     ULOGE("CEC", format, ##args)
#define MADP_CEC_MSG_FATAL(format, args...)     ULOGF("CEC", format, ##args)

#else
#define MADP_CEC_MSG_INFO(format, args...)      printf(format, ##args)
#define MADP_CEC_MSG_WARNING(format, args...)   printf(format, ##args)
#define MADP_CEC_MSG_DEBUG(format, args...)     printf(format, ##args)
#define MADP_CEC_MSG_ERROR(format, args...)     printf(format, ##args)
#define MADP_CEC_MSG_FATAL(format, args...)     printf(format, ##args)

#endif

#ifdef MSOS_TYPE_LINUX_KERNEL
#define CPY_FROM_USER(a,b,c)                    if(copy_from_user(a,b,c) != 0) { break; }
#define CPY_TO_USER(a,b,c)                      if(copy_to_user(a,b,c) != 0) { break; }
#else
#define CPY_FROM_USER                           memcpy
#define CPY_TO_USER                             memcpy
#endif  //MSOS_TYPE_LINUX_KERNEL

#if (defined(MSOS_TYPE_LINUX_KERNEL) && defined(CONFIG_COMPAT))
#define COMPAT_PTR(a)                           compat_ptr(a)
#define COMPAT_NEXT_PTR(a)                      (*((MS_U32*)compat_ptr((unsigned long)a)))
#define IS_CMP_TASK()                           is_compat_task()
#define CMP_CPY_FROM_USER(a,b,c)                if(copy_from_user(a, compat_ptr((unsigned long)b), c) != 0)  {  break; }
#define CMP_CPY_TO_USER(a,b,c)                  if(copy_to_user(compat_ptr((unsigned long)a), b, c) != 0) { break;  }
#define MS_COMPAT_CEC                           compat_uptr_t

#else 
#define COMPAT_PTR(a)                           (a)
#define COMPAT_NEXT_PTR(a)                      (*((MS_U32*)a))
#define IS_CMP_TASK()                           (FALSE)
#define CMP_CPY_FROM_USER                       CPY_FROM_USER
#define CMP_CPY_TO_USER                         CPY_TO_USER
#define MS_COMPAT_CEC                           MS_U8*

#endif //CONFIG_COMPAT

//-------------------------------------------------------------------------------------------------
//  Local Structures
//-------------------------------------------------------------------------------------------------
typedef struct DLL_PACKED
{
    MsCEC_DEVICELA eDetAddr;
    MsCEC_MSGLIST eMsg;
    MS_COMPAT_CEC ucCmd;
    MS_U8 ucLen;
    CEC_ERROR_CODE eErrorCode;
} stCEC_TX_SEND_MSG_COMPAT, *pstCEC_TX_SEND_MSG_COMPAT;

typedef struct DLL_PACKED
{
    MsCEC_DEVICELA eDetAddr;
    MsCEC_MSGLIST eMsg;
    MS_COMPAT_CEC ucCmd;
    MS_U8 ucLen;
    CEC_ERROR_CODE eErrorCode;
} stCEC_TX_SEND_MSG2_COMPAT, *pstCEC_TX_SEND_MSG2_COMPAT;

//-------------------------------------------------------------------------------------------------
//  Global Variables
//-------------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------------
//  Local Variables
//-------------------------------------------------------------------------------------------------
UADP_SPT_NAMEnNXT_DEF(CEC_MS_U8, 0);
// MAPI_CMD_DDC2BI_GET_INFO -- stCEC_DDC2BI_GET_INFO -- MS_CEC_INFO_LIST
UADP_SPT_NAMEnNXT_DEF(CEC_MS_CEC_INFO_LIST, 0);
UADP_SPT_NAMEnNXT_DEF(CEC_DDC2BI_GET_INFO, 1);
// MAPI_CMD_CEC_INIT_CHIP -- stCEC_INIT_CHIP
UADP_SPT_NAMEnNXT_DEF(CEC_INIT_CHIP, 0);
// MAPI_CMD_CEC_PORT_SELECT -- stCEC_PORT_SELECT
UADP_SPT_NAMEnNXT_DEF(CEC_PORT_SELECT, 0);
// MAPI_CMD_CEC_SET_MY_LOGICAL_ADDRESS -- stCEC_SET_MY_LOGICAL_ADDRESS
UADP_SPT_NAMEnNXT_DEF(CEC_SET_MY_LOGICAL_ADDRES, 0);
// MAPI_CMD_CEC_INIT -- stCEC_INIT
UADP_SPT_NAMEnNXT_DEF(CEC_INIT, 0);
// MAPI_CMD_CEC_NEXT_DEVICE -- stCEC_NEXT_DEVICE
UADP_SPT_NAMEnNXT_DEF(CEC_NEXT_DEVICE, 0);
// MAPI_CMD_CEC_TX_SEND_POLLING_MSG -- stCEC_TX_SEND_POLLING_MSG
UADP_SPT_NAMEnNXT_DEF(CEC_TX_SEND_POLLING_MSG, 0);
// MAPI_CMD_CEC_MSG_ACTIVE_SOURCE -- stCEC_MSG_ACTIVE_SOURCE
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_ACTIVE_SOURCE, 0);
// MAPI_CMD_CEC_MSG_ROUTING_CHANGE -- stCEC_MSG_ROUTING_CHANGE
UADP_SPT_NAMEnNXT_DEF(CEC_PHYSICAL_ADDRESS_TABLE, 0);
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_ROUTING_CHANGE, 2);
// MAPI_CMD_CEC_MSG_REQ_ACTIVE_SOURCE -- stCEC_MSG_REQ_ACTIVE_SOURCE
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REQ_ACTIVE_SOURCE, 0);
// MAPI_CMD_CEC_MSG_SET_STREAM_PATH -- stCEC_MSG_SET_STREAM_PATH
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_SET_STREAM_PATH, 1);
// MAPI_CMD_CEC_MSG_STANDBY -- stCEC_MSG_STANDBY
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_STANDBY, 0);
// MAPI_CMD_CEC_MSG_RECORD_OFF -- stCEC_MSG_RECORD_OFF
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_RECORD_OFF, 0);
// MAPI_CMD_CEC_MSG_RECORD_ON -- stCEC_MSG_RECORD_ON
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_RECORD_ON, 0);
// MAPI_CMD_CEC_MSG_REPORT_CEC_VERSION -- stCEC_MSG_REPORT_CEC_VERSION
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REPORT_CEC_VERSION, 0);
// MAPI_CMD_CEC_MSG_REQ_CEC_VERSION -- stCEC_MSG_REQ_CEC_VERSION
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REQ_CEC_VERSION, 0);
// MAPI_CMD_CEC_MSG_REPORT_PHYCAL_ADDRESS -- stCEC_MSG_REPORT_PHYCAL_ADDRESS
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REPORT_PHYCAL_ADDRESS, 0);
// MAPI_CMD_CEC_MSG_REQ_PHYCAL_ADDRESS -- stCEC_MSG_REQ_PHYCAL_ADDRESS
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REQ_PHYCAL_ADDRESS, 0);
// MAPI_CMD_CEC_MSG_DECK_CONTROL -- stCEC_MSG_DECK_CONTROL
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_DECK_CONTROL, 0);
// MAPI_CMD_CEC_MSG_DEC_STATUS -- stCEC_MSG_DEC_STATUS
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_DEC_STATUS, 0);
// MAPI_CMD_CEC_MSG_GIVE_DECK_STATUS -- stCEC_MSG_GIVE_DECK_STATUS
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_GIVE_DECK_STATUS, 0);
// MAPI_CMD_CEC_MSG_DC_PLAY -- stCEC_MSG_DC_PLAY
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_DC_PLAY, 0);
// MAPI_CMD_CEC_MSG_REQ_MENU_STATUS -- stCEC_MSG_REQ_MENU_STATUS
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REQ_MENU_STATUS, 0);
// MAPI_CMD_CEC_MSG_USER_CTRL_PRESSED -- stCEC_MSG_USER_CTRL_PRESSED
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_USER_CTRL_PRESSED, 0);
// MAPI_CMD_CEC_MSG_USER_CTRL_RELEASED -- stCEC_MSG_USER_CTRL_RELEASED
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_USER_CTRL_RELEASED, 0);
// MAPI_CMD_CEC_MSG_GIVE_AUDIO_STATUS -- stCEC_MSG_GIVE_AUDIO_STATUS
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_GIVE_AUDIO_STATUS, 0);
// MAPI_CMD_CEC_MSG_REPORT_POWER_STATUS -- stCEC_MSG_REPORT_POWER_STATUS
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REPORT_POWER_STATUS, 0);
// MAPI_CMD_CEC_MSG_REQ_POWER_STATUS -- stCEC_MSG_REQ_POWER_STATUS
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REQ_POWER_STATUS, 0);
// MAPI_CMD_CEC_MSG_FEATURE_ABORT -- stCEC_MSG_FEATURE_ABORT
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_FEATURE_ABORT, 0);
// MAPI_CMD_CEC_MSG_ABORT -- stCEC_MSG_ABORT
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_ABORT, 0);
// MAPI_CMD_CEC_MSG_SEND_MENU_LANGUAGE -- stCEC_MSG_SEND_MENU_LANGUAGE
UADP_SPT_NAMEnNXT_DEF(CEC_MENU_LANGUAGE_CODE_TABLE, 0);
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_SEND_MENU_LANGUAGE, 1);
// MAPI_CMD_CEC_MSG_REQ_ARC_INITIATION -- stCEC_MSG_REQ_ARC_INITIATION
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REQ_ARC_INITIATION, 0);
// MAPI_CMD_CEC_MSG_REQ_ARC_TERMINATION -- stCEC_MSG_REQ_ARC_TERMINATION
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REQ_ARC_TERMINATION, 0);
// MAPI_CMD_CEC_MSG_AUDIO_MODE_REQ -- stCEC_MSG_AUDIO_MODE_REQ
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_AUDIO_MODE_REQ, 1);
// MAPI_CMD_CEC_MSG_REPORT_PHYCAL_ADDRESS2 -- stCEC_MSG_REPORT_PHYCAL_ADDRESS2
UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REPORT_PHYCAL_ADDRESS2, 0);
// MAPI_CMD_CEC_CHECK_FRAME -- stCEC_CHECK_FRAME
UADP_SPT_NAMEnNXT_DEF(CEC_CHECK_FRAME, 0);
// MAPI_CMD_CEC_ENABLED -- stCEC_ENABLED
UADP_SPT_NAMEnNXT_DEF(CEC_ENABLED, 0);
// MAPI_CMD_CEC_GET_TX_STATUS -- stCEC_GET_TX_STATUS
UADP_SPT_NAMEnNXT_DEF(CEC_GET_TX_STATUS, 0);
// MAPI_CMD_CEC_CHECK_DEVICE_IS_TX -- stCEC_DEVICE_IS_TX
UADP_SPT_NAMEnNXT_DEF(CEC_DEVICE_IS_TX, 0);
// MAPI_CMD_CEC_SET_POWER_STATE -- stCEC_SET_POWER_STATE
UADP_SPT_NAMEnNXT_DEF(CEC_SET_POWER_STATE, 0);
// MAPI_CMD_CEC_SET_MY_LOGICAL_ADDRESS2 -- stCEC_SET_MY_LOGICAL_ADDRESS2
UADP_SPT_NAMEnNXT_DEF(CEC_SET_MY_LOGICAL_ADDRESS2, 0);
// MAPI_CMD_CEC_GET_HEADER -- stCEC_GET_HEADER
UADP_SPT_NAMEnNXT_DEF(CEC_GET_HEADER, 0);
// MAPI_CMD_CEC_GET_OPCODE -- stCEC_GET_OPCODE
UADP_SPT_NAMEnNXT_DEF(CEC_GET_OPCODE, 0);
// MAPI_CMD_CEC_GET_PARA -- stCEC_GET_PARA
UADP_SPT_NAMEnNXT_DEF(CEC_GET_PARA, 0);
// MAPI_CMD_CEC_GET_CMD_LEN -- stCEC_GET_CMD_LEN
UADP_SPT_NAMEnNXT_DEF(CEC_GET_CMD_LEN, 0);
// MAPI_CMD_CEC_IS_RX_BUF_EMPTY -- stCEC_IS_RX_BUF_EMPTY
UADP_SPT_NAMEnNXT_DEF(CEC_IS_RX_BUF_EMPTY, 0);
// MAPI_CMD_CEC_SET_ACTIVE_LOGICAL_ADDRESS -- stCEC_SET_ACTIVE_LOGICAL_ADDRESS
UADP_SPT_NAMEnNXT_DEF(CEC_SET_ACTIVE_LOGICAL_ADDRESS, 0);
// MAPI_CMD_CEC_GET_ACTIVE_LOGICAL_ADDRESS -- stCEC_GET_ACTIVE_LOGICAL_ADDRESS
UADP_SPT_NAMEnNXT_DEF(CEC_GET_ACTIVE_LOGICAL_ADDRESS, 0);
// MAPI_CMD_CEC_GET_POWER_STATUS -- stCEC_GET_POWER_STATUS
UADP_SPT_NAMEnNXT_DEF(CEC_GET_POWER_STATUS, 0);
// MAPI_CMD_CEC_GET_FIFO_IDX -- stCEC_GET_FIFO_IDX
UADP_SPT_NAMEnNXT_DEF(CEC_GET_FIFO_IDX, 0);
// MAPI_CMD_CEC_SET_FIFO_IDX -- stCEC_SET_FIFO_IDX
UADP_SPT_NAMEnNXT_DEF(CEC_SET_FIFO_IDX, 0);
// MAPI_CMD_CEC_SET_ACTIVE_POWER_STATUS -- stCEC_SET_ACTIVE_POWER_STATUS
UADP_SPT_NAMEnNXT_DEF(CEC_SET_ACTIVE_POWER_STATUS, 0);
// MAPI_CMD_CEC_GET_ACTIVE_POWER_STATUS -- stCEC_GET_ACTIVE_POWER_STATUS
UADP_SPT_NAMEnNXT_DEF(CEC_GET_ACTIVE_POWER_STATUS, 0);
// MAPI_CMD_CEC_SET_ACTIVE_PHYSICAL_ADDRESS -- stCEC_SET_ACTIVE_PHYSICAL_ADDRESS
UADP_SPT_NAMEnNXT_DEF(CEC_SET_ACTIVE_PHYSICAL_ADDRESS, 0);
// MAPI_CMD_CEC_SET_ACTIVE_DEVICE_CEC_VERSION -- stCEC_SET_ACTIVE_DEVICE_CEC_VERSION
UADP_SPT_NAMEnNXT_DEF(CEC_SET_ACTIVE_DEVICE_CEC_VERSION, 0);
// MAPI_CMD_CEC_SET_ACTIVE_DEVICE_TYPE -- stCEC_SET_ACTIVE_DEVICE_TYPE
UADP_SPT_NAMEnNXT_DEF(CEC_SET_ACTIVE_DEVICE_TYPE, 0);
// MAPI_CMD_CEC_GET_MSG_CNT -- stCEC_GET_MSG_CNT
UADP_SPT_NAMEnNXT_DEF(CEC_GET_MSG_CNT, 0);
// MAPI_CMD_CEC_SET_MSG_CNT -- stCEC_SET_MSG_CNT
UADP_SPT_NAMEnNXT_DEF(CEC_SET_MSG_CNT, 0);
// MAPI_CMD_CEC_GET_RX_DATA -- stCEC_GET_RX_DATA
UADP_SPT_NAMEnNXT_DEF(CEC_GET_RX_DATA, 0);
// MAPI_CMD_CEC_SET_MY_PHYSICAL_ADDRESS -- stCEC_SET_MY_PHYSICAL_ADDRESS
UADP_SPT_NAMEnNXT_DEF(CEC_SET_MY_PHYSICAL_ADDRESS, 1);
// MAPI_CMD_CEC_SET_MY_PHYSICAL_ADDRESS2 -- stCEC_SET_MY_PHYSICAL_ADDRESS2
UADP_SPT_NAMEnNXT_DEF(CEC_SET_MY_PHYSICAL_ADDRESS2, 1);
// MAPI_CMD_CEC_SET_INITIATOR -- stCEC_SET_INITIATOR
UADP_SPT_NAMEnNXT_DEF(CEC_SET_INITIATOR, 0);
// MAPI_CMD_CEC_CONFIG_WAKEUP_INFO_VENDOR_ID -- stCEC_CONFIG_WAKEUP_INFO_VENDOR_ID
UADP_SPT_NAMEnNXT_DEF(CEC_VENDOR_ID_TABLE, 0);
UADP_SPT_NAMEnNXT_DEF(CEC_CONFIG_WAKEUP_INFO_VENDOR_ID, 1);
// MAPI_CMD_CEC_SET_RETRY_COUNT -- stCEC_SET_RETRY_COUNT
UADP_SPT_NAMEnNXT_DEF(CEC_SET_RETRY_COUNT, 0);
// MAPI_CMD_CEC_ATTACH_DRIVER_ISR -- stCEC_ATTACH_DRIVER_ISR
UADP_SPT_NAMEnNXT_DEF(CEC_ATTACH_DRIVER_ISR, 0);
// MAPI_CMD_CEC_GET_CONFIGURATION -- stCEC_GET_CONFIGURATION
UADP_SPT_NAMEnNXT_DEF(CEC_GET_CONFIGURATION, 0);

//-------------------------------------------------------------------------------------------------
//  Local Functions
//-------------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------------------
//  Global Functions
//-------------------------------------------------------------------------------------------------

//**************************************************************************
//  [Function Name]:
//                  CEC_adp_Init()
//  [Description]
//                  
//  [Arguments]:
//
//  [Return]:
//
//**************************************************************************
MS_U32 CEC_adp_Init(FUtopiaIOctl* pIoctl)
{
    MS_U32 ulDataSize = 0;
	
	UADP_SPT_NAME0NXT(CEC_MS_U8, MS_U8);
    // MAPI_CMD_DDC2BI_GET_INFO
    UADP_SPT_NAME0NXT(CEC_MS_CEC_INFO_LIST, MS_CEC_INFO_LIST);
    UADP_SPT_NAME1NXT(CEC_DDC2BI_GET_INFO, stCEC_DDC2BI_GET_INFO, eInfo, CEC_MS_CEC_INFO_LIST);
	// MAPI_CMD_CEC_INIT_CHIP
	UADP_SPT_NAME0NXT(CEC_INIT_CHIP, stCEC_INIT_CHIP);
	// MAPI_CMD_CEC_PORT_SELECT
	UADP_SPT_NAME0NXT(CEC_PORT_SELECT, stCEC_PORT_SELECT);
	// MAPI_CMD_CEC_SET_MY_LOGICAL_ADDRESS
	UADP_SPT_NAME0NXT(CEC_SET_MY_LOGICAL_ADDRES, stCEC_SET_MY_LOGICAL_ADDRESS);
	// MAPI_CMD_CEC_INIT
	UADP_SPT_NAME0NXT(CEC_INIT, stCEC_INIT);
	// MAPI_CMD_CEC_NEXT_DEVICE
	UADP_SPT_NAME0NXT(CEC_NEXT_DEVICE, stCEC_NEXT_DEVICE);
	// MAPI_CMD_CEC_TX_SEND_POLLING_MSG
	UADP_SPT_NAME0NXT(CEC_TX_SEND_POLLING_MSG, stCEC_TX_SEND_POLLING_MSG);
	// MAPI_CMD_CEC_MSG_ACTIVE_SOURCE
	UADP_SPT_NAME0NXT(CEC_MSG_ACTIVE_SOURCE, stCEC_MSG_ACTIVE_SOURCE);
	// MAPI_CMD_CEC_MSG_ROUTING_CHANGE
    ulDataSize = sizeof(MS_U8) * CEC_PHY_ADDR_COUNT;
    UADP_SPT_BGN(&spt_CEC_PHYSICAL_ADDRESS_TABLE[0], ulDataSize);
    UADP_SPT_FIN(&spt_CEC_PHYSICAL_ADDRESS_TABLE[1]);
	UADP_SPT_NAME2NXT(CEC_MSG_ROUTING_CHANGE, stCEC_MSG_ROUTING_CHANGE, ucOrigAddr, CEC_PHYSICAL_ADDRESS_TABLE, ucNewAddr, CEC_PHYSICAL_ADDRESS_TABLE);
	// MAPI_CMD_CEC_MSG_REQ_ACTIVE_SOURCE
	UADP_SPT_NAME0NXT(CEC_MSG_REQ_ACTIVE_SOURCE, stCEC_MSG_REQ_ACTIVE_SOURCE);
	// MAPI_CMD_CEC_MSG_SET_STREAM_PATH
	UADP_SPT_NAME1NXT(CEC_MSG_SET_STREAM_PATH, stCEC_MSG_SET_STREAM_PATH, ucNewAddr, CEC_PHYSICAL_ADDRESS_TABLE);
	// MAPI_CMD_CEC_MSG_STANDBY
	UADP_SPT_NAME0NXT(CEC_MSG_STANDBY, stCEC_MSG_STANDBY);
	// MAPI_CMD_CEC_MSG_RECORD_OFF
	UADP_SPT_NAME0NXT(CEC_MSG_RECORD_OFF, stCEC_MSG_RECORD_OFF);
	// MAPI_CMD_CEC_MSG_RECORD_ON
	UADP_SPT_NAME0NXT(CEC_MSG_RECORD_ON, stCEC_MSG_RECORD_ON);
	// MAPI_CMD_CEC_MSG_REPORT_CEC_VERSION
	UADP_SPT_NAME0NXT(CEC_MSG_REPORT_CEC_VERSION, stCEC_MSG_REPORT_CEC_VERSION);
	// MAPI_CMD_CEC_MSG_REQ_CEC_VERSION
	UADP_SPT_NAME0NXT(CEC_MSG_REQ_CEC_VERSION, stCEC_MSG_REQ_CEC_VERSION);
	// MAPI_CMD_CEC_MSG_REPORT_PHYCAL_ADDRESS
	UADP_SPT_NAME0NXT(CEC_MSG_REPORT_PHYCAL_ADDRESS, stCEC_MSG_REPORT_PHYCAL_ADDRESS);
	// MAPI_CMD_CEC_MSG_REQ_PHYCAL_ADDRESS
	UADP_SPT_NAME0NXT(CEC_MSG_REQ_PHYCAL_ADDRESS, stCEC_MSG_REQ_PHYCAL_ADDRESS);
	// MAPI_CMD_CEC_MSG_DECK_CONTROL
	UADP_SPT_NAME0NXT(CEC_MSG_DECK_CONTROL, stCEC_MSG_DECK_CONTROL);
	// MAPI_CMD_CEC_MSG_DEC_STATUS
	UADP_SPT_NAME0NXT(CEC_MSG_DEC_STATUS, stCEC_MSG_DEC_STATUS);
	// MAPI_CMD_CEC_MSG_GIVE_DECK_STATUS
	UADP_SPT_NAME0NXT(CEC_MSG_GIVE_DECK_STATUS, stCEC_MSG_GIVE_DECK_STATUS);
	// MAPI_CMD_CEC_MSG_DC_PLAY
	UADP_SPT_NAME0NXT(CEC_MSG_DC_PLAY, stCEC_MSG_DC_PLAY);
	// MAPI_CMD_CEC_MSG_REQ_MENU_STATUS
	UADP_SPT_NAME0NXT(CEC_MSG_REQ_MENU_STATUS, stCEC_MSG_REQ_MENU_STATUS);
	// MAPI_CMD_CEC_MSG_USER_CTRL_PRESSED
	UADP_SPT_NAME0NXT(CEC_MSG_USER_CTRL_PRESSED, stCEC_MSG_USER_CTRL_PRESSED);
	// MAPI_CMD_CEC_MSG_USER_CTRL_RELEASED
	UADP_SPT_NAME0NXT(CEC_MSG_USER_CTRL_RELEASED, stCEC_MSG_USER_CTRL_RELEASED);
	// MAPI_CMD_CEC_MSG_GIVE_AUDIO_STATUS
	UADP_SPT_NAME0NXT(CEC_MSG_GIVE_AUDIO_STATUS, stCEC_MSG_GIVE_AUDIO_STATUS);
	// MAPI_CMD_CEC_MSG_REPORT_POWER_STATUS
	UADP_SPT_NAME0NXT(CEC_MSG_REPORT_POWER_STATUS, stCEC_MSG_REPORT_POWER_STATUS);
	// MAPI_CMD_CEC_MSG_REQ_POWER_STATUS
	UADP_SPT_NAME0NXT(CEC_MSG_REQ_POWER_STATUS, stCEC_MSG_REQ_POWER_STATUS);
	// MAPI_CMD_CEC_MSG_FEATURE_ABORT
	UADP_SPT_NAME0NXT(CEC_MSG_FEATURE_ABORT, stCEC_MSG_FEATURE_ABORT);
	// MAPI_CMD_CEC_MSG_ABORT
	UADP_SPT_NAME0NXT(CEC_MSG_ABORT, stCEC_MSG_ABORT);
	// MAPI_CMD_CEC_MSG_SEND_MENU_LANGUAGE
    ulDataSize = sizeof(MS_U8) * CEC_MENU_LANGUAGE_COUNT;
    UADP_SPT_BGN(&spt_CEC_MENU_LANGUAGE_CODE_TABLE[0], ulDataSize);
    UADP_SPT_FIN(&spt_CEC_MENU_LANGUAGE_CODE_TABLE[1]);
	UADP_SPT_NAME1NXT(CEC_MSG_SEND_MENU_LANGUAGE, stCEC_MSG_SEND_MENU_LANGUAGE, pu8MenulanguageCode, CEC_MENU_LANGUAGE_CODE_TABLE);
	// MAPI_CMD_CEC_MSG_REQ_ARC_INITIATION
	UADP_SPT_NAME0NXT(CEC_MSG_REQ_ARC_INITIATION, stCEC_MSG_REQ_ARC_INITIATION);
	// MAPI_CMD_CEC_MSG_REQ_ARC_TERMINATION
	UADP_SPT_NAME0NXT(CEC_MSG_REQ_ARC_TERMINATION, stCEC_MSG_REQ_ARC_TERMINATION);
	// MAPI_CMD_CEC_MSG_AUDIO_MODE_REQ
	UADP_SPT_NAME1NXT(CEC_MSG_AUDIO_MODE_REQ, stCEC_MSG_AUDIO_MODE_REQ, ucMyAddress, CEC_PHYSICAL_ADDRESS_TABLE);
	// MAPI_CMD_CEC_MSG_REPORT_PHYCAL_ADDRESS2
	UADP_SPT_NAME0NXT(CEC_MSG_REPORT_PHYCAL_ADDRESS2, stCEC_MSG_REPORT_PHYCAL_ADDRESS2);
	// MAPI_CMD_CEC_CHECK_FRAME
	UADP_SPT_NAME0NXT(CEC_CHECK_FRAME, stCEC_CHECK_FRAME);
	// MAPI_CMD_CEC_ENABLED
	UADP_SPT_NAME0NXT(CEC_ENABLED, stCEC_ENABLED);
	// MAPI_CMD_CEC_GET_TX_STATUS
	UADP_SPT_NAME0NXT(CEC_GET_TX_STATUS, stCEC_GET_TX_STATUS);
	// MAPI_CMD_CEC_CHECK_DEVICE_IS_TX
	UADP_SPT_NAME0NXT(CEC_DEVICE_IS_TX, stCEC_DEVICE_IS_TX);
	// MAPI_CMD_CEC_SET_POWER_STATE
	UADP_SPT_NAME0NXT(CEC_SET_POWER_STATE, stCEC_SET_POWER_STATE);
	// MAPI_CMD_CEC_SET_MY_LOGICAL_ADDRESS2
	UADP_SPT_NAME0NXT(CEC_SET_MY_LOGICAL_ADDRESS2, stCEC_SET_MY_LOGICAL_ADDRESS2);
	// MAPI_CMD_CEC_GET_HEADER
	UADP_SPT_NAME0NXT(CEC_GET_HEADER, stCEC_GET_HEADER);
	// MAPI_CMD_CEC_GET_OPCODE
	UADP_SPT_NAME0NXT(CEC_GET_OPCODE, stCEC_GET_OPCODE);
	// MAPI_CMD_CEC_GET_PARA
	UADP_SPT_NAME0NXT(CEC_GET_PARA, stCEC_GET_PARA);
	// MAPI_CMD_CEC_GET_CMD_LEN
	UADP_SPT_NAME0NXT(CEC_GET_CMD_LEN, stCEC_GET_CMD_LEN);
	// MAPI_CMD_CEC_IS_RX_BUF_EMPTY
	UADP_SPT_NAME0NXT(CEC_IS_RX_BUF_EMPTY, stCEC_IS_RX_BUF_EMPTY);
	// MAPI_CMD_CEC_SET_ACTIVE_LOGICAL_ADDRESS
	UADP_SPT_NAME0NXT(CEC_SET_ACTIVE_LOGICAL_ADDRESS, stCEC_SET_ACTIVE_LOGICAL_ADDRESS);
	// MAPI_CMD_CEC_GET_ACTIVE_LOGICAL_ADDRESS
	UADP_SPT_NAME0NXT(CEC_GET_ACTIVE_LOGICAL_ADDRESS, stCEC_GET_ACTIVE_LOGICAL_ADDRESS);
	// MAPI_CMD_CEC_GET_POWER_STATUS
	UADP_SPT_NAME0NXT(CEC_GET_POWER_STATUS, stCEC_GET_POWER_STATUS);
	// MAPI_CMD_CEC_GET_FIFO_IDX
	UADP_SPT_NAME0NXT(CEC_GET_FIFO_IDX, stCEC_GET_FIFO_IDX);
	// MAPI_CMD_CEC_SET_FIFO_IDX
	UADP_SPT_NAME0NXT(CEC_SET_FIFO_IDX, stCEC_SET_FIFO_IDX);
	// MAPI_CMD_CEC_SET_ACTIVE_POWER_STATUS
	UADP_SPT_NAME0NXT(CEC_SET_ACTIVE_POWER_STATUS, stCEC_SET_ACTIVE_POWER_STATUS);
	// MAPI_CMD_CEC_GET_ACTIVE_POWER_STATUS
	UADP_SPT_NAME0NXT(CEC_GET_ACTIVE_POWER_STATUS, stCEC_GET_ACTIVE_POWER_STATUS);
	// MAPI_CMD_CEC_SET_ACTIVE_PHYSICAL_ADDRESS
	UADP_SPT_NAME0NXT(CEC_SET_ACTIVE_PHYSICAL_ADDRESS, stCEC_SET_ACTIVE_PHYSICAL_ADDRESS);
	// MAPI_CMD_CEC_SET_ACTIVE_DEVICE_CEC_VERSION
	UADP_SPT_NAME0NXT(CEC_SET_ACTIVE_DEVICE_CEC_VERSION, stCEC_SET_ACTIVE_DEVICE_CEC_VERSION);
	// MAPI_CMD_CEC_SET_ACTIVE_DEVICE_TYPE
	UADP_SPT_NAME0NXT(CEC_SET_ACTIVE_DEVICE_TYPE, stCEC_SET_ACTIVE_DEVICE_TYPE);
	// MAPI_CMD_CEC_GET_MSG_CNT
	UADP_SPT_NAME0NXT(CEC_GET_MSG_CNT, stCEC_GET_MSG_CNT);
	// MAPI_CMD_CEC_SET_MSG_CNT
	UADP_SPT_NAME0NXT(CEC_SET_MSG_CNT, stCEC_SET_MSG_CNT);
	// MAPI_CMD_CEC_GET_RX_DATA
	UADP_SPT_NAME0NXT(CEC_GET_RX_DATA, stCEC_GET_RX_DATA);
	// MAPI_CMD_CEC_SET_MY_PHYSICAL_ADDRESS
	UADP_SPT_NAME1NXT(CEC_SET_MY_PHYSICAL_ADDRESS, stCEC_SET_MY_PHYSICAL_ADDRESS, ucData, CEC_PHYSICAL_ADDRESS_TABLE);
	// MAPI_CMD_CEC_SET_MY_PHYSICAL_ADDRESS2
	UADP_SPT_NAME1NXT(CEC_SET_MY_PHYSICAL_ADDRESS2, stCEC_SET_MY_PHYSICAL_ADDRESS2, ucData, CEC_PHYSICAL_ADDRESS_TABLE);
	// MAPI_CMD_CEC_SET_INITIATOR
	UADP_SPT_NAME0NXT(CEC_SET_INITIATOR, stCEC_SET_INITIATOR);
	// MAPI_CMD_CEC_CONFIG_WAKEUP_INFO_VENDOR_ID
    ulDataSize = sizeof(MS_U8) * CEC_VENDOR_ID_COUNT;
    UADP_SPT_BGN(&spt_CEC_VENDOR_ID_TABLE[0], ulDataSize);
    UADP_SPT_FIN(&spt_CEC_VENDOR_ID_TABLE[1]);
	UADP_SPT_NAME1NXT(CEC_CONFIG_WAKEUP_INFO_VENDOR_ID, stCEC_CONFIG_WAKEUP_INFO_VENDOR_ID, ucVendorID, CEC_VENDOR_ID_TABLE);
	// MAPI_CMD_CEC_SET_RETRY_COUNT
	UADP_SPT_NAME0NXT(CEC_SET_RETRY_COUNT, stCEC_SET_RETRY_COUNT);
	// MAPI_CMD_CEC_ATTACH_DRIVER_ISR
	UADP_SPT_NAME0NXT(CEC_ATTACH_DRIVER_ISR, stCEC_ATTACH_DRIVER_ISR);
	// MAPI_CMD_CEC_GET_CONFIGURATION
	UADP_SPT_NAME0NXT(CEC_GET_CONFIGURATION, stCEC_GET_CONFIGURATION);

	*pIoctl= (FUtopiaIOctl)CEC_adp_Ioctl;
    
    return 0;
}

//**************************************************************************
//  [Function Name]:
//                  CEC_adp_Ioctl()
//  [Description]
//                  
//  [Arguments]:
//
//  [Return]:
//
//**************************************************************************
MS_U32 CEC_adp_Ioctl(void* pInstanceTmp, MS_U32 u32Cmd, void* const pArgs)
{
    MS_U32 ulReturnValue = UTOPIA_STATUS_SUCCESS;
    char usbuffer_arg[2];
    
    switch(u32Cmd)
    {
    	case MAPI_CMD_DDC2BI_GET_INFO:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_DDC2BI_GET_INFO, spt_CEC_DDC2BI_GET_INFO, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_INIT_CHIP:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_INIT_CHIP, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_PORT_SELECT:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_PORT_SELECT, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_EXIT: 
			ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, pArgs);
			break;

		case MAPI_CMD_CEC_SET_MY_LOGICAL_ADDRESS:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_MY_LOGICAL_ADDRES, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_INIT:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_INIT, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_CHECK_EXIST_DEVICES:
			ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, pArgs);
			break;

		case MAPI_CMD_CEC_NEXT_DEVICE:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_NEXT_DEVICE, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_CHK_RX_BUF:
			ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, pArgs);
			break;

		case MAPI_CMD_CEC_TX_SEND_MSG:
			{
				stCEC_TX_SEND_MSG stCECArgs = {0};
				
				if(IS_CMP_TASK())
				{
					stCEC_TX_SEND_MSG_COMPAT stCompatCECArgs = {0};

					CMP_CPY_FROM_USER(&stCompatCECArgs, pArgs, sizeof(stCEC_TX_SEND_MSG_COMPAT)); 
					stCECArgs.ucCmd = malloc(sizeof(MS_U8) *stCompatCECArgs.ucLen);
					CMP_CPY_FROM_USER(stCECArgs.ucCmd, stCompatCECArgs.ucCmd, sizeof(MS_U8) *stCompatCECArgs.ucLen);
					stCECArgs.ucLen = stCompatCECArgs.ucLen;
					stCECArgs.eDetAddr = stCompatCECArgs.eDetAddr;
					stCECArgs.eMsg = stCompatCECArgs.eMsg;

					ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stCECArgs);

					stCompatCECArgs.eErrorCode = stCECArgs.eErrorCode;

					CMP_CPY_TO_USER(pArgs, &stCompatCECArgs, sizeof(stCEC_TX_SEND_MSG_COMPAT));

					free(stCECArgs.ucCmd);
				}
				else
				{
					void *pCommand = NULL;
                    
                    CPY_FROM_USER(&stCECArgs, pArgs, sizeof(stCEC_TX_SEND_MSG));
                    pCommand = stCECArgs.ucCmd;
    				stCECArgs.ucCmd = malloc(sizeof(MS_U8) *stCECArgs.ucLen);
                    CPY_FROM_USER(stCECArgs.ucCmd, pCommand, sizeof(MS_U8) *stCECArgs.ucLen);

                    ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stCECArgs);

                    CPY_TO_USER(pArgs, &stCECArgs, sizeof(stCEC_TX_SEND_MSG));

                    free(stCECArgs.ucCmd);
				}
			}
			break;

		case MAPI_CMD_CEC_TX_SEND_MSG2:
			{
                stCEC_TX_SEND_MSG2 stCECArgs = {0};
                
                if(IS_CMP_TASK())
                {
                    stCEC_TX_SEND_MSG2_COMPAT stCompatCECArgs = {0};

                    CMP_CPY_FROM_USER(&stCompatCECArgs, pArgs, sizeof(stCEC_TX_SEND_MSG2_COMPAT)); 
                    stCECArgs.ucCmd = malloc(sizeof(MS_U8) *stCompatCECArgs.ucLen);
                    CMP_CPY_FROM_USER(stCECArgs.ucCmd, stCompatCECArgs.ucCmd, sizeof(MS_U8) *stCompatCECArgs.ucLen);
                    stCECArgs.ucLen = stCompatCECArgs.ucLen;
                    stCECArgs.eDetAddr = stCompatCECArgs.eDetAddr;
                    stCECArgs.eMsg = stCompatCECArgs.eMsg;

                    ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stCECArgs);

                    stCompatCECArgs.eErrorCode = stCECArgs.eErrorCode;

                    CMP_CPY_TO_USER(pArgs, &stCompatCECArgs, sizeof(stCEC_TX_SEND_MSG2_COMPAT));

                    free(stCECArgs.ucCmd);
                }
                else
                {
                    void *pCommand = NULL;
                    
                    CPY_FROM_USER(&stCECArgs, pArgs, sizeof(stCEC_TX_SEND_MSG2));
                    pCommand = stCECArgs.ucCmd;
    				stCECArgs.ucCmd = malloc(sizeof(MS_U8) *stCECArgs.ucLen);
                    CPY_FROM_USER(stCECArgs.ucCmd, pCommand, sizeof(MS_U8) *stCECArgs.ucLen);

                    ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stCECArgs);

                    CPY_TO_USER(pArgs, &stCECArgs, sizeof(stCEC_TX_SEND_MSG2));

                    free(stCECArgs.ucCmd);
                }
                
			}
			break;

		case MAPI_CMD_CEC_TX_SEND_POLLING_MSG:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_TX_SEND_POLLING_MSG, spt_CEC_TX_SEND_POLLING_MSG, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_ACTIVE_SOURCE:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_MSG_ACTIVE_SOURCE, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_ROUTING_CHANGE:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_ROUTING_CHANGE, spt_CEC_MSG_ROUTING_CHANGE, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_REQ_ACTIVE_SOURCE:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_MSG_REQ_ACTIVE_SOURCE, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_SET_STREAM_PATH:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_SET_STREAM_PATH, spt_CEC_MSG_SET_STREAM_PATH, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_STANDBY:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_STANDBY, spt_CEC_MSG_STANDBY, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_RECORD_OFF:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_RECORD_OFF, spt_CEC_MSG_RECORD_OFF, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_RECORD_ON:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_RECORD_ON, spt_CEC_MSG_RECORD_ON, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_REPORT_CEC_VERSION:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_REPORT_CEC_VERSION, spt_CEC_MSG_REPORT_CEC_VERSION, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_REQ_CEC_VERSION:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_REQ_CEC_VERSION, spt_CEC_MSG_REQ_CEC_VERSION, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_REPORT_PHYCAL_ADDRESS:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_MSG_REPORT_PHYCAL_ADDRESS, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_REQ_PHYCAL_ADDRESS:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_REQ_PHYCAL_ADDRESS, spt_CEC_MSG_REQ_PHYCAL_ADDRESS, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_DECK_CONTROL:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_DECK_CONTROL, spt_CEC_MSG_DECK_CONTROL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_DEC_STATUS:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_DEC_STATUS, spt_CEC_MSG_DEC_STATUS, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_GIVE_DECK_STATUS:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_GIVE_DECK_STATUS, spt_CEC_MSG_GIVE_DECK_STATUS, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_DC_PLAY:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_DC_PLAY, spt_CEC_MSG_DC_PLAY, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_REQ_MENU_STATUS:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_REQ_MENU_STATUS, spt_CEC_MSG_REQ_MENU_STATUS, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_USER_CTRL_PRESSED:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_USER_CTRL_PRESSED, spt_CEC_MSG_USER_CTRL_PRESSED, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_USER_CTRL_RELEASED:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_USER_CTRL_RELEASED, spt_CEC_MSG_USER_CTRL_RELEASED, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_GIVE_AUDIO_STATUS:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_GIVE_AUDIO_STATUS, spt_CEC_MSG_GIVE_AUDIO_STATUS, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_REPORT_POWER_STATUS:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_REPORT_POWER_STATUS, spt_CEC_MSG_REPORT_POWER_STATUS, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_REQ_POWER_STATUS:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_REQ_POWER_STATUS, spt_CEC_MSG_REQ_POWER_STATUS, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_FEATURE_ABORT:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_FEATURE_ABORT, spt_CEC_MSG_FEATURE_ABORT, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_ABORT:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_ABORT, spt_CEC_MSG_ABORT, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_SEND_MENU_LANGUAGE:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_SEND_MENU_LANGUAGE, spt_CEC_MSG_SEND_MENU_LANGUAGE, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_REQ_ARC_INITIATION:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_REQ_ARC_INITIATION, spt_CEC_MSG_REQ_ARC_INITIATION, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_REQ_ARC_TERMINATION:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_REQ_ARC_TERMINATION, spt_CEC_MSG_REQ_ARC_TERMINATION, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_AUDIO_MODE_REQ:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_AUDIO_MODE_REQ, spt_CEC_MSG_AUDIO_MODE_REQ, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_MSG_REPORT_PHYCAL_ADDRESS2:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_MSG_REPORT_PHYCAL_ADDRESS2, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_CHECK_FRAME:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_CHECK_FRAME, spt_CEC_CHECK_FRAME, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_CONFIG_WAKEUP:
			ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, pArgs);
			break;

		case MAPI_CMD_CEC_ENABLED:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_ENABLED, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_GET_TX_STATUS:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_TX_STATUS, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_CHECK_DEVICE_IS_TX:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_DEVICE_IS_TX, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_SET_POWER_STATE:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_POWER_STATE, spt_CEC_SET_POWER_STATE, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_SET_MY_LOGICAL_ADDRESS2:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_MY_LOGICAL_ADDRESS2, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_GET_HEADER:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_HEADER, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_GET_OPCODE:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_OPCODE, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_GET_PARA:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_GET_PARA, spt_CEC_GET_PARA, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_GET_CMD_LEN:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_CMD_LEN, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_IS_RX_BUF_EMPTY:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_IS_RX_BUF_EMPTY, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_SET_ACTIVE_LOGICAL_ADDRESS:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_ACTIVE_LOGICAL_ADDRESS, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_GET_ACTIVE_LOGICAL_ADDRESS:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_ACTIVE_LOGICAL_ADDRESS, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_GET_POWER_STATUS:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_POWER_STATUS, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_GET_FIFO_IDX:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_FIFO_IDX, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_SET_FIFO_IDX:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_FIFO_IDX, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_SET_ACTIVE_POWER_STATUS:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_ACTIVE_POWER_STATUS, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_GET_ACTIVE_POWER_STATUS:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_ACTIVE_POWER_STATUS, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_SET_ACTIVE_PHYSICAL_ADDRESS:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_ACTIVE_PHYSICAL_ADDRESS, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_SET_ACTIVE_DEVICE_CEC_VERSION:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_ACTIVE_DEVICE_CEC_VERSION, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_SET_ACTIVE_DEVICE_TYPE:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_ACTIVE_DEVICE_TYPE, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_GET_MSG_CNT:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_MSG_CNT, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_SET_MSG_CNT:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_MSG_CNT, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_GET_RX_DATA:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_GET_RX_DATA, spt_CEC_GET_RX_DATA, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_SET_MY_PHYSICAL_ADDRESS:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_MY_PHYSICAL_ADDRESS, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_SET_MY_PHYSICAL_ADDRESS2:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_MY_PHYSICAL_ADDRESS2, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_SET_INITIATOR:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_INITIATOR, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_CONFIG_WAKEUP_INFO_VENDOR_ID:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_CONFIG_WAKEUP_INFO_VENDOR_ID, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

		case MAPI_CMD_CEC_SET_RETRY_COUNT:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_RETRY_COUNT, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

        case MAPI_CMD_CEC_ATTACH_DRIVER_ISR:
			ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_ATTACH_DRIVER_ISR, NULL, usbuffer_arg, sizeof(usbuffer_arg));
			break;

        case MAPI_CMD_CEC_GET_CONFIGURATION:
            ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_CONFIGURATION, usbuffer_arg, sizeof(usbuffer_arg));
            break;

        default:
            
            break;
    };
    
    return ulReturnValue;
}

#endif // _ADP_CEC_C_