* [PATCH] hw/core/loader: Add Extended Tektronix HEX support
@ 2026-11-14 11:28 Nagendran K
2026-11-20 9:08 ` Daniel P. Berrangé
0 siblings, 1 reply; 4+ messages in thread
From: Nagendran K @ 2026-11-14 11:28 UTC (permalink / raw)
To: qemu-devel
Cc: berrange, philmd, daan.j.demeyer, peter.maydell, alistair,
Nagendran K
Signed-off-by: Nagendran K <nagendranjairam52@gmail.com>
---
hw/core/loader.c | 231 +++++++++++++++++++++++++++++++++++++++
include/hw/core/loader.h | 15 +++
2 files changed, 246 insertions(+)
diff --git a/hw/core/loader.c b/hw/core/loader.c
index 5cbfba0a86d24569923c863d6ecda125ce43bceb..33ccb51d56dda1035e815479e20c2a6c793843d9 100644
--- a/hw/core/loader.c
+++ b/hw/core/loader.c
@@ -1940,3 +1940,234 @@ ssize_t load_targphys_hex_as(const char *filename, hwaddr *entry,
g_free(hex_blob);
return total_size;
}
+
+typedef enum Ext_Tek_HexRecord Ext_Tek_HexRecord;
+enum Ext_Tek_HexRecord {
+ TEK_DATA_RECORD = 0,
+ TEK_TERMINATION_RECORD
+};
+
+#define DATA_FIELD_MAX_LEN 0xff
+
+typedef struct {
+ uint8_t record_length;
+ uint8_t record_type;
+ uint8_t checksum;
+ uint32_t address;
+ uint8_t data[DATA_FIELD_MAX_LEN];
+} Ext_Tek_HexLine;
+
+/* return 0 or -1 if error */
+static bool parse_ext_tek_hex_record(Ext_Tek_HexLine *line,
+ uint8_t *our_checksum,
+ const uint8_t c,
+ uint32_t *index,
+ const bool in_process)
+{
+ /* +---------+---------------+-----------+---------------+-------------+
+ * | record | record | | | |
+ * | length | type | checksum | address | data |
+ * +---------+---------------+-----------+---------------+-------------+
+ * ^ ^ ^ ^ ^
+ * |1 byte | 1 bytes |1 byte | 1 to N byte | 0-255 bytes |
+ */
+ uint8_t value = 0, address_len = 0;
+ uint32_t idx = *index;
+ /* ignore space */
+ if (g_ascii_isspace(c)) {
+ return true;
+ }
+ if (!g_ascii_isxdigit(c) || !in_process) {
+ return false;
+ }
+ /* still idx is computed nibble wise */
+ value = g_ascii_xdigit_value(c);
+ value = (idx & 0x1) ? (value & 0xf) : (value << 4);
+ if (idx < 2) {
+ line->record_length |= value;
+ } else if (idx == 2) {
+ line->record_type |= value;
+ } else if (2 < idx && idx <= 4) {
+ line->checksum |= value;
+ }
+ /*
+ * Extracting address length from record to fill that many no of address
+ * characters in the address field of the line structure.
+ */
+ else if (idx == 5) {
+ address_len |= value;
+ } else if (6 <= idx &&
+ idx <= (6 + address_len)) {
+ line->address <<= address_len;
+ line->address += g_ascii_xdigit_value(c);
+ }
+ /*
+ * Checking whether index above address last char index
+ * and reaches till record length. Right shifting one divides the
+ * nibble wise index by 2 to get the byte wise index to
+ * fill the data field of the line structure
+ */
+ else if ((6 + address_len) < idx &&
+ idx <= line->record_length) {
+ line->data[(idx - (6 + address_len)) >> 1] |= value;
+ } else {
+ return false;
+ }
+ *our_checksum += value;
+ ++(*index);
+ return true;
+}
+
+typedef struct {
+ const char *filename;
+ Ext_Tek_HexLine line;
+ uint8_t *bin_buf;
+ hwaddr *start_addr;
+ int total_size;
+ uint32_t next_address_to_write;
+ uint32_t current_address;
+ uint32_t current_rom_index;
+ uint32_t rom_start_address;
+ AddressSpace *as;
+ bool complete;
+} Ext_TekHexParser;
+
+/* return size or -1 if error */
+static int handle_ext_tek_hex_record_type(Ext_TekHexParser *parser)
+{
+ Ext_Tek_HexLine *line = &(parser->line);
+ switch (line->record_type) {
+ case TEK_DATA_RECORD:
+ parser->current_address = line->address;
+ /* verify this is a contiguous block of memory */
+ if (parser->current_address != parser->next_address_to_write) {
+ if (parser->current_rom_index != 0) {
+ rom_add_blob_fixed_as(parser->filename, parser->bin_buf,
+ parser->current_rom_index,
+ parser->rom_start_address, parser->as);
+ }
+ parser->rom_start_address = parser->current_address;
+ parser->current_rom_index = 0;
+ }
+
+ /* copy from line buffer to output bin_buf */
+ /* sizeof(line->data) dynamically calculates the size of data field */
+ memcpy(parser->bin_buf + parser->current_rom_index, line->data,
+ sizeof(line->data));
+ parser->current_rom_index += sizeof(line->data);
+ parser->total_size += sizeof(line->data);
+ /* As address is absolute, we dont need to calculate next address */
+ break;
+
+ case TEK_TERMINATION_RECORD:
+ if (parser->current_rom_index != 0) {
+ rom_add_blob_fixed_as(parser->filename, parser->bin_buf,
+ parser->current_rom_index,
+ parser->rom_start_address, parser->as);
+ }
+ parser->complete = true;
+ return parser->total_size;
+
+ default:
+ return -1;
+ }
+
+ return parser->total_size;
+}
+
+/* return size or -1 if error */
+static int parse_ext_tek_hex_blob(const char *filename,
+ hwaddr *addr,
+ uint8_t *ext_tek_blob,
+ size_t ext_tek_blob_size,
+ AddressSpace *as)
+{
+ /* avoid re-enter and check whether record begin with '%' */
+ bool in_process = false;
+ uint8_t *end = ext_tek_blob + ext_tek_blob_size;
+ uint8_t our_checksum = 0;
+ uint32_t record_index = 0;
+
+ Ext_TekHexParser parser = {
+ .filename = filename,
+ .bin_buf = g_malloc(ext_tek_blob_size),
+ .start_addr = addr,
+ .as = as,
+ .complete = false
+ };
+
+ rom_transaction_begin();
+
+ for (; ext_tek_blob < end && !parser.complete; ++ext_tek_blob) {
+ switch (*ext_tek_blob) {
+ case '\r':
+ case '\n':
+ if (!in_process) {
+ break;
+ }
+
+ in_process = false;
+ /*
+ * record_length byte stores the number of hex characters
+ * (nibbles) in the record and compare it directly to
+ * the nibble index(record index).
+ */
+ if ((parser.line.record_length != record_index) ||
+ (our_checksum != 0)) {
+ parser.total_size = -1;
+ goto out;
+ }
+
+ if (handle_ext_tek_hex_record_type(&parser) == -1) {
+ parser.total_size = -1;
+ goto out;
+ }
+ break;
+
+ /* start of a new record. */
+ case '%':
+ memset(&parser.line, 0, sizeof(Ext_Tek_HexLine));
+ in_process = true;
+ record_index = 0;
+ break;
+
+ /* decoding lines */
+ default:
+ if (!parse_ext_tek_hex_record(&parser.line,
+ &our_checksum,
+ *ext_tek_blob,
+ &record_index, in_process)) {
+ parser.total_size = -1;
+ goto out;
+ }
+ break;
+ }
+ }
+
+ out:
+ g_free(parser.bin_buf);
+ rom_transaction_end(parser.total_size != -1);
+ return parser.total_size;
+}
+
+
+/* return size or -1 if error */
+ssize_t load_targphys_ext_tek_hex_as(const char *filename,
+ hwaddr *entry,
+ AddressSpace *as)
+{
+ gsize ext_tek_blob_size;
+ gchar *ext_tek_blob;
+ int total_size = 0;
+
+ if (!g_file_get_contents(filename, &ext_tek_blob,
+ &ext_tek_blob_size, NULL)) {
+ return -1;
+ }
+ total_size = parse_ext_tek_hex_blob(filename, entry,
+ (uint8_t *)ext_tek_blob,
+ ext_tek_blob_size, as);
+
+ g_free(ext_tek_blob);
+ return total_size;
+}
diff --git a/include/hw/core/loader.h b/include/hw/core/loader.h
index d9431e8a8d12e3b676160f70ed141f1064143ea3..c0d29b1d4456bb92984749e56f1109f8421cee51 100644
--- a/include/hw/core/loader.h
+++ b/include/hw/core/loader.h
@@ -57,6 +57,21 @@ ssize_t load_image_targphys_as(const char *filename,
ssize_t load_targphys_hex_as(const char *filename, hwaddr *entry,
AddressSpace *as);
+/**
+ * load_targphys_ext_tek_as:
+ * @filename: Path to the .tek file
+ * @entry: Store the entry point given by the .tek file
+ * @as: The AddressSpace to load the .tek file to. The value of
+ * address_space_memory is used if nothing is supplied here.
+ *
+ * Load a fixed .tek file into memory.
+ *
+ * Returns the size of the loaded .tek file on success, -1 otherwise.
+ */
+ssize_t load_targphys_ext_tek_hex_as(const char *filename,
+ hwaddr *entry,
+ AddressSpace *as);
+
/** load_image_targphys:
* Same as load_image_targphys_as(), but doesn't allow the caller to specify
* an AddressSpace.
--
2.54.0.windows.1
^ permalink raw reply related [flat|nested] 4+ messages in thread
* Re: [PATCH] hw/core/loader: Add Extended Tektronix HEX support
2026-11-14 11:28 [PATCH] hw/core/loader: Add Extended Tektronix HEX support Nagendran K
@ 2026-11-20 9:08 ` Daniel P. Berrangé
[not found] ` <CAEAkEp4N1uFczHexCAbABzYf5O-Th-o5dE-KasU1RXM_k7WKKQ@mail.gmail.com>
0 siblings, 1 reply; 4+ messages in thread
From: Daniel P. Berrangé @ 2026-11-20 9:08 UTC (permalink / raw)
To: Nagendran K; +Cc: qemu-devel, philmd, daan.j.demeyer, peter.maydell, alistair
On Sat, Nov 14, 2026 at 04:58:50PM +0530, Nagendran K wrote:
Please provide a commit message to explain the purpose of
this addition.
> Signed-off-by: Nagendran K <nagendranjairam52@gmail.com>
> ---
> hw/core/loader.c | 231 +++++++++++++++++++++++++++++++++++++++
> include/hw/core/loader.h | 15 +++
> 2 files changed, 246 insertions(+)
....this is adding a new API to common code and then not
calling it from anywhere in QEMU. This is pointless
and so is not likely to be accepted in isolation without
a proposed usage accompanying it.
>
> diff --git a/hw/core/loader.c b/hw/core/loader.c
> index 5cbfba0a86d24569923c863d6ecda125ce43bceb..33ccb51d56dda1035e815479e20c2a6c793843d9 100644
> --- a/hw/core/loader.c
> +++ b/hw/core/loader.c
> @@ -1940,3 +1940,234 @@ ssize_t load_targphys_hex_as(const char *filename, hwaddr *entry,
> g_free(hex_blob);
> return total_size;
> }
> +
> +typedef enum Ext_Tek_HexRecord Ext_Tek_HexRecord;
> +enum Ext_Tek_HexRecord {
> + TEK_DATA_RECORD = 0,
> + TEK_TERMINATION_RECORD
> +};
> +
> +#define DATA_FIELD_MAX_LEN 0xff
> +
> +typedef struct {
> + uint8_t record_length;
> + uint8_t record_type;
> + uint8_t checksum;
> + uint32_t address;
> + uint8_t data[DATA_FIELD_MAX_LEN];
> +} Ext_Tek_HexLine;
> +
> +/* return 0 or -1 if error */
> +static bool parse_ext_tek_hex_record(Ext_Tek_HexLine *line,
> + uint8_t *our_checksum,
> + const uint8_t c,
> + uint32_t *index,
> + const bool in_process)
> +{
> + /* +---------+---------------+-----------+---------------+-------------+
> + * | record | record | | | |
> + * | length | type | checksum | address | data |
> + * +---------+---------------+-----------+---------------+-------------+
> + * ^ ^ ^ ^ ^
> + * |1 byte | 1 bytes |1 byte | 1 to N byte | 0-255 bytes |
> + */
> + uint8_t value = 0, address_len = 0;
> + uint32_t idx = *index;
> + /* ignore space */
> + if (g_ascii_isspace(c)) {
> + return true;
> + }
> + if (!g_ascii_isxdigit(c) || !in_process) {
> + return false;
> + }
> + /* still idx is computed nibble wise */
> + value = g_ascii_xdigit_value(c);
> + value = (idx & 0x1) ? (value & 0xf) : (value << 4);
> + if (idx < 2) {
> + line->record_length |= value;
> + } else if (idx == 2) {
> + line->record_type |= value;
> + } else if (2 < idx && idx <= 4) {
> + line->checksum |= value;
> + }
> + /*
> + * Extracting address length from record to fill that many no of address
> + * characters in the address field of the line structure.
> + */
> + else if (idx == 5) {
> + address_len |= value;
> + } else if (6 <= idx &&
> + idx <= (6 + address_len)) {
> + line->address <<= address_len;
> + line->address += g_ascii_xdigit_value(c);
> + }
> + /*
> + * Checking whether index above address last char index
> + * and reaches till record length. Right shifting one divides the
> + * nibble wise index by 2 to get the byte wise index to
> + * fill the data field of the line structure
> + */
> + else if ((6 + address_len) < idx &&
> + idx <= line->record_length) {
> + line->data[(idx - (6 + address_len)) >> 1] |= value;
> + } else {
> + return false;
> + }
> + *our_checksum += value;
> + ++(*index);
> + return true;
> +}
> +
> +typedef struct {
> + const char *filename;
> + Ext_Tek_HexLine line;
> + uint8_t *bin_buf;
> + hwaddr *start_addr;
> + int total_size;
> + uint32_t next_address_to_write;
> + uint32_t current_address;
> + uint32_t current_rom_index;
> + uint32_t rom_start_address;
> + AddressSpace *as;
> + bool complete;
> +} Ext_TekHexParser;
> +
> +/* return size or -1 if error */
> +static int handle_ext_tek_hex_record_type(Ext_TekHexParser *parser)
> +{
> + Ext_Tek_HexLine *line = &(parser->line);
> + switch (line->record_type) {
> + case TEK_DATA_RECORD:
> + parser->current_address = line->address;
> + /* verify this is a contiguous block of memory */
> + if (parser->current_address != parser->next_address_to_write) {
> + if (parser->current_rom_index != 0) {
> + rom_add_blob_fixed_as(parser->filename, parser->bin_buf,
> + parser->current_rom_index,
> + parser->rom_start_address, parser->as);
> + }
> + parser->rom_start_address = parser->current_address;
> + parser->current_rom_index = 0;
> + }
> +
> + /* copy from line buffer to output bin_buf */
> + /* sizeof(line->data) dynamically calculates the size of data field */
> + memcpy(parser->bin_buf + parser->current_rom_index, line->data,
> + sizeof(line->data));
> + parser->current_rom_index += sizeof(line->data);
> + parser->total_size += sizeof(line->data);
> + /* As address is absolute, we dont need to calculate next address */
> + break;
> +
> + case TEK_TERMINATION_RECORD:
> + if (parser->current_rom_index != 0) {
> + rom_add_blob_fixed_as(parser->filename, parser->bin_buf,
> + parser->current_rom_index,
> + parser->rom_start_address, parser->as);
> + }
> + parser->complete = true;
> + return parser->total_size;
> +
> + default:
> + return -1;
> + }
> +
> + return parser->total_size;
> +}
> +
> +/* return size or -1 if error */
> +static int parse_ext_tek_hex_blob(const char *filename,
> + hwaddr *addr,
> + uint8_t *ext_tek_blob,
> + size_t ext_tek_blob_size,
> + AddressSpace *as)
> +{
> + /* avoid re-enter and check whether record begin with '%' */
> + bool in_process = false;
> + uint8_t *end = ext_tek_blob + ext_tek_blob_size;
> + uint8_t our_checksum = 0;
> + uint32_t record_index = 0;
> +
> + Ext_TekHexParser parser = {
> + .filename = filename,
> + .bin_buf = g_malloc(ext_tek_blob_size),
> + .start_addr = addr,
> + .as = as,
> + .complete = false
> + };
> +
> + rom_transaction_begin();
> +
> + for (; ext_tek_blob < end && !parser.complete; ++ext_tek_blob) {
> + switch (*ext_tek_blob) {
> + case '\r':
> + case '\n':
> + if (!in_process) {
> + break;
> + }
> +
> + in_process = false;
> + /*
> + * record_length byte stores the number of hex characters
> + * (nibbles) in the record and compare it directly to
> + * the nibble index(record index).
> + */
> + if ((parser.line.record_length != record_index) ||
> + (our_checksum != 0)) {
> + parser.total_size = -1;
> + goto out;
> + }
> +
> + if (handle_ext_tek_hex_record_type(&parser) == -1) {
> + parser.total_size = -1;
> + goto out;
> + }
> + break;
> +
> + /* start of a new record. */
> + case '%':
> + memset(&parser.line, 0, sizeof(Ext_Tek_HexLine));
> + in_process = true;
> + record_index = 0;
> + break;
> +
> + /* decoding lines */
> + default:
> + if (!parse_ext_tek_hex_record(&parser.line,
> + &our_checksum,
> + *ext_tek_blob,
> + &record_index, in_process)) {
> + parser.total_size = -1;
> + goto out;
> + }
> + break;
> + }
> + }
> +
> + out:
> + g_free(parser.bin_buf);
> + rom_transaction_end(parser.total_size != -1);
> + return parser.total_size;
> +}
> +
> +
> +/* return size or -1 if error */
> +ssize_t load_targphys_ext_tek_hex_as(const char *filename,
> + hwaddr *entry,
> + AddressSpace *as)
> +{
> + gsize ext_tek_blob_size;
> + gchar *ext_tek_blob;
> + int total_size = 0;
> +
> + if (!g_file_get_contents(filename, &ext_tek_blob,
> + &ext_tek_blob_size, NULL)) {
> + return -1;
> + }
> + total_size = parse_ext_tek_hex_blob(filename, entry,
> + (uint8_t *)ext_tek_blob,
> + ext_tek_blob_size, as);
> +
> + g_free(ext_tek_blob);
> + return total_size;
> +}
> diff --git a/include/hw/core/loader.h b/include/hw/core/loader.h
> index d9431e8a8d12e3b676160f70ed141f1064143ea3..c0d29b1d4456bb92984749e56f1109f8421cee51 100644
> --- a/include/hw/core/loader.h
> +++ b/include/hw/core/loader.h
> @@ -57,6 +57,21 @@ ssize_t load_image_targphys_as(const char *filename,
> ssize_t load_targphys_hex_as(const char *filename, hwaddr *entry,
> AddressSpace *as);
>
> +/**
> + * load_targphys_ext_tek_as:
> + * @filename: Path to the .tek file
> + * @entry: Store the entry point given by the .tek file
> + * @as: The AddressSpace to load the .tek file to. The value of
> + * address_space_memory is used if nothing is supplied here.
> + *
> + * Load a fixed .tek file into memory.
> + *
> + * Returns the size of the loaded .tek file on success, -1 otherwise.
> + */
> +ssize_t load_targphys_ext_tek_hex_as(const char *filename,
> + hwaddr *entry,
> + AddressSpace *as);
> +
> /** load_image_targphys:
> * Same as load_image_targphys_as(), but doesn't allow the caller to specify
> * an AddressSpace.
> --
> 2.54.0.windows.1
>
With regards,
Daniel
--
|: https://berrange.com ~~ https://hachyderm.io/@berrange :|
|: https://libvirt.org ~~ https://entangle-photo.org :|
|: https://pixelfed.art/berrange ~~ https://fstop138.berrange.com :|
^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [PATCH] hw/core/loader: Add Extended Tektronix HEX support
[not found] ` <CAEAkEp4N1uFczHexCAbABzYf5O-Th-o5dE-KasU1RXM_k7WKKQ@mail.gmail.com>
@ 2026-11-20 9:31 ` Daniel P. Berrangé
2026-11-20 10:03 ` Nagendran Jairam
0 siblings, 1 reply; 4+ messages in thread
From: Daniel P. Berrangé @ 2026-11-20 9:31 UTC (permalink / raw)
To: qemu-devel, Nagendran Jairam
Re-adding qemu-devel - please don't drop the mailing list when
replying to review comments.
On Fri, Nov 20, 2026 at 02:47:07PM +0530, Nagendran Jairam wrote:
> On Fri, Nov 20, 2026, 14:38 Daniel P. Berrangé <berrange@redhat.com> wrote:
>
> > On Sat, Nov 14, 2026 at 04:58:50PM +0530, Nagendran K wrote:
> >
> > Please provide a commit message to explain the purpose of
> > this addition.
> >
> I am sorry, I forgot to mention that this function is being called
> in generic-loader.c
> The purpose is to load .tek files (binaries commonly used in Texas
> instruments microcontrollers) directly without worrying about raw binary
> or hex conversion
> Hex and tek files have major differences and it reduces manual
> effort for a user to convert .tek to .hex
It is clearly not being called in generic-loader.c since this patch
makes no changes to that file.
> > > Signed-off-by: Nagendran K <nagendranjairam52@gmail.com>
> > > ---
> > > hw/core/loader.c | 231 +++++++++++++++++++++++++++++++++++++++
> > > include/hw/core/loader.h | 15 +++
> > > 2 files changed, 246 insertions(+)
> >
> > ....this is adding a new API to common code and then not
> > calling it from anywhere in QEMU. This is pointless
> > and so is not likely to be accepted in isolation without
> > a proposed usage accompanying it.
> This is function has a call in generic-loader.c to load .tek files
>
> Example Usecase: -device loader, file=my_test.tek, addr=0x00000000
>
> >
> >
> > >
> > > diff --git a/hw/core/loader.c b/hw/core/loader.c
> > > index
> > 5cbfba0a86d24569923c863d6ecda125ce43bceb..33ccb51d56dda1035e815479e20c2a6c793843d9
> > 100644
> > > --- a/hw/core/loader.c
> > > +++ b/hw/core/loader.c
> > > @@ -1940,3 +1940,234 @@ ssize_t load_targphys_hex_as(const char
> > *filename, hwaddr *entry,
> > > g_free(hex_blob);
> > > return total_size;
> > > }
> > > +
> > > +typedef enum Ext_Tek_HexRecord Ext_Tek_HexRecord;
> > > +enum Ext_Tek_HexRecord {
> > > + TEK_DATA_RECORD = 0,
> > > + TEK_TERMINATION_RECORD
> > > +};
> > > +
> > > +#define DATA_FIELD_MAX_LEN 0xff
> > > +
> > > +typedef struct {
> > > + uint8_t record_length;
> > > + uint8_t record_type;
> > > + uint8_t checksum;
> > > + uint32_t address;
> > > + uint8_t data[DATA_FIELD_MAX_LEN];
> > > +} Ext_Tek_HexLine;
> > > +
> > > +/* return 0 or -1 if error */
> > > +static bool parse_ext_tek_hex_record(Ext_Tek_HexLine *line,
> > > + uint8_t *our_checksum,
> > > + const uint8_t c,
> > > + uint32_t *index,
> > > + const bool in_process)
> > > +{
> > > + /*
> > +---------+---------------+-----------+---------------+-------------+
> > > + * | record | record | | |
> > |
> > > + * | length | type | checksum | address | data
> > |
> > > + *
> > +---------+---------------+-----------+---------------+-------------+
> > > + * ^ ^ ^ ^ ^
> > > + * |1 byte | 1 bytes |1 byte | 1 to N byte | 0-255
> > bytes |
> > > + */
> > > + uint8_t value = 0, address_len = 0;
> > > + uint32_t idx = *index;
> > > + /* ignore space */
> > > + if (g_ascii_isspace(c)) {
> > > + return true;
> > > + }
> > > + if (!g_ascii_isxdigit(c) || !in_process) {
> > > + return false;
> > > + }
> > > + /* still idx is computed nibble wise */
> > > + value = g_ascii_xdigit_value(c);
> > > + value = (idx & 0x1) ? (value & 0xf) : (value << 4);
> > > + if (idx < 2) {
> > > + line->record_length |= value;
> > > + } else if (idx == 2) {
> > > + line->record_type |= value;
> > > + } else if (2 < idx && idx <= 4) {
> > > + line->checksum |= value;
> > > + }
> > > + /*
> > > + * Extracting address length from record to fill that many no of
> > address
> > > + * characters in the address field of the line structure.
> > > + */
> > > + else if (idx == 5) {
> > > + address_len |= value;
> > > + } else if (6 <= idx &&
> > > + idx <= (6 + address_len)) {
> > > + line->address <<= address_len;
> > > + line->address += g_ascii_xdigit_value(c);
> > > + }
> > > + /*
> > > + * Checking whether index above address last char index
> > > + * and reaches till record length. Right shifting one divides the
> > > + * nibble wise index by 2 to get the byte wise index to
> > > + * fill the data field of the line structure
> > > + */
> > > + else if ((6 + address_len) < idx &&
> > > + idx <= line->record_length) {
> > > + line->data[(idx - (6 + address_len)) >> 1] |= value;
> > > + } else {
> > > + return false;
> > > + }
> > > + *our_checksum += value;
> > > + ++(*index);
> > > + return true;
> > > +}
> > > +
> > > +typedef struct {
> > > + const char *filename;
> > > + Ext_Tek_HexLine line;
> > > + uint8_t *bin_buf;
> > > + hwaddr *start_addr;
> > > + int total_size;
> > > + uint32_t next_address_to_write;
> > > + uint32_t current_address;
> > > + uint32_t current_rom_index;
> > > + uint32_t rom_start_address;
> > > + AddressSpace *as;
> > > + bool complete;
> > > +} Ext_TekHexParser;
> > > +
> > > +/* return size or -1 if error */
> > > +static int handle_ext_tek_hex_record_type(Ext_TekHexParser *parser)
> > > +{
> > > + Ext_Tek_HexLine *line = &(parser->line);
> > > + switch (line->record_type) {
> > > + case TEK_DATA_RECORD:
> > > + parser->current_address = line->address;
> > > + /* verify this is a contiguous block of memory */
> > > + if (parser->current_address != parser->next_address_to_write) {
> > > + if (parser->current_rom_index != 0) {
> > > + rom_add_blob_fixed_as(parser->filename, parser->bin_buf,
> > > + parser->current_rom_index,
> > > + parser->rom_start_address,
> > parser->as);
> > > + }
> > > + parser->rom_start_address = parser->current_address;
> > > + parser->current_rom_index = 0;
> > > + }
> > > +
> > > + /* copy from line buffer to output bin_buf */
> > > + /* sizeof(line->data) dynamically calculates the size of data
> > field */
> > > + memcpy(parser->bin_buf + parser->current_rom_index, line->data,
> > > + sizeof(line->data));
> > > + parser->current_rom_index += sizeof(line->data);
> > > + parser->total_size += sizeof(line->data);
> > > + /* As address is absolute, we dont need to calculate next
> > address */
> > > + break;
> > > +
> > > + case TEK_TERMINATION_RECORD:
> > > + if (parser->current_rom_index != 0) {
> > > + rom_add_blob_fixed_as(parser->filename, parser->bin_buf,
> > > + parser->current_rom_index,
> > > + parser->rom_start_address,
> > parser->as);
> > > + }
> > > + parser->complete = true;
> > > + return parser->total_size;
> > > +
> > > + default:
> > > + return -1;
> > > + }
> > > +
> > > + return parser->total_size;
> > > +}
> > > +
> > > +/* return size or -1 if error */
> > > +static int parse_ext_tek_hex_blob(const char *filename,
> > > + hwaddr *addr,
> > > + uint8_t *ext_tek_blob,
> > > + size_t ext_tek_blob_size,
> > > + AddressSpace *as)
> > > +{
> > > + /* avoid re-enter and check whether record begin with '%' */
> > > + bool in_process = false;
> > > + uint8_t *end = ext_tek_blob + ext_tek_blob_size;
> > > + uint8_t our_checksum = 0;
> > > + uint32_t record_index = 0;
> > > +
> > > + Ext_TekHexParser parser = {
> > > + .filename = filename,
> > > + .bin_buf = g_malloc(ext_tek_blob_size),
> > > + .start_addr = addr,
> > > + .as = as,
> > > + .complete = false
> > > + };
> > > +
> > > + rom_transaction_begin();
> > > +
> > > + for (; ext_tek_blob < end && !parser.complete; ++ext_tek_blob) {
> > > + switch (*ext_tek_blob) {
> > > + case '\r':
> > > + case '\n':
> > > + if (!in_process) {
> > > + break;
> > > + }
> > > +
> > > + in_process = false;
> > > + /*
> > > + * record_length byte stores the number of hex
> > characters
> > > + * (nibbles) in the record and compare it directly to
> > > + * the nibble index(record index).
> > > + */
> > > + if ((parser.line.record_length != record_index) ||
> > > + (our_checksum != 0)) {
> > > + parser.total_size = -1;
> > > + goto out;
> > > + }
> > > +
> > > + if (handle_ext_tek_hex_record_type(&parser) == -1) {
> > > + parser.total_size = -1;
> > > + goto out;
> > > + }
> > > + break;
> > > +
> > > + /* start of a new record. */
> > > + case '%':
> > > + memset(&parser.line, 0, sizeof(Ext_Tek_HexLine));
> > > + in_process = true;
> > > + record_index = 0;
> > > + break;
> > > +
> > > + /* decoding lines */
> > > + default:
> > > + if (!parse_ext_tek_hex_record(&parser.line,
> > > + &our_checksum,
> > > + *ext_tek_blob,
> > > + &record_index, in_process))
> > {
> > > + parser.total_size = -1;
> > > + goto out;
> > > + }
> > > + break;
> > > + }
> > > + }
> > > +
> > > + out:
> > > + g_free(parser.bin_buf);
> > > + rom_transaction_end(parser.total_size != -1);
> > > + return parser.total_size;
> > > +}
> > > +
> > > +
> > > +/* return size or -1 if error */
> > > +ssize_t load_targphys_ext_tek_hex_as(const char *filename,
> > > + hwaddr *entry,
> > > + AddressSpace *as)
> > > +{
> > > + gsize ext_tek_blob_size;
> > > + gchar *ext_tek_blob;
> > > + int total_size = 0;
> > > +
> > > + if (!g_file_get_contents(filename, &ext_tek_blob,
> > > + &ext_tek_blob_size, NULL)) {
> > > + return -1;
> > > + }
> > > + total_size = parse_ext_tek_hex_blob(filename, entry,
> > > + (uint8_t *)ext_tek_blob,
> > > + ext_tek_blob_size, as);
> > > +
> > > + g_free(ext_tek_blob);
> > > + return total_size;
> > > +}
> > > diff --git a/include/hw/core/loader.h b/include/hw/core/loader.h
> > > index
> > d9431e8a8d12e3b676160f70ed141f1064143ea3..c0d29b1d4456bb92984749e56f1109f8421cee51
> > 100644
> > > --- a/include/hw/core/loader.h
> > > +++ b/include/hw/core/loader.h
> > > @@ -57,6 +57,21 @@ ssize_t load_image_targphys_as(const char *filename,
> > > ssize_t load_targphys_hex_as(const char *filename, hwaddr *entry,
> > > AddressSpace *as);
> > >
> > > +/**
> > > + * load_targphys_ext_tek_as:
> > > + * @filename: Path to the .tek file
> > > + * @entry: Store the entry point given by the .tek file
> > > + * @as: The AddressSpace to load the .tek file to. The value of
> > > + * address_space_memory is used if nothing is supplied here.
> > > + *
> > > + * Load a fixed .tek file into memory.
> > > + *
> > > + * Returns the size of the loaded .tek file on success, -1 otherwise.
> > > + */
> > > +ssize_t load_targphys_ext_tek_hex_as(const char *filename,
> > > + hwaddr *entry,
> > > + AddressSpace *as);
> > > +
> > > /** load_image_targphys:
> > > * Same as load_image_targphys_as(), but doesn't allow the caller to
> > specify
> > > * an AddressSpace.
> > > --
> > > 2.54.0.windows.1
> > >
> >
> > With regards,
> > Daniel
> > --
> > |: https://berrange.com ~~ https://hachyderm.io/@berrange :|
> > |: https://libvirt.org ~~ https://entangle-photo.org :|
> > |: https://pixelfed.art/berrange ~~ https://fstop138.berrange.com :|
> >
> >
With regards,
Daniel
--
|: https://berrange.com ~~ https://hachyderm.io/@berrange :|
|: https://libvirt.org ~~ https://entangle-photo.org :|
|: https://pixelfed.art/berrange ~~ https://fstop138.berrange.com :|
^ permalink raw reply [flat|nested] 4+ messages in thread
* Re: [PATCH] hw/core/loader: Add Extended Tektronix HEX support
2026-11-20 9:31 ` Daniel P. Berrangé
@ 2026-11-20 10:03 ` Nagendran Jairam
0 siblings, 0 replies; 4+ messages in thread
From: Nagendran Jairam @ 2026-11-20 10:03 UTC (permalink / raw)
To: Daniel P. Berrangé; +Cc: qemu-devel
[-- Attachment #1: Type: text/plain, Size: 14415 bytes --]
On Fri, Nov 20, 2026, 15:01 Daniel P. Berrangé <berrange@redhat.com> wrote:
> Re-adding qemu-devel - please don't drop the mailing list when
> replying to review comments.
>
> On Fri, Nov 20, 2026 at 02:47:07PM +0530, Nagendran Jairam wrote:
> > On Fri, Nov 20, 2026, 14:38 Daniel P. Berrangé <berrange@redhat.com>
> wrote:
> >
> > > On Sat, Nov 14, 2026 at 04:58:50PM +0530, Nagendran K wrote:
> > >
> > > Please provide a commit message to explain the purpose of
> > > this addition.
> > >
> > I am sorry, I forgot to mention that this function is being called
> > in generic-loader.c
> > The purpose is to load .tek files (binaries commonly used in Texas
> > instruments microcontrollers) directly without worrying about raw binary
> > or hex conversion
> > Hex and tek files have major differences and it reduces manual
> > effort for a user to convert .tek to .hex
>
> It is clearly not being called in generic-loader.c since this patch
> makes no changes to that file.
>
> Alistair mailed me with the same issue too...Aactually my whole
> implementation is not in master..Its updated in my local not in upstream
>
I will update my patch in upstream master..Thanks
Nagendran
>
> > > > Signed-off-by: Nagendran K <nagendranjairam52@gmail.com>
> > > > ---
> > > > hw/core/loader.c | 231
> +++++++++++++++++++++++++++++++++++++++
> > > > include/hw/core/loader.h | 15 +++
> > > > 2 files changed, 246 insertions(+)
> > >
> > > ....this is adding a new API to common code and then not
> > > calling it from anywhere in QEMU. This is pointless
> > > and so is not likely to be accepted in isolation without
> > > a proposed usage accompanying it.
> > This is function has a call in generic-loader.c to load .tek files
> >
> > Example Usecase: -device loader, file=my_test.tek, addr=0x00000000
> >
> > >
> > >
> > > >
> > > > diff --git a/hw/core/loader.c b/hw/core/loader.c
> > > > index
> > >
> 5cbfba0a86d24569923c863d6ecda125ce43bceb..33ccb51d56dda1035e815479e20c2a6c793843d9
> > > 100644
> > > > --- a/hw/core/loader.c
> > > > +++ b/hw/core/loader.c
> > > > @@ -1940,3 +1940,234 @@ ssize_t load_targphys_hex_as(const char
> > > *filename, hwaddr *entry,
> > > > g_free(hex_blob);
> > > > return total_size;
> > > > }
> > > > +
> > > > +typedef enum Ext_Tek_HexRecord Ext_Tek_HexRecord;
> > > > +enum Ext_Tek_HexRecord {
> > > > + TEK_DATA_RECORD = 0,
> > > > + TEK_TERMINATION_RECORD
> > > > +};
> > > > +
> > > > +#define DATA_FIELD_MAX_LEN 0xff
> > > > +
> > > > +typedef struct {
> > > > + uint8_t record_length;
> > > > + uint8_t record_type;
> > > > + uint8_t checksum;
> > > > + uint32_t address;
> > > > + uint8_t data[DATA_FIELD_MAX_LEN];
> > > > +} Ext_Tek_HexLine;
> > > > +
> > > > +/* return 0 or -1 if error */
> > > > +static bool parse_ext_tek_hex_record(Ext_Tek_HexLine *line,
> > > > + uint8_t *our_checksum,
> > > > + const uint8_t c,
> > > > + uint32_t *index,
> > > > + const bool in_process)
> > > > +{
> > > > + /*
> > > +---------+---------------+-----------+---------------+-------------+
> > > > + * | record | record | | |
> > > |
> > > > + * | length | type | checksum | address |
> data
> > > |
> > > > + *
> > > +---------+---------------+-----------+---------------+-------------+
> > > > + * ^ ^ ^ ^ ^
> > > > + * |1 byte | 1 bytes |1 byte | 1 to N byte | 0-255
> > > bytes |
> > > > + */
> > > > + uint8_t value = 0, address_len = 0;
> > > > + uint32_t idx = *index;
> > > > + /* ignore space */
> > > > + if (g_ascii_isspace(c)) {
> > > > + return true;
> > > > + }
> > > > + if (!g_ascii_isxdigit(c) || !in_process) {
> > > > + return false;
> > > > + }
> > > > + /* still idx is computed nibble wise */
> > > > + value = g_ascii_xdigit_value(c);
> > > > + value = (idx & 0x1) ? (value & 0xf) : (value << 4);
> > > > + if (idx < 2) {
> > > > + line->record_length |= value;
> > > > + } else if (idx == 2) {
> > > > + line->record_type |= value;
> > > > + } else if (2 < idx && idx <= 4) {
> > > > + line->checksum |= value;
> > > > + }
> > > > + /*
> > > > + * Extracting address length from record to fill that many no of
> > > address
> > > > + * characters in the address field of the line structure.
> > > > + */
> > > > + else if (idx == 5) {
> > > > + address_len |= value;
> > > > + } else if (6 <= idx &&
> > > > + idx <= (6 + address_len)) {
> > > > + line->address <<= address_len;
> > > > + line->address += g_ascii_xdigit_value(c);
> > > > + }
> > > > + /*
> > > > + * Checking whether index above address last char index
> > > > + * and reaches till record length. Right shifting one divides
> the
> > > > + * nibble wise index by 2 to get the byte wise index to
> > > > + * fill the data field of the line structure
> > > > + */
> > > > + else if ((6 + address_len) < idx &&
> > > > + idx <= line->record_length) {
> > > > + line->data[(idx - (6 + address_len)) >> 1] |= value;
> > > > + } else {
> > > > + return false;
> > > > + }
> > > > + *our_checksum += value;
> > > > + ++(*index);
> > > > + return true;
> > > > +}
> > > > +
> > > > +typedef struct {
> > > > + const char *filename;
> > > > + Ext_Tek_HexLine line;
> > > > + uint8_t *bin_buf;
> > > > + hwaddr *start_addr;
> > > > + int total_size;
> > > > + uint32_t next_address_to_write;
> > > > + uint32_t current_address;
> > > > + uint32_t current_rom_index;
> > > > + uint32_t rom_start_address;
> > > > + AddressSpace *as;
> > > > + bool complete;
> > > > +} Ext_TekHexParser;
> > > > +
> > > > +/* return size or -1 if error */
> > > > +static int handle_ext_tek_hex_record_type(Ext_TekHexParser *parser)
> > > > +{
> > > > + Ext_Tek_HexLine *line = &(parser->line);
> > > > + switch (line->record_type) {
> > > > + case TEK_DATA_RECORD:
> > > > + parser->current_address = line->address;
> > > > + /* verify this is a contiguous block of memory */
> > > > + if (parser->current_address !=
> parser->next_address_to_write) {
> > > > + if (parser->current_rom_index != 0) {
> > > > + rom_add_blob_fixed_as(parser->filename,
> parser->bin_buf,
> > > > + parser->current_rom_index,
> > > > + parser->rom_start_address,
> > > parser->as);
> > > > + }
> > > > + parser->rom_start_address = parser->current_address;
> > > > + parser->current_rom_index = 0;
> > > > + }
> > > > +
> > > > + /* copy from line buffer to output bin_buf */
> > > > + /* sizeof(line->data) dynamically calculates the size of
> data
> > > field */
> > > > + memcpy(parser->bin_buf + parser->current_rom_index,
> line->data,
> > > > + sizeof(line->data));
> > > > + parser->current_rom_index += sizeof(line->data);
> > > > + parser->total_size += sizeof(line->data);
> > > > + /* As address is absolute, we dont need to calculate next
> > > address */
> > > > + break;
> > > > +
> > > > + case TEK_TERMINATION_RECORD:
> > > > + if (parser->current_rom_index != 0) {
> > > > + rom_add_blob_fixed_as(parser->filename, parser->bin_buf,
> > > > + parser->current_rom_index,
> > > > + parser->rom_start_address,
> > > parser->as);
> > > > + }
> > > > + parser->complete = true;
> > > > + return parser->total_size;
> > > > +
> > > > + default:
> > > > + return -1;
> > > > + }
> > > > +
> > > > + return parser->total_size;
> > > > +}
> > > > +
> > > > +/* return size or -1 if error */
> > > > +static int parse_ext_tek_hex_blob(const char *filename,
> > > > + hwaddr *addr,
> > > > + uint8_t *ext_tek_blob,
> > > > + size_t ext_tek_blob_size,
> > > > + AddressSpace *as)
> > > > +{
> > > > + /* avoid re-enter and check whether record begin with '%' */
> > > > + bool in_process = false;
> > > > + uint8_t *end = ext_tek_blob + ext_tek_blob_size;
> > > > + uint8_t our_checksum = 0;
> > > > + uint32_t record_index = 0;
> > > > +
> > > > + Ext_TekHexParser parser = {
> > > > + .filename = filename,
> > > > + .bin_buf = g_malloc(ext_tek_blob_size),
> > > > + .start_addr = addr,
> > > > + .as = as,
> > > > + .complete = false
> > > > + };
> > > > +
> > > > + rom_transaction_begin();
> > > > +
> > > > + for (; ext_tek_blob < end && !parser.complete;
> ++ext_tek_blob) {
> > > > + switch (*ext_tek_blob) {
> > > > + case '\r':
> > > > + case '\n':
> > > > + if (!in_process) {
> > > > + break;
> > > > + }
> > > > +
> > > > + in_process = false;
> > > > + /*
> > > > + * record_length byte stores the number of hex
> > > characters
> > > > + * (nibbles) in the record and compare it directly
> to
> > > > + * the nibble index(record index).
> > > > + */
> > > > + if ((parser.line.record_length != record_index) ||
> > > > + (our_checksum != 0)) {
> > > > + parser.total_size = -1;
> > > > + goto out;
> > > > + }
> > > > +
> > > > + if (handle_ext_tek_hex_record_type(&parser) == -1) {
> > > > + parser.total_size = -1;
> > > > + goto out;
> > > > + }
> > > > + break;
> > > > +
> > > > + /* start of a new record. */
> > > > + case '%':
> > > > + memset(&parser.line, 0, sizeof(Ext_Tek_HexLine));
> > > > + in_process = true;
> > > > + record_index = 0;
> > > > + break;
> > > > +
> > > > + /* decoding lines */
> > > > + default:
> > > > + if (!parse_ext_tek_hex_record(&parser.line,
> > > > + &our_checksum,
> > > > + *ext_tek_blob,
> > > > + &record_index,
> in_process))
> > > {
> > > > + parser.total_size = -1;
> > > > + goto out;
> > > > + }
> > > > + break;
> > > > + }
> > > > + }
> > > > +
> > > > + out:
> > > > + g_free(parser.bin_buf);
> > > > + rom_transaction_end(parser.total_size != -1);
> > > > + return parser.total_size;
> > > > +}
> > > > +
> > > > +
> > > > +/* return size or -1 if error */
> > > > +ssize_t load_targphys_ext_tek_hex_as(const char *filename,
> > > > + hwaddr *entry,
> > > > + AddressSpace *as)
> > > > +{
> > > > + gsize ext_tek_blob_size;
> > > > + gchar *ext_tek_blob;
> > > > + int total_size = 0;
> > > > +
> > > > + if (!g_file_get_contents(filename, &ext_tek_blob,
> > > > + &ext_tek_blob_size, NULL)) {
> > > > + return -1;
> > > > + }
> > > > + total_size = parse_ext_tek_hex_blob(filename, entry,
> > > > + (uint8_t *)ext_tek_blob,
> > > > + ext_tek_blob_size, as);
> > > > +
> > > > + g_free(ext_tek_blob);
> > > > + return total_size;
> > > > +}
> > > > diff --git a/include/hw/core/loader.h b/include/hw/core/loader.h
> > > > index
> > >
> d9431e8a8d12e3b676160f70ed141f1064143ea3..c0d29b1d4456bb92984749e56f1109f8421cee51
> > > 100644
> > > > --- a/include/hw/core/loader.h
> > > > +++ b/include/hw/core/loader.h
> > > > @@ -57,6 +57,21 @@ ssize_t load_image_targphys_as(const char
> *filename,
> > > > ssize_t load_targphys_hex_as(const char *filename, hwaddr *entry,
> > > > AddressSpace *as);
> > > >
> > > > +/**
> > > > + * load_targphys_ext_tek_as:
> > > > + * @filename: Path to the .tek file
> > > > + * @entry: Store the entry point given by the .tek file
> > > > + * @as: The AddressSpace to load the .tek file to. The value of
> > > > + * address_space_memory is used if nothing is supplied here.
> > > > + *
> > > > + * Load a fixed .tek file into memory.
> > > > + *
> > > > + * Returns the size of the loaded .tek file on success, -1
> otherwise.
> > > > + */
> > > > +ssize_t load_targphys_ext_tek_hex_as(const char *filename,
> > > > + hwaddr *entry,
> > > > + AddressSpace *as);
> > > > +
> > > > /** load_image_targphys:
> > > > * Same as load_image_targphys_as(), but doesn't allow the caller to
> > > specify
> > > > * an AddressSpace.
> > > > --
> > > > 2.54.0.windows.1
> > > >
> > >
> > > With regards,
> > > Daniel
> > > --
> > > |: https://berrange.com ~~ https://hachyderm.io/@berrange
> :|
> > > |: https://libvirt.org ~~ https://entangle-photo.org
> :|
> > > |: https://pixelfed.art/berrange ~~ https://fstop138.berrange.com
> :|
> > >
> > >
>
> With regards,
> Daniel
> --
> |: https://berrange.com ~~ https://hachyderm.io/@berrange :|
> |: https://libvirt.org ~~ https://entangle-photo.org :|
> |: https://pixelfed.art/berrange ~~ https://fstop138.berrange.com :|
>
>
[-- Attachment #2: Type: text/html, Size: 21069 bytes --]
^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2026-11-20 10:04 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-14 11:28 [PATCH] hw/core/loader: Add Extended Tektronix HEX support Nagendran K
2026-11-20 9:08 ` Daniel P. Berrangé
[not found] ` <CAEAkEp4N1uFczHexCAbABzYf5O-Th-o5dE-KasU1RXM_k7WKKQ@mail.gmail.com>
2026-11-20 9:31 ` Daniel P. Berrangé
2026-11-20 10:03 ` Nagendran Jairam
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.