treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 206
[muen/linux.git] / drivers / crypto / cavium / cpt / cptvf_algs.c
1 // SPDX-License-Identifier: GPL-2.0-only
2
3 /*
4  * Copyright (C) 2016 Cavium, Inc.
5  */
6
7 #include <crypto/aes.h>
8 #include <crypto/algapi.h>
9 #include <crypto/authenc.h>
10 #include <crypto/crypto_wq.h>
11 #include <crypto/des.h>
12 #include <crypto/xts.h>
13 #include <linux/crypto.h>
14 #include <linux/err.h>
15 #include <linux/list.h>
16 #include <linux/scatterlist.h>
17
18 #include "cptvf.h"
19 #include "cptvf_algs.h"
20
21 struct cpt_device_handle {
22         void *cdev[MAX_DEVICES];
23         u32 dev_count;
24 };
25
26 static struct cpt_device_handle dev_handle;
27
28 static void cvm_callback(u32 status, void *arg)
29 {
30         struct crypto_async_request *req = (struct crypto_async_request *)arg;
31
32         req->complete(req, !status);
33 }
34
35 static inline void update_input_iv(struct cpt_request_info *req_info,
36                                    u8 *iv, u32 enc_iv_len,
37                                    u32 *argcnt)
38 {
39         /* Setting the iv information */
40         req_info->in[*argcnt].vptr = (void *)iv;
41         req_info->in[*argcnt].size = enc_iv_len;
42         req_info->req.dlen += enc_iv_len;
43
44         ++(*argcnt);
45 }
46
47 static inline void update_output_iv(struct cpt_request_info *req_info,
48                                     u8 *iv, u32 enc_iv_len,
49                                     u32 *argcnt)
50 {
51         /* Setting the iv information */
52         req_info->out[*argcnt].vptr = (void *)iv;
53         req_info->out[*argcnt].size = enc_iv_len;
54         req_info->rlen += enc_iv_len;
55
56         ++(*argcnt);
57 }
58
59 static inline void update_input_data(struct cpt_request_info *req_info,
60                                      struct scatterlist *inp_sg,
61                                      u32 nbytes, u32 *argcnt)
62 {
63         req_info->req.dlen += nbytes;
64
65         while (nbytes) {
66                 u32 len = min(nbytes, inp_sg->length);
67                 u8 *ptr = sg_virt(inp_sg);
68
69                 req_info->in[*argcnt].vptr = (void *)ptr;
70                 req_info->in[*argcnt].size = len;
71                 nbytes -= len;
72
73                 ++(*argcnt);
74                 ++inp_sg;
75         }
76 }
77
78 static inline void update_output_data(struct cpt_request_info *req_info,
79                                       struct scatterlist *outp_sg,
80                                       u32 nbytes, u32 *argcnt)
81 {
82         req_info->rlen += nbytes;
83
84         while (nbytes) {
85                 u32 len = min(nbytes, outp_sg->length);
86                 u8 *ptr = sg_virt(outp_sg);
87
88                 req_info->out[*argcnt].vptr = (void *)ptr;
89                 req_info->out[*argcnt].size = len;
90                 nbytes -= len;
91                 ++(*argcnt);
92                 ++outp_sg;
93         }
94 }
95
96 static inline u32 create_ctx_hdr(struct ablkcipher_request *req, u32 enc,
97                                  u32 *argcnt)
98 {
99         struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
100         struct cvm_enc_ctx *ctx = crypto_ablkcipher_ctx(tfm);
101         struct cvm_req_ctx *rctx = ablkcipher_request_ctx(req);
102         struct fc_context *fctx = &rctx->fctx;
103         u64 *offset_control = &rctx->control_word;
104         u32 enc_iv_len = crypto_ablkcipher_ivsize(tfm);
105         struct cpt_request_info *req_info = &rctx->cpt_req;
106         u64 *ctrl_flags = NULL;
107
108         req_info->ctrl.s.grp = 0;
109         req_info->ctrl.s.dma_mode = DMA_GATHER_SCATTER;
110         req_info->ctrl.s.se_req = SE_CORE_REQ;
111
112         req_info->req.opcode.s.major = MAJOR_OP_FC |
113                                         DMA_MODE_FLAG(DMA_GATHER_SCATTER);
114         if (enc)
115                 req_info->req.opcode.s.minor = 2;
116         else
117                 req_info->req.opcode.s.minor = 3;
118
119         req_info->req.param1 = req->nbytes; /* Encryption Data length */
120         req_info->req.param2 = 0; /*Auth data length */
121
122         fctx->enc.enc_ctrl.e.enc_cipher = ctx->cipher_type;
123         fctx->enc.enc_ctrl.e.aes_key = ctx->key_type;
124         fctx->enc.enc_ctrl.e.iv_source = FROM_DPTR;
125
126         if (ctx->cipher_type == AES_XTS)
127                 memcpy(fctx->enc.encr_key, ctx->enc_key, ctx->key_len * 2);
128         else
129                 memcpy(fctx->enc.encr_key, ctx->enc_key, ctx->key_len);
130         ctrl_flags = (u64 *)&fctx->enc.enc_ctrl.flags;
131         *ctrl_flags = cpu_to_be64(*ctrl_flags);
132
133         *offset_control = cpu_to_be64(((u64)(enc_iv_len) << 16));
134         /* Storing  Packet Data Information in offset
135          * Control Word First 8 bytes
136          */
137         req_info->in[*argcnt].vptr = (u8 *)offset_control;
138         req_info->in[*argcnt].size = CONTROL_WORD_LEN;
139         req_info->req.dlen += CONTROL_WORD_LEN;
140         ++(*argcnt);
141
142         req_info->in[*argcnt].vptr = (u8 *)fctx;
143         req_info->in[*argcnt].size = sizeof(struct fc_context);
144         req_info->req.dlen += sizeof(struct fc_context);
145
146         ++(*argcnt);
147
148         return 0;
149 }
150
151 static inline u32 create_input_list(struct ablkcipher_request  *req, u32 enc,
152                                     u32 enc_iv_len)
153 {
154         struct cvm_req_ctx *rctx = ablkcipher_request_ctx(req);
155         struct cpt_request_info *req_info = &rctx->cpt_req;
156         u32 argcnt =  0;
157
158         create_ctx_hdr(req, enc, &argcnt);
159         update_input_iv(req_info, req->info, enc_iv_len, &argcnt);
160         update_input_data(req_info, req->src, req->nbytes, &argcnt);
161         req_info->incnt = argcnt;
162
163         return 0;
164 }
165
166 static inline void store_cb_info(struct ablkcipher_request *req,
167                                  struct cpt_request_info *req_info)
168 {
169         req_info->callback = (void *)cvm_callback;
170         req_info->callback_arg = (void *)&req->base;
171 }
172
173 static inline void create_output_list(struct ablkcipher_request *req,
174                                       u32 enc_iv_len)
175 {
176         struct cvm_req_ctx *rctx = ablkcipher_request_ctx(req);
177         struct cpt_request_info *req_info = &rctx->cpt_req;
178         u32 argcnt = 0;
179
180         /* OUTPUT Buffer Processing
181          * AES encryption/decryption output would be
182          * received in the following format
183          *
184          * ------IV--------|------ENCRYPTED/DECRYPTED DATA-----|
185          * [ 16 Bytes/     [   Request Enc/Dec/ DATA Len AES CBC ]
186          */
187         /* Reading IV information */
188         update_output_iv(req_info, req->info, enc_iv_len, &argcnt);
189         update_output_data(req_info, req->dst, req->nbytes, &argcnt);
190         req_info->outcnt = argcnt;
191 }
192
193 static inline int cvm_enc_dec(struct ablkcipher_request *req, u32 enc)
194 {
195         struct crypto_ablkcipher *tfm = crypto_ablkcipher_reqtfm(req);
196         struct cvm_req_ctx *rctx = ablkcipher_request_ctx(req);
197         u32 enc_iv_len = crypto_ablkcipher_ivsize(tfm);
198         struct fc_context *fctx = &rctx->fctx;
199         struct cpt_request_info *req_info = &rctx->cpt_req;
200         void *cdev = NULL;
201         int status;
202
203         memset(req_info, 0, sizeof(struct cpt_request_info));
204         memset(fctx, 0, sizeof(struct fc_context));
205         create_input_list(req, enc, enc_iv_len);
206         create_output_list(req, enc_iv_len);
207         store_cb_info(req, req_info);
208         cdev = dev_handle.cdev[smp_processor_id()];
209         status = cptvf_do_request(cdev, req_info);
210         /* We perform an asynchronous send and once
211          * the request is completed the driver would
212          * intimate through  registered call back functions
213          */
214
215         if (status)
216                 return status;
217         else
218                 return -EINPROGRESS;
219 }
220
221 static int cvm_encrypt(struct ablkcipher_request *req)
222 {
223         return cvm_enc_dec(req, true);
224 }
225
226 static int cvm_decrypt(struct ablkcipher_request *req)
227 {
228         return cvm_enc_dec(req, false);
229 }
230
231 static int cvm_xts_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
232                    u32 keylen)
233 {
234         struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher);
235         struct cvm_enc_ctx *ctx = crypto_tfm_ctx(tfm);
236         int err;
237         const u8 *key1 = key;
238         const u8 *key2 = key + (keylen / 2);
239
240         err = xts_check_key(tfm, key, keylen);
241         if (err)
242                 return err;
243         ctx->key_len = keylen;
244         memcpy(ctx->enc_key, key1, keylen / 2);
245         memcpy(ctx->enc_key + KEY2_OFFSET, key2, keylen / 2);
246         ctx->cipher_type = AES_XTS;
247         switch (ctx->key_len) {
248         case 32:
249                 ctx->key_type = AES_128_BIT;
250                 break;
251         case 64:
252                 ctx->key_type = AES_256_BIT;
253                 break;
254         default:
255                 return -EINVAL;
256         }
257
258         return 0;
259 }
260
261 static int cvm_validate_keylen(struct cvm_enc_ctx *ctx, u32 keylen)
262 {
263         if ((keylen == 16) || (keylen == 24) || (keylen == 32)) {
264                 ctx->key_len = keylen;
265                 switch (ctx->key_len) {
266                 case 16:
267                         ctx->key_type = AES_128_BIT;
268                         break;
269                 case 24:
270                         ctx->key_type = AES_192_BIT;
271                         break;
272                 case 32:
273                         ctx->key_type = AES_256_BIT;
274                         break;
275                 default:
276                         return -EINVAL;
277                 }
278
279                 if (ctx->cipher_type == DES3_CBC)
280                         ctx->key_type = 0;
281
282                 return 0;
283         }
284
285         return -EINVAL;
286 }
287
288 static int cvm_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
289                       u32 keylen, u8 cipher_type)
290 {
291         struct crypto_tfm *tfm = crypto_ablkcipher_tfm(cipher);
292         struct cvm_enc_ctx *ctx = crypto_tfm_ctx(tfm);
293
294         ctx->cipher_type = cipher_type;
295         if (!cvm_validate_keylen(ctx, keylen)) {
296                 memcpy(ctx->enc_key, key, keylen);
297                 return 0;
298         } else {
299                 crypto_ablkcipher_set_flags(cipher,
300                                             CRYPTO_TFM_RES_BAD_KEY_LEN);
301                 return -EINVAL;
302         }
303 }
304
305 static int cvm_cbc_aes_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
306                               u32 keylen)
307 {
308         return cvm_setkey(cipher, key, keylen, AES_CBC);
309 }
310
311 static int cvm_ecb_aes_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
312                               u32 keylen)
313 {
314         return cvm_setkey(cipher, key, keylen, AES_ECB);
315 }
316
317 static int cvm_cfb_aes_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
318                               u32 keylen)
319 {
320         return cvm_setkey(cipher, key, keylen, AES_CFB);
321 }
322
323 static int cvm_cbc_des3_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
324                                u32 keylen)
325 {
326         u32 flags = crypto_ablkcipher_get_flags(cipher);
327         int err;
328
329         err = __des3_verify_key(&flags, key);
330         if (unlikely(err)) {
331                 crypto_ablkcipher_set_flags(cipher, flags);
332                 return err;
333         }
334
335         return cvm_setkey(cipher, key, keylen, DES3_CBC);
336 }
337
338 static int cvm_ecb_des3_setkey(struct crypto_ablkcipher *cipher, const u8 *key,
339                                u32 keylen)
340 {
341         u32 flags = crypto_ablkcipher_get_flags(cipher);
342         int err;
343
344         err = __des3_verify_key(&flags, key);
345         if (unlikely(err)) {
346                 crypto_ablkcipher_set_flags(cipher, flags);
347                 return err;
348         }
349
350         return cvm_setkey(cipher, key, keylen, DES3_ECB);
351 }
352
353 static int cvm_enc_dec_init(struct crypto_tfm *tfm)
354 {
355         tfm->crt_ablkcipher.reqsize = sizeof(struct cvm_req_ctx);
356         return 0;
357 }
358
359 static struct crypto_alg algs[] = { {
360         .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
361         .cra_blocksize = AES_BLOCK_SIZE,
362         .cra_ctxsize = sizeof(struct cvm_enc_ctx),
363         .cra_alignmask = 7,
364         .cra_priority = 4001,
365         .cra_name = "xts(aes)",
366         .cra_driver_name = "cavium-xts-aes",
367         .cra_type = &crypto_ablkcipher_type,
368         .cra_u = {
369                 .ablkcipher = {
370                         .ivsize = AES_BLOCK_SIZE,
371                         .min_keysize = 2 * AES_MIN_KEY_SIZE,
372                         .max_keysize = 2 * AES_MAX_KEY_SIZE,
373                         .setkey = cvm_xts_setkey,
374                         .encrypt = cvm_encrypt,
375                         .decrypt = cvm_decrypt,
376                 },
377         },
378         .cra_init = cvm_enc_dec_init,
379         .cra_module = THIS_MODULE,
380 }, {
381         .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
382         .cra_blocksize = AES_BLOCK_SIZE,
383         .cra_ctxsize = sizeof(struct cvm_enc_ctx),
384         .cra_alignmask = 7,
385         .cra_priority = 4001,
386         .cra_name = "cbc(aes)",
387         .cra_driver_name = "cavium-cbc-aes",
388         .cra_type = &crypto_ablkcipher_type,
389         .cra_u = {
390                 .ablkcipher = {
391                         .ivsize = AES_BLOCK_SIZE,
392                         .min_keysize = AES_MIN_KEY_SIZE,
393                         .max_keysize = AES_MAX_KEY_SIZE,
394                         .setkey = cvm_cbc_aes_setkey,
395                         .encrypt = cvm_encrypt,
396                         .decrypt = cvm_decrypt,
397                 },
398         },
399         .cra_init = cvm_enc_dec_init,
400         .cra_module = THIS_MODULE,
401 }, {
402         .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
403         .cra_blocksize = AES_BLOCK_SIZE,
404         .cra_ctxsize = sizeof(struct cvm_enc_ctx),
405         .cra_alignmask = 7,
406         .cra_priority = 4001,
407         .cra_name = "ecb(aes)",
408         .cra_driver_name = "cavium-ecb-aes",
409         .cra_type = &crypto_ablkcipher_type,
410         .cra_u = {
411                 .ablkcipher = {
412                         .ivsize = AES_BLOCK_SIZE,
413                         .min_keysize = AES_MIN_KEY_SIZE,
414                         .max_keysize = AES_MAX_KEY_SIZE,
415                         .setkey = cvm_ecb_aes_setkey,
416                         .encrypt = cvm_encrypt,
417                         .decrypt = cvm_decrypt,
418                 },
419         },
420         .cra_init = cvm_enc_dec_init,
421         .cra_module = THIS_MODULE,
422 }, {
423         .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
424         .cra_blocksize = AES_BLOCK_SIZE,
425         .cra_ctxsize = sizeof(struct cvm_enc_ctx),
426         .cra_alignmask = 7,
427         .cra_priority = 4001,
428         .cra_name = "cfb(aes)",
429         .cra_driver_name = "cavium-cfb-aes",
430         .cra_type = &crypto_ablkcipher_type,
431         .cra_u = {
432                 .ablkcipher = {
433                         .ivsize = AES_BLOCK_SIZE,
434                         .min_keysize = AES_MIN_KEY_SIZE,
435                         .max_keysize = AES_MAX_KEY_SIZE,
436                         .setkey = cvm_cfb_aes_setkey,
437                         .encrypt = cvm_encrypt,
438                         .decrypt = cvm_decrypt,
439                 },
440         },
441         .cra_init = cvm_enc_dec_init,
442         .cra_module = THIS_MODULE,
443 }, {
444         .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
445         .cra_blocksize = DES3_EDE_BLOCK_SIZE,
446         .cra_ctxsize = sizeof(struct cvm_des3_ctx),
447         .cra_alignmask = 7,
448         .cra_priority = 4001,
449         .cra_name = "cbc(des3_ede)",
450         .cra_driver_name = "cavium-cbc-des3_ede",
451         .cra_type = &crypto_ablkcipher_type,
452         .cra_u = {
453                 .ablkcipher = {
454                         .min_keysize = DES3_EDE_KEY_SIZE,
455                         .max_keysize = DES3_EDE_KEY_SIZE,
456                         .ivsize = DES_BLOCK_SIZE,
457                         .setkey = cvm_cbc_des3_setkey,
458                         .encrypt = cvm_encrypt,
459                         .decrypt = cvm_decrypt,
460                 },
461         },
462         .cra_init = cvm_enc_dec_init,
463         .cra_module = THIS_MODULE,
464 }, {
465         .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER | CRYPTO_ALG_ASYNC,
466         .cra_blocksize = DES3_EDE_BLOCK_SIZE,
467         .cra_ctxsize = sizeof(struct cvm_des3_ctx),
468         .cra_alignmask = 7,
469         .cra_priority = 4001,
470         .cra_name = "ecb(des3_ede)",
471         .cra_driver_name = "cavium-ecb-des3_ede",
472         .cra_type = &crypto_ablkcipher_type,
473         .cra_u = {
474                 .ablkcipher = {
475                         .min_keysize = DES3_EDE_KEY_SIZE,
476                         .max_keysize = DES3_EDE_KEY_SIZE,
477                         .ivsize = DES_BLOCK_SIZE,
478                         .setkey = cvm_ecb_des3_setkey,
479                         .encrypt = cvm_encrypt,
480                         .decrypt = cvm_decrypt,
481                 },
482         },
483         .cra_init = cvm_enc_dec_init,
484         .cra_module = THIS_MODULE,
485 } };
486
487 static inline int cav_register_algs(void)
488 {
489         int err = 0;
490
491         err = crypto_register_algs(algs, ARRAY_SIZE(algs));
492         if (err)
493                 return err;
494
495         return 0;
496 }
497
498 static inline void cav_unregister_algs(void)
499 {
500         crypto_unregister_algs(algs, ARRAY_SIZE(algs));
501 }
502
503 int cvm_crypto_init(struct cpt_vf *cptvf)
504 {
505         struct pci_dev *pdev = cptvf->pdev;
506         u32 dev_count;
507
508         dev_count = dev_handle.dev_count;
509         dev_handle.cdev[dev_count] = cptvf;
510         dev_handle.dev_count++;
511
512         if (dev_count == 3) {
513                 if (cav_register_algs()) {
514                         dev_err(&pdev->dev, "Error in registering crypto algorithms\n");
515                         return -EINVAL;
516                 }
517         }
518
519         return 0;
520 }
521
522 void cvm_crypto_exit(void)
523 {
524         u32 dev_count;
525
526         dev_count = --dev_handle.dev_count;
527         if (!dev_count)
528                 cav_unregister_algs();
529 }