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