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

   1 From cf067bf8bb993d6cfdc42d750ae241c43f88403f 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 1/2] PCI: BCM5301X: add PCIe2 driver for BCM5301X SoCs
   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 This controller is found on SoCs usually used in SOHO routers to
  10 connect the wifi cards to the SoC. All the of the BCM5301X SoCs I know
  11 of have 2 or 3 of these controllers in the SoC.
  12
  13 I had to use PCI domains otherwise the pci_create_root_bus() function
  14 in drivers/pci/probe.c would fail for the second controller being
  15 registered because pci_find_bus() would find the same PCIe bus again
  16 and assume it is already registered, which ends up in a kernel panic in
  17 pcibios_init_hw() in arch/arm/kernel/bios32.c
  18
  19 The ARM PCI code assumes that every controller has an I/O space and
  20 adds a dummy area if the driver does not specify one. This will work
  21 for the first controller, but when we register the second one this will
  22 result in an error. To prevent this problem we add an empty I/O space.
  23
  24 Currently I have problems with probing the devices on the bus, because
  25 pci_bus_add_devices() is called too early in pci_scan_root_bus() in
  26 drivers/pci/probe.c, before pci_bus_assign_resources() was called in
  27 pci_common_init_dev() in arch/arm/kernel/bios32.c. When the devices are
  28 added too early they do not have any resources and adding fails. I have
  29 to remove the call to pci_bus_add_devices() in pci_scan_root_bus() to
  30 make registration work, calling pci_bus_add_devices() later again does
  31 not fix this problem.
  32
  33 Signed-off-by: Hauke Mehrtens <hauke@hauke-m.de>
  34 ---
  35  arch/arm/mach-bcm/Kconfig            |   1 +
  36  drivers/pci/host/Kconfig             |   7 +
  37  drivers/pci/host/Makefile            |   1 +
  38  drivers/pci/host/pci-host-bcm5301x.c | 428 +++++++++++++++++++++++++++++++++++
  39  4 files changed, 437 insertions(+)
  40  create mode 100644 drivers/pci/host/pci-host-bcm5301x.c
  41
  42 --- a/arch/arm/mach-bcm/Kconfig
  43 +++ b/arch/arm/mach-bcm/Kconfig
  44 @@ -45,6 +45,7 @@ config ARCH_BCM_5301X
  45         select ARM_GLOBAL_TIMER
  46         select CLKSRC_ARM_GLOBAL_TIMER_SCHED_CLOCK
  47         select MIGHT_HAVE_PCI
  48 +       select PCI_DOMAINS if PCI
  49         help
  50           Support for Broadcom BCM470X and BCM5301X SoCs with ARM CPU cores.
  51
  52 --- a/drivers/pci/host/Kconfig
  53 +++ b/drivers/pci/host/Kconfig
  54 @@ -33,4 +33,11 @@ config PCI_RCAR_GEN2
  55           There are 3 internal PCI controllers available with a single
  56           built-in EHCI/OHCI host controller present on each one.
  57
  58 +config PCI_BCM5301X
  59 +       bool "BCM5301X PCIe2 host controller"
  60 +       depends on BCMA && OF && ARM && PCI_DOMAINS
  61 +       help
  62 +         Say Y here if you want to support the PCIe host controller found
  63 +         on Broadcom BCM5301X and BCM470X (Northstar) SoCs.
  64 +
  65  endmenu
  66 --- a/drivers/pci/host/Makefile
  67 +++ b/drivers/pci/host/Makefile
  68 @@ -4,3 +4,4 @@ obj-$(CONFIG_PCI_IMX6) += pci-imx6.o
  69  obj-$(CONFIG_PCI_MVEBU) += pci-mvebu.o
  70  obj-$(CONFIG_PCI_TEGRA) += pci-tegra.o
  71  obj-$(CONFIG_PCI_RCAR_GEN2) += pci-rcar-gen2.o
  72 +obj-$(CONFIG_PCI_BCM5301X) += pci-host-bcm5301x.o
  73 --- /dev/null
  74 +++ b/drivers/pci/host/pci-host-bcm5301x.c
  75 @@ -0,0 +1,459 @@
  76 +/*
  77 + * Northstar PCI-Express driver
  78 + * Only supports Root-Complex (RC) mode
  79 + *
  80 + * Notes:
  81 + * PCI Domains are being used to identify the PCIe port 1:1.
  82 + *
  83 + * Only MEM access is supported, PAX does not support IO.
  84 + *
  85 + * Copyright 2012-2014, Broadcom Corporation
  86 + * Copyright 2014, Hauke Mehrtens <hauke@hauke-m.de>
  87 + *
  88 + * Licensed under the GNU/GPL. See COPYING for details.
  89 + */
  90 +
  91 +#include <linux/kernel.h>
  92 +#include <linux/module.h>
  93 +#include <linux/delay.h>
  94 +#include <linux/pci.h>
  95 +#include <linux/io.h>
  96 +#include <linux/ioport.h>
  97 +#include <linux/bcma/bcma.h>
  98 +#include <linux/bcma/bcma_driver_pcie2.h>
  99 +
 100 +#define        SOC_PCIE_HDR_OFF        0x400   /* 256 bytes per function */
 101 +
 102 +#define PCI_LINK_STATUS_CTRL_2_OFFSET 0xDC
 103 +#define PCI_TARGET_LINK_SPEED_MASK    0xF
 104 +#define PCI_TARGET_LINK_SPEED_GEN2    0x2
 105 +#define PCI_TARGET_LINK_SPEED_GEN1    0x1
 106 +
 107 +static int bcma_pcie2_map_irq(const struct pci_dev *pdev, u8 slot, u8 pin)
 108 +{
 109 +       struct pci_sys_data *sys = pdev->sysdata;
 110 +       struct bcma_device *bdev = sys->private_data;
 111 +
 112 +       return bcma_core_irq(bdev, 5);
 113 +}
 114 +
 115 +static u32 bcma_pcie2_cfg_base(struct bcma_device *bdev, int busno,
 116 +                              unsigned int devfn, int where)
 117 +{
 118 +       int slot = PCI_SLOT(devfn);
 119 +       int fn = PCI_FUNC(devfn);
 120 +       u32 addr_reg;
 121 +
 122 +       if (busno == 0) {
 123 +               if (slot >= 1)
 124 +                       return 0;
 125 +               bcma_write32(bdev, BCMA_CORE_PCIE2_CONFIGINDADDR,
 126 +                            where & 0xffc);
 127 +               return BCMA_CORE_PCIE2_CONFIGINDDATA;
 128 +       }
 129 +       if (fn > 1)
 130 +               return 0;
 131 +       addr_reg = (busno & 0xff) << 20 | (slot << 15) | (fn << 12) |
 132 +                  (where & 0xffc) | (1 & 0x3);
 133 +
 134 +       bcma_write32(bdev, BCMA_CORE_PCIE2_CFG_ADDR, addr_reg);
 135 +       return BCMA_CORE_PCIE2_CFG_DATA;
 136 +}
 137 +
 138 +static u32 bcma_pcie2_read_config(struct bcma_device *bdev, int busno,
 139 +                                 unsigned int devfn, int where, int size)
 140 +{
 141 +       u32 base;
 142 +       u32 data_reg;
 143 +       u32 mask;
 144 +       int shift;
 145 +
 146 +       base = bcma_pcie2_cfg_base(bdev, busno, devfn, where);
 147 +
 148 +       if (!base)
 149 +               return ~0UL;
 150 +
 151 +       data_reg = bcma_read32(bdev, base);
 152 +
 153 +       if (size == 4)
 154 +               return data_reg;
 155 +
 156 +       mask = (1 << (size * 8)) - 1;
 157 +       shift = (where % 4) * 8;
 158 +       return (data_reg >> shift) & mask;
 159 +}
 160 +
 161 +static void bcma_pcie2_write_config(struct bcma_device *bdev, int busno,
 162 +                                   unsigned int devfn, int where, int size,
 163 +                                   u32 val)
 164 +{
 165 +       u32 base;
 166 +       u32 data_reg;
 167 +
 168 +       base = bcma_pcie2_cfg_base(bdev, busno, devfn, where);
 169 +
 170 +       if (!base)
 171 +               return;
 172 +
 173 +       if (size < 4) {
 174 +               u32 mask = (1 << (size * 8)) - 1;
 175 +               int shift = (where % 4) * 8;
 176 +
 177 +               data_reg = bcma_read32(bdev, base);
 178 +               data_reg &= ~(mask << shift);
 179 +               data_reg |= (val & mask) << shift;
 180 +       } else {
 181 +               data_reg = val;
 182 +       }
 183 +
 184 +       bcma_write32(bdev, base, data_reg);
 185 +}
 186 +
 187 +static int bcma_pcie2_read_config_pci(struct pci_bus *bus, unsigned int devfn,
 188 +                                  int where, int size, u32 *val)
 189 +{
 190 +       struct pci_sys_data *sys = bus->sysdata;
 191 +       struct bcma_device *bdev = sys->private_data;
 192 +
 193 +       *val = bcma_pcie2_read_config(bdev, bus->number, devfn, where, size);
 194 +
 195 +       return PCIBIOS_SUCCESSFUL;
 196 +}
 197 +
 198 +static int bcma_pcie2_write_config_pci(struct pci_bus *bus, unsigned int devfn,
 199 +                                   int where, int size, u32 val)
 200 +{
 201 +       struct pci_sys_data *sys = bus->sysdata;
 202 +       struct bcma_device *bdev = sys->private_data;
 203 +
 204 +       bcma_pcie2_write_config(bdev, bus->number, devfn, where, size, val);
 205 +
 206 +       return PCIBIOS_SUCCESSFUL;
 207 +}
 208 +
 209 +/*
 210 + * Methods for accessing configuration registers
 211 + */
 212 +static struct pci_ops bcma_pcie2_ops = {
 213 +       .read = bcma_pcie2_read_config_pci,
 214 +       .write = bcma_pcie2_write_config_pci,
 215 +};
 216 +
 217 +/* NS: CLASS field is R/O, and set to wrong 0x200 value */
 218 +static void bcma_pcie2_fixup_class(struct pci_dev *dev)
 219 +{
 220 +       dev->class = PCI_CLASS_BRIDGE_PCI << 8;
 221 +}
 222 +DECLARE_PCI_FIXUP_EARLY(PCI_VENDOR_ID_BROADCOM, 0x8011, bcma_pcie2_fixup_class);
 223 +
 224 +/*
 225 + * Check link status, return 0 if link is up in RC mode,
 226 + * otherwise return non-zero
 227 + */
 228 +static int bcma_pcie2_check_link(struct bcma_device *bdev, struct pci_sys_data *sys)
 229 +{
 230 +       u32 tmp32;
 231 +       u16 tmp16;
 232 +       u16 pos;
 233 +       u8 nlw;
 234 +       /*
 235 +        * Setup callback (bcma_pcie2_setup) is called in pcibios_init_hw before
 236 +        * creating bus root, so we don't have it here yet. On the other hand
 237 +        * we really want to use pci_bus_find_capability helper to check NLW.
 238 +        * Let's fake simple pci_bus just to query for capabilities.
 239 +        */
 240 +       struct pci_bus bus = {
 241 +               .number = 0,
 242 +               .ops = &bcma_pcie2_ops,
 243 +               .sysdata = sys,
 244 +       };
 245 +
 246 +       tmp32 = bcma_read32(bdev, BCMA_CORE_PCIE2_LINK_STATUS);
 247 +       dev_dbg(&bdev->dev, "link status: 0x%08x\n", tmp32);
 248 +
 249 +       tmp32 = bcma_read32(bdev, BCMA_CORE_PCIE2_STRAP_STATUS);
 250 +       dev_dbg(&bdev->dev, "strap status: 0x%08x\n", tmp32);
 251 +
 252 +       /* check link status to see if link is active */
 253 +       pos = pci_bus_find_capability(&bus, 0, PCI_CAP_ID_EXP);
 254 +       pci_bus_read_config_word(&bus, 0, pos + PCI_EXP_LNKSTA, &tmp16);
 255 +       nlw = (tmp16 & PCI_EXP_LNKSTA_NLW) >> PCI_EXP_LNKSTA_NLW_SHIFT;
 256 +
 257 +       if (nlw == 0) {
 258 +               /* try GEN 1 link speed */
 259 +               tmp32 = bcma_pcie2_read_config(bdev, 0, 0,
 260 +                                       PCI_LINK_STATUS_CTRL_2_OFFSET, 4);
 261 +               if ((tmp32 & PCI_TARGET_LINK_SPEED_MASK) ==
 262 +                               PCI_TARGET_LINK_SPEED_GEN2) {
 263 +                       tmp32 &= ~PCI_TARGET_LINK_SPEED_MASK;
 264 +                       tmp32 |= PCI_TARGET_LINK_SPEED_GEN1;
 265 +                       bcma_pcie2_write_config(bdev, 0, 0,
 266 +                                       PCI_LINK_STATUS_CTRL_2_OFFSET, 4, tmp32);
 267 +                       tmp32 = bcma_pcie2_read_config(bdev, 0, 0,
 268 +                                       PCI_LINK_STATUS_CTRL_2_OFFSET, 4);
 269 +                       msleep(100);
 270 +
 271 +                       pos = pci_bus_find_capability(&bus, 0, PCI_CAP_ID_EXP);
 272 +                       pci_bus_read_config_word(&bus, 0, pos + PCI_EXP_LNKSTA,
 273 +                                       &tmp16);
 274 +                       nlw = (tmp16 & PCI_EXP_LNKSTA_NLW) >>
 275 +                               PCI_EXP_LNKSTA_NLW_SHIFT;
 276 +               }
 277 +       }
 278 +
 279 +       dev_info(&bdev->dev, "link: %s\n", nlw ? "UP" : "DOWN");
 280 +       return nlw ? 0 : -ENODEV;
 281 +}
 282 +
 283 +/*
 284 + * Initializte the PCIe controller
 285 + */
 286 +static void bcma_pcie2_hw_init(struct bcma_device *bdev)
 287 +{
 288 +       u32 tmp32;
 289 +       u16 tmp16;
 290 +
 291 +       /* Change MPS and MRRS to 512 */
 292 +       tmp16 = bcma_pcie2_read_config(bdev, 0, 0, 0x4d4, 2);
 293 +       tmp16 &= ~7;
 294 +       tmp16 |= 2;
 295 +       bcma_pcie2_write_config(bdev, 0, 0, 0x4d4, 2, tmp16);
 296 +
 297 +       tmp32 = bcma_pcie2_read_config(bdev, 0, 0, 0xb4, 4);
 298 +       tmp32 &= ~((7 << 12) | (7 << 5));
 299 +       tmp32 |= (2 << 12) | (2 << 5);
 300 +       bcma_pcie2_write_config(bdev, 0, 0, 0xb4, 4, tmp32);
 301 +
 302 +       /*
 303 +        * Turn-on Root-Complex (RC) mode, from reset default of EP
 304 +        * The mode is set by straps, can be overwritten via DMU
 305 +        * register <cru_straps_control> bit 5, "1" means RC
 306 +        */
 307 +
 308 +       /* Send a downstream reset */
 309 +       bcma_write32(bdev, BCMA_CORE_PCIE2_CLK_CONTROL,
 310 +                    PCIE2_CLKC_RST_OE | PCIE2_CLKC_RST);
 311 +       usleep_range(250, 400);
 312 +       bcma_write32(bdev, BCMA_CORE_PCIE2_CLK_CONTROL, PCIE2_CLKC_RST_OE);
 313 +       msleep(250);
 314 +
 315 +       /* TBD: take care of PM, check we're on */
 316 +}
 317 +
 318 +/*
 319 + * Setup the address translation
 320 + *
 321 + * NOTE: All PCI-to-CPU address mapping are 1:1 for simplicity
 322 + */
 323 +static int bcma_pcie2_map_init(struct bcma_device *bdev, u32 addr)
 324 +{
 325 +       /* 64MB alignment */
 326 +       if (!addr || (addr & (SZ_64M - 1)))
 327 +               return -EINVAL;
 328 +
 329 +       bcma_write32(bdev, BCMA_CORE_PCIE2_OMAP0_LOWER, addr);
 330 +       bcma_write32(bdev, BCMA_CORE_PCIE2_OARR0, addr | 0x01);
 331 +
 332 +       bcma_write32(bdev, BCMA_CORE_PCIE2_OMAP1_LOWER, addr + SZ_64M);
 333 +       bcma_write32(bdev, BCMA_CORE_PCIE2_OARR1, (addr + SZ_64M) | 0x01);
 334 +
 335 +       /*
 336 +        * Inbound address translation setup
 337 +        * Northstar only maps up to 128 MiB inbound, DRAM could be up to 1 GiB.
 338 +        *
 339 +        * For now allow access to entire DRAM, assuming it is less than 128MiB,
 340 +        * otherwise DMA bouncing mechanism may be required.
 341 +        * Also consider DMA mask to limit DMA physical address
 342 +        */
 343 +       /* 64-bit LE regs, write low word, high is 0 at reset */
 344 +       bcma_write32(bdev, BCMA_CORE_PCIE2_FUNC0_IMAP1, PHYS_OFFSET | 0x1);
 345 +       bcma_write32(bdev, BCMA_CORE_PCIE2_IARR1_LOWER,
 346 +                          PHYS_OFFSET | ((SZ_128M >> 20) & 0xff));
 347 +       return 0;
 348 +}
 349 +
 350 +/*
 351 + * Setup PCIE Host bridge
 352 + */
 353 +static int bcma_pcie2_bridge_init(struct bcma_device *bdev, u32 addr, u32 size)
 354 +{
 355 +       bcma_pcie2_write_config(bdev, 0, 0, PCI_PRIMARY_BUS, 1, 0);
 356 +       bcma_pcie2_write_config(bdev, 0, 0, PCI_SECONDARY_BUS, 1, 1);
 357 +       bcma_pcie2_write_config(bdev, 0, 0, PCI_SUBORDINATE_BUS, 1, 4);
 358 +
 359 +       bcma_pcie2_read_config(bdev, 0, 0, PCI_PRIMARY_BUS, 1);
 360 +       bcma_pcie2_read_config(bdev, 0, 0, PCI_SECONDARY_BUS, 1);
 361 +       bcma_pcie2_read_config(bdev, 0, 0, PCI_SUBORDINATE_BUS, 1);
 362 +
 363 +       /* MEM_BASE, MEM_LIM require 1MB alignment */
 364 +       if (((addr >> 16) & 0xf) || (((addr + size) >> 16) & 0xf))
 365 +               return -EINVAL;
 366 +
 367 +       bcma_pcie2_write_config(bdev, 0, 0, PCI_MEMORY_BASE, 2, addr >> 16);
 368 +       bcma_pcie2_write_config(bdev, 0, 0, PCI_MEMORY_LIMIT, 2,
 369 +                               (addr + size) >> 16);
 370 +
 371 +       /* These registers are not supported on the NS */
 372 +       bcma_pcie2_write_config(bdev, 0, 0, PCI_IO_BASE_UPPER16, 2, 0);
 373 +       bcma_pcie2_write_config(bdev, 0, 0, PCI_IO_LIMIT_UPPER16, 2, 0);
 374 +
 375 +       /* Force class to that of a Bridge */
 376 +       bcma_pcie2_write_config(bdev, 0, 0, PCI_CLASS_DEVICE, 2,
 377 +                               PCI_CLASS_BRIDGE_PCI);
 378 +
 379 +       bcma_pcie2_read_config(bdev, 0, 0, PCI_CLASS_DEVICE, 2);
 380 +       bcma_pcie2_read_config(bdev, 0, 0, PCI_MEMORY_BASE, 2);
 381 +       bcma_pcie2_read_config(bdev, 0, 0, PCI_MEMORY_LIMIT, 2);
 382 +       return 0;
 383 +}
 384 +
 385 +static void bcma_pcie2_3rd_init(struct bcma_bus *bus)
 386 +{
 387 +       /* PCIE PLL block register (base 0x8000) */
 388 +       bcma_chipco_b_mii_write(&bus->drv_cc_b, 0x00000088, 0x57fe8000);
 389 +       /* Check PCIE PLL lock status */
 390 +       bcma_chipco_b_mii_write(&bus->drv_cc_b, 0x00000088, 0x67c60000);
 391 +}
 392 +
 393 +/* To improve PCIE phy jitter */
 394 +static void bcma_pcie2_improve_phy_jitter(struct bcma_bus *bus, int phyaddr)
 395 +{
 396 +       u32 val;
 397 +
 398 +       /* Change blkaddr */
 399 +       val = (1 << 30) | (1 << 28) | (phyaddr << 23) | (0x1f << 18) |
 400 +               (2 << 16) | (0x863 << 4);
 401 +       bcma_chipco_b_mii_write(&bus->drv_cc_b, 0x0000009a, val);
 402 +
 403 +       /* Write 0x0190 to 0x13 regaddr */
 404 +       val = (1 << 30) | (1 << 28) | (phyaddr << 23) | (0x13 << 18) |
 405 +               (2 << 16) | 0x0190;
 406 +       bcma_chipco_b_mii_write(&bus->drv_cc_b, 0x0000009a, val);
 407 +
 408 +       /* Write 0x0191 to 0x19 regaddr */
 409 +       val = (1 << 30) | (1 << 28) | (phyaddr << 23) | (0x19 << 18) |
 410 +               (2 << 16) | 0x0191;
 411 +       bcma_chipco_b_mii_write(&bus->drv_cc_b, 0x0000009a, val);
 412 +}
 413 +
 414 +static int bcma_pcie2_setup(int nr, struct pci_sys_data *sys)
 415 +{
 416 +       struct bcma_device *bdev = sys->private_data;
 417 +       struct bcma_bus *bus = bdev->bus;
 418 +       struct resource *res;
 419 +       struct bcma_device *arm_core;
 420 +       u32 cru_straps_ctrl;
 421 +       int ret;
 422 +       int phyaddr;
 423 +
 424 +       if (bdev->core_unit == 2) {
 425 +               arm_core = bcma_find_core(bus, BCMA_CORE_ARMCA9);
 426 +               cru_straps_ctrl = bcma_read32(arm_core, 0x2a0);
 427 +
 428 +               /* 3rd PCIE is not selected */
 429 +               if (cru_straps_ctrl & 0x10)
 430 +                       return -ENODEV;
 431 +
 432 +               bcma_pcie2_3rd_init(bus);
 433 +               phyaddr = 0xf;
 434 +       } else {
 435 +               phyaddr = bdev->core_unit;
 436 +       }
 437 +       bcma_pcie2_improve_phy_jitter(bus, phyaddr);
 438 +
 439 +       /* create mem resource */
 440 +       res = devm_kzalloc(&bdev->dev, sizeof(*res), GFP_KERNEL);
 441 +       if (!res)
 442 +               return -EINVAL;
 443 +
 444 +       res->start = bdev->addr_s[0];
 445 +       res->end = bdev->addr_s[0] + SZ_128M -1;
 446 +       res->name = "PCIe dummy IO space";
 447 +       res->flags = IORESOURCE_MEM;
 448 +
 449 +       pci_add_resource(&sys->resources, res);
 450 +
 451 +       /* This PCIe controller does not support IO Mem, so use a dummy one. */
 452 +       res = devm_kzalloc(&bdev->dev, sizeof(*res), GFP_KERNEL);
 453 +       if (!res)
 454 +               return -EINVAL;
 455 +
 456 +       res->start = 0;
 457 +       res->end = 0;
 458 +       res->name = "PCIe dummy IO space";
 459 +       res->flags = IORESOURCE_IO;
 460 +
 461 +       pci_add_resource(&sys->resources, res);
 462 +
 463 +       bcma_pcie2_hw_init(bdev);
 464 +       ret = bcma_pcie2_map_init(bdev, bdev->addr_s[0]);
 465 +       if (ret)
 466 +               return ret;
 467 +
 468 +       /*
 469 +        * Skip inactive ports -
 470 +        * will need to change this for hot-plugging
 471 +        */
 472 +       ret = bcma_pcie2_check_link(bdev, sys);
 473 +       if (ret)
 474 +               return ret;
 475 +
 476 +       ret = bcma_pcie2_bridge_init(bdev, bdev->addr_s[0], SZ_128M);
 477 +       if (ret)
 478 +               return ret;
 479 +
 480 +       return 1;
 481 +}
 482 +
 483 +static int bcma_pcie2_probe(struct bcma_device *bdev)
 484 +{
 485 +       struct hw_pci hw = {
 486 +               .nr_controllers = 1,
 487 +               .domain         = bdev->core_unit,
 488 +               .private_data   = (void **)&bdev,
 489 +               .setup          = bcma_pcie2_setup,
 490 +               .map_irq        = bcma_pcie2_map_irq,
 491 +               .ops            = &bcma_pcie2_ops,
 492 +       };
 493 +
 494 +       dev_info(&bdev->dev, "initializing PCIe controller\n");
 495 +
 496 +       /* Announce this port to ARM/PCI common code */
 497 +       pci_common_init_dev(&bdev->dev, &hw);
 498 +
 499 +       /* Setup virtual-wire interrupts */
 500 +       bcma_write32(bdev, BCMA_CORE_PCIE2_SYS_RC_INTX_EN, 0xf);
 501 +
 502 +       /* Enable memory and bus master */
 503 +       bcma_write32(bdev, SOC_PCIE_HDR_OFF + 4, 0x6);
 504 +
 505 +       return 0;
 506 +}
 507 +
 508 +static const struct bcma_device_id bcma_pcie2_table[] = {
 509 +       BCMA_CORE(BCMA_MANUF_BCM, BCMA_CORE_NS_PCIEG2, BCMA_ANY_REV, BCMA_ANY_CLASS),
 510 +       BCMA_CORETABLE_END
 511 +};
 512 +MODULE_DEVICE_TABLE(bcma, bcma_pcie2_table);
 513 +
 514 +static struct bcma_driver bcma_pcie2_driver = {
 515 +       .name           = KBUILD_MODNAME,
 516 +       .id_table       = bcma_pcie2_table,
 517 +       .probe          = bcma_pcie2_probe,
 518 +};
 519 +
 520 +static int __init bcma_pcie2_init(void)
 521 +{
 522 +       return bcma_driver_register(&bcma_pcie2_driver);
 523 +}
 524 +module_init(bcma_pcie2_init);
 525 +
 526 +static void __exit bcma_pcie2_exit(void)
 527 +{
 528 +       bcma_driver_unregister(&bcma_pcie2_driver);
 529 +}
 530 +module_exit(bcma_pcie2_exit);
 531 +
 532 +MODULE_AUTHOR("Hauke Mehrtens");
 533 +MODULE_DESCRIPTION("BCM5301X PCIe host controller");
 534 +MODULE_LICENSE("GPLv2");