[J-u-boot.git] / env / mmc.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * (C) Copyright 2008-2011 Freescale Semiconductor, Inc.
 */

/* #define DEBUG */

#include <common.h>
#include <asm/global_data.h>

#include <command.h>
#include <env.h>
#include <env_internal.h>
#include <fdtdec.h>
#include <linux/stddef.h>
#include <malloc.h>
#include <memalign.h>
#include <mmc.h>
#include <part.h>
#include <search.h>
#include <errno.h>
#include <dm/ofnode.h>

#define __STR(X) #X
#define STR(X) __STR(X)

DECLARE_GLOBAL_DATA_PTR;

#if CONFIG_IS_ENABLED(OF_CONTROL)
static inline int mmc_offset_try_partition(const char *str, int copy, s64 *val)
{
	struct disk_partition info;
	struct blk_desc *desc;
	int len, i, ret;
	char dev_str[4];

	snprintf(dev_str, sizeof(dev_str), "%d", mmc_get_env_dev());
	ret = blk_get_device_by_str("mmc", dev_str, &desc);
	if (ret < 0)
		return (ret);

	for (i = 1;;i++) {
		ret = part_get_info(desc, i, &info);
		if (ret < 0)
			return ret;

		if (!strncmp((const char *)info.name, str, sizeof(info.name)))
			break;
	}

	/* round up to info.blksz */
	len = DIV_ROUND_UP(CONFIG_ENV_SIZE, info.blksz);

	/* use the top of the partion for the environment */
	*val = (info.start + info.size - (1 + copy) * len) * info.blksz;

	return 0;
}

static inline s64 mmc_offset(int copy)
{
	const struct {
		const char *offset_redund;
		const char *partition;
		const char *offset;
	} dt_prop = {
		.offset_redund = "u-boot,mmc-env-offset-redundant",
		.partition = "u-boot,mmc-env-partition",
		.offset = "u-boot,mmc-env-offset",
	};
	s64 val = 0, defvalue;
	const char *propname;
	const char *str;
	int err;

	/* look for the partition in mmc CONFIG_SYS_MMC_ENV_DEV */
	str = ofnode_conf_read_str(dt_prop.partition);
	if (str) {
		/* try to place the environment at end of the partition */
		err = mmc_offset_try_partition(str, copy, &val);
		if (!err)
			return val;
	}

	defvalue = CONFIG_ENV_OFFSET;
	propname = dt_prop.offset;

#if defined(CONFIG_ENV_OFFSET_REDUND)
	if (copy) {
		defvalue = CONFIG_ENV_OFFSET_REDUND;
		propname = dt_prop.offset_redund;
	}
#endif
	return ofnode_conf_read_int(propname, defvalue);
}
#else
static inline s64 mmc_offset(int copy)
{
	s64 offset = CONFIG_ENV_OFFSET;

#if defined(CONFIG_ENV_OFFSET_REDUND)
	if (copy)
		offset = CONFIG_ENV_OFFSET_REDUND;
#endif
	return offset;
}
#endif

__weak int mmc_get_env_addr(struct mmc *mmc, int copy, u32 *env_addr)
{
	s64 offset = mmc_offset(copy);

	if (offset < 0)
		offset += mmc->capacity;

	*env_addr = offset;

	return 0;
}

#ifdef CONFIG_SYS_MMC_ENV_PART
__weak uint mmc_get_env_part(struct mmc *mmc)
{
	return CONFIG_SYS_MMC_ENV_PART;
}

static unsigned char env_mmc_orig_hwpart;

static int mmc_set_env_part(struct mmc *mmc)
{
	uint part = mmc_get_env_part(mmc);
	int dev = mmc_get_env_dev();
	int ret = 0;

	env_mmc_orig_hwpart = mmc_get_blk_desc(mmc)->hwpart;
	ret = blk_select_hwpart_devnum(IF_TYPE_MMC, dev, part);
	if (ret)
		puts("MMC partition switch failed\n");

	return ret;
}
#else
static inline int mmc_set_env_part(struct mmc *mmc) {return 0; };
#endif

static const char *init_mmc_for_env(struct mmc *mmc)
{
	if (!mmc)
		return "No MMC card found";

#if CONFIG_IS_ENABLED(BLK)
	struct udevice *dev;

	if (blk_get_from_parent(mmc->dev, &dev))
		return "No block device";
#else
	if (mmc_init(mmc))
		return "MMC init failed";
#endif
	if (mmc_set_env_part(mmc))
		return "MMC partition switch failed";

	return NULL;
}

static void fini_mmc_for_env(struct mmc *mmc)
{
#ifdef CONFIG_SYS_MMC_ENV_PART
	int dev = mmc_get_env_dev();

	blk_select_hwpart_devnum(IF_TYPE_MMC, dev, env_mmc_orig_hwpart);
#endif
}

#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_SPL_BUILD)
static inline int write_env(struct mmc *mmc, unsigned long size,
			    unsigned long offset, const void *buffer)
{
	uint blk_start, blk_cnt, n;
	struct blk_desc *desc = mmc_get_blk_desc(mmc);

	blk_start	= ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
	blk_cnt		= ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;

	n = blk_dwrite(desc, blk_start, blk_cnt, (u_char *)buffer);

	return (n == blk_cnt) ? 0 : -1;
}

static int env_mmc_save(void)
{
	ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1);
	int dev = mmc_get_env_dev();
	struct mmc *mmc = find_mmc_device(dev);
	u32	offset;
	int	ret, copy = 0;
	const char *errmsg;

	errmsg = init_mmc_for_env(mmc);
	if (errmsg) {
		printf("%s\n", errmsg);
		return 1;
	}

	ret = env_export(env_new);
	if (ret)
		goto fini;

#ifdef CONFIG_ENV_OFFSET_REDUND
	if (gd->env_valid == ENV_VALID)
		copy = 1;
#endif

	if (mmc_get_env_addr(mmc, copy, &offset)) {
		ret = 1;
		goto fini;
	}

	printf("Writing to %sMMC(%d)... ", copy ? "redundant " : "", dev);
	if (write_env(mmc, CONFIG_ENV_SIZE, offset, (u_char *)env_new)) {
		puts("failed\n");
		ret = 1;
		goto fini;
	}

	ret = 0;

#ifdef CONFIG_ENV_OFFSET_REDUND
	gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;
#endif

fini:
	fini_mmc_for_env(mmc);
	return ret;
}

static inline int erase_env(struct mmc *mmc, unsigned long size,
			    unsigned long offset)
{
	uint blk_start, blk_cnt, n;
	struct blk_desc *desc = mmc_get_blk_desc(mmc);

	blk_start	= ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
	blk_cnt		= ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;

	n = blk_derase(desc, blk_start, blk_cnt);
	printf("%d blocks erased: %s\n", n, (n == blk_cnt) ? "OK" : "ERROR");

	return (n == blk_cnt) ? 0 : 1;
}

static int env_mmc_erase(void)
{
	int dev = mmc_get_env_dev();
	struct mmc *mmc = find_mmc_device(dev);
	int	ret, copy = 0;
	u32	offset;
	const char *errmsg;

	errmsg = init_mmc_for_env(mmc);
	if (errmsg) {
		printf("%s\n", errmsg);
		return 1;
	}

	if (mmc_get_env_addr(mmc, copy, &offset)) {
		ret = CMD_RET_FAILURE;
		goto fini;
	}

	ret = erase_env(mmc, CONFIG_ENV_SIZE, offset);

#ifdef CONFIG_ENV_OFFSET_REDUND
	copy = 1;

	if (mmc_get_env_addr(mmc, copy, &offset)) {
		ret = CMD_RET_FAILURE;
		goto fini;
	}

	ret |= erase_env(mmc, CONFIG_ENV_SIZE, offset);
#endif

fini:
	fini_mmc_for_env(mmc);
	return ret;
}
#endif /* CONFIG_CMD_SAVEENV && !CONFIG_SPL_BUILD */

static inline int read_env(struct mmc *mmc, unsigned long size,
			   unsigned long offset, const void *buffer)
{
	uint blk_start, blk_cnt, n;
	struct blk_desc *desc = mmc_get_blk_desc(mmc);

	blk_start	= ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len;
	blk_cnt		= ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len;

	n = blk_dread(desc, blk_start, blk_cnt, (uchar *)buffer);

	return (n == blk_cnt) ? 0 : -1;
}

#ifdef CONFIG_ENV_OFFSET_REDUND
static int env_mmc_load(void)
{
#if !defined(ENV_IS_EMBEDDED)
	struct mmc *mmc;
	u32 offset1, offset2;
	int read1_fail = 0, read2_fail = 0;
	int ret;
	int dev = mmc_get_env_dev();
	const char *errmsg = NULL;

	ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env1, 1);
	ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env2, 1);

	mmc_initialize(NULL);

	mmc = find_mmc_device(dev);

	errmsg = init_mmc_for_env(mmc);
	if (errmsg) {
		ret = -EIO;
		goto err;
	}

	if (mmc_get_env_addr(mmc, 0, &offset1) ||
	    mmc_get_env_addr(mmc, 1, &offset2)) {
		ret = -EIO;
		goto fini;
	}

	read1_fail = read_env(mmc, CONFIG_ENV_SIZE, offset1, tmp_env1);
	read2_fail = read_env(mmc, CONFIG_ENV_SIZE, offset2, tmp_env2);

	ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
				read2_fail, H_EXTERNAL);

fini:
	fini_mmc_for_env(mmc);
err:
	if (ret)
		env_set_default(errmsg, 0);

#endif
	return ret;
}
#else /* ! CONFIG_ENV_OFFSET_REDUND */
static int env_mmc_load(void)
{
#if !defined(ENV_IS_EMBEDDED)
	ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE);
	struct mmc *mmc;
	u32 offset;
	int ret;
	int dev = mmc_get_env_dev();
	const char *errmsg;
	env_t *ep = NULL;

	mmc = find_mmc_device(dev);

	errmsg = init_mmc_for_env(mmc);
	if (errmsg) {
		ret = -EIO;
		goto err;
	}

	if (mmc_get_env_addr(mmc, 0, &offset)) {
		ret = -EIO;
		goto fini;
	}

	if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) {
		errmsg = "!read failed";
		ret = -EIO;
		goto fini;
	}

	ret = env_import(buf, 1, H_EXTERNAL);
	if (!ret) {
		ep = (env_t *)buf;
		gd->env_addr = (ulong)&ep->data;
	}

fini:
	fini_mmc_for_env(mmc);
err:
	if (ret)
		env_set_default(errmsg, 0);
#endif
	return ret;
}
#endif /* CONFIG_ENV_OFFSET_REDUND */

U_BOOT_ENV_LOCATION(mmc) = {
	.location	= ENVL_MMC,
	ENV_NAME("MMC")
	.load		= env_mmc_load,
#ifndef CONFIG_SPL_BUILD
	.save		= env_save_ptr(env_mmc_save),
	.erase		= ENV_ERASE_PTR(env_mmc_erase)
#endif
};
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
a8060359	2	/*
97039ab9	3	* (C) Copyright 2008-2011 Freescale Semiconductor, Inc.
a8060359 TL	4	*/
	5
	6	/* #define DEBUG */
	7
	8	#include <common.h>
401d1c4f	9	#include <asm/global_data.h>
a8060359 TL	10
a8060359 TL	11	#include <command.h>
0ac7d722	12	#include <env.h>
f3998fdc	13	#include <env_internal.h>
f8b8a554	14	#include <fdtdec.h>
a8060359 TL	15	#include <linux/stddef.h>
a8060359 TL	16	#include <malloc.h>
cf92e05c	17	#include <memalign.h>
a8060359	18	#include <mmc.h>
c9e87ba6	19	#include <part.h>
6d1d51b3	20	#include <search.h>
e79f4839	21	#include <errno.h>
7de8bd03	22	#include <dm/ofnode.h>
a8060359	23
c9e87ba6 JRO	24	#define __STR(X) #X
	25	#define STR(X) __STR(X)
	26
a8060359 TL	27	DECLARE_GLOBAL_DATA_PTR;
a8060359 TL	28
f8b8a554	29	#if CONFIG_IS_ENABLED(OF_CONTROL)
5d4f7b4e	30	static inline int mmc_offset_try_partition(const char str, int copy, s64 val)
c9e87ba6	31	{
0528979f	32	struct disk_partition info;
c9e87ba6 JRO	33	struct blk_desc *desc;
c9e87ba6 JRO	34	int len, i, ret;
2b2f7275	35	char dev_str[4];
c9e87ba6	36
2b2f7275 PD	37	snprintf(dev_str, sizeof(dev_str), "%d", mmc_get_env_dev());
2b2f7275 PD	38	ret = blk_get_device_by_str("mmc", dev_str, &desc);
c9e87ba6 JRO	39	if (ret < 0)
	40	return (ret);
	41
	42	for (i = 1;;i++) {
	43	ret = part_get_info(desc, i, &info);
	44	if (ret < 0)
	45	return ret;
	46
2a0a577a	47	if (!strncmp((const char *)info.name, str, sizeof(info.name)))
c9e87ba6 JRO	48	break;
	49	}
	50
	51	/* round up to info.blksz */
76b640c3	52	len = DIV_ROUND_UP(CONFIG_ENV_SIZE, info.blksz);
c9e87ba6 JRO	53
c9e87ba6 JRO	54	/* use the top of the partion for the environment */
5d4f7b4e	55	val = (info.start + info.size - (1 + copy) len) * info.blksz;
c9e87ba6 JRO	56
	57	return 0;
	58	}
	59
f8b8a554 PT	60	static inline s64 mmc_offset(int copy)
f8b8a554 PT	61	{
c9e87ba6 JRO	62	const struct {
	63	const char *offset_redund;
	64	const char *partition;
	65	const char *offset;
	66	} dt_prop = {
	67	.offset_redund = "u-boot,mmc-env-offset-redundant",
	68	.partition = "u-boot,mmc-env-partition",
	69	.offset = "u-boot,mmc-env-offset",
	70	};
fd374665	71	s64 val = 0, defvalue;
c9e87ba6 JRO	72	const char *propname;
	73	const char *str;
	74	int err;
	75
	76	/* look for the partition in mmc CONFIG_SYS_MMC_ENV_DEV */
7de8bd03	77	str = ofnode_conf_read_str(dt_prop.partition);
c9e87ba6 JRO	78	if (str) {
c9e87ba6 JRO	79	/* try to place the environment at end of the partition */
5d4f7b4e	80	err = mmc_offset_try_partition(str, copy, &val);
c9e87ba6 JRO	81	if (!err)
	82	return val;
	83	}
	84
	85	defvalue = CONFIG_ENV_OFFSET;
	86	propname = dt_prop.offset;
f8b8a554 PT	87
	88	#if defined(CONFIG_ENV_OFFSET_REDUND)
	89	if (copy) {
f8b8a554	90	defvalue = CONFIG_ENV_OFFSET_REDUND;
c9e87ba6	91	propname = dt_prop.offset_redund;
f8b8a554 PT	92	}
f8b8a554 PT	93	#endif
7de8bd03	94	return ofnode_conf_read_int(propname, defvalue);
f8b8a554 PT	95	}
	96	#else
	97	static inline s64 mmc_offset(int copy)
97039ab9	98	{
f8b8a554	99	s64 offset = CONFIG_ENV_OFFSET;
5c088ee8	100
f8b8a554	101	#if defined(CONFIG_ENV_OFFSET_REDUND)
d196bd88	102	if (copy)
5c088ee8	103	offset = CONFIG_ENV_OFFSET_REDUND;
d196bd88	104	#endif
f8b8a554 PT	105	return offset;
	106	}
	107	#endif
	108
	109	__weak int mmc_get_env_addr(struct mmc mmc, int copy, u32 env_addr)
	110	{
	111	s64 offset = mmc_offset(copy);
5c088ee8 SW	112
	113	if (offset < 0)
	114	offset += mmc->capacity;
	115
	116	*env_addr = offset;
	117
97039ab9 MH	118	return 0;
97039ab9 MH	119	}
97039ab9	120
b9c8ccab	121	#ifdef CONFIG_SYS_MMC_ENV_PART
6e7b7df4 DL	122	__weak uint mmc_get_env_part(struct mmc *mmc)
	123	{
	124	return CONFIG_SYS_MMC_ENV_PART;
	125	}
	126
873cc1d7 SW	127	static unsigned char env_mmc_orig_hwpart;
873cc1d7 SW	128
6e7b7df4 DL	129	static int mmc_set_env_part(struct mmc *mmc)
	130	{
	131	uint part = mmc_get_env_part(mmc);
e92029c0	132	int dev = mmc_get_env_dev();
6e7b7df4	133	int ret = 0;
b9c8ccab	134
69f45cd5 SG	135	env_mmc_orig_hwpart = mmc_get_blk_desc(mmc)->hwpart;
69f45cd5 SG	136	ret = blk_select_hwpart_devnum(IF_TYPE_MMC, dev, part);
873cc1d7 SW	137	if (ret)
873cc1d7 SW	138	puts("MMC partition switch failed\n");
6e7b7df4 DL	139
	140	return ret;
	141	}
	142	#else
	143	static inline int mmc_set_env_part(struct mmc *mmc) {return 0; };
b9c8ccab TR	144	#endif
b9c8ccab TR	145
c75648d7	146	static const char init_mmc_for_env(struct mmc mmc)
6e7b7df4	147	{
c75648d7	148	if (!mmc)
c5d548a9	149	return "No MMC card found";
a8060359	150
d48b8d11	151	#if CONFIG_IS_ENABLED(BLK)
01b73fe6 SG	152	struct udevice *dev;
	153
	154	if (blk_get_from_parent(mmc->dev, &dev))
c5d548a9	155	return "No block device";
01b73fe6	156	#else
c75648d7	157	if (mmc_init(mmc))
c5d548a9	158	return "MMC init failed";
e7017a3c	159	#endif
c75648d7	160	if (mmc_set_env_part(mmc))
c5d548a9	161	return "MMC partition switch failed";
a8060359	162
c75648d7	163	return NULL;
a8060359 TL	164	}
a8060359 TL	165
9404a5fc SW	166	static void fini_mmc_for_env(struct mmc *mmc)
	167	{
	168	#ifdef CONFIG_SYS_MMC_ENV_PART
e92029c0	169	int dev = mmc_get_env_dev();
b9c8ccab	170
69f45cd5	171	blk_select_hwpart_devnum(IF_TYPE_MMC, dev, env_mmc_orig_hwpart);
9404a5fc SW	172	#endif
	173	}
	174
e5bce247	175	#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_SPL_BUILD)
e8db8f71 IG	176	static inline int write_env(struct mmc *mmc, unsigned long size,
e8db8f71 IG	177	unsigned long offset, const void *buffer)
a8060359 TL	178	{
a8060359 TL	179	uint blk_start, blk_cnt, n;
5461acba	180	struct blk_desc *desc = mmc_get_blk_desc(mmc);
a8060359	181
e8db8f71 IG	182	blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
e8db8f71 IG	183	blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;
a8060359	184
5461acba	185	n = blk_dwrite(desc, blk_start, blk_cnt, (u_char *)buffer);
a8060359 TL	186
	187	return (n == blk_cnt) ? 0 : -1;
	188	}
	189
e5bce247	190	static int env_mmc_save(void)
a8060359	191	{
cd0f4fa1	192	ALLOC_CACHE_ALIGN_BUFFER(env_t, env_new, 1);
e92029c0 CG	193	int dev = mmc_get_env_dev();
e92029c0 CG	194	struct mmc *mmc = find_mmc_device(dev);
e8db8f71	195	u32 offset;
d196bd88	196	int ret, copy = 0;
c75648d7	197	const char *errmsg;
a8060359	198
c75648d7 TH	199	errmsg = init_mmc_for_env(mmc);
	200	if (errmsg) {
	201	printf("%s\n", errmsg);
97039ab9	202	return 1;
c75648d7	203	}
97039ab9	204
7ce1526e MV	205	ret = env_export(env_new);
7ce1526e MV	206	if (ret)
9404a5fc	207	goto fini;
d196bd88 MH	208
d196bd88 MH	209	#ifdef CONFIG_ENV_OFFSET_REDUND
203e94f6	210	if (gd->env_valid == ENV_VALID)
d196bd88 MH	211	copy = 1;
	212	#endif
	213
	214	if (mmc_get_env_addr(mmc, copy, &offset)) {
	215	ret = 1;
	216	goto fini;
	217	}
	218
e92029c0	219	printf("Writing to %sMMC(%d)... ", copy ? "redundant " : "", dev);
4036b630	220	if (write_env(mmc, CONFIG_ENV_SIZE, offset, (u_char *)env_new)) {
a8060359	221	puts("failed\n");
9404a5fc SW	222	ret = 1;
9404a5fc SW	223	goto fini;
a8060359 TL	224	}
a8060359 TL	225
9404a5fc SW	226	ret = 0;
9404a5fc SW	227
d196bd88	228	#ifdef CONFIG_ENV_OFFSET_REDUND
203e94f6	229	gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;
d196bd88 MH	230	#endif
d196bd88 MH	231
9404a5fc SW	232	fini:
	233	fini_mmc_for_env(mmc);
	234	return ret;
a8060359	235	}
34853925	236
34853925 FW	237	static inline int erase_env(struct mmc *mmc, unsigned long size,
	238	unsigned long offset)
	239	{
	240	uint blk_start, blk_cnt, n;
	241	struct blk_desc *desc = mmc_get_blk_desc(mmc);
	242
	243	blk_start = ALIGN(offset, mmc->write_bl_len) / mmc->write_bl_len;
	244	blk_cnt = ALIGN(size, mmc->write_bl_len) / mmc->write_bl_len;
	245
	246	n = blk_derase(desc, blk_start, blk_cnt);
	247	printf("%d blocks erased: %s\n", n, (n == blk_cnt) ? "OK" : "ERROR");
	248
	249	return (n == blk_cnt) ? 0 : 1;
	250	}
	251
	252	static int env_mmc_erase(void)
	253	{
	254	int dev = mmc_get_env_dev();
	255	struct mmc *mmc = find_mmc_device(dev);
	256	int ret, copy = 0;
	257	u32 offset;
	258	const char *errmsg;
	259
	260	errmsg = init_mmc_for_env(mmc);
	261	if (errmsg) {
	262	printf("%s\n", errmsg);
	263	return 1;
	264	}
	265
f47f87f2 MV	266	if (mmc_get_env_addr(mmc, copy, &offset)) {
	267	ret = CMD_RET_FAILURE;
	268	goto fini;
	269	}
34853925 FW	270
	271	ret = erase_env(mmc, CONFIG_ENV_SIZE, offset);
	272
	273	#ifdef CONFIG_ENV_OFFSET_REDUND
	274	copy = 1;
	275
f47f87f2 MV	276	if (mmc_get_env_addr(mmc, copy, &offset)) {
	277	ret = CMD_RET_FAILURE;
	278	goto fini;
	279	}
34853925 FW	280
	281	ret \|= erase_env(mmc, CONFIG_ENV_SIZE, offset);
	282	#endif
	283
f47f87f2 MV	284	fini:
f47f87f2 MV	285	fini_mmc_for_env(mmc);
34853925 FW	286	return ret;
34853925 FW	287	}
e5bce247	288	#endif /* CONFIG_CMD_SAVEENV && !CONFIG_SPL_BUILD */
a8060359	289
e8db8f71 IG	290	static inline int read_env(struct mmc *mmc, unsigned long size,
e8db8f71 IG	291	unsigned long offset, const void *buffer)
a8060359 TL	292	{
a8060359 TL	293	uint blk_start, blk_cnt, n;
5461acba	294	struct blk_desc *desc = mmc_get_blk_desc(mmc);
a8060359	295
e8db8f71 IG	296	blk_start = ALIGN(offset, mmc->read_bl_len) / mmc->read_bl_len;
e8db8f71 IG	297	blk_cnt = ALIGN(size, mmc->read_bl_len) / mmc->read_bl_len;
a8060359	298
5461acba	299	n = blk_dread(desc, blk_start, blk_cnt, (uchar *)buffer);
a8060359 TL	300
	301	return (n == blk_cnt) ? 0 : -1;
	302	}
	303
d196bd88	304	#ifdef CONFIG_ENV_OFFSET_REDUND
c5951991	305	static int env_mmc_load(void)
d196bd88 MH	306	{
d196bd88 MH	307	#if !defined(ENV_IS_EMBEDDED)
b9c8ccab	308	struct mmc *mmc;
d196bd88 MH	309	u32 offset1, offset2;
d196bd88 MH	310	int read1_fail = 0, read2_fail = 0;
d196bd88	311	int ret;
e92029c0	312	int dev = mmc_get_env_dev();
c75648d7	313	const char *errmsg = NULL;
d196bd88	314
452a2722 MN	315	ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env1, 1);
	316	ALLOC_CACHE_ALIGN_BUFFER(env_t, tmp_env2, 1);
	317
26862b4a FA	318	mmc_initialize(NULL);
26862b4a FA	319
b9c8ccab TR	320	mmc = find_mmc_device(dev);
b9c8ccab TR	321
c75648d7 TH	322	errmsg = init_mmc_for_env(mmc);
c75648d7 TH	323	if (errmsg) {
c5951991	324	ret = -EIO;
d196bd88 MH	325	goto err;
	326	}
	327
	328	if (mmc_get_env_addr(mmc, 0, &offset1) \|\|
	329	mmc_get_env_addr(mmc, 1, &offset2)) {
c5951991	330	ret = -EIO;
d196bd88 MH	331	goto fini;
	332	}
	333
	334	read1_fail = read_env(mmc, CONFIG_ENV_SIZE, offset1, tmp_env1);
	335	read2_fail = read_env(mmc, CONFIG_ENV_SIZE, offset2, tmp_env2);
	336
31f044bd	337	ret = env_import_redund((char )tmp_env1, read1_fail, (char )tmp_env2,
890feeca	338	read2_fail, H_EXTERNAL);
d196bd88 MH	339
	340	fini:
	341	fini_mmc_for_env(mmc);
	342	err:
	343	if (ret)
0ac7d722	344	env_set_default(errmsg, 0);
c5951991	345
d196bd88	346	#endif
c5951991	347	return ret;
d196bd88 MH	348	}
d196bd88 MH	349	#else /* ! CONFIG_ENV_OFFSET_REDUND */
c5951991	350	static int env_mmc_load(void)
a8060359 TL	351	{
a8060359 TL	352	#if !defined(ENV_IS_EMBEDDED)
cd0f4fa1	353	ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE);
b9c8ccab	354	struct mmc *mmc;
97039ab9	355	u32 offset;
9404a5fc	356	int ret;
e92029c0	357	int dev = mmc_get_env_dev();
c75648d7	358	const char *errmsg;
0536b440	359	env_t *ep = NULL;
b9c8ccab	360
b9c8ccab	361	mmc = find_mmc_device(dev);
a8060359	362
c75648d7 TH	363	errmsg = init_mmc_for_env(mmc);
c75648d7 TH	364	if (errmsg) {
c5951991	365	ret = -EIO;
9404a5fc SW	366	goto err;
9404a5fc SW	367	}
a8060359	368
d196bd88	369	if (mmc_get_env_addr(mmc, 0, &offset)) {
c5951991	370	ret = -EIO;
9404a5fc SW	371	goto fini;
	372	}
	373
cd0f4fa1	374	if (read_env(mmc, CONFIG_ENV_SIZE, offset, buf)) {
c75648d7	375	errmsg = "!read failed";
c5951991	376	ret = -EIO;
9404a5fc SW	377	goto fini;
9404a5fc SW	378	}
a8060359	379
890feeca	380	ret = env_import(buf, 1, H_EXTERNAL);
0536b440 PG	381	if (!ret) {
	382	ep = (env_t *)buf;
	383	gd->env_addr = (ulong)&ep->data;
	384	}
9404a5fc SW	385
	386	fini:
	387	fini_mmc_for_env(mmc);
	388	err:
	389	if (ret)
0ac7d722	390	env_set_default(errmsg, 0);
a8060359	391	#endif
c5951991	392	return ret;
a8060359	393	}
d196bd88	394	#endif /* CONFIG_ENV_OFFSET_REDUND */
4415f1d1 SG	395
	396	U_BOOT_ENV_LOCATION(mmc) = {
	397	.location = ENVL_MMC,
ac358beb	398	ENV_NAME("MMC")
e5bce247	399	.load = env_mmc_load,
4415f1d1	400	#ifndef CONFIG_SPL_BUILD
e5bce247	401	.save = env_save_ptr(env_mmc_save),
1af031ac	402	.erase = ENV_ERASE_PTR(env_mmc_erase)
4415f1d1	403	#endif
4415f1d1	404	};