1 #ifdef MSOS_TYPE_LINUX_KERNEL
2 #include <linux/string.h>
3 #include <linux/uaccess.h>
4 #include <linux/compat.h>
5 #else
6 #include <stdio.h>
7 #include <string.h>
8 #endif
9
10 #include "MsTypes.h"
11 #include "utopia_dapi.h"
12 #include "utopia.h"
13 //#include "drvAESDMA.h"
14 #include "drvCIPHER.h"
15 #include "drvAESDMA_private.h"
16 #include "MsOS.h"
17
18 #define AESDMA_KEY_SLOT_BASE (0x10)
19
20 enum
21 {
22 AESDMA_POOL_ID_AES = 0,
23 AESDMA_POOL_ID_SHA,
24 AESDMA_POOL_ID_RSA,
25 AESDMA_POOL_ID_DRVAES,
26 } eAesdmaPoolID;
27
28 void* pModuleAESDMA = NULL;
29
_AESDMA_MSB2LSB(MS_U8 u8Bytes[4])30 MS_U32 _AESDMA_MSB2LSB(MS_U8 u8Bytes[4])
31 {
32 return (u8Bytes[0] << 24) | (u8Bytes[1] << 16) | (u8Bytes[2] << 8) | u8Bytes[3];
33 }
34
AESDMARegisterToUtopia(FUtopiaOpen ModuleType)35 void AESDMARegisterToUtopia(FUtopiaOpen ModuleType)
36 {
37 void* psResource = NULL;
38
39 // 1. deal with module
40 //void* pUtopiaModule = NULL;
41 UtopiaModuleCreate(MODULE_AESDMA, 8, &pModuleAESDMA);
42 UtopiaModuleRegister(pModuleAESDMA);
43 UtopiaModuleSetupFunctionPtr(pModuleAESDMA, (FUtopiaOpen)AESDMAOpen, (FUtopiaClose)AESDMAClose, (FUtopiaIOctl)AESDMAIoctl);
44
45 // 2. deal with resource
46 //Resource AES
47 UtopiaModuleAddResourceStart(pModuleAESDMA, AESDMA_POOL_ID_AES);
48 UtopiaResourceCreate("AES", sizeof(AESDMA_RESOURCE_PRIVATE), &psResource);
49 UtopiaResourceRegister(pModuleAESDMA, psResource, AESDMA_POOL_ID_AES);
50 UtopiaModuleAddResourceEnd(pModuleAESDMA, AESDMA_POOL_ID_AES);
51
52 //Resource SHA
53 UtopiaModuleAddResourceStart(pModuleAESDMA, AESDMA_POOL_ID_SHA);
54 psResource = NULL;
55 UtopiaResourceCreate("SHA", sizeof(SHA_RESOURCE_PRIVATE), &psResource);
56 UtopiaResourceRegister(pModuleAESDMA, psResource, AESDMA_POOL_ID_SHA);
57 UtopiaModuleAddResourceEnd(pModuleAESDMA, AESDMA_POOL_ID_SHA);
58
59 //Resource RSA
60 UtopiaModuleAddResourceStart(pModuleAESDMA, AESDMA_POOL_ID_RSA);
61 psResource = NULL;
62 UtopiaResourceCreate("RSA", sizeof(RSA_RESOURCE_PRIVATE), &psResource);
63 UtopiaResourceRegister(pModuleAESDMA, psResource, AESDMA_POOL_ID_RSA);
64 UtopiaModuleAddResourceEnd(pModuleAESDMA, AESDMA_POOL_ID_RSA);
65
66 //Resource DRVAES
67 UtopiaModuleAddResourceStart(pModuleAESDMA, AESDMA_POOL_ID_DRVAES);
68 psResource = NULL;
69 UtopiaResourceCreate("DRVAES", sizeof(DRVAESDMA_RESOURCE_PRIVATE), &psResource);
70 UtopiaResourceRegister(pModuleAESDMA, psResource, AESDMA_POOL_ID_DRVAES);
71 UtopiaModuleAddResourceEnd(pModuleAESDMA, AESDMA_POOL_ID_DRVAES);
72
73 }
74
AESDMAOpen(void ** ppInstance,MS_U32 u32ModuleVersion,void * pAttribute)75 MS_U32 AESDMAOpen(void** ppInstance, MS_U32 u32ModuleVersion, void* pAttribute)
76 {
77 MS_DEBUG_MSG(printf("\n[AESDMA INFO]AESDMA open \n"));
78
79 AESDMA_INSTANT_PRIVATE *pAesdmaPri = NULL;
80 void *pAesdmaPriVoid = NULL;
81 UtopiaInstanceCreate(sizeof(AESDMA_INSTANT_PRIVATE), ppInstance);
82 UtopiaInstanceGetPrivate(*ppInstance, &pAesdmaPriVoid);
83
84 pAesdmaPri = (AESDMA_INSTANT_PRIVATE *)pAesdmaPriVoid;
85
86 pAesdmaPri->fpAESDMAInit = _MDrv_AESDMA_Init;
87 pAesdmaPri->fpAESDMASetIV = _MDrv_AESDMA_SetIV;
88 pAesdmaPri->fpAESDMAReset = _MDrv_AESDMA_Reset;
89 pAesdmaPri->fpAESDMASetFileInOut = _MDrv_AESDMA_SetFileInOut;
90 pAesdmaPri->fpAESDMASetKey = _MDrv_AESDMA_SetKey;
91 pAesdmaPri->fpAESDMASelEng = _MDrv_AESDMA_SelEng;
92 pAesdmaPri->fpAESDMAStart = _MDrv_AESDMA_Start;
93 pAesdmaPri->fpAESDMAGetStatus = _MDrv_AESDMA_GetStatus;
94 pAesdmaPri->fpAESDMAIsFinished = _MDrv_AESDMA_IsFinished;
95 pAesdmaPri->fpAESDMASetSecureKey = _MDrv_AESDMA_SetSecureKey;
96 pAesdmaPri->fpAESDMASetPS = _MDrv_AESDMA_SetPS;
97 pAesdmaPri->fpAESDMAPSRelease = _MDrv_AESDMA_PSRelease;
98 pAesdmaPri->fpAESDMAGetPSMatchedByteCNT = _MDrv_AESDMA_GetPSMatchedByteCNT;
99 pAesdmaPri->fpAESDMAGetPSMatchedPTN = _MDrv_AESDMA_GetPSMatchedPTN;
100 pAesdmaPri->fpAESDMANotify = _MDrv_AESDMA_Notify;
101 pAesdmaPri->fpAESDMARand = _MDrv_AESDMA_Rand;
102 pAesdmaPri->fpRSACalculate = _MDrv_RSA_Calculate;
103 pAesdmaPri->fpRSAIsFinished = _MDrv_RSA_IsFinished;
104 pAesdmaPri->fpRSAOutput = _MDrv_RSA_Output;
105 pAesdmaPri->fpSHACalculate = _MDrv_SHA_Calculate;
106 pAesdmaPri->fpSHACalculateManual = _MDrv_SHA_CalculateManual;
107 pAesdmaPri->fpAESDMASetKey_Ex = _MDrv_AESDMA_SetKey_Ex;
108 pAesdmaPri->fpAESDMASetIV_Ex = _MDrv_AESDMA_SetIV_Ex;
109 pAesdmaPri->fpAESDMASetDefaultCAVid = _MDrv_AESDMA_SetDefaultCAVid;
110 pAesdmaPri->fpAESDMASetKeyIndex = _MDrv_AESDMA_SetKeyIndex;
111 pAesdmaPri->fpAESDMAAllocKeySlot = _MDrv_AESDMA_AllocKeySlot;
112 pAesdmaPri->fpAESDMAFreeKeySlot = _MDrv_AESDMA_FreeKeySlot;
113 pAesdmaPri->fpAESDMAInitBySWFlag = _MDrv_AESDMA_InitBySWFlag;
114
115 return UTOPIA_STATUS_SUCCESS;
116 }
117
AESDMAIoctl(void * pInstance,MS_U32 u32Cmd,void * pArgs)118 MS_U32 AESDMAIoctl(void* pInstance, MS_U32 u32Cmd, void* pArgs)
119 {
120 PAESDMA_INIT pInitParam = NULL;
121 PAESDMA_FILE_INOUT pFileInOutParam = NULL;
122 PAESDMA_SEL_ENG pSelEngParam = NULL;
123 PAESDMA_SET_KEY_EX pSetKeyEx = NULL;
124 PAESDMA_SET_IV_EX pSetIVEx = NULL;
125 PAESDMA_SET_PS pSetPSParam = NULL;
126 PAESDMA_NOTIFY pNotifyParam = NULL;
127 PAESDMA_RAND pRandParam = NULL;
128 PAESDMA_CAVID pCAVid = NULL;
129 PRSA_CALCULATE pRSACalParam = NULL;
130 PRSA_OUTPUT pRSAOutParam = NULL;
131 PSHA_CALCULATE pSHACalParam = NULL;
132 PSHA_CALCULATE_MANUAL pSHACalManuParam = NULL;
133 PAESDMA_KEY_INDEX pKeyIndex = NULL;
134 PAESDMA_ALLOC_KEY_SLOT pAllocKeySlot = NULL;
135 MS_U32 u32Ret = 0;
136 AESDMA_INSTANT_PRIVATE* psAesInstPri = NULL;
137 AESDMA_RESOURCE_SHARED* psAesResourceShared = NULL;
138 RSA_RESOURCE_SHARED* psRSAResourceShared = NULL;
139 UtopiaInstanceGetPrivate(pInstance, (void*)&psAesInstPri);
140 void* pTmpResource = NULL;
141 void* pDRVAESResource = NULL;
142 MS_U32 u32ShmId = 0;
143 MS_VIRT u32Addr = 0;
144 MS_U32 u32BufSize = 0;
145 MS_U32 u32IVarrayAddr[4] = {0};
146 MS_U32 u32KeyarryAddr[4] = {0};
147 MS_U32 u32timeout_count = 0;
148 MS_U32 u32timeout_value = 0;
149 DRVAESDMA_RESOURCE_PRIVATE* pstResPri = NULL;
150
151 if(UtopiaResourceObtain(pModuleAESDMA, AESDMA_POOL_ID_DRVAES, &pDRVAESResource) != UTOPIA_STATUS_SUCCESS)
152 {
153 printf("UtopiaResourceObtain fail\n");
154 return UTOPIA_STATUS_ERR_RESOURCE;
155 }
156 UtopiaResourceGetPrivate(pDRVAESResource, (void**)&pstResPri);
157
158 if((FALSE == pstResPri->bInited_Drv) &&
159 (u32Cmd != MDrv_CMD_AESDMA_Init) ) // which command don't need do it after init?
160 {
161 UtopiaResourceRelease(pDRVAESResource);
162 return UTOPIA_STATUS_FAIL;
163 }
164
165 switch(u32Cmd)
166 {
167 case MDrv_CMD_AESDMA_Init:
168 {
169 if(pstResPri->bInited_Drv == FALSE)
170 {
171 pInitParam = (PAESDMA_INIT)pArgs;
172 u32Ret = (psAesInstPri->fpAESDMAInit)(pInitParam->u32miu0addr,pInitParam->u32miu1addr,pInitParam->u32miunum);
173 psAesInstPri->u32IVLen = 0;
174 psAesInstPri->u32FileinAddr = 0;
175 psAesInstPri->u32FileInNum = 0;
176 psAesInstPri->u32FileOutSAddr = 0;
177 psAesInstPri->u32FileOutEAddr = 0;
178 psAesInstPri->ptrKey = 0;
179 psAesInstPri->u32KeyLen = 0;
180 psAesInstPri->u32Mode = 0xFF; //Default simple DMA
181 psAesInstPri->u32KeyIndex = 0;
182 psAesInstPri->bOddKey = FALSE;
183 psAesInstPri->u32CAVid = 0;
184
185 memset(psAesInstPri->CipherKey, 0, sizeof(psAesInstPri->CipherKey));
186 memset(psAesInstPri->InitVector, 0, sizeof(psAesInstPri->InitVector));
187 memset(psAesInstPri->u8KeySlotUsage, 0, sizeof(psAesInstPri->u8KeySlotUsage));
188
189 if (u32Ret == DRVAESDMA_OK)
190 {
191 pstResPri->bInited_Drv = TRUE;
192 u32Ret = UTOPIA_STATUS_SUCCESS;
193 }
194 else
195 {
196 u32Ret = UTOPIA_STATUS_FAIL;
197 }
198 }
199 else
200 {
201 u32Ret = (psAesInstPri->fpAESDMAInitBySWFlag)(TRUE);
202 if (u32Ret == DRVAESDMA_OK)
203 {
204 u32Ret = UTOPIA_STATUS_SUCCESS;
205 }
206 else
207 {
208 u32Ret = UTOPIA_STATUS_FAIL;
209 }
210 }
211 }
212 break;
213
214 case MDrv_CMD_AESDMA_SetIV:
215 {
216 if(NULL != pArgs)
217 {
218 u32IVarrayAddr[3] = _AESDMA_MSB2LSB((MS_U8 *)pArgs);
219 u32IVarrayAddr[2] = _AESDMA_MSB2LSB((MS_U8 *)pArgs + 4);
220 u32IVarrayAddr[1] = _AESDMA_MSB2LSB((MS_U8 *)pArgs + 8);
221 u32IVarrayAddr[0] = _AESDMA_MSB2LSB((MS_U8 *)pArgs + 12);
222 }
223 else
224 {
225 printf("[AESDMA INFO]Set IV fail, IV is NULL\n");
226 u32Ret = UTOPIA_STATUS_FAIL;
227 break;
228 }
229
230 memcpy((void *)psAesInstPri->InitVector,(MS_U8 *)u32IVarrayAddr,16);
231 psAesInstPri->u32IVLen = 16;
232 u32Ret = UTOPIA_STATUS_SUCCESS;
233 }
234 break;
235
236 case MDrv_CMD_AESDMA_Reset:
237 {
238 u32Ret = (psAesInstPri->fpAESDMAReset)();
239 //Reset private data
240 psAesInstPri->u32IVLen = 0;
241 psAesInstPri->u32FileinAddr = 0;
242 psAesInstPri->u32FileInNum = 0;
243 psAesInstPri->u32FileOutSAddr = 0;
244 psAesInstPri->u32FileOutEAddr = 0;
245 psAesInstPri->ptrKey = 0;
246 psAesInstPri->u32KeyLen = 0;
247 psAesInstPri->u32Mode = 0xFF;
248 psAesInstPri->u32KeyIndex = 0;
249 psAesInstPri->bOddKey = FALSE;
250 psAesInstPri->u32CAVid = 0;
251
252 memset(psAesInstPri->CipherKey, 0, sizeof(psAesInstPri->CipherKey));
253 memset(psAesInstPri->InitVector, 0, sizeof(psAesInstPri->InitVector));
254 memset(psAesInstPri->u8KeySlotUsage, 0, sizeof(psAesInstPri->u8KeySlotUsage));
255
256 if (u32Ret == DRVAESDMA_OK)
257 {
258 u32Ret = UTOPIA_STATUS_SUCCESS;
259 }
260 else
261 {
262 u32Ret = UTOPIA_STATUS_FAIL;
263 }
264 }
265 break;
266
267 case MDrv_CMD_AESDMA_SetFileInOut:
268 {
269 pFileInOutParam = (PAESDMA_FILE_INOUT)pArgs;
270 psAesInstPri->u32FileinAddr = pFileInOutParam->u32FileinAddr;
271 psAesInstPri->u32FileInNum = pFileInOutParam->u32FileInNum;
272 psAesInstPri->u32FileOutSAddr = pFileInOutParam->u32FileOutSAddr;
273 psAesInstPri->u32FileOutEAddr = pFileInOutParam->u32FileOutEAddr;
274 MS_DEBUG_MSG(printf("[AESDMA INFO]FileinAddr = %lx\n",psAesInstPri->u32FileinAddr));
275 MS_DEBUG_MSG(printf("[AESDMA INFO]FileInNum = %lx\n",psAesInstPri->u32FileInNum));
276 MS_DEBUG_MSG(printf("[AESDMA INFO]FileOutSAddr = %lx\n",psAesInstPri->u32FileOutSAddr));
277 MS_DEBUG_MSG(printf("[AESDMA INFO]FileOutEAddr = %lx\n",psAesInstPri->u32FileOutEAddr));
278 u32Ret = UTOPIA_STATUS_SUCCESS;
279 }
280 break;
281
282 case MDrv_CMD_AESDMA_SetKey:
283 {
284 if(NULL != pArgs)
285 {
286 u32KeyarryAddr[3] = _AESDMA_MSB2LSB((MS_U8 *)pArgs);
287 u32KeyarryAddr[2] = _AESDMA_MSB2LSB((MS_U8 *)pArgs + 4);
288 u32KeyarryAddr[1] = _AESDMA_MSB2LSB((MS_U8 *)pArgs + 8);
289 u32KeyarryAddr[0] = _AESDMA_MSB2LSB((MS_U8 *)pArgs + 12);
290 memcpy((void *)psAesInstPri->CipherKey,(MS_U8 *)u32KeyarryAddr,16);
291 psAesInstPri->ptrKey = (MS_VIRT)psAesInstPri->CipherKey;
292 }
293 else
294 {
295 psAesInstPri->ptrKey = 0;
296 }
297
298 psAesInstPri->u32KeyLen = 16;
299 u32Ret = UTOPIA_STATUS_SUCCESS;
300 }
301 break;
302
303 case MDrv_CMD_AESDMA_SelEng:
304 {
305 pSelEngParam = (PAESDMA_SEL_ENG)pArgs;
306 psAesInstPri->u32Mode = pSelEngParam->eMode;
307 psAesInstPri->bDescrypt = pSelEngParam->bDescrypt;
308 MS_DEBUG_MSG(printf("[AESDMA INFO]mode = %lu\n",(long unsigned int)psAesInstPri->u32Mode));
309 MS_DEBUG_MSG(printf("[AESDMA INFO]Descrypt = %x\n",psAesInstPri->bDescrypt));
310 u32Ret = UTOPIA_STATUS_SUCCESS;
311 }
312 break;
313
314 case MDrv_CMD_AESDMA_Start:
315 {
316 if(UtopiaResourceObtain(pModuleAESDMA, AESDMA_POOL_ID_AES, &pTmpResource) != 0)
317 {
318 printf("UtopiaResourceObtainToInstant fail\n");
319 u32Ret = UTOPIA_STATUS_ERR_NOT_AVAIL;
320 break;
321 }
322
323 if(FALSE == MsOS_SHM_GetId((MS_U8*)"AESDMA driver", sizeof(AESDMA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_QUERY))
324 {
325 if(FALSE == MsOS_SHM_GetId((MS_U8*)"AESDMA driver", sizeof(AESDMA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_CREATE))
326 {
327 printf("[AESDMA INFO]create Resouce shared memory fail\n");
328 u32Ret = UTOPIA_STATUS_ERR_NOMEM;
329 break;
330 }
331 memset((MS_U8 *)u32Addr, 0, sizeof(AESDMA_RESOURCE_SHARED));
332 }
333
334 psAesResourceShared = (AESDMA_RESOURCE_SHARED*)u32Addr;
335
336 psAesResourceShared->pAESResource = pTmpResource;
337 MS_DEBUG_MSG(printf("\n[AESDMA INFO]pResource = %x\n",(int)psAesResourceShared->pAESResource));
338
339 //AESDMA reset
340 // (psAesInstPri->fpAESDMAReset)();
341
342 //AESDMA set mode and select encrypt or decrypt
343 (psAesInstPri->fpAESDMASelEng)(psAesInstPri->u32Mode,psAesInstPri->bDescrypt);
344
345 //AESDMA set IV
346 if((psAesInstPri->u32Mode == E_DRVAESDMA_CIPHER_CBC)||
347 (psAesInstPri->u32Mode == E_DRVAESDMA_CIPHER_CTR)||
348 (psAesInstPri->u32Mode == E_DRVAESDMA_CIPHER_CTS_CBC))
349 {
350 //u32IVarrayAddr = (MS_U32)&psAesInstPri->InitVector[0];
351 //(psAesInstPri->fpAESDMASetIV)((MS_U32*)u32IVarrayAddr);
352 (psAesInstPri->fpAESDMASetIV_Ex)(&psAesInstPri->InitVector[0], psAesInstPri->u32IVLen);
353 }
354
355 //CBC segmental decryption case
356 //if(((psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CBC)||(psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CTR)||(psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CTS_CBC))
357 // && psAesInstPri->bDescrypt == TRUE)
358 if((((psAesInstPri->u32Mode == E_DRVAESDMA_CIPHER_CBC)||(psAesInstPri->u32Mode == E_DRVAESDMA_CIPHER_CTS_CBC))&& psAesInstPri->bDescrypt == TRUE)||
359 (psAesInstPri->u32Mode == E_DRVAESDMA_CIPHER_CTR))
360 {
361 //printf("[AESDMA]FileInAddr PA = %x\n",psAesInstPri->u32FileinAddr);
362 //printf("[AESDMA]Descrypt = %x\n",psAesInstPri->bDescrypt);
363 MS_U32 i;
364 MS_VIRT FileinVirtAddr;
365
366 FileinVirtAddr = MsOS_PA2KSEG1(psAesInstPri->u32FileinAddr);
367
368 if(psAesInstPri->u32Mode != E_DRVAESDMA_CIPHER_CTR)
369 {
370 for(i = 0; i < 16; i++)
371 {
372 psAesInstPri->InitVector[16-i-1] = *(MS_U8 *)(FileinVirtAddr + psAesInstPri->u32FileInNum-1-i);
373 MS_DEBUG_MSG(printf("[AESDMA INFO]Init Vector[%d] = 0x%x\n",(int)i, psAesInstPri->InitVector[i]));
374 }
375 }
376 psAesInstPri->u32IVLen = 16;
377 }
378
379 //AESDMA set FileInOut info
380 (psAesInstPri->fpAESDMASetFileInOut)(psAesInstPri->u32FileinAddr,psAesInstPri->u32FileInNum,psAesInstPri->u32FileOutSAddr,psAesInstPri->u32FileOutEAddr);
381
382 //AESDMA set key
383 if(psAesInstPri->bSecretKey==1)
384 {
385 (psAesInstPri->fpAESDMASetSecureKey)();
386 }
387 else
388 {
389 //u32KeyarryAddr = (MS_U32)&psAesInstPri->CipherKey[0];
390 //(psAesInstPri->fpAESDMASetKey)((MS_U32*)u32KeyarryAddr);
391 (psAesInstPri->fpAESDMASetKey_Ex)((MS_U8*)psAesInstPri->ptrKey, psAesInstPri->u32KeyLen);
392
393 if(0 != psAesInstPri->u32KeyIndex)
394 {
395 (psAesInstPri->fpAESDMASetKeyIndex)(psAesInstPri->u32KeyIndex, psAesInstPri->bOddKey);
396 }
397 }
398
399 //AESDMA trigger start
400 u32Ret = (psAesInstPri->fpAESDMAStart)(1);
401 MS_DEBUG_MSG(printf("[AESDMA INFO]MDrv_CMD_AESDMA_Start\n"));
402 if (u32Ret == DRVAESDMA_OK)
403 u32Ret = UTOPIA_STATUS_SUCCESS;
404 else
405 u32Ret = UTOPIA_STATUS_FAIL;
406 }
407 break;
408
409 case MDrv_CMD_AESDMA_GetStatus:
410 {
411 if ((psAesInstPri->fpAESDMAGetStatus)(&u32Ret) == UTOPIA_STATUS_SUCCESS)
412 {
413 *(MS_U32 *)pArgs = u32Ret;
414 u32Ret = UTOPIA_STATUS_SUCCESS;
415 }
416 else
417 {
418 u32Ret = UTOPIA_STATUS_FAIL;
419 }
420 }
421 break;
422
423 case MDrv_CMD_AESDMA_IsFinished:
424 {
425 if (FALSE == MsOS_SHM_GetId((MS_U8*)"AESDMA driver", sizeof(AESDMA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_QUERY))
426 {
427 printf("[AESDMA INFO]query Resouce shared memory fail\n");
428 u32Ret = UTOPIA_STATUS_ERR_NOMEM;
429 break;
430 }
431 else
432 {
433
434 #if defined (__aarch64__)
435
436 psAesResourceShared = (AESDMA_RESOURCE_SHARED*)u32Addr;
437 #else
438 psAesResourceShared = (AESDMA_RESOURCE_SHARED*)(MS_U32)u32Addr;
439 #endif
440 pTmpResource = psAesResourceShared->pAESResource;
441 MS_DEBUG_MSG(printf("\n[AESDMA INFO]pResource = %p\n",(int)psAesResourceShared->pAESResource));
442 }
443
444 while ((psAesInstPri->fpAESDMAIsFinished)(&u32Ret) != DRVAESDMA_OK);
445
446 //CBC segmental encryption case
447 if(((psAesInstPri->u32Mode == E_DRVAESDMA_CIPHER_CBC)||(psAesInstPri->u32Mode == E_DRVAESDMA_CIPHER_CTS_CBC))
448 && psAesInstPri->bDescrypt == FALSE)
449 {
450 //printf("[AESDMA]FileOutStartAddr PA = %x\n",psAesInstPri->u32FileOutSAddr);
451 //printf("[AESDMA]Descrypt = %x\n",psAesInstPri->bDescrypt);
452 MS_U32 i;
453 MS_VIRT FileOutStartVirtAddr;
454
455 FileOutStartVirtAddr = MsOS_PA2KSEG1(psAesInstPri->u32FileOutSAddr);
456
457 for(i = 0; i < 16; i++)
458 {
459 psAesInstPri->InitVector[16-i-1] = *(MS_U8 *)(FileOutStartVirtAddr+psAesInstPri->u32FileInNum-1-i);
460 MS_DEBUG_MSG(printf("[AESDMA INFO]Init Vector[%d] = 0x%x\n",(int)i, psAesInstPri->InitVector[i]));
461 }
462 psAesInstPri->u32IVLen = 16;
463
464 }
465
466 //clear secret key setting
467 psAesInstPri->bSecretKey = 0;
468 UtopiaResourceRelease(pTmpResource);
469 MS_DEBUG_MSG(printf("[AESDMA INFO]MDrv_AESDMA_IsFinished\n"));
470 u32Ret = UTOPIA_STATUS_SUCCESS;
471 }
472 break;
473
474 case MDrv_CMD_AESDMA_SetSecureKey:
475 {
476 psAesInstPri->bSecretKey = 1;
477 u32Ret = UTOPIA_STATUS_SUCCESS;
478 }
479 break;
480
481 case MDrv_CMD_AESDMA_SetPS:
482 {
483 pSetPSParam = (PAESDMA_SET_PS)pArgs;
484 u32Ret = (psAesInstPri->fpAESDMASetPS)(pSetPSParam->u32PTN,pSetPSParam->u32Mask,pSetPSParam->bPSin_Enable,pSetPSParam->bPSout_Enable);
485 if (u32Ret == DRVAESDMA_OK)
486 u32Ret = UTOPIA_STATUS_SUCCESS;
487 else
488 u32Ret = UTOPIA_STATUS_FAIL;
489 }
490 break;
491
492 case MDrv_CMD_AESDMA_PSRelease:
493 {
494 u32Ret = (psAesInstPri->fpAESDMAPSRelease)();
495 if (u32Ret == DRVAESDMA_OK)
496 u32Ret = UTOPIA_STATUS_SUCCESS;
497 else
498 u32Ret = UTOPIA_STATUS_FAIL;
499 }
500 break;
501
502 case MDrv_CMD_AESDMA_GetPSMatchedByteCNT:
503 {
504 if ((psAesInstPri->fpAESDMAGetPSMatchedByteCNT)(&u32Ret) == UTOPIA_STATUS_SUCCESS)
505 {
506 *(MS_U32 *)pArgs = u32Ret;
507 u32Ret = UTOPIA_STATUS_SUCCESS;
508 }
509 else
510 {
511 u32Ret = UTOPIA_STATUS_FAIL;
512 }
513 }
514 break;
515
516 case MDrv_CMD_AESDMA_GetPSMatchedPTN:
517 {
518 u32Ret = (psAesInstPri->fpAESDMAGetPSMatchedPTN)();
519 }
520 break;
521
522 case MDrv_CMD_AESDMA_Notify:
523 {
524 pNotifyParam = (PAESDMA_NOTIFY)pArgs;
525 u32Ret = (psAesInstPri->fpAESDMANotify)(pNotifyParam->eEvents,pNotifyParam->pfCallback);
526 if (u32Ret == DRVAESDMA_OK)
527 u32Ret = UTOPIA_STATUS_SUCCESS;
528 else
529 u32Ret = UTOPIA_STATUS_FAIL;
530 }
531 break;
532
533 case MDrv_CMD_AESDMA_Rand:
534 {
535 pRandParam = (PAESDMA_RAND)pArgs;
536 u32Ret = (psAesInstPri->fpAESDMARand)(pRandParam->u32PABuf,pRandParam->u32Size);
537 if (u32Ret == DRVAESDMA_OK)
538 u32Ret = UTOPIA_STATUS_SUCCESS;
539 else
540 u32Ret = UTOPIA_STATUS_FAIL;
541 }
542 break;
543
544 case MDrv_CMD_RSA_Calculate:
545 {
546 pRSACalParam = (PRSA_CALCULATE)pArgs;
547 if(UtopiaResourceObtain(pModuleAESDMA, AESDMA_POOL_ID_RSA, &pTmpResource) != 0)
548 {
549 printf("UtopiaResourceObtainToInstant fail\n");
550 u32Ret = UTOPIA_STATUS_ERR_NOT_AVAIL;
551 break;
552 }
553
554 if(FALSE == MsOS_SHM_GetId((MS_U8*)"RSA driver", sizeof(RSA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_QUERY))
555 {
556 if(FALSE == MsOS_SHM_GetId((MS_U8*)"RSA driver", sizeof(RSA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_CREATE))
557 {
558 printf("[RSA INFO]create Resouce shared memory fail\n");
559 u32Ret = UTOPIA_STATUS_ERR_NOMEM;
560 break;
561 }
562 memset((MS_U8 *)u32Addr, 0, sizeof(RSA_RESOURCE_SHARED));
563 }
564
565 #if defined (__aarch64__)
566
567 psRSAResourceShared = (RSA_RESOURCE_SHARED*)u32Addr;
568 #else
569 psRSAResourceShared = (RSA_RESOURCE_SHARED*)(MS_U32)u32Addr;
570 #endif
571
572 psRSAResourceShared->pRSAResource = pTmpResource;
573 MS_DEBUG_MSG(printf("\n[RSA INFO]pResource = %x\n",(int)psRSAResourceShared->pRSAResource));
574
575 u32Ret = (psAesInstPri->fpRSACalculate)(pRSACalParam->pstSign,pRSACalParam->pstKey,pRSACalParam->eMode);
576 if (u32Ret == DRVAESDMA_OK)
577 u32Ret = UTOPIA_STATUS_SUCCESS;
578 else
579 u32Ret = UTOPIA_STATUS_FAIL;
580 }
581 break;
582
583 case MDrv_CMD_RSA_IsFinished:
584 {
585 if(pArgs)
586 {
587 u32timeout_value = *(MS_U32 *)pArgs;
588 }
589 else
590 {
591 printf("[RSA INFO] Please pass timeout value to driver\n");
592 u32Ret = UTOPIA_STATUS_ERR_INV;
593 break;
594 }
595
596 if (u32timeout_value > RSA_MAX_TIMEOUT_VALUE)
597 {
598 printf("[RSA INFO] Invalid timeout value\n");
599 u32Ret = UTOPIA_STATUS_ERR_INV;
600 break;
601 }
602
603 if (FALSE == MsOS_SHM_GetId((MS_U8*)"RSA driver", sizeof(RSA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_QUERY))
604 {
605 printf("[RSA INFO]query Resouce shared memory fail\n");
606 u32Ret = UTOPIA_STATUS_ERR_NOMEM;
607 break;
608 }
609 else
610 {
611 psRSAResourceShared = (RSA_RESOURCE_SHARED*)u32Addr;
612 pTmpResource = psRSAResourceShared->pRSAResource;
613 MS_DEBUG_MSG(printf("\n[RSA INFO]pResource = %x\n",(int)psRSAResourceShared->pRSAResource));
614 }
615
616 while ((psAesInstPri->fpRSAIsFinished)() != DRVAESDMA_OK)
617 {
618 #ifdef MSOS_TYPE_OPTEE
619 #else
620 MsOS_DelayTaskUs(10);
621 #endif
622 u32timeout_count++;
623
624 //timeout
625 if(u32timeout_count>u32timeout_value)
626 {
627 UtopiaResourceRelease(pTmpResource);
628 printf("[RSA ERROR] RSA timeout happened\n");
629 u32Ret = UTOPIA_STATUS_FAIL;
630 break;
631 }
632
633 }
634
635 MS_DEBUG_MSG(printf("[RSA INFO]MDrv_RSA_IsFinished\n"));
636 u32Ret = UTOPIA_STATUS_SUCCESS;
637 }
638 break;
639
640 case MDrv_CMD_RSA_Output:
641 {
642 if (FALSE == MsOS_SHM_GetId((MS_U8*)"RSA driver", sizeof(RSA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_QUERY))
643 {
644 printf("[RSA INFO]query Resouce shared memory fail\n");
645 u32Ret = UTOPIA_STATUS_ERR_NOMEM;
646 break;
647 }
648 else
649 {
650 psRSAResourceShared = (RSA_RESOURCE_SHARED*)u32Addr;
651 pTmpResource = psRSAResourceShared->pRSAResource;
652 MS_DEBUG_MSG(printf("\n[RSA INFO]pResource = %x\n",(int)psRSAResourceShared->pRSAResource));
653 }
654
655 pRSAOutParam = (PRSA_OUTPUT)pArgs;
656 while((psAesInstPri->fpRSAIsFinished)()==1);
657 u32Ret = (psAesInstPri->fpRSAOutput)(pRSAOutParam->eMode,pRSAOutParam->pstRSAOut);
658
659 UtopiaResourceRelease(pTmpResource);
660 if (u32Ret == DRVAESDMA_OK)
661 u32Ret = UTOPIA_STATUS_SUCCESS;
662 else
663 u32Ret = UTOPIA_STATUS_FAIL;
664 }
665 break;
666
667 case MDrv_CMD_SHA_Calculate:
668 {
669 pSHACalParam = (PSHA_CALCULATE)pArgs;
670 if(UtopiaResourceObtain(pModuleAESDMA, AESDMA_POOL_ID_SHA, &pTmpResource) != 0)
671 {
672 printf("UtopiaResourceObtainToInstant fail\n");
673 u32Ret = UTOPIA_STATUS_ERR_NOT_AVAIL;
674 }
675 u32Ret = (psAesInstPri->fpSHACalculate)(pSHACalParam->eMode,pSHACalParam->u32PAInBuf,pSHACalParam->u32Size,pSHACalParam->u32PAOutBuf);
676 UtopiaResourceRelease(pTmpResource);
677 if (u32Ret == DRVAESDMA_OK)
678 u32Ret = UTOPIA_STATUS_SUCCESS;
679 else
680 u32Ret = UTOPIA_STATUS_FAIL;
681 }
682 break;
683
684 case MDrv_CMD_AESDMA_Memcpy:
685 {
686 //AESDMA trigger start for using AESDMA replace BDMA case
687 u32Ret = (psAesInstPri->fpAESDMAStart)(1);
688
689 if (u32Ret == DRVAESDMA_OK)
690 u32Ret = UTOPIA_STATUS_SUCCESS;
691 else
692 u32Ret = UTOPIA_STATUS_FAIL;
693 }
694 break;
695
696 case MDrv_CMD_SHA_CalculateManual:
697 {
698 pSHACalManuParam = (PSHA_CALCULATE_MANUAL)pArgs;
699 if(UtopiaResourceObtain(pModuleAESDMA, AESDMA_POOL_ID_SHA, &pTmpResource) != 0)
700 {
701 printf("UtopiaResourceObtainToInstant fail\n");
702 u32Ret = UTOPIA_STATUS_ERR_NOT_AVAIL;
703 }
704 u32Ret = (psAesInstPri->fpSHACalculateManual)(pSHACalManuParam->stCfg,pSHACalManuParam->eStage,pSHACalManuParam->u32DoneBytes,pSHACalManuParam->pu8SetIV);
705 UtopiaResourceRelease(pTmpResource);
706 if (u32Ret == DRVAESDMA_OK)
707 u32Ret = UTOPIA_STATUS_SUCCESS;
708 else
709 u32Ret = UTOPIA_STATUS_FAIL;
710 }
711 break;
712
713 case MDrv_CMD_AESDMA_SetKey_Ex:
714 {
715 pSetKeyEx = (PAESDMA_SET_KEY_EX)pArgs;
716 if(pSetKeyEx->pu8Key == NULL)
717 {
718 psAesInstPri->ptrKey = 0;
719 }
720 else
721 {
722 psAesInstPri->u32KeyIndex = 0;
723 memcpy((void *)psAesInstPri->CipherKey, pSetKeyEx->pu8Key, pSetKeyEx->u32Len);
724 psAesInstPri->ptrKey = (MS_VIRT)psAesInstPri->CipherKey;
725 }
726
727 psAesInstPri->u32KeyLen = pSetKeyEx->u32Len;
728 u32Ret = UTOPIA_STATUS_SUCCESS;
729 }
730 break;
731
732 case MDrv_CMD_AESDMA_SetIV_Ex:
733 {
734 pSetIVEx = (PAESDMA_SET_IV_EX)pArgs;
735 memcpy((void *)psAesInstPri->InitVector, pSetIVEx->pu8IV, pSetIVEx->u32Len);
736 psAesInstPri->u32IVLen = pSetIVEx->u32Len;
737 u32Ret = UTOPIA_STATUS_SUCCESS;
738 }
739 break;
740
741 case MDrv_CMD_AESDMA_Set_Key_Index:
742 {
743 pKeyIndex = (PAESDMA_KEY_INDEX)pArgs;
744 psAesInstPri->u32KeyIndex = pKeyIndex->u32KeyIndex;
745 psAesInstPri->bOddKey = pKeyIndex->bOddKeyEn;
746 psAesInstPri->ptrKey = 0;
747 u32Ret = (psAesInstPri->fpAESDMASetKeyIndex)(pKeyIndex->u32KeyIndex, pKeyIndex->bOddKeyEn);
748 if (u32Ret == DRVAESDMA_OK)
749 u32Ret = UTOPIA_STATUS_SUCCESS;
750 else
751 u32Ret = UTOPIA_STATUS_FAIL;
752 }
753 break;
754
755 case MDrv_CMD_AESDMA_SetDefaultCAVid:
756 {
757 pCAVid = (PAESDMA_CAVID)pArgs;
758 u32Ret = (psAesInstPri->fpAESDMASetDefaultCAVid)(pCAVid->u32CAVid);
759 if (u32Ret == DRVAESDMA_OK)
760 {
761 psAesInstPri->u32CAVid = pCAVid->u32CAVid;
762 u32Ret = UTOPIA_STATUS_SUCCESS;
763 }
764 else
765 {
766 u32Ret = UTOPIA_STATUS_FAIL;
767 }
768 }
769 break;
770
771 case MDrv_CMD_AESDMA_AllocKeySlot:
772 {
773 MS_U32 i = 0;
774
775 pAllocKeySlot = (PAESDMA_ALLOC_KEY_SLOT)pArgs;
776
777 for(i = 0;i< sizeof(psAesInstPri->u8KeySlotUsage);i++)
778 {
779 if(0 == psAesInstPri->u8KeySlotUsage[i])
780 {
781 break;
782 }
783 }
784
785 if(sizeof(psAesInstPri->u8KeySlotUsage) == i)
786 {
787 u32Ret = UTOPIA_STATUS_FAIL;
788 }
789 else
790 {
791 psAesInstPri->u8KeySlotUsage[i] = 1;
792 *pAllocKeySlot->pu32KeyIndex = i + AESDMA_KEY_SLOT_BASE;
793 u32Ret = UTOPIA_STATUS_SUCCESS;
794 }
795 }
796 break;
797
798 case MDrv_CMD_AESDMA_FreeKeySlot:
799 {
800 pKeyIndex = (PAESDMA_KEY_INDEX)pArgs;
801 u32Ret = (psAesInstPri->fpAESDMASetDefaultCAVid)(psAesInstPri->u32CAVid);
802 if(u32Ret != DRVAESDMA_OK)
803 {
804 u32Ret = UTOPIA_STATUS_FAIL;
805 break;
806 }
807
808 u32Ret = (psAesInstPri->fpAESDMAFreeKeySlot)(pKeyIndex->u32KeyIndex);
809
810 if ((u32Ret == DRVAESDMA_OK) && (pKeyIndex->u32KeyIndex >= AESDMA_KEY_SLOT_BASE))
811 {
812 psAesInstPri->u8KeySlotUsage[(pKeyIndex->u32KeyIndex - AESDMA_KEY_SLOT_BASE)] = 0;
813 u32Ret = UTOPIA_STATUS_SUCCESS;
814 }
815 else
816 {
817 u32Ret = UTOPIA_STATUS_FAIL;
818 }
819 }
820 break;
821
822 default:
823 break;
824 };
825
826 UtopiaResourceRelease(pDRVAESResource);
827
828 return u32Ret;
829 }
830
AESDMAClose(void * pInstance)831 MS_U32 AESDMAClose(void* pInstance)
832 {
833 UtopiaInstanceDelete(pInstance);
834
835 return TRUE;
836 }
837
838