1
2
3 #ifdef MSOS_TYPE_LINUX_KERNEL
4 #include <linux/string.h>
5 #else
6 #include "string.h"
7 #endif
8
9 #include "MsCommon.h"
10 #include "drvDSCMB.h"
11 #include "drvNSK2.h"
12 #include "nsk2hdi_header.h"
13 #include "drvNSK2Type.h"
14 #include "apiDMX.h"
15 #include "drvMMIO.h"
16 #include "nsk_dbg.h"
17
18 /*****************************************************************************\
19 \Definitions
20 \*****************************************************************************/
21
22 #define CMChannel_ID1 0x01234567
23 #define CMChannel_ID2 0x02461357
24
25 #define NSK2_CMCHANNEL_NUM 256
26 #define NSK2_M2MCHANNEL_NUM 16
27
28 #define NSK2_CM_ESPID_NUM 256
29 #define MaxCAPidProxyNum 256
30
31 #define GetCAPidInfo
32
33 #define CMChannelDescSize 30
34 #define CmChannelGroupMaxNumber 2
35
36 #define CmChannelCookieSize 0x1000
37
38 #define DefaultDSCMBID 0xFFFF
39 #define DefaultPidFltID 0xFFFF
40 #define DefaultPID 0xFFFF
41
42 #define CAVID 1
43
44 #define MaxXConnection 2
45 /*****************************************************************************\
46 \ typedef struct
47 \*****************************************************************************/
48 typedef enum
49 {
50 ESA_SELECT_AES = 0,
51 ESA_SELECT_DVBCSA2 = 1,
52 ESA_SELECT_DES = 2,
53 ESA_SELECT_TDES = 3,
54 ESA_SELECT_MULTI2 = 4,
55 ESA_SELECT_DVBCSA2_CONF = 5,
56 ESA_SELECT_DVBCSA3 = 6,
57 } ESASelectMap_e;
58
59
60 typedef enum
61 {
62 ESASUB_SELECT_SCTE41 = 0,
63 ESASUB_SELECT_SCTE52 = 1,
64
65 ESASUB_SELECT_MDI_CBC = 0,
66 ESASUB_SELECT_SYNAMEDIA_AES = 1,
67 ESASUB_SELECT_AES_ECB_CLR = 3,
68 ESASUB_SELECT_CIPLUS_AES = 4,
69
70 ESASUB_SELECT_NONE = 0,
71 } ESASubSelectMap_e;
72
73
74 typedef enum{
75 CMCHANNEL_LDA_DESC = 0,
76 CMCHANNEL_ESA_DESC ,
77 CMCHANNEL_LSA_DESC ,
78 CMCHANNEL_MAX_DESC ,
79 }CMCHANNEL_DESC_e;
80
81
82 typedef struct{
83 NSK2HDI_DEVICE_ID CmChGroup_ID;
84
85 } CmChannelGroup_t;
86
87
88 typedef struct _CaPID_Info_
89 {
90 MS_BOOL alloc;
91 MS_BOOL enable;
92 MS_U16 es_pid;
93 MS_U32 handle_id;
94 MS_U8 dscmb_id;
95 MS_U32 cm_handle_id;
96 MS_U32 xconn;
97 MS_U32 ProxyGlobalIndex;
98
99 MS_U32 PrimeFilterID;
100 MS_U16 PrimePID;
101
102 MS_U8 secondary_enable;
103 MS_U8 SecondaryFilterID;
104 MS_U16 SecondaryPID;
105 void *pCmCookie;
106 } CaPID_Info;
107
108 typedef struct
109 {
110 NDS_UBYTE type[NSK2_CMCHANNEL_NUM];
111 NDS_USHORT es_pid[NSK2_CMCHANNEL_NUM];
112 MS_U8 PidNo[NSK2_CMCHANNEL_NUM];
113 MS_U32 DscmbId[NSK2_CMCHANNEL_NUM];
114 MS_U32 used[NSK2_CMCHANNEL_NUM];
115 } AddXconnInfo_t;
116
117 typedef struct _CmChannelTable_Info_
118 {
119 MS_BOOL alloc;
120 NDS_ULONG CmChTable_ID;
121 MS_U32 handle_id;
122 } CmChannelTable_Info;
123
124 typedef struct _CmChannelGroup_Info_
125 {
126 MS_BOOL alloc;
127 NDS_ULONG CmChGroup_ID;
128 MS_U32 handle_id;
129 } CmChannelGroup_Info;
130
131
132 typedef struct _cmchannel_algorithm_descriptor{
133 MS_U8 descriptor_tag;
134 MS_U8 descriptor_length;
135 MS_U8 algorithm;
136 } CmChannel_Algo_Desc_t;
137
138 typedef struct _cmchannel_iv_signaling_descriptor{
139 MS_U8 descriptor_tag;
140 MS_U8 descriptor_length;
141 MS_U8 iv_signaling;
142 } CmChannel_IV_Signal_Desc_t;
143
144 typedef struct _cmchannel_iv1_descriptor{
145 MS_U8 descriptor_tag;
146 MS_U8 descriptor_length;
147 MS_U8 iv1_payload[0x10];
148 } CmChannel_IV1_Desc_t;
149
150 typedef struct _cmchannel_iv2_descriptor{
151 MS_U8 descriptor_tag;
152 MS_U8 descriptor_length;
153 MS_U8 iv2_payload[0x10];
154 } CmChannel_IV2_Desc_t;
155
156 typedef struct {
157 CmChannel_Algo_Desc_t ESA_Algo;
158 CmChannel_IV_Signal_Desc_t ESA_IV_Signal;
159 CmChannel_IV1_Desc_t ESA_IV1_Payload;
160 CmChannel_IV2_Desc_t ESA_IV2_Payload;
161 }ESA_Desc_St_t;
162
163
164 typedef struct{
165 NDS_UBYTE Algorithm;
166 NDS_UBYTE IV_Mode;
167 NDS_UBYTE IV1_Enable;
168 NDS_UBYTE IV2_Enable;
169 NDS_UBYTE IV1[0x10];
170 NDS_UBYTE IV2[0x10];
171 }CmChDesc_Parser_t;
172
173
174 typedef struct
175 {
176 MS_U32 u32DscmbId;
177 MS_U32 PidSlotID;
178 MS_U32 u16Pid;
179 #if 0
180 NDS_ULONG lda_desc_size;
181 NDS_UBYTE *lda_desc;
182 NDS_ULONG esa_desc_size;
183 NDS_UBYTE *esa_desc;
184 NDS_ULONG lsa_desc_size;
185 NDS_UBYTE *lsa_desc;
186 NDS_UBYTE lda_iv1_payload[0x10];
187 NDS_UBYTE lda_iv2_payload[0x10];
188 NDS_UBYTE esa_iv1_payload[0x10];
189 NDS_UBYTE esa_iv2_payload[0x10];
190 NDS_UBYTE lsa_iv1_payload[0x10];
191 NDS_UBYTE lsa_iv2_payload[0x10];
192 #endif
193 MS_BOOL bWriteESA;
194 NDS_UBYTE ESA_Algorithm;
195 CmChDesc_Parser_t CmChDesc[CMCHANNEL_MAX_DESC];
196 MS_BOOL bConnect;
197 } CmChannelDevice_Cookie_t;
198
199
200 typedef struct _NSK2_CMChannel
201 {
202 MS_BOOL alloc;
203 MS_BOOL enable;
204 MS_U32 nsk_sw;
205 // MS_U32 esa_sel;
206 // MS_U32 esa_subsel;
207 MS_U32 dsc_id;
208 DSCMB_Type dsc_type;
209 MS_U32 FilterID;
210 MS_U32 PidSlotID;
211 MS_U32 handle_id;
212 MS_U32 es_pid;
213
214 CmChDesc_Parser_t CmChDesc[CMCHANNEL_MAX_DESC];
215 CmChannelDevice_Cookie_t CmChCookie;
216 } NSK2_CMChannel_Info;
217
218
219 typedef struct _CaPidProxy
220 {
221 MS_U16 EsPid;
222 MS_U32 DscmbId;
223 MS_BOOL IsUsed;
224 }CaPidProxy_t;
225
226 /*****************************************************************************\
227 \ Local variables
228 \*****************************************************************************/
229
230 MS_U32 _u32KeepPidByFltId[MaxXConnection][NSK2_CMCHANNEL_NUM];
231 CaPidProxy_t _KeepCaPidProxy[MaxXConnection][NSK2_CMCHANNEL_NUM];
232 static MS_U32 _gu32WriteKeyTime = 0;
233 static MS_U32 _u32CaSoCGroupHandle = 0;
234
235 /*****************************************************************************\
236 \ Global Variables
237 \*****************************************************************************/
238
239 void *pCmChannelcookie[NSK2_CMCHANNEL_NUM];
240 void *pM2MChannelcookie[NSK2_M2MCHANNEL_NUM];
241
242 AddXconnInfo_t HDI_XconnInfo[2];
243
244 NSK2HDI_CHILD_DEVICE _gChild_Device[4];
245
246 CmChannelTable_Info CmChannelTableInfo;
247 CmChannelGroup_Info CmChannelGroupInfo[CmChannelGroupMaxNumber];
248
249 void *CmChannelcookie;
250 CmChannelDevice_Cookie_t *pCmChCookie;
251
252 CmChDesc_Parser_t gCmChannelDesc[NSK2_CMCHANNEL_NUM][CMCHANNEL_MAX_DESC];
253
254
255 /*****************************************************************************\
256 \ Global Functions
257 \*****************************************************************************/
258 MS_BOOL MDrv_DSCMB2_SetPidPair(MS_U32 u32FltIdPri, MS_U32 u32FltIdSec);
259 MS_BOOL MDrv_DSCMB2_ClearPidPair(MS_U32 u32FltIdPri, MS_U32 u32FltIdSec);
260
261
262 /*****************************************************************************\
263 \ TSP Control functions
264 \*****************************************************************************/
265
266 //The extra functions for TSP control
267 //K7 can separate write key and connect to TSP filter ID
268 //The scenario is changed.
NSKHDI_AddDscmbConnect(NDS_ULONG xconn,NDS_USHORT es_pid,MS_U32 u32FltID)269 MS_U32 NSKHDI_AddDscmbConnect(NDS_ULONG xconn,
270 NDS_USHORT es_pid,
271 MS_U32 u32FltID)
272 {
273 NSK_TRACE(("xconn = 0x%x, es_pid = 0x%04x, FltID = %d\n",xconn,es_pid,u32FltID));
274
275 MS_U32 u32DscmbId, i;
276
277 for( i=0; i<NSK2_CMCHANNEL_NUM ; i++)
278 {
279 if( (_KeepCaPidProxy[xconn][i].EsPid == es_pid) && (_KeepCaPidProxy[xconn][i].IsUsed == TRUE))
280 break;
281 }
282
283 if( i == NSK2_CMCHANNEL_NUM ) // the CA PID Proxy is not open with this PID, TSP PID add first...
284 {
285 _u32KeepPidByFltId[xconn][u32FltID] = es_pid;
286 NSK_TRACE(("Add TSP filter first, not connect to dscmb\n"));
287 return TRUE;
288 }
289
290 u32DscmbId = _KeepCaPidProxy[xconn][i].DscmbId;
291 _u32KeepPidByFltId[xconn][u32FltID] = es_pid;
292
293 NSK_TRACE(("already open dscmb handle, connect to dscmb\n"));
294 if(MDrv_DSCMB2_FltConnectFltId(0,u32DscmbId, u32FltID) == FALSE)
295 {
296 NSK_ERROR(("MDrv_DSCMB_FltConnectPid() failed\n"));
297 return FALSE;
298 }
299
300 return TRUE;
301 }
302
NSKHDI_RemoveDscmbConnect(NDS_ULONG xconn,NDS_USHORT es_pid)303 MS_U32 NSKHDI_RemoveDscmbConnect(NDS_ULONG xconn,
304 NDS_USHORT es_pid)
305 {
306
307 NSK_TRACE(("Enter\n"));
308 MS_U32 i = 0, j=0, u32FltID;
309
310 MS_U32 u32DscmbId;
311 MS_BOOL discon_flag = TRUE;
312
313 for( i=0; i<NSK2_CMCHANNEL_NUM ; i++)
314 {
315 if( _u32KeepPidByFltId[xconn][i] == es_pid)
316 break;
317 }
318
319
320 if( i == NSK2_CMCHANNEL_NUM ) // the pid is not added.....
321 {
322 NSK_ERROR(("can't not find match pid filter\n"));
323 return FALSE;
324 }
325
326 u32FltID = i;
327
328 for( j=0; j<NSK2_CMCHANNEL_NUM ; j++)
329 {
330 if( (_KeepCaPidProxy[xconn][j].EsPid == es_pid) && (_KeepCaPidProxy[xconn][j].IsUsed == TRUE))
331 break;
332 }
333
334 if( j == NSK2_CMCHANNEL_NUM ) // the CA PID Proxy is already remove this proxy, almost means already disconnect dscmb
335 {
336 NSK_TRACE(("can't find match pid proxy\n"));
337 discon_flag = FALSE;
338
339 }
340
341 if(TRUE == discon_flag)
342 {
343 u32DscmbId = _KeepCaPidProxy[xconn][j].DscmbId;
344 MDrv_DSCMB2_FltDisconnectFltId(0, u32DscmbId, u32FltID);
345 }
346
347
348 //MApi_NSK2_DTV_ClosePidNo(u32FltID);
349
350 _u32KeepPidByFltId[xconn][u32FltID] = DefaultPID;
351
352 NSK_TRACE(("Exit\n"));
353
354 return TRUE;
355 }
356
357 /*****************************************************************************\
358 \ NSK2HDI device related functions
359 \*****************************************************************************/
360
361 /*****************************************************************************\
362 \ CA SoC Group device
363 \*****************************************************************************/
364
NSKHDI_CaSoCGroupDevice_Open(NSK2HDI_DEVICE_ID CaSoCGroup_ID,NSK2HDI_HANDLE * CaSoCGroup_handle)365
366 NSK2HDI_STATUS NSKHDI_CaSoCGroupDevice_Open (NSK2HDI_DEVICE_ID CaSoCGroup_ID,
367 NSK2HDI_HANDLE *CaSoCGroup_handle)
368 {
369 NSK_TRACE(("Enter\n"));
370
371 NSK_TRACE(("CaSoCGroup_ID = %x\n",CaSoCGroup_ID));
372
373
374 *CaSoCGroup_handle = (NSK2HDI_HANDLE *)&_u32CaSoCGroupHandle;
375
376 //memset(*CaSoCGroup_handle, 0x0 , 4);
377
378 NSK_TRACE(("CaSoCGroup_handle = %p\n",*CaSoCGroup_handle));
379
380 NSK_TRACE(("Exit\n"));
381 return NSK2HDI_STATUS_OK;
382 }
NSKHDI_CaSoCGroupDevice_Close(NSK2HDI_HANDLE CaSoCGroup_handle)383
384 NSK2HDI_STATUS NSKHDI_CaSoCGroupDevice_Close (NSK2HDI_HANDLE CaSoCGroup_handle)
385 {
386 NSK_TRACE(("Enter\n"));
387
388 NSK_TRACE(("CaSoCGroup_handle = %p\n",CaSoCGroup_handle));
389
390 NSK_TRACE(("Exit\n"));
391 return NSK2HDI_STATUS_OK;
392 }
393
NSKHDI_CaSoCGroupDevice_EnumerateChildren(NSK2HDI_HANDLE CaSoCGroup_handle,NDS_ULONG * child_device_num,NSK2HDI_CHILD_DEVICE * child_device)394
395 NSK2HDI_STATUS NSKHDI_CaSoCGroupDevice_EnumerateChildren( NSK2HDI_HANDLE CaSoCGroup_handle,
396 NDS_ULONG *child_device_num,
397 NSK2HDI_CHILD_DEVICE *child_device)
398 {
399 NSK_TRACE(("Enter\n"));
400 NSK_TRACE(("CaSoCGroup_handle = %p\n",CaSoCGroup_handle));
401 //#define NSK2HDI_OTP_DEVICE_TYPE 0x00000002U /*!< @brief OTP device */
402 //#define NSK2HDI_NSK_DEVICE_TYPE 0x00000003U /*!< @brief NSK device */
403 //#define NSK2HDI_CMCHANNEL_TABLE_DEVICE_TYPE 0x00000004U /*!< @brief CM Channel Table device */
404 //#define NSK2HDI_M2MTABLE_DEVICE_TYPE 0x00000008U /*!< @brief M2M Table device */
405
406 NSK_TRACE(("child_device_num = %x\n",*child_device_num));
407
408 if(child_device == NULL)
409 {
410 //should fill the number of child device...
411 *child_device_num = 4;
412 return NSK2HDI_STATUS_OK;
413 }
414
415 *child_device_num = 4;
416
417 child_device[0].device_id = 0x3333;
418 child_device[0].device_type= NSK2HDI_NSK_DEVICE_TYPE;
419 child_device[1].device_id = 0x4444;
420 child_device[1].device_type= NSK2HDI_CMCHANNEL_TABLE_DEVICE_TYPE;
421 child_device[2].device_id = 0x2222;
422 child_device[2].device_type= NSK2HDI_OTP_DEVICE_TYPE;
423 child_device[3].device_id = 0x8888;
424 child_device[3].device_type= NSK2HDI_M2MTABLE_DEVICE_TYPE;
425
426 NSK_TRACE(("Exit\n"));
427 return NSK2HDI_STATUS_OK;
428 }
NSKHDI_CaSoCGroupDevice_RegisterEnumerationChangeCB(NSK2HDI_HANDLE CaSoCGroup_handle,HDINSK2_ENUMERATION_CHANGE_CB_FN * cb_routine,void * cookie)429
430 NSK2HDI_STATUS NSKHDI_CaSoCGroupDevice_RegisterEnumerationChangeCB (NSK2HDI_HANDLE CaSoCGroup_handle,
431 HDINSK2_ENUMERATION_CHANGE_CB_FN *cb_routine,
432 void *cookie)
433 {
434 NSK_TRACE(("Enter\n"));
435
436 NSK_TRACE(("Exit\n"));
437 return NSK2HDI_STATUS_OK;
438 }
439
440
441
442 /*****************************************************************************\
443 \ Content Module - Table device
444 \*****************************************************************************/
445
446
NSKHDI_CmChannelTable_Open(NSK2HDI_DEVICE_ID CmChannelTable_ID,NSK2HDI_HANDLE * CmChannelTable_handle)447
448 NSK2HDI_STATUS NSKHDI_CmChannelTable_Open (NSK2HDI_DEVICE_ID CmChannelTable_ID,
449 NSK2HDI_HANDLE *CmChannelTable_handle)
450 {
451 NSK_TRACE(("Enter\n"));
452
453 if(CmChannelTableInfo.alloc == TRUE)
454 {
455 NSK_ERROR(("CmChannelTable is already open\n"));
456 }
457
458 CmChannelTableInfo.CmChTable_ID = CmChannelTable_ID;
459 CmChannelTableInfo.alloc = TRUE;
460 CmChannelTableInfo.handle_id = 1;
461
462 *CmChannelTable_handle = (NSK2HDI_HANDLE *)&CmChannelTableInfo.handle_id;
463
464 NSK_TRACE(("CmChannelTable_ID = 0x%x, CmChannelTable_handle = 0x%08x\n",CmChannelTable_ID,CmChannelTableInfo.handle_id));
465 NSK_TRACE(("Exit\n"));
466 return NSK2HDI_STATUS_OK;
467 }
NSKHDI_CmChannelTable_Close(NSK2HDI_HANDLE CmChannelTable_handle)468
469 NSK2HDI_STATUS NSKHDI_CmChannelTable_Close (NSK2HDI_HANDLE CmChannelTable_handle)
470 {
471 NSK_TRACE(("Enter\n"));
472 MS_U32 u32Handle = NSKHDI_GetHandle(CmChannelTable_handle);
473 NSK_TRACE(("CmChannelTable_handle = 0x%08x\n",u32Handle));
474
475 CmChannelTableInfo.alloc = FALSE;
476
477 NSK_TRACE(("Exit\n"));
478 return NSK2HDI_STATUS_OK;
479 }
NSKHDI_CmChannelTable_EnumerateChildren(NSK2HDI_HANDLE CmChannelTable_handle,NDS_ULONG * child_device_num,NSK2HDI_CHILD_DEVICE * child_device)480
481 NSK2HDI_STATUS NSKHDI_CmChannelTable_EnumerateChildren( NSK2HDI_HANDLE CmChannelTable_handle,
482 NDS_ULONG *child_device_num,
483 NSK2HDI_CHILD_DEVICE *child_device)
484 {
485 NSK_TRACE(("Enter\n"));
486 MS_U32 cm_ch_num;
487
488 if(child_device == NULL)
489 {
490 //should fill the number of child device...
491 *child_device_num = MDrv_NSK2_CMChannelNum();
492 NSK_TRACE(("return child_device_num = %x\n",*child_device_num));
493 return NSK2HDI_STATUS_OK;
494 }
495 *child_device_num = MDrv_NSK2_CMChannelNum();
496
497 NSK_TRACE(("child_device_num = %x\n",*child_device_num));
498
499 cm_ch_num = *child_device_num;
500
501 if(cm_ch_num>2)
502 {
503 NSK_ERROR(("cm_ch_num>2\n"));
504 }
505
506 child_device[0].device_id = CMChannel_ID1;
507 child_device[0].device_type = NSK2HDI_CMCHANNEL_GROUP_DEVICE_TYPE;
508
509 if(cm_ch_num == 2)
510 {
511 child_device[1].device_id = CMChannel_ID2;
512 child_device[1].device_type = NSK2HDI_CMCHANNEL_GROUP_DEVICE_TYPE;
513 }
514
515 NSK_TRACE(("Exit\n"));
516 return NSK2HDI_STATUS_OK;
517 }
518
519 /*****************************************************************************\
520 \ Content Module - Group device
521 \*****************************************************************************/
522
NSKHDI_CmChannelGroup_Open(NSK2HDI_DEVICE_ID CmChannelGroup_ID,NSK2HDI_HANDLE * CmChannelGroup_handle)523
524 NSK2HDI_STATUS NSKHDI_CmChannelGroup_Open (NSK2HDI_DEVICE_ID CmChannelGroup_ID,
525 NSK2HDI_HANDLE *CmChannelGroup_handle)
526 {
527 NSK_TRACE(("Enter\n"));
528 CmChannelGroup_t *pGroup;
529
530 //check CmChannel Group ID.
531
532 if( (CmChannelGroup_ID != CMChannel_ID1) && (CmChannelGroup_ID != CMChannel_ID2) )
533 {
534 NSK_ERROR(("CmChannelGroup_ID is wrong\n"));
535 return NSK2HDI_STATUS_FAILED;
536 }
537
538 pGroup = MApi_NSK2_AllocateMemory(sizeof(CmChannelGroup_t), TRUE);
539 if(NULL == pGroup)
540 {
541 NSK_ERROR(("cm channel group allocate buffer error\n"));
542 return NSK2HDI_STATUS_FAILED;
543 }
544
545 memset(pGroup, 0x0, sizeof(CmChannelGroup_t));
546
547 pGroup->CmChGroup_ID = CmChannelGroup_ID;
548
549 *CmChannelGroup_handle = (NSK2HDI_HANDLE*)pGroup;
550
551 NSK_TRACE(("CmChannelGroup_ID = %x, CmChannelGroup_handle = %p\n",CmChannelGroup_ID,pGroup));
552
553 NSK_TRACE(("Exit\n"));
554 return NSK2HDI_STATUS_OK;
555 }
NSKHDI_CmChannelGroup_Close(NSK2HDI_HANDLE CmChannelGroup_handle)556
557 NSK2HDI_STATUS NSKHDI_CmChannelGroup_Close (NSK2HDI_HANDLE CmChannelGroup_handle)
558 {
559 NSK_TRACE(("Enter\n"));
560 MS_BOOL bFlag;
561
562 bFlag = MApi_NSK2_FreeMemory(CmChannelGroup_handle, TRUE);
563
564 if(bFlag == FALSE)
565 {
566 NSK_ERROR(("free memory error\n"));
567 }
568
569 NSK_TRACE(("Exit\n"));
570 return NSK2HDI_STATUS_OK;
571 }
NSKHDI_CmChannelGroup_GetProperties(NSK2HDI_HANDLE CmChannelGroup_handle,NDS_ULONG request_id,NDS_ULONG * desc_size,NDS_UBYTE * desc)572
573 NSK2HDI_STATUS NSKHDI_CmChannelGroup_GetProperties( NSK2HDI_HANDLE CmChannelGroup_handle,
574 NDS_ULONG request_id,
575 NDS_ULONG *desc_size,
576 NDS_UBYTE *desc)
577 {
578 CmChannelGroup_t *pGroup = (CmChannelGroup_t *)CmChannelGroup_handle;
579 NSK_TRACE(("Enter\n"));
580 NSK_TRACE(("CmChGroup_ID = %x, request_id = %x, desc_size = %x\n",pGroup->CmChGroup_ID, request_id, *desc_size));
581
582
583 if(NSK2HDI_CMCHANNELGROUP_READ_ALL_DESCRIPTORS_REQUEST != request_id)
584 {
585 NSK_ERROR(("error request_id\n"));
586 return NSK2HDI_STATUS_INVALID_REQUEST;
587 }
588
589
590 if(desc == NULL)
591 {
592 MDrv_NSK2_GetCMProperties((MS_U32*)desc_size, (MS_U8*)desc);
593 NSK_TRACE(("return desc_size = 0x%08x\n",(MS_U32)*desc_size));
594 return NSK2HDI_STATUS_OK;
595 }
596
597 if(*desc_size == 0)
598 {
599 return NSK2HDI_STATUS_INVALID_REQUEST;
600 }
601
602 MDrv_NSK2_GetCMProperties((MS_U32*)desc_size, (MS_U8*)desc);
603 NSK_TRACE(("Exit\n"));
604
605 return NSK2HDI_STATUS_OK;
606 }
607
608 /*****************************************************************************\
609 \ Content Module - Device
610 \*****************************************************************************/
611
NSKHDI_CmChannelDevice_Open(NSK2HDI_DEVICE_ID CmChannelGroup_ID,NSK2HDI_HANDLE * CmChannele_handle)612
613 NSK2HDI_STATUS NSKHDI_CmChannelDevice_Open (NSK2HDI_DEVICE_ID CmChannelGroup_ID,
614 NSK2HDI_HANDLE *CmChannele_handle)
615 {
616 NSK_TRACE(("Enter\n"));
617
618 NSK2_CMChannel_Info *cm_handle;
619 NSK_TRACE(("CmChannelGroup_ID = 0x%08x\n",(MS_U32)CmChannelGroup_ID));
620
621 cm_handle = MApi_NSK2_AllocateMemory(sizeof(NSK2_CMChannel_Info), TRUE);
622 if(NULL == cm_handle)
623 {
624 NSK_ERROR(("cm handle allocate buffer error\n"));
625 return NSK2HDI_STATUS_FAILED;
626 }
627
628 memset(cm_handle, 0x0, sizeof(NSK2_CMChannel_Info));
629
630 cm_handle->dsc_id = cm_handle->CmChCookie.u32DscmbId = MDrv_DSCMB2_FltAlloc_Ex(0,E_DSCMB_FLT_3_KEYS);
631
632 NSK_TRACE(("CmChannele_handle = %p, CmChannelGroup_ID = 0x%08x\n",cm_handle,(MS_U32)CmChannelGroup_ID));
633 NSK_TRACE(("dsc_id = 0x%08x\n",cm_handle->dsc_id));
634
635 if(DRV_DSCMB_FLT_NULL == cm_handle->dsc_id)
636 {
637 NSK_ERROR(("dscmb alloc flt fail\n"));
638 *CmChannele_handle = NSK2HDI_ILLEGAL_HANDLE;
639 MApi_NSK2_FreeMemory(cm_handle, TRUE);
640 return NSK2HDI_STATUS_FAILED;
641 }
642
643 *CmChannele_handle = cm_handle;
644 NSK_TRACE(("Exit, CmChannelDevice_handle = %p\n", *CmChannele_handle));
645
646 return NSK2HDI_STATUS_OK;
647 }
NSKHDI_CmChannelDevice_Close(NSK2HDI_HANDLE CmChannele_handle)648
649 NSK2HDI_STATUS NSKHDI_CmChannelDevice_Close (NSK2HDI_HANDLE CmChannele_handle)
650 {
651
652 NSK_TRACE(("Enter CmChannelDevice_handle = %p\n",CmChannele_handle));
653 NSK2_CMChannel_Info *cm_handle;
654
655 if(NULL == CmChannele_handle)
656 {
657 return NSK2HDI_STATUS_INVALID_REQUEST;
658 }
659
660 cm_handle = (NSK2_CMChannel_Info *)CmChannele_handle;
661
662 NSK_TRACE(("dsc_id = %x\n",cm_handle->dsc_id));
663
664 if(cm_handle->CmChCookie.bConnect == TRUE)
665 {
666 MDrv_DSCMB2_FltDisconnectFltId(0,cm_handle->dsc_id,cm_handle->CmChCookie.PidSlotID);
667 }
668 //should stop...de-allocate here.
669 MDrv_DSCMB2_FltFree(0, cm_handle->dsc_id); //the 0 magic value, maybe need to re-fine....
670
671 memset(cm_handle, 0x0, sizeof(NSK2_CMChannel_Info));
672
673 MApi_NSK2_FreeMemory(cm_handle, TRUE);
674 NSK_TRACE(("Exit\n"));
675
676 return NSK2HDI_STATUS_OK;
677 }
678
NSKHDI_CmChannel_SetWriteESA(NDS_UBYTE ESA_Algo,MS_U32 PidSlotID)679
680 NSK2HDI_STATUS NSKHDI_CmChannel_SetWriteESA(NDS_UBYTE ESA_Algo, MS_U32 PidSlotID)
681 {
682 NDS_UBYTE ESASelect = 0, ESASubSelect = 0;
683 NSK_TRACE(("Enter, ESA_Algo = %d, FltID = 0x%08x\n", ESA_Algo, PidSlotID));
684
685 if(ESA_Algo == NSK2HDI_SPROFILE_DVB_CSA2)
686 {
687 ESASelect = ESA_SELECT_DVBCSA2;
688 ESASubSelect = ESASUB_SELECT_NONE;
689 }
690 else if (ESA_Algo == NSK2HDI_SPROFILE_DVB_CSA_CONFORMANCE)
691 {
692 ESASelect = ESA_SELECT_DVBCSA2_CONF;
693 ESASubSelect = ESASUB_SELECT_NONE;
694 }
695 else if (ESA_Algo == NSK2HDI_SPROFILE_DVB_CSA3)
696 {
697 ESASelect = ESA_SELECT_DVBCSA3;
698 ESASubSelect = ESASUB_SELECT_NONE;
699 }
700 else if (ESA_Algo == NSK2HDI_SPROFILE_CPCM_LSA_MDI_CBC)
701 {
702 ESASelect = ESA_SELECT_AES;
703 ESASubSelect = ESASUB_SELECT_MDI_CBC;
704 }
705 else if (ESA_Algo == NSK2HDI_SPROFILE_CPCM_LSA_MDI_RCBC)
706 {
707 #if 1
708 NSK_ERROR(("NSK2HDI_SPROFILE_CPCM_LSA_MDI_RCBC NOT SUPPORT\n"));
709 #else
710 ESASelect = ESA_SELECT_AES;
711 ESASubSelect = DSCMB_SUBALGO_MDI_RCBC;
712
713 #endif
714 }
715 else if (ESA_Algo == NSK2HDI_SPROFILE_CPCM_LSA_MDD_CBC)
716 {
717 #if 1
718 NSK_ERROR(("NSK2HDI_SPROFILE_CPCM_LSA_MDD_CBC NOT SUPPORT\n"));
719 #else
720 ESASelect = DSCMB_ALGOTYPE_AES;
721 ESASubSelect = DSCMB_SUBALGO_MDD_CBC;
722
723 #endif
724 }
725 else if (ESA_Algo == NSK2HDI_SPROFILE_CPCM_LSA_MDD_RCBC)
726 {
727 #if 1
728 NSK_ERROR(("NSK2HDI_SPROFILE_CPCM_LSA_MDD_RCBC NOT SUPPORT\n"));
729 #else
730 ESASelect = DSCMB_ALGOTYPE_AES;
731 ESASubSelect = DSCMB_SUBALGO_MDD_RCBC;
732 #endif
733 }
734 else if (ESA_Algo == NSK2HDI_SPROFILE_SYNAMEDIA_AES)
735 {
736 ESASelect = ESA_SELECT_AES;
737 ESASubSelect = ESASUB_SELECT_SYNAMEDIA_AES;
738 }
739 else if (ESA_Algo == NSK2HDI_SPROFILE_AES_ECB_CLEARTAIL)
740 {
741 ESASelect = ESA_SELECT_AES;
742 ESASubSelect = ESASUB_SELECT_AES_ECB_CLR;
743 }
744 else if (ESA_Algo == NSK2HDI_SPROFILE_CIPLUS_AES)
745 {
746 ESASelect = ESA_SELECT_AES;
747 ESASubSelect = ESASUB_SELECT_CIPLUS_AES;
748 }
749 else if (ESA_Algo == NSK2HDI_SPROFILE_SCTE41_DES)
750 {
751 ESASelect = ESA_SELECT_DES;
752 ESASubSelect = ESASUB_SELECT_SCTE41;
753 }
754 else if (ESA_Algo == NSK2HDI_SPROFILE_SCTE52_DES)
755 {
756 ESASelect = ESA_SELECT_DES;
757 ESASubSelect = ESASUB_SELECT_SCTE52;
758 }
759 else if (ESA_Algo == NSK2HDI_SPROFILE_TDES_ECB_CLEARTAIL)
760 {
761 ESASelect = ESA_SELECT_TDES;
762 ESASubSelect = ESASUB_SELECT_NONE;
763 }
764 else
765 {
766 NSK_TRACE(("Not implement\n"));
767 }
768
769 MDrv_NSK2_WriteESA(ESASelect, ESASubSelect, PidSlotID);
770
771 NSK_TRACE(("Exit\n"));
772 return NSK2HDI_STATUS_OK;
773 }
774
NSKHDI_CmChannel_ParseDesc(NDS_ULONG desc_size,const NDS_UBYTE * pdesc,CmChDesc_Parser_t * pDescParser)775
776 NSK2HDI_STATUS NSKHDI_CmChannel_ParseDesc(NDS_ULONG desc_size,const NDS_UBYTE *pdesc, CmChDesc_Parser_t *pDescParser)
777 {
778 NDS_ULONG size = desc_size;
779 NDS_UBYTE *pParser_buf = (NDS_UBYTE*)pdesc;
780 NDS_UBYTE TagSwitch, TagLength;
781
782 NSK_TRACE(("desc_size = %x, pdesc = %x\n",desc_size, (NDS_ULONG)pdesc));
783 while(size>0)
784 {
785 NSK_TRACE(("desc buf = %x\n",*pParser_buf++));
786 size --;
787 }
788
789 size = desc_size;
790 pParser_buf = (NDS_UBYTE*)pdesc;
791
792 while(size>=3)
793 {
794 TagSwitch = pParser_buf[0];
795 TagLength = pParser_buf[1];
796
797 NSK_TRACE(("TagSwitch = %x, TagLength = %x\n",TagSwitch,TagLength));
798
799 switch(TagSwitch)
800 {
801 case NSK2HDI_CMCHANNEL_IV1_DESC_TAG:
802 NSK_TRACE(("CMCHANNEL_IV1_DESC_TAG length = %x\n",TagLength));
803 memcpy(pDescParser->IV1, &pParser_buf[2], TagLength);
804 pDescParser->IV1_Enable = TRUE;
805 break;
806
807 case NSK2HDI_CMCHANNEL_IV2_DESC_TAG:
808 NSK_TRACE(("CMCHANNEL_IV2_DESC_TAG length = %x\n",TagLength));
809 memcpy(pDescParser->IV2, &pParser_buf[2], TagLength);
810 pDescParser->IV2_Enable = TRUE;
811 break;
812
813 case NSK2HDI_CMCHANNEL_ALGORITHM_DESC_TAG:
814 pDescParser->Algorithm = pParser_buf[2];
815 NSK_TRACE(("ALGORITHM_DESC_TAG, Algorithm = %x\n",pDescParser->Algorithm));
816 break;
817
818 case NSK2HDI_CMCHANNEL_IV_SIGNALING_DESC_TAG:
819 NSK_TRACE(("IV_SIGNALING_DESC_TAG iv_signaling = %x\n", pParser_buf[3]));
820 pDescParser->IV_Mode = pParser_buf[3];
821 if(pParser_buf[3] == NSK2HDI_CMCHANNEL_IV_AT_CONFIG_MODE)
822 {
823 NSK_TRACE(("NSK2HDI_CMCHANNEL_IV_AT_CONFIG_MODE\n"));
824 }
825 else if(pParser_buf[3] == NSK2HDI_CMCHANNEL_IV_NOT_SET_MODE)
826 {
827 NSK_TRACE(("NSK2HDI_CMCHANNEL_IV_NOT_SET_MODE\n"));
828 }
829 else if(pParser_buf[3] == NSK2HDI_CMCHANNEL_IV_AT_WRITEKEY_MODE)
830 {
831 NSK_TRACE(("NSK2HDI_CMCHANNEL_IV_AT_WRITEKEY_MODE\n"));
832 }
833 break;
834
835 default:
836 NSK_ERROR(("unknown desc tag\n"));
837 break;
838 }
839
840 size -= (TagLength+2);
841 pParser_buf += (TagLength+2);
842 }
843
844 return NSK2HDI_STATUS_OK;
845 }
846
NSKHDI_CmChannelDevice_Configure(NSK2HDI_HANDLE CmChannele_handle,NDS_ULONG lda_desc_size,const NDS_UBYTE * lda_desc,NDS_ULONG esa_desc_size,const NDS_UBYTE * esa_desc,NDS_ULONG lsa_desc_size,const NDS_UBYTE * lsa_desc)847
848 NSK2HDI_STATUS NSKHDI_CmChannelDevice_Configure ( NSK2HDI_HANDLE CmChannele_handle,
849 NDS_ULONG lda_desc_size,
850 const NDS_UBYTE *lda_desc,
851 NDS_ULONG esa_desc_size,
852 const NDS_UBYTE *esa_desc,
853 NDS_ULONG lsa_desc_size,
854 const NDS_UBYTE *lsa_desc)
855 {
856 NSK_TRACE(("Enter\n"));
857 CmChannel_IV1_Desc_t ESA_IV1_Payload;
858 CmChannel_IV2_Desc_t ESA_IV2_Payload;
859 CmChDesc_Parser_t *pCmDescParser;
860 NSK2_CMChannel_Info *cm_handle;
861
862 if(NULL == CmChannele_handle)
863 {
864 return NSK2HDI_STATUS_INVALID_REQUEST;
865 }
866
867 cm_handle = (NSK2_CMChannel_Info *)CmChannele_handle;
868 pCmDescParser = (CmChDesc_Parser_t *) &cm_handle->CmChDesc[0];
869
870 memset(&ESA_IV1_Payload, 0x0, sizeof(CmChannel_IV1_Desc_t));
871 memset(&ESA_IV2_Payload, 0x0, sizeof(CmChannel_IV2_Desc_t));
872
873
874 NSK_TRACE(("lda_desc_size = %x, esa_desc_size = %x, lsa_desc_size = %x\n",lda_desc_size,esa_desc_size,lsa_desc_size));
875
876 if( (lda_desc!=NULL) && (lda_desc_size!=0) )
877 {
878 NSKHDI_CmChannel_ParseDesc(lda_desc_size,lda_desc,(CmChDesc_Parser_t *)&pCmDescParser[CMCHANNEL_LDA_DESC]);
879 }
880 else
881 {
882 //NSK_TRACE(("lda_desc_size = 0\n"));
883 }
884
885 NSK_TRACE(("esa_desc_size = %x\n",esa_desc_size));
886 if( (esa_desc!=NULL) && (esa_desc_size!=0) )
887 {
888 NSKHDI_CmChannel_ParseDesc(esa_desc_size,esa_desc,(CmChDesc_Parser_t *)&pCmDescParser[CMCHANNEL_ESA_DESC]);
889 //NSKHDI_CmChannel_SetWriteESA(pCmDescParser[CMCHANNEL_ESA_DESC].Algorithm, PidSlotID);
890 }
891 else
892 {
893 //NSK_TRACE(("esa_desc_size = 0\n"));
894 }
895
896 NSK_TRACE(("lsa_desc_size = %x\n",lsa_desc_size));
897 if( (lsa_desc!=NULL) && (lsa_desc_size!=0) )
898 {
899 NSKHDI_CmChannel_ParseDesc(lsa_desc_size,lsa_desc,(CmChDesc_Parser_t *)&pCmDescParser[CMCHANNEL_LSA_DESC]);
900 }
901 else
902 {
903 //NSK_TRACE(("lsa_desc_size = 0\n"));
904 }
905
906 memcpy(&cm_handle->CmChCookie.CmChDesc[0], pCmDescParser, sizeof(CmChDesc_Parser_t)*3 );
907
908 NSK_TRACE(("Exit\n"));
909 return NSK2HDI_STATUS_OK;
910 }
NSKHDI_CmChannelDevice_InvalidateKeys(NSK2HDI_HANDLE CmChannelDevice_handle)911
912 NSK2HDI_STATUS NSKHDI_CmChannelDevice_InvalidateKeys (NSK2HDI_HANDLE CmChannelDevice_handle)
913 {
914 NSK_TRACE(("Enter CmChannelDevice_handle = %p\n",CmChannelDevice_handle));
915 MS_U32 u32DscmbId;
916
917 NSK2_CMChannel_Info *cm_handle;
918
919 if(NULL == CmChannelDevice_handle)
920 {
921 return NSK2HDI_STATUS_INVALID_REQUEST;
922 }
923
924 cm_handle = (NSK2_CMChannel_Info *)CmChannelDevice_handle;
925
926
927 u32DscmbId = cm_handle->dsc_id;
928
929 //if(cm_handle->CmChCookie.bConnect == TRUE)
930 {
931 //MDrv_DSCMB2_FltDisconnectFltId(0,u32DscmbId,u32FltId);
932 MDrv_DSCMB2_FltKeyReset(0,u32DscmbId,E_DSCMB_KEY_CLEAR);
933 MDrv_DSCMB2_FltKeyReset(0,u32DscmbId,E_DSCMB_KEY_EVEN);
934 MDrv_DSCMB2_FltKeyReset(0,u32DscmbId,E_DSCMB_KEY_ODD);
935 }
936
937 NSK_TRACE(("Exit\n"));
938 return NSK2HDI_STATUS_OK;
939 }
NSKHDI_CmChannelDevice_WriteTransportKey(NSK2HDI_HANDLE CmChannelDevice_handle,NDS_ULONG scb_in_out_size,NDS_UBYTE * scb_in,NDS_UBYTE * scb_out,NDS_ULONG lda_desc_size,const NDS_UBYTE * lda_desc,NDS_ULONG esa_desc_size,const NDS_UBYTE * esa_desc,NDS_ULONG lsa_desc_size,const NDS_UBYTE * lsa_desc)940
941 NSK2HDI_STATUS NSKHDI_CmChannelDevice_WriteTransportKey ( NSK2HDI_HANDLE CmChannelDevice_handle,
942 NDS_ULONG scb_in_out_size,
943 NDS_UBYTE *scb_in,
944 NDS_UBYTE *scb_out,
945 NDS_ULONG lda_desc_size,
946 const NDS_UBYTE *lda_desc,
947 NDS_ULONG esa_desc_size,
948 const NDS_UBYTE *esa_desc,
949 NDS_ULONG lsa_desc_size,
950 const NDS_UBYTE *lsa_desc)
951 {
952 NSK2_CMChannel_Info *cm_handle;
953 NSK_TRACE(("Enter CmChannelDevice_handle = %p\n",CmChannelDevice_handle));
954
955 if(NULL == CmChannelDevice_handle)
956 {
957 return NSK2HDI_STATUS_INVALID_REQUEST;
958 }
959
960 cm_handle = (NSK2_CMChannel_Info *)CmChannelDevice_handle;
961
962 NDS_ULONG i = 0;
963 ESA_Desc_St_t tEsaDesc;
964 MS_U8 test_key[16];
965 NDS_UBYTE SCB = 0, SCB_Out = 0;
966 MS_U32 DscmbID = 0;
967 NDS_UBYTE CurSCB_In,CurSCB_Out;
968
969 CmChDesc_Parser_t *pCmDescParser;
970
971 NSK_TRACE(("Time of Two Keys = %x\n", (MsOS_GetSystemTime() - _gu32WriteKeyTime) ));
972 //printf("write key = %d\n",MsOS_GetSystemTime());
973
974 pCmDescParser = (CmChDesc_Parser_t *) &cm_handle->CmChDesc[0];
975
976 memset(test_key,0x0,16);
977 memset(&tEsaDesc,0x0,sizeof(ESA_Desc_St_t));
978
979 DscmbID = cm_handle->dsc_id;
980 NSK_TRACE(("DscmbID = %d\n",DscmbID));
981
982 //this routine is used to cause the NSK chip to copy the keys and control switches
983 //from the NSK KTE register to the NSK chip key table.
984 NSK_TRACE(("scb_in_out_size = %x, lda_desc_size = %x\n",scb_in_out_size, lda_desc_size));
985 NSK_TRACE(("esa_desc_size = %x, lsa_desc_size = %x\n",esa_desc_size, lsa_desc_size));
986
987 //NSK2DBG_KTEValid(1,DscmbID);
988 NSK_TRACE(("lda_desc_size = %x, esa_desc_size = %x, lsa_desc_size = %x\n",lda_desc_size,esa_desc_size,lsa_desc_size));
989
990 if( (lda_desc!=NULL) && (lda_desc_size!=0) )
991 {
992 NSKHDI_CmChannel_ParseDesc(lda_desc_size,lda_desc,(CmChDesc_Parser_t *)&pCmDescParser[CMCHANNEL_LDA_DESC]);
993 }
994 else
995 {
996 }
997
998 if( (esa_desc!=NULL) && (esa_desc_size!=0) )
999 {
1000 NSKHDI_CmChannel_ParseDesc(esa_desc_size,esa_desc,(CmChDesc_Parser_t *)&pCmDescParser[CMCHANNEL_ESA_DESC]);
1001 }
1002 else
1003 {
1004 //NSK_TRACE(("esa_desc_size = 0\n"));
1005 }
1006
1007 if( (lsa_desc!=NULL) && (lsa_desc_size!=0) )
1008 {
1009 NSKHDI_CmChannel_ParseDesc(lsa_desc_size,lsa_desc,(CmChDesc_Parser_t *)&pCmDescParser[CMCHANNEL_LSA_DESC]);
1010 }
1011 else
1012 {
1013
1014 }
1015
1016
1017 if(cm_handle->CmChCookie.bWriteESA == FALSE)
1018 {
1019 MDrv_NSK21_CfgCmChannel(DscmbID, pCmDescParser[CMCHANNEL_LDA_DESC].Algorithm,
1020 pCmDescParser[CMCHANNEL_ESA_DESC].Algorithm, pCmDescParser[CMCHANNEL_LSA_DESC].Algorithm, 0);
1021 }
1022
1023
1024 while(i < scb_in_out_size)
1025 {
1026 NSK_TRACE(("(%d, %x, %x) \n",i,*(scb_in+i),*(scb_out+i)));
1027 CurSCB_In = *(scb_in+i);
1028 CurSCB_Out = *(scb_out+i);
1029
1030 //scb value is match with the HW test patterns
1031 if(CurSCB_In == NSK2HDI_CMCHANNEL_ODD_PARITY)
1032 {
1033 SCB = 0x3;
1034 }
1035 else if(CurSCB_In == NSK2HDI_CMCHANNEL_EVEN_PARITY)
1036 {
1037 SCB = 0x2;
1038 }
1039 else if(CurSCB_In == NSK2HDI_CMCHANNEL_CLEAR_PARITY)
1040 {
1041 SCB = 0x0;
1042 }
1043
1044 if(CurSCB_Out == NSK2HDI_CMCHANNEL_ODD_PARITY)
1045 {
1046 SCB_Out = 0x3;
1047 }
1048 else if(CurSCB_Out == NSK2HDI_CMCHANNEL_EVEN_PARITY)
1049 {
1050 SCB_Out = 0x2;
1051 }
1052 else if(CurSCB_Out == NSK2HDI_CMCHANNEL_CLEAR_PARITY)
1053 {
1054 SCB_Out = 0x0;
1055 }
1056
1057 NSK_TRACE(("SCB_In = %x, SCB_Out = %x\n",SCB,SCB_Out));
1058
1059
1060 MDrv_NSK21_WriteTransportKey(SCB, SCB_Out,
1061 pCmDescParser[CMCHANNEL_LDA_DESC].IV1, pCmDescParser[CMCHANNEL_LDA_DESC].IV2,
1062 pCmDescParser[CMCHANNEL_ESA_DESC].IV1, pCmDescParser[CMCHANNEL_ESA_DESC].IV2,
1063 pCmDescParser[CMCHANNEL_LSA_DESC].IV1, pCmDescParser[CMCHANNEL_LSA_DESC].IV2, DscmbID);
1064
1065 MS_U8 WriteESAIV[16], WriteLSADIV[16], WriteLSASIV[16];
1066 memset(WriteESAIV, 0x0, 16);
1067 memset(WriteLSADIV, 0x0, 16);
1068 memset(WriteLSASIV, 0x0, 16);
1069
1070 CmChDesc_Parser_t *pESAParser = &pCmDescParser[CMCHANNEL_ESA_DESC];
1071 CmChDesc_Parser_t *pLDAParser = &pCmDescParser[CMCHANNEL_LDA_DESC];
1072 CmChDesc_Parser_t *pLSAParser = &pCmDescParser[CMCHANNEL_LSA_DESC];
1073
1074 DSCMB_Key_Type eKeyType = E_DSCMB_KEY_CLEAR;
1075 if(SCB == 0){
1076 eKeyType = E_DSCMB_KEY_CLEAR;
1077 }
1078 else if(SCB == 2){
1079 eKeyType = E_DSCMB_KEY_EVEN;
1080 }
1081 else if(SCB == 3){
1082 eKeyType = E_DSCMB_KEY_ODD;
1083 }
1084
1085 #if 1
1086 //if(pLDAParser->IV1_Enable)
1087 {
1088 memcpy(WriteLSADIV,pLDAParser->IV1,16);
1089
1090 if(pLDAParser->IV2_Enable)
1091 memcpy(&WriteLSADIV[8], pLDAParser->IV2, 8);
1092
1093 MDrv_DSCMB2_EngSetIV_Ex(0, DscmbID, E_DSCMB_ENG_LSAD, eKeyType, WriteLSADIV);
1094 }
1095
1096 //if(pESAParser->IV1_Enable)
1097 {
1098 memcpy(WriteESAIV,pESAParser->IV1,16);
1099
1100 if(pESAParser->IV2_Enable)
1101 memcpy(&WriteESAIV[8], pESAParser->IV2, 8);
1102
1103 MDrv_DSCMB2_EngSetIV_Ex(0, DscmbID, E_DSCMB_ENG_ESA, eKeyType, (MS_U8*)WriteESAIV);
1104 }
1105
1106 //if(pLSAParser->IV1_Enable)
1107 {
1108 memcpy(WriteLSASIV,pLSAParser->IV1,16);
1109
1110 if(pLSAParser->IV2_Enable)
1111 memcpy(&WriteLSASIV[8], pLSAParser->IV2, 8);
1112
1113 MDrv_DSCMB2_EngSetIV_Ex(0, DscmbID, E_DSCMB_ENG_LSAS, eKeyType, WriteLSASIV);
1114 }
1115 #endif
1116
1117 i++;
1118 }
1119
1120 _gu32WriteKeyTime = MsOS_GetSystemTime();
1121
1122 NSK_TRACE(("Exit\n"));
1123 return NSK2HDI_STATUS_OK;
1124 }
NSKHDI_CmChannelDevice_GetCookie(NSK2HDI_HANDLE CmChannelDevice_handle,void ** cookie)1125
1126 NSK2HDI_STATUS NSKHDI_CmChannelDevice_GetCookie(NSK2HDI_HANDLE CmChannelDevice_handle,
1127 void **cookie)
1128 {
1129 NSK2_CMChannel_Info *cm_handle;
1130 NSK_TRACE(("Enter\n"));
1131
1132 if(NULL == CmChannelDevice_handle)
1133 {
1134 return NSK2HDI_STATUS_INVALID_REQUEST;
1135 }
1136
1137 cm_handle = (NSK2_CMChannel_Info *)CmChannelDevice_handle;
1138
1139 *cookie = &cm_handle->CmChCookie;
1140
1141 NSK_TRACE(("test_cookie = %p\n", *cookie));
1142
1143 NSK_TRACE(("Exit\n"));
1144 return NSK2HDI_STATUS_OK;
1145 }
1146
1147 /*****************************************************************************\
1148 \ Content Module - CA PID Proxy devices
1149 \*****************************************************************************/
1150
NSKHDI_CaPIDProxy_Open(NDS_ULONG xconn,NSK2HDI_HANDLE * CaPIDProxy_handle)1151
1152 NSK2HDI_STATUS NSKHDI_CaPIDProxy_Open (NDS_ULONG xconn,
1153 NSK2HDI_HANDLE *CaPIDProxy_handle)
1154 {
1155 NSK_TRACE(("Enter, xconn = %x\n",xconn));
1156
1157 CaPID_Info *pCaPidProxy;
1158 pCaPidProxy = MApi_NSK2_AllocateMemory(sizeof(CaPID_Info), TRUE);
1159 if(NULL == pCaPidProxy)
1160 {
1161 NSK_ERROR(("pCaPidProxy allocate buffer error\n"));
1162 return NSK2HDI_STATUS_FAILED;
1163 }
1164
1165 memset(pCaPidProxy, 0x0, sizeof(CaPID_Info));
1166
1167 pCaPidProxy->xconn = xconn;
1168
1169 *CaPIDProxy_handle = (NSK2HDI_HANDLE)pCaPidProxy;
1170
1171 NSK_TRACE(("Exit\n"));
1172 return NSK2HDI_STATUS_OK;
1173 }
NSKHDI_CaPIDProxy_Close(NSK2HDI_HANDLE CaPIDProxy_handle)1174
1175 NSK2HDI_STATUS NSKHDI_CaPIDProxy_Close (NSK2HDI_HANDLE CaPIDProxy_handle)
1176 {
1177 NSK_TRACE(("Enter\n"));
1178
1179 if(NULL == CaPIDProxy_handle)
1180 {
1181 return NSK2HDI_STATUS_INVALID_REQUEST;
1182 }
1183
1184 MApi_NSK2_FreeMemory(CaPIDProxy_handle, TRUE);
1185
1186 NSK_TRACE(("Exit\n"));
1187 return NSK2HDI_STATUS_OK;
1188 }
NSKHDI_CaPIDProxy_SetPrimaryStreamPID(NSK2HDI_HANDLE CaPIDProxy_handle,NDS_USHORT es_pid)1189
1190 NSK2HDI_STATUS NSKHDI_CaPIDProxy_SetPrimaryStreamPID (NSK2HDI_HANDLE CaPIDProxy_handle,
1191 NDS_USHORT es_pid)
1192 {
1193 NSK_TRACE(("Enter, es_pid = %x\n",es_pid));
1194 if(NULL == CaPIDProxy_handle)
1195 {
1196 return NSK2HDI_STATUS_INVALID_REQUEST;
1197 }
1198 CaPID_Info *pCaPidProxy = (CaPID_Info *)CaPIDProxy_handle;
1199
1200 pCaPidProxy->es_pid = es_pid;
1201
1202 NSK_TRACE(("Exit\n"));
1203 return NSK2HDI_STATUS_OK;
1204 }
1205
NSKHDI_CaPIDProxy_SetPrimaryStreamCmChannel(NSK2HDI_HANDLE CaPIDProxy_handle,void * CmChannel_cookie)1206 //in this function, we connection sepecific PID to dscmb....
1207 NSK2HDI_STATUS NSKHDI_CaPIDProxy_SetPrimaryStreamCmChannel (NSK2HDI_HANDLE CaPIDProxy_handle,
1208 void *CmChannel_cookie)
1209 {
1210 NSK_TRACE(("Enter\n"));
1211 if(NULL == CaPIDProxy_handle)
1212 {
1213 return NSK2HDI_STATUS_INVALID_REQUEST;
1214 }
1215 CaPID_Info *pCaPidProxy = (CaPID_Info *)CaPIDProxy_handle;
1216
1217 MS_U16 es_pid;
1218 CmChannelDevice_Cookie_t *pCmChDeCookie;
1219 MS_U32 u32DscmbId;
1220 NDS_UBYTE ESA_Algo;
1221 MS_U32 xconn,i;
1222 MS_U32 FilterID = 0;
1223 MS_BOOL AlreadyAdd = FALSE;
1224
1225 pCmChDeCookie = (CmChannelDevice_Cookie_t *)CmChannel_cookie;
1226 es_pid = pCaPidProxy->es_pid;
1227 xconn = pCaPidProxy->xconn;
1228
1229 pCaPidProxy->pCmCookie = CmChannel_cookie;
1230 ESA_Algo = pCmChDeCookie->CmChDesc[CMCHANNEL_ESA_DESC].Algorithm;
1231 u32DscmbId = pCmChDeCookie->u32DscmbId;
1232
1233 pCaPidProxy->dscmb_id = u32DscmbId;
1234 pCmChDeCookie->u16Pid = es_pid;
1235 pCaPidProxy->PrimePID = es_pid;
1236
1237 for(i=0;i<NSK2_CMCHANNEL_NUM;i++)
1238 {
1239 if(es_pid == _u32KeepPidByFltId[xconn][i])
1240 {
1241 FilterID = i;
1242 AlreadyAdd = TRUE;
1243 break;
1244 }
1245 }
1246
1247 //_KeepCaPidProxy
1248 for(i=0;i<NSK2_CMCHANNEL_NUM;i++)
1249 {
1250 if(FALSE == _KeepCaPidProxy[xconn][i].IsUsed)
1251 {
1252 _KeepCaPidProxy[xconn][i].IsUsed = TRUE;
1253 _KeepCaPidProxy[xconn][i].EsPid = es_pid;
1254 _KeepCaPidProxy[xconn][i].DscmbId = u32DscmbId;
1255 pCaPidProxy->ProxyGlobalIndex = i;
1256 NSK_TRACE(("KeepCaPidProxy at %d\n",i));
1257 break;
1258 }
1259 }
1260
1261 if(FALSE == AlreadyAdd) //not add...
1262 {
1263 NSK_TRACE(("Not Add Pid to TSP Filter\n"));
1264 if(FALSE == pCmChDeCookie->bWriteESA)
1265 {
1266 MDrv_NSK21_CfgCmChannel(u32DscmbId, pCmChDeCookie->CmChDesc[CMCHANNEL_LDA_DESC].Algorithm,
1267 pCmChDeCookie->CmChDesc[CMCHANNEL_ESA_DESC].Algorithm, pCmChDeCookie->CmChDesc[CMCHANNEL_LSA_DESC].Algorithm, 0);
1268 pCmChDeCookie->bWriteESA = TRUE;
1269 }
1270
1271
1272 return NSK2HDI_STATUS_OK;
1273 }
1274 else
1275 {
1276 NSK_TRACE(("Already Add TSP filter\n"));
1277
1278 //if( (pCmChDeCookie->bConnect == FALSE) )
1279 {
1280 if(MDrv_DSCMB2_FltConnectFltId(0, u32DscmbId, FilterID) == FALSE)
1281 {
1282 NSK_ERROR(("MDrv_DSCMB_FltConnectPid() failed\n"));
1283 return NSK2HDI_STATUS_FAILED;
1284 }
1285
1286 if(FALSE == pCmChDeCookie->bWriteESA)
1287 {
1288 MDrv_NSK21_CfgCmChannel(u32DscmbId, pCmChDeCookie->CmChDesc[CMCHANNEL_LDA_DESC].Algorithm,
1289 pCmChDeCookie->CmChDesc[CMCHANNEL_ESA_DESC].Algorithm, pCmChDeCookie->CmChDesc[CMCHANNEL_LSA_DESC].Algorithm, 0);
1290 pCmChDeCookie->bWriteESA = TRUE;
1291 }
1292
1293 //MDrv_DSCMB2_ReadPidSlotMap(FilterID);
1294 }
1295 }
1296
1297 pCmChDeCookie->bConnect = TRUE;
1298
1299 //NSK_TRACE(("es_pid = %x, u32DscmbId = %d, FilterID = %d(0x%08x)\n",es_pid,u32DscmbId,FilterID,FilterID));
1300 NSK_TRACE(("Exit\n"));
1301
1302 return NSK2HDI_STATUS_OK;
1303 }
NSKHDI_CaPIDProxy_RemovePrimaryStreamCmChannel(NSK2HDI_HANDLE CaPIDProxy_handle)1304
1305 NSK2HDI_STATUS NSKHDI_CaPIDProxy_RemovePrimaryStreamCmChannel (NSK2HDI_HANDLE CaPIDProxy_handle)
1306 {
1307 NSK_TRACE(("Enter\n"));
1308 if(NULL == CaPIDProxy_handle)
1309 {
1310 return NSK2HDI_STATUS_INVALID_REQUEST;
1311 }
1312 CaPID_Info *pCaPidProxy = (CaPID_Info *)CaPIDProxy_handle;
1313 CmChannelDevice_Cookie_t *pCmChDeCookie;
1314
1315 MS_U32 u32DscmbId, u32FltID, i;
1316 MS_U32 xconn = 0;
1317 MS_U16 es_pid = 0;
1318 MS_U32 index;
1319
1320 xconn = pCaPidProxy->xconn;
1321 es_pid = pCaPidProxy->es_pid;
1322 index = pCaPidProxy->ProxyGlobalIndex;
1323
1324 pCmChDeCookie = (CmChannelDevice_Cookie_t*) pCaPidProxy->pCmCookie;
1325
1326 for( i=0; i<NSK2_CMCHANNEL_NUM ; i++)
1327 {
1328 if( _u32KeepPidByFltId[xconn][i] == es_pid)
1329 break;
1330 }
1331
1332 u32FltID = i;
1333 u32DscmbId = _KeepCaPidProxy[xconn][index].DscmbId;
1334
1335
1336 NSK_TRACE(("MDrv_DSCMB2_FltDisconnectFltId, u32DscmbId = %d, u32FltId = %d\n",u32DscmbId,u32FltID));
1337
1338 MDrv_DSCMB2_FltDisconnectFltId(0,u32DscmbId,u32FltID);
1339
1340 pCmChDeCookie->bConnect = FALSE;
1341
1342 _KeepCaPidProxy[xconn][index].IsUsed = FALSE;
1343 _KeepCaPidProxy[xconn][index].EsPid = DefaultPID;
1344 _KeepCaPidProxy[xconn][index].DscmbId = DefaultDSCMBID;
1345
1346 NSK_TRACE(("Exit\n"));
1347 return NSK2HDI_STATUS_OK;
1348 }
1349
NSKHDI_CaPIDProxy_SetSecondaryStream(NSK2HDI_HANDLE CaPIDProxy_handle,void * CmChannel_cookie,NDS_USHORT es_pid,NDS_ULONG merge_mode)1350
1351 NSK2HDI_STATUS NSKHDI_CaPIDProxy_SetSecondaryStream (NSK2HDI_HANDLE CaPIDProxy_handle,
1352 void *CmChannel_cookie,
1353 NDS_USHORT es_pid,
1354 NDS_ULONG merge_mode)
1355 {
1356 NSK_TRACE(("Enter\n"));
1357 if(NULL == CaPIDProxy_handle)
1358 {
1359 return NSK2HDI_STATUS_INVALID_REQUEST;
1360 }
1361 CaPID_Info *pCaPidProxy = (CaPID_Info *)CaPIDProxy_handle;
1362
1363
1364 CmChannelDevice_Cookie_t *pCmChDeCookie;
1365 MS_U32 u32DscmbId;
1366 MS_U32 SecondaryFilterID = 0;
1367 MS_U32 PrimaryPID = 0, PrimeFilterID = 0;
1368 MS_U32 xconn, i;
1369 MS_U8 DmxIdSect;
1370 DMX_Flt_info dmx_fltinfo;
1371 DMX_FILTER_TYPE FilterType;
1372
1373 //*CmChannel_cookie, this is used to set parameters, the parameters come from cmchannel command.
1374 pCmChDeCookie = (CmChannelDevice_Cookie_t *)CmChannel_cookie;
1375 PrimaryPID = pCaPidProxy->es_pid;
1376 xconn = pCaPidProxy->xconn;
1377
1378 NSK_TRACE(("primary pid = 0x%x, Secondary pid = 0x%x\n", PrimaryPID, es_pid));
1379
1380 u32DscmbId = pCmChDeCookie->u32DscmbId;
1381
1382 for(i=0;i<NSK2_CMCHANNEL_NUM;i++)
1383 {
1384 if(PrimaryPID == _u32KeepPidByFltId[xconn][i])
1385 {
1386 PrimeFilterID = i;
1387 break;
1388 }
1389 }
1390
1391 pCaPidProxy->PrimeFilterID = PrimaryPID;
1392
1393 MApi_DMX_Info(PrimeFilterID, &dmx_fltinfo, &FilterType, FALSE);
1394 FilterType |= (MApi_NSK2_EcmGetFilterType(xconn) & 0xF0000000);
1395
1396 NSK_TRACE(("PrimeFilterID = %d, Primary Filtertype is %d\n",PrimeFilterID, FilterType));
1397
1398 if (DMX_FILTER_STATUS_OK != MApi_DMX_Open(FilterType, &DmxIdSect))
1399 {
1400 NSK_ERROR(("[%s] Allocate filter fail \n",__FUNCTION__));
1401 return NSK2HDI_STATUS_FAILED;
1402 }
1403
1404 if (DMX_FILTER_STATUS_OK != MApi_DMX_Pid(DmxIdSect, &es_pid, TRUE))
1405 {
1406 NSK_ERROR(("[%s] MApi_DMX_Pid fail \n",__FUNCTION__));
1407 return NSK2HDI_STATUS_FAILED;
1408 }
1409
1410 if (DMX_FILTER_STATUS_OK != MApi_DMX_Start(DmxIdSect))
1411 {
1412 NSK_ERROR(("[%s] MApi_DMX_Start \n",__FUNCTION__));
1413 return NSK2HDI_STATUS_FAILED;
1414 }
1415 SecondaryFilterID = DmxIdSect; //one to one mapping.....
1416
1417 NSK_TRACE(("es_pid = %x, u32DscmbId = %d, FilterID = %d\n",es_pid,u32DscmbId,SecondaryFilterID));
1418
1419 pCaPidProxy->SecondaryFilterID = SecondaryFilterID;
1420 pCaPidProxy->SecondaryPID= es_pid;
1421 pCaPidProxy->secondary_enable = TRUE;
1422
1423 if(MDrv_DSCMB2_FltConnectFltId(0,u32DscmbId, SecondaryFilterID) == FALSE)
1424 {
1425 NSK_ERROR(("MDrv_DSCMB_FltConnectPid() failed\n"));
1426 return NSK2HDI_STATUS_FAILED;
1427 }
1428
1429 NSK_TRACE(("PrimeFilterID = 0x%x, SecondaryFilterID = 0x%x\n",PrimeFilterID, SecondaryFilterID));
1430
1431 MDrv_DSCMB2_SetPidPair(PrimeFilterID, (MS_U32)pCaPidProxy->SecondaryFilterID);
1432
1433 #if 0
1434 _u32KeepPidByFltId[xconn][FilterID] = es_pid;
1435 _u32DscmbID[FilterID] = u32DscmbId;
1436
1437 pCmChDeCookie->u16Pid = es_pid;
1438 pCmChDeCookie->PidSlotID = FilterID;
1439 #endif
1440 MDrv_NSK21_CfgCmChannel(u32DscmbId, pCmChDeCookie->CmChDesc[CMCHANNEL_LDA_DESC].Algorithm,
1441 pCmChDeCookie->CmChDesc[CMCHANNEL_ESA_DESC].Algorithm, pCmChDeCookie->CmChDesc[CMCHANNEL_LSA_DESC].Algorithm, 0);
1442
1443
1444 NSK_TRACE(("Exit\n"));
1445
1446 return NSK2HDI_STATUS_OK;
1447 }
1448
1449
NSKHDI_CaPIDProxy_RemoveSecondaryStream(NSK2HDI_HANDLE CaPIDProxy_handle)1450 //need to refine....
1451 NSK2HDI_STATUS NSKHDI_CaPIDProxy_RemoveSecondaryStream (NSK2HDI_HANDLE CaPIDProxy_handle)
1452 {
1453
1454 NSK_TRACE(("Enter\n"));
1455 if(NULL == CaPIDProxy_handle)
1456 {
1457 return NSK2HDI_STATUS_INVALID_REQUEST;
1458 }
1459 CaPID_Info *pCaPidProxy = (CaPID_Info *)CaPIDProxy_handle;
1460
1461 MDrv_DSCMB2_ClearPidPair(pCaPidProxy->PrimeFilterID, pCaPidProxy->SecondaryFilterID);
1462
1463 MApi_NSK2_DTV_ClosePidNo(pCaPidProxy->SecondaryFilterID);
1464 NSK_TRACE(("MApi_NSK2_DTV_ClosePidNo, FltId = %d\n",pCaPidProxy->SecondaryFilterID));
1465
1466
1467 NSK_TRACE(("Exit\n"));
1468 return NSK2HDI_STATUS_OK;
1469 }
1470
1471
1472 /*****************************************************************************\
1473 \ CA Master and SoC devices
NSK2HDI_ParamInit(void)1474 \*****************************************************************************/
1475 void NSK2HDI_ParamInit(void)
1476 {
1477 NSK_TRACE(("Enter\n"));
1478 MS_U32 i=0, j=0;
1479 debug_level = PRINT_TRACE;
1480 MS_U32 MaxConn;
1481 MS_U32 size;
1482
1483 for( i=0; i<NSK2_CMCHANNEL_NUM; i++)
1484 {
1485 pCmChannelcookie[i] = MApi_NSK2_AllocateMemory(CmChannelCookieSize, FALSE);
1486 pM2MChannelcookie[i] = MApi_NSK2_AllocateMemory(CmChannelCookieSize, FALSE);
1487 }
1488
1489 for( j=0; j<MaxXConnection ; j++)
1490 {
1491 for( i=0; i<NSK2_CMCHANNEL_NUM; i++)
1492 {
1493 _u32KeepPidByFltId[j][i] = DefaultPID;
1494 _KeepCaPidProxy[j][i].EsPid = DefaultPID;
1495 _KeepCaPidProxy[j][i].DscmbId = DefaultDSCMBID;
1496 _KeepCaPidProxy[j][i].IsUsed = 0;
1497 }
1498
1499 }
1500
1501 memset(HDI_XconnInfo,0x0,sizeof(AddXconnInfo_t)*2);
1502
1503 MaxConn = MDrv_NSK2_GetMaxXConn();
1504 size = sizeof(AddXconnInfo_t)*MaxConn;
1505 NSK_TRACE(("MaxConn = 0x%08x, size = 0x%08x\n",MaxConn, size));
1506
1507 NSK_TRACE(("Exit\n"));
1508 }
1509