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