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(sdioh_info_t *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(sdioh_info_t *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(sdioh_info_t *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 sdioh_info_t *brcmf_sdioh_attach(void *bar0, uint irq)
 110 {
 111         sdioh_info_t *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(sdioh_info_t), 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 SDIOH_API_RC brcmf_sdioh_detach(sdioh_info_t *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 SDIOH_API_RC 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 SDIOH_API_RC 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 SDIOH_API_RC
 264 brcmf_sdioh_interrupt_register(sdioh_info_t *sd, sdioh_cb_fn_t fn, void *argh)
 265 {
 266         sd_trace(("%s: Entering\n", __func__));
 267         if (fn == NULL) {
 268                 sd_err(("%s: interrupt handler is NULL, not registering\n",
 269                         __func__));
 270                 return SDIOH_API_RC_FAIL;
 271         }
 272 #if !defined(OOB_INTR_ONLY)
 273         sd->intr_handler = fn;
 274         sd->intr_handler_arg = argh;
 275         sd->intr_handler_valid = true;
 276
 277         /* register and unmask irq */
 278         if (gInstance->func[2]) {
 279                 sdio_claim_host(gInstance->func[2]);
 280                 sdio_claim_irq(gInstance->func[2], brcmf_sdioh_irqhandler_f2);
 281                 sdio_release_host(gInstance->func[2]);
 282         }
 283
 284         if (gInstance->func[1]) {
 285                 sdio_claim_host(gInstance->func[1]);
 286                 sdio_claim_irq(gInstance->func[1], brcmf_sdioh_irqhandler);
 287                 sdio_release_host(gInstance->func[1]);
 288         }
 289 #elif defined(HW_OOB)
 290         brcmf_sdioh_enable_func_intr();
 291 #endif                          /* defined(OOB_INTR_ONLY) */
 292         return SDIOH_API_RC_SUCCESS;
 293 }
 294
 295 extern SDIOH_API_RC brcmf_sdioh_interrupt_deregister(sdioh_info_t *sd)
 296 {
 297         sd_trace(("%s: Entering\n", __func__));
 298
 299 #if !defined(OOB_INTR_ONLY)
 300         if (gInstance->func[1]) {
 301                 /* register and unmask irq */
 302                 sdio_claim_host(gInstance->func[1]);
 303                 sdio_release_irq(gInstance->func[1]);
 304                 sdio_release_host(gInstance->func[1]);
 305         }
 306
 307         if (gInstance->func[2]) {
 308                 /* Claim host controller F2 */
 309                 sdio_claim_host(gInstance->func[2]);
 310                 sdio_release_irq(gInstance->func[2]);
 311                 /* Release host controller F2 */
 312                 sdio_release_host(gInstance->func[2]);
 313         }
 314
 315         sd->intr_handler_valid = false;
 316         sd->intr_handler = NULL;
 317         sd->intr_handler_arg = NULL;
 318 #elif defined(HW_OOB)
 319         brcmf_sdioh_disable_func_intr();
 320 #endif                          /*  !defined(OOB_INTR_ONLY) */
 321         return SDIOH_API_RC_SUCCESS;
 322 }
 323
 324 extern SDIOH_API_RC brcmf_sdioh_interrupt_query(sdioh_info_t *sd, bool *onoff)
 325 {
 326         sd_trace(("%s: Entering\n", __func__));
 327         *onoff = sd->client_intr_enabled;
 328         return SDIOH_API_RC_SUCCESS;
 329 }
 330
 331 #if defined(DHD_DEBUG)
 332 extern bool brcmf_sdioh_interrupt_pending(sdioh_info_t *sd)
 333 {
 334         return 0;
 335 }
 336 #endif
 337
 338 uint brcmf_sdioh_query_iofnum(sdioh_info_t *sd)
 339 {
 340         return sd->num_funcs;
 341 }
 342
 343 /* IOVar table */
 344 enum {
 345         IOV_MSGLEVEL = 1,
 346         IOV_BLOCKSIZE,
 347         IOV_USEINTS,
 348         IOV_NUMINTS,
 349         IOV_DEVREG,
 350         IOV_HCIREGS,
 351         IOV_RXCHAIN
 352 };
 353
 354 const struct brcmu_iovar sdioh_iovars[] = {
 355         {"sd_msglevel", IOV_MSGLEVEL, 0, IOVT_UINT32, 0},
 356         {"sd_blocksize", IOV_BLOCKSIZE, 0, IOVT_UINT32, 0},/* ((fn << 16) |
 357                                                                  size) */
 358         {"sd_ints", IOV_USEINTS, 0, IOVT_BOOL, 0},
 359         {"sd_numints", IOV_NUMINTS, 0, IOVT_UINT32, 0},
 360         {"sd_devreg", IOV_DEVREG, 0, IOVT_BUFFER, sizeof(sdreg_t)}
 361         ,
 362         {"sd_rxchain", IOV_RXCHAIN, 0, IOVT_BOOL, 0}
 363         ,
 364         {NULL, 0, 0, 0, 0}
 365 };
 366
 367 int
 368 brcmf_sdioh_iovar_op(sdioh_info_t *si, const char *name,
 369                      void *params, int plen, void *arg, int len, bool set)
 370 {
 371         const struct brcmu_iovar *vi = NULL;
 372         int bcmerror = 0;
 373         int val_size;
 374         s32 int_val = 0;
 375         bool bool_val;
 376         u32 actionid;
 377
 378         ASSERT(name);
 379         ASSERT(len >= 0);
 380
 381         /* Get must have return space; Set does not take qualifiers */
 382         ASSERT(set || (arg && len));
 383         ASSERT(!set || (!params && !plen));
 384
 385         sd_trace(("%s: Enter (%s %s)\n", __func__, (set ? "set" : "get"),
 386                   name));
 387
 388         vi = brcmu_iovar_lookup(sdioh_iovars, name);
 389         if (vi == NULL) {
 390                 bcmerror = -ENOTSUPP;
 391                 goto exit;
 392         }
 393
 394         bcmerror = brcmu_iovar_lencheck(vi, arg, len, set);
 395         if (bcmerror != 0)
 396                 goto exit;
 397
 398         /* Set up params so get and set can share the convenience variables */
 399         if (params == NULL) {
 400                 params = arg;
 401                 plen = len;
 402         }
 403
 404         if (vi->type == IOVT_VOID)
 405                 val_size = 0;
 406         else if (vi->type == IOVT_BUFFER)
 407                 val_size = len;
 408         else
 409                 val_size = sizeof(int);
 410
 411         if (plen >= (int)sizeof(int_val))
 412                 memcpy(&int_val, params, sizeof(int_val));
 413
 414         bool_val = (int_val != 0) ? true : false;
 415
 416         actionid = set ? IOV_SVAL(vi->varid) : IOV_GVAL(vi->varid);
 417         switch (actionid) {
 418         case IOV_GVAL(IOV_MSGLEVEL):
 419                 int_val = (s32) sd_msglevel;
 420                 memcpy(arg, &int_val, val_size);
 421                 break;
 422
 423         case IOV_SVAL(IOV_MSGLEVEL):
 424                 sd_msglevel = int_val;
 425                 break;
 426
 427         case IOV_GVAL(IOV_BLOCKSIZE):
 428                 if ((u32) int_val > si->num_funcs) {
 429                         bcmerror = -EINVAL;
 430                         break;
 431                 }
 432                 int_val = (s32) si->client_block_size[int_val];
 433                 memcpy(arg, &int_val, val_size);
 434                 break;
 435
 436         case IOV_SVAL(IOV_BLOCKSIZE):
 437                 {
 438                         uint func = ((u32) int_val >> 16);
 439                         uint blksize = (u16) int_val;
 440                         uint maxsize;
 441
 442                         if (func > si->num_funcs) {
 443                                 bcmerror = -EINVAL;
 444                                 break;
 445                         }
 446
 447                         switch (func) {
 448                         case 0:
 449                                 maxsize = 32;
 450                                 break;
 451                         case 1:
 452                                 maxsize = BLOCK_SIZE_4318;
 453                                 break;
 454                         case 2:
 455                                 maxsize = BLOCK_SIZE_4328;
 456                                 break;
 457                         default:
 458                                 maxsize = 0;
 459                         }
 460                         if (blksize > maxsize) {
 461                                 bcmerror = -EINVAL;
 462                                 break;
 463                         }
 464                         if (!blksize)
 465                                 blksize = maxsize;
 466
 467                         /* Now set it */
 468                         si->client_block_size[func] = blksize;
 469
 470                         break;
 471                 }
 472
 473         case IOV_GVAL(IOV_RXCHAIN):
 474                 int_val = false;
 475                 memcpy(arg, &int_val, val_size);
 476                 break;
 477
 478         case IOV_GVAL(IOV_USEINTS):
 479                 int_val = (s32) si->use_client_ints;
 480                 memcpy(arg, &int_val, val_size);
 481                 break;
 482
 483         case IOV_SVAL(IOV_USEINTS):
 484                 si->use_client_ints = (bool) int_val;
 485                 if (si->use_client_ints)
 486                         si->intmask |= CLIENT_INTR;
 487                 else
 488                         si->intmask &= ~CLIENT_INTR;
 489
 490                 break;
 491
 492         case IOV_GVAL(IOV_NUMINTS):
 493                 int_val = (s32) si->intrcount;
 494                 memcpy(arg, &int_val, val_size);
 495                 break;
 496
 497         case IOV_GVAL(IOV_DEVREG):
 498                 {
 499                         sdreg_t *sd_ptr = (sdreg_t *) params;
 500                         u8 data = 0;
 501
 502                         if (brcmf_sdioh_cfg_read
 503                             (si, sd_ptr->func, sd_ptr->offset, &data)) {
 504                                 bcmerror = -EIO;
 505                                 break;
 506                         }
 507
 508                         int_val = (int)data;
 509                         memcpy(arg, &int_val, sizeof(int_val));
 510                         break;
 511                 }
 512
 513         case IOV_SVAL(IOV_DEVREG):
 514                 {
 515                         sdreg_t *sd_ptr = (sdreg_t *) params;
 516                         u8 data = (u8) sd_ptr->value;
 517
 518                         if (brcmf_sdioh_cfg_write
 519                             (si, sd_ptr->func, sd_ptr->offset, &data)) {
 520                                 bcmerror = -EIO;
 521                                 break;
 522                         }
 523                         break;
 524                 }
 525
 526         default:
 527                 bcmerror = -ENOTSUPP;
 528                 break;
 529         }
 530 exit:
 531
 532         return bcmerror;
 533 }
 534
 535 #if defined(OOB_INTR_ONLY) && defined(HW_OOB)
 536
 537 SDIOH_API_RC brcmf_sdioh_enable_hw_oob_intr(sdioh_info_t *sd, bool enable)
 538 {
 539         SDIOH_API_RC status;
 540         u8 data;
 541
 542         if (enable)
 543                 data = 3;       /* enable hw oob interrupt */
 544         else
 545                 data = 4;       /* disable hw oob interrupt */
 546         data |= 4;              /* Active HIGH */
 547
 548         status = brcmf_sdioh_request_byte(sd, SDIOH_WRITE, 0, 0xf2, &data);
 549         return status;
 550 }
 551 #endif                          /* defined(OOB_INTR_ONLY) && defined(HW_OOB) */
 552
 553 extern SDIOH_API_RC
 554 brcmf_sdioh_cfg_read(sdioh_info_t *sd, uint fnc_num, u32 addr, u8 *data)
 555 {
 556         SDIOH_API_RC status;
 557         /* No lock needed since brcmf_sdioh_request_byte does locking */
 558         status = brcmf_sdioh_request_byte(sd, SDIOH_READ, fnc_num, addr, data);
 559         return status;
 560 }
 561
 562 extern SDIOH_API_RC
 563 brcmf_sdioh_cfg_write(sdioh_info_t *sd, uint fnc_num, u32 addr, u8 *data)
 564 {
 565         /* No lock needed since brcmf_sdioh_request_byte does locking */
 566         SDIOH_API_RC status;
 567         status = brcmf_sdioh_request_byte(sd, SDIOH_WRITE, fnc_num, addr, data);
 568         return status;
 569 }
 570
 571 static int brcmf_sdioh_get_cisaddr(sdioh_info_t *sd, u32 regaddr)
 572 {
 573         /* read 24 bits and return valid 17 bit addr */
 574         int i;
 575         u32 scratch, regdata;
 576         u8 *ptr = (u8 *)&scratch;
 577         for (i = 0; i < 3; i++) {
 578                 if ((brcmf_sdioh_card_regread(sd, 0, regaddr, 1, &regdata)) !=
 579                     SUCCESS)
 580                         sd_err(("%s: Can't read!\n", __func__));
 581
 582                 *ptr++ = (u8) regdata;
 583                 regaddr++;
 584         }
 585
 586         /* Only the lower 17-bits are valid */
 587         scratch = le32_to_cpu(scratch);
 588         scratch &= 0x0001FFFF;
 589         return scratch;
 590 }
 591
 592 extern SDIOH_API_RC
 593 brcmf_sdioh_cis_read(sdioh_info_t *sd, uint func, u8 *cisd, u32 length)
 594 {
 595         u32 count;
 596         int offset;
 597         u32 foo;
 598         u8 *cis = cisd;
 599
 600         sd_trace(("%s: Func = %d\n", __func__, func));
 601
 602         if (!sd->func_cis_ptr[func]) {
 603                 memset(cis, 0, length);
 604                 sd_err(("%s: no func_cis_ptr[%d]\n", __func__, func));
 605                 return SDIOH_API_RC_FAIL;
 606         }
 607
 608         sd_err(("%s: func_cis_ptr[%d]=0x%04x\n", __func__, func,
 609                 sd->func_cis_ptr[func]));
 610
 611         for (count = 0; count < length; count++) {
 612                 offset = sd->func_cis_ptr[func] + count;
 613                 if (brcmf_sdioh_card_regread(sd, 0, offset, 1, &foo) < 0) {
 614                         sd_err(("%s: regread failed: Can't read CIS\n",
 615                                 __func__));
 616                         return SDIOH_API_RC_FAIL;
 617                 }
 618
 619                 *cis = (u8) (foo & 0xff);
 620                 cis++;
 621         }
 622
 623         return SDIOH_API_RC_SUCCESS;
 624 }
 625
 626 extern SDIOH_API_RC
 627 brcmf_sdioh_request_byte(sdioh_info_t *sd, uint rw, uint func, uint regaddr,
 628                    u8 *byte)
 629 {
 630         int err_ret;
 631
 632         sd_info(("%s: rw=%d, func=%d, addr=0x%05x\n", __func__, rw, func,
 633                  regaddr));
 634
 635         DHD_PM_RESUME_WAIT(sdioh_request_byte_wait);
 636         DHD_PM_RESUME_RETURN_ERROR(SDIOH_API_RC_FAIL);
 637         if (rw) {               /* CMD52 Write */
 638                 if (func == 0) {
 639                         /* Can only directly write to some F0 registers.
 640                          * Handle F2 enable
 641                          * as a special case.
 642                          */
 643                         if (regaddr == SDIO_CCCR_IOEx) {
 644                                 if (gInstance->func[2]) {
 645                                         sdio_claim_host(gInstance->func[2]);
 646                                         if (*byte & SDIO_FUNC_ENABLE_2) {
 647                                                 /* Enable Function 2 */
 648                                                 err_ret =
 649                                                     sdio_enable_func
 650                                                     (gInstance->func[2]);
 651                                                 if (err_ret)
 652                                                         sd_err(("bcmsdh_sdmmc: enable F2 failed:%d",
 653                                                                  err_ret));
 654                                         } else {
 655                                                 /* Disable Function 2 */
 656                                                 err_ret =
 657                                                     sdio_disable_func
 658                                                     (gInstance->func[2]);
 659                                                 if (err_ret)
 660                                                         sd_err(("bcmsdh_sdmmc: Disab F2 failed:%d",
 661                                                                  err_ret));
 662                                         }
 663                                         sdio_release_host(gInstance->func[2]);
 664                                 }
 665                         }
 666 #if defined(MMC_SDIO_ABORT)
 667                         /* to allow abort command through F1 */
 668                         else if (regaddr == SDIO_CCCR_ABORT) {
 669                                 sdio_claim_host(gInstance->func[func]);
 670                                 /*
 671                                  * this sdio_f0_writeb() can be replaced
 672                                  * with another api
 673                                  * depending upon MMC driver change.
 674                                  * As of this time, this is temporaray one
 675                                  */
 676                                 sdio_writeb(gInstance->func[func], *byte,
 677                                             regaddr, &err_ret);
 678                                 sdio_release_host(gInstance->func[func]);
 679                         }
 680 #endif                          /* MMC_SDIO_ABORT */
 681                         else if (regaddr < 0xF0) {
 682                                 sd_err(("bcmsdh_sdmmc: F0 Wr:0x%02x: write "
 683                                         "disallowed\n", regaddr));
 684                         } else {
 685                                 /* Claim host controller, perform F0 write,
 686                                  and release */
 687                                 sdio_claim_host(gInstance->func[func]);
 688                                 sdio_f0_writeb(gInstance->func[func], *byte,
 689                                                regaddr, &err_ret);
 690                                 sdio_release_host(gInstance->func[func]);
 691                         }
 692                 } else {
 693                         /* Claim host controller, perform Fn write,
 694                          and release */
 695                         sdio_claim_host(gInstance->func[func]);
 696                         sdio_writeb(gInstance->func[func], *byte, regaddr,
 697                                     &err_ret);
 698                         sdio_release_host(gInstance->func[func]);
 699                 }
 700         } else {                /* CMD52 Read */
 701                 /* Claim host controller, perform Fn read, and release */
 702                 sdio_claim_host(gInstance->func[func]);
 703
 704                 if (func == 0) {
 705                         *byte =
 706                             sdio_f0_readb(gInstance->func[func], regaddr,
 707                                           &err_ret);
 708                 } else {
 709                         *byte =
 710                             sdio_readb(gInstance->func[func], regaddr,
 711                                        &err_ret);
 712                 }
 713
 714                 sdio_release_host(gInstance->func[func]);
 715         }
 716
 717         if (err_ret)
 718                 sd_err(("bcmsdh_sdmmc: Failed to %s byte F%d:@0x%05x=%02x, "
 719                         "Err: %d\n", rw ? "Write" : "Read", func, regaddr,
 720                         *byte, err_ret));
 721
 722         return ((err_ret == 0) ? SDIOH_API_RC_SUCCESS : SDIOH_API_RC_FAIL);
 723 }
 724
 725 extern SDIOH_API_RC
 726 brcmf_sdioh_request_word(sdioh_info_t *sd, uint cmd_type, uint rw, uint func,
 727                    uint addr, u32 *word, uint nbytes)
 728 {
 729         int err_ret = SDIOH_API_RC_FAIL;
 730
 731         if (func == 0) {
 732                 sd_err(("%s: Only CMD52 allowed to F0.\n", __func__));
 733                 return SDIOH_API_RC_FAIL;
 734         }
 735
 736         sd_info(("%s: cmd_type=%d, rw=%d, func=%d, addr=0x%05x, nbytes=%d\n",
 737                  __func__, cmd_type, rw, func, addr, nbytes));
 738
 739         DHD_PM_RESUME_WAIT(sdioh_request_word_wait);
 740         DHD_PM_RESUME_RETURN_ERROR(SDIOH_API_RC_FAIL);
 741         /* Claim host controller */
 742         sdio_claim_host(gInstance->func[func]);
 743
 744         if (rw) {               /* CMD52 Write */
 745                 if (nbytes == 4) {
 746                         sdio_writel(gInstance->func[func], *word, addr,
 747                                     &err_ret);
 748                 } else if (nbytes == 2) {
 749                         sdio_writew(gInstance->func[func], (*word & 0xFFFF),
 750                                     addr, &err_ret);
 751                 } else {
 752                         sd_err(("%s: Invalid nbytes: %d\n", __func__, nbytes));
 753                 }
 754         } else {                /* CMD52 Read */
 755                 if (nbytes == 4) {
 756                         *word =
 757                             sdio_readl(gInstance->func[func], addr, &err_ret);
 758                 } else if (nbytes == 2) {
 759                         *word =
 760                             sdio_readw(gInstance->func[func], addr,
 761                                        &err_ret) & 0xFFFF;
 762                 } else {
 763                         sd_err(("%s: Invalid nbytes: %d\n", __func__, nbytes));
 764                 }
 765         }
 766
 767         /* Release host controller */
 768         sdio_release_host(gInstance->func[func]);
 769
 770         if (err_ret) {
 771                 sd_err(("bcmsdh_sdmmc: Failed to %s word, Err: 0x%08x",
 772                         rw ? "Write" : "Read", err_ret));
 773         }
 774
 775         return ((err_ret == 0) ? SDIOH_API_RC_SUCCESS : SDIOH_API_RC_FAIL);
 776 }
 777
 778 static SDIOH_API_RC
 779 brcmf_sdioh_request_packet(sdioh_info_t *sd, uint fix_inc, uint write,
 780                            uint func, uint addr, struct sk_buff *pkt)
 781 {
 782         bool fifo = (fix_inc == SDIOH_DATA_FIX);
 783         u32 SGCount = 0;
 784         int err_ret = 0;
 785
 786         struct sk_buff *pnext;
 787
 788         sd_trace(("%s: Enter\n", __func__));
 789
 790         ASSERT(pkt);
 791         DHD_PM_RESUME_WAIT(sdioh_request_packet_wait);
 792         DHD_PM_RESUME_RETURN_ERROR(SDIOH_API_RC_FAIL);
 793
 794         /* Claim host controller */
 795         sdio_claim_host(gInstance->func[func]);
 796         for (pnext = pkt; pnext; pnext = pnext->next) {
 797                 uint pkt_len = pnext->len;
 798                 pkt_len += 3;
 799                 pkt_len &= 0xFFFFFFFC;
 800
 801 #ifdef CONFIG_MMC_MSM7X00A
 802                 if ((pkt_len % 64) == 32) {
 803                         sd_trace(("%s: Rounding up TX packet +=32\n",
 804                                   __func__));
 805                         pkt_len += 32;
 806                 }
 807 #endif                          /* CONFIG_MMC_MSM7X00A */
 808                 /* Make sure the packet is aligned properly.
 809                  * If it isn't, then this
 810                  * is the fault of brcmf_sdioh_request_buffer() which
 811                  * is supposed to give
 812                  * us something we can work with.
 813                  */
 814                 ASSERT(((u32) (pkt->data) & DMA_ALIGN_MASK) == 0);
 815
 816                 if ((write) && (!fifo)) {
 817                         err_ret = sdio_memcpy_toio(gInstance->func[func], addr,
 818                                                    ((u8 *) (pnext->data)),
 819                                                    pkt_len);
 820                 } else if (write) {
 821                         err_ret = sdio_memcpy_toio(gInstance->func[func], addr,
 822                                                    ((u8 *) (pnext->data)),
 823                                                    pkt_len);
 824                 } else if (fifo) {
 825                         err_ret = sdio_readsb(gInstance->func[func],
 826                                               ((u8 *) (pnext->data)),
 827                                               addr, pkt_len);
 828                 } else {
 829                         err_ret = sdio_memcpy_fromio(gInstance->func[func],
 830                                                      ((u8 *) (pnext->data)),
 831                                                      addr, pkt_len);
 832                 }
 833
 834                 if (err_ret) {
 835                         sd_err(("%s: %s FAILED %p[%d], addr=0x%05x, pkt_len=%d,"
 836                                  "ERR=0x%08x\n", __func__,
 837                                  (write) ? "TX" : "RX",
 838                                  pnext, SGCount, addr, pkt_len, err_ret));
 839                 } else {
 840                         sd_trace(("%s: %s xfr'd %p[%d], addr=0x%05x, len=%d\n",
 841                                   __func__,
 842                                   (write) ? "TX" : "RX",
 843                                   pnext, SGCount, addr, pkt_len));
 844                 }
 845
 846                 if (!fifo)
 847                         addr += pkt_len;
 848                 SGCount++;
 849
 850         }
 851
 852         /* Release host controller */
 853         sdio_release_host(gInstance->func[func]);
 854
 855         sd_trace(("%s: Exit\n", __func__));
 856         return ((err_ret == 0) ? SDIOH_API_RC_SUCCESS : SDIOH_API_RC_FAIL);
 857 }
 858
 859 /*
 860  * This function takes a buffer or packet, and fixes everything up
 861  * so that in the end, a DMA-able packet is created.
 862  *
 863  * A buffer does not have an associated packet pointer,
 864  * and may or may not be aligned.
 865  * A packet may consist of a single packet, or a packet chain.
 866  * If it is a packet chain, then all the packets in the chain
 867  * must be properly aligned.
 868  *
 869  * If the packet data is not aligned, then there may only be
 870  * one packet, and in this case,  it is copied to a new
 871  * aligned packet.
 872  *
 873  */
 874 extern SDIOH_API_RC
 875 brcmf_sdioh_request_buffer(sdioh_info_t *sd, uint pio_dma, uint fix_inc,
 876                            uint write, uint func, uint addr, uint reg_width,
 877                            uint buflen_u, u8 *buffer, struct sk_buff *pkt)
 878 {
 879         SDIOH_API_RC Status;
 880         struct sk_buff *mypkt = NULL;
 881
 882         sd_trace(("%s: Enter\n", __func__));
 883
 884         DHD_PM_RESUME_WAIT(sdioh_request_buffer_wait);
 885         DHD_PM_RESUME_RETURN_ERROR(SDIOH_API_RC_FAIL);
 886         /* Case 1: we don't have a packet. */
 887         if (pkt == NULL) {
 888                 sd_data(("%s: Creating new %s Packet, len=%d\n",
 889                          __func__, write ? "TX" : "RX", buflen_u));
 890                 mypkt = brcmu_pkt_buf_get_skb(buflen_u);
 891                 if (!mypkt) {
 892                         sd_err(("%s: brcmu_pkt_buf_get_skb failed: len %d\n",
 893                                 __func__, buflen_u));
 894                         return SDIOH_API_RC_FAIL;
 895                 }
 896
 897                 /* For a write, copy the buffer data into the packet. */
 898                 if (write)
 899                         memcpy(mypkt->data, buffer, buflen_u);
 900
 901                 Status = brcmf_sdioh_request_packet(sd, fix_inc, write, func,
 902                                                     addr, mypkt);
 903
 904                 /* For a read, copy the packet data back to the buffer. */
 905                 if (!write)
 906                         memcpy(buffer, mypkt->data, buflen_u);
 907
 908                 brcmu_pkt_buf_free_skb(mypkt);
 909         } else if (((u32) (pkt->data) & DMA_ALIGN_MASK) != 0) {
 910                 /* Case 2: We have a packet, but it is unaligned. */
 911
 912                 /* In this case, we cannot have a chain. */
 913                 ASSERT(pkt->next == NULL);
 914
 915                 sd_data(("%s: Creating aligned %s Packet, len=%d\n",
 916                          __func__, write ? "TX" : "RX", pkt->len));
 917                 mypkt = brcmu_pkt_buf_get_skb(pkt->len);
 918                 if (!mypkt) {
 919                         sd_err(("%s: brcmu_pkt_buf_get_skb failed: len %d\n",
 920                                 __func__, pkt->len));
 921                         return SDIOH_API_RC_FAIL;
 922                 }
 923
 924                 /* For a write, copy the buffer data into the packet. */
 925                 if (write)
 926                         memcpy(mypkt->data, pkt->data, pkt->len);
 927
 928                 Status = brcmf_sdioh_request_packet(sd, fix_inc, write, func,
 929                                                     addr, mypkt);
 930
 931                 /* For a read, copy the packet data back to the buffer. */
 932                 if (!write)
 933                         memcpy(pkt->data, mypkt->data, mypkt->len);
 934
 935                 brcmu_pkt_buf_free_skb(mypkt);
 936         } else {                /* case 3: We have a packet and
 937                                  it is aligned. */
 938                 sd_data(("%s: Aligned %s Packet, direct DMA\n",
 939                          __func__, write ? "Tx" : "Rx"));
 940                 Status = brcmf_sdioh_request_packet(sd, fix_inc, write, func,
 941                                                     addr, pkt);
 942         }
 943
 944         return Status;
 945 }
 946
 947 /* this function performs "abort" for both of host & device */
 948 extern int brcmf_sdioh_abort(sdioh_info_t *sd, uint func)
 949 {
 950 #if defined(MMC_SDIO_ABORT)
 951         char t_func = (char)func;
 952 #endif                          /* defined(MMC_SDIO_ABORT) */
 953         sd_trace(("%s: Enter\n", __func__));
 954
 955 #if defined(MMC_SDIO_ABORT)
 956         /* issue abort cmd52 command through F0 */
 957         brcmf_sdioh_request_byte(sd, SDIOH_WRITE, SDIO_FUNC_0, SDIO_CCCR_ABORT,
 958                            &t_func);
 959 #endif                          /* defined(MMC_SDIO_ABORT) */
 960
 961         sd_trace(("%s: Exit\n", __func__));
 962         return SDIOH_API_RC_SUCCESS;
 963 }
 964
 965 /* Reset and re-initialize the device */
 966 int brcmf_sdioh_reset(sdioh_info_t *si)
 967 {
 968         sd_trace(("%s: Enter\n", __func__));
 969         sd_trace(("%s: Exit\n", __func__));
 970         return SDIOH_API_RC_SUCCESS;
 971 }
 972
 973 /* Disable device interrupt */
 974 void brcmf_sdioh_dev_intr_off(sdioh_info_t *sd)
 975 {
 976         sd_trace(("%s: %d\n", __func__, sd->use_client_ints));
 977         sd->intmask &= ~CLIENT_INTR;
 978 }
 979
 980 /* Enable device interrupt */
 981 void brcmf_sdioh_dev_intr_on(sdioh_info_t *sd)
 982 {
 983         sd_trace(("%s: %d\n", __func__, sd->use_client_ints));
 984         sd->intmask |= CLIENT_INTR;
 985 }
 986
 987 /* Read client card reg */
 988 int
 989 brcmf_sdioh_card_regread(sdioh_info_t *sd, int func, u32 regaddr,
 990                          int regsize, u32 *data)
 991 {
 992
 993         if ((func == 0) || (regsize == 1)) {
 994                 u8 temp = 0;
 995
 996                 brcmf_sdioh_request_byte(sd, SDIOH_READ, func, regaddr, &temp);
 997                 *data = temp;
 998                 *data &= 0xff;
 999                 sd_data(("%s: byte read data=0x%02x\n", __func__, *data));
1000         } else {
1001                 brcmf_sdioh_request_word(sd, 0, SDIOH_READ, func, regaddr, data,
1002                                    regsize);
1003                 if (regsize == 2)
1004                         *data &= 0xffff;
1005
1006                 sd_data(("%s: word read data=0x%08x\n", __func__, *data));
1007         }
1008
1009         return SUCCESS;
1010 }
1011
1012 #if !defined(OOB_INTR_ONLY)
1013 /* bcmsdh_sdmmc interrupt handler */
1014 static void brcmf_sdioh_irqhandler(struct sdio_func *func)
1015 {
1016         sdioh_info_t *sd;
1017
1018         sd_trace(("bcmsdh_sdmmc: ***IRQHandler\n"));
1019         sd = gInstance->sd;
1020
1021         ASSERT(sd != NULL);
1022         sdio_release_host(gInstance->func[0]);
1023
1024         if (sd->use_client_ints) {
1025                 sd->intrcount++;
1026                 ASSERT(sd->intr_handler);
1027                 ASSERT(sd->intr_handler_arg);
1028                 (sd->intr_handler) (sd->intr_handler_arg);
1029         } else {
1030                 sd_err(("bcmsdh_sdmmc: ***IRQHandler\n"));
1031
1032                 sd_err(("%s: Not ready for intr: enabled %d, handler %p\n",
1033                         __func__, sd->client_intr_enabled, sd->intr_handler));
1034         }
1035
1036         sdio_claim_host(gInstance->func[0]);
1037 }
1038
1039 /* bcmsdh_sdmmc interrupt handler for F2 (dummy handler) */
1040 static void brcmf_sdioh_irqhandler_f2(struct sdio_func *func)
1041 {
1042         sdioh_info_t *sd;
1043
1044         sd_trace(("bcmsdh_sdmmc: ***IRQHandlerF2\n"));
1045
1046         sd = gInstance->sd;
1047
1048         ASSERT(sd != NULL);
1049 }
1050 #endif                          /* !defined(OOB_INTR_ONLY) */
1051
1052 #ifdef NOTUSED
1053 /* Write client card reg */
1054 static int
1055 brcmf_sdioh_card_regwrite(sdioh_info_t *sd, int func, u32 regaddr,
1056                           int regsize, u32 data)
1057 {
1058
1059         if ((func == 0) || (regsize == 1)) {
1060                 u8 temp;
1061
1062                 temp = data & 0xff;
1063                 brcmf_sdioh_request_byte(sd, SDIOH_READ, func, regaddr, &temp);
1064                 sd_data(("%s: byte write data=0x%02x\n", __func__, data));
1065         } else {
1066                 if (regsize == 2)
1067                         data &= 0xffff;
1068
1069                 brcmf_sdioh_request_word(sd, 0, SDIOH_READ, func, regaddr,
1070                                          &data, regsize);
1071
1072                 sd_data(("%s: word write data=0x%08x\n", __func__, data));
1073         }
1074
1075         return SUCCESS;
1076 }
1077 #endif                          /* NOTUSED */
1078
1079 int brcmf_sdioh_start(sdioh_info_t *si, int stage)
1080 {
1081         return 0;
1082 }
1083
1084 int brcmf_sdioh_stop(sdioh_info_t *si)
1085 {
1086         return 0;
1087 }