drivers/net/wireless/rockchip_wlan/rkwifi/bcmdhd/bcmsdh.c

   1 /*
   2  *  BCMSDH interface glue
   3  *  implement bcmsdh API for SDIOH driver
   4  *
   5  * Copyright (C) 1999-2016, 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  *
  26  * <<Broadcom-WL-IPTag/Open:>>
  27  *
  28  * $Id: bcmsdh.c 514727 2014-11-12 03:02:48Z $
  29  */
  30
  31 /**
  32  * @file bcmsdh.c
  33  */
  34
  35 /* ****************** BCMSDH Interface Functions *************************** */
  36
  37 #include <typedefs.h>
  38 #include <bcmdevs.h>
  39 #include <bcmendian.h>
  40 #include <bcmutils.h>
  41 #include <hndsoc.h>
  42 #include <siutils.h>
  43 #include <osl.h>
  44
  45 #include <bcmsdh.h>     /* BRCM API for SDIO clients (such as wl, dhd) */
  46 #include <bcmsdbus.h>   /* common SDIO/controller interface */
  47 #include <sbsdio.h>     /* SDIO device core hardware definitions. */
  48 #include <sdio.h>       /* SDIO Device and Protocol Specs */
  49
  50 #define SDIOH_API_ACCESS_RETRY_LIMIT    2
  51 const uint bcmsdh_msglevel = BCMSDH_ERROR_VAL;
  52
  53 /* local copy of bcm sd handler */
  54 bcmsdh_info_t * l_bcmsdh = NULL;
  55
  56
  57 #if defined(OOB_INTR_ONLY) && defined(HW_OOB) || defined(FORCE_WOWLAN)
  58 extern int
  59 sdioh_enable_hw_oob_intr(void *sdioh, bool enable);
  60
  61 void
  62 bcmsdh_enable_hw_oob_intr(bcmsdh_info_t *sdh, bool enable)
  63 {
  64         sdioh_enable_hw_oob_intr(sdh->sdioh, enable);
  65 }
  66 #endif
  67
  68 /* Attach BCMSDH layer to SDIO Host Controller Driver
  69  *
  70  * @param osh OSL Handle.
  71  * @param cfghdl Configuration Handle.
  72  * @param regsva Virtual address of controller registers.
  73  * @param irq Interrupt number of SDIO controller.
  74  *
  75  * @return bcmsdh_info_t Handle to BCMSDH context.
  76  */
  77 bcmsdh_info_t *
  78 bcmsdh_attach(osl_t *osh, void *sdioh, ulong *regsva)
  79 {
  80         bcmsdh_info_t *bcmsdh;
  81
  82         if ((bcmsdh = (bcmsdh_info_t *)MALLOC(osh, sizeof(bcmsdh_info_t))) == NULL) {
  83                 BCMSDH_ERROR(("bcmsdh_attach: out of memory, malloced %d bytes\n", MALLOCED(osh)));
  84                 return NULL;
  85         }
  86         bzero((char *)bcmsdh, sizeof(bcmsdh_info_t));
  87         bcmsdh->sdioh = sdioh;
  88         bcmsdh->osh = osh;
  89         bcmsdh->init_success = TRUE;
  90         *regsva = SI_ENUM_BASE;
  91
  92         /* Report the BAR, to fix if needed */
  93         bcmsdh->sbwad = SI_ENUM_BASE;
  94
  95         /* save the handler locally */
  96         l_bcmsdh = bcmsdh;
  97
  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                 MFREE(osh, bcmsdh, sizeof(bcmsdh_info_t));
 108         }
 109
 110         l_bcmsdh = NULL;
 111
 112         return 0;
 113 }
 114
 115 int
 116 bcmsdh_iovar_op(void *sdh, const char *name,
 117                 void *params, int plen, void *arg, int len, bool set)
 118 {
 119         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 120         return sdioh_iovar_op(bcmsdh->sdioh, name, params, plen, arg, len, set);
 121 }
 122
 123 bool
 124 bcmsdh_intr_query(void *sdh)
 125 {
 126         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 127         SDIOH_API_RC status;
 128         bool on;
 129
 130         ASSERT(bcmsdh);
 131         status = sdioh_interrupt_query(bcmsdh->sdioh, &on);
 132         if (SDIOH_API_SUCCESS(status))
 133                 return FALSE;
 134         else
 135                 return on;
 136 }
 137
 138 int
 139 bcmsdh_intr_enable(void *sdh)
 140 {
 141         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 142         SDIOH_API_RC status;
 143         ASSERT(bcmsdh);
 144
 145         status = sdioh_interrupt_set(bcmsdh->sdioh, TRUE);
 146         return (SDIOH_API_SUCCESS(status) ? 0 : BCME_ERROR);
 147 }
 148
 149 int
 150 bcmsdh_intr_disable(void *sdh)
 151 {
 152         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 153         SDIOH_API_RC status;
 154         ASSERT(bcmsdh);
 155
 156         status = sdioh_interrupt_set(bcmsdh->sdioh, FALSE);
 157         return (SDIOH_API_SUCCESS(status) ? 0 : BCME_ERROR);
 158 }
 159
 160 int
 161 bcmsdh_intr_reg(void *sdh, bcmsdh_cb_fn_t fn, void *argh)
 162 {
 163         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 164         SDIOH_API_RC status;
 165         ASSERT(bcmsdh);
 166
 167         status = sdioh_interrupt_register(bcmsdh->sdioh, fn, argh);
 168         return (SDIOH_API_SUCCESS(status) ? 0 : BCME_ERROR);
 169 }
 170
 171 int
 172 bcmsdh_intr_dereg(void *sdh)
 173 {
 174         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 175         SDIOH_API_RC status;
 176         ASSERT(bcmsdh);
 177
 178         status = sdioh_interrupt_deregister(bcmsdh->sdioh);
 179         return (SDIOH_API_SUCCESS(status) ? 0 : BCME_ERROR);
 180 }
 181
 182 #if defined(DHD_DEBUG)
 183 bool
 184 bcmsdh_intr_pending(void *sdh)
 185 {
 186         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 187
 188         ASSERT(sdh);
 189         return sdioh_interrupt_pending(bcmsdh->sdioh);
 190 }
 191 #endif
 192
 193
 194 int
 195 bcmsdh_devremove_reg(void *sdh, bcmsdh_cb_fn_t fn, void *argh)
 196 {
 197         ASSERT(sdh);
 198
 199         /* don't support yet */
 200         return BCME_UNSUPPORTED;
 201 }
 202
 203 /**
 204  * Read from SDIO Configuration Space
 205  * @param sdh SDIO Host context.
 206  * @param func_num Function number to read from.
 207  * @param addr Address to read from.
 208  * @param err Error return.
 209  * @return value read from SDIO configuration space.
 210  */
 211 uint8
 212 bcmsdh_cfg_read(void *sdh, uint fnc_num, uint32 addr, int *err)
 213 {
 214         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 215         SDIOH_API_RC status;
 216 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 217         int32 retry = 0;
 218 #endif
 219         uint8 data = 0;
 220
 221         if (!bcmsdh)
 222                 bcmsdh = l_bcmsdh;
 223
 224         ASSERT(bcmsdh->init_success);
 225
 226 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 227         do {
 228                 if (retry)      /* wait for 1 ms till bus get settled down */
 229                         OSL_DELAY(1000);
 230 #endif
 231         status = sdioh_cfg_read(bcmsdh->sdioh, fnc_num, addr, (uint8 *)&data);
 232 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 233         } while (!SDIOH_API_SUCCESS(status) && (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
 234 #endif
 235         if (err)
 236                 *err = (SDIOH_API_SUCCESS(status) ? 0 : BCME_SDIO_ERROR);
 237
 238         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, uint8data = 0x%x\n", __FUNCTION__,
 239                     fnc_num, addr, data));
 240
 241         return data;
 242 }
 243
 244 void
 245 bcmsdh_cfg_write(void *sdh, uint fnc_num, uint32 addr, uint8 data, int *err)
 246 {
 247         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 248         SDIOH_API_RC status;
 249 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 250         int32 retry = 0;
 251 #endif
 252
 253         if (!bcmsdh)
 254                 bcmsdh = l_bcmsdh;
 255
 256         ASSERT(bcmsdh->init_success);
 257
 258 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 259         do {
 260                 if (retry)      /* wait for 1 ms till bus get settled down */
 261                         OSL_DELAY(1000);
 262 #endif
 263         status = sdioh_cfg_write(bcmsdh->sdioh, fnc_num, addr, (uint8 *)&data);
 264 #ifdef SDIOH_API_ACCESS_RETRY_LIMIT
 265         } while (!SDIOH_API_SUCCESS(status) && (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
 266 #endif
 267         if (err)
 268                 *err = SDIOH_API_SUCCESS(status) ? 0 : BCME_SDIO_ERROR;
 269
 270         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, uint8data = 0x%x\n", __FUNCTION__,
 271                     fnc_num, addr, data));
 272 }
 273
 274 uint32
 275 bcmsdh_cfg_read_word(void *sdh, uint fnc_num, uint32 addr, int *err)
 276 {
 277         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 278         SDIOH_API_RC status;
 279         uint32 data = 0;
 280
 281         if (!bcmsdh)
 282                 bcmsdh = l_bcmsdh;
 283
 284         ASSERT(bcmsdh->init_success);
 285
 286         status = sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL, SDIOH_READ, fnc_num,
 287                                     addr, &data, 4);
 288
 289         if (err)
 290                 *err = (SDIOH_API_SUCCESS(status) ? 0 : BCME_SDIO_ERROR);
 291
 292         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, uint32data = 0x%x\n", __FUNCTION__,
 293                     fnc_num, addr, data));
 294
 295         return data;
 296 }
 297
 298 void
 299 bcmsdh_cfg_write_word(void *sdh, uint fnc_num, uint32 addr, uint32 data, int *err)
 300 {
 301         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 302         SDIOH_API_RC status;
 303
 304         if (!bcmsdh)
 305                 bcmsdh = l_bcmsdh;
 306
 307         ASSERT(bcmsdh->init_success);
 308
 309         status = sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL, SDIOH_WRITE, fnc_num,
 310                                     addr, &data, 4);
 311
 312         if (err)
 313                 *err = (SDIOH_API_SUCCESS(status) ? 0 : BCME_SDIO_ERROR);
 314
 315         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, uint32data = 0x%x\n", __FUNCTION__, fnc_num,
 316                      addr, data));
 317 }
 318
 319
 320 int
 321 bcmsdh_cis_read(void *sdh, uint func, uint8 *cis, uint length)
 322 {
 323         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 324         SDIOH_API_RC status;
 325
 326         uint8 *tmp_buf, *tmp_ptr;
 327         uint8 *ptr;
 328         bool ascii = func & ~0xf;
 329         func &= 0x7;
 330
 331         if (!bcmsdh)
 332                 bcmsdh = l_bcmsdh;
 333
 334         ASSERT(bcmsdh->init_success);
 335         ASSERT(cis);
 336         ASSERT(length <= SBSDIO_CIS_SIZE_LIMIT);
 337
 338         status = sdioh_cis_read(bcmsdh->sdioh, func, cis, length);
 339
 340         if (ascii) {
 341                 /* Move binary bits to tmp and format them into the provided buffer. */
 342                 if ((tmp_buf = (uint8 *)MALLOC(bcmsdh->osh, length)) == NULL) {
 343                         BCMSDH_ERROR(("%s: out of memory\n", __FUNCTION__));
 344                         return BCME_NOMEM;
 345                 }
 346                 bcopy(cis, tmp_buf, length);
 347                 for (tmp_ptr = tmp_buf, ptr = cis; ptr < (cis + length - 4); tmp_ptr++) {
 348                         ptr += snprintf((char*)ptr, (cis + length - ptr - 4),
 349                                 "%.2x ", *tmp_ptr & 0xff);
 350                         if ((((tmp_ptr - tmp_buf) + 1) & 0xf) == 0)
 351                                 ptr += snprintf((char *)ptr, (cis + length - ptr -4), "\n");
 352                 }
 353                 MFREE(bcmsdh->osh, tmp_buf, length);
 354         }
 355
 356         return (SDIOH_API_SUCCESS(status) ? 0 : BCME_ERROR);
 357 }
 358
 359
 360 int
 361 bcmsdhsdio_set_sbaddr_window(void *sdh, uint32 address, bool force_set)
 362 {
 363         int err = 0;
 364         uint bar0 = address & ~SBSDIO_SB_OFT_ADDR_MASK;
 365         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 366
 367         if (bar0 != bcmsdh->sbwad || force_set) {
 368                 bcmsdh_cfg_write(bcmsdh, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRLOW,
 369                         (address >> 8) & SBSDIO_SBADDRLOW_MASK, &err);
 370                 if (!err)
 371                         bcmsdh_cfg_write(bcmsdh, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRMID,
 372                                 (address >> 16) & SBSDIO_SBADDRMID_MASK, &err);
 373                 if (!err)
 374                         bcmsdh_cfg_write(bcmsdh, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRHIGH,
 375                                 (address >> 24) & SBSDIO_SBADDRHIGH_MASK, &err);
 376
 377                 if (!err)
 378                         bcmsdh->sbwad = bar0;
 379                 else
 380                         /* invalidate cached window var */
 381                         bcmsdh->sbwad = 0;
 382
 383         }
 384
 385         return err;
 386 }
 387
 388 uint32
 389 bcmsdh_reg_read(void *sdh, uint32 addr, uint size)
 390 {
 391         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 392         SDIOH_API_RC status;
 393         uint32 word = 0;
 394
 395         BCMSDH_INFO(("%s:fun = 1, addr = 0x%x, ", __FUNCTION__, addr));
 396
 397         if (!bcmsdh)
 398                 bcmsdh = l_bcmsdh;
 399
 400         ASSERT(bcmsdh->init_success);
 401
 402         if (bcmsdhsdio_set_sbaddr_window(bcmsdh, addr, FALSE)) {
 403                 bcmsdh->regfail = TRUE; // terence 20130621: prevent dhd_dpc in dead lock
 404                 return 0xFFFFFFFF;
 405         }
 406
 407         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 408         if (size == 4)
 409                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 410
 411         status = sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,
 412                 SDIOH_READ, SDIO_FUNC_1, addr, &word, size);
 413
 414         bcmsdh->regfail = !(SDIOH_API_SUCCESS(status));
 415
 416         BCMSDH_INFO(("uint32data = 0x%x\n", word));
 417
 418         /* if ok, return appropriately masked word */
 419         if (SDIOH_API_SUCCESS(status)) {
 420                 switch (size) {
 421                         case sizeof(uint8):
 422                                 return (word & 0xff);
 423                         case sizeof(uint16):
 424                                 return (word & 0xffff);
 425                         case sizeof(uint32):
 426                                 return word;
 427                         default:
 428                                 bcmsdh->regfail = TRUE;
 429
 430                 }
 431         }
 432
 433         /* otherwise, bad sdio access or invalid size */
 434         BCMSDH_ERROR(("%s: error reading addr 0x%04x size %d\n", __FUNCTION__, addr, size));
 435         return 0xFFFFFFFF;
 436 }
 437
 438 uint32
 439 bcmsdh_reg_write(void *sdh, uint32 addr, uint size, uint32 data)
 440 {
 441         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 442         SDIOH_API_RC status;
 443         int err = 0;
 444
 445         BCMSDH_INFO(("%s:fun = 1, addr = 0x%x, uint%ddata = 0x%x\n",
 446                      __FUNCTION__, addr, size*8, data));
 447
 448         if (!bcmsdh)
 449                 bcmsdh = l_bcmsdh;
 450
 451         ASSERT(bcmsdh->init_success);
 452
 453         if ((err = bcmsdhsdio_set_sbaddr_window(bcmsdh, addr, FALSE))) {
 454                 bcmsdh->regfail = TRUE; // terence 20130621:
 455                 return err;
 456         }
 457
 458         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 459         if (size == 4)
 460                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 461         status = sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL, SDIOH_WRITE, SDIO_FUNC_1,
 462                                     addr, &data, size);
 463         bcmsdh->regfail = !(SDIOH_API_SUCCESS(status));
 464
 465         if (SDIOH_API_SUCCESS(status))
 466                 return 0;
 467
 468         BCMSDH_ERROR(("%s: error writing 0x%08x to addr 0x%04x size %d\n",
 469                       __FUNCTION__, data, addr, size));
 470         return 0xFFFFFFFF;
 471 }
 472
 473 bool
 474 bcmsdh_regfail(void *sdh)
 475 {
 476         return ((bcmsdh_info_t *)sdh)->regfail;
 477 }
 478
 479 int
 480 bcmsdh_recv_buf(void *sdh, uint32 addr, uint fn, uint flags,
 481                 uint8 *buf, uint nbytes, void *pkt,
 482                 bcmsdh_cmplt_fn_t complete_fn, void *handle)
 483 {
 484         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 485         SDIOH_API_RC status;
 486         uint incr_fix;
 487         uint width;
 488         int err = 0;
 489
 490         ASSERT(bcmsdh);
 491         ASSERT(bcmsdh->init_success);
 492
 493         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, size = %d\n",
 494                      __FUNCTION__, fn, addr, nbytes));
 495
 496         /* Async not implemented yet */
 497         ASSERT(!(flags & SDIO_REQ_ASYNC));
 498         if (flags & SDIO_REQ_ASYNC)
 499                 return BCME_UNSUPPORTED;
 500
 501         if ((err = bcmsdhsdio_set_sbaddr_window(bcmsdh, addr, FALSE)))
 502                 return err;
 503
 504         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 505
 506         incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
 507         width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
 508         if (width == 4)
 509                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 510
 511         status = sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO, incr_fix,
 512                                       SDIOH_READ, fn, addr, width, nbytes, buf, pkt);
 513
 514         return (SDIOH_API_SUCCESS(status) ? 0 : BCME_SDIO_ERROR);
 515 }
 516
 517 int
 518 bcmsdh_send_buf(void *sdh, uint32 addr, uint fn, uint flags,
 519                 uint8 *buf, uint nbytes, void *pkt,
 520                 bcmsdh_cmplt_fn_t complete_fn, void *handle)
 521 {
 522         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 523         SDIOH_API_RC status;
 524         uint incr_fix;
 525         uint width;
 526         int err = 0;
 527
 528         ASSERT(bcmsdh);
 529         ASSERT(bcmsdh->init_success);
 530
 531         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, size = %d\n",
 532                     __FUNCTION__, fn, addr, nbytes));
 533
 534         /* Async not implemented yet */
 535         ASSERT(!(flags & SDIO_REQ_ASYNC));
 536         if (flags & SDIO_REQ_ASYNC)
 537                 return BCME_UNSUPPORTED;
 538
 539         if ((err = bcmsdhsdio_set_sbaddr_window(bcmsdh, addr, FALSE)))
 540                 return err;
 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 int
 600 bcmsdh_waitlockfree(void *sdh)
 601 {
 602         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 603
 604         return sdioh_waitlockfree(bcmsdh->sdioh);
 605 }
 606
 607
 608 int
 609 bcmsdh_query_device(void *sdh)
 610 {
 611         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 612         bcmsdh->vendevid = (VENDOR_BROADCOM << 16) | 0;
 613         return (bcmsdh->vendevid);
 614 }
 615
 616 uint
 617 bcmsdh_query_iofnum(void *sdh)
 618 {
 619         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 620
 621         if (!bcmsdh)
 622                 bcmsdh = l_bcmsdh;
 623
 624         return (sdioh_query_iofnum(bcmsdh->sdioh));
 625 }
 626
 627 int
 628 bcmsdh_reset(bcmsdh_info_t *sdh)
 629 {
 630         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 631
 632         return sdioh_sdio_reset(bcmsdh->sdioh);
 633 }
 634
 635 void *bcmsdh_get_sdioh(bcmsdh_info_t *sdh)
 636 {
 637         ASSERT(sdh);
 638         return sdh->sdioh;
 639 }
 640
 641 /* Function to pass device-status bits to DHD. */
 642 uint32
 643 bcmsdh_get_dstatus(void *sdh)
 644 {
 645         return 0;
 646 }
 647 uint32
 648 bcmsdh_cur_sbwad(void *sdh)
 649 {
 650         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 651
 652         if (!bcmsdh)
 653                 bcmsdh = l_bcmsdh;
 654
 655         return (bcmsdh->sbwad);
 656 }
 657
 658 void
 659 bcmsdh_chipinfo(void *sdh, uint32 chip, uint32 chiprev)
 660 {
 661         return;
 662 }
 663
 664
 665 int
 666 bcmsdh_sleep(void *sdh, bool enab)
 667 {
 668 #ifdef SDIOH_SLEEP_ENABLED
 669         bcmsdh_info_t *p = (bcmsdh_info_t *)sdh;
 670         sdioh_info_t *sd = (sdioh_info_t *)(p->sdioh);
 671
 672         return sdioh_sleep(sd, enab);
 673 #else
 674         return BCME_UNSUPPORTED;
 675 #endif
 676 }
 677
 678 int
 679 bcmsdh_gpio_init(void *sdh)
 680 {
 681         bcmsdh_info_t *p = (bcmsdh_info_t *)sdh;
 682         sdioh_info_t *sd = (sdioh_info_t *)(p->sdioh);
 683
 684         return sdioh_gpio_init(sd);
 685 }
 686
 687 bool
 688 bcmsdh_gpioin(void *sdh, uint32 gpio)
 689 {
 690         bcmsdh_info_t *p = (bcmsdh_info_t *)sdh;
 691         sdioh_info_t *sd = (sdioh_info_t *)(p->sdioh);
 692
 693         return sdioh_gpioin(sd, gpio);
 694 }
 695
 696 int
 697 bcmsdh_gpioouten(void *sdh, uint32 gpio)
 698 {
 699         bcmsdh_info_t *p = (bcmsdh_info_t *)sdh;
 700         sdioh_info_t *sd = (sdioh_info_t *)(p->sdioh);
 701
 702         return sdioh_gpioouten(sd, gpio);
 703 }
 704
 705 int
 706 bcmsdh_gpioout(void *sdh, uint32 gpio, bool enab)
 707 {
 708         bcmsdh_info_t *p = (bcmsdh_info_t *)sdh;
 709         sdioh_info_t *sd = (sdioh_info_t *)(p->sdioh);
 710
 711         return sdioh_gpioout(sd, gpio, enab);
 712 }
 713
 714 uint
 715 bcmsdh_set_mode(void *sdh, uint mode)
 716 {
 717         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 718         return (sdioh_set_mode(bcmsdh->sdioh, mode));
 719 }
 720
 721 #if defined(SWTXGLOM)
 722 int
 723 bcmsdh_send_swtxglom_buf(void *sdh, uint32 addr, uint fn, uint flags,
 724                 uint8 *buf, uint nbytes, void *pkt,
 725                 bcmsdh_cmplt_fn_t complete_fn, void *handle)
 726 {
 727         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 728         SDIOH_API_RC status;
 729         uint incr_fix;
 730         uint width;
 731         int err = 0;
 732
 733         ASSERT(bcmsdh);
 734         ASSERT(bcmsdh->init_success);
 735
 736         BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, size = %d\n",
 737                     __FUNCTION__, fn, addr, nbytes));
 738
 739         /* Async not implemented yet */
 740         ASSERT(!(flags & SDIO_REQ_ASYNC));
 741         if (flags & SDIO_REQ_ASYNC)
 742                 return BCME_UNSUPPORTED;
 743
 744         if ((err = bcmsdhsdio_set_sbaddr_window(bcmsdh, addr, FALSE)))
 745                 return err;
 746
 747         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 748
 749         incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
 750         width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
 751         if (width == 4)
 752                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 753
 754         status = sdioh_request_swtxglom_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO, incr_fix,
 755                                       SDIOH_WRITE, fn, addr, width, nbytes, buf, pkt);
 756
 757         return (SDIOH_API_SUCCESS(status) ? 0 : BCME_ERROR);
 758 }
 759
 760 void
 761 bcmsdh_glom_post(void *sdh, uint8 *frame, void *pkt, uint len)
 762 {
 763         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 764         sdioh_glom_post(bcmsdh->sdioh, frame, pkt, len);
 765 }
 766
 767 void
 768 bcmsdh_glom_clear(void *sdh)
 769 {
 770         bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *)sdh;
 771         sdioh_glom_clear(bcmsdh->sdioh);
 772 }
 773 #endif /* SWTXGLOM */