target/linux/generic/patches-4.1/020-ssb-backport.patch

   1 --- a/arch/mips/bcm47xx/Kconfig
   2 +++ b/arch/mips/bcm47xx/Kconfig
   3 @@ -4,6 +4,7 @@ config BCM47XX_SSB
   4         bool "SSB Support for Broadcom BCM47XX"
   5         select SYS_HAS_CPU_BMIPS32_3300
   6         select SSB
   7 +       select SSB_HOST_SOC
   8         select SSB_DRIVER_MIPS
   9         select SSB_DRIVER_EXTIF
  10         select SSB_EMBEDDED
  11 --- a/drivers/ssb/Kconfig
  12 +++ b/drivers/ssb/Kconfig
  13 @@ -80,6 +80,15 @@ config SSB_SDIOHOST
  14
  15           If unsure, say N
  16
  17 +config SSB_HOST_SOC
  18 +       bool "Support for SSB bus on SoC"
  19 +       depends on SSB
  20 +       help
  21 +         Host interface for a SSB directly mapped into memory. This is
  22 +         for some Broadcom SoCs from the BCM47xx and BCM53xx lines.
  23 +
  24 +         If unsure, say N
  25 +
  26  config SSB_SILENT
  27         bool "No SSB kernel messages"
  28         depends on SSB && EXPERT
  29 --- a/drivers/ssb/Makefile
  30 +++ b/drivers/ssb/Makefile
  31 @@ -5,8 +5,9 @@ ssb-$(CONFIG_SSB_SPROM)                 += sprom.o
  32
  33  # host support
  34  ssb-$(CONFIG_SSB_PCIHOST)              += pci.o pcihost_wrapper.o
  35 -ssb-$(CONFIG_SSB_PCMCIAHOST)           += pcmcia.o
  36 +ssb-$(CONFIG_SSB_PCMCIAHOST)           += pcmcia.o bridge_pcmcia_80211.o
  37  ssb-$(CONFIG_SSB_SDIOHOST)             += sdio.o
  38 +ssb-$(CONFIG_SSB_HOST_SOC)             += host_soc.o
  39
  40  # built-in drivers
  41  ssb-y                                  += driver_chipcommon.o
  42 --- /dev/null
  43 +++ b/drivers/ssb/bridge_pcmcia_80211.c
  44 @@ -0,0 +1,128 @@
  45 +/*
  46 + * Broadcom 43xx PCMCIA-SSB bridge module
  47 + *
  48 + * Copyright (c) 2007 Michael Buesch <m@bues.ch>
  49 + *
  50 + * Licensed under the GNU/GPL. See COPYING for details.
  51 + */
  52 +
  53 +#include <linux/ssb/ssb.h>
  54 +#include <linux/slab.h>
  55 +#include <linux/module.h>
  56 +
  57 +#include <pcmcia/cistpl.h>
  58 +#include <pcmcia/ciscode.h>
  59 +#include <pcmcia/ds.h>
  60 +#include <pcmcia/cisreg.h>
  61 +
  62 +#include "ssb_private.h"
  63 +
  64 +static const struct pcmcia_device_id ssb_host_pcmcia_tbl[] = {
  65 +       PCMCIA_DEVICE_MANF_CARD(0x2D0, 0x448),
  66 +       PCMCIA_DEVICE_MANF_CARD(0x2D0, 0x476),
  67 +       PCMCIA_DEVICE_NULL,
  68 +};
  69 +
  70 +MODULE_DEVICE_TABLE(pcmcia, ssb_host_pcmcia_tbl);
  71 +
  72 +static int ssb_host_pcmcia_probe(struct pcmcia_device *dev)
  73 +{
  74 +       struct ssb_bus *ssb;
  75 +       int err = -ENOMEM;
  76 +       int res = 0;
  77 +
  78 +       ssb = kzalloc(sizeof(*ssb), GFP_KERNEL);
  79 +       if (!ssb)
  80 +               goto out_error;
  81 +
  82 +       err = -ENODEV;
  83 +
  84 +       dev->config_flags |= CONF_ENABLE_IRQ;
  85 +
  86 +       dev->resource[2]->flags |=  WIN_ENABLE | WIN_DATA_WIDTH_16 |
  87 +                        WIN_USE_WAIT;
  88 +       dev->resource[2]->start = 0;
  89 +       dev->resource[2]->end = SSB_CORE_SIZE;
  90 +       res = pcmcia_request_window(dev, dev->resource[2], 250);
  91 +       if (res != 0)
  92 +               goto err_kfree_ssb;
  93 +
  94 +       res = pcmcia_map_mem_page(dev, dev->resource[2], 0);
  95 +       if (res != 0)
  96 +               goto err_disable;
  97 +
  98 +       if (!dev->irq)
  99 +               goto err_disable;
 100 +
 101 +       res = pcmcia_enable_device(dev);
 102 +       if (res != 0)
 103 +               goto err_disable;
 104 +
 105 +       err = ssb_bus_pcmciabus_register(ssb, dev, dev->resource[2]->start);
 106 +       if (err)
 107 +               goto err_disable;
 108 +       dev->priv = ssb;
 109 +
 110 +       return 0;
 111 +
 112 +err_disable:
 113 +       pcmcia_disable_device(dev);
 114 +err_kfree_ssb:
 115 +       kfree(ssb);
 116 +out_error:
 117 +       ssb_err("Initialization failed (%d, %d)\n", res, err);
 118 +       return err;
 119 +}
 120 +
 121 +static void ssb_host_pcmcia_remove(struct pcmcia_device *dev)
 122 +{
 123 +       struct ssb_bus *ssb = dev->priv;
 124 +
 125 +       ssb_bus_unregister(ssb);
 126 +       pcmcia_disable_device(dev);
 127 +       kfree(ssb);
 128 +       dev->priv = NULL;
 129 +}
 130 +
 131 +#ifdef CONFIG_PM
 132 +static int ssb_host_pcmcia_suspend(struct pcmcia_device *dev)
 133 +{
 134 +       struct ssb_bus *ssb = dev->priv;
 135 +
 136 +       return ssb_bus_suspend(ssb);
 137 +}
 138 +
 139 +static int ssb_host_pcmcia_resume(struct pcmcia_device *dev)
 140 +{
 141 +       struct ssb_bus *ssb = dev->priv;
 142 +
 143 +       return ssb_bus_resume(ssb);
 144 +}
 145 +#else /* CONFIG_PM */
 146 +# define ssb_host_pcmcia_suspend               NULL
 147 +# define ssb_host_pcmcia_resume                NULL
 148 +#endif /* CONFIG_PM */
 149 +
 150 +static struct pcmcia_driver ssb_host_pcmcia_driver = {
 151 +       .owner          = THIS_MODULE,
 152 +       .name           = "ssb-pcmcia",
 153 +       .id_table       = ssb_host_pcmcia_tbl,
 154 +       .probe          = ssb_host_pcmcia_probe,
 155 +       .remove         = ssb_host_pcmcia_remove,
 156 +       .suspend        = ssb_host_pcmcia_suspend,
 157 +       .resume         = ssb_host_pcmcia_resume,
 158 +};
 159 +
 160 +/*
 161 + * These are not module init/exit functions!
 162 + * The module_pcmcia_driver() helper cannot be used here.
 163 + */
 164 +int ssb_host_pcmcia_init(void)
 165 +{
 166 +       return pcmcia_register_driver(&ssb_host_pcmcia_driver);
 167 +}
 168 +
 169 +void ssb_host_pcmcia_exit(void)
 170 +{
 171 +       pcmcia_unregister_driver(&ssb_host_pcmcia_driver);
 172 +}
 173 --- /dev/null
 174 +++ b/drivers/ssb/host_soc.c
 175 @@ -0,0 +1,173 @@
 176 +/*
 177 + * Sonics Silicon Backplane SoC host related functions.
 178 + * Subsystem core
 179 + *
 180 + * Copyright 2005, Broadcom Corporation
 181 + * Copyright 2006, 2007, Michael Buesch <m@bues.ch>
 182 + *
 183 + * Licensed under the GNU/GPL. See COPYING for details.
 184 + */
 185 +
 186 +#include <linux/ssb/ssb.h>
 187 +
 188 +#include "ssb_private.h"
 189 +
 190 +static u8 ssb_host_soc_read8(struct ssb_device *dev, u16 offset)
 191 +{
 192 +       struct ssb_bus *bus = dev->bus;
 193 +
 194 +       offset += dev->core_index * SSB_CORE_SIZE;
 195 +       return readb(bus->mmio + offset);
 196 +}
 197 +
 198 +static u16 ssb_host_soc_read16(struct ssb_device *dev, u16 offset)
 199 +{
 200 +       struct ssb_bus *bus = dev->bus;
 201 +
 202 +       offset += dev->core_index * SSB_CORE_SIZE;
 203 +       return readw(bus->mmio + offset);
 204 +}
 205 +
 206 +static u32 ssb_host_soc_read32(struct ssb_device *dev, u16 offset)
 207 +{
 208 +       struct ssb_bus *bus = dev->bus;
 209 +
 210 +       offset += dev->core_index * SSB_CORE_SIZE;
 211 +       return readl(bus->mmio + offset);
 212 +}
 213 +
 214 +#ifdef CONFIG_SSB_BLOCKIO
 215 +static void ssb_host_soc_block_read(struct ssb_device *dev, void *buffer,
 216 +                                   size_t count, u16 offset, u8 reg_width)
 217 +{
 218 +       struct ssb_bus *bus = dev->bus;
 219 +       void __iomem *addr;
 220 +
 221 +       offset += dev->core_index * SSB_CORE_SIZE;
 222 +       addr = bus->mmio + offset;
 223 +
 224 +       switch (reg_width) {
 225 +       case sizeof(u8): {
 226 +               u8 *buf = buffer;
 227 +
 228 +               while (count) {
 229 +                       *buf = __raw_readb(addr);
 230 +                       buf++;
 231 +                       count--;
 232 +               }
 233 +               break;
 234 +       }
 235 +       case sizeof(u16): {
 236 +               __le16 *buf = buffer;
 237 +
 238 +               SSB_WARN_ON(count & 1);
 239 +               while (count) {
 240 +                       *buf = (__force __le16)__raw_readw(addr);
 241 +                       buf++;
 242 +                       count -= 2;
 243 +               }
 244 +               break;
 245 +       }
 246 +       case sizeof(u32): {
 247 +               __le32 *buf = buffer;
 248 +
 249 +               SSB_WARN_ON(count & 3);
 250 +               while (count) {
 251 +                       *buf = (__force __le32)__raw_readl(addr);
 252 +                       buf++;
 253 +                       count -= 4;
 254 +               }
 255 +               break;
 256 +       }
 257 +       default:
 258 +               SSB_WARN_ON(1);
 259 +       }
 260 +}
 261 +#endif /* CONFIG_SSB_BLOCKIO */
 262 +
 263 +static void ssb_host_soc_write8(struct ssb_device *dev, u16 offset, u8 value)
 264 +{
 265 +       struct ssb_bus *bus = dev->bus;
 266 +
 267 +       offset += dev->core_index * SSB_CORE_SIZE;
 268 +       writeb(value, bus->mmio + offset);
 269 +}
 270 +
 271 +static void ssb_host_soc_write16(struct ssb_device *dev, u16 offset, u16 value)
 272 +{
 273 +       struct ssb_bus *bus = dev->bus;
 274 +
 275 +       offset += dev->core_index * SSB_CORE_SIZE;
 276 +       writew(value, bus->mmio + offset);
 277 +}
 278 +
 279 +static void ssb_host_soc_write32(struct ssb_device *dev, u16 offset, u32 value)
 280 +{
 281 +       struct ssb_bus *bus = dev->bus;
 282 +
 283 +       offset += dev->core_index * SSB_CORE_SIZE;
 284 +       writel(value, bus->mmio + offset);
 285 +}
 286 +
 287 +#ifdef CONFIG_SSB_BLOCKIO
 288 +static void ssb_host_soc_block_write(struct ssb_device *dev, const void *buffer,
 289 +                                    size_t count, u16 offset, u8 reg_width)
 290 +{
 291 +       struct ssb_bus *bus = dev->bus;
 292 +       void __iomem *addr;
 293 +
 294 +       offset += dev->core_index * SSB_CORE_SIZE;
 295 +       addr = bus->mmio + offset;
 296 +
 297 +       switch (reg_width) {
 298 +       case sizeof(u8): {
 299 +               const u8 *buf = buffer;
 300 +
 301 +               while (count) {
 302 +                       __raw_writeb(*buf, addr);
 303 +                       buf++;
 304 +                       count--;
 305 +               }
 306 +               break;
 307 +       }
 308 +       case sizeof(u16): {
 309 +               const __le16 *buf = buffer;
 310 +
 311 +               SSB_WARN_ON(count & 1);
 312 +               while (count) {
 313 +                       __raw_writew((__force u16)(*buf), addr);
 314 +                       buf++;
 315 +                       count -= 2;
 316 +               }
 317 +               break;
 318 +       }
 319 +       case sizeof(u32): {
 320 +               const __le32 *buf = buffer;
 321 +
 322 +               SSB_WARN_ON(count & 3);
 323 +               while (count) {
 324 +                       __raw_writel((__force u32)(*buf), addr);
 325 +                       buf++;
 326 +                       count -= 4;
 327 +               }
 328 +               break;
 329 +       }
 330 +       default:
 331 +               SSB_WARN_ON(1);
 332 +       }
 333 +}
 334 +#endif /* CONFIG_SSB_BLOCKIO */
 335 +
 336 +/* Ops for the plain SSB bus without a host-device (no PCI or PCMCIA). */
 337 +const struct ssb_bus_ops ssb_host_soc_ops = {
 338 +       .read8          = ssb_host_soc_read8,
 339 +       .read16         = ssb_host_soc_read16,
 340 +       .read32         = ssb_host_soc_read32,
 341 +       .write8         = ssb_host_soc_write8,
 342 +       .write16        = ssb_host_soc_write16,
 343 +       .write32        = ssb_host_soc_write32,
 344 +#ifdef CONFIG_SSB_BLOCKIO
 345 +       .block_read     = ssb_host_soc_block_read,
 346 +       .block_write    = ssb_host_soc_block_write,
 347 +#endif
 348 +};
 349 --- a/drivers/ssb/main.c
 350 +++ b/drivers/ssb/main.c
 351 @@ -596,166 +596,6 @@ error:
 352         return err;
 353  }
 354
 355 -static u8 ssb_ssb_read8(struct ssb_device *dev, u16 offset)
 356 -{
 357 -       struct ssb_bus *bus = dev->bus;
 358 -
 359 -       offset += dev->core_index * SSB_CORE_SIZE;
 360 -       return readb(bus->mmio + offset);
 361 -}
 362 -
 363 -static u16 ssb_ssb_read16(struct ssb_device *dev, u16 offset)
 364 -{
 365 -       struct ssb_bus *bus = dev->bus;
 366 -
 367 -       offset += dev->core_index * SSB_CORE_SIZE;
 368 -       return readw(bus->mmio + offset);
 369 -}
 370 -
 371 -static u32 ssb_ssb_read32(struct ssb_device *dev, u16 offset)
 372 -{
 373 -       struct ssb_bus *bus = dev->bus;
 374 -
 375 -       offset += dev->core_index * SSB_CORE_SIZE;
 376 -       return readl(bus->mmio + offset);
 377 -}
 378 -
 379 -#ifdef CONFIG_SSB_BLOCKIO
 380 -static void ssb_ssb_block_read(struct ssb_device *dev, void *buffer,
 381 -                              size_t count, u16 offset, u8 reg_width)
 382 -{
 383 -       struct ssb_bus *bus = dev->bus;
 384 -       void __iomem *addr;
 385 -
 386 -       offset += dev->core_index * SSB_CORE_SIZE;
 387 -       addr = bus->mmio + offset;
 388 -
 389 -       switch (reg_width) {
 390 -       case sizeof(u8): {
 391 -               u8 *buf = buffer;
 392 -
 393 -               while (count) {
 394 -                       *buf = __raw_readb(addr);
 395 -                       buf++;
 396 -                       count--;
 397 -               }
 398 -               break;
 399 -       }
 400 -       case sizeof(u16): {
 401 -               __le16 *buf = buffer;
 402 -
 403 -               SSB_WARN_ON(count & 1);
 404 -               while (count) {
 405 -                       *buf = (__force __le16)__raw_readw(addr);
 406 -                       buf++;
 407 -                       count -= 2;
 408 -               }
 409 -               break;
 410 -       }
 411 -       case sizeof(u32): {
 412 -               __le32 *buf = buffer;
 413 -
 414 -               SSB_WARN_ON(count & 3);
 415 -               while (count) {
 416 -                       *buf = (__force __le32)__raw_readl(addr);
 417 -                       buf++;
 418 -                       count -= 4;
 419 -               }
 420 -               break;
 421 -       }
 422 -       default:
 423 -               SSB_WARN_ON(1);
 424 -       }
 425 -}
 426 -#endif /* CONFIG_SSB_BLOCKIO */
 427 -
 428 -static void ssb_ssb_write8(struct ssb_device *dev, u16 offset, u8 value)
 429 -{
 430 -       struct ssb_bus *bus = dev->bus;
 431 -
 432 -       offset += dev->core_index * SSB_CORE_SIZE;
 433 -       writeb(value, bus->mmio + offset);
 434 -}
 435 -
 436 -static void ssb_ssb_write16(struct ssb_device *dev, u16 offset, u16 value)
 437 -{
 438 -       struct ssb_bus *bus = dev->bus;
 439 -
 440 -       offset += dev->core_index * SSB_CORE_SIZE;
 441 -       writew(value, bus->mmio + offset);
 442 -}
 443 -
 444 -static void ssb_ssb_write32(struct ssb_device *dev, u16 offset, u32 value)
 445 -{
 446 -       struct ssb_bus *bus = dev->bus;
 447 -
 448 -       offset += dev->core_index * SSB_CORE_SIZE;
 449 -       writel(value, bus->mmio + offset);
 450 -}
 451 -
 452 -#ifdef CONFIG_SSB_BLOCKIO
 453 -static void ssb_ssb_block_write(struct ssb_device *dev, const void *buffer,
 454 -                               size_t count, u16 offset, u8 reg_width)
 455 -{
 456 -       struct ssb_bus *bus = dev->bus;
 457 -       void __iomem *addr;
 458 -
 459 -       offset += dev->core_index * SSB_CORE_SIZE;
 460 -       addr = bus->mmio + offset;
 461 -
 462 -       switch (reg_width) {
 463 -       case sizeof(u8): {
 464 -               const u8 *buf = buffer;
 465 -
 466 -               while (count) {
 467 -                       __raw_writeb(*buf, addr);
 468 -                       buf++;
 469 -                       count--;
 470 -               }
 471 -               break;
 472 -       }
 473 -       case sizeof(u16): {
 474 -               const __le16 *buf = buffer;
 475 -
 476 -               SSB_WARN_ON(count & 1);
 477 -               while (count) {
 478 -                       __raw_writew((__force u16)(*buf), addr);
 479 -                       buf++;
 480 -                       count -= 2;
 481 -               }
 482 -               break;
 483 -       }
 484 -       case sizeof(u32): {
 485 -               const __le32 *buf = buffer;
 486 -
 487 -               SSB_WARN_ON(count & 3);
 488 -               while (count) {
 489 -                       __raw_writel((__force u32)(*buf), addr);
 490 -                       buf++;
 491 -                       count -= 4;
 492 -               }
 493 -               break;
 494 -       }
 495 -       default:
 496 -               SSB_WARN_ON(1);
 497 -       }
 498 -}
 499 -#endif /* CONFIG_SSB_BLOCKIO */
 500 -
 501 -/* Ops for the plain SSB bus without a host-device (no PCI or PCMCIA). */
 502 -static const struct ssb_bus_ops ssb_ssb_ops = {
 503 -       .read8          = ssb_ssb_read8,
 504 -       .read16         = ssb_ssb_read16,
 505 -       .read32         = ssb_ssb_read32,
 506 -       .write8         = ssb_ssb_write8,
 507 -       .write16        = ssb_ssb_write16,
 508 -       .write32        = ssb_ssb_write32,
 509 -#ifdef CONFIG_SSB_BLOCKIO
 510 -       .block_read     = ssb_ssb_block_read,
 511 -       .block_write    = ssb_ssb_block_write,
 512 -#endif
 513 -};
 514 -
 515  static int ssb_fetch_invariants(struct ssb_bus *bus,
 516                                 ssb_invariants_func_t get_invariants)
 517  {
 518 @@ -876,7 +716,6 @@ int ssb_bus_pcibus_register(struct ssb_b
 519
 520         return err;
 521  }
 522 -EXPORT_SYMBOL(ssb_bus_pcibus_register);
 523  #endif /* CONFIG_SSB_PCIHOST */
 524
 525  #ifdef CONFIG_SSB_PCMCIAHOST
 526 @@ -898,7 +737,6 @@ int ssb_bus_pcmciabus_register(struct ss
 527
 528         return err;
 529  }
 530 -EXPORT_SYMBOL(ssb_bus_pcmciabus_register);
 531  #endif /* CONFIG_SSB_PCMCIAHOST */
 532
 533  #ifdef CONFIG_SSB_SDIOHOST
 534 @@ -923,13 +761,14 @@ int ssb_bus_sdiobus_register(struct ssb_
 535  EXPORT_SYMBOL(ssb_bus_sdiobus_register);
 536  #endif /* CONFIG_SSB_PCMCIAHOST */
 537
 538 +#ifdef CONFIG_SSB_HOST_SOC
 539  int ssb_bus_ssbbus_register(struct ssb_bus *bus, unsigned long baseaddr,
 540                             ssb_invariants_func_t get_invariants)
 541  {
 542         int err;
 543
 544         bus->bustype = SSB_BUSTYPE_SSB;
 545 -       bus->ops = &ssb_ssb_ops;
 546 +       bus->ops = &ssb_host_soc_ops;
 547
 548         err = ssb_bus_register(bus, get_invariants, baseaddr);
 549         if (!err) {
 550 @@ -939,6 +778,7 @@ int ssb_bus_ssbbus_register(struct ssb_b
 551
 552         return err;
 553  }
 554 +#endif
 555
 556  int __ssb_driver_register(struct ssb_driver *drv, struct module *owner)
 557  {
 558 @@ -1465,6 +1305,12 @@ static int __init ssb_modinit(void)
 559                 /* don't fail SSB init because of this */
 560                 err = 0;
 561         }
 562 +       err = ssb_host_pcmcia_init();
 563 +       if (err) {
 564 +               ssb_err("PCMCIA host initialization failed\n");
 565 +               /* don't fail SSB init because of this */
 566 +               err = 0;
 567 +       }
 568         err = ssb_gige_init();
 569         if (err) {
 570                 ssb_err("SSB Broadcom Gigabit Ethernet driver initialization failed\n");
 571 @@ -1482,6 +1328,7 @@ fs_initcall(ssb_modinit);
 572  static void __exit ssb_modexit(void)
 573  {
 574         ssb_gige_exit();
 575 +       ssb_host_pcmcia_exit();
 576         b43_pci_ssb_bridge_exit();
 577         bus_unregister(&ssb_bustype);
 578  }
 579 --- a/drivers/ssb/pcmcia.c
 580 +++ b/drivers/ssb/pcmcia.c
 581 @@ -147,8 +147,7 @@ error:
 582         return err;
 583  }
 584
 585 -int ssb_pcmcia_switch_core(struct ssb_bus *bus,
 586 -                          struct ssb_device *dev)
 587 +static int ssb_pcmcia_switch_core(struct ssb_bus *bus, struct ssb_device *dev)
 588  {
 589         int err;
 590
 591 --- a/drivers/ssb/sdio.c
 592 +++ b/drivers/ssb/sdio.c
 593 @@ -200,7 +200,7 @@ out:
 594  }
 595
 596  /* host must be already claimed */
 597 -int ssb_sdio_switch_core(struct ssb_bus *bus, struct ssb_device *dev)
 598 +static int ssb_sdio_switch_core(struct ssb_bus *bus, struct ssb_device *dev)
 599  {
 600         u8 coreidx = dev->core_index;
 601         u32 sbaddr;
 602 --- a/drivers/ssb/ssb_private.h
 603 +++ b/drivers/ssb/ssb_private.h
 604 @@ -85,8 +85,6 @@ static inline int ssb_pci_init(struct ss
 605
 606  /* pcmcia.c */
 607  #ifdef CONFIG_SSB_PCMCIAHOST
 608 -extern int ssb_pcmcia_switch_core(struct ssb_bus *bus,
 609 -                                 struct ssb_device *dev);
 610  extern int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus,
 611                                      u8 coreidx);
 612  extern int ssb_pcmcia_switch_segment(struct ssb_bus *bus,
 613 @@ -96,13 +94,10 @@ extern int ssb_pcmcia_get_invariants(str
 614  extern int ssb_pcmcia_hardware_setup(struct ssb_bus *bus);
 615  extern void ssb_pcmcia_exit(struct ssb_bus *bus);
 616  extern int ssb_pcmcia_init(struct ssb_bus *bus);
 617 +extern int ssb_host_pcmcia_init(void);
 618 +extern void ssb_host_pcmcia_exit(void);
 619  extern const struct ssb_bus_ops ssb_pcmcia_ops;
 620  #else /* CONFIG_SSB_PCMCIAHOST */
 621 -static inline int ssb_pcmcia_switch_core(struct ssb_bus *bus,
 622 -                                        struct ssb_device *dev)
 623 -{
 624 -       return 0;
 625 -}
 626  static inline int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus,
 627                                             u8 coreidx)
 628  {
 629 @@ -124,6 +119,13 @@ static inline int ssb_pcmcia_init(struct
 630  {
 631         return 0;
 632  }
 633 +static inline int ssb_host_pcmcia_init(void)
 634 +{
 635 +       return 0;
 636 +}
 637 +static inline void ssb_host_pcmcia_exit(void)
 638 +{
 639 +}
 640  #endif /* CONFIG_SSB_PCMCIAHOST */
 641
 642  /* sdio.c */
 643 @@ -132,9 +134,7 @@ extern int ssb_sdio_get_invariants(struc
 644                                      struct ssb_init_invariants *iv);
 645
 646  extern u32 ssb_sdio_scan_read32(struct ssb_bus *bus, u16 offset);
 647 -extern int ssb_sdio_switch_core(struct ssb_bus *bus, struct ssb_device *dev);
 648  extern int ssb_sdio_scan_switch_coreidx(struct ssb_bus *bus, u8 coreidx);
 649 -extern int ssb_sdio_hardware_setup(struct ssb_bus *bus);
 650  extern void ssb_sdio_exit(struct ssb_bus *bus);
 651  extern int ssb_sdio_init(struct ssb_bus *bus);
 652
 653 @@ -144,19 +144,10 @@ static inline u32 ssb_sdio_scan_read32(s
 654  {
 655         return 0;
 656  }
 657 -static inline int ssb_sdio_switch_core(struct ssb_bus *bus,
 658 -                                        struct ssb_device *dev)
 659 -{
 660 -       return 0;
 661 -}
 662  static inline int ssb_sdio_scan_switch_coreidx(struct ssb_bus *bus, u8 coreidx)
 663  {
 664         return 0;
 665  }
 666 -static inline int ssb_sdio_hardware_setup(struct ssb_bus *bus)
 667 -{
 668 -       return 0;
 669 -}
 670  static inline void ssb_sdio_exit(struct ssb_bus *bus)
 671  {
 672  }
 673 @@ -166,6 +157,13 @@ static inline int ssb_sdio_init(struct s
 674  }
 675  #endif /* CONFIG_SSB_SDIOHOST */
 676
 677 +/**************************************************
 678 + * host_soc.c
 679 + **************************************************/
 680 +
 681 +#ifdef CONFIG_SSB_HOST_SOC
 682 +extern const struct ssb_bus_ops ssb_host_soc_ops;
 683 +#endif
 684
 685  /* scan.c */
 686  extern const char *ssb_core_name(u16 coreid);