Root/target/linux/generic/files/crypto/ocf/kirkwood/cesa/mvCesaTest.c

1/*******************************************************************************
2Copyright (C) Marvell International Ltd. and its affiliates
3
4This software file (the "File") is owned and distributed by Marvell
5International Ltd. and/or its affiliates ("Marvell") under the following
6alternative licensing terms. Once you have made an election to distribute the
7File under one of the following license alternatives, please (i) delete this
8introductory statement regarding license alternatives, (ii) delete the two
9license alternatives that you have not elected to use and (iii) preserve the
10Marvell copyright notice above.
11
12********************************************************************************
13Marvell Commercial License Option
14
15If you received this File from Marvell and you have entered into a commercial
16license agreement (a "Commercial License") with Marvell, the File is licensed
17to you under the terms of the applicable Commercial License.
18
19********************************************************************************
20Marvell GPL License Option
21
22If you received this File from Marvell, you may opt to use, redistribute and/or
23modify this File in accordance with the terms and conditions of the General
24Public License Version 2, June 1991 (the "GPL License"), a copy of which is
25available along with the File in the license.txt file or by writing to the Free
26Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
27on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
28
29THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
30WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
31DISCLAIMED. The GPL License provides additional details about this warranty
32disclaimer.
33********************************************************************************
34Marvell BSD License Option
35
36If you received this File from Marvell, you may opt to use, redistribute and/or
37modify this File under the following licensing terms.
38Redistribution and use in source and binary forms, with or without modification,
39are permitted provided that the following conditions are met:
40
41    * Redistributions of source code must retain the above copyright notice,
42        this list of conditions and the following disclaimer.
43
44    * Redistributions in binary form must reproduce the above copyright
45        notice, this list of conditions and the following disclaimer in the
46        documentation and/or other materials provided with the distribution.
47
48    * Neither the name of Marvell nor the names of its contributors may be
49        used to endorse or promote products derived from this software without
50        specific prior written permission.
51
52THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
53ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
54WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
55DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
56ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
57(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
58LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
59ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
60(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
61SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
62
63*******************************************************************************/
64
65#include "mvOs.h"
66
67#if defined(MV_VXWORKS)
68
69#include "sysLib.h"
70#include "logLib.h"
71#include "tickLib.h"
72#include "intLib.h"
73#include "config.h"
74
75
76SEM_ID cesaSemId = NULL;
77SEM_ID cesaWaitSemId = NULL;
78
79#define CESA_TEST_LOCK(flags) flags = intLock()
80#define CESA_TEST_UNLOCK(flags) intUnlock(flags)
81
82#define CESA_TEST_WAIT_INIT() cesaWaitSemId = semBCreate(SEM_Q_PRIORITY, SEM_EMPTY)
83#define CESA_TEST_WAKE_UP() semGive(cesaWaitSemId)
84#define CESA_TEST_WAIT(cond, ms) semTake(cesaWaitSemId, (sysClkRateGet()*ms)/1000)
85
86#define CESA_TEST_TICK_GET() tickGet()
87#define CESA_TEST_TICK_TO_MS(tick) (((tick)*1000)/sysClkRateGet())
88
89#elif defined(MV_LINUX)
90
91#include <linux/wait.h>
92wait_queue_head_t cesaTest_waitq;
93spinlock_t cesaLock;
94
95#define CESA_TEST_LOCK(flags) spin_lock_irqsave( &cesaLock, flags)
96#define CESA_TEST_UNLOCK(flags) spin_unlock_irqrestore( &cesaLock, flags);
97
98#define CESA_TEST_WAIT_INIT() init_waitqueue_head(&cesaTest_waitq)
99#define CESA_TEST_WAKE_UP() wake_up(&cesaTest_waitq)
100#define CESA_TEST_WAIT(cond, ms) wait_event_timeout(cesaTest_waitq, (cond), msecs_to_jiffies(ms))
101
102#define CESA_TEST_TICK_GET() jiffies
103#define CESA_TEST_TICK_TO_MS(tick) jiffies_to_msecs(tick)
104
105#elif defined(MV_NETBSD)
106
107#include <sys/param.h>
108#include <sys/kernel.h>
109static int cesaLock;
110
111#define CESA_TEST_LOCK(flags) flags = splnet()
112#define CESA_TEST_UNLOCK(flags) splx(flags)
113
114#define CESA_TEST_WAIT_INIT() /* nothing */
115#define CESA_TEST_WAKE_UP() wakeup(&cesaLock)
116#define CESA_TEST_WAIT(cond, ms) \
117do { \
118    while (!(cond)) \
119        tsleep(&cesaLock, PWAIT, "cesatest",mstohz(ms)); \
120} while (/*CONSTCOND*/0)
121
122#define CESA_TEST_TICK_GET() hardclock_ticks
123#define CESA_TEST_TICK_TO_MS(tick) ((1000/hz)*(tick))
124
125#define request_irq(i,h,t,n,a) \
126    !mv_intr_establish((i),IPL_NET,(int(*)(void *))(h),(a))
127
128#else
129#error "Only Linux, VxWorks, or NetBSD OS are supported"
130#endif
131
132#include "mvDebug.h"
133
134#include "mvSysHwConfig.h"
135#include "boardEnv/mvBoardEnvLib.h"
136#include "ctrlEnv/sys/mvCpuIf.h"
137#include "cntmr/mvCntmr.h"
138#include "cesa/mvCesa.h"
139#include "cesa/mvCesaRegs.h"
140#include "cesa/mvMD5.h"
141#include "cesa/mvSHA1.h"
142
143#if defined(CONFIG_MV646xx)
144#include "marvell_pic.h"
145#endif
146
147#define MV_CESA_USE_TIMER_ID 0
148#define CESA_DEF_BUF_SIZE 1500
149#define CESA_DEF_BUF_NUM 1
150#define CESA_DEF_SESSION_NUM 32
151
152#define CESA_DEF_ITER_NUM 100
153
154#define CESA_DEF_REQ_SIZE 256
155
156
157/* CESA Tests Debug */
158#undef CESA_TEST_DEBUG
159
160#ifdef CESA_TEST_DEBUG
161
162# define CESA_TEST_DEBUG_PRINT(msg) mvOsPrintf msg
163# define CESA_TEST_DEBUG_CODE(code) code
164
165typedef struct
166{
167    int type; /* 0 - isrEmpty, 1 - cesaReadyGet, 2 - cesaAction */
168    MV_U32 timeStamp;
169    MV_U32 cause;
170    MV_U32 realCause;
171    MV_U32 dmaCause;
172    int resources;
173    MV_CESA_REQ* pReqReady;
174    MV_CESA_REQ* pReqEmpty;
175    MV_CESA_REQ* pReqProcess;
176} MV_CESA_TEST_TRACE;
177
178#define MV_CESA_TEST_TRACE_SIZE 25
179
180static int cesaTestTraceIdx = 0;
181static MV_CESA_TEST_TRACE cesaTestTrace[MV_CESA_TEST_TRACE_SIZE];
182
183static void cesaTestTraceAdd(int type, MV_U32 cause)
184{
185    cesaTestTrace[cesaTestTraceIdx].type = type;
186    cesaTestTrace[cesaTestTraceIdx].cause = cause;
187    cesaTestTrace[cesaTestTraceIdx].realCause = MV_REG_READ(MV_CESA_ISR_CAUSE_REG);
188    cesaTestTrace[cesaTestTraceIdx].dmaCause = MV_REG_READ(IDMA_CAUSE_REG);
189    cesaTestTrace[cesaTestTraceIdx].resources = cesaReqResources;
190    cesaTestTrace[cesaTestTraceIdx].pReqReady = pCesaReqReady;
191    cesaTestTrace[cesaTestTraceIdx].pReqEmpty = pCesaReqEmpty;
192    cesaTestTrace[cesaTestTraceIdx].pReqProcess = pCesaReqProcess;
193    cesaTestTrace[cesaTestTraceIdx].timeStamp = mvCntmrRead(MV_CESA_USE_TIMER_ID);
194    cesaTestTraceIdx++;
195    if(cesaTestTraceIdx == MV_CESA_TEST_TRACE_SIZE)
196        cesaTestTraceIdx = 0;
197}
198
199#else
200
201# define CESA_TEST_DEBUG_PRINT(msg)
202# define CESA_TEST_DEBUG_CODE(code)
203
204#endif /* CESA_TEST_DEBUG */
205
206int cesaExpReqId=0;
207int cesaCbIter=0;
208
209int cesaIdx;
210int cesaIteration;
211int cesaRateSize;
212int cesaReqSize;
213unsigned long cesaTaskId;
214int cesaBufNum;
215int cesaBufSize;
216int cesaCheckOffset;
217int cesaCheckSize;
218int cesaCheckMode;
219int cesaTestIdx;
220int cesaCaseIdx;
221
222
223MV_U32 cesaTestIsrCount = 0;
224MV_U32 cesaTestIsrMissCount = 0;
225
226MV_U32 cesaCryptoError = 0;
227MV_U32 cesaReqIdError = 0;
228MV_U32 cesaError = 0;
229
230char* cesaHexBuffer = NULL;
231
232char* cesaBinBuffer = NULL;
233char* cesaExpBinBuffer = NULL;
234
235char* cesaInputHexStr = NULL;
236char* cesaOutputHexStr = NULL;
237
238MV_BUF_INFO cesaReqBufs[CESA_DEF_REQ_SIZE];
239
240MV_CESA_COMMAND* cesaCmdRing;
241MV_CESA_RESULT cesaResult;
242
243int cesaTestFull = 0;
244
245MV_BOOL cesaIsReady = MV_FALSE;
246MV_U32 cesaCycles = 0;
247MV_U32 cesaBeginTicks = 0;
248MV_U32 cesaEndTicks = 0;
249MV_U32 cesaRate = 0;
250MV_U32 cesaRateAfterDot = 0;
251
252void *cesaTestOSHandle = NULL;
253
254enum
255{
256    CESA_FAST_CHECK_MODE = 0,
257    CESA_FULL_CHECK_MODE,
258    CESA_NULL_CHECK_MODE,
259    CESA_SHOW_CHECK_MODE,
260    CESA_SW_SHOW_CHECK_MODE,
261    CESA_SW_NULL_CHECK_MODE,
262
263    CESA_MAX_CHECK_MODE
264};
265
266enum
267{
268    DES_TEST_TYPE = 0,
269    TRIPLE_DES_TEST_TYPE = 1,
270    AES_TEST_TYPE = 2,
271    MD5_TEST_TYPE = 3,
272    SHA_TEST_TYPE = 4,
273    COMBINED_TEST_TYPE = 5,
274
275    MAX_TEST_TYPE
276};
277
278/* Tests data base */
279typedef struct
280{
281    short sid;
282    char cryptoAlgorithm; /* DES/3DES/AES */
283    char cryptoMode; /* ECB or CBC */
284    char macAlgorithm; /* MD5 / SHA1 */
285    char operation; /* CRYPTO/HMAC/CRYPTO+HMAC/HMAC+CRYPTO */
286    char direction; /* ENCODE(SIGN)/DECODE(VERIFY) */
287    unsigned char* pCryptoKey;
288    int cryptoKeySize;
289    unsigned char* pMacKey;
290    int macKeySize;
291    const char* name;
292
293} MV_CESA_TEST_SESSION;
294
295typedef struct
296{
297    MV_CESA_TEST_SESSION* pSessions;
298    int numSessions;
299
300} MV_CESA_TEST_DB_ENTRY;
301
302typedef struct
303{
304    char* plainHexStr;
305    char* cipherHexStr;
306    unsigned char* pCryptoIV;
307    int cryptoLength;
308    int macLength;
309    int digestOffset;
310
311} MV_CESA_TEST_CASE;
312
313typedef struct
314{
315    int size;
316    const char* outputHexStr;
317
318} MV_CESA_SIZE_TEST;
319
320static unsigned char cryptoKey1[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
321                                        0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
322                                        0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef};
323
324static unsigned char cryptoKey7[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef};
325static unsigned char iv1[] = {0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef};
326
327
328static unsigned char cryptoKey2[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
329                                        0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F};
330
331static unsigned char cryptoKey3[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
332                                        0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
333                                        0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17};
334
335static unsigned char cryptoKey4[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
336                                        0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
337                                        0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
338                                        0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f};
339
340static unsigned char cryptoKey5[] = {0x56, 0xe4, 0x7a, 0x38, 0xc5, 0x59, 0x89, 0x74,
341                                        0xbc, 0x46, 0x90, 0x3d, 0xba, 0x29, 0x03, 0x49};
342
343
344static unsigned char key3des1[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
345                                        0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01,
346                                        0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF, 0x01, 0x23};
347
348/* Input ASCII string: The quick brown fox jump */
349static char plain3des1[] = "54686520717566636B2062726F776E20666F78206A756D70";
350static char cipher3des1[] = "A826FD8CE53B855FCCE21C8112256FE668D5C05DD9B6B900";
351
352static unsigned char key3des2[] = {0x62, 0x7f, 0x46, 0x0e, 0x08, 0x10, 0x4a, 0x10,
353                                       0x43, 0xcd, 0x26, 0x5d, 0x58, 0x40, 0xea, 0xf1,
354                                       0x31, 0x3e, 0xdf, 0x97, 0xdf, 0x2a, 0x8a, 0x8c};
355
356static unsigned char iv3des2[] = {0x8e, 0x29, 0xf7, 0x5e, 0xa7, 0x7e, 0x54, 0x75};
357
358static char plain3des2[] = "326a494cd33fe756";
359
360static char cipher3desCbc2[] = "8e29f75ea77e5475"
361                                      "b22b8d66de970692";
362
363static unsigned char key3des3[] = {0x37, 0xae, 0x5e, 0xbf, 0x46, 0xdf, 0xf2, 0xdc,
364                                       0x07, 0x54, 0xb9, 0x4f, 0x31, 0xcb, 0xb3, 0x85,
365                                       0x5e, 0x7f, 0xd3, 0x6d, 0xc8, 0x70, 0xbf, 0xae};
366
367static unsigned char iv3des3[] = {0x3d, 0x1d, 0xe3, 0xcc, 0x13, 0x2e, 0x3b, 0x65};
368
369static char plain3des3[] = "84401f78fe6c10876d8ea23094ea5309";
370
371static char cipher3desCbc3[] = "3d1de3cc132e3b65"
372                                      "7b1f7c7e3b1c948ebd04a75ffba7d2f5";
373
374static unsigned char iv5[] = {0x8c, 0xe8, 0x2e, 0xef, 0xbe, 0xa0, 0xda, 0x3c,
375                                        0x44, 0x69, 0x9e, 0xd7, 0xdb, 0x51, 0xb7, 0xd9};
376
377static unsigned char aesCtrKey[] = {0x76, 0x91, 0xBE, 0x03, 0x5E, 0x50, 0x20, 0xA8,
378                                        0xAC, 0x6E, 0x61, 0x85, 0x29, 0xF9, 0xA0, 0xDC};
379
380static unsigned char mdKey1[] = {0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
381                                        0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b};
382
383static unsigned char mdKey2[] = {0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
384                                        0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa};
385
386static unsigned char shaKey1[] = {0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
387                                        0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
388                                        0x0b, 0x0b, 0x0b, 0x0b};
389
390static unsigned char shaKey2[] = {0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
391                                        0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
392                                        0xaa, 0xaa, 0xaa, 0xaa};
393
394static unsigned char mdKey4[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
395                                        0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};
396
397static unsigned char shaKey4[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
398                                        0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
399                                        0x11, 0x12, 0x13, 0x14};
400
401
402static MV_CESA_TEST_SESSION desTestSessions[] =
403{
404/*000*/ {-1, MV_CESA_CRYPTO_DES, MV_CESA_CRYPTO_ECB,
405             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
406             MV_CESA_DIR_ENCODE,
407             cryptoKey7, sizeof(cryptoKey7)/sizeof(cryptoKey7[0]),
408             NULL, 0,
409             "DES ECB encode",
410        },
411/*001*/ {-1, MV_CESA_CRYPTO_DES, MV_CESA_CRYPTO_ECB,
412             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
413             MV_CESA_DIR_DECODE,
414             cryptoKey7, sizeof(cryptoKey7)/sizeof(cryptoKey7[0]),
415             NULL, 0,
416             "DES ECB decode",
417        },
418/*002*/ {-1, MV_CESA_CRYPTO_DES, MV_CESA_CRYPTO_CBC,
419             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
420             MV_CESA_DIR_ENCODE,
421             cryptoKey7, sizeof(cryptoKey7)/sizeof(cryptoKey7[0]),
422             NULL, 0,
423             "DES CBC encode"
424        },
425/*003*/ {-1, MV_CESA_CRYPTO_DES, MV_CESA_CRYPTO_CBC,
426             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
427             MV_CESA_DIR_DECODE,
428             cryptoKey7, sizeof(cryptoKey7)/sizeof(cryptoKey7[0]),
429             NULL, 0,
430             "DES CBC decode"
431        },
432/*004*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
433             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
434             MV_CESA_DIR_ENCODE,
435             NULL, 0, NULL, 0,
436              "NULL Crypto Algorithm encode"
437        },
438};
439
440
441static MV_CESA_TEST_SESSION tripleDesTestSessions[] =
442{
443/*100*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_ECB,
444             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
445             MV_CESA_DIR_ENCODE,
446             cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
447             NULL, 0,
448             "3DES ECB encode",
449        },
450/*101*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_ECB,
451             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
452             MV_CESA_DIR_DECODE,
453             cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
454             NULL, 0,
455             "3DES ECB decode",
456        },
457/*102*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_CBC,
458             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
459             MV_CESA_DIR_ENCODE,
460             cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
461             NULL, 0,
462             "3DES CBC encode"
463        },
464/*103*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_CBC,
465             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
466             MV_CESA_DIR_DECODE,
467             cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
468             NULL, 0,
469             "3DES CBC decode"
470        },
471/*104*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_ECB,
472             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
473             MV_CESA_DIR_ENCODE,
474             key3des1, sizeof(key3des1),
475             NULL, 0,
476             "3DES ECB encode"
477        },
478/*105*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_CBC,
479             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
480             MV_CESA_DIR_ENCODE,
481             key3des2, sizeof(key3des2),
482             NULL, 0,
483             "3DES ECB encode"
484        },
485/*106*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_CBC,
486             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
487             MV_CESA_DIR_ENCODE,
488             key3des3, sizeof(key3des3),
489             NULL, 0,
490             "3DES ECB encode"
491        },
492};
493
494
495static MV_CESA_TEST_SESSION aesTestSessions[] =
496{
497/*200*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_ECB,
498             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
499             MV_CESA_DIR_ENCODE,
500             cryptoKey2, sizeof(cryptoKey2)/sizeof(cryptoKey2[0]),
501             NULL, 0,
502             "AES-128 ECB encode"
503        },
504/*201*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_ECB,
505             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
506             MV_CESA_DIR_DECODE,
507             cryptoKey2, sizeof(cryptoKey2)/sizeof(cryptoKey2[0]),
508             NULL, 0,
509             "AES-128 ECB decode"
510        },
511/*202*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_CBC,
512             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
513             MV_CESA_DIR_ENCODE,
514             cryptoKey5, sizeof(cryptoKey5)/sizeof(cryptoKey5[0]),
515             NULL, 0,
516             "AES-128 CBC encode"
517        },
518/*203*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_CBC,
519             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
520             MV_CESA_DIR_DECODE,
521             cryptoKey5, sizeof(cryptoKey5)/sizeof(cryptoKey5[0]),
522             NULL, 0,
523             "AES-128 CBC decode"
524        },
525/*204*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_ECB,
526             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
527             MV_CESA_DIR_ENCODE,
528             cryptoKey3, sizeof(cryptoKey3)/sizeof(cryptoKey3[0]),
529             NULL, 0,
530             "AES-192 ECB encode"
531        },
532/*205*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_ECB,
533             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
534             MV_CESA_DIR_DECODE,
535             cryptoKey3, sizeof(cryptoKey3)/sizeof(cryptoKey3[0]),
536             NULL, 0,
537             "AES-192 ECB decode"
538        },
539/*206*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_ECB,
540             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
541             MV_CESA_DIR_ENCODE,
542             cryptoKey4, sizeof(cryptoKey4)/sizeof(cryptoKey4[0]),
543             NULL, 0,
544             "AES-256 ECB encode"
545        },
546/*207*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_ECB,
547             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
548             MV_CESA_DIR_DECODE,
549             cryptoKey4, sizeof(cryptoKey4)/sizeof(cryptoKey4[0]),
550             NULL, 0,
551             "AES-256 ECB decode"
552        },
553/*208*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_CTR,
554             MV_CESA_MAC_NULL, MV_CESA_CRYPTO_ONLY,
555             MV_CESA_DIR_ENCODE,
556             aesCtrKey, sizeof(aesCtrKey)/sizeof(aesCtrKey[0]),
557             NULL, 0,
558             "AES-128 CTR encode"
559        },
560};
561
562
563static MV_CESA_TEST_SESSION md5TestSessions[] =
564{
565/*300*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
566             MV_CESA_MAC_HMAC_MD5, MV_CESA_MAC_ONLY,
567             MV_CESA_DIR_ENCODE,
568             NULL, 0,
569             mdKey1, sizeof(mdKey1),
570             "HMAC-MD5 Generate Signature"
571        },
572/*301*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
573             MV_CESA_MAC_HMAC_MD5, MV_CESA_MAC_ONLY,
574             MV_CESA_DIR_DECODE,
575             NULL, 0,
576             mdKey1, sizeof(mdKey1),
577             "HMAC-MD5 Verify Signature"
578        },
579/*302*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
580             MV_CESA_MAC_HMAC_MD5, MV_CESA_MAC_ONLY,
581             MV_CESA_DIR_ENCODE,
582             NULL, 0,
583             mdKey2, sizeof(mdKey2),
584             "HMAC-MD5 Generate Signature"
585        },
586/*303*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
587             MV_CESA_MAC_HMAC_MD5, MV_CESA_MAC_ONLY,
588             MV_CESA_DIR_DECODE,
589             NULL, 0,
590             mdKey2, sizeof(mdKey2),
591             "HMAC-MD5 Verify Signature"
592        },
593/*304*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
594             MV_CESA_MAC_HMAC_MD5, MV_CESA_MAC_ONLY,
595             MV_CESA_DIR_ENCODE,
596             NULL, 0,
597             mdKey4, sizeof(mdKey4),
598             "HMAC-MD5 Generate Signature"
599        },
600/*305*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
601             MV_CESA_MAC_MD5, MV_CESA_MAC_ONLY,
602             MV_CESA_DIR_ENCODE,
603             NULL, 0,
604             NULL, 0,
605             "HASH-MD5 Generate Signature"
606        },
607};
608
609
610static MV_CESA_TEST_SESSION shaTestSessions[] =
611{
612/*400*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
613             MV_CESA_MAC_HMAC_SHA1, MV_CESA_MAC_ONLY,
614             MV_CESA_DIR_ENCODE,
615             NULL, 0,
616             shaKey1, sizeof(shaKey1),
617             "HMAC-SHA1 Generate Signature"
618        },
619/*401*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
620             MV_CESA_MAC_HMAC_SHA1, MV_CESA_MAC_ONLY,
621             MV_CESA_DIR_DECODE,
622             NULL, 0,
623             shaKey1, sizeof(shaKey1),
624             "HMAC-SHA1 Verify Signature"
625        },
626/*402*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
627             MV_CESA_MAC_HMAC_SHA1, MV_CESA_MAC_ONLY,
628             MV_CESA_DIR_ENCODE,
629             NULL, 0,
630             shaKey2, sizeof(shaKey2),
631             "HMAC-SHA1 Generate Signature"
632        },
633/*403*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
634             MV_CESA_MAC_HMAC_SHA1, MV_CESA_MAC_ONLY,
635             MV_CESA_DIR_DECODE,
636             NULL, 0,
637             shaKey2, sizeof(shaKey2),
638             "HMAC-SHA1 Verify Signature"
639        },
640/*404*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
641             MV_CESA_MAC_HMAC_SHA1, MV_CESA_MAC_ONLY,
642             MV_CESA_DIR_ENCODE,
643             NULL, 0,
644             shaKey4, sizeof(shaKey4),
645             "HMAC-SHA1 Generate Signature"
646        },
647/*405*/ {-1, MV_CESA_CRYPTO_NULL, MV_CESA_CRYPTO_ECB,
648             MV_CESA_MAC_SHA1, MV_CESA_MAC_ONLY,
649             MV_CESA_DIR_ENCODE,
650             NULL, 0,
651             NULL, 0,
652             "HASH-SHA1 Generate Signature"
653        },
654};
655
656static MV_CESA_TEST_SESSION combinedTestSessions[] =
657{
658/*500*/ {-1, MV_CESA_CRYPTO_DES, MV_CESA_CRYPTO_ECB,
659             MV_CESA_MAC_HMAC_MD5, MV_CESA_CRYPTO_THEN_MAC,
660             MV_CESA_DIR_ENCODE,
661             cryptoKey1, MV_CESA_DES_KEY_LENGTH,
662             mdKey4, sizeof(mdKey4),
663             "DES + MD5 encode"
664        },
665/*501*/ {-1, MV_CESA_CRYPTO_DES, MV_CESA_CRYPTO_ECB,
666             MV_CESA_MAC_HMAC_SHA1, MV_CESA_CRYPTO_THEN_MAC,
667             MV_CESA_DIR_ENCODE,
668             cryptoKey1, MV_CESA_DES_KEY_LENGTH,
669             shaKey4, sizeof(shaKey4),
670             "DES + SHA1 encode"
671        },
672/*502*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_ECB,
673             MV_CESA_MAC_HMAC_MD5, MV_CESA_CRYPTO_THEN_MAC,
674             MV_CESA_DIR_ENCODE,
675             cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
676             mdKey4, sizeof(mdKey4),
677             "3DES + MD5 encode"
678        },
679/*503*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_ECB,
680             MV_CESA_MAC_HMAC_SHA1, MV_CESA_CRYPTO_THEN_MAC,
681             MV_CESA_DIR_ENCODE,
682             cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
683             shaKey4, sizeof(shaKey4),
684             "3DES + SHA1 encode"
685        },
686/*504*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_CBC,
687             MV_CESA_MAC_HMAC_MD5, MV_CESA_CRYPTO_THEN_MAC,
688             MV_CESA_DIR_ENCODE,
689             cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
690             mdKey4, sizeof(mdKey4),
691             "3DES CBC + MD5 encode"
692        },
693/*505*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_CBC,
694             MV_CESA_MAC_HMAC_SHA1, MV_CESA_CRYPTO_THEN_MAC,
695             MV_CESA_DIR_ENCODE,
696             cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
697             shaKey4, sizeof(shaKey4),
698             "3DES CBC + SHA1 encode"
699        },
700/*506*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_CBC,
701             MV_CESA_MAC_HMAC_MD5, MV_CESA_CRYPTO_THEN_MAC,
702             MV_CESA_DIR_ENCODE,
703             cryptoKey5, sizeof(cryptoKey5)/sizeof(cryptoKey5[0]),
704             mdKey4, sizeof(mdKey4),
705             "AES-128 CBC + MD5 encode"
706        },
707/*507*/ {-1, MV_CESA_CRYPTO_AES, MV_CESA_CRYPTO_CBC,
708             MV_CESA_MAC_HMAC_SHA1, MV_CESA_CRYPTO_THEN_MAC,
709             MV_CESA_DIR_ENCODE,
710             cryptoKey5, sizeof(cryptoKey5)/sizeof(cryptoKey5[0]),
711             shaKey4, sizeof(shaKey4),
712             "AES-128 CBC + SHA1 encode"
713        },
714/*508*/ {-1, MV_CESA_CRYPTO_3DES, MV_CESA_CRYPTO_ECB,
715             MV_CESA_MAC_HMAC_MD5, MV_CESA_MAC_THEN_CRYPTO,
716             MV_CESA_DIR_DECODE,
717             cryptoKey1, sizeof(cryptoKey1)/sizeof(cryptoKey1[0]),
718             mdKey4, sizeof(mdKey4),
719             "HMAC-MD5 + 3DES decode"
720        },
721};
722
723
724static MV_CESA_TEST_DB_ENTRY cesaTestsDB[MAX_TEST_TYPE+1] =
725{
726    { desTestSessions, sizeof(desTestSessions)/sizeof(desTestSessions[0]) },
727    { tripleDesTestSessions, sizeof(tripleDesTestSessions)/sizeof(tripleDesTestSessions[0]) },
728    { aesTestSessions, sizeof(aesTestSessions)/sizeof(aesTestSessions[0]) },
729    { md5TestSessions, sizeof(md5TestSessions)/sizeof(md5TestSessions[0]) },
730    { shaTestSessions, sizeof(shaTestSessions)/sizeof(shaTestSessions[0]) },
731    { combinedTestSessions, sizeof(combinedTestSessions)/sizeof(combinedTestSessions[0]) },
732    { NULL, 0 }
733};
734
735
736char cesaNullPlainHexText[] = "000000000000000000000000000000000000000000000000";
737
738char cesaPlainAsciiText[] = "Now is the time for all ";
739char cesaPlainHexEbc[] = "4e6f77206973207468652074696d6520666f7220616c6c20";
740char cesaCipherHexEcb[] = "3fa40e8a984d48156a271787ab8883f9893d51ec4b563b53";
741char cesaPlainHexCbc[] = "1234567890abcdef4e6f77206973207468652074696d6520666f7220616c6c20";
742char cesaCipherHexCbc[] = "1234567890abcdefe5c7cdde872bf27c43e934008c389c0f683788499a7c05f6";
743
744char cesaAesPlainHexEcb[] = "000102030405060708090a0b0c0d0e0f";
745char cesaAes128cipherHexEcb[] = "0a940bb5416ef045f1c39458c653ea5a";
746char cesaAes192cipherHexEcb[] = "0060bffe46834bb8da5cf9a61ff220ae";
747char cesaAes256cipherHexEcb[] = "5a6e045708fb7196f02e553d02c3a692";
748
749char cesaAsciiStr1[] = "Hi There";
750char cesaDataHexStr1[] = "4869205468657265";
751char cesaHmacMd5digestHex1[] = "9294727a3638bb1c13f48ef8158bfc9d";
752char cesaHmacSha1digestHex1[] = "b617318655057264e28bc0b6fb378c8ef146be00";
753char cesaDataAndMd5digest1[] = "48692054686572659294727a3638bb1c13f48ef8158bfc9d";
754char cesaDataAndSha1digest1[] = "4869205468657265b617318655057264e28bc0b6fb378c8ef146be00";
755
756char cesaAesPlainText[] = "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
757                                 "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
758                                 "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
759                                 "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf";
760
761char cesaAes128CipherCbc[] = "c30e32ffedc0774e6aff6af0869f71aa"
762                                 "0f3af07a9a31a9c684db207eb0ef8e4e"
763                                 "35907aa632c3ffdf868bb7b29d3d46ad"
764                                 "83ce9f9a102ee99d49a53e87f4c3da55";
765
766char cesaAesIvPlainText[] = "8ce82eefbea0da3c44699ed7db51b7d9"
767                                 "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
768                                 "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
769                                 "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
770                                 "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf";
771
772char cesaAes128IvCipherCbc[] = "8ce82eefbea0da3c44699ed7db51b7d9"
773                                 "c30e32ffedc0774e6aff6af0869f71aa"
774                                 "0f3af07a9a31a9c684db207eb0ef8e4e"
775                                 "35907aa632c3ffdf868bb7b29d3d46ad"
776                                 "83ce9f9a102ee99d49a53e87f4c3da55";
777
778char cesaAesCtrPlain[] = "00E0017B27777F3F4A1786F000000001"
779                                 "000102030405060708090A0B0C0D0E0F"
780                                 "101112131415161718191A1B1C1D1E1F"
781                                 "20212223";
782
783char cesaAesCtrCipher[] = "00E0017B27777F3F4A1786F000000001"
784                                 "C1CF48A89F2FFDD9CF4652E9EFDB72D7"
785                                 "4540A42BDE6D7836D59A5CEAAEF31053"
786                                 "25B2072F";
787
788
789
790/* Input cesaHmacHex3 is '0xdd' repeated 50 times */
791char cesaHmacMd5digestHex3[] = "56be34521d144c88dbb8c733f0e8b3f6";
792char cesaHmacSha1digestHex3[] = "125d7342b9ac11cd91a39af48aa17b4f63f175d3";
793char cesaDataHexStr3[50*2+1] = "";
794char cesaDataAndMd5digest3[sizeof(cesaDataHexStr3)+sizeof(cesaHmacMd5digestHex3)+8*2+1] = "";
795char cesaDataAndSha1digest3[sizeof(cesaDataHexStr3)+sizeof(cesaHmacSha1digestHex3)+8*2+1] = "";
796
797/* Ascii string is "abc" */
798char hashHexStr3[] = "616263";
799char hashMd5digest3[] = "900150983cd24fb0d6963f7d28e17f72";
800char hashSha1digest3[] = "a9993e364706816aba3e25717850c26c9cd0d89d";
801
802char hashHexStr80[] = "31323334353637383930"
803                          "31323334353637383930"
804                          "31323334353637383930"
805                          "31323334353637383930"
806                          "31323334353637383930"
807                          "31323334353637383930"
808                          "31323334353637383930"
809                          "31323334353637383930";
810
811char hashMd5digest80[] = "57edf4a22be3c955ac49da2e2107b67a";
812
813char tripleDesThenMd5digest80[] = "b7726a03aad490bd6c5a452a89a1b271";
814char tripleDesThenSha1digest80[] = "b2ddeaca91030eab5b95a234ef2c0f6e738ff883";
815
816char cbc3desThenMd5digest80[] = "6f463057e1a90e0e91ae505b527bcec0";
817char cbc3desThenSha1digest80[] = "1b002ed050be743aa98860cf35659646bb8efcc0";
818
819char cbcAes128ThenMd5digest80[] = "6b6e863ac5a71d15e3e9b1c86c9ba05f";
820char cbcAes128ThenSha1digest80[] = "13558472d1fc1c90dffec6e5136c7203452d509b";
821
822
823static MV_CESA_TEST_CASE cesaTestCases[] =
824{
825 /* plainHexStr cipherHexStr IV crypto mac digest */
826 /* Length Length Offset */
827 /*0*/ { NULL, NULL, NULL, 0, 0, -1 },
828 /*1*/ { cesaPlainHexEbc, cesaCipherHexEcb, NULL, 24, 0, -1 },
829 /*2*/ { cesaPlainHexCbc, cesaCipherHexCbc, NULL, 24, 0, -1 },
830 /*3*/ { cesaAesPlainHexEcb, cesaAes128cipherHexEcb, NULL, 16, 0, -1 },
831 /*4*/ { cesaAesPlainHexEcb, cesaAes192cipherHexEcb, NULL, 16, 0, -1 },
832 /*5*/ { cesaAesPlainHexEcb, cesaAes256cipherHexEcb, NULL, 16, 0, -1 },
833 /*6*/ { cesaDataHexStr1, cesaHmacMd5digestHex1, NULL, 0, 8, -1 },
834 /*7*/ { NULL, cesaDataAndMd5digest1, NULL, 0, 8, -1 },
835 /*8*/ { cesaDataHexStr3, cesaHmacMd5digestHex3, NULL, 0, 50, -1 },
836 /*9*/ { NULL, cesaDataAndMd5digest3, NULL, 0, 50, -1 },
837/*10*/ { cesaAesPlainText, cesaAes128IvCipherCbc, iv5, 64, 0, -1 },
838/*11*/ { cesaDataHexStr1, cesaHmacSha1digestHex1, NULL, 0, 8, -1 },
839/*12*/ { NULL, cesaDataAndSha1digest1, NULL, 0, 8, -1 },
840/*13*/ { cesaDataHexStr3, cesaHmacSha1digestHex3, NULL, 0, 50, -1 },
841/*14*/ { NULL, cesaDataAndSha1digest3, NULL, 0, 50, -1 },
842/*15*/ { hashHexStr3, hashMd5digest3, NULL, 0, 3, -1 },
843/*16*/ { hashHexStr3, hashSha1digest3, NULL, 0, 3, -1 },
844/*17*/ { hashHexStr80, tripleDesThenMd5digest80, NULL, 80, 80, -1 },
845/*18*/ { hashHexStr80, tripleDesThenSha1digest80, NULL, 80, 80, -1 },
846/*19*/ { hashHexStr80, cbc3desThenMd5digest80, iv1, 80, 80, -1 },
847/*20*/ { hashHexStr80, cbc3desThenSha1digest80, iv1, 80, 80, -1 },
848/*21*/ { hashHexStr80, cbcAes128ThenMd5digest80, iv5, 80, 80, -1 },
849/*22*/ { hashHexStr80, cbcAes128ThenSha1digest80, iv5, 80, 80, -1 },
850/*23*/ { cesaAesCtrPlain, cesaAesCtrCipher, NULL, 36, 0, -1 },
851/*24*/ { cesaAesIvPlainText, cesaAes128IvCipherCbc, NULL, 64, 0, -1 },
852/*25*/ { plain3des1, cipher3des1, NULL, 0, 0, -1 },
853/*26*/ { plain3des2, cipher3desCbc2, iv3des2,0, 0, -1 },
854/*27*/ { plain3des3, cipher3desCbc3, iv3des3,0, 0, -1 },
855};
856
857
858/* Key = 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
859 * 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa
860 * Input 0xdd repeated "size" times
861 */
862static MV_CESA_SIZE_TEST mdMultiSizeTest302[] =
863{
864    { 80, "7a031a640c14a4872814930b1ef3a5b2" },
865    { 512, "5488e6c5a14dc72a79f28312ca5b939b" },
866    { 1000, "d00814f586a8b78a05724239d2531821" },
867    { 1001, "bf07df7b7f49d3f5b5ecacd4e9e63281" },
868    { 1002, "1ed4a1a802e87817a819d4e37bb4d0f7" },
869    { 1003, "5972ab64a4f265ee371dac2f2f137f90" },
870    { 1004, "71f95e7ec3aa7df2548e90898abdb28e" },
871    { 1005, "e082790b4857fcfc266e92e59e608814" },
872    { 1006, "9500f02fd8ac7fde8b10e4fece9a920d" },
873    { 1336, "e42edcce57d0b75b01aa09d71427948b" },
874    { 1344, "bb5454ada0deb49ba0a97ffd60f57071" },
875    { 1399, "0f44d793e744b24d53f44f295082ee8c" },
876    { 1400, "359de8a03a9b707928c6c60e0e8d79f1" },
877    { 1401, "e913858b484cbe2b384099ea88d8855b" },
878    { 1402, "d9848a164af53620e0540c1d7d87629e" },
879    { 1403, "0c9ee1c2c9ef45e9b625c26cbaf3e822" },
880    { 1404, "12edd4f609416e3c936170360561b064" },
881    { 1405, "7fc912718a05446395345009132bf562" },
882    { 1406, "882f17425e579ff0d85a91a59f308aa0" },
883    { 1407, "005cae408630a2fb5db82ad9db7e59da" },
884    { 1408, "64655f8b404b3fea7a3e3e609bc5088f" },
885    { 1409, "4a145284a7f74e01b6bb1a0ec6a0dd80" },
886    { 2048, "67caf64475650732def374ebb8bde3fd" },
887    { 2049, "6c84f11f472825f7e6cd125c2981884b" },
888    { 2050, "8999586754a73a99efbe4dbad2816d41" },
889    { 2051, "ba6946b610e098d286bc81091659dfff" },
890    { 2052, "d0afa01c92d4d13def2b024f36faed83" },
891    { 3072, "61d8beac61806afa2585d74a9a0e6974" },
892    { 3074, "f6501a28dcc24d1e4770505c51a87ed3" },
893    { 3075, "ea4a6929be67e33e61ff475369248b73" },
894    { 4048, "aa8c4d68f282a07e7385acdfa69f4bed" },
895    { 4052, "afb5ed2c0e1d430ea59e59ed5ed6b18a" },
896    { 4058, "9e8553f9bdd43aebe0bd729f0e600c99" },
897    { 6144, "f628f3e5d183fe5cdd3a5abee39cf872" },
898    { 6150, "89a3efcea9a2f25f919168ad4a1fd292" },
899    { 6400, "cdd176b7fb747873efa4da5e32bdf88f" },
900    { 6528, "b1d707b027354aca152c45ee559ccd3f" },
901    { 8192, "c600ea4429ac47f9941f09182166e51a" },
902    {16384, "16e8754bfbeb4c649218422792267a37" },
903    {18432, "0fd0607521b0aa8b52219cfbe215f63e" },
904    { 0, NULL },
905};
906
907/* Key = 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
908 * 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
909 * InputHexStr = "31323334353637383930" (ASCII = "1234567890")
910 */
911static MV_CESA_SIZE_TEST mdMultiSizeTest304[] =
912{
913    { 80, "a456c4723fee6068530af5a2afa71627" },
914    { 512, "f85c2a2344f5de68b432208ad13e5794" },
915    { 1000, "35464d6821fd4a293a41eb84e274c8c5" },
916    { 1001, "c08eedbdce60cceb54bc2d732bb32c8b" },
917    { 1002, "5664f71800c011cc311cb6943339c1b8" },
918    { 1003, "779c723b044c585dc7802b13e8501bdc" },
919    { 1004, "55e500766a2c307bc5c5fdd15e4cacd4" },
920    { 1005, "d5f978954f5c38529d1679d2b714f068" },
921    { 1006, "cd3efc827ce628b7281b72172693abf9" },
922    { 1336, "6f04479910785878ae6335b8d1e87edf" },
923    { 1344, "b6d27b50c2bce1ba2a8e1b5cc4324368" },
924    { 1399, "65f70a1d4c86e5eaeb0704c8a7816795" },
925    { 1400, "3394b5adc4cb3ff98843ca260a44a88a" },
926    { 1401, "3a06f3582033a66a4e57e0603ce94e74" },
927    { 1402, "e4d97f5ed51edc48abfa46eeb5c31752" },
928    { 1403, "3d05e40b080ee3bedf293cb87b7140e7" },
929    { 1404, "8cf294fc3cd153ab18dccb2a52cbf244" },
930    { 1405, "d1487bd42f6edd9b4dab316631159221" },
931    { 1406, "0527123b6bf6936cf5d369dc18c6c70f" },
932    { 1407, "3224a06639db70212a0cd1ae1fcc570a" },
933    { 1408, "a9e13335612c0356f5e2c27086e86c43" },
934    { 1409, "a86d1f37d1ed8a3552e9a4f04dceea98" },
935    { 2048, "396905c9b961cd0f6152abfb69c4449c" },
936    { 2049, "49f39bff85d9dcf059fadb89efc4a70f" },
937    { 2050, "3a2b4823bc4d0415656550226a63e34a" },
938    { 2051, "dec60580d406c782540f398ad0bcc7e0" },
939    { 2052, "32f76610a14310309eb748fe025081bf" },
940    { 3072, "45edc1a42bf9d708a621076b63b774da" },
941    { 3074, "9be1b333fe7c0c9f835fb369dc45f778" },
942    { 3075, "8c06fcac7bd0e7b7a17fd6508c09a549" },
943    { 4048, "0ddaef848184bf0ad98507a10f1e90e4" },
944    { 4052, "81976bcaeb274223983996c137875cb8" },
945    { 4058, "0b0a7a1c82bc7cbc64d8b7cd2dc2bb22" },
946    { 6144, "1c24056f52725ede2dff0d7f9fc9855f" },
947    { 6150, "b7f4b65681c4e43ee68ca466ca9ca4ec" },
948    { 6400, "443bbaab9f7331ddd4bf11b659cd43c8" },
949    { 6528, "216f44f23047cfee03a7a64f88f9a995" },
950    { 8192, "ac7a993b2cad54879dba1bde63e39097" },
951    { 8320, "55ed7be9682d6c0025b3221a62088d08" },
952    {16384, "c6c722087653b62007aea668277175e5" },
953    {18432, "f1faca8e907872c809e14ffbd85792d6" },
954    { 0, NULL },
955};
956
957/* HASH-MD5
958 * InputHexStr = "31323334353637383930" (ASCII = "1234567890")
959 * repeated "size" times
960 */
961static MV_CESA_SIZE_TEST mdMultiSizeTest305[] =
962{
963    { 80, "57edf4a22be3c955ac49da2e2107b67a" },
964    { 512, "c729ae8f0736cc377a9767a660eaa04e" },
965    { 1000, "f1257a8659eb92d36fe14c6bf3852a6a" },
966    { 1001, "f8a46fe8ea04fdc8c7de0e84042d3878" },
967    { 1002, "da188dd67bff87d58aa3c02af2d0cc0f" },
968    { 1003, "961753017feee04c9b93a8e51658a829" },
969    { 1004, "dd68c4338608dcc87807a711636bf2af" },
970    { 1005, "e338d567d3ce66bf69ada29658a8759b" },
971    { 1006, "443c9811e8b92599b0b149e8d7ec700a" },
972    { 1336, "89a98511706008ba4cbd0b4a24fa5646" },
973    { 1344, "335a919805f370b9e402a62c6fe01739" },
974    { 1399, "5d18d0eddcd84212fe28d812b5e80e3b" },
975    { 1400, "6b695c240d2dffd0dffc99459ca76db6" },
976    { 1401, "49590f61298a76719bc93a57a30136f5" },
977    { 1402, "94c2999fa3ef1910a683d69b2b8476f2" },
978    { 1403, "37073a02ab00ecba2645c57c228860db" },
979    { 1404, "1bcd06994fce28b624f0c5fdc2dcdd2b" },
980    { 1405, "11b93671a64c95079e8cf9e7cddc8b3d" },
981    { 1406, "4b6695772a4c66313fa4871017d05f36" },
982    { 1407, "d1539b97fbfda1c075624e958de19c5b" },
983    { 1408, "b801b9b69920907cd018e8063092ede9" },
984    { 1409, "b765f1406cfe78e238273ed01bbcaf7e" },
985    { 2048, "1d7e2c64ac29e2b3fb4c272844ed31f5" },
986    { 2049, "71d38fac49c6b1f4478d8d88447bcdd0" },
987    { 2050, "141c34a5592b1bebfa731e0b23d0cdba" },
988    { 2051, "c5e1853f21c59f5d6039bd13d4b380d8" },
989    { 2052, "dd44a0d128b63d4b5cccd967906472d7" },
990    { 3072, "37d158e33b21390822739d13db7b87fe" },
991    { 3074, "aef3b209d01d39d0597fe03634bbf441" },
992    { 3075, "335ffb428eabf210bada96d74d5a4012" },
993    { 4048, "2434c2b43d798d2819487a886261fc64" },
994    { 4052, "ac2fa84a8a33065b2e92e36432e861f8" },
995    { 4058, "856781f85616c341c3533d090c1e1e84" },
996    { 6144, "e5d134c652c18bf19833e115f7a82e9b" },
997    { 6150, "a09a353be7795fac2401dac5601872e6" },
998    { 6400, "08b9033ac6a1821398f50af75a2dbc83" },
999    { 6528, "3d47aa193a8540c091e7e02f779e6751" },
1000    { 8192, "d3164e710c0626f6f395b38f20141cb7" },
1001    { 8320, "b727589d9183ff4e8491dd24466974a3" },
1002    {16384, "3f54d970793d2274d5b20d10a69938ac" },
1003    {18432, "f558511dcf81985b7a1bb57fad970531" },
1004    { 0, NULL },
1005};
1006
1007
1008/* Key = 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
1009 * 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa
1010 * 0xaa, 0xaa, 0xaa, 0xaa
1011 * InputHexStr = "31323334353637383930" (ASCII = "1234567890")
1012 */
1013static MV_CESA_SIZE_TEST shaMultiSizeTest402[] =
1014{
1015    { 80, "e812f370e659705a1649940d1f78cd7af18affd3" },
1016    { 512, "e547f886b2c15d995ed76a8a924cb408c8080f66" },
1017    { 1000, "239443194409f1a5342ecde1a092c8f3a3ed790a" },
1018    { 1001, "f278ab9a102850a9f48dc4e9e6822afe2d0c52b5" },
1019    { 1002, "8bcc667df5ab6ece988b3af361d09747c77f4e72" },
1020    { 1003, "0fae6046c7dc1d3e356b25af836f6077a363f338" },
1021    { 1004, "0ea48401cc92ae6bc92ae76685269cb0167fbe1a" },
1022    { 1005, "ecbcd7c879b295bafcd8766cbeac58cc371e31d1" },
1023    { 1006, "eb4a4a3d07d1e9a15e6f1ab8a9c47f243e27324c" },
1024    { 1336, "f5950ee1d77c10e9011d2149699c9366fe52529c" },
1025    { 1344, "b04263604a63c351b0b3b9cf1785b4bdba6c8838" },
1026    { 1399, "8cb1cff61d5b784045974a2fc69386e3b8d24218" },
1027    { 1400, "9bb2f3fcbeddb2b90f0be797cd647334a2816d51" },
1028    { 1401, "23ae462a7a0cb440f7445791079a5d75a535dd33" },
1029    { 1402, "832974b524a4d3f9cc2f45a3cabf5ccef65cd2aa" },
1030    { 1403, "d1c683742fe404c3c20d5704a5430e7832a7ec95" },
1031    { 1404, "867c79042e64f310628e219d8b85594cd0c7adc3" },
1032    { 1405, "c9d81d49d13d94358f56ccfd61af02b36c69f7c3" },
1033    { 1406, "0df43daab2786172f9b8d07d61f14a070cf1287a" },
1034    { 1407, "0fd8f3ad7f169534b274d4c66bbddd89f759e391" },
1035    { 1408, "3987511182b18473a564436003139b808fa46343" },
1036    { 1409, "ef667e063c9e9f539a8987a8d0bd3066ee85d901" },
1037    { 2048, "921109c99f3fedaca21727156d5f2b4460175327" },
1038    { 2049, "47188600dd165eb45f27c27196d3c46f4f042c1b" },
1039    { 2050, "8831939904009338de10e7fa670847041387807d" },
1040    { 2051, "2f8ebb5db2997d614e767be1050366f3641e7520" },
1041    { 2052, "669e51cd730dae158d3bef8adba075bd95a0d011" },
1042    { 3072, "cfee66cfd83abc8451af3c96c6b35a41cc6c55f5" },
1043    { 3074, "216ea26f02976a261b7d21a4dd3085157bedfabd" },
1044    { 3075, "bd612ebba021fd8e012b14c3bd60c8c5161fabc0" },
1045    { 4048, "c2564c1fdf2d5e9d7dde7aace2643428e90662e8" },
1046    { 4052, "91ce61fe924b445dfe7b5a1dcd10a27caec16df6" },
1047    { 4058, "db2a9be5ee8124f091c7ebd699266c5de223c164" },
1048    { 6144, "855109903feae2ba3a7a05a326b8a171116eb368" },
1049    { 6150, "37520bb3a668294d9c7b073e7e3daf8fee248a78" },
1050    { 6400, "60a353c841b6d2b1a05890349dad2fa33c7536b7" },
1051    { 6528, "9e53a43a69bb42d7c8522ca8bd632e421d5edb36" },
1052    { 8192, "a918cb0da862eaea0a33ee0efea50243e6b4927c" },
1053    { 8320, "29a5dcf55d1db29cd113fcf0572ae414f1c71329" },
1054    {16384, "6fb27966138e0c8d5a0d65ace817ebd53633cee1" },
1055    {18432, "ca09900d891c7c9ae2a559b10f63a217003341c1" },
1056    { 0, NULL },
1057};
1058
1059/* Key = 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
1060 * 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
1061 * 0x11, 0x12, 0x13, 0x14
1062 * InputHexStr = "31323334353637383930" (ASCII = "1234567890")
1063 */
1064static MV_CESA_SIZE_TEST shaMultiSizeTest404[] =
1065{
1066    { 80, "beaf20a34b06a87558d156c0949bc3957d40222e" },
1067    { 512, "3353955358d886bc2940a3c7f337ff7dafb59c7b" },
1068    { 1000, "8737a542c5e9b2b6244b757ebb69d5bd602a829f" },
1069    { 1001, "fd9e7582d8a5d3c9fe3b923e4e6a41b07a1eb4d4" },
1070    { 1002, "a146d14a6fc3c274ff600568f4d75b977989e00d" },
1071    { 1003, "be22601bbc027ddef2dec97d30b3dc424fd803c5" },
1072    { 1004, "3e71fe99b2fe2b7bfdf4dbf0c7f3da25d7ea35e7" },
1073    { 1005, "2c422735d7295408fddd76f5e8a83a2a8da13df3" },
1074    { 1006, "6d875319049314b61855101a647b9ba3313428e6" },
1075    { 1336, "c1631ea80bad9dc43a180712461b65a0598c711c" },
1076    { 1344, "816069bf91d34581005746e2e0283d0f9c7b7605" },
1077    { 1399, "4e139866dc61cfcb8b67ca2ebd637b3a538593af" },
1078    { 1400, "ff2a0f8dd2b02c5417910f6f55d33a78e081a723" },
1079    { 1401, "ab00c12be62336964cbce31ae97fe2a0002984d5" },
1080    { 1402, "61349e7f999f3a1acc56c3e9a5060a9c4a7b05b6" },
1081    { 1403, "3edbc0f61e435bc1317fa27d840076093fb79353" },
1082    { 1404, "d052c6dfdbe63d45dab23ef9893e2aa4636aca1e" },
1083    { 1405, "0cc16b7388d67bf0add15a31e6e6c753cfae4987" },
1084    { 1406, "c96ba7eaad74253c38c22101b558d2850b1d1b90" },
1085    { 1407, "3445428a40d2c6556e7c55797ad8d323b61a48d9" },
1086    { 1408, "8d6444f937a09317c89834187b8ea9b8d3a8c56b" },
1087    { 1409, "c700acd3ecd19014ea2bdb4d42510c467e088475" },
1088    { 2048, "ee27d2a0cb77470c2f496212dfd68b5bb7b04e4b" },
1089    { 2049, "683762d7a02983b26a6d046e6451d9cd82c25932" },
1090    { 2050, "0fd20f1d55a9ee18363c2a6fd54aa13aee69992f" },
1091    { 2051, "86c267d8cc4bc8d59090e4f8b303da960fd228b7" },
1092    { 2052, "452395ae05b3ec503eea34f86fc0832485ad97c1" },
1093    { 3072, "75198e3cfd0b9bcff2dabdf8e38e6fdaa33ca49a" },
1094    { 3074, "4e24785ef080141ce4aab4675986d9acea624d7c" },
1095    { 3075, "3a20c5978dd637ec0e809bf84f0d9ccf30bc65bf" },
1096    { 4048, "3c32da256be7a7554922bf5fed51b0d2d09e59ad" },
1097    { 4052, "fff898426ea16e54325ae391a32c6c9bce4c23c0" },
1098    { 4058, "c800b9e562e1c91e1310116341a3c91d37f848ec" },
1099    { 6144, "d91d509d0cc4376c2d05bf9a5097717a373530e6" },
1100    { 6150, "d957030e0f13c5df07d9eec298542d8f94a07f12" },
1101    { 6400, "bb745313c3d7dc17b3f955e5534ad500a1082613" },
1102    { 6528, "77905f80d9ca82080bbb3e5654896dabfcfd1bdb" },
1103    { 8192, "5237fd9a81830c974396f99f32047586612ff3c0" },
1104    { 8320, "57668e28d5f2dba0839518a11db0f6af3d7e08bf" },
1105    {16384, "62e093fde467f0748087beea32e9af97d5c61241" },
1106    {18432, "845fb33130c7d6ea554fd5aacb9c50cf7ccb5929" },
1107    { 0, NULL },
1108};
1109
1110/* HASH-SHA1
1111 * InputHexStr = "31323334353637383930" (ASCII = "1234567890")
1112 * repeated "size" times
1113 */
1114static MV_CESA_SIZE_TEST shaMultiSizeTest405[] =
1115{
1116    { 80, "50abf5706a150990a08b2c5ea40fa0e585554732" },
1117    { 512, "f14516a08948fa27917a974d219741a697ba0087" },
1118    { 1000, "0bd18c378d5788817eb4f1e5dc07d867efa5cbf4" },
1119    { 1001, "ca29b85c35db1b8aef83c977893a11159d1b7aa2" },
1120    { 1002, "d83bc973eaaedb8a31437994dabbb3304b0be086" },
1121    { 1003, "2cf7bbef0acd6c00536b5c58ca470df9a3a90b6c" },
1122    { 1004, "e4375d09b1223385a8a393066f8209acfd936a80" },
1123    { 1005, "1029b38043e027745d019ce1d2d68e3d8b9d8f99" },
1124    { 1006, "deea16dcebbd8ac137e2b984deb639b9fb5e9680" },
1125    { 1336, "ea031b065fff63dcfb6a41956e4777520cdbc55d" },
1126    { 1344, "b52096c6445e6c0a8355995c70dc36ae186c863c" },
1127    { 1399, "cde2f6f8379870db4b32cf17471dc828a8dbff2b" },
1128    { 1400, "e53ff664064bc09fe5054c650806bd42d8179518" },
1129    { 1401, "d1156db5ddafcace64cdb510ff0d4af9b9a8ad64" },
1130    { 1402, "34ede0e9a909dd84a2ae291539105c0507b958e1" },
1131    { 1403, "a772ca3536da77e6ad3251e4f9e1234a4d7b87c0" },
1132    { 1404, "29740fd2b04e7a8bfd32242db6233156ad699948" },
1133    { 1405, "65b17397495b70ce4865dad93bf991b74c97cce1" },
1134    { 1406, "a7ee89cd0754061fdb91af7ea6abad2c69d542e3" },
1135    { 1407, "3eebf82f7420188e23d328b7ce93580b279a5715" },
1136    { 1408, "e08d3363a8b9a490dfb3a4c453452b8f114deeec" },
1137    { 1409, "95d74df739181a4ff30b8c39e28793a36598e924" },
1138    { 2048, "aa40262509c2abf84aab0197f83187fc90056d91" },
1139    { 2049, "7dec28ef105bc313bade8d9a7cdeac58b99de5ea" },
1140    { 2050, "d2e30f77ec81197de20f56588a156094ecb88450" },
1141    { 2051, "6b22ccc874833e96551a39da0c0edcaa0d969d92" },
1142    { 2052, "f843141e57875cd669af58744bc60aa9ea59549c" },
1143    { 3072, "09c5fedeaa62c132e673cc3c608a00142273d086" },
1144    { 3074, "b09e95eea9c7b1b007a58accec488301901a7f3d" },
1145    { 3075, "e6226b77b4ada287a8c9bbcf4ed71eec5ce632dc" },
1146    { 4048, "e99394894f855821951ddddf5bfc628547435f5c" },
1147    { 4052, "32d2f1af38be9cfba6cd03d55a254d0b3e1eb382" },
1148    { 4058, "d906552a4f2aca3a22e1fecccbcd183d7289d0ef" },
1149    { 6144, "2e7f62d35a860988e1224dc0543204af19316041" },
1150    { 6150, "d6b89698ee133df46fec9d552fadc328aa5a1b51" },
1151    { 6400, "dff50e90c46853988fa3a4b4ce5dda6945aae976" },
1152    { 6528, "9e63ec0430b96db02d38bc78357a2f63de2ab7f8" },
1153    { 8192, "971eb71ed60394d5ab5abb12e88420bdd41b5992" },
1154    { 8320, "91606a31b46afeaac965cecf87297e791b211013" },
1155    {16384, "547f830a5ec1f5f170ce818f156b1002cabc7569" },
1156    {18432, "f16f272787f3b8d539652e4dc315af6ab4fda0ef" },
1157    { 0, NULL },
1158};
1159
1160/* CryptoKey = 0x01234567, 0x89abcdef,
1161 * 0x01234567, 0x89abcdef,
1162 * 0x01234567, 0x89abcdef;
1163 * MacKey = 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
1164 * 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
1165 * InputHexStr = "31323334353637383930" (ASCII = "1234567890")
1166 * Note: only sizes aligned to 3DES block size (8 bytes) allowed
1167 */
1168static MV_CESA_SIZE_TEST tripleDesMdMultiSizeTest502[] =
1169{
1170    { 64, "9586962a2aaaef28803dec2e17807a7f" },
1171    { 80, "b7726a03aad490bd6c5a452a89a1b271" },
1172    { 352, "f1ed9563aecc3c0d2766eb2bed3b4e4c" },
1173    { 512, "0f9decb11ab40fe86f4d4d9397bc020e" },
1174    { 1000, "3ba69deac12cab8ff9dff7dbd9669927" },
1175    { 1336, "6cf47bf1e80e03e2c1d0945bc50d37d2" },
1176    { 1344, "4be388dab21ceb3fa1b8d302e9b821f7" },
1177    { 1400, "a58b79fb21dd9bfc6ec93e3b99fb0ef1" },
1178    { 1408, "8bc97379fc2ac3237effcdd4f7a86528" },
1179    { 2048, "1339f03ab3076f25a20bc4cba16eb5bf" },
1180    { 3072, "731204d2d90c4b36ae41f5e1fb874288" },
1181    { 4048, "c028d998cfda5642547b7e1ed5ea16e4" },
1182    { 6144, "b1b19cd910cc51bd22992f1e59f1e068" },
1183    { 6400, "44e4613496ba622deb0e7cb768135a2f" },
1184    { 6528, "3b06b0a86f8db9cd67f9448dfcf10549" },
1185    { 8192, "d581780b7163138a0f412be681457d82" },
1186    {16384, "03b8ac05527faaf1bed03df149c65ccf" },
1187    {18432, "677c8a86a41dab6c5d81b85b8fb10ff6" },
1188    { 0, NULL },
1189};
1190
1191
1192/* CryptoKey = 0x01234567, 0x89abcdef,
1193 * 0x01234567, 0x89abcdef,
1194 * 0x01234567, 0x89abcdef;
1195 * MacKey = 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
1196 * 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
1197 * 0x11, 0x12, 0x13, 0x14
1198 * InputHexStr = "31323334353637383930" (ASCII = "1234567890")
1199 * Note: only sizes aligned to 3DES block size (8 bytes) allowed
1200 */
1201static MV_CESA_SIZE_TEST tripleDesShaMultiSizeTest503[] =
1202{
1203    { 64, "44a1e9bcbfc1429630d9ea68b7a48b0427a684f2" },
1204    { 80, "b2ddeaca91030eab5b95a234ef2c0f6e738ff883" },
1205    { 352, "4b91864c7ff629bdff75d9726421f76705452aaf" },
1206    { 512, "6dd37faceeb2aa98ba74f4242ed6734a4d546af5" },
1207    { 1000, "463661c30300be512a9df40904f0757cde5f1141" },
1208    { 1336, "b931f831d9034fe59c65176400b039fe9c1f44a5" },
1209    { 1344, "af8866b1cd4a4887d6185bfe72470ffdfb3648e1" },
1210    { 1400, "49c6caf07296d5e31d2504d088bc5b20c3ee7cdb" },
1211    { 1408, "fcae8deedbc6ebf0763575dc7e9de075b448a0f4" },
1212    { 2048, "edece5012146c1faa0dd10f50b183ba5d2af58ac" },
1213    { 3072, "5b83625adb43a488b8d64fecf39bb766818547b7" },
1214    { 4048, "d2c533678d26c970293af60f14c8279dc708bfc9" },
1215    { 6144, "b8f67af4f991b08b725f969b049ebf813bfacc5c" },
1216    { 6400, "d9a6c7f746ac7a60ef2edbed2841cf851c25cfb0" },
1217    { 6528, "376792b8c8d18161d15579fb7829e6e3a27e9946" },
1218    { 8192, "d890eabdca195b34ef8724b28360cffa92ae5655" },
1219    {16384, "a167ee52639ec7bf19aee9c6e8f76667c14134b9" },
1220    {18432, "e4396ab56f67296b220985a12078f4a0e365d2cc" },
1221    { 0, NULL },
1222};
1223
1224/* CryptoKey = 0x01234567, 0x89abcdef,
1225 * 0x01234567, 0x89abcdef,
1226 * 0x01234567, 0x89abcdef
1227 * IV = 0x12345678, 0x90abcdef
1228 * MacKey = 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
1229 * 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
1230 * InputHexStr = "31323334353637383930" (ASCII = "1234567890")
1231 * Note: only sizes aligned to 3DES block size (8 bytes) allowed
1232 */
1233static MV_CESA_SIZE_TEST cbc3desMdMultiSizeTest504[] =
1234{
1235    { 64, "8d10e00802460ede0058c139ba48bd2d" },
1236    { 80, "6f463057e1a90e0e91ae505b527bcec0" },
1237    { 352, "4938d48bdf86aece2c6851e7c6079788" },
1238    { 512, "516705d59f3cf810ebf2a13a23a7d42e" },
1239    { 1000, "a5a000ee5c830e67ddc6a2d2e5644b31" },
1240    { 1336, "44af60087b74ed07950088efbe3b126a" },
1241    { 1344, "1f5b39e0577920af731dabbfcf6dfc2a" },
1242    { 1400, "6804ea640e29b9cd39e08bc37dbce734" },
1243    { 1408, "4fb436624b02516fc9d1535466574bf9" },
1244    { 2048, "c909b0985c423d8d86719f701e9e83db" },
1245    { 3072, "cfe0bc34ef97213ee3d3f8b10122db21" },
1246    { 4048, "03ea10b5ae4ddeb20aed6af373082ed1" },
1247    { 6144, "b9a0ff4f87fc14b3c2dc6f0ed0998fdf" },
1248    { 6400, "6995f85d9d4985dd99e974ec7dda9dd6" },
1249    { 6528, "bbbb548ce2fa3d58467f6a6a5168a0e6" },
1250    { 8192, "afe101fbe745bb449ae4f50d10801456" },
1251    {16384, "9741706d0b1c923340c4660ff97cacdf" },
1252    {18432, "b0217becb73cb8f61fd79c7ce9d023fb" },
1253    { 0, NULL },
1254};
1255
1256
1257/* CryptoKey = 0x01234567, 0x89abcdef,
1258 * 0x01234567, 0x89abcdef,
1259 * 0x01234567, 0x89abcdef;
1260 * IV = 0x12345678, 0x90abcdef
1261 * MacKey = 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
1262 * 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
1263 * 0x11, 0x12, 0x13, 0x14
1264 * InputHexStr = "31323334353637383930" (ASCII = "1234567890")
1265 * Note: only sizes aligned to 3DES block size (8 bytes) allowed
1266 */
1267static MV_CESA_SIZE_TEST cbc3desShaMultiSizeTest505[] =
1268{
1269    { 64, "409187e5bdb0be4a7754ca3747f7433dc4f01b98" },
1270    { 80, "1b002ed050be743aa98860cf35659646bb8efcc0" },
1271    { 352, "6cbf7ebe50fa4fa6eecc19eca23f9eae553ccfff" },
1272    { 512, "cfb5253fb4bf72b743320c30c7e48c54965853b0" },
1273    { 1000, "95e04e1ca2937e7c5a9aba9e42d2bcdb8a7af21f" },
1274    { 1336, "3b5c1f5eee5837ebf67b83ae01405542d77a6627" },
1275    { 1344, "2b3d42ab25615437f98a1ee310b81d07a02badc2" },
1276    { 1400, "7f8687df7c1af44e4baf3c934b6cca5ab6bc993e" },
1277    { 1408, "473a581c5f04f7527d50793c845471ac87e86430" },
1278    { 2048, "e41d20cae7ebe34e6e828ed62b1e5734019037bb" },
1279    { 3072, "275664afd7a561d804e6b0d204e53939cde653ae" },
1280    { 4048, "0d220cc5b34aeeb46bbbd637dde6290b5a8285a3" },
1281    { 6144, "cb393ddcc8b1c206060625b7d822ef9839e67bc5" },
1282    { 6400, "dd3317e2a627fc04800f74a4b05bfda00fab0347" },
1283    { 6528, "8a74c3b2441ab3f5a7e08895cc432566219a7c41" },
1284    { 8192, "b8e6ef3a549ed0e005bd5b8b1a5fe6689e9711a7" },
1285    {16384, "55f59404008276cdac0e2ba0d193af2d40eac5ce" },
1286    {18432, "86ae6c4fc72369a54cce39938e2d0296cd9c6ec5" },
1287    { 0, NULL },
1288};
1289
1290
1291/* CryptoKey = 0x01234567, 0x89abcdef,
1292 * 0x01234567, 0x89abcdef,
1293 * 0x01234567, 0x89abcdef
1294 * IV = 0x12345678, 0x90abcdef
1295 * MacKey = 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
1296 * 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
1297 * InputHexStr = "31323334353637383930" (ASCII = "1234567890")
1298 * Note: only sizes aligned to AES block size (16 bytes) allowed
1299 */
1300static MV_CESA_SIZE_TEST cbcAes128md5multiSizeTest506[] =
1301{
1302    { 16, "7ca4c2ba866751598720c5c4aa0d6786" },
1303    { 64, "7dba7fb988e80da609b1fea7254bced8" },
1304    { 80, "6b6e863ac5a71d15e3e9b1c86c9ba05f" },
1305    { 352, "a1ceb9c2e3021002400d525187a9f38c" },
1306    { 512, "596c055c1c55db748379223164075641" },
1307    { 1008, "f920989c02f3b3603f53c99d89492377" },
1308    { 1344, "2e496b73759d77ed32ea222dbd2e7b41" },
1309    { 1408, "7178c046b3a8d772efdb6a71c4991ea4" },
1310    { 2048, "a917f0099c69eb94079a8421714b6aad" },
1311    { 3072, "693cd5033d7f5391d3c958519fa9e934" },
1312    { 4048, "139dca91bcff65b3c40771749052906b" },
1313    { 6144, "428d9cef6df4fb70a6e9b6bbe4819e55" },
1314    { 6400, "9c0b909e76daa811e12b1fc17000a0c4" },
1315    { 6528, "ad876f6297186a7be1f1b907ed860eda" },
1316    { 8192, "479cbbaca37dd3191ea1f3e8134a0ef4" },
1317    {16384, "60fda559c74f91df538100c9842f2f15" },
1318    {18432, "4a3eb1cba1fa45f3981270953f720c42" },
1319    { 0, NULL },
1320};
1321
1322
1323/* CryptoKey = 0x01234567, 0x89abcdef,
1324 * 0x01234567, 0x89abcdef,
1325 * 0x01234567, 0x89abcdef;
1326 * IV = 0x12345678, 0x90abcdef
1327 * MacKey = 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
1328 * 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
1329 * 0x11, 0x12, 0x13, 0x14
1330 * InputHexStr = "31323334353637383930" (ASCII = "1234567890")
1331 * Note: only sizes aligned to AES block size (16 bytes) allowed
1332 */
1333static MV_CESA_SIZE_TEST cbcAes128sha1multiSizeTest507[] =
1334{
1335    { 16, "9aa8dc1c45f0946daf78057fa978759c625c1fee" },
1336    { 64, "9f588fc1ede851e5f8b20256abc9979465ae2189" },
1337    { 80, "13558472d1fc1c90dffec6e5136c7203452d509b" },
1338    { 352, "6b93518e006cfaa1f7adb24615e7291fb0a27e06" },
1339    { 512, "096874951a77fbbf333e49d80c096ee2016e09bd" },
1340    { 1008, "696fc203c2e4b5ae0ec5d1db3f623c490bc6dbac" },
1341    { 1344, "79bf77509935ccd3528caaac6a5eb6481f74029b" },
1342    { 1408, "627f9462b95fc188e8cfa7eec15119bdc5d4fcf1" },
1343    { 2048, "3d50d0c005feba92fe41502d609fced9c882b4d1" },
1344    { 3072, "758807e5b983e3a91c06fb218fe0f73f77111e94" },
1345    { 4048, "ca90e85242e33f005da3504416a52098d0d31fb2" },
1346    { 6144, "8044c1d4fd06642dfc46990b4f18b61ef1e972cf" },
1347    { 6400, "166f1f4ea57409f04feba9fb1e39af0e00bd6f43" },
1348    { 6528, "0389016a39485d6e330f8b4215ddf718b404f7e9" },
1349    { 8192, "6df7ee2a8b61d6f7f860ce8dbf778f0c2a5b508b" },
1350    {16384, "a70a6d8dfa1f91ded621c3dbaed34162bc48783f" },
1351    {18432, "8dfad627922ce15df1eed10bdbed49244efa57db" },
1352    { 0, NULL },
1353};
1354
1355
1356void cesaTestPrintStatus(void);
1357
1358
1359/*------------------------- LOCAL FUNCTIONs ---------------------------------*/
1360MV_STATUS testCmd(int sid, int iter, MV_CESA_COMMAND* pCmd,
1361                  MV_CESA_TEST_SESSION* pTestSession, MV_U8* pIV, int ivSize);
1362MV_STATUS testClose(int idx);
1363MV_STATUS testOpen(int idx);
1364void close_session(int sid);
1365void cesaTestCheckReady(const MV_CESA_RESULT *r);
1366void cesaCheckReady(MV_CESA_RESULT* r);
1367void printTestResults(int idx, MV_STATUS status, int checkMode);
1368void cesaLastResult(void);
1369void cesaTestPrintReq(int req, int offset, int size);
1370
1371void cesaTestPrintStatus(void);
1372void cesaTestPrintSession(int idx);
1373void sizeTest(int testIdx, int iter, int checkMode);
1374void multiTest(int iter, int reqSize, int checkMode);
1375void oneTest(int testIdx, int caseIdx,int iter, int reqSize, int checkMode);
1376void multiSizeTest(int idx, int iter, int checkMode, char* inputData);
1377void cesaTest(int iter, int reqSize, int checkMode);
1378void cesaOneTest(int testIdx, int caseIdx,int iter, int reqSize, int checkMode);
1379void combiTest(int iter, int reqSize, int checkMode);
1380void shaTest(int iter, int reqSize, int checkMode);
1381void mdTest(int iter, int reqSize, int checkMode);
1382void aesTest(int iter, int reqSize, int checkMode);
1383void tripleDesTest(int iter, int reqSize, int checkMode);
1384void desTest(int iter, int reqSize, int checkMode);
1385void cesaTestStop(void);
1386MV_STATUS testRun(int idx, int caseIdx, int iter,int reqSize, int checkMode);
1387void cesaTestStart(int bufNum, int bufSize);
1388
1389
1390static MV_U32 getRate(MV_U32* remainder)
1391{
1392    MV_U32 kBits, milliSec, rate;
1393
1394    milliSec = 0;
1395    if( (cesaEndTicks - cesaBeginTicks) > 0)
1396    {
1397        milliSec = CESA_TEST_TICK_TO_MS(cesaEndTicks - cesaBeginTicks);
1398    }
1399    if(milliSec == 0)
1400    {
1401        if(remainder != NULL)
1402            *remainder = 0;
1403        return 0;
1404    }
1405
1406    kBits = (cesaIteration*cesaRateSize*8)/1000;
1407    rate = kBits/milliSec;
1408    if(remainder != NULL)
1409        *remainder = ((kBits % milliSec)*10)/milliSec;
1410
1411    return rate;
1412}
1413
1414static char* extractMbuf(MV_CESA_MBUF *pMbuf,
1415                            int offset, int size, char* hexStr)
1416{
1417    mvCesaCopyFromMbuf((MV_U8*)cesaBinBuffer, pMbuf, offset, size);
1418    mvBinToHex((const MV_U8*)cesaBinBuffer, hexStr, size);
1419
1420    return hexStr;
1421}
1422
1423static MV_BOOL cesaCheckMbuf(MV_CESA_MBUF *pMbuf,
1424                          const char* hexString, int offset,
1425                          int checkSize)
1426{
1427    MV_BOOL isFailed = MV_FALSE;
1428    MV_STATUS status;
1429    int size = strlen(hexString)/2;
1430    int checkedSize = 0;
1431/*
1432    mvOsPrintf("cesaCheckMbuf: pMbuf=%p, offset=%d, checkSize=%d, mBufSize=%d\n",
1433                pMbuf, offset, checkSize, pMbuf->mbufSize);
1434*/
1435    if(pMbuf->mbufSize < (checkSize + offset))
1436    {
1437        mvOsPrintf("checkSize (%d) is too large: offset=%d, mbufSize=%d\n",
1438                    checkSize, offset, pMbuf->mbufSize);
1439        return MV_TRUE;
1440    }
1441    status = mvCesaCopyFromMbuf((MV_U8*)cesaBinBuffer, pMbuf, offset, checkSize);
1442    if(status != MV_OK)
1443    {
1444        mvOsPrintf("CesaTest: Can't copy %d bytes from Mbuf=%p to checkBuf=%p\n",
1445                    checkSize, pMbuf, cesaBinBuffer);
1446        return MV_TRUE;
1447    }
1448/*
1449    mvDebugMemDump(cesaBinBuffer, size, 1);
1450*/
1451    mvHexToBin(hexString, (MV_U8*)cesaExpBinBuffer, size);
1452
1453    /* Compare buffers */
1454    while(checkSize > checkedSize)
1455    {
1456        size = MV_MIN(size, (checkSize - checkedSize));
1457        if(memcmp(cesaExpBinBuffer, &cesaBinBuffer[checkedSize], size) != 0)
1458        {
1459            mvOsPrintf("CheckMbuf failed: checkSize=%d, size=%d, checkedSize=%d\n",
1460                        checkSize, size, checkedSize);
1461            mvDebugMemDump(&cesaBinBuffer[checkedSize], size, 1);
1462            mvDebugMemDump(cesaExpBinBuffer, size, 1);
1463
1464            isFailed = MV_TRUE;
1465            break;
1466        }
1467        checkedSize += size;
1468    }
1469
1470    return isFailed;
1471}
1472
1473static MV_STATUS cesaSetMbuf(MV_CESA_MBUF *pMbuf,
1474                        const char* hexString,
1475                        int offset, int reqSize)
1476{
1477    MV_STATUS status = MV_OK;
1478    int copySize, size = strlen(hexString)/2;
1479
1480    mvHexToBin(hexString, (MV_U8*)cesaBinBuffer, size);
1481
1482    copySize = 0;
1483    while(reqSize > copySize)
1484    {
1485        size = MV_MIN(size, (reqSize - copySize));
1486
1487        status = mvCesaCopyToMbuf((MV_U8*)cesaBinBuffer, pMbuf, offset+copySize, size);
1488        if(status != MV_OK)
1489        {
1490            mvOsPrintf("cesaSetMbuf Error: Copy %d of %d bytes to MBuf\n",
1491                        copySize, reqSize);
1492            break;
1493        }
1494        copySize += size;
1495    }
1496    pMbuf->mbufSize = offset+copySize;
1497    return status;
1498}
1499
1500static MV_CESA_TEST_SESSION* getTestSessionDb(int idx, int* pTestIdx)
1501{
1502    int testIdx, dbIdx = idx/100;
1503
1504    if(dbIdx > MAX_TEST_TYPE)
1505    {
1506        mvOsPrintf("Wrong index %d - No such test type\n", idx);
1507        return NULL;
1508    }
1509    testIdx = idx % 100;
1510
1511    if(testIdx >= cesaTestsDB[dbIdx].numSessions)
1512    {
1513        mvOsPrintf("Wrong index %d - No such test\n", idx);
1514        return NULL;
1515    }
1516    if(pTestIdx != NULL)
1517        *pTestIdx = testIdx;
1518
1519    return cesaTestsDB[dbIdx].pSessions;
1520}
1521
1522/* Debug */
1523void cesaTestPrintReq(int req, int offset, int size)
1524{
1525    MV_CESA_MBUF* pMbuf;
1526
1527    mvOsPrintf("cesaTestPrintReq: req=%d, offset=%d, size=%d\n",
1528                req, offset, size);
1529    mvDebugMemDump(cesaCmdRing, 128, 4);
1530
1531    pMbuf = cesaCmdRing[req].pSrc;
1532    mvCesaDebugMbuf("src", pMbuf, offset,size);
1533    pMbuf = cesaCmdRing[req].pDst;
1534    mvCesaDebugMbuf("dst", pMbuf, offset, size);
1535
1536    cesaTestPrintStatus();
1537}
1538
1539void cesaLastResult(void)
1540{
1541        mvOsPrintf("Last Result: ReqId = %d, SessionId = %d, rc = (%d)\n",
1542                (MV_U32)cesaResult.pReqPrv, cesaResult.sessionId,
1543                cesaResult.retCode);
1544}
1545
1546void printTestResults(int idx, MV_STATUS status, int checkMode)
1547{
1548    int testIdx;
1549    MV_CESA_TEST_SESSION* pTestSessions = getTestSessionDb(idx, &testIdx);
1550
1551    if(pTestSessions == NULL)
1552        return;
1553
1554    mvOsPrintf("%-35s %4dx%-4d : ", pTestSessions[testIdx].name,
1555            cesaIteration, cesaReqSize);
1556    if( (status == MV_OK) &&
1557        (cesaCryptoError == 0) &&
1558        (cesaError == 0) &&
1559        (cesaReqIdError == 0) )
1560    {
1561        mvOsPrintf("Passed, Rate=%3u.%u Mbps (%5u cpp)\n",
1562                     cesaRate, cesaRateAfterDot, cesaEndTicks - cesaBeginTicks);
1563    }
1564    else
1565    {
1566        mvOsPrintf("Failed, Status = 0x%x\n", status);
1567        if(cesaCryptoError > 0)
1568            mvOsPrintf("cryptoError : %d\n", cesaCryptoError);
1569        if(cesaReqIdError > 0)
1570            mvOsPrintf("reqIdError : %d\n", cesaReqIdError);
1571        if(cesaError > 0)
1572            mvOsPrintf("cesaError : %d\n", cesaError);
1573    }
1574    if(cesaTestIsrMissCount > 0)
1575        mvOsPrintf("cesaIsrMissed : %d\n", cesaTestIsrMissCount);
1576}
1577
1578void cesaCheckReady(MV_CESA_RESULT* r)
1579{
1580    int reqId;
1581    MV_CESA_MBUF *pMbuf;
1582    MV_BOOL isFailed;
1583
1584    cesaResult = *r;
1585    reqId = (int)cesaResult.pReqPrv;
1586    pMbuf = cesaCmdRing[reqId].pDst;
1587
1588/*
1589    mvOsPrintf("cesaCheckReady: reqId=%d, checkOffset=%d, checkSize=%d\n",
1590                    reqId, cesaCheckOffset, cesaCheckSize);
1591*/
1592    /* Check expected reqId */
1593    if(reqId != cesaExpReqId)
1594    {
1595        cesaReqIdError++;
1596/*
1597        mvOsPrintf("CESA reqId Error: cbIter=%d (%d), reqId=%d, expReqId=%d\n",
1598                    cesaCbIter, cesaIteration, reqId, cesaExpReqId);
1599*/
1600    }
1601    else
1602    {
1603        if( (cesaCheckMode == CESA_FULL_CHECK_MODE) ||
1604            (cesaCheckMode == CESA_FAST_CHECK_MODE) )
1605        {
1606            if(cesaResult.retCode != MV_OK)
1607            {
1608                cesaError++;
1609
1610                mvOsPrintf("CESA Error: cbIter=%d (%d), reqId=%d, rc=%d\n",
1611                            cesaCbIter, cesaIteration, reqId, cesaResult.retCode);
1612            }
1613            else
1614            {
1615                if( (cesaCheckSize > 0) && (cesaOutputHexStr != NULL) )
1616                {
1617                    /* Check expected output */
1618
1619                    isFailed = cesaCheckMbuf(pMbuf, cesaOutputHexStr, cesaCheckOffset, cesaCheckSize);
1620                    if(isFailed)
1621                    {
1622                        mvOsPrintf("CESA Crypto Error: cbIter=%d (%d), reqId=%d\n",
1623                                    cesaCbIter, cesaIteration, reqId);
1624
1625                        CESA_TEST_DEBUG_PRINT(("Error: reqId=%d, reqSize=%d, checkOffset=%d, checkSize=%d\n",
1626                                    reqId, cesaReqSize, cesaCheckOffset, cesaCheckSize));
1627
1628                        CESA_TEST_DEBUG_PRINT(("Output str: %s\n", cesaOutputHexStr));
1629
1630                        CESA_TEST_DEBUG_CODE( mvCesaDebugMbuf("error", pMbuf, 0, cesaCheckOffset+cesaCheckSize) );
1631
1632                        cesaCryptoError++;
1633                    }
1634                }
1635            }
1636        }
1637    }
1638    if(cesaCheckMode == CESA_SHOW_CHECK_MODE)
1639    {
1640        extractMbuf(pMbuf, cesaCheckOffset, cesaCheckSize, cesaHexBuffer);
1641        mvOsPrintf("%4d, %s\n", cesaCheckOffset, cesaHexBuffer);
1642    }
1643
1644    cesaCbIter++;
1645    if(cesaCbIter >= cesaIteration)
1646    {
1647        cesaCbIter = 0;
1648        cesaExpReqId = 0;
1649        cesaIsReady = MV_TRUE;
1650
1651        cesaEndTicks = CESA_TEST_TICK_GET();
1652        cesaRate = getRate(&cesaRateAfterDot);
1653    }
1654    else
1655    {
1656        cesaExpReqId = reqId + 1;
1657        if(cesaExpReqId == CESA_DEF_REQ_SIZE)
1658            cesaExpReqId = 0;
1659    }
1660}
1661
1662
1663#ifdef MV_NETBSD
1664static int cesaTestReadyIsr(void *arg)
1665#else
1666#ifdef __KERNEL__
1667static irqreturn_t cesaTestReadyIsr( int irq , void *dev_id)
1668#endif
1669#ifdef MV_VXWORKS
1670void cesaTestReadyIsr(void)
1671#endif
1672#endif
1673{
1674    MV_U32 cause;
1675    MV_STATUS status;
1676    MV_CESA_RESULT result;
1677
1678    cesaTestIsrCount++;
1679    /* Clear cause register */
1680    cause = MV_REG_READ(MV_CESA_ISR_CAUSE_REG);
1681    if( (cause & MV_CESA_CAUSE_ACC_DMA_ALL_MASK) == 0)
1682    {
1683        mvOsPrintf("cesaTestReadyIsr: cause=0x%x\n", cause);
1684#ifdef MV_NETBSD
1685        return 0;
1686#else
1687#ifdef __KERNEL__
1688        return 1;
1689#else
1690        return;
1691#endif
1692#endif
1693    }
1694
1695    MV_REG_WRITE(MV_CESA_ISR_CAUSE_REG, 0);
1696
1697    while(MV_TRUE)
1698    {
1699        /* Get Ready requests */
1700        status = mvCesaReadyGet(&result);
1701        if(status == MV_OK)
1702            cesaCheckReady(&result);
1703
1704        break;
1705    }
1706    if( (cesaTestFull == 1) && (status != MV_BUSY) )
1707    {
1708        cesaTestFull = 0;
1709        CESA_TEST_WAKE_UP();
1710    }
1711
1712#ifdef __KERNEL__
1713    return 1;
1714#endif
1715}
1716
1717void
1718cesaTestCheckReady(const MV_CESA_RESULT *r)
1719{
1720    MV_CESA_RESULT result = *r;
1721
1722    cesaCheckReady(&result);
1723
1724    if (cesaTestFull == 1) {
1725        cesaTestFull = 0;
1726        CESA_TEST_WAKE_UP();
1727    }
1728}
1729
1730static INLINE int open_session(MV_CESA_OPEN_SESSION* pOs)
1731{
1732    MV_U16 sid;
1733    MV_STATUS status;
1734
1735    status = mvCesaSessionOpen(pOs, (short*)&sid);
1736    if(status != MV_OK)
1737    {
1738        mvOsPrintf("CesaTest: Can't open new session - status = 0x%x\n",
1739                    status);
1740        return -1;
1741    }
1742
1743    return (int)sid;
1744}
1745
1746void close_session(int sid)
1747{
1748    MV_STATUS status;
1749
1750    status = mvCesaSessionClose(sid);
1751    if(status != MV_OK)
1752    {
1753        mvOsPrintf("CesaTest: Can't close session %d - status = 0x%x\n",
1754                    sid, status);
1755    }
1756}
1757
1758MV_STATUS testOpen(int idx)
1759{
1760    MV_CESA_OPEN_SESSION os;
1761    int sid, i, testIdx;
1762    MV_CESA_TEST_SESSION* pTestSession;
1763    MV_U16 digestSize = 0;
1764
1765    pTestSession = getTestSessionDb(idx, &testIdx);
1766    if(pTestSession == NULL)
1767    {
1768        mvOsPrintf("Test %d is not exist\n", idx);
1769        return MV_BAD_PARAM;
1770    }
1771    pTestSession = &pTestSession[testIdx];
1772
1773    if(pTestSession->sid != -1)
1774    {
1775        mvOsPrintf("Session for test %d already created: sid=%d\n",
1776                    idx, pTestSession->sid);
1777        return MV_OK;
1778    }
1779
1780    os.cryptoAlgorithm = pTestSession->cryptoAlgorithm;
1781    os.macMode = pTestSession->macAlgorithm;
1782    switch(os.macMode)
1783    {
1784        case MV_CESA_MAC_MD5:
1785        case MV_CESA_MAC_HMAC_MD5:
1786            digestSize = MV_CESA_MD5_DIGEST_SIZE;
1787            break;
1788
1789        case MV_CESA_MAC_SHA1:
1790        case MV_CESA_MAC_HMAC_SHA1:
1791            digestSize = MV_CESA_SHA1_DIGEST_SIZE;
1792            break;
1793
1794        case MV_CESA_MAC_NULL:
1795            digestSize = 0;
1796    }
1797    os.cryptoMode = pTestSession->cryptoMode;
1798    os.direction = pTestSession->direction;
1799    os.operation = pTestSession->operation;
1800
1801    for(i=0; i<pTestSession->cryptoKeySize; i++)
1802        os.cryptoKey[i] = pTestSession->pCryptoKey[i];
1803
1804    os.cryptoKeyLength = pTestSession->cryptoKeySize;
1805
1806    for(i=0; i<pTestSession->macKeySize; i++)
1807        os.macKey[i] = pTestSession->pMacKey[i];
1808
1809    os.macKeyLength = pTestSession->macKeySize;
1810    os.digestSize = digestSize;
1811
1812    sid = open_session(&os);
1813    if(sid == -1)
1814    {
1815        mvOsPrintf("Can't open session for test %d: rc=0x%x\n",
1816                    idx, cesaResult.retCode);
1817        return cesaResult.retCode;
1818    }
1819    CESA_TEST_DEBUG_PRINT(("Opened session: sid = %d\n", sid));
1820    pTestSession->sid = sid;
1821    return MV_OK;
1822}
1823
1824MV_STATUS testClose(int idx)
1825{
1826    int testIdx;
1827    MV_CESA_TEST_SESSION* pTestSession;
1828
1829    pTestSession = getTestSessionDb(idx, &testIdx);
1830    if(pTestSession == NULL)
1831    {
1832        mvOsPrintf("Test %d is not exist\n", idx);
1833        return MV_BAD_PARAM;
1834    }
1835    pTestSession = &pTestSession[testIdx];
1836
1837    if(pTestSession->sid == -1)
1838    {
1839        mvOsPrintf("Test session %d is not opened\n", idx);
1840        return MV_NO_SUCH;
1841    }
1842
1843    close_session(pTestSession->sid);
1844    pTestSession->sid = -1;
1845
1846    return MV_OK;
1847}
1848
1849MV_STATUS testCmd(int sid, int iter, MV_CESA_COMMAND* pCmd,
1850             MV_CESA_TEST_SESSION* pTestSession, MV_U8* pIV, int ivSize)
1851{
1852    int cmdReqId = 0;
1853    int i;
1854    MV_STATUS rc = MV_OK;
1855    char ivZeroHex[] = "0000";
1856
1857    if(iter == 0)
1858        iter = CESA_DEF_ITER_NUM;
1859
1860    if(pCmd == NULL)
1861    {
1862        mvOsPrintf("testCmd failed: pCmd=NULL\n");
1863        return MV_BAD_PARAM;
1864    }
1865    pCmd->sessionId = sid;
1866
1867    cesaCryptoError = 0;
1868    cesaReqIdError = 0;
1869    cesaError = 0;
1870    cesaTestIsrMissCount = 0;
1871    cesaIsReady = MV_FALSE;
1872    cesaIteration = iter;
1873
1874    if(cesaInputHexStr == NULL)
1875        cesaInputHexStr = cesaPlainHexEbc;
1876
1877    for(i=0; i<CESA_DEF_REQ_SIZE; i++)
1878    {
1879        pCmd->pSrc = (MV_CESA_MBUF*)(cesaCmdRing[i].pSrc);
1880        if(pIV != NULL)
1881        {
1882            /* If IV from SA - set IV in Source buffer to zeros */
1883            cesaSetMbuf(pCmd->pSrc, ivZeroHex, 0, pCmd->cryptoOffset);
1884            cesaSetMbuf(pCmd->pSrc, cesaInputHexStr, pCmd->cryptoOffset,
1885                        (cesaReqSize - pCmd->cryptoOffset));
1886        }
1887        else
1888        {
1889            cesaSetMbuf(pCmd->pSrc, cesaInputHexStr, 0, cesaReqSize);
1890        }
1891        pCmd->pDst = (MV_CESA_MBUF*)(cesaCmdRing[i].pDst);
1892        cesaSetMbuf(pCmd->pDst, cesaNullPlainHexText, 0, cesaReqSize);
1893
1894        memcpy(&cesaCmdRing[i], pCmd, sizeof(*pCmd));
1895    }
1896
1897    if(cesaCheckMode == CESA_SW_SHOW_CHECK_MODE)
1898    {
1899        MV_U8 pDigest[MV_CESA_MAX_DIGEST_SIZE];
1900
1901        if(pTestSession->macAlgorithm == MV_CESA_MAC_MD5)
1902        {
1903            mvMD5(pCmd->pSrc->pFrags[0].bufVirtPtr, pCmd->macLength, pDigest);
1904            mvOsPrintf("SW HASH_MD5: reqSize=%d, macLength=%d\n",
1905                        cesaReqSize, pCmd->macLength);
1906            mvDebugMemDump(pDigest, MV_CESA_MD5_DIGEST_SIZE, 1);
1907            return MV_OK;
1908        }
1909        if(pTestSession->macAlgorithm == MV_CESA_MAC_SHA1)
1910        {
1911            mvSHA1(pCmd->pSrc->pFrags[0].bufVirtPtr, pCmd->macLength, pDigest);
1912            mvOsPrintf("SW HASH_SHA1: reqSize=%d, macLength=%d\n",
1913                        cesaReqSize, pCmd->macLength);
1914            mvDebugMemDump(pDigest, MV_CESA_SHA1_DIGEST_SIZE, 1);
1915            return MV_OK;
1916        }
1917    }
1918
1919    cesaBeginTicks = CESA_TEST_TICK_GET();
1920    CESA_TEST_DEBUG_CODE( memset(cesaTestTrace, 0, sizeof(cesaTestTrace));
1921                     cesaTestTraceIdx = 0;
1922    );
1923
1924    if(cesaCheckMode == CESA_SW_NULL_CHECK_MODE)
1925    {
1926        volatile MV_U8 pDigest[MV_CESA_MAX_DIGEST_SIZE];
1927
1928        for(i=0; i<iter; i++)
1929        {
1930            if(pTestSession->macAlgorithm == MV_CESA_MAC_MD5)
1931            {
1932                mvMD5(pCmd->pSrc->pFrags[0].bufVirtPtr, pCmd->macLength, (unsigned char*)pDigest);
1933            }
1934            if(pTestSession->macAlgorithm == MV_CESA_MAC_SHA1)
1935            {
1936                mvSHA1(pCmd->pSrc->pFrags[0].bufVirtPtr, pCmd->macLength, (MV_U8 *)pDigest);
1937            }
1938        }
1939        cesaEndTicks = CESA_TEST_TICK_GET();
1940        cesaRate = getRate(&cesaRateAfterDot);
1941        cesaIsReady = MV_TRUE;
1942
1943        return MV_OK;
1944    }
1945
1946    /*cesaTestIsrCount = 0;*/
1947    /*mvCesaDebugStatsClear();*/
1948
1949#ifndef MV_NETBSD
1950    MV_REG_WRITE(MV_CESA_ISR_CAUSE_REG, 0);
1951#endif
1952
1953    for(i=0; i<iter; i++)
1954    {
1955        unsigned long flags;
1956
1957        pCmd = &cesaCmdRing[cmdReqId];
1958        pCmd->pReqPrv = (void*)cmdReqId;
1959
1960        CESA_TEST_LOCK(flags);
1961
1962        rc = mvCesaAction(pCmd);
1963        if(rc == MV_NO_RESOURCE)
1964            cesaTestFull = 1;
1965
1966        CESA_TEST_UNLOCK(flags);
1967
1968        if(rc == MV_NO_RESOURCE)
1969        {
1970            CESA_TEST_LOCK(flags);
1971            CESA_TEST_WAIT( (cesaTestFull == 0), 100);
1972            CESA_TEST_UNLOCK(flags);
1973            if(cesaTestFull == 1)
1974            {
1975                mvOsPrintf("CESA Test timeout: i=%d, iter=%d, cesaTestFull=%d\n",
1976                            i, iter, cesaTestFull);
1977                cesaTestFull = 0;
1978                return MV_TIMEOUT;
1979            }
1980
1981            CESA_TEST_LOCK(flags);
1982
1983            rc = mvCesaAction(pCmd);
1984
1985            CESA_TEST_UNLOCK(flags);
1986        }
1987        if( (rc != MV_OK) && (rc != MV_NO_MORE) )
1988        {
1989            mvOsPrintf("mvCesaAction failed: rc=%d\n", rc);
1990            return rc;
1991        }
1992
1993        cmdReqId++;
1994        if(cmdReqId >= CESA_DEF_REQ_SIZE)
1995            cmdReqId = 0;
1996
1997#ifdef MV_LINUX
1998        /* Reschedule each 16 requests */
1999        if( (i & 0xF) == 0)
2000            schedule();
2001#endif
2002    }
2003    return MV_OK;
2004}
2005
2006void cesaTestStart(int bufNum, int bufSize)
2007{
2008    int i, j, idx;
2009    MV_CESA_MBUF *pMbufSrc, *pMbufDst;
2010    MV_BUF_INFO *pFragsSrc, *pFragsDst;
2011    char *pBuf;
2012#ifndef MV_NETBSD
2013    int numOfSessions, queueDepth;
2014    char *pSram;
2015    MV_STATUS status;
2016    MV_CPU_DEC_WIN addrDecWin;
2017#endif
2018
2019    cesaCmdRing = mvOsMalloc(sizeof(MV_CESA_COMMAND) * CESA_DEF_REQ_SIZE);
2020    if(cesaCmdRing == NULL)
2021    {
2022        mvOsPrintf("testStart: Can't allocate %ld bytes of memory\n",
2023                sizeof(MV_CESA_COMMAND) * CESA_DEF_REQ_SIZE);
2024        return;
2025    }
2026    memset(cesaCmdRing, 0, sizeof(MV_CESA_COMMAND) * CESA_DEF_REQ_SIZE);
2027
2028    if(bufNum == 0)
2029        bufNum = CESA_DEF_BUF_NUM;
2030
2031    if(bufSize == 0)
2032        bufSize = CESA_DEF_BUF_SIZE;
2033
2034    cesaBufNum = bufNum;
2035    cesaBufSize = bufSize;
2036    mvOsPrintf("CESA test started: bufNum = %d, bufSize = %d\n",
2037                bufNum, bufSize);
2038
2039    cesaHexBuffer = mvOsMalloc(2*bufNum*bufSize);
2040    if(cesaHexBuffer == NULL)
2041    {
2042        mvOsPrintf("testStart: Can't malloc %d bytes for cesaHexBuffer.\n",
2043                    2*bufNum*bufSize);
2044        return;
2045    }
2046    memset(cesaHexBuffer, 0, (2*bufNum*bufSize));
2047
2048    cesaBinBuffer = mvOsMalloc(bufNum*bufSize);
2049    if(cesaBinBuffer == NULL)
2050    {
2051        mvOsPrintf("testStart: Can't malloc %d bytes for cesaBinBuffer\n",
2052                    bufNum*bufSize);
2053        return;
2054    }
2055    memset(cesaBinBuffer, 0, (bufNum*bufSize));
2056
2057    cesaExpBinBuffer = mvOsMalloc(bufNum*bufSize);
2058    if(cesaExpBinBuffer == NULL)
2059    {
2060        mvOsPrintf("testStart: Can't malloc %d bytes for cesaExpBinBuffer\n",
2061                    bufNum*bufSize);
2062        return;
2063    }
2064    memset(cesaExpBinBuffer, 0, (bufNum*bufSize));
2065
2066    CESA_TEST_WAIT_INIT();
2067
2068    pMbufSrc = mvOsMalloc(sizeof(MV_CESA_MBUF) * CESA_DEF_REQ_SIZE);
2069    pFragsSrc = mvOsMalloc(sizeof(MV_BUF_INFO) * bufNum * CESA_DEF_REQ_SIZE);
2070
2071    pMbufDst = mvOsMalloc(sizeof(MV_CESA_MBUF) * CESA_DEF_REQ_SIZE);
2072    pFragsDst = mvOsMalloc(sizeof(MV_BUF_INFO) * bufNum * CESA_DEF_REQ_SIZE);
2073
2074    if( (pMbufSrc == NULL) || (pFragsSrc == NULL) ||
2075        (pMbufDst == NULL) || (pFragsDst == NULL) )
2076    {
2077        mvOsPrintf("testStart: Can't malloc Src and Dst pMbuf and pFrags structures.\n");
2078        /* !!!! Dima cesaTestCleanup();*/
2079        return;
2080    }
2081
2082    memset(pMbufSrc, 0, sizeof(MV_CESA_MBUF) * CESA_DEF_REQ_SIZE);
2083    memset(pFragsSrc, 0, sizeof(MV_BUF_INFO) * bufNum * CESA_DEF_REQ_SIZE);
2084
2085    memset(pMbufDst, 0, sizeof(MV_CESA_MBUF) * CESA_DEF_REQ_SIZE);
2086    memset(pFragsDst, 0, sizeof(MV_BUF_INFO) * bufNum * CESA_DEF_REQ_SIZE);
2087
2088    mvOsPrintf("Cesa Test Start: pMbufSrc=%p, pFragsSrc=%p, pMbufDst=%p, pFragsDst=%p\n",
2089                pMbufSrc, pFragsSrc, pMbufDst, pFragsDst);
2090
2091    idx = 0;
2092    for(i=0; i<CESA_DEF_REQ_SIZE; i++)
2093    {
2094        pBuf = mvOsIoCachedMalloc(cesaTestOSHandle,bufSize * bufNum * 2,
2095                  &cesaReqBufs[i].bufPhysAddr,
2096                  &cesaReqBufs[i].memHandle);
2097        if(pBuf == NULL)
2098        {
2099            mvOsPrintf("testStart: Can't malloc %d bytes for pBuf\n",
2100                    bufSize * bufNum * 2);
2101            return;
2102        }
2103
2104        memset(pBuf, 0, bufSize * bufNum * 2);
2105        mvOsCacheFlush(cesaTestOSHandle,pBuf, bufSize * bufNum * 2);
2106        if(pBuf == NULL)
2107        {
2108            mvOsPrintf("cesaTestStart: Can't allocate %d bytes for req_%d buffers\n",
2109                        bufSize * bufNum * 2, i);
2110            return;
2111        }
2112
2113        cesaReqBufs[i].bufVirtPtr = (MV_U8*)pBuf;
2114        cesaReqBufs[i].bufSize = bufSize * bufNum * 2;
2115
2116        cesaCmdRing[i].pSrc = &pMbufSrc[i];
2117        cesaCmdRing[i].pSrc->pFrags = &pFragsSrc[idx];
2118        cesaCmdRing[i].pSrc->numFrags = bufNum;
2119        cesaCmdRing[i].pSrc->mbufSize = 0;
2120
2121        cesaCmdRing[i].pDst = &pMbufDst[i];
2122        cesaCmdRing[i].pDst->pFrags = &pFragsDst[idx];
2123        cesaCmdRing[i].pDst->numFrags = bufNum;
2124        cesaCmdRing[i].pDst->mbufSize = 0;
2125
2126        for(j=0; j<bufNum; j++)
2127        {
2128            cesaCmdRing[i].pSrc->pFrags[j].bufVirtPtr = (MV_U8*)pBuf;
2129            cesaCmdRing[i].pSrc->pFrags[j].bufSize = bufSize;
2130            pBuf += bufSize;
2131            cesaCmdRing[i].pDst->pFrags[j].bufVirtPtr = (MV_U8*)pBuf;
2132            cesaCmdRing[i].pDst->pFrags[j].bufSize = bufSize;
2133            pBuf += bufSize;
2134        }
2135        idx += bufNum;
2136    }
2137
2138#ifndef MV_NETBSD
2139    if (mvCpuIfTargetWinGet(CRYPT_ENG, &addrDecWin) == MV_OK)
2140        pSram = (char*)addrDecWin.addrWin.baseLow;
2141    else
2142    {
2143        mvOsPrintf("mvCesaInit: ERR. mvCpuIfTargetWinGet failed\n");
2144        return;
2145    }
2146
2147#ifdef MV_CESA_NO_SRAM
2148    pSram = mvOsMalloc(4*1024+8);
2149    if(pSram == NULL)
2150    {
2151        mvOsPrintf("CesaTest: can't allocate %d bytes for SRAM simulation\n",
2152                4*1024+8);
2153        /* !!!! Dima cesaTestCleanup();*/
2154        return;
2155    }
2156    pSram = (MV_U8*)MV_ALIGN_UP((MV_U32)pSram, 8);
2157#endif /* MV_CESA_NO_SRAM */
2158
2159    numOfSessions = CESA_DEF_SESSION_NUM;
2160    queueDepth = CESA_DEF_REQ_SIZE - MV_CESA_MAX_CHAN;
2161
2162    status = mvCesaInit(numOfSessions, queueDepth, pSram, NULL);
2163    if(status != MV_OK)
2164    {
2165        mvOsPrintf("mvCesaInit is Failed: status = 0x%x\n", status);
2166        /* !!!! Dima cesaTestCleanup();*/
2167        return;
2168    }
2169#endif /* !MV_NETBSD */
2170
2171    /* Prepare data for tests */
2172    for(i=0; i<50; i++)
2173        strcat((char*)cesaDataHexStr3, "dd");
2174
2175    strcpy((char*)cesaDataAndMd5digest3, cesaDataHexStr3);
2176    strcpy((char*)cesaDataAndSha1digest3, cesaDataHexStr3);
2177
2178    /* Digest must be 8 byte aligned */
2179    for(; i<56; i++)
2180    {
2181        strcat((char*)cesaDataAndMd5digest3, "00");
2182        strcat((char*)cesaDataAndSha1digest3, "00");
2183    }
2184    strcat((char*)cesaDataAndMd5digest3, cesaHmacMd5digestHex3);
2185    strcat((char*)cesaDataAndSha1digest3, cesaHmacSha1digestHex3);
2186
2187#ifndef MV_NETBSD
2188    MV_REG_WRITE( MV_CESA_ISR_CAUSE_REG, 0);
2189    MV_REG_WRITE( MV_CESA_ISR_MASK_REG, MV_CESA_CAUSE_ACC_DMA_MASK);
2190#endif
2191
2192#ifdef MV_VXWORKS
2193    {
2194        MV_STATUS status;
2195
2196        status = intConnect((VOIDFUNCPTR *)INT_LVL_CESA, cesaTestReadyIsr, (int)NULL);
2197        if (status != OK)
2198        {
2199            mvOsPrintf("CESA: Can't connect CESA (%d) interrupt, status=0x%x \n",
2200                        INT_LVL_CESA, status);
2201            /* !!!! Dima cesaTestCleanup();*/
2202            return;
2203        }
2204        cesaSemId = semMCreate(SEM_Q_PRIORITY | SEM_INVERSION_SAFE | SEM_DELETE_SAFE);
2205        if(cesaSemId == NULL)
2206        {
2207            mvOsPrintf("cesaTestStart: Can't create semaphore\n");
2208            return;
2209        }
2210        intEnable(INT_LVL_CESA);
2211    }
2212#endif /* MV_VXWORKS */
2213
2214#if !defined(MV_NETBSD) && defined(__KERNEL__)
2215        if( request_irq(CESA_IRQ, cesaTestReadyIsr, (SA_INTERRUPT) , "cesa_test", NULL ) )
2216        {
2217            mvOsPrintf( "cannot assign irq\n" );
2218            /* !!!! Dima cesaTestCleanup();*/
2219            return;
2220        }
2221        spin_lock_init( &cesaLock );
2222#endif
2223}
2224
2225MV_STATUS testRun(int idx, int caseIdx, int iter,
2226                    int reqSize, int checkMode)
2227{
2228    int testIdx, count, sid, digestSize;
2229    int blockSize;
2230    MV_CESA_TEST_SESSION* pTestSession;
2231    MV_CESA_COMMAND cmd;
2232    MV_STATUS status;
2233
2234    memset(&cmd, 0, sizeof(cmd));
2235
2236    pTestSession = getTestSessionDb(idx, &testIdx);
2237    if(pTestSession == NULL)
2238    {
2239        mvOsPrintf("Test %d is not exist\n", idx);
2240        return MV_BAD_PARAM;
2241    }
2242    pTestSession = &pTestSession[testIdx];
2243
2244    sid = pTestSession->sid;
2245    if(sid == -1)
2246    {
2247        mvOsPrintf("Test %d is not opened\n", idx);
2248        return MV_BAD_STATE;
2249    }
2250    switch(pTestSession->cryptoAlgorithm)
2251    {
2252        case MV_CESA_CRYPTO_DES:
2253        case MV_CESA_CRYPTO_3DES:
2254            blockSize = MV_CESA_DES_BLOCK_SIZE;
2255            break;
2256
2257        case MV_CESA_CRYPTO_AES:
2258            blockSize = MV_CESA_AES_BLOCK_SIZE;
2259            break;
2260
2261        case MV_CESA_CRYPTO_NULL:
2262            blockSize = 0;
2263            break;
2264
2265        default:
2266            mvOsPrintf("cesaTestRun: Bad CryptoAlgorithm=%d\n",
2267                pTestSession->cryptoAlgorithm);
2268        return MV_BAD_PARAM;
2269    }
2270    switch(pTestSession->macAlgorithm)
2271    {
2272        case MV_CESA_MAC_MD5:
2273        case MV_CESA_MAC_HMAC_MD5:
2274            digestSize = MV_CESA_MD5_DIGEST_SIZE;
2275            break;
2276
2277        case MV_CESA_MAC_SHA1:
2278        case MV_CESA_MAC_HMAC_SHA1:
2279            digestSize = MV_CESA_SHA1_DIGEST_SIZE;
2280            break;
2281        default:
2282            digestSize = 0;
2283    }
2284
2285    if(iter == 0)
2286        iter = CESA_DEF_ITER_NUM;
2287
2288    if(pTestSession->direction == MV_CESA_DIR_ENCODE)
2289    {
2290        cesaOutputHexStr = cesaTestCases[caseIdx].cipherHexStr;
2291        cesaInputHexStr = cesaTestCases[caseIdx].plainHexStr;
2292    }
2293    else
2294    {
2295        cesaOutputHexStr = cesaTestCases[caseIdx].plainHexStr;
2296        cesaInputHexStr = cesaTestCases[caseIdx].cipherHexStr;
2297    }
2298
2299    cmd.sessionId = sid;
2300    if(checkMode == CESA_FAST_CHECK_MODE)
2301    {
2302        cmd.cryptoLength = cesaTestCases[caseIdx].cryptoLength;
2303        cmd.macLength = cesaTestCases[caseIdx].macLength;
2304    }
2305    else
2306    {
2307        cmd.cryptoLength = reqSize;
2308        cmd.macLength = reqSize;
2309    }
2310    cesaRateSize = cmd.cryptoLength;
2311    cesaReqSize = cmd.cryptoLength;
2312    cmd.cryptoOffset = 0;
2313    if(pTestSession->operation != MV_CESA_MAC_ONLY)
2314    {
2315        if( (pTestSession->cryptoMode == MV_CESA_CRYPTO_CBC) ||
2316            (pTestSession->cryptoMode == MV_CESA_CRYPTO_CTR) )
2317        {
2318            cmd.ivOffset = 0;
2319            cmd.cryptoOffset = blockSize;
2320            if(cesaTestCases[caseIdx].pCryptoIV == NULL)
2321            {
2322                cmd.ivFromUser = 1;
2323            }
2324            else
2325            {
2326                cmd.ivFromUser = 0;
2327                mvCesaCryptoIvSet(cesaTestCases[caseIdx].pCryptoIV, blockSize);
2328            }
2329            cesaReqSize = cmd.cryptoOffset + cmd.cryptoLength;
2330        }
2331    }
2332
2333/*
2334    mvOsPrintf("ivFromUser=%d, cryptoLength=%d, cesaReqSize=%d, cryptoOffset=%d\n",
2335                cmd.ivFromUser, cmd.cryptoLength, cesaReqSize, cmd.cryptoOffset);
2336*/
2337    if(pTestSession->operation != MV_CESA_CRYPTO_ONLY)
2338    {
2339        cmd.macOffset = cmd.cryptoOffset;
2340
2341        if(cesaTestCases[caseIdx].digestOffset == -1)
2342        {
2343            cmd.digestOffset = cmd.macOffset + cmd.macLength;
2344            cmd.digestOffset = MV_ALIGN_UP(cmd.digestOffset, 8);
2345        }
2346        else
2347        {
2348            cmd.digestOffset = cesaTestCases[caseIdx].digestOffset;
2349        }
2350        if( (cmd.digestOffset + digestSize) > cesaReqSize)
2351            cesaReqSize = cmd.digestOffset + digestSize;
2352    }
2353
2354    cesaCheckMode = checkMode;
2355
2356    if(checkMode == CESA_NULL_CHECK_MODE)
2357    {
2358        cesaCheckSize = 0;
2359        cesaCheckOffset = 0;
2360    }
2361    else
2362    {
2363        if(pTestSession->operation == MV_CESA_CRYPTO_ONLY)
2364        {
2365            cesaCheckOffset = 0;
2366            cesaCheckSize = cmd.cryptoLength;
2367        }
2368        else
2369        {
2370            cesaCheckSize = digestSize;
2371            cesaCheckOffset = cmd.digestOffset;
2372        }
2373    }
2374/*
2375    mvOsPrintf("reqSize=%d, checkSize=%d, checkOffset=%d, checkMode=%d\n",
2376                cesaReqSize, cesaCheckSize, cesaCheckOffset, cesaCheckMode);
2377
2378    mvOsPrintf("blockSize=%d, ivOffset=%d, ivFromUser=%d, crOffset=%d, crLength=%d\n",
2379                blockSize, cmd.ivOffset, cmd.ivFromUser,
2380                cmd.cryptoOffset, cmd.cryptoLength);
2381
2382    mvOsPrintf("macOffset=%d, digestOffset=%d, macLength=%d\n",
2383                cmd.macOffset, cmd.digestOffset, cmd.macLength);
2384*/
2385    status = testCmd(sid, iter, &cmd, pTestSession,
2386                     cesaTestCases[caseIdx].pCryptoIV, blockSize);
2387
2388    if(status != MV_OK)
2389        return status;
2390
2391    /* Wait when all callbacks is received */
2392    count = 0;
2393    while(cesaIsReady == MV_FALSE)
2394    {
2395        mvOsSleep(10);
2396        count++;
2397        if(count > 100)
2398        {
2399            mvOsPrintf("testRun: Timeout occured\n");
2400            return MV_TIMEOUT;
2401        }
2402    }
2403
2404    return MV_OK;
2405}
2406
2407
2408void cesaTestStop(void)
2409{
2410    MV_CESA_MBUF *pMbufSrc, *pMbufDst;
2411    MV_BUF_INFO *pFragsSrc, *pFragsDst;
2412    int i;
2413
2414    /* Release all allocated memories */
2415    pMbufSrc = (MV_CESA_MBUF*)(cesaCmdRing[0].pSrc);
2416    pFragsSrc = cesaCmdRing[0].pSrc->pFrags;
2417
2418    pMbufDst = (MV_CESA_MBUF*)(cesaCmdRing[0].pDst);
2419    pFragsDst = cesaCmdRing[0].pDst->pFrags;
2420
2421    mvOsFree(pMbufSrc);
2422    mvOsFree(pMbufDst);
2423    mvOsFree(pFragsSrc);
2424    mvOsFree(pFragsDst);
2425
2426    for(i=0; i<CESA_DEF_REQ_SIZE; i++)
2427    {
2428        mvOsIoCachedFree(cesaTestOSHandle,cesaReqBufs[i].bufSize,
2429             cesaReqBufs[i].bufPhysAddr,cesaReqBufs[i].bufVirtPtr,
2430             cesaReqBufs[i].memHandle);
2431    }
2432    cesaDataHexStr3[0] = '\0';
2433}
2434
2435void desTest(int iter, int reqSize, int checkMode)
2436{
2437    int mode, i;
2438    MV_STATUS status;
2439
2440    mode = checkMode;
2441    if(checkMode == CESA_FULL_CHECK_MODE)
2442        mode = CESA_FAST_CHECK_MODE;
2443    i = iter;
2444    if(mode != CESA_NULL_CHECK_MODE)
2445        i = 1;
2446
2447    testOpen(0);
2448    testOpen(1);
2449    testOpen(2);
2450    testOpen(3);
2451
2452/* DES / ECB mode / Encrypt only */
2453    status = testRun(0, 1, iter, reqSize, checkMode);
2454    printTestResults(0, status, checkMode);
2455
2456/* DES / ECB mode / Decrypt only */
2457    status = testRun(1, 1, iter, reqSize, checkMode);
2458    printTestResults(1, status, checkMode);
2459
2460/* DES / CBC mode / Encrypt only */
2461    status = testRun(2, 2, i, reqSize, mode);
2462    printTestResults(2, status, mode);
2463
2464/* DES / CBC mode / Decrypt only */
2465    status = testRun(3, 2, iter, reqSize, mode);
2466    printTestResults(3, status, mode);
2467
2468    testClose(0);
2469    testClose(1);
2470    testClose(2);
2471    testClose(3);
2472}
2473
2474void tripleDesTest(int iter, int reqSize, int checkMode)
2475{
2476    int mode, i;
2477    MV_STATUS status;
2478
2479    mode = checkMode;
2480    if(checkMode == CESA_FULL_CHECK_MODE)
2481        mode = CESA_FAST_CHECK_MODE;
2482    i = iter;
2483    if(mode != CESA_NULL_CHECK_MODE)
2484        i = 1;
2485
2486    testOpen(100);
2487    testOpen(101);
2488    testOpen(102);
2489    testOpen(103);
2490
2491/* 3DES / ECB mode / Encrypt only */
2492    status = testRun(100, 1, iter, reqSize, checkMode);
2493    printTestResults(100, status, checkMode);
2494
2495/* 3DES / ECB mode / Decrypt only */
2496    status = testRun(101, 1, iter, reqSize, checkMode);
2497    printTestResults(101, status, checkMode);
2498
2499/* 3DES / CBC mode / Encrypt only */
2500    status = testRun(102, 2, i, reqSize, mode);
2501    printTestResults(102, status, mode);
2502
2503/* 3DES / CBC mode / Decrypt only */
2504    status = testRun(103, 2, iter, reqSize, mode);
2505    printTestResults(103, status, mode);
2506
2507    testClose(100);
2508    testClose(101);
2509    testClose(102);
2510    testClose(103);
2511}
2512
2513void aesTest(int iter, int reqSize, int checkMode)
2514{
2515    MV_STATUS status;
2516    int mode, i;
2517
2518    mode = checkMode;
2519    if(checkMode == CESA_FULL_CHECK_MODE)
2520        mode = CESA_FAST_CHECK_MODE;
2521
2522    i = iter;
2523    if(mode != CESA_NULL_CHECK_MODE)
2524        i = 1;
2525
2526    testOpen(200);
2527    testOpen(201);
2528    testOpen(202);
2529    testOpen(203);
2530    testOpen(204);
2531    testOpen(205);
2532    testOpen(206);
2533    testOpen(207);
2534    testOpen(208);
2535
2536/* AES-128 Encode ECB mode */
2537    status = testRun(200, 3, iter, reqSize, checkMode);
2538    printTestResults(200, status, checkMode);
2539
2540/* AES-128 Decode ECB mode */
2541    status = testRun(201, 3, iter, reqSize, checkMode);
2542    printTestResults(201, status, checkMode);
2543
2544/* AES-128 Encode CBC mode (IV from SA) */
2545    status = testRun(202, 10, i, reqSize, mode);
2546    printTestResults(202, status, mode);
2547
2548/* AES-128 Encode CBC mode (IV from User) */
2549    status = testRun(202, 24, i, reqSize, mode);
2550    printTestResults(202, status, mode);
2551
2552/* AES-128 Decode CBC mode */
2553    status = testRun(203, 24, iter, reqSize, mode);
2554    printTestResults(203, status, checkMode);
2555
2556/* AES-192 Encode ECB mode */
2557    status = testRun(204, 4, iter, reqSize, checkMode);
2558    printTestResults(204, status, checkMode);
2559
2560/* AES-192 Decode ECB mode */
2561    status = testRun(205, 4, iter, reqSize, checkMode);
2562    printTestResults(205, status, checkMode);
2563
2564/* AES-256 Encode ECB mode */
2565    status = testRun(206, 5, iter, reqSize, checkMode);
2566    printTestResults(206, status, checkMode);
2567
2568/* AES-256 Decode ECB mode */
2569    status = testRun(207, 5, iter, reqSize, checkMode);
2570    printTestResults(207, status, checkMode);
2571
2572#if defined(MV_LINUX)
2573/* AES-128 Encode CTR mode */
2574    status = testRun(208, 23, iter, reqSize, mode);
2575    printTestResults(208, status, checkMode);
2576#endif
2577    testClose(200);
2578    testClose(201);
2579    testClose(202);
2580    testClose(203);
2581    testClose(204);
2582    testClose(205);
2583    testClose(206);
2584    testClose(207);
2585    testClose(208);
2586}
2587
2588
2589void mdTest(int iter, int reqSize, int checkMode)
2590{
2591    int mode;
2592    MV_STATUS status;
2593
2594    if(iter == 0)
2595        iter = CESA_DEF_ITER_NUM;
2596
2597    mode = checkMode;
2598    if(checkMode == CESA_FULL_CHECK_MODE)
2599        mode = CESA_FAST_CHECK_MODE;
2600
2601    testOpen(300);
2602    testOpen(301);
2603    testOpen(302);
2604    testOpen(303);
2605    testOpen(305);
2606
2607/* HMAC-MD5 Generate signature test */
2608    status = testRun(300, 6, iter, reqSize, mode);
2609    printTestResults(300, status, checkMode);
2610
2611/* HMAC-MD5 Verify Signature test */
2612    status = testRun(301, 7, iter, reqSize, mode);
2613    printTestResults(301, status, checkMode);
2614
2615/* HMAC-MD5 Generate signature test */
2616    status = testRun(302, 8, iter, reqSize, mode);
2617    printTestResults(302, status, checkMode);
2618
2619/* HMAC-MD5 Verify Signature test */
2620    status = testRun(303, 9, iter, reqSize, mode);
2621    printTestResults(303, status, checkMode);
2622
2623/* HASH-MD5 Generate signature test */
2624    status = testRun(305, 15, iter, reqSize, mode);
2625    printTestResults(305, status, checkMode);
2626
2627    testClose(300);
2628    testClose(301);
2629    testClose(302);
2630    testClose(303);
2631    testClose(305);
2632}
2633
2634void shaTest(int iter, int reqSize, int checkMode)
2635{
2636    int mode;
2637    MV_STATUS status;
2638
2639    if(iter == 0)
2640        iter = CESA_DEF_ITER_NUM;
2641
2642    mode = checkMode;
2643    if(checkMode == CESA_FULL_CHECK_MODE)
2644        mode = CESA_FAST_CHECK_MODE;
2645
2646    testOpen(400);
2647    testOpen(401);
2648    testOpen(402);
2649    testOpen(403);
2650    testOpen(405);
2651
2652/* HMAC-SHA1 Generate signature test */
2653    status = testRun(400, 11, iter, reqSize, mode);
2654    printTestResults(400, status, checkMode);
2655
2656/* HMAC-SHA1 Verify Signature test */
2657    status = testRun(401, 12, iter, reqSize, mode);
2658    printTestResults(401, status, checkMode);
2659
2660/* HMAC-SHA1 Generate signature test */
2661    status = testRun(402, 13, iter, reqSize, mode);
2662    printTestResults(402, status, checkMode);
2663
2664/* HMAC-SHA1 Verify Signature test */
2665    status = testRun(403, 14, iter, reqSize, mode);
2666    printTestResults(403, status, checkMode);
2667
2668/* HMAC-SHA1 Generate signature test */
2669    status = testRun(405, 16, iter, reqSize, mode);
2670    printTestResults(405, status, checkMode);
2671
2672    testClose(400);
2673    testClose(401);
2674    testClose(402);
2675    testClose(403);
2676    testClose(405);
2677}
2678
2679void combiTest(int iter, int reqSize, int checkMode)
2680{
2681    MV_STATUS status;
2682    int mode, i;
2683
2684    mode = checkMode;
2685    if(checkMode == CESA_FULL_CHECK_MODE)
2686        mode = CESA_FAST_CHECK_MODE;
2687
2688    if(iter == 0)
2689        iter = CESA_DEF_ITER_NUM;
2690
2691    i = iter;
2692    if(mode != CESA_NULL_CHECK_MODE)
2693        i = 1;
2694
2695    testOpen(500);
2696    testOpen(501);
2697    testOpen(502);
2698    testOpen(503);
2699    testOpen(504);
2700    testOpen(505);
2701    testOpen(506);
2702    testOpen(507);
2703
2704/* DES ECB + MD5 encode test */
2705    status = testRun(500, 17, iter, reqSize, mode);
2706    printTestResults(500, status, mode);
2707
2708/* DES ECB + SHA1 encode test */
2709    status = testRun(501, 18, iter, reqSize, mode);
2710    printTestResults(501, status, mode);
2711
2712/* 3DES ECB + MD5 encode test */
2713    status = testRun(502, 17, iter, reqSize, mode);
2714    printTestResults(502, status, mode);
2715
2716/* 3DES ECB + SHA1 encode test */
2717    status = testRun(503, 18, iter, reqSize, mode);
2718    printTestResults(503, status, mode);
2719
2720/* 3DES CBC + MD5 encode test */
2721    status = testRun(504, 19, i, reqSize, mode);
2722    printTestResults(504, status, mode);
2723
2724/* 3DES CBC + SHA1 encode test */
2725    status = testRun(505, 20, i, reqSize, mode);
2726    printTestResults(505, status, mode);
2727
2728/* AES-128 CBC + MD5 encode test */
2729    status = testRun(506, 21, i, reqSize, mode);
2730    printTestResults(506, status, mode);
2731
2732/* AES-128 CBC + SHA1 encode test */
2733    status = testRun(507, 22, i, reqSize, mode);
2734    printTestResults(507, status, mode);
2735
2736    testClose(500);
2737    testClose(501);
2738    testClose(502);
2739    testClose(503);
2740    testClose(504);
2741    testClose(505);
2742    testClose(506);
2743    testClose(507);
2744}
2745
2746void cesaOneTest(int testIdx, int caseIdx,
2747                    int iter, int reqSize, int checkMode)
2748{
2749    MV_STATUS status;
2750
2751    if(iter == 0)
2752        iter = CESA_DEF_ITER_NUM;
2753
2754    mvOsPrintf("test=%d, case=%d, size=%d, iter=%d\n",
2755                testIdx, caseIdx, reqSize, iter);
2756
2757    status = testOpen(testIdx);
2758
2759    status = testRun(testIdx, caseIdx, iter, reqSize, checkMode);
2760    printTestResults(testIdx, status, checkMode);
2761    status = testClose(testIdx);
2762
2763}
2764
2765void cesaTest(int iter, int reqSize, int checkMode)
2766{
2767    if(iter == 0)
2768        iter = CESA_DEF_ITER_NUM;
2769
2770    mvOsPrintf("%d iteration\n", iter);
2771    mvOsPrintf("%d size\n\n", reqSize);
2772
2773/* DES tests */
2774    desTest(iter, reqSize, checkMode);
2775
2776/* 3DES tests */
2777    tripleDesTest(iter, reqSize, checkMode);
2778
2779/* AES tests */
2780    aesTest(iter, reqSize, checkMode);
2781
2782/* MD5 tests */
2783    mdTest(iter, reqSize, checkMode);
2784
2785/* SHA-1 tests */
2786    shaTest(iter, reqSize, checkMode);
2787}
2788
2789void multiSizeTest(int idx, int iter, int checkMode, char* inputData)
2790{
2791    MV_STATUS status;
2792    int i;
2793    MV_CESA_SIZE_TEST* pMultiTest;
2794
2795    if( testOpen(idx) != MV_OK)
2796        return;
2797
2798    if(iter == 0)
2799        iter = CESA_DEF_ITER_NUM;
2800
2801    if(checkMode == CESA_SHOW_CHECK_MODE)
2802    {
2803        iter = 1;
2804    }
2805    else
2806        checkMode = CESA_FULL_CHECK_MODE;
2807
2808    cesaTestCases[0].plainHexStr = inputData;
2809    cesaTestCases[0].pCryptoIV = NULL;
2810
2811    switch(idx)
2812    {
2813        case 302:
2814            pMultiTest = mdMultiSizeTest302;
2815            if(inputData == NULL)
2816                cesaTestCases[0].plainHexStr = cesaDataHexStr3;
2817            break;
2818
2819        case 304:
2820            pMultiTest = mdMultiSizeTest304;
2821            if(inputData == NULL)
2822                cesaTestCases[0].plainHexStr = hashHexStr80;
2823            break;
2824
2825        case 305:
2826            pMultiTest = mdMultiSizeTest305;
2827            if(inputData == NULL)
2828                cesaTestCases[0].plainHexStr = hashHexStr80;
2829            break;
2830
2831        case 402:
2832            pMultiTest = shaMultiSizeTest402;
2833            if(inputData == NULL)
2834                cesaTestCases[0].plainHexStr = hashHexStr80;
2835            break;
2836
2837        case 404:
2838            pMultiTest = shaMultiSizeTest404;
2839            if(inputData == NULL)
2840                cesaTestCases[0].plainHexStr = hashHexStr80;
2841            break;
2842
2843        case 405:
2844            pMultiTest = shaMultiSizeTest405;
2845            if(inputData == NULL)
2846                cesaTestCases[0].plainHexStr = hashHexStr80;
2847            break;
2848
2849        case 502:
2850            pMultiTest = tripleDesMdMultiSizeTest502;
2851            if(inputData == NULL)
2852                cesaTestCases[0].plainHexStr = hashHexStr80;
2853            break;
2854
2855        case 503:
2856            pMultiTest = tripleDesShaMultiSizeTest503;
2857            if(inputData == NULL)
2858                cesaTestCases[0].plainHexStr = hashHexStr80;
2859            break;
2860
2861        case 504:
2862            iter = 1;
2863            pMultiTest = cbc3desMdMultiSizeTest504;
2864            cesaTestCases[0].pCryptoIV = iv1;
2865            if(inputData == NULL)
2866                cesaTestCases[0].plainHexStr = hashHexStr80;
2867            break;
2868
2869        case 505:
2870            iter = 1;
2871            pMultiTest = cbc3desShaMultiSizeTest505;
2872            cesaTestCases[0].pCryptoIV = iv1;
2873            if(inputData == NULL)
2874                cesaTestCases[0].plainHexStr = hashHexStr80;
2875            break;
2876
2877        case 506:
2878            iter = 1;
2879            pMultiTest = cbcAes128md5multiSizeTest506;
2880            cesaTestCases[0].pCryptoIV = iv5;
2881            if(inputData == NULL)
2882                cesaTestCases[0].plainHexStr = hashHexStr80;
2883            break;
2884
2885        case 507:
2886            iter = 1;
2887            pMultiTest = cbcAes128sha1multiSizeTest507;
2888            cesaTestCases[0].pCryptoIV = iv5;
2889            if(inputData == NULL)
2890                cesaTestCases[0].plainHexStr = hashHexStr80;
2891            break;
2892
2893        default:
2894            iter = 1;
2895            checkMode = CESA_SHOW_CHECK_MODE;
2896            pMultiTest = mdMultiSizeTest302;
2897            if(inputData == NULL)
2898                cesaTestCases[0].plainHexStr = hashHexStr80;
2899    }
2900    i = 0;
2901    while(pMultiTest[i].outputHexStr != NULL)
2902    {
2903        cesaTestCases[0].cipherHexStr = (char *)pMultiTest[i].outputHexStr;
2904        status = testRun(idx, 0, iter, pMultiTest[i].size,
2905                         checkMode);
2906        if(checkMode != CESA_SHOW_CHECK_MODE)
2907        {
2908            cesaReqSize = pMultiTest[i].size;
2909            printTestResults(idx, status, checkMode);
2910        }
2911        if(status != MV_OK)
2912            break;
2913        i++;
2914    }
2915    testClose(idx);
2916/*
2917    mvCesaDebugStatus();
2918    cesaTestPrintStatus();
2919*/
2920}
2921
2922void open_session_test(int idx, int caseIdx, int iter)
2923{
2924    int reqIdError, cryptoError, openErrors, i;
2925    int openErrDisp[100];
2926    MV_STATUS status;
2927
2928    memset(openErrDisp, 0, sizeof(openErrDisp));
2929    openErrors = 0;
2930    reqIdError = 0;
2931    cryptoError = 0;
2932    for(i=0; i<iter; i++)
2933    {
2934        status = testOpen(idx);
2935        if(status != MV_OK)
2936        {
2937            openErrors++;
2938            openErrDisp[status]++;
2939        }
2940        else
2941        {
2942            testRun(idx, caseIdx, 1, 0, CESA_FAST_CHECK_MODE);
2943            if(cesaCryptoError > 0)
2944                cryptoError++;
2945            if(cesaReqIdError > 0)
2946                reqIdError++;
2947
2948            testClose(idx);
2949        }
2950    }
2951    if(cryptoError > 0)
2952        mvOsPrintf("cryptoError : %d\n", cryptoError);
2953    if(reqIdError > 0)
2954        mvOsPrintf("reqIdError : %d\n", reqIdError);
2955
2956    if(openErrors > 0)
2957    {
2958        mvOsPrintf("Open Errors = %d\n", openErrors);
2959        for(i=0; i<100; i++)
2960        {
2961            if(openErrDisp[i] != 0)
2962                mvOsPrintf("Error %d - occurs %d times\n", i, openErrDisp[i]);
2963        }
2964    }
2965}
2966
2967
2968void loopback_test(int idx, int iter, int size, char* pPlainData)
2969{
2970}
2971
2972
2973#if defined(MV_VXWORKS)
2974int testMode = 0;
2975unsigned __TASKCONV cesaTask(void* args)
2976{
2977    int reqSize = cesaReqSize;
2978
2979    if(testMode == 0)
2980    {
2981        cesaOneTest(cesaTestIdx, cesaCaseIdx, cesaIteration,
2982                    reqSize, cesaCheckMode);
2983    }
2984    else
2985    {
2986        if(testMode == 1)
2987        {
2988            cesaTest(cesaIteration, reqSize, cesaCheckMode);
2989            combiTest(cesaIteration, reqSize, cesaCheckMode);
2990        }
2991        else
2992        {
2993            multiSizeTest(cesaIdx, cesaIteration, cesaCheckMode, NULL);
2994        }
2995    }
2996    return 0;
2997}
2998
2999void oneTest(int testIdx, int caseIdx,
3000              int iter, int reqSize, int checkMode)
3001{
3002    long rc;
3003
3004    cesaIteration = iter;
3005    cesaReqSize = cesaRateSize = reqSize;
3006    cesaCheckMode = checkMode;
3007    testMode = 0;
3008    cesaTestIdx = testIdx;
3009    cesaCaseIdx = caseIdx;
3010    rc = mvOsTaskCreate("CESA_T", 100, 4*1024, cesaTask, NULL, &cesaTaskId);
3011    if (rc != MV_OK)
3012    {
3013        mvOsPrintf("hMW: Can't create CESA multiCmd test task, rc = %ld\n", rc);
3014    }
3015}
3016
3017void multiTest(int iter, int reqSize, int checkMode)
3018{
3019    long rc;
3020
3021    cesaIteration = iter;
3022    cesaCheckMode = checkMode;
3023    cesaReqSize = reqSize;
3024    testMode = 1;
3025    rc = mvOsTaskCreate("CESA_T", 100, 4*1024, cesaTask, NULL, &cesaTaskId);
3026    if (rc != MV_OK)
3027    {
3028        mvOsPrintf("hMW: Can't create CESA multiCmd test task, rc = %ld\n", rc);
3029    }
3030}
3031
3032void sizeTest(int testIdx, int iter, int checkMode)
3033{
3034    long rc;
3035
3036    cesaIteration = iter;
3037        cesaCheckMode = checkMode;
3038        testMode = 2;
3039        cesaIdx = testIdx;
3040    rc = mvOsTaskCreate("CESA_T", 100, 4*1024, cesaTask, NULL, &cesaTaskId);
3041    if (rc != MV_OK)
3042    {
3043        mvOsPrintf("hMW: Can't create CESA test task, rc = %ld\n", rc);
3044    }
3045}
3046
3047#endif /* MV_VXWORKS */
3048
3049extern void mvCesaDebugSA(short sid, int mode);
3050void cesaTestPrintSession(int idx)
3051{
3052    int testIdx;
3053    MV_CESA_TEST_SESSION* pTestSession;
3054
3055    pTestSession = getTestSessionDb(idx, &testIdx);
3056    if(pTestSession == NULL)
3057    {
3058        mvOsPrintf("Test %d is not exist\n", idx);
3059        return;
3060    }
3061    pTestSession = &pTestSession[testIdx];
3062
3063    if(pTestSession->sid == -1)
3064    {
3065        mvOsPrintf("Test session %d is not opened\n", idx);
3066        return;
3067    }
3068
3069    mvCesaDebugSA(pTestSession->sid, 1);
3070}
3071
3072void cesaTestPrintStatus(void)
3073{
3074    mvOsPrintf("\n\t Cesa Test Status\n\n");
3075
3076    mvOsPrintf("isrCount=%d\n",
3077                cesaTestIsrCount);
3078
3079#ifdef CESA_TEST_DEBUG
3080    {
3081        int i, j;
3082        j = cesaTestTraceIdx;
3083        mvOsPrintf("No Type Cause rCause iCause Res Time pReady pProc pEmpty\n");
3084        for(i=0; i<MV_CESA_TEST_TRACE_SIZE; i++)
3085        {
3086            mvOsPrintf("%02d. %d 0x%04x 0x%04x 0x%04x 0x%02x 0x%02x %02d 0x%06x %p %p %p\n",
3087                j, cesaTestTrace[j].type, cesaTestTrace[j].cause, cesaTestTrace[j].realCause,
3088                cesaTestTrace[j].dmaCause, cesaTestTrace[j].resources, cesaTestTrace[j].timeStamp,
3089                cesaTestTrace[j].pReqReady, cesaTestTrace[j].pReqProcess, cesaTestTrace[j].pReqEmpty);
3090            j++;
3091            if(j == MV_CESA_TEST_TRACE_SIZE)
3092                j = 0;
3093        }
3094    }
3095#endif /* CESA_TEST_DEBUG */
3096}
3097

Archive Download this file

Branches:
backfire
history
master
release_2010-11-17
release_2010-12-14
release_2011-02-23
release_2011-05-28
release_2011-08-27
release_2011-11-13
release_2012-03-18
release_2012-04-09
release_2012-10-11
uclibc_nptl



interactive