1 // SPDX-License-Identifier: ISC
2 /*
3  * Copyright (c) 2010 Broadcom Corporation
4  */
5 /* ****************** SDIO CARD Interface Functions **************************/
6 
7 #include <linux/types.h>
8 #include <linux/netdevice.h>
9 #include <linux/pci.h>
10 #include <linux/pci_ids.h>
11 #include <linux/sched.h>
12 #include <linux/completion.h>
13 #include <linux/interrupt.h>
14 #include <linux/scatterlist.h>
15 #include <linux/mmc/sdio.h>
16 #include <linux/mmc/core.h>
17 #include <linux/mmc/sdio_func.h>
18 #include <linux/mmc/card.h>
19 #include <linux/mmc/host.h>
20 #include <linux/pm_runtime.h>
21 #include <linux/suspend.h>
22 #include <linux/errno.h>
23 #include <linux/module.h>
24 #include <linux/acpi.h>
25 #include <net/cfg80211.h>
26 
27 #include <defs.h>
28 #include <brcm_hw_ids.h>
29 #include <brcmu_utils.h>
30 #include <brcmu_wifi.h>
31 #include <chipcommon.h>
32 #include <soc.h>
33 #include "chip.h"
34 #include "bus.h"
35 #include "debug.h"
36 #include "sdio.h"
37 #include "core.h"
38 #include "common.h"
39 
40 #define SDIOH_API_ACCESS_RETRY_LIMIT	2
41 
42 #define DMA_ALIGN_MASK	0x03
43 
44 #define SDIO_FUNC1_BLOCKSIZE		64
45 #define SDIO_FUNC2_BLOCKSIZE		512
46 #define SDIO_4373_FUNC2_BLOCKSIZE	256
47 #define SDIO_435X_FUNC2_BLOCKSIZE	256
48 #define SDIO_4329_FUNC2_BLOCKSIZE	128
49 /* Maximum milliseconds to wait for F2 to come up */
50 #define SDIO_WAIT_F2RDY	3000
51 
52 #define BRCMF_DEFAULT_RXGLOM_SIZE	32  /* max rx frames in glom chain */
53 
54 struct brcmf_sdiod_freezer {
55 	atomic_t freezing;
56 	atomic_t thread_count;
57 	u32 frozen_count;
58 	wait_queue_head_t thread_freeze;
59 	struct completion resumed;
60 };
61 
62 static irqreturn_t brcmf_sdiod_oob_irqhandler(int irq, void *dev_id)
63 {
64 	struct brcmf_bus *bus_if = dev_get_drvdata(dev_id);
65 	struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
66 
67 	brcmf_dbg(INTR, "OOB intr triggered\n");
68 
69 	/* out-of-band interrupt is level-triggered which won't
70 	 * be cleared until dpc
71 	 */
72 	if (sdiodev->irq_en) {
73 		disable_irq_nosync(irq);
74 		sdiodev->irq_en = false;
75 	}
76 
77 	brcmf_sdio_isr(sdiodev->bus, true);
78 
79 	return IRQ_HANDLED;
80 }
81 
82 static void brcmf_sdiod_ib_irqhandler(struct sdio_func *func)
83 {
84 	struct brcmf_bus *bus_if = dev_get_drvdata(&func->dev);
85 	struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
86 
87 	brcmf_dbg(INTR, "IB intr triggered\n");
88 
89 	brcmf_sdio_isr(sdiodev->bus, false);
90 }
91 
92 /* dummy handler for SDIO function 2 interrupt */
93 static void brcmf_sdiod_dummy_irqhandler(struct sdio_func *func)
94 {
95 }
96 
97 int brcmf_sdiod_intr_register(struct brcmf_sdio_dev *sdiodev)
98 {
99 	struct brcmfmac_sdio_pd *pdata;
100 	int ret = 0;
101 	u8 data;
102 	u32 addr, gpiocontrol;
103 
104 	pdata = &sdiodev->settings->bus.sdio;
105 	if (pdata->oob_irq_supported) {
106 		brcmf_dbg(SDIO, "Enter, register OOB IRQ %d\n",
107 			  pdata->oob_irq_nr);
108 		spin_lock_init(&sdiodev->irq_en_lock);
109 		sdiodev->irq_en = true;
110 
111 		ret = request_irq(pdata->oob_irq_nr, brcmf_sdiod_oob_irqhandler,
112 				  pdata->oob_irq_flags, "brcmf_oob_intr",
113 				  &sdiodev->func1->dev);
114 		if (ret != 0) {
115 			brcmf_err("request_irq failed %d\n", ret);
116 			return ret;
117 		}
118 		sdiodev->oob_irq_requested = true;
119 
120 		ret = enable_irq_wake(pdata->oob_irq_nr);
121 		if (ret != 0) {
122 			brcmf_err("enable_irq_wake failed %d\n", ret);
123 			return ret;
124 		}
125 		disable_irq_wake(pdata->oob_irq_nr);
126 
127 		sdio_claim_host(sdiodev->func1);
128 
129 		if (sdiodev->bus_if->chip == BRCM_CC_43362_CHIP_ID) {
130 			/* assign GPIO to SDIO core */
131 			addr = brcmf_chip_enum_base(sdiodev->func1->device);
132 			addr = CORE_CC_REG(addr, gpiocontrol);
133 			gpiocontrol = brcmf_sdiod_readl(sdiodev, addr, &ret);
134 			gpiocontrol |= 0x2;
135 			brcmf_sdiod_writel(sdiodev, addr, gpiocontrol, &ret);
136 
137 			brcmf_sdiod_writeb(sdiodev, SBSDIO_GPIO_SELECT,
138 					   0xf, &ret);
139 			brcmf_sdiod_writeb(sdiodev, SBSDIO_GPIO_OUT, 0, &ret);
140 			brcmf_sdiod_writeb(sdiodev, SBSDIO_GPIO_EN, 0x2, &ret);
141 		}
142 
143 		/* must configure SDIO_CCCR_IENx to enable irq */
144 		data = brcmf_sdiod_func0_rb(sdiodev, SDIO_CCCR_IENx, &ret);
145 		data |= SDIO_CCCR_IEN_FUNC1 | SDIO_CCCR_IEN_FUNC2 |
146 			SDIO_CCCR_IEN_FUNC0;
147 		brcmf_sdiod_func0_wb(sdiodev, SDIO_CCCR_IENx, data, &ret);
148 
149 		/* redirect, configure and enable io for interrupt signal */
150 		data = SDIO_CCCR_BRCM_SEPINT_MASK | SDIO_CCCR_BRCM_SEPINT_OE;
151 		if (pdata->oob_irq_flags & IRQF_TRIGGER_HIGH)
152 			data |= SDIO_CCCR_BRCM_SEPINT_ACT_HI;
153 		brcmf_sdiod_func0_wb(sdiodev, SDIO_CCCR_BRCM_SEPINT,
154 				     data, &ret);
155 		sdio_release_host(sdiodev->func1);
156 	} else {
157 		brcmf_dbg(SDIO, "Entering\n");
158 		sdio_claim_host(sdiodev->func1);
159 		sdio_claim_irq(sdiodev->func1, brcmf_sdiod_ib_irqhandler);
160 		sdio_claim_irq(sdiodev->func2, brcmf_sdiod_dummy_irqhandler);
161 		sdio_release_host(sdiodev->func1);
162 		sdiodev->sd_irq_requested = true;
163 	}
164 
165 	return 0;
166 }
167 
168 void brcmf_sdiod_intr_unregister(struct brcmf_sdio_dev *sdiodev)
169 {
170 
171 	brcmf_dbg(SDIO, "Entering oob=%d sd=%d\n",
172 		  sdiodev->oob_irq_requested,
173 		  sdiodev->sd_irq_requested);
174 
175 	if (sdiodev->oob_irq_requested) {
176 		struct brcmfmac_sdio_pd *pdata;
177 
178 		pdata = &sdiodev->settings->bus.sdio;
179 		sdio_claim_host(sdiodev->func1);
180 		brcmf_sdiod_func0_wb(sdiodev, SDIO_CCCR_BRCM_SEPINT, 0, NULL);
181 		brcmf_sdiod_func0_wb(sdiodev, SDIO_CCCR_IENx, 0, NULL);
182 		sdio_release_host(sdiodev->func1);
183 
184 		sdiodev->oob_irq_requested = false;
185 		free_irq(pdata->oob_irq_nr, &sdiodev->func1->dev);
186 		sdiodev->irq_en = false;
187 		sdiodev->oob_irq_requested = false;
188 	}
189 
190 	if (sdiodev->sd_irq_requested) {
191 		sdio_claim_host(sdiodev->func1);
192 		sdio_release_irq(sdiodev->func2);
193 		sdio_release_irq(sdiodev->func1);
194 		sdio_release_host(sdiodev->func1);
195 		sdiodev->sd_irq_requested = false;
196 	}
197 }
198 
199 void brcmf_sdiod_change_state(struct brcmf_sdio_dev *sdiodev,
200 			      enum brcmf_sdiod_state state)
201 {
202 	if (sdiodev->state == BRCMF_SDIOD_NOMEDIUM ||
203 	    state == sdiodev->state)
204 		return;
205 
206 	brcmf_dbg(TRACE, "%d -> %d\n", sdiodev->state, state);
207 	switch (sdiodev->state) {
208 	case BRCMF_SDIOD_DATA:
209 		/* any other state means bus interface is down */
210 		brcmf_bus_change_state(sdiodev->bus_if, BRCMF_BUS_DOWN);
211 		break;
212 	case BRCMF_SDIOD_DOWN:
213 		/* transition from DOWN to DATA means bus interface is up */
214 		if (state == BRCMF_SDIOD_DATA)
215 			brcmf_bus_change_state(sdiodev->bus_if, BRCMF_BUS_UP);
216 		break;
217 	default:
218 		break;
219 	}
220 	sdiodev->state = state;
221 }
222 
223 static int brcmf_sdiod_set_backplane_window(struct brcmf_sdio_dev *sdiodev,
224 					    u32 addr)
225 {
226 	u32 v, bar0 = addr & SBSDIO_SBWINDOW_MASK;
227 	int err = 0, i;
228 
229 	if (bar0 == sdiodev->sbwad)
230 		return 0;
231 
232 	v = bar0 >> 8;
233 
234 	for (i = 0 ; i < 3 && !err ; i++, v >>= 8)
235 		brcmf_sdiod_writeb(sdiodev, SBSDIO_FUNC1_SBADDRLOW + i,
236 				   v & 0xff, &err);
237 
238 	if (!err)
239 		sdiodev->sbwad = bar0;
240 
241 	return err;
242 }
243 
244 u32 brcmf_sdiod_readl(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
245 {
246 	u32 data = 0;
247 	int retval;
248 
249 	retval = brcmf_sdiod_set_backplane_window(sdiodev, addr);
250 	if (retval)
251 		goto out;
252 
253 	addr &= SBSDIO_SB_OFT_ADDR_MASK;
254 	addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
255 
256 	data = sdio_readl(sdiodev->func1, addr, &retval);
257 
258 out:
259 	if (ret)
260 		*ret = retval;
261 
262 	return data;
263 }
264 
265 void brcmf_sdiod_writel(struct brcmf_sdio_dev *sdiodev, u32 addr,
266 			u32 data, int *ret)
267 {
268 	int retval;
269 
270 	retval = brcmf_sdiod_set_backplane_window(sdiodev, addr);
271 	if (retval)
272 		goto out;
273 
274 	addr &= SBSDIO_SB_OFT_ADDR_MASK;
275 	addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
276 
277 	sdio_writel(sdiodev->func1, data, addr, &retval);
278 
279 out:
280 	if (ret)
281 		*ret = retval;
282 }
283 
284 static int brcmf_sdiod_skbuff_read(struct brcmf_sdio_dev *sdiodev,
285 				   struct sdio_func *func, u32 addr,
286 				   struct sk_buff *skb)
287 {
288 	unsigned int req_sz;
289 	int err;
290 
291 	/* Single skb use the standard mmc interface */
292 	req_sz = skb->len + 3;
293 	req_sz &= (uint)~3;
294 
295 	switch (func->num) {
296 	case 1:
297 		err = sdio_memcpy_fromio(func, ((u8 *)(skb->data)), addr,
298 					 req_sz);
299 		break;
300 	case 2:
301 		err = sdio_readsb(func, ((u8 *)(skb->data)), addr, req_sz);
302 		break;
303 	default:
304 		/* bail out as things are really fishy here */
305 		WARN(1, "invalid sdio function number: %d\n", func->num);
306 		err = -ENOMEDIUM;
307 	}
308 
309 	if (err == -ENOMEDIUM)
310 		brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_NOMEDIUM);
311 
312 	return err;
313 }
314 
315 static int brcmf_sdiod_skbuff_write(struct brcmf_sdio_dev *sdiodev,
316 				    struct sdio_func *func, u32 addr,
317 				    struct sk_buff *skb)
318 {
319 	unsigned int req_sz;
320 	int err;
321 
322 	/* Single skb use the standard mmc interface */
323 	req_sz = skb->len + 3;
324 	req_sz &= (uint)~3;
325 
326 	err = sdio_memcpy_toio(func, addr, ((u8 *)(skb->data)), req_sz);
327 
328 	if (err == -ENOMEDIUM)
329 		brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_NOMEDIUM);
330 
331 	return err;
332 }
333 
334 static int mmc_submit_one(struct mmc_data *md, struct mmc_request *mr,
335 			  struct mmc_command *mc, int sg_cnt, int req_sz,
336 			  int func_blk_sz, u32 *addr,
337 			  struct brcmf_sdio_dev *sdiodev,
338 			  struct sdio_func *func, int write)
339 {
340 	int ret;
341 
342 	md->sg_len = sg_cnt;
343 	md->blocks = req_sz / func_blk_sz;
344 	mc->arg |= (*addr & 0x1FFFF) << 9;	/* address */
345 	mc->arg |= md->blocks & 0x1FF;	/* block count */
346 	/* incrementing addr for function 1 */
347 	if (func->num == 1)
348 		*addr += req_sz;
349 
350 	mmc_set_data_timeout(md, func->card);
351 	mmc_wait_for_req(func->card->host, mr);
352 
353 	ret = mc->error ? mc->error : md->error;
354 	if (ret == -ENOMEDIUM) {
355 		brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_NOMEDIUM);
356 	} else if (ret != 0) {
357 		brcmf_err("CMD53 sg block %s failed %d\n",
358 			  write ? "write" : "read", ret);
359 		ret = -EIO;
360 	}
361 
362 	return ret;
363 }
364 
365 /**
366  * brcmf_sdiod_sglist_rw - SDIO interface function for block data access
367  * @sdiodev: brcmfmac sdio device
368  * @func: SDIO function
369  * @write: direction flag
370  * @addr: dongle memory address as source/destination
371  * @pktlist: skb buffer head pointer
372  *
373  * This function takes the respbonsibility as the interface function to MMC
374  * stack for block data access. It assumes that the skb passed down by the
375  * caller has already been padded and aligned.
376  */
377 static int brcmf_sdiod_sglist_rw(struct brcmf_sdio_dev *sdiodev,
378 				 struct sdio_func *func,
379 				 bool write, u32 addr,
380 				 struct sk_buff_head *pktlist)
381 {
382 	unsigned int req_sz, func_blk_sz, sg_cnt, sg_data_sz, pkt_offset;
383 	unsigned int max_req_sz, src_offset, dst_offset;
384 	unsigned char *pkt_data, *orig_data, *dst_data;
385 	struct sk_buff_head local_list, *target_list;
386 	struct sk_buff *pkt_next = NULL, *src;
387 	unsigned short max_seg_cnt;
388 	struct mmc_request mmc_req;
389 	struct mmc_command mmc_cmd;
390 	struct mmc_data mmc_dat;
391 	struct scatterlist *sgl;
392 	int ret = 0;
393 
394 	if (!pktlist->qlen)
395 		return -EINVAL;
396 
397 	target_list = pktlist;
398 	/* for host with broken sg support, prepare a page aligned list */
399 	__skb_queue_head_init(&local_list);
400 	if (!write && sdiodev->settings->bus.sdio.broken_sg_support) {
401 		req_sz = 0;
402 		skb_queue_walk(pktlist, pkt_next)
403 			req_sz += pkt_next->len;
404 		req_sz = ALIGN(req_sz, func->cur_blksize);
405 		while (req_sz > PAGE_SIZE) {
406 			pkt_next = brcmu_pkt_buf_get_skb(PAGE_SIZE);
407 			if (pkt_next == NULL) {
408 				ret = -ENOMEM;
409 				goto exit;
410 			}
411 			__skb_queue_tail(&local_list, pkt_next);
412 			req_sz -= PAGE_SIZE;
413 		}
414 		pkt_next = brcmu_pkt_buf_get_skb(req_sz);
415 		if (pkt_next == NULL) {
416 			ret = -ENOMEM;
417 			goto exit;
418 		}
419 		__skb_queue_tail(&local_list, pkt_next);
420 		target_list = &local_list;
421 	}
422 
423 	func_blk_sz = func->cur_blksize;
424 	max_req_sz = sdiodev->max_request_size;
425 	max_seg_cnt = min_t(unsigned short, sdiodev->max_segment_count,
426 			    target_list->qlen);
427 
428 	memset(&mmc_req, 0, sizeof(struct mmc_request));
429 	memset(&mmc_cmd, 0, sizeof(struct mmc_command));
430 	memset(&mmc_dat, 0, sizeof(struct mmc_data));
431 
432 	mmc_dat.sg = sdiodev->sgtable.sgl;
433 	mmc_dat.blksz = func_blk_sz;
434 	mmc_dat.flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
435 	mmc_cmd.opcode = SD_IO_RW_EXTENDED;
436 	mmc_cmd.arg = write ? 1<<31 : 0;	/* write flag  */
437 	mmc_cmd.arg |= (func->num & 0x7) << 28;	/* SDIO func num */
438 	mmc_cmd.arg |= 1 << 27;			/* block mode */
439 	/* for function 1 the addr will be incremented */
440 	mmc_cmd.arg |= (func->num == 1) ? 1 << 26 : 0;
441 	mmc_cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_ADTC;
442 	mmc_req.cmd = &mmc_cmd;
443 	mmc_req.data = &mmc_dat;
444 
445 	req_sz = 0;
446 	sg_cnt = 0;
447 	sgl = sdiodev->sgtable.sgl;
448 	skb_queue_walk(target_list, pkt_next) {
449 		pkt_offset = 0;
450 		while (pkt_offset < pkt_next->len) {
451 			pkt_data = pkt_next->data + pkt_offset;
452 			sg_data_sz = pkt_next->len - pkt_offset;
453 			if (sg_data_sz > sdiodev->max_segment_size)
454 				sg_data_sz = sdiodev->max_segment_size;
455 			if (sg_data_sz > max_req_sz - req_sz)
456 				sg_data_sz = max_req_sz - req_sz;
457 
458 			sg_set_buf(sgl, pkt_data, sg_data_sz);
459 			sg_cnt++;
460 
461 			sgl = sg_next(sgl);
462 			req_sz += sg_data_sz;
463 			pkt_offset += sg_data_sz;
464 			if (req_sz >= max_req_sz || sg_cnt >= max_seg_cnt) {
465 				ret = mmc_submit_one(&mmc_dat, &mmc_req, &mmc_cmd,
466 						     sg_cnt, req_sz, func_blk_sz,
467 						     &addr, sdiodev, func, write);
468 				if (ret)
469 					goto exit_queue_walk;
470 				req_sz = 0;
471 				sg_cnt = 0;
472 				sgl = sdiodev->sgtable.sgl;
473 			}
474 		}
475 	}
476 	if (sg_cnt)
477 		ret = mmc_submit_one(&mmc_dat, &mmc_req, &mmc_cmd,
478 				     sg_cnt, req_sz, func_blk_sz,
479 				     &addr, sdiodev, func, write);
480 exit_queue_walk:
481 	if (!write && sdiodev->settings->bus.sdio.broken_sg_support) {
482 		src = __skb_peek(&local_list);
483 		src_offset = 0;
484 		skb_queue_walk(pktlist, pkt_next) {
485 			dst_offset = 0;
486 
487 			/* This is safe because we must have enough SKB data
488 			 * in the local list to cover everything in pktlist.
489 			 */
490 			while (1) {
491 				req_sz = pkt_next->len - dst_offset;
492 				if (req_sz > src->len - src_offset)
493 					req_sz = src->len - src_offset;
494 
495 				orig_data = src->data + src_offset;
496 				dst_data = pkt_next->data + dst_offset;
497 				memcpy(dst_data, orig_data, req_sz);
498 
499 				src_offset += req_sz;
500 				if (src_offset == src->len) {
501 					src_offset = 0;
502 					src = skb_peek_next(src, &local_list);
503 				}
504 				dst_offset += req_sz;
505 				if (dst_offset == pkt_next->len)
506 					break;
507 			}
508 		}
509 	}
510 
511 exit:
512 	sg_init_table(sdiodev->sgtable.sgl, sdiodev->sgtable.orig_nents);
513 	while ((pkt_next = __skb_dequeue(&local_list)) != NULL)
514 		brcmu_pkt_buf_free_skb(pkt_next);
515 
516 	return ret;
517 }
518 
519 int brcmf_sdiod_recv_buf(struct brcmf_sdio_dev *sdiodev, u8 *buf, uint nbytes)
520 {
521 	struct sk_buff *mypkt;
522 	int err;
523 
524 	mypkt = brcmu_pkt_buf_get_skb(nbytes);
525 	if (!mypkt) {
526 		brcmf_err("brcmu_pkt_buf_get_skb failed: len %d\n",
527 			  nbytes);
528 		return -EIO;
529 	}
530 
531 	err = brcmf_sdiod_recv_pkt(sdiodev, mypkt);
532 	if (!err)
533 		memcpy(buf, mypkt->data, nbytes);
534 
535 	brcmu_pkt_buf_free_skb(mypkt);
536 	return err;
537 }
538 
539 int brcmf_sdiod_recv_pkt(struct brcmf_sdio_dev *sdiodev, struct sk_buff *pkt)
540 {
541 	u32 addr = sdiodev->cc_core->base;
542 	int err = 0;
543 
544 	brcmf_dbg(SDIO, "addr = 0x%x, size = %d\n", addr, pkt->len);
545 
546 	err = brcmf_sdiod_set_backplane_window(sdiodev, addr);
547 	if (err)
548 		goto done;
549 
550 	addr &= SBSDIO_SB_OFT_ADDR_MASK;
551 	addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
552 
553 	err = brcmf_sdiod_skbuff_read(sdiodev, sdiodev->func2, addr, pkt);
554 
555 done:
556 	return err;
557 }
558 
559 int brcmf_sdiod_recv_chain(struct brcmf_sdio_dev *sdiodev,
560 			   struct sk_buff_head *pktq, uint totlen)
561 {
562 	struct sk_buff *glom_skb = NULL;
563 	struct sk_buff *skb;
564 	u32 addr = sdiodev->cc_core->base;
565 	int err = 0;
566 
567 	brcmf_dbg(SDIO, "addr = 0x%x, size = %d\n",
568 		  addr, pktq->qlen);
569 
570 	err = brcmf_sdiod_set_backplane_window(sdiodev, addr);
571 	if (err)
572 		goto done;
573 
574 	addr &= SBSDIO_SB_OFT_ADDR_MASK;
575 	addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
576 
577 	if (pktq->qlen == 1)
578 		err = brcmf_sdiod_skbuff_read(sdiodev, sdiodev->func2, addr,
579 					      __skb_peek(pktq));
580 	else if (!sdiodev->sg_support) {
581 		glom_skb = brcmu_pkt_buf_get_skb(totlen);
582 		if (!glom_skb)
583 			return -ENOMEM;
584 		err = brcmf_sdiod_skbuff_read(sdiodev, sdiodev->func2, addr,
585 					      glom_skb);
586 		if (err)
587 			goto done;
588 
589 		skb_queue_walk(pktq, skb) {
590 			memcpy(skb->data, glom_skb->data, skb->len);
591 			skb_pull(glom_skb, skb->len);
592 		}
593 	} else
594 		err = brcmf_sdiod_sglist_rw(sdiodev, sdiodev->func2, false,
595 					    addr, pktq);
596 
597 done:
598 	brcmu_pkt_buf_free_skb(glom_skb);
599 	return err;
600 }
601 
602 int brcmf_sdiod_send_buf(struct brcmf_sdio_dev *sdiodev, u8 *buf, uint nbytes)
603 {
604 	struct sk_buff *mypkt;
605 	u32 addr = sdiodev->cc_core->base;
606 	int err;
607 
608 	mypkt = brcmu_pkt_buf_get_skb(nbytes);
609 
610 	if (!mypkt) {
611 		brcmf_err("brcmu_pkt_buf_get_skb failed: len %d\n",
612 			  nbytes);
613 		return -EIO;
614 	}
615 
616 	memcpy(mypkt->data, buf, nbytes);
617 
618 	err = brcmf_sdiod_set_backplane_window(sdiodev, addr);
619 	if (err)
620 		goto out;
621 
622 	addr &= SBSDIO_SB_OFT_ADDR_MASK;
623 	addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
624 
625 	err = brcmf_sdiod_skbuff_write(sdiodev, sdiodev->func2, addr, mypkt);
626 out:
627 	brcmu_pkt_buf_free_skb(mypkt);
628 
629 	return err;
630 }
631 
632 int brcmf_sdiod_send_pkt(struct brcmf_sdio_dev *sdiodev,
633 			 struct sk_buff_head *pktq)
634 {
635 	struct sk_buff *skb;
636 	u32 addr = sdiodev->cc_core->base;
637 	int err;
638 
639 	brcmf_dbg(SDIO, "addr = 0x%x, size = %d\n", addr, pktq->qlen);
640 
641 	err = brcmf_sdiod_set_backplane_window(sdiodev, addr);
642 	if (err)
643 		return err;
644 
645 	addr &= SBSDIO_SB_OFT_ADDR_MASK;
646 	addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
647 
648 	if (pktq->qlen == 1 || !sdiodev->sg_support) {
649 		skb_queue_walk(pktq, skb) {
650 			err = brcmf_sdiod_skbuff_write(sdiodev, sdiodev->func2,
651 						       addr, skb);
652 			if (err)
653 				break;
654 		}
655 	} else {
656 		err = brcmf_sdiod_sglist_rw(sdiodev, sdiodev->func2, true,
657 					    addr, pktq);
658 	}
659 
660 	return err;
661 }
662 
663 int
664 brcmf_sdiod_ramrw(struct brcmf_sdio_dev *sdiodev, bool write, u32 address,
665 		  u8 *data, uint size)
666 {
667 	int err = 0;
668 	struct sk_buff *pkt;
669 	u32 sdaddr;
670 	uint dsize;
671 
672 	dsize = min_t(uint, SBSDIO_SB_OFT_ADDR_LIMIT, size);
673 	pkt = dev_alloc_skb(dsize);
674 	if (!pkt) {
675 		brcmf_err("dev_alloc_skb failed: len %d\n", dsize);
676 		return -EIO;
677 	}
678 	pkt->priority = 0;
679 
680 	/* Determine initial transfer parameters */
681 	sdaddr = address & SBSDIO_SB_OFT_ADDR_MASK;
682 	if ((sdaddr + size) & SBSDIO_SBWINDOW_MASK)
683 		dsize = (SBSDIO_SB_OFT_ADDR_LIMIT - sdaddr);
684 	else
685 		dsize = size;
686 
687 	sdio_claim_host(sdiodev->func1);
688 
689 	/* Do the transfer(s) */
690 	while (size) {
691 		/* Set the backplane window to include the start address */
692 		err = brcmf_sdiod_set_backplane_window(sdiodev, address);
693 		if (err)
694 			break;
695 
696 		brcmf_dbg(SDIO, "%s %d bytes at offset 0x%08x in window 0x%08x\n",
697 			  write ? "write" : "read", dsize,
698 			  sdaddr, address & SBSDIO_SBWINDOW_MASK);
699 
700 		sdaddr &= SBSDIO_SB_OFT_ADDR_MASK;
701 		sdaddr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
702 
703 		skb_put(pkt, dsize);
704 
705 		if (write) {
706 			memcpy(pkt->data, data, dsize);
707 			err = brcmf_sdiod_skbuff_write(sdiodev, sdiodev->func1,
708 						       sdaddr, pkt);
709 		} else {
710 			err = brcmf_sdiod_skbuff_read(sdiodev, sdiodev->func1,
711 						      sdaddr, pkt);
712 		}
713 
714 		if (err) {
715 			brcmf_err("membytes transfer failed\n");
716 			break;
717 		}
718 		if (!write)
719 			memcpy(data, pkt->data, dsize);
720 		skb_trim(pkt, 0);
721 
722 		/* Adjust for next transfer (if any) */
723 		size -= dsize;
724 		if (size) {
725 			data += dsize;
726 			address += dsize;
727 			sdaddr = 0;
728 			dsize = min_t(uint, SBSDIO_SB_OFT_ADDR_LIMIT, size);
729 		}
730 	}
731 
732 	dev_kfree_skb(pkt);
733 
734 	sdio_release_host(sdiodev->func1);
735 
736 	return err;
737 }
738 
739 int brcmf_sdiod_abort(struct brcmf_sdio_dev *sdiodev, struct sdio_func *func)
740 {
741 	brcmf_dbg(SDIO, "Enter\n");
742 
743 	/* Issue abort cmd52 command through F0 */
744 	brcmf_sdiod_func0_wb(sdiodev, SDIO_CCCR_ABORT, func->num, NULL);
745 
746 	brcmf_dbg(SDIO, "Exit\n");
747 	return 0;
748 }
749 
750 void brcmf_sdiod_sgtable_alloc(struct brcmf_sdio_dev *sdiodev)
751 {
752 	struct sdio_func *func;
753 	struct mmc_host *host;
754 	uint max_blocks;
755 	uint nents;
756 	int err;
757 
758 	func = sdiodev->func2;
759 	host = func->card->host;
760 	sdiodev->sg_support = host->max_segs > 1;
761 	max_blocks = min_t(uint, host->max_blk_count, 511u);
762 	sdiodev->max_request_size = min_t(uint, host->max_req_size,
763 					  max_blocks * func->cur_blksize);
764 	sdiodev->max_segment_count = min_t(uint, host->max_segs,
765 					   SG_MAX_SINGLE_ALLOC);
766 	sdiodev->max_segment_size = host->max_seg_size;
767 
768 	if (!sdiodev->sg_support)
769 		return;
770 
771 	nents = max_t(uint, BRCMF_DEFAULT_RXGLOM_SIZE,
772 		      sdiodev->settings->bus.sdio.txglomsz);
773 	nents += (nents >> 4) + 1;
774 
775 	WARN_ON(nents > sdiodev->max_segment_count);
776 
777 	brcmf_dbg(TRACE, "nents=%d\n", nents);
778 	err = sg_alloc_table(&sdiodev->sgtable, nents, GFP_KERNEL);
779 	if (err < 0) {
780 		brcmf_err("allocation failed: disable scatter-gather");
781 		sdiodev->sg_support = false;
782 	}
783 
784 	sdiodev->txglomsz = sdiodev->settings->bus.sdio.txglomsz;
785 }
786 
787 static int brcmf_sdiod_freezer_attach(struct brcmf_sdio_dev *sdiodev)
788 {
789 	if (!IS_ENABLED(CONFIG_PM_SLEEP))
790 		return 0;
791 
792 	sdiodev->freezer = kzalloc(sizeof(*sdiodev->freezer), GFP_KERNEL);
793 	if (!sdiodev->freezer)
794 		return -ENOMEM;
795 	atomic_set(&sdiodev->freezer->thread_count, 0);
796 	atomic_set(&sdiodev->freezer->freezing, 0);
797 	init_waitqueue_head(&sdiodev->freezer->thread_freeze);
798 	init_completion(&sdiodev->freezer->resumed);
799 	return 0;
800 }
801 
802 static void brcmf_sdiod_freezer_detach(struct brcmf_sdio_dev *sdiodev)
803 {
804 	if (sdiodev->freezer) {
805 		WARN_ON(atomic_read(&sdiodev->freezer->freezing));
806 		kfree(sdiodev->freezer);
807 		sdiodev->freezer = NULL;
808 	}
809 }
810 
811 static int brcmf_sdiod_freezer_on(struct brcmf_sdio_dev *sdiodev)
812 {
813 	atomic_t *expect = &sdiodev->freezer->thread_count;
814 	int res = 0;
815 
816 	sdiodev->freezer->frozen_count = 0;
817 	reinit_completion(&sdiodev->freezer->resumed);
818 	atomic_set(&sdiodev->freezer->freezing, 1);
819 	brcmf_sdio_trigger_dpc(sdiodev->bus);
820 	wait_event(sdiodev->freezer->thread_freeze,
821 		   atomic_read(expect) == sdiodev->freezer->frozen_count);
822 	sdio_claim_host(sdiodev->func1);
823 	res = brcmf_sdio_sleep(sdiodev->bus, true);
824 	sdio_release_host(sdiodev->func1);
825 	return res;
826 }
827 
828 static void brcmf_sdiod_freezer_off(struct brcmf_sdio_dev *sdiodev)
829 {
830 	sdio_claim_host(sdiodev->func1);
831 	brcmf_sdio_sleep(sdiodev->bus, false);
832 	sdio_release_host(sdiodev->func1);
833 	atomic_set(&sdiodev->freezer->freezing, 0);
834 	complete_all(&sdiodev->freezer->resumed);
835 }
836 
837 bool brcmf_sdiod_freezing(struct brcmf_sdio_dev *sdiodev)
838 {
839 	return IS_ENABLED(CONFIG_PM_SLEEP) &&
840 		atomic_read(&sdiodev->freezer->freezing);
841 }
842 
843 void brcmf_sdiod_try_freeze(struct brcmf_sdio_dev *sdiodev)
844 {
845 	if (!brcmf_sdiod_freezing(sdiodev))
846 		return;
847 	sdiodev->freezer->frozen_count++;
848 	wake_up(&sdiodev->freezer->thread_freeze);
849 	wait_for_completion(&sdiodev->freezer->resumed);
850 }
851 
852 void brcmf_sdiod_freezer_count(struct brcmf_sdio_dev *sdiodev)
853 {
854 	if (IS_ENABLED(CONFIG_PM_SLEEP))
855 		atomic_inc(&sdiodev->freezer->thread_count);
856 }
857 
858 void brcmf_sdiod_freezer_uncount(struct brcmf_sdio_dev *sdiodev)
859 {
860 	if (IS_ENABLED(CONFIG_PM_SLEEP))
861 		atomic_dec(&sdiodev->freezer->thread_count);
862 }
863 
864 int brcmf_sdiod_remove(struct brcmf_sdio_dev *sdiodev)
865 {
866 	sdiodev->state = BRCMF_SDIOD_DOWN;
867 	if (sdiodev->bus) {
868 		brcmf_sdio_remove(sdiodev->bus);
869 		sdiodev->bus = NULL;
870 	}
871 
872 	brcmf_sdiod_freezer_detach(sdiodev);
873 
874 	/* Disable functions 2 then 1. */
875 	sdio_claim_host(sdiodev->func1);
876 	sdio_disable_func(sdiodev->func2);
877 	sdio_disable_func(sdiodev->func1);
878 	sdio_release_host(sdiodev->func1);
879 
880 	sg_free_table(&sdiodev->sgtable);
881 	sdiodev->sbwad = 0;
882 
883 	pm_runtime_allow(sdiodev->func1->card->host->parent);
884 	return 0;
885 }
886 
887 static void brcmf_sdiod_host_fixup(struct mmc_host *host)
888 {
889 	/* runtime-pm powers off the device */
890 	pm_runtime_forbid(host->parent);
891 	/* avoid removal detection upon resume */
892 	host->caps |= MMC_CAP_NONREMOVABLE;
893 }
894 
895 int brcmf_sdiod_probe(struct brcmf_sdio_dev *sdiodev)
896 {
897 	int ret = 0;
898 	unsigned int f2_blksz = SDIO_FUNC2_BLOCKSIZE;
899 
900 	sdio_claim_host(sdiodev->func1);
901 
902 	ret = sdio_set_block_size(sdiodev->func1, SDIO_FUNC1_BLOCKSIZE);
903 	if (ret) {
904 		brcmf_err("Failed to set F1 blocksize\n");
905 		sdio_release_host(sdiodev->func1);
906 		return ret;
907 	}
908 	switch (sdiodev->func2->device) {
909 	case SDIO_DEVICE_ID_BROADCOM_CYPRESS_4373:
910 		f2_blksz = SDIO_4373_FUNC2_BLOCKSIZE;
911 		break;
912 	case SDIO_DEVICE_ID_BROADCOM_4359:
913 	case SDIO_DEVICE_ID_BROADCOM_4354:
914 	case SDIO_DEVICE_ID_BROADCOM_4356:
915 		f2_blksz = SDIO_435X_FUNC2_BLOCKSIZE;
916 		break;
917 	case SDIO_DEVICE_ID_BROADCOM_4329:
918 		f2_blksz = SDIO_4329_FUNC2_BLOCKSIZE;
919 		break;
920 	default:
921 		break;
922 	}
923 
924 	ret = sdio_set_block_size(sdiodev->func2, f2_blksz);
925 	if (ret) {
926 		brcmf_err("Failed to set F2 blocksize\n");
927 		sdio_release_host(sdiodev->func1);
928 		return ret;
929 	} else {
930 		brcmf_dbg(SDIO, "set F2 blocksize to %d\n", f2_blksz);
931 	}
932 
933 	/* increase F2 timeout */
934 	sdiodev->func2->enable_timeout = SDIO_WAIT_F2RDY;
935 
936 	/* Enable Function 1 */
937 	ret = sdio_enable_func(sdiodev->func1);
938 	sdio_release_host(sdiodev->func1);
939 	if (ret) {
940 		brcmf_err("Failed to enable F1: err=%d\n", ret);
941 		goto out;
942 	}
943 
944 	ret = brcmf_sdiod_freezer_attach(sdiodev);
945 	if (ret)
946 		goto out;
947 
948 	/* try to attach to the target device */
949 	sdiodev->bus = brcmf_sdio_probe(sdiodev);
950 	if (!sdiodev->bus) {
951 		ret = -ENODEV;
952 		goto out;
953 	}
954 	brcmf_sdiod_host_fixup(sdiodev->func2->card->host);
955 out:
956 	if (ret)
957 		brcmf_sdiod_remove(sdiodev);
958 
959 	return ret;
960 }
961 
962 #define BRCMF_SDIO_DEVICE(dev_id)	\
963 	{SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, dev_id)}
964 
965 /* devices we support, null terminated */
966 static const struct sdio_device_id brcmf_sdmmc_ids[] = {
967 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43143),
968 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43241),
969 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4329),
970 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4330),
971 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4334),
972 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43340),
973 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43341),
974 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43362),
975 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43364),
976 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4335_4339),
977 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4339),
978 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43430),
979 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4345),
980 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43455),
981 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4354),
982 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4356),
983 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4359),
984 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_CYPRESS_4373),
985 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_CYPRESS_43012),
986 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_CYPRESS_43752),
987 	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_CYPRESS_89359),
988 	{ /* end: all zeroes */ }
989 };
990 MODULE_DEVICE_TABLE(sdio, brcmf_sdmmc_ids);
991 
992 
993 static void brcmf_sdiod_acpi_set_power_manageable(struct device *dev,
994 						  int val)
995 {
996 #if IS_ENABLED(CONFIG_ACPI)
997 	struct acpi_device *adev;
998 
999 	adev = ACPI_COMPANION(dev);
1000 	if (adev)
1001 		adev->flags.power_manageable = 0;
1002 #endif
1003 }
1004 
1005 static int brcmf_ops_sdio_probe(struct sdio_func *func,
1006 				const struct sdio_device_id *id)
1007 {
1008 	int err;
1009 	struct brcmf_sdio_dev *sdiodev;
1010 	struct brcmf_bus *bus_if;
1011 	struct device *dev;
1012 
1013 	brcmf_dbg(SDIO, "Enter\n");
1014 	brcmf_dbg(SDIO, "Class=%x\n", func->class);
1015 	brcmf_dbg(SDIO, "sdio vendor ID: 0x%04x\n", func->vendor);
1016 	brcmf_dbg(SDIO, "sdio device ID: 0x%04x\n", func->device);
1017 	brcmf_dbg(SDIO, "Function#: %d\n", func->num);
1018 
1019 	dev = &func->dev;
1020 
1021 	/* Set MMC_QUIRK_LENIENT_FN0 for this card */
1022 	func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
1023 
1024 	/* prohibit ACPI power management for this device */
1025 	brcmf_sdiod_acpi_set_power_manageable(dev, 0);
1026 
1027 	/* Consume func num 1 but dont do anything with it. */
1028 	if (func->num == 1)
1029 		return 0;
1030 
1031 	/* Ignore anything but func 2 */
1032 	if (func->num != 2)
1033 		return -ENODEV;
1034 
1035 	bus_if = kzalloc(sizeof(struct brcmf_bus), GFP_KERNEL);
1036 	if (!bus_if)
1037 		return -ENOMEM;
1038 	sdiodev = kzalloc(sizeof(struct brcmf_sdio_dev), GFP_KERNEL);
1039 	if (!sdiodev) {
1040 		kfree(bus_if);
1041 		return -ENOMEM;
1042 	}
1043 
1044 	/* store refs to functions used. mmc_card does
1045 	 * not hold the F0 function pointer.
1046 	 */
1047 	sdiodev->func1 = func->card->sdio_func[0];
1048 	sdiodev->func2 = func;
1049 
1050 	sdiodev->bus_if = bus_if;
1051 	bus_if->bus_priv.sdio = sdiodev;
1052 	bus_if->proto_type = BRCMF_PROTO_BCDC;
1053 	dev_set_drvdata(&func->dev, bus_if);
1054 	dev_set_drvdata(&sdiodev->func1->dev, bus_if);
1055 	sdiodev->dev = &sdiodev->func1->dev;
1056 
1057 	brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_DOWN);
1058 
1059 	brcmf_dbg(SDIO, "F2 found, calling brcmf_sdiod_probe...\n");
1060 	err = brcmf_sdiod_probe(sdiodev);
1061 	if (err) {
1062 		brcmf_err("F2 error, probe failed %d...\n", err);
1063 		goto fail;
1064 	}
1065 
1066 	brcmf_dbg(SDIO, "F2 init completed...\n");
1067 	return 0;
1068 
1069 fail:
1070 	dev_set_drvdata(&func->dev, NULL);
1071 	dev_set_drvdata(&sdiodev->func1->dev, NULL);
1072 	kfree(sdiodev);
1073 	kfree(bus_if);
1074 	return err;
1075 }
1076 
1077 static void brcmf_ops_sdio_remove(struct sdio_func *func)
1078 {
1079 	struct brcmf_bus *bus_if;
1080 	struct brcmf_sdio_dev *sdiodev;
1081 
1082 	brcmf_dbg(SDIO, "Enter\n");
1083 	brcmf_dbg(SDIO, "sdio vendor ID: 0x%04x\n", func->vendor);
1084 	brcmf_dbg(SDIO, "sdio device ID: 0x%04x\n", func->device);
1085 	brcmf_dbg(SDIO, "Function: %d\n", func->num);
1086 
1087 	bus_if = dev_get_drvdata(&func->dev);
1088 	if (bus_if) {
1089 		sdiodev = bus_if->bus_priv.sdio;
1090 
1091 		/* start by unregistering irqs */
1092 		brcmf_sdiod_intr_unregister(sdiodev);
1093 
1094 		if (func->num != 1)
1095 			return;
1096 
1097 		/* only proceed with rest of cleanup if func 1 */
1098 		brcmf_sdiod_remove(sdiodev);
1099 
1100 		dev_set_drvdata(&sdiodev->func1->dev, NULL);
1101 		dev_set_drvdata(&sdiodev->func2->dev, NULL);
1102 
1103 		kfree(bus_if);
1104 		kfree(sdiodev);
1105 	}
1106 
1107 	brcmf_dbg(SDIO, "Exit\n");
1108 }
1109 
1110 void brcmf_sdio_wowl_config(struct device *dev, bool enabled)
1111 {
1112 	struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1113 	struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
1114 	mmc_pm_flag_t pm_caps = sdio_get_host_pm_caps(sdiodev->func1);
1115 
1116 	/* Power must be preserved to be able to support WOWL. */
1117 	if (!(pm_caps & MMC_PM_KEEP_POWER))
1118 		goto notsup;
1119 
1120 	if (sdiodev->settings->bus.sdio.oob_irq_supported ||
1121 	    pm_caps & MMC_PM_WAKE_SDIO_IRQ) {
1122 		sdiodev->wowl_enabled = enabled;
1123 		brcmf_dbg(SDIO, "Configuring WOWL, enabled=%d\n", enabled);
1124 		return;
1125 	}
1126 
1127 notsup:
1128 	brcmf_dbg(SDIO, "WOWL not supported\n");
1129 }
1130 
1131 static int brcmf_ops_sdio_suspend(struct device *dev)
1132 {
1133 	struct sdio_func *func;
1134 	struct brcmf_bus *bus_if;
1135 	struct brcmf_sdio_dev *sdiodev;
1136 	mmc_pm_flag_t sdio_flags;
1137 	int ret = 0;
1138 
1139 	func = container_of(dev, struct sdio_func, dev);
1140 	brcmf_dbg(SDIO, "Enter: F%d\n", func->num);
1141 	if (func->num != 1)
1142 		return 0;
1143 
1144 
1145 	bus_if = dev_get_drvdata(dev);
1146 	sdiodev = bus_if->bus_priv.sdio;
1147 
1148 	if (sdiodev->wowl_enabled) {
1149 		brcmf_sdiod_freezer_on(sdiodev);
1150 		brcmf_sdio_wd_timer(sdiodev->bus, 0);
1151 
1152 		sdio_flags = MMC_PM_KEEP_POWER;
1153 		if (sdiodev->settings->bus.sdio.oob_irq_supported)
1154 			enable_irq_wake(sdiodev->settings->bus.sdio.oob_irq_nr);
1155 		else
1156 			sdio_flags |= MMC_PM_WAKE_SDIO_IRQ;
1157 
1158 		if (sdio_set_host_pm_flags(sdiodev->func1, sdio_flags))
1159 			brcmf_err("Failed to set pm_flags %x\n", sdio_flags);
1160 
1161 	} else {
1162 		/* power will be cut so remove device, probe again in resume */
1163 		brcmf_sdiod_intr_unregister(sdiodev);
1164 		ret = brcmf_sdiod_remove(sdiodev);
1165 		if (ret)
1166 			brcmf_err("Failed to remove device on suspend\n");
1167 	}
1168 
1169 	return ret;
1170 }
1171 
1172 static int brcmf_ops_sdio_resume(struct device *dev)
1173 {
1174 	struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1175 	struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
1176 	struct sdio_func *func = container_of(dev, struct sdio_func, dev);
1177 	int ret = 0;
1178 
1179 	brcmf_dbg(SDIO, "Enter: F%d\n", func->num);
1180 	if (func->num != 2)
1181 		return 0;
1182 
1183 	if (!sdiodev->wowl_enabled) {
1184 		/* bus was powered off and device removed, probe again */
1185 		ret = brcmf_sdiod_probe(sdiodev);
1186 		if (ret)
1187 			brcmf_err("Failed to probe device on resume\n");
1188 	} else {
1189 		if (sdiodev->settings->bus.sdio.oob_irq_supported)
1190 			disable_irq_wake(sdiodev->settings->bus.sdio.oob_irq_nr);
1191 
1192 		brcmf_sdiod_freezer_off(sdiodev);
1193 	}
1194 
1195 	return ret;
1196 }
1197 
1198 static DEFINE_SIMPLE_DEV_PM_OPS(brcmf_sdio_pm_ops,
1199 				brcmf_ops_sdio_suspend,
1200 				brcmf_ops_sdio_resume);
1201 
1202 static struct sdio_driver brcmf_sdmmc_driver = {
1203 	.probe = brcmf_ops_sdio_probe,
1204 	.remove = brcmf_ops_sdio_remove,
1205 	.name = KBUILD_MODNAME,
1206 	.id_table = brcmf_sdmmc_ids,
1207 	.drv = {
1208 		.owner = THIS_MODULE,
1209 		.pm = pm_sleep_ptr(&brcmf_sdio_pm_ops),
1210 		.coredump = brcmf_dev_coredump,
1211 	},
1212 };
1213 
1214 int brcmf_sdio_register(void)
1215 {
1216 	return sdio_register_driver(&brcmf_sdmmc_driver);
1217 }
1218 
1219 void brcmf_sdio_exit(void)
1220 {
1221 	brcmf_dbg(SDIO, "Enter\n");
1222 
1223 	sdio_unregister_driver(&brcmf_sdmmc_driver);
1224 }
1225 
1226