target/linux/generic/files/crypto/ocf/kirkwood/cesa_ocf_drv.c

   1 /*******************************************************************************
   2 Copyright (C) Marvell International Ltd. and its affiliates
   3
   4 This software file (the "File") is owned and distributed by Marvell
   5 International Ltd. and/or its affiliates ("Marvell") under the following
   6 alternative licensing terms.  Once you have made an election to distribute the
   7 File under one of the following license alternatives, please (i) delete this
   8 introductory statement regarding license alternatives, (ii) delete the two
   9 license alternatives that you have not elected to use and (iii) preserve the
  10 Marvell copyright notice above.
  11
  12
  13 ********************************************************************************
  14 Marvell GPL License Option
  15
  16 If you received this File from Marvell, you may opt to use, redistribute and/or
  17 modify this File in accordance with the terms and conditions of the General
  18 Public License Version 2, June 1991 (the "GPL License"), a copy of which is
  19 available along with the File in the license.txt file or by writing to the Free
  20 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 or
  21 on the worldwide web at http://www.gnu.org/licenses/gpl.txt.
  22
  23 THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
  24 WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
  25 DISCLAIMED.  The GPL License provides additional details about this warranty
  26 disclaimer.
  27 *******************************************************************************/
  28
  29 #include <linux/version.h>
  30 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,38) && !defined(AUTOCONF_INCLUDED)
  31 #include <linux/config.h>
  32 #endif
  33 #include <linux/module.h>
  34 #include <linux/init.h>
  35 #include <linux/list.h>
  36 #include <linux/slab.h>
  37 #include <linux/sched.h>
  38 #include <linux/wait.h>
  39 #include <linux/crypto.h>
  40 #include <linux/mm.h>
  41 #include <linux/skbuff.h>
  42 #include <linux/random.h>
  43 #include <linux/platform_device.h>
  44 #include <asm/scatterlist.h>
  45 #include <linux/spinlock.h>
  46 #include "ctrlEnv/sys/mvSysCesa.h"
  47 #include "cesa/mvCesa.h" /* moved here before cryptodev.h due to include dependencies */
  48 #include <cryptodev.h>
  49 #include <uio.h>
  50 #include <plat/mv_cesa.h>
  51 #include <linux/mbus.h>
  52 #include "mvDebug.h"
  53
  54 #include "cesa/mvMD5.h"
  55 #include "cesa/mvSHA1.h"
  56
  57 #include "cesa/mvCesaRegs.h"
  58 #include "cesa/AES/mvAes.h"
  59 #include "cesa/mvLru.h"
  60
  61 #undef  RT_DEBUG
  62 #ifdef RT_DEBUG
  63 static int debug = 1;
  64 module_param(debug, int, 1);
  65 MODULE_PARM_DESC(debug, "Enable debug");
  66 #undef dprintk
  67 #define dprintk(a...)   if (debug) { printk(a); } else
  68 #else
  69 static int debug = 0;
  70 #undef dprintk
  71 #define dprintk(a...)
  72 #endif
  73
  74
  75 /* TDMA Regs */
  76 #define WINDOW_BASE(i) 0xA00 + (i << 3)
  77 #define WINDOW_CTRL(i) 0xA04 + (i << 3)
  78
  79 /* interrupt handling */
  80 #undef CESA_OCF_POLLING
  81 #undef CESA_OCF_TASKLET
  82
  83 #if defined(CESA_OCF_POLLING) && defined(CESA_OCF_TASKLET)
  84 #error "don't use both tasklet and polling mode"
  85 #endif
  86
  87 extern int cesaReqResources;
  88 /* support for spliting action into 2 actions */
  89 #define CESA_OCF_SPLIT
  90
  91 /* general defines */
  92 #define CESA_OCF_MAX_SES 128
  93 #define CESA_Q_SIZE      64
  94
  95 #if LINUX_VERSION_CODE >= KERNEL_VERSION(3,2,0)
  96 #define FRAG_PAGE(f)    (f).p
  97 #else
  98 #define FRAG_PAGE(f)    (f)
  99 #endif
 100
 101 /* data structures */
 102 struct cesa_ocf_data {
 103         int                                      cipher_alg;
 104         int                                      auth_alg;
 105         int                                      encrypt_tn_auth;
 106 #define  auth_tn_decrypt  encrypt_tn_auth
 107         int                                      ivlen;
 108         int                                      digestlen;
 109         short                                    sid_encrypt;
 110         short                                    sid_decrypt;
 111         /* fragment workaround sessions */
 112         short                                    frag_wa_encrypt;
 113         short                                    frag_wa_decrypt;
 114         short                                    frag_wa_auth;
 115 };
 116
 117 /* CESA device data */
 118 struct cesa_dev {
 119         void __iomem *sram;
 120         void __iomem *reg;
 121         struct mv_cesa_platform_data *plat_data;
 122         int irq;
 123 };
 124
 125 #define DIGEST_BUF_SIZE 32
 126 struct cesa_ocf_process {
 127         MV_CESA_COMMAND                         cesa_cmd;
 128         MV_CESA_MBUF                            cesa_mbuf;
 129         MV_BUF_INFO                             cesa_bufs[MV_CESA_MAX_MBUF_FRAGS];
 130         char                                    digest[DIGEST_BUF_SIZE];
 131         int                                     digest_len;
 132         struct cryptop                          *crp;
 133         int                                     need_cb;
 134 };
 135
 136 /* global variables */
 137 static int32_t                  cesa_ocf_id             = -1;
 138 static struct cesa_ocf_data     *cesa_ocf_sessions[CESA_OCF_MAX_SES];
 139 static spinlock_t               cesa_lock;
 140 static struct cesa_dev cesa_device;
 141
 142 /* static APIs */
 143 static int              cesa_ocf_process        (device_t, struct cryptop *, int);
 144 static int              cesa_ocf_newsession     (device_t, u_int32_t *, struct cryptoini *);
 145 static int              cesa_ocf_freesession    (device_t, u_int64_t);
 146 static void             cesa_callback           (unsigned long);
 147 static irqreturn_t      cesa_interrupt_handler  (int, void *);
 148 #ifdef CESA_OCF_POLLING
 149 static void cesa_interrupt_polling(void);
 150 #endif
 151 #ifdef CESA_OCF_TASKLET
 152 static struct tasklet_struct cesa_ocf_tasklet;
 153 #endif
 154
 155 static struct timeval          tt_start;
 156 static struct timeval          tt_end;
 157
 158 /*
 159  * dummy device structure
 160  */
 161
 162 static struct {
 163         softc_device_decl       sc_dev;
 164 } mv_cesa_dev;
 165
 166 static device_method_t mv_cesa_methods = {
 167         /* crypto device methods */
 168         DEVMETHOD(cryptodev_newsession, cesa_ocf_newsession),
 169         DEVMETHOD(cryptodev_freesession,cesa_ocf_freesession),
 170         DEVMETHOD(cryptodev_process,    cesa_ocf_process),
 171         DEVMETHOD(cryptodev_kprocess,   NULL),
 172 };
 173
 174
 175
 176 /* Add debug Trace */
 177 #undef CESA_OCF_TRACE_DEBUG
 178 #ifdef CESA_OCF_TRACE_DEBUG
 179
 180 #define MV_CESA_USE_TIMER_ID    0
 181
 182 typedef struct
 183 {
 184     int             type;       /* 0 - isrEmpty, 1 - cesaReadyGet, 2 - cesaAction */
 185     MV_U32          timeStamp;
 186     MV_U32          cause;
 187     MV_U32          realCause;
 188     MV_U32          dmaCause;
 189     int             resources;
 190     MV_CESA_REQ*    pReqReady;
 191     MV_CESA_REQ*    pReqEmpty;
 192     MV_CESA_REQ*    pReqProcess;
 193 } MV_CESA_TEST_TRACE;
 194
 195 #define MV_CESA_TEST_TRACE_SIZE      50
 196
 197 static int cesaTestTraceIdx = 0;
 198 static MV_CESA_TEST_TRACE    cesaTestTrace[MV_CESA_TEST_TRACE_SIZE];
 199
 200 static void cesaTestTraceAdd(int type)
 201 {
 202     cesaTestTrace[cesaTestTraceIdx].type = type;
 203     cesaTestTrace[cesaTestTraceIdx].realCause = MV_REG_READ(MV_CESA_ISR_CAUSE_REG);
 204     //cesaTestTrace[cesaTestTraceIdx].idmaCause = MV_REG_READ(IDMA_CAUSE_REG);
 205     cesaTestTrace[cesaTestTraceIdx].resources = cesaReqResources;
 206     cesaTestTrace[cesaTestTraceIdx].pReqReady = pCesaReqReady;
 207     cesaTestTrace[cesaTestTraceIdx].pReqEmpty = pCesaReqEmpty;
 208     cesaTestTrace[cesaTestTraceIdx].pReqProcess = pCesaReqProcess;
 209     cesaTestTrace[cesaTestTraceIdx].timeStamp = mvCntmrRead(MV_CESA_USE_TIMER_ID);
 210     cesaTestTraceIdx++;
 211     if(cesaTestTraceIdx == MV_CESA_TEST_TRACE_SIZE)
 212         cesaTestTraceIdx = 0;
 213 }
 214
 215 #else /* CESA_OCF_TRACE_DEBUG */
 216
 217 #define cesaTestTraceAdd(x)
 218
 219 #endif /* CESA_OCF_TRACE_DEBUG */
 220
 221 unsigned int
 222 get_usec(unsigned int start)
 223 {
 224         if(start) {
 225                 do_gettimeofday (&tt_start);
 226                 return 0;
 227         }
 228         else {
 229                 do_gettimeofday (&tt_end);
 230                 tt_end.tv_sec -= tt_start.tv_sec;
 231                 tt_end.tv_usec -= tt_start.tv_usec;
 232                 if (tt_end.tv_usec < 0) {
 233                         tt_end.tv_usec += 1000 * 1000;
 234                         tt_end.tv_sec -= 1;
 235                 }
 236         }
 237         printk("time taken is  %d\n", (unsigned int)(tt_end.tv_usec + tt_end.tv_sec * 1000000));
 238         return (tt_end.tv_usec + tt_end.tv_sec * 1000000);
 239 }
 240
 241 #ifdef RT_DEBUG
 242 /*
 243  * check that the crp action match the current session
 244  */
 245 static int
 246 ocf_check_action(struct cryptop *crp, struct cesa_ocf_data *cesa_ocf_cur_ses) {
 247         int count = 0;
 248         int encrypt = 0, decrypt = 0, auth = 0;
 249         struct cryptodesc *crd;
 250
 251         /* Go through crypto descriptors, processing as we go */
 252         for (crd = crp->crp_desc; crd; crd = crd->crd_next, count++) {
 253                 if(count > 2) {
 254                         printk("%s,%d: session mode is not supported.\n", __FILE__, __LINE__);
 255                         return 1;
 256                 }
 257
 258                 /* Encryption /Decryption */
 259                 if(crd->crd_alg == cesa_ocf_cur_ses->cipher_alg) {
 260                         /* check that the action is compatible with session */
 261                         if(encrypt || decrypt) {
 262                                 printk("%s,%d: session mode is not supported.\n", __FILE__, __LINE__);
 263                                 return 1;
 264                         }
 265
 266                         if(crd->crd_flags & CRD_F_ENCRYPT) { /* encrypt */
 267                                 if( (count == 2) && (cesa_ocf_cur_ses->encrypt_tn_auth) ) {
 268                                         printk("%s,%d: sequence isn't supported by this session.\n", __FILE__, __LINE__);
 269                                         return 1;
 270                                 }
 271                                 encrypt++;
 272                         }
 273                         else {                                  /* decrypt */
 274                                 if( (count == 2) && !(cesa_ocf_cur_ses->auth_tn_decrypt) ) {
 275                                         printk("%s,%d: sequence isn't supported by this session.\n", __FILE__, __LINE__);
 276                                         return 1;
 277                                 }
 278                                 decrypt++;
 279                         }
 280
 281                 }
 282                 /* Authentication */
 283                 else if(crd->crd_alg == cesa_ocf_cur_ses->auth_alg) {
 284                         /* check that the action is compatible with session */
 285                         if(auth) {
 286                                 printk("%s,%d: session mode is not supported.\n", __FILE__, __LINE__);
 287                                 return 1;
 288                         }
 289                         if( (count == 2) && (decrypt) && (cesa_ocf_cur_ses->auth_tn_decrypt)) {
 290                                 printk("%s,%d: sequence isn't supported by this session.\n", __FILE__, __LINE__);
 291                                 return 1;
 292                         }
 293                         if( (count == 2) && (encrypt) && !(cesa_ocf_cur_ses->encrypt_tn_auth)) {
 294                                 printk("%s,%d: sequence isn't supported by this session.\n", __FILE__, __LINE__);
 295                                 return 1;
 296                         }
 297                         auth++;
 298                 }
 299                 else {
 300                         printk("%s,%d: Alg isn't supported by this session.\n", __FILE__, __LINE__);
 301                         return 1;
 302                 }
 303         }
 304         return 0;
 305
 306 }
 307 #endif
 308
 309 /*
 310  * Process a request.
 311  */
 312 static int
 313 cesa_ocf_process(device_t dev, struct cryptop *crp, int hint)
 314 {
 315         struct cesa_ocf_process *cesa_ocf_cmd = NULL;
 316         struct cesa_ocf_process *cesa_ocf_cmd_wa = NULL;
 317         MV_CESA_COMMAND *cesa_cmd;
 318         struct cryptodesc *crd;
 319         struct cesa_ocf_data *cesa_ocf_cur_ses;
 320         int sid = 0, temp_len = 0, i;
 321         int encrypt = 0, decrypt = 0, auth = 0;
 322         int  status;
 323         struct sk_buff *skb = NULL;
 324         struct uio *uiop = NULL;
 325         unsigned char *ivp;
 326         MV_BUF_INFO *p_buf_info;
 327         MV_CESA_MBUF *p_mbuf_info;
 328         unsigned long flags;
 329
 330         dprintk("%s()\n", __FUNCTION__);
 331
 332         if( cesaReqResources <= 1 ) {
 333                 dprintk("%s,%d: ERESTART\n", __FILE__, __LINE__);
 334                 return ERESTART;
 335         }
 336
 337 #ifdef RT_DEBUG
 338         /* Sanity check */
 339         if (crp == NULL) {
 340                 printk("%s,%d: EINVAL\n", __FILE__, __LINE__);
 341                 return EINVAL;
 342         }
 343
 344         if (crp->crp_desc == NULL || crp->crp_buf == NULL ) {
 345                 printk("%s,%d: EINVAL\n", __FILE__, __LINE__);
 346                 crp->crp_etype = EINVAL;
 347                 return EINVAL;
 348         }
 349
 350         sid = crp->crp_sid & 0xffffffff;
 351         if ((sid >= CESA_OCF_MAX_SES) || (cesa_ocf_sessions[sid] == NULL)) {
 352                 crp->crp_etype = ENOENT;
 353                 printk("%s,%d: ENOENT session %d \n", __FILE__, __LINE__, sid);
 354                 return EINVAL;
 355         }
 356 #endif
 357
 358         sid = crp->crp_sid & 0xffffffff;
 359         crp->crp_etype = 0;
 360         cesa_ocf_cur_ses = cesa_ocf_sessions[sid];
 361
 362 #ifdef RT_DEBUG
 363         if(ocf_check_action(crp, cesa_ocf_cur_ses)){
 364                 goto p_error;
 365         }
 366 #endif
 367
 368         /* malloc a new  cesa process */
 369         cesa_ocf_cmd = kmalloc(sizeof(struct cesa_ocf_process), GFP_ATOMIC);
 370
 371         if (cesa_ocf_cmd == NULL) {
 372                 printk("%s,%d: ENOBUFS \n", __FILE__, __LINE__);
 373                 goto p_error;
 374         }
 375         memset(cesa_ocf_cmd, 0, sizeof(struct cesa_ocf_process));
 376
 377         /* init cesa_process */
 378         cesa_ocf_cmd->crp = crp;
 379         /* always call callback */
 380         cesa_ocf_cmd->need_cb = 1;
 381
 382         /* init cesa_cmd for usage of the HALs */
 383         cesa_cmd = &cesa_ocf_cmd->cesa_cmd;
 384         cesa_cmd->pReqPrv = (void *)cesa_ocf_cmd;
 385         cesa_cmd->sessionId = cesa_ocf_cur_ses->sid_encrypt; /* defualt use encrypt */
 386
 387         /* prepare src buffer   */
 388         /* we send the entire buffer to the HAL, even if only part of it should be encrypt/auth.  */
 389         /* if not using seesions for both encrypt and auth, then it will be wiser to to copy only */
 390         /* from skip to crd_len.                                                                  */
 391         p_buf_info = cesa_ocf_cmd->cesa_bufs;
 392         p_mbuf_info = &cesa_ocf_cmd->cesa_mbuf;
 393
 394         p_buf_info += 2; /* save 2 first buffers for IV and digest -
 395                             we won't append them to the end since, they
 396                             might be places in an unaligned addresses. */
 397
 398         p_mbuf_info->pFrags = p_buf_info;
 399         temp_len = 0;
 400
 401         /* handle SKB */
 402         if (crp->crp_flags & CRYPTO_F_SKBUF) {
 403
 404                 dprintk("%s,%d: handle SKB.\n", __FILE__, __LINE__);
 405                 skb = (struct sk_buff *) crp->crp_buf;
 406
 407                 if (skb_shinfo(skb)->nr_frags >= (MV_CESA_MAX_MBUF_FRAGS - 1)) {
 408                         printk("%s,%d: %d nr_frags > MV_CESA_MAX_MBUF_FRAGS", __FILE__, __LINE__, skb_shinfo(skb)->nr_frags);
 409                         goto p_error;
 410                 }
 411
 412                 p_mbuf_info->mbufSize = skb->len;
 413                 temp_len = skb->len;
 414                 /* first skb fragment */
 415                 p_buf_info->bufSize = skb_headlen(skb);
 416                 p_buf_info->bufVirtPtr = skb->data;
 417                 p_buf_info++;
 418
 419                 /* now handle all other skb fragments */
 420                 for ( i = 0; i < skb_shinfo(skb)->nr_frags; i++ ) {
 421                         skb_frag_t *frag = &skb_shinfo(skb)->frags[i];
 422                         p_buf_info->bufSize = frag->size;
 423                         p_buf_info->bufVirtPtr = page_address(FRAG_PAGE(frag->page)) + frag->page_offset;
 424                         p_buf_info++;
 425                 }
 426                 p_mbuf_info->numFrags = skb_shinfo(skb)->nr_frags + 1;
 427         }
 428         /* handle UIO */
 429         else if(crp->crp_flags & CRYPTO_F_IOV) {
 430
 431                 dprintk("%s,%d: handle UIO.\n", __FILE__, __LINE__);
 432                 uiop = (struct uio *) crp->crp_buf;
 433
 434                 if (uiop->uio_iovcnt > (MV_CESA_MAX_MBUF_FRAGS - 1)) {
 435                         printk("%s,%d: %d uio_iovcnt > MV_CESA_MAX_MBUF_FRAGS \n", __FILE__, __LINE__, uiop->uio_iovcnt);
 436                         goto p_error;
 437                 }
 438
 439                 p_mbuf_info->mbufSize = crp->crp_ilen;
 440                 p_mbuf_info->numFrags = uiop->uio_iovcnt;
 441                 for(i = 0; i < uiop->uio_iovcnt; i++) {
 442                         p_buf_info->bufVirtPtr = uiop->uio_iov[i].iov_base;
 443                         p_buf_info->bufSize = uiop->uio_iov[i].iov_len;
 444                         temp_len += p_buf_info->bufSize;
 445                         dprintk("%s,%d: buf %x-> addr %x, size %x \n"
 446                                 , __FILE__, __LINE__, i, (unsigned int)p_buf_info->bufVirtPtr, p_buf_info->bufSize);
 447                         p_buf_info++;
 448                 }
 449
 450         }
 451         /* handle CONTIG */
 452         else {
 453                 dprintk("%s,%d: handle CONTIG.\n", __FILE__, __LINE__);
 454                 p_mbuf_info->numFrags = 1;
 455                 p_mbuf_info->mbufSize = crp->crp_ilen;
 456                 p_buf_info->bufVirtPtr = crp->crp_buf;
 457                 p_buf_info->bufSize = crp->crp_ilen;
 458                 temp_len = crp->crp_ilen;
 459                 p_buf_info++;
 460         }
 461
 462         /* Support up to 64K why? cause! */
 463         if(crp->crp_ilen > 64*1024) {
 464                 printk("%s,%d: buf too big %x \n", __FILE__, __LINE__, crp->crp_ilen);
 465                 goto p_error;
 466         }
 467
 468         if( temp_len != crp->crp_ilen ) {
 469                 printk("%s,%d: warning size don't match.(%x %x) \n", __FILE__, __LINE__, temp_len, crp->crp_ilen);
 470         }
 471
 472         cesa_cmd->pSrc = p_mbuf_info;
 473         cesa_cmd->pDst = p_mbuf_info;
 474
 475         /* restore p_buf_info to point to first available buf */
 476         p_buf_info = cesa_ocf_cmd->cesa_bufs;
 477         p_buf_info += 1;
 478
 479
 480         /* Go through crypto descriptors, processing as we go */
 481         for (crd = crp->crp_desc; crd; crd = crd->crd_next) {
 482
 483                 /* Encryption /Decryption */
 484                 if(crd->crd_alg == cesa_ocf_cur_ses->cipher_alg) {
 485
 486                         dprintk("%s,%d: cipher", __FILE__, __LINE__);
 487
 488                         cesa_cmd->cryptoOffset = crd->crd_skip;
 489                         cesa_cmd->cryptoLength = crd->crd_len;
 490
 491                         if(crd->crd_flags & CRD_F_ENCRYPT) { /* encrypt */
 492                                 dprintk(" encrypt \n");
 493                                 encrypt++;
 494
 495                                 /* handle IV */
 496                                 if (crd->crd_flags & CRD_F_IV_EXPLICIT) {  /* IV from USER */
 497                                         dprintk("%s,%d: IV from USER (offset %x) \n", __FILE__, __LINE__, crd->crd_inject);
 498                                         cesa_cmd->ivFromUser = 1;
 499                                         ivp = crd->crd_iv;
 500
 501                                         /*
 502                                          * do we have to copy the IV back to the buffer ?
 503                                          */
 504                                         if ((crd->crd_flags & CRD_F_IV_PRESENT) == 0) {
 505                                                 dprintk("%s,%d: copy the IV back to the buffer\n", __FILE__, __LINE__);
 506                                                 cesa_cmd->ivOffset = crd->crd_inject;
 507                                                 crypto_copyback(crp->crp_flags, crp->crp_buf, crd->crd_inject, cesa_ocf_cur_ses->ivlen, ivp);
 508                                         }
 509                                         else {
 510                                                 dprintk("%s,%d: don't copy the IV back to the buffer \n", __FILE__, __LINE__);
 511                                                 p_mbuf_info->numFrags++;
 512                                                 p_mbuf_info->mbufSize += cesa_ocf_cur_ses->ivlen;
 513                                                 p_mbuf_info->pFrags = p_buf_info;
 514
 515                                                 p_buf_info->bufVirtPtr = ivp;
 516                                                 p_buf_info->bufSize = cesa_ocf_cur_ses->ivlen;
 517                                                 p_buf_info--;
 518
 519                                                 /* offsets */
 520                                                 cesa_cmd->ivOffset = 0;
 521                                                 cesa_cmd->cryptoOffset += cesa_ocf_cur_ses->ivlen;
 522                                                 if(auth) {
 523                                                         cesa_cmd->macOffset += cesa_ocf_cur_ses->ivlen;
 524                                                         cesa_cmd->digestOffset += cesa_ocf_cur_ses->ivlen;
 525                                                 }
 526                                         }
 527                                 }
 528                                 else {                                  /* random IV */
 529                                         dprintk("%s,%d: random IV \n", __FILE__, __LINE__);
 530                                         cesa_cmd->ivFromUser = 0;
 531
 532                                         /*
 533                                          * do we have to copy the IV back to the buffer ?
 534                                          */
 535                                         /* in this mode the HAL will always copy the IV */
 536                                         /* given by the session to the ivOffset         */
 537                                         if ((crd->crd_flags & CRD_F_IV_PRESENT) == 0) {
 538                                                 cesa_cmd->ivOffset = crd->crd_inject;
 539                                         }
 540                                         else {
 541                                                 /* if IV isn't copy, then how will the user know which IV did we use??? */
 542                                                 printk("%s,%d: EINVAL\n", __FILE__, __LINE__);
 543                                                 goto p_error;
 544                                         }
 545                                 }
 546                         }
 547                         else {                                  /* decrypt */
 548                                 dprintk(" decrypt \n");
 549                                 decrypt++;
 550                                 cesa_cmd->sessionId = cesa_ocf_cur_ses->sid_decrypt;
 551
 552                                 /* handle IV */
 553                                 if (crd->crd_flags & CRD_F_IV_EXPLICIT) {
 554                                         dprintk("%s,%d: IV from USER \n", __FILE__, __LINE__);
 555                                         /* append the IV buf to the mbuf */
 556                                         cesa_cmd->ivFromUser = 1;
 557                                         p_mbuf_info->numFrags++;
 558                                         p_mbuf_info->mbufSize += cesa_ocf_cur_ses->ivlen;
 559                                         p_mbuf_info->pFrags = p_buf_info;
 560
 561                                         p_buf_info->bufVirtPtr = crd->crd_iv;
 562                                         p_buf_info->bufSize = cesa_ocf_cur_ses->ivlen;
 563                                         p_buf_info--;
 564
 565                                         /* offsets */
 566                                         cesa_cmd->ivOffset = 0;
 567                                         cesa_cmd->cryptoOffset += cesa_ocf_cur_ses->ivlen;
 568                                         if(auth) {
 569                                                 cesa_cmd->macOffset += cesa_ocf_cur_ses->ivlen;
 570                                                 cesa_cmd->digestOffset += cesa_ocf_cur_ses->ivlen;
 571                                         }
 572                                 }
 573                                 else {
 574                                         dprintk("%s,%d: IV inside the buffer \n", __FILE__, __LINE__);
 575                                         cesa_cmd->ivFromUser = 0;
 576                                         cesa_cmd->ivOffset = crd->crd_inject;
 577                                 }
 578                         }
 579
 580                 }
 581                 /* Authentication */
 582                 else if(crd->crd_alg == cesa_ocf_cur_ses->auth_alg) {
 583                         dprintk("%s,%d:  Authentication \n", __FILE__, __LINE__);
 584                         auth++;
 585                         cesa_cmd->macOffset = crd->crd_skip;
 586                         cesa_cmd->macLength = crd->crd_len;
 587
 588                         /* digest + mac */
 589                         cesa_cmd->digestOffset = crd->crd_inject;
 590                 }
 591                 else {
 592                         printk("%s,%d: Alg isn't supported by this session.\n", __FILE__, __LINE__);
 593                         goto p_error;
 594                 }
 595         }
 596
 597         dprintk("\n");
 598         dprintk("%s,%d: Sending Action: \n", __FILE__, __LINE__);
 599         dprintk("%s,%d: IV from user: %d. IV offset %x \n",  __FILE__, __LINE__, cesa_cmd->ivFromUser, cesa_cmd->ivOffset);
 600         dprintk("%s,%d: crypt offset %x len %x \n", __FILE__, __LINE__, cesa_cmd->cryptoOffset, cesa_cmd->cryptoLength);
 601         dprintk("%s,%d: Auth offset %x len %x \n", __FILE__, __LINE__, cesa_cmd->macOffset, cesa_cmd->macLength);
 602         dprintk("%s,%d: set digest in offset %x . \n", __FILE__, __LINE__, cesa_cmd->digestOffset);
 603         if(debug) {
 604                 mvCesaDebugMbuf("SRC BUFFER", cesa_cmd->pSrc, 0, cesa_cmd->pSrc->mbufSize);
 605         }
 606
 607
 608         /* send action to HAL */
 609         spin_lock_irqsave(&cesa_lock, flags);
 610         status = mvCesaAction(cesa_cmd);
 611         spin_unlock_irqrestore(&cesa_lock, flags);
 612
 613         /* action not allowed */
 614         if(status == MV_NOT_ALLOWED) {
 615 #ifdef CESA_OCF_SPLIT
 616                 /* if both encrypt and auth try to split */
 617                 if(auth && (encrypt || decrypt)) {
 618                         MV_CESA_COMMAND *cesa_cmd_wa;
 619
 620                         /* malloc a new cesa process and init it */
 621                         cesa_ocf_cmd_wa = kmalloc(sizeof(struct cesa_ocf_process), GFP_ATOMIC);
 622
 623                         if (cesa_ocf_cmd_wa == NULL) {
 624                                 printk("%s,%d: ENOBUFS \n", __FILE__, __LINE__);
 625                                 goto p_error;
 626                         }
 627                         memcpy(cesa_ocf_cmd_wa, cesa_ocf_cmd, sizeof(struct cesa_ocf_process));
 628                         cesa_cmd_wa = &cesa_ocf_cmd_wa->cesa_cmd;
 629                         cesa_cmd_wa->pReqPrv = (void *)cesa_ocf_cmd_wa;
 630                         cesa_ocf_cmd_wa->need_cb = 0;
 631
 632                         /* break requests to two operation, first operation completion won't call callback */
 633                         if((decrypt) && (cesa_ocf_cur_ses->auth_tn_decrypt)) {
 634                                 cesa_cmd_wa->sessionId = cesa_ocf_cur_ses->frag_wa_auth;
 635                                 cesa_cmd->sessionId = cesa_ocf_cur_ses->frag_wa_decrypt;
 636                         }
 637                         else if((decrypt) && !(cesa_ocf_cur_ses->auth_tn_decrypt)) {
 638                                 cesa_cmd_wa->sessionId = cesa_ocf_cur_ses->frag_wa_decrypt;
 639                                 cesa_cmd->sessionId = cesa_ocf_cur_ses->frag_wa_auth;
 640                         }
 641                         else if((encrypt) && (cesa_ocf_cur_ses->encrypt_tn_auth)) {
 642                                 cesa_cmd_wa->sessionId = cesa_ocf_cur_ses->frag_wa_encrypt;
 643                                 cesa_cmd->sessionId = cesa_ocf_cur_ses->frag_wa_auth;
 644                         }
 645                         else if((encrypt) && !(cesa_ocf_cur_ses->encrypt_tn_auth)){
 646                                 cesa_cmd_wa->sessionId = cesa_ocf_cur_ses->frag_wa_auth;
 647                                 cesa_cmd->sessionId = cesa_ocf_cur_ses->frag_wa_encrypt;
 648                         }
 649                         else {
 650                                 printk("%s,%d: Unsupporterd fragment wa mode \n", __FILE__, __LINE__);
 651                                 goto p_error;
 652                         }
 653
 654                         /* send the 2 actions to the HAL */
 655                         spin_lock_irqsave(&cesa_lock, flags);
 656                         status = mvCesaAction(cesa_cmd_wa);
 657                         spin_unlock_irqrestore(&cesa_lock, flags);
 658
 659                         if((status != MV_NO_MORE) && (status != MV_OK)) {
 660                                 printk("%s,%d: cesa action failed, status = 0x%x\n", __FILE__, __LINE__, status);
 661                                 goto p_error;
 662                         }
 663                         spin_lock_irqsave(&cesa_lock, flags);
 664                         status = mvCesaAction(cesa_cmd);
 665                         spin_unlock_irqrestore(&cesa_lock, flags);
 666
 667                 }
 668                 /* action not allowed and can't split */
 669                 else
 670 #endif
 671                 {
 672                         goto p_error;
 673                 }
 674         }
 675
 676         /* Hal Q is full, send again. This should never happen */
 677         if(status == MV_NO_RESOURCE) {
 678                 printk("%s,%d: cesa no more resources \n", __FILE__, __LINE__);
 679                 if(cesa_ocf_cmd)
 680                         kfree(cesa_ocf_cmd);
 681                 if(cesa_ocf_cmd_wa)
 682                         kfree(cesa_ocf_cmd_wa);
 683                 return ERESTART;
 684         }
 685         else if((status != MV_NO_MORE) && (status != MV_OK)) {
 686                 printk("%s,%d: cesa action failed, status = 0x%x\n", __FILE__, __LINE__, status);
 687                 goto p_error;
 688         }
 689
 690
 691 #ifdef CESA_OCF_POLLING
 692         cesa_interrupt_polling();
 693 #endif
 694         cesaTestTraceAdd(5);
 695
 696         return 0;
 697 p_error:
 698         crp->crp_etype = EINVAL;
 699         if(cesa_ocf_cmd)
 700                 kfree(cesa_ocf_cmd);
 701         if(cesa_ocf_cmd_wa)
 702                 kfree(cesa_ocf_cmd_wa);
 703         return EINVAL;
 704 }
 705
 706 /*
 707  * cesa callback.
 708  */
 709 static void
 710 cesa_callback(unsigned long dummy)
 711 {
 712         struct cesa_ocf_process *cesa_ocf_cmd = NULL;
 713         struct cryptop          *crp = NULL;
 714         MV_CESA_RESULT          result[MV_CESA_MAX_CHAN];
 715         int                     res_idx = 0,i;
 716         MV_STATUS               status;
 717
 718         dprintk("%s()\n", __FUNCTION__);
 719
 720 #ifdef CESA_OCF_TASKLET
 721         disable_irq(cesa_device.irq);
 722 #endif
 723     while(MV_TRUE) {
 724
 725                  /* Get Ready requests */
 726                 spin_lock(&cesa_lock);
 727                 status = mvCesaReadyGet(&result[res_idx]);
 728                 spin_unlock(&cesa_lock);
 729
 730                 cesaTestTraceAdd(2);
 731
 732                     if(status != MV_OK) {
 733 #ifdef CESA_OCF_POLLING
 734                         if(status == MV_BUSY) { /* Fragment */
 735                                 cesa_interrupt_polling();
 736                                 return;
 737                         }
 738 #endif
 739                     break;
 740             }
 741                 res_idx++;
 742                     break;
 743             }
 744
 745         for(i = 0; i < res_idx; i++) {
 746
 747                 if(!result[i].pReqPrv) {
 748                         printk("%s,%d: warning private is NULL\n", __FILE__, __LINE__);
 749                         break;
 750                 }
 751
 752                 cesa_ocf_cmd = result[i].pReqPrv;
 753                 crp = cesa_ocf_cmd->crp;
 754
 755                 // ignore HMAC error.
 756                 //if(result->retCode)
 757                 //      crp->crp_etype = EIO;
 758
 759 #if  defined(CESA_OCF_POLLING)
 760                 if(!cesa_ocf_cmd->need_cb){
 761                         cesa_interrupt_polling();
 762                 }
 763 #endif
 764                 if(cesa_ocf_cmd->need_cb) {
 765                         if(debug) {
 766                                 mvCesaDebugMbuf("DST BUFFER", cesa_ocf_cmd->cesa_cmd.pDst, 0, cesa_ocf_cmd->cesa_cmd.pDst->mbufSize);
 767                         }
 768                         crypto_done(crp);
 769                 }
 770                 kfree(cesa_ocf_cmd);
 771         }
 772 #ifdef CESA_OCF_TASKLET
 773         enable_irq(cesa_device.irq);
 774 #endif
 775
 776         cesaTestTraceAdd(3);
 777
 778         return;
 779 }
 780
 781 #ifdef CESA_OCF_POLLING
 782 static void
 783 cesa_interrupt_polling(void)
 784 {
 785         u32                     cause;
 786
 787         dprintk("%s()\n", __FUNCTION__);
 788
 789         /* Read cause register */
 790         do {
 791                 cause = MV_REG_READ(MV_CESA_ISR_CAUSE_REG);
 792                 cause &= MV_CESA_CAUSE_ACC_DMA_ALL_MASK;
 793
 794         } while (cause == 0);
 795
 796         /* clear interrupts */
 797         MV_REG_WRITE(MV_CESA_ISR_CAUSE_REG, 0);
 798
 799         cesa_callback(0);
 800
 801         return;
 802 }
 803
 804 #endif
 805
 806 /*
 807  * cesa Interrupt polling routine.
 808  */
 809 static irqreturn_t
 810 cesa_interrupt_handler(int irq, void *arg)
 811 {
 812         u32                     cause;
 813
 814         dprintk("%s()\n", __FUNCTION__);
 815
 816         cesaTestTraceAdd(0);
 817
 818         /* Read cause register */
 819         cause = MV_REG_READ(MV_CESA_ISR_CAUSE_REG);
 820
 821         if( (cause & MV_CESA_CAUSE_ACC_DMA_ALL_MASK) == 0)
 822         {
 823         /* Empty interrupt */
 824                 dprintk("%s,%d: cesaTestReadyIsr: cause=0x%x\n", __FILE__, __LINE__, cause);
 825                 return IRQ_HANDLED;
 826         }
 827
 828         /* clear interrupts */
 829         MV_REG_WRITE(MV_CESA_ISR_CAUSE_REG, 0);
 830
 831         cesaTestTraceAdd(1);
 832 #ifdef CESA_OCF_TASKLET
 833         tasklet_hi_schedule(&cesa_ocf_tasklet);
 834 #else
 835         cesa_callback(0);
 836 #endif
 837         return IRQ_HANDLED;
 838 }
 839
 840 /*
 841  * Open a session.
 842  */
 843 static int
 844 /*cesa_ocf_newsession(void *arg, u_int32_t *sid, struct cryptoini *cri)*/
 845 cesa_ocf_newsession(device_t dev, u_int32_t *sid, struct cryptoini *cri)
 846 {
 847         u32 status = 0, i;
 848         u32 count = 0, auth = 0, encrypt =0;
 849         struct cesa_ocf_data *cesa_ocf_cur_ses;
 850         MV_CESA_OPEN_SESSION cesa_session;
 851         MV_CESA_OPEN_SESSION *cesa_ses = &cesa_session;
 852
 853
 854         dprintk("%s()\n", __FUNCTION__);
 855         if (sid == NULL || cri == NULL) {
 856                 printk("%s,%d: EINVAL\n", __FILE__, __LINE__);
 857                 return EINVAL;
 858         }
 859
 860         /* leave first empty like in other implementations */
 861         for (i = 1; i < CESA_OCF_MAX_SES; i++) {
 862                 if (cesa_ocf_sessions[i] == NULL)
 863                         break;
 864         }
 865
 866         if(i >= CESA_OCF_MAX_SES) {
 867                 printk("%s,%d: no more sessions \n", __FILE__, __LINE__);
 868                 return EINVAL;
 869         }
 870
 871         cesa_ocf_sessions[i] = (struct cesa_ocf_data *) kmalloc(sizeof(struct cesa_ocf_data), GFP_ATOMIC);
 872         if (cesa_ocf_sessions[i] == NULL) {
 873                 cesa_ocf_freesession(NULL, i);
 874                 printk("%s,%d: ENOBUFS \n", __FILE__, __LINE__);
 875                 return ENOBUFS;
 876         }
 877         dprintk("%s,%d: new session %d \n", __FILE__, __LINE__, i);
 878
 879         *sid = i;
 880         cesa_ocf_cur_ses = cesa_ocf_sessions[i];
 881         memset(cesa_ocf_cur_ses, 0, sizeof(struct cesa_ocf_data));
 882         cesa_ocf_cur_ses->sid_encrypt = -1;
 883         cesa_ocf_cur_ses->sid_decrypt = -1;
 884         cesa_ocf_cur_ses->frag_wa_encrypt = -1;
 885         cesa_ocf_cur_ses->frag_wa_decrypt = -1;
 886         cesa_ocf_cur_ses->frag_wa_auth = -1;
 887
 888         /* init the session */
 889         memset(cesa_ses, 0, sizeof(MV_CESA_OPEN_SESSION));
 890         count = 1;
 891         while (cri) {
 892                 if(count > 2) {
 893                         printk("%s,%d: don't support more then 2 operations\n", __FILE__, __LINE__);
 894                         goto error;
 895                 }
 896                 switch (cri->cri_alg) {
 897                 case CRYPTO_AES_CBC:
 898                         dprintk("%s,%d: (%d) AES CBC \n", __FILE__, __LINE__, count);
 899                         cesa_ocf_cur_ses->cipher_alg = cri->cri_alg;
 900                         cesa_ocf_cur_ses->ivlen = MV_CESA_AES_BLOCK_SIZE;
 901                         cesa_ses->cryptoAlgorithm = MV_CESA_CRYPTO_AES;
 902                         cesa_ses->cryptoMode = MV_CESA_CRYPTO_CBC;
 903                         if(cri->cri_klen/8 > MV_CESA_MAX_CRYPTO_KEY_LENGTH) {
 904                                 printk("%s,%d: CRYPTO key too long.\n", __FILE__, __LINE__);
 905                                 goto error;
 906                         }
 907                         memcpy(cesa_ses->cryptoKey, cri->cri_key, cri->cri_klen/8);
 908                         dprintk("%s,%d: key length %d \n", __FILE__, __LINE__, cri->cri_klen/8);
 909                         cesa_ses->cryptoKeyLength = cri->cri_klen/8;
 910                         encrypt += count;
 911                         break;
 912                 case CRYPTO_3DES_CBC:
 913                         dprintk("%s,%d: (%d) 3DES CBC \n", __FILE__, __LINE__, count);
 914                         cesa_ocf_cur_ses->cipher_alg = cri->cri_alg;
 915                         cesa_ocf_cur_ses->ivlen = MV_CESA_3DES_BLOCK_SIZE;
 916                         cesa_ses->cryptoAlgorithm = MV_CESA_CRYPTO_3DES;
 917                         cesa_ses->cryptoMode = MV_CESA_CRYPTO_CBC;
 918                         if(cri->cri_klen/8 > MV_CESA_MAX_CRYPTO_KEY_LENGTH) {
 919                                 printk("%s,%d: CRYPTO key too long.\n", __FILE__, __LINE__);
 920                                 goto error;
 921                         }
 922                         memcpy(cesa_ses->cryptoKey, cri->cri_key, cri->cri_klen/8);
 923                         cesa_ses->cryptoKeyLength = cri->cri_klen/8;
 924                         encrypt += count;
 925                         break;
 926                 case CRYPTO_DES_CBC:
 927                         dprintk("%s,%d: (%d) DES CBC \n", __FILE__, __LINE__, count);
 928                         cesa_ocf_cur_ses->cipher_alg = cri->cri_alg;
 929                         cesa_ocf_cur_ses->ivlen = MV_CESA_DES_BLOCK_SIZE;
 930                         cesa_ses->cryptoAlgorithm = MV_CESA_CRYPTO_DES;
 931                         cesa_ses->cryptoMode = MV_CESA_CRYPTO_CBC;
 932                         if(cri->cri_klen/8 > MV_CESA_MAX_CRYPTO_KEY_LENGTH) {
 933                                 printk("%s,%d: CRYPTO key too long.\n", __FILE__, __LINE__);
 934                                 goto error;
 935                         }
 936                         memcpy(cesa_ses->cryptoKey, cri->cri_key, cri->cri_klen/8);
 937                         cesa_ses->cryptoKeyLength = cri->cri_klen/8;
 938                         encrypt += count;
 939                         break;
 940                 case CRYPTO_MD5:
 941                 case CRYPTO_MD5_HMAC:
 942                         dprintk("%s,%d: (%d) %sMD5 CBC \n", __FILE__, __LINE__, count, (cri->cri_alg != CRYPTO_MD5)? "H-":" ");
 943                         cesa_ocf_cur_ses->auth_alg = cri->cri_alg;
 944                         cesa_ocf_cur_ses->digestlen = (cri->cri_alg == CRYPTO_MD5)? MV_CESA_MD5_DIGEST_SIZE : 12;
 945                         cesa_ses->macMode = (cri->cri_alg == CRYPTO_MD5)? MV_CESA_MAC_MD5 : MV_CESA_MAC_HMAC_MD5;
 946                         if(cri->cri_klen/8 > MV_CESA_MAX_CRYPTO_KEY_LENGTH) {
 947                                 printk("%s,%d: MAC key too long. \n", __FILE__, __LINE__);
 948                                 goto error;
 949                         }
 950                         cesa_ses->macKeyLength = cri->cri_klen/8;
 951                         memcpy(cesa_ses->macKey, cri->cri_key, cri->cri_klen/8);
 952                         cesa_ses->digestSize = cesa_ocf_cur_ses->digestlen;
 953                         auth += count;
 954                         break;
 955                 case CRYPTO_SHA1:
 956                 case CRYPTO_SHA1_HMAC:
 957                         dprintk("%s,%d: (%d) %sSHA1 CBC \n", __FILE__, __LINE__, count, (cri->cri_alg != CRYPTO_SHA1)? "H-":" ");
 958                         cesa_ocf_cur_ses->auth_alg = cri->cri_alg;
 959                         cesa_ocf_cur_ses->digestlen = (cri->cri_alg == CRYPTO_SHA1)? MV_CESA_SHA1_DIGEST_SIZE : 12;
 960                         cesa_ses->macMode = (cri->cri_alg == CRYPTO_SHA1)? MV_CESA_MAC_SHA1 : MV_CESA_MAC_HMAC_SHA1;
 961                         if(cri->cri_klen/8 > MV_CESA_MAX_CRYPTO_KEY_LENGTH) {
 962                                 printk("%s,%d: MAC key too long. \n", __FILE__, __LINE__);
 963                                 goto error;
 964                         }
 965                         cesa_ses->macKeyLength = cri->cri_klen/8;
 966                         memcpy(cesa_ses->macKey, cri->cri_key, cri->cri_klen/8);
 967                         cesa_ses->digestSize = cesa_ocf_cur_ses->digestlen;
 968                         auth += count;
 969                         break;
 970                 default:
 971                         printk("%s,%d: unknown algo 0x%x\n", __FILE__, __LINE__, cri->cri_alg);
 972                         goto error;
 973                 }
 974                 cri = cri->cri_next;
 975                 count++;
 976         }
 977
 978         if((encrypt > 2) || (auth > 2)) {
 979                 printk("%s,%d: session mode is not supported.\n", __FILE__, __LINE__);
 980                 goto error;
 981         }
 982         /* create new sessions in HAL */
 983         if(encrypt) {
 984                 cesa_ses->operation = MV_CESA_CRYPTO_ONLY;
 985                 /* encrypt session */
 986                 if(auth == 1) {
 987                         cesa_ses->operation = MV_CESA_MAC_THEN_CRYPTO;
 988                 }
 989                 else if(auth == 2) {
 990                         cesa_ses->operation = MV_CESA_CRYPTO_THEN_MAC;
 991                         cesa_ocf_cur_ses->encrypt_tn_auth = 1;
 992                 }
 993                 else {
 994                         cesa_ses->operation = MV_CESA_CRYPTO_ONLY;
 995                 }
 996                 cesa_ses->direction = MV_CESA_DIR_ENCODE;
 997                 status = mvCesaSessionOpen(cesa_ses, &cesa_ocf_cur_ses->sid_encrypt);
 998                 if(status != MV_OK) {
 999                         printk("%s,%d: Can't open new session - status = 0x%x\n", __FILE__, __LINE__, status);
1000                         goto error;
1001                 }
1002                 /* decrypt session */
1003                 if( cesa_ses->operation == MV_CESA_MAC_THEN_CRYPTO ) {
1004                         cesa_ses->operation = MV_CESA_CRYPTO_THEN_MAC;
1005                 }
1006                 else if( cesa_ses->operation == MV_CESA_CRYPTO_THEN_MAC ) {
1007                         cesa_ses->operation = MV_CESA_MAC_THEN_CRYPTO;
1008                 }
1009                 cesa_ses->direction = MV_CESA_DIR_DECODE;
1010                 status = mvCesaSessionOpen(cesa_ses, &cesa_ocf_cur_ses->sid_decrypt);
1011                 if(status != MV_OK) {
1012                         printk("%s,%d: Can't open new session - status = 0x%x\n", __FILE__, __LINE__, status);
1013                         goto error;
1014                 }
1015
1016                 /* preapre one action sessions for case we will need to split an action */
1017 #ifdef CESA_OCF_SPLIT
1018                 if(( cesa_ses->operation == MV_CESA_MAC_THEN_CRYPTO ) ||
1019                         ( cesa_ses->operation == MV_CESA_CRYPTO_THEN_MAC )) {
1020                         /* open one session for encode and one for decode */
1021                         cesa_ses->operation = MV_CESA_CRYPTO_ONLY;
1022                         cesa_ses->direction = MV_CESA_DIR_ENCODE;
1023                         status = mvCesaSessionOpen(cesa_ses, &cesa_ocf_cur_ses->frag_wa_encrypt);
1024                         if(status != MV_OK) {
1025                                 printk("%s,%d: Can't open new session - status = 0x%x\n", __FILE__, __LINE__, status);
1026                                 goto error;
1027                         }
1028
1029                         cesa_ses->direction = MV_CESA_DIR_DECODE;
1030                         status = mvCesaSessionOpen(cesa_ses, &cesa_ocf_cur_ses->frag_wa_decrypt);
1031                         if(status != MV_OK) {
1032                                 printk("%s,%d: Can't open new session - status = 0x%x\n", __FILE__, __LINE__, status);
1033                                 goto error;
1034                         }
1035                         /* open one session for auth */
1036                         cesa_ses->operation = MV_CESA_MAC_ONLY;
1037                         cesa_ses->direction = MV_CESA_DIR_ENCODE;
1038                         status = mvCesaSessionOpen(cesa_ses, &cesa_ocf_cur_ses->frag_wa_auth);
1039                         if(status != MV_OK) {
1040                                 printk("%s,%d: Can't open new session - status = 0x%x\n", __FILE__, __LINE__, status);
1041                                 goto error;
1042                         }
1043                 }
1044 #endif
1045         }
1046         else { /* only auth */
1047                 cesa_ses->operation = MV_CESA_MAC_ONLY;
1048                 cesa_ses->direction = MV_CESA_DIR_ENCODE;
1049                 status = mvCesaSessionOpen(cesa_ses, &cesa_ocf_cur_ses->sid_encrypt);
1050                 if(status != MV_OK) {
1051                         printk("%s,%d: Can't open new session - status = 0x%x\n", __FILE__, __LINE__, status);
1052                         goto error;
1053                 }
1054         }
1055
1056         return 0;
1057 error:
1058         cesa_ocf_freesession(NULL, *sid);
1059         return EINVAL;
1060
1061 }
1062
1063
1064 /*
1065  * Free a session.
1066  */
1067 static int
1068 cesa_ocf_freesession(device_t dev, u_int64_t tid)
1069 {
1070         struct cesa_ocf_data *cesa_ocf_cur_ses;
1071         u_int32_t sid = CRYPTO_SESID2LID(tid);
1072         //unsigned long flags;
1073
1074         dprintk("%s() %d \n", __FUNCTION__, sid);
1075         if ( (sid >= CESA_OCF_MAX_SES) || (cesa_ocf_sessions[sid] == NULL) ) {
1076                 printk("%s,%d: EINVAL can't free session %d \n", __FILE__, __LINE__, sid);
1077                 return(EINVAL);
1078         }
1079
1080         /* Silently accept and return */
1081         if (sid == 0)
1082                 return(0);
1083
1084         /* release session from HAL */
1085         cesa_ocf_cur_ses = cesa_ocf_sessions[sid];
1086         if (cesa_ocf_cur_ses->sid_encrypt != -1) {
1087                 mvCesaSessionClose(cesa_ocf_cur_ses->sid_encrypt);
1088         }
1089         if (cesa_ocf_cur_ses->sid_decrypt != -1) {
1090                 mvCesaSessionClose(cesa_ocf_cur_ses->sid_decrypt);
1091         }
1092         if (cesa_ocf_cur_ses->frag_wa_encrypt != -1) {
1093                 mvCesaSessionClose(cesa_ocf_cur_ses->frag_wa_encrypt);
1094         }
1095         if (cesa_ocf_cur_ses->frag_wa_decrypt != -1) {
1096                 mvCesaSessionClose(cesa_ocf_cur_ses->frag_wa_decrypt);
1097         }
1098         if (cesa_ocf_cur_ses->frag_wa_auth != -1) {
1099                 mvCesaSessionClose(cesa_ocf_cur_ses->frag_wa_auth);
1100         }
1101
1102         kfree(cesa_ocf_cur_ses);
1103         cesa_ocf_sessions[sid] = NULL;
1104
1105         return 0;
1106 }
1107
1108
1109 /* TDMA Window setup */
1110
1111 static void __init
1112 setup_tdma_mbus_windows(struct cesa_dev *dev)
1113 {
1114     int i;
1115
1116     for (i = 0; i < 4; i++) {
1117         writel(0, dev->reg + WINDOW_BASE(i));
1118         writel(0, dev->reg + WINDOW_CTRL(i));
1119     }
1120
1121     for (i = 0; i < dev->plat_data->dram->num_cs; i++) {
1122         struct mbus_dram_window *cs = dev->plat_data->dram->cs + i;
1123         writel(
1124             ((cs->size - 1) & 0xffff0000) |
1125             (cs->mbus_attr << 8) |
1126             (dev->plat_data->dram->mbus_dram_target_id << 4) | 1,
1127             dev->reg + WINDOW_CTRL(i)
1128         );
1129         writel(cs->base, dev->reg + WINDOW_BASE(i));
1130     }
1131 }
1132
1133 /*
1134  * our driver startup and shutdown routines
1135  */
1136 static int
1137 mv_cesa_ocf_init(struct platform_device *pdev)
1138 {
1139 #if defined(CONFIG_MV78200) || defined(CONFIG_MV632X)
1140         if (MV_FALSE == mvSocUnitIsMappedToThisCpu(CESA))
1141         {
1142                 dprintk("CESA is not mapped to this CPU\n");
1143                 return -ENODEV;
1144         }
1145 #endif
1146
1147         dprintk("%s\n", __FUNCTION__);
1148         memset(&mv_cesa_dev, 0, sizeof(mv_cesa_dev));
1149         softc_device_init(&mv_cesa_dev, "MV CESA", 0, mv_cesa_methods);
1150         cesa_ocf_id = crypto_get_driverid(softc_get_device(&mv_cesa_dev),CRYPTOCAP_F_HARDWARE);
1151
1152         if (cesa_ocf_id < 0)
1153                 panic("MV CESA crypto device cannot initialize!");
1154
1155         dprintk("%s,%d: cesa ocf device id is %d \n", __FILE__, __LINE__, cesa_ocf_id);
1156
1157         /* CESA unit is auto power on off */
1158 #if 0
1159         if (MV_FALSE == mvCtrlPwrClckGet(CESA_UNIT_ID,0))
1160         {
1161                 printk("\nWarning CESA %d is Powered Off\n",0);
1162                 return EINVAL;
1163         }
1164 #endif
1165
1166         memset(&cesa_device, 0, sizeof(struct cesa_dev));
1167         /* Get the IRQ, and crypto memory regions */
1168         {
1169                 struct resource *res;
1170                 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "sram");
1171
1172                 if (!res)
1173                         return -ENXIO;
1174
1175                 cesa_device.sram = ioremap(res->start, res->end - res->start + 1);
1176                 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs");
1177
1178                 if (!res) {
1179                         iounmap(cesa_device.sram);
1180                         return -ENXIO;
1181                 }
1182                 cesa_device.reg = ioremap(res->start, res->end - res->start + 1);
1183                 cesa_device.irq = platform_get_irq(pdev, 0);
1184                 cesa_device.plat_data = pdev->dev.platform_data;
1185                 setup_tdma_mbus_windows(&cesa_device);
1186
1187         }
1188
1189
1190         if( MV_OK != mvCesaInit(CESA_OCF_MAX_SES*5, CESA_Q_SIZE, cesa_device.reg,
1191                                 NULL) ) {
1192                 printk("%s,%d: mvCesaInit Failed. \n", __FILE__, __LINE__);
1193                 return EINVAL;
1194         }
1195
1196         /* clear and unmask Int */
1197         MV_REG_WRITE( MV_CESA_ISR_CAUSE_REG, 0);
1198 #ifndef CESA_OCF_POLLING
1199     MV_REG_WRITE( MV_CESA_ISR_MASK_REG, MV_CESA_CAUSE_ACC_DMA_MASK);
1200 #endif
1201 #ifdef CESA_OCF_TASKLET
1202         tasklet_init(&cesa_ocf_tasklet, cesa_callback, (unsigned int) 0);
1203 #endif
1204         /* register interrupt */
1205         if( request_irq( cesa_device.irq, cesa_interrupt_handler,
1206                              (IRQF_DISABLED) , "cesa", &cesa_ocf_id) < 0) {
1207                 printk("%s,%d: cannot assign irq %x\n", __FILE__, __LINE__, cesa_device.reg);
1208                 return EINVAL;
1209         }
1210
1211
1212         memset(cesa_ocf_sessions, 0, sizeof(struct cesa_ocf_data *) * CESA_OCF_MAX_SES);
1213
1214 #define REGISTER(alg) \
1215         crypto_register(cesa_ocf_id, alg, 0,0)
1216         REGISTER(CRYPTO_AES_CBC);
1217         REGISTER(CRYPTO_DES_CBC);
1218         REGISTER(CRYPTO_3DES_CBC);
1219         REGISTER(CRYPTO_MD5);
1220         REGISTER(CRYPTO_MD5_HMAC);
1221         REGISTER(CRYPTO_SHA1);
1222         REGISTER(CRYPTO_SHA1_HMAC);
1223 #undef REGISTER
1224
1225         return 0;
1226 }
1227
1228 static void
1229 mv_cesa_ocf_exit(struct platform_device *pdev)
1230 {
1231         dprintk("%s()\n", __FUNCTION__);
1232
1233         crypto_unregister_all(cesa_ocf_id);
1234         cesa_ocf_id = -1;
1235         iounmap(cesa_device.reg);
1236         iounmap(cesa_device.sram);
1237         free_irq(cesa_device.irq, NULL);
1238
1239         /* mask and clear Int */
1240         MV_REG_WRITE( MV_CESA_ISR_MASK_REG, 0);
1241         MV_REG_WRITE( MV_CESA_ISR_CAUSE_REG, 0);
1242
1243
1244         if( MV_OK != mvCesaFinish() ) {
1245                 printk("%s,%d: mvCesaFinish Failed. \n", __FILE__, __LINE__);
1246                 return;
1247         }
1248 }
1249
1250
1251 void cesa_ocf_debug(void)
1252 {
1253
1254 #ifdef CESA_OCF_TRACE_DEBUG
1255     {
1256         int i, j;
1257         j = cesaTestTraceIdx;
1258         mvOsPrintf("No  Type   rCause   iCause   Proc   Isr   Res     Time     pReady    pProc    pEmpty\n");
1259         for(i=0; i<MV_CESA_TEST_TRACE_SIZE; i++)
1260         {
1261             mvOsPrintf("%02d.  %d   0x%04x   0x%04x   0x%02x   0x%02x   %02d   0x%06x  %p  %p  %p\n",
1262                 j, cesaTestTrace[j].type, cesaTestTrace[j].realCause,
1263                 cesaTestTrace[j].idmaCause,
1264                 cesaTestTrace[j].resources, cesaTestTrace[j].timeStamp,
1265                 cesaTestTrace[j].pReqReady, cesaTestTrace[j].pReqProcess, cesaTestTrace[j].pReqEmpty);
1266             j++;
1267             if(j == MV_CESA_TEST_TRACE_SIZE)
1268                 j = 0;
1269         }
1270     }
1271 #endif
1272
1273 }
1274
1275 static struct platform_driver marvell_cesa = {
1276         .probe          = mv_cesa_ocf_init,
1277         .remove         = mv_cesa_ocf_exit,
1278         .driver         = {
1279                 .owner  = THIS_MODULE,
1280                 .name   = "mv_crypto",
1281         },
1282 };
1283
1284 MODULE_ALIAS("platform:mv_crypto");
1285
1286 static int __init mv_cesa_init(void)
1287 {
1288         return platform_driver_register(&marvell_cesa);
1289 }
1290
1291 module_init(mv_cesa_init);
1292
1293 static void __exit mv_cesa_exit(void)
1294 {
1295         platform_driver_unregister(&marvell_cesa);
1296 }
1297
1298 module_exit(mv_cesa_exit);
1299
1300 MODULE_LICENSE("GPL");
1301 MODULE_AUTHOR("Ronen Shitrit");
1302 MODULE_DESCRIPTION("OCF module for Orion CESA crypto");