drivers/staging/brcm80211/brcmfmac/bcmsdh_sdmmc.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 #include <linux/types.h>
  17 #include <linux/netdevice.h>
  18 #include <linux/mmc/sdio.h>
  19 #include <linux/mmc/core.h>
  20 #include <linux/mmc/sdio_func.h>
  21 #include <linux/mmc/sdio_ids.h>
  22 #include <linux/mmc/card.h>
  23 #include <linux/suspend.h>
  24 #include <linux/errno.h>
  25 #include <linux/sched.h>        /* request_irq() */
  26 #include <net/cfg80211.h>
  27
  28 #include <defs.h>
  29 #include <brcm_hw_ids.h>
  30 #include <brcmu_utils.h>
  31 #include <brcmu_wifi.h>
  32 #include "sdio_host.h"
  33 #include "dhd.h"
  34 #include "dhd_dbg.h"
  35 #include "wl_cfg80211.h"
  36
  37 #if !defined(SDIO_VENDOR_ID_BROADCOM)
  38 #define SDIO_VENDOR_ID_BROADCOM         0x02d0
  39 #endif                          /* !defined(SDIO_VENDOR_ID_BROADCOM) */
  40
  41 #define DMA_ALIGN_MASK  0x03
  42
  43 #if !defined(SDIO_DEVICE_ID_BROADCOM_4329)
  44 #define SDIO_DEVICE_ID_BROADCOM_4329    0x4329
  45 #endif          /* !defined(SDIO_DEVICE_ID_BROADCOM_4329) */
  46
  47 static int brcmf_sdioh_get_cisaddr(struct brcmf_sdio_dev *sdiodev, u32 regaddr);
  48 static int brcmf_ops_sdio_probe(struct sdio_func *func,
  49                                 const struct sdio_device_id *id);
  50 static void brcmf_ops_sdio_remove(struct sdio_func *func);
  51
  52 #ifdef CONFIG_PM
  53 static int brcmf_sdio_suspend(struct device *dev);
  54 static int brcmf_sdio_resume(struct device *dev);
  55 #endif /* CONFIG_PM */
  56
  57 uint sd_f2_blocksize = 512;     /* Default blocksize */
  58
  59 /* devices we support, null terminated */
  60 static const struct sdio_device_id brcmf_sdmmc_ids[] = {
  61         {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, SDIO_DEVICE_ID_BROADCOM_4329)},
  62         { /* end: all zeroes */ },
  63 };
  64
  65 #ifdef CONFIG_PM_SLEEP
  66 static const struct dev_pm_ops brcmf_sdio_pm_ops = {
  67         .suspend        = brcmf_sdio_suspend,
  68         .resume         = brcmf_sdio_resume,
  69 };
  70 #endif  /* CONFIG_PM_SLEEP */
  71
  72 static struct sdio_driver brcmf_sdmmc_driver = {
  73         .probe = brcmf_ops_sdio_probe,
  74         .remove = brcmf_ops_sdio_remove,
  75         .name = "brcmfmac",
  76         .id_table = brcmf_sdmmc_ids,
  77 #ifdef CONFIG_PM_SLEEP
  78         .drv = {
  79                 .pm = &brcmf_sdio_pm_ops,
  80         },
  81 #endif  /* CONFIG_PM_SLEEP */
  82 };
  83
  84 MODULE_DEVICE_TABLE(sdio, brcmf_sdmmc_ids);
  85
  86 #ifdef CONFIG_PM_SLEEP
  87 DECLARE_WAIT_QUEUE_HEAD(sdioh_request_byte_wait);
  88 DECLARE_WAIT_QUEUE_HEAD(sdioh_request_word_wait);
  89 DECLARE_WAIT_QUEUE_HEAD(sdioh_request_packet_wait);
  90 DECLARE_WAIT_QUEUE_HEAD(sdioh_request_buffer_wait);
  91 #define BRCMF_PM_RESUME_WAIT(a, b) do { \
  92                 int retry = 0; \
  93                 while (atomic_read(&b->suspend) && retry++ != 30) { \
  94                         wait_event_timeout(a, false, HZ/100); \
  95                 } \
  96         }       while (0)
  97 #define BRCMF_PM_RESUME_RETURN_ERROR(a, b)      \
  98         do { if (atomic_read(&b->suspend)) return a; } while (0)
  99 #else
 100 #define BRCMF_PM_RESUME_WAIT(a, b)
 101 #define BRCMF_PM_RESUME_RETURN_ERROR(a, b)
 102 #endif          /* CONFIG_PM_SLEEP */
 103
 104 static int
 105 brcmf_sdioh_card_regread(struct brcmf_sdio_dev *sdiodev, int func, u32 regaddr,
 106                          int regsize, u32 *data);
 107
 108 static int brcmf_sdioh_enablefuncs(struct brcmf_sdio_dev *sdiodev)
 109 {
 110         int err_ret;
 111         u32 fbraddr;
 112         u8 func;
 113
 114         brcmf_dbg(TRACE, "\n");
 115
 116         /* Get the Card's common CIS address */
 117         sdiodev->func_cis_ptr[0] = brcmf_sdioh_get_cisaddr(sdiodev,
 118                                                            SDIO_CCCR_CIS);
 119         brcmf_dbg(INFO, "Card's Common CIS Ptr = 0x%x\n",
 120                   sdiodev->func_cis_ptr[0]);
 121
 122         /* Get the Card's function CIS (for each function) */
 123         for (fbraddr = SDIO_FBR_BASE(1), func = 1;
 124              func <= sdiodev->num_funcs; func++, fbraddr += SDIOD_FBR_SIZE) {
 125                 sdiodev->func_cis_ptr[func] =
 126                     brcmf_sdioh_get_cisaddr(sdiodev, SDIO_FBR_CIS + fbraddr);
 127                 brcmf_dbg(INFO, "Function %d CIS Ptr = 0x%x\n",
 128                           func, sdiodev->func_cis_ptr[func]);
 129         }
 130
 131         /* Enable Function 1 */
 132         sdio_claim_host(sdiodev->func[1]);
 133         err_ret = sdio_enable_func(sdiodev->func[1]);
 134         sdio_release_host(sdiodev->func[1]);
 135         if (err_ret)
 136                 brcmf_dbg(ERROR, "Failed to enable F1 Err: 0x%08x\n", err_ret);
 137
 138         return false;
 139 }
 140
 141 /*
 142  *      Public entry points & extern's
 143  */
 144 int brcmf_sdioh_attach(struct brcmf_sdio_dev *sdiodev)
 145 {
 146         int err_ret = 0;
 147
 148         brcmf_dbg(TRACE, "\n");
 149
 150         sdiodev->num_funcs = 2;
 151
 152         sdio_claim_host(sdiodev->func[1]);
 153         err_ret = sdio_set_block_size(sdiodev->func[1], 64);
 154         sdio_release_host(sdiodev->func[1]);
 155         if (err_ret) {
 156                 brcmf_dbg(ERROR, "Failed to set F1 blocksize\n");
 157                 goto out;
 158         }
 159
 160         sdio_claim_host(sdiodev->func[2]);
 161         err_ret = sdio_set_block_size(sdiodev->func[2], sd_f2_blocksize);
 162         sdio_release_host(sdiodev->func[2]);
 163         if (err_ret) {
 164                 brcmf_dbg(ERROR, "Failed to set F2 blocksize to %d\n",
 165                           sd_f2_blocksize);
 166                 goto out;
 167         }
 168
 169         brcmf_sdioh_enablefuncs(sdiodev);
 170
 171 out:
 172         brcmf_dbg(TRACE, "Done\n");
 173         return err_ret;
 174 }
 175
 176 void brcmf_sdioh_detach(struct brcmf_sdio_dev *sdiodev)
 177 {
 178         brcmf_dbg(TRACE, "\n");
 179
 180         /* Disable Function 2 */
 181         sdio_claim_host(sdiodev->func[2]);
 182         sdio_disable_func(sdiodev->func[2]);
 183         sdio_release_host(sdiodev->func[2]);
 184
 185         /* Disable Function 1 */
 186         sdio_claim_host(sdiodev->func[1]);
 187         sdio_disable_func(sdiodev->func[1]);
 188         sdio_release_host(sdiodev->func[1]);
 189
 190 }
 191
 192 static int brcmf_sdioh_get_cisaddr(struct brcmf_sdio_dev *sdiodev, u32 regaddr)
 193 {
 194         /* read 24 bits and return valid 17 bit addr */
 195         int i;
 196         u32 scratch, regdata;
 197         u8 *ptr = (u8 *)&scratch;
 198         for (i = 0; i < 3; i++) {
 199                 if ((brcmf_sdioh_card_regread(sdiodev, 0, regaddr, 1,
 200                                 &regdata)) != SUCCESS)
 201                         brcmf_dbg(ERROR, "Can't read!\n");
 202
 203                 *ptr++ = (u8) regdata;
 204                 regaddr++;
 205         }
 206
 207         /* Only the lower 17-bits are valid */
 208         scratch = le32_to_cpu(scratch);
 209         scratch &= 0x0001FFFF;
 210         return scratch;
 211 }
 212
 213 extern int
 214 brcmf_sdioh_cis_read(struct brcmf_sdio_dev *sdiodev, uint func,
 215                      u8 *cisd, u32 length)
 216 {
 217         u32 count;
 218         int offset;
 219         u32 foo;
 220         u8 *cis = cisd;
 221
 222         brcmf_dbg(TRACE, "Func = %d\n", func);
 223
 224         if (!sdiodev->func_cis_ptr[func]) {
 225                 memset(cis, 0, length);
 226                 brcmf_dbg(ERROR, "no func_cis_ptr[%d]\n", func);
 227                 return -ENOTSUPP;
 228         }
 229
 230         brcmf_dbg(ERROR, "func_cis_ptr[%d]=0x%04x\n",
 231                   func, sdiodev->func_cis_ptr[func]);
 232
 233         for (count = 0; count < length; count++) {
 234                 offset = sdiodev->func_cis_ptr[func] + count;
 235                 if (brcmf_sdioh_card_regread(sdiodev, 0, offset, 1, &foo) < 0) {
 236                         brcmf_dbg(ERROR, "regread failed: Can't read CIS\n");
 237                         return -EIO;
 238                 }
 239
 240                 *cis = (u8) (foo & 0xff);
 241                 cis++;
 242         }
 243
 244         return 0;
 245 }
 246
 247 extern int
 248 brcmf_sdioh_request_byte(struct brcmf_sdio_dev *sdiodev, uint rw, uint func,
 249                          uint regaddr, u8 *byte)
 250 {
 251         int err_ret;
 252
 253         brcmf_dbg(INFO, "rw=%d, func=%d, addr=0x%05x\n", rw, func, regaddr);
 254
 255         BRCMF_PM_RESUME_WAIT(sdioh_request_byte_wait, sdiodev);
 256         BRCMF_PM_RESUME_RETURN_ERROR(-EIO, sdiodev);
 257         if (rw) {               /* CMD52 Write */
 258                 if (func == 0) {
 259                         /* Can only directly write to some F0 registers.
 260                          * Handle F2 enable
 261                          * as a special case.
 262                          */
 263                         if (regaddr == SDIO_CCCR_IOEx) {
 264                                 if (sdiodev->func[2]) {
 265                                         sdio_claim_host(sdiodev->func[2]);
 266                                         if (*byte & SDIO_FUNC_ENABLE_2) {
 267                                                 /* Enable Function 2 */
 268                                                 err_ret =
 269                                                     sdio_enable_func
 270                                                     (sdiodev->func[2]);
 271                                                 if (err_ret)
 272                                                         brcmf_dbg(ERROR,
 273                                                                   "enable F2 failed:%d\n",
 274                                                                   err_ret);
 275                                         } else {
 276                                                 /* Disable Function 2 */
 277                                                 err_ret =
 278                                                     sdio_disable_func
 279                                                     (sdiodev->func[2]);
 280                                                 if (err_ret)
 281                                                         brcmf_dbg(ERROR,
 282                                                                   "Disable F2 failed:%d\n",
 283                                                                   err_ret);
 284                                         }
 285                                         sdio_release_host(sdiodev->func[2]);
 286                                 }
 287                         }
 288                         /* to allow abort command through F1 */
 289                         else if (regaddr == SDIO_CCCR_ABORT) {
 290                                 sdio_claim_host(sdiodev->func[func]);
 291                                 /*
 292                                  * this sdio_f0_writeb() can be replaced
 293                                  * with another api
 294                                  * depending upon MMC driver change.
 295                                  * As of this time, this is temporaray one
 296                                  */
 297                                 sdio_writeb(sdiodev->func[func], *byte,
 298                                             regaddr, &err_ret);
 299                                 sdio_release_host(sdiodev->func[func]);
 300                         } else if (regaddr < 0xF0) {
 301                                 brcmf_dbg(ERROR, "F0 Wr:0x%02x: write disallowed\n",
 302                                           regaddr);
 303                         } else {
 304                                 /* Claim host controller, perform F0 write,
 305                                  and release */
 306                                 sdio_claim_host(sdiodev->func[func]);
 307                                 sdio_f0_writeb(sdiodev->func[func], *byte,
 308                                                regaddr, &err_ret);
 309                                 sdio_release_host(sdiodev->func[func]);
 310                         }
 311                 } else {
 312                         /* Claim host controller, perform Fn write,
 313                          and release */
 314                         sdio_claim_host(sdiodev->func[func]);
 315                         sdio_writeb(sdiodev->func[func], *byte, regaddr,
 316                                     &err_ret);
 317                         sdio_release_host(sdiodev->func[func]);
 318                 }
 319         } else {                /* CMD52 Read */
 320                 /* Claim host controller, perform Fn read, and release */
 321                 sdio_claim_host(sdiodev->func[func]);
 322
 323                 if (func == 0) {
 324                         *byte =
 325                             sdio_f0_readb(sdiodev->func[func], regaddr,
 326                                           &err_ret);
 327                 } else {
 328                         *byte =
 329                             sdio_readb(sdiodev->func[func], regaddr,
 330                                        &err_ret);
 331                 }
 332
 333                 sdio_release_host(sdiodev->func[func]);
 334         }
 335
 336         if (err_ret)
 337                 brcmf_dbg(ERROR, "Failed to %s byte F%d:@0x%05x=%02x, Err: %d\n",
 338                           rw ? "write" : "read", func, regaddr, *byte, err_ret);
 339
 340         return err_ret;
 341 }
 342
 343 extern int
 344 brcmf_sdioh_request_word(struct brcmf_sdio_dev *sdiodev, uint cmd_type, uint rw,
 345                          uint func, uint addr, u32 *word, uint nbytes)
 346 {
 347         int err_ret = -EIO;
 348
 349         if (func == 0) {
 350                 brcmf_dbg(ERROR, "Only CMD52 allowed to F0\n");
 351                 return -EINVAL;
 352         }
 353
 354         brcmf_dbg(INFO, "cmd_type=%d, rw=%d, func=%d, addr=0x%05x, nbytes=%d\n",
 355                   cmd_type, rw, func, addr, nbytes);
 356
 357         BRCMF_PM_RESUME_WAIT(sdioh_request_word_wait, sdiodev);
 358         BRCMF_PM_RESUME_RETURN_ERROR(-EIO, sdiodev);
 359         /* Claim host controller */
 360         sdio_claim_host(sdiodev->func[func]);
 361
 362         if (rw) {               /* CMD52 Write */
 363                 if (nbytes == 4)
 364                         sdio_writel(sdiodev->func[func], *word, addr,
 365                                     &err_ret);
 366                 else if (nbytes == 2)
 367                         sdio_writew(sdiodev->func[func], (*word & 0xFFFF),
 368                                     addr, &err_ret);
 369                 else
 370                         brcmf_dbg(ERROR, "Invalid nbytes: %d\n", nbytes);
 371         } else {                /* CMD52 Read */
 372                 if (nbytes == 4)
 373                         *word =
 374                             sdio_readl(sdiodev->func[func], addr, &err_ret);
 375                 else if (nbytes == 2)
 376                         *word =
 377                             sdio_readw(sdiodev->func[func], addr,
 378                                        &err_ret) & 0xFFFF;
 379                 else
 380                         brcmf_dbg(ERROR, "Invalid nbytes: %d\n", nbytes);
 381         }
 382
 383         /* Release host controller */
 384         sdio_release_host(sdiodev->func[func]);
 385
 386         if (err_ret)
 387                 brcmf_dbg(ERROR, "Failed to %s word, Err: 0x%08x\n",
 388                           rw ? "write" : "read", err_ret);
 389
 390         return err_ret;
 391 }
 392
 393 static int
 394 brcmf_sdioh_request_packet(struct brcmf_sdio_dev *sdiodev, uint fix_inc,
 395                            uint write, uint func, uint addr,
 396                            struct sk_buff *pkt)
 397 {
 398         bool fifo = (fix_inc == SDIOH_DATA_FIX);
 399         u32 SGCount = 0;
 400         int err_ret = 0;
 401
 402         struct sk_buff *pnext;
 403
 404         brcmf_dbg(TRACE, "Enter\n");
 405
 406         BRCMF_PM_RESUME_WAIT(sdioh_request_packet_wait, sdiodev);
 407         BRCMF_PM_RESUME_RETURN_ERROR(-EIO, sdiodev);
 408
 409         /* Claim host controller */
 410         sdio_claim_host(sdiodev->func[func]);
 411         for (pnext = pkt; pnext; pnext = pnext->next) {
 412                 uint pkt_len = pnext->len;
 413                 pkt_len += 3;
 414                 pkt_len &= 0xFFFFFFFC;
 415
 416                 if ((write) && (!fifo)) {
 417                         err_ret = sdio_memcpy_toio(sdiodev->func[func], addr,
 418                                                    ((u8 *) (pnext->data)),
 419                                                    pkt_len);
 420                 } else if (write) {
 421                         err_ret = sdio_memcpy_toio(sdiodev->func[func], addr,
 422                                                    ((u8 *) (pnext->data)),
 423                                                    pkt_len);
 424                 } else if (fifo) {
 425                         err_ret = sdio_readsb(sdiodev->func[func],
 426                                               ((u8 *) (pnext->data)),
 427                                               addr, pkt_len);
 428                 } else {
 429                         err_ret = sdio_memcpy_fromio(sdiodev->func[func],
 430                                                      ((u8 *) (pnext->data)),
 431                                                      addr, pkt_len);
 432                 }
 433
 434                 if (err_ret) {
 435                         brcmf_dbg(ERROR, "%s FAILED %p[%d], addr=0x%05x, pkt_len=%d, ERR=0x%08x\n",
 436                                   write ? "TX" : "RX", pnext, SGCount, addr,
 437                                   pkt_len, err_ret);
 438                 } else {
 439                         brcmf_dbg(TRACE, "%s xfr'd %p[%d], addr=0x%05x, len=%d\n",
 440                                   write ? "TX" : "RX", pnext, SGCount, addr,
 441                                   pkt_len);
 442                 }
 443
 444                 if (!fifo)
 445                         addr += pkt_len;
 446                 SGCount++;
 447
 448         }
 449
 450         /* Release host controller */
 451         sdio_release_host(sdiodev->func[func]);
 452
 453         brcmf_dbg(TRACE, "Exit\n");
 454         return err_ret;
 455 }
 456
 457 /*
 458  * This function takes a buffer or packet, and fixes everything up
 459  * so that in the end, a DMA-able packet is created.
 460  *
 461  * A buffer does not have an associated packet pointer,
 462  * and may or may not be aligned.
 463  * A packet may consist of a single packet, or a packet chain.
 464  * If it is a packet chain, then all the packets in the chain
 465  * must be properly aligned.
 466  *
 467  * If the packet data is not aligned, then there may only be
 468  * one packet, and in this case,  it is copied to a new
 469  * aligned packet.
 470  *
 471  */
 472 extern int
 473 brcmf_sdioh_request_buffer(struct brcmf_sdio_dev *sdiodev, uint pio_dma,
 474                            uint fix_inc, uint write, uint func, uint addr,
 475                            uint reg_width, uint buflen_u, u8 *buffer,
 476                            struct sk_buff *pkt)
 477 {
 478         int Status;
 479         struct sk_buff *mypkt = NULL;
 480
 481         brcmf_dbg(TRACE, "Enter\n");
 482
 483         BRCMF_PM_RESUME_WAIT(sdioh_request_buffer_wait, sdiodev);
 484         BRCMF_PM_RESUME_RETURN_ERROR(-EIO, sdiodev);
 485         /* Case 1: we don't have a packet. */
 486         if (pkt == NULL) {
 487                 brcmf_dbg(DATA, "Creating new %s Packet, len=%d\n",
 488                           write ? "TX" : "RX", buflen_u);
 489                 mypkt = brcmu_pkt_buf_get_skb(buflen_u);
 490                 if (!mypkt) {
 491                         brcmf_dbg(ERROR, "brcmu_pkt_buf_get_skb failed: len %d\n",
 492                                   buflen_u);
 493                         return -EIO;
 494                 }
 495
 496                 /* For a write, copy the buffer data into the packet. */
 497                 if (write)
 498                         memcpy(mypkt->data, buffer, buflen_u);
 499
 500                 Status = brcmf_sdioh_request_packet(sdiodev, fix_inc, write,
 501                                                     func, addr, mypkt);
 502
 503                 /* For a read, copy the packet data back to the buffer. */
 504                 if (!write)
 505                         memcpy(buffer, mypkt->data, buflen_u);
 506
 507                 brcmu_pkt_buf_free_skb(mypkt);
 508         } else if (((ulong) (pkt->data) & DMA_ALIGN_MASK) != 0) {
 509                 /*
 510                  * Case 2: We have a packet, but it is unaligned.
 511                  * In this case, we cannot have a chain (pkt->next == NULL)
 512                  */
 513                 brcmf_dbg(DATA, "Creating aligned %s Packet, len=%d\n",
 514                           write ? "TX" : "RX", pkt->len);
 515                 mypkt = brcmu_pkt_buf_get_skb(pkt->len);
 516                 if (!mypkt) {
 517                         brcmf_dbg(ERROR, "brcmu_pkt_buf_get_skb failed: len %d\n",
 518                                   pkt->len);
 519                         return -EIO;
 520                 }
 521
 522                 /* For a write, copy the buffer data into the packet. */
 523                 if (write)
 524                         memcpy(mypkt->data, pkt->data, pkt->len);
 525
 526                 Status = brcmf_sdioh_request_packet(sdiodev, fix_inc, write,
 527                                                     func, addr, mypkt);
 528
 529                 /* For a read, copy the packet data back to the buffer. */
 530                 if (!write)
 531                         memcpy(pkt->data, mypkt->data, mypkt->len);
 532
 533                 brcmu_pkt_buf_free_skb(mypkt);
 534         } else {                /* case 3: We have a packet and
 535                                  it is aligned. */
 536                 brcmf_dbg(DATA, "Aligned %s Packet, direct DMA\n",
 537                           write ? "Tx" : "Rx");
 538                 Status = brcmf_sdioh_request_packet(sdiodev, fix_inc, write,
 539                                                     func, addr, pkt);
 540         }
 541
 542         return Status;
 543 }
 544
 545 /* Read client card reg */
 546 int
 547 brcmf_sdioh_card_regread(struct brcmf_sdio_dev *sdiodev, int func, u32 regaddr,
 548                          int regsize, u32 *data)
 549 {
 550
 551         if ((func == 0) || (regsize == 1)) {
 552                 u8 temp = 0;
 553
 554                 brcmf_sdioh_request_byte(sdiodev, SDIOH_READ, func, regaddr,
 555                                          &temp);
 556                 *data = temp;
 557                 *data &= 0xff;
 558                 brcmf_dbg(DATA, "byte read data=0x%02x\n", *data);
 559         } else {
 560                 brcmf_sdioh_request_word(sdiodev, 0, SDIOH_READ, func, regaddr,
 561                                          data, regsize);
 562                 if (regsize == 2)
 563                         *data &= 0xffff;
 564
 565                 brcmf_dbg(DATA, "word read data=0x%08x\n", *data);
 566         }
 567
 568         return SUCCESS;
 569 }
 570
 571 static int brcmf_ops_sdio_probe(struct sdio_func *func,
 572                               const struct sdio_device_id *id)
 573 {
 574         int ret = 0;
 575         struct brcmf_sdio_dev *sdiodev;
 576         brcmf_dbg(TRACE, "Enter\n");
 577         brcmf_dbg(TRACE, "func->class=%x\n", func->class);
 578         brcmf_dbg(TRACE, "sdio_vendor: 0x%04x\n", func->vendor);
 579         brcmf_dbg(TRACE, "sdio_device: 0x%04x\n", func->device);
 580         brcmf_dbg(TRACE, "Function#: 0x%04x\n", func->num);
 581
 582         if (func->num == 1) {
 583                 if (dev_get_drvdata(&func->card->dev)) {
 584                         brcmf_dbg(ERROR, "card private drvdata occupied\n");
 585                         return -ENXIO;
 586                 }
 587                 sdiodev = kzalloc(sizeof(struct brcmf_sdio_dev), GFP_KERNEL);
 588                 if (!sdiodev)
 589                         return -ENOMEM;
 590                 sdiodev->func[0] = func->card->sdio_func[0];
 591                 sdiodev->func[1] = func;
 592                 dev_set_drvdata(&func->card->dev, sdiodev);
 593
 594                 atomic_set(&sdiodev->suspend, false);
 595         }
 596
 597         if (func->num == 2) {
 598                 sdiodev = dev_get_drvdata(&func->card->dev);
 599                 if ((!sdiodev) || (sdiodev->func[1]->card != func->card))
 600                         return -ENODEV;
 601                 sdiodev->func[2] = func;
 602
 603                 brcmf_cfg80211_sdio_func(func);
 604                 brcmf_dbg(TRACE, "F2 found, calling brcmf_sdio_probe...\n");
 605                 ret = brcmf_sdio_probe(sdiodev);
 606         }
 607
 608         return ret;
 609 }
 610
 611 static void brcmf_ops_sdio_remove(struct sdio_func *func)
 612 {
 613         struct brcmf_sdio_dev *sdiodev;
 614         brcmf_dbg(TRACE, "Enter\n");
 615         brcmf_dbg(INFO, "func->class=%x\n", func->class);
 616         brcmf_dbg(INFO, "sdio_vendor: 0x%04x\n", func->vendor);
 617         brcmf_dbg(INFO, "sdio_device: 0x%04x\n", func->device);
 618         brcmf_dbg(INFO, "Function#: 0x%04x\n", func->num);
 619
 620         if (func->num == 2) {
 621                 sdiodev = dev_get_drvdata(&func->card->dev);
 622                 brcmf_dbg(TRACE, "F2 found, calling brcmf_sdio_remove...\n");
 623                 brcmf_sdio_remove(sdiodev);
 624                 dev_set_drvdata(&func->card->dev, NULL);
 625                 kfree(sdiodev);
 626         }
 627 }
 628
 629
 630 #ifdef CONFIG_PM_SLEEP
 631 static int brcmf_sdio_suspend(struct device *dev)
 632 {
 633         mmc_pm_flag_t sdio_flags;
 634         struct brcmf_sdio_dev *sdiodev;
 635         struct sdio_func *func = dev_to_sdio_func(dev);
 636         int ret = 0;
 637
 638         brcmf_dbg(TRACE, "\n");
 639
 640         sdiodev = dev_get_drvdata(&func->card->dev);
 641
 642         atomic_set(&sdiodev->suspend, true);
 643
 644         sdio_flags = sdio_get_host_pm_caps(sdiodev->func[1]);
 645         if (!(sdio_flags & MMC_PM_KEEP_POWER)) {
 646                 brcmf_dbg(ERROR, "Host can't keep power while suspended\n");
 647                 return -EINVAL;
 648         }
 649
 650         ret = sdio_set_host_pm_flags(sdiodev->func[1], MMC_PM_KEEP_POWER);
 651         if (ret) {
 652                 brcmf_dbg(ERROR, "Failed to set pm_flags\n");
 653                 return ret;
 654         }
 655
 656         brcmf_sdio_wdtmr_enable(sdiodev, false);
 657
 658         return ret;
 659 }
 660
 661 static int brcmf_sdio_resume(struct device *dev)
 662 {
 663         struct brcmf_sdio_dev *sdiodev;
 664         struct sdio_func *func = dev_to_sdio_func(dev);
 665
 666         sdiodev = dev_get_drvdata(&func->card->dev);
 667         brcmf_sdio_wdtmr_enable(sdiodev, true);
 668         atomic_set(&sdiodev->suspend, false);
 669         return 0;
 670 }
 671 #endif          /* CONFIG_PM_SLEEP */
 672
 673 /*
 674  * module init
 675 */
 676 int brcmf_sdio_function_init(void)
 677 {
 678         int error = 0;
 679         brcmf_dbg(TRACE, "Enter\n");
 680
 681         error = sdio_register_driver(&brcmf_sdmmc_driver);
 682
 683         return error;
 684 }
 685
 686 /*
 687  * module cleanup
 688 */
 689 void brcmf_sdio_function_cleanup(void)
 690 {
 691         brcmf_dbg(TRACE, "Enter\n");
 692
 693         sdio_unregister_driver(&brcmf_sdmmc_driver);
 694 }