rk3288_crypto_skcipher.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536
  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. #include <linux/device.h>
  12. #include "rk3288_crypto.h"
  13. #define RK_CRYPTO_DEC BIT(0)
  14. static void rk_crypto_complete(struct crypto_async_request *base, int err)
  15. {
  16. if (base->complete)
  17. base->complete(base, err);
  18. }
  19. static int rk_handle_req(struct rk_crypto_info *dev,
  20. struct skcipher_request *req)
  21. {
  22. if (!IS_ALIGNED(req->cryptlen, dev->align_size))
  23. return -EINVAL;
  24. else
  25. return dev->enqueue(dev, &req->base);
  26. }
  27. static int rk_aes_setkey(struct crypto_skcipher *cipher,
  28. const u8 *key, unsigned int keylen)
  29. {
  30. struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);
  31. struct rk_cipher_ctx *ctx = crypto_tfm_ctx(tfm);
  32. if (keylen != AES_KEYSIZE_128 && keylen != AES_KEYSIZE_192 &&
  33. keylen != AES_KEYSIZE_256)
  34. return -EINVAL;
  35. ctx->keylen = keylen;
  36. memcpy_toio(ctx->dev->reg + RK_CRYPTO_AES_KEY_0, key, keylen);
  37. return 0;
  38. }
  39. static int rk_des_setkey(struct crypto_skcipher *cipher,
  40. const u8 *key, unsigned int keylen)
  41. {
  42. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(cipher);
  43. int err;
  44. err = verify_skcipher_des_key(cipher, key);
  45. if (err)
  46. return err;
  47. ctx->keylen = keylen;
  48. memcpy_toio(ctx->dev->reg + RK_CRYPTO_TDES_KEY1_0, key, keylen);
  49. return 0;
  50. }
  51. static int rk_tdes_setkey(struct crypto_skcipher *cipher,
  52. const u8 *key, unsigned int keylen)
  53. {
  54. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(cipher);
  55. int err;
  56. err = verify_skcipher_des3_key(cipher, key);
  57. if (err)
  58. return err;
  59. ctx->keylen = keylen;
  60. memcpy_toio(ctx->dev->reg + RK_CRYPTO_TDES_KEY1_0, key, keylen);
  61. return 0;
  62. }
  63. static int rk_aes_ecb_encrypt(struct skcipher_request *req)
  64. {
  65. struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  66. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  67. struct rk_crypto_info *dev = ctx->dev;
  68. ctx->mode = RK_CRYPTO_AES_ECB_MODE;
  69. return rk_handle_req(dev, req);
  70. }
  71. static int rk_aes_ecb_decrypt(struct skcipher_request *req)
  72. {
  73. struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  74. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  75. struct rk_crypto_info *dev = ctx->dev;
  76. ctx->mode = RK_CRYPTO_AES_ECB_MODE | RK_CRYPTO_DEC;
  77. return rk_handle_req(dev, req);
  78. }
  79. static int rk_aes_cbc_encrypt(struct skcipher_request *req)
  80. {
  81. struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  82. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  83. struct rk_crypto_info *dev = ctx->dev;
  84. ctx->mode = RK_CRYPTO_AES_CBC_MODE;
  85. return rk_handle_req(dev, req);
  86. }
  87. static int rk_aes_cbc_decrypt(struct skcipher_request *req)
  88. {
  89. struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  90. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  91. struct rk_crypto_info *dev = ctx->dev;
  92. ctx->mode = RK_CRYPTO_AES_CBC_MODE | RK_CRYPTO_DEC;
  93. return rk_handle_req(dev, req);
  94. }
  95. static int rk_des_ecb_encrypt(struct skcipher_request *req)
  96. {
  97. struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  98. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  99. struct rk_crypto_info *dev = ctx->dev;
  100. ctx->mode = 0;
  101. return rk_handle_req(dev, req);
  102. }
  103. static int rk_des_ecb_decrypt(struct skcipher_request *req)
  104. {
  105. struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  106. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  107. struct rk_crypto_info *dev = ctx->dev;
  108. ctx->mode = RK_CRYPTO_DEC;
  109. return rk_handle_req(dev, req);
  110. }
  111. static int rk_des_cbc_encrypt(struct skcipher_request *req)
  112. {
  113. struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  114. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  115. struct rk_crypto_info *dev = ctx->dev;
  116. ctx->mode = RK_CRYPTO_TDES_CHAINMODE_CBC;
  117. return rk_handle_req(dev, req);
  118. }
  119. static int rk_des_cbc_decrypt(struct skcipher_request *req)
  120. {
  121. struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  122. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  123. struct rk_crypto_info *dev = ctx->dev;
  124. ctx->mode = RK_CRYPTO_TDES_CHAINMODE_CBC | RK_CRYPTO_DEC;
  125. return rk_handle_req(dev, req);
  126. }
  127. static int rk_des3_ede_ecb_encrypt(struct skcipher_request *req)
  128. {
  129. struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  130. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  131. struct rk_crypto_info *dev = ctx->dev;
  132. ctx->mode = RK_CRYPTO_TDES_SELECT;
  133. return rk_handle_req(dev, req);
  134. }
  135. static int rk_des3_ede_ecb_decrypt(struct skcipher_request *req)
  136. {
  137. struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  138. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  139. struct rk_crypto_info *dev = ctx->dev;
  140. ctx->mode = RK_CRYPTO_TDES_SELECT | RK_CRYPTO_DEC;
  141. return rk_handle_req(dev, req);
  142. }
  143. static int rk_des3_ede_cbc_encrypt(struct skcipher_request *req)
  144. {
  145. struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  146. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  147. struct rk_crypto_info *dev = ctx->dev;
  148. ctx->mode = RK_CRYPTO_TDES_SELECT | RK_CRYPTO_TDES_CHAINMODE_CBC;
  149. return rk_handle_req(dev, req);
  150. }
  151. static int rk_des3_ede_cbc_decrypt(struct skcipher_request *req)
  152. {
  153. struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  154. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  155. struct rk_crypto_info *dev = ctx->dev;
  156. ctx->mode = RK_CRYPTO_TDES_SELECT | RK_CRYPTO_TDES_CHAINMODE_CBC |
  157. RK_CRYPTO_DEC;
  158. return rk_handle_req(dev, req);
  159. }
  160. static void rk_ablk_hw_init(struct rk_crypto_info *dev)
  161. {
  162. struct skcipher_request *req =
  163. skcipher_request_cast(dev->async_req);
  164. struct crypto_skcipher *cipher = crypto_skcipher_reqtfm(req);
  165. struct crypto_tfm *tfm = crypto_skcipher_tfm(cipher);
  166. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(cipher);
  167. u32 ivsize, block, conf_reg = 0;
  168. block = crypto_tfm_alg_blocksize(tfm);
  169. ivsize = crypto_skcipher_ivsize(cipher);
  170. if (block == DES_BLOCK_SIZE) {
  171. ctx->mode |= RK_CRYPTO_TDES_FIFO_MODE |
  172. RK_CRYPTO_TDES_BYTESWAP_KEY |
  173. RK_CRYPTO_TDES_BYTESWAP_IV;
  174. CRYPTO_WRITE(dev, RK_CRYPTO_TDES_CTRL, ctx->mode);
  175. memcpy_toio(dev->reg + RK_CRYPTO_TDES_IV_0, req->iv, ivsize);
  176. conf_reg = RK_CRYPTO_DESSEL;
  177. } else {
  178. ctx->mode |= RK_CRYPTO_AES_FIFO_MODE |
  179. RK_CRYPTO_AES_KEY_CHANGE |
  180. RK_CRYPTO_AES_BYTESWAP_KEY |
  181. RK_CRYPTO_AES_BYTESWAP_IV;
  182. if (ctx->keylen == AES_KEYSIZE_192)
  183. ctx->mode |= RK_CRYPTO_AES_192BIT_key;
  184. else if (ctx->keylen == AES_KEYSIZE_256)
  185. ctx->mode |= RK_CRYPTO_AES_256BIT_key;
  186. CRYPTO_WRITE(dev, RK_CRYPTO_AES_CTRL, ctx->mode);
  187. memcpy_toio(dev->reg + RK_CRYPTO_AES_IV_0, req->iv, ivsize);
  188. }
  189. conf_reg |= RK_CRYPTO_BYTESWAP_BTFIFO |
  190. RK_CRYPTO_BYTESWAP_BRFIFO;
  191. CRYPTO_WRITE(dev, RK_CRYPTO_CONF, conf_reg);
  192. CRYPTO_WRITE(dev, RK_CRYPTO_INTENA,
  193. RK_CRYPTO_BCDMA_ERR_ENA | RK_CRYPTO_BCDMA_DONE_ENA);
  194. }
  195. static void crypto_dma_start(struct rk_crypto_info *dev)
  196. {
  197. CRYPTO_WRITE(dev, RK_CRYPTO_BRDMAS, dev->addr_in);
  198. CRYPTO_WRITE(dev, RK_CRYPTO_BRDMAL, dev->count / 4);
  199. CRYPTO_WRITE(dev, RK_CRYPTO_BTDMAS, dev->addr_out);
  200. CRYPTO_WRITE(dev, RK_CRYPTO_CTRL, RK_CRYPTO_BLOCK_START |
  201. _SBF(RK_CRYPTO_BLOCK_START, 16));
  202. }
  203. static int rk_set_data_start(struct rk_crypto_info *dev)
  204. {
  205. int err;
  206. struct skcipher_request *req =
  207. skcipher_request_cast(dev->async_req);
  208. struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  209. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  210. u32 ivsize = crypto_skcipher_ivsize(tfm);
  211. u8 *src_last_blk = page_address(sg_page(dev->sg_src)) +
  212. dev->sg_src->offset + dev->sg_src->length - ivsize;
  213. /* Store the iv that need to be updated in chain mode.
  214. * And update the IV buffer to contain the next IV for decryption mode.
  215. */
  216. if (ctx->mode & RK_CRYPTO_DEC) {
  217. memcpy(ctx->iv, src_last_blk, ivsize);
  218. sg_pcopy_to_buffer(dev->first, dev->src_nents, req->iv,
  219. ivsize, dev->total - ivsize);
  220. }
  221. err = dev->load_data(dev, dev->sg_src, dev->sg_dst);
  222. if (!err)
  223. crypto_dma_start(dev);
  224. return err;
  225. }
  226. static int rk_ablk_start(struct rk_crypto_info *dev)
  227. {
  228. struct skcipher_request *req =
  229. skcipher_request_cast(dev->async_req);
  230. unsigned long flags;
  231. int err = 0;
  232. dev->left_bytes = req->cryptlen;
  233. dev->total = req->cryptlen;
  234. dev->sg_src = req->src;
  235. dev->first = req->src;
  236. dev->src_nents = sg_nents(req->src);
  237. dev->sg_dst = req->dst;
  238. dev->dst_nents = sg_nents(req->dst);
  239. dev->aligned = 1;
  240. spin_lock_irqsave(&dev->lock, flags);
  241. rk_ablk_hw_init(dev);
  242. err = rk_set_data_start(dev);
  243. spin_unlock_irqrestore(&dev->lock, flags);
  244. return err;
  245. }
  246. static void rk_iv_copyback(struct rk_crypto_info *dev)
  247. {
  248. struct skcipher_request *req =
  249. skcipher_request_cast(dev->async_req);
  250. struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  251. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  252. u32 ivsize = crypto_skcipher_ivsize(tfm);
  253. /* Update the IV buffer to contain the next IV for encryption mode. */
  254. if (!(ctx->mode & RK_CRYPTO_DEC)) {
  255. if (dev->aligned) {
  256. memcpy(req->iv, sg_virt(dev->sg_dst) +
  257. dev->sg_dst->length - ivsize, ivsize);
  258. } else {
  259. memcpy(req->iv, dev->addr_vir +
  260. dev->count - ivsize, ivsize);
  261. }
  262. }
  263. }
  264. static void rk_update_iv(struct rk_crypto_info *dev)
  265. {
  266. struct skcipher_request *req =
  267. skcipher_request_cast(dev->async_req);
  268. struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  269. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  270. u32 ivsize = crypto_skcipher_ivsize(tfm);
  271. u8 *new_iv = NULL;
  272. if (ctx->mode & RK_CRYPTO_DEC) {
  273. new_iv = ctx->iv;
  274. } else {
  275. new_iv = page_address(sg_page(dev->sg_dst)) +
  276. dev->sg_dst->offset + dev->sg_dst->length - ivsize;
  277. }
  278. if (ivsize == DES_BLOCK_SIZE)
  279. memcpy_toio(dev->reg + RK_CRYPTO_TDES_IV_0, new_iv, ivsize);
  280. else if (ivsize == AES_BLOCK_SIZE)
  281. memcpy_toio(dev->reg + RK_CRYPTO_AES_IV_0, new_iv, ivsize);
  282. }
  283. /* return:
  284. * true some err was occurred
  285. * fault no err, continue
  286. */
  287. static int rk_ablk_rx(struct rk_crypto_info *dev)
  288. {
  289. int err = 0;
  290. struct skcipher_request *req =
  291. skcipher_request_cast(dev->async_req);
  292. dev->unload_data(dev);
  293. if (!dev->aligned) {
  294. if (!sg_pcopy_from_buffer(req->dst, dev->dst_nents,
  295. dev->addr_vir, dev->count,
  296. dev->total - dev->left_bytes -
  297. dev->count)) {
  298. err = -EINVAL;
  299. goto out_rx;
  300. }
  301. }
  302. if (dev->left_bytes) {
  303. rk_update_iv(dev);
  304. if (dev->aligned) {
  305. if (sg_is_last(dev->sg_src)) {
  306. dev_err(dev->dev, "[%s:%d] Lack of data\n",
  307. __func__, __LINE__);
  308. err = -ENOMEM;
  309. goto out_rx;
  310. }
  311. dev->sg_src = sg_next(dev->sg_src);
  312. dev->sg_dst = sg_next(dev->sg_dst);
  313. }
  314. err = rk_set_data_start(dev);
  315. } else {
  316. rk_iv_copyback(dev);
  317. /* here show the calculation is over without any err */
  318. dev->complete(dev->async_req, 0);
  319. tasklet_schedule(&dev->queue_task);
  320. }
  321. out_rx:
  322. return err;
  323. }
  324. static int rk_ablk_init_tfm(struct crypto_skcipher *tfm)
  325. {
  326. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  327. struct skcipher_alg *alg = crypto_skcipher_alg(tfm);
  328. struct rk_crypto_tmp *algt;
  329. algt = container_of(alg, struct rk_crypto_tmp, alg.skcipher);
  330. ctx->dev = algt->dev;
  331. ctx->dev->align_size = crypto_tfm_alg_alignmask(crypto_skcipher_tfm(tfm)) + 1;
  332. ctx->dev->start = rk_ablk_start;
  333. ctx->dev->update = rk_ablk_rx;
  334. ctx->dev->complete = rk_crypto_complete;
  335. ctx->dev->addr_vir = (char *)__get_free_page(GFP_KERNEL);
  336. return ctx->dev->addr_vir ? ctx->dev->enable_clk(ctx->dev) : -ENOMEM;
  337. }
  338. static void rk_ablk_exit_tfm(struct crypto_skcipher *tfm)
  339. {
  340. struct rk_cipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  341. free_page((unsigned long)ctx->dev->addr_vir);
  342. ctx->dev->disable_clk(ctx->dev);
  343. }
  344. struct rk_crypto_tmp rk_ecb_aes_alg = {
  345. .type = ALG_TYPE_CIPHER,
  346. .alg.skcipher = {
  347. .base.cra_name = "ecb(aes)",
  348. .base.cra_driver_name = "ecb-aes-rk",
  349. .base.cra_priority = 300,
  350. .base.cra_flags = CRYPTO_ALG_ASYNC,
  351. .base.cra_blocksize = AES_BLOCK_SIZE,
  352. .base.cra_ctxsize = sizeof(struct rk_cipher_ctx),
  353. .base.cra_alignmask = 0x0f,
  354. .base.cra_module = THIS_MODULE,
  355. .init = rk_ablk_init_tfm,
  356. .exit = rk_ablk_exit_tfm,
  357. .min_keysize = AES_MIN_KEY_SIZE,
  358. .max_keysize = AES_MAX_KEY_SIZE,
  359. .setkey = rk_aes_setkey,
  360. .encrypt = rk_aes_ecb_encrypt,
  361. .decrypt = rk_aes_ecb_decrypt,
  362. }
  363. };
  364. struct rk_crypto_tmp rk_cbc_aes_alg = {
  365. .type = ALG_TYPE_CIPHER,
  366. .alg.skcipher = {
  367. .base.cra_name = "cbc(aes)",
  368. .base.cra_driver_name = "cbc-aes-rk",
  369. .base.cra_priority = 300,
  370. .base.cra_flags = CRYPTO_ALG_ASYNC,
  371. .base.cra_blocksize = AES_BLOCK_SIZE,
  372. .base.cra_ctxsize = sizeof(struct rk_cipher_ctx),
  373. .base.cra_alignmask = 0x0f,
  374. .base.cra_module = THIS_MODULE,
  375. .init = rk_ablk_init_tfm,
  376. .exit = rk_ablk_exit_tfm,
  377. .min_keysize = AES_MIN_KEY_SIZE,
  378. .max_keysize = AES_MAX_KEY_SIZE,
  379. .ivsize = AES_BLOCK_SIZE,
  380. .setkey = rk_aes_setkey,
  381. .encrypt = rk_aes_cbc_encrypt,
  382. .decrypt = rk_aes_cbc_decrypt,
  383. }
  384. };
  385. struct rk_crypto_tmp rk_ecb_des_alg = {
  386. .type = ALG_TYPE_CIPHER,
  387. .alg.skcipher = {
  388. .base.cra_name = "ecb(des)",
  389. .base.cra_driver_name = "ecb-des-rk",
  390. .base.cra_priority = 300,
  391. .base.cra_flags = CRYPTO_ALG_ASYNC,
  392. .base.cra_blocksize = DES_BLOCK_SIZE,
  393. .base.cra_ctxsize = sizeof(struct rk_cipher_ctx),
  394. .base.cra_alignmask = 0x07,
  395. .base.cra_module = THIS_MODULE,
  396. .init = rk_ablk_init_tfm,
  397. .exit = rk_ablk_exit_tfm,
  398. .min_keysize = DES_KEY_SIZE,
  399. .max_keysize = DES_KEY_SIZE,
  400. .setkey = rk_des_setkey,
  401. .encrypt = rk_des_ecb_encrypt,
  402. .decrypt = rk_des_ecb_decrypt,
  403. }
  404. };
  405. struct rk_crypto_tmp rk_cbc_des_alg = {
  406. .type = ALG_TYPE_CIPHER,
  407. .alg.skcipher = {
  408. .base.cra_name = "cbc(des)",
  409. .base.cra_driver_name = "cbc-des-rk",
  410. .base.cra_priority = 300,
  411. .base.cra_flags = CRYPTO_ALG_ASYNC,
  412. .base.cra_blocksize = DES_BLOCK_SIZE,
  413. .base.cra_ctxsize = sizeof(struct rk_cipher_ctx),
  414. .base.cra_alignmask = 0x07,
  415. .base.cra_module = THIS_MODULE,
  416. .init = rk_ablk_init_tfm,
  417. .exit = rk_ablk_exit_tfm,
  418. .min_keysize = DES_KEY_SIZE,
  419. .max_keysize = DES_KEY_SIZE,
  420. .ivsize = DES_BLOCK_SIZE,
  421. .setkey = rk_des_setkey,
  422. .encrypt = rk_des_cbc_encrypt,
  423. .decrypt = rk_des_cbc_decrypt,
  424. }
  425. };
  426. struct rk_crypto_tmp rk_ecb_des3_ede_alg = {
  427. .type = ALG_TYPE_CIPHER,
  428. .alg.skcipher = {
  429. .base.cra_name = "ecb(des3_ede)",
  430. .base.cra_driver_name = "ecb-des3-ede-rk",
  431. .base.cra_priority = 300,
  432. .base.cra_flags = CRYPTO_ALG_ASYNC,
  433. .base.cra_blocksize = DES_BLOCK_SIZE,
  434. .base.cra_ctxsize = sizeof(struct rk_cipher_ctx),
  435. .base.cra_alignmask = 0x07,
  436. .base.cra_module = THIS_MODULE,
  437. .init = rk_ablk_init_tfm,
  438. .exit = rk_ablk_exit_tfm,
  439. .min_keysize = DES3_EDE_KEY_SIZE,
  440. .max_keysize = DES3_EDE_KEY_SIZE,
  441. .setkey = rk_tdes_setkey,
  442. .encrypt = rk_des3_ede_ecb_encrypt,
  443. .decrypt = rk_des3_ede_ecb_decrypt,
  444. }
  445. };
  446. struct rk_crypto_tmp rk_cbc_des3_ede_alg = {
  447. .type = ALG_TYPE_CIPHER,
  448. .alg.skcipher = {
  449. .base.cra_name = "cbc(des3_ede)",
  450. .base.cra_driver_name = "cbc-des3-ede-rk",
  451. .base.cra_priority = 300,
  452. .base.cra_flags = CRYPTO_ALG_ASYNC,
  453. .base.cra_blocksize = DES_BLOCK_SIZE,
  454. .base.cra_ctxsize = sizeof(struct rk_cipher_ctx),
  455. .base.cra_alignmask = 0x07,
  456. .base.cra_module = THIS_MODULE,
  457. .init = rk_ablk_init_tfm,
  458. .exit = rk_ablk_exit_tfm,
  459. .min_keysize = DES3_EDE_KEY_SIZE,
  460. .max_keysize = DES3_EDE_KEY_SIZE,
  461. .ivsize = DES_BLOCK_SIZE,
  462. .setkey = rk_tdes_setkey,
  463. .encrypt = rk_des3_ede_cbc_encrypt,
  464. .decrypt = rk_des3_ede_cbc_decrypt,
  465. }
  466. };