Commit 54ca2969 authored by Roland Vossen's avatar Roland Vossen Committed by Greg Kroah-Hartman
Browse files

staging: brcm80211: replaced prefix of SDIO related functions 



Code cleanup. Prefixed functions with brcmf_ for unique namespace. In addition
to that, prefix has been changed to categorize functions depending on their
place in the drivers SDIO stack.

Signed-off-by: default avatarRoland Vossen <rvossen@broadcom.com>
Reviewed-by: default avatarArend van Spriel <arend@broadcom.com>
Reviewed-by: default avatarFranky Lin <frankyl@broadcom.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 7faf8c5b

drivers/staging/brcm80211/brcmfmac/bcmsdbus.h

+25 −23
Original line number Diff line number Diff line
@@ -48,68 +48,70 @@ typedef void (*sdioh_cb_fn_t) (void *); 
 *  The handler shall be provided by all subsequent calls. No local cache

 *  cfghdl points to the starting address of pci device mapped memory

 */

extern sdioh_info_t *sdioh_attach(void *cfghdl, uint irq);

extern SDIOH_API_RC sdioh_detach(sdioh_info_t *si);

extern SDIOH_API_RC sdioh_interrupt_register(sdioh_info_t *si,

extern sdioh_info_t *brcmf_sdioh_attach(void *cfghdl, uint irq);

extern SDIOH_API_RC brcmf_sdioh_detach(sdioh_info_t *si);

extern SDIOH_API_RC brcmf_sdioh_interrupt_register(sdioh_info_t *si,

					     sdioh_cb_fn_t fn, void *argh);

extern SDIOH_API_RC sdioh_interrupt_deregister(sdioh_info_t *si);

extern SDIOH_API_RC brcmf_sdioh_interrupt_deregister(sdioh_info_t *si);



/* query whether SD interrupt is enabled or not */

extern SDIOH_API_RC sdioh_interrupt_query(sdioh_info_t *si, bool *onoff);

extern SDIOH_API_RC brcmf_sdioh_interrupt_query(sdioh_info_t *si, bool *onoff);



/* enable or disable SD interrupt */

extern SDIOH_API_RC sdioh_interrupt_set(sdioh_info_t *si, bool enable_disable);

extern SDIOH_API_RC

brcmf_sdioh_interrupt_set(sdioh_info_t *si, bool enable_disable);



#if defined(DHD_DEBUG)

extern bool sdioh_interrupt_pending(sdioh_info_t *si);

extern bool brcmf_sdioh_interrupt_pending(sdioh_info_t *si);

#endif



extern int sdioh_claim_host_and_lock(sdioh_info_t *si);

extern int sdioh_release_host_and_unlock(sdioh_info_t *si);

extern int brcmf_sdioh_claim_host_and_lock(sdioh_info_t *si);

extern int brcmf_sdioh_release_host_and_unlock(sdioh_info_t *si);



/* read or write one byte using cmd52 */

extern SDIOH_API_RC sdioh_request_byte(sdioh_info_t *si, uint rw, uint fnc,

				       uint addr, u8 *byte);

extern SDIOH_API_RC

brcmf_sdioh_request_byte(sdioh_info_t *si, uint rw, uint fnc, uint addr,

			 u8 *byte);



/* read or write 2/4 bytes using cmd53 */

extern SDIOH_API_RC sdioh_request_word(sdioh_info_t *si, uint cmd_type,

extern SDIOH_API_RC brcmf_sdioh_request_word(sdioh_info_t *si, uint cmd_type,

				       uint rw, uint fnc, uint addr,

				       u32 *word, uint nbyte);



/* read or write any buffer using cmd53 */

extern SDIOH_API_RC sdioh_request_buffer(sdioh_info_t *si, uint pio_dma,

extern SDIOH_API_RC brcmf_sdioh_request_buffer(sdioh_info_t *si, uint pio_dma,

					 uint fix_inc, uint rw, uint fnc_num,

					 u32 addr, uint regwidth,

					 u32 buflen, u8 *buffer,

					 struct sk_buff *pkt);



/* get cis data */

extern SDIOH_API_RC sdioh_cis_read(sdioh_info_t *si, uint fuc, u8 *cis,

extern SDIOH_API_RC brcmf_sdioh_cis_read(sdioh_info_t *si, uint fuc, u8 *cis,

				   u32 length);



extern SDIOH_API_RC sdioh_cfg_read(sdioh_info_t *si, uint fuc, u32 addr,

extern SDIOH_API_RC brcmf_sdioh_cfg_read(sdioh_info_t *si, uint fuc, u32 addr,

				   u8 *data);

extern SDIOH_API_RC sdioh_cfg_write(sdioh_info_t *si, uint fuc, u32 addr,

extern SDIOH_API_RC brcmf_sdioh_cfg_write(sdioh_info_t *si, uint fuc, u32 addr,

				    u8 *data);



/* query number of io functions */

extern uint sdioh_query_iofnum(sdioh_info_t *si);

extern uint brcmf_sdioh_query_iofnum(sdioh_info_t *si);



/* handle iovars */

extern int sdioh_iovar_op(sdioh_info_t *si, const char *name,

extern int brcmf_sdioh_iovar_op(sdioh_info_t *si, const char *name,

			  void *params, int plen, void *arg, int len, bool set);



/* Issue abort to the specified function and clear controller as needed */

extern int sdioh_abort(sdioh_info_t *si, uint fnc);

extern int brcmf_sdioh_abort(sdioh_info_t *si, uint fnc);



/* Start and Stop SDIO without re-enumerating the SD card. */

extern int sdioh_start(sdioh_info_t *si, int stage);

extern int sdioh_stop(sdioh_info_t *si);

extern int brcmf_sdioh_start(sdioh_info_t *si, int stage);

extern int brcmf_sdioh_stop(sdioh_info_t *si);



/* Reset and re-initialize the device */

extern int sdioh_sdio_reset(sdioh_info_t *si);

extern int brcmf_sdioh_reset(sdioh_info_t *si);



/* Helper function */

void *bcmsdh_get_sdioh(bcmsdh_info_t *sdh);

void *brcmf_sdcard_get_sdioh(bcmsdh_info_t *sdh);



#endif				/* _sdio_api_h_ */

drivers/staging/brcm80211/brcmfmac/bcmsdh.c

+79 −79
Original line number Diff line number Diff line
@@ -45,15 +45,15 @@ struct bcmsdh_info { 
bcmsdh_info_t *l_bcmsdh;



#if defined(OOB_INTR_ONLY) && defined(HW_OOB)

extern int sdioh_enable_hw_oob_intr(void *sdioh, bool enable);

extern int brcmf_sdioh_enable_hw_oob_intr(void *sdioh, bool enable);



void bcmsdh_enable_hw_oob_intr(bcmsdh_info_t *sdh, bool enable)

void brcmf_sdcard_enable_hw_oob_intr(bcmsdh_info_t *sdh, bool enable)

{

	sdioh_enable_hw_oob_intr(sdh->sdioh, enable);

	brcmf_sdioh_enable_hw_oob_intr(sdh->sdioh, enable);

}

#endif



bcmsdh_info_t *bcmsdh_attach(void *cfghdl, void **regsva, uint irq)

bcmsdh_info_t *brcmf_sdcard_attach(void *cfghdl, void **regsva, uint irq)

{

	bcmsdh_info_t *bcmsdh;
@@ -66,9 +66,9 @@ bcmsdh_info_t *bcmsdh_attach(void *cfghdl, void **regsva, uint irq) 
	/* save the handler locally */

	l_bcmsdh = bcmsdh;



	bcmsdh->sdioh = sdioh_attach(cfghdl, irq);

	bcmsdh->sdioh = brcmf_sdioh_attach(cfghdl, irq);

	if (!bcmsdh->sdioh) {

		bcmsdh_detach(bcmsdh);

		brcmf_sdcard_detach(bcmsdh);

		return NULL;

	}
@@ -81,13 +81,13 @@ bcmsdh_info_t *bcmsdh_attach(void *cfghdl, void **regsva, uint irq) 
	return bcmsdh;

}



int bcmsdh_detach(void *sdh)

int brcmf_sdcard_detach(void *sdh)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;



	if (bcmsdh != NULL) {

		if (bcmsdh->sdioh) {

			sdioh_detach(bcmsdh->sdioh);

			brcmf_sdioh_detach(bcmsdh->sdioh);

			bcmsdh->sdioh = NULL;

		}

		kfree(bcmsdh);
@@ -98,78 +98,79 @@ int bcmsdh_detach(void *sdh) 
}



int

bcmsdh_iovar_op(void *sdh, const char *name,

brcmf_sdcard_iovar_op(void *sdh, const char *name,

		void *params, int plen, void *arg, int len, bool set)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	return sdioh_iovar_op(bcmsdh->sdioh, name, params, plen, arg, len, set);

	return brcmf_sdioh_iovar_op(bcmsdh->sdioh, name, params, plen, arg,

				    len, set);

}



bool bcmsdh_intr_query(void *sdh)

bool brcmf_sdcard_intr_query(void *sdh)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	SDIOH_API_RC status;

	bool on;



	ASSERT(bcmsdh);

	status = sdioh_interrupt_query(bcmsdh->sdioh, &on);

	status = brcmf_sdioh_interrupt_query(bcmsdh->sdioh, &on);

	if (SDIOH_API_SUCCESS(status))

		return false;

	else

		return on;

}



int bcmsdh_intr_enable(void *sdh)

int brcmf_sdcard_intr_enable(void *sdh)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	SDIOH_API_RC status;

	ASSERT(bcmsdh);



	status = sdioh_interrupt_set(bcmsdh->sdioh, true);

	status = brcmf_sdioh_interrupt_set(bcmsdh->sdioh, true);

	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;

}



int bcmsdh_intr_disable(void *sdh)

int brcmf_sdcard_intr_disable(void *sdh)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	SDIOH_API_RC status;

	ASSERT(bcmsdh);



	status = sdioh_interrupt_set(bcmsdh->sdioh, false);

	status = brcmf_sdioh_interrupt_set(bcmsdh->sdioh, false);

	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;

}



int bcmsdh_intr_reg(void *sdh, bcmsdh_cb_fn_t fn, void *argh)

int brcmf_sdcard_intr_reg(void *sdh, bcmsdh_cb_fn_t fn, void *argh)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	SDIOH_API_RC status;

	ASSERT(bcmsdh);



	status = sdioh_interrupt_register(bcmsdh->sdioh, fn, argh);

	status = brcmf_sdioh_interrupt_register(bcmsdh->sdioh, fn, argh);

	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;

}



int bcmsdh_intr_dereg(void *sdh)

int brcmf_sdcard_intr_dereg(void *sdh)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	SDIOH_API_RC status;

	ASSERT(bcmsdh);



	status = sdioh_interrupt_deregister(bcmsdh->sdioh);

	status = brcmf_sdioh_interrupt_deregister(bcmsdh->sdioh);

	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;

}



#if defined(DHD_DEBUG)

bool bcmsdh_intr_pending(void *sdh)

bool brcmf_sdcard_intr_pending(void *sdh)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;



	ASSERT(sdh);

	return sdioh_interrupt_pending(bcmsdh->sdioh);

	return brcmf_sdioh_interrupt_pending(bcmsdh->sdioh);

}

#endif



int bcmsdh_devremove_reg(void *sdh, bcmsdh_cb_fn_t fn, void *argh)

int brcmf_sdcard_devremove_reg(void *sdh, bcmsdh_cb_fn_t fn, void *argh)

{

	ASSERT(sdh);
@@ -177,7 +178,7 @@ int bcmsdh_devremove_reg(void *sdh, bcmsdh_cb_fn_t fn, void *argh) 
	return -ENOTSUPP;

}



u8 bcmsdh_cfg_read(void *sdh, uint fnc_num, u32 addr, int *err)

u8 brcmf_sdcard_cfg_read(void *sdh, uint fnc_num, u32 addr, int *err)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	SDIOH_API_RC status;
@@ -197,7 +198,7 @@ u8 bcmsdh_cfg_read(void *sdh, uint fnc_num, u32 addr, int *err) 
			udelay(1000);

#endif

		status =

		    sdioh_cfg_read(bcmsdh->sdioh, fnc_num, addr,

		    brcmf_sdioh_cfg_read(bcmsdh->sdioh, fnc_num, addr,

				   (u8 *) &data);

#ifdef SDIOH_API_ACCESS_RETRY_LIMIT

	} while (!SDIOH_API_SUCCESS(status)
@@ -213,7 +214,7 @@ u8 bcmsdh_cfg_read(void *sdh, uint fnc_num, u32 addr, int *err) 
}



void

bcmsdh_cfg_write(void *sdh, uint fnc_num, u32 addr, u8 data, int *err)

brcmf_sdcard_cfg_write(void *sdh, uint fnc_num, u32 addr, u8 data, int *err)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	SDIOH_API_RC status;
@@ -232,7 +233,7 @@ bcmsdh_cfg_write(void *sdh, uint fnc_num, u32 addr, u8 data, int *err) 
			udelay(1000);

#endif

		status =

		    sdioh_cfg_write(bcmsdh->sdioh, fnc_num, addr,

		    brcmf_sdioh_cfg_write(bcmsdh->sdioh, fnc_num, addr,

				    (u8 *) &data);

#ifdef SDIOH_API_ACCESS_RETRY_LIMIT

	} while (!SDIOH_API_SUCCESS(status)
@@ -245,7 +246,7 @@ bcmsdh_cfg_write(void *sdh, uint fnc_num, u32 addr, u8 data, int *err) 
		     __func__, fnc_num, addr, data));

}



u32 bcmsdh_cfg_read_word(void *sdh, uint fnc_num, u32 addr, int *err)

u32 brcmf_sdcard_cfg_read_word(void *sdh, uint fnc_num, u32 addr, int *err)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	SDIOH_API_RC status;
@@ -256,9 +257,8 @@ u32 bcmsdh_cfg_read_word(void *sdh, uint fnc_num, u32 addr, int *err) 


	ASSERT(bcmsdh->init_success);



	status =

	    sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL, SDIOH_READ,

			       fnc_num, addr, &data, 4);

	status = brcmf_sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,

		SDIOH_READ, fnc_num, addr, &data, 4);



	if (err)

		*err = (SDIOH_API_SUCCESS(status) ? 0 : -EIO);
@@ -270,7 +270,7 @@ u32 bcmsdh_cfg_read_word(void *sdh, uint fnc_num, u32 addr, int *err) 
}



void

bcmsdh_cfg_write_word(void *sdh, uint fnc_num, u32 addr, u32 data,

brcmf_sdcard_cfg_write_word(void *sdh, uint fnc_num, u32 addr, u32 data,

		      int *err)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
@@ -282,7 +282,7 @@ bcmsdh_cfg_write_word(void *sdh, uint fnc_num, u32 addr, u32 data, 
	ASSERT(bcmsdh->init_success);



	status =

	    sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,

	    brcmf_sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,

			       SDIOH_WRITE, fnc_num, addr, &data, 4);



	if (err)
@@ -292,7 +292,7 @@ bcmsdh_cfg_write_word(void *sdh, uint fnc_num, u32 addr, u32 data, 
		     __func__, fnc_num, addr, data));

}



int bcmsdh_cis_read(void *sdh, uint func, u8 * cis, uint length)

int brcmf_sdcard_cis_read(void *sdh, uint func, u8 * cis, uint length)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	SDIOH_API_RC status;
@@ -309,7 +309,7 @@ int bcmsdh_cis_read(void *sdh, uint func, u8 * cis, uint length) 
	ASSERT(cis);

	ASSERT(length <= SBSDIO_CIS_SIZE_LIMIT);



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

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



	if (ascii) {

		/* Move binary bits to tmp and format them
@@ -332,24 +332,27 @@ int bcmsdh_cis_read(void *sdh, uint func, u8 * cis, uint length) 
	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;

}



static int bcmsdhsdio_set_sbaddr_window(void *sdh, u32 address)

static int brcmf_sdcard_set_sbaddr_window(void *sdh, u32 address)

{

	int err = 0;

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	bcmsdh_cfg_write(bcmsdh, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRLOW,

	brcmf_sdcard_cfg_write(bcmsdh, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRLOW,

			 (address >> 8) & SBSDIO_SBADDRLOW_MASK, &err);

	if (!err)

		bcmsdh_cfg_write(bcmsdh, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRMID,

				 (address >> 16) & SBSDIO_SBADDRMID_MASK, &err);

		brcmf_sdcard_cfg_write(bcmsdh, SDIO_FUNC_1,

				       SBSDIO_FUNC1_SBADDRMID,

				       (address >> 16) & SBSDIO_SBADDRMID_MASK,

				       &err);

	if (!err)

		bcmsdh_cfg_write(bcmsdh, SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRHIGH,

		brcmf_sdcard_cfg_write(bcmsdh, SDIO_FUNC_1,

				       SBSDIO_FUNC1_SBADDRHIGH,

				       (address >> 24) & SBSDIO_SBADDRHIGH_MASK,

				       &err);



	return err;

}



u32 bcmsdh_reg_read(void *sdh, u32 addr, uint size)

u32 brcmf_sdcard_reg_read(void *sdh, u32 addr, uint size)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	SDIOH_API_RC status;
@@ -364,7 +367,7 @@ u32 bcmsdh_reg_read(void *sdh, u32 addr, uint size) 
	ASSERT(bcmsdh->init_success);



	if (bar0 != bcmsdh->sbwad) {

		if (bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0))

		if (brcmf_sdcard_set_sbaddr_window(bcmsdh, bar0))

			return 0xFFFFFFFF;



		bcmsdh->sbwad = bar0;
@@ -374,7 +377,7 @@ u32 bcmsdh_reg_read(void *sdh, u32 addr, uint size) 
	if (size == 4)

		addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;



	status = sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,

	status = brcmf_sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,

				    SDIOH_READ, SDIO_FUNC_1, addr, &word, size);



	bcmsdh->regfail = !(SDIOH_API_SUCCESS(status));
@@ -402,7 +405,7 @@ u32 bcmsdh_reg_read(void *sdh, u32 addr, uint size) 
	return 0xFFFFFFFF;

}



u32 bcmsdh_reg_write(void *sdh, u32 addr, uint size, u32 data)

u32 brcmf_sdcard_reg_write(void *sdh, u32 addr, uint size, u32 data)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	SDIOH_API_RC status;
@@ -418,7 +421,7 @@ u32 bcmsdh_reg_write(void *sdh, u32 addr, uint size, u32 data) 
	ASSERT(bcmsdh->init_success);



	if (bar0 != bcmsdh->sbwad) {

		err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0);

		err = brcmf_sdcard_set_sbaddr_window(bcmsdh, bar0);

		if (err)

			return err;
@@ -429,7 +432,7 @@ u32 bcmsdh_reg_write(void *sdh, u32 addr, uint size, u32 data) 
	if (size == 4)

		addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;

	status =

	    sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,

	    brcmf_sdioh_request_word(bcmsdh->sdioh, SDIOH_CMD_TYPE_NORMAL,

			       SDIOH_WRITE, SDIO_FUNC_1, addr, &data, size);

	bcmsdh->regfail = !(SDIOH_API_SUCCESS(status));
@@ -441,13 +444,13 @@ u32 bcmsdh_reg_write(void *sdh, u32 addr, uint size, u32 data) 
	return 0xFFFFFFFF;

}



bool bcmsdh_regfail(void *sdh)

bool brcmf_sdcard_regfail(void *sdh)

{

	return ((bcmsdh_info_t *) sdh)->regfail;

}



int

bcmsdh_recv_buf(bcmsdh_info_t *bcmsdh, u32 addr, uint fn, uint flags,

brcmf_sdcard_recv_buf(bcmsdh_info_t *bcmsdh, u32 addr, uint fn, uint flags,

		u8 *buf, uint nbytes, struct sk_buff *pkt,

		bcmsdh_cmplt_fn_t complete, void *handle)

{
@@ -469,7 +472,7 @@ bcmsdh_recv_buf(bcmsdh_info_t *bcmsdh, u32 addr, uint fn, uint flags, 
		return -ENOTSUPP;



	if (bar0 != bcmsdh->sbwad) {

		err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0);

		err = brcmf_sdcard_set_sbaddr_window(bcmsdh, bar0);

		if (err)

			return err;
@@ -483,15 +486,14 @@ bcmsdh_recv_buf(bcmsdh_info_t *bcmsdh, u32 addr, uint fn, uint flags, 
	if (width == 4)

		addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;



	status = sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO, incr_fix,

				      SDIOH_READ, fn, addr, width, nbytes, buf,

				      pkt);

	status = brcmf_sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO,

		incr_fix, SDIOH_READ, fn, addr, width, nbytes, buf, pkt);



	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;

}



int

bcmsdh_send_buf(void *sdh, u32 addr, uint fn, uint flags,

brcmf_sdcard_send_buf(void *sdh, u32 addr, uint fn, uint flags,

		u8 *buf, uint nbytes, void *pkt,

		bcmsdh_cmplt_fn_t complete, void *handle)

{
@@ -514,7 +516,7 @@ bcmsdh_send_buf(void *sdh, u32 addr, uint fn, uint flags, 
		return -ENOTSUPP;



	if (bar0 != bcmsdh->sbwad) {

		err = bcmsdhsdio_set_sbaddr_window(bcmsdh, bar0);

		err = brcmf_sdcard_set_sbaddr_window(bcmsdh, bar0);

		if (err)

			return err;
@@ -528,14 +530,13 @@ bcmsdh_send_buf(void *sdh, u32 addr, uint fn, uint flags, 
	if (width == 4)

		addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;



	status = sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO, incr_fix,

				      SDIOH_WRITE, fn, addr, width, nbytes, buf,

				      pkt);

	status = brcmf_sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO,

		incr_fix, SDIOH_WRITE, fn, addr, width, nbytes, buf, pkt);



	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;

}



int bcmsdh_rwdata(void *sdh, uint rw, u32 addr, u8 *buf, uint nbytes)

int brcmf_sdcard_rwdata(void *sdh, uint rw, u32 addr, u8 *buf, uint nbytes)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	SDIOH_API_RC status;
@@ -547,72 +548,71 @@ int bcmsdh_rwdata(void *sdh, uint rw, u32 addr, u8 *buf, uint nbytes) 
	addr &= SBSDIO_SB_OFT_ADDR_MASK;

	addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;



	status =

	    sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO, SDIOH_DATA_INC,

				 (rw ? SDIOH_WRITE : SDIOH_READ), SDIO_FUNC_1,

	status = brcmf_sdioh_request_buffer(bcmsdh->sdioh, SDIOH_DATA_PIO,

		SDIOH_DATA_INC, (rw ? SDIOH_WRITE : SDIOH_READ), SDIO_FUNC_1,

		addr, 4, nbytes, buf, NULL);



	return SDIOH_API_SUCCESS(status) ? 0 : -EIO;

}



int bcmsdh_abort(void *sdh, uint fn)

int brcmf_sdcard_abort(void *sdh, uint fn)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;



	return sdioh_abort(bcmsdh->sdioh, fn);

	return brcmf_sdioh_abort(bcmsdh->sdioh, fn);

}



int bcmsdh_start(void *sdh, int stage)

int brcmf_sdcard_start(void *sdh, int stage)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;



	return sdioh_start(bcmsdh->sdioh, stage);

	return brcmf_sdioh_start(bcmsdh->sdioh, stage);

}



int bcmsdh_stop(void *sdh)

int brcmf_sdcard_stop(void *sdh)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;



	return sdioh_stop(bcmsdh->sdioh);

	return brcmf_sdioh_stop(bcmsdh->sdioh);

}



int bcmsdh_query_device(void *sdh)

int brcmf_sdcard_query_device(void *sdh)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;

	bcmsdh->vendevid = (PCI_VENDOR_ID_BROADCOM << 16) | 0;

	return bcmsdh->vendevid;

}



uint bcmsdh_query_iofnum(void *sdh)

uint brcmf_sdcard_query_iofnum(void *sdh)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;



	if (!bcmsdh)

		bcmsdh = l_bcmsdh;



	return sdioh_query_iofnum(bcmsdh->sdioh);

	return brcmf_sdioh_query_iofnum(bcmsdh->sdioh);

}



int bcmsdh_reset(bcmsdh_info_t *sdh)

int brcmf_sdcard_reset(bcmsdh_info_t *sdh)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;



	return sdioh_sdio_reset(bcmsdh->sdioh);

	return brcmf_sdioh_reset(bcmsdh->sdioh);

}



void *bcmsdh_get_sdioh(bcmsdh_info_t *sdh)

void *brcmf_sdcard_get_sdioh(bcmsdh_info_t *sdh)

{

	ASSERT(sdh);

	return sdh->sdioh;

}



/* Function to pass device-status bits to DHD. */

u32 bcmsdh_get_dstatus(void *sdh)

u32 brcmf_sdcard_get_dstatus(void *sdh)

{

	return 0;

}



u32 bcmsdh_cur_sbwad(void *sdh)

u32 brcmf_sdcard_cur_sbwad(void *sdh)

{

	bcmsdh_info_t *bcmsdh = (bcmsdh_info_t *) sdh;
@@ -622,7 +622,7 @@ u32 bcmsdh_cur_sbwad(void *sdh) 
	return bcmsdh->sbwad;

}



void bcmsdh_chipinfo(void *sdh, u32 chip, u32 chiprev)

void brcmf_sdcard_chipinfo(void *sdh, u32 chip, u32 chiprev)

{

	return;

}

drivers/staging/brcm80211/brcmfmac/bcmsdh_linux.c

+29 −29
Original line number Diff line number Diff line
@@ -33,7 +33,7 @@ 


#if defined(OOB_INTR_ONLY)

#include <linux/irq.h>

extern void dhdsdio_isr(void *args);

extern void brcmf_sdbrcm_isr(void *args);

#endif				/* defined(OOB_INTR_ONLY) */

#if defined(CONFIG_MACH_SANDGATE2G) || defined(CONFIG_MACH_LOGICPD_PXA270)

#if !defined(BCMPLATFORM_BUS)
@@ -71,7 +71,7 @@ struct bcmsdh_hc { 
};

static bcmsdh_hc_t *sdhcinfo;



/* driver info, initialized when bcmsdh_register is called */

/* driver info, initialized when brcmf_sdio_register is called */

static bcmsdh_driver_t drvinfo = { NULL, NULL };



/* debugging macros */
@@ -80,7 +80,7 @@ static bcmsdh_driver_t drvinfo = { NULL, NULL }; 
/**

 * Checks to see if vendor and device IDs match a supported SDIO Host Controller.

 */

bool bcmsdh_chipmatch(u16 vendor, u16 device)

bool brcmf_sdio_chipmatch(u16 vendor, u16 device)

{

	/* Add other vendors and devices as required */
@@ -125,22 +125,22 @@ bool bcmsdh_chipmatch(u16 vendor, u16 device) 
#if defined(BCMPLATFORM_BUS)

#if defined(BCMLXSDMMC)

/* forward declarations */

int bcmsdh_probe(struct device *dev);

EXPORT_SYMBOL(bcmsdh_probe);

int brcmf_sdio_probe(struct device *dev);

EXPORT_SYMBOL(brcmf_sdio_probe);



int bcmsdh_remove(struct device *dev);

EXPORT_SYMBOL(bcmsdh_remove);

int brcmf_sdio_remove(struct device *dev);

EXPORT_SYMBOL(brcmf_sdio_remove);



#else

/* forward declarations */

static int __devinit bcmsdh_probe(struct device *dev);

static int __devexit bcmsdh_remove(struct device *dev);

static int __devinit brcmf_sdio_probe(struct device *dev);

static int __devexit brcmf_sdio_remove(struct device *dev);

#endif				/* BCMLXSDMMC */



#ifndef BCMLXSDMMC

static

#endif				/* BCMLXSDMMC */

int bcmsdh_probe(struct device *dev)

int brcmf_sdio_probe(struct device *dev)

{

	bcmsdh_hc_t *sdhc = NULL;

	unsigned long regs = 0;
@@ -184,13 +184,13 @@ int bcmsdh_probe(struct device *dev) 
	sdhc->dev = (void *)dev;



#ifdef BCMLXSDMMC

	sdh = bcmsdh_attach((void *)0, (void **)&regs, irq);

	sdh = brcmf_sdcard_attach((void *)0, (void **)&regs, irq);

	if (!sdh) {

		SDLX_MSG(("%s: bcmsdh_attach failed\n", __func__));

		goto err;

	}

#else

	sdh = bcmsdh_attach((void *)r->start, (void **)&regs, irq);

	sdh = brcmf_sdcard_attach((void *)r->start, (void **)&regs, irq);

	if (!sdh) {

		SDLX_MSG(("%s: bcmsdh_attach failed\n", __func__));

		goto err;
@@ -208,7 +208,7 @@ int bcmsdh_probe(struct device *dev) 
	sdhc->next = sdhcinfo;

	sdhcinfo = sdhc;

	/* Read the vendor/device ID from the CIS */

	vendevid = bcmsdh_query_device(sdh);

	vendevid = brcmf_sdcard_query_device(sdh);



	/* try to attach to the target device */

	sdhc->ch = drvinfo.attach((vendevid >> 16), (vendevid & 0xFFFF),
@@ -224,7 +224,7 @@ int bcmsdh_probe(struct device *dev) 
err:

	if (sdhc) {

		if (sdhc->sdh)

			bcmsdh_detach(sdhc->sdh);

			brcmf_sdcard_detach(sdhc->sdh);

		kfree(sdhc);

	}
@@ -234,13 +234,13 @@ err: 
#ifndef BCMLXSDMMC

static

#endif				/* BCMLXSDMMC */

int bcmsdh_remove(struct device *dev)

int brcmf_sdio_remove(struct device *dev)

{

	bcmsdh_hc_t *sdhc, *prev;



	sdhc = sdhcinfo;

	drvinfo.detach(sdhc->ch);

	bcmsdh_detach(sdhc->sdh);

	brcmf_sdcard_detach(sdhc->sdh);

	/* find the SDIO Host Controller state for this pdev

		 and take it out from the list */

	for (sdhc = sdhcinfo, prev = NULL; sdhc; sdhc = sdhc->next) {
@@ -269,25 +269,25 @@ int bcmsdh_remove(struct device *dev) 
}

#endif				/* BCMPLATFORM_BUS */



extern int sdio_function_init(void);

extern int brcmf_sdio_function_init(void);



int bcmsdh_register(bcmsdh_driver_t *driver)

int brcmf_sdio_register(bcmsdh_driver_t *driver)

{

	drvinfo = *driver;



	SDLX_MSG(("Linux Kernel SDIO/MMC Driver\n"));

	return sdio_function_init();

	return brcmf_sdio_function_init();

}



extern void sdio_function_cleanup(void);

extern void brcmf_sdio_function_cleanup(void);



void bcmsdh_unregister(void)

void brcmf_sdio_unregister(void)

{

	sdio_function_cleanup();

	brcmf_sdio_function_cleanup();

}



#if defined(OOB_INTR_ONLY)

void bcmsdh_oob_intr_set(bool enable)

void brcmf_sdio_oob_intr_set(bool enable)

{

	static bool curstate = 1;

	unsigned long flags;
@@ -303,25 +303,25 @@ void bcmsdh_oob_intr_set(bool enable) 
	spin_unlock_irqrestore(&sdhcinfo->irq_lock, flags);

}



static irqreturn_t wlan_oob_irq(int irq, void *dev_id)

static irqreturn_t brcmf_sdio_oob_irq(int irq, void *dev_id)

{

	dhd_pub_t *dhdp;



	dhdp = (dhd_pub_t *) dev_get_drvdata(sdhcinfo->dev);



	bcmsdh_oob_intr_set(0);

	brcmf_sdio_oob_intr_set(0);



	if (dhdp == NULL) {

		SDLX_MSG(("Out of band GPIO interrupt fired way too early\n"));

		return IRQ_HANDLED;

	}



	dhdsdio_isr((void *)dhdp->bus);

	brcmf_sdbrcm_isr((void *)dhdp->bus);



	return IRQ_HANDLED;

}



int bcmsdh_register_oob_intr(void *dhdp)

int brcmf_sdio_register_oob_intr(void *dhdp)

{

	int error = 0;
@@ -338,7 +338,7 @@ int bcmsdh_register_oob_intr(void *dhdp) 
		/* Refer to customer Host IRQ docs about

			 proper irqflags definition */

		error =

		    request_irq(sdhcinfo->oob_irq, wlan_oob_irq,

		    request_irq(sdhcinfo->oob_irq, brcmf_sdio_oob_irq,

				sdhcinfo->oob_flags, "bcmsdh_sdmmc", NULL);

		if (error)

			return -ENODEV;
@@ -350,7 +350,7 @@ int bcmsdh_register_oob_intr(void *dhdp) 
	return 0;

}



void bcmsdh_unregister_oob_intr(void)

void brcmf_sdio_unregister_oob_intr(void)

{

	SDLX_MSG(("%s: Enter\n", __func__));

drivers/staging/brcm80211/brcmfmac/bcmsdh_sdmmc.c

+73 −73

File changed.

Preview size limit exceeded, changes collapsed.

drivers/staging/brcm80211/brcmfmac/bcmsdh_sdmmc.h

+13 −9
Original line number Diff line number Diff line
@@ -14,6 +14,10 @@ 
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 */



/*

 * BCMSDH Function Driver for the native SDIO/MMC driver in the Linux Kernel

 */



#ifndef __BCMSDH_SDMMC_H__

#define __BCMSDH_SDMMC_H__
@@ -58,8 +62,8 @@ 
#endif



/* Allocate/init/free per-OS private data */

extern int sdioh_sdmmc_osinit(sdioh_info_t *sd);

extern void sdioh_sdmmc_osfree(sdioh_info_t *sd);

extern int brcmf_sdioh_osinit(sdioh_info_t *sd);

extern void brcmf_sdioh_osfree(sdioh_info_t *sd);



#define BLOCK_SIZE_64 64

#define BLOCK_SIZE_512 512
@@ -105,23 +109,23 @@ struct sdioh_info { 
extern uint sd_msglevel;



/* OS-independent interrupt handler */

extern bool check_client_intr(sdioh_info_t *sd);

extern bool brcmf_sdioh_check_client_intr(sdioh_info_t *sd);



/* Core interrupt enable/disable of device interrupts */

extern void sdioh_sdmmc_devintr_on(sdioh_info_t *sd);

extern void sdioh_sdmmc_devintr_off(sdioh_info_t *sd);

extern void brcmf_sdioh_dev_intr_on(sdioh_info_t *sd);

extern void brcmf_sdioh_dev_intr_off(sdioh_info_t *sd);



/**************************************************************

 * Internal interfaces: bcmsdh_sdmmc.c references to per-port code

 */



/* Register mapping routines */

extern u32 *sdioh_sdmmc_reg_map(s32 addr, int size);

extern void sdioh_sdmmc_reg_unmap(s32 addr, int size);

extern u32 *brcmf_sdioh_reg_map(s32 addr, int size);

extern void brcmf_sdioh_reg_unmap(s32 addr, int size);



/* Interrupt (de)registration routines */

extern int sdioh_sdmmc_register_irq(sdioh_info_t *sd, uint irq);

extern void sdioh_sdmmc_free_irq(uint irq, sdioh_info_t *sd);

extern int brcmf_sdioh_register_irq(sdioh_info_t *sd, uint irq);

extern void brcmf_sdioh_free_irq(uint irq, sdioh_info_t *sd);



typedef struct _BCMSDH_SDMMC_INSTANCE {

	sdioh_info_t *sd;

CRA Git | Maintained and supported by SUSTech CRA and CCSE