ad4e243433c2b367ee6bb8da0d7a72a84bc9d7f2
[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   return TRUE;
95
97 /****************************************************************************
98  * FUNCTION PURPOSE: Verify Data Mode Configuration Parameters 
99  ****************************************************************************
100  * DESCRIPTION: Verify Data Mode general configuration parameters for consistency
101  *              with the encryption and authentication mode
102  *
103  *  uint16_t salld_DM_verify_config_params(
104  *            Sa_CipherMode_e cipherMode,                  -> Ciphering mode
105  *            Sa_AuthMode_e   authMode,                    -> Aurthentication Mode
106  *            Sa_DataModeConfigParams_t*  pDataModeConfig) ->pointer to the IPsec configuration
107  *                                                    parameters.   
108  *                       
109  * Return values:  FALSE : invalid parameters
110  *                 TRUE:   valid parameters          
111  *
112  ***************************************************************************/
113 static uint16_t salld_dm_verify_config_params(Sa_CipherMode_e cipherMode, Sa_AuthMode_e authMode,
114                                               Sa_DataModeConfigParams_t*  pDataModeConfig)
116     
117     /* Common Check */
118     if((pDataModeConfig->sessionEncKeySize > 32) ||
119 #if defined (NSS_LITE2)
120        (pDataModeConfig->priv > 3)               ||
121        (pDataModeConfig->sessionMacKeySize > 64))
122 #else
123        (pDataModeConfig->sessionMacKeySize > 32))
124 #endif
125         return (FALSE);
127 #if defined(NSS_LITE) || defined(NSS_LITE2)
128     /* NSS LITE devices do not have Air Cipher Engines */
129     if ((pDataModeConfig->ctrlBitMap & sa_DM_CONFIG_SELECT_AIR_CIPHER_ENG) == sa_DM_CONFIG_SELECT_AIR_CIPHER_ENG)
130       return (FALSE);
131 #endif
133     if((authMode == sa_AuthMode_NULL) && 
134        ((cipherMode != sa_CipherMode_GCM) &&
135         (cipherMode != sa_CipherMode_CCM)))
136     {
137         if(pDataModeConfig->macSize != 0)
138             return(FALSE);
139     }    
140     
141     /* Ciphering mode specific check */
142     switch (cipherMode)
143     {
144         case sa_CipherMode_CCM:
145             if(((pDataModeConfig->ivSize                + \
146                  pDataModeConfig->sessionSaltSize) > 13) ||
147                 (pDataModeConfig->aadSize > 14)         ||
148                 (authMode != sa_AuthMode_NULL))
149                 return (FALSE);    
150             break;
151         
152         case sa_CipherMode_DES_CBC:
153         case sa_CipherMode_3DES_CBC:
154             if((pDataModeConfig->ivSize != 8)          ||
155                (pDataModeConfig->sessionSaltSize != 0))  
156                 return (FALSE);    
157             break;    
158             
159         case sa_CipherMode_GCM:
160             if(((pDataModeConfig->ivSize                 + \
161                  pDataModeConfig->sessionSaltSize) != 12) ||
162                 (pDataModeConfig->aadSize > 16)           ||
163                 (authMode != sa_AuthMode_NULL))
164                 return (FALSE);    
165             break;
166             
167 #if !defined(NSS_LITE) && !defined(NSS_LITE2)
168         case sa_CipherMode_KASUMI_F8:
169             if((pDataModeConfig->ivSize != 8))
170                 return (FALSE);    
171             break;
172             
173         case sa_CipherMode_SNOW3G_F8:
174             if((pDataModeConfig->ivSize != 16))
175                 return (FALSE);    
176             break;
177             
178         case sa_CipherMode_AES_CTR:
179         case sa_CipherMode_AES_F8:
180         case sa_CipherMode_AES_CBC:
181         case sa_CipherMode_GSM_A53:
182         case sa_CipherMode_ECSD_A53:
183         case sa_CipherMode_GEA3:
184         case sa_CipherMode_NULL:
185             break;     
186         
187 #else
188         case sa_CipherMode_AES_CTR:
189         case sa_CipherMode_AES_F8:
190         case sa_CipherMode_AES_CBC:
191         case sa_CipherMode_NULL:
192             break;     
194 #endif        
195         
196         default:
197             return (FALSE);
198     }
199     
200     /* Encryption mode specific check */
201     switch (authMode)
202     {
203         case sa_AuthMode_GMAC:
204           if(((pDataModeConfig->ivSize                 + \
205                pDataModeConfig->sessionSaltSize) != 12) ||
206               (pDataModeConfig->aadSize > 16)           ||
207                (cipherMode != sa_CipherMode_NULL)) 
208               return (FALSE);   
209             break;
210             
211         case sa_AuthMode_GMAC_AH:
212             if((pDataModeConfig->ivSize != 8)          ||
213                (pDataModeConfig->sessionSaltSize != 4) ||
214                (cipherMode != sa_CipherMode_NULL)) 
215                return (FALSE);
216             break;
217             
218         case sa_AuthMode_KASUMI_F9:
219             if((pDataModeConfig->ivSize != 8))
220                return (FALSE);
221             break;
222             
223         case sa_AuthMode_MD5:
224         case sa_AuthMode_SHA1:
225         case sa_AuthMode_SHA2_224:
226         case sa_AuthMode_SHA2_256:
227         case sa_AuthMode_SHA2_384:
228         case sa_AuthMode_SHA2_512:
229         case sa_AuthMode_HMAC_MD5:
230         case sa_AuthMode_HMAC_SHA1:
231         case sa_AuthMode_HMAC_SHA2_224:
232         case sa_AuthMode_HMAC_SHA2_256:
233         case sa_AuthMode_CMAC:
234         case sa_AuthMode_CBC_MAC:
235         case sa_AuthMode_AES_XCBC:
236         case sa_AuthMode_NULL:
237         case sa_AuthMode_HMAC_SHA2_384:
238         case sa_AuthMode_HMAC_SHA2_512:
239             break;
240             
241         default:
242             return(FALSE);
243     }
244     
246   return TRUE;
247 }            
248            
250 /****************************************************************************
251  * FUNCTION PURPOSE: Data Mode Control 
252  ****************************************************************************
253  * DESCRIPTION: Data Mode Control functions
254  *
255  * int16_t  salld_data_mode_control (
256  *   void  *salldInst  - a pointer to SALLD channel instance
257  *   void  *ctrl)      - a pointer to control structure
258  *
259  * Return values:  sa_ERR_OK
260  *                 sa_ERR_GEN
261  *                 sa_ERR_PARAMS
262  *
263  ***************************************************************************/
264 int16_t salld_data_mode_control (void *salldInst, void *salldCtrl)
266   salldDataModeInst_t *inst = (salldDataModeInst_t *)salldInst;
267   salldDataModeTxInst_t *txInst = &inst->txInst;
268   Sa_ChanCtrlInfo_t *ctrl = (Sa_ChanCtrlInfo_t *)salldCtrl;
269   uint16_t bitmap;
270   int16_t ret;
272   switch(ctrl->ctrlType)
273   {
274     /* SALLD cipher, mac and key size selection */
275     case sa_CHAN_CTRL_GEN_CONFIG:
276     {
277         bitmap = ctrl->ctrlInfo.gen.validBitfield;
278         if( bitmap & sa_CONTROLINFO_VALID_TX_CTRL)
279         {
280             /* Input parameters check */
281             Sa_GenConfigParams_t* pGenConfig = &ctrl->ctrlInfo.gen.txCtrl;
282             Sa_DataModeConfigParams_t*  pDataModeConfig  = &ctrl->ctrlInfo.gen.txCtrl.params.data;
283             
284             if (salld_dm_verify_config_params(pGenConfig->cipherMode, pGenConfig->authMode, pDataModeConfig))
285             {
286                 txInst->cipherMode = pGenConfig->cipherMode;
287                 txInst->authMode   = pGenConfig->authMode;
288                 txInst->destInfo   = pGenConfig->destInfo; 
289                 txInst->comInfo.config = *pDataModeConfig;
290                 if(txInst->cipherMode == sa_CipherMode_NULL)
291                     txInst->comInfo.config.enc1st = FALSE;    
292             }
293             else
294             {
295                 return(sa_ERR_PARAMS);
296             }
297 #if defined(NSS_LITE2)
298             txInst->comInfo.config.priv   = pDataModeConfig->priv;
299             txInst->comInfo.config.privId = pDataModeConfig->privId;
300 #endif
301         }
302         
303         /*
304          * Is it time to form and register security context?
305          */
306         if(!SALLD_TEST_STATE_TX_SC_VALID(&inst->salldInst) && 
307             SALLD_TEST_STATE_TX_ON(&inst->salldInst))
308         {
309             if ((ret = salld_data_mode_set_sc(inst)) != sa_ERR_OK)
310             {
311                 return(ret);
312             }
313             
314             if ((ret = salld_data_mode_set_cmdl(inst)) != sa_ERR_OK)
315             {
316                 return(ret);
317             }
318             
319             SALLD_SET_STATE_TX_SC_VALID(&inst->salldInst, 1);
320         } 
321     }    
322     break;
324     /* Master key and Salt setup for ac */
325     case sa_CHAN_CTRL_KEY_CONFIG:
326     {
327         bitmap = ctrl->ctrlInfo.key.ctrlBitfield;
328         
329         if (bitmap & sa_KEY_CONTROL_TX_KEY_VALID)
330         {
331             Sa_DataModeKeyParams_t* pKeyParams = &ctrl->ctrlInfo.key.txKey.data;
332             salldDataModeComInfo_t*   pComInfo = &txInst->comInfo;
333             
334             if(!salld_data_mode_setup_key(inst, pComInfo, pKeyParams))
335                 return(sa_ERR_PARAMS);
336         }    
337     }   
338     break;
339     
340     default:
341         return (sa_ERR_PARAMS);
343   }
344   return (sa_ERR_OK);
347 /******************************************************************************
348  * FUNCTION PURPOSE: Data Mode Get Stats
349  ******************************************************************************
350  * DESCRIPTION: Extract Data Mode related statistics from the instance structure
351  *
352  * void salld_data_mode_get_stats (
353  *    void   *salldInst,       - A pointer to SALLD instance
354  *    uint16_t flags,            - various control flags
355  *    void   *stats)           - The stat structure
356  *
357  * Return values:  sa_ERR_OK
358  *
359  *****************************************************************************/
360 int16_t salld_data_mode_get_stats (void *salldInst, uint16_t flags, void *stats)
362   Sa_DataModeStats_t  *pStats = (Sa_DataModeStats_t *)  stats;
363   salldDataModeInst_t   *inst   = (salldDataModeInst_t *)   salldInst; 
364   salldDataModeTxInst_t *txInst = (salldDataModeTxInst_t *) &inst->txInst;
366   pStats->pktHi  = txInst->packetMsw;
367   pStats->pktLo  = txInst->packetLsw;
369   return (sa_ERR_OK);
372 static const uint8_t saKasumiF9PaddingUp[8]   = {0x40, 0, 0, 0, 0, 0, 0, 0};
373 static const uint8_t saKasumiF9PaddingDown[8] = {0xC0, 0, 0, 0, 0, 0, 0, 0};
375 /******************************************************************************
376  * FUNCTION PURPOSE: Data Mode Send Data
377  ******************************************************************************
378  * DESCRIPTION: 
379  *
380  * void salld_data_mode_send_data (
381  *    void *salldInst,      - A pointer to SALLD Data Mode instance
382  *    void *pktInfo,        - packet pointer
383  *    uint16_t clear) 
384  *
385  *  Perform the following actions:
386  *      - Update statistics
387  *
388  *****************************************************************************/
389 int16_t salld_data_mode_send_data (void *salldInst, void *pktInfo, uint16_t clear) 
391   salldDataModeInst_t *inst   = (salldDataModeInst_t *)salldInst; 
392   salldDataModeTxInst_t *txInst = &inst->txInst;
393   Sa_PktInfo_t* pPktInfo = (Sa_PktInfo_t*)pktInfo;
394   int16_t ret_code;
395   
396   /* Kasumi-F9 Padding:
397    * The SASS is not able to generate Kasumi-F9 padding when the number of bytes to be authenticated is multiple of 8.
398    * Therefore, we need to perform Kasumi-F9 padding for this special case 
399    * Assumption:the padding bytes can be added to the end of data segments
400    */
401   if (txInst->authMode == sa_AuthMode_KASUMI_F9)
402   {
403     Sa_PayloadInfo_t *pPayloadInfo = &pPktInfo->payloadInfo;
404     uint8_t *pPadding;
405     
406     if (!(pPayloadInfo->authSize & 0x7))
407     {
408         Sa_PktDesc_t *pPktDesc = &pPktInfo->pktDesc;
409         int paddingSegIndex = pPktDesc->nSegments - 1;        
410         
411         /* The authentication data is 8-byte aligned, padding is required */
412         if(pPktDesc->size != (pPayloadInfo->authSize + pPayloadInfo->authOffset))
413             return(sa_ERR_GEN);
414             
415         if((pPktDesc->segAllocSizes[paddingSegIndex] - pPktDesc->segUsedSizes[paddingSegIndex]) < 8)
416             return(sa_ERR_GEN);
417             
418         pPadding = (uint8_t *)pPktDesc->segments[paddingSegIndex];
419         pPadding += pPktDesc->segUsedSizes[paddingSegIndex];    
420             
421         memcpy(pPadding,
422                txInst->comInfo.config.enc?saKasumiF9PaddingDown:saKasumiF9PaddingUp,
423                8);        
424             
425         pPktDesc->size += 8;
426         pPktDesc->segUsedSizes[paddingSegIndex] += 8;
427         pPayloadInfo->authSize += 8;
428     }
429   
430   }
432   /* Encrypt and Authenticate Packet(s) */
433   ret_code = salld_data_mode_update_cmdl(inst, pPktInfo);
434   
435   if(ret_code != sa_ERR_OK)
436     return (ret_code);  
437     
438   /* Pass the software Info in the packet */
439   pPktInfo->validBitMap |= sa_PKT_INFO_VALID_SW_INFO;
440   pPktInfo->swInfo = txInst->swInfo;
442   if(txInst->packetLsw == 0xFFFFFFFFu)
443   {
444       txInst->packetLsw = 0u;
445       txInst->packetMsw++;
446   }
447   else
448   {
449       txInst->packetLsw++;
450   }
451   return(sa_ERR_OK);
452       
453 } /* salld_data_mode_send_data */
455 /******************************************************************************
456  * FUNCTION PURPOSE: Data Mode Receive Data
457  ******************************************************************************
458  * DESCRIPTION: 
459  *
460  * void salld_data_mode_receive_data (
461  *    void *salldInst,    - A pointer to SALLD instance
462  *    void *pktInfo)      - packet pointer
463  * 
464  * Not Supported
465  *****************************************************************************/
466 int16_t salld_data_mode_receive_data (void *salldInst, void *pktInfo) 
468   /* Kasumi-F9 De-Padding */
469   salldDataModeInst_t *inst   = (salldDataModeInst_t *)salldInst; 
470   salldDataModeTxInst_t *txInst = &inst->txInst;
471   Sa_PktInfo_t* pPktInfo = (Sa_PktInfo_t*)pktInfo;
472   
473   /* Kasumi-F9 Padding:
474    * The SASS is not able to generate Kasumi-F9 padding when the number of bytes to be authenticated is multiple of 8.
475    * Therefore, we need to perform Kasumi-F9 padding for this special case 
476    */
477   if (txInst->authMode == sa_AuthMode_KASUMI_F9)
478   {
479     Sa_PayloadInfo_t *pPayloadInfo = &pPktInfo->payloadInfo;
480     
481     if (!(pPayloadInfo->authSize & 0x7))
482     {
483         Sa_PktDesc_t *pPktDesc = &pPktInfo->pktDesc;
484         int paddingSegIndex = pPktDesc->nSegments - 1;
485         int numBytes = 8;  
486         
487         pPktDesc->size -= 8;
488         
489         while (numBytes)
490         {
491             if (pPktDesc->segUsedSizes[paddingSegIndex] >= numBytes)
492             {
493                 pPktDesc->segUsedSizes[paddingSegIndex] -= numBytes;
494                 numBytes = 0;    
495             }
496             else
497             {
498                 numBytes -= pPktDesc->segUsedSizes[paddingSegIndex];
499                 pPktDesc->segUsedSizes[paddingSegIndex] = 0;
500                 if (paddingSegIndex)
501                 {
502                     paddingSegIndex--;    
503                 }
504                 else
505                 {
506                     return(sa_ERR_GEN);
507                 }
508                     
509             }
510         }
511     }
512   
513   }
515   return (sa_ERR_OK);
518 /****************************************************************************
519  * FUNCTION PURPOSE: Construct Data Mode Security Context
520  ****************************************************************************
521  * DESCRIPTION: Construct Security Context from the configuration parameters 
522  *          for Data Mode (to-SA) operations
523  *
524  *  uint16_t salld_data_mode_set_sc(
525  *            salldIpsecInst_t*     inst)      -> Point to Data Mode channel instance
526  *                       
527  * Return values: sa_ERR_XXX
528  * 
529  * Assumption: The same algorithm will be used for both encryption and 
530  *             authentication                          
531  *
532  ***************************************************************************/
533 int16_t salld_data_mode_set_sc(salldDataModeInst_t *inst) 
535   salldObj_t *sysInst = (salldObj_t *)sa_CONV_OFFSET_TO_ADDR(salldLObj.instPoolBaseAddr, inst->salldInst.ownerInstOffset);
536   salldDataModeTxInst_t *txInst = &inst->txInst;
537   salldDataModeComInfo_t *pComInfo = &txInst->comInfo;
538   Sa_DataModeConfigParams_t  *pConfig = &pComInfo->config;
539   Sa_ScReqInfo_t* pScInfo = &txInst->scInfo;
540   int16_t encCmdlSize, encScSize, encScOffset;
541   int16_t authCmdlSize, authScSize, authScOffset;
542 #if !defined(NSS_LITE) && !defined(NSS_LITE2)
543   int16_t acAlgorithm = SA_AC_ALGORITHM_GSM_A53;
544 #endif
545   saDMAReqInfo_t dmaReqInfo;
546   uint16_t useEnc;
547   uint16_t fRandomIV;
548   uint8_t firstEngId;
549   uint8_t tagSize;
550 #ifdef NSS_LITE2
551   uint32_t ctxAttrCtrlBitMap;
552 #endif
554   /*
555    * Calculate the security Context Size and allocate security Context
556    *
557    */
558   salld_sc_enc_get_info(txInst->cipherMode, pConfig->ivSize, &encCmdlSize, &encScSize, &pComInfo->encEngId, &fRandomIV, SALLD_TEST_SASS_GEN2(sysInst)); 
559   salld_sc_auth_get_info(txInst->authMode, &useEnc, &authCmdlSize, &authScSize, &pComInfo->authEngId);
560   pScInfo->scSize = SA_CTX_PHP_DATA_MODE_SIZE + encScSize + authScSize;
561   salldLObj.callOutFuncs.ScAlloc((Sa_ChanHandle)sa_CONV_ADDR_TO_OFFSET(salldLObj.instPoolBaseAddr,inst), pScInfo);
563   /* Fix the encrpytion engine ID that is set to use from Encryption Engine
564      when auth engine ID is Air Cipher OR if the channel is Air Cipher */
565   if (pComInfo->encEngId  == SALLD_CMDL_ENGINE_ID_ES1)
566   {
567     if (((pConfig->ctrlBitMap & sa_DM_CONFIG_SELECT_AIR_CIPHER_ENG) == sa_DM_CONFIG_SELECT_AIR_CIPHER_ENG)  ||
568          (pComInfo->authEngId == SALLD_CMDL_ENGINE_ID_ACS1))
569     {
570       pComInfo->encEngId = SALLD_CMDL_ENGINE_ID_ACS1;
571     }
572   }
574 #if !defined(NSS_LITE) && !defined(NSS_LITE2)
575   if (pComInfo->authEngId == SALLD_CMDL_ENGINE_ID_ES1)
576   {
577     if ((pConfig->ctrlBitMap & sa_DM_CONFIG_SELECT_AIR_CIPHER_ENG) == sa_DM_CONFIG_SELECT_AIR_CIPHER_ENG)
578     {
579       pComInfo->authEngId = SALLD_CMDL_ENGINE_ID_ACS1;
580     }
581   }
582 #endif
584   if(pScInfo->scBuf == (uintptr_t) NULL)
585     return(sa_ERR_NO_CTX_BUF);
586     
587   Sa_osalBeginScAccess((void *)pScInfo->scBuf, pScInfo->scSize);
588   
589   memset((void *) pScInfo->scBuf, 0, SALLD_BYTE_TO_WORD(pScInfo->scSize));
590   
591   /* Prepare PHP Security Context */
592   memset(&dmaReqInfo, 0, sizeof(saDMAReqInfo_t));
593   dmaReqInfo.phpFetchSize = SA_CTX_DMA_SIZE_64;
594   /* Non-Air Ciphering condition */
595   if ((!useEnc) || pConfig->enc1st)
596   {
597     dmaReqInfo.engFetchSize[0] = SA_CTX_SIZE_TO_DMA_SIZE(encScSize);
598     dmaReqInfo.engFetchSize[1] = SA_CTX_SIZE_TO_DMA_SIZE(authScSize);
599     encScOffset = SALLD_BYTE_TO_WORD(SA_CTX_PHP_DATA_MODE_SIZE);
600     authScOffset = SALLD_BYTE_TO_WORD(SA_CTX_PHP_DATA_MODE_SIZE + encScSize);
601   }
602   else
603   {
604     dmaReqInfo.engFetchSize[0] = SA_CTX_SIZE_TO_DMA_SIZE(authScSize);
605     dmaReqInfo.engFetchSize[1] = SA_CTX_SIZE_TO_DMA_SIZE(encScSize);
606     authScOffset = SALLD_BYTE_TO_WORD(SA_CTX_PHP_DATA_MODE_SIZE);
607     encScOffset = SALLD_BYTE_TO_WORD(SA_CTX_PHP_DATA_MODE_SIZE + authScSize);
608     
609   }
610   
611   /* Air Ciphering condition */
612   /* Assumption: Air Ciphering algorithm will be used as a pair */
613   if (pConfig->enc1st && (pComInfo->encEngId == SALLD_CMDL_ENGINE_ID_ACS1))
614   {
615     dmaReqInfo.engFetchSize[0] = SA_CTX_SIZE_TO_DMA_SIZE(encScSize);
616     dmaReqInfo.engFetchSize[1] = SA_CTX_SIZE_TO_DMA_SIZE(authScSize);
617     encScOffset = SALLD_BYTE_TO_WORD(SA_CTX_PHP_DATA_MODE_SIZE);
618     authScOffset = SALLD_BYTE_TO_WORD(SA_CTX_PHP_DATA_MODE_SIZE + encScSize);
619   }
620   else if (pComInfo->authEngId == SALLD_CMDL_ENGINE_ID_ACS1)
621   {
622     dmaReqInfo.engFetchSize[0] = SA_CTX_SIZE_TO_DMA_SIZE(authScSize);
623     dmaReqInfo.engFetchSize[1] = SA_CTX_SIZE_TO_DMA_SIZE(encScSize);
624     authScOffset = SALLD_BYTE_TO_WORD(SA_CTX_PHP_DATA_MODE_SIZE);
625     encScOffset = SALLD_BYTE_TO_WORD(SA_CTX_PHP_DATA_MODE_SIZE + authScSize);
626   }
627   
628   dmaReqInfo.phpEvictSize =  SA_CTX_DMA_SIZE_64;
630 #ifdef NSS_LITE2
631   if (pConfig->ctrlBitMap & sa_DM_CONFIG_PROMOTE_CHANNEL)
632   {
633      ctxAttrCtrlBitMap  = SA_CTX_SA2UL_ALLOW_PROMOTE | SA_CTX_SA2UL_SECURE;
634   }
635   else if (pConfig->ctrlBitMap & sa_DM_CONFIG_DEMOTE_CHANNEL)
636   {
637      ctxAttrCtrlBitMap  = SA_CTX_SA2UL_ALLOW_DEMOTE | SA_CTX_SA2UL_SECURE;
638   }
639   else
640   {
641      /* Regular channel, non secure */
642      ctxAttrCtrlBitMap = 0;
643   }
645   if (pConfig->ctrlBitMap & sa_DM_CONFIG_USE_SECURE_CTX_FOR_NON_SECURE_CHANNEL)
646   {
647      ctxAttrCtrlBitMap |= SA_CTX_SA2UL_ALLOW_NONSEC | SA_CTX_SA2UL_SECURE;
648   }
650   if (pConfig->priv)
651   {
652      /* Set for supervior mode */
653      ctxAttrCtrlBitMap |= SA_CTX_SA2UL_SET_PRIV;
654   }
656   salld_set_sc_scctl(&dmaReqInfo, &txInst->destInfo, SA_CTX_PKT_TYPE_NONE,
657                             pScInfo->scID, (tword *) pScInfo->scBuf, ctxAttrCtrlBitMap, pConfig->priv, pConfig->privId);
658 #else
659   {
660     salld_set_sc_phpCommom(&dmaReqInfo, &txInst->destInfo, SA_CTX_PKT_TYPE_NONE,
661                            pScInfo->scID, (tword *) pScInfo->scBuf);
662   }
663 #endif
665   /* Prepare Security Context for the encryption Engine */
666   if (encScSize)
667   {
668     #if !defined(NSS_LITE) && !defined(NSS_LITE2)
669     if (pComInfo->encEngId == SALLD_CMDL_ENGINE_ID_ACS1)
670     {
671         salld_set_sc_acEnc(txInst->cipherMode, pConfig->sessionEncKeySize, 
672                            pComInfo->sessionEncKey, NULL, pConfig->enc,
673                            (tword *)pScInfo->scBuf + encScOffset,
674                            &acAlgorithm, SALLD_TEST_SASS_GEN2(sysInst));
675     }
676     else
677     #endif 
678     {
679     
680         salld_set_sc_enc(sa_PT_NULL, txInst->cipherMode, pConfig->sessionEncKeySize, 
681                          pComInfo->sessionEncKey, (uint8_t) pConfig->aadSize, pConfig->enc, 
682                          (tword *)pScInfo->scBuf + encScOffset);
683     }               
684   }
685   
686   /* Prepare Security Context for the authentication Engine */
687   if (authScSize)
688   {
689     #if !defined(NSS_LITE) && !defined(NSS_LITE2)
690     if (pComInfo->authEngId == SALLD_CMDL_ENGINE_ID_ACS1)
691     {
692         salld_set_sc_acAuth(txInst->authMode, pConfig->sessionMacKeySize, 
693                             pComInfo->sessionMacKey, 
694                             (tword *) pScInfo->scBuf + authScOffset,
695                             &acAlgorithm,
696                             pConfig->enc?SA_KASUMI_AUTH_DIR1:SA_KASUMI_AUTH_DIR0,
697                             SALLD_TEST_SASS_GEN2(sysInst));
698     }  
699     else
700     #endif
701     {
702         if (useEnc)
703         {
704             salld_set_sc_enc(sa_PT_NULL, txInst->authMode, pConfig->sessionMacKeySize, 
705                           pComInfo->sessionMacKey, (uint8_t) pConfig->aadSize, FALSE,
706                           (tword *) pScInfo->scBuf + authScOffset);
707     
708         }
709         else
710         {
711             salld_set_sc_auth(txInst->authMode, pConfig->sessionMacKeySize, 
712                           pComInfo->sessionMacKey, 
713                           (tword *) pScInfo->scBuf + authScOffset);
714         }               
715     }                     
716   }
718   if ((pComInfo->encEngId == SALLD_CMDL_ENGINE_NONE) && (pComInfo->authEngId == SALLD_CMDL_ENGINE_NONE))
719   {
720     firstEngId = SALLD_CMDL_FINAL_ENGINE_ID;
721   }
722   else if ((pComInfo->encEngId == SALLD_CMDL_ENGINE_NONE))
723   {
724     firstEngId = pComInfo->authEngId;
725   }
726   else if ((pComInfo->authEngId == SALLD_CMDL_ENGINE_NONE))
727   {
728     firstEngId = pComInfo->encEngId;
729   }
730   else
731   {
732     firstEngId = pConfig->enc1st?pComInfo->encEngId:pComInfo->authEngId;
733   }
735   tagSize = SALLD_ROUND_UP(pConfig->macSize, 8);
736   
737   #ifdef SALLD_DATA_MODE_USE_PHP
738   /* Construct the Data Mode specific Security Context */    
739   {
740     tword* ctxIn = (tword *)(pScInfo->scBuf + SALLD_BYTE_TO_WORD(SA_CTX_PHP_COMMON_SIZE));
741   
742     pktWrite16bits_m(ctxIn, SALLD_FIELDOFFSET(saCtxProtoDm_t, firstEngIdTagSize), 
743                      SALLD_MK_UINT16(firstEngId, tagSize));
744                                      
745   }
746   #endif
747   
748   /* Security Context swizzling */
749   salld_swiz_128((uint8_t*) pScInfo->scBuf, (uint8_t*) pScInfo->scBuf, pScInfo->scSize);
750   
751   Sa_osalEndScAccess((void *)pScInfo->scBuf, pScInfo->scSize);
752   
753   /* Prepare the SW Info Words */
754   #ifndef SALLD_DATA_MODE_USE_PHP
755       #if defined(NSS_LITE2)
756         salld_set_swInfo2(firstEngId, 0,
757                          &txInst->destInfo,
758                          pScInfo, &txInst->swInfo, tagSize);
759       #else
760         salld_set_swInfo(firstEngId, 0,
761                        &txInst->destInfo,
762                        pScInfo, &txInst->swInfo, tagSize);
763       #endif
764   #else
765       /* Data packets enter PHP engine */
766       salld_set_swInfo(SALLD_CMDL_ENGINE_SRTP_AC_HPS1, 0, 
767                        &txInst->destInfo,
768                        pScInfo, &txInst->swInfo, 0);
769   #endif
770   /* Store the scBuf internally as offset to suppor multiprocess */
771   pScInfo->scBuf = (uintptr_t) sa_CONV_ADDR_TO_OFFSET(salldLObj.scPoolBaseAddr, pScInfo->scBuf);
772   
773   return (sa_ERR_OK);
774
776 /****************************************************************************
777  * FUNCTION PURPOSE: Data Mode Get SwInfo 
778  ****************************************************************************
779  * DESCRIPTION: Data Mode Get SwInfo
780  *
781  * int16_t  salld_data_mode_get_swInfo (
782  *   Sa_ChanHandle        handle      - SALLD channel identifier
783  *   uint16_t             dir         - packet directions
784  *   Sa_SWInfo_t         *pSwInfo)    - a pointer to swInfo
785  *
786  * Return values:  sa_ERR_OK
787  *                 sa_ERR_GEN
788  *                 sa_ERR_PARAMS
789  *                 sa_ERR_UNSUPPORTED
790  *
791  ***************************************************************************/
792 int16_t salld_data_mode_get_swInfo (void *salldInst, uint16_t dir, Sa_SWInfo_t* pChanSwInfo)
794   salldDataModeInst_t *inst = (salldDataModeInst_t *)salldInst;
795   int16_t ret = sa_ERR_OK;
796   
797   if (dir == sa_PKT_DIR_TO_NETWORK)
798   {
799     salldDataModeTxInst_t *txInst = (salldDataModeTxInst_t *) &inst->txInst;
800     memcpy(pChanSwInfo, &txInst->swInfo, sizeof(Sa_SWInfo_t));
801   }
802   else
803   {
804     ret = sa_ERR_PARAMS;
805   }
806   
807   return(ret);
810 /****************************************************************************
811  * Table PURPOSE:   Data Mode function call table 
812  ****************************************************************************
813  * DESCRIPTION:     The tables are used to link Data Mode functions to the 
814  *                  SALLD library if required 
815  *
816  ***************************************************************************/
817 Sa_ProtocolCallTbl_t Sa_callTblDataMode = 
819   sa_PT_NULL,
820   salld_data_mode_init,
821   salld_data_mode_control,
822   salld_data_mode_get_stats,
823   salld_data_mode_send_data,
824   salld_data_mode_receive_data,
825   salld_data_mode_close,
826   salld_data_mode_get_swInfo
827 };
828            
829    
830 /* Nothing past this point */