projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
brcmfmac: replace brcmf_sdioh_request_buffer with brcmf_sdio_buffrw
[deliverable/linux.git] / drivers / net / wireless / brcm80211 / brcmfmac / bcmsdh.c
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/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>
28 #include <linux/platform_data/brcmfmac-sdio.h>
29
30 #include <defs.h>
31 #include <brcm_hw_ids.h>
32 #include <brcmu_utils.h>
33 #include <brcmu_wifi.h>
34 #include <soc.h>
35 #include "dhd_bus.h"
36 #include "dhd_dbg.h"
37 #include "sdio_host.h"
38
39 #define SDIOH_API_ACCESS_RETRY_LIMIT 2
40
41
42 static irqreturn_t brcmf_sdio_oob_irqhandler(int irq, void *dev_id)
43 {
44 struct brcmf_bus *bus_if = dev_get_drvdata(dev_id);
45 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
46
47 brcmf_dbg(INTR, "OOB intr triggered\n");
48
49 /* out-of-band interrupt is level-triggered which won't
50 * be cleared until dpc
51 */
52 if (sdiodev->irq_en) {
53 disable_irq_nosync(irq);
54 sdiodev->irq_en = false;
55 }
56
57 brcmf_sdbrcm_isr(sdiodev->bus);
58
59 return IRQ_HANDLED;
60 }
61
62 static void brcmf_sdio_ib_irqhandler(struct sdio_func *func)
63 {
64 struct brcmf_bus *bus_if = dev_get_drvdata(&func->dev);
65 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
66
67 brcmf_dbg(INTR, "IB intr triggered\n");
68
69 brcmf_sdbrcm_isr(sdiodev->bus);
70 }
71
72 /* dummy handler for SDIO function 2 interrupt */
73 static void brcmf_sdio_dummy_irqhandler(struct sdio_func *func)
74 {
75 }
76
77 int brcmf_sdio_intr_register(struct brcmf_sdio_dev *sdiodev)
78 {
79 int ret = 0;
80 u8 data;
81 unsigned long flags;
82
83 if ((sdiodev->pdata) && (sdiodev->pdata->oob_irq_supported)) {
84 brcmf_dbg(SDIO, "Enter, register OOB IRQ %d\n",
85 sdiodev->pdata->oob_irq_nr);
86 ret = request_irq(sdiodev->pdata->oob_irq_nr,
87 brcmf_sdio_oob_irqhandler,
88 sdiodev->pdata->oob_irq_flags,
89 "brcmf_oob_intr",
90 &sdiodev->func[1]->dev);
91 if (ret != 0) {
92 brcmf_err("request_irq failed %d\n", ret);
93 return ret;
94 }
95 sdiodev->oob_irq_requested = true;
96 spin_lock_init(&sdiodev->irq_en_lock);
97 spin_lock_irqsave(&sdiodev->irq_en_lock, flags);
98 sdiodev->irq_en = true;
99 spin_unlock_irqrestore(&sdiodev->irq_en_lock, flags);
100
101 ret = enable_irq_wake(sdiodev->pdata->oob_irq_nr);
102 if (ret != 0) {
103 brcmf_err("enable_irq_wake failed %d\n", ret);
104 return ret;
105 }
106 sdiodev->irq_wake = true;
107
108 sdio_claim_host(sdiodev->func[1]);
109
110 /* must configure SDIO_CCCR_IENx to enable irq */
111 data = brcmf_sdio_regrb(sdiodev, SDIO_CCCR_IENx, &ret);
112 data |= 1 << SDIO_FUNC_1 | 1 << SDIO_FUNC_2 | 1;
113 brcmf_sdio_regwb(sdiodev, SDIO_CCCR_IENx, data, &ret);
114
115 /* redirect, configure and enable io for interrupt signal */
116 data = SDIO_SEPINT_MASK | SDIO_SEPINT_OE;
117 if (sdiodev->pdata->oob_irq_flags & IRQF_TRIGGER_HIGH)
118 data |= SDIO_SEPINT_ACT_HI;
119 brcmf_sdio_regwb(sdiodev, SDIO_CCCR_BRCM_SEPINT, data, &ret);
120
121 sdio_release_host(sdiodev->func[1]);
122 } else {
123 brcmf_dbg(SDIO, "Entering\n");
124 sdio_claim_host(sdiodev->func[1]);
125 sdio_claim_irq(sdiodev->func[1], brcmf_sdio_ib_irqhandler);
126 sdio_claim_irq(sdiodev->func[2], brcmf_sdio_dummy_irqhandler);
127 sdio_release_host(sdiodev->func[1]);
128 }
129
130 return 0;
131 }
132
133 int brcmf_sdio_intr_unregister(struct brcmf_sdio_dev *sdiodev)
134 {
135 brcmf_dbg(SDIO, "Entering\n");
136
137 if ((sdiodev->pdata) && (sdiodev->pdata->oob_irq_supported)) {
138 sdio_claim_host(sdiodev->func[1]);
139 brcmf_sdio_regwb(sdiodev, SDIO_CCCR_BRCM_SEPINT, 0, NULL);
140 brcmf_sdio_regwb(sdiodev, SDIO_CCCR_IENx, 0, NULL);
141 sdio_release_host(sdiodev->func[1]);
142
143 if (sdiodev->oob_irq_requested) {
144 sdiodev->oob_irq_requested = false;
145 if (sdiodev->irq_wake) {
146 disable_irq_wake(sdiodev->pdata->oob_irq_nr);
147 sdiodev->irq_wake = false;
148 }
149 free_irq(sdiodev->pdata->oob_irq_nr,
150 &sdiodev->func[1]->dev);
151 sdiodev->irq_en = false;
152 }
153 } else {
154 sdio_claim_host(sdiodev->func[1]);
155 sdio_release_irq(sdiodev->func[2]);
156 sdio_release_irq(sdiodev->func[1]);
157 sdio_release_host(sdiodev->func[1]);
158 }
159
160 return 0;
161 }
162
163 int
164 brcmf_sdcard_set_sbaddr_window(struct brcmf_sdio_dev *sdiodev, u32 address)
165 {
166 int err = 0, i;
167 u8 addr[3];
168 s32 retry;
169
170 addr[0] = (address >> 8) & SBSDIO_SBADDRLOW_MASK;
171 addr[1] = (address >> 16) & SBSDIO_SBADDRMID_MASK;
172 addr[2] = (address >> 24) & SBSDIO_SBADDRHIGH_MASK;
173
174 for (i = 0; i < 3; i++) {
175 retry = 0;
176 do {
177 if (retry)
178 usleep_range(1000, 2000);
179 err = brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE,
180 SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRLOW + i,
181 &addr[i]);
182 } while (err != 0 && retry++ < SDIOH_API_ACCESS_RETRY_LIMIT);
183
184 if (err) {
185 brcmf_err("failed at addr:0x%0x\n",
186 SBSDIO_FUNC1_SBADDRLOW + i);
187 break;
188 }
189 }
190
191 return err;
192 }
193
194 int
195 brcmf_sdio_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr,
196 void *data, bool write)
197 {
198 u8 func_num, reg_size;
199 u32 bar;
200 s32 retry = 0;
201 int ret;
202
203 /*
204 * figure out how to read the register based on address range
205 * 0x00 ~ 0x7FF: function 0 CCCR and FBR
206 * 0x10000 ~ 0x1FFFF: function 1 miscellaneous registers
207 * The rest: function 1 silicon backplane core registers
208 */
209 if ((addr & ~REG_F0_REG_MASK) == 0) {
210 func_num = SDIO_FUNC_0;
211 reg_size = 1;
212 } else if ((addr & ~REG_F1_MISC_MASK) == 0) {
213 func_num = SDIO_FUNC_1;
214 reg_size = 1;
215 } else {
216 func_num = SDIO_FUNC_1;
217 reg_size = 4;
218
219 /* Set the window for SB core register */
220 bar = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
221 if (bar != sdiodev->sbwad) {
222 ret = brcmf_sdcard_set_sbaddr_window(sdiodev, bar);
223 if (ret != 0) {
224 memset(data, 0xFF, reg_size);
225 return ret;
226 }
227 sdiodev->sbwad = bar;
228 }
229 addr &= SBSDIO_SB_OFT_ADDR_MASK;
230 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
231 }
232
233 do {
234 if (!write)
235 memset(data, 0, reg_size);
236 if (retry) /* wait for 1 ms till bus get settled down */
237 usleep_range(1000, 2000);
238 if (reg_size == 1)
239 ret = brcmf_sdioh_request_byte(sdiodev, write,
240 func_num, addr, data);
241 else
242 ret = brcmf_sdioh_request_word(sdiodev, write,
243 func_num, addr, data, 4);
244 } while (ret != 0 && retry++ < SDIOH_API_ACCESS_RETRY_LIMIT);
245
246 if (ret != 0)
247 brcmf_err("failed with %d\n", ret);
248
249 return ret;
250 }
251
252 u8 brcmf_sdio_regrb(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
253 {
254 u8 data;
255 int retval;
256
257 brcmf_dbg(SDIO, "addr:0x%08x\n", addr);
258 retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, false);
259 brcmf_dbg(SDIO, "data:0x%02x\n", data);
260
261 if (ret)
262 *ret = retval;
263
264 return data;
265 }
266
267 u32 brcmf_sdio_regrl(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
268 {
269 u32 data;
270 int retval;
271
272 brcmf_dbg(SDIO, "addr:0x%08x\n", addr);
273 retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, false);
274 brcmf_dbg(SDIO, "data:0x%08x\n", data);
275
276 if (ret)
277 *ret = retval;
278
279 return data;
280 }
281
282 void brcmf_sdio_regwb(struct brcmf_sdio_dev *sdiodev, u32 addr,
283 u8 data, int *ret)
284 {
285 int retval;
286
287 brcmf_dbg(SDIO, "addr:0x%08x, data:0x%02x\n", addr, data);
288 retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, true);
289
290 if (ret)
291 *ret = retval;
292 }
293
294 void brcmf_sdio_regwl(struct brcmf_sdio_dev *sdiodev, u32 addr,
295 u32 data, int *ret)
296 {
297 int retval;
298
299 brcmf_dbg(SDIO, "addr:0x%08x, data:0x%08x\n", addr, data);
300 retval = brcmf_sdio_regrw_helper(sdiodev, addr, &data, true);
301
302 if (ret)
303 *ret = retval;
304 }
305
306 /**
307 * brcmf_sdio_buffrw - SDIO interface function for block data access
308 * @sdiodev: brcmfmac sdio device
309 * @fn: SDIO function number
310 * @write: direction flag
311 * @addr: dongle memory address as source/destination
312 * @pkt: skb pointer
313 *
314 * This function takes the respbonsibility as the interface function to MMC
315 * stack for block data access. It assumes that the skb passed down by the
316 * caller has already been padded and aligned.
317 */
318 static int brcmf_sdio_buffrw(struct brcmf_sdio_dev *sdiodev, uint fn,
319 bool write, u32 addr, struct sk_buff *pkt)
320 {
321 uint len;
322
323 brcmf_pm_resume_wait(sdiodev, &sdiodev->request_buffer_wait);
324 if (brcmf_pm_resume_error(sdiodev))
325 return -EIO;
326
327 /* Single skb use the standard mmc interface */
328 if (!pkt->next) {
329 len = pkt->len + 3;
330 len &= (uint)~3;
331
332 if (write)
333 return sdio_memcpy_toio(sdiodev->func[fn], addr,
334 ((u8 *)(pkt->data)), len);
335 else if (fn == 1)
336 return sdio_memcpy_fromio(sdiodev->func[fn],
337 ((u8 *)(pkt->data)), addr,
338 len);
339 else
340 /* function 2 read is FIFO operation */
341 return sdio_readsb(sdiodev->func[fn],
342 ((u8 *)(pkt->data)), addr, len);
343 }
344
345 brcmf_err("skb chain is not supported yet.\n");
346 return -EOPNOTSUPP;
347 }
348
349 static int brcmf_sdcard_recv_prepare(struct brcmf_sdio_dev *sdiodev, uint fn,
350 uint flags, uint width, u32 *addr)
351 {
352 uint bar0 = *addr & ~SBSDIO_SB_OFT_ADDR_MASK;
353 int err = 0;
354
355 /* Async not implemented yet */
356 if (flags & SDIO_REQ_ASYNC)
357 return -ENOTSUPP;
358
359 if (bar0 != sdiodev->sbwad) {
360 err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0);
361 if (err)
362 return err;
363
364 sdiodev->sbwad = bar0;
365 }
366
367 *addr &= SBSDIO_SB_OFT_ADDR_MASK;
368
369 if (width == 4)
370 *addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
371
372 return 0;
373 }
374
375 int
376 brcmf_sdcard_recv_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
377 uint flags, u8 *buf, uint nbytes)
378 {
379 struct sk_buff *mypkt;
380 int err;
381
382 mypkt = brcmu_pkt_buf_get_skb(nbytes);
383 if (!mypkt) {
384 brcmf_err("brcmu_pkt_buf_get_skb failed: len %d\n",
385 nbytes);
386 return -EIO;
387 }
388
389 err = brcmf_sdcard_recv_pkt(sdiodev, addr, fn, flags, mypkt);
390 if (!err)
391 memcpy(buf, mypkt->data, nbytes);
392
393 brcmu_pkt_buf_free_skb(mypkt);
394 return err;
395 }
396
397 int
398 brcmf_sdcard_recv_pkt(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
399 uint flags, struct sk_buff *pkt)
400 {
401 uint width;
402 int err = 0;
403
404 brcmf_dbg(SDIO, "fun = %d, addr = 0x%x, size = %d\n",
405 fn, addr, pkt->len);
406
407 width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
408 err = brcmf_sdcard_recv_prepare(sdiodev, fn, flags, width, &addr);
409 if (err)
410 goto done;
411
412 err = brcmf_sdio_buffrw(sdiodev, fn, false, addr, pkt);
413
414 done:
415 return err;
416 }
417
418 int brcmf_sdcard_recv_chain(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
419 uint flags, struct sk_buff_head *pktq)
420 {
421 uint incr_fix;
422 uint width;
423 int err = 0;
424
425 brcmf_dbg(SDIO, "fun = %d, addr = 0x%x, size = %d\n",
426 fn, addr, pktq->qlen);
427
428 width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
429 err = brcmf_sdcard_recv_prepare(sdiodev, fn, flags, width, &addr);
430 if (err)
431 goto done;
432
433 incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
434 err = brcmf_sdioh_request_chain(sdiodev, incr_fix, SDIOH_READ, fn, addr,
435 pktq);
436
437 done:
438 return err;
439 }
440
441 int
442 brcmf_sdcard_send_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
443 uint flags, u8 *buf, uint nbytes)
444 {
445 struct sk_buff *mypkt;
446 int err;
447
448 mypkt = brcmu_pkt_buf_get_skb(nbytes);
449 if (!mypkt) {
450 brcmf_err("brcmu_pkt_buf_get_skb failed: len %d\n",
451 nbytes);
452 return -EIO;
453 }
454
455 memcpy(mypkt->data, buf, nbytes);
456 err = brcmf_sdcard_send_pkt(sdiodev, addr, fn, flags, mypkt);
457
458 brcmu_pkt_buf_free_skb(mypkt);
459 return err;
460
461 }
462
463 int
464 brcmf_sdcard_send_pkt(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
465 uint flags, struct sk_buff *pkt)
466 {
467 uint width;
468 uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
469 int err = 0;
470
471 brcmf_dbg(SDIO, "fun = %d, addr = 0x%x, size = %d\n",
472 fn, addr, pkt->len);
473
474 /* Async not implemented yet */
475 if (flags & SDIO_REQ_ASYNC)
476 return -ENOTSUPP;
477
478 if (bar0 != sdiodev->sbwad) {
479 err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0);
480 if (err)
481 goto done;
482
483 sdiodev->sbwad = bar0;
484 }
485
486 addr &= SBSDIO_SB_OFT_ADDR_MASK;
487
488 width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
489 if (width == 4)
490 addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
491
492 err = brcmf_sdio_buffrw(sdiodev, fn, true, addr, pkt);
493
494 done:
495 return err;
496 }
497
498 int
499 brcmf_sdio_ramrw(struct brcmf_sdio_dev *sdiodev, bool write, u32 address,
500 u8 *data, uint size)
501 {
502 int bcmerror = 0;
503 struct sk_buff *pkt;
504 u32 sdaddr;
505 uint dsize;
506
507 dsize = min_t(uint, SBSDIO_SB_OFT_ADDR_LIMIT, size);
508 pkt = dev_alloc_skb(dsize);
509 if (!pkt) {
510 brcmf_err("dev_alloc_skb failed: len %d\n", dsize);
511 return -EIO;
512 }
513 pkt->priority = 0;
514
515 /* Determine initial transfer parameters */
516 sdaddr = address & SBSDIO_SB_OFT_ADDR_MASK;
517 if ((sdaddr + size) & SBSDIO_SBWINDOW_MASK)
518 dsize = (SBSDIO_SB_OFT_ADDR_LIMIT - sdaddr);
519 else
520 dsize = size;
521
522 sdio_claim_host(sdiodev->func[1]);
523
524 /* Do the transfer(s) */
525 while (size) {
526 /* Set the backplane window to include the start address */
527 bcmerror = brcmf_sdcard_set_sbaddr_window(sdiodev, address);
528 if (bcmerror)
529 break;
530
531 brcmf_dbg(SDIO, "%s %d bytes at offset 0x%08x in window 0x%08x\n",
532 write ? "write" : "read", dsize,
533 sdaddr, address & SBSDIO_SBWINDOW_MASK);
534
535 sdaddr &= SBSDIO_SB_OFT_ADDR_MASK;
536 sdaddr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
537
538 skb_put(pkt, dsize);
539 if (write)
540 memcpy(pkt->data, data, dsize);
541 bcmerror = brcmf_sdio_buffrw(sdiodev, SDIO_FUNC_1, write,
542 sdaddr, pkt);
543 if (bcmerror) {
544 brcmf_err("membytes transfer failed\n");
545 break;
546 }
547 if (!write)
548 memcpy(data, pkt->data, dsize);
549 skb_trim(pkt, dsize);
550
551 /* Adjust for next transfer (if any) */
552 size -= dsize;
553 if (size) {
554 data += dsize;
555 address += dsize;
556 sdaddr = 0;
557 dsize = min_t(uint, SBSDIO_SB_OFT_ADDR_LIMIT, size);
558 }
559 }
560
561 dev_kfree_skb(pkt);
562
563 /* Return the window to backplane enumeration space for core access */
564 if (brcmf_sdcard_set_sbaddr_window(sdiodev, sdiodev->sbwad))
565 brcmf_err("FAILED to set window back to 0x%x\n",
566 sdiodev->sbwad);
567
568 sdio_release_host(sdiodev->func[1]);
569
570 return bcmerror;
571 }
572
573 int brcmf_sdcard_abort(struct brcmf_sdio_dev *sdiodev, uint fn)
574 {
575 char t_func = (char)fn;
576 brcmf_dbg(SDIO, "Enter\n");
577
578 /* issue abort cmd52 command through F0 */
579 brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE, SDIO_FUNC_0,
580 SDIO_CCCR_ABORT, &t_func);
581
582 brcmf_dbg(SDIO, "Exit\n");
583 return 0;
584 }
585
586 int brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev)
587 {
588 u32 regs = 0;
589 int ret = 0;
590
591 ret = brcmf_sdioh_attach(sdiodev);
592 if (ret)
593 goto out;
594
595 regs = SI_ENUM_BASE;
596
597 /* try to attach to the target device */
598 sdiodev->bus = brcmf_sdbrcm_probe(regs, sdiodev);
599 if (!sdiodev->bus) {
600 brcmf_err("device attach failed\n");
601 ret = -ENODEV;
602 goto out;
603 }
604
605 out:
606 if (ret)
607 brcmf_sdio_remove(sdiodev);
608
609 return ret;
610 }
611 EXPORT_SYMBOL(brcmf_sdio_probe);
612
613 int brcmf_sdio_remove(struct brcmf_sdio_dev *sdiodev)
614 {
615 sdiodev->bus_if->state = BRCMF_BUS_DOWN;
616
617 if (sdiodev->bus) {
618 brcmf_sdbrcm_disconnect(sdiodev->bus);
619 sdiodev->bus = NULL;
620 }
621
622 brcmf_sdioh_detach(sdiodev);
623
624 sdiodev->sbwad = 0;
625
626 return 0;
627 }
628 EXPORT_SYMBOL(brcmf_sdio_remove);
629
630 void brcmf_sdio_wdtmr_enable(struct brcmf_sdio_dev *sdiodev, bool enable)
631 {
632 if (enable)
633 brcmf_sdbrcm_wd_timer(sdiodev->bus, BRCMF_WD_POLL_MS);
634 else
635 brcmf_sdbrcm_wd_timer(sdiodev->bus, 0);
636 }
Linux kernel - Deliverables
This page took 0.045036 seconds and 6 git commands to generate.