target/linux/bcm53xx/patches-3.14/170-pcie2-bcma-add-new-PCIe2-driver-for-bcma.patch

   1 From cc2cda651fcbc498bf513a6b802dca19944bcb37 Mon Sep 17 00:00:00 2001
   2 From: Hauke Mehrtens <hauke@hauke-m.de>
   3 Date: Mon, 12 May 2014 11:55:20 +0200
   4 Subject: [PATCH 13/17] pcie2-bcma: add new PCIe2 driver for bcma
   5
   6 This driver supports the PCIe controller found on the BCM4708 and
   7 similar SoCs. The controller itself is automatically detected by bcma.
   8
   9 Signed-off-by: Hauke Mehrtens <hauke@hauke-m.de>
  10 ---
  11  arch/arm/mach-bcm/Kconfig     |   2 +
  12  drivers/pci/host/Kconfig      |   7 +
  13  drivers/pci/host/Makefile     |   1 +
  14  drivers/pci/host/pcie2-bcma.c | 591 ++++++++++++++++++++++++++++++++++++++++++
  15  4 files changed, 601 insertions(+)
  16  create mode 100644 drivers/pci/host/pcie2-bcma.c
  17
  18 --- a/arch/arm/mach-bcm/Kconfig
  19 +++ b/arch/arm/mach-bcm/Kconfig
  20 @@ -45,6 +45,7 @@ config ARCH_BCM_5301X
  21         select ARM_GLOBAL_TIMER
  22         select CLKSRC_ARM_GLOBAL_TIMER_SCHED_CLOCK
  23         select MIGHT_HAVE_PCI
  24 +       select PCI_DOMAINS if PCI
  25         help
  26           Support for Broadcom BCM470X and BCM5301X SoCs with ARM CPU cores.
  27
  28 --- a/drivers/pci/host/Kconfig
  29 +++ b/drivers/pci/host/Kconfig
  30 @@ -33,4 +33,11 @@ config PCI_RCAR_GEN2
  31           There are 3 internal PCI controllers available with a single
  32           built-in EHCI/OHCI host controller present on each one.
  33
  34 +config PCI_BCMA
  35 +       bool "BCMA PCIe2 host controller"
  36 +       depends on BCMA && OF
  37 +       help
  38 +         Say Y here if you want to support a simple generic PCI host
  39 +         controller, such as the one emulated by kvmtool.
  40 +
  41  endmenu
  42 --- a/drivers/pci/host/Makefile
  43 +++ b/drivers/pci/host/Makefile
  44 @@ -4,3 +4,4 @@ obj-$(CONFIG_PCI_IMX6) += pci-imx6.o
  45  obj-$(CONFIG_PCI_MVEBU) += pci-mvebu.o
  46  obj-$(CONFIG_PCI_TEGRA) += pci-tegra.o
  47  obj-$(CONFIG_PCI_RCAR_GEN2) += pci-rcar-gen2.o
  48 +obj-$(CONFIG_PCI_BCMA) += pcie2-bcma.o
  49 --- /dev/null
  50 +++ b/drivers/pci/host/pcie2-bcma.c
  51 @@ -0,0 +1,591 @@
  52 +/*
  53 + * Northstar PCI-Express driver
  54 + * Only supports Root-Complex (RC) mode
  55 + *
  56 + * Notes:
  57 + * PCI Domains are being used to identify the PCIe port 1:1.
  58 + *
  59 + * Only MEM access is supported, PAX does not support IO.
  60 + *
  61 + * TODO:
  62 + *     MSI interrupts,
  63 + *     DRAM > 128 MBytes (e.g. DMA zones)
  64 + */
  65 +
  66 +#include <linux/kernel.h>
  67 +#include <linux/module.h>
  68 +#include <linux/bug.h>
  69 +#include <linux/delay.h>
  70 +#include <linux/pci.h>
  71 +#include <linux/io.h>
  72 +#include <linux/ioport.h>
  73 +#include <linux/interrupt.h>
  74 +#include <linux/bcma/bcma.h>
  75 +
  76 +#define SI_ENUM_BASE           0x18000000      /* Enumeration space base */
  77 +
  78 +/*
  79 + * Register offset definitions
  80 + */
  81 +#define        SOC_PCIE_CONTROL        0x000   /* a.k.a. CLK_CONTROL reg */
  82 +#define        SOC_PCIE_PM_STATUS      0x008
  83 +#define        SOC_PCIE_PM_CONTROL     0x00c   /* in EP mode only ! */
  84 +
  85 +#define        SOC_PCIE_EXT_CFG_ADDR   0x120
  86 +#define        SOC_PCIE_EXT_CFG_DATA   0x124
  87 +#define        SOC_PCIE_CFG_ADDR       0x1f8
  88 +#define        SOC_PCIE_CFG_DATA       0x1fc
  89 +
  90 +#define        SOC_PCIE_SYS_RC_INTX_EN         0x330
  91 +#define        SOC_PCIE_SYS_RC_INTX_CSR        0x334
  92 +#define        SOC_PCIE_SYS_HOST_INTR_EN       0x344
  93 +#define        SOC_PCIE_SYS_HOST_INTR_CSR      0x348
  94 +
  95 +#define        SOC_PCIE_HDR_OFF        0x400   /* 256 bytes per function */
  96 +
  97 +/* 32-bit 4KB in-bound mapping windows for Function 0..3, n=0..7 */
  98 +#define        SOC_PCIE_SYS_IMAP0(f, n)        (0xc00 + ((f) << 9)((n) << 2))
  99 +/* 64-bit in-bound mapping windows for func 0..3 */
 100 +#define        SOC_PCIE_SYS_IMAP1(f)           (0xc80 + ((f) << 3))
 101 +#define        SOC_PCIE_SYS_IMAP2(f)           (0xcc0 + ((f) << 3))
 102 +/* 64-bit in-bound address range n=0..2 */
 103 +#define        SOC_PCIE_SYS_IARR(n)            (0xd00 + ((n) << 3))
 104 +/* 64-bit out-bound address filter n=0..2 */
 105 +#define        SOC_PCIE_SYS_OARR(n)            (0xd20 + ((n) << 3))
 106 +/* 64-bit out-bound mapping windows n=0..2 */
 107 +#define        SOC_PCIE_SYS_OMAP(n)            (0xd40 + ((n) << 3))
 108 +
 109 +#define BCM4360_D11AC_ID       0x43a0
 110 +#define BCM4360_D11AC2G_ID     0x43a1
 111 +#define BCM4360_D11AC5G_ID     0x43a2
 112 +#define BCM4352_D11AC_ID       0x43b1  /* 4352 802.11ac dualband device */
 113 +#define BCM4352_D11AC2G_ID     0x43b2  /* 4352 802.11ac 2.4G device */
 114 +#define BCM4352_D11AC5G_ID     0x43b3  /* 4352 802.11ac 5G device */
 115 +
 116 +static int bcma_pcie2_map_irq(const struct pci_dev *pdev, u8 slot, u8 pin)
 117 +{
 118 +       struct pci_sys_data *sys = pdev->sysdata;
 119 +       struct bcma_device *bdev = sys->private_data;
 120 +
 121 +       return bdev->irq;
 122 +}
 123 +
 124 +static u32 bcma_pcie2_cfg_base(struct bcma_device *bdev, int busno,
 125 +                              unsigned int devfn, int where)
 126 +{
 127 +       int slot = PCI_SLOT(devfn);
 128 +       int fn = PCI_FUNC(devfn);
 129 +       u32 addr_reg;
 130 +
 131 +       if (busno == 0) {
 132 +               if (slot >= 1)
 133 +                       return 0;
 134 +               bcma_write32(bdev, SOC_PCIE_EXT_CFG_ADDR, where & 0xffc);
 135 +               return SOC_PCIE_EXT_CFG_DATA;
 136 +       }
 137 +       if (fn > 1)
 138 +               return 0;
 139 +       addr_reg = (busno & 0xff) << 20 | (slot << 15) | (fn << 12) |
 140 +                  (where & 0xffc) | (1 & 0x3);
 141 +
 142 +       bcma_write32(bdev, SOC_PCIE_CFG_ADDR, addr_reg);
 143 +       return SOC_PCIE_CFG_DATA;
 144 +}
 145 +
 146 +static u32 bcma_pcie2_read_config(struct bcma_device *bdev, int busno,
 147 +                                 unsigned int devfn, int where, int size)
 148 +{
 149 +       u32 base;
 150 +       u32 data_reg;
 151 +       u32 mask;
 152 +       int shift;
 153 +
 154 +       base = bcma_pcie2_cfg_base(bdev, busno, devfn, where);
 155 +
 156 +       if (!base)
 157 +               return ~0UL;
 158 +
 159 +       data_reg = bcma_read32(bdev, base);
 160 +
 161 +       /* NS: CLASS field is R/O, and set to wrong 0x200 value */
 162 +       if (busno == 0 && devfn == 0) {
 163 +               /*
 164 +                * RC's class is 0x0280, but Linux PCI driver needs 0x604
 165 +                * for a PCIe bridge. So we must fixup the class code
 166 +                * to 0x604 here.
 167 +                */
 168 +               if ((where & 0xffc) == PCI_CLASS_REVISION) {
 169 +                       data_reg &= 0xff;
 170 +                       data_reg |= 0x604 << 16;
 171 +               }
 172 +       }
 173 +       /* HEADER_TYPE=00 indicates the port in EP mode */
 174 +
 175 +       if (size == 4)
 176 +               return data_reg;
 177 +
 178 +       mask = (1 << (size * 8)) - 1;
 179 +       shift = (where % 4) * 8;
 180 +       return (data_reg >> shift) & mask;
 181 +}
 182 +
 183 +static void bcma_pcie2_write_config(struct bcma_device *bdev, int busno,
 184 +                                   unsigned int devfn, int where, int size,
 185 +                                   u32 val)
 186 +{
 187 +       u32 base;
 188 +       u32 data_reg;
 189 +
 190 +       base = bcma_pcie2_cfg_base(bdev, busno, devfn, where);
 191 +
 192 +       if (!base)
 193 +               return;
 194 +
 195 +       if (size < 4) {
 196 +               u32 mask = (1 << (size * 8)) - 1;
 197 +               int shift = (where % 4) * 8;
 198 +
 199 +               data_reg = bcma_read32(bdev, base);
 200 +               data_reg &= ~(mask << shift);
 201 +               data_reg |= (val & mask) << shift;
 202 +       } else {
 203 +               data_reg = val;
 204 +       }
 205 +
 206 +       bcma_write32(bdev, base, data_reg);
 207 +}
 208 +
 209 +static u8 bcma_pcie2_read_config8(struct bcma_device *bdev, int busno,
 210 +                                 unsigned int devfn, int where)
 211 +{
 212 +       return bcma_pcie2_read_config(bdev, busno, devfn, where, 1);
 213 +}
 214 +
 215 +static u16 bcma_pcie2_read_config16(struct bcma_device *bdev, int busno,
 216 +                                   unsigned int devfn, int where)
 217 +{
 218 +       return bcma_pcie2_read_config(bdev, busno, devfn, where, 2);
 219 +}
 220 +
 221 +static u32 bcma_pcie2_read_config32(struct bcma_device *bdev, int busno,
 222 +                                   unsigned int devfn, int where)
 223 +{
 224 +       return bcma_pcie2_read_config(bdev, busno, devfn, where, 4);
 225 +}
 226 +
 227 +static void bcma_pcie2_write_config8(struct bcma_device *bdev, int busno,
 228 +                                    unsigned int devfn, int where, u8 val)
 229 +{
 230 +       return bcma_pcie2_write_config(bdev, busno, devfn, where, 1, val);
 231 +}
 232 +
 233 +static void bcma_pcie2_write_config16(struct bcma_device *bdev, int busno,
 234 +                                     unsigned int devfn, int where, u16 val)
 235 +{
 236 +       return bcma_pcie2_write_config(bdev, busno, devfn, where, 2, val);
 237 +}
 238 +
 239 +static void bcma_pcie2_write_config32(struct bcma_device *bdev, int busno,
 240 +                                     unsigned int devfn, int where, u32 val)
 241 +{
 242 +       return bcma_pcie2_write_config(bdev, busno, devfn, where, 4, val);
 243 +}
 244 +
 245 +static int bcma_pcie2_read_config_pci(struct pci_bus *bus, unsigned int devfn,
 246 +                                  int where, int size, u32 *val)
 247 +{
 248 +       struct pci_sys_data *sys = bus->sysdata;
 249 +       struct bcma_device *bdev = sys->private_data;
 250 +
 251 +       *val = bcma_pcie2_read_config(bdev, bus->number, devfn, where, size);
 252 +
 253 +       return PCIBIOS_SUCCESSFUL;
 254 +}
 255 +
 256 +static int bcma_pcie2_write_config_pci(struct pci_bus *bus, unsigned int devfn,
 257 +                                   int where, int size, u32 val)
 258 +{
 259 +       struct pci_sys_data *sys = bus->sysdata;
 260 +       struct bcma_device *bdev = sys->private_data;
 261 +
 262 +       bcma_pcie2_write_config(bdev, bus->number, devfn, where, size, val);
 263 +
 264 +       return PCIBIOS_SUCCESSFUL;
 265 +}
 266 +
 267 +/*
 268 + * Check link status, return 0 if link is up in RC mode,
 269 + * otherwise return non-zero
 270 + */
 271 +static int bcma_pcie2_check_link(struct bcma_device *bdev, u32 allow_gen2)
 272 +{
 273 +       u32 devfn = 0;
 274 +       u8 tmp8;
 275 +       u32 tmp32;
 276 +
 277 +       tmp32 = bcma_pcie2_read_config32(bdev, 0, devfn, 0xdc);
 278 +       tmp32 &= ~0xf;
 279 +       if (allow_gen2)
 280 +               tmp32 |= 2;
 281 +       else {
 282 +               /* force PCIE GEN1 */
 283 +               tmp32 |= 1;
 284 +       }
 285 +       bcma_pcie2_write_config32(bdev, 0, devfn, 0xdc, tmp32);
 286 +
 287 +       /* See if the port is in EP mode, indicated by header type 00 */
 288 +       tmp8 = bcma_pcie2_read_config8(bdev, 0, devfn, PCI_HEADER_TYPE);
 289 +       if (tmp8 != PCI_HEADER_TYPE_BRIDGE) {
 290 +               dev_info(&bdev->dev, "Port %d in End-Point mode - ignored\n",
 291 +                        bdev->core_unit);
 292 +               return -ENODEV;
 293 +       }
 294 +
 295 +       return 0;
 296 +}
 297 +
 298 +/*
 299 + * Initializte the PCIe controller
 300 + */
 301 +static void bcma_pcie2_hw_init(struct bcma_device *bdev)
 302 +{
 303 +       u32 devfn = 0;
 304 +       u32 tmp32;
 305 +       u16 tmp16;
 306 +
 307 +       /* Change MPS and MRRS to 512 */
 308 +       tmp16 = bcma_pcie2_read_config16(bdev, 0, devfn, 0x4d4);
 309 +       tmp16 &= ~7;
 310 +       tmp16 |= 2;
 311 +       bcma_pcie2_write_config16(bdev, 0, devfn, 0x4d4, tmp16);
 312 +
 313 +       tmp32 = bcma_pcie2_read_config32(bdev, 0, devfn, 0xb4);
 314 +       tmp32 &= ~((7 << 12) | (7 << 5));
 315 +       tmp32 |= (2 << 12) | (2 << 5);
 316 +       bcma_pcie2_write_config32(bdev, 0, devfn, 0xb4, tmp32);
 317 +
 318 +       /* Turn-on Root-Complex (RC) mode, from reset defailt of EP */
 319 +
 320 +       /* The mode is set by straps, can be overwritten via DMU
 321 +          register <cru_straps_control> bit 5, "1" means RC
 322 +        */
 323 +
 324 +       /* Send a downstream reset */
 325 +       bcma_write32(bdev, SOC_PCIE_CONTROL, 0x3);
 326 +       udelay(250);
 327 +       bcma_write32(bdev, SOC_PCIE_CONTROL, 0x1);
 328 +       mdelay(250);
 329 +
 330 +       /* TBD: take care of PM, check we're on */
 331 +}
 332 +
 333 +/*
 334 + * Setup the address translation
 335 + */
 336 +static void bcma_pcie2_map_init(struct bcma_device *bdev)
 337 +{
 338 +       unsigned size, i;
 339 +       u32 addr;
 340 +
 341 +       /*
 342 +        * NOTE:
 343 +        * All PCI-to-CPU address mapping are 1:1 for simplicity
 344 +        */
 345 +
 346 +       /* Outbound address translation setup */
 347 +       size = SZ_128M;
 348 +       addr = bdev->addr_s[0];
 349 +       BUG_ON(!addr);
 350 +       BUG_ON(addr & ((1 << 25) - 1)); /* 64MB alignment */
 351 +
 352 +       for (i = 0; i < 3; i++) {
 353 +               const unsigned win_size = SZ_64M;
 354 +               /* 64-bit LE regs, write low word, high is 0 at reset */
 355 +               bcma_write32(bdev, SOC_PCIE_SYS_OMAP(i), addr);
 356 +               bcma_write32(bdev, SOC_PCIE_SYS_OARR(i), addr|0x1);
 357 +               addr += win_size;
 358 +               if (size >= win_size)
 359 +                       size -= win_size;
 360 +               if (size == 0)
 361 +                       break;
 362 +       }
 363 +       WARN_ON(size > 0);
 364 +
 365 +       /*
 366 +        * Inbound address translation setup
 367 +        * Northstar only maps up to 128 MiB inbound, DRAM could be up to 1 GiB.
 368 +        *
 369 +        * For now allow access to entire DRAM, assuming it is less than 128MiB,
 370 +        * otherwise DMA bouncing mechanism may be required.
 371 +        * Also consider DMA mask to limit DMA physical address
 372 +        */
 373 +       size = SZ_128M;
 374 +       addr = PHYS_OFFSET;
 375 +
 376 +       size >>= 20;    /* In MB */
 377 +       size &= 0xff;   /* Size is an 8-bit field */
 378 +
 379 +       WARN_ON(size == 0);
 380 +       /* 64-bit LE regs, write low word, high is 0 at reset */
 381 +       bcma_write32(bdev, SOC_PCIE_SYS_IMAP1(0), addr | 0x1);
 382 +       bcma_write32(bdev, SOC_PCIE_SYS_IARR(1), addr | size);
 383 +
 384 +#ifdef CONFIG_SPARSEMEM
 385 +       addr = PHYS_OFFSET2;
 386 +       bcma_write32(bdev, SOC_PCIE_SYS_IMAP2(0), addr | 0x1);
 387 +       bcma_write32(bdev, SOC_PCIE_SYS_IARR(2), addr | size);
 388 +#endif
 389 +}
 390 +
 391 +/*
 392 + * Setup PCIE Host bridge
 393 + */
 394 +static void bcma_pcie2_bridge_init(struct bcma_device *bdev)
 395 +{
 396 +       u32 devfn = 0;
 397 +       u8 tmp8;
 398 +       u16 tmp16;
 399 +
 400 +       bcma_pcie2_write_config8(bdev, 0, devfn, PCI_PRIMARY_BUS, 0);
 401 +       bcma_pcie2_write_config8(bdev, 0, devfn, PCI_SECONDARY_BUS, 1);
 402 +       bcma_pcie2_write_config8(bdev, 0, devfn, PCI_SUBORDINATE_BUS, 4);
 403 +
 404 +       tmp8 = bcma_pcie2_read_config8(bdev, 0, devfn, PCI_PRIMARY_BUS);
 405 +       tmp8 = bcma_pcie2_read_config8(bdev, 0, devfn, PCI_SECONDARY_BUS);
 406 +       tmp8 = bcma_pcie2_read_config8(bdev, 0, devfn, PCI_SUBORDINATE_BUS);
 407 +
 408 +       /* MEM_BASE, MEM_LIM require 1MB alignment */
 409 +       BUG_ON((bdev->addr_s[0] >> 16) & 0xf);
 410 +       bcma_pcie2_write_config16(bdev, 0, devfn, PCI_MEMORY_BASE,
 411 +               bdev->addr_s[0] >> 16);
 412 +       BUG_ON(((bdev->addr_s[0] + SZ_128M) >> 16) & 0xf);
 413 +       bcma_pcie2_write_config16(bdev, 0, devfn, PCI_MEMORY_LIMIT,
 414 +               (bdev->addr_s[0] + SZ_128M) >> 16);
 415 +
 416 +       /* These registers are not supported on the NS */
 417 +       bcma_pcie2_write_config16(bdev, 0, devfn, PCI_IO_BASE_UPPER16, 0);
 418 +       bcma_pcie2_write_config16(bdev, 0, devfn, PCI_IO_LIMIT_UPPER16, 0);
 419 +
 420 +       /* Force class to that of a Bridge */
 421 +       bcma_pcie2_write_config16(bdev, 0, devfn, PCI_CLASS_DEVICE,
 422 +                                 PCI_CLASS_BRIDGE_PCI);
 423 +
 424 +       tmp16 = bcma_pcie2_read_config16(bdev, 0, devfn, PCI_CLASS_DEVICE);
 425 +       tmp16 = bcma_pcie2_read_config16(bdev, 0, devfn, PCI_MEMORY_BASE);
 426 +       tmp16 = bcma_pcie2_read_config16(bdev, 0, devfn, PCI_MEMORY_LIMIT);
 427 +}
 428 +
 429 +static int bcma_pcie2_allow_gen2_rc(struct bcma_device *bdev)
 430 +{
 431 +       u32 vendorid, devid, chipid, chiprev;
 432 +       u32 val, bar;
 433 +       void __iomem *base;
 434 +       int allow = 1;
 435 +
 436 +       /* Read PCI vendor/device ID's */
 437 +       bcma_write32(bdev, SOC_PCIE_CFG_ADDR, 0x0);
 438 +       val = bcma_read32(bdev, SOC_PCIE_CFG_DATA);
 439 +       vendorid = val & 0xffff;
 440 +       devid = val >> 16;
 441 +       if (vendorid == PCI_VENDOR_ID_BROADCOM &&
 442 +           (devid == BCMA_CHIP_ID_BCM4360 || devid == BCM4360_D11AC_ID ||
 443 +            devid == BCM4360_D11AC2G_ID || devid == BCM4360_D11AC5G_ID ||
 444 +            devid == BCM4352_D11AC_ID || devid == BCM4352_D11AC2G_ID ||
 445 +            devid == BCM4352_D11AC5G_ID)) {
 446 +               /* Config BAR0 */
 447 +               bar = bdev->addr_s[0];
 448 +               bcma_write32(bdev, SOC_PCIE_CFG_ADDR, 0x10);
 449 +               bcma_write32(bdev, SOC_PCIE_CFG_DATA, bar);
 450 +               /* Config BAR0 window to access chipc */
 451 +               bcma_write32(bdev, SOC_PCIE_CFG_ADDR, 0x80);
 452 +               bcma_write32(bdev, SOC_PCIE_CFG_DATA, SI_ENUM_BASE);
 453 +
 454 +               /* Enable memory resource */
 455 +               bcma_write32(bdev, SOC_PCIE_CFG_ADDR, 0x4);
 456 +               val = bcma_read32(bdev, SOC_PCIE_CFG_DATA);
 457 +               val |= PCI_COMMAND_MEMORY;
 458 +               bcma_write32(bdev, SOC_PCIE_CFG_DATA, val);
 459 +               /* Enable memory and bus master */
 460 +               bcma_write32(bdev, SOC_PCIE_HDR_OFF + 4, 0x6);
 461 +
 462 +               /* Read CHIP ID */
 463 +               base = ioremap(bar, 0x1000);
 464 +               val = __raw_readl(base);
 465 +               iounmap(base);
 466 +               chipid = val & 0xffff;
 467 +               chiprev = (val >> 16) & 0xf;
 468 +               if ((chipid == BCMA_CHIP_ID_BCM4360 ||
 469 +                    chipid == BCMA_CHIP_ID_BCM43460 ||
 470 +                    chipid == BCMA_CHIP_ID_BCM4352) && (chiprev < 3))
 471 +                       allow = 0;
 472 +       }
 473 +       return allow;
 474 +}
 475 +
 476 +static void bcma_pcie2_3rd_init(struct bcma_bus *bus)
 477 +{
 478 +       /* PCIE PLL block register (base 0x8000) */
 479 +       bcma_chipco_b_mii_write(&bus->drv_cc_b, 0x00000088, 0x57fe8000);
 480 +       /* Check PCIE PLL lock status */
 481 +       bcma_chipco_b_mii_write(&bus->drv_cc_b, 0x00000088, 0x67c60000);
 482 +}
 483 +
 484 +/* To improve PCIE phy jitter */
 485 +static void bcma_pcie2_improve_phy_jitter(struct bcma_bus *bus, int phyaddr)
 486 +{
 487 +       u32 val;
 488 +
 489 +       /* Change blkaddr */
 490 +       val = (1 << 30) | (1 << 28) | (phyaddr << 23) | (0x1f << 18) |
 491 +               (2 << 16) | (0x863 << 4);
 492 +       bcma_chipco_b_mii_write(&bus->drv_cc_b, 0x0000009a, val);
 493 +
 494 +       /* Write 0x0190 to 0x13 regaddr */
 495 +       val = (1 << 30) | (1 << 28) | (phyaddr << 23) | (0x13 << 18) |
 496 +               (2 << 16) | 0x0190;
 497 +       bcma_chipco_b_mii_write(&bus->drv_cc_b, 0x0000009a, val);
 498 +
 499 +       /* Write 0x0191 to 0x19 regaddr */
 500 +       val = (1 << 30) | (1 << 28) | (phyaddr << 23) | (0x19 << 18) |
 501 +               (2 << 16) | 0x0191;
 502 +       bcma_chipco_b_mii_write(&bus->drv_cc_b, 0x0000009a, val);
 503 +}
 504 +
 505 +static int bcma_pcie2_setup(int nr, struct pci_sys_data *sys)
 506 +{
 507 +       struct bcma_device *bdev = sys->private_data;
 508 +       struct bcma_bus *bus = bdev->bus;
 509 +       struct resource *res;
 510 +       struct bcma_device *arm_core;
 511 +       u32 cru_straps_ctrl;
 512 +       int allow_gen2, linkfail;
 513 +       int phyaddr;
 514 +
 515 +       if (bdev->core_unit == 2) {
 516 +               arm_core = bcma_find_core(bus, BCMA_CORE_ARMCA9);
 517 +               cru_straps_ctrl = bcma_read32(arm_core, 0x2a0);
 518 +
 519 +               /* 3rd PCIE is not selected */
 520 +               if (cru_straps_ctrl & 0x10)
 521 +                       return -ENODEV;
 522 +
 523 +               bcma_pcie2_3rd_init(bus);
 524 +               phyaddr = 0xf;
 525 +       } else {
 526 +               phyaddr = bdev->core_unit;
 527 +       }
 528 +       bcma_pcie2_improve_phy_jitter(bus, phyaddr);
 529 +
 530 +       /* create mem resource */
 531 +       res = devm_kzalloc(&bdev->dev, sizeof(*res), GFP_KERNEL);
 532 +       if (!res)
 533 +               return -EINVAL;
 534 +
 535 +       res->start = bdev->addr_s[0];
 536 +       res->end = res->start + SZ_128M - 1;
 537 +       res->name = "PCIe Configuration Space";
 538 +       res->flags = IORESOURCE_MEM;
 539 +
 540 +       pci_add_resource(&sys->resources, res);
 541 +
 542 +       /* This PCIe controller does not support IO Mem, so use a dummy one. */
 543 +       res = devm_kzalloc(&bdev->dev, sizeof(*res), GFP_KERNEL);
 544 +       if (!res)
 545 +               return -EINVAL;
 546 +
 547 +       res->start = bdev->addr_s[0];
 548 +       res->end = res->start + SZ_128M - 1;
 549 +       res->name = "PCIe Configuration Space";
 550 +       res->flags = IORESOURCE_IO;
 551 +
 552 +       pci_add_resource(&sys->resources, res);
 553 +
 554 +       for (allow_gen2 = 0; allow_gen2 <= 1; allow_gen2++) {
 555 +               bcma_pcie2_hw_init(bdev);
 556 +               bcma_pcie2_map_init(bdev);
 557 +
 558 +               /*
 559 +                * Skip inactive ports -
 560 +                * will need to change this for hot-plugging
 561 +                */
 562 +               linkfail = bcma_pcie2_check_link(bdev, allow_gen2);
 563 +               if (linkfail)
 564 +                       break;
 565 +
 566 +               bcma_pcie2_bridge_init(bdev);
 567 +
 568 +               if (allow_gen2 == 0) {
 569 +                       if (bcma_pcie2_allow_gen2_rc(bdev) == 0)
 570 +                               break;
 571 +                       dev_info(&bdev->dev, "switching to GEN2\n");
 572 +               }
 573 +       }
 574 +
 575 +       if (linkfail)
 576 +               return -1;
 577 +
 578 +       return 1;
 579 +}
 580 +
 581 +/*
 582 + * Methods for accessing configuration registers
 583 + */
 584 +static struct pci_ops bcma_pcie2_ops = {
 585 +       .read = bcma_pcie2_read_config_pci,
 586 +       .write = bcma_pcie2_write_config_pci,
 587 +};
 588 +
 589 +static int bcma_pcie2_probe(struct bcma_device *bdev)
 590 +{
 591 +       struct hw_pci hw;
 592 +
 593 +       dev_info(&bdev->dev, "scanning bus\n");
 594 +
 595 +       hw = (struct hw_pci) {
 596 +               .nr_controllers = 1,
 597 +               .domain         = bdev->core_unit,
 598 +               .private_data   = (void **)&bdev,
 599 +               .setup          = bcma_pcie2_setup,
 600 +               .map_irq        = bcma_pcie2_map_irq,
 601 +               .ops            = &bcma_pcie2_ops,
 602 +       };
 603 +
 604 +       /* Announce this port to ARM/PCI common code */
 605 +       pci_common_init_dev(&bdev->dev, &hw);
 606 +
 607 +       /* Setup virtual-wire interrupts */
 608 +       bcma_write32(bdev, SOC_PCIE_SYS_RC_INTX_EN, 0xf);
 609 +
 610 +       /* Enable memory and bus master */
 611 +       bcma_write32(bdev, SOC_PCIE_HDR_OFF + 4, 0x6);
 612 +
 613 +       return 0;
 614 +}
 615 +
 616 +static const struct bcma_device_id bcma_pcie2_table[] = {
 617 +       BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_NS_PCIEG2, BCMA_ANY_REV, BCMA_ANY_CLASS),
 618 +       BCMA_CORETABLE_END
 619 +};
 620 +MODULE_DEVICE_TABLE(bcma, bcma_pcie2_table);
 621 +
 622 +static struct bcma_driver bcma_pcie2_driver = {
 623 +       .name           = KBUILD_MODNAME,
 624 +       .id_table       = bcma_pcie2_table,
 625 +       .probe          = bcma_pcie2_probe,
 626 +};
 627 +
 628 +static int __init bcma_pcie2_init(void)
 629 +{
 630 +       return bcma_driver_register(&bcma_pcie2_driver);
 631 +}
 632 +module_init(bcma_pcie2_init);
 633 +
 634 +static void __exit bcma_pcie2_exit(void)
 635 +{
 636 +       bcma_driver_unregister(&bcma_pcie2_driver);
 637 +}
 638 +module_exit(bcma_pcie2_exit);
 639 +
 640 +MODULE_AUTHOR("Hauke Mehrtens");
 641 +MODULE_DESCRIPTION("PCIe Gen2 driver for BCMA");
 642 +MODULE_LICENSE("GPLv2");