drivers/crypto/rockchip/rk3288_crypto_skcipher.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Crypto acceleration support for Rockchip RK3288
   4  *
   5  * Copyright (c) 2015, Fuzhou Rockchip Electronics Co., Ltd
   6  *
   7  * Author: Zain Wang <zain.wang@rock-chips.com>
   8  *
   9  * Some ideas are from marvell-cesa.c and s5p-sss.c driver.
  10  */
  11
  12 #include <crypto/engine.h>
  13 #include <crypto/internal/skcipher.h>
  14 #include <crypto/scatterwalk.h>
  15 #include <linux/device.h>
  16 #include <linux/err.h>
  17 #include <linux/kernel.h>
  18 #include <linux/string.h>
  19 #include "rk3288_crypto.h"
  20
  21 #define RK_CRYPTO_DEC                   BIT(0)
  22
  23 static int rk_cipher_need_fallback(struct skcipher_request *req)
  24 {
  25         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  26         struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
  27         struct rk_crypto_tmp *algt = container_of(alg, struct rk_crypto_tmp, alg.skcipher.base);
  28         struct scatterlist *sgs, *sgd;
  29         unsigned int stodo, dtodo, len;
  30         unsigned int bs = crypto_skcipher_blocksize(tfm);
  31
  32         if (!req->cryptlen)
  33                 return true;
  34
  35         len = req->cryptlen;
  36         sgs = req->src;
  37         sgd = req->dst;
  38         while (sgs && sgd) {
  39                 if (!IS_ALIGNED(sgs->offset, sizeof(u32))) {
  40                         algt->stat_fb_align++;
  41                         return true;
  42                 }
  43                 if (!IS_ALIGNED(sgd->offset, sizeof(u32))) {
  44                         algt->stat_fb_align++;
  45                         return true;
  46                 }
  47                 stodo = min(len, sgs->length);
  48                 if (stodo % bs) {
  49                         algt->stat_fb_len++;
  50                         return true;
  51                 }
  52                 dtodo = min(len, sgd->length);
  53                 if (dtodo % bs) {
  54                         algt->stat_fb_len++;
  55                         return true;
  56                 }
  57                 if (stodo != dtodo) {
  58                         algt->stat_fb_sgdiff++;
  59                         return true;
  60                 }
  61                 len -= stodo;
  62                 sgs = sg_next(sgs);
  63                 sgd = sg_next(sgd);
  64         }
  65         return false;
  66 }
  67
  68 static int rk_cipher_fallback(struct skcipher_request *areq)
  69 {
  70         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
  71         struct rk_cipher_ctx *op = crypto_skcipher_ctx(tfm);
  72         struct rk_cipher_rctx *rctx = skcipher_request_ctx(areq);
  73         struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
  74         struct rk_crypto_tmp *algt = container_of(alg, struct rk_crypto_tmp, alg.skcipher.base);
  75         int err;
  76
  77         algt->stat_fb++;
  78
  79         skcipher_request_set_tfm(&rctx->fallback_req, op->fallback_tfm);
  80         skcipher_request_set_callback(&rctx->fallback_req, areq->base.flags,
  81                                       areq->base.complete, areq->base.data);
  82         skcipher_request_set_crypt(&rctx->fallback_req, areq->src, areq->dst,
  83                                    areq->cryptlen, areq->iv);
  84         if (rctx->mode & RK_CRYPTO_DEC)
  85                 err = crypto_skcipher_decrypt(&rctx->fallback_req);
  86         else
  87                 err = crypto_skcipher_encrypt(&rctx->fallback_req);
  88         return err;
  89 }
  90
  91 static int rk_cipher_handle_req(struct skcipher_request *req)
  92 {
  93         struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
  94         struct rk_crypto_info *rkc;
  95         struct crypto_engine *engine;
  96
  97         if (rk_cipher_need_fallback(req))
  98                 return rk_cipher_fallback(req);
  99
 100         rkc = get_rk_crypto();
 101
 102         engine = rkc->engine;
 103         rctx->dev = rkc;
 104
 105         return crypto_transfer_skcipher_request_to_engine(engine, req);
 106 }
 107
 108 static int rk_aes_setkey(struct crypto_skcipher *cipher,
 109                          const u8 *key, unsigned int keylen)
 110 {
 111         struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);
 112         struct rk_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
 113
 114         if (keylen != AES_KEYSIZE_128 && keylen != AES_KEYSIZE_192 &&
 115             keylen != AES_KEYSIZE_256)
 116                 return -EINVAL;
 117         ctx->keylen = keylen;
 118         memcpy(ctx->key, key, keylen);
 119
 120         return crypto_skcipher_setkey(ctx->fallback_tfm, key, keylen);
 121 }
 122
 123 static int rk_des_setkey(struct crypto_skcipher *cipher,
 124                          const u8 *key, unsigned int keylen)
 125 {
 126         struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(cipher);
 127         int err;
 128
 129         err = verify_skcipher_des_key(cipher, key);
 130         if (err)
 131                 return err;
 132
 133         ctx->keylen = keylen;
 134         memcpy(ctx->key, key, keylen);
 135
 136         return crypto_skcipher_setkey(ctx->fallback_tfm, key, keylen);
 137 }
 138
 139 static int rk_tdes_setkey(struct crypto_skcipher *cipher,
 140                           const u8 *key, unsigned int keylen)
 141 {
 142         struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(cipher);
 143         int err;
 144
 145         err = verify_skcipher_des3_key(cipher, key);
 146         if (err)
 147                 return err;
 148
 149         ctx->keylen = keylen;
 150         memcpy(ctx->key, key, keylen);
 151
 152         return crypto_skcipher_setkey(ctx->fallback_tfm, key, keylen);
 153 }
 154
 155 static int rk_aes_ecb_encrypt(struct skcipher_request *req)
 156 {
 157         struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
 158
 159         rctx->mode = RK_CRYPTO_AES_ECB_MODE;
 160         return rk_cipher_handle_req(req);
 161 }
 162
 163 static int rk_aes_ecb_decrypt(struct skcipher_request *req)
 164 {
 165         struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
 166
 167         rctx->mode = RK_CRYPTO_AES_ECB_MODE | RK_CRYPTO_DEC;
 168         return rk_cipher_handle_req(req);
 169 }
 170
 171 static int rk_aes_cbc_encrypt(struct skcipher_request *req)
 172 {
 173         struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
 174
 175         rctx->mode = RK_CRYPTO_AES_CBC_MODE;
 176         return rk_cipher_handle_req(req);
 177 }
 178
 179 static int rk_aes_cbc_decrypt(struct skcipher_request *req)
 180 {
 181         struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
 182
 183         rctx->mode = RK_CRYPTO_AES_CBC_MODE | RK_CRYPTO_DEC;
 184         return rk_cipher_handle_req(req);
 185 }
 186
 187 static int rk_des_ecb_encrypt(struct skcipher_request *req)
 188 {
 189         struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
 190
 191         rctx->mode = 0;
 192         return rk_cipher_handle_req(req);
 193 }
 194
 195 static int rk_des_ecb_decrypt(struct skcipher_request *req)
 196 {
 197         struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
 198
 199         rctx->mode = RK_CRYPTO_DEC;
 200         return rk_cipher_handle_req(req);
 201 }
 202
 203 static int rk_des_cbc_encrypt(struct skcipher_request *req)
 204 {
 205         struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
 206
 207         rctx->mode = RK_CRYPTO_TDES_CHAINMODE_CBC;
 208         return rk_cipher_handle_req(req);
 209 }
 210
 211 static int rk_des_cbc_decrypt(struct skcipher_request *req)
 212 {
 213         struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
 214
 215         rctx->mode = RK_CRYPTO_TDES_CHAINMODE_CBC | RK_CRYPTO_DEC;
 216         return rk_cipher_handle_req(req);
 217 }
 218
 219 static int rk_des3_ede_ecb_encrypt(struct skcipher_request *req)
 220 {
 221         struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
 222
 223         rctx->mode = RK_CRYPTO_TDES_SELECT;
 224         return rk_cipher_handle_req(req);
 225 }
 226
 227 static int rk_des3_ede_ecb_decrypt(struct skcipher_request *req)
 228 {
 229         struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
 230
 231         rctx->mode = RK_CRYPTO_TDES_SELECT | RK_CRYPTO_DEC;
 232         return rk_cipher_handle_req(req);
 233 }
 234
 235 static int rk_des3_ede_cbc_encrypt(struct skcipher_request *req)
 236 {
 237         struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
 238
 239         rctx->mode = RK_CRYPTO_TDES_SELECT | RK_CRYPTO_TDES_CHAINMODE_CBC;
 240         return rk_cipher_handle_req(req);
 241 }
 242
 243 static int rk_des3_ede_cbc_decrypt(struct skcipher_request *req)
 244 {
 245         struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
 246
 247         rctx->mode = RK_CRYPTO_TDES_SELECT | RK_CRYPTO_TDES_CHAINMODE_CBC |
 248                     RK_CRYPTO_DEC;
 249         return rk_cipher_handle_req(req);
 250 }
 251
 252 static void rk_cipher_hw_init(struct rk_crypto_info *dev, struct skcipher_request *req)
 253 {
 254         struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(req);
 255         struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);
 256         struct rk_cipher_rctx *rctx = skcipher_request_ctx(req);
 257         struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(cipher);
 258         u32 block, conf_reg = 0;
 259
 260         block = crypto_tfm_alg_blocksize(tfm);
 261
 262         if (block == DES_BLOCK_SIZE) {
 263                 rctx->mode |= RK_CRYPTO_TDES_FIFO_MODE |
 264                              RK_CRYPTO_TDES_BYTESWAP_KEY |
 265                              RK_CRYPTO_TDES_BYTESWAP_IV;
 266                 CRYPTO_WRITE(dev, RK_CRYPTO_TDES_CTRL, rctx->mode);
 267                 memcpy_toio(dev->reg + RK_CRYPTO_TDES_KEY1_0, ctx->key, ctx->keylen);
 268                 conf_reg = RK_CRYPTO_DESSEL;
 269         } else {
 270                 rctx->mode |= RK_CRYPTO_AES_FIFO_MODE |
 271                              RK_CRYPTO_AES_KEY_CHANGE |
 272                              RK_CRYPTO_AES_BYTESWAP_KEY |
 273                              RK_CRYPTO_AES_BYTESWAP_IV;
 274                 if (ctx->keylen == AES_KEYSIZE_192)
 275                         rctx->mode |= RK_CRYPTO_AES_192BIT_key;
 276                 else if (ctx->keylen == AES_KEYSIZE_256)
 277                         rctx->mode |= RK_CRYPTO_AES_256BIT_key;
 278                 CRYPTO_WRITE(dev, RK_CRYPTO_AES_CTRL, rctx->mode);
 279                 memcpy_toio(dev->reg + RK_CRYPTO_AES_KEY_0, ctx->key, ctx->keylen);
 280         }
 281         conf_reg |= RK_CRYPTO_BYTESWAP_BTFIFO |
 282                     RK_CRYPTO_BYTESWAP_BRFIFO;
 283         CRYPTO_WRITE(dev, RK_CRYPTO_CONF, conf_reg);
 284         CRYPTO_WRITE(dev, RK_CRYPTO_INTENA,
 285                      RK_CRYPTO_BCDMA_ERR_ENA | RK_CRYPTO_BCDMA_DONE_ENA);
 286 }
 287
 288 static void crypto_dma_start(struct rk_crypto_info *dev,
 289                              struct scatterlist *sgs,
 290                              struct scatterlist *sgd, unsigned int todo)
 291 {
 292         CRYPTO_WRITE(dev, RK_CRYPTO_BRDMAS, sg_dma_address(sgs));
 293         CRYPTO_WRITE(dev, RK_CRYPTO_BRDMAL, todo);
 294         CRYPTO_WRITE(dev, RK_CRYPTO_BTDMAS, sg_dma_address(sgd));
 295         CRYPTO_WRITE(dev, RK_CRYPTO_CTRL, RK_CRYPTO_BLOCK_START |
 296                      _SBF(RK_CRYPTO_BLOCK_START, 16));
 297 }
 298
 299 static int rk_cipher_run(struct crypto_engine *engine, void *async_req)
 300 {
 301         struct skcipher_request *areq = container_of(async_req, struct skcipher_request, base);
 302         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(areq);
 303         struct rk_cipher_rctx *rctx = skcipher_request_ctx(areq);
 304         struct scatterlist *sgs, *sgd;
 305         int err = 0;
 306         int ivsize = crypto_skcipher_ivsize(tfm);
 307         int offset;
 308         u8 iv[AES_BLOCK_SIZE];
 309         u8 biv[AES_BLOCK_SIZE];
 310         u8 *ivtouse = areq->iv;
 311         unsigned int len = areq->cryptlen;
 312         unsigned int todo;
 313         struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
 314         struct rk_crypto_tmp *algt = container_of(alg, struct rk_crypto_tmp, alg.skcipher.base);
 315         struct rk_crypto_info *rkc = rctx->dev;
 316
 317         err = pm_runtime_resume_and_get(rkc->dev);
 318         if (err)
 319                 return err;
 320
 321         algt->stat_req++;
 322         rkc->nreq++;
 323
 324         ivsize = crypto_skcipher_ivsize(tfm);
 325         if (areq->iv && crypto_skcipher_ivsize(tfm) > 0) {
 326                 if (rctx->mode & RK_CRYPTO_DEC) {
 327                         offset = areq->cryptlen - ivsize;
 328                         scatterwalk_map_and_copy(rctx->backup_iv, areq->src,
 329                                                  offset, ivsize, 0);
 330                 }
 331         }
 332
 333         sgs = areq->src;
 334         sgd = areq->dst;
 335
 336         while (sgs && sgd && len) {
 337                 if (!sgs->length) {
 338                         sgs = sg_next(sgs);
 339                         sgd = sg_next(sgd);
 340                         continue;
 341                 }
 342                 if (rctx->mode & RK_CRYPTO_DEC) {
 343                         /* we backup last block of source to be used as IV at next step */
 344                         offset = sgs->length - ivsize;
 345                         scatterwalk_map_and_copy(biv, sgs, offset, ivsize, 0);
 346                 }
 347                 if (sgs == sgd) {
 348                         err = dma_map_sg(rkc->dev, sgs, 1, DMA_BIDIRECTIONAL);
 349                         if (err <= 0) {
 350                                 err = -EINVAL;
 351                                 goto theend_iv;
 352                         }
 353                 } else {
 354                         err = dma_map_sg(rkc->dev, sgs, 1, DMA_TO_DEVICE);
 355                         if (err <= 0) {
 356                                 err = -EINVAL;
 357                                 goto theend_iv;
 358                         }
 359                         err = dma_map_sg(rkc->dev, sgd, 1, DMA_FROM_DEVICE);
 360                         if (err <= 0) {
 361                                 err = -EINVAL;
 362                                 goto theend_sgs;
 363                         }
 364                 }
 365                 err = 0;
 366                 rk_cipher_hw_init(rkc, areq);
 367                 if (ivsize) {
 368                         if (ivsize == DES_BLOCK_SIZE)
 369                                 memcpy_toio(rkc->reg + RK_CRYPTO_TDES_IV_0, ivtouse, ivsize);
 370                         else
 371                                 memcpy_toio(rkc->reg + RK_CRYPTO_AES_IV_0, ivtouse, ivsize);
 372                 }
 373                 reinit_completion(&rkc->complete);
 374                 rkc->status = 0;
 375
 376                 todo = min(sg_dma_len(sgs), len);
 377                 len -= todo;
 378                 crypto_dma_start(rkc, sgs, sgd, todo / 4);
 379                 wait_for_completion_interruptible_timeout(&rkc->complete,
 380                                                           msecs_to_jiffies(2000));
 381                 if (!rkc->status) {
 382                         dev_err(rkc->dev, "DMA timeout\n");
 383                         err = -EFAULT;
 384                         goto theend;
 385                 }
 386                 if (sgs == sgd) {
 387                         dma_unmap_sg(rkc->dev, sgs, 1, DMA_BIDIRECTIONAL);
 388                 } else {
 389                         dma_unmap_sg(rkc->dev, sgs, 1, DMA_TO_DEVICE);
 390                         dma_unmap_sg(rkc->dev, sgd, 1, DMA_FROM_DEVICE);
 391                 }
 392                 if (rctx->mode & RK_CRYPTO_DEC) {
 393                         memcpy(iv, biv, ivsize);
 394                         ivtouse = iv;
 395                 } else {
 396                         offset = sgd->length - ivsize;
 397                         scatterwalk_map_and_copy(iv, sgd, offset, ivsize, 0);
 398                         ivtouse = iv;
 399                 }
 400                 sgs = sg_next(sgs);
 401                 sgd = sg_next(sgd);
 402         }
 403
 404         if (areq->iv && ivsize > 0) {
 405                 offset = areq->cryptlen - ivsize;
 406                 if (rctx->mode & RK_CRYPTO_DEC) {
 407                         memcpy(areq->iv, rctx->backup_iv, ivsize);
 408                         memzero_explicit(rctx->backup_iv, ivsize);
 409                 } else {
 410                         scatterwalk_map_and_copy(areq->iv, areq->dst, offset,
 411                                                  ivsize, 0);
 412                 }
 413         }
 414
 415 theend:
 416         pm_runtime_put_autosuspend(rkc->dev);
 417
 418         local_bh_disable();
 419         crypto_finalize_skcipher_request(engine, areq, err);
 420         local_bh_enable();
 421         return 0;
 422
 423 theend_sgs:
 424         if (sgs == sgd) {
 425                 dma_unmap_sg(rkc->dev, sgs, 1, DMA_BIDIRECTIONAL);
 426         } else {
 427                 dma_unmap_sg(rkc->dev, sgs, 1, DMA_TO_DEVICE);
 428                 dma_unmap_sg(rkc->dev, sgd, 1, DMA_FROM_DEVICE);
 429         }
 430 theend_iv:
 431         return err;
 432 }
 433
 434 static int rk_cipher_tfm_init(struct crypto_skcipher *tfm)
 435 {
 436         struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
 437         const char *name = crypto_tfm_alg_name(&tfm->base);
 438         struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
 439         struct rk_crypto_tmp *algt = container_of(alg, struct rk_crypto_tmp, alg.skcipher.base);
 440
 441         ctx->fallback_tfm = crypto_alloc_skcipher(name, 0, CRYPTO_ALG_NEED_FALLBACK);
 442         if (IS_ERR(ctx->fallback_tfm)) {
 443                 dev_err(algt->dev->dev, "ERROR: Cannot allocate fallback for %s %ld\n",
 444                         name, PTR_ERR(ctx->fallback_tfm));
 445                 return PTR_ERR(ctx->fallback_tfm);
 446         }
 447
 448         tfm->reqsize = sizeof(struct rk_cipher_rctx) +
 449                 crypto_skcipher_reqsize(ctx->fallback_tfm);
 450
 451         return 0;
 452 }
 453
 454 static void rk_cipher_tfm_exit(struct crypto_skcipher *tfm)
 455 {
 456         struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
 457
 458         memzero_explicit(ctx->key, ctx->keylen);
 459         crypto_free_skcipher(ctx->fallback_tfm);
 460 }
 461
 462 struct rk_crypto_tmp rk_ecb_aes_alg = {
 463         .type = CRYPTO_ALG_TYPE_SKCIPHER,
 464         .alg.skcipher.base = {
 465                 .base.cra_name          = "ecb(aes)",
 466                 .base.cra_driver_name   = "ecb-aes-rk",
 467                 .base.cra_priority      = 300,
 468                 .base.cra_flags         = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
 469                 .base.cra_blocksize     = AES_BLOCK_SIZE,
 470                 .base.cra_ctxsize       = sizeof(struct rk_cipher_ctx),
 471                 .base.cra_alignmask     = 0x0f,
 472                 .base.cra_module        = THIS_MODULE,
 473
 474                 .init                   = rk_cipher_tfm_init,
 475                 .exit                   = rk_cipher_tfm_exit,
 476                 .min_keysize            = AES_MIN_KEY_SIZE,
 477                 .max_keysize            = AES_MAX_KEY_SIZE,
 478                 .setkey                 = rk_aes_setkey,
 479                 .encrypt                = rk_aes_ecb_encrypt,
 480                 .decrypt                = rk_aes_ecb_decrypt,
 481         },
 482         .alg.skcipher.op = {
 483                 .do_one_request = rk_cipher_run,
 484         },
 485 };
 486
 487 struct rk_crypto_tmp rk_cbc_aes_alg = {
 488         .type = CRYPTO_ALG_TYPE_SKCIPHER,
 489         .alg.skcipher.base = {
 490                 .base.cra_name          = "cbc(aes)",
 491                 .base.cra_driver_name   = "cbc-aes-rk",
 492                 .base.cra_priority      = 300,
 493                 .base.cra_flags         = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
 494                 .base.cra_blocksize     = AES_BLOCK_SIZE,
 495                 .base.cra_ctxsize       = sizeof(struct rk_cipher_ctx),
 496                 .base.cra_alignmask     = 0x0f,
 497                 .base.cra_module        = THIS_MODULE,
 498
 499                 .init                   = rk_cipher_tfm_init,
 500                 .exit                   = rk_cipher_tfm_exit,
 501                 .min_keysize            = AES_MIN_KEY_SIZE,
 502                 .max_keysize            = AES_MAX_KEY_SIZE,
 503                 .ivsize                 = AES_BLOCK_SIZE,
 504                 .setkey                 = rk_aes_setkey,
 505                 .encrypt                = rk_aes_cbc_encrypt,
 506                 .decrypt                = rk_aes_cbc_decrypt,
 507         },
 508         .alg.skcipher.op = {
 509                 .do_one_request = rk_cipher_run,
 510         },
 511 };
 512
 513 struct rk_crypto_tmp rk_ecb_des_alg = {
 514         .type = CRYPTO_ALG_TYPE_SKCIPHER,
 515         .alg.skcipher.base = {
 516                 .base.cra_name          = "ecb(des)",
 517                 .base.cra_driver_name   = "ecb-des-rk",
 518                 .base.cra_priority      = 300,
 519                 .base.cra_flags         = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
 520                 .base.cra_blocksize     = DES_BLOCK_SIZE,
 521                 .base.cra_ctxsize       = sizeof(struct rk_cipher_ctx),
 522                 .base.cra_alignmask     = 0x07,
 523                 .base.cra_module        = THIS_MODULE,
 524
 525                 .init                   = rk_cipher_tfm_init,
 526                 .exit                   = rk_cipher_tfm_exit,
 527                 .min_keysize            = DES_KEY_SIZE,
 528                 .max_keysize            = DES_KEY_SIZE,
 529                 .setkey                 = rk_des_setkey,
 530                 .encrypt                = rk_des_ecb_encrypt,
 531                 .decrypt                = rk_des_ecb_decrypt,
 532         },
 533         .alg.skcipher.op = {
 534                 .do_one_request = rk_cipher_run,
 535         },
 536 };
 537
 538 struct rk_crypto_tmp rk_cbc_des_alg = {
 539         .type = CRYPTO_ALG_TYPE_SKCIPHER,
 540         .alg.skcipher.base = {
 541                 .base.cra_name          = "cbc(des)",
 542                 .base.cra_driver_name   = "cbc-des-rk",
 543                 .base.cra_priority      = 300,
 544                 .base.cra_flags         = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
 545                 .base.cra_blocksize     = DES_BLOCK_SIZE,
 546                 .base.cra_ctxsize       = sizeof(struct rk_cipher_ctx),
 547                 .base.cra_alignmask     = 0x07,
 548                 .base.cra_module        = THIS_MODULE,
 549
 550                 .init                   = rk_cipher_tfm_init,
 551                 .exit                   = rk_cipher_tfm_exit,
 552                 .min_keysize            = DES_KEY_SIZE,
 553                 .max_keysize            = DES_KEY_SIZE,
 554                 .ivsize                 = DES_BLOCK_SIZE,
 555                 .setkey                 = rk_des_setkey,
 556                 .encrypt                = rk_des_cbc_encrypt,
 557                 .decrypt                = rk_des_cbc_decrypt,
 558         },
 559         .alg.skcipher.op = {
 560                 .do_one_request = rk_cipher_run,
 561         },
 562 };
 563
 564 struct rk_crypto_tmp rk_ecb_des3_ede_alg = {
 565         .type = CRYPTO_ALG_TYPE_SKCIPHER,
 566         .alg.skcipher.base = {
 567                 .base.cra_name          = "ecb(des3_ede)",
 568                 .base.cra_driver_name   = "ecb-des3-ede-rk",
 569                 .base.cra_priority      = 300,
 570                 .base.cra_flags         = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
 571                 .base.cra_blocksize     = DES_BLOCK_SIZE,
 572                 .base.cra_ctxsize       = sizeof(struct rk_cipher_ctx),
 573                 .base.cra_alignmask     = 0x07,
 574                 .base.cra_module        = THIS_MODULE,
 575
 576                 .init                   = rk_cipher_tfm_init,
 577                 .exit                   = rk_cipher_tfm_exit,
 578                 .min_keysize            = DES3_EDE_KEY_SIZE,
 579                 .max_keysize            = DES3_EDE_KEY_SIZE,
 580                 .setkey                 = rk_tdes_setkey,
 581                 .encrypt                = rk_des3_ede_ecb_encrypt,
 582                 .decrypt                = rk_des3_ede_ecb_decrypt,
 583         },
 584         .alg.skcipher.op = {
 585                 .do_one_request = rk_cipher_run,
 586         },
 587 };
 588
 589 struct rk_crypto_tmp rk_cbc_des3_ede_alg = {
 590         .type = CRYPTO_ALG_TYPE_SKCIPHER,
 591         .alg.skcipher.base = {
 592                 .base.cra_name          = "cbc(des3_ede)",
 593                 .base.cra_driver_name   = "cbc-des3-ede-rk",
 594                 .base.cra_priority      = 300,
 595                 .base.cra_flags         = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK,
 596                 .base.cra_blocksize     = DES_BLOCK_SIZE,
 597                 .base.cra_ctxsize       = sizeof(struct rk_cipher_ctx),
 598                 .base.cra_alignmask     = 0x07,
 599                 .base.cra_module        = THIS_MODULE,
 600
 601                 .init                   = rk_cipher_tfm_init,
 602                 .exit                   = rk_cipher_tfm_exit,
 603                 .min_keysize            = DES3_EDE_KEY_SIZE,
 604                 .max_keysize            = DES3_EDE_KEY_SIZE,
 605                 .ivsize                 = DES_BLOCK_SIZE,
 606                 .setkey                 = rk_tdes_setkey,
 607                 .encrypt                = rk_des3_ede_cbc_encrypt,
 608                 .decrypt                = rk_des3_ede_cbc_decrypt,
 609         },
 610         .alg.skcipher.op = {
 611                 .do_one_request = rk_cipher_run,
 612         },
 613 };