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