drivers/net/wireless/bcm4329/bcmsdh.c

   1 /*
   2  *  BCMSDH interface glue
   3  *  implement bcmsdh API for SDIOH driver
   4  *
   5  * Copyright (C) 1999-2010, Broadcom Corporation
   6  *
   7  *      Unless you and Broadcom execute a separate written software license
   8  * agreement governing use of this software, this software is licensed to you
   9  * under the terms of the GNU General Public License version 2 (the "GPL"),
  10  * available at http://www.broadcom.com/licenses/GPLv2.php, with the
  11  * following added to such license:
  12  *
  13  *      As a special exception, the copyright holders of this software give you
  14  * permission to link this software with independent modules, and to copy and
  15  * distribute the resulting executable under terms of your choice, provided that
  16  * you also meet, for each linked independent module, the terms and conditions of
  17  * the license of that module.  An independent module is a module which is not
  18  * derived from this software.  The special exception does not apply to any
  19  * modifications of the software.
  20  *
  21  *      Notwithstanding the above, under no circumstances may you combine this
  22  * software in any way with any other Broadcom software provided under a license
  23  * other than the GPL, without Broadcom's express prior written consent.
  24  *
  25  * $Id: bcmsdh.c,v 1.35.2.1.4.8.6.13 2010/04/06 03:26:57 Exp $
  26  */
  27 /* ****************** BCMSDH Interface Functions *************************** */
  28
  29 #include <typedefs.h>
  30 #include <bcmdevs.h>
  31 #include <bcmendian.h>
  32 #include <bcmutils.h>
  33 #include <hndsoc.h>
  34 #include <siutils.h>
  35 #include <osl.h>
  36
  37 #include <bcmsdh.h>     /* BRCM API for SDIO clients (such as wl, dhd) */
  38 #include <bcmsdbus.h>   /* common SDIO/controller interface */
  39 #include <sbsdio.h>     /* BRCM sdio device core */
  40
  41 #include <sdio.h>       /* sdio spec */
  42
  43 /* Defines number of access retries to configuration registers */
  44 #define SDIOH_API_ACCESS_RETRY_LIMIT    2
  45
  46 const uint bcmsdh_msglevel = BCMSDH_ERROR_VAL;
  47
  48
  49 struct bcmsdh_info
  50 {
  51         bool    init_success;   /* underlying driver successfully attached */
  52         void    *sdioh;         /* handler for sdioh */
  53         uint32  vendevid;       /* Target Vendor and Device ID on SD bus */
  54         osl_t   *osh;
  55         bool    regfail;        /* Save status of last reg_read/reg_write call */
  56         uint32  sbwad;          /* Save backplane window address */
  57 };
  58 /* local copy of bcm sd handler */
  59 bcmsdh_info_t * l_bcmsdh = NULL;
  60
  61 #if defined(OOB_INTR_ONLY) && defined(HW_OOB)
  62 extern int
  63 sdioh_enable_hw_oob_intr(void *sdioh, bool enable);
  64
  65 void
  66 bcmsdh_enable_hw_oob_intr(bcmsdh_info_t *sdh, bool enable)
  67 {
  68         sdioh_enable_hw_oob_intr(sdh->sdioh, enable);
  69 }
  70 #endif
  71
  72 bcmsdh_info_t *
  73 bcmsdh_attach(osl_t *osh, void *cfghdl, void **regsva, uint irq)
  74 {
  75         bcmsdh_info_t *bcmsdh;
  76
  77         if ((bcmsdh = (bcmsdh_info_t *)MALLOC(osh, sizeof(bcmsdh_info_t))) == NULL) {
  78                 BCMSDH_ERROR(("bcmsdh_attach: out of memory, malloced %d bytes\n", MALLOCED(osh)));
  79                 return NULL;
  80         }
  81         bzero((char *)bcmsdh, sizeof(bcmsdh_info_t));
  82
  83         /* save the handler locally */
  84         l_bcmsdh = bcmsdh;
  85
  86         if (!(bcmsdh->sdioh = sdioh_attach(osh, cfghdl, irq))) {
  87                 bcmsdh_detach(osh, bcmsdh);
  88                 return NULL;
  89         }
  90
  91         bcmsdh->osh = osh;
  92         bcmsdh->init_success = TRUE;
  93
  94         *regsva = (uint32 *)SI_ENUM_BASE;
  95
  96         /* Report the BAR, to fix if needed */
  97         bcmsdh->sbwad = SI_ENUM_BASE;
  98         return bcmsdh;
  99 }
 100
 101 int
 102 bcmsdh_detach(osl_t *osh, void *sdh)
 103 {
 104         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 105
 106         if (bcmsdh != NULL) {
 107                 if (bcmsdh->sdioh) {
 108                         sdioh_detach(osh, bcmsdh->sdioh);
 109                         bcmsdh->sdioh = NULL;
 110                 }
 111                 MFREE(osh, bcmsdh, sizeof(bcmsdh_info_t));
 112         }
 113
 114         l_bcmsdh = NULL;
 115         return 0;
 116 }
 117
 118 int
 119 bcmsdh_iovar_op(void *sdh, const char *name,
 120                 void *params, int plen, void *arg, int len, bool set)
 121 {
 122         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 123         return sdioh_iovar_op(bcmsdh->sdioh, name, params, plen, arg, len, set);
 124 }
 125
 126 bool
 127 bcmsdh_intr_query(void *sdh)
 128 {
 129         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 130         SDIOH_API_RC status;
 131         bool on;
 132
 133         ASSERT(bcmsdh);
 134         status = sdioh_interrupt_query(bcmsdh->sdioh, &on);
 135         if (SDIOH_API_SUCCESS(status))
 136                 return FALSE;
 137         else
 138                 return on;
 139 }
 140
 141 int
 142 bcmsdh_intr_enable(void *sdh)
 143 {
 144         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 145         SDIOH_API_RC status;
 146         ASSERT(bcmsdh);
 147
 148         status = sdioh_interrupt_set(bcmsdh->sdioh, TRUE);
 149         return (SDIOH_API_SUCCESS(status) ? 0 : BCME_ERROR);
 150 }
 151
 152 int
 153 bcmsdh_intr_disable(void *sdh)
 154 {
 155         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 156         SDIOH_API_RC status;
 157         ASSERT(bcmsdh);
 158
 159         status = sdioh_interrupt_set(bcmsdh->sdioh, FALSE);
 160         return (SDIOH_API_SUCCESS(status) ? 0 : BCME_ERROR);
 161 }
 162
 163 int
 164 bcmsdh_intr_reg(void *sdh, bcmsdh_cb_fn_t fn, void *argh)
 165 {
 166         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 167         SDIOH_API_RC status;
 168         ASSERT(bcmsdh);
 169
 170         status = sdioh_interrupt_register(bcmsdh->sdioh, fn, argh);
 171         return (SDIOH_API_SUCCESS(status) ? 0 : BCME_ERROR);
 172 }
 173
 174 int
 175 bcmsdh_intr_dereg(void *sdh)
 176 {
 177         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 178         SDIOH_API_RC status;
 179         ASSERT(bcmsdh);
 180
 181         status = sdioh_interrupt_deregister(bcmsdh->sdioh);
 182         return (SDIOH_API_SUCCESS(status) ? 0 : BCME_ERROR);
 183 }
 184
 185 #if defined(DHD_DEBUG)
 186 bool
 187 bcmsdh_intr_pending(void *sdh)
 188 {
 189         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 190
 191         ASSERT(sdh);
 192         return sdioh_interrupt_pending(bcmsdh->sdioh);
 193 }
 194 #endif
 195
 196
 197 int
 198 bcmsdh_devremove_reg(void *sdh, bcmsdh_cb_fn_t fn, void *argh)
 199 {
 200         ASSERT(sdh);
 201
 202         /* don't support yet */
 203         return BCME_UNSUPPORTED;
 204 }
 205
 206 uint8
 207 bcmsdh_cfg_read(void *sdh, uint fnc_num, uint32 addr, int *err)
 208 {
 209         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 210         SDIOH_API_RC status;
 211 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 212         int32 retry = 0;
 213 #endif
 214         uint8 data = 0;
 215
 216         if (!bcmsdh)
 217                 bcmsdh = l_bcmsdh;
 218
 219         ASSERT(bcmsdh->init_success);
 220
 221 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 222         do {
 223                 if (retry)      /* wait for 1 ms till bus get settled down */
 224                         OSL_DELAY(1000);
 225 #endif
 226         status = sdioh_cfg_read(bcmsdh->sdioh, fnc_num, addr, (uint8 *)&data);
 227 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 228         } while (!SDIOH_API_SUCCESS(status) && (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
 229 #endif
 230         if (err)
 231                 *err = (SDIOH_API_SUCCESS(status) ? 0 : BCME_SDIO_ERROR);
 232
 233         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, uint8data = 0x%x\n", __FUNCTION__,
 234                     fnc_num, addr, data));
 235
 236         return data;
 237 }
 238
 239 void
 240 bcmsdh_cfg_write(void *sdh, uint fnc_num, uint32 addr, uint8 data, int *err)
 241 {
 242         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 243         SDIOH_API_RC status;
 244 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 245         int32 retry = 0;
 246 #endif
 247
 248         if (!bcmsdh)
 249                 bcmsdh = l_bcmsdh;
 250
 251         ASSERT(bcmsdh->init_success);
 252
 253 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 254         do {
 255                 if (retry)      /* wait for 1 ms till bus get settled down */
 256                         OSL_DELAY(1000);
 257 #endif
 258         status = sdioh_cfg_write(bcmsdh->sdioh, fnc_num, addr, (uint8 *)&data);
 259 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 260         } while (!SDIOH_API_SUCCESS(status) && (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
 261 #endif
 262         if (err)
 263                 *err = SDIOH_API_SUCCESS(status) ? 0 : BCME_SDIO_ERROR;
 264
 265         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, uint8data = 0x%x\n", __FUNCTION__,
 266                     fnc_num, addr, data));
 267 }
 268
 269 uint32
 270 bcmsdh_cfg_read_word(void *sdh, uint fnc_num, uint32 addr, int *err)
 271 {
 272         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 273         SDIOH_API_RC status;
 274         uint32 data = 0;
 275
 276         if (!bcmsdh)
 277                 bcmsdh = l_bcmsdh;
 278
 279         ASSERT(bcmsdh->init_success);
 280
 281         status = sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL, SDIOH_READ, fnc_num,
 282                                     addr, &data, 4);
 283
 284         if (err)
 285                 *err = (SDIOH_API_SUCCESS(status) ? 0 : BCME_SDIO_ERROR);
 286
 287         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, uint32data = 0x%x\n", __FUNCTION__,
 288                     fnc_num, addr, data));
 289
 290         return data;
 291 }
 292
 293 void
 294 bcmsdh_cfg_write_word(void *sdh, uint fnc_num, uint32 addr, uint32 data, int *err)
 295 {
 296         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 297         SDIOH_API_RC status;
 298
 299         if (!bcmsdh)
 300                 bcmsdh = l_bcmsdh;
 301
 302         ASSERT(bcmsdh->init_success);
 303
 304         status = sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL, SDIOH_WRITE, fnc_num,
 305                                     addr, &data, 4);
 306
 307         if (err)
 308                 *err = (SDIOH_API_SUCCESS(status) ? 0 : BCME_SDIO_ERROR);
 309
 310         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, uint32data = 0x%x\n", __FUNCTION__, fnc_num,
 311                      addr, data));
 312 }
 313
 314
 315 int
 316 bcmsdh_cis_read(void *sdh, uint func, uint8 *cis, uint length)
 317 {
 318         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 319         SDIOH_API_RC status;
 320
 321         uint8 *tmp_buf, *tmp_ptr;
 322         uint8 *ptr;
 323         bool ascii = func & ~0xf;
 324         func &= 0x7;
 325
 326         if (!bcmsdh)
 327                 bcmsdh = l_bcmsdh;
 328
 329         ASSERT(bcmsdh->init_success);
 330         ASSERT(cis);
 331         ASSERT(length <= SBSDIO_CIS_SIZE_LIMIT);
 332
 333         status = sdioh_cis_read(bcmsdh->sdioh, func, cis, length);
 334
 335         if (ascii) {
 336                 /* Move binary bits to tmp and format them into the provided buffer. */
 337                 if ((tmp_buf = (uint8 *)MALLOC(bcmsdh->osh, length)) == NULL) {
 338                         BCMSDH_ERROR(("%s: out of memory\n", __FUNCTION__));
 339                         return BCME_NOMEM;
 340                 }
 341                 bcopy(cis, tmp_buf, length);
 342                 for (tmp_ptr = tmp_buf, ptr = cis; ptr < (cis + length - 4); tmp_ptr++) {
 343                         ptr += sprintf((char*)ptr, "%.2x ", *tmp_ptr & 0xff);
 344                         if ((((tmp_ptr - tmp_buf) + 1) & 0xf) == 0)
 345                                 ptr += sprintf((char *)ptr, "\n");
 346                 }
 347                 MFREE(bcmsdh->osh, tmp_buf, length);
 348         }
 349
 350         return (SDIOH_API_SUCCESS(status) ? 0 : BCME_ERROR);
 351 }
 352
 353
 354 static int
 355 bcmsdhsdio_set_sbaddr_window(void *sdh, uint32 address)
 356 {
 357         int err = 0;
 358         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 359         bcmsdh_cfg_write(bcmsdh, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRLOW,
 360                          (address >> 8) & SBSDIO_SBADDRLOW_MASK, &err);
 361         if (!err)
 362                 bcmsdh_cfg_write(bcmsdh, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRMID,
 363                                  (address >> 16) & SBSDIO_SBADDRMID_MASK, &err);
 364         if (!err)
 365                 bcmsdh_cfg_write(bcmsdh, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRHIGH,
 366                                  (address >> 24) & SBSDIO_SBADDRHIGH_MASK, &err);
 367
 368
 369         return err;
 370 }
 371
 372 uint32
 373 bcmsdh_reg_read(void *sdh, uint32 addr, uint size)
 374 {
 375         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 376         SDIOH_API_RC status;
 377         uint32 word = 0;
 378         uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
 379
 380         BCMSDH_INFO(("%s:fun = 1, addr = 0x%x, ", __FUNCTION__, addr));
 381
 382         if (!bcmsdh)
 383                 bcmsdh = l_bcmsdh;
 384
 385         ASSERT(bcmsdh->init_success);
 386
 387         if (bar0 != bcmsdh->sbwad) {
 388                 if (bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0))
 389                         return 0xFFFFFFFF;
 390
 391                 bcmsdh->sbwad = bar0;
 392         }
 393
 394         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 395         if (size == 4)
 396                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 397
 398         status = sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,
 399                 SDIOH_READ, SDIO_FUNC_1, addr, &word, size);
 400
 401         bcmsdh->regfail = !(SDIOH_API_SUCCESS(status));
 402
 403         BCMSDH_INFO(("uint32data = 0x%x\n", word));
 404
 405         /* if ok, return appropriately masked word */
 406         if (SDIOH_API_SUCCESS(status)) {
 407                 switch (size) {
 408                         case sizeof(uint8):
 409                                 return (word & 0xff);
 410                         case sizeof(uint16):
 411                                 return (word & 0xffff);
 412                         case sizeof(uint32):
 413                                 return word;
 414                         default:
 415                                 bcmsdh->regfail = TRUE;
 416
 417                 }
 418         }
 419
 420         /* otherwise, bad sdio access or invalid size */
 421         BCMSDH_ERROR(("%s: error reading addr 0x%04x size %d\n", __FUNCTION__, addr, size));
 422         return 0xFFFFFFFF;
 423 }
 424
 425 uint32
 426 bcmsdh_reg_write(void *sdh, uint32 addr, uint size, uint32 data)
 427 {
 428         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 429         SDIOH_API_RC status;
 430         uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
 431         int err = 0;
 432
 433         BCMSDH_INFO(("%s:fun = 1, addr = 0x%x, uint%ddata = 0x%x\n",
 434                      __FUNCTION__, addr, size*8, data));
 435
 436         if (!bcmsdh)
 437                 bcmsdh = l_bcmsdh;
 438
 439         ASSERT(bcmsdh->init_success);
 440
 441         if (bar0 != bcmsdh->sbwad) {
 442                 if ((err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0)))
 443                         return err;
 444
 445                 bcmsdh->sbwad = bar0;
 446         }
 447
 448         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 449         if (size == 4)
 450                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 451         status = sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL, SDIOH_WRITE, SDIO_FUNC_1,
 452                                     addr, &data, size);
 453         bcmsdh->regfail = !(SDIOH_API_SUCCESS(status));
 454
 455         if (SDIOH_API_SUCCESS(status))
 456                 return 0;
 457
 458         BCMSDH_ERROR(("%s: error writing 0x%08x to addr 0x%04x size %d\n",
 459                       __FUNCTION__, data, addr, size));
 460         return 0xFFFFFFFF;
 461 }
 462
 463 bool
 464 bcmsdh_regfail(void *sdh)
 465 {
 466         return ((bcmsdh_info_t *)sdh)->regfail;
 467 }
 468
 469 int
 470 bcmsdh_recv_buf(void *sdh, uint32 addr, uint fn, uint flags,
 471                 uint8 *buf, uint nbytes, void *pkt,
 472                 bcmsdh_cmplt_fn_t complete, void *handle)
 473 {
 474         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 475         SDIOH_API_RC status;
 476         uint incr_fix;
 477         uint width;
 478         uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
 479         int err = 0;
 480
 481         ASSERT(bcmsdh);
 482         ASSERT(bcmsdh->init_success);
 483
 484         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, size = %d\n",
 485                      __FUNCTION__, fn, addr, nbytes));
 486
 487         /* Async not implemented yet */
 488         ASSERT(!(flags & SDIO_REQ_ASYNC));
 489         if (flags & SDIO_REQ_ASYNC)
 490                 return BCME_UNSUPPORTED;
 491
 492         if (bar0 != bcmsdh->sbwad) {
 493                 if ((err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0)))
 494                         return err;
 495
 496                 bcmsdh->sbwad = bar0;
 497         }
 498
 499         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 500
 501         incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
 502         width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
 503         if (width == 4)
 504                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 505
 506         status = sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO, incr_fix,
 507                                       SDIOH_READ, fn, addr, width, nbytes, buf, pkt);
 508
 509         return (SDIOH_API_SUCCESS(status) ? 0 : BCME_SDIO_ERROR);
 510 }
 511
 512 int
 513 bcmsdh_send_buf(void *sdh, uint32 addr, uint fn, uint flags,
 514                 uint8 *buf, uint nbytes, void *pkt,
 515                 bcmsdh_cmplt_fn_t complete, void *handle)
 516 {
 517         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 518         SDIOH_API_RC status;
 519         uint incr_fix;
 520         uint width;
 521         uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
 522         int err = 0;
 523
 524         ASSERT(bcmsdh);
 525         ASSERT(bcmsdh->init_success);
 526
 527         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, size = %d\n",
 528                     __FUNCTION__, fn, addr, nbytes));
 529
 530         /* Async not implemented yet */
 531         ASSERT(!(flags & SDIO_REQ_ASYNC));
 532         if (flags & SDIO_REQ_ASYNC)
 533                 return BCME_UNSUPPORTED;
 534
 535         if (bar0 != bcmsdh->sbwad) {
 536                 if ((err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0)))
 537                         return err;
 538
 539                 bcmsdh->sbwad = bar0;
 540         }
 541
 542         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 543
 544         incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
 545         width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
 546         if (width == 4)
 547                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 548
 549         status = sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO, incr_fix,
 550                                       SDIOH_WRITE, fn, addr, width, nbytes, buf, pkt);
 551
 552         return (SDIOH_API_SUCCESS(status) ? 0 : BCME_ERROR);
 553 }
 554
 555 int
 556 bcmsdh_rwdata(void *sdh, uint rw, uint32 addr, uint8 *buf, uint nbytes)
 557 {
 558         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 559         SDIOH_API_RC status;
 560
 561         ASSERT(bcmsdh);
 562         ASSERT(bcmsdh->init_success);
 563         ASSERT((addr & SBSDIO_SBWINDOW_MASK) == 0);
 564
 565         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 566         addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 567
 568         status = sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO, SDIOH_DATA_INC,
 569                                       (rw ? SDIOH_WRITE : SDIOH_READ), SDIO_FUNC_1,
 570                                       addr, 4, nbytes, buf, NULL);
 571
 572         return (SDIOH_API_SUCCESS(status) ? 0 : BCME_ERROR);
 573 }
 574
 575 int
 576 bcmsdh_abort(void *sdh, uint fn)
 577 {
 578         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 579
 580         return sdioh_abort(bcmsdh->sdioh, fn);
 581 }
 582
 583 int
 584 bcmsdh_start(void *sdh, int stage)
 585 {
 586         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 587
 588         return sdioh_start(bcmsdh->sdioh, stage);
 589 }
 590
 591 int
 592 bcmsdh_stop(void *sdh)
 593 {
 594         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 595
 596         return sdioh_stop(bcmsdh->sdioh);
 597 }
 598
 599
 600 int
 601 bcmsdh_query_device(void *sdh)
 602 {
 603         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 604         bcmsdh->vendevid = (VENDOR_BROADCOM << 16) | 0;
 605         return (bcmsdh->vendevid);
 606 }
 607
 608 uint
 609 bcmsdh_query_iofnum(void *sdh)
 610 {
 611         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 612
 613         if (!bcmsdh)
 614                 bcmsdh = l_bcmsdh;
 615
 616         return (sdioh_query_iofnum(bcmsdh->sdioh));
 617 }
 618
 619 int
 620 bcmsdh_reset(bcmsdh_info_t *sdh)
 621 {
 622         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 623
 624         return sdioh_sdio_reset(bcmsdh->sdioh);
 625 }
 626
 627 void *bcmsdh_get_sdioh(bcmsdh_info_t *sdh)
 628 {
 629         ASSERT(sdh);
 630         return sdh->sdioh;
 631 }
 632
 633 /* Function to pass device-status bits to DHD. */
 634 uint32
 635 bcmsdh_get_dstatus(void *sdh)
 636 {
 637         return 0;
 638 }
 639 uint32
 640 bcmsdh_cur_sbwad(void *sdh)
 641 {
 642         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 643
 644         if (!bcmsdh)
 645                 bcmsdh = l_bcmsdh;
 646
 647         return (bcmsdh->sbwad);
 648 }
 649
 650 void
 651 bcmsdh_chipinfo(void *sdh, uint32 chip, uint32 chiprev)
 652 {
 653         return;
 654 }