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