tools/mkfwumdata.c - filogic/uboot - Gitiles

 // SPDX-License-Identifier: GPL-2.0+
 /*
  * Copyright (c) 2023, Linaro Limited
  */

 #include <errno.h>
 #include <getopt.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <generated/autoconf.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <u-boot/crc.h>
 #include <uuid/uuid.h>

 typedef uint8_t u8;
 typedef int16_t s16;
 typedef uint16_t u16;
 typedef uint32_t u32;
 typedef uint64_t u64;

 #undef CONFIG_FWU_NUM_BANKS
 #undef CONFIG_FWU_NUM_IMAGES_PER_BANK

 /* This will dynamically allocate the fwu_mdata */
 #define CONFIG_FWU_NUM_BANKS		0
 #define CONFIG_FWU_NUM_IMAGES_PER_BANK	0

 /* version 2 supports maximum of 4 banks */
 #define MAX_BANKS_V2			4

 #define BANK_INVALID			(u8)0xFF
 #define BANK_ACCEPTED			(u8)0xFC

 #include <fwu_mdata.h>

 static const char *opts_short = "b:i:a:p:v:V:gh";

 static struct option options[] = {
 	{"banks", required_argument, NULL, 'b'},
 	{"images", required_argument, NULL, 'i'},
 	{"guid", required_argument, NULL, 'g'},
 	{"active-bank", required_argument, NULL, 'a'},
 	{"previous-bank", required_argument, NULL, 'p'},
 	{"version", required_argument, NULL, 'v'},
 	{"vendor-file", required_argument, NULL, 'V'},
 	{"help", no_argument, NULL, 'h'},
 	{NULL, 0, NULL, 0},
 };

 static void print_usage(void)
 {
 	fprintf(stderr, "Usage: mkfwumdata [options] <UUIDs list> <output file>\n");
 	fprintf(stderr, "Options:\n"
 		"\t-i, --images <num>          Number of images (mandatory)\n"
 		"\t-b, --banks  <num>          Number of banks (mandatory)\n"
 		"\t-v, --version               Metadata version (mandatory)\n"
 		"\t-a, --active-bank  <num>    Active bank (default=0)\n"
 		"\t-p, --previous-bank  <num>  Previous active bank (default=active_bank - 1)\n"
 		"\t-g, --guid                  Use GUID instead of UUID\n"
 		"\t-V, --vendor-file           Vendor data file to append to the metadata\n"
 		"\t-h, --help                  print a help message\n"
 		);
 	fprintf(stderr, "  UUIDs list syntax:\n"
 		"\t  <location uuid>,<image type uuid>,<images uuid list>\n"
 		"\t     images uuid list syntax:\n"
 		"\t        img_uuid_00,img_uuid_01...img_uuid_0b,\n"
 		"\t        img_uuid_10,img_uuid_11...img_uuid_1b,\n"
 		"\t        ...,\n"
 		"\t        img_uuid_i0,img_uuid_i1...img_uuid_ib,\n"
 		"\t          where 'b' and 'i' are number of banks and number\n"
 		"\t          of images in a bank respectively.\n"
 	       );
 }

 struct fwu_mdata_object {
 	size_t images;
 	size_t banks;
 	size_t size;
 	u8 version;
 	size_t vsize;
 	void *vbuf;
 	struct fwu_mdata *mdata;
 };

 static int previous_bank, active_bank;
 static bool __use_guid;

 static bool supported_mdata_version(unsigned long version)
 {
 	switch (version) {
 	case 1:
 	case 2:
 		return true;
 	default:
 		return false;
 	}
 }

 static struct fwu_mdata_object *fwu_alloc_mdata(size_t images, size_t banks,
 						u8 version, size_t vendor_size)
 {
 	struct fwu_mdata_object *mobj;

 	mobj = calloc(1, sizeof(*mobj));
 	if (!mobj)
 		return NULL;

 	if (version == 1) {
 		mobj->size = sizeof(struct fwu_mdata) +
 			(sizeof(struct fwu_image_entry) +
 			 sizeof(struct fwu_image_bank_info) * banks) * images;
 	} else {
 		mobj->size = sizeof(struct fwu_mdata) +
 			sizeof(struct fwu_fw_store_desc) +
 			(sizeof(struct fwu_image_entry) +
 			 sizeof(struct fwu_image_bank_info) * banks) * images;

 		mobj->size += vendor_size;
 		mobj->vsize = vendor_size;
 	}

 	mobj->images = images;
 	mobj->banks = banks;
 	mobj->version = version;

 	mobj->mdata = calloc(1, mobj->size);
 	if (!mobj->mdata)
 		goto alloc_err;

 	if (vendor_size) {
 		mobj->vbuf = calloc(1, mobj->vsize);
 		if (!mobj->vbuf)
 			goto alloc_err;
 	}

 	return mobj;

 alloc_err:
 	free(mobj->mdata);
 	free(mobj);
 	return NULL;
 }

 static struct fwu_image_entry *
 fwu_get_image(struct fwu_mdata_object *mobj, size_t idx)
 {
 	size_t offset;

 	if (mobj->version == 1) {
 		offset = sizeof(struct fwu_mdata) +
 			(sizeof(struct fwu_image_entry) +
 			 sizeof(struct fwu_image_bank_info) * mobj->banks) *
 			idx;
 	} else {
 		offset = sizeof(struct fwu_mdata) +
 			sizeof(struct fwu_fw_store_desc) +
 			(sizeof(struct fwu_image_entry) +
 			 sizeof(struct fwu_image_bank_info) * mobj->banks) *
 			idx;
 	}

 	return (struct fwu_image_entry *)((char *)mobj->mdata + offset);
 }

 static struct fwu_image_bank_info *
 fwu_get_bank(struct fwu_mdata_object *mobj, size_t img_idx, size_t bnk_idx)
 {
 	size_t offset;

 	if (mobj->version == 1) {
 		offset = sizeof(struct fwu_mdata) +
 			(sizeof(struct fwu_image_entry) +
 			 sizeof(struct fwu_image_bank_info) * mobj->banks) *
 			img_idx + sizeof(struct fwu_image_entry) +
 			sizeof(struct fwu_image_bank_info) * bnk_idx;
 	} else {
 		offset = sizeof(struct fwu_mdata) +
 			sizeof(struct fwu_fw_store_desc) +
 			(sizeof(struct fwu_image_entry) +
 			 sizeof(struct fwu_image_bank_info) * mobj->banks) *
 			img_idx + sizeof(struct fwu_image_entry) +
 			sizeof(struct fwu_image_bank_info) * bnk_idx;
 	}

 	return (struct fwu_image_bank_info *)((char *)mobj->mdata + offset);
 }

 /**
  * convert_uuid_to_guid() - convert UUID to GUID
  * @buf:	UUID binary
  *
  * UUID and GUID have the same data structure, but their binary
  * formats are different due to the endianness. See lib/uuid.c.
  * Since uuid_parse() can handle only UUID, this function must
  * be called to get correct data for GUID when parsing a string.
  *
  * The correct data will be returned in @buf.
  */
 static void convert_uuid_to_guid(unsigned char *buf)
 {
 	unsigned char c;

 	c = buf[0];
 	buf[0] = buf[3];
 	buf[3] = c;
 	c = buf[1];
 	buf[1] = buf[2];
 	buf[2] = c;

 	c = buf[4];
 	buf[4] = buf[5];
 	buf[5] = c;

 	c = buf[6];
 	buf[6] = buf[7];
 	buf[7] = c;
 }

 static int uuid_guid_parse(char *uuidstr, unsigned char *uuid)
 {
 	int ret;

 	ret = uuid_parse(uuidstr, uuid);
 	if (ret < 0)
 		return ret;

 	if (__use_guid)
 		convert_uuid_to_guid(uuid);

 	return ret;
 }

 static int
 fwu_parse_fill_image_uuid(struct fwu_mdata_object *mobj,
 			  size_t idx, char *uuids)
 {
 	struct fwu_image_entry *image = fwu_get_image(mobj, idx);
 	struct fwu_image_bank_info *bank;
 	char *p = uuids, *uuid;
 	int i;

 	if (!image)
 		return -ENOENT;

 	/* Image location UUID */
 	uuid = strsep(&p, ",");
 	if (!uuid)
 		return -EINVAL;

 	if (strcmp(uuid, "0") &&
 	    uuid_guid_parse(uuid, (unsigned char *)&image->location_guid) < 0)
 		return -EINVAL;

 	/* Image type UUID */
 	uuid = strsep(&p, ",");
 	if (!uuid)
 		return -EINVAL;

 	if (uuid_guid_parse(uuid, (unsigned char *)&image->image_type_guid) < 0)
 		return -EINVAL;

 	/* Fill bank image-UUID */
 	for (i = 0; i < mobj->banks; i++) {
 		bank = fwu_get_bank(mobj, idx, i);
 		if (!bank)
 			return -ENOENT;
 		bank->accepted = 1;
 		uuid = strsep(&p, ",");
 		if (!uuid)
 			return -EINVAL;

 		if (strcmp(uuid, "0") &&
 		    uuid_guid_parse(uuid, (unsigned char *)&bank->image_guid) < 0)
 			return -EINVAL;
 	}
 	return 0;
 }

 #if defined(CONFIG_FWU_MDATA_V1)
 static void fwu_fill_version_specific_mdata(struct fwu_mdata_object *mobj)
 {
 }
 #else
 static void fwu_fill_version_specific_mdata(struct fwu_mdata_object *mobj)
 {
 	int i;
 	struct fwu_fw_store_desc *fw_desc;
 	struct fwu_mdata *mdata = mobj->mdata;

 	mdata->metadata_size = mobj->size;
 	mdata->desc_offset = sizeof(struct fwu_mdata);

 	for (i = 0; i < MAX_BANKS_V2; i++)
 		mdata->bank_state[i] = i < mobj->banks ?
 			BANK_ACCEPTED : BANK_INVALID;

 	fw_desc = (struct fwu_fw_store_desc *)((u8 *)mdata + sizeof(*mdata));
 	fw_desc->num_banks = mobj->banks;
 	fw_desc->num_images = mobj->images;
 	fw_desc->img_entry_size = sizeof(struct fwu_image_entry) +
 		(sizeof(struct fwu_image_bank_info) * mobj->banks);
 	fw_desc->bank_info_entry_size =
 		sizeof(struct fwu_image_bank_info);
 }
 #endif /* CONFIG_FWU_MDATA_V1 */

 /* Caller must ensure that @uuids[] has @mobj->images entries. */
 static int fwu_parse_fill_uuids(struct fwu_mdata_object *mobj, char *uuids[])
 {
 	struct fwu_mdata *mdata = mobj->mdata;
 	char *vdata;
 	int i, ret;

 	mdata->version = mobj->version;
 	mdata->active_index = active_bank;
 	mdata->previous_active_index = previous_bank;

 	fwu_fill_version_specific_mdata(mobj);

 	for (i = 0; i < mobj->images; i++) {
 		ret = fwu_parse_fill_image_uuid(mobj, i, uuids[i]);
 		if (ret < 0)
 			return ret;
 	}

 	if (mobj->vsize) {
 		vdata = (char *)mobj->mdata + (mobj->size - mobj->vsize);
 		memcpy(vdata, mobj->vbuf, mobj->vsize);
 	}

 	mdata->crc32 = crc32(0, (const unsigned char *)&mdata->version,
 			     mobj->size - sizeof(uint32_t));

 	return 0;
 }

 static int fwu_read_vendor_data(struct fwu_mdata_object *mobj,
 				const char *vendor_file)
 {
 	int ret = 0;
 	FILE *vfile = NULL;

 	vfile = fopen(vendor_file, "r");
 	if (!vfile) {
 		ret = -1;
 		goto out;
 	}

 	if (fread(mobj->vbuf, 1, mobj->vsize, vfile) != mobj->vsize)
 		ret = -1;

 out:
 	fclose(vfile);
 	return ret;
 }

 static int fwu_make_mdata(size_t images, size_t banks, u8 version,
 			  const char *vendor_file, char *uuids[],
 			  char *output)
 {
 	int ret;
 	FILE *file;
 	struct stat sbuf;
 	size_t vendor_size = 0;
 	struct fwu_mdata_object *mobj;

 	if (vendor_file) {
 		ret = stat(vendor_file, &sbuf);
 		if (ret)
 			return -errno;

 		vendor_size = sbuf.st_size;
 	}

 	mobj = fwu_alloc_mdata(images, banks, version, vendor_size);
 	if (!mobj)
 		return -ENOMEM;

 	if (vendor_file) {
 		ret = fwu_read_vendor_data(mobj, vendor_file);
 		if (ret)
 			goto done_make;
 	}

 	ret = fwu_parse_fill_uuids(mobj, uuids);
 	if (ret < 0)
 		goto done_make;

 	file = fopen(output, "w");
 	if (!file) {
 		ret = -errno;
 		goto done_make;
 	}

 	ret = fwrite(mobj->mdata, 1, mobj->size, file);
 	if (ret != mobj->size)
 		ret = -errno;
 	else
 		ret = 0;

 	fclose(file);

 done_make:
 	free(mobj->mdata);
 	free(mobj->vbuf);
 	free(mobj);

 	return ret;
 }

 int main(int argc, char *argv[])
 {
 	unsigned long banks = 0, images = 0, version = 0;
 	int c, ret;
 	const char *vendor_file;

 	/* Explicitly initialize defaults */
 	active_bank = 0;
 	__use_guid = false;
 	previous_bank = INT_MAX;
 	vendor_file = NULL;

 	do {
 		c = getopt_long(argc, argv, opts_short, options, NULL);
 		switch (c) {
 		case 'h':
 			print_usage();
 			return 0;
 		case 'b':
 			banks = strtoul(optarg, NULL, 0);
 			break;
 		case 'i':
 			images = strtoul(optarg, NULL, 0);
 			break;
 		case 'g':
 			__use_guid = true;
 			break;
 		case 'p':
 			previous_bank = strtoul(optarg, NULL, 0);
 			break;
 		case 'a':
 			active_bank = strtoul(optarg, NULL, 0);
 			break;
 		case 'v':
 			version = strtoul(optarg, NULL, 0);
 			break;
 		case 'V':
 			vendor_file = optarg;
 			break;
 		}
 	} while (c != -1);

 	if (!banks || !images) {
 		fprintf(stderr, "Error: The number of banks and images must not be 0.\n");
 		return -EINVAL;
 	}

 	if (!version || !supported_mdata_version(version)) {
 		fprintf(stderr, "Error: Version value can only be either 1 or 2, not %ld.\n",
 			version);
 		return -EINVAL;
 	}

 	if (version == 1 && vendor_file) {
 		fprintf(stderr, "Error: Vendor Data can only be appended in version 2 of FWU Metadata.\n");
 		return -EINVAL;
 	}

 	/* This command takes UUIDs * images and output file. */
 	if (optind + images + 1 != argc) {
 		fprintf(stderr, "Error: UUID list or output file is not specified or too much.\n");
 		print_usage();
 		return -ERANGE;
 	}

 	if (previous_bank == INT_MAX) {
 		/* set to the earlier bank in round-robin scheme */
 		previous_bank = active_bank > 0 ? active_bank - 1 : banks - 1;
 	}

 	ret = fwu_make_mdata(images, banks, (u8)version, vendor_file,
 			     argv + optind, argv[argc - 1]);
 	if (ret < 0)
 		fprintf(stderr, "Error: Failed to parse and write image: %s\n",
 			strerror(-ret));

 	return ret;
 }
	// SPDX-License-Identifier: GPL-2.0+
	/*
	* Copyright (c) 2023, Linaro Limited
	*/

	#include <errno.h>
	#include <getopt.h>
	#include <limits.h>
	#include <stdio.h>
	#include <stdint.h>
	#include <stdlib.h>
	#include <string.h>
	#include <unistd.h>
	#include <generated/autoconf.h>
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <u-boot/crc.h>
	#include <uuid/uuid.h>

	typedef uint8_t u8;
	typedef int16_t s16;
	typedef uint16_t u16;
	typedef uint32_t u32;
	typedef uint64_t u64;

	#undef CONFIG_FWU_NUM_BANKS
	#undef CONFIG_FWU_NUM_IMAGES_PER_BANK

	/* This will dynamically allocate the fwu_mdata */
	#define CONFIG_FWU_NUM_BANKS 0
	#define CONFIG_FWU_NUM_IMAGES_PER_BANK 0

	/* version 2 supports maximum of 4 banks */
	#define MAX_BANKS_V2 4

	#define BANK_INVALID (u8)0xFF
	#define BANK_ACCEPTED (u8)0xFC

	#include <fwu_mdata.h>

	static const char *opts_short = "b:i:a:p:v:V:gh";

	static struct option options[] = {
	{"banks", required_argument, NULL, 'b'},
	{"images", required_argument, NULL, 'i'},
	{"guid", required_argument, NULL, 'g'},
	{"active-bank", required_argument, NULL, 'a'},
	{"previous-bank", required_argument, NULL, 'p'},
	{"version", required_argument, NULL, 'v'},
	{"vendor-file", required_argument, NULL, 'V'},
	{"help", no_argument, NULL, 'h'},
	{NULL, 0, NULL, 0},
	};

	static void print_usage(void)
	{
	fprintf(stderr, "Usage: mkfwumdata [options] <UUIDs list> <output file>\n");
	fprintf(stderr, "Options:\n"
	"\t-i, --images <num> Number of images (mandatory)\n"
	"\t-b, --banks <num> Number of banks (mandatory)\n"
	"\t-v, --version Metadata version (mandatory)\n"
	"\t-a, --active-bank <num> Active bank (default=0)\n"
	"\t-p, --previous-bank <num> Previous active bank (default=active_bank - 1)\n"
	"\t-g, --guid Use GUID instead of UUID\n"
	"\t-V, --vendor-file Vendor data file to append to the metadata\n"
	"\t-h, --help print a help message\n"
	);
	fprintf(stderr, " UUIDs list syntax:\n"
	"\t <location uuid>,<image type uuid>,<images uuid list>\n"
	"\t images uuid list syntax:\n"
	"\t img_uuid_00,img_uuid_01...img_uuid_0b,\n"
	"\t img_uuid_10,img_uuid_11...img_uuid_1b,\n"
	"\t ...,\n"
	"\t img_uuid_i0,img_uuid_i1...img_uuid_ib,\n"
	"\t where 'b' and 'i' are number of banks and number\n"
	"\t of images in a bank respectively.\n"
	);
	}

	struct fwu_mdata_object {
	size_t images;
	size_t banks;
	size_t size;
	u8 version;
	size_t vsize;
	void *vbuf;
	struct fwu_mdata *mdata;
	};

	static int previous_bank, active_bank;
	static bool __use_guid;

	static bool supported_mdata_version(unsigned long version)
	{
	switch (version) {
	case 1:
	case 2:
	return true;
	default:
	return false;
	}
	}

	static struct fwu_mdata_object *fwu_alloc_mdata(size_t images, size_t banks,
	u8 version, size_t vendor_size)
	{
	struct fwu_mdata_object *mobj;

	mobj = calloc(1, sizeof(*mobj));
	if (!mobj)
	return NULL;

	if (version == 1) {
	mobj->size = sizeof(struct fwu_mdata) +
	(sizeof(struct fwu_image_entry) +
	sizeof(struct fwu_image_bank_info) * banks) * images;
	} else {
	mobj->size = sizeof(struct fwu_mdata) +
	sizeof(struct fwu_fw_store_desc) +
	(sizeof(struct fwu_image_entry) +
	sizeof(struct fwu_image_bank_info) * banks) * images;

	mobj->size += vendor_size;
	mobj->vsize = vendor_size;
	}

	mobj->images = images;
	mobj->banks = banks;
	mobj->version = version;

	mobj->mdata = calloc(1, mobj->size);
	if (!mobj->mdata)
	goto alloc_err;

	if (vendor_size) {
	mobj->vbuf = calloc(1, mobj->vsize);
	if (!mobj->vbuf)
	goto alloc_err;
	}

	return mobj;

	alloc_err:
	free(mobj->mdata);
	free(mobj);
	return NULL;
	}

	static struct fwu_image_entry *
	fwu_get_image(struct fwu_mdata_object *mobj, size_t idx)
	{
	size_t offset;

	if (mobj->version == 1) {
	offset = sizeof(struct fwu_mdata) +
	(sizeof(struct fwu_image_entry) +
	sizeof(struct fwu_image_bank_info) * mobj->banks) *
	idx;
	} else {
	offset = sizeof(struct fwu_mdata) +
	sizeof(struct fwu_fw_store_desc) +
	(sizeof(struct fwu_image_entry) +
	sizeof(struct fwu_image_bank_info) * mobj->banks) *
	idx;
	}

	return (struct fwu_image_entry )((char )mobj->mdata + offset);
	}

	static struct fwu_image_bank_info *
	fwu_get_bank(struct fwu_mdata_object *mobj, size_t img_idx, size_t bnk_idx)
	{
	size_t offset;

	if (mobj->version == 1) {
	offset = sizeof(struct fwu_mdata) +
	(sizeof(struct fwu_image_entry) +
	sizeof(struct fwu_image_bank_info) * mobj->banks) *
	img_idx + sizeof(struct fwu_image_entry) +
	sizeof(struct fwu_image_bank_info) * bnk_idx;
	} else {
	offset = sizeof(struct fwu_mdata) +
	sizeof(struct fwu_fw_store_desc) +
	(sizeof(struct fwu_image_entry) +
	sizeof(struct fwu_image_bank_info) * mobj->banks) *
	img_idx + sizeof(struct fwu_image_entry) +
	sizeof(struct fwu_image_bank_info) * bnk_idx;
	}

	return (struct fwu_image_bank_info )((char )mobj->mdata + offset);
	}

	/**
	* convert_uuid_to_guid() - convert UUID to GUID
	* @buf: UUID binary
	*
	* UUID and GUID have the same data structure, but their binary
	* formats are different due to the endianness. See lib/uuid.c.
	* Since uuid_parse() can handle only UUID, this function must
	* be called to get correct data for GUID when parsing a string.
	*
	* The correct data will be returned in @buf.
	*/
	static void convert_uuid_to_guid(unsigned char *buf)
	{
	unsigned char c;

	c = buf[0];
	buf[0] = buf[3];
	buf[3] = c;
	c = buf[1];
	buf[1] = buf[2];
	buf[2] = c;

	c = buf[4];
	buf[4] = buf[5];
	buf[5] = c;

	c = buf[6];
	buf[6] = buf[7];
	buf[7] = c;
	}

	static int uuid_guid_parse(char uuidstr, unsigned char uuid)
	{
	int ret;

	ret = uuid_parse(uuidstr, uuid);
	if (ret < 0)
	return ret;

	if (__use_guid)
	convert_uuid_to_guid(uuid);

	return ret;
	}

	static int
	fwu_parse_fill_image_uuid(struct fwu_mdata_object *mobj,
	size_t idx, char *uuids)
	{
	struct fwu_image_entry *image = fwu_get_image(mobj, idx);
	struct fwu_image_bank_info *bank;
	char p = uuids, uuid;
	int i;

	if (!image)
	return -ENOENT;

	/* Image location UUID */
	uuid = strsep(&p, ",");
	if (!uuid)
	return -EINVAL;

	if (strcmp(uuid, "0") &&
	uuid_guid_parse(uuid, (unsigned char *)&image->location_guid) < 0)
	return -EINVAL;

	/* Image type UUID */
	uuid = strsep(&p, ",");
	if (!uuid)
	return -EINVAL;

	if (uuid_guid_parse(uuid, (unsigned char *)&image->image_type_guid) < 0)
	return -EINVAL;

	/* Fill bank image-UUID */
	for (i = 0; i < mobj->banks; i++) {
	bank = fwu_get_bank(mobj, idx, i);
	if (!bank)
	return -ENOENT;
	bank->accepted = 1;
	uuid = strsep(&p, ",");
	if (!uuid)
	return -EINVAL;

	if (strcmp(uuid, "0") &&
	uuid_guid_parse(uuid, (unsigned char *)&bank->image_guid) < 0)
	return -EINVAL;
	}
	return 0;
	}

	#if defined(CONFIG_FWU_MDATA_V1)
	static void fwu_fill_version_specific_mdata(struct fwu_mdata_object *mobj)
	{
	}
	#else
	static void fwu_fill_version_specific_mdata(struct fwu_mdata_object *mobj)
	{
	int i;
	struct fwu_fw_store_desc *fw_desc;
	struct fwu_mdata *mdata = mobj->mdata;

	mdata->metadata_size = mobj->size;
	mdata->desc_offset = sizeof(struct fwu_mdata);

	for (i = 0; i < MAX_BANKS_V2; i++)
	mdata->bank_state[i] = i < mobj->banks ?
	BANK_ACCEPTED : BANK_INVALID;

	fw_desc = (struct fwu_fw_store_desc )((u8 )mdata + sizeof(*mdata));
	fw_desc->num_banks = mobj->banks;
	fw_desc->num_images = mobj->images;
	fw_desc->img_entry_size = sizeof(struct fwu_image_entry) +
	(sizeof(struct fwu_image_bank_info) * mobj->banks);
	fw_desc->bank_info_entry_size =
	sizeof(struct fwu_image_bank_info);
	}
	#endif /* CONFIG_FWU_MDATA_V1 */

	/* Caller must ensure that @uuids[] has @mobj->images entries. */
	static int fwu_parse_fill_uuids(struct fwu_mdata_object mobj, char uuids[])
	{
	struct fwu_mdata *mdata = mobj->mdata;
	char *vdata;
	int i, ret;

	mdata->version = mobj->version;
	mdata->active_index = active_bank;
	mdata->previous_active_index = previous_bank;

	fwu_fill_version_specific_mdata(mobj);

	for (i = 0; i < mobj->images; i++) {
	ret = fwu_parse_fill_image_uuid(mobj, i, uuids[i]);
	if (ret < 0)
	return ret;
	}

	if (mobj->vsize) {
	vdata = (char *)mobj->mdata + (mobj->size - mobj->vsize);
	memcpy(vdata, mobj->vbuf, mobj->vsize);
	}

	mdata->crc32 = crc32(0, (const unsigned char *)&mdata->version,
	mobj->size - sizeof(uint32_t));

	return 0;
	}

	static int fwu_read_vendor_data(struct fwu_mdata_object *mobj,
	const char *vendor_file)
	{
	int ret = 0;
	FILE *vfile = NULL;

	vfile = fopen(vendor_file, "r");
	if (!vfile) {
	ret = -1;
	goto out;
	}

	if (fread(mobj->vbuf, 1, mobj->vsize, vfile) != mobj->vsize)
	ret = -1;

	out:
	fclose(vfile);
	return ret;
	}

	static int fwu_make_mdata(size_t images, size_t banks, u8 version,
	const char vendor_file, char uuids[],
	char *output)
	{
	int ret;
	FILE *file;
	struct stat sbuf;
	size_t vendor_size = 0;
	struct fwu_mdata_object *mobj;

	if (vendor_file) {
	ret = stat(vendor_file, &sbuf);
	if (ret)
	return -errno;

	vendor_size = sbuf.st_size;
	}

	mobj = fwu_alloc_mdata(images, banks, version, vendor_size);
	if (!mobj)
	return -ENOMEM;

	if (vendor_file) {
	ret = fwu_read_vendor_data(mobj, vendor_file);
	if (ret)
	goto done_make;
	}

	ret = fwu_parse_fill_uuids(mobj, uuids);
	if (ret < 0)
	goto done_make;

	file = fopen(output, "w");
	if (!file) {
	ret = -errno;
	goto done_make;
	}

	ret = fwrite(mobj->mdata, 1, mobj->size, file);
	if (ret != mobj->size)
	ret = -errno;
	else
	ret = 0;

	fclose(file);

	done_make:
	free(mobj->mdata);
	free(mobj->vbuf);
	free(mobj);

	return ret;
	}

	int main(int argc, char *argv[])
	{
	unsigned long banks = 0, images = 0, version = 0;
	int c, ret;
	const char *vendor_file;

	/* Explicitly initialize defaults */
	active_bank = 0;
	__use_guid = false;
	previous_bank = INT_MAX;
	vendor_file = NULL;

	do {
	c = getopt_long(argc, argv, opts_short, options, NULL);
	switch (c) {
	case 'h':
	print_usage();
	return 0;
	case 'b':
	banks = strtoul(optarg, NULL, 0);
	break;
	case 'i':
	images = strtoul(optarg, NULL, 0);
	break;
	case 'g':
	__use_guid = true;
	break;
	case 'p':
	previous_bank = strtoul(optarg, NULL, 0);
	break;
	case 'a':
	active_bank = strtoul(optarg, NULL, 0);
	break;
	case 'v':
	version = strtoul(optarg, NULL, 0);
	break;
	case 'V':
	vendor_file = optarg;
	break;
	}
	} while (c != -1);

	if (!banks \|\| !images) {
	fprintf(stderr, "Error: The number of banks and images must not be 0.\n");
	return -EINVAL;
	}

	if (!version \|\| !supported_mdata_version(version)) {
	fprintf(stderr, "Error: Version value can only be either 1 or 2, not %ld.\n",
	version);
	return -EINVAL;
	}

	if (version == 1 && vendor_file) {
	fprintf(stderr, "Error: Vendor Data can only be appended in version 2 of FWU Metadata.\n");
	return -EINVAL;
	}

	/* This command takes UUIDs * images and output file. */
	if (optind + images + 1 != argc) {
	fprintf(stderr, "Error: UUID list or output file is not specified or too much.\n");
	print_usage();
	return -ERANGE;
	}

	if (previous_bank == INT_MAX) {
	/* set to the earlier bank in round-robin scheme */
	previous_bank = active_bank > 0 ? active_bank - 1 : banks - 1;
	}

	ret = fwu_make_mdata(images, banks, (u8)version, vendor_file,
	argv + optind, argv[argc - 1]);
	if (ret < 0)
	fprintf(stderr, "Error: Failed to parse and write image: %s\n",
	strerror(-ret));

	return ret;
	}