drivers/staging/brcm80211/brcmfmac/bcmsdh_sdmmc.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 #include <linux/types.h>
  17 #include <bcmdefs.h>
  18 #include <bcmdevs.h>
  19 #include <bcmendian.h>
  20 #include <bcmutils.h>
  21 #include <osl.h>
  22 #include <sdio.h>               /* SDIO Device and Protocol Specs */
  23 #include <sdioh.h>              /* SDIO Host Controller Specification */
  24 #include <bcmsdbus.h>           /* bcmsdh to/from specific controller APIs */
  25 #include <sdiovar.h>            /* ioctl/iovars */
  26
  27 #include <linux/mmc/core.h>
  28 #include <linux/mmc/sdio_func.h>
  29 #include <linux/mmc/sdio_ids.h>
  30
  31 #include <dngl_stats.h>
  32 #include <dhd.h>
  33
  34 #if defined(CONFIG_PM_SLEEP)
  35 #include <linux/suspend.h>
  36 extern volatile bool dhd_mmc_suspend;
  37 #endif
  38 #include "bcmsdh_sdmmc.h"
  39
  40 extern int sdio_function_init(void);
  41 extern void sdio_function_cleanup(void);
  42
  43 #if !defined(OOB_INTR_ONLY)
  44 static void IRQHandler(struct sdio_func *func);
  45 static void IRQHandlerF2(struct sdio_func *func);
  46 #endif                          /* !defined(OOB_INTR_ONLY) */
  47 static int sdioh_sdmmc_get_cisaddr(sdioh_info_t *sd, u32 regaddr);
  48 extern int sdio_reset_comm(struct mmc_card *card);
  49
  50 extern PBCMSDH_SDMMC_INSTANCE gInstance;
  51
  52 uint sd_sdmode = SDIOH_MODE_SD4;        /* Use SD4 mode by default */
  53 uint sd_f2_blocksize = 512;     /* Default blocksize */
  54
  55 uint sd_divisor = 2;            /* Default 48MHz/2 = 24MHz */
  56
  57 uint sd_power = 1;              /* Default to SD Slot powered ON */
  58 uint sd_clock = 1;              /* Default to SD Clock turned ON */
  59 uint sd_hiok = false;           /* Don't use hi-speed mode by default */
  60 uint sd_msglevel = 0x01;
  61 uint sd_use_dma = true;
  62 DHD_PM_RESUME_WAIT_INIT(sdioh_request_byte_wait);
  63 DHD_PM_RESUME_WAIT_INIT(sdioh_request_word_wait);
  64 DHD_PM_RESUME_WAIT_INIT(sdioh_request_packet_wait);
  65 DHD_PM_RESUME_WAIT_INIT(sdioh_request_buffer_wait);
  66
  67 #define DMA_ALIGN_MASK  0x03
  68
  69 int sdioh_sdmmc_card_regread(sdioh_info_t *sd, int func, u32 regaddr,
  70                              int regsize, u32 *data);
  71
  72 static int sdioh_sdmmc_card_enablefuncs(sdioh_info_t *sd)
  73 {
  74         int err_ret;
  75         u32 fbraddr;
  76         u8 func;
  77
  78         sd_trace(("%s\n", __func__));
  79
  80         /* Get the Card's common CIS address */
  81         sd->com_cis_ptr = sdioh_sdmmc_get_cisaddr(sd, SDIOD_CCCR_CISPTR_0);
  82         sd->func_cis_ptr[0] = sd->com_cis_ptr;
  83         sd_info(("%s: Card's Common CIS Ptr = 0x%x\n", __func__,
  84                  sd->com_cis_ptr));
  85
  86         /* Get the Card's function CIS (for each function) */
  87         for (fbraddr = SDIOD_FBR_STARTADDR, func = 1;
  88              func <= sd->num_funcs; func++, fbraddr += SDIOD_FBR_SIZE) {
  89                 sd->func_cis_ptr[func] =
  90                     sdioh_sdmmc_get_cisaddr(sd, SDIOD_FBR_CISPTR_0 + fbraddr);
  91                 sd_info(("%s: Function %d CIS Ptr = 0x%x\n", __func__, func,
  92                          sd->func_cis_ptr[func]));
  93         }
  94
  95         sd->func_cis_ptr[0] = sd->com_cis_ptr;
  96         sd_info(("%s: Card's Common CIS Ptr = 0x%x\n", __func__,
  97                  sd->com_cis_ptr));
  98
  99         /* Enable Function 1 */
 100         sdio_claim_host(gInstance->func[1]);
 101         err_ret = sdio_enable_func(gInstance->func[1]);
 102         sdio_release_host(gInstance->func[1]);
 103         if (err_ret) {
 104                 sd_err(("bcmsdh_sdmmc: Failed to enable F1 Err: 0x%08x",
 105                         err_ret));
 106         }
 107
 108         return false;
 109 }
 110
 111 /*
 112  *      Public entry points & extern's
 113  */
 114 extern sdioh_info_t *sdioh_attach(osl_t *osh, void *bar0, uint irq)
 115 {
 116         sdioh_info_t *sd;
 117         int err_ret;
 118
 119         sd_trace(("%s\n", __func__));
 120
 121         if (gInstance == NULL) {
 122                 sd_err(("%s: SDIO Device not present\n", __func__));
 123                 return NULL;
 124         }
 125
 126         sd = kzalloc(sizeof(sdioh_info_t), GFP_ATOMIC);
 127         if (sd == NULL) {
 128                 sd_err(("sdioh_attach: out of memory\n"));
 129                 return NULL;
 130         }
 131         sd->osh = osh;
 132         if (sdioh_sdmmc_osinit(sd) != 0) {
 133                 sd_err(("%s:sdioh_sdmmc_osinit() failed\n", __func__));
 134                 kfree(sd);
 135                 return NULL;
 136         }
 137
 138         sd->num_funcs = 2;
 139         sd->sd_blockmode = true;
 140         sd->use_client_ints = true;
 141         sd->client_block_size[0] = 64;
 142
 143         gInstance->sd = sd;
 144
 145         /* Claim host controller */
 146         sdio_claim_host(gInstance->func[1]);
 147
 148         sd->client_block_size[1] = 64;
 149         err_ret = sdio_set_block_size(gInstance->func[1], 64);
 150         if (err_ret)
 151                 sd_err(("bcmsdh_sdmmc: Failed to set F1 blocksize\n"));
 152
 153         /* Release host controller F1 */
 154         sdio_release_host(gInstance->func[1]);
 155
 156         if (gInstance->func[2]) {
 157                 /* Claim host controller F2 */
 158                 sdio_claim_host(gInstance->func[2]);
 159
 160                 sd->client_block_size[2] = sd_f2_blocksize;
 161                 err_ret =
 162                     sdio_set_block_size(gInstance->func[2], sd_f2_blocksize);
 163                 if (err_ret)
 164                         sd_err(("bcmsdh_sdmmc: Failed to set F2 blocksize "
 165                                 "to %d\n", sd_f2_blocksize));
 166
 167                 /* Release host controller F2 */
 168                 sdio_release_host(gInstance->func[2]);
 169         }
 170
 171         sdioh_sdmmc_card_enablefuncs(sd);
 172
 173         sd_trace(("%s: Done\n", __func__));
 174         return sd;
 175 }
 176
 177 extern SDIOH_API_RC sdioh_detach(osl_t *osh, sdioh_info_t *sd)
 178 {
 179         sd_trace(("%s\n", __func__));
 180
 181         if (sd) {
 182
 183                 /* Disable Function 2 */
 184                 sdio_claim_host(gInstance->func[2]);
 185                 sdio_disable_func(gInstance->func[2]);
 186                 sdio_release_host(gInstance->func[2]);
 187
 188                 /* Disable Function 1 */
 189                 sdio_claim_host(gInstance->func[1]);
 190                 sdio_disable_func(gInstance->func[1]);
 191                 sdio_release_host(gInstance->func[1]);
 192
 193                 /* deregister irq */
 194                 sdioh_sdmmc_osfree(sd);
 195
 196                 kfree(sd);
 197         }
 198         return SDIOH_API_RC_SUCCESS;
 199 }
 200
 201 #if defined(OOB_INTR_ONLY) && defined(HW_OOB)
 202
 203 extern SDIOH_API_RC sdioh_enable_func_intr(void)
 204 {
 205         u8 reg;
 206         int err;
 207
 208         if (gInstance->func[0]) {
 209                 sdio_claim_host(gInstance->func[0]);
 210
 211                 reg = sdio_readb(gInstance->func[0], SDIOD_CCCR_INTEN, &err);
 212                 if (err) {
 213                         sd_err(("%s: error for read SDIO_CCCR_IENx : 0x%x\n",
 214                                 __func__, err));
 215                         sdio_release_host(gInstance->func[0]);
 216                         return SDIOH_API_RC_FAIL;
 217                 }
 218
 219                 /* Enable F1 and F2 interrupts, set master enable */
 220                 reg |=
 221                     (INTR_CTL_FUNC1_EN | INTR_CTL_FUNC2_EN |
 222                      INTR_CTL_MASTER_EN);
 223
 224                 sdio_writeb(gInstance->func[0], reg, SDIOD_CCCR_INTEN, &err);
 225                 sdio_release_host(gInstance->func[0]);
 226
 227                 if (err) {
 228                         sd_err(("%s: error for write SDIO_CCCR_IENx : 0x%x\n",
 229                                 __func__, err));
 230                         return SDIOH_API_RC_FAIL;
 231                 }
 232         }
 233
 234         return SDIOH_API_RC_SUCCESS;
 235 }
 236
 237 extern SDIOH_API_RC sdioh_disable_func_intr(void)
 238 {
 239         u8 reg;
 240         int err;
 241
 242         if (gInstance->func[0]) {
 243                 sdio_claim_host(gInstance->func[0]);
 244                 reg = sdio_readb(gInstance->func[0], SDIOD_CCCR_INTEN, &err);
 245                 if (err) {
 246                         sd_err(("%s: error for read SDIO_CCCR_IENx : 0x%x\n",
 247                                 __func__, err));
 248                         sdio_release_host(gInstance->func[0]);
 249                         return SDIOH_API_RC_FAIL;
 250                 }
 251
 252                 reg &= ~(INTR_CTL_FUNC1_EN | INTR_CTL_FUNC2_EN);
 253                 /* Disable master interrupt with the last function interrupt */
 254                 if (!(reg & 0xFE))
 255                         reg = 0;
 256                 sdio_writeb(gInstance->func[0], reg, SDIOD_CCCR_INTEN, &err);
 257
 258                 sdio_release_host(gInstance->func[0]);
 259                 if (err) {
 260                         sd_err(("%s: error for write SDIO_CCCR_IENx : 0x%x\n",
 261                                 __func__, err));
 262                         return SDIOH_API_RC_FAIL;
 263                 }
 264         }
 265         return SDIOH_API_RC_SUCCESS;
 266 }
 267 #endif                          /* defined(OOB_INTR_ONLY) && defined(HW_OOB) */
 268
 269 /* Configure callback to client when we recieve client interrupt */
 270 extern SDIOH_API_RC
 271 sdioh_interrupt_register(sdioh_info_t *sd, sdioh_cb_fn_t fn, void *argh)
 272 {
 273         sd_trace(("%s: Entering\n", __func__));
 274         if (fn == NULL) {
 275                 sd_err(("%s: interrupt handler is NULL, not registering\n",
 276                         __func__));
 277                 return SDIOH_API_RC_FAIL;
 278         }
 279 #if !defined(OOB_INTR_ONLY)
 280         sd->intr_handler = fn;
 281         sd->intr_handler_arg = argh;
 282         sd->intr_handler_valid = true;
 283
 284         /* register and unmask irq */
 285         if (gInstance->func[2]) {
 286                 sdio_claim_host(gInstance->func[2]);
 287                 sdio_claim_irq(gInstance->func[2], IRQHandlerF2);
 288                 sdio_release_host(gInstance->func[2]);
 289         }
 290
 291         if (gInstance->func[1]) {
 292                 sdio_claim_host(gInstance->func[1]);
 293                 sdio_claim_irq(gInstance->func[1], IRQHandler);
 294                 sdio_release_host(gInstance->func[1]);
 295         }
 296 #elif defined(HW_OOB)
 297         sdioh_enable_func_intr();
 298 #endif                          /* defined(OOB_INTR_ONLY) */
 299         return SDIOH_API_RC_SUCCESS;
 300 }
 301
 302 extern SDIOH_API_RC sdioh_interrupt_deregister(sdioh_info_t *sd)
 303 {
 304         sd_trace(("%s: Entering\n", __func__));
 305
 306 #if !defined(OOB_INTR_ONLY)
 307         if (gInstance->func[1]) {
 308                 /* register and unmask irq */
 309                 sdio_claim_host(gInstance->func[1]);
 310                 sdio_release_irq(gInstance->func[1]);
 311                 sdio_release_host(gInstance->func[1]);
 312         }
 313
 314         if (gInstance->func[2]) {
 315                 /* Claim host controller F2 */
 316                 sdio_claim_host(gInstance->func[2]);
 317                 sdio_release_irq(gInstance->func[2]);
 318                 /* Release host controller F2 */
 319                 sdio_release_host(gInstance->func[2]);
 320         }
 321
 322         sd->intr_handler_valid = false;
 323         sd->intr_handler = NULL;
 324         sd->intr_handler_arg = NULL;
 325 #elif defined(HW_OOB)
 326         sdioh_disable_func_intr();
 327 #endif                          /*  !defined(OOB_INTR_ONLY) */
 328         return SDIOH_API_RC_SUCCESS;
 329 }
 330
 331 extern SDIOH_API_RC sdioh_interrupt_query(sdioh_info_t *sd, bool *onoff)
 332 {
 333         sd_trace(("%s: Entering\n", __func__));
 334         *onoff = sd->client_intr_enabled;
 335         return SDIOH_API_RC_SUCCESS;
 336 }
 337
 338 #if defined(DHD_DEBUG)
 339 extern bool sdioh_interrupt_pending(sdioh_info_t *sd)
 340 {
 341         return 0;
 342 }
 343 #endif
 344
 345 uint sdioh_query_iofnum(sdioh_info_t *sd)
 346 {
 347         return sd->num_funcs;
 348 }
 349
 350 /* IOVar table */
 351 enum {
 352         IOV_MSGLEVEL = 1,
 353         IOV_BLOCKMODE,
 354         IOV_BLOCKSIZE,
 355         IOV_DMA,
 356         IOV_USEINTS,
 357         IOV_NUMINTS,
 358         IOV_NUMLOCALINTS,
 359         IOV_HOSTREG,
 360         IOV_DEVREG,
 361         IOV_DIVISOR,
 362         IOV_SDMODE,
 363         IOV_HISPEED,
 364         IOV_HCIREGS,
 365         IOV_POWER,
 366         IOV_CLOCK,
 367         IOV_RXCHAIN
 368 };
 369
 370 const bcm_iovar_t sdioh_iovars[] = {
 371         {"sd_msglevel", IOV_MSGLEVEL, 0, IOVT_UINT32, 0},
 372         {"sd_blockmode", IOV_BLOCKMODE, 0, IOVT_BOOL, 0},
 373         {"sd_blocksize", IOV_BLOCKSIZE, 0, IOVT_UINT32, 0},/* ((fn << 16) |
 374                                                                  size) */
 375         {"sd_dma", IOV_DMA, 0, IOVT_BOOL, 0},
 376         {"sd_ints", IOV_USEINTS, 0, IOVT_BOOL, 0},
 377         {"sd_numints", IOV_NUMINTS, 0, IOVT_UINT32, 0},
 378         {"sd_numlocalints", IOV_NUMLOCALINTS, 0, IOVT_UINT32, 0},
 379         {"sd_hostreg", IOV_HOSTREG, 0, IOVT_BUFFER, sizeof(sdreg_t)}
 380         ,
 381         {"sd_devreg", IOV_DEVREG, 0, IOVT_BUFFER, sizeof(sdreg_t)}
 382         ,
 383         {"sd_divisor", IOV_DIVISOR, 0, IOVT_UINT32, 0}
 384         ,
 385         {"sd_power", IOV_POWER, 0, IOVT_UINT32, 0}
 386         ,
 387         {"sd_clock", IOV_CLOCK, 0, IOVT_UINT32, 0}
 388         ,
 389         {"sd_mode", IOV_SDMODE, 0, IOVT_UINT32, 100}
 390         ,
 391         {"sd_highspeed", IOV_HISPEED, 0, IOVT_UINT32, 0}
 392         ,
 393         {"sd_rxchain", IOV_RXCHAIN, 0, IOVT_BOOL, 0}
 394         ,
 395         {NULL, 0, 0, 0, 0}
 396 };
 397
 398 int
 399 sdioh_iovar_op(sdioh_info_t *si, const char *name,
 400                void *params, int plen, void *arg, int len, bool set)
 401 {
 402         const bcm_iovar_t *vi = NULL;
 403         int bcmerror = 0;
 404         int val_size;
 405         s32 int_val = 0;
 406         bool bool_val;
 407         u32 actionid;
 408
 409         ASSERT(name);
 410         ASSERT(len >= 0);
 411
 412         /* Get must have return space; Set does not take qualifiers */
 413         ASSERT(set || (arg && len));
 414         ASSERT(!set || (!params && !plen));
 415
 416         sd_trace(("%s: Enter (%s %s)\n", __func__, (set ? "set" : "get"),
 417                   name));
 418
 419         vi = bcm_iovar_lookup(sdioh_iovars, name);
 420         if (vi == NULL) {
 421                 bcmerror = BCME_UNSUPPORTED;
 422                 goto exit;
 423         }
 424
 425         bcmerror = bcm_iovar_lencheck(vi, arg, len, set);
 426         if (bcmerror != 0)
 427                 goto exit;
 428
 429         /* Set up params so get and set can share the convenience variables */
 430         if (params == NULL) {
 431                 params = arg;
 432                 plen = len;
 433         }
 434
 435         if (vi->type == IOVT_VOID)
 436                 val_size = 0;
 437         else if (vi->type == IOVT_BUFFER)
 438                 val_size = len;
 439         else
 440                 val_size = sizeof(int);
 441
 442         if (plen >= (int)sizeof(int_val))
 443                 bcopy(params, &int_val, sizeof(int_val));
 444
 445         bool_val = (int_val != 0) ? true : false;
 446
 447         actionid = set ? IOV_SVAL(vi->varid) : IOV_GVAL(vi->varid);
 448         switch (actionid) {
 449         case IOV_GVAL(IOV_MSGLEVEL):
 450                 int_val = (s32) sd_msglevel;
 451                 bcopy(&int_val, arg, val_size);
 452                 break;
 453
 454         case IOV_SVAL(IOV_MSGLEVEL):
 455                 sd_msglevel = int_val;
 456                 break;
 457
 458         case IOV_GVAL(IOV_BLOCKMODE):
 459                 int_val = (s32) si->sd_blockmode;
 460                 bcopy(&int_val, arg, val_size);
 461                 break;
 462
 463         case IOV_SVAL(IOV_BLOCKMODE):
 464                 si->sd_blockmode = (bool) int_val;
 465                 /* Haven't figured out how to make non-block mode with DMA */
 466                 break;
 467
 468         case IOV_GVAL(IOV_BLOCKSIZE):
 469                 if ((u32) int_val > si->num_funcs) {
 470                         bcmerror = BCME_BADARG;
 471                         break;
 472                 }
 473                 int_val = (s32) si->client_block_size[int_val];
 474                 bcopy(&int_val, arg, val_size);
 475                 break;
 476
 477         case IOV_SVAL(IOV_BLOCKSIZE):
 478                 {
 479                         uint func = ((u32) int_val >> 16);
 480                         uint blksize = (u16) int_val;
 481                         uint maxsize;
 482
 483                         if (func > si->num_funcs) {
 484                                 bcmerror = BCME_BADARG;
 485                                 break;
 486                         }
 487
 488                         switch (func) {
 489                         case 0:
 490                                 maxsize = 32;
 491                                 break;
 492                         case 1:
 493                                 maxsize = BLOCK_SIZE_4318;
 494                                 break;
 495                         case 2:
 496                                 maxsize = BLOCK_SIZE_4328;
 497                                 break;
 498                         default:
 499                                 maxsize = 0;
 500                         }
 501                         if (blksize > maxsize) {
 502                                 bcmerror = BCME_BADARG;
 503                                 break;
 504                         }
 505                         if (!blksize)
 506                                 blksize = maxsize;
 507
 508                         /* Now set it */
 509                         si->client_block_size[func] = blksize;
 510
 511                         break;
 512                 }
 513
 514         case IOV_GVAL(IOV_RXCHAIN):
 515                 int_val = false;
 516                 bcopy(&int_val, arg, val_size);
 517                 break;
 518
 519         case IOV_GVAL(IOV_DMA):
 520                 int_val = (s32) si->sd_use_dma;
 521                 bcopy(&int_val, arg, val_size);
 522                 break;
 523
 524         case IOV_SVAL(IOV_DMA):
 525                 si->sd_use_dma = (bool) int_val;
 526                 break;
 527
 528         case IOV_GVAL(IOV_USEINTS):
 529                 int_val = (s32) si->use_client_ints;
 530                 bcopy(&int_val, arg, val_size);
 531                 break;
 532
 533         case IOV_SVAL(IOV_USEINTS):
 534                 si->use_client_ints = (bool) int_val;
 535                 if (si->use_client_ints)
 536                         si->intmask |= CLIENT_INTR;
 537                 else
 538                         si->intmask &= ~CLIENT_INTR;
 539
 540                 break;
 541
 542         case IOV_GVAL(IOV_DIVISOR):
 543                 int_val = (u32) sd_divisor;
 544                 bcopy(&int_val, arg, val_size);
 545                 break;
 546
 547         case IOV_SVAL(IOV_DIVISOR):
 548                 sd_divisor = int_val;
 549                 break;
 550
 551         case IOV_GVAL(IOV_POWER):
 552                 int_val = (u32) sd_power;
 553                 bcopy(&int_val, arg, val_size);
 554                 break;
 555
 556         case IOV_SVAL(IOV_POWER):
 557                 sd_power = int_val;
 558                 break;
 559
 560         case IOV_GVAL(IOV_CLOCK):
 561                 int_val = (u32) sd_clock;
 562                 bcopy(&int_val, arg, val_size);
 563                 break;
 564
 565         case IOV_SVAL(IOV_CLOCK):
 566                 sd_clock = int_val;
 567                 break;
 568
 569         case IOV_GVAL(IOV_SDMODE):
 570                 int_val = (u32) sd_sdmode;
 571                 bcopy(&int_val, arg, val_size);
 572                 break;
 573
 574         case IOV_SVAL(IOV_SDMODE):
 575                 sd_sdmode = int_val;
 576                 break;
 577
 578         case IOV_GVAL(IOV_HISPEED):
 579                 int_val = (u32) sd_hiok;
 580                 bcopy(&int_val, arg, val_size);
 581                 break;
 582
 583         case IOV_SVAL(IOV_HISPEED):
 584                 sd_hiok = int_val;
 585                 break;
 586
 587         case IOV_GVAL(IOV_NUMINTS):
 588                 int_val = (s32) si->intrcount;
 589                 bcopy(&int_val, arg, val_size);
 590                 break;
 591
 592         case IOV_GVAL(IOV_NUMLOCALINTS):
 593                 int_val = (s32) 0;
 594                 bcopy(&int_val, arg, val_size);
 595                 break;
 596
 597         case IOV_GVAL(IOV_HOSTREG):
 598                 {
 599                         sdreg_t *sd_ptr = (sdreg_t *) params;
 600
 601                         if (sd_ptr->offset < SD_SysAddr
 602                             || sd_ptr->offset > SD_MaxCurCap) {
 603                                 sd_err(("%s: bad offset 0x%x\n", __func__,
 604                                         sd_ptr->offset));
 605                                 bcmerror = BCME_BADARG;
 606                                 break;
 607                         }
 608
 609                         sd_trace(("%s: rreg%d at offset %d\n", __func__,
 610                                   (sd_ptr->offset & 1) ? 8
 611                                   : ((sd_ptr->offset & 2) ? 16 : 32),
 612                                   sd_ptr->offset));
 613                         if (sd_ptr->offset & 1)
 614                                 int_val = 8;    /* sdioh_sdmmc_rreg8(si,
 615                                                  sd_ptr->offset); */
 616                         else if (sd_ptr->offset & 2)
 617                                 int_val = 16;   /* sdioh_sdmmc_rreg16(si,
 618                                                  sd_ptr->offset); */
 619                         else
 620                                 int_val = 32;   /* sdioh_sdmmc_rreg(si,
 621                                                  sd_ptr->offset); */
 622
 623                         bcopy(&int_val, arg, sizeof(int_val));
 624                         break;
 625                 }
 626
 627         case IOV_SVAL(IOV_HOSTREG):
 628                 {
 629                         sdreg_t *sd_ptr = (sdreg_t *) params;
 630
 631                         if (sd_ptr->offset < SD_SysAddr
 632                             || sd_ptr->offset > SD_MaxCurCap) {
 633                                 sd_err(("%s: bad offset 0x%x\n", __func__,
 634                                         sd_ptr->offset));
 635                                 bcmerror = BCME_BADARG;
 636                                 break;
 637                         }
 638
 639                         sd_trace(("%s: wreg%d value 0x%08x at offset %d\n",
 640                                   __func__, sd_ptr->value,
 641                                   (sd_ptr->offset & 1) ? 8
 642                                   : ((sd_ptr->offset & 2) ? 16 : 32),
 643                                   sd_ptr->offset));
 644                         break;
 645                 }
 646
 647         case IOV_GVAL(IOV_DEVREG):
 648                 {
 649                         sdreg_t *sd_ptr = (sdreg_t *) params;
 650                         u8 data = 0;
 651
 652                         if (sdioh_cfg_read
 653                             (si, sd_ptr->func, sd_ptr->offset, &data)) {
 654                                 bcmerror = BCME_SDIO_ERROR;
 655                                 break;
 656                         }
 657
 658                         int_val = (int)data;
 659                         bcopy(&int_val, arg, sizeof(int_val));
 660                         break;
 661                 }
 662
 663         case IOV_SVAL(IOV_DEVREG):
 664                 {
 665                         sdreg_t *sd_ptr = (sdreg_t *) params;
 666                         u8 data = (u8) sd_ptr->value;
 667
 668                         if (sdioh_cfg_write
 669                             (si, sd_ptr->func, sd_ptr->offset, &data)) {
 670                                 bcmerror = BCME_SDIO_ERROR;
 671                                 break;
 672                         }
 673                         break;
 674                 }
 675
 676         default:
 677                 bcmerror = BCME_UNSUPPORTED;
 678                 break;
 679         }
 680 exit:
 681
 682         return bcmerror;
 683 }
 684
 685 #if defined(OOB_INTR_ONLY) && defined(HW_OOB)
 686
 687 SDIOH_API_RC sdioh_enable_hw_oob_intr(sdioh_info_t *sd, bool enable)
 688 {
 689         SDIOH_API_RC status;
 690         u8 data;
 691
 692         if (enable)
 693                 data = 3;       /* enable hw oob interrupt */
 694         else
 695                 data = 4;       /* disable hw oob interrupt */
 696         data |= 4;              /* Active HIGH */
 697
 698         status = sdioh_request_byte(sd, SDIOH_WRITE, 0, 0xf2, &data);
 699         return status;
 700 }
 701 #endif                          /* defined(OOB_INTR_ONLY) && defined(HW_OOB) */
 702
 703 extern SDIOH_API_RC
 704 sdioh_cfg_read(sdioh_info_t *sd, uint fnc_num, u32 addr, u8 *data)
 705 {
 706         SDIOH_API_RC status;
 707         /* No lock needed since sdioh_request_byte does locking */
 708         status = sdioh_request_byte(sd, SDIOH_READ, fnc_num, addr, data);
 709         return status;
 710 }
 711
 712 extern SDIOH_API_RC
 713 sdioh_cfg_write(sdioh_info_t *sd, uint fnc_num, u32 addr, u8 *data)
 714 {
 715         /* No lock needed since sdioh_request_byte does locking */
 716         SDIOH_API_RC status;
 717         status = sdioh_request_byte(sd, SDIOH_WRITE, fnc_num, addr, data);
 718         return status;
 719 }
 720
 721 static int sdioh_sdmmc_get_cisaddr(sdioh_info_t *sd, u32 regaddr)
 722 {
 723         /* read 24 bits and return valid 17 bit addr */
 724         int i;
 725         u32 scratch, regdata;
 726         u8 *ptr = (u8 *)&scratch;
 727         for (i = 0; i < 3; i++) {
 728                 if ((sdioh_sdmmc_card_regread(sd, 0, regaddr, 1, &regdata)) !=
 729                     SUCCESS)
 730                         sd_err(("%s: Can't read!\n", __func__));
 731
 732                 *ptr++ = (u8) regdata;
 733                 regaddr++;
 734         }
 735
 736         /* Only the lower 17-bits are valid */
 737         scratch = ltoh32(scratch);
 738         scratch &= 0x0001FFFF;
 739         return scratch;
 740 }
 741
 742 extern SDIOH_API_RC
 743 sdioh_cis_read(sdioh_info_t *sd, uint func, u8 *cisd, u32 length)
 744 {
 745         u32 count;
 746         int offset;
 747         u32 foo;
 748         u8 *cis = cisd;
 749
 750         sd_trace(("%s: Func = %d\n", __func__, func));
 751
 752         if (!sd->func_cis_ptr[func]) {
 753                 bzero(cis, length);
 754                 sd_err(("%s: no func_cis_ptr[%d]\n", __func__, func));
 755                 return SDIOH_API_RC_FAIL;
 756         }
 757
 758         sd_err(("%s: func_cis_ptr[%d]=0x%04x\n", __func__, func,
 759                 sd->func_cis_ptr[func]));
 760
 761         for (count = 0; count < length; count++) {
 762                 offset = sd->func_cis_ptr[func] + count;
 763                 if (sdioh_sdmmc_card_regread(sd, 0, offset, 1, &foo) < 0) {
 764                         sd_err(("%s: regread failed: Can't read CIS\n",
 765                                 __func__));
 766                         return SDIOH_API_RC_FAIL;
 767                 }
 768
 769                 *cis = (u8) (foo & 0xff);
 770                 cis++;
 771         }
 772
 773         return SDIOH_API_RC_SUCCESS;
 774 }
 775
 776 extern SDIOH_API_RC
 777 sdioh_request_byte(sdioh_info_t *sd, uint rw, uint func, uint regaddr,
 778                    u8 *byte)
 779 {
 780         int err_ret;
 781
 782         sd_info(("%s: rw=%d, func=%d, addr=0x%05x\n", __func__, rw, func,
 783                  regaddr));
 784
 785         DHD_PM_RESUME_WAIT(sdioh_request_byte_wait);
 786         DHD_PM_RESUME_RETURN_ERROR(SDIOH_API_RC_FAIL);
 787         if (rw) {               /* CMD52 Write */
 788                 if (func == 0) {
 789                         /* Can only directly write to some F0 registers.
 790                          * Handle F2 enable
 791                          * as a special case.
 792                          */
 793                         if (regaddr == SDIOD_CCCR_IOEN) {
 794                                 if (gInstance->func[2]) {
 795                                         sdio_claim_host(gInstance->func[2]);
 796                                         if (*byte & SDIO_FUNC_ENABLE_2) {
 797                                                 /* Enable Function 2 */
 798                                                 err_ret =
 799                                                     sdio_enable_func
 800                                                     (gInstance->func[2]);
 801                                                 if (err_ret)
 802                                                         sd_err(("bcmsdh_sdmmc: enable F2 failed:%d",
 803                                                                  err_ret));
 804                                         } else {
 805                                                 /* Disable Function 2 */
 806                                                 err_ret =
 807                                                     sdio_disable_func
 808                                                     (gInstance->func[2]);
 809                                                 if (err_ret)
 810                                                         sd_err(("bcmsdh_sdmmc: Disab F2 failed:%d",
 811                                                                  err_ret));
 812                                         }
 813                                         sdio_release_host(gInstance->func[2]);
 814                                 }
 815                         }
 816 #if defined(MMC_SDIO_ABORT)
 817                         /* to allow abort command through F1 */
 818                         else if (regaddr == SDIOD_CCCR_IOABORT) {
 819                                 sdio_claim_host(gInstance->func[func]);
 820                                 /*
 821                                  * this sdio_f0_writeb() can be replaced
 822                                  * with another api
 823                                  * depending upon MMC driver change.
 824                                  * As of this time, this is temporaray one
 825                                  */
 826                                 sdio_writeb(gInstance->func[func], *byte,
 827                                             regaddr, &err_ret);
 828                                 sdio_release_host(gInstance->func[func]);
 829                         }
 830 #endif                          /* MMC_SDIO_ABORT */
 831                         else if (regaddr < 0xF0) {
 832                                 sd_err(("bcmsdh_sdmmc: F0 Wr:0x%02x: write "
 833                                         "disallowed\n", regaddr));
 834                         } else {
 835                                 /* Claim host controller, perform F0 write,
 836                                  and release */
 837                                 sdio_claim_host(gInstance->func[func]);
 838                                 sdio_f0_writeb(gInstance->func[func], *byte,
 839                                                regaddr, &err_ret);
 840                                 sdio_release_host(gInstance->func[func]);
 841                         }
 842                 } else {
 843                         /* Claim host controller, perform Fn write,
 844                          and release */
 845                         sdio_claim_host(gInstance->func[func]);
 846                         sdio_writeb(gInstance->func[func], *byte, regaddr,
 847                                     &err_ret);
 848                         sdio_release_host(gInstance->func[func]);
 849                 }
 850         } else {                /* CMD52 Read */
 851                 /* Claim host controller, perform Fn read, and release */
 852                 sdio_claim_host(gInstance->func[func]);
 853
 854                 if (func == 0) {
 855                         *byte =
 856                             sdio_f0_readb(gInstance->func[func], regaddr,
 857                                           &err_ret);
 858                 } else {
 859                         *byte =
 860                             sdio_readb(gInstance->func[func], regaddr,
 861                                        &err_ret);
 862                 }
 863
 864                 sdio_release_host(gInstance->func[func]);
 865         }
 866
 867         if (err_ret)
 868                 sd_err(("bcmsdh_sdmmc: Failed to %s byte F%d:@0x%05x=%02x, "
 869                         "Err: %d\n", rw ? "Write" : "Read", func, regaddr,
 870                         *byte, err_ret));
 871
 872         return ((err_ret == 0) ? SDIOH_API_RC_SUCCESS : SDIOH_API_RC_FAIL);
 873 }
 874
 875 extern SDIOH_API_RC
 876 sdioh_request_word(sdioh_info_t *sd, uint cmd_type, uint rw, uint func,
 877                    uint addr, u32 *word, uint nbytes)
 878 {
 879         int err_ret = SDIOH_API_RC_FAIL;
 880
 881         if (func == 0) {
 882                 sd_err(("%s: Only CMD52 allowed to F0.\n", __func__));
 883                 return SDIOH_API_RC_FAIL;
 884         }
 885
 886         sd_info(("%s: cmd_type=%d, rw=%d, func=%d, addr=0x%05x, nbytes=%d\n",
 887                  __func__, cmd_type, rw, func, addr, nbytes));
 888
 889         DHD_PM_RESUME_WAIT(sdioh_request_word_wait);
 890         DHD_PM_RESUME_RETURN_ERROR(SDIOH_API_RC_FAIL);
 891         /* Claim host controller */
 892         sdio_claim_host(gInstance->func[func]);
 893
 894         if (rw) {               /* CMD52 Write */
 895                 if (nbytes == 4) {
 896                         sdio_writel(gInstance->func[func], *word, addr,
 897                                     &err_ret);
 898                 } else if (nbytes == 2) {
 899                         sdio_writew(gInstance->func[func], (*word & 0xFFFF),
 900                                     addr, &err_ret);
 901                 } else {
 902                         sd_err(("%s: Invalid nbytes: %d\n", __func__, nbytes));
 903                 }
 904         } else {                /* CMD52 Read */
 905                 if (nbytes == 4) {
 906                         *word =
 907                             sdio_readl(gInstance->func[func], addr, &err_ret);
 908                 } else if (nbytes == 2) {
 909                         *word =
 910                             sdio_readw(gInstance->func[func], addr,
 911                                        &err_ret) & 0xFFFF;
 912                 } else {
 913                         sd_err(("%s: Invalid nbytes: %d\n", __func__, nbytes));
 914                 }
 915         }
 916
 917         /* Release host controller */
 918         sdio_release_host(gInstance->func[func]);
 919
 920         if (err_ret) {
 921                 sd_err(("bcmsdh_sdmmc: Failed to %s word, Err: 0x%08x",
 922                         rw ? "Write" : "Read", err_ret));
 923         }
 924
 925         return ((err_ret == 0) ? SDIOH_API_RC_SUCCESS : SDIOH_API_RC_FAIL);
 926 }
 927
 928 static SDIOH_API_RC
 929 sdioh_request_packet(sdioh_info_t *sd, uint fix_inc, uint write, uint func,
 930                      uint addr, void *pkt)
 931 {
 932         bool fifo = (fix_inc == SDIOH_DATA_FIX);
 933         u32 SGCount = 0;
 934         int err_ret = 0;
 935
 936         void *pnext;
 937
 938         sd_trace(("%s: Enter\n", __func__));
 939
 940         ASSERT(pkt);
 941         DHD_PM_RESUME_WAIT(sdioh_request_packet_wait);
 942         DHD_PM_RESUME_RETURN_ERROR(SDIOH_API_RC_FAIL);
 943
 944         /* Claim host controller */
 945         sdio_claim_host(gInstance->func[func]);
 946         for (pnext = pkt; pnext; pnext = PKTNEXT(pnext)) {
 947                 uint pkt_len = PKTLEN(pnext);
 948                 pkt_len += 3;
 949                 pkt_len &= 0xFFFFFFFC;
 950
 951 #ifdef CONFIG_MMC_MSM7X00A
 952                 if ((pkt_len % 64) == 32) {
 953                         sd_trace(("%s: Rounding up TX packet +=32\n",
 954                                   __func__));
 955                         pkt_len += 32;
 956                 }
 957 #endif                          /* CONFIG_MMC_MSM7X00A */
 958                 /* Make sure the packet is aligned properly.
 959                  * If it isn't, then this
 960                  * is the fault of sdioh_request_buffer() which
 961                  * is supposed to give
 962                  * us something we can work with.
 963                  */
 964                 ASSERT(((u32) (PKTDATA(pkt)) & DMA_ALIGN_MASK) == 0);
 965
 966                 if ((write) && (!fifo)) {
 967                         err_ret = sdio_memcpy_toio(gInstance->func[func], addr,
 968                                                    ((u8 *) PKTDATA(pnext)),
 969                                                    pkt_len);
 970                 } else if (write) {
 971                         err_ret = sdio_memcpy_toio(gInstance->func[func], addr,
 972                                                    ((u8 *) PKTDATA(pnext)),
 973                                                    pkt_len);
 974                 } else if (fifo) {
 975                         err_ret = sdio_readsb(gInstance->func[func],
 976                                               ((u8 *) PKTDATA(pnext)),
 977                                               addr, pkt_len);
 978                 } else {
 979                         err_ret = sdio_memcpy_fromio(gInstance->func[func],
 980                                                      ((u8 *) PKTDATA(pnext)),
 981                                                      addr, pkt_len);
 982                 }
 983
 984                 if (err_ret) {
 985                         sd_err(("%s: %s FAILED %p[%d], addr=0x%05x, pkt_len=%d,"
 986                                  "ERR=0x%08x\n", __func__,
 987                                  (write) ? "TX" : "RX",
 988                                  pnext, SGCount, addr, pkt_len, err_ret));
 989                 } else {
 990                         sd_trace(("%s: %s xfr'd %p[%d], addr=0x%05x, len=%d\n",
 991                                   __func__,
 992                                   (write) ? "TX" : "RX",
 993                                   pnext, SGCount, addr, pkt_len));
 994                 }
 995
 996                 if (!fifo)
 997                         addr += pkt_len;
 998                 SGCount++;
 999
1000         }
1001
1002         /* Release host controller */
1003         sdio_release_host(gInstance->func[func]);
1004
1005         sd_trace(("%s: Exit\n", __func__));
1006         return ((err_ret == 0) ? SDIOH_API_RC_SUCCESS : SDIOH_API_RC_FAIL);
1007 }
1008
1009 /*
1010  * This function takes a buffer or packet, and fixes everything up
1011  * so that in the
1012  * end, a DMA-able packet is created.
1013  *
1014  * A buffer does not have an associated packet pointer,
1015  * and may or may not be aligned.
1016  * A packet may consist of a single packet, or a packet chain.
1017  * If it is a packet chain,
1018  * then all the packets in the chain must be properly aligned.
1019  * If the packet data is not
1020  * aligned, then there may only be one packet, and in this case,
1021  * it is copied to a new
1022  * aligned packet.
1023  *
1024  */
1025 extern SDIOH_API_RC
1026 sdioh_request_buffer(sdioh_info_t *sd, uint pio_dma, uint fix_inc, uint write,
1027                      uint func, uint addr, uint reg_width, uint buflen_u,
1028                      u8 *buffer, void *pkt)
1029 {
1030         SDIOH_API_RC Status;
1031         void *mypkt = NULL;
1032
1033         sd_trace(("%s: Enter\n", __func__));
1034
1035         DHD_PM_RESUME_WAIT(sdioh_request_buffer_wait);
1036         DHD_PM_RESUME_RETURN_ERROR(SDIOH_API_RC_FAIL);
1037         /* Case 1: we don't have a packet. */
1038         if (pkt == NULL) {
1039                 sd_data(("%s: Creating new %s Packet, len=%d\n",
1040                          __func__, write ? "TX" : "RX", buflen_u));
1041                 mypkt = PKTGET(sd->osh, buflen_u, write ? true : false);
1042                 if (!mypkt) {
1043                         sd_err(("%s: PKTGET failed: len %d\n",
1044                                 __func__, buflen_u));
1045                         return SDIOH_API_RC_FAIL;
1046                 }
1047
1048                 /* For a write, copy the buffer data into the packet. */
1049                 if (write)
1050                         bcopy(buffer, PKTDATA(mypkt), buflen_u);
1051
1052                 Status =
1053                     sdioh_request_packet(sd, fix_inc, write, func, addr, mypkt);
1054
1055                 /* For a read, copy the packet data back to the buffer. */
1056                 if (!write)
1057                         bcopy(PKTDATA(mypkt), buffer, buflen_u);
1058
1059                 PKTFREE(sd->osh, mypkt, write ? true : false);
1060         } else if (((u32) (PKTDATA(pkt)) & DMA_ALIGN_MASK) != 0) {
1061                 /* Case 2: We have a packet, but it is unaligned. */
1062
1063                 /* In this case, we cannot have a chain. */
1064                 ASSERT(PKTNEXT(pkt) == NULL);
1065
1066                 sd_data(("%s: Creating aligned %s Packet, len=%d\n",
1067                          __func__, write ? "TX" : "RX", PKTLEN(pkt)));
1068                 mypkt = PKTGET(sd->osh, PKTLEN(pkt), write ? true : false);
1069                 if (!mypkt) {
1070                         sd_err(("%s: PKTGET failed: len %d\n",
1071                                 __func__, PKTLEN(pkt)));
1072                         return SDIOH_API_RC_FAIL;
1073                 }
1074
1075                 /* For a write, copy the buffer data into the packet. */
1076                 if (write)
1077                         bcopy(PKTDATA(pkt), PKTDATA(mypkt), PKTLEN(pkt));
1078
1079                 Status =
1080                     sdioh_request_packet(sd, fix_inc, write, func, addr, mypkt);
1081
1082                 /* For a read, copy the packet data back to the buffer. */
1083                 if (!write)
1084                         bcopy(PKTDATA(mypkt), PKTDATA(pkt), PKTLEN(mypkt));
1085
1086                 PKTFREE(sd->osh, mypkt, write ? true : false);
1087         } else {                /* case 3: We have a packet and
1088                                  it is aligned. */
1089                 sd_data(("%s: Aligned %s Packet, direct DMA\n",
1090                          __func__, write ? "Tx" : "Rx"));
1091                 Status =
1092                     sdioh_request_packet(sd, fix_inc, write, func, addr, pkt);
1093         }
1094
1095         return Status;
1096 }
1097
1098 /* this function performs "abort" for both of host & device */
1099 extern int sdioh_abort(sdioh_info_t *sd, uint func)
1100 {
1101 #if defined(MMC_SDIO_ABORT)
1102         char t_func = (char)func;
1103 #endif                          /* defined(MMC_SDIO_ABORT) */
1104         sd_trace(("%s: Enter\n", __func__));
1105
1106 #if defined(MMC_SDIO_ABORT)
1107         /* issue abort cmd52 command through F1 */
1108         sdioh_request_byte(sd, SD_IO_OP_WRITE, SDIO_FUNC_0, SDIOD_CCCR_IOABORT,
1109                            &t_func);
1110 #endif                          /* defined(MMC_SDIO_ABORT) */
1111
1112         sd_trace(("%s: Exit\n", __func__));
1113         return SDIOH_API_RC_SUCCESS;
1114 }
1115
1116 /* Reset and re-initialize the device */
1117 int sdioh_sdio_reset(sdioh_info_t *si)
1118 {
1119         sd_trace(("%s: Enter\n", __func__));
1120         sd_trace(("%s: Exit\n", __func__));
1121         return SDIOH_API_RC_SUCCESS;
1122 }
1123
1124 /* Disable device interrupt */
1125 void sdioh_sdmmc_devintr_off(sdioh_info_t *sd)
1126 {
1127         sd_trace(("%s: %d\n", __func__, sd->use_client_ints));
1128         sd->intmask &= ~CLIENT_INTR;
1129 }
1130
1131 /* Enable device interrupt */
1132 void sdioh_sdmmc_devintr_on(sdioh_info_t *sd)
1133 {
1134         sd_trace(("%s: %d\n", __func__, sd->use_client_ints));
1135         sd->intmask |= CLIENT_INTR;
1136 }
1137
1138 /* Read client card reg */
1139 int
1140 sdioh_sdmmc_card_regread(sdioh_info_t *sd, int func, u32 regaddr,
1141                          int regsize, u32 *data)
1142 {
1143
1144         if ((func == 0) || (regsize == 1)) {
1145                 u8 temp = 0;
1146
1147                 sdioh_request_byte(sd, SDIOH_READ, func, regaddr, &temp);
1148                 *data = temp;
1149                 *data &= 0xff;
1150                 sd_data(("%s: byte read data=0x%02x\n", __func__, *data));
1151         } else {
1152                 sdioh_request_word(sd, 0, SDIOH_READ, func, regaddr, data,
1153                                    regsize);
1154                 if (regsize == 2)
1155                         *data &= 0xffff;
1156
1157                 sd_data(("%s: word read data=0x%08x\n", __func__, *data));
1158         }
1159
1160         return SUCCESS;
1161 }
1162
1163 #if !defined(OOB_INTR_ONLY)
1164 /* bcmsdh_sdmmc interrupt handler */
1165 static void IRQHandler(struct sdio_func *func)
1166 {
1167         sdioh_info_t *sd;
1168
1169         sd_trace(("bcmsdh_sdmmc: ***IRQHandler\n"));
1170         sd = gInstance->sd;
1171
1172         ASSERT(sd != NULL);
1173         sdio_release_host(gInstance->func[0]);
1174
1175         if (sd->use_client_ints) {
1176                 sd->intrcount++;
1177                 ASSERT(sd->intr_handler);
1178                 ASSERT(sd->intr_handler_arg);
1179                 (sd->intr_handler) (sd->intr_handler_arg);
1180         } else {
1181                 sd_err(("bcmsdh_sdmmc: ***IRQHandler\n"));
1182
1183                 sd_err(("%s: Not ready for intr: enabled %d, handler %p\n",
1184                         __func__, sd->client_intr_enabled, sd->intr_handler));
1185         }
1186
1187         sdio_claim_host(gInstance->func[0]);
1188 }
1189
1190 /* bcmsdh_sdmmc interrupt handler for F2 (dummy handler) */
1191 static void IRQHandlerF2(struct sdio_func *func)
1192 {
1193         sdioh_info_t *sd;
1194
1195         sd_trace(("bcmsdh_sdmmc: ***IRQHandlerF2\n"));
1196
1197         sd = gInstance->sd;
1198
1199         ASSERT(sd != NULL);
1200 }
1201 #endif                          /* !defined(OOB_INTR_ONLY) */
1202
1203 #ifdef NOTUSED
1204 /* Write client card reg */
1205 static int
1206 sdioh_sdmmc_card_regwrite(sdioh_info_t *sd, int func, u32 regaddr,
1207                           int regsize, u32 data)
1208 {
1209
1210         if ((func == 0) || (regsize == 1)) {
1211                 u8 temp;
1212
1213                 temp = data & 0xff;
1214                 sdioh_request_byte(sd, SDIOH_READ, func, regaddr, &temp);
1215                 sd_data(("%s: byte write data=0x%02x\n", __func__, data));
1216         } else {
1217                 if (regsize == 2)
1218                         data &= 0xffff;
1219
1220                 sdioh_request_word(sd, 0, SDIOH_READ, func, regaddr, &data,
1221                                    regsize);
1222
1223                 sd_data(("%s: word write data=0x%08x\n", __func__, data));
1224         }
1225
1226         return SUCCESS;
1227 }
1228 #endif                          /* NOTUSED */
1229
1230 int sdioh_start(sdioh_info_t *si, int stage)
1231 {
1232         return 0;
1233 }
1234
1235 int sdioh_stop(sdioh_info_t *si)
1236 {
1237         return 0;
1238 }