git.sur5r.net Git - u-boot/blob - drivers/crypto/fsl/jr.c

   1 /*
   2  * Copyright 2008-2014 Freescale Semiconductor, Inc.
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  *
   6  * Based on CAAM driver in drivers/crypto/caam in Linux
   7  */
   8
   9 #include <common.h>
  10 #include <malloc.h>
  11 #include "fsl_sec.h"
  12 #include "jr.h"
  13 #include "jobdesc.h"
  14 #include "desc_constr.h"
  15
  16 #define CIRC_CNT(head, tail, size)      (((head) - (tail)) & (size - 1))
  17 #define CIRC_SPACE(head, tail, size)    CIRC_CNT((tail), (head) + 1, (size))
  18
  19 struct jobring jr;
  20
  21 static inline void start_jr0(void)
  22 {
  23         ccsr_sec_t *sec = (void *)CONFIG_SYS_FSL_SEC_ADDR;
  24         u32 ctpr_ms = sec_in32(&sec->ctpr_ms);
  25         u32 scfgr = sec_in32(&sec->scfgr);
  26
  27         if (ctpr_ms & SEC_CTPR_MS_VIRT_EN_INCL) {
  28                 /* VIRT_EN_INCL = 1 & VIRT_EN_POR = 1 or
  29                  * VIRT_EN_INCL = 1 & VIRT_EN_POR = 0 & SEC_SCFGR_VIRT_EN = 1
  30                  */
  31                 if ((ctpr_ms & SEC_CTPR_MS_VIRT_EN_POR) ||
  32                     (!(ctpr_ms & SEC_CTPR_MS_VIRT_EN_POR) &&
  33                                         (scfgr & SEC_SCFGR_VIRT_EN)))
  34                         sec_out32(&sec->jrstartr, CONFIG_JRSTARTR_JR0);
  35         } else {
  36                 /* VIRT_EN_INCL = 0 && VIRT_EN_POR_VALUE = 1 */
  37                 if (ctpr_ms & SEC_CTPR_MS_VIRT_EN_POR)
  38                         sec_out32(&sec->jrstartr, CONFIG_JRSTARTR_JR0);
  39         }
  40 }
  41
  42 static inline void jr_reset_liodn(void)
  43 {
  44         ccsr_sec_t *sec = (void *)CONFIG_SYS_FSL_SEC_ADDR;
  45         sec_out32(&sec->jrliodnr[0].ls, 0);
  46 }
  47
  48 static inline void jr_disable_irq(void)
  49 {
  50         struct jr_regs *regs = (struct jr_regs *)CONFIG_SYS_FSL_JR0_ADDR;
  51         uint32_t jrcfg = sec_in32(&regs->jrcfg1);
  52
  53         jrcfg = jrcfg | JR_INTMASK;
  54
  55         sec_out32(&regs->jrcfg1, jrcfg);
  56 }
  57
  58 static void jr_initregs(void)
  59 {
  60         struct jr_regs *regs = (struct jr_regs *)CONFIG_SYS_FSL_JR0_ADDR;
  61         phys_addr_t ip_base = virt_to_phys((void *)jr.input_ring);
  62         phys_addr_t op_base = virt_to_phys((void *)jr.output_ring);
  63
  64 #ifdef CONFIG_PHYS_64BIT
  65         sec_out32(&regs->irba_h, ip_base >> 32);
  66 #else
  67         sec_out32(&regs->irba_h, 0x0);
  68 #endif
  69         sec_out32(&regs->irba_l, (uint32_t)ip_base);
  70 #ifdef CONFIG_PHYS_64BIT
  71         sec_out32(&regs->orba_h, op_base >> 32);
  72 #else
  73         sec_out32(&regs->orba_h, 0x0);
  74 #endif
  75         sec_out32(&regs->orba_l, (uint32_t)op_base);
  76         sec_out32(&regs->ors, JR_SIZE);
  77         sec_out32(&regs->irs, JR_SIZE);
  78
  79         if (!jr.irq)
  80                 jr_disable_irq();
  81 }
  82
  83 static int jr_init(void)
  84 {
  85         memset(&jr, 0, sizeof(struct jobring));
  86
  87         jr.jq_id = DEFAULT_JR_ID;
  88         jr.irq = DEFAULT_IRQ;
  89
  90 #ifdef CONFIG_FSL_CORENET
  91         jr.liodn = DEFAULT_JR_LIODN;
  92 #endif
  93         jr.size = JR_SIZE;
  94         jr.input_ring = (dma_addr_t *)memalign(ARCH_DMA_MINALIGN,
  95                                 JR_SIZE * sizeof(dma_addr_t));
  96         if (!jr.input_ring)
  97                 return -1;
  98
  99         jr.op_size = roundup(JR_SIZE * sizeof(struct op_ring),
 100                              ARCH_DMA_MINALIGN);
 101         jr.output_ring =
 102             (struct op_ring *)memalign(ARCH_DMA_MINALIGN, jr.op_size);
 103         if (!jr.output_ring)
 104                 return -1;
 105
 106         memset(jr.input_ring, 0, JR_SIZE * sizeof(dma_addr_t));
 107         memset(jr.output_ring, 0, jr.op_size);
 108
 109         start_jr0();
 110
 111         jr_initregs();
 112
 113         return 0;
 114 }
 115
 116 static int jr_sw_cleanup(void)
 117 {
 118         jr.head = 0;
 119         jr.tail = 0;
 120         jr.read_idx = 0;
 121         jr.write_idx = 0;
 122         memset(jr.info, 0, sizeof(jr.info));
 123         memset(jr.input_ring, 0, jr.size * sizeof(dma_addr_t));
 124         memset(jr.output_ring, 0, jr.size * sizeof(struct op_ring));
 125
 126         return 0;
 127 }
 128
 129 static int jr_hw_reset(void)
 130 {
 131         struct jr_regs *regs = (struct jr_regs *)CONFIG_SYS_FSL_JR0_ADDR;
 132         uint32_t timeout = 100000;
 133         uint32_t jrint, jrcr;
 134
 135         sec_out32(&regs->jrcr, JRCR_RESET);
 136         do {
 137                 jrint = sec_in32(&regs->jrint);
 138         } while (((jrint & JRINT_ERR_HALT_MASK) ==
 139                   JRINT_ERR_HALT_INPROGRESS) && --timeout);
 140
 141         jrint = sec_in32(&regs->jrint);
 142         if (((jrint & JRINT_ERR_HALT_MASK) !=
 143              JRINT_ERR_HALT_INPROGRESS) && timeout == 0)
 144                 return -1;
 145
 146         timeout = 100000;
 147         sec_out32(&regs->jrcr, JRCR_RESET);
 148         do {
 149                 jrcr = sec_in32(&regs->jrcr);
 150         } while ((jrcr & JRCR_RESET) && --timeout);
 151
 152         if (timeout == 0)
 153                 return -1;
 154
 155         return 0;
 156 }
 157
 158 /* -1 --- error, can't enqueue -- no space available */
 159 static int jr_enqueue(uint32_t *desc_addr,
 160                void (*callback)(uint32_t status, void *arg),
 161                void *arg)
 162 {
 163         struct jr_regs *regs = (struct jr_regs *)CONFIG_SYS_FSL_JR0_ADDR;
 164         int head = jr.head;
 165         uint32_t desc_word;
 166         int length = desc_len(desc_addr);
 167         int i;
 168 #ifdef CONFIG_PHYS_64BIT
 169         uint32_t *addr_hi, *addr_lo;
 170 #endif
 171
 172         /* The descriptor must be submitted to SEC block as per endianness
 173          * of the SEC Block.
 174          * So, if the endianness of Core and SEC block is different, each word
 175          * of the descriptor will be byte-swapped.
 176          */
 177         for (i = 0; i < length; i++) {
 178                 desc_word = desc_addr[i];
 179                 sec_out32((uint32_t *)&desc_addr[i], desc_word);
 180         }
 181
 182         phys_addr_t desc_phys_addr = virt_to_phys(desc_addr);
 183
 184         if (sec_in32(&regs->irsa) == 0 ||
 185             CIRC_SPACE(jr.head, jr.tail, jr.size) <= 0)
 186                 return -1;
 187
 188         jr.info[head].desc_phys_addr = desc_phys_addr;
 189         jr.info[head].callback = (void *)callback;
 190         jr.info[head].arg = arg;
 191         jr.info[head].op_done = 0;
 192
 193         unsigned long start = (unsigned long)&jr.info[head] &
 194                                         ~(ARCH_DMA_MINALIGN - 1);
 195         unsigned long end = ALIGN((unsigned long)&jr.info[head] +
 196                                   sizeof(struct jr_info), ARCH_DMA_MINALIGN);
 197         flush_dcache_range(start, end);
 198
 199 #ifdef CONFIG_PHYS_64BIT
 200         /* Write the 64 bit Descriptor address on Input Ring.
 201          * The 32 bit hign and low part of the address will
 202          * depend on endianness of SEC block.
 203          */
 204 #ifdef CONFIG_SYS_FSL_SEC_LE
 205         addr_lo = (uint32_t *)(&jr.input_ring[head]);
 206         addr_hi = (uint32_t *)(&jr.input_ring[head]) + 1;
 207 #elif defined(CONFIG_SYS_FSL_SEC_BE)
 208         addr_hi = (uint32_t *)(&jr.input_ring[head]);
 209         addr_lo = (uint32_t *)(&jr.input_ring[head]) + 1;
 210 #endif /* ifdef CONFIG_SYS_FSL_SEC_LE */
 211
 212         sec_out32(addr_hi, (uint32_t)(desc_phys_addr >> 32));
 213         sec_out32(addr_lo, (uint32_t)(desc_phys_addr));
 214
 215 #else
 216         /* Write the 32 bit Descriptor address on Input Ring. */
 217         sec_out32(&jr.input_ring[head], desc_phys_addr);
 218 #endif /* ifdef CONFIG_PHYS_64BIT */
 219
 220         start = (unsigned long)&jr.input_ring[head] & ~(ARCH_DMA_MINALIGN - 1);
 221         end = ALIGN((unsigned long)&jr.input_ring[head] +
 222                      sizeof(dma_addr_t), ARCH_DMA_MINALIGN);
 223         flush_dcache_range(start, end);
 224
 225         jr.head = (head + 1) & (jr.size - 1);
 226
 227         /* Invalidate output ring */
 228         start = (unsigned long)jr.output_ring &
 229                                         ~(ARCH_DMA_MINALIGN - 1);
 230         end = ALIGN((unsigned long)jr.output_ring + jr.op_size,
 231                      ARCH_DMA_MINALIGN);
 232         invalidate_dcache_range(start, end);
 233
 234         sec_out32(&regs->irja, 1);
 235
 236         return 0;
 237 }
 238
 239 static int jr_dequeue(void)
 240 {
 241         struct jr_regs *regs = (struct jr_regs *)CONFIG_SYS_FSL_JR0_ADDR;
 242         int head = jr.head;
 243         int tail = jr.tail;
 244         int idx, i, found;
 245         void (*callback)(uint32_t status, void *arg);
 246         void *arg = NULL;
 247 #ifdef CONFIG_PHYS_64BIT
 248         uint32_t *addr_hi, *addr_lo;
 249 #else
 250         uint32_t *addr;
 251 #endif
 252
 253         while (sec_in32(&regs->orsf) && CIRC_CNT(jr.head, jr.tail, jr.size)) {
 254
 255                 found = 0;
 256
 257                 phys_addr_t op_desc;
 258         #ifdef CONFIG_PHYS_64BIT
 259                 /* Read the 64 bit Descriptor address from Output Ring.
 260                  * The 32 bit hign and low part of the address will
 261                  * depend on endianness of SEC block.
 262                  */
 263         #ifdef CONFIG_SYS_FSL_SEC_LE
 264                 addr_lo = (uint32_t *)(&jr.output_ring[jr.tail].desc);
 265                 addr_hi = (uint32_t *)(&jr.output_ring[jr.tail].desc) + 1;
 266         #elif defined(CONFIG_SYS_FSL_SEC_BE)
 267                 addr_hi = (uint32_t *)(&jr.output_ring[jr.tail].desc);
 268                 addr_lo = (uint32_t *)(&jr.output_ring[jr.tail].desc) + 1;
 269         #endif /* ifdef CONFIG_SYS_FSL_SEC_LE */
 270
 271                 op_desc = ((u64)sec_in32(addr_hi) << 32) |
 272                           ((u64)sec_in32(addr_lo));
 273
 274         #else
 275                 /* Read the 32 bit Descriptor address from Output Ring. */
 276                 addr = (uint32_t *)&jr.output_ring[jr.tail].desc;
 277                 op_desc = sec_in32(addr);
 278         #endif /* ifdef CONFIG_PHYS_64BIT */
 279
 280                 uint32_t status = sec_in32(&jr.output_ring[jr.tail].status);
 281
 282                 for (i = 0; CIRC_CNT(head, tail + i, jr.size) >= 1; i++) {
 283                         idx = (tail + i) & (jr.size - 1);
 284                         if (op_desc == jr.info[idx].desc_phys_addr) {
 285                                 found = 1;
 286                                 break;
 287                         }
 288                 }
 289
 290                 /* Error condition if match not found */
 291                 if (!found)
 292                         return -1;
 293
 294                 jr.info[idx].op_done = 1;
 295                 callback = (void *)jr.info[idx].callback;
 296                 arg = jr.info[idx].arg;
 297
 298                 /* When the job on tail idx gets done, increment
 299                  * tail till the point where job completed out of oredr has
 300                  * been taken into account
 301                  */
 302                 if (idx == tail)
 303                         do {
 304                                 tail = (tail + 1) & (jr.size - 1);
 305                         } while (jr.info[tail].op_done);
 306
 307                 jr.tail = tail;
 308                 jr.read_idx = (jr.read_idx + 1) & (jr.size - 1);
 309
 310                 sec_out32(&regs->orjr, 1);
 311                 jr.info[idx].op_done = 0;
 312
 313                 callback(status, arg);
 314         }
 315
 316         return 0;
 317 }
 318
 319 static void desc_done(uint32_t status, void *arg)
 320 {
 321         struct result *x = arg;
 322         x->status = status;
 323         caam_jr_strstatus(status);
 324         x->done = 1;
 325 }
 326
 327 int run_descriptor_jr(uint32_t *desc)
 328 {
 329         unsigned long long timeval = get_ticks();
 330         unsigned long long timeout = usec2ticks(CONFIG_SEC_DEQ_TIMEOUT);
 331         struct result op;
 332         int ret = 0;
 333
 334         memset(&op, 0, sizeof(op));
 335
 336         ret = jr_enqueue(desc, desc_done, &op);
 337         if (ret) {
 338                 debug("Error in SEC enq\n");
 339                 ret = JQ_ENQ_ERR;
 340                 goto out;
 341         }
 342
 343         timeval = get_ticks();
 344         timeout = usec2ticks(CONFIG_SEC_DEQ_TIMEOUT);
 345         while (op.done != 1) {
 346                 ret = jr_dequeue();
 347                 if (ret) {
 348                         debug("Error in SEC deq\n");
 349                         ret = JQ_DEQ_ERR;
 350                         goto out;
 351                 }
 352
 353                 if ((get_ticks() - timeval) > timeout) {
 354                         debug("SEC Dequeue timed out\n");
 355                         ret = JQ_DEQ_TO_ERR;
 356                         goto out;
 357                 }
 358         }
 359
 360         if (!op.status) {
 361                 debug("Error %x\n", op.status);
 362                 ret = op.status;
 363         }
 364 out:
 365         return ret;
 366 }
 367
 368 int jr_reset(void)
 369 {
 370         if (jr_hw_reset() < 0)
 371                 return -1;
 372
 373         /* Clean up the jobring structure maintained by software */
 374         jr_sw_cleanup();
 375
 376         return 0;
 377 }
 378
 379 int sec_reset(void)
 380 {
 381         ccsr_sec_t *sec = (void *)CONFIG_SYS_FSL_SEC_ADDR;
 382         uint32_t mcfgr = sec_in32(&sec->mcfgr);
 383         uint32_t timeout = 100000;
 384
 385         mcfgr |= MCFGR_SWRST;
 386         sec_out32(&sec->mcfgr, mcfgr);
 387
 388         mcfgr |= MCFGR_DMA_RST;
 389         sec_out32(&sec->mcfgr, mcfgr);
 390         do {
 391                 mcfgr = sec_in32(&sec->mcfgr);
 392         } while ((mcfgr & MCFGR_DMA_RST) == MCFGR_DMA_RST && --timeout);
 393
 394         if (timeout == 0)
 395                 return -1;
 396
 397         timeout = 100000;
 398         do {
 399                 mcfgr = sec_in32(&sec->mcfgr);
 400         } while ((mcfgr & MCFGR_SWRST) == MCFGR_SWRST && --timeout);
 401
 402         if (timeout == 0)
 403                 return -1;
 404
 405         return 0;
 406 }
 407
 408 static int instantiate_rng(void)
 409 {
 410         struct result op;
 411         u32 *desc;
 412         u32 rdsta_val;
 413         int ret = 0;
 414         ccsr_sec_t __iomem *sec =
 415                         (ccsr_sec_t __iomem *)CONFIG_SYS_FSL_SEC_ADDR;
 416         struct rng4tst __iomem *rng =
 417                         (struct rng4tst __iomem *)&sec->rng;
 418
 419         memset(&op, 0, sizeof(struct result));
 420
 421         desc = memalign(ARCH_DMA_MINALIGN, sizeof(uint32_t) * 6);
 422         if (!desc) {
 423                 printf("cannot allocate RNG init descriptor memory\n");
 424                 return -1;
 425         }
 426
 427         inline_cnstr_jobdesc_rng_instantiation(desc);
 428         int size = roundup(sizeof(uint32_t) * 6, ARCH_DMA_MINALIGN);
 429         flush_dcache_range((unsigned long)desc,
 430                            (unsigned long)desc + size);
 431
 432         ret = run_descriptor_jr(desc);
 433
 434         if (ret)
 435                 printf("RNG: Instantiation failed with error %x\n", ret);
 436
 437         rdsta_val = sec_in32(&rng->rdsta);
 438         if (op.status || !(rdsta_val & RNG_STATE0_HANDLE_INSTANTIATED))
 439                 return -1;
 440
 441         return ret;
 442 }
 443
 444 static u8 get_rng_vid(void)
 445 {
 446         ccsr_sec_t *sec = (void *)CONFIG_SYS_FSL_SEC_ADDR;
 447         u32 cha_vid = sec_in32(&sec->chavid_ls);
 448
 449         return (cha_vid & SEC_CHAVID_RNG_LS_MASK) >> SEC_CHAVID_LS_RNG_SHIFT;
 450 }
 451
 452 /*
 453  * By default, the TRNG runs for 200 clocks per sample;
 454  * 1200 clocks per sample generates better entropy.
 455  */
 456 static void kick_trng(int ent_delay)
 457 {
 458         ccsr_sec_t __iomem *sec =
 459                         (ccsr_sec_t __iomem *)CONFIG_SYS_FSL_SEC_ADDR;
 460         struct rng4tst __iomem *rng =
 461                         (struct rng4tst __iomem *)&sec->rng;
 462         u32 val;
 463
 464         /* put RNG4 into program mode */
 465         sec_setbits32(&rng->rtmctl, RTMCTL_PRGM);
 466         /* rtsdctl bits 0-15 contain "Entropy Delay, which defines the
 467          * length (in system clocks) of each Entropy sample taken
 468          * */
 469         val = sec_in32(&rng->rtsdctl);
 470         val = (val & ~RTSDCTL_ENT_DLY_MASK) |
 471               (ent_delay << RTSDCTL_ENT_DLY_SHIFT);
 472         sec_out32(&rng->rtsdctl, val);
 473         /* min. freq. count, equal to 1/4 of the entropy sample length */
 474         sec_out32(&rng->rtfreqmin, ent_delay >> 2);
 475         /* disable maximum frequency count */
 476         sec_out32(&rng->rtfreqmax, RTFRQMAX_DISABLE);
 477         /*
 478          * select raw sampling in both entropy shifter
 479          * and statistical checker
 480          */
 481         sec_setbits32(&rng->rtmctl, RTMCTL_SAMP_MODE_RAW_ES_SC);
 482         /* put RNG4 into run mode */
 483         sec_clrbits32(&rng->rtmctl, RTMCTL_PRGM);
 484 }
 485
 486 static int rng_init(void)
 487 {
 488         int ret, ent_delay = RTSDCTL_ENT_DLY_MIN;
 489         ccsr_sec_t __iomem *sec =
 490                         (ccsr_sec_t __iomem *)CONFIG_SYS_FSL_SEC_ADDR;
 491         struct rng4tst __iomem *rng =
 492                         (struct rng4tst __iomem *)&sec->rng;
 493
 494         u32 rdsta = sec_in32(&rng->rdsta);
 495
 496         /* Check if RNG state 0 handler is already instantiated */
 497         if (rdsta & RNG_STATE0_HANDLE_INSTANTIATED)
 498                 return 0;
 499
 500         do {
 501                 /*
 502                  * If either of the SH's were instantiated by somebody else
 503                  * then it is assumed that the entropy
 504                  * parameters are properly set and thus the function
 505                  * setting these (kick_trng(...)) is skipped.
 506                  * Also, if a handle was instantiated, do not change
 507                  * the TRNG parameters.
 508                  */
 509                 kick_trng(ent_delay);
 510                 ent_delay += 400;
 511                 /*
 512                  * if instantiate_rng(...) fails, the loop will rerun
 513                  * and the kick_trng(...) function will modfiy the
 514                  * upper and lower limits of the entropy sampling
 515                  * interval, leading to a sucessful initialization of
 516                  * the RNG.
 517                  */
 518                 ret = instantiate_rng();
 519         } while ((ret == -1) && (ent_delay < RTSDCTL_ENT_DLY_MAX));
 520         if (ret) {
 521                 printf("RNG: Failed to instantiate RNG\n");
 522                 return ret;
 523         }
 524
 525          /* Enable RDB bit so that RNG works faster */
 526         sec_setbits32(&sec->scfgr, SEC_SCFGR_RDBENABLE);
 527
 528         return ret;
 529 }
 530
 531 int sec_init(void)
 532 {
 533         ccsr_sec_t *sec = (void *)CONFIG_SYS_FSL_SEC_ADDR;
 534         uint32_t mcr = sec_in32(&sec->mcfgr);
 535         int ret = 0;
 536
 537         mcr = (mcr & ~MCFGR_AWCACHE_MASK) | (0x2 << MCFGR_AWCACHE_SHIFT);
 538 #ifdef CONFIG_PHYS_64BIT
 539         mcr |= (1 << MCFGR_PS_SHIFT);
 540 #endif
 541         sec_out32(&sec->mcfgr, mcr);
 542
 543         ret = jr_init();
 544         if (ret < 0) {
 545                 printf("SEC initialization failed\n");
 546                 return -1;
 547         }
 548
 549         if (get_rng_vid() >= 4) {
 550                 if (rng_init() < 0) {
 551                         printf("RNG instantiation failed\n");
 552                         return -1;
 553                 }
 554                 printf("SEC: RNG instantiated\n");
 555         }
 556
 557         return ret;
 558 }