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