[deliverable/linux.git] / drivers / staging / 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.
 */
/* ****************** BCMSDH Interface Functions *************************** */

#include <linux/types.h>
#include <linux/netdevice.h>
#include <linux/pci_ids.h>
#include <linux/sched.h>
#include <defs.h>
#include <brcm_hw_ids.h>
#include <brcmu_utils.h>
#include <brcmu_wifi.h>
#include <soc.h>

#include <bcmsdbus.h>		/* common SDIO/controller interface */
#include <sbsdio.h>		/* BRCM sdio device core */

#include "dngl_stats.h"
#include "dhd.h"

#define SDIOH_API_ACCESS_RETRY_LIMIT	2
const uint bcmsdh_msglevel = BCMSDH_ERROR_VAL;

struct bcmsdh_info {
	bool init_success;	/* underlying driver successfully attached */
	void *sdioh;		/* handler for sdioh */
	u32 vendevid;	/* Target Vendor and Device ID on SD bus */
	bool regfail;		/* Save status of last
				 reg_read/reg_write call */
	u32 sbwad;		/* Save backplane window address */
};
/* local copy of bcm sd handler */
bcmsdh_info_t *l_bcmsdh;

#if defined(OOB_INTR_ONLY) && defined(HW_OOB)
extern int sdioh_enable_hw_oob_intr(void *sdioh, bool enable);

void bcmsdh_enable_hw_oob_intr(bcmsdh_info_t *sdh, bool enable)
{
	sdioh_enable_hw_oob_intr(sdh->sdioh, enable);
}
#endif

bcmsdh_info_t *bcmsdh_attach(void *cfghdl, void **regsva, uint irq)
{
	bcmsdh_info_t *bcmsdh;

	bcmsdh = kzalloc(sizeof(bcmsdh_info_t), GFP_ATOMIC);
	if (bcmsdh == NULL) {
		BCMSDH_ERROR(("bcmsdh_attach: out of memory"));
		return NULL;
	}

	/* save the handler locally */
	l_bcmsdh = bcmsdh;

	bcmsdh->sdioh = sdioh_attach(cfghdl, irq);
	if (!bcmsdh->sdioh) {
		bcmsdh_detach(bcmsdh);
		return NULL;
	}

	bcmsdh->init_success = true;

	*regsva = (u32 *) SI_ENUM_BASE;

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

int bcmsdh_detach(void *sdh)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	if (bcmsdh != NULL) {
		if (bcmsdh->sdioh) {
			sdioh_detach(bcmsdh->sdioh);
			bcmsdh->sdioh = NULL;
		}
		kfree(bcmsdh);
	}

	l_bcmsdh = NULL;
	return 0;
}

int
bcmsdh_iovar_op(void *sdh, const char *name,
		void *params, int plen, void *arg, int len, bool set)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	return sdioh_iovar_op(bcmsdh->sdioh, name, params, plen, arg, len, set);
}

bool bcmsdh_intr_query(void *sdh)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	SDIOH_API_RC status;
	bool on;

	ASSERT(bcmsdh);
	status = sdioh_interrupt_query(bcmsdh->sdioh, &on);
	if (SDIOH_API_SUCCESS(status))
		return false;
	else
		return on;
}

int bcmsdh_intr_enable(void *sdh)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	SDIOH_API_RC status;
	ASSERT(bcmsdh);

	status = sdioh_interrupt_set(bcmsdh->sdioh, true);
	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
}

int bcmsdh_intr_disable(void *sdh)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	SDIOH_API_RC status;
	ASSERT(bcmsdh);

	status = sdioh_interrupt_set(bcmsdh->sdioh, false);
	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
}

int bcmsdh_intr_reg(void *sdh, bcmsdh_cb_fn_t fn, void *argh)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	SDIOH_API_RC status;
	ASSERT(bcmsdh);

	status = sdioh_interrupt_register(bcmsdh->sdioh, fn, argh);
	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
}

int bcmsdh_intr_dereg(void *sdh)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	SDIOH_API_RC status;
	ASSERT(bcmsdh);

	status = sdioh_interrupt_deregister(bcmsdh->sdioh);
	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
}

#if defined(DHD_DEBUG)
bool bcmsdh_intr_pending(void *sdh)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	ASSERT(sdh);
	return sdioh_interrupt_pending(bcmsdh->sdioh);
}
#endif

int bcmsdh_devremove_reg(void *sdh, bcmsdh_cb_fn_t fn, void *argh)
{
	ASSERT(sdh);

	/* don't support yet */
	return -ENOTSUPP;
}

u8 bcmsdh_cfg_read(void *sdh, uint fnc_num, u32 addr, int *err)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	SDIOH_API_RC status;
#ifdef SDIOH_API_ACCESS_RETRY_LIMIT
	s32 retry = 0;
#endif
	u8 data = 0;

	if (!bcmsdh)
		bcmsdh = l_bcmsdh;

	ASSERT(bcmsdh->init_success);

#ifdef SDIOH_API_ACCESS_RETRY_LIMIT
	do {
		if (retry)	/* wait for 1 ms till bus get settled down */
			udelay(1000);
#endif
		status =
		    sdioh_cfg_read(bcmsdh->sdioh, fnc_num, addr,
				   (u8 *) &data);
#ifdef SDIOH_API_ACCESS_RETRY_LIMIT
	} while (!SDIOH_API_SUCCESS(status)
		 && (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
#endif
	if (err)
		*err = (SDIOH_API_SUCCESS(status) ? 0 : -EIO);

	BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, u8data = 0x%x\n",
		     __func__, fnc_num, addr, data));

	return data;
}

void
bcmsdh_cfg_write(void *sdh, uint fnc_num, u32 addr, u8 data, int *err)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	SDIOH_API_RC status;
#ifdef SDIOH_API_ACCESS_RETRY_LIMIT
	s32 retry = 0;
#endif

	if (!bcmsdh)
		bcmsdh = l_bcmsdh;

	ASSERT(bcmsdh->init_success);

#ifdef SDIOH_API_ACCESS_RETRY_LIMIT
	do {
		if (retry)	/* wait for 1 ms till bus get settled down */
			udelay(1000);
#endif
		status =
		    sdioh_cfg_write(bcmsdh->sdioh, fnc_num, addr,
				    (u8 *) &data);
#ifdef SDIOH_API_ACCESS_RETRY_LIMIT
	} while (!SDIOH_API_SUCCESS(status)
		 && (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
#endif
	if (err)
		*err = SDIOH_API_SUCCESS(status) ? 0 : -EIO;

	BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, u8data = 0x%x\n",
		     __func__, fnc_num, addr, data));
}

u32 bcmsdh_cfg_read_word(void *sdh, uint fnc_num, u32 addr, int *err)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	SDIOH_API_RC status;
	u32 data = 0;

	if (!bcmsdh)
		bcmsdh = l_bcmsdh;

	ASSERT(bcmsdh->init_success);

	status =
	    sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL, SDIOH_READ,
			       fnc_num, addr, &data, 4);

	if (err)
		*err = (SDIOH_API_SUCCESS(status) ? 0 : -EIO);

	BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, u32data = 0x%x\n",
		     __func__, fnc_num, addr, data));

	return data;
}

void
bcmsdh_cfg_write_word(void *sdh, uint fnc_num, u32 addr, u32 data,
		      int *err)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	SDIOH_API_RC status;

	if (!bcmsdh)
		bcmsdh = l_bcmsdh;

	ASSERT(bcmsdh->init_success);

	status =
	    sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,
			       SDIOH_WRITE, fnc_num, addr, &data, 4);

	if (err)
		*err = (SDIOH_API_SUCCESS(status) ? 0 : -EIO);

	BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, u32data = 0x%x\n",
		     __func__, fnc_num, addr, data));
}

int bcmsdh_cis_read(void *sdh, uint func, u8 * cis, uint length)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	SDIOH_API_RC status;

	u8 *tmp_buf, *tmp_ptr;
	u8 *ptr;
	bool ascii = func & ~0xf;
	func &= 0x7;

	if (!bcmsdh)
		bcmsdh = l_bcmsdh;

	ASSERT(bcmsdh->init_success);
	ASSERT(cis);
	ASSERT(length <= SBSDIO_CIS_SIZE_LIMIT);

	status = sdioh_cis_read(bcmsdh->sdioh, func, cis, length);

	if (ascii) {
		/* Move binary bits to tmp and format them
			 into the provided buffer. */
		tmp_buf = kmalloc(length, GFP_ATOMIC);
		if (tmp_buf == NULL) {
			BCMSDH_ERROR(("%s: out of memory\n", __func__));
			return -ENOMEM;
		}
		memcpy(tmp_buf, cis, length);
		for (tmp_ptr = tmp_buf, ptr = cis; ptr < (cis + length - 4);
		     tmp_ptr++) {
			ptr += sprintf((char *)ptr, "%.2x ", *tmp_ptr & 0xff);
			if ((((tmp_ptr - tmp_buf) + 1) & 0xf) == 0)
				ptr += sprintf((char *)ptr, "\n");
		}
		kfree(tmp_buf);
	}

	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
}

static int bcmsdhsdio_set_sbaddr_window(void *sdh, u32 address)
{
	int err = 0;
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	bcmsdh_cfg_write(bcmsdh, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRLOW,
			 (address >> 8) & SBSDIO_SBADDRLOW_MASK, &err);
	if (!err)
		bcmsdh_cfg_write(bcmsdh, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRMID,
				 (address >> 16) & SBSDIO_SBADDRMID_MASK, &err);
	if (!err)
		bcmsdh_cfg_write(bcmsdh, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRHIGH,
				 (address >> 24) & SBSDIO_SBADDRHIGH_MASK,
				 &err);

	return err;
}

u32 bcmsdh_reg_read(void *sdh, u32 addr, uint size)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	SDIOH_API_RC status;
	u32 word = 0;
	uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;

	BCMSDH_INFO(("%s:fun = 1, addr = 0x%x, ", __func__, addr));

	if (!bcmsdh)
		bcmsdh = l_bcmsdh;

	ASSERT(bcmsdh->init_success);

	if (bar0 != bcmsdh->sbwad) {
		if (bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0))
			return 0xFFFFFFFF;

		bcmsdh->sbwad = bar0;
	}

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

	status = sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,
				    SDIOH_READ, SDIO_FUNC_1, addr, &word, size);

	bcmsdh->regfail = !(SDIOH_API_SUCCESS(status));

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

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

		}
	}

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

u32 bcmsdh_reg_write(void *sdh, u32 addr, uint size, u32 data)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	SDIOH_API_RC status;
	uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
	int err = 0;

	BCMSDH_INFO(("%s:fun = 1, addr = 0x%x, uint%ddata = 0x%x\n",
		     __func__, addr, size * 8, data));

	if (!bcmsdh)
		bcmsdh = l_bcmsdh;

	ASSERT(bcmsdh->init_success);

	if (bar0 != bcmsdh->sbwad) {
		err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0);
		if (err)
			return err;

		bcmsdh->sbwad = bar0;
	}

	addr &= SBSDIO_SB_OFT_ADDR_MASK;
	if (size == 4)
		addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
	status =
	    sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,
			       SDIOH_WRITE, SDIO_FUNC_1, addr, &data, size);
	bcmsdh->regfail = !(SDIOH_API_SUCCESS(status));

	if (SDIOH_API_SUCCESS(status))
		return 0;

	BCMSDH_ERROR(("%s: error writing 0x%08x to addr 0x%04x size %d\n",
		      __func__, data, addr, size));
	return 0xFFFFFFFF;
}

bool bcmsdh_regfail(void *sdh)
{
	return ((bcmsdh_info_t *) sdh)->regfail;
}

int
bcmsdh_recv_buf(void *sdh, u32 addr, uint fn, uint flags,
		u8 *buf, uint nbytes, struct sk_buff *pkt,
		bcmsdh_cmplt_fn_t complete, void *handle)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	SDIOH_API_RC status;
	uint incr_fix;
	uint width;
	uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
	int err = 0;

	ASSERT(bcmsdh);
	ASSERT(bcmsdh->init_success);

	BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, size = %d\n",
		     __func__, fn, addr, nbytes));

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

	if (bar0 != bcmsdh->sbwad) {
		err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0);
		if (err)
			return err;

		bcmsdh->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 = sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO, incr_fix,
				      SDIOH_READ, fn, addr, width, nbytes, buf,
				      pkt);

	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
}

int
bcmsdh_send_buf(void *sdh, u32 addr, uint fn, uint flags,
		u8 *buf, uint nbytes, void *pkt,
		bcmsdh_cmplt_fn_t complete, void *handle)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	SDIOH_API_RC status;
	uint incr_fix;
	uint width;
	uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
	int err = 0;

	ASSERT(bcmsdh);
	ASSERT(bcmsdh->init_success);

	BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, size = %d\n",
		     __func__, fn, addr, nbytes));

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

	if (bar0 != bcmsdh->sbwad) {
		err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0);
		if (err)
			return err;

		bcmsdh->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 = sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO, incr_fix,
				      SDIOH_WRITE, fn, addr, width, nbytes, buf,
				      pkt);

	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
}

int bcmsdh_rwdata(void *sdh, uint rw, u32 addr, u8 *buf, uint nbytes)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	SDIOH_API_RC status;

	ASSERT(bcmsdh);
	ASSERT(bcmsdh->init_success);
	ASSERT((addr & SBSDIO_SBWINDOW_MASK) == 0);

	addr &= SBSDIO_SB_OFT_ADDR_MASK;
	addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;

	status =
	    sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO, SDIOH_DATA_INC,
				 (rw ? SDIOH_WRITE : SDIOH_READ), SDIO_FUNC_1,
				 addr, 4, nbytes, buf, NULL);

	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
}

int bcmsdh_abort(void *sdh, uint fn)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	return sdioh_abort(bcmsdh->sdioh, fn);
}

int bcmsdh_start(void *sdh, int stage)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	return sdioh_start(bcmsdh->sdioh, stage);
}

int bcmsdh_stop(void *sdh)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	return sdioh_stop(bcmsdh->sdioh);
}

int bcmsdh_query_device(void *sdh)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
	bcmsdh->vendevid = (PCI_VENDOR_ID_BROADCOM << 16) | 0;
	return bcmsdh->vendevid;
}

uint bcmsdh_query_iofnum(void *sdh)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	if (!bcmsdh)
		bcmsdh = l_bcmsdh;

	return sdioh_query_iofnum(bcmsdh->sdioh);
}

int bcmsdh_reset(bcmsdh_info_t *sdh)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	return sdioh_sdio_reset(bcmsdh->sdioh);
}

void *bcmsdh_get_sdioh(bcmsdh_info_t *sdh)
{
	ASSERT(sdh);
	return sdh->sdioh;
}

/* Function to pass device-status bits to DHD. */
u32 bcmsdh_get_dstatus(void *sdh)
{
	return 0;
}

u32 bcmsdh_cur_sbwad(void *sdh)
{
	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	if (!bcmsdh)
		bcmsdh = l_bcmsdh;

	return bcmsdh->sbwad;
}

void bcmsdh_chipinfo(void *sdh, u32 chip, u32 chiprev)
{
	return;
}
Commit	Line	Data
cf2b4488 HP	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	/* **************** BCMSDH Interface Functions ************************* */
	17
a1c16ed2	18	#include <linux/types.h>
c6ac24e9	19	#include <linux/netdevice.h>
be1c09f9	20	#include <linux/pci_ids.h>
7c6100ee	21	#include <linux/sched.h>
cc3cea5a RV	22	#include <defs.h>
cc3cea5a RV	23	#include <brcm_hw_ids.h>
f97e956a RV	24	#include <brcmu_utils.h>
f97e956a RV	25	#include <brcmu_wifi.h>
cc3cea5a	26	#include <soc.h>
cf2b4488	27
cf2b4488 HP	28	#include <bcmsdbus.h> /* common SDIO/controller interface */
	29	#include <sbsdio.h> /* BRCM sdio device core */
	30
13f401cb RV	31	#include "dngl_stats.h"
13f401cb RV	32	#include "dhd.h"
cf2b4488 HP	33
	34	#define SDIOH_API_ACCESS_RETRY_LIMIT 2
	35	const uint bcmsdh_msglevel = BCMSDH_ERROR_VAL;
	36
	37	struct bcmsdh_info {
	38	bool init_success; /* underlying driver successfully attached */
	39	void sdioh; / handler for sdioh */
66cbd3ab	40	u32 vendevid; /* Target Vendor and Device ID on SD bus */
cf2b4488 HP	41	bool regfail; /* Save status of last
cf2b4488 HP	42	reg_read/reg_write call */
66cbd3ab	43	u32 sbwad; /* Save backplane window address */
cf2b4488 HP	44	};
cf2b4488 HP	45	/* local copy of bcm sd handler */
6998d337	46	bcmsdh_info_t *l_bcmsdh;
cf2b4488 HP	47
	48	#if defined(OOB_INTR_ONLY) && defined(HW_OOB)
	49	extern int sdioh_enable_hw_oob_intr(void *sdioh, bool enable);
	50
	51	void bcmsdh_enable_hw_oob_intr(bcmsdh_info_t *sdh, bool enable)
	52	{
	53	sdioh_enable_hw_oob_intr(sdh->sdioh, enable);
	54	}
	55	#endif
	56
3c9d4c37	57	bcmsdh_info_t bcmsdh_attach(void cfghdl, void **regsva, uint irq)
cf2b4488 HP	58	{
	59	bcmsdh_info_t *bcmsdh;
	60
5fcc1fcb	61	bcmsdh = kzalloc(sizeof(bcmsdh_info_t), GFP_ATOMIC);
c74c95cd	62	if (bcmsdh == NULL) {
97e17d0e	63	BCMSDH_ERROR(("bcmsdh_attach: out of memory"));
cf2b4488 HP	64	return NULL;
cf2b4488 HP	65	}
cf2b4488 HP	66
	67	/* save the handler locally */
	68	l_bcmsdh = bcmsdh;
	69
3c9d4c37	70	bcmsdh->sdioh = sdioh_attach(cfghdl, irq);
c74c95cd	71	if (!bcmsdh->sdioh) {
8da4a3a0	72	bcmsdh_detach(bcmsdh);
cf2b4488 HP	73	return NULL;
	74	}
	75
0f0881b0	76	bcmsdh->init_success = true;
cf2b4488	77
66cbd3ab	78	regsva = (u32 ) SI_ENUM_BASE;
cf2b4488 HP	79
	80	/* Report the BAR, to fix if needed */
	81	bcmsdh->sbwad = SI_ENUM_BASE;
	82	return bcmsdh;
	83	}
	84
8da4a3a0	85	int bcmsdh_detach(void *sdh)
cf2b4488 HP	86	{
	87	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	88
	89	if (bcmsdh != NULL) {
	90	if (bcmsdh->sdioh) {
8da4a3a0	91	sdioh_detach(bcmsdh->sdioh);
cf2b4488 HP	92	bcmsdh->sdioh = NULL;
cf2b4488 HP	93	}
182acb3c	94	kfree(bcmsdh);
cf2b4488 HP	95	}
	96
	97	l_bcmsdh = NULL;
	98	return 0;
	99	}
	100
	101	int
	102	bcmsdh_iovar_op(void sdh, const char name,
	103	void params, int plen, void arg, int len, bool set)
	104	{
	105	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	106	return sdioh_iovar_op(bcmsdh->sdioh, name, params, plen, arg, len, set);
	107	}
	108
	109	bool bcmsdh_intr_query(void *sdh)
	110	{
	111	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	112	SDIOH_API_RC status;
	113	bool on;
	114
	115	ASSERT(bcmsdh);
	116	status = sdioh_interrupt_query(bcmsdh->sdioh, &on);
	117	if (SDIOH_API_SUCCESS(status))
0965ae88	118	return false;
cf2b4488 HP	119	else
	120	return on;
	121	}
	122
	123	int bcmsdh_intr_enable(void *sdh)
	124	{
	125	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	126	SDIOH_API_RC status;
	127	ASSERT(bcmsdh);
	128
0f0881b0	129	status = sdioh_interrupt_set(bcmsdh->sdioh, true);
1bc93cec	130	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
cf2b4488 HP	131	}
	132
	133	int bcmsdh_intr_disable(void *sdh)
	134	{
	135	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	136	SDIOH_API_RC status;
	137	ASSERT(bcmsdh);
	138
0965ae88	139	status = sdioh_interrupt_set(bcmsdh->sdioh, false);
1bc93cec	140	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
cf2b4488 HP	141	}
	142
	143	int bcmsdh_intr_reg(void sdh, bcmsdh_cb_fn_t fn, void argh)
	144	{
	145	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	146	SDIOH_API_RC status;
	147	ASSERT(bcmsdh);
	148
	149	status = sdioh_interrupt_register(bcmsdh->sdioh, fn, argh);
1bc93cec	150	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
cf2b4488 HP	151	}
	152
	153	int bcmsdh_intr_dereg(void *sdh)
	154	{
	155	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	156	SDIOH_API_RC status;
	157	ASSERT(bcmsdh);
	158
	159	status = sdioh_interrupt_deregister(bcmsdh->sdioh);
1bc93cec	160	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
cf2b4488 HP	161	}
	162
	163	#if defined(DHD_DEBUG)
	164	bool bcmsdh_intr_pending(void *sdh)
	165	{
	166	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	167
	168	ASSERT(sdh);
	169	return sdioh_interrupt_pending(bcmsdh->sdioh);
	170	}
	171	#endif
	172
	173	int bcmsdh_devremove_reg(void sdh, bcmsdh_cb_fn_t fn, void argh)
	174	{
	175	ASSERT(sdh);
	176
	177	/* don't support yet */
e10d82d4	178	return -ENOTSUPP;
cf2b4488 HP	179	}
cf2b4488 HP	180
66cbd3ab	181	u8 bcmsdh_cfg_read(void sdh, uint fnc_num, u32 addr, int err)
cf2b4488 HP	182	{
	183	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	184	SDIOH_API_RC status;
	185	#ifdef SDIOH_API_ACCESS_RETRY_LIMIT
3e26416e	186	s32 retry = 0;
cf2b4488	187	#endif
3fd79f7c	188	u8 data = 0;
cf2b4488 HP	189
	190	if (!bcmsdh)
	191	bcmsdh = l_bcmsdh;
	192
	193	ASSERT(bcmsdh->init_success);
	194
	195	#ifdef SDIOH_API_ACCESS_RETRY_LIMIT
	196	do {
	197	if (retry) /* wait for 1 ms till bus get settled down */
7383141b	198	udelay(1000);
cf2b4488 HP	199	#endif
	200	status =
	201	sdioh_cfg_read(bcmsdh->sdioh, fnc_num, addr,
3fd79f7c	202	(u8 *) &data);
cf2b4488 HP	203	#ifdef SDIOH_API_ACCESS_RETRY_LIMIT
	204	} while (!SDIOH_API_SUCCESS(status)
	205	&& (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
	206	#endif
	207	if (err)
b74ac12e	208	*err = (SDIOH_API_SUCCESS(status) ? 0 : -EIO);
cf2b4488	209
3fd79f7c	210	BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, u8data = 0x%x\n",
cf2b4488 HP	211	__func__, fnc_num, addr, data));
	212
	213	return data;
	214	}
	215
	216	void
66cbd3ab	217	bcmsdh_cfg_write(void sdh, uint fnc_num, u32 addr, u8 data, int err)
cf2b4488 HP	218	{
	219	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	220	SDIOH_API_RC status;
	221	#ifdef SDIOH_API_ACCESS_RETRY_LIMIT
3e26416e	222	s32 retry = 0;
cf2b4488 HP	223	#endif
	224
	225	if (!bcmsdh)
	226	bcmsdh = l_bcmsdh;
	227
	228	ASSERT(bcmsdh->init_success);
	229
	230	#ifdef SDIOH_API_ACCESS_RETRY_LIMIT
	231	do {
	232	if (retry) /* wait for 1 ms till bus get settled down */
7383141b	233	udelay(1000);
cf2b4488 HP	234	#endif
	235	status =
	236	sdioh_cfg_write(bcmsdh->sdioh, fnc_num, addr,
3fd79f7c	237	(u8 *) &data);
cf2b4488 HP	238	#ifdef SDIOH_API_ACCESS_RETRY_LIMIT
	239	} while (!SDIOH_API_SUCCESS(status)
	240	&& (retry++ < SDIOH_API_ACCESS_RETRY_LIMIT));
	241	#endif
	242	if (err)
b74ac12e	243	*err = SDIOH_API_SUCCESS(status) ? 0 : -EIO;
cf2b4488	244
3fd79f7c	245	BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, u8data = 0x%x\n",
cf2b4488 HP	246	__func__, fnc_num, addr, data));
	247	}
	248
66cbd3ab	249	u32 bcmsdh_cfg_read_word(void sdh, uint fnc_num, u32 addr, int err)
cf2b4488 HP	250	{
	251	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	252	SDIOH_API_RC status;
66cbd3ab	253	u32 data = 0;
cf2b4488 HP	254
	255	if (!bcmsdh)
	256	bcmsdh = l_bcmsdh;
	257
	258	ASSERT(bcmsdh->init_success);
	259
	260	status =
	261	sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL, SDIOH_READ,
	262	fnc_num, addr, &data, 4);
	263
	264	if (err)
b74ac12e	265	*err = (SDIOH_API_SUCCESS(status) ? 0 : -EIO);
cf2b4488	266
66cbd3ab	267	BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, u32data = 0x%x\n",
cf2b4488 HP	268	__func__, fnc_num, addr, data));
	269
	270	return data;
	271	}
	272
	273	void
66cbd3ab	274	bcmsdh_cfg_write_word(void *sdh, uint fnc_num, u32 addr, u32 data,
cf2b4488 HP	275	int *err)
	276	{
	277	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	278	SDIOH_API_RC status;
	279
	280	if (!bcmsdh)
	281	bcmsdh = l_bcmsdh;
	282
	283	ASSERT(bcmsdh->init_success);
	284
	285	status =
	286	sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,
	287	SDIOH_WRITE, fnc_num, addr, &data, 4);
	288
	289	if (err)
b74ac12e	290	*err = (SDIOH_API_SUCCESS(status) ? 0 : -EIO);
cf2b4488	291
66cbd3ab	292	BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, u32data = 0x%x\n",
cf2b4488 HP	293	__func__, fnc_num, addr, data));
	294	}
	295
3fd79f7c	296	int bcmsdh_cis_read(void sdh, uint func, u8 cis, uint length)
cf2b4488 HP	297	{
	298	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	299	SDIOH_API_RC status;
	300
3fd79f7c GKH	301	u8 tmp_buf, tmp_ptr;
3fd79f7c GKH	302	u8 *ptr;
cf2b4488 HP	303	bool ascii = func & ~0xf;
	304	func &= 0x7;
	305
	306	if (!bcmsdh)
	307	bcmsdh = l_bcmsdh;
	308
	309	ASSERT(bcmsdh->init_success);
	310	ASSERT(cis);
	311	ASSERT(length <= SBSDIO_CIS_SIZE_LIMIT);
	312
	313	status = sdioh_cis_read(bcmsdh->sdioh, func, cis, length);
	314
	315	if (ascii) {
	316	/* Move binary bits to tmp and format them
	317	into the provided buffer. */
5fcc1fcb	318	tmp_buf = kmalloc(length, GFP_ATOMIC);
c74c95cd	319	if (tmp_buf == NULL) {
cf2b4488	320	BCMSDH_ERROR(("%s: out of memory\n", __func__));
e10d82d4	321	return -ENOMEM;
cf2b4488	322	}
02160695	323	memcpy(tmp_buf, cis, length);
cf2b4488 HP	324	for (tmp_ptr = tmp_buf, ptr = cis; ptr < (cis + length - 4);
	325	tmp_ptr++) {
	326	ptr += sprintf((char )ptr, "%.2x ", tmp_ptr & 0xff);
	327	if ((((tmp_ptr - tmp_buf) + 1) & 0xf) == 0)
	328	ptr += sprintf((char *)ptr, "\n");
	329	}
182acb3c	330	kfree(tmp_buf);
cf2b4488 HP	331	}
cf2b4488 HP	332
1bc93cec	333	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
cf2b4488 HP	334	}
cf2b4488 HP	335
66cbd3ab	336	static int bcmsdhsdio_set_sbaddr_window(void *sdh, u32 address)
cf2b4488 HP	337	{
	338	int err = 0;
	339	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	340	bcmsdh_cfg_write(bcmsdh, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRLOW,
	341	(address >> 8) & SBSDIO_SBADDRLOW_MASK, &err);
	342	if (!err)
	343	bcmsdh_cfg_write(bcmsdh, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRMID,
	344	(address >> 16) & SBSDIO_SBADDRMID_MASK, &err);
	345	if (!err)
	346	bcmsdh_cfg_write(bcmsdh, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRHIGH,
	347	(address >> 24) & SBSDIO_SBADDRHIGH_MASK,
	348	&err);
	349
	350	return err;
	351	}
	352
66cbd3ab	353	u32 bcmsdh_reg_read(void *sdh, u32 addr, uint size)
cf2b4488 HP	354	{
	355	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	356	SDIOH_API_RC status;
66cbd3ab	357	u32 word = 0;
cf2b4488 HP	358	uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
	359
	360	BCMSDH_INFO(("%s:fun = 1, addr = 0x%x, ", __func__, addr));
	361
	362	if (!bcmsdh)
	363	bcmsdh = l_bcmsdh;
	364
	365	ASSERT(bcmsdh->init_success);
	366
	367	if (bar0 != bcmsdh->sbwad) {
	368	if (bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0))
	369	return 0xFFFFFFFF;
	370
	371	bcmsdh->sbwad = bar0;
	372	}
	373
	374	addr &= SBSDIO_SB_OFT_ADDR_MASK;
	375	if (size == 4)
	376	addr \|= SBSDIO_SB_ACCESS_2_4B_FLAG;
	377
	378	status = sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,
	379	SDIOH_READ, SDIO_FUNC_1, addr, &word, size);
	380
	381	bcmsdh->regfail = !(SDIOH_API_SUCCESS(status));
	382
66cbd3ab	383	BCMSDH_INFO(("u32data = 0x%x\n", word));
cf2b4488 HP	384
	385	/* if ok, return appropriately masked word */
	386	if (SDIOH_API_SUCCESS(status)) {
	387	switch (size) {
3fd79f7c	388	case sizeof(u8):
cf2b4488	389	return word & 0xff;
7d4df48e	390	case sizeof(u16):
cf2b4488	391	return word & 0xffff;
66cbd3ab	392	case sizeof(u32):
cf2b4488 HP	393	return word;
cf2b4488 HP	394	default:
0f0881b0	395	bcmsdh->regfail = true;
cf2b4488 HP	396
	397	}
	398	}
	399
	400	/* otherwise, bad sdio access or invalid size */
	401	BCMSDH_ERROR(("%s: error reading addr 0x%04x size %d\n", __func__,
	402	addr, size));
	403	return 0xFFFFFFFF;
	404	}
	405
66cbd3ab	406	u32 bcmsdh_reg_write(void *sdh, u32 addr, uint size, u32 data)
cf2b4488 HP	407	{
	408	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	409	SDIOH_API_RC status;
	410	uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
	411	int err = 0;
	412
	413	BCMSDH_INFO(("%s:fun = 1, addr = 0x%x, uint%ddata = 0x%x\n",
	414	__func__, addr, size * 8, data));
	415
	416	if (!bcmsdh)
	417	bcmsdh = l_bcmsdh;
	418
	419	ASSERT(bcmsdh->init_success);
	420
	421	if (bar0 != bcmsdh->sbwad) {
c74c95cd JC	422	err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0);
c74c95cd JC	423	if (err)
cf2b4488 HP	424	return err;
	425
	426	bcmsdh->sbwad = bar0;
	427	}
	428
	429	addr &= SBSDIO_SB_OFT_ADDR_MASK;
	430	if (size == 4)
	431	addr \|= SBSDIO_SB_ACCESS_2_4B_FLAG;
	432	status =
	433	sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,
	434	SDIOH_WRITE, SDIO_FUNC_1, addr, &data, size);
	435	bcmsdh->regfail = !(SDIOH_API_SUCCESS(status));
	436
	437	if (SDIOH_API_SUCCESS(status))
	438	return 0;
	439
	440	BCMSDH_ERROR(("%s: error writing 0x%08x to addr 0x%04x size %d\n",
	441	__func__, data, addr, size));
	442	return 0xFFFFFFFF;
	443	}
	444
	445	bool bcmsdh_regfail(void *sdh)
	446	{
	447	return ((bcmsdh_info_t *) sdh)->regfail;
	448	}
	449
	450	int
66cbd3ab	451	bcmsdh_recv_buf(void *sdh, u32 addr, uint fn, uint flags,
c26b1378	452	u8 buf, uint nbytes, struct sk_buff pkt,
cf2b4488 HP	453	bcmsdh_cmplt_fn_t complete, void *handle)
	454	{
	455	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	456	SDIOH_API_RC status;
	457	uint incr_fix;
	458	uint width;
	459	uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
	460	int err = 0;
	461
	462	ASSERT(bcmsdh);
	463	ASSERT(bcmsdh->init_success);
	464
	465	BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, size = %d\n",
	466	__func__, fn, addr, nbytes));
	467
	468	/* Async not implemented yet */
	469	ASSERT(!(flags & SDIO_REQ_ASYNC));
	470	if (flags & SDIO_REQ_ASYNC)
e10d82d4	471	return -ENOTSUPP;
cf2b4488 HP	472
cf2b4488 HP	473	if (bar0 != bcmsdh->sbwad) {
c74c95cd JC	474	err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0);
c74c95cd JC	475	if (err)
cf2b4488 HP	476	return err;
	477
	478	bcmsdh->sbwad = bar0;
	479	}
	480
	481	addr &= SBSDIO_SB_OFT_ADDR_MASK;
	482
	483	incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
	484	width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
	485	if (width == 4)
	486	addr \|= SBSDIO_SB_ACCESS_2_4B_FLAG;
	487
	488	status = sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO, incr_fix,
	489	SDIOH_READ, fn, addr, width, nbytes, buf,
	490	pkt);
	491
b74ac12e	492	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
cf2b4488 HP	493	}
	494
	495	int
66cbd3ab	496	bcmsdh_send_buf(void *sdh, u32 addr, uint fn, uint flags,
3fd79f7c	497	u8 buf, uint nbytes, void pkt,
cf2b4488 HP	498	bcmsdh_cmplt_fn_t complete, void *handle)
	499	{
	500	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	501	SDIOH_API_RC status;
	502	uint incr_fix;
	503	uint width;
	504	uint bar0 = addr & ~SBSDIO_SB_OFT_ADDR_MASK;
	505	int err = 0;
	506
	507	ASSERT(bcmsdh);
	508	ASSERT(bcmsdh->init_success);
	509
	510	BCMSDH_INFO(("%s:fun = %d, addr = 0x%x, size = %d\n",
	511	__func__, fn, addr, nbytes));
	512
	513	/* Async not implemented yet */
	514	ASSERT(!(flags & SDIO_REQ_ASYNC));
	515	if (flags & SDIO_REQ_ASYNC)
e10d82d4	516	return -ENOTSUPP;
cf2b4488 HP	517
cf2b4488 HP	518	if (bar0 != bcmsdh->sbwad) {
c74c95cd JC	519	err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0);
c74c95cd JC	520	if (err)
cf2b4488 HP	521	return err;
	522
	523	bcmsdh->sbwad = bar0;
	524	}
	525
	526	addr &= SBSDIO_SB_OFT_ADDR_MASK;
	527
	528	incr_fix = (flags & SDIO_REQ_FIXED) ? SDIOH_DATA_FIX : SDIOH_DATA_INC;
	529	width = (flags & SDIO_REQ_4BYTE) ? 4 : 2;
	530	if (width == 4)
	531	addr \|= SBSDIO_SB_ACCESS_2_4B_FLAG;
	532
	533	status = sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO, incr_fix,
	534	SDIOH_WRITE, fn, addr, width, nbytes, buf,
	535	pkt);
	536
1bc93cec	537	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
cf2b4488 HP	538	}
cf2b4488 HP	539
66cbd3ab	540	int bcmsdh_rwdata(void sdh, uint rw, u32 addr, u8 buf, uint nbytes)
cf2b4488 HP	541	{
	542	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	543	SDIOH_API_RC status;
	544
	545	ASSERT(bcmsdh);
	546	ASSERT(bcmsdh->init_success);
	547	ASSERT((addr & SBSDIO_SBWINDOW_MASK) == 0);
	548
	549	addr &= SBSDIO_SB_OFT_ADDR_MASK;
	550	addr \|= SBSDIO_SB_ACCESS_2_4B_FLAG;
	551
	552	status =
	553	sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO, SDIOH_DATA_INC,
	554	(rw ? SDIOH_WRITE : SDIOH_READ), SDIO_FUNC_1,
	555	addr, 4, nbytes, buf, NULL);
	556
1bc93cec	557	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;
cf2b4488 HP	558	}
	559
	560	int bcmsdh_abort(void *sdh, uint fn)
	561	{
	562	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	563
	564	return sdioh_abort(bcmsdh->sdioh, fn);
	565	}
	566
	567	int bcmsdh_start(void *sdh, int stage)
	568	{
	569	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	570
	571	return sdioh_start(bcmsdh->sdioh, stage);
	572	}
	573
	574	int bcmsdh_stop(void *sdh)
	575	{
	576	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	577
	578	return sdioh_stop(bcmsdh->sdioh);
	579	}
	580
	581	int bcmsdh_query_device(void *sdh)
	582	{
	583	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
be1c09f9	584	bcmsdh->vendevid = (PCI_VENDOR_ID_BROADCOM << 16) \| 0;
cf2b4488 HP	585	return bcmsdh->vendevid;
	586	}
	587
	588	uint bcmsdh_query_iofnum(void *sdh)
	589	{
	590	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	591
	592	if (!bcmsdh)
	593	bcmsdh = l_bcmsdh;
	594
	595	return sdioh_query_iofnum(bcmsdh->sdioh);
	596	}
	597
	598	int bcmsdh_reset(bcmsdh_info_t *sdh)
	599	{
	600	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	601
	602	return sdioh_sdio_reset(bcmsdh->sdioh);
	603	}
	604
	605	void bcmsdh_get_sdioh(bcmsdh_info_t sdh)
	606	{
	607	ASSERT(sdh);
	608	return sdh->sdioh;
	609	}
	610
	611	/* Function to pass device-status bits to DHD. */
66cbd3ab	612	u32 bcmsdh_get_dstatus(void *sdh)
cf2b4488 HP	613	{
	614	return 0;
	615	}
	616
66cbd3ab	617	u32 bcmsdh_cur_sbwad(void *sdh)
cf2b4488 HP	618	{
	619	bcmsdh_info_t bcmsdh = (bcmsdh_info_t ) sdh;
	620
	621	if (!bcmsdh)
	622	bcmsdh = l_bcmsdh;
	623
	624	return bcmsdh->sbwad;
	625	}
	626
66cbd3ab	627	void bcmsdh_chipinfo(void *sdh, u32 chip, u32 chiprev)
cf2b4488 HP	628	{
	629	return;
	630	}