target/linux/generic/files/crypto/ocf/kirkwood/cesa/mvCesa.h

   1 /*******************************************************************************
   2 Copyright (C) Marvell International Ltd. and its affiliates
   3
   4 This software file (the "File") is owned and distributed by Marvell
   5 International Ltd. and/or its affiliates ("Marvell") under the following
   6 alternative licensing terms.  Once you have made an election to distribute the
   7 File under one of the following license alternatives, please (i) delete this
   8 introductory statement regarding license alternatives, (ii) delete the two
   9 license alternatives that you have not elected to use and (iii) preserve the
  10 Marvell copyright notice above.
  11
  12 ********************************************************************************
  13 Marvell Commercial License Option
  14
  15 If you received this File from Marvell and you have entered into a commercial
  16 license agreement (a "Commercial License") with Marvell, the File is licensed
  17 to you under the terms of the applicable Commercial License.
  18
  19 ********************************************************************************
  20 Marvell GPL License Option
  21
  22 If you received this File from Marvell, you may opt to use, redistribute and/or
  23 modify this File in accordance with the terms and conditions of the General
  24 Public License Version 2, June 1991 (the "GPL License"), a copy of which is
  25 available along with the File in the license.txt file or by writing to the Free
  26 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
  27 on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
  28
  29 THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
  30 WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
  31 DISCLAIMED.  The GPL License provides additional details about this warranty
  32 disclaimer.
  33 ********************************************************************************
  34 Marvell BSD License Option
  35
  36 If you received this File from Marvell, you may opt to use, redistribute and/or
  37 modify this File under the following licensing terms.
  38 Redistribution and use in source and binary forms, with or without modification,
  39 are permitted provided that the following conditions are met:
  40
  41     *   Redistributions of source code must retain the above copyright notice,
  42             this list of conditions and the following disclaimer.
  43
  44     *   Redistributions in binary form must reproduce the above copyright
  45         notice, this list of conditions and the following disclaimer in the
  46         documentation and/or other materials provided with the distribution.
  47
  48     *   Neither the name of Marvell nor the names of its contributors may be
  49         used to endorse or promote products derived from this software without
  50         specific prior written permission.
  51
  52 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  53 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  54 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  55 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
  56 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  57 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  58 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
  59 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  60 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  61 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  62
  63 *******************************************************************************/
  64
  65 /*******************************************************************************
  66 * mvCesa.h - Header File for Cryptographic Engines and Security Accelerator
  67 *
  68 * DESCRIPTION:
  69 *       This header file contains macros typedefs and function declaration for
  70 *       the Marvell Cryptographic Engines and Security Accelerator.
  71 *
  72 *******************************************************************************/
  73
  74 #ifndef __mvCesa_h__
  75 #define __mvCesa_h__
  76
  77 #include "mvOs.h"
  78 #include "mvCommon.h"
  79 #include "mvDebug.h"
  80
  81 #include "ctrlEnv/mvCtrlEnvSpec.h"
  82
  83 #include "cesa/mvMD5.h"
  84 #include "cesa/mvSHA1.h"
  85
  86 #include "cesa/mvCesa.h"
  87 #include "cesa/AES/mvAes.h"
  88 #include "mvSysHwConfig.h"
  89
  90 #ifdef MV_INCLUDE_IDMA
  91 #include "idma/mvIdma.h"
  92 #include "idma/mvIdmaRegs.h"
  93 #else
  94 /* Redefine MV_DMA_DESC structure */
  95 typedef struct _mvDmaDesc
  96 {
  97     MV_U32      byteCnt;        /* The total number of bytes to transfer        */
  98     MV_U32      phySrcAdd;          /* The physical source address                  */
  99     MV_U32      phyDestAdd;     /* The physical destination address             */
 100     MV_U32      phyNextDescPtr; /* If we are using chain mode DMA transfer,     */
 101                                             /* then this pointer should point to the        */
 102                             /* physical address of the next descriptor,     */
 103                             /* otherwise it should be NULL.                 */
 104 }MV_DMA_DESC;
 105 #endif /* MV_INCLUDE_IDMA */
 106
 107 #include "cesa/mvCesaRegs.h"
 108
 109 #define MV_CESA_AUTH_BLOCK_SIZE         64 /* bytes */
 110
 111 #define MV_CESA_MD5_DIGEST_SIZE         16 /* bytes */
 112 #define MV_CESA_SHA1_DIGEST_SIZE        20 /* bytes */
 113
 114 #define MV_CESA_MAX_DIGEST_SIZE         MV_CESA_SHA1_DIGEST_SIZE
 115
 116 #define MV_CESA_DES_KEY_LENGTH          8   /* bytes = 64 bits */
 117 #define MV_CESA_3DES_KEY_LENGTH         24  /* bytes = 192 bits */
 118 #define MV_CESA_AES_128_KEY_LENGTH      16  /* bytes = 128 bits */
 119 #define MV_CESA_AES_192_KEY_LENGTH      24  /* bytes = 192 bits */
 120 #define MV_CESA_AES_256_KEY_LENGTH      32  /* bytes = 256 bits */
 121
 122 #define MV_CESA_MAX_CRYPTO_KEY_LENGTH   MV_CESA_AES_256_KEY_LENGTH
 123
 124 #define MV_CESA_DES_BLOCK_SIZE          8 /* bytes = 64 bits */
 125 #define MV_CESA_3DES_BLOCK_SIZE         8 /* bytes = 64 bits */
 126
 127 #define MV_CESA_AES_BLOCK_SIZE          16 /* bytes = 128 bits */
 128
 129 #define MV_CESA_MAX_IV_LENGTH           MV_CESA_AES_BLOCK_SIZE
 130
 131 #define MV_CESA_MAX_MAC_KEY_LENGTH      64 /* bytes */
 132
 133 typedef struct
 134 {
 135         MV_U8               cryptoKey[MV_CESA_MAX_CRYPTO_KEY_LENGTH];
 136         MV_U8               macKey[MV_CESA_MAX_MAC_KEY_LENGTH];
 137         MV_CESA_OPERATION   operation;
 138         MV_CESA_DIRECTION   direction;
 139         MV_CESA_CRYPTO_ALG  cryptoAlgorithm;
 140         MV_CESA_CRYPTO_MODE cryptoMode;
 141         MV_U8               cryptoKeyLength;
 142         MV_CESA_MAC_MODE    macMode;
 143         MV_U8               macKeyLength;
 144         MV_U8               digestSize;
 145
 146 } MV_CESA_OPEN_SESSION;
 147
 148 typedef struct
 149 {
 150     MV_BUF_INFO *pFrags;
 151         MV_U16      numFrags;
 152     MV_U16      mbufSize;
 153
 154 } MV_CESA_MBUF;
 155
 156 typedef struct
 157 {
 158     void*       pReqPrv; /* instead of reqId */
 159     MV_U32      retCode;
 160     MV_16   sessionId;
 161
 162 } MV_CESA_RESULT;
 163
 164 typedef void    (*MV_CESA_CALLBACK) (MV_CESA_RESULT* pResult);
 165
 166
 167 typedef struct
 168 {
 169     void*               pReqPrv;    /* instead of reqId */
 170     MV_CESA_MBUF*       pSrc;
 171     MV_CESA_MBUF*       pDst;
 172     MV_CESA_CALLBACK*   pFuncCB;
 173     MV_16               sessionId;
 174     MV_U16              ivFromUser;
 175     MV_U16              ivOffset;
 176     MV_U16              cryptoOffset;
 177     MV_U16              cryptoLength;
 178     MV_U16              digestOffset;
 179     MV_U16              macOffset;
 180     MV_U16              macLength;
 181     MV_BOOL             skipFlush;
 182 } MV_CESA_COMMAND;
 183
 184
 185
 186 MV_STATUS   mvCesaHalInit (int numOfSession, int queueDepth, char* pSramBase, MV_U32 cryptEngBase, void *osHandle);
 187 MV_STATUS   mvCesaFinish (void);
 188 MV_STATUS   mvCesaSessionOpen(MV_CESA_OPEN_SESSION *pSession, short* pSid);
 189 MV_STATUS   mvCesaSessionClose(short sid);
 190 MV_STATUS   mvCesaCryptoIvSet(MV_U8* pIV, int ivSize);
 191
 192 MV_STATUS   mvCesaAction (MV_CESA_COMMAND* pCmd);
 193
 194 MV_U32      mvCesaInProcessGet(void);
 195 MV_STATUS   mvCesaReadyDispatch(void);
 196 MV_STATUS   mvCesaReadyGet(MV_CESA_RESULT* pResult);
 197 MV_BOOL     mvCesaIsReady(void);
 198
 199 int             mvCesaMbufOffset(MV_CESA_MBUF* pMbuf, int offset, int* pBufOffset);
 200 MV_STATUS   mvCesaCopyFromMbuf(MV_U8* pDst, MV_CESA_MBUF* pSrcMbuf,
 201                                int offset, int size);
 202 MV_STATUS   mvCesaCopyToMbuf(MV_U8* pSrc, MV_CESA_MBUF* pDstMbuf,
 203                                int offset, int size);
 204 MV_STATUS   mvCesaMbufCopy(MV_CESA_MBUF* pMbufDst, int dstMbufOffset,
 205                            MV_CESA_MBUF* pMbufSrc, int srcMbufOffset, int size);
 206
 207 /********** Debug functions ********/
 208
 209 void        mvCesaDebugMbuf(const char* str, MV_CESA_MBUF *pMbuf, int offset, int size);
 210 void        mvCesaDebugSA(short sid, int mode);
 211 void        mvCesaDebugStats(void);
 212 void        mvCesaDebugStatsClear(void);
 213 void        mvCesaDebugRegs(void);
 214 void        mvCesaDebugStatus(void);
 215 void        mvCesaDebugQueue(int mode);
 216 void        mvCesaDebugSram(int mode);
 217 void        mvCesaDebugSAD(int mode);
 218
 219
 220 /********  CESA Private definitions ********/
 221 #if (MV_CESA_VERSION >= 2)
 222 #if (MV_CACHE_COHERENCY  == MV_CACHE_COHER_SW)
 223 #define MV_CESA_TDMA_CTRL_VALUE       MV_CESA_TDMA_DST_BURST_MASK(MV_CESA_TDMA_BURST_128B) \
 224                                     | MV_CESA_TDMA_SRC_BURST_MASK(MV_CESA_TDMA_BURST_128B) \
 225                                     | MV_CESA_TDMA_OUTSTAND_READ_EN_MASK                   \
 226                                     | MV_CESA_TDMA_NO_BYTE_SWAP_MASK                       \
 227                                     | MV_CESA_TDMA_ENABLE_MASK
 228 #else
 229 #define MV_CESA_TDMA_CTRL_VALUE       MV_CESA_TDMA_DST_BURST_MASK(MV_CESA_TDMA_BURST_32B)  \
 230                                     | MV_CESA_TDMA_SRC_BURST_MASK(MV_CESA_TDMA_BURST_128B) \
 231                                     /*| MV_CESA_TDMA_OUTSTAND_READ_EN_MASK                   */\
 232                                     | MV_CESA_TDMA_ENABLE_MASK
 233
 234 #endif
 235 #else
 236 #define MV_CESA_IDMA_CTRL_LOW_VALUE   ICCLR_DST_BURST_LIM_128BYTE   \
 237                                     | ICCLR_SRC_BURST_LIM_128BYTE   \
 238                                     | ICCLR_INT_MODE_MASK           \
 239                                     | ICCLR_BLOCK_MODE              \
 240                                     | ICCLR_CHAN_ENABLE             \
 241                                     | ICCLR_DESC_MODE_16M
 242 #endif /* MV_CESA_VERSION >= 2 */
 243
 244 #define MV_CESA_MAX_PKT_SIZE        (64 * 1024)
 245 #define MV_CESA_MAX_MBUF_FRAGS      20
 246
 247 #define MV_CESA_MAX_REQ_FRAGS       ( (MV_CESA_MAX_PKT_SIZE / MV_CESA_MAX_BUF_SIZE) + 1)
 248
 249 #define MV_CESA_MAX_DMA_DESC    (MV_CESA_MAX_MBUF_FRAGS*2 + 5)
 250
 251 #define MAX_CESA_CHAIN_LENGTH   20
 252
 253 typedef enum
 254 {
 255     MV_CESA_IDLE     = 0,
 256     MV_CESA_PENDING,
 257     MV_CESA_PROCESS,
 258     MV_CESA_READY,
 259 #if (MV_CESA_VERSION >= 3)
 260     MV_CESA_CHAIN,
 261 #endif
 262 } MV_CESA_STATE;
 263
 264
 265 /* Session database */
 266
 267 /* Map of Key materials of the session in SRAM.
 268  * Each field must be 8 byte aligned
 269  * Total size: 32 + 24 + 24 = 80 bytes
 270  */
 271 typedef struct
 272 {
 273     MV_U8  cryptoKey[MV_CESA_MAX_CRYPTO_KEY_LENGTH];
 274     MV_U8  macInnerIV[MV_CESA_MAX_DIGEST_SIZE];
 275     MV_U8  reservedInner[4];
 276     MV_U8  macOuterIV[MV_CESA_MAX_DIGEST_SIZE];
 277     MV_U8  reservedOuter[4];
 278
 279 } MV_CESA_SRAM_SA;
 280
 281 typedef struct
 282 {
 283     MV_CESA_SRAM_SA*    pSramSA;
 284     MV_U32              config;
 285     MV_U8               cryptoKeyLength;
 286     MV_U8               cryptoIvSize;
 287     MV_U8               cryptoBlockSize;
 288     MV_U8               digestSize;
 289     MV_U8               macKeyLength;
 290     MV_U8               valid;
 291     MV_U8               ctrMode;
 292     MV_U32              count;
 293
 294 } MV_CESA_SA;
 295
 296 /* DMA list management */
 297 typedef struct
 298 {
 299     MV_DMA_DESC*    pDmaFirst;
 300     MV_DMA_DESC*    pDmaLast;
 301
 302 } MV_CESA_DMA;
 303
 304
 305 typedef struct
 306 {
 307     MV_U8               numFrag;
 308     MV_U8               nextFrag;
 309     int                 bufOffset;
 310     int                 cryptoSize;
 311     int                 macSize;
 312     int                 newDigestOffset;
 313     MV_U8               orgDigest[MV_CESA_MAX_DIGEST_SIZE];
 314
 315 } MV_CESA_FRAGS;
 316
 317 /* Request queue */
 318 typedef struct
 319 {
 320     MV_U8               state;
 321     MV_U8               fragMode;
 322     MV_U8               fixOffset;
 323     MV_CESA_COMMAND*    pCmd;
 324     MV_CESA_COMMAND*    pOrgCmd;
 325     MV_BUF_INFO         dmaDescBuf;
 326     MV_CESA_DMA         dma[MV_CESA_MAX_REQ_FRAGS];
 327     MV_BUF_INFO         cesaDescBuf;
 328     MV_CESA_DESC*       pCesaDesc;
 329     MV_CESA_FRAGS       frags;
 330
 331
 332 } MV_CESA_REQ;
 333
 334
 335 /* SRAM map */
 336 /* Total SRAM size calculation */
 337 /*  SRAM size =
 338  *              MV_CESA_MAX_BUF_SIZE  +
 339  *              sizeof(MV_CESA_DESC)  +
 340  *              MV_CESA_MAX_IV_LENGTH +
 341  *              MV_CESA_MAX_IV_LENGTH +
 342  *              MV_CESA_MAX_DIGEST_SIZE +
 343  *              sizeof(MV_CESA_SRAM_SA)
 344  *            = 1600 + 32 + 16 + 16 + 24 + 80 + 280 (reserved) = 2048 bytes
 345  *            = 3200 + 32 + 16 + 16 + 24 + 80 + 728 (reserved) = 4096 bytes
 346  */
 347 typedef struct
 348 {
 349     MV_U8               buf[MV_CESA_MAX_BUF_SIZE];
 350     MV_CESA_DESC        desc;
 351     MV_U8               cryptoIV[MV_CESA_MAX_IV_LENGTH];
 352     MV_U8               tempCryptoIV[MV_CESA_MAX_IV_LENGTH];
 353     MV_U8               tempDigest[MV_CESA_MAX_DIGEST_SIZE+4];
 354     MV_CESA_SRAM_SA     sramSA;
 355
 356 } MV_CESA_SRAM_MAP;
 357
 358
 359 typedef struct
 360 {
 361     MV_U32  openedCount;
 362     MV_U32  closedCount;
 363     MV_U32  fragCount;
 364     MV_U32  reqCount;
 365     MV_U32  maxReqCount;
 366     MV_U32  procCount;
 367     MV_U32  readyCount;
 368     MV_U32  notReadyCount;
 369     MV_U32  startCount;
 370 #if (MV_CESA_VERSION >= 3)
 371     MV_U32  maxChainUsage;
 372 #endif
 373
 374 } MV_CESA_STATS;
 375
 376
 377 /* External variables */
 378
 379 extern MV_CESA_STATS    cesaStats;
 380 extern MV_CESA_FRAGS    cesaFrags;
 381
 382 extern MV_BUF_INFO      cesaSramSaBuf;
 383
 384 extern MV_CESA_SA*       pCesaSAD;
 385 extern MV_U16            cesaMaxSA;
 386
 387 extern MV_CESA_REQ*      pCesaReqFirst;
 388 extern MV_CESA_REQ*      pCesaReqLast;
 389 extern MV_CESA_REQ*      pCesaReqEmpty;
 390 extern MV_CESA_REQ*      pCesaReqProcess;
 391 extern int               cesaQueueDepth;
 392 extern int               cesaReqResources;
 393 #if (MV_CESA_VERSION>= 3)
 394 extern MV_U32           cesaChainLength;
 395 #endif
 396
 397 extern MV_CESA_SRAM_MAP*  cesaSramVirtPtr;
 398 extern MV_U32           cesaSramPhysAddr;
 399
 400 static INLINE MV_ULONG  mvCesaVirtToPhys(MV_BUF_INFO* pBufInfo, void* pVirt)
 401 {
 402     return (pBufInfo->bufPhysAddr + ((MV_U8*)pVirt - pBufInfo->bufVirtPtr));
 403 }
 404
 405 /* Additional DEBUG functions */
 406 void        mvCesaDebugSramSA(MV_CESA_SRAM_SA* pSramSA, int mode);
 407 void        mvCesaDebugCmd(MV_CESA_COMMAND* pCmd,  int mode);
 408 void        mvCesaDebugDescriptor(MV_CESA_DESC* pDesc);
 409
 410
 411
 412 #endif /* __mvCesa_h__ */