1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2019 Fuzhou Rockchip Electronics Co., Ltd 4 */ 5 6 #include <common.h> 7 #include <clk.h> 8 #include <crypto.h> 9 #include <dm.h> 10 #include <asm/io.h> 11 #include <asm/arch/hardware.h> 12 #include <asm/arch/clock.h> 13 #include <rockchip/crypto_hash_cache.h> 14 #include <rockchip/crypto_v2.h> 15 #include <rockchip/crypto_v2_pka.h> 16 17 #define RK_HASH_CTX_MAGIC 0x1A1A1A1A 18 19 #define CRYPTO_TRNG_MAX 32 20 21 enum endian_mode { 22 BIG_ENDIAN = 0, 23 LITTLE_ENDIAN 24 }; 25 26 enum clk_type { 27 CLK = 0, 28 HCLK 29 }; 30 31 struct crypto_lli_desc { 32 u32 src_addr; 33 u32 src_len; 34 u32 dst_addr; 35 u32 dst_len; 36 u32 user_define; 37 u32 reserve; 38 u32 dma_ctrl; 39 u32 next_addr; 40 }; 41 42 struct rk_hash_ctx { 43 struct crypto_lli_desc data_lli; /* lli desc */ 44 struct crypto_hash_cache *hash_cache; 45 u32 magic; /* to check ctx */ 46 u32 algo; /* hash algo */ 47 u8 digest_size; /* hash out length */ 48 u8 reserved[3]; 49 }; 50 51 struct rockchip_crypto_priv { 52 fdt_addr_t reg; 53 struct clk clk; 54 u32 frequency; 55 char *clocks; 56 u32 *frequencies; 57 u32 nclocks; 58 u32 length; 59 struct rk_hash_ctx *hw_ctx; 60 }; 61 62 #define LLI_ADDR_ALIGIN_SIZE 8 63 #define DATA_ADDR_ALIGIN_SIZE 8 64 #define DATA_LEN_ALIGIN_SIZE 64 65 66 /* crypto timeout 500ms, must support more than 32M data per times*/ 67 #define HASH_UPDATE_LIMIT (32 * 1024 * 1024) 68 #define RK_CRYPTO_TIME_OUT 500000 69 70 #define RK_WHILE_TIME_OUT(condition, timeout, ret) { \ 71 u32 time_out = timeout; \ 72 ret = 0; \ 73 while (condition) { \ 74 if (time_out-- == 0) { \ 75 debug("[%s] %d: time out!\n", __func__,\ 76 __LINE__); \ 77 ret = -ETIME; \ 78 break; \ 79 } \ 80 udelay(1); \ 81 } \ 82 } while (0) 83 84 typedef u32 paddr_t; 85 #define virt_to_phys(addr) (((unsigned long)addr) & 0xffffffff) 86 #define phys_to_virt(addr, area) ((unsigned long)addr) 87 88 fdt_addr_t crypto_base; 89 90 static int hw_check_trng_exist(void) 91 { 92 u32 tmp = 0, val = 0; 93 94 tmp = crypto_read(CRYPTO_RNG_SAMPLE_CNT); 95 crypto_write(50, CRYPTO_RNG_SAMPLE_CNT); 96 97 val = crypto_read(CRYPTO_RNG_SAMPLE_CNT); 98 crypto_write(tmp, CRYPTO_RNG_SAMPLE_CNT); 99 100 return val; 101 } 102 103 static void word2byte(u32 word, u8 *ch, u32 endian) 104 { 105 /* 0: Big-Endian 1: Little-Endian */ 106 if (endian == BIG_ENDIAN) { 107 ch[0] = (word >> 24) & 0xff; 108 ch[1] = (word >> 16) & 0xff; 109 ch[2] = (word >> 8) & 0xff; 110 ch[3] = (word >> 0) & 0xff; 111 } else if (endian == LITTLE_ENDIAN) { 112 ch[0] = (word >> 0) & 0xff; 113 ch[1] = (word >> 8) & 0xff; 114 ch[2] = (word >> 16) & 0xff; 115 ch[3] = (word >> 24) & 0xff; 116 } else { 117 ch[0] = 0; 118 ch[1] = 0; 119 ch[2] = 0; 120 ch[3] = 0; 121 } 122 } 123 124 static inline void clear_hash_out_reg(void) 125 { 126 int i; 127 128 /*clear out register*/ 129 for (i = 0; i < 16; i++) 130 crypto_write(0, CRYPTO_HASH_DOUT_0 + 4 * i); 131 } 132 133 static int hw_crypto_reset(void) 134 { 135 u32 tmp = 0, tmp_mask = 0; 136 int ret; 137 138 tmp = CRYPTO_SW_PKA_RESET | CRYPTO_SW_CC_RESET; 139 tmp_mask = tmp << CRYPTO_WRITE_MASK_SHIFT; 140 141 /* reset pka and crypto modules*/ 142 crypto_write(tmp | tmp_mask, CRYPTO_RST_CTL); 143 144 /* wait reset compelete */ 145 RK_WHILE_TIME_OUT(crypto_read(CRYPTO_RST_CTL), 146 RK_CRYPTO_TIME_OUT, ret); 147 return ret; 148 } 149 150 static void hw_hash_clean_ctx(struct rk_hash_ctx *ctx) 151 { 152 /* clear hash status */ 153 crypto_write(CRYPTO_WRITE_MASK_ALL | 0, CRYPTO_HASH_CTL); 154 155 assert(ctx); 156 assert(ctx->magic == RK_HASH_CTX_MAGIC); 157 158 crypto_hash_cache_free(ctx->hash_cache); 159 160 memset(ctx, 0x00, sizeof(*ctx)); 161 } 162 163 static int rk_hash_init(void *hw_ctx, u32 algo) 164 { 165 struct rk_hash_ctx *tmp_ctx = (struct rk_hash_ctx *)hw_ctx; 166 u32 reg_ctrl = 0; 167 int ret; 168 169 if (!tmp_ctx) 170 return -EINVAL; 171 172 reg_ctrl = CRYPTO_SW_CC_RESET; 173 crypto_write(reg_ctrl | (reg_ctrl << CRYPTO_WRITE_MASK_SHIFT), 174 CRYPTO_RST_CTL); 175 176 /* wait reset compelete */ 177 RK_WHILE_TIME_OUT(crypto_read(CRYPTO_RST_CTL), 178 RK_CRYPTO_TIME_OUT, ret); 179 180 reg_ctrl = 0; 181 tmp_ctx->algo = algo; 182 switch (algo) { 183 case CRYPTO_MD5: 184 reg_ctrl |= CRYPTO_MODE_MD5; 185 tmp_ctx->digest_size = 16; 186 break; 187 case CRYPTO_SHA1: 188 reg_ctrl |= CRYPTO_MODE_SHA1; 189 tmp_ctx->digest_size = 20; 190 break; 191 case CRYPTO_SHA256: 192 reg_ctrl |= CRYPTO_MODE_SHA256; 193 tmp_ctx->digest_size = 32; 194 break; 195 case CRYPTO_SHA512: 196 reg_ctrl |= CRYPTO_MODE_SHA512; 197 tmp_ctx->digest_size = 64; 198 break; 199 200 default: 201 ret = -EINVAL; 202 goto exit; 203 } 204 205 clear_hash_out_reg(); 206 207 /* enable hardware padding */ 208 reg_ctrl |= CRYPTO_HW_PAD_ENABLE; 209 crypto_write(reg_ctrl | CRYPTO_WRITE_MASK_ALL, CRYPTO_HASH_CTL); 210 211 /* FIFO input and output data byte swap */ 212 /* such as B0, B1, B2, B3 -> B3, B2, B1, B0 */ 213 reg_ctrl = CRYPTO_DOUT_BYTESWAP | CRYPTO_DOIN_BYTESWAP; 214 crypto_write(reg_ctrl | CRYPTO_WRITE_MASK_ALL, CRYPTO_FIFO_CTL); 215 216 /* enable src_item_done interrupt */ 217 crypto_write(CRYPTO_SRC_ITEM_INT_EN, CRYPTO_DMA_INT_EN); 218 219 tmp_ctx->magic = RK_HASH_CTX_MAGIC; 220 221 return 0; 222 exit: 223 /* clear hash setting if init failed */ 224 crypto_write(CRYPTO_WRITE_MASK_ALL | 0, CRYPTO_HASH_CTL); 225 226 return ret; 227 } 228 229 static int rk_hash_direct_calc(void *hw_data, const u8 *data, 230 u32 data_len, u8 *started_flag, u8 is_last) 231 { 232 struct rockchip_crypto_priv *priv = hw_data; 233 struct rk_hash_ctx *hash_ctx = priv->hw_ctx; 234 struct crypto_lli_desc *lli = &hash_ctx->data_lli; 235 int ret = -EINVAL; 236 u32 tmp = 0, mask = 0; 237 238 assert(IS_ALIGNED((ulong)data, DATA_ADDR_ALIGIN_SIZE)); 239 assert(is_last || IS_ALIGNED(data_len, DATA_LEN_ALIGIN_SIZE)); 240 241 debug("%s: data = %p, len = %u, s = %x, l = %x\n", 242 __func__, data, data_len, *started_flag, is_last); 243 244 memset(lli, 0x00, sizeof(*lli)); 245 lli->src_addr = (u32)virt_to_phys(data); 246 lli->src_len = data_len; 247 lli->dma_ctrl = LLI_DMA_CTRL_SRC_DONE; 248 249 if (is_last) { 250 lli->user_define |= LLI_USER_STRING_LAST; 251 lli->dma_ctrl |= LLI_DMA_CTRL_LAST; 252 } else { 253 lli->next_addr = (u32)virt_to_phys(lli); 254 lli->dma_ctrl |= LLI_DMA_CTRL_PAUSE; 255 } 256 257 if (!(*started_flag)) { 258 lli->user_define |= 259 (LLI_USER_STRING_START | LLI_USER_CPIHER_START); 260 crypto_write((u32)virt_to_phys(lli), CRYPTO_DMA_LLI_ADDR); 261 crypto_write((CRYPTO_HASH_ENABLE << CRYPTO_WRITE_MASK_SHIFT) | 262 CRYPTO_HASH_ENABLE, CRYPTO_HASH_CTL); 263 tmp = CRYPTO_DMA_START; 264 *started_flag = 1; 265 } else { 266 tmp = CRYPTO_DMA_RESTART; 267 } 268 269 /* flush cache */ 270 crypto_flush_cacheline((ulong)lli, sizeof(*lli)); 271 crypto_flush_cacheline((ulong)data, data_len); 272 273 /* start calculate */ 274 crypto_write(tmp << CRYPTO_WRITE_MASK_SHIFT | tmp, 275 CRYPTO_DMA_CTL); 276 277 /* mask CRYPTO_SYNC_LOCKSTEP_INT_ST flag */ 278 mask = ~(mask | CRYPTO_SYNC_LOCKSTEP_INT_ST); 279 280 /* wait calc ok */ 281 RK_WHILE_TIME_OUT(!(crypto_read(CRYPTO_DMA_INT_ST) & mask), 282 RK_CRYPTO_TIME_OUT, ret); 283 284 /* clear interrupt status */ 285 tmp = crypto_read(CRYPTO_DMA_INT_ST); 286 crypto_write(tmp, CRYPTO_DMA_INT_ST); 287 288 if (tmp != CRYPTO_SRC_ITEM_DONE_INT_ST && 289 tmp != CRYPTO_ZERO_LEN_INT_ST) { 290 debug("[%s] %d: CRYPTO_DMA_INT_ST = 0x%x\n", 291 __func__, __LINE__, tmp); 292 goto exit; 293 } 294 295 priv->length += data_len; 296 exit: 297 return ret; 298 } 299 300 int rk_hash_update(void *ctx, const u8 *data, u32 data_len) 301 { 302 struct rk_hash_ctx *tmp_ctx = (struct rk_hash_ctx *)ctx; 303 int ret = -EINVAL; 304 305 debug("\n"); 306 if (!tmp_ctx || !data) 307 goto exit; 308 309 if (tmp_ctx->digest_size == 0 || tmp_ctx->magic != RK_HASH_CTX_MAGIC) 310 goto exit; 311 312 ret = crypto_hash_update_with_cache(tmp_ctx->hash_cache, 313 data, data_len); 314 315 exit: 316 /* free lli list */ 317 if (ret) 318 hw_hash_clean_ctx(tmp_ctx); 319 320 return ret; 321 } 322 323 int rk_hash_final(void *ctx, u8 *digest, size_t len) 324 { 325 struct rk_hash_ctx *tmp_ctx = (struct rk_hash_ctx *)ctx; 326 int ret = -EINVAL; 327 u32 i; 328 329 if (!digest) 330 goto exit; 331 332 if (!tmp_ctx || 333 tmp_ctx->digest_size == 0 || 334 len > tmp_ctx->digest_size || 335 tmp_ctx->magic != RK_HASH_CTX_MAGIC) { 336 goto exit; 337 } 338 339 /* wait hash value ok */ 340 RK_WHILE_TIME_OUT(!crypto_read(CRYPTO_HASH_VALID), 341 RK_CRYPTO_TIME_OUT, ret); 342 343 for (i = 0; i < len / 4; i++) 344 word2byte(crypto_read(CRYPTO_HASH_DOUT_0 + i * 4), 345 digest + i * 4, BIG_ENDIAN); 346 347 if (len % 4) { 348 u8 tmp_buf[4]; 349 350 word2byte(crypto_read(CRYPTO_HASH_DOUT_0 + i * 4), 351 tmp_buf, BIG_ENDIAN); 352 memcpy(digest + i * 4, tmp_buf, len % 4); 353 } 354 355 /* clear hash status */ 356 crypto_write(CRYPTO_HASH_IS_VALID, CRYPTO_HASH_VALID); 357 crypto_write(CRYPTO_WRITE_MASK_ALL | 0, CRYPTO_HASH_CTL); 358 359 exit: 360 361 return ret; 362 } 363 364 static int rk_trng(u8 *trng, u32 len) 365 { 366 u32 i, reg_ctrl = 0; 367 int ret = -EINVAL; 368 u32 buf[8]; 369 370 if (len > CRYPTO_TRNG_MAX) 371 return -EINVAL; 372 373 memset(buf, 0, sizeof(buf)); 374 375 /* enable osc_ring to get entropy, sample period is set as 50 */ 376 crypto_write(50, CRYPTO_RNG_SAMPLE_CNT); 377 378 reg_ctrl |= CRYPTO_RNG_256_bit_len; 379 reg_ctrl |= CRYPTO_RNG_SLOWER_SOC_RING_1; 380 reg_ctrl |= CRYPTO_RNG_ENABLE; 381 reg_ctrl |= CRYPTO_RNG_START; 382 reg_ctrl |= CRYPTO_WRITE_MASK_ALL; 383 384 crypto_write(reg_ctrl | CRYPTO_WRITE_MASK_ALL, CRYPTO_RNG_CTL); 385 RK_WHILE_TIME_OUT(crypto_read(CRYPTO_RNG_CTL) & CRYPTO_RNG_START, 386 RK_CRYPTO_TIME_OUT, ret); 387 388 if (ret == 0) { 389 for (i = 0; i < ARRAY_SIZE(buf); i++) 390 buf[i] = crypto_read(CRYPTO_RNG_DOUT_0 + i * 4); 391 memcpy(trng, buf, len); 392 } 393 394 /* close TRNG */ 395 crypto_write(0 | CRYPTO_WRITE_MASK_ALL, CRYPTO_RNG_CTL); 396 397 return ret; 398 } 399 400 static u32 rockchip_crypto_capability(struct udevice *dev) 401 { 402 u32 val = 0; 403 404 val = CRYPTO_MD5 | 405 CRYPTO_SHA1 | 406 CRYPTO_SHA256 | 407 #if !defined(CONFIG_ROCKCHIP_RK1808) 408 CRYPTO_SHA512 | 409 #endif 410 CRYPTO_RSA512 | 411 CRYPTO_RSA1024 | 412 CRYPTO_RSA2048 | 413 CRYPTO_RSA3072 | 414 CRYPTO_RSA4096; 415 416 if (hw_check_trng_exist()) 417 val |= CRYPTO_TRNG; 418 419 return val; 420 } 421 422 static int rockchip_crypto_sha_init(struct udevice *dev, sha_context *ctx) 423 { 424 struct rockchip_crypto_priv *priv = dev_get_priv(dev); 425 struct rk_hash_ctx *hash_ctx = priv->hw_ctx; 426 427 if (!ctx) 428 return -EINVAL; 429 430 memset(hash_ctx, 0x00, sizeof(*hash_ctx)); 431 432 priv->length = 0; 433 434 hash_ctx->hash_cache = crypto_hash_cache_alloc(rk_hash_direct_calc, 435 priv, ctx->length, 436 DATA_ADDR_ALIGIN_SIZE, 437 DATA_LEN_ALIGIN_SIZE); 438 if (!hash_ctx->hash_cache) 439 return -EFAULT; 440 441 return rk_hash_init(hash_ctx, ctx->algo); 442 } 443 444 static int rockchip_crypto_sha_update(struct udevice *dev, 445 u32 *input, u32 len) 446 { 447 struct rockchip_crypto_priv *priv = dev_get_priv(dev); 448 int ret, i; 449 u8 *p; 450 451 if (!len) 452 return -EINVAL; 453 454 p = (u8 *)input; 455 456 for (i = 0; i < len / HASH_UPDATE_LIMIT; i++, p += HASH_UPDATE_LIMIT) { 457 ret = rk_hash_update(priv->hw_ctx, p, HASH_UPDATE_LIMIT); 458 if (ret) 459 goto exit; 460 } 461 462 if (len % HASH_UPDATE_LIMIT) 463 ret = rk_hash_update(priv->hw_ctx, p, len % HASH_UPDATE_LIMIT); 464 465 exit: 466 return ret; 467 } 468 469 static int rockchip_crypto_sha_final(struct udevice *dev, 470 sha_context *ctx, u8 *output) 471 { 472 struct rockchip_crypto_priv *priv = dev_get_priv(dev); 473 u32 nbits; 474 int ret; 475 476 nbits = crypto_algo_nbits(ctx->algo); 477 478 if (priv->length != ctx->length) { 479 printf("total length(0x%08x) != init length(0x%08x)!\n", 480 priv->length, ctx->length); 481 ret = -EIO; 482 goto exit; 483 } 484 485 ret = rk_hash_final(priv->hw_ctx, (u8 *)output, BITS2BYTE(nbits)); 486 487 exit: 488 hw_hash_clean_ctx(priv->hw_ctx); 489 return ret; 490 } 491 492 #if CONFIG_IS_ENABLED(ROCKCHIP_RSA) 493 static int rockchip_crypto_rsa_verify(struct udevice *dev, rsa_key *ctx, 494 u8 *sign, u8 *output) 495 { 496 struct mpa_num *mpa_m = NULL, *mpa_e = NULL, *mpa_n = NULL; 497 struct mpa_num *mpa_c = NULL, *mpa_result = NULL; 498 u32 n_bits, n_words; 499 u32 *rsa_result; 500 int ret; 501 502 if (!ctx) 503 return -EINVAL; 504 505 if (ctx->algo != CRYPTO_RSA512 && 506 ctx->algo != CRYPTO_RSA1024 && 507 ctx->algo != CRYPTO_RSA2048 && 508 ctx->algo != CRYPTO_RSA3072 && 509 ctx->algo != CRYPTO_RSA4096) 510 return -EINVAL; 511 512 n_bits = crypto_algo_nbits(ctx->algo); 513 n_words = BITS2WORD(n_bits); 514 515 rsa_result = malloc(BITS2BYTE(n_bits)); 516 if (!rsa_result) 517 return -ENOMEM; 518 519 memset(rsa_result, 0x00, BITS2BYTE(n_bits)); 520 521 ret = rk_mpa_alloc(&mpa_m); 522 ret |= rk_mpa_alloc(&mpa_e); 523 ret |= rk_mpa_alloc(&mpa_n); 524 ret |= rk_mpa_alloc(&mpa_c); 525 ret |= rk_mpa_alloc(&mpa_result); 526 if (ret) 527 goto exit; 528 529 mpa_m->d = (void *)sign; 530 mpa_e->d = (void *)ctx->e; 531 mpa_n->d = (void *)ctx->n; 532 mpa_c->d = (void *)ctx->c; 533 mpa_result->d = (void *)rsa_result; 534 535 mpa_m->size = n_words; 536 mpa_e->size = n_words; 537 mpa_n->size = n_words; 538 mpa_c->size = n_words; 539 mpa_result->size = n_words; 540 541 ret = rk_exptmod_np(mpa_m, mpa_e, mpa_n, mpa_c, mpa_result); 542 if (!ret) 543 memcpy(output, rsa_result, BITS2BYTE(n_bits)); 544 545 exit: 546 free(rsa_result); 547 rk_mpa_free(&mpa_m); 548 rk_mpa_free(&mpa_e); 549 rk_mpa_free(&mpa_n); 550 rk_mpa_free(&mpa_c); 551 rk_mpa_free(&mpa_result); 552 553 return ret; 554 } 555 #else 556 static int rockchip_crypto_rsa_verify(struct udevice *dev, rsa_key *ctx, 557 u8 *sign, u8 *output) 558 { 559 return -ENOSYS; 560 } 561 #endif 562 563 static int rockchip_crypto_get_trng(struct udevice *dev, u8 *output, u32 len) 564 { 565 int ret; 566 u32 i; 567 568 if (!dev || !output || !len) 569 return -EINVAL; 570 571 for (i = 0; i < len / CRYPTO_TRNG_MAX; i++) { 572 ret = rk_trng(output + i * CRYPTO_TRNG_MAX, CRYPTO_TRNG_MAX); 573 if (ret) 574 goto fail; 575 } 576 577 ret = rk_trng(output + i * CRYPTO_TRNG_MAX, len % CRYPTO_TRNG_MAX); 578 579 fail: 580 return ret; 581 } 582 583 static const struct dm_crypto_ops rockchip_crypto_ops = { 584 .capability = rockchip_crypto_capability, 585 .sha_init = rockchip_crypto_sha_init, 586 .sha_update = rockchip_crypto_sha_update, 587 .sha_final = rockchip_crypto_sha_final, 588 .rsa_verify = rockchip_crypto_rsa_verify, 589 .get_trng = rockchip_crypto_get_trng, 590 }; 591 592 /* 593 * Only use "clocks" to parse crypto clock id and use rockchip_get_clk(). 594 * Because we always add crypto node in U-Boot dts, when kernel dtb enabled : 595 * 596 * 1. There is cru phandle mismatch between U-Boot and kernel dtb; 597 * 2. CONFIG_OF_SPL_REMOVE_PROPS removes clock property; 598 */ 599 static int rockchip_crypto_ofdata_to_platdata(struct udevice *dev) 600 { 601 struct rockchip_crypto_priv *priv = dev_get_priv(dev); 602 int len, ret = -EINVAL; 603 604 if (!dev_read_prop(dev, "clocks", &len)) { 605 printf("Can't find \"clocks\" property\n"); 606 return -EINVAL; 607 } 608 609 memset(priv, 0x00, sizeof(*priv)); 610 priv->clocks = malloc(len); 611 if (!priv->clocks) 612 return -ENOMEM; 613 614 priv->nclocks = len / sizeof(u32); 615 if (dev_read_u32_array(dev, "clocks", (u32 *)priv->clocks, 616 priv->nclocks)) { 617 printf("Can't read \"clocks\" property\n"); 618 ret = -EINVAL; 619 goto exit; 620 } 621 622 if (!dev_read_prop(dev, "clock-frequency", &len)) { 623 printf("Can't find \"clock-frequency\" property\n"); 624 ret = -EINVAL; 625 goto exit; 626 } 627 628 priv->frequencies = malloc(len); 629 if (!priv->frequencies) { 630 ret = -ENOMEM; 631 goto exit; 632 } 633 634 priv->nclocks = len / sizeof(u32); 635 if (dev_read_u32_array(dev, "clock-frequency", priv->frequencies, 636 priv->nclocks)) { 637 printf("Can't read \"clock-frequency\" property\n"); 638 ret = -EINVAL; 639 goto exit; 640 } 641 642 priv->reg = (fdt_addr_t)dev_read_addr_ptr(dev); 643 644 crypto_base = priv->reg; 645 646 return 0; 647 exit: 648 if (priv->clocks) 649 free(priv->clocks); 650 651 if (priv->frequencies) 652 free(priv->frequencies); 653 654 return ret; 655 } 656 657 static int rockchip_crypto_probe(struct udevice *dev) 658 { 659 struct rockchip_crypto_priv *priv = dev_get_priv(dev); 660 int i, ret = 0; 661 u32* clocks; 662 663 priv->hw_ctx = memalign(LLI_ADDR_ALIGIN_SIZE, 664 sizeof(struct rk_hash_ctx)); 665 if (!priv->hw_ctx) 666 return -ENOMEM; 667 668 ret = rockchip_get_clk(&priv->clk.dev); 669 if (ret) { 670 printf("Failed to get clk device, ret=%d\n", ret); 671 return ret; 672 } 673 674 clocks = (u32 *)priv->clocks; 675 for (i = 0; i < priv->nclocks; i++) { 676 priv->clk.id = clocks[i * 2 + 1]; 677 ret = clk_set_rate(&priv->clk, priv->frequencies[i]); 678 if (ret < 0) { 679 printf("%s: Failed to set clk(%ld): ret=%d\n", 680 __func__, priv->clk.id, ret); 681 return ret; 682 } 683 } 684 685 hw_crypto_reset(); 686 687 return 0; 688 } 689 690 static const struct udevice_id rockchip_crypto_ids[] = { 691 { .compatible = "rockchip,px30-crypto" }, 692 { .compatible = "rockchip,rk1808-crypto" }, 693 { .compatible = "rockchip,rk3308-crypto" }, 694 { .compatible = "rockchip,rv1126-crypto" }, 695 { .compatible = "rockchip,rk3568-crypto" }, 696 { } 697 }; 698 699 U_BOOT_DRIVER(rockchip_crypto_v2) = { 700 .name = "rockchip_crypto_v2", 701 .id = UCLASS_CRYPTO, 702 .of_match = rockchip_crypto_ids, 703 .ops = &rockchip_crypto_ops, 704 .probe = rockchip_crypto_probe, 705 .ofdata_to_platdata = rockchip_crypto_ofdata_to_platdata, 706 .priv_auto_alloc_size = sizeof(struct rockchip_crypto_priv), 707 }; 708