bcmsdh.c

   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
  54struct 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
  62static 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
  82static 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 */
  93static void brcmf_sdiod_dummy_irqhandler(struct sdio_func *func)
  94{
  95}
  96
  97int 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
 168void 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
 199void 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
 223static 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
 244u32 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
 258out:
 259	if (ret)
 260		*ret = retval;
 261
 262	return data;
 263}
 264
 265void 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
 279out:
 280	if (ret)
 281		*ret = retval;
 282}
 283
 284static 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
 315static 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
 334static 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 */
 377static 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			if (!sgl) {
 459				/* out of (pre-allocated) scatterlist entries */
 460				ret = -ENOMEM;
 461				goto exit;
 462			}
 463			sg_set_buf(sgl, pkt_data, sg_data_sz);
 464			sg_cnt++;
 465
 466			sgl = sg_next(sgl);
 467			req_sz += sg_data_sz;
 468			pkt_offset += sg_data_sz;
 469			if (req_sz >= max_req_sz || sg_cnt >= max_seg_cnt) {
 470				ret = mmc_submit_one(&mmc_dat, &mmc_req, &mmc_cmd,
 471						     sg_cnt, req_sz, func_blk_sz,
 472						     &addr, sdiodev, func, write);
 473				if (ret)
 474					goto exit_queue_walk;
 475				req_sz = 0;
 476				sg_cnt = 0;
 477				sgl = sdiodev->sgtable.sgl;
 478			}
 479		}
 480	}
 481	if (sg_cnt)
 482		ret = mmc_submit_one(&mmc_dat, &mmc_req, &mmc_cmd,
 483				     sg_cnt, req_sz, func_blk_sz,
 484				     &addr, sdiodev, func, write);
 485exit_queue_walk:
 486	if (!write && sdiodev->settings->bus.sdio.broken_sg_support) {
 487		src = __skb_peek(&local_list);
 488		src_offset = 0;
 489		skb_queue_walk(pktlist, pkt_next) {
 490			dst_offset = 0;
 491
 492			/* This is safe because we must have enough SKB data
 493			 * in the local list to cover everything in pktlist.
 494			 */
 495			while (1) {
 496				req_sz = pkt_next->len - dst_offset;
 497				if (req_sz > src->len - src_offset)
 498					req_sz = src->len - src_offset;
 499
 500				orig_data = src->data + src_offset;
 501				dst_data = pkt_next->data + dst_offset;
 502				memcpy(dst_data, orig_data, req_sz);
 503
 504				src_offset += req_sz;
 505				if (src_offset == src->len) {
 506					src_offset = 0;
 507					src = skb_peek_next(src, &local_list);
 508				}
 509				dst_offset += req_sz;
 510				if (dst_offset == pkt_next->len)
 511					break;
 512			}
 513		}
 514	}
 515
 516exit:
 517	sg_init_table(sdiodev->sgtable.sgl, sdiodev->sgtable.orig_nents);
 518	while ((pkt_next = __skb_dequeue(&local_list)) != NULL)
 519		brcmu_pkt_buf_free_skb(pkt_next);
 520
 521	return ret;
 522}
 523
 524int brcmf_sdiod_recv_buf(struct brcmf_sdio_dev *sdiodev, u8 *buf, uint nbytes)
 525{
 526	struct sk_buff *mypkt;
 527	int err;
 528
 529	mypkt = brcmu_pkt_buf_get_skb(nbytes);
 530	if (!mypkt) {
 531		brcmf_err("brcmu_pkt_buf_get_skb failed: len %d\n",
 532			  nbytes);
 533		return -EIO;
 534	}
 535
 536	err = brcmf_sdiod_recv_pkt(sdiodev, mypkt);
 537	if (!err)
 538		memcpy(buf, mypkt->data, nbytes);
 539
 540	brcmu_pkt_buf_free_skb(mypkt);
 541	return err;
 542}
 543
 544int brcmf_sdiod_recv_pkt(struct brcmf_sdio_dev *sdiodev, struct sk_buff *pkt)
 545{
 546	u32 addr = sdiodev->cc_core->base;
 547	int err = 0;
 548
 549	brcmf_dbg(SDIO, "addr = 0x%x, size = %d\n", addr, pkt->len);
 550
 551	err = brcmf_sdiod_set_backplane_window(sdiodev, addr);
 552	if (err)
 553		goto done;
 554
 555	addr &= SBSDIO_SB_OFT_ADDR_MASK;
 556	addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 557
 558	err = brcmf_sdiod_skbuff_read(sdiodev, sdiodev->func2, addr, pkt);
 559
 560done:
 561	return err;
 562}
 563
 564int brcmf_sdiod_recv_chain(struct brcmf_sdio_dev *sdiodev,
 565			   struct sk_buff_head *pktq, uint totlen)
 566{
 567	struct sk_buff *glom_skb = NULL;
 568	struct sk_buff *skb;
 569	u32 addr = sdiodev->cc_core->base;
 570	int err = 0;
 571
 572	brcmf_dbg(SDIO, "addr = 0x%x, size = %d\n",
 573		  addr, pktq->qlen);
 574
 575	err = brcmf_sdiod_set_backplane_window(sdiodev, addr);
 576	if (err)
 577		goto done;
 578
 579	addr &= SBSDIO_SB_OFT_ADDR_MASK;
 580	addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 581
 582	if (pktq->qlen == 1)
 583		err = brcmf_sdiod_skbuff_read(sdiodev, sdiodev->func2, addr,
 584					      __skb_peek(pktq));
 585	else if (!sdiodev->sg_support) {
 586		glom_skb = brcmu_pkt_buf_get_skb(totlen);
 587		if (!glom_skb)
 588			return -ENOMEM;
 589		err = brcmf_sdiod_skbuff_read(sdiodev, sdiodev->func2, addr,
 590					      glom_skb);
 591		if (err)
 592			goto done;
 593
 594		skb_queue_walk(pktq, skb) {
 595			memcpy(skb->data, glom_skb->data, skb->len);
 596			skb_pull(glom_skb, skb->len);
 597		}
 598	} else
 599		err = brcmf_sdiod_sglist_rw(sdiodev, sdiodev->func2, false,
 600					    addr, pktq);
 601
 602done:
 603	brcmu_pkt_buf_free_skb(glom_skb);
 604	return err;
 605}
 606
 607int brcmf_sdiod_send_buf(struct brcmf_sdio_dev *sdiodev, u8 *buf, uint nbytes)
 608{
 609	struct sk_buff *mypkt;
 610	u32 addr = sdiodev->cc_core->base;
 611	int err;
 612
 613	mypkt = brcmu_pkt_buf_get_skb(nbytes);
 614
 615	if (!mypkt) {
 616		brcmf_err("brcmu_pkt_buf_get_skb failed: len %d\n",
 617			  nbytes);
 618		return -EIO;
 619	}
 620
 621	memcpy(mypkt->data, buf, nbytes);
 622
 623	err = brcmf_sdiod_set_backplane_window(sdiodev, addr);
 624	if (err)
 625		goto out;
 626
 627	addr &= SBSDIO_SB_OFT_ADDR_MASK;
 628	addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 629
 630	err = brcmf_sdiod_skbuff_write(sdiodev, sdiodev->func2, addr, mypkt);
 631out:
 632	brcmu_pkt_buf_free_skb(mypkt);
 633
 634	return err;
 635}
 636
 637int brcmf_sdiod_send_pkt(struct brcmf_sdio_dev *sdiodev,
 638			 struct sk_buff_head *pktq)
 639{
 640	struct sk_buff *skb;
 641	u32 addr = sdiodev->cc_core->base;
 642	int err;
 643
 644	brcmf_dbg(SDIO, "addr = 0x%x, size = %d\n", addr, pktq->qlen);
 645
 646	err = brcmf_sdiod_set_backplane_window(sdiodev, addr);
 647	if (err)
 648		return err;
 649
 650	addr &= SBSDIO_SB_OFT_ADDR_MASK;
 651	addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 652
 653	if (pktq->qlen == 1 || !sdiodev->sg_support) {
 654		skb_queue_walk(pktq, skb) {
 655			err = brcmf_sdiod_skbuff_write(sdiodev, sdiodev->func2,
 656						       addr, skb);
 657			if (err)
 658				break;
 659		}
 660	} else {
 661		err = brcmf_sdiod_sglist_rw(sdiodev, sdiodev->func2, true,
 662					    addr, pktq);
 663	}
 664
 665	return err;
 666}
 667
 668int
 669brcmf_sdiod_ramrw(struct brcmf_sdio_dev *sdiodev, bool write, u32 address,
 670		  u8 *data, uint size)
 671{
 672	int err = 0;
 673	struct sk_buff *pkt;
 674	u32 sdaddr;
 675	uint dsize;
 676
 677	dsize = min_t(uint, SBSDIO_SB_OFT_ADDR_LIMIT, size);
 678	pkt = dev_alloc_skb(dsize);
 679	if (!pkt) {
 680		brcmf_err("dev_alloc_skb failed: len %d\n", dsize);
 681		return -EIO;
 682	}
 683	pkt->priority = 0;
 684
 685	/* Determine initial transfer parameters */
 686	sdaddr = address & SBSDIO_SB_OFT_ADDR_MASK;
 687	if ((sdaddr + size) & SBSDIO_SBWINDOW_MASK)
 688		dsize = (SBSDIO_SB_OFT_ADDR_LIMIT - sdaddr);
 689	else
 690		dsize = size;
 691
 692	sdio_claim_host(sdiodev->func1);
 693
 694	/* Do the transfer(s) */
 695	while (size) {
 696		/* Set the backplane window to include the start address */
 697		err = brcmf_sdiod_set_backplane_window(sdiodev, address);
 698		if (err)
 699			break;
 700
 701		brcmf_dbg(SDIO, "%s %d bytes at offset 0x%08x in window 0x%08x\n",
 702			  write ? "write" : "read", dsize,
 703			  sdaddr, address & SBSDIO_SBWINDOW_MASK);
 704
 705		sdaddr &= SBSDIO_SB_OFT_ADDR_MASK;
 706		sdaddr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
 707
 708		skb_put(pkt, dsize);
 709
 710		if (write) {
 711			memcpy(pkt->data, data, dsize);
 712			err = brcmf_sdiod_skbuff_write(sdiodev, sdiodev->func1,
 713						       sdaddr, pkt);
 714		} else {
 715			err = brcmf_sdiod_skbuff_read(sdiodev, sdiodev->func1,
 716						      sdaddr, pkt);
 717		}
 718
 719		if (err) {
 720			brcmf_err("membytes transfer failed\n");
 721			break;
 722		}
 723		if (!write)
 724			memcpy(data, pkt->data, dsize);
 725		skb_trim(pkt, 0);
 726
 727		/* Adjust for next transfer (if any) */
 728		size -= dsize;
 729		if (size) {
 730			data += dsize;
 731			address += dsize;
 732			sdaddr = 0;
 733			dsize = min_t(uint, SBSDIO_SB_OFT_ADDR_LIMIT, size);
 734		}
 735	}
 736
 737	dev_kfree_skb(pkt);
 738
 739	sdio_release_host(sdiodev->func1);
 740
 741	return err;
 742}
 743
 744int brcmf_sdiod_abort(struct brcmf_sdio_dev *sdiodev, struct sdio_func *func)
 745{
 746	brcmf_dbg(SDIO, "Enter\n");
 747
 748	/* Issue abort cmd52 command through F0 */
 749	brcmf_sdiod_func0_wb(sdiodev, SDIO_CCCR_ABORT, func->num, NULL);
 750
 751	brcmf_dbg(SDIO, "Exit\n");
 752	return 0;
 753}
 754
 755void brcmf_sdiod_sgtable_alloc(struct brcmf_sdio_dev *sdiodev)
 756{
 757	struct sdio_func *func;
 758	struct mmc_host *host;
 759	uint max_blocks;
 760	uint nents;
 761	int err;
 762
 763	func = sdiodev->func2;
 764	host = func->card->host;
 765	sdiodev->sg_support = host->max_segs > 1;
 766	max_blocks = min_t(uint, host->max_blk_count, 511u);
 767	sdiodev->max_request_size = min_t(uint, host->max_req_size,
 768					  max_blocks * func->cur_blksize);
 769	sdiodev->max_segment_count = min_t(uint, host->max_segs,
 770					   SG_MAX_SINGLE_ALLOC);
 771	sdiodev->max_segment_size = host->max_seg_size;
 772
 773	if (!sdiodev->sg_support)
 774		return;
 775
 776	nents = max_t(uint, BRCMF_DEFAULT_RXGLOM_SIZE,
 777		      sdiodev->settings->bus.sdio.txglomsz);
 778	nents *= 2;
 779
 780	WARN_ON(nents > sdiodev->max_segment_count);
 781
 782	brcmf_dbg(TRACE, "nents=%d\n", nents);
 783	err = sg_alloc_table(&sdiodev->sgtable, nents, GFP_KERNEL);
 784	if (err < 0) {
 785		brcmf_err("allocation failed: disable scatter-gather");
 786		sdiodev->sg_support = false;
 787	}
 788
 789	sdiodev->txglomsz = sdiodev->settings->bus.sdio.txglomsz;
 790}
 791
 792static int brcmf_sdiod_freezer_attach(struct brcmf_sdio_dev *sdiodev)
 793{
 794	if (!IS_ENABLED(CONFIG_PM_SLEEP))
 795		return 0;
 796
 797	sdiodev->freezer = kzalloc(sizeof(*sdiodev->freezer), GFP_KERNEL);
 798	if (!sdiodev->freezer)
 799		return -ENOMEM;
 800	atomic_set(&sdiodev->freezer->thread_count, 0);
 801	atomic_set(&sdiodev->freezer->freezing, 0);
 802	init_waitqueue_head(&sdiodev->freezer->thread_freeze);
 803	init_completion(&sdiodev->freezer->resumed);
 804	return 0;
 805}
 806
 807static void brcmf_sdiod_freezer_detach(struct brcmf_sdio_dev *sdiodev)
 808{
 809	if (sdiodev->freezer) {
 810		WARN_ON(atomic_read(&sdiodev->freezer->freezing));
 811		kfree(sdiodev->freezer);
 812		sdiodev->freezer = NULL;
 813	}
 814}
 815
 816static int brcmf_sdiod_freezer_on(struct brcmf_sdio_dev *sdiodev)
 817{
 818	atomic_t *expect = &sdiodev->freezer->thread_count;
 819	int res = 0;
 820
 821	sdiodev->freezer->frozen_count = 0;
 822	reinit_completion(&sdiodev->freezer->resumed);
 823	atomic_set(&sdiodev->freezer->freezing, 1);
 824	brcmf_sdio_trigger_dpc(sdiodev->bus);
 825	wait_event(sdiodev->freezer->thread_freeze,
 826		   atomic_read(expect) == sdiodev->freezer->frozen_count);
 827	sdio_claim_host(sdiodev->func1);
 828	res = brcmf_sdio_sleep(sdiodev->bus, true);
 829	sdio_release_host(sdiodev->func1);
 830	return res;
 831}
 832
 833static void brcmf_sdiod_freezer_off(struct brcmf_sdio_dev *sdiodev)
 834{
 835	sdio_claim_host(sdiodev->func1);
 836	brcmf_sdio_sleep(sdiodev->bus, false);
 837	sdio_release_host(sdiodev->func1);
 838	atomic_set(&sdiodev->freezer->freezing, 0);
 839	complete_all(&sdiodev->freezer->resumed);
 840}
 841
 842bool brcmf_sdiod_freezing(struct brcmf_sdio_dev *sdiodev)
 843{
 844	return IS_ENABLED(CONFIG_PM_SLEEP) &&
 845		atomic_read(&sdiodev->freezer->freezing);
 846}
 847
 848void brcmf_sdiod_try_freeze(struct brcmf_sdio_dev *sdiodev)
 849{
 850	if (!brcmf_sdiod_freezing(sdiodev))
 851		return;
 852	sdiodev->freezer->frozen_count++;
 853	wake_up(&sdiodev->freezer->thread_freeze);
 854	wait_for_completion(&sdiodev->freezer->resumed);
 855}
 856
 857void brcmf_sdiod_freezer_count(struct brcmf_sdio_dev *sdiodev)
 858{
 859	if (IS_ENABLED(CONFIG_PM_SLEEP))
 860		atomic_inc(&sdiodev->freezer->thread_count);
 861}
 862
 863void brcmf_sdiod_freezer_uncount(struct brcmf_sdio_dev *sdiodev)
 864{
 865	if (IS_ENABLED(CONFIG_PM_SLEEP))
 866		atomic_dec(&sdiodev->freezer->thread_count);
 867}
 868
 869int brcmf_sdiod_remove(struct brcmf_sdio_dev *sdiodev)
 870{
 871	sdiodev->state = BRCMF_SDIOD_DOWN;
 872	if (sdiodev->bus) {
 873		brcmf_sdio_remove(sdiodev->bus);
 874		sdiodev->bus = NULL;
 875	}
 876
 877	brcmf_sdiod_freezer_detach(sdiodev);
 878
 879	/* Disable functions 2 then 1. */
 880	sdio_claim_host(sdiodev->func1);
 881	sdio_disable_func(sdiodev->func2);
 882	sdio_disable_func(sdiodev->func1);
 883	sdio_release_host(sdiodev->func1);
 884
 885	sg_free_table(&sdiodev->sgtable);
 886	sdiodev->sbwad = 0;
 887
 888	pm_runtime_allow(sdiodev->func1->card->host->parent);
 889	return 0;
 890}
 891
 892static void brcmf_sdiod_host_fixup(struct mmc_host *host)
 893{
 894	/* runtime-pm powers off the device */
 895	pm_runtime_forbid(host->parent);
 896	/* avoid removal detection upon resume */
 897	host->caps |= MMC_CAP_NONREMOVABLE;
 898}
 899
 900int brcmf_sdiod_probe(struct brcmf_sdio_dev *sdiodev)
 901{
 902	int ret = 0;
 903	unsigned int f2_blksz = SDIO_FUNC2_BLOCKSIZE;
 904
 905	sdio_claim_host(sdiodev->func1);
 906
 907	ret = sdio_set_block_size(sdiodev->func1, SDIO_FUNC1_BLOCKSIZE);
 908	if (ret) {
 909		brcmf_err("Failed to set F1 blocksize\n");
 910		sdio_release_host(sdiodev->func1);
 911		return ret;
 912	}
 913	switch (sdiodev->func2->device) {
 914	case SDIO_DEVICE_ID_BROADCOM_CYPRESS_4373:
 915		f2_blksz = SDIO_4373_FUNC2_BLOCKSIZE;
 916		break;
 917	case SDIO_DEVICE_ID_BROADCOM_4359:
 918	case SDIO_DEVICE_ID_BROADCOM_4354:
 919	case SDIO_DEVICE_ID_BROADCOM_4356:
 920		f2_blksz = SDIO_435X_FUNC2_BLOCKSIZE;
 921		break;
 922	case SDIO_DEVICE_ID_BROADCOM_4329:
 923		f2_blksz = SDIO_4329_FUNC2_BLOCKSIZE;
 924		break;
 925	default:
 926		break;
 927	}
 928
 929	ret = sdio_set_block_size(sdiodev->func2, f2_blksz);
 930	if (ret) {
 931		brcmf_err("Failed to set F2 blocksize\n");
 932		sdio_release_host(sdiodev->func1);
 933		return ret;
 934	} else {
 935		brcmf_dbg(SDIO, "set F2 blocksize to %d\n", f2_blksz);
 936	}
 937
 938	/* increase F2 timeout */
 939	sdiodev->func2->enable_timeout = SDIO_WAIT_F2RDY;
 940
 941	/* Enable Function 1 */
 942	ret = sdio_enable_func(sdiodev->func1);
 943	sdio_release_host(sdiodev->func1);
 944	if (ret) {
 945		brcmf_err("Failed to enable F1: err=%d\n", ret);
 946		goto out;
 947	}
 948
 949	ret = brcmf_sdiod_freezer_attach(sdiodev);
 950	if (ret)
 951		goto out;
 952
 953	/* try to attach to the target device */
 954	ret = brcmf_sdio_probe(sdiodev);
 955	if (ret)
 956		goto out;
 957
 958	brcmf_sdiod_host_fixup(sdiodev->func2->card->host);
 959out:
 960	if (ret)
 961		brcmf_sdiod_remove(sdiodev);
 962
 963	return ret;
 964}
 965
 966#define BRCMF_SDIO_DEVICE(dev_id, fw_vend) \
 967	{ \
 968		SDIO_DEVICE(SDIO_VENDOR_ID_BROADCOM, dev_id), \
 969		.driver_data = BRCMF_FWVENDOR_ ## fw_vend \
 970	}
 971
 972#define CYW_SDIO_DEVICE(dev_id, fw_vend) \
 973	{ \
 974		SDIO_DEVICE(SDIO_VENDOR_ID_CYPRESS, dev_id), \
 975		.driver_data = BRCMF_FWVENDOR_ ## fw_vend \
 976	}
 977
 978/* devices we support, null terminated */
 979static const struct sdio_device_id brcmf_sdmmc_ids[] = {
 980	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43143, WCC),
 981	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43241, WCC),
 982	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4329, WCC),
 983	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4330, WCC),
 984	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4334, WCC),
 985	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43340, WCC),
 986	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43341, WCC),
 987	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43362, WCC),
 988	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43364, WCC),
 989	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4335_4339, WCC),
 990	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4339, WCC),
 991	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43430, WCC),
 992	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43439, WCC),
 993	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4345, WCC),
 994	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43455, WCC),
 995	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4354, WCC),
 996	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4356, WCC),
 997	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_4359, WCC),
 998	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43751, WCC),
 999	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_43752, WCC),
1000	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_CYPRESS_4373, CYW),
1001	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_CYPRESS_43012, CYW),
1002	BRCMF_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_CYPRESS_89359, CYW),
1003	CYW_SDIO_DEVICE(SDIO_DEVICE_ID_BROADCOM_CYPRESS_43439, CYW),
1004	{ /* end: all zeroes */ }
1005};
1006MODULE_DEVICE_TABLE(sdio, brcmf_sdmmc_ids);
1007
1008
1009static void brcmf_sdiod_acpi_save_power_manageable(struct brcmf_sdio_dev *sdiodev)
1010{
1011#if IS_ENABLED(CONFIG_ACPI)
1012	struct acpi_device *adev;
1013
1014	adev = ACPI_COMPANION(&sdiodev->func1->dev);
1015	if (adev)
1016		sdiodev->func1_power_manageable = adev->flags.power_manageable;
1017
1018	adev = ACPI_COMPANION(&sdiodev->func2->dev);
1019	if (adev)
1020		sdiodev->func2_power_manageable = adev->flags.power_manageable;
1021#endif
1022}
1023
1024static void brcmf_sdiod_acpi_set_power_manageable(struct brcmf_sdio_dev *sdiodev,
1025						  int enable)
1026{
1027#if IS_ENABLED(CONFIG_ACPI)
1028	struct acpi_device *adev;
1029
1030	adev = ACPI_COMPANION(&sdiodev->func1->dev);
1031	if (adev)
1032		adev->flags.power_manageable = enable ? sdiodev->func1_power_manageable : 0;
1033
1034	adev = ACPI_COMPANION(&sdiodev->func2->dev);
1035	if (adev)
1036		adev->flags.power_manageable = enable ? sdiodev->func2_power_manageable : 0;
1037#endif
1038}
1039
1040static int brcmf_ops_sdio_probe(struct sdio_func *func,
1041				const struct sdio_device_id *id)
1042{
1043	int err;
1044	struct brcmf_sdio_dev *sdiodev;
1045	struct brcmf_bus *bus_if;
1046
1047	if (!id) {
1048		dev_err(&func->dev, "Error no sdio_device_id passed for %x:%x\n", func->vendor, func->device);
1049		return -ENODEV;
1050	}
1051
1052	brcmf_dbg(SDIO, "Enter\n");
1053	brcmf_dbg(SDIO, "Class=%x\n", func->class);
1054	brcmf_dbg(SDIO, "sdio vendor ID: 0x%04x\n", func->vendor);
1055	brcmf_dbg(SDIO, "sdio device ID: 0x%04x\n", func->device);
1056	brcmf_dbg(SDIO, "Function#: %d\n", func->num);
1057
1058	/* Set MMC_QUIRK_LENIENT_FN0 for this card */
1059	func->card->quirks |= MMC_QUIRK_LENIENT_FN0;
1060
1061	/* Consume func num 1 but dont do anything with it. */
1062	if (func->num == 1)
1063		return 0;
1064
1065	/* Ignore anything but func 2 */
1066	if (func->num != 2)
1067		return -ENODEV;
1068
1069	bus_if = kzalloc(sizeof(*bus_if), GFP_KERNEL);
1070	if (!bus_if)
1071		return -ENOMEM;
1072	sdiodev = kzalloc(sizeof(*sdiodev), GFP_KERNEL);
1073	if (!sdiodev) {
1074		kfree(bus_if);
1075		return -ENOMEM;
1076	}
1077
1078	/* store refs to functions used. mmc_card does
1079	 * not hold the F0 function pointer.
1080	 */
1081	sdiodev->func1 = func->card->sdio_func[0];
1082	sdiodev->func2 = func;
1083
1084	sdiodev->bus_if = bus_if;
1085	bus_if->bus_priv.sdio = sdiodev;
1086	bus_if->proto_type = BRCMF_PROTO_BCDC;
1087	bus_if->fwvid = id->driver_data;
1088	dev_set_drvdata(&func->dev, bus_if);
1089	dev_set_drvdata(&sdiodev->func1->dev, bus_if);
1090	sdiodev->dev = &sdiodev->func1->dev;
1091
1092	brcmf_sdiod_acpi_save_power_manageable(sdiodev);
1093	brcmf_sdiod_change_state(sdiodev, BRCMF_SDIOD_DOWN);
1094
1095	brcmf_dbg(SDIO, "F2 found, calling brcmf_sdiod_probe...\n");
1096	err = brcmf_sdiod_probe(sdiodev);
1097	if (err) {
1098		brcmf_err("F2 error, probe failed %d...\n", err);
1099		goto fail;
1100	}
1101
1102	brcmf_dbg(SDIO, "F2 init completed...\n");
1103	return 0;
1104
1105fail:
1106	dev_set_drvdata(&func->dev, NULL);
1107	dev_set_drvdata(&sdiodev->func1->dev, NULL);
1108	kfree(sdiodev);
1109	kfree(bus_if);
1110	return err;
1111}
1112
1113static void brcmf_ops_sdio_remove(struct sdio_func *func)
1114{
1115	struct brcmf_bus *bus_if;
1116	struct brcmf_sdio_dev *sdiodev;
1117
1118	brcmf_dbg(SDIO, "Enter\n");
1119	brcmf_dbg(SDIO, "sdio vendor ID: 0x%04x\n", func->vendor);
1120	brcmf_dbg(SDIO, "sdio device ID: 0x%04x\n", func->device);
1121	brcmf_dbg(SDIO, "Function: %d\n", func->num);
1122
1123	bus_if = dev_get_drvdata(&func->dev);
1124	if (bus_if) {
1125		sdiodev = bus_if->bus_priv.sdio;
1126
1127		/* start by unregistering irqs */
1128		brcmf_sdiod_intr_unregister(sdiodev);
1129
1130		if (func->num != 1)
1131			return;
1132
1133		/* only proceed with rest of cleanup if func 1 */
1134		brcmf_sdiod_remove(sdiodev);
1135
1136		dev_set_drvdata(&sdiodev->func1->dev, NULL);
1137		dev_set_drvdata(&sdiodev->func2->dev, NULL);
1138
1139		kfree(bus_if);
1140		kfree(sdiodev);
1141	}
1142
1143	brcmf_dbg(SDIO, "Exit\n");
1144}
1145
1146void brcmf_sdio_wowl_config(struct device *dev, bool enabled)
1147{
1148	struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1149	struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
1150	mmc_pm_flag_t pm_caps = sdio_get_host_pm_caps(sdiodev->func1);
1151
1152	/* Power must be preserved to be able to support WOWL. */
1153	if (!(pm_caps & MMC_PM_KEEP_POWER))
1154		goto notsup;
1155
1156	if (sdiodev->settings->bus.sdio.oob_irq_supported ||
1157	    pm_caps & MMC_PM_WAKE_SDIO_IRQ) {
1158		/* Stop ACPI from turning off the device when wowl is enabled */
1159		brcmf_sdiod_acpi_set_power_manageable(sdiodev, !enabled);
1160		sdiodev->wowl_enabled = enabled;
1161		brcmf_dbg(SDIO, "Configuring WOWL, enabled=%d\n", enabled);
1162		return;
1163	}
1164
1165notsup:
1166	brcmf_dbg(SDIO, "WOWL not supported\n");
1167}
1168
1169static int brcmf_ops_sdio_suspend(struct device *dev)
1170{
1171	struct sdio_func *func;
1172	struct brcmf_bus *bus_if;
1173	struct brcmf_sdio_dev *sdiodev;
1174	mmc_pm_flag_t sdio_flags;
1175	bool cap_power_off;
1176	int ret = 0;
1177
1178	func = container_of(dev, struct sdio_func, dev);
1179	brcmf_dbg(SDIO, "Enter: F%d\n", func->num);
1180	if (func->num != 1)
1181		return 0;
1182
1183	cap_power_off = !!(func->card->host->caps & MMC_CAP_POWER_OFF_CARD);
1184
1185	bus_if = dev_get_drvdata(dev);
1186	sdiodev = bus_if->bus_priv.sdio;
1187
1188	if (sdiodev->wowl_enabled || !cap_power_off) {
1189		brcmf_sdiod_freezer_on(sdiodev);
1190		brcmf_sdio_wd_timer(sdiodev->bus, 0);
1191
1192		sdio_flags = MMC_PM_KEEP_POWER;
1193
1194		if (sdiodev->wowl_enabled) {
1195			if (sdiodev->settings->bus.sdio.oob_irq_supported)
1196				enable_irq_wake(sdiodev->settings->bus.sdio.oob_irq_nr);
1197			else
1198				sdio_flags |= MMC_PM_WAKE_SDIO_IRQ;
1199		}
1200
1201		if (sdio_set_host_pm_flags(sdiodev->func1, sdio_flags))
1202			brcmf_err("Failed to set pm_flags %x\n", sdio_flags);
1203
1204	} else {
1205		/* power will be cut so remove device, probe again in resume */
1206		brcmf_sdiod_intr_unregister(sdiodev);
1207		ret = brcmf_sdiod_remove(sdiodev);
1208		if (ret)
1209			brcmf_err("Failed to remove device on suspend\n");
1210	}
1211
1212	return ret;
1213}
1214
1215static int brcmf_ops_sdio_resume(struct device *dev)
1216{
1217	struct brcmf_bus *bus_if = dev_get_drvdata(dev);
1218	struct brcmf_sdio_dev *sdiodev = bus_if->bus_priv.sdio;
1219	struct sdio_func *func = container_of(dev, struct sdio_func, dev);
1220	int ret = 0;
1221	bool cap_power_off = !!(func->card->host->caps & MMC_CAP_POWER_OFF_CARD);
1222
1223	brcmf_dbg(SDIO, "Enter: F%d\n", func->num);
1224	if (func->num != 2)
1225		return 0;
1226
1227	if (!sdiodev->wowl_enabled && cap_power_off) {
1228		/* bus was powered off and device removed, probe again */
1229		ret = brcmf_sdiod_probe(sdiodev);
1230		if (ret)
1231			brcmf_err("Failed to probe device on resume\n");
1232	} else {
1233		if (sdiodev->wowl_enabled && sdiodev->settings->bus.sdio.oob_irq_supported)
1234			disable_irq_wake(sdiodev->settings->bus.sdio.oob_irq_nr);
1235
1236		brcmf_sdiod_freezer_off(sdiodev);
1237	}
1238
1239	return ret;
1240}
1241
1242static DEFINE_SIMPLE_DEV_PM_OPS(brcmf_sdio_pm_ops,
1243				brcmf_ops_sdio_suspend,
1244				brcmf_ops_sdio_resume);
1245
1246static struct sdio_driver brcmf_sdmmc_driver = {
1247	.probe = brcmf_ops_sdio_probe,
1248	.remove = brcmf_ops_sdio_remove,
1249	.name = KBUILD_MODNAME,
1250	.id_table = brcmf_sdmmc_ids,
1251	.drv = {
1252		.pm = pm_sleep_ptr(&brcmf_sdio_pm_ops),
1253		.coredump = brcmf_dev_coredump,
1254	},
1255};
1256
1257int brcmf_sdio_register(void)
1258{
1259	return sdio_register_driver(&brcmf_sdmmc_driver);
1260}
1261
1262void brcmf_sdio_exit(void)
1263{
1264	brcmf_dbg(SDIO, "Enter\n");
1265
1266	sdio_unregister_driver(&brcmf_sdmmc_driver);
1267}
1268