From d257e858667f229f0f17420285dbb3354ee4f474 Mon Sep 17 00:00:00 2001 From: Guanjun Date: Wed, 23 Nov 2022 17:43:52 +0800 Subject: [PATCH] anolis: Rename ycc to alicc due to some tech adjustments ANBZ: #3246 The changes log includes: - file and directory name - configs in arch/x86/configs/anolis(-debug)_defconfig and arch/arm64/configs/anolis(-debug)_defconfig - variables name - Kconfig and Makefile - some annotates and print messages Signed-off-by: Guanjun --- arch/arm64/configs/anolis-debug_defconfig | 2 +- arch/arm64/configs/anolis_defconfig | 2 +- arch/x86/configs/anolis-debug_defconfig | 1 - arch/x86/configs/anolis_defconfig | 1 - drivers/crypto/Kconfig | 2 +- drivers/crypto/Makefile | 2 +- drivers/crypto/{ycc => alibaba/alicc}/Kconfig | 8 +- .../crypto/{ycc => alibaba/alicc}/Makefile | 8 +- .../ycc_aead.c => alibaba/alicc/alicc_aead.c} | 248 ++++---- .../ycc_algs.h => alibaba/alicc/alicc_algs.h} | 190 +++--- .../ycc_cdev.c => alibaba/alicc/alicc_cdev.c} | 38 +- .../ycc_cdev.h => alibaba/alicc/alicc_cdev.h} | 14 +- .../ycc_dev.h => alibaba/alicc/alicc_dev.h} | 116 ++-- .../ycc_drv.c => alibaba/alicc/alicc_drv.c} | 342 +++++------ .../ycc_isr.c => alibaba/alicc/alicc_isr.c} | 146 ++--- drivers/crypto/alibaba/alicc/alicc_isr.h | 12 + .../ycc_pke.c => alibaba/alicc/alicc_pke.c} | 364 ++++++------ .../ycc_ring.c => alibaba/alicc/alicc_ring.c} | 324 +++++----- .../ycc_ring.h => alibaba/alicc/alicc_ring.h} | 62 +- .../ycc_ske.c => alibaba/alicc/alicc_ske.c} | 562 +++++++++--------- .../ycc_uio.c => alibaba/alicc/alicc_uio.c} | 305 +++++----- .../ycc_uio.h => alibaba/alicc/alicc_uio.h} | 50 +- .../alicc}/sm2signature_asn1.c | 0 .../alicc}/sm2signature_asn1.h | 0 drivers/crypto/ycc/ycc_isr.h | 12 - 25 files changed, 1405 insertions(+), 1406 deletions(-) rename drivers/crypto/{ycc => alibaba/alicc}/Kconfig (60%) rename drivers/crypto/{ycc => alibaba/alicc}/Makefile (33%) rename drivers/crypto/{ycc/ycc_aead.c => alibaba/alicc/alicc_aead.c} (67%) rename drivers/crypto/{ycc/ycc_algs.h => alibaba/alicc/alicc_algs.h} (33%) rename drivers/crypto/{ycc/ycc_cdev.c => alibaba/alicc/alicc_cdev.c} (52%) rename drivers/crypto/{ycc/ycc_cdev.h => alibaba/alicc/alicc_cdev.h} (39%) rename drivers/crypto/{ycc/ycc_dev.h => alibaba/alicc/alicc_dev.h} (47%) rename drivers/crypto/{ycc/ycc_drv.c => alibaba/alicc/alicc_drv.c} (50%) rename drivers/crypto/{ycc/ycc_isr.c => alibaba/alicc/alicc_isr.c} (51%) create mode 100644 drivers/crypto/alibaba/alicc/alicc_isr.h rename drivers/crypto/{ycc/ycc_pke.c => alibaba/alicc/alicc_pke.c} (61%) rename drivers/crypto/{ycc/ycc_ring.c => alibaba/alicc/alicc_ring.c} (53%) rename drivers/crypto/{ycc/ycc_ring.h => alibaba/alicc/alicc_ring.h} (65%) rename drivers/crypto/{ycc/ycc_ske.c => alibaba/alicc/alicc_ske.c} (55%) rename drivers/crypto/{ycc/ycc_uio.c => alibaba/alicc/alicc_uio.c} (50%) rename drivers/crypto/{ycc/ycc_uio.h => alibaba/alicc/alicc_uio.h} (45%) rename drivers/crypto/{ycc => alibaba/alicc}/sm2signature_asn1.c (100%) rename drivers/crypto/{ycc => alibaba/alicc}/sm2signature_asn1.h (100%) delete mode 100644 drivers/crypto/ycc/ycc_isr.h diff --git a/arch/arm64/configs/anolis-debug_defconfig b/arch/arm64/configs/anolis-debug_defconfig index f0edb81e3036..afae220cf9db 100644 --- a/arch/arm64/configs/anolis-debug_defconfig +++ b/arch/arm64/configs/anolis-debug_defconfig @@ -5962,7 +5962,7 @@ CONFIG_CRYPTO_DEV_CHELSIO=m # CONFIG_CRYPTO_DEV_HISI_ZIP is not set # CONFIG_CRYPTO_DEV_HISI_HPRE is not set # CONFIG_CRYPTO_DEV_AMLOGIC_GXL is not set -CONFIG_CRYPTO_DEV_YCC=m +# CONFIG_CRYPTO_DEV_ALICC is not set CONFIG_ASYMMETRIC_KEY_TYPE=y CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE=y # CONFIG_ASYMMETRIC_TPM_KEY_SUBTYPE is not set diff --git a/arch/arm64/configs/anolis_defconfig b/arch/arm64/configs/anolis_defconfig index dea21eff90f0..23c32a16b578 100644 --- a/arch/arm64/configs/anolis_defconfig +++ b/arch/arm64/configs/anolis_defconfig @@ -5980,7 +5980,7 @@ CONFIG_CRYPTO_DEV_CHELSIO=m # CONFIG_CRYPTO_DEV_HISI_ZIP is not set # CONFIG_CRYPTO_DEV_HISI_HPRE is not set # CONFIG_CRYPTO_DEV_AMLOGIC_GXL is not set -CONFIG_CRYPTO_DEV_YCC=m +# CONFIG_CRYPTO_DEV_ALICC is not set CONFIG_ASYMMETRIC_KEY_TYPE=y CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE=y # CONFIG_ASYMMETRIC_TPM_KEY_SUBTYPE is not set diff --git a/arch/x86/configs/anolis-debug_defconfig b/arch/x86/configs/anolis-debug_defconfig index 9466347a34cd..cd94b3cf82df 100644 --- a/arch/x86/configs/anolis-debug_defconfig +++ b/arch/x86/configs/anolis-debug_defconfig @@ -6604,7 +6604,6 @@ CONFIG_CRYPTO_DEV_CHELSIO=m # CONFIG_CRYPTO_DEV_VIRTIO is not set # CONFIG_CRYPTO_DEV_SAFEXCEL is not set # CONFIG_CRYPTO_DEV_AMLOGIC_GXL is not set -# CONFIG_CRYPTO_DEV_YCC is not set CONFIG_ASYMMETRIC_KEY_TYPE=y CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE=y # CONFIG_ASYMMETRIC_TPM_KEY_SUBTYPE is not set diff --git a/arch/x86/configs/anolis_defconfig b/arch/x86/configs/anolis_defconfig index f073840a72b0..aa3e8904dbd1 100644 --- a/arch/x86/configs/anolis_defconfig +++ b/arch/x86/configs/anolis_defconfig @@ -6597,7 +6597,6 @@ CONFIG_CRYPTO_DEV_CHELSIO=m # CONFIG_CRYPTO_DEV_VIRTIO is not set # CONFIG_CRYPTO_DEV_SAFEXCEL is not set # CONFIG_CRYPTO_DEV_AMLOGIC_GXL is not set -# CONFIG_CRYPTO_DEV_YCC is not set CONFIG_ASYMMETRIC_KEY_TYPE=y CONFIG_ASYMMETRIC_PUBLIC_KEY_SUBTYPE=y # CONFIG_ASYMMETRIC_TPM_KEY_SUBTYPE is not set diff --git a/drivers/crypto/Kconfig b/drivers/crypto/Kconfig index 234e0d687cbf..6a36a9647532 100644 --- a/drivers/crypto/Kconfig +++ b/drivers/crypto/Kconfig @@ -885,7 +885,7 @@ source "drivers/crypto/hisilicon/Kconfig" source "drivers/crypto/amlogic/Kconfig" -source "drivers/crypto/ycc/Kconfig" +source "drivers/crypto/alibaba/alicc/Kconfig" config CRYPTO_DEV_SA2UL tristate "Support for TI security accelerator" diff --git a/drivers/crypto/Makefile b/drivers/crypto/Makefile index b54e898fb3eb..7f42076d7e5e 100644 --- a/drivers/crypto/Makefile +++ b/drivers/crypto/Makefile @@ -52,4 +52,4 @@ obj-$(CONFIG_CRYPTO_DEV_ARTPEC6) += axis/ obj-$(CONFIG_CRYPTO_DEV_ZYNQMP_AES) += xilinx/ obj-y += hisilicon/ obj-$(CONFIG_CRYPTO_DEV_AMLOGIC_GXL) += amlogic/ -obj-$(CONFIG_CRYPTO_DEV_YCC) += ycc/ +obj-$(CONFIG_CRYPTO_DEV_ALICC) += alibaba/alicc/ diff --git a/drivers/crypto/ycc/Kconfig b/drivers/crypto/alibaba/alicc/Kconfig similarity index 60% rename from drivers/crypto/ycc/Kconfig rename to drivers/crypto/alibaba/alicc/Kconfig index e22b51ee541a..2019ba9df814 100644 --- a/drivers/crypto/ycc/Kconfig +++ b/drivers/crypto/alibaba/alicc/Kconfig @@ -1,6 +1,6 @@ -config CRYPTO_DEV_YCC - tristate "Support for Alibaba YCC cryptographic accelerator" - depends on CRYPTO && CRYPTO_HW && PCI +config CRYPTO_DEV_ALICC + tristate "Support for Alibaba cryptographic accelerator" + depends on ARM64 && CRYPTO && CRYPTO_HW && PCI default n select CRYPTO_SKCIPHER select CRYPTO_LIB_DES @@ -13,5 +13,5 @@ config CRYPTO_DEV_YCC select CRYPTO_SM4 help Enables the driver for the on-chip cryptographic accelerator of - Alibaba Yitian SoCs which is based on ARMv9 architecture. + Alibaba SoCs which is based on ARMv9 architecture. If unsure say N. diff --git a/drivers/crypto/ycc/Makefile b/drivers/crypto/alibaba/alicc/Makefile similarity index 33% rename from drivers/crypto/ycc/Makefile rename to drivers/crypto/alibaba/alicc/Makefile index 9bced41a8cad..731222b9564f 100644 --- a/drivers/crypto/ycc/Makefile +++ b/drivers/crypto/alibaba/alicc/Makefile @@ -1,9 +1,9 @@ # SPDX-License-Identifier: GPL-2.0 -obj-(CONFIG_CRYPTO_DEV_YCC) += ycc.o -ycc-objs := ycc_drv.o ycc_isr.o ycc_cdev.o ycc_ring.o ycc_ske.o ycc_aead.o \ - ycc_pke.o sm2signature_asn1.o +obj-m += alicc.o +alicc-objs := alicc_drv.o alicc_isr.o alicc_cdev.o alicc_ring.o alicc_ske.o alicc_aead.o \ + alicc_pke.o sm2signature_asn1.o ifdef CONFIG_UIO -ycc-objs += ycc_uio.o +alicc-objs += alicc_uio.o ccflags-y += -DCONFIG_UIO endif diff --git a/drivers/crypto/ycc/ycc_aead.c b/drivers/crypto/alibaba/alicc/alicc_aead.c similarity index 67% rename from drivers/crypto/ycc/ycc_aead.c rename to drivers/crypto/alibaba/alicc/alicc_aead.c index 08877ad95c35..ae0f1af9e7f7 100644 --- a/drivers/crypto/ycc/ycc_aead.c +++ b/drivers/crypto/alibaba/alicc/alicc_aead.c @@ -7,12 +7,12 @@ #include #include #include -#include "ycc_algs.h" +#include "alicc_algs.h" -static int ycc_aead_init(struct crypto_aead *tfm) +static int alicc_aead_init(struct crypto_aead *tfm) { - struct ycc_crypto_ctx *ctx = crypto_aead_ctx(tfm); - struct ycc_ring *ring; + struct alicc_crypto_ctx *ctx = crypto_aead_ctx(tfm); + struct alicc_ring *ring; ctx->soft_tfm = crypto_alloc_aead(crypto_tfm_alg_name(crypto_aead_tfm(tfm)), 0, @@ -21,16 +21,16 @@ static int ycc_aead_init(struct crypto_aead *tfm) pr_warn("Failed to allocate soft tfm for:%s, software fallback is limited\n", crypto_tfm_alg_name(crypto_aead_tfm(tfm))); ctx->soft_tfm = NULL; - crypto_aead_set_reqsize(tfm, sizeof(struct ycc_crypto_req)); + crypto_aead_set_reqsize(tfm, sizeof(struct alicc_crypto_req)); } else { /* * If it's software fallback, store meta data of soft request. */ - crypto_aead_set_reqsize(tfm, sizeof(struct ycc_crypto_req) + + crypto_aead_set_reqsize(tfm, sizeof(struct alicc_crypto_req) + crypto_aead_reqsize(ctx->soft_tfm)); } - ring = ycc_crypto_get_ring(); + ring = alicc_crypto_get_ring(); if (!ring) return -ENOMEM; @@ -38,12 +38,12 @@ static int ycc_aead_init(struct crypto_aead *tfm) return 0; } -static void ycc_aead_exit(struct crypto_aead *tfm) +static void alicc_aead_exit(struct crypto_aead *tfm) { - struct ycc_crypto_ctx *ctx = crypto_aead_ctx(tfm); + struct alicc_crypto_ctx *ctx = crypto_aead_ctx(tfm); if (ctx->ring) - ycc_crypto_free_ring(ctx->ring); + alicc_crypto_free_ring(ctx->ring); kfree(ctx->cipher_key); @@ -51,28 +51,28 @@ static void ycc_aead_exit(struct crypto_aead *tfm) crypto_free_aead((struct crypto_aead *)ctx->soft_tfm); } -static int ycc_aead_setkey(struct crypto_aead *tfm, const u8 *key, +static int alicc_aead_setkey(struct crypto_aead *tfm, const u8 *key, unsigned int key_size) { - struct ycc_crypto_ctx *ctx = crypto_aead_ctx(tfm); + struct alicc_crypto_ctx *ctx = crypto_aead_ctx(tfm); const char *alg_name = crypto_tfm_alg_name(&tfm->base); if (!strncmp("gcm(sm4)", alg_name, strlen("gcm(sm4)"))) { if (key_size != SM4_KEY_SIZE) return -EINVAL; - ctx->mode = YCC_SM4_GCM; + ctx->mode = ALICC_SM4_GCM; } else if (!strncmp("ccm(sm4)", alg_name, strlen("ccm(sm4)"))) { - ctx->mode = YCC_SM4_CCM; + ctx->mode = ALICC_SM4_CCM; } else if (!strncmp("gcm(aes)", alg_name, strlen("gcm(aes)"))) { switch (key_size) { case AES_KEYSIZE_128: - ctx->mode = YCC_AES_128_GCM; + ctx->mode = ALICC_AES_128_GCM; break; case AES_KEYSIZE_192: - ctx->mode = YCC_AES_192_GCM; + ctx->mode = ALICC_AES_192_GCM; break; case AES_KEYSIZE_256: - ctx->mode = YCC_AES_256_GCM; + ctx->mode = ALICC_AES_256_GCM; break; default: return -EINVAL; @@ -80,13 +80,13 @@ static int ycc_aead_setkey(struct crypto_aead *tfm, const u8 *key, } else if (!strncmp("ccm(aes)", alg_name, strlen("ccm(aes)"))) { switch (key_size) { case AES_KEYSIZE_128: - ctx->mode = YCC_AES_128_CCM; + ctx->mode = ALICC_AES_128_CCM; break; case AES_KEYSIZE_192: - ctx->mode = YCC_AES_192_CCM; + ctx->mode = ALICC_AES_192_CCM; break; case AES_KEYSIZE_256: - ctx->mode = YCC_AES_256_CCM; + ctx->mode = ALICC_AES_256_CCM; break; default: return -EINVAL; @@ -111,10 +111,10 @@ static int ycc_aead_setkey(struct crypto_aead *tfm, const u8 *key, return 0; } -static int ycc_aead_fill_key(struct ycc_crypto_req *req) +static int alicc_aead_fill_key(struct alicc_crypto_req *req) { - struct ycc_crypto_ctx *ctx = req->ctx; - struct device *dev = YCC_DEV(ctx); + struct alicc_crypto_ctx *ctx = req->ctx; + struct device *dev = ALICC_DEV(ctx); struct aead_request *aead_req = req->aead_req; struct crypto_aead *tfm = crypto_aead_reqtfm(aead_req); const char *alg_name = crypto_tfm_alg_name(&tfm->base); @@ -138,9 +138,9 @@ static int ycc_aead_fill_key(struct ycc_crypto_req *req) return 0; } -static int ycc_aead_sg_map(struct ycc_crypto_req *req) +static int alicc_aead_sg_map(struct alicc_crypto_req *req) { - struct device *dev = YCC_DEV(req->ctx); + struct device *dev = ALICC_DEV(req->ctx); int ret = -ENOMEM; req->src_paddr = dma_map_single(dev, req->src_vaddr, @@ -163,39 +163,39 @@ static int ycc_aead_sg_map(struct ycc_crypto_req *req) return ret; } -static void ycc_aead_sg_unmap(struct ycc_crypto_req *req) +static void alicc_aead_sg_unmap(struct alicc_crypto_req *req) { - struct device *dev = YCC_DEV(req->ctx); + struct device *dev = ALICC_DEV(req->ctx); dma_unmap_single(dev, req->src_paddr, ALIGN(req->in_len, 64), DMA_TO_DEVICE); dma_free_coherent(dev, ALIGN(req->in_len, 64), req->dst_vaddr, req->dst_paddr); } -static inline void ycc_aead_unformat_data(struct ycc_crypto_req *req) +static inline void alicc_aead_unformat_data(struct alicc_crypto_req *req) { kfree(req->src_vaddr); } -static int ycc_aead_callback(void *ptr, u16 state) +static int alicc_aead_callback(void *ptr, u16 state) { - struct ycc_crypto_req *req = (struct ycc_crypto_req *)ptr; + struct alicc_crypto_req *req = (struct alicc_crypto_req *)ptr; struct aead_request *aead_req = req->aead_req; - struct ycc_crypto_ctx *ctx = req->ctx; + struct alicc_crypto_ctx *ctx = req->ctx; struct crypto_aead *tfm = crypto_aead_reqtfm(aead_req); int taglen = crypto_aead_authsize(tfm); - struct device *dev = YCC_DEV(ctx); + struct device *dev = ALICC_DEV(ctx); /* TODO: workaround for GCM/CCM with junk bytes between ctext and tag */ - if ((req->desc.cmd.aead_cmd.cmd_id == YCC_CMD_GCM_ENC || - req->desc.cmd.aead_cmd.cmd_id == YCC_CMD_CCM_ENC) && + if ((req->desc.cmd.aead_cmd.cmd_id == ALICC_CMD_GCM_ENC || + req->desc.cmd.aead_cmd.cmd_id == ALICC_CMD_CCM_ENC) && aead_req->cryptlen % 16 != 0) memcpy(req->dst_vaddr + aead_req->cryptlen, req->dst_vaddr + ALIGN(aead_req->cryptlen, 16), taglen); scatterwalk_map_and_copy(req->src_vaddr + req->aad_offset, aead_req->dst, 0, aead_req->assoclen, 1); - if (req->desc.cmd.aead_cmd.cmd_id == YCC_CMD_GCM_ENC || - req->desc.cmd.aead_cmd.cmd_id == YCC_CMD_CCM_ENC) { + if (req->desc.cmd.aead_cmd.cmd_id == ALICC_CMD_GCM_ENC || + req->desc.cmd.aead_cmd.cmd_id == ALICC_CMD_CCM_ENC) { scatterwalk_map_and_copy(req->dst_vaddr, aead_req->dst, aead_req->assoclen, aead_req->cryptlen + taglen, 1); @@ -205,8 +205,8 @@ static int ycc_aead_callback(void *ptr, u16 state) aead_req->cryptlen - taglen, 1); } - ycc_aead_sg_unmap(req); - ycc_aead_unformat_data(req); + alicc_aead_sg_unmap(req); + alicc_aead_unformat_data(req); if (req->key_vaddr) { memset(req->key_vaddr, 0, 64); dma_free_coherent(dev, 64, req->key_vaddr, req->key_paddr); @@ -221,7 +221,7 @@ static int ycc_aead_callback(void *ptr, u16 state) #define aead_blob_len(x, y, z) ALIGN(((x) + (y) + (z)), 16) -static void *__ycc_aead_format_data(struct ycc_crypto_req *req, u8 *b0, u8 *b1, +static void *__alicc_aead_format_data(struct alicc_crypto_req *req, u8 *b0, u8 *b1, int alen, u8 cmd) { struct aead_request *aead_req = req->aead_req; @@ -238,10 +238,10 @@ static void *__ycc_aead_format_data(struct ycc_crypto_req *req, u8 *b0, u8 *b1, b0_len = 16; size = aead_blob_len(b0_len, alen, aad_len); - if (cmd == YCC_CMD_GCM_DEC || cmd == YCC_CMD_CCM_DEC) { + if (cmd == ALICC_CMD_GCM_DEC || cmd == ALICC_CMD_CCM_DEC) { /* * LKCF format is not aligned |cipher_text|tag_text| - * while ycc request |16-align cipher_text|16-align tag_text| + * while alicc request |16-align cipher_text|16-align tag_text| */ src_len = cryptlen - taglen; size += ALIGN(src_len, 16) + ALIGN(taglen, 16); @@ -262,7 +262,7 @@ static void *__ycc_aead_format_data(struct ycc_crypto_req *req, u8 *b0, u8 *b1, scatterwalk_map_and_copy(vaddr + aead_blob_len(b0_len, alen, aad_len), aead_req->src, aad_len, src_len, 0); - if (cmd == YCC_CMD_GCM_DEC || cmd == YCC_CMD_CCM_DEC) + if (cmd == ALICC_CMD_GCM_DEC || cmd == ALICC_CMD_CCM_DEC) scatterwalk_map_and_copy(vaddr + aead_blob_len(b0_len, alen, aad_len) + ALIGN(src_len, 16), @@ -274,7 +274,7 @@ static void *__ycc_aead_format_data(struct ycc_crypto_req *req, u8 *b0, u8 *b1, return vaddr; } -static void *ycc_aead_format_ccm_data(struct ycc_crypto_req *req, +static void *alicc_aead_format_ccm_data(struct alicc_crypto_req *req, u16 *new_aad_len, u8 cmd) { struct aead_request *aead_req = req->aead_req; @@ -325,45 +325,45 @@ static void *ycc_aead_format_ccm_data(struct ycc_crypto_req *req, l = 4; else if (cryptlen > (1 << (8 * l))) return NULL; - if (cmd == YCC_CMD_CCM_DEC) + if (cmd == ALICC_CMD_CCM_DEC) msglen = cpu_to_be32(cryptlen - taglen); else msglen = cpu_to_be32(cryptlen); memcpy(&b0[16 - l], (u8 *)&msglen + 4 - l, l); - return __ycc_aead_format_data(req, b0, b1, alen, cmd); + return __alicc_aead_format_data(req, b0, b1, alen, cmd); } -static void *ycc_aead_format_data(struct ycc_crypto_req *req, u16 *new_aad_len, +static void *alicc_aead_format_data(struct alicc_crypto_req *req, u16 *new_aad_len, u32 *new_cryptlen, u8 cmd) { struct aead_request *aead_req = req->aead_req; struct crypto_aead *tfm = crypto_aead_reqtfm(aead_req); int taglen = crypto_aead_authsize(tfm); - if (cmd == YCC_CMD_GCM_ENC || cmd == YCC_CMD_GCM_DEC) { + if (cmd == ALICC_CMD_GCM_ENC || cmd == ALICC_CMD_GCM_DEC) { /* CCM */ *new_aad_len = aead_req->assoclen; *new_cryptlen = aead_req->cryptlen; req->out_len = *new_cryptlen + taglen; - return __ycc_aead_format_data(req, NULL, NULL, 0, cmd); + return __alicc_aead_format_data(req, NULL, NULL, 0, cmd); } /* GCM */ *new_cryptlen = ALIGN(aead_req->cryptlen, 16); req->out_len = *new_cryptlen + taglen; - return ycc_aead_format_ccm_data(req, new_aad_len, cmd); + return alicc_aead_format_ccm_data(req, new_aad_len, cmd); } /* - * This is workaround: If ycc output len is outlen % 64 == 16, it + * This is workaround: If alicc output len is outlen % 64 == 16, it * might hang. taglen is 16 or 0 */ -static inline bool ycc_aead_do_soft(struct aead_request *aead_req, int taglen) +static inline bool alicc_aead_do_soft(struct aead_request *aead_req, int taglen) { struct crypto_aead *tfm = crypto_aead_reqtfm(aead_req); - struct ycc_crypto_ctx *ctx = crypto_aead_ctx(tfm); - struct ycc_dev *ydev = ctx->ring->ydev; + struct alicc_crypto_ctx *ctx = crypto_aead_ctx(tfm); + struct alicc_dev *ydev = ctx->ring->ydev; if ((ALIGN(aead_req->cryptlen, 64) + taglen) % 64 == 16 || !test_bit(YDEV_STATUS_READY, &ydev->status)) @@ -372,12 +372,12 @@ static inline bool ycc_aead_do_soft(struct aead_request *aead_req, int taglen) return false; } -static int ycc_aead_submit_desc(struct aead_request *aead_req, u8 cmd) +static int alicc_aead_submit_desc(struct aead_request *aead_req, u8 cmd) { struct crypto_aead *tfm = crypto_aead_reqtfm(aead_req); - struct ycc_crypto_ctx *ctx = crypto_aead_ctx(tfm); - struct ycc_crypto_req *req = aead_request_ctx(aead_req); - struct ycc_flags *aflags; + struct alicc_crypto_ctx *ctx = crypto_aead_ctx(tfm); + struct alicc_crypto_req *req = aead_request_ctx(aead_req); + struct alicc_flags *aflags; int taglen = crypto_aead_authsize(tfm); u16 new_aad_len; u32 new_cryptlen; @@ -388,10 +388,10 @@ static int ycc_aead_submit_desc(struct aead_request *aead_req, u8 cmd) int ret = 0; /* - * ycc hw does not support gcm zero length plaintext. According to spec + * alicc hw does not support gcm zero length plaintext. According to spec * if cryptlen is 0, just do aes_encrypt against IV */ - if (aead_req->cryptlen == 0 && cmd == YCC_CMD_GCM_ENC) { + if (aead_req->cryptlen == 0 && cmd == ALICC_CMD_GCM_ENC) { ret = aes_expandkey(&aes_ctx, ctx->cipher_key, ctx->keysize); if (ret) return ret; @@ -404,7 +404,7 @@ static int ycc_aead_submit_desc(struct aead_request *aead_req, u8 cmd) return 0; } - if (aead_req->cryptlen == taglen && cmd == YCC_CMD_GCM_DEC) { + if (aead_req->cryptlen == taglen && cmd == ALICC_CMD_GCM_DEC) { ret = aes_expandkey(&aes_ctx, ctx->cipher_key, ctx->keysize); if (ret) return ret; @@ -423,32 +423,32 @@ static int ycc_aead_submit_desc(struct aead_request *aead_req, u8 cmd) req->ctx = ctx; req->aead_req = aead_req; - ret = ycc_aead_fill_key(req); + ret = alicc_aead_fill_key(req); if (ret) return ret; - req->src_vaddr = ycc_aead_format_data(req, &new_aad_len, &new_cryptlen, cmd); + req->src_vaddr = alicc_aead_format_data(req, &new_aad_len, &new_cryptlen, cmd); if (!req->src_vaddr) goto free_key; - ret = ycc_aead_sg_map(req); + ret = alicc_aead_sg_map(req); if (ret) goto unformat; ret = -ENOMEM; - aflags = kzalloc(sizeof(struct ycc_flags), GFP_ATOMIC); + aflags = kzalloc(sizeof(struct alicc_flags), GFP_ATOMIC); if (!aflags) goto sg_unmap; - memset(&req->desc.cmd, 0, sizeof(union ycc_real_cmd)); + memset(&req->desc.cmd, 0, sizeof(union alicc_real_cmd)); aflags->ptr = (void *)req; - aflags->ycc_done_callback = ycc_aead_callback; + aflags->alicc_done_callback = alicc_aead_callback; req->desc.private_ptr = (u64)aflags; req->desc.cmd.aead_cmd.cmd_id = cmd; req->desc.cmd.aead_cmd.mode = ctx->mode; req->desc.cmd.aead_cmd.sptr = req->src_paddr; req->desc.cmd.aead_cmd.dptr = req->dst_paddr; - if (cmd == YCC_CMD_GCM_DEC || cmd == YCC_CMD_CCM_DEC) + if (cmd == ALICC_CMD_GCM_DEC || cmd == ALICC_CMD_CCM_DEC) new_cryptlen = aead_req->cryptlen - taglen; req->desc.cmd.aead_cmd.dlen = new_cryptlen; req->desc.cmd.aead_cmd.keyptr = req->key_paddr; @@ -456,7 +456,7 @@ static int ycc_aead_submit_desc(struct aead_request *aead_req, u8 cmd) req->desc.cmd.aead_cmd.taglen = taglen; /* 4. submit desc to cmd queue */ - ret = ycc_enqueue(ctx->ring, &req->desc); + ret = alicc_enqueue(ctx->ring, &req->desc); if (!ret) return -EINPROGRESS; @@ -464,24 +464,24 @@ static int ycc_aead_submit_desc(struct aead_request *aead_req, u8 cmd) kfree(aflags); sg_unmap: - ycc_aead_sg_unmap(req); + alicc_aead_sg_unmap(req); unformat: - ycc_aead_unformat_data(req); + alicc_aead_unformat_data(req); free_key: memset(req->key_vaddr, 0, 64); - dma_free_coherent(YCC_DEV(ctx), 64, req->key_vaddr, req->key_paddr); + dma_free_coherent(ALICC_DEV(ctx), 64, req->key_vaddr, req->key_paddr); req->key_vaddr = NULL; return ret; } -static int ycc_aead_ccm_encrypt(struct aead_request *aead_req) +static int alicc_aead_ccm_encrypt(struct aead_request *aead_req) { struct crypto_aead *tfm = crypto_aead_reqtfm(aead_req); - struct ycc_crypto_ctx *ctx = crypto_aead_ctx(tfm); + struct alicc_crypto_ctx *ctx = crypto_aead_ctx(tfm); struct aead_request *subreq = - &((struct ycc_crypto_req *)aead_request_ctx(aead_req))->aead_subreq; + &((struct alicc_crypto_req *)aead_request_ctx(aead_req))->aead_subreq; - if (ycc_aead_do_soft(aead_req, 16)) { + if (alicc_aead_do_soft(aead_req, 16)) { if (!ctx->soft_tfm) return -ENOENT; aead_request_set_tfm(subreq, ctx->soft_tfm); @@ -494,17 +494,17 @@ static int ycc_aead_ccm_encrypt(struct aead_request *aead_req) return crypto_aead_encrypt(subreq); } - return ycc_aead_submit_desc(aead_req, YCC_CMD_CCM_ENC); + return alicc_aead_submit_desc(aead_req, ALICC_CMD_CCM_ENC); } -static int ycc_aead_gcm_encrypt(struct aead_request *aead_req) +static int alicc_aead_gcm_encrypt(struct aead_request *aead_req) { struct crypto_aead *tfm = crypto_aead_reqtfm(aead_req); - struct ycc_crypto_ctx *ctx = crypto_aead_ctx(tfm); + struct alicc_crypto_ctx *ctx = crypto_aead_ctx(tfm); struct aead_request *subreq = - &((struct ycc_crypto_req *)aead_request_ctx(aead_req))->aead_subreq; + &((struct alicc_crypto_req *)aead_request_ctx(aead_req))->aead_subreq; - if (ycc_aead_do_soft(aead_req, 16)) { + if (alicc_aead_do_soft(aead_req, 16)) { if (!ctx->soft_tfm) return -ENOENT; aead_request_set_tfm(subreq, ctx->soft_tfm); @@ -517,17 +517,17 @@ static int ycc_aead_gcm_encrypt(struct aead_request *aead_req) return crypto_aead_encrypt(subreq); } - return ycc_aead_submit_desc(aead_req, YCC_CMD_GCM_ENC); + return alicc_aead_submit_desc(aead_req, ALICC_CMD_GCM_ENC); } -static int ycc_aead_gcm_decrypt(struct aead_request *aead_req) +static int alicc_aead_gcm_decrypt(struct aead_request *aead_req) { struct crypto_aead *tfm = crypto_aead_reqtfm(aead_req); - struct ycc_crypto_ctx *ctx = crypto_aead_ctx(tfm); + struct alicc_crypto_ctx *ctx = crypto_aead_ctx(tfm); struct aead_request *subreq = - &((struct ycc_crypto_req *)aead_request_ctx(aead_req))->aead_subreq; + &((struct alicc_crypto_req *)aead_request_ctx(aead_req))->aead_subreq; - if (ycc_aead_do_soft(aead_req, 0)) { + if (alicc_aead_do_soft(aead_req, 0)) { if (!ctx->soft_tfm) return -ENOENT; aead_request_set_tfm(subreq, ctx->soft_tfm); @@ -540,17 +540,17 @@ static int ycc_aead_gcm_decrypt(struct aead_request *aead_req) return crypto_aead_decrypt(subreq); } - return ycc_aead_submit_desc(aead_req, YCC_CMD_GCM_DEC); + return alicc_aead_submit_desc(aead_req, ALICC_CMD_GCM_DEC); } -static int ycc_aead_ccm_decrypt(struct aead_request *aead_req) +static int alicc_aead_ccm_decrypt(struct aead_request *aead_req) { struct crypto_aead *tfm = crypto_aead_reqtfm(aead_req); - struct ycc_crypto_ctx *ctx = crypto_aead_ctx(tfm); + struct alicc_crypto_ctx *ctx = crypto_aead_ctx(tfm); struct aead_request *subreq = - &((struct ycc_crypto_req *)aead_request_ctx(aead_req))->aead_subreq; + &((struct alicc_crypto_req *)aead_request_ctx(aead_req))->aead_subreq; - if (ycc_aead_do_soft(aead_req, 0)) { + if (alicc_aead_do_soft(aead_req, 0)) { if (!ctx->soft_tfm) return -ENOENT; aead_request_set_tfm(subreq, ctx->soft_tfm); @@ -563,90 +563,90 @@ static int ycc_aead_ccm_decrypt(struct aead_request *aead_req) return crypto_aead_decrypt(subreq); } - return ycc_aead_submit_desc(aead_req, YCC_CMD_CCM_DEC); + return alicc_aead_submit_desc(aead_req, ALICC_CMD_CCM_DEC); } -static struct aead_alg ycc_aeads[] = { +static struct aead_alg alicc_aeads[] = { { .base = { .cra_name = "gcm(aes)", - .cra_driver_name = "gcm-aes-ycc", + .cra_driver_name = "gcm-aes-alicc", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = 1, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_aead_init, - .exit = ycc_aead_exit, - .setkey = ycc_aead_setkey, - .decrypt = ycc_aead_gcm_decrypt, - .encrypt = ycc_aead_gcm_encrypt, + .init = alicc_aead_init, + .exit = alicc_aead_exit, + .setkey = alicc_aead_setkey, + .decrypt = alicc_aead_gcm_decrypt, + .encrypt = alicc_aead_gcm_encrypt, .ivsize = AES_BLOCK_SIZE, .maxauthsize = AES_BLOCK_SIZE, }, { .base = { .cra_name = "gcm(sm4)", - .cra_driver_name = "gcm-sm4-ycc", + .cra_driver_name = "gcm-sm4-alicc", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = 1, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_aead_init, - .exit = ycc_aead_exit, - .setkey = ycc_aead_setkey, - .decrypt = ycc_aead_gcm_decrypt, - .encrypt = ycc_aead_gcm_encrypt, + .init = alicc_aead_init, + .exit = alicc_aead_exit, + .setkey = alicc_aead_setkey, + .decrypt = alicc_aead_gcm_decrypt, + .encrypt = alicc_aead_gcm_encrypt, .ivsize = SM4_BLOCK_SIZE, .maxauthsize = SM4_BLOCK_SIZE, }, { .base = { .cra_name = "ccm(aes)", - .cra_driver_name = "ccm-aes-ycc", + .cra_driver_name = "ccm-aes-alicc", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = 1, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_aead_init, - .exit = ycc_aead_exit, - .setkey = ycc_aead_setkey, - .decrypt = ycc_aead_ccm_decrypt, - .encrypt = ycc_aead_ccm_encrypt, + .init = alicc_aead_init, + .exit = alicc_aead_exit, + .setkey = alicc_aead_setkey, + .decrypt = alicc_aead_ccm_decrypt, + .encrypt = alicc_aead_ccm_encrypt, .ivsize = AES_BLOCK_SIZE, .maxauthsize = AES_BLOCK_SIZE, }, { .base = { .cra_name = "ccm(sm4)", - .cra_driver_name = "ccm-sm4-ycc", + .cra_driver_name = "ccm-sm4-alicc", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = 1, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_aead_init, - .exit = ycc_aead_exit, - .setkey = ycc_aead_setkey, - .decrypt = ycc_aead_ccm_decrypt, - .encrypt = ycc_aead_ccm_encrypt, + .init = alicc_aead_init, + .exit = alicc_aead_exit, + .setkey = alicc_aead_setkey, + .decrypt = alicc_aead_ccm_decrypt, + .encrypt = alicc_aead_ccm_encrypt, .ivsize = SM4_BLOCK_SIZE, .maxauthsize = SM4_BLOCK_SIZE, }, }; -int ycc_aead_register(void) +int alicc_aead_register(void) { - return crypto_register_aeads(ycc_aeads, ARRAY_SIZE(ycc_aeads)); + return crypto_register_aeads(alicc_aeads, ARRAY_SIZE(alicc_aeads)); } -void ycc_aead_unregister(void) +void alicc_aead_unregister(void) { - crypto_unregister_aeads(ycc_aeads, ARRAY_SIZE(ycc_aeads)); + crypto_unregister_aeads(alicc_aeads, ARRAY_SIZE(alicc_aeads)); } diff --git a/drivers/crypto/ycc/ycc_algs.h b/drivers/crypto/alibaba/alicc/alicc_algs.h similarity index 33% rename from drivers/crypto/ycc/ycc_algs.h rename to drivers/crypto/alibaba/alicc/alicc_algs.h index 26323a8a69bf..0858b67b1f00 100644 --- a/drivers/crypto/ycc/ycc_algs.h +++ b/drivers/crypto/alibaba/alicc/alicc_algs.h @@ -1,94 +1,94 @@ // SPDX-License-Identifier: GPL-2.0 -#ifndef __YCC_ALG_H -#define __YCC_ALG_H +#ifndef __ALICC_ALG_H +#define __ALICC_ALG_H #include #include -#include "ycc_ring.h" -#include "ycc_dev.h" +#include "alicc_ring.h" +#include "alicc_dev.h" -enum ycc_gcm_mode { - YCC_AES_128_GCM = 0, - YCC_AES_192_GCM, - YCC_AES_256_GCM, - YCC_SM4_GCM, +enum alicc_gcm_mode { + ALICC_AES_128_GCM = 0, + ALICC_AES_192_GCM, + ALICC_AES_256_GCM, + ALICC_SM4_GCM, }; -enum ycc_ccm_mode { - YCC_AES_128_CCM = 0, - YCC_AES_192_CCM, - YCC_AES_256_CCM, - YCC_SM4_CCM, +enum alicc_ccm_mode { + ALICC_AES_128_CCM = 0, + ALICC_AES_192_CCM, + ALICC_AES_256_CCM, + ALICC_SM4_CCM, }; -enum ycc_ske_alg_mode { - YCC_DES_ECB = 26, - YCC_DES_CBC, - YCC_DES_CFB, - YCC_DES_OFB, - YCC_DES_CTR, /* 30 */ - - YCC_TDES_128_ECB = 31, - YCC_TDES_128_CBC, - YCC_TDES_128_CFB, - YCC_TDES_128_OFB, - YCC_TDES_128_CTR, - YCC_TDES_192_ECB, - YCC_TDES_192_CBC, - YCC_TDES_192_CFB, - YCC_TDES_192_OFB, - YCC_TDES_192_CTR, /* 40 */ - - YCC_AES_128_ECB = 41, - YCC_AES_128_CBC, - YCC_AES_128_CFB, - YCC_AES_128_OFB, - YCC_AES_128_CTR, - YCC_AES_128_XTS, /* 46 */ - - YCC_AES_192_ECB = 48, - YCC_AES_192_CBC, - YCC_AES_192_CFB, - YCC_AES_192_OFB, - YCC_AES_192_CTR, /* 52 */ - - YCC_AES_256_ECB = 55, - YCC_AES_256_CBC, - YCC_AES_256_CFB, - YCC_AES_256_OFB, - YCC_AES_256_CTR, - YCC_AES_256_XTS, /* 60 */ - - YCC_SM4_ECB = 62, - YCC_SM4_CBC, - YCC_SM4_CFB, - YCC_SM4_OFB, - YCC_SM4_CTR, - YCC_SM4_XTS, /* 67 */ +enum alicc_ske_alg_mode { + ALICC_DES_ECB = 26, + ALICC_DES_CBC, + ALICC_DES_CFB, + ALICC_DES_OFB, + ALICC_DES_CTR, /* 30 */ + + ALICC_TDES_128_ECB = 31, + ALICC_TDES_128_CBC, + ALICC_TDES_128_CFB, + ALICC_TDES_128_OFB, + ALICC_TDES_128_CTR, + ALICC_TDES_192_ECB, + ALICC_TDES_192_CBC, + ALICC_TDES_192_CFB, + ALICC_TDES_192_OFB, + ALICC_TDES_192_CTR, /* 40 */ + + ALICC_AES_128_ECB = 41, + ALICC_AES_128_CBC, + ALICC_AES_128_CFB, + ALICC_AES_128_OFB, + ALICC_AES_128_CTR, + ALICC_AES_128_XTS, /* 46 */ + + ALICC_AES_192_ECB = 48, + ALICC_AES_192_CBC, + ALICC_AES_192_CFB, + ALICC_AES_192_OFB, + ALICC_AES_192_CTR, /* 52 */ + + ALICC_AES_256_ECB = 55, + ALICC_AES_256_CBC, + ALICC_AES_256_CFB, + ALICC_AES_256_OFB, + ALICC_AES_256_CTR, + ALICC_AES_256_XTS, /* 60 */ + + ALICC_SM4_ECB = 62, + ALICC_SM4_CBC, + ALICC_SM4_CFB, + ALICC_SM4_OFB, + ALICC_SM4_CTR, + ALICC_SM4_XTS, /* 67 */ }; -enum ycc_cmd_id { - YCC_CMD_SKE_ENC = 0x23, - YCC_CMD_SKE_DEC, +enum alicc_cmd_id { + ALICC_CMD_SKE_ENC = 0x23, + ALICC_CMD_SKE_DEC, - YCC_CMD_GCM_ENC = 0x25, - YCC_CMD_GCM_DEC, - YCC_CMD_CCM_ENC, - YCC_CMD_CCM_DEC, /* 0x28 */ + ALICC_CMD_GCM_ENC = 0x25, + ALICC_CMD_GCM_DEC, + ALICC_CMD_CCM_ENC, + ALICC_CMD_CCM_DEC, /* 0x28 */ - YCC_CMD_SM2_VERIFY = 0x47, + ALICC_CMD_SM2_VERIFY = 0x47, - YCC_CMD_RSA_ENC = 0x83, - YCC_CMD_RSA_DEC, - YCC_CMD_RSA_CRT_DEC, - YCC_CMD_RSA_CRT_SIGN, - YCC_CMD_RSA_SIGN, - YCC_CMD_RSA_VERIFY, /* 0x88 */ + ALICC_CMD_RSA_ENC = 0x83, + ALICC_CMD_RSA_DEC, + ALICC_CMD_RSA_CRT_DEC, + ALICC_CMD_RSA_CRT_SIGN, + ALICC_CMD_RSA_SIGN, + ALICC_CMD_RSA_VERIFY, /* 0x88 */ }; -struct ycc_crypto_ctx { - struct ycc_ring *ring; +struct alicc_crypto_ctx { + struct alicc_ring *ring; void *soft_tfm; u32 keysize; @@ -99,14 +99,14 @@ struct ycc_crypto_ctx { u8 reserved[4]; }; -struct ycc_crypto_req { +struct alicc_crypto_req { int mapped_src_nents; int mapped_dst_nents; void *key_vaddr; dma_addr_t key_paddr; - struct ycc_cmd_desc desc; + struct alicc_cmd_desc desc; union { struct skcipher_request *ske_req; struct aead_request *aead_req; @@ -120,7 +120,7 @@ struct ycc_crypto_req { int in_len; int out_len; int aad_offset; - struct ycc_crypto_ctx *ctx; + struct alicc_crypto_ctx *ctx; u8 last_block[16]; /* used to store iv out when decrypt */ /* soft request for fallback, keep at the end */ @@ -130,14 +130,14 @@ struct ycc_crypto_req { }; }; -#define YCC_RSA_KEY_SZ_512 64 -#define YCC_RSA_KEY_SZ_1536 192 -#define YCC_RSA_CRT_PARAMS 5 -#define YCC_RSA_E_SZ_MAX 8 -#define YCC_CMD_DATA_ALIGN_SZ 64 -#define YCC_PIN_SZ 16 +#define ALICC_RSA_KEY_SZ_512 64 +#define ALICC_RSA_KEY_SZ_1536 192 +#define ALICC_RSA_CRT_PARAMS 5 +#define ALICC_RSA_E_SZ_MAX 8 +#define ALICC_CMD_DATA_ALIGN_SZ 64 +#define ALICC_PIN_SZ 16 -struct ycc_pke_ctx { +struct alicc_pke_ctx { struct rsa_key *rsa_key; void *priv_key_vaddr; @@ -148,29 +148,29 @@ struct ycc_pke_ctx { unsigned int key_len; unsigned int e_len; bool crt_mode; - struct ycc_ring *ring; + struct alicc_ring *ring; struct crypto_akcipher *soft_tfm; }; -struct ycc_pke_req { +struct alicc_pke_req { void *src_vaddr; dma_addr_t src_paddr; void *dst_vaddr; dma_addr_t dst_paddr; - struct ycc_cmd_desc desc; + struct alicc_cmd_desc desc; union { - struct ycc_pke_ctx *ctx; + struct alicc_pke_ctx *ctx; }; struct akcipher_request *req; }; -#define YCC_DEV(ctx) (&(ctx)->ring->ydev->pdev->dev) +#define ALICC_DEV(ctx) (&(ctx)->ring->ydev->pdev->dev) -int ycc_sym_register(void); -void ycc_sym_unregister(void); -int ycc_aead_register(void); -void ycc_aead_unregister(void); -int ycc_pke_register(void); -void ycc_pke_unregister(void); +int alicc_sym_register(void); +void alicc_sym_unregister(void); +int alicc_aead_register(void); +void alicc_aead_unregister(void); +int alicc_pke_register(void); +void alicc_pke_unregister(void); #endif diff --git a/drivers/crypto/ycc/ycc_cdev.c b/drivers/crypto/alibaba/alicc/alicc_cdev.c similarity index 52% rename from drivers/crypto/ycc/ycc_cdev.c rename to drivers/crypto/alibaba/alicc/alicc_cdev.c index 94f165738ae4..0b9c0857037f 100644 --- a/drivers/crypto/ycc/ycc_cdev.c +++ b/drivers/crypto/alibaba/alicc/alicc_cdev.c @@ -5,61 +5,61 @@ #include #include #include -#include "ycc_cdev.h" +#include "alicc_cdev.h" -static struct ycc_cdev ycdev; +static struct alicc_cdev ycdev; -static int ycc_cdev_open(struct inode *inode, struct file *filp) +static int alicc_cdev_open(struct inode *inode, struct file *filp) { return 0; } -static int ycc_cdev_release(struct inode *inode, struct file *filp) +static int alicc_cdev_release(struct inode *inode, struct file *filp) { return 0; } -static long ycc_cdev_ioctl(struct file *filp, unsigned int cmd, +static long alicc_cdev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { return 0; } -static const struct file_operations ycc_fops = { - .open = ycc_cdev_open, - .release = ycc_cdev_release, - .unlocked_ioctl = ycc_cdev_ioctl, +static const struct file_operations alicc_fops = { + .open = alicc_cdev_open, + .release = alicc_cdev_release, + .unlocked_ioctl = alicc_cdev_ioctl, }; -int ycc_cdev_register(void) +int alicc_cdev_register(void) { struct device *device; int ret; - ret = alloc_chrdev_region(&ycdev.devno, 0, 1, YCC_CDEV_NAME); + ret = alloc_chrdev_region(&ycdev.devno, 0, 1, ALICC_CDEV_NAME); if (ret) { - pr_err("Failed to alloc ycc cdev region\n"); + pr_err("Failed to alloc alicc cdev region\n"); return ret; } - ycdev.class = class_create(THIS_MODULE, YCC_CDEV_NAME); + ycdev.class = class_create(THIS_MODULE, ALICC_CDEV_NAME); if (IS_ERR(ycdev.class)) { - pr_err("Failed to create ycc cdev class\n"); + pr_err("Failed to create alicc cdev class\n"); ret = PTR_ERR(ycdev.class); goto unregister_region; } - cdev_init(&ycdev.cdev, &ycc_fops); + cdev_init(&ycdev.cdev, &alicc_fops); ret = cdev_add(&ycdev.cdev, ycdev.devno, 1); if (ret) { - pr_err("Failed to add ycc cdev\n"); + pr_err("Failed to add alicc cdev\n"); goto destroy_class; } device = device_create(ycdev.class, NULL, ycdev.devno, - NULL, YCC_CDEV_NAME); + NULL, ALICC_CDEV_NAME); if (IS_ERR(device)) { - pr_err("Failed to create ycc cdev device\n"); + pr_err("Failed to create alicc cdev device\n"); ret = PTR_ERR(device); goto del_cdev; } @@ -74,7 +74,7 @@ int ycc_cdev_register(void) return ret; } -void ycc_cdev_unregister(void) +void alicc_cdev_unregister(void) { device_destroy(ycdev.class, ycdev.devno); cdev_del(&ycdev.cdev); diff --git a/drivers/crypto/ycc/ycc_cdev.h b/drivers/crypto/alibaba/alicc/alicc_cdev.h similarity index 39% rename from drivers/crypto/ycc/ycc_cdev.h rename to drivers/crypto/alibaba/alicc/alicc_cdev.h index 6f6ca48c34fc..08cea953e464 100644 --- a/drivers/crypto/ycc/ycc_cdev.h +++ b/drivers/crypto/alibaba/alicc/alicc_cdev.h @@ -1,18 +1,18 @@ // SPDX-License-Identifier: GPL-2.0 -#ifndef __YCC_CDEV_H -#define __YCC_CDEV_H +#ifndef __ALICC_CDEV_H +#define __ALICC_CDEV_H #include -#include "ycc_dev.h" +#include "alicc_dev.h" -#define YCC_CDEV_NAME "ycc_dev_ctrl" +#define ALICC_CDEV_NAME "alicc_dev_ctrl" -struct ycc_cdev { +struct alicc_cdev { dev_t devno; struct class *class; struct cdev cdev; }; -int ycc_cdev_register(void); -void ycc_cdev_unregister(void); +int alicc_cdev_register(void); +void alicc_cdev_unregister(void); #endif diff --git a/drivers/crypto/ycc/ycc_dev.h b/drivers/crypto/alibaba/alicc/alicc_dev.h similarity index 47% rename from drivers/crypto/ycc/ycc_dev.h rename to drivers/crypto/alibaba/alicc/alicc_dev.h index a34126820373..3f306457f219 100644 --- a/drivers/crypto/ycc/ycc_dev.h +++ b/drivers/crypto/alibaba/alicc/alicc_dev.h @@ -1,17 +1,17 @@ /* SPDX-License-Identifier: GPL-2.0 */ -#ifndef __YCC_DEV_H -#define __YCC_DEV_H +#ifndef __ALICC_DEV_H +#define __ALICC_DEV_H #include #include -#define YCC_MAX_DEBUGFS_NAME 20 +#define ALICC_MAX_DEBUGFS_NAME 20 -#define PCI_VENDOR_ID_YCC 0x1DED +#define PCI_VENDOR_ID_ALICC 0x1DED #define PCI_DEVICE_ID_RCEC 0x8003 #define PCI_DEVICE_ID_RCIEP 0x8001 -#define YCC_RINGPAIR_NUM 48 -#define YCC_IRQS (YCC_RINGPAIR_NUM + 1) +#define ALICC_RINGPAIR_NUM 48 +#define ALICC_IRQS (ALICC_RINGPAIR_NUM + 1) #define RING_STOP_BIT BIT(15) #define RING_CFG_RING_SZ GENMASK(2, 0) @@ -19,29 +19,29 @@ #define RING_ERR_AXI BIT(0) #define RING_PENDING_CNT GENMASK(9, 0) -#define YCC_SEC_CFG_BAR 0 -#define YCC_NSEC_CFG_BAR 1 -#define YCC_SEC_Q_BAR 2 -#define YCC_NSEC_Q_BAR 3 - -/* ycc secure configuration register offset */ -#define REG_YCC_CTL 0x18 -#define REG_YCC_GO 0x50 -#define REG_YCC_HCLK_INT_STATUS 0x54 -#define REG_YCC_XCLK_INT_STATUS 0x58 -#define REG_YCC_XCLK_MEM_ECC_EN_0 0x5c -#define REG_YCC_XCLK_MEM_ECC_EN_1 0x60 -#define REG_YCC_XCLK_MEM_ECC_COR_0 0x74 -#define REG_YCC_XCLK_MEM_ECC_COR_1 0x78 -#define REG_YCC_XCLK_MEM_ECC_UNCOR_0 0x80 -#define REG_YCC_XCLK_MEM_ECC_UNCOR_1 0x84 -#define REG_YCC_HCLK_MEM_ECC_EN 0x88 -#define REG_YCC_HCLK_MEM_ECC_COR 0x94 -#define REG_YCC_HCLK_MEM_ECC_UNCOR 0x98 - -#define REG_YCC_DEV_INT_MASK 0xA4 -#define REG_YCC_HCLK_INT_MASK 0xE4 -#define REG_YCC_XCLK_INT_MASK 0xE8 +#define ALICC_SEC_CFG_BAR 0 +#define ALICC_NSEC_CFG_BAR 1 +#define ALICC_SEC_Q_BAR 2 +#define ALICC_NSEC_Q_BAR 3 + +/* alicc secure configuration register offset */ +#define REG_ALICC_CTL 0x18 +#define REG_ALICC_GO 0x50 +#define REG_ALICC_HCLK_INT_STATUS 0x54 +#define REG_ALICC_XCLK_INT_STATUS 0x58 +#define REG_ALICC_XCLK_MEM_ECC_EN_0 0x5c +#define REG_ALICC_XCLK_MEM_ECC_EN_1 0x60 +#define REG_ALICC_XCLK_MEM_ECC_COR_0 0x74 +#define REG_ALICC_XCLK_MEM_ECC_COR_1 0x78 +#define REG_ALICC_XCLK_MEM_ECC_UNCOR_0 0x80 +#define REG_ALICC_XCLK_MEM_ECC_UNCOR_1 0x84 +#define REG_ALICC_HCLK_MEM_ECC_EN 0x88 +#define REG_ALICC_HCLK_MEM_ECC_COR 0x94 +#define REG_ALICC_HCLK_MEM_ECC_UNCOR 0x98 + +#define REG_ALICC_DEV_INT_MASK 0xA4 +#define REG_ALICC_HCLK_INT_MASK 0xE4 +#define REG_ALICC_XCLK_INT_MASK 0xE8 /* ring register offset */ #define REG_RING_CMD_BASE_ADDR_LO 0x00 @@ -59,18 +59,18 @@ #define REG_RING_RSP_WR_SHADOWN_PTR 0x30 #define REG_RING_RSP_AFULL_TH 0x34 -#define YCC_HCLK_AHB_ERR BIT(0) -#define YCC_HCLK_SHIELD_ERR BIT(1) -#define YCC_HCLK_TRNG_ERR BIT(2) -#define YCC_HCLK_EFUSE_ERR BIT(3) -#define YCC_HCLK_INIT_ERR GENMASK(30, 16) -#define YCC_HCLK_CB_TRNG_ERR BIT(31) +#define ALICC_HCLK_AHB_ERR BIT(0) +#define ALICC_HCLK_SHIELD_ERR BIT(1) +#define ALICC_HCLK_TRNG_ERR BIT(2) +#define ALICC_HCLK_EFUSE_ERR BIT(3) +#define ALICC_HCLK_INIT_ERR GENMASK(30, 16) +#define ALICC_HCLK_CB_TRNG_ERR BIT(31) -#define YCC_CTRL_IRAM_EN BIT(1) -#define YCC_CTRL_SEC_EN BIT(3) +#define ALICC_CTRL_IRAM_EN BIT(1) +#define ALICC_CTRL_SEC_EN BIT(3) -#define YCC_GO_PWRON BIT(0) -#define YCC_GO_ENABLED BIT(1) +#define ALICC_GO_PWRON BIT(0) +#define ALICC_GO_ENABLED BIT(1) #define PCI_EXR_DEVCTL_TRP BIT(21) #define PCI_EXP_DEVCTL_FLREN BIT(15) @@ -82,18 +82,18 @@ #define YDEV_STATUS_ERR 4 #define YDEV_STATUS_SRIOV 5 -struct ycc_bar { +struct alicc_bar { void __iomem *vaddr; resource_size_t paddr; resource_size_t size; }; -enum ycc_dev_type { - YCC_RCIEP, - YCC_RCEC, +enum alicc_dev_type { + ALICC_RCIEP, + ALICC_RCEC, }; -struct ycc_dev { +struct alicc_dev { u8 type; bool is_vf; int id; @@ -101,8 +101,8 @@ struct ycc_dev { const char *dev_name; struct list_head list; struct pci_dev *pdev; - struct ycc_bar ycc_bars[4]; - struct ycc_dev *assoc_dev; + struct alicc_bar alicc_bars[4]; + struct alicc_dev *assoc_dev; int max_desc; int user_rings; @@ -110,7 +110,7 @@ struct ycc_dev { unsigned long status; struct workqueue_struct *dev_err_q; char err_irq_name[32]; - struct ycc_ring *rings; + struct alicc_ring *rings; struct work_struct work; char *msi_name[48]; struct dentry *debug_dir; @@ -119,39 +119,39 @@ struct ycc_dev { bool enable_vf; }; -#define YCC_CSR_WR(csr_base, csr_offset, val) \ +#define ALICC_CSR_WR(csr_base, csr_offset, val) \ __raw_writel(val, csr_base + csr_offset) -#define YCC_CSR_RD(csr_base, csr_offset) \ +#define ALICC_CSR_RD(csr_base, csr_offset) \ __raw_readl(csr_base + csr_offset) -static inline void ycc_dev_get(struct ycc_dev *ydev) +static inline void alicc_dev_get(struct alicc_dev *ydev) { atomic_inc(&ydev->refcnt); } -static inline void ycc_dev_put(struct ycc_dev *ydev) +static inline void alicc_dev_put(struct alicc_dev *ydev) { atomic_dec(&ydev->refcnt); } -static inline bool ycc_dev_in_use(struct ycc_dev *ydev) +static inline bool alicc_dev_in_use(struct alicc_dev *ydev) { return atomic_read(&ydev->refcnt) > 0; } -static inline void ycc_g_err_mask(void *vaddr) +static inline void alicc_g_err_mask(void *vaddr) { /* This will mask all error interrupt */ - YCC_CSR_WR(vaddr, REG_YCC_DEV_INT_MASK, (u32)~0); + ALICC_CSR_WR(vaddr, REG_ALICC_DEV_INT_MASK, (u32)~0); } -static inline void ycc_g_err_unmask(void *vaddr) +static inline void alicc_g_err_unmask(void *vaddr) { /* This will unmask all error interrupt */ - YCC_CSR_WR(vaddr, REG_YCC_DEV_INT_MASK, 0); + ALICC_CSR_WR(vaddr, REG_ALICC_DEV_INT_MASK, 0); } -int ycc_algorithm_register(void); -void ycc_algorithm_unregister(void); +int alicc_algorithm_register(void); +void alicc_algorithm_unregister(void); #endif diff --git a/drivers/crypto/ycc/ycc_drv.c b/drivers/crypto/alibaba/alicc/alicc_drv.c similarity index 50% rename from drivers/crypto/ycc/ycc_drv.c rename to drivers/crypto/alibaba/alicc/alicc_drv.c index 1592209d22c6..2e3d5c5d1a14 100644 --- a/drivers/crypto/ycc/ycc_drv.c +++ b/drivers/crypto/alibaba/alicc/alicc_drv.c @@ -1,8 +1,8 @@ // SPDX-License-Identifier: GPL-2.0 /* - * YCC: Drivers for Alibaba YCC (Yitian Cryptography Complex) cryptographic - * accelerator. Enables the on-chip cryptographic accelerator of Alibaba - * Yitian SoCs which is based on ARMv9 architecture. + * ALICC: Drivers for Alibaba cryptographic accelerator. Enables the + * on-chip cryptographic accelerator of Alibaba SoCs which is + * based on ARMv9 architecture. * * Copyright (C) 2020-2022 Alibaba Corporation. All rights reserved. * Author: Zelin Deng @@ -20,13 +20,13 @@ #include #include -#include "ycc_isr.h" -#include "ycc_cdev.h" -#include "ycc_ring.h" -#include "ycc_algs.h" -#include "ycc_uio.h" +#include "alicc_isr.h" +#include "alicc_cdev.h" +#include "alicc_ring.h" +#include "alicc_algs.h" +#include "alicc_uio.h" -static const char ycc_name[] = "ycc"; +static const char alicc_name[] = "alicc"; static int max_desc = 256; static int user_rings; @@ -35,68 +35,68 @@ module_param(max_desc, int, 0644); module_param(is_polling, bool, 0644); module_param(user_rings, int, 0644); -atomic_t ycc_algs_refcnt; +atomic_t alicc_algs_refcnt; -LIST_HEAD(ycc_table); -DEFINE_MUTEX(ycc_mutex); +LIST_HEAD(alicc_table); +DEFINE_MUTEX(alicc_mutex); /* - * Each ycc device (RCIEP or RCEC) supports upto 48 VFs + * Each alicc device (RCIEP or RCEC) supports upto 48 VFs * when enables SR-IOV. So each socket has 98 devices, * includes 2 PFs and 96 VFs. */ -#define YCC_MAX_DEVICES (98 * 4) /* Assume 4 sockets */ -static DEFINE_IDR(ycc_idr); +#define ALICC_MAX_DEVICES (98 * 4) /* Assume 4 sockets */ +static DEFINE_IDR(alicc_idr); -int ycc_algorithm_register(void) +int alicc_algorithm_register(void) { int ret = 0; /* No kernel rings */ - if (user_rings == YCC_RINGPAIR_NUM) + if (user_rings == ALICC_RINGPAIR_NUM) return ret; /* Only register once */ - if (atomic_inc_return(&ycc_algs_refcnt) > 1) + if (atomic_inc_return(&alicc_algs_refcnt) > 1) return ret; - ret = ycc_sym_register(); + ret = alicc_sym_register(); if (ret) goto err; - ret = ycc_aead_register(); + ret = alicc_aead_register(); if (ret) goto unregister_sym; - ret = ycc_pke_register(); + ret = alicc_pke_register(); if (ret) goto unregister_aead; return 0; unregister_aead: - ycc_aead_unregister(); + alicc_aead_unregister(); unregister_sym: - ycc_sym_unregister(); + alicc_sym_unregister(); err: - atomic_dec(&ycc_algs_refcnt); + atomic_dec(&alicc_algs_refcnt); return ret; } -void ycc_algorithm_unregister(void) +void alicc_algorithm_unregister(void) { - if (user_rings == YCC_RINGPAIR_NUM) + if (user_rings == ALICC_RINGPAIR_NUM) return; - if (atomic_dec_return(&ycc_algs_refcnt)) + if (atomic_dec_return(&alicc_algs_refcnt)) return; - ycc_pke_unregister(); - ycc_aead_unregister(); - ycc_sym_unregister(); + alicc_pke_unregister(); + alicc_aead_unregister(); + alicc_sym_unregister(); } -static int ycc_device_flr(struct pci_dev *pdev, struct pci_dev *rcec_pdev) +static int alicc_device_flr(struct pci_dev *pdev, struct pci_dev *rcec_pdev) { int ret; @@ -108,13 +108,13 @@ static int ycc_device_flr(struct pci_dev *pdev, struct pci_dev *rcec_pdev) */ ret = pci_save_state(pdev); if (ret) { - pr_err("Failed to save ycc pci state\n"); + pr_err("Failed to save alicc pci state\n"); return ret; } ret = pci_save_state(rcec_pdev); if (ret) { - pr_err("Failed to save ycc rcec pci state\n"); + pr_err("Failed to save alicc rcec pci state\n"); return ret; } @@ -130,15 +130,15 @@ static int ycc_device_flr(struct pci_dev *pdev, struct pci_dev *rcec_pdev) return 0; } -static int ycc_resource_setup(struct ycc_dev *ydev) +static int alicc_resource_setup(struct alicc_dev *ydev) { struct pci_dev *rcec_pdev = ydev->assoc_dev->pdev; struct pci_dev *pdev = ydev->pdev; - struct ycc_bar *abar, *cfg_bar; + struct alicc_bar *abar, *cfg_bar; u32 hclk_status; int ret; - ret = ycc_device_flr(pdev, rcec_pdev); + ret = alicc_device_flr(pdev, rcec_pdev); if (ret) return ret; @@ -149,38 +149,38 @@ static int ycc_resource_setup(struct ycc_dev *ydev) } ret = -EIO; - cfg_bar = &ydev->ycc_bars[YCC_SEC_CFG_BAR]; - cfg_bar->paddr = pci_resource_start(pdev, YCC_SEC_CFG_BAR); - cfg_bar->size = pci_resource_len(pdev, YCC_SEC_CFG_BAR); + cfg_bar = &ydev->alicc_bars[ALICC_SEC_CFG_BAR]; + cfg_bar->paddr = pci_resource_start(pdev, ALICC_SEC_CFG_BAR); + cfg_bar->size = pci_resource_len(pdev, ALICC_SEC_CFG_BAR); cfg_bar->vaddr = ioremap(cfg_bar->paddr, cfg_bar->size); if (!cfg_bar->vaddr) { pr_err("Failed to ioremap rciep cfg bar\n"); goto release_mem_regions; } - ycc_g_err_mask(cfg_bar->vaddr); + alicc_g_err_mask(cfg_bar->vaddr); - YCC_CSR_WR(cfg_bar->vaddr, REG_YCC_CTL, 0|YCC_CTRL_IRAM_EN); - YCC_CSR_WR(cfg_bar->vaddr, REG_YCC_GO, 0|YCC_GO_PWRON); + ALICC_CSR_WR(cfg_bar->vaddr, REG_ALICC_CTL, 0|ALICC_CTRL_IRAM_EN); + ALICC_CSR_WR(cfg_bar->vaddr, REG_ALICC_GO, 0|ALICC_GO_PWRON); - /* Waiting for ycc firmware ready, 1000ms is recommended by the HW designers */ + /* Waiting for alicc firmware ready, 1000ms is recommended by the HW designers */ mdelay(1000); - if (!(YCC_CSR_RD(cfg_bar->vaddr, REG_YCC_GO) & YCC_GO_ENABLED)) { - pr_err("Failed to set ycc enabled\n"); + if (!(ALICC_CSR_RD(cfg_bar->vaddr, REG_ALICC_GO) & ALICC_GO_ENABLED)) { + pr_err("Failed to set alicc enabled\n"); goto iounmap_cfg_bar; } /* Check HCLK int status reg, some error happened at PWRON stage */ - hclk_status = YCC_CSR_RD(cfg_bar->vaddr, REG_YCC_HCLK_INT_STATUS); - if (hclk_status & YCC_HCLK_INIT_ERR) { - pr_err("Error happened when ycc was initializing\n"); + hclk_status = ALICC_CSR_RD(cfg_bar->vaddr, REG_ALICC_HCLK_INT_STATUS); + if (hclk_status & ALICC_HCLK_INIT_ERR) { + pr_err("Error happened when alicc was initializing\n"); goto iounmap_cfg_bar; } - abar = &ydev->ycc_bars[YCC_NSEC_Q_BAR]; - abar->paddr = pci_resource_start(pdev, YCC_NSEC_Q_BAR); - abar->size = pci_resource_len(pdev, YCC_NSEC_Q_BAR); - abar->vaddr = pci_iomap(pdev, YCC_NSEC_Q_BAR, abar->size); + abar = &ydev->alicc_bars[ALICC_NSEC_Q_BAR]; + abar->paddr = pci_resource_start(pdev, ALICC_NSEC_Q_BAR); + abar->size = pci_resource_len(pdev, ALICC_NSEC_Q_BAR); + abar->vaddr = pci_iomap(pdev, ALICC_NSEC_Q_BAR, abar->size); if (!abar->vaddr) { pr_err("Failed to ioremap rciep queue bar\n"); goto iounmap_cfg_bar; @@ -194,42 +194,42 @@ static int ycc_resource_setup(struct ycc_dev *ydev) goto iounmap_queue_bar; } - ret = ycc_dev_rings_init(ydev, max_desc, user_rings); + ret = alicc_dev_rings_init(ydev, max_desc, user_rings); if (ret) { - pr_err("Failed to init ycc rings\n"); + pr_err("Failed to init alicc rings\n"); goto iounmap_queue_bar; } - ret = ycc_enable_msix(ydev); + ret = alicc_enable_msix(ydev); if (ret <= 0) { - pr_err("Failed to enable ycc msix, ret:%d\n", ret); + pr_err("Failed to enable alicc msix, ret:%d\n", ret); ret = (ret == 0) ? -EINVAL : ret; goto release_rings; } - ret = ycc_init_global_err(ydev); + ret = alicc_init_global_err(ydev); if (ret) { - pr_err("Failed to enable ycc global err\n"); + pr_err("Failed to enable alicc global err\n"); goto disable_msix; } - ret = ycc_alloc_irqs(ydev); + ret = alicc_alloc_irqs(ydev); if (ret) { - pr_err("Failed to alloc ycc irqs\n"); + pr_err("Failed to alloc alicc irqs\n"); goto deinit_g_err; } - YCC_CSR_WR(cfg_bar->vaddr, REG_YCC_HCLK_INT_STATUS, ~0); - ycc_g_err_unmask(cfg_bar->vaddr); + ALICC_CSR_WR(cfg_bar->vaddr, REG_ALICC_HCLK_INT_STATUS, ~0); + alicc_g_err_unmask(cfg_bar->vaddr); return 0; deinit_g_err: - ycc_deinit_global_err(ydev); + alicc_deinit_global_err(ydev); disable_msix: - ycc_disable_msix(ydev); + alicc_disable_msix(ydev); release_rings: - ycc_dev_rings_release(ydev, user_rings); + alicc_dev_rings_release(ydev, user_rings); iounmap_queue_bar: iounmap(abar->vaddr); iounmap_cfg_bar: @@ -240,35 +240,35 @@ static int ycc_resource_setup(struct ycc_dev *ydev) return ret; } -static void ycc_resource_free(struct ycc_dev *ydev) +static void alicc_resource_free(struct alicc_dev *ydev) { - ycc_deinit_global_err(ydev); - ycc_free_irqs(ydev); - ycc_disable_msix(ydev); - ycc_dev_rings_release(ydev, ydev->user_rings); - iounmap(ydev->ycc_bars[YCC_SEC_CFG_BAR].vaddr); - iounmap(ydev->ycc_bars[YCC_NSEC_Q_BAR].vaddr); + alicc_deinit_global_err(ydev); + alicc_free_irqs(ydev); + alicc_disable_msix(ydev); + alicc_dev_rings_release(ydev, ydev->user_rings); + iounmap(ydev->alicc_bars[ALICC_SEC_CFG_BAR].vaddr); + iounmap(ydev->alicc_bars[ALICC_NSEC_Q_BAR].vaddr); pci_release_regions(ydev->pdev); } -static inline bool ycc_rcec_match(struct pci_dev *pdev0, struct pci_dev *pdev1) +static inline bool alicc_rcec_match(struct pci_dev *pdev0, struct pci_dev *pdev1) { return pdev0->bus->number == pdev1->bus->number; } -static int ycc_rcec_bind(struct ycc_dev *ydev) +static int alicc_rcec_bind(struct alicc_dev *ydev) { - struct ycc_dev *assoc_dev, *rciep, *rcec; + struct alicc_dev *assoc_dev, *rciep, *rcec; struct list_head *itr; int ret = 0; - if (list_empty(&ycc_table)) + if (list_empty(&alicc_table)) goto out; - list_for_each(itr, &ycc_table) { - assoc_dev = list_entry(itr, struct ycc_dev, list); + list_for_each(itr, &alicc_table) { + assoc_dev = list_entry(itr, struct alicc_dev, list); /* not in the same pci bus */ - if (!ycc_rcec_match(ydev->pdev, assoc_dev->pdev)) + if (!alicc_rcec_match(ydev->pdev, assoc_dev->pdev)) continue; /* if sriov is enabled, it could be the same */ @@ -289,20 +289,20 @@ static int ycc_rcec_bind(struct ycc_dev *ydev) ydev->assoc_dev = assoc_dev; assoc_dev->assoc_dev = ydev; - rciep = (ydev->type == YCC_RCIEP) ? ydev : ydev->assoc_dev; + rciep = (ydev->type == ALICC_RCIEP) ? ydev : ydev->assoc_dev; rcec = rciep->assoc_dev; ret = sysfs_create_link(&rcec->pdev->dev.kobj, - &rciep->pdev->dev.kobj, "ycc_rciep"); + &rciep->pdev->dev.kobj, "alicc_rciep"); if (ret) goto out; ret = sysfs_create_link(&rciep->pdev->dev.kobj, - &rcec->pdev->dev.kobj, "ycc_rcec"); + &rcec->pdev->dev.kobj, "alicc_rcec"); if (ret) goto remove_rciep_link; - ret = ycc_resource_setup(rciep); + ret = alicc_resource_setup(rciep); if (ret) goto remove_rcec_link; @@ -316,103 +316,103 @@ static int ycc_rcec_bind(struct ycc_dev *ydev) return ret; remove_rcec_link: - sysfs_remove_link(&rciep->pdev->dev.kobj, "ycc_rcec"); + sysfs_remove_link(&rciep->pdev->dev.kobj, "alicc_rcec"); remove_rciep_link: - sysfs_remove_link(&rcec->pdev->dev.kobj, "ycc_rciep"); + sysfs_remove_link(&rcec->pdev->dev.kobj, "alicc_rciep"); out: return ret; } -static void ycc_rcec_unbind(struct ycc_dev *ydev) +static void alicc_rcec_unbind(struct alicc_dev *ydev) { - struct ycc_dev *rciep, *rcec; + struct alicc_dev *rciep, *rcec; if (!test_bit(YDEV_STATUS_BIND, &ydev->status)) return; - rciep = (ydev->type == YCC_RCIEP) ? ydev : ydev->assoc_dev; + rciep = (ydev->type == ALICC_RCIEP) ? ydev : ydev->assoc_dev; rcec = rciep->assoc_dev; clear_bit(YDEV_STATUS_READY, &rciep->status); clear_bit(YDEV_STATUS_READY, &rcec->status); clear_bit(YDEV_STATUS_BIND, &rciep->status); clear_bit(YDEV_STATUS_BIND, &rcec->status); - sysfs_remove_link(&rcec->pdev->dev.kobj, "ycc_rciep"); - sysfs_remove_link(&rciep->pdev->dev.kobj, "ycc_rcec"); - ycc_resource_free(rciep); + sysfs_remove_link(&rcec->pdev->dev.kobj, "alicc_rciep"); + sysfs_remove_link(&rciep->pdev->dev.kobj, "alicc_rcec"); + alicc_resource_free(rciep); rciep->assoc_dev = NULL; rcec->assoc_dev = NULL; - ycc_algorithm_unregister(); + alicc_algorithm_unregister(); } -static int ycc_dev_add(struct ycc_dev *ydev) +static int alicc_dev_add(struct alicc_dev *ydev) { int ret; - mutex_lock(&ycc_mutex); - ret = ycc_rcec_bind(ydev); + mutex_lock(&alicc_mutex); + ret = alicc_rcec_bind(ydev); if (ret) goto out; - list_add_tail(&ydev->list, &ycc_table); + list_add_tail(&ydev->list, &alicc_table); out: - mutex_unlock(&ycc_mutex); + mutex_unlock(&alicc_mutex); return ret; } -static void ycc_dev_del(struct ycc_dev *ydev) +static void alicc_dev_del(struct alicc_dev *ydev) { - mutex_lock(&ycc_mutex); - ycc_rcec_unbind(ydev); + mutex_lock(&alicc_mutex); + alicc_rcec_unbind(ydev); list_del(&ydev->list); - mutex_unlock(&ycc_mutex); + mutex_unlock(&alicc_mutex); } -static inline int ycc_rciep_init(struct ycc_dev *ydev, struct pci_dev *pdev) +static inline int alicc_rciep_init(struct alicc_dev *ydev, struct pci_dev *pdev) { - char name[YCC_MAX_DEBUGFS_NAME + 1]; + char name[ALICC_MAX_DEBUGFS_NAME + 1]; int idr; ydev->sec = false; - ydev->dev_name = ycc_name; + ydev->dev_name = alicc_name; ydev->user_rings = user_rings; ydev->max_desc = max_desc; ydev->is_polling = is_polling; - idr = idr_alloc(&ycc_idr, ydev, 0, YCC_MAX_DEVICES, GFP_KERNEL); + idr = idr_alloc(&alicc_idr, ydev, 0, ALICC_MAX_DEVICES, GFP_KERNEL); if (idr < 0) { - pr_err("Failed to allocate idr for ycc device\n"); + pr_err("Failed to allocate idr for alicc device\n"); return idr; } ydev->id = idr; - snprintf(name, YCC_MAX_DEBUGFS_NAME, "ycc_%02x:%02d.%02d", + snprintf(name, ALICC_MAX_DEBUGFS_NAME, "alicc_%02x:%02d.%02d", pdev->bus->number, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn)); ydev->debug_dir = debugfs_create_dir(name, NULL); /* If failed to create debugfs, driver can still work */ if (IS_ERR_OR_NULL(ydev->debug_dir)) { - pr_warn("Failed to create debugfs for ycc device\n"); + pr_warn("Failed to create debugfs for alicc device\n"); ydev->debug_dir = NULL; } return 0; } -static int ycc_drv_probe(struct pci_dev *pdev, const struct pci_device_id *id) +static int alicc_drv_probe(struct pci_dev *pdev, const struct pci_device_id *id) { - struct ycc_dev *ydev; + struct alicc_dev *ydev; struct device *dev = &pdev->dev; int node = dev_to_node(dev); int ret = -ENOMEM; - ydev = kzalloc_node(sizeof(struct ycc_dev), GFP_KERNEL, node); + ydev = kzalloc_node(sizeof(struct alicc_dev), GFP_KERNEL, node); if (!ydev) return ret; ret = pci_enable_device(pdev); if (ret) { - pr_err("Failed to enable ycc pci device\n"); + pr_err("Failed to enable alicc pci device\n"); goto free_ydev; } pci_set_master(pdev); @@ -423,29 +423,29 @@ static int ycc_drv_probe(struct pci_dev *pdev, const struct pci_device_id *id) ydev->enable_vf = false; ydev->node = node; if (id->device == PCI_DEVICE_ID_RCIEP) { - ydev->type = YCC_RCIEP; - ret = ycc_rciep_init(ydev, pdev); + ydev->type = ALICC_RCIEP; + ret = alicc_rciep_init(ydev, pdev); if (ret) goto disable_ydev; } else { - ydev->type = YCC_RCEC; + ydev->type = ALICC_RCEC; } - ret = ycc_dev_add(ydev); + ret = alicc_dev_add(ydev); if (ret) goto remove_debugfs; - if (ydev->type == YCC_RCIEP) { - /* TODO: add dev refcnt in ycc bind iommu domain */ - ret = ycc_bind_iommu_domain(pdev, ydev->id); + if (ydev->type == ALICC_RCIEP) { + /* TODO: add dev refcnt in alicc bind iommu domain */ + ret = alicc_bind_iommu_domain(pdev, ydev->id); if (ret) { - pr_err("Failed to bind iommu domain for ycc pci device\n"); + pr_err("Failed to bind iommu domain for alicc pci device\n"); goto dev_del; } } if (test_bit(YDEV_STATUS_READY, &ydev->status)) { - ret = ycc_algorithm_register(); + ret = alicc_algorithm_register(); if (ret) { pr_err("Failed to register algorithm\n"); clear_bit(YDEV_STATUS_READY, &ydev->status); @@ -457,32 +457,32 @@ static int ycc_drv_probe(struct pci_dev *pdev, const struct pci_device_id *id) return ret; unbind_domain: - if (ydev->type == YCC_RCIEP) - ycc_unbind_iommu_domain(pdev, ydev->id); + if (ydev->type == ALICC_RCIEP) + alicc_unbind_iommu_domain(pdev, ydev->id); dev_del: - ycc_dev_del(ydev); + alicc_dev_del(ydev); remove_debugfs: - if (ydev->type == YCC_RCIEP) { + if (ydev->type == ALICC_RCIEP) { debugfs_remove_recursive(ydev->debug_dir); - idr_remove(&ycc_idr, ydev->id); + idr_remove(&alicc_idr, ydev->id); } disable_ydev: pci_disable_device(pdev); free_ydev: - pr_err("Failed to probe :%s\n", ydev->type == YCC_RCIEP ? "rciep" : "rcec"); + pr_err("Failed to probe :%s\n", ydev->type == ALICC_RCIEP ? "rciep" : "rcec"); kfree(ydev); return ret; } -static void ycc_drv_remove(struct pci_dev *pdev) +static void alicc_drv_remove(struct pci_dev *pdev) { - struct ycc_dev *ydev = pci_get_drvdata(pdev); + struct alicc_dev *ydev = pci_get_drvdata(pdev); - ycc_dev_del(ydev); - if (ydev->type == YCC_RCIEP) { - ycc_unbind_iommu_domain(pdev, ydev->id); + alicc_dev_del(ydev); + if (ydev->type == ALICC_RCIEP) { + alicc_unbind_iommu_domain(pdev, ydev->id); debugfs_remove_recursive(ydev->debug_dir); - idr_remove(&ycc_idr, ydev->id); + idr_remove(&alicc_idr, ydev->id); } pci_disable_sriov(pdev); @@ -490,15 +490,15 @@ static void ycc_drv_remove(struct pci_dev *pdev) kfree(ydev); } -static int ycc_drv_sriov_configure(struct pci_dev *pdev, int numvfs) +static int alicc_drv_sriov_configure(struct pci_dev *pdev, int numvfs) { const int totalvfs = pci_sriov_get_totalvfs(pdev); - struct ycc_dev *ydev = pci_get_drvdata(pdev); - struct ycc_dev *rciep = NULL; + struct alicc_dev *ydev = pci_get_drvdata(pdev); + struct alicc_dev *rciep = NULL; int ret = 0; if (!ydev) { - pr_err("Failed to find ycc device\n"); + pr_err("Failed to find alicc device\n"); return -EFAULT; } @@ -518,22 +518,22 @@ static int ycc_drv_sriov_configure(struct pci_dev *pdev, int numvfs) * Before enabling SR-IOV, RCIEP and RCEC should been unbound */ if (test_bit(YDEV_STATUS_BIND, &ydev->status)) { - rciep = (ydev->type == YCC_RCIEP) ? ydev : ydev->assoc_dev; + rciep = (ydev->type == ALICC_RCIEP) ? ydev : ydev->assoc_dev; - if (ycc_dev_in_use(rciep)) { + if (alicc_dev_in_use(rciep)) { pr_info("Ycc is being used\n"); return -EBUSY; } - ycc_rcec_unbind(ydev); + alicc_rcec_unbind(ydev); } ret = pci_enable_sriov(pdev, totalvfs); if (ret) { - pr_err("Failed to enable ycc sriov\n"); - ret = ycc_rcec_bind(ydev); + pr_err("Failed to enable alicc sriov\n"); + ret = alicc_rcec_bind(ydev); if (ret) { - pr_err("Failed to rebind ycc\n"); + pr_err("Failed to rebind alicc\n"); return ret; } return -EIO; @@ -548,7 +548,7 @@ static int ycc_drv_sriov_configure(struct pci_dev *pdev, int numvfs) * and notify vf that we are going to disable SR-IOV */ pci_disable_sriov(pdev); - ycc_rcec_bind(ydev); + alicc_rcec_bind(ydev); ydev->enable_vf = false; clear_bit(YDEV_STATUS_SRIOV, &ydev->status); @@ -557,62 +557,62 @@ static int ycc_drv_sriov_configure(struct pci_dev *pdev, int numvfs) return ret; } -static const struct pci_device_id ycc_id_table[] = { - { PCI_DEVICE(PCI_VENDOR_ID_YCC, PCI_DEVICE_ID_RCIEP) }, - { PCI_DEVICE(PCI_VENDOR_ID_YCC, PCI_DEVICE_ID_RCEC) }, +static const struct pci_device_id alicc_id_table[] = { + { PCI_DEVICE(PCI_VENDOR_ID_ALICC, PCI_DEVICE_ID_RCIEP) }, + { PCI_DEVICE(PCI_VENDOR_ID_ALICC, PCI_DEVICE_ID_RCEC) }, { 0, } }; -MODULE_DEVICE_TABLE(pci, ycc_id_table); - -static struct pci_driver ycc_driver = { - .name = "ycc", - .id_table = ycc_id_table, - .probe = ycc_drv_probe, - .remove = ycc_drv_remove, - .sriov_configure = ycc_drv_sriov_configure, +MODULE_DEVICE_TABLE(pci, alicc_id_table); + +static struct pci_driver alicc_driver = { + .name = "alicc", + .id_table = alicc_id_table, + .probe = alicc_drv_probe, + .remove = alicc_drv_remove, + .sriov_configure = alicc_drv_sriov_configure, }; -static int __init ycc_drv_init(void) +static int __init alicc_drv_init(void) { int ret; - if (user_rings > YCC_RINGPAIR_NUM) - user_rings = YCC_RINGPAIR_NUM; + if (user_rings > ALICC_RINGPAIR_NUM) + user_rings = ALICC_RINGPAIR_NUM; - atomic_set(&ycc_algs_refcnt, 0); + atomic_set(&alicc_algs_refcnt, 0); - ret = ycc_udma_init(); + ret = alicc_udma_init(); if (ret) goto err; - ret = ycc_cdev_register(); + ret = alicc_cdev_register(); if (ret) goto udma_exit; - ret = pci_register_driver(&ycc_driver); + ret = pci_register_driver(&alicc_driver); if (ret) goto cdev_unregister; return 0; udma_exit: - ycc_udma_exit(); + alicc_udma_exit(); cdev_unregister: - ycc_cdev_unregister(); + alicc_cdev_unregister(); err: return ret; } -static void __exit ycc_drv_exit(void) +static void __exit alicc_drv_exit(void) { - ycc_cdev_unregister(); - pci_unregister_driver(&ycc_driver); - ycc_udma_exit(); + alicc_cdev_unregister(); + pci_unregister_driver(&alicc_driver); + alicc_udma_exit(); } -module_init(ycc_drv_init); -module_exit(ycc_drv_exit); +module_init(alicc_drv_init); +module_exit(alicc_drv_exit); MODULE_AUTHOR("Zelin Deng "); MODULE_AUTHOR("Guanjun "); MODULE_LICENSE("GPL v2"); -MODULE_DESCRIPTION("Driver for Alibaba YCC cryptographic accelerator"); +MODULE_DESCRIPTION("Driver for Alibaba cryptographic accelerator"); diff --git a/drivers/crypto/ycc/ycc_isr.c b/drivers/crypto/alibaba/alicc/alicc_isr.c similarity index 51% rename from drivers/crypto/ycc/ycc_isr.c rename to drivers/crypto/alibaba/alicc/alicc_isr.c index 04920d313545..1aa6f3c87d35 100644 --- a/drivers/crypto/ycc/ycc_isr.c +++ b/drivers/crypto/alibaba/alicc/alicc_isr.c @@ -7,29 +7,29 @@ #include #include -#include "ycc_isr.h" -#include "ycc_dev.h" -#include "ycc_ring.h" +#include "alicc_isr.h" +#include "alicc_dev.h" +#include "alicc_ring.h" -extern void ycc_clear_cmd_ring(struct ycc_ring *ring); -extern void ycc_clear_resp_ring(struct ycc_ring *ring); +extern void alicc_clear_cmd_ring(struct alicc_ring *ring); +extern void alicc_clear_resp_ring(struct alicc_ring *ring); -static irqreturn_t ycc_resp_isr(int irq, void *data) +static irqreturn_t alicc_resp_isr(int irq, void *data) { - struct ycc_ring *ring = (struct ycc_ring *)data; + struct alicc_ring *ring = (struct alicc_ring *)data; schedule_work(&ring->work); return IRQ_HANDLED; } -static int ycc_send_uevent(struct ycc_dev *ydev, const char *event) +static int alicc_send_uevent(struct alicc_dev *ydev, const char *event) { char *envp[3]; char *dev_id; int ret; - dev_id = kasprintf(GFP_ATOMIC, "YCC_DEVID=%d", ydev->id); + dev_id = kasprintf(GFP_ATOMIC, "ALICC_DEVID=%d", ydev->id); if (!dev_id) return -ENOMEM; @@ -39,86 +39,86 @@ static int ycc_send_uevent(struct ycc_dev *ydev, const char *event) ret = kobject_uevent_env(&ydev->pdev->dev.kobj, KOBJ_CHANGE, envp); if (ret) - pr_err("Failed to send uevent for ycc:%d\n", ydev->id); + pr_err("Failed to send uevent for alicc:%d\n", ydev->id); kfree(dev_id); return ret; } -static void ycc_fatal_error(struct ycc_dev *ydev) +static void alicc_fatal_error(struct alicc_dev *ydev) { - struct ycc_ring *ring; + struct alicc_ring *ring; int i; - for (i = 0; i < YCC_RINGPAIR_NUM; i++) { + for (i = 0; i < ALICC_RINGPAIR_NUM; i++) { ring = ydev->rings + i; if (ring->type != KERN_RING) continue; spin_lock_bh(&ring->lock); - ycc_clear_cmd_ring(ring); + alicc_clear_cmd_ring(ring); spin_unlock_bh(&ring->lock); - ycc_clear_resp_ring(ring); + alicc_clear_resp_ring(ring); } /* * After all rings had been cleared, we should notify - * user space that ycc has fatal error + * user space that alicc has fatal error */ - ycc_send_uevent(ydev, "YCC_STATUS=fatal"); + alicc_send_uevent(ydev, "ALICC_STATUS=fatal"); } -static void ycc_process_global_err(struct work_struct *work) +static void alicc_process_global_err(struct work_struct *work) { - struct ycc_dev *ydev = container_of(work, struct ycc_dev, work); - struct ycc_bar *cfg_bar = &ydev->ycc_bars[YCC_SEC_CFG_BAR]; - struct ycc_ring *ring; + struct alicc_dev *ydev = container_of(work, struct alicc_dev, work); + struct alicc_bar *cfg_bar = &ydev->alicc_bars[ALICC_SEC_CFG_BAR]; + struct alicc_ring *ring; u32 hclk_err, xclk_err; u32 xclk_ecc_uncor_err_0, xclk_ecc_uncor_err_1; u32 hclk_ecc_uncor_err; int i; if (pci_wait_for_pending_transaction(ydev->pdev)) - pr_warn("YCC: Failed to pending transaction\n"); + pr_warn("ALICC: Failed to pending transaction\n"); - /* Notify user space YCC is in error handling */ - ycc_send_uevent(ydev, "YCC_STATUS=stopped"); + /* Notify user space ALICC is in error handling */ + alicc_send_uevent(ydev, "ALICC_STATUS=stopped"); - hclk_err = YCC_CSR_RD(cfg_bar->vaddr, REG_YCC_HCLK_INT_STATUS); - xclk_err = YCC_CSR_RD(cfg_bar->vaddr, REG_YCC_XCLK_INT_STATUS); - xclk_ecc_uncor_err_0 = YCC_CSR_RD(cfg_bar->vaddr, REG_YCC_XCLK_MEM_ECC_UNCOR_0); - xclk_ecc_uncor_err_1 = YCC_CSR_RD(cfg_bar->vaddr, REG_YCC_XCLK_MEM_ECC_UNCOR_1); - hclk_ecc_uncor_err = YCC_CSR_RD(cfg_bar->vaddr, REG_YCC_HCLK_MEM_ECC_UNCOR); + hclk_err = ALICC_CSR_RD(cfg_bar->vaddr, REG_ALICC_HCLK_INT_STATUS); + xclk_err = ALICC_CSR_RD(cfg_bar->vaddr, REG_ALICC_XCLK_INT_STATUS); + xclk_ecc_uncor_err_0 = ALICC_CSR_RD(cfg_bar->vaddr, REG_ALICC_XCLK_MEM_ECC_UNCOR_0); + xclk_ecc_uncor_err_1 = ALICC_CSR_RD(cfg_bar->vaddr, REG_ALICC_XCLK_MEM_ECC_UNCOR_1); + hclk_ecc_uncor_err = ALICC_CSR_RD(cfg_bar->vaddr, REG_ALICC_HCLK_MEM_ECC_UNCOR); - if ((hclk_err & ~(YCC_HCLK_TRNG_ERR)) || xclk_err || hclk_ecc_uncor_err) { - pr_err("YCC: Got uncorrected error, must be reset\n"); + if ((hclk_err & ~(ALICC_HCLK_TRNG_ERR)) || xclk_err || hclk_ecc_uncor_err) { + pr_err("ALICC: Got uncorrected error, must be reset\n"); /* - * Fatal error, as YCC cannot be reset in REE, clear ring data. + * Fatal error, as ALICC cannot be reset in REE, clear ring data. */ - return ycc_fatal_error(ydev); + return alicc_fatal_error(ydev); } if (xclk_ecc_uncor_err_0 || xclk_ecc_uncor_err_1) { - pr_err("YCC: Got algorithm ECC error: %x ,%x\n", + pr_err("ALICC: Got algorithm ECC error: %x ,%x\n", xclk_ecc_uncor_err_0, xclk_ecc_uncor_err_1); - return ycc_fatal_error(ydev); + return alicc_fatal_error(ydev); } /* This has to be queue error. Handling command rings. */ - for (i = 0; i < YCC_RINGPAIR_NUM; i++) { + for (i = 0; i < ALICC_RINGPAIR_NUM; i++) { ring = ydev->rings + i; if (ring->type != KERN_RING) continue; - ring->status = YCC_CSR_RD(ring->csr_vaddr, REG_RING_STATUS); + ring->status = ALICC_CSR_RD(ring->csr_vaddr, REG_RING_STATUS); if (ring->status) { - pr_err("YCC: Dev: %d, Ring: %d got ring err: %x\n", + pr_err("ALICC: Dev: %d, Ring: %d got ring err: %x\n", ydev->id, ring->ring_id, ring->status); spin_lock_bh(&ring->lock); - ycc_clear_cmd_ring(ring); + alicc_clear_cmd_ring(ring); spin_unlock_bh(&ring->lock); } } @@ -130,101 +130,101 @@ static void ycc_process_global_err(struct work_struct *work) pci_set_master(ydev->pdev); /* Handling response rings. */ - for (i = 0; i < YCC_RINGPAIR_NUM; i++) { + for (i = 0; i < ALICC_RINGPAIR_NUM; i++) { ring = ydev->rings + i; if (ring->type != KERN_RING || !ring->status) continue; - ycc_clear_resp_ring(ring); + alicc_clear_resp_ring(ring); } - ycc_g_err_unmask(cfg_bar->vaddr); + alicc_g_err_unmask(cfg_bar->vaddr); clear_bit(YDEV_STATUS_ERR, &ydev->status); set_bit(YDEV_STATUS_READY, &ydev->status); - ycc_send_uevent(ydev, "YCC_STATUS=ready"); + alicc_send_uevent(ydev, "ALICC_STATUS=ready"); } -static irqreturn_t ycc_g_err_isr(int irq, void *data) +static irqreturn_t alicc_g_err_isr(int irq, void *data) { - struct ycc_dev *ydev = (struct ycc_dev *)data; - struct ycc_bar *cfg_bar; + struct alicc_dev *ydev = (struct alicc_dev *)data; + struct alicc_bar *cfg_bar; if (test_and_set_bit(YDEV_STATUS_ERR, &ydev->status)) return IRQ_HANDLED; /* Mask global errors until it has been processed */ - cfg_bar = &ydev->ycc_bars[YCC_SEC_CFG_BAR]; - ycc_g_err_mask(cfg_bar->vaddr); + cfg_bar = &ydev->alicc_bars[ALICC_SEC_CFG_BAR]; + alicc_g_err_mask(cfg_bar->vaddr); clear_bit(YDEV_STATUS_READY, &ydev->status); - /* Disable YCC mastering, no new transactions */ + /* Disable ALICC mastering, no new transactions */ pci_clear_master(ydev->pdev); schedule_work(&ydev->work); return IRQ_HANDLED; } -void ycc_resp_work_process(struct work_struct *work) +void alicc_resp_work_process(struct work_struct *work) { - struct ycc_ring *ring = container_of(work, struct ycc_ring, work); + struct alicc_ring *ring = container_of(work, struct alicc_ring, work); - ycc_dequeue(ring); + alicc_dequeue(ring); if (ring->ydev->is_polling) schedule_work(work); } -int ycc_enable_msix(struct ycc_dev *ydev) +int alicc_enable_msix(struct alicc_dev *ydev) { struct pci_dev *rcec_pdev = ydev->assoc_dev->pdev; /* Disable intx explicitly */ - return pci_alloc_irq_vectors(rcec_pdev, YCC_IRQS, YCC_IRQS, PCI_IRQ_MSIX); + return pci_alloc_irq_vectors(rcec_pdev, ALICC_IRQS, ALICC_IRQS, PCI_IRQ_MSIX); } -void ycc_disable_msix(struct ycc_dev *ydev) +void alicc_disable_msix(struct alicc_dev *ydev) { struct pci_dev *rcec_pdev = ydev->assoc_dev->pdev; pci_free_irq_vectors(rcec_pdev); } -static int ycc_setup_global_err_workqueue(struct ycc_dev *ydev) +static int alicc_setup_global_err_workqueue(struct alicc_dev *ydev) { char name[32] = {0}; - sprintf(name, "ycc_dev_%d_g_errd", ydev->id); - INIT_WORK(&ydev->work, ycc_process_global_err); + sprintf(name, "alicc_dev_%d_g_errd", ydev->id); + INIT_WORK(&ydev->work, alicc_process_global_err); /* Allocated, but not used temporarily */ ydev->dev_err_q = alloc_workqueue(name, WQ_UNBOUND, 0); if (!ydev->dev_err_q) { - pr_err("Failed to alloc workqueue for ycc:%d\n", ydev->id); + pr_err("Failed to alloc workqueue for alicc:%d\n", ydev->id); return -ENOMEM; } return 0; } -static void ycc_cleanup_global_err_workqueue(struct ycc_dev *ydev) +static void alicc_cleanup_global_err_workqueue(struct alicc_dev *ydev) { if (ydev->dev_err_q) destroy_workqueue(ydev->dev_err_q); } -int ycc_alloc_irqs(struct ycc_dev *ydev) +int alicc_alloc_irqs(struct alicc_dev *ydev) { struct pci_dev *rcec_pdev = ydev->assoc_dev->pdev; - int num = ydev->is_vf ? 1 : YCC_RINGPAIR_NUM; + int num = ydev->is_vf ? 1 : ALICC_RINGPAIR_NUM; int cpu, cpus = num_online_cpus(); int i, j; int ret; /* The 0-47 are rings irqs, 48 is dev error irq */ - sprintf(ydev->err_irq_name, "ycc_dev_%d_global_err", ydev->id); + sprintf(ydev->err_irq_name, "alicc_dev_%d_global_err", ydev->id); ret = request_irq(pci_irq_vector(rcec_pdev, num), - ycc_g_err_isr, 0, ydev->err_irq_name, ydev); + alicc_g_err_isr, 0, ydev->err_irq_name, ydev); if (ret) { pr_err("Failed to alloc global irq interrupt for dev:%d\n", ydev->id); goto out; @@ -240,15 +240,15 @@ int ycc_alloc_irqs(struct ycc_dev *ydev) ydev->msi_name[i] = kzalloc(16, GFP_KERNEL); if (!ydev->msi_name[i]) goto free_irq; - snprintf(ydev->msi_name[i], 16, "ycc_ring_%d", i); - ret = request_irq(pci_irq_vector(rcec_pdev, i), ycc_resp_isr, + snprintf(ydev->msi_name[i], 16, "alicc_ring_%d", i); + ret = request_irq(pci_irq_vector(rcec_pdev, i), alicc_resp_isr, 0, ydev->msi_name[i], &ydev->rings[i]); if (ret) { kfree(ydev->msi_name[i]); goto free_irq; } if (!ydev->is_vf) - cpu = (i % YCC_RINGPAIR_NUM) % cpus; + cpu = (i % ALICC_RINGPAIR_NUM) % cpus; else cpu = smp_processor_id() % cpus; @@ -276,10 +276,10 @@ int ycc_alloc_irqs(struct ycc_dev *ydev) return ret; } -void ycc_free_irqs(struct ycc_dev *ydev) +void alicc_free_irqs(struct alicc_dev *ydev) { struct pci_dev *rcec_pdev = ydev->assoc_dev->pdev; - int num = ydev->is_vf ? 1 : YCC_RINGPAIR_NUM; + int num = ydev->is_vf ? 1 : ALICC_RINGPAIR_NUM; int i; /* Free device err irq */ @@ -298,12 +298,12 @@ void ycc_free_irqs(struct ycc_dev *ydev) } } -int ycc_init_global_err(struct ycc_dev *ydev) +int alicc_init_global_err(struct alicc_dev *ydev) { - return ycc_setup_global_err_workqueue(ydev); + return alicc_setup_global_err_workqueue(ydev); } -void ycc_deinit_global_err(struct ycc_dev *ydev) +void alicc_deinit_global_err(struct alicc_dev *ydev) { - ycc_cleanup_global_err_workqueue(ydev); + alicc_cleanup_global_err_workqueue(ydev); } diff --git a/drivers/crypto/alibaba/alicc/alicc_isr.h b/drivers/crypto/alibaba/alicc/alicc_isr.h new file mode 100644 index 000000000000..9da374b97a0b --- /dev/null +++ b/drivers/crypto/alibaba/alicc/alicc_isr.h @@ -0,0 +1,12 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __ALICC_ISR_H + +#include "alicc_dev.h" + +int alicc_enable_msix(struct alicc_dev *ydev); +void alicc_disable_msix(struct alicc_dev *ydev); +int alicc_alloc_irqs(struct alicc_dev *ydev); +void alicc_free_irqs(struct alicc_dev *ydev); +int alicc_init_global_err(struct alicc_dev *ydev); +void alicc_deinit_global_err(struct alicc_dev *ydev); +#endif diff --git a/drivers/crypto/ycc/ycc_pke.c b/drivers/crypto/alibaba/alicc/alicc_pke.c similarity index 61% rename from drivers/crypto/ycc/ycc_pke.c rename to drivers/crypto/alibaba/alicc/alicc_pke.c index 97271005090b..82021624da35 100644 --- a/drivers/crypto/ycc/ycc_pke.c +++ b/drivers/crypto/alibaba/alicc/alicc_pke.c @@ -7,17 +7,17 @@ #include #include "sm2signature_asn1.h" -#include "ycc_algs.h" +#include "alicc_algs.h" -static int ycc_rsa_done_callback(void *ptr, u16 state) +static int alicc_rsa_done_callback(void *ptr, u16 state) { - struct ycc_pke_req *rsa_req = (struct ycc_pke_req *)ptr; - struct ycc_pke_ctx *ctx = rsa_req->ctx; + struct alicc_pke_req *rsa_req = (struct alicc_pke_req *)ptr; + struct alicc_pke_ctx *ctx = rsa_req->ctx; struct akcipher_request *req = rsa_req->req; - struct device *dev = YCC_DEV(ctx); + struct device *dev = ALICC_DEV(ctx); unsigned int dma_length = ctx->key_len; - if (rsa_req->desc.cmd.rsa_enc_cmd.cmd_id == YCC_CMD_RSA_VERIFY) + if (rsa_req->desc.cmd.rsa_enc_cmd.cmd_id == ALICC_CMD_RSA_VERIFY) dma_length = ctx->key_len << 1; /* For signature verify, dst is NULL */ @@ -36,11 +36,11 @@ static int ycc_rsa_done_callback(void *ptr, u16 state) return 0; } -static int ycc_prepare_dma_buf(struct ycc_pke_req *rsa_req, int is_src) +static int alicc_prepare_dma_buf(struct alicc_pke_req *rsa_req, int is_src) { - struct ycc_pke_ctx *ctx = rsa_req->ctx; + struct alicc_pke_ctx *ctx = rsa_req->ctx; struct akcipher_request *req = rsa_req->req; - struct device *dev = YCC_DEV(ctx); + struct device *dev = ALICC_DEV(ctx); unsigned int dma_length = ctx->key_len; dma_addr_t tmp; void *ptr; @@ -53,7 +53,7 @@ static int ycc_prepare_dma_buf(struct ycc_pke_req *rsa_req, int is_src) * the second contains message while src_len is signature * length, dst len is message length */ - if (rsa_req->desc.cmd.rsa_enc_cmd.cmd_id == YCC_CMD_RSA_VERIFY) { + if (rsa_req->desc.cmd.rsa_enc_cmd.cmd_id == ALICC_CMD_RSA_VERIFY) { dma_length = ctx->key_len << 1; shift = ctx->key_len - req->dst_len; } else { @@ -72,7 +72,7 @@ static int ycc_prepare_dma_buf(struct ycc_pke_req *rsa_req, int is_src) memset(ptr, 0, ALIGN(dma_length, 64)); if (is_src) { if (rsa_req->desc.cmd.rsa_enc_cmd.cmd_id == - YCC_CMD_RSA_VERIFY) { + ALICC_CMD_RSA_VERIFY) { /* Copy msg first with prepadding 0 */ sg_copy_buffer(req->src, sg_nents(req->src), ptr + shift, req->dst_len, req->src_len, 1); @@ -96,15 +96,15 @@ static int ycc_prepare_dma_buf(struct ycc_pke_req *rsa_req, int is_src) /* * Using public key to encrypt or verify */ -static int ycc_rsa_submit_pub(struct akcipher_request *req, bool is_enc) +static int alicc_rsa_submit_pub(struct akcipher_request *req, bool is_enc) { struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req); - struct ycc_pke_req *rsa_req = akcipher_request_ctx(req); - struct ycc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); - struct ycc_rsa_enc_cmd *rsa_enc_cmd; - struct ycc_ring *ring = ctx->ring; - struct device *dev = YCC_DEV(ctx); - struct ycc_flags *aflags; + struct alicc_pke_req *rsa_req = akcipher_request_ctx(req); + struct alicc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); + struct alicc_rsa_enc_cmd *rsa_enc_cmd; + struct alicc_ring *ring = ctx->ring; + struct device *dev = ALICC_DEV(ctx); + struct alicc_flags *aflags; int ret = -ENOMEM; if (req->dst_len > ctx->key_len || req->src_len > ctx->key_len) @@ -116,29 +116,29 @@ static int ycc_rsa_submit_pub(struct akcipher_request *req, bool is_enc) if (unlikely(!ctx->pub_key_vaddr)) return -EINVAL; - aflags = kzalloc(sizeof(struct ycc_flags), GFP_ATOMIC); + aflags = kzalloc(sizeof(struct alicc_flags), GFP_ATOMIC); if (!aflags) goto out; aflags->ptr = (void *)rsa_req; - aflags->ycc_done_callback = ycc_rsa_done_callback; + aflags->alicc_done_callback = alicc_rsa_done_callback; memset(&rsa_req->desc, 0, sizeof(rsa_req->desc)); rsa_req->desc.private_ptr = (u64)(void *)aflags; rsa_enc_cmd = &rsa_req->desc.cmd.rsa_enc_cmd; - rsa_enc_cmd->cmd_id = is_enc ? YCC_CMD_RSA_ENC : YCC_CMD_RSA_VERIFY; + rsa_enc_cmd->cmd_id = is_enc ? ALICC_CMD_RSA_ENC : ALICC_CMD_RSA_VERIFY; rsa_enc_cmd->keyptr = ctx->pub_key_paddr; rsa_enc_cmd->elen = ctx->e_len << 3; rsa_enc_cmd->nlen = ctx->key_len << 3; - ret = ycc_prepare_dma_buf(rsa_req, 1); + ret = alicc_prepare_dma_buf(rsa_req, 1); if (unlikely(ret)) goto free_aflags; rsa_enc_cmd->sptr = rsa_req->src_paddr; if (is_enc) { - ret = ycc_prepare_dma_buf(rsa_req, 0); + ret = alicc_prepare_dma_buf(rsa_req, 0); if (unlikely(ret)) goto free_src; @@ -147,7 +147,7 @@ static int ycc_rsa_submit_pub(struct akcipher_request *req, bool is_enc) rsa_req->dst_vaddr = NULL; } - ret = ycc_enqueue(ring, (u8 *)&rsa_req->desc); + ret = alicc_enqueue(ring, (u8 *)&rsa_req->desc); if (!ret) return -EINPROGRESS; @@ -167,15 +167,15 @@ static int ycc_rsa_submit_pub(struct akcipher_request *req, bool is_enc) /* * Using private key to decrypt or signature */ -static int ycc_rsa_submit_priv(struct akcipher_request *req, bool is_dec) +static int alicc_rsa_submit_priv(struct akcipher_request *req, bool is_dec) { struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req); - struct ycc_pke_req *rsa_req = akcipher_request_ctx(req); - struct ycc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); - struct ycc_rsa_dec_cmd *rsa_dec_cmd; - struct ycc_ring *ring = ctx->ring; - struct device *dev = YCC_DEV(ctx); - struct ycc_flags *aflags; + struct alicc_pke_req *rsa_req = akcipher_request_ctx(req); + struct alicc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); + struct alicc_rsa_dec_cmd *rsa_dec_cmd; + struct alicc_ring *ring = ctx->ring; + struct device *dev = ALICC_DEV(ctx); + struct alicc_flags *aflags; int ret = -ENOMEM; if (req->dst_len > ctx->key_len || req->src_len > ctx->key_len) @@ -187,12 +187,12 @@ static int ycc_rsa_submit_priv(struct akcipher_request *req, bool is_dec) if (unlikely(!ctx->priv_key_vaddr)) return -EINVAL; - aflags = kzalloc(sizeof(struct ycc_flags), GFP_ATOMIC); + aflags = kzalloc(sizeof(struct alicc_flags), GFP_ATOMIC); if (!aflags) goto out; aflags->ptr = (void *)rsa_req; - aflags->ycc_done_callback = ycc_rsa_done_callback; + aflags->alicc_done_callback = alicc_rsa_done_callback; memset(&rsa_req->desc, 0, sizeof(rsa_req->desc)); rsa_req->desc.private_ptr = (u64)(void *)aflags; @@ -202,22 +202,22 @@ static int ycc_rsa_submit_priv(struct akcipher_request *req, bool is_dec) rsa_dec_cmd->elen = ctx->e_len << 3; rsa_dec_cmd->nlen = ctx->key_len << 3; if (ctx->crt_mode) - rsa_dec_cmd->cmd_id = is_dec ? YCC_CMD_RSA_CRT_DEC : YCC_CMD_RSA_CRT_SIGN; + rsa_dec_cmd->cmd_id = is_dec ? ALICC_CMD_RSA_CRT_DEC : ALICC_CMD_RSA_CRT_SIGN; else - rsa_dec_cmd->cmd_id = is_dec ? YCC_CMD_RSA_DEC : YCC_CMD_RSA_SIGN; + rsa_dec_cmd->cmd_id = is_dec ? ALICC_CMD_RSA_DEC : ALICC_CMD_RSA_SIGN; - ret = ycc_prepare_dma_buf(rsa_req, 1); + ret = alicc_prepare_dma_buf(rsa_req, 1); if (unlikely(ret)) goto free_aflags; - ret = ycc_prepare_dma_buf(rsa_req, 0); + ret = alicc_prepare_dma_buf(rsa_req, 0); if (unlikely(ret)) goto free_src; rsa_dec_cmd->sptr = rsa_req->src_paddr; rsa_dec_cmd->dptr = rsa_req->dst_paddr; - ret = ycc_enqueue(ring, (u8 *)&rsa_req->desc); + ret = alicc_enqueue(ring, (u8 *)&rsa_req->desc); if (!ret) return -EINPROGRESS; @@ -232,14 +232,14 @@ static int ycc_rsa_submit_priv(struct akcipher_request *req, bool is_dec) return ret; } -static inline bool ycc_rsa_do_soft(struct akcipher_request *req) +static inline bool alicc_rsa_do_soft(struct akcipher_request *req) { struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req); - struct ycc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); - struct ycc_dev *ydev = ctx->ring->ydev; + struct alicc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); + struct alicc_dev *ydev = ctx->ring->ydev; - if (ctx->key_len == YCC_RSA_KEY_SZ_512 || - ctx->key_len == YCC_RSA_KEY_SZ_1536 || + if (ctx->key_len == ALICC_RSA_KEY_SZ_512 || + ctx->key_len == ALICC_RSA_KEY_SZ_1536 || !test_bit(YDEV_STATUS_READY, &ydev->status)) return true; @@ -253,10 +253,10 @@ enum rsa_ops { RSA_VERIFY, }; -static inline int ycc_rsa_soft_fallback(struct akcipher_request *req, int ops) +static inline int alicc_rsa_soft_fallback(struct akcipher_request *req, int ops) { struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req); - struct ycc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); + struct alicc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); int ret = -EINVAL; akcipher_request_set_tfm(req, ctx->soft_tfm); @@ -282,39 +282,39 @@ static inline int ycc_rsa_soft_fallback(struct akcipher_request *req, int ops) return ret; } -static int ycc_rsa_encrypt(struct akcipher_request *req) +static int alicc_rsa_encrypt(struct akcipher_request *req) { - if (ycc_rsa_do_soft(req)) - return ycc_rsa_soft_fallback(req, RSA_ENC); + if (alicc_rsa_do_soft(req)) + return alicc_rsa_soft_fallback(req, RSA_ENC); - return ycc_rsa_submit_pub(req, true); + return alicc_rsa_submit_pub(req, true); } -static int ycc_rsa_decrypt(struct akcipher_request *req) +static int alicc_rsa_decrypt(struct akcipher_request *req) { - if (ycc_rsa_do_soft(req)) - return ycc_rsa_soft_fallback(req, RSA_DEC); + if (alicc_rsa_do_soft(req)) + return alicc_rsa_soft_fallback(req, RSA_DEC); - return ycc_rsa_submit_priv(req, true); + return alicc_rsa_submit_priv(req, true); } -static int ycc_rsa_verify(struct akcipher_request *req) +static int alicc_rsa_verify(struct akcipher_request *req) { - if (ycc_rsa_do_soft(req)) - return ycc_rsa_soft_fallback(req, RSA_VERIFY); + if (alicc_rsa_do_soft(req)) + return alicc_rsa_soft_fallback(req, RSA_VERIFY); - return ycc_rsa_submit_pub(req, false); + return alicc_rsa_submit_pub(req, false); } -static int ycc_rsa_sign(struct akcipher_request *req) +static int alicc_rsa_sign(struct akcipher_request *req) { - if (ycc_rsa_do_soft(req)) - return ycc_rsa_soft_fallback(req, RSA_SIGN); + if (alicc_rsa_do_soft(req)) + return alicc_rsa_soft_fallback(req, RSA_SIGN); - return ycc_rsa_submit_priv(req, false); + return alicc_rsa_submit_priv(req, false); } -static int ycc_rsa_validate_n(unsigned int len) +static int alicc_rsa_validate_n(unsigned int len) { unsigned int bitslen = len << 3; @@ -331,7 +331,7 @@ static int ycc_rsa_validate_n(unsigned int len) } } -static void __ycc_rsa_drop_leading_zeros(const u8 **ptr, size_t *len) +static void __alicc_rsa_drop_leading_zeros(const u8 **ptr, size_t *len) { if (!*ptr) return; @@ -342,7 +342,7 @@ static void __ycc_rsa_drop_leading_zeros(const u8 **ptr, size_t *len) } } -static int ycc_rsa_set_n(struct ycc_pke_ctx *ctx, const char *value, +static int alicc_rsa_set_n(struct alicc_pke_ctx *ctx, const char *value, size_t value_len, bool private) { const char *ptr = value; @@ -355,19 +355,19 @@ static int ycc_rsa_set_n(struct ycc_pke_ctx *ctx, const char *value, ctx->key_len = value_len; if (private && !ctx->crt_mode) - memcpy(ctx->priv_key_vaddr + ctx->e_len + YCC_PIN_SZ + + memcpy(ctx->priv_key_vaddr + ctx->e_len + ALICC_PIN_SZ + ctx->rsa_key->d_sz, ptr, value_len); memcpy(ctx->pub_key_vaddr + ctx->e_len, ptr, value_len); return 0; } -static int ycc_rsa_set_e(struct ycc_pke_ctx *ctx, const char *value, +static int alicc_rsa_set_e(struct alicc_pke_ctx *ctx, const char *value, size_t value_len, bool private) { const char *ptr = value; - if (!ctx->key_len || !value_len || value_len > YCC_RSA_E_SZ_MAX) + if (!ctx->key_len || !value_len || value_len > ALICC_RSA_E_SZ_MAX) return -EINVAL; ctx->e_len = value_len; @@ -378,7 +378,7 @@ static int ycc_rsa_set_e(struct ycc_pke_ctx *ctx, const char *value, return 0; } -static int ycc_rsa_set_d(struct ycc_pke_ctx *ctx, const char *value, +static int alicc_rsa_set_d(struct alicc_pke_ctx *ctx, const char *value, size_t value_len) { const char *ptr = value; @@ -386,11 +386,11 @@ static int ycc_rsa_set_d(struct ycc_pke_ctx *ctx, const char *value, if (!ctx->key_len || !value_len || value_len > ctx->key_len) return -EINVAL; - memcpy(ctx->priv_key_vaddr + ctx->e_len + YCC_PIN_SZ, ptr, value_len); + memcpy(ctx->priv_key_vaddr + ctx->e_len + ALICC_PIN_SZ, ptr, value_len); return 0; } -static int ycc_rsa_set_crt_param(char *param, size_t half_key_len, +static int alicc_rsa_set_crt_param(char *param, size_t half_key_len, const char *value, size_t value_len) { const char *ptr = value; @@ -403,7 +403,7 @@ static int ycc_rsa_set_crt_param(char *param, size_t half_key_len, return 0; } -static int ycc_rsa_setkey_crt(struct ycc_pke_ctx *ctx, struct rsa_key *rsa_key) +static int alicc_rsa_setkey_crt(struct alicc_pke_ctx *ctx, struct rsa_key *rsa_key) { unsigned int half_key_len = ctx->key_len >> 1; u8 *tmp = (u8 *)ctx->priv_key_vaddr; @@ -411,27 +411,27 @@ static int ycc_rsa_setkey_crt(struct ycc_pke_ctx *ctx, struct rsa_key *rsa_key) tmp += ctx->rsa_key->e_sz + 16; /* TODO: rsa_key is better to be kept original */ - ret = ycc_rsa_set_crt_param(tmp, half_key_len, rsa_key->p, rsa_key->p_sz); + ret = alicc_rsa_set_crt_param(tmp, half_key_len, rsa_key->p, rsa_key->p_sz); if (ret) goto err; tmp += half_key_len; - ret = ycc_rsa_set_crt_param(tmp, half_key_len, rsa_key->q, rsa_key->q_sz); + ret = alicc_rsa_set_crt_param(tmp, half_key_len, rsa_key->q, rsa_key->q_sz); if (ret) goto err; tmp += half_key_len; - ret = ycc_rsa_set_crt_param(tmp, half_key_len, rsa_key->dp, rsa_key->dp_sz); + ret = alicc_rsa_set_crt_param(tmp, half_key_len, rsa_key->dp, rsa_key->dp_sz); if (ret) goto err; tmp += half_key_len; - ret = ycc_rsa_set_crt_param(tmp, half_key_len, rsa_key->dq, rsa_key->dq_sz); + ret = alicc_rsa_set_crt_param(tmp, half_key_len, rsa_key->dq, rsa_key->dq_sz); if (ret) goto err; tmp += half_key_len; - ret = ycc_rsa_set_crt_param(tmp, half_key_len, rsa_key->qinv, rsa_key->qinv_sz); + ret = alicc_rsa_set_crt_param(tmp, half_key_len, rsa_key->qinv, rsa_key->qinv_sz); if (ret) goto err; @@ -443,20 +443,20 @@ static int ycc_rsa_setkey_crt(struct ycc_pke_ctx *ctx, struct rsa_key *rsa_key) return ret; } -static void ycc_rsa_clear_ctx(struct ycc_pke_ctx *ctx) +static void alicc_rsa_clear_ctx(struct alicc_pke_ctx *ctx) { - struct device *dev = YCC_DEV(ctx); + struct device *dev = ALICC_DEV(ctx); size_t size; if (ctx->pub_key_vaddr) { - size = ALIGN(ctx->rsa_key->e_sz + ctx->key_len, YCC_CMD_DATA_ALIGN_SZ); + size = ALIGN(ctx->rsa_key->e_sz + ctx->key_len, ALICC_CMD_DATA_ALIGN_SZ); dma_free_coherent(dev, size, ctx->pub_key_vaddr, ctx->pub_key_paddr); ctx->pub_key_vaddr = NULL; } if (ctx->priv_key_vaddr) { - size = ALIGN(ctx->rsa_key->e_sz + YCC_PIN_SZ + ctx->rsa_key->d_sz + - ctx->key_len, YCC_CMD_DATA_ALIGN_SZ); + size = ALIGN(ctx->rsa_key->e_sz + ALICC_PIN_SZ + ctx->rsa_key->d_sz + + ctx->key_len, ALICC_CMD_DATA_ALIGN_SZ); memzero_explicit(ctx->priv_key_vaddr, size); dma_free_coherent(dev, size, ctx->priv_key_vaddr, ctx->priv_key_paddr); ctx->priv_key_vaddr = NULL; @@ -473,30 +473,30 @@ static void ycc_rsa_clear_ctx(struct ycc_pke_ctx *ctx) ctx->crt_mode = false; } -static void ycc_rsa_drop_leading_zeros(struct rsa_key *rsa_key) +static void alicc_rsa_drop_leading_zeros(struct rsa_key *rsa_key) { - __ycc_rsa_drop_leading_zeros(&rsa_key->n, &rsa_key->n_sz); - __ycc_rsa_drop_leading_zeros(&rsa_key->e, &rsa_key->e_sz); - __ycc_rsa_drop_leading_zeros(&rsa_key->d, &rsa_key->d_sz); - __ycc_rsa_drop_leading_zeros(&rsa_key->p, &rsa_key->p_sz); - __ycc_rsa_drop_leading_zeros(&rsa_key->q, &rsa_key->q_sz); - __ycc_rsa_drop_leading_zeros(&rsa_key->dp, &rsa_key->dp_sz); - __ycc_rsa_drop_leading_zeros(&rsa_key->dq, &rsa_key->dq_sz); - __ycc_rsa_drop_leading_zeros(&rsa_key->qinv, &rsa_key->qinv_sz); + __alicc_rsa_drop_leading_zeros(&rsa_key->n, &rsa_key->n_sz); + __alicc_rsa_drop_leading_zeros(&rsa_key->e, &rsa_key->e_sz); + __alicc_rsa_drop_leading_zeros(&rsa_key->d, &rsa_key->d_sz); + __alicc_rsa_drop_leading_zeros(&rsa_key->p, &rsa_key->p_sz); + __alicc_rsa_drop_leading_zeros(&rsa_key->q, &rsa_key->q_sz); + __alicc_rsa_drop_leading_zeros(&rsa_key->dp, &rsa_key->dp_sz); + __alicc_rsa_drop_leading_zeros(&rsa_key->dq, &rsa_key->dq_sz); + __alicc_rsa_drop_leading_zeros(&rsa_key->qinv, &rsa_key->qinv_sz); } -static int ycc_rsa_alloc_key(struct ycc_pke_ctx *ctx, bool priv) +static int alicc_rsa_alloc_key(struct alicc_pke_ctx *ctx, bool priv) { - struct device *dev = YCC_DEV(ctx); + struct device *dev = ALICC_DEV(ctx); struct rsa_key *rsa_key = ctx->rsa_key; unsigned int half_key_len; size_t size; int ret; - ycc_rsa_drop_leading_zeros(rsa_key); + alicc_rsa_drop_leading_zeros(rsa_key); ctx->key_len = rsa_key->n_sz; - ret = ycc_rsa_validate_n(ctx->key_len); + ret = alicc_rsa_validate_n(ctx->key_len); if (ret) { pr_err("Invalid n size:%d bits\n", ctx->key_len << 3); goto out; @@ -506,12 +506,12 @@ static int ycc_rsa_alloc_key(struct ycc_pke_ctx *ctx, bool priv) if (priv) { if (!(rsa_key->p_sz + rsa_key->q_sz + rsa_key->dp_sz + rsa_key->dq_sz + rsa_key->qinv_sz)) { - size = ALIGN(rsa_key->e_sz + YCC_PIN_SZ + rsa_key->d_sz + - ctx->key_len, YCC_CMD_DATA_ALIGN_SZ); + size = ALIGN(rsa_key->e_sz + ALICC_PIN_SZ + rsa_key->d_sz + + ctx->key_len, ALICC_CMD_DATA_ALIGN_SZ); } else { half_key_len = ctx->key_len >> 1; - size = ALIGN(rsa_key->e_sz + YCC_PIN_SZ + half_key_len * - YCC_RSA_CRT_PARAMS, YCC_CMD_DATA_ALIGN_SZ); + size = ALIGN(rsa_key->e_sz + ALICC_PIN_SZ + half_key_len * + ALICC_RSA_CRT_PARAMS, ALICC_CMD_DATA_ALIGN_SZ); ctx->crt_mode = true; } ctx->priv_key_vaddr = dma_alloc_coherent(dev, size, @@ -523,7 +523,7 @@ static int ycc_rsa_alloc_key(struct ycc_pke_ctx *ctx, bool priv) } if (!ctx->pub_key_vaddr) { - size = ALIGN(ctx->key_len + rsa_key->e_sz, YCC_CMD_DATA_ALIGN_SZ); + size = ALIGN(ctx->key_len + rsa_key->e_sz, ALICC_CMD_DATA_ALIGN_SZ); ctx->pub_key_vaddr = dma_alloc_coherent(dev, size, &ctx->pub_key_paddr, GFP_KERNEL); @@ -532,13 +532,13 @@ static int ycc_rsa_alloc_key(struct ycc_pke_ctx *ctx, bool priv) memset(ctx->pub_key_vaddr, 0, size); } - ret = ycc_rsa_set_e(ctx, rsa_key->e, rsa_key->e_sz, priv); + ret = alicc_rsa_set_e(ctx, rsa_key->e, rsa_key->e_sz, priv); if (ret) { pr_err("Failed to set e for rsa %s key\n", priv ? "private" : "public"); goto out; } - ret = ycc_rsa_set_n(ctx, rsa_key->n, rsa_key->n_sz, priv); + ret = alicc_rsa_set_n(ctx, rsa_key->n, rsa_key->n_sz, priv); if (ret) { pr_err("Failed to set n for rsa private key\n"); goto out; @@ -546,13 +546,13 @@ static int ycc_rsa_alloc_key(struct ycc_pke_ctx *ctx, bool priv) if (priv) { if (ctx->crt_mode) { - ret = ycc_rsa_setkey_crt(ctx, rsa_key); + ret = alicc_rsa_setkey_crt(ctx, rsa_key); if (ret) { pr_err("Failed to set private key for rsa crt key\n"); goto out; } } else { - ret = ycc_rsa_set_d(ctx, rsa_key->d, rsa_key->d_sz); + ret = alicc_rsa_set_d(ctx, rsa_key->d, rsa_key->d_sz); if (ret) { pr_err("Failed to set d for rsa private key\n"); goto out; @@ -563,14 +563,14 @@ static int ycc_rsa_alloc_key(struct ycc_pke_ctx *ctx, bool priv) return 0; out: - ycc_rsa_clear_ctx(ctx); + alicc_rsa_clear_ctx(ctx); return ret; } -static int ycc_rsa_setkey(struct crypto_akcipher *tfm, const void *key, +static int alicc_rsa_setkey(struct crypto_akcipher *tfm, const void *key, unsigned int keylen, bool priv) { - struct ycc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); + struct alicc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); struct rsa_key *rsa_key; int ret; @@ -581,7 +581,7 @@ static int ycc_rsa_setkey(struct crypto_akcipher *tfm, const void *key, if (ret) return ret; - ycc_rsa_clear_ctx(ctx); + alicc_rsa_clear_ctx(ctx); rsa_key = kzalloc(sizeof(struct rsa_key), GFP_KERNEL); if (!rsa_key) @@ -598,40 +598,40 @@ static int ycc_rsa_setkey(struct crypto_akcipher *tfm, const void *key, } ctx->rsa_key = rsa_key; - return ycc_rsa_alloc_key(ctx, priv); + return alicc_rsa_alloc_key(ctx, priv); } -static int ycc_rsa_setpubkey(struct crypto_akcipher *tfm, const void *key, +static int alicc_rsa_setpubkey(struct crypto_akcipher *tfm, const void *key, unsigned int keylen) { - return ycc_rsa_setkey(tfm, key, keylen, false); + return alicc_rsa_setkey(tfm, key, keylen, false); } -static int ycc_rsa_setprivkey(struct crypto_akcipher *tfm, const void *key, +static int alicc_rsa_setprivkey(struct crypto_akcipher *tfm, const void *key, unsigned int keylen) { - return ycc_rsa_setkey(tfm, key, keylen, true); + return alicc_rsa_setkey(tfm, key, keylen, true); } -static unsigned int ycc_rsa_max_size(struct crypto_akcipher *tfm) +static unsigned int alicc_rsa_max_size(struct crypto_akcipher *tfm) { - struct ycc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); + struct alicc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); /* - * 512 and 1536 bits key size are not supported by YCC, + * 512 and 1536 bits key size are not supported by ALICC, * we use soft tfm instead */ - if (ctx->key_len == YCC_RSA_KEY_SZ_512 || - ctx->key_len == YCC_RSA_KEY_SZ_1536) + if (ctx->key_len == ALICC_RSA_KEY_SZ_512 || + ctx->key_len == ALICC_RSA_KEY_SZ_1536) return crypto_akcipher_maxsize(ctx->soft_tfm); return ctx->rsa_key ? ctx->key_len : 0; } -static int ycc_rsa_init(struct crypto_akcipher *tfm) +static int alicc_rsa_init(struct crypto_akcipher *tfm) { - struct ycc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); - struct ycc_ring *ring; + struct alicc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); + struct alicc_ring *ring; ctx->soft_tfm = crypto_alloc_akcipher("rsa-generic", 0, 0); if (IS_ERR(ctx->soft_tfm)) { @@ -640,10 +640,10 @@ static int ycc_rsa_init(struct crypto_akcipher *tfm) } /* Reserve enough space if soft request reqires additional space */ - akcipher_set_reqsize(tfm, sizeof(struct ycc_pke_req) + + akcipher_set_reqsize(tfm, sizeof(struct alicc_pke_req) + crypto_akcipher_alg(ctx->soft_tfm)->reqsize); - ring = ycc_crypto_get_ring(); + ring = alicc_crypto_get_ring(); if (!ring) { crypto_free_akcipher(ctx->soft_tfm); return -EINVAL; @@ -654,25 +654,25 @@ static int ycc_rsa_init(struct crypto_akcipher *tfm) return 0; } -static void ycc_rsa_exit(struct crypto_akcipher *tfm) +static void alicc_rsa_exit(struct crypto_akcipher *tfm) { - struct ycc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); + struct alicc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); if (ctx->ring) - ycc_crypto_free_ring(ctx->ring); + alicc_crypto_free_ring(ctx->ring); - ycc_rsa_clear_ctx(ctx); + alicc_rsa_clear_ctx(ctx); crypto_free_akcipher(ctx->soft_tfm); } #define MPI_NBYTES(m) ((mpi_get_nbits(m) + 7) / 8) -static int ycc_sm2_done_callback(void *ptr, u16 state) +static int alicc_sm2_done_callback(void *ptr, u16 state) { - struct ycc_pke_req *sm2_req = (struct ycc_pke_req *)ptr; - struct ycc_pke_ctx *ctx = sm2_req->ctx; + struct alicc_pke_req *sm2_req = (struct alicc_pke_req *)ptr; + struct alicc_pke_ctx *ctx = sm2_req->ctx; struct akcipher_request *req = sm2_req->req; - struct device *dev = YCC_DEV(ctx); + struct device *dev = ALICC_DEV(ctx); dma_free_coherent(dev, 128, sm2_req->src_vaddr, sm2_req->src_paddr); @@ -716,17 +716,17 @@ int sm2_get_signature_s(void *context, size_t hdrlen, unsigned char tag, return 0; } -static int ycc_sm2_verify(struct akcipher_request *req) +static int alicc_sm2_verify(struct akcipher_request *req) { struct crypto_akcipher *tfm = crypto_akcipher_reqtfm(req); - struct ycc_pke_req *sm2_req = akcipher_request_ctx(req); - struct ycc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); - struct ycc_sm2_verify_cmd *sm2_verify_cmd; - struct ycc_dev *ydev = ctx->ring->ydev; - struct ycc_ring *ring = ctx->ring; - struct device *dev = YCC_DEV(ctx); + struct alicc_pke_req *sm2_req = akcipher_request_ctx(req); + struct alicc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); + struct alicc_sm2_verify_cmd *sm2_verify_cmd; + struct alicc_dev *ydev = ctx->ring->ydev; + struct alicc_ring *ring = ctx->ring; + struct device *dev = ALICC_DEV(ctx); struct sm2_signature_ctx sig; - struct ycc_flags *aflags; + struct alicc_flags *aflags; u8 buffer[80] = {0}; int ret; @@ -774,22 +774,22 @@ static int ycc_sm2_verify(struct akcipher_request *req) sm2_req->dst_vaddr = NULL; - aflags = kzalloc(sizeof(struct ycc_flags), GFP_ATOMIC); + aflags = kzalloc(sizeof(struct alicc_flags), GFP_ATOMIC); if (!aflags) goto free_src; aflags->ptr = (void *)sm2_req; - aflags->ycc_done_callback = ycc_sm2_done_callback; + aflags->alicc_done_callback = alicc_sm2_done_callback; memset(&sm2_req->desc, 0, sizeof(sm2_req->desc)); sm2_req->desc.private_ptr = (u64)(void *)aflags; sm2_verify_cmd = &sm2_req->desc.cmd.sm2_verify_cmd; - sm2_verify_cmd->cmd_id = YCC_CMD_SM2_VERIFY; + sm2_verify_cmd->cmd_id = ALICC_CMD_SM2_VERIFY; sm2_verify_cmd->sptr = sm2_req->src_paddr; sm2_verify_cmd->keyptr = ctx->pub_key_paddr; - ret = ycc_enqueue(ring, (u8 *)&sm2_req->desc); + ret = alicc_enqueue(ring, (u8 *)&sm2_req->desc); if (!ret) return -EINPROGRESS; @@ -800,16 +800,16 @@ static int ycc_sm2_verify(struct akcipher_request *req) return ret; } -static unsigned int ycc_sm2_max_size(struct crypto_akcipher *tfm) +static unsigned int alicc_sm2_max_size(struct crypto_akcipher *tfm) { return PAGE_SIZE; } -static int ycc_sm2_setpubkey(struct crypto_akcipher *tfm, const void *key, +static int alicc_sm2_setpubkey(struct crypto_akcipher *tfm, const void *key, unsigned int keylen) { - struct ycc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); - struct device *dev = YCC_DEV(ctx); + struct alicc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); + struct device *dev = ALICC_DEV(ctx); int ret; ret = crypto_akcipher_set_pub_key(ctx->soft_tfm, key, keylen); @@ -844,20 +844,20 @@ static int ycc_sm2_setpubkey(struct crypto_akcipher *tfm, const void *key, return 0; } -static int ycc_sm2_init(struct crypto_akcipher *tfm) +static int alicc_sm2_init(struct crypto_akcipher *tfm) { - struct ycc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); - struct ycc_ring *ring; + struct alicc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); + struct alicc_ring *ring; ctx->soft_tfm = crypto_alloc_akcipher("sm2-generic", 0, 0); if (IS_ERR(ctx->soft_tfm)) return PTR_ERR(ctx->soft_tfm); /* Reserve enough space if soft request reqires additional space */ - akcipher_set_reqsize(tfm, sizeof(struct ycc_pke_req) + + akcipher_set_reqsize(tfm, sizeof(struct alicc_pke_req) + crypto_akcipher_alg(ctx->soft_tfm)->reqsize); - ring = ycc_crypto_get_ring(); + ring = alicc_crypto_get_ring(); if (!ring) { crypto_free_akcipher(ctx->soft_tfm); return -ENODEV; @@ -867,13 +867,13 @@ static int ycc_sm2_init(struct crypto_akcipher *tfm) return 0; } -static void ycc_sm2_exit(struct crypto_akcipher *tfm) +static void alicc_sm2_exit(struct crypto_akcipher *tfm) { - struct ycc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); - struct device *dev = YCC_DEV(ctx); + struct alicc_pke_ctx *ctx = akcipher_tfm_ctx(tfm); + struct device *dev = ALICC_DEV(ctx); if (ctx->ring) - ycc_crypto_free_ring(ctx->ring); + alicc_crypto_free_ring(ctx->ring); if (ctx->pub_key_vaddr) dma_free_coherent(dev, 64, ctx->pub_key_vaddr, ctx->pub_key_paddr); @@ -881,61 +881,61 @@ static void ycc_sm2_exit(struct crypto_akcipher *tfm) crypto_free_akcipher(ctx->soft_tfm); } -static struct akcipher_alg ycc_rsa = { +static struct akcipher_alg alicc_rsa = { .base = { .cra_name = "rsa", - .cra_driver_name = "ycc-rsa", + .cra_driver_name = "alicc-rsa", .cra_priority = 1000, .cra_module = THIS_MODULE, - .cra_ctxsize = sizeof(struct ycc_pke_ctx), + .cra_ctxsize = sizeof(struct alicc_pke_ctx), }, - .sign = ycc_rsa_sign, - .verify = ycc_rsa_verify, - .encrypt = ycc_rsa_encrypt, - .decrypt = ycc_rsa_decrypt, - .set_pub_key = ycc_rsa_setpubkey, - .set_priv_key = ycc_rsa_setprivkey, - .max_size = ycc_rsa_max_size, - .init = ycc_rsa_init, - .exit = ycc_rsa_exit, + .sign = alicc_rsa_sign, + .verify = alicc_rsa_verify, + .encrypt = alicc_rsa_encrypt, + .decrypt = alicc_rsa_decrypt, + .set_pub_key = alicc_rsa_setpubkey, + .set_priv_key = alicc_rsa_setprivkey, + .max_size = alicc_rsa_max_size, + .init = alicc_rsa_init, + .exit = alicc_rsa_exit, }; -static struct akcipher_alg ycc_sm2 = { +static struct akcipher_alg alicc_sm2 = { .base = { .cra_name = "sm2", - .cra_driver_name = "ycc-sm2", + .cra_driver_name = "alicc-sm2", .cra_priority = 1000, .cra_module = THIS_MODULE, - .cra_ctxsize = sizeof(struct ycc_pke_ctx), + .cra_ctxsize = sizeof(struct alicc_pke_ctx), }, - .verify = ycc_sm2_verify, - .set_pub_key = ycc_sm2_setpubkey, - .max_size = ycc_sm2_max_size, - .init = ycc_sm2_init, - .exit = ycc_sm2_exit, + .verify = alicc_sm2_verify, + .set_pub_key = alicc_sm2_setpubkey, + .max_size = alicc_sm2_max_size, + .init = alicc_sm2_init, + .exit = alicc_sm2_exit, }; -int ycc_pke_register(void) +int alicc_pke_register(void) { int ret; - ret = crypto_register_akcipher(&ycc_rsa); + ret = crypto_register_akcipher(&alicc_rsa); if (ret) { pr_err("Failed to register rsa\n"); return ret; } - ret = crypto_register_akcipher(&ycc_sm2); + ret = crypto_register_akcipher(&alicc_sm2); if (ret) { - crypto_unregister_akcipher(&ycc_rsa); + crypto_unregister_akcipher(&alicc_rsa); pr_err("Failed to register sm2\n"); } return ret; } -void ycc_pke_unregister(void) +void alicc_pke_unregister(void) { - crypto_unregister_akcipher(&ycc_rsa); - crypto_unregister_akcipher(&ycc_sm2); + crypto_unregister_akcipher(&alicc_rsa); + crypto_unregister_akcipher(&alicc_sm2); } diff --git a/drivers/crypto/ycc/ycc_ring.c b/drivers/crypto/alibaba/alicc/alicc_ring.c similarity index 53% rename from drivers/crypto/ycc/ycc_ring.c rename to drivers/crypto/alibaba/alicc/alicc_ring.c index d84412846782..8e6a143feefc 100644 --- a/drivers/crypto/ycc/ycc_ring.c +++ b/drivers/crypto/alibaba/alicc/alicc_ring.c @@ -9,49 +9,49 @@ #include #include -#include "ycc_dev.h" -#include "ycc_ring.h" -#include "ycc_uio.h" +#include "alicc_dev.h" +#include "alicc_ring.h" +#include "alicc_uio.h" -#define YCC_CMD_DESC_SIZE 64 -#define YCC_RESP_DESC_SIZE 16 -#define YCC_RING_CSR_STRIDE 0x1000 +#define ALICC_CMD_DESC_SIZE 64 +#define ALICC_RESP_DESC_SIZE 16 +#define ALICC_RING_CSR_STRIDE 0x1000 -extern struct list_head ycc_table; -extern struct mutex ycc_mutex; +extern struct list_head alicc_table; +extern struct mutex alicc_mutex; -extern void ycc_resp_work_process(struct work_struct *work); +extern void alicc_resp_work_process(struct work_struct *work); /* * Show the status of specified ring's command queue and * response queue. */ -static int ycc_ring_debugfs_status_show(struct seq_file *s, void *p) +static int alicc_ring_debugfs_status_show(struct seq_file *s, void *p) { - struct ycc_ring *ring = (struct ycc_ring *)s->private; + struct alicc_ring *ring = (struct alicc_ring *)s->private; seq_printf(s, "Ring ID: %d\n", ring->ring_id); seq_printf(s, "Desscriptor Entry Size: %d, CMD Descriptor Size: %d, RESP Descriptor Size :%d\n", - ring->max_desc, YCC_CMD_DESC_SIZE, YCC_RESP_DESC_SIZE); + ring->max_desc, ALICC_CMD_DESC_SIZE, ALICC_RESP_DESC_SIZE); seq_printf(s, "CMD base addr:%llx, RESP base addr:%llx\n", ring->cmd_base_paddr, ring->resp_base_paddr); seq_printf(s, "CMD wr ptr:%d, CMD rd ptr: %d\n", - YCC_CSR_RD(ring->csr_vaddr, REG_RING_CMD_WR_PTR), - YCC_CSR_RD(ring->csr_vaddr, REG_RING_CMD_RD_PTR)); + ALICC_CSR_RD(ring->csr_vaddr, REG_RING_CMD_WR_PTR), + ALICC_CSR_RD(ring->csr_vaddr, REG_RING_CMD_RD_PTR)); seq_printf(s, "RESP rd ptr:%d, RESP wr ptr: %d\n", - YCC_CSR_RD(ring->csr_vaddr, REG_RING_RSP_RD_PTR), - YCC_CSR_RD(ring->csr_vaddr, REG_RING_RSP_WR_PTR)); + ALICC_CSR_RD(ring->csr_vaddr, REG_RING_RSP_RD_PTR), + ALICC_CSR_RD(ring->csr_vaddr, REG_RING_RSP_WR_PTR)); return 0; } -static int ycc_ring_debugfs_status_open(struct inode *inode, struct file *filp) +static int alicc_ring_debugfs_status_open(struct inode *inode, struct file *filp) { - return single_open(filp, ycc_ring_debugfs_status_show, inode->i_private); + return single_open(filp, alicc_ring_debugfs_status_show, inode->i_private); } -static const struct file_operations ycc_ring_status_fops = { - .open = ycc_ring_debugfs_status_open, +static const struct file_operations alicc_ring_status_fops = { + .open = alicc_ring_debugfs_status_open, .read = seq_read, .llseek = seq_lseek, .release = single_release, @@ -62,28 +62,28 @@ static const struct file_operations ycc_ring_status_fops = { * Dump the raw content of specified ring's command queue and * response queue. */ -static int ycc_ring_debugfs_dump_show(struct seq_file *s, void *p) +static int alicc_ring_debugfs_dump_show(struct seq_file *s, void *p) { - struct ycc_ring *ring = (struct ycc_ring *)s->private; + struct alicc_ring *ring = (struct alicc_ring *)s->private; seq_printf(s, "Ring ID: %d\n", ring->ring_id); seq_puts(s, "-------- Ring CMD Descriptors --------\n"); seq_hex_dump(s, "", DUMP_PREFIX_ADDRESS, 32, 4, ring->cmd_base_vaddr, - YCC_CMD_DESC_SIZE * ring->max_desc, false); + ALICC_CMD_DESC_SIZE * ring->max_desc, false); seq_puts(s, "-------- Ring RESP Descriptors --------\n"); seq_hex_dump(s, "", DUMP_PREFIX_ADDRESS, 32, 4, ring->resp_base_vaddr, - YCC_RESP_DESC_SIZE * ring->max_desc, false); + ALICC_RESP_DESC_SIZE * ring->max_desc, false); return 0; } -static int ycc_ring_debugfs_dump_open(struct inode *inode, struct file *filp) +static int alicc_ring_debugfs_dump_open(struct inode *inode, struct file *filp) { - return single_open(filp, ycc_ring_debugfs_dump_show, inode->i_private); + return single_open(filp, alicc_ring_debugfs_dump_show, inode->i_private); } -static const struct file_operations ycc_ring_dump_fops = { - .open = ycc_ring_debugfs_dump_open, +static const struct file_operations alicc_ring_dump_fops = { + .open = alicc_ring_debugfs_dump_open, .read = seq_read, .llseek = seq_lseek, .release = single_release, @@ -92,9 +92,9 @@ static const struct file_operations ycc_ring_dump_fops = { /* * Create debugfs for rings, only for KERN_RING - * "/sys/kernel/debugfs/ycc_b:d.f/ring${x}" + * "/sys/kernel/debugfs/alicc_b:d.f/ring${x}" */ -static int ycc_create_ring_debugfs(struct ycc_ring *ring) +static int alicc_create_ring_debugfs(struct alicc_ring *ring) { struct dentry *debugfs; char name[8]; @@ -110,12 +110,12 @@ static int ycc_create_ring_debugfs(struct ycc_ring *ring) ring->debug_dir = debugfs; debugfs = debugfs_create_file("status", 0400, ring->debug_dir, - (void *)ring, &ycc_ring_status_fops); + (void *)ring, &alicc_ring_status_fops); if (IS_ERR_OR_NULL(debugfs)) goto remove_debugfs; debugfs = debugfs_create_file("dump", 0400, ring->debug_dir, - (void *)ring, &ycc_ring_dump_fops); + (void *)ring, &alicc_ring_dump_fops); if (IS_ERR_OR_NULL(debugfs)) goto remove_debugfs; @@ -128,7 +128,7 @@ static int ycc_create_ring_debugfs(struct ycc_ring *ring) return PTR_ERR(debugfs); } -static void ycc_remove_ring_debugfs(struct ycc_ring *ring) +static void alicc_remove_ring_debugfs(struct alicc_ring *ring) { debugfs_remove_recursive(ring->debug_dir); } @@ -138,15 +138,15 @@ static void ycc_remove_ring_debugfs(struct ycc_ring *ring) * right means that the ring has the lowest reference * count. */ -static struct ycc_ring *base_r; +static struct alicc_ring *base_r; /* * Allocate memory for rings and initiate basic fields */ -static int ycc_alloc_rings(struct ycc_dev *ydev) +static int alicc_alloc_rings(struct alicc_dev *ydev) { - int num = YCC_RINGPAIR_NUM; - struct ycc_bar *abar; + int num = ALICC_RINGPAIR_NUM; + struct alicc_bar *abar; u32 i; if (ydev->rings) @@ -154,14 +154,14 @@ static int ycc_alloc_rings(struct ycc_dev *ydev) if (ydev->is_vf) { num = 1; - abar = &ydev->ycc_bars[0]; + abar = &ydev->alicc_bars[0]; } else if (ydev->sec) { - abar = &ydev->ycc_bars[YCC_SEC_Q_BAR]; + abar = &ydev->alicc_bars[ALICC_SEC_Q_BAR]; } else { - abar = &ydev->ycc_bars[YCC_NSEC_Q_BAR]; + abar = &ydev->alicc_bars[ALICC_NSEC_Q_BAR]; } - ydev->rings = kzalloc_node(num * sizeof(struct ycc_ring), + ydev->rings = kzalloc_node(num * sizeof(struct alicc_ring), GFP_KERNEL, ydev->node); if (!ydev->rings) return -ENOMEM; @@ -169,8 +169,8 @@ static int ycc_alloc_rings(struct ycc_dev *ydev) for (i = 0; i < num; i++) { ydev->rings[i].ring_id = i; ydev->rings[i].ydev = ydev; - ydev->rings[i].csr_vaddr = abar->vaddr + i * YCC_RING_CSR_STRIDE; - ydev->rings[i].csr_paddr = abar->paddr + i * YCC_RING_CSR_STRIDE; + ydev->rings[i].csr_vaddr = abar->vaddr + i * ALICC_RING_CSR_STRIDE; + ydev->rings[i].csr_paddr = abar->paddr + i * ALICC_RING_CSR_STRIDE; ydev->rings[i].cmd_wr_ptr = 0; ydev->rings[i].cmd_rd_ptr = 0; ydev->rings[i].resp_wr_ptr = 0; @@ -183,7 +183,7 @@ static int ycc_alloc_rings(struct ycc_dev *ydev) /* * Free memory for rings */ -static void ycc_free_rings(struct ycc_dev *ydev) +static void alicc_free_rings(struct alicc_dev *ydev) { kfree(ydev->rings); ydev->rings = NULL; @@ -193,9 +193,9 @@ static void ycc_free_rings(struct ycc_dev *ydev) /* * Initiate ring and create command queue and response queue. */ -static int ycc_init_ring(struct ycc_ring *ring, u32 max_desc) +static int alicc_init_ring(struct alicc_ring *ring, u32 max_desc) { - struct ycc_dev *ydev = ring->ydev; + struct alicc_dev *ydev = ring->ydev; u32 cmd_ring_size, resp_ring_size; int order = 0; u32 val = 0; @@ -204,8 +204,8 @@ static int ycc_init_ring(struct ycc_ring *ring, u32 max_desc) ring->type = KERN_RING; ring->max_desc = max_desc; - cmd_ring_size = ring->max_desc * YCC_CMD_DESC_SIZE; - resp_ring_size = ring->max_desc * YCC_RESP_DESC_SIZE; + cmd_ring_size = ring->max_desc * ALICC_CMD_DESC_SIZE; + resp_ring_size = ring->max_desc * ALICC_RESP_DESC_SIZE; ring->cmd_base_vaddr = dma_alloc_coherent(&ydev->pdev->dev, cmd_ring_size, @@ -246,18 +246,18 @@ static int ycc_init_ring(struct ycc_ring *ring, u32 max_desc) /* Ring interrupt threshold */ val |= (ydev->is_polling ? 1 : 0xFFFF) << 16; - YCC_CSR_WR(ring->csr_vaddr, REG_RING_CFG, val); - YCC_CSR_WR(ring->csr_vaddr, REG_RING_RSP_AFULL_TH, 0); - YCC_CSR_WR(ring->csr_vaddr, REG_RING_CMD_BASE_ADDR_LO, + ALICC_CSR_WR(ring->csr_vaddr, REG_RING_CFG, val); + ALICC_CSR_WR(ring->csr_vaddr, REG_RING_RSP_AFULL_TH, 0); + ALICC_CSR_WR(ring->csr_vaddr, REG_RING_CMD_BASE_ADDR_LO, (u32)ring->cmd_base_paddr & 0xffffffff); - YCC_CSR_WR(ring->csr_vaddr, REG_RING_CMD_BASE_ADDR_HI, + ALICC_CSR_WR(ring->csr_vaddr, REG_RING_CMD_BASE_ADDR_HI, ((u64)ring->cmd_base_paddr >> 32) & 0xffffffff); - YCC_CSR_WR(ring->csr_vaddr, REG_RING_RSP_BASE_ADDR_LO, + ALICC_CSR_WR(ring->csr_vaddr, REG_RING_RSP_BASE_ADDR_LO, (u32)ring->resp_base_paddr & 0xffffffff); - YCC_CSR_WR(ring->csr_vaddr, REG_RING_RSP_BASE_ADDR_HI, + ALICC_CSR_WR(ring->csr_vaddr, REG_RING_RSP_BASE_ADDR_HI, ((u64)ring->resp_base_paddr >> 32) & 0xffffffff); - if (ycc_create_ring_debugfs(ring)) + if (alicc_create_ring_debugfs(ring)) pr_warn("Failed to create debugfs entry for ring:%d\n", ring->ring_id); atomic_set(&ring->ref_cnt, 0); @@ -268,41 +268,41 @@ static int ycc_init_ring(struct ycc_ring *ring, u32 max_desc) /* * Release dma memory for command queue and response queue. */ -static void ycc_release_ring(struct ycc_ring *ring) +static void alicc_release_ring(struct alicc_ring *ring) { u32 ring_size; BUG_ON(atomic_read(&ring->ref_cnt)); if (ring->cmd_base_vaddr) { - ring_size = ring->max_desc * YCC_CMD_DESC_SIZE; + ring_size = ring->max_desc * ALICC_CMD_DESC_SIZE; dma_free_coherent(&ring->ydev->pdev->dev, ring_size, ring->cmd_base_vaddr, ring->cmd_base_paddr); ring->cmd_base_vaddr = NULL; } if (ring->resp_base_vaddr) { - ring_size = ring->max_desc * YCC_RESP_DESC_SIZE; + ring_size = ring->max_desc * ALICC_RESP_DESC_SIZE; dma_free_coherent(&ring->ydev->pdev->dev, ring_size, ring->resp_base_vaddr, ring->resp_base_paddr); ring->resp_base_vaddr = NULL; } - ycc_remove_ring_debugfs(ring); + alicc_remove_ring_debugfs(ring); ring->type = FREE_RING; } -int ycc_dev_rings_init(struct ycc_dev *ydev, u32 max_desc, int user_rings) +int alicc_dev_rings_init(struct alicc_dev *ydev, u32 max_desc, int user_rings) { - int kern_rings = YCC_RINGPAIR_NUM - user_rings; + int kern_rings = ALICC_RINGPAIR_NUM - user_rings; struct pci_dev *pdev = ydev->pdev; - struct ycc_ring *ring; + struct alicc_ring *ring; int kern_cnt, user_cnt; int ret = 0; int i; - ret = ycc_alloc_rings(ydev); + ret = alicc_alloc_rings(ydev); if (ret) { dev_err(&pdev->dev, "Probe failed when allocating rings\n"); return ret; @@ -310,18 +310,18 @@ int ycc_dev_rings_init(struct ycc_dev *ydev, u32 max_desc, int user_rings) for (i = 0; i < kern_rings; i++) { ring = &ydev->rings[i]; - ret = ycc_init_ring(ring, max_desc); + ret = alicc_init_ring(ring, max_desc); if (ret) { kern_cnt = i; goto free_kern_rings; } - INIT_WORK(&ring->work, ycc_resp_work_process); + INIT_WORK(&ring->work, alicc_resp_work_process); } kern_cnt = kern_rings; - for (i = kern_rings; i < YCC_RINGPAIR_NUM; i++) { + for (i = kern_rings; i < ALICC_RINGPAIR_NUM; i++) { ring = &ydev->rings[i]; - ret = ycc_uio_register(ring); + ret = alicc_uio_register(ring); if (ret) { user_cnt = i - kern_rings; goto free_user_rings; @@ -333,42 +333,42 @@ int ycc_dev_rings_init(struct ycc_dev *ydev, u32 max_desc, int user_rings) free_user_rings: for (i = 0; i < user_cnt; i++) { ring = &ydev->rings[i + kern_rings]; - ycc_uio_unregister(ring); + alicc_uio_unregister(ring); } free_kern_rings: for (i = 0; i < kern_cnt; i++) { ring = &ydev->rings[i]; - ycc_release_ring(ring); + alicc_release_ring(ring); } - ycc_free_rings(ydev); + alicc_free_rings(ydev); return ret; } -void ycc_dev_rings_release(struct ycc_dev *ydev, int user_rings) +void alicc_dev_rings_release(struct alicc_dev *ydev, int user_rings) { - int kern_rings = YCC_RINGPAIR_NUM - user_rings; - struct ycc_ring *ring; + int kern_rings = ALICC_RINGPAIR_NUM - user_rings; + struct alicc_ring *ring; int i; for (i = 0; i < kern_rings; i++) { ring = &ydev->rings[i]; - ycc_release_ring(ring); + alicc_release_ring(ring); } for (i = 0; i < user_rings; i++) { ring = &ydev->rings[i + kern_rings]; - ycc_uio_unregister(ring); + alicc_uio_unregister(ring); } - ycc_free_rings(ydev); + alicc_free_rings(ydev); } /* * Check if the command queue is full. */ -static inline bool ycc_ring_full(struct ycc_ring *ring) +static inline bool alicc_ring_full(struct alicc_ring *ring) { return ring->cmd_rd_ptr == (ring->cmd_wr_ptr + 1) % ring->max_desc; } @@ -376,28 +376,28 @@ static inline bool ycc_ring_full(struct ycc_ring *ring) /* * Check if the response queue is empty */ -static inline bool ycc_ring_empty(struct ycc_ring *ring) +static inline bool alicc_ring_empty(struct alicc_ring *ring) { return ring->resp_rd_ptr == ring->resp_wr_ptr; } -static struct ycc_ring *ycc_select_ring(void) +static struct alicc_ring *alicc_select_ring(void) { - struct ycc_ring *cur_r; + struct alicc_ring *cur_r; struct list_head *itr; - struct ycc_dev *ydev; + struct alicc_dev *ydev; int i; - if (list_empty(&ycc_table)) + if (list_empty(&alicc_table)) return NULL; - list_for_each(itr, &ycc_table) { - ydev = list_entry(itr, struct ycc_dev, list); - if (ydev->type != YCC_RCIEP || + list_for_each(itr, &alicc_table) { + ydev = list_entry(itr, struct alicc_dev, list); + if (ydev->type != ALICC_RCIEP || !test_bit(YDEV_STATUS_READY, &ydev->status)) continue; - for (i = 0; i < YCC_RINGPAIR_NUM; i++) { + for (i = 0; i < ALICC_RINGPAIR_NUM; i++) { cur_r = ydev->rings + i; /* Ring is not for kernel */ @@ -405,27 +405,27 @@ static struct ycc_ring *ycc_select_ring(void) continue; if (!base_r) { - /* It means ycc is first used */ + /* It means alicc is first used */ base_r = cur_r; - ycc_ring_get(cur_r); + alicc_ring_get(cur_r); return cur_r; } /* Compare to base ring */ if (!atomic_read(&base_r->ref_cnt) || (atomic_read(&base_r->ref_cnt) < atomic_read(&cur_r->ref_cnt))) { - ycc_ring_get(base_r); + alicc_ring_get(base_r); return base_r; } else if (atomic_read(&base_r->ref_cnt) > atomic_read(&cur_r->ref_cnt)) { - ycc_ring_get(cur_r); + alicc_ring_get(cur_r); return cur_r; } } } if (base_r) - ycc_ring_get(base_r); + alicc_ring_get(base_r); return base_r; } @@ -433,26 +433,26 @@ static struct ycc_ring *ycc_select_ring(void) /* * Bind the ring to crypto */ -struct ycc_ring *ycc_crypto_get_ring(void) +struct alicc_ring *alicc_crypto_get_ring(void) { - struct ycc_ring *ring = NULL; + struct alicc_ring *ring = NULL; - mutex_lock(&ycc_mutex); + mutex_lock(&alicc_mutex); - ring = ycc_select_ring(); + ring = alicc_select_ring(); if (!ring) goto out; - ycc_dev_get(ring->ydev); + alicc_dev_get(ring->ydev); if (ring->ydev->is_polling && atomic_read(&ring->ref_cnt) == 1) schedule_work(&ring->work); out: - mutex_unlock(&ycc_mutex); + mutex_unlock(&alicc_mutex); return ring; } -void ycc_crypto_free_ring(struct ycc_ring *ring) +void alicc_crypto_free_ring(struct alicc_ring *ring) { if (!ring) return; @@ -461,19 +461,19 @@ void ycc_crypto_free_ring(struct ycc_ring *ring) * will be added to protect ring->work to not be * canceled when another process just schedule it. */ - mutex_lock(&ycc_mutex); + mutex_lock(&alicc_mutex); if (atomic_dec_and_test(&ring->ref_cnt)) cancel_work_sync(&ring->work); - mutex_unlock(&ycc_mutex); + mutex_unlock(&alicc_mutex); - ycc_dev_put(ring->ydev); + alicc_dev_put(ring->ydev); } /* * Submit command to ring's command queue. */ -int ycc_enqueue(struct ycc_ring *ring, void *cmd) +int alicc_enqueue(struct alicc_ring *ring, void *cmd) { int ret = 0; @@ -481,101 +481,101 @@ int ycc_enqueue(struct ycc_ring *ring, void *cmd) return -EINVAL; spin_lock_bh(&ring->lock); - if (!test_bit(YDEV_STATUS_READY, &ring->ydev->status) || ycc_ring_stopped(ring)) { - pr_debug("YCC: equeue error, device status: %ld, ring stopped: %d\n", - ring->ydev->status, ycc_ring_stopped(ring)); + if (!test_bit(YDEV_STATUS_READY, &ring->ydev->status) || alicc_ring_stopped(ring)) { + pr_debug("ALICC: equeue error, device status: %ld, ring stopped: %d\n", + ring->ydev->status, alicc_ring_stopped(ring)); /* Fallback to software */ ret = -EAGAIN; goto out; } - ring->cmd_rd_ptr = YCC_CSR_RD(ring->csr_vaddr, REG_RING_CMD_RD_PTR); - if (ycc_ring_full(ring)) { + ring->cmd_rd_ptr = ALICC_CSR_RD(ring->csr_vaddr, REG_RING_CMD_RD_PTR); + if (alicc_ring_full(ring)) { pr_debug("Failed to enqueue cmd on ring:%d, due to ring full\n", ring->ring_id); ret = -EAGAIN; goto out; } - memcpy(ring->cmd_base_vaddr + ring->cmd_wr_ptr * YCC_CMD_DESC_SIZE, cmd, - YCC_CMD_DESC_SIZE); + memcpy(ring->cmd_base_vaddr + ring->cmd_wr_ptr * ALICC_CMD_DESC_SIZE, cmd, + ALICC_CMD_DESC_SIZE); /* Ensure that cmd_wr_ptr update after memcpy */ dma_wmb(); if (++ring->cmd_wr_ptr == ring->max_desc) ring->cmd_wr_ptr = 0; - YCC_CSR_WR(ring->csr_vaddr, REG_RING_CMD_WR_PTR, ring->cmd_wr_ptr); + ALICC_CSR_WR(ring->csr_vaddr, REG_RING_CMD_WR_PTR, ring->cmd_wr_ptr); out: spin_unlock_bh(&ring->lock); return ret; } -static void ycc_cancel_cmd(struct ycc_ring *ring, - struct ycc_cmd_desc *desc) +static void alicc_cancel_cmd(struct alicc_ring *ring, + struct alicc_cmd_desc *desc) { - struct ycc_flags *aflag; + struct alicc_flags *aflag; dma_rmb(); - aflag = (struct ycc_flags *)desc->private_ptr; + aflag = (struct alicc_flags *)desc->private_ptr; if (!aflag || (u64)aflag == CMD_INVALID_CONTENT_U64) { - pr_debug("YCC: Invalid aflag\n"); + pr_debug("ALICC: Invalid aflag\n"); return; } - aflag->ycc_done_callback(aflag->ptr, CMD_CANCELLED); + aflag->alicc_done_callback(aflag->ptr, CMD_CANCELLED); memset(desc, CMD_INVALID_CONTENT_U8, sizeof(*desc)); kfree(aflag); } -static inline void ycc_check_cmd_state(u16 state) +static inline void alicc_check_cmd_state(u16 state) { switch (state) { case CMD_SUCCESS: break; case CMD_ILLEGAL: - pr_debug("YCC response: Illegal cmd\n"); + pr_debug("ALICC response: Illegal cmd\n"); break; case CMD_UNDERATTACK: - pr_debug("YCC response: Attack is detected\n"); + pr_debug("ALICC response: Attack is detected\n"); break; case CMD_INVALID: - pr_debug("YCC response: Invalid cmd\n"); + pr_debug("ALICC response: Invalid cmd\n"); break; case CMD_ERROR: - pr_debug("YCC response: Cmd error\n"); + pr_debug("ALICC response: Cmd error\n"); break; case CMD_EXCESS: - pr_debug("YCC response: Excess permission\n"); + pr_debug("ALICC response: Excess permission\n"); break; case CMD_KEY_ERROR: - pr_debug("YCC response: Invalid internal key\n"); + pr_debug("ALICC response: Invalid internal key\n"); break; case CMD_VERIFY_ERROR: - pr_debug("YCC response: Mac/tag verify failed\n"); + pr_debug("ALICC response: Mac/tag verify failed\n"); break; default: - pr_debug("YCC response: Unknown error\n"); + pr_debug("ALICC response: Unknown error\n"); break; } } -void ycc_handle_resp(struct ycc_ring *ring, struct ycc_resp_desc *desc) +void alicc_handle_resp(struct alicc_ring *ring, struct alicc_resp_desc *desc) { - struct ycc_flags *aflag; + struct alicc_flags *aflag; dma_rmb(); - aflag = (struct ycc_flags *)desc->private_ptr; + aflag = (struct alicc_flags *)desc->private_ptr; if (!aflag || (u64)aflag == CMD_INVALID_CONTENT_U64) { - pr_debug("YCC: Invalid aflag\n"); + pr_debug("ALICC: Invalid aflag\n"); return; } - ycc_check_cmd_state(desc->state); - aflag->ycc_done_callback(aflag->ptr, desc->state); + alicc_check_cmd_state(desc->state); + aflag->alicc_done_callback(aflag->ptr, desc->state); memset(desc, CMD_INVALID_CONTENT_U8, sizeof(*desc)); kfree(aflag); @@ -584,19 +584,19 @@ void ycc_handle_resp(struct ycc_ring *ring, struct ycc_resp_desc *desc) /* * dequeue, read response descriptor */ -void ycc_dequeue(struct ycc_ring *ring) +void alicc_dequeue(struct alicc_ring *ring) { - struct ycc_resp_desc *resp; + struct alicc_resp_desc *resp; int cnt = 0; - if (!test_bit(YDEV_STATUS_READY, &ring->ydev->status) || ycc_ring_stopped(ring)) + if (!test_bit(YDEV_STATUS_READY, &ring->ydev->status) || alicc_ring_stopped(ring)) return; - ring->resp_wr_ptr = YCC_CSR_RD(ring->csr_vaddr, REG_RING_RSP_WR_PTR); - while (!ycc_ring_empty(ring)) { - resp = (struct ycc_resp_desc *)ring->resp_base_vaddr + + ring->resp_wr_ptr = ALICC_CSR_RD(ring->csr_vaddr, REG_RING_RSP_WR_PTR); + while (!alicc_ring_empty(ring)) { + resp = (struct alicc_resp_desc *)ring->resp_base_vaddr + ring->resp_rd_ptr; - ycc_handle_resp(ring, resp); + alicc_handle_resp(ring, resp); cnt++; if (++ring->resp_rd_ptr == ring->max_desc) @@ -604,42 +604,42 @@ void ycc_dequeue(struct ycc_ring *ring) } if (cnt) - YCC_CSR_WR(ring->csr_vaddr, REG_RING_RSP_RD_PTR, ring->resp_rd_ptr); + ALICC_CSR_WR(ring->csr_vaddr, REG_RING_RSP_RD_PTR, ring->resp_rd_ptr); } /* * Clear incompletion cmds in command queue while rollback cmd_wr_ptr. * - * Note: Make sure been invoked when error occurs in YCC internal and - * YCC status is not ready. + * Note: Make sure been invoked when error occurs in ALICC internal and + * ALICC status is not ready. */ -void ycc_clear_cmd_ring(struct ycc_ring *ring) +void alicc_clear_cmd_ring(struct alicc_ring *ring) { - struct ycc_cmd_desc *desc = NULL; + struct alicc_cmd_desc *desc = NULL; - ring->cmd_rd_ptr = YCC_CSR_RD(ring->csr_vaddr, REG_RING_CMD_RD_PTR); - ring->cmd_wr_ptr = YCC_CSR_RD(ring->csr_vaddr, REG_RING_CMD_WR_PTR); + ring->cmd_rd_ptr = ALICC_CSR_RD(ring->csr_vaddr, REG_RING_CMD_RD_PTR); + ring->cmd_wr_ptr = ALICC_CSR_RD(ring->csr_vaddr, REG_RING_CMD_WR_PTR); while (ring->cmd_rd_ptr != ring->cmd_wr_ptr) { - desc = (struct ycc_cmd_desc *)ring->cmd_base_vaddr + ring->cmd_rd_ptr; - ycc_cancel_cmd(ring, desc); + desc = (struct alicc_cmd_desc *)ring->cmd_base_vaddr + ring->cmd_rd_ptr; + alicc_cancel_cmd(ring, desc); if (--ring->cmd_wr_ptr == 0) ring->cmd_wr_ptr = ring->max_desc; } - YCC_CSR_WR(ring->csr_vaddr, REG_RING_CMD_WR_PTR, ring->cmd_wr_ptr); + ALICC_CSR_WR(ring->csr_vaddr, REG_RING_CMD_WR_PTR, ring->cmd_wr_ptr); } /* * Clear response queue * - * Note: Make sure been invoked when error occurs in YCC internal and - * YCC status is not ready. + * Note: Make sure been invoked when error occurs in ALICC internal and + * ALICC status is not ready. */ -void ycc_clear_resp_ring(struct ycc_ring *ring) +void alicc_clear_resp_ring(struct alicc_ring *ring) { - struct ycc_resp_desc *resp; + struct alicc_resp_desc *resp; int retry; u32 pending_cmd; @@ -648,28 +648,28 @@ void ycc_clear_resp_ring(struct ycc_ring *ring) * new transactions, No need to wait for pending_cmds * been processed under this condition. */ - retry = ycc_ring_stopped(ring) ? 0 : MAX_ERROR_RETRY; - pending_cmd = YCC_CSR_RD(ring->csr_vaddr, REG_RING_PENDING_CMD); + retry = alicc_ring_stopped(ring) ? 0 : MAX_ERROR_RETRY; + pending_cmd = ALICC_CSR_RD(ring->csr_vaddr, REG_RING_PENDING_CMD); - ring->resp_wr_ptr = YCC_CSR_RD(ring->csr_vaddr, REG_RING_RSP_WR_PTR); - while (!ycc_ring_empty(ring) || (retry && pending_cmd)) { - if (!ycc_ring_empty(ring)) { - resp = (struct ycc_resp_desc *)ring->resp_base_vaddr + + ring->resp_wr_ptr = ALICC_CSR_RD(ring->csr_vaddr, REG_RING_RSP_WR_PTR); + while (!alicc_ring_empty(ring) || (retry && pending_cmd)) { + if (!alicc_ring_empty(ring)) { + resp = (struct alicc_resp_desc *)ring->resp_base_vaddr + ring->resp_rd_ptr; resp->state = CMD_CANCELLED; - ycc_handle_resp(ring, resp); + alicc_handle_resp(ring, resp); if (++ring->resp_rd_ptr == ring->max_desc) ring->resp_rd_ptr = 0; - YCC_CSR_WR(ring->csr_vaddr, REG_RING_RSP_RD_PTR, ring->resp_rd_ptr); + ALICC_CSR_WR(ring->csr_vaddr, REG_RING_RSP_RD_PTR, ring->resp_rd_ptr); } else { udelay(MAX_SLEEP_US_PER_CHECK); retry--; } - pending_cmd = YCC_CSR_RD(ring->csr_vaddr, REG_RING_PENDING_CMD); - ring->resp_wr_ptr = YCC_CSR_RD(ring->csr_vaddr, REG_RING_RSP_WR_PTR); + pending_cmd = ALICC_CSR_RD(ring->csr_vaddr, REG_RING_PENDING_CMD); + ring->resp_wr_ptr = ALICC_CSR_RD(ring->csr_vaddr, REG_RING_RSP_WR_PTR); } if (!retry && pending_cmd) diff --git a/drivers/crypto/ycc/ycc_ring.h b/drivers/crypto/alibaba/alicc/alicc_ring.h similarity index 65% rename from drivers/crypto/ycc/ycc_ring.h rename to drivers/crypto/alibaba/alicc/alicc_ring.h index 5f48a5eb0f0e..9ad0f5a518e8 100644 --- a/drivers/crypto/ycc/ycc_ring.h +++ b/drivers/crypto/alibaba/alicc/alicc_ring.h @@ -1,11 +1,11 @@ // SPDX-License-Identifier: GPL-2.0 -#ifndef __YCC_RING_H -#define __YCC_RING_H +#ifndef __ALICC_RING_H +#define __ALICC_RING_H #include #include -#include "ycc_dev.h" +#include "alicc_dev.h" #define CMD_ILLEGAL 0x15 #define CMD_UNDERATTACK 0x25 @@ -30,13 +30,13 @@ enum ring_type { INVAL_RING, }; -struct ycc_ring { +struct alicc_ring { u16 ring_id; u32 status; atomic_t ref_cnt; void __iomem *csr_vaddr; /* config register address */ resource_size_t csr_paddr; - struct ycc_dev *ydev; /* belongs to which ydev */ + struct alicc_dev *ydev; /* belongs to which ydev */ struct uio_info *uio_info; struct dentry *debug_dir; @@ -57,18 +57,18 @@ struct ycc_ring { struct work_struct work; }; -struct ycc_flags { +struct alicc_flags { void *ptr; - int (*ycc_done_callback)(void *ptr, u16 state); + int (*alicc_done_callback)(void *ptr, u16 state); }; -struct ycc_resp_desc { +struct alicc_resp_desc { u64 private_ptr; u16 state; u8 reserved[6]; }; -struct ycc_skcipher_cmd { +struct alicc_skcipher_cmd { u8 cmd_id; u8 mode; u64 sptr:48; @@ -80,7 +80,7 @@ struct ycc_skcipher_cmd { u8 padding; } __packed; -struct ycc_aead_cmd { +struct alicc_aead_cmd { u8 cmd_id; u8 mode; u64 sptr:48; /* include aad + payload */ @@ -93,7 +93,7 @@ struct ycc_aead_cmd { u8 taglen; /* authenc size */ } __packed; -struct ycc_rsa_enc_cmd { +struct alicc_rsa_enc_cmd { u8 cmd_id; u64 sptr:48; u16 key_id; @@ -103,7 +103,7 @@ struct ycc_rsa_enc_cmd { u64 dptr:48; } __packed; -struct ycc_rsa_dec_cmd { +struct alicc_rsa_dec_cmd { u8 cmd_id; u64 sptr:48; u16 key_id; @@ -114,48 +114,48 @@ struct ycc_rsa_dec_cmd { u64 dptr:48; } __packed; -struct ycc_sm2_verify_cmd { +struct alicc_sm2_verify_cmd { u8 cmd_id; u64 sptr:48; u16 key_id; u64 keyptr:48; } __packed; -union ycc_real_cmd { - struct ycc_skcipher_cmd ske_cmd; - struct ycc_aead_cmd aead_cmd; - struct ycc_rsa_enc_cmd rsa_enc_cmd; - struct ycc_rsa_dec_cmd rsa_dec_cmd; - struct ycc_sm2_verify_cmd sm2_verify_cmd; +union alicc_real_cmd { + struct alicc_skcipher_cmd ske_cmd; + struct alicc_aead_cmd aead_cmd; + struct alicc_rsa_enc_cmd rsa_enc_cmd; + struct alicc_rsa_dec_cmd rsa_dec_cmd; + struct alicc_sm2_verify_cmd sm2_verify_cmd; u8 padding[32]; }; -struct ycc_cmd_desc { - union ycc_real_cmd cmd; +struct alicc_cmd_desc { + union alicc_real_cmd cmd; u64 private_ptr; u8 reserved0[16]; u8 reserved1[8]; } __packed; -static inline void ycc_ring_get(struct ycc_ring *ring) +static inline void alicc_ring_get(struct alicc_ring *ring) { atomic_inc(&ring->ref_cnt); } -static inline void ycc_ring_put(struct ycc_ring *ring) +static inline void alicc_ring_put(struct alicc_ring *ring) { atomic_dec(&ring->ref_cnt); } -static inline bool ycc_ring_stopped(struct ycc_ring *ring) +static inline bool alicc_ring_stopped(struct alicc_ring *ring) { - return !!(YCC_CSR_RD(ring->csr_vaddr, REG_RING_CFG) & RING_STOP_BIT); + return !!(ALICC_CSR_RD(ring->csr_vaddr, REG_RING_CFG) & RING_STOP_BIT); } -int ycc_enqueue(struct ycc_ring *ring, void *cmd); -void ycc_dequeue(struct ycc_ring *ring); -struct ycc_ring *ycc_crypto_get_ring(void); -void ycc_crypto_free_ring(struct ycc_ring *ring); -int ycc_dev_rings_init(struct ycc_dev *ydev, u32 max_desc, int user_rings); -void ycc_dev_rings_release(struct ycc_dev *ydev, int user_rings); +int alicc_enqueue(struct alicc_ring *ring, void *cmd); +void alicc_dequeue(struct alicc_ring *ring); +struct alicc_ring *alicc_crypto_get_ring(void); +void alicc_crypto_free_ring(struct alicc_ring *ring); +int alicc_dev_rings_init(struct alicc_dev *ydev, u32 max_desc, int user_rings); +void alicc_dev_rings_release(struct alicc_dev *ydev, int user_rings); #endif diff --git a/drivers/crypto/ycc/ycc_ske.c b/drivers/crypto/alibaba/alicc/alicc_ske.c similarity index 55% rename from drivers/crypto/ycc/ycc_ske.c rename to drivers/crypto/alibaba/alicc/alicc_ske.c index d7cbb0789ed5..1afb13610c61 100644 --- a/drivers/crypto/ycc/ycc_ske.c +++ b/drivers/crypto/alibaba/alicc/alicc_ske.c @@ -8,13 +8,13 @@ #include #include #include -#include "ycc_algs.h" +#include "alicc_algs.h" -static int ycc_skcipher_setkey(struct crypto_skcipher *tfm, const u8 *key, +static int alicc_skcipher_setkey(struct crypto_skcipher *tfm, const u8 *key, unsigned int key_size, int mode, unsigned int key_dma_size) { - struct ycc_crypto_ctx *ctx = crypto_skcipher_ctx(tfm); + struct alicc_crypto_ctx *ctx = crypto_skcipher_ctx(tfm); if (ctx->cipher_key) { memset(ctx->cipher_key, 0, ctx->keysize); @@ -34,98 +34,98 @@ static int ycc_skcipher_setkey(struct crypto_skcipher *tfm, const u8 *key, return 0; } -#define DEFINE_YCC_SKE_AES_SETKEY(name, mode, size) \ -int ycc_skcipher_aes_##name##_setkey(struct crypto_skcipher *tfm, \ +#define DEFINE_ALICC_SKE_AES_SETKEY(name, mode, size) \ +int alicc_skcipher_aes_##name##_setkey(struct crypto_skcipher *tfm, \ const u8 *key, \ unsigned int key_size) \ { \ int alg_mode; \ switch (key_size) { \ case AES_KEYSIZE_128: \ - alg_mode = YCC_AES_128_##mode; \ + alg_mode = ALICC_AES_128_##mode; \ break; \ case AES_KEYSIZE_192: \ - alg_mode = YCC_AES_192_##mode; \ + alg_mode = ALICC_AES_192_##mode; \ break; \ case AES_KEYSIZE_256: \ - alg_mode = YCC_AES_256_##mode; \ + alg_mode = ALICC_AES_256_##mode; \ break; \ default: \ return -EINVAL; \ } \ - return ycc_skcipher_setkey(tfm, key, key_size, alg_mode, size); \ + return alicc_skcipher_setkey(tfm, key, key_size, alg_mode, size); \ } -#define DEFINE_YCC_SKE_SM4_SETKEY(name, mode, size) \ -int ycc_skcipher_sm4_##name##_setkey(struct crypto_skcipher *tfm, \ +#define DEFINE_ALICC_SKE_SM4_SETKEY(name, mode, size) \ +int alicc_skcipher_sm4_##name##_setkey(struct crypto_skcipher *tfm, \ const u8 *key, \ unsigned int key_size) \ { \ - int alg_mode = YCC_SM4_##mode; \ + int alg_mode = ALICC_SM4_##mode; \ if (key_size != SM4_KEY_SIZE) \ return -EINVAL; \ - return ycc_skcipher_setkey(tfm, key, key_size, alg_mode, size); \ + return alicc_skcipher_setkey(tfm, key, key_size, alg_mode, size); \ } -#define DEFINE_YCC_SKE_DES_SETKEY(name, mode, size) \ -int ycc_skcipher_des_##name##_setkey(struct crypto_skcipher *tfm, \ +#define DEFINE_ALICC_SKE_DES_SETKEY(name, mode, size) \ +int alicc_skcipher_des_##name##_setkey(struct crypto_skcipher *tfm, \ const u8 *key, \ unsigned int key_size) \ { \ - int alg_mode = YCC_DES_##mode; \ + int alg_mode = ALICC_DES_##mode; \ int ret; \ if (key_size != DES_KEY_SIZE) \ return -EINVAL; \ ret = verify_skcipher_des_key(tfm, key); \ if (ret) \ return ret; \ - return ycc_skcipher_setkey(tfm, key, key_size, alg_mode, size); \ + return alicc_skcipher_setkey(tfm, key, key_size, alg_mode, size); \ } -#define DEFINE_YCC_SKE_3DES_SETKEY(name, mode, size) \ -int ycc_skcipher_3des_##name##_setkey(struct crypto_skcipher *tfm, \ +#define DEFINE_ALICC_SKE_3DES_SETKEY(name, mode, size) \ +int alicc_skcipher_3des_##name##_setkey(struct crypto_skcipher *tfm, \ const u8 *key, \ unsigned int key_size) \ { \ - int alg_mode = YCC_TDES_192_##mode; \ + int alg_mode = ALICC_TDES_192_##mode; \ int ret; \ if (key_size != DES3_EDE_KEY_SIZE) \ return -EINVAL; \ ret = verify_skcipher_des3_key(tfm, key); \ if (ret) \ return ret; \ - return ycc_skcipher_setkey(tfm, key, key_size, alg_mode, size); \ + return alicc_skcipher_setkey(tfm, key, key_size, alg_mode, size); \ } /* * ECB: Only has 1 key, without IV, at least 32 bytes. * Others except XTS: |key|iv|, at least 48 bytes. */ -DEFINE_YCC_SKE_AES_SETKEY(ecb, ECB, 32); -DEFINE_YCC_SKE_AES_SETKEY(cbc, CBC, 48); -DEFINE_YCC_SKE_AES_SETKEY(ctr, CTR, 48); -DEFINE_YCC_SKE_AES_SETKEY(cfb, CFB, 48); -DEFINE_YCC_SKE_AES_SETKEY(ofb, OFB, 48); - -DEFINE_YCC_SKE_SM4_SETKEY(ecb, ECB, 32); -DEFINE_YCC_SKE_SM4_SETKEY(cbc, CBC, 48); -DEFINE_YCC_SKE_SM4_SETKEY(ctr, CTR, 48); -DEFINE_YCC_SKE_SM4_SETKEY(cfb, CFB, 48); -DEFINE_YCC_SKE_SM4_SETKEY(ofb, OFB, 48); - -DEFINE_YCC_SKE_DES_SETKEY(ecb, ECB, 32); -DEFINE_YCC_SKE_DES_SETKEY(cbc, CBC, 48); -DEFINE_YCC_SKE_DES_SETKEY(ctr, CTR, 48); -DEFINE_YCC_SKE_DES_SETKEY(cfb, CFB, 48); -DEFINE_YCC_SKE_DES_SETKEY(ofb, OFB, 48); - -DEFINE_YCC_SKE_3DES_SETKEY(ecb, ECB, 32); -DEFINE_YCC_SKE_3DES_SETKEY(cbc, CBC, 48); -DEFINE_YCC_SKE_3DES_SETKEY(ctr, CTR, 48); -DEFINE_YCC_SKE_3DES_SETKEY(cfb, CFB, 48); -DEFINE_YCC_SKE_3DES_SETKEY(ofb, OFB, 48); - -int ycc_skcipher_aes_xts_setkey(struct crypto_skcipher *tfm, +DEFINE_ALICC_SKE_AES_SETKEY(ecb, ECB, 32); +DEFINE_ALICC_SKE_AES_SETKEY(cbc, CBC, 48); +DEFINE_ALICC_SKE_AES_SETKEY(ctr, CTR, 48); +DEFINE_ALICC_SKE_AES_SETKEY(cfb, CFB, 48); +DEFINE_ALICC_SKE_AES_SETKEY(ofb, OFB, 48); + +DEFINE_ALICC_SKE_SM4_SETKEY(ecb, ECB, 32); +DEFINE_ALICC_SKE_SM4_SETKEY(cbc, CBC, 48); +DEFINE_ALICC_SKE_SM4_SETKEY(ctr, CTR, 48); +DEFINE_ALICC_SKE_SM4_SETKEY(cfb, CFB, 48); +DEFINE_ALICC_SKE_SM4_SETKEY(ofb, OFB, 48); + +DEFINE_ALICC_SKE_DES_SETKEY(ecb, ECB, 32); +DEFINE_ALICC_SKE_DES_SETKEY(cbc, CBC, 48); +DEFINE_ALICC_SKE_DES_SETKEY(ctr, CTR, 48); +DEFINE_ALICC_SKE_DES_SETKEY(cfb, CFB, 48); +DEFINE_ALICC_SKE_DES_SETKEY(ofb, OFB, 48); + +DEFINE_ALICC_SKE_3DES_SETKEY(ecb, ECB, 32); +DEFINE_ALICC_SKE_3DES_SETKEY(cbc, CBC, 48); +DEFINE_ALICC_SKE_3DES_SETKEY(ctr, CTR, 48); +DEFINE_ALICC_SKE_3DES_SETKEY(cfb, CFB, 48); +DEFINE_ALICC_SKE_3DES_SETKEY(ofb, OFB, 48); + +int alicc_skcipher_aes_xts_setkey(struct crypto_skcipher *tfm, const u8 *key, unsigned int key_size) { @@ -138,20 +138,20 @@ int ycc_skcipher_aes_xts_setkey(struct crypto_skcipher *tfm, switch (key_size) { case AES_KEYSIZE_128 * 2: - alg_mode = YCC_AES_128_XTS; + alg_mode = ALICC_AES_128_XTS; break; case AES_KEYSIZE_256 * 2: - alg_mode = YCC_AES_256_XTS; + alg_mode = ALICC_AES_256_XTS; break; default: return -EINVAL; } /* XTS: |key1|key2|iv|, at least 32 + 32 + 16 bytes */ - return ycc_skcipher_setkey(tfm, key, key_size, alg_mode, 80); + return alicc_skcipher_setkey(tfm, key, key_size, alg_mode, 80); } -int ycc_skcipher_sm4_xts_setkey(struct crypto_skcipher *tfm, +int alicc_skcipher_sm4_xts_setkey(struct crypto_skcipher *tfm, const u8 *key, unsigned int key_size) { @@ -165,14 +165,14 @@ int ycc_skcipher_sm4_xts_setkey(struct crypto_skcipher *tfm, if (key_size != SM4_KEY_SIZE * 2) return -EINVAL; - alg_mode = YCC_SM4_XTS; - return ycc_skcipher_setkey(tfm, key, key_size, alg_mode, 80); + alg_mode = ALICC_SM4_XTS; + return alicc_skcipher_setkey(tfm, key, key_size, alg_mode, 80); } -static int ycc_skcipher_fill_key(struct ycc_crypto_req *req) +static int alicc_skcipher_fill_key(struct alicc_crypto_req *req) { - struct ycc_crypto_ctx *ctx = req->ctx; - struct device *dev = YCC_DEV(ctx); + struct alicc_crypto_ctx *ctx = req->ctx; + struct device *dev = ALICC_DEV(ctx); struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req->ske_req); u32 ivsize = crypto_skcipher_ivsize(tfm); @@ -196,19 +196,19 @@ static int ycc_skcipher_fill_key(struct ycc_crypto_req *req) } if (ivsize) { - if (ctx->mode == YCC_DES_ECB || - ctx->mode == YCC_TDES_128_ECB || - ctx->mode == YCC_TDES_192_ECB || - ctx->mode == YCC_AES_128_ECB || - ctx->mode == YCC_AES_192_ECB || - ctx->mode == YCC_AES_256_ECB || - ctx->mode == YCC_SM4_ECB) { + if (ctx->mode == ALICC_DES_ECB || + ctx->mode == ALICC_TDES_128_ECB || + ctx->mode == ALICC_TDES_192_ECB || + ctx->mode == ALICC_AES_128_ECB || + ctx->mode == ALICC_AES_192_ECB || + ctx->mode == ALICC_AES_256_ECB || + ctx->mode == ALICC_SM4_ECB) { pr_err("Illegal ivsize for ECB mode, should be zero"); goto clear_key; } /* DES or 3DES */ - if (ctx->mode >= YCC_DES_ECB && ctx->mode <= YCC_TDES_192_CTR) { + if (ctx->mode >= ALICC_DES_ECB && ctx->mode <= ALICC_TDES_192_CTR) { if (ivsize > 8) goto clear_key; memcpy(req->key_vaddr + ctx->key_dma_size - 8, @@ -227,9 +227,9 @@ static int ycc_skcipher_fill_key(struct ycc_crypto_req *req) return -EINVAL; } -static int ycc_skcipher_sg_map(struct ycc_crypto_req *req) +static int alicc_skcipher_sg_map(struct alicc_crypto_req *req) { - struct device *dev = YCC_DEV(req->ctx); + struct device *dev = ALICC_DEV(req->ctx); struct skcipher_request *ske_req = req->ske_req; int src_nents; @@ -256,9 +256,9 @@ static int ycc_skcipher_sg_map(struct ycc_crypto_req *req) return 0; } -static inline void ycc_skcipher_sg_unmap(struct ycc_crypto_req *req) +static inline void alicc_skcipher_sg_unmap(struct alicc_crypto_req *req) { - struct device *dev = YCC_DEV(req->ctx); + struct device *dev = ALICC_DEV(req->ctx); dma_free_coherent(dev, ALIGN(req->in_len, 64), req->src_vaddr, req->src_paddr); dma_free_coherent(dev, ALIGN(req->in_len, 64), req->dst_vaddr, req->dst_paddr); @@ -267,7 +267,7 @@ static inline void ycc_skcipher_sg_unmap(struct ycc_crypto_req *req) /* * For CBC & CTR */ -static void ycc_skcipher_iv_out(struct ycc_crypto_req *req, void *dst) +static void alicc_skcipher_iv_out(struct alicc_crypto_req *req, void *dst) { struct skcipher_request *ske_req = req->ske_req; struct crypto_skcipher *stfm = crypto_skcipher_reqtfm(ske_req); @@ -277,27 +277,27 @@ static void ycc_skcipher_iv_out(struct ycc_crypto_req *req, void *dst) u32 nb = (ske_req->cryptlen + bs - 1) / bs; switch (mode) { - case YCC_DES_CBC: - case YCC_TDES_128_CBC: - case YCC_TDES_192_CBC: - case YCC_AES_128_CBC: - case YCC_AES_192_CBC: - case YCC_AES_256_CBC: - case YCC_SM4_CBC: - if (cmd == YCC_CMD_SKE_DEC) + case ALICC_DES_CBC: + case ALICC_TDES_128_CBC: + case ALICC_TDES_192_CBC: + case ALICC_AES_128_CBC: + case ALICC_AES_192_CBC: + case ALICC_AES_256_CBC: + case ALICC_SM4_CBC: + if (cmd == ALICC_CMD_SKE_DEC) memcpy(ske_req->iv, req->last_block, bs); else memcpy(ske_req->iv, (u8 *)dst + ALIGN(ske_req->cryptlen, bs) - bs, bs); break; - case YCC_DES_CTR: - case YCC_TDES_128_CTR: - case YCC_TDES_192_CTR: - case YCC_AES_128_CTR: - case YCC_AES_192_CTR: - case YCC_AES_256_CTR: - case YCC_SM4_CTR: + case ALICC_DES_CTR: + case ALICC_TDES_128_CTR: + case ALICC_TDES_192_CTR: + case ALICC_AES_128_CTR: + case ALICC_AES_192_CTR: + case ALICC_AES_256_CTR: + case ALICC_SM4_CTR: for ( ; nb-- ; ) crypto_inc(ske_req->iv, bs); break; @@ -306,21 +306,21 @@ static void ycc_skcipher_iv_out(struct ycc_crypto_req *req, void *dst) } } -static int ycc_skcipher_callback(void *ptr, u16 state) +static int alicc_skcipher_callback(void *ptr, u16 state) { - struct ycc_crypto_req *req = (struct ycc_crypto_req *)ptr; + struct alicc_crypto_req *req = (struct alicc_crypto_req *)ptr; struct skcipher_request *ske_req = req->ske_req; - struct ycc_crypto_ctx *ctx = req->ctx; - struct device *dev = YCC_DEV(ctx); + struct alicc_crypto_ctx *ctx = req->ctx; + struct device *dev = ALICC_DEV(ctx); sg_copy_from_buffer(ske_req->dst, sg_nents_for_len(ske_req->dst, ske_req->cryptlen), req->dst_vaddr, ske_req->cryptlen); if (state == CMD_SUCCESS) - ycc_skcipher_iv_out(req, req->dst_vaddr); + alicc_skcipher_iv_out(req, req->dst_vaddr); - ycc_skcipher_sg_unmap(req); + alicc_skcipher_sg_unmap(req); if (req->key_vaddr) { memset(req->key_vaddr, 0, ALIGN(ctx->key_dma_size, 64)); @@ -335,18 +335,18 @@ static int ycc_skcipher_callback(void *ptr, u16 state) return 0; } -static inline bool ycc_skcipher_do_soft(struct ycc_dev *ydev) +static inline bool alicc_skcipher_do_soft(struct alicc_dev *ydev) { return !test_bit(YDEV_STATUS_READY, &ydev->status); } -static int ycc_skcipher_submit_desc(struct skcipher_request *ske_req, u8 cmd) +static int alicc_skcipher_submit_desc(struct skcipher_request *ske_req, u8 cmd) { struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(ske_req); - struct ycc_crypto_req *req = skcipher_request_ctx(ske_req); - struct ycc_skcipher_cmd *ske_cmd = &req->desc.cmd.ske_cmd; - struct ycc_crypto_ctx *ctx = crypto_skcipher_ctx(tfm); - struct ycc_flags *aflags; + struct alicc_crypto_req *req = skcipher_request_ctx(ske_req); + struct alicc_skcipher_cmd *ske_cmd = &req->desc.cmd.ske_cmd; + struct alicc_crypto_ctx *ctx = crypto_skcipher_ctx(tfm); + struct alicc_flags *aflags; u8 bs = crypto_skcipher_blocksize(tfm); int ret; @@ -362,21 +362,21 @@ static int ycc_skcipher_submit_desc(struct skcipher_request *ske_req, u8 cmd) if (req->in_len % 64 == bs) req->in_len += bs; - ret = ycc_skcipher_fill_key(req); + ret = alicc_skcipher_fill_key(req); if (ret) return ret; - ret = ycc_skcipher_sg_map(req); + ret = alicc_skcipher_sg_map(req); if (ret) goto free_key; ret = -ENOMEM; - aflags = kzalloc(sizeof(struct ycc_flags), GFP_ATOMIC); + aflags = kzalloc(sizeof(struct alicc_flags), GFP_ATOMIC); if (!aflags) goto sg_unmap; aflags->ptr = (void *)req; - aflags->ycc_done_callback = ycc_skcipher_callback; + aflags->alicc_done_callback = alicc_skcipher_callback; req->desc.private_ptr = (u64)aflags; ske_cmd->cmd_id = cmd; @@ -388,11 +388,11 @@ static int ycc_skcipher_submit_desc(struct skcipher_request *ske_req, u8 cmd) ske_cmd->padding = 0; /* LKCF will check iv output, for decryption, the iv is its last block */ - if (cmd == YCC_CMD_SKE_DEC) + if (cmd == ALICC_CMD_SKE_DEC) memcpy(req->last_block, req->src_vaddr + ALIGN(ske_req->cryptlen, bs) - bs, bs); - ret = ycc_enqueue(ctx->ring, &req->desc); + ret = alicc_enqueue(ctx->ring, &req->desc); if (!ret) return -EINPROGRESS; @@ -400,24 +400,24 @@ static int ycc_skcipher_submit_desc(struct skcipher_request *ske_req, u8 cmd) kfree(aflags); sg_unmap: - ycc_skcipher_sg_unmap(req); + alicc_skcipher_sg_unmap(req); free_key: memset(req->key_vaddr, 0, ALIGN(ctx->key_dma_size, 64)); - dma_free_coherent(YCC_DEV(ctx), + dma_free_coherent(ALICC_DEV(ctx), ALIGN(ctx->key_dma_size, 64), req->key_vaddr, req->key_paddr); req->key_vaddr = NULL; return ret; } -static int ycc_skcipher_encrypt(struct skcipher_request *req) +static int alicc_skcipher_encrypt(struct skcipher_request *req) { struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); - struct ycc_crypto_ctx *ctx = crypto_skcipher_ctx(tfm); + struct alicc_crypto_ctx *ctx = crypto_skcipher_ctx(tfm); struct skcipher_request *subreq = - &((struct ycc_crypto_req *)skcipher_request_ctx(req))->ske_subreq; + &((struct alicc_crypto_req *)skcipher_request_ctx(req))->ske_subreq; - if (ycc_skcipher_do_soft(ctx->ring->ydev)) { + if (alicc_skcipher_do_soft(ctx->ring->ydev)) { skcipher_request_set_tfm(subreq, ctx->soft_tfm); skcipher_request_set_callback(subreq, req->base.flags, req->base.complete, req->base.data); @@ -426,17 +426,17 @@ static int ycc_skcipher_encrypt(struct skcipher_request *req) return crypto_skcipher_encrypt(subreq); } - return ycc_skcipher_submit_desc(req, YCC_CMD_SKE_ENC); + return alicc_skcipher_submit_desc(req, ALICC_CMD_SKE_ENC); } -static int ycc_skcipher_decrypt(struct skcipher_request *req) +static int alicc_skcipher_decrypt(struct skcipher_request *req) { struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req); - struct ycc_crypto_ctx *ctx = crypto_skcipher_ctx(tfm); + struct alicc_crypto_ctx *ctx = crypto_skcipher_ctx(tfm); struct skcipher_request *subreq = - &((struct ycc_crypto_req *)skcipher_request_ctx(req))->ske_subreq; + &((struct alicc_crypto_req *)skcipher_request_ctx(req))->ske_subreq; - if (ycc_skcipher_do_soft(ctx->ring->ydev)) { + if (alicc_skcipher_do_soft(ctx->ring->ydev)) { skcipher_request_set_tfm(subreq, ctx->soft_tfm); skcipher_request_set_callback(subreq, req->base.flags, req->base.complete, req->base.data); @@ -445,13 +445,13 @@ static int ycc_skcipher_decrypt(struct skcipher_request *req) return crypto_skcipher_encrypt(subreq); } - return ycc_skcipher_submit_desc(req, YCC_CMD_SKE_DEC); + return alicc_skcipher_submit_desc(req, ALICC_CMD_SKE_DEC); } -static int ycc_skcipher_init(struct crypto_skcipher *tfm) +static int alicc_skcipher_init(struct crypto_skcipher *tfm) { - struct ycc_crypto_ctx *ctx = crypto_skcipher_ctx(tfm); - struct ycc_ring *ring; + struct alicc_crypto_ctx *ctx = crypto_skcipher_ctx(tfm); + struct alicc_ring *ring; ctx->soft_tfm = crypto_alloc_skcipher(crypto_tfm_alg_name(crypto_skcipher_tfm(tfm)), 0, CRYPTO_ALG_NEED_FALLBACK | CRYPTO_ALG_ASYNC); @@ -459,16 +459,16 @@ static int ycc_skcipher_init(struct crypto_skcipher *tfm) pr_warn("Failed to allocate soft tfm for:%s, software fallback is limited\n", crypto_tfm_alg_name(crypto_skcipher_tfm(tfm))); ctx->soft_tfm = NULL; - crypto_skcipher_set_reqsize(tfm, sizeof(struct ycc_crypto_req)); + crypto_skcipher_set_reqsize(tfm, sizeof(struct alicc_crypto_req)); } else { /* * If it's software fallback, store meta data of soft request. */ - crypto_skcipher_set_reqsize(tfm, sizeof(struct ycc_crypto_req) + + crypto_skcipher_set_reqsize(tfm, sizeof(struct alicc_crypto_req) + crypto_skcipher_reqsize(ctx->soft_tfm)); } - ring = ycc_crypto_get_ring(); + ring = alicc_crypto_get_ring(); if (!ring) return -ENOMEM; @@ -476,12 +476,12 @@ static int ycc_skcipher_init(struct crypto_skcipher *tfm) return 0; } -static void ycc_skcipher_exit(struct crypto_skcipher *tfm) +static void alicc_skcipher_exit(struct crypto_skcipher *tfm) { - struct ycc_crypto_ctx *ctx = crypto_skcipher_ctx(tfm); + struct alicc_crypto_ctx *ctx = crypto_skcipher_ctx(tfm); if (ctx->ring) - ycc_crypto_free_ring(ctx->ring); + alicc_crypto_free_ring(ctx->ring); kfree(ctx->cipher_key); @@ -490,22 +490,22 @@ static void ycc_skcipher_exit(struct crypto_skcipher *tfm) } -static struct skcipher_alg ycc_skciphers[] = { +static struct skcipher_alg alicc_skciphers[] = { { .base = { .cra_name = "cbc(aes)", - .cra_driver_name = "ycc_cbc(aes)", + .cra_driver_name = "alicc_cbc(aes)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = AES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_aes_cbc_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_aes_cbc_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = AES_MIN_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE, .ivsize = AES_BLOCK_SIZE, @@ -513,18 +513,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "ecb(aes)", - .cra_driver_name = "ycc_ecb(aes)", + .cra_driver_name = "alicc_ecb(aes)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = AES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_aes_ecb_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_aes_ecb_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = AES_MIN_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE, .ivsize = 0, @@ -532,18 +532,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "ctr(aes)", - .cra_driver_name = "ycc_ctr(aes)", + .cra_driver_name = "alicc_ctr(aes)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = AES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_aes_ctr_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_aes_ctr_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = AES_MIN_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE, .ivsize = AES_BLOCK_SIZE, @@ -551,18 +551,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "cfb(aes)", - .cra_driver_name = "ycc_cfb(aes)", + .cra_driver_name = "alicc_cfb(aes)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = AES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_aes_cfb_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_aes_cfb_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = AES_MIN_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE, .ivsize = AES_BLOCK_SIZE, @@ -570,18 +570,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "ofb(aes)", - .cra_driver_name = "ycc_ofb(aes)", + .cra_driver_name = "alicc_ofb(aes)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = AES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_aes_ofb_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_aes_ofb_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = AES_MIN_KEY_SIZE, .max_keysize = AES_MAX_KEY_SIZE, .ivsize = AES_BLOCK_SIZE, @@ -589,18 +589,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "xts(aes)", - .cra_driver_name = "ycc_xts(aes)", + .cra_driver_name = "alicc_xts(aes)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = AES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_aes_xts_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_aes_xts_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = AES_MIN_KEY_SIZE * 2, .max_keysize = AES_MAX_KEY_SIZE * 2, .ivsize = AES_BLOCK_SIZE, @@ -608,18 +608,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "cbc(sm4)", - .cra_driver_name = "ycc_cbc(sm4)", + .cra_driver_name = "alicc_cbc(sm4)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = SM4_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_sm4_cbc_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_sm4_cbc_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = SM4_KEY_SIZE, .max_keysize = SM4_KEY_SIZE, .ivsize = SM4_BLOCK_SIZE, @@ -627,18 +627,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "ecb(sm4)", - .cra_driver_name = "ycc_ecb(sm4)", + .cra_driver_name = "alicc_ecb(sm4)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = SM4_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_sm4_ecb_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_sm4_ecb_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = SM4_KEY_SIZE, .max_keysize = SM4_KEY_SIZE, .ivsize = 0, @@ -646,18 +646,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "ctr(sm4)", - .cra_driver_name = "ycc_ctr(sm4)", + .cra_driver_name = "alicc_ctr(sm4)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = SM4_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_sm4_ctr_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_sm4_ctr_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = SM4_KEY_SIZE, .max_keysize = SM4_KEY_SIZE, .ivsize = SM4_BLOCK_SIZE, @@ -665,18 +665,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "cfb(sm4)", - .cra_driver_name = "ycc_cfb(sm4)", + .cra_driver_name = "alicc_cfb(sm4)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = SM4_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_sm4_cfb_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_sm4_cfb_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = SM4_KEY_SIZE, .max_keysize = SM4_KEY_SIZE, .ivsize = SM4_BLOCK_SIZE, @@ -684,18 +684,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "ofb(sm4)", - .cra_driver_name = "ycc_ofb(sm4)", + .cra_driver_name = "alicc_ofb(sm4)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = SM4_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_sm4_ofb_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_sm4_ofb_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = SM4_KEY_SIZE, .max_keysize = SM4_KEY_SIZE, .ivsize = SM4_BLOCK_SIZE, @@ -703,18 +703,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "xts(sm4)", - .cra_driver_name = "ycc_xts(sm4)", + .cra_driver_name = "alicc_xts(sm4)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = SM4_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_sm4_xts_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_sm4_xts_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = SM4_KEY_SIZE * 2, .max_keysize = SM4_KEY_SIZE * 2, .ivsize = SM4_BLOCK_SIZE, @@ -722,18 +722,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "cbc(des)", - .cra_driver_name = "ycc_cbc(des)", + .cra_driver_name = "alicc_cbc(des)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = DES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_des_cbc_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_des_cbc_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = DES_KEY_SIZE, .max_keysize = DES_KEY_SIZE, .ivsize = DES_BLOCK_SIZE, @@ -741,18 +741,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "ecb(des)", - .cra_driver_name = "ycc_ecb(des)", + .cra_driver_name = "alicc_ecb(des)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = DES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_des_ecb_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_des_ecb_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = DES_KEY_SIZE, .max_keysize = DES_KEY_SIZE, .ivsize = 0, @@ -760,18 +760,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "ctr(des)", - .cra_driver_name = "ycc_ctr(des)", + .cra_driver_name = "alicc_ctr(des)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = DES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_des_ctr_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_des_ctr_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = DES_KEY_SIZE, .max_keysize = DES_KEY_SIZE, .ivsize = DES_BLOCK_SIZE, @@ -779,18 +779,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "cfb(des)", - .cra_driver_name = "ycc_cfb(des)", + .cra_driver_name = "alicc_cfb(des)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = DES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_des_cfb_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_des_cfb_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = DES_KEY_SIZE, .max_keysize = DES_KEY_SIZE, .ivsize = DES_BLOCK_SIZE, @@ -798,18 +798,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "ofb(des)", - .cra_driver_name = "ycc_ofb(des)", + .cra_driver_name = "alicc_ofb(des)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = DES_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_des_ofb_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_des_ofb_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = DES_KEY_SIZE, .max_keysize = DES_KEY_SIZE, .ivsize = DES_BLOCK_SIZE, @@ -817,18 +817,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "cbc(des3_ede)", - .cra_driver_name = "ycc_cbc(des3_ede)", + .cra_driver_name = "alicc_cbc(des3_ede)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = DES3_EDE_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_3des_cbc_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_3des_cbc_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = DES3_EDE_KEY_SIZE, .max_keysize = DES3_EDE_KEY_SIZE, .ivsize = DES3_EDE_BLOCK_SIZE, @@ -836,18 +836,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "ecb(des3_ede)", - .cra_driver_name = "ycc_ecb(des3_ede)", + .cra_driver_name = "alicc_ecb(des3_ede)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = DES3_EDE_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_3des_ecb_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_3des_ecb_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = DES3_EDE_KEY_SIZE, .max_keysize = DES3_EDE_KEY_SIZE, .ivsize = 0, @@ -855,18 +855,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "ctr(des3_ede)", - .cra_driver_name = "ycc_ctr(des3_ede)", + .cra_driver_name = "alicc_ctr(des3_ede)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = DES3_EDE_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_3des_ctr_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_3des_ctr_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = DES3_EDE_KEY_SIZE, .max_keysize = DES3_EDE_KEY_SIZE, .ivsize = DES3_EDE_BLOCK_SIZE, @@ -874,18 +874,18 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "cfb(des3_ede)", - .cra_driver_name = "ycc_cfb(des3_ede)", + .cra_driver_name = "alicc_cfb(des3_ede)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = DES3_EDE_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_3des_cfb_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_3des_cfb_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = DES3_EDE_KEY_SIZE, .max_keysize = DES3_EDE_KEY_SIZE, .ivsize = DES3_EDE_BLOCK_SIZE, @@ -893,30 +893,30 @@ static struct skcipher_alg ycc_skciphers[] = { { .base = { .cra_name = "ofb(des3_ede)", - .cra_driver_name = "ycc_ofb(des3_ede)", + .cra_driver_name = "alicc_ofb(des3_ede)", .cra_priority = 4001, .cra_flags = CRYPTO_ALG_ASYNC, .cra_blocksize = DES3_EDE_BLOCK_SIZE, - .cra_ctxsize = sizeof(struct ycc_crypto_ctx), + .cra_ctxsize = sizeof(struct alicc_crypto_ctx), .cra_module = THIS_MODULE, }, - .init = ycc_skcipher_init, - .exit = ycc_skcipher_exit, - .setkey = ycc_skcipher_3des_ofb_setkey, - .encrypt = ycc_skcipher_encrypt, - .decrypt = ycc_skcipher_decrypt, + .init = alicc_skcipher_init, + .exit = alicc_skcipher_exit, + .setkey = alicc_skcipher_3des_ofb_setkey, + .encrypt = alicc_skcipher_encrypt, + .decrypt = alicc_skcipher_decrypt, .min_keysize = DES3_EDE_KEY_SIZE, .max_keysize = DES3_EDE_KEY_SIZE, .ivsize = DES3_EDE_BLOCK_SIZE, }, }; -int ycc_sym_register(void) +int alicc_sym_register(void) { - return crypto_register_skciphers(ycc_skciphers, ARRAY_SIZE(ycc_skciphers)); + return crypto_register_skciphers(alicc_skciphers, ARRAY_SIZE(alicc_skciphers)); } -void ycc_sym_unregister(void) +void alicc_sym_unregister(void) { - crypto_unregister_skciphers(ycc_skciphers, ARRAY_SIZE(ycc_skciphers)); + crypto_unregister_skciphers(alicc_skciphers, ARRAY_SIZE(alicc_skciphers)); } diff --git a/drivers/crypto/ycc/ycc_uio.c b/drivers/crypto/alibaba/alicc/alicc_uio.c similarity index 50% rename from drivers/crypto/ycc/ycc_uio.c rename to drivers/crypto/alibaba/alicc/alicc_uio.c index ee6d49faee0e..695364e31b40 100644 --- a/drivers/crypto/ycc/ycc_uio.c +++ b/drivers/crypto/alibaba/alicc/alicc_uio.c @@ -13,11 +13,11 @@ #include #include -#include "ycc_ring.h" -#include "ycc_dev.h" -#include "ycc_uio.h" +#include "alicc_ring.h" +#include "alicc_dev.h" +#include "alicc_uio.h" -#define YCC_UIO_REMAP_SIZE 0x1000 +#define ALICC_UIO_REMAP_SIZE 0x1000 /* * 1. Check if there're pending requests in ring @@ -25,12 +25,12 @@ * 3. If there're any requests that cannot complete, mark this ring as invalid * 4. When pending requests complete, update cmd wr ptr and resp rd ptr. */ -static inline void ycc_uio_ring_cleanup(struct ycc_ring *ring) +static inline void alicc_uio_ring_cleanup(struct alicc_ring *ring) { u32 pending_cmd; int retry = 5000; - pending_cmd = YCC_CSR_RD(ring->csr_vaddr, REG_RING_PENDING_CMD); + pending_cmd = ALICC_CSR_RD(ring->csr_vaddr, REG_RING_PENDING_CMD); while (pending_cmd && retry--) { udelay(100); cpu_relax(); @@ -43,19 +43,19 @@ static inline void ycc_uio_ring_cleanup(struct ycc_ring *ring) uio_unregister_device(ring->uio_info); } - ring->cmd_rd_ptr = YCC_CSR_RD(ring->csr_vaddr, REG_RING_CMD_RD_PTR); - ring->cmd_wr_ptr = YCC_CSR_RD(ring->csr_vaddr, REG_RING_CMD_WR_PTR); - ring->resp_rd_ptr = YCC_CSR_RD(ring->csr_vaddr, REG_RING_RSP_RD_PTR); - ring->resp_wr_ptr = YCC_CSR_RD(ring->csr_vaddr, REG_RING_RSP_WR_PTR); + ring->cmd_rd_ptr = ALICC_CSR_RD(ring->csr_vaddr, REG_RING_CMD_RD_PTR); + ring->cmd_wr_ptr = ALICC_CSR_RD(ring->csr_vaddr, REG_RING_CMD_WR_PTR); + ring->resp_rd_ptr = ALICC_CSR_RD(ring->csr_vaddr, REG_RING_RSP_RD_PTR); + ring->resp_wr_ptr = ALICC_CSR_RD(ring->csr_vaddr, REG_RING_RSP_WR_PTR); if (ring->resp_rd_ptr != ring->resp_wr_ptr) - YCC_CSR_WR(ring->csr_vaddr, REG_RING_RSP_RD_PTR, ring->resp_wr_ptr); + ALICC_CSR_WR(ring->csr_vaddr, REG_RING_RSP_RD_PTR, ring->resp_wr_ptr); } -static int ycc_uio_open(struct uio_info *info, struct inode *inode) +static int alicc_uio_open(struct uio_info *info, struct inode *inode) { - struct ycc_ring *ring = info->priv; - struct ycc_dev *ydev = ring->ydev; + struct alicc_ring *ring = info->priv; + struct alicc_dev *ydev = ring->ydev; /* * Uio ring only can be opened once to ensure atomicity @@ -66,16 +66,16 @@ static int ycc_uio_open(struct uio_info *info, struct inode *inode) return -EBUSY; } - ycc_ring_get(ring); - ycc_dev_get(ydev); + alicc_ring_get(ring); + alicc_dev_get(ydev); return 0; } -static int ycc_uio_release(struct uio_info *info, struct inode *inode) +static int alicc_uio_release(struct uio_info *info, struct inode *inode) { - struct ycc_ring *ring = info->priv; - struct ycc_dev *ydev = ring->ydev; + struct alicc_ring *ring = info->priv; + struct alicc_dev *ydev = ring->ydev; /* * Uio ring is monopolized by one user process, something is @@ -87,15 +87,15 @@ static int ycc_uio_release(struct uio_info *info, struct inode *inode) return -EFAULT; } - ycc_uio_ring_cleanup(ring); + alicc_uio_ring_cleanup(ring); - ycc_ring_put(ring); - ycc_dev_put(ydev); + alicc_ring_put(ring); + alicc_dev_put(ydev); return 0; } -static int ycc_uio_mmap(struct uio_info *info, struct vm_area_struct *vma) +static int alicc_uio_mmap(struct uio_info *info, struct vm_area_struct *vma) { vma->vm_flags |= VM_IO; @@ -104,24 +104,24 @@ static int ycc_uio_mmap(struct uio_info *info, struct vm_area_struct *vma) pgprot_noncached(vma->vm_page_prot)); } -static int ycc_uio_remap(struct ycc_ring *ring, struct uio_info *info) +static int alicc_uio_remap(struct alicc_ring *ring, struct uio_info *info) { u8 name[32]; - snprintf(name, sizeof(name), "YCC_DEV_%02d_RING_%02d_MAP", ring->ydev->id, ring->ring_id); + snprintf(name, sizeof(name), "ALICC_DEV_%02d_RING_%02d_MAP", ring->ydev->id, ring->ring_id); info->mem[0].name = kstrndup(name, sizeof(name), GFP_KERNEL); if (!info->mem[0].name) return -ENOMEM; info->mem[0].addr = ring->csr_paddr; info->mem[0].internal_addr = ring->csr_vaddr; - info->mem[0].size = YCC_UIO_REMAP_SIZE; + info->mem[0].size = ALICC_UIO_REMAP_SIZE; info->mem[0].memtype = UIO_MEM_PHYS; return 0; } -int ycc_uio_register(struct ycc_ring *ring) +int alicc_uio_register(struct alicc_ring *ring) { struct device *dev = &ring->ydev->pdev->dev; struct uio_info *info; @@ -132,13 +132,13 @@ int ycc_uio_register(struct ycc_ring *ring) if (!info) goto out; - ret = ycc_uio_remap(ring, info); + ret = alicc_uio_remap(ring, info); if (ret) { pr_err("Failed to kstrndup name for uio_mem\n"); goto free_info; } - snprintf(name, sizeof(name), "YCC_DEV_%02d_RING_%02d", ring->ydev->id, ring->ring_id); + snprintf(name, sizeof(name), "ALICC_DEV_%02d_RING_%02d", ring->ydev->id, ring->ring_id); info->name = kstrndup(name, sizeof(name), GFP_KERNEL); if (!info->name) { pr_err("Failed to kstrndup name for uio_info\n"); @@ -152,9 +152,9 @@ int ycc_uio_register(struct ycc_ring *ring) } info->priv = ring; - info->open = ycc_uio_open; - info->release = ycc_uio_release; - info->mmap = ycc_uio_mmap; + info->open = alicc_uio_open; + info->release = alicc_uio_release; + info->mmap = alicc_uio_mmap; info->irq_flags |= IRQF_SHARED | IRQF_ONESHOT; ret = uio_register_device(dev, info); @@ -178,7 +178,7 @@ int ycc_uio_register(struct ycc_ring *ring) return ret; } -void ycc_uio_unregister(struct ycc_ring *ring) +void alicc_uio_unregister(struct alicc_ring *ring) { struct uio_info *info = ring->uio_info; @@ -193,37 +193,37 @@ void ycc_uio_unregister(struct ycc_ring *ring) ring->uio_info = NULL; } -static DEFINE_MUTEX(ycc_mem_lock); +static DEFINE_MUTEX(alicc_mem_lock); /* * Each fd corresponding 1 info list. If there're multiple * fd opened, link itself */ -struct ycc_udma_info_list { +struct alicc_udma_info_list { int pid; /* process id */ DECLARE_HASHTABLE(udma_slot, PAGE_SHIFT); struct list_head fd_list; - struct ycc_udma_large_info large_mem; + struct alicc_udma_large_info large_mem; }; -struct ycc_udma_kern_info { +struct alicc_udma_kern_info { void *virt_addr; /* mem block start address */ dma_addr_t dma_addr; size_t size; struct hlist_node udma_hlist; }; -#define YCC_UIO_DEV_NR (2) +#define ALICC_UIO_DEV_NR (2) -static struct iommu_domain *ycc_domains[YCC_UIO_DEV_NR]; -static bool ycc_need_map = true; +static struct iommu_domain *alicc_domains[ALICC_UIO_DEV_NR]; +static bool alicc_need_map = true; /* * TODO: We don't allocate actual iommu_domain now. */ -static inline int ycc_alloc_iommu_domain(void) +static inline int alicc_alloc_iommu_domain(void) { if (!iommu_present(&pci_bus_type) || iommu_default_passthrough()) - ycc_need_map = false; + alicc_need_map = false; return 0; } @@ -231,117 +231,118 @@ static inline int ycc_alloc_iommu_domain(void) /* * TODO: We don't free actual iommu_domain now. */ -static void ycc_free_iommu_domain(void) +static void alicc_free_iommu_domain(void) { } -int ycc_bind_iommu_domain(struct pci_dev *pdev, int id) +int alicc_bind_iommu_domain(struct pci_dev *pdev, int id) { struct iommu_domain *domain; - if (!ycc_need_map) + if (!alicc_need_map) return 0; - if (id >= YCC_UIO_DEV_NR) + if (id >= ALICC_UIO_DEV_NR) return -EINVAL; domain = iommu_get_domain_for_dev(&pdev->dev); - ycc_domains[id] = domain; + alicc_domains[id] = domain; return 0; } -void ycc_unbind_iommu_domain(struct pci_dev *pdev, int id) +void alicc_unbind_iommu_domain(struct pci_dev *pdev, int id) { - if (!ycc_need_map) + if (!alicc_need_map) return; - if (id >= YCC_UIO_DEV_NR) + if (id >= ALICC_UIO_DEV_NR) return; - ycc_domains[id] = NULL; + alicc_domains[id] = NULL; } -#define YCC_SZ_2M (2ULL << 20) -#define YCC_2M_MASK (YCC_SZ_2M - 1) +#define ALICC_SZ_2M (2ULL << 20) +#define ALICC_2M_MASK (ALICC_SZ_2M - 1) /* * Direct mapping, iova equals phys. * So we don't use dma api, just phys_to_virt/virt_to_phys */ -static int ycc_mem_map(void *vaddr, size_t size) +static int alicc_mem_map(void *vaddr, size_t size) { phys_addr_t paddr; dma_addr_t iova; int ret = 0; - if (!ycc_need_map) + if (!alicc_need_map) return 0; paddr = virt_to_phys(vaddr); iova = paddr; - if (ycc_domains[0]) { - ret = iommu_map(ycc_domains[0], iova, paddr, size, IOMMU_READ|IOMMU_WRITE); + if (alicc_domains[0]) { + ret = iommu_map(alicc_domains[0], iova, paddr, size, IOMMU_READ|IOMMU_WRITE); if (ret) goto out; } - if (ycc_domains[1] && ycc_domains[1] != ycc_domains[0]) { - ret = iommu_map(ycc_domains[1], iova, paddr, size, IOMMU_READ|IOMMU_WRITE); + if (alicc_domains[1] && alicc_domains[1] != alicc_domains[0]) { + ret = iommu_map(alicc_domains[1], iova, paddr, size, IOMMU_READ|IOMMU_WRITE); if (ret) { - if (ycc_domains[0]) - iommu_unmap(ycc_domains[0], iova, size); + if (alicc_domains[0]) + iommu_unmap(alicc_domains[0], iova, size); goto out; } } - if ((u64)iova & YCC_2M_MASK) + if ((u64)iova & ALICC_2M_MASK) pr_debug("udma: iova=0x%llx, is not 2M aligned? %llx\n", - (u64)iova, (u64)iova & YCC_2M_MASK); + (u64)iova, (u64)iova & ALICC_2M_MASK); out: return ret; } -static void ycc_mem_unmap(void *vaddr, size_t size) +static void alicc_mem_unmap(void *vaddr, size_t size) { dma_addr_t iova; - if (!ycc_need_map) + if (!alicc_need_map) return; /* As we are direct mapping */ iova = (dma_addr_t)virt_to_phys(vaddr); - if (ycc_domains[0]) - iommu_unmap(ycc_domains[0], iova, size); - if (ycc_domains[1] && ycc_domains[1] != ycc_domains[0]) - iommu_unmap(ycc_domains[1], iova, size); + if (alicc_domains[0]) + iommu_unmap(alicc_domains[0], iova, size); + if (alicc_domains[1] && alicc_domains[1] != alicc_domains[0]) + iommu_unmap(alicc_domains[1], iova, size); } -static inline int ycc_get_hash_key(dma_addr_t phys_addr) +static inline int alicc_get_hash_key(dma_addr_t phys_addr) { return (phys_addr >> 20) & ~PAGE_MASK; } -static inline void ycc_udma_add_hash(struct ycc_udma_info_list *info_list, - struct ycc_udma_kern_info *kern_info) +static inline void alicc_udma_add_hash(struct alicc_udma_info_list *info_list, + struct alicc_udma_kern_info *kern_info) { - int key = ycc_get_hash_key(kern_info->dma_addr); + int key = alicc_get_hash_key(kern_info->dma_addr); hash_add_rcu(info_list->udma_slot, &kern_info->udma_hlist, key); } -static inline void ycc_udma_del_hash(struct ycc_udma_kern_info *kern_info) +static inline void alicc_udma_del_hash(struct alicc_udma_kern_info *kern_info) { hash_del_rcu(&kern_info->udma_hlist); } -static inline struct ycc_udma_kern_info *ycc_udma_find_kern(struct ycc_udma_info_list *info_list, - dma_addr_t dma_addr) +static inline +struct alicc_udma_kern_info *alicc_udma_find_kern(struct alicc_udma_info_list *info_list, + dma_addr_t dma_addr) { - int key = ycc_get_hash_key(dma_addr); - struct ycc_udma_kern_info *kern_info = NULL; + int key = alicc_get_hash_key(dma_addr); + struct alicc_udma_kern_info *kern_info = NULL; rcu_read_lock(); hash_for_each_possible_rcu(info_list->udma_slot, kern_info, udma_hlist, key) { @@ -355,27 +356,27 @@ static inline struct ycc_udma_kern_info *ycc_udma_find_kern(struct ycc_udma_info return kern_info; } -#define YCC_MEGA_SHIFT 20 -#define YCC_UDMA_SIZE (2 << YCC_MEGA_SHIFT) -#define YCC_UDMA_SIZE_MASK (~(YCC_UDMA_SIZE - 1)) -#define YCC_UDMA_ALIGN(size) ((size + YCC_UDMA_SIZE - 1) & (YCC_UDMA_SIZE_MASK)) +#define ALICC_MEGA_SHIFT 20 +#define ALICC_UDMA_SIZE (2 << ALICC_MEGA_SHIFT) +#define ALICC_UDMA_SIZE_MASK (~(ALICC_UDMA_SIZE - 1)) +#define ALICC_UDMA_ALIGN(size) ((size + ALICC_UDMA_SIZE - 1) & (ALICC_UDMA_SIZE_MASK)) -static struct ycc_udma_info *ycc_udma_mem_alloc(struct ycc_udma_info_list *info_list, +static struct alicc_udma_info *alicc_udma_mem_alloc(struct alicc_udma_info_list *info_list, size_t size, int node) { - struct ycc_udma_info *mem_info; - struct ycc_udma_kern_info *kern_info; + struct alicc_udma_info *mem_info; + struct alicc_udma_kern_info *kern_info; if (node != NUMA_NO_NODE && (node < 0 || node > MAX_NUMNODES)) node = 0; - kern_info = kzalloc(sizeof(struct ycc_udma_kern_info), GFP_KERNEL); + kern_info = kzalloc(sizeof(struct alicc_udma_kern_info), GFP_KERNEL); if (!kern_info) return NULL; /* Always allocate 2M */ - size = YCC_UDMA_ALIGN(size); + size = ALICC_UDMA_ALIGN(size); mem_info = kzalloc_node(size, GFP_KERNEL, cpu_to_node(smp_processor_id())); if (!mem_info) { @@ -383,11 +384,11 @@ static struct ycc_udma_info *ycc_udma_mem_alloc(struct ycc_udma_info_list *info_ return NULL; } - if (((u64)mem_info & YCC_2M_MASK)) - pr_debug("ycc mem info: va:0x%llx mask:0x%llx result:%llu\n", - (u64)mem_info, YCC_2M_MASK, ((u64)mem_info & YCC_2M_MASK)); + if (((u64)mem_info & ALICC_2M_MASK)) + pr_debug("alicc mem info: va:0x%llx mask:0x%llx result:%llu\n", + (u64)mem_info, ALICC_2M_MASK, ((u64)mem_info & ALICC_2M_MASK)); - if (ycc_mem_map(mem_info, size)) { + if (alicc_mem_map(mem_info, size)) { kfree(mem_info); kfree(kern_info); return NULL; @@ -402,13 +403,13 @@ static struct ycc_udma_info *ycc_udma_mem_alloc(struct ycc_udma_info_list *info_ kern_info->dma_addr = mem_info->dma_addr; kern_info->size = mem_info->size; - ycc_udma_add_hash(info_list, kern_info); + alicc_udma_add_hash(info_list, kern_info); pr_debug("udma Allocated:%llx, %llx\n", (u64)kern_info->virt_addr, kern_info->dma_addr); return mem_info; } -static void ycc_udma_mem_large_alloc(struct ycc_udma_large_info *large_info) +static void alicc_udma_mem_large_alloc(struct alicc_udma_large_info *large_info) { void *mem = NULL; @@ -419,7 +420,7 @@ static void ycc_udma_mem_large_alloc(struct ycc_udma_large_info *large_info) if (!mem) return; - if (ycc_mem_map(mem, LARGE_ALLOC_SIZE)) { + if (alicc_mem_map(mem, LARGE_ALLOC_SIZE)) { kfree(mem); return; } @@ -428,34 +429,34 @@ static void ycc_udma_mem_large_alloc(struct ycc_udma_large_info *large_info) large_info->dma_addr = virt_to_phys(mem); } -static void ycc_udma_mem_free(struct ycc_udma_info_list *info_list, dma_addr_t dma_addr) +static void alicc_udma_mem_free(struct alicc_udma_info_list *info_list, dma_addr_t dma_addr) { - struct ycc_udma_kern_info *kern_info; + struct alicc_udma_kern_info *kern_info; - kern_info = ycc_udma_find_kern(info_list, dma_addr); + kern_info = alicc_udma_find_kern(info_list, dma_addr); if (!kern_info) return; - ycc_udma_del_hash(kern_info); - ycc_mem_unmap(kern_info->virt_addr, kern_info->size); + alicc_udma_del_hash(kern_info); + alicc_mem_unmap(kern_info->virt_addr, kern_info->size); kfree(kern_info->virt_addr); kfree(kern_info); } -static void ycc_udma_mem_large_free(struct ycc_udma_large_info *large_info) +static void alicc_udma_mem_large_free(struct alicc_udma_large_info *large_info) { if (!large_info) return; - ycc_mem_unmap(large_info->virt_addr, LARGE_ALLOC_SIZE); + alicc_mem_unmap(large_info->virt_addr, LARGE_ALLOC_SIZE); kfree(large_info->virt_addr); - memset(large_info, 0, sizeof(struct ycc_udma_large_info)); + memset(large_info, 0, sizeof(struct alicc_udma_large_info)); } -static int ycc_udma_open(struct inode *inode, struct file *filp) +static int alicc_udma_open(struct inode *inode, struct file *filp) { - struct ycc_udma_info_list *info_list; + struct alicc_udma_info_list *info_list; - info_list = kzalloc(sizeof(struct ycc_udma_info_list), GFP_KERNEL); + info_list = kzalloc(sizeof(struct alicc_udma_info_list), GFP_KERNEL); if (!info_list) return -ENOMEM; @@ -466,97 +467,97 @@ static int ycc_udma_open(struct inode *inode, struct file *filp) return 0; } -static int ycc_udma_release(struct inode *inode, struct file *filep) +static int alicc_udma_release(struct inode *inode, struct file *filep) { - struct ycc_udma_info_list *info_list = (struct ycc_udma_info_list *)filep->private_data; - struct ycc_udma_kern_info *kern_info; + struct alicc_udma_info_list *info_list = (struct alicc_udma_info_list *)filep->private_data; + struct alicc_udma_kern_info *kern_info; int bkt; hash_for_each(info_list->udma_slot, bkt, kern_info, udma_hlist) { pr_debug("releasing: %llx, %llx\n", (u64)kern_info->virt_addr, kern_info->dma_addr); - ycc_udma_del_hash(kern_info); - ycc_mem_unmap(kern_info->virt_addr, kern_info->size); + alicc_udma_del_hash(kern_info); + alicc_mem_unmap(kern_info->virt_addr, kern_info->size); kfree(kern_info->virt_addr); kfree(kern_info); } if ((info_list->large_mem).virt_addr) - ycc_udma_mem_large_free(&info_list->large_mem); + alicc_udma_mem_large_free(&info_list->large_mem); kfree(info_list); filep->private_data = NULL; return 0; } -static long ycc_udma_ioctl(struct file *filep, uint cmd, ulong args) +static long alicc_udma_ioctl(struct file *filep, uint cmd, ulong args) { - struct ycc_udma_info user_info, *mem_info; - struct ycc_udma_info_list *info_list = (struct ycc_udma_info_list *)filep->private_data; + struct alicc_udma_info user_info, *mem_info; + struct alicc_udma_info_list *info_list = (struct alicc_udma_info_list *)filep->private_data; int ret = 0; - mutex_lock(&ycc_mem_lock); + mutex_lock(&alicc_mem_lock); switch (cmd) { - case YCC_IOC_MEM_ALLOC: - ret = copy_from_user(&user_info, (struct ycc_udma_info *)args, sizeof(user_info)); + case ALICC_IOC_MEM_ALLOC: + ret = copy_from_user(&user_info, (struct alicc_udma_info *)args, sizeof(user_info)); if (ret) { ret = -EIO; goto ioctl_unlock; } - mem_info = ycc_udma_mem_alloc(info_list, user_info.size, user_info.node); + mem_info = alicc_udma_mem_alloc(info_list, user_info.size, user_info.node); if (!mem_info) { ret = -ENOMEM; goto ioctl_unlock; } - ret = copy_to_user((struct ycc_udma_info *)args, mem_info, sizeof(*mem_info)); + ret = copy_to_user((struct alicc_udma_info *)args, mem_info, sizeof(*mem_info)); if (ret) { - ycc_udma_mem_free(info_list, mem_info->dma_addr); + alicc_udma_mem_free(info_list, mem_info->dma_addr); ret = -EIO; goto ioctl_unlock; } break; - case YCC_IOC_MEM_FREE: - ret = copy_from_user(&user_info, (struct ycc_udma_info *)args, sizeof(user_info)); + case ALICC_IOC_MEM_FREE: + ret = copy_from_user(&user_info, (struct alicc_udma_info *)args, sizeof(user_info)); if (ret) { ret = -EIO; goto ioctl_unlock; } - ycc_udma_mem_free(info_list, user_info.dma_addr); + alicc_udma_mem_free(info_list, user_info.dma_addr); break; - case YCC_IOC_LARGE_MEM_ALLOC: + case ALICC_IOC_LARGE_MEM_ALLOC: if ((info_list->large_mem).virt_addr) goto ioctl_unlock; - ycc_udma_mem_large_alloc(&(info_list->large_mem)); + alicc_udma_mem_large_alloc(&(info_list->large_mem)); if (!(info_list->large_mem).virt_addr) { ret = -ENOMEM; goto ioctl_unlock; } - ret = copy_to_user((struct ycc_udma_large_info *)args, &(info_list->large_mem), - sizeof(struct ycc_udma_large_info)); + ret = copy_to_user((struct alicc_udma_large_info *)args, &(info_list->large_mem), + sizeof(struct alicc_udma_large_info)); if (ret) { - ycc_udma_mem_large_free(&(info_list->large_mem)); + alicc_udma_mem_large_free(&(info_list->large_mem)); ret = -EIO; goto ioctl_unlock; } break; - case YCC_IOC_LARGE_MEM_FREE: - ycc_udma_mem_large_free(&(info_list->large_mem)); + case ALICC_IOC_LARGE_MEM_FREE: + alicc_udma_mem_large_free(&(info_list->large_mem)); break; default: ret = -EINVAL; } ioctl_unlock: - mutex_unlock(&ycc_mem_lock); + mutex_unlock(&alicc_mem_lock); return ret; } -static int ycc_udma_mmap(struct file *filep, struct vm_area_struct *vma) +static int alicc_udma_mmap(struct file *filep, struct vm_area_struct *vma) { - struct ycc_udma_info_list *info_list = (struct ycc_udma_info_list *)filep->private_data; + struct alicc_udma_info_list *info_list = (struct alicc_udma_info_list *)filep->private_data; unsigned long vma_size = vma->vm_end - vma->vm_start; u64 dma_addr = vma->vm_pgoff << PAGE_SHIFT; - struct ycc_udma_kern_info *kern_info; + struct alicc_udma_kern_info *kern_info; int ret; pr_debug("udma: get kern info for phys addr:%llx\n", (u64)dma_addr); @@ -564,7 +565,7 @@ static int ycc_udma_mmap(struct file *filep, struct vm_area_struct *vma) if (dma_addr == (info_list->large_mem).dma_addr) goto skip_hash; - kern_info = ycc_udma_find_kern(info_list, dma_addr); + kern_info = alicc_udma_find_kern(info_list, dma_addr); if (!kern_info) return -ENOMEM; @@ -581,41 +582,41 @@ static int ycc_udma_mmap(struct file *filep, struct vm_area_struct *vma) return ret; } -const struct file_operations ycc_udma_fops = { - .open = ycc_udma_open, - .mmap = ycc_udma_mmap, - .release = ycc_udma_release, - .unlocked_ioctl = ycc_udma_ioctl, - .compat_ioctl = ycc_udma_ioctl, +const struct file_operations alicc_udma_fops = { + .open = alicc_udma_open, + .mmap = alicc_udma_mmap, + .release = alicc_udma_release, + .unlocked_ioctl = alicc_udma_ioctl, + .compat_ioctl = alicc_udma_ioctl, }; -struct miscdevice ycc_udma_misc = { +struct miscdevice alicc_udma_misc = { .minor = 0, - .name = "ycc_udma", - .fops = &ycc_udma_fops, + .name = "alicc_udma", + .fops = &alicc_udma_fops, }; -int ycc_udma_init(void) +int alicc_udma_init(void) { int ret; - ret = ycc_alloc_iommu_domain(); + ret = alicc_alloc_iommu_domain(); if (ret) return ret; - mutex_init(&ycc_mem_lock); + mutex_init(&alicc_mem_lock); - ret = misc_register(&ycc_udma_misc); + ret = misc_register(&alicc_udma_misc); if (ret) { pr_err("Failed to register misc devices\n"); - ycc_free_iommu_domain(); + alicc_free_iommu_domain(); } return ret; } -void ycc_udma_exit(void) +void alicc_udma_exit(void) { - ycc_free_iommu_domain(); - misc_deregister(&ycc_udma_misc); + alicc_free_iommu_domain(); + misc_deregister(&alicc_udma_misc); } diff --git a/drivers/crypto/ycc/ycc_uio.h b/drivers/crypto/alibaba/alicc/alicc_uio.h similarity index 45% rename from drivers/crypto/ycc/ycc_uio.h rename to drivers/crypto/alibaba/alicc/alicc_uio.h index d8743c7d200d..bb60de9f3347 100644 --- a/drivers/crypto/ycc/ycc_uio.h +++ b/drivers/crypto/alibaba/alicc/alicc_uio.h @@ -1,6 +1,6 @@ // SPDX-License-Identifier: GPL-2.0 -#ifndef __YCC_UIO_H -#define __YCC_UIO_H +#ifndef __ALICC_UIO_H +#define __ALICC_UIO_H /* udma minimum allocated granularity is 1024B */ #define UNIT_SIZE (1024) @@ -24,27 +24,27 @@ #define HASH_BUCKETS (1 << HASH_BUCKETS_SHIFT) #define HASH_BUCKETS_MASK (HASH_BUCKETS - 1) -#define YCC_CMD_MAGIC 'm' -#define YCC_CMD_MEM_ALLOC (0) -#define YCC_CMD_MEM_FREE (1) -#define YCC_CMD_LARGE_MEM_ALLOC (2) -#define YCC_CMD_LARGE_MEM_FREE (3) +#define ALICC_CMD_MAGIC 'm' +#define ALICC_CMD_MEM_ALLOC (0) +#define ALICC_CMD_MEM_FREE (1) +#define ALICC_CMD_LARGE_MEM_ALLOC (2) +#define ALICC_CMD_LARGE_MEM_FREE (3) -#define YCC_IOC_MEM_ALLOC \ - _IOWR(YCC_CMD_MAGIC, YCC_CMD_MEM_ALLOC, struct ycc_udma_info) -#define YCC_IOC_MEM_FREE \ - _IOWR(YCC_CMD_MAGIC, YCC_CMD_MEM_FREE, struct ycc_udma_info) -#define YCC_IOC_LARGE_MEM_ALLOC \ - _IOWR(YCC_CMD_MAGIC, YCC_CMD_LARGE_MEM_ALLOC, struct ycc_udma_large_info) -#define YCC_IOC_LARGE_MEM_FREE \ - _IOWR(YCC_CMD_MAGIC, YCC_CMD_LARGE_MEM_FREE, struct ycc_udma_large_info) +#define ALICC_IOC_MEM_ALLOC \ + _IOWR(ALICC_CMD_MAGIC, ALICC_CMD_MEM_ALLOC, struct alicc_udma_info) +#define ALICC_IOC_MEM_FREE \ + _IOWR(ALICC_CMD_MAGIC, ALICC_CMD_MEM_FREE, struct alicc_udma_info) +#define ALICC_IOC_LARGE_MEM_ALLOC \ + _IOWR(ALICC_CMD_MAGIC, ALICC_CMD_LARGE_MEM_ALLOC, struct alicc_udma_large_info) +#define ALICC_IOC_LARGE_MEM_FREE \ + _IOWR(ALICC_CMD_MAGIC, ALICC_CMD_LARGE_MEM_FREE, struct alicc_udma_large_info) -struct ycc_udma_large_info { +struct alicc_udma_large_info { dma_addr_t dma_addr; void *virt_addr; }; -struct ycc_udma_info { +struct alicc_udma_info { int node; size_t size; int type; @@ -55,15 +55,15 @@ struct ycc_udma_info { }; #ifndef CONFIG_UIO -static inline int ycc_uio_register(struct ycc_ring *ring) { return 0; }; -static inline void ycc_uio_unregister(struct ycc_ring *ring) { }; +static inline int alicc_uio_register(struct alicc_ring *ring) { return 0; }; +static inline void alicc_uio_unregister(struct alicc_ring *ring) { }; #else -int ycc_uio_register(struct ycc_ring *ring); -void ycc_uio_unregister(struct ycc_ring *ring); +int alicc_uio_register(struct alicc_ring *ring); +void alicc_uio_unregister(struct alicc_ring *ring); #endif -int ycc_udma_init(void); -void ycc_udma_exit(void); -int ycc_bind_iommu_domain(struct pci_dev *pdev, int id); -void ycc_unbind_iommu_domain(struct pci_dev *pdev, int id); +int alicc_udma_init(void); +void alicc_udma_exit(void); +int alicc_bind_iommu_domain(struct pci_dev *pdev, int id); +void alicc_unbind_iommu_domain(struct pci_dev *pdev, int id); #endif diff --git a/drivers/crypto/ycc/sm2signature_asn1.c b/drivers/crypto/alibaba/alicc/sm2signature_asn1.c similarity index 100% rename from drivers/crypto/ycc/sm2signature_asn1.c rename to drivers/crypto/alibaba/alicc/sm2signature_asn1.c diff --git a/drivers/crypto/ycc/sm2signature_asn1.h b/drivers/crypto/alibaba/alicc/sm2signature_asn1.h similarity index 100% rename from drivers/crypto/ycc/sm2signature_asn1.h rename to drivers/crypto/alibaba/alicc/sm2signature_asn1.h diff --git a/drivers/crypto/ycc/ycc_isr.h b/drivers/crypto/ycc/ycc_isr.h deleted file mode 100644 index 8318a6f8f829..000000000000 --- a/drivers/crypto/ycc/ycc_isr.h +++ /dev/null @@ -1,12 +0,0 @@ -/* SPDX-License-Identifier: GPL-2.0 */ -#ifndef __YCC_ISR_H - -#include "ycc_dev.h" - -int ycc_enable_msix(struct ycc_dev *ydev); -void ycc_disable_msix(struct ycc_dev *ydev); -int ycc_alloc_irqs(struct ycc_dev *ydev); -void ycc_free_irqs(struct ycc_dev *ydev); -int ycc_init_global_err(struct ycc_dev *ydev); -void ycc_deinit_global_err(struct ycc_dev *ydev); -#endif -- Gitee