drivers/net/wireless/broadcom/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/interrupt.h>
  25 #include <linux/scatterlist.h>
  26 #include <linux/mmc/sdio.h>
  27 #include <linux/mmc/core.h>
  28 #include <linux/mmc/sdio_func.h>
  29 #include <linux/mmc/card.h>
  30 #include <linux/mmc/host.h>
  31 #include <linux/pm_runtime.h>
  32 #include <linux/suspend.h>
  33 #include <linux/errno.h>
  34 #include <linux/module.h>
  35 #include <linux/acpi.h>
  36 #include <net/cfg80211.h>
  37
  38 #include <defs.h>
  39 #include <brcm_hw_ids.h>
  40 #include <brcmu_utils.h>
  41 #include <brcmu_wifi.h>
  42 #include <chipcommon.h>
  43 #include <soc.h>
  44 #include "chip.h"
  45 #include "bus.h"
  46 #include "debug.h"
  47 #include "sdio.h"
  48 #include "core.h"
  49 #include "common.h"
  50
  51 #define SDIOH_API_ACCESS_RETRY_LIMIT    2
  52
  53 #define DMA_ALIGN_MASK  0x03
  54
  55 #define SDIO_FUNC1_BLOCKSIZE            64
  56 #define SDIO_FUNC2_BLOCKSIZE            512
  57 /* Maximum milliseconds to wait for F2 to come up */
  58 #define SDIO_WAIT_F2RDY 3000
  59
  60 #define BRCMF_DEFAULT_RXGLOM_SIZE       32  /* max rx frames in glom chain */
  61
  62 struct brcmf_sdiod_freezer {
  63         atomic_t freezing;
  64         atomic_t thread_count;
  65         u32 frozen_count;
  66         wait_queue_head_t thread_freeze;
  67         struct completion resumed;
  68 };
  69
  70 static irqreturn_t brcmf_sdiod_oob_irqhandler(int irq, void *dev_id)
  71 {
  72         struct brcmf_bus *bus_if = dev_get_drvdata(dev_id);
  73         struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
  74
  75         brcmf_dbg(INTR, "OOB intr triggered\n");
  76
  77         /* out-of-band interrupt is level-triggered which won't
  78          * be cleared until dpc
  79          */
  80         if (sdiodev->irq_en) {
  81                 disable_irq_nosync(irq);
  82                 sdiodev->irq_en = false;
  83         }
  84
  85         brcmf_sdio_isr(sdiodev->bus);
  86
  87         return IRQ_HANDLED;
  88 }
  89
  90 static void brcmf_sdiod_ib_irqhandler(struct sdio_func *func)
  91 {
  92         struct brcmf_bus *bus_if = dev_get_drvdata(&func->dev);
  93         struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
  94
  95         brcmf_dbg(INTR, "IB intr triggered\n");
  96
  97         brcmf_sdio_isr(sdiodev->bus);
  98 }
  99
 100 /* dummy handler for SDIO function 2 interrupt */
 101 static void brcmf_sdiod_dummy_irqhandler(struct sdio_func *func)
 102 {
 103 }
 104
 105 int brcmf_sdiod_intr_register(struct brcmf_sdio_dev *sdiodev)
 106 {
 107         struct brcmfmac_sdio_pd *pdata;
 108         int ret = 0;
 109         u8 data;
 110         u32 addr, gpiocontrol;
 111         unsigned long flags;
 112
 113         pdata = &sdiodev->settings->bus.sdio;
 114         if (pdata->oob_irq_supported) {
 115                 brcmf_dbg(SDIO, "Enter, register OOB IRQ %d\n",
 116                           pdata->oob_irq_nr);
 117                 ret = request_irq(pdata->oob_irq_nr, brcmf_sdiod_oob_irqhandler,
 118                                   pdata->oob_irq_flags, "brcmf_oob_intr",
 119                                   &sdiodev->func[1]->dev);
 120                 if (ret != 0) {
 121                         brcmf_err("request_irq failed %d\n", ret);
 122                         return ret;
 123                 }
 124                 sdiodev->oob_irq_requested = true;
 125                 spin_lock_init(&sdiodev->irq_en_lock);
 126                 spin_lock_irqsave(&sdiodev->irq_en_lock, flags);
 127                 sdiodev->irq_en = true;
 128                 spin_unlock_irqrestore(&sdiodev->irq_en_lock, flags);
 129
 130                 ret = enable_irq_wake(pdata->oob_irq_nr);
 131                 if (ret != 0) {
 132                         brcmf_err("enable_irq_wake failed %d\n", ret);
 133                         return ret;
 134                 }
 135                 sdiodev->irq_wake = true;
 136
 137                 sdio_claim_host(sdiodev->func[1]);
 138
 139                 if (sdiodev->bus_if->chip == BRCM_CC_43362_CHIP_ID) {
 140                         /* assign GPIO to SDIO core */
 141                         addr = CORE_CC_REG(SI_ENUM_BASE, gpiocontrol);
 142                         gpiocontrol = brcmf_sdiod_regrl(sdiodev, addr, &ret);
 143                         gpiocontrol |= 0x2;
 144                         brcmf_sdiod_regwl(sdiodev, addr, gpiocontrol, &ret);
 145
 146                         brcmf_sdiod_regwb(sdiodev, SBSDIO_GPIO_SELECT, 0xf,
 147                                           &ret);
 148                         brcmf_sdiod_regwb(sdiodev, SBSDIO_GPIO_OUT, 0, &ret);
 149                         brcmf_sdiod_regwb(sdiodev, SBSDIO_GPIO_EN, 0x2, &ret);
 150                 }
 151
 152                 /* must configure SDIO_CCCR_IENx to enable irq */
 153                 data = brcmf_sdiod_regrb(sdiodev, SDIO_CCCR_IENx, &ret);
 154                 data |= 1 << SDIO_FUNC_1 | 1 << SDIO_FUNC_2 | 1;
 155                 brcmf_sdiod_regwb(sdiodev, SDIO_CCCR_IENx, data, &ret);
 156
 157                 /* redirect, configure and enable io for interrupt signal */
 158                 data = SDIO_SEPINT_MASK | SDIO_SEPINT_OE;
 159                 if (pdata->oob_irq_flags & IRQF_TRIGGER_HIGH)
 160                         data |= SDIO_SEPINT_ACT_HI;
 161                 brcmf_sdiod_regwb(sdiodev, SDIO_CCCR_BRCM_SEPINT, data, &ret);
 162
 163                 sdio_release_host(sdiodev->func[1]);
 164         } else {
 165                 brcmf_dbg(SDIO, "Entering\n");
 166                 sdio_claim_host(sdiodev->func[1]);
 167                 sdio_claim_irq(sdiodev->func[1], brcmf_sdiod_ib_irqhandler);
 168                 sdio_claim_irq(sdiodev->func[2], brcmf_sdiod_dummy_irqhandler);
 169                 sdio_release_host(sdiodev->func[1]);
 170                 sdiodev->sd_irq_requested = true;
 171         }
 172
 173         return 0;
 174 }
 175
 176 void brcmf_sdiod_intr_unregister(struct brcmf_sdio_dev *sdiodev)
 177 {
 178
 179         brcmf_dbg(SDIO, "Entering oob=%d sd=%d\n",
 180                   sdiodev->oob_irq_requested,
 181                   sdiodev->sd_irq_requested);
 182
 183         if (sdiodev->oob_irq_requested) {
 184                 struct brcmfmac_sdio_pd *pdata;
 185
 186                 pdata = &sdiodev->settings->bus.sdio;
 187                 sdio_claim_host(sdiodev->func[1]);
 188                 brcmf_sdiod_regwb(sdiodev, SDIO_CCCR_BRCM_SEPINT, 0, NULL);
 189                 brcmf_sdiod_regwb(sdiodev, SDIO_CCCR_IENx, 0, NULL);
 190                 sdio_release_host(sdiodev->func[1]);
 191
 192                 sdiodev->oob_irq_requested = false;
 193                 if (sdiodev->irq_wake) {
 194                         disable_irq_wake(pdata->oob_irq_nr);
 195                         sdiodev->irq_wake = false;
 196                 }
 197                 free_irq(pdata->oob_irq_nr, &sdiodev->func[1]->dev);
 198                 sdiodev->irq_en = false;
 199                 sdiodev->oob_irq_requested = false;
 200         }
 201
 202         if (sdiodev->sd_irq_requested) {
 203                 sdio_claim_host(sdiodev->func[1]);
 204                 sdio_release_irq(sdiodev->func[2]);
 205                 sdio_release_irq(sdiodev->func[1]);
 206                 sdio_release_host(sdiodev->func[1]);
 207                 sdiodev->sd_irq_requested = false;
 208         }
 209 }
 210
 211 void brcmf_sdiod_change_state(struct brcmf_sdio_dev *sdiodev,
 212                               enum brcmf_sdiod_state state)
 213 {
 214         if (sdiodev->state == BRCMF_SDIOD_NOMEDIUM ||
 215             state == sdiodev->state)
 216                 return;
 217
 218         brcmf_dbg(TRACE, "%d -> %d\n", sdiodev->state, state);
 219         switch (sdiodev->state) {
 220         case BRCMF_SDIOD_DATA:
 221                 /* any other state means bus interface is down */
 222                 brcmf_bus_change_state(sdiodev->bus_if, BRCMF_BUS_DOWN);
 223                 break;
 224         case BRCMF_SDIOD_DOWN:
 225                 /* transition from DOWN to DATA means bus interface is up */
 226                 if (state == BRCMF_SDIOD_DATA)
 227                         brcmf_bus_change_state(sdiodev->bus_if, BRCMF_BUS_UP);
 228                 break;
 229         default:
 230                 break;
 231         }
 232         sdiodev->state = state;
 233 }
 234
 235 static inline int brcmf_sdiod_f0_writeb(struct sdio_func *func,
 236                                         uint regaddr, u8 byte)
 237 {
 238         int err_ret;
 239
 240         /*
 241          * Can only directly write to some F0 registers.
 242          * Handle CCCR_IENx and CCCR_ABORT command
 243          * as a special case.
 244          */
 245         if ((regaddr == SDIO_CCCR_ABORT) ||
 246             (regaddr == SDIO_CCCR_IENx))
 247                 sdio_writeb(func, byte, regaddr, &err_ret);
 248         else
 249                 sdio_f0_writeb(func, byte, regaddr, &err_ret);
 250
 251         return err_ret;
 252 }
 253
 254 static int brcmf_sdiod_request_data(struct brcmf_sdio_dev *sdiodev, u8 fn,
 255                                     u32 addr, u8 regsz, void *data, bool write)
 256 {
 257         struct sdio_func *func;
 258         int ret = -EINVAL;
 259
 260         brcmf_dbg(SDIO, "rw=%d, func=%d, addr=0x%05x, nbytes=%d\n",
 261                   write, fn, addr, regsz);
 262
 263         /* only allow byte access on F0 */
 264         if (WARN_ON(regsz > 1 && !fn))
 265                 return -EINVAL;
 266         func = sdiodev->func[fn];
 267
 268         switch (regsz) {
 269         case sizeof(u8):
 270                 if (write) {
 271                         if (fn)
 272                                 sdio_writeb(func, *(u8 *)data, addr, &ret);
 273                         else
 274                                 ret = brcmf_sdiod_f0_writeb(func, addr,
 275                                                             *(u8 *)data);
 276                 } else {
 277                         if (fn)
 278                                 *(u8 *)data = sdio_readb(func, addr, &ret);
 279                         else
 280                                 *(u8 *)data = sdio_f0_readb(func, addr, &ret);
 281                 }
 282                 break;
 283         case sizeof(u16):
 284                 if (write)
 285                         sdio_writew(func, *(u16 *)data, addr, &ret);
 286                 else
 287                         *(u16 *)data = sdio_readw(func, addr, &ret);
 288                 break;
 289         case sizeof(u32):
 290                 if (write)
 291                         sdio_writel(func, *(u32 *)data, addr, &ret);
 292                 else
 293                         *(u32 *)data = sdio_readl(func, addr, &ret);
 294                 break;
 295         default:
 296                 brcmf_err("invalid size: %d\n", regsz);
 297                 break;
 298         }
 299
 300         if (ret)
 301                 brcmf_dbg(SDIO, "failed to %s data F%d@0x%05x, err: %d\n",
 302                           write ? "write" : "read", fn, addr, ret);
 303
 304         return ret;
 305 }
 306
 307 static int brcmf_sdiod_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr,
 308                                    u8 regsz, void *data, bool write)
 309 {
 310         u8 func;
 311         s32 retry = 0;
 312         int ret;
 313
 314         if (sdiodev->state == BRCMF_SDIOD_NOMEDIUM)
 315                 return -ENOMEDIUM;
 316
 317         /*
 318          * figure out how to read the register based on address range
 319          * 0x00 ~ 0x7FF: function 0 CCCR and FBR
 320          * 0x10000 ~ 0x1FFFF: function 1 miscellaneous registers
 321          * The rest: function 1 silicon backplane core registers
 322          */
 323         if ((addr & ~REG_F0_REG_MASK) == 0)
 324                 func = SDIO_FUNC_0;
 325         else
 326                 func = SDIO_FUNC_1;
 327
 328         do {
 329                 if (!write)
 330                         memset(data, 0, regsz);
 331                 /* for retry wait for 1 ms till bus get settled down */
 332                 if (retry)
 333                         usleep_range(1000, 2000);
 334                 ret = brcmf_sdiod_request_data(sdiodev, func, addr, regsz,
 335                                                data, write);
 336         } while (ret != 0 && ret != -ENOMEDIUM &&
 337                  retry++ < SDIOH_API_ACCESS_RETRY_LIMIT);
 338
 339         if (ret == -ENOMEDIUM)
 340                 brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_NOMEDIUM);
 341         else if (ret != 0) {
 342                 /*
 343                  * SleepCSR register access can fail when
 344                  * waking up the device so reduce this noise
 345                  * in the logs.
 346                  */
 347                 if (addr != SBSDIO_FUNC1_SLEEPCSR)
 348                         brcmf_err("failed to %s data F%d@0x%05x, err: %d\n",
 349                                   write ? "write" : "read", func, addr, ret);
 350                 else
 351                         brcmf_dbg(SDIO, "failed to %s data F%d@0x%05x, err: %d\n",
 352                                   write ? "write" : "read", func, addr, ret);
 353         }
 354         return ret;
 355 }
 356
 357 static int
 358 brcmf_sdiod_set_sbaddr_window(struct brcmf_sdio_dev *sdiodev, u32 address)
 359 {
 360         int err = 0, i;
 361         u8 addr[3];
 362
 363         if (sdiodev->state == BRCMF_SDIOD_NOMEDIUM)
 364                 return -ENOMEDIUM;
 365
 366         addr[0] = (address >> 8) & SBSDIO_SBADDRLOW_MASK;
 367         addr[1] = (address >> 16) & SBSDIO_SBADDRMID_MASK;
 368         addr[2] = (address >> 24) & SBSDIO_SBADDRHIGH_MASK;
 369
 370         for (i = 0; i < 3; i++) {
 371                 err = brcmf_sdiod_regrw_helper(sdiodev,
 372                                                SBSDIO_FUNC1_SBADDRLOW + i,
 373                                                sizeof(u8), &addr[i], true);
 374                 if (err) {
 375                         brcmf_err("failed at addr: 0x%0x\n",
 376                                   SBSDIO_FUNC1_SBADDRLOW + i);
 377                         break;
 378                 }
 379         }
 380
 381         return err;
 382 }
 383
 384 static int
 385 brcmf_sdiod_addrprep(struct brcmf_sdio_dev *sdiodev, uint width, u32 *addr)
 386 {
 387         uint bar0 = *addr & ~SBSDIO_SB_OFT_ADDR_MASK;
 388         int err = 0;
 389
 390         if (bar0 != sdiodev->sbwad) {
 391                 err = brcmf_sdiod_set_sbaddr_window(sdiodev, bar0);
 392                 if (err)
 393                         return err;
 394
 395                 sdiodev->sbwad = bar0;
 396         }
 397
 398         *addr &= SBSDIO_SB_OFT_ADDR_MASK;
 399
 400         if (width == 4)
 401                 *addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 402
 403         return 0;
 404 }
 405
 406 u8 brcmf_sdiod_regrb(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
 407 {
 408         u8 data;
 409         int retval;
 410
 411         brcmf_dbg(SDIO, "addr:0x%08x\n", addr);
 412         retval = brcmf_sdiod_regrw_helper(sdiodev, addr, sizeof(data), &data,
 413                                           false);
 414         brcmf_dbg(SDIO, "data:0x%02x\n", data);
 415
 416         if (ret)
 417                 *ret = retval;
 418
 419         return data;
 420 }
 421
 422 u32 brcmf_sdiod_regrl(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
 423 {
 424         u32 data = 0;
 425         int retval;
 426
 427         brcmf_dbg(SDIO, "addr:0x%08x\n", addr);
 428         retval = brcmf_sdiod_addrprep(sdiodev, sizeof(data), &addr);
 429         if (retval)
 430                 goto done;
 431         retval = brcmf_sdiod_regrw_helper(sdiodev, addr, sizeof(data), &data,
 432                                           false);
 433         brcmf_dbg(SDIO, "data:0x%08x\n", data);
 434
 435 done:
 436         if (ret)
 437                 *ret = retval;
 438
 439         return data;
 440 }
 441
 442 void brcmf_sdiod_regwb(struct brcmf_sdio_dev *sdiodev, u32 addr,
 443                       u8 data, int *ret)
 444 {
 445         int retval;
 446
 447         brcmf_dbg(SDIO, "addr:0x%08x, data:0x%02x\n", addr, data);
 448         retval = brcmf_sdiod_regrw_helper(sdiodev, addr, sizeof(data), &data,
 449                                           true);
 450         if (ret)
 451                 *ret = retval;
 452 }
 453
 454 void brcmf_sdiod_regwl(struct brcmf_sdio_dev *sdiodev, u32 addr,
 455                       u32 data, int *ret)
 456 {
 457         int retval;
 458
 459         brcmf_dbg(SDIO, "addr:0x%08x, data:0x%08x\n", addr, data);
 460         retval = brcmf_sdiod_addrprep(sdiodev, sizeof(data), &addr);
 461         if (retval)
 462                 goto done;
 463         retval = brcmf_sdiod_regrw_helper(sdiodev, addr, sizeof(data), &data,
 464                                           true);
 465
 466 done:
 467         if (ret)
 468                 *ret = retval;
 469 }
 470
 471 static int brcmf_sdiod_buffrw(struct brcmf_sdio_dev *sdiodev, uint fn,
 472                              bool write, u32 addr, struct sk_buff *pkt)
 473 {
 474         unsigned int req_sz;
 475         int err;
 476
 477         /* Single skb use the standard mmc interface */
 478         req_sz = pkt->len + 3;
 479         req_sz &= (uint)~3;
 480
 481         if (write)
 482                 err = sdio_memcpy_toio(sdiodev->func[fn], addr,
 483                                        ((u8 *)(pkt->data)), req_sz);
 484         else if (fn == 1)
 485                 err = sdio_memcpy_fromio(sdiodev->func[fn], ((u8 *)(pkt->data)),
 486                                          addr, req_sz);
 487         else
 488                 /* function 2 read is FIFO operation */
 489                 err = sdio_readsb(sdiodev->func[fn], ((u8 *)(pkt->data)), addr,
 490                                   req_sz);
 491         if (err == -ENOMEDIUM)
 492                 brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_NOMEDIUM);
 493         return err;
 494 }
 495
 496 /**
 497  * brcmf_sdiod_sglist_rw - SDIO interface function for block data access
 498  * @sdiodev: brcmfmac sdio device
 499  * @fn: SDIO function number
 500  * @write: direction flag
 501  * @addr: dongle memory address as source/destination
 502  * @pkt: skb pointer
 503  *
 504  * This function takes the respbonsibility as the interface function to MMC
 505  * stack for block data access. It assumes that the skb passed down by the
 506  * caller has already been padded and aligned.
 507  */
 508 static int brcmf_sdiod_sglist_rw(struct brcmf_sdio_dev *sdiodev, uint fn,
 509                                  bool write, u32 addr,
 510                                  struct sk_buff_head *pktlist)
 511 {
 512         unsigned int req_sz, func_blk_sz, sg_cnt, sg_data_sz, pkt_offset;
 513         unsigned int max_req_sz, orig_offset, dst_offset;
 514         unsigned short max_seg_cnt, seg_sz;
 515         unsigned char *pkt_data, *orig_data, *dst_data;
 516         struct sk_buff *pkt_next = NULL, *local_pkt_next;
 517         struct sk_buff_head local_list, *target_list;
 518         struct mmc_request mmc_req;
 519         struct mmc_command mmc_cmd;
 520         struct mmc_data mmc_dat;
 521         struct scatterlist *sgl;
 522         int ret = 0;
 523
 524         if (!pktlist->qlen)
 525                 return -EINVAL;
 526
 527         target_list = pktlist;
 528         /* for host with broken sg support, prepare a page aligned list */
 529         __skb_queue_head_init(&local_list);
 530         if (!write && sdiodev->settings->bus.sdio.broken_sg_support) {
 531                 req_sz = 0;
 532                 skb_queue_walk(pktlist, pkt_next)
 533                         req_sz += pkt_next->len;
 534                 req_sz = ALIGN(req_sz, sdiodev->func[fn]->cur_blksize);
 535                 while (req_sz > PAGE_SIZE) {
 536                         pkt_next = brcmu_pkt_buf_get_skb(PAGE_SIZE);
 537                         if (pkt_next == NULL) {
 538                                 ret = -ENOMEM;
 539                                 goto exit;
 540                         }
 541                         __skb_queue_tail(&local_list, pkt_next);
 542                         req_sz -= PAGE_SIZE;
 543                 }
 544                 pkt_next = brcmu_pkt_buf_get_skb(req_sz);
 545                 if (pkt_next == NULL) {
 546                         ret = -ENOMEM;
 547                         goto exit;
 548                 }
 549                 __skb_queue_tail(&local_list, pkt_next);
 550                 target_list = &local_list;
 551         }
 552
 553         func_blk_sz = sdiodev->func[fn]->cur_blksize;
 554         max_req_sz = sdiodev->max_request_size;
 555         max_seg_cnt = min_t(unsigned short, sdiodev->max_segment_count,
 556                             target_list->qlen);
 557         seg_sz = target_list->qlen;
 558         pkt_offset = 0;
 559         pkt_next = target_list->next;
 560
 561         memset(&mmc_req, 0, sizeof(struct mmc_request));
 562         memset(&mmc_cmd, 0, sizeof(struct mmc_command));
 563         memset(&mmc_dat, 0, sizeof(struct mmc_data));
 564
 565         mmc_dat.sg = sdiodev->sgtable.sgl;
 566         mmc_dat.blksz = func_blk_sz;
 567         mmc_dat.flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
 568         mmc_cmd.opcode = SD_IO_RW_EXTENDED;
 569         mmc_cmd.arg = write ? 1<<31 : 0;        /* write flag  */
 570         mmc_cmd.arg |= (fn & 0x7) << 28;        /* SDIO func num */
 571         mmc_cmd.arg |= 1<<27;                   /* block mode */
 572         /* for function 1 the addr will be incremented */
 573         mmc_cmd.arg |= (fn == 1) ? 1<<26 : 0;
 574         mmc_cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_ADTC;
 575         mmc_req.cmd = &mmc_cmd;
 576         mmc_req.data = &mmc_dat;
 577
 578         while (seg_sz) {
 579                 req_sz = 0;
 580                 sg_cnt = 0;
 581                 sgl = sdiodev->sgtable.sgl;
 582                 /* prep sg table */
 583                 while (pkt_next != (struct sk_buff *)target_list) {
 584                         pkt_data = pkt_next->data + pkt_offset;
 585                         sg_data_sz = pkt_next->len - pkt_offset;
 586                         if (sg_data_sz > sdiodev->max_segment_size)
 587                                 sg_data_sz = sdiodev->max_segment_size;
 588                         if (sg_data_sz > max_req_sz - req_sz)
 589                                 sg_data_sz = max_req_sz - req_sz;
 590
 591                         sg_set_buf(sgl, pkt_data, sg_data_sz);
 592
 593                         sg_cnt++;
 594                         sgl = sg_next(sgl);
 595                         req_sz += sg_data_sz;
 596                         pkt_offset += sg_data_sz;
 597                         if (pkt_offset == pkt_next->len) {
 598                                 pkt_offset = 0;
 599                                 pkt_next = pkt_next->next;
 600                         }
 601
 602                         if (req_sz >= max_req_sz || sg_cnt >= max_seg_cnt)
 603                                 break;
 604                 }
 605                 seg_sz -= sg_cnt;
 606
 607                 if (req_sz % func_blk_sz != 0) {
 608                         brcmf_err("sg request length %u is not %u aligned\n",
 609                                   req_sz, func_blk_sz);
 610                         ret = -ENOTBLK;
 611                         goto exit;
 612                 }
 613
 614                 mmc_dat.sg_len = sg_cnt;
 615                 mmc_dat.blocks = req_sz / func_blk_sz;
 616                 mmc_cmd.arg |= (addr & 0x1FFFF) << 9;   /* address */
 617                 mmc_cmd.arg |= mmc_dat.blocks & 0x1FF;  /* block count */
 618                 /* incrementing addr for function 1 */
 619                 if (fn == 1)
 620                         addr += req_sz;
 621
 622                 mmc_set_data_timeout(&mmc_dat, sdiodev->func[fn]->card);
 623                 mmc_wait_for_req(sdiodev->func[fn]->card->host, &mmc_req);
 624
 625                 ret = mmc_cmd.error ? mmc_cmd.error : mmc_dat.error;
 626                 if (ret == -ENOMEDIUM) {
 627                         brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_NOMEDIUM);
 628                         break;
 629                 } else if (ret != 0) {
 630                         brcmf_err("CMD53 sg block %s failed %d\n",
 631                                   write ? "write" : "read", ret);
 632                         ret = -EIO;
 633                         break;
 634                 }
 635         }
 636
 637         if (!write && sdiodev->settings->bus.sdio.broken_sg_support) {
 638                 local_pkt_next = local_list.next;
 639                 orig_offset = 0;
 640                 skb_queue_walk(pktlist, pkt_next) {
 641                         dst_offset = 0;
 642                         do {
 643                                 req_sz = local_pkt_next->len - orig_offset;
 644                                 req_sz = min_t(uint, pkt_next->len - dst_offset,
 645                                                req_sz);
 646                                 orig_data = local_pkt_next->data + orig_offset;
 647                                 dst_data = pkt_next->data + dst_offset;
 648                                 memcpy(dst_data, orig_data, req_sz);
 649                                 orig_offset += req_sz;
 650                                 dst_offset += req_sz;
 651                                 if (orig_offset == local_pkt_next->len) {
 652                                         orig_offset = 0;
 653                                         local_pkt_next = local_pkt_next->next;
 654                                 }
 655                                 if (dst_offset == pkt_next->len)
 656                                         break;
 657                         } while (!skb_queue_empty(&local_list));
 658                 }
 659         }
 660
 661 exit:
 662         sg_init_table(sdiodev->sgtable.sgl, sdiodev->sgtable.orig_nents);
 663         while ((pkt_next = __skb_dequeue(&local_list)) != NULL)
 664                 brcmu_pkt_buf_free_skb(pkt_next);
 665
 666         return ret;
 667 }
 668
 669 int brcmf_sdiod_recv_buf(struct brcmf_sdio_dev *sdiodev, u8 *buf, uint nbytes)
 670 {
 671         struct sk_buff *mypkt;
 672         int err;
 673
 674         mypkt = brcmu_pkt_buf_get_skb(nbytes);
 675         if (!mypkt) {
 676                 brcmf_err("brcmu_pkt_buf_get_skb failed: len %d\n",
 677                           nbytes);
 678                 return -EIO;
 679         }
 680
 681         err = brcmf_sdiod_recv_pkt(sdiodev, mypkt);
 682         if (!err)
 683                 memcpy(buf, mypkt->data, nbytes);
 684
 685         brcmu_pkt_buf_free_skb(mypkt);
 686         return err;
 687 }
 688
 689 int brcmf_sdiod_recv_pkt(struct brcmf_sdio_dev *sdiodev, struct sk_buff *pkt)
 690 {
 691         u32 addr = sdiodev->sbwad;
 692         int err = 0;
 693
 694         brcmf_dbg(SDIO, "addr = 0x%x, size = %d\n", addr, pkt->len);
 695
 696         err = brcmf_sdiod_addrprep(sdiodev, 4, &addr);
 697         if (err)
 698                 goto done;
 699
 700         err = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_2, false, addr, pkt);
 701
 702 done:
 703         return err;
 704 }
 705
 706 int brcmf_sdiod_recv_chain(struct brcmf_sdio_dev *sdiodev,
 707                            struct sk_buff_head *pktq, uint totlen)
 708 {
 709         struct sk_buff *glom_skb;
 710         struct sk_buff *skb;
 711         u32 addr = sdiodev->sbwad;
 712         int err = 0;
 713
 714         brcmf_dbg(SDIO, "addr = 0x%x, size = %d\n",
 715                   addr, pktq->qlen);
 716
 717         err = brcmf_sdiod_addrprep(sdiodev, 4, &addr);
 718         if (err)
 719                 goto done;
 720
 721         if (pktq->qlen == 1)
 722                 err = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_2, false, addr,
 723                                          pktq->next);
 724         else if (!sdiodev->sg_support) {
 725                 glom_skb = brcmu_pkt_buf_get_skb(totlen);
 726                 if (!glom_skb)
 727                         return -ENOMEM;
 728                 err = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_2, false, addr,
 729                                          glom_skb);
 730                 if (err) {
 731                         brcmu_pkt_buf_free_skb(glom_skb);
 732                         goto done;
 733                 }
 734
 735                 skb_queue_walk(pktq, skb) {
 736                         memcpy(skb->data, glom_skb->data, skb->len);
 737                         skb_pull(glom_skb, skb->len);
 738                 }
 739         } else
 740                 err = brcmf_sdiod_sglist_rw(sdiodev, SDIO_FUNC_2, false, addr,
 741                                             pktq);
 742
 743 done:
 744         return err;
 745 }
 746
 747 int brcmf_sdiod_send_buf(struct brcmf_sdio_dev *sdiodev, u8 *buf, uint nbytes)
 748 {
 749         struct sk_buff *mypkt;
 750         u32 addr = sdiodev->sbwad;
 751         int err;
 752
 753         mypkt = brcmu_pkt_buf_get_skb(nbytes);
 754         if (!mypkt) {
 755                 brcmf_err("brcmu_pkt_buf_get_skb failed: len %d\n",
 756                           nbytes);
 757                 return -EIO;
 758         }
 759
 760         memcpy(mypkt->data, buf, nbytes);
 761
 762         err = brcmf_sdiod_addrprep(sdiodev, 4, &addr);
 763
 764         if (!err)
 765                 err = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_2, true, addr,
 766                                          mypkt);
 767
 768         brcmu_pkt_buf_free_skb(mypkt);
 769         return err;
 770
 771 }
 772
 773 int brcmf_sdiod_send_pkt(struct brcmf_sdio_dev *sdiodev,
 774                          struct sk_buff_head *pktq)
 775 {
 776         struct sk_buff *skb;
 777         u32 addr = sdiodev->sbwad;
 778         int err;
 779
 780         brcmf_dbg(SDIO, "addr = 0x%x, size = %d\n", addr, pktq->qlen);
 781
 782         err = brcmf_sdiod_addrprep(sdiodev, 4, &addr);
 783         if (err)
 784                 return err;
 785
 786         if (pktq->qlen == 1 || !sdiodev->sg_support)
 787                 skb_queue_walk(pktq, skb) {
 788                         err = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_2, true,
 789                                                  addr, skb);
 790                         if (err)
 791                                 break;
 792                 }
 793         else
 794                 err = brcmf_sdiod_sglist_rw(sdiodev, SDIO_FUNC_2, true, addr,
 795                                             pktq);
 796
 797         return err;
 798 }
 799
 800 int
 801 brcmf_sdiod_ramrw(struct brcmf_sdio_dev *sdiodev, bool write, u32 address,
 802                   u8 *data, uint size)
 803 {
 804         int bcmerror = 0;
 805         struct sk_buff *pkt;
 806         u32 sdaddr;
 807         uint dsize;
 808
 809         dsize = min_t(uint, SBSDIO_SB_OFT_ADDR_LIMIT, size);
 810         pkt = dev_alloc_skb(dsize);
 811         if (!pkt) {
 812                 brcmf_err("dev_alloc_skb failed: len %d\n", dsize);
 813                 return -EIO;
 814         }
 815         pkt->priority = 0;
 816
 817         /* Determine initial transfer parameters */
 818         sdaddr = address & SBSDIO_SB_OFT_ADDR_MASK;
 819         if ((sdaddr + size) & SBSDIO_SBWINDOW_MASK)
 820                 dsize = (SBSDIO_SB_OFT_ADDR_LIMIT - sdaddr);
 821         else
 822                 dsize = size;
 823
 824         sdio_claim_host(sdiodev->func[1]);
 825
 826         /* Do the transfer(s) */
 827         while (size) {
 828                 /* Set the backplane window to include the start address */
 829                 bcmerror = brcmf_sdiod_set_sbaddr_window(sdiodev, address);
 830                 if (bcmerror)
 831                         break;
 832
 833                 brcmf_dbg(SDIO, "%s %d bytes at offset 0x%08x in window 0x%08x\n",
 834                           write ? "write" : "read", dsize,
 835                           sdaddr, address & SBSDIO_SBWINDOW_MASK);
 836
 837                 sdaddr &= SBSDIO_SB_OFT_ADDR_MASK;
 838                 sdaddr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 839
 840                 skb_put(pkt, dsize);
 841                 if (write)
 842                         memcpy(pkt->data, data, dsize);
 843                 bcmerror = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_1, write,
 844                                               sdaddr, pkt);
 845                 if (bcmerror) {
 846                         brcmf_err("membytes transfer failed\n");
 847                         break;
 848                 }
 849                 if (!write)
 850                         memcpy(data, pkt->data, dsize);
 851                 skb_trim(pkt, 0);
 852
 853                 /* Adjust for next transfer (if any) */
 854                 size -= dsize;
 855                 if (size) {
 856                         data += dsize;
 857                         address += dsize;
 858                         sdaddr = 0;
 859                         dsize = min_t(uint, SBSDIO_SB_OFT_ADDR_LIMIT, size);
 860                 }
 861         }
 862
 863         dev_kfree_skb(pkt);
 864
 865         /* Return the window to backplane enumeration space for core access */
 866         if (brcmf_sdiod_set_sbaddr_window(sdiodev, sdiodev->sbwad))
 867                 brcmf_err("FAILED to set window back to 0x%x\n",
 868                           sdiodev->sbwad);
 869
 870         sdio_release_host(sdiodev->func[1]);
 871
 872         return bcmerror;
 873 }
 874
 875 int brcmf_sdiod_abort(struct brcmf_sdio_dev *sdiodev, uint fn)
 876 {
 877         char t_func = (char)fn;
 878         brcmf_dbg(SDIO, "Enter\n");
 879
 880         /* issue abort cmd52 command through F0 */
 881         brcmf_sdiod_request_data(sdiodev, SDIO_FUNC_0, SDIO_CCCR_ABORT,
 882                                  sizeof(t_func), &t_func, true);
 883
 884         brcmf_dbg(SDIO, "Exit\n");
 885         return 0;
 886 }
 887
 888 void brcmf_sdiod_sgtable_alloc(struct brcmf_sdio_dev *sdiodev)
 889 {
 890         struct sdio_func *func;
 891         struct mmc_host *host;
 892         uint max_blocks;
 893         uint nents;
 894         int err;
 895
 896         func = sdiodev->func[2];
 897         host = func->card->host;
 898         sdiodev->sg_support = host->max_segs > 1;
 899         max_blocks = min_t(uint, host->max_blk_count, 511u);
 900         sdiodev->max_request_size = min_t(uint, host->max_req_size,
 901                                           max_blocks * func->cur_blksize);
 902         sdiodev->max_segment_count = min_t(uint, host->max_segs,
 903                                            SG_MAX_SINGLE_ALLOC);
 904         sdiodev->max_segment_size = host->max_seg_size;
 905
 906         if (!sdiodev->sg_support)
 907                 return;
 908
 909         nents = max_t(uint, BRCMF_DEFAULT_RXGLOM_SIZE,
 910                       sdiodev->settings->bus.sdio.txglomsz);
 911         nents += (nents >> 4) + 1;
 912
 913         WARN_ON(nents > sdiodev->max_segment_count);
 914
 915         brcmf_dbg(TRACE, "nents=%d\n", nents);
 916         err = sg_alloc_table(&sdiodev->sgtable, nents, GFP_KERNEL);
 917         if (err < 0) {
 918                 brcmf_err("allocation failed: disable scatter-gather");
 919                 sdiodev->sg_support = false;
 920         }
 921
 922         sdiodev->txglomsz = sdiodev->settings->bus.sdio.txglomsz;
 923 }
 924
 925 #ifdef CONFIG_PM_SLEEP
 926 static int brcmf_sdiod_freezer_attach(struct brcmf_sdio_dev *sdiodev)
 927 {
 928         sdiodev->freezer = kzalloc(sizeof(*sdiodev->freezer), GFP_KERNEL);
 929         if (!sdiodev->freezer)
 930                 return -ENOMEM;
 931         atomic_set(&sdiodev->freezer->thread_count, 0);
 932         atomic_set(&sdiodev->freezer->freezing, 0);
 933         init_waitqueue_head(&sdiodev->freezer->thread_freeze);
 934         init_completion(&sdiodev->freezer->resumed);
 935         return 0;
 936 }
 937
 938 static void brcmf_sdiod_freezer_detach(struct brcmf_sdio_dev *sdiodev)
 939 {
 940         if (sdiodev->freezer) {
 941                 WARN_ON(atomic_read(&sdiodev->freezer->freezing));
 942                 kfree(sdiodev->freezer);
 943         }
 944 }
 945
 946 static int brcmf_sdiod_freezer_on(struct brcmf_sdio_dev *sdiodev)
 947 {
 948         atomic_t *expect = &sdiodev->freezer->thread_count;
 949         int res = 0;
 950
 951         sdiodev->freezer->frozen_count = 0;
 952         reinit_completion(&sdiodev->freezer->resumed);
 953         atomic_set(&sdiodev->freezer->freezing, 1);
 954         brcmf_sdio_trigger_dpc(sdiodev->bus);
 955         wait_event(sdiodev->freezer->thread_freeze,
 956                    atomic_read(expect) == sdiodev->freezer->frozen_count);
 957         sdio_claim_host(sdiodev->func[1]);
 958         res = brcmf_sdio_sleep(sdiodev->bus, true);
 959         sdio_release_host(sdiodev->func[1]);
 960         return res;
 961 }
 962
 963 static void brcmf_sdiod_freezer_off(struct brcmf_sdio_dev *sdiodev)
 964 {
 965         sdio_claim_host(sdiodev->func[1]);
 966         brcmf_sdio_sleep(sdiodev->bus, false);
 967         sdio_release_host(sdiodev->func[1]);
 968         atomic_set(&sdiodev->freezer->freezing, 0);
 969         complete_all(&sdiodev->freezer->resumed);
 970 }
 971
 972 bool brcmf_sdiod_freezing(struct brcmf_sdio_dev *sdiodev)
 973 {
 974         return atomic_read(&sdiodev->freezer->freezing);
 975 }
 976
 977 void brcmf_sdiod_try_freeze(struct brcmf_sdio_dev *sdiodev)
 978 {
 979         if (!brcmf_sdiod_freezing(sdiodev))
 980                 return;
 981         sdiodev->freezer->frozen_count++;
 982         wake_up(&sdiodev->freezer->thread_freeze);
 983         wait_for_completion(&sdiodev->freezer->resumed);
 984 }
 985
 986 void brcmf_sdiod_freezer_count(struct brcmf_sdio_dev *sdiodev)
 987 {
 988         atomic_inc(&sdiodev->freezer->thread_count);
 989 }
 990
 991 void brcmf_sdiod_freezer_uncount(struct brcmf_sdio_dev *sdiodev)
 992 {
 993         atomic_dec(&sdiodev->freezer->thread_count);
 994 }
 995 #else
 996 static int brcmf_sdiod_freezer_attach(struct brcmf_sdio_dev *sdiodev)
 997 {
 998         return 0;
 999 }
1000
1001 static void brcmf_sdiod_freezer_detach(struct brcmf_sdio_dev *sdiodev)
1002 {
1003 }
1004 #endif /* CONFIG_PM_SLEEP */
1005
1006 static int brcmf_sdiod_remove(struct brcmf_sdio_dev *sdiodev)
1007 {
1008         sdiodev->state = BRCMF_SDIOD_DOWN;
1009         if (sdiodev->bus) {
1010                 brcmf_sdio_remove(sdiodev->bus);
1011                 sdiodev->bus = NULL;
1012         }
1013
1014         brcmf_sdiod_freezer_detach(sdiodev);
1015
1016         /* Disable Function 2 */
1017         sdio_claim_host(sdiodev->func[2]);
1018         sdio_disable_func(sdiodev->func[2]);
1019         sdio_release_host(sdiodev->func[2]);
1020
1021         /* Disable Function 1 */
1022         sdio_claim_host(sdiodev->func[1]);
1023         sdio_disable_func(sdiodev->func[1]);
1024         sdio_release_host(sdiodev->func[1]);
1025
1026         sg_free_table(&sdiodev->sgtable);
1027         sdiodev->sbwad = 0;
1028
1029         pm_runtime_allow(sdiodev->func[1]->card->host->parent);
1030         return 0;
1031 }
1032
1033 static void brcmf_sdiod_host_fixup(struct mmc_host *host)
1034 {
1035         /* runtime-pm powers off the device */
1036         pm_runtime_forbid(host->parent);
1037         /* avoid removal detection upon resume */
1038         host->caps |= MMC_CAP_NONREMOVABLE;
1039 }
1040
1041 static int brcmf_sdiod_probe(struct brcmf_sdio_dev *sdiodev)
1042 {
1043         int ret = 0;
1044
1045         sdiodev->num_funcs = 2;
1046
1047         sdio_claim_host(sdiodev->func[1]);
1048
1049         ret = sdio_set_block_size(sdiodev->func[1], SDIO_FUNC1_BLOCKSIZE);
1050         if (ret) {
1051                 brcmf_err("Failed to set F1 blocksize\n");
1052                 sdio_release_host(sdiodev->func[1]);
1053                 goto out;
1054         }
1055         ret = sdio_set_block_size(sdiodev->func[2], SDIO_FUNC2_BLOCKSIZE);
1056         if (ret) {
1057                 brcmf_err("Failed to set F2 blocksize\n");
1058                 sdio_release_host(sdiodev->func[1]);
1059                 goto out;
1060         }
1061
1062         /* increase F2 timeout */
1063         sdiodev->func[2]->enable_timeout = SDIO_WAIT_F2RDY;
1064
1065         /* Enable Function 1 */
1066         ret = sdio_enable_func(sdiodev->func[1]);
1067         sdio_release_host(sdiodev->func[1]);
1068         if (ret) {
1069                 brcmf_err("Failed to enable F1: err=%d\n", ret);
1070                 goto out;
1071         }
1072
1073         ret = brcmf_sdiod_freezer_attach(sdiodev);
1074         if (ret)
1075                 goto out;
1076
1077         /* try to attach to the target device */
1078         sdiodev->bus = brcmf_sdio_probe(sdiodev);
1079         if (!sdiodev->bus) {
1080                 ret = -ENODEV;
1081                 goto out;
1082         }
1083         brcmf_sdiod_host_fixup(sdiodev->func[2]->card->host);
1084 out:
1085         if (ret)
1086                 brcmf_sdiod_remove(sdiodev);
1087
1088         return ret;
1089 }
1090
1091 #define BRCMF_SDIO_DEVICE(dev_id)       \
1092         {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, dev_id)}
1093
1094 /* devices we support, null terminated */
1095 static const struct sdio_device_id brcmf_sdmmc_ids[] = {
1096         BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43143),
1097         BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43241),
1098         BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4329),
1099         BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4330),
1100         BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4334),
1101         BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43340),
1102         BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43341),
1103         BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43362),
1104         BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4335_4339),
1105         BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4339),
1106         BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43430),
1107         BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4345),
1108         BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43455),
1109         BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4354),
1110         BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4356),
1111         { /* end: all zeroes */ }
1112 };
1113 MODULE_DEVICE_TABLE(sdio, brcmf_sdmmc_ids);
1114
1115
1116 static void brcmf_sdiod_acpi_set_power_manageable(struct device *dev,
1117                                                   int val)
1118 {
1119 #if IS_ENABLED(CONFIG_ACPI)
1120         struct acpi_device *adev;
1121
1122         adev = ACPI_COMPANION(dev);
1123         if (adev)
1124                 adev->flags.power_manageable = 0;
1125 #endif
1126 }
1127
1128 static int brcmf_ops_sdio_probe(struct sdio_func *func,
1129                                 const struct sdio_device_id *id)
1130 {
1131         int err;
1132         struct brcmf_sdio_dev *sdiodev;
1133         struct brcmf_bus *bus_if;
1134         struct device *dev;
1135
1136         brcmf_dbg(SDIO, "Enter\n");
1137         brcmf_dbg(SDIO, "Class=%x\n", func->class);
1138         brcmf_dbg(SDIO, "sdio vendor ID: 0x%04x\n", func->vendor);
1139         brcmf_dbg(SDIO, "sdio device ID: 0x%04x\n", func->device);
1140         brcmf_dbg(SDIO, "Function#: %d\n", func->num);
1141
1142         dev = &func->dev;
1143         /* prohibit ACPI power management for this device */
1144         brcmf_sdiod_acpi_set_power_manageable(dev, 0);
1145
1146         /* Consume func num 1 but dont do anything with it. */
1147         if (func->num == 1)
1148                 return 0;
1149
1150         /* Ignore anything but func 2 */
1151         if (func->num != 2)
1152                 return -ENODEV;
1153
1154         bus_if = kzalloc(sizeof(struct brcmf_bus), GFP_KERNEL);
1155         if (!bus_if)
1156                 return -ENOMEM;
1157         sdiodev = kzalloc(sizeof(struct brcmf_sdio_dev), GFP_KERNEL);
1158         if (!sdiodev) {
1159                 kfree(bus_if);
1160                 return -ENOMEM;
1161         }
1162
1163         /* store refs to functions used. mmc_card does
1164          * not hold the F0 function pointer.
1165          */
1166         sdiodev->func[0] = kmemdup(func, sizeof(*func), GFP_KERNEL);
1167         sdiodev->func[0]->num = 0;
1168         sdiodev->func[1] = func->card->sdio_func[0];
1169         sdiodev->func[2] = func;
1170
1171         sdiodev->bus_if = bus_if;
1172         bus_if->bus_priv.sdio = sdiodev;
1173         bus_if->proto_type = BRCMF_PROTO_BCDC;
1174         dev_set_drvdata(&func->dev, bus_if);
1175         dev_set_drvdata(&sdiodev->func[1]->dev, bus_if);
1176         sdiodev->dev = &sdiodev->func[1]->dev;
1177
1178         brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_DOWN);
1179
1180         brcmf_dbg(SDIO, "F2 found, calling brcmf_sdiod_probe...\n");
1181         err = brcmf_sdiod_probe(sdiodev);
1182         if (err) {
1183                 brcmf_err("F2 error, probe failed %d...\n", err);
1184                 goto fail;
1185         }
1186
1187         brcmf_dbg(SDIO, "F2 init completed...\n");
1188         return 0;
1189
1190 fail:
1191         dev_set_drvdata(&func->dev, NULL);
1192         dev_set_drvdata(&sdiodev->func[1]->dev, NULL);
1193         kfree(sdiodev->func[0]);
1194         kfree(sdiodev);
1195         kfree(bus_if);
1196         return err;
1197 }
1198
1199 static void brcmf_ops_sdio_remove(struct sdio_func *func)
1200 {
1201         struct brcmf_bus *bus_if;
1202         struct brcmf_sdio_dev *sdiodev;
1203
1204         brcmf_dbg(SDIO, "Enter\n");
1205         brcmf_dbg(SDIO, "sdio vendor ID: 0x%04x\n", func->vendor);
1206         brcmf_dbg(SDIO, "sdio device ID: 0x%04x\n", func->device);
1207         brcmf_dbg(SDIO, "Function: %d\n", func->num);
1208
1209         bus_if = dev_get_drvdata(&func->dev);
1210         if (bus_if) {
1211                 sdiodev = bus_if->bus_priv.sdio;
1212
1213                 /* start by unregistering irqs */
1214                 brcmf_sdiod_intr_unregister(sdiodev);
1215
1216                 if (func->num != 1)
1217                         return;
1218
1219                 /* only proceed with rest of cleanup if func 1 */
1220                 brcmf_sdiod_remove(sdiodev);
1221
1222                 dev_set_drvdata(&sdiodev->func[1]->dev, NULL);
1223                 dev_set_drvdata(&sdiodev->func[2]->dev, NULL);
1224
1225                 kfree(bus_if);
1226                 kfree(sdiodev->func[0]);
1227                 kfree(sdiodev);
1228         }
1229
1230         brcmf_dbg(SDIO, "Exit\n");
1231 }
1232
1233 void brcmf_sdio_wowl_config(struct device *dev, bool enabled)
1234 {
1235         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1236         struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
1237
1238         brcmf_dbg(SDIO, "Configuring WOWL, enabled=%d\n", enabled);
1239         sdiodev->wowl_enabled = enabled;
1240 }
1241
1242 #ifdef CONFIG_PM_SLEEP
1243 static int brcmf_ops_sdio_suspend(struct device *dev)
1244 {
1245         struct sdio_func *func;
1246         struct brcmf_bus *bus_if;
1247         struct brcmf_sdio_dev *sdiodev;
1248         mmc_pm_flag_t sdio_flags;
1249
1250         func = container_of(dev, struct sdio_func, dev);
1251         brcmf_dbg(SDIO, "Enter: F%d\n", func->num);
1252         if (func->num != SDIO_FUNC_1)
1253                 return 0;
1254
1255
1256         bus_if = dev_get_drvdata(dev);
1257         sdiodev = bus_if->bus_priv.sdio;
1258
1259         brcmf_sdiod_freezer_on(sdiodev);
1260         brcmf_sdio_wd_timer(sdiodev->bus, 0);
1261
1262         sdio_flags = MMC_PM_KEEP_POWER;
1263         if (sdiodev->wowl_enabled) {
1264                 if (sdiodev->settings->bus.sdio.oob_irq_supported)
1265                         enable_irq_wake(sdiodev->settings->bus.sdio.oob_irq_nr);
1266                 else
1267                         sdio_flags |= MMC_PM_WAKE_SDIO_IRQ;
1268         }
1269         if (sdio_set_host_pm_flags(sdiodev->func[1], sdio_flags))
1270                 brcmf_err("Failed to set pm_flags %x\n", sdio_flags);
1271         return 0;
1272 }
1273
1274 static int brcmf_ops_sdio_resume(struct device *dev)
1275 {
1276         struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1277         struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
1278         struct sdio_func *func = container_of(dev, struct sdio_func, dev);
1279
1280         brcmf_dbg(SDIO, "Enter: F%d\n", func->num);
1281         if (func->num != SDIO_FUNC_2)
1282                 return 0;
1283
1284         brcmf_sdiod_freezer_off(sdiodev);
1285         return 0;
1286 }
1287
1288 static const struct dev_pm_ops brcmf_sdio_pm_ops = {
1289         .suspend        = brcmf_ops_sdio_suspend,
1290         .resume         = brcmf_ops_sdio_resume,
1291 };
1292 #endif  /* CONFIG_PM_SLEEP */
1293
1294 static struct sdio_driver brcmf_sdmmc_driver = {
1295         .probe = brcmf_ops_sdio_probe,
1296         .remove = brcmf_ops_sdio_remove,
1297         .name = KBUILD_MODNAME,
1298         .id_table = brcmf_sdmmc_ids,
1299         .drv = {
1300                 .owner = THIS_MODULE,
1301 #ifdef CONFIG_PM_SLEEP
1302                 .pm = &brcmf_sdio_pm_ops,
1303 #endif  /* CONFIG_PM_SLEEP */
1304         },
1305 };
1306
1307 void brcmf_sdio_register(void)
1308 {
1309         int ret;
1310
1311         ret = sdio_register_driver(&brcmf_sdmmc_driver);
1312         if (ret)
1313                 brcmf_err("sdio_register_driver failed: %d\n", ret);
1314 }
1315
1316 void brcmf_sdio_exit(void)
1317 {
1318         brcmf_dbg(SDIO, "Enter\n");
1319
1320         sdio_unregister_driver(&brcmf_sdmmc_driver);
1321 }
1322