[z180-stamp.git] / avr / cmd_loadihex.c

/*
 * (C) Copyright 2015 Leo C. <erbl259-lmu@yahoo.de>
 *
 * SPDX-License-Identifier:	GPL-2.0
 */

#include "cmd_loadihex.h"
#include <ctype.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;
}

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;
}


static
int ihex_get_record(ihex_t *rec) {

	int c;
	uint8_t sum;

	rec->status = IHX_BROKEN;
	rec->len = 0;
	rec->type = 0xff;

	while ((c = my_getchar(0)) != ':') {
		if (c == 0x03)
			return -1;					/* Control-C */
		if (c == 0x04) {
			rec->status = IHX_OK;
			return 0;					/*Control-D, EOF */
		}
	}

	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;
}


command_ret_t do_loadihex(cmd_tbl_t *cmdtp, uint_fast8_t 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;
	bool firstrec = true;

	(void) cmdtp; (void) flag;


	if (argc > 1)
		offset = strtol(argv[1], NULL, 16);

	printf_P(PSTR("Waiting for Intel Hex Records...\n"));

	while (ihex_get_record(&rec) > 0 &&
				rec.status == IHX_OK &&
				rec.type != 1 ) {

		switch (rec.type) {
		case 0: /* Data record */
			if (firstrec) {
				printf_P(PSTR("Loading: 0x....."));
				firstrec = false;
			}
			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;

//				debug("low: 0x%.5lX, high: 0x%.5lX, max: 0x%.5lX, addr: 0x%.5lX, len: %d\n",
//					address_low, address_high, address_max, addr, rec.len);
				printf_P(PSTR("\b\b\b\b\b%.5lX"), addr);
				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 = (uint32_t)((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;
	}


	for (uint_fast8_t i=0; i<100; ++i) {
		/* flush input buffer */
		while (my_getchar(0) > 0)
			;
		udelay(1000);
	}


	printf_P(PSTR("\nData 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 "
			"(in range 0x%.5lX - 0x%.5lX) ignored!\n"), address_max, address_high - 1);

	return rcode;
}
Commit	Line	Data
179bc609 L	1	/*
	2	* (C) Copyright 2015 Leo C. <erbl259-lmu@yahoo.de>
	3	*
93ea25f2	4	* SPDX-License-Identifier: GPL-2.0
179bc609 L	5	*/
179bc609 L	6
228b1c5f	7	#include "cmd_loadihex.h"
179bc609	8	#include <ctype.h>
179bc609	9
179bc609 L	10	#include "con-utils.h"
179bc609 L	11	#include "z80-if.h"
d264541a	12	#include "debug.h"
179bc609 L	13
179bc609 L	14
5480dc65 L	15	uint32_t detect_ramsize(void)
	16	{
	17	uint32_t addr;
	18	uint8_t save_addr, save_0;
	19	const uint8_t PATTERN_1 = 0x55;
	20	const uint8_t PATTERN_2 = ~PATTERN_1;
	21
	22	if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
	23	my_puts_P(PSTR("Bus timeout\n"));
	24	return 0;
	25	}
	26
	27	save_0 = z80_read(0);
	28	z80_write(0, PATTERN_1);
	29
	30	for (addr=1; addr < CONFIG_SYS_RAMSIZE_MAX; addr <<= 1) {
	31	save_addr = z80_read(addr);
	32	z80_write(addr, PATTERN_2);
	33	if (z80_read(0) != PATTERN_1 \|\| z80_read(addr) != PATTERN_2)
	34	break;
	35	z80_write(addr, save_addr);
	36	}
	37	z80_write(0, save_0);
	38	z80_bus_cmd(Release);
	39
	40	return addr;
	41	}
	42
179bc609 L	43	typedef enum {
	44	IHX_OK,
	45	IHX_BROKEN,
	46	IHX_CHKSUMERR
	47	} ihx_rstat_t;
	48
	49	typedef struct {
	50	ihx_rstat_t status;
	51	int8_t type;
	52	uint8_t len;
	53	uint16_t address;
5480dc65	54	uint8_t data[256];
179bc609 L	55	} ihex_t;
	56
	57
	58	static
	59	int get_hexdigit(void) {
	60
	61	int c;
	62	c = toupper(my_getchar(1));
	63	if (isxdigit(c)) {
	64	c -= '0';
	65	if (c > 9)
	66	c -= ('A' - '0' - 10);
	67	return c;
	68	} else
	69	return -1;
	70	}
	71
	72	static
	73	int get_hexbyte(void) {
	74
	75	uint8_t i,j;
	76
	77	if ((i = (uint8_t) get_hexdigit()) < 0x10)
	78	if ((j = (uint8_t) get_hexdigit()) < 0x10) {
	79	return (i<<4) + j;
	80	}
	81
	82	return -1;
	83	}
	84
5480dc65 L	85
	86	static
	87	int ihex_get_record(ihex_t *rec) {
	88
	89	int c;
	90	uint8_t sum;
	91
	92	rec->status = IHX_BROKEN;
bf587043 L	93	rec->len = 0;
bf587043 L	94	rec->type = 0xff;
5480dc65	95
bf587043	96	while ((c = my_getchar(0)) != ':') {
5480dc65	97	if (c == 0x03)
bf587043 L	98	return -1; /* Control-C */
	99	if (c == 0x04) {
	100	rec->status = IHX_OK;
	101	return 0; /Control-D, EOF /
	102	}
	103	}
5480dc65 L	104
	105	if ((c = get_hexbyte()) < 0) /* Start code */
	106	return -1;
	107	sum = c;
	108	rec->len = c;
	109	if ((c = get_hexbyte()) < 0) /* Byte Count */
	110	return -1;
	111	sum += c;
	112	rec->address = c * 256;
	113	if ((c = get_hexbyte()) < 0) /* Address */
	114	return -1;
	115	sum += c;
	116	rec->address += c;
	117	if ((c = get_hexbyte()) < 0) /* Record type */
	118	return -1;
	119	sum += c;
	120	rec->type = c;
	121
	122	if (rec->len) { /* Record Data */
	123	uint8_t n;
	124
	125	for (n = 0; n < rec->len; n++) {
	126	if ((c = get_hexbyte()) < 0)
	127	break;
	128	sum += c;
	129	rec->data[n] = c;
	130	}
	131
	132	if (n < rec->len) {
	133	return -1;
	134	}
	135	}
	136
	137	c = get_hexbyte(); /* Check sum */
	138
	139	if (c >= 0) {
	140	sum += c;
	141	if (sum == 0)
	142	rec->status = IHX_OK;
	143	else
	144	rec->status = IHX_CHKSUMERR;
	145	}
	146
	147	return rec->len;
	148	}
	149
179bc609	150
93ea25f2	151	command_ret_t do_loadihex(cmd_tbl_t cmdtp, uint_fast8_t flag, int argc, char const argv[])
179bc609 L	152	{
	153	long offset = 0;
	154	uint32_t base_address = 0;
5480dc65	155	uint32_t address_max = detect_ramsize();
179bc609	156	uint32_t address_high = 0;
5480dc65	157	uint32_t address_low = address_max;
179bc609 L	158	command_ret_t rcode = CMD_RET_FAILURE;
179bc609 L	159	ihex_t rec;
bf587043	160	bool firstrec = true;
179bc609	161
5480dc65 L	162	(void) cmdtp; (void) flag;
	163
	164
179bc609 L	165	if (argc > 1)
	166	offset = strtol(argv[1], NULL, 16);
	167
bf587043 L	168	printf_P(PSTR("Waiting for Intel Hex Records...\n"));
bf587043 L	169
5480dc65 L	170	while (ihex_get_record(&rec) > 0 &&
	171	rec.status == IHX_OK &&
	172	rec.type != 1 ) {
	173
	174	switch (rec.type) {
	175	case 0: /* Data record */
bf587043 L	176	if (firstrec) {
	177	printf_P(PSTR("Loading: 0x....."));
	178	firstrec = false;
	179	}
5480dc65 L	180	if (rec.len) {
	181	uint32_t addr = base_address + rec.address + offset;
	182	if (addr < address_low)
	183	address_low = addr;
	184	if (addr+rec.len > address_high)
	185	address_high = addr + rec.len;
179bc609	186
d264541a L	187	// debug("low: 0x%.5lX, high: 0x%.5lX, max: 0x%.5lX, addr: 0x%.5lX, len: %d\n",
d264541a L	188	// address_low, address_high, address_max, addr, rec.len);
bf587043	189	printf_P(PSTR("\b\b\b\b\b%.5lX"), addr);
5480dc65 L	190	if (addr < address_max) {
	191	uint32_t tmplen = address_max - addr;
	192	if (rec.len > tmplen)
	193	rec.len = tmplen;
	194
	195	if (!(z80_bus_cmd(Request) & ZST_ACQUIRED)) {
	196	my_puts_P(PSTR("Bus timeout\n"));
	197	return CMD_RET_FAILURE;
	198	}
179bc609 L	199	z80_write_block(rec.data, /* src */
	200	addr, /* dest */
	201	rec.len); /* len */
	202	z80_bus_cmd(Release);
	203	}
179bc609	204	}
5480dc65	205	break;
179bc609	206
5480dc65 L	207	#if 0
	208	case 1: /* EOF record */
	209	break;
	210	#endif
	211	case 2: /* Extended Segment Address Record */
d264541a	212	base_address = (uint32_t)((rec.data[0] << 8) + rec.data[1]) << 4;
5480dc65	213	break;
ae017d4c	214
5480dc65 L	215	case 4: /* Extended Linear Address Record */
	216	base_address = (uint32_t)((rec.data[0] << 8) + rec.data[1]) << 16;
	217	break;
ae017d4c	218
5480dc65 L	219	case 3: /* Start Segment Address Record (ignored)*/
	220	case 5: /* Start Linear Address Record (ignored)*/
	221	break;
	222
	223	}
179bc609 L	224	}
	225
	226	switch (rec.status) {
	227	case IHX_OK:
	228	rcode = CMD_RET_SUCCESS;
	229	break;
	230
	231	case IHX_BROKEN:
	232	case IHX_CHKSUMERR:
	233	printf_P(PSTR("Broken Hex Record or loading interrupted!\n"));
	234	break;
	235	}
	236
4cbc8d3e	237
bf587043 L	238	for (uint_fast8_t i=0; i<100; ++i) {
	239	/* flush input buffer */
	240	while (my_getchar(0) > 0)
	241	;
	242	udelay(1000);
	243	}
	244
	245
	246	printf_P(PSTR("\nData loaded: "));
d264541a	247	if (address_low >= MIN(address_high, address_max))
179bc609 L	248	printf_P(PSTR("None.\n"));
179bc609 L	249	else
5480dc65	250	printf_P(PSTR("low: 0x%.5lX high: 0x%.5lX\n"), address_low,
d264541a	251	MIN(address_high, address_max) - 1);
5480dc65 L	252
	253	if (address_high > address_max)
	254	printf_P(PSTR("Data above highest RAM address "
d264541a	255	"(in range 0x%.5lX - 0x%.5lX) ignored!\n"), address_max, address_high - 1);
179bc609 L	256
	257	return rcode;
	258	}