[linux-block.git] / include / linux / ihex.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * Compact binary representation of ihex records. Some devices need their
 * firmware loaded in strange orders rather than a single big blob, but
 * actually parsing ihex-as-text within the kernel seems silly. Thus,...
 */

#ifndef __LINUX_IHEX_H__
#define __LINUX_IHEX_H__

#include <linux/types.h>
#include <linux/firmware.h>
#include <linux/device.h>

/* Intel HEX files actually limit the length to 256 bytes, but we have
   drivers which would benefit from using separate records which are
   longer than that, so we extend to 16 bits of length */
struct ihex_binrec {
	__be32 addr;
	__be16 len;
	uint8_t data[];
} __attribute__((packed));

static inline uint16_t ihex_binrec_size(const struct ihex_binrec *p)
{
	return be16_to_cpu(p->len) + sizeof(*p);
}

/* Find the next record, taking into account the 4-byte alignment */
static inline const struct ihex_binrec *
__ihex_next_binrec(const struct ihex_binrec *rec)
{
	const void *p = rec;

	return p + ALIGN(ihex_binrec_size(rec), 4);
}

static inline const struct ihex_binrec *
ihex_next_binrec(const struct ihex_binrec *rec)
{
	rec = __ihex_next_binrec(rec);

	return be16_to_cpu(rec->len) ? rec : NULL;
}

/* Check that ihex_next_binrec() won't take us off the end of the image... */
static inline int ihex_validate_fw(const struct firmware *fw)
{
	const struct ihex_binrec *end, *rec;

	rec = (const void *)fw->data;
	end = (const void *)&fw->data[fw->size - sizeof(*end)];

	for (; rec <= end; rec = __ihex_next_binrec(rec)) {
		/* Zero length marks end of records */
		if (rec == end && !be16_to_cpu(rec->len))
			return 0;
	}
	return -EINVAL;
}

/* Request firmware and validate it so that we can trust we won't
 * run off the end while reading records... */
static inline int request_ihex_firmware(const struct firmware **fw,
					const char *fw_name,
					struct device *dev)
{
	const struct firmware *lfw;
	int ret;

	ret = request_firmware(&lfw, fw_name, dev);
	if (ret)
		return ret;
	ret = ihex_validate_fw(lfw);
	if (ret) {
		dev_err(dev, "Firmware \"%s\" not valid IHEX records\n",
			fw_name);
		release_firmware(lfw);
		return ret;
	}
	*fw = lfw;
	return 0;
}
#endif /* __LINUX_IHEX_H__ */
Commit	Line	Data
b2441318	1	/* SPDX-License-Identifier: GPL-2.0 */
bacfe09d DW	2	/*
	3	* Compact binary representation of ihex records. Some devices need their
	4	* firmware loaded in strange orders rather than a single big blob, but
	5	* actually parsing ihex-as-text within the kernel seems silly. Thus,...
	6	*/
	7
	8	#ifndef __LINUX_IHEX_H__
	9	#define __LINUX_IHEX_H__
	10
	11	#include <linux/types.h>
	12	#include <linux/firmware.h>
f1485f3d	13	#include <linux/device.h>
bacfe09d DW	14
	15	/* Intel HEX files actually limit the length to 256 bytes, but we have
	16	drivers which would benefit from using separate records which are
	17	longer than that, so we extend to 16 bits of length */
	18	struct ihex_binrec {
	19	__be32 addr;
	20	__be16 len;
1d9e13e8	21	uint8_t data[];
85ebd003	22	} __attribute__((packed));
bacfe09d	23
9fb4ab4d AS	24	static inline uint16_t ihex_binrec_size(const struct ihex_binrec *p)
	25	{
	26	return be16_to_cpu(p->len) + sizeof(*p);
	27	}
	28
bacfe09d DW	29	/* Find the next record, taking into account the 4-byte alignment */
bacfe09d DW	30	static inline const struct ihex_binrec *
8092e792	31	__ihex_next_binrec(const struct ihex_binrec *rec)
bacfe09d	32	{
9fb4ab4d	33	const void *p = rec;
bacfe09d	34
9fb4ab4d	35	return p + ALIGN(ihex_binrec_size(rec), 4);
8092e792 AS	36	}
	37
	38	static inline const struct ihex_binrec *
	39	ihex_next_binrec(const struct ihex_binrec *rec)
	40	{
	41	rec = __ihex_next_binrec(rec);
	42
bacfe09d DW	43	return be16_to_cpu(rec->len) ? rec : NULL;
	44	}
	45
	46	/* Check that ihex_next_binrec() won't take us off the end of the image... */
	47	static inline int ihex_validate_fw(const struct firmware *fw)
	48	{
8092e792	49	const struct ihex_binrec end, rec;
bacfe09d	50
8092e792 AS	51	rec = (const void *)fw->data;
8092e792 AS	52	end = (const void )&fw->data[fw->size - sizeof(end)];
bacfe09d	53
8092e792	54	for (; rec <= end; rec = __ihex_next_binrec(rec)) {
bacfe09d	55	/* Zero length marks end of records */
5158c36e	56	if (rec == end && !be16_to_cpu(rec->len))
bacfe09d	57	return 0;
bacfe09d DW	58	}
	59	return -EINVAL;
	60	}
f1485f3d DW	61
	62	/* Request firmware and validate it so that we can trust we won't
	63	* run off the end while reading records... */
	64	static inline int request_ihex_firmware(const struct firmware **fw,
	65	const char *fw_name,
	66	struct device *dev)
	67	{
	68	const struct firmware *lfw;
	69	int ret;
	70
	71	ret = request_firmware(&lfw, fw_name, dev);
	72	if (ret)
	73	return ret;
	74	ret = ihex_validate_fw(lfw);
	75	if (ret) {
	76	dev_err(dev, "Firmware \"%s\" not valid IHEX records\n",
	77	fw_name);
	78	release_firmware(lfw);
	79	return ret;
	80	}
	81	*fw = lfw;
	82	return 0;
	83	}
bacfe09d	84	#endif /* __LINUX_IHEX_H__ */