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 1323