drivers/crypto/marvell/cesa.c

   1 /*
   2  * Support for Marvell's Cryptographic Engine and Security Accelerator (CESA)
   3  * that can be found on the following platform: Orion, Kirkwood, Armada. This
   4  * driver supports the TDMA engine on platforms on which it is available.
   5  *
   6  * Author: Boris Brezillon <boris.brezillon@free-electrons.com>
   7  * Author: Arnaud Ebalard <arno@natisbad.org>
   8  *
   9  * This work is based on an initial version written by
  10  * Sebastian Andrzej Siewior < sebastian at breakpoint dot cc >
  11  *
  12  * This program is free software; you can redistribute it and/or modify it
  13  * under the terms of the GNU General Public License version 2 as published
  14  * by the Free Software Foundation.
  15  */
  16
  17 #include <linux/delay.h>
  18 #include <linux/genalloc.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/io.h>
  21 #include <linux/kthread.h>
  22 #include <linux/mbus.h>
  23 #include <linux/platform_device.h>
  24 #include <linux/scatterlist.h>
  25 #include <linux/slab.h>
  26 #include <linux/module.h>
  27 #include <linux/clk.h>
  28 #include <linux/of.h>
  29 #include <linux/of_platform.h>
  30 #include <linux/of_irq.h>
  31
  32 #include "cesa.h"
  33
  34 struct mv_cesa_dev *cesa_dev;
  35
  36 static void mv_cesa_dequeue_req_unlocked(struct mv_cesa_engine *engine)
  37 {
  38         struct crypto_async_request *req, *backlog;
  39         struct mv_cesa_ctx *ctx;
  40
  41         spin_lock_bh(&cesa_dev->lock);
  42         backlog = crypto_get_backlog(&cesa_dev->queue);
  43         req = crypto_dequeue_request(&cesa_dev->queue);
  44         engine->req = req;
  45         spin_unlock_bh(&cesa_dev->lock);
  46
  47         if (!req)
  48                 return;
  49
  50         if (backlog)
  51                 backlog->complete(backlog, -EINPROGRESS);
  52
  53         ctx = crypto_tfm_ctx(req->tfm);
  54         ctx->ops->prepare(req, engine);
  55         ctx->ops->step(req);
  56 }
  57
  58 static irqreturn_t mv_cesa_int(int irq, void *priv)
  59 {
  60         struct mv_cesa_engine *engine = priv;
  61         struct crypto_async_request *req;
  62         struct mv_cesa_ctx *ctx;
  63         u32 status, mask;
  64         irqreturn_t ret = IRQ_NONE;
  65
  66         while (true) {
  67                 int res;
  68
  69                 mask = mv_cesa_get_int_mask(engine);
  70                 status = readl(engine->regs + CESA_SA_INT_STATUS);
  71
  72                 if (!(status & mask))
  73                         break;
  74
  75                 /*
  76                  * TODO: avoid clearing the FPGA_INT_STATUS if this not
  77                  * relevant on some platforms.
  78                  */
  79                 writel(~status, engine->regs + CESA_SA_FPGA_INT_STATUS);
  80                 writel(~status, engine->regs + CESA_SA_INT_STATUS);
  81
  82                 ret = IRQ_HANDLED;
  83                 spin_lock_bh(&engine->lock);
  84                 req = engine->req;
  85                 spin_unlock_bh(&engine->lock);
  86                 if (req) {
  87                         ctx = crypto_tfm_ctx(req->tfm);
  88                         res = ctx->ops->process(req, status & mask);
  89                         if (res != -EINPROGRESS) {
  90                                 spin_lock_bh(&engine->lock);
  91                                 engine->req = NULL;
  92                                 mv_cesa_dequeue_req_unlocked(engine);
  93                                 spin_unlock_bh(&engine->lock);
  94                                 ctx->ops->cleanup(req);
  95                                 local_bh_disable();
  96                                 req->complete(req, res);
  97                                 local_bh_enable();
  98                         } else {
  99                                 ctx->ops->step(req);
 100                         }
 101                 }
 102         }
 103
 104         return ret;
 105 }
 106
 107 int mv_cesa_queue_req(struct crypto_async_request *req)
 108 {
 109         int ret;
 110         int i;
 111
 112         spin_lock_bh(&cesa_dev->lock);
 113         ret = crypto_enqueue_request(&cesa_dev->queue, req);
 114         spin_unlock_bh(&cesa_dev->lock);
 115
 116         if (ret != -EINPROGRESS)
 117                 return ret;
 118
 119         for (i = 0; i < cesa_dev->caps->nengines; i++) {
 120                 spin_lock_bh(&cesa_dev->engines[i].lock);
 121                 if (!cesa_dev->engines[i].req)
 122                         mv_cesa_dequeue_req_unlocked(&cesa_dev->engines[i]);
 123                 spin_unlock_bh(&cesa_dev->engines[i].lock);
 124         }
 125
 126         return -EINPROGRESS;
 127 }
 128
 129 static int mv_cesa_add_algs(struct mv_cesa_dev *cesa)
 130 {
 131         int ret;
 132         int i, j;
 133
 134         for (i = 0; i < cesa->caps->ncipher_algs; i++) {
 135                 ret = crypto_register_alg(cesa->caps->cipher_algs[i]);
 136                 if (ret)
 137                         goto err_unregister_crypto;
 138         }
 139
 140         for (i = 0; i < cesa->caps->nahash_algs; i++) {
 141                 ret = crypto_register_ahash(cesa->caps->ahash_algs[i]);
 142                 if (ret)
 143                         goto err_unregister_ahash;
 144         }
 145
 146         return 0;
 147
 148 err_unregister_ahash:
 149         for (j = 0; j < i; j++)
 150                 crypto_unregister_ahash(cesa->caps->ahash_algs[j]);
 151         i = cesa->caps->ncipher_algs;
 152
 153 err_unregister_crypto:
 154         for (j = 0; j < i; j++)
 155                 crypto_unregister_alg(cesa->caps->cipher_algs[j]);
 156
 157         return ret;
 158 }
 159
 160 static void mv_cesa_remove_algs(struct mv_cesa_dev *cesa)
 161 {
 162         int i;
 163
 164         for (i = 0; i < cesa->caps->nahash_algs; i++)
 165                 crypto_unregister_ahash(cesa->caps->ahash_algs[i]);
 166
 167         for (i = 0; i < cesa->caps->ncipher_algs; i++)
 168                 crypto_unregister_alg(cesa->caps->cipher_algs[i]);
 169 }
 170
 171 static struct crypto_alg *armada_370_cipher_algs[] = {
 172         &mv_cesa_ecb_des_alg,
 173         &mv_cesa_cbc_des_alg,
 174         &mv_cesa_ecb_des3_ede_alg,
 175         &mv_cesa_cbc_des3_ede_alg,
 176         &mv_cesa_ecb_aes_alg,
 177         &mv_cesa_cbc_aes_alg,
 178 };
 179
 180 static struct ahash_alg *armada_370_ahash_algs[] = {
 181         &mv_md5_alg,
 182         &mv_sha1_alg,
 183         &mv_ahmac_md5_alg,
 184         &mv_ahmac_sha1_alg,
 185 };
 186
 187 static const struct mv_cesa_caps armada_370_caps = {
 188         .nengines = 1,
 189         .cipher_algs = armada_370_cipher_algs,
 190         .ncipher_algs = ARRAY_SIZE(armada_370_cipher_algs),
 191         .ahash_algs = armada_370_ahash_algs,
 192         .nahash_algs = ARRAY_SIZE(armada_370_ahash_algs),
 193         .has_tdma = true,
 194 };
 195
 196 static const struct of_device_id mv_cesa_of_match_table[] = {
 197         { .compatible = "marvell,armada-370-crypto", .data = &armada_370_caps },
 198         {}
 199 };
 200 MODULE_DEVICE_TABLE(of, mv_cesa_of_match_table);
 201
 202 static void
 203 mv_cesa_conf_mbus_windows(struct mv_cesa_engine *engine,
 204                           const struct mbus_dram_target_info *dram)
 205 {
 206         void __iomem *iobase = engine->regs;
 207         int i;
 208
 209         for (i = 0; i < 4; i++) {
 210                 writel(0, iobase + CESA_TDMA_WINDOW_CTRL(i));
 211                 writel(0, iobase + CESA_TDMA_WINDOW_BASE(i));
 212         }
 213
 214         for (i = 0; i < dram->num_cs; i++) {
 215                 const struct mbus_dram_window *cs = dram->cs + i;
 216
 217                 writel(((cs->size - 1) & 0xffff0000) |
 218                        (cs->mbus_attr << 8) |
 219                        (dram->mbus_dram_target_id << 4) | 1,
 220                        iobase + CESA_TDMA_WINDOW_CTRL(i));
 221                 writel(cs->base, iobase + CESA_TDMA_WINDOW_BASE(i));
 222         }
 223 }
 224
 225 static int mv_cesa_dev_dma_init(struct mv_cesa_dev *cesa)
 226 {
 227         struct device *dev = cesa->dev;
 228         struct mv_cesa_dev_dma *dma;
 229
 230         if (!cesa->caps->has_tdma)
 231                 return 0;
 232
 233         dma = devm_kzalloc(dev, sizeof(*dma), GFP_KERNEL);
 234         if (!dma)
 235                 return -ENOMEM;
 236
 237         dma->tdma_desc_pool = dmam_pool_create("tdma_desc", dev,
 238                                         sizeof(struct mv_cesa_tdma_desc),
 239                                         16, 0);
 240         if (!dma->tdma_desc_pool)
 241                 return -ENOMEM;
 242
 243         dma->op_pool = dmam_pool_create("cesa_op", dev,
 244                                         sizeof(struct mv_cesa_op_ctx), 16, 0);
 245         if (!dma->op_pool)
 246                 return -ENOMEM;
 247
 248         dma->cache_pool = dmam_pool_create("cesa_cache", dev,
 249                                            CESA_MAX_HASH_BLOCK_SIZE, 1, 0);
 250         if (!dma->cache_pool)
 251                 return -ENOMEM;
 252
 253         dma->padding_pool = dmam_pool_create("cesa_padding", dev, 72, 1, 0);
 254         if (!dma->cache_pool)
 255                 return -ENOMEM;
 256
 257         cesa->dma = dma;
 258
 259         return 0;
 260 }
 261
 262 static int mv_cesa_get_sram(struct platform_device *pdev, int idx)
 263 {
 264         struct mv_cesa_dev *cesa = platform_get_drvdata(pdev);
 265         struct mv_cesa_engine *engine = &cesa->engines[idx];
 266         const char *res_name = "sram";
 267         struct resource *res;
 268
 269         engine->pool = of_get_named_gen_pool(cesa->dev->of_node,
 270                                              "marvell,crypto-srams",
 271                                              idx);
 272         if (engine->pool) {
 273                 engine->sram = gen_pool_dma_alloc(engine->pool,
 274                                                   cesa->sram_size,
 275                                                   &engine->sram_dma);
 276                 if (engine->sram)
 277                         return 0;
 278
 279                 engine->pool = NULL;
 280                 return -ENOMEM;
 281         }
 282
 283         if (cesa->caps->nengines > 1) {
 284                 if (!idx)
 285                         res_name = "sram0";
 286                 else
 287                         res_name = "sram1";
 288         }
 289
 290         res = platform_get_resource_byname(pdev, IORESOURCE_MEM,
 291                                            res_name);
 292         if (!res || resource_size(res) < cesa->sram_size)
 293                 return -EINVAL;
 294
 295         engine->sram = devm_ioremap_resource(cesa->dev, res);
 296         if (IS_ERR(engine->sram))
 297                 return PTR_ERR(engine->sram);
 298
 299         engine->sram_dma = phys_to_dma(cesa->dev,
 300                                        (phys_addr_t)res->start);
 301
 302         return 0;
 303 }
 304
 305 static void mv_cesa_put_sram(struct platform_device *pdev, int idx)
 306 {
 307         struct mv_cesa_dev *cesa = platform_get_drvdata(pdev);
 308         struct mv_cesa_engine *engine = &cesa->engines[idx];
 309
 310         if (!engine->pool)
 311                 return;
 312
 313         gen_pool_free(engine->pool, (unsigned long)engine->sram,
 314                       cesa->sram_size);
 315 }
 316
 317 static int mv_cesa_probe(struct platform_device *pdev)
 318 {
 319         const struct mv_cesa_caps *caps = NULL;
 320         const struct mbus_dram_target_info *dram;
 321         const struct of_device_id *match;
 322         struct device *dev = &pdev->dev;
 323         struct mv_cesa_dev *cesa;
 324         struct mv_cesa_engine *engines;
 325         struct resource *res;
 326         int irq, ret, i;
 327         u32 sram_size;
 328
 329         if (cesa_dev) {
 330                 dev_err(&pdev->dev, "Only one CESA device authorized\n");
 331                 return -EEXIST;
 332         }
 333
 334         if (!dev->of_node)
 335                 return -ENOTSUPP;
 336
 337         match = of_match_node(mv_cesa_of_match_table, dev->of_node);
 338         if (!match || !match->data)
 339                 return -ENOTSUPP;
 340
 341         caps = match->data;
 342
 343         cesa = devm_kzalloc(dev, sizeof(*cesa), GFP_KERNEL);
 344         if (!cesa)
 345                 return -ENOMEM;
 346
 347         cesa->caps = caps;
 348         cesa->dev = dev;
 349
 350         sram_size = CESA_SA_DEFAULT_SRAM_SIZE;
 351         of_property_read_u32(cesa->dev->of_node, "marvell,crypto-sram-size",
 352                              &sram_size);
 353         if (sram_size < CESA_SA_MIN_SRAM_SIZE)
 354                 sram_size = CESA_SA_MIN_SRAM_SIZE;
 355
 356         cesa->sram_size = sram_size;
 357         cesa->engines = devm_kzalloc(dev, caps->nengines * sizeof(*engines),
 358                                      GFP_KERNEL);
 359         if (!cesa->engines)
 360                 return -ENOMEM;
 361
 362         spin_lock_init(&cesa->lock);
 363         crypto_init_queue(&cesa->queue, 50);
 364         res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "regs");
 365         cesa->regs = devm_ioremap_resource(dev, res);
 366         if (IS_ERR(cesa->regs))
 367                 return -ENOMEM;
 368
 369         ret = mv_cesa_dev_dma_init(cesa);
 370         if (ret)
 371                 return ret;
 372
 373         dram = mv_mbus_dram_info_nooverlap();
 374
 375         platform_set_drvdata(pdev, cesa);
 376
 377         for (i = 0; i < caps->nengines; i++) {
 378                 struct mv_cesa_engine *engine = &cesa->engines[i];
 379                 char res_name[7];
 380
 381                 engine->id = i;
 382                 spin_lock_init(&engine->lock);
 383
 384                 ret = mv_cesa_get_sram(pdev, i);
 385                 if (ret)
 386                         goto err_cleanup;
 387
 388                 irq = platform_get_irq(pdev, i);
 389                 if (irq < 0) {
 390                         ret = irq;
 391                         goto err_cleanup;
 392                 }
 393
 394                 /*
 395                  * Not all platforms can gate the CESA clocks: do not complain
 396                  * if the clock does not exist.
 397                  */
 398                 snprintf(res_name, sizeof(res_name), "cesa%d", i);
 399                 engine->clk = devm_clk_get(dev, res_name);
 400                 if (IS_ERR(engine->clk)) {
 401                         engine->clk = devm_clk_get(dev, NULL);
 402                         if (IS_ERR(engine->clk))
 403                                 engine->clk = NULL;
 404                 }
 405
 406                 snprintf(res_name, sizeof(res_name), "cesaz%d", i);
 407                 engine->zclk = devm_clk_get(dev, res_name);
 408                 if (IS_ERR(engine->zclk))
 409                         engine->zclk = NULL;
 410
 411                 ret = clk_prepare_enable(engine->clk);
 412                 if (ret)
 413                         goto err_cleanup;
 414
 415                 ret = clk_prepare_enable(engine->zclk);
 416                 if (ret)
 417                         goto err_cleanup;
 418
 419                 engine->regs = cesa->regs + CESA_ENGINE_OFF(i);
 420
 421                 if (dram && cesa->caps->has_tdma)
 422                         mv_cesa_conf_mbus_windows(&cesa->engines[i], dram);
 423
 424                 writel(0, cesa->engines[i].regs + CESA_SA_INT_STATUS);
 425                 writel(CESA_SA_CFG_STOP_DIG_ERR,
 426                        cesa->engines[i].regs + CESA_SA_CFG);
 427                 writel(engine->sram_dma & CESA_SA_SRAM_MSK,
 428                        cesa->engines[i].regs + CESA_SA_DESC_P0);
 429
 430                 ret = devm_request_threaded_irq(dev, irq, NULL, mv_cesa_int,
 431                                                 IRQF_ONESHOT,
 432                                                 dev_name(&pdev->dev),
 433                                                 &cesa->engines[i]);
 434                 if (ret)
 435                         goto err_cleanup;
 436         }
 437
 438         cesa_dev = cesa;
 439
 440         ret = mv_cesa_add_algs(cesa);
 441         if (ret) {
 442                 cesa_dev = NULL;
 443                 goto err_cleanup;
 444         }
 445
 446         dev_info(dev, "CESA device successfully registered\n");
 447
 448         return 0;
 449
 450 err_cleanup:
 451         for (i = 0; i < caps->nengines; i++) {
 452                 clk_disable_unprepare(cesa->engines[i].zclk);
 453                 clk_disable_unprepare(cesa->engines[i].clk);
 454                 mv_cesa_put_sram(pdev, i);
 455         }
 456
 457         return ret;
 458 }
 459
 460 static int mv_cesa_remove(struct platform_device *pdev)
 461 {
 462         struct mv_cesa_dev *cesa = platform_get_drvdata(pdev);
 463         int i;
 464
 465         mv_cesa_remove_algs(cesa);
 466
 467         for (i = 0; i < cesa->caps->nengines; i++) {
 468                 clk_disable_unprepare(cesa->engines[i].zclk);
 469                 clk_disable_unprepare(cesa->engines[i].clk);
 470                 mv_cesa_put_sram(pdev, i);
 471         }
 472
 473         return 0;
 474 }
 475
 476 static struct platform_driver marvell_cesa = {
 477         .probe          = mv_cesa_probe,
 478         .remove         = mv_cesa_remove,
 479         .driver         = {
 480                 .owner  = THIS_MODULE,
 481                 .name   = "marvell-cesa",
 482                 .of_match_table = mv_cesa_of_match_table,
 483         },
 484 };
 485 module_platform_driver(marvell_cesa);
 486
 487 MODULE_ALIAS("platform:mv_crypto");
 488 MODULE_AUTHOR("Boris Brezillon <boris.brezillon@free-electrons.com>");
 489 MODULE_AUTHOR("Arnaud Ebalard <arno@natisbad.org>");
 490 MODULE_DESCRIPTION("Support for Marvell's cryptographic engine");
 491 MODULE_LICENSE("GPL v2");