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 /// file drvNDS_NSK.c
98 /// @brief NDS NSK Driver Interface
99 /// @author MStar Semiconductor Inc.
100 ///////////////////////////////////////////////////////////////////////////////////////////////////
101
102 //-------------------------------------------------------------------------------------------------
103 // Include Files
104 //-------------------------------------------------------------------------------------------------
105 #include "MsCommon.h"
106 #ifdef MSOS_TYPE_LINUX
107 #include "string.h"
108 #endif
109
110 #include "asmCPU.h"
111
112 #include "drvDSCMB.h"
113 extern MS_BOOL MDrv_DSCMB_SlotSwitchWrite(MS_U32 u32DscmbId, DSCMB_Key_Type eKeyType, MS_U32 u32SW0, MS_U32 u32SW1, MS_U32 u32SW2);
114
115 #if defined(CHIP_U3)
116 #include "../tsp/drvTSP.h"
117 #else
118 #include "../tsp2/drvTSP2.h"
119 #endif
120
121 #include "regNDS.h"
122 #include "drvNDS.h"
123 #include "halNDS.h"
124
125 #include "ddiNDS_HDI.h"
126
127 #include "nds.h"
128
129 extern void HALHDI_InitSVP_HW ( unsigned long instance );
130 extern unsigned short HALHDI_InterruptServiceRoutine ( unsigned long instance, unsigned long interrupt_cause );
131
132
133 //-------------------------------------------------------------------------------------------------
134 // Driver Compiler Options
135 //-------------------------------------------------------------------------------------------------
136 #define NSK_DEBUG_ENABLE 0
137
138
139 //-------------------------------------------------------------------------------------------------
140 // Local Defines
141 //-------------------------------------------------------------------------------------------------
142 #define NSK_TASK_STACK_SIZE 8192//4096
143
144 #define NDS_NSK_IRQ E_INT_IRQ_CA_I3//E_INT_IRQ_CA_SVP
145
146 #if defined(CHIP_U3)
147 #define NSK_SW_ESA_SEL_MASK 0x000F0000
148 #define NSK_SW_ESA_SEL_SHFT 16
149 #define NSK_SW_ESA_VARI_MASK 0x00300000
150 #define NSK_SW_ESA_VARI_SHFT 20
151 #define NSK_SW_ESA_MODE_MASK 0x07000000
152 #define NSK_SW_ESA_MODE_SHFT 24
153 #define NSK_SW_NSA_MASK 0xF0000000
154 #define NSK_SW_NSAD_MDD 0x10000000
155 #define NSK_SW_NSAS_MDD 0x20000000
156 #define NSK_SW_NSAD_MDI 0x40000000
157 #define NSK_SW_NSAS_MDI 0x80000000
158 #endif
159
160 /* Appendix A: Return value */
161 #define NSK_STATUS_OK 0x0000
162 #define NSK_STATUS_FAILED 0x0001
163 #define NSK_INVALID_XCONNECTION 0x0008
164 #define NSK_INVALID_PID 0x0009
165 #define NSK_INVALID_SCB 0x000A
166 #define NSK_INVALID_INSTANCE 0x0011
167 #define NSK_INVALID_SCRAMBLING_SETTINGS 0x0015
168 #define NSK_INVALID_ESA_SELECT 0x0016
169 #define NSK_INVALID_ESA_SUBSELECT 0x0017
170 #define NSK_INVALID_ESA_VARIANT 0x0018
171 #define NSK_INVALID_LENGTH_OFFSET 0x0019
172 #define NSK_INVALID_ENTRY_NUM 0x001A
173 #define NSK_INVALID_CM_CHANNEL_HANDLE 0x001C
174 #define NSK_INSUFFICIENT_BUFFER 0x001D
175 #define NSK_INVALID_INPUT_SCB 0x001E
176 #define NSK_INVALID_OUTPUT_SCB 0x001F
177
178 /* Appendix B: Interrupt register definition */
179 #define NSK_CMD_COMPLETE 0x00000001
180 #define NSK_ICAM_SECTION 0x00000002
181 #define NSK_TIMER_EVENT 0x00000004
182 #define NSK_BAD_REG_ACCESS 0x00000008
183
184 /* Appendix C: Scrambler / Descrambler */
185 #define SVPHDI_DESCRAMBLER_CONTROL_ENABLE_DESCRAMBLING 0x80
186 #define SVPHDI_DESCRAMBLER_CONTROL_DISABLE_DESCRAMBLING 0x00
187 #define SVPHDI_DESCRAMBLE_TRANSPORT_PACKET_LEVEL 0x00
188 #define SVPHDI_DESCRAMBLE_PES_PACKET_LEVEL 0x40
189
190 #define SVPHDI_BASE_CONTENT_MODULE_DESCRIPTOR 0x20
191
192
193 /* Appendix D: SCB */
194 #define NSK_CLEAR 0x00
195 #define NSK_EVEN 0x02
196 #define NSK_ODD 0x03
197 #define NSK_ALL_POLARITIES 0x04
198 #define NSK_SCB_CLEAR 0x80
199
200
201 /* Appendix E: Scrambling Settings Constants */
202
203 // MDD / MDI length of descriptor is one
204 #define MDD_MDI_DESCRIPTOR_TAG 0x10 // MDI/MDD/MSC Descriptor
205 #define MDD_MDI_MSC_DESCRIPTOR_TAG_LEN 0x01
206 // MDD/MDI/MSC Scrambling �V byte 0 of the data
207 #define MDD_MDI_SCRAM_BIT_MASK 0x01 // Bit 0: 0�VMDD 1-MDI */
208 #define MDD_MDI_DESCRAM_BIT_MASK 0x02 // Bit 1: 0�VMDD 1-MDI*/
209
210 #define DESCRAMBLER_ALGORITHM_DESCRIPTOR_TAG 0x01
211 #define DESCRAMBLER_ALGORITHM_DESCRIPTOR_TAG_LEN 0x02
212 #define MSC_SCRAM_BIT_MASK 0x01 // Bit 0: Defined in IC-Q063
213 #define MSC_DESCRAM_BIT_MASK 0x02 // Bit 1: Defined in IC-Q063
214 #define DESCRAMBLER_ALGORITHM_FLAGS_OFFSET 0
215 #define DESCRAMBLER_ALGORITHM_ESA_VARIENT_OFFSET 1
216
217 #define CSH1_DESCRIPTOR_TAG 0x02 /* CSH */
218
219 #define SVP_CM_CHANNEL_NUM 8
220 #define SVP_CM_ESPID_NUM 16
221
222 #if NSK_DEBUG_ENABLE
223 #define NSK_DBG(_fmt, _args...) printf(_fmt, ##_args)
224 #else
225 #define NSK_DBG(_fmt, _args...) { }
226 #endif
227
228 #ifdef MS_DEBUG //---------------------------------------------------------------------------------
229 #define NSK_ERR(_fmt, _args...) printf(_fmt, ##_args)
230 #define NSK_ASSERT(_cnd, _fmt, _args...) \
231 if (!(_cnd)) { \
232 printf(_fmt, ##_args); \
233 MAsm_CPU_SwDbgBp(); \
234 while(1); \
235 }
236 #else //-------------------------------------------------------------------------------------------
237 #define NSK_ERR(_fmt, _args...) { }
238 #define NSK_ASSERT(_cnd, _fmt, _args...) \
239 if (!(_cnd)) { \
240 printf(_fmt, ##_args); \
241 } // CAUTION: It should be before GE_ENTRY
242 #endif //------------------------------------------------------------------------------------------
243
244 #define SVP_ENTRY() { }
245 #define SVP_RETURN(_ret) { return (_ret); }
246
247
248 //-------------------------------------------------------------------------------------------------
249 // Local Structurs
250 //-------------------------------------------------------------------------------------------------
251 typedef struct _SVP_CM_EsPid
252 {
253 MS_BOOL alloc;
254 MS_U32 pid;
255 MS_U32 flt_id;
256 MS_U32 dscmb_odd;
257 MS_U32 dscmb_even;
258 MS_U32 dscmb_clear;
259
260 } SVP_CM_EsPid;
261
262 typedef struct _SVP_CM_Channel
263 {
264 MS_BOOL alloc;
265 MS_BOOL enable;
266 MS_U32 nsk_sw;
267 // MS_U32 esa_sel;
268 // MS_U32 esa_subsel;
269 MS_U32 dsc_id;
270 DSCMB_Type dsc_type;
271
272
273 SVP_CM_EsPid es[SVP_CM_ESPID_NUM];
274 } SVP_CM_Channel;
275
276
277 //[HAL] {
278 typedef struct _SVP_CM_Prop_Base
279 {
280 MS_U8 tag;
281 MS_U8 len;
282 MS_U8 hwid[4]; // big-endian
283 MS_U8 ch_num[2]; // big-endian
284 } SVP_CM_Prop_Base;
285
286 typedef struct _SVP_CM_Prop
287 {
288 SVP_CM_Prop_Base base;
289 } SVP_CM_Prop;
290 //[HAL] }
291
292
293 //-------------------------------------------------------------------------------------------------
294 // Global Variables
295 //-------------------------------------------------------------------------------------------------
296
297
298 //-------------------------------------------------------------------------------------------------
299 // Local Variables
300 //-------------------------------------------------------------------------------------------------
301
302 static MS_U32 u32NSK_Stack[NSK_TASK_STACK_SIZE/sizeof(MS_U32)];
303 static MS_S32 s32NSK_TaskId = -1;
304 static MS_S32 s32NSK_EventId = -1;
305
306
307 SVP_CM_Channel svp_cm[SVP_CM_CHANNEL_NUM];
308
309 //[HAL]
310 SVP_CM_Prop svp_prop = {
311 { SVPHDI_BASE_CONTENT_MODULE_DESCRIPTOR,
312 6, // length
313 { 0, 0, 0, 0 }, // hardware id
314 { 8, 0 }, // max channel number
315 },
316 };
317 //[HAL]
318
319
320
321 //-------------------------------------------------------------------------------------------------
322 // Debug Functions
323 //-------------------------------------------------------------------------------------------------
324
325
326 //-------------------------------------------------------------------------------------------------
327 // Local Functions
328 //-------------------------------------------------------------------------------------------------
329
330
331 //-------------------------------------------------------------------------------------------------
332 // Global Functions
333 //-------------------------------------------------------------------------------------------------
334
335 //-------- (HAL) ----------
HDIHAL_WriteNSKReg(unsigned long instance,unsigned long offset,unsigned long length,unsigned long * reg_data_out)336 unsigned short HDIHAL_WriteNSKReg(unsigned long instance,
337 unsigned long offset,
338 unsigned long length,
339 unsigned long* reg_data_out)
340 {
341 // MS_U32 *reg_ptr;
342 int i;
343
344 NSK_DBG("[%s]-[%d]\n", __FUNCTION__, __LINE__);
345
346 if (instance >= NSK_DEV_NUM)
347 {
348 return NSK_INVALID_INSTANCE;
349 }
350
351 if (instance == 0)
352 {
353 for (i = 0; i < length ; i++)
354 {
355 NSK_REG_W(offset+i, *reg_data_out++);
356 }
357 }
358 else
359 {
360 NSK_ASSERT(FALSE, "[%s]-[%d]\n", __FUNCTION__, __LINE__);
361 return NSK_INVALID_INSTANCE;
362 }
363 /*
364 reg_ptr = (MS_U32*)(0xBE000000 + (instance*NSK_BANK_SIZE) + (offset<<2));
365
366 for (i = 0; i < length; i++)
367 {
368 *reg_ptr++ = *reg_data_out++;
369 }
370 */
371 return NSK_STATUS_OK;
372 }
373
374
HDIHAL_ReadNSKReg(unsigned long instance,unsigned long offset,unsigned long length,unsigned long * reg_data_in)375 unsigned short HDIHAL_ReadNSKReg(unsigned long instance,
376 unsigned long offset,
377 unsigned long length,
378 unsigned long* reg_data_in)
379 {
380 // MS_U32 *reg_ptr, i=0;
381 int i;
382
383 NSK_DBG("[%s]-[%d] \n", __FUNCTION__, __LINE__);
384
385 if (instance >= NSK_DEV_NUM)
386 {
387 return NSK_INVALID_INSTANCE;
388 }
389
390 if (instance == 0)
391 {
392 for (i = 0; i < length ; i++)
393 {
394 *reg_data_in++ = NSK_REG_R(offset+i);
395 }
396 }
397 else
398 {
399 NSK_ASSERT(FALSE, "[%s]-[%d]\n", __FUNCTION__, __LINE__);
400 return NSK_INVALID_INSTANCE;
401 }
402 /*
403 reg_ptr = (MS_U32*)(0xBE000000 + (instance*NSK_BANK_SIZE) + (offset<<2));
404
405 for (i = 0; i < length; i++)
406 {
407 *reg_data_in++ = *reg_ptr++;
408 }
409 */
410
411 return NSK_STATUS_OK;
412 }
413
414
SWAP(MS_U8 * value)415 MS_U32 SWAP(MS_U8 *value)
416 {
417 return ((MS_U32)*(value)<<24) | ((MS_U32)*(value+1)<<16) | ((MS_U32)*(value+2)<<8) | ((MS_U32)*(value+3));
418 }
419
420
HDIHAL_WriteNSKData(unsigned long instance,unsigned long offset,unsigned long length,unsigned char * data_out)421 unsigned short HDIHAL_WriteNSKData(unsigned long instance,
422 unsigned long offset,
423 unsigned long length,
424 unsigned char* data_out)
425 {
426 // MS_U32 *reg_ptr;
427 MS_U32 tmp;
428 // MS_U8 *tmp_ptr;
429 NSK_DBG("[%s]-[%d] \n", __FUNCTION__, __LINE__);
430
431 if (instance >= NSK_DEV_NUM)
432 {
433 return NSK_INVALID_INSTANCE;
434 }
435
436 if (instance == 0)
437 {
438 while (length)
439 {
440 if (length >= 4)
441 {
442 tmp = SWAP(data_out);
443 data_out += 4;
444 length -= 4;
445 }
446 else
447 {
448 tmp = 0;
449 while (length)
450 {
451 tmp |= ((MS_U32)*(data_out)) << ((3-length)<<3);
452 data_out++;
453 length--;
454 }
455 }
456 NSK_REG_W(offset, tmp);
457 offset++;
458 }
459 }
460 else
461 {
462 NSK_ASSERT(FALSE, "[%s]-[%d]\n", __FUNCTION__, __LINE__);
463 return NSK_INVALID_INSTANCE;
464 }
465
466 /*
467 reg_ptr = (MS_U32*)(0xBE000000 + (instance*NSK_BANK_SIZE) + (offset<<2));
468
469 while (length)
470 {
471 if (length >= 4)
472 {
473 L2B(data_out);
474 *reg_ptr = *(MS_U32*)(data_out);
475 reg_ptr++;
476 data_out += 4;
477 length -= 4;
478 }
479 else
480 {
481 tmp = 0;
482 tmp_ptr = (MS_U8 *)&tmp;
483 while(length)
484 {
485 *tmp_ptr = *(data_out);
486 tmp_ptr++;
487 data_out++;
488 length--;
489 }
490 L2B((unsigned char*)&tmp);
491 *reg_ptr = tmp;
492 }
493 }
494 */
495
496 return NSK_STATUS_OK;
497 }
498
499
500
501
HDIHAL_ReadNSKData(unsigned long instance,unsigned long offset,unsigned long length,unsigned char * data_in)502 unsigned short HDIHAL_ReadNSKData(unsigned long instance,
503 unsigned long offset,
504 unsigned long length,
505 unsigned char* data_in)
506 {
507 // MS_U32 *reg_ptr;
508 MS_U32 tmp;
509 NSK_DBG("[%s]-[%d] \n", __FUNCTION__, __LINE__);
510
511 if (instance >= NSK_DEV_NUM)
512 {
513 return NSK_INVALID_INSTANCE;
514 }
515
516 if (instance == 0)
517 {
518 while (length)
519 {
520 tmp = NSK_REG_R(offset);
521 if (length >= 4)
522 {
523 *(MS_U32*)data_in = SWAP((MS_U8*)&tmp);
524 data_in += 4;
525 length -= 4;
526 }
527 else
528 {
529 while (length)
530 {
531 *(data_in) = tmp & 0xFF;
532 tmp >>= 8;
533 data_in++;
534 length--;
535 }
536 }
537 offset++;
538 }
539 }
540 else
541 {
542 NSK_ASSERT(FALSE, "[%s]-[%d]\n", __FUNCTION__, __LINE__);
543 return NSK_INVALID_INSTANCE;
544 }
545
546
547 /*
548 reg_ptr = (MS_U32*)(0xBE000000 + (instance*NSK_BANK_SIZE) + (offset<<2));
549
550 while (length)
551 {
552 if (length >= 4)
553 {
554 *(MS_U32*)(data_in) = *reg_ptr;
555 LE2BE(data_in);
556 reg_ptr++;
557 data_in += 4;
558 length -= 4;
559
560 }
561 else
562 {
563 tmp = *reg_ptr;
564 LE2BE((unsigned char*)&tmp);
565 while(length)
566 {
567 *(data_in) = tmp & 0xFF;
568 tmp >>= 4;
569 data_in++;
570 }
571 }
572 }
573 */
574 return NSK_STATUS_OK;
575 }
576
577 /*unsigned short HALHDI_InterruptServiceRoutine(
578 unsigned long instance,
579 unsigned long interrupt_source)
580 {
581 return NSK_STATUS_OK;
582 }
583
584
585 unsigned short HALHDI_InitSVP_HW(unsigned long instance)
586 {
587 return NSK_STATUS_OK;
588 }*/
589
590 #define NSK_INT_EVENT_0 0x00000001
591 #define NSK_INT_GROUP 0x0000FFFF
592
_NSK_Isr(void)593 void _NSK_Isr(void)
594 {
595
596 MsOS_DisableInterrupt(NDS_NSK_IRQ);
597 //reg_ptr = (MS_U32*)(0xBE000000 + (instance*NSK_BANK_SIZE) + (offset<<2));
598 MsOS_SetEvent(s32NSK_EventId, NSK_INT_EVENT_0); //[[ NDS BUG ]] not match in spec doc id : 482-sec 4.3
599
600 }
601
602
_NSK_Isr_Task(void)603 static void _NSK_Isr_Task(void)
604 {
605 MS_U32 u32Reg;
606 MS_U32 u32Events = 0;
607 unsigned long instance = 0;
608
609 while(1)
610 {
611 MsOS_WaitEvent(s32NSK_EventId, NSK_INT_GROUP, &u32Events, E_OR_CLEAR, MSOS_WAIT_FOREVER);
612 //MsOS_DisableInterrupt(NDS_NSK_IRQ);
613 if (u32Events & NSK_INT_EVENT_0)
614 {
615 u32Reg = NSK_REG_R(REG_NSK_INT);
616 NSK_REG_W(REG_NSK_INT, u32Reg);
617
618 #ifndef CDI_CA
619 // NDS Library
620 HALHDI_InterruptServiceRoutine( instance, u32Reg );
621 #endif
622 }
623 else
624 {
625 u32Reg = NSK_REG_R(REG_NSK_INT);
626 NSK_REG_W(REG_NSK_INT, u32Reg);
627 }
628 MsOS_EnableInterrupt(NDS_NSK_IRQ);
629
630 MsOS_DelayTask(5);
631 }
632 }
633
634
_SVP_EnableEsPidCmChannel(unsigned int cm_channel_handle,unsigned int espid_id)635 unsigned short _SVP_EnableEsPidCmChannel(unsigned int cm_channel_handle, unsigned int espid_id)
636 {
637 //TODO: maybe nothing to do
638 return NSK_STATUS_OK;
639 }
640
_SVP_RemoveEsPidCmChannel(unsigned int cm_channel_handle,unsigned int espid_id)641 unsigned short _SVP_RemoveEsPidCmChannel(unsigned int cm_channel_handle, unsigned int espid_id)
642 {
643
644 //TODO:
645 /*
646 MS_U16 ret;
647 ret = MDrv_TSP_PidFlt_Free(svp_cm[cm_channel_handle].es[cm_espid_id].flt_id);
648 NSK_ASSERT((ret == TRUE), "%s FAIL\n", __FUNCTION__);
649 */
650
651 svp_cm[cm_channel_handle].es[espid_id].alloc = FALSE;
652
653 return NSK_STATUS_OK;
654 }
655
656
_SVP_DisableCmChannel(unsigned int cm_channel_handle)657 unsigned short _SVP_DisableCmChannel(unsigned int cm_channel_handle)
658 {
659 //TODO: disable CmChannel
660 return NSK_STATUS_OK;
661 }
662
663
_SVP_DeallocateCmChannel(unsigned int cm_channel_handle)664 unsigned short _SVP_DeallocateCmChannel(unsigned int cm_channel_handle)
665 {
666 int j;
667
668 _SVP_DisableCmChannel(cm_channel_handle);
669 for (j = 0; j < SVP_CM_ESPID_NUM; j++)
670 {
671 if (svp_cm[cm_channel_handle].es[j].alloc == TRUE)
672 {
673 _SVP_RemoveEsPidCmChannel(cm_channel_handle, j);
674 }
675 }
676
677 // Free CmChannel
678 //TODO:
679 /*
680 MS_U16 ret;
681 NSK_ASSERT((ret == TRUE), "%s FAIL\n", __FUNCTION__);
682 */
683 svp_cm[cm_channel_handle].alloc = FALSE;
684
685 return NSK_STATUS_OK;
686 }
687
688
_SVP_WriteKey_Parse(unsigned int cm_channel_handle,unsigned char scb,unsigned int settings_len,unsigned char * settings)689 unsigned short _SVP_WriteKey_Parse(unsigned int cm_channel_handle,
690 unsigned char scb,
691 unsigned int settings_len,
692 unsigned char* settings)
693 {
694 MS_U32 u32SetLen = settings_len;
695 DSCMB_Key_Type key_type = E_DSCMB_KEY_CLEAR;
696
697 switch (scb)
698 {
699 case NSK_CLEAR:
700 key_type = E_DSCMB_KEY_CLEAR;
701 break;
702 case NSK_ODD:
703 key_type = E_DSCMB_KEY_ODD;
704 break;
705 case NSK_EVEN:
706 key_type = E_DSCMB_KEY_EVEN;
707 break;
708 default:
709 return CA_REQUEST_NOT_SUPPORTED_BY_DRIVER;
710 }
711
712 //TODO: should we support more nsk_sw for other than switch13?
713 while (u32SetLen)
714 {
715 if (MDD_MDI_DESCRIPTOR_TAG == *settings)
716 {
717 svp_cm[cm_channel_handle].nsk_sw &= ~DSCMB_SW_NSA_MASK;
718
719 if ((u32SetLen >= (MDD_MDI_MSC_DESCRIPTOR_TAG_LEN+2) &&
720 *(settings+1) == MDD_MDI_MSC_DESCRIPTOR_TAG_LEN) )
721 {
722 if (*(settings+2) & MDD_MDI_SCRAM_BIT_MASK)
723 {
724 svp_cm[cm_channel_handle].nsk_sw |= DSCMB_SW_NSAS_MDI;
725 }
726 else
727 {
728 svp_cm[cm_channel_handle].nsk_sw |= DSCMB_SW_NSAS_MDD;
729 }
730 if (*(settings+2) & MDD_MDI_DESCRAM_BIT_MASK)
731 {
732 svp_cm[cm_channel_handle].nsk_sw |= DSCMB_SW_NSAD_MDI;
733 }
734 else
735 {
736 svp_cm[cm_channel_handle].nsk_sw |= DSCMB_SW_NSAD_MDD;
737 }
738 u32SetLen -= MDD_MDI_MSC_DESCRIPTOR_TAG_LEN + 2;
739 settings += MDD_MDI_MSC_DESCRIPTOR_TAG_LEN + 2;
740 }
741 else
742 {
743 NSK_ASSERT(TRUE, "MDD_MDI_TAG fail\n");
744 return NSK_INVALID_SCRAMBLING_SETTINGS;
745 }
746 }
747 else if (DESCRAMBLER_ALGORITHM_DESCRIPTOR_TAG == *settings)
748 {
749 svp_cm[cm_channel_handle].nsk_sw &= ~DSCMB_SW_ESA_VAR_MASK;
750
751 if ((u32SetLen >= (DESCRAMBLER_ALGORITHM_DESCRIPTOR_TAG_LEN+2) &&
752 *(settings+1) == DESCRAMBLER_ALGORITHM_DESCRIPTOR_TAG_LEN) )
753 {
754 // non-SVP ESA MSC (must stay clear)
755 if (*(settings+2) & MSC_SCRAM_BIT_MASK)
756 {
757 //TODO:
758 MAsm_CPU_SwDbgBp();
759 printf("#### Not support #### %s %d\n", __FUNCTION__, __LINE__);
760 }
761
762 if (*(settings+2) & MSC_DESCRAM_BIT_MASK)
763 {
764 //TODO:
765 MAsm_CPU_SwDbgBp();
766 printf("#### Not support #### %s %d\n", __FUNCTION__, __LINE__);
767 }
768
769 // non-SVP ESA variant
770 svp_cm[cm_channel_handle].nsk_sw |= ((*(settings+3)) << DSCMB_SW_ESA_VAR_SHFT) & DSCMB_SW_ESA_VAR_MASK;
771
772 u32SetLen -= DESCRAMBLER_ALGORITHM_DESCRIPTOR_TAG_LEN + 2;
773 settings += DESCRAMBLER_ALGORITHM_DESCRIPTOR_TAG_LEN + 2;
774
775 }
776 else
777 {
778 NSK_ASSERT(TRUE, "DSCMB_TAG fail\n");
779 return NSK_INVALID_SCRAMBLING_SETTINGS;
780 }
781 }
782 else
783 {
784 NSK_ASSERT(TRUE, "TAG fail\n");
785 return NSK_INVALID_SCRAMBLING_SETTINGS;
786 }
787
788 if (u32SetLen < 0)
789 {
790 return NSK_INVALID_SCRAMBLING_SETTINGS;
791 }
792 }
793
794 #if defined(CHIP_U3)
795 //MDrv_DSCMB_CleanSCB();
796 #endif
797 MDrv_DSCMB_FltKeySet(svp_cm[cm_channel_handle].dsc_id, key_type, NULL); // Dummy control word for SVP mode
798 #if defined(CHIP_U3)
799 MDrv_DSCMB_FltTypeSet(svp_cm[cm_channel_handle].dsc_id, svp_cm[cm_channel_handle].dsc_type, svp_cm[cm_channel_handle].nsk_sw, key_type);
800 #else
801
802 MS_U32 i = 0 ;
803 for ( i = 0 ; i < SVP_CM_ESPID_NUM ; i++ )
804 {
805 if (TRUE == svp_cm[cm_channel_handle].es[i].alloc)
806 {
807 MDrv_DSCMB_SlotSwitchWrite(svp_cm[cm_channel_handle].es[i].flt_id
808 ,key_type
809 ,svp_cm[cm_channel_handle].nsk_sw, 0, 0);
810 break ;
811 }
812 }
813 #endif
814
815
816 return NSK_STATUS_OK;
817 }
818
SVPHDI_ReadSerialData(unsigned int offset,unsigned int length,unsigned char * data)819 unsigned short SVPHDI_ReadSerialData(unsigned int offset,
820 unsigned int length,
821 unsigned char* data)
822 {
823 return NSK_STATUS_OK;
824 }
825
826
SVPHDI_AllocateCmChannel(unsigned long xconn,unsigned int esa_select,unsigned int esa_subselect,unsigned int * cm_channel_handle)827 unsigned short SVPHDI_AllocateCmChannel(unsigned long xconn,
828 unsigned int esa_select,
829 unsigned int esa_subselect,
830 unsigned int* cm_channel_handle)
831 {
832 int i;
833 // DSCMB_Type dsc_type = E_DSCMB_TYPE_CSA;
834
835 SVP_ENTRY();
836
837 //TODO: x_connection
838 // SVP_RETURN(NSK_INVALID_XCONNECTION);
839
840 for(i = 0; i < SVP_CM_CHANNEL_NUM; i++)
841 {
842 if (svp_cm[i].alloc == FALSE)
843 {
844 break;
845 }
846 }
847 if (i == SVP_CM_CHANNEL_NUM)
848 {
849 SVP_RETURN(NSK_STATUS_FAILED);
850 }
851
852 #if defined(CHIP_U3)
853 //TODO: remove it? TDES is different than DES! ECM,etc...is defined by esa_select!
854 switch (esa_select)
855 {
856 case 0x0: // AES
857 dsc_type = E_DSCMB_TYPE_AES;
858 break;
859 case 0x1: // DVB CSA
860 dsc_type = E_DSCMB_TYPE_CSA;
861 break;
862 case 0x2: // DES
863 case 0x3: // TDES
864 dsc_type = E_DSCMB_TYPE_DES;
865 break;
866 case 0xF: // SW
867 // regardless esa_subselect
868 break;
869 default:
870 SVP_RETURN(NSK_INVALID_ESA_SELECT)
871 }
872 svp_cm[i].dsc_type = dsc_type;
873 #else
874 MS_U32 sw1, sw2, sw3, sw_cnt;
875 sw_cnt = HAL_NDS_KTE_GetSwitch(esa_select, esa_subselect, &sw1, &sw2, &sw3);
876 if (sw_cnt == 0)
877 {
878 SVP_RETURN(NSK_INVALID_ESA_SELECT);
879 }
880 svp_cm[i].nsk_sw = sw1; // U3/U4
881 #endif
882
883 if (DRV_DSCMB_FLT_NULL == (svp_cm[i].dsc_id = MDrv_DSCMB_FltAlloc()))
884 {
885 SVP_RETURN(NSK_STATUS_FAILED);
886 }
887
888 // allocate descarmbler filter slot
889 //TODO:
890 /*
891 MS_U16 ret;
892 MDrv_DSCMB_FltAlloc
893 if (ret != TRUE)
894 {
895 SVP_RETURN(NSK_STATUS_FAILED);
896 }
897 */
898
899 svp_cm[i].alloc = TRUE;
900
901 *cm_channel_handle = i;
902
903 SVP_RETURN(NSK_STATUS_OK);
904 }
905
906
SVPHDI_DeallocateCmChannel(unsigned int cm_channel_handle)907 unsigned short SVPHDI_DeallocateCmChannel(unsigned int cm_channel_handle)
908 {
909 SVP_ENTRY();
910
911 if ((cm_channel_handle >= SVP_CM_CHANNEL_NUM) || (svp_cm[cm_channel_handle].alloc != TRUE))
912 {
913 SVP_RETURN(NSK_INVALID_CM_CHANNEL_HANDLE);
914 }
915
916 // disable cm_channel
917 if (_SVP_DisableCmChannel(cm_channel_handle) != NSK_STATUS_OK)
918 {
919 SVP_RETURN(NSK_STATUS_FAILED);
920 }
921
922
923 // Free Channel
924 //TODO:
925 /*
926 MS_U16 ret;
927 if (ret != TRUE)
928 {
929 SVP_RETURN(NSK_STATUS_FAILED);
930 }
931 */
932
933 SVP_RETURN(NSK_STATUS_OK);
934 }
935
936
SVPHDI_AddEsPidCmChannel(unsigned int cm_channel_handle,unsigned short es_pid)937 unsigned short SVPHDI_AddEsPidCmChannel(unsigned int cm_channel_handle,
938 unsigned short es_pid)
939 {
940 int j;
941
942 SVP_ENTRY();
943 if ((cm_channel_handle >= SVP_CM_CHANNEL_NUM) || (svp_cm[cm_channel_handle].alloc != TRUE))
944 {
945 SVP_RETURN(NSK_INVALID_CM_CHANNEL_HANDLE);
946 }
947
948 for (j = 0; j < SVP_CM_ESPID_NUM; j++)
949 {
950 if (svp_cm[cm_channel_handle].es[j].alloc != TRUE)
951 {
952 break;
953 }
954 }
955 if (j == SVP_CM_ESPID_NUM)
956 {
957 SVP_RETURN(NSK_INVALID_PID);
958 }
959
960 // allocate a PID slot
961 //TODO:
962 /*
963 if (ret != TRUE);
964 {
965 SVP_RETURN(NSK_INVALID_PID);
966 }
967 // enable espid if channel is enabled
968 if (svp_cm[cm_channel_handle].enable == TRUE)
969 {
970 if (_SVP_EnableEsPidCmChannel(cm_channel_handle, j) != NSK_STATUS_OK)
971 {
972 SVP_RETURN(NSK_STATUS_FAILED);
973 }
974 }
975 */
976 svp_cm[cm_channel_handle].enable = TRUE;
977
978
979 MS_U32 flt_id, fltnum = 0 , pid = 0 ;
980 #if 0
981 //tt
982 //FIXME: --jerry
983 //////////////// Fix Me for SVP test ///////////////
984 //-------------- Alloc and Set pid -----------------
985 TSP_FltType flt_type;
986 if (0xFFFF != es_pid)
987 {
988
989 if (es_pid == 0x200)
990 flt_type = E_TSP_FLT_FIFO_VIDEO;
991 else if (es_pid == 0x280)
992 flt_type = E_TSP_FLT_FIFO_AUDIO;
993 else
994 flt_type = E_TSP_FLT_USER_SEC;
995
996 //if (DMX_FILTER_STATUS_OK != MApi_DMX_Open(FilterType, &DmxIdSect))
997 if (E_TSP_OK != MDrv_TSP_FLT_Alloc(0, flt_type, &flt_id))
998 {
999 SVP_RETURN(NSK_INVALID_PID);
1000 }
1001 pid = es_pid;
1002 //if (DMX_FILTER_STATUS_OK != MApi_DMX_Pid(DmxIdSect, &u16Pid, TRUE))
1003 if (E_TSP_OK != MDrv_TSP_FLT_SetPID(flt_id, (MS_U32)pid))
1004 {
1005 SVP_RETURN(NSK_INVALID_PID);
1006 }
1007 }
1008 //tt
1009 #else
1010
1011 if ( E_TSP_OK != MDrv_TSP_GetCaps(E_TSP_CAP_PIDFLT_NUM, &fltnum))
1012 {
1013 SVP_RETURN(NSK_STATUS_FAILED);
1014 }
1015 else
1016 {
1017 for( flt_id = 0 ; flt_id < fltnum ; flt_id ++ )
1018 {
1019 pid = 0 ;
1020 if (E_TSP_OK != MDrv_TSP_FLT_GetPID(flt_id, &pid))
1021 {
1022 SVP_RETURN(NSK_INVALID_PID);
1023 }
1024
1025 if ( pid == es_pid)
1026 {
1027 break ;
1028 }
1029 }
1030 if (flt_id == fltnum )
1031 {
1032 SVP_RETURN(NSK_INVALID_PID);
1033 }
1034 }
1035 #endif
1036
1037 svp_cm[cm_channel_handle].es[j].alloc = TRUE;
1038 svp_cm[cm_channel_handle].es[j].pid = (MS_U32)es_pid;
1039 svp_cm[cm_channel_handle].es[j].flt_id = flt_id;
1040
1041 MDrv_DSCMB_FltConnectPid(svp_cm[cm_channel_handle].dsc_id, (MS_U32)es_pid);
1042
1043 SVP_RETURN(NSK_STATUS_OK);
1044 }
1045
1046
SVPHDI_RemoveEsPidCmChannel(unsigned int cm_channel_handle,unsigned short es_pid)1047 unsigned short SVPHDI_RemoveEsPidCmChannel(unsigned int cm_channel_handle,
1048 unsigned short es_pid)
1049 {
1050 int j;
1051
1052 SVP_ENTRY();
1053 if ((cm_channel_handle >= SVP_CM_CHANNEL_NUM) || (svp_cm[cm_channel_handle].alloc != TRUE))
1054 {
1055 SVP_RETURN(NSK_INVALID_CM_CHANNEL_HANDLE);
1056 }
1057 for (j = 0; j < SVP_CM_ESPID_NUM; j++)
1058 {
1059 if ( (svp_cm[cm_channel_handle].es[j].alloc == TRUE) &&
1060 (svp_cm[cm_channel_handle].es[j].pid == es_pid) )
1061 {
1062 if (_SVP_RemoveEsPidCmChannel(cm_channel_handle, j))
1063 {
1064 SVP_RETURN(NSK_STATUS_FAILED);
1065 }
1066 }
1067 }
1068 SVP_RETURN(NSK_STATUS_OK);
1069 }
1070
1071
SVPHDI_EnableCmChannel(unsigned int cm_channel_handle)1072 unsigned short SVPHDI_EnableCmChannel(unsigned int cm_channel_handle)
1073 {
1074 int j;
1075
1076 SVP_ENTRY();
1077 if ((cm_channel_handle >= SVP_CM_CHANNEL_NUM) || (svp_cm[cm_channel_handle].alloc != TRUE))
1078 {
1079 SVP_RETURN(NSK_INVALID_CM_CHANNEL_HANDLE);
1080 }
1081
1082 for (j = 0; j < SVP_CM_ESPID_NUM; j++)
1083 {
1084 #if 1 //temp
1085 if ((svp_cm[cm_channel_handle].es[j].alloc == TRUE) && (0x1FFFF != svp_cm[cm_channel_handle].es[j].pid))
1086 {
1087 //if (DMX_FILTER_STATUS_OK != MApi_DMX_Start(svp_cm[cm_channel_handle].es[j].flt_id))
1088 if (E_TSP_OK != MDrv_TSP_FLT_Enable(svp_cm[cm_channel_handle].es[j].flt_id, TRUE))
1089 {
1090 SVP_RETURN(NSK_INVALID_CM_CHANNEL_HANDLE);
1091 }
1092 }
1093 #else
1094 //FIXME: Please no more DMX/TSP in SVP code
1095 if (svp_cm[cm_channel_handle].es[j].alloc == TRUE)
1096 {
1097 _SVP_EnableEsPidCmChannel(cm_channel_handle, j);
1098 }
1099 // -- jerry
1100 #endif
1101 }
1102
1103 //TODO: enable CmChannel
1104
1105 SVP_RETURN(NSK_STATUS_OK);
1106 }
1107
1108
SVPHDI_DisableCmChannel(unsigned int cm_channel_handle)1109 unsigned short SVPHDI_DisableCmChannel(unsigned int cm_channel_handle)
1110 {
1111 SVP_ENTRY();
1112 if ((cm_channel_handle >= SVP_CM_CHANNEL_NUM) || (svp_cm[cm_channel_handle].alloc != TRUE))
1113 {
1114 SVP_RETURN(NSK_INVALID_CM_CHANNEL_HANDLE);
1115 }
1116
1117 _SVP_DisableCmChannel(cm_channel_handle);
1118
1119 SVP_RETURN(NSK_STATUS_OK);
1120 }
1121
1122
SVPHDI_WriteKey(unsigned long instance,unsigned int cm_channel_handle,unsigned char scb,unsigned int scrambling_settings_len,unsigned char * scrambling_settings)1123 unsigned short SVPHDI_WriteKey(unsigned long instance,
1124 unsigned int cm_channel_handle,
1125 unsigned char scb,
1126 unsigned int scrambling_settings_len,
1127 unsigned char* scrambling_settings)
1128 {
1129 SVP_ENTRY();
1130
1131 _SVP_WriteKey_Parse(cm_channel_handle, scb, scrambling_settings_len, scrambling_settings);
1132 //TODO WriteKTE
1133
1134 SVP_RETURN(NSK_STATUS_OK);
1135 }
1136
1137
SVPHDI_GetContentModuleProperties(unsigned int cm_prop_length,unsigned int * actual_cm_prop_len,unsigned char * cm_properties)1138 unsigned short SVPHDI_GetContentModuleProperties(unsigned int cm_prop_length,
1139 unsigned int* actual_cm_prop_len,
1140 unsigned char* cm_properties)
1141 {
1142 SVP_ENTRY();
1143
1144 *actual_cm_prop_len = sizeof(svp_prop); // will the size more than sepcified coz alignment?
1145
1146 if (cm_prop_length != 0)
1147 {
1148 memcpy(cm_properties, &svp_prop, MIN(cm_prop_length, sizeof(svp_prop)));
1149 }
1150
1151 if (cm_prop_length < sizeof(svp_prop))
1152 {
1153 SVP_RETURN(NSK_INSUFFICIENT_BUFFER);
1154 }
1155
1156 SVP_RETURN(NSK_STATUS_OK);
1157 }
1158
1159
1160 /////------ no support now ------
SVPHDI_SetSecondaryVideoPid(unsigned int cm_channel_handle,unsigned short primary_pid,unsigned short secondary_pid)1161 unsigned short SVPHDI_SetSecondaryVideoPid
1162 (
1163 unsigned int cm_channel_handle,
1164 unsigned short primary_pid,
1165 unsigned short secondary_pid
1166 )
1167 {
1168 return NSK_STATUS_OK;
1169 }
1170
1171
1172
SVPHDI_ReleaseSecondaryVideoPid(unsigned int cm_channel_handle,unsigned short secondary_pid)1173 unsigned short SVPHDI_ReleaseSecondaryVideoPid
1174 (
1175 unsigned int cm_channel_handle,
1176 unsigned short secondary_pid
1177 )
1178 {
1179 return NSK_STATUS_OK;
1180 }
1181
1182
1183
SVPHDI_StartPacketInjection(unsigned long xconn,unsigned char * transport_packet,unsigned int injection_type,unsigned int injection_frequency)1184 unsigned short SVPHDI_StartPacketInjection
1185 (
1186 unsigned long xconn,
1187 unsigned char* transport_packet,
1188 unsigned int injection_type,
1189 unsigned int injection_frequency
1190 )
1191 {
1192 return NSK_STATUS_OK;
1193 }
1194
1195
SVPHDI_InjectSinglePacket(unsigned long xconn,unsigned char * transport_packet)1196 unsigned short SVPHDI_InjectSinglePacket
1197 (
1198 unsigned long xconn,
1199 unsigned char* transport_packet
1200 )
1201 {
1202 return NSK_STATUS_OK;
1203 }
1204
1205
1206
SVPHDI_ContinousReplacePacket(unsigned long xconn,unsigned short replace_pid,unsigned char * transport_packet)1207 unsigned short SVPHDI_ContinousReplacePacket
1208 (
1209 unsigned long xconn,
1210 unsigned short replace_pid,
1211 unsigned char* transport_packet
1212 )
1213 {
1214 return NSK_STATUS_OK;
1215 }
1216
1217
1218
SVPHDI_TerminatePacketWrite(unsigned long xconn,unsigned short pid)1219 unsigned short SVPHDI_TerminatePacketWrite
1220 (
1221 unsigned long xconn,
1222 unsigned short pid
1223 )
1224 {
1225 return NSK_STATUS_OK;
1226 }
1227
1228
HDIHAL_WriteDescrambler(unsigned long xconn,unsigned short pid,unsigned char scb,unsigned char flags)1229 unsigned short HDIHAL_WriteDescrambler
1230 (
1231 unsigned long xconn,
1232 unsigned short pid,
1233 unsigned char scb,
1234 unsigned char flags
1235 )
1236 {
1237 //---- no support this now ----
1238 return NSK_STATUS_OK;
1239 }
1240
1241
NDS_NSK_Init(MS_U32 nds_id)1242 NDS_Result NDS_NSK_Init(MS_U32 nds_id)
1243 {
1244 int i, j;
1245
1246 s32NSK_EventId = MsOS_CreateEventGroup("NDS_NSK_Event");
1247 if (s32NSK_EventId < 0)
1248 {
1249 return E_NDS_FAIL;
1250 }
1251
1252 s32NSK_TaskId = MsOS_CreateTask((TaskEntry)_NSK_Isr_Task,
1253 (MS_U32)NULL,
1254 E_TASK_PRI_SYS,
1255 TRUE,
1256 u32NSK_Stack,
1257 NSK_TASK_STACK_SIZE,
1258 "NDS_NSK_Task");
1259 if (s32NSK_TaskId < 0)
1260 {
1261 MsOS_DeleteEventGroup(s32NSK_EventId);
1262 return E_NDS_FAIL;
1263 }
1264
1265 for (i = 0; i < SVP_CM_CHANNEL_NUM; i++)
1266 {
1267 svp_cm[i].alloc = FALSE;
1268 svp_cm[i].enable = FALSE;
1269 for (j = 0; j < SVP_CM_ESPID_NUM; j++)
1270 {
1271 svp_cm[i].es[j].alloc = FALSE;
1272 }
1273 }
1274
1275 // Initialize hardware
1276 NSK_REG_W(REG_NSK_INT, 0x8000000F);//enable nsk int
1277 MsOS_DisableInterrupt(NDS_NSK_IRQ);
1278 MsOS_DetachInterrupt(NDS_NSK_IRQ);
1279 MsOS_AttachInterrupt(NDS_NSK_IRQ, (InterruptCb)_NSK_Isr);
1280 MsOS_EnableInterrupt(NDS_NSK_IRQ);
1281
1282 #ifndef CDI_CA
1283 // NDS Library
1284 HALHDI_InitSVP_HW(0);
1285 #endif
1286
1287 return E_NDS_OK;
1288 }
1289
1290
NDS_NSK_Exit(MS_U32 nds_id)1291 NDS_Result NDS_NSK_Exit(MS_U32 nds_id)
1292 {
1293 MsOS_DetachInterrupt(NDS_NSK_IRQ);
1294 MsOS_DisableInterrupt(NDS_NSK_IRQ);
1295
1296 NSK_REG_W(REG_NSK_INT, 0x8000); // enable nsk int
1297
1298 MsOS_DeleteTask(s32NSK_TaskId);
1299 MsOS_DeleteEventGroup(s32NSK_EventId);
1300
1301 return E_NDS_OK;
1302 }
1303