drivers/qe/qe.c

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