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