1 //<MStar Software>
2 //******************************************************************************
3 // MStar Software
4 // Copyright (c) 2010 - 2012 MStar Semiconductor, Inc. All rights reserved.
5 // All software, firmware and related documentation herein ("MStar Software") are
6 // intellectual property of MStar Semiconductor, Inc. ("MStar") and protected by
7 // law, including, but not limited to, copyright law and international treaties.
8 // Any use, modification, reproduction, retransmission, or republication of all
9 // or part of MStar Software is expressly prohibited, unless prior written
10 // permission has been granted by MStar.
11 //
12 // By accessing, browsing and/or using MStar Software, you acknowledge that you
13 // have read, understood, and agree, to be bound by below terms ("Terms") and to
14 // comply with all applicable laws and regulations:
15 //
16 // 1. MStar shall retain any and all right, ownership and interest to MStar
17 // Software and any modification/derivatives thereof.
18 // No right, ownership, or interest to MStar Software and any
19 // modification/derivatives thereof is transferred to you under Terms.
20 //
21 // 2. You understand that MStar Software might include, incorporate or be
22 // supplied together with third party`s software and the use of MStar
23 // Software may require additional licenses from third parties.
24 // Therefore, you hereby agree it is your sole responsibility to separately
25 // obtain any and all third party right and license necessary for your use of
26 // such third party`s software.
27 //
28 // 3. MStar Software and any modification/derivatives thereof shall be deemed as
29 // MStar`s confidential information and you agree to keep MStar`s
30 // confidential information in strictest confidence and not disclose to any
31 // third party.
32 //
33 // 4. MStar Software is provided on an "AS IS" basis without warranties of any
34 // kind. Any warranties are hereby expressly disclaimed by MStar, including
35 // without limitation, any warranties of merchantability, non-infringement of
36 // intellectual property rights, fitness for a particular purpose, error free
37 // and in conformity with any international standard. You agree to waive any
38 // claim against MStar for any loss, damage, cost or expense that you may
39 // incur related to your use of MStar Software.
40 // In no event shall MStar be liable for any direct, indirect, incidental or
41 // consequential damages, including without limitation, lost of profit or
42 // revenues, lost or damage of data, and unauthorized system use.
43 // You agree that this Section 4 shall still apply without being affected
44 // even if MStar Software has been modified by MStar in accordance with your
45 // request or instruction for your use, except otherwise agreed by both
46 // parties in writing.
47 //
48 // 5. If requested, MStar may from time to time provide technical supports or
49 // services in relation with MStar Software to you for your use of
50 // MStar Software in conjunction with your or your customer`s product
51 // ("Services").
52 // You understand and agree that, except otherwise agreed by both parties in
53 // writing, Services are provided on an "AS IS" basis and the warranty
54 // disclaimer set forth in Section 4 above shall apply.
55 //
56 // 6. Nothing contained herein shall be construed as by implication, estoppels
57 // or otherwise:
58 // (a) conferring any license or right to use MStar name, trademark, service
59 // mark, symbol or any other identification;
60 // (b) obligating MStar or any of its affiliates to furnish any person,
61 // including without limitation, you and your customers, any assistance
62 // of any kind whatsoever, or any information; or
63 // (c) conferring any license or right under any intellectual property right.
64 //
65 // 7. These terms shall be governed by and construed in accordance with the laws
66 // of Taiwan, R.O.C., excluding its conflict of law rules.
67 // Any and all dispute arising out hereof or related hereto shall be finally
68 // settled by arbitration referred to the Chinese Arbitration Association,
69 // Taipei in accordance with the ROC Arbitration Law and the Arbitration
70 // Rules of the Association by three (3) arbitrators appointed in accordance
71 // with the said Rules.
72 // The place of arbitration shall be in Taipei, Taiwan and the language shall
73 // be English.
74 // The arbitration award shall be final and binding to both parties.
75 //
76 //******************************************************************************
77 //<MStar Software>
78 ////////////////////////////////////////////////////////////////////////////////
79 //
80 // Copyright (c) 2008-2009 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
96
97 //-------------------------------------------------------------------------------------------------
98 // Include Files
99 //-------------------------------------------------------------------------------------------------
100 #define _DRV_CEC_C_
101
102 #ifdef MSOS_TYPE_LINUX_KERNEL
103 #include <linux/string.h>
104 #else
105 #include <string.h>
106 #endif
107 #include "MsCommon.h"
108 #include "MsIRQ.h"
109 #include "MsOS.h"
110 #include "MsTypes.h"
111
112 #include "cec_hwreg_utility2.h"
113 #include "cec_Analog_Reg.h"
114
115 #include "apiCEC_private.h"
116 #include "apiCEC.h"
117 #include "drvCEC.h"
118 #include "drvMMIO.h"
119 #include "mhal_CEC.h"
120 #include "drvIPAUTH.h"
121
122 #ifndef _DRV_SYS_H_
123 #include "drvSYS.h"
124 #endif
125
126 #include "utopia.h"
127 #include "utopia_dapi.h"
128
129 //-------------------------------------------------------------------------------------------------
130 // Local Defines
131 //-------------------------------------------------------------------------------------------------
132 #if(defined(CONFIG_MLOG))
133 #include "ULog.h"
134
135 #define MDRV_CEC_MSG_INFO(format, args...) //ULOGI("CEC", format, ##args)
136 #define MDRV_CEC_MSG_WARNING(format, args...) ULOGW("CEC", format, ##args)
137 #define MDRV_CEC_MSG_DEBUG(format, args...) ULOGD("CEC", format, ##args)
138 #define MDRV_CEC_MSG_ERROR(format, args...) ULOGE("CEC", format, ##args)
139 #define MDRV_CEC_MSG_FATAL(format, args...) ULOGF("CEC", format, ##args)
140
141 #else
142 #define MDRV_CEC_MSG_INFO(format, args...) //printf(format, ##args)
143 #define MDRV_CEC_MSG_WARNING(format, args...) printf(format, ##args)
144 #define MDRV_CEC_MSG_DEBUG(format, args...) printf(format, ##args)
145 #define MDRV_CEC_MSG_ERROR(format, args...) printf(format, ##args)
146 #define MDRV_CEC_MSG_FATAL(format, args...) printf(format, ##args)
147
148 #endif
149
150 //-------------------------------------------------------------------------------------------------
151 // Local Structures
152 //-------------------------------------------------------------------------------------------------
153
154 //-------------------------------------------------------------------------------------------------
155 // Global Variables
156 //-------------------------------------------------------------------------------------------------
157
158 //-------------------------------------------------------------------------------------------------
159 // Local Variables
160 //-------------------------------------------------------------------------------------------------
161
162 //MS_VIRT CEC_RIU_BASE;
163
164 //-------------------------------------------------------------------------------------------------
165 // Local Functions
166 //-------------------------------------------------------------------------------------------------
167
168 //**************************************************************************
169 // [Function Name]:
170 // _MDrv_CEC_init_riu_base()
171 // [Description]
172 //
173 // [Arguments]:
174 //
175 // [Return]:
176 //
177 //**************************************************************************
_MDrv_CEC_init_riu_base(CEC_RESOURCE_PRIVATE * pCECResourcePrivate)178 void _MDrv_CEC_init_riu_base(CEC_RESOURCE_PRIVATE *pCECResourcePrivate)
179 {
180 MS_VIRT _XCRIUBaseAddress = 0, _PMRIUBaseAddress = 0;
181 MS_PHY u32NonPMBankSize = 0, u32PMBankSize = 0;
182
183 // get MMIO base
184 if(MDrv_MMIO_GetBASE( &_XCRIUBaseAddress, &u32NonPMBankSize, MS_MODULE_XC ) != TRUE)
185 {
186 MDRV_CEC_MSG_FATAL("CEC GetBase failed\n");
187 }
188 else if(MDrv_MMIO_GetBASE( &_PMRIUBaseAddress, &u32PMBankSize, MS_MODULE_PM ) != TRUE)
189 {
190 MDRV_CEC_MSG_FATAL("CEC GetBase failed\n");
191 }
192 else
193 {
194 pCECResourcePrivate->ulXCRiuBaseAddress = _XCRIUBaseAddress;
195 pCECResourcePrivate->ulPMRiuBaseAddress = _PMRIUBaseAddress;
196
197 mhal_CEC_init_riu_base(pCECResourcePrivate->ulXCRiuBaseAddress, pCECResourcePrivate->ulPMRiuBaseAddress);
198
199 pCECResourcePrivate->bRIUAddrReady = TRUE;
200 }
201 }
202
203 //**************************************************************************
204 // [Function Name]:
205 // MDrv_CecRxChkBuf()
206 // [Description]
207 // Driver layer: Use to retrieve CEC message and store into CEC Rx buffer
208 // [Arguments]:
209 //
210 // [Return]:
211 // TRUE: While get the new CEC message
212 // FALSE: No new CEC message
213 //**************************************************************************
_MDrv_CEC_ChkRxBuf(CEC_RESOURCE_PRIVATE * pCECResourcePrivate,MS_BOOL bGetResourceFlag)214 void _MDrv_CEC_ChkRxBuf(CEC_RESOURCE_PRIVATE *pCECResourcePrivate, MS_BOOL bGetResourceFlag) //don't place print message in this function
215 {
216 MS_U8 i;
217 // MS_BOOL ret = FALSE;
218 MS_U8 hashinfo[18];
219 MS_U8 temp1[11];
220 MS_U8 temp2[11];
221 MS_U8 k;
222
223 if(mhal_CEC_IsMessageReceived())
224 {
225 if(bGetResourceFlag)
226 {
227 pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].ucLength = mhal_CEC_ReceivedMessageLen();
228
229 if((pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].ucLength>1) && (pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].ucLength<17)) //1: polling message, 17: over size, not needed to handle
230 {
231 for(i = 0 ; i < pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].ucLength ; i++)
232 {
233 pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].tRxData[i] = mhal_CEC_GetMessageByte(i);
234 }
235 if(pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].tRxData[0] != mhal_CEC_HeaderSwap(pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].tRxData[0]) )
236 {
237 pCECResourcePrivate->bCecMsgCnt++;
238 pCECResourcePrivate->CecFifoIdxE=((++pCECResourcePrivate->CecFifoIdxE)>=CEC_FIFO_NUM_COUNT)? 0 : pCECResourcePrivate->CecFifoIdxE;
239 }
240 else if( pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].tRxData[0] == 0xFF && pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].tRxData[1] == E_MSG_STANDBY)//12.04 Albert-PT
241 {
242 pCECResourcePrivate->bCecMsgCnt++;
243 pCECResourcePrivate->CecFifoIdxE=((++pCECResourcePrivate->CecFifoIdxE)>=CEC_FIFO_NUM_COUNT)? 0 : pCECResourcePrivate->CecFifoIdxE;
244 }
245 else if(pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].tRxData[0] == 0xFF && pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].tRxData[1] == E_MSG_RC_REQUEST_ACTIVE_SOURCE)//2014.4.23 Cindy
246 {
247 pCECResourcePrivate->bCecMsgCnt++;
248 pCECResourcePrivate->CecFifoIdxE=((++pCECResourcePrivate->CecFifoIdxE)>=CEC_FIFO_NUM_COUNT)? 0 : pCECResourcePrivate->CecFifoIdxE;
249 }
250 else if (pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].tRxData[0] == mhal_CEC_HeaderSwap(pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].tRxData[0]))
251 {
252 if((pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].tRxData[1] == 0xA0) &&
253 (pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].tRxData[2] == 0x36) &&
254 (pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].tRxData[3] == 0x97) &&
255 (pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].tRxData[4] == 0x00) )
256 {
257 MDrv_AUTH_GetHashInfo (hashinfo);
258 temp1[0] = 0x00;
259 temp1[1] = hashinfo[0];
260 temp1[2] = hashinfo[1];
261 temp2[0] = 0x01;
262 temp2[1] = hashinfo[0];
263 temp2[2] = hashinfo[1];
264 for(i = 0; i< 8; i++)
265 {
266 temp1[3+i] = hashinfo[2+i];
267 temp2[3+i] = hashinfo[10+i];
268 }
269
270 k = mhal_CEC_SendFramex(0, 0xA0, temp1, 0x0B);
271 k = mhal_CEC_SendFramex(0, 0xA0, temp2, 0x0B);
272 MDRV_CEC_MSG_INFO("mhal_CEC_SendFramex: res = 0x[%x]\n", k);
273 }
274 }
275 }
276 }
277
278 mhal_CEC_ClearRxStatus();
279 }
280
281 #if ENABLE_CEC_MULTIPLE
282 if(mhal_CEC_IsMessageReceived2())
283 {
284 if(bGetResourceFlag)
285 {
286 pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].ucLength = mhal_CEC_ReceivedMessageLen2();
287
288 if((pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].ucLength>1) && (pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].ucLength<17)) //1: polling message, 17: over size, not needed to handle
289 {
290 for(i = 0 ; i < pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].ucLength ; i++)
291 {
292 pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].tRxData[i] = mhal_CEC_GetMessageByte2(i);
293 }
294 if( pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].tRxData[0] != mhal_CEC_HeaderSwap(pCECResourcePrivate->CecRxBufgCECInfo.CecFifoIdxE].tRxData[0]) )
295 {
296 pCECResourcePrivate->bCecMsgCnt++;
297 pCECResourcePrivate->CecFifoIdxE=((++pCECResourcePrivate->CecFifoIdxE)>=CEC_FIFO_NUM_COUNT)? 0 : pCECResourcePrivate->CecFifoIdxE;
298 }
299 else if(pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].tRxData[0] == 0xFF && pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxE].tRxData[1] == E_MSG_STANDBY)
300 {
301 pCECResourcePrivate->bCecMsgCnt++;
302 pCECResourcePrivate->CecFifoIdxE=((++pCECResourcePrivate->CecFifoIdxE)>=CEC_FIFO_NUM_COUNT)? 0 : pCECResourcePrivate->CecFifoIdxE;
303 }
304 }
305 }
306
307 mhal_CEC_ClearRxStatus2();
308 }
309 #endif
310 }
311
312 //**************************************************************************
313 // [Function Name]:
314 // _MDrv_CEC_InitVariable()
315 // [Description]
316 //
317 // [Arguments]:
318 //
319 // [Return]:
320 //
321 //**************************************************************************
322 void _MDrv_CEC_InitVariable(CEC_RESOURCE_PRIVATE *pCECResourcePrivate)
323 {
324 MS_U8 i = 0;
325 MS_U8 j = 0;
326
327 pCECResourcePrivate->bCECIsSource = MDrv_SYS_GetChipType();
328 pCECResourcePrivate->bRIUAddrReady = FALSE;
329 pCECResourcePrivate->CecFifoIdxS = 0;
330 pCECResourcePrivate->CecFifoIdxE = 0;
331 pCECResourcePrivate->bCecMsgCnt = 0;
332 pCECResourcePrivate->bCecInitFinish = FALSE;
333 pCECResourcePrivate->bCecISRAttach = FALSE;
334 pCECResourcePrivate->bAttachDrvISR = TRUE;
335 pCECResourcePrivate->ucRetryCount = RETRY_CNT;
336 pCECResourcePrivate->ucVendorID[0] = 0x00;
337 pCECResourcePrivate->ucVendorID[1] = 0x00;
338 pCECResourcePrivate->ucVendorID[2] = 0x00;
339 pCECResourcePrivate->usPrePowerState = 0;
340
341 if(pCECResourcePrivate->bCECIsSource) // STB series
342 {
343 pCECResourcePrivate->MyLogicalAddress = E_LA_TUNER1; // Tuner
344 pCECResourcePrivate->MyPhysicalAddress[0] = 0x10; //default (1,0,0,0)
345 pCECResourcePrivate->MyPhysicalAddress[1] = 0x00;
346 pCECResourcePrivate->MyDeviceType = E_DEVICE_TYPE_TUNER; //Tuner device
347 }
348 else // TV series
349 {
350 pCECResourcePrivate->MyLogicalAddress = E_LA_TV; //TV
351 pCECResourcePrivate->MyPhysicalAddress[0] = 0x00; //default (0,0,0,0) for TV
352 pCECResourcePrivate->MyPhysicalAddress[1] = 0x00;
353 pCECResourcePrivate->MyDeviceType = E_DEVICE_TYPE_TV; //TV device
354 }
355
356 pCECResourcePrivate->MyPowerStatus = E_MSG_PWRSTA_STANDBY2ON;
357 pCECResourcePrivate->ActiveLogicalAddress = E_LA_TV;
358 pCECResourcePrivate->ActiveDeviceType = E_DEVICE_TYPE_RESERVED;
359 pCECResourcePrivate->ActivePowerStatus = E_MSG_PWRSTA_STANDBY;
360 pCECResourcePrivate->ActivePhysicalAddress[0] = 0x00;
361 pCECResourcePrivate->ActivePhysicalAddress[1] = 0x00;
362 pCECResourcePrivate->ActiveDeviceCECVersion = CEC_VERSION_13a;
363
364 for(i=0;i<CEC_FIFO_NUM_COUNT;i++)
365 {
366 pCECResourcePrivate->CecRxBuf[i].ucLength = 0;
367 for(j=0;j<16;j++)
368 pCECResourcePrivate->CecRxBuf[i].tRxData[j] = 0;
369 }
370 for(i=0;i<15;i++)
371 {
372 pCECResourcePrivate->CecDevicesExisted[i] = FALSE;
373 }
374 }
375
376 //**************************************************************************
377 // [Function Name]:
378 // _MDrv_CEC_SendFrame()
379 // [Description]
380 //
381 // [Arguments]:
382 //
383 // [Return]:
384 //
385 //**************************************************************************
386 static MS_U8 _MDrv_CEC_SendFrame(MS_U8 header, MS_U8 opcode, MS_U8* operand, MS_U8 len)
387 {
388 return (mhal_CEC_SendFrame(header, opcode, operand, len));
389 }
390
391 //******************************************************************************
392 //
393 // [Function Name]:
394 // CecPingApi
395 // [Arguments]:
396 // destination address (range:0x01~0x0E)
397 // [Return]:
398 // CEC_ERROR_CODE
399 //*******************************************************************************
400 CEC_ERROR_CODE _MDrv_CEC_PingApi(MsCEC_DEVICELA addr)
401 {
402 MS_U8 res;
403 CEC_ERROR_CODE error_code = E_CEC_FEATURE_ABORT;
404 MS_U8* Oprend_ptr = NULL;
405
406 if(addr>=0x0f)
407 {
408 error_code = E_CEC_FEATURE_ABORT;
409 return error_code;
410 }
411
412 res = _MDrv_CEC_SendFrame( ((addr<<4)&0xF0) |(addr&0x0F), 0x00, Oprend_ptr, 0);
413 MDRV_CEC_MSG_INFO("_MDrv_CEC_SendFrame: res = %u\n", res);
414
415 if(res&E_CEC_TX_SUCCESS)
416 error_code = E_CEC_TX_SUCCESS;
417 else if(res&E_CEC_RF)
418 error_code = E_CEC_RF;
419 else if(res&E_CEC_LOST_ABT)
420 error_code = E_CEC_LOST_ABT;
421 else if(res&E_CEC_SYSTEM_BUSY)
422 error_code = E_CEC_SYSTEM_BUSY;
423
424 return error_code;
425 }
426
427 //**************************************************************************
428 // [Function Name]:
429 // _MDrv_CEC_FindMyAddress()
430 // [Description]
431 //
432 // [Arguments]:
433 //
434 // [Return]:
435 //
436 //**************************************************************************
437 void _MDrv_CEC_FindMyAddress(CEC_RESOURCE_PRIVATE *pCECResourcePrivate)
438 {
439 MDRV_CEC_MSG_INFO("\r\n CEC Find My address \r\n");
440
441 if(pCECResourcePrivate->bCECIsSource)// STB series
442 {
443 if(_MDrv_CEC_PingApi(E_LA_TUNER1) == E_CEC_RF)
444 {
445 pCECResourcePrivate->MyLogicalAddress = E_LA_TUNER1;
446 }
447 else if(_MDrv_CEC_PingApi(E_LA_TUNER2) == E_CEC_RF)
448 {
449 pCECResourcePrivate->MyLogicalAddress = E_LA_TUNER2;
450 }
451 else if(_MDrv_CEC_PingApi(E_LA_TUNER3) == E_CEC_RF)
452 {
453 pCECResourcePrivate->MyLogicalAddress = E_LA_TUNER3;
454 }
455 else if(_MDrv_CEC_PingApi(E_LA_TUNER4) == E_CEC_RF)
456 {
457 pCECResourcePrivate->MyLogicalAddress = E_LA_TUNER4;
458 }
459 else if(_MDrv_CEC_PingApi(E_LA_FREE_USE) == E_CEC_RF)
460 pCECResourcePrivate->MyLogicalAddress = E_LA_FREE_USE;
461 else
462 pCECResourcePrivate->MyLogicalAddress = E_LA_TUNER1;
463 }
464 else // TV series
465 {
466 if(_MDrv_CEC_PingApi(E_LA_TV) == E_CEC_RF)
467 {
468 pCECResourcePrivate->MyLogicalAddress = E_LA_TV;
469 }
470 else if(_MDrv_CEC_PingApi(E_LA_FREE_USE) == E_CEC_RF)
471 pCECResourcePrivate->MyLogicalAddress = E_LA_FREE_USE;
472 else
473 pCECResourcePrivate->MyLogicalAddress = E_LA_TV;
474 }
475 mhal_CEC_SetMyAddress((MS_U8)pCECResourcePrivate->MyLogicalAddress);
476
477 MDRV_CEC_MSG_INFO("\r\nMy logical address=%x\r\n", pCECResourcePrivate->MyLogicalAddress);
478 }
479
480 //**************************************************************************
481 // [Function Name]:
482 // MDrv_CecCheckExistedDevices()
483 // [Description]
484 // Driver layer: Use to check the existed CEC devices currently
485 // [Arguments]:
486 //
487 // [Return]:
488 //
489 //**************************************************************************
490 void _MDrv_CEC_CheckExistDevices(CEC_RESOURCE_PRIVATE *pCECResourcePrivate)
491 {
492 MS_U8 i, res;
493 MS_U8* Oprend_ptr = NULL;
494
495 MDRV_CEC_MSG_INFO("\r\n Existed CEC device \r\n");
496 for (i=E_LA_TV; i<E_LA_UNREGISTERED; i++)
497 {
498 #if ENABLE_CUST01_CEC
499 if(pCECResourcePrivate->bCECIsSource) // STB series
500 {
501 if(!((i==E_LA_TV) ||(i==E_LA_AUDIO_SYS)) )
502 continue;
503 }
504 else // TV series
505 {
506 if(!((i==E_LA_RECORDER1) || (i==E_LA_TUNER1) || (i==E_LA_PLAYBACK1) || (i==E_LA_AUDIO_SYS) || (i==E_LA_PLAYBACK2) || (i==E_LA_PLYBACK3)))
507 continue;
508 }
509 #endif // #if ENABLE_CUST01_CEC
510
511 MDRV_CEC_MSG_INFO("CEC CheckDev:%u\n",i);
512
513 // Just request a response.
514 res = _MDrv_CEC_SendFrame( ((pCECResourcePrivate->MyLogicalAddress<<4)&0xF0) |(i&0x0F), 0x00, Oprend_ptr, 0);
515 MDRV_CEC_MSG_INFO("_MDrv_CEC_SendFrame: res = %u\n", res);
516
517 if (res&E_CEC_TX_SUCCESS)
518 {
519 pCECResourcePrivate->CecDevicesExisted[i] = TRUE;
520 pCECResourcePrivate->ActiveLogicalAddress = (MsCEC_DEVICELA)i;
521 MDRV_CEC_MSG_INFO("\r\n DEVICE ID= %d \r\n", i);
522 }
523 else
524 {
525 pCECResourcePrivate->CecDevicesExisted[i]= FALSE;
526 }
527 }
528 }
529
530 //**************************************************************************
531 // [Function Name]:
532 // _MDrv_CEC_TxApi()
533 // [Description]
534 // Driver layer: Use to send CEC message
535 // [Arguments]:
536 // dst_address: destination logical address
537 // msg: CEC message
538 // operand_ptr: message parameters
539 // len: parameter length
540 // [Return]:
541 // error_code: return status
542 //**************************************************************************
543 CEC_ERROR_CODE _MDrv_CEC_TxApi(MS_U8 ucInitiatorLA, MsCEC_DEVICELA dst_address, MsCEC_MSGLIST msg, MS_U8* operand_ptr, MS_U8 len)
544 {
545 MS_U8 res, header;
546 CEC_ERROR_CODE error_code = E_CEC_FEATURE_ABORT;
547
548 header = ((ucInitiatorLA<<4)&0xF0)|(dst_address&0x0F);
549
550 res=_MDrv_CEC_SendFrame(header, msg, operand_ptr, len);
551 MDRV_CEC_MSG_INFO("_MDrv_CEC_SendFrame: res = 0x[%x]\n", res);
552
553 if(res&E_CEC_TX_SUCCESS)
554 error_code = E_CEC_TX_SUCCESS;
555 else if(res&E_CEC_RF)
556 error_code = E_CEC_RF;
557 else if(res&E_CEC_LOST_ABT)
558 error_code = E_CEC_LOST_ABT;
559 else if(res&E_CEC_SYSTEM_BUSY)
560 error_code = E_CEC_SYSTEM_BUSY;
561
562 #if ENABLE_CUST01_CEC
563 if( (msg==E_MSG_UI_PRESS) && (error_code==E_CEC_TX_SUCCESS) )
564 {
565 res=_MDrv_CEC_SendFrame(header, E_MSG_UI_RELEASE, operand_ptr, 0);
566 MDRV_CEC_MSG_INFO("_MDrv_CEC_SendFrame: res = %u\n", res);
567
568 if(res&E_CEC_TX_SUCCESS)
569 error_code = E_CEC_TX_SUCCESS;
570 else if(res&E_CEC_RF)
571 error_code = E_CEC_RF;
572 else if(res&E_CEC_LOST_ABT)
573 error_code = E_CEC_LOST_ABT;
574 else if(res&E_CEC_SYSTEM_BUSY)
575 error_code = E_CEC_SYSTEM_BUSY;
576 }
577 #endif
578 return error_code;
579 }
580
581 //**************************************************************************
582 // [Function Name]:
583 // _MDrv_CEC_TxApi2()
584 // [Description]
585 // Driver layer: Use to send CEC message
586 // [Arguments]:
587 // dst_address: destination logical address
588 // msg: CEC message
589 // operand_ptr: message parameters
590 // len: parameter length
591 // [Return]:
592 // error_code: return status
593 //**************************************************************************
594 CEC_ERROR_CODE _MDrv_CEC_TxApi2(MS_U8 ucInitiatorLA, MsCEC_DEVICELA dst_address, MsCEC_MSGLIST msg, MS_U8* operand_ptr, MS_U8 len)
595 {
596 MS_U8 res, header;
597 CEC_ERROR_CODE error_code = E_CEC_FEATURE_ABORT;
598
599 header = ((ucInitiatorLA<<4)&0xF0)|(dst_address&0x0F);
600
601 res =_MDrv_CEC_SendFrame(header, msg, operand_ptr, len);
602 MDRV_CEC_MSG_INFO("_MDrv_CEC_SendFrame: res = 0x[%x]\n", res);
603
604 if(res&E_CEC_TX_SUCCESS)
605 error_code = E_CEC_TX_SUCCESS;
606 else if(res&E_CEC_RF)
607 error_code = E_CEC_RF;
608 else if(res&E_CEC_LOST_ABT)
609 error_code = E_CEC_LOST_ABT;
610 else if(res&E_CEC_SYSTEM_BUSY)
611 error_code = E_CEC_SYSTEM_BUSY;
612
613 return error_code;
614 }
615
616 //#if !CEC_DEVICE_IS_SOURCE// TV series
617 //**************************************************************************
618 // [Function Name]:
619 // _MDrv_CEC_RxIsr()
620 // [Description]
621 //
622 // [Arguments]:
623 //
624 // [Return]:
625 //
626 //**************************************************************************
627 static void _MDrv_CEC_RxIsr(InterruptNum eIntNum)
628 {
629 void* pModule = NULL;
630 void* pCECResource = NULL;
631 MS_BOOL bGetResourceFlag = FALSE;
632 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
633
634 UtopiaModuleGetPtr(MODULE_CEC, &pModule);
635
636 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
637 {
638 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
639 }
640 else
641 {
642 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
643 {
644 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
645 }
646 else
647 {
648 bGetResourceFlag = TRUE;
649 }
650 }
651
652 UNUSED(eIntNum);
653
654 if(ENABLE_CEC_INT)
655 {
656 _MDrv_CEC_ChkRxBuf(pCECResourcePrivate, bGetResourceFlag);
657 }
658
659 UtopiaResourceRelease(pCECResource);
660
661 MsOS_EnableInterrupt(E_INT_IRQ_CEC);
662 }
663 //#endif // TV series
664
665 //**************************************************************************
666 // [Function Name]:
667 // _MDrv_CEC_Init()
668 // [Description]
669 // Driver layer: CEC initiail sequence
670 // [Arguments]:
671 //
672 // [Return]:
673 //
674 //**************************************************************************
675 void _MDrv_CEC_Init(CEC_RESOURCE_PRIVATE *pCECResourcePrivate, MS_U32 u32XTAL_CLK_Hz)
676 {
677 if(pCECResourcePrivate->ucInitialIndex != 0xA5)
678 {
679 _MDrv_CEC_InitVariable(pCECResourcePrivate);
680
681 pCECResourcePrivate->ucInitialIndex = 0xA5;
682 }
683
684 _MDrv_CEC_init_riu_base(pCECResourcePrivate);
685
686 if(pCECResourcePrivate->bRIUAddrReady)
687 {
688 if(!pCECResourcePrivate->bCecInitFinish)
689 {
690 mhal_CEC_Init(u32XTAL_CLK_Hz, pCECResourcePrivate->MyLogicalAddress, pCECResourcePrivate->ucRetryCount);
691
692 pCECResourcePrivate->bCecInitFinish = TRUE;
693 }
694
695 if((!pCECResourcePrivate->bCecISRAttach) && (pCECResourcePrivate->bAttachDrvISR))
696 {
697 //#if !CEC_DEVICE_IS_SOURCE // TV series
698 #if ENABLE_CEC_INT
699 MsOS_AttachInterrupt(E_INT_IRQ_CEC, _MDrv_CEC_RxIsr);
700 MsOS_EnableInterrupt(E_INT_IRQ_CEC);
701 #endif
702 //#endif
703 pCECResourcePrivate->bCecISRAttach = TRUE;
704 }
705
706 pCECResourcePrivate->MyPowerStatus = E_MSG_PWRSTA_ON;
707
708 MDRV_CEC_MSG_INFO("** Complete CEC Initiation!! **\r\n");
709 }
710 }
711
712 //-------------------------------------------------------------------------------------------------
713 // Global Functions
714 //-------------------------------------------------------------------------------------------------
715
716 //**************************************************************************
717 // [Function Name]:
718 // mdrv_CEC_STREventProc()
719 // [Description]
720 //
721 // [Arguments]:
722 //
723 // [Return]:
724 //
725 //**************************************************************************
726 MS_U32 mdrv_CEC_STREventProc(void* pModule, EN_POWER_MODE usPowerState)
727 {
728 void* pCECResource = NULL;
729 MS_U32 ulReturnValue = UTOPIA_STATUS_FAIL;
730 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
731
732 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
733 {
734 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
735 }
736 else
737 {
738 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
739 {
740 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
741 }
742 else
743 {
744 if(pCECResourcePrivate->usPrePowerState != usPowerState)
745 {
746 if(usPowerState == E_POWER_SUSPEND)
747 {
748 ulReturnValue = UTOPIA_STATUS_SUCCESS;
749 }
750 else if(usPowerState == E_POWER_RESUME)
751 {
752 if(pCECResourcePrivate->bRIUAddrReady)
753 {
754 mhal_CEC_Init(pCECResourcePrivate->ulXTAL_CLK_Hz, pCECResourcePrivate->MyLogicalAddress, pCECResourcePrivate->ucRetryCount);
755 }
756
757 ulReturnValue = UTOPIA_STATUS_SUCCESS;
758 }
759
760 pCECResourcePrivate->usPrePowerState = usPowerState;
761 }
762 }
763 }
764
765 UtopiaResourceRelease(pCECResource);
766
767 return ulReturnValue;
768 }
769
770 MS_BOOL MDrv_CEC_DDC2BI_GetInfo(void* pInstance, MS_CEC_INFO_LIST *pInfo)
771 {
772 void* pModule = NULL;
773 void* pCECResource = NULL;
774 MS_BOOL bReturnValue = FALSE;
775 MS_U8 uctemp = 0;
776 MS_U8 ucIndex = 0;
777 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
778
779 UtopiaInstanceGetModule(pInstance, &pModule);
780
781 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
782 {
783 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
784 }
785 else
786 {
787 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
788 {
789 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
790 }
791 else
792 {
793 if(pInfo != NULL)
794 {
795 bReturnValue = TRUE;
796
797 pInfo->ActiveDeviceCECVersion = pCECResourcePrivate->ActiveDeviceCECVersion;
798 pInfo->ActiveDeviceType = pCECResourcePrivate->ActiveDeviceType;
799 pInfo->ActiveLogicalAddress = pCECResourcePrivate->ActiveLogicalAddress;
800 pInfo->ActivePowerStatus = pCECResourcePrivate->ActivePowerStatus;
801 pInfo->bCecMsgCnt = pCECResourcePrivate->bCecMsgCnt;
802 pInfo->CecFifoIdxE = pCECResourcePrivate->CecFifoIdxE;
803 pInfo->CecFifoIdxS = pCECResourcePrivate->CecFifoIdxS;
804 pInfo->fCecInitFinish = pCECResourcePrivate->bCecInitFinish;
805 #if(ENABLE_CEC_MULTIPLE)
806 pInfo->IniLogicalAddress = pCECResourcePrivate->IniLogicalAddress;
807 pInfo->MyDeviceType2 = pCECResourcePrivate->MyDeviceType2;
808 pInfo->MyLogicalAddress2 = pCECResourcePrivate->MyLogicalAddress2;
809
810 #endif
811 pInfo->MyDeviceType = pCECResourcePrivate->MyDeviceType;
812 pInfo->MyLogicalAddress = pCECResourcePrivate->MyLogicalAddress;
813 pInfo->MyPowerStatus = pCECResourcePrivate->MyPowerStatus;
814
815 for(uctemp = 0; uctemp < CEC_DEVICE_EXIST_COUNT; uctemp++)
816 {
817 if(uctemp < CEC_PHY_ADDR_COUNT)
818 {
819 pInfo->ActivePhysicalAddress[uctemp] = pCECResourcePrivate->ActivePhysicalAddress[uctemp];
820 pInfo->MyPhysicalAddress[uctemp] = pCECResourcePrivate->MyPhysicalAddress[uctemp];
821 #if(ENABLE_CEC_MULTIPLE)
822 pInfo->MyPhysicalAddress2[uctemp] = pCECResourcePrivate->MyPhysicalAddress2[uctemp];
823 #endif
824 }
825
826 if(uctemp < CEC_DEVICE_EXIST_COUNT)
827 {
828 pInfo->CecDevicesExisted[uctemp] = pCECResourcePrivate->CecDevicesExisted[uctemp];
829 }
830
831 if(uctemp < CEC_FIFO_NUM_COUNT)
832 {
833 pInfo->CecRxBuf[uctemp].ucLength = pCECResourcePrivate->CecRxBuf[uctemp].ucLength;
834
835 for(ucIndex = 0; ucIndex < CEC_FIFO_DATA_NUMBER; ucIndex++)
836 {
837 pInfo->CecRxBuf[uctemp].tRxData[ucIndex] = pCECResourcePrivate->CecRxBuf[uctemp].tRxData[ucIndex];
838 }
839 }
840 }
841 }
842 }
843 }
844
845 UtopiaResourceRelease(pCECResource);
846
847 return bReturnValue;
848 }
849
850 //**************************************************************************
851 // [Function Name]:
852 // MDrv_CEC_PortSelect()
853 // [Description]
854 // Port Select
855 // [Arguments]:
856 //
857 // [Return]:
858 //
859 //**************************************************************************
860 void MDrv_CEC_PortSelect(void* pInstance, MsCEC_INPUT_PORT InputPort)
861 {
862 mhal_CEC_PortSelect(InputPort);
863 }
864
865 //**************************************************************************
866 // [Function Name]:
867 // MDrv_CecExit()
868 // [Description]
869 // Driver layer: CEC initiail sequence
870 // [Arguments]:
871 //
872 // [Return]:
873 //
874 //*************************************************************************
875 void MDrv_CEC_Exit(void* pInstance)
876 {
877 void* pModule = NULL;
878 void* pCECResource = NULL;
879 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
880
881 UtopiaInstanceGetModule(pInstance, &pModule);
882
883 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
884 {
885 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
886 }
887 else
888 {
889 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
890 {
891 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
892 }
893 else
894 {
895 if((pCECResourcePrivate->bCecISRAttach) && (pCECResourcePrivate->bAttachDrvISR))
896 {
897 // Release CEC
898 MsOS_DetachInterrupt(E_INT_IRQ_CEC);
899 pCECResourcePrivate->bCecISRAttach = FALSE;
900 }
901 }
902 }
903
904 UtopiaResourceRelease(pCECResource);
905
906 // Mask CEC interrupt
907 mhal_CEC_INTEn(FALSE);
908
909 }
910
911 //**************************************************************************
912 // [Function Name]:
913 // MDrv_CecInit()
914 // [Description]
915 // Driver layer: CEC set own logical address
916 // [Arguments]:
917 //
918 // [Return]:
919 //
920 //**************************************************************************
921 void MDrv_CEC_SetMyLogicalAddress(void* pInstance, MsCEC_DEVICELA myLA)
922 {
923 void* pModule = NULL;
924 void* pCECResource = NULL;
925 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
926
927 UtopiaInstanceGetModule(pInstance, &pModule);
928
929 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
930 {
931 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
932 }
933 else
934 {
935 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
936 {
937 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
938 }
939 else
940 {
941 pCECResourcePrivate->MyLogicalAddress = myLA;
942 mhal_CEC_SetMyAddress((MS_U8)myLA);
943 }
944 }
945
946 UtopiaResourceRelease(pCECResource);
947 }
948
949 //**************************************************************************
950 // [Function Name]:
951 // MDrv_CEC_InitChip()
952 // [Description]
953 // Driver layer: CEC initiail chip
954 // [Arguments]:
955 //
956 // [Return]:
957 //
958 //**************************************************************************
959 void MDrv_CEC_InitChip(void* pInstance, MS_U32 u32XTAL_CLK_Hz)
960 {
961 void* pModule = NULL;
962 void* pCECResource = NULL;
963 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
964
965 UtopiaInstanceGetModule(pInstance, &pModule);
966
967 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
968 {
969 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
970 }
971 else
972 {
973 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
974 {
975 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
976 }
977 else
978 {
979 MDRV_CEC_MSG_INFO("** CEC init: MDrv_CEC_InitChip **\n");
980
981 pCECResourcePrivate->ulXTAL_CLK_Hz = u32XTAL_CLK_Hz;
982 _MDrv_CEC_Init(pCECResourcePrivate, pCECResourcePrivate->ulXTAL_CLK_Hz);
983 }
984 }
985
986 UtopiaResourceRelease(pCECResource);
987 }
988
989 //**************************************************************************
990 // [Function Name]:
991 // MDrv_CEC_Init()
992 // [Description]
993 // CEC initial sequence
994 // [Arguments]:
995 //
996 // [Return]:
997 //
998 //**************************************************************************
999 void MDrv_CEC_Init(void* pInstance, MS_U32 u32XTAL_CLK_Hz)
1000 {
1001 void* pModule = NULL;
1002 void* pCECResource = NULL;
1003 MS_BOOL bIsSource = FALSE;
1004 MS_BOOL bDeviceExisted[CEC_DEVICE_EXIST_COUNT] = {0};
1005 MS_U8 ucInitiatorLA = 0;
1006 MS_U8* pPowerStatus = 0;
1007 MsCEC_DEVICELA i;
1008 #if !ENABLE_SW_CEC_WAKEUP
1009 MS_U8 u8PowerOnMode = 0;
1010 #endif
1011 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1012
1013 UtopiaInstanceGetModule(pInstance, &pModule);
1014
1015 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1016 {
1017 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1018 }
1019 else
1020 {
1021 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1022 {
1023 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1024 }
1025 else
1026 {
1027 _MDrv_CEC_Init(pCECResourcePrivate, u32XTAL_CLK_Hz);
1028 _MDrv_CEC_FindMyAddress(pCECResourcePrivate); //logical address for this TV.
1029 _MDrv_CEC_CheckExistDevices(pCECResourcePrivate);
1030
1031 bIsSource = pCECResourcePrivate->bCECIsSource;
1032
1033 #if ENABLE_CEC_MULTIPLE
1034 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
1035 #else
1036 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
1037 #endif
1038 pPowerStatus = (MS_U8*)&(pCECResourcePrivate->MyPowerStatus);
1039
1040 for (i=E_LA_TV; i<E_LA_UNREGISTERED; i++)
1041 {
1042 bDeviceExisted[i] = pCECResourcePrivate->CecDevicesExisted[i];
1043 }
1044 }
1045 }
1046
1047 UtopiaResourceRelease(pCECResource);
1048
1049 // report power status to the active CEC devices
1050 for (i=E_LA_TV; i<E_LA_UNREGISTERED; i++)
1051 {
1052 #if ENABLE_CUST01_CEC
1053 if(bIsSource)
1054 {
1055 if(!((i==E_LA_TV) ||(i==E_LA_AUDIO_SYS)) )
1056 continue;
1057 }
1058 else
1059 {
1060 if(!((i==E_LA_RECORDER1) || (i==E_LA_TUNER1) || (i==E_LA_PLAYBACK1) || (i==E_LA_AUDIO_SYS) || (i==E_LA_PLAYBACK2) || (i==E_LA_PLYBACK3)))
1061 continue;
1062 }
1063 #endif // #if ENABLE_CUST01_CEC
1064 if(bDeviceExisted[i])
1065 {
1066 _MDrv_CEC_TxApi(ucInitiatorLA, i, E_MSG_PS_REPORT_POWER_STATUS, pPowerStatus, 1); // report TV power status
1067 }
1068 }
1069
1070 //some dvd player may send the active source too early,
1071 //so we add here another request active source to get the proper cmd from player
1072 //to get the correct the HDMI port to switch to.
1073 #if !ENABLE_SW_CEC_WAKEUP
1074 mdrv_pm_ctrl_read(CTRL_READ_CMD, CP_READ_POWERON_MODE, 1, &u8PowerOnMode);
1075 if(u8PowerOnMode == M_POWER_ON_BY_HDMI_CEC)
1076 {
1077 MDRV_CEC_MSG_INFO("cec wake up, then req active source\n");
1078 _MDrv_CEC_TxApi(ucInitiatorLA, E_LA_BROADCAST, E_MSG_RC_REQ_ACTIVE_SOURCE, (MS_U8*)E_MSG_FEATURE_ABORT, 0);
1079 }
1080 #endif
1081
1082 }
1083
1084 //**************************************************************************
1085 // [Function Name]:
1086 // MDrv_CecCheckExistedDevices()
1087 // [Description]
1088 // Driver layer: Use to check the existed CEC devices currently
1089 // [Arguments]:
1090 //
1091 // [Return]:
1092 //
1093 //**************************************************************************
1094 void MDrv_CEC_CheckExistDevices(void* pInstance)
1095 {
1096 void* pModule = NULL;
1097 void* pCECResource = NULL;
1098 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1099
1100 UtopiaInstanceGetModule(pInstance, &pModule);
1101
1102 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1103 {
1104 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1105 }
1106 else
1107 {
1108 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1109 {
1110 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1111 }
1112 else
1113 {
1114 _MDrv_CEC_CheckExistDevices(pCECResourcePrivate);
1115 }
1116 }
1117
1118 UtopiaResourceRelease(pCECResource);
1119 }
1120
1121 //-------------------------------------------------------------------------------------------------
1122 // Local Functions
1123 //-------------------------------------------------------------------------------------------------
1124
1125 //**************************************************************************
1126 // [Function Name]:
1127 // MDrv_CEC_NextDevice()
1128 // [Description]
1129 // Set logical address to next active device
1130 // [Arguments]:
1131 //
1132 // [Return]:
1133 // Next CEC active device's logical address
1134 //**************************************************************************
1135 MsCEC_DEVICELA MDrv_CEC_NextDevice(void* pInstance)
1136 {
1137 void* pModule = NULL;
1138 void* pCECResource = NULL;
1139 MS_U8 uctemp = 0;
1140 MsCEC_DEVICELA eReturnValue = E_LA_UNREGISTERED;
1141 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1142
1143 UtopiaInstanceGetModule(pInstance, &pModule);
1144
1145 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1146 {
1147 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1148 }
1149 else
1150 {
1151 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1152 {
1153 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1154 }
1155 else
1156 {
1157 _MDrv_CEC_CheckExistDevices(pCECResourcePrivate);
1158
1159 eReturnValue = pCECResourcePrivate->ActiveLogicalAddress;
1160
1161 for(uctemp = (pCECResourcePrivate->ActiveLogicalAddress +1); uctemp < E_LA_UNREGISTERED; uctemp++)
1162 {
1163 if(pCECResourcePrivate->CecDevicesExisted[uctemp] && (uctemp != E_LA_TV) && (uctemp != E_LA_FREE_USE))
1164 {
1165 eReturnValue = (MsCEC_DEVICELA)uctemp;
1166 }
1167 }
1168 }
1169 }
1170
1171 UtopiaResourceRelease(pCECResource);
1172
1173 return eReturnValue;
1174 }
1175
1176 //**************************************************************************
1177 // [Function Name]:
1178 // MDrv_CecRxChkBuf()
1179 // [Description]
1180 // Driver layer: Use to retrieve CEC message and store into CEC Rx buffer
1181 // [Arguments]:
1182 //
1183 // [Return]:
1184 // TRUE: While get the new CEC message
1185 // FALSE: No new CEC message
1186 //**************************************************************************
1187 void MDrv_CEC_ChkRxBuf(void* pInstance) //don't place print message in this function
1188 {
1189 void* pModule = NULL;
1190 void* pCECResource = NULL;
1191 MS_BOOL bGetResourceFlag = FALSE;
1192 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1193
1194 UtopiaInstanceGetModule(pInstance, &pModule);
1195
1196 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1197 {
1198 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1199 }
1200 else
1201 {
1202 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1203 {
1204 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1205 }
1206 else
1207 {
1208 bGetResourceFlag = TRUE;
1209 }
1210 }
1211
1212 _MDrv_CEC_ChkRxBuf(pCECResourcePrivate, bGetResourceFlag);
1213
1214 UtopiaResourceRelease(pCECResource);
1215 }
1216
1217 //**************************************************************************
1218 // [Function Name]:
1219 // MDrv_CEC_TxSendMsg()
1220 // [Description]
1221 // Use to send any CEC message by user defined
1222 // [Arguments]:
1223 // dst_address: destination logical address
1224 // msg: CEC message
1225 // cmd: message parameters
1226 // len: parameter length
1227 // [Return]:
1228 // error_code: return status
1229 //**************************************************************************
1230 CEC_ERROR_CODE MDrv_CEC_TxSendMsg(void* pInstance, MsCEC_DEVICELA dst_address, MsCEC_MSGLIST msg, MS_U8 *cmd, MS_U8 len)
1231 {
1232 void* pModule = NULL;
1233 void* pCECResource = NULL;
1234 MS_U8 ucInitiatorLA = 0;
1235 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
1236 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1237
1238 UtopiaInstanceGetModule(pInstance, &pModule);
1239
1240 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1241 {
1242 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1243 }
1244 else
1245 {
1246 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1247 {
1248 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1249 }
1250 else
1251 {
1252
1253 #if ENABLE_CEC_MULTIPLE
1254 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
1255 #else
1256 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
1257 #endif
1258 }
1259 }
1260
1261 UtopiaResourceRelease(pCECResource);
1262
1263 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, msg, cmd, len);
1264
1265 return res;
1266 }
1267
1268 //**************************************************************************
1269 // [Function Name]:
1270 // MApi_CEC_TxSendMsg2()
1271 // [Description]
1272 // Use to send any CEC message by user defined
1273 // [Arguments]:
1274 // dst_address: destination logical address
1275 // msg: CEC message
1276 // cmd: message parameters
1277 // len: parameter length
1278 // [Return]:
1279 // error_code: return status
1280 //**************************************************************************
1281 CEC_ERROR_CODE MDrv_CEC_TxSendMsg2(void* pInstance, MsCEC_DEVICELA dst_address, MsCEC_MSGLIST msg, MS_U8* cmd, MS_U8 len)
1282 {
1283 void* pModule = NULL;
1284 void* pCECResource = NULL;
1285 MS_U8 ucInitiatorLA = 0;
1286 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
1287 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1288
1289 UtopiaInstanceGetModule(pInstance, &pModule);
1290
1291 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1292 {
1293 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1294 }
1295 else
1296 {
1297 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1298 {
1299 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1300 }
1301 else
1302 {
1303 #if ENABLE_CEC_MULTIPLE
1304 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
1305 #else
1306 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
1307 #endif
1308 }
1309 }
1310
1311 UtopiaResourceRelease(pCECResource);
1312
1313 res = _MDrv_CEC_TxApi2(ucInitiatorLA, dst_address, msg, cmd, len);
1314
1315 return res;
1316 }
1317 //**************************************************************************
1318 // [Function Name]:
1319 // MDrv_CecTxSendPollingMsg()
1320 // [Description]
1321 // Use to send any CEC polling msg by user defined
1322 // [Arguments]:
1323 // dst_address: destination logical address
1324 // [Return]:
1325 // error_code: return status
1326 //**************************************************************************
1327 CEC_ERROR_CODE MDrv_CecTxSendPollingMsg(void* pInstance, MsCEC_DEVICELA dst_address)
1328 {
1329 void* pModule = NULL;
1330 void* pCECResource = NULL;
1331 MS_U8 ucInitiatorLA = 0;
1332 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
1333 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1334
1335 UtopiaInstanceGetModule(pInstance, &pModule);
1336
1337 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1338 {
1339 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1340 }
1341 else
1342 {
1343 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1344 {
1345 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1346 }
1347 else
1348 {
1349 #if ENABLE_CEC_MULTIPLE
1350 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
1351 #else
1352 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
1353 #endif
1354 }
1355 }
1356
1357 UtopiaResourceRelease(pCECResource);
1358
1359 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, (MsCEC_MSGLIST)0x00, NULL, 0x00);
1360
1361 return res;
1362 }
1363
1364 //**************************************************************************
1365 // [Function Name]:
1366 // MDrv_CEC_Msg_ActiveSource()
1367 // [Description]
1368 // Used by a new source to indicate that it has started to transmit a stream or
1369 // used in response to a <Request Active Source>
1370 // [Message property]
1371 // Address: Broadcast
1372 // Initiator: All sources
1373 // Follower: TV, CEC Switches
1374 // [Arguments]:
1375 //
1376 // [Return]:
1377 // error_code: return status
1378 //**************************************************************************
1379 CEC_ERROR_CODE MDrv_CEC_Msg_ActiveSource(void* pInstance)
1380 {
1381 void* pModule = NULL;
1382 void* pCECResource = NULL;
1383 MS_U8 txbuf[2] = {0};
1384 MS_U8 ucInitiatorLA = 0;
1385 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
1386 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1387
1388 UtopiaInstanceGetModule(pInstance, &pModule);
1389
1390 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1391 {
1392 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1393 }
1394 else
1395 {
1396 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1397 {
1398 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1399 }
1400 else
1401 {
1402 #if ENABLE_CEC_MULTIPLE
1403 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
1404 #else
1405 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
1406 #endif
1407 txbuf[0] = pCECResourcePrivate->MyPhysicalAddress[0];
1408 txbuf[1] = pCECResourcePrivate->MyPhysicalAddress[1];
1409 }
1410 }
1411
1412 UtopiaResourceRelease(pCECResource);
1413
1414 res = _MDrv_CEC_TxApi(ucInitiatorLA, E_LA_BROADCAST, E_MSG_ACTIVE_SOURCE, txbuf, 2);
1415
1416 return res;
1417 }
1418
1419 //**************************************************************************
1420 // [Function Name]:
1421 // MDrv_CEC_Msg_RoutingChange()
1422 // [Description]
1423 // Used by a CEC switch when it's manually switched to inform akk other devices.
1424 // [Message property]
1425 // Address: Broadcast
1426 // Initiator: CEC switches and TV(with 2 or more HDMI inputs)
1427 // Follower: CEC switches
1428 // [Arguments]:
1429 // orig_address: The original physicall address
1430 // new_address: The new physical address
1431 // [Return]:
1432 // error_code: return status
1433 //**************************************************************************
1434 CEC_ERROR_CODE MDrv_CEC_Msg_RoutingChange(void* pInstance, MS_U8* orig_address, MS_U8* new_address)
1435 {
1436 void* pModule = NULL;
1437 void* pCECResource = NULL;
1438 MS_U8 txbuf[4] = {0};
1439 MS_U8 ucInitiatorLA = 0;
1440 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
1441 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1442
1443 UtopiaInstanceGetModule(pInstance, &pModule);
1444
1445 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1446 {
1447 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1448 }
1449 else
1450 {
1451 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1452 {
1453 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1454 }
1455 else
1456 {
1457 #if ENABLE_CEC_MULTIPLE
1458 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
1459 #else
1460 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
1461 #endif
1462 txbuf[0] = orig_address[0];
1463 txbuf[1] = orig_address[1];
1464 txbuf[2] = new_address[0];
1465 txbuf[3] = new_address[1];
1466 }
1467 }
1468
1469 UtopiaResourceRelease(pCECResource);
1470
1471 res = _MDrv_CEC_TxApi(ucInitiatorLA, E_LA_BROADCAST, E_MSG_RC_ROUTING_CHANGE, txbuf, 4);
1472
1473 return res;
1474 }
1475
1476 //**************************************************************************
1477 // [Function Name]:
1478 // MDrv_CEC_Msg_ReqActiveSource()
1479 // [Description]
1480 // Used by a new device to discover the status of the system.
1481 // [Message property]
1482 // Address: Broadcast
1483 // Initiator:
1484 // Follower: All, except for CEC Switches and devices which cannot become a source.
1485 // [Arguments]:
1486 //
1487 // [Return]:
1488 // error_code: return status
1489 //**************************************************************************
1490 CEC_ERROR_CODE MDrv_CEC_Msg_ReqActiveSource(void* pInstance)
1491 {
1492 void* pModule = NULL;
1493 void* pCECResource = NULL;
1494 MS_U8 ucInitiatorLA = 0;
1495 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
1496 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1497
1498 UtopiaInstanceGetModule(pInstance, &pModule);
1499
1500 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1501 {
1502 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1503 }
1504 else
1505 {
1506 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1507 {
1508 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1509 }
1510 else
1511 {
1512 #if ENABLE_CEC_MULTIPLE
1513 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
1514 #else
1515 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
1516 #endif
1517 }
1518 }
1519
1520 UtopiaResourceRelease(pCECResource);
1521
1522 res = _MDrv_CEC_TxApi(ucInitiatorLA, E_LA_BROADCAST, E_MSG_RC_REQ_ACTIVE_SOURCE, (MS_U8*)E_MSG_FEATURE_ABORT, 0);
1523 return res;
1524 }
1525
1526 //**************************************************************************
1527 // [Function Name]:
1528 // MDrv_CEC_Msg_SetStreamPath()
1529 // [Description]
1530 // Used by the TV to request a streaming path from the specified physical address.
1531 // [Message property]
1532 // Address: Broadcast
1533 // Initiator:
1534 // Follower: CEC Switches
1535 // [Arguments]:
1536 // new_address: The new physical address
1537 // [Return]:
1538 // error_code: return status
1539 //**************************************************************************
1540 CEC_ERROR_CODE MDrv_CEC_Msg_SetStreamPath(void* pInstance, MS_U8* new_address)
1541 {
1542 void* pModule = NULL;
1543 void* pCECResource = NULL;
1544 MS_U8 txbuf[2] = {0};
1545 MS_U8 ucInitiatorLA = 0;
1546 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
1547 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1548
1549 UtopiaInstanceGetModule(pInstance, &pModule);
1550
1551 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1552 {
1553 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1554 }
1555 else
1556 {
1557 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1558 {
1559 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1560 }
1561 else
1562 {
1563 #if ENABLE_CEC_MULTIPLE
1564 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
1565 #else
1566 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
1567 #endif
1568 txbuf[0] = new_address[0];
1569 txbuf[1] = new_address[1];
1570 }
1571 }
1572
1573 UtopiaResourceRelease(pCECResource);
1574
1575 res = _MDrv_CEC_TxApi(ucInitiatorLA, E_LA_BROADCAST, E_MSG_RC_SET_STREM_PATH, txbuf, 2);
1576
1577 return res;
1578 }
1579
1580 //**************************************************************************
1581 // [Function Name]:
1582 // MDrv_CEC_Msg_Standby()
1583 // [Description]
1584 // Use to switch one or all devices into standby mode.
1585 // One device: it's specific logical address, like "E_LA_RECORDER1"
1586 // All device: Use broadcast logical address, "E_LA_BROADCAST"
1587 // [Message property]
1588 // Address: Directly / Broadcast
1589 // Initiator: TV(Broadcast Address)
1590 // Follower: All
1591 // [Arguments]:
1592 // dst_address: destination logical address
1593 // [Return]:
1594 // error_code: return status
1595 //**************************************************************************
1596 CEC_ERROR_CODE MDrv_CEC_Msg_Standby(void* pInstance, MsCEC_DEVICELA dst_address)
1597 {
1598 void* pModule = NULL;
1599 void* pCECResource = NULL;
1600 MS_U8 ucInitiatorLA = 0;
1601 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
1602 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1603
1604 UtopiaInstanceGetModule(pInstance, &pModule);
1605
1606 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1607 {
1608 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1609 }
1610 else
1611 {
1612 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1613 {
1614 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1615 }
1616 else
1617 {
1618 #if ENABLE_CEC_MULTIPLE
1619 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
1620 #else
1621 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
1622 #endif
1623 pCECResourcePrivate->MyPowerStatus = E_MSG_PWRSTA_STANDBY;
1624 }
1625 }
1626
1627 UtopiaResourceRelease(pCECResource);
1628
1629 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_STANDBY, (MS_U8*)E_MSG_FEATURE_ABORT, 0);
1630 return res;
1631 }
1632
1633 //**************************************************************************
1634 // [Function Name]:
1635 // MDrv_CEC_Msg_RecordOff()
1636 // [Description]
1637 // Requests a device to stop a recording.
1638 // [Message property]
1639 // Address: Directly
1640 // Initiator: Device Initiating a recording
1641 // Follower: Recording Device if implementing <Record On>
1642 // [Arguments]:
1643 // dst_address: destination logical address
1644 // [Return]:
1645 // error_code: return status
1646 //**************************************************************************
1647 CEC_ERROR_CODE MDrv_CEC_Msg_RecordOff(void* pInstance, MsCEC_DEVICELA dst_address)
1648 {
1649 void* pModule = NULL;
1650 void* pCECResource = NULL;
1651 MS_U8 ucInitiatorLA = 0;
1652 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
1653 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1654
1655 UtopiaInstanceGetModule(pInstance, &pModule);
1656
1657 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1658 {
1659 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1660 }
1661 else
1662 {
1663 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1664 {
1665 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1666 }
1667 else
1668 {
1669 #if ENABLE_CEC_MULTIPLE
1670 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
1671 #else
1672 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
1673 #endif
1674 }
1675 }
1676
1677 UtopiaResourceRelease(pCECResource);
1678
1679 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_OTR_RECORD_OFF, (MS_U8*)E_MSG_FEATURE_ABORT, 0);
1680
1681 return res;
1682 }
1683
1684 //**************************************************************************
1685 // [Function Name]:
1686 // MDrv_CEC_Msg_RecordOn()
1687 // [Description]
1688 // Attempt to record the specified source.
1689 // [Message property]
1690 // Address: Directly
1691 // Initiator:
1692 // Follower:
1693 // [Arguments]:
1694 // dst_address: destination logical address
1695 // [Return]:
1696 // error_code: return status
1697 //**************************************************************************
1698 CEC_ERROR_CODE MDrv_CEC_Msg_RecordOn(void* pInstance, MsCEC_DEVICELA dst_address, MsCEC_MSG_RECORD_SOURCE_TYPE cmd)
1699 {
1700 void* pModule = NULL;
1701 void* pCECResource = NULL;
1702 MS_U8 ucInitiatorLA = 0;
1703 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
1704 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1705
1706 UtopiaInstanceGetModule(pInstance, &pModule);
1707
1708 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1709 {
1710 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1711 }
1712 else
1713 {
1714 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1715 {
1716 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1717 }
1718 else
1719 {
1720 #if ENABLE_CEC_MULTIPLE
1721 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
1722 #else
1723 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
1724 #endif
1725 }
1726 }
1727
1728 UtopiaResourceRelease(pCECResource);
1729 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_OTR_RECORD_ON, (MS_U8*)&cmd, 1);
1730
1731 return res;
1732 }
1733
1734
1735 //**************************************************************************
1736 // [Function Name]:
1737 // MDrv_CEC_Msg_ReportCECVersion()
1738 // [Description]
1739 // Used to indicate the supported CEC version, in response to a <Get CEC Version>
1740 // [Message property]
1741 // Address: Directly
1742 // Initiator: All
1743 // Follower: All
1744 // [Arguments]:
1745 // dst_address: destination logical address
1746 // version: CEC version
1747 // [Return]:
1748 // error_code: return status
1749 //**************************************************************************
1750 CEC_ERROR_CODE MDrv_CEC_Msg_ReportCECVersion(void* pInstance, MsCEC_DEVICELA dst_address, MS_U8 version)
1751 {
1752 void* pModule = NULL;
1753 void* pCECResource = NULL;
1754 MS_U8 ucInitiatorLA = 0;
1755 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
1756 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1757
1758 UtopiaInstanceGetModule(pInstance, &pModule);
1759
1760 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1761 {
1762 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1763 }
1764 else
1765 {
1766 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1767 {
1768 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1769 }
1770 else
1771 {
1772 #if ENABLE_CEC_MULTIPLE
1773 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
1774 #else
1775 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
1776 #endif
1777 }
1778 }
1779
1780 UtopiaResourceRelease(pCECResource);
1781
1782 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_SI_CEC_VERSION, &version, 1);
1783 return res;
1784 }
1785
1786 //**************************************************************************
1787 // [Function Name]:
1788 // MDrv_CEC_Msg_ReqCECVersion()
1789 // [Description]
1790 // Used by a device to enquire which version of CEC the target supports
1791 // [Message property]
1792 // Address: Directly
1793 // Initiator: All
1794 // Follower: All
1795 // [Arguments]:
1796 // dst_address: destination logical address
1797 // [Return]:
1798 // error_code: return status
1799 //**************************************************************************
1800 CEC_ERROR_CODE MDrv_CEC_Msg_ReqCECVersion(void* pInstance, MsCEC_DEVICELA dst_address)
1801 {
1802 void* pModule = NULL;
1803 void* pCECResource = NULL;
1804 MS_U8 ucInitiatorLA = 0;
1805 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
1806 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1807
1808 UtopiaInstanceGetModule(pInstance, &pModule);
1809
1810 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1811 {
1812 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1813 }
1814 else
1815 {
1816 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1817 {
1818 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1819 }
1820 else
1821 {
1822 #if ENABLE_CEC_MULTIPLE
1823 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
1824 #else
1825 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
1826 #endif
1827 }
1828 }
1829
1830 UtopiaResourceRelease(pCECResource);
1831
1832 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_SI_GET_CEC_VERSION, (MS_U8*)E_MSG_FEATURE_ABORT, 0);
1833
1834 return res;
1835 }
1836
1837 //**************************************************************************
1838 // [Function Name]:
1839 // MDrv_CEC_Msg_ReportPhycalAddress()
1840 // [Description]
1841 // Use to inform all other devices of the mapping between physical and logical address of the initiator
1842 // [Message property]
1843 // Address: Broadcast
1844 // Initiator: All
1845 // Follower: TV
1846 // [Arguments]:
1847 //
1848 // [Return]:
1849 // error_code: return status
1850 //**************************************************************************
1851 CEC_ERROR_CODE MDrv_CEC_Msg_ReportPhycalAddress(void* pInstance)
1852 {
1853 void* pModule = NULL;
1854 void* pCECResource = NULL;
1855 MS_U8 ucInitiatorLA = 0;
1856 MS_U8 txbuf[3] = {0};
1857 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
1858 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1859
1860 UtopiaInstanceGetModule(pInstance, &pModule);
1861
1862 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1863 {
1864 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1865 }
1866 else
1867 {
1868 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1869 {
1870 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1871 }
1872 else
1873 {
1874 #if ENABLE_CEC_MULTIPLE
1875 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
1876 #else
1877 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
1878 #endif
1879 txbuf[0] = pCECResourcePrivate->MyPhysicalAddress[0];
1880 txbuf[1] = pCECResourcePrivate->MyPhysicalAddress[1];
1881 txbuf[2] = pCECResourcePrivate->MyDeviceType;
1882 }
1883 }
1884
1885 UtopiaResourceRelease(pCECResource);
1886
1887 res = _MDrv_CEC_TxApi(ucInitiatorLA, E_LA_BROADCAST, E_MSG_SI_REPORT_PHY_ADDR, txbuf, 3);
1888 return res;
1889 }
1890
1891 //**************************************************************************
1892 // [Function Name]:
1893 // MDrv_CEC_Msg_ReqPhycalAddress()
1894 // [Description]
1895 // A request to a device to return its physical address
1896 // [Message property]
1897 // Address: Directly
1898 // Initiator:
1899 // Follower: All, except for CEC Switches using logical address 15
1900 // [Arguments]:
1901 // dst_address: destination logical address
1902 // [Return]:
1903 // error_code: return status
1904 //**************************************************************************
1905 CEC_ERROR_CODE MDrv_CEC_Msg_ReqPhycalAddress(void* pInstance, MsCEC_DEVICELA dst_address)
1906 {
1907 void* pModule = NULL;
1908 void* pCECResource = NULL;
1909 MS_U8 ucInitiatorLA = 0;
1910 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
1911 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1912
1913 UtopiaInstanceGetModule(pInstance, &pModule);
1914
1915 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1916 {
1917 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1918 }
1919 else
1920 {
1921 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1922 {
1923 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1924 }
1925 else
1926 {
1927 #if ENABLE_CEC_MULTIPLE
1928 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
1929 #else
1930 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
1931 #endif
1932 }
1933 }
1934
1935 UtopiaResourceRelease(pCECResource);
1936
1937 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_SI_REQUEST_PHY_ADDR, (MS_U8*)E_MSG_FEATURE_ABORT, 0);
1938
1939 return res;
1940 }
1941
1942 //**************************************************************************
1943 // [Function Name]:
1944 // MDrv_CEC_Msg_DeckControl()
1945 // [Description]
1946 // Use to control a device's media functions
1947 // [Message property]
1948 // Address: Directly
1949 // Initiator:
1950 // Follower:
1951 // [Arguments]:
1952 // dst_address: destination logical address
1953 // cmd: deck control mode
1954 // [Return]:
1955 // error_code: return status
1956 //**************************************************************************
1957 CEC_ERROR_CODE MDrv_CEC_Msg_DeckControl(void* pInstance, MsCEC_DEVICELA dst_address, MsCEC_MSG_DC_DECK_CTRL_PARM cmd)
1958 {
1959 void* pModule = NULL;
1960 void* pCECResource = NULL;
1961 MS_U8 ucInitiatorLA = 0;
1962 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
1963 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
1964
1965 UtopiaInstanceGetModule(pInstance, &pModule);
1966
1967 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
1968 {
1969 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
1970 }
1971 else
1972 {
1973 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
1974 {
1975 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
1976 }
1977 else
1978 {
1979 #if ENABLE_CEC_MULTIPLE
1980 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
1981 #else
1982 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
1983 #endif
1984 }
1985 }
1986
1987 UtopiaResourceRelease(pCECResource);
1988
1989 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_DC_DECK_CTRL, (MS_U8*)&cmd, 1);
1990 return res;
1991 }
1992
1993 //**************************************************************************
1994 // [Function Name]:
1995 // MDrv_CEC_Msg_DecStatus()
1996 // [Description]
1997 // Use to provide a device's status when received "Give Deck Status"
1998 // [Message property]
1999 // Address: Directly
2000 // Initiator:
2001 // Follower:
2002 // [Arguments]:
2003 // dst_address: destination logical address
2004 // cmd: deck info mode
2005 // [Return]:
2006 // error_code: return status
2007 //**************************************************************************
2008 CEC_ERROR_CODE MDrv_CEC_Msg_DecStatus(void* pInstance, MsCEC_DEVICELA dst_address, MsCEC_MSG_DC_DECK_STATUS_PARM cmd)
2009 {
2010 void* pModule = NULL;
2011 void* pCECResource = NULL;
2012 MS_U8 ucInitiatorLA = 0;
2013 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
2014 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2015
2016 UtopiaInstanceGetModule(pInstance, &pModule);
2017
2018 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2019 {
2020 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2021 }
2022 else
2023 {
2024 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2025 {
2026 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2027 }
2028 else
2029 {
2030 #if ENABLE_CEC_MULTIPLE
2031 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
2032 #else
2033 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
2034 #endif
2035 }
2036 }
2037
2038 UtopiaResourceRelease(pCECResource);
2039
2040 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_DC_DECK_STATUS, (MS_U8*)&cmd, 1);
2041
2042 return res;
2043 }
2044
2045 //**************************************************************************
2046 // [Function Name]:
2047 // MDrv_CEC_MSg_GiveDeckStatus()
2048 // [Description]
2049 // Use to request device's status
2050 // [Message property]
2051 // Address: Directly
2052 // Initiator:
2053 // Follower:
2054 // [Arguments]:
2055 // dst_address: destination logical address
2056 // cmd: status request mode
2057 // [Return]:
2058 // error_code: return status
2059 //**************************************************************************
2060 CEC_ERROR_CODE MDrv_CEC_MSg_GiveDeckStatus(void* pInstance, MsCEC_DEVICELA dst_address, MsCEC_MSG_STATUS_REQUEST_PARM cmd)
2061 {
2062 void* pModule = NULL;
2063 void* pCECResource = NULL;
2064 MS_U8 ucInitiatorLA = 0;
2065 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
2066 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2067
2068 UtopiaInstanceGetModule(pInstance, &pModule);
2069
2070 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2071 {
2072 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2073 }
2074 else
2075 {
2076 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2077 {
2078 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2079 }
2080 else
2081 {
2082 #if ENABLE_CEC_MULTIPLE
2083 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
2084 #else
2085 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
2086 #endif
2087 }
2088 }
2089
2090 UtopiaResourceRelease(pCECResource);
2091
2092 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_DC_GIVE_DECK_STATUS, (MS_U8*)&cmd, 1);
2093 return res;
2094 }
2095
2096 //**************************************************************************
2097 // [Function Name]:
2098 // MDrv_CEC_MSg_DCPlay()
2099 // [Description]
2100 // Use to control the playback behaviour of a source device
2101 // [Message property]
2102 // Address: Directly
2103 // Initiator:
2104 // Follower:
2105 // [Arguments]:
2106 // dst_address: destination logical address
2107 // cmd: play mode
2108 // [Return]:
2109 // error_code: return status
2110 //**************************************************************************
2111 CEC_ERROR_CODE MDrv_CEC_MSg_DCPlay(void* pInstance, MsCEC_DEVICELA dst_address, MsCEC_MSG_DC_PLAY_PARM cmd)
2112 {
2113 void* pModule = NULL;
2114 void* pCECResource = NULL;
2115 MS_U8 ucInitiatorLA = 0;
2116 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
2117 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2118
2119 UtopiaInstanceGetModule(pInstance, &pModule);
2120
2121 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2122 {
2123 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2124 }
2125 else
2126 {
2127 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2128 {
2129 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2130 }
2131 else
2132 {
2133 #if ENABLE_CEC_MULTIPLE
2134 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
2135 #else
2136 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
2137 #endif
2138 }
2139 }
2140
2141 UtopiaResourceRelease(pCECResource);
2142
2143 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_DC_PLAY, (MS_U8*)&cmd, 1);
2144
2145 return res;
2146 }
2147
2148 //**************************************************************************
2149 // [Function Name]:
2150 // MDrv_CEC_Msg_ReqMenuStatus()
2151 // [Description]
2152 // Request from TV for a device to show/remove a menu or to query status
2153 // [Message property]
2154 // Address: Directly
2155 // Initiator:
2156 // Follower:
2157 // [Arguments]:
2158 // dst_address: destination logical address
2159 // cmd: menu request type
2160 // [Return]:
2161 // error_code: return status
2162 //**************************************************************************
2163 CEC_ERROR_CODE MDrv_CEC_Msg_ReqMenuStatus(void* pInstance, MsCEC_DEVICELA dst_address, MsCEC_MSG_MENU_REQ_TYPE cmd)
2164 {
2165 void* pModule = NULL;
2166 void* pCECResource = NULL;
2167 MS_U8 ucInitiatorLA = 0;
2168 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
2169 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2170
2171 UtopiaInstanceGetModule(pInstance, &pModule);
2172
2173 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2174 {
2175 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2176 }
2177 else
2178 {
2179 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2180 {
2181 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2182 }
2183 else
2184 {
2185 #if ENABLE_CEC_MULTIPLE
2186 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
2187 #else
2188 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
2189 #endif
2190 }
2191 }
2192
2193 UtopiaResourceRelease(pCECResource);
2194
2195 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_DMC_MENU_REQUEST, (MS_U8*)&cmd, 1);
2196
2197 return res;
2198 }
2199
2200 //**************************************************************************
2201 // [Function Name]:
2202 // MDrv_CEC_Msg_UserCtrlPressed()
2203 // [Description]
2204 // Use to indicated that user pressed which control button
2205 // [Message property]
2206 // Address: Directly
2207 // Initiator:
2208 // Follower:
2209 // [Arguments]:
2210 // dst_address: destination logical address
2211 // cmd: UI command
2212 // [Return]:
2213 // error_code: return status
2214 //**************************************************************************
2215 CEC_ERROR_CODE MDrv_CEC_Msg_UserCtrlPressed(void* pInstance, MS_BOOL bUserCtrlEn, MsCEC_DEVICELA dst_address, MsCEC_MSG_USER_CTRL_PARM cmd)
2216 {
2217 void* pModule = NULL;
2218 void* pCECResource = NULL;
2219 MS_U8 ucInitiatorLA = 0;
2220 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
2221 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2222
2223 UtopiaInstanceGetModule(pInstance, &pModule);
2224
2225 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2226 {
2227 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2228 }
2229 else
2230 {
2231 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2232 {
2233 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2234 }
2235 else
2236 {
2237 #if ENABLE_CEC_MULTIPLE
2238 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
2239 #else
2240 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
2241 #endif
2242 }
2243 }
2244
2245 UtopiaResourceRelease(pCECResource);
2246
2247 if(bUserCtrlEn) // menu status is activated
2248 {
2249 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_UI_PRESS, (MS_U8*)&cmd, 1);
2250 }
2251 else // if menu status ia deactivated, send request to active device
2252 {
2253 //res = MApi_CEC_Msg_ReqMenuStatus(dst_address, E_MSG_MENU_REQ_ACTIVATED);
2254 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_DMC_MENU_REQUEST, E_MSG_MENU_REQ_ACTIVATED, 1);
2255 }
2256
2257 return res;
2258 }
2259
2260 //**************************************************************************
2261 // [Function Name]:
2262 // MDrv_CEC_Msg_UserCtrlReleased()
2263 // [Description]
2264 // Use to indicated that user released which control button
2265 // [Message property]
2266 // Address: Directly
2267 // Initiator:
2268 // Follower:
2269 // [Arguments]:
2270 // dst_address: destination logical address
2271 // [Return]:
2272 // error_code: return status
2273 //**************************************************************************
2274 CEC_ERROR_CODE MDrv_CEC_Msg_UserCtrlReleased(void* pInstance, MsCEC_DEVICELA dst_address)
2275 {
2276 void* pModule = NULL;
2277 void* pCECResource = NULL;
2278 MS_U8 ucInitiatorLA = 0;
2279 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
2280 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2281
2282 UtopiaInstanceGetModule(pInstance, &pModule);
2283
2284 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2285 {
2286 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2287 }
2288 else
2289 {
2290 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2291 {
2292 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2293 }
2294 else
2295 {
2296
2297 #if ENABLE_CEC_MULTIPLE
2298 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
2299 #else
2300 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
2301 #endif
2302 }
2303 }
2304
2305 UtopiaResourceRelease(pCECResource);
2306
2307 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_UI_RELEASE, (MS_U8*)E_MSG_FEATURE_ABORT, 0);
2308
2309 return res;
2310 }
2311
2312 //**************************************************************************
2313 // [Function Name]:
2314 // MDrv_CEC_Msg_GiveAudioStatus()
2315 // [Description]
2316 // Use to request an Amplifier to send its volume and mute status
2317 // [Message property]
2318 // Address: Directly
2319 // Initiator: All (except CEC switches)
2320 // Follower:
2321 // [Arguments]:
2322 // dst_address: destination logical address
2323 // [Return]:
2324 // error_code: return status
2325 //**************************************************************************
2326 CEC_ERROR_CODE MDrv_CEC_Msg_GiveAudioStatus(void* pInstance, MsCEC_DEVICELA dst_address)
2327 {
2328 void* pModule = NULL;
2329 void* pCECResource = NULL;
2330 MS_U8 ucInitiatorLA = 0;
2331 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
2332 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2333
2334 UtopiaInstanceGetModule(pInstance, &pModule);
2335
2336 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2337 {
2338 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2339 }
2340 else
2341 {
2342 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2343 {
2344 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2345 }
2346 else
2347 {
2348 #if ENABLE_CEC_MULTIPLE
2349 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
2350 #else
2351 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
2352 #endif
2353 }
2354 }
2355
2356 UtopiaResourceRelease(pCECResource);
2357
2358 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_SAC_GIVE_AUDIO_STATUS, (MS_U8*)E_MSG_FEATURE_ABORT, 0);
2359
2360 return res;
2361 }
2362
2363 //**************************************************************************
2364 // [Function Name]:
2365 // MDrv_CEC_Msg_ReportPowerStatus()
2366 // [Description]
2367 // Use to inform a requesting device of the current power status
2368 // [Message property]
2369 // Address: Directly
2370 // Initiator: All (except CEC switches)
2371 // Follower:
2372 // [Arguments]:
2373 // dst_address: destination logical address
2374 // [Return]:
2375 // error_code: return status
2376 //**************************************************************************
2377 CEC_ERROR_CODE MDrv_CEC_Msg_ReportPowerStatus(void* pInstance, MsCEC_DEVICELA dst_address)
2378 {
2379 void* pModule = NULL;
2380 void* pCECResource = NULL;
2381 MS_U8 ucInitiatorLA = 0;
2382 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
2383 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2384
2385 UtopiaInstanceGetModule(pInstance, &pModule);
2386
2387 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2388 {
2389 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2390 }
2391 else
2392 {
2393 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2394 {
2395 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2396 }
2397 else
2398 {
2399 MDRV_CEC_MSG_INFO("*CEC*:Report My PowerSts: 0x%x\n", pCECResourcePrivate->MyPowerStatus);
2400 #if ENABLE_CEC_MULTIPLE
2401 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
2402 #else
2403 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
2404 #endif
2405 }
2406 }
2407
2408 UtopiaResourceRelease(pCECResource);
2409
2410 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_PS_REPORT_POWER_STATUS, (MS_U8*)&(pCECResourcePrivate->MyPowerStatus), 1);
2411 return res;
2412 }
2413
2414 //**************************************************************************
2415 // [Function Name]:
2416 // MDrv_CEC_Msg_ReqPowerStatus()
2417 // [Description]
2418 // Use to determine the current power status of a target device
2419 // [Message property]
2420 // Address: Directly
2421 // Initiator:
2422 // Follower: All (except CEC switches)
2423 // [Arguments]:
2424 // dst_address: destination logical address
2425 // [Return]:
2426 // error_code: return status
2427 //**************************************************************************
2428 CEC_ERROR_CODE MDrv_CEC_Msg_ReqPowerStatus(void* pInstance, MsCEC_DEVICELA dst_address)
2429 {
2430 void* pModule = NULL;
2431 void* pCECResource = NULL;
2432 MS_U8 ucInitiatorLA = 0;
2433 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
2434 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2435
2436 UtopiaInstanceGetModule(pInstance, &pModule);
2437
2438 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2439 {
2440 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2441 }
2442 else
2443 {
2444 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2445 {
2446 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2447 }
2448 else
2449 {
2450 #if ENABLE_CEC_MULTIPLE
2451 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
2452 #else
2453 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
2454 #endif
2455 }
2456 }
2457
2458 UtopiaResourceRelease(pCECResource);
2459
2460 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_PS_GIVE_POWER_STATUS, (MS_U8*)E_MSG_FEATURE_ABORT, 0);
2461 MDRV_CEC_MSG_INFO("*CEC*:Req PowerSts: 0x%x\n", (MS_U16)res);
2462
2463 return res;
2464 }
2465
2466 //**************************************************************************
2467 // [Function Name]:
2468 // MDrv_CEC_Msg_FeatureAbort()
2469 // [Description]
2470 // Use to indicate that device doesn't support message type
2471 // [Message property]
2472 // Address: Directly
2473 // Initiator: Generate if a message is not supported
2474 // Follower: All
2475 // [Arguments]:
2476 // dst_address: destination logical address
2477 // msg: the requested message type
2478 // cmd: unsupport reason
2479 // [Return]:
2480 // error_code: return status
2481 //**************************************************************************
2482 CEC_ERROR_CODE MDrv_CEC_Msg_FeatureAbort(void* pInstance, MsCEC_DEVICELA dst_address, MsCEC_MSGLIST msg, MsCEC_MSG_ABORT_REASON cmd)
2483 {
2484 void* pModule = NULL;
2485 void* pCECResource = NULL;
2486 MS_U8 txbuf[2] = {0};
2487 MS_U8 ucInitiatorLA = 0;
2488 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
2489 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2490
2491 UtopiaInstanceGetModule(pInstance, &pModule);
2492
2493 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2494 {
2495 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2496 }
2497 else
2498 {
2499 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2500 {
2501 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2502 }
2503 else
2504 {
2505 #if ENABLE_CEC_MULTIPLE
2506 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
2507 #else
2508 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
2509 #endif
2510 txbuf[0] = msg;
2511 txbuf[1] = cmd;
2512 }
2513 }
2514
2515 UtopiaResourceRelease(pCECResource);
2516
2517 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_FEATURE_ABORT, txbuf, 2);
2518
2519 return res;
2520 }
2521
2522 //**************************************************************************
2523 // [Function Name]:
2524 // MDrv_CEC_Msg_Abort()
2525 // [Description]
2526 // This message is reserved for testing purposes.
2527 // [Message property]
2528 // Address: Directly
2529 // Initiator:
2530 // Follower: All except for CEC switches
2531 // [Arguments]:
2532 // dst_address: destination logical address
2533 // [Return]:
2534 // error_code: return status
2535 //**************************************************************************
2536 CEC_ERROR_CODE MDrv_CEC_Msg_Abort(void* pInstance, MsCEC_DEVICELA dst_address)
2537 {
2538 void* pModule = NULL;
2539 void* pCECResource = NULL;
2540 MS_U8 ucInitiatorLA = 0;
2541 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
2542 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2543
2544 UtopiaInstanceGetModule(pInstance, &pModule);
2545
2546 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2547 {
2548 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2549 }
2550 else
2551 {
2552 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2553 {
2554 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2555 }
2556 else
2557 {
2558 #if ENABLE_CEC_MULTIPLE
2559 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
2560 #else
2561 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
2562 #endif
2563 }
2564 }
2565
2566 UtopiaResourceRelease(pCECResource);
2567
2568 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_ABORT_MESSAGE, (MS_U8*)E_MSG_FEATURE_ABORT, 0);
2569
2570 return res;
2571 }
2572
2573 //**************************************************************************
2574 // [Function Name]:
2575 // MDrv_CEC_Msg_SendMenuLanguage()
2576 // [Description]
2577 // Used by a CEC switch when it's manually switched language to inform akk other devices.
2578 // [Message property]
2579 // Address: Broadcast
2580 // Initiator: CEC switches and TV(with 2 or more HDMI inputs)
2581 // Follower: CEC switches
2582 // [Arguments]:
2583 // MenuLanguageCode: iso639-2 Language Code, 3 bytes
2584 // [Return]:
2585 // error_code: return status
2586 //**************************************************************************
2587 CEC_ERROR_CODE MDrv_CEC_Msg_SendMenuLanguage(void* pInstance, MS_U8* pu8MenuLanguageCode)
2588 {
2589 void* pModule = NULL;
2590 void* pCECResource = NULL;
2591 MS_U8 ucInitiatorLA = 0;
2592 MS_U8 txbuf[3] = {0};
2593 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
2594 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2595
2596 UtopiaInstanceGetModule(pInstance, &pModule);
2597
2598 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2599 {
2600 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2601 }
2602 else
2603 {
2604 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2605 {
2606 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2607 }
2608 else
2609 {
2610 #if ENABLE_CEC_MULTIPLE
2611 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
2612 #else
2613 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
2614 #endif
2615 txbuf[0] = pu8MenuLanguageCode[0];
2616 txbuf[1] = pu8MenuLanguageCode[1];
2617 txbuf[2] = pu8MenuLanguageCode[2];
2618 }
2619 }
2620
2621 UtopiaResourceRelease(pCECResource);
2622
2623 res = _MDrv_CEC_TxApi(ucInitiatorLA, E_LA_BROADCAST, E_MSG_SI_SET_MENU_LANGUAGE, txbuf, 3);
2624
2625 return res;
2626 }
2627
2628 //**************************************************************************
2629 // [Function Name]:
2630 // MDrv_CecMsg_ReqARCInitiation()
2631 // [Description]
2632 // Used by an ARC TX device to request an ARC RX device to active
2633 // the ARC functionility in ARC TX device
2634 // [Message property]
2635 // Address: Directly
2636 // Initiator:
2637 // Follower: ARC RX device
2638 // [Arguments]:
2639 // dst_address: destination logical address
2640 // [Return]:
2641 // error_code: return status
2642 //**************************************************************************
2643 CEC_ERROR_CODE MDrv_CecMsg_ReqARCInitiation(void* pInstance, MsCEC_DEVICELA dst_address)
2644 {
2645 void* pModule = NULL;
2646 void* pCECResource = NULL;
2647 MS_U8 ucInitiatorLA = 0;
2648 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
2649 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2650
2651 UtopiaInstanceGetModule(pInstance, &pModule);
2652
2653 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2654 {
2655 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2656 }
2657 else
2658 {
2659 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2660 {
2661 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2662 }
2663 else
2664 {
2665 #if ENABLE_CEC_MULTIPLE
2666 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
2667 #else
2668 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
2669 #endif
2670 }
2671 }
2672
2673 UtopiaResourceRelease(pCECResource);
2674
2675 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_ARC_REQUEST_ARC_INITATION, (MS_U8*)E_MSG_FEATURE_ABORT, 0);
2676
2677 return res;
2678 }
2679
2680 //**************************************************************************
2681 // [Function Name]:
2682 // MDrv_CecMsg_ReqARCTermination()
2683 // [Description]
2684 // Used by an ARC TX device to request an ARC RX device to deactive
2685 // the ARC functionility in ARC TX device
2686 // [Message property]
2687 // Address: Directly
2688 // Initiator:
2689 // Follower: ARC RX device
2690 // [Arguments]:
2691 // dst_address: destination logical address
2692 // [Return]:
2693 // error_code: return status
2694 //**************************************************************************
2695 CEC_ERROR_CODE MDrv_CecMsg_ReqARCTermination(void* pInstance, MsCEC_DEVICELA dst_address)
2696 {
2697 void* pModule = NULL;
2698 void* pCECResource = NULL;
2699 MS_U8 ucInitiatorLA = 0;
2700 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
2701 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2702
2703 UtopiaInstanceGetModule(pInstance, &pModule);
2704
2705 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2706 {
2707 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2708 }
2709 else
2710 {
2711 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2712 {
2713 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2714 }
2715 else
2716 {
2717 #if ENABLE_CEC_MULTIPLE
2718 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
2719 #else
2720 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
2721 #endif
2722 }
2723 }
2724
2725 UtopiaResourceRelease(pCECResource);
2726
2727 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_ARC_REQUEST_ARC_TERMINATION, (MS_U8*)E_MSG_FEATURE_ABORT, 0);
2728
2729 return res;
2730 }
2731
2732 //**************************************************************************
2733 // [Function Name]:
2734 // MDrv_CecMsg_AudioModeReq()
2735 // [Description]
2736 // A device implementing System Audio Control and which has volume control
2737 // RC buttons request to use System Audio Mode to the Amplifier
2738 // [Message property]
2739 // Address: Directly
2740 // Initiator:
2741 // Follower:
2742 // [Arguments]:
2743 // dst_address: destination logical address
2744 // amp_switch: 1: unmute amplifier. 0: mute amplifier
2745 // my_address: source to be used is the device specified at this address
2746 // [Return]:
2747 // error_code: return status
2748 //**************************************************************************
2749 CEC_ERROR_CODE MDrv_CecMsg_AudioModeReq(void* pInstance, MsCEC_DEVICELA dst_address, MS_BOOL amp_switch, MS_U8* my_address)
2750 {
2751 void* pModule = NULL;
2752 void* pCECResource = NULL;
2753 MS_U8 txbuf[2] = {0};
2754 MS_U8 ucInitiatorLA = 0;
2755 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
2756 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2757
2758 UtopiaInstanceGetModule(pInstance, &pModule);
2759
2760 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2761 {
2762 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2763 }
2764 else
2765 {
2766 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2767 {
2768 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2769 }
2770 else
2771 {
2772 #if ENABLE_CEC_MULTIPLE
2773 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
2774 #else
2775 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
2776 #endif
2777 }
2778 }
2779
2780 UtopiaResourceRelease(pCECResource);
2781
2782 if(amp_switch)
2783 {
2784 txbuf[0] = my_address[0];
2785 txbuf[1] = my_address[1];
2786 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_SAC_SYSTEM_AUDIO_MODE_REQUEST, txbuf, 2);
2787 }
2788 else
2789 {
2790 res = _MDrv_CEC_TxApi(ucInitiatorLA, dst_address, E_MSG_SAC_SYSTEM_AUDIO_MODE_REQUEST, (MS_U8*)E_MSG_FEATURE_ABORT, 0);
2791 }
2792
2793 return res;
2794 }
2795
2796 //**************************************************************************
2797 // [Function Name]:
2798 // MDrv_CecCheckFrame()
2799 // [Description]
2800 // Driver layer: Use to check CEC frame is valid or not
2801 // [Arguments]:
2802 // msg_type: CEC message type
2803 // uclen: message length, include header and opcode
2804 // [Return]:
2805 // True or False
2806 //**************************************************************************
2807 MS_BOOL MDrv_CEC_CheckFrame(void* pInstance, MsCEC_MSG_TRANS_TYPE msg_type, MS_U8 ucLen)
2808 {
2809 void* pModule = NULL;
2810 void* pCECResource = NULL;
2811 MS_BOOL a = FALSE;
2812 MS_BOOL b = FALSE;
2813 MS_BOOL bReturnFlag = FALSE;
2814 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2815
2816 UtopiaInstanceGetModule(pInstance, &pModule);
2817
2818 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2819 {
2820 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2821 }
2822 else
2823 {
2824 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2825 {
2826 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2827 }
2828 else
2829 {
2830 a = (pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxS].tRxData[0]&0x0F) == 0x0F; //broadcast case or not (addressed)
2831 b = (pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxS].ucLength) >= ucLen; //para length same or bigger than want (spec)
2832
2833 if((pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxS].tRxData[0]&0xF0) == 0xF0) //message from unregistered device
2834 {
2835 switch(pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxS].tRxData[1]) //opcode
2836 {
2837 case E_MSG_RC_INACTIVE_SOURCE:
2838 case E_MSG_RC_REQ_ACTIVE_SOURCE:
2839 case E_MSG_RC_ROUTING_CHANGE:
2840 case E_MSG_RC_ROUTING_INFO:
2841 case E_MSG_RC_SET_STREM_PATH:
2842
2843 case E_MSG_STANDBY: //=> system standby
2844 // following command invoke broadcast response
2845 case E_MSG_SI_REQUEST_PHY_ADDR: //=> Report_Physical_Address
2846 case E_MSG_SI_GET_MENU_LANGUAGE: //=> Set_Menu_Language
2847 case E_MSG_VS_GIVE_VENDOR_ID: //=> Device_Vendor_ID
2848 break;
2849 default:
2850 bReturnFlag = FALSE;
2851 break;
2852 };
2853 }
2854
2855 switch(msg_type)
2856 {
2857 case E_TRANS_BROADCAST_MSG:
2858 bReturnFlag = a&b;
2859 break;
2860 case E_TRANS_DIRECT_MSG:
2861 bReturnFlag = (!a)&b;
2862 break;
2863 case E_TRANS_BOTHTYPE_MSG:
2864 bReturnFlag = b;
2865 break;
2866 };
2867 }
2868 }
2869
2870 UtopiaResourceRelease(pCECResource);
2871
2872 return bReturnFlag;
2873 }
2874
2875 //**************************************************************************
2876 // [Function Name]:
2877 // MDrv_CEC_SetRetryCount()
2878 // [Description]
2879 //
2880 // [Arguments]:
2881 //
2882 // [Return]:
2883 //
2884 //**************************************************************************
2885 void MDrv_CEC_SetRetryCount(void* pInstance, MS_U8 u8RetryCount)
2886 {
2887 void* pModule = NULL;
2888 void* pCECResource = NULL;
2889 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2890
2891 UtopiaInstanceGetModule(pInstance, &pModule);
2892
2893 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2894 {
2895 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2896 }
2897 else
2898 {
2899 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2900 {
2901 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2902 }
2903 else
2904 {
2905 pCECResourcePrivate->ucRetryCount = u8RetryCount;
2906 }
2907 }
2908
2909 UtopiaResourceRelease(pCECResource);
2910 }
2911
2912 //**************************************************************************
2913 // [Function Name]:
2914 // MDrv_CEC_ConfigWakeUp()
2915 // [Description]
2916 //
2917 // [Arguments]:
2918 //
2919 // [Return]:
2920 //
2921 //**************************************************************************
2922 void MDrv_CEC_ConfigWakeUp(void* pInstance)
2923 {
2924 void* pModule = NULL;
2925 void* pCECResource = NULL;
2926 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2927
2928 UtopiaInstanceGetModule(pInstance, &pModule);
2929
2930 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2931 {
2932 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2933 }
2934 else
2935 {
2936 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2937 {
2938 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2939 }
2940 else
2941 {
2942 if (!pCECResourcePrivate->bRIUAddrReady)
2943 {
2944 _MDrv_CEC_init_riu_base(pCECResourcePrivate); // Get base address to prevent core dump
2945 }
2946
2947 mhal_CEC_ConfigWakeUp(pCECResourcePrivate->ucRetryCount, pCECResourcePrivate->ucVendorID, pCECResourcePrivate->ulXTAL_CLK_Hz,
2948 pCECResourcePrivate->MyPhysicalAddress, pCECResourcePrivate->MyDeviceType, pCECResourcePrivate->bCECIsSource);
2949 }
2950 }
2951
2952 UtopiaResourceRelease(pCECResource);
2953 }
2954
2955 //**************************************************************************
2956 // [Function Name]:
2957 // MDrv_CEC_ConfigWakeupInfoVendorID()
2958 // [Description]
2959 //
2960 // [Arguments]:
2961 //
2962 // [Return]:
2963 //
2964 //**************************************************************************
2965 void MDrv_CEC_ConfigWakeupInfoVendorID(void* pInstance, MS_U8 *u8CecVendorID)
2966 {
2967 void* pModule = NULL;
2968 void* pCECResource = NULL;
2969 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
2970
2971 UtopiaInstanceGetModule(pInstance, &pModule);
2972
2973 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
2974 {
2975 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
2976 }
2977 else
2978 {
2979 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
2980 {
2981 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
2982 }
2983 else
2984 {
2985 pCECResourcePrivate->ucVendorID[0] = u8CecVendorID[0];
2986 pCECResourcePrivate->ucVendorID[1] = u8CecVendorID[1];
2987 pCECResourcePrivate->ucVendorID[2] = u8CecVendorID[2];
2988 }
2989 }
2990
2991 UtopiaResourceRelease(pCECResource);
2992 }
2993
2994 //**************************************************************************
2995 // [Function Name]:
2996 // MDrv_CEC_Enabled()
2997 // [Description]
2998 //
2999 // [Arguments]:
3000 //
3001 // [Return]:
3002 //
3003 //**************************************************************************
3004 void MDrv_CEC_Enabled(void* pInstance, MS_BOOL bEnableFlag)
3005 {
3006 if (bEnableFlag)
3007 {
3008 mhal_CEC_ClearRxStatus();
3009 #if ENABLE_CEC_MULTIPLE
3010 mhal_CEC_ClearRxStatus2();
3011 #endif
3012 mhal_CEC_INTEn(TRUE);
3013 mhal_CEC_Enabled(TRUE);
3014 }
3015 else
3016 {
3017 mhal_CEC_INTEn(FALSE);
3018 mhal_CEC_Enabled(FALSE);
3019 }
3020 }
3021
3022 //**************************************************************************
3023 // [Function Name]:
3024 // MDrv_CEC_TxStatus()
3025 // [Description]
3026 //
3027 // [Arguments]:
3028 //
3029 // [Return]:
3030 //
3031 //**************************************************************************
3032 MS_U8 MDrv_CEC_TxStatus(void* pInstance)
3033 {
3034 return mhal_CEC_TxStatus();
3035 }
3036
3037 //**************************************************************************
3038 // [Function Name]:
3039 // MDrv_CEC_CheckDeviceIsTx()
3040 // [Description]
3041 //
3042 // [Arguments]:
3043 //
3044 // [Return]:
3045 //
3046 //**************************************************************************
3047 MS_BOOL MDrv_CEC_CheckDeviceIsTx(void* pInstance)
3048 {
3049 void* pModule = NULL;
3050 void* pCECResource = NULL;
3051 MS_BOOL bCECIsSourceFlag = FALSE;
3052 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3053
3054 UtopiaInstanceGetModule(pInstance, &pModule);
3055
3056 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3057 {
3058 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3059 }
3060 else
3061 {
3062 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3063 {
3064 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3065 }
3066 else
3067 {
3068 bCECIsSourceFlag = pCECResourcePrivate->bCECIsSource;
3069 }
3070 }
3071
3072 UtopiaResourceRelease(pCECResource);
3073
3074 return bCECIsSourceFlag;
3075 }
3076
3077 //**************************************************************************
3078 // [Function Name]:
3079 // MDrv_CEC_SetPowerState()
3080 // [Description]
3081 //
3082 // [Arguments]:
3083 //
3084 // [Return]:
3085 //
3086 //**************************************************************************
3087 MS_U32 MDrv_CEC_SetPowerState(void* pInstance, EN_POWER_MODE u16PowerState)
3088 {
3089 void* pModule = NULL;
3090
3091 UtopiaInstanceGetModule(pInstance, &pModule);
3092
3093 return mdrv_CEC_STREventProc(pModule, u16PowerState);
3094 }
3095
3096 //**************************************************************************
3097 // [Function Name]:
3098 // MDrv_CEC_Get_Header()
3099 // [Description]
3100 //
3101 // [Arguments]:
3102 //
3103 // [Return]:
3104 //
3105 //**************************************************************************
3106 MS_U8 MDrv_CEC_Get_Header(void* pInstance)
3107 {
3108 void* pModule = NULL;
3109 void* pCECResource = NULL;
3110 MS_U8 ucReturnValue = 0;
3111 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3112
3113 UtopiaInstanceGetModule(pInstance, &pModule);
3114
3115 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3116 {
3117 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3118 }
3119 else
3120 {
3121 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3122 {
3123 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3124 }
3125 else
3126 {
3127 ucReturnValue = pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxS].tRxData[0];
3128 }
3129 }
3130
3131 UtopiaResourceRelease(pCECResource);
3132
3133 return ucReturnValue;
3134 }
3135
3136 //**************************************************************************
3137 // [Function Name]:
3138 // MDrv_CEC_Get_OpCode()
3139 // [Description]
3140 //
3141 // [Arguments]:
3142 //
3143 // [Return]:
3144 //
3145 //**************************************************************************
3146 MS_U8 MDrv_CEC_Get_OpCode(void* pInstance)
3147 {
3148 void* pModule = NULL;
3149 void* pCECResource = NULL;
3150 MS_U8 ucReturnValue = 0;
3151 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3152
3153 UtopiaInstanceGetModule(pInstance, &pModule);
3154
3155 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3156 {
3157 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3158 }
3159 else
3160 {
3161 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3162 {
3163 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3164 }
3165 else
3166 {
3167 ucReturnValue = pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxS].tRxData[1];
3168 }
3169 }
3170
3171 UtopiaResourceRelease(pCECResource);
3172
3173 return ucReturnValue;
3174 }
3175
3176 //**************************************************************************
3177 // [Function Name]:
3178 // MDrv_CEC_Get_Para()
3179 // [Description]
3180 //
3181 // [Arguments]:
3182 //
3183 // [Return]:
3184 //
3185 //**************************************************************************
3186 MS_U8 MDrv_CEC_Get_Para(void* pInstance, MS_U8 u8Idx)
3187 {
3188 void* pModule = NULL;
3189 void* pCECResource = NULL;
3190 MS_U8 ucReturnValue = 0;
3191 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3192
3193 UtopiaInstanceGetModule(pInstance, &pModule);
3194
3195 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3196 {
3197 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3198 }
3199 else
3200 {
3201 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3202 {
3203 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3204 }
3205 else
3206 {
3207 if(u8Idx+2 > 15)
3208 {
3209 ucReturnValue = pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxS].tRxData[0];
3210 }
3211 else
3212 {
3213 ucReturnValue = pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxS].tRxData[u8Idx+2];
3214 }
3215 }
3216 }
3217
3218 UtopiaResourceRelease(pCECResource);
3219
3220 return ucReturnValue;
3221 }
3222
3223 //**************************************************************************
3224 // [Function Name]:
3225 // MDrv_CEC_GetCmdLen()
3226 // [Description]
3227 //
3228 // [Arguments]:
3229 //
3230 // [Return]:
3231 //
3232 //**************************************************************************
3233 MS_U8 MDrv_CEC_GetCmdLen(void* pInstance)
3234 {
3235 void* pModule = NULL;
3236 void* pCECResource = NULL;
3237 MS_U8 ucReturnValue = 0;
3238 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3239
3240 UtopiaInstanceGetModule(pInstance, &pModule);
3241
3242 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3243 {
3244 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3245 }
3246 else
3247 {
3248 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3249 {
3250 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3251 }
3252 else
3253 {
3254 ucReturnValue = pCECResourcePrivate->CecRxBuf[pCECResourcePrivate->CecFifoIdxS].ucLength;
3255 }
3256 }
3257
3258 UtopiaResourceRelease(pCECResource);
3259
3260 return ucReturnValue;
3261 }
3262
3263 //**************************************************************************
3264 // [Function Name]:
3265 // MDrv_CEC_IsRxBufEmpty()
3266 // [Description]
3267 //
3268 // [Arguments]:
3269 //
3270 // [Return]:
3271 //
3272 //**************************************************************************
3273 MS_BOOL MDrv_CEC_IsRxBufEmpty(void* pInstance)
3274 {
3275 void* pModule = NULL;
3276 void* pCECResource = NULL;
3277 MS_BOOL bReturnFlag = FALSE;
3278 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3279
3280 UtopiaInstanceGetModule(pInstance, &pModule);
3281
3282 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3283 {
3284 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3285 }
3286 else
3287 {
3288 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3289 {
3290 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3291 }
3292 else
3293 {
3294 if(pCECResourcePrivate->bCecMsgCnt == 0 )
3295 {
3296 bReturnFlag = TRUE;
3297 }
3298 else
3299 {
3300 bReturnFlag = FALSE;
3301 }
3302 }
3303 }
3304
3305 UtopiaResourceRelease(pCECResource);
3306
3307 return bReturnFlag;
3308 }
3309
3310 //**************************************************************************
3311 // [Function Name]:
3312 // MDrv_CEC_SetActiveLogicalAddress()
3313 // [Description]
3314 //
3315 // [Arguments]:
3316 //
3317 // [Return]:
3318 //
3319 //**************************************************************************
3320 void MDrv_CEC_SetActiveLogicalAddress(void* pInstance, MsCEC_DEVICELA Addr)
3321 {
3322 void* pModule = NULL;
3323 void* pCECResource = NULL;
3324 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3325
3326 UtopiaInstanceGetModule(pInstance, &pModule);
3327
3328 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3329 {
3330 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3331 }
3332 else
3333 {
3334 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3335 {
3336 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3337 }
3338 else
3339 {
3340 pCECResourcePrivate->ActiveLogicalAddress = Addr;
3341 }
3342 }
3343
3344 UtopiaResourceRelease(pCECResource);
3345 }
3346
3347 //**************************************************************************
3348 // [Function Name]:
3349 // MDrv_CEC_GetActiveLogicalAddress()
3350 // [Description]
3351 //
3352 // [Arguments]:
3353 //
3354 // [Return]:
3355 //
3356 //**************************************************************************
3357 MsCEC_DEVICELA MDrv_CEC_GetActiveLogicalAddress(void* pInstance)
3358 {
3359 void* pModule = NULL;
3360 void* pCECResource = NULL;
3361 MsCEC_DEVICELA eReturnValue = E_LA_UNREGISTERED;
3362 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3363
3364 UtopiaInstanceGetModule(pInstance, &pModule);
3365
3366 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3367 {
3368 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3369 }
3370 else
3371 {
3372 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3373 {
3374 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3375 }
3376 else
3377 {
3378 eReturnValue = pCECResourcePrivate->ActiveLogicalAddress;
3379 }
3380 }
3381
3382 UtopiaResourceRelease(pCECResource);
3383
3384 return eReturnValue;
3385 }
3386
3387 //**************************************************************************
3388 // [Function Name]:
3389 // MDrv_CEC_GetPowerStatus()
3390 // [Description]
3391 //
3392 // [Arguments]:
3393 //
3394 // [Return]:
3395 //
3396 //**************************************************************************
3397 MsCEC_MSG_POWER_STATUS_PARM MDrv_CEC_GetPowerStatus(void* pInstance)
3398 {
3399 void* pModule = NULL;
3400 void* pCECResource = NULL;
3401 MsCEC_MSG_POWER_STATUS_PARM eReturnValue = E_MSG_PWRSTA_UNKNOW;
3402 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3403
3404 UtopiaInstanceGetModule(pInstance, &pModule);
3405
3406 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3407 {
3408 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3409 }
3410 else
3411 {
3412 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3413 {
3414 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3415 }
3416 else
3417 {
3418 eReturnValue = pCECResourcePrivate->MyPowerStatus;
3419 }
3420 }
3421
3422 UtopiaResourceRelease(pCECResource);
3423
3424 return eReturnValue;
3425 }
3426
3427 //**************************************************************************
3428 // [Function Name]:
3429 // MDrv_CEC_GetFifoIdx()
3430 // [Description]
3431 //
3432 // [Arguments]:
3433 //
3434 // [Return]:
3435 //
3436 //**************************************************************************
3437 MS_U8 MDrv_CEC_GetFifoIdx(void* pInstance)
3438 {
3439 void* pModule = NULL;
3440 void* pCECResource = NULL;
3441 MS_U8 ucReturnValue = 0;
3442 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3443
3444 UtopiaInstanceGetModule(pInstance, &pModule);
3445
3446 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3447 {
3448 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3449 }
3450 else
3451 {
3452 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3453 {
3454 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3455 }
3456 else
3457 {
3458 ucReturnValue = pCECResourcePrivate->CecFifoIdxS;
3459 }
3460 }
3461
3462 UtopiaResourceRelease(pCECResource);
3463
3464 return ucReturnValue;
3465 }
3466
3467 //**************************************************************************
3468 // [Function Name]:
3469 // MDrv_CEC_SetFifoIdx()
3470 // [Description]
3471 //
3472 // [Arguments]:
3473 //
3474 // [Return]:
3475 //
3476 //**************************************************************************
3477 void MDrv_CEC_SetFifoIdx(void* pInstance, MS_U8 u8Idx)
3478 {
3479 void* pModule = NULL;
3480 void* pCECResource = NULL;
3481 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3482
3483 UtopiaInstanceGetModule(pInstance, &pModule);
3484
3485 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3486 {
3487 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3488 }
3489 else
3490 {
3491 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3492 {
3493 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3494 }
3495 else
3496 {
3497 pCECResourcePrivate->CecFifoIdxS = u8Idx;
3498 }
3499 }
3500
3501 UtopiaResourceRelease(pCECResource);
3502 }
3503
3504 //**************************************************************************
3505 // [Function Name]:
3506 // MDrv_CEC_SetActivePowerStatus()
3507 // [Description]
3508 //
3509 // [Arguments]:
3510 //
3511 // [Return]:
3512 //
3513 //**************************************************************************
3514 void MDrv_CEC_SetActivePowerStatus(void* pInstance, MsCEC_MSG_POWER_STATUS_PARM Status)
3515 {
3516 void* pModule = NULL;
3517 void* pCECResource = NULL;
3518 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3519
3520 UtopiaInstanceGetModule(pInstance, &pModule);
3521
3522 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3523 {
3524 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3525 }
3526 else
3527 {
3528 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3529 {
3530 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3531 }
3532 else
3533 {
3534 pCECResourcePrivate->ActivePowerStatus = Status;
3535 }
3536 }
3537
3538 UtopiaResourceRelease(pCECResource);
3539 }
3540
3541 //**************************************************************************
3542 // [Function Name]:
3543 // MDrv_CEC_GetActivePowerStatus()
3544 // [Description]
3545 //
3546 // [Arguments]:
3547 //
3548 // [Return]:
3549 //
3550 //**************************************************************************
3551 MsCEC_MSG_POWER_STATUS_PARM MDrv_CEC_GetActivePowerStatus(void* pInstance)
3552 {
3553 void* pModule = NULL;
3554 void* pCECResource = NULL;
3555 MsCEC_MSG_POWER_STATUS_PARM eReturnValue = E_MSG_PWRSTA_UNKNOW;
3556 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3557
3558 UtopiaInstanceGetModule(pInstance, &pModule);
3559
3560 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3561 {
3562 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3563 }
3564 else
3565 {
3566 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3567 {
3568 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3569 }
3570 else
3571 {
3572 eReturnValue = pCECResourcePrivate->ActivePowerStatus;
3573 }
3574 }
3575
3576 UtopiaResourceRelease(pCECResource);
3577
3578 return eReturnValue;
3579 }
3580
3581 //**************************************************************************
3582 // [Function Name]:
3583 // MDrv_CEC_SetActivePhysicalAddress()
3584 // [Description]
3585 //
3586 // [Arguments]:
3587 //
3588 // [Return]:
3589 //
3590 //**************************************************************************
3591 void MDrv_CEC_SetActivePhysicalAddress(void* pInstance, MS_U8 u8Para1, MS_U8 u8Para2)
3592 {
3593 void* pModule = NULL;
3594 void* pCECResource = NULL;
3595 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3596
3597 UtopiaInstanceGetModule(pInstance, &pModule);
3598
3599 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3600 {
3601 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3602 }
3603 else
3604 {
3605 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3606 {
3607 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3608 }
3609 else
3610 {
3611 pCECResourcePrivate->ActivePhysicalAddress[0] = u8Para1;
3612 pCECResourcePrivate->ActivePhysicalAddress[1] = u8Para2;
3613 }
3614 }
3615
3616 UtopiaResourceRelease(pCECResource);
3617 }
3618
3619 //**************************************************************************
3620 // [Function Name]:
3621 // MDrv_CEC_SetActiveDeviceCECVersion()
3622 // [Description]
3623 //
3624 // [Arguments]:
3625 //
3626 // [Return]:
3627 //
3628 //**************************************************************************
3629 void MDrv_CEC_SetActiveDeviceCECVersion(void* pInstance, MS_U8 u8Ver)
3630 {
3631 void* pModule = NULL;
3632 void* pCECResource = NULL;
3633 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3634
3635 UtopiaInstanceGetModule(pInstance, &pModule);
3636
3637 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3638 {
3639 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3640 }
3641 else
3642 {
3643 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3644 {
3645 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3646 }
3647 else
3648 {
3649 pCECResourcePrivate->ActiveDeviceCECVersion= u8Ver;
3650 }
3651 }
3652
3653 UtopiaResourceRelease(pCECResource);
3654 }
3655
3656 //**************************************************************************
3657 // [Function Name]:
3658 // MDrv_CEC_SetActiveDeviceType()
3659 // [Description]
3660 //
3661 // [Arguments]:
3662 //
3663 // [Return]:
3664 //
3665 //**************************************************************************
3666 void MDrv_CEC_SetActiveDeviceType(void* pInstance, MsCEC_DEVICE_TYPE Type)
3667 {
3668 void* pModule = NULL;
3669 void* pCECResource = NULL;
3670 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3671
3672 UtopiaInstanceGetModule(pInstance, &pModule);
3673
3674 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3675 {
3676 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3677 }
3678 else
3679 {
3680 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3681 {
3682 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3683 }
3684 else
3685 {
3686 pCECResourcePrivate->ActiveDeviceType = Type;
3687 }
3688 }
3689
3690 UtopiaResourceRelease(pCECResource);
3691 }
3692
3693 //**************************************************************************
3694 // [Function Name]:
3695 // MDrv_CEC_GetMsgCnt()
3696 // [Description]
3697 //
3698 // [Arguments]:
3699 //
3700 // [Return]:
3701 //
3702 //**************************************************************************
3703 MS_U8 MDrv_CEC_GetMsgCnt(void* pInstance)
3704 {
3705 void* pModule = NULL;
3706 void* pCECResource = NULL;
3707 MS_U8 ucReturnValue = 0;
3708 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3709
3710 UtopiaInstanceGetModule(pInstance, &pModule);
3711
3712 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3713 {
3714 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3715 }
3716 else
3717 {
3718 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3719 {
3720 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3721 }
3722 else
3723 {
3724 ucReturnValue = pCECResourcePrivate->bCecMsgCnt;
3725 }
3726 }
3727
3728 UtopiaResourceRelease(pCECResource);
3729
3730 return ucReturnValue;
3731 }
3732
3733 //**************************************************************************
3734 // [Function Name]:
3735 // MDrv_CEC_SetMsgCnt()
3736 // [Description]
3737 //
3738 // [Arguments]:
3739 //
3740 // [Return]:
3741 //
3742 //**************************************************************************
3743 void MDrv_CEC_SetMsgCnt(void* pInstance, MS_U8 u8Cnt)
3744 {
3745 void* pModule = NULL;
3746 void* pCECResource = NULL;
3747 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3748
3749 UtopiaInstanceGetModule(pInstance, &pModule);
3750
3751 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3752 {
3753 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3754 }
3755 else
3756 {
3757 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3758 {
3759 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3760 }
3761 else
3762 {
3763 pCECResourcePrivate->bCecMsgCnt = u8Cnt;
3764 }
3765 }
3766
3767 UtopiaResourceRelease(pCECResource);
3768 }
3769
3770 //**************************************************************************
3771 // [Function Name]:
3772 // MDrv_CEC_GetRxData()
3773 // [Description]
3774 //
3775 // [Arguments]:
3776 //
3777 // [Return]:
3778 //
3779 //**************************************************************************
3780 MS_U8 MDrv_CEC_GetRxData(void* pInstance, MS_U8 u8Fifoidx, MS_U8 u8Idx)
3781 {
3782 void* pModule = NULL;
3783 void* pCECResource = NULL;
3784 MS_U8 ucReturnValue = 0;
3785 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3786
3787 UtopiaInstanceGetModule(pInstance, &pModule);
3788
3789 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3790 {
3791 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3792 }
3793 else
3794 {
3795 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3796 {
3797 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3798 }
3799 else
3800 {
3801 ucReturnValue = pCECResourcePrivate->CecRxBuf[u8Fifoidx].tRxData[u8Idx];
3802 }
3803 }
3804
3805 UtopiaResourceRelease(pCECResource);
3806
3807 return ucReturnValue;
3808 }
3809
3810 //**************************************************************************
3811 // [Function Name]:
3812 // MDrv_CEC_SetMyPhysicalAddress()
3813 // [Description]
3814 //
3815 // [Arguments]:
3816 //
3817 // [Return]:
3818 //
3819 //**************************************************************************
3820 void MDrv_CEC_SetMyPhysicalAddress(void* pInstance, MS_U8 *pdata)
3821 {
3822 void* pModule = NULL;
3823 void* pCECResource = NULL;
3824 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3825
3826 UtopiaInstanceGetModule(pInstance, &pModule);
3827
3828 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3829 {
3830 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3831 }
3832 else
3833 {
3834 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3835 {
3836 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3837 }
3838 else
3839 {
3840 pCECResourcePrivate->MyPhysicalAddress[0] = pdata[0];
3841 pCECResourcePrivate->MyPhysicalAddress[1] = pdata[1];
3842 }
3843 }
3844
3845 UtopiaResourceRelease(pCECResource);
3846 }
3847
3848 #if ENABLE_CEC_MULTIPLE
3849 //**************************************************************************
3850 // [Function Name]:
3851 // MDrv_CEC_SetMyLogicalAddress2()
3852 // [Description]
3853 //
3854 // [Arguments]:
3855 //
3856 // [Return]:
3857 //
3858 //**************************************************************************
3859 void MDrv_CEC_SetMyLogicalAddress2(void* pInstance, MsCEC_DEVICELA myLA)
3860 {
3861 void* pModule = NULL;
3862 void* pCECResource = NULL;
3863 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3864
3865 UtopiaInstanceGetModule(pInstance, &pModule);
3866
3867 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3868 {
3869 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3870 }
3871 else
3872 {
3873 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3874 {
3875 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3876 }
3877 else
3878 {
3879 pCECResourcePrivate->MyLogicalAddress2= myLA;
3880
3881 mhal_CEC_SetMyAddress2((MS_U8)pCECResourcePrivate->MyLogicalAddress2);
3882 }
3883 }
3884
3885 UtopiaResourceRelease(pCECResource);
3886 }
3887
3888 //**************************************************************************
3889 // [Function Name]:
3890 // MDrv_CEC_Msg_ReportPhycalAddress2()
3891 // [Description]
3892 //
3893 // [Arguments]:
3894 //
3895 // [Return]:
3896 //
3897 //**************************************************************************
3898 CEC_ERROR_CODE MDrv_CEC_Msg_ReportPhycalAddress2(void* pInstance)
3899 {
3900 void* pModule = NULL;
3901 void* pCECResource = NULL;
3902 MS_U8 txbuf[3] = {0};
3903 MS_U8 ucInitiatorLA = 0;
3904 CEC_ERROR_CODE res = E_CEC_FEATURE_ABORT;
3905 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3906
3907 UtopiaInstanceGetModule(pInstance, &pModule);
3908
3909 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3910 {
3911 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3912 }
3913 else
3914 {
3915 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3916 {
3917 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3918 }
3919 else
3920 {
3921 #if ENABLE_CEC_MULTIPLE
3922 ucInitiatorLA = pCECResourcePrivate->IniLogicalAddress;
3923 #else
3924 ucInitiatorLA = pCECResourcePrivate->MyLogicalAddress;
3925 #endif
3926 txbuf[0] = pCECResourcePrivate->MyPhysicalAddress2[0];
3927 txbuf[1] = pCECResourcePrivate->MyPhysicalAddress2[1];
3928 txbuf[2] = pCECResourcePrivate->MyDeviceType2;
3929 }
3930 }
3931
3932 UtopiaResourceRelease(pCECResource);
3933
3934 res = _MDrv_CEC_TxApi(ucInitiatorLA, E_LA_BROADCAST, E_MSG_SI_REPORT_PHY_ADDR, txbuf, 3);
3935
3936 return res;
3937 }
3938
3939 //**************************************************************************
3940 // [Function Name]:
3941 // MDrv_CEC_SetMyPhysicalAddress2()
3942 // [Description]
3943 //
3944 // [Arguments]:
3945 //
3946 // [Return]:
3947 //
3948 //**************************************************************************
3949 void MDrv_CEC_SetMyPhysicalAddress2(void* pInstance, MS_U8 *pdata)
3950 {
3951 void* pModule = NULL;
3952 void* pCECResource = NULL;
3953 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3954
3955 UtopiaInstanceGetModule(pInstance, &pModule);
3956
3957 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3958 {
3959 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3960 }
3961 else
3962 {
3963 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
3964 {
3965 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
3966 }
3967 else
3968 {
3969 pCECResourcePrivate->MyPhysicalAddress2[0] = pdata[0];
3970 pCECResourcePrivate->MyPhysicalAddress2[1] = pdata[1];
3971 }
3972 }
3973
3974 UtopiaResourceRelease(pCECResource);
3975 }
3976
3977 //**************************************************************************
3978 // [Function Name]:
3979 // MDrv_CEC_SetInitiator()
3980 // [Description]
3981 //
3982 // [Arguments]:
3983 //
3984 // [Return]:
3985 //
3986 //**************************************************************************
3987 void MDrv_CEC_SetInitiator(void* pInstance, MsCEC_DEVICELA IniLA)
3988 {
3989 void* pModule = NULL;
3990 void* pCECResource = NULL;
3991 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
3992
3993 UtopiaInstanceGetModule(pInstance, &pModule);
3994
3995 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
3996 {
3997 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
3998 }
3999 else
4000 {
4001 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
4002 {
4003 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
4004 }
4005 else
4006 {
4007 pCECResourcePrivate->IniLogicalAddress = IniLA ;
4008 }
4009 }
4010
4011 UtopiaResourceRelease(pCECResource);
4012 }
4013
4014 #endif
4015
4016 //**************************************************************************
4017 // [Function Name]:
4018 // MDrv_CEC_AttachISR()
4019 // [Description]
4020 //
4021 // [Arguments]:
4022 //
4023 // [Return]:
4024 //
4025 //**************************************************************************
4026 void MDrv_CEC_AttachDriverISR(void* pInstance, MS_BOOL bAttachDrvFlag)
4027 {
4028 void* pModule = NULL;
4029 void* pCECResource = NULL;
4030 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
4031
4032 UtopiaInstanceGetModule(pInstance, &pModule);
4033
4034 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
4035 {
4036 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
4037 }
4038 else
4039 {
4040 if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
4041 {
4042 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
4043 }
4044 else
4045 {
4046 if(pCECResourcePrivate->ucInitialIndex != 0xA5)
4047 {
4048 _MDrv_CEC_InitVariable(pCECResourcePrivate);
4049
4050 pCECResourcePrivate->ucInitialIndex = 0xA5;
4051 }
4052
4053 pCECResourcePrivate->bAttachDrvISR = bAttachDrvFlag;
4054 }
4055 }
4056
4057 UtopiaResourceRelease(pCECResource);
4058 }
4059
4060 //**************************************************************************
4061 // [Function Name]:
4062 // MDrv_CEC_GetConfiguration()
4063 // [Description]
4064 // CEC get init config
4065 // [Arguments]:
4066 //
4067 // [Return]:
4068 //
4069 //**************************************************************************
4070 stCEC_INITIAL_CONFIG_INFO MDrv_CEC_GetConfiguration(void* pInstance)
4071 {
4072 void* pModule = NULL;
4073 void* pCECResource = NULL;
4074 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
4075 stCEC_INITIAL_CONFIG_INFO stInitialConfigInfo = {0};
4076
4077 stInitialConfigInfo.ulReturnValue = UTOPIA_STATUS_ERR_NOT_AVAIL;
4078
4079 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
4080 {
4081 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
4082 }
4083 else if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
4084 {
4085 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
4086 }
4087 else
4088 {
4089 _MDrv_CEC_init_riu_base(pCECResourcePrivate);
4090
4091 if(pCECResourcePrivate->bCecInitFinish)
4092 {
4093 stInitialConfigInfo.ulReturnValue = UTOPIA_STATUS_SUCCESS;
4094 stInitialConfigInfo.bAttachDrvISR = pCECResourcePrivate->bAttachDrvISR;
4095 stInitialConfigInfo.ulXTAL_CLK_Hz = pCECResourcePrivate->ulXTAL_CLK_Hz;
4096 }
4097 }
4098
4099 UtopiaResourceRelease(pCECResource);
4100 return stInitialConfigInfo;
4101 }
4102
4103 #ifdef CONFIG_UTOPIA_PROC_DBG_SUPPORT
4104 //**************************************************************************
4105 // [Function Name]:
4106 // mdrv_CEC_MDCMDEchoCommand()
4107 // [Description]
4108 // CEC MDCMD echo command function
4109 // [Arguments]:
4110 //
4111 // [Return]:
4112 //
4113 //**************************************************************************
4114 void mdrv_CEC_MDCMDEchoCommand(void* pInstance, MS_U64* u64ReqHdl, char* pcCmdLine)
4115 {
4116 char pch[] = "=,";
4117 char* psep;
4118
4119 MdbPrint(u64ReqHdl, "LINE:%d, MDBCMD_CMDLINE\n", __LINE__);
4120 MdbPrint(u64ReqHdl, "pcCmdLine: %s\n", pcCmdLine);
4121
4122 psep = strsep(&pcCmdLine, pch);
4123
4124 if(strncmp("CECOn", psep, 5) == 0)
4125 {
4126
4127 }
4128 }
4129
4130 //**************************************************************************
4131 // [Function Name]:
4132 // mdrv_CEC_MDCMDGetInfo()
4133 // [Description]
4134 // CEC MDCMD get info function
4135 // [Arguments]:
4136 //
4137 // [Return]:
4138 //
4139 //**************************************************************************
4140 void mdrv_CEC_MDCMDGetInfo(void* pInstance, MS_U64* u64ReqHdl)
4141 {
4142 void* pModule = NULL;
4143 void* pCECResource = NULL;
4144 CEC_RESOURCE_PRIVATE *pCECResourcePrivate = NULL;
4145
4146 if(UtopiaResourceObtain(pModule, CEC_POOL, &pCECResource) != UTOPIA_STATUS_SUCCESS)
4147 {
4148 MDRV_CEC_MSG_ERROR("[%s,%5d] UtopiaResourceObtainToInstant failed\n", __FUNCTION__, __LINE__);
4149 }
4150 else if(UtopiaResourceGetPrivate(pCECResource, (void*)&pCECResourcePrivate) != UTOPIA_STATUS_SUCCESS)
4151 {
4152 MDRV_CEC_MSG_ERROR("[%s,%5d] Get CEC resource failed\n", __FUNCTION__, __LINE__);
4153 }
4154 else
4155 {
4156 MdbPrint(u64ReqHdl, "LINE:%d, MDBCMD_GETINFO\n", __LINE__);
4157 MdbPrint(u64ReqHdl, "---------------- Mstar CEC Info -----------------\n");
4158 #if ENABLE_CEC_MULTIPLE
4159 MdbPrint(u64ReqHdl,"Logical Address: %d\n",pCECResourcePrivate->IniLogicalAddress);
4160 #else
4161 MdbPrint(u64ReqHdl,"Logical Address: %d\n",pCECResourcePrivate->MyLogicalAddress);
4162 #endif
4163 }
4164
4165 UtopiaResourceRelease(pCECResource);
4166 }
4167
4168 #endif
4169