drivers/crypto/allwinner/sun8i-ss/sun8i-ss.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  * sun8i-ss.h - hardware cryptographic offloader for
   4  * Allwinner A80/A83T SoC
   5  *
   6  * Copyright (C) 2016-2019 Corentin LABBE <clabbe.montjoie@gmail.com>
   7  */
   8 #include <crypto/aes.h>
   9 #include <crypto/des.h>
  10 #include <crypto/engine.h>
  11 #include <crypto/rng.h>
  12 #include <crypto/skcipher.h>
  13 #include <linux/atomic.h>
  14 #include <linux/debugfs.h>
  15 #include <linux/crypto.h>
  16 #include <crypto/internal/hash.h>
  17 #include <crypto/md5.h>
  18 #include <crypto/sha.h>
  19
  20 #define SS_START        1
  21
  22 #define SS_ENCRYPTION           0
  23 #define SS_DECRYPTION           BIT(6)
  24
  25 #define SS_ALG_AES              0
  26 #define SS_ALG_DES              (1 << 2)
  27 #define SS_ALG_3DES             (2 << 2)
  28 #define SS_ALG_MD5              (3 << 2)
  29 #define SS_ALG_PRNG             (4 << 2)
  30 #define SS_ALG_SHA1             (6 << 2)
  31 #define SS_ALG_SHA224           (7 << 2)
  32 #define SS_ALG_SHA256           (8 << 2)
  33
  34 #define SS_CTL_REG              0x00
  35 #define SS_INT_CTL_REG          0x04
  36 #define SS_INT_STA_REG          0x08
  37 #define SS_KEY_ADR_REG          0x10
  38 #define SS_IV_ADR_REG           0x18
  39 #define SS_SRC_ADR_REG          0x20
  40 #define SS_DST_ADR_REG          0x28
  41 #define SS_LEN_ADR_REG          0x30
  42
  43 #define SS_ID_NOTSUPP           0xFF
  44
  45 #define SS_ID_CIPHER_AES        0
  46 #define SS_ID_CIPHER_DES        1
  47 #define SS_ID_CIPHER_DES3       2
  48 #define SS_ID_CIPHER_MAX        3
  49
  50 #define SS_ID_OP_ECB    0
  51 #define SS_ID_OP_CBC    1
  52 #define SS_ID_OP_MAX    2
  53
  54 #define SS_AES_128BITS 0
  55 #define SS_AES_192BITS 1
  56 #define SS_AES_256BITS 2
  57
  58 #define SS_OP_ECB       0
  59 #define SS_OP_CBC       (1 << 13)
  60
  61 #define SS_ID_HASH_MD5  0
  62 #define SS_ID_HASH_SHA1 1
  63 #define SS_ID_HASH_SHA224       2
  64 #define SS_ID_HASH_SHA256       3
  65 #define SS_ID_HASH_MAX  4
  66
  67 #define SS_FLOW0        BIT(30)
  68 #define SS_FLOW1        BIT(31)
  69
  70 #define SS_PRNG_CONTINUE        BIT(18)
  71
  72 #define MAX_SG 8
  73
  74 #define MAXFLOW 2
  75
  76 #define SS_MAX_CLOCKS 2
  77
  78 #define SS_DIE_ID_SHIFT 20
  79 #define SS_DIE_ID_MASK  0x07
  80
  81 #define PRNG_DATA_SIZE (160 / 8)
  82 #define PRNG_SEED_SIZE DIV_ROUND_UP(175, 8)
  83
  84 /*
  85  * struct ss_clock - Describe clocks used by sun8i-ss
  86  * @name:       Name of clock needed by this variant
  87  * @freq:       Frequency to set for each clock
  88  * @max_freq:   Maximum frequency for each clock
  89  */
  90 struct ss_clock {
  91         const char *name;
  92         unsigned long freq;
  93         unsigned long max_freq;
  94 };
  95
  96 /*
  97  * struct ss_variant - Describe SS capability for each variant hardware
  98  * @alg_cipher: list of supported ciphers. for each SS_ID_ this will give the
  99  *              coresponding SS_ALG_XXX value
 100  * @alg_hash:   list of supported hashes. for each SS_ID_ this will give the
 101  *              corresponding SS_ALG_XXX value
 102  * @op_mode:    list of supported block modes
 103  * @ss_clks!    list of clock needed by this variant
 104  */
 105 struct ss_variant {
 106         char alg_cipher[SS_ID_CIPHER_MAX];
 107         char alg_hash[SS_ID_HASH_MAX];
 108         u32 op_mode[SS_ID_OP_MAX];
 109         struct ss_clock ss_clks[SS_MAX_CLOCKS];
 110 };
 111
 112 struct sginfo {
 113         u32 addr;
 114         u32 len;
 115 };
 116
 117 /*
 118  * struct sun8i_ss_flow - Information used by each flow
 119  * @engine:     ptr to the crypto_engine for this flow
 120  * @complete:   completion for the current task on this flow
 121  * @status:     set to 1 by interrupt if task is done
 122  * @stat_req:   number of request done by this flow
 123  */
 124 struct sun8i_ss_flow {
 125         struct crypto_engine *engine;
 126         struct completion complete;
 127         int status;
 128 #ifdef CONFIG_CRYPTO_DEV_SUN8I_SS_DEBUG
 129         unsigned long stat_req;
 130 #endif
 131 };
 132
 133 /*
 134  * struct sun8i_ss_dev - main container for all this driver information
 135  * @base:       base address of SS
 136  * @ssclks:     clocks used by SS
 137  * @reset:      pointer to reset controller
 138  * @dev:        the platform device
 139  * @mlock:      Control access to device registers
 140  * @flows:      array of all flow
 141  * @flow:       flow to use in next request
 142  * @variant:    pointer to variant specific data
 143  * @dbgfs_dir:  Debugfs dentry for statistic directory
 144  * @dbgfs_stats: Debugfs dentry for statistic counters
 145  */
 146 struct sun8i_ss_dev {
 147         void __iomem *base;
 148         struct clk *ssclks[SS_MAX_CLOCKS];
 149         struct reset_control *reset;
 150         struct device *dev;
 151         struct mutex mlock;
 152         struct sun8i_ss_flow *flows;
 153         atomic_t flow;
 154         const struct ss_variant *variant;
 155 #ifdef CONFIG_CRYPTO_DEV_SUN8I_SS_DEBUG
 156         struct dentry *dbgfs_dir;
 157         struct dentry *dbgfs_stats;
 158 #endif
 159 };
 160
 161 /*
 162  * struct sun8i_cipher_req_ctx - context for a skcipher request
 163  * @t_src:              list of mapped SGs with their size
 164  * @t_dst:              list of mapped SGs with their size
 165  * @p_key:              DMA address of the key
 166  * @p_iv:               DMA address of the IV
 167  * @method:             current algorithm for this request
 168  * @op_mode:            op_mode for this request
 169  * @op_dir:             direction (encrypt vs decrypt) for this request
 170  * @flow:               the flow to use for this request
 171  * @ivlen:              size of biv
 172  * @keylen:             keylen for this request
 173  * @biv:                buffer which contain the IV
 174  * @fallback_req:       request struct for invoking the fallback skcipher TFM
 175  */
 176 struct sun8i_cipher_req_ctx {
 177         struct sginfo t_src[MAX_SG];
 178         struct sginfo t_dst[MAX_SG];
 179         u32 p_key;
 180         u32 p_iv;
 181         u32 method;
 182         u32 op_mode;
 183         u32 op_dir;
 184         int flow;
 185         unsigned int ivlen;
 186         unsigned int keylen;
 187         void *biv;
 188         struct skcipher_request fallback_req;   // keep at the end
 189 };
 190
 191 /*
 192  * struct sun8i_cipher_tfm_ctx - context for a skcipher TFM
 193  * @enginectx:          crypto_engine used by this TFM
 194  * @key:                pointer to key data
 195  * @keylen:             len of the key
 196  * @ss:                 pointer to the private data of driver handling this TFM
 197  * @fallback_tfm:       pointer to the fallback TFM
 198  */
 199 struct sun8i_cipher_tfm_ctx {
 200         struct crypto_engine_ctx enginectx;
 201         u32 *key;
 202         u32 keylen;
 203         struct sun8i_ss_dev *ss;
 204         struct crypto_skcipher *fallback_tfm;
 205 };
 206
 207 /*
 208  * struct sun8i_ss_prng_ctx - context for PRNG TFM
 209  * @seed:       The seed to use
 210  * @slen:       The size of the seed
 211  */
 212 struct sun8i_ss_rng_tfm_ctx {
 213         void *seed;
 214         unsigned int slen;
 215 };
 216
 217 /*
 218  * struct sun8i_ss_hash_tfm_ctx - context for an ahash TFM
 219  * @enginectx:          crypto_engine used by this TFM
 220  * @fallback_tfm:       pointer to the fallback TFM
 221  * @ss:                 pointer to the private data of driver handling this TFM
 222  *
 223  * enginectx must be the first element
 224  */
 225 struct sun8i_ss_hash_tfm_ctx {
 226         struct crypto_engine_ctx enginectx;
 227         struct crypto_ahash *fallback_tfm;
 228         struct sun8i_ss_dev *ss;
 229 };
 230
 231 /*
 232  * struct sun8i_ss_hash_reqctx - context for an ahash request
 233  * @t_src:      list of DMA address and size for source SGs
 234  * @t_dst:      list of DMA address and size for destination SGs
 235  * @fallback_req:       pre-allocated fallback request
 236  * @method:     the register value for the algorithm used by this request
 237  * @flow:       the flow to use for this request
 238  */
 239 struct sun8i_ss_hash_reqctx {
 240         struct sginfo t_src[MAX_SG];
 241         struct sginfo t_dst[MAX_SG];
 242         struct ahash_request fallback_req;
 243         u32 method;
 244         int flow;
 245 };
 246
 247 /*
 248  * struct sun8i_ss_alg_template - crypto_alg template
 249  * @type:               the CRYPTO_ALG_TYPE for this template
 250  * @ss_algo_id:         the SS_ID for this template
 251  * @ss_blockmode:       the type of block operation SS_ID
 252  * @ss:                 pointer to the sun8i_ss_dev structure associated with
 253  *                      this template
 254  * @alg:                one of sub struct must be used
 255  * @stat_req:           number of request done on this template
 256  * @stat_fb:            number of request which has fallbacked
 257  * @stat_bytes:         total data size done by this template
 258  */
 259 struct sun8i_ss_alg_template {
 260         u32 type;
 261         u32 ss_algo_id;
 262         u32 ss_blockmode;
 263         struct sun8i_ss_dev *ss;
 264         union {
 265                 struct skcipher_alg skcipher;
 266                 struct rng_alg rng;
 267                 struct ahash_alg hash;
 268         } alg;
 269 #ifdef CONFIG_CRYPTO_DEV_SUN8I_SS_DEBUG
 270         unsigned long stat_req;
 271         unsigned long stat_fb;
 272         unsigned long stat_bytes;
 273 #endif
 274 };
 275
 276 int sun8i_ss_enqueue(struct crypto_async_request *areq, u32 type);
 277
 278 int sun8i_ss_aes_setkey(struct crypto_skcipher *tfm, const u8 *key,
 279                         unsigned int keylen);
 280 int sun8i_ss_des3_setkey(struct crypto_skcipher *tfm, const u8 *key,
 281                          unsigned int keylen);
 282 int sun8i_ss_cipher_init(struct crypto_tfm *tfm);
 283 void sun8i_ss_cipher_exit(struct crypto_tfm *tfm);
 284 int sun8i_ss_skdecrypt(struct skcipher_request *areq);
 285 int sun8i_ss_skencrypt(struct skcipher_request *areq);
 286
 287 int sun8i_ss_get_engine_number(struct sun8i_ss_dev *ss);
 288
 289 int sun8i_ss_run_task(struct sun8i_ss_dev *ss, struct sun8i_cipher_req_ctx *rctx, const char *name);
 290 int sun8i_ss_prng_generate(struct crypto_rng *tfm, const u8 *src,
 291                            unsigned int slen, u8 *dst, unsigned int dlen);
 292 int sun8i_ss_prng_seed(struct crypto_rng *tfm, const u8 *seed, unsigned int slen);
 293 int sun8i_ss_prng_init(struct crypto_tfm *tfm);
 294 void sun8i_ss_prng_exit(struct crypto_tfm *tfm);
 295
 296 int sun8i_ss_hash_crainit(struct crypto_tfm *tfm);
 297 void sun8i_ss_hash_craexit(struct crypto_tfm *tfm);
 298 int sun8i_ss_hash_init(struct ahash_request *areq);
 299 int sun8i_ss_hash_export(struct ahash_request *areq, void *out);
 300 int sun8i_ss_hash_import(struct ahash_request *areq, const void *in);
 301 int sun8i_ss_hash_final(struct ahash_request *areq);
 302 int sun8i_ss_hash_update(struct ahash_request *areq);
 303 int sun8i_ss_hash_finup(struct ahash_request *areq);
 304 int sun8i_ss_hash_digest(struct ahash_request *areq);
 305 int sun8i_ss_hash_run(struct crypto_engine *engine, void *breq);