drivers/net/wireless/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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  19
  20 #include <linux/types.h>
  21 #include <linux/netdevice.h>
  22 #include <linux/export.h>
  23 #include <linux/pci.h>
  24 #include <linux/pci_ids.h>
  25 #include <linux/sched.h>
  26 #include <linux/completion.h>
  27 #include <linux/mmc/sdio.h>
  28 #include <linux/mmc/sdio_func.h>
  29 #include <linux/mmc/card.h>
  30
  31 #include <defs.h>
  32 #include <brcm_hw_ids.h>
  33 #include <brcmu_utils.h>
  34 #include <brcmu_wifi.h>
  35 #include <soc.h>
  36 #include "dhd_bus.h"
  37 #include "dhd_dbg.h"
  38 #include "sdio_host.h"
  39
  40 #define SDIOH_API_ACCESS_RETRY_LIMIT    2
  41
  42 #ifdef CONFIG_BRCMFMAC_SDIO_OOB
  43 static irqreturn_t brcmf_sdio_irqhandler(int irq, void *dev_id)
  44 {
  45         struct brcmf_bus *bus_if = dev_get_drvdata(dev_id);
  46         struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
  47
  48         brcmf_dbg(INTR, "oob intr triggered\n");
  49
  50         /*
  51          * out-of-band interrupt is level-triggered which won't
  52          * be cleared until dpc
  53          */
  54         if (sdiodev->irq_en) {
  55                 disable_irq_nosync(irq);
  56                 sdiodev->irq_en = false;
  57         }
  58
  59         brcmf_sdbrcm_isr(sdiodev->bus);
  60
  61         return IRQ_HANDLED;
  62 }
  63
  64 int brcmf_sdio_intr_register(struct brcmf_sdio_dev *sdiodev)
  65 {
  66         int ret = 0;
  67         u8 data;
  68         unsigned long flags;
  69
  70         brcmf_dbg(TRACE, "Entering\n");
  71
  72         brcmf_dbg(ERROR, "requesting irq %d\n", sdiodev->irq);
  73         ret = request_irq(sdiodev->irq, brcmf_sdio_irqhandler,
  74                           sdiodev->irq_flags, "brcmf_oob_intr",
  75                           &sdiodev->func[1]->dev);
  76         if (ret != 0)
  77                 return ret;
  78         spin_lock_init(&sdiodev->irq_en_lock);
  79         spin_lock_irqsave(&sdiodev->irq_en_lock, flags);
  80         sdiodev->irq_en = true;
  81         spin_unlock_irqrestore(&sdiodev->irq_en_lock, flags);
  82
  83         ret = enable_irq_wake(sdiodev->irq);
  84         if (ret != 0)
  85                 return ret;
  86         sdiodev->irq_wake = true;
  87
  88         sdio_claim_host(sdiodev->func[1]);
  89
  90         /* must configure SDIO_CCCR_IENx to enable irq */
  91         data = brcmf_sdio_regrb(sdiodev, SDIO_CCCR_IENx, &ret);
  92         data |= 1 << SDIO_FUNC_1 | 1 << SDIO_FUNC_2 | 1;
  93         brcmf_sdio_regwb(sdiodev, SDIO_CCCR_IENx, data, &ret);
  94
  95         /* redirect, configure and enable io for interrupt signal */
  96         data = SDIO_SEPINT_MASK | SDIO_SEPINT_OE;
  97         if (sdiodev->irq_flags & IRQF_TRIGGER_HIGH)
  98                 data |= SDIO_SEPINT_ACT_HI;
  99         brcmf_sdio_regwb(sdiodev, SDIO_CCCR_BRCM_SEPINT, data, &ret);
 100
 101         sdio_release_host(sdiodev->func[1]);
 102
 103         return 0;
 104 }
 105
 106 int brcmf_sdio_intr_unregister(struct brcmf_sdio_dev *sdiodev)
 107 {
 108         brcmf_dbg(TRACE, "Entering\n");
 109
 110         sdio_claim_host(sdiodev->func[1]);
 111         brcmf_sdio_regwb(sdiodev, SDIO_CCCR_BRCM_SEPINT, 0, NULL);
 112         brcmf_sdio_regwb(sdiodev, SDIO_CCCR_IENx, 0, NULL);
 113         sdio_release_host(sdiodev->func[1]);
 114
 115         if (sdiodev->irq_wake) {
 116                 disable_irq_wake(sdiodev->irq);
 117                 sdiodev->irq_wake = false;
 118         }
 119         free_irq(sdiodev->irq, &sdiodev->func[1]->dev);
 120         sdiodev->irq_en = false;
 121
 122         return 0;
 123 }
 124 #else           /* CONFIG_BRCMFMAC_SDIO_OOB */
 125 static void brcmf_sdio_irqhandler(struct sdio_func *func)
 126 {
 127         struct brcmf_bus *bus_if = dev_get_drvdata(&func->dev);
 128         struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
 129
 130         brcmf_dbg(INTR, "ib intr triggered\n");
 131
 132         brcmf_sdbrcm_isr(sdiodev->bus);
 133 }
 134
 135 /* dummy handler for SDIO function 2 interrupt */
 136 static void brcmf_sdio_dummy_irqhandler(struct sdio_func *func)
 137 {
 138 }
 139
 140 int brcmf_sdio_intr_register(struct brcmf_sdio_dev *sdiodev)
 141 {
 142         brcmf_dbg(TRACE, "Entering\n");
 143
 144         sdio_claim_host(sdiodev->func[1]);
 145         sdio_claim_irq(sdiodev->func[1], brcmf_sdio_irqhandler);
 146         sdio_claim_irq(sdiodev->func[2], brcmf_sdio_dummy_irqhandler);
 147         sdio_release_host(sdiodev->func[1]);
 148
 149         return 0;
 150 }
 151
 152 int brcmf_sdio_intr_unregister(struct brcmf_sdio_dev *sdiodev)
 153 {
 154         brcmf_dbg(TRACE, "Entering\n");
 155
 156         sdio_claim_host(sdiodev->func[1]);
 157         sdio_release_irq(sdiodev->func[2]);
 158         sdio_release_irq(sdiodev->func[1]);
 159         sdio_release_host(sdiodev->func[1]);
 160
 161         return 0;
 162 }
 163 #endif          /* CONFIG_BRCMFMAC_SDIO_OOB */
 164
 165 int
 166 brcmf_sdcard_set_sbaddr_window(struct brcmf_sdio_dev *sdiodev, u32 address)
 167 {
 168         int err = 0, i;
 169         u8 addr[3];
 170         s32 retry;
 171
 172         addr[0] = (address >> 8) & SBSDIO_SBADDRLOW_MASK;
 173         addr[1] = (address >> 16) & SBSDIO_SBADDRMID_MASK;
 174         addr[2] = (address >> 24) & SBSDIO_SBADDRHIGH_MASK;
 175
 176         for (i = 0; i < 3; i++) {
 177                 retry = 0;
 178                 do {
 179                         if (retry)
 180                                 usleep_range(1000, 2000);
 181                         err = brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE,
 182                                         SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRLOW + i,
 183                                         &addr[i]);
 184                 } while (err != 0 && retry++ < SDIOH_API_ACCESS_RETRY_LIMIT);
 185
 186                 if (err) {
 187                         brcmf_dbg(ERROR, "failed at addr:0x%0x\n",
 188                                   SBSDIO_FUNC1_SBADDRLOW + i);
 189                         break;
 190                 }
 191         }
 192
 193         return err;
 194 }
 195
 196 int
 197 brcmf_sdio_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr,
 198                         void *data, bool write)
 199 {
 200         u8 func_num, reg_size;
 201         u32 bar;
 202         s32 retry = 0;
 203         int ret;
 204
 205         /*
 206          * figure out how to read the register based on address range
 207          * 0x00 ~ 0x7FF: function 0 CCCR and FBR
 208          * 0x10000 ~ 0x1FFFF: function 1 miscellaneous registers
 209          * The rest: function 1 silicon backplane core registers
 210          */
 211         if ((addr & ~REG_F0_REG_MASK) == 0) {
 212                 func_num = SDIO_FUNC_0;
 213                 reg_size = 1;
 214         } else if ((addr & ~REG_F1_MISC_MASK) == 0) {
 215                 func_num = SDIO_FUNC_1;
 216                 reg_size = 1;
 217         } else {
 218                 func_num = SDIO_FUNC_1;
 219                 reg_size = 4;
 220
 221                 /* Set the window for SB core register */
 222                 bar = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
 223                 if (bar != sdiodev->sbwad) {
 224                         ret = brcmf_sdcard_set_sbaddr_window(sdiodev, bar);
 225                         if (ret != 0) {
 226                                 memset(data, 0xFF, reg_size);
 227                                 return ret;
 228                         }
 229                         sdiodev->sbwad = bar;
 230                 }
 231                 addr &= SBSDIO_SB_OFT_ADDR_MASK;
 232                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 233         }
 234
 235         do {
 236                 if (!write)
 237                         memset(data, 0, reg_size);
 238                 if (retry)      /* wait for 1 ms till bus get settled down */
 239                         usleep_range(1000, 2000);
 240                 if (reg_size == 1)
 241                         ret = brcmf_sdioh_request_byte(sdiodev, write,
 242                                                        func_num, addr, data);
 243                 else
 244                         ret = brcmf_sdioh_request_word(sdiodev, write,
 245                                                        func_num, addr, data, 4);
 246         } while (ret != 0 && retry++ < SDIOH_API_ACCESS_RETRY_LIMIT);
 247
 248         if (ret != 0)
 249                 brcmf_dbg(ERROR, "failed with %d\n", ret);
 250
 251         return ret;
 252 }
 253
 254 u8 brcmf_sdio_regrb(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
 255 {
 256         u8 data;
 257         int retval;
 258
 259         brcmf_dbg(INFO, "addr:0x%08x\n", addr);
 260         retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, false);
 261         brcmf_dbg(INFO, "data:0x%02x\n", data);
 262
 263         if (ret)
 264                 *ret = retval;
 265
 266         return data;
 267 }
 268
 269 u32 brcmf_sdio_regrl(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
 270 {
 271         u32 data;
 272         int retval;
 273
 274         brcmf_dbg(INFO, "addr:0x%08x\n", addr);
 275         retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, false);
 276         brcmf_dbg(INFO, "data:0x%08x\n", data);
 277
 278         if (ret)
 279                 *ret = retval;
 280
 281         return data;
 282 }
 283
 284 void brcmf_sdio_regwb(struct brcmf_sdio_dev *sdiodev, u32 addr,
 285                       u8 data, int *ret)
 286 {
 287         int retval;
 288
 289         brcmf_dbg(INFO, "addr:0x%08x, data:0x%02x\n", addr, data);
 290         retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, true);
 291
 292         if (ret)
 293                 *ret = retval;
 294 }
 295
 296 void brcmf_sdio_regwl(struct brcmf_sdio_dev *sdiodev, u32 addr,
 297                       u32 data, int *ret)
 298 {
 299         int retval;
 300
 301         brcmf_dbg(INFO, "addr:0x%08x, data:0x%08x\n", addr, data);
 302         retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, true);
 303
 304         if (ret)
 305                 *ret = retval;
 306 }
 307
 308 static int brcmf_sdcard_recv_prepare(struct brcmf_sdio_dev *sdiodev, uint fn,
 309                                      uint flags, uint width, u32 *addr)
 310 {
 311         uint bar0 = *addr & ~SBSDIO_SB_OFT_ADDR_MASK;
 312         int err = 0;
 313
 314         /* Async not implemented yet */
 315         if (flags & SDIO_REQ_ASYNC)
 316                 return -ENOTSUPP;
 317
 318         if (bar0 != sdiodev->sbwad) {
 319                 err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0);
 320                 if (err)
 321                         return err;
 322
 323                 sdiodev->sbwad = bar0;
 324         }
 325
 326         *addr &= SBSDIO_SB_OFT_ADDR_MASK;
 327
 328         if (width == 4)
 329                 *addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 330
 331         return 0;
 332 }
 333
 334 int
 335 brcmf_sdcard_recv_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
 336                       uint flags, u8 *buf, uint nbytes)
 337 {
 338         struct sk_buff *mypkt;
 339         int err;
 340
 341         mypkt = brcmu_pkt_buf_get_skb(nbytes);
 342         if (!mypkt) {
 343                 brcmf_dbg(ERROR, "brcmu_pkt_buf_get_skb failed: len %d\n",
 344                           nbytes);
 345                 return -EIO;
 346         }
 347
 348         err = brcmf_sdcard_recv_pkt(sdiodev, addr, fn, flags, mypkt);
 349         if (!err)
 350                 memcpy(buf, mypkt->data, nbytes);
 351
 352         brcmu_pkt_buf_free_skb(mypkt);
 353         return err;
 354 }
 355
 356 int
 357 brcmf_sdcard_recv_pkt(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
 358                       uint flags, struct sk_buff *pkt)
 359 {
 360         uint incr_fix;
 361         uint width;
 362         int err = 0;
 363
 364         brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n",
 365                   fn, addr, pkt->len);
 366
 367         width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
 368         err = brcmf_sdcard_recv_prepare(sdiodev, fn, flags, width, &addr);
 369         if (err)
 370                 goto done;
 371
 372         incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
 373         err = brcmf_sdioh_request_buffer(sdiodev, incr_fix, SDIOH_READ,
 374                                          fn, addr, pkt);
 375
 376 done:
 377         return err;
 378 }
 379
 380 int brcmf_sdcard_recv_chain(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
 381                             uint flags, struct sk_buff_head *pktq)
 382 {
 383         uint incr_fix;
 384         uint width;
 385         int err = 0;
 386
 387         brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n",
 388                   fn, addr, pktq->qlen);
 389
 390         width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
 391         err = brcmf_sdcard_recv_prepare(sdiodev, fn, flags, width, &addr);
 392         if (err)
 393                 goto done;
 394
 395         incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
 396         err = brcmf_sdioh_request_chain(sdiodev, incr_fix, SDIOH_READ, fn, addr,
 397                                         pktq);
 398
 399 done:
 400         return err;
 401 }
 402
 403 int
 404 brcmf_sdcard_send_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
 405                       uint flags, u8 *buf, uint nbytes)
 406 {
 407         struct sk_buff *mypkt;
 408         int err;
 409
 410         mypkt = brcmu_pkt_buf_get_skb(nbytes);
 411         if (!mypkt) {
 412                 brcmf_dbg(ERROR, "brcmu_pkt_buf_get_skb failed: len %d\n",
 413                           nbytes);
 414                 return -EIO;
 415         }
 416
 417         memcpy(mypkt->data, buf, nbytes);
 418         err = brcmf_sdcard_send_pkt(sdiodev, addr, fn, flags, mypkt);
 419
 420         brcmu_pkt_buf_free_skb(mypkt);
 421         return err;
 422
 423 }
 424
 425 int
 426 brcmf_sdcard_send_pkt(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
 427                       uint flags, struct sk_buff *pkt)
 428 {
 429         uint incr_fix;
 430         uint width;
 431         uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
 432         int err = 0;
 433
 434         brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n",
 435                   fn, addr, pkt->len);
 436
 437         /* Async not implemented yet */
 438         if (flags & SDIO_REQ_ASYNC)
 439                 return -ENOTSUPP;
 440
 441         if (bar0 != sdiodev->sbwad) {
 442                 err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0);
 443                 if (err)
 444                         goto done;
 445
 446                 sdiodev->sbwad = bar0;
 447         }
 448
 449         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 450
 451         incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
 452         width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
 453         if (width == 4)
 454                 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 455
 456         err = brcmf_sdioh_request_buffer(sdiodev, incr_fix, SDIOH_WRITE, fn,
 457                                          addr, pkt);
 458
 459 done:
 460         return err;
 461 }
 462
 463 int brcmf_sdcard_rwdata(struct brcmf_sdio_dev *sdiodev, uint rw, u32 addr,
 464                         u8 *buf, uint nbytes)
 465 {
 466         struct sk_buff *mypkt;
 467         bool write = rw ? SDIOH_WRITE : SDIOH_READ;
 468         int err;
 469
 470         addr &= SBSDIO_SB_OFT_ADDR_MASK;
 471         addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 472
 473         mypkt = brcmu_pkt_buf_get_skb(nbytes);
 474         if (!mypkt) {
 475                 brcmf_dbg(ERROR, "brcmu_pkt_buf_get_skb failed: len %d\n",
 476                           nbytes);
 477                 return -EIO;
 478         }
 479
 480         /* For a write, copy the buffer data into the packet. */
 481         if (write)
 482                 memcpy(mypkt->data, buf, nbytes);
 483
 484         err = brcmf_sdioh_request_buffer(sdiodev, SDIOH_DATA_INC, write,
 485                                          SDIO_FUNC_1, addr, mypkt);
 486
 487         /* For a read, copy the packet data back to the buffer. */
 488         if (!err && !write)
 489                 memcpy(buf, mypkt->data, nbytes);
 490
 491         brcmu_pkt_buf_free_skb(mypkt);
 492         return err;
 493 }
 494
 495 int brcmf_sdcard_abort(struct brcmf_sdio_dev *sdiodev, uint fn)
 496 {
 497         char t_func = (char)fn;
 498         brcmf_dbg(TRACE, "Enter\n");
 499
 500         /* issue abort cmd52 command through F0 */
 501         brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE, SDIO_FUNC_0,
 502                                  SDIO_CCCR_ABORT, &t_func);
 503
 504         brcmf_dbg(TRACE, "Exit\n");
 505         return 0;
 506 }
 507
 508 int brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev)
 509 {
 510         u32 regs = 0;
 511         int ret = 0;
 512
 513         ret = brcmf_sdioh_attach(sdiodev);
 514         if (ret)
 515                 goto out;
 516
 517         regs = SI_ENUM_BASE;
 518
 519         /* Report the BAR, to fix if needed */
 520         sdiodev->sbwad = SI_ENUM_BASE;
 521
 522         /* try to attach to the target device */
 523         sdiodev->bus = brcmf_sdbrcm_probe(regs, sdiodev);
 524         if (!sdiodev->bus) {
 525                 brcmf_dbg(ERROR, "device attach failed\n");
 526                 ret = -ENODEV;
 527                 goto out;
 528         }
 529
 530 out:
 531         if (ret)
 532                 brcmf_sdio_remove(sdiodev);
 533
 534         return ret;
 535 }
 536 EXPORT_SYMBOL(brcmf_sdio_probe);
 537
 538 int brcmf_sdio_remove(struct brcmf_sdio_dev *sdiodev)
 539 {
 540         sdiodev->bus_if->state = BRCMF_BUS_DOWN;
 541
 542         if (sdiodev->bus) {
 543                 brcmf_sdbrcm_disconnect(sdiodev->bus);
 544                 sdiodev->bus = NULL;
 545         }
 546
 547         brcmf_sdioh_detach(sdiodev);
 548
 549         sdiodev->sbwad = 0;
 550
 551         return 0;
 552 }
 553 EXPORT_SYMBOL(brcmf_sdio_remove);
 554
 555 void brcmf_sdio_wdtmr_enable(struct brcmf_sdio_dev *sdiodev, bool enable)
 556 {
 557         if (enable)
 558                 brcmf_sdbrcm_wd_timer(sdiodev->bus, BRCMF_WD_POLL_MS);
 559         else
 560                 brcmf_sdbrcm_wd_timer(sdiodev->bus, 0);
 561 }