add adapter handling for HiROM

[flashkit-mdc.git] / flashkit.c

/*
 * Tool for USB serial communication with Krikzz's FlashKit-MD
 * Copyright (c) 2017 notaz
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be 
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <assert.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <arpa/inet.h> // hton
#include <termios.h>
#include <unistd.h>

#ifndef min
#define min(x, y) ((x) < (y) ? (x) : (y))
#define max(x, y) ((x) > (y) ? (x) : (y))
#endif

enum dev_cmd {
	CMD_ADDR = 0,
        CMD_LEN = 1,
        CMD_RD = 2,
        CMD_WR = 3,
        CMD_RY = 4,
        CMD_DELAY = 5,
};
#define PAR_MODE8  (1 << 4)	/* but still drives noth LWR and UWR */
#define PAR_DEV_ID (1 << 5)
#define PAR_SINGE  (1 << 6)
#define PAR_INC    (1 << 7)

static struct flash_info {
	uint32_t prog_addr;
	uint16_t mid;
	uint16_t did;
	uint32_t size;
	uint16_t region_cnt;
	struct {
		uint32_t block_size;
		uint32_t block_count;
		uint32_t start;
		uint32_t size;
	} region[4];
} info;

static int setup(int fd)
{
	struct termios tty;
	int ret;

	memset(&tty, 0, sizeof(tty));

	ret = tcgetattr(fd, &tty);
	if (ret != 0)
	{
		perror("tcgetattr");
		return 1;
	}

	tty.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP
			| INLCR | IGNCR | ICRNL | IXON);
	tty.c_oflag &= ~OPOST;
	tty.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
	tty.c_cflag &= ~(CSIZE | PARENB);
	tty.c_cflag |= CS8;

	//tty.c_cc[VMIN] = 1;
	//tty.c_cc[VTIME] = 5;            // 0.5 seconds read timeout

	ret = tcsetattr(fd, TCSANOW, &tty);
	if (ret != 0) {
		perror("tcsetattr");
		return ret;
	}

	return 0;
}

static int write_serial(int fd, const void *data, size_t size)
{
	int ret;

	ret = write(fd, data, size);
	if (ret != size) {
		fprintf(stderr, "write %d/%zd: ", ret, size);
		perror("");
		exit(1);
	}

	return 0;
}

static int read_serial(int fd, void *data, size_t size)
{
	size_t got = 0;
	int ret;

	while (got < size) {
		ret = read(fd, (char *)data + got, size - got);
		if (ret <= 0) {
			fprintf(stderr, "read %d %zd/%zd: ",
				ret, got, size);
			perror("");
			exit(1);
		}
		got += ret;
	}

	return 0;
}

/* addr arg is always byte address */
static void set_addr8(int fd, uint32_t addr)
{
	uint8_t cmd[6] = {
		CMD_ADDR, addr >> 16,
		CMD_ADDR, addr >> 8,
		CMD_ADDR, addr >> 0
	};
	write_serial(fd, cmd, sizeof(cmd));
}

static void set_addr16(int fd, uint32_t addr)
{
	set_addr8(fd, addr >> 1);
}

static uint16_t read_bus8(int fd, uint32_t addr)
{
	uint8_t cmd[7] = {
		CMD_ADDR, addr >> 16,
		CMD_ADDR, addr >> 8,
		CMD_ADDR, addr >> 0,
		CMD_RD | PAR_SINGE | PAR_MODE8
	};
	uint8_t r;

	write_serial(fd, cmd, sizeof(cmd));
	read_serial(fd, &r, sizeof(r));
	return r;
}

static uint16_t read_bus16(int fd, uint32_t addr)
{
	uint8_t cmd[7] = {
		CMD_ADDR, addr >> 17,
		CMD_ADDR, addr >> 9,
		CMD_ADDR, addr >> 1,
		CMD_RD | PAR_SINGE
	};
	uint16_t r;

	write_serial(fd, cmd, sizeof(cmd));
	read_serial(fd, &r, sizeof(r));
	return ntohs(r);
}

static void write_bus8(int fd, uint32_t addr, uint16_t d)
{
	uint8_t cmd[8] = {
		CMD_ADDR, addr >> 16,
		CMD_ADDR, addr >> 8,
		CMD_ADDR, addr >> 0,
		CMD_WR | PAR_SINGE | PAR_MODE8,
		d
	};

	write_serial(fd, cmd, sizeof(cmd));
}

static void write_bus16(int fd, uint32_t addr, uint16_t d)
{
	uint8_t cmd[9] = {
		CMD_ADDR, addr >> 17,
		CMD_ADDR, addr >> 9,
		CMD_ADDR, addr >> 1,
		CMD_WR | PAR_SINGE,
		d >> 8, d
	};

	write_serial(fd, cmd, sizeof(cmd));
}

static void read_block8(int fd, void *dst, uint32_t size)
{
	// PAR_MODE8 does not work, so read as 16bit and throw away MSB
	uint8_t tmp[0x10000], *d8 = dst;
	uint8_t cmd[5] = {
		CMD_LEN, size >> 8,
		CMD_LEN, size >> 0,
		CMD_RD | PAR_INC
	};
	int i;

	assert(size <= 0x10000);
	write_serial(fd, cmd, sizeof(cmd));
	read_serial(fd, dst, size);
	read_serial(fd, tmp, size);

	for (i = 0; i < size / 2; i++)
		d8[i] = d8[i * 2 + 1];
	d8 += size / 2;
	for (i = 0; i < size / 2; i++)
		d8[i] = tmp[i * 2 + 1];
}

static void read_block16(int fd, void *dst, uint32_t size)
{
	uint8_t cmd[5] = {
		CMD_LEN, size >> 9,
		CMD_LEN, size >> 1,
		CMD_RD | PAR_INC
	};

	assert(size <= 0x10000);
	write_serial(fd, cmd, sizeof(cmd));
	read_serial(fd, dst, size);
}

static void flash_seq_write8(int fd, uint32_t addr, const uint8_t *d)
{
	uint8_t cmd[] = {
		// unlock
		CMD_ADDR, info.prog_addr >> 16,
		CMD_ADDR, info.prog_addr >> 8,
		CMD_ADDR, info.prog_addr >> 0,
		CMD_WR | PAR_SINGE | PAR_MODE8, 0xaa,
		CMD_ADDR, info.prog_addr >> 17,
		CMD_ADDR, info.prog_addr >> 9,
		CMD_ADDR, info.prog_addr >> 1,
		CMD_WR | PAR_SINGE | PAR_MODE8, 0x55,
		// program setup
		CMD_ADDR, info.prog_addr >> 16,
		CMD_ADDR, info.prog_addr >> 8,
		CMD_ADDR, info.prog_addr >> 0,
		CMD_WR | PAR_SINGE | PAR_MODE8, 0xa0,
		// program data
		CMD_ADDR, addr >> 16,
		CMD_ADDR, addr >> 8,
		CMD_ADDR, addr >> 0,
		CMD_WR | PAR_SINGE | PAR_MODE8, *d,
		CMD_RY
	};

	assert(info.prog_addr);
	write_serial(fd, cmd, sizeof(cmd));
}

static void flash_seq_write16(int fd, uint32_t addr, const uint8_t *d)
{
	uint8_t cmd[] = {
		// unlock
		CMD_ADDR, info.prog_addr >> 17,
		CMD_ADDR, info.prog_addr >> 9,
		CMD_ADDR, info.prog_addr >> 1,
		CMD_WR | PAR_SINGE | PAR_MODE8, 0xaa,
		CMD_ADDR, info.prog_addr >> 18,
		CMD_ADDR, info.prog_addr >> 10,
		CMD_ADDR, info.prog_addr >> 2,
		CMD_WR | PAR_SINGE | PAR_MODE8, 0x55,
		// program setup
		CMD_ADDR, info.prog_addr >> 17,
		CMD_ADDR, info.prog_addr >> 9,
		CMD_ADDR, info.prog_addr >> 1,
		CMD_WR | PAR_SINGE | PAR_MODE8, 0xa0,
		// program data
		CMD_ADDR, addr >> 17,
		CMD_ADDR, addr >> 9,
		CMD_ADDR, addr >> 1,
		CMD_WR | PAR_SINGE, d[0], d[1],
		CMD_RY
	};

	assert(info.prog_addr);
	write_serial(fd, cmd, sizeof(cmd));
}

// -- 8bit+LoROM --

static uint32_t lorom_rom_addr(uint32_t a)
{
	return ((a & 0x7f8000) << 1) | 0x8000 | (a & 0x7fff);
}

static void set_addr8l(int fd, uint32_t a)
{
	set_addr8(fd, lorom_rom_addr(a));
}

static uint16_t read_bus8l(int fd, uint32_t a)
{
	return read_bus8(fd, lorom_rom_addr(a));
}

static void write_bus8l(int fd, uint32_t a, uint16_t d)
{
	write_bus8(fd, lorom_rom_addr(a), d);
}

static void flash_seq_write8l(int fd, uint32_t a, const uint8_t *d)
{
	a = lorom_rom_addr(a);
	uint8_t cmd[] = {
		// unlock
		CMD_ADDR, 0,
		CMD_ADDR, 0x8a,
		CMD_ADDR, 0xaa,
		CMD_WR | PAR_SINGE | PAR_MODE8, 0xaa,
		CMD_ADDR, 0,
		CMD_ADDR, 0x85,
		CMD_ADDR, 0x55,
		CMD_WR | PAR_SINGE | PAR_MODE8, 0x55,
		// program setup
		CMD_ADDR, 0,
		CMD_ADDR, 0x8a,
		CMD_ADDR, 0xaa,
		CMD_WR | PAR_SINGE | PAR_MODE8, 0xa0,
		// program data
		CMD_ADDR, a >> 16,
		CMD_ADDR, a >> 8,
		CMD_ADDR, a >> 0,
		CMD_WR | PAR_SINGE | PAR_MODE8, *d,
		CMD_RY
	};

	write_serial(fd, cmd, sizeof(cmd));
}

// -- 8bit+LoROM+adapter --

static uint32_t do_flipflops(int fd, uint32_t a)
{
	static uint32_t abits_now = ~0u; // A23, A22, A21
	uint32_t abits = (a >> 21) & 7;

	if (abits != abits_now) {
		// printf("flipflops: %x->%x\n", abits_now, abits);
		write_bus16(fd, 0xa13000, abits);
		abits_now = abits;
	}
	return a & 0x1fffff;
}

static void set_addr8la(int fd, uint32_t a)
{
	set_addr8(fd, do_flipflops(fd, lorom_rom_addr(a)));
}

static uint16_t read_bus8la(int fd, uint32_t a)
{
	return read_bus8(fd, do_flipflops(fd, lorom_rom_addr(a)));
}

static void write_bus8la(int fd, uint32_t a, uint16_t d)
{
	write_bus8(fd, do_flipflops(fd, lorom_rom_addr(a)), d);
}

static void flash_seq_write8la(int fd, uint32_t a, const uint8_t *d)
{
	// we should clear flipflops for the flash commands, but this
	// doesn't seem to be necessary as the flash chip seems to
	// ignore the upper bits when looking for commands, and this
	// extra clearing would slow things down
	a = do_flipflops(fd, lorom_rom_addr(a));
	uint8_t cmd[] = {
		// unlock
		CMD_ADDR, 0,
		CMD_ADDR, 0x8a,
		CMD_ADDR, 0xaa,
		CMD_WR | PAR_SINGE | PAR_MODE8, 0xaa,
		CMD_ADDR, 0,
		CMD_ADDR, 0x85,
		CMD_ADDR, 0x55,
		CMD_WR | PAR_SINGE | PAR_MODE8, 0x55,
		// program setup
		CMD_ADDR, 0,
		CMD_ADDR, 0x8a,
		CMD_ADDR, 0xaa,
		CMD_WR | PAR_SINGE | PAR_MODE8, 0xa0,
		// program data
		CMD_ADDR, a >> 16,
		CMD_ADDR, a >> 8,
		CMD_ADDR, a >> 0,
		CMD_WR | PAR_SINGE | PAR_MODE8, *d,
		CMD_RY
	};

	write_serial(fd, cmd, sizeof(cmd));
}

// -- 8bit+LoROM+adapter+sram --

static uint32_t lorom_sram_addr(uint32_t a)
{
	return a | 0x600000;
}

static void set_addr8las(int fd, uint32_t a)
{
	set_addr8(fd, do_flipflops(fd, lorom_sram_addr(a)));
}

static uint16_t read_bus8las(int fd, uint32_t a)
{
	return read_bus8(fd, do_flipflops(fd, lorom_sram_addr(a)));
}

static void write_bus8las(int fd, uint32_t a, uint16_t d)
{
	write_bus8(fd, do_flipflops(fd, lorom_sram_addr(a)), d);
}

static void flash_seq_write8las(int fd, uint32_t a, const uint8_t *d)
{
}

// -- 8bit+adapter --

static void set_addr8a(int fd, uint32_t a)
{
	set_addr8(fd, do_flipflops(fd, a));
}

static uint16_t read_bus8a(int fd, uint32_t a)
{
	return read_bus8(fd, do_flipflops(fd, a));
}

static void write_bus8a(int fd, uint32_t a, uint16_t d)
{
	write_bus8(fd, do_flipflops(fd, a), d);
}

static void flash_seq_write8a(int fd, uint32_t a, const uint8_t *d)
{
	// no flipflop clearing, see flash_seq_write8la
	a = do_flipflops(fd, a);
	uint8_t cmd[] = {
		// unlock
		CMD_ADDR, 0,
		CMD_ADDR, 0x8a,
		CMD_ADDR, 0xaa,
		CMD_WR | PAR_SINGE | PAR_MODE8, 0xaa,
		CMD_ADDR, 0,
		CMD_ADDR, 0x85,
		CMD_ADDR, 0x55,
		CMD_WR | PAR_SINGE | PAR_MODE8, 0x55,
		// program setup
		CMD_ADDR, 0,
		CMD_ADDR, 0x8a,
		CMD_ADDR, 0xaa,
		CMD_WR | PAR_SINGE | PAR_MODE8, 0xa0,
		// program data
		CMD_ADDR, a >> 16,
		CMD_ADDR, a >> 8,
		CMD_ADDR, a >> 0,
		CMD_WR | PAR_SINGE | PAR_MODE8, *d,
		CMD_RY
	};

	write_serial(fd, cmd, sizeof(cmd));
}

// -- 8bit+adapter+nocart --

static void set_addr8an(int fd, uint32_t a)
{
	set_addr8(fd, do_flipflops(fd, a) | 0x200000);
}

static uint16_t read_bus8an(int fd, uint32_t a)
{
	return read_bus8(fd, do_flipflops(fd, a) | 0x200000);
}

static void write_bus8an(int fd, uint32_t a, uint16_t d)
{
	write_bus8(fd, do_flipflops(fd, a) | 0x200000, d);
}

static void flash_seq_write8an(int fd, uint32_t a, const uint8_t *d)
{
}

#define N0 ""
#define N1 "8bit"
#define N2 "8bit+LoROM"
#define N3 "8bit+LoROM+adapter"
#define N4 "8bit+LoROM+adapter+sram"
#define N5 "8bit+adapter (use '-a 0x400000' for HiROM)"
#define N6 "8bit+adapter+nocart"
static const struct iof
{
	const char *name;
	int      addrs_remapped;
	void     (*set_addr)(int fd, uint32_t addr);
	uint16_t (*read_bus)(int fd, uint32_t addr);
	void     (*write_bus)(int fd, uint32_t addr, uint16_t d);
	void     (*read_block)(int fd, void *dst, uint32_t size);
	void     (*flash_seq_write)(int fd, uint32_t addr, const uint8_t *d);
}
io_ops[] =
{
	{ N0, 0, set_addr16,   read_bus16,   write_bus16,   read_block16, flash_seq_write16   },
	{ N1, 0, set_addr8,    read_bus8,    write_bus8,    read_block8,  flash_seq_write8    },
	{ N2, 1, set_addr8l,   read_bus8l,   write_bus8l,   read_block8,  flash_seq_write8l   },
	{ N3, 1, set_addr8la,  read_bus8la,  write_bus8la,  read_block8,  flash_seq_write8la  },
	{ N4, 0, set_addr8las, read_bus8las, write_bus8las, read_block8,  flash_seq_write8las },
	{ N5, 0, set_addr8a,   read_bus8a,   write_bus8a,   read_block8,  flash_seq_write8a   },
	{ N6, 0, set_addr8an,  read_bus8an,  write_bus8an,  read_block8,  flash_seq_write8an  },
};

static const struct iof *io = &io_ops[0];

static uint16_t flash_seq_r(int fd, uint8_t cmd, uint32_t addr)
{
	// unlock
	assert(info.prog_addr);
	io->write_bus(fd, info.prog_addr >> 0, 0xaa);
	io->write_bus(fd, info.prog_addr >> 1, 0x55);

	io->write_bus(fd, info.prog_addr >> 0, cmd);
	return io->read_bus(fd, addr);
}

static void flash_seq_erase_d(int fd, uint32_t addr, uint8_t d)
{
	// printf("erase %06x\n", addr);
	assert(info.prog_addr);
	io->write_bus(fd, info.prog_addr >> 0, 0xaa);
	io->write_bus(fd, info.prog_addr >> 1, 0x55);
	io->write_bus(fd, info.prog_addr >> 0, 0x80);

	io->write_bus(fd, info.prog_addr >> 0, 0xaa);
	io->write_bus(fd, info.prog_addr >> 1, 0x55);
	io->write_bus(fd, addr, d);
}

static void flash_seq_erase(int fd, uint32_t addr)
{
	flash_seq_erase_d(fd, addr, 0x30);
}

static void flash_seq_erase_full(int fd)
{
	flash_seq_erase_d(fd, info.prog_addr, 0x10);
}

// status wait + dummy read to cause a wait?
static uint16_t ry_read(int fd)
{
	uint8_t cmd[2] = { CMD_RY, CMD_RD | PAR_SINGE };
	uint16_t rv = 0;

	write_serial(fd, cmd, sizeof(cmd));
	read_serial(fd, &rv, sizeof(rv));
	return ntohs(rv);
}

static void set_delay(int fd, uint8_t delay)
{
	uint8_t cmd[2] = { CMD_DELAY, delay };

	write_serial(fd, cmd, sizeof(cmd));
}

static void read_info(int fd)
{
	static const uint16_t qry[3] = { 'Q', 'R', 'Y' };
	uint16_t resp_cfi[3], sst_mid = ~0;
	uint32_t total = 0;
	uint32_t i, a;


	// see if this chip understands CFI (common flash interface)
	io->write_bus(fd, 0xaa, 0x98);
	resp_cfi[0] = io->read_bus(fd, 0x20);
	resp_cfi[1] = io->read_bus(fd, 0x22);
	resp_cfi[2] = io->read_bus(fd, 0x24);
	if (memcmp(resp_cfi, qry, sizeof(resp_cfi)) == 0)
	{
		info.size = 1u << io->read_bus(fd, 0x4e);
		info.region_cnt = io->read_bus(fd, 0x58);
		assert(0 < info.region_cnt && info.region_cnt <= 4);
		for (i = 0, a = 0x5a; i < info.region_cnt; i++, a += 8) {
			info.region[i].block_count = io->read_bus(fd, a + 0) + 1;
			info.region[i].block_count += io->read_bus(fd, a + 2) << 8;
			info.region[i].block_size = io->read_bus(fd, a + 4) << 8;
			info.region[i].block_size |= io->read_bus(fd, a + 6) << 16;
			info.region[i].start = total;
			info.region[i].size =
				info.region[i].block_size * info.region[i].block_count;
			assert(info.region[i].size);
			total += info.region[i].size;
		}
		if (info.size != total)
			fprintf(stderr, "warning: total is %u, bad CFI?\n", total);

		info.prog_addr = 0xaaa;
		io->write_bus(fd, 0, 0xf0);
		info.mid = flash_seq_r(fd, 0x90, 0); // autoselect
		info.did = io->read_bus(fd, 2);
	}
	else
	{
		// try the SST protocol
		info.prog_addr = 0x5555;
		sst_mid = flash_seq_r(fd, 0x90, 0);
		if (sst_mid == 0xbf)
		{
			info.mid = sst_mid;
			info.did = io->read_bus(fd, 0x01);
			switch (info.did) {
			case 0xb5:
			case 0xb6:
			case 0xb7:
				info.size = 128 * 1024 << (info.did - 0xb5);
				break;
			default:
				fprintf(stderr, "unrecognized SST device %02x\n", info.did);
				exit(1);
			}
			info.region_cnt = 1;
			info.region[0].block_count = info.size / 4096;
			info.region[0].block_size = 4096;
			info.region[0].start = 0;
			info.region[0].size = info.size;
		}
		else
			info.prog_addr = 0;
	}

	io->write_bus(fd, 0, 0xf0); // flash reset

	if (info.prog_addr == 0) {
		fprintf(stderr, "unable to identify the flash chip :(\n");
		fprintf(stderr, "CFI response: %02x %02x %02x\n",
			resp_cfi[0], resp_cfi[1], resp_cfi[2]);
		fprintf(stderr, "SST MID: %02x\n", sst_mid);
		exit(1);
	}

	printf("Flash info:\n");
	printf("Manufacturer ID: %04x\n", info.mid);
	printf("Device ID: %04x\n", info.did);
	printf("size: %u\n", info.size);
	printf("Erase Block Regions: %u\n", info.region_cnt);
	for (i = 0; i < info.region_cnt; i++)
		printf("  %5u x %u\n", info.region[i].block_size,
			info.region[i].block_count);
}

static uint32_t get_block_addr(uint32_t addr, uint32_t blk_offset)
{
	uint32_t i, base, faddr;

	assert(info.region_cnt);
	assert(info.size);

	// get a flash address to allow mapper hardware
	faddr = addr & (info.size - 1);
	base = addr & ~(info.size - 1);

	for (i = 0; i < info.region_cnt; i++) {
		if (info.region[i].start <= faddr
		    && faddr < info.region[i].start + info.region[i].size)
		{
			uint32_t blk = (faddr - info.region[i].start)
					/ info.region[i].block_size
					+ blk_offset;
			return base + info.region[i].start
				+ blk * info.region[i].block_size;
		}
	}

	fprintf(stderr, "\naddress out of range: 0x%x\n", addr);
	exit(1);
}

static void print_progress(uint32_t done, uint32_t total)
{
	int i, step;

	printf("\r%06x/%06x |", done, total);

	step = (total + 19) / 20;
	for (i = step; i <= total; i += step)
		fputc(done >= i ? '=' : '-', stdout);
	printf("| %3d%%", done * 100 / total);
	fflush(stdout);
	if (done >= total)
		fputc('\n', stdout);
}

static FILE *open_prep_read(const char *fname, long *size)
{
	FILE *f = fopen(fname, "rb");
	if (!f) {
		fprintf(stderr, "fopen %s: ", fname);
		perror("");
		exit(1);
	}
	if (*size <= 0) {
		fseek(f, 0, SEEK_END);
		*size = ftell(f);
		fseek(f, 0, SEEK_SET);
	}
	if (*size <= 0) {
		fprintf(stderr, "size of %s is %ld\n", fname, *size);
		exit(1);
	}
	return f;
}

static const char *portname =
#ifdef __APPLE__
	"/dev/cu.usbserial-AL0254JM";
#else
	"/dev/ttyUSB0";
#endif

static void usage(const char *argv0)
{
	size_t i;

	printf("usage:\n"
		"%s [options]\n"
		"  -d <ttydevice>      (default %s)\n"
		"  -r <file> [size]    dump the cart (default 4MB)\n"
		"  -w <file> [size]    program the flash (def. file size)\n"
		"  -s <file> [size]    simple write (SRAM, etc, def. file size)\n"
		"  -e <size>           erase (rounds to block size); can specify 'full'\n"
		"  -a <start_address>  read/write start address (default 0)\n"
		"  -m <n>              use an address mapper n, one of:\n"
		, argv0, portname);
	for (i = 1; i < sizeof(io_ops) / sizeof(io_ops[0]); i++)
		printf(
		"                       %zd: %s\n", i, io_ops[i].name);
	printf( "  -v                  verify written data\n"
		"  -i                  get info about the flash chip\n");
	exit(1);
}

static void invarg(int argc, char *argv[], int arg)
{
	if (arg < argc)
		fprintf(stderr, "invalid arg %d: \"%s\"\n", arg, argv[arg]);
	else
		fprintf(stderr, "missing required argument %d\n", arg);
	exit(1);
}

static void *getarg(int argc, char *argv[], int arg)
{
	if (arg >= argc)
		invarg(argc, argv, arg);
	return argv[arg];
}

static long getarg_l(int argc, char *argv[], int arg)
{
	char *endp = NULL;
	long r;

	if (arg >= argc)
		invarg(argc, argv, arg);
	r = strtol(argv[arg], &endp, 0);
	if (endp == NULL || *endp != 0)
		invarg(argc, argv, arg);
	return r;
}

// 32K to easily handle SNES LoROM
static uint8_t g_block[0x8000];
static uint8_t g_block2[sizeof(g_block)];

int main(int argc, char *argv[])
{
	const char *fname_w = NULL;
	const char *fname_r = NULL;
	const char *fname_ws = NULL;
	long size_w = 0;
	long size_r = 0;
	long size_ws = 0;
	long size_e = 0;
	long size_v = 0;
	long len, address_in = 0;
	long a, a_blk, end;
	int do_info = 0;
	int do_verify = 0;
	int write_step = 2;
	FILE *f_w = NULL;
	FILE *f_r = NULL;
	FILE *f_ws = NULL;
	uint8_t id[2] = { 0, 0 };
	uint8_t cmd;
	uint16_t rv;
	int arg = 1;
	int fd;

	if (argc < 2 || !strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))
		usage(argv[0]);

	for (arg = 1; arg < argc; arg++) {
		if (!strcmp(argv[arg], "-d")) {
			portname = getarg(argc, argv, ++arg);
			continue;
		}
		if (!strcmp(argv[arg], "-r")) {
			fname_r = getarg(argc, argv, ++arg);
			if (arg + 1 < argc && argv[arg + 1][0] != '-') {
				size_r = getarg_l(argc, argv, ++arg);
				if (size_r <= 0)
					invarg(argc, argv, arg);
			}
			continue;
		}
		if (!strcmp(argv[arg], "-w")) {
			fname_w = getarg(argc, argv, ++arg);
			if (arg + 1 < argc && argv[arg + 1][0] != '-') {
				size_w = getarg_l(argc, argv, ++arg);
				if (size_w <= 0)
					invarg(argc, argv, arg);
			}
			continue;
		}
		if (!strcmp(argv[arg], "-s")) {
			fname_ws = getarg(argc, argv, ++arg);
			if (arg + 1 < argc && argv[arg + 1][0] != '-') {
				size_ws = getarg_l(argc, argv, ++arg);
				if (size_ws <= 0)
					invarg(argc, argv, arg);
			}
			continue;
		}
		if (!strcmp(argv[arg], "-a")) {
			address_in = getarg_l(argc, argv, ++arg);
			if (address_in < 0)
				invarg(argc, argv, arg);
			continue;
		}
		if (!strcmp(argv[arg], "-e")) {
			arg++;
			if (!strcmp(getarg(argc, argv, arg), "full"))
				size_e = -1;
			else {
				size_e = getarg_l(argc, argv, arg);
				if (size_e <= 0)
					invarg(argc, argv, arg);
			}
			continue;
		}
		if (!strcmp(argv[arg], "-m")) {
			long v = getarg_l(argc, argv, ++arg);
			if ((size_t)v >= sizeof(io_ops) / sizeof(io_ops[0]))
				invarg(argc, argv, arg);
			io = &io_ops[v];
			if (v != 0)
				write_step = 1;
			continue;
		}
		if (!strcmp(argv[arg], "-v")) {
			do_verify = 1;
			continue;
		}
		if (!strcmp(argv[arg], "-i")) {
			do_info = 1;
			continue;
		}
		invarg(argc, argv, arg);
	}

	if (fname_r && size_r == 0)
		size_r = 0x400000;

	if (fname_w) {
		f_w = open_prep_read(fname_w, &size_w);
		if (size_e == 0 && io->addrs_remapped)
			size_e = -1;
		if (size_e != -1 && size_e < size_w)
			size_e = size_w;
		if (do_verify)
			size_v = size_w;
	}

	fd = open(portname, O_RDWR | O_NOCTTY | O_SYNC);
	if (fd < 0) {
		fprintf(stderr, "open %s: ", portname);
		perror("");
		return 1;
	}

	if (fname_ws)
		f_ws = open_prep_read(fname_ws, &size_ws);

	setup(fd);

	cmd = CMD_RD | PAR_SINGE | PAR_DEV_ID;
	write_serial(fd, &cmd, sizeof(cmd));
	read_serial(fd, id, sizeof(id));
	if (id[0] != id[1] || id[0] == 0) {
		fprintf(stderr, "unexpected id: %02x %02x\n", id[0], id[1]);
		return 1;
	}
	printf("flashkit id: %02x\n", id[0]);

	set_delay(fd, 1);

	if (do_info || size_e || f_w)
		io->write_bus(fd, 0, 0xf0); // flash reset

	if (do_info || size_e)
		read_info(fd);

	if (size_e == -1) {
		printf("performing full erase..."); fflush(stdout);
		flash_seq_erase_full(fd);
		rv = ry_read(fd);
		if (rv != 0xffff) {
			fprintf(stderr, "\nerase error: %04x\n", rv);
			return 1;
		}
		printf(" done.\n");
	}
	else if (size_e) {
		// set_delay(fd, 0); // ?
		a_blk = get_block_addr(address_in, 0);
		end = address_in + size_e;

		printf("erasing %ld bytes:\n", size_e);
		print_progress(0, size_e);
		for (a = address_in; a < end; ) {
			flash_seq_erase(fd, a_blk);
			rv = ry_read(fd);
			if (rv != 0xffff) {
				fprintf(stderr, "\nerase error: %lx %04x\n",
					a_blk, rv);
				return 1;
			}

			a_blk = get_block_addr(a_blk, 1);
			a += a_blk - a;
			print_progress(a - address_in, size_e);
		}
	}
	if (f_w != NULL) {
		uint8_t b[2];
		set_delay(fd, 0);
		printf("flashing %ld bytes:\n", size_w);
		for (a = 0; a < size_w; a += write_step) {
			ssize_t r;

			b[1] = 0xff;
			len = min(size_w - a, write_step);
			r = fread(b, 1, len, f_w);
			if (r != len) {
				perror("\nfread");
				return 1;
			}
			io->flash_seq_write(fd, address_in + a, b);

			if (!(a & 0x3ff))
				print_progress(a, size_w);
		}
		print_progress(a, size_w);
		rv = ry_read(fd);
		if (write_step == 2 && rv != ((b[0] << 8) | b[1]))
			fprintf(stderr, "warning: last bytes: %04x %02x%02x\n",
				rv, b[0], b[1]);
		rewind(f_w);
		set_delay(fd, 1);
	}
	if (f_ws != NULL) {
		printf("writing %ld bytes:\n", size_ws);
		for (a = 0; a < size_ws; a += write_step) {
			uint16_t b = 0xffff;
			ssize_t r;

			len = min(size_ws - a, write_step);
			r = fread(&b, 1, len, f_ws);
			if (r != len) {
				perror("\nfread");
				return 1;
			}
			if (write_step == 2)
				b = htons(b);
			io->write_bus(fd, address_in + a, b);

			if (!(a & 0x3ff))
				print_progress(a, size_ws);
		}
		print_progress(a, size_ws);
	}

	if (fname_r || size_v) {
		long blks, blks_v, done, verify_diff = 0;

		blks = (size_r + sizeof(g_block) - 1) / sizeof(g_block);
		blks_v = (size_v + sizeof(g_block) - 1) / sizeof(g_block);
		blks = max(blks, blks_v);
		if (fname_r) {
			f_r = fopen(fname_r, "wb");
			if (!f_r) {
				fprintf(stderr, "fopen %s: ", fname_r);
				perror("");
				return 1;
			}
		}

		printf("reading %ld bytes:\n", max(size_r, size_v));
		print_progress(0, blks * sizeof(g_block));
		a_blk = -1;
		for (done = 0; done < size_r || done < size_v; ) {
			a = address_in + done;
			if (io->addrs_remapped || (a >> 21) != a_blk) {
				a_blk = a >> 21;
				io->set_addr(fd, a);
			}
			io->read_block(fd, g_block, sizeof(g_block));
			if (f_r && done < size_r) {
				len = min(size_r - done, sizeof(g_block));
				if (fwrite(g_block, 1, len, f_r) != len) {
					perror("fwrite");
					return 1;
				}
			}
			if (done < size_v) {
				len = min(size_v - done, sizeof(g_block));
				if (fread(g_block2, 1, len, f_w) != len) {
					perror("fread");
					return 1;
				}
				verify_diff |= memcmp(g_block, g_block2, len);
			}
			done += sizeof(g_block);
			print_progress(done, blks * sizeof(g_block));
		}
		if (verify_diff) {
			fprintf(stderr, "verify FAILED\n");
			return 1;
		}
	}
	if (f_r)
		fclose(f_r);
	if (f_w)
		fclose(f_w);

	return 0;
}