2 * Copyright (c) 2010 Broadcom Corporation
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.
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.
16 /* ****************** SDIO CARD Interface Functions **************************/
18 #include <linux/types.h>
19 #include <linux/netdevice.h>
20 #include <linux/export.h>
21 #include <linux/pci.h>
22 #include <linux/pci_ids.h>
23 #include <linux/sched.h>
24 #include <linux/completion.h>
25 #include <linux/mmc/sdio.h>
26 #include <linux/mmc/sdio_func.h>
27 #include <linux/mmc/card.h>
30 #include <brcm_hw_ids.h>
31 #include <brcmu_utils.h>
32 #include <brcmu_wifi.h>
36 #include "sdio_host.h"
38 #define SDIOH_API_ACCESS_RETRY_LIMIT 2
40 #ifdef CONFIG_BRCMFMAC_SDIO_OOB
41 static irqreturn_t brcmf_sdio_irqhandler(int irq, void *dev_id)
43 struct brcmf_bus *bus_if = dev_get_drvdata(dev_id);
44 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
46 brcmf_dbg(INTR, "oob intr triggered\n");
49 * out-of-band interrupt is level-triggered which won't
50 * be cleared until dpc
52 if (sdiodev->irq_en) {
53 disable_irq_nosync(irq);
54 sdiodev->irq_en = false;
57 brcmf_sdbrcm_isr(sdiodev->bus);
62 int brcmf_sdio_intr_register(struct brcmf_sdio_dev *sdiodev)
68 brcmf_dbg(TRACE, "Entering: irq %d\n", sdiodev->irq);
70 ret = request_irq(sdiodev->irq, brcmf_sdio_irqhandler,
71 sdiodev->irq_flags, "brcmf_oob_intr",
72 &sdiodev->func[1]->dev);
75 spin_lock_init(&sdiodev->irq_en_lock);
76 spin_lock_irqsave(&sdiodev->irq_en_lock, flags);
77 sdiodev->irq_en = true;
78 spin_unlock_irqrestore(&sdiodev->irq_en_lock, flags);
80 ret = enable_irq_wake(sdiodev->irq);
83 sdiodev->irq_wake = true;
85 sdio_claim_host(sdiodev->func[1]);
87 /* must configure SDIO_CCCR_IENx to enable irq */
88 data = brcmf_sdio_regrb(sdiodev, SDIO_CCCR_IENx, &ret);
89 data |= 1 << SDIO_FUNC_1 | 1 << SDIO_FUNC_2 | 1;
90 brcmf_sdio_regwb(sdiodev, SDIO_CCCR_IENx, data, &ret);
92 /* redirect, configure and enable io for interrupt signal */
93 data = SDIO_SEPINT_MASK | SDIO_SEPINT_OE;
94 if (sdiodev->irq_flags & IRQF_TRIGGER_HIGH)
95 data |= SDIO_SEPINT_ACT_HI;
96 brcmf_sdio_regwb(sdiodev, SDIO_CCCR_BRCM_SEPINT, data, &ret);
98 sdio_release_host(sdiodev->func[1]);
103 int brcmf_sdio_intr_unregister(struct brcmf_sdio_dev *sdiodev)
105 brcmf_dbg(TRACE, "Entering\n");
107 sdio_claim_host(sdiodev->func[1]);
108 brcmf_sdio_regwb(sdiodev, SDIO_CCCR_BRCM_SEPINT, 0, NULL);
109 brcmf_sdio_regwb(sdiodev, SDIO_CCCR_IENx, 0, NULL);
110 sdio_release_host(sdiodev->func[1]);
112 if (sdiodev->irq_wake) {
113 disable_irq_wake(sdiodev->irq);
114 sdiodev->irq_wake = false;
116 free_irq(sdiodev->irq, &sdiodev->func[1]->dev);
117 sdiodev->irq_en = false;
121 #else /* CONFIG_BRCMFMAC_SDIO_OOB */
122 static void brcmf_sdio_irqhandler(struct sdio_func *func)
124 struct brcmf_bus *bus_if = dev_get_drvdata(&func->dev);
125 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
127 brcmf_dbg(INTR, "ib intr triggered\n");
129 brcmf_sdbrcm_isr(sdiodev->bus);
132 /* dummy handler for SDIO function 2 interrupt */
133 static void brcmf_sdio_dummy_irqhandler(struct sdio_func *func)
137 int brcmf_sdio_intr_register(struct brcmf_sdio_dev *sdiodev)
139 brcmf_dbg(TRACE, "Entering\n");
141 sdio_claim_host(sdiodev->func[1]);
142 sdio_claim_irq(sdiodev->func[1], brcmf_sdio_irqhandler);
143 sdio_claim_irq(sdiodev->func[2], brcmf_sdio_dummy_irqhandler);
144 sdio_release_host(sdiodev->func[1]);
149 int brcmf_sdio_intr_unregister(struct brcmf_sdio_dev *sdiodev)
151 brcmf_dbg(TRACE, "Entering\n");
153 sdio_claim_host(sdiodev->func[1]);
154 sdio_release_irq(sdiodev->func[2]);
155 sdio_release_irq(sdiodev->func[1]);
156 sdio_release_host(sdiodev->func[1]);
160 #endif /* CONFIG_BRCMFMAC_SDIO_OOB */
163 brcmf_sdcard_set_sbaddr_window(struct brcmf_sdio_dev *sdiodev, u32 address)
169 addr[0] = (address >> 8) & SBSDIO_SBADDRLOW_MASK;
170 addr[1] = (address >> 16) & SBSDIO_SBADDRMID_MASK;
171 addr[2] = (address >> 24) & SBSDIO_SBADDRHIGH_MASK;
173 for (i = 0; i < 3; i++) {
177 usleep_range(1000, 2000);
178 err = brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE,
179 SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRLOW + i,
181 } while (err != 0 && retry++ < SDIOH_API_ACCESS_RETRY_LIMIT);
184 brcmf_err("failed at addr:0x%0x\n",
185 SBSDIO_FUNC1_SBADDRLOW + i);
194 brcmf_sdio_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr,
195 void *data, bool write)
197 u8 func_num, reg_size;
203 * figure out how to read the register based on address range
204 * 0x00 ~ 0x7FF: function 0 CCCR and FBR
205 * 0x10000 ~ 0x1FFFF: function 1 miscellaneous registers
206 * The rest: function 1 silicon backplane core registers
208 if ((addr & ~REG_F0_REG_MASK) == 0) {
209 func_num = SDIO_FUNC_0;
211 } else if ((addr & ~REG_F1_MISC_MASK) == 0) {
212 func_num = SDIO_FUNC_1;
215 func_num = SDIO_FUNC_1;
218 /* Set the window for SB core register */
219 bar = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
220 if (bar != sdiodev->sbwad) {
221 ret = brcmf_sdcard_set_sbaddr_window(sdiodev, bar);
223 memset(data, 0xFF, reg_size);
226 sdiodev->sbwad = bar;
228 addr &= SBSDIO_SB_OFT_ADDR_MASK;
229 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
234 memset(data, 0, reg_size);
235 if (retry) /* wait for 1 ms till bus get settled down */
236 usleep_range(1000, 2000);
238 ret = brcmf_sdioh_request_byte(sdiodev, write,
239 func_num, addr, data);
241 ret = brcmf_sdioh_request_word(sdiodev, write,
242 func_num, addr, data, 4);
243 } while (ret != 0 && retry++ < SDIOH_API_ACCESS_RETRY_LIMIT);
246 brcmf_err("failed with %d\n", ret);
251 u8 brcmf_sdio_regrb(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
256 brcmf_dbg(INFO, "addr:0x%08x\n", addr);
257 retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, false);
258 brcmf_dbg(INFO, "data:0x%02x\n", data);
266 u32 brcmf_sdio_regrl(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
271 brcmf_dbg(INFO, "addr:0x%08x\n", addr);
272 retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, false);
273 brcmf_dbg(INFO, "data:0x%08x\n", data);
281 void brcmf_sdio_regwb(struct brcmf_sdio_dev *sdiodev, u32 addr,
286 brcmf_dbg(INFO, "addr:0x%08x, data:0x%02x\n", addr, data);
287 retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, true);
293 void brcmf_sdio_regwl(struct brcmf_sdio_dev *sdiodev, u32 addr,
298 brcmf_dbg(INFO, "addr:0x%08x, data:0x%08x\n", addr, data);
299 retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, true);
305 static int brcmf_sdcard_recv_prepare(struct brcmf_sdio_dev *sdiodev, uint fn,
306 uint flags, uint width, u32 *addr)
308 uint bar0 = *addr & ~SBSDIO_SB_OFT_ADDR_MASK;
311 /* Async not implemented yet */
312 if (flags & SDIO_REQ_ASYNC)
315 if (bar0 != sdiodev->sbwad) {
316 err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0);
320 sdiodev->sbwad = bar0;
323 *addr &= SBSDIO_SB_OFT_ADDR_MASK;
326 *addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
332 brcmf_sdcard_recv_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
333 uint flags, u8 *buf, uint nbytes)
335 struct sk_buff *mypkt;
338 mypkt = brcmu_pkt_buf_get_skb(nbytes);
340 brcmf_err("brcmu_pkt_buf_get_skb failed: len %d\n",
345 err = brcmf_sdcard_recv_pkt(sdiodev, addr, fn, flags, mypkt);
347 memcpy(buf, mypkt->data, nbytes);
349 brcmu_pkt_buf_free_skb(mypkt);
354 brcmf_sdcard_recv_pkt(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
355 uint flags, struct sk_buff *pkt)
361 brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n",
364 width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
365 err = brcmf_sdcard_recv_prepare(sdiodev, fn, flags, width, &addr);
369 incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
370 err = brcmf_sdioh_request_buffer(sdiodev, incr_fix, SDIOH_READ,
377 int brcmf_sdcard_recv_chain(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
378 uint flags, struct sk_buff_head *pktq)
384 brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n",
385 fn, addr, pktq->qlen);
387 width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
388 err = brcmf_sdcard_recv_prepare(sdiodev, fn, flags, width, &addr);
392 incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
393 err = brcmf_sdioh_request_chain(sdiodev, incr_fix, SDIOH_READ, fn, addr,
401 brcmf_sdcard_send_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
402 uint flags, u8 *buf, uint nbytes)
404 struct sk_buff *mypkt;
407 mypkt = brcmu_pkt_buf_get_skb(nbytes);
409 brcmf_err("brcmu_pkt_buf_get_skb failed: len %d\n",
414 memcpy(mypkt->data, buf, nbytes);
415 err = brcmf_sdcard_send_pkt(sdiodev, addr, fn, flags, mypkt);
417 brcmu_pkt_buf_free_skb(mypkt);
423 brcmf_sdcard_send_pkt(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
424 uint flags, struct sk_buff *pkt)
428 uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
431 brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n",
434 /* Async not implemented yet */
435 if (flags & SDIO_REQ_ASYNC)
438 if (bar0 != sdiodev->sbwad) {
439 err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0);
443 sdiodev->sbwad = bar0;
446 addr &= SBSDIO_SB_OFT_ADDR_MASK;
448 incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
449 width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
451 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
453 err = brcmf_sdioh_request_buffer(sdiodev, incr_fix, SDIOH_WRITE, fn,
460 int brcmf_sdcard_rwdata(struct brcmf_sdio_dev *sdiodev, uint rw, u32 addr,
461 u8 *buf, uint nbytes)
463 struct sk_buff *mypkt;
464 bool write = rw ? SDIOH_WRITE : SDIOH_READ;
467 addr &= SBSDIO_SB_OFT_ADDR_MASK;
468 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
470 mypkt = brcmu_pkt_buf_get_skb(nbytes);
472 brcmf_err("brcmu_pkt_buf_get_skb failed: len %d\n",
477 /* For a write, copy the buffer data into the packet. */
479 memcpy(mypkt->data, buf, nbytes);
481 err = brcmf_sdioh_request_buffer(sdiodev, SDIOH_DATA_INC, write,
482 SDIO_FUNC_1, addr, mypkt);
484 /* For a read, copy the packet data back to the buffer. */
486 memcpy(buf, mypkt->data, nbytes);
488 brcmu_pkt_buf_free_skb(mypkt);
492 int brcmf_sdcard_abort(struct brcmf_sdio_dev *sdiodev, uint fn)
494 char t_func = (char)fn;
495 brcmf_dbg(TRACE, "Enter\n");
497 /* issue abort cmd52 command through F0 */
498 brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE, SDIO_FUNC_0,
499 SDIO_CCCR_ABORT, &t_func);
501 brcmf_dbg(TRACE, "Exit\n");
505 int brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev)
510 ret = brcmf_sdioh_attach(sdiodev);
516 /* try to attach to the target device */
517 sdiodev->bus = brcmf_sdbrcm_probe(regs, sdiodev);
519 brcmf_err("device attach failed\n");
526 brcmf_sdio_remove(sdiodev);
530 EXPORT_SYMBOL(brcmf_sdio_probe);
532 int brcmf_sdio_remove(struct brcmf_sdio_dev *sdiodev)
534 sdiodev->bus_if->state = BRCMF_BUS_DOWN;
537 brcmf_sdbrcm_disconnect(sdiodev->bus);
541 brcmf_sdioh_detach(sdiodev);
547 EXPORT_SYMBOL(brcmf_sdio_remove);
549 void brcmf_sdio_wdtmr_enable(struct brcmf_sdio_dev *sdiodev, bool enable)
552 brcmf_sdbrcm_wd_timer(sdiodev->bus, BRCMF_WD_POLL_MS);
554 brcmf_sdbrcm_wd_timer(sdiodev->bus, 0);