All of lore.kernel.org
 help / color / mirror / Atom feed
* [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.