1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2014 - 2016 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 // Copyright (c) 2014-2016 MStar Semiconductor, Inc.
81 // All rights reserved.
82 //
83 // Unless otherwise stipulated in writing, any and all information contained
84 // herein regardless in any format shall remain the sole proprietary of
85 // MStar Semiconductor Inc. and be kept in strict confidence
86 // ("MStar Confidential Information") by the recipient.
87 // Any unauthorized act including without limitation unauthorized disclosure,
88 // copying, use, reproduction, sale, distribution, modification, disassembling,
89 // reverse engineering and compiling of the contents of MStar Confidential
90 // Information is unlawful and strictly prohibited. MStar hereby reserves the
91 // rights to any and all damages, losses, costs and expenses resulting therefrom.
92 //
93 ////////////////////////////////////////////////////////////////////////////////
94
95 #ifndef _ADP_HDMITX_C_
96 #define _ADP_HDMITX_C_
97
98 //-------------------------------------------------------------------------------------------------
99 // Include Files
100 //-------------------------------------------------------------------------------------------------
101 #include "MsCommon.h"
102 #include "MsVersion.h"
103 #include "MsDevice.h"
104
105 #ifdef MSOS_TYPE_LINUX_KERNEL
106 #include <linux/kernel.h>
107 #include <linux/string.h>
108 #include <linux/uaccess.h>
109 #include <linux/compat.h>
110 #else
111 #include <string.h>
112 #endif
113 #include <linux/sched.h>
114 #include <linux/slab.h>
115 #include <asm/uaccess.h>
116 #include "MsTypes.h"
117 #include "utopia.h"
118 #include "utopia_adp.h"
119 #include "MsOS.h"
120
121 #include "utopia_dapi.h"
122 #include "HDMITX_adp.h"
123 #include "apiHDMITx.h"
124 #include "apiHDMITx_v2.h"
125
126
127 //-------------------------------------------------------------------------------------------------
128 // Local Defines
129 //-------------------------------------------------------------------------------------------------
130 #ifdef MSOS_TYPE_LINUX_KERNEL
131 #define CPY_FROM_USER(a,b,c) if(copy_from_user(a,b,c) != 0) { break; }
132 #define CPY_TO_USER(a,b,c) if(copy_to_user(a,b,c) != 0) { break; }
133 #else
134 #define CPY_FROM_USER memcpy
135 #define CPY_TO_USER memcpy
136 #endif //MSOS_TYPE_LINUX_KERNEL
137
138 #if (defined(MSOS_TYPE_LINUX_KERNEL) && defined(CONFIG_COMPAT))
139 #define COMPAT_PTR(a) compat_ptr(a)
140 #define COMPAT_NEXT_PTR(a) (*((MS_U32*)compat_ptr((unsigned long)a)))
141 #define IS_CMP_TASK() is_compat_task()
142 #define CMP_CPY_FROM_USER(a,b,c) if(copy_from_user(a, compat_ptr((unsigned long)b), c) != 0) { break; }
143 #define CMP_CPY_TO_USER(a,b,c) if(copy_to_user(compat_ptr((unsigned long)a), b, c) != 0) { break; }
144 #define MS_COMPAT_HDMITX compat_uptr_t
145
146 #else
147 #define COMPAT_PTR(a) (a)
148 #define COMPAT_NEXT_PTR(a) (*((MS_U32*)a))
149 #define IS_CMP_TASK() (FALSE)
150 #define CMP_CPY_FROM_USER CPY_FROM_USER
151 #define CMP_CPY_TO_USER CPY_TO_USER
152 #define MS_COMPAT_HDMITX MS_U8*
153
154 #endif //CONFIG_COMPAT
155
156 //-------------------------------------------------------------------------------------------------
157 // Local Structures
158 //-------------------------------------------------------------------------------------------------
159 typedef struct DLL_PACKED
160 {
161 MS_COMPAT_HDMITX pu8Buffer;
162 MS_U8 u8BufSize;
163 MS_BOOL bReturn;
164 } stHDMITx_GetRxVideoFormatFromEDID_Compat,*pstHDMITx_GetRxVideoFormatFromEDID_Compat;
165
166 typedef struct DLL_PACKED
167 {
168 MS_COMPAT_HDMITX pu8Buffer;
169 MS_U8 u8BufSize;
170 MS_BOOL bReturn;
171 } stHDMITx_GetVICListFromEDID_Compat,*pstHDMITx_GetVICListFromEDID_Compat;
172
173 typedef struct DLL_PACKED
174 {
175 HDMITX_VIDEO_TIMING timing;
176 MS_COMPAT_HDMITX pColorFmt;
177 MS_BOOL bReturn;
178 } stHDMITx_GetColorFormatFromEDID_Compat,*pstHDMITx_GetColorFormatFromEDID_Compat;
179
180 typedef struct DLL_PACKED
181 {
182 MS_COMPAT_HDMITX pu8Buffer;
183 MS_U8 u8BufSize;
184 MS_BOOL bReturn;
185 } stHDMITx_GetRxAudioFormatFromEDID_Compat,*pstHDMITx_GetRxAudioFormatFromEDID_Compat;
186
187 typedef struct DLL_PACKED
188 {
189 MS_COMPAT_HDMITX pu8Buffer;
190 MS_BOOL bReturn;
191 } stHDMITx_GetRxIDManufacturerName_Compat,*pstHDMITx_GetRxIDManufacturerName_Compat;
192
193 typedef struct DLL_PACKED
194 {
195 MS_COMPAT_HDMITX pu8Buffer;
196 MS_BOOL BlockIdx;
197 MS_BOOL bReturn;
198 } stHDMITx_GetEDIDData_Compat,*pstHDMITx_GetEDIDData_Compat;
199
200 typedef struct DLL_PACKED
201 {
202 HDMITX_VIDEO_TIMING timing;
203 MS_COMPAT_HDMITX p3DStructure;
204 MS_BOOL bReturn;
205 } stHDMITx_GetRx3DStructureFromEDID_Compat,*pstHDMITx_GetRx3DStructureFromEDID_Compat;
206
207
208 typedef struct DLL_PACKED
209 {
210 HDMITX_PACKET_TYPE packet_type;
211 MS_COMPAT_HDMITX data;
212 MS_U8 length;
213 MS_BOOL bReturn;
214 } stHDMITx_PKT_Content_Define_Compat,*pstHDMITx_PKT_Content_Define_Compat;
215
216 typedef struct DLL_PACKED
217 {
218 MS_BOOL useinternalkey;
219 MS_COMPAT_HDMITX data;
220 } stHDMITx_GetHdcpKey_Compat,*pstHDMITx_GetHdcpKey_Compat;
221
222 typedef struct DLL_PACKED
223 {
224 MS_COMPAT_HDMITX pdata;
225 MS_BOOL bReturn;
226 } stHDMITx_GetBksv_Compat,*pstHDMITx_GetBksv_Compat;
227
228 typedef struct DLL_PACKED
229 {
230 MS_COMPAT_HDMITX pdata;
231 MS_BOOL bReturn;
232 } stHDMITx_GetAksv_Compat,*pstHDMITx_GetAksv_Compat;
233
234 typedef struct DLL_PACKED
235 {
236 MS_COMPAT_HDMITX data;
237 MS_U16 size;
238 } stHDMITx_HDCP_RevocationKey_List_Compat,*pstHDMITx_HDCP_RevocationKey_List_Compat;
239
240 typedef struct DLL_PACKED
241 {
242 MS_COMPAT_HDMITX data;
243 MS_U32 size;
244 MS_BOOL bReturn;
245 } stHDMITx_HDCP_IsSRMSignatureValid_Compat,*pstHDMITx_HDCP_IsSRMSignatureValid_Compat;
246
247 typedef struct DLL_PACKED
248 {
249 MS_COMPAT_HDMITX pdata;
250 } stHDMITx_GetEDIDPhyAdr_Compat,*pstHDMITx_GetEDIDPhyAdr_Compat;
251
252 typedef struct DLL_PACKED
253 {
254 EN_HDMITX_CAPS eCapType;
255 MS_COMPAT_HDMITX pRet;
256 MS_U32 ret_size;
257 MS_BOOL bReturn;
258 } stHDMITx_GetChipCaps_Compat,*pstHDMITx_GetChipCaps_Compat;
259
260 typedef struct DLL_PACKED
261 {
262 HDMITX_CEA_DB_TAG_CODE enTagCode;
263 HDMITX_CEA_EXT_TAG_CODE enExtTagCode;
264 MS_COMPAT_HDMITX pu8Data;
265 MS_U32 u32DataLen;
266 MS_COMPAT_HDMITX pu32RealLen;
267 MS_BOOL bReturn;
268 } stHDMITx_GetEdidDataBlocks_Compat, *pstHDMITx_GetEdidDataBlocks_Compat;
269
270 typedef struct DLL_PACKED
271 {
272 MS_COMPAT_HDMITX pu8Bstatus;
273 MS_COMPAT_HDMITX pu8KSVList;
274 MS_U16 u16BufLen;
275 MS_COMPAT_HDMITX pu16KSVLength;
276 MS_BOOL bReturn;
277 } stHDMITx_GetKSVList_Compat, *pstHDMITx_GetKSVList_Compat;
278
279 typedef struct DLL_PACKED
280 {
281 MS_U8 u8PortIdx;
282 MS_U8 u8OffsetAddr;
283 MS_U8 u8OpCode;
284 MS_COMPAT_HDMITX pu8RdBuf;
285 MS_U16 u16RdLen;
286 MS_COMPAT_HDMITX pu8WRBuff;
287 MS_U16 u16WrLen;
288 MS_BOOL bReturn;
289 } stHDMITx_HDCP2AccessX74_Compat, *pstHDMITx_HDCP2AccessX74_Compat;
290
291 typedef struct DLL_PACKED
292 {
293 MS_U8 u8PortIdx;
294 MS_COMPAT_HDMITX pu8Riv;
295 MS_COMPAT_HDMITX pu8KsXORLC128;
296 } stHDMITx_HDCP2TxFillCipherKey_Compat, *pstHDMITx_HDCP2TxFillCipherKey_Compat;
297
298
299 //-------------------------------------------------------------------------------------------------
300 // Global Variables
301 //-------------------------------------------------------------------------------------------------
302
303 //-------------------------------------------------------------------------------------------------
304 // Local Variables
305 //-------------------------------------------------------------------------------------------------
306
307 UADP_SPT_NAMEnNXT_DEF(HDMITX_BOOL, 0);
308
309 //Mapi_HDMITx_init()
310 UADP_SPT_NAMEnNXT_DEF(HDMITX_INIT, 0);
311
312 //Mapi_HDMITx_Exit()
313 UADP_SPT_NAMEnNXT_DEF(HDMITX_EXIT, 0);
314
315 //Mapi_HDMITx_TurnOnOff()
316 UADP_SPT_NAMEnNXT_DEF(HDMITX_TURNONOFF, 0);
317
318 //Mapi_HDMITx_EnablePacketGen()
319 UADP_SPT_NAMEnNXT_DEF(HDMITX_ENPKTGEN, 0);
320
321 //Mapi_HDMITx_SetHDMITxMode()
322 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETHDMITXMODE, 0);
323
324 //Mapi_HDMITx_SetHDMITxMode_CD()
325 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETHDMITXMODECD, 0);
326
327 //Mapi_HDMITx_SetTMDSOnOff()
328 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETTMDSONOFF, 0);
329
330 //Mapi_HDMITx_DisableTMDSCtrl()
331 UADP_SPT_NAMEnNXT_DEF(HDMITX_DISABLETMDSCTRL, 0);
332
333 //Mapi_HDMITx_SetRBChannelSwap()
334 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETRBCHSWAP, 0);
335
336 //Mapi_HDMITx_GetRxStatus()
337 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETRXSTATUS, 0);
338
339 //Mapi_HDMITx_GetRxDCInfoFromEDID()
340 UADP_SPT_NAMEnNXT_DEF(ColorDepthPt, 0);
341 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETDCINFOFROMEDID, 1);
342
343 //Mapi_HDMITx_GetRxVideoFormatFromEDID()
344 #if 0
345 UADP_SPT_NAMEnNXT_DEF(VidFmtData, 0);
346 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETRXVIDFMTFROMEDID, 1);
347 #endif
348
349 //Mapi_HDMITx_GetVICListFromEDID()
350 #if 0
351 UADP_SPT_NAMEnNXT_DEF(VICListData, 0);
352 UADP_SPT_NAMEnNXT_DEF(HDMITX_GTVICLISTFROMEDID, 1);
353 #endif
354
355 //Mapi_HDMITx_GetDataBlockLengthFromEDID()
356 UADP_SPT_NAMEnNXT_DEF(DataBlkLenPt, 0);
357 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETDATABLKLENFROMEDID, 1);
358
359 //Mapi_HDMITx_GetColorFormatFromEDID()
360 #if 0
361 UADP_SPT_NAMEnNXT_DEF(ColorFmtPt, 0);
362 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETCOLORFMTFROMEDID, 1);
363 #endif
364
365 //Mapi_HDMITx_GetRxAudioFormatFromEDID()
366 #if 0
367 UADP_SPT_NAMEnNXT_DEF(AudFmtData, 0);
368 UADP_SPT_NAMEnNXT_DEF(HDMITx_GETRXAUDFMTFROMEDID, 1);
369 #endif
370
371 //Mapi_HDMITx_EDID_HDMISupport()
372 UADP_SPT_NAMEnNXT_DEF(HDMISupPt, 0);
373 UADP_SPT_NAMEnNXT_DEF(HDMITX_EDIDHDMISUPPORT, 1);
374
375 //Mapi_HDMITx_GetRxIDManufacturerName()
376 #if 0
377 UADP_SPT_NAMEnNXT_DEF(ManuIDData, 0);
378 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETRXIDMANUFACTNAME, 1);
379 #endif
380
381 //Mapi_HDMITx_GetEDIDData()
382 #if 0
383 //UADP_SPT_NAMEnNXT_DEF(SinkEDIDBlockData, 0);
384 //UADP_SPT_NAMEnNXT_DEF(HDMITX_GETEDIDDATA, 1);
385 #endif
386
387 //Mapi_HDMITx_GetRx3DStructureFromEDID()
388 #if 0
389 UADP_SPT_NAMEnNXT_DEF(Edid3DStPt, 0);
390 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETRX3DSTRUCTFROMEDID, 1);
391 #endif
392
393 //Mapi_HDMITx_PKT_User_Define()
394 UADP_SPT_NAMEnNXT_DEF(HDMITX_PKTUSERDEF, 0);
395
396 //Mapi_HDMITx_PKT_Content_Define()
397 #if 0
398 //UADP_SPT_NAMEnNXT_DEF(UserDefPktContent, 0);
399 //UADP_SPT_NAMEnNXT_DEF(HDMITX_PKTCONTENTDEF, 1);
400 #endif
401
402 //Mapi_HDMITx_SetVideoOnOff()
403 UADP_SPT_NAMEnNXT_DEF(HDMITx_SETVIDONOFF, 0);
404
405 //Mapi_HDMITx_SetColorFormat
406 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETCOLORFMT, 0);
407
408 //Mapi_HDMITx_Set_VS_InfoFrame()
409 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETVSINFOFRAME, 0);
410
411 //Mapi_HDMITx_SetVideoOutputTiming()
412 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETVIDOUTPUTTIMING, 0);
413
414 //Mapi_HDMITx_SetVideoOutputTimingByCustomer()
415 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETVIDEOUTPUTTIMINGBYCUSTOMER, 0);
416
417 //Mapi_HDMITx_SetVideoOutputAsepctRatio()
418 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETVIDOUTPUTASPECTRATIO, 0);
419
420 //Mapi_HDMITx_SetVideoOutputOverscan_AFD()
421 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETVIDOUTPUTOVERSCANAFD, 0);
422
423 //Mapi_HDMITx_SetAudioOnOff()
424 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETAUDONOFF, 0);
425
426 //Mapi_HDMITx_SetAudioFrequency()
427 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETAUDFREQ, 0);
428
429 //Mapi_HDMITx_SetVideoOutputOverscan_AFD_II()
430 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETVIDOUTPUTOVERSCANAFD_II, 0);
431
432 //Mapi_HDMITx_SetAudioConfiguration()
433 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETAUDCONFIG, 0);
434
435 //Mapi_HDMITx_SetAudioSourceFormat()
436 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETAUDSRCFMT, 0);
437
438 //Mapi_HDMITx_SetAudioSourceFormat()
439 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETAVIINFOEXTCOLORIMETRY, 0);
440
441 //Mapi_HDMITx_GetAudioCTS()
442 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETAUDCTS, 0);
443
444 //Mapi_HDMITx_MuteAudioFIFO()
445 UADP_SPT_NAMEnNXT_DEF(HDMITX_MUTEAUDFIFO, 0);
446
447 //Mapi_HDMITx_GetHdcpKey()
448 //UADP_SPT_NAMEnNXT_DEF(Hdcp14KeyData, 0);
449 //UADP_SPT_NAMEnNXT_DEF(HDMITX_GETHDCPKEY, 1);
450
451 //Mapi_HDMITx_GetBksv()
452 //UADP_SPT_NAMEnNXT_DEF(Hdcp14BKSVData, 0);
453 //UADP_SPT_NAMEnNXT_DEF(HDMITX_GETBKSV, 1);
454
455 //Mapi_HDMITx_GetAksv()
456 //UADP_SPT_NAMEnNXT_DEF(Hdcp14AKSVData, 0);
457 //UADP_SPT_NAMEnNXT_DEF(HDMITX_GETAKSV, 1);
458
459 //Mapi_HDMITx_SetHDCPOnOff()
460 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETHDCPONOFF, 0);
461
462 //Mapi_HDMITx_SetAVMUTE()
463 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETAVMUTE, 0);
464
465 //Mapi_HDMITx_GetAVMUTEStatus()
466 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETAVMUTESTATUS, 0);
467
468 //Mapi_HDMITx_HDCP_RevocationKey_List()
469 //UADP_SPT_NAMEnNXT_DEF(Hdcp14RevokeList, 0);
470 //UADP_SPT_NAMEnNXT_DEF(HDMITX_HDCPREVOKEKEYLIST, 1);
471
472 //Mapi_HDMITx_HDCP_RevocationKey_Check()
473 UADP_SPT_NAMEnNXT_DEF(HDMITX_HDCP14REVOKEKEYCHK, 0);
474
475 //Mapi_HDMITx_HDCP_IsSRMSignatureValid()
476 #if 0
477 //UADP_SPT_NAMEnNXT_DEF(Hdcp14SRMSignData, 0);
478 //UADP_SPT_NAMEnNXT_DEF(HDMITX_HDCP14ISSRMSIGNVALID, 1);
479 #endif
480
481 //Mapi_HDMITx_GetHDCPStatus()
482 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETHDCPSTATUS, 0);
483
484 //Mapi_HDMITx_HDCP_StartAuth()
485 UADP_SPT_NAMEnNXT_DEF(HDMITX_HDCP14STARTAUTH, 0);
486
487 //Mapi_HDMITx_GetINTHDCPStatus()
488 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETINTHDCPSTATUS, 0);
489
490 //Mapi_HDMITx_GetHDCP_PreStatus()
491 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETHDCP14PRESTATUS, 0);
492
493 //Mapi_UnHDCPRxControl()
494 UADP_SPT_NAMEnNXT_DEF(HDMITX_UNHDCPRXCTRL, 0);
495
496 //Mapi_HDMITx_HDCPRxFailControl()
497 UADP_SPT_NAMEnNXT_DEF(HDMITX_HDCPRXFAILCTRL, 0);
498
499 //Mapi_HDMITx_GetLibVer()
500 #if 0
501 UADP_SPT_NAMEnNXT_DEF(MSIF_VER_PT, 0);
502 UADP_SPT_NAMEnNXT_DEF(LibVerPt, 1);
503 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETLIBVER, 1);
504 #endif
505
506 //Mapi_HDMITx_GetInfo()
507 UADP_SPT_NAMEnNXT_DEF(HdmiTxInfoPt, 0);
508 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETINFO, 1);
509
510 //Mapi_HDMITx_GetStatus()
511 UADP_SPT_NAMEnNXT_DEF(HdmiTxStatusPt, 0);
512 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETSTATUS, 1);
513
514 //Mapi_HDMITx_SetDbgLevels()
515 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETDBGLEVEL, 0);
516
517 //Mapi_HDMITx_SetHPDGpioPin()
518 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETHPDGPIOPIN, 0);
519
520 //Mapi_HDMITx_AnalogTuning()
521 UADP_SPT_NAMEnNXT_DEF(AnalogTuningPt, 0);
522 UADP_SPT_NAMEnNXT_DEF(HDMITX_ANALOGTUNING, 1);
523
524 //Mapi_HDMITx_ForceHDMIOutputMode()
525 UADP_SPT_NAMEnNXT_DEF(HDMITX_FORCEHDMIOUTPUTMODE, 0);
526
527 //Mapi_HDMITx_ForceHDMIOutputColorFormat()
528 UADP_SPT_NAMEnNXT_DEF(HDMITX_FORCEHDMIOUTPUTCOLORFMT, 0);
529
530 //Mapi_HDMITx_DisableRegWrite()
531 UADP_SPT_NAMEnNXT_DEF(HDMITX_DISABLEREGWRITE, 0);
532
533 //Mapi_HDMITx_GetEDIDPhyAdr()
534 //UADP_SPT_NAMEnNXT_DEF(EdidPhyAddrData, 0);
535 //UADP_SPT_NAMEnNXT_DEF(HDMITX_GETEDIDPHYADR, 1);
536
537 //Mapi_HDMITx_SetCECOnOff()
538 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETCECONOFF, 0);
539
540 //Mapi_HDMITx_GetCECStatus()
541 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETCECSTATUS, 0);
542
543 //Mapi_HDMITx_EdidChecking()
544 UADP_SPT_NAMEnNXT_DEF(HDMITX_EDIDCHECKING, 0);
545
546 //Mapi_HDMITx_RxBypass_Mode()
547 UADP_SPT_NAMEnNXT_DEF(HDMITX_RXBYPASSMODE, 0);
548
549 //Mapi_HDMITx_Disable_RxBypass()
550 UADP_SPT_NAMEnNXT_DEF(HDMITX_DISABLERXBYPASS, 0);
551
552 //Mapi_HDMITx_SetAksv2R0Interval()
553 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETAKSV2R0INTERVAL, 0);
554
555 //Mapi_HDMITx_IsHDCPRxValid()
556 UADP_SPT_NAMEnNXT_DEF(HDMITX_ISHDCPRXVALID, 0);
557
558 //Mapi_HDMITx_GetChipCaps()
559 #if 0
560 UADP_SPT_NAMEnNXT_DEF(HdmiChipCapInfo, 0);
561 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETCHIPCAPS, 1);
562 #endif
563
564 //Mapi_HDMITx_SetPowerState()
565 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETPWRSTATE, 0);
566
567 //Mapi_HDMITx_GetEdidDataBlocks()
568 #if 0
569 UADP_SPT_NAMEnNXT_DEF(SinkEDIDDataBlk, 0);
570 UADP_SPT_NAMEnNXT_DEF(DataBlkRetLenPt, 0);
571 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETEDIDDATABLKS, 2);
572 #endif
573
574 //Mapi_HDMITx_GetKSVList()
575 #if 0
576 UADP_SPT_NAMEnNXT_DEF(SinkBstatusData, 0);
577 UADP_SPT_NAMEnNXT_DEF(SinkKSVList, 0);
578 UADP_SPT_NAMEnNXT_DEF(KSVListLenPt, 0);
579 UADP_SPT_NAMEnNXT_DEF(HDMITX_GETKSVLIST, 3);
580 #endif
581
582 //Mapi_HDMITx_HDCP2AccessX74()
583 #if 0
584 UADP_SPT_NAMEnNXT_DEF(Hdcp22x74RdData, 0);
585 UADP_SPT_NAMEnNXT_DEF(Hdcp22x74WrData, 0);
586 UADP_SPT_NAMEnNXT_DEF(HDMITX_HDCP2ACCESSX74, 2);
587 #endif
588
589 //Mapi_HDMITx_HDCP2TxInit()
590 UADP_SPT_NAMEnNXT_DEF(HDMITX_HDCP2TXINIT, 0);
591
592 //Mapi_HDMITx_HDCP2TxEnableEncrypt()
593 UADP_SPT_NAMEnNXT_DEF(HDMITX_HDCP2TXENABLEENC, 0);
594
595
596 //Mapi_HDMITx_HDCP2TxFillCipherKey()
597 #if 0
598 UADP_SPT_NAMEnNXT_DEF(Hdcp22RivData, 0);
599 UADP_SPT_NAMEnNXT_DEF(Hdcp22KsData, 0);
600 UADP_SPT_NAMEnNXT_DEF(HDMITx_HDCP2TXFILLCIPHERKEY, 2);
601 #endif
602
603 //MApi_HDMITx_ColorandRange_Transform
604 UADP_SPT_NAMEnNXT_DEF(HDMITX_COLORRANGE_TRANSFORM, 0);
605
606 //MApi_HDMITx_SSC_Enable
607 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETSSCENABLE, 0);
608
609 //MApi_HDMITx_SetAVIInfoExtColorimetry
610 UADP_SPT_NAMEnNXT_DEF(HDMITX_SETCOLORIMETRY, 0);
611
612 //MApi_HDMITx_SetAVIInfoExtColorimetry
613 UADP_SPT_NAMEnNXT_DEF(HDMITX_GET_FULL_RX_STATUS, 0);
614
615 //MApi_HDMITx_SetAVIInfoExtColorimetry
616 UADP_SPT_NAMEnNXT_DEF(HDMITX_CHECK_LEGAL_TIMING, 0);
617
HDMITX_adp_Init(FUtopiaIOctl * pIoctl)618 MS_U32 HDMITX_adp_Init(FUtopiaIOctl* pIoctl)
619 {
620 MS_U32 u32DataSize = 0x00;
621
622 //MS_BOOL
623 UADP_SPT_NAME0NXT(HDMITX_BOOL, MS_BOOL);
624
625 //E_HDMITX_CMD_INIT:: Mapi_HDMITx_init()
626 UADP_SPT_NAME0NXT(HDMITX_INIT, stHDMITx_Init);
627
628 //E_HDMITX_CMD_INIT:: Mapi_HDMITx_Exit()
629 UADP_SPT_NAME0NXT(HDMITX_EXIT, stHDMITx_Exit);
630
631 //E_HDMITX_CMD_TURNONOFF:: Mapi_HDMITx_TurnOnOff()
632 UADP_SPT_NAME0NXT(HDMITX_TURNONOFF, stHDMITx_TurnOnOff);
633
634 //Mapi_HDMITx_EnablePacketGen()
635 UADP_SPT_NAME0NXT(HDMITX_ENPKTGEN, stHDMITx_EnablePacketGen);
636
637 //Mapi_HDMITx_SetHDMITxMode()
638 UADP_SPT_NAME0NXT(HDMITX_SETHDMITXMODE, stHDMITx_SetHDMITxMode);
639
640 //Mapi_HDMITx_SetHDMITxMode_CD()
641 UADP_SPT_NAME0NXT(HDMITX_SETHDMITXMODECD, stHDMITx_SetHDMITxMode_CD);
642
643 //Mapi_HDMITx_SetTMDSOnOff()
644 UADP_SPT_NAME0NXT(HDMITX_SETTMDSONOFF, stHDMITx_SetTMDSOnOff);
645
646 //Mapi_HDMITx_DisableTMDSCtrl()
647 UADP_SPT_NAME0NXT(HDMITX_DISABLETMDSCTRL, stHDMITx_DisableTMDSCtrl);
648
649 //Mapi_HDMITx_SetRBChannelSwap()
650 UADP_SPT_NAME0NXT(HDMITX_SETRBCHSWAP, stHDMITx_SetRBChannelSwap);
651
652 //Mapi_HDMITx_GetRxStatus()
653 UADP_SPT_NAME0NXT(HDMITX_GETRXSTATUS, stHDMITx_GetRxStatus);
654
655 //Mapi_HDMITx_GetRxDCInfoFromEDID()
656 UADP_SPT_NAME0NXT(ColorDepthPt, HDMITX_VIDEO_COLORDEPTH_VAL);
657 UADP_SDT_NAME1(HDMITX_GETDCINFOFROMEDID, stHDMITx_GetRxDCInfoFromEDID, UADP_SDT_P2N, val, ColorDepthPt);
658
659 //Mapi_HDMITx_GetRxVideoFormatFromEDID()
660 #if 0
661 #define DEF_EDID_VIDFMT_SIZE 127U
662 u32DataSize = sizeof(MS_U8) * DEF_EDID_VIDFMT_SIZE;
663 UADP_SPT_BGN(&spt_VidFmtData[0], u32DataSize);
664 UADP_SPT_FIN(&spt_VidFmtData[1]);
665 UADP_SPT_NAME1NXT(HDMITX_GETRXVIDFMTFROMEDID, stHDMITx_GetRxVideoFormatFromEDID, pu8Buffer, VidFmtData);
666 #undef DEF_EDID_VIDFMT_SIZE
667 #endif
668
669 //Mapi_HDMITx_GetVICListFromEDID()
670 #if 0
671 #define DEF_EDID_VICLIST_SIZE 127U
672 u32DataSize = sizeof(MS_U8) * DEF_EDID_VICLIST_SIZE;
673 UADP_SPT_BGN(&spt_VICListData[0], u32DataSize);
674 UADP_SPT_FIN(&spt_VICListData[1]);
675 UADP_SPT_NAME1NXT(HDMITX_GTVICLISTFROMEDID, stHDMITx_GetVICListFromEDID, pu8Buffer, VICListData);
676 #undef DEF_EDID_VICLIST_SIZE
677 #endif
678
679 //Mapi_HDMITx_GetDataBlockLengthFromEDID()
680 UADP_SPT_NAME0NXT(DataBlkLenPt, MS_U8);
681 UADP_SPT_NAME1NXT(HDMITX_GETDATABLKLENFROMEDID, stHDMITx_GetDataBlockLengthFromEDID, pu8Length, DataBlkLenPt);
682
683 //Mapi_HDMITx_GetColorFormatFromEDID()
684 #if 0
685 UADP_SPT_NAME0NXT(ColorFmtPt, HDMITX_EDID_COLOR_FORMAT);
686 UADP_SDT_NAME1(HDMITX_GETCOLORFMTFROMEDID, stHDMITx_GetColorFormatFromEDID, UADP_SDT_P2N, pColorFmt,ColorFmtPt);
687 #endif
688
689 //Mapi_HDMITx_GetRxAudioFormatFromEDID()
690 #if 0
691 #define DEF_EDID_AUDFMT_SIZE 127U
692 u32DataSize = sizeof(MS_U8) * DEF_EDID_AUDFMT_SIZE;
693 UADP_SPT_BGN(&spt_AudFmtData[0], u32DataSize);
694 UADP_SPT_FIN(&spt_AudFmtData[1]);
695 UADP_SPT_NAME1NXT(HDMITx_GETRXAUDFMTFROMEDID, stHDMITx_GetRxAudioFormatFromEDID, pu8Buffer, AudFmtData);
696 #undef DEF_EDID_AUDFMT_SIZE
697 #endif
698
699 //Mapi_HDMITx_EDID_HDMISupport()
700 UADP_SPT_NAME1NXT(HDMITX_EDIDHDMISUPPORT, stHDMITx_EDID_HDMISupport, HDMI_Support, HDMITX_BOOL);
701
702
703 //Mapi_HDMITx_GetRxIDManufacturerName()
704 #if 0
705 #define DEF_EDID_MANUFACTORID_SIZE 3U
706 u32DataSize = sizeof(MS_U8) * DEF_EDID_MANUFACTORID_SIZE;
707 UADP_SPT_BGN(&spt_ManuIDData[0], u32DataSize);
708 UADP_SPT_FIN(&spt_ManuIDData[1]);
709 UADP_SPT_NAME1NXT(HDMITX_GETRXIDMANUFACTNAME, stHDMITx_GetRxIDManufacturerName, pu8Buffer, ManuIDData);
710 #undef DEF_EDID_MANUFACTORID_SIZE
711 #endif
712
713 //Mapi_HDMITx_GetEDIDData()
714 #if 0
715 #define DEF_EDID_BLOCK_SIZE 128U
716 u32DataSize = sizeof(MS_U8) * DEF_EDID_BLOCK_SIZE;
717 UADP_SPT_BGN(&spt_SinkEDIDBlockData[0], u32DataSize);
718 UADP_SPT_FIN(&spt_SinkEDIDBlockData[1]);
719 UADP_SPT_NAME1NXT(HDMITX_GETEDIDDATA, stHDMITx_GetEDIDData, pu8Buffer, SinkEDIDBlockData);
720 #undef DEF_EDID_BLOCK_SIZE
721 #endif
722
723 //Mapi_HDMITx_GetRx3DStructureFromEDID()
724 #if 0
725 UADP_SPT_NAME0NXT(Edid3DStPt, HDMITX_EDID_3D_STRUCTURE_ALL);
726 UADP_SDT_NAME1(HDMITX_GETRX3DSTRUCTFROMEDID, stHDMITx_GetRx3DStructureFromEDID, UADP_SDT_P2N, p3DStructure, Edid3DStPt);
727 #endif
728
729 //Mapi_HDMITx_PKT_User_Define()
730 UADP_SPT_NAME0NXT(HDMITX_PKTUSERDEF, stHDMITx_PKT_User_Define);
731
732 //Mapi_HDMITx_PKT_Content_Define()
733 #if 0
734 #define DEF_MAX_U8_SIZE 127U
735 u32DataSize = sizeof(MS_U8) * DEF_MAX_U8_SIZE;
736 UADP_SPT_BGN(&spt_UserDefPktContent[0], u32DataSize);
737 UADP_SPT_FIN(&spt_UserDefPktContent[1]);
738 UADP_SPT_NAME1NXT(HDMITX_PKTCONTENTDEF, stHDMITx_PKT_Content_Define, data, UserDefPktContent);
739 #undef DEF_MAX_U8_SIZE
740 #endif
741
742 //Mapi_HDMITx_SetVideoOnOff()
743 UADP_SPT_NAME0NXT(HDMITx_SETVIDONOFF, stHDMITx_SetVideoOnOff);
744
745 //Mapi_HDMITx_SetColorFormat
746 UADP_SPT_NAME0NXT(HDMITX_SETCOLORFMT, stHDMITx_SetColorFormat);
747
748 //Mapi_HDMITx_Set_VS_InfoFrame()
749 UADP_SPT_NAME0NXT(HDMITX_SETVSINFOFRAME, stHDMITx_Set_VS_InfoFrame);
750
751 //Mapi_HDMITx_SetVideoOutputTiming()
752 UADP_SPT_NAME0NXT(HDMITX_SETVIDOUTPUTTIMING, stHDMITx_SetVideoOutputTiming);
753
754 //Mapi_HDMITx_SetVideoOutputTimingByCustomer()
755 UADP_SPT_NAME0NXT(HDMITX_SETVIDEOUTPUTTIMINGBYCUSTOMER, stHDMITx_SetVideoOutputTimingByCustomer);
756
757 //Mapi_HDMITx_SetVideoOutputAsepctRatio()
758 UADP_SPT_NAME0NXT(HDMITX_SETVIDOUTPUTASPECTRATIO, stHDMITx_SetVideoOutputAsepctRatio);
759
760 //Mapi_HDMITx_SetVideoOutputOverscan_AFD()
761 UADP_SPT_NAME0NXT(HDMITX_SETVIDOUTPUTOVERSCANAFD, stHDMITx_SetVideoOutputOverscan_AFD);
762
763 //Mapi_HDMITx_SetAudioOnOff()
764 UADP_SPT_NAME0NXT(HDMITX_SETAUDONOFF, stHDMITx_SetAudioOnOff);
765
766 //Mapi_HDMITx_SetAudioFrequency()
767 UADP_SPT_NAME0NXT(HDMITX_SETAUDFREQ, stHDMITx_SetAudioFrequency);
768
769 //Mapi_HDMITx_SetVideoOutputOverscan_AFD_II()
770 UADP_SPT_NAME0NXT(HDMITX_SETVIDOUTPUTOVERSCANAFD_II, stHDMITx_SetVideoOutputOverscan_AFD_II);
771
772 //Mapi_HDMITx_SetAudioConfiguration()
773 UADP_SPT_NAME0NXT(HDMITX_SETAUDCONFIG, stHDMITx_SetAudioConfiguration);
774
775 //Mapi_HDMITx_SetAudioSourceFormat()
776 UADP_SPT_NAME0NXT(HDMITX_SETAUDSRCFMT, stHDMITx_SetAudioSourceFormat);
777
778 //Mapi_HDMITx_SetAudioSourceFormat()
779 UADP_SPT_NAME0NXT(HDMITX_SETAVIINFOEXTCOLORIMETRY, stHDMITx_SetAVIInfoExtColorimetry);
780
781 //Mapi_HDMITx_GetAudioCTS()
782 UADP_SPT_NAME0NXT(HDMITX_GETAUDCTS, stHDMITx_GetAudioCTS);
783
784 //Mapi_HDMITx_MuteAudioFIFO()
785 UADP_SPT_NAME0NXT(HDMITX_MUTEAUDFIFO, stHDMITx_MuteAudioFIFO);
786
787 //Mapi_HDMITx_GetHdcpKey()
788 #if 0
789 #define DEF_HDCP14_KEY_SIZE 304U
790 u32DataSize = sizeof(MS_U8) * DEF_HDCP14_KEY_SIZE;
791 UADP_SPT_BGN(&spt_Hdcp14KeyData[0], u32DataSize);
792 UADP_SPT_FIN(&spt_Hdcp14KeyData[1]);
793 UADP_SPT_NAME1NXT(HDMITX_GETHDCPKEY, stHDMITx_GetHdcpKey, data, Hdcp14KeyData);
794 #undef DEF_HDCP14_KEY_SIZE
795 #endif
796
797 #if 0
798 #define DEF_HDCP14_KSV_SIZE 5U
799 //Mapi_HDMITx_GetBksv()
800 u32DataSize = sizeof(MS_U8) * DEF_HDCP14_KSV_SIZE;
801 UADP_SPT_BGN(&spt_Hdcp14BKSVData[0], u32DataSize);
802 UADP_SPT_FIN(&spt_Hdcp14BKSVData[1]);
803 UADP_SPT_NAME1NXT(HDMITX_GETBKSV, stHDMITx_GetBksv, pdata, Hdcp14BKSVData);
804
805 //Mapi_HDMITx_GetAksv()
806 UADP_SPT_BGN(&spt_Hdcp14AKSVData[0], u32DataSize);
807 UADP_SPT_FIN(&spt_Hdcp14AKSVData[1]);
808 UADP_SPT_NAME1NXT(HDMITX_GETAKSV, stHDMITx_GetAksv, pdata, Hdcp14AKSVData);
809 #undef DEF_HDCP14_KSV_SIZE
810 #endif
811
812 //Mapi_HDMITx_SetHDCPOnOff()
813 UADP_SPT_NAME0NXT(HDMITX_SETHDCPONOFF, stHDMITx_SetHDCPOnOff);
814
815 //Mapi_HDMITx_SetAVMUTE()
816 UADP_SPT_NAME0NXT(HDMITX_SETAVMUTE, stHDMITx_SetAVMUTE);
817
818 //Mapi_HDMITx_GetAVMUTEStatus()
819 UADP_SPT_NAME0NXT(HDMITX_GETAVMUTESTATUS, stHDMITx_GetAVMUTEStatus);
820
821 //Mapi_HDMITx_HDCP_RevocationKey_List()
822 #if 0
823 #define DEF_HDCP14_REVOKKEY_SIZE 5*127U
824 u32DataSize = sizeof(MS_U8) * DEF_HDCP14_REVOKKEY_SIZE;
825 UADP_SPT_BGN(&spt_Hdcp14RevokeList[0], u32DataSize);
826 UADP_SPT_FIN(&spt_Hdcp14RevokeList[1]);
827 UADP_SPT_NAME1NXT(HDMITX_HDCPREVOKEKEYLIST, stHDMITx_HDCP_RevocationKey_List, data, Hdcp14RevokeList);
828 #undef DEF_HDCP14_REVOKKEY_SIZE
829 #endif
830
831 //Mapi_HDMITx_HDCP_RevocationKey_Check()
832 UADP_SPT_NAME0NXT(HDMITX_HDCP14REVOKEKEYCHK, stHDMITx_HDCP_RevocationKey_Check);
833
834 //Mapi_HDMITx_HDCP_IsSRMSignatureValid()
835 #if 0
836 #define DEF_HDCP14_SRMSIGN_SIZE 1U //fake function, always return true
837 u32DataSize = sizeof(MS_U8) * DEF_HDCP14_SRMSIGN_SIZE;
838 UADP_SPT_BGN(&spt_Hdcp14SRMSignData[0], u32DataSize);
839 UADP_SPT_FIN(&spt_Hdcp14SRMSignData[1]);
840 UADP_SPT_NAME1NXT(HDMITX_HDCP14ISSRMSIGNVALID, stHDMITx_HDCP_IsSRMSignatureValid, data, Hdcp14SRMSignData);
841 #undef DEF_HDCP14_SRMSIGN_SIZE
842 #endif
843
844 //Mapi_HDMITx_GetHDCPStatus()
845 UADP_SPT_NAME0NXT(HDMITX_GETHDCPSTATUS, stHDMITx_GetHDCPStatus);
846
847 //Mapi_HDMITx_HDCP_StartAuth()
848 UADP_SPT_NAME0NXT(HDMITX_HDCP14STARTAUTH, stHDMITx_HDCP_StartAuth);
849
850 //Mapi_HDMITx_GetINTHDCPStatus()
851 UADP_SPT_NAME0NXT(HDMITX_GETINTHDCPSTATUS, stHDMITx_GetINTHDCPStatus);
852
853 //Mapi_HDMITx_GetHDCP_PreStatus()
854 UADP_SPT_NAME0NXT(HDMITX_GETHDCP14PRESTATUS, stHDMITx_GetHDCP_PreStatus);
855
856 //Mapi_UnHDCPRxControl()
857 UADP_SPT_NAME0NXT(HDMITX_UNHDCPRXCTRL, stHDMITx_UnHDCPRxControl);
858
859 //Mapi_HDMITx_HDCPRxFailControl()
860 UADP_SPT_NAME0NXT(HDMITX_HDCPRXFAILCTRL, stHDMITx_HDCPRxFailControl);
861
862 //undercheck!!!!
863 #if 0 //no use
864 //Mapi_HDMITx_GetLibVer()
865 UADP_SPT_NAME1NXT(HDMITX_GETLIBVER, stHDMITx_GetLibVer, ppVersion, LibVerPt);
866 #endif
867
868 /*
869 typedef struct _stHDMITx_GetLibVer
870 {
871 const MSIF_Version **ppVersion;
872 MS_BOOL bReturn;
873 } stHDMITx_GetLibVer,*pstHDMITx_GetLibVer;
874 */
875 //Mapi_HDMITx_GetInfo()
876 UADP_SPT_NAME0NXT(HdmiTxInfoPt, HDMI_TX_INFO);
877 UADP_SDT_NAME1(HDMITX_GETINFO, stHDMITx_GetInfo, UADP_SDT_P2N, pInfo, HdmiTxInfoPt);
878
879 //Mapi_HDMITx_GetStatus()
880 UADP_SPT_NAME0NXT(HdmiTxStatusPt, HDMI_TX_Status);
881 UADP_SDT_NAME1(HDMITX_GETSTATUS, stHDMITx_GetStatus, UADP_SDT_P2N, pStatus, HdmiTxStatusPt);
882
883 //Mapi_HDMITx_SetDbgLevels()
884 UADP_SPT_NAME0NXT(HDMITX_SETDBGLEVEL, stHDMITx_SetDbgLevels);
885
886 //Mapi_HDMITx_SetHPDGpioPin()
887 UADP_SPT_NAME0NXT(HDMITX_SETHPDGPIOPIN, stHDMITx_SetHPDGpioPin);
888
889 //Mapi_HDMITx_AnalogTuning()
890 UADP_SDT_NAME0(AnalogTuningPt, HDMITX_ANALOG_TUNING);
891 UADP_SDT_NAME1(HDMITX_ANALOGTUNING, stHDMITx_AnalogTuning, UADP_SDT_P2N, pInfo, AnalogTuningPt);
892
893 //Mapi_HDMITx_ForceHDMIOutputMode()
894 UADP_SPT_NAME0NXT(HDMITX_FORCEHDMIOUTPUTMODE, stHDMITx_ForceHDMIOutputMode);
895
896 //Mapi_HDMITx_ForceHDMIOutputColorFormat()
897 UADP_SPT_NAME0NXT(HDMITX_FORCEHDMIOUTPUTCOLORFMT, stHDMITx_ForceHDMIOutputColorFormat);
898
899 //Mapi_HDMITx_DisableRegWrite()
900 UADP_SPT_NAME0NXT(HDMITX_DISABLEREGWRITE, stHDMITx_DisableRegWrite);
901
902 //Mapi_HDMITx_GetEDIDPhyAdr()
903 #if 0
904 #define DEF_EDID_PHYADDR_SIZE 2U
905 u32DataSize = sizeof(MS_U8) * DEF_EDID_PHYADDR_SIZE;
906 UADP_SPT_BGN(&spt_EdidPhyAddrData[0], u32DataSize);
907 UADP_SPT_FIN(&spt_EdidPhyAddrData[1]);
908 UADP_SPT_NAME1NXT(HDMITX_GETEDIDPHYADR, stHDMITx_GetEDIDPhyAdr, pdata, EdidPhyAddrData);
909 #undef DEF_EDID_PHYADDR_SIZE
910 #endif
911
912 //Mapi_HDMITx_SetCECOnOff()
913 UADP_SPT_NAME0NXT(HDMITX_SETCECONOFF, stHDMITx_SetCECOnOff);
914
915 //Mapi_HDMITx_GetCECStatus()
916 UADP_SPT_NAME0NXT(HDMITX_GETCECSTATUS, stHDMITx_GetCECStatus);
917
918 //Mapi_HDMITx_EdidChecking()
919 UADP_SPT_NAME0NXT(HDMITX_EDIDCHECKING, stHDMITx_EdidChecking);
920
921 //Mapi_HDMITx_RxBypass_Mode()
922 UADP_SPT_NAME0NXT(HDMITX_RXBYPASSMODE, stHDMITx_RxBypass_Mode);
923
924 //Mapi_HDMITx_Disable_RxBypass()
925 UADP_SPT_NAME0NXT(HDMITX_DISABLERXBYPASS, stHDMITx_Disable_RxBypass);
926
927 //Mapi_HDMITx_SetAksv2R0Interval()
928 UADP_SPT_NAME0NXT(HDMITX_SETAKSV2R0INTERVAL, stHDMITx_SetAksv2R0Interval);
929
930 //Mapi_HDMITx_IsHDCPRxValid()
931 UADP_SPT_NAME0NXT(HDMITX_ISHDCPRXVALID, stHDMITx_IsHDCPRxValid);
932
933 //Mapi_HDMITx_GetChipCaps()
934 #if 0
935 #define DEF_HDMITX_CHIPCAP_SIZE 1U
936 u32DataSize = sizeof(MS_U32) * DEF_HDMITX_CHIPCAP_SIZE;
937 UADP_SPT_BGN(&spt_HdmiChipCapInfo[0], u32DataSize);
938 UADP_SPT_FIN(&spt_HdmiChipCapInfo[1]);
939 UADP_SPT_NAME1NXT(HDMITX_GETCHIPCAPS, stHDMITx_GetChipCaps, pRet, HdmiChipCapInfo);
940 #undef DEF_HDMITX_CHIPCAP_SIZE
941 #endif
942
943 //Mapi_HDMITx_SetPowerState()
944 UADP_SPT_NAME0NXT(HDMITX_SETPWRSTATE, stHDMITx_SetPowerState);
945
946 //Mapi_HDMITx_GetEdidDataBlocks()
947 #if 0
948 #define DEF_EDID_BATABLK_SIZE 128U
949 u32DataSize = sizeof(MS_U8) * DEF_EDID_BATABLK_SIZE;
950 UADP_SPT_BGN(&spt_SinkEDIDDataBlk[0], u32DataSize);
951 UADP_SPT_FIN(&spt_SinkEDIDDataBlk[1]);
952 UADP_SPT_NAME2NXT(HDMITX_GETEDIDDATABLKS, stHDMITx_GetEdidDataBlocks, pu8Data, SinkEDIDDataBlk, pu32RealLen, DataBlkRetLenPt);
953 #undef DEF_EDID_BATABLK_SIZE
954 #endif
955
956 //Mapi_HDMITx_GetKSVList()
957 #if 0
958 #define DEF_KSVLIST_SIZE 5*127U
959 #define DEF_HDCP14_BSTATUS_SIZE 2U
960 u32DataSize = sizeof(MS_U8) * DEF_HDCP14_BSTATUS_SIZE;
961 UADP_SPT_BGN(&spt_SinkBstatusData[0], u32DataSize);
962 UADP_SPT_FIN(&spt_SinkBstatusData[1]);
963
964 u32DataSize = sizeof(MS_U8) * DEF_KSVLIST_SIZE;
965 UADP_SPT_BGN(&spt_SinkKSVList[0], u32DataSize);
966 UADP_SPT_FIN(&spt_SinkKSVList[1]);
967
968 UADP_SPT_NAME3NXT(HDMITX_GETKSVLIST, stHDMITx_GetKSVList, pu8Bstatus, SinkBstatusData, pu8KSVList, SinkKSVList, pu16KSVLength, KSVListLenPt);
969 #undef DEF_HDCP14_BSTATUS_SIZE
970 #undef DEF_KSVLIST_SIZE
971 #endif
972
973 //Mapi_HDMITx_HDCP2AccessX74()
974 #if 0
975 #define DEF_HDCP22_RDBUFF_SIZE 534U //AKE_Send_Cert
976 #define DEF_HDCP22_WRBUFF_SIZE 129U //AKE_No_StoredKm
977 u32DataSize = sizeof(MS_U8) * DEF_HDCP22_RDBUFF_SIZE;
978 UADP_SPT_BGN(&spt_Hdcp22x74RdData[0], u32DataSize);
979 UADP_SPT_FIN(&spt_Hdcp22x74RdData[1]);
980
981 u32DataSize = sizeof(MS_U8) * DEF_HDCP22_WRBUFF_SIZE;
982 UADP_SPT_BGN(&spt_Hdcp22x74WrData[0], u32DataSize);
983 UADP_SPT_FIN(&spt_Hdcp22x74RdData[1]);
984
985 UADP_SPT_NAME2NXT(HDMITX_HDCP2ACCESSX74, stHDMITx_HDCP2AccessX74, pu8RdBuf, Hdcp22x74RdData, pu8WRBuff, Hdcp22x74WrData);
986 #undef DEF_HDCP22_RDBUFF_SIZE
987 #undef DEF_HDCP22_WRBUFF_SIZE
988 #endif
989
990 //Mapi_HDMITx_HDCP2TxInit()
991 UADP_SPT_NAME0NXT(HDMITX_HDCP2TXINIT, stHDMITx_HDCP2TxInit);
992
993 //Mapi_HDMITx_HDCP2TxEnableEncrypt()
994 UADP_SPT_NAME0NXT(HDMITX_HDCP2TXENABLEENC, stHDMITx_HDCP2TxEnableEncrypt);
995
996 //Mapi_HDMITx_HDCP2TxFillCipherKey()
997 #if 0
998 #define DEF_HDCP22_RIV_SIZE 8U
999 #define DEF_HDCP22_KS_SIZE 16U
1000 u32DataSize = sizeof(MS_U8) * DEF_HDCP22_RIV_SIZE;
1001 UADP_SPT_BGN(&spt_Hdcp22RivData[0], u32DataSize);
1002 UADP_SPT_FIN(&spt_Hdcp22RivData[1]);
1003
1004 u32DataSize = sizeof(MS_U8) * DEF_HDCP22_KS_SIZE;
1005 UADP_SPT_BGN(&spt_Hdcp22KsData[0], u32DataSize);
1006 UADP_SPT_FIN(&spt_Hdcp22KsData[1]);
1007
1008 UADP_SPT_NAME2NXT(HDMITx_HDCP2TXFILLCIPHERKEY, stHDMITx_HDCP2TxFillCipherKey, pu8Riv, Hdcp22RivData, pu8KsXORLC128, Hdcp22KsData);
1009 #undef DEF_HDCP22_KS_SIZE
1010 #undef DEF_HDCP22_RIV_SIZE
1011 #endif
1012
1013 //MApi_HDMITx_ColorandRange_Transform
1014 UADP_SPT_NAME0NXT(HDMITX_COLORRANGE_TRANSFORM, stHDMITX_COLOR_AND_RANGE_TRANSFORM_PARAMETERS);
1015
1016 //MApi_HDMITx_SSC_Enable
1017 UADP_SPT_NAME0NXT(HDMITX_SETSSCENABLE, stHDMITX_SSCENABLE);
1018
1019 //MApi_HDMITx_SetAVIInfoExtColorimetry
1020 UADP_SPT_NAME0NXT(HDMITX_SETCOLORIMETRY, stHDMITX_SET_COLORIMETRY);
1021
1022 //MApi_HDMITx_GetFullRxStatus
1023 UADP_SPT_NAME0NXT(HDMITX_GET_FULL_RX_STATUS, stHDMITX_GET_FULL_RX_STATUS);
1024
1025 //MApi_HDMITx_GetFullRxStatus
1026 UADP_SPT_NAME0NXT(HDMITX_CHECK_LEGAL_TIMING, stHDMITX_CHECK_LEGAL_TIMING);
1027
1028 *pIoctl= (FUtopiaIOctl)HDMITX_adp_Ioctl;
1029
1030 return 0;
1031
1032 }
1033 #define EN_HDMITX_ADP_LOG 0
HDMITX_adp_Ioctl(void * pInstanceTmp,MS_U32 u32Cmd,void * const pArgs)1034 MS_U32 HDMITX_adp_Ioctl(void *pInstanceTmp, MS_U32 u32Cmd, void* const pArgs)
1035 {
1036 MS_U32 ulReturnValue = UTOPIA_STATUS_SUCCESS;
1037 char usbuffer_arg[2];
1038 //MS_U32 u32DataSize = 0x00;
1039
1040 switch(u32Cmd)
1041 {
1042 case E_HDMITX_CMD_INIT:
1043 #if EN_HDMITX_ADP_LOG
1044 printk("E_HDMITX_CMD_INIT\r\n");
1045 #endif
1046 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_INIT, spt_HDMITX_INIT, usbuffer_arg, sizeof(usbuffer_arg));
1047 break;
1048
1049 case E_HDMITX_CMD_EXIT:
1050 #if EN_HDMITX_ADP_LOG
1051 printk("E_HDMITX_CMD_EXIT\r\n");
1052 #endif
1053 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_EXIT, spt_HDMITX_EXIT, usbuffer_arg, sizeof(usbuffer_arg));
1054 break;
1055
1056 case E_HDMITX_CMD_TURNONOFF:
1057 #if EN_HDMITX_ADP_LOG
1058 printk("E_HDMITX_CMD_TURNONOFF\r\n");
1059 #endif
1060 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_TURNONOFF, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1061 break;
1062
1063 case E_HDMITX_CMD_ENABLEPACKETGEN:
1064 #if EN_HDMITX_ADP_LOG
1065 printk("E_HDMITX_CMD_ENABLEPACKETGEN\r\n");
1066 #endif
1067 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_ENPKTGEN, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1068 break;
1069
1070 case E_HDMITX_CMD_SETHDMITXMODE:
1071 #if EN_HDMITX_ADP_LOG
1072 printk("E_HDMITX_CMD_SETHDMITXMODE\r\n");
1073 #endif
1074 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETHDMITXMODE, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1075 break;
1076
1077 case E_HDMITX_CMD_SETHDMITXMODE_CD:
1078 #if EN_HDMITX_ADP_LOG
1079 printk("E_HDMITX_CMD_SETHDMITXMODE_CD\r\n");
1080 #endif
1081 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETHDMITXMODECD, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1082 break;
1083
1084 case E_HDMITX_CMD_SETTMDSONOFF:
1085 #if EN_HDMITX_ADP_LOG
1086 printk("E_HDMITX_CMD_SETTMDSONOFF\r\n");
1087 #endif
1088 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETTMDSONOFF, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1089 break;
1090
1091 case E_HDMITX_CMD_DISABLETMDSCTRL:
1092 #if EN_HDMITX_ADP_LOG
1093 printk("E_HDMITX_CMD_DISABLETMDSCTRL\r\n");
1094 #endif
1095 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_DISABLETMDSCTRL, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1096 break;
1097
1098 case E_HDMITX_CMD_SETRBCHANNELSWAP:
1099 #if EN_HDMITX_ADP_LOG
1100 printk("E_HDMITX_CMD_SETRBCHANNELSWAP\r\n");
1101 #endif
1102 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETRBCHSWAP, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1103 break;
1104
1105 case E_HDMITX_CMD_EXHIBIT:
1106 #if EN_HDMITX_ADP_LOG
1107 printk("E_HDMITX_CMD_EXHIBIT\r\n");
1108 #endif
1109 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, pArgs);
1110 break;
1111
1112 case E_HDMITX_CMD_GETRXSTATUS:
1113 #if EN_HDMITX_ADP_LOG
1114 printk("E_HDMITX_CMD_GETRXSTATUS\r\n");
1115 #endif
1116 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_GETRXSTATUS, spt_HDMITX_GETRXSTATUS, usbuffer_arg, sizeof(usbuffer_arg));
1117 break;
1118
1119 case E_HDMITX_CMD_GETRXDCINFOFROMEDID:
1120 #if EN_HDMITX_ADP_LOG
1121 printk("E_HDMITX_CMD_GETRXDCINFOFROMEDID\r\n");
1122 #endif
1123 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_GETDCINFOFROMEDID, spt_HDMITX_GETDCINFOFROMEDID, usbuffer_arg, sizeof(usbuffer_arg));
1124 break;
1125
1126 case E_HDMITX_CMD_GETRXVIDEODORMATFROMEDID:
1127 {
1128 #if EN_HDMITX_ADP_LOG
1129 printk("E_HDMITX_CMD_GETRXVIDEODORMATFROMEDID\r\n");
1130 #endif
1131 stHDMITx_GetRxVideoFormatFromEDID stHDMITxArgs = {0};
1132
1133 if(IS_CMP_TASK())
1134 {
1135 stHDMITx_GetRxVideoFormatFromEDID_Compat stCompatHDMITxArgs = {0};
1136
1137 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_GetRxVideoFormatFromEDID_Compat));
1138
1139 //copy Arguments
1140 stHDMITxArgs.pu8Buffer = malloc(sizeof(MS_U8)*stCompatHDMITxArgs.u8BufSize);
1141 CMP_CPY_FROM_USER(stHDMITxArgs.pu8Buffer, stCompatHDMITxArgs.pu8Buffer, sizeof(MS_U8)*stHDMITxArgs.u8BufSize);
1142 stHDMITxArgs.u8BufSize = stCompatHDMITxArgs.u8BufSize;
1143 stHDMITxArgs.bReturn = stCompatHDMITxArgs.bReturn;
1144
1145 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1146 stCompatHDMITxArgs.bReturn = stHDMITxArgs.bReturn;
1147
1148 CMP_CPY_TO_USER(stCompatHDMITxArgs.pu8Buffer, stHDMITxArgs.pu8Buffer, sizeof(MS_U8)*stCompatHDMITxArgs.u8BufSize);
1149 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_GetRxVideoFormatFromEDID_Compat));
1150
1151 free(stHDMITxArgs.pu8Buffer);
1152 }
1153 else
1154 {
1155 void *pData = NULL;
1156
1157 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_GetRxVideoFormatFromEDID));
1158
1159 pData = stHDMITxArgs.pu8Buffer;
1160 stHDMITxArgs.pu8Buffer = malloc(sizeof(MS_U8) *stHDMITxArgs.u8BufSize);
1161 CPY_FROM_USER(stHDMITxArgs.pu8Buffer, pData, sizeof(MS_U8) *stHDMITxArgs.u8BufSize);
1162
1163 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1164
1165 CPY_TO_USER(pData, stHDMITxArgs.pu8Buffer, sizeof(MS_U8) *stHDMITxArgs.u8BufSize);
1166 free(stHDMITxArgs.pu8Buffer);
1167 stHDMITxArgs.pu8Buffer = pData;
1168 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_GetRxVideoFormatFromEDID));
1169 }
1170 }
1171 break;
1172
1173 case E_HDMITX_CMD_GETVICLISTFROMEDID:
1174 {
1175 #if EN_HDMITX_ADP_LOG
1176 printk("E_HDMITX_CMD_GETVICLISTFROMEDID\r\n");
1177 #endif
1178 stHDMITx_GetVICListFromEDID stHDMITxArgs = {0};
1179
1180 if(IS_CMP_TASK())
1181 {
1182 stHDMITx_GetVICListFromEDID_Compat stCompatHDMITxArgs = {0};
1183
1184 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_GetVICListFromEDID_Compat));
1185
1186 //copy arguments
1187 stHDMITxArgs.pu8Buffer = malloc(sizeof(MS_U8) *stCompatHDMITxArgs.u8BufSize);
1188 CMP_CPY_FROM_USER(stHDMITxArgs.pu8Buffer, stCompatHDMITxArgs.pu8Buffer, sizeof(MS_U8) *stCompatHDMITxArgs.u8BufSize);
1189 stHDMITxArgs.u8BufSize = stCompatHDMITxArgs.u8BufSize;
1190 stHDMITxArgs.bReturn = stCompatHDMITxArgs.bReturn;
1191
1192 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1193 stCompatHDMITxArgs.bReturn = stHDMITxArgs.bReturn;
1194
1195 CMP_CPY_TO_USER(stCompatHDMITxArgs.pu8Buffer, stCompatHDMITxArgs.pu8Buffer, sizeof(MS_U8) *stCompatHDMITxArgs.u8BufSize);
1196 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_GetVICListFromEDID_Compat));
1197
1198 free(stHDMITxArgs.pu8Buffer);
1199 }
1200 else
1201 {
1202 void *pData = NULL;
1203
1204 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_GetVICListFromEDID));
1205
1206 pData = stHDMITxArgs.pu8Buffer;
1207 stHDMITxArgs.pu8Buffer = malloc(sizeof(MS_U8) *stHDMITxArgs.u8BufSize);
1208 CPY_FROM_USER(stHDMITxArgs.pu8Buffer, pData, sizeof(MS_U8) *stHDMITxArgs.u8BufSize);
1209
1210 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1211
1212 CPY_TO_USER(pData, stHDMITxArgs.pu8Buffer, sizeof(MS_U8) *stHDMITxArgs.u8BufSize);
1213 free(stHDMITxArgs.pu8Buffer);
1214 stHDMITxArgs.pu8Buffer = pData;
1215 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_GetVICListFromEDID));
1216
1217 }
1218 }
1219 break;
1220
1221 case E_HDMITX_CMD_GETDATABLOCKLENGTHFROMEDID:
1222 #if EN_HDMITX_ADP_LOG
1223 printk("E_HDMITX_CMD_GETDATABLOCKLENGTHFROMEDID\r\n");
1224 #endif
1225 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_GETDATABLKLENFROMEDID, spt_HDMITX_GETDATABLKLENFROMEDID, usbuffer_arg, sizeof(usbuffer_arg));
1226 break;
1227
1228 case E_HDMITX_CMD_GETCOLORFORMATFROMEDID:
1229 {
1230 #if EN_HDMITX_ADP_LOG
1231 printk("E_HDMITX_CMD_GETCOLORFORMATFROMEDID\r\n");
1232 #endif
1233 stHDMITx_GetColorFormatFromEDID stHDMITxArgs = {0};
1234
1235 if(IS_CMP_TASK())
1236 {
1237 stHDMITx_GetColorFormatFromEDID_Compat stCompatHDMITxArgs = {0};
1238
1239 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_GetColorFormatFromEDID_Compat));
1240
1241 stHDMITxArgs.pColorFmt = malloc(sizeof(HDMITX_EDID_COLOR_FORMAT));
1242 CMP_CPY_FROM_USER(stHDMITxArgs.pColorFmt, stCompatHDMITxArgs.pColorFmt, sizeof(HDMITX_EDID_COLOR_FORMAT));
1243 stHDMITxArgs.timing = stCompatHDMITxArgs.timing;
1244 stHDMITxArgs.bReturn = stCompatHDMITxArgs.bReturn;
1245
1246 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1247 stCompatHDMITxArgs.bReturn = stHDMITxArgs.bReturn;
1248
1249 CMP_CPY_TO_USER(stCompatHDMITxArgs.pColorFmt, stHDMITxArgs.pColorFmt, sizeof(HDMITX_EDID_COLOR_FORMAT));
1250 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_GetColorFormatFromEDID_Compat));
1251
1252 free(stHDMITxArgs.pColorFmt);
1253 }
1254 else
1255 {
1256 void *pData = NULL;
1257
1258 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_GetColorFormatFromEDID));
1259
1260 pData = stHDMITxArgs.pColorFmt;
1261 stHDMITxArgs.pColorFmt = malloc(sizeof(HDMITX_EDID_COLOR_FORMAT));
1262 CPY_FROM_USER(stHDMITxArgs.pColorFmt, pData, sizeof(HDMITX_EDID_COLOR_FORMAT));
1263
1264 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1265
1266 CPY_TO_USER(pData, stHDMITxArgs.pColorFmt, sizeof(HDMITX_EDID_COLOR_FORMAT));
1267 free(stHDMITxArgs.pColorFmt);
1268 stHDMITxArgs.pColorFmt = pData;
1269 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_GetColorFormatFromEDID));
1270 }
1271 //ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_GETCOLORFMTFROMEDID, spt_HDMITX_GETCOLORFMTFROMEDID, usbuffer_arg, sizeof(usbuffer_arg));
1272 }
1273 break;
1274
1275 case E_HDMITX_CMD_GETRXAUDIOFORMATFROMEDID:
1276 {
1277 #if EN_HDMITX_ADP_LOG
1278 printk("E_HDMITX_CMD_GETRXAUDIOFORMATFROMEDID\r\n");
1279 #endif
1280 stHDMITx_GetRxAudioFormatFromEDID stHDMITxArgs = {0};
1281
1282 if(IS_CMP_TASK())
1283 {
1284 stHDMITx_GetRxAudioFormatFromEDID_Compat stCompatHDMITxArgs = {0};
1285
1286 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_GetRxAudioFormatFromEDID_Compat));
1287
1288 stHDMITxArgs.pu8Buffer = malloc(sizeof(MS_U8)*stCompatHDMITxArgs.u8BufSize);
1289 CMP_CPY_FROM_USER(stHDMITxArgs.pu8Buffer, stCompatHDMITxArgs.pu8Buffer, sizeof(MS_U8)*stCompatHDMITxArgs.u8BufSize);
1290 stHDMITxArgs.u8BufSize = stCompatHDMITxArgs.u8BufSize;
1291 stHDMITxArgs.bReturn = stCompatHDMITxArgs.bReturn;
1292
1293 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1294 stCompatHDMITxArgs.bReturn = stHDMITxArgs.bReturn;
1295
1296 CMP_CPY_TO_USER(stCompatHDMITxArgs.pu8Buffer, stHDMITxArgs.pu8Buffer, sizeof(MS_U8)*stCompatHDMITxArgs.u8BufSize);
1297 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_GetRxAudioFormatFromEDID_Compat));
1298
1299 free(stHDMITxArgs.pu8Buffer);
1300 }
1301 else
1302 {
1303 void *pData = NULL;
1304
1305 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_GetRxAudioFormatFromEDID));
1306
1307 pData = stHDMITxArgs.pu8Buffer;
1308 stHDMITxArgs.pu8Buffer = malloc(sizeof(MS_U8) *stHDMITxArgs.u8BufSize);
1309 CPY_FROM_USER(stHDMITxArgs.pu8Buffer, pData, sizeof(MS_U8) *stHDMITxArgs.u8BufSize);
1310
1311 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1312
1313 CPY_TO_USER(pData, stHDMITxArgs.pu8Buffer, sizeof(MS_U8) *stHDMITxArgs.u8BufSize);
1314 free(stHDMITxArgs.pu8Buffer);
1315 stHDMITxArgs.pu8Buffer = pData;
1316 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_GetRxAudioFormatFromEDID));
1317
1318 }
1319 }
1320 break;
1321
1322 case E_HDMITX_CMD_EDID_HDMISUPPORT:
1323 #if EN_HDMITX_ADP_LOG
1324 printk("E_HDMITX_CMD_EDID_HDMISUPPORT\r\n");
1325 #endif
1326 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_EDIDHDMISUPPORT, spt_HDMITX_EDIDHDMISUPPORT, usbuffer_arg, sizeof(usbuffer_arg));
1327 break;
1328
1329 case E_HDMITX_CMD_GETRXIDMANUFACTURERNAME:
1330 {
1331 #if EN_HDMITX_ADP_LOG
1332 printk("E_HDMITX_CMD_GETRXIDMANUFACTURERNAME\r\n");
1333 #endif
1334 stHDMITx_GetRxIDManufacturerName stHDMITxArgs = {0};
1335 #define DEF_EDID_MANUFACTORID_SIZE 3U
1336 if(IS_CMP_TASK())
1337 {
1338 stHDMITx_GetRxIDManufacturerName_Compat stCompatHDMITxArgs = {0};
1339
1340 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_GetRxIDManufacturerName_Compat));
1341
1342 stHDMITxArgs.pu8Buffer = malloc(sizeof(MS_U8) * DEF_EDID_MANUFACTORID_SIZE);
1343 CMP_CPY_FROM_USER(stHDMITxArgs.pu8Buffer, stCompatHDMITxArgs.pu8Buffer, sizeof(MS_U8) * DEF_EDID_MANUFACTORID_SIZE);
1344 stHDMITxArgs.bReturn = stCompatHDMITxArgs.bReturn;
1345
1346 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1347 stCompatHDMITxArgs.bReturn = stHDMITxArgs.bReturn;
1348
1349 CMP_CPY_TO_USER(stCompatHDMITxArgs.pu8Buffer, stHDMITxArgs.pu8Buffer, sizeof(MS_U8) * DEF_EDID_MANUFACTORID_SIZE);
1350 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_GetRxIDManufacturerName_Compat));
1351
1352 free(stHDMITxArgs.pu8Buffer);
1353 }
1354 else
1355 {
1356 void *pData = NULL;
1357
1358 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_GetRxIDManufacturerName));
1359
1360 pData = stHDMITxArgs.pu8Buffer;
1361 stHDMITxArgs.pu8Buffer = malloc(sizeof(MS_U8) * DEF_EDID_MANUFACTORID_SIZE);
1362 CPY_FROM_USER(stHDMITxArgs.pu8Buffer, pData, sizeof(MS_U8) * DEF_EDID_MANUFACTORID_SIZE);
1363
1364 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1365
1366 CPY_TO_USER(pData, stHDMITxArgs.pu8Buffer, sizeof(MS_U8) * DEF_EDID_MANUFACTORID_SIZE);
1367 free(stHDMITxArgs.pu8Buffer);
1368 stHDMITxArgs.pu8Buffer = pData;
1369 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_GetRxIDManufacturerName));
1370
1371 }
1372 #undef DEF_EDID_MANUFACTORID_SIZE
1373 }
1374 break;
1375
1376 case E_HDMITX_CMD_GETEDIDDATA:
1377 {
1378 #if EN_HDMITX_ADP_LOG
1379 printk("E_HDMITX_CMD_GETEDIDDATA\r\n");
1380 #endif
1381 stHDMITx_GetEDIDData stHDMITxArgs = {0};
1382 #define DEF_EDID_BLOCK_SIZE 128U
1383 if(IS_CMP_TASK())
1384 {
1385 stHDMITx_GetEDIDData_Compat stCompatHDMITxArgs = {0};
1386
1387 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_GetEDIDData_Compat));
1388
1389 stHDMITxArgs.pu8Buffer = malloc(sizeof(MS_U8) * DEF_EDID_BLOCK_SIZE);
1390 CMP_CPY_FROM_USER(stHDMITxArgs.pu8Buffer, stCompatHDMITxArgs.pu8Buffer, sizeof(MS_U8) * DEF_EDID_BLOCK_SIZE);
1391 stHDMITxArgs.BlockIdx = stCompatHDMITxArgs.BlockIdx;
1392 stHDMITxArgs.bReturn = stCompatHDMITxArgs.bReturn;
1393
1394 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1395 stCompatHDMITxArgs.bReturn = stHDMITxArgs.bReturn;
1396
1397 CMP_CPY_TO_USER(stCompatHDMITxArgs.pu8Buffer, stHDMITxArgs.pu8Buffer, sizeof(MS_U8) * DEF_EDID_BLOCK_SIZE);
1398 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_GetEDIDData_Compat));
1399
1400 free(stHDMITxArgs.pu8Buffer);
1401 }
1402 else
1403 {
1404 void *pData = NULL;
1405
1406 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_GetEDIDData));
1407
1408 pData = stHDMITxArgs.pu8Buffer;
1409 stHDMITxArgs.pu8Buffer = malloc(sizeof(MS_U8) * DEF_EDID_BLOCK_SIZE);
1410 CPY_FROM_USER(stHDMITxArgs.pu8Buffer, pData, sizeof(MS_U8) * DEF_EDID_BLOCK_SIZE);
1411
1412 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1413
1414 CPY_TO_USER(pData, stHDMITxArgs.pu8Buffer, sizeof(MS_U8) * DEF_EDID_BLOCK_SIZE);
1415 free(stHDMITxArgs.pu8Buffer);
1416 stHDMITxArgs.pu8Buffer = pData;
1417 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_GetEDIDData));
1418
1419
1420 }
1421 #undef DEF_EDID_BLOCK_SIZE
1422 }
1423 break;
1424
1425 case E_HDMITX_CMD_GETRX3DSTRUCTUREFROMEDID:
1426 {
1427 #if EN_HDMITX_ADP_LOG
1428 printk("E_HDMITX_CMD_GETRX3DSTRUCTUREFROMEDID\r\n");
1429 #endif
1430 stHDMITx_GetRx3DStructureFromEDID stHDMITxArgs = {0};
1431
1432 if(IS_CMP_TASK())
1433 {
1434 stHDMITx_GetRx3DStructureFromEDID_Compat stCompatHDMITxArgs = {0};
1435
1436 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_GetRx3DStructureFromEDID_Compat));
1437
1438 stHDMITxArgs.p3DStructure = malloc(sizeof(HDMITX_EDID_3D_STRUCTURE_ALL));
1439
1440 CMP_CPY_FROM_USER(stHDMITxArgs.p3DStructure, stCompatHDMITxArgs.p3DStructure, sizeof(HDMITX_EDID_3D_STRUCTURE_ALL));
1441 stHDMITxArgs.timing = stCompatHDMITxArgs.timing;
1442 stHDMITxArgs.bReturn = stCompatHDMITxArgs.bReturn;
1443
1444 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1445 stCompatHDMITxArgs.bReturn = stHDMITxArgs.bReturn;
1446
1447 CMP_CPY_TO_USER(stCompatHDMITxArgs.p3DStructure, stHDMITxArgs.p3DStructure, sizeof(HDMITX_EDID_3D_STRUCTURE_ALL));
1448 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_GetRx3DStructureFromEDID_Compat));
1449
1450 free(stHDMITxArgs.p3DStructure);
1451 }
1452 else
1453 {
1454 void *pData = NULL;
1455
1456 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_GetRx3DStructureFromEDID));
1457
1458 pData = stHDMITxArgs.p3DStructure;
1459 stHDMITxArgs.p3DStructure = malloc(sizeof(HDMITX_EDID_3D_STRUCTURE_ALL));
1460
1461 CPY_FROM_USER(stHDMITxArgs.p3DStructure, pData, sizeof(HDMITX_EDID_3D_STRUCTURE_ALL));
1462
1463 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1464
1465 CPY_TO_USER(pData, stHDMITxArgs.p3DStructure, sizeof(HDMITX_EDID_3D_STRUCTURE_ALL));
1466 free(stHDMITxArgs.p3DStructure);
1467 stHDMITxArgs.p3DStructure = pData;
1468 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_GetRx3DStructureFromEDID));
1469
1470 }
1471 }
1472 break;
1473
1474 case E_HDMITX_CMD_PKT_USER_DEFINE_CLEAR:
1475 #if EN_HDMITX_ADP_LOG
1476 printk("E_HDMITX_CMD_PKT_USER_DEFINE_CLEAR\r\n");
1477 #endif
1478 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, pArgs);
1479 break;
1480
1481 case E_HDMITX_CMD_PKT_USER_DEFINE:
1482 #if EN_HDMITX_ADP_LOG
1483 printk("E_HDMITX_CMD_PKT_USER_DEFINE\r\n");
1484 #endif
1485 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_PKTUSERDEF, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1486 break;
1487
1488 case E_HDMITX_CMD_PKT_CONTENT_DEFINE:
1489 {
1490 #if EN_HDMITX_ADP_LOG
1491 printk("E_HDMITX_CMD_PKT_CONTENT_DEFINE\r\n");
1492 #endif
1493 stHDMITx_PKT_Content_Define stHDMITxArgs = {0};
1494
1495 if(IS_CMP_TASK())
1496 {
1497 stHDMITx_PKT_Content_Define_Compat stCompatHDMITxArgs = {0};
1498
1499 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_PKT_Content_Define_Compat));
1500
1501 stHDMITxArgs.data = malloc(sizeof(MS_U8) *stCompatHDMITxArgs.length);
1502
1503 CMP_CPY_FROM_USER(stHDMITxArgs.data, stCompatHDMITxArgs.data, sizeof(MS_U8) *stCompatHDMITxArgs.length);
1504 stHDMITxArgs.packet_type = stCompatHDMITxArgs.packet_type;
1505 stHDMITxArgs.length = stCompatHDMITxArgs.length;
1506 stHDMITxArgs.bReturn = stCompatHDMITxArgs.bReturn;
1507
1508 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1509 stCompatHDMITxArgs.bReturn = stHDMITxArgs.bReturn;
1510
1511 CMP_CPY_TO_USER(stCompatHDMITxArgs.data, stHDMITxArgs.data, sizeof(MS_U8) *stCompatHDMITxArgs.length);
1512 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_PKT_Content_Define_Compat));
1513
1514 free(stHDMITxArgs.data);
1515 }
1516 else
1517 {
1518 void *pData = NULL;
1519
1520 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_PKT_Content_Define));
1521
1522 pData = stHDMITxArgs.data;
1523 stHDMITxArgs.data = malloc(sizeof(MS_U8) *stHDMITxArgs.length);
1524
1525 CPY_FROM_USER(stHDMITxArgs.data, pData, sizeof(MS_U8) *stHDMITxArgs.length);
1526
1527 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1528
1529 CPY_TO_USER(pData, stHDMITxArgs.data, sizeof(MS_U8) * stHDMITxArgs.length);
1530 free(stHDMITxArgs.data);
1531 stHDMITxArgs.data = pData;
1532 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_PKT_Content_Define));
1533 }
1534 }
1535 break;
1536
1537 case E_HDMITX_CMD_SETVIDEOONOFF:
1538 #if EN_HDMITX_ADP_LOG
1539 printk("E_HDMITX_CMD_SETVIDEOONOFF\r\n");
1540 #endif
1541 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITx_SETVIDONOFF, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1542 break;
1543
1544 case E_HDMITX_CMD_SETCOLORFORMAT:
1545 #if EN_HDMITX_ADP_LOG
1546 printk("E_HDMITX_CMD_SETCOLORFORMAT\r\n");
1547 #endif
1548 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETCOLORFMT, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1549 break;
1550
1551 case E_HDMITX_CMD_SET_VS_INFOFRAME:
1552 #if EN_HDMITX_ADP_LOG
1553 printk("E_HDMITX_CMD_SET_VS_INFOFRAME\r\n");
1554 #endif
1555 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETVSINFOFRAME, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1556 break;
1557
1558 case E_HDMITX_CMD_SETVIDEOOUTPUTTIMING:
1559 #if EN_HDMITX_ADP_LOG
1560 printk("E_HDMITX_CMD_SETVIDEOOUTPUTTIMING\r\n");
1561 #endif
1562 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETVIDOUTPUTTIMING, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1563 break;
1564
1565 case E_HDMITX_CMD_SETVIDEOOUTPUTASEPCTRATIO:
1566 #if EN_HDMITX_ADP_LOG
1567 printk("E_HDMITX_CMD_SETVIDEOOUTPUTASEPCTRATIO\r\n");
1568 #endif
1569 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETVIDOUTPUTASPECTRATIO, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1570 break;
1571
1572 case E_HDMITX_CMD_SETVIDEOOUTPUTOVERSCAN_AFD:
1573 #if EN_HDMITX_ADP_LOG
1574 printk("E_HDMITX_CMD_SETVIDEOOUTPUTOVERSCAN_AFD\r\n");
1575 #endif
1576 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETVIDOUTPUTOVERSCANAFD, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1577 break;
1578
1579 case E_HDMITX_CMD_SETAUDIOONOFF:
1580 #if EN_HDMITX_ADP_LOG
1581 printk("E_HDMITX_CMD_SETAUDIOONOFF\r\n");
1582 #endif
1583 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETAUDONOFF, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1584 break;
1585
1586 case E_HDMITX_CMD_SETAUDIOFREQUENCY:
1587 #if EN_HDMITX_ADP_LOG
1588 printk("E_HDMITX_CMD_SETAUDIOFREQUENCY\r\n");
1589 #endif
1590 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETAUDFREQ, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1591 break;
1592
1593 case E_HDMITX_CMD_SETVIDEOOUTPUTOVERSCAN_AFD_II:
1594 #if EN_HDMITX_ADP_LOG
1595 printk("E_HDMITX_CMD_SETVIDEOOUTPUTOVERSCAN_AFD_II\r\n");
1596 #endif
1597 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETVIDOUTPUTOVERSCANAFD_II, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1598 break;
1599
1600 case E_HDMITX_CMD_SETAUDIOCONFIGURATION:
1601 #if EN_HDMITX_ADP_LOG
1602 printk("E_HDMITX_CMD_SETAUDIOCONFIGURATION\r\n");
1603 #endif
1604 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETAUDCONFIG, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1605 break;
1606
1607 case E_HDMITX_CMD_SETAUDIOSOURCEFORMAT:
1608 #if EN_HDMITX_ADP_LOG
1609 printk("E_HDMITX_CMD_SETAUDIOSOURCEFORMAT\r\n");
1610 #endif
1611 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETAUDSRCFMT, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1612 break;
1613
1614 case E_HDMITX_CMD_SETAVIINFOEXTCOLORIMETRY:
1615 #if EN_HDMITX_ADP_LOG
1616 printk("E_HDMITX_CMD_EXIT\r\n");
1617 #endif
1618 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETAVIINFOEXTCOLORIMETRY, spt_HDMITX_SETAVIINFOEXTCOLORIMETRY, usbuffer_arg, sizeof(usbuffer_arg));
1619 break;
1620
1621 case E_HDMITX_CMD_GETAUDIOCTS:
1622 #if EN_HDMITX_ADP_LOG
1623 printk("E_HDMITX_CMD_GETAUDIOCTS\r\n");
1624 #endif
1625 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_GETAUDCTS, spt_HDMITX_GETAUDCTS, usbuffer_arg, sizeof(usbuffer_arg));
1626 break;
1627
1628 case E_HDMITX_CMD_MUTEAUDIOFIFO:
1629 #if EN_HDMITX_ADP_LOG
1630 printk("E_HDMITX_CMD_MUTEAUDIOFIFO\r\n");
1631 #endif
1632 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_MUTEAUDFIFO, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1633 break;
1634
1635 case E_HDMITX_CMD_GETHDCPKEY:
1636 {
1637 #if EN_HDMITX_ADP_LOG
1638 printk("E_HDMITX_CMD_GETHDCPKEY\r\n");
1639 #endif
1640 stHDMITx_GetHdcpKey stHDMITxArgs = {0};
1641 #define DEF_HDCP14_KEY_SIZE 304U
1642
1643 if(IS_CMP_TASK())
1644 {
1645 stHDMITx_GetHdcpKey_Compat stCompatHDMITxArgs = {0};
1646
1647 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_GetHdcpKey_Compat));
1648
1649 stHDMITxArgs.data = malloc(sizeof(MS_U8) * DEF_HDCP14_KEY_SIZE);
1650 CMP_CPY_FROM_USER(stHDMITxArgs.data, stCompatHDMITxArgs.data, sizeof(MS_U8) * DEF_HDCP14_KEY_SIZE);
1651 stHDMITxArgs.useinternalkey = stCompatHDMITxArgs.useinternalkey;
1652
1653 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1654
1655 CMP_CPY_TO_USER(stCompatHDMITxArgs.data, stHDMITxArgs.data, sizeof(MS_U8) * DEF_HDCP14_KEY_SIZE);
1656 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_GetHdcpKey_Compat));
1657
1658 free(stHDMITxArgs.data);
1659 }
1660 else
1661 {
1662 void *pData = NULL;
1663
1664 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_GetHdcpKey));
1665
1666 pData = stHDMITxArgs.data;
1667 stHDMITxArgs.data = malloc(sizeof(MS_U8) * DEF_HDCP14_KEY_SIZE);
1668 CPY_FROM_USER(stHDMITxArgs.data, pData, sizeof(MS_U8) * DEF_HDCP14_KEY_SIZE);
1669
1670 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1671
1672 CPY_TO_USER(pData, stHDMITxArgs.data, sizeof(MS_U8) * DEF_HDCP14_KEY_SIZE);
1673 free(stHDMITxArgs.data);
1674 stHDMITxArgs.data = pData;
1675 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_GetHdcpKey));
1676 }
1677 #undef DEF_HDCP14_KEY_SIZE
1678 }
1679 break;
1680
1681 case E_HDMITX_CMD_GETBKSV:
1682 {
1683 #if EN_HDMITX_ADP_LOG
1684 printk("E_HDMITX_CMD_GETBKSV\r\n");
1685 #endif
1686 stHDMITx_GetBksv stHDMITxArgs = {0};
1687 #define DEF_HDCP14_KSV_SIZE 5U
1688
1689 if(IS_CMP_TASK())
1690 {
1691 stHDMITx_GetBksv_Compat stCompatHDMITxArgs = {0};
1692
1693 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_GetBksv_Compat));
1694
1695 stHDMITxArgs.pdata = malloc(sizeof(MS_U8) * DEF_HDCP14_KSV_SIZE);
1696 CMP_CPY_FROM_USER(stHDMITxArgs.pdata, stCompatHDMITxArgs.pdata, sizeof(MS_U8) * DEF_HDCP14_KSV_SIZE);
1697 stHDMITxArgs.bReturn = stCompatHDMITxArgs.bReturn;
1698
1699 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1700 stCompatHDMITxArgs.bReturn = stHDMITxArgs.bReturn;
1701
1702 CMP_CPY_TO_USER(stCompatHDMITxArgs.pdata, stHDMITxArgs.pdata, sizeof(MS_U8) * DEF_HDCP14_KSV_SIZE);
1703 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_GetBksv_Compat));
1704
1705 free(stHDMITxArgs.pdata);
1706 }
1707 else
1708 {
1709 void *pData = NULL;
1710
1711 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_GetBksv));
1712
1713 pData = stHDMITxArgs.pdata;
1714 stHDMITxArgs.pdata = malloc(sizeof(MS_U8) * DEF_HDCP14_KSV_SIZE);
1715 CPY_FROM_USER(stHDMITxArgs.pdata, pData, sizeof(MS_U8) * DEF_HDCP14_KSV_SIZE);
1716
1717 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1718
1719 CPY_TO_USER(pData, stHDMITxArgs.pdata, sizeof(MS_U8) * DEF_HDCP14_KSV_SIZE);
1720 free(stHDMITxArgs.pdata);
1721 stHDMITxArgs.pdata = pData;
1722 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_GetBksv));
1723
1724 }
1725 #undef DEF_HDCP14_KSV_SIZE
1726 }
1727 break;
1728
1729 case E_HDMITX_CMD_GETAKSV:
1730 {
1731 #if EN_HDMITX_ADP_LOG
1732 printk("E_HDMITX_CMD_GETAKSV\r\n");
1733 #endif
1734 stHDMITx_GetAksv stHDMITxArgs = {0};
1735 #define DEF_HDCP14_KSV_SIZE 5U
1736
1737 if(IS_CMP_TASK())
1738 {
1739 stHDMITx_GetAksv_Compat stCompatHDMITxArgs = {0};
1740
1741 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_GetAksv_Compat));
1742
1743 stHDMITxArgs.pdata = malloc(sizeof(MS_U8) * DEF_HDCP14_KSV_SIZE);
1744 CMP_CPY_FROM_USER(stHDMITxArgs.pdata, stCompatHDMITxArgs.pdata, sizeof(MS_U8) * DEF_HDCP14_KSV_SIZE);
1745 stHDMITxArgs.bReturn = stCompatHDMITxArgs.bReturn;
1746
1747 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1748 stCompatHDMITxArgs.bReturn = stHDMITxArgs.bReturn;
1749
1750 CMP_CPY_TO_USER(stCompatHDMITxArgs.pdata, stHDMITxArgs.pdata, sizeof(MS_U8) * DEF_HDCP14_KSV_SIZE);
1751 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_GetAksv_Compat));
1752
1753 free(stHDMITxArgs.pdata);
1754 }
1755 else
1756 {
1757 void *pData = NULL;
1758
1759 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_GetAksv));
1760
1761 pData = stHDMITxArgs.pdata;
1762 stHDMITxArgs.pdata = malloc(sizeof(MS_U8) * DEF_HDCP14_KSV_SIZE);
1763 CPY_FROM_USER(stHDMITxArgs.pdata, pData, sizeof(MS_U8) * DEF_HDCP14_KSV_SIZE);
1764
1765 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1766
1767 CPY_TO_USER(pData, stHDMITxArgs.pdata, sizeof(MS_U8) * DEF_HDCP14_KSV_SIZE);
1768 free(stHDMITxArgs.pdata);
1769 stHDMITxArgs.pdata = pData;
1770 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_GetAksv));
1771
1772 }
1773 #undef DEF_HDCP14_KSV_SIZE
1774 }
1775 break;
1776
1777 case E_HDMITX_CMD_SETHDCPONOFF:
1778 #if EN_HDMITX_ADP_LOG
1779 printk("E_HDMITX_CMD_SETHDCPONOFF\r\n");
1780 #endif
1781 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETHDCPONOFF, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1782 break;
1783
1784 case E_HDMITX_CMD_SETAVMUTE:
1785 #if EN_HDMITX_ADP_LOG
1786 printk("E_HDMITX_CMD_SETAVMUTE\r\n");
1787 #endif
1788 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETAVMUTE, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1789 break;
1790
1791 case E_HDMITX_CMD_GETAVMUTESTATUS:
1792 #if EN_HDMITX_ADP_LOG
1793 printk("E_HDMITX_CMD_GETAVMUTESTATUS\r\n");
1794 #endif
1795 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_GETAVMUTESTATUS, spt_HDMITX_GETAVMUTESTATUS, usbuffer_arg, sizeof(usbuffer_arg));
1796 break;
1797
1798 case E_HDMITX_CMD_HDCP_REVOCATIONKEY_LIST:
1799 {
1800 #if EN_HDMITX_ADP_LOG
1801 printk("E_HDMITX_CMD_HDCP_REVOCATIONKEY_LIST\r\n");
1802 #endif
1803 stHDMITx_HDCP_RevocationKey_List stHDMITxArgs = {0};
1804
1805 if(IS_CMP_TASK())
1806 {
1807 stHDMITx_HDCP_RevocationKey_List_Compat stCompatHDMITxArgs = {0};
1808
1809 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_HDCP_RevocationKey_List_Compat));
1810
1811 stHDMITxArgs.data = malloc(sizeof(MS_U8) *stCompatHDMITxArgs.size);
1812 CMP_CPY_FROM_USER(stHDMITxArgs.data, stCompatHDMITxArgs.data, sizeof(MS_U8) *stCompatHDMITxArgs.size);
1813 stHDMITxArgs.size = stCompatHDMITxArgs.size;
1814
1815 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1816
1817 CMP_CPY_TO_USER(stCompatHDMITxArgs.data, stHDMITxArgs.data, sizeof(MS_U8) *stCompatHDMITxArgs.size);
1818 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_HDCP_RevocationKey_List_Compat));
1819
1820 free(stHDMITxArgs.data);
1821 }
1822 else
1823 {
1824 void *pData = NULL;
1825
1826 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_HDCP_RevocationKey_List));
1827
1828 pData = stHDMITxArgs.data;
1829 stHDMITxArgs.data = malloc(sizeof(MS_U8) *stHDMITxArgs.size);
1830 CPY_FROM_USER(stHDMITxArgs.data, pData, sizeof(MS_U8) *stHDMITxArgs.size);
1831
1832 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1833
1834 CPY_TO_USER(pData, stHDMITxArgs.data, sizeof(MS_U8) *stHDMITxArgs.size);
1835 free(stHDMITxArgs.data);
1836 stHDMITxArgs.data = pData;
1837 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_HDCP_RevocationKey_List));
1838 }
1839 }
1840 break;
1841
1842 case E_HDMITX_CMD_HDCP_REVOCATIONKEY_CHECK:
1843 #if EN_HDMITX_ADP_LOG
1844 printk("E_HDMITX_CMD_HDCP_REVOCATIONKEY_CHECK\r\n");
1845 #endif
1846 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_HDCP14REVOKEKEYCHK, spt_HDMITX_HDCP14REVOKEKEYCHK, usbuffer_arg, sizeof(usbuffer_arg));
1847 break;
1848
1849 case E_HDMITX_CMD_HDCP_ISSRMSIGNATUREVALID:
1850 {
1851 #if EN_HDMITX_ADP_LOG
1852 printk("E_HDMITX_CMD_HDCP_ISSRMSIGNATUREVALID\r\n");
1853 #endif
1854 stHDMITx_HDCP_IsSRMSignatureValid stHDMITxArgs = {0};
1855
1856 if(IS_CMP_TASK())
1857 {
1858 stHDMITx_HDCP_IsSRMSignatureValid_Compat stCompatHDMITxArgs = {0};
1859
1860 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_HDCP_IsSRMSignatureValid_Compat));
1861
1862 stHDMITxArgs.data = malloc(sizeof(MS_U8) *stCompatHDMITxArgs.size);
1863 CMP_CPY_FROM_USER(stHDMITxArgs.data, stCompatHDMITxArgs.data, sizeof(MS_U8) *stCompatHDMITxArgs.size);
1864 stHDMITxArgs.size = stCompatHDMITxArgs.size;
1865 stHDMITxArgs.bReturn = stCompatHDMITxArgs.bReturn;
1866
1867 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1868 stCompatHDMITxArgs.bReturn = stHDMITxArgs.bReturn;
1869
1870 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_HDCP_IsSRMSignatureValid_Compat));
1871
1872 free(stHDMITxArgs.data);
1873 }
1874 else
1875 {
1876 void *pData = NULL;
1877
1878 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_HDCP_IsSRMSignatureValid));
1879
1880 pData = stHDMITxArgs.data;
1881 stHDMITxArgs.data = malloc(sizeof(MS_U8) *stHDMITxArgs.size);
1882 CPY_FROM_USER(stHDMITxArgs.data, pData, sizeof(MS_U8) *stHDMITxArgs.size);
1883
1884 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
1885
1886 CPY_TO_USER(pData, stHDMITxArgs.data, sizeof(MS_U8) *stHDMITxArgs.size);
1887 free(stHDMITxArgs.data);
1888 stHDMITxArgs.data = pData;
1889 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_HDCP_IsSRMSignatureValid));
1890
1891 }
1892 }
1893 break;
1894
1895 case E_HDMITX_CMD_GETHDCPSTATUS:
1896 #if EN_HDMITX_ADP_LOG
1897 printk("E_HDMITX_CMD_GETHDCPSTATUS\r\n");
1898 #endif
1899 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_GETHDCPSTATUS, spt_HDMITX_GETHDCPSTATUS, usbuffer_arg, sizeof(usbuffer_arg));
1900 break;
1901
1902 case E_HDMITX_CMD_HDCP_STARTAUTH:
1903 #if EN_HDMITX_ADP_LOG
1904 printk("E_HDMITX_CMD_HDCP_STARTAUTH\r\n");
1905 #endif
1906 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_HDCP14STARTAUTH, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1907 break;
1908
1909 case E_HDMITX_CMD_GETINTHDCPSTATUS:
1910 #if EN_HDMITX_ADP_LOG
1911 printk("E_HDMITX_CMD_GETINTHDCPSTATUS\r\n");
1912 #endif
1913 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_GETINTHDCPSTATUS, spt_HDMITX_GETINTHDCPSTATUS, usbuffer_arg, sizeof(usbuffer_arg));
1914 break;
1915
1916 case E_HDMITX_CMD_GETHDCP_PRESTATUS:
1917 #if EN_HDMITX_ADP_LOG
1918 printk("E_HDMITX_CMD_GETHDCP_PRESTATUS\r\n");
1919 #endif
1920 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_GETHDCP14PRESTATUS, spt_HDMITX_GETHDCP14PRESTATUS, usbuffer_arg, sizeof(usbuffer_arg));
1921 break;
1922
1923 case E_HDMITX_CMD_UNHDCPRXCONTROL:
1924 #if EN_HDMITX_ADP_LOG
1925 printk("E_HDMITX_CMD_UNHDCPRXCONTROL\r\n");
1926 #endif
1927 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_UNHDCPRXCTRL, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1928 break;
1929
1930 case E_HDMITX_CMD_HDCPRXFAILCONTROL:
1931 #if EN_HDMITX_ADP_LOG
1932 printk("E_HDMITX_CMD_HDCPRXFAILCONTROL\r\n");
1933 #endif
1934 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_HDCPRXFAILCTRL, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1935 break;
1936
1937 case E_HDMITX_CMD_GETLIBVER:
1938 #if EN_HDMITX_ADP_LOG
1939 printk("E_HDMITX_CMD_GETLIBVER\r\n");
1940 #endif
1941 #if 0
1942 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_GETLIBVER, spt_HDMITX_GETLIBVER, usbuffer_arg, sizeof(usbuffer_arg));
1943 #endif
1944 break;
1945
1946 case E_HDMITX_CMD_GETINFO:
1947 #if EN_HDMITX_ADP_LOG
1948 printk("E_HDMITX_CMD_GETINFO\r\n");
1949 #endif
1950 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_GETINFO, spt_HDMITX_GETINFO, usbuffer_arg, sizeof(usbuffer_arg));
1951 break;
1952
1953 case E_HDMITX_CMD_GETSTATUS:
1954 #if EN_HDMITX_ADP_LOG
1955 printk("E_HDMITX_CMD_GETSTATUS\r\n");
1956 #endif
1957 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_GETSTATUS, spt_HDMITX_GETSTATUS, usbuffer_arg, sizeof(usbuffer_arg));
1958 break;
1959
1960 case E_HDMITX_CMD_SETDBGLEVEL:
1961 #if EN_HDMITX_ADP_LOG
1962 printk("E_HDMITX_CMD_SETDBGLEVEL\r\n");
1963 #endif
1964 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETDBGLEVEL, spt_HDMITX_SETDBGLEVEL, usbuffer_arg, sizeof(usbuffer_arg));
1965 break;
1966
1967 case E_HDMITX_CMD_SETHPDGPIOPIN:
1968 #if EN_HDMITX_ADP_LOG
1969 printk("E_HDMITX_CMD_SETHPDGPIOPIN\r\n");
1970 #endif
1971 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETHPDGPIOPIN, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1972 break;
1973
1974 case E_HDMITX_CMD_ANALOGTUNING:
1975 #if EN_HDMITX_ADP_LOG
1976 printk("E_HDMITX_CMD_ANALOGTUNING\r\n");
1977 #endif
1978 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_ANALOGTUNING, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1979 break;
1980
1981 case E_HDMITX_CMD_FORCEHDMIOUTPUTMODE:
1982 #if EN_HDMITX_ADP_LOG
1983 printk("E_HDMITX_CMD_FORCEHDMIOUTPUTMODE\r\n");
1984 #endif
1985 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_FORCEHDMIOUTPUTMODE, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1986 break;
1987
1988 case E_HDMITX_CMD_FORCEHDMIOUTPUTCOLORFORMAT:
1989 #if EN_HDMITX_ADP_LOG
1990 printk("E_HDMITX_CMD_FORCEHDMIOUTPUTCOLORFORMAT\r\n");
1991 #endif
1992 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_FORCEHDMIOUTPUTCOLORFMT, NULL, usbuffer_arg, sizeof(usbuffer_arg));
1993 break;
1994
1995 case E_HDMITX_CMD_DISABLEREGWRITE:
1996 #if EN_HDMITX_ADP_LOG
1997 printk("E_HDMITX_CMD_DISABLEREGWRITE\r\n");
1998 #endif
1999 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_DISABLEREGWRITE, NULL, usbuffer_arg, sizeof(usbuffer_arg));
2000 break;
2001
2002 case E_HDMITX_CMD_GETEDIDPHYADR:
2003 {
2004 #if EN_HDMITX_ADP_LOG
2005 printk("E_HDMITX_CMD_GETEDIDPHYADR\r\n");
2006 #endif
2007 stHDMITx_GetEDIDPhyAdr stHDMITxArgs = {0};
2008 #define DEF_EDID_PHYADDR_SIZE 2U
2009
2010 if(IS_CMP_TASK())
2011 {
2012 stHDMITx_GetEDIDPhyAdr_Compat stCompatHDMITxArgs = {0};
2013
2014 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_GetEDIDPhyAdr_Compat));
2015
2016 stHDMITxArgs.pdata = malloc(sizeof(MS_U8) * DEF_EDID_PHYADDR_SIZE);
2017 CMP_CPY_FROM_USER(stHDMITxArgs.pdata, stCompatHDMITxArgs.pdata, sizeof(MS_U8) * DEF_EDID_PHYADDR_SIZE);
2018
2019 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
2020
2021 CMP_CPY_TO_USER(stCompatHDMITxArgs.pdata, stHDMITxArgs.pdata, sizeof(MS_U8) * DEF_EDID_PHYADDR_SIZE);
2022 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_GetEDIDPhyAdr_Compat));
2023
2024 free(stHDMITxArgs.pdata);
2025 }
2026 else
2027 {
2028 void *pData = NULL;
2029
2030 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_GetEDIDPhyAdr));
2031
2032 pData = stHDMITxArgs.pdata;
2033 stHDMITxArgs.pdata = malloc(sizeof(MS_U8) * DEF_EDID_PHYADDR_SIZE);
2034 CPY_FROM_USER(stHDMITxArgs.pdata, pData, sizeof(MS_U8) * DEF_EDID_PHYADDR_SIZE);
2035
2036 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
2037
2038 CPY_TO_USER(pData, stHDMITxArgs.pdata, sizeof(MS_U8) * DEF_EDID_PHYADDR_SIZE);
2039 free(stHDMITxArgs.pdata);
2040 stHDMITxArgs.pdata = pData;
2041 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_GetEDIDPhyAdr));
2042
2043 }
2044 #undef DEF_EDID_PHYADDR_SIZE
2045 }
2046 break;
2047
2048 case E_HDMITX_CMD_SETCECONOFF:
2049 #if EN_HDMITX_ADP_LOG
2050 printk("E_HDMITX_CMD_SETCECONOFF\r\n");
2051 #endif
2052 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETCECONOFF, NULL, usbuffer_arg, sizeof(usbuffer_arg));
2053 break;
2054
2055 case E_HDMITX_CMD_GETCECSTATUS:
2056 #if EN_HDMITX_ADP_LOG
2057 printk("E_HDMITX_CMD_GETCECSTATUS\r\n");
2058 #endif
2059 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_GETCECSTATUS, spt_HDMITX_GETCECSTATUS, usbuffer_arg, sizeof(usbuffer_arg));
2060 break;
2061
2062 case E_HDMITX_CMD_EDIDCHECKING:
2063 #if EN_HDMITX_ADP_LOG
2064 printk("E_HDMITX_CMD_EDIDCHECKING111::: 0x%X\r\n", u32Cmd);
2065 #endif
2066 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_EDIDCHECKING, spt_HDMITX_EDIDCHECKING, usbuffer_arg, sizeof(usbuffer_arg));
2067 #if EN_HDMITX_ADP_LOG
2068 printk("end of E_HDMITX_CMD_EDIDCHECKING\r\n");
2069 #endif
2070 break;
2071
2072 case E_HDMITX_CMD_RXBYPASS_MODE:
2073 #if EN_HDMITX_ADP_LOG
2074 printk("E_HDMITX_CMD_RXBYPASS_MODE\r\n");
2075 #endif
2076 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_RXBYPASSMODE, spt_HDMITX_RXBYPASSMODE, usbuffer_arg, sizeof(usbuffer_arg));
2077 break;
2078
2079 case E_HDMITX_CMD_DISABLE_RXBYPASS:
2080 #if EN_HDMITX_ADP_LOG
2081 printk("E_HDMITX_CMD_DISABLE_RXBYPASS\r\n");
2082 #endif
2083 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_DISABLERXBYPASS, spt_HDMITX_DISABLERXBYPASS, usbuffer_arg, sizeof(usbuffer_arg));
2084 break;
2085
2086 case E_HDMITX_CMD_SETAKSV2R0INTERVAL:
2087 #if EN_HDMITX_ADP_LOG
2088 printk("E_HDMITX_CMD_SETAKSV2R0INTERVAL\r\n");
2089 #endif
2090 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETAKSV2R0INTERVAL, spt_HDMITX_SETAKSV2R0INTERVAL, usbuffer_arg, sizeof(usbuffer_arg));
2091 break;
2092
2093 case E_HDMITX_CMD_ISRXVALID:
2094 #if EN_HDMITX_ADP_LOG
2095 printk("E_HDMITX_CMD_ISRXVALID\r\n");
2096 #endif
2097 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_ISHDCPRXVALID, spt_HDMITX_ISHDCPRXVALID, usbuffer_arg, sizeof(usbuffer_arg));
2098 break;
2099
2100 case E_HDMITX_CMD_GETCHIPCAPS:
2101 {
2102 #if EN_HDMITX_ADP_LOG
2103 printk("E_HDMITX_CMD_GETCHIPCAPS\r\n");
2104 #endif
2105 stHDMITx_GetChipCaps stHDMITxArgs = {0};
2106
2107 if(IS_CMP_TASK())
2108 {
2109 stHDMITx_GetChipCaps_Compat stCompatHDMITxArgs = {0};
2110
2111 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_GetChipCaps_Compat));
2112
2113 stHDMITxArgs.pRet = malloc(sizeof(MS_U32) * stCompatHDMITxArgs.ret_size);
2114 CMP_CPY_FROM_USER(stHDMITxArgs.pRet, stCompatHDMITxArgs.pRet, sizeof(MS_U32) * stCompatHDMITxArgs.ret_size);
2115 stHDMITxArgs.eCapType = stCompatHDMITxArgs.eCapType;
2116 stHDMITxArgs.ret_size = stCompatHDMITxArgs.ret_size;
2117 stHDMITxArgs.bReturn = stCompatHDMITxArgs.bReturn;
2118
2119 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
2120 stCompatHDMITxArgs.bReturn = stHDMITxArgs.bReturn;
2121
2122 CMP_CPY_TO_USER(stCompatHDMITxArgs.pRet, stHDMITxArgs.pRet, sizeof(MS_U32) * stCompatHDMITxArgs.ret_size);
2123 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_GetChipCaps_Compat));
2124
2125 free(stHDMITxArgs.pRet);
2126 }
2127 else
2128 {
2129 void *pData = NULL;
2130
2131 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_GetChipCaps));
2132
2133 pData = stHDMITxArgs.pRet;
2134 stHDMITxArgs.pRet = malloc(sizeof(MS_U32) * stHDMITxArgs.ret_size);
2135 CPY_FROM_USER(stHDMITxArgs.pRet, pData, sizeof(MS_U32) * stHDMITxArgs.ret_size);
2136
2137 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
2138
2139 CPY_TO_USER(pData, stHDMITxArgs.pRet, sizeof(MS_U32) * stHDMITxArgs.ret_size);
2140 free(stHDMITxArgs.pRet);
2141 stHDMITxArgs.pRet = pData;
2142 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_GetChipCaps));
2143 }
2144 }
2145 break;
2146
2147 case E_HDMITX_CMD_SETPOWERSTATE:
2148 #if EN_HDMITX_ADP_LOG
2149 printk("E_HDMITX_CMD_SETPOWERSTATE\r\n");
2150 #endif
2151 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETPWRSTATE, spt_HDMITX_SETPWRSTATE, usbuffer_arg, sizeof(usbuffer_arg));
2152 break;
2153 case E_HDMITX_CMD_GETEDIDDATABLOCK:
2154 {
2155 #if EN_HDMITX_ADP_LOG
2156 printk("E_HDMITX_CMD_GETEDIDDATABLOCK\r\n");
2157 #endif
2158 stHDMITx_GetEdidDataBlocks stHDMITxArgs = {0};
2159
2160 if(IS_CMP_TASK())
2161 {
2162 stHDMITx_GetEdidDataBlocks_Compat stCompatHDMITxArgs = {0};
2163
2164 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_GetEdidDataBlocks_Compat));
2165
2166 stHDMITxArgs.pu8Data = malloc(sizeof(MS_U8) *stCompatHDMITxArgs.u32DataLen);
2167 CMP_CPY_FROM_USER(stHDMITxArgs.pu8Data, stCompatHDMITxArgs.pu8Data, sizeof(MS_U8) *stCompatHDMITxArgs.u32DataLen);
2168
2169 stHDMITxArgs.enTagCode = stCompatHDMITxArgs.enTagCode;
2170 stHDMITxArgs.enExtTagCode = stCompatHDMITxArgs.enExtTagCode;
2171 stHDMITxArgs.u32DataLen = stCompatHDMITxArgs.u32DataLen;
2172
2173 stHDMITxArgs.pu32RealLen = malloc(sizeof(MS_U32));
2174 CMP_CPY_FROM_USER(stHDMITxArgs.pu32RealLen, stCompatHDMITxArgs.pu32RealLen, sizeof(MS_U32));
2175
2176 stHDMITxArgs.bReturn = stCompatHDMITxArgs.bReturn;
2177
2178 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
2179 stCompatHDMITxArgs.bReturn = stHDMITxArgs.bReturn;
2180
2181 CMP_CPY_TO_USER(stCompatHDMITxArgs.pu8Data, stHDMITxArgs.pu8Data, sizeof(MS_U8) *stCompatHDMITxArgs.u32DataLen);
2182 CMP_CPY_TO_USER(stCompatHDMITxArgs.pu32RealLen, stHDMITxArgs.pu32RealLen, sizeof(MS_U32));
2183 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_GetEdidDataBlocks_Compat));
2184
2185 free(stHDMITxArgs.pu8Data);
2186 free(stHDMITxArgs.pu32RealLen);
2187 }
2188 else
2189 {
2190 void *pData = NULL;
2191 void *pLen = NULL;
2192
2193 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_GetEdidDataBlocks));
2194
2195 pData = stHDMITxArgs.pu8Data;
2196 stHDMITxArgs.pu8Data = malloc(sizeof(MS_U8) *stHDMITxArgs.u32DataLen);
2197 CPY_FROM_USER(stHDMITxArgs.pu8Data, pData, sizeof(MS_U8) *stHDMITxArgs.u32DataLen);
2198
2199 pLen = stHDMITxArgs.pu32RealLen;
2200 stHDMITxArgs.pu32RealLen = malloc(sizeof(MS_U32));
2201 CPY_FROM_USER(stHDMITxArgs.pu32RealLen, pLen, sizeof(MS_U32));
2202
2203 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
2204
2205 CPY_TO_USER(pData, stHDMITxArgs.pu8Data, sizeof(MS_U8) *stHDMITxArgs.u32DataLen);
2206 CPY_TO_USER(pLen, stHDMITxArgs.pu32RealLen, sizeof(MS_U32));
2207 free(stHDMITxArgs.pu8Data);
2208 free(stHDMITxArgs.pu32RealLen);
2209 stHDMITxArgs.pu8Data = pData;
2210 stHDMITxArgs.pu32RealLen = pLen;
2211 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_GetEdidDataBlocks));
2212
2213 }
2214 }
2215 break;
2216 case E_HDMITX_CMD_GETKSVLIST:
2217 {
2218 #if EN_HDMITX_ADP_LOG
2219 printk("E_HDMITX_CMD_GETKSVLIST\r\n");
2220 #endif
2221 #define DEF_HDCP14_BSTATUS_SIZE 2U
2222 stHDMITx_GetKSVList stHDMITxArgs = {0};
2223
2224 if(IS_CMP_TASK())
2225 {
2226 stHDMITx_GetKSVList_Compat stCompatHDMITxArgs = {0};
2227
2228 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_GetKSVList_Compat));
2229
2230 stHDMITxArgs.pu8Bstatus = malloc(sizeof(MS_U8) * DEF_HDCP14_BSTATUS_SIZE);
2231 CMP_CPY_FROM_USER(stHDMITxArgs.pu8Bstatus, stCompatHDMITxArgs.pu8Bstatus, sizeof(MS_U8) * DEF_HDCP14_BSTATUS_SIZE);
2232
2233 stHDMITxArgs.pu8KSVList = malloc(sizeof(MS_U8) *stCompatHDMITxArgs.u16BufLen);
2234 CMP_CPY_FROM_USER(stHDMITxArgs.pu8KSVList, stCompatHDMITxArgs.pu8KSVList, sizeof(MS_U8) *stCompatHDMITxArgs.u16BufLen);
2235
2236 stHDMITxArgs.u16BufLen = stCompatHDMITxArgs.u16BufLen;
2237
2238 stHDMITxArgs.pu16KSVLength = malloc(sizeof(MS_U16));
2239 CMP_CPY_FROM_USER(stHDMITxArgs.pu16KSVLength, stCompatHDMITxArgs.pu16KSVLength, sizeof(MS_U16));
2240
2241 stHDMITxArgs.bReturn = stCompatHDMITxArgs.bReturn;
2242
2243 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
2244 stCompatHDMITxArgs.bReturn = stHDMITxArgs.bReturn;
2245
2246 CMP_CPY_TO_USER(stCompatHDMITxArgs.pu8Bstatus, stHDMITxArgs.pu8Bstatus, sizeof(MS_U8) * DEF_HDCP14_BSTATUS_SIZE);
2247 CMP_CPY_TO_USER(stCompatHDMITxArgs.pu8KSVList, stHDMITxArgs.pu8KSVList, sizeof(MS_U8) *stCompatHDMITxArgs.u16BufLen);
2248 CMP_CPY_TO_USER(stCompatHDMITxArgs.pu16KSVLength, stHDMITxArgs.pu16KSVLength, sizeof(MS_U16));
2249 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_GetKSVList_Compat));
2250
2251 free(stHDMITxArgs.pu8Bstatus);
2252 free(stHDMITxArgs.pu8KSVList);
2253 free(stHDMITxArgs.pu16KSVLength);
2254 }
2255 else
2256 {
2257 void *pBStatus = NULL;
2258 void *pData = NULL;
2259 void *pLen = NULL;
2260
2261 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_GetKSVList));
2262
2263 pBStatus = stHDMITxArgs.pu8Bstatus;
2264 stHDMITxArgs.pu8Bstatus = malloc(sizeof(MS_U8) * DEF_HDCP14_BSTATUS_SIZE);
2265 CPY_FROM_USER(stHDMITxArgs.pu8Bstatus, pBStatus, sizeof(MS_U8) * DEF_HDCP14_BSTATUS_SIZE);
2266
2267 pData = stHDMITxArgs.pu8KSVList;
2268 stHDMITxArgs.pu8KSVList = malloc(sizeof(MS_U8) * stHDMITxArgs.u16BufLen);
2269 CPY_FROM_USER(stHDMITxArgs.pu8KSVList, pData, sizeof(MS_U8) * stHDMITxArgs.u16BufLen);
2270
2271 pLen = stHDMITxArgs.pu16KSVLength;
2272 stHDMITxArgs.pu16KSVLength = malloc(sizeof(MS_U16));
2273 CPY_FROM_USER(stHDMITxArgs.pu16KSVLength, pLen, sizeof(MS_U16));
2274
2275 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
2276
2277 CPY_TO_USER(pBStatus, stHDMITxArgs.pu8Bstatus, sizeof(MS_U8) * DEF_HDCP14_BSTATUS_SIZE);
2278 CPY_TO_USER(pData, stHDMITxArgs.pu8KSVList, sizeof(MS_U8) * stHDMITxArgs.u16BufLen);
2279 CPY_TO_USER(pLen, stHDMITxArgs.pu16KSVLength, sizeof(MS_U16));
2280 free(stHDMITxArgs.pu8Bstatus);
2281 free(stHDMITxArgs.pu8KSVList);
2282 free(stHDMITxArgs.pu16KSVLength);
2283 stHDMITxArgs.pu8Bstatus = pBStatus;
2284 stHDMITxArgs.pu8KSVList = pData;
2285 stHDMITxArgs.pu16KSVLength= pLen;
2286 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_GetKSVList));
2287
2288 }
2289 #undef DEF_HDCP14_BSTATUS_SIZE
2290 }
2291 break;
2292
2293 case E_HDMITX_CMD_HDCP2ACCESSX74:
2294 {
2295 #if EN_HDMITX_ADP_LOG
2296 printk("E_HDMITX_CMD_HDCP2ACCESSX74\r\n");
2297 #endif
2298 stHDMITx_HDCP2AccessX74 stHDMITxArgs = {0};
2299
2300 if(IS_CMP_TASK())
2301 {
2302 stHDMITx_HDCP2AccessX74_Compat stCompatHDMITxArgs = {0};
2303
2304 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_HDCP2AccessX74_Compat));
2305
2306 stHDMITxArgs.u8PortIdx = stCompatHDMITxArgs.u8PortIdx;
2307 stHDMITxArgs.u8OffsetAddr = stCompatHDMITxArgs.u8OffsetAddr;
2308 stHDMITxArgs.u8OpCode = stCompatHDMITxArgs.u8OpCode;
2309
2310 stHDMITxArgs.pu8RdBuf = malloc(sizeof(MS_U8) * stCompatHDMITxArgs.u16RdLen);
2311 CMP_CPY_FROM_USER(stHDMITxArgs.pu8RdBuf, stCompatHDMITxArgs.pu8RdBuf, sizeof(MS_U8) * stCompatHDMITxArgs.u16RdLen);
2312
2313 stHDMITxArgs.u16RdLen = stCompatHDMITxArgs.u16RdLen;
2314
2315 stHDMITxArgs.pu8WRBuff = malloc(sizeof(MS_U8) * stCompatHDMITxArgs.u16WrLen);
2316 CMP_CPY_FROM_USER(stHDMITxArgs.pu8WRBuff, stCompatHDMITxArgs.pu8WRBuff, sizeof(MS_U8) * stCompatHDMITxArgs.u16WrLen);
2317
2318 stHDMITxArgs.u16WrLen = stCompatHDMITxArgs.u16WrLen;
2319 stHDMITxArgs.bReturn = stCompatHDMITxArgs.bReturn;
2320
2321 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
2322 stCompatHDMITxArgs.bReturn = stHDMITxArgs.bReturn;
2323
2324 CMP_CPY_TO_USER(stCompatHDMITxArgs.pu8RdBuf, stHDMITxArgs.pu8RdBuf, sizeof(MS_U8) * stCompatHDMITxArgs.u16RdLen);
2325 CMP_CPY_TO_USER(pArgs, &stCompatHDMITxArgs, sizeof(stHDMITx_HDCP2AccessX74_Compat));
2326
2327 free(stHDMITxArgs.pu8RdBuf);
2328 free(stHDMITxArgs.pu8WRBuff);
2329 }
2330 else
2331 {
2332 MS_U8 *pRdData = NULL;
2333 MS_U8 *pWrData = NULL;
2334
2335 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_HDCP2AccessX74));
2336
2337 pRdData = stHDMITxArgs.pu8RdBuf;
2338 stHDMITxArgs.pu8RdBuf = malloc(sizeof(MS_U8) * stHDMITxArgs.u16RdLen);
2339 CPY_FROM_USER(stHDMITxArgs.pu8RdBuf, pRdData, sizeof(MS_U8) * stHDMITxArgs.u16RdLen);
2340
2341 pWrData = stHDMITxArgs.pu8WRBuff;
2342 stHDMITxArgs.pu8WRBuff = malloc(sizeof(MS_U8) * stHDMITxArgs.u16WrLen);
2343 CPY_FROM_USER(stHDMITxArgs.pu8WRBuff, pWrData, sizeof(MS_U8) * stHDMITxArgs.u16WrLen);
2344
2345 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
2346
2347 CPY_TO_USER(pRdData, stHDMITxArgs.pu8RdBuf, sizeof(MS_U8) * stHDMITxArgs.u16RdLen);
2348 //CPY_TO_USER(pWrData, stHDMITxArgs.pu8WRBuff, sizeof(MS_U8) * stHDMITxArgs.u16WrLen);
2349 free(stHDMITxArgs.pu8RdBuf);
2350 free(stHDMITxArgs.pu8WRBuff);
2351 stHDMITxArgs.pu8RdBuf = pRdData;
2352 stHDMITxArgs.pu8WRBuff = pWrData;
2353 CPY_TO_USER(pArgs, &stHDMITxArgs, sizeof(stHDMITx_HDCP2AccessX74));
2354 }
2355 }
2356 break;
2357
2358 case E_HDMITX_CMD_HDCP2TxInit:
2359 #if EN_HDMITX_ADP_LOG
2360 printk("E_HDMITX_CMD_HDCP2TxInit\r\n");
2361 #endif
2362 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_HDCP2TXINIT, NULL, usbuffer_arg, sizeof(usbuffer_arg));
2363 break;
2364
2365 case E_HDMITX_CMD_HDCP2TxEnableEncrypt:
2366 #if EN_HDMITX_ADP_LOG
2367 printk("E_HDMITX_CMD_HDCP2TxEnableEncrypt\r\n");
2368 #endif
2369 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_HDCP2TXENABLEENC, NULL, usbuffer_arg, sizeof(usbuffer_arg));
2370 break;
2371
2372 case E_HDMITX_CMD_HDCP2TxFillCipherKey:
2373 {
2374 #if EN_HDMITX_ADP_LOG
2375 printk("E_HDMITX_CMD_HDCP2TxFillCipherKey\r\n");
2376 #endif
2377 #define DEF_HDCP22_RIV_SIZE 8U
2378 #define DEF_HDCP22_KS_SIZE 16U
2379
2380 stHDMITx_HDCP2TxFillCipherKey stHDMITxArgs = {0};
2381
2382 if(IS_CMP_TASK())
2383 {
2384 stHDMITx_HDCP2TxFillCipherKey_Compat stCompatHDMITxArgs = {0};
2385
2386 CMP_CPY_FROM_USER(&stCompatHDMITxArgs, pArgs, sizeof(stHDMITx_HDCP2TxFillCipherKey_Compat));
2387
2388 stHDMITxArgs.u8PortIdx = stCompatHDMITxArgs.u8PortIdx;
2389
2390 stHDMITxArgs.pu8Riv = malloc(sizeof(MS_U8) * DEF_HDCP22_RIV_SIZE);
2391 CMP_CPY_FROM_USER(stHDMITxArgs.pu8Riv, stCompatHDMITxArgs.pu8Riv, sizeof(MS_U8) * DEF_HDCP22_RIV_SIZE);
2392
2393 stHDMITxArgs.pu8Riv = malloc(sizeof(MS_U8) * DEF_HDCP22_KS_SIZE);
2394 CMP_CPY_FROM_USER(stHDMITxArgs.pu8KsXORLC128, stCompatHDMITxArgs.pu8KsXORLC128, sizeof(MS_U8) * DEF_HDCP22_KS_SIZE);
2395
2396 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
2397
2398 free(stHDMITxArgs.pu8Riv);
2399 free(stHDMITxArgs.pu8KsXORLC128);
2400 }
2401 else
2402 {
2403 MS_U8 *pRivData = NULL;
2404 MS_U8 *pKsData = NULL;
2405
2406 CPY_FROM_USER(&stHDMITxArgs, pArgs, sizeof(stHDMITx_HDCP2TxFillCipherKey));
2407
2408 pRivData = stHDMITxArgs.pu8Riv;
2409 stHDMITxArgs.pu8Riv = malloc(sizeof(MS_U8) * DEF_HDCP22_RIV_SIZE);
2410 CPY_FROM_USER(stHDMITxArgs.pu8Riv, pRivData, sizeof(MS_U8) * DEF_HDCP22_RIV_SIZE);
2411
2412 pKsData = stHDMITxArgs.pu8KsXORLC128;
2413 stHDMITxArgs.pu8KsXORLC128 = malloc(sizeof(MS_U8) * DEF_HDCP22_KS_SIZE);
2414 CPY_FROM_USER(stHDMITxArgs.pu8KsXORLC128, pKsData, sizeof(MS_U8) * DEF_HDCP22_KS_SIZE);
2415
2416 ulReturnValue = UtopiaIoctl(pInstanceTmp, u32Cmd, &stHDMITxArgs);
2417
2418 free(stHDMITxArgs.pu8Riv);
2419 free(stHDMITxArgs.pu8KsXORLC128);
2420 }
2421 #undef DEF_HDCP22_RIV_SIZE
2422 #undef DEF_HDCP22_KS_SIZE
2423 }
2424
2425 break;
2426
2427 case E_HDMITX_CMD_COLOR_AND_RANGE_TRANSFORM:
2428 {
2429 #if EN_HDMITX_ADP_LOG
2430 printk("E_HDMITX_CMD_COLOR_AND_RANGE_TRANSFORM\r\n");
2431 #endif
2432 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_COLORRANGE_TRANSFORM, spt_HDMITX_COLORRANGE_TRANSFORM, usbuffer_arg, sizeof(usbuffer_arg));
2433 }
2434 break;
2435
2436 case E_HDMITX_CMD_SSC_ENABLE:
2437 {
2438 #if EN_HDMITX_ADP_LOG
2439 printk("E_HDMITX_CMD_SSC_ENABLE\r\n");
2440 #endif
2441 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETSSCENABLE, spt_HDMITX_SETSSCENABLE, usbuffer_arg, sizeof(usbuffer_arg));
2442 }
2443 break;
2444
2445 case E_HDMITX_CMD_SET_COLORIMETRY:
2446 {
2447 #if EN_HDMITX_ADP_LOG
2448 printk("E_HDMITX_CMD_SETCOLORIMETRY\r\n");
2449 #endif
2450 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETCOLORIMETRY, spt_HDMITX_SETCOLORIMETRY, usbuffer_arg, sizeof(usbuffer_arg));
2451 }
2452 break;
2453
2454 case E_HDMITX_CMD_GET_FULL_RX_STATUS:
2455 {
2456 #if EN_HDMITX_ADP_LOG
2457 printk("E_HDMITX_CMD_SETCOLORIMETRY\r\n");
2458 #endif
2459 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_GET_FULL_RX_STATUS, spt_HDMITX_GET_FULL_RX_STATUS, usbuffer_arg, sizeof(usbuffer_arg));
2460 }
2461 break;
2462
2463 case E_HDMITX_CMD_TIMING_CAPABILITY_CHECK:
2464 {
2465 #if EN_HDMITX_ADP_LOG
2466 printk("E_HDMITX_CMD_TIMING_CAPABILITY_CHECK\r\n");
2467 #endif
2468 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_CHECK_LEGAL_TIMING, spt_HDMITX_CHECK_LEGAL_TIMING, usbuffer_arg, sizeof(usbuffer_arg));
2469 }
2470 break;
2471
2472 case E_HDMITX_CMD_SETVIDEOUTPUTTIMINGBYCUSTOMER:
2473 {
2474 #if EN_HDMITX_ADP_LOG
2475 printk("E_HDMITX_CMD_SetVideoOutputTimingByCustomer\r\n");
2476 #endif
2477 ulReturnValue = UADPBypassIoctl(pInstanceTmp, u32Cmd, pArgs, spt_HDMITX_SETVIDEOUTPUTTIMINGBYCUSTOMER, NULL, usbuffer_arg, sizeof(usbuffer_arg));
2478 }
2479 break;
2480 };
2481
2482 return ulReturnValue;
2483 }
2484
2485 #endif //#ifndef _ADP_HDMITX_C_
2486
2487