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

Commit b55604ac authored by Freeman Liu's avatar Freeman Liu Committed by Greg Kroah-Hartman
Browse files

UPSTREAM: nvmem: sprd: Optimize the block lock operation 



We have some cases that will programme the eFuse block partially multiple
times, so we should allow the block to be programmed again if it was
programmed partially. But we should lock the block if the whole block
was programmed. Thus add a condition to validate if we need lock the
block or not.

Moreover we only enable the auto-check function when locking the block.

bug: 153500755
Change-Id: Ia019890c01781a298c6676ede19a6b2da2728000
Signed-off-by: default avatarFreeman Liu <freeman.liu@unisoc.com>
Signed-off-by: default avatarBaolin Wang <baolin.wang7@gmail.com>
Signed-off-by: default avatarSrinivas Kandagatla <srinivas.kandagatla@linaro.org>
Link: https://lore.kernel.org/r/20200323150007.7487-3-srinivas.kandagatla@linaro.org


Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
(cherry picked from commit 5af25388ba250ae9624a22587cc98685dc6d4e9e)
parent 13ebd2bf

drivers/nvmem/sprd-efuse.c

+20 −4
Original line number Diff line number Diff line
@@ -217,11 +217,13 @@ static int sprd_efuse_raw_prog(struct sprd_efuse *efuse, u32 blk, bool doub, 
	 * Enable the auto-check function to validate if the programming is

	 * successful.

	 */

	if (lock)

		sprd_efuse_set_auto_check(efuse, true);



	writel(*data, efuse->base + SPRD_EFUSE_MEM(blk));



	/* Disable auto-check and data double after programming */

	if (lock)

		sprd_efuse_set_auto_check(efuse, false);

	sprd_efuse_set_data_double(efuse, false);
@@ -237,7 +239,7 @@ static int sprd_efuse_raw_prog(struct sprd_efuse *efuse, u32 blk, bool doub, 
		writel(SPRD_EFUSE_ERR_CLR_MASK,

		       efuse->base + SPRD_EFUSE_ERR_CLR);

		ret = -EBUSY;

	} else {

	} else if (lock) {

		sprd_efuse_set_prog_lock(efuse, lock);

		writel(0, efuse->base + SPRD_EFUSE_MEM(blk));

		sprd_efuse_set_prog_lock(efuse, false);
@@ -322,6 +324,7 @@ static int sprd_efuse_read(void *context, u32 offset, void *val, size_t bytes) 
static int sprd_efuse_write(void *context, u32 offset, void *val, size_t bytes)

{

	struct sprd_efuse *efuse = context;

	bool lock;

	int ret;



	ret = sprd_efuse_lock(efuse);
@@ -332,7 +335,20 @@ static int sprd_efuse_write(void *context, u32 offset, void *val, size_t bytes) 
	if (ret)

		goto unlock;



	ret = sprd_efuse_raw_prog(efuse, offset, false, false, val);

	/*

	 * If the writing bytes are equal with the block width, which means the

	 * whole block will be programmed. For this case, we should not allow

	 * this block to be programmed again by locking this block.

	 *

	 * If the block was programmed partially, we should allow this block to

	 * be programmed again.

	 */

	if (bytes < SPRD_EFUSE_BLOCK_WIDTH)

		lock = false;

	else

		lock = true;



	ret = sprd_efuse_raw_prog(efuse, offset, false, lock, val);



	clk_disable_unprepare(efuse->clk);