drivers/staging/brcm80211/brcmfmac/bcmsdh.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 /* ****************** SDIO CARD Interface Functions **************************/
  17
  18 #include <linux/types.h>
  19 #include <linux/netdevice.h>
  20 #include <linux/pci.h>
  21 #include <linux/pci_ids.h>
  22 #include <linux/sched.h>
  23 #include <linux/completion.h>
  24 #include <linux/mmc/sdio.h>
  25 #include <linux/mmc/sdio_func.h>
  26 #include <linux/mmc/card.h>
  27
  28 #include <defs.h>
  29 #include <brcm_hw_ids.h>
  30 #include <brcmu_utils.h>
  31 #include <brcmu_wifi.h>
  32 #include <soc.h>
  33 #include "dhd.h"
  34 #include "dhd_bus.h"
  35 #include "dhd_dbg.h"
  36 #include "sdio_host.h"
  37
  38 #define SDIOH_API_ACCESS_RETRY_LIMIT    2
  39
  40 #define SDIOH_CMD_TYPE_NORMAL   0       /* Normal command */
  41 #define SDIOH_CMD_TYPE_APPEND   1       /* Append command */
  42 #define SDIOH_CMD_TYPE_CUTTHRU  2       /* Cut-through command */
  43
  44 #define SDIOH_DATA_PIO          0       /* PIO mode */
  45 #define SDIOH_DATA_DMA          1       /* DMA mode */
  46
  47 /* Module parameters specific to each host-controller driver */
  48
  49 module_param(sd_f2_blocksize, int, 0);
  50
  51 /* IOVar table */
  52 enum {
  53         IOV_MSGLEVEL = 1,
  54         IOV_DEVREG,
  55         IOV_HCIREGS,
  56         IOV_RXCHAIN
  57 };
  58
  59 const struct brcmu_iovar sdioh_iovars[] = {
  60         {"sd_devreg", IOV_DEVREG, 0, IOVT_BUFFER, sizeof(struct brcmf_sdreg)}
  61         ,
  62         {"sd_rxchain", IOV_RXCHAIN, 0, IOVT_BOOL, 0}
  63         ,
  64         {NULL, 0, 0, 0, 0}
  65 };
  66
  67 int
  68 brcmf_sdcard_iovar_op(struct brcmf_sdio_dev *sdiodev, const char *name,
  69                 void *params, int plen, void *arg, int len, bool set)
  70 {
  71         const struct brcmu_iovar *vi = NULL;
  72         int bcmerror = 0;
  73         int val_size;
  74         s32 int_val = 0;
  75         bool bool_val;
  76         u32 actionid;
  77
  78         if (name == NULL || len < 0)
  79                 return -EINVAL;
  80
  81         /* Set does not take qualifiers */
  82         if (set && (params || plen))
  83                 return -EINVAL;
  84
  85         /* Get must have return space;*/
  86         if (!set && !(arg && len))
  87                 return -EINVAL;
  88
  89         BRCMF_TRACE(("%s: Enter (%s %s)\n", __func__, (set ? "set" : "get"),
  90                   name));
  91
  92         vi = brcmu_iovar_lookup(sdioh_iovars, name);
  93         if (vi == NULL) {
  94                 bcmerror = -ENOTSUPP;
  95                 goto exit;
  96         }
  97
  98         bcmerror = brcmu_iovar_lencheck(vi, arg, len, set);
  99         if (bcmerror != 0)
 100                 goto exit;
 101
 102         /* Set up params so get and set can share the convenience variables */
 103         if (params == NULL) {
 104                 params = arg;
 105                 plen = len;
 106         }
 107
 108         if (vi->type == IOVT_VOID)
 109                 val_size = 0;
 110         else if (vi->type == IOVT_BUFFER)
 111                 val_size = len;
 112         else
 113                 val_size = sizeof(int);
 114
 115         if (plen >= (int)sizeof(int_val))
 116                 memcpy(&int_val, params, sizeof(int_val));
 117
 118         bool_val = (int_val != 0) ? true : false;
 119
 120         actionid = set ? IOV_SVAL(vi->varid) : IOV_GVAL(vi->varid);
 121         switch (actionid) {
 122         case IOV_GVAL(IOV_RXCHAIN):
 123                 int_val = false;
 124                 memcpy(arg, &int_val, val_size);
 125                 break;
 126
 127         case IOV_GVAL(IOV_DEVREG):
 128                 {
 129                         struct brcmf_sdreg *sd_ptr =
 130                                         (struct brcmf_sdreg *) params;
 131                         u8 data = 0;
 132
 133                         if (brcmf_sdioh_request_byte(sdiodev, SDIOH_READ,
 134                                         sd_ptr->func, sd_ptr->offset, &data)) {
 135                                 bcmerror = -EIO;
 136                                 break;
 137                         }
 138
 139                         int_val = (int)data;
 140                         memcpy(arg, &int_val, sizeof(int_val));
 141                         break;
 142                 }
 143
 144         case IOV_SVAL(IOV_DEVREG):
 145                 {
 146                         struct brcmf_sdreg *sd_ptr =
 147                                         (struct brcmf_sdreg *) params;
 148                         u8 data = (u8) sd_ptr->value;
 149
 150                         if (brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE,
 151                                         sd_ptr->func, sd_ptr->offset, &data)) {
 152                                 bcmerror = -EIO;
 153                                 break;
 154                         }
 155                         break;
 156                 }
 157
 158         default:
 159                 bcmerror = -ENOTSUPP;
 160                 break;
 161         }
 162 exit:
 163
 164         return bcmerror;
 165 }
 166
 167 static void brcmf_sdioh_irqhandler(struct sdio_func *func)
 168 {
 169         struct brcmf_sdio_dev *sdiodev = dev_get_drvdata(&func->card->dev);
 170
 171         BRCMF_TRACE(("brcmf: ***IRQHandler\n"));
 172
 173         sdio_release_host(func);
 174
 175         brcmf_sdbrcm_isr(sdiodev->bus);
 176
 177         sdio_claim_host(func);
 178 }
 179
 180 int brcmf_sdcard_intr_reg(struct brcmf_sdio_dev *sdiodev)
 181 {
 182         BRCMF_TRACE(("%s: Entering\n", __func__));
 183
 184         sdio_claim_host(sdiodev->func[1]);
 185         sdio_claim_irq(sdiodev->func[1], brcmf_sdioh_irqhandler);
 186         sdio_release_host(sdiodev->func[1]);
 187
 188         return 0;
 189 }
 190
 191 int brcmf_sdcard_intr_dereg(struct brcmf_sdio_dev *sdiodev)
 192 {
 193         BRCMF_TRACE(("%s: Entering\n", __func__));
 194
 195         sdio_claim_host(sdiodev->func[1]);
 196         sdio_release_irq(sdiodev->func[1]);
 197         sdio_release_host(sdiodev->func[1]);
 198
 199         return 0;
 200 }
 201
 202 u8 brcmf_sdcard_cfg_read(struct brcmf_sdio_dev *sdiodev, uint fnc_num, u32 addr,
 203                          int *err)
 204 {
 205         int status;
 206         s32 retry = 0;
 207         u8 data = 0;
 208
 209         do {
 210                 if (retry)      /* wait for 1 ms till bus get settled down */
 211                         udelay(1000);
 212                 status = brcmf_sdioh_request_byte(sdiodev, SDIOH_READ, fnc_num,
 213                                                   addr, (u8 *) &data);
 214         } while (status != 0
 215                  && (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
 216         if (err)
 217                 *err = status;
 218
 219         BRCMF_INFO(("%s:fun = %d, addr = 0x%x, u8data = 0x%x\n",
 220                      __func__, fnc_num, addr, data));
 221
 222         return data;
 223 }
 224
 225 void
 226 brcmf_sdcard_cfg_write(struct brcmf_sdio_dev *sdiodev, uint fnc_num, u32 addr,
 227                        u8 data, int *err)
 228 {
 229         int status;
 230         s32 retry = 0;
 231
 232         do {
 233                 if (retry)      /* wait for 1 ms till bus get settled down */
 234                         udelay(1000);
 235                 status = brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE, fnc_num,
 236                                                   addr, (u8 *) &data);
 237         } while (status != 0
 238                  && (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
 239         if (err)
 240                 *err = status;
 241
 242         BRCMF_INFO(("%s:fun = %d, addr = 0x%x, u8data = 0x%x\n",
 243                      __func__, fnc_num, addr, data));
 244 }
 245
 246 int brcmf_sdcard_cis_read(struct brcmf_sdio_dev *sdiodev, uint func, u8 * cis,
 247                           uint length)
 248 {
 249         int status;
 250
 251         u8 *tmp_buf, *tmp_ptr;
 252         u8 *ptr;
 253         bool ascii = func & ~0xf;
 254         func &= 0x7;
 255
 256         status = brcmf_sdioh_cis_read(sdiodev, func, cis, length);
 257
 258         if (ascii) {
 259                 /* Move binary bits to tmp and format them
 260                          into the provided buffer. */
 261                 tmp_buf = kmalloc(length, GFP_ATOMIC);
 262                 if (tmp_buf == NULL) {
 263                         BRCMF_ERROR(("%s: out of memory\n", __func__));
 264                         return -ENOMEM;
 265                 }
 266                 memcpy(tmp_buf, cis, length);
 267                 for (tmp_ptr = tmp_buf, ptr = cis; ptr < (cis + length - 4);
 268                      tmp_ptr++) {
 269                         ptr += sprintf((char *)ptr, "%.2x ", *tmp_ptr & 0xff);
 270                         if ((((tmp_ptr - tmp_buf) + 1) & 0xf) == 0)
 271                                 ptr += sprintf((char *)ptr, "\n");
 272                 }
 273                 kfree(tmp_buf);
 274         }
 275
 276         return status;
 277 }
 278
 279 static int
 280 brcmf_sdcard_set_sbaddr_window(struct brcmf_sdio_dev *sdiodev, u32 address)
 281 {
 282         int err = 0;
 283         brcmf_sdcard_cfg_write(sdiodev, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRLOW,
 284                          (address >> 8) & SBSDIO_SBADDRLOW_MASK, &err);
 285         if (!err)
 286                 brcmf_sdcard_cfg_write(sdiodev, SDIO_FUNC_1,
 287                                        SBSDIO_FUNC1_SBADDRMID,
 288                                        (address >> 16) & SBSDIO_SBADDRMID_MASK,
 289                                        &err);
 290         if (!err)
 291                 brcmf_sdcard_cfg_write(sdiodev, SDIO_FUNC_1,
 292                                        SBSDIO_FUNC1_SBADDRHIGH,
 293                                        (address >> 24) & SBSDIO_SBADDRHIGH_MASK,
 294                                        &err);
 295
 296         return err;
 297 }
 298
 299 u32 brcmf_sdcard_reg_read(struct brcmf_sdio_dev *sdiodev, u32 addr, uint size)
 300 {
 301         int status;
 302         u32 word = 0;
 303         uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
 304
 305         BRCMF_INFO(("%s:fun = 1, addr = 0x%x, ", __func__, addr));
 306
 307         if (bar0 != sdiodev->sbwad) {
 308                 if (brcmf_sdcard_set_sbaddr_window(sdiodev, bar0))
 309                         return 0xFFFFFFFF;
 310
 311                 sdiodev->sbwad = bar0;
 312         }
 313
 314         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 315         if (size == 4)
 316                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 317
 318         status = brcmf_sdioh_request_word(sdiodev, SDIOH_CMD_TYPE_NORMAL,
 319                                     SDIOH_READ, SDIO_FUNC_1, addr, &word, size);
 320
 321         sdiodev->regfail = (status != 0);
 322
 323         BRCMF_INFO(("u32data = 0x%x\n", word));
 324
 325         /* if ok, return appropriately masked word */
 326         if (status == 0) {
 327                 switch (size) {
 328                 case sizeof(u8):
 329                         return word & 0xff;
 330                 case sizeof(u16):
 331                         return word & 0xffff;
 332                 case sizeof(u32):
 333                         return word;
 334                 default:
 335                         sdiodev->regfail = true;
 336
 337                 }
 338         }
 339
 340         /* otherwise, bad sdio access or invalid size */
 341         BRCMF_ERROR(("%s: error reading addr 0x%04x size %d\n", __func__,
 342                       addr, size));
 343         return 0xFFFFFFFF;
 344 }
 345
 346 u32 brcmf_sdcard_reg_write(struct brcmf_sdio_dev *sdiodev, u32 addr, uint size,
 347                            u32 data)
 348 {
 349         int status;
 350         uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
 351         int err = 0;
 352
 353         BRCMF_INFO(("%s:fun = 1, addr = 0x%x, uint%ddata = 0x%x\n",
 354                      __func__, addr, size * 8, data));
 355
 356         if (bar0 != sdiodev->sbwad) {
 357                 err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0);
 358                 if (err)
 359                         return err;
 360
 361                 sdiodev->sbwad = bar0;
 362         }
 363
 364         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 365         if (size == 4)
 366                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 367         status =
 368             brcmf_sdioh_request_word(sdiodev, SDIOH_CMD_TYPE_NORMAL,
 369                                SDIOH_WRITE, SDIO_FUNC_1, addr, &data, size);
 370         sdiodev->regfail = (status != 0);
 371
 372         if (status == 0)
 373                 return 0;
 374
 375         BRCMF_ERROR(("%s: error writing 0x%08x to addr 0x%04x size %d\n",
 376                       __func__, data, addr, size));
 377         return 0xFFFFFFFF;
 378 }
 379
 380 bool brcmf_sdcard_regfail(struct brcmf_sdio_dev *sdiodev)
 381 {
 382         return sdiodev->regfail;
 383 }
 384
 385 int
 386 brcmf_sdcard_recv_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
 387                       uint flags,
 388                       u8 *buf, uint nbytes, struct sk_buff *pkt,
 389                       void (*complete)(void *handle, int status,
 390                                        bool sync_waiting),
 391                       void *handle)
 392 {
 393         int status;
 394         uint incr_fix;
 395         uint width;
 396         uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
 397         int err = 0;
 398
 399         BRCMF_INFO(("%s:fun = %d, addr = 0x%x, size = %d\n",
 400                      __func__, fn, addr, nbytes));
 401
 402         /* Async not implemented yet */
 403         if (flags & SDIO_REQ_ASYNC)
 404                 return -ENOTSUPP;
 405
 406         if (bar0 != sdiodev->sbwad) {
 407                 err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0);
 408                 if (err)
 409                         return err;
 410
 411                 sdiodev->sbwad = bar0;
 412         }
 413
 414         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 415
 416         incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
 417         width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
 418         if (width == 4)
 419                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 420
 421         status = brcmf_sdioh_request_buffer(sdiodev, SDIOH_DATA_PIO,
 422                 incr_fix, SDIOH_READ, fn, addr, width, nbytes, buf, pkt);
 423
 424         return status;
 425 }
 426
 427 int
 428 brcmf_sdcard_send_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
 429                       uint flags, u8 *buf, uint nbytes, void *pkt,
 430                       void (*complete)(void *handle, int status,
 431                                        bool sync_waiting),
 432                       void *handle)
 433 {
 434         uint incr_fix;
 435         uint width;
 436         uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
 437         int err = 0;
 438
 439         BRCMF_INFO(("%s:fun = %d, addr = 0x%x, size = %d\n",
 440                      __func__, fn, addr, nbytes));
 441
 442         /* Async not implemented yet */
 443         if (flags & SDIO_REQ_ASYNC)
 444                 return -ENOTSUPP;
 445
 446         if (bar0 != sdiodev->sbwad) {
 447                 err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0);
 448                 if (err)
 449                         return err;
 450
 451                 sdiodev->sbwad = bar0;
 452         }
 453
 454         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 455
 456         incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
 457         width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
 458         if (width == 4)
 459                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 460
 461         return brcmf_sdioh_request_buffer(sdiodev, SDIOH_DATA_PIO,
 462                 incr_fix, SDIOH_WRITE, fn, addr, width, nbytes, buf, pkt);
 463 }
 464
 465 int brcmf_sdcard_rwdata(struct brcmf_sdio_dev *sdiodev, uint rw, u32 addr,
 466                         u8 *buf, uint nbytes)
 467 {
 468         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 469         addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 470
 471         return brcmf_sdioh_request_buffer(sdiodev, SDIOH_DATA_PIO,
 472                 SDIOH_DATA_INC, (rw ? SDIOH_WRITE : SDIOH_READ), SDIO_FUNC_1,
 473                 addr, 4, nbytes, buf, NULL);
 474 }
 475
 476 int brcmf_sdcard_abort(struct brcmf_sdio_dev *sdiodev, uint fn)
 477 {
 478         char t_func = (char)fn;
 479         BRCMF_TRACE(("%s: Enter\n", __func__));
 480
 481         /* issue abort cmd52 command through F0 */
 482         brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE, SDIO_FUNC_0,
 483                                  SDIO_CCCR_ABORT, &t_func);
 484
 485         BRCMF_TRACE(("%s: Exit\n", __func__));
 486         return 0;
 487 }
 488
 489 u32 brcmf_sdcard_cur_sbwad(struct brcmf_sdio_dev *sdiodev)
 490 {
 491         return sdiodev->sbwad;
 492 }
 493
 494 int brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev)
 495 {
 496         u32 regs = 0;
 497         int ret = 0;
 498
 499         ret = brcmf_sdioh_attach(sdiodev);
 500         if (ret)
 501                 goto out;
 502
 503         regs = SI_ENUM_BASE;
 504
 505         /* Report the BAR, to fix if needed */
 506         sdiodev->sbwad = SI_ENUM_BASE;
 507
 508         /* try to attach to the target device */
 509         sdiodev->bus = brcmf_sdbrcm_probe(0, 0, 0, 0, regs, sdiodev);
 510         if (!sdiodev->bus) {
 511                 BRCMF_ERROR(("%s: device attach failed\n", __func__));
 512                 ret = -ENODEV;
 513                 goto out;
 514         }
 515
 516 out:
 517         if (ret)
 518                 brcmf_sdio_remove(sdiodev);
 519
 520         return ret;
 521 }
 522 EXPORT_SYMBOL(brcmf_sdio_probe);
 523
 524 int brcmf_sdio_remove(struct brcmf_sdio_dev *sdiodev)
 525 {
 526         if (sdiodev->bus) {
 527                 brcmf_sdbrcm_disconnect(sdiodev->bus);
 528                 sdiodev->bus = NULL;
 529         }
 530
 531         brcmf_sdioh_detach(sdiodev);
 532
 533         sdiodev->sbwad = 0;
 534
 535         return 0;
 536 }
 537 EXPORT_SYMBOL(brcmf_sdio_remove);
 538
 539 int brcmf_sdio_register(void)
 540 {
 541         return brcmf_sdio_function_init();
 542 }
 543
 544 void brcmf_sdio_unregister(void)
 545 {
 546         brcmf_sdio_function_cleanup();
 547 }
 548
 549 void brcmf_sdio_wdtmr_enable(struct brcmf_sdio_dev *sdiodev, bool enable)
 550 {
 551         if (enable)
 552                 brcmf_sdbrcm_wd_timer(sdiodev->bus, brcmf_watchdog_ms);
 553         else
 554                 brcmf_sdbrcm_wd_timer(sdiodev->bus, 0);
 555 }