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