1 #if !defined(MSOS_TYPE_LINUX_KERNEL)
2 #include <stdio.h>
3 #include <string.h>
4 #else
5 #include <linux/string.h>
6 #include <linux/slab.h>
7 #endif
8 #include "MsTypes.h"
9 #include "utopia_dapi.h"
10 #include "utopia.h"
11 #include "drvAESDMA.h"
12 #include "drvAESDMA_private.h"
13 #include "MsOS.h"
14 #include "halAESDMA.h"
15 #include "ULog.h"
16
17 #define TAG_AESDMA "AESDMA"
18
19 enum
20 {
21 AESDMA_POOL_ID_AES = 0,
22 AESDMA_POOL_ID_SHA,
23 AESDMA_POOL_ID_RSA,
24 } eAesdmaPoolID;
25
AESDMARegisterToUtopia(FUtopiaOpen ModuleType)26 void AESDMARegisterToUtopia(FUtopiaOpen ModuleType)
27 {
28 // 1. deal with module
29 void* pUtopiaModule = NULL;
30 UtopiaModuleCreate(MODULE_AESDMA, 8, &pUtopiaModule);
31 UtopiaModuleRegister(pUtopiaModule);
32 UtopiaModuleSetupFunctionPtr(pUtopiaModule, (FUtopiaOpen)AESDMAOpen, (FUtopiaClose)AESDMAClose, (FUtopiaIOctl)AESDMAIoctl);
33
34 // 2. deal with resource
35 void* psResource = NULL;
36 UtopiaModuleAddResourceStart(pUtopiaModule, AESDMA_POOL_ID_AES);
37 UtopiaResourceCreate("AES", sizeof(AESDMA_RESOURCE_PRIVATE), &psResource);
38 UtopiaResourceRegister(pUtopiaModule, psResource, AESDMA_POOL_ID_AES);
39 UtopiaModuleAddResourceEnd(pUtopiaModule, AESDMA_POOL_ID_AES);
40
41 UtopiaModuleAddResourceStart(pUtopiaModule, AESDMA_POOL_ID_SHA);
42 psResource = NULL;
43 UtopiaResourceCreate("SHA", sizeof(SHA_RESOURCE_PRIVATE), &psResource);
44 UtopiaResourceRegister(pUtopiaModule, psResource, AESDMA_POOL_ID_SHA);
45 UtopiaModuleAddResourceEnd(pUtopiaModule, AESDMA_POOL_ID_SHA);
46
47 UtopiaModuleAddResourceStart(pUtopiaModule, AESDMA_POOL_ID_RSA);
48 psResource = NULL;
49 UtopiaResourceCreate("RSA", sizeof(RSA_RESOURCE_PRIVATE), &psResource);
50 UtopiaResourceRegister(pUtopiaModule, psResource, AESDMA_POOL_ID_RSA);
51 UtopiaModuleAddResourceEnd(pUtopiaModule, AESDMA_POOL_ID_RSA);
52
53 }
54
AESDMAOpen(void ** ppInstance,MS_U32 u32ModuleVersion,void * pAttribute)55 MS_U32 AESDMAOpen(void** ppInstance, MS_U32 u32ModuleVersion, void* pAttribute)
56 {
57 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "\n[AESDMA INFO]AESDMA open \n"));
58
59 AESDMA_INSTANT_PRIVATE *pAesdmaPri = NULL;
60 void *pAesdmaPriVoid = NULL;
61 UtopiaInstanceCreate(sizeof(AESDMA_INSTANT_PRIVATE), ppInstance);
62 UtopiaInstanceGetPrivate(*ppInstance, &pAesdmaPriVoid);
63
64 pAesdmaPri = (AESDMA_INSTANT_PRIVATE *)pAesdmaPriVoid;
65
66 pAesdmaPri->fpAESDMAInit = _MDrv_AESDMA_Init;
67 pAesdmaPri->fpAESDMASetIV = _MDrv_AESDMA_SetIV;
68 pAesdmaPri->fpAESDMAReset = _MDrv_AESDMA_Reset;
69 pAesdmaPri->fpAESDMASetFileInOut = _MDrv_AESDMA_SetFileInOut;
70 pAesdmaPri->fpAESDMASetKey = _MDrv_AESDMA_SetKey;
71 pAesdmaPri->fpAESDMASelEng = _MDrv_AESDMA_SelEng;
72 pAesdmaPri->fpAESDMAStart = _MDrv_AESDMA_Start;
73 pAesdmaPri->fpAESDMAGetStatus = _MDrv_AESDMA_GetStatus;
74 pAesdmaPri->fpAESDMAIsFinished = _MDrv_AESDMA_IsFinished;
75 pAesdmaPri->fpAESDMASetClk = _MDrv_AESDMA_Set_Clk;
76 pAesdmaPri->fpAESDMASetSecureKey = _MDrv_AESDMA_SetSecureKey;
77 pAesdmaPri->fpAESDMASetPS = _MDrv_AESDMA_SetPS;
78 pAesdmaPri->fpAESDMAPSRelease = _MDrv_AESDMA_PSRelease;
79 pAesdmaPri->fpAESDMAGetPSMatchedByteCNT = _MDrv_AESDMA_GetPSMatchedByteCNT;
80 pAesdmaPri->fpAESDMAGetPSMatchedPTN = _MDrv_AESDMA_GetPSMatchedPTN;
81 pAesdmaPri->fpAESDMANotify = _MDrv_AESDMA_Notify;
82 pAesdmaPri->fpAESDMARand = _MDrv_AESDMA_Rand;
83 pAesdmaPri->fpAESDMAGetRandNum = _MDrv_AESDMA_Get_Rand_Num;
84 pAesdmaPri->fpRSACalculate = _MDrv_RSA_Calculate;
85 pAesdmaPri->fpRSAIsFinished = _MDrv_RSA_IsFinished;
86 pAesdmaPri->fpRSAOutput = _MDrv_RSA_Output;
87 pAesdmaPri->fpSHACalculate = _MDrv_SHA_Calculate;
88 pAesdmaPri->fpSHACalculateManual = MDrv_SHA_CalculateManual;
89 pAesdmaPri->fpAESDMAParserMaskscrmb = _MDrv_AESDMA_Parser_MaskScrmb;
90 pAesdmaPri->fpAESDMAParserSetScrmbPatten = _MDrv_AESDMA_Parser_SetScrmbPattern;
91 pAesdmaPri->fpAESDMAParserBypassPid = _MDrv_AESDMA_Parser_BypassPid;
92 pAesdmaPri->fpAESDMAParserSetPid = _MDrv_AESDMA_Parser_SetPid;
93 pAesdmaPri->fpAESDMAParserEncrypt = _MDrv_AESDMA_Parser_Encrypt;
94 pAesdmaPri->fpAESDMAParserDecrypt = _MDrv_AESDMA_Parser_Decrypt;
95 pAesdmaPri->fpAESDMAParserQueryPidCount = _MDrv_AESDMA_Parser_QueryPidCount;
96 pAesdmaPri->fpAESDMAParserSetAddedScrmbPattern = _MDrv_AESDMA_Parser_SetAddedScrmbPattern;
97 pAesdmaPri->fpAESDMASetKeySel = _MDrv_AESDMA_SetKeySel;
98 pAesdmaPri->fpAESDMASetOddIv = _MDrv_AESDMA_SetOddIV;
99 pAesdmaPri->fpAESDMAIsSecretKeyInNormalBlank = _MDrv_AESDMA_IsSecretKeyInNormalBank;
100 pAesdmaPri->fpHDCPHDCPProcessCipher = MDrv_HDCP_ProcessCipher;
101 pAesdmaPri->fpAESDMANormalReset = _MDrv_AESDMA_NormalReset;
102 pAesdmaPri->fpGetHDCPCipherState = MDrv_HDCP_GetHdcpCipherState;
103 pAesdmaPri->bEvenScrmbPatternEn = FALSE;
104 pAesdmaPri->bOddScrmbPatternEn = FALSE;
105 pAesdmaPri->bSetKey = FALSE;
106 pAesdmaPri->bSetEng = FALSE;
107 pAesdmaPri->bSetIV = FALSE;
108 pAesdmaPri->bHwParserEn = FALSE;
109 pAesdmaPri->bPid0En = FALSE;
110 pAesdmaPri->bPid1En = FALSE;
111 pAesdmaPri->bMaskScrmbEn = FALSE;
112 pAesdmaPri->fpAESDMAKeyIndex = _MDrv_AESDMA_SetKeyIndex;
113 pAesdmaPri->u32KeyIndexEven = 0x0;
114 pAesdmaPri->u32KeyIndexOdd = 0x0;
115 pAesdmaPri->bEnableKeyIndexEvenKey = FALSE;
116 pAesdmaPri->bEnableKeyIndexOddKey = FALSE;
117 pAesdmaPri->fpAesCtr64 = _MDrv_AESDMA_SetAesCtr64;
118 pAesdmaPri->bEnableAesCtr64 = FALSE;
119 pAesdmaPri->fpAESDMASecureKeyIdx = _MDrv_AESDMA_SetSecuredKeyIndex;
120 pAesdmaPri->u8SecureKeyIndex = 1;
121 pAesdmaPri->u32miunum = 0;
122 return UTOPIA_STATUS_SUCCESS;
123 }
124
AESDMAIoctl(void * pInstance,MS_U32 u32Cmd,void * pArgs)125 MS_U32 AESDMAIoctl(void* pInstance, MS_U32 u32Cmd, void* pArgs)
126 {
127 PAESDMA_INIT pInitParam = NULL;
128 PAESDMA_FILE_INOUT pFileInOutParam = NULL;
129 PAESDMA_SEL_ENG pSelEngParam = NULL;
130 PAESDMA_SET_PS pSetPSParam = NULL;
131 PAESDMA_NOTIFY pNotifyParam = NULL;
132 PAESDMA_RAND pRandParam = NULL;
133 PRSA_CALCULATE pRSACalParam = NULL;
134 PRSA_OUTPUT pRSAOutParam = NULL;
135 PSHA_CALCULATE pSHACalParam = NULL;
136 PSHA_CALCULATE_MANUAL pSHACalManualParam = NULL;
137 PAESDMA_PARSER_CONFIGURATIONS pParserConfigurations = NULL;
138 PAESDMA_PARSER_PID_CONFIGURATIONS pParserPidConfigurations = NULL;
139
140 MS_U32 u32Ret = 0;
141 MS_BOOL bEnable = 0;
142 AESDMA_INSTANT_PRIVATE* psAesInstPri = NULL;
143 AESDMA_RESOURCE_SHARED* psAesResourceShared = NULL;
144 RSA_RESOURCE_SHARED* psRSAResourceShared = NULL;
145 PHDCP_CIPHER psHDCPData = NULL;
146 PHDCP_CIPHER_STATE psHDCPCipherState = NULL;
147 PAESDMA_KEY_INDEX psAESDMAKeyIndex = NULL;
148
149 UtopiaInstanceGetPrivate(pInstance, (void*)&psAesInstPri);
150 void* pResource = NULL;
151 void* pModule = NULL;
152 UtopiaInstanceGetModule(pInstance, &pModule);
153 MS_VIRT u32Addr = 0;
154 MS_U32 u32ShmId = 0;
155 MS_U32 u32BufSize = 0;
156 MS_VIRT u32IVarrayAddr = 0;
157 MS_VIRT u32KeyarryAddr = 0;
158 MS_U32 u32timeout_count = 0;
159 MS_U32 u32timeout_value = 0;
160
161 switch(u32Cmd)
162 {
163 case MDrv_CMD_AESDMA_Init:
164 {
165 pInitParam = (PAESDMA_INIT)pArgs;
166 u32Ret = (psAesInstPri->fpAESDMAInit)(pInitParam->u32miu0addr,pInitParam->u32miu1addr,pInitParam->u32miunum);
167
168 psAesInstPri->u32miu0addr = pInitParam->u32miu0addr;
169 psAesInstPri->u32miu1addr = pInitParam->u32miu1addr;
170 psAesInstPri->u32miunum = pInitParam->u32miunum;
171 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "[AESDMA INFO]u32miu0addr = %lx\n",psAesInstPri->u32miu0addr));
172 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "[AESDMA INFO]u32miu1addr = %lx\n",psAesInstPri->u32miu1addr));
173 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "[AESDMA INFO]u32miunum = %lx\n",psAesInstPri->u32miunum));
174
175 if (u32Ret == DRVAESDMA_OK)
176 return UTOPIA_STATUS_SUCCESS;
177 else
178 return UTOPIA_STATUS_FAIL;
179 }
180 case MDrv_CMD_AESDMA_SetIV:
181 {
182 memcpy((void *)psAesInstPri->InitVector,(void *)pArgs,16);
183 psAesInstPri->bSetIV = TRUE;
184 return UTOPIA_STATUS_SUCCESS;
185 }
186 case MDrv_CMD_AESDMA_Reset:
187 {
188 u32Ret = (psAesInstPri->fpAESDMAReset)();
189 if (u32Ret == DRVAESDMA_OK)
190 return UTOPIA_STATUS_SUCCESS;
191 else
192 return UTOPIA_STATUS_FAIL;
193 }
194 case MDrv_CMD_AESDMA_SetFileInOut:
195 {
196 pFileInOutParam = (PAESDMA_FILE_INOUT)pArgs;
197 psAesInstPri->u32FileinAddr = pFileInOutParam->u32FileinAddr;
198 psAesInstPri->u32FileInNum = pFileInOutParam->u32FileInNum;
199 psAesInstPri->u32FileOutSAddr = pFileInOutParam->u32FileOutSAddr;
200 psAesInstPri->u32FileOutEAddr = pFileInOutParam->u32FileOutEAddr;
201 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "[AESDMA INFO]FileinAddr = %lx\n",psAesInstPri->u32FileinAddr));
202 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "[AESDMA INFO]FileInNum = %lx\n",psAesInstPri->u32FileInNum));
203 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "[AESDMA INFO]FileOutSAddr = %lx\n",psAesInstPri->u32FileOutSAddr));
204 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "[AESDMA INFO]FileOutEAddr = %lx\n",psAesInstPri->u32FileOutEAddr));
205 return UTOPIA_STATUS_SUCCESS;
206 }
207 case MDrv_CMD_AESDMA_SetKey:
208 {
209 memcpy((void *)psAesInstPri->CipherKey,(void *)pArgs,16);
210 psAesInstPri->bSetKey = TRUE;
211 return UTOPIA_STATUS_SUCCESS;
212 }
213 case MDrv_CMD_AESDMA_SelEng:
214 {
215 pSelEngParam = (PAESDMA_SEL_ENG)pArgs;
216 psAesInstPri->eMode = pSelEngParam->eMode;
217 psAesInstPri->bDescrypt = pSelEngParam->bDescrypt;
218 psAesInstPri->bSetEng = TRUE;
219 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "[AESDMA INFO]mode = %x\n",psAesInstPri->eMode));
220 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "[AESDMA INFO]Descrypt = %x\n",psAesInstPri->bDescrypt));
221 return UTOPIA_STATUS_SUCCESS;
222 }
223 case MDrv_CMD_AESDMA_Start:
224 {
225 if(UtopiaResourceObtain(pModule, AESDMA_POOL_ID_AES, &pResource) != 0)
226 {
227 ULOGE(TAG_AESDMA, "UtopiaResourceObtainToInstant fail\n");
228 return UTOPIA_STATUS_ERR_NOT_AVAIL;
229 }
230
231 if(FALSE == MsOS_SHM_GetId((MS_U8*)"AESDMA driver", sizeof(AESDMA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_QUERY))
232 {
233 if(FALSE == MsOS_SHM_GetId((MS_U8*)"AESDMA driver", sizeof(AESDMA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_CREATE))
234 {
235 ULOGE(TAG_AESDMA, "[AESDMA INFO]create Resouce shared memory fail\n");
236 return UTOPIA_STATUS_ERR_NOMEM;
237 }
238 memset( (MS_U8*)u32Addr, 0, sizeof(AESDMA_RESOURCE_SHARED));
239 }
240
241 psAesResourceShared = (AESDMA_RESOURCE_SHARED*)u32Addr;
242
243 psAesResourceShared->pAESResource = pResource;
244 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "\n[AESDMA INFO]pResource = %x\n",(MS_U32)psAesResourceShared->pAESResource));
245
246 //AESDMA reset
247 if ((psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CTR)||
248 (psAesInstPri->eMode == E_DRVAESDMA_CIPHER_DES_CTR)||
249 (psAesInstPri->eMode == E_DRVAESDMA_CIPHER_TDES_CTR))
250 {
251 (psAesInstPri->fpAESDMANormalReset)();
252 }
253 else
254 {
255 (psAesInstPri->fpAESDMAReset)();
256 }
257
258 //AESDMA set mode and select encrypt or decrypt
259 if (psAesInstPri->bSetEng == TRUE)
260 {
261 //AESDMA set mode and select encrypt or decrypt
262 (psAesInstPri->fpAESDMASelEng)(psAesInstPri->eMode,psAesInstPri->bDescrypt);
263 psAesInstPri->bSetEng = FALSE;
264 }
265
266 //AESDMA set FileInOut info
267 (psAesInstPri->fpAESDMASetFileInOut)(psAesInstPri->u32FileinAddr,psAesInstPri->u32FileInNum,psAesInstPri->u32FileOutSAddr,psAesInstPri->u32FileOutEAddr);
268
269 //AESDMA set key
270 if(psAesInstPri->bEnableTwoKey==1)
271 {
272 u32KeyarryAddr = (MS_VIRT)&psAesInstPri->CipherOddKey[0];
273 (psAesInstPri->fpAESDMASetKeySel)((MS_U32*)u32KeyarryAddr, E_DRVAESDMA_ODD_KEY);
274
275 u32KeyarryAddr = (MS_VIRT)&psAesInstPri->CipherKey[0];
276 (psAesInstPri->fpAESDMASetKeySel)((MS_U32*)u32KeyarryAddr, E_DRVAESDMA_EVEN_KEY);
277 }
278 else
279 {
280 if(psAesInstPri->bSecretKey==1)
281 {
282 (psAesInstPri->fpAESDMASecureKeyIdx)(psAesInstPri->u8SecureKeyIndex);
283 }
284 else
285 {
286 u32KeyarryAddr = (MS_VIRT)&psAesInstPri->CipherKey[0];
287 (psAesInstPri->fpAESDMASetKey)((MS_U32*)u32KeyarryAddr);
288 }
289 }
290
291 //AESDMA set IV
292 if((psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CBC)||
293 (psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CTR)||
294 (psAesInstPri->eMode == E_DRVAESDMA_CIPHER_TDES_CTR)||
295 (psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CTS_CBC))
296 {
297 u32IVarrayAddr = (MS_VIRT)&psAesInstPri->InitVector[0];
298 (psAesInstPri->fpAESDMASetIV)((MS_U32*)u32IVarrayAddr);
299 psAesInstPri->bSetIV = FALSE;
300
301
302 if(psAesInstPri->bEnableTwoKey==1)
303 {
304 u32IVarrayAddr = (MS_VIRT)&psAesInstPri->InitVectorOdd[0];
305 (psAesInstPri->fpAESDMASetOddIv)((MS_U32*)u32IVarrayAddr);
306 }
307 }
308
309 // HW Parser configurations
310 if (psAesInstPri->bHwParserEn == TRUE)
311 {
312 psAesInstPri->bHwParserEn = FALSE;
313 if (psAesInstPri->bParserDecrypt == TRUE)
314 {
315 (psAesInstPri->fpAESDMAParserDecrypt)(psAesInstPri->eParserMode);
316 }
317 else
318 {
319 (psAesInstPri->fpAESDMAParserEncrypt)(psAesInstPri->eParserMode);
320 }
321
322 if (psAesInstPri->bEvenScrmbPatternEn == TRUE)
323 {
324 psAesInstPri->bEvenScrmbPatternEn = FALSE;
325 (psAesInstPri->fpAESDMAParserSetScrmbPatten)(psAesInstPri->eScrmbPattern);
326 }
327
328 if (psAesInstPri->bOddScrmbPatternEn == TRUE)
329 {
330 psAesInstPri->bOddScrmbPatternEn = FALSE;
331 (psAesInstPri->fpAESDMAParserSetAddedScrmbPattern)(psAesInstPri->eAddedScrmbPattern);
332 }
333
334 if (psAesInstPri->bMaskScrmbEn == TRUE)
335 {
336 psAesInstPri->bMaskScrmbEn = FALSE;
337 (psAesInstPri->fpAESDMAParserMaskscrmb)(psAesInstPri->bMaskScrmb);
338 }
339
340 // Set PID
341 if (psAesInstPri->bBypassPid == TRUE)
342 {
343 psAesInstPri->bBypassPid = FALSE;
344 (psAesInstPri->fpAESDMAParserBypassPid)(psAesInstPri->bBypassPid);
345 }
346
347 if (psAesInstPri->bPid0En == TRUE)
348 {
349 psAesInstPri->bPid0En = FALSE;
350 (psAesInstPri->fpAESDMAParserSetPid)(psAesInstPri->u8PidIndex, psAesInstPri->u16Pid);
351 }
352
353 if (psAesInstPri->bPid1En == TRUE)
354 {
355 psAesInstPri->bPid1En = FALSE;
356 (psAesInstPri->fpAESDMAParserSetPid)(psAesInstPri->u8PidIndex1, psAesInstPri->u16Pid1);
357 }
358 }
359 //CBC segmental decryption case
360 //if(((psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CBC)||(psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CTR)||(psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CTS_CBC))
361 // && psAesInstPri->bDescrypt == TRUE)
362 if((((psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CBC)||(psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CTS_CBC))&& psAesInstPri->bDescrypt == TRUE)||
363 (psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CTR))
364 {
365 MS_U32 i;
366 MS_VIRT FileinVirtAddr;
367
368 FileinVirtAddr = MsOS_PA2KSEG1(psAesInstPri->u32FileinAddr);
369
370 if(psAesInstPri->eMode != E_DRVAESDMA_CIPHER_CTR)
371 {
372 for(i = 0; i < 16; i++)
373 {
374 psAesInstPri->InitVector[i] = *(MS_U8 *)(FileinVirtAddr + psAesInstPri->u32FileInNum-1-i);
375 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "[AESDMA INFO]Init Vector[%d] = 0x%x\n",(MS_U32)i, psAesInstPri->InitVector[i]));
376 }
377 }
378 }
379
380 //AESDMA set FileInOut info
381 (psAesInstPri->fpAESDMASetFileInOut)(psAesInstPri->u32FileinAddr,psAesInstPri->u32FileInNum,psAesInstPri->u32FileOutSAddr,psAesInstPri->u32FileOutEAddr);
382
383 //AESDMA set key
384 if(psAesInstPri->bSecretKey==1)
385 {
386 (psAesInstPri->fpAESDMASecureKeyIdx)(psAesInstPri->u8SecureKeyIndex);
387 }
388 else
389 {
390 u32KeyarryAddr = (MS_VIRT)&psAesInstPri->CipherKey[0];
391 (psAesInstPri->fpAESDMASetKey)((MS_U32*)u32KeyarryAddr);
392 }
393
394 //Set Key Index
395 if(psAesInstPri->bEnableKeyIndexEvenKey == TRUE)
396 {
397 psAesInstPri->bEnableKeyIndexEvenKey = FALSE;
398 (psAesInstPri->fpAESDMAKeyIndex) (psAesInstPri->u32KeyIndexEven, FALSE);
399 }
400
401 if(psAesInstPri->bEnableKeyIndexOddKey == TRUE)
402 {
403 psAesInstPri->bEnableKeyIndexOddKey = FALSE;
404 (psAesInstPri->fpAESDMAKeyIndex) (psAesInstPri->u32KeyIndexOdd, TRUE);
405 }
406
407 //Set AESDMA CTR 64 Enable
408 psAesInstPri->fpAesCtr64 (psAesInstPri->bEnableAesCtr64);
409
410 //AESDMA trigger start
411 u32Ret = (psAesInstPri->fpAESDMAStart)(1);
412
413 if (u32Ret == DRVAESDMA_OK)
414 return UTOPIA_STATUS_SUCCESS;
415 else
416 return UTOPIA_STATUS_FAIL;
417 }
418 case MDrv_CMD_AESDMA_GetStatus:
419 {
420 if ((psAesInstPri->fpAESDMAGetStatus)(&u32Ret) == UTOPIA_STATUS_SUCCESS)
421 {
422 *(MS_U32 *)pArgs = u32Ret;
423 return UTOPIA_STATUS_SUCCESS;
424 }
425 else
426 {
427 return UTOPIA_STATUS_FAIL;
428 }
429 }
430 case MDrv_CMD_AESDMA_IsFinished:
431 {
432 if(pArgs)
433 {
434 u32timeout_value = *(MS_U32 *)pArgs;
435 }
436 else
437 {
438 ULOGE(TAG_AESDMA, "[AESDMA INFO] Please pass timeout value to driver\n");
439 return UTOPIA_STATUS_ERR_INV;
440 }
441
442 if ((u32timeout_value < 1) | (u32timeout_value > AES_MAX_TIMEOUT_VALUE))
443 {
444 ULOGE(TAG_AESDMA, "[AESDMA INFO] Invalid timeout value\n");
445 return UTOPIA_STATUS_ERR_INV;
446 }
447
448
449 if (FALSE == MsOS_SHM_GetId((MS_U8*)"AESDMA driver", sizeof(AESDMA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_QUERY))
450 {
451 ULOGE(TAG_AESDMA, "[AESDMA INFO]query Resouce shared memory fail\n");
452 return UTOPIA_STATUS_ERR_NOMEM;
453 }
454 else
455 {
456 psAesResourceShared = (AESDMA_RESOURCE_SHARED*)u32Addr;
457 pResource = psAesResourceShared->pAESResource;
458 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "\n[AESDMA INFO]pResource = %x\n",(MS_U32)psAesResourceShared->pAESResource));
459 }
460
461 psAesInstPri->fpAESDMAIsFinished(&u32Ret);
462 while (u32Ret != DRVAESDMA_OK)
463 {
464 MsOS_DelayTaskUs(10);
465 u32timeout_count++;
466
467 //timeout
468 if(u32timeout_count>u32timeout_value)
469 {
470 (psAesInstPri->fpAESDMAReset)();
471 UtopiaResourceRelease(pResource);
472 ULOGE(TAG_AESDMA, "[AESDMA ERROR] AESDMA timeout happened\n");
473 return UTOPIA_STATUS_FAIL;
474 }
475 psAesInstPri->fpAESDMAIsFinished(&u32Ret);
476 }
477
478 //CBC segmental encryption case
479 if(((psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CBC)||(psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CTS_CBC))
480 && psAesInstPri->bDescrypt == FALSE)
481 {
482 //printf("[AESDMA]FileOutStartAddr PA = %x\n",psAesInstPri->u32FileOutSAddr);
483 //printf("[AESDMA]Descrypt = %x\n",psAesInstPri->bDescrypt);
484 MS_U32 i;
485 MS_VIRT FileOutStartVirtAddr;
486
487 FileOutStartVirtAddr = MsOS_PA2KSEG1(psAesInstPri->u32FileOutSAddr);
488
489 for(i = 0; i < 16; i++)
490 {
491 psAesInstPri->InitVector[i] = *(MS_U8 *)(FileOutStartVirtAddr+psAesInstPri->u32FileInNum-1-i);
492 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "[AESDMA INFO]Init Vector[%d] = 0x%x\n",(MS_U32)i, psAesInstPri->InitVector[i]));
493 }
494 }
495
496 //clear secret key setting
497 psAesInstPri->bSecretKey = 0;
498
499 UtopiaResourceRelease(pResource);
500 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "[AESDMA INFO]MDrv_AESDMA_IsFinished\n"));
501 return UTOPIA_STATUS_SUCCESS;
502 }
503 case MDrv_CMD_AESDMA_SetClk:
504 {
505 bEnable = *(MS_BOOL *)pArgs;
506 u32Ret = (psAesInstPri->fpAESDMASetClk)(bEnable);
507 if (u32Ret == DRVAESDMA_OK)
508 return UTOPIA_STATUS_SUCCESS;
509 else
510 return UTOPIA_STATUS_FAIL;
511 }
512 case MDrv_CMD_AESDMA_SetSecureKey:
513 {
514 psAesInstPri->bSecretKey = 1;
515 return UTOPIA_STATUS_SUCCESS;
516 }
517 case MDrv_CMD_AESDMA_SetPS:
518 {
519 pSetPSParam = (PAESDMA_SET_PS)pArgs;
520 u32Ret = (psAesInstPri->fpAESDMASetPS)(pSetPSParam->u32PTN,pSetPSParam->u32Mask,pSetPSParam->bPSin_Enable,pSetPSParam->bPSout_Enable);
521 if (u32Ret == DRVAESDMA_OK)
522 return UTOPIA_STATUS_SUCCESS;
523 else
524 return UTOPIA_STATUS_FAIL;
525 }
526 case MDrv_CMD_AESDMA_PSRelease:
527 {
528 u32Ret = (psAesInstPri->fpAESDMAPSRelease)();
529 if (u32Ret == DRVAESDMA_OK)
530 return UTOPIA_STATUS_SUCCESS;
531 else
532 return UTOPIA_STATUS_FAIL;
533 }
534 case MDrv_CMD_AESDMA_GetPSMatchedByteCNT:
535 {
536 (psAesInstPri->fpAESDMAGetPSMatchedByteCNT)(&u32Ret);
537 return u32Ret;
538 }
539 case MDrv_CMD_AESDMA_GetPSMatchedPTN:
540 {
541 u32Ret = (psAesInstPri->fpAESDMAGetPSMatchedPTN)();
542 return u32Ret;
543 }
544 case MDrv_CMD_AESDMA_Notify:
545 {
546 pNotifyParam = (PAESDMA_NOTIFY)pArgs;
547 u32Ret = (psAesInstPri->fpAESDMANotify)(pNotifyParam->eEvents,pNotifyParam->pfCallback);
548 if (u32Ret == DRVAESDMA_OK)
549 return UTOPIA_STATUS_SUCCESS;
550 else
551 return UTOPIA_STATUS_FAIL;
552 }
553 case MDrv_CMD_AESDMA_Rand:
554 {
555 pRandParam = (PAESDMA_RAND)pArgs;
556 u32Ret = (psAesInstPri->fpAESDMARand)(pRandParam->u32PABuf,pRandParam->u32Size);
557 if (u32Ret == DRVAESDMA_OK)
558 return UTOPIA_STATUS_SUCCESS;
559 else
560 return UTOPIA_STATUS_FAIL;
561 }
562 case MDrv_CMD_RSA_Calculate:
563 {
564 pRSACalParam = (PRSA_CALCULATE)pArgs;
565 if(UtopiaResourceObtain(pModule, AESDMA_POOL_ID_RSA, &pResource) != 0)
566 {
567 ULOGE(TAG_AESDMA, "UtopiaResourceObtainToInstant fail\n");
568 return UTOPIA_STATUS_ERR_NOT_AVAIL;
569 }
570
571 if(FALSE == MsOS_SHM_GetId((MS_U8*)"RSA driver", sizeof(RSA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_QUERY))
572 {
573 if(FALSE == MsOS_SHM_GetId((MS_U8*)"RSA driver", sizeof(RSA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_CREATE))
574 {
575 ULOGE(TAG_AESDMA, "[RSA INFO]create Resouce shared memory fail\n");
576 return UTOPIA_STATUS_ERR_NOMEM;
577 }
578 memset( (MS_U8*)u32Addr, 0, sizeof(RSA_RESOURCE_SHARED));
579 }
580
581 psRSAResourceShared = (RSA_RESOURCE_SHARED*)u32Addr;
582
583 psRSAResourceShared->pRSAResource = pResource;
584 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "\n[RSA INFO]pResource = %x\n",(MS_U32)psRSAResourceShared->pRSAResource));
585
586 u32Ret = (psAesInstPri->fpRSACalculate)(pRSACalParam->pstSign,pRSACalParam->pstKey,pRSACalParam->eMode);
587 if (u32Ret == DRVAESDMA_OK)
588 return UTOPIA_STATUS_SUCCESS;
589 else
590 return UTOPIA_STATUS_FAIL;
591 }
592 case MDrv_CMD_RSA_IsFinished:
593 {
594 if(pArgs)
595 {
596 u32timeout_value = *(MS_U32 *)pArgs;
597 }
598 else
599 {
600 ULOGE(TAG_AESDMA, "[RSA INFO] Please pass timeout value to driver\n");
601 return UTOPIA_STATUS_ERR_INV;
602 }
603
604 if (u32timeout_value > RSA_MAX_TIMEOUT_VALUE)
605 {
606 ULOGE(TAG_AESDMA, "[RSA INFO] Invalid timeout value\n");
607 return UTOPIA_STATUS_ERR_INV;
608 }
609
610 if (FALSE == MsOS_SHM_GetId((MS_U8*)"RSA driver", sizeof(RSA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_QUERY))
611 {
612 ULOGE(TAG_AESDMA, "[RSA INFO]query Resouce shared memory fail\n");
613 return UTOPIA_STATUS_ERR_NOMEM;
614 }
615 else
616 {
617 psRSAResourceShared = (RSA_RESOURCE_SHARED*)u32Addr;
618 pResource = psRSAResourceShared->pRSAResource;
619 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "\n[RSA INFO]pResource = %x\n",(MS_U32)psRSAResourceShared->pRSAResource));
620 }
621
622 while ((psAesInstPri->fpRSAIsFinished)() != DRVAESDMA_OK)
623 {
624 MsOS_DelayTaskUs(10);
625 u32timeout_count++;
626
627 //timeout
628 if(u32timeout_count>u32timeout_value)
629 {
630 UtopiaResourceRelease(pResource);
631 ULOGE(TAG_AESDMA, "[RSA ERROR] RSA timeout happened\n");
632 return UTOPIA_STATUS_FAIL;
633 }
634
635 }
636
637 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "[RSA INFO]MDrv_RSA_IsFinished\n"));
638 return UTOPIA_STATUS_SUCCESS;
639
640 }
641 case MDrv_CMD_RSA_Output:
642 {
643 if (FALSE == MsOS_SHM_GetId((MS_U8*)"RSA driver", sizeof(RSA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_QUERY))
644 {
645 ULOGE(TAG_AESDMA, "[RSA INFO]query Resouce shared memory fail\n");
646 return UTOPIA_STATUS_ERR_NOMEM;
647 }
648 else
649 {
650 psRSAResourceShared = (RSA_RESOURCE_SHARED*)u32Addr;
651 pResource = psRSAResourceShared->pRSAResource;
652 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "\n[RSA INFO]pResource = %x\n",(MS_U32)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(pResource);
660 if (u32Ret == DRVAESDMA_OK)
661 return UTOPIA_STATUS_SUCCESS;
662 else
663 return UTOPIA_STATUS_FAIL;
664 }
665 case MDrv_CMD_SHA_Calculate:
666 {
667 pSHACalParam = (PSHA_CALCULATE)pArgs;
668 if(UtopiaResourceObtain(pModule, AESDMA_POOL_ID_SHA, &pResource) != 0)
669 {
670 ULOGE(TAG_AESDMA, "UtopiaResourceObtainToInstant fail\n");
671 return UTOPIA_STATUS_ERR_NOT_AVAIL;
672 }
673 u32Ret = (psAesInstPri->fpSHACalculate)(pSHACalParam->eMode,pSHACalParam->u32PAInBuf,pSHACalParam->u32Size,pSHACalParam->u32PAOutBuf);
674 UtopiaResourceRelease(pResource);
675 if (u32Ret == DRVAESDMA_OK)
676 return UTOPIA_STATUS_SUCCESS;
677 else
678 return UTOPIA_STATUS_FAIL;
679 }
680 case MDrv_CMD_AESDMA_Memcpy:
681 {
682 if(UtopiaResourceObtain(pModule, AESDMA_POOL_ID_AES, &pResource) != 0)
683 {
684 ULOGE(TAG_AESDMA, "UtopiaResourceObtainToInstant fail\n");
685 return UTOPIA_STATUS_ERR_NOT_AVAIL;
686 }
687
688 if(FALSE == MsOS_SHM_GetId((MS_U8*)"AESDMA driver", sizeof(AESDMA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_QUERY))
689 {
690 if(FALSE == MsOS_SHM_GetId((MS_U8*)"AESDMA driver", sizeof(AESDMA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_CREATE))
691 {
692 ULOGE(TAG_AESDMA, "[AESDMA INFO]create Resouce shared memory fail\n");
693 return UTOPIA_STATUS_ERR_NOMEM;
694 }
695 memset( (MS_U8*)u32Addr, 0, sizeof(AESDMA_RESOURCE_SHARED));
696 }
697
698 psAesResourceShared = (AESDMA_RESOURCE_SHARED*)u32Addr;
699
700 psAesResourceShared->pAESResource = pResource;
701 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "\n[AESDMA INFO]pResource = %x\n",(MS_U32)psAesResourceShared->pAESResource));
702
703 //AESDMA reset
704 (psAesInstPri->fpAESDMAReset)();
705
706 //AESDMA set FileInOut info
707 (psAesInstPri->fpAESDMASetFileInOut)(psAesInstPri->u32FileinAddr,psAesInstPri->u32FileInNum,psAesInstPri->u32FileOutSAddr,psAesInstPri->u32FileOutEAddr);
708
709 //AESDMA trigger start for using AESDMA replace BDMA case
710 u32Ret = (psAesInstPri->fpAESDMAStart)(1);
711
712 if (u32Ret == DRVAESDMA_OK)
713 return UTOPIA_STATUS_SUCCESS;
714 else
715 return UTOPIA_STATUS_FAIL;
716 }
717 case MDrv_CMD_SHA_CalculateManual:
718 {
719 pSHACalManualParam = (PSHA_CALCULATE_MANUAL)pArgs;
720 if(UtopiaResourceObtain(pModule, AESDMA_POOL_ID_SHA, &pResource) != 0)
721 {
722 ULOGE(TAG_AESDMA, "UtopiaResourceObtainToInstant fail\n");
723 return UTOPIA_STATUS_ERR_NOT_AVAIL;
724 }
725 u32Ret = (psAesInstPri->fpSHACalculateManual)(pSHACalManualParam->stCfg,pSHACalManualParam->eStage,pSHACalManualParam->u32DoneBytes,pSHACalManualParam->pu8SetIV);
726 UtopiaResourceRelease(pResource);
727 if (u32Ret == DRVAESDMA_OK)
728 return UTOPIA_STATUS_SUCCESS;
729 else
730 return UTOPIA_STATUS_FAIL;
731 }
732
733
734 case MDrv_CMD_AESDMA_PARSER_SETADDEDSCRMBPATTERN:
735 {
736 if (pArgs == NULL)
737 return UTOPIA_STATUS_FAIL;
738
739 pParserConfigurations = (PAESDMA_PARSER_CONFIGURATIONS)pArgs;
740 psAesInstPri->eAddedScrmbPattern = pParserConfigurations->eAddedScrmbPattern;
741 psAesInstPri->bOddScrmbPatternEn = TRUE;
742 return UTOPIA_STATUS_SUCCESS;
743 }
744
745 case MDrv_CMD_AESDMA_PARSER_QUERYPIDCOUNT:
746 {
747 if (pArgs == NULL)
748 return UTOPIA_STATUS_FAIL;
749
750 psAesInstPri->fpAESDMAParserQueryPidCount(pArgs);
751
752 return UTOPIA_STATUS_SUCCESS;
753 }
754
755 case MDrv_CMD_AESDMA_PARSER_MASKSCRMB:
756 {
757 if (pArgs == NULL)
758 return UTOPIA_STATUS_FAIL;
759
760 bEnable = *(MS_BOOL *)pArgs;
761 psAesInstPri->bMaskScrmb = bEnable;
762 psAesInstPri->bMaskScrmbEn = TRUE;
763 return UTOPIA_STATUS_SUCCESS;
764 }
765
766 case MDrv_CMD_AESDMA_PARSER_SETSCRMBPATTERN:
767 {
768 if (pArgs == NULL)
769 return UTOPIA_STATUS_FAIL;
770
771 pParserConfigurations = (PAESDMA_PARSER_CONFIGURATIONS)pArgs;
772 psAesInstPri->eScrmbPattern = pParserConfigurations->eScrmbPattern;
773 psAesInstPri->bEvenScrmbPatternEn = TRUE;
774 return UTOPIA_STATUS_SUCCESS;
775 }
776
777 case MDrv_CMD_AESDMA_PARSER_BYPASSPID:
778 {
779 if (pArgs == NULL)
780 return UTOPIA_STATUS_FAIL;
781
782 pParserPidConfigurations = (PAESDMA_PARSER_PID_CONFIGURATIONS)pArgs;
783 psAesInstPri->bBypassPid = pParserPidConfigurations->bBypassPid;
784 return UTOPIA_STATUS_SUCCESS;
785 }
786
787 case MDrv_CMD_AESDMA_PARSER_SETPID:
788 {
789 if (pArgs == NULL)
790 return UTOPIA_STATUS_FAIL;
791
792 pParserPidConfigurations = (PAESDMA_PARSER_PID_CONFIGURATIONS)pArgs;
793
794 if (pParserPidConfigurations->u8PidIndex == 0)
795 {
796 psAesInstPri->u8PidIndex = pParserPidConfigurations->u8PidIndex;
797 psAesInstPri->u16Pid = pParserPidConfigurations->u16Pid;
798 psAesInstPri->bPid0En = TRUE;
799 }
800 else if (pParserPidConfigurations->u8PidIndex == 1)
801 {
802 psAesInstPri->u8PidIndex1 = pParserPidConfigurations->u8PidIndex;
803 psAesInstPri->u16Pid1 = pParserPidConfigurations->u16Pid;
804 psAesInstPri->bPid1En = TRUE;
805 }
806
807 return UTOPIA_STATUS_SUCCESS;
808 }
809
810 case MDrv_CMD_AESDMA_PARSER_ENCRYPT:
811 {
812 if (pArgs == NULL)
813 return UTOPIA_STATUS_FAIL;
814
815 pParserConfigurations = (PAESDMA_PARSER_CONFIGURATIONS)pArgs;
816 psAesInstPri->eParserMode = pParserConfigurations->eParserMode;
817 psAesInstPri->bParserDecrypt = FALSE;
818 psAesInstPri->bHwParserEn = TRUE;
819 return UTOPIA_STATUS_SUCCESS;
820 }
821
822 case MDrv_CMD_AESDMA_PARSER_DECRYPT:
823 {
824 if (pArgs == NULL)
825 return UTOPIA_STATUS_FAIL;
826
827 pParserConfigurations = (PAESDMA_PARSER_CONFIGURATIONS)pArgs;
828 psAesInstPri->eParserMode = pParserConfigurations->eParserMode;
829 psAesInstPri->bParserDecrypt = TRUE;
830 psAesInstPri->bHwParserEn = TRUE;
831 return UTOPIA_STATUS_SUCCESS;
832 }
833
834 case MDrv_CMD_AESDMA_PARSER_Start:
835 {
836 if(UtopiaResourceObtain(pModule, AESDMA_POOL_ID_AES, &pResource) != 0)
837 {
838 ULOGE(TAG_AESDMA, "UtopiaResourceObtainToInstant fail\n");
839 return UTOPIA_STATUS_ERR_NOT_AVAIL;
840 }
841
842 if(FALSE == MsOS_SHM_GetId((MS_U8*)"AESDMA driver", sizeof(AESDMA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_QUERY))
843 {
844 if(FALSE == MsOS_SHM_GetId((MS_U8*)"AESDMA driver", sizeof(AESDMA_RESOURCE_SHARED), &u32ShmId, &u32Addr, &u32BufSize, MSOS_SHM_CREATE))
845 {
846 ULOGE(TAG_AESDMA, "[AESDMA INFO]create Resouce shared memory fail\n");
847 return UTOPIA_STATUS_ERR_NOMEM;
848 }
849 memset( (MS_U8*)u32Addr, 0, sizeof(AESDMA_RESOURCE_SHARED));
850 }
851
852 psAesResourceShared = (AESDMA_RESOURCE_SHARED*)u32Addr;
853
854 psAesResourceShared->pAESResource = pResource;
855 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "\n[AESDMA INFO]pResource = %x\n",(MS_U32)psAesResourceShared->pAESResource));
856
857 if ((psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CTR)||
858 (psAesInstPri->eMode == E_DRVAESDMA_CIPHER_DES_CTR)||
859 (psAesInstPri->eMode == E_DRVAESDMA_CIPHER_TDES_CTR))
860 {
861 (psAesInstPri->fpAESDMANormalReset)();
862 }
863 else
864 {
865 //AESDMA reset
866 (psAesInstPri->fpAESDMAReset)();
867 }
868
869 if (psAesInstPri->bSetEng == TRUE)
870 {
871 //AESDMA set mode and select encrypt or decrypt
872 (psAesInstPri->fpAESDMASelEng)(psAesInstPri->eMode,psAesInstPri->bDescrypt);
873 psAesInstPri->bSetEng = FALSE;
874 }
875
876 //AESDMA set FileInOut info
877 (psAesInstPri->fpAESDMASetFileInOut)(psAesInstPri->u32FileinAddr,psAesInstPri->u32FileInNum,psAesInstPri->u32FileOutSAddr,psAesInstPri->u32FileOutEAddr);
878
879 //AESDMA set key
880 if(psAesInstPri->bEnableTwoKey==1)
881 {
882 u32KeyarryAddr = (MS_VIRT)&psAesInstPri->CipherOddKey[0];
883 (psAesInstPri->fpAESDMASetKeySel)((MS_U32*)u32KeyarryAddr, E_DRVAESDMA_ODD_KEY);
884
885 u32KeyarryAddr = (MS_VIRT)&psAesInstPri->CipherKey[0];
886 (psAesInstPri->fpAESDMASetKeySel)((MS_U32*)u32KeyarryAddr, E_DRVAESDMA_EVEN_KEY);
887 }
888 else
889 {
890 if(psAesInstPri->bSecretKey==1)
891 {
892 (psAesInstPri->fpAESDMASecureKeyIdx)(psAesInstPri->u8SecureKeyIndex);
893 }
894 else
895 {
896 u32KeyarryAddr = (MS_VIRT)&psAesInstPri->CipherKey[0];
897 (psAesInstPri->fpAESDMASetKey)((MS_U32*)u32KeyarryAddr);
898 }
899 }
900
901 //AESDMA set IV
902 if((psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CBC)||
903 (psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CTR)||
904 (psAesInstPri->eMode == E_DRVAESDMA_CIPHER_CTS_CBC))
905 {
906 u32IVarrayAddr = (MS_VIRT)&psAesInstPri->InitVector[0];
907 if (psAesInstPri->bSetIV == TRUE)
908 {
909 (psAesInstPri->fpAESDMASetIV)((MS_U32*)u32IVarrayAddr);
910 psAesInstPri->bSetIV = FALSE;
911 }
912
913 if(psAesInstPri->bEnableTwoKey==1)
914 {
915 u32IVarrayAddr = (MS_VIRT)&psAesInstPri->InitVectorOdd[0];
916 (psAesInstPri->fpAESDMASetOddIv)((MS_U32*)u32IVarrayAddr);
917 }
918
919 }
920
921 // HW Parser configurations
922 if (psAesInstPri->bHwParserEn == TRUE)
923 {
924 psAesInstPri->bHwParserEn = FALSE;
925 }
926 if (psAesInstPri->bParserDecrypt == TRUE)
927 {
928 (psAesInstPri->fpAESDMAParserDecrypt)(psAesInstPri->eParserMode);
929 }
930 else
931 {
932 (psAesInstPri->fpAESDMAParserEncrypt)(psAesInstPri->eParserMode);
933 }
934
935 if (psAesInstPri->bEvenScrmbPatternEn == TRUE)
936 {
937 psAesInstPri->bEvenScrmbPatternEn = FALSE;
938 (psAesInstPri->fpAESDMAParserSetScrmbPatten)(psAesInstPri->eScrmbPattern);
939 }
940
941 if (psAesInstPri->bOddScrmbPatternEn == TRUE)
942 {
943 psAesInstPri->bOddScrmbPatternEn = FALSE;
944 (psAesInstPri->fpAESDMAParserSetAddedScrmbPattern)(psAesInstPri->eAddedScrmbPattern);
945 }
946
947 (psAesInstPri->fpAESDMAParserMaskscrmb)(psAesInstPri->bMaskScrmb);
948
949 // Set PID
950 if (psAesInstPri->bBypassPid == TRUE)
951 {
952 psAesInstPri->bBypassPid = FALSE;
953 (psAesInstPri->fpAESDMAParserBypassPid)(psAesInstPri->bBypassPid);
954 }
955
956 if (psAesInstPri->bPid0En == TRUE)
957 {
958 psAesInstPri->bPid0En = FALSE;
959 (psAesInstPri->fpAESDMAParserSetPid)(psAesInstPri->u8PidIndex, psAesInstPri->u16Pid);
960 }
961 if (psAesInstPri->bPid1En == TRUE)
962 {
963 psAesInstPri->bPid1En = FALSE;
964 (psAesInstPri->fpAESDMAParserSetPid)(psAesInstPri->u8PidIndex1, psAesInstPri->u16Pid1);
965 }
966
967 // AESDMA trigger start
968 u32Ret = (psAesInstPri->fpAESDMAStart)(1);
969 MS_DEBUG_MSG(ULOGD(TAG_AESDMA, "[AESDMA INFO]MDrv_CMD_AESDMA_PARSER_Start\n"));
970 if (u32Ret == DRVAESDMA_OK)
971 return UTOPIA_STATUS_SUCCESS;
972 else
973 return UTOPIA_STATUS_FAIL;
974 }
975
976 case MDrv_CMD_AESDMA_SetOddKey:
977 {
978 if (pArgs == NULL)
979 return UTOPIA_STATUS_FAIL;
980
981 memcpy((void *)psAesInstPri->CipherOddKey,(void *)pArgs,16);
982 return UTOPIA_STATUS_SUCCESS;
983 }
984
985 case MDrv_CMD_AESDMA_ENABLE_Two_Key:
986 {
987 if (pArgs == NULL)
988 return UTOPIA_STATUS_FAIL;
989
990 bEnable = *(MS_BOOL *)pArgs;
991 psAesInstPri->bEnableTwoKey = bEnable;
992
993 return UTOPIA_STATUS_SUCCESS;
994 }
995
996 case MDrv_CMD_AESDMA_SetOddIV:
997 {
998 memcpy((void *)psAesInstPri->InitVectorOdd,(void *)pArgs,16);
999 return UTOPIA_STATUS_SUCCESS;
1000 }
1001
1002 case MDrv_CMD_IS_SECRETKEY_IN_NORMAL_BLANK:
1003 {
1004 if (pArgs == NULL)
1005 return UTOPIA_STATUS_FAIL;
1006
1007 if ( psAesInstPri->fpAESDMAIsSecretKeyInNormalBlank(pArgs) == DRVAESDMA_OK )
1008 {
1009 return UTOPIA_STATUS_SUCCESS;
1010 }
1011 else
1012 {
1013 return UTOPIA_STATUS_FAIL;
1014 }
1015 }
1016
1017
1018 case MDrv_CMD_HDCP_MDrv_PROCESSCIPHER:
1019 {
1020 if (pArgs == NULL)
1021 return UTOPIA_STATUS_FAIL;
1022
1023 psHDCPData = (HDCP_CIPHER *)pArgs;
1024
1025 if ( psAesInstPri->fpHDCPHDCPProcessCipher(psHDCPData->u8Idx, (void*)psHDCPData->pu8Riv, (void*)psHDCPData->pu8ContentKey) == DRVAESDMA_OK )
1026 {
1027 return UTOPIA_STATUS_SUCCESS;
1028 }
1029 else
1030 {
1031 return UTOPIA_STATUS_FAIL;
1032 }
1033 }
1034
1035 case MDrv_CMD_HDCP_GetHdcpCipherState:
1036 {
1037 if (pArgs == NULL)
1038 return UTOPIA_STATUS_FAIL;
1039
1040 psHDCPCipherState = (HDCP_CIPHER_STATE *)pArgs;
1041
1042 if ( psAesInstPri->fpGetHDCPCipherState(psHDCPCipherState->u8Idx, psHDCPCipherState->pu8State) == DRVAESDMA_OK )
1043 {
1044 return UTOPIA_STATUS_SUCCESS;
1045 }
1046 else
1047 {
1048 return UTOPIA_STATUS_FAIL;
1049 }
1050 }
1051
1052 case MDrv_CMD_AESDMA_Set_Key_Index:
1053 {
1054 if (pArgs == NULL)
1055 return UTOPIA_STATUS_FAIL;
1056
1057 psAESDMAKeyIndex = (AESDMA_KEY_INDEX *)pArgs;
1058
1059 if (psAESDMAKeyIndex-> bOddKeyEn == TRUE)
1060 {
1061 psAesInstPri->bEnableKeyIndexOddKey = TRUE;
1062 psAesInstPri->u32KeyIndexOdd = psAESDMAKeyIndex->u32KeyIndex;
1063 }
1064 else
1065 {
1066 psAesInstPri->bEnableKeyIndexEvenKey = TRUE;
1067 psAesInstPri->u32KeyIndexEven = psAESDMAKeyIndex->u32KeyIndex;
1068 }
1069
1070 return UTOPIA_STATUS_SUCCESS;
1071 }
1072
1073 case MDrv_CMD_AESDMA_Set_AES_CTR64_En:
1074 {
1075 if (pArgs == NULL)
1076 return UTOPIA_STATUS_FAIL;
1077
1078 bEnable = *(MS_BOOL *)pArgs;
1079 psAesInstPri->bEnableAesCtr64 = bEnable;
1080
1081 return UTOPIA_STATUS_SUCCESS;
1082 }
1083
1084 case MDrv_CMD_AESDMA_Set_Efuse_Key_Index:
1085 {
1086 if (pArgs == NULL)
1087 return UTOPIA_STATUS_FAIL;
1088
1089 psAesInstPri->bSecretKey = 1;
1090 psAesInstPri->u8SecureKeyIndex = *(MS_U8 *)pArgs;
1091
1092 return UTOPIA_STATUS_SUCCESS;
1093 }
1094 case MDrv_CMD_AESDMA_GetConfig:
1095 {
1096 if (psAesInstPri->u32miunum == 0){
1097 return UTOPIA_STATUS_FAIL;
1098 }
1099 pInitParam = (PAESDMA_INIT) pArgs;
1100
1101 pInitParam->u32miu0addr = psAesInstPri->u32miu0addr;
1102 pInitParam->u32miu1addr = psAesInstPri->u32miu1addr;
1103 pInitParam->u32miunum = psAesInstPri->u32miunum;
1104
1105 return UTOPIA_STATUS_SUCCESS;
1106 }
1107 default:
1108 break;
1109 };
1110
1111 return 0;
1112 }
1113
AESDMAClose(void * pInstance)1114 MS_U32 AESDMAClose(void* pInstance)
1115 {
1116 UtopiaInstanceDelete(pInstance);
1117
1118 return 0;
1119 }
1120
1121