1 //<MStar Software> 2 //****************************************************************************** 3 // MStar Software 4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved. 5 // All software, firmware and related documentation herein ("MStar Software") are 6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by 7 // law, including, but not limited to, copyright law and international treaties. 8 // Any use, modification, reproduction, retransmission, or republication of all 9 // or part of MStar Software is expressly prohibited, unless prior written 10 // permission has been granted by MStar. 11 // 12 // By accessing, browsing and/or using MStar Software, you acknowledge that you 13 // have read, understood, and agree, to be bound by below terms ("Terms") and to 14 // comply with all applicable laws and regulations: 15 // 16 // 1. MStar shall retain any and all right, ownership and interest to MStar 17 // Software and any modification/derivatives thereof. 18 // No right, ownership, or interest to MStar Software and any 19 // modification/derivatives thereof is transferred to you under Terms. 20 // 21 // 2. You understand that MStar Software might include, incorporate or be 22 // supplied together with third party`s software and the use of MStar 23 // Software may require additional licenses from third parties. 24 // Therefore, you hereby agree it is your sole responsibility to separately 25 // obtain any and all third party right and license necessary for your use of 26 // such third party`s software. 27 // 28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as 29 // MStar`s confidential information and you agree to keep MStar`s 30 // confidential information in strictest confidence and not disclose to any 31 // third party. 32 // 33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any 34 // kind. Any warranties are hereby expressly disclaimed by MStar, including 35 // without limitation, any warranties of merchantability, non-infringement of 36 // intellectual property rights, fitness for a particular purpose, error free 37 // and in conformity with any international standard. You agree to waive any 38 // claim against MStar for any loss, damage, cost or expense that you may 39 // incur related to your use of MStar Software. 40 // In no event shall MStar be liable for any direct, indirect, incidental or 41 // consequential damages, including without limitation, lost of profit or 42 // revenues, lost or damage of data, and unauthorized system use. 43 // You agree that this Section 4 shall still apply without being affected 44 // even if MStar Software has been modified by MStar in accordance with your 45 // request or instruction for your use, except otherwise agreed by both 46 // parties in writing. 47 // 48 // 5. If requested, MStar may from time to time provide technical supports or 49 // services in relation with MStar Software to you for your use of 50 // MStar Software in conjunction with your or your customer`s product 51 // ("Services"). 52 // You understand and agree that, except otherwise agreed by both parties in 53 // writing, Services are provided on an "AS IS" basis and the warranty 54 // disclaimer set forth in Section 4 above shall apply. 55 // 56 // 6. Nothing contained herein shall be construed as by implication, estoppels 57 // or otherwise: 58 // (a) conferring any license or right to use MStar name, trademark, service 59 // mark, symbol or any other identification; 60 // (b) obligating MStar or any of its affiliates to furnish any person, 61 // including without limitation, you and your customers, any assistance 62 // of any kind whatsoever, or any information; or 63 // (c) conferring any license or right under any intellectual property right. 64 // 65 // 7. These terms shall be governed by and construed in accordance with the laws 66 // of Taiwan, R.O.C., excluding its conflict of law rules. 67 // Any and all dispute arising out hereof or related hereto shall be finally 68 // settled by arbitration referred to the Chinese Arbitration Association, 69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration 70 // Rules of the Association by three (3) arbitrators appointed in accordance 71 // with the said Rules. 72 // The place of arbitration shall be in Taipei, Taiwan and the language shall 73 // be English. 74 // The arbitration award shall be final and binding to both parties. 75 // 76 //****************************************************************************** 77 //<MStar Software> 78 /////////////////////////////////////////////////////////////////////////////////////////////////// 79 /// 80 /// file adpCEC.c 81 /// @author MStar Semiconductor Inc. 82 /// @brief CEC driver Function 83 /////////////////////////////////////////////////////////////////////////////////////////////////// 84 85 #ifndef _ADP_CEC_C_ 86 #define _ADP_CEC_C_ 87 88 //------------------------------------------------------------------------------------------------- 89 // Include Files 90 //------------------------------------------------------------------------------------------------- 91 // Common Definition 92 #include "MsCommon.h" 93 #include "MsVersion.h" 94 #include "MsDevice.h" 95 #include <linux/kernel.h> 96 #include <linux/sched.h> 97 98 #ifdef MSOS_TYPE_LINUX_KERNEL 99 #include <linux/string.h> 100 #else 101 #include <string.h> 102 #endif 103 104 #include <linux/slab.h> 105 #include <asm/uaccess.h> 106 #include <linux/compat.h> 107 108 #include "utopia.h" 109 #include "utopia_dapi.h" 110 #include "utopia_adp.h" 111 112 #include "adpCEC.h" 113 #include "apiCEC.h" 114 115 //------------------------------------------------------------------------------------------------- 116 // Local Defines 117 //------------------------------------------------------------------------------------------------- 118 #if(defined(CONFIG_MLOG)) 119 #include "ULog.h" 120 121 #define MADP_CEC_MSG_INFO(format, args...) ULOGI("CEC", format, ##args) 122 #define MADP_CEC_MSG_WARNING(format, args...) ULOGW("CEC", format, ##args) 123 #define MADP_CEC_MSG_DEBUG(format, args...) ULOGD("CEC", format, ##args) 124 #define MADP_CEC_MSG_ERROR(format, args...) ULOGE("CEC", format, ##args) 125 #define MADP_CEC_MSG_FATAL(format, args...) ULOGF("CEC", format, ##args) 126 127 #else 128 #define MADP_CEC_MSG_INFO(format, args...) printf(format, ##args) 129 #define MADP_CEC_MSG_WARNING(format, args...) printf(format, ##args) 130 #define MADP_CEC_MSG_DEBUG(format, args...) printf(format, ##args) 131 #define MADP_CEC_MSG_ERROR(format, args...) printf(format, ##args) 132 #define MADP_CEC_MSG_FATAL(format, args...) printf(format, ##args) 133 134 #endif 135 136 #ifdef MSOS_TYPE_LINUX_KERNEL 137 #define CPY_FROM_USER(a,b,c) if(copy_from_user(a,b,c) != 0) { break; } 138 #define CPY_TO_USER(a,b,c) if(copy_to_user(a,b,c) != 0) { break; } 139 #else 140 #define CPY_FROM_USER memcpy 141 #define CPY_TO_USER memcpy 142 #endif //MSOS_TYPE_LINUX_KERNEL 143 144 #if (defined(MSOS_TYPE_LINUX_KERNEL) && defined(CONFIG_COMPAT)) 145 #define COMPAT_PTR(a) compat_ptr(a) 146 #define COMPAT_NEXT_PTR(a) (*((MS_U32*)compat_ptr((unsigned long)a))) 147 #define IS_CMP_TASK() is_compat_task() 148 #define CMP_CPY_FROM_USER(a,b,c) if(copy_from_user(a, compat_ptr((unsigned long)b), c) != 0) { break; } 149 #define CMP_CPY_TO_USER(a,b,c) if(copy_to_user(compat_ptr((unsigned long)a), b, c) != 0) { break; } 150 #define MS_COMPAT_CEC compat_uptr_t 151 152 #else 153 #define COMPAT_PTR(a) (a) 154 #define COMPAT_NEXT_PTR(a) (*((MS_U32*)a)) 155 #define IS_CMP_TASK() (FALSE) 156 #define CMP_CPY_FROM_USER CPY_FROM_USER 157 #define CMP_CPY_TO_USER CPY_TO_USER 158 #define MS_COMPAT_CEC MS_U8* 159 160 #endif //CONFIG_COMPAT 161 162 //------------------------------------------------------------------------------------------------- 163 // Local Structures 164 //------------------------------------------------------------------------------------------------- 165 typedef struct DLL_PACKED 166 { 167 MsCEC_DEVICELA eDetAddr; 168 MsCEC_MSGLIST eMsg; 169 MS_COMPAT_CEC ucCmd; 170 MS_U8 ucLen; 171 CEC_ERROR_CODE eErrorCode; 172 } stCEC_TX_SEND_MSG_COMPAT, *pstCEC_TX_SEND_MSG_COMPAT; 173 174 typedef struct DLL_PACKED 175 { 176 MsCEC_DEVICELA eDetAddr; 177 MsCEC_MSGLIST eMsg; 178 MS_COMPAT_CEC ucCmd; 179 MS_U8 ucLen; 180 CEC_ERROR_CODE eErrorCode; 181 } stCEC_TX_SEND_MSG2_COMPAT, *pstCEC_TX_SEND_MSG2_COMPAT; 182 183 //------------------------------------------------------------------------------------------------- 184 // Global Variables 185 //------------------------------------------------------------------------------------------------- 186 187 //------------------------------------------------------------------------------------------------- 188 // Local Variables 189 //------------------------------------------------------------------------------------------------- 190 UADP_SPT_NAMEnNXT_DEF(CEC_MS_U8, 0); 191 // MAPI_CMD_DDC2BI_GET_INFO -- stCEC_DDC2BI_GET_INFO -- MS_CEC_INFO_LIST 192 UADP_SPT_NAMEnNXT_DEF(CEC_MS_CEC_INFO_LIST, 0); 193 UADP_SPT_NAMEnNXT_DEF(CEC_DDC2BI_GET_INFO, 1); 194 // MAPI_CMD_CEC_INIT_CHIP -- stCEC_INIT_CHIP 195 UADP_SPT_NAMEnNXT_DEF(CEC_INIT_CHIP, 0); 196 // MAPI_CMD_CEC_PORT_SELECT -- stCEC_PORT_SELECT 197 UADP_SPT_NAMEnNXT_DEF(CEC_PORT_SELECT, 0); 198 // MAPI_CMD_CEC_SET_MY_LOGICAL_ADDRESS -- stCEC_SET_MY_LOGICAL_ADDRESS 199 UADP_SPT_NAMEnNXT_DEF(CEC_SET_MY_LOGICAL_ADDRES, 0); 200 // MAPI_CMD_CEC_INIT -- stCEC_INIT 201 UADP_SPT_NAMEnNXT_DEF(CEC_INIT, 0); 202 // MAPI_CMD_CEC_NEXT_DEVICE -- stCEC_NEXT_DEVICE 203 UADP_SPT_NAMEnNXT_DEF(CEC_NEXT_DEVICE, 0); 204 // MAPI_CMD_CEC_TX_SEND_POLLING_MSG -- stCEC_TX_SEND_POLLING_MSG 205 UADP_SPT_NAMEnNXT_DEF(CEC_TX_SEND_POLLING_MSG, 0); 206 // MAPI_CMD_CEC_MSG_ACTIVE_SOURCE -- stCEC_MSG_ACTIVE_SOURCE 207 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_ACTIVE_SOURCE, 0); 208 // MAPI_CMD_CEC_MSG_ROUTING_CHANGE -- stCEC_MSG_ROUTING_CHANGE 209 UADP_SPT_NAMEnNXT_DEF(CEC_PHYSICAL_ADDRESS_TABLE, 0); 210 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_ROUTING_CHANGE, 2); 211 // MAPI_CMD_CEC_MSG_REQ_ACTIVE_SOURCE -- stCEC_MSG_REQ_ACTIVE_SOURCE 212 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REQ_ACTIVE_SOURCE, 0); 213 // MAPI_CMD_CEC_MSG_SET_STREAM_PATH -- stCEC_MSG_SET_STREAM_PATH 214 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_SET_STREAM_PATH, 1); 215 // MAPI_CMD_CEC_MSG_STANDBY -- stCEC_MSG_STANDBY 216 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_STANDBY, 0); 217 // MAPI_CMD_CEC_MSG_RECORD_OFF -- stCEC_MSG_RECORD_OFF 218 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_RECORD_OFF, 0); 219 // MAPI_CMD_CEC_MSG_RECORD_ON -- stCEC_MSG_RECORD_ON 220 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_RECORD_ON, 0); 221 // MAPI_CMD_CEC_MSG_REPORT_CEC_VERSION -- stCEC_MSG_REPORT_CEC_VERSION 222 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REPORT_CEC_VERSION, 0); 223 // MAPI_CMD_CEC_MSG_REQ_CEC_VERSION -- stCEC_MSG_REQ_CEC_VERSION 224 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REQ_CEC_VERSION, 0); 225 // MAPI_CMD_CEC_MSG_REPORT_PHYCAL_ADDRESS -- stCEC_MSG_REPORT_PHYCAL_ADDRESS 226 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REPORT_PHYCAL_ADDRESS, 0); 227 // MAPI_CMD_CEC_MSG_REQ_PHYCAL_ADDRESS -- stCEC_MSG_REQ_PHYCAL_ADDRESS 228 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REQ_PHYCAL_ADDRESS, 0); 229 // MAPI_CMD_CEC_MSG_DECK_CONTROL -- stCEC_MSG_DECK_CONTROL 230 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_DECK_CONTROL, 0); 231 // MAPI_CMD_CEC_MSG_DEC_STATUS -- stCEC_MSG_DEC_STATUS 232 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_DEC_STATUS, 0); 233 // MAPI_CMD_CEC_MSG_GIVE_DECK_STATUS -- stCEC_MSG_GIVE_DECK_STATUS 234 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_GIVE_DECK_STATUS, 0); 235 // MAPI_CMD_CEC_MSG_DC_PLAY -- stCEC_MSG_DC_PLAY 236 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_DC_PLAY, 0); 237 // MAPI_CMD_CEC_MSG_REQ_MENU_STATUS -- stCEC_MSG_REQ_MENU_STATUS 238 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REQ_MENU_STATUS, 0); 239 // MAPI_CMD_CEC_MSG_USER_CTRL_PRESSED -- stCEC_MSG_USER_CTRL_PRESSED 240 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_USER_CTRL_PRESSED, 0); 241 // MAPI_CMD_CEC_MSG_USER_CTRL_RELEASED -- stCEC_MSG_USER_CTRL_RELEASED 242 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_USER_CTRL_RELEASED, 0); 243 // MAPI_CMD_CEC_MSG_GIVE_AUDIO_STATUS -- stCEC_MSG_GIVE_AUDIO_STATUS 244 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_GIVE_AUDIO_STATUS, 0); 245 // MAPI_CMD_CEC_MSG_REPORT_POWER_STATUS -- stCEC_MSG_REPORT_POWER_STATUS 246 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REPORT_POWER_STATUS, 0); 247 // MAPI_CMD_CEC_MSG_REQ_POWER_STATUS -- stCEC_MSG_REQ_POWER_STATUS 248 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REQ_POWER_STATUS, 0); 249 // MAPI_CMD_CEC_MSG_FEATURE_ABORT -- stCEC_MSG_FEATURE_ABORT 250 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_FEATURE_ABORT, 0); 251 // MAPI_CMD_CEC_MSG_ABORT -- stCEC_MSG_ABORT 252 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_ABORT, 0); 253 // MAPI_CMD_CEC_MSG_SEND_MENU_LANGUAGE -- stCEC_MSG_SEND_MENU_LANGUAGE 254 UADP_SPT_NAMEnNXT_DEF(CEC_MENU_LANGUAGE_CODE_TABLE, 0); 255 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_SEND_MENU_LANGUAGE, 1); 256 // MAPI_CMD_CEC_MSG_REQ_ARC_INITIATION -- stCEC_MSG_REQ_ARC_INITIATION 257 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REQ_ARC_INITIATION, 0); 258 // MAPI_CMD_CEC_MSG_REQ_ARC_TERMINATION -- stCEC_MSG_REQ_ARC_TERMINATION 259 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REQ_ARC_TERMINATION, 0); 260 // MAPI_CMD_CEC_MSG_AUDIO_MODE_REQ -- stCEC_MSG_AUDIO_MODE_REQ 261 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_AUDIO_MODE_REQ, 1); 262 // MAPI_CMD_CEC_MSG_REPORT_PHYCAL_ADDRESS2 -- stCEC_MSG_REPORT_PHYCAL_ADDRESS2 263 UADP_SPT_NAMEnNXT_DEF(CEC_MSG_REPORT_PHYCAL_ADDRESS2, 0); 264 // MAPI_CMD_CEC_CHECK_FRAME -- stCEC_CHECK_FRAME 265 UADP_SPT_NAMEnNXT_DEF(CEC_CHECK_FRAME, 0); 266 // MAPI_CMD_CEC_ENABLED -- stCEC_ENABLED 267 UADP_SPT_NAMEnNXT_DEF(CEC_ENABLED, 0); 268 // MAPI_CMD_CEC_GET_TX_STATUS -- stCEC_GET_TX_STATUS 269 UADP_SPT_NAMEnNXT_DEF(CEC_GET_TX_STATUS, 0); 270 // MAPI_CMD_CEC_CHECK_DEVICE_IS_TX -- stCEC_DEVICE_IS_TX 271 UADP_SPT_NAMEnNXT_DEF(CEC_DEVICE_IS_TX, 0); 272 // MAPI_CMD_CEC_SET_POWER_STATE -- stCEC_SET_POWER_STATE 273 UADP_SPT_NAMEnNXT_DEF(CEC_SET_POWER_STATE, 0); 274 // MAPI_CMD_CEC_SET_MY_LOGICAL_ADDRESS2 -- stCEC_SET_MY_LOGICAL_ADDRESS2 275 UADP_SPT_NAMEnNXT_DEF(CEC_SET_MY_LOGICAL_ADDRESS2, 0); 276 // MAPI_CMD_CEC_GET_HEADER -- stCEC_GET_HEADER 277 UADP_SPT_NAMEnNXT_DEF(CEC_GET_HEADER, 0); 278 // MAPI_CMD_CEC_GET_OPCODE -- stCEC_GET_OPCODE 279 UADP_SPT_NAMEnNXT_DEF(CEC_GET_OPCODE, 0); 280 // MAPI_CMD_CEC_GET_PARA -- stCEC_GET_PARA 281 UADP_SPT_NAMEnNXT_DEF(CEC_GET_PARA, 0); 282 // MAPI_CMD_CEC_GET_CMD_LEN -- stCEC_GET_CMD_LEN 283 UADP_SPT_NAMEnNXT_DEF(CEC_GET_CMD_LEN, 0); 284 // MAPI_CMD_CEC_IS_RX_BUF_EMPTY -- stCEC_IS_RX_BUF_EMPTY 285 UADP_SPT_NAMEnNXT_DEF(CEC_IS_RX_BUF_EMPTY, 0); 286 // MAPI_CMD_CEC_SET_ACTIVE_LOGICAL_ADDRESS -- stCEC_SET_ACTIVE_LOGICAL_ADDRESS 287 UADP_SPT_NAMEnNXT_DEF(CEC_SET_ACTIVE_LOGICAL_ADDRESS, 0); 288 // MAPI_CMD_CEC_GET_ACTIVE_LOGICAL_ADDRESS -- stCEC_GET_ACTIVE_LOGICAL_ADDRESS 289 UADP_SPT_NAMEnNXT_DEF(CEC_GET_ACTIVE_LOGICAL_ADDRESS, 0); 290 // MAPI_CMD_CEC_GET_POWER_STATUS -- stCEC_GET_POWER_STATUS 291 UADP_SPT_NAMEnNXT_DEF(CEC_GET_POWER_STATUS, 0); 292 // MAPI_CMD_CEC_GET_FIFO_IDX -- stCEC_GET_FIFO_IDX 293 UADP_SPT_NAMEnNXT_DEF(CEC_GET_FIFO_IDX, 0); 294 // MAPI_CMD_CEC_SET_FIFO_IDX -- stCEC_SET_FIFO_IDX 295 UADP_SPT_NAMEnNXT_DEF(CEC_SET_FIFO_IDX, 0); 296 // MAPI_CMD_CEC_SET_ACTIVE_POWER_STATUS -- stCEC_SET_ACTIVE_POWER_STATUS 297 UADP_SPT_NAMEnNXT_DEF(CEC_SET_ACTIVE_POWER_STATUS, 0); 298 // MAPI_CMD_CEC_GET_ACTIVE_POWER_STATUS -- stCEC_GET_ACTIVE_POWER_STATUS 299 UADP_SPT_NAMEnNXT_DEF(CEC_GET_ACTIVE_POWER_STATUS, 0); 300 // MAPI_CMD_CEC_SET_ACTIVE_PHYSICAL_ADDRESS -- stCEC_SET_ACTIVE_PHYSICAL_ADDRESS 301 UADP_SPT_NAMEnNXT_DEF(CEC_SET_ACTIVE_PHYSICAL_ADDRESS, 0); 302 // MAPI_CMD_CEC_SET_ACTIVE_DEVICE_CEC_VERSION -- stCEC_SET_ACTIVE_DEVICE_CEC_VERSION 303 UADP_SPT_NAMEnNXT_DEF(CEC_SET_ACTIVE_DEVICE_CEC_VERSION, 0); 304 // MAPI_CMD_CEC_SET_ACTIVE_DEVICE_TYPE -- stCEC_SET_ACTIVE_DEVICE_TYPE 305 UADP_SPT_NAMEnNXT_DEF(CEC_SET_ACTIVE_DEVICE_TYPE, 0); 306 // MAPI_CMD_CEC_GET_MSG_CNT -- stCEC_GET_MSG_CNT 307 UADP_SPT_NAMEnNXT_DEF(CEC_GET_MSG_CNT, 0); 308 // MAPI_CMD_CEC_SET_MSG_CNT -- stCEC_SET_MSG_CNT 309 UADP_SPT_NAMEnNXT_DEF(CEC_SET_MSG_CNT, 0); 310 // MAPI_CMD_CEC_GET_RX_DATA -- stCEC_GET_RX_DATA 311 UADP_SPT_NAMEnNXT_DEF(CEC_GET_RX_DATA, 0); 312 // MAPI_CMD_CEC_SET_MY_PHYSICAL_ADDRESS -- stCEC_SET_MY_PHYSICAL_ADDRESS 313 UADP_SPT_NAMEnNXT_DEF(CEC_SET_MY_PHYSICAL_ADDRESS, 1); 314 // MAPI_CMD_CEC_SET_MY_PHYSICAL_ADDRESS2 -- stCEC_SET_MY_PHYSICAL_ADDRESS2 315 UADP_SPT_NAMEnNXT_DEF(CEC_SET_MY_PHYSICAL_ADDRESS2, 1); 316 // MAPI_CMD_CEC_SET_INITIATOR -- stCEC_SET_INITIATOR 317 UADP_SPT_NAMEnNXT_DEF(CEC_SET_INITIATOR, 0); 318 // MAPI_CMD_CEC_CONFIG_WAKEUP_INFO_VENDOR_ID -- stCEC_CONFIG_WAKEUP_INFO_VENDOR_ID 319 UADP_SPT_NAMEnNXT_DEF(CEC_VENDOR_ID_TABLE, 0); 320 UADP_SPT_NAMEnNXT_DEF(CEC_CONFIG_WAKEUP_INFO_VENDOR_ID, 1); 321 // MAPI_CMD_CEC_SET_RETRY_COUNT -- stCEC_SET_RETRY_COUNT 322 UADP_SPT_NAMEnNXT_DEF(CEC_SET_RETRY_COUNT, 0); 323 // MAPI_CMD_CEC_ATTACH_DRIVER_ISR -- stCEC_ATTACH_DRIVER_ISR 324 UADP_SPT_NAMEnNXT_DEF(CEC_ATTACH_DRIVER_ISR, 0); 325 // MAPI_CMD_CEC_GET_CONFIGURATION -- stCEC_GET_CONFIGURATION 326 UADP_SPT_NAMEnNXT_DEF(CEC_GET_CONFIGURATION, 0); 327 328 //------------------------------------------------------------------------------------------------- 329 // Local Functions 330 //------------------------------------------------------------------------------------------------- 331 332 //------------------------------------------------------------------------------------------------- 333 // Global Functions 334 //------------------------------------------------------------------------------------------------- 335 336 //************************************************************************** 337 // [Function Name]: 338 // CEC_adp_Init() 339 // [Description] 340 // 341 // [Arguments]: 342 // 343 // [Return]: 344 // 345 //************************************************************************** 346 MS_U32 CEC_adp_Init(FUtopiaIOctl* pIoctl) 347 { 348 MS_U32 ulDataSize = 0; 349 350 UADP_SPT_NAME0NXT(CEC_MS_U8, MS_U8); 351 // MAPI_CMD_DDC2BI_GET_INFO 352 UADP_SPT_NAME0NXT(CEC_MS_CEC_INFO_LIST, MS_CEC_INFO_LIST); 353 UADP_SPT_NAME1NXT(CEC_DDC2BI_GET_INFO, stCEC_DDC2BI_GET_INFO, eInfo, CEC_MS_CEC_INFO_LIST); 354 // MAPI_CMD_CEC_INIT_CHIP 355 UADP_SPT_NAME0NXT(CEC_INIT_CHIP, stCEC_INIT_CHIP); 356 // MAPI_CMD_CEC_PORT_SELECT 357 UADP_SPT_NAME0NXT(CEC_PORT_SELECT, stCEC_PORT_SELECT); 358 // MAPI_CMD_CEC_SET_MY_LOGICAL_ADDRESS 359 UADP_SPT_NAME0NXT(CEC_SET_MY_LOGICAL_ADDRES, stCEC_SET_MY_LOGICAL_ADDRESS); 360 // MAPI_CMD_CEC_INIT 361 UADP_SPT_NAME0NXT(CEC_INIT, stCEC_INIT); 362 // MAPI_CMD_CEC_NEXT_DEVICE 363 UADP_SPT_NAME0NXT(CEC_NEXT_DEVICE, stCEC_NEXT_DEVICE); 364 // MAPI_CMD_CEC_TX_SEND_POLLING_MSG 365 UADP_SPT_NAME0NXT(CEC_TX_SEND_POLLING_MSG, stCEC_TX_SEND_POLLING_MSG); 366 // MAPI_CMD_CEC_MSG_ACTIVE_SOURCE 367 UADP_SPT_NAME0NXT(CEC_MSG_ACTIVE_SOURCE, stCEC_MSG_ACTIVE_SOURCE); 368 // MAPI_CMD_CEC_MSG_ROUTING_CHANGE 369 ulDataSize = sizeof(MS_U8) * CEC_PHY_ADDR_COUNT; 370 UADP_SPT_BGN(&spt_CEC_PHYSICAL_ADDRESS_TABLE[0], ulDataSize); 371 UADP_SPT_FIN(&spt_CEC_PHYSICAL_ADDRESS_TABLE[1]); 372 UADP_SPT_NAME2NXT(CEC_MSG_ROUTING_CHANGE, stCEC_MSG_ROUTING_CHANGE, ucOrigAddr, CEC_PHYSICAL_ADDRESS_TABLE, ucNewAddr, CEC_PHYSICAL_ADDRESS_TABLE); 373 // MAPI_CMD_CEC_MSG_REQ_ACTIVE_SOURCE 374 UADP_SPT_NAME0NXT(CEC_MSG_REQ_ACTIVE_SOURCE, stCEC_MSG_REQ_ACTIVE_SOURCE); 375 // MAPI_CMD_CEC_MSG_SET_STREAM_PATH 376 UADP_SPT_NAME1NXT(CEC_MSG_SET_STREAM_PATH, stCEC_MSG_SET_STREAM_PATH, ucNewAddr, CEC_PHYSICAL_ADDRESS_TABLE); 377 // MAPI_CMD_CEC_MSG_STANDBY 378 UADP_SPT_NAME0NXT(CEC_MSG_STANDBY, stCEC_MSG_STANDBY); 379 // MAPI_CMD_CEC_MSG_RECORD_OFF 380 UADP_SPT_NAME0NXT(CEC_MSG_RECORD_OFF, stCEC_MSG_RECORD_OFF); 381 // MAPI_CMD_CEC_MSG_RECORD_ON 382 UADP_SPT_NAME0NXT(CEC_MSG_RECORD_ON, stCEC_MSG_RECORD_ON); 383 // MAPI_CMD_CEC_MSG_REPORT_CEC_VERSION 384 UADP_SPT_NAME0NXT(CEC_MSG_REPORT_CEC_VERSION, stCEC_MSG_REPORT_CEC_VERSION); 385 // MAPI_CMD_CEC_MSG_REQ_CEC_VERSION 386 UADP_SPT_NAME0NXT(CEC_MSG_REQ_CEC_VERSION, stCEC_MSG_REQ_CEC_VERSION); 387 // MAPI_CMD_CEC_MSG_REPORT_PHYCAL_ADDRESS 388 UADP_SPT_NAME0NXT(CEC_MSG_REPORT_PHYCAL_ADDRESS, stCEC_MSG_REPORT_PHYCAL_ADDRESS); 389 // MAPI_CMD_CEC_MSG_REQ_PHYCAL_ADDRESS 390 UADP_SPT_NAME0NXT(CEC_MSG_REQ_PHYCAL_ADDRESS, stCEC_MSG_REQ_PHYCAL_ADDRESS); 391 // MAPI_CMD_CEC_MSG_DECK_CONTROL 392 UADP_SPT_NAME0NXT(CEC_MSG_DECK_CONTROL, stCEC_MSG_DECK_CONTROL); 393 // MAPI_CMD_CEC_MSG_DEC_STATUS 394 UADP_SPT_NAME0NXT(CEC_MSG_DEC_STATUS, stCEC_MSG_DEC_STATUS); 395 // MAPI_CMD_CEC_MSG_GIVE_DECK_STATUS 396 UADP_SPT_NAME0NXT(CEC_MSG_GIVE_DECK_STATUS, stCEC_MSG_GIVE_DECK_STATUS); 397 // MAPI_CMD_CEC_MSG_DC_PLAY 398 UADP_SPT_NAME0NXT(CEC_MSG_DC_PLAY, stCEC_MSG_DC_PLAY); 399 // MAPI_CMD_CEC_MSG_REQ_MENU_STATUS 400 UADP_SPT_NAME0NXT(CEC_MSG_REQ_MENU_STATUS, stCEC_MSG_REQ_MENU_STATUS); 401 // MAPI_CMD_CEC_MSG_USER_CTRL_PRESSED 402 UADP_SPT_NAME0NXT(CEC_MSG_USER_CTRL_PRESSED, stCEC_MSG_USER_CTRL_PRESSED); 403 // MAPI_CMD_CEC_MSG_USER_CTRL_RELEASED 404 UADP_SPT_NAME0NXT(CEC_MSG_USER_CTRL_RELEASED, stCEC_MSG_USER_CTRL_RELEASED); 405 // MAPI_CMD_CEC_MSG_GIVE_AUDIO_STATUS 406 UADP_SPT_NAME0NXT(CEC_MSG_GIVE_AUDIO_STATUS, stCEC_MSG_GIVE_AUDIO_STATUS); 407 // MAPI_CMD_CEC_MSG_REPORT_POWER_STATUS 408 UADP_SPT_NAME0NXT(CEC_MSG_REPORT_POWER_STATUS, stCEC_MSG_REPORT_POWER_STATUS); 409 // MAPI_CMD_CEC_MSG_REQ_POWER_STATUS 410 UADP_SPT_NAME0NXT(CEC_MSG_REQ_POWER_STATUS, stCEC_MSG_REQ_POWER_STATUS); 411 // MAPI_CMD_CEC_MSG_FEATURE_ABORT 412 UADP_SPT_NAME0NXT(CEC_MSG_FEATURE_ABORT, stCEC_MSG_FEATURE_ABORT); 413 // MAPI_CMD_CEC_MSG_ABORT 414 UADP_SPT_NAME0NXT(CEC_MSG_ABORT, stCEC_MSG_ABORT); 415 // MAPI_CMD_CEC_MSG_SEND_MENU_LANGUAGE 416 ulDataSize = sizeof(MS_U8) * CEC_MENU_LANGUAGE_COUNT; 417 UADP_SPT_BGN(&spt_CEC_MENU_LANGUAGE_CODE_TABLE[0], ulDataSize); 418 UADP_SPT_FIN(&spt_CEC_MENU_LANGUAGE_CODE_TABLE[1]); 419 UADP_SPT_NAME1NXT(CEC_MSG_SEND_MENU_LANGUAGE, stCEC_MSG_SEND_MENU_LANGUAGE, pu8MenulanguageCode, CEC_MENU_LANGUAGE_CODE_TABLE); 420 // MAPI_CMD_CEC_MSG_REQ_ARC_INITIATION 421 UADP_SPT_NAME0NXT(CEC_MSG_REQ_ARC_INITIATION, stCEC_MSG_REQ_ARC_INITIATION); 422 // MAPI_CMD_CEC_MSG_REQ_ARC_TERMINATION 423 UADP_SPT_NAME0NXT(CEC_MSG_REQ_ARC_TERMINATION, stCEC_MSG_REQ_ARC_TERMINATION); 424 // MAPI_CMD_CEC_MSG_AUDIO_MODE_REQ 425 UADP_SPT_NAME1NXT(CEC_MSG_AUDIO_MODE_REQ, stCEC_MSG_AUDIO_MODE_REQ, ucMyAddress, CEC_PHYSICAL_ADDRESS_TABLE); 426 // MAPI_CMD_CEC_MSG_REPORT_PHYCAL_ADDRESS2 427 UADP_SPT_NAME0NXT(CEC_MSG_REPORT_PHYCAL_ADDRESS2, stCEC_MSG_REPORT_PHYCAL_ADDRESS2); 428 // MAPI_CMD_CEC_CHECK_FRAME 429 UADP_SPT_NAME0NXT(CEC_CHECK_FRAME, stCEC_CHECK_FRAME); 430 // MAPI_CMD_CEC_ENABLED 431 UADP_SPT_NAME0NXT(CEC_ENABLED, stCEC_ENABLED); 432 // MAPI_CMD_CEC_GET_TX_STATUS 433 UADP_SPT_NAME0NXT(CEC_GET_TX_STATUS, stCEC_GET_TX_STATUS); 434 // MAPI_CMD_CEC_CHECK_DEVICE_IS_TX 435 UADP_SPT_NAME0NXT(CEC_DEVICE_IS_TX, stCEC_DEVICE_IS_TX); 436 // MAPI_CMD_CEC_SET_POWER_STATE 437 UADP_SPT_NAME0NXT(CEC_SET_POWER_STATE, stCEC_SET_POWER_STATE); 438 // MAPI_CMD_CEC_SET_MY_LOGICAL_ADDRESS2 439 UADP_SPT_NAME0NXT(CEC_SET_MY_LOGICAL_ADDRESS2, stCEC_SET_MY_LOGICAL_ADDRESS2); 440 // MAPI_CMD_CEC_GET_HEADER 441 UADP_SPT_NAME0NXT(CEC_GET_HEADER, stCEC_GET_HEADER); 442 // MAPI_CMD_CEC_GET_OPCODE 443 UADP_SPT_NAME0NXT(CEC_GET_OPCODE, stCEC_GET_OPCODE); 444 // MAPI_CMD_CEC_GET_PARA 445 UADP_SPT_NAME0NXT(CEC_GET_PARA, stCEC_GET_PARA); 446 // MAPI_CMD_CEC_GET_CMD_LEN 447 UADP_SPT_NAME0NXT(CEC_GET_CMD_LEN, stCEC_GET_CMD_LEN); 448 // MAPI_CMD_CEC_IS_RX_BUF_EMPTY 449 UADP_SPT_NAME0NXT(CEC_IS_RX_BUF_EMPTY, stCEC_IS_RX_BUF_EMPTY); 450 // MAPI_CMD_CEC_SET_ACTIVE_LOGICAL_ADDRESS 451 UADP_SPT_NAME0NXT(CEC_SET_ACTIVE_LOGICAL_ADDRESS, stCEC_SET_ACTIVE_LOGICAL_ADDRESS); 452 // MAPI_CMD_CEC_GET_ACTIVE_LOGICAL_ADDRESS 453 UADP_SPT_NAME0NXT(CEC_GET_ACTIVE_LOGICAL_ADDRESS, stCEC_GET_ACTIVE_LOGICAL_ADDRESS); 454 // MAPI_CMD_CEC_GET_POWER_STATUS 455 UADP_SPT_NAME0NXT(CEC_GET_POWER_STATUS, stCEC_GET_POWER_STATUS); 456 // MAPI_CMD_CEC_GET_FIFO_IDX 457 UADP_SPT_NAME0NXT(CEC_GET_FIFO_IDX, stCEC_GET_FIFO_IDX); 458 // MAPI_CMD_CEC_SET_FIFO_IDX 459 UADP_SPT_NAME0NXT(CEC_SET_FIFO_IDX, stCEC_SET_FIFO_IDX); 460 // MAPI_CMD_CEC_SET_ACTIVE_POWER_STATUS 461 UADP_SPT_NAME0NXT(CEC_SET_ACTIVE_POWER_STATUS, stCEC_SET_ACTIVE_POWER_STATUS); 462 // MAPI_CMD_CEC_GET_ACTIVE_POWER_STATUS 463 UADP_SPT_NAME0NXT(CEC_GET_ACTIVE_POWER_STATUS, stCEC_GET_ACTIVE_POWER_STATUS); 464 // MAPI_CMD_CEC_SET_ACTIVE_PHYSICAL_ADDRESS 465 UADP_SPT_NAME0NXT(CEC_SET_ACTIVE_PHYSICAL_ADDRESS, stCEC_SET_ACTIVE_PHYSICAL_ADDRESS); 466 // MAPI_CMD_CEC_SET_ACTIVE_DEVICE_CEC_VERSION 467 UADP_SPT_NAME0NXT(CEC_SET_ACTIVE_DEVICE_CEC_VERSION, stCEC_SET_ACTIVE_DEVICE_CEC_VERSION); 468 // MAPI_CMD_CEC_SET_ACTIVE_DEVICE_TYPE 469 UADP_SPT_NAME0NXT(CEC_SET_ACTIVE_DEVICE_TYPE, stCEC_SET_ACTIVE_DEVICE_TYPE); 470 // MAPI_CMD_CEC_GET_MSG_CNT 471 UADP_SPT_NAME0NXT(CEC_GET_MSG_CNT, stCEC_GET_MSG_CNT); 472 // MAPI_CMD_CEC_SET_MSG_CNT 473 UADP_SPT_NAME0NXT(CEC_SET_MSG_CNT, stCEC_SET_MSG_CNT); 474 // MAPI_CMD_CEC_GET_RX_DATA 475 UADP_SPT_NAME0NXT(CEC_GET_RX_DATA, stCEC_GET_RX_DATA); 476 // MAPI_CMD_CEC_SET_MY_PHYSICAL_ADDRESS 477 UADP_SPT_NAME1NXT(CEC_SET_MY_PHYSICAL_ADDRESS, stCEC_SET_MY_PHYSICAL_ADDRESS, ucData, CEC_PHYSICAL_ADDRESS_TABLE); 478 // MAPI_CMD_CEC_SET_MY_PHYSICAL_ADDRESS2 479 UADP_SPT_NAME1NXT(CEC_SET_MY_PHYSICAL_ADDRESS2, stCEC_SET_MY_PHYSICAL_ADDRESS2, ucData, CEC_PHYSICAL_ADDRESS_TABLE); 480 // MAPI_CMD_CEC_SET_INITIATOR 481 UADP_SPT_NAME0NXT(CEC_SET_INITIATOR, stCEC_SET_INITIATOR); 482 // MAPI_CMD_CEC_CONFIG_WAKEUP_INFO_VENDOR_ID 483 ulDataSize = sizeof(MS_U8) * CEC_VENDOR_ID_COUNT; 484 UADP_SPT_BGN(&spt_CEC_VENDOR_ID_TABLE[0], ulDataSize); 485 UADP_SPT_FIN(&spt_CEC_VENDOR_ID_TABLE[1]); 486 UADP_SPT_NAME1NXT(CEC_CONFIG_WAKEUP_INFO_VENDOR_ID, stCEC_CONFIG_WAKEUP_INFO_VENDOR_ID, ucVendorID, CEC_VENDOR_ID_TABLE); 487 // MAPI_CMD_CEC_SET_RETRY_COUNT 488 UADP_SPT_NAME0NXT(CEC_SET_RETRY_COUNT, stCEC_SET_RETRY_COUNT); 489 // MAPI_CMD_CEC_ATTACH_DRIVER_ISR 490 UADP_SPT_NAME0NXT(CEC_ATTACH_DRIVER_ISR, stCEC_ATTACH_DRIVER_ISR); 491 // MAPI_CMD_CEC_GET_CONFIGURATION 492 UADP_SPT_NAME0NXT(CEC_GET_CONFIGURATION, stCEC_GET_CONFIGURATION); 493 494 *pIoctl= (FUtopiaIOctl)CEC_adp_Ioctl; 495 496 return 0; 497 } 498 499 //************************************************************************** 500 // [Function Name]: 501 // CEC_adp_Ioctl() 502 // [Description] 503 // 504 // [Arguments]: 505 // 506 // [Return]: 507 // 508 //************************************************************************** 509 MS_U32 CEC_adp_Ioctl(void* pInstanceTmp, MS_U32 u32Cmd, void* const pArgs) 510 { 511 MS_U32 ulReturnValue = UTOPIA_STATUS_SUCCESS; 512 char usbuffer_arg[2]; 513 514 switch(u32Cmd) 515 { 516 case MAPI_CMD_DDC2BI_GET_INFO: 517 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_DDC2BI_GET_INFO, spt_CEC_DDC2BI_GET_INFO, usbuffer_arg, sizeof(usbuffer_arg)); 518 break; 519 520 case MAPI_CMD_CEC_INIT_CHIP: 521 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_INIT_CHIP, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 522 break; 523 524 case MAPI_CMD_CEC_PORT_SELECT: 525 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_PORT_SELECT, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 526 break; 527 528 case MAPI_CMD_CEC_EXIT: 529 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, pArgs); 530 break; 531 532 case MAPI_CMD_CEC_SET_MY_LOGICAL_ADDRESS: 533 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_MY_LOGICAL_ADDRES, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 534 break; 535 536 case MAPI_CMD_CEC_INIT: 537 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_INIT, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 538 break; 539 540 case MAPI_CMD_CEC_CHECK_EXIST_DEVICES: 541 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, pArgs); 542 break; 543 544 case MAPI_CMD_CEC_NEXT_DEVICE: 545 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_NEXT_DEVICE, usbuffer_arg, sizeof(usbuffer_arg)); 546 break; 547 548 case MAPI_CMD_CEC_CHK_RX_BUF: 549 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, pArgs); 550 break; 551 552 case MAPI_CMD_CEC_TX_SEND_MSG: 553 { 554 stCEC_TX_SEND_MSG stCECArgs = {0}; 555 556 if(IS_CMP_TASK()) 557 { 558 stCEC_TX_SEND_MSG_COMPAT stCompatCECArgs = {0}; 559 560 CMP_CPY_FROM_USER(&stCompatCECArgs, pArgs, sizeof(stCEC_TX_SEND_MSG_COMPAT)); 561 stCECArgs.ucCmd = malloc(sizeof(MS_U8) *stCompatCECArgs.ucLen); 562 CMP_CPY_FROM_USER(stCECArgs.ucCmd, stCompatCECArgs.ucCmd, sizeof(MS_U8) *stCompatCECArgs.ucLen); 563 stCECArgs.ucLen = stCompatCECArgs.ucLen; 564 stCECArgs.eDetAddr = stCompatCECArgs.eDetAddr; 565 stCECArgs.eMsg = stCompatCECArgs.eMsg; 566 567 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stCECArgs); 568 569 stCompatCECArgs.eErrorCode = stCECArgs.eErrorCode; 570 571 CMP_CPY_TO_USER(pArgs, &stCompatCECArgs, sizeof(stCEC_TX_SEND_MSG_COMPAT)); 572 573 free(stCECArgs.ucCmd); 574 } 575 else 576 { 577 void *pCommand = NULL; 578 579 CPY_FROM_USER(&stCECArgs, pArgs, sizeof(stCEC_TX_SEND_MSG)); 580 pCommand = stCECArgs.ucCmd; 581 stCECArgs.ucCmd = malloc(sizeof(MS_U8) *stCECArgs.ucLen); 582 CPY_FROM_USER(stCECArgs.ucCmd, pCommand, sizeof(MS_U8) *stCECArgs.ucLen); 583 584 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stCECArgs); 585 586 CPY_TO_USER(pArgs, &stCECArgs, sizeof(stCEC_TX_SEND_MSG)); 587 588 free(stCECArgs.ucCmd); 589 } 590 } 591 break; 592 593 case MAPI_CMD_CEC_TX_SEND_MSG2: 594 { 595 stCEC_TX_SEND_MSG2 stCECArgs = {0}; 596 597 if(IS_CMP_TASK()) 598 { 599 stCEC_TX_SEND_MSG2_COMPAT stCompatCECArgs = {0}; 600 601 CMP_CPY_FROM_USER(&stCompatCECArgs, pArgs, sizeof(stCEC_TX_SEND_MSG2_COMPAT)); 602 stCECArgs.ucCmd = malloc(sizeof(MS_U8) *stCompatCECArgs.ucLen); 603 CMP_CPY_FROM_USER(stCECArgs.ucCmd, stCompatCECArgs.ucCmd, sizeof(MS_U8) *stCompatCECArgs.ucLen); 604 stCECArgs.ucLen = stCompatCECArgs.ucLen; 605 stCECArgs.eDetAddr = stCompatCECArgs.eDetAddr; 606 stCECArgs.eMsg = stCompatCECArgs.eMsg; 607 608 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stCECArgs); 609 610 stCompatCECArgs.eErrorCode = stCECArgs.eErrorCode; 611 612 CMP_CPY_TO_USER(pArgs, &stCompatCECArgs, sizeof(stCEC_TX_SEND_MSG2_COMPAT)); 613 614 free(stCECArgs.ucCmd); 615 } 616 else 617 { 618 void *pCommand = NULL; 619 620 CPY_FROM_USER(&stCECArgs, pArgs, sizeof(stCEC_TX_SEND_MSG2)); 621 pCommand = stCECArgs.ucCmd; 622 stCECArgs.ucCmd = malloc(sizeof(MS_U8) *stCECArgs.ucLen); 623 CPY_FROM_USER(stCECArgs.ucCmd, pCommand, sizeof(MS_U8) *stCECArgs.ucLen); 624 625 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stCECArgs); 626 627 CPY_TO_USER(pArgs, &stCECArgs, sizeof(stCEC_TX_SEND_MSG2)); 628 629 free(stCECArgs.ucCmd); 630 } 631 632 } 633 break; 634 635 case MAPI_CMD_CEC_TX_SEND_POLLING_MSG: 636 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_TX_SEND_POLLING_MSG, spt_CEC_TX_SEND_POLLING_MSG, usbuffer_arg, sizeof(usbuffer_arg)); 637 break; 638 639 case MAPI_CMD_CEC_MSG_ACTIVE_SOURCE: 640 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_MSG_ACTIVE_SOURCE, usbuffer_arg, sizeof(usbuffer_arg)); 641 break; 642 643 case MAPI_CMD_CEC_MSG_ROUTING_CHANGE: 644 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_ROUTING_CHANGE, spt_CEC_MSG_ROUTING_CHANGE, usbuffer_arg, sizeof(usbuffer_arg)); 645 break; 646 647 case MAPI_CMD_CEC_MSG_REQ_ACTIVE_SOURCE: 648 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_MSG_REQ_ACTIVE_SOURCE, usbuffer_arg, sizeof(usbuffer_arg)); 649 break; 650 651 case MAPI_CMD_CEC_MSG_SET_STREAM_PATH: 652 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_SET_STREAM_PATH, spt_CEC_MSG_SET_STREAM_PATH, usbuffer_arg, sizeof(usbuffer_arg)); 653 break; 654 655 case MAPI_CMD_CEC_MSG_STANDBY: 656 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_STANDBY, spt_CEC_MSG_STANDBY, usbuffer_arg, sizeof(usbuffer_arg)); 657 break; 658 659 case MAPI_CMD_CEC_MSG_RECORD_OFF: 660 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_RECORD_OFF, spt_CEC_MSG_RECORD_OFF, usbuffer_arg, sizeof(usbuffer_arg)); 661 break; 662 663 case MAPI_CMD_CEC_MSG_RECORD_ON: 664 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_RECORD_ON, spt_CEC_MSG_RECORD_ON, usbuffer_arg, sizeof(usbuffer_arg)); 665 break; 666 667 case MAPI_CMD_CEC_MSG_REPORT_CEC_VERSION: 668 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_REPORT_CEC_VERSION, spt_CEC_MSG_REPORT_CEC_VERSION, usbuffer_arg, sizeof(usbuffer_arg)); 669 break; 670 671 case MAPI_CMD_CEC_MSG_REQ_CEC_VERSION: 672 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_REQ_CEC_VERSION, spt_CEC_MSG_REQ_CEC_VERSION, usbuffer_arg, sizeof(usbuffer_arg)); 673 break; 674 675 case MAPI_CMD_CEC_MSG_REPORT_PHYCAL_ADDRESS: 676 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_MSG_REPORT_PHYCAL_ADDRESS, usbuffer_arg, sizeof(usbuffer_arg)); 677 break; 678 679 case MAPI_CMD_CEC_MSG_REQ_PHYCAL_ADDRESS: 680 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_REQ_PHYCAL_ADDRESS, spt_CEC_MSG_REQ_PHYCAL_ADDRESS, usbuffer_arg, sizeof(usbuffer_arg)); 681 break; 682 683 case MAPI_CMD_CEC_MSG_DECK_CONTROL: 684 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_DECK_CONTROL, spt_CEC_MSG_DECK_CONTROL, usbuffer_arg, sizeof(usbuffer_arg)); 685 break; 686 687 case MAPI_CMD_CEC_MSG_DEC_STATUS: 688 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_DEC_STATUS, spt_CEC_MSG_DEC_STATUS, usbuffer_arg, sizeof(usbuffer_arg)); 689 break; 690 691 case MAPI_CMD_CEC_MSG_GIVE_DECK_STATUS: 692 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_GIVE_DECK_STATUS, spt_CEC_MSG_GIVE_DECK_STATUS, usbuffer_arg, sizeof(usbuffer_arg)); 693 break; 694 695 case MAPI_CMD_CEC_MSG_DC_PLAY: 696 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_DC_PLAY, spt_CEC_MSG_DC_PLAY, usbuffer_arg, sizeof(usbuffer_arg)); 697 break; 698 699 case MAPI_CMD_CEC_MSG_REQ_MENU_STATUS: 700 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_REQ_MENU_STATUS, spt_CEC_MSG_REQ_MENU_STATUS, usbuffer_arg, sizeof(usbuffer_arg)); 701 break; 702 703 case MAPI_CMD_CEC_MSG_USER_CTRL_PRESSED: 704 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_USER_CTRL_PRESSED, spt_CEC_MSG_USER_CTRL_PRESSED, usbuffer_arg, sizeof(usbuffer_arg)); 705 break; 706 707 case MAPI_CMD_CEC_MSG_USER_CTRL_RELEASED: 708 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_USER_CTRL_RELEASED, spt_CEC_MSG_USER_CTRL_RELEASED, usbuffer_arg, sizeof(usbuffer_arg)); 709 break; 710 711 case MAPI_CMD_CEC_MSG_GIVE_AUDIO_STATUS: 712 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_GIVE_AUDIO_STATUS, spt_CEC_MSG_GIVE_AUDIO_STATUS, usbuffer_arg, sizeof(usbuffer_arg)); 713 break; 714 715 case MAPI_CMD_CEC_MSG_REPORT_POWER_STATUS: 716 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_REPORT_POWER_STATUS, spt_CEC_MSG_REPORT_POWER_STATUS, usbuffer_arg, sizeof(usbuffer_arg)); 717 break; 718 719 case MAPI_CMD_CEC_MSG_REQ_POWER_STATUS: 720 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_REQ_POWER_STATUS, spt_CEC_MSG_REQ_POWER_STATUS, usbuffer_arg, sizeof(usbuffer_arg)); 721 break; 722 723 case MAPI_CMD_CEC_MSG_FEATURE_ABORT: 724 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_FEATURE_ABORT, spt_CEC_MSG_FEATURE_ABORT, usbuffer_arg, sizeof(usbuffer_arg)); 725 break; 726 727 case MAPI_CMD_CEC_MSG_ABORT: 728 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_ABORT, spt_CEC_MSG_ABORT, usbuffer_arg, sizeof(usbuffer_arg)); 729 break; 730 731 case MAPI_CMD_CEC_MSG_SEND_MENU_LANGUAGE: 732 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_SEND_MENU_LANGUAGE, spt_CEC_MSG_SEND_MENU_LANGUAGE, usbuffer_arg, sizeof(usbuffer_arg)); 733 break; 734 735 case MAPI_CMD_CEC_MSG_REQ_ARC_INITIATION: 736 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_REQ_ARC_INITIATION, spt_CEC_MSG_REQ_ARC_INITIATION, usbuffer_arg, sizeof(usbuffer_arg)); 737 break; 738 739 case MAPI_CMD_CEC_MSG_REQ_ARC_TERMINATION: 740 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_REQ_ARC_TERMINATION, spt_CEC_MSG_REQ_ARC_TERMINATION, usbuffer_arg, sizeof(usbuffer_arg)); 741 break; 742 743 case MAPI_CMD_CEC_MSG_AUDIO_MODE_REQ: 744 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_MSG_AUDIO_MODE_REQ, spt_CEC_MSG_AUDIO_MODE_REQ, usbuffer_arg, sizeof(usbuffer_arg)); 745 break; 746 747 case MAPI_CMD_CEC_MSG_REPORT_PHYCAL_ADDRESS2: 748 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_MSG_REPORT_PHYCAL_ADDRESS2, usbuffer_arg, sizeof(usbuffer_arg)); 749 break; 750 751 case MAPI_CMD_CEC_CHECK_FRAME: 752 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_CHECK_FRAME, spt_CEC_CHECK_FRAME, usbuffer_arg, sizeof(usbuffer_arg)); 753 break; 754 755 case MAPI_CMD_CEC_CONFIG_WAKEUP: 756 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, pArgs); 757 break; 758 759 case MAPI_CMD_CEC_ENABLED: 760 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_ENABLED, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 761 break; 762 763 case MAPI_CMD_CEC_GET_TX_STATUS: 764 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_TX_STATUS, usbuffer_arg, sizeof(usbuffer_arg)); 765 break; 766 767 case MAPI_CMD_CEC_CHECK_DEVICE_IS_TX: 768 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_DEVICE_IS_TX, usbuffer_arg, sizeof(usbuffer_arg)); 769 break; 770 771 case MAPI_CMD_CEC_SET_POWER_STATE: 772 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_POWER_STATE, spt_CEC_SET_POWER_STATE, usbuffer_arg, sizeof(usbuffer_arg)); 773 break; 774 775 case MAPI_CMD_CEC_SET_MY_LOGICAL_ADDRESS2: 776 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_MY_LOGICAL_ADDRESS2, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 777 break; 778 779 case MAPI_CMD_CEC_GET_HEADER: 780 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_HEADER, usbuffer_arg, sizeof(usbuffer_arg)); 781 break; 782 783 case MAPI_CMD_CEC_GET_OPCODE: 784 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_OPCODE, usbuffer_arg, sizeof(usbuffer_arg)); 785 break; 786 787 case MAPI_CMD_CEC_GET_PARA: 788 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_GET_PARA, spt_CEC_GET_PARA, usbuffer_arg, sizeof(usbuffer_arg)); 789 break; 790 791 case MAPI_CMD_CEC_GET_CMD_LEN: 792 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_CMD_LEN, usbuffer_arg, sizeof(usbuffer_arg)); 793 break; 794 795 case MAPI_CMD_CEC_IS_RX_BUF_EMPTY: 796 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_IS_RX_BUF_EMPTY, usbuffer_arg, sizeof(usbuffer_arg)); 797 break; 798 799 case MAPI_CMD_CEC_SET_ACTIVE_LOGICAL_ADDRESS: 800 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_ACTIVE_LOGICAL_ADDRESS, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 801 break; 802 803 case MAPI_CMD_CEC_GET_ACTIVE_LOGICAL_ADDRESS: 804 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_ACTIVE_LOGICAL_ADDRESS, usbuffer_arg, sizeof(usbuffer_arg)); 805 break; 806 807 case MAPI_CMD_CEC_GET_POWER_STATUS: 808 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_POWER_STATUS, usbuffer_arg, sizeof(usbuffer_arg)); 809 break; 810 811 case MAPI_CMD_CEC_GET_FIFO_IDX: 812 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_FIFO_IDX, usbuffer_arg, sizeof(usbuffer_arg)); 813 break; 814 815 case MAPI_CMD_CEC_SET_FIFO_IDX: 816 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_FIFO_IDX, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 817 break; 818 819 case MAPI_CMD_CEC_SET_ACTIVE_POWER_STATUS: 820 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_ACTIVE_POWER_STATUS, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 821 break; 822 823 case MAPI_CMD_CEC_GET_ACTIVE_POWER_STATUS: 824 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_ACTIVE_POWER_STATUS, usbuffer_arg, sizeof(usbuffer_arg)); 825 break; 826 827 case MAPI_CMD_CEC_SET_ACTIVE_PHYSICAL_ADDRESS: 828 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_ACTIVE_PHYSICAL_ADDRESS, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 829 break; 830 831 case MAPI_CMD_CEC_SET_ACTIVE_DEVICE_CEC_VERSION: 832 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_ACTIVE_DEVICE_CEC_VERSION, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 833 break; 834 835 case MAPI_CMD_CEC_SET_ACTIVE_DEVICE_TYPE: 836 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_ACTIVE_DEVICE_TYPE, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 837 break; 838 839 case MAPI_CMD_CEC_GET_MSG_CNT: 840 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_MSG_CNT, usbuffer_arg, sizeof(usbuffer_arg)); 841 break; 842 843 case MAPI_CMD_CEC_SET_MSG_CNT: 844 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_MSG_CNT, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 845 break; 846 847 case MAPI_CMD_CEC_GET_RX_DATA: 848 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_GET_RX_DATA, spt_CEC_GET_RX_DATA, usbuffer_arg, sizeof(usbuffer_arg)); 849 break; 850 851 case MAPI_CMD_CEC_SET_MY_PHYSICAL_ADDRESS: 852 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_MY_PHYSICAL_ADDRESS, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 853 break; 854 855 case MAPI_CMD_CEC_SET_MY_PHYSICAL_ADDRESS2: 856 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_MY_PHYSICAL_ADDRESS2, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 857 break; 858 859 case MAPI_CMD_CEC_SET_INITIATOR: 860 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_INITIATOR, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 861 break; 862 863 case MAPI_CMD_CEC_CONFIG_WAKEUP_INFO_VENDOR_ID: 864 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_CONFIG_WAKEUP_INFO_VENDOR_ID, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 865 break; 866 867 case MAPI_CMD_CEC_SET_RETRY_COUNT: 868 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_SET_RETRY_COUNT, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 869 break; 870 871 case MAPI_CMD_CEC_ATTACH_DRIVER_ISR: 872 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_CEC_ATTACH_DRIVER_ISR, NULL, usbuffer_arg, sizeof(usbuffer_arg)); 873 break; 874 875 case MAPI_CMD_CEC_GET_CONFIGURATION: 876 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, NULL, spt_CEC_GET_CONFIGURATION, usbuffer_arg, sizeof(usbuffer_arg)); 877 break; 878 879 default: 880 881 break; 882 }; 883 884 return ulReturnValue; 885 } 886 887 #endif // _ADP_CEC_C_