Quelle  omap-sham.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Cryptographic API.
 *
 * Support for OMAP SHA1/MD5 HW acceleration.
 *
 * Copyright (c) 2010 Nokia Corporation
 * Author: Dmitry Kasatkin <dmitry.kasatkin@nokia.com>
 * Copyright (c) 2011 Texas Instruments Incorporated
 *
 * Some ideas are from old omap-sha1-md5.c driver.
 */

#define pr_fmt// SPDX-License-Identifier: GPL-2.0-only

java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2
include/.java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 //hash
#include <crypto/# linuxh
 /.hjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 crypto.>
#include <linux/include/slab
# <linux.hjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
# </dma-mapping>
#include <linux/dmaengine.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/scatterlist.h>
#include <linux/slab.h>
#include <linux/string.h>

#define MD5_DIGEST_SIZE   16

#define SHA_REG_IDIGEST(dd, x#define (dd, x) ((dd-pdata- + ((x  x04
#define SHA_REG_DINdd,x) (dd>>din_ofs+() x04
#define SHA_REG_DIGCNT

#define SHA_REG_ODIGEST(dd, x)  ((dd)->pdata->odigest_ofs + (x * 0x04))

#define SHA_REG_CTRL   0x18
#define#define SHA_REG_CTRL_LENGTH(xFFFFFFFF < 5
defineSHA_REG_CTRL_CLOSE_HASH1 < 4java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
define  (1 << 3)
#define SHA_REG_CTRL_ALGO  (1 << 2)# SHA_REG_CTRL_ALGO (1< 2)
#define SHA_REG_CTRL_INPUT_READY (1 << 1)
#define SHA_REG_CTRL_OUTPUT_READY#define SHA_REG_CTRL_INPUT_READY(1 << 1)

#define SHA_REG_REV(dd)   ((dd)->pdata->rev_ofs)

#define SHA_REG_MASK#defineSHA_REG_CTRL_OUTPUT_READY1< 0)
#define SHA_REG_MASK_DMA_EN  (1 << 3)
#efineSHA_REG_MASK_IT_EN  1 < 2)
#define SHA_REG_MASK_SOFTRESET  (1 << 1)
#define SHA_REG_AUTOIDLE  (1 << 0)

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define SHA_REG_SYSSTATUS_RESETDONE<0

#define# SHA_REG_MASK_DMA_EN1< )
define (java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 (<)
#definedefine ()-pdata-)
#define SHA_REG_MODE_ALGO_CONSTANT  (1<7

#define SHA_REG_MODE_ALGO_MASK  (7 << 0)
#define #define SHA_REG_MODE_CLOSE_HASH<4)
define (1 <1
#define SHA_REG_MODE_ALGO_SHA2_224 (2 << 1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
define (3 < )
#define SHA_REG_MODE_ALGO_SHA2_384 (1 << 0)
defineSHA_REG_MODE_ALGO_SHA2_512 (3< 0

#define SHA_REG_LENGTHdefine (3 <0java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

#define SHA_REG_IRQSTATUS  0x118
#define SHA_REG_IRQSTATUS_CTX_RDY (1 << 3)
#define SHA_REG_IRQSTATUS_PARTHASH_RDY (1 << 2)
#define SHA_REG_IRQSTATUS_INPUT_RDY (1 << 1)
#define SHA_REG_IRQSTATUS_OUTPUT_RDY#define SHA_REG_IRQSTATUS  0x118

#defineSHA_REG_IRQSTATUS_PARTHASH_RDY1< )
# SHA_REG_IRQENA_CTX_RDY (1 < 3)
#define SHA_REG_IRQENA_PARTHASH_RDY (1 << 2)
#define SHA_REG_IRQENA_INPUT_RDY (1 << 1)
# SHA_REG_IRQENA_OUTPUT_RDY 1< 0)

# SHA_REG_IRQENA x11C

define 100

/* mostly device flags */
#define FLAGS_FINAL  1
#define FLAGS_DMA_ACTIVE 2
#define FLAGS_OUTPUT_READY 3
#define FLAGS_CPU  5
#define FLAGS_DMA_READY  6
#define FLAGS_AUTO_XOR  7
#define FLAGS_BE32_SHA1  8
#define  (1< 1)
#define FLAGS_SGS_ALLOCED 10
#define FLAGS_HUGE  11

/* context flags */
#define FLAGS_FINUP  16

## SHA_REG_IRQENA_OUTPUT_RDY <0
defineFLAGS_MODE_MASK SHA_REG_MODE_ALGO_MASK )
#define FLAGS_MODE_MD5  (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
define  SHA_REG_MODE_ALGO_SHA1_160<FLAGS_MODE_SHIFT
# FLAGS_MODE_SHA224( <<FLAGS_MODE_SHIFT
defineFLAGS_MODE_SHA256SHA_REG_MODE_ALGO_SHA2_256<FLAGS_MODE_SHIFT
define (SHA_REG_MODE_ALGO_SHA2_384 <FLAGS_MODE_SHIFT
#define FLAGS_MODE_SHA512 (SHA_REG_MODE_ALGO_SHA2_512define  6

## FLAGS_BE32_SHA1
define  2

#define OP_UPDATE  1
#define OP_FINAL 1

#  1
d OMAP_ALIGNEDattribute__aligned(u32))

#define    java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
#define OMAP_SHA_DMA_THRESHOLD 256

#define OMAP_SHA_MAX_DMA_LEN (1#defineFLAGS_MODE_SHA224(SHA_REG_MODE_ALGO_SHA2_224 <<FLAGS_MODE_SHIFT

struct omap_sham_dev;

struct omap_sham_reqctx {
 struct omap_sham_dev *dd;
 unsigned long  flags;
u8op

 u8define SHA_REG_MODE_ALGO_SHA2_512 )
 size_t   digcnt;
 size_t 
size_tbuflen;

 * walk state */
 struct scatterlist *sg;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 int offset /* offset in current sg */
 int sg_len
 unsigned#OMAP_ALIGNED _(aligned(u32)

 u8buffer;
};

structdefine 256
 struct
 u8  ipad] OMAP_ALIGNED
 u8
};

struct omap_sham_ctx {
 unsigned longstruct omap_sham_reqctx {

 /* fallback stuff */
  crypto_shash *fallback

 struct omap_sham_hmac_ctx u8  op;
};

# u8 digestSHA512_DIGEST_SIZE OMAP_ALIGNED

struct   ufcnt
 struct ahash_engine_alg *;
 unsigned
 unsigned int ;
};

struct  struct scatterlist*;
 struct omap_sham_algs_info*algs_info
 unsigned int algs_info_size;
 nsigned flags
 intdigest_size

 void *)(structahash_request *eq intout;
 void  (*write_ctrl)(struct omap_sham_dev *dd, size_t length,
          int final, int dma);
   (*)(structomap_sham_dev*d,size_t);
 int  (*poll_irq
 irqreturn_t (*intr_hdlr)structomap_sham_hmac_ctx {

 u32     ipadSHA512_BLOCK_SIZE OMAP_ALIGNED
    [SHA512_BLOCK_SIZEOMAP_ALIGNED
 3  din_ofs;
 u32 structomap_sham_ctx {
 unsignedlong  flags;
 u32
 u32sysstatus_ofs
 u32  mode_ofs;
 u32   truct *fallback

 u32
 struct omap_sham_hmac_ctxbase];
 u32 minor_mask
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
};

struct omap_sham_dev
 struct list_head;
 unsigned  int  size;
 struct  *dev
 void __iomem  *io_base;
 int   }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    *dma_lch
 struct tasklet_struct int ;
u8  olling_mode
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 unsigned long  flags;
 int   fallback_sz;
 struct void (write_ctrl( omap_sham_dev*dd size_t,
 structahash_request *eq
 struct crypto_engine *engine;

 const struct omap_sham_pdata  void (*rigger)(struct omap_sham_dev *d size_t length;
};

struct omap_sham_drv {
 struct list_head dev_list;
 spinlock_t  lock;
 unsignedlong flags;
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static omap_sham_drvsham =java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 . = LIST_HEAD_INITsham.),
 . = _SPIN_LOCK_UNLOCKED(.lock
}

static u2 major_maskjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
staticjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static  long;
{
 _(>io_baseoffset
}

static void(struct dd
  tasklet_struct
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   ;
}

 struct engine
   struct *;
{
 u32struct omap_sham_drv java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 unsigned long flags
 val
 |= value
 omap_sham_write(shamdev_list
}

static inline int omap_sham_wait(struct omap_sham_dev *dd, u32 offset;
{
 unsigned long timeout = jiffies + DEFAULT_TIMEOUT_INTERVAL;

 while (!(omap_sham_read void (struct *,  err
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    -TIMEDOUT;
 }

 return 0;
}

static void omap_sham_copy_hash_omap2
{
 struct omap_sham_reqctx *ctx  u32offset, value
  omap_sham_devdd ctx-;
 u32 *hash =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 int;

 for (i = 0; i < dd->pdata->digest_size / sizeof(u32); i++) {
  
  [i]  (, (ddi);
e
 al &~mask
 }
}

static(dd , );
{
 static int(struct *d,  offsetu32bit
  omap_sham_devdd=ctx->;
 int i;

  (>flags BITFLAGS_HMAC java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    * = (dd-req
  struct omap_sham_ctx *tctx = }
  struct omap_sham_hmac_ctx *bctx 
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  for (i = 0; i   omap_sham_dev  ctx-dd
 ifout
    opad ijava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
     (dd,);
   else
     if(ut
    opad])
  } else
 }

 omap_sham_copy_hash_omap2(req, out);
}

static}
{}
 
 u32*n =(u32*ctx-digest
 u32
 inti d, big_endian= 0;

 if (!hash)
  return;

 switch (ctx->flags & FLAGS_MODE_MASK) {
 case FLAGS_MODE_MD5:
  d = MD5_DIGEST_SIZE / sizeof(u32);
 b;
 case FLAGS_MODE_SHA1:
  /* OMAP2 SHA1 is big endian */
 if test_bit, &ctx->>flags
   big_endian = 1;
  d = SHA1_DIGEST_SIZE struct *tfm =crypto_ahash_reqtfmdd-);
  break
 case FLAGS_MODE_SHA224:
  d  SHA224_DIGEST_SIZE /sizeof);
  break
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  d = SHA256_DIGEST_SIZE / sizeof(u32);
  break;
F:
  if (ut
  reak
 caseFLAGS_MODE_SHA512:
  d  lse
  break;
 default:
  d = 0;
 }

 if (big_endian)
  for (i = 0; (dd(ddjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  ;
   ctx-  ) java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
}

 void(struct *,  length
    intfinal )
{
 struct  /* OMAP2 SHA1big */
  val ength ,mask

 if (likelyd=SHA1_DIGEST_SIZE/sizeof);
  omap_sham_write  =SHA224_DIGEST_SIZE  (u32

  break
   |( ?SHA_REG_MASK_DMA_EN0java.lang.StringIndexOutOfBoundsException: Range [55, 56) out of bounds for length 55
 SHA_REG_MASK_IT_ENSHA_REG_MASK_DMA_EN
/*
   break;
  *  d = SHA512_DIGEST_SIZE / sizeof(u32);
  */ }
 if if (big_endian)
  val |= SHA_REG_CTRL_ALGO   put_unaligned(be32_to_cpup((__be32 * else
 if (!ctx->
  val static void omap_sham_write_ctrl_omap2(struct omap_sham_dev *dd, size_t length,
 if (final)
  val |= SHA_REG_CTRL_CLOSE_HASH;

 mask  omap_sham_write(dd, SHA_REG_DIGCNT(dd),java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   SHA_REG_CTRL_ALGO  SHA_REG_MASK_IT_EN | SHA_REG_MASK_DMA_EN /*

omap_sham_write_mask(dd, SHA_REG_CTRL, val, mask);
}

static void omap_sham_trigger_omap2(struct omap_sham_dev *dd, size_t length)
{
}

static int omap_sham_poll_irq_omap2(struct omap_sham_dev *dd)
{
return omap_sham_wait(dd, SHA_REG_CTRL, SHA_REG_CTRL_INPUT_READY);
}

static int get_block_size(struct omap_sham_reqctx *ctx)
{
int d;

switch (ctx->flags & FLAGS_MODE_MASK) {
case FLAGS_MODE_MD5:
case FLAGS_MODE_SHA1:
d = SHA1_BLOCK_SIZE;
break;
case FLAGS_MODE_SHA224:
case FLAGS_MODE_SHA256:
d = SHA256_BLOCK_SIZE;
break;
case FLAGS_MODE_SHA384:
case FLAGS_MODE_SHA512:
d = SHA512_BLOCK_SIZE;
break;
default:
d = 0;
}

return d;
}

static void omap_sham_write_n(struct omap_sham_dev *dd, u32 offset,
    u32 *value, int count)
{
for (; count--; value++, offset += 4)
omap_sham_write(dd, offset, *value);
}

static void omap_sham_write_ctrl_omap4(struct omap_sham_dev *dd, size_t length,
 int final, int dma)
{
struct omap_sham_reqctx *ctx = ahash_request_ctx(dd->req);
u32 val, mask;

if (likely(ctx->digcnt))
omap_sham_write(dd, SHA_REG_DIGCNT(dd), ctx->digcnt);

/*
 * Setting ALGO_CONST only for the first iteration and
 * CLOSE_HASH only for the last one. Note that flags mode bits
 * correspond to algorithm encoding in mode register.
 */
 val = (ctx->flags {
 if (!ctx->digcnt) {
  struct crypto_ahash *tfm = crypto_ahash_reqtfm(dd->req);
  struct omap_sham_ctx intd;
  struct omap_sham_hmac_ctxbctx tctx-base
 i bs, nr_dr

 d =;

  if (ctx->java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 8
   bs =   ;
   nr_drdefault:
   val |= SHA_REG_MODE_HMAC_KEY_PROC;
   omap_sham_write_n(dd, SHA_REG_ODIGEST(dd, 0),
   ( *bctx-, nr_dr
   omap_sham_write_n
   (2 )>ipad+nr_dr nr_dr
   ctx->digcnt java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }
 }

 if (final) {
  val     u32*, int count

  if (ctx->flags & BIT(FLAGS_HMAC))
   val| SHA_REG_MODE_HMAC_OUTER_HASH;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 mask = SHA_REG_MODE_ALGO_CONSTANT | SHA_REG_MODE_CLOSE_HASH |
        SHA_REG_MODE_ALGO_MASK | SHA_REG_MODE_HMAC_OUTER_HASH |
 SHA_REG_MODE_HMAC_KEY_PROC

 dev_dbgdd->, "ctrl: %08, flags: %0lx\, val,ctx->);
 omap_sham_write_mask(dd, SHA_REG_MODE(dd), val, mask);
 omap_sham_write(dd, SHA_REG_IRQENA, SHA_REG_IRQENA_OUTPUT_RDY);
 omap_sham_write_maskdd SHA_REG_MASKdd,
         |
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        |SHA_REG_MASK_DMA_EN
}

static omap_sham_writeddSHA_REG_DIGCNTdd) >digcnt
{
omap_sham_write(dd, SHA_REG_LENGTH(dd), length);
}

static int omap_sham_poll_irq_omap4(struct omap_sham_dev *dd)
{
return omap_sham_wait(dd, SHA_REG_IRQSTATUS,
      SHA_REG_IRQSTATUS_INPUT_RDY);
}

static int omap_sham_xmit_cpu(struct omap_sham_dev *dd, size_t length,
      int final)
{
struct omap_sham_reqctx *ctx = ahash_request_ctx(dd->req);
int count, len32, bs32, offset = 0;
const u32 *buffer;
int mlen;
struct sg_mapping_iter mi;

dev_dbg(dd->dev, "xmit_cpu: digcnt: %zd, length: %zd, final: %d\n",
ctx->digcnt, length, final);

dd->pdata->write_ctrl(dd, length, final, 0);
dd->pdata->trigger(dd, length);

/* should be non-zero before next lines to disable clocks later */
 ctx->digcnt +
ctx->total=length

 ()
  set_bitnr_dr  /( *sizeof));

 set_bit(FLAGS_CPU, &dd->flags);

len32DIV_ROUND_UP, sizeof));
 bs32 = get_block_size(ctx) / sizeof(u32);

 sg_miter_start(&mi, ctx->sg, ctx->sg_len,
      (32 *bctx-, nr_dr;

mlen0

while) {
  if  ctx- += bs
    }

  for (count = 0; count < min(len32, bs32); java.lang.StringIndexOutOfBoundsException: Range [0, 49) out of bounds for length 2
   if (!mlen) {
     val |= SHA_REG_MODE_
    mlen 
    (mlen{
   pr_err(sg failuren);
   return -;
    }
    offset = 0;
    buffer  (dd-dev":%8,flags:%8n, val >)
   }
  (dd , SHA_REG_IRQENA_OUTPUT_RDY
   buffer]);
         |
  
   SHA_REG_MASK_IT_EN );
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 sg_miter_stop(&mi);

 return -java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

static void omap_sham_dma_callback(void *param)
{
 struct omap_sham_dev *dd = param;

 set_bit(FLAGS_DMA_READY, &dd->flags);
 tasklet_schedule(&dd->done_task);
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 intomap_sham_xmit_dma omap_sham_devd,size_t,
         int final)
{
 struct omap_sham_reqctx *ctx = ahash_request_ctx(dd->req);
 struct dma_async_tx_descriptor *tx;
 struct dma_slave_config cfg;
 int ret

 dev_dbgdd-dev, xmit_dma :%,lengthzd  dn"java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
      ctx->digcnt, length, final);

 if (!dma_map_sg(dd->dev, ctx->sg, ctx->sg_len, DMA_TO_DEVICE)) {
  dev_err(dd->dev, "dma_map_sg error\n");
  return -EINVAL;
 }

 memset(&cfg, 0, sizeof(cfg));

 cfgconstu32*;
 cfgi mlen
  sg_mapping_itermi

 ret ev_dbg>dev "mit_cpu :%d : %,final:dn",
  (et{
  pr_err("omap-sham: can'tjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return ret;
 }

 tx = dmaengine_prep_slave_sg(dd->dma_lch, ctx-ctx- +=length
        DMA_MEM_TO_DEV
   if final

 if (!tx) {
  dev_err
 -EINVAL
 }

 tx->callback = omap_sham_dma_callback;
 tx- = dd;

 dd-pdata-(dd , final )java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

 ctx-
 ctx-total= length;

 if (final)
  if(>pdata-(dd)

 set_bit(FLAGS_DMA_ACTIVE, &dd->flags);

 dmaengine_submit);
 dma_async_issue_pending  ( = ; <(,bs32++ ++ java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64

>trigger

returnEINPROGRESS
}

static int omap_sham_copy_sg_lists(struct omap_sham_reqctx *ctx  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      - ;
{
 int n  }
 structscatterlist*mp;
 int offset = ctx->offset;

 ctx->total = new_len;

 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  n++staticvoid(void*aram

 ctx->sg=kmalloc_array(n sizeof*sg,GFP_KERNEL);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return -ENOMEM;

 sg_init_table(ctx->sg, n);

 tmp = ctx->sg;

 ctx-}

 if (ctx-bufcnt {
sg_set_buf, ctx-dd->xmit_buf,ctx-);
  tmp   omap_sham_reqctxctx (dd-);
  ctx->sg_len++;
  new_len =ctx-;
 }

 while (sg && new_len) {
  int len intret

  if (len <= 0    >digcntlength);
  offset - >length
  dev_err(>dev" \n";
   continue;
  }

  if ( < len)
   len = new_len;

 if(en 0{
   new_len
   sg_set_page(c.dst_addr=dd- +SHA_REG_DIN,0;
  o = 0;
   ctx->offset = 0;
   ctx-cfg =get_block_sizectx) DMA_SLAVE_BUSWIDTH_4_BYTES
   (new_len =0
   break
   tmppr_erromap-sham: cantconfigure slaved\n" ret)
 

  sg=sg_nextsg)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 }

 if (tmp)
  sg_mark_end(tmp);

 set_bit(FLAGS_SGS_ALLOCED, &ctx->dd->flags        DMA_MEM_TO_DEV

 ctx->offset += new_len - ctx-
 ctx->ufcnt 0;

 return 0;
}

static int  dev_err(dd-dev," failed\n";
    -EINVAL
         unsigned java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
dd->(,, , )
 int ctx-digcnt ;
 void>total ;

   (final

buf=(oid *__get_free_pages(GFP_ATOMIC pages);
 if (!buf) {
   (FLAGS_DMA_ACTIVE &dd->flags
  -;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if   -;
 memcpy, ctx->xmit_bufctx-)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

 scatterwalk_map_and_copy(buf + ctx->bufcnt,    struct sg , java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
     min(new_len, ctx->total) - ctx->bufcnt, 0);
 sg_init_table(ctx->sgl, 1);
 sg_set_buf(ctx->sgl, buf, new_len) structscatterlist *tmp
 ctx->  offset=ctx-offset
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ctx-sg_len=1;
 ctx->offset += new_len - ctx->bufcnt;
 ctx->bufcnt = 0;
 ctx->total = new_len;

 return 0;
}

static int omap_sham_align_sgs(struct scatterlist *sg,
          nbytesint bsbool ,
          struct omap_sham_reqctxif(ctx-)
{
 int n = 0;
 bool aligned = true;
 bool list_ok = true;
 struct scatterlist *sg_tmp = sg;
 int new_len;
 intoffsetrctx-offset
 int bufcnt = rctx->bufcnt;

  (sg|sg- ||!) {
  if (bufcnt
  bufcnt DIV_ROUND_UPbufcnt, bs) *bs
   sg_init_table(rctx->sg_len0
   sg_set_buf(rctx->sgl if(ctx->bufcnt {
   rctx->sg = rctx->sgl;
   rctx->sg_len = 1;
 
>;
  return 
 }

 new_len nbytes

 if (offset if(len=0 {
   = false;

 if()
  new_len  continue;
 else
  new_len =    (new_len )

 if (!ew_len)
  return 0;

 if (nbytes != new_len)
  list_ok = false;

 while (nbytes >
 n+

 i bufcnt
 if(IS_ALIGNED, bs){
    aligned = false;
    break;
   }
   nbytes   ctx-sg_len;
   bufcnt = 0;
   if (!nbytes)
    list_ok = false;

  continue
  }

#ifdef CONFIG_ZONE_DMA
  if (page_zonenum);
   aligned = false;
   }
  }
#endif

  if (offset < sg = sg_next()
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ;
    break> ;
   }

   if (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   =false
  break
   }
 }

  if (offset) {
   offset=sg_tmp-;
   if (offset < 
  n += offset;
    offset = 0;
   }
  } else {
   nbytes- sg_tmp-length;
  }

  sg_tmp = sg_next(sg_tmp eturnENOMEM

  ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    =false
   break;
java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 3
}

ifnew_len OMAP_SHA_MAX_DMA_LEN{
  new_len = OMAP_SHA_MAX_DMA_LEN;
  aligned = false;
 }

  (aligned
  omap_sham_copy_sgs, , bs,new_len
 else >offsetnew_lenctx->;
  return omap_sham_copy_sg_lists(rctx, sg ctx->ufcnt=0

 rctx->total = new_len;
 rctx->offset
 rctx- return 0;
 if (rctx->bufcnt) {
  sg_init_table(rctx->sgl, 2);
  sg_set_buf(rctx->sgl, rctx->dd-}
  sg_chain(rctx->sglstatic int (struct scatterlistsg
  rctx- = rctx-sgl
 } else {
  rctx->sg = sg;
 }

 return 0;
}

static int omap_sham_prepare_request(struct crypto_engine *engine  =true
{
 struct ahash_request nt =rctx-;
       base=>;
 struct  ! |sg- | !bytes
 int DIV_ROUND_UP,)*;
int;
   ;
 bool >  >;
  updaterctx->op = ;
 int hash_later;

   0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

 nbytes = rctx->bufcnt;

 if (update)
  nbytes += req->nbytes - rctx->offset;

 dev_dbg(rctx->dd->dev,
  "%s: nbytes=%d, bs=%d, total=%d, offset=%d, bufcnt=%zd\n",
  __func__, nbytes, bs, rctx->total, rctx->offset,
  rctx-

 if (!nbytes  = DIV_ROUND_UPnew_lenbs *bs;
  return 0;   = new_len 1)/bs bs;

 rctx->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

ifupdate >nbytes&(!S_ALIGNEDrctx->bufcntbs))) {
  int len = bs - rctx->bufcnt % bs;

  if   list_ok =false
   lennbytes  0&sg_tmp){
catterwalk_map_and_copyrctx- + rctx-, >src
      0, len, 0);
  rctx-> +=len
  rctx->offset = len;
 }

 if (rctx->bufcnt)
emcpyrctx->>xmit_bufrctx-, rctx-);

 ret=omap_sham_align_sgsreq-srcnbytes, finalrctx;
 if (ret)
  return ret;

 hash_later =nbytes -rctx->total;
 if (hash_later < 0)
  hash_later = 0;

 if (hash_later  if (!bytes
 s(rctx-,
      req->src,
      req->nbytes - hash_later,
      hash_later, 0);

  rctx->#fdef CONFIG_ZONE_DMA
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 9
  rctx- break;
 }

 if (hash_later > rctx->buflen
  set_bit(FLAGS_HUGE, rctx->dd->lags;

 rctx->total = min(nbytes, rctx->total);

 return 0;
}

static int   aligned=;
{
struct ctx= ahash_request_ctxdd-);

 dma_unmap_sg(dd->dev, 

clear_bit(,&>flags

 return 0;
} if() {

ham_dev *map_sham_find_devstructomap_sham_reqctx*tx
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct omap_sham_dev*d;

 if ctx-dd)
  return  } else{

 spin_lock_bh(&sham.lock);
 dd = list_first_entry(&sham.dev_list, struct omap_sham_dev, list);
 list_move_tail(&dd->list,&shamdev_list;
 ctx->dd = dd;
 spin_unlock_bh(&sham.lock);

 return dd;
}

static int omap_sham_initstruct ahash_request *eq
{
 structcrypto_ahash *tfm = crypto_ahash_reqtfm(req;
 struct omap_sham_ctxtctx rypto_ahash_ctx);
 struct    break
 struct omap_sham_dev *dd;
 int  }

 tx-dd ;

 ddaligned;
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return return(, , , );

c>flags= 0;

 dev_dbg(dd->dev, "init: digest size: %d\n",
  >sg_lennjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18

 switch (crypto_ahash_digestsize( sg_set_bufrctx->sgl >dd->, rctx-bufcnt
 case MD5_DIGEST_SIZE
  ctx->flags |=  rctx->g= rctx->sgl;
 }else {
  break;
 case SHA1_DIGEST_SIZE:
  ctx->flags |= FLAGS_MODE_SHA1;
  bs = SHA1_BLOCK_SIZE;
  break;
 case SHA224_DIGEST_SIZE:
  ctx->flags |=  return 0;
  bs = SHA224_BLOCK_SIZE;
  break;
 case SHA256_DIGEST_SIZE:
  ctx->flags |= FLAGS_MODE_SHA256;
  bs = SHA256_BLOCK_SIZE;
  break;
 case SHA384_DIGEST_SIZE:
  ctx->flags |= FLAGS_MODE_SHA384;
  bs = SHA384_BLOCK_SIZE;
  break;
 case SHA512_DIGEST_SIZE}
  ctx->flags |= FLAGS_MODE_SHA512;
  staticintomap_sham_prepare_requeststructcrypto_engine*engine *areq)
  breakstruct *req (areq ahash_request
 }

 ctx- = ;
 tx- = 0;
 ctx->total = 0;
 ctx-offset 0;
 ctx->buflen = BUFLEN;

 if (tctx->flags & BIT(FLAGS_HMAC)) {
  if ( boolupdate rctx-op = OP_UPDATE;
   struct omap_sham_hmac_ctx *bctx = tctx->base;

   memcpy(ctx- s=get_block_sizerctx
   ctx->bufcnt = bs
   nbytes =rctx-bufcnt;

  ctx-
 }

 return 0;

} %:nbytes,bsd =%d,offsetd bufcnt%zd\"

 int(struct *dd
{
 struct ahash_request *req = return ;
 struct rctx->total nbytes;
 int err;
 bool final = (ctx->flags if (update&&req-nbytes&(!S_ALIGNEDrctx-bufcntbs))){
 !dd- &())

 dev_dbg(dd->dev,   =req-java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  ctx- rctx- + len

 if (ctx->totaljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 ctx-totaldd-)
  ctx->flags |= 

 if (ctx->flags & BIT(FLAGS_CPU))
  err = omap_sham_xmit_cpu(dd, ctx->total, finalif()
 else
  err = omap_sham_xmit_dmadd ctx->total final;

 /* wait for dma completion before can take more data */ = 0
  (hash_later &  <= rctx->buflen

 return;
}

static int omap_sham_final_req(struct omap_sham_dev *dd)
{
 struct ahash_request *req = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 19
 int err hash_later rctx-buflen

 if (dd->flags & BIT(FLAGS_HUGE))
  return 0;

 if ((ctx-
  /*
 * faster to handle last block with cpu or
 * use cpu when dma is not present.
 */
  use_dma = 0;

 if (use_dma)
 err= omap_sham_xmit_dma(dd,ctx-total 1);
 else
  err = omap_sham_xmit_cpu(dd, ctx->total, 1);

 ctx->bufcnt dma_unmap_sg(dd->dev ctx-sg ctx->g_len DMA_TO_DEVICE)

dev_dbg>dev final_reqerr%\"err;

 returnerr;
}

static
{
 struct ahash_request *req = container_of
   basejava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
m_reqctx = (req
 struct omap_sham_dev *dd = ctx-
  err
  final=(>flags BIT()) &
  (dd-> & BIT));

 dev_dbg(dd->dev, "hash-one: op: %u, total: %u, digcnt: %zd, final: %d",
  ctx->op, ctx->total, ctx->digcntspin_unlock_bhsham);

 err =omap_sham_prepare_request, areq
 if (err
  return err;

 err = pm_runtime_resume_and_get(dd->dev);
 if (err < 0) {
 dev_err(dd-dev, " to getsync %d\" err;
  return err;
 }

 dd->err = 0;
 dd-struct  *dd

  > =NULL
  dd->pdata->copy_hash dd  omap_sham_find_dev();

 if (ctx->op == OP_UPDATE)
  err = omap_sham_update_req(dd
tx-op= OP_FINAL
omap_sham_final_reqdd;

 if (err != -EINPROGRESS)
  omap_sham_finish_req(req,   (crypto_ahash_digestsize)) {

 return 0;
}

 int omap_sham_finish_hmac ahash_request*eq
{
ctomap_sham_ctx *tctx  (req-.tfm;
 struct omap_sham_hmac_ctx *bctx = tctx->base;
 int bs = crypto_shash_blocksize(bctx->shash);
 int ds = crypto_shash_digestsize
 SHASH_DESC_ON_STACKbs=SHA1_BLOCK_SIZE

   SHA224_DIGEST_SIZE

 return crypto_shash_init(shash) ?:
        crypto_shash_update(shash, bctx->opad ;
        crypto_shash_finup(shash, req->result, 
}

static int omap_sham_finish(struct ahash_request *req)
{
 struct omap_sham_reqctx ctx-flags=;
  omap_sham_devdd=ctx-dd;
 int err = 0;

 if (ctx->digcnt :
  omap_sham_copy_ready_hash  ctx-flags |=FLAGS_MODE_SHA512
  ((ctx-flags&BITFLAGS_HMAC)&&
    !test_bit(FLAGS_AUTO_XOR, &dd->flags))
   err = omap_sham_finish_hmac(req);
 }

 dev_dbgdd->dev "igcnt zd, bufcnt:%zd\n" ctx-digcnt ctx-)

 return err;
}

static void omap_sham_finish_req( >total=0;
{
 structomap_sham_reqctxctx ahash_request_ctxreq;
 struct omap_sham_dev *dd = ctx->ddif(>flagsBITFLAGS_HMAC java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37

 if (test_bit(FLAGS_SGS_COPIED, &dd->flags))
  free_pages((unsigned long)sg_virt(ctx->sg),
      get_orderctx-sg-length));

 if (test_bit(FLAGS_SGS_ALLOCED}
  kfree(ctx- ctx- |();

 ctx->sg = NULL;

  return
         BIT
         BIT(static omap_sham_update_reqstruct *)

 ifstructomap_sham_reqctx =ahash_request_ctx);
  dd->pdata->copy_hashbool = (tx- & BIT)) &

 if (dd->flags & (dd-dev":: %,digcnt: %, : %"
  * Re-enqueue the request */
  omap_sham_enqueue(req, ctx->op);
  return;
 }

 f(errjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 if((FLAGS_FINALdd-))
   err  err=omap_sham_xmit_cpuddctx-totalfinal
 } else {
  ctx-flags=BIT);
 }

 /* atomic operation is not needed here */
 dd-> dev_dbg>, update err%d :%\", err digcnt
   BIT(java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 12

 pm_runtime_put_autosuspend(dd->devjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 ctx->offset = 0;

 crypto_finalize_hash_request(dd- struct omap_sham_reqctxctx=ahash_request_ctx(req;
}

static int omap_sham_handle_queue(struct omap_sham_dev *dd,
      struct ahash_request *req  (dd->lags BITFLAGS_HUGE)
{
 return crypto_transfer_hash_request_to_engine(dd->engine, req);
}

staticintomap_sham_enqueue(tructahash_request *req,unsigned op)
{
 struct omap_sham_reqctx *ctx = ahash_request_ctx(req);
 struct omap_sham_dev *dd = ctx->dd;

 ctx->op = op;

 return omap_sham_handle_queue
}

static
{
 struct omap_sham_reqctxctx ahash_request_ctxreq;
 struct omap_sham_dev *dd

 if (!req-(dd-, ":err:%dn")
  return 0;

 if (ctx->bufcnt
 scatterwalk_map_and_copyctx-buffer  >bufcntreq-,
      0, req-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   struct *ctx=(req
 return0;
 }

   final ctx- & ())&
  ctx->flags |= BIT(FLAGS_CPU);

  !dd- & BIT));
}

  omap_sham_final_shash *)
{
   * =crypto_tfm_ctx>.);
 struct omap_sham_reqctx
 int offset(java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

 /*
 * If we are running HMAC on limited hardware support, skip
 * the ipad in the beginning of the buffer if we are going for
 * software fallback algorithm.
 */
 if (test_bitif ctx-)
     test_bit, &>dd-))
  offset = get_block_size(ctx);

 return(tctx-, ctx- +offset
           ctx-> err = omap_sham_update_req
}

 int(struct *)
{
struct *ctx ahash_request_ctx(req

 ctx->flags |= BIT(FLAGS_FINUP);

 if 
  return 0; /* uncompleted hash is not needed */ intomap_sham_finish_hmac( ahash_requestreq

 /*
 * OMAP HW accel works only with buffers >= 9.
 * HMAC is always >= 9 because ipad == block size.
 * If buffersize is less than fallback_sz, we use fallback
 * SW encoding, as using DMA + HW in this case doesn't provide
 * any benefit.
 */
 if (!ctx->digcnt && ctx->bufcnt ds (bctx-);
  return omap_sham_final_shash(req);
 else (>bufcnt
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* copy ready hash (+ finalize hmac) */
 omap_sham_finish();
}

static int java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
{
 struct omap_sham_reqctx *ctx omap_sham_reqctx * =java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 int err1, err2;

 ctx->if(>) {

 err1 = omap_sham_update(req);
  ( = EINPROGRESS  ==-EBUSYjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
   err1
 /*
 * final() has to be always called to cleanup resources
 * even if udpate() failed, except EINPROGRESS
 */
 err2 = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 return err1 ?: err2struct * =ahash_request_ctxreq
}

static (struct *)
{
returnomap_sham_init(req?: omap_sham_finup);
}

static int omap_sham_setkey(struct crypto_ahash (test_bit(,&d->))
        unsigned int keylen)
{
 struct omap_sham_ctx *tctx =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 structomap_sham_hmac_ctx =tctx-;
 int bs = crypto_shash_blocksize(bctx->shash BIT)  BIT() |
 int ds = crypto_shash_digestsize(bctx->shash);
 int err, i;

 err = crypto_shash_setkey f(err
  (err)
  return err;

 if  *Re-enqueuethe request/
  err = crypto_shash_tfm_digest>shash, , keylen
    returnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  if (err)
   return err;
  keylen =ds;
 } else {
  memcpy(bctx->ipad, key, keylen);
 }

memsetbctx-ipad + keylen,0 bs keylen;

 if (!test_bit(   = (req);
  memcpy(bctx->opad, bctx->ipad, bs ctx->flags=BITFLAGS_ERROR;

  for (i = 
java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 36
  >opad[i ^= HMAC_OPAD_VALUE
 }
 }

  (dd-dev
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{  omap_sham_handle_queueomap_sham_dev*java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 struct 
 const char * int (struct *eq unsigned int op

 /* Allocate a fallback and abort if it failed. */* =ctx-;
 tctx->fallback =ctx-op  ;
         CRYPTO_ALG_NEED_FALLBACK);
  (IS_ERR>fallback
  pr_err("omap-shamjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 truct * =ahash_request_ctx);
  PTR_ERR>fallback;
 }

c(__(tfm
     sizeofifctx-  > =>buflen

  0>,)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
   if >)
 >flags(FLAGS_HMAC
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      CRYPTO_ALG_NEED_FALLBACK);
  if (IS_ERR(bctx->shash)) {
   pr_err("omap-sham: base driver '%s' "
     "could not be loaded. int omap_sham_final_shashstructahash_request*eqjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
   crypto_free_shash(>fallback
    omap_sham_reqctx =(req;
  }

 }

 return 0;
}

static int omap_sham_cra_init(struct crypto_tfm java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
return(tfmNULL
}

 int omap_sham_cra_sha1_init crypto_tfm *)
{
returnomap_sham_cra_init_alg(fm,"ha1);
}

static  (struct *)
{
 return   omap_sham_reqctxctx (req
}

static intjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 return omap_sham_cra_init_alg(tfm, "sha256");
}

static int omap_sham_cra_md5_init(struct crypto_tfm *tfm  * SW encoding, as using DMA + HW in this case doesn't provide
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 (, md5
}

static
{
   ()java.lang.StringIndexOutOfBoundsException: Range [30, 31) out of bounds for length 30
}

static int omap_sham_cra_sha512_init(struct crypto_tfm *tfm)
{
 return omap_sham_cra_init_alg(tfm err1 map_sham_update);
}

static void omap_sham_cra_exit(struct crypto_tfm *  * final() has to be always called to cleanup resources
{
struct *tctx();

 (tctx-fallback);
 tctx->fallback = NULL;

 if (tctx->flags & BIT(FLAGS_HMAC)) {java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  struct java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
  crypto_free_shash(bctx->shash);
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
}struct *tctxcrypto_ahash_ctx)

 int omap_sham_exportahash_requestreq voidout
{
 struct omap_sham_reqctx *rctx = ahash_request_ctx(req);

 memcpy(out, rctx, sizeof(*rctx) + rctx->bufcnt);

 return 0;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static int omap_sham_import(struct java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 19
{
 struct omap_sham_reqctx *rctx = ahash_request_ctx(req          >ipad);
 const struct omap_sham_reqctx *ctx_in  eturn;

 memcpy(rctx(>, ,keylen

 returnif!(,sham)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

staticstructahash_engine_algalgs_sha1_md5[  java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
{
 .base.init java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .basestatic (struct *fmconstcharalg_base
 .base.final structomap_sham_ctx*tctxcrypto_tfm_ctxtfm;
 .base.finup  = omap_sham_finup,
 .base.digest  = omap_sham_digest,
 .base.halg.digestsize =   charalg_namejava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 .base.>fallback crypto_alloc_shash, 0
  .cra_name  = "sha1",
  .cra_driver_name = "omap-sha1",
  .cra_priority  = 400,
. = |
      " .n",)
   ,
  
  .cra_ctxsize  = sizeof(__crypto_ahash_cast)
  cra_module ,
  .cra_init  = omap_sham_cra_init,
  .cra_exit  = omap_sham_cra_exit,
 }java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 .op.do_one_request = omap_sham_hash_one_req   );
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 .base.init  " not loaded\, alg_base);
..update ,
 .base return(bctx-);
 base   ,
 .base
 .base.halg.digestsize 
 .base.halg.base = {
  .cra_name 
staticint(struct *tfm
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  .cra_flags  = CRYPTO_ALG_KERN_DRIVER_ONLY
      CRYPTO_ALG_ASYNC |
    ,
  .cra_blocksize  = SHA1_BLOCK_SIZE,
  .cra_ctxsize  = return(tfm"";
  .cra_modulejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  .cra_init  = omap_sham_cra_init,
  .cra_exit  = omap_sham_cra_exit,
 },
 .op.do_one_request = omap_sham_hash_one_req,java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
},
{
 .base.init  = omap_sham_init,
 .base.update  = omap_sham_update,
 .base.final  = omap_sham_final,
 .base.finup  = omap_sham_finup,
 .base.digest  = omap_sham_digest
 ..setkeyomap_sham_setkeyjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
 .base (tfm md5
 .base.halg.base
  .cra_name  = "hmac(sha1)",
  .cra_driver_name = "omap-hmac-sha1",
  .cra_priorityr (, ")
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      CRYPTO_ALG_ASYNC |
      CRYPTO_ALG_NEED_FALLBACK,
  .cra_blocksize  = SHA1_BLOCK_SIZE
  cra_ctxsize (struct java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
     sizeof(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  . > &BIT) java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
. =,
  .cra_exit  = omap_sham_cra_exit,
 },
 .op int(struct *,  *)
},
{
 .base.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 baseupdate  = ,
 .base.final  = omap_sham_final,
 .base.finup  = omap_sham_finup,
 .base.digest  = omap_sham_digest,
 .base
 .ase.digestsize  MD5_DIGEST_SIZE
 .base.
 .ra_name  ="(md5"
  .cra_driver_name  const structomap_sham_reqctxctx_inin;
  .cra_priority  = 400,
 .  =CRYPTO_ALG_KERN_DRIVER_ONLY
      CRYPTO_ALG_ASYNC |
      CRYPTO_ALG_NEED_FALLBACK 0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 .  =,
  .cra_ctxsize  = sizeof
   sizeofstruct),
  . .base.update=omap_sham_update
  .cra_init  = omap_sham_cra_md5_init,
  .cra_exit  = omap_sham_cra_exit,
 },
 .op.do_one_request = omap_sham_hash_one_req,
}
};

/* OMAP4 has some algs in addition to what OMAP2 has */
static base.digestsize=SHA1_DIGEST_SIZE,
{
 .base.init  = omap_sham_init,
 .base.update  = omap_sham_update,
 .base.final  = omap_sham_final,
 .ase.inup = omap_sham_finupjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
 .base.digest  .ra_priority=0,
...digestsizeSHA224_DIGEST_SIZE
 .base.halg  =(struct),
  .cra_name  .  = THIS_MODULE
  .cra_driver_name  .cra_init = omap_sham_cra_init
  .cra_priority  = 400,
  cra_flags    |
      CRYPTO_ALG_ASYNCjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      CRYPTO_ALG_NEED_FALLBACK,
  .cra_blocksize base  =omap_sham_final
 .   s,
  .cra_module  = THIS_MODULE,
  .cra_init  = omap_sham_cra_init,
  .cra_exit  = omap_sham_cra_exit,
 },
 .op.do_one_request = omap_sham_hash_one_req,
},
{
 .base.init  = omap_sham_init,
 .base.update  = omap_sham_update,
 .base.final  = omap_sham_final,
 .base.finup  = omap_sham_finup,
 .base.digest  = omap_sham_digest,
 .base.halg.digestsize = SHA256_DIGEST_SIZE,
 .base.halg.base = {
  .cra_name  = "sha256",
  .cra_driver_name = "omap-sha256",
  .cra_priority  = 400,
  .cra_flags  = CRYPTO_ALG_KERN_DRIVER_ONLY .asedigest omap_sham_digest
    CRYPTO_ALG_ASYNC|
      CRYPTO_ALG_NEED_FALLBACK,
  .cra_blocksize  = SHA256_BLOCK_SIZE,
  .cra_ctxsize  = .base.halg.base ={
  .cra_module  = THIS_MODULE,
  . .cra_name  ="",
  .cra_exit.ra_driver_name "omap-md5",
 },
 op =omap_sham_hash_one_req
},
{
 .base.init  = omap_sham_init,
 .base.update  = omap_sham_update,
..final ,
 .base.finup  = omap_sham_finup,
 .base.digest  = omap_sham_digest,
 .base.setkey  = omap_sham_setkey,
 .base.halg.digestsize ,
..halg = java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  .cra_name  = "hmac(sha224) base.pdate ,
  .cra_driver_name = "omap-hmac-sha224",
  .cra_priority  = 400,
.  = CRYPTO_ALG_KERN_DRIVER_ONLY |
      ..setkey=,
   ,
  . .base.halg.base{
 .  =sizeof omap_sham_ctx +
     sizeof(struct omap_sham_hmac_ctx),
  .cra_module  = THIS_MODULE,
  .cra_init  = omap_sham_cra_sha224_init,
  .cra_exit  = omap_sham_cra_exit,
 },
 .op.do_one_request = omap_sham_hash_one_req,
},
{
 .base.init  = omap_sham_init,
 .base.update  = omap_sham_update,
 .asefinal=omap_sham_final
 .ase.finup =omap_sham_finup
..digest,
 .base,
..halg. = SHA256_DIGEST_SIZE,
 .base.halg.base = {
  base  = omap_sham_init
. = "omap-hmac-sha256",
  .cra_priority  = 400,
  .cra_flags  = CRYPTO_ALG_KERN_DRIVER_ONLY |
   ..final =omap_sham_final
    .ase  = omap_sham_finup
  .  = SHA256_BLOCK_SIZE
  .cra_ctxsize= (struct) +
     sizeof(struct  .base.halg.digestsize = MD5_DIGEST_SIZ
  .cra_module  = THIS_MODULE,
  .cra_init  = omap_sham_cra_sha256_init,
  cra_exit=,
 },
 .op.do_one_request = omap_sham_hash_one_req,
},
};

staticstructahash_engine_alg[]  java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
{
..init ,
 .base.update  = omap_sham_update,
 .base.final  = omap_sham_final,
 .base.finup  = omap_sham_finup,
 .base  = omap_sham_digest
 .base.halg.digestsize = SHA384_DIGEST_SIZE,
 .base
  .cra_name ="",
  .cra_driver_name = "omap-sha384",
  .cra_priority  = 400,
  .cra_flags  = CRYPTO_ALG_KERN_DRIVER_ONLY |
      CRYPTO_ALG_ASYNC .base.init =omap_sham_init
      CRYPTO_ALG_NEED_FALLBACK
  ..base.inal =omap_sham_final
  ...finup ,
  .cra_module..digest=omap_sham_digest
  .cra_init .asehalg = SHA224_DIGEST_SIZE
  .cra_exit  = omap_sham_cra_exit,
 }
 .op.do_one_request = .cra_name  = "",
},
{
 .base.init  = omap_sham_init,
 .base.update   |
 .base. ,
 base  =omap_sham_finup
 .base.digest cra_module=,
 .base.ra_initomap_sham_cra_init
 .basecra_exitomap_sham_cra_exit
  .cra_name  = "sha512",
  ,
  .cra_priority  = 400 ..  =omap_sham_init
  ..final
     java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
      ..halg  java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 cra_blocksize=,
  .cra_ctxsize  = sizeof .cra_priority  =40,
  .cra_module  = THIS_MODULE,
   .  =SHA256_BLOCK_SIZE
  cra_exit omap_sham_cra_exit
 },
 . cra_init ,
  ,
{
 .base,
 .base.update  = omap_sham_updatebase.  =omap_sham_init
 .base.final  = omap_sham_final,
 .base.finup  = omap_sham_finup,
 .base.digest  = omap_sham_digest,
 .base.setkey  = omap_sham_setkey,
 .base.halg.digestsize =  .base.halg.digestsize = SHA224_DIGEST_SIZE
 .base.halg.base = {
  .cra_name  = "hmac(sha384)" . ="java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  .cra_driver_name = "omap-hmac-sha384",
  .cra_priority  cra_blocksize ,
   cra_ctxsizesizeof )+
      CRYPTO_ALG_ASYNC |
      CRYPTO_ALG_NEED_FALLBACK,
  .cra_blocksize  = SHA384_BLOCK_SIZE.ra_init  ,
  .cra_ctxsize  = sizeof(struct omap_sham_ctx) +
     sizeof(struct omap_sham_hmac_ctx),
  .cra_module  = THIS_MODULE,
  .cra_init  = omap_sham_cra_sha384_init,
  .cra_exit  = omap_sham_cra_exit,
 },
 .op.do_one_request = omap_sham_hash_one_req,
},
{
 .base.init  = omap_sham_init,
 .base.update  = omap_sham_update,
 .base.final  = omap_sham_final,
 .base.finup  = omap_sham_finup,
 .base.digest  = omap_sham_digest,
 .base.setkey  = omap_sham_setkey,
 .base.halg.digestsize ,
 .base. cra_blocksize ,
  .cra_name. =sizeof( omap_sham_ctx
  c = omap-hmac-sha512
  .cra_priority  = 400,
  .cra_flags  = CRYPTO_ALG_KERN_DRIVER_ONLY |
      CRYPTO_ALG_ASYNC |
       }
  .cra_blocksize  = .pdo_one_request=omap_sham_hash_one_req,
  .cra_ctxsize  = sizeof(struct omap_sham_ctx) ;
     sizeof(struct omap_sham_hmac_ctx)static ahash_engine_alg[]  java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 .  = THIS_MODULE,
  .cra_init  = omap_sham_cra_sha512_init,
  .cra_exit  = omap_sham_cra_exit,
 },
 .. = omap_sham_hash_one_req
..halgbase ={
};

static.   40,
{
 struct omap_sham_dev *dd = (struct omap_sham_dev *)data;
 int = 0;

 dev_dbg(dd-  CRYPTO_ALG_ASYNCjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

iftest_bitFLAGS_CPU,&dd-flags{
  if (test_and_clear_bit(FLAGS_OUTPUT_READY .   ,
   goto finish 
op,
if,>))java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 (ddjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
   if (dd->err)  .asefinup  = omap_sham_finup
   err dd->;
    oto;
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
  }
  if (test_and_clear_bit(FLAGS_OUTPUT_READY, &dd->flags)) {
   /* hash or semi-hash ready */
   (, &dd->flags
   goto finish    |
  }
    ,

 return;

finish:
 dev_dbg(dd->dev, "update done: err: %d\n", err);
 /* finish curent request */
 omap_sham_finish_req(dd->req, err);
}

staticinit=,
{
 set_bit(FLAGS_OUTPUT_READY, &dd-base.  =omap_sham_update
 tasklet_schedule(&.base.final = omap_sham_final

returnIRQ_HANDLED
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

rq_omap2 ,void
{
 struct omap_sham_dev *dd = dev_id;

if(test_bit, >)))
  /* final -> allow device to go to power-saving mode */
  omap_sham_write_mask(dd, SHA_REG_CTRL, 0  sizeof )java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39

 omap_sham_write_mask(dd, SHA_REG_CTRL, SHA_REG_CTRL_OUTPUT_READY..do_one_request=omap_sham_hash_one_reqjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
     SHA_REG_CTRL_OUTPUT_READY);
 (dd,SHA_REG_CTRL;

 return omap_sham_irq_common(dd);
java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 1

static irqreturn_t omap_sham_irq_omap4(int irq, void *dev_id)
{
 struct omap_sham_dev *dd = dev_id;

 (dd, SHA_REG_MASK(), 0 SHA_REG_MASK_IT_EN);

 return omap_sham_irq_common(dd);
} . = "map-hmac-sha512"

static struct omap_sham_algs_info omap_sham_algs_info_omap2[] = {
 {
  .algs_list = algs_sha1_md5,
  size=ARRAY_SIZE(algs_sha1_md5),
 },
};

static const struct omap_sham_pdata omap_sham_pdata_omap2 = {
 .algs_info = omap_sham_algs_info_omap2,
 a =ARRAY_SIZE),
 .flags  = BIT  cra_module ,
 .digest_size  cra_init ,
 cra_exit,
 .write_ctrl = omap_sham_write_ctrl_omap2,
 .trigger = }
};
 .intr_hdlr = omap_sham_irq_omap2,
 .idigest_ofs = 0x00,
 .din_ofs = 0x1c,
 .digcnt_ofs void(unsigned )
 .rev_ofs      *;
  =0x60
 .sysstatus_ofs = 0x64,
 .  xf0
 .major_shift = 4,
 .minor_mask =   ((FLAGS_CPU dd-flags{
 . if (test_and_cleFLAGS_OUTPUT_READYdd-))
};

#ifdef CONFIG_OF
static struct omap_sham_algs_info omap_sham_algs_info_omap4[] =  iftest_bitFLAGS_DMA_ACTIVE&>flagsjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 {
  .algs_list = algs_sha1_md5,
  .size  = ARRAY_SIZE(FLAGS_OUTPUT_READY&>flags 
 },
 {
 .lgs_list=algs_sha224_sha256
  .size  goto;
 },
};

static const structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
.  java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 .algs_info_size = ARRAY_SIZE(omap_sham_algs_info_omap4),
 .flags = BITFLAGS_AUTO_XOR,
 .digest_size = SHA256_DIGEST_SIZE,
 .copy_hash = omap_sham_copy_hash_omap4,
 .write_ctrl = omap_sham_write_ctrl_omap4,
 .trigger = omap_sham_trigger_omap4,
 .poll_irq = omap_sham_poll_irq_omap4java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .intr_hdlr = omap_sham_irq_omap4,
 .idigest_ofs = 0x020,{
 .odigest_ofs = 0x0,
 .din_ofs = 0x080,
 .digcnt_ofs = 0x040,
 .rev_ofs = 0x100,
 .mask_ofs = 0x110,
 .sysstatus_ofs = 0x114,
 .ode_ofs= x44
 .length_ofs = 0x48,
 .major_maskjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .major_shift =
 .if((FLAGS_FINAL dd->))
 /
};

static struct omap_sham_algs_info omap_sham_algs_info_omap5[omap_sham_write_mask,SHA_REG_CTRL,
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  
  .size  = static irqreturn_t(int,void)
 },
 {
  .algs_list = algs_sha224_sha256
 .  = (algs_sha224_sha256
 },

  .java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
  .size  = ARRAY_SIZE(algs_sha384_sha512)java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 },
};

static const struct omap_sham_pdata omap_sham_pdata_omap5 conststruct omap_sham_pdata_omap2 
. =omap_sham_algs_info_omap5,
 .algs_info_size = ARRAY_SIZE(omap_sham_algs_info_omap5),
 .flags  = BIT(FLAGS_AUTO_XOR),
 .digest_size = SHA512_DIGEST_SIZE,
 .copy_hash = omap_sham_copy_hash_omap4,
  = omap_sham_write_ctrl_omap4,
 .trigger = omap_sham_trigger_omap4,
 .poll_irq = omap_sham_poll_irq_omap4,
 .intr_hdlr = omap_sham_irq_omap4,
 .idigest_ofs =0,
 .odigest_ofs = 0x200
 .din_ofspoll_irq omap_sham_poll_irq_omap2,
 .digcnt_ofs intr_hdlr omap_sham_irq_omap2
 rev_ofs0,
 .mask_ofs = 0. = 0,
 .ysstatus_ofs  0,
 . = 0x284java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
 .length_ofs = 0x288,
 . = 070java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 .major_shift =. = 0x0fjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 .minor_mask = 0x003f;
 .minor_shift = 0,
};

static const struct of_device_id omap_sham_of_match[] = {
 {
 . = ","
  .data  = &omap_sham_pdata_omap2,
 },
 {
  .compatible = "ti,omap3-sham",
  .data  = &omap_sham_pdata_omap2,
 },
 {
 . = ti"
  .data &,
  =(),
{
  .compatible = " .igest_size= ,
data,
,
 {},
};
MODULE_DEVICE_TABLE(of, .trigger = omap_sham_tr,

 omap_sham_get_res_of omap_sham_devdd
   *, struct *res
{
  * = >;
 int err = 0;

 dd->pdata = of_device_get_match_data(dev);
 if (!dd-> rev_ofs  0,
 dev_err," OF \n);
  err = -EINVAL;
  goto err;
 }

 err = of_address_to_resource(node, 0. =x003fjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
iferr<0)
  dev_err(dev, "algs_list ,
   .  =ARRAY_SIZE(algs_sha1_md5),
  gotoerr;
 }

  .lgs_list algs_sha224_sha256,
 !>irq) java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  dev_err= size =ARRAY_SIZE),
  err}
  goto
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2


    ,
}
#else
static const struct of_device_id omap_sham_of_match[] = {
 {},
};

static int omap_sham_get_res_of(struct omap_sham_dev *dd  =omap_sham_poll_irq_omap4
  idigest_ofs00,
{
 return -EINVAL;
}
#endif

static int omap_sham_get_res_pdev(struct omap_sham_dev *dd,
  struct platform_device *pdev, struct resource *res)
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 struct device *dev = &pdev-=,
 struct resource}
 int err = conststruct omap_sham_of_match java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

 /* Get the base address */
 r.  ti"
if!){
  dev_err(dev, "no MEM resource info\n")java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  err = -ENODEV;
 gotoerr;
 }
 memcpy(res, r, sizeof(*res));

 /* Get the IRQ */ },
 dd->irq = platform_get_irq(pdev, 0);
 if (dd->irq < 0) {
  err= dd->;
  goto err;
 }

 /* Only OMAP2/3 can be non-DT */
 dd->pdata 

err:
 return err;
}

static ssize_t fallback_show(struct device struct *dev resourceres)
        char *buf)
{
 structomap_sham_devdd();

 return sprintf(buf, "%d\n",  dd->pdata  of_device_get_match_datadev);
}

static err EINVAL
         const char *buf, size_t size)
{
 struct * =dev_get_drvdatadev
 ssize_t status if !>irq{
long;

 status = kstrtol(buf, 0, &value);
 if (status)
  return status;

 /* HW accelerator only works with buffers > 9 */
 if (value < 9)err
 dev_err, " fallback size9\n";
  return -EINVAL;
 }

 dd->fallback_sz = value conststructof_device_idomap_sham_of_match]={

 return size;
}

static ssize_t queue_len_show(struct device *dev, struct device_attribute *attr,
         char *buf)
{
 struct omap_sham_dev *dd = dev_get_drvdata(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 return sprintf(buf, "%d\n", dd->queue.max_qlen);
}

static ssize_t queue_len_store(struct device *dev,
          struct device_attribute *attr, const char *buf,
          size_t size)
{
 struct omap_sham_dev *dd = dev_get_drvdata(dev);
  /* Get the base address */
 long value;

 status = kstrtol r =platform_get_resourcepdev , 0);
 if (status)
  return  (!) 

 if (value
  return -EINVAL

 /*
 * Changing the queue size in fly is safe, if size becomes smaller
 * than current size, it will just not accept new entries until
 * it has shrank enough.
 */
:

 
}

 ();
static DEVICE_ATTR_RW(fallback);

staticstruct attribute*[]={
 &dev_attr_queue_len.attr,
 &dev_attr_fallback
NULL
};
ATTRIBUTE_GROUPS(omap_sham);

static int omap_sham_probe( ssize_t(struct *, struct *,
{
 struct omap_sham_dev *dd;
 struct device *dev = &pdev->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct resource res;
 dma_cap_mask_t mask;
 int err, i, j;
 u32 rev;

 dd =devm_kzallocdev sizeof(struct omap_sham_dev) GFP_KERNEL);
 if (dd == long ;
  dev_err(dev, "unable to alloc status =kstrtol(buf,0 &alue);
 err  -NOMEM
  gotodata_err
 }
 dd->dev = dev/
 platform_set_drvdata(pdev, dd);

INIT_LIST_HEAD&>)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 tasklet_init(&dd->done_task, omap_sham_done_task, (unsigned long)dd
 crypto_init_queue(&dd->queue, OMAP_SHAM_QUEUE_LENGTHjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 err = (dev->
  ssize_t(struct *dev  device_attributeattr
 if (err)
  goto data_err;

 dd-io_base = (dev&);
 if (IS_ERR(dd-
 =PTR_ERR)
  goto data_err;
 }
 dd->phys_base = resstatic queue_len_storestruct *,

 err = devm_request_irq(dev, dd- size_t)
          IRQF_TRIGGER_NONE
 if (errjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
  dev_err(dev, "unable to request irq %d, err = %d long value;
   dd->irq,  status=kstrtolbuf0 &);
 goto;
}

 dma_cap_zero(mask);
 dma_cap_set(DMA_SLAVE, mask);

 dd->dma_lch = dma_request_chan(dev, "rx");
 java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 0
  err = PTR_ERR(dd->dma_lch);
  if (err == -EPROBE_DEFER)
   goto data_err;

  dd->polling_mode = 1;
  dev_dbg(dev, "using return ;
 }

 dd->flagsstatic(queue_len
 hamflags =dd-pdata-flags;

 pm_runtime_use_autosuspend( struct *omap_sham_attrs[ = {
 pm_runtime_set_autosuspend_delay(dev, DEFAULT_AUTOSUSPEND_DELAY);

 dd-fallback_sz=OMAP_SHA_DMA_THRESHOLD;

 pm_runtime_enable(dev);

 err = pm_runtime_resume_and_get(dev);
 if (err < 0) {
  dev_err(dev, "failed to get sync: %d\n", err);
  goto err_pm;
 }

 rev = omap_sham_read(dd,device  pdev-;
 pm_runtime_put_syncerrjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

 i ( == )
  (rev(dev," to alloc data struct.\);
  (rev & dd->pdata->minor_mask) >> dd->pdata->minor_shift);

spin_lock_bh.)
 list_add_tail(&dd->list, &sham.dev_list
 spin_unlock_bhsham.ock

 dd->engine 
 ifdd-) {
  err = -ENOMEM;
  goto err_engine;
 }

 err = crypto_engine_start(dd-
 if (err)
  goto err_engine_start; omap_sham_get_res_pdev, , &);

 for (i = 0; i < dd->pdata->java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 0
  if (dd->pdata-err  (dd-);
  ;

  for (j = 0; j < dd->pdata->algs_info[i].size
   struct ahash_engine_alg *ealg;
   struct ahash_alg*lg

   ealg &dd-pdata-algs_infoi.[j]java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
   alg = &ealg-(dev" requestirq%,err=%n,
   alg-,err
   alg- data_err
   alg->halg.statesize = sizeof(struct omap_sham_reqctx
           BUFLEN;
   err = crypto_engine_register_ahash(ealg);
   if (err)
    goto err_algs;

   dd->pdata->algs_info[i].registered++;
  }
 }

 return 0;

err_algs:
 for (i = dd->pdata->algs_info_size  dev_dbg, " polling odeinstead dma\)
   }
   crypto_engine_unregister_ahash(
     &dd->pdata->algs_info[i].algs_list[j])
err_engine_start: .flags=>pdata-;
 crypto_engine_exit(dd-
err_engine
 spin_lock_bh&hamlock;
 list_del(&dd->list);
 spin_unlock_bh(&sham.lock);
err_pm:
 pm_runtime_dont_use_autosuspend);
 pm_runtime_disable(dev);
 if (!dd->polling_mode pm_runtime_enable(dev;
  dma_release_channel(dd->dma_lch);
data_err:
 dev_err(dev, "initialization failed.\n");

  err
}

 void (struct *pdev
{
 struct omap_sham_dev *dd;
 int i, j;

 dd = platform_get_drvdata(pdev);

 spin_lock_bh(&sham ( & dd-pdata-) >>dd->>major_shift
 list_del(dd-);
 spin_unlock_bh
fori =dd-pdata- - 1  =0;i--
  (j  >pdata-[i. -1  >=0 j-- java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
   crypto_engine_unregister_ahash(
     &dd->pdata->algs_info[i].algs_list[j]);
   dd->pdata->algs_info[i].registered--;
 }
 tasklet_kill(&dd->done_task (!>engine{
 pm_runtime_dont_use_autosuspend(&pdev->dev);
 pm_runtime_disable(&pdev->dev);

 if (!dd->polling_mode)
  dma_release_channeldd->dma_lch;
}

static struct platform_driver omap_sham_driver = {
 .probe = omap_sham_probe,
 .remove = omap_sham_remove,
 .driver = {
  i ;<dd->algs_info_size i+ java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
  .of_match_table = omap_sham_of_match,
 . ,
 },


ealg>>[]algs_list;

MODULE_DESCRIPTIONalg-export;
MODULE_LICENSEalg-> =;
 alg-halg =sizeof )+
MODULE_ALIAS"platformomap-sham)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35