target/linux/generic/patches-3.1/025-bcma_backport.patch

   1 --- a/drivers/bcma/Kconfig
   2 +++ b/drivers/bcma/Kconfig
   3 @@ -33,6 +33,19 @@ config BCMA_DRIVER_PCI_HOSTMODE
   4         help
   5           PCI core hostmode operation (external PCI bus).
   6
   7 +config BCMA_HOST_SOC
   8 +       bool
   9 +       depends on BCMA_DRIVER_MIPS
  10 +
  11 +config BCMA_DRIVER_MIPS
  12 +       bool "BCMA Broadcom MIPS core driver"
  13 +       depends on BCMA && MIPS
  14 +       help
  15 +         Driver for the Broadcom MIPS core attached to Broadcom specific
  16 +         Advanced Microcontroller Bus.
  17 +
  18 +         If unsure, say N
  19 +
  20  config BCMA_DEBUG
  21         bool "BCMA debugging"
  22         depends on BCMA
  23 --- a/drivers/bcma/Makefile
  24 +++ b/drivers/bcma/Makefile
  25 @@ -2,7 +2,9 @@ bcma-y                                  += main.o scan.o core.o sprom
  26  bcma-y                                 += driver_chipcommon.o driver_chipcommon_pmu.o
  27  bcma-y                                 += driver_pci.o
  28  bcma-$(CONFIG_BCMA_DRIVER_PCI_HOSTMODE)        += driver_pci_host.o
  29 +bcma-$(CONFIG_BCMA_DRIVER_MIPS)                += driver_mips.o
  30  bcma-$(CONFIG_BCMA_HOST_PCI)           += host_pci.o
  31 +bcma-$(CONFIG_BCMA_HOST_SOC)           += host_soc.o
  32  obj-$(CONFIG_BCMA)                     += bcma.o
  33
  34  ccflags-$(CONFIG_BCMA_DEBUG)           := -DDEBUG
  35 --- a/drivers/bcma/bcma_private.h
  36 +++ b/drivers/bcma/bcma_private.h
  37 @@ -15,13 +15,32 @@ struct bcma_bus;
  38  /* main.c */
  39  int bcma_bus_register(struct bcma_bus *bus);
  40  void bcma_bus_unregister(struct bcma_bus *bus);
  41 +int __init bcma_bus_early_register(struct bcma_bus *bus,
  42 +                                  struct bcma_device *core_cc,
  43 +                                  struct bcma_device *core_mips);
  44 +#ifdef CONFIG_PM
  45 +int bcma_bus_resume(struct bcma_bus *bus);
  46 +#endif
  47
  48  /* scan.c */
  49  int bcma_bus_scan(struct bcma_bus *bus);
  50 +int __init bcma_bus_scan_early(struct bcma_bus *bus,
  51 +                              struct bcma_device_id *match,
  52 +                              struct bcma_device *core);
  53 +void bcma_init_bus(struct bcma_bus *bus);
  54
  55  /* sprom.c */
  56  int bcma_sprom_get(struct bcma_bus *bus);
  57
  58 +/* driver_chipcommon.c */
  59 +#ifdef CONFIG_BCMA_DRIVER_MIPS
  60 +void bcma_chipco_serial_init(struct bcma_drv_cc *cc);
  61 +#endif /* CONFIG_BCMA_DRIVER_MIPS */
  62 +
  63 +/* driver_chipcommon_pmu.c */
  64 +u32 bcma_pmu_alp_clock(struct bcma_drv_cc *cc);
  65 +u32 bcma_pmu_get_clockcpu(struct bcma_drv_cc *cc);
  66 +
  67  #ifdef CONFIG_BCMA_HOST_PCI
  68  /* host_pci.c */
  69  extern int __init bcma_host_pci_init(void);
  70 --- a/drivers/bcma/core.c
  71 +++ b/drivers/bcma/core.c
  72 @@ -110,6 +110,8 @@ EXPORT_SYMBOL_GPL(bcma_core_pll_ctl);
  73  u32 bcma_core_dma_translation(struct bcma_device *core)
  74  {
  75         switch (core->bus->hosttype) {
  76 +       case BCMA_HOSTTYPE_SOC:
  77 +               return 0;
  78         case BCMA_HOSTTYPE_PCI:
  79                 if (bcma_aread32(core, BCMA_IOST) & BCMA_IOST_DMA64)
  80                         return BCMA_DMA_TRANSLATION_DMA64_CMT;
  81 --- a/drivers/bcma/driver_chipcommon.c
  82 +++ b/drivers/bcma/driver_chipcommon.c
  83 @@ -26,6 +26,9 @@ void bcma_core_chipcommon_init(struct bc
  84         u32 leddc_on = 10;
  85         u32 leddc_off = 90;
  86
  87 +       if (cc->setup_done)
  88 +               return;
  89 +
  90         if (cc->core->id.rev >= 11)
  91                 cc->status = bcma_cc_read32(cc, BCMA_CC_CHIPSTAT);
  92         cc->capabilities = bcma_cc_read32(cc, BCMA_CC_CAP);
  93 @@ -52,6 +55,8 @@ void bcma_core_chipcommon_init(struct bc
  94                         ((leddc_on << BCMA_CC_GPIOTIMER_ONTIME_SHIFT) |
  95                          (leddc_off << BCMA_CC_GPIOTIMER_OFFTIME_SHIFT)));
  96         }
  97 +
  98 +       cc->setup_done = true;
  99  }
 100
 101  /* Set chip watchdog reset timer to fire in 'ticks' backplane cycles */
 102 @@ -101,3 +106,51 @@ u32 bcma_chipco_gpio_polarity(struct bcm
 103  {
 104         return bcma_cc_write32_masked(cc, BCMA_CC_GPIOPOL, mask, value);
 105  }
 106 +
 107 +#ifdef CONFIG_BCMA_DRIVER_MIPS
 108 +void bcma_chipco_serial_init(struct bcma_drv_cc *cc)
 109 +{
 110 +       unsigned int irq;
 111 +       u32 baud_base;
 112 +       u32 i;
 113 +       unsigned int ccrev = cc->core->id.rev;
 114 +       struct bcma_serial_port *ports = cc->serial_ports;
 115 +
 116 +       if (ccrev >= 11 && ccrev != 15) {
 117 +               /* Fixed ALP clock */
 118 +               baud_base = bcma_pmu_alp_clock(cc);
 119 +               if (ccrev >= 21) {
 120 +                       /* Turn off UART clock before switching clocksource. */
 121 +                       bcma_cc_write32(cc, BCMA_CC_CORECTL,
 122 +                                      bcma_cc_read32(cc, BCMA_CC_CORECTL)
 123 +                                      & ~BCMA_CC_CORECTL_UARTCLKEN);
 124 +               }
 125 +               /* Set the override bit so we don't divide it */
 126 +               bcma_cc_write32(cc, BCMA_CC_CORECTL,
 127 +                              bcma_cc_read32(cc, BCMA_CC_CORECTL)
 128 +                              | BCMA_CC_CORECTL_UARTCLK0);
 129 +               if (ccrev >= 21) {
 130 +                       /* Re-enable the UART clock. */
 131 +                       bcma_cc_write32(cc, BCMA_CC_CORECTL,
 132 +                                      bcma_cc_read32(cc, BCMA_CC_CORECTL)
 133 +                                      | BCMA_CC_CORECTL_UARTCLKEN);
 134 +               }
 135 +       } else {
 136 +               pr_err("serial not supported on this device ccrev: 0x%x\n",
 137 +                      ccrev);
 138 +               return;
 139 +       }
 140 +
 141 +       irq = bcma_core_mips_irq(cc->core);
 142 +
 143 +       /* Determine the registers of the UARTs */
 144 +       cc->nr_serial_ports = (cc->capabilities & BCMA_CC_CAP_NRUART);
 145 +       for (i = 0; i < cc->nr_serial_ports; i++) {
 146 +               ports[i].regs = cc->core->io_addr + BCMA_CC_UART0_DATA +
 147 +                               (i * 256);
 148 +               ports[i].irq = irq;
 149 +               ports[i].baud_base = baud_base;
 150 +               ports[i].reg_shift = 0;
 151 +       }
 152 +}
 153 +#endif /* CONFIG_BCMA_DRIVER_MIPS */
 154 --- a/drivers/bcma/driver_chipcommon_pmu.c
 155 +++ b/drivers/bcma/driver_chipcommon_pmu.c
 156 @@ -11,20 +11,47 @@
 157  #include "bcma_private.h"
 158  #include <linux/bcma/bcma.h>
 159
 160 -static void bcma_chipco_chipctl_maskset(struct bcma_drv_cc *cc,
 161 -                                       u32 offset, u32 mask, u32 set)
 162 +static u32 bcma_chipco_pll_read(struct bcma_drv_cc *cc, u32 offset)
 163  {
 164 -       u32 value;
 165 +       bcma_cc_write32(cc, BCMA_CC_PLLCTL_ADDR, offset);
 166 +       bcma_cc_read32(cc, BCMA_CC_PLLCTL_ADDR);
 167 +       return bcma_cc_read32(cc, BCMA_CC_PLLCTL_DATA);
 168 +}
 169
 170 -       bcma_cc_read32(cc, BCMA_CC_CHIPCTL_ADDR);
 171 +void bcma_chipco_pll_write(struct bcma_drv_cc *cc, u32 offset, u32 value)
 172 +{
 173 +       bcma_cc_write32(cc, BCMA_CC_PLLCTL_ADDR, offset);
 174 +       bcma_cc_read32(cc, BCMA_CC_PLLCTL_ADDR);
 175 +       bcma_cc_write32(cc, BCMA_CC_PLLCTL_DATA, value);
 176 +}
 177 +EXPORT_SYMBOL_GPL(bcma_chipco_pll_write);
 178 +
 179 +void bcma_chipco_pll_maskset(struct bcma_drv_cc *cc, u32 offset, u32 mask,
 180 +                            u32 set)
 181 +{
 182 +       bcma_cc_write32(cc, BCMA_CC_PLLCTL_ADDR, offset);
 183 +       bcma_cc_read32(cc, BCMA_CC_PLLCTL_ADDR);
 184 +       bcma_cc_maskset32(cc, BCMA_CC_PLLCTL_DATA, mask, set);
 185 +}
 186 +EXPORT_SYMBOL_GPL(bcma_chipco_pll_maskset);
 187 +
 188 +void bcma_chipco_chipctl_maskset(struct bcma_drv_cc *cc,
 189 +                                u32 offset, u32 mask, u32 set)
 190 +{
 191         bcma_cc_write32(cc, BCMA_CC_CHIPCTL_ADDR, offset);
 192         bcma_cc_read32(cc, BCMA_CC_CHIPCTL_ADDR);
 193 -       value = bcma_cc_read32(cc, BCMA_CC_CHIPCTL_DATA);
 194 -       value &= mask;
 195 -       value |= set;
 196 -       bcma_cc_write32(cc, BCMA_CC_CHIPCTL_DATA, value);
 197 -       bcma_cc_read32(cc, BCMA_CC_CHIPCTL_DATA);
 198 +       bcma_cc_maskset32(cc, BCMA_CC_CHIPCTL_DATA, mask, set);
 199  }
 200 +EXPORT_SYMBOL_GPL(bcma_chipco_chipctl_maskset);
 201 +
 202 +void bcma_chipco_regctl_maskset(struct bcma_drv_cc *cc, u32 offset, u32 mask,
 203 +                               u32 set)
 204 +{
 205 +       bcma_cc_write32(cc, BCMA_CC_REGCTL_ADDR, offset);
 206 +       bcma_cc_read32(cc, BCMA_CC_REGCTL_ADDR);
 207 +       bcma_cc_maskset32(cc, BCMA_CC_REGCTL_DATA, mask, set);
 208 +}
 209 +EXPORT_SYMBOL_GPL(bcma_chipco_regctl_maskset);
 210
 211  static void bcma_pmu_pll_init(struct bcma_drv_cc *cc)
 212  {
 213 @@ -83,6 +110,24 @@ void bcma_pmu_swreg_init(struct bcma_drv
 214         }
 215  }
 216
 217 +/* Disable to allow reading SPROM. Don't know the adventages of enabling it. */
 218 +void bcma_chipco_bcm4331_ext_pa_lines_ctl(struct bcma_drv_cc *cc, bool enable)
 219 +{
 220 +       struct bcma_bus *bus = cc->core->bus;
 221 +       u32 val;
 222 +
 223 +       val = bcma_cc_read32(cc, BCMA_CC_CHIPCTL);
 224 +       if (enable) {
 225 +               val |= BCMA_CHIPCTL_4331_EXTPA_EN;
 226 +               if (bus->chipinfo.pkg == 9 || bus->chipinfo.pkg == 11)
 227 +                       val |= BCMA_CHIPCTL_4331_EXTPA_ON_GPIO2_5;
 228 +       } else {
 229 +               val &= ~BCMA_CHIPCTL_4331_EXTPA_EN;
 230 +               val &= ~BCMA_CHIPCTL_4331_EXTPA_ON_GPIO2_5;
 231 +       }
 232 +       bcma_cc_write32(cc, BCMA_CC_CHIPCTL, val);
 233 +}
 234 +
 235  void bcma_pmu_workarounds(struct bcma_drv_cc *cc)
 236  {
 237         struct bcma_bus *bus = cc->core->bus;
 238 @@ -92,7 +137,7 @@ void bcma_pmu_workarounds(struct bcma_dr
 239                 bcma_chipco_chipctl_maskset(cc, 0, ~0, 0x7);
 240                 break;
 241         case 0x4331:
 242 -               pr_err("Enabling Ext PA lines not implemented\n");
 243 +               /* BCM4331 workaround is SPROM-related, we put it in sprom.c */
 244                 break;
 245         case 43224:
 246                 if (bus->chipinfo.rev == 0) {
 247 @@ -136,3 +181,129 @@ void bcma_pmu_init(struct bcma_drv_cc *c
 248         bcma_pmu_swreg_init(cc);
 249         bcma_pmu_workarounds(cc);
 250  }
 251 +
 252 +u32 bcma_pmu_alp_clock(struct bcma_drv_cc *cc)
 253 +{
 254 +       struct bcma_bus *bus = cc->core->bus;
 255 +
 256 +       switch (bus->chipinfo.id) {
 257 +       case 0x4716:
 258 +       case 0x4748:
 259 +       case 47162:
 260 +       case 0x4313:
 261 +       case 0x5357:
 262 +       case 0x4749:
 263 +       case 53572:
 264 +               /* always 20Mhz */
 265 +               return 20000 * 1000;
 266 +       case 0x5356:
 267 +       case 0x5300:
 268 +               /* always 25Mhz */
 269 +               return 25000 * 1000;
 270 +       default:
 271 +               pr_warn("No ALP clock specified for %04X device, "
 272 +                       "pmu rev. %d, using default %d Hz\n",
 273 +                       bus->chipinfo.id, cc->pmu.rev, BCMA_CC_PMU_ALP_CLOCK);
 274 +       }
 275 +       return BCMA_CC_PMU_ALP_CLOCK;
 276 +}
 277 +
 278 +/* Find the output of the "m" pll divider given pll controls that start with
 279 + * pllreg "pll0" i.e. 12 for main 6 for phy, 0 for misc.
 280 + */
 281 +static u32 bcma_pmu_clock(struct bcma_drv_cc *cc, u32 pll0, u32 m)
 282 +{
 283 +       u32 tmp, div, ndiv, p1, p2, fc;
 284 +       struct bcma_bus *bus = cc->core->bus;
 285 +
 286 +       BUG_ON((pll0 & 3) || (pll0 > BCMA_CC_PMU4716_MAINPLL_PLL0));
 287 +
 288 +       BUG_ON(!m || m > 4);
 289 +
 290 +       if (bus->chipinfo.id == 0x5357 || bus->chipinfo.id == 0x4749) {
 291 +               /* Detect failure in clock setting */
 292 +               tmp = bcma_cc_read32(cc, BCMA_CC_CHIPSTAT);
 293 +               if (tmp & 0x40000)
 294 +                       return 133 * 1000000;
 295 +       }
 296 +
 297 +       tmp = bcma_chipco_pll_read(cc, pll0 + BCMA_CC_PPL_P1P2_OFF);
 298 +       p1 = (tmp & BCMA_CC_PPL_P1_MASK) >> BCMA_CC_PPL_P1_SHIFT;
 299 +       p2 = (tmp & BCMA_CC_PPL_P2_MASK) >> BCMA_CC_PPL_P2_SHIFT;
 300 +
 301 +       tmp = bcma_chipco_pll_read(cc, pll0 + BCMA_CC_PPL_M14_OFF);
 302 +       div = (tmp >> ((m - 1) * BCMA_CC_PPL_MDIV_WIDTH)) &
 303 +               BCMA_CC_PPL_MDIV_MASK;
 304 +
 305 +       tmp = bcma_chipco_pll_read(cc, pll0 + BCMA_CC_PPL_NM5_OFF);
 306 +       ndiv = (tmp & BCMA_CC_PPL_NDIV_MASK) >> BCMA_CC_PPL_NDIV_SHIFT;
 307 +
 308 +       /* Do calculation in Mhz */
 309 +       fc = bcma_pmu_alp_clock(cc) / 1000000;
 310 +       fc = (p1 * ndiv * fc) / p2;
 311 +
 312 +       /* Return clock in Hertz */
 313 +       return (fc / div) * 1000000;
 314 +}
 315 +
 316 +/* query bus clock frequency for PMU-enabled chipcommon */
 317 +u32 bcma_pmu_get_clockcontrol(struct bcma_drv_cc *cc)
 318 +{
 319 +       struct bcma_bus *bus = cc->core->bus;
 320 +
 321 +       switch (bus->chipinfo.id) {
 322 +       case 0x4716:
 323 +       case 0x4748:
 324 +       case 47162:
 325 +               return bcma_pmu_clock(cc, BCMA_CC_PMU4716_MAINPLL_PLL0,
 326 +                                     BCMA_CC_PMU5_MAINPLL_SSB);
 327 +       case 0x5356:
 328 +               return bcma_pmu_clock(cc, BCMA_CC_PMU5356_MAINPLL_PLL0,
 329 +                                     BCMA_CC_PMU5_MAINPLL_SSB);
 330 +       case 0x5357:
 331 +       case 0x4749:
 332 +               return bcma_pmu_clock(cc, BCMA_CC_PMU5357_MAINPLL_PLL0,
 333 +                                     BCMA_CC_PMU5_MAINPLL_SSB);
 334 +       case 0x5300:
 335 +               return bcma_pmu_clock(cc, BCMA_CC_PMU4706_MAINPLL_PLL0,
 336 +                                     BCMA_CC_PMU5_MAINPLL_SSB);
 337 +       case 53572:
 338 +               return 75000000;
 339 +       default:
 340 +               pr_warn("No backplane clock specified for %04X device, "
 341 +                       "pmu rev. %d, using default %d Hz\n",
 342 +                       bus->chipinfo.id, cc->pmu.rev, BCMA_CC_PMU_HT_CLOCK);
 343 +       }
 344 +       return BCMA_CC_PMU_HT_CLOCK;
 345 +}
 346 +
 347 +/* query cpu clock frequency for PMU-enabled chipcommon */
 348 +u32 bcma_pmu_get_clockcpu(struct bcma_drv_cc *cc)
 349 +{
 350 +       struct bcma_bus *bus = cc->core->bus;
 351 +
 352 +       if (bus->chipinfo.id == 53572)
 353 +               return 300000000;
 354 +
 355 +       if (cc->pmu.rev >= 5) {
 356 +               u32 pll;
 357 +               switch (bus->chipinfo.id) {
 358 +               case 0x5356:
 359 +                       pll = BCMA_CC_PMU5356_MAINPLL_PLL0;
 360 +                       break;
 361 +               case 0x5357:
 362 +               case 0x4749:
 363 +                       pll = BCMA_CC_PMU5357_MAINPLL_PLL0;
 364 +                       break;
 365 +               default:
 366 +                       pll = BCMA_CC_PMU4716_MAINPLL_PLL0;
 367 +                       break;
 368 +               }
 369 +
 370 +               /* TODO: if (bus->chipinfo.id == 0x5300)
 371 +                 return si_4706_pmu_clock(sih, osh, cc, PMU4706_MAINPLL_PLL0, PMU5_MAINPLL_CPU); */
 372 +               return bcma_pmu_clock(cc, pll, BCMA_CC_PMU5_MAINPLL_CPU);
 373 +       }
 374 +
 375 +       return bcma_pmu_get_clockcontrol(cc);
 376 +}
 377 --- /dev/null
 378 +++ b/drivers/bcma/driver_mips.c
 379 @@ -0,0 +1,256 @@
 380 +/*
 381 + * Broadcom specific AMBA
 382 + * Broadcom MIPS32 74K core driver
 383 + *
 384 + * Copyright 2009, Broadcom Corporation
 385 + * Copyright 2006, 2007, Michael Buesch <mb@bu3sch.de>
 386 + * Copyright 2010, Bernhard Loos <bernhardloos@googlemail.com>
 387 + * Copyright 2011, Hauke Mehrtens <hauke@hauke-m.de>
 388 + *
 389 + * Licensed under the GNU/GPL. See COPYING for details.
 390 + */
 391 +
 392 +#include "bcma_private.h"
 393 +
 394 +#include <linux/bcma/bcma.h>
 395 +
 396 +#include <linux/serial.h>
 397 +#include <linux/serial_core.h>
 398 +#include <linux/serial_reg.h>
 399 +#include <linux/time.h>
 400 +
 401 +/* The 47162a0 hangs when reading MIPS DMP registers registers */
 402 +static inline bool bcma_core_mips_bcm47162a0_quirk(struct bcma_device *dev)
 403 +{
 404 +       return dev->bus->chipinfo.id == 47162 && dev->bus->chipinfo.rev == 0 &&
 405 +              dev->id.id == BCMA_CORE_MIPS_74K;
 406 +}
 407 +
 408 +/* The 5357b0 hangs when reading USB20H DMP registers */
 409 +static inline bool bcma_core_mips_bcm5357b0_quirk(struct bcma_device *dev)
 410 +{
 411 +       return (dev->bus->chipinfo.id == 0x5357 ||
 412 +               dev->bus->chipinfo.id == 0x4749) &&
 413 +              dev->bus->chipinfo.pkg == 11 &&
 414 +              dev->id.id == BCMA_CORE_USB20_HOST;
 415 +}
 416 +
 417 +static inline u32 mips_read32(struct bcma_drv_mips *mcore,
 418 +                             u16 offset)
 419 +{
 420 +       return bcma_read32(mcore->core, offset);
 421 +}
 422 +
 423 +static inline void mips_write32(struct bcma_drv_mips *mcore,
 424 +                               u16 offset,
 425 +                               u32 value)
 426 +{
 427 +       bcma_write32(mcore->core, offset, value);
 428 +}
 429 +
 430 +static const u32 ipsflag_irq_mask[] = {
 431 +       0,
 432 +       BCMA_MIPS_IPSFLAG_IRQ1,
 433 +       BCMA_MIPS_IPSFLAG_IRQ2,
 434 +       BCMA_MIPS_IPSFLAG_IRQ3,
 435 +       BCMA_MIPS_IPSFLAG_IRQ4,
 436 +};
 437 +
 438 +static const u32 ipsflag_irq_shift[] = {
 439 +       0,
 440 +       BCMA_MIPS_IPSFLAG_IRQ1_SHIFT,
 441 +       BCMA_MIPS_IPSFLAG_IRQ2_SHIFT,
 442 +       BCMA_MIPS_IPSFLAG_IRQ3_SHIFT,
 443 +       BCMA_MIPS_IPSFLAG_IRQ4_SHIFT,
 444 +};
 445 +
 446 +static u32 bcma_core_mips_irqflag(struct bcma_device *dev)
 447 +{
 448 +       u32 flag;
 449 +
 450 +       if (bcma_core_mips_bcm47162a0_quirk(dev))
 451 +               return dev->core_index;
 452 +       if (bcma_core_mips_bcm5357b0_quirk(dev))
 453 +               return dev->core_index;
 454 +       flag = bcma_aread32(dev, BCMA_MIPS_OOBSELOUTA30);
 455 +
 456 +       return flag & 0x1F;
 457 +}
 458 +
 459 +/* Get the MIPS IRQ assignment for a specified device.
 460 + * If unassigned, 0 is returned.
 461 + */
 462 +unsigned int bcma_core_mips_irq(struct bcma_device *dev)
 463 +{
 464 +       struct bcma_device *mdev = dev->bus->drv_mips.core;
 465 +       u32 irqflag;
 466 +       unsigned int irq;
 467 +
 468 +       irqflag = bcma_core_mips_irqflag(dev);
 469 +
 470 +       for (irq = 1; irq <= 4; irq++)
 471 +               if (bcma_read32(mdev, BCMA_MIPS_MIPS74K_INTMASK(irq)) &
 472 +                   (1 << irqflag))
 473 +                       return irq;
 474 +
 475 +       return 0;
 476 +}
 477 +EXPORT_SYMBOL(bcma_core_mips_irq);
 478 +
 479 +static void bcma_core_mips_set_irq(struct bcma_device *dev, unsigned int irq)
 480 +{
 481 +       unsigned int oldirq = bcma_core_mips_irq(dev);
 482 +       struct bcma_bus *bus = dev->bus;
 483 +       struct bcma_device *mdev = bus->drv_mips.core;
 484 +       u32 irqflag;
 485 +
 486 +       irqflag = bcma_core_mips_irqflag(dev);
 487 +       BUG_ON(oldirq == 6);
 488 +
 489 +       dev->irq = irq + 2;
 490 +
 491 +       /* clear the old irq */
 492 +       if (oldirq == 0)
 493 +               bcma_write32(mdev, BCMA_MIPS_MIPS74K_INTMASK(0),
 494 +                           bcma_read32(mdev, BCMA_MIPS_MIPS74K_INTMASK(0)) &
 495 +                           ~(1 << irqflag));
 496 +       else
 497 +               bcma_write32(mdev, BCMA_MIPS_MIPS74K_INTMASK(irq), 0);
 498 +
 499 +       /* assign the new one */
 500 +       if (irq == 0) {
 501 +               bcma_write32(mdev, BCMA_MIPS_MIPS74K_INTMASK(0),
 502 +                           bcma_read32(mdev, BCMA_MIPS_MIPS74K_INTMASK(0)) |
 503 +                           (1 << irqflag));
 504 +       } else {
 505 +               u32 oldirqflag = bcma_read32(mdev,
 506 +                                            BCMA_MIPS_MIPS74K_INTMASK(irq));
 507 +               if (oldirqflag) {
 508 +                       struct bcma_device *core;
 509 +
 510 +                       /* backplane irq line is in use, find out who uses
 511 +                        * it and set user to irq 0
 512 +                        */
 513 +                       list_for_each_entry_reverse(core, &bus->cores, list) {
 514 +                               if ((1 << bcma_core_mips_irqflag(core)) ==
 515 +                                   oldirqflag) {
 516 +                                       bcma_core_mips_set_irq(core, 0);
 517 +                                       break;
 518 +                               }
 519 +                       }
 520 +               }
 521 +               bcma_write32(mdev, BCMA_MIPS_MIPS74K_INTMASK(irq),
 522 +                            1 << irqflag);
 523 +       }
 524 +
 525 +       pr_info("set_irq: core 0x%04x, irq %d => %d\n",
 526 +               dev->id.id, oldirq + 2, irq + 2);
 527 +}
 528 +
 529 +static void bcma_core_mips_print_irq(struct bcma_device *dev, unsigned int irq)
 530 +{
 531 +       int i;
 532 +       static const char *irq_name[] = {"2(S)", "3", "4", "5", "6", "D", "I"};
 533 +       printk(KERN_INFO KBUILD_MODNAME ": core 0x%04x, irq :", dev->id.id);
 534 +       for (i = 0; i <= 6; i++)
 535 +               printk(" %s%s", irq_name[i], i == irq ? "*" : " ");
 536 +       printk("\n");
 537 +}
 538 +
 539 +static void bcma_core_mips_dump_irq(struct bcma_bus *bus)
 540 +{
 541 +       struct bcma_device *core;
 542 +
 543 +       list_for_each_entry_reverse(core, &bus->cores, list) {
 544 +               bcma_core_mips_print_irq(core, bcma_core_mips_irq(core));
 545 +       }
 546 +}
 547 +
 548 +u32 bcma_cpu_clock(struct bcma_drv_mips *mcore)
 549 +{
 550 +       struct bcma_bus *bus = mcore->core->bus;
 551 +
 552 +       if (bus->drv_cc.capabilities & BCMA_CC_CAP_PMU)
 553 +               return bcma_pmu_get_clockcpu(&bus->drv_cc);
 554 +
 555 +       pr_err("No PMU available, need this to get the cpu clock\n");
 556 +       return 0;
 557 +}
 558 +EXPORT_SYMBOL(bcma_cpu_clock);
 559 +
 560 +static void bcma_core_mips_flash_detect(struct bcma_drv_mips *mcore)
 561 +{
 562 +       struct bcma_bus *bus = mcore->core->bus;
 563 +
 564 +       switch (bus->drv_cc.capabilities & BCMA_CC_CAP_FLASHT) {
 565 +       case BCMA_CC_FLASHT_STSER:
 566 +       case BCMA_CC_FLASHT_ATSER:
 567 +               pr_err("Serial flash not supported.\n");
 568 +               break;
 569 +       case BCMA_CC_FLASHT_PARA:
 570 +               pr_info("found parallel flash.\n");
 571 +               bus->drv_cc.pflash.window = 0x1c000000;
 572 +               bus->drv_cc.pflash.window_size = 0x02000000;
 573 +
 574 +               if ((bcma_read32(bus->drv_cc.core, BCMA_CC_FLASH_CFG) &
 575 +                    BCMA_CC_FLASH_CFG_DS) == 0)
 576 +                       bus->drv_cc.pflash.buswidth = 1;
 577 +               else
 578 +                       bus->drv_cc.pflash.buswidth = 2;
 579 +               break;
 580 +       default:
 581 +               pr_err("flash not supported.\n");
 582 +       }
 583 +}
 584 +
 585 +void bcma_core_mips_init(struct bcma_drv_mips *mcore)
 586 +{
 587 +       struct bcma_bus *bus;
 588 +       struct bcma_device *core;
 589 +       bus = mcore->core->bus;
 590 +
 591 +       pr_info("Initializing MIPS core...\n");
 592 +
 593 +       if (!mcore->setup_done)
 594 +               mcore->assigned_irqs = 1;
 595 +
 596 +       /* Assign IRQs to all cores on the bus */
 597 +       list_for_each_entry_reverse(core, &bus->cores, list) {
 598 +               int mips_irq;
 599 +               if (core->irq)
 600 +                       continue;
 601 +
 602 +               mips_irq = bcma_core_mips_irq(core);
 603 +               if (mips_irq > 4)
 604 +                       core->irq = 0;
 605 +               else
 606 +                       core->irq = mips_irq + 2;
 607 +               if (core->irq > 5)
 608 +                       continue;
 609 +               switch (core->id.id) {
 610 +               case BCMA_CORE_PCI:
 611 +               case BCMA_CORE_PCIE:
 612 +               case BCMA_CORE_ETHERNET:
 613 +               case BCMA_CORE_ETHERNET_GBIT:
 614 +               case BCMA_CORE_MAC_GBIT:
 615 +               case BCMA_CORE_80211:
 616 +               case BCMA_CORE_USB20_HOST:
 617 +                       /* These devices get their own IRQ line if available,
 618 +                        * the rest goes on IRQ0
 619 +                        */
 620 +                       if (mcore->assigned_irqs <= 4)
 621 +                               bcma_core_mips_set_irq(core,
 622 +                                                      mcore->assigned_irqs++);
 623 +                       break;
 624 +               }
 625 +       }
 626 +       pr_info("IRQ reconfiguration done\n");
 627 +       bcma_core_mips_dump_irq(bus);
 628 +
 629 +       if (mcore->setup_done)
 630 +               return;
 631 +
 632 +       bcma_chipco_serial_init(&bus->drv_cc);
 633 +       bcma_core_mips_flash_detect(mcore);
 634 +       mcore->setup_done = true;
 635 +}
 636 --- a/drivers/bcma/driver_pci.c
 637 +++ b/drivers/bcma/driver_pci.c
 638 @@ -173,7 +173,7 @@ static bool bcma_core_pci_is_in_hostmode
 639                 return false;
 640
 641  #ifdef CONFIG_SSB_DRIVER_PCICORE
 642 -       if (bus->sprom.boardflags_lo & SSB_PCICORE_BFL_NOPCI)
 643 +       if (bus->sprom.boardflags_lo & SSB_BFL_NOPCI)
 644                 return false;
 645  #endif /* CONFIG_SSB_DRIVER_PCICORE */
 646
 647 @@ -189,6 +189,9 @@ static bool bcma_core_pci_is_in_hostmode
 648
 649  void bcma_core_pci_init(struct bcma_drv_pci *pc)
 650  {
 651 +       if (pc->setup_done)
 652 +               return;
 653 +
 654         if (bcma_core_pci_is_in_hostmode(pc)) {
 655  #ifdef CONFIG_BCMA_DRIVER_PCI_HOSTMODE
 656                 bcma_core_pci_hostmode_init(pc);
 657 @@ -198,6 +201,8 @@ void bcma_core_pci_init(struct bcma_drv_
 658         } else {
 659                 bcma_core_pci_clientmode_init(pc);
 660         }
 661 +
 662 +       pc->setup_done = true;
 663  }
 664
 665  int bcma_core_pci_irq_ctl(struct bcma_drv_pci *pc, struct bcma_device *core,
 666 @@ -205,7 +210,14 @@ int bcma_core_pci_irq_ctl(struct bcma_dr
 667  {
 668         struct pci_dev *pdev = pc->core->bus->host_pci;
 669         u32 coremask, tmp;
 670 -       int err;
 671 +       int err = 0;
 672 +
 673 +       if (core->bus->hosttype != BCMA_HOSTTYPE_PCI) {
 674 +               /* This bcma device is not on a PCI host-bus. So the IRQs are
 675 +                * not routed through the PCI core.
 676 +                * So we must not enable routing through the PCI core. */
 677 +               goto out;
 678 +       }
 679
 680         err = pci_read_config_dword(pdev, BCMA_PCI_IRQMASK, &tmp);
 681         if (err)
 682 --- a/drivers/bcma/host_pci.c
 683 +++ b/drivers/bcma/host_pci.c
 684 @@ -9,6 +9,7 @@
 685  #include <linux/slab.h>
 686  #include <linux/bcma/bcma.h>
 687  #include <linux/pci.h>
 688 +#include <linux/module.h>
 689
 690  static void bcma_host_pci_switch_core(struct bcma_device *core)
 691  {
 692 @@ -20,48 +21,58 @@ static void bcma_host_pci_switch_core(st
 693         pr_debug("Switched to core: 0x%X\n", core->id.id);
 694  }
 695
 696 -static u8 bcma_host_pci_read8(struct bcma_device *core, u16 offset)
 697 -{
 698 +/* Provides access to the requested core. Returns base offset that has to be
 699 + * used. It makes use of fixed windows when possible. */
 700 +static u16 bcma_host_pci_provide_access_to_core(struct bcma_device *core)
 701 +{
 702 +       switch (core->id.id) {
 703 +       case BCMA_CORE_CHIPCOMMON:
 704 +               return 3 * BCMA_CORE_SIZE;
 705 +       case BCMA_CORE_PCIE:
 706 +               return 2 * BCMA_CORE_SIZE;
 707 +       }
 708 +
 709         if (core->bus->mapped_core != core)
 710                 bcma_host_pci_switch_core(core);
 711 +       return 0;
 712 +}
 713 +
 714 +static u8 bcma_host_pci_read8(struct bcma_device *core, u16 offset)
 715 +{
 716 +       offset += bcma_host_pci_provide_access_to_core(core);
 717         return ioread8(core->bus->mmio + offset);
 718  }
 719
 720  static u16 bcma_host_pci_read16(struct bcma_device *core, u16 offset)
 721  {
 722 -       if (core->bus->mapped_core != core)
 723 -               bcma_host_pci_switch_core(core);
 724 +       offset += bcma_host_pci_provide_access_to_core(core);
 725         return ioread16(core->bus->mmio + offset);
 726  }
 727
 728  static u32 bcma_host_pci_read32(struct bcma_device *core, u16 offset)
 729  {
 730 -       if (core->bus->mapped_core != core)
 731 -               bcma_host_pci_switch_core(core);
 732 +       offset += bcma_host_pci_provide_access_to_core(core);
 733         return ioread32(core->bus->mmio + offset);
 734  }
 735
 736  static void bcma_host_pci_write8(struct bcma_device *core, u16 offset,
 737                                  u8 value)
 738  {
 739 -       if (core->bus->mapped_core != core)
 740 -               bcma_host_pci_switch_core(core);
 741 +       offset += bcma_host_pci_provide_access_to_core(core);
 742         iowrite8(value, core->bus->mmio + offset);
 743  }
 744
 745  static void bcma_host_pci_write16(struct bcma_device *core, u16 offset,
 746                                  u16 value)
 747  {
 748 -       if (core->bus->mapped_core != core)
 749 -               bcma_host_pci_switch_core(core);
 750 +       offset += bcma_host_pci_provide_access_to_core(core);
 751         iowrite16(value, core->bus->mmio + offset);
 752  }
 753
 754  static void bcma_host_pci_write32(struct bcma_device *core, u16 offset,
 755                                  u32 value)
 756  {
 757 -       if (core->bus->mapped_core != core)
 758 -               bcma_host_pci_switch_core(core);
 759 +       offset += bcma_host_pci_provide_access_to_core(core);
 760         iowrite32(value, core->bus->mmio + offset);
 761  }
 762
 763 @@ -223,6 +234,41 @@ static void bcma_host_pci_remove(struct
 764         pci_set_drvdata(dev, NULL);
 765  }
 766
 767 +#ifdef CONFIG_PM
 768 +static int bcma_host_pci_suspend(struct pci_dev *dev, pm_message_t state)
 769 +{
 770 +       /* Host specific */
 771 +       pci_save_state(dev);
 772 +       pci_disable_device(dev);
 773 +       pci_set_power_state(dev, pci_choose_state(dev, state));
 774 +
 775 +       return 0;
 776 +}
 777 +
 778 +static int bcma_host_pci_resume(struct pci_dev *dev)
 779 +{
 780 +       struct bcma_bus *bus = pci_get_drvdata(dev);
 781 +       int err;
 782 +
 783 +       /* Host specific */
 784 +       pci_set_power_state(dev, 0);
 785 +       err = pci_enable_device(dev);
 786 +       if (err)
 787 +               return err;
 788 +       pci_restore_state(dev);
 789 +
 790 +       /* Bus specific */
 791 +       err = bcma_bus_resume(bus);
 792 +       if (err)
 793 +               return err;
 794 +
 795 +       return 0;
 796 +}
 797 +#else /* CONFIG_PM */
 798 +# define bcma_host_pci_suspend NULL
 799 +# define bcma_host_pci_resume  NULL
 800 +#endif /* CONFIG_PM */
 801 +
 802  static DEFINE_PCI_DEVICE_TABLE(bcma_pci_bridge_tbl) = {
 803         { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x0576) },
 804         { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4331) },
 805 @@ -238,6 +284,8 @@ static struct pci_driver bcma_pci_bridge
 806         .id_table = bcma_pci_bridge_tbl,
 807         .probe = bcma_host_pci_probe,
 808         .remove = bcma_host_pci_remove,
 809 +       .suspend = bcma_host_pci_suspend,
 810 +       .resume = bcma_host_pci_resume,
 811  };
 812
 813  int __init bcma_host_pci_init(void)
 814 --- /dev/null
 815 +++ b/drivers/bcma/host_soc.c
 816 @@ -0,0 +1,183 @@
 817 +/*
 818 + * Broadcom specific AMBA
 819 + * System on Chip (SoC) Host
 820 + *
 821 + * Licensed under the GNU/GPL. See COPYING for details.
 822 + */
 823 +
 824 +#include "bcma_private.h"
 825 +#include "scan.h"
 826 +#include <linux/bcma/bcma.h>
 827 +#include <linux/bcma/bcma_soc.h>
 828 +
 829 +static u8 bcma_host_soc_read8(struct bcma_device *core, u16 offset)
 830 +{
 831 +       return readb(core->io_addr + offset);
 832 +}
 833 +
 834 +static u16 bcma_host_soc_read16(struct bcma_device *core, u16 offset)
 835 +{
 836 +       return readw(core->io_addr + offset);
 837 +}
 838 +
 839 +static u32 bcma_host_soc_read32(struct bcma_device *core, u16 offset)
 840 +{
 841 +       return readl(core->io_addr + offset);
 842 +}
 843 +
 844 +static void bcma_host_soc_write8(struct bcma_device *core, u16 offset,
 845 +                                u8 value)
 846 +{
 847 +       writeb(value, core->io_addr + offset);
 848 +}
 849 +
 850 +static void bcma_host_soc_write16(struct bcma_device *core, u16 offset,
 851 +                                u16 value)
 852 +{
 853 +       writew(value, core->io_addr + offset);
 854 +}
 855 +
 856 +static void bcma_host_soc_write32(struct bcma_device *core, u16 offset,
 857 +                                u32 value)
 858 +{
 859 +       writel(value, core->io_addr + offset);
 860 +}
 861 +
 862 +#ifdef CONFIG_BCMA_BLOCKIO
 863 +static void bcma_host_soc_block_read(struct bcma_device *core, void *buffer,
 864 +                                    size_t count, u16 offset, u8 reg_width)
 865 +{
 866 +       void __iomem *addr = core->io_addr + offset;
 867 +
 868 +       switch (reg_width) {
 869 +       case sizeof(u8): {
 870 +               u8 *buf = buffer;
 871 +
 872 +               while (count) {
 873 +                       *buf = __raw_readb(addr);
 874 +                       buf++;
 875 +                       count--;
 876 +               }
 877 +               break;
 878 +       }
 879 +       case sizeof(u16): {
 880 +               __le16 *buf = buffer;
 881 +
 882 +               WARN_ON(count & 1);
 883 +               while (count) {
 884 +                       *buf = (__force __le16)__raw_readw(addr);
 885 +                       buf++;
 886 +                       count -= 2;
 887 +               }
 888 +               break;
 889 +       }
 890 +       case sizeof(u32): {
 891 +               __le32 *buf = buffer;
 892 +
 893 +               WARN_ON(count & 3);
 894 +               while (count) {
 895 +                       *buf = (__force __le32)__raw_readl(addr);
 896 +                       buf++;
 897 +                       count -= 4;
 898 +               }
 899 +               break;
 900 +       }
 901 +       default:
 902 +               WARN_ON(1);
 903 +       }
 904 +}
 905 +
 906 +static void bcma_host_soc_block_write(struct bcma_device *core,
 907 +                                     const void *buffer,
 908 +                                     size_t count, u16 offset, u8 reg_width)
 909 +{
 910 +       void __iomem *addr = core->io_addr + offset;
 911 +
 912 +       switch (reg_width) {
 913 +       case sizeof(u8): {
 914 +               const u8 *buf = buffer;
 915 +
 916 +               while (count) {
 917 +                       __raw_writeb(*buf, addr);
 918 +                       buf++;
 919 +                       count--;
 920 +               }
 921 +               break;
 922 +       }
 923 +       case sizeof(u16): {
 924 +               const __le16 *buf = buffer;
 925 +
 926 +               WARN_ON(count & 1);
 927 +               while (count) {
 928 +                       __raw_writew((__force u16)(*buf), addr);
 929 +                       buf++;
 930 +                       count -= 2;
 931 +               }
 932 +               break;
 933 +       }
 934 +       case sizeof(u32): {
 935 +               const __le32 *buf = buffer;
 936 +
 937 +               WARN_ON(count & 3);
 938 +               while (count) {
 939 +                       __raw_writel((__force u32)(*buf), addr);
 940 +                       buf++;
 941 +                       count -= 4;
 942 +               }
 943 +               break;
 944 +       }
 945 +       default:
 946 +               WARN_ON(1);
 947 +       }
 948 +}
 949 +#endif /* CONFIG_BCMA_BLOCKIO */
 950 +
 951 +static u32 bcma_host_soc_aread32(struct bcma_device *core, u16 offset)
 952 +{
 953 +       return readl(core->io_wrap + offset);
 954 +}
 955 +
 956 +static void bcma_host_soc_awrite32(struct bcma_device *core, u16 offset,
 957 +                                 u32 value)
 958 +{
 959 +       writel(value, core->io_wrap + offset);
 960 +}
 961 +
 962 +const struct bcma_host_ops bcma_host_soc_ops = {
 963 +       .read8          = bcma_host_soc_read8,
 964 +       .read16         = bcma_host_soc_read16,
 965 +       .read32         = bcma_host_soc_read32,
 966 +       .write8         = bcma_host_soc_write8,
 967 +       .write16        = bcma_host_soc_write16,
 968 +       .write32        = bcma_host_soc_write32,
 969 +#ifdef CONFIG_BCMA_BLOCKIO
 970 +       .block_read     = bcma_host_soc_block_read,
 971 +       .block_write    = bcma_host_soc_block_write,
 972 +#endif
 973 +       .aread32        = bcma_host_soc_aread32,
 974 +       .awrite32       = bcma_host_soc_awrite32,
 975 +};
 976 +
 977 +int __init bcma_host_soc_register(struct bcma_soc *soc)
 978 +{
 979 +       struct bcma_bus *bus = &soc->bus;
 980 +       int err;
 981 +
 982 +       /* iomap only first core. We have to read some register on this core
 983 +        * to scan the bus.
 984 +        */
 985 +       bus->mmio = ioremap_nocache(BCMA_ADDR_BASE, BCMA_CORE_SIZE * 1);
 986 +       if (!bus->mmio)
 987 +               return -ENOMEM;
 988 +
 989 +       /* Host specific */
 990 +       bus->hosttype = BCMA_HOSTTYPE_SOC;
 991 +       bus->ops = &bcma_host_soc_ops;
 992 +
 993 +       /* Register */
 994 +       err = bcma_bus_early_register(bus, &soc->core_cc, &soc->core_mips);
 995 +       if (err)
 996 +               iounmap(bus->mmio);
 997 +
 998 +       return err;
 999 +}
1000 --- a/drivers/bcma/main.c
1001 +++ b/drivers/bcma/main.c
1002 @@ -6,6 +6,7 @@
1003   */
1004
1005  #include "bcma_private.h"
1006 +#include <linux/module.h>
1007  #include <linux/bcma/bcma.h>
1008  #include <linux/slab.h>
1009
1010 @@ -68,6 +69,10 @@ static struct bcma_device *bcma_find_cor
1011  static void bcma_release_core_dev(struct device *dev)
1012  {
1013         struct bcma_device *core = container_of(dev, struct bcma_device, dev);
1014 +       if (core->io_addr)
1015 +               iounmap(core->io_addr);
1016 +       if (core->io_wrap)
1017 +               iounmap(core->io_wrap);
1018         kfree(core);
1019  }
1020
1021 @@ -82,6 +87,7 @@ static int bcma_register_cores(struct bc
1022                 case BCMA_CORE_CHIPCOMMON:
1023                 case BCMA_CORE_PCI:
1024                 case BCMA_CORE_PCIE:
1025 +               case BCMA_CORE_MIPS_74K:
1026                         continue;
1027                 }
1028
1029 @@ -95,7 +101,10 @@ static int bcma_register_cores(struct bc
1030                         core->dma_dev = &bus->host_pci->dev;
1031                         core->irq = bus->host_pci->irq;
1032                         break;
1033 -               case BCMA_HOSTTYPE_NONE:
1034 +               case BCMA_HOSTTYPE_SOC:
1035 +                       core->dev.dma_mask = &core->dev.coherent_dma_mask;
1036 +                       core->dma_dev = &core->dev;
1037 +                       break;
1038                 case BCMA_HOSTTYPE_SDIO:
1039                         break;
1040                 }
1041 @@ -142,6 +151,13 @@ int bcma_bus_register(struct bcma_bus *b
1042                 bcma_core_chipcommon_init(&bus->drv_cc);
1043         }
1044
1045 +       /* Init MIPS core */
1046 +       core = bcma_find_core(bus, BCMA_CORE_MIPS_74K);
1047 +       if (core) {
1048 +               bus->drv_mips.core = core;
1049 +               bcma_core_mips_init(&bus->drv_mips);
1050 +       }
1051 +
1052         /* Init PCIE core */
1053         core = bcma_find_core(bus, BCMA_CORE_PCIE);
1054         if (core) {
1055 @@ -171,6 +187,75 @@ void bcma_bus_unregister(struct bcma_bus
1056         bcma_unregister_cores(bus);
1057  }
1058
1059 +int __init bcma_bus_early_register(struct bcma_bus *bus,
1060 +                                  struct bcma_device *core_cc,
1061 +                                  struct bcma_device *core_mips)
1062 +{
1063 +       int err;
1064 +       struct bcma_device *core;
1065 +       struct bcma_device_id match;
1066 +
1067 +       bcma_init_bus(bus);
1068 +
1069 +       match.manuf = BCMA_MANUF_BCM;
1070 +       match.id = BCMA_CORE_CHIPCOMMON;
1071 +       match.class = BCMA_CL_SIM;
1072 +       match.rev = BCMA_ANY_REV;
1073 +
1074 +       /* Scan for chip common core */
1075 +       err = bcma_bus_scan_early(bus, &match, core_cc);
1076 +       if (err) {
1077 +               pr_err("Failed to scan for common core: %d\n", err);
1078 +               return -1;
1079 +       }
1080 +
1081 +       match.manuf = BCMA_MANUF_MIPS;
1082 +       match.id = BCMA_CORE_MIPS_74K;
1083 +       match.class = BCMA_CL_SIM;
1084 +       match.rev = BCMA_ANY_REV;
1085 +
1086 +       /* Scan for mips core */
1087 +       err = bcma_bus_scan_early(bus, &match, core_mips);
1088 +       if (err) {
1089 +               pr_err("Failed to scan for mips core: %d\n", err);
1090 +               return -1;
1091 +       }
1092 +
1093 +       /* Init CC core */
1094 +       core = bcma_find_core(bus, BCMA_CORE_CHIPCOMMON);
1095 +       if (core) {
1096 +               bus->drv_cc.core = core;
1097 +               bcma_core_chipcommon_init(&bus->drv_cc);
1098 +       }
1099 +
1100 +       /* Init MIPS core */
1101 +       core = bcma_find_core(bus, BCMA_CORE_MIPS_74K);
1102 +       if (core) {
1103 +               bus->drv_mips.core = core;
1104 +               bcma_core_mips_init(&bus->drv_mips);
1105 +       }
1106 +
1107 +       pr_info("Early bus registered\n");
1108 +
1109 +       return 0;
1110 +}
1111 +
1112 +#ifdef CONFIG_PM
1113 +int bcma_bus_resume(struct bcma_bus *bus)
1114 +{
1115 +       struct bcma_device *core;
1116 +
1117 +       /* Init CC core */
1118 +       core = bcma_find_core(bus, BCMA_CORE_CHIPCOMMON);
1119 +       if (core) {
1120 +               bus->drv_cc.setup_done = false;
1121 +               bcma_core_chipcommon_init(&bus->drv_cc);
1122 +       }
1123 +
1124 +       return 0;
1125 +}
1126 +#endif
1127 +
1128  int __bcma_driver_register(struct bcma_driver *drv, struct module *owner)
1129  {
1130         drv->drv.name = drv->name;
1131 --- a/drivers/bcma/scan.c
1132 +++ b/drivers/bcma/scan.c
1133 @@ -200,18 +200,162 @@ static s32 bcma_erom_get_addr_desc(struc
1134         return addrl;
1135  }
1136
1137 -int bcma_bus_scan(struct bcma_bus *bus)
1138 +static struct bcma_device *bcma_find_core_by_index(struct bcma_bus *bus,
1139 +                                                  u16 index)
1140  {
1141 -       u32 erombase;
1142 -       u32 __iomem *eromptr, *eromend;
1143 +       struct bcma_device *core;
1144
1145 +       list_for_each_entry(core, &bus->cores, list) {
1146 +               if (core->core_index == index)
1147 +                       return core;
1148 +       }
1149 +       return NULL;
1150 +}
1151 +
1152 +static int bcma_get_next_core(struct bcma_bus *bus, u32 __iomem **eromptr,
1153 +                             struct bcma_device_id *match, int core_num,
1154 +                             struct bcma_device *core)
1155 +{
1156 +       s32 tmp;
1157 +       u8 i, j;
1158         s32 cia, cib;
1159         u8 ports[2], wrappers[2];
1160
1161 +       /* get CIs */
1162 +       cia = bcma_erom_get_ci(bus, eromptr);
1163 +       if (cia < 0) {
1164 +               bcma_erom_push_ent(eromptr);
1165 +               if (bcma_erom_is_end(bus, eromptr))
1166 +                       return -ESPIPE;
1167 +               return -EILSEQ;
1168 +       }
1169 +       cib = bcma_erom_get_ci(bus, eromptr);
1170 +       if (cib < 0)
1171 +               return -EILSEQ;
1172 +
1173 +       /* parse CIs */
1174 +       core->id.class = (cia & SCAN_CIA_CLASS) >> SCAN_CIA_CLASS_SHIFT;
1175 +       core->id.id = (cia & SCAN_CIA_ID) >> SCAN_CIA_ID_SHIFT;
1176 +       core->id.manuf = (cia & SCAN_CIA_MANUF) >> SCAN_CIA_MANUF_SHIFT;
1177 +       ports[0] = (cib & SCAN_CIB_NMP) >> SCAN_CIB_NMP_SHIFT;
1178 +       ports[1] = (cib & SCAN_CIB_NSP) >> SCAN_CIB_NSP_SHIFT;
1179 +       wrappers[0] = (cib & SCAN_CIB_NMW) >> SCAN_CIB_NMW_SHIFT;
1180 +       wrappers[1] = (cib & SCAN_CIB_NSW) >> SCAN_CIB_NSW_SHIFT;
1181 +       core->id.rev = (cib & SCAN_CIB_REV) >> SCAN_CIB_REV_SHIFT;
1182 +
1183 +       if (((core->id.manuf == BCMA_MANUF_ARM) &&
1184 +            (core->id.id == 0xFFF)) ||
1185 +           (ports[1] == 0)) {
1186 +               bcma_erom_skip_component(bus, eromptr);
1187 +               return -ENXIO;
1188 +       }
1189 +
1190 +       /* check if component is a core at all */
1191 +       if (wrappers[0] + wrappers[1] == 0) {
1192 +               /* we could save addrl of the router
1193 +               if (cid == BCMA_CORE_OOB_ROUTER)
1194 +                */
1195 +               bcma_erom_skip_component(bus, eromptr);
1196 +               return -ENXIO;
1197 +       }
1198 +
1199 +       if (bcma_erom_is_bridge(bus, eromptr)) {
1200 +               bcma_erom_skip_component(bus, eromptr);
1201 +               return -ENXIO;
1202 +       }
1203 +
1204 +       if (bcma_find_core_by_index(bus, core_num)) {
1205 +               bcma_erom_skip_component(bus, eromptr);
1206 +               return -ENODEV;
1207 +       }
1208 +
1209 +       if (match && ((match->manuf != BCMA_ANY_MANUF &&
1210 +             match->manuf != core->id.manuf) ||
1211 +            (match->id != BCMA_ANY_ID && match->id != core->id.id) ||
1212 +            (match->rev != BCMA_ANY_REV && match->rev != core->id.rev) ||
1213 +            (match->class != BCMA_ANY_CLASS && match->class != core->id.class)
1214 +           )) {
1215 +               bcma_erom_skip_component(bus, eromptr);
1216 +               return -ENODEV;
1217 +       }
1218 +
1219 +       /* get & parse master ports */
1220 +       for (i = 0; i < ports[0]; i++) {
1221 +               s32 mst_port_d = bcma_erom_get_mst_port(bus, eromptr);
1222 +               if (mst_port_d < 0)
1223 +                       return -EILSEQ;
1224 +       }
1225 +
1226 +       /* get & parse slave ports */
1227 +       for (i = 0; i < ports[1]; i++) {
1228 +               for (j = 0; ; j++) {
1229 +                       tmp = bcma_erom_get_addr_desc(bus, eromptr,
1230 +                               SCAN_ADDR_TYPE_SLAVE, i);
1231 +                       if (tmp < 0) {
1232 +                               /* no more entries for port _i_ */
1233 +                               /* pr_debug("erom: slave port %d "
1234 +                                * "has %d descriptors\n", i, j); */
1235 +                               break;
1236 +                       } else {
1237 +                               if (i == 0 && j == 0)
1238 +                                       core->addr = tmp;
1239 +                       }
1240 +               }
1241 +       }
1242 +
1243 +       /* get & parse master wrappers */
1244 +       for (i = 0; i < wrappers[0]; i++) {
1245 +               for (j = 0; ; j++) {
1246 +                       tmp = bcma_erom_get_addr_desc(bus, eromptr,
1247 +                               SCAN_ADDR_TYPE_MWRAP, i);
1248 +                       if (tmp < 0) {
1249 +                               /* no more entries for port _i_ */
1250 +                               /* pr_debug("erom: master wrapper %d "
1251 +                                * "has %d descriptors\n", i, j); */
1252 +                               break;
1253 +                       } else {
1254 +                               if (i == 0 && j == 0)
1255 +                                       core->wrap = tmp;
1256 +                       }
1257 +               }
1258 +       }
1259 +
1260 +       /* get & parse slave wrappers */
1261 +       for (i = 0; i < wrappers[1]; i++) {
1262 +               u8 hack = (ports[1] == 1) ? 0 : 1;
1263 +               for (j = 0; ; j++) {
1264 +                       tmp = bcma_erom_get_addr_desc(bus, eromptr,
1265 +                               SCAN_ADDR_TYPE_SWRAP, i + hack);
1266 +                       if (tmp < 0) {
1267 +                               /* no more entries for port _i_ */
1268 +                               /* pr_debug("erom: master wrapper %d "
1269 +                                * has %d descriptors\n", i, j); */
1270 +                               break;
1271 +                       } else {
1272 +                               if (wrappers[0] == 0 && !i && !j)
1273 +                                       core->wrap = tmp;
1274 +                       }
1275 +               }
1276 +       }
1277 +       if (bus->hosttype == BCMA_HOSTTYPE_SOC) {
1278 +               core->io_addr = ioremap_nocache(core->addr, BCMA_CORE_SIZE);
1279 +               if (!core->io_addr)
1280 +                       return -ENOMEM;
1281 +               core->io_wrap = ioremap_nocache(core->wrap, BCMA_CORE_SIZE);
1282 +               if (!core->io_wrap) {
1283 +                       iounmap(core->io_addr);
1284 +                       return -ENOMEM;
1285 +               }
1286 +       }
1287 +       return 0;
1288 +}
1289 +
1290 +void bcma_init_bus(struct bcma_bus *bus)
1291 +{
1292         s32 tmp;
1293 -       u8 i, j;
1294
1295 -       int err;
1296 +       if (bus->init_done)
1297 +               return;
1298
1299         INIT_LIST_HEAD(&bus->cores);
1300         bus->nr_cores = 0;
1301 @@ -222,9 +366,27 @@ int bcma_bus_scan(struct bcma_bus *bus)
1302         bus->chipinfo.id = (tmp & BCMA_CC_ID_ID) >> BCMA_CC_ID_ID_SHIFT;
1303         bus->chipinfo.rev = (tmp & BCMA_CC_ID_REV) >> BCMA_CC_ID_REV_SHIFT;
1304         bus->chipinfo.pkg = (tmp & BCMA_CC_ID_PKG) >> BCMA_CC_ID_PKG_SHIFT;
1305 +       bus->init_done = true;
1306 +}
1307 +
1308 +int bcma_bus_scan(struct bcma_bus *bus)
1309 +{
1310 +       u32 erombase;
1311 +       u32 __iomem *eromptr, *eromend;
1312 +
1313 +       int err, core_num = 0;
1314 +
1315 +       bcma_init_bus(bus);
1316
1317         erombase = bcma_scan_read32(bus, 0, BCMA_CC_EROM);
1318 -       eromptr = bus->mmio;
1319 +       if (bus->hosttype == BCMA_HOSTTYPE_SOC) {
1320 +               eromptr = ioremap_nocache(erombase, BCMA_CORE_SIZE);
1321 +               if (!eromptr)
1322 +                       return -ENOMEM;
1323 +       } else {
1324 +               eromptr = bus->mmio;
1325 +       }
1326 +
1327         eromend = eromptr + BCMA_CORE_SIZE / sizeof(u32);
1328
1329         bcma_scan_switch_core(bus, erombase);
1330 @@ -236,125 +398,89 @@ int bcma_bus_scan(struct bcma_bus *bus)
1331                 INIT_LIST_HEAD(&core->list);
1332                 core->bus = bus;
1333
1334 -               /* get CIs */
1335 -               cia = bcma_erom_get_ci(bus, &eromptr);
1336 -               if (cia < 0) {
1337 -                       bcma_erom_push_ent(&eromptr);
1338 -                       if (bcma_erom_is_end(bus, &eromptr))
1339 -                               break;
1340 -                       err= -EILSEQ;
1341 -                       goto out;
1342 -               }
1343 -               cib = bcma_erom_get_ci(bus, &eromptr);
1344 -               if (cib < 0) {
1345 -                       err= -EILSEQ;
1346 -                       goto out;
1347 -               }
1348 -
1349 -               /* parse CIs */
1350 -               core->id.class = (cia & SCAN_CIA_CLASS) >> SCAN_CIA_CLASS_SHIFT;
1351 -               core->id.id = (cia & SCAN_CIA_ID) >> SCAN_CIA_ID_SHIFT;
1352 -               core->id.manuf = (cia & SCAN_CIA_MANUF) >> SCAN_CIA_MANUF_SHIFT;
1353 -               ports[0] = (cib & SCAN_CIB_NMP) >> SCAN_CIB_NMP_SHIFT;
1354 -               ports[1] = (cib & SCAN_CIB_NSP) >> SCAN_CIB_NSP_SHIFT;
1355 -               wrappers[0] = (cib & SCAN_CIB_NMW) >> SCAN_CIB_NMW_SHIFT;
1356 -               wrappers[1] = (cib & SCAN_CIB_NSW) >> SCAN_CIB_NSW_SHIFT;
1357 -               core->id.rev = (cib & SCAN_CIB_REV) >> SCAN_CIB_REV_SHIFT;
1358 -
1359 -               if (((core->id.manuf == BCMA_MANUF_ARM) &&
1360 -                    (core->id.id == 0xFFF)) ||
1361 -                   (ports[1] == 0)) {
1362 -                       bcma_erom_skip_component(bus, &eromptr);
1363 +               err = bcma_get_next_core(bus, &eromptr, NULL, core_num, core);
1364 +               if (err == -ENODEV) {
1365 +                       core_num++;
1366                         continue;
1367 -               }
1368 -
1369 -               /* check if component is a core at all */
1370 -               if (wrappers[0] + wrappers[1] == 0) {
1371 -                       /* we could save addrl of the router
1372 -                       if (cid == BCMA_CORE_OOB_ROUTER)
1373 -                        */
1374 -                       bcma_erom_skip_component(bus, &eromptr);
1375 +               } else if (err == -ENXIO)
1376                         continue;
1377 -               }
1378 +               else if (err == -ESPIPE)
1379 +                       break;
1380 +               else if (err < 0)
1381 +                       return err;
1382
1383 -               if (bcma_erom_is_bridge(bus, &eromptr)) {
1384 -                       bcma_erom_skip_component(bus, &eromptr);
1385 -                       continue;
1386 -               }
1387 +               core->core_index = core_num++;
1388 +               bus->nr_cores++;
1389
1390 -               /* get & parse master ports */
1391 -               for (i = 0; i < ports[0]; i++) {
1392 -                       u32 mst_port_d = bcma_erom_get_mst_port(bus, &eromptr);
1393 -                       if (mst_port_d < 0) {
1394 -                               err= -EILSEQ;
1395 -                               goto out;
1396 -                       }
1397 -               }
1398 +               pr_info("Core %d found: %s "
1399 +                       "(manuf 0x%03X, id 0x%03X, rev 0x%02X, class 0x%X)\n",
1400 +                       core->core_index, bcma_device_name(&core->id),
1401 +                       core->id.manuf, core->id.id, core->id.rev,
1402 +                       core->id.class);
1403
1404 -               /* get & parse slave ports */
1405 -               for (i = 0; i < ports[1]; i++) {
1406 -                       for (j = 0; ; j++) {
1407 -                               tmp = bcma_erom_get_addr_desc(bus, &eromptr,
1408 -                                       SCAN_ADDR_TYPE_SLAVE, i);
1409 -                               if (tmp < 0) {
1410 -                                       /* no more entries for port _i_ */
1411 -                                       /* pr_debug("erom: slave port %d "
1412 -                                        * "has %d descriptors\n", i, j); */
1413 -                                       break;
1414 -                               } else {
1415 -                                       if (i == 0 && j == 0)
1416 -                                               core->addr = tmp;
1417 -                               }
1418 -                       }
1419 -               }
1420 +               list_add(&core->list, &bus->cores);
1421 +       }
1422
1423 -               /* get & parse master wrappers */
1424 -               for (i = 0; i < wrappers[0]; i++) {
1425 -                       for (j = 0; ; j++) {
1426 -                               tmp = bcma_erom_get_addr_desc(bus, &eromptr,
1427 -                                       SCAN_ADDR_TYPE_MWRAP, i);
1428 -                               if (tmp < 0) {
1429 -                                       /* no more entries for port _i_ */
1430 -                                       /* pr_debug("erom: master wrapper %d "
1431 -                                        * "has %d descriptors\n", i, j); */
1432 -                                       break;
1433 -                               } else {
1434 -                                       if (i == 0 && j == 0)
1435 -                                               core->wrap = tmp;
1436 -                               }
1437 -                       }
1438 -               }
1439 +       if (bus->hosttype == BCMA_HOSTTYPE_SOC)
1440 +               iounmap(eromptr);
1441
1442 -               /* get & parse slave wrappers */
1443 -               for (i = 0; i < wrappers[1]; i++) {
1444 -                       u8 hack = (ports[1] == 1) ? 0 : 1;
1445 -                       for (j = 0; ; j++) {
1446 -                               tmp = bcma_erom_get_addr_desc(bus, &eromptr,
1447 -                                       SCAN_ADDR_TYPE_SWRAP, i + hack);
1448 -                               if (tmp < 0) {
1449 -                                       /* no more entries for port _i_ */
1450 -                                       /* pr_debug("erom: master wrapper %d "
1451 -                                        * has %d descriptors\n", i, j); */
1452 -                                       break;
1453 -                               } else {
1454 -                                       if (wrappers[0] == 0 && !i && !j)
1455 -                                               core->wrap = tmp;
1456 -                               }
1457 -                       }
1458 -               }
1459 +       return 0;
1460 +}
1461 +
1462 +int __init bcma_bus_scan_early(struct bcma_bus *bus,
1463 +                              struct bcma_device_id *match,
1464 +                              struct bcma_device *core)
1465 +{
1466 +       u32 erombase;
1467 +       u32 __iomem *eromptr, *eromend;
1468
1469 +       int err = -ENODEV;
1470 +       int core_num = 0;
1471 +
1472 +       erombase = bcma_scan_read32(bus, 0, BCMA_CC_EROM);
1473 +       if (bus->hosttype == BCMA_HOSTTYPE_SOC) {
1474 +               eromptr = ioremap_nocache(erombase, BCMA_CORE_SIZE);
1475 +               if (!eromptr)
1476 +                       return -ENOMEM;
1477 +       } else {
1478 +               eromptr = bus->mmio;
1479 +       }
1480 +
1481 +       eromend = eromptr + BCMA_CORE_SIZE / sizeof(u32);
1482 +
1483 +       bcma_scan_switch_core(bus, erombase);
1484 +
1485 +       while (eromptr < eromend) {
1486 +               memset(core, 0, sizeof(*core));
1487 +               INIT_LIST_HEAD(&core->list);
1488 +               core->bus = bus;
1489 +
1490 +               err = bcma_get_next_core(bus, &eromptr, match, core_num, core);
1491 +               if (err == -ENODEV) {
1492 +                       core_num++;
1493 +                       continue;
1494 +               } else if (err == -ENXIO)
1495 +                       continue;
1496 +               else if (err == -ESPIPE)
1497 +                       break;
1498 +               else if (err < 0)
1499 +                       return err;
1500 +
1501 +               core->core_index = core_num++;
1502 +               bus->nr_cores++;
1503                 pr_info("Core %d found: %s "
1504                         "(manuf 0x%03X, id 0x%03X, rev 0x%02X, class 0x%X)\n",
1505 -                       bus->nr_cores, bcma_device_name(&core->id),
1506 +                       core->core_index, bcma_device_name(&core->id),
1507                         core->id.manuf, core->id.id, core->id.rev,
1508                         core->id.class);
1509
1510 -               core->core_index = bus->nr_cores++;
1511                 list_add(&core->list, &bus->cores);
1512 -               continue;
1513 -out:
1514 -               return err;
1515 +               err = 0;
1516 +               break;
1517         }
1518
1519 -       return 0;
1520 +       if (bus->hosttype == BCMA_HOSTTYPE_SOC)
1521 +               iounmap(eromptr);
1522 +
1523 +       return err;
1524  }
1525 --- a/drivers/bcma/sprom.c
1526 +++ b/drivers/bcma/sprom.c
1527 @@ -129,10 +129,80 @@ static void bcma_sprom_extract_r8(struct
1528         u16 v;
1529         int i;
1530
1531 +       bus->sprom.revision = sprom[SSB_SPROMSIZE_WORDS_R4 - 1] &
1532 +               SSB_SPROM_REVISION_REV;
1533 +
1534         for (i = 0; i < 3; i++) {
1535                 v = sprom[SPOFF(SSB_SPROM8_IL0MAC) + i];
1536                 *(((__be16 *)bus->sprom.il0mac) + i) = cpu_to_be16(v);
1537         }
1538 +
1539 +       bus->sprom.board_rev = sprom[SPOFF(SSB_SPROM8_BOARDREV)];
1540 +
1541 +       bus->sprom.txpid2g[0] = (sprom[SPOFF(SSB_SPROM4_TXPID2G01)] &
1542 +            SSB_SPROM4_TXPID2G0) >> SSB_SPROM4_TXPID2G0_SHIFT;
1543 +       bus->sprom.txpid2g[1] = (sprom[SPOFF(SSB_SPROM4_TXPID2G01)] &
1544 +            SSB_SPROM4_TXPID2G1) >> SSB_SPROM4_TXPID2G1_SHIFT;
1545 +       bus->sprom.txpid2g[2] = (sprom[SPOFF(SSB_SPROM4_TXPID2G23)] &
1546 +            SSB_SPROM4_TXPID2G2) >> SSB_SPROM4_TXPID2G2_SHIFT;
1547 +       bus->sprom.txpid2g[3] = (sprom[SPOFF(SSB_SPROM4_TXPID2G23)] &
1548 +            SSB_SPROM4_TXPID2G3) >> SSB_SPROM4_TXPID2G3_SHIFT;
1549 +
1550 +       bus->sprom.txpid5gl[0] = (sprom[SPOFF(SSB_SPROM4_TXPID5GL01)] &
1551 +            SSB_SPROM4_TXPID5GL0) >> SSB_SPROM4_TXPID5GL0_SHIFT;
1552 +       bus->sprom.txpid5gl[1] = (sprom[SPOFF(SSB_SPROM4_TXPID5GL01)] &
1553 +            SSB_SPROM4_TXPID5GL1) >> SSB_SPROM4_TXPID5GL1_SHIFT;
1554 +       bus->sprom.txpid5gl[2] = (sprom[SPOFF(SSB_SPROM4_TXPID5GL23)] &
1555 +            SSB_SPROM4_TXPID5GL2) >> SSB_SPROM4_TXPID5GL2_SHIFT;
1556 +       bus->sprom.txpid5gl[3] = (sprom[SPOFF(SSB_SPROM4_TXPID5GL23)] &
1557 +            SSB_SPROM4_TXPID5GL3) >> SSB_SPROM4_TXPID5GL3_SHIFT;
1558 +
1559 +       bus->sprom.txpid5g[0] = (sprom[SPOFF(SSB_SPROM4_TXPID5G01)] &
1560 +            SSB_SPROM4_TXPID5G0) >> SSB_SPROM4_TXPID5G0_SHIFT;
1561 +       bus->sprom.txpid5g[1] = (sprom[SPOFF(SSB_SPROM4_TXPID5G01)] &
1562 +            SSB_SPROM4_TXPID5G1) >> SSB_SPROM4_TXPID5G1_SHIFT;
1563 +       bus->sprom.txpid5g[2] = (sprom[SPOFF(SSB_SPROM4_TXPID5G23)] &
1564 +            SSB_SPROM4_TXPID5G2) >> SSB_SPROM4_TXPID5G2_SHIFT;
1565 +       bus->sprom.txpid5g[3] = (sprom[SPOFF(SSB_SPROM4_TXPID5G23)] &
1566 +            SSB_SPROM4_TXPID5G3) >> SSB_SPROM4_TXPID5G3_SHIFT;
1567 +
1568 +       bus->sprom.txpid5gh[0] = (sprom[SPOFF(SSB_SPROM4_TXPID5GH01)] &
1569 +            SSB_SPROM4_TXPID5GH0) >> SSB_SPROM4_TXPID5GH0_SHIFT;
1570 +       bus->sprom.txpid5gh[1] = (sprom[SPOFF(SSB_SPROM4_TXPID5GH01)] &
1571 +            SSB_SPROM4_TXPID5GH1) >> SSB_SPROM4_TXPID5GH1_SHIFT;
1572 +       bus->sprom.txpid5gh[2] = (sprom[SPOFF(SSB_SPROM4_TXPID5GH23)] &
1573 +            SSB_SPROM4_TXPID5GH2) >> SSB_SPROM4_TXPID5GH2_SHIFT;
1574 +       bus->sprom.txpid5gh[3] = (sprom[SPOFF(SSB_SPROM4_TXPID5GH23)] &
1575 +            SSB_SPROM4_TXPID5GH3) >> SSB_SPROM4_TXPID5GH3_SHIFT;
1576 +
1577 +       bus->sprom.boardflags_lo = sprom[SPOFF(SSB_SPROM8_BFLLO)];
1578 +       bus->sprom.boardflags_hi = sprom[SPOFF(SSB_SPROM8_BFLHI)];
1579 +       bus->sprom.boardflags2_lo = sprom[SPOFF(SSB_SPROM8_BFL2LO)];
1580 +       bus->sprom.boardflags2_hi = sprom[SPOFF(SSB_SPROM8_BFL2HI)];
1581 +
1582 +       bus->sprom.country_code = sprom[SPOFF(SSB_SPROM8_CCODE)];
1583 +
1584 +       bus->sprom.fem.ghz2.tssipos = (sprom[SPOFF(SSB_SPROM8_FEM2G)] &
1585 +               SSB_SROM8_FEM_TSSIPOS) >> SSB_SROM8_FEM_TSSIPOS_SHIFT;
1586 +       bus->sprom.fem.ghz2.extpa_gain = (sprom[SPOFF(SSB_SPROM8_FEM2G)] &
1587 +               SSB_SROM8_FEM_EXTPA_GAIN) >> SSB_SROM8_FEM_EXTPA_GAIN_SHIFT;
1588 +       bus->sprom.fem.ghz2.pdet_range = (sprom[SPOFF(SSB_SPROM8_FEM2G)] &
1589 +               SSB_SROM8_FEM_PDET_RANGE) >> SSB_SROM8_FEM_PDET_RANGE_SHIFT;
1590 +       bus->sprom.fem.ghz2.tr_iso = (sprom[SPOFF(SSB_SPROM8_FEM2G)] &
1591 +               SSB_SROM8_FEM_TR_ISO) >> SSB_SROM8_FEM_TR_ISO_SHIFT;
1592 +       bus->sprom.fem.ghz2.antswlut = (sprom[SPOFF(SSB_SPROM8_FEM2G)] &
1593 +               SSB_SROM8_FEM_ANTSWLUT) >> SSB_SROM8_FEM_ANTSWLUT_SHIFT;
1594 +
1595 +       bus->sprom.fem.ghz5.tssipos = (sprom[SPOFF(SSB_SPROM8_FEM5G)] &
1596 +               SSB_SROM8_FEM_TSSIPOS) >> SSB_SROM8_FEM_TSSIPOS_SHIFT;
1597 +       bus->sprom.fem.ghz5.extpa_gain = (sprom[SPOFF(SSB_SPROM8_FEM5G)] &
1598 +               SSB_SROM8_FEM_EXTPA_GAIN) >> SSB_SROM8_FEM_EXTPA_GAIN_SHIFT;
1599 +       bus->sprom.fem.ghz5.pdet_range = (sprom[SPOFF(SSB_SPROM8_FEM5G)] &
1600 +               SSB_SROM8_FEM_PDET_RANGE) >> SSB_SROM8_FEM_PDET_RANGE_SHIFT;
1601 +       bus->sprom.fem.ghz5.tr_iso = (sprom[SPOFF(SSB_SPROM8_FEM5G)] &
1602 +               SSB_SROM8_FEM_TR_ISO) >> SSB_SROM8_FEM_TR_ISO_SHIFT;
1603 +       bus->sprom.fem.ghz5.antswlut = (sprom[SPOFF(SSB_SPROM8_FEM5G)] &
1604 +               SSB_SROM8_FEM_ANTSWLUT) >> SSB_SROM8_FEM_ANTSWLUT_SHIFT;
1605  }
1606
1607  int bcma_sprom_get(struct bcma_bus *bus)
1608 @@ -152,6 +222,9 @@ int bcma_sprom_get(struct bcma_bus *bus)
1609         if (!sprom)
1610                 return -ENOMEM;
1611
1612 +       if (bus->chipinfo.id == 0x4331)
1613 +               bcma_chipco_bcm4331_ext_pa_lines_ctl(&bus->drv_cc, false);
1614 +
1615         /* Most cards have SPROM moved by additional offset 0x30 (48 dwords).
1616          * According to brcm80211 this applies to cards with PCIe rev >= 6
1617          * TODO: understand this condition and use it */
1618 @@ -159,6 +232,9 @@ int bcma_sprom_get(struct bcma_bus *bus)
1619                 BCMA_CC_SPROM_PCIE6;
1620         bcma_sprom_read(bus, offset, sprom);
1621
1622 +       if (bus->chipinfo.id == 0x4331)
1623 +               bcma_chipco_bcm4331_ext_pa_lines_ctl(&bus->drv_cc, true);
1624 +
1625         err = bcma_sprom_valid(sprom);
1626         if (err)
1627                 goto out;
1628 --- a/include/linux/bcma/bcma.h
1629 +++ b/include/linux/bcma/bcma.h
1630 @@ -6,6 +6,7 @@
1631
1632  #include <linux/bcma/bcma_driver_chipcommon.h>
1633  #include <linux/bcma/bcma_driver_pci.h>
1634 +#include <linux/bcma/bcma_driver_mips.h>
1635  #include <linux/ssb/ssb.h> /* SPROM sharing */
1636
1637  #include "bcma_regs.h"
1638 @@ -14,9 +15,9 @@ struct bcma_device;
1639  struct bcma_bus;
1640
1641  enum bcma_hosttype {
1642 -       BCMA_HOSTTYPE_NONE,
1643         BCMA_HOSTTYPE_PCI,
1644         BCMA_HOSTTYPE_SDIO,
1645 +       BCMA_HOSTTYPE_SOC,
1646  };
1647
1648  struct bcma_chipinfo {
1649 @@ -130,6 +131,7 @@ struct bcma_device {
1650
1651         struct device dev;
1652         struct device *dma_dev;
1653 +
1654         unsigned int irq;
1655         bool dev_registered;
1656
1657 @@ -138,6 +140,9 @@ struct bcma_device {
1658         u32 addr;
1659         u32 wrap;
1660
1661 +       void __iomem *io_addr;
1662 +       void __iomem *io_wrap;
1663 +
1664         void *drvdata;
1665         struct list_head list;
1666  };
1667 @@ -165,10 +170,9 @@ struct bcma_driver {
1668  };
1669  extern
1670  int __bcma_driver_register(struct bcma_driver *drv, struct module *owner);
1671 -static inline int bcma_driver_register(struct bcma_driver *drv)
1672 -{
1673 -       return __bcma_driver_register(drv, THIS_MODULE);
1674 -}
1675 +#define bcma_driver_register(drv) \
1676 +       __bcma_driver_register(drv, THIS_MODULE)
1677 +
1678  extern void bcma_driver_unregister(struct bcma_driver *drv);
1679
1680  struct bcma_bus {
1681 @@ -190,70 +194,93 @@ struct bcma_bus {
1682         struct bcma_device *mapped_core;
1683         struct list_head cores;
1684         u8 nr_cores;
1685 +       u8 init_done:1;
1686
1687         struct bcma_drv_cc drv_cc;
1688         struct bcma_drv_pci drv_pci;
1689 +       struct bcma_drv_mips drv_mips;
1690
1691         /* We decided to share SPROM struct with SSB as long as we do not need
1692          * any hacks for BCMA. This simplifies drivers code. */
1693         struct ssb_sprom sprom;
1694  };
1695
1696 -extern inline u32 bcma_read8(struct bcma_device *core, u16 offset)
1697 +static inline u32 bcma_read8(struct bcma_device *core, u16 offset)
1698  {
1699         return core->bus->ops->read8(core, offset);
1700  }
1701 -extern inline u32 bcma_read16(struct bcma_device *core, u16 offset)
1702 +static inline u32 bcma_read16(struct bcma_device *core, u16 offset)
1703  {
1704         return core->bus->ops->read16(core, offset);
1705  }
1706 -extern inline u32 bcma_read32(struct bcma_device *core, u16 offset)
1707 +static inline u32 bcma_read32(struct bcma_device *core, u16 offset)
1708  {
1709         return core->bus->ops->read32(core, offset);
1710  }
1711 -extern inline
1712 +static inline
1713  void bcma_write8(struct bcma_device *core, u16 offset, u32 value)
1714  {
1715         core->bus->ops->write8(core, offset, value);
1716  }
1717 -extern inline
1718 +static inline
1719  void bcma_write16(struct bcma_device *core, u16 offset, u32 value)
1720  {
1721         core->bus->ops->write16(core, offset, value);
1722  }
1723 -extern inline
1724 +static inline
1725  void bcma_write32(struct bcma_device *core, u16 offset, u32 value)
1726  {
1727         core->bus->ops->write32(core, offset, value);
1728  }
1729  #ifdef CONFIG_BCMA_BLOCKIO
1730 -extern inline void bcma_block_read(struct bcma_device *core, void *buffer,
1731 +static inline void bcma_block_read(struct bcma_device *core, void *buffer,
1732                                    size_t count, u16 offset, u8 reg_width)
1733  {
1734         core->bus->ops->block_read(core, buffer, count, offset, reg_width);
1735  }
1736 -extern inline void bcma_block_write(struct bcma_device *core, const void *buffer,
1737 -                                   size_t count, u16 offset, u8 reg_width)
1738 +static inline void bcma_block_write(struct bcma_device *core,
1739 +                                   const void *buffer, size_t count,
1740 +                                   u16 offset, u8 reg_width)
1741  {
1742         core->bus->ops->block_write(core, buffer, count, offset, reg_width);
1743  }
1744  #endif
1745 -extern inline u32 bcma_aread32(struct bcma_device *core, u16 offset)
1746 +static inline u32 bcma_aread32(struct bcma_device *core, u16 offset)
1747  {
1748         return core->bus->ops->aread32(core, offset);
1749  }
1750 -extern inline
1751 +static inline
1752  void bcma_awrite32(struct bcma_device *core, u16 offset, u32 value)
1753  {
1754         core->bus->ops->awrite32(core, offset, value);
1755  }
1756
1757 -#define bcma_mask32(cc, offset, mask) \
1758 -       bcma_write32(cc, offset, bcma_read32(cc, offset) & (mask))
1759 -#define bcma_set32(cc, offset, set) \
1760 -       bcma_write32(cc, offset, bcma_read32(cc, offset) | (set))
1761 -#define bcma_maskset32(cc, offset, mask, set) \
1762 -       bcma_write32(cc, offset, (bcma_read32(cc, offset) & (mask)) | (set))
1763 +static inline void bcma_mask32(struct bcma_device *cc, u16 offset, u32 mask)
1764 +{
1765 +       bcma_write32(cc, offset, bcma_read32(cc, offset) & mask);
1766 +}
1767 +static inline void bcma_set32(struct bcma_device *cc, u16 offset, u32 set)
1768 +{
1769 +       bcma_write32(cc, offset, bcma_read32(cc, offset) | set);
1770 +}
1771 +static inline void bcma_maskset32(struct bcma_device *cc,
1772 +                                 u16 offset, u32 mask, u32 set)
1773 +{
1774 +       bcma_write32(cc, offset, (bcma_read32(cc, offset) & mask) | set);
1775 +}
1776 +static inline void bcma_mask16(struct bcma_device *cc, u16 offset, u16 mask)
1777 +{
1778 +       bcma_write16(cc, offset, bcma_read16(cc, offset) & mask);
1779 +}
1780 +static inline void bcma_set16(struct bcma_device *cc, u16 offset, u16 set)
1781 +{
1782 +       bcma_write16(cc, offset, bcma_read16(cc, offset) | set);
1783 +}
1784 +static inline void bcma_maskset16(struct bcma_device *cc,
1785 +                                 u16 offset, u16 mask, u16 set)
1786 +{
1787 +       bcma_write16(cc, offset, (bcma_read16(cc, offset) & mask) | set);
1788 +}
1789
1790  extern bool bcma_core_is_enabled(struct bcma_device *core);
1791  extern void bcma_core_disable(struct bcma_device *core, u32 flags);
1792 --- a/include/linux/bcma/bcma_driver_chipcommon.h
1793 +++ b/include/linux/bcma/bcma_driver_chipcommon.h
1794 @@ -24,6 +24,7 @@
1795  #define   BCMA_CC_FLASHT_NONE          0x00000000      /* No flash */
1796  #define   BCMA_CC_FLASHT_STSER         0x00000100      /* ST serial flash */
1797  #define   BCMA_CC_FLASHT_ATSER         0x00000200      /* Atmel serial flash */
1798 +#define   BCMA_CC_FLASHT_NFLASH                0x00000200
1799  #define          BCMA_CC_FLASHT_PARA           0x00000700      /* Parallel flash */
1800  #define  BCMA_CC_CAP_PLLT              0x00038000      /* PLL Type */
1801  #define   BCMA_PLLTYPE_NONE            0x00000000
1802 @@ -178,6 +179,7 @@
1803  #define BCMA_CC_PROG_CFG               0x0120
1804  #define BCMA_CC_PROG_WAITCNT           0x0124
1805  #define BCMA_CC_FLASH_CFG              0x0128
1806 +#define  BCMA_CC_FLASH_CFG_DS          0x0010  /* Data size, 0=8bit, 1=16bit */
1807  #define BCMA_CC_FLASH_WAITCNT          0x012C
1808  /* 0x1E0 is defined as shared BCMA_CLKCTLST */
1809  #define BCMA_CC_HW_WORKAROUND          0x01E4 /* Hardware workaround (rev >= 20) */
1810 @@ -201,6 +203,7 @@
1811  #define BCMA_CC_PMU_CTL                        0x0600 /* PMU control */
1812  #define  BCMA_CC_PMU_CTL_ILP_DIV       0xFFFF0000 /* ILP div mask */
1813  #define  BCMA_CC_PMU_CTL_ILP_DIV_SHIFT 16
1814 +#define  BCMA_CC_PMU_CTL_PLL_UPD       0x00000400
1815  #define  BCMA_CC_PMU_CTL_NOILPONW      0x00000200 /* No ILP on wait */
1816  #define  BCMA_CC_PMU_CTL_HTREQEN       0x00000100 /* HT req enable */
1817  #define  BCMA_CC_PMU_CTL_ALPREQEN      0x00000080 /* ALP req enable */
1818 @@ -239,6 +242,64 @@
1819  #define BCMA_CC_SPROM                  0x0800 /* SPROM beginning */
1820  #define BCMA_CC_SPROM_PCIE6            0x0830 /* SPROM beginning on PCIe rev >= 6 */
1821
1822 +/* Divider allocation in 4716/47162/5356 */
1823 +#define BCMA_CC_PMU5_MAINPLL_CPU       1
1824 +#define BCMA_CC_PMU5_MAINPLL_MEM       2
1825 +#define BCMA_CC_PMU5_MAINPLL_SSB       3
1826 +
1827 +/* PLL usage in 4716/47162 */
1828 +#define BCMA_CC_PMU4716_MAINPLL_PLL0   12
1829 +
1830 +/* PLL usage in 5356/5357 */
1831 +#define BCMA_CC_PMU5356_MAINPLL_PLL0   0
1832 +#define BCMA_CC_PMU5357_MAINPLL_PLL0   0
1833 +
1834 +/* 4706 PMU */
1835 +#define BCMA_CC_PMU4706_MAINPLL_PLL0   0
1836 +
1837 +/* ALP clock on pre-PMU chips */
1838 +#define BCMA_CC_PMU_ALP_CLOCK          20000000
1839 +/* HT clock for systems with PMU-enabled chipcommon */
1840 +#define BCMA_CC_PMU_HT_CLOCK           80000000
1841 +
1842 +/* PMU rev 5 (& 6) */
1843 +#define BCMA_CC_PPL_P1P2_OFF           0
1844 +#define BCMA_CC_PPL_P1_MASK            0x0f000000
1845 +#define BCMA_CC_PPL_P1_SHIFT           24
1846 +#define BCMA_CC_PPL_P2_MASK            0x00f00000
1847 +#define BCMA_CC_PPL_P2_SHIFT           20
1848 +#define BCMA_CC_PPL_M14_OFF            1
1849 +#define BCMA_CC_PPL_MDIV_MASK          0x000000ff
1850 +#define BCMA_CC_PPL_MDIV_WIDTH         8
1851 +#define BCMA_CC_PPL_NM5_OFF            2
1852 +#define BCMA_CC_PPL_NDIV_MASK          0xfff00000
1853 +#define BCMA_CC_PPL_NDIV_SHIFT         20
1854 +#define BCMA_CC_PPL_FMAB_OFF           3
1855 +#define BCMA_CC_PPL_MRAT_MASK          0xf0000000
1856 +#define BCMA_CC_PPL_MRAT_SHIFT         28
1857 +#define BCMA_CC_PPL_ABRAT_MASK         0x08000000
1858 +#define BCMA_CC_PPL_ABRAT_SHIFT                27
1859 +#define BCMA_CC_PPL_FDIV_MASK          0x07ffffff
1860 +#define BCMA_CC_PPL_PLLCTL_OFF         4
1861 +#define BCMA_CC_PPL_PCHI_OFF           5
1862 +#define BCMA_CC_PPL_PCHI_MASK          0x0000003f
1863 +
1864 +/* BCM4331 ChipControl numbers. */
1865 +#define BCMA_CHIPCTL_4331_BT_COEXIST           BIT(0)  /* 0 disable */
1866 +#define BCMA_CHIPCTL_4331_SECI                 BIT(1)  /* 0 SECI is disabled (JATG functional) */
1867 +#define BCMA_CHIPCTL_4331_EXT_LNA              BIT(2)  /* 0 disable */
1868 +#define BCMA_CHIPCTL_4331_SPROM_GPIO13_15      BIT(3)  /* sprom/gpio13-15 mux */
1869 +#define BCMA_CHIPCTL_4331_EXTPA_EN             BIT(4)  /* 0 ext pa disable, 1 ext pa enabled */
1870 +#define BCMA_CHIPCTL_4331_GPIOCLK_ON_SPROMCS   BIT(5)  /* set drive out GPIO_CLK on sprom_cs pin */
1871 +#define BCMA_CHIPCTL_4331_PCIE_MDIO_ON_SPROMCS BIT(6)  /* use sprom_cs pin as PCIE mdio interface */
1872 +#define BCMA_CHIPCTL_4331_EXTPA_ON_GPIO2_5     BIT(7)  /* aband extpa will be at gpio2/5 and sprom_dout */
1873 +#define BCMA_CHIPCTL_4331_OVR_PIPEAUXCLKEN     BIT(8)  /* override core control on pipe_AuxClkEnable */
1874 +#define BCMA_CHIPCTL_4331_OVR_PIPEAUXPWRDOWN   BIT(9)  /* override core control on pipe_AuxPowerDown */
1875 +#define BCMA_CHIPCTL_4331_PCIE_AUXCLKEN                BIT(10) /* pcie_auxclkenable */
1876 +#define BCMA_CHIPCTL_4331_PCIE_PIPE_PLLDOWN    BIT(11) /* pcie_pipe_pllpowerdown */
1877 +#define BCMA_CHIPCTL_4331_BT_SHD0_ON_GPIO4     BIT(16) /* enable bt_shd0 at gpio4 */
1878 +#define BCMA_CHIPCTL_4331_BT_SHD1_ON_GPIO5     BIT(17) /* enable bt_shd1 at gpio5 */
1879 +
1880  /* Data for the PMU, if available.
1881   * Check availability with ((struct bcma_chipcommon)->capabilities & BCMA_CC_CAP_PMU)
1882   */
1883 @@ -247,14 +308,37 @@ struct bcma_chipcommon_pmu {
1884         u32 crystalfreq;        /* The active crystal frequency (in kHz) */
1885  };
1886
1887 +#ifdef CONFIG_BCMA_DRIVER_MIPS
1888 +struct bcma_pflash {
1889 +       u8 buswidth;
1890 +       u32 window;
1891 +       u32 window_size;
1892 +};
1893 +
1894 +struct bcma_serial_port {
1895 +       void *regs;
1896 +       unsigned long clockspeed;
1897 +       unsigned int irq;
1898 +       unsigned int baud_base;
1899 +       unsigned int reg_shift;
1900 +};
1901 +#endif /* CONFIG_BCMA_DRIVER_MIPS */
1902 +
1903  struct bcma_drv_cc {
1904         struct bcma_device *core;
1905         u32 status;
1906         u32 capabilities;
1907         u32 capabilities_ext;
1908 +       u8 setup_done:1;
1909         /* Fast Powerup Delay constant */
1910         u16 fast_pwrup_delay;
1911         struct bcma_chipcommon_pmu pmu;
1912 +#ifdef CONFIG_BCMA_DRIVER_MIPS
1913 +       struct bcma_pflash pflash;
1914 +
1915 +       int nr_serial_ports;
1916 +       struct bcma_serial_port serial_ports[4];
1917 +#endif /* CONFIG_BCMA_DRIVER_MIPS */
1918  };
1919
1920  /* Register access */
1921 @@ -275,6 +359,8 @@ extern void bcma_core_chipcommon_init(st
1922  extern void bcma_chipco_suspend(struct bcma_drv_cc *cc);
1923  extern void bcma_chipco_resume(struct bcma_drv_cc *cc);
1924
1925 +void bcma_chipco_bcm4331_ext_pa_lines_ctl(struct bcma_drv_cc *cc, bool enable);
1926 +
1927  extern void bcma_chipco_watchdog_timer_set(struct bcma_drv_cc *cc,
1928                                           u32 ticks);
1929
1930 @@ -293,4 +379,13 @@ u32 bcma_chipco_gpio_polarity(struct bcm
1931  /* PMU support */
1932  extern void bcma_pmu_init(struct bcma_drv_cc *cc);
1933
1934 +extern void bcma_chipco_pll_write(struct bcma_drv_cc *cc, u32 offset,
1935 +                                 u32 value);
1936 +extern void bcma_chipco_pll_maskset(struct bcma_drv_cc *cc, u32 offset,
1937 +                                   u32 mask, u32 set);
1938 +extern void bcma_chipco_chipctl_maskset(struct bcma_drv_cc *cc,
1939 +                                       u32 offset, u32 mask, u32 set);
1940 +extern void bcma_chipco_regctl_maskset(struct bcma_drv_cc *cc,
1941 +                                      u32 offset, u32 mask, u32 set);
1942 +
1943  #endif /* LINUX_BCMA_DRIVER_CC_H_ */
1944 --- /dev/null
1945 +++ b/include/linux/bcma/bcma_driver_mips.h
1946 @@ -0,0 +1,51 @@
1947 +#ifndef LINUX_BCMA_DRIVER_MIPS_H_
1948 +#define LINUX_BCMA_DRIVER_MIPS_H_
1949 +
1950 +#define BCMA_MIPS_IPSFLAG              0x0F08
1951 +/* which sbflags get routed to mips interrupt 1 */
1952 +#define  BCMA_MIPS_IPSFLAG_IRQ1                0x0000003F
1953 +#define  BCMA_MIPS_IPSFLAG_IRQ1_SHIFT  0
1954 +/* which sbflags get routed to mips interrupt 2 */
1955 +#define  BCMA_MIPS_IPSFLAG_IRQ2                0x00003F00
1956 +#define  BCMA_MIPS_IPSFLAG_IRQ2_SHIFT  8
1957 +/* which sbflags get routed to mips interrupt 3 */
1958 +#define  BCMA_MIPS_IPSFLAG_IRQ3                0x003F0000
1959 +#define  BCMA_MIPS_IPSFLAG_IRQ3_SHIFT  16
1960 +/* which sbflags get routed to mips interrupt 4 */
1961 +#define  BCMA_MIPS_IPSFLAG_IRQ4                0x3F000000
1962 +#define  BCMA_MIPS_IPSFLAG_IRQ4_SHIFT  24
1963 +
1964 +/* MIPS 74K core registers */
1965 +#define BCMA_MIPS_MIPS74K_CORECTL      0x0000
1966 +#define BCMA_MIPS_MIPS74K_EXCEPTBASE   0x0004
1967 +#define BCMA_MIPS_MIPS74K_BIST         0x000C
1968 +#define BCMA_MIPS_MIPS74K_INTMASK_INT0 0x0014
1969 +#define BCMA_MIPS_MIPS74K_INTMASK(int) \
1970 +       ((int) * 4 + BCMA_MIPS_MIPS74K_INTMASK_INT0)
1971 +#define BCMA_MIPS_MIPS74K_NMIMASK      0x002C
1972 +#define BCMA_MIPS_MIPS74K_GPIOSEL      0x0040
1973 +#define BCMA_MIPS_MIPS74K_GPIOOUT      0x0044
1974 +#define BCMA_MIPS_MIPS74K_GPIOEN       0x0048
1975 +#define BCMA_MIPS_MIPS74K_CLKCTLST     0x01E0
1976 +
1977 +#define BCMA_MIPS_OOBSELOUTA30         0x100
1978 +
1979 +struct bcma_device;
1980 +
1981 +struct bcma_drv_mips {
1982 +       struct bcma_device *core;
1983 +       u8 setup_done:1;
1984 +       unsigned int assigned_irqs;
1985 +};
1986 +
1987 +#ifdef CONFIG_BCMA_DRIVER_MIPS
1988 +extern void bcma_core_mips_init(struct bcma_drv_mips *mcore);
1989 +#else
1990 +static inline void bcma_core_mips_init(struct bcma_drv_mips *mcore) { }
1991 +#endif
1992 +
1993 +extern u32 bcma_cpu_clock(struct bcma_drv_mips *mcore);
1994 +
1995 +extern unsigned int bcma_core_mips_irq(struct bcma_device *dev);
1996 +
1997 +#endif /* LINUX_BCMA_DRIVER_MIPS_H_ */
1998 --- /dev/null
1999 +++ b/include/linux/bcma/bcma_soc.h
2000 @@ -0,0 +1,16 @@
2001 +#ifndef LINUX_BCMA_SOC_H_
2002 +#define LINUX_BCMA_SOC_H_
2003 +
2004 +#include <linux/bcma/bcma.h>
2005 +
2006 +struct bcma_soc {
2007 +       struct bcma_bus bus;
2008 +       struct bcma_device core_cc;
2009 +       struct bcma_device core_mips;
2010 +};
2011 +
2012 +int __init bcma_host_soc_register(struct bcma_soc *soc);
2013 +
2014 +int bcma_bus_register(struct bcma_bus *bus);
2015 +
2016 +#endif /* LINUX_BCMA_SOC_H_ */