1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Cryptographic API. 4 * 5 * Support for SAHARA cryptographic accelerator. 6 * 7 * Copyright (c) 2014 Steffen Trumtrar <s.trumtrar@pengutronix.de> 8 * Copyright (c) 2013 Vista Silicon S.L. 9 * Author: Javier Martin <javier.martin@vista-silicon.com> 10 * 11 * Based on omap-aes.c and tegra-aes.c 12 */ 13 14 #include <crypto/aes.h> 15 #include <crypto/internal/hash.h> 16 #include <crypto/internal/skcipher.h> 17 #include <crypto/scatterwalk.h> 18 #include <crypto/sha.h> 19 20 #include <linux/clk.h> 21 #include <linux/crypto.h> 22 #include <linux/interrupt.h> 23 #include <linux/io.h> 24 #include <linux/irq.h> 25 #include <linux/kernel.h> 26 #include <linux/kthread.h> 27 #include <linux/module.h> 28 #include <linux/mutex.h> 29 #include <linux/of.h> 30 #include <linux/of_device.h> 31 #include <linux/platform_device.h> 32 33 #define SHA_BUFFER_LEN PAGE_SIZE 34 #define SAHARA_MAX_SHA_BLOCK_SIZE SHA256_BLOCK_SIZE 35 36 #define SAHARA_NAME "sahara" 37 #define SAHARA_VERSION_3 3 38 #define SAHARA_VERSION_4 4 39 #define SAHARA_TIMEOUT_MS 1000 40 #define SAHARA_MAX_HW_DESC 2 41 #define SAHARA_MAX_HW_LINK 20 42 43 #define FLAGS_MODE_MASK 0x000f 44 #define FLAGS_ENCRYPT BIT(0) 45 #define FLAGS_CBC BIT(1) 46 #define FLAGS_NEW_KEY BIT(3) 47 48 #define SAHARA_HDR_BASE 0x00800000 49 #define SAHARA_HDR_SKHA_ALG_AES 0 50 #define SAHARA_HDR_SKHA_OP_ENC (1 << 2) 51 #define SAHARA_HDR_SKHA_MODE_ECB (0 << 3) 52 #define SAHARA_HDR_SKHA_MODE_CBC (1 << 3) 53 #define SAHARA_HDR_FORM_DATA (5 << 16) 54 #define SAHARA_HDR_FORM_KEY (8 << 16) 55 #define SAHARA_HDR_LLO (1 << 24) 56 #define SAHARA_HDR_CHA_SKHA (1 << 28) 57 #define SAHARA_HDR_CHA_MDHA (2 << 28) 58 #define SAHARA_HDR_PARITY_BIT (1 << 31) 59 60 #define SAHARA_HDR_MDHA_SET_MODE_MD_KEY 0x20880000 61 #define SAHARA_HDR_MDHA_SET_MODE_HASH 0x208D0000 62 #define SAHARA_HDR_MDHA_HASH 0xA0850000 63 #define SAHARA_HDR_MDHA_STORE_DIGEST 0x20820000 64 #define SAHARA_HDR_MDHA_ALG_SHA1 0 65 #define SAHARA_HDR_MDHA_ALG_MD5 1 66 #define SAHARA_HDR_MDHA_ALG_SHA256 2 67 #define SAHARA_HDR_MDHA_ALG_SHA224 3 68 #define SAHARA_HDR_MDHA_PDATA (1 << 2) 69 #define SAHARA_HDR_MDHA_HMAC (1 << 3) 70 #define SAHARA_HDR_MDHA_INIT (1 << 5) 71 #define SAHARA_HDR_MDHA_IPAD (1 << 6) 72 #define SAHARA_HDR_MDHA_OPAD (1 << 7) 73 #define SAHARA_HDR_MDHA_SWAP (1 << 8) 74 #define SAHARA_HDR_MDHA_MAC_FULL (1 << 9) 75 #define SAHARA_HDR_MDHA_SSL (1 << 10) 76 77 /* SAHARA can only process one request at a time */ 78 #define SAHARA_QUEUE_LENGTH 1 79 80 #define SAHARA_REG_VERSION 0x00 81 #define SAHARA_REG_DAR 0x04 82 #define SAHARA_REG_CONTROL 0x08 83 #define SAHARA_CONTROL_SET_THROTTLE(x) (((x) & 0xff) << 24) 84 #define SAHARA_CONTROL_SET_MAXBURST(x) (((x) & 0xff) << 16) 85 #define SAHARA_CONTROL_RNG_AUTORSD (1 << 7) 86 #define SAHARA_CONTROL_ENABLE_INT (1 << 4) 87 #define SAHARA_REG_CMD 0x0C 88 #define SAHARA_CMD_RESET (1 << 0) 89 #define SAHARA_CMD_CLEAR_INT (1 << 8) 90 #define SAHARA_CMD_CLEAR_ERR (1 << 9) 91 #define SAHARA_CMD_SINGLE_STEP (1 << 10) 92 #define SAHARA_CMD_MODE_BATCH (1 << 16) 93 #define SAHARA_CMD_MODE_DEBUG (1 << 18) 94 #define SAHARA_REG_STATUS 0x10 95 #define SAHARA_STATUS_GET_STATE(x) ((x) & 0x7) 96 #define SAHARA_STATE_IDLE 0 97 #define SAHARA_STATE_BUSY 1 98 #define SAHARA_STATE_ERR 2 99 #define SAHARA_STATE_FAULT 3 100 #define SAHARA_STATE_COMPLETE 4 101 #define SAHARA_STATE_COMP_FLAG (1 << 2) 102 #define SAHARA_STATUS_DAR_FULL (1 << 3) 103 #define SAHARA_STATUS_ERROR (1 << 4) 104 #define SAHARA_STATUS_SECURE (1 << 5) 105 #define SAHARA_STATUS_FAIL (1 << 6) 106 #define SAHARA_STATUS_INIT (1 << 7) 107 #define SAHARA_STATUS_RNG_RESEED (1 << 8) 108 #define SAHARA_STATUS_ACTIVE_RNG (1 << 9) 109 #define SAHARA_STATUS_ACTIVE_MDHA (1 << 10) 110 #define SAHARA_STATUS_ACTIVE_SKHA (1 << 11) 111 #define SAHARA_STATUS_MODE_BATCH (1 << 16) 112 #define SAHARA_STATUS_MODE_DEDICATED (1 << 17) 113 #define SAHARA_STATUS_MODE_DEBUG (1 << 18) 114 #define SAHARA_STATUS_GET_ISTATE(x) (((x) >> 24) & 0xff) 115 #define SAHARA_REG_ERRSTATUS 0x14 116 #define SAHARA_ERRSTATUS_GET_SOURCE(x) ((x) & 0xf) 117 #define SAHARA_ERRSOURCE_CHA 14 118 #define SAHARA_ERRSOURCE_DMA 15 119 #define SAHARA_ERRSTATUS_DMA_DIR (1 << 8) 120 #define SAHARA_ERRSTATUS_GET_DMASZ(x)(((x) >> 9) & 0x3) 121 #define SAHARA_ERRSTATUS_GET_DMASRC(x) (((x) >> 13) & 0x7) 122 #define SAHARA_ERRSTATUS_GET_CHASRC(x) (((x) >> 16) & 0xfff) 123 #define SAHARA_ERRSTATUS_GET_CHAERR(x) (((x) >> 28) & 0x3) 124 #define SAHARA_REG_FADDR 0x18 125 #define SAHARA_REG_CDAR 0x1C 126 #define SAHARA_REG_IDAR 0x20 127 128 struct sahara_hw_desc { 129 u32 hdr; 130 u32 len1; 131 u32 p1; 132 u32 len2; 133 u32 p2; 134 u32 next; 135 }; 136 137 struct sahara_hw_link { 138 u32 len; 139 u32 p; 140 u32 next; 141 }; 142 143 struct sahara_ctx { 144 unsigned long flags; 145 146 /* AES-specific context */ 147 int keylen; 148 u8 key[AES_KEYSIZE_128]; 149 struct crypto_sync_skcipher *fallback; 150 }; 151 152 struct sahara_aes_reqctx { 153 unsigned long mode; 154 }; 155 156 /* 157 * struct sahara_sha_reqctx - private data per request 158 * @buf: holds data for requests smaller than block_size 159 * @rembuf: used to prepare one block_size-aligned request 160 * @context: hw-specific context for request. Digest is extracted from this 161 * @mode: specifies what type of hw-descriptor needs to be built 162 * @digest_size: length of digest for this request 163 * @context_size: length of hw-context for this request. 164 * Always digest_size + 4 165 * @buf_cnt: number of bytes saved in buf 166 * @sg_in_idx: number of hw links 167 * @in_sg: scatterlist for input data 168 * @in_sg_chain: scatterlists for chained input data 169 * @total: total number of bytes for transfer 170 * @last: is this the last block 171 * @first: is this the first block 172 * @active: inside a transfer 173 */ 174 struct sahara_sha_reqctx { 175 u8 buf[SAHARA_MAX_SHA_BLOCK_SIZE]; 176 u8 rembuf[SAHARA_MAX_SHA_BLOCK_SIZE]; 177 u8 context[SHA256_DIGEST_SIZE + 4]; 178 unsigned int mode; 179 unsigned int digest_size; 180 unsigned int context_size; 181 unsigned int buf_cnt; 182 unsigned int sg_in_idx; 183 struct scatterlist *in_sg; 184 struct scatterlist in_sg_chain[2]; 185 size_t total; 186 unsigned int last; 187 unsigned int first; 188 unsigned int active; 189 }; 190 191 struct sahara_dev { 192 struct device *device; 193 unsigned int version; 194 void __iomem *regs_base; 195 struct clk *clk_ipg; 196 struct clk *clk_ahb; 197 struct mutex queue_mutex; 198 struct task_struct *kthread; 199 struct completion dma_completion; 200 201 struct sahara_ctx *ctx; 202 struct crypto_queue queue; 203 unsigned long flags; 204 205 struct sahara_hw_desc *hw_desc[SAHARA_MAX_HW_DESC]; 206 dma_addr_t hw_phys_desc[SAHARA_MAX_HW_DESC]; 207 208 u8 *key_base; 209 dma_addr_t key_phys_base; 210 211 u8 *iv_base; 212 dma_addr_t iv_phys_base; 213 214 u8 *context_base; 215 dma_addr_t context_phys_base; 216 217 struct sahara_hw_link *hw_link[SAHARA_MAX_HW_LINK]; 218 dma_addr_t hw_phys_link[SAHARA_MAX_HW_LINK]; 219 220 size_t total; 221 struct scatterlist *in_sg; 222 int nb_in_sg; 223 struct scatterlist *out_sg; 224 int nb_out_sg; 225 226 u32 error; 227 }; 228 229 static struct sahara_dev *dev_ptr; 230 231 static inline void sahara_write(struct sahara_dev *dev, u32 data, u32 reg) 232 { 233 writel(data, dev->regs_base + reg); 234 } 235 236 static inline unsigned int sahara_read(struct sahara_dev *dev, u32 reg) 237 { 238 return readl(dev->regs_base + reg); 239 } 240 241 static u32 sahara_aes_key_hdr(struct sahara_dev *dev) 242 { 243 u32 hdr = SAHARA_HDR_BASE | SAHARA_HDR_SKHA_ALG_AES | 244 SAHARA_HDR_FORM_KEY | SAHARA_HDR_LLO | 245 SAHARA_HDR_CHA_SKHA | SAHARA_HDR_PARITY_BIT; 246 247 if (dev->flags & FLAGS_CBC) { 248 hdr |= SAHARA_HDR_SKHA_MODE_CBC; 249 hdr ^= SAHARA_HDR_PARITY_BIT; 250 } 251 252 if (dev->flags & FLAGS_ENCRYPT) { 253 hdr |= SAHARA_HDR_SKHA_OP_ENC; 254 hdr ^= SAHARA_HDR_PARITY_BIT; 255 } 256 257 return hdr; 258 } 259 260 static u32 sahara_aes_data_link_hdr(struct sahara_dev *dev) 261 { 262 return SAHARA_HDR_BASE | SAHARA_HDR_FORM_DATA | 263 SAHARA_HDR_CHA_SKHA | SAHARA_HDR_PARITY_BIT; 264 } 265 266 static const char *sahara_err_src[16] = { 267 "No error", 268 "Header error", 269 "Descriptor length error", 270 "Descriptor length or pointer error", 271 "Link length error", 272 "Link pointer error", 273 "Input buffer error", 274 "Output buffer error", 275 "Output buffer starvation", 276 "Internal state fault", 277 "General descriptor problem", 278 "Reserved", 279 "Descriptor address error", 280 "Link address error", 281 "CHA error", 282 "DMA error" 283 }; 284 285 static const char *sahara_err_dmasize[4] = { 286 "Byte transfer", 287 "Half-word transfer", 288 "Word transfer", 289 "Reserved" 290 }; 291 292 static const char *sahara_err_dmasrc[8] = { 293 "No error", 294 "AHB bus error", 295 "Internal IP bus error", 296 "Parity error", 297 "DMA crosses 256 byte boundary", 298 "DMA is busy", 299 "Reserved", 300 "DMA HW error" 301 }; 302 303 static const char *sahara_cha_errsrc[12] = { 304 "Input buffer non-empty", 305 "Illegal address", 306 "Illegal mode", 307 "Illegal data size", 308 "Illegal key size", 309 "Write during processing", 310 "CTX read during processing", 311 "HW error", 312 "Input buffer disabled/underflow", 313 "Output buffer disabled/overflow", 314 "DES key parity error", 315 "Reserved" 316 }; 317 318 static const char *sahara_cha_err[4] = { "No error", "SKHA", "MDHA", "RNG" }; 319 320 static void sahara_decode_error(struct sahara_dev *dev, unsigned int error) 321 { 322 u8 source = SAHARA_ERRSTATUS_GET_SOURCE(error); 323 u16 chasrc = ffs(SAHARA_ERRSTATUS_GET_CHASRC(error)); 324 325 dev_err(dev->device, "%s: Error Register = 0x%08x\n", __func__, error); 326 327 dev_err(dev->device, " - %s.\n", sahara_err_src[source]); 328 329 if (source == SAHARA_ERRSOURCE_DMA) { 330 if (error & SAHARA_ERRSTATUS_DMA_DIR) 331 dev_err(dev->device, " * DMA read.\n"); 332 else 333 dev_err(dev->device, " * DMA write.\n"); 334 335 dev_err(dev->device, " * %s.\n", 336 sahara_err_dmasize[SAHARA_ERRSTATUS_GET_DMASZ(error)]); 337 dev_err(dev->device, " * %s.\n", 338 sahara_err_dmasrc[SAHARA_ERRSTATUS_GET_DMASRC(error)]); 339 } else if (source == SAHARA_ERRSOURCE_CHA) { 340 dev_err(dev->device, " * %s.\n", 341 sahara_cha_errsrc[chasrc]); 342 dev_err(dev->device, " * %s.\n", 343 sahara_cha_err[SAHARA_ERRSTATUS_GET_CHAERR(error)]); 344 } 345 dev_err(dev->device, "\n"); 346 } 347 348 static const char *sahara_state[4] = { "Idle", "Busy", "Error", "HW Fault" }; 349 350 static void sahara_decode_status(struct sahara_dev *dev, unsigned int status) 351 { 352 u8 state; 353 354 if (!__is_defined(DEBUG)) 355 return; 356 357 state = SAHARA_STATUS_GET_STATE(status); 358 359 dev_dbg(dev->device, "%s: Status Register = 0x%08x\n", 360 __func__, status); 361 362 dev_dbg(dev->device, " - State = %d:\n", state); 363 if (state & SAHARA_STATE_COMP_FLAG) 364 dev_dbg(dev->device, " * Descriptor completed. IRQ pending.\n"); 365 366 dev_dbg(dev->device, " * %s.\n", 367 sahara_state[state & ~SAHARA_STATE_COMP_FLAG]); 368 369 if (status & SAHARA_STATUS_DAR_FULL) 370 dev_dbg(dev->device, " - DAR Full.\n"); 371 if (status & SAHARA_STATUS_ERROR) 372 dev_dbg(dev->device, " - Error.\n"); 373 if (status & SAHARA_STATUS_SECURE) 374 dev_dbg(dev->device, " - Secure.\n"); 375 if (status & SAHARA_STATUS_FAIL) 376 dev_dbg(dev->device, " - Fail.\n"); 377 if (status & SAHARA_STATUS_RNG_RESEED) 378 dev_dbg(dev->device, " - RNG Reseed Request.\n"); 379 if (status & SAHARA_STATUS_ACTIVE_RNG) 380 dev_dbg(dev->device, " - RNG Active.\n"); 381 if (status & SAHARA_STATUS_ACTIVE_MDHA) 382 dev_dbg(dev->device, " - MDHA Active.\n"); 383 if (status & SAHARA_STATUS_ACTIVE_SKHA) 384 dev_dbg(dev->device, " - SKHA Active.\n"); 385 386 if (status & SAHARA_STATUS_MODE_BATCH) 387 dev_dbg(dev->device, " - Batch Mode.\n"); 388 else if (status & SAHARA_STATUS_MODE_DEDICATED) 389 dev_dbg(dev->device, " - Dedicated Mode.\n"); 390 else if (status & SAHARA_STATUS_MODE_DEBUG) 391 dev_dbg(dev->device, " - Debug Mode.\n"); 392 393 dev_dbg(dev->device, " - Internal state = 0x%02x\n", 394 SAHARA_STATUS_GET_ISTATE(status)); 395 396 dev_dbg(dev->device, "Current DAR: 0x%08x\n", 397 sahara_read(dev, SAHARA_REG_CDAR)); 398 dev_dbg(dev->device, "Initial DAR: 0x%08x\n\n", 399 sahara_read(dev, SAHARA_REG_IDAR)); 400 } 401 402 static void sahara_dump_descriptors(struct sahara_dev *dev) 403 { 404 int i; 405 406 if (!__is_defined(DEBUG)) 407 return; 408 409 for (i = 0; i < SAHARA_MAX_HW_DESC; i++) { 410 dev_dbg(dev->device, "Descriptor (%d) (%pad):\n", 411 i, &dev->hw_phys_desc[i]); 412 dev_dbg(dev->device, "\thdr = 0x%08x\n", dev->hw_desc[i]->hdr); 413 dev_dbg(dev->device, "\tlen1 = %u\n", dev->hw_desc[i]->len1); 414 dev_dbg(dev->device, "\tp1 = 0x%08x\n", dev->hw_desc[i]->p1); 415 dev_dbg(dev->device, "\tlen2 = %u\n", dev->hw_desc[i]->len2); 416 dev_dbg(dev->device, "\tp2 = 0x%08x\n", dev->hw_desc[i]->p2); 417 dev_dbg(dev->device, "\tnext = 0x%08x\n", 418 dev->hw_desc[i]->next); 419 } 420 dev_dbg(dev->device, "\n"); 421 } 422 423 static void sahara_dump_links(struct sahara_dev *dev) 424 { 425 int i; 426 427 if (!__is_defined(DEBUG)) 428 return; 429 430 for (i = 0; i < SAHARA_MAX_HW_LINK; i++) { 431 dev_dbg(dev->device, "Link (%d) (%pad):\n", 432 i, &dev->hw_phys_link[i]); 433 dev_dbg(dev->device, "\tlen = %u\n", dev->hw_link[i]->len); 434 dev_dbg(dev->device, "\tp = 0x%08x\n", dev->hw_link[i]->p); 435 dev_dbg(dev->device, "\tnext = 0x%08x\n", 436 dev->hw_link[i]->next); 437 } 438 dev_dbg(dev->device, "\n"); 439 } 440 441 static int sahara_hw_descriptor_create(struct sahara_dev *dev) 442 { 443 struct sahara_ctx *ctx = dev->ctx; 444 struct scatterlist *sg; 445 int ret; 446 int i, j; 447 int idx = 0; 448 449 /* Copy new key if necessary */ 450 if (ctx->flags & FLAGS_NEW_KEY) { 451 memcpy(dev->key_base, ctx->key, ctx->keylen); 452 ctx->flags &= ~FLAGS_NEW_KEY; 453 454 if (dev->flags & FLAGS_CBC) { 455 dev->hw_desc[idx]->len1 = AES_BLOCK_SIZE; 456 dev->hw_desc[idx]->p1 = dev->iv_phys_base; 457 } else { 458 dev->hw_desc[idx]->len1 = 0; 459 dev->hw_desc[idx]->p1 = 0; 460 } 461 dev->hw_desc[idx]->len2 = ctx->keylen; 462 dev->hw_desc[idx]->p2 = dev->key_phys_base; 463 dev->hw_desc[idx]->next = dev->hw_phys_desc[1]; 464 465 dev->hw_desc[idx]->hdr = sahara_aes_key_hdr(dev); 466 467 idx++; 468 } 469 470 dev->nb_in_sg = sg_nents_for_len(dev->in_sg, dev->total); 471 if (dev->nb_in_sg < 0) { 472 dev_err(dev->device, "Invalid numbers of src SG.\n"); 473 return dev->nb_in_sg; 474 } 475 dev->nb_out_sg = sg_nents_for_len(dev->out_sg, dev->total); 476 if (dev->nb_out_sg < 0) { 477 dev_err(dev->device, "Invalid numbers of dst SG.\n"); 478 return dev->nb_out_sg; 479 } 480 if ((dev->nb_in_sg + dev->nb_out_sg) > SAHARA_MAX_HW_LINK) { 481 dev_err(dev->device, "not enough hw links (%d)\n", 482 dev->nb_in_sg + dev->nb_out_sg); 483 return -EINVAL; 484 } 485 486 ret = dma_map_sg(dev->device, dev->in_sg, dev->nb_in_sg, 487 DMA_TO_DEVICE); 488 if (ret != dev->nb_in_sg) { 489 dev_err(dev->device, "couldn't map in sg\n"); 490 goto unmap_in; 491 } 492 ret = dma_map_sg(dev->device, dev->out_sg, dev->nb_out_sg, 493 DMA_FROM_DEVICE); 494 if (ret != dev->nb_out_sg) { 495 dev_err(dev->device, "couldn't map out sg\n"); 496 goto unmap_out; 497 } 498 499 /* Create input links */ 500 dev->hw_desc[idx]->p1 = dev->hw_phys_link[0]; 501 sg = dev->in_sg; 502 for (i = 0; i < dev->nb_in_sg; i++) { 503 dev->hw_link[i]->len = sg->length; 504 dev->hw_link[i]->p = sg->dma_address; 505 if (i == (dev->nb_in_sg - 1)) { 506 dev->hw_link[i]->next = 0; 507 } else { 508 dev->hw_link[i]->next = dev->hw_phys_link[i + 1]; 509 sg = sg_next(sg); 510 } 511 } 512 513 /* Create output links */ 514 dev->hw_desc[idx]->p2 = dev->hw_phys_link[i]; 515 sg = dev->out_sg; 516 for (j = i; j < dev->nb_out_sg + i; j++) { 517 dev->hw_link[j]->len = sg->length; 518 dev->hw_link[j]->p = sg->dma_address; 519 if (j == (dev->nb_out_sg + i - 1)) { 520 dev->hw_link[j]->next = 0; 521 } else { 522 dev->hw_link[j]->next = dev->hw_phys_link[j + 1]; 523 sg = sg_next(sg); 524 } 525 } 526 527 /* Fill remaining fields of hw_desc[1] */ 528 dev->hw_desc[idx]->hdr = sahara_aes_data_link_hdr(dev); 529 dev->hw_desc[idx]->len1 = dev->total; 530 dev->hw_desc[idx]->len2 = dev->total; 531 dev->hw_desc[idx]->next = 0; 532 533 sahara_dump_descriptors(dev); 534 sahara_dump_links(dev); 535 536 sahara_write(dev, dev->hw_phys_desc[0], SAHARA_REG_DAR); 537 538 return 0; 539 540 unmap_out: 541 dma_unmap_sg(dev->device, dev->out_sg, dev->nb_out_sg, 542 DMA_FROM_DEVICE); 543 unmap_in: 544 dma_unmap_sg(dev->device, dev->in_sg, dev->nb_in_sg, 545 DMA_TO_DEVICE); 546 547 return -EINVAL; 548 } 549 550 static int sahara_aes_process(struct skcipher_request *req) 551 { 552 struct sahara_dev *dev = dev_ptr; 553 struct sahara_ctx *ctx; 554 struct sahara_aes_reqctx *rctx; 555 int ret; 556 unsigned long timeout; 557 558 /* Request is ready to be dispatched by the device */ 559 dev_dbg(dev->device, 560 "dispatch request (nbytes=%d, src=%p, dst=%p)\n", 561 req->cryptlen, req->src, req->dst); 562 563 /* assign new request to device */ 564 dev->total = req->cryptlen; 565 dev->in_sg = req->src; 566 dev->out_sg = req->dst; 567 568 rctx = skcipher_request_ctx(req); 569 ctx = crypto_skcipher_ctx(crypto_skcipher_reqtfm(req)); 570 rctx->mode &= FLAGS_MODE_MASK; 571 dev->flags = (dev->flags & ~FLAGS_MODE_MASK) | rctx->mode; 572 573 if ((dev->flags & FLAGS_CBC) && req->iv) 574 memcpy(dev->iv_base, req->iv, AES_KEYSIZE_128); 575 576 /* assign new context to device */ 577 dev->ctx = ctx; 578 579 reinit_completion(&dev->dma_completion); 580 581 ret = sahara_hw_descriptor_create(dev); 582 if (ret) 583 return -EINVAL; 584 585 timeout = wait_for_completion_timeout(&dev->dma_completion, 586 msecs_to_jiffies(SAHARA_TIMEOUT_MS)); 587 if (!timeout) { 588 dev_err(dev->device, "AES timeout\n"); 589 return -ETIMEDOUT; 590 } 591 592 dma_unmap_sg(dev->device, dev->out_sg, dev->nb_out_sg, 593 DMA_FROM_DEVICE); 594 dma_unmap_sg(dev->device, dev->in_sg, dev->nb_in_sg, 595 DMA_TO_DEVICE); 596 597 return 0; 598 } 599 600 static int sahara_aes_setkey(struct crypto_skcipher *tfm, const u8 *key, 601 unsigned int keylen) 602 { 603 struct sahara_ctx *ctx = crypto_skcipher_ctx(tfm); 604 605 ctx->keylen = keylen; 606 607 /* SAHARA only supports 128bit keys */ 608 if (keylen == AES_KEYSIZE_128) { 609 memcpy(ctx->key, key, keylen); 610 ctx->flags |= FLAGS_NEW_KEY; 611 return 0; 612 } 613 614 if (keylen != AES_KEYSIZE_192 && keylen != AES_KEYSIZE_256) 615 return -EINVAL; 616 617 /* 618 * The requested key size is not supported by HW, do a fallback. 619 */ 620 crypto_sync_skcipher_clear_flags(ctx->fallback, CRYPTO_TFM_REQ_MASK); 621 crypto_sync_skcipher_set_flags(ctx->fallback, tfm->base.crt_flags & 622 CRYPTO_TFM_REQ_MASK); 623 return crypto_sync_skcipher_setkey(ctx->fallback, key, keylen); 624 } 625 626 static int sahara_aes_crypt(struct skcipher_request *req, unsigned long mode) 627 { 628 struct sahara_aes_reqctx *rctx = skcipher_request_ctx(req); 629 struct sahara_dev *dev = dev_ptr; 630 int err = 0; 631 632 dev_dbg(dev->device, "nbytes: %d, enc: %d, cbc: %d\n", 633 req->cryptlen, !!(mode & FLAGS_ENCRYPT), !!(mode & FLAGS_CBC)); 634 635 if (!IS_ALIGNED(req->cryptlen, AES_BLOCK_SIZE)) { 636 dev_err(dev->device, 637 "request size is not exact amount of AES blocks\n"); 638 return -EINVAL; 639 } 640 641 rctx->mode = mode; 642 643 mutex_lock(&dev->queue_mutex); 644 err = crypto_enqueue_request(&dev->queue, &req->base); 645 mutex_unlock(&dev->queue_mutex); 646 647 wake_up_process(dev->kthread); 648 649 return err; 650 } 651 652 static int sahara_aes_ecb_encrypt(struct skcipher_request *req) 653 { 654 struct sahara_ctx *ctx = crypto_skcipher_ctx( 655 crypto_skcipher_reqtfm(req)); 656 int err; 657 658 if (unlikely(ctx->keylen != AES_KEYSIZE_128)) { 659 SYNC_SKCIPHER_REQUEST_ON_STACK(subreq, ctx->fallback); 660 661 skcipher_request_set_sync_tfm(subreq, ctx->fallback); 662 skcipher_request_set_callback(subreq, req->base.flags, 663 NULL, NULL); 664 skcipher_request_set_crypt(subreq, req->src, req->dst, 665 req->cryptlen, req->iv); 666 err = crypto_skcipher_encrypt(subreq); 667 skcipher_request_zero(subreq); 668 return err; 669 } 670 671 return sahara_aes_crypt(req, FLAGS_ENCRYPT); 672 } 673 674 static int sahara_aes_ecb_decrypt(struct skcipher_request *req) 675 { 676 struct sahara_ctx *ctx = crypto_skcipher_ctx( 677 crypto_skcipher_reqtfm(req)); 678 int err; 679 680 if (unlikely(ctx->keylen != AES_KEYSIZE_128)) { 681 SYNC_SKCIPHER_REQUEST_ON_STACK(subreq, ctx->fallback); 682 683 skcipher_request_set_sync_tfm(subreq, ctx->fallback); 684 skcipher_request_set_callback(subreq, req->base.flags, 685 NULL, NULL); 686 skcipher_request_set_crypt(subreq, req->src, req->dst, 687 req->cryptlen, req->iv); 688 err = crypto_skcipher_decrypt(subreq); 689 skcipher_request_zero(subreq); 690 return err; 691 } 692 693 return sahara_aes_crypt(req, 0); 694 } 695 696 static int sahara_aes_cbc_encrypt(struct skcipher_request *req) 697 { 698 struct sahara_ctx *ctx = crypto_skcipher_ctx( 699 crypto_skcipher_reqtfm(req)); 700 int err; 701 702 if (unlikely(ctx->keylen != AES_KEYSIZE_128)) { 703 SYNC_SKCIPHER_REQUEST_ON_STACK(subreq, ctx->fallback); 704 705 skcipher_request_set_sync_tfm(subreq, ctx->fallback); 706 skcipher_request_set_callback(subreq, req->base.flags, 707 NULL, NULL); 708 skcipher_request_set_crypt(subreq, req->src, req->dst, 709 req->cryptlen, req->iv); 710 err = crypto_skcipher_encrypt(subreq); 711 skcipher_request_zero(subreq); 712 return err; 713 } 714 715 return sahara_aes_crypt(req, FLAGS_ENCRYPT | FLAGS_CBC); 716 } 717 718 static int sahara_aes_cbc_decrypt(struct skcipher_request *req) 719 { 720 struct sahara_ctx *ctx = crypto_skcipher_ctx( 721 crypto_skcipher_reqtfm(req)); 722 int err; 723 724 if (unlikely(ctx->keylen != AES_KEYSIZE_128)) { 725 SYNC_SKCIPHER_REQUEST_ON_STACK(subreq, ctx->fallback); 726 727 skcipher_request_set_sync_tfm(subreq, ctx->fallback); 728 skcipher_request_set_callback(subreq, req->base.flags, 729 NULL, NULL); 730 skcipher_request_set_crypt(subreq, req->src, req->dst, 731 req->cryptlen, req->iv); 732 err = crypto_skcipher_decrypt(subreq); 733 skcipher_request_zero(subreq); 734 return err; 735 } 736 737 return sahara_aes_crypt(req, FLAGS_CBC); 738 } 739 740 static int sahara_aes_init_tfm(struct crypto_skcipher *tfm) 741 { 742 const char *name = crypto_tfm_alg_name(&tfm->base); 743 struct sahara_ctx *ctx = crypto_skcipher_ctx(tfm); 744 745 ctx->fallback = crypto_alloc_sync_skcipher(name, 0, 746 CRYPTO_ALG_NEED_FALLBACK); 747 if (IS_ERR(ctx->fallback)) { 748 pr_err("Error allocating fallback algo %s\n", name); 749 return PTR_ERR(ctx->fallback); 750 } 751 752 crypto_skcipher_set_reqsize(tfm, sizeof(struct sahara_aes_reqctx)); 753 754 return 0; 755 } 756 757 static void sahara_aes_exit_tfm(struct crypto_skcipher *tfm) 758 { 759 struct sahara_ctx *ctx = crypto_skcipher_ctx(tfm); 760 761 crypto_free_sync_skcipher(ctx->fallback); 762 } 763 764 static u32 sahara_sha_init_hdr(struct sahara_dev *dev, 765 struct sahara_sha_reqctx *rctx) 766 { 767 u32 hdr = 0; 768 769 hdr = rctx->mode; 770 771 if (rctx->first) { 772 hdr |= SAHARA_HDR_MDHA_SET_MODE_HASH; 773 hdr |= SAHARA_HDR_MDHA_INIT; 774 } else { 775 hdr |= SAHARA_HDR_MDHA_SET_MODE_MD_KEY; 776 } 777 778 if (rctx->last) 779 hdr |= SAHARA_HDR_MDHA_PDATA; 780 781 if (hweight_long(hdr) % 2 == 0) 782 hdr |= SAHARA_HDR_PARITY_BIT; 783 784 return hdr; 785 } 786 787 static int sahara_sha_hw_links_create(struct sahara_dev *dev, 788 struct sahara_sha_reqctx *rctx, 789 int start) 790 { 791 struct scatterlist *sg; 792 unsigned int i; 793 int ret; 794 795 dev->in_sg = rctx->in_sg; 796 797 dev->nb_in_sg = sg_nents_for_len(dev->in_sg, rctx->total); 798 if (dev->nb_in_sg < 0) { 799 dev_err(dev->device, "Invalid numbers of src SG.\n"); 800 return dev->nb_in_sg; 801 } 802 if ((dev->nb_in_sg) > SAHARA_MAX_HW_LINK) { 803 dev_err(dev->device, "not enough hw links (%d)\n", 804 dev->nb_in_sg + dev->nb_out_sg); 805 return -EINVAL; 806 } 807 808 sg = dev->in_sg; 809 ret = dma_map_sg(dev->device, dev->in_sg, dev->nb_in_sg, DMA_TO_DEVICE); 810 if (!ret) 811 return -EFAULT; 812 813 for (i = start; i < dev->nb_in_sg + start; i++) { 814 dev->hw_link[i]->len = sg->length; 815 dev->hw_link[i]->p = sg->dma_address; 816 if (i == (dev->nb_in_sg + start - 1)) { 817 dev->hw_link[i]->next = 0; 818 } else { 819 dev->hw_link[i]->next = dev->hw_phys_link[i + 1]; 820 sg = sg_next(sg); 821 } 822 } 823 824 return i; 825 } 826 827 static int sahara_sha_hw_data_descriptor_create(struct sahara_dev *dev, 828 struct sahara_sha_reqctx *rctx, 829 struct ahash_request *req, 830 int index) 831 { 832 unsigned result_len; 833 int i = index; 834 835 if (rctx->first) 836 /* Create initial descriptor: #8*/ 837 dev->hw_desc[index]->hdr = sahara_sha_init_hdr(dev, rctx); 838 else 839 /* Create hash descriptor: #10. Must follow #6. */ 840 dev->hw_desc[index]->hdr = SAHARA_HDR_MDHA_HASH; 841 842 dev->hw_desc[index]->len1 = rctx->total; 843 if (dev->hw_desc[index]->len1 == 0) { 844 /* if len1 is 0, p1 must be 0, too */ 845 dev->hw_desc[index]->p1 = 0; 846 rctx->sg_in_idx = 0; 847 } else { 848 /* Create input links */ 849 dev->hw_desc[index]->p1 = dev->hw_phys_link[index]; 850 i = sahara_sha_hw_links_create(dev, rctx, index); 851 852 rctx->sg_in_idx = index; 853 if (i < 0) 854 return i; 855 } 856 857 dev->hw_desc[index]->p2 = dev->hw_phys_link[i]; 858 859 /* Save the context for the next operation */ 860 result_len = rctx->context_size; 861 dev->hw_link[i]->p = dev->context_phys_base; 862 863 dev->hw_link[i]->len = result_len; 864 dev->hw_desc[index]->len2 = result_len; 865 866 dev->hw_link[i]->next = 0; 867 868 return 0; 869 } 870 871 /* 872 * Load descriptor aka #6 873 * 874 * To load a previously saved context back to the MDHA unit 875 * 876 * p1: Saved Context 877 * p2: NULL 878 * 879 */ 880 static int sahara_sha_hw_context_descriptor_create(struct sahara_dev *dev, 881 struct sahara_sha_reqctx *rctx, 882 struct ahash_request *req, 883 int index) 884 { 885 dev->hw_desc[index]->hdr = sahara_sha_init_hdr(dev, rctx); 886 887 dev->hw_desc[index]->len1 = rctx->context_size; 888 dev->hw_desc[index]->p1 = dev->hw_phys_link[index]; 889 dev->hw_desc[index]->len2 = 0; 890 dev->hw_desc[index]->p2 = 0; 891 892 dev->hw_link[index]->len = rctx->context_size; 893 dev->hw_link[index]->p = dev->context_phys_base; 894 dev->hw_link[index]->next = 0; 895 896 return 0; 897 } 898 899 static int sahara_walk_and_recalc(struct scatterlist *sg, unsigned int nbytes) 900 { 901 if (!sg || !sg->length) 902 return nbytes; 903 904 while (nbytes && sg) { 905 if (nbytes <= sg->length) { 906 sg->length = nbytes; 907 sg_mark_end(sg); 908 break; 909 } 910 nbytes -= sg->length; 911 sg = sg_next(sg); 912 } 913 914 return nbytes; 915 } 916 917 static int sahara_sha_prepare_request(struct ahash_request *req) 918 { 919 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 920 struct sahara_sha_reqctx *rctx = ahash_request_ctx(req); 921 unsigned int hash_later; 922 unsigned int block_size; 923 unsigned int len; 924 925 block_size = crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm)); 926 927 /* append bytes from previous operation */ 928 len = rctx->buf_cnt + req->nbytes; 929 930 /* only the last transfer can be padded in hardware */ 931 if (!rctx->last && (len < block_size)) { 932 /* to few data, save for next operation */ 933 scatterwalk_map_and_copy(rctx->buf + rctx->buf_cnt, req->src, 934 0, req->nbytes, 0); 935 rctx->buf_cnt += req->nbytes; 936 937 return 0; 938 } 939 940 /* add data from previous operation first */ 941 if (rctx->buf_cnt) 942 memcpy(rctx->rembuf, rctx->buf, rctx->buf_cnt); 943 944 /* data must always be a multiple of block_size */ 945 hash_later = rctx->last ? 0 : len & (block_size - 1); 946 if (hash_later) { 947 unsigned int offset = req->nbytes - hash_later; 948 /* Save remaining bytes for later use */ 949 scatterwalk_map_and_copy(rctx->buf, req->src, offset, 950 hash_later, 0); 951 } 952 953 /* nbytes should now be multiple of blocksize */ 954 req->nbytes = req->nbytes - hash_later; 955 956 sahara_walk_and_recalc(req->src, req->nbytes); 957 958 /* have data from previous operation and current */ 959 if (rctx->buf_cnt && req->nbytes) { 960 sg_init_table(rctx->in_sg_chain, 2); 961 sg_set_buf(rctx->in_sg_chain, rctx->rembuf, rctx->buf_cnt); 962 963 sg_chain(rctx->in_sg_chain, 2, req->src); 964 965 rctx->total = req->nbytes + rctx->buf_cnt; 966 rctx->in_sg = rctx->in_sg_chain; 967 968 req->src = rctx->in_sg_chain; 969 /* only data from previous operation */ 970 } else if (rctx->buf_cnt) { 971 if (req->src) 972 rctx->in_sg = req->src; 973 else 974 rctx->in_sg = rctx->in_sg_chain; 975 /* buf was copied into rembuf above */ 976 sg_init_one(rctx->in_sg, rctx->rembuf, rctx->buf_cnt); 977 rctx->total = rctx->buf_cnt; 978 /* no data from previous operation */ 979 } else { 980 rctx->in_sg = req->src; 981 rctx->total = req->nbytes; 982 req->src = rctx->in_sg; 983 } 984 985 /* on next call, we only have the remaining data in the buffer */ 986 rctx->buf_cnt = hash_later; 987 988 return -EINPROGRESS; 989 } 990 991 static int sahara_sha_process(struct ahash_request *req) 992 { 993 struct sahara_dev *dev = dev_ptr; 994 struct sahara_sha_reqctx *rctx = ahash_request_ctx(req); 995 int ret; 996 unsigned long timeout; 997 998 ret = sahara_sha_prepare_request(req); 999 if (!ret) 1000 return ret; 1001 1002 if (rctx->first) { 1003 sahara_sha_hw_data_descriptor_create(dev, rctx, req, 0); 1004 dev->hw_desc[0]->next = 0; 1005 rctx->first = 0; 1006 } else { 1007 memcpy(dev->context_base, rctx->context, rctx->context_size); 1008 1009 sahara_sha_hw_context_descriptor_create(dev, rctx, req, 0); 1010 dev->hw_desc[0]->next = dev->hw_phys_desc[1]; 1011 sahara_sha_hw_data_descriptor_create(dev, rctx, req, 1); 1012 dev->hw_desc[1]->next = 0; 1013 } 1014 1015 sahara_dump_descriptors(dev); 1016 sahara_dump_links(dev); 1017 1018 reinit_completion(&dev->dma_completion); 1019 1020 sahara_write(dev, dev->hw_phys_desc[0], SAHARA_REG_DAR); 1021 1022 timeout = wait_for_completion_timeout(&dev->dma_completion, 1023 msecs_to_jiffies(SAHARA_TIMEOUT_MS)); 1024 if (!timeout) { 1025 dev_err(dev->device, "SHA timeout\n"); 1026 return -ETIMEDOUT; 1027 } 1028 1029 if (rctx->sg_in_idx) 1030 dma_unmap_sg(dev->device, dev->in_sg, dev->nb_in_sg, 1031 DMA_TO_DEVICE); 1032 1033 memcpy(rctx->context, dev->context_base, rctx->context_size); 1034 1035 if (req->result) 1036 memcpy(req->result, rctx->context, rctx->digest_size); 1037 1038 return 0; 1039 } 1040 1041 static int sahara_queue_manage(void *data) 1042 { 1043 struct sahara_dev *dev = (struct sahara_dev *)data; 1044 struct crypto_async_request *async_req; 1045 struct crypto_async_request *backlog; 1046 int ret = 0; 1047 1048 do { 1049 __set_current_state(TASK_INTERRUPTIBLE); 1050 1051 mutex_lock(&dev->queue_mutex); 1052 backlog = crypto_get_backlog(&dev->queue); 1053 async_req = crypto_dequeue_request(&dev->queue); 1054 mutex_unlock(&dev->queue_mutex); 1055 1056 if (backlog) 1057 backlog->complete(backlog, -EINPROGRESS); 1058 1059 if (async_req) { 1060 if (crypto_tfm_alg_type(async_req->tfm) == 1061 CRYPTO_ALG_TYPE_AHASH) { 1062 struct ahash_request *req = 1063 ahash_request_cast(async_req); 1064 1065 ret = sahara_sha_process(req); 1066 } else { 1067 struct skcipher_request *req = 1068 skcipher_request_cast(async_req); 1069 1070 ret = sahara_aes_process(req); 1071 } 1072 1073 async_req->complete(async_req, ret); 1074 1075 continue; 1076 } 1077 1078 schedule(); 1079 } while (!kthread_should_stop()); 1080 1081 return 0; 1082 } 1083 1084 static int sahara_sha_enqueue(struct ahash_request *req, int last) 1085 { 1086 struct sahara_sha_reqctx *rctx = ahash_request_ctx(req); 1087 struct sahara_dev *dev = dev_ptr; 1088 int ret; 1089 1090 if (!req->nbytes && !last) 1091 return 0; 1092 1093 rctx->last = last; 1094 1095 if (!rctx->active) { 1096 rctx->active = 1; 1097 rctx->first = 1; 1098 } 1099 1100 mutex_lock(&dev->queue_mutex); 1101 ret = crypto_enqueue_request(&dev->queue, &req->base); 1102 mutex_unlock(&dev->queue_mutex); 1103 1104 wake_up_process(dev->kthread); 1105 1106 return ret; 1107 } 1108 1109 static int sahara_sha_init(struct ahash_request *req) 1110 { 1111 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 1112 struct sahara_sha_reqctx *rctx = ahash_request_ctx(req); 1113 1114 memset(rctx, 0, sizeof(*rctx)); 1115 1116 switch (crypto_ahash_digestsize(tfm)) { 1117 case SHA1_DIGEST_SIZE: 1118 rctx->mode |= SAHARA_HDR_MDHA_ALG_SHA1; 1119 rctx->digest_size = SHA1_DIGEST_SIZE; 1120 break; 1121 case SHA256_DIGEST_SIZE: 1122 rctx->mode |= SAHARA_HDR_MDHA_ALG_SHA256; 1123 rctx->digest_size = SHA256_DIGEST_SIZE; 1124 break; 1125 default: 1126 return -EINVAL; 1127 } 1128 1129 rctx->context_size = rctx->digest_size + 4; 1130 rctx->active = 0; 1131 1132 return 0; 1133 } 1134 1135 static int sahara_sha_update(struct ahash_request *req) 1136 { 1137 return sahara_sha_enqueue(req, 0); 1138 } 1139 1140 static int sahara_sha_final(struct ahash_request *req) 1141 { 1142 req->nbytes = 0; 1143 return sahara_sha_enqueue(req, 1); 1144 } 1145 1146 static int sahara_sha_finup(struct ahash_request *req) 1147 { 1148 return sahara_sha_enqueue(req, 1); 1149 } 1150 1151 static int sahara_sha_digest(struct ahash_request *req) 1152 { 1153 sahara_sha_init(req); 1154 1155 return sahara_sha_finup(req); 1156 } 1157 1158 static int sahara_sha_export(struct ahash_request *req, void *out) 1159 { 1160 struct sahara_sha_reqctx *rctx = ahash_request_ctx(req); 1161 1162 memcpy(out, rctx, sizeof(struct sahara_sha_reqctx)); 1163 1164 return 0; 1165 } 1166 1167 static int sahara_sha_import(struct ahash_request *req, const void *in) 1168 { 1169 struct sahara_sha_reqctx *rctx = ahash_request_ctx(req); 1170 1171 memcpy(rctx, in, sizeof(struct sahara_sha_reqctx)); 1172 1173 return 0; 1174 } 1175 1176 static int sahara_sha_cra_init(struct crypto_tfm *tfm) 1177 { 1178 crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm), 1179 sizeof(struct sahara_sha_reqctx) + 1180 SHA_BUFFER_LEN + SHA256_BLOCK_SIZE); 1181 1182 return 0; 1183 } 1184 1185 static struct skcipher_alg aes_algs[] = { 1186 { 1187 .base.cra_name = "ecb(aes)", 1188 .base.cra_driver_name = "sahara-ecb-aes", 1189 .base.cra_priority = 300, 1190 .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK, 1191 .base.cra_blocksize = AES_BLOCK_SIZE, 1192 .base.cra_ctxsize = sizeof(struct sahara_ctx), 1193 .base.cra_alignmask = 0x0, 1194 .base.cra_module = THIS_MODULE, 1195 1196 .init = sahara_aes_init_tfm, 1197 .exit = sahara_aes_exit_tfm, 1198 .min_keysize = AES_MIN_KEY_SIZE , 1199 .max_keysize = AES_MAX_KEY_SIZE, 1200 .setkey = sahara_aes_setkey, 1201 .encrypt = sahara_aes_ecb_encrypt, 1202 .decrypt = sahara_aes_ecb_decrypt, 1203 }, { 1204 .base.cra_name = "cbc(aes)", 1205 .base.cra_driver_name = "sahara-cbc-aes", 1206 .base.cra_priority = 300, 1207 .base.cra_flags = CRYPTO_ALG_ASYNC | CRYPTO_ALG_NEED_FALLBACK, 1208 .base.cra_blocksize = AES_BLOCK_SIZE, 1209 .base.cra_ctxsize = sizeof(struct sahara_ctx), 1210 .base.cra_alignmask = 0x0, 1211 .base.cra_module = THIS_MODULE, 1212 1213 .init = sahara_aes_init_tfm, 1214 .exit = sahara_aes_exit_tfm, 1215 .min_keysize = AES_MIN_KEY_SIZE , 1216 .max_keysize = AES_MAX_KEY_SIZE, 1217 .ivsize = AES_BLOCK_SIZE, 1218 .setkey = sahara_aes_setkey, 1219 .encrypt = sahara_aes_cbc_encrypt, 1220 .decrypt = sahara_aes_cbc_decrypt, 1221 } 1222 }; 1223 1224 static struct ahash_alg sha_v3_algs[] = { 1225 { 1226 .init = sahara_sha_init, 1227 .update = sahara_sha_update, 1228 .final = sahara_sha_final, 1229 .finup = sahara_sha_finup, 1230 .digest = sahara_sha_digest, 1231 .export = sahara_sha_export, 1232 .import = sahara_sha_import, 1233 .halg.digestsize = SHA1_DIGEST_SIZE, 1234 .halg.statesize = sizeof(struct sahara_sha_reqctx), 1235 .halg.base = { 1236 .cra_name = "sha1", 1237 .cra_driver_name = "sahara-sha1", 1238 .cra_priority = 300, 1239 .cra_flags = CRYPTO_ALG_ASYNC | 1240 CRYPTO_ALG_NEED_FALLBACK, 1241 .cra_blocksize = SHA1_BLOCK_SIZE, 1242 .cra_ctxsize = sizeof(struct sahara_ctx), 1243 .cra_alignmask = 0, 1244 .cra_module = THIS_MODULE, 1245 .cra_init = sahara_sha_cra_init, 1246 } 1247 }, 1248 }; 1249 1250 static struct ahash_alg sha_v4_algs[] = { 1251 { 1252 .init = sahara_sha_init, 1253 .update = sahara_sha_update, 1254 .final = sahara_sha_final, 1255 .finup = sahara_sha_finup, 1256 .digest = sahara_sha_digest, 1257 .export = sahara_sha_export, 1258 .import = sahara_sha_import, 1259 .halg.digestsize = SHA256_DIGEST_SIZE, 1260 .halg.statesize = sizeof(struct sahara_sha_reqctx), 1261 .halg.base = { 1262 .cra_name = "sha256", 1263 .cra_driver_name = "sahara-sha256", 1264 .cra_priority = 300, 1265 .cra_flags = CRYPTO_ALG_ASYNC | 1266 CRYPTO_ALG_NEED_FALLBACK, 1267 .cra_blocksize = SHA256_BLOCK_SIZE, 1268 .cra_ctxsize = sizeof(struct sahara_ctx), 1269 .cra_alignmask = 0, 1270 .cra_module = THIS_MODULE, 1271 .cra_init = sahara_sha_cra_init, 1272 } 1273 }, 1274 }; 1275 1276 static irqreturn_t sahara_irq_handler(int irq, void *data) 1277 { 1278 struct sahara_dev *dev = (struct sahara_dev *)data; 1279 unsigned int stat = sahara_read(dev, SAHARA_REG_STATUS); 1280 unsigned int err = sahara_read(dev, SAHARA_REG_ERRSTATUS); 1281 1282 sahara_write(dev, SAHARA_CMD_CLEAR_INT | SAHARA_CMD_CLEAR_ERR, 1283 SAHARA_REG_CMD); 1284 1285 sahara_decode_status(dev, stat); 1286 1287 if (SAHARA_STATUS_GET_STATE(stat) == SAHARA_STATE_BUSY) { 1288 return IRQ_NONE; 1289 } else if (SAHARA_STATUS_GET_STATE(stat) == SAHARA_STATE_COMPLETE) { 1290 dev->error = 0; 1291 } else { 1292 sahara_decode_error(dev, err); 1293 dev->error = -EINVAL; 1294 } 1295 1296 complete(&dev->dma_completion); 1297 1298 return IRQ_HANDLED; 1299 } 1300 1301 1302 static int sahara_register_algs(struct sahara_dev *dev) 1303 { 1304 int err; 1305 unsigned int i, j, k, l; 1306 1307 for (i = 0; i < ARRAY_SIZE(aes_algs); i++) { 1308 err = crypto_register_skcipher(&aes_algs[i]); 1309 if (err) 1310 goto err_aes_algs; 1311 } 1312 1313 for (k = 0; k < ARRAY_SIZE(sha_v3_algs); k++) { 1314 err = crypto_register_ahash(&sha_v3_algs[k]); 1315 if (err) 1316 goto err_sha_v3_algs; 1317 } 1318 1319 if (dev->version > SAHARA_VERSION_3) 1320 for (l = 0; l < ARRAY_SIZE(sha_v4_algs); l++) { 1321 err = crypto_register_ahash(&sha_v4_algs[l]); 1322 if (err) 1323 goto err_sha_v4_algs; 1324 } 1325 1326 return 0; 1327 1328 err_sha_v4_algs: 1329 for (j = 0; j < l; j++) 1330 crypto_unregister_ahash(&sha_v4_algs[j]); 1331 1332 err_sha_v3_algs: 1333 for (j = 0; j < k; j++) 1334 crypto_unregister_ahash(&sha_v3_algs[j]); 1335 1336 err_aes_algs: 1337 for (j = 0; j < i; j++) 1338 crypto_unregister_skcipher(&aes_algs[j]); 1339 1340 return err; 1341 } 1342 1343 static void sahara_unregister_algs(struct sahara_dev *dev) 1344 { 1345 unsigned int i; 1346 1347 for (i = 0; i < ARRAY_SIZE(aes_algs); i++) 1348 crypto_unregister_skcipher(&aes_algs[i]); 1349 1350 for (i = 0; i < ARRAY_SIZE(sha_v3_algs); i++) 1351 crypto_unregister_ahash(&sha_v3_algs[i]); 1352 1353 if (dev->version > SAHARA_VERSION_3) 1354 for (i = 0; i < ARRAY_SIZE(sha_v4_algs); i++) 1355 crypto_unregister_ahash(&sha_v4_algs[i]); 1356 } 1357 1358 static const struct platform_device_id sahara_platform_ids[] = { 1359 { .name = "sahara-imx27" }, 1360 { /* sentinel */ } 1361 }; 1362 MODULE_DEVICE_TABLE(platform, sahara_platform_ids); 1363 1364 static const struct of_device_id sahara_dt_ids[] = { 1365 { .compatible = "fsl,imx53-sahara" }, 1366 { .compatible = "fsl,imx27-sahara" }, 1367 { /* sentinel */ } 1368 }; 1369 MODULE_DEVICE_TABLE(of, sahara_dt_ids); 1370 1371 static int sahara_probe(struct platform_device *pdev) 1372 { 1373 struct sahara_dev *dev; 1374 u32 version; 1375 int irq; 1376 int err; 1377 int i; 1378 1379 dev = devm_kzalloc(&pdev->dev, sizeof(*dev), GFP_KERNEL); 1380 if (!dev) 1381 return -ENOMEM; 1382 1383 dev->device = &pdev->dev; 1384 platform_set_drvdata(pdev, dev); 1385 1386 /* Get the base address */ 1387 dev->regs_base = devm_platform_ioremap_resource(pdev, 0); 1388 if (IS_ERR(dev->regs_base)) 1389 return PTR_ERR(dev->regs_base); 1390 1391 /* Get the IRQ */ 1392 irq = platform_get_irq(pdev, 0); 1393 if (irq < 0) 1394 return irq; 1395 1396 err = devm_request_irq(&pdev->dev, irq, sahara_irq_handler, 1397 0, dev_name(&pdev->dev), dev); 1398 if (err) { 1399 dev_err(&pdev->dev, "failed to request irq\n"); 1400 return err; 1401 } 1402 1403 /* clocks */ 1404 dev->clk_ipg = devm_clk_get(&pdev->dev, "ipg"); 1405 if (IS_ERR(dev->clk_ipg)) { 1406 dev_err(&pdev->dev, "Could not get ipg clock\n"); 1407 return PTR_ERR(dev->clk_ipg); 1408 } 1409 1410 dev->clk_ahb = devm_clk_get(&pdev->dev, "ahb"); 1411 if (IS_ERR(dev->clk_ahb)) { 1412 dev_err(&pdev->dev, "Could not get ahb clock\n"); 1413 return PTR_ERR(dev->clk_ahb); 1414 } 1415 1416 /* Allocate HW descriptors */ 1417 dev->hw_desc[0] = dmam_alloc_coherent(&pdev->dev, 1418 SAHARA_MAX_HW_DESC * sizeof(struct sahara_hw_desc), 1419 &dev->hw_phys_desc[0], GFP_KERNEL); 1420 if (!dev->hw_desc[0]) { 1421 dev_err(&pdev->dev, "Could not allocate hw descriptors\n"); 1422 return -ENOMEM; 1423 } 1424 dev->hw_desc[1] = dev->hw_desc[0] + 1; 1425 dev->hw_phys_desc[1] = dev->hw_phys_desc[0] + 1426 sizeof(struct sahara_hw_desc); 1427 1428 /* Allocate space for iv and key */ 1429 dev->key_base = dmam_alloc_coherent(&pdev->dev, 2 * AES_KEYSIZE_128, 1430 &dev->key_phys_base, GFP_KERNEL); 1431 if (!dev->key_base) { 1432 dev_err(&pdev->dev, "Could not allocate memory for key\n"); 1433 return -ENOMEM; 1434 } 1435 dev->iv_base = dev->key_base + AES_KEYSIZE_128; 1436 dev->iv_phys_base = dev->key_phys_base + AES_KEYSIZE_128; 1437 1438 /* Allocate space for context: largest digest + message length field */ 1439 dev->context_base = dmam_alloc_coherent(&pdev->dev, 1440 SHA256_DIGEST_SIZE + 4, 1441 &dev->context_phys_base, GFP_KERNEL); 1442 if (!dev->context_base) { 1443 dev_err(&pdev->dev, "Could not allocate memory for MDHA context\n"); 1444 return -ENOMEM; 1445 } 1446 1447 /* Allocate space for HW links */ 1448 dev->hw_link[0] = dmam_alloc_coherent(&pdev->dev, 1449 SAHARA_MAX_HW_LINK * sizeof(struct sahara_hw_link), 1450 &dev->hw_phys_link[0], GFP_KERNEL); 1451 if (!dev->hw_link[0]) { 1452 dev_err(&pdev->dev, "Could not allocate hw links\n"); 1453 return -ENOMEM; 1454 } 1455 for (i = 1; i < SAHARA_MAX_HW_LINK; i++) { 1456 dev->hw_phys_link[i] = dev->hw_phys_link[i - 1] + 1457 sizeof(struct sahara_hw_link); 1458 dev->hw_link[i] = dev->hw_link[i - 1] + 1; 1459 } 1460 1461 crypto_init_queue(&dev->queue, SAHARA_QUEUE_LENGTH); 1462 1463 mutex_init(&dev->queue_mutex); 1464 1465 dev_ptr = dev; 1466 1467 dev->kthread = kthread_run(sahara_queue_manage, dev, "sahara_crypto"); 1468 if (IS_ERR(dev->kthread)) { 1469 return PTR_ERR(dev->kthread); 1470 } 1471 1472 init_completion(&dev->dma_completion); 1473 1474 err = clk_prepare_enable(dev->clk_ipg); 1475 if (err) 1476 return err; 1477 err = clk_prepare_enable(dev->clk_ahb); 1478 if (err) 1479 goto clk_ipg_disable; 1480 1481 version = sahara_read(dev, SAHARA_REG_VERSION); 1482 if (of_device_is_compatible(pdev->dev.of_node, "fsl,imx27-sahara")) { 1483 if (version != SAHARA_VERSION_3) 1484 err = -ENODEV; 1485 } else if (of_device_is_compatible(pdev->dev.of_node, 1486 "fsl,imx53-sahara")) { 1487 if (((version >> 8) & 0xff) != SAHARA_VERSION_4) 1488 err = -ENODEV; 1489 version = (version >> 8) & 0xff; 1490 } 1491 if (err == -ENODEV) { 1492 dev_err(&pdev->dev, "SAHARA version %d not supported\n", 1493 version); 1494 goto err_algs; 1495 } 1496 1497 dev->version = version; 1498 1499 sahara_write(dev, SAHARA_CMD_RESET | SAHARA_CMD_MODE_BATCH, 1500 SAHARA_REG_CMD); 1501 sahara_write(dev, SAHARA_CONTROL_SET_THROTTLE(0) | 1502 SAHARA_CONTROL_SET_MAXBURST(8) | 1503 SAHARA_CONTROL_RNG_AUTORSD | 1504 SAHARA_CONTROL_ENABLE_INT, 1505 SAHARA_REG_CONTROL); 1506 1507 err = sahara_register_algs(dev); 1508 if (err) 1509 goto err_algs; 1510 1511 dev_info(&pdev->dev, "SAHARA version %d initialized\n", version); 1512 1513 return 0; 1514 1515 err_algs: 1516 kthread_stop(dev->kthread); 1517 dev_ptr = NULL; 1518 clk_disable_unprepare(dev->clk_ahb); 1519 clk_ipg_disable: 1520 clk_disable_unprepare(dev->clk_ipg); 1521 1522 return err; 1523 } 1524 1525 static int sahara_remove(struct platform_device *pdev) 1526 { 1527 struct sahara_dev *dev = platform_get_drvdata(pdev); 1528 1529 kthread_stop(dev->kthread); 1530 1531 sahara_unregister_algs(dev); 1532 1533 clk_disable_unprepare(dev->clk_ipg); 1534 clk_disable_unprepare(dev->clk_ahb); 1535 1536 dev_ptr = NULL; 1537 1538 return 0; 1539 } 1540 1541 static struct platform_driver sahara_driver = { 1542 .probe = sahara_probe, 1543 .remove = sahara_remove, 1544 .driver = { 1545 .name = SAHARA_NAME, 1546 .of_match_table = sahara_dt_ids, 1547 }, 1548 .id_table = sahara_platform_ids, 1549 }; 1550 1551 module_platform_driver(sahara_driver); 1552 1553 MODULE_LICENSE("GPL"); 1554 MODULE_AUTHOR("Javier Martin <javier.martin@vista-silicon.com>"); 1555 MODULE_AUTHOR("Steffen Trumtrar <s.trumtrar@pengutronix.de>"); 1556 MODULE_DESCRIPTION("SAHARA2 HW crypto accelerator"); 1557