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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20 #include <linux/types.h>
21 #include <linux/netdevice.h>
22 #include <linux/export.h>
23 #include <linux/pci.h>
24 #include <linux/pci_ids.h>
25 #include <linux/sched.h>
26 #include <linux/completion.h>
27 #include <linux/mmc/sdio.h>
28 #include <linux/mmc/sdio_func.h>
29 #include <linux/mmc/card.h>
32 #include <brcm_hw_ids.h>
33 #include <brcmu_utils.h>
34 #include <brcmu_wifi.h>
38 #include "sdio_host.h"
40 #define SDIOH_API_ACCESS_RETRY_LIMIT 2
42 #ifdef CONFIG_BRCMFMAC_SDIO_OOB
43 static irqreturn_t
brcmf_sdio_irqhandler(int irq
, void *dev_id
)
45 struct brcmf_bus
*bus_if
= dev_get_drvdata(dev_id
);
46 struct brcmf_sdio_dev
*sdiodev
= bus_if
->bus_priv
.sdio
;
48 brcmf_dbg(INTR
, "oob intr triggered\n");
51 * out-of-band interrupt is level-triggered which won't
52 * be cleared until dpc
54 if (sdiodev
->irq_en
) {
55 disable_irq_nosync(irq
);
56 sdiodev
->irq_en
= false;
59 brcmf_sdbrcm_isr(sdiodev
->bus
);
64 int brcmf_sdio_intr_register(struct brcmf_sdio_dev
*sdiodev
)
70 brcmf_dbg(TRACE
, "Entering: irq %d\n", sdiodev
->irq
);
72 ret
= request_irq(sdiodev
->irq
, brcmf_sdio_irqhandler
,
73 sdiodev
->irq_flags
, "brcmf_oob_intr",
74 &sdiodev
->func
[1]->dev
);
77 spin_lock_init(&sdiodev
->irq_en_lock
);
78 spin_lock_irqsave(&sdiodev
->irq_en_lock
, flags
);
79 sdiodev
->irq_en
= true;
80 spin_unlock_irqrestore(&sdiodev
->irq_en_lock
, flags
);
82 ret
= enable_irq_wake(sdiodev
->irq
);
85 sdiodev
->irq_wake
= true;
87 sdio_claim_host(sdiodev
->func
[1]);
89 /* must configure SDIO_CCCR_IENx to enable irq */
90 data
= brcmf_sdio_regrb(sdiodev
, SDIO_CCCR_IENx
, &ret
);
91 data
|= 1 << SDIO_FUNC_1
| 1 << SDIO_FUNC_2
| 1;
92 brcmf_sdio_regwb(sdiodev
, SDIO_CCCR_IENx
, data
, &ret
);
94 /* redirect, configure and enable io for interrupt signal */
95 data
= SDIO_SEPINT_MASK
| SDIO_SEPINT_OE
;
96 if (sdiodev
->irq_flags
& IRQF_TRIGGER_HIGH
)
97 data
|= SDIO_SEPINT_ACT_HI
;
98 brcmf_sdio_regwb(sdiodev
, SDIO_CCCR_BRCM_SEPINT
, data
, &ret
);
100 sdio_release_host(sdiodev
->func
[1]);
105 int brcmf_sdio_intr_unregister(struct brcmf_sdio_dev
*sdiodev
)
107 brcmf_dbg(TRACE
, "Entering\n");
109 sdio_claim_host(sdiodev
->func
[1]);
110 brcmf_sdio_regwb(sdiodev
, SDIO_CCCR_BRCM_SEPINT
, 0, NULL
);
111 brcmf_sdio_regwb(sdiodev
, SDIO_CCCR_IENx
, 0, NULL
);
112 sdio_release_host(sdiodev
->func
[1]);
114 if (sdiodev
->irq_wake
) {
115 disable_irq_wake(sdiodev
->irq
);
116 sdiodev
->irq_wake
= false;
118 free_irq(sdiodev
->irq
, &sdiodev
->func
[1]->dev
);
119 sdiodev
->irq_en
= false;
123 #else /* CONFIG_BRCMFMAC_SDIO_OOB */
124 static void brcmf_sdio_irqhandler(struct sdio_func
*func
)
126 struct brcmf_bus
*bus_if
= dev_get_drvdata(&func
->dev
);
127 struct brcmf_sdio_dev
*sdiodev
= bus_if
->bus_priv
.sdio
;
129 brcmf_dbg(INTR
, "ib intr triggered\n");
131 brcmf_sdbrcm_isr(sdiodev
->bus
);
134 /* dummy handler for SDIO function 2 interrupt */
135 static void brcmf_sdio_dummy_irqhandler(struct sdio_func
*func
)
139 int brcmf_sdio_intr_register(struct brcmf_sdio_dev
*sdiodev
)
141 brcmf_dbg(TRACE
, "Entering\n");
143 sdio_claim_host(sdiodev
->func
[1]);
144 sdio_claim_irq(sdiodev
->func
[1], brcmf_sdio_irqhandler
);
145 sdio_claim_irq(sdiodev
->func
[2], brcmf_sdio_dummy_irqhandler
);
146 sdio_release_host(sdiodev
->func
[1]);
151 int brcmf_sdio_intr_unregister(struct brcmf_sdio_dev
*sdiodev
)
153 brcmf_dbg(TRACE
, "Entering\n");
155 sdio_claim_host(sdiodev
->func
[1]);
156 sdio_release_irq(sdiodev
->func
[2]);
157 sdio_release_irq(sdiodev
->func
[1]);
158 sdio_release_host(sdiodev
->func
[1]);
162 #endif /* CONFIG_BRCMFMAC_SDIO_OOB */
165 brcmf_sdcard_set_sbaddr_window(struct brcmf_sdio_dev
*sdiodev
, u32 address
)
171 addr
[0] = (address
>> 8) & SBSDIO_SBADDRLOW_MASK
;
172 addr
[1] = (address
>> 16) & SBSDIO_SBADDRMID_MASK
;
173 addr
[2] = (address
>> 24) & SBSDIO_SBADDRHIGH_MASK
;
175 for (i
= 0; i
< 3; i
++) {
179 usleep_range(1000, 2000);
180 err
= brcmf_sdioh_request_byte(sdiodev
, SDIOH_WRITE
,
181 SDIO_FUNC_1
, SBSDIO_FUNC1_SBADDRLOW
+ i
,
183 } while (err
!= 0 && retry
++ < SDIOH_API_ACCESS_RETRY_LIMIT
);
186 brcmf_err("failed at addr:0x%0x\n",
187 SBSDIO_FUNC1_SBADDRLOW
+ i
);
196 brcmf_sdio_regrw_helper(struct brcmf_sdio_dev
*sdiodev
, u32 addr
,
197 void *data
, bool write
)
199 u8 func_num
, reg_size
;
205 * figure out how to read the register based on address range
206 * 0x00 ~ 0x7FF: function 0 CCCR and FBR
207 * 0x10000 ~ 0x1FFFF: function 1 miscellaneous registers
208 * The rest: function 1 silicon backplane core registers
210 if ((addr
& ~REG_F0_REG_MASK
) == 0) {
211 func_num
= SDIO_FUNC_0
;
213 } else if ((addr
& ~REG_F1_MISC_MASK
) == 0) {
214 func_num
= SDIO_FUNC_1
;
217 func_num
= SDIO_FUNC_1
;
220 /* Set the window for SB core register */
221 bar
= addr
& ~SBSDIO_SB_OFT_ADDR_MASK
;
222 if (bar
!= sdiodev
->sbwad
) {
223 ret
= brcmf_sdcard_set_sbaddr_window(sdiodev
, bar
);
225 memset(data
, 0xFF, reg_size
);
228 sdiodev
->sbwad
= bar
;
230 addr
&= SBSDIO_SB_OFT_ADDR_MASK
;
231 addr
|= SBSDIO_SB_ACCESS_2_4B_FLAG
;
236 memset(data
, 0, reg_size
);
237 if (retry
) /* wait for 1 ms till bus get settled down */
238 usleep_range(1000, 2000);
240 ret
= brcmf_sdioh_request_byte(sdiodev
, write
,
241 func_num
, addr
, data
);
243 ret
= brcmf_sdioh_request_word(sdiodev
, write
,
244 func_num
, addr
, data
, 4);
245 } while (ret
!= 0 && retry
++ < SDIOH_API_ACCESS_RETRY_LIMIT
);
248 brcmf_err("failed with %d\n", ret
);
253 u8
brcmf_sdio_regrb(struct brcmf_sdio_dev
*sdiodev
, u32 addr
, int *ret
)
258 brcmf_dbg(INFO
, "addr:0x%08x\n", addr
);
259 retval
= brcmf_sdio_regrw_helper(sdiodev
, addr
, &data
, false);
260 brcmf_dbg(INFO
, "data:0x%02x\n", data
);
268 u32
brcmf_sdio_regrl(struct brcmf_sdio_dev
*sdiodev
, u32 addr
, int *ret
)
273 brcmf_dbg(INFO
, "addr:0x%08x\n", addr
);
274 retval
= brcmf_sdio_regrw_helper(sdiodev
, addr
, &data
, false);
275 brcmf_dbg(INFO
, "data:0x%08x\n", data
);
283 void brcmf_sdio_regwb(struct brcmf_sdio_dev
*sdiodev
, u32 addr
,
288 brcmf_dbg(INFO
, "addr:0x%08x, data:0x%02x\n", addr
, data
);
289 retval
= brcmf_sdio_regrw_helper(sdiodev
, addr
, &data
, true);
295 void brcmf_sdio_regwl(struct brcmf_sdio_dev
*sdiodev
, u32 addr
,
300 brcmf_dbg(INFO
, "addr:0x%08x, data:0x%08x\n", addr
, data
);
301 retval
= brcmf_sdio_regrw_helper(sdiodev
, addr
, &data
, true);
307 static int brcmf_sdcard_recv_prepare(struct brcmf_sdio_dev
*sdiodev
, uint fn
,
308 uint flags
, uint width
, u32
*addr
)
310 uint bar0
= *addr
& ~SBSDIO_SB_OFT_ADDR_MASK
;
313 /* Async not implemented yet */
314 if (flags
& SDIO_REQ_ASYNC
)
317 if (bar0
!= sdiodev
->sbwad
) {
318 err
= brcmf_sdcard_set_sbaddr_window(sdiodev
, bar0
);
322 sdiodev
->sbwad
= bar0
;
325 *addr
&= SBSDIO_SB_OFT_ADDR_MASK
;
328 *addr
|= SBSDIO_SB_ACCESS_2_4B_FLAG
;
334 brcmf_sdcard_recv_buf(struct brcmf_sdio_dev
*sdiodev
, u32 addr
, uint fn
,
335 uint flags
, u8
*buf
, uint nbytes
)
337 struct sk_buff
*mypkt
;
340 mypkt
= brcmu_pkt_buf_get_skb(nbytes
);
342 brcmf_err("brcmu_pkt_buf_get_skb failed: len %d\n",
347 err
= brcmf_sdcard_recv_pkt(sdiodev
, addr
, fn
, flags
, mypkt
);
349 memcpy(buf
, mypkt
->data
, nbytes
);
351 brcmu_pkt_buf_free_skb(mypkt
);
356 brcmf_sdcard_recv_pkt(struct brcmf_sdio_dev
*sdiodev
, u32 addr
, uint fn
,
357 uint flags
, struct sk_buff
*pkt
)
363 brcmf_dbg(INFO
, "fun = %d, addr = 0x%x, size = %d\n",
366 width
= (flags
& SDIO_REQ_4BYTE
) ? 4 : 2;
367 err
= brcmf_sdcard_recv_prepare(sdiodev
, fn
, flags
, width
, &addr
);
371 incr_fix
= (flags
& SDIO_REQ_FIXED
) ? SDIOH_DATA_FIX
: SDIOH_DATA_INC
;
372 err
= brcmf_sdioh_request_buffer(sdiodev
, incr_fix
, SDIOH_READ
,
379 int brcmf_sdcard_recv_chain(struct brcmf_sdio_dev
*sdiodev
, u32 addr
, uint fn
,
380 uint flags
, struct sk_buff_head
*pktq
)
386 brcmf_dbg(INFO
, "fun = %d, addr = 0x%x, size = %d\n",
387 fn
, addr
, pktq
->qlen
);
389 width
= (flags
& SDIO_REQ_4BYTE
) ? 4 : 2;
390 err
= brcmf_sdcard_recv_prepare(sdiodev
, fn
, flags
, width
, &addr
);
394 incr_fix
= (flags
& SDIO_REQ_FIXED
) ? SDIOH_DATA_FIX
: SDIOH_DATA_INC
;
395 err
= brcmf_sdioh_request_chain(sdiodev
, incr_fix
, SDIOH_READ
, fn
, addr
,
403 brcmf_sdcard_send_buf(struct brcmf_sdio_dev
*sdiodev
, u32 addr
, uint fn
,
404 uint flags
, u8
*buf
, uint nbytes
)
406 struct sk_buff
*mypkt
;
409 mypkt
= brcmu_pkt_buf_get_skb(nbytes
);
411 brcmf_err("brcmu_pkt_buf_get_skb failed: len %d\n",
416 memcpy(mypkt
->data
, buf
, nbytes
);
417 err
= brcmf_sdcard_send_pkt(sdiodev
, addr
, fn
, flags
, mypkt
);
419 brcmu_pkt_buf_free_skb(mypkt
);
425 brcmf_sdcard_send_pkt(struct brcmf_sdio_dev
*sdiodev
, u32 addr
, uint fn
,
426 uint flags
, struct sk_buff
*pkt
)
430 uint bar0
= addr
& ~SBSDIO_SB_OFT_ADDR_MASK
;
433 brcmf_dbg(INFO
, "fun = %d, addr = 0x%x, size = %d\n",
436 /* Async not implemented yet */
437 if (flags
& SDIO_REQ_ASYNC
)
440 if (bar0
!= sdiodev
->sbwad
) {
441 err
= brcmf_sdcard_set_sbaddr_window(sdiodev
, bar0
);
445 sdiodev
->sbwad
= bar0
;
448 addr
&= SBSDIO_SB_OFT_ADDR_MASK
;
450 incr_fix
= (flags
& SDIO_REQ_FIXED
) ? SDIOH_DATA_FIX
: SDIOH_DATA_INC
;
451 width
= (flags
& SDIO_REQ_4BYTE
) ? 4 : 2;
453 addr
|= SBSDIO_SB_ACCESS_2_4B_FLAG
;
455 err
= brcmf_sdioh_request_buffer(sdiodev
, incr_fix
, SDIOH_WRITE
, fn
,
462 int brcmf_sdcard_rwdata(struct brcmf_sdio_dev
*sdiodev
, uint rw
, u32 addr
,
463 u8
*buf
, uint nbytes
)
465 struct sk_buff
*mypkt
;
466 bool write
= rw
? SDIOH_WRITE
: SDIOH_READ
;
469 addr
&= SBSDIO_SB_OFT_ADDR_MASK
;
470 addr
|= SBSDIO_SB_ACCESS_2_4B_FLAG
;
472 mypkt
= brcmu_pkt_buf_get_skb(nbytes
);
474 brcmf_err("brcmu_pkt_buf_get_skb failed: len %d\n",
479 /* For a write, copy the buffer data into the packet. */
481 memcpy(mypkt
->data
, buf
, nbytes
);
483 err
= brcmf_sdioh_request_buffer(sdiodev
, SDIOH_DATA_INC
, write
,
484 SDIO_FUNC_1
, addr
, mypkt
);
486 /* For a read, copy the packet data back to the buffer. */
488 memcpy(buf
, mypkt
->data
, nbytes
);
490 brcmu_pkt_buf_free_skb(mypkt
);
494 int brcmf_sdcard_abort(struct brcmf_sdio_dev
*sdiodev
, uint fn
)
496 char t_func
= (char)fn
;
497 brcmf_dbg(TRACE
, "Enter\n");
499 /* issue abort cmd52 command through F0 */
500 brcmf_sdioh_request_byte(sdiodev
, SDIOH_WRITE
, SDIO_FUNC_0
,
501 SDIO_CCCR_ABORT
, &t_func
);
503 brcmf_dbg(TRACE
, "Exit\n");
507 int brcmf_sdio_probe(struct brcmf_sdio_dev
*sdiodev
)
512 ret
= brcmf_sdioh_attach(sdiodev
);
518 /* try to attach to the target device */
519 sdiodev
->bus
= brcmf_sdbrcm_probe(regs
, sdiodev
);
521 brcmf_err("device attach failed\n");
528 brcmf_sdio_remove(sdiodev
);
532 EXPORT_SYMBOL(brcmf_sdio_probe
);
534 int brcmf_sdio_remove(struct brcmf_sdio_dev
*sdiodev
)
536 sdiodev
->bus_if
->state
= BRCMF_BUS_DOWN
;
539 brcmf_sdbrcm_disconnect(sdiodev
->bus
);
543 brcmf_sdioh_detach(sdiodev
);
549 EXPORT_SYMBOL(brcmf_sdio_remove
);
551 void brcmf_sdio_wdtmr_enable(struct brcmf_sdio_dev
*sdiodev
, bool enable
)
554 brcmf_sdbrcm_wd_timer(sdiodev
->bus
, BRCMF_WD_POLL_MS
);
556 brcmf_sdbrcm_wd_timer(sdiodev
->bus
, 0);