| 1 | |
| 2 | * Broadcom specific AMBA
|
| 3 | * PCI Core in hostmode
|
| 4 | *
|
| 5 | * Copyright 2005 - 2011, Broadcom Corporation
|
| 6 | * Copyright 2006, 2007, Michael Buesch <[email protected]>
|
| 7 | * Copyright 2011, 2012, Hauke Mehrtens <[email protected]>
|
| 8 | *
|
| 9 | * Licensed under the GNU/GPL. See COPYING for details.
|
| 10 |
|
| 11 |
|
| 12 | #include "bcma_private.h"
|
| 13 | #include <linux/pci.h>
|
| 14 | #include <linux/slab.h>
|
| 15 | #include <linux/export.h>
|
| 16 | #include <linux/bcma/bcma.h>
|
| 17 | #include <asm/paccess.h>
|
| 18 |
|
| 19 | |
| 20 | * Returns nonzero on a bus exception.
|
| 21 | * This is MIPS specific
|
| 22 | #define mips_busprobe32(val, addr) get_dbe((val), ((u32 *)(addr)))
|
| 23 |
|
| 24 |
|
| 25 | #define BCMA_PCI_SLOT_MAX 16
|
| 26 | #define PCI_CONFIG_SPACE_SIZE 256
|
| 27 |
|
| 28 | bool bcma_core_pci_is_in_hostmode(struct bcma_drv_pci *pc)
|
| 29 | {
|
| 30 | struct bcma_bus *bus = pc->core->bus;
|
| 31 | u16 chipid_top;
|
| 32 | u32 tmp;
|
| 33 |
|
| 34 | chipid_top = (bus->chipinfo.id & 0xFF00);
|
| 35 | if (chipid_top != 0x4700 &&
|
| 36 | chipid_top != 0x5300)
|
| 37 | return false;
|
| 38 |
|
| 39 | bcma_core_enable(pc->core, 0);
|
| 40 |
|
| 41 | return !mips_busprobe32(tmp, pc->core->io_addr);
|
| 42 | }
|
| 43 |
|
| 44 | static u32 bcma_pcie_read_config(struct bcma_drv_pci *pc, u32 address)
|
| 45 | {
|
| 46 | pcicore_write32(pc, BCMA_CORE_PCI_CONFIG_ADDR, address);
|
| 47 | pcicore_read32(pc, BCMA_CORE_PCI_CONFIG_ADDR);
|
| 48 | return pcicore_read32(pc, BCMA_CORE_PCI_CONFIG_DATA);
|
| 49 | }
|
| 50 |
|
| 51 | static void bcma_pcie_write_config(struct bcma_drv_pci *pc, u32 address,
|
| 52 | u32 data)
|
| 53 | {
|
| 54 | pcicore_write32(pc, BCMA_CORE_PCI_CONFIG_ADDR, address);
|
| 55 | pcicore_read32(pc, BCMA_CORE_PCI_CONFIG_ADDR);
|
| 56 | pcicore_write32(pc, BCMA_CORE_PCI_CONFIG_DATA, data);
|
| 57 | }
|
| 58 |
|
| 59 | static u32 bcma_get_cfgspace_addr(struct bcma_drv_pci *pc, unsigned int dev,
|
| 60 | unsigned int func, unsigned int off)
|
| 61 | {
|
| 62 | u32 addr = 0;
|
| 63 |
|
| 64 | |
| 65 | * one external pcie device is present).
|
| 66 |
|
| 67 | if (dev >= 2 || !(bcma_pcie_read(pc, BCMA_CORE_PCI_DLLP_LSREG)
|
| 68 | & BCMA_CORE_PCI_DLLP_LSREG_LINKUP))
|
| 69 | goto out;
|
| 70 |
|
| 71 |
|
| 72 |
|
| 73 | pcicore_write32(pc, BCMA_CORE_PCI_SBTOPCI1, BCMA_CORE_PCI_SBTOPCI_CFG0);
|
| 74 |
|
| 75 | addr = pc->host_controller->host_cfg_addr;
|
| 76 | addr |= (dev << BCMA_CORE_PCI_CFG_SLOT_SHIFT);
|
| 77 | addr |= (func << BCMA_CORE_PCI_CFG_FUN_SHIFT);
|
| 78 | addr |= (off & ~3);
|
| 79 |
|
| 80 | out:
|
| 81 | return addr;
|
| 82 | }
|
| 83 |
|
| 84 | static int bcma_extpci_read_config(struct bcma_drv_pci *pc, unsigned int dev,
|
| 85 | unsigned int func, unsigned int off,
|
| 86 | void *buf, int len)
|
| 87 | {
|
| 88 | int err = -EINVAL;
|
| 89 | u32 addr, val;
|
| 90 | void __iomem *mmio = 0;
|
| 91 |
|
| 92 | WARN_ON(!pc->hostmode);
|
| 93 | if (unlikely(len != 1 && len != 2 && len != 4))
|
| 94 | goto out;
|
| 95 | if (dev == 0) {
|
| 96 |
|
| 97 | if (func > 1)
|
| 98 | goto out;
|
| 99 |
|
| 100 | |
| 101 | * requires indirect access.
|
| 102 |
|
| 103 | if (off >= PCI_CONFIG_SPACE_SIZE) {
|
| 104 | addr = (func << 12);
|
| 105 | addr |= (off & 0x0FFC);
|
| 106 | val = bcma_pcie_read_config(pc, addr);
|
| 107 | } else {
|
| 108 | addr = BCMA_CORE_PCI_PCICFG0;
|
| 109 | addr |= (func << 8);
|
| 110 | addr |= (off & 0xFC);
|
| 111 | val = pcicore_read32(pc, addr);
|
| 112 | }
|
| 113 | } else {
|
| 114 | addr = bcma_get_cfgspace_addr(pc, dev, func, off);
|
| 115 | if (unlikely(!addr))
|
| 116 | goto out;
|
| 117 | err = -ENOMEM;
|
| 118 | mmio = ioremap(addr, sizeof(val));
|
| 119 | if (!mmio)
|
| 120 | goto out;
|
| 121 |
|
| 122 | if (mips_busprobe32(val, mmio)) {
|
| 123 | val = 0xFFFFFFFF;
|
| 124 | goto unmap;
|
| 125 | }
|
| 126 | }
|
| 127 | val >>= (8 * (off & 3));
|
| 128 |
|
| 129 | switch (len) {
|
| 130 | case 1:
|
| 131 | *((u8 *)buf) = (u8)val;
|
| 132 | break;
|
| 133 | case 2:
|
| 134 | *((u16 *)buf) = (u16)val;
|
| 135 | break;
|
| 136 | case 4:
|
| 137 | *((u32 *)buf) = (u32)val;
|
| 138 | break;
|
| 139 | }
|
| 140 | err = 0;
|
| 141 | unmap:
|
| 142 | if (mmio)
|
| 143 | iounmap(mmio);
|
| 144 | out:
|
| 145 | return err;
|
| 146 | }
|
| 147 |
|
| 148 | static int bcma_extpci_write_config(struct bcma_drv_pci *pc, unsigned int dev,
|
| 149 | unsigned int func, unsigned int off,
|
| 150 | const void *buf, int len)
|
| 151 | {
|
| 152 | int err = -EINVAL;
|
| 153 | u32 addr, val;
|
| 154 | void __iomem *mmio = 0;
|
| 155 | u16 chipid = pc->core->bus->chipinfo.id;
|
| 156 |
|
| 157 | WARN_ON(!pc->hostmode);
|
| 158 | if (unlikely(len != 1 && len != 2 && len != 4))
|
| 159 | goto out;
|
| 160 | if (dev == 0) {
|
| 161 |
|
| 162 | if (func > 1)
|
| 163 | goto out;
|
| 164 |
|
| 165 | |
| 166 | * requires indirect access.
|
| 167 |
|
| 168 | if (off >= PCI_CONFIG_SPACE_SIZE) {
|
| 169 | addr = (func << 12);
|
| 170 | addr |= (off & 0x0FFC);
|
| 171 | val = bcma_pcie_read_config(pc, addr);
|
| 172 | } else {
|
| 173 | addr = BCMA_CORE_PCI_PCICFG0;
|
| 174 | addr |= (func << 8);
|
| 175 | addr |= (off & 0xFC);
|
| 176 | val = pcicore_read32(pc, addr);
|
| 177 | }
|
| 178 | } else {
|
| 179 | addr = bcma_get_cfgspace_addr(pc, dev, func, off);
|
| 180 | if (unlikely(!addr))
|
| 181 | goto out;
|
| 182 | err = -ENOMEM;
|
| 183 | mmio = ioremap(addr, sizeof(val));
|
| 184 | if (!mmio)
|
| 185 | goto out;
|
| 186 |
|
| 187 | if (mips_busprobe32(val, mmio)) {
|
| 188 | val = 0xFFFFFFFF;
|
| 189 | goto unmap;
|
| 190 | }
|
| 191 | }
|
| 192 |
|
| 193 | switch (len) {
|
| 194 | case 1:
|
| 195 | val &= ~(0xFF << (8 * (off & 3)));
|
| 196 | val |= *((const u8 *)buf) << (8 * (off & 3));
|
| 197 | break;
|
| 198 | case 2:
|
| 199 | val &= ~(0xFFFF << (8 * (off & 3)));
|
| 200 | val |= *((const u16 *)buf) << (8 * (off & 3));
|
| 201 | break;
|
| 202 | case 4:
|
| 203 | val = *((const u32 *)buf);
|
| 204 | break;
|
| 205 | }
|
| 206 | if (dev == 0) {
|
| 207 | |
| 208 | * requires indirect access.
|
| 209 |
|
| 210 | if (off >= PCI_CONFIG_SPACE_SIZE)
|
| 211 | bcma_pcie_write_config(pc, addr, val);
|
| 212 | else
|
| 213 | pcicore_write32(pc, addr, val);
|
| 214 | } else {
|
| 215 | writel(val, mmio);
|
| 216 |
|
| 217 | if (chipid == BCMA_CHIP_ID_BCM4716 ||
|
| 218 | chipid == BCMA_CHIP_ID_BCM4748)
|
| 219 | readl(mmio);
|
| 220 | }
|
| 221 |
|
| 222 | err = 0;
|
| 223 | unmap:
|
| 224 | if (mmio)
|
| 225 | iounmap(mmio);
|
| 226 | out:
|
| 227 | return err;
|
| 228 | }
|
| 229 |
|
| 230 | static int bcma_core_pci_hostmode_read_config(struct pci_bus *bus,
|
| 231 | unsigned int devfn,
|
| 232 | int reg, int size, u32 *val)
|
| 233 | {
|
| 234 | unsigned long flags;
|
| 235 | int err;
|
| 236 | struct bcma_drv_pci *pc;
|
| 237 | struct bcma_drv_pci_host *pc_host;
|
| 238 |
|
| 239 | pc_host = container_of(bus->ops, struct bcma_drv_pci_host, pci_ops);
|
| 240 | pc = pc_host->pdev;
|
| 241 |
|
| 242 | spin_lock_irqsave(&pc_host->cfgspace_lock, flags);
|
| 243 | err = bcma_extpci_read_config(pc, PCI_SLOT(devfn),
|
| 244 | PCI_FUNC(devfn), reg, val, size);
|
| 245 | spin_unlock_irqrestore(&pc_host->cfgspace_lock, flags);
|
| 246 |
|
| 247 | return err ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL;
|
| 248 | }
|
| 249 |
|
| 250 | static int bcma_core_pci_hostmode_write_config(struct pci_bus *bus,
|
| 251 | unsigned int devfn,
|
| 252 | int reg, int size, u32 val)
|
| 253 | {
|
| 254 | unsigned long flags;
|
| 255 | int err;
|
| 256 | struct bcma_drv_pci *pc;
|
| 257 | struct bcma_drv_pci_host *pc_host;
|
| 258 |
|
| 259 | pc_host = container_of(bus->ops, struct bcma_drv_pci_host, pci_ops);
|
| 260 | pc = pc_host->pdev;
|
| 261 |
|
| 262 | spin_lock_irqsave(&pc_host->cfgspace_lock, flags);
|
| 263 | err = bcma_extpci_write_config(pc, PCI_SLOT(devfn),
|
| 264 | PCI_FUNC(devfn), reg, &val, size);
|
| 265 | spin_unlock_irqrestore(&pc_host->cfgspace_lock, flags);
|
| 266 |
|
| 267 | return err ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL;
|
| 268 | }
|
| 269 |
|
| 270 |
|
| 271 | static u8 bcma_find_pci_capability(struct bcma_drv_pci *pc, unsigned int dev,
|
| 272 | unsigned int func, u8 req_cap_id,
|
| 273 | unsigned char *buf, u32 *buflen)
|
| 274 | {
|
| 275 | u8 cap_id;
|
| 276 | u8 cap_ptr = 0;
|
| 277 | u32 bufsize;
|
| 278 | u8 byte_val;
|
| 279 |
|
| 280 |
|
| 281 | bcma_extpci_read_config(pc, dev, func, PCI_HEADER_TYPE, &byte_val,
|
| 282 | sizeof(u8));
|
| 283 | if ((byte_val & PCI_HEADER_TYPE_MASK) != PCI_HEADER_TYPE_NORMAL)
|
| 284 | return cap_ptr;
|
| 285 |
|
| 286 |
|
| 287 | bcma_extpci_read_config(pc, dev, func, PCI_STATUS, &byte_val,
|
| 288 | sizeof(u8));
|
| 289 | if (!(byte_val & PCI_STATUS_CAP_LIST))
|
| 290 | return cap_ptr;
|
| 291 |
|
| 292 |
|
| 293 | bcma_extpci_read_config(pc, dev, func, PCI_CAPABILITY_LIST, &cap_ptr,
|
| 294 | sizeof(u8));
|
| 295 | if (cap_ptr == 0x00)
|
| 296 | return cap_ptr;
|
| 297 |
|
| 298 | |
| 299 | * exists
|
| 300 | bcma_extpci_read_config(pc, dev, func, cap_ptr, &cap_id, sizeof(u8));
|
| 301 | while (cap_id != req_cap_id) {
|
| 302 | bcma_extpci_read_config(pc, dev, func, cap_ptr + 1, &cap_ptr,
|
| 303 | sizeof(u8));
|
| 304 | if (cap_ptr == 0x00)
|
| 305 | return cap_ptr;
|
| 306 | bcma_extpci_read_config(pc, dev, func, cap_ptr, &cap_id,
|
| 307 | sizeof(u8));
|
| 308 | }
|
| 309 |
|
| 310 |
|
| 311 | if ((buf != NULL) && (buflen != NULL)) {
|
| 312 | u8 cap_data;
|
| 313 |
|
| 314 | bufsize = *buflen;
|
| 315 | if (!bufsize)
|
| 316 | return cap_ptr;
|
| 317 |
|
| 318 | *buflen = 0;
|
| 319 |
|
| 320 |
|
| 321 | cap_data = cap_ptr + 2;
|
| 322 | if ((bufsize + cap_data) > PCI_CONFIG_SPACE_SIZE)
|
| 323 | bufsize = PCI_CONFIG_SPACE_SIZE - cap_data;
|
| 324 | *buflen = bufsize;
|
| 325 | while (bufsize--) {
|
| 326 | bcma_extpci_read_config(pc, dev, func, cap_data, buf,
|
| 327 | sizeof(u8));
|
| 328 | cap_data++;
|
| 329 | buf++;
|
| 330 | }
|
| 331 | }
|
| 332 |
|
| 333 | return cap_ptr;
|
| 334 | }
|
| 335 |
|
| 336 | |
| 337 | * Retry Status (RRS) Completion Status to software then
|
| 338 | * enable the feature.
|
| 339 |
|
| 340 | static void bcma_core_pci_enable_crs(struct bcma_drv_pci *pc)
|
| 341 | {
|
| 342 | struct bcma_bus *bus = pc->core->bus;
|
| 343 | u8 cap_ptr, root_ctrl, root_cap, dev;
|
| 344 | u16 val16;
|
| 345 | int i;
|
| 346 |
|
| 347 | cap_ptr = bcma_find_pci_capability(pc, 0, 0, PCI_CAP_ID_EXP, NULL,
|
| 348 | NULL);
|
| 349 | root_cap = cap_ptr + PCI_EXP_RTCAP;
|
| 350 | bcma_extpci_read_config(pc, 0, 0, root_cap, &val16, sizeof(u16));
|
| 351 | if (val16 & BCMA_CORE_PCI_RC_RRS_VISIBILITY) {
|
| 352 |
|
| 353 | root_ctrl = cap_ptr + PCI_EXP_RTCTL;
|
| 354 | val16 = PCI_EXP_RTCTL_RRS_SVE;
|
| 355 | bcma_extpci_read_config(pc, 0, 0, root_ctrl, &val16,
|
| 356 | sizeof(u16));
|
| 357 |
|
| 358 | |
| 359 | * field of the device function's config space header after
|
| 360 | * 100 ms wait time from the end of Reset. If the device is
|
| 361 | * not done with its internal initialization, it must at
|
| 362 | * least return a completion TLP, with a completion status
|
| 363 | * of "Configuration Request Retry Status (RRS)". The root
|
| 364 | * complex must complete the request to the host by returning
|
| 365 | * a read-data value of 0001h for the Vendor ID field and
|
| 366 | * all 1s for any additional bytes included in the request.
|
| 367 | * Poll using the config reads for max wait time of 1 sec or
|
| 368 | * until we receive the successful completion status. Repeat
|
| 369 | * the procedure for all the devices.
|
| 370 |
|
| 371 | for (dev = 1; dev < BCMA_PCI_SLOT_MAX; dev++) {
|
| 372 | for (i = 0; i < 100000; i++) {
|
| 373 | bcma_extpci_read_config(pc, dev, 0,
|
| 374 | PCI_VENDOR_ID, &val16,
|
| 375 | sizeof(val16));
|
| 376 | if (val16 != 0x1)
|
| 377 | break;
|
| 378 | udelay(10);
|
| 379 | }
|
| 380 | if (val16 == 0x1)
|
| 381 | bcma_err(bus, "PCI: Broken device in slot %d\n",
|
| 382 | dev);
|
| 383 | }
|
| 384 | }
|
| 385 | }
|
| 386 |
|
| 387 | void bcma_core_pci_hostmode_init(struct bcma_drv_pci *pc)
|
| 388 | {
|
| 389 | struct bcma_bus *bus = pc->core->bus;
|
| 390 | struct bcma_drv_pci_host *pc_host;
|
| 391 | u32 tmp;
|
| 392 | u32 pci_membase_1G;
|
| 393 | unsigned long io_map_base;
|
| 394 |
|
| 395 | bcma_info(bus, "PCIEcore in host mode found\n");
|
| 396 |
|
| 397 | if (bus->sprom.boardflags_lo & BCMA_CORE_PCI_BFL_NOPCI) {
|
| 398 | bcma_info(bus, "This PCIE core is disabled and not working\n");
|
| 399 | return;
|
| 400 | }
|
| 401 |
|
| 402 | pc_host = kzalloc_obj(*pc_host);
|
| 403 | if (!pc_host) {
|
| 404 | bcma_err(bus, "can not allocate memory");
|
| 405 | return;
|
| 406 | }
|
| 407 |
|
| 408 | spin_lock_init(&pc_host->cfgspace_lock);
|
| 409 |
|
| 410 | pc->host_controller = pc_host;
|
| 411 | pc_host->pci_controller.io_resource = &pc_host->io_resource;
|
| 412 | pc_host->pci_controller.mem_resource = &pc_host->mem_resource;
|
| 413 | pc_host->pci_controller.pci_ops = &pc_host->pci_ops;
|
| 414 | pc_host->pdev = pc;
|
| 415 |
|
| 416 | pci_membase_1G = BCMA_SOC_PCI_DMA;
|
| 417 | pc_host->host_cfg_addr = BCMA_SOC_PCI_CFG;
|
| 418 |
|
| 419 | pc_host->pci_ops.read = bcma_core_pci_hostmode_read_config;
|
| 420 | pc_host->pci_ops.write = bcma_core_pci_hostmode_write_config;
|
| 421 |
|
| 422 | pc_host->mem_resource.name = "BCMA PCIcore external memory";
|
| 423 | pc_host->mem_resource.start = BCMA_SOC_PCI_DMA;
|
| 424 | pc_host->mem_resource.end = BCMA_SOC_PCI_DMA + BCMA_SOC_PCI_DMA_SZ - 1;
|
| 425 | pc_host->mem_resource.flags = IORESOURCE_MEM | IORESOURCE_PCI_FIXED;
|
| 426 |
|
| 427 | pc_host->io_resource.name = "BCMA PCIcore external I/O";
|
| 428 | pc_host->io_resource.start = 0x100;
|
| 429 | pc_host->io_resource.end = 0x7FF;
|
| 430 | pc_host->io_resource.flags = IORESOURCE_IO | IORESOURCE_PCI_FIXED;
|
| 431 |
|
| 432 |
|
| 433 | usleep_range(3000, 5000);
|
| 434 | pcicore_write32(pc, BCMA_CORE_PCI_CTL, BCMA_CORE_PCI_CTL_RST_OE);
|
| 435 | msleep(50);
|
| 436 | pcicore_write32(pc, BCMA_CORE_PCI_CTL, BCMA_CORE_PCI_CTL_RST |
|
| 437 | BCMA_CORE_PCI_CTL_RST_OE);
|
| 438 |
|
| 439 | |
| 440 | * sbtopcie0 to access the device registers. We
|
| 441 | * can't use address match 2 (1 GB window) region
|
| 442 | * as mips can't generate 64-bit address on the
|
| 443 | * backplane.
|
| 444 |
|
| 445 | if (bus->chipinfo.id == BCMA_CHIP_ID_BCM4716 ||
|
| 446 | bus->chipinfo.id == BCMA_CHIP_ID_BCM4748) {
|
| 447 | pc_host->mem_resource.start = BCMA_SOC_PCI_MEM;
|
| 448 | pc_host->mem_resource.end = BCMA_SOC_PCI_MEM +
|
| 449 | BCMA_SOC_PCI_MEM_SZ - 1;
|
| 450 | pcicore_write32(pc, BCMA_CORE_PCI_SBTOPCI0,
|
| 451 | BCMA_CORE_PCI_SBTOPCI_MEM | BCMA_SOC_PCI_MEM);
|
| 452 | } else if (bus->chipinfo.id == BCMA_CHIP_ID_BCM4706) {
|
| 453 | tmp = BCMA_CORE_PCI_SBTOPCI_MEM;
|
| 454 | tmp |= BCMA_CORE_PCI_SBTOPCI_PREF;
|
| 455 | tmp |= BCMA_CORE_PCI_SBTOPCI_BURST;
|
| 456 | if (pc->core->core_unit == 0) {
|
| 457 | pc_host->mem_resource.start = BCMA_SOC_PCI_MEM;
|
| 458 | pc_host->mem_resource.end = BCMA_SOC_PCI_MEM +
|
| 459 | BCMA_SOC_PCI_MEM_SZ - 1;
|
| 460 | pc_host->io_resource.start = 0x100;
|
| 461 | pc_host->io_resource.end = 0x47F;
|
| 462 | pci_membase_1G = BCMA_SOC_PCIE_DMA_H32;
|
| 463 | pcicore_write32(pc, BCMA_CORE_PCI_SBTOPCI0,
|
| 464 | tmp | BCMA_SOC_PCI_MEM);
|
| 465 | } else if (pc->core->core_unit == 1) {
|
| 466 | pc_host->mem_resource.start = BCMA_SOC_PCI1_MEM;
|
| 467 | pc_host->mem_resource.end = BCMA_SOC_PCI1_MEM +
|
| 468 | BCMA_SOC_PCI_MEM_SZ - 1;
|
| 469 | pc_host->io_resource.start = 0x480;
|
| 470 | pc_host->io_resource.end = 0x7FF;
|
| 471 | pci_membase_1G = BCMA_SOC_PCIE1_DMA_H32;
|
| 472 | pc_host->host_cfg_addr = BCMA_SOC_PCI1_CFG;
|
| 473 | pcicore_write32(pc, BCMA_CORE_PCI_SBTOPCI0,
|
| 474 | tmp | BCMA_SOC_PCI1_MEM);
|
| 475 | }
|
| 476 | } else
|
| 477 | pcicore_write32(pc, BCMA_CORE_PCI_SBTOPCI0,
|
| 478 | BCMA_CORE_PCI_SBTOPCI_IO);
|
| 479 |
|
| 480 |
|
| 481 | pcicore_write32(pc, BCMA_CORE_PCI_SBTOPCI1, BCMA_CORE_PCI_SBTOPCI_CFG0);
|
| 482 |
|
| 483 |
|
| 484 | pcicore_write32(pc, BCMA_CORE_PCI_SBTOPCI2,
|
| 485 | BCMA_CORE_PCI_SBTOPCI_MEM | pci_membase_1G);
|
| 486 |
|
| 487 |
|
| 488 | |
| 489 | * at least 100 ms from the end of a reset (cold/warm/hot)
|
| 490 | * before issuing configuration requests to PCI Express
|
| 491 | * devices.
|
| 492 |
|
| 493 | msleep(100);
|
| 494 |
|
| 495 | bcma_core_pci_enable_crs(pc);
|
| 496 |
|
| 497 | if (bus->chipinfo.id == BCMA_CHIP_ID_BCM4706 ||
|
| 498 | bus->chipinfo.id == BCMA_CHIP_ID_BCM4716) {
|
| 499 | u16 val16;
|
| 500 | bcma_extpci_read_config(pc, 0, 0, BCMA_CORE_PCI_CFG_DEVCTRL,
|
| 501 | &val16, sizeof(val16));
|
| 502 | val16 |= (2 << 5);
|
| 503 | val16 |= (2 << 12);
|
| 504 | bcma_extpci_write_config(pc, 0, 0, BCMA_CORE_PCI_CFG_DEVCTRL,
|
| 505 | &val16, sizeof(val16));
|
| 506 | }
|
| 507 |
|
| 508 |
|
| 509 | tmp = PCI_COMMAND_MASTER | PCI_COMMAND_MEMORY;
|
| 510 | bcma_extpci_write_config(pc, 0, 0, PCI_COMMAND, &tmp, sizeof(tmp));
|
| 511 |
|
| 512 |
|
| 513 | pcicore_write32(pc, BCMA_CORE_PCI_IMASK, BCMA_CORE_PCI_IMASK_INTA);
|
| 514 |
|
| 515 | |
| 516 | * The following needs change, if we want to port hostmode
|
| 517 | * to non-MIPS platform.
|
| 518 | io_map_base = (unsigned long)ioremap(pc_host->mem_resource.start,
|
| 519 | resource_size(&pc_host->mem_resource));
|
| 520 | pc_host->pci_controller.io_map_base = io_map_base;
|
| 521 | set_io_port_base(pc_host->pci_controller.io_map_base);
|
| 522 | |
| 523 | * values. Not waiting at this point causes crashes of the machine.
|
| 524 | usleep_range(10000, 15000);
|
| 525 | register_pci_controller(&pc_host->pci_controller);
|
| 526 | return;
|
| 527 | }
|
| 528 |
|
| 529 |
|
| 530 | static void bcma_core_pci_fixup_pcibridge(struct pci_dev *dev)
|
| 531 | {
|
| 532 | if (dev->bus->ops->read != bcma_core_pci_hostmode_read_config) {
|
| 533 |
|
| 534 | return;
|
| 535 | }
|
| 536 | if (PCI_SLOT(dev->devfn) != 0)
|
| 537 | return;
|
| 538 |
|
| 539 | pr_info("PCI: Fixing up bridge %s\n", pci_name(dev));
|
| 540 |
|
| 541 |
|
| 542 | pci_set_master(dev);
|
| 543 | if (pcibios_enable_device(dev, ~0) < 0) {
|
| 544 | pr_err("PCI: BCMA bridge enable failed\n");
|
| 545 | return;
|
| 546 | }
|
| 547 |
|
| 548 |
|
| 549 | pci_write_config_dword(dev, BCMA_PCI_BAR1_CONTROL, 3);
|
| 550 | }
|
| 551 | DECLARE_PCI_FIXUP_EARLY(PCI_ANY_ID, PCI_ANY_ID, bcma_core_pci_fixup_pcibridge);
|
| 552 |
|
| 553 |
|
| 554 | static void bcma_core_pci_fixup_addresses(struct pci_dev *dev)
|
| 555 | {
|
| 556 | struct resource *res;
|
| 557 | int pos, err;
|
| 558 |
|
| 559 | if (dev->bus->ops->read != bcma_core_pci_hostmode_read_config) {
|
| 560 |
|
| 561 | return;
|
| 562 | }
|
| 563 | if (PCI_SLOT(dev->devfn) == 0)
|
| 564 | return;
|
| 565 |
|
| 566 | pr_info("PCI: Fixing up addresses %s\n", pci_name(dev));
|
| 567 |
|
| 568 | for (pos = 0; pos < 6; pos++) {
|
| 569 | res = &dev->resource[pos];
|
| 570 | if (res->flags & (IORESOURCE_IO | IORESOURCE_MEM)) {
|
| 571 | err = pci_assign_resource(dev, pos);
|
| 572 | if (err)
|
| 573 | pr_err("PCI: Problem fixing up the addresses on %s\n",
|
| 574 | pci_name(dev));
|
| 575 | }
|
| 576 | }
|
| 577 | }
|
| 578 | DECLARE_PCI_FIXUP_HEADER(PCI_ANY_ID, PCI_ANY_ID, bcma_core_pci_fixup_addresses);
|
| 579 |
|
| 580 | |
| 581 | * We must first check if the device is a device on the PCI-core bridge.
|
| 582 | int bcma_core_pci_plat_dev_init(struct pci_dev *dev)
|
| 583 | {
|
| 584 | struct bcma_drv_pci_host *pc_host;
|
| 585 | int readrq;
|
| 586 |
|
| 587 | if (dev->bus->ops->read != bcma_core_pci_hostmode_read_config) {
|
| 588 |
|
| 589 | return -ENODEV;
|
| 590 | }
|
| 591 | pc_host = container_of(dev->bus->ops, struct bcma_drv_pci_host,
|
| 592 | pci_ops);
|
| 593 |
|
| 594 | pr_info("PCI: Fixing up device %s\n", pci_name(dev));
|
| 595 |
|
| 596 |
|
| 597 | dev->irq = bcma_core_irq(pc_host->pdev->core, 0);
|
| 598 | pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
|
| 599 |
|
| 600 | readrq = pcie_get_readrq(dev);
|
| 601 | if (readrq > 128) {
|
| 602 | pr_info("change PCIe max read request size from %i to 128\n", readrq);
|
| 603 | pcie_set_readrq(dev, 128);
|
| 604 | }
|
| 605 | return 0;
|
| 606 | }
|
| 607 | EXPORT_SYMBOL(bcma_core_pci_plat_dev_init);
|
| 608 |
|
| 609 |
|
| 610 | int bcma_core_pci_pcibios_map_irq(const struct pci_dev *dev)
|
| 611 | {
|
| 612 | struct bcma_drv_pci_host *pc_host;
|
| 613 |
|
| 614 | if (dev->bus->ops->read != bcma_core_pci_hostmode_read_config) {
|
| 615 |
|
| 616 | return -ENODEV;
|
| 617 | }
|
| 618 |
|
| 619 | pc_host = container_of(dev->bus->ops, struct bcma_drv_pci_host,
|
| 620 | pci_ops);
|
| 621 | return bcma_core_irq(pc_host->pdev->core, 0);
|
| 622 | }
|
| 623 | EXPORT_SYMBOL(bcma_core_pci_pcibios_map_irq);
|