[mirror_ubuntu-artful-kernel.git] / drivers / net / wireless / brcm80211 / brcmfmac / bcmsdh.c

/*
 * Copyright (c) 2010 Broadcom Corporation
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
/* ****************** SDIO CARD Interface Functions **************************/

#include <linux/types.h>
#include <linux/netdevice.h>
#include <linux/pci.h>
#include <linux/pci_ids.h>
#include <linux/sched.h>
#include <linux/completion.h>
#include <linux/mmc/sdio.h>
#include <linux/mmc/sdio_func.h>
#include <linux/mmc/card.h>

#include <defs.h>
#include <brcm_hw_ids.h>
#include <brcmu_utils.h>
#include <brcmu_wifi.h>
#include <soc.h>
#include "dhd.h"
#include "dhd_bus.h"
#include "dhd_dbg.h"
#include "sdio_host.h"

#define SDIOH_API_ACCESS_RETRY_LIMIT	2

static void brcmf_sdioh_irqhandler(struct sdio_func *func)
{
	struct brcmf_sdio_dev *sdiodev = dev_get_drvdata(&func->card->dev);

	brcmf_dbg(TRACE, "***IRQHandler\n");

	sdio_release_host(func);

	brcmf_sdbrcm_isr(sdiodev->bus);

	sdio_claim_host(func);
}

int brcmf_sdcard_intr_reg(struct brcmf_sdio_dev *sdiodev)
{
	brcmf_dbg(TRACE, "Entering\n");

	sdio_claim_host(sdiodev->func[1]);
	sdio_claim_irq(sdiodev->func[1], brcmf_sdioh_irqhandler);
	sdio_release_host(sdiodev->func[1]);

	return 0;
}

int brcmf_sdcard_intr_dereg(struct brcmf_sdio_dev *sdiodev)
{
	brcmf_dbg(TRACE, "Entering\n");

	sdio_claim_host(sdiodev->func[1]);
	sdio_release_irq(sdiodev->func[1]);
	sdio_release_host(sdiodev->func[1]);

	return 0;
}

u8 brcmf_sdcard_cfg_read(struct brcmf_sdio_dev *sdiodev, uint fnc_num, u32 addr,
			 int *err)
{
	int status;
	s32 retry = 0;
	u8 data = 0;

	do {
		if (retry)	/* wait for 1 ms till bus get settled down */
			udelay(1000);
		status = brcmf_sdioh_request_byte(sdiodev, SDIOH_READ, fnc_num,
						  addr, (u8 *) &data);
	} while (status != 0
		 && (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
	if (err)
		*err = status;

	brcmf_dbg(INFO, "fun = %d, addr = 0x%x, u8data = 0x%x\n",
		  fnc_num, addr, data);

	return data;
}

void
brcmf_sdcard_cfg_write(struct brcmf_sdio_dev *sdiodev, uint fnc_num, u32 addr,
		       u8 data, int *err)
{
	int status;
	s32 retry = 0;

	do {
		if (retry)	/* wait for 1 ms till bus get settled down */
			udelay(1000);
		status = brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE, fnc_num,
						  addr, (u8 *) &data);
	} while (status != 0
		 && (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
	if (err)
		*err = status;

	brcmf_dbg(INFO, "fun = %d, addr = 0x%x, u8data = 0x%x\n",
		  fnc_num, addr, data);
}

int
brcmf_sdcard_set_sbaddr_window(struct brcmf_sdio_dev *sdiodev, u32 address)
{
	int err = 0;
	brcmf_sdcard_cfg_write(sdiodev, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRLOW,
			 (address >> 8) & SBSDIO_SBADDRLOW_MASK, &err);
	if (!err)
		brcmf_sdcard_cfg_write(sdiodev, SDIO_FUNC_1,
				       SBSDIO_FUNC1_SBADDRMID,
				       (address >> 16) & SBSDIO_SBADDRMID_MASK,
				       &err);
	if (!err)
		brcmf_sdcard_cfg_write(sdiodev, SDIO_FUNC_1,
				       SBSDIO_FUNC1_SBADDRHIGH,
				       (address >> 24) & SBSDIO_SBADDRHIGH_MASK,
				       &err);

	return err;
}

u32 brcmf_sdcard_reg_read(struct brcmf_sdio_dev *sdiodev, u32 addr, uint size)
{
	int status;
	u32 word = 0;
	uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;

	brcmf_dbg(INFO, "fun = 1, addr = 0x%x\n", addr);

	if (bar0 != sdiodev->sbwad) {
		if (brcmf_sdcard_set_sbaddr_window(sdiodev, bar0))
			return 0xFFFFFFFF;

		sdiodev->sbwad = bar0;
	}

	addr &= SBSDIO_SB_OFT_ADDR_MASK;
	if (size == 4)
		addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;

	status = brcmf_sdioh_request_word(sdiodev, SDIOH_READ, SDIO_FUNC_1,
					  addr, &word, size);

	sdiodev->regfail = (status != 0);

	brcmf_dbg(INFO, "u32data = 0x%x\n", word);

	/* if ok, return appropriately masked word */
	if (status == 0) {
		switch (size) {
		case sizeof(u8):
			return word & 0xff;
		case sizeof(u16):
			return word & 0xffff;
		case sizeof(u32):
			return word;
		default:
			sdiodev->regfail = true;

		}
	}

	/* otherwise, bad sdio access or invalid size */
	brcmf_dbg(ERROR, "error reading addr 0x%04x size %d\n", addr, size);
	return 0xFFFFFFFF;
}

u32 brcmf_sdcard_reg_write(struct brcmf_sdio_dev *sdiodev, u32 addr, uint size,
			   u32 data)
{
	int status;
	uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
	int err = 0;

	brcmf_dbg(INFO, "fun = 1, addr = 0x%x, uint%ddata = 0x%x\n",
		  addr, size * 8, data);

	if (bar0 != sdiodev->sbwad) {
		err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0);
		if (err)
			return err;

		sdiodev->sbwad = bar0;
	}

	addr &= SBSDIO_SB_OFT_ADDR_MASK;
	if (size == 4)
		addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
	status =
	    brcmf_sdioh_request_word(sdiodev, SDIOH_WRITE, SDIO_FUNC_1,
				     addr, &data, size);
	sdiodev->regfail = (status != 0);

	if (status == 0)
		return 0;

	brcmf_dbg(ERROR, "error writing 0x%08x to addr 0x%04x size %d\n",
		  data, addr, size);
	return 0xFFFFFFFF;
}

bool brcmf_sdcard_regfail(struct brcmf_sdio_dev *sdiodev)
{
	return sdiodev->regfail;
}

int
brcmf_sdcard_recv_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
		      uint flags,
		      u8 *buf, uint nbytes, struct sk_buff *pkt)
{
	int status;
	uint incr_fix;
	uint width;
	uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
	int err = 0;

	brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n", fn, addr, nbytes);

	/* Async not implemented yet */
	if (flags & SDIO_REQ_ASYNC)
		return -ENOTSUPP;

	if (bar0 != sdiodev->sbwad) {
		err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0);
		if (err)
			return err;

		sdiodev->sbwad = bar0;
	}

	addr &= SBSDIO_SB_OFT_ADDR_MASK;

	incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
	width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
	if (width == 4)
		addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;

	status = brcmf_sdioh_request_buffer(sdiodev, incr_fix, SDIOH_READ,
					    fn, addr, width, nbytes, buf, pkt);

	return status;
}

int
brcmf_sdcard_send_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
		      uint flags, u8 *buf, uint nbytes, struct sk_buff *pkt)
{
	uint incr_fix;
	uint width;
	uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
	int err = 0;

	brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n", fn, addr, nbytes);

	/* Async not implemented yet */
	if (flags & SDIO_REQ_ASYNC)
		return -ENOTSUPP;

	if (bar0 != sdiodev->sbwad) {
		err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0);
		if (err)
			return err;

		sdiodev->sbwad = bar0;
	}

	addr &= SBSDIO_SB_OFT_ADDR_MASK;

	incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
	width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
	if (width == 4)
		addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;

	return brcmf_sdioh_request_buffer(sdiodev, incr_fix, SDIOH_WRITE, fn,
					  addr, width, nbytes, buf, pkt);
}

int brcmf_sdcard_rwdata(struct brcmf_sdio_dev *sdiodev, uint rw, u32 addr,
			u8 *buf, uint nbytes)
{
	addr &= SBSDIO_SB_OFT_ADDR_MASK;
	addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;

	return brcmf_sdioh_request_buffer(sdiodev, SDIOH_DATA_INC,
		(rw ? SDIOH_WRITE : SDIOH_READ), SDIO_FUNC_1,
		addr, 4, nbytes, buf, NULL);
}

int brcmf_sdcard_abort(struct brcmf_sdio_dev *sdiodev, uint fn)
{
	char t_func = (char)fn;
	brcmf_dbg(TRACE, "Enter\n");

	/* issue abort cmd52 command through F0 */
	brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE, SDIO_FUNC_0,
				 SDIO_CCCR_ABORT, &t_func);

	brcmf_dbg(TRACE, "Exit\n");
	return 0;
}

int brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev)
{
	u32 regs = 0;
	int ret = 0;

	ret = brcmf_sdioh_attach(sdiodev);
	if (ret)
		goto out;

	regs = SI_ENUM_BASE;

	/* Report the BAR, to fix if needed */
	sdiodev->sbwad = SI_ENUM_BASE;

	/* try to attach to the target device */
	sdiodev->bus = brcmf_sdbrcm_probe(0, 0, 0, 0, regs, sdiodev);
	if (!sdiodev->bus) {
		brcmf_dbg(ERROR, "device attach failed\n");
		ret = -ENODEV;
		goto out;
	}

out:
	if (ret)
		brcmf_sdio_remove(sdiodev);

	return ret;
}
EXPORT_SYMBOL(brcmf_sdio_probe);

int brcmf_sdio_remove(struct brcmf_sdio_dev *sdiodev)
{
	if (sdiodev->bus) {
		brcmf_sdbrcm_disconnect(sdiodev->bus);
		sdiodev->bus = NULL;
	}

	brcmf_sdioh_detach(sdiodev);

	sdiodev->sbwad = 0;

	return 0;
}
EXPORT_SYMBOL(brcmf_sdio_remove);

void brcmf_sdio_wdtmr_enable(struct brcmf_sdio_dev *sdiodev, bool enable)
{
	if (enable)
		brcmf_sdbrcm_wd_timer(sdiodev->bus, BRCMF_WD_POLL_MS);
	else
		brcmf_sdbrcm_wd_timer(sdiodev->bus, 0);
}
Commit	Line	Data
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>
	24	#include <linux/mmc/sdio.h>
	25	#include <linux/mmc/sdio_func.h>
	26	#include <linux/mmc/card.h>
	27
	28	#include <defs.h>
	29	#include <brcm_hw_ids.h>
	30	#include <brcmu_utils.h>
	31	#include <brcmu_wifi.h>
	32	#include <soc.h>
	33	#include "dhd.h"
	34	#include "dhd_bus.h"
	35	#include "dhd_dbg.h"
	36	#include "sdio_host.h"
	37
	38	#define SDIOH_API_ACCESS_RETRY_LIMIT 2
	39
	40	static void brcmf_sdioh_irqhandler(struct sdio_func *func)
	41	{
	42	struct brcmf_sdio_dev *sdiodev = dev_get_drvdata(&func->card->dev);
	43
	44	brcmf_dbg(TRACE, "***IRQHandler\n");
	45
	46	sdio_release_host(func);
	47
	48	brcmf_sdbrcm_isr(sdiodev->bus);
	49
	50	sdio_claim_host(func);
	51	}
	52
	53	int brcmf_sdcard_intr_reg(struct brcmf_sdio_dev *sdiodev)
	54	{
	55	brcmf_dbg(TRACE, "Entering\n");
	56
	57	sdio_claim_host(sdiodev->func[1]);
	58	sdio_claim_irq(sdiodev->func[1], brcmf_sdioh_irqhandler);
	59	sdio_release_host(sdiodev->func[1]);
	60
	61	return 0;
	62	}
	63
	64	int brcmf_sdcard_intr_dereg(struct brcmf_sdio_dev *sdiodev)
65	{
66	brcmf_dbg(TRACE, "Entering\n");
67
68	sdio_claim_host(sdiodev->func[1]);
69	sdio_release_irq(sdiodev->func[1]);
70	sdio_release_host(sdiodev->func[1]);
71
72	return 0;
73	}
74
75	u8 brcmf_sdcard_cfg_read(struct brcmf_sdio_dev *sdiodev, uint fnc_num, u32 addr,
76	int *err)
77	{
78	int status;
79	s32 retry = 0;
80	u8 data = 0;
81
82	do {
83	if (retry) /* wait for 1 ms till bus get settled down */
84	udelay(1000);
85	status = brcmf_sdioh_request_byte(sdiodev, SDIOH_READ, fnc_num,
86	addr, (u8 *) &data);
87	} while (status != 0
88	&& (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
89	if (err)
90	*err = status;
91
92	brcmf_dbg(INFO, "fun = %d, addr = 0x%x, u8data = 0x%x\n",
93	fnc_num, addr, data);
94
95	return data;
96	}
97
98	void
99	brcmf_sdcard_cfg_write(struct brcmf_sdio_dev *sdiodev, uint fnc_num, u32 addr,
100	u8 data, int *err)
101	{
102	int status;
103	s32 retry = 0;
104
105	do {
106	if (retry) /* wait for 1 ms till bus get settled down */
107	udelay(1000);
108	status = brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE, fnc_num,
109	addr, (u8 *) &data);
110	} while (status != 0
111	&& (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
112	if (err)
113	*err = status;
114
115	brcmf_dbg(INFO, "fun = %d, addr = 0x%x, u8data = 0x%x\n",
116	fnc_num, addr, data);
117	}
118
119	int
120	brcmf_sdcard_set_sbaddr_window(struct brcmf_sdio_dev *sdiodev, u32 address)
121	{
122	int err = 0;
123	brcmf_sdcard_cfg_write(sdiodev, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRLOW,
124	(address >> 8) & SBSDIO_SBADDRLOW_MASK, &err);
125	if (!err)
126	brcmf_sdcard_cfg_write(sdiodev, SDIO_FUNC_1,
127	SBSDIO_FUNC1_SBADDRMID,
128	(address >> 16) & SBSDIO_SBADDRMID_MASK,
129	&err);
130	if (!err)
131	brcmf_sdcard_cfg_write(sdiodev, SDIO_FUNC_1,
132	SBSDIO_FUNC1_SBADDRHIGH,
133	(address >> 24) & SBSDIO_SBADDRHIGH_MASK,
134	&err);
135
136	return err;
137	}
138
139	u32 brcmf_sdcard_reg_read(struct brcmf_sdio_dev *sdiodev, u32 addr, uint size)
140	{
141	int status;
142	u32 word = 0;
143	uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
144
145	brcmf_dbg(INFO, "fun = 1, addr = 0x%x\n", addr);
146
147	if (bar0 != sdiodev->sbwad) {
148	if (brcmf_sdcard_set_sbaddr_window(sdiodev, bar0))
149	return 0xFFFFFFFF;
150
151	sdiodev->sbwad = bar0;
152	}
153
154	addr &= SBSDIO_SB_OFT_ADDR_MASK;
155	if (size == 4)
156	addr \|= SBSDIO_SB_ACCESS_2_4B_FLAG;
157
158	status = brcmf_sdioh_request_word(sdiodev, SDIOH_READ, SDIO_FUNC_1,
159	addr, &word, size);
160
161	sdiodev->regfail = (status != 0);
162
163	brcmf_dbg(INFO, "u32data = 0x%x\n", word);
164
165	/* if ok, return appropriately masked word */
166	if (status == 0) {
167	switch (size) {
168	case sizeof(u8):
169	return word & 0xff;
170	case sizeof(u16):
171	return word & 0xffff;
172	case sizeof(u32):
173	return word;
174	default:
175	sdiodev->regfail = true;
176
177	}
178	}
179
180	/* otherwise, bad sdio access or invalid size */
181	brcmf_dbg(ERROR, "error reading addr 0x%04x size %d\n", addr, size);
182	return 0xFFFFFFFF;
183	}
184
185	u32 brcmf_sdcard_reg_write(struct brcmf_sdio_dev *sdiodev, u32 addr, uint size,
186	u32 data)
187	{
188	int status;
189	uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
190	int err = 0;
191
192	brcmf_dbg(INFO, "fun = 1, addr = 0x%x, uint%ddata = 0x%x\n",
193	addr, size * 8, data);
194
195	if (bar0 != sdiodev->sbwad) {
196	err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0);
197	if (err)
198	return err;
199
200	sdiodev->sbwad = bar0;
201	}
202
203	addr &= SBSDIO_SB_OFT_ADDR_MASK;
204	if (size == 4)
205	addr \|= SBSDIO_SB_ACCESS_2_4B_FLAG;
206	status =
207	brcmf_sdioh_request_word(sdiodev, SDIOH_WRITE, SDIO_FUNC_1,
208	addr, &data, size);
209	sdiodev->regfail = (status != 0);
210
211	if (status == 0)
212	return 0;
213
214	brcmf_dbg(ERROR, "error writing 0x%08x to addr 0x%04x size %d\n",
215	data, addr, size);
216	return 0xFFFFFFFF;
217	}
218
219	bool brcmf_sdcard_regfail(struct brcmf_sdio_dev *sdiodev)
220	{
221	return sdiodev->regfail;
222	}
223
224	int
225	brcmf_sdcard_recv_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
226	uint flags,
227	u8 buf, uint nbytes, struct sk_buff pkt)
228	{
229	int status;
230	uint incr_fix;
231	uint width;
232	uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
233	int err = 0;
234
235	brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n", fn, addr, nbytes);
236
237	/* Async not implemented yet */
238	if (flags & SDIO_REQ_ASYNC)
239	return -ENOTSUPP;
240
241	if (bar0 != sdiodev->sbwad) {
242	err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0);
243	if (err)
244	return err;
245
246	sdiodev->sbwad = bar0;
247	}
248
249	addr &= SBSDIO_SB_OFT_ADDR_MASK;
250
251	incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
252	width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
253	if (width == 4)
254	addr \|= SBSDIO_SB_ACCESS_2_4B_FLAG;
255
256	status = brcmf_sdioh_request_buffer(sdiodev, incr_fix, SDIOH_READ,
257	fn, addr, width, nbytes, buf, pkt);
258
259	return status;
260	}
261
262	int
263	brcmf_sdcard_send_buf(struct brcmf_sdio_dev *sdiodev, u32 addr, uint fn,
264	uint flags, u8 buf, uint nbytes, struct sk_buff pkt)
265	{
266	uint incr_fix;
267	uint width;
268	uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
269	int err = 0;
270
271	brcmf_dbg(INFO, "fun = %d, addr = 0x%x, size = %d\n", fn, addr, nbytes);
272
273	/* Async not implemented yet */
274	if (flags & SDIO_REQ_ASYNC)
275	return -ENOTSUPP;
276
277	if (bar0 != sdiodev->sbwad) {
278	err = brcmf_sdcard_set_sbaddr_window(sdiodev, bar0);
279	if (err)
280	return err;
281
282	sdiodev->sbwad = bar0;
283	}
284
285	addr &= SBSDIO_SB_OFT_ADDR_MASK;
286
287	incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
288	width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
289	if (width == 4)
290	addr \|= SBSDIO_SB_ACCESS_2_4B_FLAG;
291
292	return brcmf_sdioh_request_buffer(sdiodev, incr_fix, SDIOH_WRITE, fn,
293	addr, width, nbytes, buf, pkt);
294	}
295
296	int brcmf_sdcard_rwdata(struct brcmf_sdio_dev *sdiodev, uint rw, u32 addr,
297	u8 *buf, uint nbytes)
298	{
299	addr &= SBSDIO_SB_OFT_ADDR_MASK;
300	addr \|= SBSDIO_SB_ACCESS_2_4B_FLAG;
301
302	return brcmf_sdioh_request_buffer(sdiodev, SDIOH_DATA_INC,
303	(rw ? SDIOH_WRITE : SDIOH_READ), SDIO_FUNC_1,
304	addr, 4, nbytes, buf, NULL);
305	}
306
307	int brcmf_sdcard_abort(struct brcmf_sdio_dev *sdiodev, uint fn)
308	{
309	char t_func = (char)fn;
310	brcmf_dbg(TRACE, "Enter\n");
311
312	/* issue abort cmd52 command through F0 */
313	brcmf_sdioh_request_byte(sdiodev, SDIOH_WRITE, SDIO_FUNC_0,
314	SDIO_CCCR_ABORT, &t_func);
315
316	brcmf_dbg(TRACE, "Exit\n");
317	return 0;
318	}
319
320	int brcmf_sdio_probe(struct brcmf_sdio_dev *sdiodev)
321	{
322	u32 regs = 0;
323	int ret = 0;
324
325	ret = brcmf_sdioh_attach(sdiodev);
326	if (ret)
327	goto out;
328
329	regs = SI_ENUM_BASE;
330
331	/* Report the BAR, to fix if needed */
332	sdiodev->sbwad = SI_ENUM_BASE;
333
334	/* try to attach to the target device */
335	sdiodev->bus = brcmf_sdbrcm_probe(0, 0, 0, 0, regs, sdiodev);
336	if (!sdiodev->bus) {
337	brcmf_dbg(ERROR, "device attach failed\n");
338	ret = -ENODEV;
339	goto out;
340	}
341
342	out:
343	if (ret)
344	brcmf_sdio_remove(sdiodev);
345
346	return ret;
347	}
348	EXPORT_SYMBOL(brcmf_sdio_probe);
349
350	int brcmf_sdio_remove(struct brcmf_sdio_dev *sdiodev)
351	{
352	if (sdiodev->bus) {
353	brcmf_sdbrcm_disconnect(sdiodev->bus);
354	sdiodev->bus = NULL;
355	}
356
357	brcmf_sdioh_detach(sdiodev);
358
359	sdiodev->sbwad = 0;
360
361	return 0;
362	}
363	EXPORT_SYMBOL(brcmf_sdio_remove);
364
365	void brcmf_sdio_wdtmr_enable(struct brcmf_sdio_dev *sdiodev, bool enable)
366	{
367	if (enable)
368	brcmf_sdbrcm_wd_timer(sdiodev->bus, BRCMF_WD_POLL_MS);
369	else
370	brcmf_sdbrcm_wd_timer(sdiodev->bus, 0);
371	}