drivers/crypto/hisilicon/trng/trng.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2019 HiSilicon Limited. */
   3
   4 #include <linux/acpi.h>
   5 #include <linux/crypto.h>
   6 #include <linux/err.h>
   7 #include <linux/hw_random.h>
   8 #include <linux/io.h>
   9 #include <linux/iopoll.h>
  10 #include <linux/kernel.h>
  11 #include <linux/list.h>
  12 #include <linux/module.h>
  13 #include <linux/mutex.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/random.h>
  16 #include <crypto/internal/rng.h>
  17
  18 #define HISI_TRNG_REG           0x00F0
  19 #define HISI_TRNG_BYTES         4
  20 #define HISI_TRNG_QUALITY       512
  21 #define SLEEP_US                10
  22 #define TIMEOUT_US              10000
  23 #define SW_DRBG_NUM_SHIFT       2
  24 #define SW_DRBG_KEY_BASE        0x082C
  25 #define SW_DRBG_SEED(n)         (SW_DRBG_KEY_BASE - ((n) << SW_DRBG_NUM_SHIFT))
  26 #define SW_DRBG_SEED_REGS_NUM   12
  27 #define SW_DRBG_SEED_SIZE       48
  28 #define SW_DRBG_BLOCKS          0x0830
  29 #define SW_DRBG_INIT            0x0834
  30 #define SW_DRBG_GEN             0x083c
  31 #define SW_DRBG_STATUS          0x0840
  32 #define SW_DRBG_BLOCKS_NUM      4095
  33 #define SW_DRBG_DATA_BASE       0x0850
  34 #define SW_DRBG_DATA_NUM        4
  35 #define SW_DRBG_DATA(n)         (SW_DRBG_DATA_BASE - ((n) << SW_DRBG_NUM_SHIFT))
  36 #define SW_DRBG_BYTES           16
  37 #define SW_DRBG_ENABLE_SHIFT    12
  38 #define SEED_SHIFT_24           24
  39 #define SEED_SHIFT_16           16
  40 #define SEED_SHIFT_8            8
  41
  42 struct hisi_trng_list {
  43         struct mutex lock;
  44         struct list_head list;
  45         bool is_init;
  46 };
  47
  48 struct hisi_trng {
  49         void __iomem *base;
  50         struct hisi_trng_list *trng_list;
  51         struct list_head list;
  52         struct hwrng rng;
  53         bool is_used;
  54         struct mutex mutex;
  55 };
  56
  57 struct hisi_trng_ctx {
  58         struct hisi_trng *trng;
  59 };
  60
  61 static atomic_t trng_active_devs;
  62 static struct hisi_trng_list trng_devices;
  63
  64 static void hisi_trng_set_seed(struct hisi_trng *trng, const u8 *seed)
  65 {
  66         u32 val, seed_reg, i;
  67
  68         for (i = 0; i < SW_DRBG_SEED_SIZE;
  69              i += SW_DRBG_SEED_SIZE / SW_DRBG_SEED_REGS_NUM) {
  70                 val = seed[i] << SEED_SHIFT_24;
  71                 val |= seed[i + 1UL] << SEED_SHIFT_16;
  72                 val |= seed[i + 2UL] << SEED_SHIFT_8;
  73                 val |= seed[i + 3UL];
  74
  75                 seed_reg = (i >> SW_DRBG_NUM_SHIFT) % SW_DRBG_SEED_REGS_NUM;
  76                 writel(val, trng->base + SW_DRBG_SEED(seed_reg));
  77         }
  78 }
  79
  80 static int hisi_trng_seed(struct crypto_rng *tfm, const u8 *seed,
  81                           unsigned int slen)
  82 {
  83         struct hisi_trng_ctx *ctx = crypto_rng_ctx(tfm);
  84         struct hisi_trng *trng = ctx->trng;
  85         u32 val = 0;
  86         int ret = 0;
  87
  88         if (slen < SW_DRBG_SEED_SIZE) {
  89                 pr_err("slen(%u) is not matched with trng(%d)\n", slen,
  90                         SW_DRBG_SEED_SIZE);
  91                 return -EINVAL;
  92         }
  93
  94         writel(0x0, trng->base + SW_DRBG_BLOCKS);
  95         hisi_trng_set_seed(trng, seed);
  96
  97         writel(SW_DRBG_BLOCKS_NUM | (0x1 << SW_DRBG_ENABLE_SHIFT),
  98                trng->base + SW_DRBG_BLOCKS);
  99         writel(0x1, trng->base + SW_DRBG_INIT);
 100
 101         ret = readl_relaxed_poll_timeout(trng->base + SW_DRBG_STATUS,
 102                                         val, val & BIT(0), SLEEP_US, TIMEOUT_US);
 103         if (ret)
 104                 pr_err("fail to init trng(%d)\n", ret);
 105
 106         return ret;
 107 }
 108
 109 static int hisi_trng_generate(struct crypto_rng *tfm, const u8 *src,
 110                               unsigned int slen, u8 *dstn, unsigned int dlen)
 111 {
 112         struct hisi_trng_ctx *ctx = crypto_rng_ctx(tfm);
 113         struct hisi_trng *trng = ctx->trng;
 114         u32 data[SW_DRBG_DATA_NUM];
 115         u32 currsize = 0;
 116         u32 val = 0;
 117         int ret;
 118         u32 i;
 119
 120         if (dlen > SW_DRBG_BLOCKS_NUM * SW_DRBG_BYTES || dlen == 0) {
 121                 pr_err("dlen(%d) exceeds limit(%d)!\n", dlen,
 122                         SW_DRBG_BLOCKS_NUM * SW_DRBG_BYTES);
 123                 return -EINVAL;
 124         }
 125
 126         do {
 127                 ret = readl_relaxed_poll_timeout(trng->base + SW_DRBG_STATUS,
 128                      val, val & BIT(1), SLEEP_US, TIMEOUT_US);
 129                 if (ret) {
 130                         pr_err("fail to generate random number(%d)!\n", ret);
 131                         break;
 132                 }
 133
 134                 for (i = 0; i < SW_DRBG_DATA_NUM; i++)
 135                         data[i] = readl(trng->base + SW_DRBG_DATA(i));
 136
 137                 if (dlen - currsize >= SW_DRBG_BYTES) {
 138                         memcpy(dstn + currsize, data, SW_DRBG_BYTES);
 139                         currsize += SW_DRBG_BYTES;
 140                 } else {
 141                         memcpy(dstn + currsize, data, dlen - currsize);
 142                         currsize = dlen;
 143                 }
 144
 145                 writel(0x1, trng->base + SW_DRBG_GEN);
 146         } while (currsize < dlen);
 147
 148         return ret;
 149 }
 150
 151 static int hisi_trng_init(struct crypto_tfm *tfm)
 152 {
 153         struct hisi_trng_ctx *ctx = crypto_tfm_ctx(tfm);
 154         struct hisi_trng *trng;
 155         int ret = -EBUSY;
 156
 157         mutex_lock(&trng_devices.lock);
 158         list_for_each_entry(trng, &trng_devices.list, list) {
 159                 if (!trng->is_used) {
 160                         trng->is_used = true;
 161                         ctx->trng = trng;
 162                         ret = 0;
 163                         break;
 164                 }
 165         }
 166         mutex_unlock(&trng_devices.lock);
 167
 168         return ret;
 169 }
 170
 171 static void hisi_trng_exit(struct crypto_tfm *tfm)
 172 {
 173         struct hisi_trng_ctx *ctx = crypto_tfm_ctx(tfm);
 174
 175         mutex_lock(&trng_devices.lock);
 176         ctx->trng->is_used = false;
 177         mutex_unlock(&trng_devices.lock);
 178 }
 179
 180 static int hisi_trng_read(struct hwrng *rng, void *buf, size_t max, bool wait)
 181 {
 182         struct hisi_trng *trng;
 183         int currsize = 0;
 184         u32 val = 0;
 185         u32 ret;
 186
 187         trng = container_of(rng, struct hisi_trng, rng);
 188
 189         do {
 190                 ret = readl_poll_timeout(trng->base + HISI_TRNG_REG, val,
 191                                          val, SLEEP_US, TIMEOUT_US);
 192                 if (ret)
 193                         return currsize;
 194
 195                 if (max - currsize >= HISI_TRNG_BYTES) {
 196                         memcpy(buf + currsize, &val, HISI_TRNG_BYTES);
 197                         currsize += HISI_TRNG_BYTES;
 198                         if (currsize == max)
 199                                 return currsize;
 200                         continue;
 201                 }
 202
 203                 /* copy remaining bytes */
 204                 memcpy(buf + currsize, &val, max - currsize);
 205                 currsize = max;
 206         } while (currsize < max);
 207
 208         return currsize;
 209 }
 210
 211 static struct rng_alg hisi_trng_alg = {
 212         .generate = hisi_trng_generate,
 213         .seed = hisi_trng_seed,
 214         .seedsize = SW_DRBG_SEED_SIZE,
 215         .base = {
 216                 .cra_name = "stdrng",
 217                 .cra_driver_name = "hisi_stdrng",
 218                 .cra_priority = 300,
 219                 .cra_ctxsize = sizeof(struct hisi_trng_ctx),
 220                 .cra_module = THIS_MODULE,
 221                 .cra_init = hisi_trng_init,
 222                 .cra_exit = hisi_trng_exit,
 223         },
 224 };
 225
 226 static void hisi_trng_add_to_list(struct hisi_trng *trng)
 227 {
 228         mutex_lock(&trng_devices.lock);
 229         list_add_tail(&trng->list, &trng_devices.list);
 230         mutex_unlock(&trng_devices.lock);
 231 }
 232
 233 static int hisi_trng_del_from_list(struct hisi_trng *trng)
 234 {
 235         int ret = -EBUSY;
 236
 237         mutex_lock(&trng_devices.lock);
 238         if (!trng->is_used) {
 239                 list_del(&trng->list);
 240                 ret = 0;
 241         }
 242         mutex_unlock(&trng_devices.lock);
 243
 244         return ret;
 245 }
 246
 247 static int hisi_trng_probe(struct platform_device *pdev)
 248 {
 249         struct hisi_trng *trng;
 250         int ret;
 251
 252         trng = devm_kzalloc(&pdev->dev, sizeof(*trng), GFP_KERNEL);
 253         if (!trng)
 254                 return -ENOMEM;
 255
 256         platform_set_drvdata(pdev, trng);
 257
 258         trng->base = devm_platform_ioremap_resource(pdev, 0);
 259         if (IS_ERR(trng->base))
 260                 return PTR_ERR(trng->base);
 261
 262         trng->is_used = false;
 263         if (!trng_devices.is_init) {
 264                 INIT_LIST_HEAD(&trng_devices.list);
 265                 mutex_init(&trng_devices.lock);
 266                 trng_devices.is_init = true;
 267         }
 268
 269         hisi_trng_add_to_list(trng);
 270         if (atomic_inc_return(&trng_active_devs) == 1) {
 271                 ret = crypto_register_rng(&hisi_trng_alg);
 272                 if (ret) {
 273                         dev_err(&pdev->dev,
 274                                 "failed to register crypto(%d)\n", ret);
 275                         atomic_dec_return(&trng_active_devs);
 276                         goto err_remove_from_list;
 277                 }
 278         }
 279
 280         trng->rng.name = pdev->name;
 281         trng->rng.read = hisi_trng_read;
 282         trng->rng.quality = HISI_TRNG_QUALITY;
 283         ret = devm_hwrng_register(&pdev->dev, &trng->rng);
 284         if (ret) {
 285                 dev_err(&pdev->dev, "failed to register hwrng: %d!\n", ret);
 286                 goto err_crypto_unregister;
 287         }
 288
 289         return ret;
 290
 291 err_crypto_unregister:
 292         if (atomic_dec_return(&trng_active_devs) == 0)
 293                 crypto_unregister_rng(&hisi_trng_alg);
 294
 295 err_remove_from_list:
 296         hisi_trng_del_from_list(trng);
 297         return ret;
 298 }
 299
 300 static int hisi_trng_remove(struct platform_device *pdev)
 301 {
 302         struct hisi_trng *trng = platform_get_drvdata(pdev);
 303
 304         /* Wait until the task is finished */
 305         while (hisi_trng_del_from_list(trng))
 306                 ;
 307
 308         if (atomic_dec_return(&trng_active_devs) == 0)
 309                 crypto_unregister_rng(&hisi_trng_alg);
 310
 311         return 0;
 312 }
 313
 314 static const struct acpi_device_id hisi_trng_acpi_match[] = {
 315         { "HISI02B3", 0 },
 316         { }
 317 };
 318 MODULE_DEVICE_TABLE(acpi, hisi_trng_acpi_match);
 319
 320 static struct platform_driver hisi_trng_driver = {
 321         .probe          = hisi_trng_probe,
 322         .remove         = hisi_trng_remove,
 323         .driver         = {
 324                 .name   = "hisi-trng-v2",
 325                 .acpi_match_table = ACPI_PTR(hisi_trng_acpi_match),
 326         },
 327 };
 328
 329 module_platform_driver(hisi_trng_driver);
 330
 331 MODULE_LICENSE("GPL v2");
 332 MODULE_AUTHOR("Weili Qian <qianweili@huawei.com>");
 333 MODULE_AUTHOR("Zaibo Xu <xuzaibo@huawei.com>");
 334 MODULE_DESCRIPTION("HiSilicon true random number generator V2 driver");