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