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

   1 /*******************************************************************************
   2 Copyright (C) Marvell International Ltd. and its affiliates
   3
   4 This software file (the "File") is owned and distributed by Marvell
   5 International Ltd. and/or its affiliates ("Marvell") under the following
   6 alternative licensing terms.  Once you have made an election to distribute the
   7 File under one of the following license alternatives, please (i) delete this
   8 introductory statement regarding license alternatives, (ii) delete the two
   9 license alternatives that you have not elected to use and (iii) preserve the
  10 Marvell copyright notice above.
  11
  12 ********************************************************************************
  13 Marvell Commercial License Option
  14
  15 If you received this File from Marvell and you have entered into a commercial
  16 license agreement (a "Commercial License") with Marvell, the File is licensed
  17 to you under the terms of the applicable Commercial License.
  18
  19 ********************************************************************************
  20 Marvell GPL License Option
  21
  22 If you received this File from Marvell, you may opt to use, redistribute and/or
  23 modify this File in accordance with the terms and conditions of the General
  24 Public License Version 2, June 1991 (the "GPL License"), a copy of which is
  25 available along with the File in the license.txt file or by writing to the Free
  26 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
  27 on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
  28
  29 THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
  30 WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
  31 DISCLAIMED.  The GPL License provides additional details about this warranty
  32 disclaimer.
  33 ********************************************************************************
  34 Marvell BSD License Option
  35
  36 If you received this File from Marvell, you may opt to use, redistribute and/or
  37 modify this File under the following licensing terms.
  38 Redistribution and use in source and binary forms, with or without modification,
  39 are 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
  52 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  53 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  54 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  55 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
  56 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  57 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  58 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  59 ANY 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
  61 SOFTWARE, 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
  76 SEM_ID      cesaSemId = NULL;
  77 SEM_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>
  92 wait_queue_head_t   cesaTest_waitq;
  93 spinlock_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>
 109 static 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)        \
 117 do {                                    \
 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
 165 typedef 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
 180 static int cesaTestTraceIdx = 0;
 181 static MV_CESA_TEST_TRACE    cesaTestTrace[MV_CESA_TEST_TRACE_SIZE];
 182
 183 static 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
 206 int                 cesaExpReqId=0;
 207 int                 cesaCbIter=0;
 208
 209 int                 cesaIdx;
 210 int                 cesaIteration;
 211 int                 cesaRateSize;
 212 int                 cesaReqSize;
 213 unsigned long       cesaTaskId;
 214 int                 cesaBufNum;
 215 int                 cesaBufSize;
 216 int                 cesaCheckOffset;
 217 int                 cesaCheckSize;
 218 int                 cesaCheckMode;
 219 int                 cesaTestIdx;
 220 int                 cesaCaseIdx;
 221
 222
 223 MV_U32      cesaTestIsrCount = 0;
 224 MV_U32      cesaTestIsrMissCount = 0;
 225
 226 MV_U32      cesaCryptoError = 0;
 227 MV_U32      cesaReqIdError  = 0;
 228 MV_U32      cesaError = 0;
 229
 230 char*       cesaHexBuffer = NULL;
 231
 232 char*       cesaBinBuffer = NULL;
 233 char*       cesaExpBinBuffer = NULL;
 234
 235 char*       cesaInputHexStr  = NULL;
 236 char*       cesaOutputHexStr = NULL;
 237
 238 MV_BUF_INFO         cesaReqBufs[CESA_DEF_REQ_SIZE];
 239
 240 MV_CESA_COMMAND*    cesaCmdRing;
 241 MV_CESA_RESULT      cesaResult;
 242
 243 int                 cesaTestFull = 0;
 244
 245 MV_BOOL             cesaIsReady = MV_FALSE;
 246 MV_U32              cesaCycles = 0;
 247 MV_U32              cesaBeginTicks = 0;
 248 MV_U32              cesaEndTicks = 0;
 249 MV_U32              cesaRate = 0;
 250 MV_U32              cesaRateAfterDot = 0;
 251
 252 void                *cesaTestOSHandle = NULL;
 253
 254 enum
 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
 266 enum
 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 */
 279 typedef 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
 295 typedef struct
 296 {
 297     MV_CESA_TEST_SESSION*   pSessions;
 298     int                     numSessions;
 299
 300 } MV_CESA_TEST_DB_ENTRY;
 301
 302 typedef 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
 313 typedef struct
 314 {
 315     int     size;
 316     const char* outputHexStr;
 317
 318 } MV_CESA_SIZE_TEST;
 319
 320 static 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
 324 static unsigned char    cryptoKey7[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef};
 325 static unsigned char    iv1[]        = {0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef};
 326
 327
 328 static unsigned char    cryptoKey2[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
 329                                         0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F};
 330
 331 static 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
 335 static 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
 340 static unsigned char    cryptoKey5[] = {0x56, 0xe4, 0x7a, 0x38, 0xc5, 0x59, 0x89, 0x74,
 341                                         0xbc, 0x46, 0x90, 0x3d, 0xba, 0x29, 0x03, 0x49};
 342
 343
 344 static 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  */
 349 static char  plain3des1[]           =   "54686520717566636B2062726F776E20666F78206A756D70";
 350 static char  cipher3des1[]          =   "A826FD8CE53B855FCCE21C8112256FE668D5C05DD9B6B900";
 351
 352 static 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
 356 static unsigned char    iv3des2[]   = {0x8e, 0x29, 0xf7, 0x5e, 0xa7, 0x7e, 0x54, 0x75};
 357
 358 static char  plain3des2[]           = "326a494cd33fe756";
 359
 360 static char  cipher3desCbc2[]       = "8e29f75ea77e5475"
 361                                       "b22b8d66de970692";
 362
 363 static 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
 367 static unsigned char    iv3des3[]   = {0x3d, 0x1d, 0xe3, 0xcc, 0x13, 0x2e, 0x3b, 0x65};
 368
 369 static char  plain3des3[]           = "84401f78fe6c10876d8ea23094ea5309";
 370
 371 static char  cipher3desCbc3[]       = "3d1de3cc132e3b65"
 372                                       "7b1f7c7e3b1c948ebd04a75ffba7d2f5";
 373
 374 static unsigned char    iv5[]        = {0x8c, 0xe8, 0x2e, 0xef, 0xbe, 0xa0, 0xda, 0x3c,
 375                                         0x44, 0x69, 0x9e, 0xd7, 0xdb, 0x51, 0xb7, 0xd9};
 376
 377 static unsigned char    aesCtrKey[]  = {0x76, 0x91, 0xBE, 0x03, 0x5E, 0x50, 0x20, 0xA8,
 378                                         0xAC, 0x6E, 0x61, 0x85, 0x29, 0xF9, 0xA0, 0xDC};
 379
 380 static unsigned char    mdKey1[]     = {0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
 381                                         0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b};
 382
 383 static unsigned char    mdKey2[]     = {0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
 384                                         0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa};
 385
 386 static 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
 390 static 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
 394 static unsigned char    mdKey4[]     = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
 395                                         0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10};
 396
 397 static 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
 402 static 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
 441 static 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
 495 static 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
 563 static 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
 610 static 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
 656 static 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
 724 static 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
 736 char  cesaNullPlainHexText[]   = "000000000000000000000000000000000000000000000000";
 737
 738 char  cesaPlainAsciiText[]     = "Now is the time for all ";
 739 char  cesaPlainHexEbc[]        = "4e6f77206973207468652074696d6520666f7220616c6c20";
 740 char  cesaCipherHexEcb[]       = "3fa40e8a984d48156a271787ab8883f9893d51ec4b563b53";
 741 char  cesaPlainHexCbc[]        = "1234567890abcdef4e6f77206973207468652074696d6520666f7220616c6c20";
 742 char  cesaCipherHexCbc[]       = "1234567890abcdefe5c7cdde872bf27c43e934008c389c0f683788499a7c05f6";
 743
 744 char  cesaAesPlainHexEcb[]     = "000102030405060708090a0b0c0d0e0f";
 745 char  cesaAes128cipherHexEcb[] = "0a940bb5416ef045f1c39458c653ea5a";
 746 char  cesaAes192cipherHexEcb[] = "0060bffe46834bb8da5cf9a61ff220ae";
 747 char  cesaAes256cipherHexEcb[] = "5a6e045708fb7196f02e553d02c3a692";
 748
 749 char  cesaAsciiStr1[]          = "Hi There";
 750 char  cesaDataHexStr1[]        = "4869205468657265";
 751 char  cesaHmacMd5digestHex1[]  = "9294727a3638bb1c13f48ef8158bfc9d";
 752 char  cesaHmacSha1digestHex1[] = "b617318655057264e28bc0b6fb378c8ef146be00";
 753 char  cesaDataAndMd5digest1[]  = "48692054686572659294727a3638bb1c13f48ef8158bfc9d";
 754 char  cesaDataAndSha1digest1[] = "4869205468657265b617318655057264e28bc0b6fb378c8ef146be00";
 755
 756 char  cesaAesPlainText[]       = "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
 757                                  "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
 758                                  "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
 759                                  "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf";
 760
 761 char  cesaAes128CipherCbc[]    = "c30e32ffedc0774e6aff6af0869f71aa"
 762                                  "0f3af07a9a31a9c684db207eb0ef8e4e"
 763                                  "35907aa632c3ffdf868bb7b29d3d46ad"
 764                                  "83ce9f9a102ee99d49a53e87f4c3da55";
 765
 766 char  cesaAesIvPlainText[]     = "8ce82eefbea0da3c44699ed7db51b7d9"
 767                                  "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
 768                                  "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
 769                                  "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
 770                                  "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf";
 771
 772 char  cesaAes128IvCipherCbc[]  = "8ce82eefbea0da3c44699ed7db51b7d9"
 773                                  "c30e32ffedc0774e6aff6af0869f71aa"
 774                                  "0f3af07a9a31a9c684db207eb0ef8e4e"
 775                                  "35907aa632c3ffdf868bb7b29d3d46ad"
 776                                  "83ce9f9a102ee99d49a53e87f4c3da55";
 777
 778 char  cesaAesCtrPlain[]        = "00E0017B27777F3F4A1786F000000001"
 779                                  "000102030405060708090A0B0C0D0E0F"
 780                                  "101112131415161718191A1B1C1D1E1F"
 781                                  "20212223";
 782
 783 char  cesaAesCtrCipher[]       = "00E0017B27777F3F4A1786F000000001"
 784                                  "C1CF48A89F2FFDD9CF4652E9EFDB72D7"
 785                                  "4540A42BDE6D7836D59A5CEAAEF31053"
 786                                  "25B2072F";
 787
 788
 789
 790 /* Input cesaHmacHex3 is '0xdd' repeated 50 times */
 791 char  cesaHmacMd5digestHex3[]  = "56be34521d144c88dbb8c733f0e8b3f6";
 792 char  cesaHmacSha1digestHex3[] = "125d7342b9ac11cd91a39af48aa17b4f63f175d3";
 793 char  cesaDataHexStr3[50*2+1]          = "";
 794 char  cesaDataAndMd5digest3[sizeof(cesaDataHexStr3)+sizeof(cesaHmacMd5digestHex3)+8*2+1] = "";
 795 char  cesaDataAndSha1digest3[sizeof(cesaDataHexStr3)+sizeof(cesaHmacSha1digestHex3)+8*2+1] = "";
 796
 797 /* Ascii string is "abc" */
 798 char hashHexStr3[] = "616263";
 799 char hashMd5digest3[] = "900150983cd24fb0d6963f7d28e17f72";
 800 char hashSha1digest3[] = "a9993e364706816aba3e25717850c26c9cd0d89d";
 801
 802 char hashHexStr80[]     = "31323334353637383930"
 803                           "31323334353637383930"
 804                           "31323334353637383930"
 805                           "31323334353637383930"
 806                           "31323334353637383930"
 807                           "31323334353637383930"
 808                           "31323334353637383930"
 809                           "31323334353637383930";
 810
 811 char hashMd5digest80[]           = "57edf4a22be3c955ac49da2e2107b67a";
 812
 813 char tripleDesThenMd5digest80[]  = "b7726a03aad490bd6c5a452a89a1b271";
 814 char tripleDesThenSha1digest80[] = "b2ddeaca91030eab5b95a234ef2c0f6e738ff883";
 815
 816 char cbc3desThenMd5digest80[]    = "6f463057e1a90e0e91ae505b527bcec0";
 817 char cbc3desThenSha1digest80[]   = "1b002ed050be743aa98860cf35659646bb8efcc0";
 818
 819 char cbcAes128ThenMd5digest80[]  = "6b6e863ac5a71d15e3e9b1c86c9ba05f";
 820 char cbcAes128ThenSha1digest80[] = "13558472d1fc1c90dffec6e5136c7203452d509b";
 821
 822
 823 static 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  */
 862 static 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  */
 911 static 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  */
 961 static 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  */
1013 static 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  */
1064 static 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  */
1114 static 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  */
1168 static 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  */
1201 static 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  */
1233 static 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  */
1267 static 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  */
1300 static 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  */
1333 static 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
1356 void    cesaTestPrintStatus(void);
1357
1358
1359 /*------------------------- LOCAL FUNCTIONs ---------------------------------*/
1360 MV_STATUS testCmd(int sid, int iter, MV_CESA_COMMAND* pCmd,
1361                   MV_CESA_TEST_SESSION* pTestSession, MV_U8* pIV, int ivSize);
1362 MV_STATUS testClose(int idx);
1363 MV_STATUS testOpen(int idx);
1364 void close_session(int sid);
1365 void cesaTestCheckReady(const MV_CESA_RESULT *r);
1366 void cesaCheckReady(MV_CESA_RESULT* r);
1367 void printTestResults(int idx, MV_STATUS status, int checkMode);
1368 void cesaLastResult(void);
1369 void cesaTestPrintReq(int req, int offset, int size);
1370
1371 void cesaTestPrintStatus(void);
1372 void cesaTestPrintSession(int idx);
1373 void sizeTest(int testIdx, int iter, int checkMode);
1374 void multiTest(int iter, int reqSize, int checkMode);
1375 void oneTest(int testIdx, int caseIdx,int iter, int reqSize, int checkMode);
1376 void multiSizeTest(int idx, int iter, int checkMode, char* inputData);
1377 void cesaTest(int iter, int reqSize, int checkMode);
1378 void cesaOneTest(int testIdx, int caseIdx,int iter, int reqSize, int checkMode);
1379 void combiTest(int iter, int reqSize, int checkMode);
1380 void shaTest(int iter, int reqSize, int checkMode);
1381 void mdTest(int iter, int reqSize, int checkMode);
1382 void aesTest(int iter, int reqSize, int checkMode);
1383 void tripleDesTest(int iter, int reqSize, int checkMode);
1384 void desTest(int iter, int reqSize, int checkMode);
1385 void cesaTestStop(void);
1386 MV_STATUS testRun(int idx, int caseIdx, int iter,int reqSize, int checkMode);
1387 void cesaTestStart(int bufNum, int bufSize);
1388
1389
1390 static 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
1414 static 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
1423 static 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
1473 static 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
1500 static  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 */
1523 void    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
1539 void    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
1546 void    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
1578 void 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
1664 static int cesaTestReadyIsr(void *arg)
1665 #else
1666 #ifdef __KERNEL__
1667 static irqreturn_t cesaTestReadyIsr( int irq , void *dev_id)
1668 #endif
1669 #ifdef MV_VXWORKS
1670 void   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
1717 void
1718 cesaTestCheckReady(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
1730 static 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
1746 void 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
1758 MV_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
1824 MV_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
1849 MV_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
2006 void    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
2225 MV_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
2408 void 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
2435 void    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
2474 void    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
2513 void    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
2589 void    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
2634 void    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
2679 void    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
2746 void    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
2765 void    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
2789 void    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
2922 void    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
2968 void    loopback_test(int idx, int iter, int size, char* pPlainData)
2969 {
2970 }
2971
2972
2973 #if defined(MV_VXWORKS)
2974 int testMode = 0;
2975 unsigned __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
2999 void 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
3017 void 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
3032 void 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
3049 extern void    mvCesaDebugSA(short sid, int mode);
3050 void    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
3072 void    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 }