ihex: add ihex2fw tool for converting HEX files into firmware images

Not the straight conversion to binary which objcopy can do for us, but actually representing each record with its original {addr, length}, because some drivers need that information preserved. Fix up 'firmware_install' to be able to build $(hostprogs-y) too. Signed-off-by: David Woodhouse <dwmw2@infradead.org>

ihex: add ihex2fw tool for converting HEX files into firmware images
Not the straight conversion to binary which objcopy can do for us, but actually representing each record with its original {addr, length}, because some drivers need that information preserved. Fix up 'firmware_install' to be able to build $(hostprogs-y) too. Signed-off-by: David Woodhouse <dwmw2@infradead.org>
David Woodhouse · David Woodhouse
1 parent f1485f3deb
Showing 3 changed files with 262 additions and 1 deletions Side-by-side Diff
firmware/Makefile
firmware/ihex2fw.c
scripts/Makefile.fwinst
@@ -32,6 +32,9 @@
 quiet_cmd_ihex  = IHEX    $@
       cmd_ihex  = $(OBJCOPY) -Iihex -Obinary $< $@
  
+quiet_cmd_ihex2fw  = IHEX2FW $@
+      cmd_ihex2fw  = $(objtree)/$(obj)/ihex2fw $< $@
+
 quiet_cmd_fwbin = MK_FW   $@
       cmd_fwbin = FWNAME="$(patsubst firmware/%.gen.S,%,$@)";		     \
 		  FWSTR="$(subst /,_,$(subst .,_,$(subst -,_,$(patsubst	     \
  
@@ -84,9 +87,18 @@
 $(patsubst %,$(obj)/%.gen.o, $(fw-shipped-y)): %.gen.o: %
 $(patsubst %,$(obj)/%.gen.o, $(fw-external-y)): $(obj)/%.gen.o: $(fwdir)/%
  
+# .ihex is used just as a simple way to hold binary files in a source tree
+# where binaries are frowned upon. They are directly converted with objcopy.
 $(obj)/%: $(obj)/%.ihex | $(objtree)/$(obj)/$$(dir %)
 	$(call cmd,ihex)
  
+# .HEX is also Intel HEX, but where the offset and length in each record
+# is actually meaningful, because the firmware has to be loaded in a certain
+# order rather than as a single binary blob. Thus, we convert them into our
+# more compact binary representation of ihex records (<linux/ihex.h>)
+$(obj)/%.fw: $(obj)/%.HEX $(obj)/ihex2fw | $(objtree)/$(obj)/$$(dir %)
+	$(call cmd,ihex2fw)
+
 $(firmware-dirs):
 	$(call cmd,mkdir)
  
@@ -101,4 +113,6 @@
 # Without this, built-in.o won't be created when it's empty, and the
 # final vmlinux link will fail.
 obj-n := dummy
+
+hostprogs-y := ihex2fw
+/*
+ * Parser/loader for IHEX formatted data.
+ *
+ * Copyright © 2008 David Woodhouse <dwmw2@infradead.org>
+ * Copyright © 2005 Jan Harkes <jaharkes@cs.cmu.edu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <stdint.h>
+#include <arpa/inet.h>
+#include <stdio.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+struct ihex_binrec {
+	struct ihex_binrec *next; /* not part of the real data structure */
+        uint32_t addr;
+        uint16_t len;
+        uint8_t data[];
+};
+
+/**
+ * nybble/hex are little helpers to parse hexadecimal numbers to a byte value
+ **/
+static uint8_t nybble(const uint8_t n)
+{
+       if      (n >= '0' && n <= '9') return n - '0';
+       else if (n >= 'A' && n <= 'F') return n - ('A' - 10);
+       else if (n >= 'a' && n <= 'f') return n - ('a' - 10);
+       return 0;
+}
+
+static uint8_t hex(const uint8_t *data, uint8_t *crc)
+{
+       uint8_t val = (nybble(data[0]) << 4) | nybble(data[1]);
+       *crc += val;
+       return val;
+}
+
+static int process_ihex(uint8_t *data, ssize_t size);
+static void file_record(struct ihex_binrec *record);
+static int output_records(int outfd);
+
+static int sort_records = 0;
+
+int main(int argc, char **argv)
+{
+	int infd, outfd;
+	struct stat st;
+	uint8_t *data;
+
+	if (argc == 4 && !strcmp(argv[1], "-s")) {
+		sort_records = 1;
+		argc--;
+		argv++;
+	}
+	if (argc != 3) {
+	usage:
+		fprintf(stderr, "ihex2fw: Convert ihex files into binary "
+				"representation for use by Linux kernel\n");
+		fprintf(stderr, "usage: ihex2fw [-s] <src.HEX> <dst.fw>\n");
+		fprintf(stderr, "       -s: sort records by address\n");
+		return 1;
+	}
+	if (!strcmp(argv[1], "-"))
+	    infd = 0;
+	else
+		infd = open(argv[1], O_RDONLY);
+	if (infd == -1) {
+		fprintf(stderr, "Failed to open source file: %s",
+			strerror(errno));
+		goto usage;
+	}
+	if (fstat(infd, &st)) {
+		perror("stat");
+		return 1;
+	}
+	data = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, infd, 0);
+	if (data == MAP_FAILED) {
+		perror("mmap");
+		return 1;
+	}
+
+	if (!strcmp(argv[2], "-"))
+	    outfd = 1;
+	else
+		outfd = open(argv[2], O_TRUNC|O_CREAT|O_WRONLY, 0644);
+	if (outfd == -1) {
+		fprintf(stderr, "Failed to open destination file: %s",
+			strerror(errno));
+		goto usage;
+	}
+	if (process_ihex(data, st.st_size))
+		return 1;
+
+	output_records(outfd);
+	return 0;
+}
+
+static int process_ihex(uint8_t *data, ssize_t size)
+{
+	struct ihex_binrec *record;
+	uint32_t offset = 0;
+	uint8_t type, crc = 0, crcbyte = 0;
+	int i, j;
+	int line = 1;
+	int len;
+
+	i = 0;
+next_record:
+	/* search for the start of record character */
+	while (i < size) {
+		if (data[i] == '\n') line++;
+		if (data[i++] == ':') break;
+	}
+
+	/* Minimum record length would be about 10 characters */
+	if (i + 10 > size) {
+		fprintf(stderr, "Can't find valid record at line %d\n", line);
+		return -EINVAL;
+	}
+
+	len = hex(data + i, &crc); i += 2;
+
+	record = malloc((sizeof (*record) + len + 3) & ~3);
+	if (!record) {
+		fprintf(stderr, "out of memory for records\n");
+		return -ENOMEM;
+	}
+	memset(record, 0, (sizeof(*record) + len + 3) & ~3);
+	record->len = len;
+
+	/* now check if we have enough data to read everything */
+	if (i + 8 + (record->len * 2) > size) {
+		fprintf(stderr, "Not enough data to read complete record at line %d\n",
+			line);
+		return -EINVAL;
+	}
+
+	record->addr  = hex(data + i, &crc) << 8; i += 2;
+	record->addr |= hex(data + i, &crc); i += 2;
+	type = hex(data + i, &crc); i += 2;
+
+	for (j = 0; j < record->len; j++, i += 2)
+		record->data[j] = hex(data + i, &crc);
+
+	/* check CRC */
+	crcbyte = hex(data + i, &crc); i += 2;
+	if (crc != 0) {
+		fprintf(stderr, "CRC failure at line %d: got 0x%X, expected 0x%X\n",
+			line, crcbyte, (unsigned char)(crcbyte-crc));
+		return -EINVAL;
+	}
+
+	/* Done reading the record */
+	switch (type) {
+	case 0:
+		/* old style EOF record? */
+		if (!record->len)
+			break;
+
+		record->addr += offset;
+		file_record(record);
+		goto next_record;
+
+	case 1: /* End-Of-File Record */
+		if (record->addr || record->len) {
+			fprintf(stderr, "Bad EOF record (type 01) format at line %d",
+				line);
+			return -EINVAL;
+		}
+		break;
+
+	case 2: /* Extended Segment Address Record (HEX86) */
+	case 4: /* Extended Linear Address Record (HEX386) */
+		if (record->addr || record->len != 2) {
+			fprintf(stderr, "Bad HEX86/HEX386 record (type %02X) at line %d\n",
+				type, line);
+			return -EINVAL;
+		}
+
+		/* We shouldn't really be using the offset for HEX86 because
+		 * the wraparound case is specified quite differently. */
+		offset = record->data[0] << 8 | record->data[1];
+		offset <<= (type == 2 ? 4 : 16);
+		goto next_record;
+
+	case 3: /* Start Segment Address Record */
+	case 5: /* Start Linear Address Record */
+		if (record->addr || record->len != 4) {
+			fprintf(stderr, "Bad Start Address record (type %02X) at line %d\n",
+				type, line);
+			return -EINVAL;
+		}
+
+		/* These records contain the CS/IP or EIP where execution
+		 * starts. Don't really know what to do with them. */
+		goto next_record;
+
+	default:
+		fprintf(stderr, "Unknown record (type %02X)\n", type);
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+static struct ihex_binrec *records;
+
+static void file_record(struct ihex_binrec *record)
+{
+	struct ihex_binrec **p = &records;
+
+	while ((*p) && (!sort_records || (*p)->addr < record->addr))
+		p = &((*p)->next);
+
+	record->next = *p;
+	*p = record;
+}
+
+static int output_records(int outfd)
+{
+	unsigned char zeroes[5] = {0, 0, 0, 0, 0};
+	struct ihex_binrec *p = records;
+
+	while (p) {
+		uint16_t writelen = (p->len + 9) & ~3;
+
+		p->addr = htonl(p->addr);
+		p->len = htonl(p->len);
+		write(outfd, &p->addr, writelen);
+		p = p->next;
+	}
+	/* EOF record is zero length, since we don't bother to represent
+	   the type field in the binary version */
+	write(outfd, zeroes, 5);
+	return 0;
+}
@@ -6,6 +6,7 @@
 # ==========================================================================
  
 INSTALL := install
+src := $(obj)
  
 # For modules_install installing firmware, we want to see .config
 # But for firmware_install, we don't care, but don't want to require it.
@@ -40,7 +41,6 @@
  
 __fw_install: $(installed-fw)
 __fw_modinst: $(mod-fw)
-
  
 FORCE:
...	...	@@ -32,6 +32,9 @@
32	32	quiet_cmd_ihex = IHEX $@
33	33	cmd_ihex = $(OBJCOPY) -Iihex -Obinary $< $@
34	34
	35	+quiet_cmd_ihex2fw = IHEX2FW $@
	36	+ cmd_ihex2fw = $(objtree)/$(obj)/ihex2fw $< $@
	37	+
35	38	quiet_cmd_fwbin = MK_FW $@
36	39	cmd_fwbin = FWNAME="$(patsubst firmware/%.gen.S,%,$@)"; \
37	40	FWSTR="$(subst /,_,$(subst .,_,$(subst -,_,$(patsubst \
38	41
...	...	@@ -84,9 +87,18 @@
84	87	$(patsubst %,$(obj)/%.gen.o, $(fw-shipped-y)): %.gen.o: %
85	88	$(patsubst %,$(obj)/%.gen.o, $(fw-external-y)): $(obj)/%.gen.o: $(fwdir)/%
86	89
	90	+# .ihex is used just as a simple way to hold binary files in a source tree
	91	+# where binaries are frowned upon. They are directly converted with objcopy.
87	92	$(obj)/%: $(obj)/%.ihex \| $(objtree)/$(obj)/$$(dir %)
88	93	$(call cmd,ihex)
89	94
	95	+# .HEX is also Intel HEX, but where the offset and length in each record
	96	+# is actually meaningful, because the firmware has to be loaded in a certain
	97	+# order rather than as a single binary blob. Thus, we convert them into our
	98	+# more compact binary representation of ihex records (<linux/ihex.h>)
	99	+$(obj)/%.fw: $(obj)/%.HEX $(obj)/ihex2fw \| $(objtree)/$(obj)/$$(dir %)
	100	+ $(call cmd,ihex2fw)
	101	+
90	102	$(firmware-dirs):
91	103	$(call cmd,mkdir)
92	104
...	...	@@ -101,4 +113,6 @@
101	113	# Without this, built-in.o won't be created when it's empty, and the
102	114	# final vmlinux link will fail.
103	115	obj-n := dummy
	116	+
	117	+hostprogs-y := ihex2fw
	1	+/*
	2	+ * Parser/loader for IHEX formatted data.
	3	+ *
	4	+ * Copyright © 2008 David Woodhouse <dwmw2@infradead.org>
	5	+ * Copyright © 2005 Jan Harkes <jaharkes@cs.cmu.edu>
	6	+ *
	7	+ * This program is free software; you can redistribute it and/or modify
	8	+ * it under the terms of the GNU General Public License version 2 as
	9	+ * published by the Free Software Foundation.
	10	+ */
	11	+
	12	+#include <stdint.h>
	13	+#include <arpa/inet.h>
	14	+#include <stdio.h>
	15	+#include <errno.h>
	16	+#include <sys/types.h>
	17	+#include <sys/stat.h>
	18	+#include <sys/mman.h>
	19	+#include <fcntl.h>
	20	+#include <string.h>
	21	+#include <unistd.h>
	22	+#include <stdlib.h>
	23	+
	24	+struct ihex_binrec {
	25	+ struct ihex_binrec next; / not part of the real data structure */
	26	+ uint32_t addr;
	27	+ uint16_t len;
	28	+ uint8_t data[];
	29	+};
	30	+
	31	+/**
	32	+ * nybble/hex are little helpers to parse hexadecimal numbers to a byte value
	33	+ **/
	34	+static uint8_t nybble(const uint8_t n)
	35	+{
	36	+ if (n >= '0' && n <= '9') return n - '0';
	37	+ else if (n >= 'A' && n <= 'F') return n - ('A' - 10);
	38	+ else if (n >= 'a' && n <= 'f') return n - ('a' - 10);
	39	+ return 0;
	40	+}
	41	+
	42	+static uint8_t hex(const uint8_t data, uint8_t crc)
	43	+{
	44	+ uint8_t val = (nybble(data[0]) << 4) \| nybble(data[1]);
	45	+ *crc += val;
	46	+ return val;
	47	+}
	48	+
	49	+static int process_ihex(uint8_t *data, ssize_t size);
	50	+static void file_record(struct ihex_binrec *record);
	51	+static int output_records(int outfd);
	52	+
	53	+static int sort_records = 0;
	54	+
	55	+int main(int argc, char **argv)
	56	+{
	57	+ int infd, outfd;
	58	+ struct stat st;
	59	+ uint8_t *data;
	60	+
	61	+ if (argc == 4 && !strcmp(argv[1], "-s")) {
	62	+ sort_records = 1;
	63	+ argc--;
	64	+ argv++;
	65	+ }
	66	+ if (argc != 3) {
	67	+ usage:
	68	+ fprintf(stderr, "ihex2fw: Convert ihex files into binary "
	69	+ "representation for use by Linux kernel\n");
	70	+ fprintf(stderr, "usage: ihex2fw [-s] <src.HEX> <dst.fw>\n");
	71	+ fprintf(stderr, " -s: sort records by address\n");
	72	+ return 1;
	73	+ }
	74	+ if (!strcmp(argv[1], "-"))
	75	+ infd = 0;
	76	+ else
	77	+ infd = open(argv[1], O_RDONLY);
	78	+ if (infd == -1) {
	79	+ fprintf(stderr, "Failed to open source file: %s",
	80	+ strerror(errno));
	81	+ goto usage;
	82	+ }
	83	+ if (fstat(infd, &st)) {
	84	+ perror("stat");
	85	+ return 1;
	86	+ }
	87	+ data = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, infd, 0);
	88	+ if (data == MAP_FAILED) {
	89	+ perror("mmap");
	90	+ return 1;
	91	+ }
	92	+
	93	+ if (!strcmp(argv[2], "-"))
	94	+ outfd = 1;
	95	+ else
	96	+ outfd = open(argv[2], O_TRUNC\|O_CREAT\|O_WRONLY, 0644);
	97	+ if (outfd == -1) {
	98	+ fprintf(stderr, "Failed to open destination file: %s",
	99	+ strerror(errno));
	100	+ goto usage;
	101	+ }
	102	+ if (process_ihex(data, st.st_size))
	103	+ return 1;
	104	+
	105	+ output_records(outfd);
	106	+ return 0;
	107	+}
	108	+
	109	+static int process_ihex(uint8_t *data, ssize_t size)
	110	+{
	111	+ struct ihex_binrec *record;
	112	+ uint32_t offset = 0;
	113	+ uint8_t type, crc = 0, crcbyte = 0;
	114	+ int i, j;
	115	+ int line = 1;
	116	+ int len;
	117	+
	118	+ i = 0;
	119	+next_record:
	120	+ /* search for the start of record character */
	121	+ while (i < size) {
	122	+ if (data[i] == '\n') line++;
	123	+ if (data[i++] == ':') break;
	124	+ }
	125	+
	126	+ /* Minimum record length would be about 10 characters */
	127	+ if (i + 10 > size) {
	128	+ fprintf(stderr, "Can't find valid record at line %d\n", line);
	129	+ return -EINVAL;
	130	+ }
	131	+
	132	+ len = hex(data + i, &crc); i += 2;
	133	+
	134	+ record = malloc((sizeof (*record) + len + 3) & ~3);
	135	+ if (!record) {
	136	+ fprintf(stderr, "out of memory for records\n");
	137	+ return -ENOMEM;
	138	+ }
	139	+ memset(record, 0, (sizeof(*record) + len + 3) & ~3);
	140	+ record->len = len;
	141	+
	142	+ /* now check if we have enough data to read everything */
	143	+ if (i + 8 + (record->len * 2) > size) {
	144	+ fprintf(stderr, "Not enough data to read complete record at line %d\n",
	145	+ line);
	146	+ return -EINVAL;
	147	+ }
	148	+
	149	+ record->addr = hex(data + i, &crc) << 8; i += 2;
	150	+ record->addr \|= hex(data + i, &crc); i += 2;
	151	+ type = hex(data + i, &crc); i += 2;
	152	+
	153	+ for (j = 0; j < record->len; j++, i += 2)
	154	+ record->data[j] = hex(data + i, &crc);
	155	+
	156	+ /* check CRC */
	157	+ crcbyte = hex(data + i, &crc); i += 2;
	158	+ if (crc != 0) {
	159	+ fprintf(stderr, "CRC failure at line %d: got 0x%X, expected 0x%X\n",
	160	+ line, crcbyte, (unsigned char)(crcbyte-crc));
	161	+ return -EINVAL;
	162	+ }
	163	+
	164	+ /* Done reading the record */
	165	+ switch (type) {
	166	+ case 0:
	167	+ /* old style EOF record? */
	168	+ if (!record->len)
	169	+ break;
	170	+
	171	+ record->addr += offset;
	172	+ file_record(record);
	173	+ goto next_record;
	174	+
	175	+ case 1: /* End-Of-File Record */
	176	+ if (record->addr \|\| record->len) {
	177	+ fprintf(stderr, "Bad EOF record (type 01) format at line %d",
	178	+ line);
	179	+ return -EINVAL;
	180	+ }
	181	+ break;
	182	+
	183	+ case 2: /* Extended Segment Address Record (HEX86) */
	184	+ case 4: /* Extended Linear Address Record (HEX386) */
	185	+ if (record->addr \|\| record->len != 2) {
	186	+ fprintf(stderr, "Bad HEX86/HEX386 record (type %02X) at line %d\n",
	187	+ type, line);
	188	+ return -EINVAL;
	189	+ }
	190	+
	191	+ /* We shouldn't really be using the offset for HEX86 because
	192	+ * the wraparound case is specified quite differently. */
	193	+ offset = record->data[0] << 8 \| record->data[1];
	194	+ offset <<= (type == 2 ? 4 : 16);
	195	+ goto next_record;
	196	+
	197	+ case 3: /* Start Segment Address Record */
	198	+ case 5: /* Start Linear Address Record */
	199	+ if (record->addr \|\| record->len != 4) {
	200	+ fprintf(stderr, "Bad Start Address record (type %02X) at line %d\n",
	201	+ type, line);
	202	+ return -EINVAL;
	203	+ }
	204	+
	205	+ /* These records contain the CS/IP or EIP where execution
	206	+ * starts. Don't really know what to do with them. */
	207	+ goto next_record;
	208	+
	209	+ default:
	210	+ fprintf(stderr, "Unknown record (type %02X)\n", type);
	211	+ return -EINVAL;
	212	+ }
	213	+
	214	+ return 0;
	215	+}
	216	+
	217	+static struct ihex_binrec *records;
	218	+
	219	+static void file_record(struct ihex_binrec *record)
	220	+{
	221	+ struct ihex_binrec **p = &records;
	222	+
	223	+ while ((p) && (!sort_records \|\| (p)->addr < record->addr))
	224	+ p = &((*p)->next);
	225	+
	226	+ record->next = *p;
	227	+ *p = record;
	228	+}
	229	+
	230	+static int output_records(int outfd)
	231	+{
	232	+ unsigned char zeroes[5] = {0, 0, 0, 0, 0};
	233	+ struct ihex_binrec *p = records;
	234	+
	235	+ while (p) {
	236	+ uint16_t writelen = (p->len + 9) & ~3;
	237	+
	238	+ p->addr = htonl(p->addr);
	239	+ p->len = htonl(p->len);
	240	+ write(outfd, &p->addr, writelen);
	241	+ p = p->next;
	242	+ }
	243	+ /* EOF record is zero length, since we don't bother to represent
	244	+ the type field in the binary version */
	245	+ write(outfd, zeroes, 5);
	246	+ return 0;
	247	+}
...	...	@@ -6,6 +6,7 @@
6	6	# ==========================================================================
7	7
8	8	INSTALL := install
	9	+src := $(obj)
9	10
10	11	# For modules_install installing firmware, we want to see .config
11	12	# But for firmware_install, we don't care, but don't want to require it.
...	...	@@ -40,7 +41,6 @@
40	41
41	42	__fw_install: $(installed-fw)
42	43	__fw_modinst: $(mod-fw)
43		-
44	44
45	45	FORCE: