/*
 *  'Standard' SDIO HOST CONTROLLER driver
 *
 * Copyright (C) 2020, Broadcom.
 *
 *      Unless you and Broadcom execute a separate written software license
 * agreement governing use of this software, this software is licensed to you
 * under the terms of the GNU General Public License version 2 (the "GPL"),
 * available at http://www.broadcom.com/licenses/GPLv2.php, with the
 * following added to such license:
 *
 *      As a special exception, the copyright holders of this software give you
 * permission to link this software with independent modules, and to copy and
 * distribute the resulting executable under terms of your choice, provided that
 * you also meet, for each linked independent module, the terms and conditions of
 * the license of that module.  An independent module is a module which is not
 * derived from this software.  The special exception does not apply to any
 * modifications of the software.
 *
 *
 * <<Broadcom-WL-IPTag/Open:>>
 *
 * $Id$
 */

#include <typedefs.h>

#include <bcmdevs.h>
#include <bcmendian.h>
#include <bcmutils.h>
#include <osl.h>
#include <siutils.h>
#include <sdio.h>	/* SDIO Device and Protocol Specs */
#include <sdioh.h>	/* Standard SDIO Host Controller Specification */
#include <bcmsdbus.h>	/* bcmsdh to/from specific controller APIs */
#include <sdiovar.h>	/* ioctl/iovars */
#include <pcicfg.h>
#include <bcmsdstd.h>
/* XXX Quick NDIS hack */
#ifdef NDIS
#define inline  __inline
#define	PCI_CFG_VID		0
#define	PCI_CFG_BAR0	0x10
#endif

#define SD_PAGE_BITS	12
#define SD_PAGE 	(1 << SD_PAGE_BITS)
#define SDSTD_MAX_TUNING_PHASE	5

/*
 * Upper GPIO 16 - 31 are available on J22
 *   J22.pin3 == gpio16, J22.pin5 == gpio17, etc.
 * Lower GPIO 0 - 15 are available on J15 (WL_GPIO)
 */
#define SDH_GPIO16		16
#define SDH_GPIO_ENABLE		0xffff

#include <bcmsdstd.h>
#include <sbsdio.h> /* SDIOH (host controller) core hardware definitions */

/* Globals */
uint sd_msglevel = SDH_ERROR_VAL;

uint sd_hiok = TRUE;			/* Use hi-speed mode if available? */
uint sd_sdmode = SDIOH_MODE_SD4;	/* Use SD4 mode by default */
uint sd_f2_blocksize = 64;		/* Default blocksize */
uint sd_f1_blocksize = BLOCK_SIZE_4318;		/* Default blocksize */

#define sd3_trace(x)

/*	sd3ClkMode: 	0-SDR12 [25MHz]
 *				1-SDR25 [50MHz]+SHS=1
 *				2-SDR50 [100MHz]+SSDR50=1
 *				3-SDR104 [208MHz]+SSDR104=1
 *				4-DDR50 [50MHz]+SDDR50=1
 */
#define SD3CLKMODE_0_SDR12	(0)
#define SD3CLKMODE_1_SDR25	(1)
#define SD3CLKMODE_2_SDR50	(2)
#define SD3CLKMODE_3_SDR104	(3)
#define SD3CLKMODE_4_DDR50	(4)
#define SD3CLKMODE_DISABLED	(-1)
#define SD3CLKMODE_AUTO		(99)

/* values for global_UHSI_Supp : Means host and card caps match. */
#define HOST_SDR_UNSUPP			(0)
#define HOST_SDR_12_25			(1)
#define HOST_SDR_50_104_DDR		(2)

/* depends-on/affects sd3_autoselect_uhsi_max.
 *	see sd3_autoselect_uhsi_max
 */
int sd_uhsimode = SD3CLKMODE_DISABLED;
uint sd_tuning_period = CAP3_RETUNING_TC_OTHER;
uint sd_delay_value = 500000;
/* Enables host to dongle glomming. Also increases the
 * dma buffer size. This will increase the rx throughput
 * as there will be lesser CMD53 transactions
 */
#ifdef BCMSDIOH_TXGLOM
uint sd_txglom;
#ifdef LINUX
module_param(sd_txglom, uint, 0);
#endif
#endif /* BCMSDIOH_TXGLOM */

char dhd_sdiod_uhsi_ds_override[2] = {' '};

#define MAX_DTS_INDEX		(3)
#define DRVSTRN_MAX_CHAR	('D')
#define DRVSTRN_IGNORE_CHAR	(' ')

char DTS_vals[MAX_DTS_INDEX + 1] = {
	0x1, /* Driver Strength Type-A */
	0x0, /* Driver Strength Type-B */
	0x2, /* Driver Strength Type-C */
	0x3, /* Driver Strength Type-D */
	};

/* depends-on/affects sd_uhsimode.
	select MAX speed automatically based on caps of host and card.
	If this is 1, sd_uhsimode will be ignored. If the sd_uhsimode is set
	by the user specifically, this var becomes 0. default value: 0. [XXX:TBD: for future]
	*/
uint32 sd3_autoselect_uhsi_max = 0;

#define MAX_TUNING_ITERS		(40)
/* (150+10)millisecs total time; so dividing it for per-loop */
#define PER_TRY_TUNING_DELAY_MS		(160/MAX_TUNING_ITERS)
#define CLKTUNING_MAX_BRR_RETRIES	(1000)	/* 1 ms: 1000 retries with 1 us delay per loop */

/* table analogous to preset value register.
*	This is bcos current HC doesn't have preset value reg support.
*	All has DrvStr as 'B' [val:0] and CLKGEN as 0.
*/
static unsigned short presetval_sw_table[] = {
	0x0520, /* initialization: 	DrvStr:'B' [0]; CLKGen:0;
			* SDCLKFreqSel: 520 [division: 320*2 = 640: ~400 KHz]
			*/
	0x0008, /* default speed:DrvStr:'B' [0]; CLKGen:0;
			* SDCLKFreqSel: 8 [division: 6*2 = 12: ~25 MHz]
			*/
	0x0004, /* High speed: 	DrvStr:'B' [0]; CLKGen:0;
			* SDCLKFreqSel: 4 [division: 3*2 = 6: ~50 MHz]
			*/
	0x0008, /* SDR12: 		DrvStr:'B' [0]; CLKGen:0;
			* SDCLKFreqSel: 8 [division: 6*2 = 12: ~25 MHz]
			*/
	0x0004, /* SDR25: 		DrvStr:'B' [0]; CLKGen:0;
			* SDCLKFreqSel: 4 [division: 3*2 = 6: ~50 MHz]
			*/
	0x0001, /* SDR50: 		DrvStr:'B' [0]; CLKGen:0;
			* SDCLKFreqSel: 2 [division: 1*2 = 2: ~100 MHz]
			*/
	0x0001, /* SDR104: 		DrvStr:'B' [0]; CLKGen:0;
			SDCLKFreqSel: 1 [no division: ~255/~208 MHz]
			*/
	0x0002  /* DDR50: 		DrvStr:'B' [0]; CLKGen:0;
			SDCLKFreqSel: 4 [division: 3*2 = 6: ~50 MHz]
			*/
};

/* This is to have software overrides to the hardware. Info follows:
	For override [1]: 	Preset registers: not supported
	Voltage switch:  not supported
	Clock Tuning: not supported
*/
bool sd3_sw_override1 = FALSE;
bool sd3_sw_read_magic_bytes = FALSE;

#define SD3_TUNING_REQD(sd, sd_uhsimode) ((sd_uhsimode != SD3CLKMODE_DISABLED) && \
			(sd->version == HOST_CONTR_VER_3) &&	\
			((sd_uhsimode == SD3CLKMODE_3_SDR104) ||	\
			((sd_uhsimode == SD3CLKMODE_2_SDR50) &&	\
			(GFIELD(sd->caps3, CAP3_TUNING_SDR50)))))

/* find next power of 2 */
#define NEXT_POW2(n)  {n--; n |= n>>1; n |= n>>2; n |= n>>4; n++;}

#ifdef BCMSDYIELD
bool sd_yieldcpu = TRUE;		/* Allow CPU yielding for buffer requests */
uint sd_minyield = 0;			/* Minimum xfer size to allow CPU yield */
bool sd_forcerb = FALSE;		/* Force sync readback in intrs_on/off */
#endif

/* XXX: Issues with CMD14 enter/exit sleep
 * XXX: Temp fix for special CMD14 handling
 */
#define F1_SLEEPCSR_ADDR	0x1001F

uint sd_divisor = 2;	/* Default 48MHz/2 = 24MHz
							:might get changed in code for 208
							*/

uint sd_power = 1;		/* Default to SD Slot powered ON */
uint sd_3_power_save = 1;		/* Default to SDIO 3.0 power save */
uint sd_clock = 1;		/* Default to SD Clock turned ON */
uint sd_pci_slot = 0xFFFFffff; /* Used to force selection of a particular PCI slot */
uint8 sd_dma_mode = DMA_MODE_AUTO; /* Default to AUTO & program based on capability */

/* XXX Base timeout counter value on 48MHz (2^20 @ 48MHz => 21845us)
 * Could adjust by adding sd_divisor (to maintain bit count) but really
 * need something more elaborate to do that right.  Still allows xfer
 * of about 1000 bytes at 400KHz, so constant is ok.
 * Timeout control N produces 2^(13+N) counter.
 */
uint sd_toctl = 7;
static bool trap_errs = FALSE;

static const char *dma_mode_description[] = { "PIO", "SDMA", "ADMA1", "32b ADMA2", "64b ADMA2" };

/* Prototypes */
static bool sdstd_start_clock(sdioh_info_t *sd, uint16 divisor);
static uint16 sdstd_start_power(sdioh_info_t *sd, int volts_req);
static bool sdstd_bus_width(sdioh_info_t *sd, int width);
static int sdstd_set_highspeed_mode(sdioh_info_t *sd, bool HSMode);
static int sdstd_set_dma_mode(sdioh_info_t *sd, int8 dma_mode);
static int sdstd_card_enablefuncs(sdioh_info_t *sd);
static void sdstd_cmd_getrsp(sdioh_info_t *sd, uint32 *rsp_buffer, int count);
static int sdstd_cmd_issue(sdioh_info_t *sd, bool use_dma, uint32 cmd, uint32 arg);
static int sdstd_card_regread(sdioh_info_t *sd, int func, uint32 regaddr,
                              int regsize, uint32 *data);
static int sdstd_card_regwrite(sdioh_info_t *sd, int func, uint32 regaddr,
                               int regsize, uint32 data);
static int sdstd_driver_init(sdioh_info_t *sd);
static bool sdstd_reset(sdioh_info_t *sd, bool host_reset, bool client_reset);
static int sdstd_card_buf(sdioh_info_t *sd, int rw, int func, bool fifo,
                          uint32 addr, int nbytes, uint32 *data);
static int sdstd_abort(sdioh_info_t *sd, uint func);
static int sdstd_check_errs(sdioh_info_t *sdioh_info, uint32 cmd, uint32 arg);
static int set_client_block_size(sdioh_info_t *sd, int func, int blocksize);
static void sd_map_dma(sdioh_info_t * sd);
static void sd_unmap_dma(sdioh_info_t * sd);
static void sd_clear_adma_dscr_buf(sdioh_info_t *sd);
static void sd_fill_dma_data_buf(sdioh_info_t *sd, uint8 data);
static void sd_create_adma_descriptor(sdioh_info_t *sd,
                                      uint32 index, uint32 addr_phys,
                                      uint16 length, uint16 flags);
static void sd_dump_adma_dscr(sdioh_info_t *sd);
static void sdstd_dumpregs(sdioh_info_t *sd);

static int sdstd_3_set_highspeed_uhsi_mode(sdioh_info_t *sd, int sd3ClkMode);
static int sdstd_3_sigvoltswitch_proc(sdioh_info_t *sd);
static int sdstd_3_get_matching_uhsi_clkmode(sdioh_info_t *sd,
	int sd3_requested_clkmode);
static bool sdstd_3_get_matching_drvstrn(sdioh_info_t *sd,
	int sd3_requested_clkmode, uint32 *drvstrn, uint16 *presetval);
static int sdstd_3_clock_wrapper(sdioh_info_t *sd);
static int sdstd_clock_wrapper(sdioh_info_t *sd);

#ifdef BCMINTERNAL
#ifdef NOTUSED
static int parse_caps(uint32 caps_reg, char *buf, int len);
static int parse_state(uint32 state_reg, char *buf, int len);
static void cis_fetch(sdioh_info_t *sd, int func, char *data, int len);
#endif /* NOTUSED */
#endif /* BCMINTERNAL */

#ifdef BCMDBG
static void print_regs(sdioh_info_t *sd);
#endif

/*
 * Private register access routines.
 */

/* 16 bit PCI regs */

/* XXX This is a hack to satisfy the -Wmissing-prototypes warning */
extern uint16 sdstd_rreg16(sdioh_info_t *sd, uint reg);
uint16
sdstd_rreg16(sdioh_info_t *sd, uint reg)
{

	volatile uint16 data = *(volatile uint16 *)(sd->mem_space + reg);
	sd_ctrl(("16: R Reg 0x%02x, Data 0x%x\n", reg, data));
	return data;
}

/* XXX This is a hack to satisfy the -Wmissing-prototypes warning */
extern void sdstd_wreg16(sdioh_info_t *sd, uint reg, uint16 data);
void
sdstd_wreg16(sdioh_info_t *sd, uint reg, uint16 data)
{
	*(volatile uint16 *)(sd->mem_space + reg) = (uint16) data;
	sd_ctrl(("16: W Reg 0x%02x, Data 0x%x\n", reg, data));
}

static void
sdstd_or_reg16(sdioh_info_t *sd, uint reg, uint16 val)
{
	volatile uint16 data = *(volatile uint16 *)(sd->mem_space + reg);
	sd_ctrl(("16: OR Reg 0x%02x, Val 0x%x\n", reg, val));
	data |= val;
	*(volatile uint16 *)(sd->mem_space + reg) = (uint16)data;

}
static void
sdstd_mod_reg16(sdioh_info_t *sd, uint reg, int16 mask, uint16 val)
{

	volatile uint16 data = *(volatile uint16 *)(sd->mem_space + reg);
	sd_ctrl(("16: MOD Reg 0x%02x, Mask 0x%x, Val 0x%x\n", reg, mask, val));
	data &= ~mask;
	data |= (val & mask);
	*(volatile uint16 *)(sd->mem_space + reg) = (uint16)data;
}

/* 32 bit PCI regs */
static uint32
sdstd_rreg(sdioh_info_t *sd, uint reg)
{
	volatile uint32 data = *(volatile uint32 *)(sd->mem_space + reg);
	sd_ctrl(("32: R Reg 0x%02x, Data 0x%x\n", reg, data));
	return data;
}
static inline void
sdstd_wreg(sdioh_info_t *sd, uint reg, uint32 data)
{
	*(volatile uint32 *)(sd->mem_space + reg) = (uint32)data;
	sd_ctrl(("32: W Reg 0x%02x, Data 0x%x\n", reg, data));

}
#ifdef BCMINTERNAL
#ifdef NOTUSED
static void
sdstd_or_reg(sdioh_info_t *sd, uint reg, uint32 val)
{
	volatile uint32 data = *(volatile uint32 *)(sd->mem_space + reg);
	data |= val;
	*(volatile uint32 *)(sd->mem_space + reg) = (volatile uint32)data;
}
static void
sdstd_mod_reg(sdioh_info_t *sd, uint reg, uint32 mask, uint32 val)
{
	volatile uint32 data = *(volatile uint32 *)(sd->mem_space + reg);
	data &= ~mask;
	data |= (val & mask);
	*(volatile uint32 *)(sd->mem_space + reg) = (volatile uint32)data;
}
#endif /* NOTUSED */
#endif /* BCMINTERNAL */

/* 8 bit PCI regs */
static inline void
sdstd_wreg8(sdioh_info_t *sd, uint reg, uint8 data)
{
	*(volatile uint8 *)(sd->mem_space + reg) = (uint8)data;
	sd_ctrl(("08: W Reg 0x%02x, Data 0x%x\n", reg, data));
}
static uint8
sdstd_rreg8(sdioh_info_t *sd, uint reg)
{
	volatile uint8 data = *(volatile uint8 *)(sd->mem_space + reg);
	sd_ctrl(("08: R Reg 0x%02x, Data 0x%x\n", reg, data));
	return data;
}

/*
 * Private work routines
 */

sdioh_info_t *glob_sd;

/*
 *  Public entry points & extern's
 */
extern sdioh_info_t *
sdioh_attach(osl_t *osh, void *bar0, uint irq)
{
	sdioh_info_t *sd;

	sd_trace(("%s\n", __FUNCTION__));
	if ((sd = (sdioh_info_t *)MALLOC(osh, sizeof(sdioh_info_t))) == NULL) {
		sd_err(("sdioh_attach: out of memory, malloced %d bytes\n", MALLOCED(osh)));
		return NULL;
	}
	bzero((char *)sd, sizeof(sdioh_info_t));
	glob_sd = sd;
	sd->osh = osh;
	if (sdstd_osinit(sd) != 0) {
		sd_err(("%s:sdstd_osinit() failed\n", __FUNCTION__));
		MFREE(sd->osh, sd, sizeof(sdioh_info_t));
		return NULL;
	}
	sd->mem_space = (volatile char *)sdstd_reg_map(osh, (ulong)bar0, SDIOH_REG_WINSZ);
	sd_init_dma(sd);
	sd->irq = irq;
	if (sd->mem_space == NULL) {
		sd_err(("%s:ioremap() failed\n", __FUNCTION__));
		sdstd_osfree(sd);
		MFREE(sd->osh, sd, sizeof(sdioh_info_t));
		return NULL;
	}
	sd_info(("%s:sd->mem_space = %p\n", __FUNCTION__, sd->mem_space));
	sd->intr_handler = NULL;
	sd->intr_handler_arg = NULL;
	sd->intr_handler_valid = FALSE;

	/* Set defaults */
	sd->sd_blockmode = TRUE;
	sd->use_client_ints = TRUE;
	sd->sd_dma_mode = sd_dma_mode;

	/* XXX Haven't figured out how to make bytemode work with dma */
	if (!sd->sd_blockmode)
		sd->sd_dma_mode = DMA_MODE_NONE;

	if (sdstd_driver_init(sd) != SUCCESS) {
		/* If host CPU was reset without resetting SD bus or
		   SD device, the device will still have its RCA but
		   driver no longer knows what it is (since driver has been restarted).
		   go through once to clear the RCA and a gain reassign it.
		 */
		sd_info(("driver_init failed - Reset RCA and try again\n"));
		if (sdstd_driver_init(sd) != SUCCESS) {
			sd_err(("%s:driver_init() failed()\n", __FUNCTION__));
			if (sd->mem_space) {
				sdstd_reg_unmap(osh, (ulong)sd->mem_space, SDIOH_REG_WINSZ);
				sd->mem_space = NULL;
			}
			sdstd_osfree(sd);
			MFREE(sd->osh, sd, sizeof(sdioh_info_t));
			return (NULL);
		}
	}

	/* XXX Needed for NDIS as its OSL checks for correct dma address width
	 * This value is normally set by wlc_attach() which has yet to run
	 */
	OSL_DMADDRWIDTH(osh, 32);

	/* Always map DMA buffers, so we can switch between DMA modes. */
	sd_map_dma(sd);

	if (sdstd_register_irq(sd, irq) != SUCCESS) {
		sd_err(("%s: sdstd_register_irq() failed for irq = %d\n", __FUNCTION__, irq));
		sdstd_free_irq(sd->irq, sd);
		if (sd->mem_space) {
			sdstd_reg_unmap(osh, (ulong)sd->mem_space, SDIOH_REG_WINSZ);
			sd->mem_space = NULL;
		}

		sdstd_osfree(sd);
		MFREE(sd->osh, sd, sizeof(sdioh_info_t));
		return (NULL);
	}

	sd_trace(("%s: Done\n", __FUNCTION__));
	return sd;
}

extern SDIOH_API_RC
sdioh_detach(osl_t *osh, sdioh_info_t *sd)
{
	sd_trace(("%s\n", __FUNCTION__));
	if (sd) {
		sd_unmap_dma(sd);
		sdstd_wreg16(sd, SD_IntrSignalEnable, 0);
		if (sd->sd3_tuning_reqd == TRUE) {
			sdstd_3_osclean_tuning(sd);
			sd->sd3_tuning_reqd = FALSE;
		}
		sd->sd3_tuning_disable = FALSE;
		sd_trace(("%s: freeing irq %d\n", __FUNCTION__, sd->irq));
		sdstd_free_irq(sd->irq, sd);
		if (sd->card_init_done)
			sdstd_reset(sd, 1, 1);
		if (sd->mem_space) {
			sdstd_reg_unmap(osh, (ulong)sd->mem_space, SDIOH_REG_WINSZ);
			sd->mem_space = NULL;
		}

		sdstd_osfree(sd);
		MFREE(sd->osh, sd, sizeof(sdioh_info_t));
	}
	return SDIOH_API_RC_SUCCESS;
}

/* Configure callback to client when we receive client interrupt */
extern SDIOH_API_RC
sdioh_interrupt_register(sdioh_info_t *sd, sdioh_cb_fn_t fn, void *argh)
{
	sd_trace(("%s: Entering\n", __FUNCTION__));
	sd->intr_handler = fn;
	sd->intr_handler_arg = argh;
	sd->intr_handler_valid = TRUE;
	return SDIOH_API_RC_SUCCESS;
}

extern SDIOH_API_RC
sdioh_interrupt_deregister(sdioh_info_t *sd)
{
	sd_trace(("%s: Entering\n", __FUNCTION__));
	sd->intr_handler_valid = FALSE;
	sd->intr_handler = NULL;
	sd->intr_handler_arg = NULL;
	return SDIOH_API_RC_SUCCESS;
}

extern SDIOH_API_RC
sdioh_interrupt_query(sdioh_info_t *sd, bool *onoff)
{
	sd_trace(("%s: Entering\n", __FUNCTION__));
	*onoff = sd->client_intr_enabled;
	return SDIOH_API_RC_SUCCESS;
}

#if defined(DHD_DEBUG) || defined(BCMDBG)
extern bool
sdioh_interrupt_pending(sdioh_info_t *sd)
{
	uint16 intrstatus;
	intrstatus = sdstd_rreg16(sd, SD_IntrStatus);
	return !!(intrstatus & CLIENT_INTR);
}
#endif

uint
sdioh_query_iofnum(sdioh_info_t *sd)
{
	return sd->num_funcs;
}

/* IOVar table */
enum {
	IOV_MSGLEVEL = 1,
	IOV_BLOCKMODE,
	IOV_BLOCKSIZE,
	IOV_DMA,
	IOV_USEINTS,
	IOV_NUMINTS,
	IOV_NUMLOCALINTS,
	IOV_HOSTREG,
	IOV_DEVREG,
	IOV_DIVISOR,
	IOV_SDMODE,
	IOV_HISPEED,
	IOV_HCIREGS,
	IOV_POWER,
	IOV_POWER_SAVE,
	IOV_YIELDCPU,
	IOV_MINYIELD,
	IOV_FORCERB,
	IOV_CLOCK,
	IOV_UHSIMOD,
	IOV_TUNEMOD,
	IOV_TUNEDIS
};

const bcm_iovar_t sdioh_iovars[] = {
	{"sd_msglevel",	IOV_MSGLEVEL,	0,	0, IOVT_UINT32,	0 },
	{"sd_blockmode", IOV_BLOCKMODE,	0,	0, IOVT_BOOL,	0 },
	{"sd_blocksize", IOV_BLOCKSIZE, 0,	0, IOVT_UINT32,	0 }, /* ((fn << 16) | size) */
	{"sd_dma",	IOV_DMA,	0,	0, IOVT_UINT32,	0 },
#ifdef BCMSDYIELD
	{"sd_yieldcpu",	IOV_YIELDCPU,	0,	0, IOVT_BOOL,	0 },
	{"sd_minyield",	IOV_MINYIELD,	0,	0, IOVT_UINT32,	0 },
	{"sd_forcerb",	IOV_FORCERB,	0,	0, IOVT_BOOL,	0 },
#endif
	{"sd_ints",	IOV_USEINTS,	0,	0, IOVT_BOOL,	0 },
	{"sd_numints",	IOV_NUMINTS,	0,	0, IOVT_UINT32,	0 },
	{"sd_numlocalints", IOV_NUMLOCALINTS, 0, 0, IOVT_UINT32,	0 },
	{"sd_hostreg",	IOV_HOSTREG,	0,	0, IOVT_BUFFER,	sizeof(sdreg_t) },
	{"sd_devreg",	IOV_DEVREG,	0,	0, IOVT_BUFFER,	sizeof(sdreg_t)	},
	{"sd_divisor",	IOV_DIVISOR,	0,	0, IOVT_UINT32,	0 },
	{"sd_power",	IOV_POWER,	0,	0, IOVT_UINT32,	0 },
	{"sd_power_save",	IOV_POWER_SAVE,	0,	0, IOVT_UINT32,	0 },
	{"sd_clock",	IOV_CLOCK,	0,	0, IOVT_UINT32,	0 },
	{"sd_mode",	IOV_SDMODE,	0,	0, IOVT_UINT32,	100},
	{"sd_highspeed",	IOV_HISPEED,	0,	0, IOVT_UINT32,	0},
	{"sd_uhsimode",	IOV_UHSIMOD,	0,	0, IOVT_UINT32,	0},
#ifdef BCMDBG
	{"sd_hciregs",	IOV_HCIREGS,	0,	0, IOVT_BUFFER,	0 },
#endif
	{"tuning_mode", IOV_TUNEMOD,	0,	0, IOVT_UINT32,	0},
	{"sd3_tuning_disable", IOV_TUNEDIS,	0,	0, IOVT_BOOL,	0},

	{NULL, 0, 0, 0, 0, 0 }
};
uint8 sdstd_turn_on_clock(sdioh_info_t *sd)
{
	sdstd_or_reg16(sd, SD_ClockCntrl, 0x4);
	return 0;
}

uint8 sdstd_turn_off_clock(sdioh_info_t *sd)
{
	sdstd_wreg16(sd, SD_ClockCntrl, sdstd_rreg16(sd, SD_ClockCntrl) & ~((uint16)0x4));
	return 0;
}

int
sdioh_iovar_op(sdioh_info_t *si, const char *name,
               void *params, int plen, void *arg, uint len, bool set)
{
	const bcm_iovar_t *vi = NULL;
	int bcmerror = 0;
	uint val_size;
	int32 int_val = 0;
	bool bool_val;
	uint32 actionid;

	ASSERT(name);

	/* Get must have return space; Set does not take qualifiers */
	ASSERT(set || (arg && len));
	ASSERT(!set || (!params && !plen));

	sd_trace(("%s: Enter (%s %s)\n", __FUNCTION__, (set ? "set" : "get"), name));

	if ((vi = bcm_iovar_lookup(sdioh_iovars, name)) == NULL) {
		bcmerror = BCME_UNSUPPORTED;
		goto exit;
	}

	if ((bcmerror = bcm_iovar_lencheck(vi, arg, len, set)) != 0)
		goto exit;

	/* XXX Copied from dhd, copied from wl; certainly overkill here? */
	/* Set up params so get and set can share the convenience variables */
	if (params == NULL) {
		params = arg;
		plen = len;
	}

	if (vi->type == IOVT_VOID)
		val_size = 0;
	else if (vi->type == IOVT_BUFFER)
		val_size = len;
	else
		val_size = sizeof(int);

	if (plen >= (int)sizeof(int_val))
		bcopy(params, &int_val, sizeof(int_val));

	bool_val = (int_val != 0) ? TRUE : FALSE;
	BCM_REFERENCE(bool_val);

	actionid = set ? IOV_SVAL(vi->varid) : IOV_GVAL(vi->varid);
	switch (actionid) {
	case IOV_GVAL(IOV_MSGLEVEL):
		int_val = (int32)sd_msglevel;
		bcopy(&int_val, arg, val_size);
		break;

	case IOV_SVAL(IOV_MSGLEVEL):
		sd_msglevel = int_val;
		break;

	case IOV_GVAL(IOV_BLOCKMODE):
		int_val = (int32)si->sd_blockmode;
		bcopy(&int_val, arg, val_size);
		break;

	case IOV_SVAL(IOV_BLOCKMODE):
		si->sd_blockmode = (bool)int_val;
		/* Haven't figured out how to make non-block mode with DMA */
		if (!si->sd_blockmode)
			si->sd_dma_mode = DMA_MODE_NONE;
		break;

#ifdef BCMSDYIELD
	case IOV_GVAL(IOV_YIELDCPU):
		int_val = sd_yieldcpu;
		bcopy(&int_val, arg, val_size);
		break;

	case IOV_SVAL(IOV_YIELDCPU):
		sd_yieldcpu = (bool)int_val;
		break;

	case IOV_GVAL(IOV_MINYIELD):
		int_val = sd_minyield;
		bcopy(&int_val, arg, val_size);
		break;

	case IOV_SVAL(IOV_MINYIELD):
		sd_minyield = (bool)int_val;
		break;

	case IOV_GVAL(IOV_FORCERB):
		int_val = sd_forcerb;
		bcopy(&int_val, arg, val_size);
		break;

	case IOV_SVAL(IOV_FORCERB):
		sd_forcerb = (bool)int_val;
		break;
#endif /* BCMSDYIELD */

	case IOV_GVAL(IOV_BLOCKSIZE):
		if ((uint32)int_val > si->num_funcs) {
			bcmerror = BCME_BADARG;
			break;
		}
		int_val = (int32)si->client_block_size[int_val];
		bcopy(&int_val, arg, val_size);
		break;

	case IOV_SVAL(IOV_BLOCKSIZE):
	{
		uint func = ((uint32)int_val >> 16);
		uint blksize = (uint16)int_val;
		uint maxsize;

		if (func > si->num_funcs) {
			bcmerror = BCME_BADARG;
			break;
		}

		/* XXX These hardcoded sizes are a hack, remove after proper CIS parsing. */
		switch (func) {
		case 0: maxsize = 32; break;
		case 1: maxsize = BLOCK_SIZE_4318; break;
		case 2: maxsize = BLOCK_SIZE_4328; break;
		default: maxsize = 0;
		}
		if (blksize > maxsize) {
			bcmerror = BCME_BADARG;
			break;
		}
		if (!blksize) {
			blksize = maxsize;
		}

		/* Now set it */
		sdstd_lock(si);
		bcmerror = set_client_block_size(si, func, blksize);
		sdstd_unlock(si);
		break;
	}

	case IOV_GVAL(IOV_DMA):
		int_val = (int32)si->sd_dma_mode;
		bcopy(&int_val, arg, val_size);
		break;

	case IOV_SVAL(IOV_DMA):
		si->sd_dma_mode = (char)int_val;
		sdstd_set_dma_mode(si, si->sd_dma_mode);
		break;

	case IOV_GVAL(IOV_USEINTS):
		int_val = (int32)si->use_client_ints;
		bcopy(&int_val, arg, val_size);
		break;

	case IOV_SVAL(IOV_USEINTS):
		si->use_client_ints = (bool)int_val;
		if (si->use_client_ints)
			si->intmask |= CLIENT_INTR;
		else
			si->intmask &= ~CLIENT_INTR;
		break;

	case IOV_GVAL(IOV_DIVISOR):
		int_val = (uint32)sd_divisor;
		bcopy(&int_val, arg, val_size);
		break;

	case IOV_SVAL(IOV_DIVISOR):
		sd_divisor = int_val;
		if (!sdstd_start_clock(si, (uint16)sd_divisor)) {
			sd_err(("set clock failed!\n"));
			bcmerror = BCME_ERROR;
		}
		break;

	case IOV_GVAL(IOV_POWER):
		int_val = (uint32)sd_power;
		bcopy(&int_val, arg, val_size);
		break;

	case IOV_GVAL(IOV_POWER_SAVE):
		int_val = (uint32)sd_3_power_save;
		bcopy(&int_val, arg, val_size);
		break;

	case IOV_SVAL(IOV_POWER):
		sd_power = int_val;
		if (sd_power == 1) {
			if (sdstd_driver_init(si) != SUCCESS) {
				sd_err(("set SD Slot power failed!\n"));
				bcmerror = BCME_ERROR;
			} else {
				sd_err(("SD Slot Powered ON.\n"));
			}
		} else {
			uint8 pwr = 0;

			pwr = SFIELD(pwr, PWR_BUS_EN, 0);
			sdstd_wreg8(si, SD_PwrCntrl, pwr); /* Set Voltage level */
			sd_err(("SD Slot Powered OFF.\n"));
		}
		break;

	case IOV_SVAL(IOV_POWER_SAVE):
		sd_3_power_save = int_val;
		break;

	case IOV_GVAL(IOV_CLOCK):
		int_val = (uint32)sd_clock;
		bcopy(&int_val, arg, val_size);
		break;

	case IOV_SVAL(IOV_CLOCK):
		sd_clock = int_val;
		if (sd_clock == 1) {
			sd_info(("SD Clock turned ON.\n"));
			if (!sdstd_start_clock(si, (uint16)sd_divisor)) {
				sd_err(("sdstd_start_clock failed\n"));
				bcmerror = BCME_ERROR;
			}
		} else {
			/* turn off HC clock */
			sdstd_wreg16(si, SD_ClockCntrl,
			             sdstd_rreg16(si, SD_ClockCntrl) & ~((uint16)0x4));

			sd_info(("SD Clock turned OFF.\n"));
		}
		break;

	case IOV_GVAL(IOV_SDMODE):
		int_val = (uint32)sd_sdmode;
		bcopy(&int_val, arg, val_size);
		break;

	case IOV_SVAL(IOV_SDMODE):
		sd_sdmode = int_val;

		if (!sdstd_bus_width(si, sd_sdmode)) {
			sd_err(("sdstd_bus_width failed\n"));
			bcmerror = BCME_ERROR;
		}
		break;

	case IOV_GVAL(IOV_HISPEED):
		int_val = (uint32)sd_hiok;
		bcopy(&int_val, arg, val_size);
		break;

	case IOV_SVAL(IOV_HISPEED):
		sd_hiok = int_val;
		bcmerror = sdstd_set_highspeed_mode(si, (bool)sd_hiok);
		break;

	case IOV_GVAL(IOV_UHSIMOD):
		sd3_trace(("%s: Get UHSI: \n", __FUNCTION__));
		int_val = (int)sd_uhsimode;
		bcopy(&int_val, arg, val_size);
		break;

	case IOV_SVAL(IOV_UHSIMOD):
		{
			int oldval = sd_uhsimode; /* save old, working value */
			sd3_trace(("%s: Set UHSI: \n", __FUNCTION__));
			/* check if UHSI is supported by card/host */
			if (!(si->card_UHSI_voltage_Supported && si->host_UHSISupported)) {
				sd_err(("%s:UHSI not suppoted!\n", __FUNCTION__));
				bcmerror = BCME_UNSUPPORTED;
				break;
			}
			/* check for valid values */
			if (!((int_val == SD3CLKMODE_AUTO) ||
				(int_val == SD3CLKMODE_DISABLED) ||
				((int_val >= SD3CLKMODE_0_SDR12) &&
				(int_val <= SD3CLKMODE_4_DDR50)))) {
				sd_err(("%s:CLK: bad arg!\n", __FUNCTION__));
				bcmerror = BCME_BADARG;
				break;
			}

			sd_uhsimode = int_val;
			if (SUCCESS != sdstd_3_clock_wrapper(si)) {
				sd_err(("%s:Error in setting uhsi clkmode:%d,"
					"restoring back to %d\n", __FUNCTION__,
					sd_uhsimode, oldval));
				/* try to set back the old one */
				sd_uhsimode = oldval;
				if (SUCCESS != sdstd_3_clock_wrapper(si)) {
					sd_err(("%s:Error in setting uhsi to old mode;"
						"ignoring:\n", __FUNCTION__));
				}
			}
			break;
		}
#ifdef DHD_DEBUG
	case IOV_SVAL(IOV_TUNEMOD):
	{

		if( int_val == SD_DHD_DISABLE_PERIODIC_TUNING) { /* do tuning single time */
			sd3_trace(("Start tuning from Iovar\n"));
			si->sd3_tuning_reqd = TRUE;
			sdstd_enable_disable_periodic_timer(si, int_val);
			sdstd_lock(si);
			sdstd_3_clk_tuning(si, sdstd_3_get_uhsi_clkmode(si));
			sdstd_unlock(si);
			si->sd3_tuning_reqd = FALSE;
		}
		if (int_val == SD_DHD_ENABLE_PERIODIC_TUNING) {
			sd3_trace(("Enabling  automatic tuning\n"));
			si->sd3_tuning_reqd = TRUE;
		    sdstd_enable_disable_periodic_timer(si, int_val);
		}
		break;
	}
#endif /* debugging purpose */
	case IOV_GVAL(IOV_NUMINTS):
		int_val = (int32)si->intrcount;
		bcopy(&int_val, arg, val_size);
		break;

	case IOV_GVAL(IOV_NUMLOCALINTS):
		int_val = (int32)si->local_intrcount;
		bcopy(&int_val, arg, val_size);
		break;

	case IOV_GVAL(IOV_HOSTREG):
	{
		/* XXX Should copy for alignment reasons */
		sdreg_t *sd_ptr = (sdreg_t *)params;

		if (sd_ptr->offset < SD_SysAddr || sd_ptr->offset > SD3_WL_BT_reset_register) {
			sd_err(("%s: bad offset 0x%x\n", __FUNCTION__, sd_ptr->offset));
			bcmerror = BCME_BADARG;
			break;
		}

		sd_trace(("%s: rreg%d at offset %d\n", __FUNCTION__,
		          (sd_ptr->offset & 1) ? 8 : ((sd_ptr->offset & 2) ? 16 : 32),
		          sd_ptr->offset));
		if (sd_ptr->offset & 1)
			int_val = sdstd_rreg8(si, sd_ptr->offset);
		else if (sd_ptr->offset & 2)
			int_val = sdstd_rreg16(si, sd_ptr->offset);
		else
			int_val = sdstd_rreg(si, sd_ptr->offset);

		bcopy(&int_val, arg, sizeof(int_val));
		break;
	}

	case IOV_SVAL(IOV_HOSTREG):
	{
		/* XXX Should copy for alignment reasons */
		sdreg_t *sd_ptr = (sdreg_t *)params;

		if (sd_ptr->offset < SD_SysAddr || sd_ptr->offset > SD3_WL_BT_reset_register) {
			sd_err(("%s: bad offset 0x%x\n", __FUNCTION__, sd_ptr->offset));
			bcmerror = BCME_BADARG;
			break;
		}

		sd_trace(("%s: wreg%d value 0x%08x at offset %d\n", __FUNCTION__, sd_ptr->value,
		          (sd_ptr->offset & 1) ? 8 : ((sd_ptr->offset & 2) ? 16 : 32),
		          sd_ptr->offset));
		if (sd_ptr->offset & 1)
			sdstd_wreg8(si, sd_ptr->offset, (uint8)sd_ptr->value);
		else if (sd_ptr->offset & 2)
			sdstd_wreg16(si, sd_ptr->offset, (uint16)sd_ptr->value);
		else
			sdstd_wreg(si, sd_ptr->offset, (uint32)sd_ptr->value);

		break;
	}

	case IOV_GVAL(IOV_DEVREG):
	{
		/* XXX Should copy for alignment reasons */
		sdreg_t *sd_ptr = (sdreg_t *)params;
		uint8 data;

		if (sdioh_cfg_read(si, sd_ptr->func, sd_ptr->offset, &data)) {
			bcmerror = BCME_SDIO_ERROR;
			break;
		}

		int_val = (int)data;
		bcopy(&int_val, arg, sizeof(int_val));
		break;
	}

	case IOV_SVAL(IOV_DEVREG):
	{
		/* XXX Should copy for alignment reasons */
		sdreg_t *sd_ptr = (sdreg_t *)params;
		uint8 data = (uint8)sd_ptr->value;

		if (sdioh_cfg_write(si, sd_ptr->func, sd_ptr->offset, &data)) {
			bcmerror = BCME_SDIO_ERROR;
			break;
		}
		break;
	}

#ifdef BCMDBG
	case IOV_GVAL(IOV_HCIREGS):
	{
		struct bcmstrbuf b;
		bcm_binit(&b, arg, len);

		sdstd_lock(si);
		bcm_bprintf(&b, "IntrStatus:       0x%04x ErrorIntrStatus       0x%04x\n",
		            sdstd_rreg16(si, SD_IntrStatus),
		            sdstd_rreg16(si, SD_ErrorIntrStatus));
		bcm_bprintf(&b, "IntrStatusEnable: 0x%04x ErrorIntrStatusEnable 0x%04x\n",
		            sdstd_rreg16(si, SD_IntrStatusEnable),
		            sdstd_rreg16(si, SD_ErrorIntrStatusEnable));
		bcm_bprintf(&b, "IntrSignalEnable: 0x%04x ErrorIntrSignalEnable 0x%04x\n",
		            sdstd_rreg16(si, SD_IntrSignalEnable),
		            sdstd_rreg16(si, SD_ErrorIntrSignalEnable));
		print_regs(si);

		sdstd_unlock(si);

		if (!b.size)
			bcmerror = BCME_BUFTOOSHORT;
		break;
	}
#endif /* BCMDBG */

	case IOV_SVAL(IOV_TUNEDIS):
		si->sd3_tuning_disable = (bool)int_val;
		break;

	default:
		bcmerror = BCME_UNSUPPORTED;
		break;
	}
exit:

	/* XXX Remove protective lock after clients all clean... */
	return bcmerror;
}

extern SDIOH_API_RC
sdioh_cfg_read(sdioh_info_t *sd, uint fnc_num, uint32 addr, uint8 *data)
{
	SDIOH_API_RC status;
	/* No lock needed since sdioh_request_byte does locking */
	status = sdioh_request_byte(sd, SDIOH_READ, fnc_num, addr, data);
	return status;
}

extern SDIOH_API_RC
sdioh_cfg_write(sdioh_info_t *sd, uint fnc_num, uint32 addr, uint8 *data)
{
	/* No lock needed since sdioh_request_byte does locking */
	SDIOH_API_RC status;
	status = sdioh_request_byte(sd, SDIOH_WRITE, fnc_num, addr, data);
	return status;
}

extern SDIOH_API_RC
sdioh_cis_read(sdioh_info_t *sd, uint func, uint8 *cisd, uint32 length)
{
	uint32 count;
	int offset;
	uint32 foo;
	uint8 *cis = cisd;

	sd_trace(("%s: Func = %d\n", __FUNCTION__, func));

	if (!sd->func_cis_ptr[func]) {
		bzero(cis, length);
		return SDIOH_API_RC_FAIL;
	}

	sdstd_lock(sd);
	*cis = 0;
	for (count = 0; count < length; count++) {
		offset =  sd->func_cis_ptr[func] + count;
		if (sdstd_card_regread(sd, 0, offset, 1, &foo)) {
			sd_err(("%s: regread failed: Can't read CIS\n", __FUNCTION__));
			sdstd_unlock(sd);
			return SDIOH_API_RC_FAIL;
		}
		*cis = (uint8)(foo & 0xff);
		cis++;
	}
	sdstd_unlock(sd);
	return SDIOH_API_RC_SUCCESS;
}

extern SDIOH_API_RC
sdioh_request_byte(sdioh_info_t *sd, uint rw, uint func, uint regaddr, uint8 *byte)
{
	int status = SDIOH_API_RC_SUCCESS;
	uint32 cmd_arg;
	uint32 rsp5;

	sdstd_lock(sd);
	if (rw == SDIOH_READ)
	sdstd_3_check_and_do_tuning(sd, CHECK_TUNING_PRE_DATA);

	/* Change to DATA_TRANSFER_ONGOING , protection against tuning tasklet */
	sdstd_3_set_data_state(sd, DATA_TRANSFER_ONGOING);

#ifdef BCMDBG
	if (sdstd_rreg16 (sd, SD_ErrorIntrStatus) != 0) {
		sd_err(("%s: Entering: ErririntrStatus 0x%x, intstat = 0x%x\n",
		        __FUNCTION__, sdstd_rreg16(sd, SD_ErrorIntrStatus),
		        sdstd_rreg16(sd, SD_IntrStatus)));
	}
#endif
	cmd_arg = 0;
	cmd_arg = SFIELD(cmd_arg, CMD52_FUNCTION, func);
	cmd_arg = SFIELD(cmd_arg, CMD52_REG_ADDR, regaddr);
	cmd_arg = SFIELD(cmd_arg, CMD52_RW_FLAG, rw == SDIOH_READ ? 0 : 1);
	cmd_arg = SFIELD(cmd_arg, CMD52_RAW, 0);
	cmd_arg = SFIELD(cmd_arg, CMD52_DATA, rw == SDIOH_READ ? 0 : *byte);

	if ((status = sdstd_cmd_issue(sd, USE_DMA(sd), SDIOH_CMD_52, cmd_arg)) != SUCCESS) {
		/* Change to DATA_TRANSFER_IDLE */
		sdstd_3_set_data_state(sd, DATA_TRANSFER_IDLE);
		sdstd_unlock(sd);
		return status;
	}

	sdstd_cmd_getrsp(sd, &rsp5, 1);
	if (sdstd_rreg16 (sd, SD_ErrorIntrStatus) != 0) {
		sd_err(("%s: 1: ErrorintrStatus 0x%x\n",
		        __FUNCTION__, sdstd_rreg16(sd, SD_ErrorIntrStatus)));
		status = SDIOH_API_RC_FAIL;
	}
	if (GFIELD(rsp5, RSP5_FLAGS) != 0x10) {
		/* PR 101351: sdiod_aos sleep followed by immediate wakeup
		 *    before sdiod_aos takes over has a problem.
		 * While exiting sleep with CMD14, device returning 0x00
		 * Don't flag as error for now for 0x1001f.
		 */
		if (GFIELD(cmd_arg, CMD52_REG_ADDR) != F1_SLEEPCSR_ADDR) {
			sd_err(("%s: rsp5 flags is 0x%x\t %d \n",
				__FUNCTION__, GFIELD(rsp5, RSP5_FLAGS), func));
		}
		status = SDIOH_API_RC_FAIL;
	}

	if (GFIELD(rsp5, RSP5_STUFF)) {
		sd_err(("%s: rsp5 stuff is 0x%x: should be 0\n",
		        __FUNCTION__, GFIELD(rsp5, RSP5_STUFF)));
		status = SDIOH_API_RC_FAIL;
	}

	if (rw == SDIOH_READ)
		*byte = GFIELD(rsp5, RSP5_DATA);

	/* Change to DATA_TRANSFER_IDLE */
	sdstd_3_set_data_state(sd, DATA_TRANSFER_IDLE);

	/* check if we have to do tuning; if so, start */
	sdstd_3_check_and_do_tuning(sd, CHECK_TUNING_POST_DATA);

	sdstd_unlock(sd);
	return status;
}

extern SDIOH_API_RC
sdioh_request_word(sdioh_info_t *sd, uint cmd_type, uint rw, uint func, uint addr,
                   uint32 *word, uint nbytes)
{
	int status;

	sdstd_lock(sd);

	sdstd_3_check_and_do_tuning(sd, CHECK_TUNING_PRE_DATA);

	/* Change to DATA_TRANSFER_ONGOING , protection against tuning tasklet */
	sdstd_3_set_data_state(sd, DATA_TRANSFER_ONGOING);

	if (rw == SDIOH_READ) {
		status = sdstd_card_regread(sd, func, addr, nbytes, word);
	} else {
		status = sdstd_card_regwrite(sd, func, addr, nbytes, *word);
	}

	/* Change to DATA_TRANSFER_IDLE */
	sdstd_3_set_data_state(sd, DATA_TRANSFER_IDLE);

	/* check if we have to do tuning; if so, start */
	sdstd_3_check_and_do_tuning(sd, CHECK_TUNING_POST_DATA);

	sdstd_unlock(sd);
	return (status == SUCCESS ?  SDIOH_API_RC_SUCCESS : SDIOH_API_RC_FAIL);
}

#ifdef BCMSDIOH_TXGLOM
void
sdioh_glom_post(sdioh_info_t *sd, uint8 *frame, void *pkt, uint len)
{
	BCM_REFERENCE(pkt);
	sd->glom_info.dma_buf_arr[sd->glom_info.count] = frame;
	sd->glom_info.nbytes[sd->glom_info.count] = len;
	/* Convert the frame addr to phy addr for DMA in case of host controller version3 */
	if (sd->txglom_mode == SDPCM_TXGLOM_MDESC) {
		sd->glom_info.dma_phys_arr[sd->glom_info.count] = DMA_MAP(sd->osh,
			frame,
			len,
			DMA_TX, 0, 0);
	}
	sd->glom_info.count++;
}

void
sdioh_glom_clear(sdioh_info_t *sd)
{
	int i;
	/* DMA_MAP is done per frame only if host controller version is 3 */
	if (sd->txglom_mode == SDPCM_TXGLOM_MDESC) {
		for (i = 0; i < sd->glom_info.count; i++) {
			DMA_UNMAP(sd->osh,
				sd->glom_info.dma_phys_arr[i],
				sd->glom_info.nbytes[i],
				DMA_TX, 0, 0);
		}
	}
	sd->glom_info.count = 0;
}

uint
sdioh_set_mode(sdioh_info_t *sd, uint mode)
{
	if (mode == SDPCM_TXGLOM_CPY)
		sd->txglom_mode = mode;
	else if ((mode == SDPCM_TXGLOM_MDESC) && (sd->version == HOST_CONTR_VER_3))
		sd->txglom_mode = mode;

	return (sd->txglom_mode);
}

bool
sdioh_glom_enabled(void)
{
	return sd_txglom;
}
#endif /* BCMSDIOH_TXGLOM */

extern SDIOH_API_RC
sdioh_request_buffer(sdioh_info_t *sd, uint pio_dma, uint fix_inc, uint rw, uint func,
                     uint addr, uint reg_width, uint buflen_u, uint8 *buffer, void *pkt)
{
	uint8 is_ddr50 = FALSE;
	int len;
	int buflen = (int)buflen_u;
	bool fifo = (fix_inc == SDIOH_DATA_FIX);
	uint8 *localbuf = NULL, *tmpbuf = NULL;
	bool local_blockmode = sd->sd_blockmode;
	SDIOH_API_RC status = SDIOH_API_RC_SUCCESS;

	sdstd_lock(sd);

	is_ddr50 = (sd_uhsimode == SD3CLKMODE_4_DDR50) ? TRUE : FALSE;

	sdstd_3_check_and_do_tuning(sd, CHECK_TUNING_PRE_DATA);

	/* Change to DATA_TRANSFER_ONGOING , protection against tuning tasklet */
	sdstd_3_set_data_state(sd, DATA_TRANSFER_ONGOING);

	ASSERT(reg_width == 4);
	ASSERT(buflen_u < (1 << 30));
	ASSERT(sd->client_block_size[func]);

#ifdef BCMSDIOH_TXGLOM
	if (sd_txglom) {
		while (pkt) {
			sdioh_glom_post(sd, PKTDATA(sd->osh, pkt), pkt, PKTLEN(sd->osh, pkt));
			pkt = PKTNEXT(sd->osh, pkt);
		}
	}
#endif
	sd_data(("%s: %c len %d r_cnt %d t_cnt %d, pkt @0x%p\n",
	         __FUNCTION__, rw == SDIOH_READ ? 'R' : 'W',
	         buflen_u, sd->r_cnt, sd->t_cnt, pkt));

	/* Break buffer down into blocksize chunks:
	 * Bytemode: 1 block at a time.
	 * Blockmode: Multiples of blocksizes at a time w/ max of SD_PAGE.
	 * Both: leftovers are handled last (will be sent via bytemode).
	 */
	while (buflen > 0) {
		if (local_blockmode) {
			int max_tran_size = SD_PAGE;
#ifdef BCMSDIOH_TXGLOM
			/* There is no alignment requirement for HC3 */
			if ((sd->version == HOST_CONTR_VER_3) && sd_txglom)
				max_tran_size = SD_PAGE * 4;
#endif
			/* Max xfer is Page size */
			len = MIN(max_tran_size, buflen);

			/* Round down to a block boundry */
			if (buflen > sd->client_block_size[func])
				len = (len/sd->client_block_size[func]) *
				        sd->client_block_size[func];
			/* XXX Arasan trashes 3-byte transfers, WAR to add one byte extra. */
			/* XXX In Case of SDIO3.0 DDR50 mode if no of bytes to be
			 * transferred is odd append one more byte to make it even.
			 * Check If odd bytes can come for SDIO_FUNC_2 also.
			 */
			if ((func == SDIO_FUNC_1) && (((len % 4) == 3) || (((len % 2) == 1) &&
			    (is_ddr50))) && ((rw == SDIOH_WRITE) || (rw == SDIOH_READ))) {
				sd_err(("%s: Rounding up buffer to mod4 length.\n", __FUNCTION__));
				len++;
				tmpbuf = buffer;
				if ((localbuf = (uint8 *)MALLOC(sd->osh, len)) == NULL) {
					sd_err(("out of memory, malloced %d bytes\n",
					        MALLOCED(sd->osh)));
					status = SDIOH_API_RC_FAIL;
					goto done;
				}
				bcopy(buffer, localbuf, len);
				buffer = localbuf;
			}
		} else {
			/* Byte mode: One block at a time */
			len = MIN(sd->client_block_size[func], buflen);
		}

		if (sdstd_card_buf(sd, rw, func, fifo, addr, len, (uint32 *)buffer) != SUCCESS) {
			status = SDIOH_API_RC_FAIL;
		}

		/* XXX Restore len and buffer pointer WAR'ed for Arasan 3-byte transfer problem */
		/* XXX WAR for SDIO3.0 DDR50 mode. */
		if (local_blockmode && localbuf) {
			MFREE(sd->osh, localbuf, len);
			len--;
			buffer = tmpbuf;
			sd_err(("%s: Restoring back buffer ptr and len.\n", __FUNCTION__));
		}

		if (status == SDIOH_API_RC_FAIL) {
			goto done;
		}

		buffer += len;
		buflen -= len;
		if (!fifo)
			addr += len;
#ifdef BCMSDIOH_TXGLOM
		/* This loop should not come in case of glommed pkts as it is send in
		 * multiple of blocks or total pkt size less than a block
		 */
		if (sd->glom_info.count != 0)
			buflen = 0;
#endif
	}
done:

	/* Change to DATA_TRANSFER_IDLE */
	sdstd_3_set_data_state(sd, DATA_TRANSFER_IDLE);

	/* check if we have to do tuning; if so, start */
	sdstd_3_check_and_do_tuning(sd, CHECK_TUNING_POST_DATA);

	sdstd_unlock(sd);

#ifdef BCMSDIOH_TXGLOM
	if (sd_txglom)
		sdioh_glom_clear(sd);
#endif

	return status;
}

extern SDIOH_API_RC
sdioh_gpioouten(sdioh_info_t *sd, uint32 gpio)
{
	uint offset = 0;
	uint16 val;

	/* check if upper bank */
	if (gpio >= SDH_GPIO16) {
		gpio -= SDH_GPIO16;
		offset = 2;
	}

	val = sdstd_rreg16(sd, SD_GPIO_OE + offset);
	val |= (1 << gpio);
	sdstd_wreg16(sd, SD_GPIO_OE + offset, val);

	return SDIOH_API_RC_SUCCESS;
}

extern SDIOH_API_RC
sdioh_gpioout(sdioh_info_t *sd, uint32 gpio, bool enab)
{
	uint offset = 0;
	uint16 val;

	/* check if upper bank */
	if (gpio >= SDH_GPIO16) {
		gpio -= SDH_GPIO16;
		offset = 2;
	}

	val = sdstd_rreg16(sd, SD_GPIO_Reg + offset);
	if (enab == TRUE)
		val |= (1 << gpio);
	else
		val &= ~(1 << gpio);
	sdstd_wreg16(sd, SD_GPIO_Reg + offset, val);

	return SDIOH_API_RC_SUCCESS;
}

extern bool
sdioh_gpioin(sdioh_info_t *sd, uint32 gpio)
{
	uint offset = 0;
	uint16 val;

	/* check if upper bank */
	if (gpio >= SDH_GPIO16) {
		gpio -= SDH_GPIO16;
		offset = 2;
	}

	val = sdstd_rreg16(sd, SD_GPIO_Reg + offset);
	val = (val >> gpio) & 1;

	return (val == 1);
}

extern SDIOH_API_RC
sdioh_gpio_init(sdioh_info_t *sd)
{
	uint rev;

	rev = sdstd_rreg16(sd, SD_HostControllerVersion) >> 8;

	/* Only P206 (fpga rev >= 16) supports gpio */
	if (rev < 16) {
		sd_err(("%s: gpio not supported in rev %d \n", __FUNCTION__, rev));
		return SDIOH_API_RC_FAIL;
	}

	sdstd_wreg16(sd, SD_GPIO_Enable, SDH_GPIO_ENABLE);
	sdstd_wreg16(sd, SD_GPIO_Enable + 2, SDH_GPIO_ENABLE);

	/* Default to input */
	sdstd_wreg16(sd, SD_GPIO_OE, 0);
	sdstd_wreg16(sd, SD_GPIO_OE + 2, 0);

	return SDIOH_API_RC_SUCCESS;
}

extern SDIOH_API_RC
sdioh_sleep(sdioh_info_t *sd, bool enab)
{
	SDIOH_API_RC status;
	uint32 cmd_arg = 0, rsp1 = 0;
	int retry = 100;

	sdstd_lock(sd);

	cmd_arg = SFIELD(cmd_arg, CMD14_RCA, sd->card_rca);
	cmd_arg = SFIELD(cmd_arg, CMD14_SLEEP, enab);

	/*
	 * For ExitSleep:
	 *  1) Repeat CMD14 until R1 is received
	 *  2) Send CMD7
	 */
	status = SDIOH_API_RC_FAIL;
	while (retry-- > 0) {
		if ((sdstd_cmd_issue(sd, USE_DMA(sd), SDIOH_CMD_14, cmd_arg)) == SUCCESS) {
			status = SDIOH_API_RC_SUCCESS;
			break;
		}
		OSL_DELAY(1400);
	}

	if (status == SDIOH_API_RC_FAIL) {
		sd_err(("%s: CMD14: failed! enable:%d\n", __FUNCTION__, enab));
		goto exit;
	}

	sdstd_cmd_getrsp(sd, &rsp1, 1);
	sd_info(("%s: CMD14 OK: cmd_resp:0x%x\n", __FUNCTION__, rsp1));

	/* ExitSleep: Send CMD7 After R1 */
	if (enab == FALSE) {
		/* Select the card */
		cmd_arg = SFIELD(0, CMD7_RCA, sd->card_rca);
		if ((status = sdstd_cmd_issue(sd, USE_DMA(sd), SDIOH_CMD_7, cmd_arg)) != SUCCESS) {
			sd_err(("%s: CMD14 send CMD7 failed!\n", __FUNCTION__));
			status = SDIOH_API_RC_FAIL;
			goto exit;
		}

		sdstd_cmd_getrsp(sd, &rsp1, 1);
		if (rsp1 != SDIOH_CMD7_EXP_STATUS) {
			sd_err(("%s: CMD7 response error. Response = 0x%x!\n",
			        __FUNCTION__, rsp1));
			status = SDIOH_API_RC_FAIL;
			goto exit;
		}
	}

exit:
	sdstd_unlock(sd);

	return status;
}

/* XXX Copied guts of request_byte and cmd_issue.  Might make sense to fold this into
 * those by passing another parameter indicating command type (abort).  [But maybe
 * keeping it separate is better -- if called internally on command failure it's less
 * recursion to wrap your head around?]
 */
static int
sdstd_abort(sdioh_info_t *sd, uint func)
{
	int err = 0;
	int retries;

	uint16 cmd_reg;
	uint32 cmd_arg;
	uint32 rsp5;
	uint8 rflags;

	uint16 int_reg = 0;
	uint16 plain_intstatus;

	/* Argument is write to F0 (CCCR) IOAbort with function number */
	cmd_arg = 0;
	cmd_arg = SFIELD(cmd_arg, CMD52_FUNCTION, SDIO_FUNC_0);
	cmd_arg = SFIELD(cmd_arg, CMD52_REG_ADDR, SDIOD_CCCR_IOABORT);
	cmd_arg = SFIELD(cmd_arg, CMD52_RW_FLAG, SD_IO_OP_WRITE);
	cmd_arg = SFIELD(cmd_arg, CMD52_RAW, 0);
	cmd_arg = SFIELD(cmd_arg, CMD52_DATA, func);

	/* Command is CMD52 write */
	cmd_reg = 0;
	cmd_reg = SFIELD(cmd_reg, CMD_RESP_TYPE, RESP_TYPE_48_BUSY);
	cmd_reg = SFIELD(cmd_reg, CMD_CRC_EN, 1);
	cmd_reg = SFIELD(cmd_reg, CMD_INDEX_EN, 1);
	cmd_reg = SFIELD(cmd_reg, CMD_DATA_EN, 0);
	cmd_reg = SFIELD(cmd_reg, CMD_TYPE, CMD_TYPE_ABORT);
	cmd_reg = SFIELD(cmd_reg, CMD_INDEX, SDIOH_CMD_52);

	/* XXX Copied from cmd_issue(), but no SPI response handling! */
	if (sd->sd_mode == SDIOH_MODE_SPI) {
		cmd_reg = SFIELD(cmd_reg, CMD_CRC_EN, 0);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX_EN, 0);
	}

	/* Wait for CMD_INHIBIT to go away as per spec section 3.6.1.1 */
	/* XXX For a single-threaded driver, what circumstances would result
	 * in cmd_inhibit being on but going off in a short time?  Experiment
	 * shows a HW command timeout doesn't leave inhibit on, so maybe a SW
	 * timeout?  Then that command should be responsible for clearing...
	 */
	retries = RETRIES_SMALL;
	while (GFIELD(sdstd_rreg(sd, SD_PresentState), PRES_CMD_INHIBIT)) {
		if (retries == RETRIES_SMALL)
			sd_err(("%s: Waiting for Command Inhibit, state 0x%08x\n",
			        __FUNCTION__, sdstd_rreg(sd, SD_PresentState)));
		if (!--retries) {
			sd_err(("%s: Command Inhibit timeout, state 0x%08x\n",
			        __FUNCTION__, sdstd_rreg(sd, SD_PresentState)));
			if (trap_errs)
				ASSERT(0);
			err = BCME_SDIO_ERROR;
			goto done;
		}
	}

	/* Clear errors from any previous commands */
	if ((plain_intstatus = sdstd_rreg16(sd, SD_ErrorIntrStatus)) != 0) {
		sd_err(("abort: clearing errstat 0x%04x\n", plain_intstatus));
		sdstd_wreg16(sd, SD_ErrorIntrStatus, plain_intstatus);
	}
	plain_intstatus = sdstd_rreg16(sd, SD_IntrStatus);
	if (plain_intstatus & ~(SFIELD(0, INTSTAT_CARD_INT, 1))) {
		sd_err(("abort: intstatus 0x%04x\n", plain_intstatus));
		if (GFIELD(plain_intstatus, INTSTAT_CMD_COMPLETE)) {
			sd_err(("SDSTD_ABORT: CMD COMPLETE SET BEFORE COMMAND GIVEN!!!\n"));
		}
		if (GFIELD(plain_intstatus, INTSTAT_CARD_REMOVAL)) {
			sd_err(("SDSTD_ABORT: INTSTAT_CARD_REMOVAL\n"));
			err = BCME_NODEVICE;
			goto done;
		}
	}

	/* Issue the command */
	sdstd_wreg(sd, SD_Arg0, cmd_arg);
	sdstd_wreg16(sd, SD_Command, cmd_reg);

	/* In interrupt mode return, expect later CMD_COMPLETE interrupt */
	if (!sd->polled_mode)
		return err;

	/* Otherwise, wait for the command to complete */
	retries = RETRIES_LARGE;
	do {
		int_reg = sdstd_rreg16(sd, SD_IntrStatus);
	} while (--retries &&
	         (GFIELD(int_reg, INTSTAT_ERROR_INT) == 0) &&
	         (GFIELD(int_reg, INTSTAT_CMD_COMPLETE) == 0));

	/* If command completion fails, do a cmd reset and note the error */
	if (!retries) {
		sd_err(("%s: CMD_COMPLETE timeout: intr 0x%04x err 0x%04x state 0x%08x\n",
		        __FUNCTION__, int_reg,
		        sdstd_rreg16(sd, SD_ErrorIntrStatus),
		        sdstd_rreg(sd, SD_PresentState)));

		sdstd_wreg8(sd, SD_SoftwareReset, SFIELD(0, SW_RESET_CMD, 1));
		retries = RETRIES_LARGE;
		do {
			sd_trace(("%s: waiting for CMD line reset\n", __FUNCTION__));
		} while ((GFIELD(sdstd_rreg8(sd, SD_SoftwareReset),
		                 SW_RESET_CMD)) && retries--);

		if (!retries) {
			sd_err(("%s: Timeout waiting for CMD line reset\n", __FUNCTION__));
		}

		if (trap_errs)
			ASSERT(0);

		err = BCME_SDIO_ERROR;
	}

	/* Clear Command Complete interrupt */
	int_reg = SFIELD(0, INTSTAT_CMD_COMPLETE, 1);
	sdstd_wreg16(sd, SD_IntrStatus, int_reg);

	/* Check for Errors */
	if ((plain_intstatus = sdstd_rreg16 (sd, SD_ErrorIntrStatus)) != 0) {
		sd_err(("%s: ErrorintrStatus: 0x%x, "
		        "(intrstatus = 0x%x, present state 0x%x) clearing\n",
		        __FUNCTION__, plain_intstatus,
		        sdstd_rreg16(sd, SD_IntrStatus),
		        sdstd_rreg(sd, SD_PresentState)));

		sdstd_wreg16(sd, SD_ErrorIntrStatus, plain_intstatus);

		sdstd_wreg8(sd, SD_SoftwareReset, SFIELD(0, SW_RESET_DAT, 1));
		retries = RETRIES_LARGE;
		do {
			sd_trace(("%s: waiting for DAT line reset\n", __FUNCTION__));
		} while ((GFIELD(sdstd_rreg8(sd, SD_SoftwareReset),
		                 SW_RESET_DAT)) && retries--);

		if (!retries) {
			sd_err(("%s: Timeout waiting for DAT line reset\n", __FUNCTION__));
		}

		if (trap_errs)
			ASSERT(0);

		/* ABORT is dataless, only cmd errs count */
		/* XXX But what about busy timeout?  Response valid? */
		if (plain_intstatus & ERRINT_CMD_ERRS)
			err = BCME_SDIO_ERROR;
	}

	/* If command failed don't bother looking at response */
	if (err)
		goto done;

	/* Otherwise, check the response */
	sdstd_cmd_getrsp(sd, &rsp5, 1);
	rflags = GFIELD(rsp5, RSP5_FLAGS);

	if (rflags & SD_RSP_R5_ERRBITS) {
		sd_err(("%s: R5 flags include errbits: 0x%02x\n", __FUNCTION__, rflags));

		/* The CRC error flag applies to the previous command */
		if (rflags & (SD_RSP_R5_ERRBITS & ~SD_RSP_R5_COM_CRC_ERROR)) {
			err = BCME_SDIO_ERROR;
			goto done;
		}
	}

	if (((rflags & (SD_RSP_R5_IO_CURRENTSTATE0 | SD_RSP_R5_IO_CURRENTSTATE1)) != 0x10) &&
	    ((rflags & (SD_RSP_R5_IO_CURRENTSTATE0 | SD_RSP_R5_IO_CURRENTSTATE1)) != 0x20)) {
		sd_err(("%s: R5 flags has bad state: 0x%02x\n", __FUNCTION__, rflags));
		err = BCME_SDIO_ERROR;
		goto done;
	}

	if (GFIELD(rsp5, RSP5_STUFF)) {
		sd_err(("%s: rsp5 stuff is 0x%x: should be 0\n",
		        __FUNCTION__, GFIELD(rsp5, RSP5_STUFF)));
		err = BCME_SDIO_ERROR;
		goto done;
	}

done:
	if (err == BCME_NODEVICE)
		return err;

	/* XXX As per spec 3.7.1 (and to be safe) do the resets here */
	sdstd_wreg8(sd, SD_SoftwareReset,
	            SFIELD(SFIELD(0, SW_RESET_DAT, 1), SW_RESET_CMD, 1));

	retries = RETRIES_LARGE;
	do {
		rflags = sdstd_rreg8(sd, SD_SoftwareReset);
		if (!GFIELD(rflags, SW_RESET_DAT) && !GFIELD(rflags, SW_RESET_CMD))
			break;
	} while (--retries);

	if (!retries) {
		sd_err(("%s: Timeout waiting for DAT/CMD reset: 0x%02x\n",
		        __FUNCTION__, rflags));
		err = BCME_SDIO_ERROR;
	}

	return err;
}

extern int
sdioh_abort(sdioh_info_t *sd, uint fnum)
{
	int ret;

	sdstd_lock(sd);
	ret = sdstd_abort(sd, fnum);
	sdstd_unlock(sd);

	return ret;
}

int
sdioh_start(sdioh_info_t *sd, int stage)
{
	return SUCCESS;
}

int
sdioh_stop(sdioh_info_t *sd)
{
	return SUCCESS;
}

int
sdioh_waitlockfree(sdioh_info_t *sd)
{
	sdstd_waitlockfree(sd);
	return SUCCESS;
}

static int
sdstd_check_errs(sdioh_info_t *sdioh_info, uint32 cmd, uint32 arg)
{
	uint16 regval;
	uint retries;
	uint function = 0;

	/* If no errors, we're done */
	if ((regval = sdstd_rreg16(sdioh_info, SD_ErrorIntrStatus)) == 0)
		return SUCCESS;

#ifdef BCMQT
	if (regval == 0xFFFF) {
		/* XXX - Getting bogus errors under QT
		 * XXX - Not sure why; Just ignore for now
		 */
		sd_err(("%s: Bogus SD_ErrorIntrStatus: 0x%x????\n", __FUNCTION__, regval));
		sdstd_wreg16(sdioh_info, SD_ErrorIntrStatus, regval);
		return SUCCESS;
	}
#endif

	sd_info(("%s: ErrorIntrStatus 0x%04x (clearing), IntrStatus 0x%04x PresentState 0x%08x\n",
	        __FUNCTION__, regval, sdstd_rreg16(sdioh_info, SD_IntrStatus),
	        sdstd_rreg(sdioh_info, SD_PresentState)));
	sdstd_wreg16(sdioh_info, SD_ErrorIntrStatus, regval);

	if (cmd == SDIOH_CMD_14) {
		if (regval & ERRINT_CMD_TIMEOUT_BIT) {
			/* PR 101351: sdiod_aos sleep followed by immediate wakeup
			 *    before sdiod_aos takes over has a problem.
			 * Getting command timeouts while exiting sleep
			 * with CMD14. Ignore this error due to this PR.
			 */
			regval &= ~ERRINT_CMD_TIMEOUT_BIT;
		}
	}

	/* On command error, issue CMD reset */
	if (regval & ERRINT_CMD_ERRS) {
		sd_trace(("%s: issuing CMD reset\n", __FUNCTION__));
		sdstd_wreg8(sdioh_info, SD_SoftwareReset, SFIELD(0, SW_RESET_CMD, 1));
		for (retries = RETRIES_LARGE; retries; retries--)
			if (!(GFIELD(sdstd_rreg8(sdioh_info, SD_SoftwareReset), SW_RESET_CMD)))
				break;
		if (!retries) {
			sd_err(("%s: Timeout waiting for CMD line reset\n", __FUNCTION__));
		}
	}

	/* On data error, issue DAT reset */
	if (regval & ERRINT_DATA_ERRS) {
		if (regval & ERRINT_ADMA_BIT)
			sd_err(("%s:ADMAError: status:0x%x\n",
				__FUNCTION__, sdstd_rreg(sdioh_info, SD_ADMA_ErrStatus)));
		sd_trace(("%s: issuing DAT reset\n", __FUNCTION__));
		sdstd_wreg8(sdioh_info, SD_SoftwareReset, SFIELD(0, SW_RESET_DAT, 1));
		for (retries = RETRIES_LARGE; retries; retries--)
			if (!(GFIELD(sdstd_rreg8(sdioh_info, SD_SoftwareReset), SW_RESET_DAT)))
				break;
		if (!retries) {
			sd_err(("%s: Timeout waiting for DAT line reset\n", __FUNCTION__));
		}
	}

	/* For an IO command (CMD52 or CMD53) issue an abort to the appropriate function */
	if (cmd == SDIOH_CMD_53)
		function = GFIELD(arg, CMD53_FUNCTION);
	else if (cmd == SDIOH_CMD_52) {
		/* PR 101351: sdiod_aos sleep followed by immediate wakeup
		 *    before sdiod_aos takes over has a problem.
		 */
		if (GFIELD(arg, CMD52_REG_ADDR) != F1_SLEEPCSR_ADDR)
			function = GFIELD(arg, CMD52_FUNCTION);
	}
	if (function) {
		sd_trace(("%s: requesting abort for function %d after cmd %d\n",
		          __FUNCTION__, function, cmd));
		sdstd_abort(sdioh_info, function);
	}

	if (trap_errs)
		ASSERT(0);

	return ERROR;
}

#ifdef BCMINTERNAL
extern SDIOH_API_RC
sdioh_test_diag(sdioh_info_t *sd)
{
	sd_err(("%s: Implement me\n", __FUNCTION__));
	return (0);
}
#endif /* BCMINTERNAL */

/*
 * Private/Static work routines
 */
static bool
sdstd_reset(sdioh_info_t *sd, bool host_reset, bool client_reset)
{
	int retries = RETRIES_LARGE;
	uchar regval;

	if (!sd)
		return TRUE;

	sdstd_lock(sd);
	/* Reset client card */
	if (client_reset && (sd->adapter_slot != -1)) {
		if (sdstd_card_regwrite(sd, 0, SDIOD_CCCR_IOABORT, 1, 0x8) != SUCCESS)
			sd_err(("%s: Cannot write to card reg 0x%x\n",
			        __FUNCTION__, SDIOD_CCCR_IOABORT));
		else
			sd->card_rca = 0;
	}

	/* Reset host controller */
	if (host_reset) {
		regval = SFIELD(0, SW_RESET_ALL, 1);
		sdstd_wreg8(sd, SD_SoftwareReset, regval);
		do {
			sd_trace(("%s: waiting for reset\n", __FUNCTION__));
		} while ((sdstd_rreg8(sd, SD_SoftwareReset) & regval) && retries--);

		if (!retries) {
			sd_err(("%s: Timeout waiting for host reset\n", __FUNCTION__));
			sdstd_unlock(sd);
			return (FALSE);
		}

		/* A reset should reset bus back to 1 bit mode */
		sd->sd_mode = SDIOH_MODE_SD1;
		sdstd_set_dma_mode(sd, sd->sd_dma_mode);
	}
	sdstd_unlock(sd);
	return TRUE;
}

/* Disable device interrupt */
void
sdstd_devintr_off(sdioh_info_t *sd)
{
	sd_trace(("%s: %d\n", __FUNCTION__, sd->use_client_ints));
	if (sd->use_client_ints) {
		sd->intmask &= ~CLIENT_INTR;
		sdstd_wreg16(sd, SD_IntrSignalEnable, sd->intmask);
		sdstd_rreg16(sd, SD_IntrSignalEnable); /* Sync readback */
	}
}

/* Enable device interrupt */
void
sdstd_devintr_on(sdioh_info_t *sd)
{
	ASSERT(sd->lockcount == 0);
	sd_trace(("%s: %d\n", __FUNCTION__, sd->use_client_ints));
	if (sd->use_client_ints) {
		if (sd->version < HOST_CONTR_VER_3) {
			uint16 status = sdstd_rreg16(sd, SD_IntrStatusEnable);
			sdstd_wreg16(sd, SD_IntrStatusEnable, SFIELD(status, INTSTAT_CARD_INT, 0));
			sdstd_wreg16(sd, SD_IntrStatusEnable, status);
		}

		sd->intmask |= CLIENT_INTR;
		sdstd_wreg16(sd, SD_IntrSignalEnable, sd->intmask);
		sdstd_rreg16(sd, SD_IntrSignalEnable); /* Sync readback */
	}
}

#ifdef BCMSDYIELD
/* Enable/disable other interrupts */
void
sdstd_intrs_on(sdioh_info_t *sd, uint16 norm, uint16 err)
{
	if (err) {
		norm = SFIELD(norm, INTSTAT_ERROR_INT, 1);
		sdstd_wreg16(sd, SD_ErrorIntrSignalEnable, err);
	}

	sd->intmask |= norm;
	sdstd_wreg16(sd, SD_IntrSignalEnable, sd->intmask);
	if (sd_forcerb)
		sdstd_rreg16(sd, SD_IntrSignalEnable); /* Sync readback */
}

void
sdstd_intrs_off(sdioh_info_t *sd, uint16 norm, uint16 err)
{
	if (err) {
		norm = SFIELD(norm, INTSTAT_ERROR_INT, 1);
		sdstd_wreg16(sd, SD_ErrorIntrSignalEnable, 0);
	}

	sd->intmask &= ~norm;
	sdstd_wreg16(sd, SD_IntrSignalEnable, sd->intmask);
	if (sd_forcerb)
		sdstd_rreg16(sd, SD_IntrSignalEnable); /* Sync readback */
}
#endif /* BCMSDYIELD */

static int
sdstd_host_init(sdioh_info_t *sd)
{
	int 		num_slots, full_slot;
	uint8		reg8;
	uint32		card_ins;
	int		slot, first_bar = 0;
	bool		detect_slots = FALSE;
#ifdef _WIN32
	NDIS_PHYSICAL_ADDRESS	bar;
#else
	uint		bar;
#endif

	/* Check for Arasan ID */
	if ((OSL_PCI_READ_CONFIG(sd->osh, PCI_CFG_VID, 4) & 0xFFFF) == VENDOR_SI_IMAGE) {
		sd_info(("%s: Found Arasan Standard SDIO Host Controller\n", __FUNCTION__));
		sd->controller_type = SDIOH_TYPE_ARASAN_HDK;
		detect_slots = TRUE;
		/* Controller supports SDMA, so turn it on here. */
		sd->sd_dma_mode = DMA_MODE_SDMA;
	} else if ((OSL_PCI_READ_CONFIG(sd->osh, PCI_CFG_VID, 4) & 0xFFFF) == VENDOR_BROADCOM) {
		sd_info(("%s: Found Broadcom 27xx Standard SDIO Host Controller\n", __FUNCTION__));
		sd->controller_type = SDIOH_TYPE_BCM27XX;
		detect_slots = FALSE;
	} else if ((OSL_PCI_READ_CONFIG(sd->osh, PCI_CFG_VID, 4) & 0xFFFF) == VENDOR_TI) {
		sd_info(("%s: Found TI PCIxx21 Standard SDIO Host Controller\n", __FUNCTION__));
		sd->controller_type = SDIOH_TYPE_TI_PCIXX21;
		detect_slots = TRUE;
	} else if ((OSL_PCI_READ_CONFIG(sd->osh, PCI_CFG_VID, 4) & 0xFFFF) == VENDOR_RICOH) {
		sd_info(("%s: Ricoh Co Ltd R5C822 SD/SDIO/MMC/MS/MSPro Host Adapter\n",
			__FUNCTION__));
		sd->controller_type = SDIOH_TYPE_RICOH_R5C822;
		detect_slots = TRUE;
	} else if ((OSL_PCI_READ_CONFIG(sd->osh, PCI_CFG_VID, 4) & 0xFFFF) == VENDOR_JMICRON) {
		sd_info(("%s: JMicron Standard SDIO Host Controller\n",
			__FUNCTION__));
		sd->controller_type = SDIOH_TYPE_JMICRON;
		detect_slots = TRUE;
#ifdef BCMINTERNAL
	} else if ((OSL_PCI_READ_CONFIG(sd->osh, PCI_CFG_VID, 4) & 0xFFFF) == VENDOR_JINVANI) {
		sd_info(("%s: Found Jinvani Standard SDIO Host Controller\n", __FUNCTION__));
		detect_slots = FALSE;
		sd->controller_type = SDIOH_TYPE_JINVANI_GOLD;
#endif /* BCMINTERNAL */
	} else {
		return ERROR;
	}

	/*
	 * Determine num of slots
	 * Search each slot
	 */

	first_bar = OSL_PCI_READ_CONFIG(sd->osh, SD_SlotInfo, 4) & 0x7;
	num_slots = (OSL_PCI_READ_CONFIG(sd->osh, SD_SlotInfo, 4) & 0xff) >> 4;
	num_slots &= 7;
	num_slots++;   	/* map bits to num slots according to spec */

	/* XXX Since the sdio20h core does not present the proper SD_SlotInfo
	 * register at PCI config space offset 0x40, fake it here.  Also,
	 * set the BAR0 window to point to the sdio20h core.
	 */
	if (OSL_PCI_READ_CONFIG(sd->osh, PCI_CFG_VID, 4) ==
	    ((SDIOH_FPGA_ID << 16) | VENDOR_BROADCOM)) {
		sd_err(("%s: Found Broadcom Standard SDIO Host Controller FPGA\n", __FUNCTION__));
		/* Set BAR0 Window to SDIOSTH core */
		OSL_PCI_WRITE_CONFIG(sd->osh, PCI_BAR0_WIN, 4, 0x18001000);

		/* Set defaults particular to this controller. */
		detect_slots = TRUE;
		num_slots = 1;
		first_bar = 0;

		/* Controller supports ADMA2, so turn it on here. */
		sd->sd_dma_mode = DMA_MODE_ADMA2;
	}

	/* Map in each slot on the board and query it to see if a
	 * card is inserted.  Use the first populated slot found.
	 */
	if (sd->mem_space) {
		sdstd_reg_unmap(sd->osh, (ulong)sd->mem_space, SDIOH_REG_WINSZ);
		sd->mem_space = NULL;
	}

	full_slot = -1;

	for (slot = 0; slot < num_slots; slot++) {
/* XXX :Ugly define, is there a better way */
#ifdef _WIN32
		bar.HighPart = 0;
		bar.LowPart = OSL_PCI_READ_CONFIG(sd->osh, PCI_CFG_BAR0
		              + (4*(slot + first_bar)), 4);
		sd->mem_space = (volatile char *)sdstd_reg_map(sd->osh,
		                                               (int32)&bar, SDIOH_REG_WINSZ);
#else
		bar = OSL_PCI_READ_CONFIG(sd->osh, PCI_CFG_BAR0 + (4*(slot + first_bar)), 4);
		sd->mem_space = (volatile char *)sdstd_reg_map(sd->osh,
		                                               (uintptr)bar, SDIOH_REG_WINSZ);
#endif

		sd->adapter_slot = -1;

		if (detect_slots) {
			card_ins = GFIELD(sdstd_rreg(sd, SD_PresentState), PRES_CARD_PRESENT);
		} else {
			card_ins = TRUE;
		}

		if (card_ins) {
			sd_info(("%s: SDIO slot %d: Full\n", __FUNCTION__, slot));
			if (full_slot < 0)
				full_slot = slot;
		} else {
			sd_info(("%s: SDIO slot %d: Empty\n", __FUNCTION__, slot));
		}

		if (sd->mem_space) {
			sdstd_reg_unmap(sd->osh, (ulong)sd->mem_space, SDIOH_REG_WINSZ);
			sd->mem_space = NULL;
		}
	}

	if (full_slot < 0) {
		sd_err(("No slots on SDIO controller are populated\n"));
		return -1;
	}

/* XXX :Ugly define, is there a better way */
#ifdef _WIN32
	bar.HighPart = 0;
	bar.LowPart = OSL_PCI_READ_CONFIG(sd->osh, PCI_CFG_BAR0 + (4*(full_slot + first_bar)), 4);
	sd->mem_space = (volatile char *)sdstd_reg_map(sd->osh, (int32)&bar, SDIOH_REG_WINSZ);
#else
	bar = OSL_PCI_READ_CONFIG(sd->osh, PCI_CFG_BAR0 + (4*(full_slot + first_bar)), 4);
	sd->mem_space = (volatile char *)sdstd_reg_map(sd->osh, (uintptr)bar, SDIOH_REG_WINSZ);
#endif

	sd_err(("Using slot %d at BAR%d [0x%08x] mem_space 0x%p\n",
		full_slot,
		(full_slot + first_bar),
		OSL_PCI_READ_CONFIG(sd->osh, PCI_CFG_BAR0 + (4*(full_slot + first_bar)), 4),
		sd->mem_space));

	sd->adapter_slot = full_slot;

	sd->version = sdstd_rreg16(sd, SD_HostControllerVersion) & 0xFF;
	switch (sd->version) {
		case 0:
			sd_err(("Host Controller version 1.0, Vendor Revision: 0x%02x\n",
				sdstd_rreg16(sd, SD_HostControllerVersion) >> 8));
			break;
		case 1:
			sd_err(("Host Controller version 2.0, Vendor Revision: 0x%02x\n",
				sdstd_rreg16(sd, SD_HostControllerVersion) >> 8));
			break;
		case 2:
			sd_err(("Host Controller version 3.0, Vendor Revision: 0x%02x\n",
				sdstd_rreg16(sd, SD_HostControllerVersion) >> 8));
			break;
		default:
			sd_err(("%s: Host Controller version 0x%02x not supported.\n",
			    __FUNCTION__, sd->version));
			break;
	}

	sd->caps = sdstd_rreg(sd, SD_Capabilities);	/* Cache this for later use */
	/* MSB 32 bits of caps supported in sdio 3.0 */
	sd->caps3 = sdstd_rreg(sd, SD_Capabilities3); /* Cache this for later use */
	sd3_trace(("sd3: %s: caps: 0x%x; MCCap:0x%x\n", __FUNCTION__, sd->caps, sd->curr_caps));
	sd3_trace(("sd3: %s: caps3: 0x%x\n", __FUNCTION__, sd->caps3));
	sd->curr_caps = sdstd_rreg(sd, SD_MaxCurCap);

	sd_info(("%s: caps: 0x%x; MCCap:0x%x\n", __FUNCTION__, sd->caps, sd->curr_caps));

	sdstd_set_dma_mode(sd, sd->sd_dma_mode);

#if defined(BCMINTERNAL)
	if (OSL_PCI_READ_CONFIG(sd->osh, PCI_CFG_VID, 4) ==
	    ((SDIOH_FPGA_ID << 16) | VENDOR_BROADCOM)) {
			sd_err(("* * * SDIO20H FPGA Build Date: 0x%04x\n", sdstd_rreg(sd, 0x110)));
	}

	if (GFIELD(sd->caps, CAP_MAXBLOCK) == 0x3) {
		sd_info(("SD HOST CAPS: Max block size is INVALID\n"));
	} else {
		sd_info(("SD HOST CAPS: Max block size is %d bytes\n",
			512 << GFIELD(sd->caps, CAP_MAXBLOCK)));
	}

	sd_info(("SD HOST CAPS: 64-bit DMA is %ssupported.\n",
		GFIELD(sd->caps, CAP_64BIT_HOST) ? "" : "not "));
	sd_info(("SD HOST CAPS: Suspend/Resume is %ssupported.\n",
		GFIELD(sd->caps, CAP_SUSPEND) ? "" : "not "));

	sd_err(("SD HOST CAPS: SD Host supports "));
	if (GFIELD(sd->caps, CAP_VOLT_3_3)) {
		sd_err(("3.3V"));
		if (GFIELD(sd->curr_caps, CAP_CURR_3_3)) {
			sd_err(("@%dmA\n", 4*GFIELD(sd->curr_caps, CAP_CURR_3_3)));
		}
	}
	if (GFIELD(sd->caps, CAP_VOLT_3_0)) {
		sd_err((", 3.0V"));
		if (GFIELD(sd->curr_caps, CAP_CURR_3_0)) {
			sd_err(("@%dmA\n", 4*GFIELD(sd->curr_caps, CAP_CURR_3_0)));
		}
	}
	if (GFIELD(sd->caps, CAP_VOLT_1_8)) {
		sd_err((", 1.8V"));
		if (GFIELD(sd->curr_caps, CAP_CURR_1_8)) {
			sd_err(("@%dmA\n", 4*GFIELD(sd->curr_caps, CAP_CURR_1_8)));
		}
	}
	sd_err(("\n"));
#endif /* defined(BCMINTERNAL) */

	sdstd_reset(sd, 1, 0);

	/* Read SD4/SD1 mode */
	if ((reg8 = sdstd_rreg8(sd, SD_HostCntrl))) {
		if (reg8 & SD4_MODE) {
			sd_err(("%s: Host cntrlr already in 4 bit mode: 0x%x\n",
			        __FUNCTION__,  reg8));
		}
	}

	/* Default power on mode is SD1 */
	sd->sd_mode = SDIOH_MODE_SD1;
	sd->polled_mode = TRUE;
	sd->host_init_done = TRUE;
	sd->card_init_done = FALSE;
	sd->adapter_slot = full_slot;

	/* XXX: If sd_uhsimode is disabled, which means that, use the HC in SDIO 2.0 mode. */
	if (sd_uhsimode == SD3CLKMODE_DISABLED) {
		sd->version = HOST_CONTR_VER_2;
		sd3_trace(("%s:forcing to SDIO HC 2.0\n", __FUNCTION__));
	}

	if (sd->version == HOST_CONTR_VER_3) {
		/* read host ctrl 2 */
		uint16 reg16 = 0;
		sd3_trace(("sd3: %s: HC3: reading additional regs\n", __FUNCTION__));

		reg16 = sdstd_rreg16(sd, SD3_HostCntrl2);

		sd_info(("%s: HCtrl: 0x%x; HCtrl2:0x%x\n", __FUNCTION__, reg8, reg16));
		BCM_REFERENCE(reg16);

		/* if HC supports 1.8V and one of the SDR/DDR modes, hc uhci support is PRESENT */
		if ((GFIELD(sd->caps, CAP_VOLT_1_8)) &&
			(GFIELD(sd->caps3, CAP3_SDR50_SUP) ||
			GFIELD(sd->caps3, CAP3_SDR104_SUP) ||
			GFIELD(sd->caps3, CAP3_DDR50_SUP)))
			sd->host_UHSISupported = 1;
	}

#ifdef BCMQT
	{
		uint32 intmask;

		/* FIX: force interrupts with QT sdio20 host */
		/* pci cw [expr $def(configbase) +0x95] 1 2 */
		intmask = OSL_PCI_READ_CONFIG(sd->osh, PCI_INT_MASK, 4);
		intmask |= 0x0200;
		OSL_PCI_WRITE_CONFIG(sd->osh, PCI_INT_MASK, 4, intmask);
	}
#endif
	return (SUCCESS);
}
#define CMD5_RETRIES 200
static int
get_ocr(sdioh_info_t *sd, uint32 *cmd_arg, uint32 *cmd_rsp)
{
	int retries, status;

	/* Get the Card's Operation Condition.  Occasionally the board
	 * takes a while to become ready
	 */
	retries = CMD5_RETRIES;
	do {
		*cmd_rsp = 0;
		if ((status = sdstd_cmd_issue(sd, USE_DMA(sd), SDIOH_CMD_5, *cmd_arg))
		    != SUCCESS) {
			sd_err(("%s: CMD5 failed\n", __FUNCTION__));
			return status;
		}
		sdstd_cmd_getrsp(sd, cmd_rsp, 1);
		if (!GFIELD(*cmd_rsp, RSP4_CARD_READY))
			sd_trace(("%s: Waiting for card to become ready\n", __FUNCTION__));
	} while ((!GFIELD(*cmd_rsp, RSP4_CARD_READY)) && --retries);
	if (!retries)
		return ERROR;

	return (SUCCESS);
}

static int
sdstd_client_init(sdioh_info_t *sd)
{
	uint32 cmd_arg, cmd_rsp;
	int status;
	uint8 fn_ints;
	uint32 regdata;
	uint16 powerstat = 0;

#ifdef BCMINTERNAL
#ifdef NOTUSED
	/* Handy routine to dump capabilities. */
	static char caps_buf[500];
	parse_caps(sd->caps, caps_buf, 500);
	sd_err((caps_buf));
#endif /* NOTUSED */
#endif /* BCMINTERNAL */

	sd_trace(("%s: Powering up slot %d\n", __FUNCTION__, sd->adapter_slot));

	/* Clear any pending ints */
	sdstd_wreg16(sd, SD_IntrStatus, 0x1fff);
	sdstd_wreg16(sd, SD_ErrorIntrStatus, 0x0fff);

	/* Enable both Normal and Error Status.  This does not enable
	 * interrupts, it only enables the status bits to
	 * become 'live'
	 */

	if (!sd->host_UHSISupported)
		sdstd_wreg16(sd, SD_IntrStatusEnable, 0x1ff);
	else
	{
		/* INT_x interrupts, but DO NOT enable signalling [enable retuning
		 * will happen later]
		 */
		sdstd_wreg16(sd, SD_IntrStatusEnable, 0x0fff);
	}
	sdstd_wreg16(sd, SD_ErrorIntrStatusEnable, 0xffff);

	sdstd_wreg16(sd, SD_IntrSignalEnable, 0);	  /* Disable ints for now. */

	if (sd->host_UHSISupported) {
		/* when HC is started for SDIO 3.0 mode, start in lowest voltage mode first. */
		powerstat = sdstd_start_power(sd, 1);
		if (SDIO_OCR_READ_FAIL == powerstat) {
			/* This could be because the device is 3.3V, and possible does
			 * not have sdio3.0 support. So, try in highest voltage
			 */
			sd_err(("sdstd_start_power: legacy device: trying highest voltage\n"));
			sd_err(("%s failed\n", __FUNCTION__));
			return ERROR;
		} else if (TRUE != powerstat) {
			sd_err(("sdstd_start_power failed\n"));
			return ERROR;
		}
	} else
	/* XXX legacy driver: start in highest voltage mode first.
	 * CAUTION: trying to start a legacy dhd with sdio3.0HC and sdio3.0 device could
	 * burn the sdio3.0device if the device has started in 1.8V.
	 */
	if (TRUE != sdstd_start_power(sd, 0)) {
		sd_err(("sdstd_start_power failed\n"));
		return ERROR;
	}

	if (sd->num_funcs == 0) {
		sd_err(("%s: No IO funcs!\n", __FUNCTION__));
		return ERROR;
	}

	/* In SPI mode, issue CMD0 first */
	if (sd->sd_mode == SDIOH_MODE_SPI) {
		cmd_arg = 0;
		if ((status = sdstd_cmd_issue(sd, USE_DMA(sd), SDIOH_CMD_0, cmd_arg))
		    != SUCCESS) {
			sd_err(("BCMSDIOH: cardinit: CMD0 failed!\n"));
			return status;
		}
	}

	if (sd->sd_mode != SDIOH_MODE_SPI) {
		uint16 rsp6_status;

		/* Card is operational. Ask it to send an RCA */
		cmd_arg = 0;
		if ((status = sdstd_cmd_issue(sd, USE_DMA(sd), SDIOH_CMD_3, cmd_arg))
		    != SUCCESS) {
			sd_err(("%s: CMD3 failed!\n", __FUNCTION__));
			return status;
		}

		/* Verify the card status returned with the cmd response */
		sdstd_cmd_getrsp(sd, &cmd_rsp, 1);
		rsp6_status = GFIELD(cmd_rsp, RSP6_STATUS);
		if (GFIELD(rsp6_status, RSP6STAT_COM_CRC_ERROR) ||
		    GFIELD(rsp6_status, RSP6STAT_ILLEGAL_CMD) ||
		    GFIELD(rsp6_status, RSP6STAT_ERROR)) {
			sd_err(("%s: CMD3 response error. Response = 0x%x!\n",
			        __FUNCTION__, rsp6_status));
			return ERROR;
		}

		/* Save the Card's RCA */
		sd->card_rca = GFIELD(cmd_rsp, RSP6_IO_RCA);
		sd_info(("RCA is 0x%x\n", sd->card_rca));

		if (rsp6_status)
			sd_err(("raw status is 0x%x\n", rsp6_status));

		/* Select the card */
		cmd_arg = SFIELD(0, CMD7_RCA, sd->card_rca);
		if ((status = sdstd_cmd_issue(sd, USE_DMA(sd), SDIOH_CMD_7, cmd_arg))
		    != SUCCESS) {
			sd_err(("%s: CMD7 failed!\n", __FUNCTION__));
			return status;
		}
		sdstd_cmd_getrsp(sd, &cmd_rsp, 1);
		if (cmd_rsp != SDIOH_CMD7_EXP_STATUS) {
			sd_err(("%s: CMD7 response error. Response = 0x%x!\n",
			        __FUNCTION__, cmd_rsp));
			return ERROR;
		}
	}

	/* Disable default/power-up device Card Detect (CD) pull up resistor on DAT3
	 * via CCCR bus interface control register.  Set CD disable bit while leaving
	 * others alone.
	 */
	if (sdstd_card_regread (sd, 0, SDIOD_CCCR_BICTRL, 1, &regdata) != SUCCESS) {
		sd_err(("Disabling card detect: read of device CCCR BICTRL register failed\n"));
		return ERROR;
	}
	regdata |= BUS_CARD_DETECT_DIS;

	if (sdstd_card_regwrite (sd, 0, SDIOD_CCCR_BICTRL, 1, regdata) != SUCCESS) {
		sd_err(("Disabling card detect: write of device CCCR BICTRL register failed\n"));
		return ERROR;
	}

	sdstd_card_enablefuncs(sd);

	if (!sdstd_bus_width(sd, sd_sdmode)) {
		sd_err(("sdstd_bus_width failed\n"));
		return ERROR;
	}

	set_client_block_size(sd, 1, sd_f1_blocksize);
	fn_ints = INTR_CTL_FUNC1_EN;

	if (sd->num_funcs >= 2) {
		/* XXX Device side can't handle 512 yet */
		set_client_block_size(sd, 2, sd_f2_blocksize /* BLOCK_SIZE_4328 */);
		fn_ints |= INTR_CTL_FUNC2_EN;
	}

	/* Enable/Disable Client interrupts */
	/* Turn on here but disable at host controller? */
	if (sdstd_card_regwrite(sd, 0, SDIOD_CCCR_INTEN, 1,
	                        (fn_ints | INTR_CTL_MASTER_EN)) != SUCCESS) {
		sd_err(("%s: Could not enable ints in CCCR\n", __FUNCTION__));
		return ERROR;
	}

	if (sd_uhsimode != SD3CLKMODE_DISABLED) {
	/* Switch to High-speed clocking mode if both host and device support it */
		if (sdstd_3_clock_wrapper(sd) != SUCCESS) {
				sd_err(("sdstd_3_clock_wrapper failed\n"));
				return ERROR;
		}
	} else
	{
		if (sdstd_clock_wrapper(sd)) {
			sd_err(("sdstd_start_clock failed\n"));
			return ERROR;
		}
	}
	sd->card_init_done = TRUE;

	return SUCCESS;
}

static int
sdstd_clock_wrapper(sdioh_info_t *sd)
{
	sd_trace(("%s:Enter\n", __FUNCTION__));
	/* After configuring for High-Speed mode, set the desired clock rate. */
	sdstd_set_highspeed_mode(sd, (bool)sd_hiok);

	if (FALSE == sdstd_start_clock(sd, (uint16)sd_divisor)) {
		sd_err(("sdstd_start_clock failed\n"));
		return ERROR;
	}
	return SUCCESS;
}

static int
sdstd_3_clock_wrapper(sdioh_info_t *sd)
{
	int retclk = 0;
	sd_info(("%s: Enter\n", __FUNCTION__));
	if (sd->card_UHSI_voltage_Supported) {
		/* check if clk config requested is supported by both host and target. */
		retclk = sdstd_3_get_matching_uhsi_clkmode(sd, sd_uhsimode);

		/* if no match for requested caps, try to get the max match possible */
		if (retclk == -1) {
			/* if auto enabled */
			if (sd3_autoselect_uhsi_max == 1) {
				retclk = sdstd_3_get_matching_uhsi_clkmode(sd, SD3CLKMODE_AUTO);
				/* still NO match */
				if (retclk == -1) {
					/* NO match with HC and card capabilities. Now try the
					 * High speed/legacy mode if possible.
					 */

					sd_err(("%s: Not able to set requested clock\n",
					        __FUNCTION__));
					return ERROR;
				}
			} else {
				/* means user doesn't want auto clock. So return ERROR */
				sd_err(("%s: Not able to set requested clock, Try"
				"auto mode\n", __FUNCTION__));
				return ERROR;
			}
		}

		if (retclk != -1) {
			/* set the current clk to be selected clock */
			sd_uhsimode = retclk;

			if (BCME_OK != sdstd_3_set_highspeed_uhsi_mode(sd, sd_uhsimode)) {
				sd_err(("%s: Not able to set requested clock\n", __FUNCTION__));
				return ERROR;
			}
		} else {
			/* try legacy mode */
			if (SUCCESS != sdstd_clock_wrapper(sd)) {
				sd_err(("sdstd_start_clock failed\n"));
				return ERROR;
			}
		}
	} else {
		sd_info(("%s: Legacy Mode Clock\n", __FUNCTION__));
		/* try legacy mode */
		if (SUCCESS != sdstd_clock_wrapper(sd)) {
			sd_err(("%s sdstd_clock_wrapper failed\n", __FUNCTION__));
			return ERROR;
		}
	}
	return SUCCESS;
}

int
sdstd_3_clk_tuning(sdioh_info_t *sd, uint32 sd3ClkMode)
{
	int status, lcount = 0, brr_count = 0;
	uint16 val1 = 0, bufready = 0;
	uint32 val2 = 0;
	uint8 phase_info_local = 0;

	sd3_trace(("sd3: %s: Enter\n", __FUNCTION__));
	/* if (NOT SDR104) OR
	 *	(SDR_50 AND sdr50_tuning_reqd is NOT enabled)
	 * return success, as tuning not reqd.
	 */
	if (!sd->sd3_tuning_reqd) {
		sd_info(("%s: Tuning NOT reqd!\n", __FUNCTION__));
		return SUCCESS;
	}

	/* execute tuning procedure */

	/* enable Buffer ready  status. [donot enable the interrupt right now] */
	/* Execute tuning */
	sd_trace(("sd3: %s: Execute tuning\n", __FUNCTION__));
	val1 = sdstd_rreg16(sd, SD3_HostCntrl2);
	val1 = SFIELD(val1, HOSTCtrl2_EXEC_TUNING, 1);
	sdstd_wreg16(sd, SD3_HostCntrl2, val1);

	do {
		sd3_trace(("sd3: %s: cmd19 issue\n", __FUNCTION__));
		/* Issue cmd19 */
		if ((status = sdstd_cmd_issue(sd, USE_DMA(sd), SDIOH_CMD_19, 0))
			!= SUCCESS) {
			sd_err(("%s: CMD19 failed\n", __FUNCTION__));
			val1 = sdstd_rreg16(sd, SD3_HostCntrl2);
			val1 = SFIELD(val1, HOSTCtrl2_EXEC_TUNING, 0);
			val1 = SFIELD(val1, HOSTCtrl2_SAMPCLK_SEL, 0);
			sdstd_wreg16(sd, SD3_HostCntrl2, val1);
			return status;
		}

		/* wait for buffer read ready */
		brr_count = 0;
		do {
			bufready = sdstd_rreg16(sd, SD_IntrStatus);

			if (GFIELD(bufready, INTSTAT_BUF_READ_READY))
				break;

			/* delay after checking bufready becuase INTSTAT_BUF_READ_READY
			   might have been most likely set already in the first check
			*/
			OSL_DELAY(1);
		} while (++brr_count < CLKTUNING_MAX_BRR_RETRIES);

		/* buffer read ready timedout */
		if (brr_count == CLKTUNING_MAX_BRR_RETRIES) {
			sd_err(("%s: TUNINGFAILED: BRR response timedout!\n",
				__FUNCTION__));
			val1 = sdstd_rreg16(sd, SD3_HostCntrl2);
			val1 = SFIELD(val1, HOSTCtrl2_EXEC_TUNING, 0);
			val1 = SFIELD(val1, HOSTCtrl2_SAMPCLK_SEL, 0);
			sdstd_wreg16(sd, SD3_HostCntrl2, val1);
			return ERROR;
		}

		/* In response to CMD19 card will send 64 magic bytes.
		 * Current Aizyc HC h/w doesn't auto clear those bytes.
		 * So read 64 bytes send by card.
		 * Aizyc need to implement in hw to do an auto clear.
		*/
		if (sd3_sw_read_magic_bytes == TRUE)
		{
			uint8 l_cnt_1 = 0;
			uint32 l_val_1 = 0;
			for (l_cnt_1 = 0; l_cnt_1 < 16; l_cnt_1++) {
				l_val_1 = sdstd_rreg(sd, SD_BufferDataPort0);
				sd_trace(("%s:l_val_1 = 0x%x", __FUNCTION__, l_val_1));
			}
			BCM_REFERENCE(l_val_1);
		}

		/* clear BuffReadReady int */
		bufready = SFIELD(bufready, INTSTAT_BUF_READ_READY, 1);
		sdstd_wreg16(sd, SD_IntrStatus, bufready);

		/* wait before continuing */
		/* OSL_DELAY(PER_TRY_TUNING_DELAY_MS * 1000); */ /* Not required */

		/* check execute tuning bit */
		val1 = sdstd_rreg16(sd, SD3_HostCntrl2);
		if (!GFIELD(val1, HOSTCtrl2_EXEC_TUNING)) {
			/* done tuning, break from loop */
			break;
		}

		/* max tuning iterations exceeded */
		if (lcount++ > MAX_TUNING_ITERS) {
			sd_err(("%s: TUNINGFAILED: Max tuning iterations"
				"exceeded!\n", __FUNCTION__));
			val1 = sdstd_rreg16(sd, SD3_HostCntrl2);
			val1 = SFIELD(val1, HOSTCtrl2_EXEC_TUNING, 0);
			val1 = SFIELD(val1, HOSTCtrl2_SAMPCLK_SEL, 0);
			sdstd_wreg16(sd, SD3_HostCntrl2, val1);
			return ERROR;
		}
	} while (1);

	val2 = sdstd_rreg(sd, SD3_Tuning_Info_Register);
	phase_info_local = ((val2>>15)& 0x7);
	sd_info(("Phase passed info: 0x%x\n", (val2>>8)& 0x3F));
	sd_info(("Phase selected post tune: 0x%x\n", phase_info_local));

	if (phase_info_local > SDSTD_MAX_TUNING_PHASE) {
		sd_err(("!!Phase selected:%x\n", phase_info_local));
	}

	/* check sampling clk select */
	val1 = sdstd_rreg16(sd, SD3_HostCntrl2);
	if (!GFIELD(val1, HOSTCtrl2_SAMPCLK_SEL)) {
		/* error in selecting clk */
		sd_err(("%s: TUNINGFAILED: SamplClkSel failed!\n", __FUNCTION__));
		val1 = sdstd_rreg16(sd, SD3_HostCntrl2);
		val1 = SFIELD(val1, HOSTCtrl2_EXEC_TUNING, 0);
		val1 = SFIELD(val1, HOSTCtrl2_SAMPCLK_SEL, 0);
		sdstd_wreg16(sd, SD3_HostCntrl2, val1);
		return ERROR;
	}
/* done: */
	sd_info(("%s: TUNING Success!\n", __FUNCTION__));
	return SUCCESS;
}

void
sdstd_3_enable_retuning_int(sdioh_info_t *sd)
{
	uint16 raw_int;
	unsigned long flags;

	sdstd_os_lock_irqsave(sd, &flags);
	raw_int = sdstd_rreg16(sd, SD_IntrSignalEnable);
	sdstd_wreg16(sd, SD_IntrSignalEnable, (raw_int | HC_INTR_RETUNING));
	/* Enable retuning status */
	raw_int = sdstd_rreg16(sd, SD_IntrStatusEnable);
	sdstd_wreg16(sd, SD_IntrStatusEnable, (raw_int | HC_INTR_RETUNING));
	sdstd_os_unlock_irqrestore(sd, &flags);
}

void
sdstd_3_disable_retuning_int(sdioh_info_t *sd)
{
	uint16 raw_int;
	unsigned long flags;

	sdstd_os_lock_irqsave(sd, &flags);
	sd->intmask &= ~HC_INTR_RETUNING;
	raw_int = sdstd_rreg16(sd, SD_IntrSignalEnable);
	sdstd_wreg16(sd, SD_IntrSignalEnable, (raw_int & (~HC_INTR_RETUNING)));
	/* Disable retuning status */
	raw_int = sdstd_rreg16(sd, SD_IntrStatusEnable);
	sdstd_wreg16(sd, SD_IntrStatusEnable, (raw_int & (~HC_INTR_RETUNING)));
	sdstd_os_unlock_irqrestore(sd, &flags);
}

bool
sdstd_3_is_retuning_int_set(sdioh_info_t *sd)
{
	uint16 raw_int;

	raw_int = sdstd_rreg16(sd, SD_IntrStatus);

	if (GFIELD(raw_int, INTSTAT_RETUNING_INT))
		return TRUE;

	return FALSE;
}

/*
	Assumption: sd3ClkMode is checked to be present in both host/card
	capabilities before entering this function. VALID values for sd3ClkMode
	in this function: SD3CLKMODE_2, 3, 4 [0 and 1 NOT supported as
	they are legacy] For that, need to call
	sdstd_3_get_matching_uhsi_clkmode()
*/
static int
sdstd_3_set_highspeed_uhsi_mode(sdioh_info_t *sd, int sd3ClkMode)
{
	uint32 drvstrn;
	int status;
	uint8 hc_reg8;
	uint16 val1 = 0, presetval = 0;
	uint32 regdata;

	sd3_trace(("sd3: %s:enter:clkmode:%d\n", __FUNCTION__, sd3ClkMode));

	hc_reg8 = sdstd_rreg8(sd, SD_HostCntrl);

	if (HOST_SDR_UNSUPP == sd->global_UHSI_Supp) {
		sd_err(("%s:Trying to set clk with unsupported global support\n", __FUNCTION__));
		return BCME_ERROR;
	}

	/* get [double check, as this is already done in
		sdstd_3_get_matching_uhsi_clkmode] drvstrn
	*/
	if (!sdstd_3_get_matching_drvstrn(sd, sd3ClkMode, &drvstrn, &presetval)) {
		sd_err(("%s:DRVStrn mismatch!: card strn:0x%x; HC preset"
			"val:0x%x\n", __FUNCTION__, drvstrn, presetval));
		return BCME_SDIO_ERROR;
	}

	/* also set driver type select in CCCR */
	if ((status = sdstd_card_regwrite(sd, 0, SDIOD_CCCR_DRIVER_STRENGTH,
		1, drvstrn)) != BCME_OK) {
		sd_err(("%s:Setting SDIOD_CCCR_DRIVER_STRENGTH in card Failed!\n", __FUNCTION__));
		return BCME_SDIO_ERROR;
	}

	/* ********** change Bus speed select in device */
	if ((status = sdstd_card_regread(sd, 0, SDIOD_CCCR_SPEED_CONTROL,
	                                 1, &regdata)) != SUCCESS) {
		sd_err(("%s:FAILED 1\n", __FUNCTION__));
		return BCME_SDIO_ERROR;
	}
	sd_info(("Attempting to change BSS.current val:0x%x\n", regdata));

	if (regdata & SDIO_SPEED_SHS) {
		sd_info(("Device supports High-Speed mode.\n"));
		/* clear existing BSS */
		regdata &= ~0xE;

		regdata |= (sd3ClkMode << 1);

		sd_info(("Writing %08x to Card at %08x\n",
		         regdata, SDIOD_CCCR_SPEED_CONTROL));
		if ((status = sdstd_card_regwrite(sd, 0, SDIOD_CCCR_SPEED_CONTROL,
		                                  1, regdata)) != BCME_OK) {
			sd_err(("%s:FAILED 2\n", __FUNCTION__));
			return BCME_SDIO_ERROR;
		}

		if ((status = sdstd_card_regread(sd, 0, SDIOD_CCCR_SPEED_CONTROL,
		                                 1, &regdata)) != BCME_OK) {
			sd_err(("%s:FAILED 3\n", __FUNCTION__));
			return BCME_SDIO_ERROR;
		}

		sd_info(("Read %08x from Card at %08x\n", regdata, SDIOD_CCCR_SPEED_CONTROL));
	}
	else {
		sd_err(("Device does not support High-Speed Mode.\n"));
	}

	/* SD Clock Enable = 0 */
	sdstd_wreg16(sd, SD_ClockCntrl,
		sdstd_rreg16(sd, SD_ClockCntrl) & ~((uint16)0x4));

	/* set to HighSpeed mode */
	/* TBD: is these to change SD_HostCntrl reqd for UHSI? */
	hc_reg8 = SFIELD(hc_reg8, HOST_HI_SPEED_EN, 1);
	sdstd_wreg8(sd, SD_HostCntrl, hc_reg8);

	/* set UHS Mode select in HC2 and also set preset */
	val1 = sdstd_rreg16(sd, SD3_HostCntrl2);
	val1 = SFIELD(val1, HOSTCtrl2_UHSMODE_SEL, sd3ClkMode);
	if (TRUE != sd3_sw_override1) {
		val1 = SFIELD(val1, HOSTCtrl2_PRESVAL_EN, 1);
	} else {
		/* set hC registers manually using the retreived values */
		/* *set drvstrn */
		val1 = SFIELD(val1, HOSTCtrl2_DRIVSTRENGTH_SEL,
			GFIELD(presetval, PRESET_DRIVR_SELECT));
		val1 = SFIELD(val1, HOSTCtrl2_PRESVAL_EN, 0);
	}

	/* finally write Hcontrol2 */
	sdstd_wreg16(sd, SD3_HostCntrl2, val1);

	sd_err(("%s:HostCtrl2 final value:0x%x\n", __FUNCTION__, val1));

	/* start clock : clk will be enabled inside. */
	if (FALSE == sdstd_start_clock(sd, GFIELD(presetval, PRESET_CLK_DIV))) {
		sd_err(("sdstd_start_clock failed\n"));
		return ERROR;
	}

	/* execute first tuning procedure */
	if (!sd3_sw_override1) {
		if (SD3_TUNING_REQD(sd, sd3ClkMode)) {
			sd_err(("%s: Tuning start..\n", __FUNCTION__));
			sd->sd3_tuning_reqd = TRUE;
			/* TBD: first time: enabling INT's could be problem? */
			sdstd_3_start_tuning(sd);
		}
		else
			sd->sd3_tuning_reqd = FALSE;
	}

	return BCME_OK;
}

/* Check & do tuning if required */
void sdstd_3_check_and_do_tuning(sdioh_info_t *sd, int tuning_param)
{
	int retries = 0;

	if (!sd->sd3_tuning_disable && sd->sd3_tuning_reqd) {
		sd3_trace(("sd3: %s: tuning reqd\n", __FUNCTION__));
			if (tuning_param == CHECK_TUNING_PRE_DATA) {
			if (sd->sd3_tun_state == TUNING_ONGOING) {
				retries = RETRIES_SMALL;
				/* check if tuning is already going on */
				while ((GFIELD(sdstd_rreg(sd, SD3_HostCntrl2),
					HOSTCtrl2_EXEC_TUNING)) && retries--) {
					if (retries == RETRIES_SMALL)
						sd_err(("%s: Waiting for Tuning to complete\n",
						__FUNCTION__));
				}

				if (!retries) {
					sd_err(("%s: Tuning wait timeout\n", __FUNCTION__));
					if (trap_errs)
						ASSERT(0);
				}
			} else if (sd->sd3_tun_state == TUNING_START) {
				/* check and start tuning if required. */
				sd3_trace(("sd3 : %s : Doing Tuning before Data Transfer\n",
					__FUNCTION__));
				sdstd_3_start_tuning(sd);
			}
		} else if (tuning_param == CHECK_TUNING_POST_DATA) {
			if (sd->sd3_tun_state == TUNING_START_AFTER_DAT) {
				sd3_trace(("sd3: %s: tuning start\n", __FUNCTION__));
				/* check and start tuning if required. */
				sdstd_3_start_tuning(sd);
			}
		}
	}
}
/* Need to run this function in interrupt-disabled context */
bool sdstd_3_check_and_set_retuning(sdioh_info_t *sd)
{
	sd3_trace(("sd3: %s:\n", __FUNCTION__));

	/* if already initiated, just return without anything */
	if ((sd->sd3_tun_state == TUNING_START) ||
		(sd->sd3_tun_state == TUNING_ONGOING) ||
		(sd->sd3_tun_state == TUNING_START_AFTER_DAT)) {
		/* do nothing */
		return FALSE;
	}

	if (sd->sd3_dat_state == DATA_TRANSFER_IDLE) {
		sd->sd3_tun_state = TUNING_START; /* tuning to be started by the tasklet */
		return TRUE;
	} else {
		/* tuning to be started after finishing the existing data transfer */
		sd->sd3_tun_state = TUNING_START_AFTER_DAT;
	}
	return FALSE;
}

int sdstd_3_get_data_state(sdioh_info_t *sd)
{
	return sd->sd3_dat_state;
}

void sdstd_3_set_data_state(sdioh_info_t *sd, int state)
{
	sd->sd3_dat_state = state;
}

int sdstd_3_get_tune_state(sdioh_info_t *sd)
{
	return sd->sd3_tun_state;
}

void sdstd_3_set_tune_state(sdioh_info_t *sd, int state)
{
	sd->sd3_tun_state = state;
}

uint8 sdstd_3_get_tuning_exp(sdioh_info_t *sd)
{
	if (sd_tuning_period == CAP3_RETUNING_TC_OTHER) {
		return GFIELD(sd->caps3, CAP3_RETUNING_TC);
	} else {
		return (uint8)sd_tuning_period;
	}
}

uint32 sdstd_3_get_uhsi_clkmode(sdioh_info_t *sd)
{
	return sd_uhsimode;
}

/* check, to see if the card supports driver_type corr to the driver_type
	in preset value, which will be selected by requested UHSI mode
    input:
	clk mode: valid values: SD3CLKMODE_2_SDR50, SD3CLKMODE_3_SDR104,
			SD3CLKMODE_4_DDR50, SD3CLKMODE_AUTO
    outputs:
	return_val: 	TRUE; if a matching drvstrn for the given clkmode is
		found in both HC and card. otherwise, FALSE.
		[other outputs below valid ONLY if return_val is TRUE]
	drvstrn	:      driver strength read from CCCR.
	presetval: 	value of preset reg, corr to the clkmode.
 */
static bool
sdstd_3_get_matching_drvstrn(sdioh_info_t *sd, int sd3_requested_clkmode,
	uint32 *drvstrn, uint16 *presetval)
{
	int status;
	uint8 presetreg;
	uint8 cccr_reqd_dtype_mask = 1;

	sd3_trace(("sd3: %s:\n", __FUNCTION__));

	if (sd3_requested_clkmode != SD3CLKMODE_AUTO) {
		/* CARD: get the card driver strength from cccr */
		if ((status = sdstd_card_regread(sd, 0, SDIOD_CCCR_DRIVER_STRENGTH,
			1, drvstrn)) != BCME_OK) {
			sd_err(("%s:Reading SDIOD_CCCR_DRIVER_STRENGTH from card"
				"Failed!\n", __FUNCTION__));
			return FALSE;
		}
		if (TRUE != sd3_sw_override1) {
		/* HOSTC: get the addr of preset register indexed by the clkmode */
		presetreg = SD3_PresetValStart +
			(2*sd3_requested_clkmode + 6);
		*presetval = sdstd_rreg16(sd, presetreg);
		} else {
			/* Note: +3 for mapping between SD3CLKMODE_xxx and presetval_sw_table */
			*presetval = presetval_sw_table[sd3_requested_clkmode + 3];
		}
		sd_err(("%s:reqCLK: %d, presetval: 0x%x\n",
			__FUNCTION__, sd3_requested_clkmode, *presetval));

		cccr_reqd_dtype_mask <<= GFIELD(*presetval, PRESET_DRIVR_SELECT);

		/* compare/match */
		if (!(cccr_reqd_dtype_mask & GFIELD(*drvstrn, SDIO_BUS_DRVR_TYPE_CAP))) {
			sd_err(("%s:cccr_reqd_dtype_mask and SDIO_BUS_DRVR_TYPE_CAP"
				"not matching!:reqd:0x%x, cap:0x%x\n", __FUNCTION__,
				cccr_reqd_dtype_mask, GFIELD(*drvstrn, SDIO_BUS_DRVR_TYPE_CAP)));
			return FALSE;
		} else {
			/* check if drive strength override is required. If so, first setit */
			if (*dhd_sdiod_uhsi_ds_override != DRVSTRN_IGNORE_CHAR) {
				int ds_offset = 0;
				uint32 temp = 0;

				/* drvstrn to reflect the preset val: this is default */
				*drvstrn = GFIELD(*presetval, PRESET_DRIVR_SELECT);

				/* now check override */
				ds_offset = (((int)DRVSTRN_MAX_CHAR -
					(int)(*dhd_sdiod_uhsi_ds_override)));
				if ((ds_offset >= 0) && (ds_offset <= MAX_DTS_INDEX)) {
					ds_offset = MAX_DTS_INDEX - ds_offset;
					sd_err(("%s:Drive strength override: %c, offset: "
						"%d, val: %d\n", __FUNCTION__,
						*dhd_sdiod_uhsi_ds_override,
						ds_offset, DTS_vals[ds_offset]));
					temp = SFIELD(*drvstrn, SDIO_BUS_DRVR_TYPE_SEL,
						DTS_vals[ds_offset]);
					sd_err(("%s:DrvStrn orig: 0x%x, modif: 0x%x\n",
						__FUNCTION__, *drvstrn, temp));
					*drvstrn = temp;
				} else {
					/* else case is default: use preset val */
					sd_err(("%s:override invalid: DrvStrn is from "
						"preset: 0x%x\n",
						__FUNCTION__, *drvstrn));
				}
			} else {
				sd_err(("%s:DrvStrn is from preset: 0x%x\n",
					__FUNCTION__, *drvstrn));
			}
		}
	} else {
		/* TBD check for sd3_requested_clkmode : -1 also.  */
		sd_err(("%s: Automode not supported!\n", __FUNCTION__));
		return FALSE;
	}
	return TRUE;
}

/* Returns a matching UHSI clk speed is found. If not, returns -1.
	Also, if  sd3_requested_clkmode is -1, finds the closest max match clk and returns.
 */
static int
sdstd_3_get_matching_uhsi_clkmode(sdioh_info_t *sd, int sd3_requested_clkmode)
{
	uint32 card_val_uhsisupp;
	uint8 speedmask = 1;
	uint32 drvstrn;
	uint16 presetval;
	int status;

	sd3_trace(("sd3: %s:\n", __FUNCTION__));

	sd->global_UHSI_Supp = HOST_SDR_UNSUPP;

	/* for legacy/25MHz/50MHz bus speeds, no checks done here */
	if ((sd3_requested_clkmode == SD3CLKMODE_0_SDR12) ||
		(sd3_requested_clkmode == SD3CLKMODE_1_SDR25)) {
		sd->global_UHSI_Supp = HOST_SDR_12_25;
		return sd3_requested_clkmode;
	}
	/* get cap of card */
	if ((status = sdstd_card_regread(sd, 0, SDIOD_CCCR_UHSI_SUPPORT,
	                                 1, &card_val_uhsisupp)) != BCME_OK) {
		sd_err(("%s:SDIOD_CCCR_UHSI_SUPPORT query failed!\n", __FUNCTION__));
		return -1;
	}
	sd_info(("%s:Read %08x from Card at %08x\n", __FUNCTION__,
		card_val_uhsisupp, SDIOD_CCCR_UHSI_SUPPORT));

	if (sd3_requested_clkmode != SD3CLKMODE_AUTO) {
		/* Note: it is assumed that, following are executed when (sd3ClkMode >= 2) */
		speedmask <<= (sd3_requested_clkmode - SD3CLKMODE_2_SDR50);

		/* check first about 3.0 HS CLK modes */
		if (!(GFIELD(sd->caps3, CAP3_30CLKCAP) & speedmask)) {
			sd_err(("%s:HC does not support req 3.0 UHSI mode."
				"requested:%d; capable:0x%x\n", __FUNCTION__,
				sd3_requested_clkmode, GFIELD(sd->caps3, CAP3_30CLKCAP)));
			return -1;
		}

		/* check first about 3.0 CARD CLK modes */
		if (!(GFIELD(card_val_uhsisupp, SDIO_BUS_SPEED_UHSICAP) & speedmask)) {
			sd_err(("%s:Card does not support req 3.0 UHSI mode. requested:%d;"
				"capable:0x%x\n", __FUNCTION__, sd3_requested_clkmode,
				GFIELD(card_val_uhsisupp, SDIO_BUS_SPEED_UHSICAP)));
			return -1;
		}

		/* check, to see if the card supports driver_type corr to the
			driver_type in preset value, which will be selected by
			requested UHSI mode
		*/
		if (!sdstd_3_get_matching_drvstrn(sd, sd3_requested_clkmode,
			&drvstrn, &presetval)) {
			sd_err(("%s:DRVStrn mismatch!: card strn:0x%x; HC preset"
				"val:0x%x\n", __FUNCTION__, drvstrn, presetval));
			return -1;
		}
		/* success path. change the support variable accordingly */
		sd->global_UHSI_Supp = HOST_SDR_50_104_DDR;
		return sd3_requested_clkmode;
	} else {
		/* auto clk selection: get the highest clock capable by both card and HC */
/* TBD		TOBE DONE */
/* 		sd->global_UHSI_Supp = TRUE; on success */
		return -1;
	}
}

static int
sdstd_3_sigvoltswitch_proc(sdioh_info_t *sd)
{
	int status;
	uint32 cmd_rsp = 0, presst;
	uint16 val1 = 0;

	sd3_trace(("sd3: %s:\n", __FUNCTION__));

	/* Issue cmd11 */
	if ((status = sdstd_cmd_issue(sd, USE_DMA(sd), SDIOH_CMD_11, 0))
		!= SUCCESS) {
		sd_err(("%s: CMD11 failed\n", __FUNCTION__));
		return status;
	}

	/* check response */
	sdstd_cmd_getrsp(sd, &cmd_rsp, 1);
	if (
		GFIELD(cmd_rsp, RSP1_ERROR) ||	/*  bit 19 */
		GFIELD(cmd_rsp, RSP1_ILLEGAL_CMD) ||	/*  bit 22 */
		GFIELD(cmd_rsp, RSP1_COM_CRC_ERROR) ||	/*  bit 23 */
		GFIELD(cmd_rsp, RSP1_CARD_LOCKED)	/*  bit 25 */	) {
		sd_err(("%s: FAIL:CMD11: cmd_resp:0x%x\n", __FUNCTION__, cmd_rsp));
		return ERROR;
	}

	/* SD Clock Enable = 0 */
	sdstd_wreg16(sd, SD_ClockCntrl,
	             sdstd_rreg16(sd, SD_ClockCntrl) & ~((uint16)0x4));

	/* check DAT[3..0] using Present State Reg. If not 0, error */
	presst = sdstd_rreg(sd, SD_PresentState);
	if (0 != GFIELD(presst, PRES_DAT_SIGNAL)) {
		sd_err(("%s: FAIL: PRESTT:0x%x\n", __FUNCTION__, presst));
		return ERROR;
	}

	/* turn 1.8V sig enable in HC2 */
	val1 = sdstd_rreg16(sd, SD3_HostCntrl2);
	val1 = SFIELD(val1, HOSTCtrl2_1_8SIG_EN, 1);
	sdstd_wreg16(sd, SD3_HostCntrl2, val1);

	/* wait 5ms */
	OSL_DELAY(5000);

	/* check 1.8V sig enable in HC2. if cleared, error */
	val1 = sdstd_rreg16(sd, SD3_HostCntrl2);

	if (!GFIELD(val1, HOSTCtrl2_1_8SIG_EN)) {
		sd_err(("%s: FAIL: HC2:1.8V_En:0x%x\n", __FUNCTION__, val1));
		return ERROR;
	}

	/* SD Clock Enable = 1 */
	val1 = sdstd_rreg16(sd, SD_ClockCntrl);
	sdstd_wreg16(sd, SD_ClockCntrl, val1 | 0x4);

	/* wait 1ms */
	OSL_DELAY(1000);

	/* check DAT[3..0] using Present State Reg. If not 0b1111, error */
	presst = sdstd_rreg(sd, SD_PresentState);
	if (0xf != GFIELD(presst, PRES_DAT_SIGNAL)) {
		sd_err(("%s: FAIL: PRESTT_FINAL:0x%x\n", __FUNCTION__, presst));
		return ERROR;
	}

	return (SUCCESS);
}

static int
sdstd_set_highspeed_mode(sdioh_info_t *sd, bool HSMode)
{
	uint32 regdata;
	int status;
	uint8 reg8;

	uint32 drvstrn;

	reg8 = sdstd_rreg8(sd, SD_HostCntrl);

#ifdef BCMINTERNAL
	/* The Jinvani SD Gold Host forces the highest clock rate in high-speed mode */
	/* Only enable high-speed mode if the SD clock divisor is 1. */
	if (sd->controller_type == SDIOH_TYPE_JINVANI_GOLD) {
		if (sd_divisor != 1) {
			HSMode = FALSE;
		}
	}
#endif /* BCMINTERNAL */

	if (HSMode == TRUE) {
		if (sd_hiok && (GFIELD(sd->caps, CAP_HIGHSPEED)) == 0) {
			sd_err(("Host Controller does not support hi-speed mode.\n"));
			return BCME_ERROR;
		}

		sd_info(("Attempting to enable High-Speed mode.\n"));

		if ((status = sdstd_card_regread(sd, 0, SDIOD_CCCR_SPEED_CONTROL,
		                                 1, &regdata)) != SUCCESS) {
			return BCME_SDIO_ERROR;
		}
		if (regdata & SDIO_SPEED_SHS) {
			sd_info(("Device supports High-Speed mode.\n"));

			regdata |= SDIO_SPEED_EHS;

			sd_info(("Writing %08x to Card at %08x\n",
			         regdata, SDIOD_CCCR_SPEED_CONTROL));
			if ((status = sdstd_card_regwrite(sd, 0, SDIOD_CCCR_SPEED_CONTROL,
			                                  1, regdata)) != BCME_OK) {
				return BCME_SDIO_ERROR;
			}

			if ((status = sdstd_card_regread(sd, 0, SDIOD_CCCR_SPEED_CONTROL,
			                                 1, &regdata)) != BCME_OK) {
				return BCME_SDIO_ERROR;
			}

			sd_info(("Read %08x to Card at %08x\n", regdata, SDIOD_CCCR_SPEED_CONTROL));

			reg8 = SFIELD(reg8, HOST_HI_SPEED_EN, 1);

			sd_err(("High-speed clocking mode enabled.\n"));
		}
		else {
			sd_err(("Device does not support High-Speed Mode.\n"));
			reg8 = SFIELD(reg8, HOST_HI_SPEED_EN, 0);
		}
	} else {
		/* Force off device bit */
		if ((status = sdstd_card_regread(sd, 0, SDIOD_CCCR_SPEED_CONTROL,
		                                 1, &regdata)) != BCME_OK) {
			return status;
		}
		if (regdata & SDIO_SPEED_EHS) {
			regdata &= ~SDIO_SPEED_EHS;
			if ((status = sdstd_card_regwrite(sd, 0, SDIOD_CCCR_SPEED_CONTROL,
			                                  1, regdata)) != BCME_OK) {
				return status;
			}
		}

		sd_err(("High-speed clocking mode disabled.\n"));
		reg8 = SFIELD(reg8, HOST_HI_SPEED_EN, 0);
	}

	if ((sd->host_UHSISupported) && (sd->card_UHSI_voltage_Supported)) {
		/* also set the default driver strength in the card/HC [this is reqd because,
			if earlier we selected any other drv_strn, we need to reset it]
		*/
		/* get the card driver strength from cccr */
		if ((status = sdstd_card_regread(sd, 0, SDIOD_CCCR_DRIVER_STRENGTH,
			1, &drvstrn)) != BCME_OK) {
			sd_err(("%s:Reading SDIOD_CCCR_DRIVER_STRENGTH from card"
				"Failed!\n", __FUNCTION__));
			return BCME_SDIO_ERROR;
		}

		/* reset card drv strn */
		drvstrn = SFIELD(drvstrn, SDIO_BUS_DRVR_TYPE_SEL, 0);

		/* set card drv strn */
		if ((status = sdstd_card_regwrite(sd, 0, SDIOD_CCCR_DRIVER_STRENGTH,
			1, drvstrn)) != BCME_OK) {
			sd_err(("%s:Setting SDIOD_CCCR_DRIVER_STRENGTH in"
				"card Failed!\n", __FUNCTION__));
			return BCME_SDIO_ERROR;
		}
	}

	sdstd_wreg8(sd, SD_HostCntrl, reg8);

	return BCME_OK;
}

/* Select DMA Mode:
 * If dma_mode == DMA_MODE_AUTO, pick the "best" mode.
 * Otherwise, pick the selected mode if supported.
 * If not supported, use PIO mode.
 */
static int
sdstd_set_dma_mode(sdioh_info_t *sd, int8 dma_mode)
{
	uint8 reg8, dma_sel_bits = SDIOH_SDMA_MODE;
	int8 prev_dma_mode = sd->sd_dma_mode;

	switch (prev_dma_mode) {
		case DMA_MODE_AUTO:
			sd_dma(("%s: Selecting best DMA mode supported by controller.\n",
			          __FUNCTION__));
			if (GFIELD(sd->caps, CAP_ADMA2)) {
				sd->sd_dma_mode = DMA_MODE_ADMA2;
				dma_sel_bits = SDIOH_ADMA2_MODE;
			} else if (GFIELD(sd->caps, CAP_ADMA1)) {
				sd->sd_dma_mode = DMA_MODE_ADMA1;
				dma_sel_bits = SDIOH_ADMA1_MODE;
			} else if (GFIELD(sd->caps, CAP_DMA)) {
				sd->sd_dma_mode = DMA_MODE_SDMA;
			} else {
				sd->sd_dma_mode = DMA_MODE_NONE;
			}
			break;
		case DMA_MODE_NONE:
			sd->sd_dma_mode = DMA_MODE_NONE;
			break;
		case DMA_MODE_SDMA:
			if (GFIELD(sd->caps, CAP_DMA)) {
				sd->sd_dma_mode = DMA_MODE_SDMA;
			} else {
				sd_err(("%s: SDMA not supported by controller.\n", __FUNCTION__));
				sd->sd_dma_mode = DMA_MODE_NONE;
			}
			break;
		case DMA_MODE_ADMA1:
			if (GFIELD(sd->caps, CAP_ADMA1)) {
				sd->sd_dma_mode = DMA_MODE_ADMA1;
				dma_sel_bits = SDIOH_ADMA1_MODE;
			} else {
				sd_err(("%s: ADMA1 not supported by controller.\n", __FUNCTION__));
				sd->sd_dma_mode = DMA_MODE_NONE;
			}
			break;
		case DMA_MODE_ADMA2:
			if (GFIELD(sd->caps, CAP_ADMA2)) {
				sd->sd_dma_mode = DMA_MODE_ADMA2;
				dma_sel_bits = SDIOH_ADMA2_MODE;
			} else {
				sd_err(("%s: ADMA2 not supported by controller.\n", __FUNCTION__));
				sd->sd_dma_mode = DMA_MODE_NONE;
			}
			break;
		case DMA_MODE_ADMA2_64:
			sd_err(("%s: 64b ADMA2 not supported by driver.\n", __FUNCTION__));
			sd->sd_dma_mode = DMA_MODE_NONE;
			break;
		default:
			sd_err(("%s: Unsupported DMA Mode %d requested.\n", __FUNCTION__,
			        prev_dma_mode));
			sd->sd_dma_mode = DMA_MODE_NONE;
			break;
	}

	/* clear SysAddr, only used for SDMA */
	sdstd_wreg(sd, SD_SysAddr, 0);

	sd_err(("%s: %s mode selected.\n", __FUNCTION__, dma_mode_description[sd->sd_dma_mode]));

	reg8 = sdstd_rreg8(sd, SD_HostCntrl);
	reg8 = SFIELD(reg8, HOST_DMA_SEL, dma_sel_bits);
	sdstd_wreg8(sd, SD_HostCntrl, reg8);
	sd_dma(("%s: SD_HostCntrl=0x%02x\n", __FUNCTION__, reg8));

	return BCME_OK;
}

#ifdef BCMDBG
void
print_regs(sdioh_info_t *sd)
{
	uint8 reg8 = 0;
	uint16 reg16 = 0;
	uint32 reg32 = 0;
	uint8 presetreg;
	int i;

	reg8 = sdstd_rreg8(sd, SD_BlockSize);
	printf("REGS: SD_BlockSize [004h]:0x%x\n", reg8);

	reg8 = sdstd_rreg8(sd, SD_BlockCount);
	printf("REGS: SD_BlockCount [006h]:0x%x\n", reg8);

	reg8 = sdstd_rreg8(sd, SD_BlockSize);
	printf("REGS: SD_BlockSize [004h]:0x%x\n", reg8);

	reg8 = sdstd_rreg8(sd, SD_TransferMode);
	printf("REGS: SD_TransferMode [00Ch]:0x%x\n", reg8);

	reg8 = sdstd_rreg8(sd, SD_HostCntrl);
	printf("REGS: SD_HostCntrl [028h]:0x%x\n", reg8);

	reg32 = sdstd_rreg(sd, SD_PresentState);
	printf("REGS: SD_PresentState [024h]:0x%x\n", reg32);

	reg8 = sdstd_rreg8(sd, SD_PwrCntrl);
	printf("REGS: SD_PwrCntrl [029h]:0x%x\n", reg8);

	reg8 = sdstd_rreg8(sd, SD_BlockGapCntrl);
	printf("REGS: SD_BlockGapCntrl [02Ah]:0x%x\n", reg8);

	reg8 = sdstd_rreg8(sd, SD_WakeupCntrl);
	printf("REGS: SD_WakeupCntrl [02Bh]:0x%x\n", reg8);

	reg16 = sdstd_rreg16(sd, SD_ClockCntrl);
	printf("REGS: SD_ClockCntrl [02Ch]:0x%x\n", reg16);

	reg8 = sdstd_rreg8(sd, SD_TimeoutCntrl);
	printf("REGS: SD_TimeoutCntrl [02Eh]:0x%x\n", reg8);

	reg8 = sdstd_rreg8(sd, SD_SoftwareReset);
	printf("REGS: SD_SoftwareReset [02Fh]:0x%x\n", reg8);

	reg16 = sdstd_rreg16(sd, SD_IntrStatus);
	printf("REGS: SD_IntrStatus [030h]:0x%x\n", reg16);

	reg16 = sdstd_rreg16(sd, SD_ErrorIntrStatus);
	printf("REGS: SD_ErrorIntrStatus [032h]:0x%x\n", reg16);

	reg16 = sdstd_rreg16(sd, SD_IntrStatusEnable);
	printf("REGS: SD_IntrStatusEnable [034h]:0x%x\n", reg16);

	reg16 = sdstd_rreg16(sd, SD_ErrorIntrStatusEnable);
	printf("REGS: SD_ErrorIntrStatusEnable [036h]:0x%x\n", reg16);

	reg16 = sdstd_rreg16(sd, SD_IntrSignalEnable);
	printf("REGS: SD_IntrSignalEnable [038h]:0x%x\n", reg16);

	reg16 = sdstd_rreg16(sd, SD_ErrorIntrSignalEnable);
	printf("REGS: SD_ErrorIntrSignalEnable [03Ah]:0x%x\n", reg16);

	reg32 = sdstd_rreg(sd, SD_Capabilities);
	printf("REGS: SD_Capabilities [040h]:0x%x\n", reg32);

	reg32 = sdstd_rreg(sd, SD_MaxCurCap);
	printf("REGS: SD_MaxCurCap [04Ah]:0x%x\n", reg32);

	reg32 = sdstd_rreg(sd, SD_Capabilities3);
	printf("REGS: SD_Capabilities3 [044h]:0x%x\n", reg32);

	reg16 = sdstd_rreg16(sd, SD3_HostCntrl2);
	printf("REGS: SD3_HostCntrl2 [03Eh]:0x%x\n", reg16);

	for (i = 0; i < 8; i++) {
		presetreg = SD3_PresetValStart + i*2;
		printf("REGS: Presetvalreg:ix[%d]:0x%x, val=0x%x\n", i,
		       presetreg, sdstd_rreg16(sd, presetreg));
	}

	reg16 = sdstd_rreg16(sd, SD_SlotInterruptStatus);
	printf("REGS: SD_SlotInterruptStatus [0FCh]:0x%x\n", reg16);

	reg16 = sdstd_rreg16(sd, SD_HostControllerVersion);
	printf("REGS: SD_HostControllerVersion [0FEh]:0x%x\n", reg16);
}
#endif /* BCMDBG */

#ifdef BCMINTERNAL
#ifdef NOTUSED
static int
parse_state(uint32 state, char *buf, int len)
{
	char *data = buf;

	sd_err(("Parsing state 0x%x\n", state));
	if (!len) {
		return (0);
	}

	data += sprintf(data, "cmd_inhibit      %d\n", GFIELD(state, PRES_CMD_INHIBIT));
	data += sprintf(data, "dat_inhibit      %d\n", GFIELD(state, PRES_DAT_INHIBIT));
	data += sprintf(data, "dat_busy	        %d\n", GFIELD(state, PRES_DAT_BUSY));
	data += sprintf(data, "write_active     %d\n", GFIELD(state, PRES_WRITE_ACTIVE));
	data += sprintf(data, "read_active      %d\n", GFIELD(state, PRES_READ_ACTIVE));
	data += sprintf(data, "write_data_rdy   %d\n", GFIELD(state, PRES_WRITE_DATA_RDY));
	data += sprintf(data, "read_data_rdy    %d\n", GFIELD(state, PRES_READ_DATA_RDY));
	data += sprintf(data, "card_present     %d\n", GFIELD(state, PRES_CARD_PRESENT));
	data += sprintf(data, "card_stable      %d\n", GFIELD(state, PRES_CARD_STABLE));
	data += sprintf(data, "card_present_raw %d\n", GFIELD(state, PRES_CARD_PRESENT_RAW));
	data += sprintf(data, "write_enabled    %d\n", GFIELD(state, PRES_WRITE_ENABLED));
	data += sprintf(data, "cmd_signal       %d\n", GFIELD(state, PRES_CMD_SIGNAL));

	return (data - buf);
}

static int
parse_caps(uint32 cap, char *buf, int len)
{
	int block = 0xbeef;
	char *data = buf;

	data += sprintf(data, "TimeOut Clock Freq:\t%d\n", GFIELD(cap, CAP_TO_CLKFREQ));
	data += sprintf(data, "TimeOut Clock Unit:\t%d\n", GFIELD(cap, CAP_TO_CLKUNIT));
	data += sprintf(data, "Base Clock:\t\t%d\n", GFIELD(cap, CAP_BASECLK));
	switch (GFIELD(cap, CAP_MAXBLOCK)) {
	case 0: block = 512; break;
	case 1: block = 1024; break;
	case 2: block = 2048; break;
	case 3: block = 0; break;
	}
	data += sprintf(data, "Max Block Size:\t\t%d\n", block);
	data += sprintf(data, "Support High Speed:\t%d\n", GFIELD(cap, CAP_HIGHSPEED));
	data += sprintf(data, "Support DMA:\t\t%d\n", GFIELD(cap, CAP_DMA));
	data += sprintf(data, "Support Suspend:\t%d\n", GFIELD(cap, CAP_SUSPEND));
	data += sprintf(data, "Support 3.3 Volts:\t%d\n", GFIELD(cap, CAP_VOLT_3_3));
	data += sprintf(data, "Support 3.0 Volts:\t%d\n", GFIELD(cap, CAP_VOLT_3_0));
	data += sprintf(data, "Support 1.8 Volts:\t%d\n", GFIELD(cap, CAP_VOLT_1_8));
	return (data - buf);
}
#endif /* NOTUSED */
#endif /* BCMINTERNAL */

/* XXX Per SDIO Host Controller Spec section 3.2.1
	Note: for 2.x HC, new_sd_divisor should be a power of 2, but for 3.0
	HC, new_sd_divisor should be a multiple of 2.
*/
bool
sdstd_start_clock(sdioh_info_t *sd, uint16 new_sd_divisor)
{
	uint rc, count;
	uint16 divisor;
	uint16 regdata;
	uint16 val1;

	sd3_trace(("%s: starting clk\n", __FUNCTION__));
	/* turn off HC clock */
	sdstd_wreg16(sd, SD_ClockCntrl,
	             sdstd_rreg16(sd, SD_ClockCntrl) & ~((uint16)0x4)); /*  Disable the HC clock */

	/* Set divisor */
	if (sd->host_UHSISupported) {
#ifdef BCMDBG
		if ((new_sd_divisor != 1) &&		/* 1 is a valid value */
		    ((new_sd_divisor & (0x1)) ||	/* check for multiple of 2 */
		     (new_sd_divisor == 0) ||
		     (new_sd_divisor > 0x3ff))) {
			sd_err(("3.0: Invalid clock divisor target: %d\n", new_sd_divisor));
			return FALSE;
		}
#endif
		divisor = (new_sd_divisor >> 1);
	} else
	{
#ifdef BCMDBG
		if ((new_sd_divisor & (new_sd_divisor-1)) ||
		    (new_sd_divisor == 0)) {
			sd_err(("Invalid clock divisor target: %d\n", new_sd_divisor));
			return FALSE;
		}
#endif
		/* new logic: if divisor > 256, restrict to 256 */
		if (new_sd_divisor > 256)
			new_sd_divisor = 256;
		divisor = (new_sd_divisor >> 1) << 8;
	}
#ifdef BCMINTERNAL
	if (sd->controller_type == SDIOH_TYPE_JINVANI_GOLD) {
		divisor = (new_sd_divisor >> 2) << 8;
	}
#endif /* BCMINTERNAL */

	sd_info(("Clock control is 0x%x\n", sdstd_rreg16(sd, SD_ClockCntrl)));
	if (sd->host_UHSISupported) {
		/* *get preset value and shift so that.
		*	bits 0-7 are in 15-8 and 9-8 are in 7-6 of clkctrl
		*/
		val1 = divisor << 2;
		val1 &= 0x0ffc;
		val1 |= divisor >> 8;
		val1 <<= 6;
		printf("divisor:%x;val1:%x\n", divisor, val1);
		sdstd_mod_reg16(sd, SD_ClockCntrl, 0xffC0, val1);
	} else
	{
		sdstd_mod_reg16(sd, SD_ClockCntrl, 0xff00, divisor);
	}

	sd_err(("%s: Using clock divisor of %d (regval 0x%04x)\n", __FUNCTION__,
	         new_sd_divisor, divisor));
	if (new_sd_divisor > 0)
		sd_err(("%s:now, divided clk is: %d Hz\n",
		  __FUNCTION__, GFIELD(sd->caps, CAP_BASECLK)*1000000/new_sd_divisor));
	else
		sd_err(("Using Primary Clock Freq of %d MHz\n", GFIELD(sd->caps, CAP_BASECLK)));
	sd_info(("Primary Clock Freq = %d MHz\n", GFIELD(sd->caps, CAP_BASECLK)));
	if (GFIELD(sd->caps, CAP_TO_CLKFREQ) == 50) {
		sd_info(("%s: Resulting SDIO clock is %d %s\n", __FUNCTION__,
		        ((50 % new_sd_divisor) ? (50000 / new_sd_divisor) : (50 / new_sd_divisor)),
		        ((50 % new_sd_divisor) ? "KHz" : "MHz")));
	} else if (GFIELD(sd->caps, CAP_TO_CLKFREQ) == 48) {
		sd_info(("%s: Resulting SDIO clock is %d %s\n", __FUNCTION__,
		        ((48 % new_sd_divisor) ? (48000 / new_sd_divisor) : (48 / new_sd_divisor)),
		        ((48 % new_sd_divisor) ? "KHz" : "MHz")));
	} else if (GFIELD(sd->caps, CAP_TO_CLKFREQ) == 33) {
		sd_info(("%s: Resulting SDIO clock is %d %s\n", __FUNCTION__,
		        ((33 % new_sd_divisor) ? (33000 / new_sd_divisor) : (33 / new_sd_divisor)),
		        ((33 % new_sd_divisor) ? "KHz" : "MHz")));
	} else if (GFIELD(sd->caps, CAP_TO_CLKFREQ) == 31) {
		sd_info(("%s: Resulting SDIO clock is %d %s\n", __FUNCTION__,
		        ((31 % new_sd_divisor) ? (31000 / new_sd_divisor) : (31 / new_sd_divisor)),
		        ((31 % new_sd_divisor) ? "KHz" : "MHz")));
	} else if (GFIELD(sd->caps, CAP_TO_CLKFREQ) == 8) {
		sd_info(("%s: Resulting SDIO clock is %d %s\n", __FUNCTION__,
		        ((8 % new_sd_divisor) ? (8000 / new_sd_divisor) : (8 / new_sd_divisor)),
		        ((8 % new_sd_divisor) ? "KHz" : "MHz")));
	} else if (sd->controller_type == SDIOH_TYPE_BCM27XX) {
		/* XXX - BCM 27XX Standard Host Controller returns 0 for CLKFREQ */
	} else {
		sd_err(("Need to determine divisor for %d MHz clocks\n",
		        GFIELD(sd->caps, CAP_BASECLK)));
		sd_err(("Consult SD Host Controller Spec: Clock Control Register\n"));
		return (FALSE);
	}

	sdstd_or_reg16(sd, SD_ClockCntrl, 0x1); /*  Enable the clock */

	/* Wait for clock to stabilize */
	rc = (sdstd_rreg16(sd, SD_ClockCntrl) & 2);
	count = 0;
	while (!rc) {
		OSL_DELAY(1);
		sd_info(("Waiting for clock to become stable 0x%x\n", rc));
		rc = (sdstd_rreg16(sd, SD_ClockCntrl) & 2);
		count++;
		if (count > 10000) {
			sd_err(("%s:Clocks failed to stabilize after %u attempts\n",
			        __FUNCTION__, count));
			return (FALSE);
		}
	}
	/* Turn on clock */
	sdstd_or_reg16(sd, SD_ClockCntrl, 0x4);

	OSL_DELAY(20);

	/* Set timeout control (adjust default value based on divisor).
	 * Disabling timeout interrupts during setting is advised by host spec.
	 */
#ifdef BCMQT
	if (GFIELD(sd->caps, CAP_BASECLK) < 50)
#endif
	{
		uint toval;

		toval = sd_toctl;
		divisor = new_sd_divisor;

		while (toval && !(divisor & 1)) {
			toval -= 1;
			divisor >>= 1;
		}

		regdata = sdstd_rreg16(sd, SD_ErrorIntrStatusEnable);
		sdstd_wreg16(sd, SD_ErrorIntrStatusEnable, (regdata & ~ERRINT_DATA_TIMEOUT_BIT));
		sdstd_wreg8(sd, SD_TimeoutCntrl, (uint8)toval);
		sdstd_wreg16(sd, SD_ErrorIntrStatusEnable, regdata);
	}
#ifdef BCMQT
	else {
		sd_info(("%s: REsetting err int control\n", __FUNCTION__));
		/* XXX: turn off timeout INT, it resets clk ctrl bit */
		regdata = sdstd_rreg16(sd, SD_ErrorIntrStatusEnable);
		sdstd_wreg16(sd, SD_ErrorIntrStatusEnable, (regdata & ~ERRINT_DATA_TIMEOUT_BIT));
	}
#endif
	OSL_DELAY(2);

	sd_info(("Final Clock control is 0x%x\n", sdstd_rreg16(sd, SD_ClockCntrl)));

	return TRUE;
}

/* XXX Per SDIO Host Controller Spec 3.3
 * volts_req:
 *		0 means default: select highest voltage.
 *		1 means 1.8V
 *		2 means 3.0V
 *		3 means 3.3V
 * returns
 *	TRUE: no error
 *	FALSE: general error
 *	SDIO_OCR_READ_FAIL: ocr reading failure. Now the HC has to try in other available voltages.
*/
uint16
sdstd_start_power(sdioh_info_t *sd, int volts_req)
{
	char *s;
	uint32 cmd_arg;
	uint32 cmd_rsp;
	uint8 pwr = 0;
	int volts = 0;
	uint16 val1;
	uint16 init_divider = 0;
	uint8 baseclk = 0;
	bool selhighest = (volts_req == 0) ? TRUE : FALSE;

	/* reset the card uhsi volt support to false */
	sd->card_UHSI_voltage_Supported = FALSE;

	/* Ensure a power on reset by turning off bus power in case it happened to
	 * be on already. (This might happen if driver doesn't unload/clean up correctly,
	 * crash, etc.)  Leave off for 100ms to make sure the power off isn't
	 * ignored/filtered by the device.  Note we can't skip this step if the power is
	 * off already since we don't know how long it has been off before starting
	 * the driver.
	 */
	sdstd_wreg8(sd, SD_PwrCntrl, 0);
	sd_info(("Turning off VDD/bus power briefly (100ms) to ensure reset\n"));
	OSL_DELAY(100000);

	/* For selecting highest available voltage, start from lowest and iterate */
	if (!volts_req)
		volts_req = 1;

	s = NULL;

	if (volts_req == 1) {
		if (GFIELD(sd->caps, CAP_VOLT_1_8)) {
			volts = 5;
			s = "1.8";
			if (FALSE == selhighest)
				goto voltsel;
			else
				volts_req++;
		} else {
			sd_err(("HC doesn't support voltage! trying higher voltage: %d\n", volts));
			volts_req++;
		}
	}

	if (volts_req == 2) {
		if (GFIELD(sd->caps, CAP_VOLT_3_0)) {
			volts = 6;
			s = "3.0";
			if (FALSE == selhighest)
				goto voltsel;
			else volts_req++;
		} else {
			sd_err(("HC doesn't support voltage! trying higher voltage: %d\n", volts));
			volts_req++;
		}
	}

	if (volts_req == 3) {
		if (GFIELD(sd->caps, CAP_VOLT_3_3)) {
			volts = 7;
			s = "3.3";
		} else {
			if ((FALSE == selhighest) || (volts == 0)) {
				sd_err(("HC doesn't support any voltage! error!\n"));
				return FALSE;
			}
		}
	}

	/* XXX
	 * if UHSI is NOT supported, check for other voltages also. This is a safety measure
	 * for embedded devices also, so that HC starts in lower power first. If this
	 * function fails, the caller may disable UHSISupported
	 * and call start power again to check support in higher voltages.
	 */

voltsel:
	pwr = SFIELD(pwr, PWR_VOLTS, volts);
	pwr = SFIELD(pwr, PWR_BUS_EN, 1);
	sdstd_wreg8(sd, SD_PwrCntrl, pwr); /* Set Voltage level */
	sd_info(("Setting Bus Power to %s Volts\n", s));
	BCM_REFERENCE(s);

	/*
	 * PR101766 : BRCM SDIO3.0 card is an embedded SD device. It is not a SD card.
	 * VDDIO signalling will be tied to 1.8v level on all SDIO3.0 based boards.
	 * So program the HC to drive VDDIO at 1.8v level.
	 */
	if ((sd->version == HOST_CONTR_VER_3) && (volts == 5)) {
		val1 = sdstd_rreg16(sd, SD3_HostCntrl2);
		val1 = SFIELD(val1, HOSTCtrl2_1_8SIG_EN, 1);
		sdstd_wreg16(sd, SD3_HostCntrl2, val1);
	}

	/* Wait for 500ms for power to stabilize.  Some designs have reset IC's
	 * which can hold reset low for close to 300ms.  In addition there can
	 * be ramp time for VDD and/or VDDIO which might be provided from a LDO.
	 * For these reasons we need a pretty conservative delay here to have
	 * predictable reset behavior in the face of an unknown design.
	 */
	OSL_DELAY(500000);

	baseclk = GFIELD(sd->caps, CAP_BASECLK);
	sd_info(("%s:baseclk: %d MHz\n",	__FUNCTION__, baseclk));
	/* for 3.0, find divisor */
	if (sd->host_UHSISupported) {
		/* ToDo : Dynamic modification of preset value table based on base clk */
		sd3_trace(("sd3: %s: checking divisor\n", __FUNCTION__));
		if (GFIELD(sd->caps3, CAP3_CLK_MULT) != 0)	{
			sd_err(("%s:Possible error: CLK Mul 1 CLOCKING NOT supported!\n",
				__FUNCTION__));
			return FALSE;
		} else {
			/*  calculate dividor, which leads to 400KHz.  */
			init_divider = baseclk*10/4; /* baseclk*1000000/(400000); */
			/* make it a multiple of 2. */
			init_divider += (init_divider & 0x1);
			sd_err(("%s:divider used for init:%d\n",
				__FUNCTION__, init_divider));
		}
	} else {
		/* Note: sd_divisor assumes that SDIO Base CLK is 50MHz. */
		int final_freq_based_on_div = 50/sd_divisor;
	    if (baseclk > 50)
			sd_divisor = baseclk/final_freq_based_on_div;
		/* TBD: merge both SDIO 2.0 and 3.0 to share same divider logic */
		init_divider = baseclk*10/4; /* baseclk*1000000/(400000); */
		/* find next power of 2 */
		NEXT_POW2(init_divider);
		sd_err(("%s:NONUHSI: divider used for init:%d\n",
			__FUNCTION__, init_divider));
	}

	/* Start at ~400KHz clock rate for initialization */
	if (!sdstd_start_clock(sd, init_divider)) {
		sd_err(("%s: sdstd_start_clock failed\n", __FUNCTION__));
		return FALSE;
	}

	/* Get the Card's Operation Condition.  Occasionally the board
	 * takes a while to become ready
	 */
	cmd_arg = 0;
	cmd_rsp = 0;
	if (get_ocr(sd, &cmd_arg, &cmd_rsp) != SUCCESS) {
		sd_err(("%s: Failed to get OCR bailing\n", __FUNCTION__));
		/* No need to reset as not sure in what state the card is. */
		return SDIO_OCR_READ_FAIL;
	}

	sd_info(("cmd_rsp = 0x%x\n", cmd_rsp));
	sd_info(("mem_present = %d\n", GFIELD(cmd_rsp, RSP4_MEM_PRESENT)));
	sd_info(("num_funcs = %d\n", GFIELD(cmd_rsp, RSP4_NUM_FUNCS)));
	sd_info(("card_ready = %d\n", GFIELD(cmd_rsp, RSP4_CARD_READY)));
	sd_info(("OCR = 0x%x\n", GFIELD(cmd_rsp, RSP4_IO_OCR)));

	/* Verify that the card supports I/O mode */
	if (GFIELD(cmd_rsp, RSP4_NUM_FUNCS) == 0) {
		sd_err(("%s: Card does not support I/O\n", __FUNCTION__));
		return ERROR;
	}
	sd->num_funcs = GFIELD(cmd_rsp, RSP4_NUM_FUNCS);

	/* Examine voltage: Arasan only supports 3.3 volts,
	 * so look for 3.2-3.3 Volts and also 3.3-3.4 volts.
	 */

	/* XXX Pg 10 SDIO spec v1.10 */
	if ((GFIELD(cmd_rsp, RSP4_IO_OCR) & (0x3 << 20)) == 0) {
		sd_err(("This client does not support 3.3 volts!\n"));
		return ERROR;
	}
	sd_info(("Leaving bus power at 3.3 Volts\n"));

	cmd_arg = SFIELD(0, CMD5_OCR, 0xfff000);
	/* if HC uhsi supported and card voltage set is 3.3V then switch to 1.8V */
	if ((sd->host_UHSISupported) && (volts == 5)) {
		/* set S18R also */
		cmd_arg = SFIELD(cmd_arg, CMD5_S18R, 1);
	}
	cmd_rsp = 0;
	get_ocr(sd, &cmd_arg, &cmd_rsp);
	sd_info(("OCR = 0x%x\n", GFIELD(cmd_rsp, RSP4_IO_OCR)));

	if ((sd->host_UHSISupported)) {
		/* card responded with s18A => card supports sdio3.0,do tuning proc */
		if (GFIELD(cmd_rsp, RSP4_S18A) == 1) {
			if (sdstd_3_sigvoltswitch_proc(sd)) {
				/* continue with legacy way of working */
				sd_err(("%s: voltage switch not done. error, stopping\n",
					__FUNCTION__));
				/* How to gracefully proceced here? */
				return FALSE;
			} else {
				sd->card_UHSI_voltage_Supported = TRUE;
				sd_err(("%s: voltage switch SUCCESS!\n", __FUNCTION__));
			}
		} else {
				/* This could happen for 2 cases.
				 * 1) means card is NOT sdio3.0 . Note that
				 *    card_UHSI_voltage_Supported is already false.
				 * 2) card is sdio3.0 but it is already in 1.8V.
				 *    But now, how to change host controller's voltage?
				 * In this case we need to do the following.
				 * sd->card_UHSI_voltage_Supported = TRUE;
				 * turn 1.8V sig enable in HC2
				 * val1 = sdstd_rreg16(sd, SD3_HostCntrl2);
				 * val1 = SFIELD(val1, HOSTCtrl2_1_8SIG_EN, 1);
				 * sdstd_wreg16(sd, SD3_HostCntrl2, val1);
				 */
				sd_info(("%s: Not sdio3.0: host_UHSISupported: %d; HC volts=%d\n",
					__FUNCTION__, sd->host_UHSISupported, volts));
		}
	} else {
		sd_info(("%s: Legacy [non sdio3.0] HC\n", __FUNCTION__));
	}

	return TRUE;
}

bool
sdstd_bus_width(sdioh_info_t *sd, int new_mode)
{
	uint32 regdata;
	int status;
	uint8 reg8;

	sd_trace(("%s\n", __FUNCTION__));
	if (sd->sd_mode == new_mode) {
		sd_info(("%s: Already at width %d\n", __FUNCTION__, new_mode));
		/* Could exit, but continue just in case... */
	}

	/* Set client side via reg 0x7 in CCCR */
	if ((status = sdstd_card_regread (sd, 0, SDIOD_CCCR_BICTRL, 1, &regdata)) != SUCCESS)
		return (bool)status;
	regdata &= ~BUS_SD_DATA_WIDTH_MASK;
	if (new_mode == SDIOH_MODE_SD4) {
		sd_info(("Changing to SD4 Mode\n"));
		regdata |= SD4_MODE;
	} else if (new_mode == SDIOH_MODE_SD1) {
		sd_info(("Changing to SD1 Mode\n"));
	} else {
		sd_err(("SPI Mode not supported by Standard Host Controller\n"));
	}

	if ((status = sdstd_card_regwrite (sd, 0, SDIOD_CCCR_BICTRL, 1, regdata)) != SUCCESS)
		return (bool)status;

	if (sd->host_UHSISupported) {
		uint32 card_asyncint = 0;
		uint16 host_asyncint = 0;

		if ((status = sdstd_card_regread (sd, 0, SDIOD_CCCR_INTR_EXTN, 1,
			&card_asyncint)) != SUCCESS) {
			sd_err(("%s:INTR EXT getting failed!, ignoring\n", __FUNCTION__));
		} else {
			host_asyncint = sdstd_rreg16(sd, SD3_HostCntrl2);

			/* check if supported by host and card */
			if ((regdata & SD4_MODE) &&
				(GFIELD(card_asyncint, SDIO_BUS_ASYNCINT_CAP)) &&
				(GFIELD(sd->caps, CAP_ASYNCINT_SUP))) {
				/* set enable async int in card */
				card_asyncint = SFIELD(card_asyncint, SDIO_BUS_ASYNCINT_SEL, 1);

				if ((status = sdstd_card_regwrite (sd, 0,
					SDIOD_CCCR_INTR_EXTN, 1, card_asyncint)) != SUCCESS)
					sd_err(("%s:INTR EXT setting failed!, ignoring\n",
					__FUNCTION__));
				else {
					/* set enable async int in host */
					host_asyncint = SFIELD(host_asyncint,
						HOSTCtrl2_ASYINT_EN, 1);
					sdstd_wreg16(sd, SD3_HostCntrl2, host_asyncint);
				}
			} else {
				sd_err(("%s:INTR EXT NOT supported by either host or"
					"card!, ignoring\n", __FUNCTION__));
			}
		}
	}

	/* Set host side via Host reg */
	reg8 = sdstd_rreg8(sd, SD_HostCntrl) & ~SD4_MODE;
	if (new_mode == SDIOH_MODE_SD4)
		reg8 |= SD4_MODE;
	sdstd_wreg8(sd, SD_HostCntrl, reg8);

	sd->sd_mode = new_mode;

	return TRUE;
}

static int
sdstd_driver_init(sdioh_info_t *sd)
{
	sd_trace(("%s\n", __FUNCTION__));
	sd->sd3_tuning_reqd = FALSE;
	sd->sd3_tuning_disable = FALSE;
	if ((sdstd_host_init(sd)) != SUCCESS) {
		return ERROR;
	}

	/* Give WL_reset before sending CMD5 to dongle for Revx SDIO3 HC's */
	if ((sd->controller_type == SDIOH_TYPE_RICOH_R5C822) && (sd->version == HOST_CONTR_VER_3))
	{
		sdstd_wreg16(sd, SD3_WL_BT_reset_register, 0x8);
		OSL_DELAY(sd_delay_value);
		sdstd_wreg16(sd, SD3_WL_BT_reset_register, 0x0);
		OSL_DELAY(500000);
	}

	if (sdstd_client_init(sd) != SUCCESS) {
		return ERROR;
	}

	/* if the global cap matched and is SDR 104/50 [if 50 it is reqd] enable tuning. */
	if ((TRUE != sd3_sw_override1) && SD3_TUNING_REQD(sd, sd_uhsimode)) {
			sd->sd3_tuning_reqd = TRUE;

			/* init OS structs for tuning */
			sdstd_3_osinit_tuning(sd);

			/* enable HC tuning interrupt OR timer based on tuning method */
			if (GFIELD(sd->caps3, CAP3_RETUNING_MODES)) {
				/* enable both RTReq and timer */
				sd->intmask |= HC_INTR_RETUNING;
				sdstd_wreg16(sd, SD_IntrSignalEnable, sd->intmask);
#ifdef BCMSDYIELD
				if (sd_forcerb)
					sdstd_rreg16(sd, SD_IntrSignalEnable); /* Sync readback */
#endif /* BCMSDYIELD */
			}
		}

	return SUCCESS;
}

static int
sdstd_get_cisaddr(sdioh_info_t *sd, uint32 regaddr)
{
	/* read 24 bits and return valid 17 bit addr */
	int i;
	uint32 scratch, regdata;
	uint8 *ptr = (uint8 *)&scratch;
	for (i = 0; i < 3; i++) {
		if ((sdstd_card_regread (sd, 0, regaddr, 1, &regdata)) != SUCCESS)
			sd_err(("%s: Can't read!\n", __FUNCTION__));

		*ptr++ = (uint8) regdata;
		regaddr++;
	}
	/* Only the lower 17-bits are valid */
	scratch = ltoh32(scratch);
	scratch &= 0x0001FFFF;
	return (scratch);
}

static int
sdstd_card_enablefuncs(sdioh_info_t *sd)
{
	int status;
	uint32 regdata;
	uint32 fbraddr;
	uint8 func;

	sd_trace(("%s\n", __FUNCTION__));

	/* Get the Card's common CIS address */
	sd->com_cis_ptr = sdstd_get_cisaddr(sd, SDIOD_CCCR_CISPTR_0);
	sd->func_cis_ptr[0] = sd->com_cis_ptr;
	sd_info(("%s: Card's Common CIS Ptr = 0x%x\n", __FUNCTION__, sd->com_cis_ptr));

	/* Get the Card's function CIS (for each function) */
	for (fbraddr = SDIOD_FBR_STARTADDR, func = 1;
	     func <= sd->num_funcs; func++, fbraddr += SDIOD_FBR_SIZE) {
		sd->func_cis_ptr[func] = sdstd_get_cisaddr(sd, SDIOD_FBR_CISPTR_0 + fbraddr);
		sd_info(("%s: Function %d CIS Ptr = 0x%x\n",
		         __FUNCTION__, func, sd->func_cis_ptr[func]));
	}

	/* Enable function 1 on the card */
	regdata = SDIO_FUNC_ENABLE_1;
	if ((status = sdstd_card_regwrite(sd, 0, SDIOD_CCCR_IOEN, 1, regdata)) != SUCCESS)
		return status;

	return SUCCESS;
}

/* Read client card reg */
static int
sdstd_card_regread(sdioh_info_t *sd, int func, uint32 regaddr, int regsize, uint32 *data)
{
	int status;
	uint32 cmd_arg;
	uint32 rsp5;

#ifdef BCMDBG
	if (sdstd_rreg16 (sd, SD_ErrorIntrStatus) != 0) {
		sd_err(("%s: Entering: ErrorintrStatus 0x%x, intstat = 0x%x\n",
		        __FUNCTION__, sdstd_rreg16(sd, SD_ErrorIntrStatus),
		        sdstd_rreg16(sd, SD_IntrStatus)));
	}
#endif

	cmd_arg = 0;

	if ((func == 0) || (regsize == 1)) {
		cmd_arg = SFIELD(cmd_arg, CMD52_FUNCTION, func);
		cmd_arg = SFIELD(cmd_arg, CMD52_REG_ADDR, regaddr);
		cmd_arg = SFIELD(cmd_arg, CMD52_RW_FLAG, SDIOH_XFER_TYPE_READ);
		cmd_arg = SFIELD(cmd_arg, CMD52_RAW, 0);
		cmd_arg = SFIELD(cmd_arg, CMD52_DATA, 0);

		if ((status = sdstd_cmd_issue(sd, USE_DMA(sd), SDIOH_CMD_52, cmd_arg))
		    != SUCCESS)
			return status;

		sdstd_cmd_getrsp(sd, &rsp5, 1);
		if (sdstd_rreg16(sd, SD_ErrorIntrStatus) != 0) {
			sd_err(("%s: 1: ErrorintrStatus 0x%x\n",
			        __FUNCTION__, sdstd_rreg16(sd, SD_ErrorIntrStatus)));
		}

		if (GFIELD(rsp5, RSP5_FLAGS) != 0x10)
			sd_err(("%s: rsp5 flags is 0x%x\t %d\n",
			        __FUNCTION__, GFIELD(rsp5, RSP5_FLAGS), func));

		if (GFIELD(rsp5, RSP5_STUFF))
			sd_err(("%s: rsp5 stuff is 0x%x: should be 0\n",
			        __FUNCTION__, GFIELD(rsp5, RSP5_STUFF)));
		*data = GFIELD(rsp5, RSP5_DATA);

		sd_data(("%s: Resp data(0x%x)\n", __FUNCTION__, *data));
	} else {
		cmd_arg = SFIELD(cmd_arg, CMD53_BYTE_BLK_CNT, regsize);
		cmd_arg = SFIELD(cmd_arg, CMD53_OP_CODE, 1);	/* XXX SDIO spec v 1.10, Sec 5.3 */
		cmd_arg = SFIELD(cmd_arg, CMD53_BLK_MODE, 0);
		cmd_arg = SFIELD(cmd_arg, CMD53_FUNCTION, func);
		cmd_arg = SFIELD(cmd_arg, CMD53_REG_ADDR, regaddr);
		cmd_arg = SFIELD(cmd_arg, CMD53_RW_FLAG, SDIOH_XFER_TYPE_READ);

		sd->data_xfer_count = regsize;

		/* sdstd_cmd_issue() returns with the command complete bit
		 * in the ISR already cleared
		 */
		if ((status = sdstd_cmd_issue(sd, USE_DMA(sd), SDIOH_CMD_53, cmd_arg))
		    != SUCCESS)
			return status;

		sdstd_cmd_getrsp(sd, &rsp5, 1);

		if (GFIELD(rsp5, RSP5_FLAGS) != 0x10)
			sd_err(("%s: rsp5 flags is 0x%x\t %d\n",
			        __FUNCTION__, GFIELD(rsp5, RSP5_FLAGS), func));

		if (GFIELD(rsp5, RSP5_STUFF))
			sd_err(("%s: rsp5 stuff is 0x%x: should be 0\n",
			        __FUNCTION__, GFIELD(rsp5, RSP5_STUFF)));

		if (sd->polled_mode) {
			volatile uint16 int_reg;
			int retries = RETRIES_LARGE;

			/* Wait for Read Buffer to become ready */
			do {
				sdstd_os_yield(sd);
				int_reg = sdstd_rreg16(sd, SD_IntrStatus);
			} while (--retries && (GFIELD(int_reg, INTSTAT_BUF_READ_READY) == 0));

			if (!retries) {
				sd_err(("%s: Timeout on Buf_Read_Ready: "
				        "intStat: 0x%x errint: 0x%x PresentState 0x%x\n",
				        __FUNCTION__, int_reg,
				        sdstd_rreg16(sd, SD_ErrorIntrStatus),
				        sdstd_rreg(sd, SD_PresentState)));
				sdstd_check_errs(sd, SDIOH_CMD_53, cmd_arg);
				return (ERROR);
			}

			/* Have Buffer Ready, so clear it and read the data */
			sdstd_wreg16(sd, SD_IntrStatus, SFIELD(0, INTSTAT_BUF_READ_READY, 1));
			if (regsize == 2)
				*data = sdstd_rreg16(sd, SD_BufferDataPort0);
			else
				*data = sdstd_rreg(sd, SD_BufferDataPort0);

			sd_data(("%s: Resp data(0x%x)\n", __FUNCTION__, *data));
			/* Check Status.
			 * After the data is read, the Transfer Complete bit should be on
			 */
			retries = RETRIES_LARGE;
			do {
				int_reg = sdstd_rreg16(sd, SD_IntrStatus);
			} while (--retries && (GFIELD(int_reg, INTSTAT_XFER_COMPLETE) == 0));

			/* Check for any errors from the data phase */
			if (sdstd_check_errs(sd, SDIOH_CMD_53, cmd_arg))
				return ERROR;

			if (!retries) {
				sd_err(("%s: Timeout on xfer complete: "
				        "intr 0x%04x err 0x%04x state 0x%08x\n",
				        __FUNCTION__, int_reg,
				        sdstd_rreg16(sd, SD_ErrorIntrStatus),
				        sdstd_rreg(sd, SD_PresentState)));
				return (ERROR);
			}

			sdstd_wreg16(sd, SD_IntrStatus, SFIELD(0, INTSTAT_XFER_COMPLETE, 1));
		}
	}
	if (sd->polled_mode) {
		if (regsize == 2)
			*data &= 0xffff;
	}
	return SUCCESS;
}

bool
check_client_intr(sdioh_info_t *sd)
{
	uint16 raw_int, cur_int, old_int;

	raw_int = sdstd_rreg16(sd, SD_IntrStatus);
	cur_int = raw_int & sd->intmask;

	if (!cur_int) {
		/* Not an error -- might share interrupts... */
		return FALSE;
	}

	if (GFIELD(cur_int, INTSTAT_CARD_INT)) {
		unsigned long flags;

		sdstd_os_lock_irqsave(sd, &flags);
		old_int = sdstd_rreg16(sd, SD_IntrStatusEnable);
		sdstd_wreg16(sd, SD_IntrStatusEnable, SFIELD(old_int, INTSTAT_CARD_INT, 0));
		sdstd_os_unlock_irqrestore(sd, &flags);

		if (sd->client_intr_enabled && sd->use_client_ints) {
			sd->intrcount++;
			ASSERT(sd->intr_handler);
			ASSERT(sd->intr_handler_arg);
			(sd->intr_handler)(sd->intr_handler_arg);
		} else {
			sd_err(("%s: Not ready for intr: enabled %d, handler %p\n",
			        __FUNCTION__, sd->client_intr_enabled, sd->intr_handler));
		}
		sdstd_os_lock_irqsave(sd, &flags);
		old_int = sdstd_rreg16(sd, SD_IntrStatusEnable);
		sdstd_wreg16(sd, SD_IntrStatusEnable, SFIELD(old_int, INTSTAT_CARD_INT, 1));
		sdstd_os_unlock_irqrestore(sd, &flags);
	} else {
		/* Local interrupt: disable, set flag, and save intrstatus */
		sdstd_wreg16(sd, SD_IntrSignalEnable, 0);
		sdstd_wreg16(sd, SD_ErrorIntrSignalEnable, 0);
		sd->local_intrcount++;
		sd->got_hcint = TRUE;
		sd->last_intrstatus = cur_int;
	}

	return TRUE;
}

void
sdstd_spinbits(sdioh_info_t *sd, uint16 norm, uint16 err)
{
	uint16 int_reg, err_reg;
	int retries = RETRIES_LARGE;

	do {
		int_reg = sdstd_rreg16(sd, SD_IntrStatus);
		err_reg = sdstd_rreg16(sd, SD_ErrorIntrStatus);
	} while (--retries && !(int_reg & norm) && !(err_reg & err));

	norm |= sd->intmask;
	if (err_reg & err)
		norm = SFIELD(norm, INTSTAT_ERROR_INT, 1);
	sd->last_intrstatus = int_reg & norm;
}

/* write a client register */
static int
sdstd_card_regwrite(sdioh_info_t *sd, int func, uint32 regaddr, int regsize, uint32 data)
{
	int status;
	uint32 cmd_arg, rsp5, flags;

	cmd_arg = 0;

	if ((func == 0) || (regsize == 1)) {
		cmd_arg = SFIELD(cmd_arg, CMD52_FUNCTION, func);
		cmd_arg = SFIELD(cmd_arg, CMD52_REG_ADDR, regaddr);
		cmd_arg = SFIELD(cmd_arg, CMD52_RW_FLAG, SDIOH_XFER_TYPE_WRITE);
		cmd_arg = SFIELD(cmd_arg, CMD52_RAW, 0);
		cmd_arg = SFIELD(cmd_arg, CMD52_DATA, data & 0xff);
		if ((status = sdstd_cmd_issue(sd, USE_DMA(sd), SDIOH_CMD_52, cmd_arg))
		    != SUCCESS)
			return status;

		sdstd_cmd_getrsp(sd, &rsp5, 1);
		flags = GFIELD(rsp5, RSP5_FLAGS);
		if (flags && (flags != 0x10))
			sd_err(("%s: rsp5.rsp5.flags = 0x%x, expecting 0x10\n",
			        __FUNCTION__,  flags));
	}
	else {
		cmd_arg = SFIELD(cmd_arg, CMD53_BYTE_BLK_CNT, regsize);
		/* XXX SDIO spec v 1.10, Sec 5.3  Not FIFO */
		cmd_arg = SFIELD(cmd_arg, CMD53_OP_CODE, 1);
		cmd_arg = SFIELD(cmd_arg, CMD53_BLK_MODE, 0);
		cmd_arg = SFIELD(cmd_arg, CMD53_FUNCTION, func);
		cmd_arg = SFIELD(cmd_arg, CMD53_REG_ADDR, regaddr);
		cmd_arg = SFIELD(cmd_arg, CMD53_RW_FLAG, SDIOH_XFER_TYPE_WRITE);

		sd->data_xfer_count = regsize;

		/* sdstd_cmd_issue() returns with the command complete bit
		 * in the ISR already cleared
		 */
		if ((status = sdstd_cmd_issue(sd, USE_DMA(sd), SDIOH_CMD_53, cmd_arg))
		    != SUCCESS)
			return status;

		sdstd_cmd_getrsp(sd, &rsp5, 1);

		if (GFIELD(rsp5, RSP5_FLAGS) != 0x10)
			sd_err(("%s: rsp5 flags = 0x%x, expecting 0x10\n",
			        __FUNCTION__,  GFIELD(rsp5, RSP5_FLAGS)));
		if (GFIELD(rsp5, RSP5_STUFF))
			sd_err(("%s: rsp5 stuff is 0x%x: expecting 0\n",
			        __FUNCTION__, GFIELD(rsp5, RSP5_STUFF)));

		if (sd->polled_mode) {
			uint16 int_reg;
			int retries = RETRIES_LARGE;

			/* Wait for Write Buffer to become ready */
			do {
				int_reg = sdstd_rreg16(sd, SD_IntrStatus);
			} while (--retries && (GFIELD(int_reg, INTSTAT_BUF_WRITE_READY) == 0));

			if (!retries) {
				sd_err(("%s: Timeout on Buf_Write_Ready: intStat: 0x%x "
				        "errint: 0x%x PresentState 0x%x\n",
				        __FUNCTION__, int_reg,
				        sdstd_rreg16(sd, SD_ErrorIntrStatus),
				        sdstd_rreg(sd, SD_PresentState)));
				sdstd_check_errs(sd, SDIOH_CMD_53, cmd_arg);
				return (ERROR);
			}
			/* Clear Write Buf Ready bit */
			int_reg = 0;
			int_reg = SFIELD(int_reg, INTSTAT_BUF_WRITE_READY, 1);
			sdstd_wreg16(sd, SD_IntrStatus, int_reg);

			/* At this point we have Buffer Ready, so write the data */
			if (regsize == 2)
				sdstd_wreg16(sd, SD_BufferDataPort0, (uint16) data);
			else
				sdstd_wreg(sd, SD_BufferDataPort0, data);

			/* Wait for Transfer Complete */
			retries = RETRIES_LARGE;
			do {
				int_reg = sdstd_rreg16(sd, SD_IntrStatus);
			} while (--retries && (GFIELD(int_reg, INTSTAT_XFER_COMPLETE) == 0));

			/* Check for any errors from the data phase */
			if (sdstd_check_errs(sd, SDIOH_CMD_53, cmd_arg))
				return ERROR;

			if (retries == 0) {
				sd_err(("%s: Timeout for xfer complete; State = 0x%x, "
				        "intr state=0x%x, Errintstatus 0x%x rcnt %d, tcnt %d\n",
				        __FUNCTION__, sdstd_rreg(sd, SD_PresentState),
				        int_reg, sdstd_rreg16(sd, SD_ErrorIntrStatus),
				        sd->r_cnt, sd->t_cnt));
			}
			/* Clear the status bits */
			sdstd_wreg16(sd, SD_IntrStatus, SFIELD(int_reg, INTSTAT_CARD_INT, 0));
		}
	}
	return SUCCESS;
}

void
sdstd_cmd_getrsp(sdioh_info_t *sd, uint32 *rsp_buffer, int count /* num 32 bit words */)
{
	int rsp_count;
	int respaddr = SD_Response0;

	if (count > 4)
		count = 4;

	for (rsp_count = 0; rsp_count < count; rsp_count++) {
		*rsp_buffer++ = sdstd_rreg(sd, respaddr);
		respaddr += 4;
	}
}

/*
	Note: options: 0 - default
				 1 - tuning option: Means that, this cmd issue is as a part
					of tuning. So no need to check the start tuning function.
*/
static int
sdstd_cmd_issue(sdioh_info_t *sdioh_info, bool use_dma, uint32 cmd, uint32 arg)
{
	uint16 cmd_reg;
	int retries;
	uint32 cmd_arg;
	uint16 xfer_reg = 0;

#ifdef BCMDBG
	if (sdstd_rreg16(sdioh_info, SD_ErrorIntrStatus) != 0) {
		sd_err(("%s: Entering: ErrorIntrStatus 0x%x, Expecting 0\n",
		        __FUNCTION__, sdstd_rreg16(sdioh_info, SD_ErrorIntrStatus)));
	}
#endif

	if ((sdioh_info->sd_mode == SDIOH_MODE_SPI) &&
	    ((cmd == SDIOH_CMD_3) || (cmd == SDIOH_CMD_7) || (cmd == SDIOH_CMD_15))) {
		sd_err(("%s: Cmd %d is not for SPI\n", __FUNCTION__, cmd));
		return ERROR;
	}

	retries = RETRIES_SMALL;
	while ((GFIELD(sdstd_rreg(sdioh_info, SD_PresentState), PRES_CMD_INHIBIT)) && --retries) {
		if (retries == RETRIES_SMALL)
			sd_err(("%s: Waiting for Command Inhibit cmd = %d 0x%x\n",
			        __FUNCTION__, cmd, sdstd_rreg(sdioh_info, SD_PresentState)));
	}
	if (!retries) {
		sd_err(("%s: Command Inhibit timeout\n", __FUNCTION__));
		if (trap_errs)
			ASSERT(0);
		return ERROR;
	}

	cmd_reg = 0;
	switch (cmd) {
	case SDIOH_CMD_0:       /* Set Card to Idle State - No Response */
		sd_data(("%s: CMD%d\n", __FUNCTION__, cmd));
		cmd_reg = SFIELD(cmd_reg, CMD_RESP_TYPE, RESP_TYPE_NONE);
		cmd_reg = SFIELD(cmd_reg, CMD_CRC_EN, 0);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX_EN, 0);
		cmd_reg = SFIELD(cmd_reg, CMD_DATA_EN, 0);
		cmd_reg = SFIELD(cmd_reg, CMD_TYPE, CMD_TYPE_NORMAL);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX, cmd);
		break;

	case SDIOH_CMD_3:	/* Ask card to send RCA - Response R6 */
		sd_data(("%s: CMD%d\n", __FUNCTION__, cmd));
		cmd_reg = SFIELD(cmd_reg, CMD_RESP_TYPE, RESP_TYPE_48);
		cmd_reg = SFIELD(cmd_reg, CMD_CRC_EN, 0);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX_EN, 0);
		cmd_reg = SFIELD(cmd_reg, CMD_DATA_EN, 0);
		cmd_reg = SFIELD(cmd_reg, CMD_TYPE, CMD_TYPE_NORMAL);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX, cmd);
		break;

	case SDIOH_CMD_5:	/* Send Operation condition - Response R4 */
		sd_data(("%s: CMD%d\n", __FUNCTION__, cmd));
		cmd_reg = SFIELD(cmd_reg, CMD_RESP_TYPE, RESP_TYPE_48);
		cmd_reg = SFIELD(cmd_reg, CMD_CRC_EN, 0);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX_EN, 0);
		cmd_reg = SFIELD(cmd_reg, CMD_DATA_EN, 0);
		cmd_reg = SFIELD(cmd_reg, CMD_TYPE, CMD_TYPE_NORMAL);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX, cmd);
		break;

	case SDIOH_CMD_7:	/* Select card - Response R1 */
		sd_data(("%s: CMD%d\n", __FUNCTION__, cmd));
		cmd_reg = SFIELD(cmd_reg, CMD_RESP_TYPE, RESP_TYPE_48);
		cmd_reg = SFIELD(cmd_reg, CMD_CRC_EN, 1);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX_EN, 1);
		cmd_reg = SFIELD(cmd_reg, CMD_DATA_EN, 0);
		cmd_reg = SFIELD(cmd_reg, CMD_TYPE, CMD_TYPE_NORMAL);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX, cmd);
		break;

	case SDIOH_CMD_14:	/* eSD Sleep - Response R1 */
	case SDIOH_CMD_11:	/* Select card - Response R1 */
		sd_data(("%s: CMD%d\n", __FUNCTION__, cmd));
		cmd_reg = SFIELD(cmd_reg, CMD_RESP_TYPE, RESP_TYPE_48);
		cmd_reg = SFIELD(cmd_reg, CMD_CRC_EN, 1);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX_EN, 1);
		cmd_reg = SFIELD(cmd_reg, CMD_DATA_EN, 0);
		cmd_reg = SFIELD(cmd_reg, CMD_TYPE, CMD_TYPE_NORMAL);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX, cmd);
		break;

	case SDIOH_CMD_15:	/* Set card to inactive state - Response None */
		sd_data(("%s: CMD%d\n", __FUNCTION__, cmd));
		cmd_reg = SFIELD(cmd_reg, CMD_RESP_TYPE, RESP_TYPE_NONE);
		cmd_reg = SFIELD(cmd_reg, CMD_CRC_EN, 0);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX_EN, 0);
		cmd_reg = SFIELD(cmd_reg, CMD_DATA_EN, 0);
		cmd_reg = SFIELD(cmd_reg, CMD_TYPE, CMD_TYPE_NORMAL);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX, cmd);
		break;

	case SDIOH_CMD_19:	/* clock tuning - Response R1 */
		sd_data(("%s: CMD%d\n", __FUNCTION__, cmd));
		cmd_reg = SFIELD(cmd_reg, CMD_RESP_TYPE, RESP_TYPE_48);
		cmd_reg = SFIELD(cmd_reg, CMD_CRC_EN, 1);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX_EN, 1);
		cmd_reg = SFIELD(cmd_reg, CMD_DATA_EN, 1);
		cmd_reg = SFIELD(cmd_reg, CMD_TYPE, CMD_TYPE_NORMAL);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX, cmd);
		/* Host controller reads 64 byte magic pattern from card
		*  Hence Direction = 1 ( READ )
		*/
		xfer_reg = SFIELD(xfer_reg, XFER_DATA_DIRECTION, 1);
		break;

	case SDIOH_CMD_52:	/* IO R/W Direct (single byte) - Response R5 */

		sd_data(("%s: CMD52 func(%d) addr(0x%x) %s data(0x%x)\n",
			__FUNCTION__,
			GFIELD(arg, CMD52_FUNCTION),
			GFIELD(arg, CMD52_REG_ADDR),
			GFIELD(arg, CMD52_RW_FLAG) ? "W" : "R",
			GFIELD(arg, CMD52_DATA)));

		cmd_reg = SFIELD(cmd_reg, CMD_RESP_TYPE, RESP_TYPE_48);
		cmd_reg = SFIELD(cmd_reg, CMD_CRC_EN, 1);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX_EN, 1);
		cmd_reg = SFIELD(cmd_reg, CMD_DATA_EN, 0);
		cmd_reg = SFIELD(cmd_reg, CMD_TYPE, CMD_TYPE_NORMAL);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX, cmd);
		break;

	case SDIOH_CMD_53:	/* IO R/W Extended (multiple bytes/blocks) */

		sd_data(("%s: CMD53 func(%d) addr(0x%x) %s mode(%s) cnt(%d), %s\n",
			__FUNCTION__,
			GFIELD(arg, CMD53_FUNCTION),
			GFIELD(arg, CMD53_REG_ADDR),
			GFIELD(arg, CMD53_RW_FLAG) ? "W" : "R",
			GFIELD(arg, CMD53_BLK_MODE) ? "Block" : "Byte",
			GFIELD(arg, CMD53_BYTE_BLK_CNT),
			GFIELD(arg, CMD53_OP_CODE) ? "Incrementing addr" : "Single addr"));

		cmd_arg = arg;
		xfer_reg = 0;

		cmd_reg = SFIELD(cmd_reg, CMD_RESP_TYPE, RESP_TYPE_48);
		cmd_reg = SFIELD(cmd_reg, CMD_CRC_EN, 1);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX_EN, 1);
		cmd_reg = SFIELD(cmd_reg, CMD_DATA_EN, 1);
		cmd_reg = SFIELD(cmd_reg, CMD_TYPE, CMD_TYPE_NORMAL);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX, cmd);

		use_dma = USE_DMA(sdioh_info) && GFIELD(cmd_arg, CMD53_BLK_MODE);

		if (GFIELD(cmd_arg, CMD53_BLK_MODE)) {
			uint16 blocksize;
			uint16 blockcount;
			int func;

			ASSERT(sdioh_info->sd_blockmode);

			func = GFIELD(cmd_arg, CMD53_FUNCTION);
			blocksize = MIN((int)sdioh_info->data_xfer_count,
			                sdioh_info->client_block_size[func]);
			blockcount = GFIELD(cmd_arg, CMD53_BYTE_BLK_CNT);

			/* data_xfer_cnt is already setup so that for multiblock mode,
			 * it is the entire buffer length.  For non-block or single block,
			 * it is < 64 bytes
			 */
			if (use_dma) {
				switch (sdioh_info->sd_dma_mode) {
				case DMA_MODE_SDMA:
					sd_dma(("%s: SDMA: SysAddr reg was 0x%x now 0x%x\n",
					      __FUNCTION__, sdstd_rreg(sdioh_info, SD_SysAddr),
					     (uint32)sdioh_info->dma_phys));
				sdstd_wreg(sdioh_info, SD_SysAddr, sdioh_info->dma_phys);
					break;
				case DMA_MODE_ADMA1:
				case DMA_MODE_ADMA2:
					sd_dma(("%s: ADMA: Using ADMA\n", __FUNCTION__));
#ifdef BCMSDIOH_TXGLOM
					/* multi-descriptor is currently used only for hc3 */
					if ((sdioh_info->glom_info.count != 0) &&
						(sdioh_info->txglom_mode == SDPCM_TXGLOM_MDESC)) {
						uint32 i = 0;
						for (i = 0;
							i < sdioh_info->glom_info.count-1;
							i++) {
							glom_buf_t *glom_info;
							glom_info = &(sdioh_info->glom_info);
							sd_create_adma_descriptor(sdioh_info,
								i,
								glom_info->dma_phys_arr[i],
								glom_info->nbytes[i],
								ADMA2_ATTRIBUTE_VALID |
								ADMA2_ATTRIBUTE_ACT_TRAN);
						}

						sd_create_adma_descriptor(sdioh_info,
							i,
							sdioh_info->glom_info.dma_phys_arr[i],
							sdioh_info->glom_info.nbytes[i],
							ADMA2_ATTRIBUTE_VALID |
							ADMA2_ATTRIBUTE_END |
							ADMA2_ATTRIBUTE_INT |
							ADMA2_ATTRIBUTE_ACT_TRAN);
					} else
#endif /* BCMSDIOH_TXGLOM */
					{
						sd_create_adma_descriptor(sdioh_info, 0,
						sdioh_info->dma_phys, blockcount*blocksize,
						ADMA2_ATTRIBUTE_VALID | ADMA2_ATTRIBUTE_END |
						ADMA2_ATTRIBUTE_INT | ADMA2_ATTRIBUTE_ACT_TRAN);
					}
					/* Dump descriptor if DMA debugging is enabled. */
					if (sd_msglevel & SDH_DMA_VAL) {
						sd_dump_adma_dscr(sdioh_info);
					}

					sdstd_wreg(sdioh_info, SD_ADMA_SysAddr,
					           sdioh_info->adma2_dscr_phys);
					break;
				default:
					sd_err(("%s: unsupported DMA mode %d.\n",
						__FUNCTION__, sdioh_info->sd_dma_mode));
					break;
				}
			}

			sd_trace(("%s: Setting block count %d, block size %d bytes\n",
			          __FUNCTION__, blockcount, blocksize));
			sdstd_wreg16(sdioh_info, SD_BlockSize, blocksize);
			sdstd_wreg16(sdioh_info, SD_BlockCount, blockcount);

			xfer_reg = SFIELD(xfer_reg, XFER_DMA_ENABLE, use_dma);

			if (sdioh_info->client_block_size[func] != blocksize)
				set_client_block_size(sdioh_info, 1, blocksize);

			if (blockcount > 1) {
				xfer_reg = SFIELD(xfer_reg, XFER_MULTI_BLOCK, 1);
				xfer_reg = SFIELD(xfer_reg, XFER_BLK_COUNT_EN, 1);
				xfer_reg = SFIELD(xfer_reg, XFER_CMD_12_EN, 0);
			} else {
				xfer_reg = SFIELD(xfer_reg, XFER_MULTI_BLOCK, 0);
				xfer_reg = SFIELD(xfer_reg, XFER_BLK_COUNT_EN, 0);
				xfer_reg = SFIELD(xfer_reg, XFER_CMD_12_EN, 0);
			}

			if (GFIELD(cmd_arg, CMD53_RW_FLAG) == SDIOH_XFER_TYPE_READ)
				xfer_reg = SFIELD(xfer_reg, XFER_DATA_DIRECTION, 1);
			else
				xfer_reg = SFIELD(xfer_reg, XFER_DATA_DIRECTION, 0);

			retries = RETRIES_SMALL;
			while (GFIELD(sdstd_rreg(sdioh_info, SD_PresentState),
			              PRES_DAT_INHIBIT) && --retries)
				sd_err(("%s: Waiting for Data Inhibit cmd = %d\n",
				        __FUNCTION__, cmd));
			if (!retries) {
				sd_err(("%s: Data Inhibit timeout\n", __FUNCTION__));
				if (trap_errs)
					ASSERT(0);
				return ERROR;
			}

			/* Consider deferring this write to the comment below "Deferred Write" */
			sdstd_wreg16(sdioh_info, SD_TransferMode, xfer_reg);

		} else {	/* Non block mode */
			uint16 bytes = GFIELD(cmd_arg, CMD53_BYTE_BLK_CNT);
			/* The byte/block count field only has 9 bits,
			 * so, to do a 512-byte bytemode transfer, this
			 * field will contain 0, but we need to tell the
			 * controller we're transferring 512 bytes.
			 */
			if (bytes == 0) bytes = 512;

			if (use_dma)
				sdstd_wreg(sdioh_info, SD_SysAddr, sdioh_info->dma_phys);

			/* PCI: Transfer Mode register 0x0c */
			xfer_reg = SFIELD(xfer_reg, XFER_DMA_ENABLE, bytes <= 4 ? 0 : use_dma);
			xfer_reg = SFIELD(xfer_reg, XFER_CMD_12_EN, 0);
			if (GFIELD(cmd_arg, CMD53_RW_FLAG) == SDIOH_XFER_TYPE_READ)
				xfer_reg = SFIELD(xfer_reg, XFER_DATA_DIRECTION, 1);
			else
				xfer_reg = SFIELD(xfer_reg, XFER_DATA_DIRECTION, 0);
			/* See table 2-8 Host Controller spec ver 1.00 */
			xfer_reg = SFIELD(xfer_reg, XFER_BLK_COUNT_EN, 0); /* Dont care */
			xfer_reg = SFIELD(xfer_reg, XFER_MULTI_BLOCK, 0);

			sdstd_wreg16(sdioh_info, SD_BlockSize,  bytes);

			/* XXX This should be a don't care but Arasan needs it
			 * to be one.  Its fixed in later versions (but they
			 * don't have version numbers, sigh).
			 */
			sdstd_wreg16(sdioh_info, SD_BlockCount, 1);

			retries = RETRIES_SMALL;
			while (GFIELD(sdstd_rreg(sdioh_info, SD_PresentState),
			              PRES_DAT_INHIBIT) && --retries)
				sd_err(("%s: Waiting for Data Inhibit cmd = %d\n",
				        __FUNCTION__, cmd));
			if (!retries) {
				sd_err(("%s: Data Inhibit timeout\n", __FUNCTION__));
				if (trap_errs)
					ASSERT(0);
				return ERROR;
			}

			/* Consider deferring this write to the comment below "Deferred Write" */
			sdstd_wreg16(sdioh_info, SD_TransferMode, xfer_reg);
		}
		break;

	default:
		sd_err(("%s: Unknown command\n", __FUNCTION__));
		return ERROR;
	}

	if (sdioh_info->sd_mode == SDIOH_MODE_SPI) {
		cmd_reg = SFIELD(cmd_reg, CMD_CRC_EN, 0);
		cmd_reg = SFIELD(cmd_reg, CMD_INDEX_EN, 0);
	}

	/* Setup and issue the SDIO command */
	sdstd_wreg(sdioh_info, SD_Arg0, arg);

	/* Deferred Write
	 * Consider deferring the two writes above until this point in the code.
	 * The following would do one 32 bit write.
	 *
	 * {
	 *	uint32 tmp32 = cmd_reg << 16;
	 *	tmp32 |= xfer_reg;
	 *	sdstd_wreg(sdioh_info, SD_TransferMode, tmp32);
	 * }
	 */

	/* Alternate to Deferred Write START */

	/* In response to CMD19 card sends 64 byte magic pattern.
	 * So SD_BlockSize = 64 & SD_BlockCount = 1
	*/
	if (GFIELD(cmd_reg, CMD_INDEX) == SDIOH_CMD_19) {
		sdstd_wreg16(sdioh_info, SD_TransferMode, xfer_reg);
		sdstd_wreg16(sdioh_info, SD_BlockSize, 64);
		sdstd_wreg16(sdioh_info, SD_BlockCount, 1);
	}
	sdstd_wreg16(sdioh_info, SD_Command, cmd_reg);

	/* Alternate to Deferred Write END */

	/* If we are in polled mode, wait for the command to complete.
	 * In interrupt mode, return immediately. The calling function will
	 * know that the command has completed when the CMDATDONE interrupt
	 * is asserted
	 */
	if (sdioh_info->polled_mode) {
		uint16 int_reg = 0;
		retries = RETRIES_LARGE;

		/* For CMD19 no need to wait for cmd completion */
		if (GFIELD(cmd_reg, CMD_INDEX) == SDIOH_CMD_19)
			return SUCCESS;

		do {
			int_reg = sdstd_rreg16(sdioh_info, SD_IntrStatus);
			sdstd_os_yield(sdioh_info);
		} while (--retries &&
		         (GFIELD(int_reg, INTSTAT_ERROR_INT) == 0) &&
		         (GFIELD(int_reg, INTSTAT_CMD_COMPLETE) == 0));

		if (!retries) {
			sd_err(("%s: CMD_COMPLETE timeout: intrStatus: 0x%x "
			        "error stat 0x%x state 0x%x\n",
			        __FUNCTION__, int_reg,
			        sdstd_rreg16(sdioh_info, SD_ErrorIntrStatus),
			        sdstd_rreg(sdioh_info, SD_PresentState)));

			/* Attempt to reset CMD line when we get a CMD timeout */
			sdstd_wreg8(sdioh_info, SD_SoftwareReset, SFIELD(0, SW_RESET_CMD, 1));
			retries = RETRIES_LARGE;
			do {
				sd_trace(("%s: waiting for CMD line reset\n", __FUNCTION__));
			} while ((GFIELD(sdstd_rreg8(sdioh_info, SD_SoftwareReset),
			                 SW_RESET_CMD)) && retries--);

			if (!retries) {
				sd_err(("%s: Timeout waiting for CMD line reset\n", __FUNCTION__));
			}

			if (trap_errs)
				ASSERT(0);
			return (ERROR);
		}

		/* Clear Command Complete interrupt */
		int_reg = SFIELD(0, INTSTAT_CMD_COMPLETE, 1);
		sdstd_wreg16(sdioh_info, SD_IntrStatus, int_reg);

		/* Check for Errors */
		if (sdstd_check_errs(sdioh_info, cmd, arg)) {
			if (trap_errs)
				ASSERT(0);
			return ERROR;
		}
	}
	return SUCCESS;
}

/*
 * XXX On entry: If single block or non-block, buffersize <= blocksize.
 * If Mulitblock, buffersize is unlimited.
 * Question is how to handle the leftovers in either single or multiblock.
 * I think the caller should break the buffer up so this routine will always
 * use blocksize == buffersize to handle the end piece of the buffer
 */

static int
sdstd_card_buf(sdioh_info_t *sd, int rw, int func, bool fifo, uint32 addr, int nbytes, uint32 *data)
{
	int retval = SUCCESS;
	int status;
	uint32 cmd_arg;
	uint32 rsp5;
	uint16 int_reg, int_bit;
	uint flags;
	int num_blocks, blocksize;
	bool local_blockmode, local_dma;
	bool read = rw == SDIOH_READ ? 1 : 0;
	bool local_yield = FALSE;
#ifdef BCMSDIOH_TXGLOM
	uint32 i;
	uint8 *localbuf = NULL;
#endif

	ASSERT(nbytes);

	cmd_arg = 0;

	sd_data(("%s: %s 53 addr 0x%x, len %d bytes, r_cnt %d t_cnt %d\n",
	         __FUNCTION__, read ? "Rd" : "Wr", addr, nbytes, sd->r_cnt, sd->t_cnt));

	if (read) sd->r_cnt++; else sd->t_cnt++;

	local_blockmode = sd->sd_blockmode;
	local_dma = USE_DMA(sd);

#ifdef BCMSDIOH_TXGLOM
	/* If multiple buffers are there, then calculate the nbytes from that */
	if (!read && (func == SDIO_FUNC_2) && (sd->glom_info.count != 0)) {
		uint32 ii;
		nbytes = 0;
		for (ii = 0; ii < sd->glom_info.count; ii++) {
			nbytes += sd->glom_info.nbytes[ii];
		}
		ASSERT(nbytes <= sd->alloced_dma_size);
	}
#endif

	/* Don't bother with block mode on small xfers */
	if (nbytes < sd->client_block_size[func]) {
		sd_data(("setting local blockmode to false: nbytes (%d) != block_size (%d)\n",
		         nbytes, sd->client_block_size[func]));
		local_blockmode = FALSE;
		local_dma = FALSE;
#ifdef BCMSDIOH_TXGLOM
		/* In glommed case, create a single pkt from multiple pkts */
		if (!read && (func == SDIO_FUNC_2) && (sd->glom_info.count != 0)) {
			uint32 offset = 0;
			localbuf = (uint8 *)MALLOC(sd->osh, nbytes);
			data = (uint32 *)localbuf;
			for (i = 0; i < sd->glom_info.count; i++) {
				bcopy(sd->glom_info.dma_buf_arr[i],
					((uint8 *)data + offset),
					sd->glom_info.nbytes[i]);
				offset += sd->glom_info.nbytes[i];
			}
		}
#endif
	}

	if (local_blockmode) {
		blocksize = MIN(sd->client_block_size[func], nbytes);
		num_blocks = nbytes/blocksize;
		cmd_arg = SFIELD(cmd_arg, CMD53_BYTE_BLK_CNT, num_blocks);
		cmd_arg = SFIELD(cmd_arg, CMD53_BLK_MODE, 1);
	} else {
		num_blocks =  1;
		blocksize = nbytes;
		cmd_arg = SFIELD(cmd_arg, CMD53_BYTE_BLK_CNT, nbytes);
		cmd_arg = SFIELD(cmd_arg, CMD53_BLK_MODE, 0);
	}

	if (local_dma && !read) {
#ifdef BCMSDIOH_TXGLOM
		if ((func == SDIO_FUNC_2) && (sd->glom_info.count != 0)) {
			/* In case of hc ver 2 DMA_MAP may not work properly due to 4K alignment
			 * requirements. So copying pkt to 4K aligned pre-allocated pkt.
			 * Total length should not cross the pre-alloced memory size
			 */
			if (sd->txglom_mode == SDPCM_TXGLOM_CPY) {
				uint32 total_bytes = 0;
				for (i = 0; i < sd->glom_info.count; i++) {
					bcopy(sd->glom_info.dma_buf_arr[i],
						(uint8 *)sd->dma_buf + total_bytes,
						sd->glom_info.nbytes[i]);
					total_bytes += sd->glom_info.nbytes[i];
				}
				sd_sync_dma(sd, read, total_bytes);
			}
		} else
#endif /* BCMSDIOH_TXGLOM */
		{
			bcopy(data, sd->dma_buf, nbytes);
			sd_sync_dma(sd, read, nbytes);
		}
	}

	if (fifo)
		cmd_arg = SFIELD(cmd_arg, CMD53_OP_CODE, 0);	/* XXX SDIO spec v 1.10, Sec 5.3  */
	else
		cmd_arg = SFIELD(cmd_arg, CMD53_OP_CODE, 1);	/* XXX SDIO spec v 1.10, Sec 5.3  */

	cmd_arg = SFIELD(cmd_arg, CMD53_FUNCTION, func);
	cmd_arg = SFIELD(cmd_arg, CMD53_REG_ADDR, addr);
	if (read)
		cmd_arg = SFIELD(cmd_arg, CMD53_RW_FLAG, SDIOH_XFER_TYPE_READ);
	else
		cmd_arg = SFIELD(cmd_arg, CMD53_RW_FLAG, SDIOH_XFER_TYPE_WRITE);

	sd->data_xfer_count = nbytes;

	/* sdstd_cmd_issue() returns with the command complete bit
	 * in the ISR already cleared
	 */
	if ((status = sdstd_cmd_issue(sd, local_dma, SDIOH_CMD_53, cmd_arg)) != SUCCESS) {
		sd_err(("%s: cmd_issue failed for %s\n", __FUNCTION__, (read ? "read" : "write")));
		retval = status;
		goto done;
	}

	sdstd_cmd_getrsp(sd, &rsp5, 1);

	if ((flags = GFIELD(rsp5, RSP5_FLAGS)) != 0x10) {
		sd_err(("%s: Rsp5: nbytes %d, dma %d blockmode %d, read %d "
		        "numblocks %d, blocksize %d\n",
		        __FUNCTION__, nbytes, local_dma, local_dma, read, num_blocks, blocksize));

		if (flags & 1)
			sd_err(("%s: rsp5: Command not accepted: arg out of range 0x%x, "
			        "bytes %d dma %d\n",
			        __FUNCTION__, flags, GFIELD(cmd_arg, CMD53_BYTE_BLK_CNT),
			        GFIELD(cmd_arg, CMD53_BLK_MODE)));
		if (flags & 0x8)
			sd_err(("%s: Rsp5: General Error\n", __FUNCTION__));

		sd_err(("%s: rsp5 flags = 0x%x, expecting 0x10 returning error\n",
		        __FUNCTION__,  flags));
		if (trap_errs)
			ASSERT(0);
		retval = ERROR;
		goto done;
	}

	if (GFIELD(rsp5, RSP5_STUFF))
		sd_err(("%s: rsp5 stuff is 0x%x: expecting 0\n",
		        __FUNCTION__, GFIELD(rsp5, RSP5_STUFF)));

#ifdef BCMSDYIELD
	local_yield = sd_yieldcpu && ((uint)nbytes >= sd_minyield);
#endif

	if (!local_dma) {
		int bytes, ii;
		uint32 tmp;

		for (ii = 0; ii < num_blocks; ii++) {
			int words;

			/* Decide which status bit we're waiting for */
			if (read)
				int_bit = SFIELD(0, INTSTAT_BUF_READ_READY, 1);
			else
				int_bit = SFIELD(0, INTSTAT_BUF_WRITE_READY, 1);

			/* If not on, wait for it (or for xfer error) */
			int_reg = sdstd_rreg16(sd, SD_IntrStatus);
			if (!(int_reg & int_bit)) {
				status = sdstd_waitbits(sd, int_bit, ERRINT_TRANSFER_ERRS,
				                        local_yield, &int_reg);
				switch (status) {
				case -1:
					sd_err(("%s: pio interrupted\n", __FUNCTION__));
					retval = ERROR;
					goto done;
				case -2:
					sd_err(("%s: pio timeout waiting for interrupt\n",
					        __FUNCTION__));
					retval = ERROR;
					goto done;
				}
			}
#ifdef BCMSLTGT
		/*	int_reg = sdstd_rreg16(sd, SD_IntrStatus); */
#endif
			/* Confirm we got the bit w/o error */
			if (!(int_reg & int_bit) || GFIELD(int_reg, INTSTAT_ERROR_INT)) {
				sd_err(("%s: Error or timeout for Buf_%s_Ready: intStat: 0x%x "
				        "errint: 0x%x PresentState 0x%x\n",
				        __FUNCTION__, read ? "Read" : "Write", int_reg,
				        sdstd_rreg16(sd, SD_ErrorIntrStatus),
				        sdstd_rreg(sd, SD_PresentState)));
				sdstd_dumpregs(sd);
				sdstd_check_errs(sd, SDIOH_CMD_53, cmd_arg);
				retval = ERROR;
				goto done;
			}

			/* Clear Buf Ready bit */
			sdstd_wreg16(sd, SD_IntrStatus, int_bit);

			/* At this point we have Buffer Ready, write the data 4 bytes at a time */
			for (words = blocksize/4; words; words--) {
				if (read)
					*data = sdstd_rreg(sd, SD_BufferDataPort0);
				else
					sdstd_wreg(sd, SD_BufferDataPort0, *data);
				data++;
			}

			/* XXX
			 * Handle < 4 bytes.  wlc_pio.c currently (as of 12/20/05) truncates buflen
			 * to be evenly divisible by 4.  However dongle passes arbitrary lengths,
			 * so handle it here
			 */
			bytes = blocksize % 4;

			/* If no leftover bytes, go to next block */
			if (!bytes)
				continue;

			switch (bytes) {
			case 1:
				/* R/W 8 bits */
				if (read)
					*(data++) = (uint32)(sdstd_rreg8(sd, SD_BufferDataPort0));
				else
					sdstd_wreg8(sd, SD_BufferDataPort0,
					            (uint8)(*(data++) & 0xff));
				break;
			case 2:
				/* R/W 16 bits */
				if (read)
					*(data++) = (uint32)sdstd_rreg16(sd, SD_BufferDataPort0);
				else
					sdstd_wreg16(sd, SD_BufferDataPort0, (uint16)(*(data++)));
				break;
			case 3:
				/* R/W 24 bits:
				 * SD_BufferDataPort0[0-15] | SD_BufferDataPort1[16-23]
				 */
				if (read) {
					tmp = (uint32)sdstd_rreg16(sd, SD_BufferDataPort0);
					tmp |= ((uint32)(sdstd_rreg8(sd,
					                             SD_BufferDataPort1)) << 16);
					*(data++) = tmp;
				} else {
					tmp = *(data++);
					sdstd_wreg16(sd, SD_BufferDataPort0, (uint16)tmp & 0xffff);
					sdstd_wreg8(sd, SD_BufferDataPort1,
					            (uint8)((tmp >> 16) & 0xff));
				}
				break;
			default:
				sd_err(("%s: Unexpected bytes leftover %d\n",
				        __FUNCTION__, bytes));
				ASSERT(0);
				break;
			}
		}
	}	/* End PIO processing */

	/* Wait for Transfer Complete or Transfer Error */
	int_bit = SFIELD(0, INTSTAT_XFER_COMPLETE, 1);

	/* If not on, wait for it (or for xfer error) */
	int_reg = sdstd_rreg16(sd, SD_IntrStatus);
	if (!(int_reg & int_bit)) {
		status = sdstd_waitbits(sd, int_bit, ERRINT_TRANSFER_ERRS, local_yield, &int_reg);
		switch (status) {
		case -1:
			sd_err(("%s: interrupted\n", __FUNCTION__));
			retval = ERROR;
			goto done;
		case -2:
			sd_err(("%s: timeout waiting for interrupt\n", __FUNCTION__));
			retval = ERROR;
			goto done;
		}
	}

	/* Check for any errors from the data phase */
	if (sdstd_check_errs(sd, SDIOH_CMD_53, cmd_arg)) {
		retval = ERROR;
		goto done;
	}

	/* May have gotten a software timeout if not blocking? */
	int_reg = sdstd_rreg16(sd, SD_IntrStatus);
	if (!(int_reg & int_bit)) {
		sd_err(("%s: Error or Timeout for xfer complete; %s, dma %d, State 0x%08x, "
		        "intr 0x%04x, Err 0x%04x, len = %d, rcnt %d, tcnt %d\n",
		        __FUNCTION__, read ? "R" : "W", local_dma,
		        sdstd_rreg(sd, SD_PresentState), int_reg,
		        sdstd_rreg16(sd, SD_ErrorIntrStatus), nbytes,
		        sd->r_cnt, sd->t_cnt));
		sdstd_dumpregs(sd);
		retval = ERROR;
		goto done;
	}

	/* Clear the status bits */
	int_reg = int_bit;
	if (local_dma) {
		/* DMA Complete */
		/* XXX Step 14, Section 3.6.2.2 Stnd Cntrlr Spec */
		/* Reads in particular don't have DMA_COMPLETE set */
		int_reg = SFIELD(int_reg, INTSTAT_DMA_INT, 1);
	}
	sdstd_wreg16(sd, SD_IntrStatus, int_reg);

	/* Fetch data */
	if (local_dma && read) {
		sd_sync_dma(sd, read, nbytes);
		bcopy(sd->dma_buf, data, nbytes);
	}

done:
#ifdef BCMSDIOH_TXGLOM
	if (localbuf)
		MFREE(sd->osh, localbuf, nbytes);
#endif
	return retval;
}

static int
set_client_block_size(sdioh_info_t *sd, int func, int block_size)
{
	int base;
	int err = 0;

	sd_err(("%s: Setting block size %d, func %d\n", __FUNCTION__, block_size, func));
	sd->client_block_size[func] = block_size;

	/* Set the block size in the SDIO Card register */
	base = func * SDIOD_FBR_SIZE;
	err = sdstd_card_regwrite(sd, 0, base+SDIOD_CCCR_BLKSIZE_0, 1, block_size & 0xff);
	if (!err) {
		err = sdstd_card_regwrite(sd, 0, base+SDIOD_CCCR_BLKSIZE_1, 1,
		                          (block_size >> 8) & 0xff);
	}

	/* Do not set the block size in the SDIO Host register, that
	 * is func dependent and will get done on an individual
	 * transaction basis
	 */

	return (err ? BCME_SDIO_ERROR : 0);
}

/* Reset and re-initialize the device */
int
sdioh_sdio_reset(sdioh_info_t *si)
{
	uint8 hreg;

	/* Reset the attached device (use slower clock for safety) */
	if (!sdstd_start_clock(si, 128)) {
			sd_err(("set clock failed!\n"));
			return ERROR;
			}
	sdstd_reset(si, 0, 1);

	/* Reset portions of the host state accordingly */
	hreg = sdstd_rreg8(si, SD_HostCntrl);
	hreg = SFIELD(hreg, HOST_HI_SPEED_EN, 0);
	hreg = SFIELD(hreg, HOST_DATA_WIDTH, 0);
	si->sd_mode = SDIOH_MODE_SD1;

	/* Reinitialize the card */
	si->card_init_done = FALSE;
	return sdstd_client_init(si);
}

#ifdef BCMINTERNAL
#ifdef NOTUSED
static void
cis_fetch(sdioh_info_t *sd, int func, char *data, int len)
{
	int count;
	int offset;
	char *end = data + len;
	uint32 foo;

	for (count = 0; count < 512 && data < end; count++) {
		offset =  sd->func_cis_ptr[func] + count;
		if (sdstd_card_regread (sd, func, offset, 1, &foo) < 0) {
			sd_err(("%s: regread failed\n", __FUNCTION__));
			return;
		}
		data += sprintf(data, "%.2x ", foo & 0xff);
		if (((count+1) % 16) == 0)
			data += sprintf(data, "\n");
	}
}
#endif /* NOTUSED */
#endif /* BCMINTERNAL */

static void
sd_map_dma(sdioh_info_t * sd)
{

	int alloced;
	void *va;
	uint dma_buf_size = SD_PAGE;

#ifdef BCMSDIOH_TXGLOM
	/* There is no alignment requirement for HC3 */
	if ((sd->version == HOST_CONTR_VER_3) && sd_txglom) {
		/* Max glom packet length is 64KB */
		dma_buf_size = SD_PAGE * 16;
	}
#endif

	alloced = 0;
	if ((va = DMA_ALLOC_CONSISTENT(sd->osh, dma_buf_size, SD_PAGE_BITS, &alloced,
		&sd->dma_start_phys, 0x12)) == NULL) {
		sd->sd_dma_mode = DMA_MODE_NONE;
		sd->dma_start_buf = 0;
		sd->dma_buf = (void *)0;
		sd->dma_phys = 0;
		sd->alloced_dma_size = 0;
		sd_err(("%s: DMA_ALLOC failed. Disabling DMA support.\n", __FUNCTION__));
	} else {
		sd->dma_start_buf = va;
		sd->dma_buf = (void *)ROUNDUP((uintptr)va, SD_PAGE);
		sd->dma_phys = ROUNDUP((sd->dma_start_phys), SD_PAGE);
		sd->alloced_dma_size = alloced;
		sd_err(("%s: Mapped DMA Buffer %dbytes @virt/phys: %p/0x%x-0x%x\n",
		        __FUNCTION__, sd->alloced_dma_size, sd->dma_buf,
		        (uint)PHYSADDRHI(sd->dma_phys), (uint)PHYSADDRLO(sd->dma_phys)));
		sd_fill_dma_data_buf(sd, 0xA5);
	}

	if ((va = DMA_ALLOC_CONSISTENT(sd->osh, SD_PAGE, SD_PAGE_BITS, &alloced,
		&sd->adma2_dscr_start_phys, 0x12)) == NULL) {
		sd->sd_dma_mode = DMA_MODE_NONE;
		sd->adma2_dscr_start_buf = 0;
		sd->adma2_dscr_buf = (void *)0;
		sd->adma2_dscr_phys = 0;
		sd->alloced_adma2_dscr_size = 0;
		sd_err(("%s: DMA_ALLOC failed for descriptor buffer. "
		        "Disabling DMA support.\n", __FUNCTION__));
	} else {
		sd->adma2_dscr_start_buf = va;
		sd->adma2_dscr_buf = (void *)ROUNDUP((uintptr)va, SD_PAGE);
		sd->adma2_dscr_phys = ROUNDUP((sd->adma2_dscr_start_phys), SD_PAGE);
		sd->alloced_adma2_dscr_size = alloced;
		sd_err(("%s: Mapped ADMA2 Descriptor Buffer %dbytes @virt/phys: %p/0x%x-0x%x\n",
		        __FUNCTION__, sd->alloced_adma2_dscr_size, sd->adma2_dscr_buf,
		        (uint)PHYSADDRHI(sd->adma2_dscr_phys),
			(uint)PHYSADDRLO(sd->adma2_dscr_phys)));
		sd_clear_adma_dscr_buf(sd);
	}
}

static void
sd_unmap_dma(sdioh_info_t * sd)
{
	if (sd->dma_start_buf) {
		DMA_FREE_CONSISTENT(sd->osh, sd->dma_start_buf, sd->alloced_dma_size,
			sd->dma_start_phys, 0x12);
	}

	if (sd->adma2_dscr_start_buf) {
		DMA_FREE_CONSISTENT(sd->osh, sd->adma2_dscr_start_buf, sd->alloced_adma2_dscr_size,
		                    sd->adma2_dscr_start_phys, 0x12);
	}
}

static void
sd_clear_adma_dscr_buf(sdioh_info_t *sd)
{
	bzero((char *)sd->adma2_dscr_buf, SD_PAGE);
	sd_dump_adma_dscr(sd);
}

static void
sd_fill_dma_data_buf(sdioh_info_t *sd, uint8 data)
{
	memset((char *)sd->dma_buf, data, SD_PAGE);
}

static void
sd_create_adma_descriptor(sdioh_info_t *sd, uint32 index,
                          uint32 addr_phys, uint16 length, uint16 flags)
{
	adma2_dscr_32b_t *adma2_dscr_table;
	adma1_dscr_t *adma1_dscr_table;

	adma2_dscr_table = sd->adma2_dscr_buf;
	adma1_dscr_table = sd->adma2_dscr_buf;

	switch (sd->sd_dma_mode) {
		case DMA_MODE_ADMA2:
			sd_dma(("%s: creating ADMA2 descriptor for index %d\n",
				__FUNCTION__, index));

			adma2_dscr_table[index].phys_addr = addr_phys;
			adma2_dscr_table[index].len_attr = length << 16;
			adma2_dscr_table[index].len_attr |= flags;
			break;
		case DMA_MODE_ADMA1:
			/* ADMA1 requires two descriptors, one for len
			 * and the other for data transfer
			 */
			index <<= 1;

			sd_dma(("%s: creating ADMA1 descriptor for index %d\n",
				__FUNCTION__, index));

			adma1_dscr_table[index].phys_addr_attr = length << 12;
			adma1_dscr_table[index].phys_addr_attr |= (ADMA1_ATTRIBUTE_ACT_SET |
			                                           ADMA2_ATTRIBUTE_VALID);
			adma1_dscr_table[index+1].phys_addr_attr = addr_phys & 0xFFFFF000;
			adma1_dscr_table[index+1].phys_addr_attr |= (flags & 0x3f);
			break;
		default:
			sd_err(("%s: cannot create ADMA descriptor for DMA mode %d\n",
				__FUNCTION__, sd->sd_dma_mode));
			break;
	}
}

static void
sd_dump_adma_dscr(sdioh_info_t *sd)
{
	adma2_dscr_32b_t *adma2_dscr_table;
	adma1_dscr_t *adma1_dscr_table;
	uint32 i = 0;
	uint16 flags;
	char flags_str[32];

	ASSERT(sd->adma2_dscr_buf != NULL);

	adma2_dscr_table = sd->adma2_dscr_buf;
	adma1_dscr_table = sd->adma2_dscr_buf;

	switch (sd->sd_dma_mode) {
		case DMA_MODE_ADMA2:
			sd_err(("ADMA2 Descriptor Table (%dbytes) @virt/phys: %p/0x%x-0x%x\n",
				SD_PAGE, sd->adma2_dscr_buf,
			        (uint)PHYSADDRHI(sd->adma2_dscr_phys),
			        (uint)PHYSADDRLO(sd->adma2_dscr_phys)));
			sd_err((" #[Descr VA  ]  Buffer PA  | Len    | Flags  (5:4  2   1   0)"
			        "     |\n"));
			while (adma2_dscr_table->len_attr & ADMA2_ATTRIBUTE_VALID) {
				flags = adma2_dscr_table->len_attr & 0xFFFF;
				sprintf(flags_str, "%s%s%s%s",
					((flags & ADMA2_ATTRIBUTE_ACT_LINK) ==
					ADMA2_ATTRIBUTE_ACT_LINK) ? "LINK " :
					((flags & ADMA2_ATTRIBUTE_ACT_LINK) ==
					ADMA2_ATTRIBUTE_ACT_TRAN) ? "TRAN " :
					((flags & ADMA2_ATTRIBUTE_ACT_LINK) ==
					ADMA2_ATTRIBUTE_ACT_NOP) ? "NOP  " : "RSV  ",
					(flags & ADMA2_ATTRIBUTE_INT ? "INT " : "    "),
					(flags & ADMA2_ATTRIBUTE_END ? "END " : "    "),
					(flags & ADMA2_ATTRIBUTE_VALID ? "VALID" : ""));
				sd_err(("%2d[0x%p]: 0x%08x | 0x%04x | 0x%04x (%s) |\n",
				        i, adma2_dscr_table, adma2_dscr_table->phys_addr,
				        adma2_dscr_table->len_attr >> 16, flags, flags_str));
				i++;

#ifdef linux
				/* Follow LINK descriptors or skip to next. */
				if ((flags & ADMA2_ATTRIBUTE_ACT_LINK) ==
				     ADMA2_ATTRIBUTE_ACT_LINK) {
					adma2_dscr_table = phys_to_virt(
					    adma2_dscr_table->phys_addr);
				} else {
					adma2_dscr_table++;
				}
#else
				adma2_dscr_table++;
#endif /* linux */

			}
			break;
		case DMA_MODE_ADMA1:
			sd_err(("ADMA1 Descriptor Table (%dbytes) @virt/phys: %p/0x%x-0x%x\n",
			         SD_PAGE, sd->adma2_dscr_buf,
			        (uint)PHYSADDRHI(sd->adma2_dscr_phys),
			        (uint)PHYSADDRLO(sd->adma2_dscr_phys)));
			sd_err((" #[Descr VA  ]  Buffer PA  | Flags  (5:4  2   1   0)     |\n"));

			for (i = 0; adma1_dscr_table->phys_addr_attr & ADMA2_ATTRIBUTE_VALID; i++) {
				flags = adma1_dscr_table->phys_addr_attr & 0x3F;
				sprintf(flags_str, "%s%s%s%s",
					((flags & ADMA2_ATTRIBUTE_ACT_LINK) ==
					ADMA2_ATTRIBUTE_ACT_LINK) ? "LINK " :
					((flags & ADMA2_ATTRIBUTE_ACT_LINK) ==
					ADMA2_ATTRIBUTE_ACT_TRAN) ? "TRAN " :
					((flags & ADMA2_ATTRIBUTE_ACT_LINK) ==
					ADMA2_ATTRIBUTE_ACT_NOP) ? "NOP  " : "SET  ",
					(flags & ADMA2_ATTRIBUTE_INT ? "INT " : "    "),
					(flags & ADMA2_ATTRIBUTE_END ? "END " : "    "),
					(flags & ADMA2_ATTRIBUTE_VALID ? "VALID" : ""));
				sd_err(("%2d[0x%p]: 0x%08x | 0x%04x | (%s) |\n",
				        i, adma1_dscr_table,
				        adma1_dscr_table->phys_addr_attr & 0xFFFFF000,
				        flags, flags_str));

#ifdef linux
				/* Follow LINK descriptors or skip to next. */
				if ((flags & ADMA2_ATTRIBUTE_ACT_LINK) ==
				     ADMA2_ATTRIBUTE_ACT_LINK) {
					adma1_dscr_table = phys_to_virt(
						adma1_dscr_table->phys_addr_attr & 0xFFFFF000);
				} else {
					adma1_dscr_table++;
				}
#else
				adma2_dscr_table++;
#endif /* linux */
			}
			break;
		default:
			sd_err(("Unknown DMA Descriptor Table Format.\n"));
			break;
	}
}

static void
sdstd_dumpregs(sdioh_info_t *sd)
{
	sd_err(("IntrStatus:       0x%04x ErrorIntrStatus       0x%04x\n",
	            sdstd_rreg16(sd, SD_IntrStatus),
	            sdstd_rreg16(sd, SD_ErrorIntrStatus)));
	sd_err(("IntrStatusEnable: 0x%04x ErrorIntrStatusEnable 0x%04x\n",
	            sdstd_rreg16(sd, SD_IntrStatusEnable),
	            sdstd_rreg16(sd, SD_ErrorIntrStatusEnable)));
	sd_err(("IntrSignalEnable: 0x%04x ErrorIntrSignalEnable 0x%04x\n",
	            sdstd_rreg16(sd, SD_IntrSignalEnable),
	            sdstd_rreg16(sd, SD_ErrorIntrSignalEnable)));
}
