drivers/ssb/sdio.c

   1 /*
   2  * Sonics Silicon Backplane
   3  * SDIO-Hostbus related functions
   4  *
   5  * Copyright 2009 Albert Herranz <albert_herranz@yahoo.es>
   6  *
   7  * Based on drivers/ssb/pcmcia.c
   8  * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
   9  * Copyright 2007-2008 Michael Buesch <m@bues.ch>
  10  *
  11  * Licensed under the GNU/GPL. See COPYING for details.
  12  *
  13  */
  14
  15 #include <linux/ssb/ssb.h>
  16 #include <linux/delay.h>
  17 #include <linux/io.h>
  18 #include <linux/etherdevice.h>
  19 #include <linux/mmc/sdio_func.h>
  20
  21 #include "ssb_private.h"
  22
  23 /* Define the following to 1 to enable a printk on each coreswitch. */
  24 #define SSB_VERBOSE_SDIOCORESWITCH_DEBUG                0
  25
  26
  27 /* Hardware invariants CIS tuples */
  28 #define SSB_SDIO_CIS                    0x80
  29 #define  SSB_SDIO_CIS_SROMREV           0x00
  30 #define  SSB_SDIO_CIS_ID                0x01
  31 #define  SSB_SDIO_CIS_BOARDREV          0x02
  32 #define  SSB_SDIO_CIS_PA                0x03
  33 #define   SSB_SDIO_CIS_PA_PA0B0_LO      0
  34 #define   SSB_SDIO_CIS_PA_PA0B0_HI      1
  35 #define   SSB_SDIO_CIS_PA_PA0B1_LO      2
  36 #define   SSB_SDIO_CIS_PA_PA0B1_HI      3
  37 #define   SSB_SDIO_CIS_PA_PA0B2_LO      4
  38 #define   SSB_SDIO_CIS_PA_PA0B2_HI      5
  39 #define   SSB_SDIO_CIS_PA_ITSSI         6
  40 #define   SSB_SDIO_CIS_PA_MAXPOW        7
  41 #define  SSB_SDIO_CIS_OEMNAME           0x04
  42 #define  SSB_SDIO_CIS_CCODE             0x05
  43 #define  SSB_SDIO_CIS_ANTENNA           0x06
  44 #define  SSB_SDIO_CIS_ANTGAIN           0x07
  45 #define  SSB_SDIO_CIS_BFLAGS            0x08
  46 #define  SSB_SDIO_CIS_LEDS              0x09
  47
  48 #define CISTPL_FUNCE_LAN_NODE_ID        0x04    /* same as in PCMCIA */
  49
  50
  51 /*
  52  * Function 1 miscellaneous registers.
  53  *
  54  * Definitions match src/include/sbsdio.h from the
  55  * Android Open Source Project
  56  * http://android.git.kernel.org/?p=platform/system/wlan/broadcom.git
  57  *
  58  */
  59 #define SBSDIO_FUNC1_SBADDRLOW  0x1000a /* SB Address window Low (b15) */
  60 #define SBSDIO_FUNC1_SBADDRMID  0x1000b /* SB Address window Mid (b23-b16) */
  61 #define SBSDIO_FUNC1_SBADDRHIGH 0x1000c /* SB Address window High (b24-b31) */
  62
  63 /* valid bits in SBSDIO_FUNC1_SBADDRxxx regs */
  64 #define SBSDIO_SBADDRLOW_MASK   0x80    /* Valid address bits in SBADDRLOW */
  65 #define SBSDIO_SBADDRMID_MASK   0xff    /* Valid address bits in SBADDRMID */
  66 #define SBSDIO_SBADDRHIGH_MASK  0xff    /* Valid address bits in SBADDRHIGH */
  67
  68 #define SBSDIO_SB_OFT_ADDR_MASK 0x7FFF  /* sb offset addr is <= 15 bits, 32k */
  69
  70 /* REVISIT: this flag doesn't seem to matter */
  71 #define SBSDIO_SB_ACCESS_2_4B_FLAG      0x8000  /* forces 32-bit SB access */
  72
  73
  74 /*
  75  * Address map within the SDIO function address space (128K).
  76  *
  77  *   Start   End     Description
  78  *   ------- ------- ------------------------------------------
  79  *   0x00000 0x0ffff selected backplane address window (64K)
  80  *   0x10000 0x1ffff backplane control registers (max 64K)
  81  *
  82  * The current address window is configured by writing to registers
  83  * SBADDRLOW, SBADDRMID and SBADDRHIGH.
  84  *
  85  * In order to access the contents of a 32-bit Silicon Backplane address
  86  * the backplane address window must be first loaded with the highest
  87  * 16 bits of the target address. Then, an access must be done to the
  88  * SDIO function address space using the lower 15 bits of the address.
  89  * Bit 15 of the address must be set when doing 32 bit accesses.
  90  *
  91  * 10987654321098765432109876543210
  92  * WWWWWWWWWWWWWWWWW                 SB Address Window
  93  *                 OOOOOOOOOOOOOOOO  Offset within SB Address Window
  94  *                 a                 32-bit access flag
  95  */
  96
  97
  98 /*
  99  * SSB I/O via SDIO.
 100  *
 101  * NOTE: SDIO address @addr is 17 bits long (SDIO address space is 128K).
 102  */
 103
 104 static inline struct device *ssb_sdio_dev(struct ssb_bus *bus)
 105 {
 106         return &bus->host_sdio->dev;
 107 }
 108
 109 /* host claimed */
 110 static int ssb_sdio_writeb(struct ssb_bus *bus, unsigned int addr, u8 val)
 111 {
 112         int error = 0;
 113
 114         sdio_writeb(bus->host_sdio, val, addr, &error);
 115         if (unlikely(error)) {
 116                 dev_dbg(ssb_sdio_dev(bus), "%08X <- %02x, error %d\n",
 117                         addr, val, error);
 118         }
 119
 120         return error;
 121 }
 122
 123 #if 0
 124 static u8 ssb_sdio_readb(struct ssb_bus *bus, unsigned int addr)
 125 {
 126         u8 val;
 127         int error = 0;
 128
 129         val = sdio_readb(bus->host_sdio, addr, &error);
 130         if (unlikely(error)) {
 131                 dev_dbg(ssb_sdio_dev(bus), "%08X -> %02x, error %d\n",
 132                         addr, val, error);
 133         }
 134
 135         return val;
 136 }
 137 #endif
 138
 139 /* host claimed */
 140 static int ssb_sdio_set_sbaddr_window(struct ssb_bus *bus, u32 address)
 141 {
 142         int error;
 143
 144         error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRLOW,
 145                                 (address >> 8) & SBSDIO_SBADDRLOW_MASK);
 146         if (error)
 147                 goto out;
 148         error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRMID,
 149                                 (address >> 16) & SBSDIO_SBADDRMID_MASK);
 150         if (error)
 151                 goto out;
 152         error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRHIGH,
 153                                 (address >> 24) & SBSDIO_SBADDRHIGH_MASK);
 154         if (error)
 155                 goto out;
 156         bus->sdio_sbaddr = address;
 157 out:
 158         if (error) {
 159                 dev_dbg(ssb_sdio_dev(bus), "failed to set address window"
 160                         " to 0x%08x, error %d\n", address, error);
 161         }
 162
 163         return error;
 164 }
 165
 166 /* for enumeration use only */
 167 u32 ssb_sdio_scan_read32(struct ssb_bus *bus, u16 offset)
 168 {
 169         u32 val;
 170         int error;
 171
 172         sdio_claim_host(bus->host_sdio);
 173         val = sdio_readl(bus->host_sdio, offset, &error);
 174         sdio_release_host(bus->host_sdio);
 175         if (unlikely(error)) {
 176                 dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %08x, error %d\n",
 177                         bus->sdio_sbaddr >> 16, offset, val, error);
 178         }
 179
 180         return val;
 181 }
 182
 183 /* for enumeration use only */
 184 int ssb_sdio_scan_switch_coreidx(struct ssb_bus *bus, u8 coreidx)
 185 {
 186         u32 sbaddr;
 187         int error;
 188
 189         sbaddr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE;
 190         sdio_claim_host(bus->host_sdio);
 191         error = ssb_sdio_set_sbaddr_window(bus, sbaddr);
 192         sdio_release_host(bus->host_sdio);
 193         if (error) {
 194                 dev_err(ssb_sdio_dev(bus), "failed to switch to core %u,"
 195                         " error %d\n", coreidx, error);
 196                 goto out;
 197         }
 198 out:
 199         return error;
 200 }
 201
 202 /* host must be already claimed */
 203 int ssb_sdio_switch_core(struct ssb_bus *bus, struct ssb_device *dev)
 204 {
 205         u8 coreidx = dev->core_index;
 206         u32 sbaddr;
 207         int error = 0;
 208
 209         sbaddr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE;
 210         if (unlikely(bus->sdio_sbaddr != sbaddr)) {
 211 #if SSB_VERBOSE_SDIOCORESWITCH_DEBUG
 212                 dev_info(ssb_sdio_dev(bus),
 213                            "switching to %s core, index %d\n",
 214                            ssb_core_name(dev->id.coreid), coreidx);
 215 #endif
 216                 error = ssb_sdio_set_sbaddr_window(bus, sbaddr);
 217                 if (error) {
 218                         dev_dbg(ssb_sdio_dev(bus), "failed to switch to"
 219                                 " core %u, error %d\n", coreidx, error);
 220                         goto out;
 221                 }
 222                 bus->mapped_device = dev;
 223         }
 224
 225 out:
 226         return error;
 227 }
 228
 229 static u8 ssb_sdio_read8(struct ssb_device *dev, u16 offset)
 230 {
 231         struct ssb_bus *bus = dev->bus;
 232         u8 val = 0xff;
 233         int error = 0;
 234
 235         sdio_claim_host(bus->host_sdio);
 236         if (unlikely(ssb_sdio_switch_core(bus, dev)))
 237                 goto out;
 238         offset |= bus->sdio_sbaddr & 0xffff;
 239         offset &= SBSDIO_SB_OFT_ADDR_MASK;
 240         val = sdio_readb(bus->host_sdio, offset, &error);
 241         if (error) {
 242                 dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %02x, error %d\n",
 243                         bus->sdio_sbaddr >> 16, offset, val, error);
 244         }
 245 out:
 246         sdio_release_host(bus->host_sdio);
 247
 248         return val;
 249 }
 250
 251 static u16 ssb_sdio_read16(struct ssb_device *dev, u16 offset)
 252 {
 253         struct ssb_bus *bus = dev->bus;
 254         u16 val = 0xffff;
 255         int error = 0;
 256
 257         sdio_claim_host(bus->host_sdio);
 258         if (unlikely(ssb_sdio_switch_core(bus, dev)))
 259                 goto out;
 260         offset |= bus->sdio_sbaddr & 0xffff;
 261         offset &= SBSDIO_SB_OFT_ADDR_MASK;
 262         val = sdio_readw(bus->host_sdio, offset, &error);
 263         if (error) {
 264                 dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %04x, error %d\n",
 265                         bus->sdio_sbaddr >> 16, offset, val, error);
 266         }
 267 out:
 268         sdio_release_host(bus->host_sdio);
 269
 270         return val;
 271 }
 272
 273 static u32 ssb_sdio_read32(struct ssb_device *dev, u16 offset)
 274 {
 275         struct ssb_bus *bus = dev->bus;
 276         u32 val = 0xffffffff;
 277         int error = 0;
 278
 279         sdio_claim_host(bus->host_sdio);
 280         if (unlikely(ssb_sdio_switch_core(bus, dev)))
 281                 goto out;
 282         offset |= bus->sdio_sbaddr & 0xffff;
 283         offset &= SBSDIO_SB_OFT_ADDR_MASK;
 284         offset |= SBSDIO_SB_ACCESS_2_4B_FLAG;   /* 32 bit data access */
 285         val = sdio_readl(bus->host_sdio, offset, &error);
 286         if (error) {
 287                 dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %08x, error %d\n",
 288                         bus->sdio_sbaddr >> 16, offset, val, error);
 289         }
 290 out:
 291         sdio_release_host(bus->host_sdio);
 292
 293         return val;
 294 }
 295
 296 #ifdef CONFIG_SSB_BLOCKIO
 297 static void ssb_sdio_block_read(struct ssb_device *dev, void *buffer,
 298                                   size_t count, u16 offset, u8 reg_width)
 299 {
 300         size_t saved_count = count;
 301         struct ssb_bus *bus = dev->bus;
 302         int error = 0;
 303
 304         sdio_claim_host(bus->host_sdio);
 305         if (unlikely(ssb_sdio_switch_core(bus, dev))) {
 306                 error = -EIO;
 307                 memset(buffer, 0xff, count);
 308                 goto err_out;
 309         }
 310         offset |= bus->sdio_sbaddr & 0xffff;
 311         offset &= SBSDIO_SB_OFT_ADDR_MASK;
 312
 313         switch (reg_width) {
 314         case sizeof(u8): {
 315                 error = sdio_readsb(bus->host_sdio, buffer, offset, count);
 316                 break;
 317         }
 318         case sizeof(u16): {
 319                 SSB_WARN_ON(count & 1);
 320                 error = sdio_readsb(bus->host_sdio, buffer, offset, count);
 321                 break;
 322         }
 323         case sizeof(u32): {
 324                 SSB_WARN_ON(count & 3);
 325                 offset |= SBSDIO_SB_ACCESS_2_4B_FLAG;   /* 32 bit data access */
 326                 error = sdio_readsb(bus->host_sdio, buffer, offset, count);
 327                 break;
 328         }
 329         default:
 330                 SSB_WARN_ON(1);
 331         }
 332         if (!error)
 333                 goto out;
 334
 335 err_out:
 336         dev_dbg(ssb_sdio_dev(bus), "%04X:%04X (width=%u, len=%zu), error %d\n",
 337                 bus->sdio_sbaddr >> 16, offset, reg_width, saved_count, error);
 338 out:
 339         sdio_release_host(bus->host_sdio);
 340 }
 341 #endif /* CONFIG_SSB_BLOCKIO */
 342
 343 static void ssb_sdio_write8(struct ssb_device *dev, u16 offset, u8 val)
 344 {
 345         struct ssb_bus *bus = dev->bus;
 346         int error = 0;
 347
 348         sdio_claim_host(bus->host_sdio);
 349         if (unlikely(ssb_sdio_switch_core(bus, dev)))
 350                 goto out;
 351         offset |= bus->sdio_sbaddr & 0xffff;
 352         offset &= SBSDIO_SB_OFT_ADDR_MASK;
 353         sdio_writeb(bus->host_sdio, val, offset, &error);
 354         if (error) {
 355                 dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %02x, error %d\n",
 356                         bus->sdio_sbaddr >> 16, offset, val, error);
 357         }
 358 out:
 359         sdio_release_host(bus->host_sdio);
 360 }
 361
 362 static void ssb_sdio_write16(struct ssb_device *dev, u16 offset, u16 val)
 363 {
 364         struct ssb_bus *bus = dev->bus;
 365         int error = 0;
 366
 367         sdio_claim_host(bus->host_sdio);
 368         if (unlikely(ssb_sdio_switch_core(bus, dev)))
 369                 goto out;
 370         offset |= bus->sdio_sbaddr & 0xffff;
 371         offset &= SBSDIO_SB_OFT_ADDR_MASK;
 372         sdio_writew(bus->host_sdio, val, offset, &error);
 373         if (error) {
 374                 dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %04x, error %d\n",
 375                         bus->sdio_sbaddr >> 16, offset, val, error);
 376         }
 377 out:
 378         sdio_release_host(bus->host_sdio);
 379 }
 380
 381 static void ssb_sdio_write32(struct ssb_device *dev, u16 offset, u32 val)
 382 {
 383         struct ssb_bus *bus = dev->bus;
 384         int error = 0;
 385
 386         sdio_claim_host(bus->host_sdio);
 387         if (unlikely(ssb_sdio_switch_core(bus, dev)))
 388                 goto out;
 389         offset |= bus->sdio_sbaddr & 0xffff;
 390         offset &= SBSDIO_SB_OFT_ADDR_MASK;
 391         offset |= SBSDIO_SB_ACCESS_2_4B_FLAG;   /* 32 bit data access */
 392         sdio_writel(bus->host_sdio, val, offset, &error);
 393         if (error) {
 394                 dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %08x, error %d\n",
 395                         bus->sdio_sbaddr >> 16, offset, val, error);
 396         }
 397         if (bus->quirks & SSB_QUIRK_SDIO_READ_AFTER_WRITE32)
 398                 sdio_readl(bus->host_sdio, 0, &error);
 399 out:
 400         sdio_release_host(bus->host_sdio);
 401 }
 402
 403 #ifdef CONFIG_SSB_BLOCKIO
 404 static void ssb_sdio_block_write(struct ssb_device *dev, const void *buffer,
 405                                    size_t count, u16 offset, u8 reg_width)
 406 {
 407         size_t saved_count = count;
 408         struct ssb_bus *bus = dev->bus;
 409         int error = 0;
 410
 411         sdio_claim_host(bus->host_sdio);
 412         if (unlikely(ssb_sdio_switch_core(bus, dev))) {
 413                 error = -EIO;
 414                 memset((void *)buffer, 0xff, count);
 415                 goto err_out;
 416         }
 417         offset |= bus->sdio_sbaddr & 0xffff;
 418         offset &= SBSDIO_SB_OFT_ADDR_MASK;
 419
 420         switch (reg_width) {
 421         case sizeof(u8):
 422                 error = sdio_writesb(bus->host_sdio, offset,
 423                                      (void *)buffer, count);
 424                 break;
 425         case sizeof(u16):
 426                 SSB_WARN_ON(count & 1);
 427                 error = sdio_writesb(bus->host_sdio, offset,
 428                                      (void *)buffer, count);
 429                 break;
 430         case sizeof(u32):
 431                 SSB_WARN_ON(count & 3);
 432                 offset |= SBSDIO_SB_ACCESS_2_4B_FLAG;   /* 32 bit data access */
 433                 error = sdio_writesb(bus->host_sdio, offset,
 434                                      (void *)buffer, count);
 435                 break;
 436         default:
 437                 SSB_WARN_ON(1);
 438         }
 439         if (!error)
 440                 goto out;
 441
 442 err_out:
 443         dev_dbg(ssb_sdio_dev(bus), "%04X:%04X (width=%u, len=%zu), error %d\n",
 444                 bus->sdio_sbaddr >> 16, offset, reg_width, saved_count, error);
 445 out:
 446         sdio_release_host(bus->host_sdio);
 447 }
 448
 449 #endif /* CONFIG_SSB_BLOCKIO */
 450
 451 /* Not "static", as it's used in main.c */
 452 const struct ssb_bus_ops ssb_sdio_ops = {
 453         .read8          = ssb_sdio_read8,
 454         .read16         = ssb_sdio_read16,
 455         .read32         = ssb_sdio_read32,
 456         .write8         = ssb_sdio_write8,
 457         .write16        = ssb_sdio_write16,
 458         .write32        = ssb_sdio_write32,
 459 #ifdef CONFIG_SSB_BLOCKIO
 460         .block_read     = ssb_sdio_block_read,
 461         .block_write    = ssb_sdio_block_write,
 462 #endif
 463 };
 464
 465 #define GOTO_ERROR_ON(condition, description) do {      \
 466         if (unlikely(condition)) {                      \
 467                 error_description = description;        \
 468                 goto error;                             \
 469         }                                               \
 470   } while (0)
 471
 472 int ssb_sdio_get_invariants(struct ssb_bus *bus,
 473                             struct ssb_init_invariants *iv)
 474 {
 475         struct ssb_sprom *sprom = &iv->sprom;
 476         struct ssb_boardinfo *bi = &iv->boardinfo;
 477         const char *error_description = "none";
 478         struct sdio_func_tuple *tuple;
 479         void *mac;
 480
 481         memset(sprom, 0xFF, sizeof(*sprom));
 482         sprom->boardflags_lo = 0;
 483         sprom->boardflags_hi = 0;
 484
 485         tuple = bus->host_sdio->tuples;
 486         while (tuple) {
 487                 switch (tuple->code) {
 488                 case 0x22: /* extended function */
 489                         switch (tuple->data[0]) {
 490                         case CISTPL_FUNCE_LAN_NODE_ID:
 491                                 GOTO_ERROR_ON((tuple->size != 7) &&
 492                                               (tuple->data[1] != 6),
 493                                               "mac tpl size");
 494                                 /* fetch the MAC address. */
 495                                 mac = tuple->data + 2;
 496                                 memcpy(sprom->il0mac, mac, ETH_ALEN);
 497                                 memcpy(sprom->et1mac, mac, ETH_ALEN);
 498                                 break;
 499                         default:
 500                                 break;
 501                         }
 502                         break;
 503                 case 0x80: /* vendor specific tuple */
 504                         switch (tuple->data[0]) {
 505                         case SSB_SDIO_CIS_SROMREV:
 506                                 GOTO_ERROR_ON(tuple->size != 2,
 507                                               "sromrev tpl size");
 508                                 sprom->revision = tuple->data[1];
 509                                 break;
 510                         case SSB_SDIO_CIS_ID:
 511                                 GOTO_ERROR_ON((tuple->size != 5) &&
 512                                               (tuple->size != 7),
 513                                               "id tpl size");
 514                                 bi->vendor = tuple->data[1] |
 515                                              (tuple->data[2]<<8);
 516                                 break;
 517                         case SSB_SDIO_CIS_BOARDREV:
 518                                 GOTO_ERROR_ON(tuple->size != 2,
 519                                               "boardrev tpl size");
 520                                 sprom->board_rev = tuple->data[1];
 521                                 break;
 522                         case SSB_SDIO_CIS_PA:
 523                                 GOTO_ERROR_ON((tuple->size != 9) &&
 524                                               (tuple->size != 10),
 525                                               "pa tpl size");
 526                                 sprom->pa0b0 = tuple->data[1] |
 527                                          ((u16)tuple->data[2] << 8);
 528                                 sprom->pa0b1 = tuple->data[3] |
 529                                          ((u16)tuple->data[4] << 8);
 530                                 sprom->pa0b2 = tuple->data[5] |
 531                                          ((u16)tuple->data[6] << 8);
 532                                 sprom->itssi_a = tuple->data[7];
 533                                 sprom->itssi_bg = tuple->data[7];
 534                                 sprom->maxpwr_a = tuple->data[8];
 535                                 sprom->maxpwr_bg = tuple->data[8];
 536                                 break;
 537                         case SSB_SDIO_CIS_OEMNAME:
 538                                 /* Not present */
 539                                 break;
 540                         case SSB_SDIO_CIS_CCODE:
 541                                 GOTO_ERROR_ON(tuple->size != 2,
 542                                               "ccode tpl size");
 543                                 sprom->country_code = tuple->data[1];
 544                                 break;
 545                         case SSB_SDIO_CIS_ANTENNA:
 546                                 GOTO_ERROR_ON(tuple->size != 2,
 547                                               "ant tpl size");
 548                                 sprom->ant_available_a = tuple->data[1];
 549                                 sprom->ant_available_bg = tuple->data[1];
 550                                 break;
 551                         case SSB_SDIO_CIS_ANTGAIN:
 552                                 GOTO_ERROR_ON(tuple->size != 2,
 553                                               "antg tpl size");
 554                                 sprom->antenna_gain.a0 = tuple->data[1];
 555                                 sprom->antenna_gain.a1 = tuple->data[1];
 556                                 sprom->antenna_gain.a2 = tuple->data[1];
 557                                 sprom->antenna_gain.a3 = tuple->data[1];
 558                                 break;
 559                         case SSB_SDIO_CIS_BFLAGS:
 560                                 GOTO_ERROR_ON((tuple->size != 3) &&
 561                                               (tuple->size != 5),
 562                                               "bfl tpl size");
 563                                 sprom->boardflags_lo = tuple->data[1] |
 564                                                  ((u16)tuple->data[2] << 8);
 565                                 break;
 566                         case SSB_SDIO_CIS_LEDS:
 567                                 GOTO_ERROR_ON(tuple->size != 5,
 568                                               "leds tpl size");
 569                                 sprom->gpio0 = tuple->data[1];
 570                                 sprom->gpio1 = tuple->data[2];
 571                                 sprom->gpio2 = tuple->data[3];
 572                                 sprom->gpio3 = tuple->data[4];
 573                                 break;
 574                         default:
 575                                 break;
 576                         }
 577                         break;
 578                 default:
 579                         break;
 580                 }
 581                 tuple = tuple->next;
 582         }
 583
 584         return 0;
 585 error:
 586         dev_err(ssb_sdio_dev(bus), "failed to fetch device invariants: %s\n",
 587                 error_description);
 588         return -ENODEV;
 589 }
 590
 591 void ssb_sdio_exit(struct ssb_bus *bus)
 592 {
 593         if (bus->bustype != SSB_BUSTYPE_SDIO)
 594                 return;
 595         /* Nothing to do here. */
 596 }
 597
 598 int ssb_sdio_init(struct ssb_bus *bus)
 599 {
 600         if (bus->bustype != SSB_BUSTYPE_SDIO)
 601                 return 0;
 602
 603         bus->sdio_sbaddr = ~0;
 604
 605         return 0;
 606 }