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

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.