sys/mips/nlm/xlp_pci.c

   1 /*-
   2  * Copyright (c) 2003-2012 Broadcom Corporation
   3  * All Rights Reserved
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in
  13  *    the documentation and/or other materials provided with the
  14  *    distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY BROADCOM ``AS IS'' AND ANY EXPRESS OR
  17  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  18  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL BROADCOM OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  23  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  24  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  25  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  26  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/types.h>
  35 #include <sys/kernel.h>
  36 #include <sys/module.h>
  37 #include <sys/malloc.h>
  38 #include <sys/bus.h>
  39 #include <sys/endian.h>
  40 #include <sys/rman.h>
  41 #include <sys/pciio.h>
  42
  43 #include <vm/vm.h>
  44 #include <vm/vm_param.h>
  45 #include <vm/pmap.h>
  46
  47 #include <dev/pci/pcivar.h>
  48 #include <dev/pci/pcireg.h>
  49 #include <dev/pci/pci_private.h>
  50
  51 #include <dev/uart/uart.h>
  52 #include <dev/uart/uart_bus.h>
  53 #include <dev/uart/uart_cpu.h>
  54
  55 #include <machine/bus.h>
  56 #include <machine/md_var.h>
  57 #include <machine/intr_machdep.h>
  58 #include <machine/cpuregs.h>
  59
  60 #include <mips/nlm/hal/haldefs.h>
  61 #include <mips/nlm/interrupt.h>
  62 #include <mips/nlm/hal/iomap.h>
  63 #include <mips/nlm/hal/mips-extns.h>
  64 #include <mips/nlm/hal/pic.h>
  65 #include <mips/nlm/hal/bridge.h>
  66 #include <mips/nlm/hal/gbu.h>
  67 #include <mips/nlm/hal/pcibus.h>
  68 #include <mips/nlm/hal/uart.h>
  69 #include <mips/nlm/xlp.h>
  70
  71 #include "pcib_if.h"
  72 #include "pci_if.h"
  73
  74 #define EMUL_MEM_START  0x16000000UL
  75 #define EMUL_MEM_END    0x18ffffffUL
  76
  77 /* SoC device qurik handling */
  78 static int irt_irq_map[4 * 256];
  79 static int irq_irt_map[64];
  80
  81 static void
  82 xlp_add_irq(int node, int irt, int irq)
  83 {
  84         int nodeirt = node * 256 + irt;
  85
  86         irt_irq_map[nodeirt] = irq;
  87         irq_irt_map[irq] = nodeirt;
  88 }
  89
  90 int
  91 xlp_irq_to_irt(int irq)
  92 {
  93         return irq_irt_map[irq];
  94 }
  95
  96 int
  97 xlp_irt_to_irq(int nodeirt)
  98 {
  99         return irt_irq_map[nodeirt];
 100 }
 101
 102 /* Override PCI a bit for SoC devices */
 103
 104 enum {
 105         INTERNAL_DEV    = 0x1,  /* internal device, skip on enumeration */
 106         MEM_RES_EMUL    = 0x2,  /* no MEM or IO bar, custom res alloc */
 107         SHARED_IRQ      = 0x4,
 108         DEV_MMIO32      = 0x8,  /* byte access not allowed to mmio */
 109 };
 110
 111 struct soc_dev_desc {
 112         u_int   devid;          /* device ID */
 113         int     irqbase;        /* start IRQ */
 114         u_int   flags;          /* flags */
 115         int     ndevs;          /* to keep track of number of devices */
 116 };
 117
 118 struct soc_dev_desc xlp_dev_desc[] = {
 119         { PCI_DEVICE_ID_NLM_ICI,               0, INTERNAL_DEV },
 120         { PCI_DEVICE_ID_NLM_PIC,               0, INTERNAL_DEV },
 121         { PCI_DEVICE_ID_NLM_FMN,               0, INTERNAL_DEV },
 122         { PCI_DEVICE_ID_NLM_UART, PIC_UART_0_IRQ, MEM_RES_EMUL | DEV_MMIO32},
 123         { PCI_DEVICE_ID_NLM_I2C,               0, MEM_RES_EMUL | DEV_MMIO32 },
 124         { PCI_DEVICE_ID_NLM_NOR,               0, MEM_RES_EMUL },
 125         { PCI_DEVICE_ID_NLM_MMC,     PIC_MMC_IRQ, MEM_RES_EMUL },
 126         { PCI_DEVICE_ID_NLM_EHCI, PIC_EHCI_0_IRQ, 0 }
 127 };
 128
 129 struct  xlp_devinfo {
 130         struct pci_devinfo pcidev;
 131         int     irq;
 132         int     flags;
 133         u_long  mem_res_start;
 134 };
 135
 136 static __inline struct soc_dev_desc *
 137 xlp_find_soc_desc(int devid)
 138 {
 139         struct soc_dev_desc *p;
 140         int i, n;
 141
 142         n = sizeof(xlp_dev_desc) / sizeof(xlp_dev_desc[0]);
 143         for (i = 0, p = xlp_dev_desc; i < n; i++, p++)
 144                 if (p->devid == devid)
 145                         return (p);
 146         return (NULL);
 147 }
 148
 149 static struct resource *
 150 xlp_pci_alloc_resource(device_t bus, device_t child, int type, int *rid,
 151     u_long start, u_long end, u_long count, u_int flags)
 152 {
 153         struct resource *r;
 154         struct xlp_devinfo *xlp_devinfo;
 155         int busno;
 156
 157         /*
 158          * Do custom allocation for MEMORY resource for SoC device if
 159          * MEM_RES_EMUL flag is set
 160          */
 161         busno = pci_get_bus(child);
 162         if ((type == SYS_RES_MEMORY || type == SYS_RES_IOPORT) && busno == 0) {
 163                 xlp_devinfo = (struct xlp_devinfo *)device_get_ivars(child);
 164                 if ((xlp_devinfo->flags & MEM_RES_EMUL) != 0) {
 165                         /* no emulation for IO ports */
 166                         if (type == SYS_RES_IOPORT)
 167                                 return (NULL);
 168
 169                         start = xlp_devinfo->mem_res_start;
 170                         count = XLP_PCIE_CFG_SIZE - XLP_IO_PCI_HDRSZ;
 171
 172                         /* MMC needs to 2 slots with rids 16 and 20 and a
 173                          * fixup for size */
 174                         if (pci_get_device(child) == PCI_DEVICE_ID_NLM_MMC) {
 175                                 count = 0x100;
 176                                 if (*rid == 16)
 177                                         ; /* first slot already setup */
 178                                 else if (*rid == 20)
 179                                         start += 0x100; /* second slot */
 180                                 else
 181                                         return (NULL);
 182                         }
 183
 184                         end = start + count - 1;
 185                         r = BUS_ALLOC_RESOURCE(device_get_parent(bus), child,
 186                             type, rid, start, end, count, flags);
 187                         if (r == NULL)
 188                                 return (NULL);
 189                         if ((xlp_devinfo->flags & DEV_MMIO32) != 0)
 190                                 rman_set_bustag(r, rmi_uart_bus_space);
 191                         return (r);
 192                 }
 193         }
 194
 195         /* Not custom alloc, use PCI code */
 196         return (pci_alloc_resource(bus, child, type, rid, start, end, count,
 197             flags));
 198 }
 199
 200 static int
 201 xlp_pci_release_resource(device_t bus, device_t child, int type, int rid,
 202     struct resource *r)
 203 {
 204         u_long start;
 205
 206         /* If custom alloc, handle that */
 207         start = rman_get_start(r);
 208         if (type == SYS_RES_MEMORY && pci_get_bus(child) == 0 &&
 209             start >= EMUL_MEM_START && start <= EMUL_MEM_END)
 210                 return (BUS_RELEASE_RESOURCE(device_get_parent(bus), child,
 211                     type, rid, r));
 212
 213         /* use default PCI function */
 214         return (bus_generic_rl_release_resource(bus, child, type, rid, r));
 215 }
 216
 217 static void
 218 xlp_add_soc_child(device_t pcib, device_t dev, int b, int s, int f)
 219 {
 220         struct pci_devinfo *dinfo;
 221         struct xlp_devinfo *xlp_dinfo;
 222         struct soc_dev_desc *si;
 223         uint64_t pcibase;
 224         int domain, node, irt, irq, flags, devoffset, num;
 225         uint16_t devid;
 226
 227         domain = pcib_get_domain(dev);
 228         node = s / 8;
 229         devoffset = XLP_HDR_OFFSET(node, 0, s % 8, f);
 230         if (!nlm_dev_exists(devoffset))
 231                 return;
 232
 233         /* Find if there is a desc for the SoC device */
 234         devid = PCIB_READ_CONFIG(pcib, b, s, f, PCIR_DEVICE, 2);
 235         si = xlp_find_soc_desc(devid);
 236
 237         /* update flags and irq from desc if available */
 238         irq = 0;
 239         flags = 0;
 240         if (si != NULL) {
 241                 if (si->irqbase != 0)
 242                         irq = si->irqbase + si->ndevs;
 243                 flags = si->flags;
 244                 si->ndevs++;
 245         }
 246
 247         /* skip internal devices */
 248         if ((flags & INTERNAL_DEV) != 0)
 249                 return;
 250
 251         /* PCIe interfaces are special, bug in Ax */
 252         if (devid == PCI_DEVICE_ID_NLM_PCIE) {
 253                 xlp_add_irq(node, xlp_pcie_link_irt(f), PIC_PCIE_0_IRQ + f);
 254         } else {
 255                 /* Stash intline and pin in shadow reg for devices */
 256                 pcibase = nlm_pcicfg_base(devoffset);
 257                 irt = nlm_irtstart(pcibase);
 258                 num = nlm_irtnum(pcibase);
 259                 if (irq != 0 && num > 0) {
 260                         xlp_add_irq(node, irt, irq);
 261                         nlm_write_reg(pcibase, XLP_PCI_DEVSCRATCH_REG0,
 262                             (1 << 8) | irq);
 263                 }
 264         }
 265         dinfo = pci_read_device(pcib, domain, b, s, f, sizeof(*xlp_dinfo));
 266         if (dinfo == NULL)
 267                 return;
 268         xlp_dinfo = (struct xlp_devinfo *)dinfo;
 269         xlp_dinfo->irq = irq;
 270         xlp_dinfo->flags = flags;
 271
 272         /* memory resource from ecfg space, if MEM_RES_EMUL is set */
 273         if ((flags & MEM_RES_EMUL) != 0)
 274                 xlp_dinfo->mem_res_start = XLP_DEFAULT_IO_BASE + devoffset +
 275                     XLP_IO_PCI_HDRSZ;
 276         pci_add_child(dev, dinfo);
 277 }
 278
 279 static int
 280 xlp_pci_attach(device_t dev)
 281 {
 282         device_t pcib = device_get_parent(dev);
 283         int maxslots, s, f, pcifunchigh;
 284         int busno;
 285         uint8_t hdrtype;
 286
 287         /*
 288          * The on-chip devices are on a bus that is almost, but not
 289          * quite, completely like PCI. Add those things by hand.
 290          */
 291         busno = pcib_get_bus(dev);
 292         maxslots = PCIB_MAXSLOTS(pcib);
 293         for (s = 0; s <= maxslots; s++) {
 294                 pcifunchigh = 0;
 295                 f = 0;
 296                 hdrtype = PCIB_READ_CONFIG(pcib, busno, s, f, PCIR_HDRTYPE, 1);
 297                 if ((hdrtype & PCIM_HDRTYPE) > PCI_MAXHDRTYPE)
 298                         continue;
 299                 if (hdrtype & PCIM_MFDEV)
 300                         pcifunchigh = PCI_FUNCMAX;
 301                 for (f = 0; f <= pcifunchigh; f++)
 302                         xlp_add_soc_child(pcib, dev, busno, s, f);
 303         }
 304         return (bus_generic_attach(dev));
 305 }
 306
 307 static int
 308 xlp_pci_probe(device_t dev)
 309 {
 310         device_t pcib;
 311
 312         pcib = device_get_parent(dev);
 313         /*
 314          * Only the top level bus has SoC devices, leave the rest to
 315          * Generic PCI code
 316          */
 317         if (strcmp(device_get_nameunit(pcib), "pcib0") != 0)
 318                 return (ENXIO);
 319         device_set_desc(dev, "XLP SoCbus");
 320         return (BUS_PROBE_DEFAULT);
 321 }
 322
 323 static devclass_t pci_devclass;
 324 static device_method_t xlp_pci_methods[] = {
 325         /* Device interface */
 326         DEVMETHOD(device_probe,         xlp_pci_probe),
 327         DEVMETHOD(device_attach,        xlp_pci_attach),
 328         DEVMETHOD(bus_alloc_resource,   xlp_pci_alloc_resource),
 329         DEVMETHOD(bus_release_resource, xlp_pci_release_resource),
 330
 331         DEVMETHOD_END
 332 };
 333
 334 DEFINE_CLASS_1(pci, xlp_pci_driver, xlp_pci_methods, sizeof(struct pci_softc),
 335     pci_driver);
 336 DRIVER_MODULE(xlp_pci, pcib, xlp_pci_driver, pci_devclass, 0, 0);
 337
 338 static devclass_t pcib_devclass;
 339 static struct rman irq_rman, port_rman, mem_rman, emul_rman;
 340
 341 static void
 342 xlp_pcib_init_resources(void)
 343 {
 344         irq_rman.rm_start = 0;
 345         irq_rman.rm_end = 255;
 346         irq_rman.rm_type = RMAN_ARRAY;
 347         irq_rman.rm_descr = "PCI Mapped Interrupts";
 348         if (rman_init(&irq_rman)
 349             || rman_manage_region(&irq_rman, 0, 255))
 350                 panic("pci_init_resources irq_rman");
 351
 352         port_rman.rm_start = 0;
 353         port_rman.rm_end = ~0ul;
 354         port_rman.rm_type = RMAN_ARRAY;
 355         port_rman.rm_descr = "I/O ports";
 356         if (rman_init(&port_rman)
 357             || rman_manage_region(&port_rman, PCIE_IO_BASE, PCIE_IO_LIMIT))
 358                 panic("pci_init_resources port_rman");
 359
 360         mem_rman.rm_start = 0;
 361         mem_rman.rm_end = ~0ul;
 362         mem_rman.rm_type = RMAN_ARRAY;
 363         mem_rman.rm_descr = "I/O memory";
 364         if (rman_init(&mem_rman)
 365             || rman_manage_region(&mem_rman, PCIE_MEM_BASE, PCIE_MEM_LIMIT))
 366                 panic("pci_init_resources mem_rman");
 367
 368         /*
 369          * This includes the GBU (nor flash) memory range and the PCIe
 370          * memory area.
 371          */
 372         emul_rman.rm_start = 0;
 373         emul_rman.rm_end = ~0ul;
 374         emul_rman.rm_type = RMAN_ARRAY;
 375         emul_rman.rm_descr = "Emulated MEMIO";
 376         if (rman_init(&emul_rman)
 377             || rman_manage_region(&emul_rman, EMUL_MEM_START, EMUL_MEM_END))
 378                 panic("pci_init_resources emul_rman");
 379 }
 380
 381 static int
 382 xlp_pcib_probe(device_t dev)
 383 {
 384
 385         device_set_desc(dev, "XLP PCI bus");
 386         return (BUS_PROBE_NOWILDCARD);
 387 }
 388
 389 static int
 390 xlp_pcib_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)
 391 {
 392
 393         switch (which) {
 394         case PCIB_IVAR_DOMAIN:
 395                 *result = 0;
 396                 return (0);
 397         case PCIB_IVAR_BUS:
 398                 *result = 0;
 399                 return (0);
 400         }
 401         return (ENOENT);
 402 }
 403
 404 static int
 405 xlp_pcib_write_ivar(device_t dev, device_t child, int which, uintptr_t result)
 406 {
 407         switch (which) {
 408         case PCIB_IVAR_DOMAIN:
 409                 return (EINVAL);
 410         case PCIB_IVAR_BUS:
 411                 return (EINVAL);
 412         }
 413         return (ENOENT);
 414 }
 415
 416 static int
 417 xlp_pcib_maxslots(device_t dev)
 418 {
 419
 420         return (PCI_SLOTMAX);
 421 }
 422
 423 static u_int32_t
 424 xlp_pcib_read_config(device_t dev, u_int b, u_int s, u_int f,
 425     u_int reg, int width)
 426 {
 427         uint32_t data = 0;
 428         uint64_t cfgaddr;
 429         int     regindex = reg/sizeof(uint32_t);
 430
 431         cfgaddr = nlm_pcicfg_base(XLP_HDR_OFFSET(0, b, s, f));
 432         if ((width == 2) && (reg & 1))
 433                 return 0xFFFFFFFF;
 434         else if ((width == 4) && (reg & 3))
 435                 return 0xFFFFFFFF;
 436
 437         /*
 438          * The intline and int pin of SoC devices are DOA, except
 439          * for bridges (slot %8 == 1).
 440          * use the values we stashed in a writable PCI scratch reg.
 441          */
 442         if (b == 0 && regindex == 0xf && s % 8 > 1)
 443                 regindex = XLP_PCI_DEVSCRATCH_REG0;
 444
 445         data = nlm_read_pci_reg(cfgaddr, regindex);
 446         if (width == 1)
 447                 return ((data >> ((reg & 3) << 3)) & 0xff);
 448         else if (width == 2)
 449                 return ((data >> ((reg & 3) << 3)) & 0xffff);
 450         else
 451                 return (data);
 452 }
 453
 454 static void
 455 xlp_pcib_write_config(device_t dev, u_int b, u_int s, u_int f,
 456     u_int reg, u_int32_t val, int width)
 457 {
 458         uint64_t cfgaddr;
 459         uint32_t data = 0;
 460         int     regindex = reg / sizeof(uint32_t);
 461
 462         cfgaddr = nlm_pcicfg_base(XLP_HDR_OFFSET(0, b, s, f));
 463         if ((width == 2) && (reg & 1))
 464                 return;
 465         else if ((width == 4) && (reg & 3))
 466                 return;
 467
 468         if (width == 1) {
 469                 data = nlm_read_pci_reg(cfgaddr, regindex);
 470                 data = (data & ~(0xff << ((reg & 3) << 3))) |
 471                     (val << ((reg & 3) << 3));
 472         } else if (width == 2) {
 473                 data = nlm_read_pci_reg(cfgaddr, regindex);
 474                 data = (data & ~(0xffff << ((reg & 3) << 3))) |
 475                     (val << ((reg & 3) << 3));
 476         } else {
 477                 data = val;
 478         }
 479
 480         /*
 481          * use shadow reg for intpin/intline which are dead
 482          */
 483         if (b == 0 && regindex == 0xf && s % 8 > 1)
 484                 regindex = XLP_PCI_DEVSCRATCH_REG0;
 485         nlm_write_pci_reg(cfgaddr, regindex, data);
 486 }
 487
 488 /*
 489  * Enable byte swap in hardware when compiled big-endian.
 490  * Programs a link's PCIe SWAP regions from the link's IO and MEM address
 491  * ranges.
 492  */
 493 static void
 494 xlp_pcib_hardware_swap_enable(int node, int link)
 495 {
 496 #if BYTE_ORDER == BIG_ENDIAN
 497         uint64_t bbase, linkpcibase;
 498         uint32_t bar;
 499         int pcieoffset;
 500
 501         pcieoffset = XLP_IO_PCIE_OFFSET(node, link);
 502         if (!nlm_dev_exists(pcieoffset))
 503                 return;
 504
 505         bbase = nlm_get_bridge_regbase(node);
 506         linkpcibase = nlm_pcicfg_base(pcieoffset);
 507         bar = nlm_read_bridge_reg(bbase, BRIDGE_PCIEMEM_BASE0 + link);
 508         nlm_write_pci_reg(linkpcibase, PCIE_BYTE_SWAP_MEM_BASE, bar);
 509
 510         bar = nlm_read_bridge_reg(bbase, BRIDGE_PCIEMEM_LIMIT0 + link);
 511         nlm_write_pci_reg(linkpcibase, PCIE_BYTE_SWAP_MEM_LIM, bar | 0xFFF);
 512
 513         bar = nlm_read_bridge_reg(bbase, BRIDGE_PCIEIO_BASE0 + link);
 514         nlm_write_pci_reg(linkpcibase, PCIE_BYTE_SWAP_IO_BASE, bar);
 515
 516         bar = nlm_read_bridge_reg(bbase, BRIDGE_PCIEIO_LIMIT0 + link);
 517         nlm_write_pci_reg(linkpcibase, PCIE_BYTE_SWAP_IO_LIM, bar | 0xFFF);
 518 #endif
 519 }
 520
 521 static int
 522 xlp_pcib_attach(device_t dev)
 523 {
 524         int node, link;
 525
 526         xlp_pcib_init_resources();
 527
 528         /* enable hardware swap on all nodes/links */
 529         for (node = 0; node < XLP_MAX_NODES; node++)
 530                 for (link = 0; link < 4; link++)
 531                         xlp_pcib_hardware_swap_enable(node, link);
 532
 533         device_add_child(dev, "pci", 0);
 534         bus_generic_attach(dev);
 535         return (0);
 536 }
 537
 538 static void
 539 xlp_pcib_identify(driver_t * driver, device_t parent)
 540 {
 541
 542         BUS_ADD_CHILD(parent, 0, "pcib", 0);
 543 }
 544
 545 /*
 546  * XLS PCIe can have upto 4 links, and each link has its on IRQ
 547  * Find the link on which the device is on
 548  */
 549 static int
 550 xlp_pcie_link(device_t pcib, device_t dev)
 551 {
 552         device_t parent, tmp;
 553
 554         /* find the lane on which the slot is connected to */
 555         tmp = dev;
 556         while (1) {
 557                 parent = device_get_parent(tmp);
 558                 if (parent == NULL || parent == pcib) {
 559                         device_printf(dev, "Cannot find parent bus\n");
 560                         return (-1);
 561                 }
 562                 if (strcmp(device_get_nameunit(parent), "pci0") == 0)
 563                         break;
 564                 tmp = parent;
 565         }
 566         return (pci_get_function(tmp));
 567 }
 568
 569 static int
 570 xlp_alloc_msi(device_t pcib, device_t dev, int count, int maxcount, int *irqs)
 571 {
 572         int i, link;
 573
 574         /*
 575          * Each link has 32 MSIs that can be allocated, but for now
 576          * we only support one device per link.
 577          * msi_alloc() equivalent is needed when we start supporting
 578          * bridges on the PCIe link.
 579          */
 580         link = xlp_pcie_link(pcib, dev);
 581         if (link == -1)
 582                 return (ENXIO);
 583
 584         /*
 585          * encode the irq so that we know it is a MSI interrupt when we
 586          * setup interrupts
 587          */
 588         for (i = 0; i < count; i++)
 589                 irqs[i] = 64 + link * 32 + i;
 590
 591         return (0);
 592 }
 593
 594 static int
 595 xlp_release_msi(device_t pcib, device_t dev, int count, int *irqs)
 596 {
 597         return (0);
 598 }
 599
 600 static int
 601 xlp_map_msi(device_t pcib, device_t dev, int irq, uint64_t *addr,
 602     uint32_t *data)
 603 {
 604         int msi, irt;
 605
 606         if (irq >= 64) {
 607                 msi = irq - 64;
 608                 *addr = MIPS_MSI_ADDR(0);
 609
 610                 irt = xlp_pcie_link_irt(msi/32);
 611                 if (irt != -1)
 612                         *data = MIPS_MSI_DATA(xlp_irt_to_irq(irt));
 613                 return (0);
 614         } else {
 615                 device_printf(dev, "%s: map_msi for irq %d  - ignored",
 616                     device_get_nameunit(pcib), irq);
 617                 return (ENXIO);
 618         }
 619 }
 620
 621 static void
 622 bridge_pcie_ack(int irq)
 623 {
 624         uint32_t node,reg;
 625         uint64_t base;
 626
 627         node = nlm_nodeid();
 628         reg = PCIE_MSI_STATUS;
 629
 630         switch (irq) {
 631                 case PIC_PCIE_0_IRQ:
 632                         base = nlm_pcicfg_base(XLP_IO_PCIE0_OFFSET(node));
 633                         break;
 634                 case PIC_PCIE_1_IRQ:
 635                         base = nlm_pcicfg_base(XLP_IO_PCIE1_OFFSET(node));
 636                         break;
 637                 case PIC_PCIE_2_IRQ:
 638                         base = nlm_pcicfg_base(XLP_IO_PCIE2_OFFSET(node));
 639                         break;
 640                 case PIC_PCIE_3_IRQ:
 641                         base = nlm_pcicfg_base(XLP_IO_PCIE3_OFFSET(node));
 642                         break;
 643                 default:
 644                         return;
 645         }
 646
 647         nlm_write_pci_reg(base, reg, 0xFFFFFFFF);
 648         return;
 649 }
 650
 651 static int
 652 mips_platform_pcib_setup_intr(device_t dev, device_t child,
 653     struct resource *irq, int flags, driver_filter_t *filt,
 654     driver_intr_t *intr, void *arg, void **cookiep)
 655 {
 656         int error = 0;
 657         int xlpirq;
 658         void *extra_ack;
 659
 660         error = rman_activate_resource(irq);
 661         if (error)
 662                 return error;
 663         if (rman_get_start(irq) != rman_get_end(irq)) {
 664                 device_printf(dev, "Interrupt allocation %lu != %lu\n",
 665                     rman_get_start(irq), rman_get_end(irq));
 666                 return (EINVAL);
 667         }
 668         xlpirq = rman_get_start(irq);
 669         if (xlpirq == 0)
 670                 return (0);
 671
 672         if (strcmp(device_get_name(dev), "pcib") != 0)
 673                 return (0);
 674
 675         /*
 676          * temporary hack for MSI, we support just one device per
 677          * link, and assign the link interrupt to the device interrupt
 678          */
 679         if (xlpirq >= 64) {
 680                 int node, val, link;
 681                 uint64_t base;
 682
 683                 xlpirq -= 64;
 684                 if (xlpirq % 32 != 0)
 685                         return (0);
 686
 687                 node = nlm_nodeid();
 688                 link = xlpirq / 32;
 689                 base = nlm_pcicfg_base(XLP_IO_PCIE_OFFSET(node,link));
 690
 691                 /* MSI Interrupt Vector enable at bridge's configuration */
 692                 nlm_write_pci_reg(base, PCIE_MSI_EN, PCIE_MSI_VECTOR_INT_EN);
 693
 694                 val = nlm_read_pci_reg(base, PCIE_INT_EN0);
 695                 /* MSI Interrupt enable at bridge's configuration */
 696                 nlm_write_pci_reg(base, PCIE_INT_EN0,
 697                     (val | PCIE_MSI_INT_EN));
 698
 699                 /* legacy interrupt disable at bridge */
 700                 val = nlm_read_pci_reg(base, PCIE_BRIDGE_CMD);
 701                 nlm_write_pci_reg(base, PCIE_BRIDGE_CMD,
 702                     (val | PCIM_CMD_INTxDIS));
 703
 704                 /* MSI address update at bridge */
 705                 nlm_write_pci_reg(base, PCIE_BRIDGE_MSI_ADDRL,
 706                     MSI_MIPS_ADDR_BASE);
 707                 nlm_write_pci_reg(base, PCIE_BRIDGE_MSI_ADDRH, 0);
 708
 709                 val = nlm_read_pci_reg(base, PCIE_BRIDGE_MSI_CAP);
 710                 /* MSI capability enable at bridge */
 711                 nlm_write_pci_reg(base, PCIE_BRIDGE_MSI_CAP,
 712                     (val | (PCIM_MSICTRL_MSI_ENABLE << 16) |
 713                         (PCIM_MSICTRL_MMC_32 << 16)));
 714
 715                 xlpirq = xlp_pcie_link_irt(xlpirq / 32);
 716                 if (xlpirq == -1)
 717                         return (EINVAL);
 718                 xlpirq = xlp_irt_to_irq(xlpirq);
 719         }
 720         /* Set all irqs to CPU 0 for now */
 721         nlm_pic_write_irt_direct(xlp_pic_base, xlp_irq_to_irt(xlpirq), 1, 0,
 722             PIC_LOCAL_SCHEDULING, xlpirq, 0);
 723         extra_ack = NULL;
 724         if (xlpirq >= PIC_PCIE_0_IRQ && xlpirq <= PIC_PCIE_3_IRQ)
 725                 extra_ack = bridge_pcie_ack;
 726         xlp_establish_intr(device_get_name(child), filt,
 727             intr, arg, xlpirq, flags, cookiep, extra_ack);
 728
 729         return (0);
 730 }
 731
 732 static int
 733 mips_platform_pcib_teardown_intr(device_t dev, device_t child,
 734     struct resource *irq, void *cookie)
 735 {
 736         if (strcmp(device_get_name(child), "pci") == 0) {
 737                 /* if needed reprogram the pic to clear pcix related entry */
 738                 device_printf(dev, "teardown intr\n");
 739         }
 740         return (bus_generic_teardown_intr(dev, child, irq, cookie));
 741 }
 742
 743 static struct resource *
 744 xlp_pcib_alloc_resource(device_t bus, device_t child, int type, int *rid,
 745     u_long start, u_long end, u_long count, u_int flags)
 746 {
 747         struct rman *rm = NULL;
 748         struct resource *rv;
 749         void *va;
 750         int needactivate = flags & RF_ACTIVE;
 751
 752         switch (type) {
 753         case SYS_RES_IRQ:
 754                 rm = &irq_rman;
 755                 break;
 756
 757         case SYS_RES_IOPORT:
 758                 rm = &port_rman;
 759                 break;
 760
 761         case SYS_RES_MEMORY:
 762                 if (start >= EMUL_MEM_START && start <= EMUL_MEM_END)
 763                         rm = &emul_rman;
 764                 else
 765                         rm = &mem_rman;
 766                         break;
 767
 768         default:
 769                 return (0);
 770         }
 771
 772         rv = rman_reserve_resource(rm, start, end, count, flags, child);
 773         if (rv == NULL)
 774                 return (NULL);
 775
 776         rman_set_rid(rv, *rid);
 777
 778         if (type == SYS_RES_MEMORY || type == SYS_RES_IOPORT) {
 779                 va = pmap_mapdev(start, count);
 780                 rman_set_bushandle(rv, (bus_space_handle_t)va);
 781                 rman_set_bustag(rv, rmi_bus_space);
 782         }
 783         if (needactivate) {
 784                 if (bus_activate_resource(child, type, *rid, rv)) {
 785                         rman_release_resource(rv);
 786                         return (NULL);
 787                 }
 788         }
 789         return (rv);
 790 }
 791
 792 static int
 793 xlp_pcib_release_resource(device_t bus, device_t child, int type, int rid,
 794     struct resource *r)
 795 {
 796
 797         return (rman_release_resource(r));
 798 }
 799
 800 static int
 801 xlp_pcib_activate_resource(device_t bus, device_t child, int type, int rid,
 802     struct resource *r)
 803 {
 804
 805         return (rman_activate_resource(r));
 806 }
 807
 808 static int
 809 xlp_pcib_deactivate_resource(device_t bus, device_t child, int type, int rid,
 810     struct resource *r)
 811 {
 812
 813         return (rman_deactivate_resource(r));
 814 }
 815
 816 static int
 817 mips_pcib_route_interrupt(device_t bus, device_t dev, int pin)
 818 {
 819         int irt, link;
 820
 821         /*
 822          * Validate requested pin number.
 823          */
 824         if ((pin < 1) || (pin > 4))
 825                 return (255);
 826
 827         if (pci_get_bus(dev) == 0 &&
 828             pci_get_vendor(dev) == PCI_VENDOR_NETLOGIC) {
 829                 /* SoC devices */
 830                 uint64_t pcibase;
 831                 int f, n, d, num;
 832
 833                 f = pci_get_function(dev);
 834                 n = pci_get_slot(dev) / 8;
 835                 d = pci_get_slot(dev) % 8;
 836
 837                 /*
 838                  * For PCIe links, return link IRT, for other SoC devices
 839                  * get the IRT from its PCIe header
 840                  */
 841                 if (d == 1) {
 842                         irt = xlp_pcie_link_irt(f);
 843                 } else {
 844                         pcibase = nlm_pcicfg_base(XLP_HDR_OFFSET(n, 0, d, f));
 845                         irt = nlm_irtstart(pcibase);
 846                         num = nlm_irtnum(pcibase);
 847                         if (num != 1)
 848                                 device_printf(bus, "[%d:%d:%d] Error %d IRQs\n",
 849                                     n, d, f, num);
 850                 }
 851         } else {
 852                 /* Regular PCI devices */
 853                 link = xlp_pcie_link(bus, dev);
 854                 irt = xlp_pcie_link_irt(link);
 855         }
 856
 857         if (irt != -1)
 858                 return (xlp_irt_to_irq(irt));
 859
 860         return (255);
 861 }
 862
 863 static device_method_t xlp_pcib_methods[] = {
 864         /* Device interface */
 865         DEVMETHOD(device_identify, xlp_pcib_identify),
 866         DEVMETHOD(device_probe, xlp_pcib_probe),
 867         DEVMETHOD(device_attach, xlp_pcib_attach),
 868
 869         /* Bus interface */
 870         DEVMETHOD(bus_read_ivar, xlp_pcib_read_ivar),
 871         DEVMETHOD(bus_write_ivar, xlp_pcib_write_ivar),
 872         DEVMETHOD(bus_alloc_resource, xlp_pcib_alloc_resource),
 873         DEVMETHOD(bus_release_resource, xlp_pcib_release_resource),
 874         DEVMETHOD(bus_activate_resource, xlp_pcib_activate_resource),
 875         DEVMETHOD(bus_deactivate_resource, xlp_pcib_deactivate_resource),
 876         DEVMETHOD(bus_setup_intr, mips_platform_pcib_setup_intr),
 877         DEVMETHOD(bus_teardown_intr, mips_platform_pcib_teardown_intr),
 878
 879         /* pcib interface */
 880         DEVMETHOD(pcib_maxslots, xlp_pcib_maxslots),
 881         DEVMETHOD(pcib_read_config, xlp_pcib_read_config),
 882         DEVMETHOD(pcib_write_config, xlp_pcib_write_config),
 883         DEVMETHOD(pcib_route_interrupt, mips_pcib_route_interrupt),
 884
 885         DEVMETHOD(pcib_alloc_msi, xlp_alloc_msi),
 886         DEVMETHOD(pcib_release_msi, xlp_release_msi),
 887         DEVMETHOD(pcib_map_msi, xlp_map_msi),
 888
 889         DEVMETHOD_END
 890 };
 891
 892 static driver_t xlp_pcib_driver = {
 893         "pcib",
 894         xlp_pcib_methods,
 895         1, /* no softc */
 896 };
 897
 898 DRIVER_MODULE(pcib, nexus, xlp_pcib_driver, pcib_devclass, 0, 0);