drivers/staging/brcm80211/brcmfmac/bcmsdh.c

   1 /*
   2  * Copyright (c) 2010 Broadcom Corporation
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  11  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  13  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16 /* ****************** BCMSDH Interface Functions *************************** */
  17
  18 #include <linux/types.h>
  19 #include <linux/netdevice.h>
  20 #include <linux/pci_ids.h>
  21 #include <linux/sched.h>
  22
  23 #include <defs.h>
  24 #include <brcm_hw_ids.h>
  25 #include <brcmu_utils.h>
  26 #include <brcmu_wifi.h>
  27 #include <soc.h>
  28 #include "bcmsdbus.h"           /* common SDIO/controller interface */
  29 #include "sbsdio.h"             /* BRCM sdio device core */
  30 #include "dngl_stats.h"
  31 #include "dhd.h"
  32
  33 #define SDIOH_API_ACCESS_RETRY_LIMIT    2
  34 const uint bcmsdh_msglevel = BCMSDH_ERROR_VAL;
  35
  36 struct bcmsdh_info {
  37         bool init_success;      /* underlying driver successfully attached */
  38         void *sdioh;            /* handler for sdioh */
  39         u32 vendevid;   /* Target Vendor and Device ID on SD bus */
  40         bool regfail;           /* Save status of last
  41                                  reg_read/reg_write call */
  42         u32 sbwad;              /* Save backplane window address */
  43 };
  44 /* local copy of bcm sd handler */
  45 bcmsdh_info_t *l_bcmsdh;
  46
  47 #if defined(OOB_INTR_ONLY) && defined(HW_OOB)
  48 extern int brcmf_sdioh_enable_hw_oob_intr(void *sdioh, bool enable);
  49
  50 void brcmf_sdcard_enable_hw_oob_intr(bcmsdh_info_t *sdh, bool enable)
  51 {
  52         brcmf_sdioh_enable_hw_oob_intr(sdh->sdioh, enable);
  53 }
  54 #endif
  55
  56 bcmsdh_info_t *brcmf_sdcard_attach(void *cfghdl, void **regsva, uint irq)
  57 {
  58         bcmsdh_info_t *bcmsdh;
  59
  60         bcmsdh = kzalloc(sizeof(bcmsdh_info_t), GFP_ATOMIC);
  61         if (bcmsdh == NULL) {
  62                 BCMSDH_ERROR(("bcmsdh_attach: out of memory"));
  63                 return NULL;
  64         }
  65
  66         /* save the handler locally */
  67         l_bcmsdh = bcmsdh;
  68
  69         bcmsdh->sdioh = brcmf_sdioh_attach(cfghdl, irq);
  70         if (!bcmsdh->sdioh) {
  71                 brcmf_sdcard_detach(bcmsdh);
  72                 return NULL;
  73         }
  74
  75         bcmsdh->init_success = true;
  76
  77         *regsva = (u32 *) SI_ENUM_BASE;
  78
  79         /* Report the BAR, to fix if needed */
  80         bcmsdh->sbwad = SI_ENUM_BASE;
  81         return bcmsdh;
  82 }
  83
  84 int brcmf_sdcard_detach(void *sdh)
  85 {
  86         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
  87
  88         if (bcmsdh != NULL) {
  89                 if (bcmsdh->sdioh) {
  90                         brcmf_sdioh_detach(bcmsdh->sdioh);
  91                         bcmsdh->sdioh = NULL;
  92                 }
  93                 kfree(bcmsdh);
  94         }
  95
  96         l_bcmsdh = NULL;
  97         return 0;
  98 }
  99
 100 int
 101 brcmf_sdcard_iovar_op(void *sdh, const char *name,
 102                 void *params, int plen, void *arg, int len, bool set)
 103 {
 104         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 105         return brcmf_sdioh_iovar_op(bcmsdh->sdioh, name, params, plen, arg,
 106                                     len, set);
 107 }
 108
 109 bool brcmf_sdcard_intr_query(void *sdh)
 110 {
 111         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 112         SDIOH_API_RC status;
 113         bool on;
 114
 115         ASSERT(bcmsdh);
 116         status = brcmf_sdioh_interrupt_query(bcmsdh->sdioh, &on);
 117         if (SDIOH_API_SUCCESS(status))
 118                 return false;
 119         else
 120                 return on;
 121 }
 122
 123 int brcmf_sdcard_intr_enable(void *sdh)
 124 {
 125         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 126         SDIOH_API_RC status;
 127         ASSERT(bcmsdh);
 128
 129         status = brcmf_sdioh_interrupt_set(bcmsdh->sdioh, true);
 130         return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
 131 }
 132
 133 int brcmf_sdcard_intr_disable(void *sdh)
 134 {
 135         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 136         SDIOH_API_RC status;
 137         ASSERT(bcmsdh);
 138
 139         status = brcmf_sdioh_interrupt_set(bcmsdh->sdioh, false);
 140         return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
 141 }
 142
 143 int brcmf_sdcard_intr_reg(void *sdh, bcmsdh_cb_fn_t fn, void *argh)
 144 {
 145         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 146         SDIOH_API_RC status;
 147         ASSERT(bcmsdh);
 148
 149         status = brcmf_sdioh_interrupt_register(bcmsdh->sdioh, fn, argh);
 150         return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
 151 }
 152
 153 int brcmf_sdcard_intr_dereg(void *sdh)
 154 {
 155         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 156         SDIOH_API_RC status;
 157         ASSERT(bcmsdh);
 158
 159         status = brcmf_sdioh_interrupt_deregister(bcmsdh->sdioh);
 160         return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
 161 }
 162
 163 #if defined(DHD_DEBUG)
 164 bool brcmf_sdcard_intr_pending(void *sdh)
 165 {
 166         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 167
 168         ASSERT(sdh);
 169         return brcmf_sdioh_interrupt_pending(bcmsdh->sdioh);
 170 }
 171 #endif
 172
 173 int brcmf_sdcard_devremove_reg(void *sdh, bcmsdh_cb_fn_t fn, void *argh)
 174 {
 175         ASSERT(sdh);
 176
 177         /* don't support yet */
 178         return -ENOTSUPP;
 179 }
 180
 181 u8 brcmf_sdcard_cfg_read(void *sdh, uint fnc_num, u32 addr, int *err)
 182 {
 183         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 184         SDIOH_API_RC status;
 185 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 186         s32 retry = 0;
 187 #endif
 188         u8 data = 0;
 189
 190         if (!bcmsdh)
 191                 bcmsdh = l_bcmsdh;
 192
 193         ASSERT(bcmsdh->init_success);
 194
 195 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 196         do {
 197                 if (retry)      /* wait for 1 ms till bus get settled down */
 198                         udelay(1000);
 199 #endif
 200                 status =
 201                     brcmf_sdioh_cfg_read(bcmsdh->sdioh, fnc_num, addr,
 202                                    (u8 *) &data);
 203 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 204         } while (!SDIOH_API_SUCCESS(status)
 205                  && (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
 206 #endif
 207         if (err)
 208                 *err = (SDIOH_API_SUCCESS(status) ? 0 : -EIO);
 209
 210         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, u8data = 0x%x\n",
 211                      __func__, fnc_num, addr, data));
 212
 213         return data;
 214 }
 215
 216 void
 217 brcmf_sdcard_cfg_write(void *sdh, uint fnc_num, u32 addr, u8 data, int *err)
 218 {
 219         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 220         SDIOH_API_RC status;
 221 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 222         s32 retry = 0;
 223 #endif
 224
 225         if (!bcmsdh)
 226                 bcmsdh = l_bcmsdh;
 227
 228         ASSERT(bcmsdh->init_success);
 229
 230 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 231         do {
 232                 if (retry)      /* wait for 1 ms till bus get settled down */
 233                         udelay(1000);
 234 #endif
 235                 status =
 236                     brcmf_sdioh_cfg_write(bcmsdh->sdioh, fnc_num, addr,
 237                                     (u8 *) &data);
 238 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 239         } while (!SDIOH_API_SUCCESS(status)
 240                  && (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
 241 #endif
 242         if (err)
 243                 *err = SDIOH_API_SUCCESS(status) ? 0 : -EIO;
 244
 245         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, u8data = 0x%x\n",
 246                      __func__, fnc_num, addr, data));
 247 }
 248
 249 u32 brcmf_sdcard_cfg_read_word(void *sdh, uint fnc_num, u32 addr, int *err)
 250 {
 251         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 252         SDIOH_API_RC status;
 253         u32 data = 0;
 254
 255         if (!bcmsdh)
 256                 bcmsdh = l_bcmsdh;
 257
 258         ASSERT(bcmsdh->init_success);
 259
 260         status = brcmf_sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,
 261                 SDIOH_READ, fnc_num, addr, &data, 4);
 262
 263         if (err)
 264                 *err = (SDIOH_API_SUCCESS(status) ? 0 : -EIO);
 265
 266         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, u32data = 0x%x\n",
 267                      __func__, fnc_num, addr, data));
 268
 269         return data;
 270 }
 271
 272 void
 273 brcmf_sdcard_cfg_write_word(void *sdh, uint fnc_num, u32 addr, u32 data,
 274                       int *err)
 275 {
 276         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 277         SDIOH_API_RC status;
 278
 279         if (!bcmsdh)
 280                 bcmsdh = l_bcmsdh;
 281
 282         ASSERT(bcmsdh->init_success);
 283
 284         status =
 285             brcmf_sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,
 286                                SDIOH_WRITE, fnc_num, addr, &data, 4);
 287
 288         if (err)
 289                 *err = (SDIOH_API_SUCCESS(status) ? 0 : -EIO);
 290
 291         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, u32data = 0x%x\n",
 292                      __func__, fnc_num, addr, data));
 293 }
 294
 295 int brcmf_sdcard_cis_read(void *sdh, uint func, u8 * cis, uint length)
 296 {
 297         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 298         SDIOH_API_RC status;
 299
 300         u8 *tmp_buf, *tmp_ptr;
 301         u8 *ptr;
 302         bool ascii = func & ~0xf;
 303         func &= 0x7;
 304
 305         if (!bcmsdh)
 306                 bcmsdh = l_bcmsdh;
 307
 308         ASSERT(bcmsdh->init_success);
 309         ASSERT(cis);
 310         ASSERT(length <= SBSDIO_CIS_SIZE_LIMIT);
 311
 312         status = brcmf_sdioh_cis_read(bcmsdh->sdioh, func, cis, length);
 313
 314         if (ascii) {
 315                 /* Move binary bits to tmp and format them
 316                          into the provided buffer. */
 317                 tmp_buf = kmalloc(length, GFP_ATOMIC);
 318                 if (tmp_buf == NULL) {
 319                         BCMSDH_ERROR(("%s: out of memory\n", __func__));
 320                         return -ENOMEM;
 321                 }
 322                 memcpy(tmp_buf, cis, length);
 323                 for (tmp_ptr = tmp_buf, ptr = cis; ptr < (cis + length - 4);
 324                      tmp_ptr++) {
 325                         ptr += sprintf((char *)ptr, "%.2x ", *tmp_ptr & 0xff);
 326                         if ((((tmp_ptr - tmp_buf) + 1) & 0xf) == 0)
 327                                 ptr += sprintf((char *)ptr, "\n");
 328                 }
 329                 kfree(tmp_buf);
 330         }
 331
 332         return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
 333 }
 334
 335 static int brcmf_sdcard_set_sbaddr_window(void *sdh, u32 address)
 336 {
 337         int err = 0;
 338         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 339         brcmf_sdcard_cfg_write(bcmsdh, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRLOW,
 340                          (address >> 8) & SBSDIO_SBADDRLOW_MASK, &err);
 341         if (!err)
 342                 brcmf_sdcard_cfg_write(bcmsdh, SDIO_FUNC_1,
 343                                        SBSDIO_FUNC1_SBADDRMID,
 344                                        (address >> 16) & SBSDIO_SBADDRMID_MASK,
 345                                        &err);
 346         if (!err)
 347                 brcmf_sdcard_cfg_write(bcmsdh, SDIO_FUNC_1,
 348                                        SBSDIO_FUNC1_SBADDRHIGH,
 349                                        (address >> 24) & SBSDIO_SBADDRHIGH_MASK,
 350                                        &err);
 351
 352         return err;
 353 }
 354
 355 u32 brcmf_sdcard_reg_read(void *sdh, u32 addr, uint size)
 356 {
 357         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 358         SDIOH_API_RC status;
 359         u32 word = 0;
 360         uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
 361
 362         BCMSDH_INFO(("%s:fun = 1, addr = 0x%x, ", __func__, addr));
 363
 364         if (!bcmsdh)
 365                 bcmsdh = l_bcmsdh;
 366
 367         ASSERT(bcmsdh->init_success);
 368
 369         if (bar0 != bcmsdh->sbwad) {
 370                 if (brcmf_sdcard_set_sbaddr_window(bcmsdh, bar0))
 371                         return 0xFFFFFFFF;
 372
 373                 bcmsdh->sbwad = bar0;
 374         }
 375
 376         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 377         if (size == 4)
 378                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 379
 380         status = brcmf_sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,
 381                                     SDIOH_READ, SDIO_FUNC_1, addr, &word, size);
 382
 383         bcmsdh->regfail = !(SDIOH_API_SUCCESS(status));
 384
 385         BCMSDH_INFO(("u32data = 0x%x\n", word));
 386
 387         /* if ok, return appropriately masked word */
 388         if (SDIOH_API_SUCCESS(status)) {
 389                 switch (size) {
 390                 case sizeof(u8):
 391                         return word & 0xff;
 392                 case sizeof(u16):
 393                         return word & 0xffff;
 394                 case sizeof(u32):
 395                         return word;
 396                 default:
 397                         bcmsdh->regfail = true;
 398
 399                 }
 400         }
 401
 402         /* otherwise, bad sdio access or invalid size */
 403         BCMSDH_ERROR(("%s: error reading addr 0x%04x size %d\n", __func__,
 404                       addr, size));
 405         return 0xFFFFFFFF;
 406 }
 407
 408 u32 brcmf_sdcard_reg_write(void *sdh, u32 addr, uint size, u32 data)
 409 {
 410         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 411         SDIOH_API_RC status;
 412         uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
 413         int err = 0;
 414
 415         BCMSDH_INFO(("%s:fun = 1, addr = 0x%x, uint%ddata = 0x%x\n",
 416                      __func__, addr, size * 8, data));
 417
 418         if (!bcmsdh)
 419                 bcmsdh = l_bcmsdh;
 420
 421         ASSERT(bcmsdh->init_success);
 422
 423         if (bar0 != bcmsdh->sbwad) {
 424                 err = brcmf_sdcard_set_sbaddr_window(bcmsdh, bar0);
 425                 if (err)
 426                         return err;
 427
 428                 bcmsdh->sbwad = bar0;
 429         }
 430
 431         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 432         if (size == 4)
 433                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 434         status =
 435             brcmf_sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,
 436                                SDIOH_WRITE, SDIO_FUNC_1, addr, &data, size);
 437         bcmsdh->regfail = !(SDIOH_API_SUCCESS(status));
 438
 439         if (SDIOH_API_SUCCESS(status))
 440                 return 0;
 441
 442         BCMSDH_ERROR(("%s: error writing 0x%08x to addr 0x%04x size %d\n",
 443                       __func__, data, addr, size));
 444         return 0xFFFFFFFF;
 445 }
 446
 447 bool brcmf_sdcard_regfail(void *sdh)
 448 {
 449         return ((bcmsdh_info_t *) sdh)->regfail;
 450 }
 451
 452 int
 453 brcmf_sdcard_recv_buf(bcmsdh_info_t *bcmsdh, u32 addr, uint fn, uint flags,
 454                 u8 *buf, uint nbytes, struct sk_buff *pkt,
 455                 bcmsdh_cmplt_fn_t complete, void *handle)
 456 {
 457         SDIOH_API_RC status;
 458         uint incr_fix;
 459         uint width;
 460         uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
 461         int err = 0;
 462
 463         ASSERT(bcmsdh);
 464         ASSERT(bcmsdh->init_success);
 465
 466         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, size = %d\n",
 467                      __func__, fn, addr, nbytes));
 468
 469         /* Async not implemented yet */
 470         ASSERT(!(flags & SDIO_REQ_ASYNC));
 471         if (flags & SDIO_REQ_ASYNC)
 472                 return -ENOTSUPP;
 473
 474         if (bar0 != bcmsdh->sbwad) {
 475                 err = brcmf_sdcard_set_sbaddr_window(bcmsdh, bar0);
 476                 if (err)
 477                         return err;
 478
 479                 bcmsdh->sbwad = bar0;
 480         }
 481
 482         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 483
 484         incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
 485         width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
 486         if (width == 4)
 487                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 488
 489         status = brcmf_sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO,
 490                 incr_fix, SDIOH_READ, fn, addr, width, nbytes, buf, pkt);
 491
 492         return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
 493 }
 494
 495 int
 496 brcmf_sdcard_send_buf(void *sdh, u32 addr, uint fn, uint flags,
 497                 u8 *buf, uint nbytes, void *pkt,
 498                 bcmsdh_cmplt_fn_t complete, void *handle)
 499 {
 500         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 501         SDIOH_API_RC status;
 502         uint incr_fix;
 503         uint width;
 504         uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
 505         int err = 0;
 506
 507         ASSERT(bcmsdh);
 508         ASSERT(bcmsdh->init_success);
 509
 510         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, size = %d\n",
 511                      __func__, fn, addr, nbytes));
 512
 513         /* Async not implemented yet */
 514         ASSERT(!(flags & SDIO_REQ_ASYNC));
 515         if (flags & SDIO_REQ_ASYNC)
 516                 return -ENOTSUPP;
 517
 518         if (bar0 != bcmsdh->sbwad) {
 519                 err = brcmf_sdcard_set_sbaddr_window(bcmsdh, bar0);
 520                 if (err)
 521                         return err;
 522
 523                 bcmsdh->sbwad = bar0;
 524         }
 525
 526         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 527
 528         incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
 529         width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
 530         if (width == 4)
 531                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 532
 533         status = brcmf_sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO,
 534                 incr_fix, SDIOH_WRITE, fn, addr, width, nbytes, buf, pkt);
 535
 536         return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
 537 }
 538
 539 int brcmf_sdcard_rwdata(void *sdh, uint rw, u32 addr, u8 *buf, uint nbytes)
 540 {
 541         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 542         SDIOH_API_RC status;
 543
 544         ASSERT(bcmsdh);
 545         ASSERT(bcmsdh->init_success);
 546         ASSERT((addr & SBSDIO_SBWINDOW_MASK) == 0);
 547
 548         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 549         addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 550
 551         status = brcmf_sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO,
 552                 SDIOH_DATA_INC, (rw ? SDIOH_WRITE : SDIOH_READ), SDIO_FUNC_1,
 553                 addr, 4, nbytes, buf, NULL);
 554
 555         return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
 556 }
 557
 558 int brcmf_sdcard_abort(void *sdh, uint fn)
 559 {
 560         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 561
 562         return brcmf_sdioh_abort(bcmsdh->sdioh, fn);
 563 }
 564
 565 int brcmf_sdcard_start(void *sdh, int stage)
 566 {
 567         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 568
 569         return brcmf_sdioh_start(bcmsdh->sdioh, stage);
 570 }
 571
 572 int brcmf_sdcard_stop(void *sdh)
 573 {
 574         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 575
 576         return brcmf_sdioh_stop(bcmsdh->sdioh);
 577 }
 578
 579 int brcmf_sdcard_query_device(void *sdh)
 580 {
 581         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 582         bcmsdh->vendevid = (PCI_VENDOR_ID_BROADCOM << 16) | 0;
 583         return bcmsdh->vendevid;
 584 }
 585
 586 uint brcmf_sdcard_query_iofnum(void *sdh)
 587 {
 588         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 589
 590         if (!bcmsdh)
 591                 bcmsdh = l_bcmsdh;
 592
 593         return brcmf_sdioh_query_iofnum(bcmsdh->sdioh);
 594 }
 595
 596 int brcmf_sdcard_reset(bcmsdh_info_t *sdh)
 597 {
 598         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 599
 600         return brcmf_sdioh_reset(bcmsdh->sdioh);
 601 }
 602
 603 void *brcmf_sdcard_get_sdioh(bcmsdh_info_t *sdh)
 604 {
 605         ASSERT(sdh);
 606         return sdh->sdioh;
 607 }
 608
 609 /* Function to pass device-status bits to DHD. */
 610 u32 brcmf_sdcard_get_dstatus(void *sdh)
 611 {
 612         return 0;
 613 }
 614
 615 u32 brcmf_sdcard_cur_sbwad(void *sdh)
 616 {
 617         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
 618
 619         if (!bcmsdh)
 620                 bcmsdh = l_bcmsdh;
 621
 622         return bcmsdh->sbwad;
 623 }
 624
 625 void brcmf_sdcard_chipinfo(void *sdh, u32 chip, u32 chiprev)
 626 {
 627         return;
 628 }