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