1
2
3 #include <stdlib.h>
4 #include <string.h>
5 #include "MsCommon.h"
6
7 #include "nsk_dbg.h"
8
9 #include "nsk_282.h"
10 #include "nsk_dbg.h"
11 #include "nsk_3014.h"
12 #include "hdi_121.h"
13 #include "drvCIPHER.h"
14 #include "drvDSCMB.h"
15 #include "drvNSK2.h"
16 #include "nsk2hdi_header.h"
17
18
19
20 /*****************************************************************************\
21 \Definitions
22 \*****************************************************************************/
23 #define NSK2_M2MCHANNEL_NUM 16
24 #define M2MChannelCookieSize 0x1000
25 #define NSK2_M2MChannelGroup_Number 2
26 #define NSK2_M2MChannel_Number 2
27
28 #define ChangeGetM2MProp
29
30 /*****************************************************************************\
31 \ typedef struct
32 \*****************************************************************************/
33
34 typedef struct
35 {
36 MS_U32 u32CMHandle;
37 MS_U8 Algorithm;
38 MS_U8 Operation;
39 MS_U8 clearkey[0x100];
40 MS_U8 clearkey_length;
41 MS_U8 en_swKeys;
42 } M2MChannelDevice_Cookie_t;
43
44 typedef struct _NSK2_M2MTable
45 {
46 MS_BOOL alloc;
47 MS_BOOL enable;
48 MS_U32 nsk_sw;
49 MS_U32 handle_id;
50 } NSK2_M2MTable_Info;
51
52 typedef struct _DMA_iv1_descriptor{
53 MS_U8 descriptor_tag;
54 MS_U8 descriptor_length;
55 MS_U8 iv_payload[18];
56 }DMA_IV1_Desc_t;
57
58
59 typedef struct _DMA_iv2_descriptor{
60 MS_U8 descriptor_tag;
61 MS_U8 descriptor_length;
62 MS_U8 iv_payload[18];
63 }DMA_IV2_Desc_t;
64
65 typedef struct _DMA_operation_descriptor{
66 MS_U8 descriptor_tag;
67 MS_U8 descriptor_length;
68 MS_U8 operation;
69 }DMA_Operation_Desc_t;
70
71
72 typedef struct _DMA_memory_descriptor{
73 MS_U8 descriptor_tag;
74 MS_U8 descriptor_length;
75 MS_U8 type;
76 }DMA_Memory_Desc_t;
77
78 typedef struct _NSK2_DMAInfo
79 {
80 MS_BOOL alloc;
81 MS_BOOL enable;
82 MS_U32 nsk_sw;
83 MS_U32 handle_id;
84 } NSK2_DMA_Info;
85
86
87 typedef struct {
88 MS_U8 Algorithm;
89 MS_U8 Operation;
90 MS_U32 size;
91 MS_U8 *pInput;
92 MS_U8 *pOutput;
93 MS_U8 IV1[0x10];
94 MS_U32 u32IV[0x4];
95 MS_U8 IV2[0x10];
96 MS_U8 clearkey[0x100];
97 MS_U8 clearkey_length;
98 MS_U8 en_swKeys;
99 } M2MConfig_t;
100
101
102 typedef struct _M2MChannel_ClearSWKey_Descriptor{
103 MS_U8 descriptor_tag;
104 MS_U8 descriptor_length;
105 MS_U8 *pClearSWKey;
106 } M2MChannel_ClearSWKey_Desc_t;
107
108 typedef struct _NSK2_M2MChannelGroup
109 {
110 MS_BOOL alloc;
111 MS_BOOL enable;
112 MS_U32 nsk_sw;
113 MS_U32 handle_id;
114 } NSK2_M2MChannelGroup_Info;
115
116 typedef struct _M2MChannel_Operation_Descriptor{
117 MS_U8 descriptor_tag;
118 MS_U8 descriptor_length;
119 MS_U8 operation;
120 } M2MCh_Operation_Desc_t;
121
122 typedef struct _NSK2_M2MChannel
123 {
124 MS_BOOL alloc;
125 MS_BOOL enable;
126 MS_U32 nsk_sw;
127 MS_U32 handle_id;
128 } NSK2_M2MChannel_Info;
129
130
131 /*****************************************************************************\
132 \ local variables
133 \*****************************************************************************/
134
135
136 static DMA_IV1_Desc_t dma_iv1_desc = {
137 .descriptor_tag = NSK2HDI_DMA_IV1_DESC_TAG,
138 .descriptor_length = sizeof(DMA_IV1_Desc_t) - 2,
139 };
140
141 static DMA_IV2_Desc_t dma_iv2_desc = {
142 .descriptor_tag = NSK2HDI_DMA_IV2_DESC_TAG,
143 .descriptor_length = sizeof(DMA_IV2_Desc_t) - 2,
144 };
145
146
147
148 /*****************************************************************************\
149 \ global variables
150 \*****************************************************************************/
151 extern void *pM2MChannelcookie[NSK2_M2MCHANNEL_NUM];
152
153 M2MChannelDevice_Cookie_t *gpM2MChCookie;
154 NSK2_M2MTable_Info nsk_m2mTable;
155 NSK2_DMA_Info nsk2_dma;
156 NSK2_M2MChannel_Info nsk_m2m[NSK2_M2MChannel_Number];
157 NSK2_M2MChannelGroup_Info nsk_m2mgrp[NSK2_M2MChannelGroup_Number];
158
159 /*****************************************************************************\
160 \ NSK2HDI m2m functions
161 \*****************************************************************************/
162
163 /*****************************************************************************\
164 \ M2M devices - Table device
165 \*****************************************************************************/
166
167
NSKHDI_M2MTable_Open(NSK2HDI_DEVICE_ID M2MTable_ID,NSK2HDI_HANDLE * M2MTable_handle)168 NSK2HDI_STATUS NSKHDI_M2MTable_Open (NSK2HDI_DEVICE_ID M2MTable_ID,
169 NSK2HDI_HANDLE *M2MTable_handle)
170 {
171 NSK_TRACE(("Enter\n"));
172 NSK_TRACE(("M2MTable_ID = %x\n",M2MTable_ID));
173
174 nsk_m2mTable.alloc = TRUE;
175 nsk_m2mTable.handle_id = 0;
176
177 *M2MTable_handle = (NSK2HDI_HANDLE *)&nsk_m2mTable.handle_id;
178
179 NSK_TRACE(("M2MTable_handle = 0x%x\n",nsk_m2mTable.handle_id));
180
181 NSK_TRACE(("Exit\n"));
182 return NSK2HDI_STATUS_OK;
183 }
184
NSKHDI_M2MTable_Close(NSK2HDI_HANDLE M2MTable_handle)185 NSK2HDI_STATUS NSKHDI_M2MTable_Close (NSK2HDI_HANDLE M2MTable_handle)
186 {
187 NSK_TRACE(("Enter\n"));
188 MS_U32 u32Handle = NSKHDI_GetHandle(M2MTable_handle);
189 NSK_TRACE(("u32Handle = 0x%x\n",u32Handle));
190
191 nsk_m2mTable.alloc = FALSE;
192 nsk_m2mTable.handle_id = 0;
193
194 NSK_TRACE(("Exit\n"));
195 return NSK2HDI_STATUS_OK;
196 }
197
NSKHDI_M2MTable_EnumerateChildren(NSK2HDI_HANDLE M2MTable_handle,NDS_ULONG * child_device_num,NSK2HDI_CHILD_DEVICE * child_device)198 NSK2HDI_STATUS NSKHDI_M2MTable_EnumerateChildren( NSK2HDI_HANDLE M2MTable_handle,
199 NDS_ULONG *child_device_num,
200 NSK2HDI_CHILD_DEVICE *child_device)
201 {
202 NSK_TRACE(("Enter\n"));
203
204 NSK_TRACE(("child_device_num = %x\n",*child_device_num));
205
206 if(child_device == NULL)
207 {
208 //should fill the number of child device...
209 *child_device_num = 2;
210 return NSK2HDI_STATUS_OK;
211 }
212
213 child_device[0].device_id = 0x1234;
214 child_device[0].device_type = NSK2HDI_DMA_DEVICE_TYPE;
215 child_device[1].device_id = 0x5678;
216 child_device[1].device_type = NSK2HDI_M2MCHANNEL_GROUP_DEVICE_TYPE;
217
218 NSK_TRACE(("Exit\n"));
219 return NSK2HDI_STATUS_OK;
220 }
221
222 /*****************************************************************************\
223 \ M2M devices - DMA device
224 \*****************************************************************************/
225
NSKHDI_DMADevice_Open(NSK2HDI_DEVICE_ID DMADevice_ID,NSK2HDI_HANDLE * DMADevice_handle)226 NSK2HDI_STATUS NSKHDI_DMADevice_Open (NSK2HDI_DEVICE_ID DMADevice_ID,
227 NSK2HDI_HANDLE *DMADevice_handle)
228 {
229
230 NSK_TRACE(("Enter\n"));
231
232 NSK_TRACE(("DMADevice_ID = %x\n",DMADevice_ID));
233
234 if(*DMADevice_handle != NULL)
235 {
236 //NSK_ERROR(("CmChannele_handle no NULL\n"));
237 }
238
239 if(nsk2_dma.alloc == TRUE)
240 {
241 //NSK_ERROR(("DMA is used\n"));
242 }
243
244 nsk2_dma.alloc = TRUE;
245 *DMADevice_handle = (NSK2HDI_HANDLE *)&nsk2_dma.handle_id;
246
247 NSK_TRACE(("DMADevice_handle = 0x%x\n",nsk2_dma.handle_id));
248
249 NSK_TRACE(("Exit\n"));
250 return NSK2HDI_STATUS_OK;
251 }
252
NSKHDI_DMADevice_Close(NSK2HDI_HANDLE DMADevice_handle)253 NSK2HDI_STATUS NSKHDI_DMADevice_Close (NSK2HDI_HANDLE DMADevice_handle)
254 {
255 NSK_TRACE(("Enter\n"));
256
257 MS_U32 u32Handle = NSKHDI_GetHandle(DMADevice_handle);
258 //NSK_TRACE(("DMADevice_handle = %x\n",u32Handle));
259 NSK_TRACE(("DMADevice_handle = 0x%x\n",u32Handle));
260
261 nsk2_dma.alloc = FALSE;
262
263 NSK_TRACE(("Exit\n"));
264 return NSK2HDI_STATUS_OK;
265 }
266
267
268
NSKHDI_DMADevice_GetProperties(NSK2HDI_HANDLE DMADevice_handle,NDS_ULONG request_id,NDS_ULONG * desc_size,NDS_UBYTE * desc)269 NSK2HDI_STATUS NSKHDI_DMADevice_GetProperties( NSK2HDI_HANDLE DMADevice_handle,
270 NDS_ULONG request_id,
271 NDS_ULONG *desc_size,
272 NDS_UBYTE *desc)
273 {
274 NSK_TRACE(("Enter\n"));
275 MS_U32 u32Handle = NSKHDI_GetHandle(DMADevice_handle);
276 NSK_TRACE(("DMADevice_handle = 0x%x\n",u32Handle));
277
278 if(request_id != NSK2HDI_DMA_READ_ALL_DESCRIPTORS_REQUEST)
279 {
280 return NSK2HDI_STATUS_INVALID_REQUEST;
281 }
282
283 if(desc == NULL)
284 {
285 MDrv_NSK2_GetDMAProperties((MS_U32*)desc_size, (MS_U8*)desc);
286 NSK_TRACE(("return desc_size = 0x%x\n",(MS_U32)*desc_size));
287 return NSK2HDI_STATUS_OK;
288 }
289
290 if(*desc_size == 0)
291 {
292 return NSK2HDI_STATUS_INVALID_REQUEST;
293 }
294
295 MDrv_NSK2_GetDMAProperties((MS_U32*)desc_size, (MS_U8*)desc);
296 NSK_TRACE(("Exit\n"));
297 return NSK2HDI_STATUS_OK;
298 }
299
NSKHDI_M2MAlgoTrans(MS_U8 NSK2HDI_Algo,DRV_CIPHER_ALGO * pCipherAlgo)300 void NSKHDI_M2MAlgoTrans(MS_U8 NSK2HDI_Algo, DRV_CIPHER_ALGO *pCipherAlgo)
301 {
302
303 NSK_TRACE(("NSK2HDI_Algo = %x\n",NSK2HDI_Algo));
304
305 if(NSK2HDI_SPROFILE_M2M_DES_ECB_CLR_CLR == NSK2HDI_Algo)
306 {
307 pCipherAlgo->eMainAlgo = E_CIPHER_MAIN_DES;
308 pCipherAlgo->eSubAlgo = E_CIPHER_SUB_ECB;
309 pCipherAlgo->eResAlgo = E_CIPHER_RES_CLR;
310 pCipherAlgo->eSBAlgo = E_CIPHER_SB_CLR;
311 }
312 else if(NSK2HDI_SPROFILE_M2M_DES_CBC_SCTE52_IV1 == NSK2HDI_Algo)
313 {
314 pCipherAlgo->eMainAlgo = E_CIPHER_MAIN_DES;
315 pCipherAlgo->eSubAlgo = E_CIPHER_SUB_CBC;
316 pCipherAlgo->eResAlgo = E_CIPHER_RES_SCTE52;
317 pCipherAlgo->eSBAlgo = E_CIPHER_SB_IV1;
318 }
319 else if(NSK2HDI_SPROFILE_M2M_DES_CBC_SCTE52_IV2 == NSK2HDI_Algo)
320 {
321 pCipherAlgo->eMainAlgo = E_CIPHER_MAIN_DES;
322 pCipherAlgo->eSubAlgo = E_CIPHER_SUB_CBC;
323 pCipherAlgo->eResAlgo = E_CIPHER_RES_SCTE52;
324 pCipherAlgo->eSBAlgo = E_CIPHER_SB_IV2;
325 }
326 else if(NSK2HDI_SPROFILE_M2M_DES_CBC_CLR_CLR == NSK2HDI_Algo)
327 {
328 pCipherAlgo->eMainAlgo = E_CIPHER_MAIN_DES;
329 pCipherAlgo->eSubAlgo = E_CIPHER_SUB_CBC;
330 pCipherAlgo->eResAlgo = E_CIPHER_RES_CLR;
331 pCipherAlgo->eSBAlgo = E_CIPHER_SB_CLR;
332 }
333 else if(NSK2HDI_SPROFILE_M2M_TDES_ECB_CLR_CLR == NSK2HDI_Algo)
334 {
335 pCipherAlgo->eMainAlgo = E_CIPHER_MAIN_TDES;
336 pCipherAlgo->eSubAlgo = E_CIPHER_SUB_ECB;
337 pCipherAlgo->eResAlgo = E_CIPHER_RES_CLR;
338 pCipherAlgo->eSBAlgo = E_CIPHER_SB_CLR;
339 }
340 else if(NSK2HDI_SPROFILE_M2M_TDES_CBC_SCTE52_IV1 == NSK2HDI_Algo)
341 {
342 pCipherAlgo->eMainAlgo = E_CIPHER_MAIN_TDES;
343 pCipherAlgo->eSubAlgo = E_CIPHER_SUB_CBC;
344 pCipherAlgo->eResAlgo = E_CIPHER_RES_SCTE52;
345 pCipherAlgo->eSBAlgo = E_CIPHER_SB_IV1;
346 }
347 else if(NSK2HDI_SPROFILE_M2M_TDES_CBC_SCTE52_IV2 == NSK2HDI_Algo)
348 {
349 pCipherAlgo->eMainAlgo = E_CIPHER_MAIN_TDES;
350 pCipherAlgo->eSubAlgo = E_CIPHER_SUB_CBC;
351 pCipherAlgo->eResAlgo = E_CIPHER_RES_SCTE52;
352 pCipherAlgo->eSBAlgo = E_CIPHER_SB_IV2;
353 }
354 else if(NSK2HDI_SPROFILE_M2M_TDES_CBC_CLR_CLR == NSK2HDI_Algo)
355 {
356 pCipherAlgo->eMainAlgo = E_CIPHER_MAIN_TDES;
357 pCipherAlgo->eSubAlgo = E_CIPHER_SUB_CBC;
358 pCipherAlgo->eResAlgo = E_CIPHER_RES_CLR;
359 pCipherAlgo->eSBAlgo = E_CIPHER_SB_CLR;
360 }
361 else if(NSK2HDI_SPROFILE_M2M_AES_ECB_CLR_CLR == NSK2HDI_Algo)
362 {
363 pCipherAlgo->eMainAlgo = E_CIPHER_MAIN_AES;
364 pCipherAlgo->eSubAlgo = E_CIPHER_SUB_ECB;
365 pCipherAlgo->eResAlgo = E_CIPHER_RES_CLR;
366 pCipherAlgo->eSBAlgo = E_CIPHER_SB_CLR;
367 }
368 else if(NSK2HDI_SPROFILE_M2M_AES_CBC_CTS_IV1 == NSK2HDI_Algo)
369 {
370 pCipherAlgo->eMainAlgo = E_CIPHER_MAIN_AES;
371 pCipherAlgo->eSubAlgo = E_CIPHER_SUB_CBC;
372 pCipherAlgo->eResAlgo = E_CIPHER_RES_CTS;
373 pCipherAlgo->eSBAlgo = E_CIPHER_SB_IV1;
374 }
375 else if(NSK2HDI_SPROFILE_M2M_AES_CBC_CTS_CLR == NSK2HDI_Algo)
376 {
377 pCipherAlgo->eMainAlgo = E_CIPHER_MAIN_AES;
378 pCipherAlgo->eSubAlgo = E_CIPHER_SUB_CBC;
379 pCipherAlgo->eResAlgo = E_CIPHER_RES_CTS;
380 pCipherAlgo->eSBAlgo = E_CIPHER_SB_CLR;
381 }
382 else if(NSK2HDI_SPROFILE_M2M_AES_CBC_SCTE52_IV1 == NSK2HDI_Algo)
383 {
384 pCipherAlgo->eMainAlgo = E_CIPHER_MAIN_AES;
385 pCipherAlgo->eSubAlgo = E_CIPHER_SUB_CBC;
386 pCipherAlgo->eResAlgo = E_CIPHER_RES_SCTE52;
387 pCipherAlgo->eSBAlgo = E_CIPHER_SB_IV1;
388 }
389 else if(NSK2HDI_SPROFILE_M2M_AES_CBC_SCTE52_CLR == NSK2HDI_Algo)
390 {
391 pCipherAlgo->eMainAlgo = E_CIPHER_MAIN_AES;
392 pCipherAlgo->eSubAlgo = E_CIPHER_SUB_CBC;
393 pCipherAlgo->eResAlgo = E_CIPHER_RES_SCTE52;
394 pCipherAlgo->eSBAlgo = E_CIPHER_SB_CLR;
395 }
396 else if(NSK2HDI_SPROFILE_M2M_AES_CBC_CLR_CLR == NSK2HDI_Algo)
397 {
398 pCipherAlgo->eMainAlgo = E_CIPHER_MAIN_AES;
399 pCipherAlgo->eSubAlgo = E_CIPHER_SUB_CBC;
400 pCipherAlgo->eResAlgo = E_CIPHER_RES_CLR;
401 pCipherAlgo->eSBAlgo = E_CIPHER_SB_CLR;
402 }
403 else if(NSK2HDI_SPROFILE_M2M_RC4_64 == NSK2HDI_Algo)
404 {
405 pCipherAlgo->eMainAlgo = E_CIPHER_MAIN_RC4;
406 pCipherAlgo->eSubAlgo = E_CIPHER_SUB_NONE;
407 pCipherAlgo->eResAlgo = E_CIPHER_RES_CLR;
408 pCipherAlgo->eSBAlgo = E_CIPHER_SB_CLR;
409 }
410 else if(NSK2HDI_SPROFILE_M2M_AES_CTR == NSK2HDI_Algo)
411 {
412 pCipherAlgo->eMainAlgo = E_CIPHER_MAIN_AES;
413 pCipherAlgo->eSubAlgo = E_CIPHER_SUB_CTR;
414 pCipherAlgo->eResAlgo = E_CIPHER_RES_CLR;
415 pCipherAlgo->eSBAlgo = E_CIPHER_SB_CLR;
416 }
417 else if(NSK2HDI_SPROFILE_M2M_AES_CTR64 == NSK2HDI_Algo)
418 {
419 pCipherAlgo->eMainAlgo = E_CIPHER_MAIN_AES;
420 pCipherAlgo->eSubAlgo = E_CIPHER_SUB_CTR;
421 pCipherAlgo->eResAlgo = E_CIPHER_RES_CLR;
422 pCipherAlgo->eSBAlgo = E_CIPHER_SB_CLR;
423 }
424 else
425 {
426 NSK_ERROR(("Not Implement\n"));
427 }
428 }
429
430
NSKHDI_M2MGetNSKSubAlgo(MS_U8 NSK2HDI_Algo,CIPHER_SUB_ALGO * pSubAlgo)431 void NSKHDI_M2MGetNSKSubAlgo(MS_U8 NSK2HDI_Algo, CIPHER_SUB_ALGO *pSubAlgo)
432 {
433 #define SUBALGO_ECB 0
434 #define SUBALGO_CBC 1
435 #define SUBALGO_CTR 2
436 #define SUBALGO_CBCMAC 3
437 #define SUBALGO_CTR_64 4
438 #define SUBALGO_CMAC_KEY 5
439 #define SUBALGO_CMAC_Algo 6
440 #define SUBALGO_PCBC_ADD 7
441 #define SUBALGO_PCBC_XOR 8
442
443 NSK_TRACE(("NSK2HDI_Algo = 0x%02x\n",NSK2HDI_Algo));
444
445 if(NSK2HDI_SPROFILE_M2M_DES_ECB_CLR_CLR == NSK2HDI_Algo)
446 {
447 *pSubAlgo = SUBALGO_ECB;
448 }
449 else if(NSK2HDI_SPROFILE_M2M_DES_CBC_SCTE52_IV1 == NSK2HDI_Algo)
450 {
451 *pSubAlgo = SUBALGO_CBC;
452 }
453 else if(NSK2HDI_SPROFILE_M2M_DES_CBC_SCTE52_IV2 == NSK2HDI_Algo)
454 {
455 *pSubAlgo = SUBALGO_CBC;
456 }
457 else if(NSK2HDI_SPROFILE_M2M_DES_CBC_CLR_CLR == NSK2HDI_Algo)
458 {
459 *pSubAlgo = SUBALGO_CBC;
460 }
461 else if(NSK2HDI_SPROFILE_M2M_TDES_ECB_CLR_CLR == NSK2HDI_Algo)
462 {
463 *pSubAlgo = SUBALGO_ECB;
464 }
465 else if(NSK2HDI_SPROFILE_M2M_TDES_CBC_SCTE52_IV1 == NSK2HDI_Algo)
466 {
467 *pSubAlgo = SUBALGO_CBC;
468 }
469 else if(NSK2HDI_SPROFILE_M2M_TDES_CBC_SCTE52_IV2 == NSK2HDI_Algo)
470 {
471 *pSubAlgo = SUBALGO_CBC;
472 }
473 else if(NSK2HDI_SPROFILE_M2M_TDES_CBC_CLR_CLR == NSK2HDI_Algo)
474 {
475 *pSubAlgo = SUBALGO_CBC;
476 }
477 else if(NSK2HDI_SPROFILE_M2M_AES_ECB_CLR_CLR == NSK2HDI_Algo)
478 {
479 *pSubAlgo = SUBALGO_ECB;
480 }
481 else if(NSK2HDI_SPROFILE_M2M_AES_CBC_CTS_IV1 == NSK2HDI_Algo)
482 {
483 *pSubAlgo = SUBALGO_CBC;
484 }
485 else if(NSK2HDI_SPROFILE_M2M_AES_CBC_CTS_CLR == NSK2HDI_Algo)
486 {
487 *pSubAlgo = SUBALGO_CBC;
488 }
489 else if(NSK2HDI_SPROFILE_M2M_AES_CBC_SCTE52_IV1 == NSK2HDI_Algo)
490 {
491 *pSubAlgo = SUBALGO_CBC;
492 }
493 else if(NSK2HDI_SPROFILE_M2M_AES_CBC_SCTE52_CLR == NSK2HDI_Algo)
494 {
495 *pSubAlgo = SUBALGO_CBC;
496 }
497 else if(NSK2HDI_SPROFILE_M2M_AES_CBC_CLR_CLR == NSK2HDI_Algo)
498 {
499 *pSubAlgo = SUBALGO_CBC;
500 }
501 else if(NSK2HDI_SPROFILE_M2M_RC4_64 == NSK2HDI_Algo)
502 {
503 *pSubAlgo = 0;
504 }
505 else if(NSK2HDI_SPROFILE_M2M_AES_CTR == NSK2HDI_Algo)
506 {
507 *pSubAlgo = SUBALGO_CTR;
508 }
509 else if(NSK2HDI_SPROFILE_M2M_AES_CTR64 == NSK2HDI_Algo)
510 {
511 *pSubAlgo = SUBALGO_CTR_64;
512 }
513 else
514 {
515 NSK_ERROR(("Not Implement\n"));
516 }
517
518 }
519
520
521 //#define IV_FROM_MAGIC
522
NSKHDI_WriteM2MTest(M2MConfig_t * pM2MConfig)523 void NSKHDI_WriteM2MTest(M2MConfig_t *pM2MConfig)
524 {
525
526 MS_BOOL bDecrpt = FALSE;
527 DRV_CIPHER_RET ret;
528 MS_U32 u32CmdId;
529 DRV_CIPHER_DMACFG stCfg;
530 MS_U32 u32DelayTime;
531
532 memset(&stCfg,0x0,sizeof(DRV_CIPHER_DMACFG));
533
534 if (pM2MConfig->Operation == NSK2HDI_M2MCHANNEL_DECRYPT_OPERATION)
535 {
536 NSK_TRACE(("DECRYPT_OPERATION\n"));
537 bDecrpt = TRUE;
538 }
539 else if (pM2MConfig->Operation == NSK2HDI_M2MCHANNEL_ENCRYPT_OPERATION)
540 {
541 NSK_TRACE(("ENCRYPT_OPERATION\n"));
542 bDecrpt = FALSE;
543 }
544 else
545 {
546 NSK_ERROR(("Not support operation\n"));
547 }
548
549
550 NSKHDI_M2MAlgoTrans(pM2MConfig->Algorithm,&stCfg.stAlgo);
551
552 MS_U8 u8IVData[0x10];
553 MS_U8 i;
554
555 memset(u8IVData,0x0,0x10);
556 #ifdef IV_FROM_MAGIC
557 MS_U8 u8IVData1[0x10] = {0xbd, 0x98, 0xa2, 0x06, 0x1b, 0x76, 0x1b, 0xa4, 0x15, 0x10, 0x1f, 0x26, 0xf6, 0x66, 0x6, 0x45};
558 MS_U8 u8IVData2[0x10] = {0x91, 0x0c, 0xc0, 0x9f, 0x9a, 0x04, 0x7b, 0x6a, 0xa8, 0xde, 0xfe, 0xe2, 0xfc, 0xae, 0xad, 0xb3};
559 memcpy(pM2MConfig->IV1,u8IVData1,0x10);
560 memcpy(pM2MConfig->IV2,u8IVData2,0x10);
561 #endif
562
563 NSKHDI_IVDataTrans(pM2MConfig->Algorithm,pM2MConfig->IV1,pM2MConfig->IV2,pM2MConfig->u32IV);
564
565 if(pM2MConfig->en_swKeys == TRUE)
566 {
567 NSK_TRACE(("Write SW key\n"));
568 stCfg.u32CAVid = 2;
569 stCfg.stKey.eKeySrc = E_CIPHER_KSRC_CPU;
570 stCfg.stKey.u8KeyIdx = 0;
571 stCfg.stKey.u8KeyLen = pM2MConfig->clearkey_length;
572 stCfg.stKey.pu8KeyData = (MS_U8 *)pM2MConfig->clearkey;
573 stCfg.stKey.u8IVLen = 16;
574
575 for(i=0;i<4;i++)
576 {
577 u8IVData[i*4+0] = (MS_U8)((pM2MConfig->u32IV[i]>>24)&0xff);
578 u8IVData[i*4+1] = (MS_U8)((pM2MConfig->u32IV[i]>>16)&0xff);
579 u8IVData[i*4+2] = (MS_U8)((pM2MConfig->u32IV[i]>>8)&0xff);
580 u8IVData[i*4+3] = (MS_U8)((pM2MConfig->u32IV[i]>>0)&0xff);
581 }
582
583 stCfg.stKey.pu8IVData = (MS_U8 *)u8IVData;
584 }
585 else
586 {
587 stCfg.u32CAVid = 1;
588 NSK_TRACE(("WriteM2MKey with NSK write key\n"));
589
590 //for nds usage....
591 stCfg.stAlgo.eSubAlgo = E_CIPHER_SUB_NONE;
592 stCfg.stAlgo.eMainAlgo = E_CIPHER_MAIN_NONE;
593 stCfg.stAlgo.eSBAlgo = E_CIPHER_SB_NONE;
594 stCfg.stAlgo.eResAlgo = E_CIPHER_RES_NONE;
595
596 //Key, NDS
597 stCfg.stKey.eKeySrc = E_CIPHER_KSRC_CAIP;
598 stCfg.stKey.u8KeyIdx = 0;
599 stCfg.stKey.u8KeyLen = 0;
600 stCfg.stKey.pu8KeyData = 0;
601
602 stCfg.stKey.u8IVLen = 16;
603
604
605 //(MS_U8*)pM2MConfig->u32IV;
606 //pu32IV[3] = 0xf6660645;
607 //pu32IV[2] = 0x15101f26;
608 //pu32IV[1] = 0x1b761ba4;
609 //pu32IV[0] = 0xbd98a206;
610 for(i=0;i<4;i++)
611 {
612 u8IVData[i*4+0] = (MS_U8)((pM2MConfig->u32IV[i]>>24)&0xff);
613 u8IVData[i*4+1] = (MS_U8)((pM2MConfig->u32IV[i]>>16)&0xff);
614 u8IVData[i*4+2] = (MS_U8)((pM2MConfig->u32IV[i]>>8)&0xff);
615 u8IVData[i*4+3] = (MS_U8)((pM2MConfig->u32IV[i]>>0)&0xff);
616 }
617 stCfg.stKey.pu8IVData = u8IVData;
618
619 }
620
621 u32DelayTime = pM2MConfig->size >> 10 ; //100k byte, 1ms
622
623 if(u32DelayTime < 100)
624 u32DelayTime = 1;
625 else
626 u32DelayTime /= 100;
627
628 //Decrpt or Encrypt
629 stCfg.bDecrypt = bDecrpt;
630
631 if( MApi_NSK2_IsHarmonizer() == TRUE )//running harmonizer test....
632 {
633 MS_U8 *pTestInput, *pTestOutput;
634 pTestInput = MApi_NSK2_AllocateMemory(pM2MConfig->size, FALSE);
635 pTestOutput = MApi_NSK2_AllocateMemory(pM2MConfig->size, FALSE);
636
637 memcpy(pTestInput, pM2MConfig->pInput,pM2MConfig->size);
638 //InData
639 stCfg.stInput.u32Addr = MsOS_VA2PA((MS_VIRT)pTestInput);
640 stCfg.stInput.u32Size = pM2MConfig->size;
641
642 NSK_TRACE(("Input Addr = 0x%llx, u32Size = 0x%x\n", stCfg.stInput.u32Addr, stCfg.stInput.u32Size));
643
644 //OutData
645 stCfg.stOutput.u32Addr = MsOS_VA2PA((MS_VIRT)pTestOutput);
646 stCfg.stOutput.u32Size = pM2MConfig->size;
647
648 NSK_TRACE(("Output Addr = 0x%llx, u32Size = 0x%x\n",stCfg.stOutput.u32Addr, stCfg.stOutput.u32Size));
649
650 MsOS_FlushMemory();
651
652 MS_U32 u32Exception=0;
653
654 ret = MDrv_CIPHER_DMACalc(stCfg, &u32CmdId); //use hal code?
655 if(ret != DRV_CIPHER_OK)
656 {
657 NSK_ERROR(("Fail to M2M Test\n"));
658 return;
659 }
660
661 do
662 {
663 MsOS_DelayTask(u32DelayTime);
664 ret = MDrv_CIPHER_IsDMADone(u32CmdId, &u32Exception);
665 }while(ret == FALSE);
666
667
668 NSK_TRACE(("DMA done\n"));
669 MsOS_ReadMemory();
670
671 if(u32Exception)
672 {
673 NSK_TRACE(("DMA Exception: [0x%x]\n", u32Exception));
674 }
675
676 memcpy(pM2MConfig->pOutput, pTestOutput,pM2MConfig->size);
677
678 MApi_NSK2_FreeMemory(pTestInput, FALSE);
679 MApi_NSK2_FreeMemory(pTestOutput, FALSE);
680 }
681 else //normal case..., real project, not harmonizer one....
682 {
683 MS_U8 *pTestInput, *pTestOutput;
684 pTestInput = pM2MConfig->pInput;
685 pTestOutput = pM2MConfig->pOutput;
686
687 //InData
688 stCfg.stInput.u32Addr = MsOS_VA2PA((MS_VIRT)pTestInput);
689 stCfg.stInput.u32Size = pM2MConfig->size;
690
691 NSK_TRACE(("Input Addr = 0x%llx, u32Size = 0x%x\n",stCfg.stInput.u32Addr, stCfg.stInput.u32Size));
692
693 //OutData
694 stCfg.stOutput.u32Addr = MsOS_VA2PA((MS_VIRT)pTestOutput);
695 stCfg.stOutput.u32Size = pM2MConfig->size;
696
697 NSK_TRACE(("Output Addr = 0x%llx, u32Size = 0x%x\n",stCfg.stOutput.u32Addr, stCfg.stOutput.u32Size));
698
699 MsOS_FlushMemory();
700
701 MS_U32 u32Exception=0;
702
703 ret = MDrv_CIPHER_DMACalc(stCfg, &u32CmdId); //use hal code?
704 if(ret != DRV_CIPHER_OK)
705 {
706 NSK_ERROR(("Fail to M2M Test\n"));
707 return;
708 }
709
710 do
711 {
712 MsOS_DelayTask(u32DelayTime);
713 ret = MDrv_CIPHER_IsDMADone(u32CmdId, &u32Exception);
714 }while(ret == FALSE);
715
716 NSK_TRACE(("DMA done\n"));
717 MsOS_ReadMemory();
718
719 if(u32Exception)
720 {
721 NSK_TRACE(("DMA Exception: [0x%x]\n", u32Exception));
722 }
723 }
724 }
725
NSKHDI_DMADevice_WriteData(NSK2HDI_HANDLE DMADevice_handle,void * M2MChannel_cookie,NDS_ULONG desc_size,const NDS_UBYTE * desc,NDS_ULONG data_size,NDS_UBYTE * in_data,NDS_UBYTE * out_data)726 NSK2HDI_STATUS NSKHDI_DMADevice_WriteData( NSK2HDI_HANDLE DMADevice_handle,
727 void *M2MChannel_cookie,
728 NDS_ULONG desc_size,
729 const NDS_UBYTE *desc,
730 NDS_ULONG data_size,
731 NDS_UBYTE *in_data,
732 NDS_UBYTE *out_data)
733 {
734
735 MS_U8 *pDesc = (MS_U8 *)desc;
736 MS_U8 desc_tag;
737 NDS_ULONG size;
738 MS_U8 TagSwitch;
739 MS_U8 descriptor_length;
740 MS_U8 operation;
741 MS_U8 type;
742 M2MConfig_t tM2MConfig;
743 MS_U8 M2MAlgorithm, M2MOpration;
744
745 M2MChannelDevice_Cookie_t *pM2MChCookie = (M2MChannelDevice_Cookie_t *)M2MChannel_cookie;
746
747 memset(&tM2MConfig,0x0,sizeof(M2MConfig_t));
748
749 M2MAlgorithm = tM2MConfig.Algorithm = pM2MChCookie->Algorithm;
750 M2MOpration = tM2MConfig.Operation = pM2MChCookie->Operation;
751 tM2MConfig.en_swKeys = pM2MChCookie->en_swKeys;
752 tM2MConfig.pInput = in_data;
753 tM2MConfig.pOutput = out_data;
754 tM2MConfig.size = data_size;
755 tM2MConfig.clearkey_length = pM2MChCookie->clearkey_length;
756 memcpy(tM2MConfig.clearkey, pM2MChCookie->clearkey, tM2MConfig.clearkey_length);
757
758 NSK_TRACE(("Enter , M2MChannel_cookie = 0x%p\n", M2MChannel_cookie));
759
760 NSK_TRACE(("desc_size = %x,data_size=%x\n",desc_size,data_size));
761 NSK_TRACE(("in_data = 0x%p,out_data=0x%p\n",in_data,out_data));
762 NSK_TRACE(("M2MAlgorithm = 0x%x, M2MOpration = 0x%x\n",M2MAlgorithm,M2MOpration));
763
764 desc_tag = *pDesc;
765 size = desc_size;
766 pDesc = (MS_U8*)desc;
767
768 while(size>=3)
769 {
770 TagSwitch = pDesc[0] ;
771 descriptor_length = pDesc[1];
772
773 switch(TagSwitch)
774 {
775 case NSK2HDI_DMA_IV1_DESC_TAG:
776 NSK_TRACE(("NSK2HDI_DMA_IV1_DESC_TAG, descriptor_length = 0x%02x\n",descriptor_length));
777 memcpy(dma_iv1_desc.iv_payload,&pDesc[2],descriptor_length);
778 memcpy(tM2MConfig.IV1,&pDesc[2],descriptor_length);
779 #if 0
780 printf("NSK2HDI_DMA_IV1, ");
781 for(i=0;i<descriptor_length;i++)
782 {
783 printf("%x, ",tM2MConfig.IV1[i]);
784 }
785 printf("\n");
786 #endif
787 break;
788
789 case NSK2HDI_DMA_IV2_DESC_TAG:
790 NSK_TRACE(("NSK2HDI_DMA_IV2_DESC_TAG, descriptor_length = 0x%02x\n",descriptor_length));
791 memcpy(dma_iv2_desc.iv_payload,&pDesc[2],descriptor_length);
792 memcpy(tM2MConfig.IV2,&pDesc[2],descriptor_length);
793 #if 0
794 printf("NSK2HDI_DMA_IV2, ");
795 for(i=0;i<descriptor_length;i++)
796 {
797 printf("%x, ",tM2MConfig.IV2[i]);
798 }
799 printf("\n");
800 #endif
801 break;
802
803 case NSK2HDI_DMA_OPERATION_DESC_TAG:
804 operation = pDesc[2];
805 NSK_TRACE(("NSK2HDI_DMA_OPERATION_DESC_TAG, operation = 0x%02x\n",operation));
806 break;
807
808 case NSK2HDI_DMA_SRC_MEMORY_TYPE_DESC_TAG:
809 type = pDesc[2];
810 NSK_TRACE(("NSK2HDI_DMA_SRC_MEMORY_TYPE_DESC_TAG, type = 0x%02x\n",type));
811 if(NSK2HDI_DMA_CONTIGUOUS_MEMORY_TYPE == type)
812 {
813 NSK_TRACE(("DMA_SRC_MEMORY NSK2HDI_DMA_CONTIGUOUS_MEMORY_TYPE\n"));
814 }
815 break;
816
817 case NSK2HDI_DMA_DST_MEMORY_TYPE_DESC_TAG:
818 type = pDesc[2];
819 NSK_TRACE(("NSK2HDI_DMA_DST_MEMORY_TYPE_DESC_TAG, type = 0x%02x\n",type));
820 if(NSK2HDI_DMA_CONTIGUOUS_MEMORY_TYPE == type)
821 {
822 NSK_TRACE(("DMA_DST_MEMORY NSK2HDI_DMA_CONTIGUOUS_MEMORY_TYPE\n"));
823 }
824 break;
825
826 default:
827 NSK_ERROR(("unknown desc tag\n"));
828 break;
829 }
830 size -= (descriptor_length+2);
831 pDesc += (descriptor_length+2);
832 }
833
834
835 //memcpy(out_data,in_data,data_size);
836
837 NSKHDI_WriteM2MTest(&tM2MConfig);
838
839 NSK_TRACE(("Exit\n"));
840 return NSK2HDI_STATUS_OK;
841 }
842
843 /*****************************************************************************\
844 \ M2M devices - Channle Group device
845 \*****************************************************************************/
846
NSKHDI_M2MChannelGroup_Open(NSK2HDI_DEVICE_ID M2MChannelGroup_ID,NSK2HDI_HANDLE * M2MChannelGroup_handle)847 NSK2HDI_STATUS NSKHDI_M2MChannelGroup_Open (NSK2HDI_DEVICE_ID M2MChannelGroup_ID,
848 NSK2HDI_HANDLE *M2MChannelGroup_handle)
849 {
850 NSK_TRACE(("Enter\n"));
851 MS_U32 i;
852
853 NSK_TRACE(("M2MChannelGroup_ID = %x\n",M2MChannelGroup_ID));
854
855 if(*M2MChannelGroup_handle != NULL)
856 {
857 NSK_ERROR(("M2MChannelGroup_handle no NULL\n"));
858 }
859
860 for(i = 0; i < NSK2_M2MChannelGroup_Number; i++)
861 {
862 if (nsk_m2mgrp[i].alloc == FALSE)
863 {
864 break;
865 }
866 }
867 if (i == NSK2_M2MChannelGroup_Number)
868 {
869 return (NSK2HDI_STATUS_FAILED);
870 }
871
872 nsk_m2mgrp[i].alloc = TRUE;
873 nsk_m2mgrp[i].handle_id = i;
874
875 *M2MChannelGroup_handle = (NSK2HDI_HANDLE *)&nsk_m2mgrp[i].handle_id;
876
877 NSK_TRACE(("M2MChannelGroup_handle = 0x%x\n",nsk_m2mgrp[i].handle_id));
878
879 NSK_TRACE(("Exit\n"));
880 return NSK2HDI_STATUS_OK;
881 }
882
NSKHDI_M2MChannelGroup_Close(NSK2HDI_HANDLE M2MChannelGroup_handle)883 NSK2HDI_STATUS NSKHDI_M2MChannelGroup_Close (NSK2HDI_HANDLE M2MChannelGroup_handle)
884 {
885 NSK_TRACE(("Enter\n"));
886 MS_U32 u32Handle = NSKHDI_GetHandle(M2MChannelGroup_handle);
887
888 nsk_m2mgrp[u32Handle].alloc = FALSE;
889 nsk_m2mgrp[u32Handle].handle_id = 0;
890
891 NSK_TRACE(("Exit\n"));
892 return NSK2HDI_STATUS_OK;
893 }
894
895
NSKHDI_M2MChannelGroup_GetProperties(NSK2HDI_HANDLE M2MChannelGroup_handle,NDS_ULONG request_id,NDS_ULONG * desc_size,NDS_UBYTE * desc)896 NSK2HDI_STATUS NSKHDI_M2MChannelGroup_GetProperties( NSK2HDI_HANDLE M2MChannelGroup_handle,
897 NDS_ULONG request_id,
898 NDS_ULONG *desc_size,
899 NDS_UBYTE *desc)
900 {
901 NSK_TRACE(("Enter\n"));
902
903 if(request_id != NSK2HDI_M2MCHANNELGROUP_READ_ALL_DESCRIPTORS_REQUEST)
904 {
905 return NSK2HDI_STATUS_INVALID_REQUEST;
906 }
907
908 if(desc == NULL)
909 {
910 MDrv_NSK2_GetM2MProperties((MS_U32*)desc_size, (MS_U8*)desc);
911 return NSK2HDI_STATUS_OK;
912 }
913
914 if(*desc_size == 0)
915 {
916 return NSK2HDI_STATUS_INVALID_REQUEST;
917 }
918
919
920 MDrv_NSK2_GetM2MProperties((MS_U32*)desc_size, (MS_U8*)desc);
921 NSK_TRACE(("Exit\n"));
922 return NSK2HDI_STATUS_OK;
923 }
924
925 /*****************************************************************************\
926 \ M2M devices - Channle device
927 \*****************************************************************************/
928
NSKHDI_M2MChannelDevice_Open(NSK2HDI_DEVICE_ID M2MChannelGroup_ID,NSK2HDI_HANDLE * M2MChannel_handle)929 NSK2HDI_STATUS NSKHDI_M2MChannelDevice_Open (NSK2HDI_DEVICE_ID M2MChannelGroup_ID,
930 NSK2HDI_HANDLE *M2MChannel_handle)
931 {
932 NSK_TRACE(("Enter\n"));
933
934 NSK_TRACE(("M2MChannelGroup_ID = %x\n",M2MChannelGroup_ID));
935
936 MS_U32 i;
937
938 if(*M2MChannel_handle != NULL)
939 {
940 NSK_ERROR(("CmChannele_handle no NULL\n"));
941 }
942
943 for(i = 0; i < NSK2_M2MChannel_Number; i++)
944 {
945 if (nsk_m2m[i].alloc == FALSE)
946 {
947 break;
948 }
949 }
950 if (i == NSK2_M2MChannel_Number)
951 {
952 return (NSK2HDI_STATUS_FAILED);
953 }
954
955 nsk_m2m[i].alloc = TRUE;
956 nsk_m2m[i].handle_id = i;
957
958 *M2MChannel_handle = (NSK2HDI_HANDLE *)&nsk_m2m[i].handle_id;
959
960 NSK_TRACE(("M2MChannel_handle = 0x%x\n",nsk_m2m[i].handle_id));
961 NSK_TRACE(("Exit\n"));
962 return NSK2HDI_STATUS_OK;
963 }
964
NSKHDI_M2MChannelDevice_Close(NSK2HDI_HANDLE M2MChannel_handle)965 NSK2HDI_STATUS NSKHDI_M2MChannelDevice_Close (NSK2HDI_HANDLE M2MChannel_handle)
966 {
967 NSK_TRACE(("Enter\n"));
968 MS_U32 u32Handle = NSKHDI_GetHandle(M2MChannel_handle);
969
970 nsk_m2m[u32Handle].alloc = FALSE;
971 nsk_m2m[u32Handle].handle_id = 0;
972
973 NSK_TRACE(("Exit\n"));
974 return NSK2HDI_STATUS_OK;
975 }
976
977
NSKHDI_M2MChannelDevice_GetCookie(NSK2HDI_HANDLE M2MChannele_handle,void ** cookie)978 NSK2HDI_STATUS NSKHDI_M2MChannelDevice_GetCookie(NSK2HDI_HANDLE M2MChannele_handle,
979 void **cookie)
980 {
981 NSK_TRACE(("Enter\n"));
982
983 MS_U32 u32Handle = NSKHDI_GetHandle(M2MChannele_handle);
984
985 *cookie = pM2MChannelcookie[u32Handle];
986
987 NSK_TRACE(("Exit, cookie = %p\n",*cookie));
988 return NSK2HDI_STATUS_OK;
989 }
990
991
992 /* configure cookie according to given descriptor.
993 later cookie will be used to set m2m params @ WriteData */
NSKHDI_M2MChannelDevice_Configure(NSK2HDI_HANDLE M2MChannele_handle,NDS_ULONG desc_size,const NDS_UBYTE * desc)994 NSK2HDI_STATUS NSKHDI_M2MChannelDevice_Configure (NSK2HDI_HANDLE M2MChannele_handle,
995 NDS_ULONG desc_size,
996 const NDS_UBYTE *desc)
997 {
998 NSK_TRACE(("Enter\n"));
999
1000 MS_U32 u32Handle = NSKHDI_GetHandle(M2MChannele_handle);
1001
1002 MS_U8 *pDesc = (MS_U8 *)desc;
1003 NDS_ULONG size;
1004 MS_U8 TagSwitch;
1005 MS_U8 descriptor_length;
1006 MS_U8 operation;
1007 MS_U8 algorithm;
1008
1009 gpM2MChCookie = (M2MChannelDevice_Cookie_t *)pM2MChannelcookie[u32Handle];
1010
1011 NSK_TRACE(("gpM2MChCookie = 0x%p\n", gpM2MChCookie));
1012
1013 size = desc_size;
1014 pDesc = (MS_U8*)desc;
1015
1016 while(size>=3)
1017 {
1018 TagSwitch = pDesc[0] ;
1019 descriptor_length = pDesc[1];
1020
1021 switch(TagSwitch)
1022 {
1023 case NSK2HDI_M2MCHANNEL_ALGORITHM_DESC_TAG:
1024 algorithm = pDesc[2];
1025 NSK_TRACE(("NSK2HDI_M2MCHANNEL_ALGORITHM_DESC_TAG, algorithm = 0x%02x\n",algorithm));
1026 gpM2MChCookie->Algorithm = algorithm;
1027 break;
1028
1029 case NSK2HDI_M2MCHANNEL_OPERATION_DESC_TAG:
1030 operation = pDesc[2];
1031 NSK_TRACE(("NSK2HDI_M2MCHANNEL_OPERATION_DESC_TAG, operation = 0x%02x\n",operation));
1032 gpM2MChCookie->Operation = operation;
1033 break;
1034
1035 default:
1036 NSK_ERROR(("unknown desc tag\n"));
1037 break;
1038 }
1039 size -= (descriptor_length+2);
1040 pDesc += (descriptor_length+2);
1041 }
1042
1043 #if 0
1044 if(desc != NULL)
1045 {
1046 M2MCh_Operation_Desc_t *pM2MChOp = (M2MCh_Operation_Desc_t *)desc;
1047
1048 NSK_TRACE(("desc_size = %x, tag = %x , operation = %x\n",desc_size, pM2MChOp->descriptor_tag, pM2MChOp->operation));
1049
1050 #if 0
1051 if(pM2MChOp->descriptor_tag == NSK2HDI_M2MCHANNEL_ALGORITHM_DESC_TAG)
1052 {
1053 NSK_TRACE(("set algorithm = %d\n",pM2MChOp->operation));
1054 }
1055 else if (pM2MChOp->descriptor_tag == NSK2HDI_M2MCHANNEL_OPERATION_DESC_TAG)
1056 {
1057 NSK_TRACE(("set operation = %d\n",pM2MChOp->operation));
1058 }
1059
1060 //#define NSK2HDI_M2MCHANNEL_DECRYPT_OPERATION 0x01U /*!< @brief Data chunk descrambling operation */
1061 //#define NSK2HDI_M2MCHANNEL_ENCRYPT_OPERATION 0x02U /*!< @brief Data chunk scrambling operation */
1062 #endif
1063 gpM2MChCookie->u32Algorithm = pM2MChOp->operation;
1064 }
1065 else
1066 {
1067 NSK_TRACE(("desc == NULL\n"));
1068 }
1069 #endif
1070 NSK_TRACE(("Exit\n"));
1071 return NSK2HDI_STATUS_OK;
1072 }
1073
1074
1075
NSKHDI_M2MChannelDevice_WriteM2MKey(NSK2HDI_HANDLE M2MChannele_handle,NDS_ULONG desc_size,const NDS_UBYTE * desc)1076 NSK2HDI_STATUS NSKHDI_M2MChannelDevice_WriteM2MKey(NSK2HDI_HANDLE M2MChannele_handle,
1077 NDS_ULONG desc_size,
1078 const NDS_UBYTE *desc)
1079 {
1080 NSK_TRACE(("Enter\n"));
1081 // MS_U32 i;
1082 MS_U8 *pDesc = (MS_U8 *)desc;
1083 NDS_ULONG size;
1084 MS_U8 TagSwitch;
1085 MS_U8 descriptor_length;
1086 MS_U8 operation;
1087 MS_U8 algorithm;
1088
1089 MS_U32 u32Handle = NSKHDI_GetHandle(M2MChannele_handle);
1090 M2MChannelDevice_Cookie_t *pM2MChCookie = (M2MChannelDevice_Cookie_t *)pM2MChannelcookie[u32Handle];
1091
1092 if(desc != NULL)
1093 {
1094 size = desc_size;
1095 pDesc = (MS_U8*)desc;
1096
1097 while(size>=3)
1098 {
1099 TagSwitch = pDesc[0] ;
1100 descriptor_length = pDesc[1];
1101
1102 switch(TagSwitch)
1103 {
1104 case NSK2HDI_M2MCHANNEL_ALGORITHM_DESC_TAG:
1105 algorithm = pDesc[2];
1106 NSK_TRACE(("NSK2HDI_M2MCHANNEL_ALGORITHM_DESC_TAG, algorithm = %x\n",algorithm));
1107 break;
1108
1109 case NSK2HDI_M2MCHANNEL_OPERATION_DESC_TAG:
1110 operation = pDesc[2];
1111 NSK_TRACE(("NSK2HDI_M2MCHANNEL_OPERATION_DESC_TAG, operation = %x\n",operation));
1112 break;
1113
1114
1115 case NSK2HDI_M2MCHANNEL_CLEAR_SWKEY_DESC_TAG:
1116 NSK_TRACE(("set clear key\n"));
1117 pM2MChCookie->clearkey_length = descriptor_length;
1118 memcpy(pM2MChCookie->clearkey, &pDesc[2], descriptor_length);
1119 #if 0
1120 for(i=0;i<pM2MChCookie->clearkey_length;i++)
1121 {
1122 printf("%x, ",pM2MChCookie->clearkey[i]);
1123 }
1124 printf("\n");
1125 #endif
1126 pM2MChCookie->en_swKeys = TRUE;
1127 break;
1128
1129 default:
1130 NSK_ERROR(("unknown desc tag\n"));
1131 break;
1132 }
1133 size -= (descriptor_length+2);
1134 pDesc += (descriptor_length+2);
1135 }
1136 }
1137 else
1138 {
1139 NSK_TRACE(("desc == NULL\n"));
1140 }
1141
1142 NSK_TRACE(("Exit\n"));
1143 return NSK2HDI_STATUS_OK;
1144 }
1145
NSKHDI_M2MChannelDevice_NSKWriteM2MKey(NSK2HDI_HANDLE M2MChannele_handle,NDS_ULONG desc_size,const NDS_UBYTE * desc)1146 NSK2HDI_STATUS NSKHDI_M2MChannelDevice_NSKWriteM2MKey(NSK2HDI_HANDLE M2MChannele_handle,
1147 NDS_ULONG desc_size,
1148 const NDS_UBYTE *desc)
1149 {
1150 NSK_TRACE(("Enter\n"));
1151
1152 MS_U8 *pDesc = (MS_U8 *)desc;
1153 NDS_ULONG size;
1154 MS_U8 TagSwitch;
1155 MS_U8 descriptor_length;
1156 MS_U8 operation;
1157 MS_U8 algorithm = 1;
1158
1159 MS_U32 u32Handle = NSKHDI_GetHandle(M2MChannele_handle);
1160 M2MChannelDevice_Cookie_t *pM2MChCookie = (M2MChannelDevice_Cookie_t *)pM2MChannelcookie[u32Handle];
1161
1162 if(desc != NULL)
1163 {
1164 M2MCh_Operation_Desc_t *pM2MOp = (M2MCh_Operation_Desc_t *)desc;
1165
1166 NSK_TRACE(("desc_size = %x, length = %x, operation = %x\n",desc_size,pM2MOp->descriptor_length,pM2MOp->operation));
1167
1168 size = desc_size;
1169 pDesc = (MS_U8*)desc;
1170
1171 while(size>=3)
1172 {
1173 TagSwitch = pDesc[0] ;
1174 descriptor_length = pDesc[1];
1175
1176 switch(TagSwitch)
1177 {
1178 case NSK2HDI_M2MCHANNEL_ALGORITHM_DESC_TAG:
1179 algorithm = pDesc[2];
1180 NSK_TRACE(("NSK2HDI_M2MCHANNEL_ALGORITHM_DESC_TAG, algorithm = %x\n",algorithm));
1181 break;
1182
1183 case NSK2HDI_M2MCHANNEL_OPERATION_DESC_TAG:
1184 operation = pDesc[2];
1185 NSK_TRACE(("NSK2HDI_M2MCHANNEL_OPERATION_DESC_TAG, operation = %x\n",operation));
1186 break;
1187
1188 default:
1189 NSK_ERROR(("unknown desc tag\n"));
1190 break;
1191 }
1192 size -= (descriptor_length+2);
1193 pDesc += (descriptor_length+2);
1194 }
1195
1196 pM2MChCookie->en_swKeys = FALSE;
1197 MDrv_NSK21_WriteM2MKey(algorithm);
1198 }
1199 else
1200 {
1201 NSK_TRACE(("desc == NULL\n"));
1202 }
1203
1204 NSK_TRACE(("Exit\n"));
1205 return NSK2HDI_STATUS_OK;
1206
1207 }
1208
1209