projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
brcmfmac: use one list of event defintions
[deliverable/linux.git] / drivers / net / wireless / brcm80211 / brcmfmac / bcmsdh.c
CommitLineData
5b435de0
AS		 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
02f77195
JP		 18#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
19
5b435de0
AS		 20#include <linux/types.h>
21#include <linux/netdevice.h>
ee40fa06 22#include <linux/export.h>
5b435de0
AS		 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>
30
31#include <defs.h>
32#include <brcm_hw_ids.h>
33#include <brcmu_utils.h>
34#include <brcmu_wifi.h>
35#include <soc.h>
5b435de0
AS		 36#include "dhd_bus.h"
37#include "dhd_dbg.h"
38#include "sdio_host.h"
39
40#define SDIOH_API_ACCESS_RETRY_LIMIT 2
41
ba89bf19
FL		 42#ifdef CONFIG_BRCMFMAC_SDIO_OOB
43static irqreturn_t brcmf_sdio_irqhandler(int irq, void *dev_id)
44{
5b3c1832
HM		 45 struct brcmf_bus *bus_if = dev_get_drvdata(dev_id);
46 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
ba89bf19
FL		 47
48 brcmf_dbg(INTR, "oob intr triggered\n");
49
50 /*
51 * out-of-band interrupt is level-triggered which won't
52 * be cleared until dpc
53 */
54 if (sdiodev->irq_en) {
55 disable_irq_nosync(irq);
56 sdiodev->irq_en = false;
57 }
58
59 brcmf_sdbrcm_isr(sdiodev->bus);
60
61 return IRQ_HANDLED;
62}
63
64int brcmf_sdio_intr_register(struct brcmf_sdio_dev *sdiodev)
65{
66 int ret = 0;
67 u8 data;
68 unsigned long flags;
69
70 brcmf_dbg(TRACE, "Entering\n");
71
72 brcmf_dbg(ERROR, "requesting irq %d\n", sdiodev->irq);
73 ret = request_irq(sdiodev->irq, brcmf_sdio_irqhandler,
74 sdiodev->irq_flags, "brcmf_oob_intr",
5b3c1832 75 &sdiodev->func[1]->dev);
ba89bf19
FL		 76 if (ret != 0)
77 return ret;
78 spin_lock_init(&sdiodev->irq_en_lock);
79 spin_lock_irqsave(&sdiodev->irq_en_lock, flags);
80 sdiodev->irq_en = true;
81 spin_unlock_irqrestore(&sdiodev->irq_en_lock, flags);
82
83 ret = enable_irq_wake(sdiodev->irq);
84 if (ret != 0)
85 return ret;
86 sdiodev->irq_wake = true;
87
38b0b0dd
FL		 88 sdio_claim_host(sdiodev->func[1]);
89
ba89bf19 90 /* must configure SDIO_CCCR_IENx to enable irq */
45db339c 91 data = brcmf_sdio_regrb(sdiodev, SDIO_CCCR_IENx, &ret);
ba89bf19 92 data |= 1 << SDIO_FUNC_1 | 1 << SDIO_FUNC_2 | 1;
3bba829f 93 brcmf_sdio_regwb(sdiodev, SDIO_CCCR_IENx, data, &ret);
ba89bf19 94
f304a993 95 /* redirect, configure and enable io for interrupt signal */
ba89bf19 96 data = SDIO_SEPINT_MASK | SDIO_SEPINT_OE;
f304a993 97 if (sdiodev->irq_flags & IRQF_TRIGGER_HIGH)
ba89bf19 98 data |= SDIO_SEPINT_ACT_HI;
3bba829f 99 brcmf_sdio_regwb(sdiodev, SDIO_CCCR_BRCM_SEPINT, data, &ret);
ba89bf19 100
38b0b0dd
FL		 101 sdio_release_host(sdiodev->func[1]);
102
ba89bf19
FL		 103 return 0;
104}
105
106int brcmf_sdio_intr_unregister(struct brcmf_sdio_dev *sdiodev)
107{
108 brcmf_dbg(TRACE, "Entering\n");
109
38b0b0dd 110 sdio_claim_host(sdiodev->func[1]);
3bba829f
FL		 111 brcmf_sdio_regwb(sdiodev, SDIO_CCCR_BRCM_SEPINT, 0, NULL);
112 brcmf_sdio_regwb(sdiodev, SDIO_CCCR_IENx, 0, NULL);
38b0b0dd 113 sdio_release_host(sdiodev->func[1]);
ba89bf19
FL		 114
115 if (sdiodev->irq_wake) {
116 disable_irq_wake(sdiodev->irq);
117 sdiodev->irq_wake = false;
118 }
5b3c1832 119 free_irq(sdiodev->irq, &sdiodev->func[1]->dev);
ba89bf19
FL		 120 sdiodev->irq_en = false;
121
122 return 0;
123}
124#else /* CONFIG_BRCMFMAC_SDIO_OOB */
125static void brcmf_sdio_irqhandler(struct sdio_func *func)
5b435de0 126{
5b3c1832
HM		 127 struct brcmf_bus *bus_if = dev_get_drvdata(&func->dev);
128 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
5b435de0 129
ba89bf19 130 brcmf_dbg(INTR, "ib intr triggered\n");
5b435de0 131
5b435de0 132 brcmf_sdbrcm_isr(sdiodev->bus);
5b435de0
AS		 133}
134
fbf59108 135/* dummy handler for SDIO function 2 interrupt */
ba89bf19 136static void brcmf_sdio_dummy_irqhandler(struct sdio_func *func)
fbf59108
FL		 137{
138}
139
ba89bf19 140int brcmf_sdio_intr_register(struct brcmf_sdio_dev *sdiodev)
5b435de0
AS		 141{
142 brcmf_dbg(TRACE, "Entering\n");
143
144 sdio_claim_host(sdiodev->func[1]);
ba89bf19
FL		 145 sdio_claim_irq(sdiodev->func[1], brcmf_sdio_irqhandler);
146 sdio_claim_irq(sdiodev->func[2], brcmf_sdio_dummy_irqhandler);
5b435de0
AS		 147 sdio_release_host(sdiodev->func[1]);
148
149 return 0;
150}
151
ba89bf19 152int brcmf_sdio_intr_unregister(struct brcmf_sdio_dev *sdiodev)
5b435de0
AS		 153{
154 brcmf_dbg(TRACE, "Entering\n");
155
156 sdio_claim_host(sdiodev->func[1]);
fbf59108 157 sdio_release_irq(sdiodev->func[2]);
5b435de0
AS		 158 sdio_release_irq(sdiodev->func[1]);
159 sdio_release_host(sdiodev->func[1]);
160
161 return 0;
162}
ba89bf19 163#endif /* CONFIG_BRCMFMAC_SDIO_OOB */
5b435de0 164
5b435de0
AS		 165int
166brcmf_sdcard_set_sbaddr_window(struct brcmf_sdio_dev *sdiodev, u32 address)
167{
7d9cfc28
FL		 168 int err = 0, i;
169 u8 addr[3];
170 s32 retry;
171
172 addr[0] = (address >> 8) & SBSDIO_SBADDRLOW_MASK;
173 addr[1] = (address >> 16) & SBSDIO_SBADDRMID_MASK;
174 addr[2] = (address >> 24) & SBSDIO_SBADDRHIGH_MASK;
175
176 for (i = 0; i < 3; i++) {
177 retry = 0;
178 do {
179 if (retry)
180 usleep_range(1000, 2000);
181 err = brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE,
182 SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRLOW + i,
183 &addr[i]);
184 } while (err != 0 && retry++ < SDIOH_API_ACCESS_RETRY_LIMIT);
185
186 if (err) {
187 brcmf_dbg(ERROR, "failed at addr:0x%0x\n",
188 SBSDIO_FUNC1_SBADDRLOW + i);
189 break;
190 }
191 }
5b435de0
AS		 192
193 return err;
194}
195
4531603a 196int
e9b8d91d
FL		 197brcmf_sdio_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr,
198 void *data, bool write)
199{
200 u8 func_num, reg_size;
201 u32 bar;
202 s32 retry = 0;
203 int ret;
204
205 /*
206 * figure out how to read the register based on address range
d8b3fc59 207 * 0x00 ~ 0x7FF: function 0 CCCR and FBR
e9b8d91d
FL		 208 * 0x10000 ~ 0x1FFFF: function 1 miscellaneous registers
209 * The rest: function 1 silicon backplane core registers
210 */
d8b3fc59 211 if ((addr & ~REG_F0_REG_MASK) == 0) {
e9b8d91d
FL		 212 func_num = SDIO_FUNC_0;
213 reg_size = 1;
214 } else if ((addr & ~REG_F1_MISC_MASK) == 0) {
215 func_num = SDIO_FUNC_1;
216 reg_size = 1;
217 } else {
218 func_num = SDIO_FUNC_1;
219 reg_size = 4;
220
221 /* Set the window for SB core register */
222 bar = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
223 if (bar != sdiodev->sbwad) {
224 ret = brcmf_sdcard_set_sbaddr_window(sdiodev, bar);
225 if (ret != 0) {
226 memset(data, 0xFF, reg_size);
227 return ret;
228 }
229 sdiodev->sbwad = bar;
230 }
231 addr &= SBSDIO_SB_OFT_ADDR_MASK;
232 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
233 }
234
235 do {
236 if (!write)
237 memset(data, 0, reg_size);
238 if (retry) /* wait for 1 ms till bus get settled down */
239 usleep_range(1000, 2000);
240 if (reg_size == 1)
241 ret = brcmf_sdioh_request_byte(sdiodev, write,
242 func_num, addr, data);
243 else
244 ret = brcmf_sdioh_request_word(sdiodev, write,
245 func_num, addr, data, 4);
246 } while (ret != 0 && retry++ < SDIOH_API_ACCESS_RETRY_LIMIT);
247
5c15c23a 248 if (ret != 0)
e9b8d91d
FL		 249 brcmf_dbg(ERROR, "failed with %d\n", ret);
250
251 return ret;
252}
253
254u8 brcmf_sdio_regrb(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
255{
256 u8 data;
257 int retval;
258
259 brcmf_dbg(INFO, "addr:0x%08x\n", addr);
260 retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, false);
261 brcmf_dbg(INFO, "data:0x%02x\n", data);
262
263 if (ret)
264 *ret = retval;
265
266 return data;
267}
268
269u32 brcmf_sdio_regrl(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
270{
271 u32 data;
272 int retval;
273
274 brcmf_dbg(INFO, "addr:0x%08x\n", addr);
275 retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, false);
276 brcmf_dbg(INFO, "data:0x%08x\n", data);
277
278 if (ret)
279 *ret = retval;
280
281 return data;
282}
283
284void brcmf_sdio_regwb(struct brcmf_sdio_dev *sdiodev, u32 addr,
285 u8 data, int *ret)
286{
287 int retval;
288
289 brcmf_dbg(INFO, "addr:0x%08x, data:0x%02x\n", addr, data);
290 retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, true);
291
292 if (ret)
293 *ret = retval;
294}
295
296void brcmf_sdio_regwl(struct brcmf_sdio_dev *sdiodev, u32 addr,
297 u32 data, int *ret)
298{
299 int retval;
300
301 brcmf_dbg(INFO, "addr:0x%08x, data:0x%08x\n", addr, data);
302 retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, true);
303
304 if (ret)
305 *ret = retval;
306}
307
5adfeb63
AS		 308static int brcmf_sdcard_recv_prepare(struct brcmf_sdio_dev *sdiodev, uint fn,
309 uint flags, uint width, u32 *addr)
5b435de0 310{
5adfeb63 311 uint bar0 = *addr & ~SBSDIO_SB_OFT_ADDR_MASK;
5b435de0
AS		 312 int err = 0;
313
5b435de0
AS		 314 /* Async not implemented yet */
315 if (flags & SDIO_REQ_ASYNC)
316 return -ENOTSUPP;
317
318 if (bar0 != sdiodev->sbwad) {
319 err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0);
320 if (err)
321 return err;
322
323 sdiodev->sbwad = bar0;
324 }
325
5adfeb63
AS		 326 *addr &= SBSDIO_SB_OFT_ADDR_MASK;
327
328 if (width == 4)
329 *addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
330
331 return 0;
332}
333
334int
335brcmf_sdcard_recv_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
336 uint flags, u8 *buf, uint nbytes)
337{
338 struct sk_buff *mypkt;
339 int err;
340
341 mypkt = brcmu_pkt_buf_get_skb(nbytes);
342 if (!mypkt) {
343 brcmf_dbg(ERROR, "brcmu_pkt_buf_get_skb failed: len %d\n",
344 nbytes);
345 return -EIO;
346 }
347
348 err = brcmf_sdcard_recv_pkt(sdiodev, addr, fn, flags, mypkt);
349 if (!err)
350 memcpy(buf, mypkt->data, nbytes);
351
352 brcmu_pkt_buf_free_skb(mypkt);
353 return err;
354}
355
356int
357brcmf_sdcard_recv_pkt(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
358 uint flags, struct sk_buff *pkt)
359{
360 uint incr_fix;
361 uint width;
362 int err = 0;
363
364 brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n",
365 fn, addr, pkt->len);
366
367 width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
368 err = brcmf_sdcard_recv_prepare(sdiodev, fn, flags, width, &addr);
369 if (err)
7057fd00 370 goto done;
5b435de0
AS		 371
372 incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
5adfeb63 373 err = brcmf_sdioh_request_buffer(sdiodev, incr_fix, SDIOH_READ,
4c6e869d 374 fn, addr, pkt);
5adfeb63 375
7057fd00 376done:
5adfeb63
AS		 377 return err;
378}
379
380int brcmf_sdcard_recv_chain(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
381 uint flags, struct sk_buff_head *pktq)
382{
383 uint incr_fix;
384 uint width;
385 int err = 0;
386
387 brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n",
388 fn, addr, pktq->qlen);
389
5b435de0 390 width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
5adfeb63
AS		 391 err = brcmf_sdcard_recv_prepare(sdiodev, fn, flags, width, &addr);
392 if (err)
7057fd00 393 goto done;
5b435de0 394
5adfeb63
AS		 395 incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
396 err = brcmf_sdioh_request_chain(sdiodev, incr_fix, SDIOH_READ, fn, addr,
397 pktq);
5b435de0 398
7057fd00 399done:
5adfeb63 400 return err;
5b435de0
AS		 401}
402
403int
404brcmf_sdcard_send_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
5adfeb63
AS		 405 uint flags, u8 *buf, uint nbytes)
406{
407 struct sk_buff *mypkt;
408 int err;
409
410 mypkt = brcmu_pkt_buf_get_skb(nbytes);
411 if (!mypkt) {
412 brcmf_dbg(ERROR, "brcmu_pkt_buf_get_skb failed: len %d\n",
413 nbytes);
414 return -EIO;
415 }
416
417 memcpy(mypkt->data, buf, nbytes);
418 err = brcmf_sdcard_send_pkt(sdiodev, addr, fn, flags, mypkt);
419
420 brcmu_pkt_buf_free_skb(mypkt);
421 return err;
422
423}
424
425int
426brcmf_sdcard_send_pkt(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
427 uint flags, struct sk_buff *pkt)
5b435de0
AS		 428{
429 uint incr_fix;
430 uint width;
431 uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
432 int err = 0;
433
5adfeb63
AS		 434 brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n",
435 fn, addr, pkt->len);
5b435de0
AS		 436
437 /* Async not implemented yet */
438 if (flags & SDIO_REQ_ASYNC)
439 return -ENOTSUPP;
440
441 if (bar0 != sdiodev->sbwad) {
442 err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0);
443 if (err)
7057fd00 444 goto done;
5b435de0
AS		 445
446 sdiodev->sbwad = bar0;
447 }
448
449 addr &= SBSDIO_SB_OFT_ADDR_MASK;
450
451 incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
452 width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
453 if (width == 4)
454 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
455
7057fd00
FL		 456 err = brcmf_sdioh_request_buffer(sdiodev, incr_fix, SDIOH_WRITE, fn,
457 addr, pkt);
458
459done:
7057fd00 460 return err;
5b435de0
AS		 461}
462
463int brcmf_sdcard_rwdata(struct brcmf_sdio_dev *sdiodev, uint rw, u32 addr,
464 u8 *buf, uint nbytes)
465{
4c6e869d
AS		 466 struct sk_buff *mypkt;
467 bool write = rw ? SDIOH_WRITE : SDIOH_READ;
468 int err;
469
5b435de0
AS		 470 addr &= SBSDIO_SB_OFT_ADDR_MASK;
471 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
472
4c6e869d
AS		 473 mypkt = brcmu_pkt_buf_get_skb(nbytes);
474 if (!mypkt) {
475 brcmf_dbg(ERROR, "brcmu_pkt_buf_get_skb failed: len %d\n",
476 nbytes);
477 return -EIO;
478 }
479
480 /* For a write, copy the buffer data into the packet. */
481 if (write)
482 memcpy(mypkt->data, buf, nbytes);
483
484 err = brcmf_sdioh_request_buffer(sdiodev, SDIOH_DATA_INC, write,
485 SDIO_FUNC_1, addr, mypkt);
486
487 /* For a read, copy the packet data back to the buffer. */
488 if (!err && !write)
489 memcpy(buf, mypkt->data, nbytes);
490
491 brcmu_pkt_buf_free_skb(mypkt);
492 return err;
5b435de0
AS		 493}
494
495int brcmf_sdcard_abort(struct brcmf_sdio_dev *sdiodev, uint fn)
496{
497 char t_func = (char)fn;
498 brcmf_dbg(TRACE, "Enter\n");
499
500 /* issue abort cmd52 command through F0 */
501 brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE, SDIO_FUNC_0,
502 SDIO_CCCR_ABORT, &t_func);
503
504 brcmf_dbg(TRACE, "Exit\n");
505 return 0;
506}
507
508int brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev)
509{
510 u32 regs = 0;
511 int ret = 0;
512
513 ret = brcmf_sdioh_attach(sdiodev);
514 if (ret)
515 goto out;
516
517 regs = SI_ENUM_BASE;
518
5b435de0 519 /* try to attach to the target device */
4175b88b 520 sdiodev->bus = brcmf_sdbrcm_probe(regs, sdiodev);
5b435de0
AS		 521 if (!sdiodev->bus) {
522 brcmf_dbg(ERROR, "device attach failed\n");
523 ret = -ENODEV;
524 goto out;
525 }
526
527out:
528 if (ret)
529 brcmf_sdio_remove(sdiodev);
530
531 return ret;
532}
533EXPORT_SYMBOL(brcmf_sdio_probe);
534
535int brcmf_sdio_remove(struct brcmf_sdio_dev *sdiodev)
536{
2def5c10
HM		 537 sdiodev->bus_if->state = BRCMF_BUS_DOWN;
538
5b435de0
AS		 539 if (sdiodev->bus) {
540 brcmf_sdbrcm_disconnect(sdiodev->bus);
541 sdiodev->bus = NULL;
542 }
543
544 brcmf_sdioh_detach(sdiodev);
545
546 sdiodev->sbwad = 0;
547
548 return 0;
549}
550EXPORT_SYMBOL(brcmf_sdio_remove);
551
552void brcmf_sdio_wdtmr_enable(struct brcmf_sdio_dev *sdiodev, bool enable)
553{
554 if (enable)
555 brcmf_sdbrcm_wd_timer(sdiodev->bus, BRCMF_WD_POLL_MS);
556 else
557 brcmf_sdbrcm_wd_timer(sdiodev->bus, 0);
558}
Linux kernel - Deliverables
This page took 0.248664 seconds and 5 git commands to generate.