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 apiMHL.c 81 /// @author MStar Semiconductor Inc. 82 /// @brief MHL driver Function 83 /////////////////////////////////////////////////////////////////////////////////////////////////// 84 85 #ifndef _API_MHL_V2_C_ 86 #define _API_MHL_V2_C_ 87 88 //------------------------------------------------------------------------------------------------- 89 // Include Files 90 //------------------------------------------------------------------------------------------------- 91 // Common Definition 92 #include "MsCommon.h" 93 #include "MsVersion.h" 94 #ifdef MSOS_TYPE_LINUX_KERNEL 95 #include <linux/string.h> 96 #else 97 #include <string.h> 98 #endif 99 100 #include "MsOS.h" 101 #include "utopia.h" 102 #include "utopia_dapi.h" 103 #include "mdrv_mhl_st.h" 104 #include "apiMHL.h" 105 #include "drvMHL.h" 106 #include "apiMHL_private.h" 107 108 //------------------------------------------------------------------------------------------------- 109 // Local Defines 110 //------------------------------------------------------------------------------------------------- 111 #if(defined(CONFIG_MLOG)) 112 #include "ULog.h" 113 114 #define MAPI_MHL_MSG_INFO(format, args...) ULOGI("MHL", format, ##args) 115 #define MAPI_MHL_MSG_WARNING(format, args...) ULOGW("MHL", format, ##args) 116 #define MAPI_MHL_MSG_DEBUG(format, args...) ULOGD("MHL", format, ##args) 117 #define MAPI_MHL_MSG_ERROR(format, args...) ULOGE("MHL", format, ##args) 118 #define MAPI_MHL_MSG_FATAL(format, args...) ULOGF("MHL", format, ##args) 119 120 #else 121 #define MAPI_MHL_MSG_INFO(format, args...) printf(format, ##args) 122 #define MAPI_MHL_MSG_WARNING(format, args...) printf(format, ##args) 123 #define MAPI_MHL_MSG_DEBUG(format, args...) printf(format, ##args) 124 #define MAPI_MHL_MSG_ERROR(format, args...) printf(format, ##args) 125 #define MAPI_MHL_MSG_FATAL(format, args...) printf(format, ##args) 126 127 #endif 128 129 //------------------------------------------------------------------------------------------------- 130 // Local Structures 131 //------------------------------------------------------------------------------------------------- 132 133 //------------------------------------------------------------------------------------------------- 134 // Global Variables 135 //------------------------------------------------------------------------------------------------- 136 137 //------------------------------------------------------------------------------------------------- 138 // Local Variables 139 //------------------------------------------------------------------------------------------------- 140 141 //------------------------------------------------------------------------------------------------- 142 // Local Functions 143 //------------------------------------------------------------------------------------------------- 144 145 //------------------------------------------------------------------------------------------------- 146 // Global Functions 147 //------------------------------------------------------------------------------------------------- 148 #if(MHL_USE_UTOPIA_VERSION == MHL_UTOPIA_VERSION_20) 149 //************************************************************************** 150 // [Function Name]: 151 // MHLOpen() 152 // [Description] 153 // 154 // [Arguments]: 155 // 156 // [Return]: 157 // 158 //************************************************************************** 159 MS_U32 MHLOpen(void** ppInstance, const void* const pAttribute) 160 { 161 MHL_INSTANT_PRIVATE *psMHLInstPri = NULL; 162 163 //UTOPIA_TRACE(MS_UTOPIA_DB_LEVEL_TRACE,printf("enter %s %d\n",__FUNCTION__,__LINE__)); 164 // instance is allocated here, also can allocate private for internal use, ex, BDMA_INSTANT_PRIVATE 165 UtopiaInstanceCreate(sizeof(MHL_INSTANT_PRIVATE), ppInstance); 166 // setup func in private and assign the calling func in func ptr in instance private 167 UtopiaInstanceGetPrivate(*ppInstance, (void**)&psMHLInstPri); 168 169 psMHLInstPri->fpMHLSupportPath = (IOCTL_MHL_SUPPORT_PATH)mdrv_mhl_MHLSupportPath; 170 psMHLInstPri->fpMHLInitial = (IOCTL_MHL_INITIAL)mdrv_mhl_Initial; 171 psMHLInstPri->fpMHLHandler = (IOCTL_MHL_HANDLER)mdrv_mhl_Handler; 172 psMHLInstPri->fpMHLAutoSwitchHandler = (IOCTL_MHL_AUTO_SWITCH)mdrv_mhl_AutoSwitchHandler; 173 psMHLInstPri->fpMHLSetPowerState = (IOCTL_MHL_SET_POWER_STATE)mdrv_mhl_SetPowerState; 174 psMHLInstPri->fpMHLCbusControl = (IOCTL_MHL_CBUS_CONTROL)mdrv_mhl_CbusControl; 175 psMHLInstPri->fpMHLLoadEDID = (IOCTL_MHL_LOAD_EDID)mdrv_mhl_LoadEDID; 176 psMHLInstPri->fpMHLReadEDID = (IOCTL_MHL_READ_EDID)mdrv_mhl_ReadEDID; 177 psMHLInstPri->fpMHLLoadDeviceCapability = (IOCTL_MHL_LOAD_DEVCAP)mdrv_mhl_LoadDeviceCapability; 178 psMHLInstPri->fpMHLSetVenderID = (IOCTL_MHL_SET_VENDER_ID)mdrv_mhl_SetVenderID; 179 psMHLInstPri->fpMHLCableDetectInvert = (IOCTL_MHL_CABLE_DETECT_INVERT)mdrv_mhl_InvertCableDetect; 180 psMHLInstPri->fpMHLVbusConfigSetting = (IOCTL_MHL_VBUS_CONFIG)mdrv_mhl_VbusConfigSetting; 181 psMHLInstPri->fpMHLAdjustIControl = (IOCTL_MHL_ADJUST_I_CONTROL)mdrv_mhl_AdjustSettingIControl; 182 psMHLInstPri->fpMHLAdjustImpedance = (IOCTL_MHL_ADJUST_IMPEDANCE)mdrv_mhl_AdjustImpedanceSetting; 183 psMHLInstPri->fpMHLCableDetectFlag = (IOCTL_MHL_CABLE_DETECT_FLAG)mdrv_mhl_GetCableDetectFlag; 184 psMHLInstPri->fpMHLCbusConnectFlag = (IOCTL_MHL_CBUS_CONNECT_FLAG)mdrv_mhl_GetCbusConnectFlag; 185 psMHLInstPri->fpMHLCbusWakeupIntFlag = (IOCTL_MHL_CBUS_WAKEUP_FLAG)mdrv_mhl_CbusWakeupIntFlag; 186 psMHLInstPri->fpMHLSourceSupportRCP = (IOCTL_MHL_SOURCE_SUPPORT_RCP)mdrv_mhl_SrcRCPSupportFlag; 187 psMHLInstPri->fpMHLSourceSupportRAP = (IOCTL_MHL_SOURCE_SUPPORT_RAP)mdrv_mhl_SrcRAPSupportFlag; 188 psMHLInstPri->fpMHLGetStatusFlag = (IOCTL_MHL_GET_STATUS_FLAG)mdrv_mhl_CbusGetStatusFlag; 189 psMHLInstPri->fpMHLSendRAPCommand = (IOCTL_MHL_SEND_RAP_COMMAND)mdrv_mhl_SendRAPCommand; 190 psMHLInstPri->fpMHLSendRCPCommand = (IOCTL_MHL_SEND_RCP_COMMAND)mdrv_mhl_SendRCPAutoReleaseCmd; 191 psMHLInstPri->fpMHLSendUCPCommand = (IOCTL_MHL_SEND_UCP_COMMAND)mdrv_mhl_SendUCPCommand; 192 psMHLInstPri->fpMHLSendWriteBurst = (IOCTL_MHL_SEND_WRITE_BURST)mdrv_mhl_SendWriteBurst; 193 psMHLInstPri->fpMHLSendUserWriteBurst = (IOCTL_MHL_SEND_USER_WRITE_BURST)mdrv_mhl_CbusSendUserWriteBurst; 194 psMHLInstPri->fpMHLGetDeviceCapability = (IOCTL_MHL_GET_DEVCAP)mdrv_mhl_GetDeviceCapability; 195 psMHLInstPri->fpMHLGetExtendDeviceCapability = (IOCTL_MHL_GET_EXTEND_DEVCAP)mdrv_mhl_GetExtendDeviceCapability; 196 psMHLInstPri->fpMHLGetVenderID = (IOCTL_MHL_GET_VENDER_ID)mdrv_mhl_GetDeviceVenderID; 197 psMHLInstPri->fpMHLGetWriteBurstData = (IOCTL_MHL_GET_WRITE_BURST_DATA)mdrv_mhl_GetWriteBurstData; 198 psMHLInstPri->fpMHLRegisterCallBackfunction = (IOCTL_MHL_CALL_BACK_FUNCTION)mdrv_mhl_RegisterCallBackFunctions; 199 psMHLInstPri->fpMHLRegisterRCPCallBackfunction = (IOCTL_MHL_RCP_CALL_BACK_FUNCTION)mdrv_mhl_RegisterRcpCallBackFunction; 200 psMHLInstPri->fpMHLRegisterRAPCallBackfunction = (IOCTL_MHL_RAP_CALL_BACK_FUNCTION)mdrv_mhl_RegisterRapCallBackFunction; 201 psMHLInstPri->fpMHLRegisterUCPCallBackfunction = (IOCTL_MHL_UCP_CALL_BACK_FUNCTION)mdrv_mhl_RegisterUcpCallBackFunction; 202 psMHLInstPri->fpMHLRegisterATTCallBackfunction = (IOCTL_MHL_ATT_CALL_BACK_FUNCTION)mdrv_mhl_RegisterAttCallBackFunction; 203 psMHLInstPri->fpMHLRegisterRBPCallBackfunction = (IOCTL_MHL_RBP_CALL_BACK_FUNCTION)mdrv_mhl_RegisterRbpCallBackFunction; 204 psMHLInstPri->fpMHLGetConfiguration = (IOCTL_MHL_GET_CONFIGURATION)mdrv_mhl_GetConfiguration; 205 206 return UTOPIA_STATUS_SUCCESS; 207 } 208 209 //************************************************************************** 210 // [Function Name]: 211 // MHLIoctl() 212 // [Description] 213 // 214 // [Arguments]: 215 // 216 // [Return]: 217 // 218 //************************************************************************** 219 MS_U32 MHLIoctl(void* pInstance, MS_U32 u32Cmd, void* pArgs) 220 { 221 void* pModule = NULL; 222 MS_U32 ulReturnValue = UTOPIA_STATUS_SUCCESS; 223 MHL_INSTANT_PRIVATE* psMHLInstPri = NULL; 224 225 UtopiaInstanceGetModule(pInstance, &pModule); 226 UtopiaInstanceGetPrivate(pInstance, (void**)&psMHLInstPri); 227 228 switch(u32Cmd) 229 { 230 case MAPI_CMD_MHL_SUPPORT_PATH: 231 { 232 pstMHL_SET_SUPPORT_PATH pMHLArgs = (pstMHL_SET_SUPPORT_PATH)pArgs; 233 psMHLInstPri->fpMHLSupportPath(pInstance, pMHLArgs->ucSupportPath); 234 } 235 break; 236 237 case MAPI_CMD_MHL_INITIAL: 238 { 239 pstMHL_INITIAL_SETTING pMHLArgs = (pstMHL_INITIAL_SETTING)pArgs; 240 psMHLInstPri->fpMHLInitial(pInstance, pMHLArgs->ucEDIDTable, pMHLArgs->ucDevcapTable); 241 } 242 break; 243 244 case MAPI_CMD_MHL_HANDLER: 245 { 246 pstMHL_POLLING_HANDLER pMHLArgs = (pstMHL_POLLING_HANDLER)pArgs; 247 pMHLArgs->usMSGKeyInfo = psMHLInstPri->fpMHLHandler(pInstance); 248 } 249 break; 250 251 case MAPI_CMD_MHL_AUTO_SWITCH: 252 { 253 pstMHL_AUTO_SWITCH_HANDLER pMHLArgs = (pstMHL_AUTO_SWITCH_HANDLER)pArgs; 254 pMHLArgs->bAutoSwitchFlag = psMHLInstPri->fpMHLAutoSwitchHandler(pInstance, pMHLArgs->bResetFlag, pMHLArgs->ucCbusPath); 255 } 256 break; 257 258 case MAPI_CMD_MHL_SET_POWER_STATE: 259 { 260 pstMHL_SET_POWER_STATE pMHLArgs = (pstMHL_SET_POWER_STATE)pArgs; 261 pMHLArgs->ulFailFlag = psMHLInstPri->fpMHLSetPowerState(pInstance, pMHLArgs->usPowerState); 262 } 263 break; 264 265 case MAPI_CMD_MHL_CBUS_CONTROL: 266 { 267 pstMHL_CBUS_CONTROL pMHLArgs = (pstMHL_CBUS_CONTROL)pArgs; 268 psMHLInstPri->fpMHLCbusControl(pInstance, pMHLArgs->ucState); 269 } 270 break; 271 272 case MAPI_CMD_MHL_LOAD_EDID: 273 { 274 pstMHL_LOAD_EDID pMHLArgs = (pstMHL_LOAD_EDID)pArgs; 275 psMHLInstPri->fpMHLLoadEDID(pInstance, pMHLArgs->ucEDIDTable); 276 } 277 break; 278 279 case MAPI_CMD_MHL_READ_EDID: 280 { 281 pstMHL_READ_EDID pMHLArgs = (pstMHL_READ_EDID)pArgs; 282 psMHLInstPri->fpMHLReadEDID(pInstance, pMHLArgs->ucEDIDSize, pMHLArgs->ucEDIDTable); 283 } 284 break; 285 286 case MAPI_CMD_MHL_LOAD_DEVCAP: 287 { 288 pstMHL_LOAD_DEVCAP pMHLArgs = (pstMHL_LOAD_DEVCAP)pArgs; 289 psMHLInstPri->fpMHLLoadDeviceCapability(pInstance, pMHLArgs->ucDevcapTable); 290 } 291 break; 292 293 case MAPI_CMD_MHL_SET_VENDER_ID: 294 { 295 pstMHL_SET_VENDER_ID pMHLArgs = (pstMHL_SET_VENDER_ID)pArgs; 296 psMHLInstPri->fpMHLSetVenderID(pInstance, pMHLArgs->ucVenderID); 297 } 298 break; 299 300 case MAPI_CMD_MHL_SET_CABLE_DETECT_INVERT: 301 { 302 pstMHL_SET_CABLE_DETECT_INVERT pMHLArgs = (pstMHL_SET_CABLE_DETECT_INVERT)pArgs; 303 psMHLInstPri->fpMHLCableDetectInvert(pInstance, pMHLArgs->bCableDetectInvert); 304 } 305 break; 306 307 case MAPI_CMD_MHL_VBUS_CONFIG_SETTING: 308 { 309 pstMHL_VBUS_CONFIG_SETTING pMHLArgs = (pstMHL_VBUS_CONFIG_SETTING)pArgs; 310 psMHLInstPri->fpMHLVbusConfigSetting(pInstance, pMHLArgs->ucConfigMode); 311 } 312 break; 313 314 case MAPI_CMD_MHL_ADJUST_I_CONTROL: 315 { 316 pstMHL_ADJUST_I_CONTROL pMHLArgs = (pstMHL_ADJUST_I_CONTROL)pArgs; 317 psMHLInstPri->fpMHLAdjustIControl(pInstance, pMHLArgs->ucIControlValue); 318 } 319 break; 320 321 case MAPI_CMD_MHL_ADJUST_IMPEDANCE: 322 { 323 pstMHL_ADJUST_IMPEDANCE pMHLArgs = (pstMHL_ADJUST_IMPEDANCE)pArgs; 324 psMHLInstPri->fpMHLAdjustImpedance(pInstance, pMHLArgs->ucImpedanceValue); 325 } 326 break; 327 328 case MAPI_CMD_MHL_CABLE_DETECT_FLAG: 329 { 330 pstMHL_CABLE_DETECT_FLAG pMHLArgs = (pstMHL_CABLE_DETECT_FLAG)pArgs; 331 pMHLArgs->bCableDetectFlag = psMHLInstPri->fpMHLCableDetectFlag(pInstance); 332 } 333 break; 334 335 case MAPI_CMD_MHL_CBUS_CONNECT_FLAG: 336 { 337 pstMHL_CBUS_CONNECT_FLAG pMHLArgs = (pstMHL_CBUS_CONNECT_FLAG)pArgs; 338 pMHLArgs->bCbusConnectFlag = psMHLInstPri->fpMHLCbusConnectFlag(pInstance); 339 } 340 break; 341 342 case MAPI_CMD_MHL_CBUS_WAKEUP_INT_FLAG: 343 { 344 pstMHL_CBUS_WAKEUP_INT_FLAG pMHLArgs = (pstMHL_CBUS_WAKEUP_INT_FLAG)pArgs; 345 pMHLArgs->bCbusWakeupFlag = psMHLInstPri->fpMHLCbusWakeupIntFlag(pInstance); 346 } 347 break; 348 349 case MAPI_CMD_MHL_SOURCE_SUPPORT_RCP: 350 { 351 pstMHL_SOURCE_SUPPORT_RCP pMHLArgs = (pstMHL_SOURCE_SUPPORT_RCP)pArgs; 352 pMHLArgs->bSourceSupportRCP = psMHLInstPri->fpMHLSourceSupportRCP(pInstance); 353 } 354 break; 355 356 case MAPI_CMD_MHL_SOURCE_SUPPORT_RAP: 357 { 358 pstMHL_SOURCE_SUPPORT_RAP pMHLArgs = (pstMHL_SOURCE_SUPPORT_RAP)pArgs; 359 pMHLArgs->bSourceSupportRAP = psMHLInstPri->fpMHLSourceSupportRAP(pInstance); 360 } 361 break; 362 363 case MAPI_CMD_MHL_GET_STATUS_FLAG: 364 { 365 pstMHL_GET_STATUS_FLAG pMHLArgs = (pstMHL_GET_STATUS_FLAG)pArgs; 366 pMHLArgs->bStatusFlag = psMHLInstPri->fpMHLGetStatusFlag(pInstance, pMHLArgs->ucStatusType); 367 } 368 break; 369 370 case MAPI_CMD_MHL_SEND_RAP_COMMAND: 371 { 372 pstMHL_SEND_RAP_COMMAND pMHLArgs = (pstMHL_SEND_RAP_COMMAND)pArgs; 373 pMHLArgs->bSendFlag = psMHLInstPri->fpMHLSendRAPCommand(pInstance, pMHLArgs->ucKeyCode); 374 } 375 break; 376 377 case MAPI_CMD_MHL_SEND_RCP_COMMAND: 378 { 379 pstMHL_SEND_RCP_COMMAND pMHLArgs = (pstMHL_SEND_RCP_COMMAND)pArgs; 380 pMHLArgs->bSendFlag = psMHLInstPri->fpMHLSendRCPCommand(pInstance, pMHLArgs->ucKeyCode); 381 } 382 break; 383 384 case MAPI_CMD_MHL_SEND_UCP_COMMAND: 385 { 386 pstMHL_SEND_UCP_COMMAND pMHLArgs = (pstMHL_SEND_UCP_COMMAND)pArgs; 387 pMHLArgs->bSendFlag = psMHLInstPri->fpMHLSendUCPCommand(pInstance, pMHLArgs->ucKeyCode); 388 } 389 break; 390 391 case MAPI_CMD_MHL_SEND_WRITE_BURST: 392 { 393 pstMHL_SEND_WRITE_BURST pMHLArgs = (pstMHL_SEND_WRITE_BURST)pArgs; 394 pMHLArgs->bSendFlag = psMHLInstPri->fpMHLSendWriteBurst(pInstance, pMHLArgs->ucAddress, pMHLArgs->ucLength, pMHLArgs->ucData); 395 } 396 break; 397 398 case MAPI_CMD_MHL_SEND_USER_WRITE_BURST: 399 { 400 pstMHL_SEND_USER_WRITE_BURST pMHLArgs = (pstMHL_SEND_USER_WRITE_BURST)pArgs; 401 pMHLArgs->bSendFlag = psMHLInstPri->fpMHLSendUserWriteBurst(pInstance, pMHLArgs->ucLength, pMHLArgs->ucData); 402 } 403 break; 404 405 case MAPI_CMD_MHL_GET_DEVICE_CAPABILITY: 406 { 407 pstMHL_GET_DEVICE_CAPABILITY pMHLArgs = (pstMHL_GET_DEVICE_CAPABILITY)pArgs; 408 pMHLArgs->bObtainFlag = psMHLInstPri->fpMHLGetDeviceCapability(pInstance, pMHLArgs->usDevcapMask, pMHLArgs->ucDeviceCapability); 409 } 410 break; 411 412 case MAPI_CMD_MHL_GET_EXTEND_DEVICE_CAPABILITY: 413 { 414 pstMHL_GET_EXTEND_DEVICE_CAPABILITY pMHLArgs = (pstMHL_GET_EXTEND_DEVICE_CAPABILITY)pArgs; 415 pMHLArgs->bObtainFlag = psMHLInstPri->fpMHLGetExtendDeviceCapability(pInstance, pMHLArgs->usExtendDevcapMask, pMHLArgs->ucExtendDeviceCapability); 416 } 417 break; 418 419 case MAPI_CMD_MHL_GET_VENDER_ID: 420 { 421 pstMHL_GET_VENDER_ID pMHLArgs = (pstMHL_GET_VENDER_ID)pArgs; 422 pMHLArgs->bObtainFlag = psMHLInstPri->fpMHLGetVenderID(pInstance, pMHLArgs->ucVenderID); 423 } 424 break; 425 426 case MAPI_CMD_MHL_GET_WRITE_BURST_DATA: 427 { 428 pstMHL_GET_WRITE_BURST_DATA pMHLArgs = (pstMHL_GET_WRITE_BURST_DATA)pArgs; 429 pMHLArgs->bObtainFlag = psMHLInstPri->fpMHLGetWriteBurstData(pInstance, pMHLArgs->ucWriteBurstData); 430 } 431 break; 432 433 case MAPI_CMD_MHL_CALL_BACK_FUNCTION: 434 { 435 pstMHL_CALL_BACK_FUNCTION pMHLArgs = (pstMHL_CALL_BACK_FUNCTION)pArgs; 436 psMHLInstPri->fpMHLRegisterCallBackfunction(pInstance, pMHLArgs->bRCPfunctionFlag, pMHLArgs->bRAPfunctionFlag); 437 } 438 break; 439 440 case MAPI_CMD_MHL_RCP_CALL_BACK_FUNCTION: 441 { 442 pstMHL_RCP_CALL_BACK_FUNCTION pMHLArgs = (pstMHL_RCP_CALL_BACK_FUNCTION)pArgs; 443 psMHLInstPri->fpMHLRegisterRCPCallBackfunction(pInstance, pMHLArgs->bRCPfunctionFlag); 444 } 445 break; 446 447 case MAPI_CMD_MHL_RAP_CALL_BACK_FUNCTION: 448 { 449 pstMHL_RAP_CALL_BACK_FUNCTION pMHLArgs = (pstMHL_RAP_CALL_BACK_FUNCTION)pArgs; 450 psMHLInstPri->fpMHLRegisterRAPCallBackfunction(pInstance, pMHLArgs->bRAPfunctionFlag); 451 } 452 break; 453 454 case MAPI_CMD_MHL_UCP_CALL_BACK_FUNCTION: 455 { 456 pstMHL_UCP_CALL_BACK_FUNCTION pMHLArgs = (pstMHL_UCP_CALL_BACK_FUNCTION)pArgs; 457 psMHLInstPri->fpMHLRegisterUCPCallBackfunction(pInstance, pMHLArgs->bUCPfunctionFlag); 458 } 459 break; 460 461 case MAPI_CMD_MHL_ATT_CALL_BACK_FUNCTION: 462 { 463 pstMHL_ATT_CALL_BACK_FUNCTION pMHLArgs = (pstMHL_ATT_CALL_BACK_FUNCTION)pArgs; 464 psMHLInstPri->fpMHLRegisterATTCallBackfunction(pInstance, pMHLArgs->bATTfunctionFlag); 465 } 466 break; 467 468 case MAPI_CMD_MHL_RBP_CALL_BACK_FUNCTION: 469 { 470 pstMHL_RBP_CALL_BACK_FUNCTION pMHLArgs = (pstMHL_RBP_CALL_BACK_FUNCTION)pArgs; 471 psMHLInstPri->fpMHLRegisterRBPCallBackfunction(pInstance, pMHLArgs->bRBPfunctionFlag); 472 } 473 break; 474 475 case MAPI_CMD_MHL_GET_CONFIGURATION: 476 { 477 pstMHL_GET_CONFIGURATION pMHLArgs = (pstMHL_GET_CONFIGURATION)pArgs; 478 pMHLArgs->stInitialConfigInfo = psMHLInstPri->fpMHLGetConfiguration(pInstance); 479 } 480 break; 481 482 default: 483 ulReturnValue = UTOPIA_STATUS_FAIL; 484 break; 485 }; 486 487 return ulReturnValue; 488 } 489 490 //************************************************************************** 491 // [Function Name]: 492 // MHLClose() 493 // [Description] 494 // 495 // [Arguments]: 496 // 497 // [Return]: 498 // 499 //************************************************************************** 500 MS_U32 MHLClose(void* pInstance) 501 { 502 UtopiaInstanceDelete(pInstance); 503 504 return TRUE; 505 } 506 507 //************************************************************************** 508 // [Function Name]: 509 // MHLSTR() 510 // [Description] 511 // 512 // [Arguments]: 513 // 514 // [Return]: 515 // 516 //************************************************************************** 517 MS_U32 MHLSTR(MS_U32 ulPowerState, void* pModule) 518 { 519 MS_U32 ulReturnValue = UTOPIA_STATUS_FAIL; 520 521 ulReturnValue = mdrv_mhl_STREventProc(pModule, (EN_POWER_MODE)ulPowerState); 522 523 return ulReturnValue; 524 } 525 526 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT 527 //************************************************************************** 528 // [Function Name]: 529 // MHLMdbIoctl() 530 // [Description] 531 // 532 // [Arguments]: 533 // 534 // [Return]: 535 // 536 //************************************************************************** 537 MS_U32 MHLMdbIoctl(MS_U32 cmd, const void* const pArgs) 538 { 539 void* pInstance = NULL; 540 MS_U32 ulReturnValue = UTOPIA_STATUS_SUCCESS; 541 MDBCMD_CMDLINE_PARAMETER *paraCmdLine; 542 MDBCMD_GETINFO_PARAMETER *paraGetInfo; 543 544 pInstance = UtopiaModuleGetLocalInstantList(MODULE_MHL, pInstance); 545 546 switch(cmd) 547 { 548 case MDBCMD_CMDLINE: 549 paraCmdLine = (MDBCMD_CMDLINE_PARAMETER *)pArgs; 550 MdbPrint(paraCmdLine->u64ReqHdl,"u32CmdSize: %d\n", paraCmdLine->u32CmdSize); 551 mdrv_mhl_MDCMDEchoCommand(pInstance, paraCmdLine->u64ReqHdl, paraCmdLine->pcCmdLine); 552 paraCmdLine->result = MDBRESULT_SUCCESS_FIN; 553 break; 554 555 case MDBCMD_GETINFO: 556 paraGetInfo = (MDBCMD_GETINFO_PARAMETER *)pArgs; 557 mdrv_mhl_MDCMDGetInfo(pInstance, paraGetInfo->u64ReqHdl); 558 paraGetInfo->result = MDBRESULT_SUCCESS_FIN; 559 break; 560 561 default: 562 paraGetInfo = (MDBCMD_GETINFO_PARAMETER *)pArgs; 563 MdbPrint(paraGetInfo->u64ReqHdl,"unknown cmd\n", __LINE__); 564 break; 565 }; 566 567 return ulReturnValue; 568 } 569 #endif 570 571 //************************************************************************** 572 // [Function Name]: 573 // MHLRegisterToUtopia() 574 // [Description] 575 // 576 // [Arguments]: 577 // 578 // [Return]: 579 // 580 //************************************************************************** 581 void MHLRegisterToUtopia(FUtopiaOpen ModuleType) 582 { 583 void* pUtopiaModule = NULL; 584 void* psResource = NULL; 585 586 // 1. deal with module 587 UtopiaModuleCreate(MODULE_MHL, 0, &pUtopiaModule); 588 UtopiaModuleRegister(pUtopiaModule); 589 // register func for module, after register here, then ap call UtopiaOpen/UtopiaIoctl/UtopiaClose can call to these registered standard func 590 UtopiaModuleSetupFunctionPtr(pUtopiaModule, (FUtopiaOpen)MHLOpen, (FUtopiaClose)MHLClose, (FUtopiaIOctl)MHLIoctl); 591 592 #if(defined(MSOS_TYPE_LINUX_KERNEL)) 593 UtopiaModuleSetupSTRFunctionPtr(pUtopiaModule, (FUtopiaSTR)MHLSTR); 594 #endif 595 596 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT 597 UtopiaModuleRegisterMdbNode("MHL", (FUtopiaMdbIoctl)MHLMdbIoctl); 598 #endif 599 600 // 2. deal with resource 601 // start func to add res, call once will create 2 access in resource. Also can declare BDMA_POOL_ID_BDMA1 for another channel depend on driver owner. 602 UtopiaModuleAddResourceStart(pUtopiaModule, MHL_POOL); 603 // resource can alloc private for internal use, ex, BDMA_RESOURCE_PRIVATE 604 UtopiaResourceCreate("MHL", sizeof(MHL_RESOURCE_PRIVATE), &psResource); 605 // func to reg res 606 UtopiaResourceRegister(pUtopiaModule, psResource, MHL_POOL); 607 608 UtopiaModuleAddResourceEnd(pUtopiaModule, MHL_POOL); 609 } 610 611 #endif 612 613 #endif // _API_MHL_V2_C_