1 // SPDX-License-Identifier: GPL-2.0-only 2 /** 3 * AES CBC routines supporting VMX instructions on the Power 8 4 * 5 * Copyright (C) 2015 International Business Machines Inc. 6 * 7 * Author: Marcelo Henrique Cerri <mhcerri@br.ibm.com> 8 */ 9 10 #include <asm/simd.h> 11 #include <asm/switch_to.h> 12 #include <crypto/aes.h> 13 #include <crypto/internal/simd.h> 14 #include <crypto/internal/skcipher.h> 15 16 #include "aesp8-ppc.h" 17 18 struct p8_aes_cbc_ctx { 19 struct crypto_skcipher *fallback; 20 struct aes_key enc_key; 21 struct aes_key dec_key; 22 }; 23 24 static int p8_aes_cbc_init(struct crypto_skcipher *tfm) 25 { 26 struct p8_aes_cbc_ctx *ctx = crypto_skcipher_ctx(tfm); 27 struct crypto_skcipher *fallback; 28 29 fallback = crypto_alloc_skcipher("cbc(aes)", 0, 30 CRYPTO_ALG_NEED_FALLBACK | 31 CRYPTO_ALG_ASYNC); 32 if (IS_ERR(fallback)) { 33 pr_err("Failed to allocate cbc(aes) fallback: %ld\n", 34 PTR_ERR(fallback)); 35 return PTR_ERR(fallback); 36 } 37 38 crypto_skcipher_set_reqsize(tfm, sizeof(struct skcipher_request) + 39 crypto_skcipher_reqsize(fallback)); 40 ctx->fallback = fallback; 41 return 0; 42 } 43 44 static void p8_aes_cbc_exit(struct crypto_skcipher *tfm) 45 { 46 struct p8_aes_cbc_ctx *ctx = crypto_skcipher_ctx(tfm); 47 48 crypto_free_skcipher(ctx->fallback); 49 } 50 51 static int p8_aes_cbc_setkey(struct crypto_skcipher *tfm, const u8 *key, 52 unsigned int keylen) 53 { 54 struct p8_aes_cbc_ctx *ctx = crypto_skcipher_ctx(tfm); 55 int ret; 56 57 preempt_disable(); 58 pagefault_disable(); 59 enable_kernel_vsx(); 60 ret = aes_p8_set_encrypt_key(key, keylen * 8, &ctx->enc_key); 61 ret |= aes_p8_set_decrypt_key(key, keylen * 8, &ctx->dec_key); 62 disable_kernel_vsx(); 63 pagefault_enable(); 64 preempt_enable(); 65 66 ret |= crypto_skcipher_setkey(ctx->fallback, key, keylen); 67 68 return ret ? -EINVAL : 0; 69 } 70 71 static int p8_aes_cbc_crypt(struct skcipher_request *req, int enc) 72 { 73 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); 74 const struct p8_aes_cbc_ctx *ctx = crypto_skcipher_ctx(tfm); 75 struct skcipher_walk walk; 76 unsigned int nbytes; 77 int ret; 78 79 if (!crypto_simd_usable()) { 80 struct skcipher_request *subreq = skcipher_request_ctx(req); 81 82 *subreq = *req; 83 skcipher_request_set_tfm(subreq, ctx->fallback); 84 return enc ? crypto_skcipher_encrypt(subreq) : 85 crypto_skcipher_decrypt(subreq); 86 } 87 88 ret = skcipher_walk_virt(&walk, req, false); 89 while ((nbytes = walk.nbytes) != 0) { 90 preempt_disable(); 91 pagefault_disable(); 92 enable_kernel_vsx(); 93 aes_p8_cbc_encrypt(walk.src.virt.addr, 94 walk.dst.virt.addr, 95 round_down(nbytes, AES_BLOCK_SIZE), 96 enc ? &ctx->enc_key : &ctx->dec_key, 97 walk.iv, enc); 98 disable_kernel_vsx(); 99 pagefault_enable(); 100 preempt_enable(); 101 102 ret = skcipher_walk_done(&walk, nbytes % AES_BLOCK_SIZE); 103 } 104 return ret; 105 } 106 107 static int p8_aes_cbc_encrypt(struct skcipher_request *req) 108 { 109 return p8_aes_cbc_crypt(req, 1); 110 } 111 112 static int p8_aes_cbc_decrypt(struct skcipher_request *req) 113 { 114 return p8_aes_cbc_crypt(req, 0); 115 } 116 117 struct skcipher_alg p8_aes_cbc_alg = { 118 .base.cra_name = "cbc(aes)", 119 .base.cra_driver_name = "p8_aes_cbc", 120 .base.cra_module = THIS_MODULE, 121 .base.cra_priority = 2000, 122 .base.cra_flags = CRYPTO_ALG_NEED_FALLBACK, 123 .base.cra_blocksize = AES_BLOCK_SIZE, 124 .base.cra_ctxsize = sizeof(struct p8_aes_cbc_ctx), 125 .setkey = p8_aes_cbc_setkey, 126 .encrypt = p8_aes_cbc_encrypt, 127 .decrypt = p8_aes_cbc_decrypt, 128 .init = p8_aes_cbc_init, 129 .exit = p8_aes_cbc_exit, 130 .min_keysize = AES_MIN_KEY_SIZE, 131 .max_keysize = AES_MAX_KEY_SIZE, 132 .ivsize = AES_BLOCK_SIZE, 133 }; 134