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 #define _HAL_EMMFLT_C
94
95 ////////////////////////////////////////////////////////////////////////////////
96 /// @file halEMMflt.c
97 /// @author MStar Semiconductor Inc.
98 /// @brief
99 ////////////////////////////////////////////////////////////////////////////////
100
101 ////////////////////////////////////////////////////////////////////////////////
102 // Header Files
103 ////////////////////////////////////////////////////////////////////////////////
104 #include "MsCommon.h"
105 #include "MsTypes.h"
106 #include "drvEMMFlt.h"
107 #include "halEMMflt.h"
108 #include "regEMMflt.h"
109 #include "../../include/drvNSK2Type.h"
110 #include "MsIRQ.h"
111
112 ////////////////////////////////////////////////////////////////////////////////
113 // Define & data type
114 ///////////////////////////////////////////////////////////////////////////////
115 //0x113c for emm filter..
116
117 //0x100B
118 #define CLKGEN0_REG(addr) (*((volatile MS_U16*)(_gCLKGEN0_Addr + ((addr)<<2))))
119
120 //0x100A
121 #define CLKGEN2_REG(addr) (*((volatile MS_U16*)(_gCLKGEN2_Addr + ((addr)<<2))))
122
123 //bank 0x101E
124 #define CHIP_REG(addr) (*((volatile MS_U16*)(_gCHIPTOP_Addr + ((addr)<<2))))
125
126 //bank 0x1137
127 #define PVR0_REG(addr) (*((volatile MS_U16*)(_gPVR0_Addr + ((addr)<<2))))
128
129 //bank 0x19xx
130 #define OTP_REG(addr) (*((volatile MS_U32*)(_gOTP_Addr + addr )))
131
132 //bank 0x1713
133 #define OTP_CTRL_REG(addr) (*((volatile MS_U32*)(_gOTP_CTRL_Addr + (addr<<2) )))
134
135
136 #define EMM_IRQ_INT E_INT_IRQ_RASP
137
138
139 static MS_U32 _g32EMMHalDbgLv = EMM_DBGLV_INFO;
140
141 #define HALEMM_DBG(lv, x, args...) if (lv <= _g32EMMHalDbgLv ) \
142 {printf(x, ##args);}
143
144
145 #define ConnectionCheck(x) { if(x>EMMENG_NUMBER) \
146 { printf("only one emm allow\n"); \
147 return FALSE;} }
148
149
150 ////////////////////////////////////////////////////////////////////////////////
151 // Local variable
152 ////////////////////////////////////////////////////////////////////////////////
153
154 //static MS_U32 _gEMMflt_BankAddr = 0;
155 static MS_U32 _gEMMflt_Addr[EMMENG_NUMBER];
156 static MS_U32 _gBasicAddr = 0;
157 static MS_U32 _gOTP_Addr = 0;
158 static MS_U32 _gOTP_CTRL_Addr = 0;
159 static MS_U32 _gPVR0_Addr = 0;
160 static MS_U32 _gCLKGEN0_Addr = 0;
161 static MS_U32 _gCLKGEN2_Addr = 0;
162 static MS_U32 _gCHIPTOP_Addr = 0;
163
164 ////////////////////////////////////////////////////////////////////////////////
165 // Global variable
166 ////////////////////////////////////////////////////////////////////////////////
167
168
169
170 ////////////////////////////////////////////////////////////////////////////////
171 // Extern Function
172 ////////////////////////////////////////////////////////////////////////////////
173
174 ////////////////////////////////////////////////////////////////////////////////
175 // Function Declaration
176 ////////////////////////////////////////////////////////////////////////////////
177 void PrintSetting(void);
178
179 ////////////////////////////////////////////////////////////////////////////////
180 // Local Function
181 ////////////////////////////////////////////////////////////////////////////////
182
HAL_EMMFLT_WriteReg_Word(MS_U32 connection,MS_U32 u32RegAddr,MS_U16 u16Data)183 static void HAL_EMMFLT_WriteReg_Word(MS_U32 connection, MS_U32 u32RegAddr, MS_U16 u16Data)
184 {
185 MS_U32 u32reg;
186 u32reg = (u32RegAddr*4) + _gEMMflt_Addr[connection];
187 (*(volatile MS_U16*)(u32reg)) = u16Data;
188 }
189
HAL_EMMFLT_ReadReg_Word(MS_U32 connection,MS_U32 u32RegAddr)190 static MS_U16 HAL_EMMFLT_ReadReg_Word(MS_U32 connection, MS_U32 u32RegAddr)
191 {
192 MS_U32 u32reg;
193 MS_U16 u16Data;
194 u32reg = (u32RegAddr*4) + _gEMMflt_Addr[connection];
195 u16Data = (*(volatile MS_U16*)(u32reg));
196
197 return u16Data;
198 }
199
HAL_EMMFLT_WriteReg_Dword(MS_U32 connection,MS_U32 u32RegAddr,MS_U32 u32Data)200 static void HAL_EMMFLT_WriteReg_Dword(MS_U32 connection, MS_U32 u32RegAddr, MS_U32 u32Data)
201 {
202 MS_U32 u32reg;
203
204 u32reg = (u32RegAddr*4) + _gEMMflt_Addr[connection];
205 (*(volatile MS_U16*)(u32reg)) = (MS_U16)(u32Data&0xffff);
206
207 u32reg += 4;
208 (*(volatile MS_U16*)(u32reg)) = (MS_U16)((u32Data>>16)&0xffff);
209 }
210
HAL_EMMFLT_ReadReg_Dword(MS_U32 connection,MS_U32 u32RegAddr)211 static MS_U32 HAL_EMMFLT_ReadReg_Dword(MS_U32 connection, MS_U32 u32RegAddr)
212 {
213 MS_U32 u32reg,u32Data;
214 MS_U16 u16Data1,u16Data2;
215
216 u32reg = (u32RegAddr*4) + _gEMMflt_Addr[connection];
217 u16Data1 = (*(volatile MS_U16*)(u32reg));
218
219 u32reg += 4;
220 u16Data2 = (*(volatile MS_U16*)(u32reg));
221 u32Data = (u16Data1) + ((MS_U32)u16Data2<<16);
222
223 return u32Data;
224 }
225
226 ////////////////////////////////////////////////////////////////////////////////
227 // Global Function
228 ////////////////////////////////////////////////////////////////////////////////
229
HAL_EMMFLT_SetBank(MS_U32 u32Base)230 void HAL_EMMFLT_SetBank(MS_U32 u32Base)
231 {
232 MS_U16 u16I,u16J;
233 MS_U16 u16Data;
234
235 HALEMM_DBG(EMM_DBGLV_INFO, "%s: u32Base = 0x%x\n", __FUNCTION__, u32Base);
236
237 _gBasicAddr = u32Base;
238
239 _gEMMflt_Addr[0] = _gBasicAddr + REG_EMMFLT_BASE1;
240 _gEMMflt_Addr[1] = _gBasicAddr + REG_EMMFLT_BASE2;
241
242 _gOTP_Addr = _gBasicAddr + REG_OTP_BASE;
243 _gOTP_CTRL_Addr = _gBasicAddr + REG_OTP_CTRL_BASE;
244 _gPVR0_Addr = _gBasicAddr + REG_PVR0_BASE;
245 _gCHIPTOP_Addr= _gBasicAddr + REG_CHIPTOP_BASE;
246 _gCLKGEN0_Addr= _gBasicAddr + REG_CLKGEN0_BASE;
247 _gCLKGEN2_Addr= _gBasicAddr + REG_CLKGEN2_BASE;
248
249
250 HALEMM_DBG(EMM_DBGLV_INFO,"_gBasicAddr = %x, _gEMMflt_Addr[0] = %x, _gEMMflt_Addr[1] = %x\n",_gBasicAddr,_gEMMflt_Addr[0],_gEMMflt_Addr[1]);
251 HALEMM_DBG(EMM_DBGLV_INFO,"_gCHIPTOP_Addr = %x, _gCLKGEN0_Addr = %x\n",_gCHIPTOP_Addr,_gCLKGEN0_Addr);
252 HALEMM_DBG(EMM_DBGLV_INFO,"int ctrl addr = %x\n", (_gBasicAddr+ (0x101900<<1) ));
253
254 for( u16J=0; u16J<EMMENG_NUMBER; u16J++ )
255 {
256 for(u16I=0; u16I<=REG_EMM_TSIF_LOCKED_CNT_STATUS; u16I++)
257 {
258 u16Data = HAL_EMMFLT_ReadReg_Word(u16J,u16I);
259 HALEMM_DBG(EMM_DBGLV_ARRAY, " %x = %x \n",u16I,u16Data);
260 }
261 }
262
263 }
264
265 #define FileInTest
266
HAL_EMMFLT_FileInSet(void)267 static void HAL_EMMFLT_FileInSet(void)
268 {
269 //MS_U32 u32Addr;
270 MS_U16 u16Data,i;
271
272 HALEMM_DBG(EMM_DBGLV_INFO, "CHIP_REG(0x2) = %x\n",CHIP_REG(0x2));
273 HALEMM_DBG(EMM_DBGLV_INFO, "CHIP_REG(0x3A) = %x\n",CHIP_REG(0x3A));
274
275 #if 0
276 HALEMM_DBG(0, "CHIP_REG(0x2A) = %x\n",CHIP_REG(0x2A));
277 HALEMM_DBG(0, "CHIP_REG(0x28) = %x\n",CHIP_REG(0x28));
278 HALEMM_DBG(0, "CHIP_REG(0x29) = %x\n",CHIP_REG(0x29));
279
280
281 if(CHIP_REG(0x29) != 0)
282 {
283 CHIP_REG(0x29) = 0;
284 }
285 #endif
286
287 for( i=0 ; i<EMMENG_NUMBER ; i++ )
288 {
289 u16Data = HAL_EMMFLT_ReadReg_Word(i,REG_EMM_CTRL0_L);
290
291 #if 0 //file in and bypass
292 HALEMM_DBG(EMM_DBGLV_INFO, "File in and bypass\n");
293 u16Data |= (EMM_FW_FILEIN | EMM_FLT_BYPASS);
294 #else //file in only
295 HALEMM_DBG(EMM_DBGLV_INFO, "File in only\n");
296 u16Data |= (EMM_FW_FILEIN);
297 #endif
298
299 HAL_EMMFLT_WriteReg_Word(i,REG_EMM_CTRL0_L, u16Data);
300 }
301
302
303 }
304
HAL_EMMFLT_LiveInSet(void)305 static void HAL_EMMFLT_LiveInSet(void)
306 {
307 MS_U16 u16Data,i;
308
309 for( i=0 ; i<EMMENG_NUMBER ; i++ )
310 {
311 u16Data = HAL_EMMFLT_ReadReg_Word(i,REG_EMM_CTRL0_L);
312 u16Data &= ~(EMM_FW_FILEIN);
313
314 HAL_EMMFLT_WriteReg_Word(i,REG_EMM_CTRL0_L, u16Data);
315 }
316
317 }
318
HAL_EMMFLT_SrcSelect(MS_U32 connection,MS_U32 u32SrcFrom,MS_U32 u32SrcType)319 MS_U32 HAL_EMMFLT_SrcSelect(MS_U32 connection, MS_U32 u32SrcFrom, MS_U32 u32SrcType)
320 {
321
322 //CLKGEN0 bank, [0x29]_bit[11:8]=4'h8
323 //CLKGEN0_REG(0x29) = ( CLKGEN0_REG(0x29) & 0xf0ff ) | 0x800 ;
324
325 HALEMM_DBG(EMM_DBGLV_INFO,"Enter %s.....\n",__FUNCTION__);
326
327 //[0x1137]_[0x1e]_[9] = 0
328 //[0x101e]_[0x3a]_[6:4] = 3'b100: from demod0
329 //[0x101e]_[0x43]_[15:0] = 16'h8000: reg_miu_wc_bypass
330 //[0x101e]_[0x44]_[15:0] = 16'h0003: reg_miu_wc_bypass
331 //[0x101e]_[0x02]_[7:0] = 8'h11 (reg_ts1_mode = 1, reg_ts0_mode=1)
332 //[0x100b]_[0x2f]_[12:8] = 5'b100_00 : clk_ts6_p
333 //[0x100b]_[0x2a]_[4:0] = 5'b010_00 : clk_tsp
334 //[0x1015]_[0x7a]_[15:0] = 16'h0002 software reset
335
336
337 MS_U32 addr;
338 MS_U16 u16Reg;
339
340 #if 1
341 addr = _gBasicAddr + (0x101200*2 + 0x18*4); // MIU_EN
342 (*((volatile MS_U16*)(addr))) = 0xffff;
343
344 addr = _gBasicAddr + (0x161300*2 + 0x00*4); //$ enable MIUCrossbar
345 (*((volatile MS_U16*)(addr))) = 0x000f;
346 #endif
347
348
349 MsOS_DelayTask(1);
350 PrintSetting();
351
352
353 //connection needs to modify for K3
354 if(u32SrcFrom == EMM_SRC_FILEIN)
355 {
356 HAL_EMMFLT_FileInSet();
357 }
358 else //EMM_LIVEIN
359 {
360 HAL_EMMFLT_LiveInSet();
361
362 // TS PAD setting
363 u16Reg = CHIP_REG (0x39);
364 u16Reg &= (~0xf00 << (connection << 2));
365 u16Reg |= (u32SrcType << (8 + (connection << 2)));
366 CHIP_REG (0x39) = u16Reg;
367 // Clock source setting
368 u16Reg = CLKGEN2_REG (0x04 + connection);
369 u16Reg &= (~0x001f);
370 u16Reg |= (u32SrcType << 2);
371 CLKGEN2_REG (0x04 + connection) = u16Reg;
372 }
373
374 return TRUE;
375 }
376
377
PrintSetting(void)378 void PrintSetting(void)
379 {
380
381 MS_U32 addr;
382 MS_U16 u16Reg;
383
384
385 #if 0
386
387 KERES EMM PADDING
388 //a. reg_ts0_mode : bank_101e_0x02_[2:0] = 3'd001; //TS0 Mode
389 u16Reg = CHIP_REG(0x02);
390 u16Reg = (u16Reg & ~0x0007) | 0x1;
391 CHIP_REG(0x02) = u16Reg;
392
393 //b. reg_ckg_ts4 : bank_100b_0x26_[3:0] = 4'b0;
394 //clk source for ts4: ts0_clk
395 u16Reg = CLKGEN0_REG(0x26);
396 u16Reg = (u16Reg & ~0x000f) | 0x0;
397 CLKGEN0_REG(0x26) = u16Reg;
398
399 //c. reg_ckg_ts5 : bank_100b_0x26_[11:8] = 4'b0;
400 //clk source for ts5: ts0_clk
401 u16Reg = CLKGEN0_REG(0x26);
402 u16Reg = (u16Reg & ~0x0f00) | 0x0;
403 CLKGEN0_REG(0x26) = u16Reg;
404
405 //d. reg_emmflt0_mux: bank_101e_0x39_[10:8] = 3'd000
406 //Source Selections for EMMFLT Channel 0: come from PAD_TS0
407 u16Reg = CHIP_REG(0x39);
408 u16Reg = (u16Reg & ~0x0700) | 0x0;
409 CHIP_REG(0x39) = u16Reg;
410
411 //e. reg_emmflt1_mux: bank_101e_0x39_[14:12] = 3'd000
412 //Source Selections for EMMFLT Channel 1: come from PAD_TS0
413 u16Reg = CHIP_REG(0x39);
414 u16Reg = (u16Reg & ~0x7000) | 0x0;
415 CHIP_REG(0x39) = u16Reg;
416
417 #endif
418
419 u16Reg = CHIP_REG(0x2);
420 HALEMM_DBG(EMM_DBGLV_DEBUG, "CHIP 0x2 = %x\n", u16Reg);
421
422 u16Reg = CHIP_REG(0x39);
423 HALEMM_DBG(EMM_DBGLV_DEBUG, "CHIP 0x39 = %x\n", u16Reg);
424
425 u16Reg = CLKGEN0_REG(0x26);
426 HALEMM_DBG(EMM_DBGLV_DEBUG, "CLKGEN0 0x26 = %x\n", u16Reg);
427
428
429 addr = _gBasicAddr + (0x101500*2 + 0x7a*4);
430 u16Reg = (*((volatile MS_U16*)(addr)));
431 HALEMM_DBG(EMM_DBGLV_DEBUG, "(TSP0, 0x101500*2 + 0x7a*4) = %x\n", u16Reg);
432
433 #if 0
434 addr = _gBasicAddr + (0x113700*2 + 0x1e*4);
435 u16Reg = (*((volatile MS_U16*)(addr)));
436 HALEMM_DBG(EMM_DBGLV_DEBUG, "(0x113700*2 + 0x1e*4) = %x\n", u16Reg);
437 #endif
438 }
439
440
HAL_EMMFLT_Init(void)441 MS_U32 HAL_EMMFLT_Init(void)
442 {
443 MS_U16 u16Data;
444 MS_U32 i;
445
446 for( i=0 ; i<EMMENG_NUMBER ; i++ )
447 {
448 u16Data = HAL_EMMFLT_ReadReg_Word(i,REG_EMM_RESET);
449
450 u16Data |= EMM_RESET_UNLOCK;
451 HAL_EMMFLT_WriteReg_Word(i,REG_EMM_RESET, u16Data);
452 }
453
454 for( i=0 ; i<EMMENG_NUMBER ; i++ )
455 {
456 u16Data = HAL_EMMFLT_ReadReg_Word(i,REG_EMM_STR2MIU_EN);
457 u16Data |= EMM_STR2MIU_EN;
458 HAL_EMMFLT_WriteReg_Word(i, REG_EMM_STR2MIU_EN, u16Data); //string 2 miu enable
459
460 HALEMM_DBG(EMM_DBGLV_INFO, "enable stream to miu \n");
461
462 //designer suggest setting....still needs to confirm
463
464 HAL_EMMFLT_WriteReg_Word(i, REG_EMM_TS_IF2_CTRL, 0x80e1);
465 //HAL_EMMFLT_WriteReg_Word(i, REG_EMM_TS_IF2_CTRL, 0x8fe1); //DEBUG
466 }
467
468 return TRUE;
469 }
470
HAL_EMMFLT_GetHwBufCnt(MS_U32 * pHwBufCnt)471 MS_U32 HAL_EMMFLT_GetHwBufCnt(MS_U32 *pHwBufCnt)
472 {
473 *pHwBufCnt = EMMFLT_HWBUF_NUM;
474 return TRUE;
475 }
476
477 //does connection needs to be increased.
HAL_EMMFLT_SWReset(MS_U32 connection)478 MS_U32 HAL_EMMFLT_SWReset(MS_U32 connection)
479 {
480 MS_U16 u16Data;
481
482 u16Data = HAL_EMMFLT_ReadReg_Word(connection,REG_EMM_RESET);
483 u16Data &= (~EMM_RESET_UNLOCK);
484
485 HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_RESET, u16Data);
486
487 u16Data |= EMM_RESET_UNLOCK;
488 HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_RESET, u16Data);
489
490 return TRUE;
491 }
492
HAL_EMMFLT_SetDbgLevel(MS_U32 u32Level)493 MS_U32 HAL_EMMFLT_SetDbgLevel(MS_U32 u32Level)
494 {
495 _g32EMMHalDbgLv = u32Level;
496 HALEMM_DBG(EMM_DBGLV_DEBUG, "%s level: %x\n", __FUNCTION__, u32Level);
497 return TRUE;
498 }
499
500
HAL_EMMFLT_SetOutputType(MS_U32 connection,MS_U32 u32Type)501 MS_U32 HAL_EMMFLT_SetOutputType(MS_U32 connection, MS_U32 u32Type)
502 {
503 MS_U16 u16Data;
504
505 HALEMM_DBG(EMM_DBGLV_INFO, "SetOutputType conn = %x, Type = %x \n",connection,u32Type);
506 if(u32Type == EMM_OUT_NORMAL)
507 {
508 u16Data = HAL_EMMFLT_ReadReg_Word(connection,REG_EMM_GENERAL_CTRL_L);
509 u16Data &= ~(__BIT2);
510 HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_GENERAL_CTRL_L, u16Data);
511 }
512 else if(u32Type == EMM_OUT_184BYTES)
513 {
514
515 }
516 else if(u32Type == EMM_OUT_PACKETNUM)
517 {
518 u16Data = HAL_EMMFLT_ReadReg_Word(connection,REG_EMM_GENERAL_CTRL_L);
519 u16Data |= (__BIT2);
520 HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_GENERAL_CTRL_L, u16Data);
521 }
522 return TRUE;
523 }
524
HAL_EMMFLT_Enable_Int(void)525 MS_U32 HAL_EMMFLT_Enable_Int(void)
526 {
527 MS_U32 i;
528
529 HALEMM_DBG(EMM_DBGLV_INFO, "EMMFLT_Enable_Int\n");
530 for( i=0 ; i<EMMENG_NUMBER ; i++ )
531 {
532 //HAL_EMMFLT_WriteReg_Word(REG_EMM_CA_INT,0);
533 //HAL_EMMFLT_WriteReg_Word( i, 0x0075, 0x3);
534 HAL_EMMFLT_WriteReg_Word( i, REG_EMM_CA_INT, (EMM_ONEPAKCET_INT | EMM_OVERFLOW_INT));
535 }
536 return TRUE;
537 }
538
HAL_EMMFLT_GetIntNumber(void)539 MS_U32 HAL_EMMFLT_GetIntNumber(void)
540 {
541 return EMM_IRQ_INT;
542 }
543
HAL_EMMFLT_GetIntMode(void)544 MS_BOOL HAL_EMMFLT_GetIntMode(void)
545 {
546 //share interrupt.
547 return TRUE;
548 }
549
550
551
HAL_EMMFLT_SetTidMode(MS_U32 connection,MS_U8 u8TidValue,EMM_TIDMODE_e eTIDMODE)552 MS_U32 HAL_EMMFLT_SetTidMode(MS_U32 connection, MS_U8 u8TidValue, EMM_TIDMODE_e eTIDMODE)
553 {
554
555 MS_U32 u32Data;
556
557 ConnectionCheck(connection);
558
559 u32Data = HAL_EMMFLT_ReadReg_Dword(connection,REG_EMM_TID_MODE_L);
560
561 u32Data &= ~((MS_U32)E_TIDMODE_RESERVED<<u8TidValue);
562 u32Data |= ((MS_U32)eTIDMODE<<u8TidValue);
563
564
565 HAL_EMMFLT_WriteReg_Dword(connection,REG_EMM_TID_MODE_L,u32Data);
566 HALEMM_DBG(EMM_DBGLV_INFO, "%s SetTidMode value : %x\n", __FUNCTION__, u32Data);
567 return TRUE;
568 }
569
HAL_EMMFLT_SetIRDMode(MS_U32 connection,MS_U8 u8IRDNum,MS_U8 u8CompareMode)570 MS_U32 HAL_EMMFLT_SetIRDMode(MS_U32 connection,MS_U8 u8IRDNum, MS_U8 u8CompareMode)
571 {
572 MS_U16 u16Mask,u16Data;
573
574 ConnectionCheck(connection);
575 if(u8CompareMode > REG_EMM_CTRL_MAX)
576 {
577 return HAL_EMMFLT_INVALID_REQUEST;
578 }
579
580 if(u8IRDNum > REG_EMM_IRD_MAX)
581 {
582 return HAL_EMMFLT_INVALID_REQUEST;
583 }
584
585 HALEMM_DBG(EMM_DBGLV_INFO, "%s u8IRDNum= %d, u8CompareMode = %d\n", __FUNCTION__, u8IRDNum, u8CompareMode );
586 u16Mask = (EMM_IRD_REG_MASK << (u8IRDNum*2));
587
588 u16Data = HAL_EMMFLT_ReadReg_Word(connection,REG_EMM_CTRL_ID);
589
590 HALEMM_DBG(EMM_DBGLV_INFO, "REG_EMM_CTRL_ID = %x\n",u16Data);
591 u16Data &= ~u16Mask;
592
593
594 u16Data |= (u8CompareMode << (u8IRDNum*2));
595 HALEMM_DBG(EMM_DBGLV_INFO, "%s u16Data= %x \n", __FUNCTION__, u16Data);
596 HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_CTRL_ID, u16Data);
597
598 return TRUE;
599 }
600
601
HAL_EMMFLT_SetEmmDataIDx(MS_U32 connection,MS_U8 u8IRDNum,MS_U8 * pu8Data)602 MS_U32 HAL_EMMFLT_SetEmmDataIDx(MS_U32 connection, MS_U8 u8IRDNum, MS_U8 *pu8Data)
603 {
604 MS_U32 u32IRDAddr,u32EMMAddr;
605 MS_U32 u32Mapping[] = {REG_EMM_DATA_ID1_L, REG_EMM_DATA_ID2_L,
606 REG_EMM_DATA_ID3_L, REG_EMM_DATA_ID4_L,
607 REG_EMM_DATA_ID5_L, REG_EMM_DATA_ID6_L,
608 REG_EMM_DATA_ID7_L, REG_EMM_DATA_ID8_L, };
609
610
611 ConnectionCheck(connection);
612
613 u32EMMAddr = ((MS_U32)pu8Data[0]<<24) + ((MS_U32)pu8Data[1]<<16) +
614 ((MS_U32)pu8Data[2]<<8) + ((MS_U32)pu8Data[3]) ;
615
616
617 HALEMM_DBG(EMM_DBGLV_INFO, "%s u8IRDNum= %x, u32EMMAddr = %x\n", __FUNCTION__, u8IRDNum, u32EMMAddr);
618
619 if(u8IRDNum >= REG_EMM_IRD_MAX)
620 {
621 return HAL_EMMFLT_INVALID_REQUEST;
622 }
623
624
625 u32IRDAddr = u32Mapping[u8IRDNum];
626
627 HAL_EMMFLT_WriteReg_Dword(connection,u32IRDAddr,u32EMMAddr);
628
629 return TRUE;
630 }
631
HAL_EMMFLT_SetEmmMaskIDx(MS_U32 connection,MS_U8 u8IRDNum,MS_U8 * pu8Data)632 MS_U32 HAL_EMMFLT_SetEmmMaskIDx(MS_U32 connection,MS_U8 u8IRDNum, MS_U8 *pu8Data)
633 {
634 MS_U32 u32IRDAddr,u32EMMMask;
635 MS_U32 u32Mapping[] = {REG_EMM_MASK_ID1_L, REG_EMM_MASK_ID2_L,
636 REG_EMM_MASK_ID3_L, REG_EMM_MASK_ID4_L,
637 REG_EMM_MASK_ID5_L, REG_EMM_MASK_ID6_L,
638 REG_EMM_MASK_ID7_L, REG_EMM_MASK_ID8_L, };
639
640
641 ConnectionCheck(connection);
642
643 u32EMMMask = ((MS_U32)pu8Data[0]<<24) + ((MS_U32)pu8Data[1]<<16) +
644 ((MS_U32)pu8Data[2]<<8) + ((MS_U32)pu8Data[3]) ;
645 HALEMM_DBG(EMM_DBGLV_INFO, "%s u8IRDNum= %x, u32EMMMask = %x\n", __FUNCTION__, u8IRDNum, u32EMMMask);
646
647 if(u8IRDNum >= REG_EMM_IRD_MAX)
648 {
649 return HAL_EMMFLT_INVALID_REQUEST;
650 }
651
652
653 u32IRDAddr = u32Mapping[u8IRDNum];
654
655 HAL_EMMFLT_WriteReg_Dword(connection,u32IRDAddr,u32EMMMask);
656
657 return TRUE;
658 }
659
HAL_EMMFLT_DisableEMM(MS_U32 connection)660 MS_U32 HAL_EMMFLT_DisableEMM(MS_U32 connection)
661 {
662 ConnectionCheck(connection);
663
664 HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_PID, 0);
665 return TRUE;
666 }
667
HAL_EMMFLT_SetEmmPID(MS_U32 connection,MS_U16 u16EmmPID)668 MS_U32 HAL_EMMFLT_SetEmmPID(MS_U32 connection,MS_U16 u16EmmPID)
669 {
670 MS_U16 u16Data;
671
672 HALEMM_DBG(EMM_DBGLV_INFO, "EMMFLT_SetEmmPID conn = %x, u16EmmPID = %x \n",connection,u16EmmPID);
673 PrintSetting();
674
675 ConnectionCheck(connection);
676 #if 1
677 u16Data = 0;
678 u16Data = u16EmmPID;
679 #else
680 u16Data = HAL_EMMFLT_ReadReg_Word(connection,REG_EMM_PID);
681
682 u16Data = ( u16Data & ~(REG_EMM_ENABLE_TID | REG_EMM_ENABLE_PID) ) | u16EmmPID;
683 #endif
684 HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_PID, u16Data);
685 return TRUE;
686 }
687
HAL_EMMFLT_SetEmmTID(MS_U32 connection,MS_U16 u16EmmTID)688 MS_U32 HAL_EMMFLT_SetEmmTID(MS_U32 connection,MS_U16 u16EmmTID)
689 {
690 HALEMM_DBG(EMM_DBGLV_INFO, "EMMFLT_SetEmmTID conn = %x, u16EmmTID = %x \n",connection,u16EmmTID);
691 ConnectionCheck(connection);
692 HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_TID, u16EmmTID);
693 return TRUE;
694 }
695
HAL_EMMFLT_EnableEmmTID(MS_U32 connection,MS_BOOL bEnable)696 MS_U32 HAL_EMMFLT_EnableEmmTID(MS_U32 connection, MS_BOOL bEnable)
697 {
698 MS_U16 u16Data;
699
700 HALEMM_DBG(EMM_DBGLV_INFO, "EMMFLT_EnableEmmTID conn = %x, bEnable = %x \n",connection,bEnable);
701 ConnectionCheck(connection);
702 u16Data = HAL_EMMFLT_ReadReg_Word(connection,REG_EMM_PID);
703
704 if(TRUE == bEnable)
705 {
706 u16Data |= REG_EMM_ENABLE_TID;
707 }
708 else
709 {
710 u16Data &= (~REG_EMM_ENABLE_TID);
711 }
712
713 HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_PID, u16Data);
714
715 return TRUE;
716 }
717
718
HAL_EMMFLT_ResetInt(MS_U32 connection)719 MS_U32 HAL_EMMFLT_ResetInt(MS_U32 connection)
720 {
721 MS_U16 u16Data;
722
723 HALEMM_DBG(EMM_DBGLV_ERR, "EMMFLT_ResetInt conn = %x\n",connection);
724
725 u16Data = HAL_EMMFLT_ReadReg_Word(connection,REG_EMM_CA_INT);
726
727 u16Data |= EMM_RESET_INT;
728
729 HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_CA_INT, u16Data);
730
731 return TRUE;
732 }
733
734 #if 0
735 MS_U32 HAL_EMMFLT_GetIntReg(MS_U16 *pu16Data)
736 {
737 MS_U16 u16Data = 0,u16I;
738 *pu16Data = 0;
739
740 for( u16I=0 ; u16I<EMMENG_NUMBER ; u16I++)
741 {
742 u16Data = HAL_EMMFLT_ReadReg_Word( u16I, REG_EMM_CA_INT );
743 *pu16Data = u16Data & (EMM_ONEPAKCET_INT | EMM_OVERFLOW_INT);
744 }
745
746 return TRUE;
747 }
748 #endif
749
HAL_EMMFLT_GetIntStatus(MS_U16 * pu16EMMInt,MS_U16 * pu16IntStat,MS_U8 * pu8conflag)750 MS_U32 HAL_EMMFLT_GetIntStatus(MS_U16 *pu16EMMInt, MS_U16 *pu16IntStat, MS_U8 *pu8conflag)
751 {
752 MS_U16 u16Data,i;
753
754 for( i=0; i<EMMENG_NUMBER ; i++)
755 {
756 pu8conflag[i] = FALSE;
757 u16Data = HAL_EMMFLT_ReadReg_Word(i,REG_EMM_CA_INT);
758 HALEMM_DBG(EMM_DBGLV_DEBUG, "%s i= %x, u16Data = %x\n", __FUNCTION__, i, u16Data);
759
760 //that means the first emm has interrupt....
761 if( (u16Data & EMMFLT_EMM_OVERFLOW_INT) || (u16Data & EMMFLT_EMM_INT) )
762 {
763 pu8conflag[i] = TRUE;
764 pu16IntStat[i] = (u16Data & EMM_INT_MASK) ;
765 pu16EMMInt[i] = u16Data;
766 }
767 }
768 HALEMM_DBG(EMM_DBGLV_DEBUG, "Int status = %x\n",u16Data);
769
770 return TRUE;
771 }
772
HAL_EMMFLT_GetCurrentBufIndex(MS_U32 connection)773 MS_U32 HAL_EMMFLT_GetCurrentBufIndex(MS_U32 connection)
774 {
775 MS_U32 index = HAL_EMMFLT_ReadReg_Word(connection, REG_EMM_INT_STAT);
776
777 //MS_U32 index = (HAL_EMMFLT_ReadReg_Word(connection, REG_EMM_CA_INT)>>8);
778 HALEMM_DBG(EMM_DBGLV_INFO, "current index = %x\n",index);
779 return index;
780 }
781
HAL_EMMFLT_ReqDstBufSize(MS_U32 * p32DstBufSize,MS_U32 * p32AlignBytes,MS_U8 * p8BufBum)782 MS_U32 HAL_EMMFLT_ReqDstBufSize(MS_U32 *p32DstBufSize, MS_U32 *p32AlignBytes, MS_U8 *p8BufBum)
783 {
784 *p32DstBufSize = EMMFLT_HWBUF_SIZE;
785 *p32AlignBytes = EMMFLT_BUF_ALIGNMENT;
786 *p8BufBum = EMMENG_NUMBER;
787
788 HALEMM_DBG(EMM_DBGLV_INFO, "ReqDstBufSize HWBUF_SIZE = %x, BUF_ALIGNMENT = %x, EMMENG_NUMBER = %x\n",EMMFLT_HWBUF_SIZE, EMMFLT_BUF_ALIGNMENT,EMMENG_NUMBER);
789 return TRUE;
790 }
791
HAL_EMMFLT_SetDstBufInfo(MS_U32 connection,MS_U32 u32BufAddr,MS_U32 u32BufSize,MS_U32 * p32BufAddrs)792 MS_U32 HAL_EMMFLT_SetDstBufInfo(MS_U32 connection, MS_U32 u32BufAddr, MS_U32 u32BufSize, MS_U32 *p32BufAddrs)
793 {
794 MS_U32 u32I;
795 MS_U16 u16Reg;
796
797 ConnectionCheck(connection);
798 HALEMM_DBG(EMM_DBGLV_INFO, "%s u32BufAddr= %x, u32BufSize= %x \n", __FUNCTION__, u32BufAddr,u32BufSize);
799
800 HAL_EMMFLT_WriteReg_Dword(connection,REG_EMM_STR2MIU_HEAD1_L, (u32BufAddr>>4));
801 HAL_EMMFLT_WriteReg_Dword(connection,REG_EMM_STR2MIU_TAIL1_L, ((u32BufAddr+u32BufSize)>>4));
802 HAL_EMMFLT_WriteReg_Dword(connection,REG_EMM_STR2MIU_MID1_L, ((u32BufAddr+u32BufSize)>>4));
803
804
805 u16Reg = HAL_EMMFLT_ReadReg_Word(connection,REG_EMM_STR2MIU_EN);
806 HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_STR2MIU_EN, (u16Reg | 0x4) );
807
808 HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_STR2MIU_EN,u16Reg);
809
810 for(u32I = 0; u32I<MAX_EMMFLT_NUM ; u32I++)
811 {
812 p32BufAddrs[u32I] = u32BufAddr + (u32I*U01_NDS_EMMFLT_BUF_SIZE);
813 HALEMM_DBG(EMM_DBGLV_INFO, "%s p32BufAddr[%x] = %x, \n", __FUNCTION__, u32I, p32BufAddrs[u32I]);
814 }
815
816 return TRUE;
817 }
818
819
820 //does connection needs to be increased.
HAL_EMMFLT_PacketCount(MS_U32 connection,MS_U8 * pCount)821 MS_U32 HAL_EMMFLT_PacketCount(MS_U32 connection,MS_U8 *pCount)
822 {
823 MS_U16 PacketCnt;
824 PacketCnt = HAL_EMMFLT_ReadReg_Word(connection,REG_EMM_PACKET_CNT);
825 HALEMM_DBG(EMM_DBGLV_INFO, "REG_EMM_PACKET_CNT = %x\n",PacketCnt);
826 *pCount = (MS_U8)((PacketCnt>>8)&0xff);
827 return TRUE;
828 }
829
830
831
832 //does connection needs to be increased.
HAL_EMMFLT_PacketAct(MS_U32 connection)833 MS_U32 HAL_EMMFLT_PacketAct(MS_U32 connection)
834 {
835 #if 0
836 MS_U16 u16Rg;
837 u16Rg = HAL_EMMFLT_ReadReg_Word(connection,REG_EMM_CA_INT);
838 u16Rg = (0x10<<8);
839 HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_CA_INT,u16Rg);
840 #else
841 HALEMM_DBG(EMM_DBGLV_INFO, "HAL_EMMFLT_PacketAct = %x\n",connection);
842 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_INT_STAT,EMM_RECIEVE_ACT);
843 //HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_CA_INT,(EMM_RECIEVE_ACT<<8) + 0x6);
844 #endif
845
846 //MS_U16 u16Data;
847 //MsOS_DelayTaskUs(10);
848
849 //u16Data = HAL_EMMFLT_ReadReg_Word(REG_EMM_INT_STAT);
850
851 //HALEMM_DBG(0, "HAL_EMMFLT_PacketAct = %x\n",u16Data);
852
853 return TRUE;
854 }
855
856
HAL_EMMFLT_IntCtrl(MS_U8 u8En)857 MS_U32 HAL_EMMFLT_IntCtrl(MS_U8 u8En)
858 {
859 MS_U16 u16Data;
860
861 HALEMM_DBG(EMM_DBGLV_INFO, "EMMFLT_IntCtrl u8En = %x\n",u8En);
862
863 u16Data = HAL_EMMFLT_ReadReg_Word(0,REG_EMM_CA_INT);
864
865 if(1 == u8En ) //mask interrupt
866 {
867 u16Data &= (~EMM_RESET_INT);
868 u16Data &= ~(EMM_ONEPAKCET_INT | EMM_OVERFLOW_INT);
869 }
870 else //unmask interrupt....
871 {
872 u16Data &= (~EMM_RESET_INT);
873 u16Data |= (EMM_ONEPAKCET_INT | EMM_OVERFLOW_INT);
874 }
875
876 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_CA_INT, u16Data);
877 return TRUE;
878 }
879
880
HAL_EMMFLT_SetDebugMode(MS_U16 u16Mode)881 MS_U32 HAL_EMMFLT_SetDebugMode(MS_U16 u16Mode)
882 {
883 MS_U16 u16Reg,u16I;
884
885 for(u16I=0; u16I<EMMENG_NUMBER; u16I++)
886 {
887 u16Reg = HAL_EMMFLT_ReadReg_Word(u16I,REG_EMM_TS_IF2_CTRL);
888
889 u16Reg &= ~(REG_EMM_DGB_SEL);
890 u16Reg |= (u16Mode<<8);
891
892 u16Reg |= (0x1<<13);
893 HAL_EMMFLT_WriteReg_Word(u16I,REG_EMM_TS_IF2_CTRL, u16Reg);
894 }
895 return TRUE;
896 }
897
HAL_EMMFLT_GetDebugStatus(MS_U32 * pRegValue)898 MS_U32 HAL_EMMFLT_GetDebugStatus(MS_U32 *pRegValue)
899 {
900 *pRegValue = HAL_EMMFLT_ReadReg_Dword(0,REG_EMM_TS_IF2_DEBUG_L);
901 return TRUE;
902 }
903
904
905 //#define PureFileInOut
906
HAL_EMMFLT_GeneralCtrl(MS_U32 connection)907 MS_U32 HAL_EMMFLT_GeneralCtrl(MS_U32 connection)
908 {
909
910 #if 0
911 u16Data = HAL_EMMFLT_ReadReg_Word(REG_EMM_STR2MIU_EN);
912 u16Data |= REG_STR2MIU_RST_WADR;
913
914 HALEMM_DBG(0, "REG_EMM_STR2MIU_EN = %x\n",(u16Data | REG_STR2MIU_RST_WADR));
915
916 HAL_EMMFLT_WriteReg_Word(REG_EMM_STR2MIU_EN, (u16Data | REG_STR2MIU_RST_WADR) );
917
918 MsOS_DelayTaskUs(1);
919
920 u16Data &= ~(REG_STR2MIU_RST_WADR);
921 HALEMM_DBG(0, "REG_EMM_STR2MIU_EN = %x\n",u16Data);
922 HAL_EMMFLT_WriteReg_Word(REG_EMM_STR2MIU_EN, u16Data);
923 #endif
924
925 #ifdef PureFileInOut
926 MS_U16 u16Data;
927 u16Data = HAL_EMMFLT_ReadReg_Word(connection,REG_EMM_PID);
928 u16Data &= 0x3fff;
929 HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_PID, u16Data);
930 #endif
931
932 //HAL_EMMFLT_WriteReg_Word(REG_EMM_GENERAL_CTRL_L, 0x0004);
933
934 /* select parallel TS interface for TS interface 2 in emm_flt0
935 select exteranl sync for ts_if2 in emm_flt0
936 Set 1 to enable the patch of internal sync in ��tsif�� in emm_flt0
937 set 1 to enable ts_if2 in emm_flt0 */
938 //HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_TS_IF2_CTRL, 0x80e1);
939
940 HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_GENERAL_CTRL_L, 0x0000);
941 HAL_EMMFLT_WriteReg_Word(connection,REG_EMM_GENERAL_CTRL_H, 0x0010); //Bit[23:20]: packet number enable bits for TS3-TS0
942
943 HALEMM_DBG(EMM_DBGLV_ERR, "fire EMM filter\n");
944
945 return TRUE;
946 }
947
HAL_EMMFLT_ConnectCheck(MS_U32 connection)948 MS_U32 HAL_EMMFLT_ConnectCheck(MS_U32 connection)
949 {
950
951 ConnectionCheck(connection);
952 return TRUE;
953 }
954
HAL_EMMFLT_HWSimulation(void)955 MS_U32 HAL_EMMFLT_HWSimulation(void)
956 {
957 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_GENERAL_CTRL_L, 0x0004);
958 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_GENERAL_CTRL_H, 0x0010);
959
960 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_CA_INT, 0x0006);
961 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_TS_IF2_CTRL, 0x80e1);
962
963 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_PID, 0xC000);
964 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_TID, 0x0000);
965
966 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_TID_MODE_L, 0xFFFF);
967 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_TID_MODE_H, 0x0000);
968
969 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_STR2MIU_EN, 0x0002); //string 2 miu enable
970
971 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_STR2MIU_HEAD1_L, 0x0000);
972 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_STR2MIU_HEAD1_H, 0x0000);
973
974 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_STR2MIU_TAIL1_L, 0x006C);
975 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_STR2MIU_TAIL1_H, 0x0000);
976
977 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_STR2MIU_MID1_L, 0x0010);
978 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_STR2MIU_MID1_H, 0x0000);
979
980
981 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_STR2MIU_HEAD2_L, 0x1000);
982 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_STR2MIU_HEAD2_H, 0x0000);
983
984 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_STR2MIU_TAIL2_L, 0x106C);
985 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_STR2MIU_TAIL2_H, 0x0000);
986
987 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_STR2MIU_MID2_L, 0x1010);
988 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_STR2MIU_MID2_H, 0x0000);
989
990 return TRUE;
991 }
992
HAL_EMMFLT_IntStatusTest(void)993 void HAL_EMMFLT_IntStatusTest(void)
994 {
995 MS_U16 CA_INT, INT_STAT;
996
997 CA_INT = HAL_EMMFLT_ReadReg_Word(0,REG_EMM_CA_INT);
998 HALEMM_DBG(EMM_DBGLV_INFO, "REG_EMM_CA_INT = %x\n",CA_INT);
999
1000 INT_STAT = HAL_EMMFLT_ReadReg_Word(0,REG_EMM_INT_STAT);
1001 HALEMM_DBG(EMM_DBGLV_INFO, "REG_EMM_INT_STAT = %x\n",INT_STAT);
1002
1003
1004 if(CA_INT == 0x2)
1005 {
1006 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_INT_STAT,EMM_RECIEVE_ACT);
1007 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_CA_INT,(EMM_RECIEVE_ACT<<8) + 0x6);
1008 }
1009 else if(CA_INT == 0x6)
1010 {
1011 HALEMM_DBG(EMM_DBGLV_INFO, "Buffer overflow\n");
1012 }
1013
1014 }
1015
HAL_EMMFLT_SetExtendConfig(MS_U32 x_connection,MS_U16 type,MS_U16 extendbytes,MS_U16 syncbyte)1016 MS_U32 HAL_EMMFLT_SetExtendConfig(MS_U32 x_connection, MS_U16 type, MS_U16 extendbytes, MS_U16 syncbyte)
1017 {
1018 MS_U16 Reg;
1019
1020 Reg = 0x204;
1021 Reg = (Reg&(~0x1f0)) | ((extendbytes&0x1f)<<4);
1022 printf("EMM HW Config 0 is %x\n",Reg);
1023 HAL_EMMFLT_WriteReg_Word(x_connection,REG_EMM_HW_CONFIG0, 0x02C4);
1024
1025
1026 Reg = HAL_EMMFLT_ReadReg_Word(x_connection,REG_EMM_SYNC_BYTES);
1027
1028 Reg = ((extendbytes + 188)<<0x8) | (syncbyte&0xff);
1029 printf("sync byte reg is %x\n",Reg);
1030 HAL_EMMFLT_WriteReg_Word(x_connection,REG_EMM_SYNC_BYTES, Reg);
1031
1032 return TRUE;
1033 }
1034
HAL_EMMFLT_Bypass(void)1035 MS_U32 HAL_EMMFLT_Bypass(void)
1036 {
1037 MS_U16 Reg;
1038 Reg = HAL_EMMFLT_ReadReg_Word(0,REG_EMM_CTRL0_L);
1039 HAL_EMMFLT_WriteReg_Word(0,REG_EMM_CTRL0_L, (Reg | EMM_FLT_BYPASS) );
1040
1041 return TRUE;
1042 }
1043
HAL_EMMFLT_En192Output(MS_U32 x_connection)1044 MS_U32 HAL_EMMFLT_En192Output(MS_U32 x_connection)
1045 {
1046 MS_U16 Reg;
1047
1048 Reg = HAL_EMMFLT_ReadReg_Word(x_connection,REG_EMM_CTRL0_L);
1049 HAL_EMMFLT_WriteReg_Word(x_connection,REG_EMM_CTRL0_L, (Reg & ~(EMM_PACKET256_EN | EMM_PVR_EN)) );
1050
1051 Reg = HAL_EMMFLT_ReadReg_Word(x_connection,REG_EMM_STR2MIU_CTRL);
1052 HAL_EMMFLT_WriteReg_Word(x_connection,REG_EMM_STR2MIU_CTRL, (Reg | REG_PKT192_EN) );
1053
1054 return TRUE;
1055 }
1056
HAL_EMMFLT_InputMode(MS_U32 x_connection,MS_BOOL bSerial)1057 MS_U32 HAL_EMMFLT_InputMode(MS_U32 x_connection, MS_BOOL bSerial)
1058 {
1059 MS_U16 Reg_TS_IF2_CTRL = 0, Reg_STR2MIU_CTRL = 0;
1060
1061 Reg_TS_IF2_CTRL = HAL_EMMFLT_ReadReg_Word(x_connection, REG_EMM_TS_IF2_CTRL );
1062 Reg_TS_IF2_CTRL &= ~(REG_SIM_C0_CONFIG | REG_SIM_C1_CONFIG | REG_P_SEL2 | REG_EXT_SYNC_SEL2 | REG_SERIAL_EXT_SYNC_1T); // bit 2,3,5,6,12
1063
1064 Reg_STR2MIU_CTRL = HAL_EMMFLT_ReadReg_Word(x_connection, REG_EMM_STR2MIU_CTRL );
1065
1066 if( bSerial == TRUE ) //input with serial mode....
1067 {
1068 Reg_TS_IF2_CTRL |= (REG_SIM_C0_CONFIG | REG_SIM_C1_CONFIG | REG_EXT_SYNC_SEL2 | REG_SERIAL_EXT_SYNC_1T); // bit[3..2]=11, bit[6..5]=10,bit[12]=1
1069 Reg_STR2MIU_CTRL |= REG_RECORD_AT_SYNC_DIS; // bit[10]=1
1070 }
1071 else //input with parallel mode....
1072 {
1073 Reg_TS_IF2_CTRL |= (REG_P_SEL2 | REG_EXT_SYNC_SEL2); // bit[3..2]=00, bit[6..5]=11,bit[12]=0
1074 Reg_STR2MIU_CTRL &= ~(REG_RECORD_AT_SYNC_DIS); // bit[10]=0
1075 }
1076
1077 HAL_EMMFLT_WriteReg_Word( x_connection, REG_EMM_TS_IF2_CTRL, Reg_TS_IF2_CTRL );
1078 HAL_EMMFLT_WriteReg_Word( x_connection, REG_EMM_STR2MIU_CTRL, Reg_STR2MIU_CTRL );
1079 return TRUE;
1080 }
1081
1082