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) 2006-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 drvCIPHER.c
98 // @brief CIPHER Driver
99 // @author MStar Semiconductor,Inc.
100 //
101 ////////////////////////////////////////////////////////////////////////////////////////////////////
102
103 #ifdef MSOS_TYPE_LINUX_KERNEL
104 #include <linux/string.h>
105 #include <linux/uaccess.h>
106 #include <linux/compat.h>
107 #else
108 #include <stdio.h>
109 #include <string.h>
110 #endif
111
112 #include "MsCommon.h"
113 #include "MsIRQ.h"
114 #include "MsOS.h"
115 #include "MsVersion.h"
116
117 #include "drvCIPHER.h"
118 #include "drvMMIO.h"
119 #include "halRSA.h"
120 #include "halCIPHER.h"
121 #include "utopia.h"
122
123 #include "drvAESDMA_v2.h"
124 #include "drvAESDMA_private.h"
125
126 #ifdef CIPHER_UTOPIA_20
127 #define CIPHER_UTOPIA2 1UL
128 #else
129 #define CIPHER_UTOPIA2 0UL
130 #endif
131
132 #if CIPHER_UTOPIA2
133 #include "drvCIPHER_v2.h"
134 #endif
135 #include "drvCIPHER_private.h"
136
137 //--------------------------------------------------------------------------------------------------
138 // Driver Compiler Option
139 //--------------------------------------------------------------------------------------------------
140 #define CIPHERIntEnable() MsOS_EnableInterrupt (CRYPTODMA_IRQ)
141 #define CIPHERIntDisable() MsOS_DisableInterrupt(CRYPTODMA_IRQ)
142 #define CIPHERIntAttach() MsOS_AttachInterrupt (CRYPTODMA_IRQ, (InterruptCb )_CIPHER_Isr)
143 #define CIPHERIntDetach() MsOS_DetachInterrupt (CRYPTODMA_IRQ)
144
145 #define AESDMAPA2KSEG1(addr) ((void *)(((MS_U32)addr) | 0xa0000000UL)) //physical -> unchched
146
147
148 #define RSAInitChk() if(_bRSA_Init == FALSE){ DEBUG_CIPHER(CIPHER_DBG_ERR,"Not initialized"); return DRVAESDMA_FAIL; }
149 //--------------------------------------------------------------------------------------------------
150 // Local Defines
151 //--------------------------------------------------------------------------------------------------
152 #define CIPHER_TASK_STACK_SIZE (4096UL)
153 #define CIPHER_CAVID (0x0FUL)
154 #define HASH_HMAC_KEYPAD_SIZE (64UL)
155 #define HASH_RPT_SIZE_ALL (10UL)
156 #define HASH_RPT_SIZE_STATUS (2UL)
157
158 #define HASH_MD5_DIGEST_SIZE (16UL)
159 #define HASH_SHA1_DIGEST_SIZE (20UL)
160 #define HASH_SHA256_DIGEST_SIZE (32UL)
161 #define HASH_SM3_DIGEST_SIZE (32UL)
162 #define HASH_BLOCK_SIZE (64UL)
163
164 #define DRV_CIPHER_TA_SHA_CHECK_SIZE (8UL)
165 #define DRV_CIPHER_TA_LUT3_BITMAP_LUT (0x1UL)
166 #define DRV_CIPHER_TA_LUT3_BITMAP_M (0x2UL)
167 #define DRV_CIPHER_TA_LUT3_BITMAP_BC (0x4UL)
168 #define DRV_CIPHER_TA_KCV_SIZE (16UL) //HW limitation, need padding to 16 bytes
169 #define DRV_CIPHER_TA_LUT_SIZE (256UL)
170 #define DRV_CIPHER_TA_M_SIZE (128UL)
171 #define DRV_CIPHER_TA_BC_SIZE (16UL)
172
173 #define DRV_CIPHER_TA_SHA_FAIL (0x00000010UL)
174 #define DRV_CIPHER_TA_KCV_FAIL (0x00000020UL)
175 #define DRV_CIPHER_TA_LUT_FAIL (0x00000030UL)
176 #define DRV_CIPHER_TA_M_FAIL (0x00000040UL)
177 #define DRV_CIPHER_TA_BC_FAIL (0x00000050UL)
178
179 #define DRV_CIPHER_NO_REPORT_BUFFER (0x00000003UL)
180
181 //Interrupt
182 #define DRV_CIPHER_DMA_DATA_INIT (0x00000000UL)
183 #define DRV_CIPHER_DONE (0x00000100UL)
184 #define DRV_CIPHER_CALLBACK (0x0000000FUL)
185 #define DRV_CIPHER_CLOSE (0x80000000UL)
186
187 //Report status
188 #define DRV_CIPHER_REPORT_OK (0x80000000UL)
189
190 typedef struct
191 {
192 MS_U32 u32LUT; //LUT3 fill in 512 bytes table, each has 9 bits to describe
193 MS_U32 u32M;
194 MS_U32 u32BC;
195 }DRV_CIPHER_TA_LUT3;
196
197
198 //--------------------------------------------------------------------------------------------------
199 // Global Variable
200 //--------------------------------------------------------------------------------------------------
201 static MS_BOOL _bCIPHERDrv_Inited = FALSE;
202 static MS_BOOL _bCIPHERDrv_KeyCtrlEn = FALSE;
203
204 #ifdef CIPHER_NO_PRINTF
205 #define DRV_CIPHER_ASSERT( _bool_, _msg_, ret) if(!(_bool_)){return (ret);}
206 #else
207 #define DRV_CIPHER_ASSERT( _bool_, _msg_, ret) if(!(_bool_)){ printf(_msg_); return (ret);}
208 #endif
209 #define DRV_CIPHER_INIT_CHECK(ret) DRV_CIPHER_ASSERT(TRUE == _bCIPHERDrv_Inited, "drvCIPHER is not initialized\n", ret)
210 #define DRV_CIPHER_KEYCTRL_CHECK(ret) DRV_CIPHER_ASSERT(TRUE == _bCIPHERDrv_KeyCtrlEn, "drvCIPHER key control mode is not enable\n", ret)
211
212 MS_S32 _CipherMtx = 0;
213 MS_S32 _CipherRSAMtx;
214 MS_S32 _CipherSemaphore;
215
216 MS_S32 _AESDMAMtx = 0;
217
218 MS_BOOL bDES_Key = FALSE;
219
220 #if CIPHER_UTOPIA2
221 static void *pu32AesdmaInst = NULL;
222 static void *pu32CipherInst = NULL;
223 #endif
224
225 static CIPHER_DBGMSG_LEVEL _CIPHERDBGLevel = CIPHER_DBG_ERR;
226 static MSIF_Version _drv_cipher_version = {
227 .DDI = { CIPHER_DRV_VERSION, },
228 };
229
230 #if !defined (MSOS_TYPE_NOS) && !defined (MCU_AEON) && !defined (MSOS_TYPE_OPTEE)
231 //Isr proc
232 static void* _pCIPHERTaskStack;
233 static MS_U8 _u8CIPHER_StackBuffer[CIPHER_TASK_STACK_SIZE];
234 static MS_S32 _s32CIPHERTaskId;
235
236 static MS_U32 _u32LastErr;
237
238 typedef enum
239 {
240 E_CIPHER_DMA_DONE,
241 E_CIPHER_HASH_DONE,
242 }CIPHER_WAIT;
243
244 static CIPHER_WAIT _eCipherWait;
245
246 #endif
247
248 #define CIPHER_REPORT_BUFFER_MAX 2UL
249
250 typedef struct
251 {
252 MS_U32 u32Report;
253 MS_U32 u32DoneBytes;
254 MS_U32 u32ExcMsg;
255 MS_U8* pu8Digest_Buf;
256 MS_U32 u32Digest_Buf_Size;
257 P_DrvCIPHER_EvtCallback pfCallback;
258 CIPHER_KEY_SRC eKeySrc;
259 MS_U8 u8KeyIdx;
260 MS_BOOL bUsed;
261 }CIPHER_REPORT;
262
263 typedef struct
264 {
265 DRV_CIPHER_DMACFG stConfig;
266 MS_U8 u8Key[HAL_CRYPTODMA_KEYLEN_MAX];
267 MS_U8 u8IV[HAL_CRYPTODMA_KEYLEN_MAX];
268 MS_BOOL bUsed;
269 }CIPHER_RESOURCE;
270
271 static CIPHER_REPORT _CIPHER_ReportBuffer[CIPHER_REPORT_BUFFER_MAX];
272 static CIPHER_RESOURCE _CIPHER_Resource[HAL_CRYPTODMA_DMA_KEY_SLOT];
273
274 #if CIPHER_UTOPIA2
275 extern MS_U32 _u32CallbackID;
276 extern MS_U16 _u16ThreadID;
277 #else
278 static MS_U32 _u32CallbackID = 1;
279 static MS_U16 _u16ThreadID = 1;
280 #endif
281
282 //--------------------------------------------------------------------------------------------------
283 // Internal Variable
284 //--------------------------------------------------------------------------------------------------
285
286 static MS_BOOL _bRSA_Init = FALSE;
287
288 #if !defined (MSOS_TYPE_NOS) && !defined (MCU_AEON) && !defined (MSOS_TYPE_OPTEE)
289 static MS_S32 _s32CIPHEREventId;
290
291 #define _CIPHER_SetEvent(flag) MsOS_SetEvent(_s32CIPHEREventId, (flag))
292 #define _CIPHER_GetEvent(events) MsOS_WaitEvent(_s32CIPHEREventId, DRV_CIPHER_DONE, &events, E_OR_CLEAR, MSOS_WAIT_FOREVER)
293
294 #endif
295 //--------------------------------------------------------------------------------------------------
296 // Debug Function
297 //--------------------------------------------------------------------------------------------------
298 #ifdef CIPHER_NO_PRINTF
299 #define DEBUG_CIPHER(debug_level, fmt, args...)
300 #define DEBUG_CIPHER_KEYCTRL(debug_level, fmt, args...)
301 #else
302 #define DEBUG_CIPHER(debug_level, fmt, args...) do{ if (_CIPHERDBGLevel >= (debug_level))\
303 printf("[%s][%d]"fmt"\n", __FUNCTION__, __LINE__, ## args);}\
304 while(0)
305 #define DEBUG_CIPHER_KEYCTRL(debug_level, fmt, args...) do{ if (_CIPHERDBGLevel >= (debug_level))\
306 printf("[%s][%d][KeyCtrl] "fmt"\n", __FUNCTION__, __LINE__, ## args);}\
307 while(0)
308 #endif
309
310
311 //--------------------------------------------------------------------------------------------------
312 // Internal Function
313 //--------------------------------------------------------------------------------------------------
314 #if !defined (MSOS_TYPE_NOS) && !defined (MCU_AEON) && !defined (MSOS_TYPE_OPTEE)
_CIPHER_Isr(void)315 static void _CIPHER_Isr(void)
316 {
317 MS_U32 u32Rpt[10] = {0};
318 MS_U32 u32ExcMsg = 0;
319 MS_U32 u32RptId = 0;
320 MS_U8 u8BufNum = 0;
321 MS_U8* pu8Digest_Buf = NULL;
322 MS_U32 u32Digest_Buf_Size = 0;
323
324 HAL_CIPHER_IntClear();
325
326 if(E_CIPHER_DMA_DONE == _eCipherWait)
327 {
328 HAL_CIPHER_DMA_GetRpt(u32Rpt);
329 HAL_CIPHER_GetException(&u32ExcMsg);
330
331 u32RptId = u32Rpt[0] & REG_CIPHER_RPT_THREAD_MSK;
332 u8BufNum = u32RptId % (MS_U32)CIPHER_REPORT_BUFFER_MAX;
333
334 _CIPHER_ReportBuffer[u8BufNum].u32Report = u32Rpt[0];
335 _CIPHER_ReportBuffer[u8BufNum].u32DoneBytes = u32Rpt[1];
336 _CIPHER_ReportBuffer[u8BufNum].u32ExcMsg = u32ExcMsg;
337
338 }
339 else //E_CIPHER_HASH_DONE
340 {
341 //Get all register report, include status and digest
342 HAL_CIPHER_Hash_GetRpt(u32Rpt, HASH_RPT_SIZE_ALL);
343 HAL_CIPHER_GetException(&u32ExcMsg);
344
345 u32RptId = u32Rpt[0] & REG_CIPHER_RPT_THREAD_MSK;
346 u8BufNum = u32RptId % (MS_U32)CIPHER_REPORT_BUFFER_MAX;
347
348 _CIPHER_ReportBuffer[u8BufNum].u32Report = u32Rpt[0];
349 _CIPHER_ReportBuffer[u8BufNum].u32DoneBytes = u32Rpt[1];
350 _CIPHER_ReportBuffer[u8BufNum].u32ExcMsg = u32ExcMsg;
351
352 pu8Digest_Buf = _CIPHER_ReportBuffer[u8BufNum].pu8Digest_Buf;
353 u32Digest_Buf_Size = _CIPHER_ReportBuffer[u8BufNum].u32Digest_Buf_Size;
354
355 if((pu8Digest_Buf != NULL) && (u32Digest_Buf_Size != 0))
356 {
357 //Avoid status report, only copy digest to output address
358 memcpy((MS_U8 *)pu8Digest_Buf, u32Rpt+HASH_RPT_SIZE_STATUS, u32Digest_Buf_Size);
359 }
360
361 }
362
363 _u32CallbackID = u32RptId;
364
365 _CIPHER_SetEvent(DRV_CIPHER_DONE); // Trigger task
366 CIPHERIntEnable();
367
368 }
369
_CIPHER_Isr_Proc(void)370 static void _CIPHER_Isr_Proc(void)
371 {
372 MS_U32 u32Events = 0;
373 MS_U32 u32Rpt = 0;
374 MS_BOOL bSuccess = FALSE;
375 MS_U32 u32ExcMsg = 0;
376 MS_U32 u32ExcTmp = 0;
377 MS_U32 u32RptId = 0;
378 MS_U8 u8BufNum = 0;
379 MS_U8 u8KeyIdx = 0;
380 P_DrvCIPHER_EvtCallback pfCallBack = NULL;
381 CIPHER_KEY_SRC eKeySrc = 0;
382
383 while (1)
384 {
385 _CIPHER_GetEvent(u32Events);
386
387 if (HAS_FLAG(u32Events, DRV_CIPHER_DONE))
388 {
389 //Handling callback
390 u8BufNum = _u32CallbackID % (MS_U32)CIPHER_REPORT_BUFFER_MAX;
391 u32Rpt = _CIPHER_ReportBuffer[u8BufNum].u32Report;
392 pfCallBack = _CIPHER_ReportBuffer[u8BufNum].pfCallback;
393 u32ExcTmp = _CIPHER_ReportBuffer[u8BufNum].u32ExcMsg;
394 eKeySrc = _CIPHER_ReportBuffer[u8BufNum].eKeySrc;
395 u8KeyIdx = _CIPHER_ReportBuffer[u8BufNum].u8KeyIdx;
396
397 HAL_CIPHER_Hash_ExceptFilter(&u32ExcTmp, eKeySrc, u8KeyIdx);
398 u32ExcMsg = HAL_CIPHER_ReadException(u32ExcTmp);
399
400 u32RptId = u32Rpt & REG_CIPHER_RPT_THREAD_MSK;
401
402 bSuccess = FALSE;
403
404 if(u32Rpt & DRV_CIPHER_REPORT_OK)
405 {
406 bSuccess = TRUE;
407 }
408
409 if(u32ExcMsg != 0)
410 {
411 HAL_CIPHER_ResetException();
412 }
413
414 _CIPHER_ReportBuffer[u8BufNum].u32Report = 0;
415 _CIPHER_ReportBuffer[u8BufNum].u32DoneBytes = 0;
416 _CIPHER_ReportBuffer[u8BufNum].u32ExcMsg = 0;
417 _CIPHER_ReportBuffer[u8BufNum].pu8Digest_Buf = NULL;
418 _CIPHER_ReportBuffer[u8BufNum].u32Digest_Buf_Size = 0;
419 _CIPHER_ReportBuffer[u8BufNum].pfCallback = NULL;
420 _CIPHER_ReportBuffer[u8BufNum].eKeySrc = 0;
421 _CIPHER_ReportBuffer[u8BufNum].u8KeyIdx = 0;
422 _CIPHER_ReportBuffer[u8BufNum].bUsed = FALSE;
423
424 MsOS_ReleaseSemaphore(_CipherSemaphore);
425 if(pfCallBack != NULL)
426 {
427 pfCallBack(u32RptId, bSuccess, u32ExcMsg);
428
429 }
430 }
431
432 if (HAS_FLAG(u32Events, DRV_CIPHER_CLOSE))
433 {
434 break;
435 }
436
437 } // Task while loop
438 }
439
440 #endif
441
_MDrv_CIPHER_IsDMADone(MS_U32 u32CmdId,MS_U32 * pu32Exception)442 MS_BOOL _MDrv_CIPHER_IsDMADone(MS_U32 u32CmdId, MS_U32 *pu32Exception)
443 {
444 MS_U32 u32Ret = DRV_CIPHER_OK;
445 MS_U32 u32Rpt[2] = {0};
446 MS_U8 u8BufNum = 0;
447 MS_BOOL bDone = FALSE;
448
449 DRV_CIPHER_INIT_CHECK(FALSE);
450
451 MsOS_ObtainMutex(_CipherMtx, MSOS_WAIT_FOREVER);
452
453 u8BufNum = u32CmdId % (MS_U32)CIPHER_REPORT_BUFFER_MAX;
454
455 //Check register report
456 if(FALSE == HAL_CIPHER_DMA_CmdDone(u32CmdId, &u32Ret))
457 {
458 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning:DMA cmd[%u] NOT done!", u32CmdId);
459 bDone = FALSE;
460 goto ISDMADONE_FINISH;
461 }
462
463 HAL_CIPHER_DMA_GetRpt(u32Rpt);
464
465 if((u32Rpt[0] & DRV_CIPHER_REPORT_OK) == 0)
466 {
467 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:DMA fail[%u]!", u32CmdId);
468
469 if(u32Ret != 0)
470 {
471 *pu32Exception = HAL_CIPHER_ReadException(u32Ret);
472 HAL_CIPHER_ResetException();
473 }
474 }
475
476 bDone = TRUE;
477
478 _CIPHER_ReportBuffer[u8BufNum].u32Report = 0;
479 _CIPHER_ReportBuffer[u8BufNum].u32DoneBytes = 0;
480 _CIPHER_ReportBuffer[u8BufNum].u32ExcMsg = 0;
481 _CIPHER_ReportBuffer[u8BufNum].pu8Digest_Buf = NULL;
482 _CIPHER_ReportBuffer[u8BufNum].u32Digest_Buf_Size = 0;
483 _CIPHER_ReportBuffer[u8BufNum].bUsed = FALSE;
484
485 ISDMADONE_FINISH:
486
487 MsOS_ReleaseMutex(_CipherMtx);
488
489 if(bDone)
490 {
491 MsOS_ReadMemory();
492 MsOS_ReleaseSemaphore(_CipherSemaphore);
493 }
494
495 return bDone;
496 }
497
MDrv_CIPHER_IsDMADone(MS_U32 u32CmdId,MS_U32 * pu32Exception)498 DLL_PUBLIC MS_BOOL MDrv_CIPHER_IsDMADone(MS_U32 u32CmdId, MS_U32 *pu32Exception)
499 {
500 #if CIPHER_UTOPIA2
501 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
502 CIPHER_ISDMADONE pArgs;
503 memset(&pArgs, 0, sizeof(CIPHER_ISDMADONE));
504
505 if(pu32CipherInst == NULL)
506 {
507 return DRV_CIPHER_FAIL;
508 }
509
510 pArgs.u32CmdId = u32CmdId;
511 pArgs.pu32Exception = pu32Exception;
512
513 u32Ret = UtopiaIoctl(pu32CipherInst, E_MDRV_CMD_CIPHER_IsDMADone, (void*)&pArgs);
514 if(UTOPIA_STATUS_SUCCESS != u32Ret)
515 {
516 //DEBUG_CIPHER(CIPHER_DBG_ERR, "[%s]ERROR : UtopiaIoctl return value 0x%x\n", __FUNCTION__, (unsigned int)u32Ret);
517 return FALSE;
518 }
519
520 return TRUE;
521 #else
522 return _MDrv_CIPHER_IsDMADone(u32CmdId, pu32Exception);
523 #endif
524 }
525
_MDrv_CIPHER_IsHASHDone(MS_U32 u32CmdId,MS_U32 * pu32Exception)526 MS_BOOL _MDrv_CIPHER_IsHASHDone(MS_U32 u32CmdId, MS_U32 *pu32Exception)
527 {
528 MS_U32 u32Ret = DRV_CIPHER_OK;
529 MS_U32 u32Rpt[10] = {0};
530 MS_U8 u8BufNum = 0;
531 MS_BOOL bDone = FALSE;
532
533 MS_U8* pu8Digest_Buf = NULL;
534 MS_U32 u32Digest_Buf_Size = 0;
535 CIPHER_KEY_SRC eKeySrc = 0;
536 MS_U8 u8KeyIdx = 0;
537
538 DRV_CIPHER_INIT_CHECK(FALSE);
539
540 MsOS_ObtainMutex(_CipherMtx, MSOS_WAIT_FOREVER);
541
542 u8BufNum = u32CmdId % (MS_U32)CIPHER_REPORT_BUFFER_MAX;
543
544 if(FALSE == HAL_CIPHER_Hash_CmdDone(u32CmdId, &u32Ret))
545 {
546 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning:HASH cmd[%u] NOT done!", u32CmdId);
547 bDone = FALSE;
548 goto ISHASHDONE_FINISH;
549 }
550
551 //Get all register report, include status and digest
552 HAL_CIPHER_Hash_GetRpt(u32Rpt, HASH_RPT_SIZE_ALL);
553
554 pu8Digest_Buf = _CIPHER_ReportBuffer[u8BufNum].pu8Digest_Buf;
555 u32Digest_Buf_Size = _CIPHER_ReportBuffer[u8BufNum].u32Digest_Buf_Size;
556 eKeySrc = _CIPHER_ReportBuffer[u8BufNum].eKeySrc;
557 u8KeyIdx = _CIPHER_ReportBuffer[u8BufNum].u8KeyIdx;
558
559 //Avoid status report, only copy digest to output address
560 if((pu8Digest_Buf != NULL) && (u32Digest_Buf_Size > 0))
561 {
562 memcpy((MS_U8 *)pu8Digest_Buf, u32Rpt+HASH_RPT_SIZE_STATUS, u32Digest_Buf_Size);
563 }
564
565 //Reset exception flag for polling mode
566 if(u32Ret != 0)
567 {
568 HAL_CIPHER_Hash_ExceptFilter(&u32Ret, eKeySrc, u8KeyIdx);
569 *pu32Exception = HAL_CIPHER_ReadException(u32Ret);
570 HAL_CIPHER_ResetException();
571 }
572
573 if((u32Rpt[0] & DRV_CIPHER_REPORT_OK) == 0)
574 {
575 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:HASH fail[%u]!", u32CmdId);
576 }
577
578 bDone = TRUE;
579
580 _CIPHER_ReportBuffer[u8BufNum].u32Report = 0;
581 _CIPHER_ReportBuffer[u8BufNum].u32DoneBytes = 0;
582 _CIPHER_ReportBuffer[u8BufNum].u32ExcMsg = 0;
583 _CIPHER_ReportBuffer[u8BufNum].pu8Digest_Buf = NULL;
584 _CIPHER_ReportBuffer[u8BufNum].u32Digest_Buf_Size = 0;
585 _CIPHER_ReportBuffer[u8BufNum].eKeySrc = 0;
586 _CIPHER_ReportBuffer[u8BufNum].u8KeyIdx = 0;
587 _CIPHER_ReportBuffer[u8BufNum].bUsed = FALSE;
588
589 ISHASHDONE_FINISH:
590
591 MsOS_ReleaseMutex(_CipherMtx);
592
593 if(bDone)
594 {
595 MsOS_FlushMemory();
596 MsOS_ReleaseSemaphore(_CipherSemaphore);
597 }
598
599 return bDone;
600 }
601
MDrv_CIPHER_IsHASHDone(MS_U32 u32CmdId,MS_U32 * pu32Exception)602 DLL_PUBLIC MS_BOOL MDrv_CIPHER_IsHASHDone(MS_U32 u32CmdId, MS_U32 *pu32Exception)
603 {
604 #if CIPHER_UTOPIA2
605 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
606 CIPHER_ISHASHDONE pArgs;
607 memset(&pArgs, 0, sizeof(CIPHER_ISHASHDONE));
608
609 if(pu32CipherInst == NULL)
610 {
611 return DRV_CIPHER_FAIL;
612 }
613
614 pArgs.u32CmdId = u32CmdId;
615 pArgs.pu32Exception = pu32Exception;
616
617 u32Ret = UtopiaIoctl(pu32CipherInst, E_MDRV_CMD_CIPHER_IsHASHDone, (void*)&pArgs);
618 if(UTOPIA_STATUS_SUCCESS != u32Ret)
619 {
620 //DEBUG_CIPHER(CIPHER_DBG_ERR, "[%s]ERROR : UtopiaIoctl return value 0x%x\n", __FUNCTION__, (unsigned int)u32Ret);
621 return FALSE;
622 }
623
624 return TRUE;
625 #else
626 return _MDrv_CIPHER_IsHASHDone(u32CmdId, pu32Exception);
627 #endif
628 }
629
630 #if 0
631 static void _dump(MS_U8 *ptr, MS_U32 size)
632 {
633 int i = 0;
634 printf("[DUMP Start]\n");
635 for(i = 0; i < size; i++)
636 {
637 printf("0x%02x ", *(ptr+i));
638 }
639 printf("[DUMP Finish]\n");
640 }
641 #endif
642
_AESDMA_MSBF2Native(MS_U8 u8Bytes[4])643 MS_U32 _AESDMA_MSBF2Native(MS_U8 u8Bytes[4])
644 {
645 return (u8Bytes[0] << 24) | (u8Bytes[1] << 16) | (u8Bytes[2] << 8) | u8Bytes[3];
646 }
647
_ReverseU8Buf(MS_U8 * buf,MS_U32 len)648 void _ReverseU8Buf(MS_U8 *buf, MS_U32 len)
649 {
650 MS_U8 i = 0;
651 MS_U8 j = len-1;
652 MS_U8 temp = 0;
653
654 if((buf==NULL)||(len<=1)) return;
655
656 while(i<j)
657 {
658 temp = buf[i];
659 buf[i] = buf[j];
660 buf[j] = temp;
661 i++;
662 j--;
663 }
664 }
665
_CIPHER_TransDbgLevel(DrvAESDMA_DbgLevel eDbgLevel)666 CIPHER_DBGMSG_LEVEL _CIPHER_TransDbgLevel(DrvAESDMA_DbgLevel eDbgLevel)
667 {
668 CIPHER_DBGMSG_LEVEL eCipherDbgLevel = CIPHER_DBG_NONE;
669 switch(eDbgLevel)
670 {
671 case E_DRVAESDMA_DBG_L1:
672 eCipherDbgLevel = CIPHER_DBG_ERR;
673 break;
674
675 case E_DRVAESDMA_DBG_L2:
676 eCipherDbgLevel = CIPHER_DBG_INFO;
677 break;
678
679 default:
680 eCipherDbgLevel = CIPHER_DBG_NONE;
681 break;
682 }
683
684 return eCipherDbgLevel;
685
686 }
687
688 //--------------------------------------------------------------------------------------------------
689 // Global Function
690 //--------------------------------------------------------------------------------------------------
_MDrv_CIPHER_InitBySWFlag(MS_BOOL bSWInit)691 DRV_CIPHER_RET _MDrv_CIPHER_InitBySWFlag(MS_BOOL bSWInit)
692 {
693 MS_VIRT u32Bank;
694 MS_PHY u32BankSize;
695 MS_U32 i = 0;
696
697 if(_bCIPHERDrv_Inited == TRUE)
698 {
699 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning:Double Init!");
700 return DRV_CIPHER_OK;
701 }
702
703 if (FALSE == MDrv_MMIO_GetBASE(&u32Bank, &u32BankSize, MS_MODULE_HW))
704 {
705 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Get MMIO base fail");
706 return DRV_CIPHER_FAIL;
707 }
708
709 HAL_CIPHER_SetBank(u32Bank);
710 HAL_CIPHER_ResetStatus(TRUE, TRUE);
711
712 if(FALSE == bSWInit)
713 {
714 HAL_CIPHER_SWReset();
715
716 _u16ThreadID = 1;
717 _u32CallbackID = 1;
718 }
719
720 for(i=0;i<CIPHER_REPORT_BUFFER_MAX;i++)
721 {
722 _CIPHER_ReportBuffer[i].u32Report = 0;
723 _CIPHER_ReportBuffer[i].u32DoneBytes = 0;
724 _CIPHER_ReportBuffer[i].u32ExcMsg = 0;
725 _CIPHER_ReportBuffer[i].pu8Digest_Buf = NULL;
726 _CIPHER_ReportBuffer[i].u32Digest_Buf_Size = 0;
727 _CIPHER_ReportBuffer[i].eKeySrc = 0;
728 _CIPHER_ReportBuffer[i].u8KeyIdx = 0;
729 _CIPHER_ReportBuffer[i].bUsed = FALSE;
730 }
731
732 _CipherMtx = MsOS_CreateMutex(E_MSOS_FIFO, (char*)"CIPHER Mutex", MSOS_PROCESS_SHARED);
733 _AESDMAMtx = MsOS_CreateMutex(E_MSOS_FIFO, (char*)"AESDMA Mutex", MSOS_PROCESS_SHARED);
734 _CipherSemaphore = MsOS_CreateSemaphore(1, E_MSOS_FIFO, (char *)"CIPHER Semaphore");
735
736 _bCIPHERDrv_Inited = TRUE;
737 #if !defined (MSOS_TYPE_NOS) && !defined (MCU_AEON) && !defined (MSOS_TYPE_OPTEE)
738
739 //Isr event
740 _s32CIPHEREventId = MsOS_CreateEventGroup("CIPHER_Event");
741 if (_s32CIPHEREventId < 0)
742 {
743 DEBUG_CIPHER(CIPHER_DBG_ERR, "_s32CIPHEREventId < 0 ");
744 _u32LastErr = DRV_CIPHER_FAIL;
745 return _u32LastErr;
746 }
747
748 //Task stack
749 _pCIPHERTaskStack = _u8CIPHER_StackBuffer;
750
751 //Isr Task
752 _s32CIPHERTaskId = MsOS_CreateTask((TaskEntry)_CIPHER_Isr_Proc,
753 0,
754 E_TASK_PRI_SYS,
755 TRUE,
756 _pCIPHERTaskStack,
757 CIPHER_TASK_STACK_SIZE,
758 "CIPHER_Task");
759
760 if (_s32CIPHERTaskId < 0)
761 {
762 DEBUG_CIPHER(CIPHER_DBG_ERR, "_s32CIPHERTaskId < 0 ");
763 MsOS_DeleteEventGroup(_s32CIPHEREventId);
764 _u32LastErr = DRV_CIPHER_FAIL;
765 return _u32LastErr;
766 }
767
768 HAL_CIPHER_IntEnable();
769
770 CIPHERIntDisable();
771 CIPHERIntDetach();
772 CIPHERIntAttach();
773 CIPHERIntEnable();
774
775 #endif
776
777 return DRV_CIPHER_OK;
778 }
779
_MDrv_CIPHER_Init(void)780 DRV_CIPHER_RET _MDrv_CIPHER_Init(void)
781 {
782 return _MDrv_CIPHER_InitBySWFlag(FALSE);
783 }
784
MDrv_CIPHER_Init(void)785 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_Init(void)
786 {
787 #if CIPHER_UTOPIA2
788 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
789
790 if(pu32CipherInst == NULL)
791 {
792 if(UTOPIA_STATUS_FAIL == UtopiaOpen(MODULE_CIPHER, &pu32CipherInst, 0x0, NULL))
793 {
794 DEBUG_CIPHER(CIPHER_DBG_ERR, "UtopiaOpen CIPHER fail\n");
795 return DRV_CIPHER_FAIL;
796 }
797 }
798
799 u32Ret = UtopiaIoctl(pu32CipherInst, E_MDRV_CMD_CIPHER_Init, NULL);
800 if(UTOPIA_STATUS_SUCCESS != u32Ret)
801 {
802 DEBUG_CIPHER(CIPHER_DBG_ERR, "[%s]ERROR : UtopiaIoctl return value 0x%x\n", __FUNCTION__, (unsigned int)u32Ret);
803 return DRV_CIPHER_FAIL;
804 }
805
806 return DRV_CIPHER_OK;
807 #else
808 return _MDrv_CIPHER_Init();
809 #endif
810 }
811
_MDrv_CIPHER_Reset(void)812 DRV_CIPHER_RET _MDrv_CIPHER_Reset(void)
813 {
814 MS_U32 i = 0;
815 DRV_CIPHER_INIT_CHECK(DRV_CIPHER_FAIL);
816
817 MsOS_ObtainMutex(_CipherMtx, MSOS_WAIT_FOREVER);
818
819 HAL_CIPHER_ResetStatus(TRUE, TRUE);
820 HAL_CIPHER_SWReset();
821 HAL_CIPHER_ResetException();
822
823 _u16ThreadID = 1;
824 _u32CallbackID = 1;
825
826 for(i=0;i<CIPHER_REPORT_BUFFER_MAX;i++)
827 {
828 _CIPHER_ReportBuffer[i].u32Report = 0;
829 _CIPHER_ReportBuffer[i].u32DoneBytes = 0;
830 _CIPHER_ReportBuffer[i].u32ExcMsg = 0;
831 _CIPHER_ReportBuffer[i].pu8Digest_Buf = NULL;
832 _CIPHER_ReportBuffer[i].u32Digest_Buf_Size = 0;
833 _CIPHER_ReportBuffer[i].pfCallback = NULL;
834 _CIPHER_ReportBuffer[i].eKeySrc = 0;
835 _CIPHER_ReportBuffer[i].u8KeyIdx = 0;
836 _CIPHER_ReportBuffer[i].bUsed = FALSE;
837 }
838
839 if(TRUE == _bCIPHERDrv_KeyCtrlEn)
840 {
841 for(i = 0;i < HAL_CRYPTODMA_DMA_KEY_SLOT;i++)
842 {
843 memset(&_CIPHER_Resource[i], 0, sizeof(CIPHER_RESOURCE));
844 }
845
846 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_INFO, "INFO:Reset Key Ctrl!\n");
847 }
848
849 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Cipher Reset!\n");
850
851 MsOS_ReleaseMutex(_CipherMtx);
852
853 return DRV_CIPHER_OK;
854 }
855
MDrv_CIPHER_Reset(void)856 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_Reset(void)
857 {
858 #if CIPHER_UTOPIA2
859 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
860
861 if(pu32CipherInst == NULL)
862 {
863 return DRV_CIPHER_FAIL;
864 }
865
866 u32Ret = UtopiaIoctl(pu32CipherInst, E_MDRV_CMD_CIPHER_Reset, NULL);
867 if(UTOPIA_STATUS_SUCCESS != u32Ret)
868 {
869 DEBUG_CIPHER(CIPHER_DBG_ERR, "[%s]ERROR : UtopiaIoctl return value 0x%x\n", __FUNCTION__, (unsigned int)u32Ret);
870 return DRV_CIPHER_FAIL;
871 }
872
873 return DRV_CIPHER_OK;
874 #else
875 return _MDrv_CIPHER_Reset();
876 #endif
877 }
878
_MDrv_CIPHER_ResetKey(MS_U32 u32CAVid,MS_U32 u32KeyIdx)879 DRV_CIPHER_RET _MDrv_CIPHER_ResetKey(MS_U32 u32CAVid, MS_U32 u32KeyIdx)
880 {
881 DRV_CIPHER_RET ret = DRV_CIPHER_OK;
882 DRV_CIPHER_ALGO algo = {0};
883 MS_U32 u32Ret = 0;
884 MS_U32 u32WaitCnt = 0;
885
886 DRV_CIPHER_INIT_CHECK(DRV_CIPHER_FAIL);
887
888 MsOS_ObtainSemaphore(_CipherSemaphore, MSOS_WAIT_FOREVER);
889 MsOS_ObtainMutex(_CipherMtx, MSOS_WAIT_FOREVER);
890
891 HAL_CIPHER_ResetStatus(TRUE , FALSE );
892
893 if(FALSE == HAL_CIPHER_DMA_Set_CaVid(u32CAVid))
894 {
895 ret = DRV_CIPHER_BAD_PARAM;
896 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set CAVid [0x%x]fail!", (unsigned int)u32CAVid);
897 goto RESETKEY_FINISH;
898 }
899
900 HAL_CIPHER_DMA_Set_Algo(algo);
901
902 if(FALSE == HAL_CIPHER_ResetKey(u32KeyIdx))
903 {
904 ret = DRV_CIPHER_BAD_PARAM;
905 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Reset Key Index fail!");
906 goto RESETKEY_FINISH;
907 }
908
909 HAL_CIPHER_DMA_Set_InputSrcFrom(E_CIPHER_DIRECT, NULL, 0);
910 HAL_CIPHER_DMA_Set_OutputDstTo(E_CIPHER_DIRECT, NULL, 0);
911 HAL_CIPHER_DMA_Set_FileinDesc ( 0, HAL_CRYPTODMA_DIRDATA_MAX);
912 HAL_CIPHER_DMA_Set_FileoutDesc( 0, (HAL_CRYPTODMA_DIRDATA_MAX - 1));
913
914 if(FALSE == HAL_CIPHER_DMA_Start(FALSE, E_DMA_INT_NONE, TRUE, 0))
915 {
916 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Reset Key fail!\n");
917 ret = DRV_CIPHER_FAIL;
918 goto RESETKEY_FINISH;
919 }
920
921 //Check register report
922 while((FALSE == HAL_CIPHER_DMA_CmdDone(0, &u32Ret)) && (u32WaitCnt < HAL_CIPHER_RESETKEY_TIMEOUT_VALUE))
923 {
924 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning:Reset Key NOT done!");
925 u32WaitCnt++;
926 }
927
928 if(u32WaitCnt >= HAL_CIPHER_RESETKEY_TIMEOUT_VALUE)
929 {
930 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning:Reset Key timeout!");
931 ret = DRV_CIPHER_FAIL;
932 goto RESETKEY_FINISH;
933 }
934
935 if(u32Ret != 0)
936 {
937 //Ignore exception here, HW still clear session key
938 HAL_CIPHER_ResetException();
939 }
940
941 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Cipher Reset Key success!\n");
942
943 RESETKEY_FINISH:
944
945 MsOS_ReleaseMutex(_CipherMtx);
946
947 MsOS_ReleaseSemaphore(_CipherSemaphore);
948
949
950 return ret;
951 }
952
MDrv_CIPHER_ResetKey(MS_U32 u32CAVid,MS_U32 u32KeyIdx)953 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_ResetKey(MS_U32 u32CAVid, MS_U32 u32KeyIdx)
954 {
955 #if CIPHER_UTOPIA2
956 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
957 CIPHER_RESETKEY pArgs;
958 memset(&pArgs, 0, sizeof(CIPHER_RESETKEY));
959
960 if(pu32CipherInst == NULL)
961 {
962 return DRV_CIPHER_FAIL;
963 }
964
965 pArgs.u32CAVid = u32CAVid;
966 pArgs.u32KeyIdx = u32KeyIdx;
967 pArgs.ret = DRV_CIPHER_OK;
968
969 u32Ret = UtopiaIoctl(pu32CipherInst, E_MDRV_CMD_CIPHER_ResetKey, (void*)&pArgs);
970 if(UTOPIA_STATUS_SUCCESS != u32Ret)
971 {
972 DEBUG_CIPHER(CIPHER_DBG_ERR, "[%s]ERROR : UtopiaIoctl return value 0x%x\n", __FUNCTION__, (unsigned int)u32Ret);
973 return DRV_CIPHER_FAIL;
974 }
975
976 return pArgs.ret;
977 #else
978 return _MDrv_CIPHER_ResetKey(u32CAVid, u32KeyIdx);
979 #endif
980 }
981
_MDrv_CIPHER_SetDbgLevel(CIPHER_DBGMSG_LEVEL eDBGMsgLevel)982 DRV_CIPHER_RET _MDrv_CIPHER_SetDbgLevel(CIPHER_DBGMSG_LEVEL eDBGMsgLevel)
983 {
984 _CIPHERDBGLevel = eDBGMsgLevel;
985 HAL_CIPHER_SetDbgLevel(eDBGMsgLevel);
986
987 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set Debug level[%d]!", eDBGMsgLevel);
988
989 return DRV_CIPHER_OK;
990 }
991
MDrv_CIPHER_SetDbgLevel(CIPHER_DBGMSG_LEVEL eDBGMsgLevel)992 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_SetDbgLevel(CIPHER_DBGMSG_LEVEL eDBGMsgLevel)
993 {
994 #if CIPHER_UTOPIA2
995 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
996 CIPHER_DBGLEVEL pArgs;
997 memset(&pArgs, 0, sizeof(CIPHER_DBGLEVEL));
998
999 if(pu32CipherInst == NULL)
1000 {
1001 return DRV_CIPHER_FAIL;
1002 }
1003
1004 pArgs.eDBGMsgLevel = eDBGMsgLevel;
1005
1006 u32Ret = UtopiaIoctl(pu32CipherInst, E_MDRV_CMD_CIPHER_DbgLevel, (void*)&pArgs);
1007 if(UTOPIA_STATUS_SUCCESS != u32Ret)
1008 {
1009 DEBUG_CIPHER(CIPHER_DBG_ERR, "[%s]ERROR : UtopiaIoctl return value 0x%x\n", __FUNCTION__, (unsigned int)u32Ret);
1010 return DRV_CIPHER_FAIL;
1011 }
1012
1013 return DRV_CIPHER_OK;
1014 #else
1015 return _MDrv_CIPHER_SetDbgLevel(eDBGMsgLevel);
1016 #endif
1017 }
1018
MDrv_CIPHER_GetLibVer(const MSIF_Version ** ppVersion)1019 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_GetLibVer(const MSIF_Version **ppVersion)
1020 {
1021 if (!ppVersion)
1022 {
1023 return DRV_CIPHER_FAIL;
1024 }
1025
1026 *ppVersion = &_drv_cipher_version;
1027
1028 return DRV_CIPHER_OK;
1029 }
1030
_MDrv_CIPHER_DMACalc(DRV_CIPHER_DMACFG stCfg,MS_U32 * pu32CmdId)1031 DRV_CIPHER_RET _MDrv_CIPHER_DMACalc(DRV_CIPHER_DMACFG stCfg, MS_U32 *pu32CmdId)
1032 {
1033 DRV_CIPHER_RET ret = DRV_CIPHER_OK;
1034 HAL_CIPHER_INTMODE eIntMode = E_DMA_INT_NONE;
1035 MS_U8 u8BufNum = 0;
1036
1037 DRV_CIPHER_INIT_CHECK(DRV_CIPHER_FAIL);
1038
1039 if(TRUE == _bCIPHERDrv_KeyCtrlEn)
1040 {
1041 if(HAL_CRYPTODMA_DMA_KEY_SLOT <= stCfg.stKey.u8KeyIdx)
1042 {
1043 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_ERR, "Error:Invalid Key Index!");
1044 return DRV_CIPHER_BAD_PARAM;
1045 }
1046
1047 if(E_CIPHER_KSRC_KL == stCfg.stKey.eKeySrc && FALSE == _CIPHER_Resource[stCfg.stKey.u8KeyIdx % HAL_CRYPTODMA_DMA_KEY_SLOT].bUsed)
1048 {
1049 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_ERR, "Error:Not used Cipher Id[%u]!", stCfg.stKey.u8KeyIdx);
1050 return DRV_CIPHER_BAD_PARAM;
1051 }
1052 }
1053
1054 //Check data size
1055 if((stCfg.stInput.u32Size == 0) || (stCfg.stOutput.u32Size == 0))
1056 {
1057 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:DMA data size is zero!");
1058 return DRV_CIPHER_BAD_PARAM;
1059 }
1060
1061 //Check Key length
1062 if((stCfg.stKey.u8KeyLen > HAL_CRYPTODMA_KEYLEN_MAX) || (stCfg.stKey.u8IVLen > HAL_CRYPTODMA_KEYLEN_MAX))
1063 {
1064 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Invalid Key length!\n");
1065 return DRV_CIPHER_BAD_PARAM;
1066 }
1067
1068 if(pu32CmdId == NULL)
1069 {
1070 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:DMA CmdId is NULL!");
1071 return DRV_CIPHER_BAD_PARAM;
1072 }
1073
1074 MsOS_FlushMemory();
1075
1076 //==============Obtain Semaphore==============
1077 MsOS_ObtainSemaphore(_CipherSemaphore, MSOS_WAIT_FOREVER);
1078
1079 MsOS_ObtainMutex(_CipherMtx, MSOS_WAIT_FOREVER);
1080
1081 HAL_CIPHER_ResetStatus(TRUE , FALSE ) ;
1082
1083 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set CAVid [0x%x]", (unsigned int)stCfg.u32CAVid);
1084
1085 if(FALSE == HAL_CIPHER_DMA_Set_CaVid(stCfg.u32CAVid))
1086 {
1087 ret = DRV_CIPHER_BAD_PARAM;
1088 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set CAVid [0x%x]fail!", (unsigned int)stCfg.u32CAVid);
1089 goto DMA_FINISH;
1090 }
1091
1092 HAL_CIPHER_DMA_Set_Algo( stCfg.stAlgo);
1093
1094 if(FALSE == HAL_CIPHER_DMA_Set_Key(stCfg.stKey))
1095 {
1096 ret = DRV_CIPHER_BAD_PARAM;
1097 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set Key fail!");
1098 goto DMA_FINISH;
1099 }
1100
1101 HAL_CIPHER_DMA_Set_IV(stCfg.stKey.pu8IVData, stCfg.stKey.u8IVLen);
1102
1103 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set algorithm: MAIN[%d], SUB[%d], RES[%d], SB[%d]",
1104 stCfg.stAlgo.eMainAlgo, stCfg.stAlgo.eSubAlgo, stCfg.stAlgo.eResAlgo, stCfg.stAlgo.eSBAlgo);
1105
1106 // need to call DMA_Set_InputSrcFrom and DMA_Set_OutputDstTo
1107 // before call DMA_Set_FileinDesc and DMA_Set_FileoutDesc
1108 HAL_CIPHER_DMA_Set_InputSrcFrom(stCfg.stInput.eMemoryType, NULL, 0);
1109 if(FALSE == HAL_CIPHER_DMA_Set_OutputDstTo(stCfg.stOutput.eMemoryType, NULL, 0))
1110 {
1111 ret = DRV_CIPHER_BAD_PARAM;
1112 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set Output destination fail!");
1113 goto DMA_FINISH;
1114 }
1115
1116 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set Input source from [%d], Output destination to [%d]",
1117 stCfg.stInput.eMemoryType, stCfg.stOutput.eMemoryType);
1118
1119 // Set File-in Addr //
1120 HAL_CIPHER_DMA_Set_FileinDesc ( stCfg.stInput.u32Addr, stCfg.stInput.u32Size);
1121 HAL_CIPHER_DMA_Set_FileoutDesc( stCfg.stOutput.u32Addr, stCfg.stOutput.u32Addr + stCfg.stOutput.u32Size - 1);
1122
1123 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set Input address [0x%08x], size[%u], Output address [0x%08x], size[%u]",
1124 (unsigned int)stCfg.stInput.u32Addr, stCfg.stInput.u32Size, (unsigned int)stCfg.stOutput.u32Addr, stCfg.stOutput.u32Size);
1125
1126 //Check report buffer
1127 u8BufNum = (MS_U8)(_u16ThreadID % (MS_U16)CIPHER_REPORT_BUFFER_MAX);
1128
1129 //Report buffer already used
1130 if(_CIPHER_ReportBuffer[u8BufNum].bUsed == TRUE)
1131 {
1132 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning:CIPHER report buffer is used!");
1133 ret = DRV_CIPHER_NO_REPORT_BUFFER;
1134 goto DMA_FINISH;
1135 }
1136
1137 _CIPHER_ReportBuffer[u8BufNum].u32Report = 0;
1138 _CIPHER_ReportBuffer[u8BufNum].u32DoneBytes = 0;
1139 _CIPHER_ReportBuffer[u8BufNum].bUsed = TRUE;
1140
1141
1142 #if !defined (MSOS_TYPE_NOS) && !defined (MCU_AEON) && !defined (MSOS_TYPE_OPTEE)
1143
1144 _eCipherWait = E_CIPHER_DMA_DONE;
1145
1146 if(stCfg.pfCallback != NULL)
1147 {
1148 _CIPHER_ReportBuffer[u8BufNum].pfCallback = stCfg.pfCallback;
1149 eIntMode = E_DMA_INT_ENABLE;
1150 }
1151 #endif
1152 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:DMA decrypt operation[%d]", stCfg.bDecrypt);
1153
1154 if(FALSE == HAL_CIPHER_DMA_Start(stCfg.bDecrypt, eIntMode , TRUE , _u16ThreadID))
1155 {
1156 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:DMA Fail!\n");
1157 ret = DRV_CIPHER_FAIL;
1158 goto DMA_FINISH;
1159 }
1160
1161 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:IntMode[%d], CmdId[%hu]", eIntMode, _u16ThreadID);
1162
1163 *pu32CmdId = (MS_U32)_u16ThreadID;
1164
1165 //Check thread id max
1166 if(_u16ThreadID == HAL_CRYPTODMA_THREAD_ID_MAX)
1167 {
1168 _u16ThreadID = 1;
1169 }
1170 else
1171 {
1172 _u16ThreadID++;
1173 }
1174
1175 DMA_FINISH:
1176
1177 MsOS_ReleaseMutex(_CipherMtx);
1178
1179 if(ret != DRV_CIPHER_OK)
1180 {
1181 MsOS_ReleaseSemaphore(_CipherSemaphore);
1182 }
1183
1184 return ret;
1185 }
1186
MDrv_CIPHER_DMACalc(DRV_CIPHER_DMACFG stCfg,MS_U32 * pu32CmdId)1187 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_DMACalc(DRV_CIPHER_DMACFG stCfg, MS_U32 *pu32CmdId)
1188 {
1189 #if CIPHER_UTOPIA2
1190 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
1191 CIPHER_DMACALC pArgs;
1192 memset(&pArgs, 0, sizeof(CIPHER_DMACALC));
1193
1194 if(pu32CipherInst == NULL)
1195 {
1196 return DRV_CIPHER_FAIL;
1197 }
1198
1199 memcpy(&pArgs.stCfg, &stCfg, sizeof(DRV_CIPHER_DMACFG));
1200 pArgs.pu32CmdId = pu32CmdId;
1201 pArgs.ret = DRV_CIPHER_OK;
1202
1203 u32Ret = UtopiaIoctl(pu32CipherInst, E_MDRV_CMD_CIPHER_DMACalc, (void*)&pArgs);
1204 if(UTOPIA_STATUS_SUCCESS != u32Ret)
1205 {
1206 DEBUG_CIPHER(CIPHER_DBG_ERR, "[%s]ERROR : UtopiaIoctl return value 0x%x\n", __FUNCTION__, (unsigned int)u32Ret);
1207 return DRV_CIPHER_FAIL;
1208 }
1209
1210 return pArgs.ret;
1211 #else
1212 return _MDrv_CIPHER_DMACalc(stCfg, pu32CmdId);
1213 #endif
1214 }
1215
MDrv_CIPHER_OTPHASHCalc(DRV_CIPHER_DMACFG stCfg,MS_U32 * pu32CmdId)1216 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_OTPHASHCalc(DRV_CIPHER_DMACFG stCfg, MS_U32 *pu32CmdId)
1217 {
1218 DRV_CIPHER_RET ret = DRV_CIPHER_OK;
1219 HAL_CIPHER_INTMODE eIntMode = E_DMA_INT_NONE;
1220 MS_U8 u8BufNum = 0;
1221 MS_U32 u32OTPHashRound = 0;
1222 MS_U32 u32CurrentRound = 0;
1223
1224 DRV_CIPHER_INIT_CHECK(DRV_CIPHER_FAIL);
1225
1226 // Check data size
1227 if((stCfg.stInput.u32Size == 0) || (stCfg.stOutput.u32Size == 0))
1228 {
1229 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:DMA data size is zero!");
1230 return DRV_CIPHER_BAD_PARAM;
1231 }
1232
1233 // Check CmdId
1234 if(pu32CmdId == NULL)
1235 {
1236 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:DMA CmdId is NULL!");
1237 return DRV_CIPHER_BAD_PARAM;
1238 }
1239 MsOS_FlushMemory();
1240
1241 //==============Obtain Semaphore==============
1242 MsOS_ObtainSemaphore(_CipherSemaphore, MSOS_WAIT_FOREVER);
1243
1244 MsOS_ObtainMutex(_CipherMtx, MSOS_WAIT_FOREVER);
1245
1246 HAL_CIPHER_ResetStatus(TRUE , FALSE ) ;
1247
1248 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set CAVid [0x%x]", (unsigned int)stCfg.u32CAVid);
1249
1250 if(FALSE == HAL_CIPHER_DMA_Set_CaVid(stCfg.u32CAVid))
1251 {
1252 ret = DRV_CIPHER_BAD_PARAM;
1253 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set CAVid [0x%x]fail!", (unsigned int)stCfg.u32CAVid);
1254 goto DMA_FINISH;
1255 }
1256
1257 // Set Algorithm
1258 HAL_CIPHER_DMA_Set_Algo( stCfg.stAlgo);
1259
1260 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set algorithm: MAIN[%d], SUB[%d], RES[%d], SB[%d]",
1261 stCfg.stAlgo.eMainAlgo, stCfg.stAlgo.eSubAlgo, stCfg.stAlgo.eResAlgo, stCfg.stAlgo.eSBAlgo);
1262
1263 // need to call DMA_Set_InputSrcFrom and DMA_Set_OutputDstTo
1264 // before call DMA_Set_FileinDesc and DMA_Set_FileoutDesc
1265 HAL_CIPHER_DMA_Set_InputSrcFrom(stCfg.stInput.eMemoryType, NULL, 0);
1266 HAL_CIPHER_DMA_Set_OutputDstTo(stCfg.stOutput.eMemoryType, NULL, 0);
1267
1268 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set Input source from [%d], Output destination to [%d]",
1269 stCfg.stInput.eMemoryType, stCfg.stOutput.eMemoryType);
1270
1271 // Not suppoet OTPHash (size low than 32 bytes)
1272 if(stCfg.stInput.u32Size < HAL_CRYPTODMA_OTPHASH_SIZE_MIN)
1273 {
1274 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:OTPHASH input size error!");
1275 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:OTPHASH support input size should lagger than %lu bytes!", HAL_CRYPTODMA_OTPHASH_SIZE_MIN);
1276 return DRV_CIPHER_BAD_PARAM;
1277 }
1278
1279 // Check OTPHash round
1280 while(1)
1281 {
1282 if(stCfg.stInput.u32Size <= (u32OTPHashRound+1)*HAL_CRYPTODMA_OTPHASH_UNIT)
1283 {
1284 break;
1285 }
1286 else
1287 {
1288 u32OTPHashRound++;
1289 }
1290 }
1291
1292 // Set File-out Addr //
1293 HAL_CIPHER_DMA_Set_FileoutDesc( stCfg.stOutput.u32Addr, stCfg.stOutput.u32Addr + stCfg.stOutput.u32Size - 1);
1294
1295 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set Output address [0x%08x], size[%u]",
1296 (unsigned int)stCfg.stOutput.u32Addr, stCfg.stOutput.u32Size);
1297
1298 //Check report buffer
1299 u8BufNum = (MS_U8)(_u16ThreadID % (MS_U16)CIPHER_REPORT_BUFFER_MAX);
1300
1301 //Report buffer already used
1302 if(_CIPHER_ReportBuffer[u8BufNum].bUsed == TRUE)
1303 {
1304 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning:CIPHER report buffer is used!");
1305 ret = DRV_CIPHER_NO_REPORT_BUFFER;
1306 goto DMA_FINISH;
1307 }
1308
1309 _CIPHER_ReportBuffer[u8BufNum].u32Report = 0;
1310 _CIPHER_ReportBuffer[u8BufNum].u32DoneBytes = 0;
1311 _CIPHER_ReportBuffer[u8BufNum].bUsed = TRUE;
1312
1313
1314 #if !defined (MSOS_TYPE_NOS) && !defined (MCU_AEON) && !defined (MSOS_TYPE_OPTEE)
1315
1316 _eCipherWait = E_CIPHER_DMA_DONE;
1317
1318 if(stCfg.pfCallback != NULL)
1319 {
1320 _CIPHER_ReportBuffer[u8BufNum].pfCallback = stCfg.pfCallback;
1321 eIntMode = E_DMA_INT_ENABLE;
1322 }
1323 #endif
1324
1325 // Start OTPHash
1326 for(u32CurrentRound=0; u32CurrentRound<=u32OTPHashRound; u32CurrentRound++)
1327 {
1328 // Set OTPHash configuration //
1329 HAL_CIPHER_DMA_Set_OTPHash( u32CurrentRound, u32OTPHashRound);
1330
1331 // Set OTPHash File-in Addr //
1332 HAL_CIPHER_OTPHash_Set_FileinDesc( stCfg.stInput.u32Addr, stCfg.stInput.u32Size, u32CurrentRound, stCfg.stInput.eMemoryType);
1333
1334 if(FALSE == HAL_CIPHER_OTPHash_Start(eIntMode , TRUE , _u16ThreadID))
1335 {
1336 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:DMA Fail!\n");
1337 ret = DRV_CIPHER_FAIL;
1338 goto DMA_FINISH;
1339 }
1340
1341 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:IntMode[%d], CmdId[%hu]", eIntMode, _u16ThreadID);
1342
1343 *pu32CmdId = (MS_U32)_u16ThreadID;
1344
1345 //Check thread id max
1346 if(_u16ThreadID == HAL_CRYPTODMA_THREAD_ID_MAX)
1347 {
1348 _u16ThreadID = 1;
1349 }
1350 else
1351 {
1352 _u16ThreadID++;
1353 }
1354 }
1355
1356 DMA_FINISH:
1357
1358 MsOS_ReleaseMutex(_CipherMtx);
1359
1360 if(ret != DRV_CIPHER_OK)
1361 {
1362 MsOS_ReleaseSemaphore(_CipherSemaphore);
1363 }
1364
1365 return ret;
1366
1367 }
1368
_MDrv_CIPHER_HASH(DRV_CIPHER_HASHCFG stCfg,MS_U32 * pu32CmdId)1369 DRV_CIPHER_RET _MDrv_CIPHER_HASH(DRV_CIPHER_HASHCFG stCfg, MS_U32 *pu32CmdId)
1370 {
1371 DRV_CIPHER_RET ret = DRV_CIPHER_OK;
1372 HAL_CIPHER_INTMODE eIntMode = E_DMA_INT_NONE;
1373 MS_U32 u32OutLen = 32;
1374 MS_U32 u32HashSrc = 0;
1375 MS_U32 u32HashDst = 0;
1376 MS_U8 u8BufNum = 0;
1377
1378 DRV_CIPHER_INIT_CHECK(DRV_CIPHER_FAIL);
1379
1380 //==============Obtain Semaphore==============
1381 MsOS_ObtainSemaphore(_CipherSemaphore, MSOS_WAIT_FOREVER);
1382
1383 MsOS_ObtainMutex(_CipherMtx, MSOS_WAIT_FOREVER);
1384
1385 //Check data size
1386 if((stCfg.stInput.u32Size == 0) || (stCfg.u32Digest_Buf_Size == 0))
1387 {
1388 ret = DRV_CIPHER_BAD_PARAM;
1389 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:HASH data size is zero!");
1390 goto HASHAUTO_FINISH;
1391 }
1392
1393 if(pu32CmdId == NULL)
1394 {
1395 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:HASH CmdId is NULL!");
1396 ret = DRV_CIPHER_BAD_PARAM;
1397 goto HASHAUTO_FINISH;
1398 }
1399
1400 if(stCfg.eAlgo == E_CIPHER_HASH_ALGO_SHA1) u32OutLen = HASH_SHA1_DIGEST_SIZE; //160 bits
1401 else if(stCfg.eAlgo == E_CIPHER_HASH_ALGO_SHA256) u32OutLen = HASH_SHA256_DIGEST_SIZE; //256 bits
1402 else if(stCfg.eAlgo == E_CIPHER_HASH_ALGO_MD5) u32OutLen = HASH_MD5_DIGEST_SIZE; //128 bits
1403 else if(stCfg.eAlgo == E_CIPHER_HASH_ALGO_SM3) u32OutLen = HASH_SM3_DIGEST_SIZE; //256 bits
1404 else u32OutLen = HASH_SHA256_DIGEST_SIZE;
1405
1406 if(stCfg.u32Digest_Buf_Size != u32OutLen)
1407 {
1408 ret = DRV_CIPHER_BAD_PARAM;
1409 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Wrong buffer size[%u]!", stCfg.u32Digest_Buf_Size);
1410 goto HASHAUTO_FINISH;
1411 }
1412
1413 //Reset all
1414 HAL_CIPHER_ResetStatus(FALSE , TRUE);
1415
1416 //Set CAVid
1417 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set CAVid [0x%x]\n", (unsigned int)stCfg.u32CAVid);
1418
1419 if(FALSE == HAL_CIPHER_Hash_Set_CaVid(stCfg.u32CAVid))
1420 {
1421 ret = DRV_CIPHER_BAD_PARAM;
1422 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set CAVid [0x%x]fail!", (unsigned int)stCfg.u32CAVid);
1423 goto HASHAUTO_FINISH;
1424 }
1425
1426 //Set Algo
1427 HAL_CIPHER_Hash_Set_Config(stCfg.eAlgo, TRUE, FALSE );
1428
1429 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set Algorithm [%d]", stCfg.eAlgo);
1430
1431 //Set IV to FIPS
1432 if(FALSE == HAL_CIPHER_Hash_Set_IV(NULL, 0 , CMD_HASH_IV_FIPS))
1433 {
1434 ret = DRV_CIPHER_BAD_PARAM;
1435 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set HASH IV fail!");
1436 goto HASHAUTO_FINISH;
1437 }
1438
1439 if(FALSE == HAL_CIPHER_Hash_Set_InitWordCnt(E_CIPHER_HASH_IWC_MANUAL, 0))
1440 {
1441 ret = DRV_CIPHER_BAD_PARAM;
1442 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set init word count fail!");
1443 goto HASHAUTO_FINISH;
1444 }
1445
1446 //Set Hash message source
1447 if(FALSE == HAL_CIPHER_Hash_Set_MsgSrcFrom(stCfg.stInput.eMemoryType, &u32HashSrc))
1448 {
1449 ret = DRV_CIPHER_BAD_PARAM;
1450 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Set source memory type [%d] fail", stCfg.stInput.eMemoryType);
1451 goto HASHAUTO_FINISH;
1452 }
1453
1454 //Set input message address
1455 if(FALSE == HAL_CIPHER_Hash_SetMsg(stCfg.stInput.u32Addr, stCfg.stInput.u32Size, u32HashSrc))
1456 {
1457 ret = DRV_CIPHER_BAD_PARAM;
1458 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Input address[0x%08x], size[%u]",
1459 (unsigned int)stCfg.stInput.u32Addr, stCfg.stInput.u32Size);
1460 goto HASHAUTO_FINISH;
1461 }
1462
1463 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO;Set Input address[0x%08x], size[%u]",
1464 (unsigned int)stCfg.stInput.u32Addr, stCfg.stInput.u32Size);
1465
1466 //Set output destination
1467 if(FALSE == HAL_CIPHER_Hash_Set_OutputDstTo(E_CIPHER_DIRECT, &u32HashDst))
1468 {
1469 ret = DRV_CIPHER_BAD_PARAM;
1470 goto HASHAUTO_FINISH;
1471 }
1472
1473 #if 0 //Default output to Register
1474 //Set output address
1475 if(FALSE == HAL_CIPHER_Hash_Set_OuputAddr(MsOS_VA2PA((MS_U32)stCfg.pu8Digest_Buf), u32HashDst))
1476 {
1477 ret = DRV_CIPHER_FAIL;
1478 goto HASHAUTO_FINISH;
1479 }
1480 #endif
1481
1482 //Set HOS = 1 , Output will be MSB First
1483 HAL_CIPHER_Hash_SetHOS(TRUE);
1484
1485 u8BufNum = (MS_U8)(_u16ThreadID % (MS_U16)CIPHER_REPORT_BUFFER_MAX);
1486
1487 //Report buffer already used
1488 if(_CIPHER_ReportBuffer[u8BufNum].bUsed == TRUE)
1489 {
1490 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning:CIPHER report buffer is used!");
1491 ret = DRV_CIPHER_NO_REPORT_BUFFER;
1492 goto HASHAUTO_FINISH;
1493 }
1494
1495 _CIPHER_ReportBuffer[u8BufNum].u32Report = 0;
1496 _CIPHER_ReportBuffer[u8BufNum].u32DoneBytes = 0;
1497 _CIPHER_ReportBuffer[u8BufNum].pu8Digest_Buf = stCfg.pu8Digest_Buf;
1498 _CIPHER_ReportBuffer[u8BufNum].u32Digest_Buf_Size = stCfg.u32Digest_Buf_Size;
1499 _CIPHER_ReportBuffer[u8BufNum].bUsed = TRUE;
1500
1501 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Digest buffer address[0x%08lx], buffer size[%u]",
1502 (long unsigned int)stCfg.pu8Digest_Buf,
1503 stCfg.u32Digest_Buf_Size);
1504
1505 #if !defined (MSOS_TYPE_NOS) && !defined (MCU_AEON) && !defined (MSOS_TYPE_OPTEE)
1506
1507 _eCipherWait = E_CIPHER_HASH_DONE;
1508
1509 if(stCfg.pfCallback != NULL)
1510 {
1511 _CIPHER_ReportBuffer[u8BufNum].pfCallback = stCfg.pfCallback;
1512 eIntMode = E_DMA_INT_ENABLE;
1513 }
1514 #endif
1515 MsOS_FlushMemory();
1516
1517 //Start hash
1518 if(FALSE == HAL_CIPHER_Hash_Start(eIntMode , TRUE, FALSE, _u16ThreadID))
1519 {
1520 ret = DRV_CIPHER_FAIL;
1521 goto HASHAUTO_FINISH;
1522 }
1523
1524 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:IntMode[%d], CmdId[%hu]", eIntMode, _u16ThreadID);
1525
1526 *pu32CmdId = (MS_U32)_u16ThreadID;
1527
1528 //Check thread id max
1529 if(_u16ThreadID == HAL_CRYPTODMA_THREAD_ID_MAX)
1530 {
1531 _u16ThreadID = 1;
1532 }
1533 else
1534 {
1535 _u16ThreadID++;
1536 }
1537
1538 HASHAUTO_FINISH:
1539
1540 MsOS_ReleaseMutex(_CipherMtx);
1541
1542 if(ret != DRV_CIPHER_OK)
1543 {
1544 MsOS_ReleaseSemaphore(_CipherSemaphore);
1545 }
1546
1547 return ret;
1548 }
1549
MDrv_CIPHER_HASH(DRV_CIPHER_HASHCFG stCfg,MS_U32 * pu32CmdId)1550 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_HASH(DRV_CIPHER_HASHCFG stCfg, MS_U32 *pu32CmdId)
1551 {
1552 #if CIPHER_UTOPIA2
1553 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
1554 CIPHER_HASHCALC pArgs;
1555 memset(&pArgs, 0, sizeof(CIPHER_HASHCALC));
1556
1557 if(pu32CipherInst == NULL)
1558 {
1559 return DRV_CIPHER_FAIL;
1560 }
1561
1562 memcpy(&pArgs.stCfg, &stCfg, sizeof(DRV_CIPHER_HASHCFG));
1563 pArgs.pu32CmdId = pu32CmdId;
1564 pArgs.ret = DRV_CIPHER_OK;
1565
1566 u32Ret = UtopiaIoctl(pu32CipherInst, E_MDRV_CMD_CIPHER_HASH, (void*)&pArgs);
1567 if(UTOPIA_STATUS_SUCCESS != u32Ret)
1568 {
1569 DEBUG_CIPHER(CIPHER_DBG_ERR, "[%s]ERROR : UtopiaIoctl return value 0x%x\n", __FUNCTION__, (unsigned int)u32Ret);
1570 return DRV_CIPHER_FAIL;
1571 }
1572
1573 return pArgs.ret;
1574 #else
1575 return _MDrv_CIPHER_HASH(stCfg, pu32CmdId);
1576 #endif
1577 }
1578
MDrv_CIPHER_HASHManual(DRV_CIPHER_HASHCFG_MANUAL stCfg,MS_U32 * pu32CmdId)1579 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_HASHManual(DRV_CIPHER_HASHCFG_MANUAL stCfg, MS_U32 *pu32CmdId)
1580 {
1581 DRV_CIPHER_RET ret = DRV_CIPHER_OK;
1582 HAL_CIPHER_INTMODE eIntMode = E_DMA_INT_NONE;
1583 HAL_CIPHER_IWCTYPE eIWCType = E_CIPHER_HASH_IWC_MANUAL; //Init Word Count
1584 MS_U32 u32IVSel = CMD_HASH_IV_FIPS;
1585 MS_U8* pu8IV = NULL;
1586 MS_U32 u32DataSize = 0;
1587 MS_U32 u32IVSize = 0;
1588 MS_BOOL bAutoPad = FALSE;
1589 MS_U32 u32OutLen = 32;
1590 MS_U32 u32HashSrc = 0;
1591 MS_U32 u32HashDst = 0;
1592 MS_U8 u8BufNum = 0;
1593
1594 DRV_CIPHER_INIT_CHECK(DRV_CIPHER_FAIL);
1595
1596 MsOS_FlushMemory();
1597
1598 //==============Obtain Semaphore==============
1599 MsOS_ObtainSemaphore(_CipherSemaphore, MSOS_WAIT_FOREVER);
1600
1601 MsOS_ObtainMutex(_CipherMtx, MSOS_WAIT_FOREVER);
1602
1603 //Check data size
1604 u32DataSize = stCfg.stInput.u32Size;
1605
1606 if((0 == u32DataSize) && (E_CIPHER_HASH_STAGE_LAST != stCfg.eStage))
1607 {
1608 ret = DRV_CIPHER_BAD_PARAM;
1609 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:HASH data size is [%u]!\n", u32DataSize);
1610 goto HASHMANUAL_FINISH;
1611 }
1612
1613 if(pu32CmdId == NULL)
1614 {
1615 ret = DRV_CIPHER_BAD_PARAM;
1616 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:HASH CmdId is NULL!");
1617 goto HASHMANUAL_FINISH;
1618 }
1619
1620 if(stCfg.eAlgo == E_CIPHER_HASH_ALGO_SHA1) u32OutLen = HASH_SHA1_DIGEST_SIZE; //160 bits
1621 else if(stCfg.eAlgo == E_CIPHER_HASH_ALGO_SHA256) u32OutLen = HASH_SHA256_DIGEST_SIZE; //256 bits
1622 else if(stCfg.eAlgo == E_CIPHER_HASH_ALGO_MD5) u32OutLen = HASH_MD5_DIGEST_SIZE; //128 bits
1623 else if(stCfg.eAlgo == E_CIPHER_HASH_ALGO_SM3) u32OutLen = HASH_SM3_DIGEST_SIZE; //256 bits
1624 else u32OutLen = HASH_SHA256_DIGEST_SIZE;
1625
1626 //Check buffer and size
1627 if((stCfg.pu8Digest_Buf != NULL) && (stCfg.u32Digest_Buf_Size != u32OutLen))
1628 {
1629 ret = DRV_CIPHER_BAD_PARAM;
1630 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Wrong buffer size[%u]!\n", stCfg.u32Digest_Buf_Size);
1631 goto HASHMANUAL_FINISH;
1632 }
1633
1634 //Check IV setting
1635 if(stCfg.pu8SetIV != NULL)
1636 {
1637 pu8IV = stCfg.pu8SetIV;
1638 u32IVSel = CMD_HASH_IV_CMD;
1639
1640 if(stCfg.eAlgo == E_CIPHER_HASH_ALGO_SHA1)
1641 {
1642 u32IVSize = HASH_SHA1_DIGEST_SIZE;
1643 }
1644 else if(stCfg.eAlgo == E_CIPHER_HASH_ALGO_SHA256)
1645 {
1646 u32IVSize = HASH_SHA256_DIGEST_SIZE;
1647 }
1648 else if(stCfg.eAlgo == E_CIPHER_HASH_ALGO_MD5)
1649 {
1650 u32IVSize = HASH_MD5_DIGEST_SIZE;
1651 }
1652 else if(stCfg.eAlgo == E_CIPHER_HASH_ALGO_SM3)
1653 {
1654 u32IVSize = HASH_SM3_DIGEST_SIZE;
1655 }
1656 }
1657 else
1658 {
1659 //NULL IV
1660 if(stCfg.eIVMode == E_CIPHER_HASH_IV_CMD)
1661 {
1662 ret = DRV_CIPHER_BAD_PARAM;
1663 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:NULL IV!");
1664 goto HASHMANUAL_FINISH;
1665 }
1666 }
1667
1668 //IV and IWC is from previous report
1669 if(stCfg.eIVMode == E_CIPHER_HASH_IV_PRV)
1670 {
1671 u32IVSel = CMD_HASH_IV_PRV_RPT;
1672 eIWCType = E_CIPHER_HASH_IWC_PRV;
1673 }
1674
1675 //AutoPad only works on last stage, previous stage is 64 bytes alignment
1676 if(stCfg.eStage == E_CIPHER_HASH_STAGE_LAST)
1677 {
1678 bAutoPad = TRUE;
1679 }
1680 else
1681 {
1682 if((u32DataSize % (MS_U32)HASH_BLOCK_SIZE) != 0 )
1683 {
1684 ret = DRV_CIPHER_BAD_PARAM;
1685 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:HASH block is 64 bytes alignment!");
1686 goto HASHMANUAL_FINISH;
1687 }
1688 }
1689
1690 //Reset all
1691 HAL_CIPHER_ResetStatus(FALSE , TRUE);
1692
1693 //Set CAVid
1694 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set CAVid [0x%x]", (unsigned int)stCfg.u32CAVid);
1695
1696 if(FALSE == HAL_CIPHER_Hash_Set_CaVid(stCfg.u32CAVid))
1697 {
1698 ret = DRV_CIPHER_BAD_PARAM;
1699 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set CAVid [0x%x]fail!", (unsigned int)stCfg.u32CAVid);
1700 goto HASHMANUAL_FINISH;
1701 }
1702
1703 //Set Algo
1704 HAL_CIPHER_Hash_Set_Config(stCfg.eAlgo, bAutoPad, FALSE);
1705
1706 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set Algorithm[%d], AutoPad[%d]", stCfg.eAlgo, bAutoPad);
1707
1708 //Set IV to FIPS
1709 if(FALSE == HAL_CIPHER_Hash_Set_IV(pu8IV, u32IVSize , u32IVSel))
1710 {
1711 ret = DRV_CIPHER_BAD_PARAM;
1712 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Set IV fail, IV size[%u]", u32IVSize);
1713 goto HASHMANUAL_FINISH;
1714 }
1715
1716 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set IV size[%u], IV Mode[%d]", u32IVSize, stCfg.eIVMode);
1717
1718 //Set Init Word Count
1719 if(FALSE == HAL_CIPHER_Hash_Set_InitWordCnt(eIWCType, stCfg.u32StartByte))
1720 {
1721 ret = DRV_CIPHER_BAD_PARAM;
1722 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Set IWC fail, IWC[%d], StartBytes[%u]", eIWCType, stCfg.u32StartByte);
1723 goto HASHMANUAL_FINISH;
1724 }
1725
1726 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set IWC[%d], StartBytes[%u]", eIWCType, stCfg.u32StartByte);
1727
1728 //Set HMAC Key
1729 if(FALSE == HAL_CIPHER_Hash_SetHMACKey(stCfg.stHMACKey, stCfg.eHMACKPad, FALSE))
1730 {
1731 ret = DRV_CIPHER_BAD_PARAM;
1732 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Set HMAC key fail, HMAC key source[%d], key index[%u]", stCfg.stHMACKey.eKeySrc, stCfg.stHMACKey.u8KeyIdx);
1733 goto HASHMANUAL_FINISH;
1734 }
1735
1736 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set HMAC Key Source[%d], Key Index[%u], KeyPad[%d]",
1737 stCfg.stHMACKey.eKeySrc, stCfg.stHMACKey.u8KeyIdx, stCfg.eHMACKPad);
1738
1739 //Set Hash message source
1740 if(FALSE == HAL_CIPHER_Hash_Set_MsgSrcFrom(stCfg.stInput.eMemoryType, &u32HashSrc))
1741 {
1742 ret = DRV_CIPHER_BAD_PARAM;
1743 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Set source memory type [%d] fail", stCfg.stInput.eMemoryType);
1744 goto HASHMANUAL_FINISH;
1745 }
1746
1747 //Set input message address
1748 if(FALSE == HAL_CIPHER_Hash_SetMsg(stCfg.stInput.u32Addr, stCfg.stInput.u32Size, u32HashSrc))
1749 {
1750 ret = DRV_CIPHER_BAD_PARAM;
1751 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Input address[0x%08x], size[%u]",
1752 (unsigned int)stCfg.stInput.u32Addr, stCfg.stInput.u32Size);
1753 goto HASHMANUAL_FINISH;
1754 }
1755
1756 DEBUG_CIPHER(CIPHER_DBG_INFO, "Set Input address[0x%08x], size[%u]",
1757 (unsigned int)stCfg.stInput.u32Addr, stCfg.stInput.u32Size);
1758
1759 //Set output destination
1760 if(FALSE == HAL_CIPHER_Hash_Set_OutputDstTo(E_CIPHER_DIRECT, &u32HashDst))
1761 {
1762 ret = DRV_CIPHER_BAD_PARAM;
1763 goto HASHMANUAL_FINISH;
1764 }
1765 #if 0
1766 //Set output address
1767 if(FALSE == HAL_CIPHER_Hash_Set_OuputAddr(MsOS_VA2PA(stCfg.stOutput.u32Addr), u32HashDst))
1768 {
1769 ret = DRV_CIPHER_FAIL;
1770 goto HASHMANUAL_FINISH;
1771 }
1772 #endif
1773 //Set HOS = 1, Output will be MSB First
1774 //IV auto mode use previous report digest as IV, report must be LSB first
1775 if(stCfg.pu8Digest_Buf == NULL)
1776 {
1777 HAL_CIPHER_Hash_SetHOS(FALSE);
1778 }
1779 else
1780 {
1781 HAL_CIPHER_Hash_SetHOS(TRUE);
1782 }
1783
1784 //Set total size if last command
1785 if(stCfg.eStage == E_CIPHER_HASH_STAGE_LAST)
1786 {
1787 HAL_CIPHER_Hash_SetMsgLength(stCfg.u32StartByte + stCfg.stInput.u32Size);
1788 }
1789
1790 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set Message length, StartBytes[0x%08x], Input Size[%u]",
1791 (unsigned int)stCfg.u32StartByte, stCfg.stInput.u32Size);
1792
1793
1794 u8BufNum = (MS_U8)(_u16ThreadID % (MS_U16)CIPHER_REPORT_BUFFER_MAX);
1795
1796 //Report buffer already used
1797 if(_CIPHER_ReportBuffer[u8BufNum].bUsed == TRUE)
1798 {
1799 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning:CIPHER report buffer[%u] is used!", u8BufNum);
1800 ret = DRV_CIPHER_NO_REPORT_BUFFER;
1801 goto HASHMANUAL_FINISH;
1802 }
1803
1804 _CIPHER_ReportBuffer[u8BufNum].u32Report = 0;
1805 _CIPHER_ReportBuffer[u8BufNum].u32DoneBytes = 0;
1806 _CIPHER_ReportBuffer[u8BufNum].pu8Digest_Buf = stCfg.pu8Digest_Buf;
1807 _CIPHER_ReportBuffer[u8BufNum].u32Digest_Buf_Size = stCfg.u32Digest_Buf_Size;
1808 _CIPHER_ReportBuffer[u8BufNum].eKeySrc = stCfg.stHMACKey.eKeySrc;
1809 _CIPHER_ReportBuffer[u8BufNum].u8KeyIdx = stCfg.stHMACKey.u8KeyIdx;
1810 _CIPHER_ReportBuffer[u8BufNum].bUsed = TRUE;
1811
1812 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Digest buffer address[0x%08lx], buffer size[%u]",
1813 (long unsigned int)stCfg.pu8Digest_Buf, stCfg.u32Digest_Buf_Size);
1814
1815
1816 #if !defined (MSOS_TYPE_NOS) && !defined (MCU_AEON) && !defined (MSOS_TYPE_OPTEE)
1817
1818 _eCipherWait = E_CIPHER_HASH_DONE;
1819 #endif
1820
1821 //Start hash
1822 if(FALSE == HAL_CIPHER_Hash_Start(eIntMode , TRUE, FALSE, _u16ThreadID))
1823 {
1824 ret = DRV_CIPHER_FAIL;
1825 goto HASHMANUAL_FINISH;
1826 }
1827
1828 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:IntMode[%d], CmdId[%hu]\n", eIntMode, _u16ThreadID);
1829
1830 *pu32CmdId = (MS_U32)_u16ThreadID;
1831
1832 //Check thread id max
1833 if(_u16ThreadID == HAL_CRYPTODMA_THREAD_ID_MAX)
1834 {
1835 _u16ThreadID = 1;
1836 }
1837 else
1838 {
1839 _u16ThreadID++;
1840 }
1841
1842 HASHMANUAL_FINISH:
1843
1844 MsOS_ReleaseMutex(_CipherMtx);
1845
1846 if(ret != DRV_CIPHER_OK)
1847 {
1848 MsOS_ReleaseSemaphore(_CipherSemaphore);
1849 }
1850
1851 return ret;
1852 }
1853
MDrv_CIPHER_HMAC(DRV_CIPHER_HMACCFG stCfg,MS_U32 * pu32CmdId)1854 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_HMAC(DRV_CIPHER_HMACCFG stCfg, MS_U32 *pu32CmdId)
1855 {
1856 DRV_CIPHER_RET ret = DRV_CIPHER_OK;
1857 HAL_CIPHER_INTMODE eIntMode = E_DMA_INT_NONE;
1858 MS_U32 u32OutLen = 0;
1859 MS_U32 u32HashSrc = 0;
1860 MS_U32 u32HashDst = 0;
1861 MS_U8 u8BufNum = 0;
1862
1863 #if defined (MSOS_TYPE_NOS) || defined (MCU_AEON) || defined (MSOS_TYPE_OPTEE)
1864 MS_U32 Rpt[10] = {0};
1865 MS_U32 u32WaitCnt = 0;
1866 MS_U32 u32ErrorMsg = 0;
1867 #endif
1868
1869 DRV_CIPHER_INIT_CHECK(DRV_CIPHER_FAIL);
1870
1871 if(TRUE == _bCIPHERDrv_KeyCtrlEn)
1872 {
1873 if(E_CIPHER_KSRC_KL == stCfg.stHMACKey.eKeySrc)
1874 {
1875 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_ERR, "Error:Not support!");
1876 return DRV_CIPHER_FAIL;
1877 }
1878 }
1879
1880 MsOS_FlushMemory();
1881
1882 //==============Obtain Semaphore==============
1883 MsOS_ObtainSemaphore(_CipherSemaphore, MSOS_WAIT_FOREVER);
1884
1885 MsOS_ObtainMutex(_CipherMtx, MSOS_WAIT_FOREVER);
1886
1887 //Check data size
1888 if((stCfg.stInput.u32Size == 0) || (stCfg.u32Digest_Buf_Size == 0))
1889 {
1890 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:HASH data size is zero!");
1891 ret = DRV_CIPHER_BAD_PARAM;
1892 goto HASHHMAC_FINISH;
1893 }
1894
1895 if(pu32CmdId == NULL)
1896 {
1897 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:HASH CmdId is NULL!");
1898 ret = DRV_CIPHER_BAD_PARAM;
1899 goto HASHHMAC_FINISH;
1900 }
1901
1902 if(stCfg.eAlgo == E_CIPHER_HASH_ALGO_SHA1) u32OutLen = HASH_SHA1_DIGEST_SIZE; //160 bits
1903 else if(stCfg.eAlgo == E_CIPHER_HASH_ALGO_SHA256) u32OutLen = HASH_SHA256_DIGEST_SIZE; //256 bits
1904 else if(stCfg.eAlgo == E_CIPHER_HASH_ALGO_MD5) u32OutLen = HASH_MD5_DIGEST_SIZE; //128 bits
1905 else if(stCfg.eAlgo == E_CIPHER_HASH_ALGO_SM3) u32OutLen = HASH_SM3_DIGEST_SIZE; //256 bits
1906 else u32OutLen = HASH_SHA256_DIGEST_SIZE;
1907
1908 if(stCfg.u32Digest_Buf_Size != u32OutLen)
1909 {
1910 ret = DRV_CIPHER_BAD_PARAM;
1911 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Wrong buffer size[%u]!", stCfg.u32Digest_Buf_Size);
1912 goto HASHHMAC_FINISH;
1913 }
1914 //------------Inner hash----------------------------
1915 //Reset all
1916 HAL_CIPHER_ResetStatus(FALSE , TRUE);
1917 //Set CAVid
1918 if(FALSE == HAL_CIPHER_Hash_Set_CaVid(stCfg.u32CAVid))
1919 {
1920 ret = DRV_CIPHER_BAD_PARAM;
1921 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set CAVid [0x%x]fail!", (unsigned int)stCfg.u32CAVid);
1922 goto HASHHMAC_FINISH;
1923 }
1924 //Set Algo
1925 HAL_CIPHER_Hash_Set_Config(stCfg.eAlgo, TRUE, FALSE);
1926
1927 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set Algorithm [%d]", stCfg.eAlgo);
1928
1929 //Set IV to FIPS
1930 if(FALSE == HAL_CIPHER_Hash_Set_IV(NULL, 0 , CMD_HASH_IV_FIPS))
1931 {
1932 ret = DRV_CIPHER_BAD_PARAM;
1933 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set HMAC IV fail!");
1934 goto HASHHMAC_FINISH;
1935 }
1936
1937 if(FALSE == HAL_CIPHER_Hash_Set_InitWordCnt(E_CIPHER_HASH_IWC_MANUAL, 0))
1938 {
1939 ret = DRV_CIPHER_BAD_PARAM;
1940 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set init word count fail!");
1941 goto HASHHMAC_FINISH;
1942 }
1943
1944 //Set HMAC Key
1945 if(FALSE == HAL_CIPHER_Hash_SetHMACKey(stCfg.stHMACKey, E_CIPHER_HMAC_IKPAD, FALSE))
1946 {
1947 ret = DRV_CIPHER_BAD_PARAM;
1948 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Set HMAC key fail, HMAC key source[%d], key index[%u]", stCfg.stHMACKey.eKeySrc, stCfg.stHMACKey.u8KeyIdx);
1949 goto HASHHMAC_FINISH;
1950 }
1951
1952 //Set Hash message source
1953 if(FALSE == HAL_CIPHER_Hash_Set_MsgSrcFrom(stCfg.stInput.eMemoryType, &u32HashSrc))
1954 {
1955 ret = DRV_CIPHER_BAD_PARAM;
1956 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Set source memory type [%d] fail", stCfg.stInput.eMemoryType);
1957 goto HASHHMAC_FINISH;
1958 }
1959 //Set input message address
1960 if(FALSE == HAL_CIPHER_Hash_SetMsg(stCfg.stInput.u32Addr, stCfg.stInput.u32Size, u32HashSrc))
1961 {
1962 ret = DRV_CIPHER_BAD_PARAM;
1963 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Input address[0x%08x], size[%u]",
1964 (unsigned int)stCfg.stInput.u32Addr, stCfg.stInput.u32Size);
1965 goto HASHHMAC_FINISH;
1966 }
1967
1968 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set Input address[0x%08x], size[%u]",
1969 (unsigned int)stCfg.stInput.u32Addr, stCfg.stInput.u32Size);
1970
1971 //Set output destination, HMAC inner hash output to register
1972 if(FALSE == HAL_CIPHER_Hash_Set_OutputDstTo(E_CIPHER_DIRECT, &u32HashDst))
1973 {
1974 ret = DRV_CIPHER_BAD_PARAM;
1975 goto HASHHMAC_FINISH;
1976 }
1977 #if 0
1978 //Set output address
1979 if(FALSE == HAL_CIPHER_Hash_Set_OuputAddr(MsOS_VA2PA(stCfg.stOutput.u32Addr), u32HashDst))
1980 {
1981 ret = DRV_CIPHER_FAIL;
1982 goto HASHHMAC_FINISH;
1983 }
1984 #endif
1985 //Set HOS = 0, HW limitation
1986 HAL_CIPHER_Hash_SetHOS(FALSE);
1987
1988 HAL_CIPHER_Hash_SetMsgLength(stCfg.stInput.u32Size + HASH_HMAC_KEYPAD_SIZE);
1989
1990 u8BufNum = (MS_U8)(_u16ThreadID % (MS_U16)CIPHER_REPORT_BUFFER_MAX);
1991
1992 _CIPHER_ReportBuffer[u8BufNum].u32Report = 0;
1993 _CIPHER_ReportBuffer[u8BufNum].u32DoneBytes = 0;
1994 _CIPHER_ReportBuffer[u8BufNum].pu8Digest_Buf = NULL;
1995 _CIPHER_ReportBuffer[u8BufNum].u32Digest_Buf_Size = 0;
1996 _CIPHER_ReportBuffer[u8BufNum].eKeySrc = stCfg.stHMACKey.eKeySrc;
1997 _CIPHER_ReportBuffer[u8BufNum].u8KeyIdx = stCfg.stHMACKey.u8KeyIdx;
1998
1999 #if !defined (MSOS_TYPE_NOS) && !defined (MCU_AEON) && !defined (MSOS_TYPE_OPTEE)
2000
2001 _eCipherWait = E_CIPHER_HASH_DONE;
2002 eIntMode = E_DMA_INT_ENABLE;
2003
2004 #endif
2005
2006 //Start hash
2007 if(FALSE == HAL_CIPHER_Hash_Start(eIntMode , TRUE, FALSE, _u16ThreadID))
2008 {
2009 ret = DRV_CIPHER_FAIL;
2010 goto HASHHMAC_FINISH;
2011 }
2012
2013 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:IntMode[%d], CmdId[%hu]", eIntMode, _u16ThreadID);
2014
2015 #if defined (MSOS_TYPE_NOS) || defined (MCU_AEON) || defined (MSOS_TYPE_OPTEE)
2016
2017 while(FALSE == HAL_CIPHER_Hash_CmdDone(_u16ThreadID, &u32ErrorMsg) && u32WaitCnt < HASH_TIMEOUT_VALUE)
2018 {
2019 #ifdef MSOS_TYPE_NUTTX
2020 MsOS_DelayTaskUs(200);
2021 #elif MSOS_TYPE_OPTEE
2022
2023 #else
2024 MsOS_DelayTask(20);
2025 #endif
2026 u32WaitCnt++;
2027 }
2028 //First time should print HMAC error flag
2029 if(u32ErrorMsg != 0)
2030 {
2031 HAL_CIPHER_Hash_ExceptFilter(&u32ErrorMsg, stCfg.stHMACKey.eKeySrc, stCfg.stHMACKey.u8KeyIdx);
2032 HAL_CIPHER_ReadException(u32ErrorMsg);
2033 }
2034
2035 if(u32WaitCnt >= HASH_TIMEOUT_VALUE)
2036 {
2037 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning;HASH timeout!");
2038 ret = DRV_CIPHER_FAIL;
2039 goto HASHHMAC_FINISH;
2040 }
2041
2042 HAL_CIPHER_Hash_GetRpt(Rpt, HASH_RPT_SIZE_STATUS);
2043
2044 if((Rpt[0] & DRV_CIPHER_REPORT_OK) == 0)
2045 {
2046 ret = DRV_CIPHER_FAIL;
2047 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:HMAC Inner Hash Fail!");
2048 goto HASHHMAC_FINISH;
2049 }
2050
2051 MsOS_ReleaseSemaphore(_CipherSemaphore);
2052 #endif
2053
2054 //Check thread id max
2055 if(_u16ThreadID == HAL_CRYPTODMA_THREAD_ID_MAX)
2056 {
2057 _u16ThreadID = 1;
2058 }
2059 else
2060 {
2061 _u16ThreadID++;
2062 }
2063
2064 MsOS_ReleaseMutex(_CipherMtx);
2065
2066 //----------------Outer hash------------------------------
2067
2068 //==============Obtain Semaphore==============
2069 MsOS_ObtainSemaphore(_CipherSemaphore, MSOS_WAIT_FOREVER);
2070
2071 MsOS_ObtainMutex(_CipherMtx, MSOS_WAIT_FOREVER);
2072
2073 eIntMode = E_DMA_INT_NONE;
2074
2075 //Set CAVid
2076 if(FALSE == HAL_CIPHER_Hash_Set_CaVid(stCfg.u32CAVid))
2077 {
2078 ret = DRV_CIPHER_BAD_PARAM;
2079 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set CAVid [0x%x]fail!", (unsigned int)stCfg.u32CAVid);
2080 goto HASHHMAC_FINISH;
2081 }
2082
2083 //Set Algo
2084 HAL_CIPHER_Hash_Set_Config(stCfg.eAlgo, TRUE, FALSE );
2085
2086 //Set IV to FIPS
2087 if(FALSE == HAL_CIPHER_Hash_Set_IV(NULL, 0 , CMD_HASH_IV_FIPS))
2088 {
2089 ret = DRV_CIPHER_BAD_PARAM;
2090 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set HMAC IV fail!");
2091 goto HASHHMAC_FINISH;
2092 }
2093
2094 if(FALSE == HAL_CIPHER_Hash_Set_InitWordCnt(E_CIPHER_HASH_IWC_MANUAL, 0))
2095 {
2096 ret = DRV_CIPHER_BAD_PARAM;
2097 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set init word count fail!");
2098 goto HASHHMAC_FINISH;
2099 }
2100
2101
2102 //Set HMAC Key,
2103 if(FALSE == HAL_CIPHER_Hash_SetHMACKey(stCfg.stHMACKey, E_CIPHER_HMAC_OKPAD, FALSE))
2104 {
2105 ret = DRV_CIPHER_BAD_PARAM;
2106 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set HMAC key fail!");
2107 goto HASHHMAC_FINISH;
2108 }
2109
2110 //No need to set Hash message source
2111 //HAL_CIPHER_Hash_Set_MsgSrcFrom(stCfg.stInput.eMemoryType, &u32HashSrc);
2112
2113 //Set input message address, outer hash from previous report
2114 if(FALSE == HAL_CIPHER_Hash_SetMsg(NULL, 0, CMD_HASH_SRC_PRV_RPT))
2115 {
2116 ret = DRV_CIPHER_BAD_PARAM;
2117 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set HMAC message fail!");
2118 goto HASHHMAC_FINISH;
2119 }
2120
2121 //Set output destination
2122 if(FALSE == HAL_CIPHER_Hash_Set_OutputDstTo(E_CIPHER_DIRECT, &u32HashDst))
2123 {
2124 ret = DRV_CIPHER_BAD_PARAM;
2125 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set HMAC output destination fail!");
2126 goto HASHHMAC_FINISH;
2127 }
2128
2129 #if 0 //Default output to Register
2130 //Set output address
2131 if(FALSE == HAL_CIPHER_Hash_Set_OuputAddr(MsOS_VA2PA(stCfg.stOutput.u32Addr), u32HashDst))
2132 {
2133 ret = DRV_CIPHER_FAIL;
2134 goto HASHHMAC_FINISH;
2135 }
2136 #endif
2137
2138 //Set HOS = 1
2139 HAL_CIPHER_Hash_SetHOS(TRUE);
2140
2141 HAL_CIPHER_Hash_SetMsgLength(u32OutLen + HASH_HMAC_KEYPAD_SIZE); //Hash output size + O_keypad_size
2142
2143 u8BufNum = _u16ThreadID % (MS_U32)CIPHER_REPORT_BUFFER_MAX;
2144
2145 _CIPHER_ReportBuffer[u8BufNum].u32Report = 0;
2146 _CIPHER_ReportBuffer[u8BufNum].u32DoneBytes = 0;
2147 _CIPHER_ReportBuffer[u8BufNum].pu8Digest_Buf = stCfg.pu8Digest_Buf;
2148 _CIPHER_ReportBuffer[u8BufNum].u32Digest_Buf_Size = stCfg.u32Digest_Buf_Size;
2149 _CIPHER_ReportBuffer[u8BufNum].eKeySrc = stCfg.stHMACKey.eKeySrc;
2150 _CIPHER_ReportBuffer[u8BufNum].u8KeyIdx = stCfg.stHMACKey.u8KeyIdx;
2151 _CIPHER_ReportBuffer[u8BufNum].bUsed = TRUE;
2152
2153 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Digest buffer address[0x%08lx], buffer size[%u]\n",
2154 (long unsigned int)stCfg.pu8Digest_Buf, stCfg.u32Digest_Buf_Size);
2155
2156
2157 #if !defined (MSOS_TYPE_NOS) && !defined (MCU_AEON) && !defined (MSOS_TYPE_OPTEE)
2158
2159 _eCipherWait = E_CIPHER_HASH_DONE;
2160
2161 if(stCfg.pfCallback != NULL)
2162 {
2163 _CIPHER_ReportBuffer[u8BufNum].pfCallback = stCfg.pfCallback;
2164 eIntMode = E_DMA_INT_ENABLE;
2165 }
2166 #endif
2167
2168 //Start hash
2169 if(FALSE == HAL_CIPHER_Hash_Start(eIntMode , TRUE, FALSE, _u16ThreadID))
2170 {
2171 ret = DRV_CIPHER_FAIL;
2172 goto HASHHMAC_FINISH;
2173 }
2174
2175 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:IntMode[%d], CmdId[%hu]\n", eIntMode, _u16ThreadID);
2176
2177 *pu32CmdId = (MS_U32)_u16ThreadID;
2178
2179 //Check thread id max
2180 if(_u16ThreadID == HAL_CRYPTODMA_THREAD_ID_MAX)
2181 {
2182 _u16ThreadID = 1;
2183 }
2184 else
2185 {
2186 _u16ThreadID++;
2187 }
2188
2189 HASHHMAC_FINISH:
2190
2191 MsOS_ReleaseMutex(_CipherMtx);
2192
2193 if(ret != DRV_CIPHER_OK)
2194 {
2195 MsOS_ReleaseSemaphore(_CipherSemaphore);
2196 }
2197
2198 return ret;
2199 }
2200
MDrv_CIPHER_KeyCtrl(MS_BOOL bEnable)2201 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_KeyCtrl(MS_BOOL bEnable)
2202 {
2203 DRV_CIPHER_RET ret = DRV_CIPHER_OK;
2204 MS_U32 i = 0;
2205
2206 DRV_CIPHER_INIT_CHECK(DRV_CIPHER_FAIL);
2207
2208 MsOS_ObtainMutex(_CipherMtx, MSOS_WAIT_FOREVER);
2209
2210 if(bEnable)
2211 {
2212 for(i = 0;i < HAL_CRYPTODMA_DMA_KEY_SLOT;i++)
2213 {
2214 memset(&_CIPHER_Resource[i], 0, sizeof(CIPHER_RESOURCE));
2215 }
2216
2217 _bCIPHERDrv_KeyCtrlEn = TRUE;
2218 }
2219 else
2220 {
2221 for(i = 0;i < HAL_CRYPTODMA_DMA_KEY_SLOT;i++)
2222 {
2223 memset(&_CIPHER_Resource[i], 0, sizeof(CIPHER_RESOURCE));
2224 }
2225
2226 _bCIPHERDrv_KeyCtrlEn = FALSE;
2227 }
2228
2229 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_INFO, "Key slot control mode[%d]", _bCIPHERDrv_KeyCtrlEn);
2230
2231 MsOS_ReleaseMutex(_CipherMtx);
2232
2233 return ret;
2234 }
2235
MDrv_CIPHER_Alloc(MS_U32 * pu32CipherId)2236 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_Alloc(MS_U32 *pu32CipherId)
2237 {
2238 DRV_CIPHER_RET ret = DRV_CIPHER_OK;
2239 MS_U32 i = 0;
2240
2241 DRV_CIPHER_INIT_CHECK(DRV_CIPHER_FAIL);
2242 DRV_CIPHER_KEYCTRL_CHECK(DRV_CIPHER_FAIL);
2243
2244 if(NULL == pu32CipherId)
2245 {
2246 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_ERR, "Error:Cipher Id is NULL!");
2247 return DRV_CIPHER_BAD_PARAM;
2248 }
2249
2250 MsOS_ObtainMutex(_CipherMtx, MSOS_WAIT_FOREVER);
2251
2252 for(i = 0;i < HAL_CRYPTODMA_DMA_KEY_SLOT;i++)
2253 {
2254 if(FALSE == _CIPHER_Resource[i].bUsed)
2255 {
2256 _CIPHER_Resource[i].bUsed = TRUE;
2257 *pu32CipherId = i;
2258 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_INFO, "Allocate Cipher Id[%u]", i);
2259 goto CIPHER_ALLOC_DONE;
2260 }
2261 }
2262
2263 ret = DRV_CIPHER_FAIL;
2264 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_ERR, "Allocate Cipher Id fail");
2265
2266 CIPHER_ALLOC_DONE:
2267
2268 MsOS_ReleaseMutex(_CipherMtx);
2269 return ret;
2270
2271 }
2272
MDrv_CIPHER_Free(MS_U32 u32CipherId)2273 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_Free(MS_U32 u32CipherId)
2274 {
2275 DRV_CIPHER_RET ret = DRV_CIPHER_OK;
2276
2277 DRV_CIPHER_INIT_CHECK(DRV_CIPHER_FAIL);
2278 DRV_CIPHER_KEYCTRL_CHECK(DRV_CIPHER_FAIL);
2279
2280 if(HAL_CRYPTODMA_DMA_KEY_SLOT <= u32CipherId)
2281 {
2282 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_ERR, "Error:Invalid Cipher Id[%u]!", u32CipherId);
2283 return DRV_CIPHER_BAD_PARAM;
2284 }
2285
2286 u32CipherId %= HAL_CRYPTODMA_DMA_KEY_SLOT;
2287
2288 if(FALSE == _CIPHER_Resource[u32CipherId].bUsed)
2289 {
2290 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_WARN, "Warning:Not used Cipher Id[%u]!", u32CipherId);
2291 return DRV_CIPHER_BAD_PARAM;
2292 }
2293
2294 if(E_CIPHER_KSRC_KL == _CIPHER_Resource[u32CipherId].stConfig.stKey.eKeySrc)
2295 {
2296 if(DRV_CIPHER_OK != MDrv_CIPHER_ResetKey(_CIPHER_Resource[u32CipherId].stConfig.u32CAVid, _CIPHER_Resource[u32CipherId].stConfig.stKey.u8KeyIdx))
2297 {
2298 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_ERR, "Error:Reset key slot fail!");
2299 return DRV_CIPHER_FAIL;
2300
2301 }
2302 }
2303
2304 MsOS_ObtainMutex(_CipherMtx, MSOS_WAIT_FOREVER);
2305
2306 memset(&_CIPHER_Resource[u32CipherId], 0, sizeof(CIPHER_RESOURCE));
2307 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_INFO, "Free Cipher Id[%u]", u32CipherId);
2308
2309 MsOS_ReleaseMutex(_CipherMtx);
2310
2311 return ret;
2312 }
2313
MDrv_CIPHER_DMAConfigure(MS_U32 u32CipherId,DRV_CIPHER_DMACFG stCfg)2314 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_DMAConfigure(MS_U32 u32CipherId, DRV_CIPHER_DMACFG stCfg)
2315 {
2316 DRV_CIPHER_RET ret = DRV_CIPHER_OK;
2317
2318 DRV_CIPHER_INIT_CHECK(DRV_CIPHER_FAIL);
2319 DRV_CIPHER_KEYCTRL_CHECK(DRV_CIPHER_FAIL);
2320
2321 if(HAL_CRYPTODMA_DMA_KEY_SLOT <= u32CipherId)
2322 {
2323 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_ERR, "Error:Invalid Cipher Id[%u]!", u32CipherId);
2324 return DRV_CIPHER_BAD_PARAM;
2325 }
2326
2327 u32CipherId %= HAL_CRYPTODMA_DMA_KEY_SLOT;
2328
2329 if(FALSE == _CIPHER_Resource[u32CipherId].bUsed)
2330 {
2331 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_ERR, "Error:Not used Cipher Id[%u]!", u32CipherId);
2332 return DRV_CIPHER_BAD_PARAM;
2333 }
2334
2335 MsOS_ObtainMutex(_CipherMtx, MSOS_WAIT_FOREVER);
2336
2337 if(0 != stCfg.u32CAVid)
2338 {
2339 _CIPHER_Resource[u32CipherId].stConfig.u32CAVid = stCfg.u32CAVid;
2340 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_INFO, "INFO:Set CAVid [0x%x]", (unsigned int)stCfg.u32CAVid);
2341 }
2342
2343 //Update Algorithm and Encrypt/Decrypt operation
2344 if(0 != stCfg.stAlgo.eMainAlgo || 0 != stCfg.stAlgo.eSubAlgo || 0 != stCfg.stAlgo.eResAlgo || 0 != stCfg.stAlgo.eSBAlgo)
2345 {
2346 _CIPHER_Resource[u32CipherId].stConfig.stAlgo = stCfg.stAlgo;
2347 _CIPHER_Resource[u32CipherId].stConfig.bDecrypt = stCfg.bDecrypt;
2348 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_INFO, "INFO:Set algorithm: MAIN[%d], SUB[%d], RES[%d], SB[%d]",
2349 stCfg.stAlgo.eMainAlgo, stCfg.stAlgo.eSubAlgo, stCfg.stAlgo.eResAlgo, stCfg.stAlgo.eSBAlgo);
2350 }
2351
2352 if(0 != stCfg.stInput.u32Addr || 0 != stCfg.stInput.u32Size || 0 != stCfg.stInput.eMemoryType)
2353 {
2354 _CIPHER_Resource[u32CipherId].stConfig.stInput = stCfg.stInput;
2355 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set Input address [0x%08x], size[%u]",
2356 (unsigned int)stCfg.stInput.u32Addr, stCfg.stInput.u32Size);
2357 }
2358
2359 if(0 != stCfg.stOutput.u32Addr || 0 != stCfg.stOutput.u32Size || 0 != stCfg.stOutput.eMemoryType)
2360 {
2361 _CIPHER_Resource[u32CipherId].stConfig.stOutput = stCfg.stOutput;
2362 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Set Output address [0x%08x], size[%u]",
2363 (unsigned int)stCfg.stOutput.u32Addr, stCfg.stOutput.u32Size);
2364 }
2365
2366 if(0 != stCfg.stKey.eKeySrc || 0 != stCfg.stKey.u8KeyIdx || NULL != stCfg.stKey.pu8KeyData)
2367 {
2368 if(E_CIPHER_KSRC_CPU == stCfg.stKey.eKeySrc)
2369 {
2370 if(NULL != stCfg.stKey.pu8KeyData && 0 != stCfg.stKey.u8KeyLen)
2371 {
2372 memset(&_CIPHER_Resource[u32CipherId].u8Key, 0, HAL_CRYPTODMA_KEYLEN_MAX);
2373 memcpy(&_CIPHER_Resource[u32CipherId].u8Key, (MS_U8 *)stCfg.stKey.pu8KeyData, stCfg.stKey.u8KeyLen);
2374
2375 _CIPHER_Resource[u32CipherId].stConfig.stKey.eKeySrc = E_CIPHER_KSRC_CPU;
2376 _CIPHER_Resource[u32CipherId].stConfig.stKey.pu8KeyData = _CIPHER_Resource[u32CipherId].u8Key;
2377 _CIPHER_Resource[u32CipherId].stConfig.stKey.u8KeyLen = stCfg.stKey.u8KeyLen;
2378 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_INFO, "Set ACPU key in CipherId[%u]", u32CipherId);
2379 }
2380 else
2381 {
2382 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_ERR, "Error:Key is NULL!");
2383 ret = DRV_CIPHER_BAD_PARAM;
2384 goto DMA_CONFIGURE_DONE;
2385 }
2386 }
2387
2388 if(E_CIPHER_KSRC_KL == stCfg.stKey.eKeySrc)
2389 {
2390 _CIPHER_Resource[u32CipherId].stConfig.stKey.eKeySrc = E_CIPHER_KSRC_KL;
2391 _CIPHER_Resource[u32CipherId].stConfig.stKey.u8KeyIdx = (MS_U8)u32CipherId;
2392 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_INFO, "Set KL index in CipherId[%u]", u32CipherId);
2393 }
2394
2395 if(E_CIPHER_KSRC_OTP == stCfg.stKey.eKeySrc)
2396 {
2397 _CIPHER_Resource[u32CipherId].stConfig.stKey.eKeySrc = E_CIPHER_KSRC_OTP;
2398 _CIPHER_Resource[u32CipherId].stConfig.stKey.u8KeyIdx = stCfg.stKey.u8KeyIdx;
2399 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_INFO, "Set OTP key index in CipherId[%u]", u32CipherId);
2400 }
2401
2402 if(E_CIPHER_KSRC_CAIP == stCfg.stKey.eKeySrc)
2403 {
2404 _CIPHER_Resource[u32CipherId].stConfig.stKey.eKeySrc = E_CIPHER_KSRC_CAIP;
2405 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_INFO, "Set CAIP key in CipherId[%u]", u32CipherId);
2406 }
2407
2408 }
2409
2410 if(NULL != stCfg.stKey.pu8IVData && 0 != stCfg.stKey.u8IVLen)
2411 {
2412 memset(&_CIPHER_Resource[u32CipherId].u8IV, 0, HAL_CRYPTODMA_KEYLEN_MAX);
2413 memcpy(&_CIPHER_Resource[u32CipherId].u8IV, (MS_U8 *)stCfg.stKey.pu8IVData, stCfg.stKey.u8IVLen);
2414 _CIPHER_Resource[u32CipherId].stConfig.stKey.pu8IVData = _CIPHER_Resource[u32CipherId].u8IV;
2415 _CIPHER_Resource[u32CipherId].stConfig.stKey.u8IVLen = stCfg.stKey.u8IVLen;
2416 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_INFO, "Set IV in CipherId[%u]", u32CipherId);
2417 }
2418
2419 DMA_CONFIGURE_DONE:
2420
2421 MsOS_ReleaseMutex(_CipherMtx);
2422 return ret;
2423
2424 }
2425
MDrv_CIPHER_DMAStart(MS_U32 u32CipherId,MS_U32 * pu32CmdId)2426 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_DMAStart(MS_U32 u32CipherId, MS_U32 *pu32CmdId)
2427 {
2428 DRV_CIPHER_RET ret = DRV_CIPHER_OK;
2429 DRV_CIPHER_DMACFG stCfg;
2430
2431 DRV_CIPHER_INIT_CHECK(DRV_CIPHER_FAIL);
2432 DRV_CIPHER_KEYCTRL_CHECK(DRV_CIPHER_FAIL);
2433
2434 if(HAL_CRYPTODMA_DMA_KEY_SLOT <= u32CipherId)
2435 {
2436 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_ERR, "Error:Invalid Cipher Id[%u]!", u32CipherId);
2437 return DRV_CIPHER_BAD_PARAM;
2438 }
2439
2440 u32CipherId %= HAL_CRYPTODMA_DMA_KEY_SLOT;
2441
2442 if(FALSE == _CIPHER_Resource[u32CipherId].bUsed)
2443 {
2444 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_ERR, "Error:Not used Cipher Id[%u]!", u32CipherId);
2445 return DRV_CIPHER_BAD_PARAM;
2446 }
2447
2448 if(pu32CmdId == NULL)
2449 {
2450 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_ERR, "Error:DMA CmdId is NULL!");
2451 return DRV_CIPHER_BAD_PARAM;
2452 }
2453
2454 MsOS_ObtainMutex(_CipherMtx, MSOS_WAIT_FOREVER);
2455
2456 memset(&stCfg, 0 , sizeof(DRV_CIPHER_DMACFG));
2457
2458 stCfg = _CIPHER_Resource[u32CipherId].stConfig;
2459
2460 DEBUG_CIPHER_KEYCTRL(CIPHER_DBG_INFO, "DMA use CipherId[%u]", u32CipherId);
2461
2462 MsOS_ReleaseMutex(_CipherMtx);
2463
2464 ret = MDrv_CIPHER_DMACalc(stCfg, pu32CmdId);
2465
2466 return ret;
2467
2468 }
2469
2470
2471 #if 0
2472 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_DMAParser(CIPHER_PARSERCFG stParserCfg, MS_U32 *pu32CmdId)
2473 {
2474 DRV_CIPHER_RET ret = DRV_CIPHER_OK;
2475 HAL_CIPHER_INTMODE eIntMode = E_DMA_INT_NONE;
2476 MS_U8 u8BufNum = 0;
2477
2478 MsOS_FlushMemory();
2479
2480 //==============Obtain Semaphore==============
2481 MsOS_ObtainSemaphore(_CipherSemaphore, MSOS_WAIT_FOREVER);
2482
2483 MsOS_ObtainMutex(_CipherMtx, MSOS_WAIT_FOREVER);
2484
2485 //Check data size
2486 if((stParserCfg.stInput.u32Size == 0) || (stParserCfg.stOutput.u32Size == 0))
2487 {
2488 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:DMA data size is zero!\n");
2489 ret = DRV_CIPHER_BAD_PARAM;
2490 goto PARSER_FINISH;
2491 }
2492
2493 if(pu32CmdId == NULL)
2494 {
2495 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:DMA CmdId is NULL!\n");
2496 ret = DRV_CIPHER_BAD_PARAM;
2497 goto PARSER_FINISH;
2498 }
2499
2500 HAL_CIPHER_ResetStatus(TRUE , FALSE ) ;
2501
2502 DEBUG_CIPHER(CIPHER_DBG_INFO, "Set CAVid [0x%x]\n", (unsigned int)stParserCfg.u32CAVid);
2503
2504 if(FALSE == HAL_CIPHER_DMA_Set_CaVid(stParserCfg.u32CAVid))
2505 {
2506 ret = DRV_CIPHER_BAD_PARAM;
2507 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error: Set CAVid [0x%x]fail!\n", (unsigned int)stParserCfg.u32CAVid);
2508 goto PARSER_FINISH;
2509 }
2510
2511 HAL_CIPHER_DMA_Set_Algo( stParserCfg.stAlgo);
2512 HAL_CIPHER_DMA_Set_Key ( stParserCfg.stKey);
2513 HAL_CIPHER_DMA_Set_IV(stParserCfg.stKey.pu8IVData, stParserCfg.stKey.u8IVLen);
2514
2515 DEBUG_CIPHER(CIPHER_DBG_INFO, "Set algorithm: MAIN[%d], SUB[%d], RES[%d], SB[%d]\n"
2516 ,stParserCfg.stAlgo.eMainAlgo, stParserCfg.stAlgo.eSubAlgo, stParserCfg.stAlgo.eResAlgo, stParserCfg.stAlgo.eSBAlgo);
2517
2518 // need to call DMA_Set_InputSrcFrom and DMA_Set_OutputDstTo
2519 // before call DMA_Set_FileinDesc and DMA_Set_FileoutDesc
2520 HAL_CIPHER_DMA_Set_InputSrcFrom(stParserCfg.stInput.eMemoryType, NULL, 0);
2521 HAL_CIPHER_DMA_Set_OutputDstTo(stParserCfg.stOutput.eMemoryType, NULL, 0);
2522
2523 DEBUG_CIPHER(CIPHER_DBG_INFO, "Set Input source from [%d], Output source from [%d]\n",
2524 stParserCfg.stInput.eMemoryType, stParserCfg.stOutput.eMemoryType);
2525
2526 // Set File-in Addr //
2527 HAL_CIPHER_DMA_Set_FileinDesc ( stParserCfg.stInput.u32Addr, stParserCfg.stInput.u32Size);
2528 HAL_CIPHER_DMA_Set_FileoutDesc( stParserCfg.stOutput.u32Addr, stParserCfg.stOutput.u32Addr + stParserCfg.stOutput.u32Size - 1);
2529
2530 DEBUG_CIPHER(CIPHER_DBG_INFO, "Set Input address [0x%08x], size[%u], Output address [0x%08x], size[%u]\n",
2531 (unsigned int)stParserCfg.stInput.u32Addr, stParserCfg.stInput.u32Size, (unsigned int)stParserCfg.stOutput.u32Addr, stParserCfg.stOutput.u32Size);
2532
2533 // Set Hardware Parser
2534 HAL_CIPHER_PARSER_Set_Mode(stParserCfg.eParserMode);
2535
2536 HAL_CIPHER_PARSER_Set_PID(stParserCfg.stPID);
2537 HAL_CIPHER_PARSER_Set_SCB(stParserCfg.stTSCfg.eSCB);
2538
2539 HAL_CIPHER_PARSER_Set_ForceSCB(stParserCfg.stTSCfg.bInScrb, stParserCfg.stTSCfg.eFSCB);
2540 HAL_CIPHER_PARSER_Rmv_SCB(stParserCfg.stTSCfg.bRmvScrb);
2541
2542 HAL_CIPHER_PARSER_Set_MaskSCB(stParserCfg.stTSCfg.bTsScrbMask);
2543
2544 HAL_CIPHER_PARSER_Set_Key2(stParserCfg.stKey2);
2545 HAL_CIPHER_PARSER_Set_IV2(stParserCfg.stKey2.pu8IVData, stParserCfg.stKey2.u8IVLen);
2546
2547 HAL_CIPHER_PARSER_Set_ClearHeaderMode(stParserCfg.bClearHead);
2548
2549 //Check report buffer
2550 u8BufNum = (MS_U8)(_u16ThreadID % (MS_U16)CIPHER_REPORT_BUFFER_MAX);
2551
2552 //Report buffer already used
2553 if(_CIPHER_ReportBuffer[u8BufNum].bUsed == TRUE)
2554 {
2555 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning:CIPHER report buffer is used!\n");
2556 ret = DRV_CIPHER_NO_REPORT_BUFFER;
2557 goto PARSER_FINISH;
2558 }
2559
2560 _CIPHER_ReportBuffer[u8BufNum].u32Report = 0;
2561 _CIPHER_ReportBuffer[u8BufNum].u32DoneBytes = 0;
2562 _CIPHER_ReportBuffer[u8BufNum].bUsed = TRUE;
2563
2564
2565 #if !defined (MSOS_TYPE_NOS) && !defined (MCU_AEON) && !defined (MSOS_TYPE_OPTEE)
2566
2567 _eCipherWait = E_CIPHER_DMA_DONE;
2568
2569 if(stParserCfg.pfCallback != NULL)
2570 {
2571 _CIPHER_ReportBuffer[u8BufNum].pfCallback = stParserCfg.pfCallback;
2572 eIntMode = E_DMA_INT_ENABLE;
2573 }
2574 #endif
2575
2576 if(FALSE == HAL_CIPHER_DMA_Start(stParserCfg.bDecrypt, eIntMode , TRUE , _u16ThreadID))
2577 {
2578 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:PARSER Fail!\n");
2579 ret = DRV_CIPHER_FAIL;
2580 goto PARSER_FINISH;
2581 }
2582
2583 DEBUG_CIPHER(CIPHER_DBG_INFO, "IntMode[%d], CmdId[%hu]\n", eIntMode, _u16ThreadID);
2584
2585 *pu32CmdId = (MS_U32)_u16ThreadID;
2586
2587 _u16ThreadID++;
2588
2589 PARSER_FINISH:
2590
2591 MsOS_ReleaseMutex(_CipherMtx);
2592
2593 if(ret != DRV_CIPHER_OK)
2594 {
2595 MsOS_ReleaseSemaphore(_CipherSemaphore);
2596 }
2597
2598 return ret;
2599
2600 }
2601 #endif
2602
2603 #ifdef ENABLE_BGC
MDrv_CIPHER_BGC_Enable(MS_U32 u32EngId,MS_U32 u32Algo,MS_U8 * pu8Golden,MS_U32 u32SAddr,MS_U32 u32Size)2604 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_BGC_Enable(MS_U32 u32EngId,MS_U32 u32Algo, MS_U8 *pu8Golden, MS_U32 u32SAddr, MS_U32 u32Size)
2605 {
2606 //Set BGC Algo
2607 HAL_CIPHER_BGC_Algo(u32EngId, u32Algo);
2608
2609 //Set BGC Period
2610 HAL_CIPHER_BGC_Period(u32EngId, E_CIPHER_BGC_PERIOD_1MS);
2611
2612 //Set BGC Range
2613 HAL_CIPHER_BGC_Range(u32EngId, u32SAddr, (u32SAddr + u32Size-1) );
2614
2615 //Set BGC Golden
2616 HAL_CIPHER_BGC_Golden(u32EngId, pu8Golden);
2617
2618 //Set BGC Enable
2619 HAL_CIPHER_BGC_Start(u32EngId, TRUE);
2620
2621
2622 return 0;
2623 }
2624
MDrv_CIPHER_BGC_Check(MS_U32 u32EngId,MS_BOOL * bOK)2625 DLL_PUBLIC DRV_CIPHER_RET MDrv_CIPHER_BGC_Check(MS_U32 u32EngId, MS_BOOL *bOK)
2626 {
2627 if(HAL_CIPHER_BGC_Check(u32EngId) == FALSE)
2628 {
2629 *bOK = FALSE;
2630 }
2631 else
2632 {
2633 *bOK = TRUE;
2634 }
2635 return 0;
2636 }
2637
2638 #endif
2639 //////////////////////////////////////////////////////////////////
2640 static DRV_CIPHER_KEY _CipherKey = {
2641 E_CIPHER_KSRC_CPU,
2642 0,
2643 0,
2644 0,
2645 0,
2646 0
2647 };
2648 static MS_BOOL _isDecrypt = TRUE;
2649 static DRV_CIPHER_ALGO _stAlgo = {0};
2650 static DRV_CIPHER_DATA _stInput = {0};
2651 static DRV_CIPHER_DATA _stOutput = {0};
2652 static MS_U32 _RetId = 0;
2653 static MS_U8 _u8IV[16] = {0};
2654 static MS_U8 _u8Key[16] = {0};
2655 static MS_U8 _u8ZeroData[16] = {0};
2656 static MS_U32 _u32CAVid = 0x0F;
2657
_MDrv_AESDMA_InitBySWFlag(MS_BOOL bSWInit)2658 DRVAESDMA_RESULT _MDrv_AESDMA_InitBySWFlag(MS_BOOL bSWInit)
2659 {
2660 DRV_CIPHER_RET ret = DRV_CIPHER_OK;
2661
2662 ret = _MDrv_CIPHER_InitBySWFlag(bSWInit);
2663
2664 if(DRV_CIPHER_OK != ret)
2665 {
2666 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:_MDrv_CIPHER_InitBySWFlag fail");
2667 return DRVAESDMA_FAIL;
2668 }
2669
2670 // Default Key from ACPU
2671 _CipherKey.eKeySrc = E_CIPHER_KSRC_CPU;
2672 _CipherKey.pu8KeyData = _u8ZeroData;
2673 _CipherKey.u8KeyLen = 16;
2674 _CipherKey.u8KeyIdx = 0;
2675
2676 //Clear IV
2677 _CipherKey.pu8IVData = _u8ZeroData;
2678 _CipherKey.u8IVLen = 16;
2679
2680 //Clear Algo
2681 _stAlgo.eMainAlgo = 0;
2682 _stAlgo.eSubAlgo = 0;
2683 _stAlgo.eResAlgo = 0;
2684 _stAlgo.eSBAlgo = 0;
2685
2686 //Clear Input
2687 _stInput.u32Addr = 0;
2688 _stInput.u32Size = 0;
2689 _stInput.eMemoryType = 0;
2690
2691 //Clear Output
2692 _stOutput.u32Addr = 0;
2693 _stOutput.u32Size = 0;
2694 _stOutput.eMemoryType = 0;
2695
2696 memset(_u8Key, 0, sizeof(_u8Key));
2697 memset(_u8IV, 0, sizeof(_u8IV));
2698
2699 return DRVAESDMA_OK;
2700 }
2701
_MDrv_AESDMA_Init(MS_PHY u32miu0addr,MS_PHY u32miu1addr,MS_U32 u32miunum)2702 DRVAESDMA_RESULT _MDrv_AESDMA_Init(MS_PHY u32miu0addr , MS_PHY u32miu1addr , MS_U32 u32miunum)
2703 {
2704 DRV_CIPHER_RET ret = DRV_CIPHER_OK;
2705 MS_U32 i = 0;
2706
2707 ret = MDrv_CIPHER_Init();
2708
2709 for(i = 0;i < HAL_CRYPTODMA_DMA_KEY_SLOT;i++)
2710 {
2711 memset(&_CIPHER_Resource[i], 0, sizeof(CIPHER_RESOURCE));
2712 }
2713
2714 return ret;
2715 }
2716
MDrv_AESDMA_Init(MS_PHY u32miu0addr,MS_PHY u32miu1addr,MS_U32 u32miunum)2717 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_Init(MS_PHY u32miu0addr , MS_PHY u32miu1addr , MS_U32 u32miunum)
2718 {
2719 #if CIPHER_UTOPIA2
2720 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
2721 AESDMA_INIT pArgs;
2722
2723 if(pu32AesdmaInst == NULL)
2724 {
2725 if(UTOPIA_STATUS_FAIL == UtopiaOpen(MODULE_AESDMA, &pu32AesdmaInst, 0x0, NULL))
2726 {
2727 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaOpen CIPHER fail");
2728 return DRVAESDMA_FAIL;
2729 }
2730 }
2731
2732 pArgs.u32miu0addr = u32miu0addr;
2733 pArgs.u32miu1addr = u32miu1addr;
2734 pArgs.u32miunum = u32miunum;
2735
2736 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_Init, (void*)&pArgs);
2737 if(UTOPIA_STATUS_SUCCESS != u32Ret)
2738 {
2739 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
2740 return DRVAESDMA_FAIL;
2741 }
2742
2743 return DRVAESDMA_OK;
2744 #else
2745 return _MDrv_AESDMA_Init(u32miu0addr, u32miu1addr, u32miunum);
2746 #endif
2747 }
2748
MDrv_AESDMA_QueryCipherMode(DrvAESDMA_CipherMode eMode)2749 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_QueryCipherMode(DrvAESDMA_CipherMode eMode)
2750 {
2751 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
2752 return DRVAESDMA_OK;
2753 }
2754
2755
_MDrv_AESDMA_SelEng(DrvAESDMA_CipherMode eMode,MS_BOOL bDescrypt)2756 DRVAESDMA_RESULT _MDrv_AESDMA_SelEng(DrvAESDMA_CipherMode eMode, MS_BOOL bDescrypt)
2757 {
2758 //DRV_CIPHER_ALGO stAlgo;
2759 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Cipher mode[%d], Decrypt[%d]!", eMode, bDescrypt);
2760
2761 bDES_Key = FALSE;
2762 switch(eMode)
2763 {
2764 case E_DRVAESDMA_CIPHER_ECB:
2765 _stAlgo.eMainAlgo = E_CIPHER_MAIN_AES;
2766 _stAlgo.eSubAlgo = E_CIPHER_SUB_ECB;
2767 _stAlgo.eResAlgo = E_CIPHER_RES_CLR;
2768 _stAlgo.eSBAlgo = E_CIPHER_SB_CLR;
2769 break;
2770 case E_DRVAESDMA_CIPHER_CTR:
2771 _stAlgo.eMainAlgo = E_CIPHER_MAIN_AES;
2772 _stAlgo.eSubAlgo = E_CIPHER_SUB_CTR;
2773 _stAlgo.eResAlgo = E_CIPHER_RES_CLR;
2774 _stAlgo.eSBAlgo = E_CIPHER_SB_CLR;
2775 break;
2776 case E_DRVAESDMA_CIPHER_CBC:
2777 _stAlgo.eMainAlgo = E_CIPHER_MAIN_AES;
2778 _stAlgo.eSubAlgo = E_CIPHER_SUB_CBC;
2779 _stAlgo.eResAlgo = E_CIPHER_RES_CLR;
2780 _stAlgo.eSBAlgo = E_CIPHER_SB_CLR;
2781 break;
2782 case E_DRVAESDMA_CIPHER_DES_ECB:
2783 _stAlgo.eMainAlgo = E_CIPHER_MAIN_DES;
2784 _stAlgo.eSubAlgo = E_CIPHER_SUB_ECB;
2785 _stAlgo.eResAlgo = E_CIPHER_RES_CLR;
2786 _stAlgo.eSBAlgo = E_CIPHER_SB_CLR;
2787 bDES_Key = TRUE;
2788 break;
2789 case E_DRVAESDMA_CIPHER_DES_CTR:
2790 _stAlgo.eMainAlgo = E_CIPHER_MAIN_DES;
2791 _stAlgo.eSubAlgo = E_CIPHER_SUB_CTR;
2792 _stAlgo.eResAlgo = E_CIPHER_RES_CLR;
2793 _stAlgo.eSBAlgo = E_CIPHER_SB_CLR;
2794 bDES_Key = TRUE;
2795 break;
2796 case E_DRVAESDMA_CIPHER_DES_CBC:
2797 _stAlgo.eMainAlgo = E_CIPHER_MAIN_DES;
2798 _stAlgo.eSubAlgo = E_CIPHER_SUB_CBC;
2799 _stAlgo.eResAlgo = E_CIPHER_RES_CLR;
2800 _stAlgo.eSBAlgo = E_CIPHER_SB_CLR;
2801 bDES_Key = TRUE;
2802 break;
2803 case E_DRVAESDMA_CIPHER_TDES_ECB:
2804 _stAlgo.eMainAlgo = E_CIPHER_MAIN_TDES;
2805 _stAlgo.eSubAlgo = E_CIPHER_SUB_ECB;
2806 _stAlgo.eResAlgo = E_CIPHER_RES_CLR;
2807 _stAlgo.eSBAlgo = E_CIPHER_SB_CLR;
2808 break;
2809 case E_DRVAESDMA_CIPHER_TDES_CTR:
2810 _stAlgo.eMainAlgo = E_CIPHER_MAIN_TDES;
2811 _stAlgo.eSubAlgo = E_CIPHER_SUB_CTR;
2812 _stAlgo.eResAlgo = E_CIPHER_RES_CLR;
2813 _stAlgo.eSBAlgo = E_CIPHER_SB_CLR;
2814 break;
2815 case E_DRVAESDMA_CIPHER_TDES_CBC:
2816 _stAlgo.eMainAlgo = E_CIPHER_MAIN_TDES;
2817 _stAlgo.eSubAlgo = E_CIPHER_SUB_CBC;
2818 _stAlgo.eResAlgo = E_CIPHER_RES_CLR;
2819 _stAlgo.eSBAlgo = E_CIPHER_SB_CLR;
2820 break;
2821 case E_DRVAESDMA_CIPHER_CTS_CBC:
2822 _stAlgo.eMainAlgo = E_CIPHER_MAIN_AES;
2823 _stAlgo.eSubAlgo = E_CIPHER_SUB_CBC;
2824 _stAlgo.eResAlgo = E_CIPHER_RES_CTS;
2825 _stAlgo.eSBAlgo = E_CIPHER_SB_CLR;
2826 break;
2827 case E_DRVAESDMA_CIPHER_CTS_ECB:
2828 _stAlgo.eMainAlgo = E_CIPHER_MAIN_AES;
2829 _stAlgo.eSubAlgo = E_CIPHER_SUB_ECB;
2830 _stAlgo.eResAlgo = E_CIPHER_RES_CTS;
2831 _stAlgo.eSBAlgo = E_CIPHER_SB_CLR;
2832 break;
2833 case E_DRVAESDMA_CIPHER_DES_CTS_CBC:
2834 _stAlgo.eMainAlgo = E_CIPHER_MAIN_DES;
2835 _stAlgo.eSubAlgo = E_CIPHER_SUB_CBC;
2836 _stAlgo.eResAlgo = E_CIPHER_RES_CTS;
2837 _stAlgo.eSBAlgo = E_CIPHER_SB_CLR;
2838 bDES_Key = TRUE;
2839 break;
2840
2841 case E_DRVAESDMA_CIPHER_DES_CTS_ECB:
2842 _stAlgo.eMainAlgo = E_CIPHER_MAIN_DES;
2843 _stAlgo.eSubAlgo = E_CIPHER_SUB_ECB;
2844 _stAlgo.eResAlgo = E_CIPHER_RES_CTS;
2845 _stAlgo.eSBAlgo = E_CIPHER_SB_CLR;
2846 bDES_Key = TRUE;
2847 break;
2848 case E_DRVAESDMA_CIPHER_TDES_CTS_CBC:
2849 _stAlgo.eMainAlgo = E_CIPHER_MAIN_TDES;
2850 _stAlgo.eSubAlgo = E_CIPHER_SUB_CBC;
2851 _stAlgo.eResAlgo = E_CIPHER_RES_CTS;
2852 _stAlgo.eSBAlgo = E_CIPHER_SB_CLR;
2853 break;
2854 case E_DRVAESDMA_CIPHER_TDES_CTS_ECB:
2855 _stAlgo.eMainAlgo = E_CIPHER_MAIN_TDES;
2856 _stAlgo.eSubAlgo = E_CIPHER_SUB_ECB;
2857 _stAlgo.eResAlgo = E_CIPHER_RES_CTS;
2858 _stAlgo.eSBAlgo = E_CIPHER_SB_CLR;
2859 break;
2860 default:
2861 _stAlgo.eMainAlgo = 0;
2862 _stAlgo.eSubAlgo = 0;
2863 _stAlgo.eResAlgo = 0;
2864 _stAlgo.eSBAlgo = 0;
2865 break;
2866 }
2867
2868 _isDecrypt = bDescrypt;
2869
2870 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Algo 0x%x 0x%x 0x%x 0x%x",
2871 _stAlgo.eMainAlgo, _stAlgo.eSubAlgo,_stAlgo.eResAlgo,_stAlgo.eSBAlgo);
2872
2873 return 0;
2874 }
2875
MDrv_AESDMA_SelEng(DrvAESDMA_CipherMode eMode,MS_BOOL bDescrypt)2876 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_SelEng(DrvAESDMA_CipherMode eMode, MS_BOOL bDescrypt)
2877 {
2878 #if CIPHER_UTOPIA2
2879 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
2880 AESDMA_SEL_ENG pArgs;
2881 if(pu32AesdmaInst == NULL)
2882 {
2883 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
2884 return DRVAESDMA_FAIL;
2885 }
2886
2887 pArgs.eMode = eMode;
2888 pArgs.bDescrypt = bDescrypt;
2889
2890 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_SelEng, (void*)&pArgs);
2891 if(UTOPIA_STATUS_SUCCESS != u32Ret)
2892 {
2893 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
2894 return DRVAESDMA_FAIL;
2895 }
2896
2897 return DRVAESDMA_OK;
2898 #else
2899 return _MDrv_AESDMA_SelEng(eMode, bDescrypt);
2900 #endif
2901 }
2902
_MDrv_AESDMA_SetKey_Ex(const MS_U8 * pu8Key,MS_U32 u32Len)2903 DRVAESDMA_RESULT _MDrv_AESDMA_SetKey_Ex(const MS_U8 *pu8Key, MS_U32 u32Len)
2904 {
2905 DRVAESDMA_RESULT ret = DRVAESDMA_OK;
2906 if(pu8Key && (u32Len <= HAL_CRYPTODMA_KEYLEN_MAX) && (u32Len > 0))
2907 {
2908 // Key from ACPU
2909 _CipherKey.eKeySrc = E_CIPHER_KSRC_CPU;
2910
2911 memcpy(_u8Key, (MS_U8*)pu8Key, u32Len);
2912 _CipherKey.pu8KeyData = _u8Key;
2913
2914 _CipherKey.u8KeyLen = u32Len;
2915 _CipherKey.u8KeyIdx = 0;
2916 }
2917 else
2918 {
2919 //Key from KL
2920 _CipherKey.eKeySrc = E_CIPHER_KSRC_KL;
2921 _CipherKey.pu8KeyData = 0;
2922 _CipherKey.u8KeyLen = 0;
2923 _CipherKey.u8KeyIdx = 0; // always use 0
2924 }
2925
2926 if(u32Len > HAL_CRYPTODMA_KEYLEN_MAX)
2927 {
2928 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Invalid Key Length!");
2929 ret = DRVAESDMA_INVALID_PARAM;
2930 }
2931
2932 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Key Source[%d], Key Length[%u], Key Index[%u]",
2933 _CipherKey.eKeySrc, _CipherKey.u8KeyLen, _CipherKey.u8KeyIdx);
2934
2935 return ret;
2936 }
2937
MDrv_AESDMA_SetKey_Ex(const MS_U8 * pu8Key,MS_U32 u32Len)2938 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_SetKey_Ex(const MS_U8 *pu8Key, MS_U32 u32Len)
2939 {
2940 #if CIPHER_UTOPIA2
2941 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
2942 AESDMA_SET_KEY_EX pArgs;
2943 if(pu32AesdmaInst == NULL)
2944 {
2945 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
2946 return DRVAESDMA_FAIL;
2947 }
2948
2949 pArgs.pu8Key = pu8Key;
2950 pArgs.u32Len = u32Len;
2951
2952 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_SetKey_Ex, (void*)&pArgs);
2953 if(UTOPIA_STATUS_SUCCESS != u32Ret)
2954 {
2955 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
2956 return DRVAESDMA_FAIL;
2957 }
2958
2959 return DRVAESDMA_OK;
2960 #else
2961 return _MDrv_AESDMA_SetKey_Ex(pu8Key, u32Len);
2962 #endif
2963
2964 }
2965
_MDrv_AESDMA_SetIV_Ex(const MS_U8 * pu8IV,MS_U32 u32Len)2966 DRVAESDMA_RESULT _MDrv_AESDMA_SetIV_Ex(const MS_U8 *pu8IV, MS_U32 u32Len)
2967 {
2968 DRVAESDMA_RESULT ret = DRVAESDMA_OK;
2969
2970 if(pu8IV && (u32Len <= HAL_CRYPTODMA_KEYLEN_MAX) && (u32Len > 0))
2971 {
2972 memcpy(_u8IV, pu8IV, u32Len);
2973 _CipherKey.pu8IVData = _u8IV;
2974 _CipherKey.u8IVLen = u32Len;
2975 }
2976 else
2977 {
2978 _CipherKey.pu8IVData = 0;
2979 _CipherKey.u8IVLen = 0;
2980 }
2981
2982 if(u32Len > HAL_CRYPTODMA_KEYLEN_MAX)
2983 {
2984 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Invalid IV Length!");
2985 ret = DRVAESDMA_INVALID_PARAM;
2986 }
2987
2988 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:IV Length[%u]", _CipherKey.u8IVLen);
2989
2990 return ret;
2991 }
2992
MDrv_AESDMA_SetIV_Ex(const MS_U8 * pu8IV,MS_U32 u32Len)2993 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_SetIV_Ex(const MS_U8 *pu8IV, MS_U32 u32Len)
2994 {
2995 #if CIPHER_UTOPIA2
2996 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
2997 AESDMA_SET_IV_EX pArgs;
2998 if(pu32AesdmaInst == NULL)
2999 {
3000 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
3001 return DRVAESDMA_FAIL;
3002 }
3003
3004 pArgs.pu8IV = pu8IV;
3005 pArgs.u32Len = u32Len;
3006
3007 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_SetIV_Ex, (void*)&pArgs);
3008 if(UTOPIA_STATUS_SUCCESS != u32Ret)
3009 {
3010 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
3011 return DRVAESDMA_FAIL;
3012 }
3013
3014 return DRVAESDMA_OK;
3015 #else
3016 return _MDrv_AESDMA_SetIV_Ex(pu8IV, u32Len);
3017 #endif
3018 }
3019
_MDrv_AESDMA_SetKey(MS_U32 * pCipherKey)3020 DRVAESDMA_RESULT _MDrv_AESDMA_SetKey(MS_U32 *pCipherKey)
3021 {
3022 if(pCipherKey)
3023 {
3024 MS_U32 u32Tmp[4] = {0};
3025 if(!bDES_Key)
3026 {
3027 u32Tmp[3] = _AESDMA_MSBF2Native((MS_U8 *)pCipherKey);
3028 u32Tmp[2] = _AESDMA_MSBF2Native((MS_U8 *)pCipherKey + 4);
3029 u32Tmp[1] = _AESDMA_MSBF2Native((MS_U8 *)pCipherKey + 8);
3030 u32Tmp[0] = _AESDMA_MSBF2Native((MS_U8 *)pCipherKey + 12);
3031 }
3032 else
3033 {
3034 u32Tmp[1] = _AESDMA_MSBF2Native((MS_U8 *)pCipherKey);
3035 u32Tmp[0] = _AESDMA_MSBF2Native((MS_U8 *)pCipherKey + 4);
3036
3037 }
3038 // Key from ACPU
3039 _CipherKey.eKeySrc = E_CIPHER_KSRC_CPU;
3040
3041 memcpy(_u8Key,(MS_U8 *)u32Tmp, 16);
3042 _CipherKey.pu8KeyData = _u8Key;
3043 _CipherKey.u8KeyLen = 16;
3044 _CipherKey.u8KeyIdx = 0;
3045 }
3046 else
3047 {
3048 //Key from KL
3049 memset(_u8Key, 0, 16);
3050 _CipherKey.eKeySrc = E_CIPHER_KSRC_KL;
3051 _CipherKey.pu8KeyData = 0;
3052 _CipherKey.u8KeyLen = 16;
3053 _CipherKey.u8KeyIdx = 0;
3054 }
3055
3056 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Key Source[%d], Key Length[%u], Key Index[%u], DES Key[%d]",
3057 _CipherKey.eKeySrc, _CipherKey.u8KeyLen, _CipherKey.u8KeyIdx, bDES_Key);
3058
3059 return 0;
3060 }
3061
MDrv_AESDMA_SetKey(MS_U32 * pCipherKey)3062 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_SetKey(MS_U32 *pCipherKey)
3063 {
3064 #if CIPHER_UTOPIA2
3065 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
3066
3067 if(pu32AesdmaInst == NULL)
3068 {
3069 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
3070 return DRVAESDMA_FAIL;
3071 }
3072
3073 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_SetKey, pCipherKey);
3074 if(UTOPIA_STATUS_SUCCESS != u32Ret)
3075 {
3076 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
3077 return DRVAESDMA_FAIL;
3078 }
3079
3080 return DRVAESDMA_OK;
3081 #else
3082 return _MDrv_AESDMA_SetKey(pCipherKey);
3083 #endif
3084 }
3085
MDrv_AESDMA_SetKeySel(MS_U32 * pCipherKey,DrvAESDMA_KEY_TYPE stKeyType)3086 DRVAESDMA_RESULT MDrv_AESDMA_SetKeySel(MS_U32 *pCipherKey, DrvAESDMA_KEY_TYPE stKeyType)
3087 {
3088 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3089 return DRVAESDMA_OK;
3090 }
3091
MDrv_AESDMA_SetOddIV(MS_U32 * pInitVector)3092 DRVAESDMA_RESULT MDrv_AESDMA_SetOddIV(MS_U32 *pInitVector)
3093 {
3094 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3095 return DRVAESDMA_OK;
3096 }
3097
_MDrv_AESDMA_SetSecureKey(void)3098 DRVAESDMA_RESULT _MDrv_AESDMA_SetSecureKey(void)
3099 {
3100 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3101 return DRVAESDMA_OK;
3102 }
3103
MDrv_AESDMA_SetSecureKey(void)3104 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_SetSecureKey(void)
3105 {
3106 #if CIPHER_UTOPIA2
3107 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
3108 if(pu32AesdmaInst == NULL)
3109 {
3110 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
3111 return DRVAESDMA_FAIL;
3112 }
3113
3114 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_SetSecureKey, NULL);
3115 if(UTOPIA_STATUS_SUCCESS != u32Ret)
3116 {
3117 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
3118 return DRVAESDMA_FAIL;
3119 }
3120
3121 return DRVAESDMA_OK;
3122 #else
3123 return _MDrv_AESDMA_SetSecureKey();
3124 #endif
3125 }
3126
MDrv_AESDMA_SetSecuredKeyIndex(MS_U8 u8KeyIdx)3127 DRVAESDMA_RESULT SYMBOL_WEAK MDrv_AESDMA_SetSecuredKeyIndex (MS_U8 u8KeyIdx)
3128 {
3129 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3130 return DRVAESDMA_OK;
3131 }
3132
_MDrv_AESDMA_SetIV(MS_U32 * pInitVector)3133 DRVAESDMA_RESULT _MDrv_AESDMA_SetIV(MS_U32 *pInitVector)
3134 {
3135 if(pInitVector)
3136 {
3137 MS_U32 u32Tmp[4] = {0};
3138 if(!bDES_Key)
3139 {
3140 u32Tmp[3] = _AESDMA_MSBF2Native((MS_U8 *)pInitVector);
3141 u32Tmp[2] = _AESDMA_MSBF2Native((MS_U8 *)pInitVector + 4);
3142 u32Tmp[1] = _AESDMA_MSBF2Native((MS_U8 *)pInitVector + 8);
3143 u32Tmp[0] = _AESDMA_MSBF2Native((MS_U8 *)pInitVector + 12);
3144 }
3145 else
3146 {
3147 u32Tmp[1] = _AESDMA_MSBF2Native((MS_U8 *)pInitVector);
3148 u32Tmp[0] = _AESDMA_MSBF2Native((MS_U8 *)pInitVector + 4);
3149 }
3150 memcpy(_u8IV,(MS_U8 *)u32Tmp, 16);
3151 _CipherKey.pu8IVData = _u8IV;
3152 _CipherKey.u8IVLen = 16;
3153 }
3154 else
3155 {
3156 memset(_u8IV, 0, 16);
3157 _CipherKey.pu8IVData = 0;
3158 _CipherKey.u8IVLen = 0;
3159 }
3160
3161 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:IV Length[%u], DES IV[%d]", _CipherKey.u8IVLen, bDES_Key);
3162
3163 return 0;
3164 }
3165
MDrv_AESDMA_SetIV(MS_U32 * pInitVector)3166 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_SetIV(MS_U32 *pInitVector)
3167 {
3168 #if CIPHER_UTOPIA2
3169 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
3170 if(pu32AesdmaInst == NULL)
3171 {
3172 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
3173 return DRVAESDMA_FAIL;
3174 }
3175
3176 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_SetIV, pInitVector);
3177 if(UTOPIA_STATUS_SUCCESS != u32Ret)
3178 {
3179 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
3180 return DRVAESDMA_FAIL;
3181 }
3182
3183 return DRVAESDMA_OK;
3184 #else
3185 return _MDrv_AESDMA_SetIV(pInitVector);
3186 #endif
3187
3188 }
3189
_MDrv_AESDMA_SetPS(MS_U32 u32PTN,MS_U32 u32Mask,MS_BOOL bPSin_Enable,MS_BOOL bPSout_Enable)3190 DRVAESDMA_RESULT _MDrv_AESDMA_SetPS(MS_U32 u32PTN, MS_U32 u32Mask, MS_BOOL bPSin_Enable, MS_BOOL bPSout_Enable)
3191 {
3192 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3193 return DRVAESDMA_OK;
3194 }
3195
MDrv_AESDMA_SetPS(MS_U32 u32PTN,MS_U32 u32Mask,MS_BOOL bPSin_Enable,MS_BOOL bPSout_Enable)3196 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_SetPS(MS_U32 u32PTN, MS_U32 u32Mask, MS_BOOL bPSin_Enable, MS_BOOL bPSout_Enable)
3197 {
3198 #if CIPHER_UTOPIA2
3199 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
3200 AESDMA_SET_PS pArgs;
3201 if(pu32AesdmaInst == NULL)
3202 {
3203 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
3204 return DRVAESDMA_FAIL;
3205 }
3206
3207 pArgs.u32PTN = u32PTN;
3208 pArgs.u32Mask = u32Mask;
3209 pArgs.bPSin_Enable = bPSin_Enable;
3210 pArgs.bPSout_Enable = bPSout_Enable;
3211
3212 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_SetPS, (void*)&pArgs);
3213 if(UTOPIA_STATUS_SUCCESS != u32Ret)
3214 {
3215 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
3216 return DRVAESDMA_FAIL;
3217 }
3218
3219 return DRVAESDMA_OK;
3220 #else
3221 return _MDrv_AESDMA_SetPS(u32PTN, u32Mask, bPSin_Enable, bPSout_Enable);
3222 #endif
3223 }
3224
_MDrv_AESDMA_SetDefaultCAVid(MS_U32 u32CAVid)3225 DRVAESDMA_RESULT _MDrv_AESDMA_SetDefaultCAVid(MS_U32 u32CAVid)
3226 {
3227 DEBUG_CIPHER(CIPHER_DBG_INFO, "Set CAVid [0x%x]",(unsigned int)u32CAVid);
3228
3229 if((u32CAVid > HAL_CRYPTODMA_CAVID_MAX) || (u32CAVid == 0))
3230 {
3231 return DRVAESDMA_INVALID_PARAM;
3232 }
3233
3234 _u32CAVid = u32CAVid;
3235
3236 return DRVAESDMA_OK;
3237 }
3238
MDrv_AESDMA_SetDefaultCAVid(MS_U32 u32CAVid)3239 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_SetDefaultCAVid(MS_U32 u32CAVid)
3240 {
3241 #if CIPHER_UTOPIA2
3242 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
3243 AESDMA_CAVID pArgs;
3244 if(pu32AesdmaInst == NULL)
3245 {
3246 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
3247 return DRVAESDMA_FAIL;
3248 }
3249
3250 pArgs.u32CAVid = u32CAVid;
3251
3252 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_SetDefaultCAVid, (void*)&pArgs);
3253 if(UTOPIA_STATUS_SUCCESS != u32Ret)
3254 {
3255 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
3256 return DRVAESDMA_FAIL;
3257 }
3258
3259 return DRVAESDMA_OK;
3260 #else
3261 return _MDrv_AESDMA_SetDefaultCAVid(u32CAVid);
3262 #endif
3263 }
3264
3265
_MDrv_AESDMA_PSRelease(void)3266 DRVAESDMA_RESULT _MDrv_AESDMA_PSRelease(void)
3267 {
3268 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3269 return DRVAESDMA_OK;
3270 }
3271
MDrv_AESDMA_PSRelease(void)3272 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_PSRelease(void)
3273 {
3274 #if CIPHER_UTOPIA2
3275 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
3276 if(pu32AesdmaInst == NULL)
3277 {
3278 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
3279 return DRVAESDMA_FAIL;
3280 }
3281
3282 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_PSRelease, NULL);
3283 if(UTOPIA_STATUS_SUCCESS != u32Ret)
3284 {
3285 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
3286 return DRVAESDMA_FAIL;
3287 }
3288
3289 return DRVAESDMA_OK;
3290 #else
3291 return _MDrv_AESDMA_PSRelease();
3292 #endif
3293 }
3294
_MDrv_AESDMA_SetFileInOut(MS_PHY u32FileinAddr,MS_U32 u32FileInNum,MS_PHY u32FileOutSAddr,MS_PHY u32FileOutEAddr)3295 DRVAESDMA_RESULT _MDrv_AESDMA_SetFileInOut(MS_PHY u32FileinAddr, MS_U32 u32FileInNum, MS_PHY u32FileOutSAddr, MS_PHY u32FileOutEAddr)
3296 {
3297
3298 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:FileIn address[0x%x], FileIn num[0x%x], FileOut start address[0x%x], FileOut end address[0x%x]",
3299 (unsigned int)u32FileinAddr,
3300 (unsigned int)u32FileInNum,
3301 (unsigned int)u32FileOutSAddr,
3302 (unsigned int)u32FileOutEAddr);
3303
3304 _stInput.u32Addr = u32FileinAddr;
3305 _stInput.u32Size = u32FileInNum;
3306 _stInput.eMemoryType = E_CIPHER_DRAM;
3307
3308 _stOutput.u32Addr = u32FileOutSAddr;
3309 _stOutput.u32Size = (u32FileOutEAddr - u32FileOutSAddr) + 1;
3310 _stOutput.eMemoryType = E_CIPHER_DRAM;
3311
3312 return 0;
3313 }
3314
MDrv_AESDMA_SetFileInOut(MS_PHY u32FileinAddr,MS_U32 u32FileInNum,MS_PHY u32FileOutSAddr,MS_PHY u32FileOutEAddr)3315 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_SetFileInOut(MS_PHY u32FileinAddr, MS_U32 u32FileInNum, MS_PHY u32FileOutSAddr, MS_PHY u32FileOutEAddr)
3316 {
3317 #if CIPHER_UTOPIA2
3318 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
3319 AESDMA_FILE_INOUT pArgs;
3320 if(pu32AesdmaInst == NULL)
3321 {
3322 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
3323 return DRVAESDMA_FAIL;
3324 }
3325
3326 pArgs.u32FileinAddr = u32FileinAddr;
3327 pArgs.u32FileInNum = u32FileInNum;
3328 pArgs.u32FileOutSAddr = u32FileOutSAddr;
3329 pArgs.u32FileOutEAddr = u32FileOutEAddr;
3330
3331 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_SetFileInOut, (void*)&pArgs);
3332 if(UTOPIA_STATUS_SUCCESS != u32Ret)
3333 {
3334 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
3335 return DRVAESDMA_FAIL;
3336 }
3337
3338 return DRVAESDMA_OK;
3339 #else
3340 return _MDrv_AESDMA_SetFileInOut(u32FileinAddr, u32FileInNum, u32FileOutSAddr, u32FileOutEAddr);
3341 #endif
3342 }
3343
_MDrv_AESDMA_Start(MS_BOOL bStart)3344 DRVAESDMA_RESULT _MDrv_AESDMA_Start(MS_BOOL bStart)
3345 {
3346 DRV_CIPHER_DMACFG stCfg = {{0}};
3347 DRV_CIPHER_RET ret = DRV_CIPHER_OK;
3348 MsOS_FlushMemory();
3349
3350 stCfg.stAlgo = _stAlgo;
3351 stCfg.u32CAVid = _u32CAVid;
3352 stCfg.stKey = _CipherKey;
3353 stCfg.stInput = _stInput;
3354 stCfg.stOutput = _stOutput;
3355
3356 stCfg.bDecrypt = _isDecrypt;
3357
3358 ret = MDrv_CIPHER_DMACalc(stCfg, &_RetId);
3359
3360 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Decrypt[%d], CmdId[%u]!", _isDecrypt, _RetId);
3361
3362 return ret;
3363 }
3364
MDrv_AESDMA_Start(MS_BOOL bStart)3365 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_Start(MS_BOOL bStart)
3366 {
3367 #if CIPHER_UTOPIA2
3368 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
3369 if(pu32AesdmaInst == NULL)
3370 {
3371 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
3372 return DRVAESDMA_FAIL;
3373 }
3374
3375 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_Start, &bStart);
3376 if(UTOPIA_STATUS_SUCCESS != u32Ret)
3377 {
3378 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
3379 return DRVAESDMA_FAIL;
3380 }
3381
3382 return DRVAESDMA_OK;
3383 #else
3384 return _MDrv_AESDMA_Start(bStart);
3385 #endif
3386 }
3387
_MDrv_AESDMA_Reset(void)3388 DRVAESDMA_RESULT _MDrv_AESDMA_Reset(void)
3389 {
3390 DRV_CIPHER_RET ret = DRV_CIPHER_OK;
3391 ret = MDrv_CIPHER_Reset();
3392
3393 if(DRV_CIPHER_OK != ret)
3394 return ret;
3395
3396 // Default Key from ACPU
3397 _CipherKey.eKeySrc = E_CIPHER_KSRC_CPU;
3398 _CipherKey.pu8KeyData = _u8ZeroData;
3399 _CipherKey.u8KeyLen = 16;
3400 _CipherKey.u8KeyIdx = 0;
3401
3402 //Clear IV
3403 _CipherKey.pu8IVData = _u8ZeroData;
3404 _CipherKey.u8IVLen = 16;
3405
3406 //Clear Algo
3407 _stAlgo.eMainAlgo = 0;
3408 _stAlgo.eSubAlgo = 0;
3409 _stAlgo.eResAlgo = 0;
3410 _stAlgo.eSBAlgo = 0;
3411
3412 //Clear Input
3413 _stInput.u32Addr = 0;
3414 _stInput.u32Size = 0;
3415 _stInput.eMemoryType = 0;
3416
3417 //Clear Output
3418 _stOutput.u32Addr = 0;
3419 _stOutput.u32Size = 0;
3420 _stOutput.eMemoryType = 0;
3421
3422 memset(_u8Key, 0, sizeof(_u8Key));
3423 memset(_u8IV, 0, sizeof(_u8IV));
3424
3425 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:AESDMA Reset");
3426
3427 return 0;
3428 }
3429
MDrv_AESDMA_Reset(void)3430 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_Reset(void)
3431 {
3432 #if CIPHER_UTOPIA2
3433 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
3434
3435 if(pu32AesdmaInst == NULL)
3436 {
3437 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
3438 return DRVAESDMA_FAIL;
3439 }
3440
3441 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_Reset, NULL);
3442 if(UTOPIA_STATUS_SUCCESS != u32Ret)
3443 {
3444 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
3445 return DRVAESDMA_FAIL;
3446 }
3447
3448 return DRVAESDMA_OK;
3449 #else
3450 return _MDrv_AESDMA_Reset();
3451 #endif
3452
3453 }
3454
_MDrv_AESDMA_GetStatus(MS_U32 * u32RetVal)3455 DRVAESDMA_RESULT _MDrv_AESDMA_GetStatus(MS_U32 *u32RetVal)
3456 {
3457 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3458 return DRVAESDMA_OK;
3459 }
3460
MDrv_AESDMA_GetStatus(void)3461 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_GetStatus(void)
3462 {
3463 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3464 return DRVAESDMA_OK;
3465 }
3466
_MDrv_AESDMA_IsFinished(MS_U32 * u32RetVal)3467 DRVAESDMA_RESULT _MDrv_AESDMA_IsFinished(MS_U32 *u32RetVal)
3468 {
3469 MS_BOOL bDone = FALSE;
3470 MS_U32 u32Ret = 0;
3471
3472 bDone = MDrv_CIPHER_IsDMADone(_RetId, &u32Ret);
3473
3474 if(TRUE == bDone)
3475 {
3476 return DRVAESDMA_OK;
3477 }
3478 else
3479 {
3480 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning:CmdId[%u] Not Done!", _RetId);
3481 return DRVAESDMA_FAIL;
3482 }
3483 }
3484
MDrv_AESDMA_IsFinished(void)3485 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_IsFinished(void)
3486 {
3487 #if CIPHER_UTOPIA2
3488 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
3489 if(pu32AesdmaInst == NULL)
3490 {
3491 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
3492 return DRVAESDMA_FAIL;
3493 }
3494
3495 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_IsFinished, NULL);
3496 if(UTOPIA_STATUS_SUCCESS != u32Ret)
3497 {
3498 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
3499 return DRVAESDMA_FAIL;
3500 }
3501
3502 return DRVAESDMA_OK;
3503 #else
3504 MS_U32 u32Tmp = 0;
3505 return _MDrv_AESDMA_IsFinished(&u32Tmp);
3506 #endif
3507 }
3508
_MDrv_AESDMA_GetPSMatchedByteCNT(MS_U32 * u32RetVal)3509 MS_U32 _MDrv_AESDMA_GetPSMatchedByteCNT(MS_U32 *u32RetVal)
3510 {
3511 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3512 return DRVAESDMA_OK;
3513 }
3514
MDrv_AESDMA_GetPSMatchedByteCNT(void)3515 DLL_PUBLIC MS_U32 MDrv_AESDMA_GetPSMatchedByteCNT(void)
3516 {
3517 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3518 return DRVAESDMA_OK;
3519 }
3520
_MDrv_AESDMA_GetPSMatchedPTN(void)3521 MS_U32 _MDrv_AESDMA_GetPSMatchedPTN(void)
3522 {
3523 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3524 return DRVAESDMA_OK;
3525 }
3526
MDrv_AESDMA_GetPSMatchedPTN(void)3527 DLL_PUBLIC MS_U32 MDrv_AESDMA_GetPSMatchedPTN(void)
3528 {
3529 #if CIPHER_UTOPIA2
3530 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
3531 if(pu32AesdmaInst == NULL)
3532 {
3533 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
3534 return DRVAESDMA_FAIL;
3535 }
3536
3537 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_GetPSMatchedPTN, NULL);
3538 if(UTOPIA_STATUS_SUCCESS != u32Ret)
3539 {
3540 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
3541 return DRVAESDMA_FAIL;
3542 }
3543
3544 return DRVAESDMA_OK;
3545 #else
3546 return _MDrv_AESDMA_GetPSMatchedPTN();
3547 #endif
3548 }
3549
_MDrv_AESDMA_Notify(DrvAESDMA_Event eEvents,P_DrvAESDMA_EvtCallback pfCallback)3550 DRVAESDMA_RESULT _MDrv_AESDMA_Notify(DrvAESDMA_Event eEvents, P_DrvAESDMA_EvtCallback pfCallback)
3551 {
3552 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3553 return DRVAESDMA_OK;
3554 }
3555
MDrv_AESDMA_Notify(DrvAESDMA_Event eEvents,P_DrvAESDMA_EvtCallback pfCallback)3556 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_Notify(DrvAESDMA_Event eEvents, P_DrvAESDMA_EvtCallback pfCallback)
3557 {
3558 #if CIPHER_UTOPIA2
3559 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
3560 AESDMA_NOTIFY pArgs;
3561 if(pu32AesdmaInst == NULL)
3562 {
3563 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
3564 return DRVAESDMA_FAIL;
3565 }
3566
3567 pArgs.eEvents = eEvents;
3568 pArgs.pfCallback = pfCallback;
3569
3570 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_Notify, (void*)&pArgs);
3571 if(UTOPIA_STATUS_SUCCESS != u32Ret)
3572 {
3573 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
3574 return DRVAESDMA_FAIL;
3575 }
3576
3577 return DRVAESDMA_OK;
3578 #else
3579 return _MDrv_AESDMA_Notify(eEvents, pfCallback);
3580 #endif
3581 }
3582
MDrv_AESDMA_SetDbgLevel(DrvAESDMA_DbgLevel DbgLevel)3583 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_SetDbgLevel(DrvAESDMA_DbgLevel DbgLevel)
3584 {
3585 CIPHER_DBGMSG_LEVEL eDbgLevel = _CIPHER_TransDbgLevel(DbgLevel);
3586
3587 MDrv_CIPHER_SetDbgLevel(eDbgLevel);
3588
3589 return DRVAESDMA_OK;
3590 }
3591
MDrv_AESDMA_GetLibVer(const MSIF_Version ** ppVersion)3592 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_GetLibVer(const MSIF_Version **ppVersion)
3593 {
3594 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3595 return DRVAESDMA_OK;
3596 }
3597
_MDrv_AESDMA_Rand(MS_U32 * u32PABuf,MS_U32 u32Size)3598 DRVAESDMA_RESULT _MDrv_AESDMA_Rand(MS_U32 *u32PABuf, MS_U32 u32Size)
3599 {
3600 if(NULL == u32PABuf || 0 == u32Size)
3601 {
3602 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Buffer or Size is zero!");
3603 return DRVAESDMA_INVALID_PARAM;
3604 }
3605
3606 ptrdiff_t n = (ptrdiff_t)u32PABuf;
3607 MS_VIRT u8VABuf = (MS_VIRT)MsOS_PA2KSEG1((MS_PHY)n);
3608
3609 if( FALSE == HAL_CIPHER_Misc_Random((MS_U8 *)u8VABuf,u32Size))
3610 {
3611 return DRVAESDMA_FAIL;
3612 }
3613
3614 return DRVAESDMA_OK;
3615 }
3616
MDrv_AESDMA_Rand(MS_U32 * u32PABuf,MS_U32 u32Size)3617 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_Rand(MS_U32 *u32PABuf, MS_U32 u32Size)
3618 {
3619 #if CIPHER_UTOPIA2
3620 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
3621 AESDMA_RAND pArgs;
3622 if(pu32AesdmaInst == NULL)
3623 {
3624 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
3625 return DRVAESDMA_FAIL;
3626 }
3627
3628 pArgs.u32PABuf = u32PABuf;
3629 pArgs.u32Size = u32Size;
3630
3631 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_Rand, (void*)&pArgs);
3632 if(UTOPIA_STATUS_SUCCESS != u32Ret)
3633 {
3634 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
3635 return DRVAESDMA_FAIL;
3636 }
3637
3638 return DRVAESDMA_OK;
3639 #else
3640 return _MDrv_AESDMA_Rand(u32PABuf, u32Size);
3641 #endif
3642 }
3643
3644
MDrv_AESDMA_Set_Clk(MS_BOOL benable)3645 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_Set_Clk(MS_BOOL benable)
3646 {
3647 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning:Not Support!");
3648 return 0;
3649 }
3650
_MDrv_SHA_Calculate(DrvAESDMA_SHAMode eMode,MS_PHY u32PAInBuf,MS_U32 u32Size,MS_PHY u32PAOutBuf)3651 DRVAESDMA_RESULT _MDrv_SHA_Calculate(DrvAESDMA_SHAMode eMode, MS_PHY u32PAInBuf, MS_U32 u32Size, MS_PHY u32PAOutBuf)
3652 {
3653 DRV_CIPHER_HASHCFG stCfg = {0};
3654 CIPHER_HASH_ALGO eAlgo = E_CIPHER_HASH_ALGO_SHA1;
3655 MS_U32 u32DgstSize = 20;
3656 MS_U32 u32Ret = 0;
3657 MS_U32 u32WaitCnt = 0;
3658
3659 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:eMode[%d], InBuffer[0x%08x], Size[%u], OutBuffer[0x%08x]!",
3660 eMode, (unsigned int)u32PAInBuf, u32Size, (unsigned int)u32PAOutBuf);
3661
3662 switch(eMode)
3663 {
3664 case E_DRVAESDMA_SHA1:
3665 eAlgo = E_CIPHER_HASH_ALGO_SHA1;
3666 u32DgstSize = 20;
3667 break;
3668 case E_DRVAESDMA_SHA256:
3669 eAlgo = E_CIPHER_HASH_ALGO_SHA256;
3670 u32DgstSize = 32;
3671 break;
3672 default:
3673 eAlgo = E_CIPHER_HASH_ALGO_SHA1;
3674 u32DgstSize = 20;
3675 }
3676
3677 stCfg.eAlgo = eAlgo;
3678 stCfg.stInput.u32Addr = u32PAInBuf;
3679 stCfg.stInput.u32Size = u32Size;
3680 stCfg.pu8Digest_Buf = (MS_U8*)(MsOS_PA2KSEG1(u32PAOutBuf));
3681 stCfg.u32Digest_Buf_Size = u32DgstSize;
3682
3683 if(DRV_CIPHER_OK != MDrv_CIPHER_HASH(stCfg, &_RetId))
3684 {
3685 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:HASH Fail!");
3686 return DRVAESDMA_FAIL;
3687 }
3688
3689 while((FALSE == MDrv_CIPHER_IsHASHDone(_RetId, &u32Ret)) && u32WaitCnt < HASH_TIMEOUT_VALUE)
3690 {
3691 #ifdef MSOS_TYPE_NUTTX
3692 MsOS_DelayTaskUs(200);
3693 #elif defined MSOS_TYPE_OPTEE
3694
3695 #else
3696 MsOS_DelayTask(20);
3697 #endif
3698 u32WaitCnt++;
3699 }
3700
3701 if(u32WaitCnt >= HASH_TIMEOUT_VALUE)
3702 {
3703 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning;HASH timeout!");
3704 return DRVAESDMA_FAIL;
3705 }
3706
3707 //Reverse MSB to LSB for old API compatible
3708 _ReverseU8Buf((MS_U8 *)stCfg.pu8Digest_Buf, u32DgstSize );
3709
3710 return DRVAESDMA_OK;
3711 }
3712
MDrv_SHA_Calculate(DrvAESDMA_SHAMode eMode,MS_PHY u32PAInBuf,MS_U32 u32Size,MS_PHY u32PAOutBuf)3713 DLL_PUBLIC DRVAESDMA_RESULT MDrv_SHA_Calculate(DrvAESDMA_SHAMode eMode, MS_PHY u32PAInBuf, MS_U32 u32Size, MS_PHY u32PAOutBuf)
3714 {
3715 #if CIPHER_UTOPIA2
3716 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
3717 SHA_CALCULATE pArgs;
3718 if(pu32AesdmaInst == NULL)
3719 {
3720 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
3721 return DRVAESDMA_FAIL;
3722 }
3723
3724 pArgs.eMode = eMode;
3725 pArgs.u32PAInBuf = u32PAInBuf;
3726 pArgs.u32Size = u32Size;
3727 pArgs.u32PAOutBuf = u32PAOutBuf;
3728
3729 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_SHA_Calculate, (void*)&pArgs);
3730 if(UTOPIA_STATUS_SUCCESS != u32Ret)
3731 {
3732 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
3733 return DRVAESDMA_FAIL;
3734 }
3735
3736 return DRVAESDMA_OK;
3737 #else
3738 return _MDrv_SHA_Calculate(eMode, u32PAInBuf, u32Size, u32PAOutBuf);
3739 #endif
3740 }
3741
_MDrv_SHA_CalculateManual(DrvAESDMA_HASHCFG stCfg,DrvAESDMA_HASH_STAGE eStage,MS_U32 u32DoneBytes,MS_U8 * pu8SetIV)3742 DRVAESDMA_RESULT _MDrv_SHA_CalculateManual(DrvAESDMA_HASHCFG stCfg, DrvAESDMA_HASH_STAGE eStage, MS_U32 u32DoneBytes, MS_U8 *pu8SetIV)
3743 {
3744 DRV_CIPHER_HASHCFG_MANUAL stCipherCfg = {0};
3745 CIPHER_HASH_ALGO eAlgo = E_CIPHER_HASH_ALGO_SHA1;
3746 MS_U32 u32DgstSize = 20;
3747 MS_U32 u32Ret = 0;
3748 MS_U32 u32WaitCnt = 0;
3749
3750 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:eMode[%d], Stage[%d], Done Bytes[%u]!",
3751 stCfg.eMode, eStage, u32DoneBytes);
3752 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:InAddress[0x%08x], InSize[%u], OutAddress[0x%08x], OutSize[%u]!",
3753 (unsigned int)stCfg.stInput.u32Addr, stCfg.stInput.u32Size, (unsigned int)stCfg.stOutput.u32Addr, stCfg.stOutput.u32Size);
3754
3755 switch(stCfg.eMode)
3756 {
3757 case E_DRVAESDMA_SHA1:
3758 eAlgo = E_CIPHER_HASH_ALGO_SHA1;
3759 u32DgstSize = 20;
3760 break;
3761 case E_DRVAESDMA_SHA256:
3762 eAlgo = E_CIPHER_HASH_ALGO_SHA256;
3763 u32DgstSize = 32;
3764 break;
3765 default:
3766 eAlgo = E_CIPHER_HASH_ALGO_SHA1;
3767 u32DgstSize = 20;
3768 }
3769
3770 //Algo
3771 stCipherCfg.eAlgo = eAlgo;
3772
3773 //Input
3774 stCipherCfg.stInput.u32Addr = stCfg.stInput.u32Addr;
3775 stCipherCfg.stInput.u32Size = stCfg.stInput.u32Size;
3776
3777 //Output
3778 stCipherCfg.pu8Digest_Buf = (MS_U8*)stCfg.stOutput.u32Addr;
3779 stCipherCfg.u32Digest_Buf_Size = stCfg.stOutput.u32Size;
3780
3781 //Stage
3782 stCipherCfg.eStage = eStage;
3783
3784 //StartBytes
3785 stCipherCfg.u32StartByte = u32DoneBytes;
3786
3787 //IV
3788 stCipherCfg.pu8SetIV = pu8SetIV;
3789
3790 if(DRV_CIPHER_OK != MDrv_CIPHER_HASHManual(stCipherCfg, &_RetId))
3791 {
3792 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:HASH Fail!");
3793 return DRVAESDMA_FAIL;
3794 }
3795
3796 while((FALSE == MDrv_CIPHER_IsHASHDone(_RetId, &u32Ret)) && u32WaitCnt < HASH_TIMEOUT_VALUE)
3797 {
3798 #ifdef MSOS_TYPE_NUTTX
3799 MsOS_DelayTaskUs(200);
3800 #elif defined MSOS_TYPE_OPTEE
3801
3802 #else
3803 MsOS_DelayTask(20);
3804 #endif
3805 u32WaitCnt++;
3806 }
3807
3808 if(u32WaitCnt >= HASH_TIMEOUT_VALUE)
3809 {
3810 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning;HASH timeout!");
3811 return DRVAESDMA_FAIL;
3812 }
3813
3814 //Reverse MSB to LSB for old API compatible
3815 if(eStage == E_DRVAESDMA_HASH_STAGE_LAST)
3816 {
3817 _ReverseU8Buf((MS_U8 *)stCipherCfg.pu8Digest_Buf, u32DgstSize );
3818 }
3819
3820 return DRVAESDMA_OK;
3821 }
3822
MDrv_SHA_CalculateManual(DrvAESDMA_HASHCFG stCfg,DrvAESDMA_HASH_STAGE eStage,MS_U32 u32DoneBytes,MS_U8 * pu8SetIV)3823 DLL_PUBLIC DRVAESDMA_RESULT MDrv_SHA_CalculateManual(DrvAESDMA_HASHCFG stCfg, DrvAESDMA_HASH_STAGE eStage, MS_U32 u32DoneBytes, MS_U8 *pu8SetIV)
3824 {
3825 #if CIPHER_UTOPIA2
3826 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
3827 SHA_CALCULATE_MANUAL pArgs;
3828 if(pu32AesdmaInst == NULL)
3829 {
3830 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
3831 return DRVAESDMA_FAIL;
3832 }
3833
3834 if(NULL != stCfg.stInput.u32Addr)
3835 {
3836 stCfg.stInput.u32Addr = MsOS_VA2PA(stCfg.stInput.u32Addr);
3837 }
3838 pArgs.stCfg = stCfg;
3839 pArgs.eStage = eStage;
3840 pArgs.u32DoneBytes = u32DoneBytes;
3841 pArgs.pu8SetIV = pu8SetIV;
3842
3843 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_SHA_CalculateManual, (void*)&pArgs);
3844 if(UTOPIA_STATUS_SUCCESS != u32Ret)
3845 {
3846 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
3847 return DRVAESDMA_FAIL;
3848 }
3849
3850 return DRVAESDMA_OK;
3851 #else
3852
3853 if(NULL != stCfg.stInput.u32Addr)
3854 {
3855 stCfg.stInput.u32Addr = MsOS_VA2PA(stCfg.stInput.u32Addr);
3856 }
3857 return _MDrv_SHA_CalculateManual(stCfg, eStage, u32DoneBytes, pu8SetIV);
3858 #endif
3859 }
3860
3861
3862 #ifdef MOBF_ENABLE
MDrv_MOBF_DmaOnly(void)3863 DLL_PUBLIC DRVAESDMA_RESULT MDrv_MOBF_DmaOnly(void)
3864 {
3865 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3866 return DRVAESDMA_OK;
3867 }
3868
MDrv_MOBF_Encrypt(MS_U32 u32Key,MS_BOOL bEnable)3869 DLL_PUBLIC DRVAESDMA_RESULT MDrv_MOBF_Encrypt(MS_U32 u32Key, MS_BOOL bEnable)
3870 {
3871 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3872 return DRVAESDMA_OK;
3873 }
3874
MDrv_MOBF_Decrypt(MS_U32 u32Key,MS_BOOL bEnable)3875 DLL_PUBLIC DRVAESDMA_RESULT MDrv_MOBF_Decrypt(MS_U32 u32Key, MS_BOOL bEnable)
3876 {
3877 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3878 return DRVAESDMA_OK;
3879 }
3880
MDrv_MOBF_OneWay(void)3881 DLL_PUBLIC DRVAESDMA_RESULT MDrv_MOBF_OneWay(void)
3882 {
3883 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3884 return DRVAESDMA_OK;
3885 }
3886 #endif
3887
MDrv_AESDMA_Parser_MaskScrmb(MS_BOOL bEnable)3888 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_Parser_MaskScrmb(MS_BOOL bEnable)
3889 {
3890 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3891 return DRVAESDMA_OK;
3892 }
3893
MDrv_AESDMA_Parser_SetScrmbPattern(DrvAESDMA_ScrmbPattern ePattern)3894 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_Parser_SetScrmbPattern(DrvAESDMA_ScrmbPattern ePattern)
3895 {
3896 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3897 return DRVAESDMA_OK;
3898 }
3899
MDrv_AESDMA_Parser_SetAddedScrmbPattern(DrvAESDMA_ScrmbPattern ePattern)3900 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_Parser_SetAddedScrmbPattern(DrvAESDMA_ScrmbPattern ePattern)
3901 {
3902 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3903 return DRVAESDMA_OK;
3904 }
3905
MDrv_AESDMA_Parser_QueryPidCount(void)3906 DLL_PUBLIC MS_U8 MDrv_AESDMA_Parser_QueryPidCount(void)
3907 {
3908 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3909 return DRVAESDMA_OK;
3910 }
3911
MDrv_AESDMA_Parser_SetPid(MS_U8 u8Index,MS_U16 u16Pid)3912 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_Parser_SetPid(MS_U8 u8Index, MS_U16 u16Pid)
3913 {
3914 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3915 return DRVAESDMA_OK;
3916 }
3917
MDrv_AESDMA_Parser_BypassPid(MS_BOOL bEnable)3918 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_Parser_BypassPid(MS_BOOL bEnable)
3919 {
3920 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3921 return DRVAESDMA_OK;
3922 }
3923
MDrv_AESDMA_Parser_Encrypt(DrvAESDMA_ParserMode eMode)3924 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_Parser_Encrypt(DrvAESDMA_ParserMode eMode)
3925 {
3926 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3927 return DRVAESDMA_OK;
3928 }
3929
MDrv_AESDMA_Parser_Decrypt(DrvAESDMA_ParserMode eMode)3930 DLL_PUBLIC DRVAESDMA_RESULT MDrv_AESDMA_Parser_Decrypt(DrvAESDMA_ParserMode eMode)
3931 {
3932 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
3933 return DRVAESDMA_OK;
3934 }
3935
MDrv_AESDMA_Lock(void)3936 DLL_PUBLIC MS_BOOL MDrv_AESDMA_Lock(void)
3937 {
3938 MsOS_ObtainMutex(_AESDMAMtx, MSOS_WAIT_FOREVER);
3939 return TRUE;
3940 }
3941
MDrv_AESDMA_Unlock(void)3942 DLL_PUBLIC MS_BOOL MDrv_AESDMA_Unlock(void)
3943 {
3944 MsOS_ReleaseMutex(_AESDMAMtx);
3945 return TRUE;
3946 }
3947
MDrv_AESDMA_SetPowerState(EN_POWER_MODE u16PowerState)3948 MS_U32 MDrv_AESDMA_SetPowerState(EN_POWER_MODE u16PowerState)
3949 {
3950 static EN_POWER_MODE u16PreAESDMAPowerState = E_POWER_MECHANICAL;
3951 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
3952
3953 if (u16PowerState == E_POWER_SUSPEND)
3954 {
3955 DEBUG_CIPHER(CIPHER_DBG_WARN, "Go to SUSPEND\n");
3956
3957 #if !defined (MSOS_TYPE_NOS) && !defined (MCU_AEON) && !defined (MSOS_TYPE_OPTEE)
3958 MsOS_DeleteEventGroup(_s32CIPHEREventId);
3959 #endif
3960 // MsOS_DeleteTask(_s32AESDMATaskId);
3961 MsOS_DeleteSemaphore(_CipherSemaphore);
3962 MsOS_DeleteMutex(_CipherMtx);
3963 MsOS_DeleteMutex(_AESDMAMtx);
3964
3965 u16PreAESDMAPowerState = u16PowerState;
3966 u32Return = UTOPIA_STATUS_SUCCESS;//SUSPEND_OK;
3967
3968 _bCIPHERDrv_Inited = FALSE;
3969 }
3970 else if (u16PowerState == E_POWER_RESUME)
3971 {
3972 if (u16PreAESDMAPowerState == E_POWER_SUSPEND)
3973 {
3974 DEBUG_CIPHER(CIPHER_DBG_WARN, "Go to RESUME\n");
3975 _bCIPHERDrv_Inited = FALSE;
3976 MDrv_CIPHER_Init();
3977
3978
3979 u16PreAESDMAPowerState = u16PowerState;
3980 u32Return = UTOPIA_STATUS_SUCCESS;//RESUME_OK;
3981 }
3982 else
3983 {
3984 DEBUG_CIPHER(CIPHER_DBG_ERR, "[%s,%5d]It is not suspended yet. We shouldn't resume\n",__FUNCTION__,__LINE__);
3985 u32Return = UTOPIA_STATUS_FAIL;//SUSPEND_FAILED;
3986 }
3987 }
3988 else
3989 {
3990 DEBUG_CIPHER(CIPHER_DBG_ERR, "[%s,%5d]Do Nothing: %d\n",__FUNCTION__,__LINE__,u16PowerState);
3991 u32Return = UTOPIA_STATUS_FAIL;
3992 }
3993
3994 return u32Return;// for success
3995
3996 }
3997
MDrv_AESDMA_Exit(void)3998 DRVAESDMA_RESULT MDrv_AESDMA_Exit(void)
3999 {
4000 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
4001 return DRVAESDMA_OK;
4002 }
4003
MDrv_AESDMA_IsSecretKeyInNormalBank(void)4004 DRVAESDMA_RESULT MDrv_AESDMA_IsSecretKeyInNormalBank(void)
4005 {
4006 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
4007 return DRVAESDMA_OK;
4008 }
4009
MDrv_AESDMA_EnableTwoKeys(MS_BOOL bEnable)4010 DRVAESDMA_RESULT MDrv_AESDMA_EnableTwoKeys(MS_BOOL bEnable)
4011 {
4012 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
4013 return DRVAESDMA_OK;
4014 }
4015
MDrv_AESDMA_SetOddKey(MS_U32 * pInitVector)4016 DRVAESDMA_RESULT MDrv_AESDMA_SetOddKey(MS_U32 *pInitVector)
4017 {
4018 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
4019 return DRVAESDMA_OK;
4020 }
4021
MDrv_AESDMA_ParserStart(MS_BOOL bStart)4022 DRVAESDMA_RESULT MDrv_AESDMA_ParserStart(MS_BOOL bStart)
4023 {
4024 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
4025 return DRVAESDMA_OK;
4026 }
4027
_MDrv_AESDMA_NormalReset(void)4028 DRVAESDMA_RESULT _MDrv_AESDMA_NormalReset(void)
4029 {
4030 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
4031 return DRVAESDMA_OK;
4032 }
4033
MDrv_AESDMA_NormalReset(void)4034 DRVAESDMA_RESULT MDrv_AESDMA_NormalReset(void)
4035 {
4036 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
4037 return DRVAESDMA_OK;
4038 }
4039
MDrv_HDCP_ProcessCipher(MS_U8 u8Idx,MS_U8 * pu8Riv,MS_U8 * pu8ContentKey)4040 DRVAESDMA_RESULT MDrv_HDCP_ProcessCipher(MS_U8 u8Idx, MS_U8* pu8Riv, MS_U8 *pu8ContentKey)
4041 {
4042 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
4043 return DRVAESDMA_OK;
4044 }
4045
MDrv_HDCP_GetHdcpCipherState(MS_U8 u8Idx,MS_U8 * pu8State)4046 DRVAESDMA_RESULT MDrv_HDCP_GetHdcpCipherState(MS_U8 u8Idx, MS_U8 *pu8State)
4047 {
4048 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
4049 return DRVAESDMA_OK;
4050 }
4051
MDrv_HDMI_GetM0(MS_U32 u32InputPortType,MS_U8 * pu8Data)4052 DRVAESDMA_RESULT MDrv_HDMI_GetM0(MS_U32 u32InputPortType, MS_U8 *pu8Data)
4053 {
4054 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
4055 return DRVAESDMA_OK;
4056 }
4057
_MDrv_AESDMA_SetKeyIndex(MS_U32 u32Index,MS_BOOL bIsOddKey)4058 DRVAESDMA_RESULT _MDrv_AESDMA_SetKeyIndex (MS_U32 u32Index, MS_BOOL bIsOddKey)
4059 {
4060 DRVAESDMA_RESULT ret = DRVAESDMA_OK;
4061
4062 if(HAL_CIPHER_KEYSLOT_BASE > u32Index || (HAL_CIPHER_KEYSLOT_BASE + HAL_CRYPTODMA_DMA_KEY_SLOT - 1) < u32Index)
4063 {
4064 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Invalid Key index[0x%04u]!", (unsigned int)u32Index);
4065 return DRVAESDMA_INVALID_PARAM;
4066 }
4067
4068 //Key from KL
4069 _CipherKey.eKeySrc = E_CIPHER_KSRC_KL;
4070 _CipherKey.pu8KeyData = 0;
4071 _CipherKey.u8KeyLen = 0;
4072 _CipherKey.u8KeyIdx = u32Index - HAL_CIPHER_KEYSLOT_BASE; //SK0:0x10, SK1:0x11
4073
4074 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:Key Source[%d], Key Length[%u], Key Index[%u]",
4075 _CipherKey.eKeySrc, _CipherKey.u8KeyLen, _CipherKey.u8KeyIdx);
4076
4077 return ret;
4078 }
4079
MDrv_AESDMA_SetKeyIndex(MS_U32 u32Index,MS_BOOL bIsOddKey)4080 DRVAESDMA_RESULT SYMBOL_WEAK MDrv_AESDMA_SetKeyIndex (MS_U32 u32Index, MS_BOOL bIsOddKey)
4081 {
4082 #if CIPHER_UTOPIA2
4083 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
4084 AESDMA_KEY_INDEX pArgs;
4085 if(pu32AesdmaInst == NULL)
4086 {
4087 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
4088 return DRVAESDMA_FAIL;
4089 }
4090
4091 pArgs.bOddKeyEn = bIsOddKey;
4092 pArgs.u32KeyIndex = u32Index;
4093
4094 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_Set_Key_Index, (void*)&pArgs);
4095 if(UTOPIA_STATUS_SUCCESS != u32Ret)
4096 {
4097 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
4098 return DRVAESDMA_FAIL;
4099 }
4100
4101 return DRVAESDMA_OK;
4102 #else
4103 return _MDrv_AESDMA_SetKeyIndex(u32Index, bIsOddKey);
4104 #endif
4105 }
4106
MDrv_AESDMA_SetAesCtr64(MS_BOOL bCtr64En)4107 DRVAESDMA_RESULT SYMBOL_WEAK MDrv_AESDMA_SetAesCtr64 (MS_BOOL bCtr64En)
4108 {
4109 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
4110 return DRVAESDMA_OK;
4111 }
4112
_MDrv_AESDMA_AllocKeySlot(MS_U32 * pu32Index)4113 DRVAESDMA_RESULT _MDrv_AESDMA_AllocKeySlot (MS_U32 *pu32Index)
4114 {
4115 MS_U32 i = 0;
4116
4117 if(NULL == pu32Index)
4118 {
4119 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:pu32Index is NULL");
4120 return DRVAESDMA_INVALID_PARAM;
4121 }
4122
4123 for(i = 0;i < HAL_CRYPTODMA_DMA_KEY_SLOT;i++)
4124 {
4125 if(FALSE == _CIPHER_Resource[i].bUsed)
4126 {
4127 _CIPHER_Resource[i].bUsed = TRUE;
4128 *pu32Index = i + HAL_CIPHER_KEYSLOT_BASE;
4129 break;
4130 }
4131 }
4132
4133 if(HAL_CRYPTODMA_DMA_KEY_SLOT == i)
4134 {
4135 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning:No empty key slot");
4136 return DRVAESDMA_FAIL;
4137 }
4138
4139 return DRVAESDMA_OK;
4140 }
4141
MDrv_AESDMA_AllocKeySlot(MS_U32 * pu32Index)4142 DRVAESDMA_RESULT SYMBOL_WEAK MDrv_AESDMA_AllocKeySlot (MS_U32 *pu32Index)
4143 {
4144 #if CIPHER_UTOPIA2
4145 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
4146 AESDMA_ALLOC_KEY_SLOT pArgs;
4147 if(pu32AesdmaInst == NULL)
4148 {
4149 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
4150 return DRVAESDMA_FAIL;
4151 }
4152
4153 pArgs.pu32KeyIndex = pu32Index;
4154
4155 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_AllocKeySlot, (void*)&pArgs);
4156 if(UTOPIA_STATUS_SUCCESS != u32Ret)
4157 {
4158 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
4159 return DRVAESDMA_FAIL;
4160 }
4161
4162 return DRVAESDMA_OK;
4163 #else
4164 return _MDrv_AESDMA_AllocKeySlot(pu32Index);
4165 #endif
4166
4167 }
4168
_MDrv_AESDMA_FreeKeySlot(MS_U32 u32Index)4169 DRVAESDMA_RESULT _MDrv_AESDMA_FreeKeySlot (MS_U32 u32Index)
4170 {
4171 MS_U32 i = 0;
4172
4173 if(HAL_CIPHER_KEYSLOT_BASE > u32Index || (HAL_CIPHER_KEYSLOT_BASE + HAL_CRYPTODMA_DMA_KEY_SLOT - 1) < u32Index)
4174 {
4175 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Invalid Key index[0x%04u]!", (unsigned int)u32Index);
4176 return DRVAESDMA_INVALID_PARAM;
4177 }
4178
4179 i = u32Index - HAL_CIPHER_KEYSLOT_BASE;
4180
4181 if(DRV_CIPHER_OK != MDrv_CIPHER_ResetKey(_u32CAVid, i))
4182 {
4183 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Reset key fail, CAVid=[0x%04u], index=[0x%04u]!", (unsigned int)_u32CAVid, (unsigned int)u32Index);
4184 return DRVAESDMA_FAIL;
4185 }
4186
4187 _CIPHER_Resource[i].bUsed = FALSE;
4188
4189 return DRVAESDMA_OK;
4190 }
4191
MDrv_AESDMA_FreeKeySlot(MS_U32 u32Index)4192 DRVAESDMA_RESULT SYMBOL_WEAK MDrv_AESDMA_FreeKeySlot (MS_U32 u32Index)
4193 {
4194 #if CIPHER_UTOPIA2
4195 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
4196 AESDMA_KEY_INDEX pArgs;
4197 if(pu32AesdmaInst == NULL)
4198 {
4199 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
4200 return DRVAESDMA_FAIL;
4201 }
4202
4203 pArgs.u32KeyIndex = u32Index;
4204
4205 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_AESDMA_FreeKeySlot, (void*)&pArgs);
4206 if(UTOPIA_STATUS_SUCCESS != u32Ret)
4207 {
4208 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
4209 return DRVAESDMA_FAIL;
4210 }
4211
4212 return DRVAESDMA_OK;
4213 #else
4214 return _MDrv_AESDMA_FreeKeySlot(u32Index);
4215 #endif
4216 }
4217
4218 #ifndef MSOS_TYPE_NUTTX
MDrv_AESDMA_SetSecurityInfo(DrvAESDMA_SecureInfo * pSecureInfo)4219 DRVAESDMA_RESULT MDrv_AESDMA_SetSecurityInfo(DrvAESDMA_SecureInfo *pSecureInfo)
4220 {
4221 DEBUG_CIPHER(CIPHER_DBG_ERR, "Not support!");
4222 return DRVAESDMA_OK;
4223 }
4224 #endif
4225
_MDrv_RSA_Init(void)4226 MS_BOOL _MDrv_RSA_Init(void)
4227 {
4228 MS_VIRT u32Bank;
4229 MS_PHY u32BankSize;
4230
4231 if(_bRSA_Init == FALSE)
4232 {
4233 if(FALSE == MDrv_MMIO_GetBASE(&u32Bank, &u32BankSize, MS_MODULE_HW))
4234 {
4235 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Get MMIO base fail");
4236 return FALSE;
4237 }
4238
4239 HAL_RSA_SetBank(u32Bank);
4240
4241 _CipherRSAMtx = MsOS_CreateMutex( E_MSOS_FIFO, (char*)"CIPHER RSA mutex", MSOS_PROCESS_SHARED);
4242 _bRSA_Init = TRUE;
4243 }
4244 return TRUE;
4245 }
4246
_MDrv_RSA_Calculate(DrvAESDMA_RSASig * pstSign,DrvAESDMA_RSAKey * pstKey,DrvAESDMA_RSAMode eMode)4247 DRVAESDMA_RESULT _MDrv_RSA_Calculate(DrvAESDMA_RSASig *pstSign, DrvAESDMA_RSAKey *pstKey, DrvAESDMA_RSAMode eMode)
4248 {
4249 MS_U32 ret = DRVAESDMA_OK;
4250 MS_U32 u32KeyLen = 0;
4251 MS_U8 u8Public = 0;
4252 MS_U32 *pu32Sig = NULL;
4253
4254 if( pstSign==NULL || pstKey==NULL )
4255 {
4256 ret = DRVAESDMA_INVALID_PARAM;
4257 goto RSA_CAL_FINISH;
4258 }
4259 pu32Sig = (MS_U32 *)(pstSign);
4260
4261 if( _MDrv_RSA_Init()==FALSE )
4262 {
4263 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:RSA Init fail");
4264 ret = DRVAESDMA_FAIL;
4265 goto RSA_CAL_FINISH;
4266 }
4267
4268 MsOS_ObtainMutex( _CipherRSAMtx, MSOS_WAIT_FOREVER);
4269
4270 HAL_RSA_Reset();
4271 HAL_RSA_Ind32Ctrl(RAM_WRITE);
4272
4273 switch (eMode)
4274 {
4275 case E_DRVAESDMA_RSA1024_PUBLIC:
4276 {
4277 u32KeyLen = 128;
4278 u8Public = E_RSA_USE_PUB_KEY;
4279 break;
4280 }
4281 case E_DRVAESDMA_RSA1024_PRIVATE:
4282 {
4283 u32KeyLen = 128;
4284 u8Public = E_RSA_USE_PRIV_KEY;
4285 break;
4286 }
4287 case E_DRVAESDMA_RSA2048_PUBLIC:
4288 {
4289 u32KeyLen = 256;
4290 u8Public = E_RSA_USE_PUB_KEY;
4291 break;
4292 }
4293 case E_DRVAESDMA_RSA2048_PRIVATE:
4294 {
4295 u32KeyLen = 256;
4296 u8Public = E_RSA_USE_PRIV_KEY;
4297 break;
4298 }
4299 case E_DRVAESDMA_RSA256_PUBLIC:
4300 {
4301 u32KeyLen = 32;
4302 u8Public = E_RSA_USE_PUB_KEY;
4303 break;
4304 }
4305 case E_DRVAESDMA_RSA256_PRIVATE:
4306 {
4307 u32KeyLen = 32;
4308 u8Public = E_RSA_USE_PRIV_KEY;
4309 break;
4310 }
4311 default:
4312 {
4313 ret = DRVAESDMA_INVALID_PARAM;
4314 goto RSA_CAL_FINISH;
4315 }
4316 }
4317
4318 DEBUG_CIPHER(CIPHER_DBG_INFO, "RSA Mode[%d]", eMode);
4319
4320 HAL_RSA_LoadSram((pstKey->u32KeyE), E_RSA_ADDRESS_E);
4321 HAL_RSA_LoadSram((pstKey->u32KeyN), E_RSA_ADDRESS_N);
4322 HAL_RSA_LoadSram(pu32Sig, E_RSA_ADDRESS_A);
4323
4324 HAL_RSA_SetKeyLength((u32KeyLen/RSA_UNIT_SIZE)-1);
4325 HAL_RSA_SetKeyType(E_RSA_USE_SW_KEY, u8Public); //sw key, public key
4326 HAL_RSA_ExponetialStart();
4327
4328 RSA_CAL_FINISH:
4329 return ret;
4330 }
4331
MDrv_RSA_Calculate(DrvAESDMA_RSASig * pstSign,DrvAESDMA_RSAKey * pstKey,DrvAESDMA_RSAMode eMode)4332 DLL_PUBLIC DRVAESDMA_RESULT MDrv_RSA_Calculate(DrvAESDMA_RSASig *pstSign, DrvAESDMA_RSAKey *pstKey, DrvAESDMA_RSAMode eMode)
4333 {
4334 #if CIPHER_UTOPIA2
4335 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
4336 RSA_CALCULATE pArgs;
4337
4338 if(pu32AesdmaInst == NULL)
4339 {
4340 if(UTOPIA_STATUS_FAIL == UtopiaOpen(MODULE_AESDMA, &pu32AesdmaInst, 0x0, NULL))
4341 {
4342 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaOpen CIPHER fail");
4343 return DRVAESDMA_FAIL;
4344 }
4345 }
4346
4347 pArgs.pstSign = pstSign;
4348 pArgs.pstKey = pstKey;
4349 pArgs.eMode = eMode;
4350
4351 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_RSA_Calculate, (void*)&pArgs);
4352 if(UTOPIA_STATUS_SUCCESS != u32Ret)
4353 {
4354 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
4355 return DRVAESDMA_FAIL;
4356 }
4357
4358 return DRVAESDMA_OK;
4359 #else
4360 return _MDrv_RSA_Calculate(pstSign, pstKey, eMode);
4361 #endif
4362 }
MDrv_RSA_Calculate_Hw_Key(DrvAESDMA_RSASig * pstSign,DrvAESDMA_RSAHwKeyMode eMode)4363 DRVAESDMA_RESULT MDrv_RSA_Calculate_Hw_Key(DrvAESDMA_RSASig *pstSign, DrvAESDMA_RSAHwKeyMode eMode)
4364 {
4365 MS_U32 ret = DRVAESDMA_OK;
4366 MS_U8 u8KeySrc= 0;
4367 MS_U8 u8Public = 0;
4368 MS_U32 *pu32Sig = NULL;
4369 MS_U32 u32SwitchValue;
4370
4371 if( pstSign==NULL )
4372 {
4373 ret = DRVAESDMA_INVALID_PARAM;
4374 goto RSA_CAL_HW_FINISH;
4375 }
4376 pu32Sig = (MS_U32 *)(pstSign);
4377
4378 if( _MDrv_RSA_Init()==FALSE )
4379 {
4380 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:RSA Init fail");
4381 ret = DRVAESDMA_FAIL;
4382 goto RSA_CAL_HW_FINISH;
4383 }
4384
4385 MsOS_ObtainMutex( _CipherRSAMtx, MSOS_WAIT_FOREVER);
4386
4387 HAL_RSA_Reset();
4388 HAL_RSA_Ind32Ctrl(RAM_WRITE);
4389
4390 switch (eMode)
4391 {
4392 case E_DRVAESDMA_RSA_HWKEY_PRIVATE:
4393 {
4394 u8KeySrc = E_RSA_HW_PRI_KEY;
4395 u8Public = E_RSA_USE_PRIV_KEY;
4396 break;
4397 }
4398 case E_DRVAESDMA_RSA_HWKEY_PUBLIC1:
4399 {
4400 u8KeySrc = E_RSA_HW_PUB_KEY1;
4401 u8Public = E_RSA_USE_PUB_KEY;
4402 break;
4403 }
4404 case E_DRVAESDMA_RSA_HWKEY_PUBLIC2:
4405 {
4406 u8KeySrc = E_RSA_HW_PUB_KEY2;
4407 u8Public = E_RSA_USE_PUB_KEY;
4408 break;
4409 }
4410 case E_DRVAESDMA_RSA_HWKEY_ROM_PRIVATE:
4411 {
4412 u8KeySrc = E_RSA_HW_PRI_KEY;
4413 u8Public = E_RSA_USE_PRIV_KEY;
4414 break;
4415 }
4416 case E_DRVAESDMA_RSA_HWKEY_ROM_PUBLIC:
4417 {
4418 u8KeySrc = E_RSA_HW_PUB_KEY1;
4419 u8Public = E_RSA_USE_PUB_KEY;
4420 break;
4421 }
4422 default:
4423 {
4424 ret = DRVAESDMA_INVALID_PARAM;
4425 goto RSA_CAL_HW_FINISH;
4426 }
4427 }
4428
4429 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:RSA Mode[%d], Key Source[%u], Public[%u]",
4430 eMode, u8KeySrc, u8Public);
4431
4432 if(eMode == E_DRVAESDMA_RSA_HWKEY_ROM_PRIVATE || eMode == E_DRVAESDMA_RSA_HWKEY_ROM_PUBLIC)
4433 {
4434 HAL_RSA_Hwkey_Switch();
4435
4436 u32SwitchValue = HAL_RSA_Read_Hwkey_Switch();
4437
4438 if( u32SwitchValue != 1 )
4439 {
4440 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:RSA Hwkey Switch fail");
4441 ret = DRVAESDMA_FAIL;
4442 goto RSA_CAL_HW_FINISH;
4443 }
4444 }
4445
4446 HAL_RSA_LoadSram(pu32Sig, E_RSA_ADDRESS_A);
4447
4448 HAL_RSA_SetKeyType(E_RSA_USE_HW_KEY, u8Public);
4449 HAL_RSA_Rootkey_Sel(u8KeySrc);
4450 HAL_RSA_ExponetialStart();
4451
4452 RSA_CAL_HW_FINISH:
4453 return ret;
4454 }
4455
_MDrv_RSA_IsFinished(void)4456 DRVAESDMA_RESULT _MDrv_RSA_IsFinished(void)
4457 {
4458 RSAInitChk();
4459
4460 if(HAL_RSA_Get_RSA_IsFinished()==0)
4461 {
4462 return DRVAESDMA_OK;
4463 }
4464 else
4465 {
4466 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning:RSA Not Done!");
4467 return DRVAESDMA_FAIL;
4468 }
4469 }
4470
MDrv_RSA_IsFinished(void)4471 DLL_PUBLIC DRVAESDMA_RESULT MDrv_RSA_IsFinished(void)
4472 {
4473 #if CIPHER_UTOPIA2
4474 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
4475 MS_U32 u32TimeOut = RSA_DEFAULT_TIMEOUT_VALUE;
4476
4477 if(pu32AesdmaInst == NULL)
4478 {
4479 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
4480 return DRVAESDMA_FAIL;
4481 }
4482
4483 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_RSA_IsFinished, (void*)&u32TimeOut);
4484 if(UTOPIA_STATUS_SUCCESS != u32Ret)
4485 {
4486 DEBUG_CIPHER(CIPHER_DBG_WARN, "Warning:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
4487 return DRVAESDMA_FAIL;
4488 }
4489
4490 return DRVAESDMA_OK;
4491 #else
4492 return _MDrv_RSA_IsFinished();
4493 #endif
4494 }
4495
_MDrv_RSA_Output(DrvAESDMA_RSAMode eMode,DrvAESDMA_RSAOut * pstRSAOut)4496 DRVAESDMA_RESULT _MDrv_RSA_Output(DrvAESDMA_RSAMode eMode, DrvAESDMA_RSAOut *pstRSAOut)
4497 {
4498 MS_U32 ret = DRVAESDMA_OK;
4499 MS_U32 i = 0;
4500 MS_U32 u32KeyLen = 0;
4501 MS_U32 *pu32RSAOut = (MS_U32 *)(pstRSAOut->u32RSAOut);
4502
4503 RSAInitChk();
4504
4505 switch (eMode)
4506 {
4507 case E_DRVAESDMA_RSA1024_PUBLIC:
4508 case E_DRVAESDMA_RSA1024_PRIVATE:
4509 {
4510 u32KeyLen = 128;
4511 break;
4512 }
4513 case E_DRVAESDMA_RSA2048_PUBLIC:
4514 case E_DRVAESDMA_RSA2048_PRIVATE:
4515 {
4516 u32KeyLen = 256;
4517 break;
4518 }
4519 case E_DRVAESDMA_RSA256_PUBLIC:
4520 case E_DRVAESDMA_RSA256_PRIVATE:
4521 {
4522 u32KeyLen = 32;
4523 break;
4524 }
4525 default:
4526 {
4527 ret = DRVAESDMA_INVALID_PARAM;
4528 goto RSA_OUTPUT_FINISH;
4529 }
4530 }
4531
4532 DEBUG_CIPHER(CIPHER_DBG_INFO, "INFO:RSA Mode[%d], Key length[%u]", eMode, u32KeyLen);
4533
4534 HAL_RSA_SetFileOutAddr(64-(u32KeyLen/sizeof(MS_U32)));
4535 HAL_RSA_Ind32Ctrl(RAM_READ);
4536 HAL_RSA_FileOutStart();
4537 for( i = 0; i<(u32KeyLen/RSA_UNIT_SIZE); i++)
4538 {
4539 pu32RSAOut[(u32KeyLen/RSA_UNIT_SIZE)-1-i] = HAL_RSA_FileOut();
4540 }
4541
4542 RSA_OUTPUT_FINISH:
4543 MsOS_ReleaseMutex(_CipherRSAMtx);
4544 return ret;
4545 }
MDrv_RSA_Output(DrvAESDMA_RSAMode eMode,DrvAESDMA_RSAOut * pstRSAOut)4546 DLL_PUBLIC DRVAESDMA_RESULT MDrv_RSA_Output(DrvAESDMA_RSAMode eMode, DrvAESDMA_RSAOut *pstRSAOut)
4547 {
4548 #if CIPHER_UTOPIA2
4549 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
4550 RSA_OUTPUT pArgs;
4551 if(pu32AesdmaInst == NULL)
4552 {
4553 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:Cipher instance NULL");
4554 return DRVAESDMA_FAIL;
4555 }
4556
4557 pArgs.eMode = eMode;
4558 pArgs.pstRSAOut = pstRSAOut;
4559
4560 u32Ret = UtopiaIoctl(pu32AesdmaInst, MDrv_CMD_RSA_Output, (void*)&pArgs);
4561 if(UTOPIA_STATUS_SUCCESS != u32Ret)
4562 {
4563 DEBUG_CIPHER(CIPHER_DBG_ERR, "Error:UtopiaIoctl return value 0x%x", (unsigned int)u32Ret);
4564 return DRVAESDMA_FAIL;
4565 }
4566
4567 return DRVAESDMA_OK;
4568 #else
4569 return _MDrv_RSA_Output(eMode, pstRSAOut);
4570 #endif
4571 }
4572
4573
4574