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 drvAESDMA.c
98 // @brief AESDMA Driver
99 // @author MStar Semiconductor,Inc.
100 //
101 ////////////////////////////////////////////////////////////////////////////////////////////////////
102
103 #if !defined(MSOS_TYPE_LINUX_KERNEL)
104 #include <stdio.h>
105 #include <string.h>
106 #else
107 #include <linux/string.h>
108 #include <linux/slab.h>
109 #endif
110 #include "MsCommon.h"
111 #include "MsIRQ.h"
112 #include "MsOS.h"
113 #include "MsVersion.h"
114
115 #include "drvMMIO.h"
116 #include "halAESDMA.h"
117 #include "drvAESDMA.h"
118 #include "utopia.h"
119 #include "drvAESDMA_private.h"
120 #include "ULog.h"
121
122 //--------------------------------------------------------------------------------------------------
123 // Driver Compiler Option
124 //--------------------------------------------------------------------------------------------------
125 #if !defined(MSOS_TYPE_NOS)
126 #define AESDMAIntEnable() MsOS_EnableInterrupt(E_INT_IRQ_WADR_ERR);
127 #define AESDMAIntDisable() MsOS_DisableInterrupt(E_INT_IRQ_WADR_ERR);
128 #define AESDMAIntAttach() MsOS_AttachInterrupt(E_INT_IRQ_WADR_ERR, (InterruptCb )_AESDMA_Isr)
129 #define AESDMAIntDetach() MsOS_DetachInterrupt (E_INT_IRQ_WADR_ERR)
130 #endif //#if !defined(MSOS_TYPE_NOS)
131 #define AESDMAPA2KSEG1(addr) ((void *)(((MS_U32)addr) | 0xa0000000)) //physical -> unchched
132
133
134 //--------------------------------------------------------------------------------------------------
135 // Local Defines
136 //--------------------------------------------------------------------------------------------------
137 #if !defined(MSOS_TYPE_NOS)
138 #define AESDMA_TASK_STACK_SIZE 4096UL
139 #endif //#if !defined(MSOS_TYPE_NOS)
140
141 #define TAG_AESDMA "AESDMA"
142
143 static MS_PHY phyTmpFileInAddr = 0;
144 static MS_PHY phyTmpFileOutAddr = 0;
145 static MS_U32 u32TmpFileInNum = 0;
146
147 //--------------------------------------------------------------------------------------------------
148 // Global Variable
149 //--------------------------------------------------------------------------------------------------
150 //#ifndef MSOS_TYPE_LINUX
151 static DrvAESDMA_Event _AESDMAEvtNotify;
152 static P_DrvAESDMA_EvtCallback _AESDMACallback;
153 //#endif // #ifndef MSOS_TYPE_LINUX
154
155 #if !defined(MSOS_TYPE_NOS)
156 static void* _pAESDMATaskStack;
157 static MS_U8 _u8AESDMA_StackBuffer[AESDMA_TASK_STACK_SIZE];
158 static MS_S32 _s32AESDMATaskId;
159 static MS_U32 _u32LastErr;
160 #endif //#if !defined(MSOS_TYPE_NOS)
161
162 static MS_PHY _u32MIU0_Addr, _u32MIU1_Addr , _u32MIU2_Addr, _u32MIU_num;
163 static DrvAESDMA_DbgLevel _u32AESDMADBGLevel;
164 static MS_BOOL _bExitIsrLoop;
165
166 static MSIF_Version _drv_aesdma_version = {
167 .DDI = { AESDMA_DRV_VERSION, },
168 };
169
170 #if (AESDMA_UTOPIA20)
171 void* pInstantAesdma = NULL;
172 void* pAttributeAesdma = NULL;
173 #endif
174
175 //--------------------------------------------------------------------------------------------------
176 // Internal Variable
177 //--------------------------------------------------------------------------------------------------
178 #if !defined(MSOS_TYPE_NOS)
179 static MS_S32 _s32AESDMAMutexId;
180 static MS_S32 _s32AESDMAEventId;
181 #endif //#if !defined(MSOS_TYPE_NOS)
182 static MS_U8 _u8IsInit = FALSE;
183 #ifndef MSOS_TYPE_NUTTX
184 static MS_BOOL bSecureModeEnable = FALSE;
185 #endif
186
187 #if !defined(MSOS_TYPE_NOS)
188 #define _AESDMA_SetEvent(flag) MsOS_SetEvent(_s32AESDMAEventId, (flag))
189 #define _AESDMA_GetEvent(events) MsOS_WaitEvent(_s32AESDMAEventId, AESDMA_STATES_GROUP, &events, E_OR_CLEAR, MSOS_WAIT_FOREVER)
190 #endif //#if !defined(MSOS_TYPE_NOS)
191
192 //--------------------------------------------------------------------------------------------------
193 // Debug Function
194 //--------------------------------------------------------------------------------------------------
195 #define DEBUG_AES_DMA(debug_level, x) do { if (_u32AESDMADBGLevel >= (debug_level)) (x); } while(0)
196
197 //--------------------------------------------------------------------------------------------------
198 // Internal Function
199 //--------------------------------------------------------------------------------------------------
_AESDMA_Chk_MIU(MS_PHY * phy64InAddr,MS_U32 u32InLen,MS_PHY * phy64OutSAddr,MS_PHY * phyOutEAddr)200 static MS_BOOL _AESDMA_Chk_MIU(MS_PHY *phy64InAddr, MS_U32 u32InLen, MS_PHY *phy64OutSAddr, MS_PHY *phyOutEAddr)
201 {
202
203 if (_u32MIU_num == 3)
204 {
205 if ((_u32MIU1_Addr > *phy64InAddr) & (_u32MIU1_Addr > *phy64InAddr+u32InLen) & (_u32MIU1_Addr > *phy64OutSAddr) & (_u32MIU1_Addr > *phyOutEAddr))
206 {
207 AESDMA_Set_MIU_Path(FALSE,FALSE);
208 AESDMA_Set_MIU2_Path(FALSE,FALSE); // miu0->miu0
209 return TRUE;
210 }
211
212 if ((_u32MIU1_Addr > *phy64InAddr) & (_u32MIU1_Addr > *phy64InAddr+u32InLen) & (_u32MIU1_Addr < *phy64OutSAddr) & (_u32MIU1_Addr < *phyOutEAddr) & (_u32MIU2_Addr > *phy64OutSAddr) & (_u32MIU2_Addr > *phyOutEAddr))
213 {
214 *phy64OutSAddr = *phy64OutSAddr - _u32MIU1_Addr;
215 *phyOutEAddr = *phyOutEAddr - _u32MIU1_Addr;
216 AESDMA_Set_MIU_Path(FALSE,TRUE);
217 AESDMA_Set_MIU2_Path(FALSE,FALSE); // miu0->miu1
218 return TRUE;
219 }
220
221 if ((_u32MIU1_Addr > *phy64InAddr) & (_u32MIU1_Addr > *phy64InAddr+u32InLen) & (_u32MIU2_Addr <= *phy64OutSAddr) & (_u32MIU2_Addr <= *phyOutEAddr))
222 {
223 *phy64OutSAddr = *phy64OutSAddr - _u32MIU2_Addr;
224 *phyOutEAddr = *phyOutEAddr - _u32MIU2_Addr;
225 AESDMA_Set_MIU_Path(FALSE,FALSE);
226 AESDMA_Set_MIU2_Path(FALSE,TRUE); // miu0->miu2
227 return TRUE;
228 }
229
230 if ((_u32MIU1_Addr <= *phy64InAddr) & (_u32MIU1_Addr <= *phy64InAddr+u32InLen) & (_u32MIU2_Addr > *phy64InAddr) & (_u32MIU2_Addr > *phy64InAddr+u32InLen) & (_u32MIU1_Addr > *phy64OutSAddr) & (_u32MIU1_Addr > *phyOutEAddr))
231 {
232 *phy64InAddr = *phy64InAddr - _u32MIU1_Addr;
233 AESDMA_Set_MIU_Path(TRUE,FALSE);
234 AESDMA_Set_MIU2_Path(FALSE,FALSE); // miu1->miu0
235 return TRUE;
236 }
237
238 if ((_u32MIU1_Addr <= *phy64InAddr) & (_u32MIU1_Addr <= *phy64InAddr+u32InLen) & (_u32MIU2_Addr > *phy64InAddr) & (_u32MIU2_Addr > *phy64InAddr+u32InLen) & (_u32MIU1_Addr <= *phy64OutSAddr) & (_u32MIU1_Addr <= *phyOutEAddr) & (_u32MIU2_Addr > *phy64OutSAddr) & (_u32MIU2_Addr > *phyOutEAddr))
239 {
240 *phy64InAddr = *phy64InAddr - _u32MIU1_Addr;
241 *phy64OutSAddr = *phy64OutSAddr - _u32MIU1_Addr;
242 *phyOutEAddr = *phyOutEAddr - _u32MIU1_Addr;
243 AESDMA_Set_MIU_Path(TRUE,TRUE);
244 AESDMA_Set_MIU2_Path(FALSE,FALSE); // miu1->miu1
245 return TRUE;
246 }
247
248 if ((_u32MIU1_Addr <= *phy64InAddr) & (_u32MIU1_Addr <= *phy64InAddr+u32InLen) & (_u32MIU2_Addr > *phy64InAddr) & (_u32MIU2_Addr > *phy64InAddr+u32InLen) & (_u32MIU2_Addr <= *phy64OutSAddr) & (_u32MIU2_Addr <= *phyOutEAddr))
249 {
250 *phy64InAddr = *phy64InAddr - _u32MIU1_Addr;
251 *phy64OutSAddr = *phy64OutSAddr - _u32MIU2_Addr;
252 *phyOutEAddr = *phyOutEAddr - _u32MIU2_Addr;
253 AESDMA_Set_MIU_Path(TRUE,FALSE);
254 AESDMA_Set_MIU2_Path(FALSE,TRUE); // miu1->miu2
255 return TRUE;
256 }
257
258 if ((_u32MIU2_Addr <= *phy64InAddr) & (_u32MIU2_Addr <= *phy64InAddr+u32InLen) & (_u32MIU1_Addr > *phy64OutSAddr) & (_u32MIU1_Addr > *phyOutEAddr))
259 {
260 *phy64InAddr = *phy64InAddr - _u32MIU2_Addr;
261 AESDMA_Set_MIU_Path(FALSE,FALSE);
262 AESDMA_Set_MIU2_Path(TRUE,FALSE); // miu2->miu0
263 return TRUE;
264 }
265
266 if ((_u32MIU2_Addr <= *phy64InAddr) & (_u32MIU2_Addr <= *phy64InAddr+u32InLen) & (_u32MIU1_Addr <= *phy64OutSAddr) & (_u32MIU1_Addr <= *phyOutEAddr) & (_u32MIU2_Addr > *phy64OutSAddr) & (_u32MIU2_Addr > *phyOutEAddr))
267 {
268 *phy64InAddr = *phy64InAddr - _u32MIU2_Addr;
269 *phy64OutSAddr = *phy64OutSAddr - _u32MIU1_Addr;
270 *phyOutEAddr = *phyOutEAddr - _u32MIU1_Addr;
271 AESDMA_Set_MIU_Path(FALSE,TRUE);
272 AESDMA_Set_MIU2_Path(TRUE,FALSE); // miu2->miu1
273 return TRUE;
274 }
275
276 if ((_u32MIU2_Addr <= *phy64InAddr) & (_u32MIU2_Addr <= *phy64InAddr+u32InLen) & (_u32MIU2_Addr <= *phy64OutSAddr) & (_u32MIU2_Addr <= *phyOutEAddr))
277 {
278 *phy64InAddr = *phy64InAddr - _u32MIU2_Addr;
279 *phy64OutSAddr = *phy64OutSAddr - _u32MIU2_Addr;
280 *phyOutEAddr = *phyOutEAddr - _u32MIU2_Addr;
281 AESDMA_Set_MIU_Path(FALSE,FALSE);
282 AESDMA_Set_MIU2_Path(TRUE,TRUE); // miu2->miu2
283 return TRUE;
284 }
285 return FALSE;
286 }
287 else if (_u32MIU_num == 2)
288 {
289 if ((_u32MIU1_Addr > *phy64InAddr) & (_u32MIU1_Addr > *phy64InAddr+u32InLen) & (_u32MIU1_Addr > *phy64OutSAddr) & (_u32MIU1_Addr > *phyOutEAddr))
290 {
291 AESDMA_Set_MIU_Path(FALSE,FALSE); // miu0->miu0
292 return TRUE;
293 }
294
295 if ((_u32MIU1_Addr < *phy64InAddr) & (_u32MIU1_Addr < *phy64InAddr+u32InLen) & (_u32MIU1_Addr < *phy64OutSAddr) & (_u32MIU1_Addr < *phyOutEAddr))
296 {
297 *phy64InAddr = *phy64InAddr - _u32MIU1_Addr;
298 *phy64OutSAddr = *phy64OutSAddr - _u32MIU1_Addr;
299 *phyOutEAddr = *phyOutEAddr - _u32MIU1_Addr;
300 AESDMA_Set_MIU_Path(TRUE,TRUE); // miu1->miu1
301 return TRUE;
302 }
303
304 if ((_u32MIU1_Addr > *phy64InAddr) & (_u32MIU1_Addr > *phy64InAddr+u32InLen) & (_u32MIU1_Addr <= *phy64OutSAddr) & (_u32MIU1_Addr <= *phyOutEAddr))
305 {
306 *phy64OutSAddr = *phy64OutSAddr - _u32MIU1_Addr;
307 *phyOutEAddr = *phyOutEAddr - _u32MIU1_Addr;
308 AESDMA_Set_MIU_Path(FALSE,TRUE); // miu0->miu1
309 return TRUE;
310 }
311
312 if ((_u32MIU1_Addr <= *phy64InAddr) & (_u32MIU1_Addr <= *phy64InAddr+u32InLen) & (_u32MIU1_Addr > *phy64OutSAddr) & (_u32MIU1_Addr > *phyOutEAddr))
313 {
314 *phy64InAddr = *phy64InAddr - _u32MIU1_Addr;
315 AESDMA_Set_MIU_Path(TRUE,FALSE); // miu1->miu0
316 return TRUE;
317 }
318 return FALSE;
319 }
320 else
321 {
322 if ((_u32MIU0_Addr < *phy64InAddr) & (_u32MIU0_Addr < *phy64InAddr+u32InLen) & (_u32MIU0_Addr < *phy64OutSAddr) & (_u32MIU0_Addr < *phyOutEAddr))
323 {
324 AESDMA_Set_MIU_Path(FALSE,FALSE); // miu0->miu0
325
326 }
327 return TRUE;
328 }
329 }
330
331 #if !defined(MSOS_TYPE_NOS)
_AESDMA_Isr(void)332 static void _AESDMA_Isr(void)
333 {
334 MS_U32 u32AESDMAStatus;
335
336 // Direct register access
337 u32AESDMAStatus = AESDMA_Get_AESDMA_Status();
338
339 if (HAS_FLAG(u32AESDMAStatus, AESDMA_STATES_GROUP))
340 {
341 _AESDMA_SetEvent(HAS_FLAG(u32AESDMAStatus, AESDMA_STATES_GROUP)); // Trigger task
342 }
343 AESDMA_Clear_Int();
344 AESDMA_Enable_Int();
345 AESDMAIntEnable();
346 }
347
_AESDMA_Isr_Proc(void)348 static void _AESDMA_Isr_Proc(void)
349 {
350 MS_U32 u32Events;
351
352 while ( _bExitIsrLoop == FALSE )
353 {
354 _AESDMA_GetEvent(u32Events);
355 if (u32Events & AESDMA_STATES_GROUP)
356 {
357 if (HAS_FLAG(u32Events, AESDMA_STATES_GROUP) && _AESDMAEvtNotify && _AESDMACallback)
358 {
359 switch (u32Events & AESDMA_STATES_GROUP)
360 {
361 case AESDMA_DMA_DONE:
362 if (HAS_FLAG(_AESDMAEvtNotify, E_DRVAESDMA_EVENT_DMA_DONE))
363 {
364 MsOS_ReadMemory();
365 _AESDMACallback(E_DRVAESDMA_EVENT_DMA_DONE);
366 }
367 break;
368 case AESDMA_DMA_PAUSE:
369 if (HAS_FLAG(_AESDMAEvtNotify, E_DRVAESDMA_EVENT_DMA_PAUSE))
370 {
371 _AESDMACallback(E_DRVAESDMA_EVENT_DMA_PAUSE);
372 }
373 break;
374 default:
375 break;
376 }
377 }
378 }
379 } // Task while loop
380 }
381 #endif //#if !defined(MSOS_TYPE_NOS)
382
_AESDMA_MSBF2Native(const MS_U8 u8Bytes[4])383 MS_U32 _AESDMA_MSBF2Native(const MS_U8 u8Bytes[4])
384 {
385 return (u8Bytes[0] << 24) | (u8Bytes[1] << 16) | (u8Bytes[2] << 8) | u8Bytes[3];
386 }
387
388 //--------------------------------------------------------------------------------------------------
389 // Global Function
390 //--------------------------------------------------------------------------------------------------
391 #ifndef MSOS_TYPE_NUTTX
MDrv_AESDMA_SetSecurityInfo(DrvAESDMA_SecureInfo * pSecureInfo)392 DRVAESDMA_RESULT MDrv_AESDMA_SetSecurityInfo(DrvAESDMA_SecureInfo *pSecureInfo)
393 {
394 bSecureModeEnable = pSecureInfo->bSecureModeEnable;
395 return DRVAESDMA_OK;
396 }
397 #endif
398
_MDrv_AESDMA_Init(MS_PHY phy64miu0addr,MS_PHY phy64miu1addr,MS_U32 u32miunum)399 DRVAESDMA_RESULT _MDrv_AESDMA_Init(MS_PHY phy64miu0addr , MS_PHY phy64miu1addr , MS_U32 u32miunum)
400 {
401 MS_VIRT u32Bank, u32IRBank;
402 MS_PHY u32BankSize; // Non-PM bank
403 MS_PHY u32IrBankSize; // PM bank
404
405 _bExitIsrLoop = FALSE;
406
407 if(_u8IsInit == FALSE)
408 {
409 if (FALSE == MDrv_MMIO_GetBASE(&u32Bank, &u32BankSize, MS_MODULE_BDMA))
410 {
411 MS_DEBUG_MSG(ULOGE(TAG_AESDMA, "MDrv_MMIO_GetBASE (NonPM base)fail\n"));
412 MS_ASSERT(0);
413 }
414
415 if (FALSE == MDrv_MMIO_GetBASE(&u32IRBank, &u32IrBankSize, MS_MODULE_IR))
416 {
417 MS_DEBUG_MSG(ULOGE(TAG_AESDMA, "MDrv_MMIO_GetBASE (PM base)fail\n"));
418 MS_ASSERT(0);
419 }
420 _u8IsInit = TRUE;
421 HAL_AESDMA_SetBank(u32Bank, u32IRBank);
422 AESDMA_Enable_Clk();
423 _u32MIU_num = u32miunum;
424 _u32MIU0_Addr = 0;
425 if(_u32MIU_num == 2)
426 {
427 _u32MIU1_Addr = AESDMA_GetMIU1Base();
428 }
429
430 if(_u32MIU_num == 3)
431 {
432 _u32MIU1_Addr = AESDMA_GetMIU1Base();
433 _u32MIU2_Addr = AESDMA_GetMIU2Base();
434 }
435
436 // ++ Release reset that asserted in the DC off
437 // *(volatile MS_U32*)(0xbf800000+(0x2380<<2)) |= BIT15;
438 // -- Release reset that asserted in the DC off
439
440 #ifndef MSOS_TYPE_NUTTX
441 if(bSecureModeEnable == FALSE)
442 {
443 AESDMA_Reset();
444 }
445 #else
446 AESDMA_Reset();
447 #endif
448
449 #if !defined(MSOS_TYPE_NOS)
450 _AESDMAEvtNotify = E_DRVAESDMA_EVENT_DATA_INIT;
451 _AESDMACallback = NULL;
452
453 AESDMA_HW_Patch();
454
455 AESDMAIntDetach();
456 AESDMAIntAttach();
457 AESDMAIntEnable();
458
459 AESDMA_Enable_Int();
460
461 _s32AESDMAEventId = MsOS_CreateEventGroup("AESDMA_Event");
462 if (_s32AESDMAEventId < 0)
463 {
464 MsOS_DeleteMutex(_s32AESDMAMutexId);
465 _u32LastErr = DRVAESDMA_FAIL;
466 return _u32LastErr;
467 }
468
469 _pAESDMATaskStack = _u8AESDMA_StackBuffer;
470 _s32AESDMATaskId = MsOS_CreateTask((TaskEntry)_AESDMA_Isr_Proc,
471 NULL,
472 E_TASK_PRI_MEDIUM,
473 TRUE,
474 _pAESDMATaskStack,
475 AESDMA_TASK_STACK_SIZE,
476 "AESDMA_ISR_Task");
477 if (_s32AESDMATaskId < 0)
478 {
479 MsOS_DeleteEventGroup(_s32AESDMAEventId);
480 MsOS_DeleteMutex(_s32AESDMAMutexId);
481 _u32LastErr = DRVAESDMA_FAIL;
482 return _u32LastErr;
483 }
484 #endif //#if !defined(MSOS_TYPE_NOS)
485 }
486 else
487 {
488 AESDMA_Enable_Clk();
489 #ifndef MSOS_TYPE_NUTTX
490 if(bSecureModeEnable == FALSE)
491 {
492 AESDMA_Reset();
493 }
494 #else
495 AESDMA_Reset();
496 #endif
497
498 _u8IsInit = TRUE;
499 }
500
501 #if AESDMS_SECURED_BANK_EN
502 AESDMA_Set_SecureBankEnable (TRUE);
503 #else
504 AESDMA_Set_SecureBankEnable (FALSE);
505 #endif
506
507 return DRVAESDMA_OK;
508 }
509
MDrv_AESDMA_Init(MS_PHY u32miu0addr,MS_PHY u32miu1addr,MS_U32 u32miunum)510 DRVAESDMA_RESULT MDrv_AESDMA_Init(MS_PHY u32miu0addr , MS_PHY u32miu1addr , MS_U32 u32miunum)
511 {
512 #if (AESDMA_UTOPIA20)
513 AESDMA_INIT sAesdmaInit;
514
515 sAesdmaInit.u32miu0addr = u32miu0addr;
516 sAesdmaInit.u32miu1addr = u32miu1addr;
517 sAesdmaInit.u32miunum = u32miunum;
518
519 #ifndef CONFIG_MBOOT
520 if (pInstantAesdma != NULL) // prevent memory leak, and avoid strange issue in mboot after using same instance for a long time
521 {
522 UtopiaClose(pInstantAesdma);
523 }
524 #endif
525
526 if(UtopiaOpen(MODULE_AESDMA, &pInstantAesdma, 0, pAttributeAesdma) != UTOPIA_STATUS_SUCCESS)
527 {
528 pInstantAesdma = NULL;
529 return DRVAESDMA_FAIL;
530 }
531
532 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_Init,(void*)&sAesdmaInit) != UTOPIA_STATUS_SUCCESS)
533 {
534 return DRVAESDMA_FAIL;
535 }
536 return DRVAESDMA_OK;
537 #else
538 return _MDrv_AESDMA_Init(u32miu0addr, u32miu1addr, u32miunum);
539 #endif
540 }
541 //--------------------------------------------------------------------------------------------------
542 /// Set key to the AESDMA
543 /// @param pu8Key \b IN: The key is represented as vectors of bytes with the MSB first
544 /// @param u32Len \b IN: The byte length of the pu8Key. 16 for AES/TDES and 8 for DES
545 /// @return DRVAESDMA_OK - Success
546 /// @return DRVAESDMA_INVALID_PARAM - Invalid key length
547 //--------------------------------------------------------------------------------------------------
MDrv_AESDMA_SetKey_Ex(const MS_U8 * pu8Key,MS_U32 u32Len)548 DRVAESDMA_RESULT MDrv_AESDMA_SetKey_Ex(const MS_U8 *pu8Key, MS_U32 u32Len)
549 {
550 MS_U32 u32Tmp[4] = {0};
551
552 if(pu8Key == NULL)
553 {
554 AESDMA_Sel_Key(TRUE); // key from KL
555 return DRVAESDMA_OK;
556 }
557
558 // key from cipherkey
559 if(u32Len == 16)
560 {
561 u32Tmp[3] = _AESDMA_MSBF2Native(pu8Key);
562 u32Tmp[2] = _AESDMA_MSBF2Native(pu8Key + 4);
563 u32Tmp[1] = _AESDMA_MSBF2Native(pu8Key + 8);
564 u32Tmp[0] = _AESDMA_MSBF2Native(pu8Key + 12);
565 }
566 else if(u32Len == 8)
567 {
568 u32Tmp[3] = _AESDMA_MSBF2Native(pu8Key);
569 u32Tmp[2] = _AESDMA_MSBF2Native(pu8Key + 4);
570 }
571 else
572 {
573 return DRVAESDMA_INVALID_PARAM;
574 }
575
576 AESDMA_Set_CipherKey(u32Tmp);
577 AESDMA_Sel_Key(FALSE);
578
579 return DRVAESDMA_OK;
580 }
581
582 //--------------------------------------------------------------------------------------------------
583 /// Set IV to the AESDMA
584 /// @param pu8IV \b IN: The IV is represented as vectors of bytes with the MSB first
585 /// @param u32Len \b IN: The byte length of the pu8IV. 16 for AES and 8 for TDES/DES
586 /// @return DRVAESDMA_OK - Success
587 /// @return DRVAESDMA_INVALID_PARAM - Invalid IV length
588 //--------------------------------------------------------------------------------------------------
MDrv_AESDMA_SetIV_Ex(const MS_U8 * pu8IV,MS_U32 u32Len)589 DRVAESDMA_RESULT MDrv_AESDMA_SetIV_Ex(const MS_U8 *pu8IV, MS_U32 u32Len)
590 {
591 MS_U32 u32Tmp[4] = {0};
592
593 if(pu8IV == NULL)
594 {
595 return DRVAESDMA_OK;
596 }
597
598 if(u32Len == 16)
599 {
600 u32Tmp[3] = _AESDMA_MSBF2Native(pu8IV);
601 u32Tmp[2] = _AESDMA_MSBF2Native(pu8IV + 4);
602 u32Tmp[1] = _AESDMA_MSBF2Native(pu8IV + 8);
603 u32Tmp[0] = _AESDMA_MSBF2Native(pu8IV + 12);
604 }
605 else if(u32Len == 8)
606 {
607 u32Tmp[3] = _AESDMA_MSBF2Native(pu8IV);
608 u32Tmp[2] = _AESDMA_MSBF2Native(pu8IV + 4);
609 }
610 else
611 {
612 return DRVAESDMA_INVALID_PARAM;
613 }
614
615 AESDMA_Set_InitVector(u32Tmp);
616
617 return DRVAESDMA_OK;
618 }
619
_MDrv_AESDMA_SetKey(MS_U32 * pCipherKey)620 DRVAESDMA_RESULT _MDrv_AESDMA_SetKey(MS_U32 *pCipherKey)
621 {
622 if (pCipherKey != NULL)
623 {
624 AESDMA_Set_CipherKey(pCipherKey);
625 AESDMA_Sel_Key(FALSE); // key from cipherkey
626 }
627 else
628 {
629 AESDMA_Sel_Key(TRUE); // key from KL
630 }
631
632 return DRVAESDMA_OK;
633 }
634
MDrv_AESDMA_SetKey(MS_U32 * pCipherKey)635 DRVAESDMA_RESULT MDrv_AESDMA_SetKey(MS_U32 *pCipherKey)
636 {
637 #if (AESDMA_UTOPIA20)
638 if (NULL == pInstantAesdma)
639 return DRVAESDMA_FAIL;
640 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_SetKey,(void*)pCipherKey) != UTOPIA_STATUS_SUCCESS)
641 {
642 return DRVAESDMA_FAIL;
643 }
644 return DRVAESDMA_OK;
645 #else
646 return _MDrv_AESDMA_SetKey(pCipherKey);
647 #endif
648 }
649
_MDrv_AESDMA_SetKeySel(MS_U32 * pCipherKey,DrvAESDMA_KEY_TYPE stKeyType)650 DRVAESDMA_RESULT _MDrv_AESDMA_SetKeySel(MS_U32 *pCipherKey, DrvAESDMA_KEY_TYPE stKeyType)
651 {
652 AESDMA_Parser_Enable_Two_Keys(TRUE);
653 switch (stKeyType)
654 {
655 case E_DRVAESDMA_ODD_KEY:
656 AESDMA_Set_CipherOddKey(pCipherKey);
657 break;
658
659 case E_DRVAESDMA_EVEN_KEY:
660 AESDMA_Set_CipherEvenKey(pCipherKey);
661 break;
662
663 default:
664 break;
665 }
666
667 return DRVAESDMA_OK;
668 }
669
670 //--------------------------------------------------------------------------------------------------
671 /// Set Odd/Even Key to the AESDMA
672 /// @param pCipherKey \b IN: The key is represented as vectors of 4-bytes
673 /// @param stKeyType \b IN: The key type of input key.
674 /// @return DRVAESDMA_OK - Success
675 //--------------------------------------------------------------------------------------------------
MDrv_AESDMA_SetKeySel(MS_U32 * pCipherKey,DrvAESDMA_KEY_TYPE stKeyType)676 DRVAESDMA_RESULT MDrv_AESDMA_SetKeySel(MS_U32 *pCipherKey, DrvAESDMA_KEY_TYPE stKeyType)
677 {
678 #ifndef MSOS_TYPE_NUTTX
679 if(bSecureModeEnable)
680 {
681 return DRVAESDMA_OK;
682 }
683 else
684 {
685 AESDMA_Parser_Enable_Two_Keys(TRUE);
686 return _MDrv_AESDMA_SetKeySel(pCipherKey, stKeyType);
687 }
688 #else
689 AESDMA_Parser_Enable_Two_Keys(TRUE);
690 return _MDrv_AESDMA_SetKeySel(pCipherKey, stKeyType);
691 #endif
692 }
693
_MDrv_AESDMA_SetOddIV(MS_U32 * pInitVector)694 DRVAESDMA_RESULT _MDrv_AESDMA_SetOddIV(MS_U32 *pInitVector)
695 {
696 if (pInitVector != NULL)
697 {
698 AESDMA_Set_OddInitVector(pInitVector);
699 return DRVAESDMA_OK;
700 }
701 else
702 {
703 return DRVAESDMA_INVALID_PARAM;
704 }
705 }
706
MDrv_AESDMA_SetOddIV(MS_U32 * pInitVector)707 DRVAESDMA_RESULT MDrv_AESDMA_SetOddIV(MS_U32 *pInitVector)
708 {
709 #ifndef MSOS_TYPE_NUTTX
710 if(bSecureModeEnable)
711 {
712 return DRVAESDMA_OK;
713 }
714 else
715 {
716 if (NULL == pInstantAesdma)
717 return DRVAESDMA_FAIL;
718
719 if(UtopiaIoctl(pInstantAesdma, MDrv_CMD_AESDMA_SetOddIV, (void*)pInitVector) != UTOPIA_STATUS_SUCCESS)
720 {
721 return DRVAESDMA_FAIL;
722 }
723 return DRVAESDMA_OK;
724 }
725 #else
726 return _MDrv_AESDMA_SetOddIV(pInitVector);
727 #endif
728 }
729
730
MDrv_AESDMA_SetSecureKey(void)731 DRVAESDMA_RESULT MDrv_AESDMA_SetSecureKey(void)
732 {
733 #if (AESDMA_UTOPIA20)
734 if (NULL == pInstantAesdma)
735 return DRVAESDMA_FAIL;
736 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_SetSecureKey,NULL) != UTOPIA_STATUS_SUCCESS)
737 {
738 return DRVAESDMA_FAIL;
739 }
740 return DRVAESDMA_OK;
741 #else
742 AESDMA_Sel_SecureKey();
743 return DRVAESDMA_OK;
744 #endif
745 }
746
_MDrv_AESDMA_SetSecureKey(void)747 DRVAESDMA_RESULT _MDrv_AESDMA_SetSecureKey(void)
748 {
749 AESDMA_Sel_SecureKey();
750 return DRVAESDMA_OK;
751 }
752
_MDrv_AESDMA_SetIV(MS_U32 * pInitVector)753 DRVAESDMA_RESULT _MDrv_AESDMA_SetIV(MS_U32 *pInitVector)
754 {
755 if (pInitVector != NULL)
756 {
757 AESDMA_Set_InitVector(pInitVector);
758 return DRVAESDMA_OK;
759 }
760 else
761 {
762 return DRVAESDMA_INVALID_PARAM;
763 }
764 }
765
MDrv_AESDMA_SetIV(MS_U32 * pInitVector)766 DRVAESDMA_RESULT MDrv_AESDMA_SetIV(MS_U32 *pInitVector)
767 {
768 #if (AESDMA_UTOPIA20)
769 if (NULL == pInstantAesdma)
770 return DRVAESDMA_FAIL;
771
772 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_SetIV,(void*)pInitVector) != UTOPIA_STATUS_SUCCESS)
773 {
774 MS_DEBUG_MSG(printf("Ioctl MDrv_AESDMA_SetIV fail\n"));
775 return DRVAESDMA_FAIL;
776 }
777 return DRVAESDMA_OK;
778 #else
779 return _MDrv_AESDMA_SetIV(pInitVector);
780 #endif
781 }
782
MDrv_AESDMA_QueryCipherMode(DrvAESDMA_CipherMode eMode)783 DRVAESDMA_RESULT MDrv_AESDMA_QueryCipherMode(DrvAESDMA_CipherMode eMode)
784 {
785 return AESDMA_QueryCipherMode(eMode);
786 }
787
_MDrv_AESDMA_SelEng(DrvAESDMA_CipherMode eMode,MS_BOOL bDescrypt)788 DRVAESDMA_RESULT _MDrv_AESDMA_SelEng(DrvAESDMA_CipherMode eMode, MS_BOOL bDescrypt)
789 {
790 switch (eMode)
791 {
792 case E_DRVAESDMA_CIPHER_CTR:
793 case E_DRVAESDMA_CIPHER_DES_CTR:
794 case E_DRVAESDMA_CIPHER_TDES_CTR:
795 AESDMA_Set_CIPHER_ENG((AESDMA_CipherMode)eMode, FALSE);
796 break;
797 case E_DRVAESDMA_CIPHER_ECB:
798 case E_DRVAESDMA_CIPHER_CBC:
799 case E_DRVAESDMA_CIPHER_DES_ECB:
800 case E_DRVAESDMA_CIPHER_DES_CBC:
801 case E_DRVAESDMA_CIPHER_TDES_ECB:
802 case E_DRVAESDMA_CIPHER_TDES_CBC:
803 case E_DRVAESDMA_CIPHER_CTS_CBC:
804 case E_DRVAESDMA_CIPHER_CTS_ECB:
805 case E_DRVAESDMA_CIPHER_DES_CTS_CBC:
806 case E_DRVAESDMA_CIPHER_DES_CTS_ECB:
807 case E_DRVAESDMA_CIPHER_TDES_CTS_CBC:
808 case E_DRVAESDMA_CIPHER_TDES_CTS_ECB:
809 AESDMA_Set_CIPHER_ENG((AESDMA_CipherMode)eMode, bDescrypt);
810 break;
811 default:
812 break;
813 }
814 return DRVAESDMA_OK;
815 }
816
MDrv_AESDMA_SelEng(DrvAESDMA_CipherMode eMode,MS_BOOL bDescrypt)817 DRVAESDMA_RESULT MDrv_AESDMA_SelEng(DrvAESDMA_CipherMode eMode, MS_BOOL bDescrypt)
818 {
819 #if (AESDMA_UTOPIA20)
820 AESDMA_SEL_ENG SelEngParam;
821 SelEngParam.eMode= eMode;
822 SelEngParam.bDescrypt= bDescrypt;
823 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_SelEng,(void*)&SelEngParam) != UTOPIA_STATUS_SUCCESS)
824 {
825 return DRVAESDMA_FAIL;
826 }
827 return DRVAESDMA_OK;
828 #else
829 return _MDrv_AESDMA_SelEng(eMode,bDescrypt);
830 #endif
831 }
832
MDrv_AESDMA_SetPS(MS_U32 u32PTN,MS_U32 u32Mask,MS_BOOL bPSin_Enable,MS_BOOL bPSout_Enable)833 DRVAESDMA_RESULT MDrv_AESDMA_SetPS(MS_U32 u32PTN, MS_U32 u32Mask, MS_BOOL bPSin_Enable, MS_BOOL bPSout_Enable)
834 {
835 #if (AESDMA_UTOPIA20)
836 AESDMA_SET_PS SetPsParam;
837 SetPsParam.u32PTN = u32PTN;
838 SetPsParam.u32Mask = u32Mask;
839 SetPsParam.bPSin_Enable = bPSin_Enable;
840 SetPsParam.bPSout_Enable = bPSout_Enable;
841 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_SetPS,(void*)&SetPsParam) != UTOPIA_STATUS_SUCCESS)
842 {
843 return DRVAESDMA_FAIL;
844 }
845 return DRVAESDMA_OK;
846 #else
847 AESDMA_Set_PS_PTN(u32PTN);
848 AESDMA_Set_PS_Mask(u32Mask);
849 AESDMA_Set_PS_ENG(bPSin_Enable, bPSout_Enable);
850 AESDMA_Enable_Int();
851 return DRVAESDMA_OK;
852 #endif
853 }
854
_MDrv_AESDMA_SetPS(MS_U32 u32PTN,MS_U32 u32Mask,MS_BOOL bPSin_Enable,MS_BOOL bPSout_Enable)855 DRVAESDMA_RESULT _MDrv_AESDMA_SetPS(MS_U32 u32PTN, MS_U32 u32Mask, MS_BOOL bPSin_Enable, MS_BOOL bPSout_Enable)
856 {
857 AESDMA_Set_PS_PTN(u32PTN);
858 AESDMA_Set_PS_Mask(u32Mask);
859 AESDMA_Set_PS_ENG(bPSin_Enable, bPSout_Enable);
860 AESDMA_Enable_Int();
861
862 return DRVAESDMA_OK;
863 }
864
MDrv_AESDMA_PSRelease(void)865 DRVAESDMA_RESULT MDrv_AESDMA_PSRelease(void)
866 {
867 #if (AESDMA_UTOPIA20)
868 if (NULL == pInstantAesdma)
869 return DRVAESDMA_FAIL;
870 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_PSRelease,NULL) != UTOPIA_STATUS_SUCCESS)
871 {
872 return DRVAESDMA_FAIL;
873 }
874 return DRVAESDMA_OK;
875 #else
876 AESDMA_Set_PS_Release();
877 return DRVAESDMA_OK;
878 #endif
879 }
880
_MDrv_AESDMA_PSRelease(void)881 DRVAESDMA_RESULT _MDrv_AESDMA_PSRelease(void)
882 {
883 AESDMA_Set_PS_Release();
884 return DRVAESDMA_OK;
885 }
886
_MDrv_AESDMA_SetFileInOut(MS_PHY phy64FileinAddr,MS_U32 u32FileInNum,MS_PHY phy64FileOutSAddr,MS_PHY phy64FileOutEAddr)887 DRVAESDMA_RESULT _MDrv_AESDMA_SetFileInOut(MS_PHY phy64FileinAddr, MS_U32 u32FileInNum, MS_PHY phy64FileOutSAddr, MS_PHY phy64FileOutEAddr)
888 {
889 // check miu addr
890 if (!_AESDMA_Chk_MIU(&phy64FileinAddr, u32FileInNum, &phy64FileOutSAddr, &phy64FileOutEAddr))
891 {
892 return DRVAESDMA_MIU_ADDR_ERROR;
893 }
894
895 if ((phy64FileOutSAddr == 0) | (phy64FileOutEAddr == 0))
896 {
897 AESDMA_Set_FileinDesc(phy64FileinAddr , u32FileInNum);
898 }
899 else
900 {
901 AESDMA_Set_FileinDesc(phy64FileinAddr, u32FileInNum);
902 AESDMA_Set_FileoutDesc(phy64FileOutSAddr, phy64FileOutEAddr);
903 }
904
905 phyTmpFileInAddr = phy64FileinAddr;
906 u32TmpFileInNum = u32FileInNum;
907 phyTmpFileOutAddr = phy64FileOutSAddr;
908
909 return DRVAESDMA_OK;
910 }
911
MDrv_AESDMA_SetFileInOut(MS_PHY u32FileinAddr,MS_U32 u32FileInNum,MS_PHY u32FileOutSAddr,MS_PHY u32FileOutEAddr)912 DRVAESDMA_RESULT MDrv_AESDMA_SetFileInOut(MS_PHY u32FileinAddr, MS_U32 u32FileInNum, MS_PHY u32FileOutSAddr, MS_PHY u32FileOutEAddr)
913 {
914 #if (AESDMA_UTOPIA20)
915 AESDMA_FILE_INOUT FileInOutParam;
916 FileInOutParam.u32FileinAddr= u32FileinAddr;
917 FileInOutParam.u32FileInNum= u32FileInNum;
918 FileInOutParam.u32FileOutSAddr= u32FileOutSAddr;
919 FileInOutParam.u32FileOutEAddr= u32FileOutEAddr;
920
921 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_SetFileInOut,(void*)&FileInOutParam) != UTOPIA_STATUS_SUCCESS)
922 {
923 return DRVAESDMA_FAIL;
924 }
925 return DRVAESDMA_OK;
926 #else
927 return _MDrv_AESDMA_SetFileInOut(u32FileinAddr,u32FileInNum,u32FileOutSAddr,u32FileOutEAddr);
928 #endif
929 }
930
_MDrv_AESDMA_Start(MS_BOOL bStart)931 DRVAESDMA_RESULT _MDrv_AESDMA_Start(MS_BOOL bStart)
932 {
933 if (!MsOS_Dcache_Flush(MsOS_PA2KSEG0(phyTmpFileOutAddr), u32TmpFileInNum))
934 MsOS_Dcache_Flush(MsOS_PA2KSEG0(phyTmpFileOutAddr) & ~((MS_VIRT)0x0F), u32TmpFileInNum+32);
935
936 MsOS_FlushMemory();
937 AESDMA_Start(bStart);
938 return DRVAESDMA_OK;
939 }
940
MDrv_AESDMA_Start(MS_BOOL bStart)941 DRVAESDMA_RESULT MDrv_AESDMA_Start(MS_BOOL bStart)
942 {
943 #if (AESDMA_UTOPIA20)
944 if (NULL == pInstantAesdma)
945 return DRVAESDMA_FAIL;
946
947 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_Start,(void*)&bStart) != UTOPIA_STATUS_SUCCESS)
948 {
949 return DRVAESDMA_FAIL;
950 }
951 return DRVAESDMA_OK;
952 #else
953 return _MDrv_AESDMA_Start(bStart);
954 #endif
955 }
956
MDrv_AESDMA_Reset(void)957 DRVAESDMA_RESULT MDrv_AESDMA_Reset(void)
958 {
959 #if (AESDMA_UTOPIA20)
960 if (NULL == pInstantAesdma)
961 return DRVAESDMA_FAIL;
962
963 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_Reset,NULL) != UTOPIA_STATUS_SUCCESS)
964 {
965 return DRVAESDMA_FAIL;
966 }
967
968 return DRVAESDMA_OK;
969 #else
970 AESDMA_Reset();
971 AESDMA_HW_Patch();
972 AESDMA_Enable_Int();
973 AESDMA_Parser_Enable_HWParser(FALSE);
974 return DRVAESDMA_OK;
975 #endif
976 }
977
_MDrv_AESDMA_NormalReset(void)978 DRVAESDMA_RESULT _MDrv_AESDMA_NormalReset(void)
979 {
980 #ifndef MSOS_TYPE_NUTTX
981 if(bSecureModeEnable)
982 {
983 return DRVAESDMA_OK;
984 }
985 else
986 {
987 AESDMA_NormalReset();
988 AESDMA_HW_Patch();
989 AESDMA_Enable_Int();
990 AESDMA_Parser_Enable_HWParser(FALSE);
991 return DRVAESDMA_OK;
992 }
993 #else
994 AESDMA_NormalReset();
995 AESDMA_HW_Patch();
996 AESDMA_Enable_Int();
997 AESDMA_Parser_Enable_HWParser(FALSE);
998 return DRVAESDMA_OK;
999 #endif
1000 }
1001
_MDrv_AESDMA_Reset(void)1002 DRVAESDMA_RESULT _MDrv_AESDMA_Reset(void)
1003 {
1004 AESDMA_Reset();
1005 AESDMA_HW_Patch();
1006 AESDMA_Enable_Int();
1007 AESDMA_Parser_Enable_HWParser(FALSE);
1008 return DRVAESDMA_OK;
1009 }
MDrv_AESDMA_GetStatus(void)1010 MS_U32 MDrv_AESDMA_GetStatus(void)
1011 {
1012 #if (AESDMA_UTOPIA20)
1013 MS_U32 u32RetVal = 0;
1014 if (NULL == pInstantAesdma)
1015 return DRVAESDMA_FAIL;
1016 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_GetStatus,(void*)&u32RetVal) != UTOPIA_STATUS_SUCCESS)
1017 {
1018 return 0;
1019 }
1020 return u32RetVal;
1021 #else
1022 return AESDMA_Get_AESDMA_Status();
1023 #endif
1024 }
_MDrv_AESDMA_GetStatus(MS_U32 * u32RetVal)1025 DRVAESDMA_RESULT _MDrv_AESDMA_GetStatus(MS_U32 *u32RetVal)
1026 {
1027 *u32RetVal = AESDMA_Get_AESDMA_Status();
1028
1029 return DRVAESDMA_OK;
1030 }
1031
_MDrv_AESDMA_IsFinished(MS_U32 * u32RetVal)1032 DRVAESDMA_RESULT _MDrv_AESDMA_IsFinished(MS_U32 *u32RetVal)
1033 {
1034 if(AESDMA_Get_AESDMA_IsFinished())
1035 {
1036 *u32RetVal = DRVAESDMA_OK;
1037 MsOS_ReadMemory();
1038 return DRVAESDMA_OK;
1039 }
1040 else
1041 {
1042 *u32RetVal = DRVAESDMA_FAIL;
1043 return DRVAESDMA_FAIL;
1044 }
1045 }
1046
MDrv_AESDMA_IsFinished(void)1047 DRVAESDMA_RESULT MDrv_AESDMA_IsFinished(void)
1048 {
1049 #if (AESDMA_UTOPIA20)
1050 MS_U32 u32TimeOut = AES_MAX_TIMEOUT_VALUE;
1051 if (NULL == pInstantAesdma)
1052 return DRVAESDMA_FAIL;
1053
1054 if(UtopiaIoctl(pInstantAesdma, MDrv_CMD_AESDMA_IsFinished, (void*)&u32TimeOut) != UTOPIA_STATUS_SUCCESS)
1055 {
1056 return DRVAESDMA_FAIL;
1057 }
1058 return DRVAESDMA_OK;
1059 #else
1060 return _MDrv_AESDMA_IsFinished();
1061 #endif
1062 }
1063
MDrv_AESDMA_GetPSMatchedByteCNT(void)1064 MS_U32 MDrv_AESDMA_GetPSMatchedByteCNT(void)
1065 {
1066 #if (AESDMA_UTOPIA20)
1067 MS_U32 u32Count = 0x000;
1068
1069 if (NULL == pInstantAesdma)
1070 return DRVAESDMA_FAIL;
1071
1072 if(UtopiaIoctl(pInstantAesdma, MDrv_CMD_AESDMA_GetPSMatchedByteCNT, (void*)&u32Count) != UTOPIA_STATUS_SUCCESS)
1073 {
1074 return 0;
1075 }
1076
1077 return u32Count;
1078 #else
1079 return AESDMA_Get_PS_MatchedBytecnt();
1080 #endif
1081 }
1082
_MDrv_AESDMA_GetPSMatchedByteCNT(MS_U32 * u32RetVal)1083 MS_U32 _MDrv_AESDMA_GetPSMatchedByteCNT(MS_U32 *u32RetVal)
1084 {
1085 MS_U32 u32Val = AESDMA_Get_PS_MatchedBytecnt();
1086 *u32RetVal = u32Val;
1087 return u32Val;
1088 }
1089
MDrv_AESDMA_GetPSMatchedPTN(void)1090 MS_U32 MDrv_AESDMA_GetPSMatchedPTN(void)
1091 {
1092 #if (AESDMA_UTOPIA20)
1093 if (NULL == pInstantAesdma)
1094 return DRVAESDMA_FAIL;
1095
1096 return UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_GetPSMatchedPTN,NULL);
1097 #else
1098 return AESDMA_Get_PS_MatchedPTN();
1099 #endif
1100 }
1101
_MDrv_AESDMA_GetPSMatchedPTN(void)1102 MS_U32 _MDrv_AESDMA_GetPSMatchedPTN(void)
1103 {
1104 return AESDMA_Get_PS_MatchedPTN();
1105 }
1106
MDrv_AESDMA_Notify(DrvAESDMA_Event eEvents,P_DrvAESDMA_EvtCallback pfCallback)1107 DRVAESDMA_RESULT MDrv_AESDMA_Notify(DrvAESDMA_Event eEvents, P_DrvAESDMA_EvtCallback pfCallback)
1108 {
1109 #if (AESDMA_UTOPIA20)
1110 AESDMA_NOTIFY stNotifyParam;
1111
1112 if (NULL == pInstantAesdma)
1113 return DRVAESDMA_FAIL;
1114
1115 stNotifyParam.eEvents = eEvents;
1116 stNotifyParam.pfCallback = pfCallback;
1117
1118 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_Notify, (void*)&stNotifyParam) != UTOPIA_STATUS_SUCCESS)
1119 {
1120 return DRVAESDMA_FAIL;
1121 }
1122
1123 _AESDMAEvtNotify = eEvents;
1124 _AESDMACallback = pfCallback;
1125
1126 return DRVAESDMA_OK;
1127 #else
1128 if (pfCallback)
1129 {
1130 AESDMA_Enable_Int();
1131 }
1132 else
1133 {
1134 AESDMA_Disable_Int();
1135 }
1136
1137 _AESDMAEvtNotify = eEvents;
1138 _AESDMACallback = pfCallback;
1139
1140 return DRVAESDMA_OK;
1141 #endif
1142 }
1143
_MDrv_AESDMA_Notify(DrvAESDMA_Event eEvents,P_DrvAESDMA_EvtCallback pfCallback)1144 DRVAESDMA_RESULT _MDrv_AESDMA_Notify(DrvAESDMA_Event eEvents, P_DrvAESDMA_EvtCallback pfCallback)
1145 {
1146 if (pfCallback)
1147 {
1148 AESDMA_Enable_Int();
1149 }
1150 else
1151 {
1152 AESDMA_Disable_Int();
1153 }
1154
1155 return DRVAESDMA_OK;
1156 }
1157
MDrv_AESDMA_SetDbgLevel(DrvAESDMA_DbgLevel DbgLevel)1158 DRVAESDMA_RESULT MDrv_AESDMA_SetDbgLevel(DrvAESDMA_DbgLevel DbgLevel)
1159 {
1160 _u32AESDMADBGLevel = DbgLevel;
1161 return DRVAESDMA_OK;
1162 }
1163
MDrv_AESDMA_GetLibVer(const MSIF_Version ** ppVersion)1164 DRVAESDMA_RESULT MDrv_AESDMA_GetLibVer(const MSIF_Version **ppVersion)
1165 {
1166 // No mutex check, it can be called before Init
1167 if (!ppVersion)
1168 {
1169 return DRVAESDMA_FAIL;
1170 }
1171
1172 *ppVersion = &_drv_aesdma_version;
1173
1174 return DRVAESDMA_OK;
1175 }
1176
MDrv_AESDMA_Rand(MS_U32 * u32PABuf,MS_U32 u32Size)1177 DRVAESDMA_RESULT MDrv_AESDMA_Rand(MS_U32 *u32PABuf, MS_U32 u32Size)
1178 {
1179 #if (AESDMA_UTOPIA20)
1180
1181 AESDMA_RAND stAesdmaRand;
1182 stAesdmaRand.u32PABuf = u32PABuf;
1183 stAesdmaRand.u32Size = u32Size;
1184
1185 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_Rand, (void*)&stAesdmaRand) != UTOPIA_STATUS_SUCCESS)
1186 {
1187 return DRVAESDMA_FAIL;
1188 }
1189 return DRVAESDMA_OK;
1190
1191 #else
1192 MS_U32 Index;
1193 MS_U8 *u8VABuf = (MS_U8 *)MsOS_PA2KSEG1((MS_U32)u32PABuf);
1194
1195 for( Index = 0; Index < u32Size; Index++ )
1196 {
1197 *(u8VABuf + Index) = AESDMA_Rand();
1198 }
1199 return DRVAESDMA_OK;
1200 #endif
1201 }
1202
_MDrv_AESDMA_Rand(MS_U32 * u32PABuf,MS_U32 u32Size)1203 DRVAESDMA_RESULT _MDrv_AESDMA_Rand(MS_U32 *u32PABuf, MS_U32 u32Size)
1204 {
1205 MS_U32 Index;
1206 ptrdiff_t n = (ptrdiff_t)u32PABuf;
1207 MS_U8 *u8VABuf = (MS_U8 *)MsOS_PA2KSEG1((MS_PHY)n);
1208
1209 for( Index = 0; Index < u32Size; Index++ )
1210 {
1211 *(u8VABuf + Index) = AESDMA_Rand();
1212 }
1213 return DRVAESDMA_OK;
1214 }
1215
_MDrv_AESDMA_Get_Rand_Num(MS_U8 * pu8Num)1216 DRVAESDMA_RESULT _MDrv_AESDMA_Get_Rand_Num(MS_U8 *pu8Num)
1217 {
1218
1219 *pu8Num = AESDMA_Rand();
1220
1221 return DRVAESDMA_OK;
1222 }
1223
MDrv_AESDMA_Set_Clk(MS_BOOL benable)1224 DRVAESDMA_RESULT MDrv_AESDMA_Set_Clk(MS_BOOL benable)
1225 {
1226 #if (AESDMA_UTOPIA20)
1227 if (NULL == pInstantAesdma)
1228 return DRVAESDMA_FAIL;
1229 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_SetClk,(void*)&benable) != UTOPIA_STATUS_SUCCESS)
1230 {
1231 return DRVAESDMA_FAIL;
1232 }
1233 return DRVAESDMA_OK;
1234 #else
1235 if(benable)
1236 {
1237 AESDMA_Enable_Clk();
1238 }
1239 else
1240 {
1241 AESDMA_Disable_Clk();
1242 }
1243 return DRVAESDMA_OK;
1244 #endif
1245 }
1246
_MDrv_AESDMA_Set_Clk(MS_BOOL benable)1247 DRVAESDMA_RESULT _MDrv_AESDMA_Set_Clk(MS_BOOL benable)
1248 {
1249 if(benable)
1250 {
1251 AESDMA_Enable_Clk();
1252 }
1253 else
1254 {
1255 AESDMA_Disable_Clk();
1256 }
1257
1258 return DRVAESDMA_OK;
1259 }
1260
_MDrv_SHA_Calculate(DrvAESDMA_SHAMode eMode,MS_PHY phy64PAInBuf,MS_U32 u32Size,MS_PHY phy64PAOutBuf)1261 DRVAESDMA_RESULT _MDrv_SHA_Calculate(DrvAESDMA_SHAMode eMode, MS_PHY phy64PAInBuf, MS_U32 u32Size, MS_PHY phy64PAOutBuf)
1262 {
1263 MS_U8 *u8scattergather_format = 0; //[B7, B6, B5, B4] = MIU byte address;[B3, B2, B1, B0] = the length of this message block
1264 MS_PHY u32scattergather_Address = 0;
1265 MS_U32 u32OutOffset = 0;
1266 MS_U32 u32timeout_count = 0;
1267 MS_PHY phy64PAOutBufE;
1268
1269
1270 switch (eMode)
1271 {
1272 case E_AESDMA_SHA1:
1273 u32OutOffset = 20; //Out 160-bit
1274 break;
1275
1276 case E_AESDMA_SHA256:
1277 u32OutOffset = 32; //Out 256-bit
1278 break;
1279
1280 default:
1281 return DRVAESDMA_INVALID_PARAM;
1282 }
1283 #if 1
1284 // check miu addr
1285 phy64PAOutBufE = (phy64PAOutBuf + u32OutOffset);
1286 if (!_AESDMA_Chk_MIU(&phy64PAInBuf, u32Size, &phy64PAOutBuf, &phy64PAOutBufE))
1287 {
1288 DEBUG_AES_DMA(E_DRVAESDMA_DBG_L1, ULOGE(TAG_AESDMA, "@@@DRVAESDMA_MIU_ADDR_ERROR\n"));
1289 return DRVAESDMA_MIU_ADDR_ERROR;
1290 }
1291 #endif
1292 // Clear all SHA setting(clear the last outputs)
1293 SHA_Reset();
1294
1295 // Error handler for 16-byte alignment limitation
1296 if(phy64PAInBuf & WORD_MASK)
1297 {
1298 DEBUG_AES_DMA(E_DRVAESDMA_DBG_L1, ULOGE(TAG_AESDMA, "Input Address should be 16-byte alignment\n"));
1299 return DRVAESDMA_FAIL;
1300 }
1301
1302 u32scattergather_Address = ALIGN_8(phy64PAInBuf + u32Size);
1303
1304 u32Size /= SHA_UNIT_SIZE;
1305 phy64PAInBuf /= SHA_UNIT_SIZE;
1306
1307 if(phy64PAInBuf > _u32MIU1_Addr)
1308 {
1309 SHA_SetAddress((u32scattergather_Address | SHA_MIU1_ENABLE) / SHA_UNIT_SIZE);
1310 phy64PAInBuf = phy64PAInBuf | SHA_MIU1_ENABLE;
1311 }
1312 else
1313 {
1314 SHA_SetAddress((u32scattergather_Address) / SHA_UNIT_SIZE);
1315 }
1316
1317 SHA_SetLength(u32Size);
1318
1319 u8scattergather_format = (MS_U8 *)MsOS_PA2KSEG1(u32scattergather_Address);
1320 *(u8scattergather_format++) = (MS_U8)((u32Size>>0x00)&0xFF);
1321 *(u8scattergather_format++) = (MS_U8)((u32Size>>0x08)&0xFF);
1322 *(u8scattergather_format++) = (MS_U8)((u32Size>>0x10)&0xFF);
1323 *(u8scattergather_format++) = (MS_U8)((u32Size>>0x18)&0xFF);
1324 *(u8scattergather_format++) = (MS_U8)(((phy64PAInBuf)>>0x00)&0xFF);
1325 *(u8scattergather_format++) = (MS_U8)(((phy64PAInBuf)>>0x08)&0xFF);
1326 *(u8scattergather_format++) = (MS_U8)(((phy64PAInBuf)>>0x10)&0xFF);
1327 *(u8scattergather_format++) = (MS_U8)(((phy64PAInBuf)>>0x18)&0xFF);
1328
1329 SHA_SelMode((AESDMA_SHAMode)eMode);
1330 MsOS_DelayTaskUs(40);
1331
1332 MsOS_FlushMemory();
1333
1334 MsOS_DelayTaskUs(200);
1335
1336 SHA_Start(1);
1337
1338 while ((SHA_Get_Status() & SHARNG_CTRL_SHA_READY) == 0)
1339 {
1340 MsOS_DelayTaskUs(10);
1341 u32timeout_count++;
1342 #if (SHA_WAIT==1)
1343 //500ms timeout
1344 if(u32timeout_count>SHA_TIMEOUT_VALUE)
1345 {
1346 SHA_Reset();
1347 return DRVAESDMA_FAIL;
1348 }
1349 #endif
1350 }
1351
1352 SHA_Out(MsOS_PA2KSEG1(phy64PAOutBuf));
1353 while ((SHA_Get_Status() & SHARNG_CTRL_SHA_BUSY) != 0)
1354 ;
1355 return DRVAESDMA_OK;
1356 }
1357
MDrv_SHA_Calculate(DrvAESDMA_SHAMode eMode,MS_PHY u32PAInBuf,MS_U32 u32Size,MS_PHY u32PAOutBuf)1358 DRVAESDMA_RESULT MDrv_SHA_Calculate(DrvAESDMA_SHAMode eMode, MS_PHY u32PAInBuf, MS_U32 u32Size, MS_PHY u32PAOutBuf)
1359 {
1360 #if (AESDMA_UTOPIA20)
1361 SHA_CALCULATE ShaCalParam;
1362 ShaCalParam.eMode= eMode;
1363 ShaCalParam.u32PAInBuf= u32PAInBuf;
1364 ShaCalParam.u32Size= u32Size;
1365 ShaCalParam.u32PAOutBuf= u32PAOutBuf;
1366
1367 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_SHA_Calculate,(void*)&ShaCalParam) != UTOPIA_STATUS_SUCCESS)
1368 {
1369 return DRVAESDMA_FAIL;
1370 }
1371 return DRVAESDMA_OK;
1372 #else
1373 return _MDrv_SHA_Calculate(eMode,u32PAInBuf,u32Size,u32PAOutBuf, NULL);
1374 #endif
1375 }
1376
MDrv_SHA_CalculateManual(DrvAESDMA_HASHCFG stCfg,DrvAESDMA_HASH_STAGE eStage,MS_U32 u32DoneBytes,MS_U8 * pu8SetIV)1377 DRVAESDMA_RESULT MDrv_SHA_CalculateManual(DrvAESDMA_HASHCFG stCfg, DrvAESDMA_HASH_STAGE eStage, MS_U32 u32DoneBytes, MS_U8 *pu8SetIV)
1378 {
1379
1380 //not implement yet
1381 return DRVAESDMA_OK;
1382 }
1383
1384
1385
1386 #ifdef MOBF_ENABLE
1387 //-------------------------------------------------------------------------------------------------
1388 /// MOBF BDMA without any Encrypt (sw patch)
1389 ///
1390
1391 /// @return AESDMA_Result
1392 /// @note Must be called after MDrv_AESDMA_SelEng(E_DRVAESDMA_CIPHER_DES_CTR,1)
1393 //-------------------------------------------------------------------------------------------------
MDrv_MOBF_DmaOnly(void)1394 DRVAESDMA_RESULT MDrv_MOBF_DmaOnly(void)
1395 {
1396 MOBF_DisableTDES();
1397 return DRVAESDMA_OK;
1398 }
1399
1400 //-------------------------------------------------------------------------------------------------
1401 /// Set MOBF encrypt (from AESDMA to MIU)
1402 /// @param u32Key \b IN: Encrypt Key
1403 /// @param bEnable \b IN: Encrypt Enable/disable
1404
1405 /// @return AESDMA_Result
1406 /// @note
1407 //-------------------------------------------------------------------------------------------------
MDrv_MOBF_Encrypt(MS_U32 u32Key,MS_BOOL bEnable)1408 DRVAESDMA_RESULT MDrv_MOBF_Encrypt(MS_U32 u32Key, MS_BOOL bEnable)
1409 {
1410 MOBF_WriteKey(u32Key);
1411 MOBF_WriteEnable(bEnable);
1412
1413 return DRVAESDMA_OK;
1414 }
1415
1416 //-------------------------------------------------------------------------------------------------
1417 /// Set MOBF decrypt (from MIU to AESDMA)
1418 /// @param u32Key \b IN: Decrypt Key
1419 /// @param bEnable \b IN: Decrypt Enable/disable
1420
1421 /// @return AESDMA_Result
1422 /// @note
1423 //-------------------------------------------------------------------------------------------------
MDrv_MOBF_Decrypt(MS_U32 u32Key,MS_BOOL bEnable)1424 DRVAESDMA_RESULT MDrv_MOBF_Decrypt(MS_U32 u32Key, MS_BOOL bEnable)
1425 {
1426 MOBF_ReadKey(u32Key);
1427 MOBF_ReadEnable(bEnable);
1428
1429 return DRVAESDMA_OK;
1430 }
1431
1432 //-------------------------------------------------------------------------------------------------
1433 /// Enable MOBF One Way
1434 /// @return AESDMA_Result
1435 /// @note disable read mobf key
1436 //-------------------------------------------------------------------------------------------------
MDrv_MOBF_OneWay(void)1437 DRVAESDMA_RESULT MDrv_MOBF_OneWay(void)
1438 {
1439 MOBF_OneWay();
1440 return DRVAESDMA_OK;
1441 }
1442
1443 #endif
1444
1445 //-------------------------------------------------------------------------------------------------
1446 /// Mask Scrmb bit(for decrypt using)
1447 /// @param bEnable \b IN: Mask Scrmb Enable/disable
1448 /// @return AESDMA_Result
1449 /// @note mask Scrmb bit
1450 //-------------------------------------------------------------------------------------------------
_MDrv_AESDMA_Parser_MaskScrmb(MS_BOOL bEnable)1451 DRVAESDMA_RESULT _MDrv_AESDMA_Parser_MaskScrmb(MS_BOOL bEnable)
1452 {
1453 AESDMA_Parser_Mask_Scrmb(bEnable);
1454 return DRVAESDMA_OK;
1455 }
1456
MDrv_AESDMA_Parser_MaskScrmb(MS_BOOL bEnable)1457 DRVAESDMA_RESULT MDrv_AESDMA_Parser_MaskScrmb(MS_BOOL bEnable)
1458 {
1459 #if (AESDMA_UTOPIA20)
1460
1461 if (NULL == pInstantAesdma)
1462 return DRVAESDMA_FAIL;
1463
1464 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_PARSER_MASKSCRMB,(void*)&bEnable) != UTOPIA_STATUS_SUCCESS)
1465 {
1466 return DRVAESDMA_FAIL;
1467 }
1468 return DRVAESDMA_OK;
1469
1470 #else
1471 AESDMA_Parser_Mask_Scrmb(bEnable);
1472 return DRVAESDMA_OK;
1473 #endif
1474 }
1475
1476 //-------------------------------------------------------------------------------------------------
1477 /// Set Scrmb Pattern
1478 /// @param ePattern \b IN: input Scrmb pattern(10/11)
1479 /// @return AESDMA_Result
1480 /// @note set Scrmb Pattern
1481 //-------------------------------------------------------------------------------------------------
_MDrv_AESDMA_Parser_SetScrmbPattern(DrvAESDMA_ScrmbPattern ePattern)1482 DRVAESDMA_RESULT _MDrv_AESDMA_Parser_SetScrmbPattern(DrvAESDMA_ScrmbPattern ePattern)
1483 {
1484 AESDMA_Parser_Set_ScrmbPattern(ePattern);
1485 return DRVAESDMA_OK;
1486 }
1487
MDrv_AESDMA_Parser_SetScrmbPattern(DrvAESDMA_ScrmbPattern ePattern)1488 DRVAESDMA_RESULT MDrv_AESDMA_Parser_SetScrmbPattern(DrvAESDMA_ScrmbPattern ePattern)
1489 {
1490 #if (AESDMA_UTOPIA20)
1491
1492 if (NULL == pInstantAesdma)
1493 return DRVAESDMA_FAIL;
1494
1495 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_PARSER_SETSCRMBPATTERN,(void*)&ePattern) != UTOPIA_STATUS_SUCCESS)
1496 {
1497 return DRVAESDMA_FAIL;
1498 }
1499 return DRVAESDMA_OK;
1500
1501 #else
1502 AESDMA_Parser_Set_ScrmbPattern(ePattern);
1503 return DRVAESDMA_OK;
1504 #endif
1505 }
1506
1507 //-------------------------------------------------------------------------------------------------
1508 /// Set Scrmb Pattern
1509 /// @param ePattern \b IN: input Scrmb pattern(10/11)
1510 /// @return AESDMA_Result
1511 /// @note set Scrmb Pattern
1512 //-------------------------------------------------------------------------------------------------
_MDrv_AESDMA_Parser_SetAddedScrmbPattern(DrvAESDMA_ScrmbPattern ePattern)1513 DRVAESDMA_RESULT _MDrv_AESDMA_Parser_SetAddedScrmbPattern(DrvAESDMA_ScrmbPattern ePattern)
1514 {
1515 AESDMA_Parser_Set_AddedScrmbPattern(ePattern);
1516 return DRVAESDMA_OK;
1517 }
1518
MDrv_AESDMA_Parser_SetAddedScrmbPattern(DrvAESDMA_ScrmbPattern ePattern)1519 DRVAESDMA_RESULT MDrv_AESDMA_Parser_SetAddedScrmbPattern(DrvAESDMA_ScrmbPattern ePattern)
1520 {
1521 #if (AESDMA_UTOPIA20)
1522 if (NULL == pInstantAesdma)
1523 return DRVAESDMA_FAIL;
1524
1525 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_PARSER_SETADDEDSCRMBPATTERN,(void*)&ePattern) != UTOPIA_STATUS_SUCCESS)
1526 {
1527 return DRVAESDMA_FAIL;
1528 }
1529 return DRVAESDMA_OK;
1530
1531 #else
1532 AESDMA_Parser_Set_AddedScrmbPattern(ePattern);
1533 return DRVAESDMA_OK;
1534 #endif
1535 }
1536
1537 //-------------------------------------------------------------------------------------------------
1538 /// Query Pid Count
1539 /// @return Pid Count
1540 /// @note query pid count
1541 //-------------------------------------------------------------------------------------------------
_MDrv_AESDMA_Parser_QueryPidCount(MS_U8 * retCount)1542 MS_U8 _MDrv_AESDMA_Parser_QueryPidCount(MS_U8* retCount)
1543 {
1544 *retCount = AESDMA_Parser_Query_PidCount();
1545 return *retCount;
1546 }
1547
MDrv_AESDMA_Parser_QueryPidCount(void)1548 MS_U8 MDrv_AESDMA_Parser_QueryPidCount(void)
1549 {
1550 #if (AESDMA_UTOPIA20)
1551
1552 MS_U8 mCount = 0;
1553 if (NULL == pInstantAesdma)
1554 return DRVAESDMA_FAIL;
1555
1556 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_PARSER_QUERYPIDCOUNT,(void*)&mCount) != UTOPIA_STATUS_SUCCESS)
1557 {
1558 return mCount;
1559 }
1560 return mCount;
1561
1562 #else
1563 return AESDMA_Parser_Query_PidCount();
1564 #endif
1565 }
1566
1567 //-------------------------------------------------------------------------------------------------
1568 /// Set Pid
1569 /// @param u8Index \b IN: Pid Index(0/1)
1570 /// @param u16Pid \b IN: Pid Value(max value is 0x1FFF)
1571 /// @return AESDMA_Result
1572 /// @note set Pid
1573 //-------------------------------------------------------------------------------------------------
_MDrv_AESDMA_Parser_SetPid(MS_U8 u8Index,MS_U16 u16Pid)1574 DRVAESDMA_RESULT _MDrv_AESDMA_Parser_SetPid(MS_U8 u8Index, MS_U16 u16Pid)
1575 {
1576 MS_U8 u8PidCount;
1577 // check Pid value
1578 if (u16Pid > AESDMA_PARSER_PID_MAX)
1579 {
1580 return DRVAESDMA_INVALID_PARAM;
1581 }
1582
1583 // check Pid count
1584 u8PidCount = AESDMA_Parser_Query_PidCount();
1585 if (u8Index >= u8PidCount)
1586 {
1587 return DRVAESDMA_INVALID_PARAM;
1588 }
1589
1590 AESDMA_Parser_Set_Pid(u8Index,u16Pid);
1591 return DRVAESDMA_OK;
1592 }
1593
MDrv_AESDMA_Parser_SetPid(MS_U8 u8Index,MS_U16 u16Pid)1594 DRVAESDMA_RESULT MDrv_AESDMA_Parser_SetPid(MS_U8 u8Index, MS_U16 u16Pid)
1595 {
1596 #if (AESDMA_UTOPIA20)
1597 AESDMA_PARSER_PID_CONFIGURATIONS mConfig;
1598
1599 if (NULL == pInstantAesdma)
1600 return DRVAESDMA_FAIL;
1601
1602 mConfig.u8PidIndex = u8Index;
1603 mConfig.u16Pid = u16Pid;
1604
1605 if(UtopiaIoctl(pInstantAesdma, MDrv_CMD_AESDMA_PARSER_SETPID,(void*)&mConfig) != UTOPIA_STATUS_SUCCESS)
1606 {
1607 return DRVAESDMA_FAIL;
1608 }
1609 return DRVAESDMA_OK;
1610
1611 #else
1612 MS_U8 u8PidCount;
1613 // check Pid value
1614 if (u16Pid > AESDMA_PARSER_PID_MAX)
1615 {
1616 return DRVAESDMA_INVALID_PARAM;
1617 }
1618
1619 // check Pid count
1620 u8PidCount = AESDMA_Parser_Query_PidCount();
1621 if (u8Index >= u8PidCount)
1622 {
1623 return DRVAESDMA_INVALID_PARAM;
1624 }
1625
1626 AESDMA_Parser_Set_Pid(u8Index,u16Pid);
1627 return DRVAESDMA_OK;
1628 #endif
1629 }
1630
1631 //-------------------------------------------------------------------------------------------------
1632 /// Bypass Pid
1633 /// @param bEnable \b IN: Bypass Pid Enable/disable
1634 /// @return AESDMA_Result
1635 /// @note bypass Pid
1636 //-------------------------------------------------------------------------------------------------
_MDrv_AESDMA_Parser_BypassPid(MS_BOOL bEnable)1637 DRVAESDMA_RESULT _MDrv_AESDMA_Parser_BypassPid(MS_BOOL bEnable)
1638 {
1639 AESDMA_Parser_Bypass_Pid(bEnable);
1640 return DRVAESDMA_OK;
1641 }
1642
MDrv_AESDMA_Parser_BypassPid(MS_BOOL bEnable)1643 DRVAESDMA_RESULT MDrv_AESDMA_Parser_BypassPid(MS_BOOL bEnable)
1644 {
1645 #if (AESDMA_UTOPIA20)
1646
1647 if (NULL == pInstantAesdma)
1648 return DRVAESDMA_FAIL;
1649
1650 if(UtopiaIoctl(pInstantAesdma, MDrv_CMD_AESDMA_PARSER_BYPASSPID,(void*)&bEnable) != UTOPIA_STATUS_SUCCESS)
1651 {
1652 return DRVAESDMA_FAIL;
1653 }
1654 return DRVAESDMA_OK;
1655
1656 #else
1657 AESDMA_Parser_Bypass_Pid(bEnable);
1658 return DRVAESDMA_OK;
1659 #endif
1660 }
1661
1662 //-------------------------------------------------------------------------------------------------
1663 /// Init Parser Encrypt
1664 /// @param eMode \b IN: input parser mode
1665 /// @return AESDMA_Result
1666 /// @note init parser encrypt
1667 //-------------------------------------------------------------------------------------------------
_MDrv_AESDMA_Parser_Encrypt(DrvAESDMA_ParserMode eMode)1668 DRVAESDMA_RESULT _MDrv_AESDMA_Parser_Encrypt(DrvAESDMA_ParserMode eMode)
1669 {
1670 AESDMA_Parser_Set_Mode((AESDMA_ParserMode)eMode);
1671 switch (eMode)
1672 {
1673 case E_DRVAESDMA_PARSER_TS_PKT192:
1674 case E_DRVAESDMA_PARSER_TS_PKT192_CLEAR:
1675 case E_DRVAESDMA_PARSER_TS_PKT188:
1676 case E_DRVAESDMA_PARSER_TS_PKT188_CLEAR:
1677 AESDMA_Parser_Insert_Scrmb(TRUE);
1678 AESDMA_Parser_Remove_Scrmb(FALSE);
1679 break;
1680
1681 case E_DRVAESDMA_PARSER_HDCP20_PKT192:
1682 case E_DRVAESDMA_PARSER_HDCP20_PKT192_CLEAR:
1683 case E_DRVAESDMA_PARSER_HDCP20_PKT188:
1684 case E_DRVAESDMA_PARSER_HDCP20_PKT188_CLEAR:
1685 AESDMA_Parser_Insert_Scrmb(FALSE);
1686 AESDMA_Parser_Remove_Scrmb(FALSE);
1687 break;
1688 }
1689
1690 AESDMA_Parser_Enable_HWParser(TRUE);
1691 return DRVAESDMA_OK;
1692 }
1693
MDrv_AESDMA_Parser_Encrypt(DrvAESDMA_ParserMode eMode)1694 DRVAESDMA_RESULT MDrv_AESDMA_Parser_Encrypt(DrvAESDMA_ParserMode eMode)
1695 {
1696 #if (AESDMA_UTOPIA20)
1697 AESDMA_PARSER_CONFIGURATIONS stArgs;
1698
1699 if (NULL == pInstantAesdma)
1700 return DRVAESDMA_FAIL;
1701
1702 stArgs.eParserMode = eMode;
1703
1704 if(UtopiaIoctl(pInstantAesdma, MDrv_CMD_AESDMA_PARSER_ENCRYPT,(void*)&stArgs) != UTOPIA_STATUS_SUCCESS)
1705 {
1706 return DRVAESDMA_FAIL;
1707 }
1708 return DRVAESDMA_OK;
1709
1710 #else
1711 AESDMA_Parser_Set_Mode((AESDMA_ParserMode)eMode);
1712 switch (eMode)
1713 {
1714 case E_DRVAESDMA_PARSER_TS_PKT192:
1715 case E_DRVAESDMA_PARSER_TS_PKT192_CLEAR:
1716 case E_DRVAESDMA_PARSER_TS_PKT188:
1717 case E_DRVAESDMA_PARSER_TS_PKT188_CLEAR:
1718 AESDMA_Parser_Insert_Scrmb(TRUE);
1719 AESDMA_Parser_Remove_Scrmb(FALSE);
1720 break;
1721
1722 case E_DRVAESDMA_PARSER_HDCP20_PKT192:
1723 case E_DRVAESDMA_PARSER_HDCP20_PKT192_CLEAR:
1724 case E_DRVAESDMA_PARSER_HDCP20_PKT188:
1725 case E_DRVAESDMA_PARSER_HDCP20_PKT188_CLEAR:
1726 AESDMA_Parser_Insert_Scrmb(FALSE);
1727 AESDMA_Parser_Remove_Scrmb(FALSE);
1728 break;
1729 }
1730
1731 AESDMA_Parser_Enable_HWParser(TRUE);
1732 return DRVAESDMA_OK;
1733 #endif
1734 }
1735
1736 //-------------------------------------------------------------------------------------------------
1737 /// Init Parser Decrypt
1738 /// @param eMode \b IN: input parser mode
1739 /// @return AESDMA_Result
1740 /// @note init parser decrypt
1741 //-------------------------------------------------------------------------------------------------
_MDrv_AESDMA_Parser_Decrypt(DrvAESDMA_ParserMode eMode)1742 DRVAESDMA_RESULT _MDrv_AESDMA_Parser_Decrypt(DrvAESDMA_ParserMode eMode)
1743 {
1744 AESDMA_Parser_Set_Mode((AESDMA_ParserMode)eMode);
1745
1746 switch (eMode)
1747 {
1748 case E_DRVAESDMA_PARSER_TS_PKT192:
1749 case E_DRVAESDMA_PARSER_TS_PKT192_CLEAR:
1750 case E_DRVAESDMA_PARSER_TS_PKT188:
1751 case E_DRVAESDMA_PARSER_TS_PKT188_CLEAR:
1752 AESDMA_Parser_Insert_Scrmb(FALSE);
1753 AESDMA_Parser_Remove_Scrmb(TRUE);
1754 break;
1755
1756 case E_DRVAESDMA_PARSER_HDCP20_PKT192:
1757 case E_DRVAESDMA_PARSER_HDCP20_PKT192_CLEAR:
1758 case E_DRVAESDMA_PARSER_HDCP20_PKT188:
1759 case E_DRVAESDMA_PARSER_HDCP20_PKT188_CLEAR:
1760 AESDMA_Parser_Insert_Scrmb(FALSE);
1761 AESDMA_Parser_Remove_Scrmb(FALSE);
1762 break;
1763 }
1764
1765
1766 AESDMA_Parser_Enable_HWParser(TRUE);
1767 return DRVAESDMA_OK;
1768 }
1769
MDrv_AESDMA_Parser_Decrypt(DrvAESDMA_ParserMode eMode)1770 DRVAESDMA_RESULT MDrv_AESDMA_Parser_Decrypt(DrvAESDMA_ParserMode eMode)
1771 {
1772 #if (AESDMA_UTOPIA20)
1773 AESDMA_PARSER_CONFIGURATIONS stArgs;
1774
1775 if (NULL == pInstantAesdma)
1776 return DRVAESDMA_FAIL;
1777
1778 stArgs.eParserMode = eMode;
1779
1780 if(UtopiaIoctl(pInstantAesdma, MDrv_CMD_AESDMA_PARSER_DECRYPT,(void*)&stArgs) != UTOPIA_STATUS_SUCCESS)
1781 {
1782 return DRVAESDMA_FAIL;
1783 }
1784 return DRVAESDMA_OK;
1785
1786 #else
1787 AESDMA_Parser_Set_Mode((AESDMA_ParserMode)eMode);
1788
1789 switch (eMode)
1790 {
1791 case E_DRVAESDMA_PARSER_TS_PKT192:
1792 case E_DRVAESDMA_PARSER_TS_PKT192_CLEAR:
1793 case E_DRVAESDMA_PARSER_TS_PKT188:
1794 case E_DRVAESDMA_PARSER_TS_PKT188_CLEAR:
1795 AESDMA_Parser_Insert_Scrmb(FALSE);
1796 AESDMA_Parser_Remove_Scrmb(TRUE);
1797 break;
1798
1799 case E_DRVAESDMA_PARSER_HDCP20_PKT192:
1800 case E_DRVAESDMA_PARSER_HDCP20_PKT192_CLEAR:
1801 case E_DRVAESDMA_PARSER_HDCP20_PKT188:
1802 case E_DRVAESDMA_PARSER_HDCP20_PKT188_CLEAR:
1803 AESDMA_Parser_Insert_Scrmb(FALSE);
1804 AESDMA_Parser_Remove_Scrmb(FALSE);
1805 break;
1806 }
1807
1808
1809 AESDMA_Parser_Enable_HWParser(TRUE);
1810 return DRVAESDMA_OK;
1811 #endif
1812 }
1813
_MDrv_RSA_Calculate(DrvAESDMA_RSASig * pstSign,DrvAESDMA_RSAKey * pstKey,DrvAESDMA_RSAMode eMode)1814 DRVAESDMA_RESULT _MDrv_RSA_Calculate(DrvAESDMA_RSASig *pstSign, DrvAESDMA_RSAKey *pstKey, DrvAESDMA_RSAMode eMode)
1815 {
1816 MS_U32 u32KeyLen = 0;
1817 MS_U8 u8Public = 0;
1818 MS_U32 *pu32Sig = (MS_U32 *)((void*)pstSign);
1819 MS_U32 *pu32Key = (MS_U32 *)((void*)pstKey);
1820
1821
1822 RSA_Reset();
1823 RSA_Ind32Ctrl(1);//ind32_ctrl=0xE0
1824
1825 switch (eMode)
1826 {
1827 case E_DRVAESDMA_RSA1024_PUBLIC:
1828 {
1829 u32KeyLen = 128;
1830 u8Public = 1;
1831 }
1832 break;
1833 case E_DRVAESDMA_RSA1024_PRIVATE:
1834 {
1835 u32KeyLen = 128;
1836 u8Public = 0;
1837 }
1838 break;
1839 case E_DRVAESDMA_RSA2048_PUBLIC:
1840 {
1841 u32KeyLen = 256;
1842 u8Public = 1;
1843 }
1844 break;
1845 case E_DRVAESDMA_RSA2048_PRIVATE:
1846 {
1847 u32KeyLen = 256;
1848 u8Public = 0;
1849 }
1850 break;
1851 case E_DRVAESDMA_RSA256_PUBLIC:
1852 {
1853 u32KeyLen = 32;
1854 u8Public = 1;
1855 }
1856 break;
1857 case E_DRVAESDMA_RSA256_PRIVATE:
1858 {
1859 u32KeyLen = 32;
1860 u8Public = 0;
1861 }
1862 break;
1863 default:
1864 return DRVAESDMA_INVALID_PARAM;
1865 }
1866
1867 RSA_LoadSram((pu32Sig+(RSA_INPUT_SIZE/RSA_UNIT_SIZE)-1),E_RSA_ADDRESS_A);
1868 RSA_LoadSram((pu32Key+(RSA_INPUT_SIZE/RSA_UNIT_SIZE)-1),E_RSA_ADDRESS_N);
1869 RSA_LoadSram((pu32Key+(RSA_INPUT_SIZE/RSA_UNIT_SIZE)),E_RSA_ADDRESS_E);
1870
1871 RSA_SetKeyLength((u32KeyLen/RSA_UNIT_SIZE)-1);
1872 RSA_SetKeyType(0,u8Public); //sw key, public key
1873
1874 RSA_ExponetialStart();
1875
1876 return DRVAESDMA_OK;
1877 }
1878
MDrv_RSA_Calculate_Hw_Key(DrvAESDMA_RSASig * pstSign,DrvAESDMA_RSAHwKeyMode eMode)1879 DRVAESDMA_RESULT MDrv_RSA_Calculate_Hw_Key(DrvAESDMA_RSASig *pstSign, DrvAESDMA_RSAHwKeyMode eMode)
1880 {
1881 return DRVAESDMA_FAIL;
1882 }
1883
MDrv_RSA_Calculate(DrvAESDMA_RSASig * pstSign,DrvAESDMA_RSAKey * pstKey,DrvAESDMA_RSAMode eMode)1884 DRVAESDMA_RESULT MDrv_RSA_Calculate(DrvAESDMA_RSASig *pstSign, DrvAESDMA_RSAKey *pstKey, DrvAESDMA_RSAMode eMode)
1885 {
1886 #if (AESDMA_UTOPIA20)
1887 RSA_CALCULATE stRsaCalParam;
1888
1889 if (NULL == pInstantAesdma)
1890 return DRVAESDMA_FAIL;
1891
1892 stRsaCalParam.pstSign = pstSign;
1893 stRsaCalParam.pstKey = pstKey;
1894 stRsaCalParam.eMode= eMode;
1895
1896 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_RSA_Calculate,(void*)&stRsaCalParam) != UTOPIA_STATUS_SUCCESS)
1897 {
1898 return DRVAESDMA_FAIL;
1899 }
1900 return DRVAESDMA_OK;
1901 #else
1902 return _MDrv_RSA_Calculate(pstSign,pstKey,eMode);
1903 #endif
1904 }
1905
_MDrv_RSA_IsFinished(void)1906 DRVAESDMA_RESULT _MDrv_RSA_IsFinished(void)
1907 {
1908 if(!RSA_Get_RSA_IsFinished())
1909 {
1910 return DRVAESDMA_OK;
1911 }
1912 else
1913 {
1914 return DRVAESDMA_FAIL;
1915 }
1916 }
1917
MDrv_RSA_IsFinished(void)1918 DRVAESDMA_RESULT MDrv_RSA_IsFinished(void)
1919 {
1920 #if (AESDMA_UTOPIA20)
1921 MS_U32 u32Timeout = 0x100000;
1922
1923 if (NULL == pInstantAesdma)
1924 return DRVAESDMA_FAIL;
1925
1926 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_RSA_IsFinished,(void*)&u32Timeout) != UTOPIA_STATUS_SUCCESS)
1927 {
1928 return DRVAESDMA_FAIL;
1929 }
1930 return DRVAESDMA_OK;
1931 #else
1932 return _MDrv_RSA_IsFinished();
1933 #endif
1934 }
_MDrv_RSA_Output(DrvAESDMA_RSAMode eMode,DrvAESDMA_RSAOut * pstRSAOut)1935 DRVAESDMA_RESULT _MDrv_RSA_Output(DrvAESDMA_RSAMode eMode, DrvAESDMA_RSAOut *pstRSAOut)
1936 {
1937 MS_U32 i = 0;
1938 MS_U32 u32KeyLen = 0;
1939
1940 MS_U32 *pu32RSAOut = (MS_U32 *)((void*)pstRSAOut);
1941
1942 RSA_Ind32Ctrl(0);//ind32_ctrl=0xC0
1943
1944 switch (eMode)
1945 {
1946 case E_DRVAESDMA_RSA1024_PUBLIC:
1947 case E_DRVAESDMA_RSA1024_PRIVATE:
1948 u32KeyLen = 128;
1949 break;
1950 case E_DRVAESDMA_RSA2048_PUBLIC:
1951 case E_DRVAESDMA_RSA2048_PRIVATE:
1952 u32KeyLen = 256;
1953 break;
1954 case E_DRVAESDMA_RSA256_PUBLIC:
1955 case E_DRVAESDMA_RSA256_PRIVATE:
1956 u32KeyLen = 32;
1957 break;
1958 default:
1959 return DRVAESDMA_INVALID_PARAM;
1960 }
1961
1962 for( i = 0; i<(u32KeyLen/RSA_UNIT_SIZE); i++)
1963 {
1964 RSA_SetFileOutAddr(i);
1965 RSA_FileOutStart();
1966 *(pu32RSAOut+i) = RSA_FileOut();
1967 }
1968
1969 //clear the used key whenever calculating is finished
1970 RSA_Reset();
1971
1972 return DRVAESDMA_OK;
1973 }
1974
MDrv_RSA_Output(DrvAESDMA_RSAMode eMode,DrvAESDMA_RSAOut * pstRSAOut)1975 DRVAESDMA_RESULT MDrv_RSA_Output(DrvAESDMA_RSAMode eMode, DrvAESDMA_RSAOut *pstRSAOut)
1976 {
1977 #if (AESDMA_UTOPIA20)
1978 RSA_OUTPUT RsaOutParam;
1979 RsaOutParam.eMode= eMode;
1980 RsaOutParam.pstRSAOut= pstRSAOut;
1981
1982 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_RSA_Output,(void*)&RsaOutParam) != UTOPIA_STATUS_SUCCESS)
1983 {
1984 return DRVAESDMA_FAIL;
1985 }
1986 return DRVAESDMA_OK;
1987 #else
1988 return _MDrv_RSA_Output(eMode,pstRSAOut);
1989 #endif
1990 }
1991
MDrv_AESDMA_SetPowerState(EN_POWER_MODE u16PowerState)1992 MS_U32 MDrv_AESDMA_SetPowerState(EN_POWER_MODE u16PowerState)
1993 {
1994 static EN_POWER_MODE u16PreAESDMAPowerState = E_POWER_MECHANICAL;
1995 MS_U32 u32Return = UTOPIA_STATUS_FAIL;
1996
1997 if (u16PowerState == E_POWER_SUSPEND)
1998 {
1999 u16PreAESDMAPowerState = u16PowerState;
2000 _u8IsInit = FALSE;
2001 u32Return = UTOPIA_STATUS_SUCCESS;//SUSPEND_OK;
2002
2003 AESDMA_POWER_SUSPEND();
2004
2005 #if !defined(MSOS_TYPE_NOS)
2006 MsOS_DeleteEventGroup(_s32AESDMAEventId);
2007 _AESDMA_SetEvent(AESDMA_DMA_PAUSE);
2008 #endif //#if !defined(MSOS_TYPE_NOS)
2009 _bExitIsrLoop = TRUE;
2010 }
2011 else if (u16PowerState == E_POWER_RESUME)
2012 {
2013 if (u16PreAESDMAPowerState == E_POWER_SUSPEND)
2014 {
2015 MDrv_AESDMA_Init(0, 0x20000000, 2);
2016
2017 AESDMA_POWER_RESUME();
2018
2019 u16PreAESDMAPowerState = u16PowerState;
2020 u32Return = UTOPIA_STATUS_SUCCESS;//RESUME_OK;
2021 }
2022 else
2023 {
2024 ULOGE(TAG_AESDMA, "[%s,%5d]It is not suspended yet. We shouldn't resume\n",__FUNCTION__,__LINE__);
2025 u32Return = UTOPIA_STATUS_FAIL;//SUSPEND_FAILED;
2026 }
2027 }
2028 else
2029 {
2030 ULOGE(TAG_AESDMA, "[%s,%5d]Do Nothing: %d\n",__FUNCTION__,__LINE__,u16PowerState);
2031 u32Return = UTOPIA_STATUS_FAIL;
2032 }
2033
2034 return u32Return;// for success
2035 }
2036
2037 //reserved for secure protect function
2038 /*
2039 DRVAESDMA_RESULT MDrv_AESDMA_SecureSetKey(MS_U32 *pCipherKey)
2040 {
2041 if (pCipherKey != NULL)
2042 {
2043 AESDMA_Secure_SetCipherKey(pCipherKey);
2044 return DRVAESDMA_OK;
2045 }
2046 else
2047 {
2048 return DRVAESDMA_INVALID_PARAM;
2049 }
2050 }
2051
2052 DRVAESDMA_RESULT MDrv_AESDMA_SecureProtect(MS_BOOL bEnable)
2053 {
2054 AESDMA_SecureProtect(bEnable);
2055 return DRVAESDMA_OK;
2056 }
2057
2058 DRVAESDMA_RESULT MDrv_AESDMA_SecureSetIV(MS_U32 *pInitVector)
2059 {
2060 if (pInitVector != NULL)
2061 {
2062 AESDMA_Secure_SetInitVector(pInitVector);
2063 return DRVAESDMA_OK;
2064 }
2065 else
2066 {
2067 return DRVAESDMA_INVALID_PARAM;
2068 }
2069 }
2070
2071 DRVAESDMA_RESULT MDrv_AESDMA_SetFileOutEnable(MS_BOOL bEnable)
2072 {
2073 AESDMA_Set_FileOutEnable(bEnable);
2074 return DRVAESDMA_OK;
2075 }
2076
2077 DRVAESDMA_RESULT MDrv_AESDMA_SecureStart(MS_BOOL bStart)
2078 {
2079 MsOS_FlushMemory();
2080 AESDMA_Secure_Start(bStart);
2081 return DRVAESDMA_OK;
2082 }
2083
2084 DRVAESDMA_RESULT MDrv_AESDMA_SecureIsFinished(void)
2085 {
2086 if(AESDMA_Get_AESDMA_SecureIsFinished())
2087 {
2088 MsOS_ReadMemory();
2089 return DRVAESDMA_OK;
2090 }
2091 else
2092 {
2093 return DRVAESDMA_FAIL;
2094 }
2095 }
2096 */
2097
_MDrv_AESDMA_IsSecretKeyInNormalBank(MS_U8 * retVal)2098 DRVAESDMA_RESULT _MDrv_AESDMA_IsSecretKeyInNormalBank(MS_U8 *retVal)
2099 {
2100 *retVal = AESDMA_IsSecretKeyInNormalBank ();
2101 if (*retVal == 0)
2102 {
2103 return DRVAESDMA_FAIL;
2104 }
2105 else
2106 {
2107 return DRVAESDMA_OK;
2108 }
2109 }
2110
MDrv_AESDMA_IsSecretKeyInNormalBank(void)2111 DRVAESDMA_RESULT MDrv_AESDMA_IsSecretKeyInNormalBank(void)
2112 {
2113
2114 #if (AESDMA_UTOPIA20)
2115
2116 MS_U8 retVal = 0;
2117 if (NULL == pInstantAesdma)
2118 return DRVAESDMA_FAIL;
2119
2120 if(UtopiaIoctl(pInstantAesdma, MDrv_CMD_IS_SECRETKEY_IN_NORMAL_BLANK,(void*)&retVal) != UTOPIA_STATUS_SUCCESS)
2121 {
2122 return DRVAESDMA_FAIL;
2123 }
2124
2125 if (retVal == 0)
2126 return DRVAESDMA_FAIL;
2127 else
2128 return DRVAESDMA_OK;
2129
2130
2131 #else
2132 if (AESDMA_IsSecretKeyInNormalBank() == 0)
2133 {
2134 return DRVAESDMA_FAIL;
2135 }
2136 else
2137 {
2138 return DRVAESDMA_OK;
2139 }
2140 #endif
2141 }
2142
MDrv_HDCP_ProcessCipher(MS_U8 u8Idx,MS_U8 * pu8Riv,MS_U8 * pu8ContentKey)2143 DRVAESDMA_RESULT MDrv_HDCP_ProcessCipher(MS_U8 u8Idx, MS_U8* pu8Riv, MS_U8 *pu8ContentKey)
2144 {
2145 HDCP_ProcessCipher(u8Idx, pu8ContentKey, pu8Riv);
2146
2147 return DRVAESDMA_OK;
2148 }
2149
2150 ////////////////////////////////////////////////////////////////////////////////
2151 /// @brief \b Function \b Name: MDrv_HDCP_GetHdcpCipherState
2152 /// @brief \b Function \b Description: Check the capability of HDCP 2.2
2153 /// @param None \b IN : u8Idx
2154 /// @param None \b OUT : pu8State
2155 /// @param DRVAESDMA_RESULT \b RET : DRVAESDMA_OK
2156 /// @param None \b GLOBAL :
2157 ////////////////////////////////////////////////////////////////////////////////
MDrv_HDCP_GetHdcpCipherState(MS_U8 u8Idx,MS_U8 * pu8State)2158 DRVAESDMA_RESULT MDrv_HDCP_GetHdcpCipherState(MS_U8 u8Idx, MS_U8 *pu8State)
2159 {
2160 HDCP_GetHdcpCipherState(u8Idx, pu8State);
2161
2162 return DRVAESDMA_OK;
2163 }
2164
MDrv_AESDMA_SetKeyIndex(MS_U32 u32Index,MS_BOOL bIsOddKey)2165 DRVAESDMA_RESULT MDrv_AESDMA_SetKeyIndex (MS_U32 u32Index, MS_BOOL bIsOddKey)
2166 {
2167 #if (AESDMA_UTOPIA20)
2168 AESDMA_KEY_INDEX KeyIndex;
2169 KeyIndex.bOddKeyEn = bIsOddKey;
2170 KeyIndex.u32KeyIndex = u32Index;
2171 if(UtopiaIoctl(pInstantAesdma, MDrv_CMD_AESDMA_Set_Key_Index, (void*)&KeyIndex) != UTOPIA_STATUS_SUCCESS)
2172 {
2173 return DRVAESDMA_FAIL;
2174 }
2175 return DRVAESDMA_OK;
2176 #else
2177 AESDMA_SetKeyIndex (u32Index, bIsOddKey);
2178 return DRVAESDMA_OK;
2179 #endif
2180 }
2181
_MDrv_AESDMA_SetKeyIndex(MS_U32 u32Index,MS_BOOL bIsOddKey)2182 DRVAESDMA_RESULT _MDrv_AESDMA_SetKeyIndex (MS_U32 u32Index, MS_BOOL bIsOddKey)
2183 {
2184 AESDMA_SetKeyIndex (u32Index, bIsOddKey);
2185 return DRVAESDMA_OK;
2186 }
2187
_MDrv_AESDMA_EnableTwoKeys(MS_BOOL bEnable)2188 DRVAESDMA_RESULT _MDrv_AESDMA_EnableTwoKeys(MS_BOOL bEnable)
2189 {
2190 AESDMA_Parser_Enable_Two_Keys(bEnable);
2191 return DRVAESDMA_OK;
2192 }
2193
MDrv_AESDMA_EnableTwoKeys(MS_BOOL bEnable)2194 DRVAESDMA_RESULT MDrv_AESDMA_EnableTwoKeys(MS_BOOL bEnable)
2195 {
2196 #if (AESDMA_UTOPIA20)
2197 if(UtopiaIoctl(pInstantAesdma, MDrv_CMD_AESDMA_ENABLE_Two_Key, (void*)&bEnable) != UTOPIA_STATUS_SUCCESS)
2198 {
2199 return DRVAESDMA_FAIL;
2200 }
2201 return DRVAESDMA_OK;
2202 #else
2203 AESDMA_Parser_Enable_Two_Keys(bEnable);
2204 return DRVAESDMA_OK;
2205 #endif
2206 }
2207
_MDrv_AESDMA_SetOddKey(MS_U32 * pInitVector)2208 DRVAESDMA_RESULT _MDrv_AESDMA_SetOddKey(MS_U32 *pInitVector)
2209 {
2210 if (pInitVector != NULL)
2211 {
2212 AESDMA_Set_CipherOddKey(pInitVector);
2213 return DRVAESDMA_OK;
2214 }
2215 else
2216 {
2217 return DRVAESDMA_INVALID_PARAM;
2218 }
2219 }
2220
MDrv_AESDMA_SetOddKey(MS_U32 * pInitVector)2221 DRVAESDMA_RESULT MDrv_AESDMA_SetOddKey(MS_U32 *pInitVector)
2222 {
2223 #if (AESDMA_UTOPIA20)
2224 if(UtopiaIoctl(pInstantAesdma, MDrv_CMD_AESDMA_SetOddKey,(void*)pInitVector) != UTOPIA_STATUS_SUCCESS)
2225 {
2226 return DRVAESDMA_FAIL;
2227 }
2228 return DRVAESDMA_OK;
2229 #else
2230 if (pInitVector != NULL)
2231 {
2232 AESDMA_Set_CipherOddKey(pInitVector);
2233 return DRVAESDMA_OK;
2234 }
2235 else
2236 {
2237 return DRVAESDMA_INVALID_PARAM;
2238 }
2239 #endif
2240 }
2241
MDrv_AESDMA_ParserStart(MS_BOOL bStart)2242 DRVAESDMA_RESULT MDrv_AESDMA_ParserStart(MS_BOOL bStart)
2243 {
2244 #if (AESDMA_UTOPIA20)
2245 if (NULL == pInstantAesdma)
2246 return DRVAESDMA_FAIL;
2247
2248 if(UtopiaIoctl(pInstantAesdma,MDrv_CMD_AESDMA_PARSER_Start,(void*)&bStart) != UTOPIA_STATUS_SUCCESS)
2249 {
2250 return DRVAESDMA_FAIL;
2251 }
2252 return DRVAESDMA_OK;
2253 #else
2254 return _MDrv_AESDMA_ParserStart(bStart);
2255 #endif
2256 }
2257
MDrv_HDMI_GetM0(MS_U32 u32InputPortType,MS_U8 * pu8Data)2258 DRVAESDMA_RESULT MDrv_HDMI_GetM0(MS_U32 u32InputPortType, MS_U8 *pu8Data)
2259 {
2260 if (pu8Data == NULL)
2261 {
2262 return DRVAESDMA_FAIL;
2263 }
2264 else
2265 {
2266 HAL_AESDMA_HDMI_GetM0(u32InputPortType, pu8Data);
2267 return DRVAESDMA_OK;
2268 }
2269 }
2270
MDrv_Set_Kslot(MS_U32 u32InputPortType,MS_U8 * pu8Data)2271 DRVAESDMA_RESULT MDrv_Set_Kslot(MS_U32 u32InputPortType, MS_U8 *pu8Data)
2272 {
2273 if (pu8Data == NULL)
2274 {
2275 return DRVAESDMA_FAIL;
2276 }
2277 else
2278 {
2279 HAL_AESDMA_HDMI_GetM0(u32InputPortType, pu8Data);
2280 return DRVAESDMA_OK;
2281 }
2282 }
2283
_MDrv_AESDMA_SetAesCtr64(MS_BOOL bCtr64En)2284 DRVAESDMA_RESULT _MDrv_AESDMA_SetAesCtr64 (MS_BOOL bCtr64En)
2285 {
2286 AESDMA_SET_CTR64(bCtr64En);
2287 return DRVAESDMA_OK;
2288 }
2289
MDrv_AESDMA_SetAesCtr64(MS_BOOL bCtr64En)2290 DRVAESDMA_RESULT MDrv_AESDMA_SetAesCtr64 (MS_BOOL bCtr64En)
2291 {
2292 #if (AESDMA_UTOPIA20)
2293 if (NULL == pInstantAesdma)
2294 return DRVAESDMA_FAIL;
2295
2296 if(UtopiaIoctl(pInstantAesdma, MDrv_CMD_AESDMA_Set_AES_CTR64_En, (void*)&bCtr64En) != UTOPIA_STATUS_SUCCESS)
2297 {
2298 return DRVAESDMA_FAIL;
2299 }
2300 return DRVAESDMA_OK;
2301 #else
2302 AESDMA_SET_CTR64(bCtr64En);
2303 return DRVAESDMA_OK;
2304 #endif
2305 }
2306
_MDrv_AESDMA_SetSecuredKeyIndex(MS_U8 u8KeyIdx)2307 DRVAESDMA_RESULT _MDrv_AESDMA_SetSecuredKeyIndex (MS_U8 u8KeyIdx)
2308 {
2309 AESDMA_SetSecureKeyIdx (u8KeyIdx);
2310 return DRVAESDMA_OK;
2311 }
2312
MDrv_AESDMA_SetSecuredKeyIndex(MS_U8 u8KeyIdx)2313 DRVAESDMA_RESULT MDrv_AESDMA_SetSecuredKeyIndex (MS_U8 u8KeyIdx)
2314 {
2315 #if (AESDMA_UTOPIA20)
2316 if (NULL == pInstantAesdma)
2317 return DRVAESDMA_FAIL;
2318
2319 if(UtopiaIoctl(pInstantAesdma, MDrv_CMD_AESDMA_Set_Efuse_Key_Index, (void*)&u8KeyIdx) != UTOPIA_STATUS_SUCCESS)
2320 {
2321 return DRVAESDMA_FAIL;
2322 }
2323 return DRVAESDMA_OK;
2324 #else
2325 AESDMA_SetSecureKeyIdx (u8KeyIdx);
2326 return DRVAESDMA_OK;
2327 #endif
2328 }
2329
MDrv_AESDMA_GetConfig(PAESDMA_INIT sAesdmaInit)2330 MS_BOOL MDrv_AESDMA_GetConfig(PAESDMA_INIT sAesdmaInit)
2331 {
2332 MS_U32 u32Ret = UTOPIA_STATUS_SUCCESS;
2333 #if (AESDMA_UTOPIA20)
2334 if(NULL == pInstantAesdma)
2335 {
2336 if(UTOPIA_STATUS_FAIL == UtopiaOpen(MODULE_AESDMA, &pInstantAesdma, 0, NULL))
2337 {
2338 ULOGE("AESDMA", "%s, open MODULE_AESDMA failed\n", __FUNCTION__);
2339 return FALSE;
2340 }
2341 }
2342 u32Ret = UtopiaIoctl(pInstantAesdma, MDrv_CMD_AESDMA_GetConfig, (PAESDMA_INIT)sAesdmaInit);
2343 if(UTOPIA_STATUS_SUCCESS != u32Ret)
2344 {
2345 ULOGE("AESDMA", "[%s]ERROR : UtopiaIoctl return value 0x%x\n", __FUNCTION__, (unsigned int)u32Ret);
2346 return FALSE;
2347 }
2348 else
2349 {
2350 return TRUE;
2351 }
2352 #else
2353 return TRUE;
2354 #endif
2355 }
2356