Orange Pi5 kernel

// SPDX-License-Identifier: GPL-2.0
/*
 * Crypto acceleration support for Rockchip Crypto V3
 *
 * Copyright (c) 2022, Rockchip Electronics Co., Ltd
 *
 * Author: Lin Jinhan <troy.lin@rock-chips.com>
 *
 */
 
#include "rk_crypto_core.h"
#include "rk_crypto_v3.h"
#include "rk_crypto_v3_reg.h"
#include "rk_crypto_utils.h"
 
static const u32 cipher_mode2bit_mask[] = {
<------>[CIPHER_MODE_ECB]      = CRYPTO_ECB_FLAG,
<------>[CIPHER_MODE_CBC]      = CRYPTO_CBC_FLAG,
<------>[CIPHER_MODE_CFB]      = CRYPTO_CFB_FLAG,
<------>[CIPHER_MODE_OFB]      = CRYPTO_OFB_FLAG,
<------>[CIPHER_MODE_CTR]      = CRYPTO_CTR_FLAG,
<------>[CIPHER_MODE_XTS]      = CRYPTO_XTS_FLAG,
<------>[CIPHER_MODE_CTS]      = CRYPTO_CTS_FLAG,
<------>[CIPHER_MODE_CCM]      = CRYPTO_CCM_FLAG,
<------>[CIPHER_MODE_GCM]      = CRYPTO_GCM_FLAG,
<------>[CIPHER_MODE_CMAC]     = CRYPTO_CMAC_FLAG,
<------>[CIPHER_MODE_CBCMAC]   = CRYPTO_CBCMAC_FLAG,
};
 
static const u32 hash_algo2bit_mask[] = {
<------>[HASH_ALGO_SHA1]       = CRYPTO_HASH_SHA1_FLAG,
<------>[HASH_ALGO_SHA224]     = CRYPTO_HASH_SHA224_FLAG,
<------>[HASH_ALGO_SHA256]     = CRYPTO_HASH_SHA256_FLAG,
<------>[HASH_ALGO_SHA384]     = CRYPTO_HASH_SHA384_FLAG,
<------>[HASH_ALGO_SHA512]     = CRYPTO_HASH_SHA512_FLAG,
<------>[HASH_ALGO_SHA512_224] = CRYPTO_HASH_SHA512_224_FLAG,
<------>[HASH_ALGO_SHA512_256] = CRYPTO_HASH_SHA512_256_FLAG,
<------>[HASH_ALGO_MD5]        = CRYPTO_HASH_MD5_FLAG,
<------>[HASH_ALGO_SM3]        = CRYPTO_HASH_SM3_FLAG,
};
 
static const u32 hmac_algo2bit_mask[] = {
<------>[HASH_ALGO_SHA1]       = CRYPTO_HMAC_SHA1_FLAG,
<------>[HASH_ALGO_SHA256]     = CRYPTO_HMAC_SHA256_FLAG,
<------>[HASH_ALGO_SHA512]     = CRYPTO_HMAC_SHA512_FLAG,
<------>[HASH_ALGO_MD5]        = CRYPTO_HMAC_MD5_FLAG,
<------>[HASH_ALGO_SM3]        = CRYPTO_HMAC_SM3_FLAG,
};
 
static const char * const crypto_v3_rsts[] = {
<------> "crypto-rst",
};
 
static struct rk_crypto_algt *crypto_v3_algs[] = {
<------>&rk_v3_ecb_sm4_alg,		/* ecb(sm4) */
<------>&rk_v3_cbc_sm4_alg,		/* cbc(sm4) */
<------>&rk_v3_xts_sm4_alg,		/* xts(sm4) */
<------>&rk_v3_cfb_sm4_alg,		/* cfb(sm4) */
<------>&rk_v3_ofb_sm4_alg,		/* ofb(sm4) */
<------>&rk_v3_ctr_sm4_alg,		/* ctr(sm4) */
<------>&rk_v3_gcm_sm4_alg,		/* ctr(sm4) */
 
<------>&rk_v3_ecb_aes_alg,		/* ecb(aes) */
<------>&rk_v3_cbc_aes_alg,		/* cbc(aes) */
<------>&rk_v3_xts_aes_alg,		/* xts(aes) */
<------>&rk_v3_cfb_aes_alg,		/* cfb(aes) */
<------>&rk_v3_ofb_aes_alg,		/* ofb(aes) */
<------>&rk_v3_ctr_aes_alg,		/* ctr(aes) */
<------>&rk_v3_gcm_aes_alg,		/* gcm(aes) */
 
<------>&rk_v3_ecb_des_alg,		/* ecb(des) */
<------>&rk_v3_cbc_des_alg,		/* cbc(des) */
<------>&rk_v3_cfb_des_alg,		/* cfb(des) */
<------>&rk_v3_ofb_des_alg,		/* ofb(des) */
 
<------>&rk_v3_ecb_des3_ede_alg,	/* ecb(des3_ede) */
<------>&rk_v3_cbc_des3_ede_alg,	/* cbc(des3_ede) */
<------>&rk_v3_cfb_des3_ede_alg,	/* cfb(des3_ede) */
<------>&rk_v3_ofb_des3_ede_alg,	/* ofb(des3_ede) */
 
<------>&rk_v3_ahash_sha1,		/* sha1 */
<------>&rk_v3_ahash_sha224,		/* sha224 */
<------>&rk_v3_ahash_sha256,		/* sha256 */
<------>&rk_v3_ahash_sha384,		/* sha384 */
<------>&rk_v3_ahash_sha512,		/* sha512 */
<------>&rk_v3_ahash_md5,		/* md5 */
<------>&rk_v3_ahash_sm3,		/* sm3 */
 
<------>&rk_v3_hmac_sha1,		/* hmac(sha1) */
<------>&rk_v3_hmac_sha256,		/* hmac(sha256) */
<------>&rk_v3_hmac_sha512,		/* hmac(sha512) */
<------>&rk_v3_hmac_md5,		/* hmac(md5) */
<------>&rk_v3_hmac_sm3,		/* hmac(sm3) */
 
<------>/* Shared v2 version implementation */
<------>&rk_v2_asym_rsa,		/* rsa */
};
 
static bool rk_is_cipher_support(struct rk_crypto_dev *rk_dev, u32 algo, u32 mode, u32 key_len)
{
<------>u32 version = 0;
<------>u32 mask = 0;
<------>bool key_len_valid = true;
 
<------>switch (algo) {
<------>case CIPHER_ALGO_DES:
<------>case CIPHER_ALGO_DES3_EDE:
<------><------>version = CRYPTO_READ(rk_dev, CRYPTO_DES_VERSION);
 
<------><------>if (key_len == 8)
<------><------><------>key_len_valid = true;
<------><------>else if (key_len == 16 || key_len == 24)
<------><------><------>key_len_valid = version & CRYPTO_TDES_FLAG;
<------><------>else
<------><------><------>key_len_valid = false;
<------><------>break;
<------>case CIPHER_ALGO_AES:
<------><------>version = CRYPTO_READ(rk_dev, CRYPTO_AES_VERSION);
 
<------><------>if (key_len == 16)
<------><------><------>key_len_valid = version & CRYPTO_AES128_FLAG;
<------><------>else if (key_len == 24)
<------><------><------>key_len_valid = version & CRYPTO_AES192_FLAG;
<------><------>else if (key_len == 32)
<------><------><------>key_len_valid = version & CRYPTO_AES256_FLAG;
<------><------>else
<------><------><------>key_len_valid = false;
<------><------>break;
<------>case CIPHER_ALGO_SM4:
<------><------>version = CRYPTO_READ(rk_dev, CRYPTO_SM4_VERSION);
 
<------><------>key_len_valid = (key_len == SM4_KEY_SIZE) ? true : false;
<------><------>break;
<------>default:
<------><------>return false;
<------>}
 
<------>mask = cipher_mode2bit_mask[mode];
 
<------>if (key_len == 0)
<------><------>key_len_valid = true;
 
<------>return (version & mask) && key_len_valid;
}
 
static bool rk_is_hash_support(struct rk_crypto_dev *rk_dev, u32 algo, u32 type)
{
<------>u32 version = 0;
<------>u32 mask = 0;
 
<------>if (type == ALG_TYPE_HMAC) {
<------><------>version = CRYPTO_READ(rk_dev, CRYPTO_HMAC_VERSION);
<------><------>mask    = hmac_algo2bit_mask[algo];
<------>} else if (type == ALG_TYPE_HASH) {
<------><------>version = CRYPTO_READ(rk_dev, CRYPTO_HASH_VERSION);
<------><------>mask    = hash_algo2bit_mask[algo];
<------>} else {
<------><------>return false;
<------>}
 
<------>return version & mask;
}
 
int rk_hw_crypto_v3_init(struct device *dev, void *hw_info)
{
<------>struct rk_hw_crypto_v3_info *info =
<------><------>(struct rk_hw_crypto_v3_info *)hw_info;
 
<------>if (!dev || !hw_info)
<------><------>return -EINVAL;
 
<------>memset(info, 0x00, sizeof(*info));
 
<------>return rk_crypto_hw_desc_alloc(dev, &info->hw_desc);
}
 
void rk_hw_crypto_v3_deinit(struct device *dev, void *hw_info)
{
<------>struct rk_hw_crypto_v3_info *info =
<------><------>(struct rk_hw_crypto_v3_info *)hw_info;
 
<------>if (!dev || !hw_info)
<------><------>return;
 
<------>rk_crypto_hw_desc_free(&info->hw_desc);
}
 
const char * const *rk_hw_crypto_v3_get_rsts(uint32_t *num)
{
<------>*num = ARRAY_SIZE(crypto_v3_rsts);
 
<------>return crypto_v3_rsts;
}
 
struct rk_crypto_algt **rk_hw_crypto_v3_get_algts(uint32_t *num)
{
<------>*num = ARRAY_SIZE(crypto_v3_algs);
 
<------>return crypto_v3_algs;
}
 
bool rk_hw_crypto_v3_algo_valid(struct rk_crypto_dev *rk_dev, struct rk_crypto_algt *aglt)
{
<------>if (aglt->type == ALG_TYPE_CIPHER || aglt->type == ALG_TYPE_AEAD) {
<------><------>CRYPTO_TRACE("CIPHER");
<------><------>return rk_is_cipher_support(rk_dev, aglt->algo, aglt->mode, 0);
<------>} else if (aglt->type == ALG_TYPE_HASH || aglt->type == ALG_TYPE_HMAC) {
<------><------>CRYPTO_TRACE("HASH/HMAC");
<------><------>return rk_is_hash_support(rk_dev, aglt->algo, aglt->type);
<------>} else if (aglt->type == ALG_TYPE_ASYM) {
<------><------>CRYPTO_TRACE("RSA");
<------><------>return true;
<------>} else {
<------><------>return false;
<------>}
}