Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 71c60cf2 authored by Arend van Spriel's avatar Arend van Spriel Committed by John W. Linville
Browse files

brcmfmac: rework SDIO register access functions 



The logic in the SDIO register access functions was hard to
read and contained a lot of conditional code path. This rework
attempts to clean it up.

Reviewed-by: default avatarFranky Lin <frankyl@broadcom.com>
Reviewed-by: default avatarHante Meuleman <meuleman@broadcom.com>
Reviewed-by: default avatarPieter-Paul Giesberts <pieterpg@broadcom.com>
Signed-off-by: default avatarArend van Spriel <arend@broadcom.com>
Signed-off-by: default avatarJohn W. Linville <linville@tuxdriver.com>
parent 9d1cd503

drivers/net/wireless/brcm80211/brcmfmac/bcmsdh.c

+96 −131
Original line number Original line Diff line number Diff line
@@ -216,94 +216,104 @@ static inline int brcmf_sdiod_f0_writeb(struct sdio_func *func, 
	return err_ret;

	return err_ret;

}

}





static int brcmf_sdiod_request_byte(struct brcmf_sdio_dev *sdiodev, uint rw,

static int brcmf_sdiod_request_data(struct brcmf_sdio_dev *sdiodev, u8 fn,

				    uint func, uint regaddr, u8 *byte)

				    u32 addr, u8 regsz, void *data, bool write)

{

{

	int err_ret;

	struct sdio_func *func;

	int ret;





	brcmf_dbg(SDIO, "rw=%d, func=%d, addr=0x%05x\n", rw, func, regaddr);

	brcmf_dbg(SDIO, "rw=%d, func=%d, addr=0x%05x, nbytes=%d\n",

		  write, fn, addr, regsz);





	brcmf_sdiod_pm_resume_wait(sdiodev, &sdiodev->request_byte_wait);

	brcmf_sdiod_pm_resume_wait(sdiodev, &sdiodev->request_word_wait);

	if (brcmf_sdiod_pm_resume_error(sdiodev))

	if (brcmf_sdiod_pm_resume_error(sdiodev))

		return -EIO;

		return -EIO;





	if (rw && func == 0) {

	/* only allow byte access on F0 */

		/* handle F0 separately */

	if (WARN_ON(regsz > 1 && !fn))

		err_ret = brcmf_sdiod_f0_writeb(sdiodev->func[func],

		return -EINVAL;

						regaddr, *byte);

	func = sdiodev->func[fn];

	} else {



		if (rw) /* CMD52 Write */

	switch (regsz) {

			sdio_writeb(sdiodev->func[func], *byte, regaddr,

	case sizeof(u8):

				    &err_ret);

		if (write) {

		else if (func == 0) {

			if (fn)

			*byte = sdio_f0_readb(sdiodev->func[func], regaddr,

				sdio_writeb(func, *(u8 *)data, addr, &ret);

					      &err_ret);

			else

				ret = brcmf_sdiod_f0_writeb(func, addr,

							    *(u8 *)data);

		} else {

		} else {

			*byte = sdio_readb(sdiodev->func[func], regaddr,

			if (fn)

					   &err_ret);

				*(u8 *)data = sdio_readb(func, addr, &ret);

			else

				*(u8 *)data = sdio_f0_readb(func, addr, &ret);

		}

		}

		break;

	case sizeof(u16):

		if (write)

			sdio_writew(func, *(u16 *)data, addr, &ret);

		else

			*(u16 *)data = sdio_readw(func, addr, &ret);

		break;

	case sizeof(u32):

		if (write)

			sdio_writel(func, *(u32 *)data, addr, &ret);

		else

			*(u32 *)data = sdio_readl(func, addr, &ret);

		break;

	default:

		brcmf_err("invalid size: %d\n", regsz);

		break;

	}

	}





	if (err_ret) {

	if (ret) {

		/*

		/*

		 * SleepCSR register access can fail when

		 * SleepCSR register access can fail when

		 * waking up the device so reduce this noise

		 * waking up the device so reduce this noise

		 * in the logs.

		 * in the logs.

		 */

		 */

		if (regaddr != SBSDIO_FUNC1_SLEEPCSR)

		if (addr != SBSDIO_FUNC1_SLEEPCSR)

			brcmf_err("Failed to %s byte F%d:@0x%05x=%02x, Err: %d\n",

			brcmf_err("failed to %s data F%d@0x%05x, err: %d\n",

				  rw ? "write" : "read", func, regaddr, *byte,

				  write ? "write" : "read", fn, addr, ret);

				  err_ret);

		else

		else

			brcmf_dbg(SDIO, "Failed to %s byte F%d:@0x%05x=%02x, Err: %d\n",

			brcmf_dbg(SDIO, "failed to %s data F%d@0x%05x, err: %d\n",

				  rw ? "write" : "read", func, regaddr, *byte,

				  write ? "write" : "read", fn, addr, ret);

				  err_ret);

	}

	}

	return err_ret;

	return ret;

}

}





static int brcmf_sdiod_request_word(struct brcmf_sdio_dev *sdiodev, uint rw,

static int brcmf_sdiod_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr,

				    uint func, uint addr, u32 *word,

				   u8 regsz, void *data, bool write)

				    uint nbytes)

{

{

	int err_ret = -EIO;

	u8 func_num;



	s32 retry = 0;

	if (func == 0) {

	int ret;

		brcmf_err("Only CMD52 allowed to F0\n");

		return -EINVAL;

	}



	brcmf_dbg(SDIO, "rw=%d, func=%d, addr=0x%05x, nbytes=%d\n",

		  rw, func, addr, nbytes);



	brcmf_sdiod_pm_resume_wait(sdiodev, &sdiodev->request_word_wait);

	if (brcmf_sdiod_pm_resume_error(sdiodev))

		return -EIO;





	if (rw) {		/* CMD52 Write */

	/*

		if (nbytes == 4)

	 * figure out how to read the register based on address range

			sdio_writel(sdiodev->func[func], *word, addr,

	 * 0x00 ~ 0x7FF: function 0 CCCR and FBR

				    &err_ret);

	 * 0x10000 ~ 0x1FFFF: function 1 miscellaneous registers

		else if (nbytes == 2)

	 * The rest: function 1 silicon backplane core registers

			sdio_writew(sdiodev->func[func], (*word & 0xFFFF),

	 */

				    addr, &err_ret);

	if ((addr & ~REG_F0_REG_MASK) == 0)

		else

		func_num = SDIO_FUNC_0;

			brcmf_err("Invalid nbytes: %d\n", nbytes);

	} else {		/* CMD52 Read */

		if (nbytes == 4)

			*word = sdio_readl(sdiodev->func[func], addr, &err_ret);

		else if (nbytes == 2)

			*word = sdio_readw(sdiodev->func[func], addr,

					   &err_ret) & 0xFFFF;

	else

	else

			brcmf_err("Invalid nbytes: %d\n", nbytes);

		func_num = SDIO_FUNC_1;

	}





	if (err_ret)

	do {

		brcmf_err("Failed to %s word, Err: 0x%08x\n",

		if (!write)

			  rw ? "write" : "read", err_ret);

			memset(data, 0, regsz);

		/* for retry wait for 1 ms till bus get settled down */

		if (retry)

			usleep_range(1000, 2000);

		ret = brcmf_sdiod_request_data(sdiodev, func_num, addr, regsz,

					       data, write);

	} while (ret != 0 && retry++ < SDIOH_API_ACCESS_RETRY_LIMIT);





	return err_ret;

	if (ret != 0)

		brcmf_err("failed with %d\n", ret);



	return ret;

}

}





static int

static int
@@ -311,22 +321,15 @@ brcmf_sdiod_set_sbaddr_window(struct brcmf_sdio_dev *sdiodev, u32 address) 
{

{

	int err = 0, i;

	int err = 0, i;

	u8 addr[3];

	u8 addr[3];

	s32 retry;





	addr[0] = (address >> 8) & SBSDIO_SBADDRLOW_MASK;

	addr[0] = (address >> 8) & SBSDIO_SBADDRLOW_MASK;

	addr[1] = (address >> 16) & SBSDIO_SBADDRMID_MASK;

	addr[1] = (address >> 16) & SBSDIO_SBADDRMID_MASK;

	addr[2] = (address >> 24) & SBSDIO_SBADDRHIGH_MASK;

	addr[2] = (address >> 24) & SBSDIO_SBADDRHIGH_MASK;





	for (i = 0; i < 3; i++) {

	for (i = 0; i < 3; i++) {

		retry = 0;

		err = brcmf_sdiod_regrw_helper(sdiodev,

		do {

					       SBSDIO_FUNC1_SBADDRLOW + i,

			if (retry)

					       sizeof(u8), &addr[i], true);

				usleep_range(1000, 2000);

			err = brcmf_sdiod_request_byte(sdiodev, SDIOH_WRITE,

					SDIO_FUNC_1, SBSDIO_FUNC1_SBADDRLOW + i,

					&addr[i]);

		} while (err != 0 && retry++ < SDIOH_API_ACCESS_RETRY_LIMIT);



		if (err) {

		if (err) {

			brcmf_err("failed at addr: 0x%0x\n",

			brcmf_err("failed at addr: 0x%0x\n",

				  SBSDIO_FUNC1_SBADDRLOW + i);

				  SBSDIO_FUNC1_SBADDRLOW + i);
@@ -359,61 +362,14 @@ brcmf_sdiod_addrprep(struct brcmf_sdio_dev *sdiodev, uint width, u32 *addr) 
	return 0;

	return 0;

}

}





static int brcmf_sdiod_regrw_helper(struct brcmf_sdio_dev *sdiodev, u32 addr,

				    void *data, bool write)

{

	u8 func_num, reg_size;

	s32 retry = 0;

	int ret;



	/*

	 * figure out how to read the register based on address range

	 * 0x00 ~ 0x7FF: function 0 CCCR and FBR

	 * 0x10000 ~ 0x1FFFF: function 1 miscellaneous registers

	 * The rest: function 1 silicon backplane core registers

	 */

	if ((addr & ~REG_F0_REG_MASK) == 0) {

		func_num = SDIO_FUNC_0;

		reg_size = 1;

	} else if ((addr & ~REG_F1_MISC_MASK) == 0) {

		func_num = SDIO_FUNC_1;

		reg_size = 1;

	} else {

		func_num = SDIO_FUNC_1;

		reg_size = 4;



		ret = brcmf_sdiod_addrprep(sdiodev, reg_size, &addr);

		if (ret)

			goto done;

	}



	do {

		if (!write)

			memset(data, 0, reg_size);

		if (retry)	/* wait for 1 ms till bus get settled down */

			usleep_range(1000, 2000);

		if (reg_size == 1)

			ret = brcmf_sdiod_request_byte(sdiodev, write,

						       func_num, addr, data);

		else

			ret = brcmf_sdiod_request_word(sdiodev, write,

						       func_num, addr, data, 4);

	} while (ret != 0 && retry++ < SDIOH_API_ACCESS_RETRY_LIMIT);



done:

	if (ret != 0)

		brcmf_err("failed with %d\n", ret);



	return ret;

}



u8 brcmf_sdiod_regrb(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)

u8 brcmf_sdiod_regrb(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)

{

{

	u8 data;

	u8 data;

	int retval;

	int retval;





	brcmf_dbg(SDIO, "addr:0x%08x\n", addr);

	brcmf_dbg(SDIO, "addr:0x%08x\n", addr);

	retval = brcmf_sdiod_regrw_helper(sdiodev, addr, &data, false);

	retval = brcmf_sdiod_regrw_helper(sdiodev, addr, sizeof(data), &data,

					  false);

	brcmf_dbg(SDIO, "data:0x%02x\n", data);

	brcmf_dbg(SDIO, "data:0x%02x\n", data);





	if (ret)

	if (ret)
@@ -428,9 +384,14 @@ u32 brcmf_sdiod_regrl(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret) 
	int retval;

	int retval;





	brcmf_dbg(SDIO, "addr:0x%08x\n", addr);

	brcmf_dbg(SDIO, "addr:0x%08x\n", addr);

	retval = brcmf_sdiod_regrw_helper(sdiodev, addr, &data, false);

	retval = brcmf_sdiod_addrprep(sdiodev, sizeof(data), &addr);

	if (retval)

		goto done;

	retval = brcmf_sdiod_regrw_helper(sdiodev, addr, sizeof(data), &data,

					  false);

	brcmf_dbg(SDIO, "data:0x%08x\n", data);

	brcmf_dbg(SDIO, "data:0x%08x\n", data);





done:

	if (ret)

	if (ret)

		*ret = retval;

		*ret = retval;
@@ -443,8 +404,8 @@ void brcmf_sdiod_regwb(struct brcmf_sdio_dev *sdiodev, u32 addr, 
	int retval;

	int retval;





	brcmf_dbg(SDIO, "addr:0x%08x, data:0x%02x\n", addr, data);

	brcmf_dbg(SDIO, "addr:0x%08x, data:0x%02x\n", addr, data);

	retval = brcmf_sdiod_regrw_helper(sdiodev, addr, &data, true);

	retval = brcmf_sdiod_regrw_helper(sdiodev, addr, sizeof(data), &data,



					  true);

	if (ret)

	if (ret)

		*ret = retval;

		*ret = retval;

}

}
@@ -455,8 +416,13 @@ void brcmf_sdiod_regwl(struct brcmf_sdio_dev *sdiodev, u32 addr, 
	int retval;

	int retval;





	brcmf_dbg(SDIO, "addr:0x%08x, data:0x%08x\n", addr, data);

	brcmf_dbg(SDIO, "addr:0x%08x, data:0x%08x\n", addr, data);

	retval = brcmf_sdiod_regrw_helper(sdiodev, addr, &data, true);

	retval = brcmf_sdiod_addrprep(sdiodev, sizeof(data), &addr);

	if (retval)

		goto done;

	retval = brcmf_sdiod_regrw_helper(sdiodev, addr, sizeof(data), &data,

					  true);





done:

	if (ret)

	if (ret)

		*ret = retval;

		*ret = retval;

}

}
@@ -879,8 +845,8 @@ int brcmf_sdiod_abort(struct brcmf_sdio_dev *sdiodev, uint fn) 
	brcmf_dbg(SDIO, "Enter\n");

	brcmf_dbg(SDIO, "Enter\n");





	/* issue abort cmd52 command through F0 */

	/* issue abort cmd52 command through F0 */

	brcmf_sdiod_request_byte(sdiodev, SDIOH_WRITE, SDIO_FUNC_0,

	brcmf_sdiod_request_data(sdiodev, SDIO_FUNC_0, SDIO_CCCR_ABORT,

				 SDIO_CCCR_ABORT, &t_func);

				 sizeof(t_func), &t_func, true);





	brcmf_dbg(SDIO, "Exit\n");

	brcmf_dbg(SDIO, "Exit\n");

	return 0;

	return 0;
@@ -1037,7 +1003,6 @@ static int brcmf_ops_sdio_probe(struct sdio_func *func, 
	sdiodev->pdata = brcmfmac_sdio_pdata;

	sdiodev->pdata = brcmfmac_sdio_pdata;





	atomic_set(&sdiodev->suspend, false);

	atomic_set(&sdiodev->suspend, false);

	init_waitqueue_head(&sdiodev->request_byte_wait);

	init_waitqueue_head(&sdiodev->request_word_wait);

	init_waitqueue_head(&sdiodev->request_word_wait);

	init_waitqueue_head(&sdiodev->request_buffer_wait);

	init_waitqueue_head(&sdiodev->request_buffer_wait);

drivers/net/wireless/brcm80211/brcmfmac/sdio_host.h

+0 −1
Original line number Original line Diff line number Diff line
@@ -167,7 +167,6 @@ struct brcmf_sdio_dev { 
	u32 sbwad;			/* Save backplane window address */

	u32 sbwad;			/* Save backplane window address */

	struct brcmf_sdio *bus;

	struct brcmf_sdio *bus;

	atomic_t suspend;		/* suspend flag */

	atomic_t suspend;		/* suspend flag */

	wait_queue_head_t request_byte_wait;

	wait_queue_head_t request_word_wait;

	wait_queue_head_t request_word_wait;

	wait_queue_head_t request_buffer_wait;

	wait_queue_head_t request_buffer_wait;

	struct device *dev;

	struct device *dev;