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