drivers/pci/host/pci-mvebu.c

   1 /*
   2  * PCIe driver for Marvell Armada 370 and Armada XP SoCs
   3  *
   4  * This file is licensed under the terms of the GNU General Public
   5  * License version 2.  This program is licensed "as is" without any
   6  * warranty of any kind, whether express or implied.
   7  */
   8
   9 #include <linux/kernel.h>
  10 #include <linux/pci.h>
  11 #include <linux/clk.h>
  12 #include <linux/delay.h>
  13 #include <linux/gpio.h>
  14 #include <linux/module.h>
  15 #include <linux/mbus.h>
  16 #include <linux/msi.h>
  17 #include <linux/slab.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/of_address.h>
  20 #include <linux/of_irq.h>
  21 #include <linux/of_gpio.h>
  22 #include <linux/of_pci.h>
  23 #include <linux/of_platform.h>
  24
  25 /*
  26  * PCIe unit register offsets.
  27  */
  28 #define PCIE_DEV_ID_OFF         0x0000
  29 #define PCIE_CMD_OFF            0x0004
  30 #define PCIE_DEV_REV_OFF        0x0008
  31 #define PCIE_BAR_LO_OFF(n)      (0x0010 + ((n) << 3))
  32 #define PCIE_BAR_HI_OFF(n)      (0x0014 + ((n) << 3))
  33 #define PCIE_HEADER_LOG_4_OFF   0x0128
  34 #define PCIE_BAR_CTRL_OFF(n)    (0x1804 + (((n) - 1) * 4))
  35 #define PCIE_WIN04_CTRL_OFF(n)  (0x1820 + ((n) << 4))
  36 #define PCIE_WIN04_BASE_OFF(n)  (0x1824 + ((n) << 4))
  37 #define PCIE_WIN04_REMAP_OFF(n) (0x182c + ((n) << 4))
  38 #define PCIE_WIN5_CTRL_OFF      0x1880
  39 #define PCIE_WIN5_BASE_OFF      0x1884
  40 #define PCIE_WIN5_REMAP_OFF     0x188c
  41 #define PCIE_CONF_ADDR_OFF      0x18f8
  42 #define  PCIE_CONF_ADDR_EN              0x80000000
  43 #define  PCIE_CONF_REG(r)               ((((r) & 0xf00) << 16) | ((r) & 0xfc))
  44 #define  PCIE_CONF_BUS(b)               (((b) & 0xff) << 16)
  45 #define  PCIE_CONF_DEV(d)               (((d) & 0x1f) << 11)
  46 #define  PCIE_CONF_FUNC(f)              (((f) & 0x7) << 8)
  47 #define  PCIE_CONF_ADDR(bus, devfn, where) \
  48         (PCIE_CONF_BUS(bus) | PCIE_CONF_DEV(PCI_SLOT(devfn))    | \
  49          PCIE_CONF_FUNC(PCI_FUNC(devfn)) | PCIE_CONF_REG(where) | \
  50          PCIE_CONF_ADDR_EN)
  51 #define PCIE_CONF_DATA_OFF      0x18fc
  52 #define PCIE_MASK_OFF           0x1910
  53 #define  PCIE_MASK_ENABLE_INTS          0x0f000000
  54 #define PCIE_CTRL_OFF           0x1a00
  55 #define  PCIE_CTRL_X1_MODE              0x0001
  56 #define PCIE_STAT_OFF           0x1a04
  57 #define  PCIE_STAT_BUS                  0xff00
  58 #define  PCIE_STAT_DEV                  0x1f0000
  59 #define  PCIE_STAT_LINK_DOWN            BIT(0)
  60 #define PCIE_DEBUG_CTRL         0x1a60
  61 #define  PCIE_DEBUG_SOFT_RESET          BIT(20)
  62
  63 /* PCI configuration space of a PCI-to-PCI bridge */
  64 struct mvebu_sw_pci_bridge {
  65         u16 vendor;
  66         u16 device;
  67         u16 command;
  68         u16 class;
  69         u8 interface;
  70         u8 revision;
  71         u8 bist;
  72         u8 header_type;
  73         u8 latency_timer;
  74         u8 cache_line_size;
  75         u32 bar[2];
  76         u8 primary_bus;
  77         u8 secondary_bus;
  78         u8 subordinate_bus;
  79         u8 secondary_latency_timer;
  80         u8 iobase;
  81         u8 iolimit;
  82         u16 secondary_status;
  83         u16 membase;
  84         u16 memlimit;
  85         u16 iobaseupper;
  86         u16 iolimitupper;
  87         u8 cappointer;
  88         u8 reserved1;
  89         u16 reserved2;
  90         u32 romaddr;
  91         u8 intline;
  92         u8 intpin;
  93         u16 bridgectrl;
  94 };
  95
  96 struct mvebu_pcie_port;
  97
  98 /* Structure representing all PCIe interfaces */
  99 struct mvebu_pcie {
 100         struct platform_device *pdev;
 101         struct mvebu_pcie_port *ports;
 102         struct msi_controller *msi;
 103         struct resource io;
 104         struct resource realio;
 105         struct resource mem;
 106         struct resource busn;
 107         int nports;
 108 };
 109
 110 /* Structure representing one PCIe interface */
 111 struct mvebu_pcie_port {
 112         char *name;
 113         void __iomem *base;
 114         u32 port;
 115         u32 lane;
 116         int devfn;
 117         unsigned int mem_target;
 118         unsigned int mem_attr;
 119         unsigned int io_target;
 120         unsigned int io_attr;
 121         struct clk *clk;
 122         struct gpio_desc *reset_gpio;
 123         char *reset_name;
 124         struct mvebu_sw_pci_bridge bridge;
 125         struct device_node *dn;
 126         struct mvebu_pcie *pcie;
 127         phys_addr_t memwin_base;
 128         size_t memwin_size;
 129         phys_addr_t iowin_base;
 130         size_t iowin_size;
 131         u32 saved_pcie_stat;
 132 };
 133
 134 static inline void mvebu_writel(struct mvebu_pcie_port *port, u32 val, u32 reg)
 135 {
 136         writel(val, port->base + reg);
 137 }
 138
 139 static inline u32 mvebu_readl(struct mvebu_pcie_port *port, u32 reg)
 140 {
 141         return readl(port->base + reg);
 142 }
 143
 144 static inline bool mvebu_has_ioport(struct mvebu_pcie_port *port)
 145 {
 146         return port->io_target != -1 && port->io_attr != -1;
 147 }
 148
 149 static bool mvebu_pcie_link_up(struct mvebu_pcie_port *port)
 150 {
 151         return !(mvebu_readl(port, PCIE_STAT_OFF) & PCIE_STAT_LINK_DOWN);
 152 }
 153
 154 static void mvebu_pcie_set_local_bus_nr(struct mvebu_pcie_port *port, int nr)
 155 {
 156         u32 stat;
 157
 158         stat = mvebu_readl(port, PCIE_STAT_OFF);
 159         stat &= ~PCIE_STAT_BUS;
 160         stat |= nr << 8;
 161         mvebu_writel(port, stat, PCIE_STAT_OFF);
 162 }
 163
 164 static void mvebu_pcie_set_local_dev_nr(struct mvebu_pcie_port *port, int nr)
 165 {
 166         u32 stat;
 167
 168         stat = mvebu_readl(port, PCIE_STAT_OFF);
 169         stat &= ~PCIE_STAT_DEV;
 170         stat |= nr << 16;
 171         mvebu_writel(port, stat, PCIE_STAT_OFF);
 172 }
 173
 174 /*
 175  * Setup PCIE BARs and Address Decode Wins:
 176  * BAR[0,2] -> disabled, BAR[1] -> covers all DRAM banks
 177  * WIN[0-3] -> DRAM bank[0-3]
 178  */
 179 static void mvebu_pcie_setup_wins(struct mvebu_pcie_port *port)
 180 {
 181         const struct mbus_dram_target_info *dram;
 182         u32 size;
 183         int i;
 184
 185         dram = mv_mbus_dram_info();
 186
 187         /* First, disable and clear BARs and windows. */
 188         for (i = 1; i < 3; i++) {
 189                 mvebu_writel(port, 0, PCIE_BAR_CTRL_OFF(i));
 190                 mvebu_writel(port, 0, PCIE_BAR_LO_OFF(i));
 191                 mvebu_writel(port, 0, PCIE_BAR_HI_OFF(i));
 192         }
 193
 194         for (i = 0; i < 5; i++) {
 195                 mvebu_writel(port, 0, PCIE_WIN04_CTRL_OFF(i));
 196                 mvebu_writel(port, 0, PCIE_WIN04_BASE_OFF(i));
 197                 mvebu_writel(port, 0, PCIE_WIN04_REMAP_OFF(i));
 198         }
 199
 200         mvebu_writel(port, 0, PCIE_WIN5_CTRL_OFF);
 201         mvebu_writel(port, 0, PCIE_WIN5_BASE_OFF);
 202         mvebu_writel(port, 0, PCIE_WIN5_REMAP_OFF);
 203
 204         /* Setup windows for DDR banks.  Count total DDR size on the fly. */
 205         size = 0;
 206         for (i = 0; i < dram->num_cs; i++) {
 207                 const struct mbus_dram_window *cs = dram->cs + i;
 208
 209                 mvebu_writel(port, cs->base & 0xffff0000,
 210                              PCIE_WIN04_BASE_OFF(i));
 211                 mvebu_writel(port, 0, PCIE_WIN04_REMAP_OFF(i));
 212                 mvebu_writel(port,
 213                              ((cs->size - 1) & 0xffff0000) |
 214                              (cs->mbus_attr << 8) |
 215                              (dram->mbus_dram_target_id << 4) | 1,
 216                              PCIE_WIN04_CTRL_OFF(i));
 217
 218                 size += cs->size;
 219         }
 220
 221         /* Round up 'size' to the nearest power of two. */
 222         if ((size & (size - 1)) != 0)
 223                 size = 1 << fls(size);
 224
 225         /* Setup BAR[1] to all DRAM banks. */
 226         mvebu_writel(port, dram->cs[0].base, PCIE_BAR_LO_OFF(1));
 227         mvebu_writel(port, 0, PCIE_BAR_HI_OFF(1));
 228         mvebu_writel(port, ((size - 1) & 0xffff0000) | 1,
 229                      PCIE_BAR_CTRL_OFF(1));
 230 }
 231
 232 static void mvebu_pcie_setup_hw(struct mvebu_pcie_port *port)
 233 {
 234         u32 cmd, mask;
 235
 236         /* Point PCIe unit MBUS decode windows to DRAM space. */
 237         mvebu_pcie_setup_wins(port);
 238
 239         /* Master + slave enable. */
 240         cmd = mvebu_readl(port, PCIE_CMD_OFF);
 241         cmd |= PCI_COMMAND_IO;
 242         cmd |= PCI_COMMAND_MEMORY;
 243         cmd |= PCI_COMMAND_MASTER;
 244         mvebu_writel(port, cmd, PCIE_CMD_OFF);
 245
 246         /* Enable interrupt lines A-D. */
 247         mask = mvebu_readl(port, PCIE_MASK_OFF);
 248         mask |= PCIE_MASK_ENABLE_INTS;
 249         mvebu_writel(port, mask, PCIE_MASK_OFF);
 250 }
 251
 252 static int mvebu_pcie_hw_rd_conf(struct mvebu_pcie_port *port,
 253                                  struct pci_bus *bus,
 254                                  u32 devfn, int where, int size, u32 *val)
 255 {
 256         void __iomem *conf_data = port->base + PCIE_CONF_DATA_OFF;
 257
 258         mvebu_writel(port, PCIE_CONF_ADDR(bus->number, devfn, where),
 259                      PCIE_CONF_ADDR_OFF);
 260
 261         switch (size) {
 262         case 1:
 263                 *val = readb_relaxed(conf_data + (where & 3));
 264                 break;
 265         case 2:
 266                 *val = readw_relaxed(conf_data + (where & 2));
 267                 break;
 268         case 4:
 269                 *val = readl_relaxed(conf_data);
 270                 break;
 271         }
 272
 273         return PCIBIOS_SUCCESSFUL;
 274 }
 275
 276 static int mvebu_pcie_hw_wr_conf(struct mvebu_pcie_port *port,
 277                                  struct pci_bus *bus,
 278                                  u32 devfn, int where, int size, u32 val)
 279 {
 280         void __iomem *conf_data = port->base + PCIE_CONF_DATA_OFF;
 281
 282         mvebu_writel(port, PCIE_CONF_ADDR(bus->number, devfn, where),
 283                      PCIE_CONF_ADDR_OFF);
 284
 285         switch (size) {
 286         case 1:
 287                 writeb(val, conf_data + (where & 3));
 288                 break;
 289         case 2:
 290                 writew(val, conf_data + (where & 2));
 291                 break;
 292         case 4:
 293                 writel(val, conf_data);
 294                 break;
 295         default:
 296                 return PCIBIOS_BAD_REGISTER_NUMBER;
 297         }
 298
 299         return PCIBIOS_SUCCESSFUL;
 300 }
 301
 302 /*
 303  * Remove windows, starting from the largest ones to the smallest
 304  * ones.
 305  */
 306 static void mvebu_pcie_del_windows(struct mvebu_pcie_port *port,
 307                                    phys_addr_t base, size_t size)
 308 {
 309         while (size) {
 310                 size_t sz = 1 << (fls(size) - 1);
 311
 312                 mvebu_mbus_del_window(base, sz);
 313                 base += sz;
 314                 size -= sz;
 315         }
 316 }
 317
 318 /*
 319  * MBus windows can only have a power of two size, but PCI BARs do not
 320  * have this constraint. Therefore, we have to split the PCI BAR into
 321  * areas each having a power of two size. We start from the largest
 322  * one (i.e highest order bit set in the size).
 323  */
 324 static void mvebu_pcie_add_windows(struct mvebu_pcie_port *port,
 325                                    unsigned int target, unsigned int attribute,
 326                                    phys_addr_t base, size_t size,
 327                                    phys_addr_t remap)
 328 {
 329         size_t size_mapped = 0;
 330
 331         while (size) {
 332                 size_t sz = 1 << (fls(size) - 1);
 333                 int ret;
 334
 335                 ret = mvebu_mbus_add_window_remap_by_id(target, attribute, base,
 336                                                         sz, remap);
 337                 if (ret) {
 338                         phys_addr_t end = base + sz - 1;
 339
 340                         dev_err(&port->pcie->pdev->dev,
 341                                 "Could not create MBus window at [mem %pa-%pa]: %d\n",
 342                                 &base, &end, ret);
 343                         mvebu_pcie_del_windows(port, base - size_mapped,
 344                                                size_mapped);
 345                         return;
 346                 }
 347
 348                 size -= sz;
 349                 size_mapped += sz;
 350                 base += sz;
 351                 if (remap != MVEBU_MBUS_NO_REMAP)
 352                         remap += sz;
 353         }
 354 }
 355
 356 static void mvebu_pcie_handle_iobase_change(struct mvebu_pcie_port *port)
 357 {
 358         phys_addr_t iobase;
 359
 360         /* Are the new iobase/iolimit values invalid? */
 361         if (port->bridge.iolimit < port->bridge.iobase ||
 362             port->bridge.iolimitupper < port->bridge.iobaseupper ||
 363             !(port->bridge.command & PCI_COMMAND_IO)) {
 364
 365                 /* If a window was configured, remove it */
 366                 if (port->iowin_base) {
 367                         mvebu_pcie_del_windows(port, port->iowin_base,
 368                                                port->iowin_size);
 369                         port->iowin_base = 0;
 370                         port->iowin_size = 0;
 371                 }
 372
 373                 return;
 374         }
 375
 376         if (!mvebu_has_ioport(port)) {
 377                 dev_WARN(&port->pcie->pdev->dev,
 378                          "Attempt to set IO when IO is disabled\n");
 379                 return;
 380         }
 381
 382         /*
 383          * We read the PCI-to-PCI bridge emulated registers, and
 384          * calculate the base address and size of the address decoding
 385          * window to setup, according to the PCI-to-PCI bridge
 386          * specifications. iobase is the bus address, port->iowin_base
 387          * is the CPU address.
 388          */
 389         iobase = ((port->bridge.iobase & 0xF0) << 8) |
 390                 (port->bridge.iobaseupper << 16);
 391         port->iowin_base = port->pcie->io.start + iobase;
 392         port->iowin_size = ((0xFFF | ((port->bridge.iolimit & 0xF0) << 8) |
 393                             (port->bridge.iolimitupper << 16)) -
 394                             iobase) + 1;
 395
 396         mvebu_pcie_add_windows(port, port->io_target, port->io_attr,
 397                                port->iowin_base, port->iowin_size,
 398                                iobase);
 399 }
 400
 401 static void mvebu_pcie_handle_membase_change(struct mvebu_pcie_port *port)
 402 {
 403         /* Are the new membase/memlimit values invalid? */
 404         if (port->bridge.memlimit < port->bridge.membase ||
 405             !(port->bridge.command & PCI_COMMAND_MEMORY)) {
 406
 407                 /* If a window was configured, remove it */
 408                 if (port->memwin_base) {
 409                         mvebu_pcie_del_windows(port, port->memwin_base,
 410                                                port->memwin_size);
 411                         port->memwin_base = 0;
 412                         port->memwin_size = 0;
 413                 }
 414
 415                 return;
 416         }
 417
 418         /*
 419          * We read the PCI-to-PCI bridge emulated registers, and
 420          * calculate the base address and size of the address decoding
 421          * window to setup, according to the PCI-to-PCI bridge
 422          * specifications.
 423          */
 424         port->memwin_base  = ((port->bridge.membase & 0xFFF0) << 16);
 425         port->memwin_size  =
 426                 (((port->bridge.memlimit & 0xFFF0) << 16) | 0xFFFFF) -
 427                 port->memwin_base + 1;
 428
 429         mvebu_pcie_add_windows(port, port->mem_target, port->mem_attr,
 430                                port->memwin_base, port->memwin_size,
 431                                MVEBU_MBUS_NO_REMAP);
 432 }
 433
 434 /*
 435  * Initialize the configuration space of the PCI-to-PCI bridge
 436  * associated with the given PCIe interface.
 437  */
 438 static void mvebu_sw_pci_bridge_init(struct mvebu_pcie_port *port)
 439 {
 440         struct mvebu_sw_pci_bridge *bridge = &port->bridge;
 441
 442         memset(bridge, 0, sizeof(struct mvebu_sw_pci_bridge));
 443
 444         bridge->class = PCI_CLASS_BRIDGE_PCI;
 445         bridge->vendor = PCI_VENDOR_ID_MARVELL;
 446         bridge->device = mvebu_readl(port, PCIE_DEV_ID_OFF) >> 16;
 447         bridge->revision = mvebu_readl(port, PCIE_DEV_REV_OFF) & 0xff;
 448         bridge->header_type = PCI_HEADER_TYPE_BRIDGE;
 449         bridge->cache_line_size = 0x10;
 450
 451         /* We support 32 bits I/O addressing */
 452         bridge->iobase = PCI_IO_RANGE_TYPE_32;
 453         bridge->iolimit = PCI_IO_RANGE_TYPE_32;
 454 }
 455
 456 /*
 457  * Read the configuration space of the PCI-to-PCI bridge associated to
 458  * the given PCIe interface.
 459  */
 460 static int mvebu_sw_pci_bridge_read(struct mvebu_pcie_port *port,
 461                                   unsigned int where, int size, u32 *value)
 462 {
 463         struct mvebu_sw_pci_bridge *bridge = &port->bridge;
 464
 465         switch (where & ~3) {
 466         case PCI_VENDOR_ID:
 467                 *value = bridge->device << 16 | bridge->vendor;
 468                 break;
 469
 470         case PCI_COMMAND:
 471                 *value = bridge->command;
 472                 break;
 473
 474         case PCI_CLASS_REVISION:
 475                 *value = bridge->class << 16 | bridge->interface << 8 |
 476                          bridge->revision;
 477                 break;
 478
 479         case PCI_CACHE_LINE_SIZE:
 480                 *value = bridge->bist << 24 | bridge->header_type << 16 |
 481                          bridge->latency_timer << 8 | bridge->cache_line_size;
 482                 break;
 483
 484         case PCI_BASE_ADDRESS_0 ... PCI_BASE_ADDRESS_1:
 485                 *value = bridge->bar[((where & ~3) - PCI_BASE_ADDRESS_0) / 4];
 486                 break;
 487
 488         case PCI_PRIMARY_BUS:
 489                 *value = (bridge->secondary_latency_timer << 24 |
 490                           bridge->subordinate_bus         << 16 |
 491                           bridge->secondary_bus           <<  8 |
 492                           bridge->primary_bus);
 493                 break;
 494
 495         case PCI_IO_BASE:
 496                 if (!mvebu_has_ioport(port))
 497                         *value = bridge->secondary_status << 16;
 498                 else
 499                         *value = (bridge->secondary_status << 16 |
 500                                   bridge->iolimit          <<  8 |
 501                                   bridge->iobase);
 502                 break;
 503
 504         case PCI_MEMORY_BASE:
 505                 *value = (bridge->memlimit << 16 | bridge->membase);
 506                 break;
 507
 508         case PCI_PREF_MEMORY_BASE:
 509                 *value = 0;
 510                 break;
 511
 512         case PCI_IO_BASE_UPPER16:
 513                 *value = (bridge->iolimitupper << 16 | bridge->iobaseupper);
 514                 break;
 515
 516         case PCI_ROM_ADDRESS1:
 517                 *value = 0;
 518                 break;
 519
 520         case PCI_INTERRUPT_LINE:
 521                 /* LINE PIN MIN_GNT MAX_LAT */
 522                 *value = 0;
 523                 break;
 524
 525         default:
 526                 /*
 527                  * PCI defines configuration read accesses to reserved or
 528                  * unimplemented registers to read as zero and complete
 529                  * normally.
 530                  */
 531                 *value = 0;
 532                 return PCIBIOS_SUCCESSFUL;
 533         }
 534
 535         if (size == 2)
 536                 *value = (*value >> (8 * (where & 3))) & 0xffff;
 537         else if (size == 1)
 538                 *value = (*value >> (8 * (where & 3))) & 0xff;
 539
 540         return PCIBIOS_SUCCESSFUL;
 541 }
 542
 543 /* Write to the PCI-to-PCI bridge configuration space */
 544 static int mvebu_sw_pci_bridge_write(struct mvebu_pcie_port *port,
 545                                      unsigned int where, int size, u32 value)
 546 {
 547         struct mvebu_sw_pci_bridge *bridge = &port->bridge;
 548         u32 mask, reg;
 549         int err;
 550
 551         if (size == 4)
 552                 mask = 0x0;
 553         else if (size == 2)
 554                 mask = ~(0xffff << ((where & 3) * 8));
 555         else if (size == 1)
 556                 mask = ~(0xff << ((where & 3) * 8));
 557         else
 558                 return PCIBIOS_BAD_REGISTER_NUMBER;
 559
 560         err = mvebu_sw_pci_bridge_read(port, where & ~3, 4, &reg);
 561         if (err)
 562                 return err;
 563
 564         value = (reg & mask) | value << ((where & 3) * 8);
 565
 566         switch (where & ~3) {
 567         case PCI_COMMAND:
 568         {
 569                 u32 old = bridge->command;
 570
 571                 if (!mvebu_has_ioport(port))
 572                         value &= ~PCI_COMMAND_IO;
 573
 574                 bridge->command = value & 0xffff;
 575                 if ((old ^ bridge->command) & PCI_COMMAND_IO)
 576                         mvebu_pcie_handle_iobase_change(port);
 577                 if ((old ^ bridge->command) & PCI_COMMAND_MEMORY)
 578                         mvebu_pcie_handle_membase_change(port);
 579                 break;
 580         }
 581
 582         case PCI_BASE_ADDRESS_0 ... PCI_BASE_ADDRESS_1:
 583                 bridge->bar[((where & ~3) - PCI_BASE_ADDRESS_0) / 4] = value;
 584                 break;
 585
 586         case PCI_IO_BASE:
 587                 /*
 588                  * We also keep bit 1 set, it is a read-only bit that
 589                  * indicates we support 32 bits addressing for the
 590                  * I/O
 591                  */
 592                 bridge->iobase = (value & 0xff) | PCI_IO_RANGE_TYPE_32;
 593                 bridge->iolimit = ((value >> 8) & 0xff) | PCI_IO_RANGE_TYPE_32;
 594                 mvebu_pcie_handle_iobase_change(port);
 595                 break;
 596
 597         case PCI_MEMORY_BASE:
 598                 bridge->membase = value & 0xffff;
 599                 bridge->memlimit = value >> 16;
 600                 mvebu_pcie_handle_membase_change(port);
 601                 break;
 602
 603         case PCI_IO_BASE_UPPER16:
 604                 bridge->iobaseupper = value & 0xffff;
 605                 bridge->iolimitupper = value >> 16;
 606                 mvebu_pcie_handle_iobase_change(port);
 607                 break;
 608
 609         case PCI_PRIMARY_BUS:
 610                 bridge->primary_bus             = value & 0xff;
 611                 bridge->secondary_bus           = (value >> 8) & 0xff;
 612                 bridge->subordinate_bus         = (value >> 16) & 0xff;
 613                 bridge->secondary_latency_timer = (value >> 24) & 0xff;
 614                 mvebu_pcie_set_local_bus_nr(port, bridge->secondary_bus);
 615                 break;
 616
 617         default:
 618                 break;
 619         }
 620
 621         return PCIBIOS_SUCCESSFUL;
 622 }
 623
 624 static inline struct mvebu_pcie *sys_to_pcie(struct pci_sys_data *sys)
 625 {
 626         return sys->private_data;
 627 }
 628
 629 static struct mvebu_pcie_port *mvebu_pcie_find_port(struct mvebu_pcie *pcie,
 630                                                     struct pci_bus *bus,
 631                                                     int devfn)
 632 {
 633         int i;
 634
 635         for (i = 0; i < pcie->nports; i++) {
 636                 struct mvebu_pcie_port *port = &pcie->ports[i];
 637
 638                 if (bus->number == 0 && port->devfn == devfn)
 639                         return port;
 640                 if (bus->number != 0 &&
 641                     bus->number >= port->bridge.secondary_bus &&
 642                     bus->number <= port->bridge.subordinate_bus)
 643                         return port;
 644         }
 645
 646         return NULL;
 647 }
 648
 649 /* PCI configuration space write function */
 650 static int mvebu_pcie_wr_conf(struct pci_bus *bus, u32 devfn,
 651                               int where, int size, u32 val)
 652 {
 653         struct mvebu_pcie *pcie = sys_to_pcie(bus->sysdata);
 654         struct mvebu_pcie_port *port;
 655         int ret;
 656
 657         port = mvebu_pcie_find_port(pcie, bus, devfn);
 658         if (!port)
 659                 return PCIBIOS_DEVICE_NOT_FOUND;
 660
 661         /* Access the emulated PCI-to-PCI bridge */
 662         if (bus->number == 0)
 663                 return mvebu_sw_pci_bridge_write(port, where, size, val);
 664
 665         if (!mvebu_pcie_link_up(port))
 666                 return PCIBIOS_DEVICE_NOT_FOUND;
 667
 668         /*
 669          * On the secondary bus, we don't want to expose any other
 670          * device than the device physically connected in the PCIe
 671          * slot, visible in slot 0. In slot 1, there's a special
 672          * Marvell device that only makes sense when the Armada is
 673          * used as a PCIe endpoint.
 674          */
 675         if (bus->number == port->bridge.secondary_bus &&
 676             PCI_SLOT(devfn) != 0)
 677                 return PCIBIOS_DEVICE_NOT_FOUND;
 678
 679         /* Access the real PCIe interface */
 680         ret = mvebu_pcie_hw_wr_conf(port, bus, devfn,
 681                                     where, size, val);
 682
 683         return ret;
 684 }
 685
 686 /* PCI configuration space read function */
 687 static int mvebu_pcie_rd_conf(struct pci_bus *bus, u32 devfn, int where,
 688                               int size, u32 *val)
 689 {
 690         struct mvebu_pcie *pcie = sys_to_pcie(bus->sysdata);
 691         struct mvebu_pcie_port *port;
 692         int ret;
 693
 694         port = mvebu_pcie_find_port(pcie, bus, devfn);
 695         if (!port) {
 696                 *val = 0xffffffff;
 697                 return PCIBIOS_DEVICE_NOT_FOUND;
 698         }
 699
 700         /* Access the emulated PCI-to-PCI bridge */
 701         if (bus->number == 0)
 702                 return mvebu_sw_pci_bridge_read(port, where, size, val);
 703
 704         if (!mvebu_pcie_link_up(port)) {
 705                 *val = 0xffffffff;
 706                 return PCIBIOS_DEVICE_NOT_FOUND;
 707         }
 708
 709         /*
 710          * On the secondary bus, we don't want to expose any other
 711          * device than the device physically connected in the PCIe
 712          * slot, visible in slot 0. In slot 1, there's a special
 713          * Marvell device that only makes sense when the Armada is
 714          * used as a PCIe endpoint.
 715          */
 716         if (bus->number == port->bridge.secondary_bus &&
 717             PCI_SLOT(devfn) != 0) {
 718                 *val = 0xffffffff;
 719                 return PCIBIOS_DEVICE_NOT_FOUND;
 720         }
 721
 722         /* Access the real PCIe interface */
 723         ret = mvebu_pcie_hw_rd_conf(port, bus, devfn,
 724                                     where, size, val);
 725
 726         return ret;
 727 }
 728
 729 static struct pci_ops mvebu_pcie_ops = {
 730         .read = mvebu_pcie_rd_conf,
 731         .write = mvebu_pcie_wr_conf,
 732 };
 733
 734 static int mvebu_pcie_setup(int nr, struct pci_sys_data *sys)
 735 {
 736         struct mvebu_pcie *pcie = sys_to_pcie(sys);
 737         int i;
 738
 739         pcie->mem.name = "PCI MEM";
 740         pcie->realio.name = "PCI I/O";
 741
 742         if (request_resource(&iomem_resource, &pcie->mem))
 743                 return 0;
 744
 745         if (resource_size(&pcie->realio) != 0) {
 746                 if (request_resource(&ioport_resource, &pcie->realio)) {
 747                         release_resource(&pcie->mem);
 748                         return 0;
 749                 }
 750                 pci_add_resource_offset(&sys->resources, &pcie->realio,
 751                                         sys->io_offset);
 752         }
 753         pci_add_resource_offset(&sys->resources, &pcie->mem, sys->mem_offset);
 754         pci_add_resource(&sys->resources, &pcie->busn);
 755
 756         for (i = 0; i < pcie->nports; i++) {
 757                 struct mvebu_pcie_port *port = &pcie->ports[i];
 758
 759                 if (!port->base)
 760                         continue;
 761                 mvebu_pcie_setup_hw(port);
 762         }
 763
 764         return 1;
 765 }
 766
 767 static resource_size_t mvebu_pcie_align_resource(struct pci_dev *dev,
 768                                                  const struct resource *res,
 769                                                  resource_size_t start,
 770                                                  resource_size_t size,
 771                                                  resource_size_t align)
 772 {
 773         if (dev->bus->number != 0)
 774                 return start;
 775
 776         /*
 777          * On the PCI-to-PCI bridge side, the I/O windows must have at
 778          * least a 64 KB size and the memory windows must have at
 779          * least a 1 MB size. Moreover, MBus windows need to have a
 780          * base address aligned on their size, and their size must be
 781          * a power of two. This means that if the BAR doesn't have a
 782          * power of two size, several MBus windows will actually be
 783          * created. We need to ensure that the biggest MBus window
 784          * (which will be the first one) is aligned on its size, which
 785          * explains the rounddown_pow_of_two() being done here.
 786          */
 787         if (res->flags & IORESOURCE_IO)
 788                 return round_up(start, max_t(resource_size_t, SZ_64K,
 789                                              rounddown_pow_of_two(size)));
 790         else if (res->flags & IORESOURCE_MEM)
 791                 return round_up(start, max_t(resource_size_t, SZ_1M,
 792                                              rounddown_pow_of_two(size)));
 793         else
 794                 return start;
 795 }
 796
 797 static void mvebu_pcie_enable(struct mvebu_pcie *pcie)
 798 {
 799         struct hw_pci hw;
 800
 801         memset(&hw, 0, sizeof(hw));
 802
 803 #ifdef CONFIG_PCI_MSI
 804         hw.msi_ctrl = pcie->msi;
 805 #endif
 806
 807         hw.nr_controllers = 1;
 808         hw.private_data   = (void **)&pcie;
 809         hw.setup          = mvebu_pcie_setup;
 810         hw.map_irq        = of_irq_parse_and_map_pci;
 811         hw.ops            = &mvebu_pcie_ops;
 812         hw.align_resource = mvebu_pcie_align_resource;
 813
 814         pci_common_init_dev(&pcie->pdev->dev, &hw);
 815 }
 816
 817 /*
 818  * Looks up the list of register addresses encoded into the reg =
 819  * <...> property for one that matches the given port/lane. Once
 820  * found, maps it.
 821  */
 822 static void __iomem *mvebu_pcie_map_registers(struct platform_device *pdev,
 823                                               struct device_node *np,
 824                                               struct mvebu_pcie_port *port)
 825 {
 826         struct resource regs;
 827         int ret = 0;
 828
 829         ret = of_address_to_resource(np, 0, &regs);
 830         if (ret)
 831                 return ERR_PTR(ret);
 832
 833         return devm_ioremap_resource(&pdev->dev, &regs);
 834 }
 835
 836 #define DT_FLAGS_TO_TYPE(flags)       (((flags) >> 24) & 0x03)
 837 #define    DT_TYPE_IO                 0x1
 838 #define    DT_TYPE_MEM32              0x2
 839 #define DT_CPUADDR_TO_TARGET(cpuaddr) (((cpuaddr) >> 56) & 0xFF)
 840 #define DT_CPUADDR_TO_ATTR(cpuaddr)   (((cpuaddr) >> 48) & 0xFF)
 841
 842 static int mvebu_get_tgt_attr(struct device_node *np, int devfn,
 843                               unsigned long type,
 844                               unsigned int *tgt,
 845                               unsigned int *attr)
 846 {
 847         const int na = 3, ns = 2;
 848         const __be32 *range;
 849         int rlen, nranges, rangesz, pna, i;
 850
 851         *tgt = -1;
 852         *attr = -1;
 853
 854         range = of_get_property(np, "ranges", &rlen);
 855         if (!range)
 856                 return -EINVAL;
 857
 858         pna = of_n_addr_cells(np);
 859         rangesz = pna + na + ns;
 860         nranges = rlen / sizeof(__be32) / rangesz;
 861
 862         for (i = 0; i < nranges; i++, range += rangesz) {
 863                 u32 flags = of_read_number(range, 1);
 864                 u32 slot = of_read_number(range + 1, 1);
 865                 u64 cpuaddr = of_read_number(range + na, pna);
 866                 unsigned long rtype;
 867
 868                 if (DT_FLAGS_TO_TYPE(flags) == DT_TYPE_IO)
 869                         rtype = IORESOURCE_IO;
 870                 else if (DT_FLAGS_TO_TYPE(flags) == DT_TYPE_MEM32)
 871                         rtype = IORESOURCE_MEM;
 872                 else
 873                         continue;
 874
 875                 if (slot == PCI_SLOT(devfn) && type == rtype) {
 876                         *tgt = DT_CPUADDR_TO_TARGET(cpuaddr);
 877                         *attr = DT_CPUADDR_TO_ATTR(cpuaddr);
 878                         return 0;
 879                 }
 880         }
 881
 882         return -ENOENT;
 883 }
 884
 885 static void mvebu_pcie_msi_enable(struct mvebu_pcie *pcie)
 886 {
 887         struct device_node *msi_node;
 888
 889         msi_node = of_parse_phandle(pcie->pdev->dev.of_node,
 890                                     "msi-parent", 0);
 891         if (!msi_node)
 892                 return;
 893
 894         pcie->msi = of_pci_find_msi_chip_by_node(msi_node);
 895         of_node_put(msi_node);
 896
 897         if (pcie->msi)
 898                 pcie->msi->dev = &pcie->pdev->dev;
 899 }
 900
 901 static int mvebu_pcie_suspend(struct device *dev)
 902 {
 903         struct mvebu_pcie *pcie;
 904         int i;
 905
 906         pcie = dev_get_drvdata(dev);
 907         for (i = 0; i < pcie->nports; i++) {
 908                 struct mvebu_pcie_port *port = pcie->ports + i;
 909                 port->saved_pcie_stat = mvebu_readl(port, PCIE_STAT_OFF);
 910         }
 911
 912         return 0;
 913 }
 914
 915 static int mvebu_pcie_resume(struct device *dev)
 916 {
 917         struct mvebu_pcie *pcie;
 918         int i;
 919
 920         pcie = dev_get_drvdata(dev);
 921         for (i = 0; i < pcie->nports; i++) {
 922                 struct mvebu_pcie_port *port = pcie->ports + i;
 923                 mvebu_writel(port, port->saved_pcie_stat, PCIE_STAT_OFF);
 924                 mvebu_pcie_setup_hw(port);
 925         }
 926
 927         return 0;
 928 }
 929
 930 static void mvebu_pcie_port_clk_put(void *data)
 931 {
 932         struct mvebu_pcie_port *port = data;
 933
 934         clk_put(port->clk);
 935 }
 936
 937 static int mvebu_pcie_parse_port(struct mvebu_pcie *pcie,
 938         struct mvebu_pcie_port *port, struct device_node *child)
 939 {
 940         struct device *dev = &pcie->pdev->dev;
 941         enum of_gpio_flags flags;
 942         int reset_gpio, ret;
 943
 944         port->pcie = pcie;
 945
 946         if (of_property_read_u32(child, "marvell,pcie-port", &port->port)) {
 947                 dev_warn(dev, "ignoring %s, missing pcie-port property\n",
 948                          of_node_full_name(child));
 949                 goto skip;
 950         }
 951
 952         if (of_property_read_u32(child, "marvell,pcie-lane", &port->lane))
 953                 port->lane = 0;
 954
 955         port->name = devm_kasprintf(dev, GFP_KERNEL, "pcie%d.%d", port->port,
 956                                     port->lane);
 957         if (!port->name) {
 958                 ret = -ENOMEM;
 959                 goto err;
 960         }
 961
 962         port->devfn = of_pci_get_devfn(child);
 963         if (port->devfn < 0)
 964                 goto skip;
 965
 966         ret = mvebu_get_tgt_attr(dev->of_node, port->devfn, IORESOURCE_MEM,
 967                                  &port->mem_target, &port->mem_attr);
 968         if (ret < 0) {
 969                 dev_err(dev, "%s: cannot get tgt/attr for mem window\n",
 970                         port->name);
 971                 goto skip;
 972         }
 973
 974         if (resource_size(&pcie->io) != 0) {
 975                 mvebu_get_tgt_attr(dev->of_node, port->devfn, IORESOURCE_IO,
 976                                    &port->io_target, &port->io_attr);
 977         } else {
 978                 port->io_target = -1;
 979                 port->io_attr = -1;
 980         }
 981
 982         reset_gpio = of_get_named_gpio_flags(child, "reset-gpios", 0, &flags);
 983         if (reset_gpio == -EPROBE_DEFER) {
 984                 ret = reset_gpio;
 985                 goto err;
 986         }
 987
 988         if (gpio_is_valid(reset_gpio)) {
 989                 unsigned long gpio_flags;
 990
 991                 port->reset_name = devm_kasprintf(dev, GFP_KERNEL, "%s-reset",
 992                                                   port->name);
 993                 if (!port->reset_name) {
 994                         ret = -ENOMEM;
 995                         goto err;
 996                 }
 997
 998                 if (flags & OF_GPIO_ACTIVE_LOW) {
 999                         dev_info(dev, "%s: reset gpio is active low\n",
1000                                  of_node_full_name(child));
1001                         gpio_flags = GPIOF_ACTIVE_LOW |
1002                                      GPIOF_OUT_INIT_LOW;
1003                 } else {
1004                         gpio_flags = GPIOF_OUT_INIT_HIGH;
1005                 }
1006
1007                 ret = devm_gpio_request_one(dev, reset_gpio, gpio_flags,
1008                                             port->reset_name);
1009                 if (ret) {
1010                         if (ret == -EPROBE_DEFER)
1011                                 goto err;
1012                         goto skip;
1013                 }
1014
1015                 port->reset_gpio = gpio_to_desc(reset_gpio);
1016         }
1017
1018         port->clk = of_clk_get_by_name(child, NULL);
1019         if (IS_ERR(port->clk)) {
1020                 dev_err(dev, "%s: cannot get clock\n", port->name);
1021                 goto skip;
1022         }
1023
1024         ret = devm_add_action(dev, mvebu_pcie_port_clk_put, port);
1025         if (ret < 0) {
1026                 clk_put(port->clk);
1027                 goto err;
1028         }
1029
1030         return 1;
1031
1032 skip:
1033         ret = 0;
1034
1035         /* In the case of skipping, we need to free these */
1036         devm_kfree(dev, port->reset_name);
1037         port->reset_name = NULL;
1038         devm_kfree(dev, port->name);
1039         port->name = NULL;
1040
1041 err:
1042         return ret;
1043 }
1044
1045 static int mvebu_pcie_probe(struct platform_device *pdev)
1046 {
1047         struct mvebu_pcie *pcie;
1048         struct device_node *np = pdev->dev.of_node;
1049         struct device_node *child;
1050         int num, i, ret;
1051
1052         pcie = devm_kzalloc(&pdev->dev, sizeof(struct mvebu_pcie),
1053                             GFP_KERNEL);
1054         if (!pcie)
1055                 return -ENOMEM;
1056
1057         pcie->pdev = pdev;
1058         platform_set_drvdata(pdev, pcie);
1059
1060         /* Get the PCIe memory and I/O aperture */
1061         mvebu_mbus_get_pcie_mem_aperture(&pcie->mem);
1062         if (resource_size(&pcie->mem) == 0) {
1063                 dev_err(&pdev->dev, "invalid memory aperture size\n");
1064                 return -EINVAL;
1065         }
1066
1067         mvebu_mbus_get_pcie_io_aperture(&pcie->io);
1068
1069         if (resource_size(&pcie->io) != 0) {
1070                 pcie->realio.flags = pcie->io.flags;
1071                 pcie->realio.start = PCIBIOS_MIN_IO;
1072                 pcie->realio.end = min_t(resource_size_t,
1073                                          IO_SPACE_LIMIT,
1074                                          resource_size(&pcie->io));
1075         } else
1076                 pcie->realio = pcie->io;
1077
1078         /* Get the bus range */
1079         ret = of_pci_parse_bus_range(np, &pcie->busn);
1080         if (ret) {
1081                 dev_err(&pdev->dev, "failed to parse bus-range property: %d\n",
1082                         ret);
1083                 return ret;
1084         }
1085
1086         num = of_get_available_child_count(pdev->dev.of_node);
1087
1088         pcie->ports = devm_kcalloc(&pdev->dev, num, sizeof(*pcie->ports),
1089                                    GFP_KERNEL);
1090         if (!pcie->ports)
1091                 return -ENOMEM;
1092
1093         i = 0;
1094         for_each_available_child_of_node(pdev->dev.of_node, child) {
1095                 struct mvebu_pcie_port *port = &pcie->ports[i];
1096
1097                 ret = mvebu_pcie_parse_port(pcie, port, child);
1098                 if (ret < 0) {
1099                         of_node_put(child);
1100                         return ret;
1101                 } else if (ret == 0) {
1102                         continue;
1103                 }
1104
1105                 port->dn = child;
1106                 i++;
1107         }
1108         pcie->nports = i;
1109
1110         for (i = 0; i < pcie->nports; i++) {
1111                 struct mvebu_pcie_port *port = &pcie->ports[i];
1112
1113                 child = port->dn;
1114                 if (!child)
1115                         continue;
1116
1117                 if (port->reset_gpio) {
1118                         u32 reset_udelay = 20000;
1119
1120                         of_property_read_u32(child, "reset-delay-us",
1121                                              &reset_udelay);
1122
1123                         gpiod_set_value_cansleep(port->reset_gpio, 0);
1124                         msleep(reset_udelay / 1000);
1125                 }
1126
1127                 ret = clk_prepare_enable(port->clk);
1128                 if (ret)
1129                         continue;
1130
1131                 port->base = mvebu_pcie_map_registers(pdev, child, port);
1132                 if (IS_ERR(port->base)) {
1133                         dev_err(&pdev->dev, "%s: cannot map registers\n",
1134                                 port->name);
1135                         port->base = NULL;
1136                         clk_disable_unprepare(port->clk);
1137                         continue;
1138                 }
1139
1140                 mvebu_pcie_set_local_dev_nr(port, 1);
1141                 mvebu_sw_pci_bridge_init(port);
1142         }
1143
1144         pcie->nports = i;
1145
1146         for (i = 0; i < (IO_SPACE_LIMIT - SZ_64K); i += SZ_64K)
1147                 pci_ioremap_io(i, pcie->io.start + i);
1148
1149         mvebu_pcie_msi_enable(pcie);
1150         mvebu_pcie_enable(pcie);
1151
1152         platform_set_drvdata(pdev, pcie);
1153
1154         return 0;
1155 }
1156
1157 static const struct of_device_id mvebu_pcie_of_match_table[] = {
1158         { .compatible = "marvell,armada-xp-pcie", },
1159         { .compatible = "marvell,armada-370-pcie", },
1160         { .compatible = "marvell,dove-pcie", },
1161         { .compatible = "marvell,kirkwood-pcie", },
1162         {},
1163 };
1164 MODULE_DEVICE_TABLE(of, mvebu_pcie_of_match_table);
1165
1166 static struct dev_pm_ops mvebu_pcie_pm_ops = {
1167         .suspend_noirq = mvebu_pcie_suspend,
1168         .resume_noirq = mvebu_pcie_resume,
1169 };
1170
1171 static struct platform_driver mvebu_pcie_driver = {
1172         .driver = {
1173                 .name = "mvebu-pcie",
1174                 .of_match_table = mvebu_pcie_of_match_table,
1175                 /* driver unloading/unbinding currently not supported */
1176                 .suppress_bind_attrs = true,
1177                 .pm = &mvebu_pcie_pm_ops,
1178         },
1179         .probe = mvebu_pcie_probe,
1180 };
1181 module_platform_driver(mvebu_pcie_driver);
1182
1183 MODULE_AUTHOR("Thomas Petazzoni <thomas.petazzoni@free-electrons.com>");
1184 MODULE_DESCRIPTION("Marvell EBU PCIe driver");
1185 MODULE_LICENSE("GPL v2");