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