summaryrefslogtreecommitdiff
path: root/avr/cmd_loadihex.c
diff options
context:
space:
mode:
Diffstat (limited to 'avr/cmd_loadihex.c')
-rw-r--r--avr/cmd_loadihex.c320
1 files changed, 320 insertions, 0 deletions
diff --git a/avr/cmd_loadihex.c b/avr/cmd_loadihex.c
new file mode 100644
index 0000000..01fb6b0
--- /dev/null
+++ b/avr/cmd_loadihex.c
@@ -0,0 +1,320 @@
+/*
+ * (C) Copyright 2015 Leo C. <erbl259-lmu@yahoo.de>
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ */
+
+#include "common.h"
+#include <stdlib.h>
+#include <ctype.h>
+#include <stdbool.h>
+
+#include "command.h"
+#include "con-utils.h"
+#include "z80-if.h"
+//#include "debug.h"
+
+
+uint32_t detect_ramsize(void)
+{
+ uint32_t addr;
+ uint8_t save_addr, save_0;
+ const uint8_t PATTERN_1 = 0x55;
+ const uint8_t PATTERN_2 = ~PATTERN_1;
+
+ if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
+ my_puts_P(PSTR("Bus timeout\n"));
+ return 0;
+ }
+
+ save_0 = z80_read(0);
+ z80_write(0, PATTERN_1);
+
+ for (addr=1; addr < CONFIG_SYS_RAMSIZE_MAX; addr <<= 1) {
+ save_addr = z80_read(addr);
+ z80_write(addr, PATTERN_2);
+ if (z80_read(0) != PATTERN_1 || z80_read(addr) != PATTERN_2)
+ break;
+ z80_write(addr, save_addr);
+ }
+ z80_write(0, save_0);
+ z80_bus_cmd(Release);
+
+ return addr;
+}
+
+static uint32_t min(uint32_t a, uint32_t b)
+{
+ if (a < b)
+ return a;
+ return b;
+}
+
+
+typedef enum {
+ IHX_OK,
+ IHX_BROKEN,
+ IHX_CHKSUMERR
+} ihx_rstat_t;
+
+typedef struct {
+ ihx_rstat_t status;
+ int8_t type;
+ uint8_t len;
+ uint16_t address;
+ uint8_t data[256];
+} ihex_t;
+
+
+static
+int get_hexdigit(void) {
+
+ int c;
+ c = toupper(my_getchar(1));
+ if (isxdigit(c)) {
+ c -= '0';
+ if (c > 9)
+ c -= ('A' - '0' - 10);
+ return c;
+ } else
+ return -1;
+}
+
+static
+int get_hexbyte(void) {
+
+ uint8_t i,j;
+
+ if ((i = (uint8_t) get_hexdigit()) < 0x10)
+ if ((j = (uint8_t) get_hexdigit()) < 0x10) {
+ return (i<<4) + j;
+ }
+
+ return -1;
+}
+
+#if 0
+
+static
+ihex_t ihex_get_record() {
+
+ int i;
+ uint8_t sum, c;
+ ihex_t rec = { IHX_BROKEN, 0, 0, 0, 0 };
+
+
+ while ((c = my_getchar(0)) != ':')
+ if (c == 0x03)
+ return rec;
+
+ if ((i = get_hexbyte()) < 0) /* Start code */
+ return rec;
+ sum = i;
+ rec.len = i;
+ if ((i = get_hexbyte()) < 0) /* Byte Count */
+ return rec;
+ sum += i;
+ rec.address = i * 256;
+ if ((i = get_hexbyte()) < 0) /* Address */
+ return rec;
+ sum += i;
+ rec.address += i;
+ if ((i = get_hexbyte()) < 0) /* Record type */
+ return rec;
+ sum += i;
+ rec.type = i;
+
+ if (rec.len) { /* Record Data */
+ uint8_t *p; int k;
+ if ((rec.data = malloc(rec.len)) == 0)
+ return rec;
+
+ for (p=rec.data, k=rec.len; k; k--) {
+ if ((i = get_hexbyte()) < 0)
+ break;
+ sum += i;
+ *p++ = i;
+ }
+
+ if (k) {
+ free(rec.data); rec.data = 0;
+ return rec;
+ }
+ }
+
+ i = get_hexbyte(); /* Check sum */
+
+ if (i >= 0) {
+ sum += i;
+ if (sum == 0)
+ rec.status = IHX_OK;
+ else
+ rec.status = IHX_CHKSUMERR;
+ }
+
+ if (rec.status != IHX_OK) {
+ free(rec.data);
+ rec.data = 0;
+ }
+
+ return rec;
+}
+
+#else
+
+static
+int ihex_get_record(ihex_t *rec) {
+
+ int c;
+ uint8_t sum;
+
+ rec->status = IHX_BROKEN;
+
+
+ while ((c = my_getchar(0)) != ':')
+ if (c == 0x03)
+ return -1;
+
+ if ((c = get_hexbyte()) < 0) /* Start code */
+ return -1;
+ sum = c;
+ rec->len = c;
+ if ((c = get_hexbyte()) < 0) /* Byte Count */
+ return -1;
+ sum += c;
+ rec->address = c * 256;
+ if ((c = get_hexbyte()) < 0) /* Address */
+ return -1;
+ sum += c;
+ rec->address += c;
+ if ((c = get_hexbyte()) < 0) /* Record type */
+ return -1;
+ sum += c;
+ rec->type = c;
+
+ if (rec->len) { /* Record Data */
+ uint8_t n;
+
+ for (n = 0; n < rec->len; n++) {
+ if ((c = get_hexbyte()) < 0)
+ break;
+ sum += c;
+ rec->data[n] = c;
+ }
+
+ if (n < rec->len) {
+ return -1;
+ }
+ }
+
+ c = get_hexbyte(); /* Check sum */
+
+ if (c >= 0) {
+ sum += c;
+ if (sum == 0)
+ rec->status = IHX_OK;
+ else
+ rec->status = IHX_CHKSUMERR;
+ }
+
+ return rec->len;
+}
+
+#endif
+
+command_ret_t do_loadihex(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+{
+ long offset = 0;
+ uint32_t base_address = 0;
+ uint32_t address_max = detect_ramsize();
+ uint32_t address_high = 0;
+ uint32_t address_low = address_max;
+ command_ret_t rcode = CMD_RET_FAILURE;
+ ihex_t rec;
+
+ (void) cmdtp; (void) flag;
+
+
+ printf_P(PSTR("RAM Size: 0x%.5lX\n"), address_max);
+
+
+ if (argc > 1)
+ offset = strtol(argv[1], NULL, 16);
+
+ while (ihex_get_record(&rec) > 0 &&
+ rec.status == IHX_OK &&
+ rec.type != 1 ) {
+
+ switch (rec.type) {
+ case 0: /* Data record */
+ if (rec.len) {
+ uint32_t addr = base_address + rec.address + offset;
+ if (addr < address_low)
+ address_low = addr;
+ if (addr+rec.len > address_high)
+ address_high = addr + rec.len;
+
+
+printf_P(PSTR("low: 0x%.5lX, high: 0x%.5lX, max: 0x%.5lX, addr: 0x%.5lX, len: %d\n"),
+ address_low, address_high, address_max, addr, rec.len);
+
+ if (addr < address_max) {
+ uint32_t tmplen = address_max - addr;
+ if (rec.len > tmplen)
+ rec.len = tmplen;
+
+ if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
+ my_puts_P(PSTR("Bus timeout\n"));
+ return CMD_RET_FAILURE;
+ }
+ z80_write_block(rec.data, /* src */
+ addr, /* dest */
+ rec.len); /* len */
+ z80_bus_cmd(Release);
+ }
+ }
+ break;
+
+#if 0
+ case 1: /* EOF record */
+ break;
+#endif
+ case 2: /* Extended Segment Address Record */
+ base_address = ((rec.data[0] << 8) + rec.data[1]) << 4;
+ break;
+
+ case 4: /* Extended Linear Address Record */
+ base_address = (uint32_t)((rec.data[0] << 8) + rec.data[1]) << 16;
+ break;
+
+ case 3: /* Start Segment Address Record (ignored)*/
+ case 5: /* Start Linear Address Record (ignored)*/
+ break;
+
+ }
+ }
+
+ switch (rec.status) {
+ case IHX_OK:
+ rcode = CMD_RET_SUCCESS;
+ break;
+
+ case IHX_BROKEN:
+ case IHX_CHKSUMERR:
+ printf_P(PSTR("Broken Hex Record or loading interrupted!\n"));
+ break;
+ }
+
+ printf_P(PSTR("Data loaded: "));
+ if (address_low >= min(address_high, address_max))
+ printf_P(PSTR("None.\n"));
+ else
+ printf_P(PSTR("low: 0x%.5lX high: 0x%.5lX\n"), address_low,
+ min(address_high, address_max) - 1);
+
+ if (address_high > address_max)
+ printf_P(PSTR("Data above highest RAM address "
+ "(Range 0x%.5lX...0x%.5lX) ignored!\n"), address_max, address_high - 1);
+
+ return rcode;
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-01 16:26:50 +0000