[thirdparty/u-boot.git] / common / spl / spl_mmc.c

/*
 * (C) Copyright 2010
 * Texas Instruments, <www.ti.com>
 *
 * Aneesh V <aneesh@ti.com>
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */
#include <common.h>
#include <dm.h>
#include <spl.h>
#include <linux/compiler.h>
#include <errno.h>
#include <asm/u-boot.h>
#include <errno.h>
#include <mmc.h>
#include <image.h>

DECLARE_GLOBAL_DATA_PTR;

static int mmc_load_legacy(struct mmc *mmc, ulong sector,
			   struct image_header *header)
{
	u32 image_size_sectors;
	unsigned long count;

	spl_parse_image_header(header);
	/* convert size to sectors - round up */
	image_size_sectors = (spl_image.size + mmc->read_bl_len - 1) /
			     mmc->read_bl_len;

	/* Read the header too to avoid extra memcpy */
	count = mmc->block_dev.block_read(&mmc->block_dev, sector,
					  image_size_sectors,
					  (void *)(ulong)spl_image.load_addr);
	debug("read %x sectors to %x\n", image_size_sectors,
	      spl_image.load_addr);
	if (count != image_size_sectors)
		return -EIO;

	return 0;
}

static ulong h_spl_load_read(struct spl_load_info *load, ulong sector,
			     ulong count, void *buf)
{
	struct mmc *mmc = load->dev;

	return mmc->block_dev.block_read(&mmc->block_dev, sector, count, buf);
}

static int mmc_load_image_raw_sector(struct mmc *mmc, unsigned long sector)
{
	unsigned long count;
	struct image_header *header;
	int ret = 0;

	header = (struct image_header *)(CONFIG_SYS_TEXT_BASE -
					 sizeof(struct image_header));

	/* read image header to find the image size & load address */
	count = mmc->block_dev.block_read(&mmc->block_dev, sector, 1, header);
	debug("hdr read sector %lx, count=%lu\n", sector, count);
	if (count == 0) {
		ret = -EIO;
		goto end;
	}

	if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) &&
	    image_get_magic(header) == FDT_MAGIC) {
		struct spl_load_info load;

		debug("Found FIT\n");
		load.dev = mmc;
		load.priv = NULL;
		load.bl_len = mmc->read_bl_len;
		load.read = h_spl_load_read;
		ret = spl_load_simple_fit(&load, sector, header);
	} else {
		ret = mmc_load_legacy(mmc, sector, header);
	}

end:
	if (ret) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
		puts("spl: mmc block read error\n");
#endif
		return -1;
	}

	return 0;
}

int spl_mmc_get_device_index(u32 boot_device)
{
	switch (boot_device) {
	case BOOT_DEVICE_MMC1:
		return 0;
	case BOOT_DEVICE_MMC2:
	case BOOT_DEVICE_MMC2_2:
		return 1;
	}

#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
	printf("spl: unsupported mmc boot device.\n");
#endif

	return -ENODEV;
}

static int spl_mmc_find_device(struct mmc **mmcp, u32 boot_device)
{
#ifdef CONFIG_DM_MMC
	struct udevice *dev;
#endif
	int err, mmc_dev;

	mmc_dev = spl_mmc_get_device_index(boot_device);
	if (mmc_dev < 0)
		return mmc_dev;

	err = mmc_initialize(NULL);
	if (err) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
		printf("spl: could not initialize mmc. error: %d\n", err);
#endif
		return err;
	}

#ifdef CONFIG_DM_MMC
	err = uclass_get_device(UCLASS_MMC, mmc_dev, &dev);
	if (!err)
		*mmcp = mmc_get_mmc_dev(dev);
#else
	*mmcp = find_mmc_device(mmc_dev);
	err = *mmcp ? 0 : -ENODEV;
#endif
	if (err) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
		printf("spl: could not find mmc device. error: %d\n", err);
#endif
		return err;
	}

	return 0;
}

#ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION
static int mmc_load_image_raw_partition(struct mmc *mmc, int partition)
{
	disk_partition_t info;
	int err;

	err = part_get_info(&mmc->block_dev, partition, &info);
	if (err) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
		puts("spl: partition error\n");
#endif
		return -1;
	}

#ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR
	return mmc_load_image_raw_sector(mmc, info.start +
					 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
#else
	return mmc_load_image_raw_sector(mmc, info.start);
#endif
}
#else
#define CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION -1
static int mmc_load_image_raw_partition(struct mmc *mmc, int partition)
{
	return -ENOSYS;
}
#endif

#ifdef CONFIG_SPL_OS_BOOT
static int mmc_load_image_raw_os(struct mmc *mmc)
{
	unsigned long count;

	count = mmc->block_dev.block_read(&mmc->block_dev,
		CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR,
		CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS,
		(void *) CONFIG_SYS_SPL_ARGS_ADDR);
	if (count == 0) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
		puts("spl: mmc block read error\n");
#endif
		return -1;
	}

	return mmc_load_image_raw_sector(mmc,
		CONFIG_SYS_MMCSD_RAW_MODE_KERNEL_SECTOR);
}
#else
int spl_start_uboot(void)
{
	return 1;
}
static int mmc_load_image_raw_os(struct mmc *mmc)
{
	return -ENOSYS;
}
#endif

#ifdef CONFIG_SYS_MMCSD_FS_BOOT_PARTITION
int spl_mmc_do_fs_boot(struct mmc *mmc)
{
	int err = -ENOSYS;

#ifdef CONFIG_SPL_FAT_SUPPORT
	if (!spl_start_uboot()) {
		err = spl_load_image_fat_os(&mmc->block_dev,
			CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
		if (!err)
			return err;
	}
#ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
	err = spl_load_image_fat(&mmc->block_dev,
				 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
				 CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
	if (!err)
		return err;
#endif
#endif
#ifdef CONFIG_SPL_EXT_SUPPORT
	if (!spl_start_uboot()) {
		err = spl_load_image_ext_os(&mmc->block_dev,
			CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
		if (!err)
			return err;
	}
#ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
	err = spl_load_image_ext(&mmc->block_dev,
				 CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
				 CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
	if (!err)
		return err;
#endif
#endif

#if defined(CONFIG_SPL_FAT_SUPPORT) || defined(CONFIG_SPL_EXT_SUPPORT)
	err = -ENOENT;
#endif

	return err;
}
#else
int spl_mmc_do_fs_boot(struct mmc *mmc)
{
	return -ENOSYS;
}
#endif

int spl_mmc_load_image(u32 boot_device)
{
	struct mmc *mmc = NULL;
	u32 boot_mode;
	int err = 0;
	__maybe_unused int part;

	err = spl_mmc_find_device(&mmc, boot_device);
	if (err)
		return err;

	err = mmc_init(mmc);
	if (err) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
		printf("spl: mmc init failed with error: %d\n", err);
#endif
		return err;
	}

	boot_mode = spl_boot_mode();
	err = -EINVAL;
	switch (boot_mode) {
	case MMCSD_MODE_EMMCBOOT:
			/*
			 * We need to check what the partition is configured to.
			 * 1 and 2 match up to boot0 / boot1 and 7 is user data
			 * which is the first physical partition (0).
			 */
			part = (mmc->part_config >> 3) & PART_ACCESS_MASK;

			if (part == 7)
				part = 0;

			err = mmc_switch_part(0, part);
			if (err) {
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
				puts("spl: mmc partition switch failed\n");
#endif
				return err;
			}
			/* Fall through */
	case MMCSD_MODE_RAW:
		debug("spl: mmc boot mode: raw\n");

		if (!spl_start_uboot()) {
			err = mmc_load_image_raw_os(mmc);
			if (!err)
				return err;
		}

		err = mmc_load_image_raw_partition(mmc,
			CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION);
		if (!err)
			return err;
#if defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR)
		err = mmc_load_image_raw_sector(mmc,
			CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
		if (!err)
			return err;
#endif
		/* If RAW mode fails, try FS mode. */
	case MMCSD_MODE_FS:
		debug("spl: mmc boot mode: fs\n");

		err = spl_mmc_do_fs_boot(mmc);
		if (!err)
			return err;

		break;
	case MMCSD_MODE_UNDEFINED:
#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
	default:
		puts("spl: mmc: wrong boot mode\n");
#endif
	}

	return err;
}
Commit	Line	Data
9ea5c6ef SS	1	/*
	2	* (C) Copyright 2010
	3	* Texas Instruments, <www.ti.com>
	4	*
	5	* Aneesh V <aneesh@ti.com>
	6	*
1a459660	7	* SPDX-License-Identifier: GPL-2.0+
9ea5c6ef SS	8	*/
9ea5c6ef SS	9	#include <common.h>
dc3dedfe	10	#include <dm.h>
47f7bcae	11	#include <spl.h>
91199f4a	12	#include <linux/compiler.h>
36afd451	13	#include <errno.h>
9ea5c6ef	14	#include <asm/u-boot.h>
4188ba32	15	#include <errno.h>
9ea5c6ef	16	#include <mmc.h>
e4c444b3	17	#include <image.h>
9ea5c6ef SS	18
	19	DECLARE_GLOBAL_DATA_PTR;
	20
96debd1f SG	21	static int mmc_load_legacy(struct mmc *mmc, ulong sector,
	22	struct image_header *header)
	23	{
	24	u32 image_size_sectors;
	25	unsigned long count;
	26
	27	spl_parse_image_header(header);
	28	/* convert size to sectors - round up */
	29	image_size_sectors = (spl_image.size + mmc->read_bl_len - 1) /
	30	mmc->read_bl_len;
	31
	32	/* Read the header too to avoid extra memcpy */
	33	count = mmc->block_dev.block_read(&mmc->block_dev, sector,
	34	image_size_sectors,
	35	(void *)(ulong)spl_image.load_addr);
	36	debug("read %x sectors to %x\n", image_size_sectors,
	37	spl_image.load_addr);
	38	if (count != image_size_sectors)
	39	return -EIO;
	40
	41	return 0;
	42	}
	43
96debd1f SG	44	static ulong h_spl_load_read(struct spl_load_info *load, ulong sector,
	45	ulong count, void *buf)
	46	{
	47	struct mmc *mmc = load->dev;
	48
	49	return mmc->block_dev.block_read(&mmc->block_dev, sector, count, buf);
	50	}
96debd1f	51
b97300b6	52	static int mmc_load_image_raw_sector(struct mmc *mmc, unsigned long sector)
9ea5c6ef	53	{
3bc37b6d	54	unsigned long count;
2e222105	55	struct image_header *header;
96debd1f	56	int ret = 0;
9ea5c6ef SS	57
9ea5c6ef SS	58	header = (struct image_header *)(CONFIG_SYS_TEXT_BASE -
91199f4a	59	sizeof(struct image_header));
9ea5c6ef SS	60
9ea5c6ef SS	61	/* read image header to find the image size & load address */
7c4213f6	62	count = mmc->block_dev.block_read(&mmc->block_dev, sector, 1, header);
96debd1f SG	63	debug("hdr read sector %lx, count=%lu\n", sector, count);
	64	if (count == 0) {
	65	ret = -EIO;
9ea5c6ef	66	goto end;
96debd1f	67	}
9ea5c6ef	68
4976f482 MY	69	if (IS_ENABLED(CONFIG_SPL_LOAD_FIT) &&
4976f482 MY	70	image_get_magic(header) == FDT_MAGIC) {
96debd1f SG	71	struct spl_load_info load;
	72
	73	debug("Found FIT\n");
	74	load.dev = mmc;
	75	load.priv = NULL;
	76	load.bl_len = mmc->read_bl_len;
	77	load.read = h_spl_load_read;
	78	ret = spl_load_simple_fit(&load, sector, header);
4976f482 MY	79	} else {
4976f482 MY	80	ret = mmc_load_legacy(mmc, sector, header);
fdfa39d3	81	}
e4c444b3	82
9ea5c6ef	83	end:
96debd1f	84	if (ret) {
8112f5fa	85	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
1ec26469	86	puts("spl: mmc block read error\n");
8112f5fa	87	#endif
3bc37b6d	88	return -1;
1ec26469	89	}
3bc37b6d PK	90
3bc37b6d PK	91	return 0;
9ea5c6ef SS	92	}
9ea5c6ef SS	93
a1e56cf6 NK	94	int spl_mmc_get_device_index(u32 boot_device)
	95	{
	96	switch (boot_device) {
	97	case BOOT_DEVICE_MMC1:
	98	return 0;
	99	case BOOT_DEVICE_MMC2:
	100	case BOOT_DEVICE_MMC2_2:
	101	return 1;
	102	}
	103
	104	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
	105	printf("spl: unsupported mmc boot device.\n");
	106	#endif
	107
	108	return -ENODEV;
	109	}
	110
99c7a51a	111	static int spl_mmc_find_device(struct mmc **mmcp, u32 boot_device)
4188ba32	112	{
b4857aa9	113	#ifdef CONFIG_DM_MMC
4188ba32	114	struct udevice *dev;
b4857aa9	115	#endif
a1e56cf6 NK	116	int err, mmc_dev;
	117
	118	mmc_dev = spl_mmc_get_device_index(boot_device);
	119	if (mmc_dev < 0)
	120	return mmc_dev;
4188ba32 NK	121
	122	err = mmc_initialize(NULL);
	123	if (err) {
	124	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
	125	printf("spl: could not initialize mmc. error: %d\n", err);
	126	#endif
	127	return err;
	128	}
	129
b4857aa9	130	#ifdef CONFIG_DM_MMC
a1e56cf6	131	err = uclass_get_device(UCLASS_MMC, mmc_dev, &dev);
b4857aa9 SG	132	if (!err)
b4857aa9 SG	133	*mmcp = mmc_get_mmc_dev(dev);
4188ba32	134	#else
b4857aa9 SG	135	*mmcp = find_mmc_device(mmc_dev);
	136	err = *mmcp ? 0 : -ENODEV;
	137	#endif
4188ba32 NK	138	if (err) {
4188ba32 NK	139	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
b4857aa9	140	printf("spl: could not find mmc device. error: %d\n", err);
4188ba32 NK	141	#endif
	142	return err;
	143	}
	144
4188ba32 NK	145	return 0;
4188ba32 NK	146	}
4188ba32	147
b97300b6 PK	148	#ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION
	149	static int mmc_load_image_raw_partition(struct mmc *mmc, int partition)
	150	{
	151	disk_partition_t info;
3bc37b6d	152	int err;
b97300b6	153
3e8bd469	154	err = part_get_info(&mmc->block_dev, partition, &info);
3bc37b6d	155	if (err) {
b97300b6	156	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
1ec26469	157	puts("spl: partition error\n");
b97300b6 PK	158	#endif
	159	return -1;
	160	}
	161
4bfcc54c SR	162	#ifdef CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR
	163	return mmc_load_image_raw_sector(mmc, info.start +
	164	CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
	165	#else
b97300b6	166	return mmc_load_image_raw_sector(mmc, info.start);
4bfcc54c	167	#endif
b97300b6	168	}
d074ebb9 NK	169	#else
	170	#define CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION -1
	171	static int mmc_load_image_raw_partition(struct mmc *mmc, int partition)
	172	{
	173	return -ENOSYS;
	174	}
b97300b6 PK	175	#endif
b97300b6 PK	176
2b75b0ad PK	177	#ifdef CONFIG_SPL_OS_BOOT
	178	static int mmc_load_image_raw_os(struct mmc *mmc)
	179	{
3bc37b6d	180	unsigned long count;
91199f4a	181
7c4213f6	182	count = mmc->block_dev.block_read(&mmc->block_dev,
3bc37b6d PK	183	CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTOR,
	184	CONFIG_SYS_MMCSD_RAW_MODE_ARGS_SECTORS,
	185	(void *) CONFIG_SYS_SPL_ARGS_ADDR);
	186	if (count == 0) {
8112f5fa	187	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
1ec26469	188	puts("spl: mmc block read error\n");
8112f5fa	189	#endif
2b75b0ad PK	190	return -1;
	191	}
	192
b97300b6	193	return mmc_load_image_raw_sector(mmc,
91199f4a	194	CONFIG_SYS_MMCSD_RAW_MODE_KERNEL_SECTOR);
2b75b0ad	195	}
339245b7 NK	196	#else
	197	int spl_start_uboot(void)
	198	{
	199	return 1;
	200	}
	201	static int mmc_load_image_raw_os(struct mmc *mmc)
	202	{
	203	return -ENOSYS;
	204	}
2b75b0ad PK	205	#endif
2b75b0ad PK	206
f52b7293 NK	207	#ifdef CONFIG_SYS_MMCSD_FS_BOOT_PARTITION
	208	int spl_mmc_do_fs_boot(struct mmc *mmc)
	209	{
	210	int err = -ENOSYS;
	211
	212	#ifdef CONFIG_SPL_FAT_SUPPORT
	213	if (!spl_start_uboot()) {
	214	err = spl_load_image_fat_os(&mmc->block_dev,
	215	CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
	216	if (!err)
	217	return err;
	218	}
	219	#ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
	220	err = spl_load_image_fat(&mmc->block_dev,
	221	CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
	222	CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
	223	if (!err)
	224	return err;
	225	#endif
	226	#endif
	227	#ifdef CONFIG_SPL_EXT_SUPPORT
	228	if (!spl_start_uboot()) {
	229	err = spl_load_image_ext_os(&mmc->block_dev,
	230	CONFIG_SYS_MMCSD_FS_BOOT_PARTITION);
	231	if (!err)
	232	return err;
	233	}
	234	#ifdef CONFIG_SPL_FS_LOAD_PAYLOAD_NAME
	235	err = spl_load_image_ext(&mmc->block_dev,
	236	CONFIG_SYS_MMCSD_FS_BOOT_PARTITION,
	237	CONFIG_SPL_FS_LOAD_PAYLOAD_NAME);
	238	if (!err)
	239	return err;
	240	#endif
	241	#endif
	242
	243	#if defined(CONFIG_SPL_FAT_SUPPORT) \|\| defined(CONFIG_SPL_EXT_SUPPORT)
	244	err = -ENOENT;
	245	#endif
	246
	247	return err;
	248	}
	249	#else
	250	int spl_mmc_do_fs_boot(struct mmc *mmc)
	251	{
	252	return -ENOSYS;
	253	}
	254	#endif
	255
a1e56cf6	256	int spl_mmc_load_image(u32 boot_device)
9ea5c6ef	257	{
d773a008	258	struct mmc *mmc = NULL;
9ea5c6ef	259	u32 boot_mode;
dc3dedfe	260	int err = 0;
91199f4a	261	__maybe_unused int part;
9ea5c6ef	262
a1e56cf6	263	err = spl_mmc_find_device(&mmc, boot_device);
36afd451 NK	264	if (err)
36afd451 NK	265	return err;
9ea5c6ef	266
4188ba32	267	err = mmc_init(mmc);
9ea5c6ef	268	if (err) {
8112f5fa	269	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
91199f4a	270	printf("spl: mmc init failed with error: %d\n", err);
8112f5fa	271	#endif
36afd451	272	return err;
9ea5c6ef	273	}
79adb7a2	274
37189a19	275	boot_mode = spl_boot_mode();
36afd451	276	err = -EINVAL;
91199f4a	277	switch (boot_mode) {
83cdf6fa NK	278	case MMCSD_MODE_EMMCBOOT:
	279	/*
	280	* We need to check what the partition is configured to.
	281	* 1 and 2 match up to boot0 / boot1 and 7 is user data
	282	* which is the first physical partition (0).
	283	*/
	284	part = (mmc->part_config >> 3) & PART_ACCESS_MASK;
	285
	286	if (part == 7)
	287	part = 0;
	288
36afd451 NK	289	err = mmc_switch_part(0, part);
36afd451 NK	290	if (err) {
83cdf6fa NK	291	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
	292	puts("spl: mmc partition switch failed\n");
	293	#endif
36afd451	294	return err;
83cdf6fa NK	295	}
83cdf6fa NK	296	/* Fall through */
91199f4a PK	297	case MMCSD_MODE_RAW:
	298	debug("spl: mmc boot mode: raw\n");
	299
91199f4a PK	300	if (!spl_start_uboot()) {
	301	err = mmc_load_image_raw_os(mmc);
	302	if (!err)
36afd451	303	return err;
91199f4a	304	}
d074ebb9	305
b97300b6 PK	306	err = mmc_load_image_raw_partition(mmc,
b97300b6 PK	307	CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_PARTITION);
3ae8f4c8	308	if (!err)
36afd451	309	return err;
d074ebb9	310	#if defined(CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR)
b97300b6	311	err = mmc_load_image_raw_sector(mmc,
773b5940	312	CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR);
91199f4a	313	if (!err)
36afd451	314	return err;
3ae8f4c8	315	#endif
86a0df73	316	/* If RAW mode fails, try FS mode. */
91199f4a PK	317	case MMCSD_MODE_FS:
	318	debug("spl: mmc boot mode: fs\n");
	319
f52b7293	320	err = spl_mmc_do_fs_boot(mmc);
91199f4a	321	if (!err)
36afd451	322	return err;
f52b7293	323
fd61d399	324	break;
91199f4a	325	case MMCSD_MODE_UNDEFINED:
8112f5fa	326	#ifdef CONFIG_SPL_LIBCOMMON_SUPPORT
fd61d399 NK	327	default:
fd61d399 NK	328	puts("spl: mmc: wrong boot mode\n");
8112f5fa	329	#endif
91199f4a	330	}
fd61d399	331
36afd451	332	return err;
9ea5c6ef	333	}