arch/powerpc/sysdev/qe_lib/qe.c

   1 /*
   2  * Copyright (C) 2006 Freescale Semicondutor, Inc. All rights reserved.
   3  *
   4  * Authors:     Shlomi Gridish <gridish@freescale.com>
   5  *              Li Yang <leoli@freescale.com>
   6  * Based on cpm2_common.c from Dan Malek (dmalek@jlc.net)
   7  *
   8  * Description:
   9  * General Purpose functions for the global management of the
  10  * QUICC Engine (QE).
  11  *
  12  * This program is free software; you can redistribute  it and/or modify it
  13  * under  the terms of  the GNU General  Public License as published by the
  14  * Free Software Foundation;  either version 2 of the  License, or (at your
  15  * option) any later version.
  16  */
  17 #include <linux/errno.h>
  18 #include <linux/sched.h>
  19 #include <linux/kernel.h>
  20 #include <linux/param.h>
  21 #include <linux/string.h>
  22 #include <linux/mm.h>
  23 #include <linux/interrupt.h>
  24 #include <linux/bootmem.h>
  25 #include <linux/module.h>
  26 #include <linux/delay.h>
  27 #include <linux/ioport.h>
  28 #include <linux/crc32.h>
  29 #include <asm/irq.h>
  30 #include <asm/page.h>
  31 #include <asm/pgtable.h>
  32 #include <asm/immap_qe.h>
  33 #include <asm/qe.h>
  34 #include <asm/prom.h>
  35 #include <asm/rheap.h>
  36
  37 static void qe_snums_init(void);
  38 static void qe_muram_init(void);
  39 static int qe_sdma_init(void);
  40
  41 static DEFINE_SPINLOCK(qe_lock);
  42
  43 /* QE snum state */
  44 enum qe_snum_state {
  45         QE_SNUM_STATE_USED,
  46         QE_SNUM_STATE_FREE
  47 };
  48
  49 /* QE snum */
  50 struct qe_snum {
  51         u8 num;
  52         enum qe_snum_state state;
  53 };
  54
  55 /* We allocate this here because it is used almost exclusively for
  56  * the communication processor devices.
  57  */
  58 struct qe_immap *qe_immr = NULL;
  59 EXPORT_SYMBOL(qe_immr);
  60
  61 static struct qe_snum snums[QE_NUM_OF_SNUM];    /* Dynamically allocated SNUMs */
  62
  63 static phys_addr_t qebase = -1;
  64
  65 phys_addr_t get_qe_base(void)
  66 {
  67         struct device_node *qe;
  68         unsigned int size;
  69         const u32 *prop;
  70
  71         if (qebase != -1)
  72                 return qebase;
  73
  74         qe = of_find_compatible_node(NULL, NULL, "fsl,qe");
  75         if (!qe) {
  76                 qe = of_find_node_by_type(NULL, "qe");
  77                 if (!qe)
  78                         return qebase;
  79         }
  80
  81         prop = of_get_property(qe, "reg", &size);
  82         if (prop && size >= sizeof(*prop))
  83                 qebase = of_translate_address(qe, prop);
  84         of_node_put(qe);
  85
  86         return qebase;
  87 }
  88
  89 EXPORT_SYMBOL(get_qe_base);
  90
  91 void qe_reset(void)
  92 {
  93         if (qe_immr == NULL)
  94                 qe_immr = ioremap(get_qe_base(), QE_IMMAP_SIZE);
  95
  96         qe_snums_init();
  97
  98         qe_issue_cmd(QE_RESET, QE_CR_SUBBLOCK_INVALID,
  99                      QE_CR_PROTOCOL_UNSPECIFIED, 0);
 100
 101         /* Reclaim the MURAM memory for our use. */
 102         qe_muram_init();
 103
 104         if (qe_sdma_init())
 105                 panic("sdma init failed!");
 106 }
 107
 108 int qe_issue_cmd(u32 cmd, u32 device, u8 mcn_protocol, u32 cmd_input)
 109 {
 110         unsigned long flags;
 111         u8 mcn_shift = 0, dev_shift = 0;
 112
 113         spin_lock_irqsave(&qe_lock, flags);
 114         if (cmd == QE_RESET) {
 115                 out_be32(&qe_immr->cp.cecr, (u32) (cmd | QE_CR_FLG));
 116         } else {
 117                 if (cmd == QE_ASSIGN_PAGE) {
 118                         /* Here device is the SNUM, not sub-block */
 119                         dev_shift = QE_CR_SNUM_SHIFT;
 120                 } else if (cmd == QE_ASSIGN_RISC) {
 121                         /* Here device is the SNUM, and mcnProtocol is
 122                          * e_QeCmdRiscAssignment value */
 123                         dev_shift = QE_CR_SNUM_SHIFT;
 124                         mcn_shift = QE_CR_MCN_RISC_ASSIGN_SHIFT;
 125                 } else {
 126                         if (device == QE_CR_SUBBLOCK_USB)
 127                                 mcn_shift = QE_CR_MCN_USB_SHIFT;
 128                         else
 129                                 mcn_shift = QE_CR_MCN_NORMAL_SHIFT;
 130                 }
 131
 132                 out_be32(&qe_immr->cp.cecdr, cmd_input);
 133                 out_be32(&qe_immr->cp.cecr,
 134                          (cmd | QE_CR_FLG | ((u32) device << dev_shift) | (u32)
 135                           mcn_protocol << mcn_shift));
 136         }
 137
 138         /* wait for the QE_CR_FLG to clear */
 139         while(in_be32(&qe_immr->cp.cecr) & QE_CR_FLG)
 140                 cpu_relax();
 141         spin_unlock_irqrestore(&qe_lock, flags);
 142
 143         return 0;
 144 }
 145 EXPORT_SYMBOL(qe_issue_cmd);
 146
 147 /* Set a baud rate generator. This needs lots of work. There are
 148  * 16 BRGs, which can be connected to the QE channels or output
 149  * as clocks. The BRGs are in two different block of internal
 150  * memory mapped space.
 151  * The BRG clock is the QE clock divided by 2.
 152  * It was set up long ago during the initial boot phase and is
 153  * is given to us.
 154  * Baud rate clocks are zero-based in the driver code (as that maps
 155  * to port numbers). Documentation uses 1-based numbering.
 156  */
 157 static unsigned int brg_clk = 0;
 158
 159 unsigned int get_brg_clk(void)
 160 {
 161         struct device_node *qe;
 162         unsigned int size;
 163         const u32 *prop;
 164
 165         if (brg_clk)
 166                 return brg_clk;
 167
 168         qe = of_find_compatible_node(NULL, NULL, "fsl,qe");
 169         if (!qe) {
 170                 qe = of_find_node_by_type(NULL, "qe");
 171                 if (!qe)
 172                         return brg_clk;
 173         }
 174
 175         prop = of_get_property(qe, "brg-frequency", &size);
 176         if (prop && size == sizeof(*prop))
 177                 brg_clk = *prop;
 178
 179         of_node_put(qe);
 180
 181         return brg_clk;
 182 }
 183
 184 /* Program the BRG to the given sampling rate and multiplier
 185  *
 186  * @brg: the BRG, QE_BRG1 - QE_BRG16
 187  * @rate: the desired sampling rate
 188  * @multiplier: corresponds to the value programmed in GUMR_L[RDCR] or
 189  * GUMR_L[TDCR].  E.g., if this BRG is the RX clock, and GUMR_L[RDCR]=01,
 190  * then 'multiplier' should be 8.
 191  */
 192 int qe_setbrg(enum qe_clock brg, unsigned int rate, unsigned int multiplier)
 193 {
 194         u32 divisor, tempval;
 195         u32 div16 = 0;
 196
 197         if ((brg < QE_BRG1) || (brg > QE_BRG16))
 198                 return -EINVAL;
 199
 200         divisor = get_brg_clk() / (rate * multiplier);
 201
 202         if (divisor > QE_BRGC_DIVISOR_MAX + 1) {
 203                 div16 = QE_BRGC_DIV16;
 204                 divisor /= 16;
 205         }
 206
 207         /* Errata QE_General4, which affects some MPC832x and MPC836x SOCs, says
 208            that the BRG divisor must be even if you're not using divide-by-16
 209            mode. */
 210         if (!div16 && (divisor & 1))
 211                 divisor++;
 212
 213         tempval = ((divisor - 1) << QE_BRGC_DIVISOR_SHIFT) |
 214                 QE_BRGC_ENABLE | div16;
 215
 216         out_be32(&qe_immr->brg.brgc[brg - QE_BRG1], tempval);
 217
 218         return 0;
 219 }
 220 EXPORT_SYMBOL(qe_setbrg);
 221
 222 /* Convert a string to a QE clock source enum
 223  *
 224  * This function takes a string, typically from a property in the device
 225  * tree, and returns the corresponding "enum qe_clock" value.
 226 */
 227 enum qe_clock qe_clock_source(const char *source)
 228 {
 229         unsigned int i;
 230
 231         if (strcasecmp(source, "none") == 0)
 232                 return QE_CLK_NONE;
 233
 234         if (strncasecmp(source, "brg", 3) == 0) {
 235                 i = simple_strtoul(source + 3, NULL, 10);
 236                 if ((i >= 1) && (i <= 16))
 237                         return (QE_BRG1 - 1) + i;
 238                 else
 239                         return QE_CLK_DUMMY;
 240         }
 241
 242         if (strncasecmp(source, "clk", 3) == 0) {
 243                 i = simple_strtoul(source + 3, NULL, 10);
 244                 if ((i >= 1) && (i <= 24))
 245                         return (QE_CLK1 - 1) + i;
 246                 else
 247                         return QE_CLK_DUMMY;
 248         }
 249
 250         return QE_CLK_DUMMY;
 251 }
 252 EXPORT_SYMBOL(qe_clock_source);
 253
 254 /* Initialize SNUMs (thread serial numbers) according to
 255  * QE Module Control chapter, SNUM table
 256  */
 257 static void qe_snums_init(void)
 258 {
 259         int i;
 260         static const u8 snum_init[] = {
 261                 0x04, 0x05, 0x0C, 0x0D, 0x14, 0x15, 0x1C, 0x1D,
 262                 0x24, 0x25, 0x2C, 0x2D, 0x34, 0x35, 0x88, 0x89,
 263                 0x98, 0x99, 0xA8, 0xA9, 0xB8, 0xB9, 0xC8, 0xC9,
 264                 0xD8, 0xD9, 0xE8, 0xE9,
 265         };
 266
 267         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
 268                 snums[i].num = snum_init[i];
 269                 snums[i].state = QE_SNUM_STATE_FREE;
 270         }
 271 }
 272
 273 int qe_get_snum(void)
 274 {
 275         unsigned long flags;
 276         int snum = -EBUSY;
 277         int i;
 278
 279         spin_lock_irqsave(&qe_lock, flags);
 280         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
 281                 if (snums[i].state == QE_SNUM_STATE_FREE) {
 282                         snums[i].state = QE_SNUM_STATE_USED;
 283                         snum = snums[i].num;
 284                         break;
 285                 }
 286         }
 287         spin_unlock_irqrestore(&qe_lock, flags);
 288
 289         return snum;
 290 }
 291 EXPORT_SYMBOL(qe_get_snum);
 292
 293 void qe_put_snum(u8 snum)
 294 {
 295         int i;
 296
 297         for (i = 0; i < QE_NUM_OF_SNUM; i++) {
 298                 if (snums[i].num == snum) {
 299                         snums[i].state = QE_SNUM_STATE_FREE;
 300                         break;
 301                 }
 302         }
 303 }
 304 EXPORT_SYMBOL(qe_put_snum);
 305
 306 static int qe_sdma_init(void)
 307 {
 308         struct sdma *sdma = &qe_immr->sdma;
 309         unsigned long sdma_buf_offset;
 310
 311         if (!sdma)
 312                 return -ENODEV;
 313
 314         /* allocate 2 internal temporary buffers (512 bytes size each) for
 315          * the SDMA */
 316         sdma_buf_offset = qe_muram_alloc(512 * 2, 4096);
 317         if (IS_ERR_VALUE(sdma_buf_offset))
 318                 return -ENOMEM;
 319
 320         out_be32(&sdma->sdebcr, (u32) sdma_buf_offset & QE_SDEBCR_BA_MASK);
 321         out_be32(&sdma->sdmr, (QE_SDMR_GLB_1_MSK |
 322                                         (0x1 << QE_SDMR_CEN_SHIFT)));
 323
 324         return 0;
 325 }
 326
 327 /*
 328  * muram_alloc / muram_free bits.
 329  */
 330 static DEFINE_SPINLOCK(qe_muram_lock);
 331
 332 /* 16 blocks should be enough to satisfy all requests
 333  * until the memory subsystem goes up... */
 334 static rh_block_t qe_boot_muram_rh_block[16];
 335 static rh_info_t qe_muram_info;
 336
 337 static void qe_muram_init(void)
 338 {
 339         struct device_node *np;
 340         const u32 *address;
 341         u64 size;
 342         unsigned int flags;
 343
 344         /* initialize the info header */
 345         rh_init(&qe_muram_info, 1,
 346                 sizeof(qe_boot_muram_rh_block) /
 347                 sizeof(qe_boot_muram_rh_block[0]), qe_boot_muram_rh_block);
 348
 349         /* Attach the usable muram area */
 350         /* XXX: This is a subset of the available muram. It
 351          * varies with the processor and the microcode patches activated.
 352          */
 353         np = of_find_compatible_node(NULL, NULL, "fsl,qe-muram-data");
 354         if (!np) {
 355                 np = of_find_node_by_name(NULL, "data-only");
 356                 if (!np) {
 357                         WARN_ON(1);
 358                         return;
 359                 }
 360         }
 361
 362         address = of_get_address(np, 0, &size, &flags);
 363         WARN_ON(!address);
 364
 365         of_node_put(np);
 366         if (address)
 367                 rh_attach_region(&qe_muram_info, *address, (int)size);
 368 }
 369
 370 /* This function returns an index into the MURAM area.
 371  */
 372 unsigned long qe_muram_alloc(int size, int align)
 373 {
 374         unsigned long start;
 375         unsigned long flags;
 376
 377         spin_lock_irqsave(&qe_muram_lock, flags);
 378         start = rh_alloc_align(&qe_muram_info, size, align, "QE");
 379         spin_unlock_irqrestore(&qe_muram_lock, flags);
 380
 381         return start;
 382 }
 383 EXPORT_SYMBOL(qe_muram_alloc);
 384
 385 int qe_muram_free(unsigned long offset)
 386 {
 387         int ret;
 388         unsigned long flags;
 389
 390         spin_lock_irqsave(&qe_muram_lock, flags);
 391         ret = rh_free(&qe_muram_info, offset);
 392         spin_unlock_irqrestore(&qe_muram_lock, flags);
 393
 394         return ret;
 395 }
 396 EXPORT_SYMBOL(qe_muram_free);
 397
 398 /* not sure if this is ever needed */
 399 unsigned long qe_muram_alloc_fixed(unsigned long offset, int size)
 400 {
 401         unsigned long start;
 402         unsigned long flags;
 403
 404         spin_lock_irqsave(&qe_muram_lock, flags);
 405         start = rh_alloc_fixed(&qe_muram_info, offset, size, "commproc");
 406         spin_unlock_irqrestore(&qe_muram_lock, flags);
 407
 408         return start;
 409 }
 410 EXPORT_SYMBOL(qe_muram_alloc_fixed);
 411
 412 void qe_muram_dump(void)
 413 {
 414         rh_dump(&qe_muram_info);
 415 }
 416 EXPORT_SYMBOL(qe_muram_dump);
 417
 418 void *qe_muram_addr(unsigned long offset)
 419 {
 420         return (void *)&qe_immr->muram[offset];
 421 }
 422 EXPORT_SYMBOL(qe_muram_addr);
 423
 424 /* The maximum number of RISCs we support */
 425 #define MAX_QE_RISC     2
 426
 427 /* Firmware information stored here for qe_get_firmware_info() */
 428 static struct qe_firmware_info qe_firmware_info;
 429
 430 /*
 431  * Set to 1 if QE firmware has been uploaded, and therefore
 432  * qe_firmware_info contains valid data.
 433  */
 434 static int qe_firmware_uploaded;
 435
 436 /*
 437  * Upload a QE microcode
 438  *
 439  * This function is a worker function for qe_upload_firmware().  It does
 440  * the actual uploading of the microcode.
 441  */
 442 static void qe_upload_microcode(const void *base,
 443         const struct qe_microcode *ucode)
 444 {
 445         const __be32 *code = base + be32_to_cpu(ucode->code_offset);
 446         unsigned int i;
 447
 448         if (ucode->major || ucode->minor || ucode->revision)
 449                 printk(KERN_INFO "qe-firmware: "
 450                         "uploading microcode '%s' version %u.%u.%u\n",
 451                         ucode->id, ucode->major, ucode->minor, ucode->revision);
 452         else
 453                 printk(KERN_INFO "qe-firmware: "
 454                         "uploading microcode '%s'\n", ucode->id);
 455
 456         /* Use auto-increment */
 457         out_be32(&qe_immr->iram.iadd, be32_to_cpu(ucode->iram_offset) |
 458                 QE_IRAM_IADD_AIE | QE_IRAM_IADD_BADDR);
 459
 460         for (i = 0; i < be32_to_cpu(ucode->count); i++)
 461                 out_be32(&qe_immr->iram.idata, be32_to_cpu(code[i]));
 462 }
 463
 464 /*
 465  * Upload a microcode to the I-RAM at a specific address.
 466  *
 467  * See Documentation/powerpc/qe-firmware.txt for information on QE microcode
 468  * uploading.
 469  *
 470  * Currently, only version 1 is supported, so the 'version' field must be
 471  * set to 1.
 472  *
 473  * The SOC model and revision are not validated, they are only displayed for
 474  * informational purposes.
 475  *
 476  * 'calc_size' is the calculated size, in bytes, of the firmware structure and
 477  * all of the microcode structures, minus the CRC.
 478  *
 479  * 'length' is the size that the structure says it is, including the CRC.
 480  */
 481 int qe_upload_firmware(const struct qe_firmware *firmware)
 482 {
 483         unsigned int i;
 484         unsigned int j;
 485         u32 crc;
 486         size_t calc_size = sizeof(struct qe_firmware);
 487         size_t length;
 488         const struct qe_header *hdr;
 489
 490         if (!firmware) {
 491                 printk(KERN_ERR "qe-firmware: invalid pointer\n");
 492                 return -EINVAL;
 493         }
 494
 495         hdr = &firmware->header;
 496         length = be32_to_cpu(hdr->length);
 497
 498         /* Check the magic */
 499         if ((hdr->magic[0] != 'Q') || (hdr->magic[1] != 'E') ||
 500             (hdr->magic[2] != 'F')) {
 501                 printk(KERN_ERR "qe-firmware: not a microcode\n");
 502                 return -EPERM;
 503         }
 504
 505         /* Check the version */
 506         if (hdr->version != 1) {
 507                 printk(KERN_ERR "qe-firmware: unsupported version\n");
 508                 return -EPERM;
 509         }
 510
 511         /* Validate some of the fields */
 512         if ((firmware->count < 1) || (firmware->count >= MAX_QE_RISC)) {
 513                 printk(KERN_ERR "qe-firmware: invalid data\n");
 514                 return -EINVAL;
 515         }
 516
 517         /* Validate the length and check if there's a CRC */
 518         calc_size += (firmware->count - 1) * sizeof(struct qe_microcode);
 519
 520         for (i = 0; i < firmware->count; i++)
 521                 /*
 522                  * For situations where the second RISC uses the same microcode
 523                  * as the first, the 'code_offset' and 'count' fields will be
 524                  * zero, so it's okay to add those.
 525                  */
 526                 calc_size += sizeof(__be32) *
 527                         be32_to_cpu(firmware->microcode[i].count);
 528
 529         /* Validate the length */
 530         if (length != calc_size + sizeof(__be32)) {
 531                 printk(KERN_ERR "qe-firmware: invalid length\n");
 532                 return -EPERM;
 533         }
 534
 535         /* Validate the CRC */
 536         crc = be32_to_cpu(*(__be32 *)((void *)firmware + calc_size));
 537         if (crc != crc32(0, firmware, calc_size)) {
 538                 printk(KERN_ERR "qe-firmware: firmware CRC is invalid\n");
 539                 return -EIO;
 540         }
 541
 542         /*
 543          * If the microcode calls for it, split the I-RAM.
 544          */
 545         if (!firmware->split)
 546                 setbits16(&qe_immr->cp.cercr, QE_CP_CERCR_CIR);
 547
 548         if (firmware->soc.model)
 549                 printk(KERN_INFO
 550                         "qe-firmware: firmware '%s' for %u V%u.%u\n",
 551                         firmware->id, be16_to_cpu(firmware->soc.model),
 552                         firmware->soc.major, firmware->soc.minor);
 553         else
 554                 printk(KERN_INFO "qe-firmware: firmware '%s'\n",
 555                         firmware->id);
 556
 557         /*
 558          * The QE only supports one microcode per RISC, so clear out all the
 559          * saved microcode information and put in the new.
 560          */
 561         memset(&qe_firmware_info, 0, sizeof(qe_firmware_info));
 562         strcpy(qe_firmware_info.id, firmware->id);
 563         qe_firmware_info.extended_modes = firmware->extended_modes;
 564         memcpy(qe_firmware_info.vtraps, firmware->vtraps,
 565                 sizeof(firmware->vtraps));
 566
 567         /* Loop through each microcode. */
 568         for (i = 0; i < firmware->count; i++) {
 569                 const struct qe_microcode *ucode = &firmware->microcode[i];
 570
 571                 /* Upload a microcode if it's present */
 572                 if (ucode->code_offset)
 573                         qe_upload_microcode(firmware, ucode);
 574
 575                 /* Program the traps for this processor */
 576                 for (j = 0; j < 16; j++) {
 577                         u32 trap = be32_to_cpu(ucode->traps[j]);
 578
 579                         if (trap)
 580                                 out_be32(&qe_immr->rsp[i].tibcr[j], trap);
 581                 }
 582
 583                 /* Enable traps */
 584                 out_be32(&qe_immr->rsp[i].eccr, be32_to_cpu(ucode->eccr));
 585         }
 586
 587         qe_firmware_uploaded = 1;
 588
 589         return 0;
 590 }
 591 EXPORT_SYMBOL(qe_upload_firmware);
 592
 593 /*
 594  * Get info on the currently-loaded firmware
 595  *
 596  * This function also checks the device tree to see if the boot loader has
 597  * uploaded a firmware already.
 598  */
 599 struct qe_firmware_info *qe_get_firmware_info(void)
 600 {
 601         static int initialized;
 602         struct property *prop;
 603         struct device_node *qe;
 604         struct device_node *fw = NULL;
 605         const char *sprop;
 606         unsigned int i;
 607
 608         /*
 609          * If we haven't checked yet, and a driver hasn't uploaded a firmware
 610          * yet, then check the device tree for information.
 611          */
 612         if (initialized || qe_firmware_uploaded)
 613                 return NULL;
 614
 615         initialized = 1;
 616
 617         /*
 618          * Newer device trees have an "fsl,qe" compatible property for the QE
 619          * node, but we still need to support older device trees.
 620         */
 621         qe = of_find_compatible_node(NULL, NULL, "fsl,qe");
 622         if (!qe) {
 623                 qe = of_find_node_by_type(NULL, "qe");
 624                 if (!qe)
 625                         return NULL;
 626         }
 627
 628         /* Find the 'firmware' child node */
 629         for_each_child_of_node(qe, fw) {
 630                 if (strcmp(fw->name, "firmware") == 0)
 631                         break;
 632         }
 633
 634         of_node_put(qe);
 635
 636         /* Did we find the 'firmware' node? */
 637         if (!fw)
 638                 return NULL;
 639
 640         qe_firmware_uploaded = 1;
 641
 642         /* Copy the data into qe_firmware_info*/
 643         sprop = of_get_property(fw, "id", NULL);
 644         if (sprop)
 645                 strncpy(qe_firmware_info.id, sprop,
 646                         sizeof(qe_firmware_info.id) - 1);
 647
 648         prop = of_find_property(fw, "extended-modes", NULL);
 649         if (prop && (prop->length == sizeof(u64))) {
 650                 const u64 *iprop = prop->value;
 651
 652                 qe_firmware_info.extended_modes = *iprop;
 653         }
 654
 655         prop = of_find_property(fw, "virtual-traps", NULL);
 656         if (prop && (prop->length == 32)) {
 657                 const u32 *iprop = prop->value;
 658
 659                 for (i = 0; i < ARRAY_SIZE(qe_firmware_info.vtraps); i++)
 660                         qe_firmware_info.vtraps[i] = iprop[i];
 661         }
 662
 663         of_node_put(fw);
 664
 665         return &qe_firmware_info;
 666 }
 667 EXPORT_SYMBOL(qe_get_firmware_info);
 668