arch/tile/kernel/pci_gx.c

   1 /*
   2  * Copyright 2012 Tilera Corporation. All Rights Reserved.
   3  *
   4  *   This program is free software; you can redistribute it and/or
   5  *   modify it under the terms of the GNU General Public License
   6  *   as published by the Free Software Foundation, version 2.
   7  *
   8  *   This program is distributed in the hope that it will be useful, but
   9  *   WITHOUT ANY WARRANTY; without even the implied warranty of
  10  *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
  11  *   NON INFRINGEMENT.  See the GNU General Public License for
  12  *   more details.
  13  */
  14
  15 #include <linux/kernel.h>
  16 #include <linux/mmzone.h>
  17 #include <linux/pci.h>
  18 #include <linux/delay.h>
  19 #include <linux/string.h>
  20 #include <linux/init.h>
  21 #include <linux/capability.h>
  22 #include <linux/sched.h>
  23 #include <linux/errno.h>
  24 #include <linux/irq.h>
  25 #include <linux/msi.h>
  26 #include <linux/io.h>
  27 #include <linux/uaccess.h>
  28 #include <linux/ctype.h>
  29
  30 #include <asm/processor.h>
  31 #include <asm/sections.h>
  32 #include <asm/byteorder.h>
  33
  34 #include <gxio/iorpc_globals.h>
  35 #include <gxio/kiorpc.h>
  36 #include <gxio/trio.h>
  37 #include <gxio/iorpc_trio.h>
  38 #include <hv/drv_trio_intf.h>
  39
  40 #include <arch/sim.h>
  41
  42 /*
  43  * This file containes the routines to search for PCI buses,
  44  * enumerate the buses, and configure any attached devices.
  45  */
  46
  47 #define DEBUG_PCI_CFG   0
  48
  49 #if DEBUG_PCI_CFG
  50 #define TRACE_CFG_WR(size, val, bus, dev, func, offset) \
  51         pr_info("CFG WR %d-byte VAL %#x to bus %d dev %d func %d addr %u\n", \
  52                 size, val, bus, dev, func, offset & 0xFFF);
  53 #define TRACE_CFG_RD(size, val, bus, dev, func, offset) \
  54         pr_info("CFG RD %d-byte VAL %#x from bus %d dev %d func %d addr %u\n", \
  55                 size, val, bus, dev, func, offset & 0xFFF);
  56 #else
  57 #define TRACE_CFG_WR(...)
  58 #define TRACE_CFG_RD(...)
  59 #endif
  60
  61 static int pci_probe = 1;
  62
  63 /* Information on the PCIe RC ports configuration. */
  64 static int pcie_rc[TILEGX_NUM_TRIO][TILEGX_TRIO_PCIES];
  65
  66 /*
  67  * On some platforms with one or more Gx endpoint ports, we need to
  68  * delay the PCIe RC port probe for a few seconds to work around
  69  * a HW PCIe link-training bug. The exact delay is specified with
  70  * a kernel boot argument in the form of "pcie_rc_delay=T,P,S",
  71  * where T is the TRIO instance number, P is the port number and S is
  72  * the delay in seconds. If the delay is not provided, the value
  73  * will be DEFAULT_RC_DELAY.
  74  */
  75 static int rc_delay[TILEGX_NUM_TRIO][TILEGX_TRIO_PCIES];
  76
  77 /* Default number of seconds that the PCIe RC port probe can be delayed. */
  78 #define DEFAULT_RC_DELAY        10
  79
  80 /* Max number of seconds that the PCIe RC port probe can be delayed. */
  81 #define MAX_RC_DELAY            20
  82
  83 /* Array of the PCIe ports configuration info obtained from the BIB. */
  84 struct pcie_port_property pcie_ports[TILEGX_NUM_TRIO][TILEGX_TRIO_PCIES];
  85
  86 /* All drivers share the TRIO contexts defined here. */
  87 gxio_trio_context_t trio_contexts[TILEGX_NUM_TRIO];
  88
  89 /* Pointer to an array of PCIe RC controllers. */
  90 struct pci_controller pci_controllers[TILEGX_NUM_TRIO * TILEGX_TRIO_PCIES];
  91 int num_rc_controllers;
  92 static int num_ep_controllers;
  93
  94 static struct pci_ops tile_cfg_ops;
  95
  96 /* Mask of CPUs that should receive PCIe interrupts. */
  97 static struct cpumask intr_cpus_map;
  98
  99 /*
 100  * We don't need to worry about the alignment of resources.
 101  */
 102 resource_size_t pcibios_align_resource(void *data, const struct resource *res,
 103                                 resource_size_t size, resource_size_t align)
 104 {
 105         return res->start;
 106 }
 107 EXPORT_SYMBOL(pcibios_align_resource);
 108
 109
 110 /*
 111  * Pick a CPU to receive and handle the PCIe interrupts, based on the IRQ #.
 112  * For now, we simply send interrupts to non-dataplane CPUs.
 113  * We may implement methods to allow user to specify the target CPUs,
 114  * e.g. via boot arguments.
 115  */
 116 static int tile_irq_cpu(int irq)
 117 {
 118         unsigned int count;
 119         int i = 0;
 120         int cpu;
 121
 122         count = cpumask_weight(&intr_cpus_map);
 123         if (unlikely(count == 0)) {
 124                 pr_warning("intr_cpus_map empty, interrupts will be"
 125                            " delievered to dataplane tiles\n");
 126                 return irq % (smp_height * smp_width);
 127         }
 128
 129         count = irq % count;
 130         for_each_cpu(cpu, &intr_cpus_map) {
 131                 if (i++ == count)
 132                         break;
 133         }
 134         return cpu;
 135 }
 136
 137 /*
 138  * Open a file descriptor to the TRIO shim.
 139  */
 140 static int tile_pcie_open(int trio_index)
 141 {
 142         gxio_trio_context_t *context = &trio_contexts[trio_index];
 143         int ret;
 144
 145         /*
 146          * This opens a file descriptor to the TRIO shim.
 147          */
 148         ret = gxio_trio_init(context, trio_index);
 149         if (ret < 0)
 150                 return ret;
 151
 152         /*
 153          * Allocate an ASID for the kernel.
 154          */
 155         ret = gxio_trio_alloc_asids(context, 1, 0, 0);
 156         if (ret < 0) {
 157                 pr_err("PCI: ASID alloc failure on TRIO %d, give up\n",
 158                         trio_index);
 159                 goto asid_alloc_failure;
 160         }
 161
 162         context->asid = ret;
 163
 164 #ifdef USE_SHARED_PCIE_CONFIG_REGION
 165         /*
 166          * Alloc a PIO region for config access, shared by all MACs per TRIO.
 167          * This shouldn't fail since the kernel is supposed to the first
 168          * client of the TRIO's PIO regions.
 169          */
 170         ret = gxio_trio_alloc_pio_regions(context, 1, 0, 0);
 171         if (ret < 0) {
 172                 pr_err("PCI: CFG PIO alloc failure on TRIO %d, give up\n",
 173                         trio_index);
 174                 goto pio_alloc_failure;
 175         }
 176
 177         context->pio_cfg_index = ret;
 178
 179         /*
 180          * For PIO CFG, the bus_address_hi parameter is 0. The mac parameter
 181          * is also 0 because it is specified in PIO_REGION_SETUP_CFG_ADDR.
 182          */
 183         ret = gxio_trio_init_pio_region_aux(context, context->pio_cfg_index,
 184                 0, 0, HV_TRIO_PIO_FLAG_CONFIG_SPACE);
 185         if (ret < 0) {
 186                 pr_err("PCI: CFG PIO init failure on TRIO %d, give up\n",
 187                         trio_index);
 188                 goto pio_alloc_failure;
 189         }
 190 #endif
 191
 192         return ret;
 193
 194 asid_alloc_failure:
 195 #ifdef USE_SHARED_PCIE_CONFIG_REGION
 196 pio_alloc_failure:
 197 #endif
 198         hv_dev_close(context->fd);
 199
 200         return ret;
 201 }
 202
 203 static void
 204 tilegx_legacy_irq_ack(struct irq_data *d)
 205 {
 206         __insn_mtspr(SPR_IPI_EVENT_RESET_K, 1UL << d->irq);
 207 }
 208
 209 static void
 210 tilegx_legacy_irq_mask(struct irq_data *d)
 211 {
 212         __insn_mtspr(SPR_IPI_MASK_SET_K, 1UL << d->irq);
 213 }
 214
 215 static void
 216 tilegx_legacy_irq_unmask(struct irq_data *d)
 217 {
 218         __insn_mtspr(SPR_IPI_MASK_RESET_K, 1UL << d->irq);
 219 }
 220
 221 static struct irq_chip tilegx_legacy_irq_chip = {
 222         .name                   = "tilegx_legacy_irq",
 223         .irq_ack                = tilegx_legacy_irq_ack,
 224         .irq_mask               = tilegx_legacy_irq_mask,
 225         .irq_unmask             = tilegx_legacy_irq_unmask,
 226
 227         /* TBD: support set_affinity. */
 228 };
 229
 230 /*
 231  * This is a wrapper function of the kernel level-trigger interrupt
 232  * handler handle_level_irq() for PCI legacy interrupts. The TRIO
 233  * is configured such that only INTx Assert interrupts are proxied
 234  * to Linux which just calls handle_level_irq() after clearing the
 235  * MAC INTx Assert status bit associated with this interrupt.
 236  */
 237 static void
 238 trio_handle_level_irq(unsigned int irq, struct irq_desc *desc)
 239 {
 240         struct pci_controller *controller = irq_desc_get_handler_data(desc);
 241         gxio_trio_context_t *trio_context = controller->trio;
 242         uint64_t intx = (uint64_t)irq_desc_get_chip_data(desc);
 243         int mac = controller->mac;
 244         unsigned int reg_offset;
 245         uint64_t level_mask;
 246
 247         handle_level_irq(irq, desc);
 248
 249         /*
 250          * Clear the INTx Level status, otherwise future interrupts are
 251          * not sent.
 252          */
 253         reg_offset = (TRIO_PCIE_INTFC_MAC_INT_STS <<
 254                 TRIO_CFG_REGION_ADDR__REG_SHIFT) |
 255                 (TRIO_CFG_REGION_ADDR__INTFC_VAL_MAC_INTERFACE <<
 256                 TRIO_CFG_REGION_ADDR__INTFC_SHIFT ) |
 257                 (mac << TRIO_CFG_REGION_ADDR__MAC_SEL_SHIFT);
 258
 259         level_mask = TRIO_PCIE_INTFC_MAC_INT_STS__INT_LEVEL_MASK << intx;
 260
 261         __gxio_mmio_write(trio_context->mmio_base_mac + reg_offset, level_mask);
 262 }
 263
 264 /*
 265  * Create kernel irqs and set up the handlers for the legacy interrupts.
 266  * Also some minimum initialization for the MSI support.
 267  */
 268 static int tile_init_irqs(struct pci_controller *controller)
 269 {
 270         int i;
 271         int j;
 272         int irq;
 273         int result;
 274
 275         cpumask_copy(&intr_cpus_map, cpu_online_mask);
 276
 277
 278         for (i = 0; i < 4; i++) {
 279                 gxio_trio_context_t *context = controller->trio;
 280                 int cpu;
 281
 282                 /* Ask the kernel to allocate an IRQ. */
 283                 irq = create_irq();
 284                 if (irq < 0) {
 285                         pr_err("PCI: no free irq vectors, failed for %d\n", i);
 286
 287                         goto free_irqs;
 288                 }
 289                 controller->irq_intx_table[i] = irq;
 290
 291                 /* Distribute the 4 IRQs to different tiles. */
 292                 cpu = tile_irq_cpu(irq);
 293
 294                 /* Configure the TRIO intr binding for this IRQ. */
 295                 result = gxio_trio_config_legacy_intr(context, cpu_x(cpu),
 296                                                       cpu_y(cpu), KERNEL_PL,
 297                                                       irq, controller->mac, i);
 298                 if (result < 0) {
 299                         pr_err("PCI: MAC intx config failed for %d\n", i);
 300
 301                         goto free_irqs;
 302                 }
 303
 304                 /*
 305                  * Register the IRQ handler with the kernel.
 306                  */
 307                 irq_set_chip_and_handler(irq, &tilegx_legacy_irq_chip,
 308                                         trio_handle_level_irq);
 309                 irq_set_chip_data(irq, (void *)(uint64_t)i);
 310                 irq_set_handler_data(irq, controller);
 311         }
 312
 313         return 0;
 314
 315 free_irqs:
 316         for (j = 0; j < i; j++)
 317                 destroy_irq(controller->irq_intx_table[j]);
 318
 319         return -1;
 320 }
 321
 322 /*
 323  * Find valid controllers and fill in pci_controller structs for each
 324  * of them.
 325  *
 326  * Returns the number of controllers discovered.
 327  */
 328 int __init tile_pci_init(void)
 329 {
 330         int num_trio_shims = 0;
 331         int ctl_index = 0;
 332         int i, j;
 333
 334         if (!pci_probe) {
 335                 pr_info("PCI: disabled by boot argument\n");
 336                 return 0;
 337         }
 338
 339         pr_info("PCI: Searching for controllers...\n");
 340
 341         /*
 342          * We loop over all the TRIO shims.
 343          */
 344         for (i = 0; i < TILEGX_NUM_TRIO; i++) {
 345                 int ret;
 346
 347                 ret = tile_pcie_open(i);
 348                 if (ret < 0)
 349                         continue;
 350
 351                 num_trio_shims++;
 352         }
 353
 354         if (num_trio_shims == 0 || sim_is_simulator())
 355                 return 0;
 356
 357         /*
 358          * Now determine which PCIe ports are configured to operate in RC mode.
 359          * We look at the Board Information Block first and then see if there
 360          * are any overriding configuration by the HW strapping pin.
 361          */
 362         for (i = 0; i < TILEGX_NUM_TRIO; i++) {
 363                 gxio_trio_context_t *context = &trio_contexts[i];
 364                 int ret;
 365
 366                 if (context->fd < 0)
 367                         continue;
 368
 369                 ret = hv_dev_pread(context->fd, 0,
 370                         (HV_VirtAddr)&pcie_ports[i][0],
 371                         sizeof(struct pcie_port_property) * TILEGX_TRIO_PCIES,
 372                         GXIO_TRIO_OP_GET_PORT_PROPERTY);
 373                 if (ret < 0) {
 374                         pr_err("PCI: PCIE_GET_PORT_PROPERTY failure, error %d,"
 375                                 " on TRIO %d\n", ret, i);
 376                         continue;
 377                 }
 378
 379                 for (j = 0; j < TILEGX_TRIO_PCIES; j++) {
 380                         if (pcie_ports[i][j].allow_rc) {
 381                                 pcie_rc[i][j] = 1;
 382                                 num_rc_controllers++;
 383                         }
 384                         else if (pcie_ports[i][j].allow_ep) {
 385                                 num_ep_controllers++;
 386                         }
 387                 }
 388         }
 389
 390         /*
 391          * Return if no PCIe ports are configured to operate in RC mode.
 392          */
 393         if (num_rc_controllers == 0)
 394                 return 0;
 395
 396         /*
 397          * Set the TRIO pointer and MAC index for each PCIe RC port.
 398          */
 399         for (i = 0; i < TILEGX_NUM_TRIO; i++) {
 400                 for (j = 0; j < TILEGX_TRIO_PCIES; j++) {
 401                         if (pcie_rc[i][j]) {
 402                                 pci_controllers[ctl_index].trio =
 403                                         &trio_contexts[i];
 404                                 pci_controllers[ctl_index].mac = j;
 405                                 pci_controllers[ctl_index].trio_index = i;
 406                                 ctl_index++;
 407                                 if (ctl_index == num_rc_controllers)
 408                                         goto out;
 409                         }
 410                 }
 411         }
 412
 413 out:
 414         /*
 415          * Configure each PCIe RC port.
 416          */
 417         for (i = 0; i < num_rc_controllers; i++) {
 418                 /*
 419                  * Configure the PCIe MAC to run in RC mode.
 420                  */
 421
 422                 struct pci_controller *controller = &pci_controllers[i];
 423
 424                 controller->index = i;
 425                 controller->ops = &tile_cfg_ops;
 426
 427                 /*
 428                  * The PCI memory resource is located above the PA space.
 429                  * For every host bridge, the BAR window or the MMIO aperture
 430                  * is in range [3GB, 4GB - 1] of a 4GB space beyond the
 431                  * PA space.
 432                  */
 433
 434                 controller->mem_offset = TILE_PCI_MEM_START +
 435                         (i * TILE_PCI_BAR_WINDOW_TOP);
 436                 controller->mem_space.start = controller->mem_offset +
 437                         TILE_PCI_BAR_WINDOW_TOP - TILE_PCI_BAR_WINDOW_SIZE;
 438                 controller->mem_space.end = controller->mem_offset +
 439                         TILE_PCI_BAR_WINDOW_TOP - 1;
 440                 controller->mem_space.flags = IORESOURCE_MEM;
 441                 snprintf(controller->mem_space_name,
 442                          sizeof(controller->mem_space_name),
 443                          "PCI mem domain %d", i);
 444                 controller->mem_space.name = controller->mem_space_name;
 445         }
 446
 447         return num_rc_controllers;
 448 }
 449
 450 /*
 451  * (pin - 1) converts from the PCI standard's [1:4] convention to
 452  * a normal [0:3] range.
 453  */
 454 static int tile_map_irq(const struct pci_dev *dev, u8 device, u8 pin)
 455 {
 456         struct pci_controller *controller =
 457                 (struct pci_controller *)dev->sysdata;
 458         return controller->irq_intx_table[pin - 1];
 459 }
 460
 461
 462 static void fixup_read_and_payload_sizes(struct pci_controller *controller)
 463 {
 464         gxio_trio_context_t *trio_context = controller->trio;
 465         struct pci_bus *root_bus = controller->root_bus;
 466         TRIO_PCIE_RC_DEVICE_CONTROL_t dev_control;
 467         TRIO_PCIE_RC_DEVICE_CAP_t rc_dev_cap;
 468         unsigned int reg_offset;
 469         struct pci_bus *child;
 470         int mac;
 471         int err;
 472
 473         mac = controller->mac;
 474
 475         /*
 476          * Set our max read request size to be 4KB.
 477          */
 478         reg_offset =
 479                 (TRIO_PCIE_RC_DEVICE_CONTROL <<
 480                         TRIO_CFG_REGION_ADDR__REG_SHIFT) |
 481                 (TRIO_CFG_REGION_ADDR__INTFC_VAL_MAC_STANDARD <<
 482                         TRIO_CFG_REGION_ADDR__INTFC_SHIFT ) |
 483                 (mac << TRIO_CFG_REGION_ADDR__MAC_SEL_SHIFT);
 484
 485         dev_control.word = __gxio_mmio_read32(trio_context->mmio_base_mac +
 486                                                 reg_offset);
 487         dev_control.max_read_req_sz = 5;
 488         __gxio_mmio_write32(trio_context->mmio_base_mac + reg_offset,
 489                                                 dev_control.word);
 490
 491         /*
 492          * Set the max payload size supported by this Gx PCIe MAC.
 493          * Though Gx PCIe supports Max Payload Size of up to 1024 bytes,
 494          * experiments have shown that setting MPS to 256 yields the
 495          * best performance.
 496          */
 497         reg_offset =
 498                 (TRIO_PCIE_RC_DEVICE_CAP <<
 499                         TRIO_CFG_REGION_ADDR__REG_SHIFT) |
 500                 (TRIO_CFG_REGION_ADDR__INTFC_VAL_MAC_STANDARD <<
 501                         TRIO_CFG_REGION_ADDR__INTFC_SHIFT ) |
 502                 (mac << TRIO_CFG_REGION_ADDR__MAC_SEL_SHIFT);
 503
 504         rc_dev_cap.word = __gxio_mmio_read32(trio_context->mmio_base_mac +
 505                                                 reg_offset);
 506         rc_dev_cap.mps_sup = 1;
 507         __gxio_mmio_write32(trio_context->mmio_base_mac + reg_offset,
 508                                                 rc_dev_cap.word);
 509
 510         /* Configure PCI Express MPS setting. */
 511         list_for_each_entry(child, &root_bus->children, node)
 512                 pcie_bus_configure_settings(child);
 513
 514         /*
 515          * Set the mac_config register in trio based on the MPS/MRS of the link.
 516          */
 517         reg_offset =
 518                 (TRIO_PCIE_RC_DEVICE_CONTROL <<
 519                         TRIO_CFG_REGION_ADDR__REG_SHIFT) |
 520                 (TRIO_CFG_REGION_ADDR__INTFC_VAL_MAC_STANDARD <<
 521                         TRIO_CFG_REGION_ADDR__INTFC_SHIFT ) |
 522                 (mac << TRIO_CFG_REGION_ADDR__MAC_SEL_SHIFT);
 523
 524         dev_control.word = __gxio_mmio_read32(trio_context->mmio_base_mac +
 525                                                 reg_offset);
 526
 527         err = gxio_trio_set_mps_mrs(trio_context,
 528                                     dev_control.max_payload_size,
 529                                     dev_control.max_read_req_sz,
 530                                     mac);
 531         if (err < 0) {
 532                 pr_err("PCI: PCIE_CONFIGURE_MAC_MPS_MRS failure, "
 533                         "MAC %d on TRIO %d\n",
 534                         mac, controller->trio_index);
 535         }
 536 }
 537
 538 static int setup_pcie_rc_delay(char *str)
 539 {
 540         unsigned long delay = 0;
 541         unsigned long trio_index;
 542         unsigned long mac;
 543
 544         if (str == NULL || !isdigit(*str))
 545                 return -EINVAL;
 546         trio_index = simple_strtoul(str, (char **)&str, 10);
 547         if (trio_index >= TILEGX_NUM_TRIO)
 548                 return -EINVAL;
 549
 550         if (*str != ',')
 551                 return -EINVAL;
 552
 553         str++;
 554         if (!isdigit(*str))
 555                 return -EINVAL;
 556         mac = simple_strtoul(str, (char **)&str, 10);
 557         if (mac >= TILEGX_TRIO_PCIES)
 558                 return -EINVAL;
 559
 560         if (*str != '\0') {
 561                 if (*str != ',')
 562                         return -EINVAL;
 563
 564                 str++;
 565                 if (!isdigit(*str))
 566                         return -EINVAL;
 567                 delay = simple_strtoul(str, (char **)&str, 10);
 568                 if (delay > MAX_RC_DELAY)
 569                         return -EINVAL;
 570         }
 571
 572         rc_delay[trio_index][mac] = delay ? : DEFAULT_RC_DELAY;
 573         pr_info("Delaying PCIe RC link training for %u sec"
 574                 " on MAC %lu on TRIO %lu\n", rc_delay[trio_index][mac],
 575                 mac, trio_index);
 576         return 0;
 577 }
 578 early_param("pcie_rc_delay", setup_pcie_rc_delay);
 579
 580 /*
 581  * PCI initialization entry point, called by subsys_initcall.
 582  */
 583 int __init pcibios_init(void)
 584 {
 585         resource_size_t offset;
 586         LIST_HEAD(resources);
 587         int next_busno;
 588         int i;
 589
 590         tile_pci_init();
 591
 592         if (num_rc_controllers == 0 && num_ep_controllers == 0)
 593                 return 0;
 594
 595         /*
 596          * We loop over all the TRIO shims and set up the MMIO mappings.
 597          */
 598         for (i = 0; i < TILEGX_NUM_TRIO; i++) {
 599                 gxio_trio_context_t *context = &trio_contexts[i];
 600
 601                 if (context->fd < 0)
 602                         continue;
 603
 604                 /*
 605                  * Map in the MMIO space for the MAC.
 606                  */
 607                 offset = 0;
 608                 context->mmio_base_mac =
 609                         iorpc_ioremap(context->fd, offset,
 610                                       HV_TRIO_CONFIG_IOREMAP_SIZE);
 611                 if (context->mmio_base_mac == NULL) {
 612                         pr_err("PCI: MAC map failure on TRIO %d\n", i);
 613
 614                         hv_dev_close(context->fd);
 615                         context->fd = -1;
 616                         continue;
 617                 }
 618         }
 619
 620         /*
 621          * Delay a bit in case devices aren't ready.  Some devices are
 622          * known to require at least 20ms here, but we use a more
 623          * conservative value.
 624          */
 625         msleep(250);
 626
 627         /* Scan all of the recorded PCI controllers.  */
 628         for (next_busno = 0, i = 0; i < num_rc_controllers; i++) {
 629                 struct pci_controller *controller = &pci_controllers[i];
 630                 gxio_trio_context_t *trio_context = controller->trio;
 631                 TRIO_PCIE_INTFC_PORT_CONFIG_t port_config;
 632                 TRIO_PCIE_INTFC_PORT_STATUS_t port_status;
 633                 TRIO_PCIE_INTFC_TX_FIFO_CTL_t tx_fifo_ctl;
 634                 struct pci_bus *bus;
 635                 unsigned int reg_offset;
 636                 unsigned int class_code_revision;
 637                 int trio_index;
 638                 int mac;
 639                 int ret;
 640
 641                 if (trio_context->fd < 0)
 642                         continue;
 643
 644                 trio_index = controller->trio_index;
 645                 mac = controller->mac;
 646
 647                 /*
 648                  * Check the port strap state which will override the BIB
 649                  * setting.
 650                  */
 651
 652                 reg_offset =
 653                         (TRIO_PCIE_INTFC_PORT_CONFIG <<
 654                                 TRIO_CFG_REGION_ADDR__REG_SHIFT) |
 655                         (TRIO_CFG_REGION_ADDR__INTFC_VAL_MAC_INTERFACE <<
 656                                 TRIO_CFG_REGION_ADDR__INTFC_SHIFT ) |
 657                         (mac << TRIO_CFG_REGION_ADDR__MAC_SEL_SHIFT);
 658
 659                 port_config.word =
 660                         __gxio_mmio_read(trio_context->mmio_base_mac +
 661                                          reg_offset);
 662
 663                 if ((port_config.strap_state !=
 664                         TRIO_PCIE_INTFC_PORT_CONFIG__STRAP_STATE_VAL_AUTO_CONFIG_RC) &&
 665                         (port_config.strap_state !=
 666                         TRIO_PCIE_INTFC_PORT_CONFIG__STRAP_STATE_VAL_AUTO_CONFIG_RC_G1)) {
 667                         /*
 668                          * If this is really intended to be an EP port,
 669                          * record it so that the endpoint driver will know about it.
 670                          */
 671                         if (port_config.strap_state ==
 672                         TRIO_PCIE_INTFC_PORT_CONFIG__STRAP_STATE_VAL_AUTO_CONFIG_ENDPOINT ||
 673                         port_config.strap_state ==
 674                         TRIO_PCIE_INTFC_PORT_CONFIG__STRAP_STATE_VAL_AUTO_CONFIG_ENDPOINT_G1)
 675                                 pcie_ports[trio_index][mac].allow_ep = 1;
 676
 677                         continue;
 678                 }
 679
 680                 /*
 681                  * Delay the RC link training if needed.
 682                  */
 683                 if (rc_delay[trio_index][mac])
 684                         msleep(rc_delay[trio_index][mac] * 1000);
 685
 686                 ret = gxio_trio_force_rc_link_up(trio_context, mac);
 687                 if (ret < 0)
 688                         pr_err("PCI: PCIE_FORCE_LINK_UP failure, "
 689                                 "MAC %d on TRIO %d\n", mac, trio_index);
 690
 691                 pr_info("PCI: Found PCI controller #%d on TRIO %d MAC %d\n", i,
 692                         trio_index, controller->mac);
 693
 694                 /*
 695                  * Wait a bit here because some EP devices take longer
 696                  * to come up.
 697                  */
 698                 msleep(1000);
 699
 700                 /*
 701                  * Check for PCIe link-up status.
 702                  */
 703
 704                 reg_offset =
 705                         (TRIO_PCIE_INTFC_PORT_STATUS <<
 706                                 TRIO_CFG_REGION_ADDR__REG_SHIFT) |
 707                         (TRIO_CFG_REGION_ADDR__INTFC_VAL_MAC_INTERFACE <<
 708                                 TRIO_CFG_REGION_ADDR__INTFC_SHIFT ) |
 709                         (mac << TRIO_CFG_REGION_ADDR__MAC_SEL_SHIFT);
 710
 711                 port_status.word =
 712                         __gxio_mmio_read(trio_context->mmio_base_mac +
 713                                          reg_offset);
 714                 if (!port_status.dl_up) {
 715                         pr_err("PCI: link is down, MAC %d on TRIO %d\n",
 716                                 mac, trio_index);
 717                         continue;
 718                 }
 719
 720                 /*
 721                  * Ensure that the link can come out of L1 power down state.
 722                  * Strictly speaking, this is needed only in the case of
 723                  * heavy RC-initiated DMAs.
 724                  */
 725                 reg_offset =
 726                         (TRIO_PCIE_INTFC_TX_FIFO_CTL <<
 727                                 TRIO_CFG_REGION_ADDR__REG_SHIFT) |
 728                         (TRIO_CFG_REGION_ADDR__INTFC_VAL_MAC_INTERFACE <<
 729                                 TRIO_CFG_REGION_ADDR__INTFC_SHIFT ) |
 730                         (mac << TRIO_CFG_REGION_ADDR__MAC_SEL_SHIFT);
 731                 tx_fifo_ctl.word =
 732                         __gxio_mmio_read(trio_context->mmio_base_mac +
 733                                          reg_offset);
 734                 tx_fifo_ctl.min_p_credits = 0;
 735                 __gxio_mmio_write(trio_context->mmio_base_mac + reg_offset,
 736                                   tx_fifo_ctl.word);
 737
 738                 /*
 739                  * Change the device ID so that Linux bus crawl doesn't confuse
 740                  * the internal bridge with any Tilera endpoints.
 741                  */
 742
 743                 reg_offset =
 744                         (TRIO_PCIE_RC_DEVICE_ID_VEN_ID <<
 745                                 TRIO_CFG_REGION_ADDR__REG_SHIFT) |
 746                         (TRIO_CFG_REGION_ADDR__INTFC_VAL_MAC_STANDARD <<
 747                                 TRIO_CFG_REGION_ADDR__INTFC_SHIFT ) |
 748                         (mac << TRIO_CFG_REGION_ADDR__MAC_SEL_SHIFT);
 749
 750                 __gxio_mmio_write32(trio_context->mmio_base_mac + reg_offset,
 751                                     (TILERA_GX36_RC_DEV_ID <<
 752                                     TRIO_PCIE_RC_DEVICE_ID_VEN_ID__DEV_ID_SHIFT) |
 753                                     TILERA_VENDOR_ID);
 754
 755                 /*
 756                  * Set the internal P2P bridge class code.
 757                  */
 758
 759                 reg_offset =
 760                         (TRIO_PCIE_RC_REVISION_ID <<
 761                                 TRIO_CFG_REGION_ADDR__REG_SHIFT) |
 762                         (TRIO_CFG_REGION_ADDR__INTFC_VAL_MAC_STANDARD <<
 763                                 TRIO_CFG_REGION_ADDR__INTFC_SHIFT ) |
 764                         (mac << TRIO_CFG_REGION_ADDR__MAC_SEL_SHIFT);
 765
 766                 class_code_revision =
 767                         __gxio_mmio_read32(trio_context->mmio_base_mac +
 768                                            reg_offset);
 769                 class_code_revision = (class_code_revision & 0xff ) |
 770                                         (PCI_CLASS_BRIDGE_PCI << 16);
 771
 772                 __gxio_mmio_write32(trio_context->mmio_base_mac +
 773                                     reg_offset, class_code_revision);
 774
 775 #ifdef USE_SHARED_PCIE_CONFIG_REGION
 776
 777                 /*
 778                  * Map in the MMIO space for the PIO region.
 779                  */
 780                 offset = HV_TRIO_PIO_OFFSET(trio_context->pio_cfg_index) |
 781                         (((unsigned long long)mac) <<
 782                         TRIO_TILE_PIO_REGION_SETUP_CFG_ADDR__MAC_SHIFT);
 783
 784 #else
 785
 786                 /*
 787                  * Alloc a PIO region for PCI config access per MAC.
 788                  */
 789                 ret = gxio_trio_alloc_pio_regions(trio_context, 1, 0, 0);
 790                 if (ret < 0) {
 791                         pr_err("PCI: PCI CFG PIO alloc failure for mac %d "
 792                                 "on TRIO %d, give up\n", mac, trio_index);
 793
 794                         continue;
 795                 }
 796
 797                 trio_context->pio_cfg_index[mac] = ret;
 798
 799                 /*
 800                  * For PIO CFG, the bus_address_hi parameter is 0.
 801                  */
 802                 ret = gxio_trio_init_pio_region_aux(trio_context,
 803                         trio_context->pio_cfg_index[mac],
 804                         mac, 0, HV_TRIO_PIO_FLAG_CONFIG_SPACE);
 805                 if (ret < 0) {
 806                         pr_err("PCI: PCI CFG PIO init failure for mac %d "
 807                                 "on TRIO %d, give up\n", mac, trio_index);
 808
 809                         continue;
 810                 }
 811
 812                 offset = HV_TRIO_PIO_OFFSET(trio_context->pio_cfg_index[mac]) |
 813                         (((unsigned long long)mac) <<
 814                         TRIO_TILE_PIO_REGION_SETUP_CFG_ADDR__MAC_SHIFT);
 815
 816 #endif
 817
 818                 trio_context->mmio_base_pio_cfg[mac] =
 819                         iorpc_ioremap(trio_context->fd, offset,
 820                         (1 << TRIO_TILE_PIO_REGION_SETUP_CFG_ADDR__MAC_SHIFT));
 821                 if (trio_context->mmio_base_pio_cfg[mac] == NULL) {
 822                         pr_err("PCI: PIO map failure for mac %d on TRIO %d\n",
 823                                 mac, trio_index);
 824
 825                         continue;
 826                 }
 827
 828                 /*
 829                  * Initialize the PCIe interrupts.
 830                  */
 831                 if (tile_init_irqs(controller)) {
 832                         pr_err("PCI: IRQs init failure for mac %d on TRIO %d\n",
 833                                 mac, trio_index);
 834
 835                         continue;
 836                 }
 837
 838                 /*
 839                  * The PCI memory resource is located above the PA space.
 840                  * The memory range for the PCI root bus should not overlap
 841                  * with the physical RAM
 842                  */
 843                 pci_add_resource_offset(&resources, &controller->mem_space,
 844                                         controller->mem_offset);
 845
 846                 controller->first_busno = next_busno;
 847                 bus = pci_scan_root_bus(NULL, next_busno, controller->ops,
 848                                         controller, &resources);
 849                 controller->root_bus = bus;
 850                 next_busno = bus->busn_res.end + 1;
 851
 852         }
 853
 854         /* Do machine dependent PCI interrupt routing */
 855         pci_fixup_irqs(pci_common_swizzle, tile_map_irq);
 856
 857         /*
 858          * This comes from the generic Linux PCI driver.
 859          *
 860          * It allocates all of the resources (I/O memory, etc)
 861          * associated with the devices read in above.
 862          */
 863
 864         pci_assign_unassigned_resources();
 865
 866         /* Record the I/O resources in the PCI controller structure. */
 867         for (i = 0; i < num_rc_controllers; i++) {
 868                 struct pci_controller *controller = &pci_controllers[i];
 869                 gxio_trio_context_t *trio_context = controller->trio;
 870                 struct pci_bus *root_bus = pci_controllers[i].root_bus;
 871                 struct pci_bus *next_bus;
 872                 uint32_t bus_address_hi;
 873                 struct pci_dev *dev;
 874                 int ret;
 875                 int j;
 876
 877                 /*
 878                  * Skip controllers that are not properly initialized or
 879                  * have down links.
 880                  */
 881                 if (root_bus == NULL)
 882                         continue;
 883
 884                 /* Configure the max_payload_size values for this domain. */
 885                 fixup_read_and_payload_sizes(controller);
 886
 887                 list_for_each_entry(dev, &root_bus->devices, bus_list) {
 888                         /* Find the PCI host controller, ie. the 1st bridge. */
 889                         if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI &&
 890                                 (PCI_SLOT(dev->devfn) == 0)) {
 891                                 next_bus = dev->subordinate;
 892                                 pci_controllers[i].mem_resources[0] =
 893                                         *next_bus->resource[0];
 894                                 pci_controllers[i].mem_resources[1] =
 895                                          *next_bus->resource[1];
 896                                 pci_controllers[i].mem_resources[2] =
 897                                          *next_bus->resource[2];
 898
 899                                 break;
 900                         }
 901                 }
 902
 903                 if (pci_controllers[i].mem_resources[1].flags & IORESOURCE_MEM)
 904                         bus_address_hi =
 905                                 pci_controllers[i].mem_resources[1].start >> 32;
 906                 else if (pci_controllers[i].mem_resources[2].flags & IORESOURCE_PREFETCH)
 907                         bus_address_hi =
 908                                 pci_controllers[i].mem_resources[2].start >> 32;
 909                 else {
 910                         /* This is unlikely. */
 911                         pr_err("PCI: no memory resources on TRIO %d mac %d\n",
 912                                 controller->trio_index, controller->mac);
 913                         continue;
 914                 }
 915
 916                 /*
 917                  * Alloc a PIO region for PCI memory access for each RC port.
 918                  */
 919                 ret = gxio_trio_alloc_pio_regions(trio_context, 1, 0, 0);
 920                 if (ret < 0) {
 921                         pr_err("PCI: MEM PIO alloc failure on TRIO %d mac %d, "
 922                                 "give up\n", controller->trio_index,
 923                                 controller->mac);
 924
 925                         continue;
 926                 }
 927
 928                 controller->pio_mem_index = ret;
 929
 930                 /*
 931                  * For PIO MEM, the bus_address_hi parameter is hard-coded 0
 932                  * because we always assign 32-bit PCI bus BAR ranges.
 933                  */
 934                 ret = gxio_trio_init_pio_region_aux(trio_context,
 935                                                     controller->pio_mem_index,
 936                                                     controller->mac,
 937                                                     0,
 938                                                     0);
 939                 if (ret < 0) {
 940                         pr_err("PCI: MEM PIO init failure on TRIO %d mac %d, "
 941                                 "give up\n", controller->trio_index,
 942                                 controller->mac);
 943
 944                         continue;
 945                 }
 946
 947                 /*
 948                  * Configure a Mem-Map region for each memory controller so
 949                  * that Linux can map all of its PA space to the PCI bus.
 950                  * Use the IOMMU to handle hash-for-home memory.
 951                  */
 952                 for_each_online_node(j) {
 953                         unsigned long start_pfn = node_start_pfn[j];
 954                         unsigned long end_pfn = node_end_pfn[j];
 955                         unsigned long nr_pages = end_pfn - start_pfn;
 956
 957                         ret = gxio_trio_alloc_memory_maps(trio_context, 1, 0,
 958                                                           0);
 959                         if (ret < 0) {
 960                                 pr_err("PCI: Mem-Map alloc failure on TRIO %d "
 961                                         "mac %d for MC %d, give up\n",
 962                                         controller->trio_index,
 963                                         controller->mac, j);
 964
 965                                 goto alloc_mem_map_failed;
 966                         }
 967
 968                         controller->mem_maps[j] = ret;
 969
 970                         /*
 971                          * Initialize the Mem-Map and the I/O MMU so that all
 972                          * the physical memory can be accessed by the endpoint
 973                          * devices. The base bus address is set to the base CPA
 974                          * of this memory controller plus an offset (see pci.h).
 975                          * The region's base VA is set to the base CPA. The
 976                          * I/O MMU table essentially translates the CPA to
 977                          * the real PA. Implicitly, for node 0, we create
 978                          * a separate Mem-Map region that serves as the inbound
 979                          * window for legacy 32-bit devices. This is a direct
 980                          * map of the low 4GB CPA space.
 981                          */
 982                         ret = gxio_trio_init_memory_map_mmu_aux(trio_context,
 983                                 controller->mem_maps[j],
 984                                 start_pfn << PAGE_SHIFT,
 985                                 nr_pages << PAGE_SHIFT,
 986                                 trio_context->asid,
 987                                 controller->mac,
 988                                 (start_pfn << PAGE_SHIFT) +
 989                                 TILE_PCI_MEM_MAP_BASE_OFFSET,
 990                                 j,
 991                                 GXIO_TRIO_ORDER_MODE_UNORDERED);
 992                         if (ret < 0) {
 993                                 pr_err("PCI: Mem-Map init failure on TRIO %d "
 994                                         "mac %d for MC %d, give up\n",
 995                                         controller->trio_index,
 996                                         controller->mac, j);
 997
 998                                 goto alloc_mem_map_failed;
 999                         }
1000                         continue;
1001
1002 alloc_mem_map_failed:
1003                         break;
1004                 }
1005
1006         }
1007
1008         return 0;
1009 }
1010 subsys_initcall(pcibios_init);
1011
1012 /* Note: to be deleted after Linux 3.6 merge. */
1013 void pcibios_fixup_bus(struct pci_bus *bus)
1014 {
1015 }
1016
1017 /*
1018  * This can be called from the generic PCI layer, but doesn't need to
1019  * do anything.
1020  */
1021 char *pcibios_setup(char *str)
1022 {
1023         if (!strcmp(str, "off")) {
1024                 pci_probe = 0;
1025                 return NULL;
1026         }
1027         return str;
1028 }
1029
1030 /*
1031  * Enable memory address decoding, as appropriate, for the
1032  * device described by the 'dev' struct. The I/O decoding
1033  * is disabled, though the TILE-Gx supports I/O addressing.
1034  *
1035  * This is called from the generic PCI layer, and can be called
1036  * for bridges or endpoints.
1037  */
1038 int pcibios_enable_device(struct pci_dev *dev, int mask)
1039 {
1040         return pci_enable_resources(dev, mask);
1041 }
1042
1043 /* Called for each device after PCI setup is done. */
1044 static void pcibios_fixup_final(struct pci_dev *pdev)
1045 {
1046         set_dma_ops(&pdev->dev, gx_pci_dma_map_ops);
1047         set_dma_offset(&pdev->dev, TILE_PCI_MEM_MAP_BASE_OFFSET);
1048         pdev->dev.archdata.max_direct_dma_addr =
1049                 TILE_PCI_MAX_DIRECT_DMA_ADDRESS;
1050 }
1051 DECLARE_PCI_FIXUP_FINAL(PCI_ANY_ID, PCI_ANY_ID, pcibios_fixup_final);
1052
1053 /* Map a PCI MMIO bus address into VA space. */
1054 void __iomem *ioremap(resource_size_t phys_addr, unsigned long size)
1055 {
1056         struct pci_controller *controller = NULL;
1057         resource_size_t bar_start;
1058         resource_size_t bar_end;
1059         resource_size_t offset;
1060         resource_size_t start;
1061         resource_size_t end;
1062         int trio_fd;
1063         int i, j;
1064
1065         start = phys_addr;
1066         end = phys_addr + size - 1;
1067
1068         /*
1069          * In the following, each PCI controller's mem_resources[1]
1070          * represents its (non-prefetchable) PCI memory resource and
1071          * mem_resources[2] refers to its prefetchable PCI memory resource.
1072          * By searching phys_addr in each controller's mem_resources[], we can
1073          * determine the controller that should accept the PCI memory access.
1074          */
1075
1076         for (i = 0; i < num_rc_controllers; i++) {
1077                 /*
1078                  * Skip controllers that are not properly initialized or
1079                  * have down links.
1080                  */
1081                 if (pci_controllers[i].root_bus == NULL)
1082                         continue;
1083
1084                 for (j = 1; j < 3; j++) {
1085                         bar_start =
1086                                 pci_controllers[i].mem_resources[j].start;
1087                         bar_end =
1088                                 pci_controllers[i].mem_resources[j].end;
1089
1090                         if ((start >= bar_start) && (end <= bar_end)) {
1091
1092                                 controller = &pci_controllers[i];
1093
1094                                 goto got_it;
1095                         }
1096                 }
1097         }
1098
1099         if (controller == NULL)
1100                 return NULL;
1101
1102 got_it:
1103         trio_fd = controller->trio->fd;
1104
1105         /* Convert the resource start to the bus address offset. */
1106         start = phys_addr - controller->mem_offset;
1107
1108         offset = HV_TRIO_PIO_OFFSET(controller->pio_mem_index) + start;
1109
1110         /*
1111          * We need to keep the PCI bus address's in-page offset in the VA.
1112          */
1113         return iorpc_ioremap(trio_fd, offset, size) +
1114                 (phys_addr & (PAGE_SIZE - 1));
1115 }
1116 EXPORT_SYMBOL(ioremap);
1117
1118 void pci_iounmap(struct pci_dev *dev, void __iomem *addr)
1119 {
1120         iounmap(addr);
1121 }
1122 EXPORT_SYMBOL(pci_iounmap);
1123
1124 /****************************************************************
1125  *
1126  * Tile PCI config space read/write routines
1127  *
1128  ****************************************************************/
1129
1130 /*
1131  * These are the normal read and write ops
1132  * These are expanded with macros from  pci_bus_read_config_byte() etc.
1133  *
1134  * devfn is the combined PCI device & function.
1135  *
1136  * offset is in bytes, from the start of config space for the
1137  * specified bus & device.
1138  */
1139
1140 static int tile_cfg_read(struct pci_bus *bus, unsigned int devfn, int offset,
1141                          int size, u32 *val)
1142 {
1143         struct pci_controller *controller = bus->sysdata;
1144         gxio_trio_context_t *trio_context = controller->trio;
1145         int busnum = bus->number & 0xff;
1146         int device = PCI_SLOT(devfn);
1147         int function = PCI_FUNC(devfn);
1148         int config_type = 1;
1149         TRIO_TILE_PIO_REGION_SETUP_CFG_ADDR_t cfg_addr;
1150         void *mmio_addr;
1151
1152         /*
1153          * Map all accesses to the local device on root bus into the
1154          * MMIO space of the MAC. Accesses to the downstream devices
1155          * go to the PIO space.
1156          */
1157         if (pci_is_root_bus(bus)) {
1158                 if (device == 0) {
1159                         /*
1160                          * This is the internal downstream P2P bridge,
1161                          * access directly.
1162                          */
1163                         unsigned int reg_offset;
1164
1165                         reg_offset = ((offset & 0xFFF) <<
1166                                 TRIO_CFG_REGION_ADDR__REG_SHIFT) |
1167                                 (TRIO_CFG_REGION_ADDR__INTFC_VAL_MAC_PROTECTED
1168                                 << TRIO_CFG_REGION_ADDR__INTFC_SHIFT ) |
1169                                 (controller->mac <<
1170                                         TRIO_CFG_REGION_ADDR__MAC_SEL_SHIFT);
1171
1172                         mmio_addr = trio_context->mmio_base_mac + reg_offset;
1173
1174                         goto valid_device;
1175
1176                 } else {
1177                         /*
1178                          * We fake an empty device for (device > 0),
1179                          * since there is only one device on bus 0.
1180                          */
1181                         goto invalid_device;
1182                 }
1183         }
1184
1185         /*
1186          * Accesses to the directly attached device have to be
1187          * sent as type-0 configs.
1188          */
1189
1190         if (busnum == (controller->first_busno + 1)) {
1191                 /*
1192                  * There is only one device off of our built-in P2P bridge.
1193                  */
1194                 if (device != 0)
1195                         goto invalid_device;
1196
1197                 config_type = 0;
1198         }
1199
1200         cfg_addr.word = 0;
1201         cfg_addr.reg_addr = (offset & 0xFFF);
1202         cfg_addr.fn = function;
1203         cfg_addr.dev = device;
1204         cfg_addr.bus = busnum;
1205         cfg_addr.type = config_type;
1206
1207         /*
1208          * Note that we don't set the mac field in cfg_addr because the
1209          * mapping is per port.
1210          */
1211
1212         mmio_addr = trio_context->mmio_base_pio_cfg[controller->mac] +
1213                         cfg_addr.word;
1214
1215 valid_device:
1216
1217         switch (size) {
1218         case 4:
1219                 *val = __gxio_mmio_read32(mmio_addr);
1220                 break;
1221
1222         case 2:
1223                 *val = __gxio_mmio_read16(mmio_addr);
1224                 break;
1225
1226         case 1:
1227                 *val = __gxio_mmio_read8(mmio_addr);
1228                 break;
1229
1230         default:
1231                 return PCIBIOS_FUNC_NOT_SUPPORTED;
1232         }
1233
1234         TRACE_CFG_RD(size, *val, busnum, device, function, offset);
1235
1236         return 0;
1237
1238 invalid_device:
1239
1240         switch (size) {
1241         case 4:
1242                 *val = 0xFFFFFFFF;
1243                 break;
1244
1245         case 2:
1246                 *val = 0xFFFF;
1247                 break;
1248
1249         case 1:
1250                 *val = 0xFF;
1251                 break;
1252
1253         default:
1254                 return PCIBIOS_FUNC_NOT_SUPPORTED;
1255         }
1256
1257         return 0;
1258 }
1259
1260
1261 /*
1262  * See tile_cfg_read() for relevent comments.
1263  * Note that "val" is the value to write, not a pointer to that value.
1264  */
1265 static int tile_cfg_write(struct pci_bus *bus, unsigned int devfn, int offset,
1266                           int size, u32 val)
1267 {
1268         struct pci_controller *controller = bus->sysdata;
1269         gxio_trio_context_t *trio_context = controller->trio;
1270         int busnum = bus->number & 0xff;
1271         int device = PCI_SLOT(devfn);
1272         int function = PCI_FUNC(devfn);
1273         int config_type = 1;
1274         TRIO_TILE_PIO_REGION_SETUP_CFG_ADDR_t cfg_addr;
1275         void *mmio_addr;
1276         u32 val_32 = (u32)val;
1277         u16 val_16 = (u16)val;
1278         u8 val_8 = (u8)val;
1279
1280         /*
1281          * Map all accesses to the local device on root bus into the
1282          * MMIO space of the MAC. Accesses to the downstream devices
1283          * go to the PIO space.
1284          */
1285         if (pci_is_root_bus(bus)) {
1286                 if (device == 0) {
1287                         /*
1288                          * This is the internal downstream P2P bridge,
1289                          * access directly.
1290                          */
1291                         unsigned int reg_offset;
1292
1293                         reg_offset = ((offset & 0xFFF) <<
1294                                 TRIO_CFG_REGION_ADDR__REG_SHIFT) |
1295                                 (TRIO_CFG_REGION_ADDR__INTFC_VAL_MAC_PROTECTED
1296                                 << TRIO_CFG_REGION_ADDR__INTFC_SHIFT ) |
1297                                 (controller->mac <<
1298                                         TRIO_CFG_REGION_ADDR__MAC_SEL_SHIFT);
1299
1300                         mmio_addr = trio_context->mmio_base_mac + reg_offset;
1301
1302                         goto valid_device;
1303
1304                 } else {
1305                         /*
1306                          * We fake an empty device for (device > 0),
1307                          * since there is only one device on bus 0.
1308                          */
1309                         goto invalid_device;
1310                 }
1311         }
1312
1313         /*
1314          * Accesses to the directly attached device have to be
1315          * sent as type-0 configs.
1316          */
1317
1318         if (busnum == (controller->first_busno + 1)) {
1319                 /*
1320                  * There is only one device off of our built-in P2P bridge.
1321                  */
1322                 if (device != 0)
1323                         goto invalid_device;
1324
1325                 config_type = 0;
1326         }
1327
1328         cfg_addr.word = 0;
1329         cfg_addr.reg_addr = (offset & 0xFFF);
1330         cfg_addr.fn = function;
1331         cfg_addr.dev = device;
1332         cfg_addr.bus = busnum;
1333         cfg_addr.type = config_type;
1334
1335         /*
1336          * Note that we don't set the mac field in cfg_addr because the
1337          * mapping is per port.
1338          */
1339
1340         mmio_addr = trio_context->mmio_base_pio_cfg[controller->mac] +
1341                         cfg_addr.word;
1342
1343 valid_device:
1344
1345         switch (size) {
1346         case 4:
1347                 __gxio_mmio_write32(mmio_addr, val_32);
1348                 TRACE_CFG_WR(size, val_32, busnum, device, function, offset);
1349                 break;
1350
1351         case 2:
1352                 __gxio_mmio_write16(mmio_addr, val_16);
1353                 TRACE_CFG_WR(size, val_16, busnum, device, function, offset);
1354                 break;
1355
1356         case 1:
1357                 __gxio_mmio_write8(mmio_addr, val_8);
1358                 TRACE_CFG_WR(size, val_8, busnum, device, function, offset);
1359                 break;
1360
1361         default:
1362                 return PCIBIOS_FUNC_NOT_SUPPORTED;
1363         }
1364
1365 invalid_device:
1366
1367         return 0;
1368 }
1369
1370
1371 static struct pci_ops tile_cfg_ops = {
1372         .read =         tile_cfg_read,
1373         .write =        tile_cfg_write,
1374 };
1375
1376
1377 /*
1378  * MSI support starts here.
1379  */
1380 static unsigned int
1381 tilegx_msi_startup(struct irq_data *d)
1382 {
1383         if (d->msi_desc)
1384                 unmask_msi_irq(d);
1385
1386         return 0;
1387 }
1388
1389 static void
1390 tilegx_msi_ack(struct irq_data *d)
1391 {
1392         __insn_mtspr(SPR_IPI_EVENT_RESET_K, 1UL << d->irq);
1393 }
1394
1395 static void
1396 tilegx_msi_mask(struct irq_data *d)
1397 {
1398         mask_msi_irq(d);
1399         __insn_mtspr(SPR_IPI_MASK_SET_K, 1UL << d->irq);
1400 }
1401
1402 static void
1403 tilegx_msi_unmask(struct irq_data *d)
1404 {
1405         __insn_mtspr(SPR_IPI_MASK_RESET_K, 1UL << d->irq);
1406         unmask_msi_irq(d);
1407 }
1408
1409 static struct irq_chip tilegx_msi_chip = {
1410         .name                   = "tilegx_msi",
1411         .irq_startup            = tilegx_msi_startup,
1412         .irq_ack                = tilegx_msi_ack,
1413         .irq_mask               = tilegx_msi_mask,
1414         .irq_unmask             = tilegx_msi_unmask,
1415
1416         /* TBD: support set_affinity. */
1417 };
1418
1419 int arch_setup_msi_irq(struct pci_dev *pdev, struct msi_desc *desc)
1420 {
1421         struct pci_controller *controller;
1422         gxio_trio_context_t *trio_context;
1423         struct msi_msg msg;
1424         int default_irq;
1425         uint64_t mem_map_base;
1426         uint64_t mem_map_limit;
1427         u64 msi_addr;
1428         int mem_map;
1429         int cpu;
1430         int irq;
1431         int ret;
1432
1433         irq = create_irq();
1434         if (irq < 0)
1435                 return irq;
1436
1437         /*
1438          * Since we use a 64-bit Mem-Map to accept the MSI write, we fail
1439          * devices that are not capable of generating a 64-bit message address.
1440          * These devices will fall back to using the legacy interrupts.
1441          * Most PCIe endpoint devices do support 64-bit message addressing.
1442          */
1443         if (desc->msi_attrib.is_64 == 0) {
1444                 dev_printk(KERN_INFO, &pdev->dev,
1445                         "64-bit MSI message address not supported, "
1446                         "falling back to legacy interrupts.\n");
1447
1448                 ret = -ENOMEM;
1449                 goto is_64_failure;
1450         }
1451
1452         default_irq = desc->msi_attrib.default_irq;
1453         controller = irq_get_handler_data(default_irq);
1454
1455         BUG_ON(!controller);
1456
1457         trio_context = controller->trio;
1458
1459         /*
1460          * Allocate the Mem-Map that will accept the MSI write and
1461          * trigger the TILE-side interrupts.
1462          */
1463         mem_map = gxio_trio_alloc_memory_maps(trio_context, 1, 0, 0);
1464         if (mem_map < 0) {
1465                 dev_printk(KERN_INFO, &pdev->dev,
1466                         "%s Mem-Map alloc failure. "
1467                         "Failed to initialize MSI interrupts. "
1468                         "Falling back to legacy interrupts.\n",
1469                         desc->msi_attrib.is_msix ? "MSI-X" : "MSI");
1470
1471                 ret = -ENOMEM;
1472                 goto msi_mem_map_alloc_failure;
1473         }
1474
1475         /* We try to distribute different IRQs to different tiles. */
1476         cpu = tile_irq_cpu(irq);
1477
1478         /*
1479          * Now call up to the HV to configure the Mem-Map interrupt and
1480          * set up the IPI binding.
1481          */
1482         mem_map_base = MEM_MAP_INTR_REGIONS_BASE +
1483                 mem_map * MEM_MAP_INTR_REGION_SIZE;
1484         mem_map_limit = mem_map_base + MEM_MAP_INTR_REGION_SIZE - 1;
1485
1486         ret = gxio_trio_config_msi_intr(trio_context, cpu_x(cpu), cpu_y(cpu),
1487                                         KERNEL_PL, irq, controller->mac,
1488                                         mem_map, mem_map_base, mem_map_limit,
1489                                         trio_context->asid);
1490         if (ret < 0) {
1491                 dev_printk(KERN_INFO, &pdev->dev, "HV MSI config failed.\n");
1492
1493                 goto hv_msi_config_failure;
1494         }
1495
1496         irq_set_msi_desc(irq, desc);
1497
1498         msi_addr = mem_map_base + TRIO_MAP_MEM_REG_INT3 - TRIO_MAP_MEM_REG_INT0;
1499
1500         msg.address_hi = msi_addr >> 32;
1501         msg.address_lo = msi_addr & 0xffffffff;
1502
1503         msg.data = mem_map;
1504
1505         write_msi_msg(irq, &msg);
1506         irq_set_chip_and_handler(irq, &tilegx_msi_chip, handle_level_irq);
1507         irq_set_handler_data(irq, controller);
1508
1509         return 0;
1510
1511 hv_msi_config_failure:
1512         /* Free mem-map */
1513 msi_mem_map_alloc_failure:
1514 is_64_failure:
1515         destroy_irq(irq);
1516         return ret;
1517 }
1518
1519 void arch_teardown_msi_irq(unsigned int irq)
1520 {
1521         destroy_irq(irq);
1522 }