1 /******************************************************************************
2 * FILE PURPOSE: Data Mode Main File
3 ******************************************************************************
4 * FILE NAME: sallddm.c
5 *
6 * DESCRIPTION: The main module for Data Mode Code
7 *
8 * (C) Copyright 2009-2014, Texas Instruments Inc.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 *
14 * Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 *
17 * Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the
20 * distribution.
21 *
22 * Neither the name of Texas Instruments Incorporated nor the names of
23 * its contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
27 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
28 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
29 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
30 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
31 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
32 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
33 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
34 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
35 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
36 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 *
38 */
39 /* RTSC header files */
41 /* Standard include files */
42 #include <string.h>
44 /* SALLD header files */
45 #include <ti/drv/sa/salld.h>
46 #include <ti/drv/sa/sa_osal.h>
47 #include "src/salldloc.h"
48 #include "src/salldport.h"
49 #include "sallddm.h"
50 #include "sallddmloc.h"
52 /* Defined for testing. Should be moved to makedefs.mk */
53 #define dmGetChID(mid_chnum) ( (((uint16_t)(mid_chnum)) & 0x00FF )-1)
55 /****************************************************************************
56 * FUNCTION PURPOSE: Data Mode Key Setup
57 ****************************************************************************
58 * DESCRIPTION: Update the Data Mode channel key information based on the input
59 * parameters.
60 *
61 * uint16_t salld_data_mode_setup_key(
62 * salldDataModeInst_t* inst -> Point to Data Mode channel instance
63 * salldDataModeComInfo_t* pComInfo -> pointer to the instance key storage
64 * Sa_DataModeKeyParams_t* pKeyParams) -> pointer to the key configuration
65 * parameters.
66 *
67 * Return values: FALSE : invalid parameters
68 * TRUE: successful updtae
69 *
70 ***************************************************************************/
71 uint16_t salld_data_mode_setup_key(salldDataModeInst_t *inst,
72 salldDataModeComInfo_t* pComInfo, Sa_DataModeKeyParams_t* pKeyParams)
73 {
74 uint16_t ctrlBitMap = pKeyParams->ctrlBitfield;
76 if(ctrlBitMap & sa_DATA_MODE_KEY_CTRL_ENC_KEY)
77 {
78 /* Copy Encryption Key */
79 memcpy(pComInfo->sessionEncKey, pKeyParams->sessionEncKey, pComInfo->config.sessionEncKeySize);
80 }
82 if( ctrlBitMap & sa_DATA_MODE_KEY_CTRL_MAC_KEY)
83 {
84 /* Copy MAC Key */
85 memcpy(pComInfo->sessionMacKey, pKeyParams->sessionAuthKey, pComInfo->config.sessionMacKeySize);
86 }
88 if( ctrlBitMap & sa_DATA_MODE_KEY_CTRL_SALT)
89 {
90 /* Copy session Salt */
91 memcpy(pComInfo->sessionSalt, pKeyParams->sessionSalt, pComInfo->config.sessionSaltSize);
92 }
94 if(ctrlBitMap & sa_DATA_MODE_KEY_USE_DKEK)
95 {
96 /* Set USE_DKEK flag */
97 pComInfo->config.ctrlBitMap |= sa_DM_CONFIG_USE_DKEK;
98 }
100 return TRUE;
101 }
103 /****************************************************************************
104 * FUNCTION PURPOSE: Verify Data Mode Configuration Parameters
105 ****************************************************************************
106 * DESCRIPTION: Verify Data Mode general configuration parameters for consistency
107 * with the encryption and authentication mode
108 *
109 * uint16_t salld_DM_verify_config_params(
110 * Sa_CipherMode_e cipherMode, -> Ciphering mode
111 * Sa_AuthMode_e authMode, -> Aurthentication Mode
112 * Sa_DataModeConfigParams_t* pDataModeConfig) ->pointer to the IPsec configuration
113 * parameters.
114 *
115 * Return values: FALSE : invalid parameters
116 * TRUE: valid parameters
117 *
118 ***************************************************************************/
119 static uint16_t salld_dm_verify_config_params(Sa_CipherMode_e cipherMode, Sa_AuthMode_e authMode,
120 Sa_DataModeConfigParams_t* pDataModeConfig)
121 {
123 /* Common Check */
124 if((pDataModeConfig->sessionEncKeySize > 32) ||
125 #if defined (NSS_LITE2)
126 (pDataModeConfig->priv > 3) ||
127 (pDataModeConfig->sessionMacKeySize > 64))
128 #else
129 (pDataModeConfig->sessionMacKeySize > 32))
130 #endif
131 return (FALSE);
133 #if defined(NSS_LITE) || defined(NSS_LITE2)
134 /* NSS LITE devices do not have Air Cipher Engines */
135 if ((pDataModeConfig->ctrlBitMap & sa_DM_CONFIG_SELECT_AIR_CIPHER_ENG) == sa_DM_CONFIG_SELECT_AIR_CIPHER_ENG)
136 return (FALSE);
137 #endif
139 if((authMode == sa_AuthMode_NULL) &&
140 ((cipherMode != sa_CipherMode_GCM) &&
141 (cipherMode != sa_CipherMode_CCM)))
142 {
143 if(pDataModeConfig->macSize != 0)
144 return(FALSE);
145 }
147 /* Ciphering mode specific check */
148 switch (cipherMode)
149 {
150 case sa_CipherMode_CCM:
151 if(((pDataModeConfig->ivSize + \
152 pDataModeConfig->sessionSaltSize) > 13) ||
153 (pDataModeConfig->aadSize > 14) ||
154 (authMode != sa_AuthMode_NULL))
155 return (FALSE);
156 break;
158 case sa_CipherMode_DES_CBC:
159 case sa_CipherMode_3DES_CBC:
160 if((pDataModeConfig->ivSize != 8) ||
161 (pDataModeConfig->sessionSaltSize != 0))
162 return (FALSE);
163 break;
165 case sa_CipherMode_GCM:
166 if(((pDataModeConfig->ivSize + \
167 pDataModeConfig->sessionSaltSize) != 12) ||
168 (pDataModeConfig->aadSize > 16) ||
169 (authMode != sa_AuthMode_NULL))
170 return (FALSE);
171 break;
173 #if !defined(NSS_LITE) && !defined(NSS_LITE2)
174 case sa_CipherMode_KASUMI_F8:
175 if((pDataModeConfig->ivSize != 8))
176 return (FALSE);
177 break;
179 case sa_CipherMode_SNOW3G_F8:
180 if((pDataModeConfig->ivSize != 16))
181 return (FALSE);
182 break;
184 case sa_CipherMode_AES_CTR:
185 case sa_CipherMode_AES_F8:
186 case sa_CipherMode_AES_CBC:
187 case sa_CipherMode_GSM_A53:
188 case sa_CipherMode_ECSD_A53:
189 case sa_CipherMode_GEA3:
190 case sa_CipherMode_NULL:
191 break;
193 #else
194 case sa_CipherMode_AES_CTR:
195 case sa_CipherMode_AES_F8:
196 case sa_CipherMode_AES_CBC:
197 case sa_CipherMode_NULL:
198 break;
200 #endif
202 default:
203 return (FALSE);
204 }
206 /* Encryption mode specific check */
207 switch (authMode)
208 {
209 case sa_AuthMode_GMAC:
210 if(((pDataModeConfig->ivSize + \
211 pDataModeConfig->sessionSaltSize) != 12) ||
212 (pDataModeConfig->aadSize > 16) ||
213 (cipherMode != sa_CipherMode_NULL))
214 return (FALSE);
215 break;
217 case sa_AuthMode_GMAC_AH:
218 if((pDataModeConfig->ivSize != 8) ||
219 (pDataModeConfig->sessionSaltSize != 4) ||
220 (cipherMode != sa_CipherMode_NULL))
221 return (FALSE);
222 break;
224 case sa_AuthMode_KASUMI_F9:
225 if((pDataModeConfig->ivSize != 8))
226 return (FALSE);
227 break;
229 case sa_AuthMode_MD5:
230 case sa_AuthMode_SHA1:
231 case sa_AuthMode_SHA2_224:
232 case sa_AuthMode_SHA2_256:
233 case sa_AuthMode_SHA2_384:
234 case sa_AuthMode_SHA2_512:
235 case sa_AuthMode_HMAC_MD5:
236 case sa_AuthMode_HMAC_SHA1:
237 case sa_AuthMode_HMAC_SHA2_224:
238 case sa_AuthMode_HMAC_SHA2_256:
239 case sa_AuthMode_CMAC:
240 case sa_AuthMode_CBC_MAC:
241 case sa_AuthMode_AES_XCBC:
242 case sa_AuthMode_NULL:
243 case sa_AuthMode_HMAC_SHA2_384:
244 case sa_AuthMode_HMAC_SHA2_512:
245 break;
247 default:
248 return(FALSE);
249 }
252 return TRUE;
253 }
256 /****************************************************************************
257 * FUNCTION PURPOSE: Data Mode Control
258 ****************************************************************************
259 * DESCRIPTION: Data Mode Control functions
260 *
261 * int16_t salld_data_mode_control (
262 * void *salldInst - a pointer to SALLD channel instance
263 * void *ctrl) - a pointer to control structure
264 *
265 * Return values: sa_ERR_OK
266 * sa_ERR_GEN
267 * sa_ERR_PARAMS
268 *
269 ***************************************************************************/
270 int16_t salld_data_mode_control (void *salldInst, void *salldCtrl)
271 {
272 salldDataModeInst_t *inst = (salldDataModeInst_t *)salldInst;
273 salldDataModeTxInst_t *txInst = &inst->txInst;
274 Sa_ChanCtrlInfo_t *ctrl = (Sa_ChanCtrlInfo_t *)salldCtrl;
275 uint16_t bitmap;
276 int16_t ret;
278 switch(ctrl->ctrlType)
279 {
280 /* SALLD cipher, mac and key size selection */
281 case sa_CHAN_CTRL_GEN_CONFIG:
282 {
283 bitmap = ctrl->ctrlInfo.gen.validBitfield;
284 if( bitmap & sa_CONTROLINFO_VALID_TX_CTRL)
285 {
286 /* Input parameters check */
287 Sa_GenConfigParams_t* pGenConfig = &ctrl->ctrlInfo.gen.txCtrl;
288 Sa_DataModeConfigParams_t* pDataModeConfig = &ctrl->ctrlInfo.gen.txCtrl.params.data;
290 if (salld_dm_verify_config_params(pGenConfig->cipherMode, pGenConfig->authMode, pDataModeConfig))
291 {
292 txInst->cipherMode = pGenConfig->cipherMode;
293 txInst->authMode = pGenConfig->authMode;
294 txInst->destInfo = pGenConfig->destInfo;
295 txInst->comInfo.config = *pDataModeConfig;
296 if(txInst->cipherMode == sa_CipherMode_NULL)
297 txInst->comInfo.config.enc1st = FALSE;
298 }
299 else
300 {
301 return(sa_ERR_PARAMS);
302 }
303 #if defined(NSS_LITE2)
304 txInst->comInfo.config.priv = pDataModeConfig->priv;
305 txInst->comInfo.config.privId = pDataModeConfig->privId;
306 #endif
307 }
309 /*
310 * Is it time to form and register security context?
311 */
312 if(!SALLD_TEST_STATE_TX_SC_VALID(&inst->salldInst) &&
313 SALLD_TEST_STATE_TX_ON(&inst->salldInst))
314 {
315 if ((ret = salld_data_mode_set_sc(inst)) != sa_ERR_OK)
316 {
317 return(ret);
318 }
320 if ((ret = salld_data_mode_set_cmdl(inst)) != sa_ERR_OK)
321 {
322 return(ret);
323 }
325 SALLD_SET_STATE_TX_SC_VALID(&inst->salldInst, 1);
326 }
327 }
328 break;
330 /* Master key and Salt setup for ac */
331 case sa_CHAN_CTRL_KEY_CONFIG:
332 {
333 bitmap = ctrl->ctrlInfo.key.ctrlBitfield;
335 if (bitmap & sa_KEY_CONTROL_TX_KEY_VALID)
336 {
337 Sa_DataModeKeyParams_t* pKeyParams = &ctrl->ctrlInfo.key.txKey.data;
338 salldDataModeComInfo_t* pComInfo = &txInst->comInfo;
340 if(!salld_data_mode_setup_key(inst, pComInfo, pKeyParams))
341 return(sa_ERR_PARAMS);
342 }
343 }
344 break;
346 default:
347 return (sa_ERR_PARAMS);
349 }
350 return (sa_ERR_OK);
351 }
353 /******************************************************************************
354 * FUNCTION PURPOSE: Data Mode Get Stats
355 ******************************************************************************
356 * DESCRIPTION: Extract Data Mode related statistics from the instance structure
357 *
358 * void salld_data_mode_get_stats (
359 * void *salldInst, - A pointer to SALLD instance
360 * uint16_t flags, - various control flags
361 * void *stats) - The stat structure
362 *
363 * Return values: sa_ERR_OK
364 *
365 *****************************************************************************/
366 int16_t salld_data_mode_get_stats (void *salldInst, uint16_t flags, void *stats)
367 {
368 Sa_DataModeStats_t *pStats = (Sa_DataModeStats_t *) stats;
369 salldDataModeInst_t *inst = (salldDataModeInst_t *) salldInst;
370 salldDataModeTxInst_t *txInst = (salldDataModeTxInst_t *) &inst->txInst;
372 pStats->pktHi = txInst->packetMsw;
373 pStats->pktLo = txInst->packetLsw;
375 return (sa_ERR_OK);
376 }
378 static const uint8_t saKasumiF9PaddingUp[8] = {0x40, 0, 0, 0, 0, 0, 0, 0};
379 static const uint8_t saKasumiF9PaddingDown[8] = {0xC0, 0, 0, 0, 0, 0, 0, 0};
381 /******************************************************************************
382 * FUNCTION PURPOSE: Data Mode Send Data
383 ******************************************************************************
384 * DESCRIPTION:
385 *
386 * void salld_data_mode_send_data (
387 * void *salldInst, - A pointer to SALLD Data Mode instance
388 * void *pktInfo, - packet pointer
389 * uint16_t clear)
390 *
391 * Perform the following actions:
392 * - Update statistics
393 *
394 *****************************************************************************/
395 int16_t salld_data_mode_send_data (void *salldInst, void *pktInfo, uint16_t clear)
396 {
397 salldDataModeInst_t *inst = (salldDataModeInst_t *)salldInst;
398 salldDataModeTxInst_t *txInst = &inst->txInst;
399 Sa_PktInfo_t* pPktInfo = (Sa_PktInfo_t*)pktInfo;
400 int16_t ret_code;
402 /* Kasumi-F9 Padding:
403 * The SASS is not able to generate Kasumi-F9 padding when the number of bytes to be authenticated is multiple of 8.
404 * Therefore, we need to perform Kasumi-F9 padding for this special case
405 * Assumption:the padding bytes can be added to the end of data segments
406 */
407 if (txInst->authMode == sa_AuthMode_KASUMI_F9)
408 {
409 Sa_PayloadInfo_t *pPayloadInfo = &pPktInfo->payloadInfo;
410 uint8_t *pPadding;
412 if (!(pPayloadInfo->authSize & 0x7))
413 {
414 Sa_PktDesc_t *pPktDesc = &pPktInfo->pktDesc;
415 int paddingSegIndex = pPktDesc->nSegments - 1;
417 /* The authentication data is 8-byte aligned, padding is required */
418 if(pPktDesc->size != (pPayloadInfo->authSize + pPayloadInfo->authOffset))
419 return(sa_ERR_GEN);
421 if((pPktDesc->segAllocSizes[paddingSegIndex] - pPktDesc->segUsedSizes[paddingSegIndex]) < 8)
422 return(sa_ERR_GEN);
424 pPadding = (uint8_t *)pPktDesc->segments[paddingSegIndex];
425 pPadding += pPktDesc->segUsedSizes[paddingSegIndex];
427 memcpy(pPadding,
428 txInst->comInfo.config.enc?saKasumiF9PaddingDown:saKasumiF9PaddingUp,
429 8);
431 pPktDesc->size += 8;
432 pPktDesc->segUsedSizes[paddingSegIndex] += 8;
433 pPayloadInfo->authSize += 8;
434 }
436 }
438 /* Encrypt and Authenticate Packet(s) */
439 ret_code = salld_data_mode_update_cmdl(inst, pPktInfo);
441 if(ret_code != sa_ERR_OK)
442 return (ret_code);
444 /* Pass the software Info in the packet */
445 pPktInfo->validBitMap |= sa_PKT_INFO_VALID_SW_INFO;
446 pPktInfo->swInfo = txInst->swInfo;
448 if(txInst->packetLsw == 0xFFFFFFFFu)
449 {
450 txInst->packetLsw = 0u;
451 txInst->packetMsw++;
452 }
453 else
454 {
455 txInst->packetLsw++;
456 }
457 return(sa_ERR_OK);
459 } /* salld_data_mode_send_data */
461 /******************************************************************************
462 * FUNCTION PURPOSE: Data Mode Receive Data
463 ******************************************************************************
464 * DESCRIPTION:
465 *
466 * void salld_data_mode_receive_data (
467 * void *salldInst, - A pointer to SALLD instance
468 * void *pktInfo) - packet pointer
469 *
470 * Not Supported
471 *****************************************************************************/
472 int16_t salld_data_mode_receive_data (void *salldInst, void *pktInfo)
473 {
474 /* Kasumi-F9 De-Padding */
475 salldDataModeInst_t *inst = (salldDataModeInst_t *)salldInst;
476 salldDataModeTxInst_t *txInst = &inst->txInst;
477 Sa_PktInfo_t* pPktInfo = (Sa_PktInfo_t*)pktInfo;
479 /* Kasumi-F9 Padding:
480 * The SASS is not able to generate Kasumi-F9 padding when the number of bytes to be authenticated is multiple of 8.
481 * Therefore, we need to perform Kasumi-F9 padding for this special case
482 */
483 if (txInst->authMode == sa_AuthMode_KASUMI_F9)
484 {
485 Sa_PayloadInfo_t *pPayloadInfo = &pPktInfo->payloadInfo;
487 if (!(pPayloadInfo->authSize & 0x7))
488 {
489 Sa_PktDesc_t *pPktDesc = &pPktInfo->pktDesc;
490 int paddingSegIndex = pPktDesc->nSegments - 1;
491 int numBytes = 8;
493 pPktDesc->size -= 8;
495 while (numBytes)
496 {
497 if (pPktDesc->segUsedSizes[paddingSegIndex] >= numBytes)
498 {
499 pPktDesc->segUsedSizes[paddingSegIndex] -= numBytes;
500 numBytes = 0;
501 }
502 else
503 {
504 numBytes -= pPktDesc->segUsedSizes[paddingSegIndex];
505 pPktDesc->segUsedSizes[paddingSegIndex] = 0;
506 if (paddingSegIndex)
507 {
508 paddingSegIndex--;
509 }
510 else
511 {
512 return(sa_ERR_GEN);
513 }
515 }
516 }
517 }
519 }
521 return (sa_ERR_OK);
522 }
524 /****************************************************************************
525 * FUNCTION PURPOSE: Construct Data Mode Security Context
526 ****************************************************************************
527 * DESCRIPTION: Construct Security Context from the configuration parameters
528 * for Data Mode (to-SA) operations
529 *
530 * uint16_t salld_data_mode_set_sc(
531 * salldIpsecInst_t* inst) -> Point to Data Mode channel instance
532 *
533 * Return values: sa_ERR_XXX
534 *
535 * Assumption: The same algorithm will be used for both encryption and
536 * authentication
537 *
538 ***************************************************************************/
539 int16_t salld_data_mode_set_sc(salldDataModeInst_t *inst)
540 {
541 salldObj_t *sysInst = (salldObj_t *)sa_CONV_OFFSET_TO_ADDR(salldLObj.instPoolBaseAddr, inst->salldInst.ownerInstOffset);
542 salldDataModeTxInst_t *txInst = &inst->txInst;
543 salldDataModeComInfo_t *pComInfo = &txInst->comInfo;
544 Sa_DataModeConfigParams_t *pConfig = &pComInfo->config;
545 Sa_ScReqInfo_t* pScInfo = &txInst->scInfo;
546 int16_t encCmdlSize, encScSize, encScOffset;
547 int16_t authCmdlSize, authScSize, authScOffset;
548 #if !defined(NSS_LITE) && !defined(NSS_LITE2)
549 int16_t acAlgorithm = SA_AC_ALGORITHM_GSM_A53;
550 #endif
551 saDMAReqInfo_t dmaReqInfo;
552 uint16_t useEnc;
553 uint16_t fRandomIV;
554 uint8_t firstEngId;
555 uint8_t tagSize;
556 #ifdef NSS_LITE2
557 uint32_t ctxAttrCtrlBitMap;
558 #endif
560 /*
561 * Calculate the security Context Size and allocate security Context
562 *
563 */
564 salld_sc_enc_get_info(txInst->cipherMode, pConfig->ivSize, &encCmdlSize, &encScSize, &pComInfo->encEngId, &fRandomIV, SALLD_TEST_SASS_GEN2(sysInst));
565 salld_sc_auth_get_info(txInst->authMode, &useEnc, &authCmdlSize, &authScSize, &pComInfo->authEngId);
566 pScInfo->scSize = SA_CTX_PHP_DATA_MODE_SIZE + encScSize + authScSize;
567 salldLObj.callOutFuncs.ScAlloc((Sa_ChanHandle)sa_CONV_ADDR_TO_OFFSET(salldLObj.instPoolBaseAddr,inst), pScInfo);
569 /* Fix the encrpytion engine ID that is set to use from Encryption Engine
570 when auth engine ID is Air Cipher OR if the channel is Air Cipher */
571 if (pComInfo->encEngId == SALLD_CMDL_ENGINE_ID_ES1)
572 {
573 if (((pConfig->ctrlBitMap & sa_DM_CONFIG_SELECT_AIR_CIPHER_ENG) == sa_DM_CONFIG_SELECT_AIR_CIPHER_ENG) ||
574 (pComInfo->authEngId == SALLD_CMDL_ENGINE_ID_ACS1))
575 {
576 pComInfo->encEngId = SALLD_CMDL_ENGINE_ID_ACS1;
577 }
578 }
580 #if !defined(NSS_LITE) && !defined(NSS_LITE2)
581 if (pComInfo->authEngId == SALLD_CMDL_ENGINE_ID_ES1)
582 {
583 if ((pConfig->ctrlBitMap & sa_DM_CONFIG_SELECT_AIR_CIPHER_ENG) == sa_DM_CONFIG_SELECT_AIR_CIPHER_ENG)
584 {
585 pComInfo->authEngId = SALLD_CMDL_ENGINE_ID_ACS1;
586 }
587 }
588 #endif
590 if(pScInfo->scBuf == (uintptr_t) NULL)
591 return(sa_ERR_NO_CTX_BUF);
593 Sa_osalBeginScAccess((void *)pScInfo->scBuf, pScInfo->scSize);
595 memset((void *) pScInfo->scBuf, 0, SALLD_BYTE_TO_WORD(pScInfo->scSize));
597 /* Prepare PHP Security Context */
598 memset(&dmaReqInfo, 0, sizeof(saDMAReqInfo_t));
599 dmaReqInfo.phpFetchSize = SA_CTX_DMA_SIZE_64;
600 /* Non-Air Ciphering condition */
601 if ((!useEnc) || pConfig->enc1st)
602 {
603 dmaReqInfo.engFetchSize[0] = SA_CTX_SIZE_TO_DMA_SIZE(encScSize);
604 dmaReqInfo.engFetchSize[1] = SA_CTX_SIZE_TO_DMA_SIZE(authScSize);
605 encScOffset = SALLD_BYTE_TO_WORD(SA_CTX_PHP_DATA_MODE_SIZE);
606 authScOffset = SALLD_BYTE_TO_WORD(SA_CTX_PHP_DATA_MODE_SIZE + encScSize);
607 }
608 else
609 {
610 dmaReqInfo.engFetchSize[0] = SA_CTX_SIZE_TO_DMA_SIZE(authScSize);
611 dmaReqInfo.engFetchSize[1] = SA_CTX_SIZE_TO_DMA_SIZE(encScSize);
612 authScOffset = SALLD_BYTE_TO_WORD(SA_CTX_PHP_DATA_MODE_SIZE);
613 encScOffset = SALLD_BYTE_TO_WORD(SA_CTX_PHP_DATA_MODE_SIZE + authScSize);
615 }
617 /* Air Ciphering condition */
618 /* Assumption: Air Ciphering algorithm will be used as a pair */
619 if (pConfig->enc1st && (pComInfo->encEngId == SALLD_CMDL_ENGINE_ID_ACS1))
620 {
621 dmaReqInfo.engFetchSize[0] = SA_CTX_SIZE_TO_DMA_SIZE(encScSize);
622 dmaReqInfo.engFetchSize[1] = SA_CTX_SIZE_TO_DMA_SIZE(authScSize);
623 encScOffset = SALLD_BYTE_TO_WORD(SA_CTX_PHP_DATA_MODE_SIZE);
624 authScOffset = SALLD_BYTE_TO_WORD(SA_CTX_PHP_DATA_MODE_SIZE + encScSize);
625 }
626 else if (pComInfo->authEngId == SALLD_CMDL_ENGINE_ID_ACS1)
627 {
628 dmaReqInfo.engFetchSize[0] = SA_CTX_SIZE_TO_DMA_SIZE(authScSize);
629 dmaReqInfo.engFetchSize[1] = SA_CTX_SIZE_TO_DMA_SIZE(encScSize);
630 authScOffset = SALLD_BYTE_TO_WORD(SA_CTX_PHP_DATA_MODE_SIZE);
631 encScOffset = SALLD_BYTE_TO_WORD(SA_CTX_PHP_DATA_MODE_SIZE + authScSize);
632 }
634 dmaReqInfo.phpEvictSize = SA_CTX_DMA_SIZE_64;
636 #ifdef NSS_LITE2
637 if (pConfig->ctrlBitMap & sa_DM_CONFIG_PROMOTE_CHANNEL)
638 {
639 ctxAttrCtrlBitMap = SA_CTX_SA2UL_ALLOW_PROMOTE | SA_CTX_SA2UL_SECURE;
640 }
641 else if (pConfig->ctrlBitMap & sa_DM_CONFIG_DEMOTE_CHANNEL)
642 {
643 ctxAttrCtrlBitMap = SA_CTX_SA2UL_ALLOW_DEMOTE | SA_CTX_SA2UL_SECURE;
644 }
645 else
646 {
647 /* Regular channel, non secure */
648 ctxAttrCtrlBitMap = 0;
649 }
651 if (pConfig->ctrlBitMap & sa_DM_CONFIG_USE_SECURE_CTX_FOR_NON_SECURE_CHANNEL)
652 {
653 ctxAttrCtrlBitMap |= SA_CTX_SA2UL_ALLOW_NONSEC | SA_CTX_SA2UL_SECURE;
654 }
656 if (pConfig->priv)
657 {
658 /* Set for supervior mode */
659 ctxAttrCtrlBitMap |= SA_CTX_SA2UL_SET_PRIV;
660 }
662 salld_set_sc_scctl(&dmaReqInfo, &txInst->destInfo, SA_CTX_PKT_TYPE_NONE,
663 pScInfo->scID, (tword *) pScInfo->scBuf, ctxAttrCtrlBitMap, pConfig->priv, pConfig->privId);
664 #else
665 {
666 salld_set_sc_phpCommom(&dmaReqInfo, &txInst->destInfo, SA_CTX_PKT_TYPE_NONE,
667 pScInfo->scID, (tword *) pScInfo->scBuf);
668 }
669 #endif
671 /* Prepare Security Context for the encryption Engine */
672 if (encScSize)
673 {
674 #if !defined(NSS_LITE) && !defined(NSS_LITE2)
675 if (pComInfo->encEngId == SALLD_CMDL_ENGINE_ID_ACS1)
676 {
677 salld_set_sc_acEnc(txInst->cipherMode, pConfig->sessionEncKeySize,
678 pComInfo->sessionEncKey, NULL, pConfig->enc,
679 (tword *)pScInfo->scBuf + encScOffset,
680 &acAlgorithm, SALLD_TEST_SASS_GEN2(sysInst));
681 }
682 else
683 #endif
684 {
686 salld_set_sc_enc(sa_PT_NULL, txInst->cipherMode, pConfig->sessionEncKeySize,
687 pComInfo->sessionEncKey, (uint8_t) pConfig->aadSize, pConfig->enc,
688 (tword *)pScInfo->scBuf + encScOffset);
689 }
691 if (pConfig->ctrlBitMap & sa_DM_CONFIG_USE_DKEK)
692 {
693 pktWrite8bits_m((tword *)pScInfo->scBuf, encScOffset, SA_ENC_MODE_USE_DKEK);
694 }
695 }
697 /* Prepare Security Context for the authentication Engine */
698 if (authScSize)
699 {
700 #if !defined(NSS_LITE) && !defined(NSS_LITE2)
701 if (pComInfo->authEngId == SALLD_CMDL_ENGINE_ID_ACS1)
702 {
703 salld_set_sc_acAuth(txInst->authMode, pConfig->sessionMacKeySize,
704 pComInfo->sessionMacKey,
705 (tword *) pScInfo->scBuf + authScOffset,
706 &acAlgorithm,
707 pConfig->enc?SA_KASUMI_AUTH_DIR1:SA_KASUMI_AUTH_DIR0,
708 SALLD_TEST_SASS_GEN2(sysInst));
709 }
710 else
711 #endif
712 {
713 if (useEnc)
714 {
715 salld_set_sc_enc(sa_PT_NULL, txInst->authMode, pConfig->sessionMacKeySize,
716 pComInfo->sessionMacKey, (uint8_t) pConfig->aadSize, FALSE,
717 (tword *) pScInfo->scBuf + authScOffset);
719 }
720 else
721 {
722 salld_set_sc_auth(txInst->authMode, pConfig->sessionMacKeySize,
723 pComInfo->sessionMacKey,
724 (tword *) pScInfo->scBuf + authScOffset);
725 }
726 }
727 }
729 if ((pComInfo->encEngId == SALLD_CMDL_ENGINE_NONE) && (pComInfo->authEngId == SALLD_CMDL_ENGINE_NONE))
730 {
731 firstEngId = SALLD_CMDL_FINAL_ENGINE_ID;
732 }
733 else if ((pComInfo->encEngId == SALLD_CMDL_ENGINE_NONE))
734 {
735 firstEngId = pComInfo->authEngId;
736 }
737 else if ((pComInfo->authEngId == SALLD_CMDL_ENGINE_NONE))
738 {
739 firstEngId = pComInfo->encEngId;
740 }
741 else
742 {
743 firstEngId = pConfig->enc1st?pComInfo->encEngId:pComInfo->authEngId;
744 }
746 tagSize = SALLD_ROUND_UP(pConfig->macSize, 8);
748 #ifdef SALLD_DATA_MODE_USE_PHP
749 /* Construct the Data Mode specific Security Context */
750 {
751 tword* ctxIn = (tword *)(pScInfo->scBuf + SALLD_BYTE_TO_WORD(SA_CTX_PHP_COMMON_SIZE));
753 pktWrite16bits_m(ctxIn, SALLD_FIELDOFFSET(saCtxProtoDm_t, firstEngIdTagSize),
754 SALLD_MK_UINT16(firstEngId, tagSize));
756 }
757 #endif
759 /* Security Context swizzling */
760 salld_swiz_128((uint8_t*) pScInfo->scBuf, (uint8_t*) pScInfo->scBuf, pScInfo->scSize);
762 Sa_osalEndScAccess((void *)pScInfo->scBuf, pScInfo->scSize);
764 /* Prepare the SW Info Words */
765 #ifndef SALLD_DATA_MODE_USE_PHP
766 #if defined(NSS_LITE2)
767 salld_set_swInfo2(firstEngId, 0,
768 &txInst->destInfo,
769 pScInfo, &txInst->swInfo, tagSize);
770 #else
771 salld_set_swInfo(firstEngId, 0,
772 &txInst->destInfo,
773 pScInfo, &txInst->swInfo, tagSize);
774 #endif
775 #else
776 /* Data packets enter PHP engine */
777 salld_set_swInfo(SALLD_CMDL_ENGINE_SRTP_AC_HPS1, 0,
778 &txInst->destInfo,
779 pScInfo, &txInst->swInfo, 0);
780 #endif
781 /* Store the scBuf internally as offset to suppor multiprocess */
782 pScInfo->scBuf = (uintptr_t) sa_CONV_ADDR_TO_OFFSET(salldLObj.scPoolBaseAddr, pScInfo->scBuf);
784 return (sa_ERR_OK);
785 }
787 /****************************************************************************
788 * FUNCTION PURPOSE: Data Mode Get SwInfo
789 ****************************************************************************
790 * DESCRIPTION: Data Mode Get SwInfo
791 *
792 * int16_t salld_data_mode_get_swInfo (
793 * Sa_ChanHandle handle - SALLD channel identifier
794 * uint16_t dir - packet directions
795 * Sa_SWInfo_t *pSwInfo) - a pointer to swInfo
796 *
797 * Return values: sa_ERR_OK
798 * sa_ERR_GEN
799 * sa_ERR_PARAMS
800 * sa_ERR_UNSUPPORTED
801 *
802 ***************************************************************************/
803 int16_t salld_data_mode_get_swInfo (void *salldInst, uint16_t dir, Sa_SWInfo_t* pChanSwInfo)
804 {
805 salldDataModeInst_t *inst = (salldDataModeInst_t *)salldInst;
806 int16_t ret = sa_ERR_OK;
808 if (dir == sa_PKT_DIR_TO_NETWORK)
809 {
810 salldDataModeTxInst_t *txInst = (salldDataModeTxInst_t *) &inst->txInst;
811 memcpy(pChanSwInfo, &txInst->swInfo, sizeof(Sa_SWInfo_t));
812 }
813 else
814 {
815 ret = sa_ERR_PARAMS;
816 }
818 return(ret);
819 }
821 /****************************************************************************
822 * Table PURPOSE: Data Mode function call table
823 ****************************************************************************
824 * DESCRIPTION: The tables are used to link Data Mode functions to the
825 * SALLD library if required
826 *
827 ***************************************************************************/
828 Sa_ProtocolCallTbl_t Sa_callTblDataMode =
829 {
830 sa_PT_NULL,
831 salld_data_mode_init,
832 salld_data_mode_control,
833 salld_data_mode_get_stats,
834 salld_data_mode_send_data,
835 salld_data_mode_receive_data,
836 salld_data_mode_close,
837 salld_data_mode_get_swInfo
838 };
841 /* Nothing past this point */