sys/powerpc/mpc85xx/pci_mpc85xx.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright 2006-2007 by Juniper Networks.
   5  * Copyright 2008 Semihalf.
   6  * Copyright 2010 The FreeBSD Foundation
   7  * All rights reserved.
   8  *
   9  * Portions of this software were developed by Semihalf
  10  * under sponsorship from the FreeBSD Foundation.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 3. The name of the author may not be used to endorse or promote products
  21  *    derived from this software without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  25  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  26  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  30  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  *
  35  * From: FreeBSD: src/sys/powerpc/mpc85xx/pci_ocp.c,v 1.9 2010/03/23 23:46:28 marcel
  36  */
  37
  38 #include <sys/cdefs.h>
  39 __FBSDID("$FreeBSD$");
  40
  41 #include <sys/param.h>
  42 #include <sys/systm.h>
  43 #include <sys/ktr.h>
  44 #include <sys/sockio.h>
  45 #include <sys/mbuf.h>
  46 #include <sys/malloc.h>
  47 #include <sys/kernel.h>
  48 #include <sys/module.h>
  49 #include <sys/socket.h>
  50 #include <sys/queue.h>
  51 #include <sys/bus.h>
  52 #include <sys/lock.h>
  53 #include <sys/mutex.h>
  54 #include <sys/queue.h>
  55 #include <sys/rman.h>
  56 #include <sys/endian.h>
  57 #include <sys/vmem.h>
  58
  59 #include <vm/vm.h>
  60 #include <vm/pmap.h>
  61
  62 #include <dev/ofw/ofw_pci.h>
  63 #include <dev/ofw/ofw_bus.h>
  64 #include <dev/ofw/ofw_bus_subr.h>
  65 #include <dev/ofw/ofwpci.h>
  66 #include <dev/pci/pcivar.h>
  67 #include <dev/pci/pcireg.h>
  68 #include <dev/pci/pcib_private.h>
  69
  70 #include "ofw_bus_if.h"
  71 #include "pcib_if.h"
  72 #include "pic_if.h"
  73
  74 #include <machine/resource.h>
  75 #include <machine/bus.h>
  76 #include <machine/intr_machdep.h>
  77
  78 #include <powerpc/mpc85xx/mpc85xx.h>
  79
  80 #define REG_CFG_ADDR    0x0000
  81 #define CONFIG_ACCESS_ENABLE    0x80000000
  82
  83 #define REG_CFG_DATA    0x0004
  84 #define REG_INT_ACK     0x0008
  85
  86 #define REG_PEX_IP_BLK_REV1     0x0bf8
  87 #define   IP_MJ_M                 0x0000ff00
  88 #define   IP_MJ_S                 8
  89 #define   IP_MN_M                 0x000000ff
  90 #define   IP_MN_S                 0
  91
  92 #define REG_POTAR(n)    (0x0c00 + 0x20 * (n))
  93 #define REG_POTEAR(n)   (0x0c04 + 0x20 * (n))
  94 #define REG_POWBAR(n)   (0x0c08 + 0x20 * (n))
  95 #define REG_POWAR(n)    (0x0c10 + 0x20 * (n))
  96
  97 #define REG_PITAR(n)    (0x0e00 - 0x20 * (n))
  98 #define REG_PIWBAR(n)   (0x0e08 - 0x20 * (n))
  99 #define REG_PIWBEAR(n)  (0x0e0c - 0x20 * (n))
 100 #define REG_PIWAR(n)    (0x0e10 - 0x20 * (n))
 101 #define   PIWAR_EN        0x80000000
 102 #define   PIWAR_PF        0x40000000
 103 #define   PIWAR_TRGT_M    0x00f00000
 104 #define   PIWAR_TRGT_S    20
 105 #define   PIWAR_TRGT_CCSR         0xe
 106 #define   PIWAR_TRGT_LOCAL        0xf
 107
 108 #define REG_PEX_MES_DR  0x0020
 109 #define REG_PEX_MES_IER 0x0028
 110 #define REG_PEX_ERR_DR  0x0e00
 111 #define REG_PEX_ERR_EN  0x0e08
 112
 113 #define REG_PEX_ERR_DR          0x0e00
 114 #define REG_PEX_ERR_DR_ME       0x80000000
 115 #define REG_PEX_ERR_DR_PCT      0x800000
 116 #define REG_PEX_ERR_DR_PAT      0x400000
 117 #define REG_PEX_ERR_DR_PCAC     0x200000
 118 #define REG_PEX_ERR_DR_PNM      0x100000
 119 #define REG_PEX_ERR_DR_CDNSC    0x80000
 120 #define REG_PEX_ERR_DR_CRSNC    0x40000
 121 #define REG_PEX_ERR_DR_ICCA     0x20000
 122 #define REG_PEX_ERR_DR_IACA     0x10000
 123 #define REG_PEX_ERR_DR_CRST     0x8000
 124 #define REG_PEX_ERR_DR_MIS      0x4000
 125 #define REG_PEX_ERR_DR_IOIS     0x2000
 126 #define REG_PEX_ERR_DR_CIS      0x1000
 127 #define REG_PEX_ERR_DR_CIEP     0x800
 128 #define REG_PEX_ERR_DR_IOIEP    0x400
 129 #define REG_PEX_ERR_DR_OAC      0x200
 130 #define REG_PEX_ERR_DR_IOIA     0x100
 131 #define REG_PEX_ERR_DR_IMBA     0x80
 132 #define REG_PEX_ERR_DR_IIOBA    0x40
 133 #define REG_PEX_ERR_DR_LDDE     0x20
 134 #define REG_PEX_ERR_EN          0x0e08
 135
 136 #define PCIR_LTSSM      0x404
 137 #define LTSSM_STAT_L0   0x16
 138
 139 #define DEVFN(b, s, f)  ((b << 16) | (s << 8) | f)
 140
 141 #define FSL_NUM_MSIS    256     /* 8 registers of 32 bits (8 hardware IRQs) */
 142 #define PCI_SLOT_FIRST  0x1     /* used to be 0x11 but qemu-ppce500 starts from 0x1 */
 143
 144 struct fsl_pcib_softc {
 145         struct ofw_pci_softc pci_sc;
 146         device_t        sc_dev;
 147         struct mtx      sc_cfg_mtx;
 148         int             sc_ip_maj;
 149         int             sc_ip_min;
 150
 151         int             sc_iomem_target;
 152         bus_addr_t      sc_iomem_start, sc_iomem_end;
 153         int             sc_ioport_target;
 154         bus_addr_t      sc_ioport_start, sc_ioport_end;
 155
 156         struct resource *sc_res;
 157         bus_space_handle_t sc_bsh;
 158         bus_space_tag_t sc_bst;
 159         int             sc_rid;
 160
 161         struct resource *sc_irq_res;
 162         void            *sc_ih;
 163
 164         int             sc_busnr;
 165         int             sc_pcie;
 166         uint8_t         sc_pcie_capreg;         /* PCI-E Capability Reg Set */
 167 };
 168
 169 struct fsl_pcib_err_dr {
 170         const char      *msg;
 171         uint32_t        err_dr_mask;
 172 };
 173
 174 struct fsl_msi_map {
 175         SLIST_ENTRY(fsl_msi_map) slist;
 176         uint32_t        irq_base;
 177         bus_addr_t      target;
 178 };
 179
 180 SLIST_HEAD(msi_head, fsl_msi_map) fsl_msis = SLIST_HEAD_INITIALIZER(msi_head);
 181
 182 static const struct fsl_pcib_err_dr pci_err[] = {
 183         {"ME",          REG_PEX_ERR_DR_ME},
 184         {"PCT",         REG_PEX_ERR_DR_PCT},
 185         {"PAT",         REG_PEX_ERR_DR_PAT},
 186         {"PCAC",        REG_PEX_ERR_DR_PCAC},
 187         {"PNM",         REG_PEX_ERR_DR_PNM},
 188         {"CDNSC",       REG_PEX_ERR_DR_CDNSC},
 189         {"CRSNC",       REG_PEX_ERR_DR_CRSNC},
 190         {"ICCA",        REG_PEX_ERR_DR_ICCA},
 191         {"IACA",        REG_PEX_ERR_DR_IACA},
 192         {"CRST",        REG_PEX_ERR_DR_CRST},
 193         {"MIS",         REG_PEX_ERR_DR_MIS},
 194         {"IOIS",        REG_PEX_ERR_DR_IOIS},
 195         {"CIS",         REG_PEX_ERR_DR_CIS},
 196         {"CIEP",        REG_PEX_ERR_DR_CIEP},
 197         {"IOIEP",       REG_PEX_ERR_DR_IOIEP},
 198         {"OAC",         REG_PEX_ERR_DR_OAC},
 199         {"IOIA",        REG_PEX_ERR_DR_IOIA},
 200         {"IMBA",        REG_PEX_ERR_DR_IMBA},
 201         {"IIOBA",       REG_PEX_ERR_DR_IIOBA},
 202         {"LDDE",        REG_PEX_ERR_DR_LDDE}
 203 };
 204
 205 /* Local forward declerations. */
 206 static uint32_t fsl_pcib_cfgread(struct fsl_pcib_softc *, u_int, u_int, u_int,
 207     u_int, int);
 208 static void fsl_pcib_cfgwrite(struct fsl_pcib_softc *, u_int, u_int, u_int,
 209     u_int, uint32_t, int);
 210 static int fsl_pcib_decode_win(phandle_t, struct fsl_pcib_softc *);
 211 static void fsl_pcib_err_init(device_t);
 212 static void fsl_pcib_inbound(struct fsl_pcib_softc *, int, int, uint64_t,
 213     uint64_t, uint64_t);
 214 static void fsl_pcib_outbound(struct fsl_pcib_softc *, int, int, uint64_t,
 215     uint64_t, uint64_t);
 216
 217 /* Forward declerations. */
 218 static int fsl_pcib_attach(device_t);
 219 static int fsl_pcib_detach(device_t);
 220 static int fsl_pcib_probe(device_t);
 221
 222 static int fsl_pcib_maxslots(device_t);
 223 static uint32_t fsl_pcib_read_config(device_t, u_int, u_int, u_int, u_int, int);
 224 static void fsl_pcib_write_config(device_t, u_int, u_int, u_int, u_int,
 225     uint32_t, int);
 226 static int fsl_pcib_alloc_msi(device_t dev, device_t child,
 227     int count, int maxcount, int *irqs);
 228 static int fsl_pcib_release_msi(device_t dev, device_t child,
 229     int count, int *irqs);
 230 static int fsl_pcib_alloc_msix(device_t dev, device_t child, int *irq);
 231 static int fsl_pcib_release_msix(device_t dev, device_t child, int irq);
 232 static int fsl_pcib_map_msi(device_t dev, device_t child,
 233     int irq, uint64_t *addr, uint32_t *data);
 234
 235 static vmem_t *msi_vmem;        /* Global MSI vmem, holds all MSI ranges. */
 236
 237 /*
 238  * Bus interface definitions.
 239  */
 240 static device_method_t fsl_pcib_methods[] = {
 241         /* Device interface */
 242         DEVMETHOD(device_probe,         fsl_pcib_probe),
 243         DEVMETHOD(device_attach,        fsl_pcib_attach),
 244         DEVMETHOD(device_detach,        fsl_pcib_detach),
 245
 246         /* pcib interface */
 247         DEVMETHOD(pcib_maxslots,        fsl_pcib_maxslots),
 248         DEVMETHOD(pcib_read_config,     fsl_pcib_read_config),
 249         DEVMETHOD(pcib_write_config,    fsl_pcib_write_config),
 250         DEVMETHOD(pcib_alloc_msi,       fsl_pcib_alloc_msi),
 251         DEVMETHOD(pcib_release_msi,     fsl_pcib_release_msi),
 252         DEVMETHOD(pcib_alloc_msix,      fsl_pcib_alloc_msix),
 253         DEVMETHOD(pcib_release_msix,    fsl_pcib_release_msix),
 254         DEVMETHOD(pcib_map_msi,         fsl_pcib_map_msi),
 255
 256         DEVMETHOD_END
 257 };
 258
 259 DEFINE_CLASS_1(pcib, fsl_pcib_driver, fsl_pcib_methods,
 260     sizeof(struct fsl_pcib_softc), ofw_pcib_driver);
 261 EARLY_DRIVER_MODULE(pcib, ofwbus, fsl_pcib_driver, 0, 0, BUS_PASS_BUS);
 262
 263 static void
 264 fsl_pcib_err_intr(void *v)
 265 {
 266         struct fsl_pcib_softc *sc;
 267         device_t dev;
 268         uint32_t err_reg, clear_reg;
 269         uint8_t i;
 270
 271         dev = (device_t)v;
 272         sc = device_get_softc(dev);
 273
 274         clear_reg = 0;
 275         err_reg = bus_space_read_4(sc->sc_bst, sc->sc_bsh, REG_PEX_ERR_DR);
 276
 277         /* Check which one error occurred */
 278         for (i = 0; i < sizeof(pci_err)/sizeof(struct fsl_pcib_err_dr); i++) {
 279                 if (err_reg & pci_err[i].err_dr_mask) {
 280                         device_printf(dev, "PCI %d: report %s error\n",
 281                             device_get_unit(dev), pci_err[i].msg);
 282                         clear_reg |= pci_err[i].err_dr_mask;
 283                 }
 284         }
 285
 286         /* Clear pending errors */
 287         bus_space_write_4(sc->sc_bst, sc->sc_bsh, REG_PEX_ERR_DR, clear_reg);
 288 }
 289
 290 static int
 291 fsl_pcib_probe(device_t dev)
 292 {
 293
 294         if (ofw_bus_get_type(dev) == NULL ||
 295             strcmp(ofw_bus_get_type(dev), "pci") != 0)
 296                 return (ENXIO);
 297
 298         if (!(ofw_bus_is_compatible(dev, "fsl,mpc8540-pci") ||
 299             ofw_bus_is_compatible(dev, "fsl,mpc8540-pcie") ||
 300             ofw_bus_is_compatible(dev, "fsl,mpc8548-pcie") ||
 301             ofw_bus_is_compatible(dev, "fsl,p5020-pcie") ||
 302             ofw_bus_is_compatible(dev, "fsl,qoriq-pcie-v2.2") ||
 303             ofw_bus_is_compatible(dev, "fsl,qoriq-pcie")))
 304                 return (ENXIO);
 305
 306         device_set_desc(dev, "Freescale Integrated PCI/PCI-E Controller");
 307         return (BUS_PROBE_DEFAULT);
 308 }
 309
 310 static int
 311 fsl_pcib_attach(device_t dev)
 312 {
 313         struct fsl_pcib_softc *sc;
 314         phandle_t node;
 315         uint32_t cfgreg, brctl, ipreg;
 316         int do_reset, error, rid;
 317         uint8_t ltssm, capptr;
 318
 319         sc = device_get_softc(dev);
 320         sc->sc_dev = dev;
 321
 322         sc->sc_rid = 0;
 323         sc->sc_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &sc->sc_rid,
 324             RF_ACTIVE);
 325         if (sc->sc_res == NULL) {
 326                 device_printf(dev, "could not map I/O memory\n");
 327                 return (ENXIO);
 328         }
 329         sc->sc_bst = rman_get_bustag(sc->sc_res);
 330         sc->sc_bsh = rman_get_bushandle(sc->sc_res);
 331         sc->sc_busnr = 0;
 332
 333         ipreg = bus_read_4(sc->sc_res, REG_PEX_IP_BLK_REV1);
 334         sc->sc_ip_min = (ipreg & IP_MN_M) >> IP_MN_S;
 335         sc->sc_ip_maj = (ipreg & IP_MJ_M) >> IP_MJ_S;
 336         mtx_init(&sc->sc_cfg_mtx, "pcicfg", NULL, MTX_SPIN);
 337
 338         cfgreg = fsl_pcib_cfgread(sc, 0, 0, 0, PCIR_VENDOR, 2);
 339         if (cfgreg != 0x1057 && cfgreg != 0x1957)
 340                 goto err;
 341
 342         capptr = fsl_pcib_cfgread(sc, 0, 0, 0, PCIR_CAP_PTR, 1);
 343         while (capptr != 0) {
 344                 cfgreg = fsl_pcib_cfgread(sc, 0, 0, 0, capptr, 2);
 345                 switch (cfgreg & 0xff) {
 346                 case PCIY_PCIX:
 347                         break;
 348                 case PCIY_EXPRESS:
 349                         sc->sc_pcie = 1;
 350                         sc->sc_pcie_capreg = capptr;
 351                         break;
 352                 }
 353                 capptr = (cfgreg >> 8) & 0xff;
 354         }
 355
 356         node = ofw_bus_get_node(dev);
 357
 358         /*
 359          * Initialize generic OF PCI interface (ranges, etc.)
 360          */
 361
 362         error = ofw_pcib_init(dev);
 363         if (error)
 364                 return (error);
 365
 366         /*
 367          * Configure decode windows for PCI(E) access.
 368          */
 369         if (fsl_pcib_decode_win(node, sc) != 0)
 370                 goto err;
 371
 372         cfgreg = fsl_pcib_cfgread(sc, 0, 0, 0, PCIR_COMMAND, 2);
 373         cfgreg |= PCIM_CMD_SERRESPEN | PCIM_CMD_BUSMASTEREN | PCIM_CMD_MEMEN |
 374             PCIM_CMD_PORTEN;
 375         fsl_pcib_cfgwrite(sc, 0, 0, 0, PCIR_COMMAND, cfgreg, 2);
 376
 377         do_reset = 0;
 378         resource_int_value("pcib", device_get_unit(dev), "reset", &do_reset);
 379         if (do_reset) {
 380                 /* Reset the bus.  Needed for Radeon video cards. */
 381                 brctl = fsl_pcib_read_config(sc->sc_dev, 0, 0, 0,
 382                     PCIR_BRIDGECTL_1, 1);
 383                 brctl |= PCIB_BCR_SECBUS_RESET;
 384                 fsl_pcib_write_config(sc->sc_dev, 0, 0, 0,
 385                     PCIR_BRIDGECTL_1, brctl, 1);
 386                 DELAY(100000);
 387                 brctl &= ~PCIB_BCR_SECBUS_RESET;
 388                 fsl_pcib_write_config(sc->sc_dev, 0, 0, 0,
 389                     PCIR_BRIDGECTL_1, brctl, 1);
 390                 DELAY(100000);
 391         }
 392
 393         if (sc->sc_pcie) {
 394                 ltssm = fsl_pcib_cfgread(sc, 0, 0, 0, PCIR_LTSSM, 1);
 395                 if (ltssm < LTSSM_STAT_L0) {
 396                         if (bootverbose)
 397                                 printf("PCI %d: no PCIE link, skipping\n",
 398                                     device_get_unit(dev));
 399                         return (0);
 400                 }
 401         }
 402
 403         /* Allocate irq */
 404         rid = 0;
 405         sc->sc_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
 406             RF_ACTIVE | RF_SHAREABLE);
 407         if (sc->sc_irq_res == NULL) {
 408                 error = fsl_pcib_detach(dev);
 409                 if (error != 0) {
 410                         device_printf(dev,
 411                             "Detach of the driver failed with error %d\n",
 412                             error);
 413                 }
 414                 return (ENXIO);
 415         }
 416
 417         /* Setup interrupt handler */
 418         error = bus_setup_intr(dev, sc->sc_irq_res, INTR_TYPE_MISC | INTR_MPSAFE,
 419             NULL, fsl_pcib_err_intr, dev, &sc->sc_ih);
 420         if (error != 0) {
 421                 device_printf(dev, "Could not setup irq, %d\n", error);
 422                 sc->sc_ih = NULL;
 423                 error = fsl_pcib_detach(dev);
 424                 if (error != 0) {
 425                         device_printf(dev,
 426                             "Detach of the driver failed with error %d\n",
 427                             error);
 428                 }
 429                 return (ENXIO);
 430         }
 431
 432         fsl_pcib_err_init(dev);
 433
 434         return (ofw_pcib_attach(dev));
 435
 436 err:
 437         return (ENXIO);
 438 }
 439
 440 static uint32_t
 441 fsl_pcib_cfgread(struct fsl_pcib_softc *sc, u_int bus, u_int slot, u_int func,
 442     u_int reg, int bytes)
 443 {
 444         uint32_t addr, data;
 445
 446         addr = CONFIG_ACCESS_ENABLE;
 447         addr |= (bus & 0xff) << 16;
 448         addr |= (slot & 0x1f) << 11;
 449         addr |= (func & 0x7) << 8;
 450         addr |= reg & 0xfc;
 451         if (sc->sc_pcie)
 452                 addr |= (reg & 0xf00) << 16;
 453
 454         mtx_lock_spin(&sc->sc_cfg_mtx);
 455         bus_space_write_4(sc->sc_bst, sc->sc_bsh, REG_CFG_ADDR, addr);
 456
 457         switch (bytes) {
 458         case 1:
 459                 data = bus_space_read_1(sc->sc_bst, sc->sc_bsh,
 460                     REG_CFG_DATA + (reg & 3));
 461                 break;
 462         case 2:
 463                 data = le16toh(bus_space_read_2(sc->sc_bst, sc->sc_bsh,
 464                     REG_CFG_DATA + (reg & 2)));
 465                 break;
 466         case 4:
 467                 data = le32toh(bus_space_read_4(sc->sc_bst, sc->sc_bsh,
 468                     REG_CFG_DATA));
 469                 break;
 470         default:
 471                 data = ~0;
 472                 break;
 473         }
 474         mtx_unlock_spin(&sc->sc_cfg_mtx);
 475         return (data);
 476 }
 477
 478 static void
 479 fsl_pcib_cfgwrite(struct fsl_pcib_softc *sc, u_int bus, u_int slot, u_int func,
 480     u_int reg, uint32_t data, int bytes)
 481 {
 482         uint32_t addr;
 483
 484         addr = CONFIG_ACCESS_ENABLE;
 485         addr |= (bus & 0xff) << 16;
 486         addr |= (slot & 0x1f) << 11;
 487         addr |= (func & 0x7) << 8;
 488         addr |= reg & 0xfc;
 489         if (sc->sc_pcie)
 490                 addr |= (reg & 0xf00) << 16;
 491
 492         mtx_lock_spin(&sc->sc_cfg_mtx);
 493         bus_space_write_4(sc->sc_bst, sc->sc_bsh, REG_CFG_ADDR, addr);
 494
 495         switch (bytes) {
 496         case 1:
 497                 bus_space_write_1(sc->sc_bst, sc->sc_bsh,
 498                     REG_CFG_DATA + (reg & 3), data);
 499                 break;
 500         case 2:
 501                 bus_space_write_2(sc->sc_bst, sc->sc_bsh,
 502                     REG_CFG_DATA + (reg & 2), htole16(data));
 503                 break;
 504         case 4:
 505                 bus_space_write_4(sc->sc_bst, sc->sc_bsh,
 506                     REG_CFG_DATA, htole32(data));
 507                 break;
 508         }
 509         mtx_unlock_spin(&sc->sc_cfg_mtx);
 510 }
 511
 512 #if 0
 513 static void
 514 dump(struct fsl_pcib_softc *sc)
 515 {
 516         unsigned int i;
 517
 518 #define RD(o)   bus_space_read_4(sc->sc_bst, sc->sc_bsh, o)
 519         for (i = 0; i < 5; i++) {
 520                 printf("POTAR%u  =0x%08x\n", i, RD(REG_POTAR(i)));
 521                 printf("POTEAR%u =0x%08x\n", i, RD(REG_POTEAR(i)));
 522                 printf("POWBAR%u =0x%08x\n", i, RD(REG_POWBAR(i)));
 523                 printf("POWAR%u  =0x%08x\n", i, RD(REG_POWAR(i)));
 524         }
 525         printf("\n");
 526         for (i = 1; i < 4; i++) {
 527                 printf("PITAR%u  =0x%08x\n", i, RD(REG_PITAR(i)));
 528                 printf("PIWBAR%u =0x%08x\n", i, RD(REG_PIWBAR(i)));
 529                 printf("PIWBEAR%u=0x%08x\n", i, RD(REG_PIWBEAR(i)));
 530                 printf("PIWAR%u  =0x%08x\n", i, RD(REG_PIWAR(i)));
 531         }
 532         printf("\n");
 533 #undef RD
 534
 535         for (i = 0; i < 0x48; i += 4) {
 536                 printf("cfg%02x=0x%08x\n", i, fsl_pcib_cfgread(sc, 0, 0, 0,
 537                     i, 4));
 538         }
 539 }
 540 #endif
 541
 542 static int
 543 fsl_pcib_maxslots(device_t dev)
 544 {
 545         struct fsl_pcib_softc *sc = device_get_softc(dev);
 546
 547         return ((sc->sc_pcie) ? 0 : PCI_SLOTMAX);
 548 }
 549
 550 static uint32_t
 551 fsl_pcib_read_config(device_t dev, u_int bus, u_int slot, u_int func,
 552     u_int reg, int bytes)
 553 {
 554         struct fsl_pcib_softc *sc = device_get_softc(dev);
 555
 556         if (bus == sc->sc_busnr && !sc->sc_pcie &&
 557             slot < PCI_SLOT_FIRST)
 558                 return (~0);
 559
 560         return (fsl_pcib_cfgread(sc, bus, slot, func, reg, bytes));
 561 }
 562
 563 static void
 564 fsl_pcib_write_config(device_t dev, u_int bus, u_int slot, u_int func,
 565     u_int reg, uint32_t val, int bytes)
 566 {
 567         struct fsl_pcib_softc *sc = device_get_softc(dev);
 568
 569         if (bus == sc->sc_busnr && !sc->sc_pcie &&
 570             slot < PCI_SLOT_FIRST)
 571                 return;
 572         fsl_pcib_cfgwrite(sc, bus, slot, func, reg, val, bytes);
 573 }
 574
 575 static void
 576 fsl_pcib_inbound(struct fsl_pcib_softc *sc, int wnd, int tgt, uint64_t start,
 577     uint64_t size, uint64_t pci_start)
 578 {
 579         uint32_t attr, bar, tar;
 580
 581         KASSERT(wnd > 0, ("%s: inbound window 0 is invalid", __func__));
 582
 583         attr = PIWAR_EN;
 584
 585         switch (tgt) {
 586         case -1:
 587                 attr &= ~PIWAR_EN;
 588                 break;
 589         case PIWAR_TRGT_LOCAL:
 590                 attr |= (ffsl(size) - 2);
 591         default:
 592                 attr |= (tgt << PIWAR_TRGT_S);
 593                 break;
 594         }
 595         tar = start >> 12;
 596         bar = pci_start >> 12;
 597
 598         bus_space_write_4(sc->sc_bst, sc->sc_bsh, REG_PITAR(wnd), tar);
 599         bus_space_write_4(sc->sc_bst, sc->sc_bsh, REG_PIWBEAR(wnd), 0);
 600         bus_space_write_4(sc->sc_bst, sc->sc_bsh, REG_PIWBAR(wnd), bar);
 601         bus_space_write_4(sc->sc_bst, sc->sc_bsh, REG_PIWAR(wnd), attr);
 602 }
 603
 604 static void
 605 fsl_pcib_outbound(struct fsl_pcib_softc *sc, int wnd, int res, uint64_t start,
 606     uint64_t size, uint64_t pci_start)
 607 {
 608         uint32_t attr, bar, tar;
 609
 610         switch (res) {
 611         case SYS_RES_MEMORY:
 612                 attr = 0x80044000 | (ffsll(size) - 2);
 613                 break;
 614         case SYS_RES_IOPORT:
 615                 attr = 0x80088000 | (ffsll(size) - 2);
 616                 break;
 617         default:
 618                 attr = 0x0004401f;
 619                 break;
 620         }
 621         bar = start >> 12;
 622         tar = pci_start >> 12;
 623
 624         bus_space_write_4(sc->sc_bst, sc->sc_bsh, REG_POTAR(wnd), tar);
 625         bus_space_write_4(sc->sc_bst, sc->sc_bsh, REG_POTEAR(wnd), 0);
 626         bus_space_write_4(sc->sc_bst, sc->sc_bsh, REG_POWBAR(wnd), bar);
 627         bus_space_write_4(sc->sc_bst, sc->sc_bsh, REG_POWAR(wnd), attr);
 628 }
 629
 630 static void
 631 fsl_pcib_err_init(device_t dev)
 632 {
 633         struct fsl_pcib_softc *sc;
 634         uint16_t sec_stat, dsr;
 635         uint32_t dcr, err_en;
 636
 637         sc = device_get_softc(dev);
 638
 639         sec_stat = fsl_pcib_cfgread(sc, 0, 0, 0, PCIR_SECSTAT_1, 2);
 640         if (sec_stat)
 641                 fsl_pcib_cfgwrite(sc, 0, 0, 0, PCIR_SECSTAT_1, 0xffff, 2);
 642         if (sc->sc_pcie) {
 643                 /* Clear error bits */
 644                 bus_space_write_4(sc->sc_bst, sc->sc_bsh, REG_PEX_MES_IER,
 645                     0xffffffff);
 646                 bus_space_write_4(sc->sc_bst, sc->sc_bsh, REG_PEX_MES_DR,
 647                     0xffffffff);
 648                 bus_space_write_4(sc->sc_bst, sc->sc_bsh, REG_PEX_ERR_DR,
 649                     0xffffffff);
 650
 651                 dsr = fsl_pcib_cfgread(sc, 0, 0, 0,
 652                     sc->sc_pcie_capreg + PCIER_DEVICE_STA, 2);
 653                 if (dsr)
 654                         fsl_pcib_cfgwrite(sc, 0, 0, 0,
 655                             sc->sc_pcie_capreg + PCIER_DEVICE_STA,
 656                             0xffff, 2);
 657
 658                 /* Enable all errors reporting */
 659                 err_en = 0x00bfff00;
 660                 bus_space_write_4(sc->sc_bst, sc->sc_bsh, REG_PEX_ERR_EN,
 661                     err_en);
 662
 663                 /* Enable error reporting: URR, FER, NFER */
 664                 dcr = fsl_pcib_cfgread(sc, 0, 0, 0,
 665                     sc->sc_pcie_capreg + PCIER_DEVICE_CTL, 4);
 666                 dcr |= PCIEM_CTL_URR_ENABLE | PCIEM_CTL_FER_ENABLE |
 667                     PCIEM_CTL_NFER_ENABLE;
 668                 fsl_pcib_cfgwrite(sc, 0, 0, 0,
 669                     sc->sc_pcie_capreg + PCIER_DEVICE_CTL, dcr, 4);
 670         }
 671 }
 672
 673 static int
 674 fsl_pcib_detach(device_t dev)
 675 {
 676         struct fsl_pcib_softc *sc;
 677
 678         sc = device_get_softc(dev);
 679
 680         mtx_destroy(&sc->sc_cfg_mtx);
 681
 682         return (bus_generic_detach(dev));
 683 }
 684
 685 static int
 686 fsl_pcib_decode_win(phandle_t node, struct fsl_pcib_softc *sc)
 687 {
 688         device_t dev;
 689         int error, i, trgt;
 690
 691         dev = sc->sc_dev;
 692
 693         fsl_pcib_outbound(sc, 0, -1, 0, 0, 0);
 694
 695         /*
 696          * Configure LAW decode windows.
 697          */
 698         error = law_pci_target(sc->sc_res, &sc->sc_iomem_target,
 699             &sc->sc_ioport_target);
 700         if (error != 0) {
 701                 device_printf(dev, "could not retrieve PCI LAW target info\n");
 702                 return (error);
 703         }
 704
 705         for (i = 0; i < sc->pci_sc.sc_nrange; i++) {
 706                 switch (sc->pci_sc.sc_range[i].pci_hi &
 707                     OFW_PCI_PHYS_HI_SPACEMASK) {
 708                 case OFW_PCI_PHYS_HI_SPACE_CONFIG:
 709                         continue;
 710                 case OFW_PCI_PHYS_HI_SPACE_IO:
 711                         trgt = sc->sc_ioport_target;
 712                         fsl_pcib_outbound(sc, 2, SYS_RES_IOPORT,
 713                             sc->pci_sc.sc_range[i].host,
 714                             sc->pci_sc.sc_range[i].size,
 715                             sc->pci_sc.sc_range[i].pci);
 716                         sc->sc_ioport_start = sc->pci_sc.sc_range[i].pci;
 717                         sc->sc_ioport_end = sc->pci_sc.sc_range[i].pci +
 718                             sc->pci_sc.sc_range[i].size - 1;
 719                         break;
 720                 case OFW_PCI_PHYS_HI_SPACE_MEM32:
 721                 case OFW_PCI_PHYS_HI_SPACE_MEM64:
 722                         trgt = sc->sc_iomem_target;
 723                         fsl_pcib_outbound(sc, 1, SYS_RES_MEMORY,
 724                             sc->pci_sc.sc_range[i].host,
 725                             sc->pci_sc.sc_range[i].size,
 726                             sc->pci_sc.sc_range[i].pci);
 727                         sc->sc_iomem_start = sc->pci_sc.sc_range[i].pci;
 728                         sc->sc_iomem_end = sc->pci_sc.sc_range[i].pci +
 729                             sc->pci_sc.sc_range[i].size - 1;
 730                         break;
 731                 default:
 732                         panic("Unknown range type %#x\n",
 733                             sc->pci_sc.sc_range[i].pci_hi &
 734                             OFW_PCI_PHYS_HI_SPACEMASK);
 735                 }
 736                 error = law_enable(trgt, sc->pci_sc.sc_range[i].host,
 737                     sc->pci_sc.sc_range[i].size);
 738                 if (error != 0) {
 739                         device_printf(dev, "could not program LAW for range "
 740                             "%d\n", i);
 741                         return (error);
 742                 }
 743         }
 744
 745         /*
 746          * Set outbout and inbound windows.
 747          */
 748         fsl_pcib_outbound(sc, 3, -1, 0, 0, 0);
 749         fsl_pcib_outbound(sc, 4, -1, 0, 0, 0);
 750
 751         fsl_pcib_inbound(sc, 1, -1, 0, 0, 0);
 752         fsl_pcib_inbound(sc, 2, -1, 0, 0, 0);
 753         fsl_pcib_inbound(sc, 3, PIWAR_TRGT_LOCAL, 0,
 754             ptoa(Maxmem), 0);
 755
 756         /* Direct-map the CCSR for MSIs. */
 757         /* Freescale PCIe 2.x has a dedicated MSI window. */
 758         /* inbound window 8 makes it hit 0xD00 offset, the MSI window. */
 759         if (sc->sc_ip_maj >= 2)
 760                 fsl_pcib_inbound(sc, 8, PIWAR_TRGT_CCSR, ccsrbar_pa,
 761                     ccsrbar_size, ccsrbar_pa);
 762         else
 763                 fsl_pcib_inbound(sc, 1, PIWAR_TRGT_CCSR, ccsrbar_pa,
 764                     ccsrbar_size, ccsrbar_pa);
 765
 766         return (0);
 767 }
 768
 769 static int fsl_pcib_alloc_msi(device_t dev, device_t child,
 770     int count, int maxcount, int *irqs)
 771 {
 772         vmem_addr_t start;
 773         int err, i;
 774
 775         if (msi_vmem == NULL)
 776                 return (ENODEV);
 777
 778         err = vmem_xalloc(msi_vmem, count, powerof2(count), 0, 0,
 779             VMEM_ADDR_MIN, VMEM_ADDR_MAX, M_BESTFIT | M_WAITOK, &start);
 780
 781         if (err)
 782                 return (err);
 783
 784         for (i = 0; i < count; i++)
 785                 irqs[i] = start + i;
 786
 787         return (0);
 788 }
 789
 790 static int fsl_pcib_release_msi(device_t dev, device_t child,
 791     int count, int *irqs)
 792 {
 793         if (msi_vmem == NULL)
 794                 return (ENODEV);
 795
 796         vmem_xfree(msi_vmem, irqs[0], count);
 797         return (0);
 798 }
 799
 800 static int fsl_pcib_alloc_msix(device_t dev, device_t child, int *irq)
 801 {
 802         return (fsl_pcib_alloc_msi(dev, child, 1, 1, irq));
 803 }
 804
 805 static int fsl_pcib_release_msix(device_t dev, device_t child, int irq)
 806 {
 807         return (fsl_pcib_release_msi(dev, child, 1, &irq));
 808 }
 809
 810 static int fsl_pcib_map_msi(device_t dev, device_t child,
 811     int irq, uint64_t *addr, uint32_t *data)
 812 {
 813         struct fsl_msi_map *mp;
 814
 815         SLIST_FOREACH(mp, &fsl_msis, slist) {
 816                 if (irq >= mp->irq_base && irq < mp->irq_base + FSL_NUM_MSIS)
 817                         break;
 818         }
 819
 820         if (mp == NULL)
 821                 return (ENODEV);
 822
 823         *data = (irq & 255);
 824         *addr = ccsrbar_pa + mp->target;
 825
 826         return (0);
 827 }
 828
 829 /*
 830  * Linux device trees put the msi@<x> as children of the SoC, with ranges based
 831  * on the CCSR.  Since rman doesn't permit overlapping or sub-ranges between
 832  * devices (bus_space_subregion(9) could do it, but let's not touch the PIC
 833  * driver just to allocate a subregion for a sibling driver).  This driver will
 834  * use ccsr_write() and ccsr_read() instead.
 835  */
 836
 837 #define FSL_NUM_IRQS            8
 838 #define FSL_NUM_MSI_PER_IRQ     32
 839 #define FSL_MSI_TARGET  0x140
 840
 841 struct fsl_msi_softc {
 842         vm_offset_t     sc_base;
 843         vm_offset_t     sc_target;
 844         int             sc_msi_base_irq;
 845         struct fsl_msi_map sc_map;
 846         struct fsl_msi_irq {
 847                 /* This struct gets passed as the filter private data. */
 848                 struct fsl_msi_softc *sc_ptr;   /* Pointer back to softc. */
 849                 struct resource *res;
 850                 int irq;
 851                 void *cookie;
 852                 int vectors[FSL_NUM_MSI_PER_IRQ];
 853                 vm_offset_t reg;
 854         } sc_msi_irq[FSL_NUM_IRQS];
 855 };
 856
 857 static int
 858 fsl_msi_intr_filter(void *priv)
 859 {
 860         struct fsl_msi_irq *data = priv;
 861         uint32_t reg;
 862         int i;
 863
 864         reg = ccsr_read4(ccsrbar_va + data->reg);
 865         i = 0;
 866         while (reg != 0) {
 867                 if (reg & 1)
 868                         powerpc_dispatch_intr(data->vectors[i], NULL);
 869                 reg >>= 1;
 870                 i++;
 871         }
 872
 873         return (FILTER_HANDLED);
 874 }
 875
 876 static int
 877 fsl_msi_probe(device_t dev)
 878 {
 879         if (!ofw_bus_is_compatible(dev, "fsl,mpic-msi"))
 880                 return (ENXIO);
 881
 882         device_set_desc(dev, "Freescale MSI");
 883
 884         return (BUS_PROBE_DEFAULT);
 885 }
 886
 887 static int
 888 fsl_msi_attach(device_t dev)
 889 {
 890         struct fsl_msi_softc *sc;
 891         struct fsl_msi_irq *irq;
 892         int i;
 893
 894         sc = device_get_softc(dev);
 895
 896         if (msi_vmem == NULL)
 897                 msi_vmem = vmem_create("MPIC MSI", 0, 0, 1, 0, M_BESTFIT | M_WAITOK);
 898
 899         /* Manually play with resource entries. */
 900         sc->sc_base = bus_get_resource_start(dev, SYS_RES_MEMORY, 0);
 901         sc->sc_map.target = bus_get_resource_start(dev, SYS_RES_MEMORY, 1);
 902
 903         if (sc->sc_map.target == 0)
 904                 sc->sc_map.target = sc->sc_base + FSL_MSI_TARGET;
 905
 906         for (i = 0; i < FSL_NUM_IRQS; i++) {
 907                 irq = &sc->sc_msi_irq[i];
 908                 irq->irq = i;
 909                 irq->reg = sc->sc_base + 16 * i;
 910                 irq->res = bus_alloc_resource_any(dev, SYS_RES_IRQ,
 911                     &irq->irq, RF_ACTIVE);
 912                 bus_setup_intr(dev, irq->res, INTR_TYPE_MISC | INTR_MPSAFE,
 913                     fsl_msi_intr_filter, NULL, irq, &irq->cookie);
 914         }
 915         sc->sc_map.irq_base = powerpc_register_pic(dev, ofw_bus_get_node(dev),
 916             FSL_NUM_MSIS, 0, 0);
 917
 918         /* Let vmem and the IRQ subsystem work their magic for allocations. */
 919         vmem_add(msi_vmem, sc->sc_map.irq_base, FSL_NUM_MSIS, M_WAITOK);
 920
 921         SLIST_INSERT_HEAD(&fsl_msis, &sc->sc_map, slist);
 922
 923         return (0);
 924 }
 925
 926 static void
 927 fsl_msi_enable(device_t dev, u_int irq, u_int vector, void **priv)
 928 {
 929         struct fsl_msi_softc *sc;
 930         struct fsl_msi_irq *irqd;
 931
 932         sc = device_get_softc(dev);
 933
 934         irqd = &sc->sc_msi_irq[irq / FSL_NUM_MSI_PER_IRQ];
 935         irqd->vectors[irq % FSL_NUM_MSI_PER_IRQ] = vector;
 936 }
 937
 938 static device_method_t fsl_msi_methods[] = {
 939         DEVMETHOD(device_probe,         fsl_msi_probe),
 940         DEVMETHOD(device_attach,        fsl_msi_attach),
 941
 942         DEVMETHOD(pic_enable,           fsl_msi_enable),
 943         DEVMETHOD_END
 944 };
 945
 946 static driver_t fsl_msi_driver = {
 947         "fsl_msi",
 948         fsl_msi_methods,
 949         sizeof(struct fsl_msi_softc)
 950 };
 951
 952 EARLY_DRIVER_MODULE(fsl_msi, simplebus, fsl_msi_driver, 0, 0,
 953     BUS_PASS_INTERRUPT + 1);