drivers/qe/qe.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (C) 2006-2009 Freescale Semiconductor, Inc.
   4  *
   5  * Dave Liu <daveliu@freescale.com>
   6  * based on source code of Shlomi Gridish
   7  */
   8
   9 #include <common.h>
  10 #include <malloc.h>
  11 #include <command.h>
  12 #include <linux/errno.h>
  13 #include <asm/io.h>
  14 #include <linux/immap_qe.h>
  15 #include <fsl_qe.h>
  16 #include <mmc.h>
  17 #include <u-boot/crc.h>
  18
  19 #ifdef CONFIG_ARCH_LS1021A
  20 #include <asm/arch/immap_ls102xa.h>
  21 #endif
  22 #ifdef CONFIG_ARM64
  23 #include <asm/armv8/mmu.h>
  24 #include <asm/arch/cpu.h>
  25 #endif
  26
  27 #define MPC85xx_DEVDISR_QE_DISABLE      0x1
  28
  29 qe_map_t                *qe_immr;
  30 #ifdef CONFIG_QE
  31 static qe_snum_t        snums[QE_NUM_OF_SNUM];
  32 #endif
  33
  34 DECLARE_GLOBAL_DATA_PTR;
  35
  36 void qe_issue_cmd(uint cmd, uint sbc, u8 mcn, u32 cmd_data)
  37 {
  38         u32 cecr;
  39
  40         if (cmd == QE_RESET) {
  41                 out_be32(&qe_immr->cp.cecr, (u32)(cmd | QE_CR_FLG));
  42         } else {
  43                 out_be32(&qe_immr->cp.cecdr, cmd_data);
  44                 out_be32(&qe_immr->cp.cecr, (sbc | QE_CR_FLG |
  45                          ((u32)mcn << QE_CR_PROTOCOL_SHIFT) | cmd));
  46         }
  47         /* Wait for the QE_CR_FLG to clear */
  48         do {
  49                 cecr = in_be32(&qe_immr->cp.cecr);
  50         } while (cecr & QE_CR_FLG);
  51 }
  52
  53 #ifdef CONFIG_QE
  54 uint qe_muram_alloc(uint size, uint align)
  55 {
  56         uint    retloc;
  57         uint    align_mask, off;
  58         uint    savebase;
  59
  60         align_mask = align - 1;
  61         savebase = gd->arch.mp_alloc_base;
  62
  63         off = gd->arch.mp_alloc_base & align_mask;
  64         if (off != 0)
  65                 gd->arch.mp_alloc_base += (align - off);
  66
  67         off = size & align_mask;
  68         if (off != 0)
  69                 size += (align - off);
  70
  71         if ((gd->arch.mp_alloc_base + size) >= gd->arch.mp_alloc_top) {
  72                 gd->arch.mp_alloc_base = savebase;
  73                 printf("%s: ran out of ram.\n",  __func__);
  74         }
  75
  76         retloc = gd->arch.mp_alloc_base;
  77         gd->arch.mp_alloc_base += size;
  78
  79         memset((void *)&qe_immr->muram[retloc], 0, size);
  80
  81         __asm__ __volatile__("sync");
  82
  83         return retloc;
  84 }
  85 #endif
  86
  87 void *qe_muram_addr(uint offset)
  88 {
  89         return (void *)&qe_immr->muram[offset];
  90 }
  91
  92 #ifdef CONFIG_QE
  93 static void qe_sdma_init(void)
  94 {
  95         sdma_t  *p;
  96         uint    sdma_buffer_base;
  97
  98         p = (sdma_t *)&qe_immr->sdma;
  99
 100         /* All of DMA transaction in bus 1 */
 101         out_be32(&p->sdaqr, 0);
 102         out_be32(&p->sdaqmr, 0);
 103
 104         /* Allocate 2KB temporary buffer for sdma */
 105         sdma_buffer_base = qe_muram_alloc(2048, 4096);
 106         out_be32(&p->sdwbcr, sdma_buffer_base & QE_SDEBCR_BA_MASK);
 107
 108         /* Clear sdma status */
 109         out_be32(&p->sdsr, 0x03000000);
 110
 111         /* Enable global mode on bus 1, and 2KB buffer size */
 112         out_be32(&p->sdmr, QE_SDMR_GLB_1_MSK | (0x3 << QE_SDMR_CEN_SHIFT));
 113 }
 114
 115 /* This table is a list of the serial numbers of the Threads, taken from the
 116  * "SNUM Table" chart in the QE Reference Manual. The order is not important,
 117  * we just need to know what the SNUMs are for the threads.
 118  */
 119 static u8 thread_snum[] = {
 120 /* Evthreads 16-29 are not supported in MPC8309 */
 121 #if !defined(CONFIG_ARCH_MPC8309)
 122         0x04, 0x05, 0x0c, 0x0d,
 123         0x14, 0x15, 0x1c, 0x1d,
 124         0x24, 0x25, 0x2c, 0x2d,
 125         0x34, 0x35,
 126 #endif
 127         0x88, 0x89, 0x98, 0x99,
 128         0xa8, 0xa9, 0xb8, 0xb9,
 129         0xc8, 0xc9, 0xd8, 0xd9,
 130         0xe8, 0xe9, 0x08, 0x09,
 131         0x18, 0x19, 0x28, 0x29,
 132         0x38, 0x39, 0x48, 0x49,
 133         0x58, 0x59, 0x68, 0x69,
 134         0x78, 0x79, 0x80, 0x81
 135 };
 136
 137 static void qe_snums_init(void)
 138 {
 139         int     i;
 140
 141         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
 142                 snums[i].state = QE_SNUM_STATE_FREE;
 143                 snums[i].num   = thread_snum[i];
 144         }
 145 }
 146
 147 int qe_get_snum(void)
 148 {
 149         int     snum = -EBUSY;
 150         int     i;
 151
 152         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
 153                 if (snums[i].state == QE_SNUM_STATE_FREE) {
 154                         snums[i].state = QE_SNUM_STATE_USED;
 155                         snum = snums[i].num;
 156                         break;
 157                 }
 158         }
 159
 160         return snum;
 161 }
 162
 163 void qe_put_snum(u8 snum)
 164 {
 165         int     i;
 166
 167         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
 168                 if (snums[i].num == snum) {
 169                         snums[i].state = QE_SNUM_STATE_FREE;
 170                         break;
 171                 }
 172         }
 173 }
 174
 175 #ifdef CONFIG_TFABOOT
 176 void qe_init(uint qe_base)
 177 {
 178         enum boot_src src = get_boot_src();
 179
 180         /* Init the QE IMMR base */
 181         qe_immr = (qe_map_t *)qe_base;
 182
 183         if (src == BOOT_SOURCE_IFC_NOR) {
 184                 /*
 185                  * Upload microcode to IRAM for those SOCs
 186                  * which do not have ROM in QE.
 187                  */
 188                 qe_upload_firmware((const void *)(CONFIG_SYS_QE_FW_ADDR +
 189                                    CONFIG_SYS_FSL_IFC_BASE));
 190
 191                 /* enable the microcode in IRAM */
 192                 out_be32(&qe_immr->iram.iready, QE_IRAM_READY);
 193         }
 194
 195         gd->arch.mp_alloc_base = QE_DATAONLY_BASE;
 196         gd->arch.mp_alloc_top = gd->arch.mp_alloc_base + QE_DATAONLY_SIZE;
 197
 198         qe_sdma_init();
 199         qe_snums_init();
 200 }
 201 #else
 202 void qe_init(uint qe_base)
 203 {
 204         /* Init the QE IMMR base */
 205         qe_immr = (qe_map_t *)qe_base;
 206
 207 #ifdef CONFIG_SYS_QE_FMAN_FW_IN_NOR
 208         /*
 209          * Upload microcode to IRAM for those SOCs which do not have ROM in QE.
 210          */
 211         qe_upload_firmware((const void *)CONFIG_SYS_QE_FW_ADDR);
 212
 213         /* enable the microcode in IRAM */
 214         out_be32(&qe_immr->iram.iready, QE_IRAM_READY);
 215 #endif
 216
 217         gd->arch.mp_alloc_base = QE_DATAONLY_BASE;
 218         gd->arch.mp_alloc_top = gd->arch.mp_alloc_base + QE_DATAONLY_SIZE;
 219
 220         qe_sdma_init();
 221         qe_snums_init();
 222 }
 223 #endif
 224 #endif
 225
 226 #ifdef CONFIG_U_QE
 227 #ifdef CONFIG_TFABOOT
 228 void u_qe_init(void)
 229 {
 230         enum boot_src src = get_boot_src();
 231
 232         qe_immr = (qe_map_t *)(CONFIG_SYS_IMMR + QE_IMMR_OFFSET);
 233
 234         void *addr = (void *)CONFIG_SYS_QE_FW_ADDR;
 235
 236         if (src == BOOT_SOURCE_IFC_NOR)
 237                 addr = (void *)(CONFIG_SYS_QE_FW_ADDR +
 238                                 CONFIG_SYS_FSL_IFC_BASE);
 239
 240         if (src == BOOT_SOURCE_QSPI_NOR)
 241                 addr = (void *)(CONFIG_SYS_QE_FW_ADDR +
 242                                 CONFIG_SYS_FSL_QSPI_BASE);
 243
 244         if (src == BOOT_SOURCE_SD_MMC) {
 245                 int dev = CONFIG_SYS_MMC_ENV_DEV;
 246                 u32 cnt = CONFIG_SYS_QE_FMAN_FW_LENGTH / 512;
 247                 u32 blk = CONFIG_SYS_QE_FW_ADDR / 512;
 248
 249                 if (mmc_initialize(gd->bd)) {
 250                         printf("%s: mmc_initialize() failed\n", __func__);
 251                         return;
 252                 }
 253                 addr = malloc(CONFIG_SYS_QE_FMAN_FW_LENGTH);
 254                 struct mmc *mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV);
 255
 256                 if (!mmc) {
 257                         free(addr);
 258                         printf("\nMMC cannot find device for ucode\n");
 259                 } else {
 260                         printf("\nMMC read: dev # %u, block # %u, count %u ...\n",
 261                                dev, blk, cnt);
 262                         mmc_init(mmc);
 263                         (void)blk_dread(mmc_get_blk_desc(mmc), blk, cnt,
 264                                                 addr);
 265                 }
 266         }
 267         if (!u_qe_upload_firmware(addr))
 268                 out_be32(&qe_immr->iram.iready, QE_IRAM_READY);
 269         if (src == BOOT_SOURCE_SD_MMC)
 270                 free(addr);
 271 }
 272 #else
 273 void u_qe_init(void)
 274 {
 275         qe_immr = (qe_map_t *)(CONFIG_SYS_IMMR + QE_IMMR_OFFSET);
 276
 277         void *addr = (void *)CONFIG_SYS_QE_FW_ADDR;
 278 #ifdef CONFIG_SYS_QE_FMAN_FW_IN_MMC
 279         int dev = CONFIG_SYS_MMC_ENV_DEV;
 280         u32 cnt = CONFIG_SYS_QE_FMAN_FW_LENGTH / 512;
 281         u32 blk = CONFIG_SYS_QE_FW_ADDR / 512;
 282
 283         if (mmc_initialize(gd->bd)) {
 284                 printf("%s: mmc_initialize() failed\n", __func__);
 285                 return;
 286         }
 287         addr = malloc(CONFIG_SYS_QE_FMAN_FW_LENGTH);
 288         struct mmc *mmc = find_mmc_device(CONFIG_SYS_MMC_ENV_DEV);
 289
 290         if (!mmc) {
 291                 printf("\nMMC cannot find device for ucode\n");
 292         } else {
 293                 printf("\nMMC read: dev # %u, block # %u, count %u ...\n",
 294                        dev, blk, cnt);
 295                 mmc_init(mmc);
 296                 (void)blk_dread(mmc_get_blk_desc(mmc), blk, cnt,
 297                                                 addr);
 298         }
 299 #endif
 300         if (!u_qe_upload_firmware(addr))
 301                 out_be32(&qe_immr->iram.iready, QE_IRAM_READY);
 302 #ifdef CONFIG_SYS_QE_FMAN_FW_IN_MMC
 303         free(addr);
 304 #endif
 305 }
 306 #endif
 307 #endif
 308
 309 #ifdef CONFIG_U_QE
 310 void u_qe_resume(void)
 311 {
 312         qe_map_t *qe_immrr;
 313
 314         qe_immrr = (qe_map_t *)(CONFIG_SYS_IMMR + QE_IMMR_OFFSET);
 315         u_qe_firmware_resume((const void *)CONFIG_SYS_QE_FW_ADDR, qe_immrr);
 316         out_be32(&qe_immrr->iram.iready, QE_IRAM_READY);
 317 }
 318 #endif
 319
 320 void qe_reset(void)
 321 {
 322         qe_issue_cmd(QE_RESET, QE_CR_SUBBLOCK_INVALID,
 323                      (u8)QE_CR_PROTOCOL_UNSPECIFIED, 0);
 324 }
 325
 326 #ifdef CONFIG_QE
 327 void qe_assign_page(uint snum, uint para_ram_base)
 328 {
 329         u32     cecr;
 330
 331         out_be32(&qe_immr->cp.cecdr, para_ram_base);
 332         out_be32(&qe_immr->cp.cecr, ((u32)snum << QE_CR_ASSIGN_PAGE_SNUM_SHIFT)
 333                                          | QE_CR_FLG | QE_ASSIGN_PAGE);
 334
 335         /* Wait for the QE_CR_FLG to clear */
 336         do {
 337                 cecr = in_be32(&qe_immr->cp.cecr);
 338         } while (cecr & QE_CR_FLG);
 339 }
 340 #endif
 341
 342 /*
 343  * brg: 0~15 as BRG1~BRG16
 344  * rate: baud rate
 345  * BRG input clock comes from the BRGCLK (internal clock generated from
 346  * the QE clock, it is one-half of the QE clock), If need the clock source
 347  * from CLKn pin, we have te change the function.
 348  */
 349
 350 #define BRG_CLK         (gd->arch.brg_clk)
 351
 352 #ifdef CONFIG_QE
 353 int qe_set_brg(uint brg, uint rate)
 354 {
 355         uint    *bp;
 356         u32     divisor;
 357         u32     val;
 358         int     div16 = 0;
 359
 360         if (brg >= QE_NUM_OF_BRGS)
 361                 return -EINVAL;
 362
 363         bp = (uint *)&qe_immr->brg.brgc1;
 364         bp += brg;
 365
 366         divisor = (BRG_CLK / rate);
 367         if (divisor > QE_BRGC_DIVISOR_MAX + 1) {
 368                 div16 = 1;
 369                 divisor /= 16;
 370         }
 371
 372         /* CHECK TODO */
 373         /*
 374          * was
 375          * *bp = ((divisor - 1) << QE_BRGC_DIVISOR_SHIFT) | QE_BRGC_ENABLE;
 376          * __asm__ __volatile__("sync");
 377          */
 378
 379         val = ((divisor - 1) << QE_BRGC_DIVISOR_SHIFT) | QE_BRGC_ENABLE;
 380         if (div16)
 381                 val |= QE_BRGC_DIV16;
 382
 383         out_be32(bp, val);
 384
 385         return 0;
 386 }
 387 #endif
 388
 389 /* Set ethernet MII clock master */
 390 int qe_set_mii_clk_src(int ucc_num)
 391 {
 392         u32     cmxgcr;
 393
 394         /* check if the UCC number is in range. */
 395         if ((ucc_num > UCC_MAX_NUM - 1) || ucc_num < 0) {
 396                 printf("%s: ucc num not in ranges\n", __func__);
 397                 return -EINVAL;
 398         }
 399
 400         cmxgcr = in_be32(&qe_immr->qmx.cmxgcr);
 401         cmxgcr &= ~QE_CMXGCR_MII_ENET_MNG_MASK;
 402         cmxgcr |= (ucc_num << QE_CMXGCR_MII_ENET_MNG_SHIFT);
 403         out_be32(&qe_immr->qmx.cmxgcr, cmxgcr);
 404
 405         return 0;
 406 }
 407
 408 /* Firmware information stored here for qe_get_firmware_info() */
 409 static struct qe_firmware_info qe_firmware_info;
 410
 411 /*
 412  * Set to 1 if QE firmware has been uploaded, and therefore
 413  * qe_firmware_info contains valid data.
 414  */
 415 static int qe_firmware_uploaded;
 416
 417 /*
 418  * Upload a QE microcode
 419  *
 420  * This function is a worker function for qe_upload_firmware().  It does
 421  * the actual uploading of the microcode.
 422  */
 423 static void qe_upload_microcode(const void *base,
 424                                 const struct qe_microcode *ucode)
 425 {
 426         const u32 *code = base + be32_to_cpu(ucode->code_offset);
 427         unsigned int i;
 428
 429         if (ucode->major || ucode->minor || ucode->revision)
 430                 printf("QE: uploading microcode '%s' version %u.%u.%u\n",
 431                        (char *)ucode->id, (u16)ucode->major, (u16)ucode->minor,
 432                        (u16)ucode->revision);
 433         else
 434                 printf("QE: uploading microcode '%s'\n", (char *)ucode->id);
 435
 436         /* Use auto-increment */
 437         out_be32(&qe_immr->iram.iadd, be32_to_cpu(ucode->iram_offset) |
 438                 QE_IRAM_IADD_AIE | QE_IRAM_IADD_BADDR);
 439
 440         for (i = 0; i < be32_to_cpu(ucode->count); i++)
 441                 out_be32(&qe_immr->iram.idata, be32_to_cpu(code[i]));
 442 }
 443
 444 /*
 445  * Upload a microcode to the I-RAM at a specific address.
 446  *
 447  * See Documentation/powerpc/qe_firmware.rst in the Linux kernel tree for
 448  * information on QE microcode uploading.
 449  *
 450  * Currently, only version 1 is supported, so the 'version' field must be
 451  * set to 1.
 452  *
 453  * The SOC model and revision are not validated, they are only displayed for
 454  * informational purposes.
 455  *
 456  * 'calc_size' is the calculated size, in bytes, of the firmware structure and
 457  * all of the microcode structures, minus the CRC.
 458  *
 459  * 'length' is the size that the structure says it is, including the CRC.
 460  */
 461 int qe_upload_firmware(const struct qe_firmware *firmware)
 462 {
 463         unsigned int i;
 464         unsigned int j;
 465         u32 crc;
 466         size_t calc_size = sizeof(struct qe_firmware);
 467         size_t length;
 468         const struct qe_header *hdr;
 469 #ifdef CONFIG_DEEP_SLEEP
 470 #ifdef CONFIG_ARCH_LS1021A
 471         struct ccsr_gur __iomem *gur = (void *)CONFIG_SYS_FSL_GUTS_ADDR;
 472 #else
 473         ccsr_gur_t *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
 474 #endif
 475 #endif
 476         if (!firmware) {
 477                 printf("Invalid address\n");
 478                 return -EINVAL;
 479         }
 480
 481         hdr = &firmware->header;
 482         length = be32_to_cpu(hdr->length);
 483
 484         /* Check the magic */
 485         if ((hdr->magic[0] != 'Q') || (hdr->magic[1] != 'E') ||
 486             (hdr->magic[2] != 'F')) {
 487                 printf("QE microcode not found\n");
 488 #ifdef CONFIG_DEEP_SLEEP
 489                 setbits_be32(&gur->devdisr, MPC85xx_DEVDISR_QE_DISABLE);
 490 #endif
 491                 return -EPERM;
 492         }
 493
 494         /* Check the version */
 495         if (hdr->version != 1) {
 496                 printf("Unsupported version\n");
 497                 return -EPERM;
 498         }
 499
 500         /* Validate some of the fields */
 501         if (firmware->count < 1 || firmware->count > MAX_QE_RISC) {
 502                 printf("Invalid data\n");
 503                 return -EINVAL;
 504         }
 505
 506         /* Validate the length and check if there's a CRC */
 507         calc_size += (firmware->count - 1) * sizeof(struct qe_microcode);
 508
 509         for (i = 0; i < firmware->count; i++)
 510                 /*
 511                  * For situations where the second RISC uses the same microcode
 512                  * as the first, the 'code_offset' and 'count' fields will be
 513                  * zero, so it's okay to add those.
 514                  */
 515                 calc_size += sizeof(u32) *
 516                         be32_to_cpu(firmware->microcode[i].count);
 517
 518         /* Validate the length */
 519         if (length != calc_size + sizeof(u32)) {
 520                 printf("Invalid length\n");
 521                 return -EPERM;
 522         }
 523
 524         /*
 525          * Validate the CRC.  We would normally call crc32_no_comp(), but that
 526          * function isn't available unless you turn on JFFS support.
 527          */
 528         crc = be32_to_cpu(*(u32 *)((void *)firmware + calc_size));
 529         if (crc != (crc32(-1, (const void *)firmware, calc_size) ^ -1)) {
 530                 printf("Firmware CRC is invalid\n");
 531                 return -EIO;
 532         }
 533
 534         /*
 535          * If the microcode calls for it, split the I-RAM.
 536          */
 537         if (!firmware->split) {
 538                 out_be16(&qe_immr->cp.cercr,
 539                          in_be16(&qe_immr->cp.cercr) | QE_CP_CERCR_CIR);
 540         }
 541
 542         if (firmware->soc.model)
 543                 printf("Firmware '%s' for %u V%u.%u\n",
 544                        firmware->id, be16_to_cpu(firmware->soc.model),
 545                         firmware->soc.major, firmware->soc.minor);
 546         else
 547                 printf("Firmware '%s'\n", firmware->id);
 548
 549         /*
 550          * The QE only supports one microcode per RISC, so clear out all the
 551          * saved microcode information and put in the new.
 552          */
 553         memset(&qe_firmware_info, 0, sizeof(qe_firmware_info));
 554         strncpy(qe_firmware_info.id, (char *)firmware->id, 62);
 555         qe_firmware_info.extended_modes = firmware->extended_modes;
 556         memcpy(qe_firmware_info.vtraps, firmware->vtraps,
 557                sizeof(firmware->vtraps));
 558         qe_firmware_uploaded = 1;
 559
 560         /* Loop through each microcode. */
 561         for (i = 0; i < firmware->count; i++) {
 562                 const struct qe_microcode *ucode = &firmware->microcode[i];
 563
 564                 /* Upload a microcode if it's present */
 565                 if (ucode->code_offset)
 566                         qe_upload_microcode(firmware, ucode);
 567
 568                 /* Program the traps for this processor */
 569                 for (j = 0; j < 16; j++) {
 570                         u32 trap = be32_to_cpu(ucode->traps[j]);
 571
 572                         if (trap)
 573                                 out_be32(&qe_immr->rsp[i].tibcr[j], trap);
 574                 }
 575
 576                 /* Enable traps */
 577                 out_be32(&qe_immr->rsp[i].eccr, be32_to_cpu(ucode->eccr));
 578         }
 579
 580         return 0;
 581 }
 582
 583 #ifdef CONFIG_U_QE
 584 /*
 585  * Upload a microcode to the I-RAM at a specific address.
 586  *
 587  * See Documentation/powerpc/qe_firmware.rst in the Linux kernel tree for
 588  * information on QE microcode uploading.
 589  *
 590  * Currently, only version 1 is supported, so the 'version' field must be
 591  * set to 1.
 592  *
 593  * The SOC model and revision are not validated, they are only displayed for
 594  * informational purposes.
 595  *
 596  * 'calc_size' is the calculated size, in bytes, of the firmware structure and
 597  * all of the microcode structures, minus the CRC.
 598  *
 599  * 'length' is the size that the structure says it is, including the CRC.
 600  */
 601 int u_qe_upload_firmware(const struct qe_firmware *firmware)
 602 {
 603         unsigned int i;
 604         unsigned int j;
 605         u32 crc;
 606         size_t calc_size = sizeof(struct qe_firmware);
 607         size_t length;
 608         const struct qe_header *hdr;
 609 #ifdef CONFIG_DEEP_SLEEP
 610 #ifdef CONFIG_ARCH_LS1021A
 611         struct ccsr_gur __iomem *gur = (void *)CONFIG_SYS_FSL_GUTS_ADDR;
 612 #else
 613         ccsr_gur_t __iomem *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
 614 #endif
 615 #endif
 616         if (!firmware) {
 617                 printf("Invalid address\n");
 618                 return -EINVAL;
 619         }
 620
 621         hdr = &firmware->header;
 622         length = be32_to_cpu(hdr->length);
 623
 624         /* Check the magic */
 625         if ((hdr->magic[0] != 'Q') || (hdr->magic[1] != 'E') ||
 626             (hdr->magic[2] != 'F')) {
 627                 printf("Not a microcode\n");
 628 #ifdef CONFIG_DEEP_SLEEP
 629                 setbits_be32(&gur->devdisr, MPC85xx_DEVDISR_QE_DISABLE);
 630 #endif
 631                 return -EPERM;
 632         }
 633
 634         /* Check the version */
 635         if (hdr->version != 1) {
 636                 printf("Unsupported version\n");
 637                 return -EPERM;
 638         }
 639
 640         /* Validate some of the fields */
 641         if (firmware->count < 1 || firmware->count > MAX_QE_RISC) {
 642                 printf("Invalid data\n");
 643                 return -EINVAL;
 644         }
 645
 646         /* Validate the length and check if there's a CRC */
 647         calc_size += (firmware->count - 1) * sizeof(struct qe_microcode);
 648
 649         for (i = 0; i < firmware->count; i++)
 650                 /*
 651                  * For situations where the second RISC uses the same microcode
 652                  * as the first, the 'code_offset' and 'count' fields will be
 653                  * zero, so it's okay to add those.
 654                  */
 655                 calc_size += sizeof(u32) *
 656                         be32_to_cpu(firmware->microcode[i].count);
 657
 658         /* Validate the length */
 659         if (length != calc_size + sizeof(u32)) {
 660                 printf("Invalid length\n");
 661                 return -EPERM;
 662         }
 663
 664         /*
 665          * Validate the CRC.  We would normally call crc32_no_comp(), but that
 666          * function isn't available unless you turn on JFFS support.
 667          */
 668         crc = be32_to_cpu(*(u32 *)((void *)firmware + calc_size));
 669         if (crc != (crc32(-1, (const void *)firmware, calc_size) ^ -1)) {
 670                 printf("Firmware CRC is invalid\n");
 671                 return -EIO;
 672         }
 673
 674         /*
 675          * If the microcode calls for it, split the I-RAM.
 676          */
 677         if (!firmware->split) {
 678                 out_be16(&qe_immr->cp.cercr,
 679                          in_be16(&qe_immr->cp.cercr) | QE_CP_CERCR_CIR);
 680         }
 681
 682         if (firmware->soc.model)
 683                 printf("Firmware '%s' for %u V%u.%u\n",
 684                        firmware->id, be16_to_cpu(firmware->soc.model),
 685                        firmware->soc.major, firmware->soc.minor);
 686         else
 687                 printf("Firmware '%s'\n", firmware->id);
 688
 689         /* Loop through each microcode. */
 690         for (i = 0; i < firmware->count; i++) {
 691                 const struct qe_microcode *ucode = &firmware->microcode[i];
 692
 693                 /* Upload a microcode if it's present */
 694                 if (ucode->code_offset)
 695                         qe_upload_microcode(firmware, ucode);
 696
 697                 /* Program the traps for this processor */
 698                 for (j = 0; j < 16; j++) {
 699                         u32 trap = be32_to_cpu(ucode->traps[j]);
 700
 701                         if (trap)
 702                                 out_be32(&qe_immr->rsp[i].tibcr[j], trap);
 703                 }
 704
 705                 /* Enable traps */
 706                 out_be32(&qe_immr->rsp[i].eccr, be32_to_cpu(ucode->eccr));
 707         }
 708
 709         return 0;
 710 }
 711 #endif
 712
 713 #ifdef CONFIG_U_QE
 714 int u_qe_firmware_resume(const struct qe_firmware *firmware, qe_map_t *qe_immrr)
 715 {
 716         unsigned int i;
 717         unsigned int j;
 718         const struct qe_header *hdr;
 719         const u32 *code;
 720 #ifdef CONFIG_DEEP_SLEEP
 721 #ifdef CONFIG_PPC
 722         ccsr_gur_t __iomem *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
 723 #else
 724         struct ccsr_gur __iomem *gur = (void *)CONFIG_SYS_FSL_GUTS_ADDR;
 725 #endif
 726 #endif
 727
 728         if (!firmware)
 729                 return -EINVAL;
 730
 731         hdr = &firmware->header;
 732
 733         /* Check the magic */
 734         if ((hdr->magic[0] != 'Q') || (hdr->magic[1] != 'E') ||
 735             (hdr->magic[2] != 'F')) {
 736 #ifdef CONFIG_DEEP_SLEEP
 737                 setbits_be32(&gur->devdisr, MPC85xx_DEVDISR_QE_DISABLE);
 738 #endif
 739                 return -EPERM;
 740         }
 741
 742         /*
 743          * If the microcode calls for it, split the I-RAM.
 744          */
 745         if (!firmware->split) {
 746                 out_be16(&qe_immrr->cp.cercr,
 747                          in_be16(&qe_immrr->cp.cercr) | QE_CP_CERCR_CIR);
 748         }
 749
 750         /* Loop through each microcode. */
 751         for (i = 0; i < firmware->count; i++) {
 752                 const struct qe_microcode *ucode = &firmware->microcode[i];
 753
 754                 /* Upload a microcode if it's present */
 755                 if (!ucode->code_offset)
 756                         return 0;
 757
 758                 code = (const void *)firmware + be32_to_cpu(ucode->code_offset);
 759
 760                 /* Use auto-increment */
 761                 out_be32(&qe_immrr->iram.iadd, be32_to_cpu(ucode->iram_offset) |
 762                         QE_IRAM_IADD_AIE | QE_IRAM_IADD_BADDR);
 763
 764                 for (i = 0; i < be32_to_cpu(ucode->count); i++)
 765                         out_be32(&qe_immrr->iram.idata, be32_to_cpu(code[i]));
 766
 767                 /* Program the traps for this processor */
 768                 for (j = 0; j < 16; j++) {
 769                         u32 trap = be32_to_cpu(ucode->traps[j]);
 770
 771                         if (trap)
 772                                 out_be32(&qe_immrr->rsp[i].tibcr[j], trap);
 773                 }
 774
 775                 /* Enable traps */
 776                 out_be32(&qe_immrr->rsp[i].eccr, be32_to_cpu(ucode->eccr));
 777         }
 778
 779         return 0;
 780 }
 781 #endif
 782
 783 struct qe_firmware_info *qe_get_firmware_info(void)
 784 {
 785         return qe_firmware_uploaded ? &qe_firmware_info : NULL;
 786 }
 787
 788 static int qe_cmd(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 789 {
 790         ulong addr;
 791
 792         if (argc < 3)
 793                 return cmd_usage(cmdtp);
 794
 795         if (strcmp(argv[1], "fw") == 0) {
 796                 addr = simple_strtoul(argv[2], NULL, 16);
 797
 798                 if (!addr) {
 799                         printf("Invalid address\n");
 800                         return -EINVAL;
 801                 }
 802
 803                 /*
 804                  * If a length was supplied, compare that with the 'length'
 805                  * field.
 806                  */
 807
 808                 if (argc > 3) {
 809                         ulong length = simple_strtoul(argv[3], NULL, 16);
 810                         struct qe_firmware *firmware = (void *)addr;
 811
 812                         if (length != be32_to_cpu(firmware->header.length)) {
 813                                 printf("Length mismatch\n");
 814                                 return -EINVAL;
 815                         }
 816                 }
 817
 818                 return qe_upload_firmware((const struct qe_firmware *)addr);
 819         }
 820
 821         return cmd_usage(cmdtp);
 822 }
 823
 824 U_BOOT_CMD(
 825         qe, 4, 0, qe_cmd,
 826         "QUICC Engine commands",
 827         "fw <addr> [<length>] - Upload firmware binary at address <addr> to the QE,\n"
 828         "\twith optional length <length> verification."
 829 );