drv: sa: Add USE_DKEK flag support
[keystone-rtos/sa-lld.git] / src / proto / datamode / sallddm.c
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;
75     
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   }
81   
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   }
87   
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)
122     
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     }    
146     
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;
157         
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;    
164             
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;
172             
173 #if !defined(NSS_LITE) && !defined(NSS_LITE2)
174         case sa_CipherMode_KASUMI_F8:
175             if((pDataModeConfig->ivSize != 8))
176                 return (FALSE);    
177             break;
178             
179         case sa_CipherMode_SNOW3G_F8:
180             if((pDataModeConfig->ivSize != 16))
181                 return (FALSE);    
182             break;
183             
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;     
192         
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        
201         
202         default:
203             return (FALSE);
204     }
205     
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;
216             
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;
223             
224         case sa_AuthMode_KASUMI_F9:
225             if((pDataModeConfig->ivSize != 8))
226                return (FALSE);
227             break;
228             
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;
246             
247         default:
248             return(FALSE);
249     }
250     
252   return TRUE;
253 }            
254            
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)
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;
289             
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         }
308         
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             }
319             
320             if ((ret = salld_data_mode_set_cmdl(inst)) != sa_ERR_OK)
321             {
322                 return(ret);
323             }
324             
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;
334         
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;
339             
340             if(!salld_data_mode_setup_key(inst, pComInfo, pKeyParams))
341                 return(sa_ERR_PARAMS);
342         }    
343     }   
344     break;
345     
346     default:
347         return (sa_ERR_PARAMS);
349   }
350   return (sa_ERR_OK);
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)
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);
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) 
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;
401   
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;
411     
412     if (!(pPayloadInfo->authSize & 0x7))
413     {
414         Sa_PktDesc_t *pPktDesc = &pPktInfo->pktDesc;
415         int paddingSegIndex = pPktDesc->nSegments - 1;        
416         
417         /* The authentication data is 8-byte aligned, padding is required */
418         if(pPktDesc->size != (pPayloadInfo->authSize + pPayloadInfo->authOffset))
419             return(sa_ERR_GEN);
420             
421         if((pPktDesc->segAllocSizes[paddingSegIndex] - pPktDesc->segUsedSizes[paddingSegIndex]) < 8)
422             return(sa_ERR_GEN);
423             
424         pPadding = (uint8_t *)pPktDesc->segments[paddingSegIndex];
425         pPadding += pPktDesc->segUsedSizes[paddingSegIndex];    
426             
427         memcpy(pPadding,
428                txInst->comInfo.config.enc?saKasumiF9PaddingDown:saKasumiF9PaddingUp,
429                8);        
430             
431         pPktDesc->size += 8;
432         pPktDesc->segUsedSizes[paddingSegIndex] += 8;
433         pPayloadInfo->authSize += 8;
434     }
435   
436   }
438   /* Encrypt and Authenticate Packet(s) */
439   ret_code = salld_data_mode_update_cmdl(inst, pPktInfo);
440   
441   if(ret_code != sa_ERR_OK)
442     return (ret_code);  
443     
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);
458       
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) 
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;
478   
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;
486     
487     if (!(pPayloadInfo->authSize & 0x7))
488     {
489         Sa_PktDesc_t *pPktDesc = &pPktInfo->pktDesc;
490         int paddingSegIndex = pPktDesc->nSegments - 1;
491         int numBytes = 8;  
492         
493         pPktDesc->size -= 8;
494         
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                 }
514                     
515             }
516         }
517     }
518   
519   }
521   return (sa_ERR_OK);
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) 
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);
592     
593   Sa_osalBeginScAccess((void *)pScInfo->scBuf, pScInfo->scSize);
594   
595   memset((void *) pScInfo->scBuf, 0, SALLD_BYTE_TO_WORD(pScInfo->scSize));
596   
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);
614     
615   }
616   
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   }
633   
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     {
685     
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   }
696   
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);
718     
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);
747   
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));
752   
753     pktWrite16bits_m(ctxIn, SALLD_FIELDOFFSET(saCtxProtoDm_t, firstEngIdTagSize), 
754                      SALLD_MK_UINT16(firstEngId, tagSize));
755                                      
756   }
757   #endif
758   
759   /* Security Context swizzling */
760   salld_swiz_128((uint8_t*) pScInfo->scBuf, (uint8_t*) pScInfo->scBuf, pScInfo->scSize);
761   
762   Sa_osalEndScAccess((void *)pScInfo->scBuf, pScInfo->scSize);
763   
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);
783   
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)
805   salldDataModeInst_t *inst = (salldDataModeInst_t *)salldInst;
806   int16_t ret = sa_ERR_OK;
807   
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   }
817   
818   return(ret);
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 = 
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 };
839            
840    
841 /* Nothing past this point */