508cbc79e508882855fd24ee00e7b52a2a7b4267
[sfrench/cifs-2.6.git] / drivers / crypto / chelsio / chcr_algo.c
1 /*
2  * This file is part of the Chelsio T6 Crypto driver for Linux.
3  *
4  * Copyright (c) 2003-2016 Chelsio Communications, Inc. All rights reserved.
5  *
6  * This software is available to you under a choice of one of two
7  * licenses.  You may choose to be licensed under the terms of the GNU
8  * General Public License (GPL) Version 2, available from the file
9  * COPYING in the main directory of this source tree, or the
10  * OpenIB.org BSD license below:
11  *
12  *     Redistribution and use in source and binary forms, with or
13  *     without modification, are permitted provided that the following
14  *     conditions are met:
15  *
16  *      - Redistributions of source code must retain the above
17  *        copyright notice, this list of conditions and the following
18  *        disclaimer.
19  *
20  *      - Redistributions in binary form must reproduce the above
21  *        copyright notice, this list of conditions and the following
22  *        disclaimer in the documentation and/or other materials
23  *        provided with the distribution.
24  *
25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32  * SOFTWARE.
33  *
34  * Written and Maintained by:
35  *      Manoj Malviya (manojmalviya@chelsio.com)
36  *      Atul Gupta (atul.gupta@chelsio.com)
37  *      Jitendra Lulla (jlulla@chelsio.com)
38  *      Yeshaswi M R Gowda (yeshaswi@chelsio.com)
39  *      Harsh Jain (harsh@chelsio.com)
40  */
41
42 #define pr_fmt(fmt) "chcr:" fmt
43
44 #include <linux/kernel.h>
45 #include <linux/module.h>
46 #include <linux/crypto.h>
47 #include <linux/cryptohash.h>
48 #include <linux/skbuff.h>
49 #include <linux/rtnetlink.h>
50 #include <linux/highmem.h>
51 #include <linux/scatterlist.h>
52
53 #include <crypto/aes.h>
54 #include <crypto/algapi.h>
55 #include <crypto/hash.h>
56 #include <crypto/sha.h>
57 #include <crypto/authenc.h>
58 #include <crypto/ctr.h>
59 #include <crypto/gf128mul.h>
60 #include <crypto/internal/aead.h>
61 #include <crypto/null.h>
62 #include <crypto/internal/skcipher.h>
63 #include <crypto/aead.h>
64 #include <crypto/scatterwalk.h>
65 #include <crypto/internal/hash.h>
66
67 #include "t4fw_api.h"
68 #include "t4_msg.h"
69 #include "chcr_core.h"
70 #include "chcr_algo.h"
71 #include "chcr_crypto.h"
72
73 static inline  struct chcr_aead_ctx *AEAD_CTX(struct chcr_context *ctx)
74 {
75         return ctx->crypto_ctx->aeadctx;
76 }
77
78 static inline struct ablk_ctx *ABLK_CTX(struct chcr_context *ctx)
79 {
80         return ctx->crypto_ctx->ablkctx;
81 }
82
83 static inline struct hmac_ctx *HMAC_CTX(struct chcr_context *ctx)
84 {
85         return ctx->crypto_ctx->hmacctx;
86 }
87
88 static inline struct chcr_gcm_ctx *GCM_CTX(struct chcr_aead_ctx *gctx)
89 {
90         return gctx->ctx->gcm;
91 }
92
93 static inline struct chcr_authenc_ctx *AUTHENC_CTX(struct chcr_aead_ctx *gctx)
94 {
95         return gctx->ctx->authenc;
96 }
97
98 static inline struct uld_ctx *ULD_CTX(struct chcr_context *ctx)
99 {
100         return ctx->dev->u_ctx;
101 }
102
103 static inline int is_ofld_imm(const struct sk_buff *skb)
104 {
105         return (skb->len <= CRYPTO_MAX_IMM_TX_PKT_LEN);
106 }
107
108 /*
109  *      sgl_len - calculates the size of an SGL of the given capacity
110  *      @n: the number of SGL entries
111  *      Calculates the number of flits needed for a scatter/gather list that
112  *      can hold the given number of entries.
113  */
114 static inline unsigned int sgl_len(unsigned int n)
115 {
116         n--;
117         return (3 * n) / 2 + (n & 1) + 2;
118 }
119
120 static void chcr_verify_tag(struct aead_request *req, u8 *input, int *err)
121 {
122         u8 temp[SHA512_DIGEST_SIZE];
123         struct crypto_aead *tfm = crypto_aead_reqtfm(req);
124         int authsize = crypto_aead_authsize(tfm);
125         struct cpl_fw6_pld *fw6_pld;
126         int cmp = 0;
127
128         fw6_pld = (struct cpl_fw6_pld *)input;
129         if ((get_aead_subtype(tfm) == CRYPTO_ALG_SUB_TYPE_AEAD_RFC4106) ||
130             (get_aead_subtype(tfm) == CRYPTO_ALG_SUB_TYPE_AEAD_GCM)) {
131                 cmp = crypto_memneq(&fw6_pld->data[2], (fw6_pld + 1), authsize);
132         } else {
133
134                 sg_pcopy_to_buffer(req->src, sg_nents(req->src), temp,
135                                 authsize, req->assoclen +
136                                 req->cryptlen - authsize);
137                 cmp = crypto_memneq(temp, (fw6_pld + 1), authsize);
138         }
139         if (cmp)
140                 *err = -EBADMSG;
141         else
142                 *err = 0;
143 }
144
145 /*
146  *      chcr_handle_resp - Unmap the DMA buffers associated with the request
147  *      @req: crypto request
148  */
149 int chcr_handle_resp(struct crypto_async_request *req, unsigned char *input,
150                          int err)
151 {
152         struct crypto_tfm *tfm = req->tfm;
153         struct chcr_context *ctx = crypto_tfm_ctx(tfm);
154         struct uld_ctx *u_ctx = ULD_CTX(ctx);
155         struct chcr_req_ctx ctx_req;
156         unsigned int digestsize, updated_digestsize;
157         struct adapter *adap = padap(ctx->dev);
158
159         switch (tfm->__crt_alg->cra_flags & CRYPTO_ALG_TYPE_MASK) {
160         case CRYPTO_ALG_TYPE_AEAD:
161                 ctx_req.req.aead_req = aead_request_cast(req);
162                 ctx_req.ctx.reqctx = aead_request_ctx(ctx_req.req.aead_req);
163                 dma_unmap_sg(&u_ctx->lldi.pdev->dev, ctx_req.ctx.reqctx->dst,
164                              ctx_req.ctx.reqctx->dst_nents, DMA_FROM_DEVICE);
165                 if (ctx_req.ctx.reqctx->skb) {
166                         kfree_skb(ctx_req.ctx.reqctx->skb);
167                         ctx_req.ctx.reqctx->skb = NULL;
168                 }
169                 free_new_sg(ctx_req.ctx.reqctx->newdstsg);
170                 ctx_req.ctx.reqctx->newdstsg = NULL;
171                 if (ctx_req.ctx.reqctx->verify == VERIFY_SW) {
172                         chcr_verify_tag(ctx_req.req.aead_req, input,
173                                         &err);
174                         ctx_req.ctx.reqctx->verify = VERIFY_HW;
175                 }
176                 ctx_req.req.aead_req->base.complete(req, err);
177                 break;
178
179         case CRYPTO_ALG_TYPE_ABLKCIPHER:
180                  err = chcr_handle_cipher_resp(ablkcipher_request_cast(req),
181                                                input, err);
182                 break;
183
184         case CRYPTO_ALG_TYPE_AHASH:
185                 ctx_req.req.ahash_req = ahash_request_cast(req);
186                 ctx_req.ctx.ahash_ctx =
187                         ahash_request_ctx(ctx_req.req.ahash_req);
188                 digestsize =
189                         crypto_ahash_digestsize(crypto_ahash_reqtfm(
190                                                         ctx_req.req.ahash_req));
191                 updated_digestsize = digestsize;
192                 if (digestsize == SHA224_DIGEST_SIZE)
193                         updated_digestsize = SHA256_DIGEST_SIZE;
194                 else if (digestsize == SHA384_DIGEST_SIZE)
195                         updated_digestsize = SHA512_DIGEST_SIZE;
196                 if (ctx_req.ctx.ahash_ctx->skb) {
197                         kfree_skb(ctx_req.ctx.ahash_ctx->skb);
198                         ctx_req.ctx.ahash_ctx->skb = NULL;
199                 }
200                 if (ctx_req.ctx.ahash_ctx->result == 1) {
201                         ctx_req.ctx.ahash_ctx->result = 0;
202                         memcpy(ctx_req.req.ahash_req->result, input +
203                                sizeof(struct cpl_fw6_pld),
204                                digestsize);
205                 } else {
206                         memcpy(ctx_req.ctx.ahash_ctx->partial_hash, input +
207                                sizeof(struct cpl_fw6_pld),
208                                updated_digestsize);
209                 }
210                 ctx_req.req.ahash_req->base.complete(req, err);
211                 break;
212         }
213         atomic_inc(&adap->chcr_stats.complete);
214         return err;
215 }
216
217 /*
218  *      calc_tx_flits_ofld - calculate # of flits for an offload packet
219  *      @skb: the packet
220  *      Returns the number of flits needed for the given offload packet.
221  *      These packets are already fully constructed and no additional headers
222  *      will be added.
223  */
224 static inline unsigned int calc_tx_flits_ofld(const struct sk_buff *skb)
225 {
226         unsigned int flits, cnt;
227
228         if (is_ofld_imm(skb))
229                 return DIV_ROUND_UP(skb->len, 8);
230
231         flits = skb_transport_offset(skb) / 8;   /* headers */
232         cnt = skb_shinfo(skb)->nr_frags;
233         if (skb_tail_pointer(skb) != skb_transport_header(skb))
234                 cnt++;
235         return flits + sgl_len(cnt);
236 }
237
238 static inline void get_aes_decrypt_key(unsigned char *dec_key,
239                                        const unsigned char *key,
240                                        unsigned int keylength)
241 {
242         u32 temp;
243         u32 w_ring[MAX_NK];
244         int i, j, k;
245         u8  nr, nk;
246
247         switch (keylength) {
248         case AES_KEYLENGTH_128BIT:
249                 nk = KEYLENGTH_4BYTES;
250                 nr = NUMBER_OF_ROUNDS_10;
251                 break;
252         case AES_KEYLENGTH_192BIT:
253                 nk = KEYLENGTH_6BYTES;
254                 nr = NUMBER_OF_ROUNDS_12;
255                 break;
256         case AES_KEYLENGTH_256BIT:
257                 nk = KEYLENGTH_8BYTES;
258                 nr = NUMBER_OF_ROUNDS_14;
259                 break;
260         default:
261                 return;
262         }
263         for (i = 0; i < nk; i++)
264                 w_ring[i] = be32_to_cpu(*(u32 *)&key[4 * i]);
265
266         i = 0;
267         temp = w_ring[nk - 1];
268         while (i + nk < (nr + 1) * 4) {
269                 if (!(i % nk)) {
270                         /* RotWord(temp) */
271                         temp = (temp << 8) | (temp >> 24);
272                         temp = aes_ks_subword(temp);
273                         temp ^= round_constant[i / nk];
274                 } else if (nk == 8 && (i % 4 == 0)) {
275                         temp = aes_ks_subword(temp);
276                 }
277                 w_ring[i % nk] ^= temp;
278                 temp = w_ring[i % nk];
279                 i++;
280         }
281         i--;
282         for (k = 0, j = i % nk; k < nk; k++) {
283                 *((u32 *)dec_key + k) = htonl(w_ring[j]);
284                 j--;
285                 if (j < 0)
286                         j += nk;
287         }
288 }
289
290 static struct crypto_shash *chcr_alloc_shash(unsigned int ds)
291 {
292         struct crypto_shash *base_hash = ERR_PTR(-EINVAL);
293
294         switch (ds) {
295         case SHA1_DIGEST_SIZE:
296                 base_hash = crypto_alloc_shash("sha1", 0, 0);
297                 break;
298         case SHA224_DIGEST_SIZE:
299                 base_hash = crypto_alloc_shash("sha224", 0, 0);
300                 break;
301         case SHA256_DIGEST_SIZE:
302                 base_hash = crypto_alloc_shash("sha256", 0, 0);
303                 break;
304         case SHA384_DIGEST_SIZE:
305                 base_hash = crypto_alloc_shash("sha384", 0, 0);
306                 break;
307         case SHA512_DIGEST_SIZE:
308                 base_hash = crypto_alloc_shash("sha512", 0, 0);
309                 break;
310         }
311
312         return base_hash;
313 }
314
315 static int chcr_compute_partial_hash(struct shash_desc *desc,
316                                      char *iopad, char *result_hash,
317                                      int digest_size)
318 {
319         struct sha1_state sha1_st;
320         struct sha256_state sha256_st;
321         struct sha512_state sha512_st;
322         int error;
323
324         if (digest_size == SHA1_DIGEST_SIZE) {
325                 error = crypto_shash_init(desc) ?:
326                         crypto_shash_update(desc, iopad, SHA1_BLOCK_SIZE) ?:
327                         crypto_shash_export(desc, (void *)&sha1_st);
328                 memcpy(result_hash, sha1_st.state, SHA1_DIGEST_SIZE);
329         } else if (digest_size == SHA224_DIGEST_SIZE) {
330                 error = crypto_shash_init(desc) ?:
331                         crypto_shash_update(desc, iopad, SHA256_BLOCK_SIZE) ?:
332                         crypto_shash_export(desc, (void *)&sha256_st);
333                 memcpy(result_hash, sha256_st.state, SHA256_DIGEST_SIZE);
334
335         } else if (digest_size == SHA256_DIGEST_SIZE) {
336                 error = crypto_shash_init(desc) ?:
337                         crypto_shash_update(desc, iopad, SHA256_BLOCK_SIZE) ?:
338                         crypto_shash_export(desc, (void *)&sha256_st);
339                 memcpy(result_hash, sha256_st.state, SHA256_DIGEST_SIZE);
340
341         } else if (digest_size == SHA384_DIGEST_SIZE) {
342                 error = crypto_shash_init(desc) ?:
343                         crypto_shash_update(desc, iopad, SHA512_BLOCK_SIZE) ?:
344                         crypto_shash_export(desc, (void *)&sha512_st);
345                 memcpy(result_hash, sha512_st.state, SHA512_DIGEST_SIZE);
346
347         } else if (digest_size == SHA512_DIGEST_SIZE) {
348                 error = crypto_shash_init(desc) ?:
349                         crypto_shash_update(desc, iopad, SHA512_BLOCK_SIZE) ?:
350                         crypto_shash_export(desc, (void *)&sha512_st);
351                 memcpy(result_hash, sha512_st.state, SHA512_DIGEST_SIZE);
352         } else {
353                 error = -EINVAL;
354                 pr_err("Unknown digest size %d\n", digest_size);
355         }
356         return error;
357 }
358
359 static void chcr_change_order(char *buf, int ds)
360 {
361         int i;
362
363         if (ds == SHA512_DIGEST_SIZE) {
364                 for (i = 0; i < (ds / sizeof(u64)); i++)
365                         *((__be64 *)buf + i) =
366                                 cpu_to_be64(*((u64 *)buf + i));
367         } else {
368                 for (i = 0; i < (ds / sizeof(u32)); i++)
369                         *((__be32 *)buf + i) =
370                                 cpu_to_be32(*((u32 *)buf + i));
371         }
372 }
373
374 static inline int is_hmac(struct crypto_tfm *tfm)
375 {
376         struct crypto_alg *alg = tfm->__crt_alg;
377         struct chcr_alg_template *chcr_crypto_alg =
378                 container_of(__crypto_ahash_alg(alg), struct chcr_alg_template,
379                              alg.hash);
380         if (chcr_crypto_alg->type == CRYPTO_ALG_TYPE_HMAC)
381                 return 1;
382         return 0;
383 }
384
385 static void write_phys_cpl(struct cpl_rx_phys_dsgl *phys_cpl,
386                            struct scatterlist *sg,
387                            struct phys_sge_parm *sg_param)
388 {
389         struct phys_sge_pairs *to;
390         unsigned int len = 0, left_size = sg_param->obsize;
391         unsigned int nents = sg_param->nents, i, j = 0;
392
393         phys_cpl->op_to_tid = htonl(CPL_RX_PHYS_DSGL_OPCODE_V(CPL_RX_PHYS_DSGL)
394                                     | CPL_RX_PHYS_DSGL_ISRDMA_V(0));
395         phys_cpl->pcirlxorder_to_noofsgentr =
396                 htonl(CPL_RX_PHYS_DSGL_PCIRLXORDER_V(0) |
397                       CPL_RX_PHYS_DSGL_PCINOSNOOP_V(0) |
398                       CPL_RX_PHYS_DSGL_PCITPHNTENB_V(0) |
399                       CPL_RX_PHYS_DSGL_PCITPHNT_V(0) |
400                       CPL_RX_PHYS_DSGL_DCAID_V(0) |
401                       CPL_RX_PHYS_DSGL_NOOFSGENTR_V(nents));
402         phys_cpl->rss_hdr_int.opcode = CPL_RX_PHYS_ADDR;
403         phys_cpl->rss_hdr_int.qid = htons(sg_param->qid);
404         phys_cpl->rss_hdr_int.hash_val = 0;
405         to = (struct phys_sge_pairs *)((unsigned char *)phys_cpl +
406                                        sizeof(struct cpl_rx_phys_dsgl));
407         for (i = 0; nents && left_size; to++) {
408                 for (j = 0; j < 8 && nents && left_size; j++, nents--) {
409                         len = min(left_size, sg_dma_len(sg));
410                         to->len[j] = htons(len);
411                         to->addr[j] = cpu_to_be64(sg_dma_address(sg));
412                         left_size -= len;
413                         sg = sg_next(sg);
414                 }
415         }
416 }
417
418 static inline int map_writesg_phys_cpl(struct device *dev,
419                                         struct cpl_rx_phys_dsgl *phys_cpl,
420                                         struct scatterlist *sg,
421                                         struct phys_sge_parm *sg_param)
422 {
423         if (!sg || !sg_param->nents)
424                 return -EINVAL;
425
426         sg_param->nents = dma_map_sg(dev, sg, sg_param->nents, DMA_FROM_DEVICE);
427         if (sg_param->nents == 0) {
428                 pr_err("CHCR : DMA mapping failed\n");
429                 return -EINVAL;
430         }
431         write_phys_cpl(phys_cpl, sg, sg_param);
432         return 0;
433 }
434
435 static inline int get_aead_subtype(struct crypto_aead *aead)
436 {
437         struct aead_alg *alg = crypto_aead_alg(aead);
438         struct chcr_alg_template *chcr_crypto_alg =
439                 container_of(alg, struct chcr_alg_template, alg.aead);
440         return chcr_crypto_alg->type & CRYPTO_ALG_SUB_TYPE_MASK;
441 }
442
443 static inline int get_cryptoalg_subtype(struct crypto_tfm *tfm)
444 {
445         struct crypto_alg *alg = tfm->__crt_alg;
446         struct chcr_alg_template *chcr_crypto_alg =
447                 container_of(alg, struct chcr_alg_template, alg.crypto);
448
449         return chcr_crypto_alg->type & CRYPTO_ALG_SUB_TYPE_MASK;
450 }
451
452 static inline void write_buffer_to_skb(struct sk_buff *skb,
453                                         unsigned int *frags,
454                                         char *bfr,
455                                         u8 bfr_len)
456 {
457         skb->len += bfr_len;
458         skb->data_len += bfr_len;
459         skb->truesize += bfr_len;
460         get_page(virt_to_page(bfr));
461         skb_fill_page_desc(skb, *frags, virt_to_page(bfr),
462                            offset_in_page(bfr), bfr_len);
463         (*frags)++;
464 }
465
466
467 static inline void
468 write_sg_to_skb(struct sk_buff *skb, unsigned int *frags,
469                         struct scatterlist *sg, unsigned int count)
470 {
471         struct page *spage;
472         unsigned int page_len;
473
474         skb->len += count;
475         skb->data_len += count;
476         skb->truesize += count;
477
478         while (count > 0) {
479                 if (!sg || (!(sg->length)))
480                         break;
481                 spage = sg_page(sg);
482                 get_page(spage);
483                 page_len = min(sg->length, count);
484                 skb_fill_page_desc(skb, *frags, spage, sg->offset, page_len);
485                 (*frags)++;
486                 count -= page_len;
487                 sg = sg_next(sg);
488         }
489 }
490
491 static int cxgb4_is_crypto_q_full(struct net_device *dev, unsigned int idx)
492 {
493         struct adapter *adap = netdev2adap(dev);
494         struct sge_uld_txq_info *txq_info =
495                 adap->sge.uld_txq_info[CXGB4_TX_CRYPTO];
496         struct sge_uld_txq *txq;
497         int ret = 0;
498
499         local_bh_disable();
500         txq = &txq_info->uldtxq[idx];
501         spin_lock(&txq->sendq.lock);
502         if (txq->full)
503                 ret = -1;
504         spin_unlock(&txq->sendq.lock);
505         local_bh_enable();
506         return ret;
507 }
508
509 static int generate_copy_rrkey(struct ablk_ctx *ablkctx,
510                                struct _key_ctx *key_ctx)
511 {
512         if (ablkctx->ciph_mode == CHCR_SCMD_CIPHER_MODE_AES_CBC) {
513                 memcpy(key_ctx->key, ablkctx->rrkey, ablkctx->enckey_len);
514         } else {
515                 memcpy(key_ctx->key,
516                        ablkctx->key + (ablkctx->enckey_len >> 1),
517                        ablkctx->enckey_len >> 1);
518                 memcpy(key_ctx->key + (ablkctx->enckey_len >> 1),
519                        ablkctx->rrkey, ablkctx->enckey_len >> 1);
520         }
521         return 0;
522 }
523 static int chcr_sg_ent_in_wr(struct scatterlist *src,
524                              struct scatterlist *dst,
525                              unsigned int minsg,
526                              unsigned int space,
527                              short int *sent,
528                              short int *dent)
529 {
530         int srclen = 0, dstlen = 0;
531         int srcsg = minsg, dstsg = 0;
532
533         *sent = 0;
534         *dent = 0;
535         while (src && dst && ((srcsg + 1) <= MAX_SKB_FRAGS) &&
536                space > (sgl_ent_len[srcsg + 1] + dsgl_ent_len[dstsg])) {
537                 srclen += src->length;
538                 srcsg++;
539                 while (dst && ((dstsg + 1) <= MAX_DSGL_ENT) &&
540                        space > (sgl_ent_len[srcsg] + dsgl_ent_len[dstsg + 1])) {
541                         if (srclen <= dstlen)
542                                 break;
543                         dstlen += dst->length;
544                         dst = sg_next(dst);
545                         dstsg++;
546                 }
547                 src = sg_next(src);
548         }
549         *sent = srcsg - minsg;
550         *dent = dstsg;
551         return min(srclen, dstlen);
552 }
553
554 static int chcr_cipher_fallback(struct crypto_skcipher *cipher,
555                                 u32 flags,
556                                 struct scatterlist *src,
557                                 struct scatterlist *dst,
558                                 unsigned int nbytes,
559                                 u8 *iv,
560                                 unsigned short op_type)
561 {
562         int err;
563
564         SKCIPHER_REQUEST_ON_STACK(subreq, cipher);
565         skcipher_request_set_tfm(subreq, cipher);
566         skcipher_request_set_callback(subreq, flags, NULL, NULL);
567         skcipher_request_set_crypt(subreq, src, dst,
568                                    nbytes, iv);
569
570         err = op_type ? crypto_skcipher_decrypt(subreq) :
571                 crypto_skcipher_encrypt(subreq);
572         skcipher_request_zero(subreq);
573
574         return err;
575
576 }
577 static inline void create_wreq(struct chcr_context *ctx,
578                                struct chcr_wr *chcr_req,
579                                void *req, struct sk_buff *skb,
580                                int kctx_len, int hash_sz,
581                                int is_iv,
582                                unsigned int sc_len,
583                                unsigned int lcb)
584 {
585         struct uld_ctx *u_ctx = ULD_CTX(ctx);
586         int iv_loc = IV_DSGL;
587         int qid = u_ctx->lldi.rxq_ids[ctx->rx_qidx];
588         unsigned int immdatalen = 0, nr_frags = 0;
589
590         if (is_ofld_imm(skb)) {
591                 immdatalen = skb->data_len;
592                 iv_loc = IV_IMMEDIATE;
593         } else {
594                 nr_frags = skb_shinfo(skb)->nr_frags;
595         }
596
597         chcr_req->wreq.op_to_cctx_size = FILL_WR_OP_CCTX_SIZE(immdatalen,
598                                 ((sizeof(chcr_req->key_ctx) + kctx_len) >> 4));
599         chcr_req->wreq.pld_size_hash_size =
600                 htonl(FW_CRYPTO_LOOKASIDE_WR_PLD_SIZE_V(sgl_lengths[nr_frags]) |
601                       FW_CRYPTO_LOOKASIDE_WR_HASH_SIZE_V(hash_sz));
602         chcr_req->wreq.len16_pkd =
603                 htonl(FW_CRYPTO_LOOKASIDE_WR_LEN16_V(DIV_ROUND_UP(
604                                     (calc_tx_flits_ofld(skb) * 8), 16)));
605         chcr_req->wreq.cookie = cpu_to_be64((uintptr_t)req);
606         chcr_req->wreq.rx_chid_to_rx_q_id =
607                 FILL_WR_RX_Q_ID(ctx->dev->rx_channel_id, qid,
608                                 is_iv ? iv_loc : IV_NOP, !!lcb,
609                                 ctx->tx_qidx);
610
611         chcr_req->ulptx.cmd_dest = FILL_ULPTX_CMD_DEST(ctx->dev->tx_channel_id,
612                                                        qid);
613         chcr_req->ulptx.len = htonl((DIV_ROUND_UP((calc_tx_flits_ofld(skb) * 8),
614                                         16) - ((sizeof(chcr_req->wreq)) >> 4)));
615
616         chcr_req->sc_imm.cmd_more = FILL_CMD_MORE(immdatalen);
617         chcr_req->sc_imm.len = cpu_to_be32(sizeof(struct cpl_tx_sec_pdu) +
618                                    sizeof(chcr_req->key_ctx) +
619                                    kctx_len + sc_len + immdatalen);
620 }
621
622 /**
623  *      create_cipher_wr - form the WR for cipher operations
624  *      @req: cipher req.
625  *      @ctx: crypto driver context of the request.
626  *      @qid: ingress qid where response of this WR should be received.
627  *      @op_type:       encryption or decryption
628  */
629 static struct sk_buff *create_cipher_wr(struct cipher_wr_param *wrparam)
630 {
631         struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(wrparam->req);
632         struct chcr_context *ctx = crypto_ablkcipher_ctx(tfm);
633         struct uld_ctx *u_ctx = ULD_CTX(ctx);
634         struct ablk_ctx *ablkctx = ABLK_CTX(ctx);
635         struct sk_buff *skb = NULL;
636         struct chcr_wr *chcr_req;
637         struct cpl_rx_phys_dsgl *phys_cpl;
638         struct chcr_blkcipher_req_ctx *reqctx =
639                 ablkcipher_request_ctx(wrparam->req);
640         struct phys_sge_parm sg_param;
641         unsigned int frags = 0, transhdr_len, phys_dsgl;
642         int error;
643         unsigned int ivsize = AES_BLOCK_SIZE, kctx_len;
644         gfp_t flags = wrparam->req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP ?
645                         GFP_KERNEL : GFP_ATOMIC;
646         struct adapter *adap = padap(ctx->dev);
647
648         phys_dsgl = get_space_for_phys_dsgl(reqctx->dst_nents);
649
650         kctx_len = (DIV_ROUND_UP(ablkctx->enckey_len, 16) * 16);
651         transhdr_len = CIPHER_TRANSHDR_SIZE(kctx_len, phys_dsgl);
652         skb = alloc_skb((transhdr_len + sizeof(struct sge_opaque_hdr)), flags);
653         if (!skb) {
654                 error = -ENOMEM;
655                 goto err;
656         }
657         skb_reserve(skb, sizeof(struct sge_opaque_hdr));
658         chcr_req = (struct chcr_wr *)__skb_put(skb, transhdr_len);
659         memset(chcr_req, 0, transhdr_len);
660         chcr_req->sec_cpl.op_ivinsrtofst =
661                 FILL_SEC_CPL_OP_IVINSR(ctx->dev->rx_channel_id, 2, 1);
662
663         chcr_req->sec_cpl.pldlen = htonl(ivsize + wrparam->bytes);
664         chcr_req->sec_cpl.aadstart_cipherstop_hi =
665                         FILL_SEC_CPL_CIPHERSTOP_HI(0, 0, ivsize + 1, 0);
666
667         chcr_req->sec_cpl.cipherstop_lo_authinsert =
668                         FILL_SEC_CPL_AUTHINSERT(0, 0, 0, 0);
669         chcr_req->sec_cpl.seqno_numivs = FILL_SEC_CPL_SCMD0_SEQNO(reqctx->op, 0,
670                                                          ablkctx->ciph_mode,
671                                                          0, 0, ivsize >> 1);
672         chcr_req->sec_cpl.ivgen_hdrlen = FILL_SEC_CPL_IVGEN_HDRLEN(0, 0, 0,
673                                                           0, 1, phys_dsgl);
674
675         chcr_req->key_ctx.ctx_hdr = ablkctx->key_ctx_hdr;
676         if ((reqctx->op == CHCR_DECRYPT_OP) &&
677             (!(get_cryptoalg_subtype(crypto_ablkcipher_tfm(tfm)) ==
678                CRYPTO_ALG_SUB_TYPE_CTR)) &&
679             (!(get_cryptoalg_subtype(crypto_ablkcipher_tfm(tfm)) ==
680                CRYPTO_ALG_SUB_TYPE_CTR_RFC3686))) {
681                 generate_copy_rrkey(ablkctx, &chcr_req->key_ctx);
682         } else {
683                 if ((ablkctx->ciph_mode == CHCR_SCMD_CIPHER_MODE_AES_CBC) ||
684                     (ablkctx->ciph_mode == CHCR_SCMD_CIPHER_MODE_AES_CTR)) {
685                         memcpy(chcr_req->key_ctx.key, ablkctx->key,
686                                ablkctx->enckey_len);
687                 } else {
688                         memcpy(chcr_req->key_ctx.key, ablkctx->key +
689                                (ablkctx->enckey_len >> 1),
690                                ablkctx->enckey_len >> 1);
691                         memcpy(chcr_req->key_ctx.key +
692                                (ablkctx->enckey_len >> 1),
693                                ablkctx->key,
694                                ablkctx->enckey_len >> 1);
695                 }
696         }
697         phys_cpl = (struct cpl_rx_phys_dsgl *)((u8 *)(chcr_req + 1) + kctx_len);
698         sg_param.nents = reqctx->dst_nents;
699         sg_param.obsize =  wrparam->bytes;
700         sg_param.qid = wrparam->qid;
701         error = map_writesg_phys_cpl(&u_ctx->lldi.pdev->dev, phys_cpl,
702                                        reqctx->dst, &sg_param);
703         if (error)
704                 goto map_fail1;
705
706         skb_set_transport_header(skb, transhdr_len);
707         write_buffer_to_skb(skb, &frags, reqctx->iv, ivsize);
708         write_sg_to_skb(skb, &frags, wrparam->srcsg, wrparam->bytes);
709         atomic_inc(&adap->chcr_stats.cipher_rqst);
710         create_wreq(ctx, chcr_req, &(wrparam->req->base), skb, kctx_len, 0, 1,
711                         sizeof(struct cpl_rx_phys_dsgl) + phys_dsgl,
712                         ablkctx->ciph_mode == CHCR_SCMD_CIPHER_MODE_AES_CBC);
713         reqctx->skb = skb;
714         skb_get(skb);
715         return skb;
716 map_fail1:
717         kfree_skb(skb);
718 err:
719         return ERR_PTR(error);
720 }
721
722 static inline int chcr_keyctx_ck_size(unsigned int keylen)
723 {
724         int ck_size = 0;
725
726         if (keylen == AES_KEYSIZE_128)
727                 ck_size = CHCR_KEYCTX_CIPHER_KEY_SIZE_128;
728         else if (keylen == AES_KEYSIZE_192)
729                 ck_size = CHCR_KEYCTX_CIPHER_KEY_SIZE_192;
730         else if (keylen == AES_KEYSIZE_256)
731                 ck_size = CHCR_KEYCTX_CIPHER_KEY_SIZE_256;
732         else
733                 ck_size = 0;
734
735         return ck_size;
736 }
737 static int chcr_cipher_fallback_setkey(struct crypto_ablkcipher *cipher,
738                                        const u8 *key,
739                                        unsigned int keylen)
740 {
741         struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher);
742         struct chcr_context *ctx = crypto_ablkcipher_ctx(cipher);
743         struct ablk_ctx *ablkctx = ABLK_CTX(ctx);
744         int err = 0;
745
746         crypto_skcipher_clear_flags(ablkctx->sw_cipher, CRYPTO_TFM_REQ_MASK);
747         crypto_skcipher_set_flags(ablkctx->sw_cipher, cipher->base.crt_flags &
748                                   CRYPTO_TFM_REQ_MASK);
749         err = crypto_skcipher_setkey(ablkctx->sw_cipher, key, keylen);
750         tfm->crt_flags &= ~CRYPTO_TFM_RES_MASK;
751         tfm->crt_flags |=
752                 crypto_skcipher_get_flags(ablkctx->sw_cipher) &
753                 CRYPTO_TFM_RES_MASK;
754         return err;
755 }
756
757 static int chcr_aes_cbc_setkey(struct crypto_ablkcipher *cipher,
758                                const u8 *key,
759                                unsigned int keylen)
760 {
761         struct chcr_context *ctx = crypto_ablkcipher_ctx(cipher);
762         struct ablk_ctx *ablkctx = ABLK_CTX(ctx);
763         unsigned int ck_size, context_size;
764         u16 alignment = 0;
765         int err;
766
767         err = chcr_cipher_fallback_setkey(cipher, key, keylen);
768         if (err)
769                 goto badkey_err;
770
771         ck_size = chcr_keyctx_ck_size(keylen);
772         alignment = ck_size == CHCR_KEYCTX_CIPHER_KEY_SIZE_192 ? 8 : 0;
773         memcpy(ablkctx->key, key, keylen);
774         ablkctx->enckey_len = keylen;
775         get_aes_decrypt_key(ablkctx->rrkey, ablkctx->key, keylen << 3);
776         context_size = (KEY_CONTEXT_HDR_SALT_AND_PAD +
777                         keylen + alignment) >> 4;
778
779         ablkctx->key_ctx_hdr = FILL_KEY_CTX_HDR(ck_size, CHCR_KEYCTX_NO_KEY,
780                                                 0, 0, context_size);
781         ablkctx->ciph_mode = CHCR_SCMD_CIPHER_MODE_AES_CBC;
782         return 0;
783 badkey_err:
784         crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
785         ablkctx->enckey_len = 0;
786
787         return err;
788 }
789
790 static int chcr_aes_ctr_setkey(struct crypto_ablkcipher *cipher,
791                                    const u8 *key,
792                                    unsigned int keylen)
793 {
794         struct chcr_context *ctx = crypto_ablkcipher_ctx(cipher);
795         struct ablk_ctx *ablkctx = ABLK_CTX(ctx);
796         unsigned int ck_size, context_size;
797         u16 alignment = 0;
798         int err;
799
800         err = chcr_cipher_fallback_setkey(cipher, key, keylen);
801         if (err)
802                 goto badkey_err;
803         ck_size = chcr_keyctx_ck_size(keylen);
804         alignment = (ck_size == CHCR_KEYCTX_CIPHER_KEY_SIZE_192) ? 8 : 0;
805         memcpy(ablkctx->key, key, keylen);
806         ablkctx->enckey_len = keylen;
807         context_size = (KEY_CONTEXT_HDR_SALT_AND_PAD +
808                         keylen + alignment) >> 4;
809
810         ablkctx->key_ctx_hdr = FILL_KEY_CTX_HDR(ck_size, CHCR_KEYCTX_NO_KEY,
811                                                 0, 0, context_size);
812         ablkctx->ciph_mode = CHCR_SCMD_CIPHER_MODE_AES_CTR;
813
814         return 0;
815 badkey_err:
816         crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
817         ablkctx->enckey_len = 0;
818
819         return err;
820 }
821
822 static int chcr_aes_rfc3686_setkey(struct crypto_ablkcipher *cipher,
823                                    const u8 *key,
824                                    unsigned int keylen)
825 {
826         struct chcr_context *ctx = crypto_ablkcipher_ctx(cipher);
827         struct ablk_ctx *ablkctx = ABLK_CTX(ctx);
828         unsigned int ck_size, context_size;
829         u16 alignment = 0;
830         int err;
831
832         if (keylen < CTR_RFC3686_NONCE_SIZE)
833                 return -EINVAL;
834         memcpy(ablkctx->nonce, key + (keylen - CTR_RFC3686_NONCE_SIZE),
835                CTR_RFC3686_NONCE_SIZE);
836
837         keylen -= CTR_RFC3686_NONCE_SIZE;
838         err = chcr_cipher_fallback_setkey(cipher, key, keylen);
839         if (err)
840                 goto badkey_err;
841
842         ck_size = chcr_keyctx_ck_size(keylen);
843         alignment = (ck_size == CHCR_KEYCTX_CIPHER_KEY_SIZE_192) ? 8 : 0;
844         memcpy(ablkctx->key, key, keylen);
845         ablkctx->enckey_len = keylen;
846         context_size = (KEY_CONTEXT_HDR_SALT_AND_PAD +
847                         keylen + alignment) >> 4;
848
849         ablkctx->key_ctx_hdr = FILL_KEY_CTX_HDR(ck_size, CHCR_KEYCTX_NO_KEY,
850                                                 0, 0, context_size);
851         ablkctx->ciph_mode = CHCR_SCMD_CIPHER_MODE_AES_CTR;
852
853         return 0;
854 badkey_err:
855         crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
856         ablkctx->enckey_len = 0;
857
858         return err;
859 }
860 static void ctr_add_iv(u8 *dstiv, u8 *srciv, u32 add)
861 {
862         unsigned int size = AES_BLOCK_SIZE;
863         __be32 *b = (__be32 *)(dstiv + size);
864         u32 c, prev;
865
866         memcpy(dstiv, srciv, AES_BLOCK_SIZE);
867         for (; size >= 4; size -= 4) {
868                 prev = be32_to_cpu(*--b);
869                 c = prev + add;
870                 *b = cpu_to_be32(c);
871                 if (prev < c)
872                         break;
873                 add = 1;
874         }
875
876 }
877
878 static unsigned int adjust_ctr_overflow(u8 *iv, u32 bytes)
879 {
880         __be32 *b = (__be32 *)(iv + AES_BLOCK_SIZE);
881         u64 c;
882         u32 temp = be32_to_cpu(*--b);
883
884         temp = ~temp;
885         c = (u64)temp +  1; // No of block can processed withou overflow
886         if ((bytes / AES_BLOCK_SIZE) > c)
887                 bytes = c * AES_BLOCK_SIZE;
888         return bytes;
889 }
890
891 static int chcr_update_tweak(struct ablkcipher_request *req, u8 *iv)
892 {
893         struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
894         struct chcr_context *ctx = crypto_ablkcipher_ctx(tfm);
895         struct ablk_ctx *ablkctx = ABLK_CTX(ctx);
896         struct chcr_blkcipher_req_ctx *reqctx = ablkcipher_request_ctx(req);
897         struct crypto_cipher *cipher;
898         int ret, i;
899         u8 *key;
900         unsigned int keylen;
901
902         cipher = ablkctx->aes_generic;
903         memcpy(iv, req->info, AES_BLOCK_SIZE);
904
905         keylen = ablkctx->enckey_len / 2;
906         key = ablkctx->key + keylen;
907         ret = crypto_cipher_setkey(cipher, key, keylen);
908         if (ret)
909                 goto out;
910
911         crypto_cipher_encrypt_one(cipher, iv, iv);
912         for (i = 0; i < (reqctx->processed / AES_BLOCK_SIZE); i++)
913                 gf128mul_x_ble((le128 *)iv, (le128 *)iv);
914
915         crypto_cipher_decrypt_one(cipher, iv, iv);
916 out:
917         return ret;
918 }
919
920 static int chcr_update_cipher_iv(struct ablkcipher_request *req,
921                                    struct cpl_fw6_pld *fw6_pld, u8 *iv)
922 {
923         struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
924         struct chcr_blkcipher_req_ctx *reqctx = ablkcipher_request_ctx(req);
925         int subtype = get_cryptoalg_subtype(crypto_ablkcipher_tfm(tfm));
926         int ret = 0;
927
928         if (subtype == CRYPTO_ALG_SUB_TYPE_CTR)
929                 ctr_add_iv(iv, req->info, (reqctx->processed /
930                            AES_BLOCK_SIZE));
931         else if (subtype == CRYPTO_ALG_SUB_TYPE_CTR_RFC3686)
932                 *(__be32 *)(reqctx->iv + CTR_RFC3686_NONCE_SIZE +
933                         CTR_RFC3686_IV_SIZE) = cpu_to_be32((reqctx->processed /
934                                                 AES_BLOCK_SIZE) + 1);
935         else if (subtype == CRYPTO_ALG_SUB_TYPE_XTS)
936                 ret = chcr_update_tweak(req, iv);
937         else if (subtype == CRYPTO_ALG_SUB_TYPE_CBC) {
938                 if (reqctx->op)
939                         sg_pcopy_to_buffer(req->src, sg_nents(req->src), iv,
940                                            16,
941                                            reqctx->processed - AES_BLOCK_SIZE);
942                 else
943                         memcpy(iv, &fw6_pld->data[2], AES_BLOCK_SIZE);
944         }
945
946         return ret;
947
948 }
949
950 /* We need separate function for final iv because in rfc3686  Initial counter
951  * starts from 1 and buffer size of iv is 8 byte only which remains constant
952  * for subsequent update requests
953  */
954
955 static int chcr_final_cipher_iv(struct ablkcipher_request *req,
956                                    struct cpl_fw6_pld *fw6_pld, u8 *iv)
957 {
958         struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
959         struct chcr_blkcipher_req_ctx *reqctx = ablkcipher_request_ctx(req);
960         int subtype = get_cryptoalg_subtype(crypto_ablkcipher_tfm(tfm));
961         int ret = 0;
962
963         if (subtype == CRYPTO_ALG_SUB_TYPE_CTR)
964                 ctr_add_iv(iv, req->info, (reqctx->processed /
965                            AES_BLOCK_SIZE));
966         else if (subtype == CRYPTO_ALG_SUB_TYPE_XTS)
967                 ret = chcr_update_tweak(req, iv);
968         else if (subtype == CRYPTO_ALG_SUB_TYPE_CBC) {
969                 if (reqctx->op)
970                         sg_pcopy_to_buffer(req->src, sg_nents(req->src), iv,
971                                            16,
972                                            reqctx->processed - AES_BLOCK_SIZE);
973                 else
974                         memcpy(iv, &fw6_pld->data[2], AES_BLOCK_SIZE);
975
976         }
977         return ret;
978
979 }
980
981
982 static int chcr_handle_cipher_resp(struct ablkcipher_request *req,
983                                    unsigned char *input, int err)
984 {
985         struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
986         struct chcr_context *ctx = crypto_ablkcipher_ctx(tfm);
987         struct uld_ctx *u_ctx = ULD_CTX(ctx);
988         struct ablk_ctx *ablkctx = ABLK_CTX(ctx);
989         struct sk_buff *skb;
990         struct cpl_fw6_pld *fw6_pld = (struct cpl_fw6_pld *)input;
991         struct chcr_blkcipher_req_ctx *reqctx = ablkcipher_request_ctx(req);
992         struct  cipher_wr_param wrparam;
993         int bytes;
994
995         dma_unmap_sg(&u_ctx->lldi.pdev->dev, reqctx->dst, reqctx->dst_nents,
996                      DMA_FROM_DEVICE);
997
998         if (reqctx->skb) {
999                 kfree_skb(reqctx->skb);
1000                 reqctx->skb = NULL;
1001         }
1002         if (err)
1003                 goto complete;
1004
1005         if (req->nbytes == reqctx->processed) {
1006                 err = chcr_final_cipher_iv(req, fw6_pld, req->info);
1007                 goto complete;
1008         }
1009
1010         if (unlikely(cxgb4_is_crypto_q_full(u_ctx->lldi.ports[0],
1011                                             ctx->tx_qidx))) {
1012                 if (!(req->base.flags & CRYPTO_TFM_REQ_MAY_BACKLOG)) {
1013                         err = -EBUSY;
1014                         goto complete;
1015                 }
1016
1017         }
1018         wrparam.srcsg = scatterwalk_ffwd(reqctx->srcffwd, req->src,
1019                                        reqctx->processed);
1020         reqctx->dst = scatterwalk_ffwd(reqctx->dstffwd, reqctx->dstsg,
1021                                          reqctx->processed);
1022         if (!wrparam.srcsg || !reqctx->dst) {
1023                 pr_err("Input sg list length less that nbytes\n");
1024                 err = -EINVAL;
1025                 goto complete;
1026         }
1027         bytes = chcr_sg_ent_in_wr(wrparam.srcsg, reqctx->dst, 1,
1028                                  SPACE_LEFT(ablkctx->enckey_len),
1029                                  &wrparam.snent, &reqctx->dst_nents);
1030         if ((bytes + reqctx->processed) >= req->nbytes)
1031                 bytes  = req->nbytes - reqctx->processed;
1032         else
1033                 bytes = ROUND_16(bytes);
1034         err = chcr_update_cipher_iv(req, fw6_pld, reqctx->iv);
1035         if (err)
1036                 goto complete;
1037
1038         if (unlikely(bytes == 0)) {
1039                 err = chcr_cipher_fallback(ablkctx->sw_cipher,
1040                                      req->base.flags,
1041                                      wrparam.srcsg,
1042                                      reqctx->dst,
1043                                      req->nbytes - reqctx->processed,
1044                                      reqctx->iv,
1045                                      reqctx->op);
1046                 goto complete;
1047         }
1048
1049         if (get_cryptoalg_subtype(crypto_ablkcipher_tfm(tfm)) ==
1050             CRYPTO_ALG_SUB_TYPE_CTR)
1051                 bytes = adjust_ctr_overflow(reqctx->iv, bytes);
1052         reqctx->processed += bytes;
1053         wrparam.qid = u_ctx->lldi.rxq_ids[ctx->rx_qidx];
1054         wrparam.req = req;
1055         wrparam.bytes = bytes;
1056         skb = create_cipher_wr(&wrparam);
1057         if (IS_ERR(skb)) {
1058                 pr_err("chcr : %s : Failed to form WR. No memory\n", __func__);
1059                 err = PTR_ERR(skb);
1060                 goto complete;
1061         }
1062         skb->dev = u_ctx->lldi.ports[0];
1063         set_wr_txq(skb, CPL_PRIORITY_DATA, ctx->tx_qidx);
1064         chcr_send_wr(skb);
1065         return 0;
1066 complete:
1067         free_new_sg(reqctx->newdstsg);
1068         reqctx->newdstsg = NULL;
1069         req->base.complete(&req->base, err);
1070         return err;
1071 }
1072
1073 static int process_cipher(struct ablkcipher_request *req,
1074                                   unsigned short qid,
1075                                   struct sk_buff **skb,
1076                                   unsigned short op_type)
1077 {
1078         struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
1079         unsigned int ivsize = crypto_ablkcipher_ivsize(tfm);
1080         struct chcr_blkcipher_req_ctx *reqctx = ablkcipher_request_ctx(req);
1081         struct chcr_context *ctx = crypto_ablkcipher_ctx(tfm);
1082         struct ablk_ctx *ablkctx = ABLK_CTX(ctx);
1083         struct  cipher_wr_param wrparam;
1084         int bytes, nents, err = -EINVAL;
1085
1086         reqctx->newdstsg = NULL;
1087         reqctx->processed = 0;
1088         if (!req->info)
1089                 goto error;
1090         if ((ablkctx->enckey_len == 0) || (ivsize > AES_BLOCK_SIZE) ||
1091             (req->nbytes == 0) ||
1092             (req->nbytes % crypto_ablkcipher_blocksize(tfm))) {
1093                 pr_err("AES: Invalid value of Key Len %d nbytes %d IV Len %d\n",
1094                        ablkctx->enckey_len, req->nbytes, ivsize);
1095                 goto error;
1096         }
1097         wrparam.srcsg = req->src;
1098         if (is_newsg(req->dst, &nents)) {
1099                 reqctx->newdstsg = alloc_new_sg(req->dst, nents);
1100                 if (IS_ERR(reqctx->newdstsg))
1101                         return PTR_ERR(reqctx->newdstsg);
1102                 reqctx->dstsg = reqctx->newdstsg;
1103         } else {
1104                 reqctx->dstsg = req->dst;
1105         }
1106         bytes = chcr_sg_ent_in_wr(wrparam.srcsg, reqctx->dstsg, MIN_CIPHER_SG,
1107                                  SPACE_LEFT(ablkctx->enckey_len),
1108                                  &wrparam.snent,
1109                                  &reqctx->dst_nents);
1110         if ((bytes + reqctx->processed) >= req->nbytes)
1111                 bytes  = req->nbytes - reqctx->processed;
1112         else
1113                 bytes = ROUND_16(bytes);
1114         if (unlikely(bytes > req->nbytes))
1115                 bytes = req->nbytes;
1116         if (get_cryptoalg_subtype(crypto_ablkcipher_tfm(tfm)) ==
1117                                   CRYPTO_ALG_SUB_TYPE_CTR) {
1118                 bytes = adjust_ctr_overflow(req->info, bytes);
1119         }
1120         if (get_cryptoalg_subtype(crypto_ablkcipher_tfm(tfm)) ==
1121             CRYPTO_ALG_SUB_TYPE_CTR_RFC3686) {
1122                 memcpy(reqctx->iv, ablkctx->nonce, CTR_RFC3686_NONCE_SIZE);
1123                 memcpy(reqctx->iv + CTR_RFC3686_NONCE_SIZE, req->info,
1124                                 CTR_RFC3686_IV_SIZE);
1125
1126                 /* initialize counter portion of counter block */
1127                 *(__be32 *)(reqctx->iv + CTR_RFC3686_NONCE_SIZE +
1128                         CTR_RFC3686_IV_SIZE) = cpu_to_be32(1);
1129
1130         } else {
1131
1132                 memcpy(reqctx->iv, req->info, ivsize);
1133         }
1134         if (unlikely(bytes == 0)) {
1135                 err = chcr_cipher_fallback(ablkctx->sw_cipher,
1136                                            req->base.flags,
1137                                            req->src,
1138                                            req->dst,
1139                                            req->nbytes,
1140                                            req->info,
1141                                            op_type);
1142                 goto error;
1143         }
1144         reqctx->processed = bytes;
1145         reqctx->dst = reqctx->dstsg;
1146         reqctx->op = op_type;
1147         wrparam.qid = qid;
1148         wrparam.req = req;
1149         wrparam.bytes = bytes;
1150         *skb = create_cipher_wr(&wrparam);
1151         if (IS_ERR(*skb)) {
1152                 err = PTR_ERR(*skb);
1153                 goto error;
1154         }
1155
1156         return 0;
1157 error:
1158         free_new_sg(reqctx->newdstsg);
1159         reqctx->newdstsg = NULL;
1160         return err;
1161 }
1162
1163 static int chcr_aes_encrypt(struct ablkcipher_request *req)
1164 {
1165         struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
1166         struct chcr_context *ctx = crypto_ablkcipher_ctx(tfm);
1167         struct sk_buff *skb = NULL;
1168         int err;
1169         struct uld_ctx *u_ctx = ULD_CTX(ctx);
1170
1171         if (unlikely(cxgb4_is_crypto_q_full(u_ctx->lldi.ports[0],
1172                                             ctx->tx_qidx))) {
1173                 if (!(req->base.flags & CRYPTO_TFM_REQ_MAY_BACKLOG))
1174                         return -EBUSY;
1175         }
1176
1177         err = process_cipher(req, u_ctx->lldi.rxq_ids[ctx->rx_qidx], &skb,
1178                                CHCR_ENCRYPT_OP);
1179         if (err || !skb)
1180                 return  err;
1181         skb->dev = u_ctx->lldi.ports[0];
1182         set_wr_txq(skb, CPL_PRIORITY_DATA, ctx->tx_qidx);
1183         chcr_send_wr(skb);
1184         return -EINPROGRESS;
1185 }
1186
1187 static int chcr_aes_decrypt(struct ablkcipher_request *req)
1188 {
1189         struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
1190         struct chcr_context *ctx = crypto_ablkcipher_ctx(tfm);
1191         struct uld_ctx *u_ctx = ULD_CTX(ctx);
1192         struct sk_buff *skb = NULL;
1193         int err;
1194
1195         if (unlikely(cxgb4_is_crypto_q_full(u_ctx->lldi.ports[0],
1196                                             ctx->tx_qidx))) {
1197                 if (!(req->base.flags & CRYPTO_TFM_REQ_MAY_BACKLOG))
1198                         return -EBUSY;
1199         }
1200
1201          err = process_cipher(req, u_ctx->lldi.rxq_ids[ctx->rx_qidx], &skb,
1202                                CHCR_DECRYPT_OP);
1203         if (err || !skb)
1204                 return err;
1205         skb->dev = u_ctx->lldi.ports[0];
1206         set_wr_txq(skb, CPL_PRIORITY_DATA, ctx->tx_qidx);
1207         chcr_send_wr(skb);
1208         return -EINPROGRESS;
1209 }
1210
1211 static int chcr_device_init(struct chcr_context *ctx)
1212 {
1213         struct uld_ctx *u_ctx = NULL;
1214         struct adapter *adap;
1215         unsigned int id;
1216         int txq_perchan, txq_idx, ntxq;
1217         int err = 0, rxq_perchan, rxq_idx;
1218
1219         id = smp_processor_id();
1220         if (!ctx->dev) {
1221                 u_ctx = assign_chcr_device();
1222                 if (!u_ctx) {
1223                         pr_err("chcr device assignment fails\n");
1224                         goto out;
1225                 }
1226                 ctx->dev = u_ctx->dev;
1227                 adap = padap(ctx->dev);
1228                 ntxq = min_not_zero((unsigned int)u_ctx->lldi.nrxq,
1229                                     adap->vres.ncrypto_fc);
1230                 rxq_perchan = u_ctx->lldi.nrxq / u_ctx->lldi.nchan;
1231                 txq_perchan = ntxq / u_ctx->lldi.nchan;
1232                 rxq_idx = ctx->dev->tx_channel_id * rxq_perchan;
1233                 rxq_idx += id % rxq_perchan;
1234                 txq_idx = ctx->dev->tx_channel_id * txq_perchan;
1235                 txq_idx += id % txq_perchan;
1236                 spin_lock(&ctx->dev->lock_chcr_dev);
1237                 ctx->rx_qidx = rxq_idx;
1238                 ctx->tx_qidx = txq_idx;
1239                 ctx->dev->tx_channel_id = !ctx->dev->tx_channel_id;
1240                 ctx->dev->rx_channel_id = 0;
1241                 spin_unlock(&ctx->dev->lock_chcr_dev);
1242         }
1243 out:
1244         return err;
1245 }
1246
1247 static int chcr_cra_init(struct crypto_tfm *tfm)
1248 {
1249         struct crypto_alg *alg = tfm->__crt_alg;
1250         struct chcr_context *ctx = crypto_tfm_ctx(tfm);
1251         struct ablk_ctx *ablkctx = ABLK_CTX(ctx);
1252
1253         ablkctx->sw_cipher = crypto_alloc_skcipher(alg->cra_name, 0,
1254                                 CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK);
1255         if (IS_ERR(ablkctx->sw_cipher)) {
1256                 pr_err("failed to allocate fallback for %s\n", alg->cra_name);
1257                 return PTR_ERR(ablkctx->sw_cipher);
1258         }
1259
1260         if (get_cryptoalg_subtype(tfm) == CRYPTO_ALG_SUB_TYPE_XTS) {
1261                 /* To update tweak*/
1262                 ablkctx->aes_generic = crypto_alloc_cipher("aes-generic", 0, 0);
1263                 if (IS_ERR(ablkctx->aes_generic)) {
1264                         pr_err("failed to allocate aes cipher for tweak\n");
1265                         return PTR_ERR(ablkctx->aes_generic);
1266                 }
1267         } else
1268                 ablkctx->aes_generic = NULL;
1269
1270         tfm->crt_ablkcipher.reqsize =  sizeof(struct chcr_blkcipher_req_ctx);
1271         return chcr_device_init(crypto_tfm_ctx(tfm));
1272 }
1273
1274 static int chcr_rfc3686_init(struct crypto_tfm *tfm)
1275 {
1276         struct crypto_alg *alg = tfm->__crt_alg;
1277         struct chcr_context *ctx = crypto_tfm_ctx(tfm);
1278         struct ablk_ctx *ablkctx = ABLK_CTX(ctx);
1279
1280         /*RFC3686 initialises IV counter value to 1, rfc3686(ctr(aes))
1281          * cannot be used as fallback in chcr_handle_cipher_response
1282          */
1283         ablkctx->sw_cipher = crypto_alloc_skcipher("ctr(aes)", 0,
1284                                 CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK);
1285         if (IS_ERR(ablkctx->sw_cipher)) {
1286                 pr_err("failed to allocate fallback for %s\n", alg->cra_name);
1287                 return PTR_ERR(ablkctx->sw_cipher);
1288         }
1289         tfm->crt_ablkcipher.reqsize =  sizeof(struct chcr_blkcipher_req_ctx);
1290         return chcr_device_init(crypto_tfm_ctx(tfm));
1291 }
1292
1293
1294 static void chcr_cra_exit(struct crypto_tfm *tfm)
1295 {
1296         struct chcr_context *ctx = crypto_tfm_ctx(tfm);
1297         struct ablk_ctx *ablkctx = ABLK_CTX(ctx);
1298
1299         crypto_free_skcipher(ablkctx->sw_cipher);
1300         if (ablkctx->aes_generic)
1301                 crypto_free_cipher(ablkctx->aes_generic);
1302 }
1303
1304 static int get_alg_config(struct algo_param *params,
1305                           unsigned int auth_size)
1306 {
1307         switch (auth_size) {
1308         case SHA1_DIGEST_SIZE:
1309                 params->mk_size = CHCR_KEYCTX_MAC_KEY_SIZE_160;
1310                 params->auth_mode = CHCR_SCMD_AUTH_MODE_SHA1;
1311                 params->result_size = SHA1_DIGEST_SIZE;
1312                 break;
1313         case SHA224_DIGEST_SIZE:
1314                 params->mk_size = CHCR_KEYCTX_MAC_KEY_SIZE_256;
1315                 params->auth_mode = CHCR_SCMD_AUTH_MODE_SHA224;
1316                 params->result_size = SHA256_DIGEST_SIZE;
1317                 break;
1318         case SHA256_DIGEST_SIZE:
1319                 params->mk_size = CHCR_KEYCTX_MAC_KEY_SIZE_256;
1320                 params->auth_mode = CHCR_SCMD_AUTH_MODE_SHA256;
1321                 params->result_size = SHA256_DIGEST_SIZE;
1322                 break;
1323         case SHA384_DIGEST_SIZE:
1324                 params->mk_size = CHCR_KEYCTX_MAC_KEY_SIZE_512;
1325                 params->auth_mode = CHCR_SCMD_AUTH_MODE_SHA512_384;
1326                 params->result_size = SHA512_DIGEST_SIZE;
1327                 break;
1328         case SHA512_DIGEST_SIZE:
1329                 params->mk_size = CHCR_KEYCTX_MAC_KEY_SIZE_512;
1330                 params->auth_mode = CHCR_SCMD_AUTH_MODE_SHA512_512;
1331                 params->result_size = SHA512_DIGEST_SIZE;
1332                 break;
1333         default:
1334                 pr_err("chcr : ERROR, unsupported digest size\n");
1335                 return -EINVAL;
1336         }
1337         return 0;
1338 }
1339
1340 static inline void chcr_free_shash(struct crypto_shash *base_hash)
1341 {
1342                 crypto_free_shash(base_hash);
1343 }
1344
1345 /**
1346  *      create_hash_wr - Create hash work request
1347  *      @req - Cipher req base
1348  */
1349 static struct sk_buff *create_hash_wr(struct ahash_request *req,
1350                                       struct hash_wr_param *param)
1351 {
1352         struct chcr_ahash_req_ctx *req_ctx = ahash_request_ctx(req);
1353         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
1354         struct chcr_context *ctx = crypto_tfm_ctx(crypto_ahash_tfm(tfm));
1355         struct hmac_ctx *hmacctx = HMAC_CTX(ctx);
1356         struct sk_buff *skb = NULL;
1357         struct chcr_wr *chcr_req;
1358         unsigned int frags = 0, transhdr_len, iopad_alignment = 0;
1359         unsigned int digestsize = crypto_ahash_digestsize(tfm);
1360         unsigned int kctx_len = 0;
1361         u8 hash_size_in_response = 0;
1362         gfp_t flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL :
1363                 GFP_ATOMIC;
1364         struct adapter *adap = padap(ctx->dev);
1365
1366         iopad_alignment = KEYCTX_ALIGN_PAD(digestsize);
1367         kctx_len = param->alg_prm.result_size + iopad_alignment;
1368         if (param->opad_needed)
1369                 kctx_len += param->alg_prm.result_size + iopad_alignment;
1370
1371         if (req_ctx->result)
1372                 hash_size_in_response = digestsize;
1373         else
1374                 hash_size_in_response = param->alg_prm.result_size;
1375         transhdr_len = HASH_TRANSHDR_SIZE(kctx_len);
1376         skb = alloc_skb((transhdr_len + sizeof(struct sge_opaque_hdr)), flags);
1377         if (!skb)
1378                 return skb;
1379
1380         skb_reserve(skb, sizeof(struct sge_opaque_hdr));
1381         chcr_req = (struct chcr_wr *)__skb_put(skb, transhdr_len);
1382         memset(chcr_req, 0, transhdr_len);
1383
1384         chcr_req->sec_cpl.op_ivinsrtofst =
1385                 FILL_SEC_CPL_OP_IVINSR(ctx->dev->rx_channel_id, 2, 0);
1386         chcr_req->sec_cpl.pldlen = htonl(param->bfr_len + param->sg_len);
1387
1388         chcr_req->sec_cpl.aadstart_cipherstop_hi =
1389                 FILL_SEC_CPL_CIPHERSTOP_HI(0, 0, 0, 0);
1390         chcr_req->sec_cpl.cipherstop_lo_authinsert =
1391                 FILL_SEC_CPL_AUTHINSERT(0, 1, 0, 0);
1392         chcr_req->sec_cpl.seqno_numivs =
1393                 FILL_SEC_CPL_SCMD0_SEQNO(0, 0, 0, param->alg_prm.auth_mode,
1394                                          param->opad_needed, 0);
1395
1396         chcr_req->sec_cpl.ivgen_hdrlen =
1397                 FILL_SEC_CPL_IVGEN_HDRLEN(param->last, param->more, 0, 1, 0, 0);
1398
1399         memcpy(chcr_req->key_ctx.key, req_ctx->partial_hash,
1400                param->alg_prm.result_size);
1401
1402         if (param->opad_needed)
1403                 memcpy(chcr_req->key_ctx.key +
1404                        ((param->alg_prm.result_size <= 32) ? 32 :
1405                         CHCR_HASH_MAX_DIGEST_SIZE),
1406                        hmacctx->opad, param->alg_prm.result_size);
1407
1408         chcr_req->key_ctx.ctx_hdr = FILL_KEY_CTX_HDR(CHCR_KEYCTX_NO_KEY,
1409                                             param->alg_prm.mk_size, 0,
1410                                             param->opad_needed,
1411                                             ((kctx_len +
1412                                              sizeof(chcr_req->key_ctx)) >> 4));
1413         chcr_req->sec_cpl.scmd1 = cpu_to_be64((u64)param->scmd1);
1414
1415         skb_set_transport_header(skb, transhdr_len);
1416         if (param->bfr_len != 0)
1417                 write_buffer_to_skb(skb, &frags, req_ctx->reqbfr,
1418                                     param->bfr_len);
1419         if (param->sg_len != 0)
1420                 write_sg_to_skb(skb, &frags, req->src, param->sg_len);
1421         atomic_inc(&adap->chcr_stats.digest_rqst);
1422         create_wreq(ctx, chcr_req, &req->base, skb, kctx_len,
1423                     hash_size_in_response, 0, DUMMY_BYTES, 0);
1424         req_ctx->skb = skb;
1425         skb_get(skb);
1426         return skb;
1427 }
1428
1429 static int chcr_ahash_update(struct ahash_request *req)
1430 {
1431         struct chcr_ahash_req_ctx *req_ctx = ahash_request_ctx(req);
1432         struct crypto_ahash *rtfm = crypto_ahash_reqtfm(req);
1433         struct chcr_context *ctx = crypto_tfm_ctx(crypto_ahash_tfm(rtfm));
1434         struct uld_ctx *u_ctx = NULL;
1435         struct sk_buff *skb;
1436         u8 remainder = 0, bs;
1437         unsigned int nbytes = req->nbytes;
1438         struct hash_wr_param params;
1439
1440         bs = crypto_tfm_alg_blocksize(crypto_ahash_tfm(rtfm));
1441
1442         u_ctx = ULD_CTX(ctx);
1443         if (unlikely(cxgb4_is_crypto_q_full(u_ctx->lldi.ports[0],
1444                                             ctx->tx_qidx))) {
1445                 if (!(req->base.flags & CRYPTO_TFM_REQ_MAY_BACKLOG))
1446                         return -EBUSY;
1447         }
1448
1449         if (nbytes + req_ctx->reqlen >= bs) {
1450                 remainder = (nbytes + req_ctx->reqlen) % bs;
1451                 nbytes = nbytes + req_ctx->reqlen - remainder;
1452         } else {
1453                 sg_pcopy_to_buffer(req->src, sg_nents(req->src), req_ctx->reqbfr
1454                                    + req_ctx->reqlen, nbytes, 0);
1455                 req_ctx->reqlen += nbytes;
1456                 return 0;
1457         }
1458
1459         params.opad_needed = 0;
1460         params.more = 1;
1461         params.last = 0;
1462         params.sg_len = nbytes - req_ctx->reqlen;
1463         params.bfr_len = req_ctx->reqlen;
1464         params.scmd1 = 0;
1465         get_alg_config(&params.alg_prm, crypto_ahash_digestsize(rtfm));
1466         req_ctx->result = 0;
1467         req_ctx->data_len += params.sg_len + params.bfr_len;
1468         skb = create_hash_wr(req, &params);
1469         if (!skb)
1470                 return -ENOMEM;
1471
1472         if (remainder) {
1473                 u8 *temp;
1474                 /* Swap buffers */
1475                 temp = req_ctx->reqbfr;
1476                 req_ctx->reqbfr = req_ctx->skbfr;
1477                 req_ctx->skbfr = temp;
1478                 sg_pcopy_to_buffer(req->src, sg_nents(req->src),
1479                                    req_ctx->reqbfr, remainder, req->nbytes -
1480                                    remainder);
1481         }
1482         req_ctx->reqlen = remainder;
1483         skb->dev = u_ctx->lldi.ports[0];
1484         set_wr_txq(skb, CPL_PRIORITY_DATA, ctx->tx_qidx);
1485         chcr_send_wr(skb);
1486
1487         return -EINPROGRESS;
1488 }
1489
1490 static void create_last_hash_block(char *bfr_ptr, unsigned int bs, u64 scmd1)
1491 {
1492         memset(bfr_ptr, 0, bs);
1493         *bfr_ptr = 0x80;
1494         if (bs == 64)
1495                 *(__be64 *)(bfr_ptr + 56) = cpu_to_be64(scmd1  << 3);
1496         else
1497                 *(__be64 *)(bfr_ptr + 120) =  cpu_to_be64(scmd1  << 3);
1498 }
1499
1500 static int chcr_ahash_final(struct ahash_request *req)
1501 {
1502         struct chcr_ahash_req_ctx *req_ctx = ahash_request_ctx(req);
1503         struct crypto_ahash *rtfm = crypto_ahash_reqtfm(req);
1504         struct chcr_context *ctx = crypto_tfm_ctx(crypto_ahash_tfm(rtfm));
1505         struct hash_wr_param params;
1506         struct sk_buff *skb;
1507         struct uld_ctx *u_ctx = NULL;
1508         u8 bs = crypto_tfm_alg_blocksize(crypto_ahash_tfm(rtfm));
1509
1510         u_ctx = ULD_CTX(ctx);
1511         if (is_hmac(crypto_ahash_tfm(rtfm)))
1512                 params.opad_needed = 1;
1513         else
1514                 params.opad_needed = 0;
1515         params.sg_len = 0;
1516         get_alg_config(&params.alg_prm, crypto_ahash_digestsize(rtfm));
1517         req_ctx->result = 1;
1518         params.bfr_len = req_ctx->reqlen;
1519         req_ctx->data_len += params.bfr_len + params.sg_len;
1520         if (req_ctx->reqlen == 0) {
1521                 create_last_hash_block(req_ctx->reqbfr, bs, req_ctx->data_len);
1522                 params.last = 0;
1523                 params.more = 1;
1524                 params.scmd1 = 0;
1525                 params.bfr_len = bs;
1526
1527         } else {
1528                 params.scmd1 = req_ctx->data_len;
1529                 params.last = 1;
1530                 params.more = 0;
1531         }
1532         skb = create_hash_wr(req, &params);
1533         if (!skb)
1534                 return -ENOMEM;
1535
1536         skb->dev = u_ctx->lldi.ports[0];
1537         set_wr_txq(skb, CPL_PRIORITY_DATA, ctx->tx_qidx);
1538         chcr_send_wr(skb);
1539         return -EINPROGRESS;
1540 }
1541
1542 static int chcr_ahash_finup(struct ahash_request *req)
1543 {
1544         struct chcr_ahash_req_ctx *req_ctx = ahash_request_ctx(req);
1545         struct crypto_ahash *rtfm = crypto_ahash_reqtfm(req);
1546         struct chcr_context *ctx = crypto_tfm_ctx(crypto_ahash_tfm(rtfm));
1547         struct uld_ctx *u_ctx = NULL;
1548         struct sk_buff *skb;
1549         struct hash_wr_param params;
1550         u8  bs;
1551
1552         bs = crypto_tfm_alg_blocksize(crypto_ahash_tfm(rtfm));
1553         u_ctx = ULD_CTX(ctx);
1554
1555         if (unlikely(cxgb4_is_crypto_q_full(u_ctx->lldi.ports[0],
1556                                             ctx->tx_qidx))) {
1557                 if (!(req->base.flags & CRYPTO_TFM_REQ_MAY_BACKLOG))
1558                         return -EBUSY;
1559         }
1560
1561         if (is_hmac(crypto_ahash_tfm(rtfm)))
1562                 params.opad_needed = 1;
1563         else
1564                 params.opad_needed = 0;
1565
1566         params.sg_len = req->nbytes;
1567         params.bfr_len = req_ctx->reqlen;
1568         get_alg_config(&params.alg_prm, crypto_ahash_digestsize(rtfm));
1569         req_ctx->data_len += params.bfr_len + params.sg_len;
1570         req_ctx->result = 1;
1571         if ((req_ctx->reqlen + req->nbytes) == 0) {
1572                 create_last_hash_block(req_ctx->reqbfr, bs, req_ctx->data_len);
1573                 params.last = 0;
1574                 params.more = 1;
1575                 params.scmd1 = 0;
1576                 params.bfr_len = bs;
1577         } else {
1578                 params.scmd1 = req_ctx->data_len;
1579                 params.last = 1;
1580                 params.more = 0;
1581         }
1582
1583         skb = create_hash_wr(req, &params);
1584         if (!skb)
1585                 return -ENOMEM;
1586
1587         skb->dev = u_ctx->lldi.ports[0];
1588         set_wr_txq(skb, CPL_PRIORITY_DATA, ctx->tx_qidx);
1589         chcr_send_wr(skb);
1590
1591         return -EINPROGRESS;
1592 }
1593
1594 static int chcr_ahash_digest(struct ahash_request *req)
1595 {
1596         struct chcr_ahash_req_ctx *req_ctx = ahash_request_ctx(req);
1597         struct crypto_ahash *rtfm = crypto_ahash_reqtfm(req);
1598         struct chcr_context *ctx = crypto_tfm_ctx(crypto_ahash_tfm(rtfm));
1599         struct uld_ctx *u_ctx = NULL;
1600         struct sk_buff *skb;
1601         struct hash_wr_param params;
1602         u8  bs;
1603
1604         rtfm->init(req);
1605         bs = crypto_tfm_alg_blocksize(crypto_ahash_tfm(rtfm));
1606
1607         u_ctx = ULD_CTX(ctx);
1608         if (unlikely(cxgb4_is_crypto_q_full(u_ctx->lldi.ports[0],
1609                                             ctx->tx_qidx))) {
1610                 if (!(req->base.flags & CRYPTO_TFM_REQ_MAY_BACKLOG))
1611                         return -EBUSY;
1612         }
1613
1614         if (is_hmac(crypto_ahash_tfm(rtfm)))
1615                 params.opad_needed = 1;
1616         else
1617                 params.opad_needed = 0;
1618
1619         params.last = 0;
1620         params.more = 0;
1621         params.sg_len = req->nbytes;
1622         params.bfr_len = 0;
1623         params.scmd1 = 0;
1624         get_alg_config(&params.alg_prm, crypto_ahash_digestsize(rtfm));
1625         req_ctx->result = 1;
1626         req_ctx->data_len += params.bfr_len + params.sg_len;
1627
1628         if (req->nbytes == 0) {
1629                 create_last_hash_block(req_ctx->reqbfr, bs, 0);
1630                 params.more = 1;
1631                 params.bfr_len = bs;
1632         }
1633
1634         skb = create_hash_wr(req, &params);
1635         if (!skb)
1636                 return -ENOMEM;
1637
1638         skb->dev = u_ctx->lldi.ports[0];
1639         set_wr_txq(skb, CPL_PRIORITY_DATA, ctx->tx_qidx);
1640         chcr_send_wr(skb);
1641         return -EINPROGRESS;
1642 }
1643
1644 static int chcr_ahash_export(struct ahash_request *areq, void *out)
1645 {
1646         struct chcr_ahash_req_ctx *req_ctx = ahash_request_ctx(areq);
1647         struct chcr_ahash_req_ctx *state = out;
1648
1649         state->reqlen = req_ctx->reqlen;
1650         state->data_len = req_ctx->data_len;
1651         memcpy(state->bfr1, req_ctx->reqbfr, req_ctx->reqlen);
1652         memcpy(state->partial_hash, req_ctx->partial_hash,
1653                CHCR_HASH_MAX_DIGEST_SIZE);
1654                 return 0;
1655 }
1656
1657 static int chcr_ahash_import(struct ahash_request *areq, const void *in)
1658 {
1659         struct chcr_ahash_req_ctx *req_ctx = ahash_request_ctx(areq);
1660         struct chcr_ahash_req_ctx *state = (struct chcr_ahash_req_ctx *)in;
1661
1662         req_ctx->reqlen = state->reqlen;
1663         req_ctx->data_len = state->data_len;
1664         req_ctx->reqbfr = req_ctx->bfr1;
1665         req_ctx->skbfr = req_ctx->bfr2;
1666         memcpy(req_ctx->bfr1, state->bfr1, CHCR_HASH_MAX_BLOCK_SIZE_128);
1667         memcpy(req_ctx->partial_hash, state->partial_hash,
1668                CHCR_HASH_MAX_DIGEST_SIZE);
1669         return 0;
1670 }
1671
1672 static int chcr_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,
1673                              unsigned int keylen)
1674 {
1675         struct chcr_context *ctx = crypto_tfm_ctx(crypto_ahash_tfm(tfm));
1676         struct hmac_ctx *hmacctx = HMAC_CTX(ctx);
1677         unsigned int digestsize = crypto_ahash_digestsize(tfm);
1678         unsigned int bs = crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm));
1679         unsigned int i, err = 0, updated_digestsize;
1680
1681         SHASH_DESC_ON_STACK(shash, hmacctx->base_hash);
1682
1683         /* use the key to calculate the ipad and opad. ipad will sent with the
1684          * first request's data. opad will be sent with the final hash result
1685          * ipad in hmacctx->ipad and opad in hmacctx->opad location
1686          */
1687         shash->tfm = hmacctx->base_hash;
1688         shash->flags = crypto_shash_get_flags(hmacctx->base_hash);
1689         if (keylen > bs) {
1690                 err = crypto_shash_digest(shash, key, keylen,
1691                                           hmacctx->ipad);
1692                 if (err)
1693                         goto out;
1694                 keylen = digestsize;
1695         } else {
1696                 memcpy(hmacctx->ipad, key, keylen);
1697         }
1698         memset(hmacctx->ipad + keylen, 0, bs - keylen);
1699         memcpy(hmacctx->opad, hmacctx->ipad, bs);
1700
1701         for (i = 0; i < bs / sizeof(int); i++) {
1702                 *((unsigned int *)(&hmacctx->ipad) + i) ^= IPAD_DATA;
1703                 *((unsigned int *)(&hmacctx->opad) + i) ^= OPAD_DATA;
1704         }
1705
1706         updated_digestsize = digestsize;
1707         if (digestsize == SHA224_DIGEST_SIZE)
1708                 updated_digestsize = SHA256_DIGEST_SIZE;
1709         else if (digestsize == SHA384_DIGEST_SIZE)
1710                 updated_digestsize = SHA512_DIGEST_SIZE;
1711         err = chcr_compute_partial_hash(shash, hmacctx->ipad,
1712                                         hmacctx->ipad, digestsize);
1713         if (err)
1714                 goto out;
1715         chcr_change_order(hmacctx->ipad, updated_digestsize);
1716
1717         err = chcr_compute_partial_hash(shash, hmacctx->opad,
1718                                         hmacctx->opad, digestsize);
1719         if (err)
1720                 goto out;
1721         chcr_change_order(hmacctx->opad, updated_digestsize);
1722 out:
1723         return err;
1724 }
1725
1726 static int chcr_aes_xts_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
1727                                unsigned int key_len)
1728 {
1729         struct chcr_context *ctx = crypto_ablkcipher_ctx(cipher);
1730         struct ablk_ctx *ablkctx = ABLK_CTX(ctx);
1731         unsigned short context_size = 0;
1732         int err;
1733
1734         err = chcr_cipher_fallback_setkey(cipher, key, key_len);
1735         if (err)
1736                 goto badkey_err;
1737
1738         memcpy(ablkctx->key, key, key_len);
1739         ablkctx->enckey_len = key_len;
1740         get_aes_decrypt_key(ablkctx->rrkey, ablkctx->key, key_len << 2);
1741         context_size = (KEY_CONTEXT_HDR_SALT_AND_PAD + key_len) >> 4;
1742         ablkctx->key_ctx_hdr =
1743                 FILL_KEY_CTX_HDR((key_len == AES_KEYSIZE_256) ?
1744                                  CHCR_KEYCTX_CIPHER_KEY_SIZE_128 :
1745                                  CHCR_KEYCTX_CIPHER_KEY_SIZE_256,
1746                                  CHCR_KEYCTX_NO_KEY, 1,
1747                                  0, context_size);
1748         ablkctx->ciph_mode = CHCR_SCMD_CIPHER_MODE_AES_XTS;
1749         return 0;
1750 badkey_err:
1751         crypto_ablkcipher_set_flags(cipher, CRYPTO_TFM_RES_BAD_KEY_LEN);
1752         ablkctx->enckey_len = 0;
1753
1754         return err;
1755 }
1756
1757 static int chcr_sha_init(struct ahash_request *areq)
1758 {
1759         struct chcr_ahash_req_ctx *req_ctx = ahash_request_ctx(areq);
1760         struct crypto_ahash *tfm = crypto_ahash_reqtfm(areq);
1761         int digestsize =  crypto_ahash_digestsize(tfm);
1762
1763         req_ctx->data_len = 0;
1764         req_ctx->reqlen = 0;
1765         req_ctx->reqbfr = req_ctx->bfr1;
1766         req_ctx->skbfr = req_ctx->bfr2;
1767         req_ctx->skb = NULL;
1768         req_ctx->result = 0;
1769         copy_hash_init_values(req_ctx->partial_hash, digestsize);
1770         return 0;
1771 }
1772
1773 static int chcr_sha_cra_init(struct crypto_tfm *tfm)
1774 {
1775         crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
1776                                  sizeof(struct chcr_ahash_req_ctx));
1777         return chcr_device_init(crypto_tfm_ctx(tfm));
1778 }
1779
1780 static int chcr_hmac_init(struct ahash_request *areq)
1781 {
1782         struct chcr_ahash_req_ctx *req_ctx = ahash_request_ctx(areq);
1783         struct crypto_ahash *rtfm = crypto_ahash_reqtfm(areq);
1784         struct chcr_context *ctx = crypto_tfm_ctx(crypto_ahash_tfm(rtfm));
1785         struct hmac_ctx *hmacctx = HMAC_CTX(ctx);
1786         unsigned int digestsize = crypto_ahash_digestsize(rtfm);
1787         unsigned int bs = crypto_tfm_alg_blocksize(crypto_ahash_tfm(rtfm));
1788
1789         chcr_sha_init(areq);
1790         req_ctx->data_len = bs;
1791         if (is_hmac(crypto_ahash_tfm(rtfm))) {
1792                 if (digestsize == SHA224_DIGEST_SIZE)
1793                         memcpy(req_ctx->partial_hash, hmacctx->ipad,
1794                                SHA256_DIGEST_SIZE);
1795                 else if (digestsize == SHA384_DIGEST_SIZE)
1796                         memcpy(req_ctx->partial_hash, hmacctx->ipad,
1797                                SHA512_DIGEST_SIZE);
1798                 else
1799                         memcpy(req_ctx->partial_hash, hmacctx->ipad,
1800                                digestsize);
1801         }
1802         return 0;
1803 }
1804
1805 static int chcr_hmac_cra_init(struct crypto_tfm *tfm)
1806 {
1807         struct chcr_context *ctx = crypto_tfm_ctx(tfm);
1808         struct hmac_ctx *hmacctx = HMAC_CTX(ctx);
1809         unsigned int digestsize =
1810                 crypto_ahash_digestsize(__crypto_ahash_cast(tfm));
1811
1812         crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm),
1813                                  sizeof(struct chcr_ahash_req_ctx));
1814         hmacctx->base_hash = chcr_alloc_shash(digestsize);
1815         if (IS_ERR(hmacctx->base_hash))
1816                 return PTR_ERR(hmacctx->base_hash);
1817         return chcr_device_init(crypto_tfm_ctx(tfm));
1818 }
1819
1820 static void chcr_hmac_cra_exit(struct crypto_tfm *tfm)
1821 {
1822         struct chcr_context *ctx = crypto_tfm_ctx(tfm);
1823         struct hmac_ctx *hmacctx = HMAC_CTX(ctx);
1824
1825         if (hmacctx->base_hash) {
1826                 chcr_free_shash(hmacctx->base_hash);
1827                 hmacctx->base_hash = NULL;
1828         }
1829 }
1830
1831 static int is_newsg(struct scatterlist *sgl, unsigned int *newents)
1832 {
1833         int nents = 0;
1834         int ret = 0;
1835
1836         while (sgl) {
1837                 if (sgl->length > CHCR_SG_SIZE)
1838                         ret = 1;
1839                 nents += DIV_ROUND_UP(sgl->length, CHCR_SG_SIZE);
1840                 sgl = sg_next(sgl);
1841         }
1842         *newents = nents;
1843         return ret;
1844 }
1845
1846 static inline void free_new_sg(struct scatterlist *sgl)
1847 {
1848         kfree(sgl);
1849 }
1850
1851 static struct scatterlist *alloc_new_sg(struct scatterlist *sgl,
1852                                        unsigned int nents)
1853 {
1854         struct scatterlist *newsg, *sg;
1855         int i, len, processed = 0;
1856         struct page *spage;
1857         int offset;
1858
1859         newsg = kmalloc_array(nents, sizeof(struct scatterlist), GFP_KERNEL);
1860         if (!newsg)
1861                 return ERR_PTR(-ENOMEM);
1862         sg = newsg;
1863         sg_init_table(sg, nents);
1864         offset = sgl->offset;
1865         spage = sg_page(sgl);
1866         for (i = 0; i < nents; i++) {
1867                 len = min_t(u32, sgl->length - processed, CHCR_SG_SIZE);
1868                 sg_set_page(sg, spage, len, offset);
1869                 processed += len;
1870                 offset += len;
1871                 if (offset >= PAGE_SIZE) {
1872                         offset = offset % PAGE_SIZE;
1873                         spage++;
1874                 }
1875                 if (processed == sgl->length) {
1876                         processed = 0;
1877                         sgl = sg_next(sgl);
1878                         if (!sgl)
1879                                 break;
1880                         spage = sg_page(sgl);
1881                         offset = sgl->offset;
1882                 }
1883                 sg = sg_next(sg);
1884         }
1885         return newsg;
1886 }
1887
1888 static int chcr_copy_assoc(struct aead_request *req,
1889                                 struct chcr_aead_ctx *ctx)
1890 {
1891         SKCIPHER_REQUEST_ON_STACK(skreq, ctx->null);
1892
1893         skcipher_request_set_tfm(skreq, ctx->null);
1894         skcipher_request_set_callback(skreq, aead_request_flags(req),
1895                         NULL, NULL);
1896         skcipher_request_set_crypt(skreq, req->src, req->dst, req->assoclen,
1897                         NULL);
1898
1899         return crypto_skcipher_encrypt(skreq);
1900 }
1901 static int chcr_aead_need_fallback(struct aead_request *req, int src_nent,
1902                                    int aadmax, int wrlen,
1903                                    unsigned short op_type)
1904 {
1905         unsigned int authsize = crypto_aead_authsize(crypto_aead_reqtfm(req));
1906
1907         if (((req->cryptlen - (op_type ? authsize : 0)) == 0) ||
1908             (req->assoclen > aadmax) ||
1909             (src_nent > MAX_SKB_FRAGS) ||
1910             (wrlen > MAX_WR_SIZE))
1911                 return 1;
1912         return 0;
1913 }
1914
1915 static int chcr_aead_fallback(struct aead_request *req, unsigned short op_type)
1916 {
1917         struct crypto_aead *tfm = crypto_aead_reqtfm(req);
1918         struct chcr_context *ctx = crypto_aead_ctx(tfm);
1919         struct chcr_aead_ctx *aeadctx = AEAD_CTX(ctx);
1920         struct aead_request *subreq = aead_request_ctx(req);
1921
1922         aead_request_set_tfm(subreq, aeadctx->sw_cipher);
1923         aead_request_set_callback(subreq, req->base.flags,
1924                                   req->base.complete, req->base.data);
1925          aead_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,
1926                                  req->iv);
1927          aead_request_set_ad(subreq, req->assoclen);
1928         return op_type ? crypto_aead_decrypt(subreq) :
1929                 crypto_aead_encrypt(subreq);
1930 }
1931
1932 static struct sk_buff *create_authenc_wr(struct aead_request *req,
1933                                          unsigned short qid,
1934                                          int size,
1935                                          unsigned short op_type)
1936 {
1937         struct crypto_aead *tfm = crypto_aead_reqtfm(req);
1938         struct chcr_context *ctx = crypto_aead_ctx(tfm);
1939         struct uld_ctx *u_ctx = ULD_CTX(ctx);
1940         struct chcr_aead_ctx *aeadctx = AEAD_CTX(ctx);
1941         struct chcr_authenc_ctx *actx = AUTHENC_CTX(aeadctx);
1942         struct chcr_aead_reqctx *reqctx = aead_request_ctx(req);
1943         struct sk_buff *skb = NULL;
1944         struct chcr_wr *chcr_req;
1945         struct cpl_rx_phys_dsgl *phys_cpl;
1946         struct phys_sge_parm sg_param;
1947         struct scatterlist *src;
1948         unsigned int frags = 0, transhdr_len;
1949         unsigned int ivsize = crypto_aead_ivsize(tfm), dst_size = 0;
1950         unsigned int   kctx_len = 0, nents;
1951         unsigned short stop_offset = 0;
1952         unsigned int  assoclen = req->assoclen;
1953         unsigned int  authsize = crypto_aead_authsize(tfm);
1954         int error = -EINVAL, src_nent;
1955         int null = 0;
1956         gfp_t flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL :
1957                 GFP_ATOMIC;
1958         struct adapter *adap = padap(ctx->dev);
1959
1960         reqctx->newdstsg = NULL;
1961         dst_size = req->assoclen + req->cryptlen + (op_type ? -authsize :
1962                                                    authsize);
1963         if (aeadctx->enckey_len == 0 || (req->cryptlen <= 0))
1964                 goto err;
1965
1966         if (op_type && req->cryptlen < crypto_aead_authsize(tfm))
1967                 goto err;
1968         src_nent = sg_nents_for_len(req->src, req->assoclen + req->cryptlen);
1969         if (src_nent < 0)
1970                 goto err;
1971         src = scatterwalk_ffwd(reqctx->srcffwd, req->src, req->assoclen);
1972
1973         if (req->src != req->dst) {
1974                 error = chcr_copy_assoc(req, aeadctx);
1975                 if (error)
1976                         return ERR_PTR(error);
1977         }
1978         if (dst_size && is_newsg(req->dst, &nents)) {
1979                 reqctx->newdstsg = alloc_new_sg(req->dst, nents);
1980                 if (IS_ERR(reqctx->newdstsg))
1981                         return ERR_CAST(reqctx->newdstsg);
1982                 reqctx->dst = scatterwalk_ffwd(reqctx->dstffwd,
1983                                                reqctx->newdstsg, req->assoclen);
1984         } else {
1985                 if (req->src == req->dst)
1986                         reqctx->dst = src;
1987                 else
1988                         reqctx->dst = scatterwalk_ffwd(reqctx->dstffwd,
1989                                                        req->dst, req->assoclen);
1990         }
1991         if (get_aead_subtype(tfm) == CRYPTO_ALG_SUB_TYPE_AEAD_NULL) {
1992                 null = 1;
1993                 assoclen = 0;
1994         }
1995         reqctx->dst_nents = sg_nents_for_len(reqctx->dst, req->cryptlen +
1996                                              (op_type ? -authsize : authsize));
1997         if (reqctx->dst_nents < 0) {
1998                 pr_err("AUTHENC:Invalid Destination sg entries\n");
1999                 error = -EINVAL;
2000                 goto err;
2001         }
2002         dst_size = get_space_for_phys_dsgl(reqctx->dst_nents);
2003         kctx_len = (ntohl(KEY_CONTEXT_CTX_LEN_V(aeadctx->key_ctx_hdr)) << 4)
2004                 - sizeof(chcr_req->key_ctx);
2005         transhdr_len = CIPHER_TRANSHDR_SIZE(kctx_len, dst_size);
2006         if (chcr_aead_need_fallback(req, src_nent + MIN_AUTH_SG,
2007                         T6_MAX_AAD_SIZE,
2008                         transhdr_len + (sgl_len(src_nent + MIN_AUTH_SG) * 8),
2009                                 op_type)) {
2010                 atomic_inc(&adap->chcr_stats.fallback);
2011                 free_new_sg(reqctx->newdstsg);
2012                 reqctx->newdstsg = NULL;
2013                 return ERR_PTR(chcr_aead_fallback(req, op_type));
2014         }
2015         skb = alloc_skb((transhdr_len + sizeof(struct sge_opaque_hdr)), flags);
2016         if (!skb) {
2017                 error = -ENOMEM;
2018                 goto err;
2019         }
2020
2021         /* LLD is going to write the sge hdr. */
2022         skb_reserve(skb, sizeof(struct sge_opaque_hdr));
2023
2024         /* Write WR */
2025         chcr_req = (struct chcr_wr *) __skb_put(skb, transhdr_len);
2026         memset(chcr_req, 0, transhdr_len);
2027
2028         stop_offset = (op_type == CHCR_ENCRYPT_OP) ? 0 : authsize;
2029
2030         /*
2031          * Input order  is AAD,IV and Payload. where IV should be included as
2032          * the part of authdata. All other fields should be filled according
2033          * to the hardware spec
2034          */
2035         chcr_req->sec_cpl.op_ivinsrtofst =
2036                 FILL_SEC_CPL_OP_IVINSR(ctx->dev->rx_channel_id, 2,
2037                                        (ivsize ? (assoclen + 1) : 0));
2038         chcr_req->sec_cpl.pldlen = htonl(assoclen + ivsize + req->cryptlen);
2039         chcr_req->sec_cpl.aadstart_cipherstop_hi = FILL_SEC_CPL_CIPHERSTOP_HI(
2040                                         assoclen ? 1 : 0, assoclen,
2041                                         assoclen + ivsize + 1,
2042                                         (stop_offset & 0x1F0) >> 4);
2043         chcr_req->sec_cpl.cipherstop_lo_authinsert = FILL_SEC_CPL_AUTHINSERT(
2044                                         stop_offset & 0xF,
2045                                         null ? 0 : assoclen + ivsize + 1,
2046                                         stop_offset, stop_offset);
2047         chcr_req->sec_cpl.seqno_numivs = FILL_SEC_CPL_SCMD0_SEQNO(op_type,
2048                                         (op_type == CHCR_ENCRYPT_OP) ? 1 : 0,
2049                                         CHCR_SCMD_CIPHER_MODE_AES_CBC,
2050                                         actx->auth_mode, aeadctx->hmac_ctrl,
2051                                         ivsize >> 1);
2052         chcr_req->sec_cpl.ivgen_hdrlen =  FILL_SEC_CPL_IVGEN_HDRLEN(0, 0, 1,
2053                                          0, 1, dst_size);
2054
2055         chcr_req->key_ctx.ctx_hdr = aeadctx->key_ctx_hdr;
2056         if (op_type == CHCR_ENCRYPT_OP)
2057                 memcpy(chcr_req->key_ctx.key, aeadctx->key,
2058                        aeadctx->enckey_len);
2059         else
2060                 memcpy(chcr_req->key_ctx.key, actx->dec_rrkey,
2061                        aeadctx->enckey_len);
2062
2063         memcpy(chcr_req->key_ctx.key + (DIV_ROUND_UP(aeadctx->enckey_len, 16) <<
2064                                         4), actx->h_iopad, kctx_len -
2065                                 (DIV_ROUND_UP(aeadctx->enckey_len, 16) << 4));
2066
2067         phys_cpl = (struct cpl_rx_phys_dsgl *)((u8 *)(chcr_req + 1) + kctx_len);
2068         sg_param.nents = reqctx->dst_nents;
2069         sg_param.obsize = req->cryptlen + (op_type ? -authsize : authsize);
2070         sg_param.qid = qid;
2071         error = map_writesg_phys_cpl(&u_ctx->lldi.pdev->dev, phys_cpl,
2072                                         reqctx->dst, &sg_param);
2073         if (error)
2074                 goto dstmap_fail;
2075
2076         skb_set_transport_header(skb, transhdr_len);
2077
2078         if (assoclen) {
2079                 /* AAD buffer in */
2080                 write_sg_to_skb(skb, &frags, req->src, assoclen);
2081
2082         }
2083         write_buffer_to_skb(skb, &frags, req->iv, ivsize);
2084         write_sg_to_skb(skb, &frags, src, req->cryptlen);
2085         atomic_inc(&adap->chcr_stats.cipher_rqst);
2086         create_wreq(ctx, chcr_req, &req->base, skb, kctx_len, size, 1,
2087                    sizeof(struct cpl_rx_phys_dsgl) + dst_size, 0);
2088         reqctx->skb = skb;
2089         skb_get(skb);
2090
2091         return skb;
2092 dstmap_fail:
2093         /* ivmap_fail: */
2094         kfree_skb(skb);
2095 err:
2096         free_new_sg(reqctx->newdstsg);
2097         reqctx->newdstsg = NULL;
2098         return ERR_PTR(error);
2099 }
2100
2101 static int set_msg_len(u8 *block, unsigned int msglen, int csize)
2102 {
2103         __be32 data;
2104
2105         memset(block, 0, csize);
2106         block += csize;
2107
2108         if (csize >= 4)
2109                 csize = 4;
2110         else if (msglen > (unsigned int)(1 << (8 * csize)))
2111                 return -EOVERFLOW;
2112
2113         data = cpu_to_be32(msglen);
2114         memcpy(block - csize, (u8 *)&data + 4 - csize, csize);
2115
2116         return 0;
2117 }
2118
2119 static void generate_b0(struct aead_request *req,
2120                         struct chcr_aead_ctx *aeadctx,
2121                         unsigned short op_type)
2122 {
2123         unsigned int l, lp, m;
2124         int rc;
2125         struct crypto_aead *aead = crypto_aead_reqtfm(req);
2126         struct chcr_aead_reqctx *reqctx = aead_request_ctx(req);
2127         u8 *b0 = reqctx->scratch_pad;
2128
2129         m = crypto_aead_authsize(aead);
2130
2131         memcpy(b0, reqctx->iv, 16);
2132
2133         lp = b0[0];
2134         l = lp + 1;
2135
2136         /* set m, bits 3-5 */
2137         *b0 |= (8 * ((m - 2) / 2));
2138
2139         /* set adata, bit 6, if associated data is used */
2140         if (req->assoclen)
2141                 *b0 |= 64;
2142         rc = set_msg_len(b0 + 16 - l,
2143                          (op_type == CHCR_DECRYPT_OP) ?
2144                          req->cryptlen - m : req->cryptlen, l);
2145 }
2146
2147 static inline int crypto_ccm_check_iv(const u8 *iv)
2148 {
2149         /* 2 <= L <= 8, so 1 <= L' <= 7. */
2150         if (iv[0] < 1 || iv[0] > 7)
2151                 return -EINVAL;
2152
2153         return 0;
2154 }
2155
2156 static int ccm_format_packet(struct aead_request *req,
2157                              struct chcr_aead_ctx *aeadctx,
2158                              unsigned int sub_type,
2159                              unsigned short op_type)
2160 {
2161         struct chcr_aead_reqctx *reqctx = aead_request_ctx(req);
2162         int rc = 0;
2163
2164         if (sub_type == CRYPTO_ALG_SUB_TYPE_AEAD_RFC4309) {
2165                 reqctx->iv[0] = 3;
2166                 memcpy(reqctx->iv + 1, &aeadctx->salt[0], 3);
2167                 memcpy(reqctx->iv + 4, req->iv, 8);
2168                 memset(reqctx->iv + 12, 0, 4);
2169                 *((unsigned short *)(reqctx->scratch_pad + 16)) =
2170                         htons(req->assoclen - 8);
2171         } else {
2172                 memcpy(reqctx->iv, req->iv, 16);
2173                 *((unsigned short *)(reqctx->scratch_pad + 16)) =
2174                         htons(req->assoclen);
2175         }
2176         generate_b0(req, aeadctx, op_type);
2177         /* zero the ctr value */
2178         memset(reqctx->iv + 15 - reqctx->iv[0], 0, reqctx->iv[0] + 1);
2179         return rc;
2180 }
2181
2182 static void fill_sec_cpl_for_aead(struct cpl_tx_sec_pdu *sec_cpl,
2183                                   unsigned int dst_size,
2184                                   struct aead_request *req,
2185                                   unsigned short op_type,
2186                                           struct chcr_context *chcrctx)
2187 {
2188         struct crypto_aead *tfm = crypto_aead_reqtfm(req);
2189         struct chcr_aead_ctx *aeadctx = AEAD_CTX(crypto_aead_ctx(tfm));
2190         unsigned int ivsize = AES_BLOCK_SIZE;
2191         unsigned int cipher_mode = CHCR_SCMD_CIPHER_MODE_AES_CCM;
2192         unsigned int mac_mode = CHCR_SCMD_AUTH_MODE_CBCMAC;
2193         unsigned int c_id = chcrctx->dev->rx_channel_id;
2194         unsigned int ccm_xtra;
2195         unsigned char tag_offset = 0, auth_offset = 0;
2196         unsigned int assoclen;
2197
2198         if (get_aead_subtype(tfm) == CRYPTO_ALG_SUB_TYPE_AEAD_RFC4309)
2199                 assoclen = req->assoclen - 8;
2200         else
2201                 assoclen = req->assoclen;
2202         ccm_xtra = CCM_B0_SIZE +
2203                 ((assoclen) ? CCM_AAD_FIELD_SIZE : 0);
2204
2205         auth_offset = req->cryptlen ?
2206                 (assoclen + ivsize + 1 + ccm_xtra) : 0;
2207         if (op_type == CHCR_DECRYPT_OP) {
2208                 if (crypto_aead_authsize(tfm) != req->cryptlen)
2209                         tag_offset = crypto_aead_authsize(tfm);
2210                 else
2211                         auth_offset = 0;
2212         }
2213
2214
2215         sec_cpl->op_ivinsrtofst = FILL_SEC_CPL_OP_IVINSR(c_id,
2216                                          2, (ivsize ?  (assoclen + 1) :  0) +
2217                                          ccm_xtra);
2218         sec_cpl->pldlen =
2219                 htonl(assoclen + ivsize + req->cryptlen + ccm_xtra);
2220         /* For CCM there wil be b0 always. So AAD start will be 1 always */
2221         sec_cpl->aadstart_cipherstop_hi = FILL_SEC_CPL_CIPHERSTOP_HI(
2222                                         1, assoclen + ccm_xtra, assoclen
2223                                         + ivsize + 1 + ccm_xtra, 0);
2224
2225         sec_cpl->cipherstop_lo_authinsert = FILL_SEC_CPL_AUTHINSERT(0,
2226                                         auth_offset, tag_offset,
2227                                         (op_type == CHCR_ENCRYPT_OP) ? 0 :
2228                                         crypto_aead_authsize(tfm));
2229         sec_cpl->seqno_numivs =  FILL_SEC_CPL_SCMD0_SEQNO(op_type,
2230                                         (op_type == CHCR_ENCRYPT_OP) ? 0 : 1,
2231                                         cipher_mode, mac_mode,
2232                                         aeadctx->hmac_ctrl, ivsize >> 1);
2233
2234         sec_cpl->ivgen_hdrlen = FILL_SEC_CPL_IVGEN_HDRLEN(0, 0, 1, 0,
2235                                         1, dst_size);
2236 }
2237
2238 int aead_ccm_validate_input(unsigned short op_type,
2239                             struct aead_request *req,
2240                             struct chcr_aead_ctx *aeadctx,
2241                             unsigned int sub_type)
2242 {
2243         if (sub_type != CRYPTO_ALG_SUB_TYPE_AEAD_RFC4309) {
2244                 if (crypto_ccm_check_iv(req->iv)) {
2245                         pr_err("CCM: IV check fails\n");
2246                         return -EINVAL;
2247                 }
2248         } else {
2249                 if (req->assoclen != 16 && req->assoclen != 20) {
2250                         pr_err("RFC4309: Invalid AAD length %d\n",
2251                                req->assoclen);
2252                         return -EINVAL;
2253                 }
2254         }
2255         if (aeadctx->enckey_len == 0) {
2256                 pr_err("CCM: Encryption key not set\n");
2257                 return -EINVAL;
2258         }
2259         return 0;
2260 }
2261
2262 unsigned int fill_aead_req_fields(struct sk_buff *skb,
2263                                   struct aead_request *req,
2264                                   struct scatterlist *src,
2265                                   unsigned int ivsize,
2266                                   struct chcr_aead_ctx *aeadctx)
2267 {
2268         unsigned int frags = 0;
2269         struct crypto_aead *tfm = crypto_aead_reqtfm(req);
2270         struct chcr_aead_reqctx *reqctx = aead_request_ctx(req);
2271         /* b0 and aad length(if available) */
2272
2273         write_buffer_to_skb(skb, &frags, reqctx->scratch_pad, CCM_B0_SIZE +
2274                                 (req->assoclen ?  CCM_AAD_FIELD_SIZE : 0));
2275         if (req->assoclen) {
2276                 if (get_aead_subtype(tfm) == CRYPTO_ALG_SUB_TYPE_AEAD_RFC4309)
2277                         write_sg_to_skb(skb, &frags, req->src,
2278                                         req->assoclen - 8);
2279                 else
2280                         write_sg_to_skb(skb, &frags, req->src, req->assoclen);
2281         }
2282         write_buffer_to_skb(skb, &frags, reqctx->iv, ivsize);
2283         if (req->cryptlen)
2284                 write_sg_to_skb(skb, &frags, src, req->cryptlen);
2285
2286         return frags;
2287 }
2288
2289 static struct sk_buff *create_aead_ccm_wr(struct aead_request *req,
2290                                           unsigned short qid,
2291                                           int size,
2292                                           unsigned short op_type)
2293 {
2294         struct crypto_aead *tfm = crypto_aead_reqtfm(req);
2295         struct chcr_context *ctx = crypto_aead_ctx(tfm);
2296         struct uld_ctx *u_ctx = ULD_CTX(ctx);
2297         struct chcr_aead_ctx *aeadctx = AEAD_CTX(ctx);
2298         struct chcr_aead_reqctx *reqctx = aead_request_ctx(req);
2299         struct sk_buff *skb = NULL;
2300         struct chcr_wr *chcr_req;
2301         struct cpl_rx_phys_dsgl *phys_cpl;
2302         struct phys_sge_parm sg_param;
2303         struct scatterlist *src;
2304         unsigned int frags = 0, transhdr_len, ivsize = AES_BLOCK_SIZE;
2305         unsigned int dst_size = 0, kctx_len, nents;
2306         unsigned int sub_type;
2307         unsigned int authsize = crypto_aead_authsize(tfm);
2308         int error = -EINVAL, src_nent;
2309         gfp_t flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL :
2310                 GFP_ATOMIC;
2311         struct adapter *adap = padap(ctx->dev);
2312
2313         dst_size = req->assoclen + req->cryptlen + (op_type ? -authsize :
2314                                                    authsize);
2315         reqctx->newdstsg = NULL;
2316         if (op_type && req->cryptlen < crypto_aead_authsize(tfm))
2317                 goto err;
2318         src_nent = sg_nents_for_len(req->src, req->assoclen + req->cryptlen);
2319         if (src_nent < 0)
2320                 goto err;
2321
2322         sub_type = get_aead_subtype(tfm);
2323         src = scatterwalk_ffwd(reqctx->srcffwd, req->src, req->assoclen);
2324         if (req->src != req->dst) {
2325                 error = chcr_copy_assoc(req, aeadctx);
2326                 if (error) {
2327                         pr_err("AAD copy to destination buffer fails\n");
2328                         return ERR_PTR(error);
2329                 }
2330         }
2331         if (dst_size && is_newsg(req->dst, &nents)) {
2332                 reqctx->newdstsg = alloc_new_sg(req->dst, nents);
2333                 if (IS_ERR(reqctx->newdstsg))
2334                         return ERR_CAST(reqctx->newdstsg);
2335                 reqctx->dst = scatterwalk_ffwd(reqctx->dstffwd,
2336                                                reqctx->newdstsg, req->assoclen);
2337         } else {
2338                 if (req->src == req->dst)
2339                         reqctx->dst = src;
2340                 else
2341                         reqctx->dst = scatterwalk_ffwd(reqctx->dstffwd,
2342                                                        req->dst, req->assoclen);
2343         }
2344         reqctx->dst_nents = sg_nents_for_len(reqctx->dst, req->cryptlen +
2345                                              (op_type ? -authsize : authsize));
2346         if (reqctx->dst_nents < 0) {
2347                 pr_err("CCM:Invalid Destination sg entries\n");
2348                 error = -EINVAL;
2349                 goto err;
2350         }
2351         error = aead_ccm_validate_input(op_type, req, aeadctx, sub_type);
2352         if (error)
2353                 goto err;
2354
2355         dst_size = get_space_for_phys_dsgl(reqctx->dst_nents);
2356         kctx_len = ((DIV_ROUND_UP(aeadctx->enckey_len, 16)) << 4) * 2;
2357         transhdr_len = CIPHER_TRANSHDR_SIZE(kctx_len, dst_size);
2358         if (chcr_aead_need_fallback(req, src_nent + MIN_CCM_SG,
2359                             T6_MAX_AAD_SIZE - 18,
2360                             transhdr_len + (sgl_len(src_nent + MIN_CCM_SG) * 8),
2361                             op_type)) {
2362                 atomic_inc(&adap->chcr_stats.fallback);
2363                 free_new_sg(reqctx->newdstsg);
2364                 reqctx->newdstsg = NULL;
2365                 return ERR_PTR(chcr_aead_fallback(req, op_type));
2366         }
2367
2368         skb = alloc_skb((transhdr_len + sizeof(struct sge_opaque_hdr)),  flags);
2369
2370         if (!skb) {
2371                 error = -ENOMEM;
2372                 goto err;
2373         }
2374
2375         skb_reserve(skb, sizeof(struct sge_opaque_hdr));
2376
2377         chcr_req = (struct chcr_wr *) __skb_put(skb, transhdr_len);
2378         memset(chcr_req, 0, transhdr_len);
2379
2380         fill_sec_cpl_for_aead(&chcr_req->sec_cpl, dst_size, req, op_type, ctx);
2381
2382         chcr_req->key_ctx.ctx_hdr = aeadctx->key_ctx_hdr;
2383         memcpy(chcr_req->key_ctx.key, aeadctx->key, aeadctx->enckey_len);
2384         memcpy(chcr_req->key_ctx.key + (DIV_ROUND_UP(aeadctx->enckey_len, 16) *
2385                                         16), aeadctx->key, aeadctx->enckey_len);
2386
2387         phys_cpl = (struct cpl_rx_phys_dsgl *)((u8 *)(chcr_req + 1) + kctx_len);
2388         error = ccm_format_packet(req, aeadctx, sub_type, op_type);
2389         if (error)
2390                 goto dstmap_fail;
2391
2392         sg_param.nents = reqctx->dst_nents;
2393         sg_param.obsize = req->cryptlen + (op_type ? -authsize : authsize);
2394         sg_param.qid = qid;
2395         error = map_writesg_phys_cpl(&u_ctx->lldi.pdev->dev, phys_cpl,
2396                                  reqctx->dst, &sg_param);
2397         if (error)
2398                 goto dstmap_fail;
2399
2400         skb_set_transport_header(skb, transhdr_len);
2401         frags = fill_aead_req_fields(skb, req, src, ivsize, aeadctx);
2402         atomic_inc(&adap->chcr_stats.aead_rqst);
2403         create_wreq(ctx, chcr_req, &req->base, skb, kctx_len, 0, 1,
2404                     sizeof(struct cpl_rx_phys_dsgl) + dst_size, 0);
2405         reqctx->skb = skb;
2406         skb_get(skb);
2407         return skb;
2408 dstmap_fail:
2409         kfree_skb(skb);
2410 err:
2411         free_new_sg(reqctx->newdstsg);
2412         reqctx->newdstsg = NULL;
2413         return ERR_PTR(error);
2414 }
2415
2416 static struct sk_buff *create_gcm_wr(struct aead_request *req,
2417                                      unsigned short qid,
2418                                      int size,
2419                                      unsigned short op_type)
2420 {
2421         struct crypto_aead *tfm = crypto_aead_reqtfm(req);
2422         struct chcr_context *ctx = crypto_aead_ctx(tfm);
2423         struct uld_ctx *u_ctx = ULD_CTX(ctx);
2424         struct chcr_aead_ctx *aeadctx = AEAD_CTX(ctx);
2425         struct chcr_aead_reqctx  *reqctx = aead_request_ctx(req);
2426         struct sk_buff *skb = NULL;
2427         struct chcr_wr *chcr_req;
2428         struct cpl_rx_phys_dsgl *phys_cpl;
2429         struct phys_sge_parm sg_param;
2430         struct scatterlist *src;
2431         unsigned int frags = 0, transhdr_len;
2432         unsigned int ivsize = AES_BLOCK_SIZE;
2433         unsigned int dst_size = 0, kctx_len, nents, assoclen = req->assoclen;
2434         unsigned char tag_offset = 0;
2435         unsigned int authsize = crypto_aead_authsize(tfm);
2436         int error = -EINVAL, src_nent;
2437         gfp_t flags = req->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL :
2438                 GFP_ATOMIC;
2439         struct adapter *adap = padap(ctx->dev);
2440
2441         reqctx->newdstsg = NULL;
2442         dst_size = assoclen + req->cryptlen + (op_type ? -authsize :
2443                                                     authsize);
2444         /* validate key size */
2445         if (aeadctx->enckey_len == 0)
2446                 goto err;
2447
2448         if (op_type && req->cryptlen < crypto_aead_authsize(tfm))
2449                 goto err;
2450         src_nent = sg_nents_for_len(req->src, assoclen + req->cryptlen);
2451         if (src_nent < 0)
2452                 goto err;
2453
2454         src = scatterwalk_ffwd(reqctx->srcffwd, req->src, assoclen);
2455         if (req->src != req->dst) {
2456                 error = chcr_copy_assoc(req, aeadctx);
2457                 if (error)
2458                         return  ERR_PTR(error);
2459         }
2460
2461         if (dst_size && is_newsg(req->dst, &nents)) {
2462                 reqctx->newdstsg = alloc_new_sg(req->dst, nents);
2463                 if (IS_ERR(reqctx->newdstsg))
2464                         return ERR_CAST(reqctx->newdstsg);
2465                 reqctx->dst = scatterwalk_ffwd(reqctx->dstffwd,
2466                                                reqctx->newdstsg, assoclen);
2467         } else {
2468                 if (req->src == req->dst)
2469                         reqctx->dst = src;
2470                 else
2471                         reqctx->dst = scatterwalk_ffwd(reqctx->dstffwd,
2472                                                        req->dst, assoclen);
2473         }
2474
2475         reqctx->dst_nents = sg_nents_for_len(reqctx->dst, req->cryptlen +
2476                                              (op_type ? -authsize : authsize));
2477         if (reqctx->dst_nents < 0) {
2478                 pr_err("GCM:Invalid Destination sg entries\n");
2479                 error = -EINVAL;
2480                 goto err;
2481         }
2482
2483
2484         dst_size = get_space_for_phys_dsgl(reqctx->dst_nents);
2485         kctx_len = ((DIV_ROUND_UP(aeadctx->enckey_len, 16)) << 4) +
2486                 AEAD_H_SIZE;
2487         transhdr_len = CIPHER_TRANSHDR_SIZE(kctx_len, dst_size);
2488         if (chcr_aead_need_fallback(req, src_nent + MIN_GCM_SG,
2489                             T6_MAX_AAD_SIZE,
2490                             transhdr_len + (sgl_len(src_nent + MIN_GCM_SG) * 8),
2491                             op_type)) {
2492                 atomic_inc(&adap->chcr_stats.fallback);
2493                 free_new_sg(reqctx->newdstsg);
2494                 reqctx->newdstsg = NULL;
2495                 return ERR_PTR(chcr_aead_fallback(req, op_type));
2496         }
2497         skb = alloc_skb((transhdr_len + sizeof(struct sge_opaque_hdr)), flags);
2498         if (!skb) {
2499                 error = -ENOMEM;
2500                 goto err;
2501         }
2502
2503         /* NIC driver is going to write the sge hdr. */
2504         skb_reserve(skb, sizeof(struct sge_opaque_hdr));
2505
2506         chcr_req = (struct chcr_wr *)__skb_put(skb, transhdr_len);
2507         memset(chcr_req, 0, transhdr_len);
2508
2509         if (get_aead_subtype(tfm) == CRYPTO_ALG_SUB_TYPE_AEAD_RFC4106)
2510                 assoclen = req->assoclen - 8;
2511
2512         tag_offset = (op_type == CHCR_ENCRYPT_OP) ? 0 : authsize;
2513         chcr_req->sec_cpl.op_ivinsrtofst = FILL_SEC_CPL_OP_IVINSR(
2514                                         ctx->dev->rx_channel_id, 2, (ivsize ?
2515                                         (assoclen + 1) : 0));
2516         chcr_req->sec_cpl.pldlen =
2517                 htonl(assoclen + ivsize + req->cryptlen);
2518         chcr_req->sec_cpl.aadstart_cipherstop_hi = FILL_SEC_CPL_CIPHERSTOP_HI(
2519                                         assoclen ? 1 : 0, assoclen,
2520                                         assoclen + ivsize + 1, 0);
2521                 chcr_req->sec_cpl.cipherstop_lo_authinsert =
2522                         FILL_SEC_CPL_AUTHINSERT(0, assoclen + ivsize + 1,
2523                                                 tag_offset, tag_offset);
2524                 chcr_req->sec_cpl.seqno_numivs =
2525                         FILL_SEC_CPL_SCMD0_SEQNO(op_type, (op_type ==
2526                                         CHCR_ENCRYPT_OP) ? 1 : 0,
2527                                         CHCR_SCMD_CIPHER_MODE_AES_GCM,
2528                                         CHCR_SCMD_AUTH_MODE_GHASH,
2529                                         aeadctx->hmac_ctrl, ivsize >> 1);
2530         chcr_req->sec_cpl.ivgen_hdrlen =  FILL_SEC_CPL_IVGEN_HDRLEN(0, 0, 1,
2531                                         0, 1, dst_size);
2532         chcr_req->key_ctx.ctx_hdr = aeadctx->key_ctx_hdr;
2533         memcpy(chcr_req->key_ctx.key, aeadctx->key, aeadctx->enckey_len);
2534         memcpy(chcr_req->key_ctx.key + (DIV_ROUND_UP(aeadctx->enckey_len, 16) *
2535                                 16), GCM_CTX(aeadctx)->ghash_h, AEAD_H_SIZE);
2536
2537         /* prepare a 16 byte iv */
2538         /* S   A   L  T |  IV | 0x00000001 */
2539         if (get_aead_subtype(tfm) ==
2540             CRYPTO_ALG_SUB_TYPE_AEAD_RFC4106) {
2541                 memcpy(reqctx->iv, aeadctx->salt, 4);
2542                 memcpy(reqctx->iv + 4, req->iv, 8);
2543         } else {
2544                 memcpy(reqctx->iv, req->iv, 12);
2545         }
2546         *((unsigned int *)(reqctx->iv + 12)) = htonl(0x01);
2547
2548         phys_cpl = (struct cpl_rx_phys_dsgl *)((u8 *)(chcr_req + 1) + kctx_len);
2549         sg_param.nents = reqctx->dst_nents;
2550         sg_param.obsize = req->cryptlen + (op_type ? -authsize : authsize);
2551         sg_param.qid = qid;
2552         error = map_writesg_phys_cpl(&u_ctx->lldi.pdev->dev, phys_cpl,
2553                                           reqctx->dst, &sg_param);
2554         if (error)
2555                 goto dstmap_fail;
2556
2557         skb_set_transport_header(skb, transhdr_len);
2558         write_sg_to_skb(skb, &frags, req->src, assoclen);
2559         write_buffer_to_skb(skb, &frags, reqctx->iv, ivsize);
2560         write_sg_to_skb(skb, &frags, src, req->cryptlen);
2561         atomic_inc(&adap->chcr_stats.aead_rqst);
2562         create_wreq(ctx, chcr_req, &req->base, skb, kctx_len, size, 1,
2563                         sizeof(struct cpl_rx_phys_dsgl) + dst_size,
2564                         reqctx->verify);
2565         reqctx->skb = skb;
2566         skb_get(skb);
2567         return skb;
2568
2569 dstmap_fail:
2570         /* ivmap_fail: */
2571         kfree_skb(skb);
2572 err:
2573         free_new_sg(reqctx->newdstsg);
2574         reqctx->newdstsg = NULL;
2575         return ERR_PTR(error);
2576 }
2577
2578
2579
2580 static int chcr_aead_cra_init(struct crypto_aead *tfm)
2581 {
2582         struct chcr_context *ctx = crypto_aead_ctx(tfm);
2583         struct chcr_aead_ctx *aeadctx = AEAD_CTX(ctx);
2584         struct aead_alg *alg = crypto_aead_alg(tfm);
2585
2586         aeadctx->sw_cipher = crypto_alloc_aead(alg->base.cra_name, 0,
2587                                                CRYPTO_ALG_NEED_FALLBACK |
2588                                                CRYPTO_ALG_ASYNC);
2589         if  (IS_ERR(aeadctx->sw_cipher))
2590                 return PTR_ERR(aeadctx->sw_cipher);
2591         crypto_aead_set_reqsize(tfm, max(sizeof(struct chcr_aead_reqctx),
2592                                  sizeof(struct aead_request) +
2593                                  crypto_aead_reqsize(aeadctx->sw_cipher)));
2594         aeadctx->null = crypto_get_default_null_skcipher();
2595         if (IS_ERR(aeadctx->null))
2596                 return PTR_ERR(aeadctx->null);
2597         return chcr_device_init(ctx);
2598 }
2599
2600 static void chcr_aead_cra_exit(struct crypto_aead *tfm)
2601 {
2602         struct chcr_context *ctx = crypto_aead_ctx(tfm);
2603         struct chcr_aead_ctx *aeadctx = AEAD_CTX(ctx);
2604
2605         crypto_put_default_null_skcipher();
2606         crypto_free_aead(aeadctx->sw_cipher);
2607 }
2608
2609 static int chcr_authenc_null_setauthsize(struct crypto_aead *tfm,
2610                                         unsigned int authsize)
2611 {
2612         struct chcr_aead_ctx *aeadctx = AEAD_CTX(crypto_aead_ctx(tfm));
2613
2614         aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_NOP;
2615         aeadctx->mayverify = VERIFY_HW;
2616         return crypto_aead_setauthsize(aeadctx->sw_cipher, authsize);
2617 }
2618 static int chcr_authenc_setauthsize(struct crypto_aead *tfm,
2619                                     unsigned int authsize)
2620 {
2621         struct chcr_aead_ctx *aeadctx = AEAD_CTX(crypto_aead_ctx(tfm));
2622         u32 maxauth = crypto_aead_maxauthsize(tfm);
2623
2624         /*SHA1 authsize in ipsec is 12 instead of 10 i.e maxauthsize / 2 is not
2625          * true for sha1. authsize == 12 condition should be before
2626          * authsize == (maxauth >> 1)
2627          */
2628         if (authsize == ICV_4) {
2629                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_PL1;
2630                 aeadctx->mayverify = VERIFY_HW;
2631         } else if (authsize == ICV_6) {
2632                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_PL2;
2633                 aeadctx->mayverify = VERIFY_HW;
2634         } else if (authsize == ICV_10) {
2635                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_TRUNC_RFC4366;
2636                 aeadctx->mayverify = VERIFY_HW;
2637         } else if (authsize == ICV_12) {
2638                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_IPSEC_96BIT;
2639                 aeadctx->mayverify = VERIFY_HW;
2640         } else if (authsize == ICV_14) {
2641                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_PL3;
2642                 aeadctx->mayverify = VERIFY_HW;
2643         } else if (authsize == (maxauth >> 1)) {
2644                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_DIV2;
2645                 aeadctx->mayverify = VERIFY_HW;
2646         } else if (authsize == maxauth) {
2647                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_NO_TRUNC;
2648                 aeadctx->mayverify = VERIFY_HW;
2649         } else {
2650                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_NO_TRUNC;
2651                 aeadctx->mayverify = VERIFY_SW;
2652         }
2653         return crypto_aead_setauthsize(aeadctx->sw_cipher, authsize);
2654 }
2655
2656
2657 static int chcr_gcm_setauthsize(struct crypto_aead *tfm, unsigned int authsize)
2658 {
2659         struct chcr_aead_ctx *aeadctx = AEAD_CTX(crypto_aead_ctx(tfm));
2660
2661         switch (authsize) {
2662         case ICV_4:
2663                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_PL1;
2664                 aeadctx->mayverify = VERIFY_HW;
2665                 break;
2666         case ICV_8:
2667                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_DIV2;
2668                 aeadctx->mayverify = VERIFY_HW;
2669                 break;
2670         case ICV_12:
2671                  aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_IPSEC_96BIT;
2672                  aeadctx->mayverify = VERIFY_HW;
2673                 break;
2674         case ICV_14:
2675                  aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_PL3;
2676                  aeadctx->mayverify = VERIFY_HW;
2677                 break;
2678         case ICV_16:
2679                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_NO_TRUNC;
2680                 aeadctx->mayverify = VERIFY_HW;
2681                 break;
2682         case ICV_13:
2683         case ICV_15:
2684                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_NO_TRUNC;
2685                 aeadctx->mayverify = VERIFY_SW;
2686                 break;
2687         default:
2688
2689                   crypto_tfm_set_flags((struct crypto_tfm *) tfm,
2690                         CRYPTO_TFM_RES_BAD_KEY_LEN);
2691                 return -EINVAL;
2692         }
2693         return crypto_aead_setauthsize(aeadctx->sw_cipher, authsize);
2694 }
2695
2696 static int chcr_4106_4309_setauthsize(struct crypto_aead *tfm,
2697                                           unsigned int authsize)
2698 {
2699         struct chcr_aead_ctx *aeadctx = AEAD_CTX(crypto_aead_ctx(tfm));
2700
2701         switch (authsize) {
2702         case ICV_8:
2703                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_DIV2;
2704                 aeadctx->mayverify = VERIFY_HW;
2705                 break;
2706         case ICV_12:
2707                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_IPSEC_96BIT;
2708                 aeadctx->mayverify = VERIFY_HW;
2709                 break;
2710         case ICV_16:
2711                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_NO_TRUNC;
2712                 aeadctx->mayverify = VERIFY_HW;
2713                 break;
2714         default:
2715                 crypto_tfm_set_flags((struct crypto_tfm *)tfm,
2716                                      CRYPTO_TFM_RES_BAD_KEY_LEN);
2717                 return -EINVAL;
2718         }
2719         return crypto_aead_setauthsize(aeadctx->sw_cipher, authsize);
2720 }
2721
2722 static int chcr_ccm_setauthsize(struct crypto_aead *tfm,
2723                                 unsigned int authsize)
2724 {
2725         struct chcr_aead_ctx *aeadctx = AEAD_CTX(crypto_aead_ctx(tfm));
2726
2727         switch (authsize) {
2728         case ICV_4:
2729                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_PL1;
2730                 aeadctx->mayverify = VERIFY_HW;
2731                 break;
2732         case ICV_6:
2733                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_PL2;
2734                 aeadctx->mayverify = VERIFY_HW;
2735                 break;
2736         case ICV_8:
2737                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_DIV2;
2738                 aeadctx->mayverify = VERIFY_HW;
2739                 break;
2740         case ICV_10:
2741                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_TRUNC_RFC4366;
2742                 aeadctx->mayverify = VERIFY_HW;
2743                 break;
2744         case ICV_12:
2745                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_IPSEC_96BIT;
2746                 aeadctx->mayverify = VERIFY_HW;
2747                 break;
2748         case ICV_14:
2749                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_PL3;
2750                 aeadctx->mayverify = VERIFY_HW;
2751                 break;
2752         case ICV_16:
2753                 aeadctx->hmac_ctrl = CHCR_SCMD_HMAC_CTRL_NO_TRUNC;
2754                 aeadctx->mayverify = VERIFY_HW;
2755                 break;
2756         default:
2757                 crypto_tfm_set_flags((struct crypto_tfm *)tfm,
2758                                      CRYPTO_TFM_RES_BAD_KEY_LEN);
2759                 return -EINVAL;
2760         }
2761         return crypto_aead_setauthsize(aeadctx->sw_cipher, authsize);
2762 }
2763
2764 static int chcr_ccm_common_setkey(struct crypto_aead *aead,
2765                                 const u8 *key,
2766                                 unsigned int keylen)
2767 {
2768         struct chcr_context *ctx = crypto_aead_ctx(aead);
2769         struct chcr_aead_ctx *aeadctx = AEAD_CTX(ctx);
2770         unsigned char ck_size, mk_size;
2771         int key_ctx_size = 0;
2772
2773         key_ctx_size = sizeof(struct _key_ctx) +
2774                 ((DIV_ROUND_UP(keylen, 16)) << 4)  * 2;
2775         if (keylen == AES_KEYSIZE_128) {
2776                 mk_size = CHCR_KEYCTX_CIPHER_KEY_SIZE_128;
2777                 ck_size = CHCR_KEYCTX_CIPHER_KEY_SIZE_128;
2778         } else if (keylen == AES_KEYSIZE_192) {
2779                 ck_size = CHCR_KEYCTX_CIPHER_KEY_SIZE_192;
2780                 mk_size = CHCR_KEYCTX_MAC_KEY_SIZE_192;
2781         } else if (keylen == AES_KEYSIZE_256) {
2782                 ck_size = CHCR_KEYCTX_CIPHER_KEY_SIZE_256;
2783                 mk_size = CHCR_KEYCTX_MAC_KEY_SIZE_256;
2784         } else {
2785                 crypto_tfm_set_flags((struct crypto_tfm *)aead,
2786                                      CRYPTO_TFM_RES_BAD_KEY_LEN);
2787                 aeadctx->enckey_len = 0;
2788                 return  -EINVAL;
2789         }
2790         aeadctx->key_ctx_hdr = FILL_KEY_CTX_HDR(ck_size, mk_size, 0, 0,
2791                                                 key_ctx_size >> 4);
2792         memcpy(aeadctx->key, key, keylen);
2793         aeadctx->enckey_len = keylen;
2794
2795         return 0;
2796 }
2797
2798 static int chcr_aead_ccm_setkey(struct crypto_aead *aead,
2799                                 const u8 *key,
2800                                 unsigned int keylen)
2801 {
2802         struct chcr_context *ctx = crypto_aead_ctx(aead);
2803         struct chcr_aead_ctx *aeadctx = AEAD_CTX(ctx);
2804         int error;
2805
2806         crypto_aead_clear_flags(aeadctx->sw_cipher, CRYPTO_TFM_REQ_MASK);
2807         crypto_aead_set_flags(aeadctx->sw_cipher, crypto_aead_get_flags(aead) &
2808                               CRYPTO_TFM_REQ_MASK);
2809         error = crypto_aead_setkey(aeadctx->sw_cipher, key, keylen);
2810         crypto_aead_clear_flags(aead, CRYPTO_TFM_RES_MASK);
2811         crypto_aead_set_flags(aead, crypto_aead_get_flags(aeadctx->sw_cipher) &
2812                               CRYPTO_TFM_RES_MASK);
2813         if (error)
2814                 return error;
2815         return chcr_ccm_common_setkey(aead, key, keylen);
2816 }
2817
2818 static int chcr_aead_rfc4309_setkey(struct crypto_aead *aead, const u8 *key,
2819                                     unsigned int keylen)
2820 {
2821         struct chcr_context *ctx = crypto_aead_ctx(aead);
2822         struct chcr_aead_ctx *aeadctx = AEAD_CTX(ctx);
2823         int error;
2824
2825         if (keylen < 3) {
2826                 crypto_tfm_set_flags((struct crypto_tfm *)aead,
2827                                      CRYPTO_TFM_RES_BAD_KEY_LEN);
2828                 aeadctx->enckey_len = 0;
2829                 return  -EINVAL;
2830         }
2831         crypto_aead_clear_flags(aeadctx->sw_cipher, CRYPTO_TFM_REQ_MASK);
2832         crypto_aead_set_flags(aeadctx->sw_cipher, crypto_aead_get_flags(aead) &
2833                               CRYPTO_TFM_REQ_MASK);
2834         error = crypto_aead_setkey(aeadctx->sw_cipher, key, keylen);
2835         crypto_aead_clear_flags(aead, CRYPTO_TFM_RES_MASK);
2836         crypto_aead_set_flags(aead, crypto_aead_get_flags(aeadctx->sw_cipher) &
2837                               CRYPTO_TFM_RES_MASK);
2838         if (error)
2839                 return error;
2840         keylen -= 3;
2841         memcpy(aeadctx->salt, key + keylen, 3);
2842         return chcr_ccm_common_setkey(aead, key, keylen);
2843 }
2844
2845 static int chcr_gcm_setkey(struct crypto_aead *aead, const u8 *key,
2846                            unsigned int keylen)
2847 {
2848         struct chcr_context *ctx = crypto_aead_ctx(aead);
2849         struct chcr_aead_ctx *aeadctx = AEAD_CTX(ctx);
2850         struct chcr_gcm_ctx *gctx = GCM_CTX(aeadctx);
2851         struct crypto_cipher *cipher;
2852         unsigned int ck_size;
2853         int ret = 0, key_ctx_size = 0;
2854
2855         aeadctx->enckey_len = 0;
2856         crypto_aead_clear_flags(aeadctx->sw_cipher, CRYPTO_TFM_REQ_MASK);
2857         crypto_aead_set_flags(aeadctx->sw_cipher, crypto_aead_get_flags(aead)
2858                               & CRYPTO_TFM_REQ_MASK);
2859         ret = crypto_aead_setkey(aeadctx->sw_cipher, key, keylen);
2860         crypto_aead_clear_flags(aead, CRYPTO_TFM_RES_MASK);
2861         crypto_aead_set_flags(aead, crypto_aead_get_flags(aeadctx->sw_cipher) &
2862                               CRYPTO_TFM_RES_MASK);
2863         if (ret)
2864                 goto out;
2865
2866         if (get_aead_subtype(aead) == CRYPTO_ALG_SUB_TYPE_AEAD_RFC4106 &&
2867             keylen > 3) {
2868                 keylen -= 4;  /* nonce/salt is present in the last 4 bytes */
2869                 memcpy(aeadctx->salt, key + keylen, 4);
2870         }
2871         if (keylen == AES_KEYSIZE_128) {
2872                 ck_size = CHCR_KEYCTX_CIPHER_KEY_SIZE_128;
2873         } else if (keylen == AES_KEYSIZE_192) {
2874                 ck_size = CHCR_KEYCTX_CIPHER_KEY_SIZE_192;
2875         } else if (keylen == AES_KEYSIZE_256) {
2876                 ck_size = CHCR_KEYCTX_CIPHER_KEY_SIZE_256;
2877         } else {
2878                 crypto_tfm_set_flags((struct crypto_tfm *)aead,
2879                                      CRYPTO_TFM_RES_BAD_KEY_LEN);
2880                 pr_err("GCM: Invalid key length %d\n", keylen);
2881                 ret = -EINVAL;
2882                 goto out;
2883         }
2884
2885         memcpy(aeadctx->key, key, keylen);
2886         aeadctx->enckey_len = keylen;
2887         key_ctx_size = sizeof(struct _key_ctx) +
2888                 ((DIV_ROUND_UP(keylen, 16)) << 4) +
2889                 AEAD_H_SIZE;
2890                 aeadctx->key_ctx_hdr = FILL_KEY_CTX_HDR(ck_size,
2891                                                 CHCR_KEYCTX_MAC_KEY_SIZE_128,
2892                                                 0, 0,
2893                                                 key_ctx_size >> 4);
2894         /* Calculate the H = CIPH(K, 0 repeated 16 times).
2895          * It will go in key context
2896          */
2897         cipher = crypto_alloc_cipher("aes-generic", 0, 0);
2898         if (IS_ERR(cipher)) {
2899                 aeadctx->enckey_len = 0;
2900                 ret = -ENOMEM;
2901                 goto out;
2902         }
2903
2904         ret = crypto_cipher_setkey(cipher, key, keylen);
2905         if (ret) {
2906                 aeadctx->enckey_len = 0;
2907                 goto out1;
2908         }
2909         memset(gctx->ghash_h, 0, AEAD_H_SIZE);
2910         crypto_cipher_encrypt_one(cipher, gctx->ghash_h, gctx->ghash_h);
2911
2912 out1:
2913         crypto_free_cipher(cipher);
2914 out:
2915         return ret;
2916 }
2917
2918 static int chcr_authenc_setkey(struct crypto_aead *authenc, const u8 *key,
2919                                    unsigned int keylen)
2920 {
2921         struct chcr_context *ctx = crypto_aead_ctx(authenc);
2922         struct chcr_aead_ctx *aeadctx = AEAD_CTX(ctx);
2923         struct chcr_authenc_ctx *actx = AUTHENC_CTX(aeadctx);
2924         /* it contains auth and cipher key both*/
2925         struct crypto_authenc_keys keys;
2926         unsigned int bs;
2927         unsigned int max_authsize = crypto_aead_alg(authenc)->maxauthsize;
2928         int err = 0, i, key_ctx_len = 0;
2929         unsigned char ck_size = 0;
2930         unsigned char pad[CHCR_HASH_MAX_BLOCK_SIZE_128] = { 0 };
2931         struct crypto_shash *base_hash = ERR_PTR(-EINVAL);
2932         struct algo_param param;
2933         int align;
2934         u8 *o_ptr = NULL;
2935
2936         crypto_aead_clear_flags(aeadctx->sw_cipher, CRYPTO_TFM_REQ_MASK);
2937         crypto_aead_set_flags(aeadctx->sw_cipher, crypto_aead_get_flags(authenc)
2938                               & CRYPTO_TFM_REQ_MASK);
2939         err = crypto_aead_setkey(aeadctx->sw_cipher, key, keylen);
2940         crypto_aead_clear_flags(authenc, CRYPTO_TFM_RES_MASK);
2941         crypto_aead_set_flags(authenc, crypto_aead_get_flags(aeadctx->sw_cipher)
2942                               & CRYPTO_TFM_RES_MASK);
2943         if (err)
2944                 goto out;
2945
2946         if (crypto_authenc_extractkeys(&keys, key, keylen) != 0) {
2947                 crypto_aead_set_flags(authenc, CRYPTO_TFM_RES_BAD_KEY_LEN);
2948                 goto out;
2949         }
2950
2951         if (get_alg_config(&param, max_authsize)) {
2952                 pr_err("chcr : Unsupported digest size\n");
2953                 goto out;
2954         }
2955         if (keys.enckeylen == AES_KEYSIZE_128) {
2956                 ck_size = CHCR_KEYCTX_CIPHER_KEY_SIZE_128;
2957         } else if (keys.enckeylen == AES_KEYSIZE_192) {
2958                 ck_size = CHCR_KEYCTX_CIPHER_KEY_SIZE_192;
2959         } else if (keys.enckeylen == AES_KEYSIZE_256) {
2960                 ck_size = CHCR_KEYCTX_CIPHER_KEY_SIZE_256;
2961         } else {
2962                 pr_err("chcr : Unsupported cipher key\n");
2963                 goto out;
2964         }
2965
2966         /* Copy only encryption key. We use authkey to generate h(ipad) and
2967          * h(opad) so authkey is not needed again. authkeylen size have the
2968          * size of the hash digest size.
2969          */
2970         memcpy(aeadctx->key, keys.enckey, keys.enckeylen);
2971         aeadctx->enckey_len = keys.enckeylen;
2972         get_aes_decrypt_key(actx->dec_rrkey, aeadctx->key,
2973                             aeadctx->enckey_len << 3);
2974
2975         base_hash  = chcr_alloc_shash(max_authsize);
2976         if (IS_ERR(base_hash)) {
2977                 pr_err("chcr : Base driver cannot be loaded\n");
2978                 aeadctx->enckey_len = 0;
2979                 return -EINVAL;
2980         }
2981         {
2982                 SHASH_DESC_ON_STACK(shash, base_hash);
2983                 shash->tfm = base_hash;
2984                 shash->flags = crypto_shash_get_flags(base_hash);
2985                 bs = crypto_shash_blocksize(base_hash);
2986                 align = KEYCTX_ALIGN_PAD(max_authsize);
2987                 o_ptr =  actx->h_iopad + param.result_size + align;
2988
2989                 if (keys.authkeylen > bs) {
2990                         err = crypto_shash_digest(shash, keys.authkey,
2991                                                   keys.authkeylen,
2992                                                   o_ptr);
2993                         if (err) {
2994                                 pr_err("chcr : Base driver cannot be loaded\n");
2995                                 goto out;
2996                         }
2997                         keys.authkeylen = max_authsize;
2998                 } else
2999                         memcpy(o_ptr, keys.authkey, keys.authkeylen);
3000
3001                 /* Compute the ipad-digest*/
3002                 memset(pad + keys.authkeylen, 0, bs - keys.authkeylen);
3003                 memcpy(pad, o_ptr, keys.authkeylen);
3004                 for (i = 0; i < bs >> 2; i++)
3005                         *((unsigned int *)pad + i) ^= IPAD_DATA;
3006
3007                 if (chcr_compute_partial_hash(shash, pad, actx->h_iopad,
3008                                               max_authsize))
3009                         goto out;
3010                 /* Compute the opad-digest */
3011                 memset(pad + keys.authkeylen, 0, bs - keys.authkeylen);