]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/net/wireless/brcm80211/brcmfmac/bcmsdh.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
brcmfmac: rework .get_station() callback
[mirror_ubuntu-artful-kernel.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
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>
354b75bf 24#include <linux/scatterlist.h>
5b435de0 25#include <linux/mmc/sdio.h>
e2dc9eea 26#include <linux/mmc/core.h>
5b435de0
AS		 27#include <linux/mmc/sdio_func.h>
28#include <linux/mmc/card.h>
e2dc9eea
AS		 29#include <linux/mmc/host.h>
30#include <linux/platform_device.h>
668761ac 31#include <linux/platform_data/brcmfmac-sdio.h>
063d5177 32#include <linux/pm_runtime.h>
e2dc9eea
AS		 33#include <linux/suspend.h>
34#include <linux/errno.h>
35#include <linux/module.h>
f0992ace 36#include <linux/acpi.h>
e2dc9eea 37#include <net/cfg80211.h>
5b435de0
AS		 38
39#include <defs.h>
40#include <brcm_hw_ids.h>
41#include <brcmu_utils.h>
42#include <brcmu_wifi.h>
568ba389 43#include <chipcommon.h>
5b435de0 44#include <soc.h>
568ba389 45#include "chip.h"
d14f78b9 46#include "bus.h"
a8e8ed34 47#include "debug.h"
888bf76e 48#include "sdio.h"
61f663df 49#include "of.h"
5b435de0
AS		 50
51#define SDIOH_API_ACCESS_RETRY_LIMIT 2
52
e49b06ba
AS		 53#define DMA_ALIGN_MASK 0x03
54
55#define SDIO_FUNC1_BLOCKSIZE 64
56#define SDIO_FUNC2_BLOCKSIZE 512
71370eb8
AS		 57/* Maximum milliseconds to wait for F2 to come up */
58#define SDIO_WAIT_F2RDY 3000
59
af1fa210
AS		 60#define BRCMF_DEFAULT_TXGLOM_SIZE 32 /* max tx frames in glom chain */
61#define BRCMF_DEFAULT_RXGLOM_SIZE 32 /* max rx frames in glom chain */
62
99824643
AS		 63struct brcmf_sdiod_freezer {
64 atomic_t freezing;
65 atomic_t thread_count;
66 u32 frozen_count;
67 wait_queue_head_t thread_freeze;
68 struct completion resumed;
69};
70
af1fa210
AS		 71static int brcmf_sdiod_txglomsz = BRCMF_DEFAULT_TXGLOM_SIZE;
72module_param_named(txglomsz, brcmf_sdiod_txglomsz, int, 0);
73MODULE_PARM_DESC(txglomsz, "maximum tx packet chain size [SDIO]");
668761ac 74
a39be27b 75static irqreturn_t brcmf_sdiod_oob_irqhandler(int irq, void *dev_id)
ba89bf19 76{
5b3c1832
HM		 77 struct brcmf_bus *bus_if = dev_get_drvdata(dev_id);
78 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
ba89bf19 79
668761ac 80 brcmf_dbg(INTR, "OOB intr triggered\n");
ba89bf19 81
668761ac 82 /* out-of-band interrupt is level-triggered which won't
ba89bf19
FL		 83 * be cleared until dpc
84 */
85 if (sdiodev->irq_en) {
86 disable_irq_nosync(irq);
87 sdiodev->irq_en = false;
88 }
89
82d7f3c1 90 brcmf_sdio_isr(sdiodev->bus);
ba89bf19
FL		 91
92 return IRQ_HANDLED;
93}
94
a39be27b 95static void brcmf_sdiod_ib_irqhandler(struct sdio_func *func)
5b435de0 96{
5b3c1832
HM		 97 struct brcmf_bus *bus_if = dev_get_drvdata(&func->dev);
98 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
5b435de0 99
668761ac 100 brcmf_dbg(INTR, "IB intr triggered\n");
5b435de0 101
82d7f3c1 102 brcmf_sdio_isr(sdiodev->bus);
5b435de0
AS		 103}
104
fbf59108 105/* dummy handler for SDIO function 2 interrupt */
a39be27b 106static void brcmf_sdiod_dummy_irqhandler(struct sdio_func *func)
fbf59108
FL		 107{
108}
109
a39be27b 110int brcmf_sdiod_intr_register(struct brcmf_sdio_dev *sdiodev)
5b435de0 111{
668761ac
HM		 112 int ret = 0;
113 u8 data;
568ba389 114 u32 addr, gpiocontrol;
668761ac 115 unsigned long flags;
5b435de0 116
668761ac
HM		 117 if ((sdiodev->pdata) && (sdiodev->pdata->oob_irq_supported)) {
118 brcmf_dbg(SDIO, "Enter, register OOB IRQ %d\n",
119 sdiodev->pdata->oob_irq_nr);
120 ret = request_irq(sdiodev->pdata->oob_irq_nr,
a39be27b 121 brcmf_sdiod_oob_irqhandler,
668761ac
HM		 122 sdiodev->pdata->oob_irq_flags,
123 "brcmf_oob_intr",
124 &sdiodev->func[1]->dev);
125 if (ret != 0) {
126 brcmf_err("request_irq failed %d\n", ret);
127 return ret;
128 }
129 sdiodev->oob_irq_requested = true;
130 spin_lock_init(&sdiodev->irq_en_lock);
131 spin_lock_irqsave(&sdiodev->irq_en_lock, flags);
132 sdiodev->irq_en = true;
133 spin_unlock_irqrestore(&sdiodev->irq_en_lock, flags);
134
135 ret = enable_irq_wake(sdiodev->pdata->oob_irq_nr);
136 if (ret != 0) {
137 brcmf_err("enable_irq_wake failed %d\n", ret);
138 return ret;
139 }
140 sdiodev->irq_wake = true;
141
142 sdio_claim_host(sdiodev->func[1]);
143
568ba389
HG		 144 if (sdiodev->bus_if->chip == BRCM_CC_43362_CHIP_ID) {
145 /* assign GPIO to SDIO core */
146 addr = CORE_CC_REG(SI_ENUM_BASE, gpiocontrol);
147 gpiocontrol = brcmf_sdiod_regrl(sdiodev, addr, &ret);
148 gpiocontrol |= 0x2;
149 brcmf_sdiod_regwl(sdiodev, addr, gpiocontrol, &ret);
150
151 brcmf_sdiod_regwb(sdiodev, SBSDIO_GPIO_SELECT, 0xf,
152 &ret);
153 brcmf_sdiod_regwb(sdiodev, SBSDIO_GPIO_OUT, 0, &ret);
154 brcmf_sdiod_regwb(sdiodev, SBSDIO_GPIO_EN, 0x2, &ret);
155 }
156
668761ac 157 /* must configure SDIO_CCCR_IENx to enable irq */
a39be27b 158 data = brcmf_sdiod_regrb(sdiodev, SDIO_CCCR_IENx, &ret);
668761ac 159 data |= 1 << SDIO_FUNC_1 | 1 << SDIO_FUNC_2 | 1;
a39be27b 160 brcmf_sdiod_regwb(sdiodev, SDIO_CCCR_IENx, data, &ret);
668761ac
HM		 161
162 /* redirect, configure and enable io for interrupt signal */
163 data = SDIO_SEPINT_MASK | SDIO_SEPINT_OE;
164 if (sdiodev->pdata->oob_irq_flags & IRQF_TRIGGER_HIGH)
165 data |= SDIO_SEPINT_ACT_HI;
a39be27b 166 brcmf_sdiod_regwb(sdiodev, SDIO_CCCR_BRCM_SEPINT, data, &ret);
668761ac
HM		 167
168 sdio_release_host(sdiodev->func[1]);
169 } else {
170 brcmf_dbg(SDIO, "Entering\n");
171 sdio_claim_host(sdiodev->func[1]);
a39be27b
AS		 172 sdio_claim_irq(sdiodev->func[1], brcmf_sdiod_ib_irqhandler);
173 sdio_claim_irq(sdiodev->func[2], brcmf_sdiod_dummy_irqhandler);
668761ac
HM		 174 sdio_release_host(sdiodev->func[1]);
175 }
5b435de0
AS		 176
177 return 0;
178}
179
a39be27b 180int brcmf_sdiod_intr_unregister(struct brcmf_sdio_dev *sdiodev)
5b435de0 181{
c3203374 182 brcmf_dbg(SDIO, "Entering\n");
5b435de0 183
668761ac
HM		 184 if ((sdiodev->pdata) && (sdiodev->pdata->oob_irq_supported)) {
185 sdio_claim_host(sdiodev->func[1]);
a39be27b
AS		 186 brcmf_sdiod_regwb(sdiodev, SDIO_CCCR_BRCM_SEPINT, 0, NULL);
187 brcmf_sdiod_regwb(sdiodev, SDIO_CCCR_IENx, 0, NULL);
668761ac
HM		 188 sdio_release_host(sdiodev->func[1]);
189
190 if (sdiodev->oob_irq_requested) {
191 sdiodev->oob_irq_requested = false;
192 if (sdiodev->irq_wake) {
193 disable_irq_wake(sdiodev->pdata->oob_irq_nr);
194 sdiodev->irq_wake = false;
195 }
196 free_irq(sdiodev->pdata->oob_irq_nr,
197 &sdiodev->func[1]->dev);
198 sdiodev->irq_en = false;
199 }
200 } else {
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 }
5b435de0
AS		 206
207 return 0;
208}
209
a1ce7a0d
AS		 210void brcmf_sdiod_change_state(struct brcmf_sdio_dev *sdiodev,
211 enum brcmf_sdiod_state state)
212{
213 if (sdiodev->state == BRCMF_SDIOD_NOMEDIUM ||
214 state == sdiodev->state)
215 return;
216
217 brcmf_dbg(TRACE, "%d -> %d\n", sdiodev->state, state);
218 switch (sdiodev->state) {
219 case BRCMF_SDIOD_DATA:
220 /* any other state means bus interface is down */
221 brcmf_bus_change_state(sdiodev->bus_if, BRCMF_BUS_DOWN);
222 break;
223 case BRCMF_SDIOD_DOWN:
224 /* transition from DOWN to DATA means bus interface is up */
225 if (state == BRCMF_SDIOD_DATA)
226 brcmf_bus_change_state(sdiodev->bus_if, BRCMF_BUS_UP);
227 break;
228 default:
229 break;
230 }
231 sdiodev->state = state;
232}
233
36c4e7e4
AS		 234static inline int brcmf_sdiod_f0_writeb(struct sdio_func *func,
235 uint regaddr, u8 byte)
e49b06ba 236{
e49b06ba
AS		 237 int err_ret;
238
239 /*
240 * Can only directly write to some F0 registers.
36c4e7e4 241 * Handle CCCR_IENx and CCCR_ABORT command
e49b06ba
AS		 242 * as a special case.
243 */
71370eb8 244 if ((regaddr == SDIO_CCCR_ABORT) ||
36c4e7e4
AS		 245 (regaddr == SDIO_CCCR_IENx))
246 sdio_writeb(func, byte, regaddr, &err_ret);
247 else
248 sdio_f0_writeb(func, byte, regaddr, &err_ret);
e49b06ba
AS		 249
250 return err_ret;
251}
252
71c60cf2
AS		 253static int brcmf_sdiod_request_data(struct brcmf_sdio_dev *sdiodev, u8 fn,
254 u32 addr, u8 regsz, void *data, bool write)
e49b06ba 255{
71c60cf2
AS		 256 struct sdio_func *func;
257 int ret;
e49b06ba 258
71c60cf2
AS		 259 brcmf_dbg(SDIO, "rw=%d, func=%d, addr=0x%05x, nbytes=%d\n",
260 write, fn, addr, regsz);
e49b06ba 261
71c60cf2
AS		 262 /* only allow byte access on F0 */
263 if (WARN_ON(regsz > 1 && !fn))
264 return -EINVAL;
265 func = sdiodev->func[fn];
266
267 switch (regsz) {
268 case sizeof(u8):
269 if (write) {
270 if (fn)
271 sdio_writeb(func, *(u8 *)data, addr, &ret);
272 else
273 ret = brcmf_sdiod_f0_writeb(func, addr,
274 *(u8 *)data);
e49b06ba 275 } else {
71c60cf2
AS		 276 if (fn)
277 *(u8 *)data = sdio_readb(func, addr, &ret);
278 else
279 *(u8 *)data = sdio_f0_readb(func, addr, &ret);
e49b06ba 280 }
71c60cf2
AS		 281 break;
282 case sizeof(u16):
283 if (write)
284 sdio_writew(func, *(u16 *)data, addr, &ret);
285 else
286 *(u16 *)data = sdio_readw(func, addr, &ret);
287 break;
288 case sizeof(u32):
289 if (write)
290 sdio_writel(func, *(u32 *)data, addr, &ret);
291 else
292 *(u32 *)data = sdio_readl(func, addr, &ret);
293 break;
294 default:
295 brcmf_err("invalid size: %d\n", regsz);
296 break;
e49b06ba
AS		 297 }
298
4d1a4f16
AS		 299 if (ret)
300 brcmf_dbg(SDIO, "failed to %s data F%d@0x%05x, err: %d\n",
301 write ? "write" : "read", fn, addr, ret);
302
71c60cf2 303 return ret;
e49b06ba
AS		 304}
305
71c60cf2
AS		 306static int brcmf_sdiod_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr,
307 u8 regsz, void *data, bool write)
e49b06ba 308{
4d1a4f16 309 u8 func;
71c60cf2
AS		 310 s32 retry = 0;
311 int ret;
e49b06ba 312
a1ce7a0d 313 if (sdiodev->state == BRCMF_SDIOD_NOMEDIUM)
bb350711
AS		 314 return -ENOMEDIUM;
315
71c60cf2
AS		 316 /*
317 * figure out how to read the register based on address range
318 * 0x00 ~ 0x7FF: function 0 CCCR and FBR
319 * 0x10000 ~ 0x1FFFF: function 1 miscellaneous registers
320 * The rest: function 1 silicon backplane core registers
321 */
322 if ((addr & ~REG_F0_REG_MASK) == 0)
4d1a4f16 323 func = SDIO_FUNC_0;
71c60cf2 324 else
4d1a4f16 325 func = SDIO_FUNC_1;
e49b06ba 326
71c60cf2
AS		 327 do {
328 if (!write)
329 memset(data, 0, regsz);
330 /* for retry wait for 1 ms till bus get settled down */
331 if (retry)
332 usleep_range(1000, 2000);
4d1a4f16 333 ret = brcmf_sdiod_request_data(sdiodev, func, addr, regsz,
71c60cf2 334 data, write);
bb350711
AS		 335 } while (ret != 0 && ret != -ENOMEDIUM &&
336 retry++ < SDIOH_API_ACCESS_RETRY_LIMIT);
e49b06ba 337
bb350711 338 if (ret == -ENOMEDIUM)
a1ce7a0d 339 brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_NOMEDIUM);
4d1a4f16
AS		 340 else if (ret != 0) {
341 /*
342 * SleepCSR register access can fail when
343 * waking up the device so reduce this noise
344 * in the logs.
345 */
346 if (addr != SBSDIO_FUNC1_SLEEPCSR)
347 brcmf_err("failed to %s data F%d@0x%05x, err: %d\n",
348 write ? "write" : "read", func, addr, ret);
349 else
350 brcmf_dbg(SDIO, "failed to %s data F%d@0x%05x, err: %d\n",
351 write ? "write" : "read", func, addr, ret);
352 }
71c60cf2 353 return ret;
e49b06ba
AS		 354}
355
356bae6f 356static int
a39be27b 357brcmf_sdiod_set_sbaddr_window(struct brcmf_sdio_dev *sdiodev, u32 address)
5b435de0 358{
7d9cfc28
FL		 359 int err = 0, i;
360 u8 addr[3];
7d9cfc28 361
a1ce7a0d 362 if (sdiodev->state == BRCMF_SDIOD_NOMEDIUM)
bb350711
AS		 363 return -ENOMEDIUM;
364
7d9cfc28
FL		 365 addr[0] = (address >> 8) & SBSDIO_SBADDRLOW_MASK;
366 addr[1] = (address >> 16) & SBSDIO_SBADDRMID_MASK;
367 addr[2] = (address >> 24) & SBSDIO_SBADDRHIGH_MASK;
368
369 for (i = 0; i < 3; i++) {
71c60cf2
AS		 370 err = brcmf_sdiod_regrw_helper(sdiodev,
371 SBSDIO_FUNC1_SBADDRLOW + i,
372 sizeof(u8), &addr[i], true);
7d9cfc28 373 if (err) {
71c60cf2 374 brcmf_err("failed at addr: 0x%0x\n",
7d9cfc28
FL		 375 SBSDIO_FUNC1_SBADDRLOW + i);
376 break;
377 }
378 }
5b435de0
AS		 379
380 return err;
381}
382
356bae6f 383static int
a39be27b 384brcmf_sdiod_addrprep(struct brcmf_sdio_dev *sdiodev, uint width, u32 *addr)
356bae6f
FL		 385{
386 uint bar0 = *addr & ~SBSDIO_SB_OFT_ADDR_MASK;
387 int err = 0;
388
389 if (bar0 != sdiodev->sbwad) {
a39be27b 390 err = brcmf_sdiod_set_sbaddr_window(sdiodev, bar0);
356bae6f
FL		 391 if (err)
392 return err;
393
394 sdiodev->sbwad = bar0;
395 }
396
397 *addr &= SBSDIO_SB_OFT_ADDR_MASK;
398
399 if (width == 4)
400 *addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
401
402 return 0;
403}
404
a39be27b 405u8 brcmf_sdiod_regrb(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
e9b8d91d
FL		 406{
407 u8 data;
408 int retval;
409
c3203374 410 brcmf_dbg(SDIO, "addr:0x%08x\n", addr);
71c60cf2
AS		 411 retval = brcmf_sdiod_regrw_helper(sdiodev, addr, sizeof(data), &data,
412 false);
c3203374 413 brcmf_dbg(SDIO, "data:0x%02x\n", data);
e9b8d91d
FL		 414
415 if (ret)
416 *ret = retval;
417
418 return data;
419}
420
a39be27b 421u32 brcmf_sdiod_regrl(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
e9b8d91d
FL		 422{
423 u32 data;
424 int retval;
425
c3203374 426 brcmf_dbg(SDIO, "addr:0x%08x\n", addr);
71c60cf2
AS		 427 retval = brcmf_sdiod_addrprep(sdiodev, sizeof(data), &addr);
428 if (retval)
429 goto done;
430 retval = brcmf_sdiod_regrw_helper(sdiodev, addr, sizeof(data), &data,
431 false);
c3203374 432 brcmf_dbg(SDIO, "data:0x%08x\n", data);
e9b8d91d 433
71c60cf2 434done:
e9b8d91d
FL		 435 if (ret)
436 *ret = retval;
437
438 return data;
439}
440
a39be27b 441void brcmf_sdiod_regwb(struct brcmf_sdio_dev *sdiodev, u32 addr,
e9b8d91d
FL		 442 u8 data, int *ret)
443{
444 int retval;
445
c3203374 446 brcmf_dbg(SDIO, "addr:0x%08x, data:0x%02x\n", addr, data);
71c60cf2
AS		 447 retval = brcmf_sdiod_regrw_helper(sdiodev, addr, sizeof(data), &data,
448 true);
e9b8d91d
FL		 449 if (ret)
450 *ret = retval;
451}
452
a39be27b 453void brcmf_sdiod_regwl(struct brcmf_sdio_dev *sdiodev, u32 addr,
e9b8d91d
FL		 454 u32 data, int *ret)
455{
456 int retval;
457
c3203374 458 brcmf_dbg(SDIO, "addr:0x%08x, data:0x%08x\n", addr, data);
71c60cf2
AS		 459 retval = brcmf_sdiod_addrprep(sdiodev, sizeof(data), &addr);
460 if (retval)
461 goto done;
462 retval = brcmf_sdiod_regrw_helper(sdiodev, addr, sizeof(data), &data,
463 true);
e9b8d91d 464
71c60cf2 465done:
e9b8d91d
FL		 466 if (ret)
467 *ret = retval;
468}
469
a39be27b 470static int brcmf_sdiod_buffrw(struct brcmf_sdio_dev *sdiodev, uint fn,
4aef267e
AS		 471 bool write, u32 addr, struct sk_buff *pkt)
472{
473 unsigned int req_sz;
bb350711 474 int err;
4aef267e 475
4aef267e
AS		 476 /* Single skb use the standard mmc interface */
477 req_sz = pkt->len + 3;
478 req_sz &= (uint)~3;
479
480 if (write)
bb350711
AS		 481 err = sdio_memcpy_toio(sdiodev->func[fn], addr,
482 ((u8 *)(pkt->data)), req_sz);
4aef267e 483 else if (fn == 1)
bb350711
AS		 484 err = sdio_memcpy_fromio(sdiodev->func[fn], ((u8 *)(pkt->data)),
485 addr, req_sz);
4aef267e
AS		 486 else
487 /* function 2 read is FIFO operation */
bb350711
AS		 488 err = sdio_readsb(sdiodev->func[fn], ((u8 *)(pkt->data)), addr,
489 req_sz);
490 if (err == -ENOMEDIUM)
a1ce7a0d 491 brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_NOMEDIUM);
bb350711 492 return err;
4aef267e
AS		 493}
494
78b3f1c5 495/**
a39be27b 496 * brcmf_sdiod_sglist_rw - SDIO interface function for block data access
78b3f1c5
FL		 497 * @sdiodev: brcmfmac sdio device
498 * @fn: SDIO function number
499 * @write: direction flag
500 * @addr: dongle memory address as source/destination
501 * @pkt: skb pointer
502 *
503 * This function takes the respbonsibility as the interface function to MMC
504 * stack for block data access. It assumes that the skb passed down by the
505 * caller has already been padded and aligned.
506 */
a39be27b
AS		 507static int brcmf_sdiod_sglist_rw(struct brcmf_sdio_dev *sdiodev, uint fn,
508 bool write, u32 addr,
509 struct sk_buff_head *pktlist)
78b3f1c5 510{
354b75bf 511 unsigned int req_sz, func_blk_sz, sg_cnt, sg_data_sz, pkt_offset;
71201496 512 unsigned int max_req_sz, orig_offset, dst_offset;
3f782744 513 unsigned short max_seg_cnt, seg_sz;
3b81a680
FL		 514 unsigned char *pkt_data, *orig_data, *dst_data;
515 struct sk_buff *pkt_next = NULL, *local_pkt_next;
516 struct sk_buff_head local_list, *target_list;
354b75bf
FL		 517 struct mmc_request mmc_req;
518 struct mmc_command mmc_cmd;
519 struct mmc_data mmc_dat;
354b75bf 520 struct scatterlist *sgl;
354b75bf
FL		 521 int ret = 0;
522
523 if (!pktlist->qlen)
524 return -EINVAL;
78b3f1c5 525
3b81a680
FL		 526 target_list = pktlist;
527 /* for host with broken sg support, prepare a page aligned list */
528 __skb_queue_head_init(&local_list);
529 if (sdiodev->pdata && sdiodev->pdata->broken_sg_support && !write) {
530 req_sz = 0;
531 skb_queue_walk(pktlist, pkt_next)
532 req_sz += pkt_next->len;
533 req_sz = ALIGN(req_sz, sdiodev->func[fn]->cur_blksize);
534 while (req_sz > PAGE_SIZE) {
535 pkt_next = brcmu_pkt_buf_get_skb(PAGE_SIZE);
536 if (pkt_next == NULL) {
537 ret = -ENOMEM;
538 goto exit;
539 }
540 __skb_queue_tail(&local_list, pkt_next);
541 req_sz -= PAGE_SIZE;
542 }
543 pkt_next = brcmu_pkt_buf_get_skb(req_sz);
544 if (pkt_next == NULL) {
545 ret = -ENOMEM;
546 goto exit;
547 }
548 __skb_queue_tail(&local_list, pkt_next);
549 target_list = &local_list;
550 }
551
354b75bf 552 func_blk_sz = sdiodev->func[fn]->cur_blksize;
71201496
AS		 553 max_req_sz = sdiodev->max_request_size;
554 max_seg_cnt = min_t(unsigned short, sdiodev->max_segment_count,
555 target_list->qlen);
3b81a680 556 seg_sz = target_list->qlen;
354b75bf 557 pkt_offset = 0;
3b81a680 558 pkt_next = target_list->next;
354b75bf 559
7f9a8dc8
AS		 560 memset(&mmc_req, 0, sizeof(struct mmc_request));
561 memset(&mmc_cmd, 0, sizeof(struct mmc_command));
562 memset(&mmc_dat, 0, sizeof(struct mmc_data));
563
af1fa210 564 mmc_dat.sg = sdiodev->sgtable.sgl;
7f9a8dc8
AS		 565 mmc_dat.blksz = func_blk_sz;
566 mmc_dat.flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
567 mmc_cmd.opcode = SD_IO_RW_EXTENDED;
568 mmc_cmd.arg = write ? 1<<31 : 0; /* write flag */
569 mmc_cmd.arg |= (fn & 0x7) << 28; /* SDIO func num */
570 mmc_cmd.arg |= 1<<27; /* block mode */
571 /* for function 1 the addr will be incremented */
572 mmc_cmd.arg |= (fn == 1) ? 1<<26 : 0;
573 mmc_cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_ADTC;
574 mmc_req.cmd = &mmc_cmd;
575 mmc_req.data = &mmc_dat;
576
354b75bf
FL		 577 while (seg_sz) {
578 req_sz = 0;
579 sg_cnt = 0;
af1fa210 580 sgl = sdiodev->sgtable.sgl;
354b75bf 581 /* prep sg table */
3b81a680 582 while (pkt_next != (struct sk_buff *)target_list) {
354b75bf
FL		 583 pkt_data = pkt_next->data + pkt_offset;
584 sg_data_sz = pkt_next->len - pkt_offset;
71201496
AS		 585 if (sg_data_sz > sdiodev->max_segment_size)
586 sg_data_sz = sdiodev->max_segment_size;
354b75bf
FL		 587 if (sg_data_sz > max_req_sz - req_sz)
588 sg_data_sz = max_req_sz - req_sz;
589
590 sg_set_buf(sgl, pkt_data, sg_data_sz);
591
592 sg_cnt++;
593 sgl = sg_next(sgl);
594 req_sz += sg_data_sz;
595 pkt_offset += sg_data_sz;
596 if (pkt_offset == pkt_next->len) {
597 pkt_offset = 0;
598 pkt_next = pkt_next->next;
599 }
600
3f782744 601 if (req_sz >= max_req_sz || sg_cnt >= max_seg_cnt)
354b75bf
FL		 602 break;
603 }
604 seg_sz -= sg_cnt;
605
606 if (req_sz % func_blk_sz != 0) {
607 brcmf_err("sg request length %u is not %u aligned\n",
608 req_sz, func_blk_sz);
3b81a680
FL		 609 ret = -ENOTBLK;
610 goto exit;
354b75bf 611 }
7f9a8dc8 612
354b75bf 613 mmc_dat.sg_len = sg_cnt;
354b75bf 614 mmc_dat.blocks = req_sz / func_blk_sz;
354b75bf
FL		 615 mmc_cmd.arg |= (addr & 0x1FFFF) << 9; /* address */
616 mmc_cmd.arg |= mmc_dat.blocks & 0x1FF; /* block count */
7f9a8dc8 617 /* incrementing addr for function 1 */
354b75bf
FL		 618 if (fn == 1)
619 addr += req_sz;
620
621 mmc_set_data_timeout(&mmc_dat, sdiodev->func[fn]->card);
71201496 622 mmc_wait_for_req(sdiodev->func[fn]->card->host, &mmc_req);
354b75bf
FL		 623
624 ret = mmc_cmd.error ? mmc_cmd.error : mmc_dat.error;
bb350711 625 if (ret == -ENOMEDIUM) {
a1ce7a0d 626 brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_NOMEDIUM);
bb350711
AS		 627 break;
628 } else if (ret != 0) {
354b75bf
FL		 629 brcmf_err("CMD53 sg block %s failed %d\n",
630 write ? "write" : "read", ret);
631 ret = -EIO;
632 break;
633 }
634 }
635
3b81a680
FL		 636 if (sdiodev->pdata && sdiodev->pdata->broken_sg_support && !write) {
637 local_pkt_next = local_list.next;
638 orig_offset = 0;
639 skb_queue_walk(pktlist, pkt_next) {
640 dst_offset = 0;
641 do {
642 req_sz = local_pkt_next->len - orig_offset;
643 req_sz = min_t(uint, pkt_next->len - dst_offset,
644 req_sz);
645 orig_data = local_pkt_next->data + orig_offset;
646 dst_data = pkt_next->data + dst_offset;
647 memcpy(dst_data, orig_data, req_sz);
648 orig_offset += req_sz;
649 dst_offset += req_sz;
650 if (orig_offset == local_pkt_next->len) {
651 orig_offset = 0;
652 local_pkt_next = local_pkt_next->next;
653 }
654 if (dst_offset == pkt_next->len)
655 break;
656 } while (!skb_queue_empty(&local_list));
657 }
658 }
659
660exit:
af1fa210 661 sg_init_table(sdiodev->sgtable.sgl, sdiodev->sgtable.orig_nents);
3b81a680
FL		 662 while ((pkt_next = __skb_dequeue(&local_list)) != NULL)
663 brcmu_pkt_buf_free_skb(pkt_next);
354b75bf
FL		 664
665 return ret;
78b3f1c5
FL		 666}
667
a7cdd821 668int brcmf_sdiod_recv_buf(struct brcmf_sdio_dev *sdiodev, u8 *buf, uint nbytes)
5adfeb63
AS		 669{
670 struct sk_buff *mypkt;
671 int err;
672
673 mypkt = brcmu_pkt_buf_get_skb(nbytes);
674 if (!mypkt) {
5e8149f5 675 brcmf_err("brcmu_pkt_buf_get_skb failed: len %d\n",
5adfeb63
AS		 676 nbytes);
677 return -EIO;
678 }
679
a7cdd821 680 err = brcmf_sdiod_recv_pkt(sdiodev, mypkt);
5adfeb63
AS		 681 if (!err)
682 memcpy(buf, mypkt->data, nbytes);
683
684 brcmu_pkt_buf_free_skb(mypkt);
685 return err;
686}
687
a7cdd821 688int brcmf_sdiod_recv_pkt(struct brcmf_sdio_dev *sdiodev, struct sk_buff *pkt)
5adfeb63 689{
a7cdd821 690 u32 addr = sdiodev->sbwad;
5adfeb63
AS		 691 int err = 0;
692
a7cdd821 693 brcmf_dbg(SDIO, "addr = 0x%x, size = %d\n", addr, pkt->len);
5adfeb63 694
a7cdd821 695 err = brcmf_sdiod_addrprep(sdiodev, 4, &addr);
5adfeb63 696 if (err)
7057fd00 697 goto done;
5b435de0 698
a7cdd821 699 err = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_2, false, addr, pkt);
5adfeb63 700
7057fd00 701done:
5adfeb63
AS		 702 return err;
703}
704
a7cdd821
AS		 705int brcmf_sdiod_recv_chain(struct brcmf_sdio_dev *sdiodev,
706 struct sk_buff_head *pktq, uint totlen)
5adfeb63 707{
a413e39a
AS		 708 struct sk_buff *glom_skb;
709 struct sk_buff *skb;
a7cdd821 710 u32 addr = sdiodev->sbwad;
5adfeb63
AS		 711 int err = 0;
712
a7cdd821
AS		 713 brcmf_dbg(SDIO, "addr = 0x%x, size = %d\n",
714 addr, pktq->qlen);
5adfeb63 715
a7cdd821 716 err = brcmf_sdiod_addrprep(sdiodev, 4, &addr);
5adfeb63 717 if (err)
7057fd00 718 goto done;
5b435de0 719
a413e39a 720 if (pktq->qlen == 1)
a7cdd821
AS		 721 err = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_2, false, addr,
722 pktq->next);
a413e39a
AS		 723 else if (!sdiodev->sg_support) {
724 glom_skb = brcmu_pkt_buf_get_skb(totlen);
725 if (!glom_skb)
726 return -ENOMEM;
a7cdd821
AS		 727 err = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_2, false, addr,
728 glom_skb);
a413e39a
AS		 729 if (err)
730 goto done;
731
732 skb_queue_walk(pktq, skb) {
733 memcpy(skb->data, glom_skb->data, skb->len);
734 skb_pull(glom_skb, skb->len);
735 }
736 } else
a7cdd821
AS		 737 err = brcmf_sdiod_sglist_rw(sdiodev, SDIO_FUNC_2, false, addr,
738 pktq);
5b435de0 739
7057fd00 740done:
5adfeb63 741 return err;
5b435de0
AS		 742}
743
a7cdd821 744int brcmf_sdiod_send_buf(struct brcmf_sdio_dev *sdiodev, u8 *buf, uint nbytes)
5adfeb63
AS		 745{
746 struct sk_buff *mypkt;
a7cdd821 747 u32 addr = sdiodev->sbwad;
5adfeb63
AS		 748 int err;
749
750 mypkt = brcmu_pkt_buf_get_skb(nbytes);
751 if (!mypkt) {
5e8149f5 752 brcmf_err("brcmu_pkt_buf_get_skb failed: len %d\n",
5adfeb63
AS		 753 nbytes);
754 return -EIO;
755 }
756
757 memcpy(mypkt->data, buf, nbytes);
4aef267e 758
a7cdd821 759 err = brcmf_sdiod_addrprep(sdiodev, 4, &addr);
4aef267e 760
fcaac2b1 761 if (!err)
a7cdd821
AS		 762 err = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_2, true, addr,
763 mypkt);
5adfeb63
AS		 764
765 brcmu_pkt_buf_free_skb(mypkt);
766 return err;
767
768}
769
a7cdd821
AS		 770int brcmf_sdiod_send_pkt(struct brcmf_sdio_dev *sdiodev,
771 struct sk_buff_head *pktq)
5b435de0 772{
c8cce1f9 773 struct sk_buff *skb;
a7cdd821 774 u32 addr = sdiodev->sbwad;
fcaac2b1 775 int err;
5b435de0 776
a7cdd821 777 brcmf_dbg(SDIO, "addr = 0x%x, size = %d\n", addr, pktq->qlen);
5b435de0 778
a7cdd821 779 err = brcmf_sdiod_addrprep(sdiodev, 4, &addr);
fcaac2b1
AS		 780 if (err)
781 return err;
5b435de0 782
c8cce1f9
AS		 783 if (pktq->qlen == 1 || !sdiodev->sg_support)
784 skb_queue_walk(pktq, skb) {
a7cdd821
AS		 785 err = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_2, true,
786 addr, skb);
c8cce1f9
AS		 787 if (err)
788 break;
789 }
790 else
a7cdd821
AS		 791 err = brcmf_sdiod_sglist_rw(sdiodev, SDIO_FUNC_2, true, addr,
792 pktq);
c8cce1f9
AS		 793
794 return err;
5b435de0
AS		 795}
796
ba540b01 797int
a39be27b
AS		 798brcmf_sdiod_ramrw(struct brcmf_sdio_dev *sdiodev, bool write, u32 address,
799 u8 *data, uint size)
5b435de0 800{
ba540b01
FL		 801 int bcmerror = 0;
802 struct sk_buff *pkt;
803 u32 sdaddr;
804 uint dsize;
805
806 dsize = min_t(uint, SBSDIO_SB_OFT_ADDR_LIMIT, size);
807 pkt = dev_alloc_skb(dsize);
808 if (!pkt) {
809 brcmf_err("dev_alloc_skb failed: len %d\n", dsize);
810 return -EIO;
811 }
812 pkt->priority = 0;
4c6e869d 813
ba540b01
FL		 814 /* Determine initial transfer parameters */
815 sdaddr = address & SBSDIO_SB_OFT_ADDR_MASK;
816 if ((sdaddr + size) & SBSDIO_SBWINDOW_MASK)
817 dsize = (SBSDIO_SB_OFT_ADDR_LIMIT - sdaddr);
818 else
819 dsize = size;
5b435de0 820
ba540b01
FL		 821 sdio_claim_host(sdiodev->func[1]);
822
823 /* Do the transfer(s) */
824 while (size) {
825 /* Set the backplane window to include the start address */
a39be27b 826 bcmerror = brcmf_sdiod_set_sbaddr_window(sdiodev, address);
ba540b01
FL		 827 if (bcmerror)
828 break;
829
830 brcmf_dbg(SDIO, "%s %d bytes at offset 0x%08x in window 0x%08x\n",
831 write ? "write" : "read", dsize,
832 sdaddr, address & SBSDIO_SBWINDOW_MASK);
833
834 sdaddr &= SBSDIO_SB_OFT_ADDR_MASK;
835 sdaddr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
836
837 skb_put(pkt, dsize);
838 if (write)
839 memcpy(pkt->data, data, dsize);
a39be27b
AS		 840 bcmerror = brcmf_sdiod_buffrw(sdiodev, SDIO_FUNC_1, write,
841 sdaddr, pkt);
ba540b01
FL		 842 if (bcmerror) {
843 brcmf_err("membytes transfer failed\n");
844 break;
845 }
846 if (!write)
847 memcpy(data, pkt->data, dsize);
79c868e5 848 skb_trim(pkt, 0);
ba540b01
FL		 849
850 /* Adjust for next transfer (if any) */
851 size -= dsize;
852 if (size) {
853 data += dsize;
854 address += dsize;
855 sdaddr = 0;
856 dsize = min_t(uint, SBSDIO_SB_OFT_ADDR_LIMIT, size);
857 }
4c6e869d
AS		 858 }
859
ba540b01 860 dev_kfree_skb(pkt);
4c6e869d 861
ba540b01 862 /* Return the window to backplane enumeration space for core access */
a39be27b 863 if (brcmf_sdiod_set_sbaddr_window(sdiodev, sdiodev->sbwad))
ba540b01
FL		 864 brcmf_err("FAILED to set window back to 0x%x\n",
865 sdiodev->sbwad);
4c6e869d 866
ba540b01 867 sdio_release_host(sdiodev->func[1]);
4c6e869d 868
ba540b01 869 return bcmerror;
5b435de0
AS		 870}
871
a39be27b 872int brcmf_sdiod_abort(struct brcmf_sdio_dev *sdiodev, uint fn)
5b435de0
AS		 873{
874 char t_func = (char)fn;
c3203374 875 brcmf_dbg(SDIO, "Enter\n");
5b435de0
AS		 876
877 /* issue abort cmd52 command through F0 */
71c60cf2
AS		 878 brcmf_sdiod_request_data(sdiodev, SDIO_FUNC_0, SDIO_CCCR_ABORT,
879 sizeof(t_func), &t_func, true);
5b435de0 880
c3203374 881 brcmf_dbg(SDIO, "Exit\n");
5b435de0
AS		 882 return 0;
883}
884
af1fa210
AS		 885static void brcmf_sdiod_sgtable_alloc(struct brcmf_sdio_dev *sdiodev)
886{
887 uint nents;
888 int err;
889
890 if (!sdiodev->sg_support)
891 return;
892
893 nents = max_t(uint, BRCMF_DEFAULT_RXGLOM_SIZE, brcmf_sdiod_txglomsz);
894 nents += (nents >> 4) + 1;
895
896 WARN_ON(nents > sdiodev->max_segment_count);
897
898 brcmf_dbg(TRACE, "nents=%d\n", nents);
899 err = sg_alloc_table(&sdiodev->sgtable, nents, GFP_KERNEL);
900 if (err < 0) {
901 brcmf_err("allocation failed: disable scatter-gather");
902 sdiodev->sg_support = false;
903 }
904
905 sdiodev->txglomsz = brcmf_sdiod_txglomsz;
906}
907
99824643
AS		 908#ifdef CONFIG_PM_SLEEP
909static int brcmf_sdiod_freezer_attach(struct brcmf_sdio_dev *sdiodev)
910{
911 sdiodev->freezer = kzalloc(sizeof(*sdiodev->freezer), GFP_KERNEL);
912 if (!sdiodev->freezer)
913 return -ENOMEM;
914 atomic_set(&sdiodev->freezer->thread_count, 0);
915 atomic_set(&sdiodev->freezer->freezing, 0);
916 init_waitqueue_head(&sdiodev->freezer->thread_freeze);
917 init_completion(&sdiodev->freezer->resumed);
918 return 0;
919}
920
921static void brcmf_sdiod_freezer_detach(struct brcmf_sdio_dev *sdiodev)
922{
923 if (sdiodev->freezer) {
924 WARN_ON(atomic_read(&sdiodev->freezer->freezing));
925 kfree(sdiodev->freezer);
926 }
927}
928
929static int brcmf_sdiod_freezer_on(struct brcmf_sdio_dev *sdiodev)
930{
931 atomic_t *expect = &sdiodev->freezer->thread_count;
932 int res = 0;
933
934 sdiodev->freezer->frozen_count = 0;
935 reinit_completion(&sdiodev->freezer->resumed);
936 atomic_set(&sdiodev->freezer->freezing, 1);
937 brcmf_sdio_trigger_dpc(sdiodev->bus);
938 wait_event(sdiodev->freezer->thread_freeze,
939 atomic_read(expect) == sdiodev->freezer->frozen_count);
940 sdio_claim_host(sdiodev->func[1]);
941 res = brcmf_sdio_sleep(sdiodev->bus, true);
942 sdio_release_host(sdiodev->func[1]);
943 return res;
944}
945
946static void brcmf_sdiod_freezer_off(struct brcmf_sdio_dev *sdiodev)
947{
948 sdio_claim_host(sdiodev->func[1]);
949 brcmf_sdio_sleep(sdiodev->bus, false);
950 sdio_release_host(sdiodev->func[1]);
951 atomic_set(&sdiodev->freezer->freezing, 0);
952 complete_all(&sdiodev->freezer->resumed);
953}
954
955bool brcmf_sdiod_freezing(struct brcmf_sdio_dev *sdiodev)
956{
957 return atomic_read(&sdiodev->freezer->freezing);
958}
959
960void brcmf_sdiod_try_freeze(struct brcmf_sdio_dev *sdiodev)
961{
962 if (!brcmf_sdiod_freezing(sdiodev))
963 return;
964 sdiodev->freezer->frozen_count++;
965 wake_up(&sdiodev->freezer->thread_freeze);
966 wait_for_completion(&sdiodev->freezer->resumed);
967}
968
969void brcmf_sdiod_freezer_count(struct brcmf_sdio_dev *sdiodev)
970{
971 atomic_inc(&sdiodev->freezer->thread_count);
972}
973
974void brcmf_sdiod_freezer_uncount(struct brcmf_sdio_dev *sdiodev)
975{
976 atomic_dec(&sdiodev->freezer->thread_count);
977}
978#else
979static int brcmf_sdiod_freezer_attach(struct brcmf_sdio_dev *sdiodev)
980{
981 return 0;
982}
983
984static void brcmf_sdiod_freezer_detach(struct brcmf_sdio_dev *sdiodev)
985{
986}
987#endif /* CONFIG_PM_SLEEP */
988
a39be27b
AS		 989static int brcmf_sdiod_remove(struct brcmf_sdio_dev *sdiodev)
990{
a39be27b 991 if (sdiodev->bus) {
9fbe2a6d 992 brcmf_sdio_remove(sdiodev->bus);
a39be27b
AS		 993 sdiodev->bus = NULL;
994 }
995
99824643
AS		 996 brcmf_sdiod_freezer_detach(sdiodev);
997
a39be27b
AS		 998 /* Disable Function 2 */
999 sdio_claim_host(sdiodev->func[2]);
1000 sdio_disable_func(sdiodev->func[2]);
1001 sdio_release_host(sdiodev->func[2]);
1002
1003 /* Disable Function 1 */
1004 sdio_claim_host(sdiodev->func[1]);
1005 sdio_disable_func(sdiodev->func[1]);
1006 sdio_release_host(sdiodev->func[1]);
1007
af1fa210 1008 sg_free_table(&sdiodev->sgtable);
a39be27b
AS		 1009 sdiodev->sbwad = 0;
1010
063d5177 1011 pm_runtime_allow(sdiodev->func[1]->card->host->parent);
a39be27b
AS		 1012 return 0;
1013}
1014
bdf1340c
AS		 1015static void brcmf_sdiod_host_fixup(struct mmc_host *host)
1016{
1017 /* runtime-pm powers off the device */
1018 pm_runtime_forbid(host->parent);
1019 /* avoid removal detection upon resume */
1020 host->caps |= MMC_CAP_NONREMOVABLE;
1021}
1022
a39be27b 1023static int brcmf_sdiod_probe(struct brcmf_sdio_dev *sdiodev)
e2dc9eea 1024{
e2dc9eea 1025 struct sdio_func *func;
a39be27b 1026 struct mmc_host *host;
e2dc9eea 1027 uint max_blocks;
a39be27b 1028 int ret = 0;
e2dc9eea
AS		 1029
1030 sdiodev->num_funcs = 2;
1031
1032 sdio_claim_host(sdiodev->func[1]);
1033
a39be27b
AS		 1034 ret = sdio_set_block_size(sdiodev->func[1], SDIO_FUNC1_BLOCKSIZE);
1035 if (ret) {
e2dc9eea 1036 brcmf_err("Failed to set F1 blocksize\n");
a39be27b 1037 sdio_release_host(sdiodev->func[1]);
e2dc9eea
AS		 1038 goto out;
1039 }
a39be27b
AS		 1040 ret = sdio_set_block_size(sdiodev->func[2], SDIO_FUNC2_BLOCKSIZE);
1041 if (ret) {
e2dc9eea 1042 brcmf_err("Failed to set F2 blocksize\n");
a39be27b 1043 sdio_release_host(sdiodev->func[1]);
e2dc9eea
AS		 1044 goto out;
1045 }
1046
71370eb8
AS		 1047 /* increase F2 timeout */
1048 sdiodev->func[2]->enable_timeout = SDIO_WAIT_F2RDY;
1049
463c30b3 1050 /* Enable Function 1 */
a39be27b
AS		 1051 ret = sdio_enable_func(sdiodev->func[1]);
1052 sdio_release_host(sdiodev->func[1]);
1053 if (ret) {
1054 brcmf_err("Failed to enable F1: err=%d\n", ret);
463c30b3
AS		 1055 goto out;
1056 }
e2dc9eea
AS		 1057
1058 /*
a39be27b 1059 * determine host related variables after brcmf_sdiod_probe()
e2dc9eea
AS		 1060 * as func->cur_blksize is properly set and F2 init has been
1061 * completed successfully.
1062 */
1063 func = sdiodev->func[2];
1064 host = func->card->host;
1065 sdiodev->sg_support = host->max_segs > 1;
1066 max_blocks = min_t(uint, host->max_blk_count, 511u);
1067 sdiodev->max_request_size = min_t(uint, host->max_req_size,
1068 max_blocks * func->cur_blksize);
1069 sdiodev->max_segment_count = min_t(uint, host->max_segs,
1070 SG_MAX_SINGLE_ALLOC);
1071 sdiodev->max_segment_size = host->max_seg_size;
e49b06ba 1072
af1fa210
AS		 1073 /* allocate scatter-gather table. sg support
1074 * will be disabled upon allocation failure.
1075 */
1076 brcmf_sdiod_sgtable_alloc(sdiodev);
1077
99824643
AS		 1078 ret = brcmf_sdiod_freezer_attach(sdiodev);
1079 if (ret)
1080 goto out;
1081
e49b06ba 1082 /* try to attach to the target device */
82d7f3c1 1083 sdiodev->bus = brcmf_sdio_probe(sdiodev);
e49b06ba 1084 if (!sdiodev->bus) {
e49b06ba
AS		 1085 ret = -ENODEV;
1086 goto out;
1087 }
bdf1340c 1088 brcmf_sdiod_host_fixup(host);
e49b06ba
AS		 1089out:
1090 if (ret)
a39be27b 1091 brcmf_sdiod_remove(sdiodev);
e49b06ba
AS		 1092
1093 return ret;
1094}
1095
5779ae6a 1096#define BRCMF_SDIO_DEVICE(dev_id) \
8bd61f8d 1097 {SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, dev_id)}
5779ae6a 1098
e49b06ba
AS		 1099/* devices we support, null terminated */
1100static const struct sdio_device_id brcmf_sdmmc_ids[] = {
8bd61f8d
AS		 1101 BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43143),
1102 BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43241),
1103 BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4329),
1104 BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4330),
1105 BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4334),
1106 BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43340),
1107 BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43341),
1108 BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43362),
1109 BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4335_4339),
25911556 1110 BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43430),
9c510265 1111 BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4345),
8bd61f8d 1112 BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4354),
5779ae6a 1113 { /* end: all zeroes */ }
e49b06ba
AS		 1114};
1115MODULE_DEVICE_TABLE(sdio, brcmf_sdmmc_ids);
1116
1117static struct brcmfmac_sdio_platform_data *brcmfmac_sdio_pdata;
1118
1119
00e27eeb
AS		 1120static void brcmf_sdiod_acpi_set_power_manageable(struct device *dev,
1121 int val)
1122{
1123#if IS_ENABLED(CONFIG_ACPI)
1124 struct acpi_device *adev;
1125
1126 adev = ACPI_COMPANION(dev);
1127 if (adev)
1128 adev->flags.power_manageable = 0;
1129#endif
1130}
1131
e2dc9eea
AS		 1132static int brcmf_ops_sdio_probe(struct sdio_func *func,
1133 const struct sdio_device_id *id)
1134{
1135 int err;
1136 struct brcmf_sdio_dev *sdiodev;
1137 struct brcmf_bus *bus_if;
f0992ace 1138 struct device *dev;
e2dc9eea
AS		 1139
1140 brcmf_dbg(SDIO, "Enter\n");
1141 brcmf_dbg(SDIO, "Class=%x\n", func->class);
1142 brcmf_dbg(SDIO, "sdio vendor ID: 0x%04x\n", func->vendor);
1143 brcmf_dbg(SDIO, "sdio device ID: 0x%04x\n", func->device);
1144 brcmf_dbg(SDIO, "Function#: %d\n", func->num);
1145
f0992ace 1146 dev = &func->dev;
00e27eeb
AS		 1147 /* prohibit ACPI power management for this device */
1148 brcmf_sdiod_acpi_set_power_manageable(dev, 0);
f0992ace 1149
e2dc9eea
AS		 1150 /* Consume func num 1 but dont do anything with it. */
1151 if (func->num == 1)
1152 return 0;
1153
1154 /* Ignore anything but func 2 */
1155 if (func->num != 2)
1156 return -ENODEV;
1157
1158 bus_if = kzalloc(sizeof(struct brcmf_bus), GFP_KERNEL);
1159 if (!bus_if)
1160 return -ENOMEM;
1161 sdiodev = kzalloc(sizeof(struct brcmf_sdio_dev), GFP_KERNEL);
1162 if (!sdiodev) {
1163 kfree(bus_if);
1164 return -ENOMEM;
1165 }
1166
36c4e7e4
AS		 1167 /* store refs to functions used. mmc_card does
1168 * not hold the F0 function pointer.
1169 */
1170 sdiodev->func[0] = kmemdup(func, sizeof(*func), GFP_KERNEL);
1171 sdiodev->func[0]->num = 0;
e2dc9eea
AS		 1172 sdiodev->func[1] = func->card->sdio_func[0];
1173 sdiodev->func[2] = func;
1174
1175 sdiodev->bus_if = bus_if;
1176 bus_if->bus_priv.sdio = sdiodev;
943258b6 1177 bus_if->proto_type = BRCMF_PROTO_BCDC;
e2dc9eea
AS		 1178 dev_set_drvdata(&func->dev, bus_if);
1179 dev_set_drvdata(&sdiodev->func[1]->dev, bus_if);
1180 sdiodev->dev = &sdiodev->func[1]->dev;
1181 sdiodev->pdata = brcmfmac_sdio_pdata;
1182
61f663df
CYT		 1183 if (!sdiodev->pdata)
1184 brcmf_of_probe(sdiodev);
1185
330b4e4b
HM		 1186#ifdef CONFIG_PM_SLEEP
1187 /* wowl can be supported when KEEP_POWER is true and (WAKE_SDIO_IRQ
1188 * is true or when platform data OOB irq is true).
1189 */
1190 if ((sdio_get_host_pm_caps(sdiodev->func[1]) & MMC_PM_KEEP_POWER) &&
1191 ((sdio_get_host_pm_caps(sdiodev->func[1]) & MMC_PM_WAKE_SDIO_IRQ) ||
8975842b 1192 (sdiodev->pdata && sdiodev->pdata->oob_irq_supported)))
330b4e4b
HM		 1193 bus_if->wowl_supported = true;
1194#endif
1195
a1ce7a0d 1196 brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_DOWN);
e2dc9eea 1197
a39be27b
AS		 1198 brcmf_dbg(SDIO, "F2 found, calling brcmf_sdiod_probe...\n");
1199 err = brcmf_sdiod_probe(sdiodev);
e2dc9eea
AS		 1200 if (err) {
1201 brcmf_err("F2 error, probe failed %d...\n", err);
1202 goto fail;
1203 }
1204
1205 brcmf_dbg(SDIO, "F2 init completed...\n");
1206 return 0;
1207
1208fail:
1209 dev_set_drvdata(&func->dev, NULL);
1210 dev_set_drvdata(&sdiodev->func[1]->dev, NULL);
36c4e7e4 1211 kfree(sdiodev->func[0]);
e2dc9eea
AS		 1212 kfree(sdiodev);
1213 kfree(bus_if);
1214 return err;
1215}
1216
1217static void brcmf_ops_sdio_remove(struct sdio_func *func)
1218{
1219 struct brcmf_bus *bus_if;
1220 struct brcmf_sdio_dev *sdiodev;
1221
1222 brcmf_dbg(SDIO, "Enter\n");
1223 brcmf_dbg(SDIO, "sdio vendor ID: 0x%04x\n", func->vendor);
1224 brcmf_dbg(SDIO, "sdio device ID: 0x%04x\n", func->device);
1225 brcmf_dbg(SDIO, "Function: %d\n", func->num);
1226
de6878c8 1227 if (func->num != 1)
e2dc9eea
AS		 1228 return;
1229
1230 bus_if = dev_get_drvdata(&func->dev);
1231 if (bus_if) {
1232 sdiodev = bus_if->bus_priv.sdio;
a39be27b 1233 brcmf_sdiod_remove(sdiodev);
e2dc9eea
AS		 1234
1235 dev_set_drvdata(&sdiodev->func[1]->dev, NULL);
1236 dev_set_drvdata(&sdiodev->func[2]->dev, NULL);
1237
1238 kfree(bus_if);
36c4e7e4 1239 kfree(sdiodev->func[0]);
e2dc9eea
AS		 1240 kfree(sdiodev);
1241 }
1242
1243 brcmf_dbg(SDIO, "Exit\n");
1244}
1245
330b4e4b
HM		 1246void brcmf_sdio_wowl_config(struct device *dev, bool enabled)
1247{
1248 struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1249 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
1250
1251 brcmf_dbg(SDIO, "Configuring WOWL, enabled=%d\n", enabled);
1252 sdiodev->wowl_enabled = enabled;
1253}
1254
e2dc9eea 1255#ifdef CONFIG_PM_SLEEP
a39be27b 1256static int brcmf_ops_sdio_suspend(struct device *dev)
e2dc9eea 1257{
99824643 1258 struct sdio_func *func;
8982cd40
AS		 1259 struct brcmf_bus *bus_if;
1260 struct brcmf_sdio_dev *sdiodev;
330b4e4b 1261 mmc_pm_flag_t sdio_flags;
e2dc9eea 1262
99824643
AS		 1263 func = container_of(dev, struct sdio_func, dev);
1264 brcmf_dbg(SDIO, "Enter: F%d\n", func->num);
1265 if (func->num != SDIO_FUNC_1)
1266 return 0;
1267
e2dc9eea 1268
8982cd40
AS		 1269 bus_if = dev_get_drvdata(dev);
1270 sdiodev = bus_if->bus_priv.sdio;
1271
99824643 1272 brcmf_sdiod_freezer_on(sdiodev);
8982cd40 1273 brcmf_sdio_wd_timer(sdiodev->bus, 0);
3e3831c4 1274
bdf1340c 1275 sdio_flags = MMC_PM_KEEP_POWER;
330b4e4b 1276 if (sdiodev->wowl_enabled) {
330b4e4b
HM		 1277 if (sdiodev->pdata->oob_irq_supported)
1278 enable_irq_wake(sdiodev->pdata->oob_irq_nr);
1279 else
bdf1340c 1280 sdio_flags |= MMC_PM_WAKE_SDIO_IRQ;
e2dc9eea 1281 }
bdf1340c
AS		 1282 if (sdio_set_host_pm_flags(sdiodev->func[1], sdio_flags))
1283 brcmf_err("Failed to set pm_flags %x\n", sdio_flags);
330b4e4b 1284 return 0;
e2dc9eea
AS		 1285}
1286
a39be27b 1287static int brcmf_ops_sdio_resume(struct device *dev)
e2dc9eea
AS		 1288{
1289 struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1290 struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
99824643 1291 struct sdio_func *func = container_of(dev, struct sdio_func, dev);
e2dc9eea 1292
99824643
AS		 1293 brcmf_dbg(SDIO, "Enter: F%d\n", func->num);
1294 if (func->num != SDIO_FUNC_2)
1295 return 0;
1296
1297 brcmf_sdiod_freezer_off(sdiodev);
e2dc9eea
AS		 1298 return 0;
1299}
1300
1301static const struct dev_pm_ops brcmf_sdio_pm_ops = {
a39be27b
AS		 1302 .suspend = brcmf_ops_sdio_suspend,
1303 .resume = brcmf_ops_sdio_resume,
e2dc9eea
AS		 1304};
1305#endif /* CONFIG_PM_SLEEP */
1306
1307static struct sdio_driver brcmf_sdmmc_driver = {
1308 .probe = brcmf_ops_sdio_probe,
1309 .remove = brcmf_ops_sdio_remove,
1310 .name = BRCMFMAC_SDIO_PDATA_NAME,
1311 .id_table = brcmf_sdmmc_ids,
e2dc9eea 1312 .drv = {
0b0acd8c
FL		 1313 .owner = THIS_MODULE,
1314#ifdef CONFIG_PM_SLEEP
e2dc9eea 1315 .pm = &brcmf_sdio_pm_ops,
e2dc9eea 1316#endif /* CONFIG_PM_SLEEP */
0b0acd8c 1317 },
e2dc9eea
AS		 1318};
1319
c2d23c70 1320static int __init brcmf_sdio_pd_probe(struct platform_device *pdev)
e2dc9eea
AS		 1321{
1322 brcmf_dbg(SDIO, "Enter\n");
1323
1324 brcmfmac_sdio_pdata = dev_get_platdata(&pdev->dev);
1325
1326 if (brcmfmac_sdio_pdata->power_on)
1327 brcmfmac_sdio_pdata->power_on();
1328
1329 return 0;
1330}
1331
1332static int brcmf_sdio_pd_remove(struct platform_device *pdev)
1333{
1334 brcmf_dbg(SDIO, "Enter\n");
1335
1336 if (brcmfmac_sdio_pdata->power_off)
1337 brcmfmac_sdio_pdata->power_off();
1338
1339 sdio_unregister_driver(&brcmf_sdmmc_driver);
1340
1341 return 0;
1342}
1343
1344static struct platform_driver brcmf_sdio_pd = {
1345 .remove = brcmf_sdio_pd_remove,
1346 .driver = {
1347 .name = BRCMFMAC_SDIO_PDATA_NAME,
e2dc9eea
AS		 1348 }
1349};
1350
1351void brcmf_sdio_register(void)
1352{
1353 int ret;
1354
1355 ret = sdio_register_driver(&brcmf_sdmmc_driver);
1356 if (ret)
1357 brcmf_err("sdio_register_driver failed: %d\n", ret);
1358}
1359
1360void brcmf_sdio_exit(void)
1361{
1362 brcmf_dbg(SDIO, "Enter\n");
1363
1364 if (brcmfmac_sdio_pdata)
1365 platform_driver_unregister(&brcmf_sdio_pd);
1366 else
1367 sdio_unregister_driver(&brcmf_sdmmc_driver);
1368}
1369
1370void __init brcmf_sdio_init(void)
1371{
1372 int ret;
1373
1374 brcmf_dbg(SDIO, "Enter\n");
1375
1376 ret = platform_driver_probe(&brcmf_sdio_pd, brcmf_sdio_pd_probe);
1377 if (ret == -ENODEV)
1378 brcmf_dbg(SDIO, "No platform data available.\n");
1379}
Ubuntu Artful kernel mirror