f32xbase/f32x/f32x.c

/*
 * f32x/f32x.c - Simple C8051F326/7 Flash programmer
 *
 * Written 2008-2010 by Werner Almesberger
 * Copyright 2008-2010 Werner Almesberger
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 */


#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>

#include "c2.h"
#include "flash.h"
#include "boundary.h"


#define	LOCK_BYTE	0x3dff


static size_t file_size;


static void dump(const char *title, void *data, size_t size)
{
	int i, j;

	fprintf(stderr, "%s:\n", title);
	for (i = 0; i < size; i += 16) {
		fprintf(stderr, "  %04x", i);
		for (j = 0; j != 16 && i+j < size; j++)
			fprintf(stderr, " %02x", ((uint8_t *) data)[i+j]);
		fprintf(stderr, "\n");
	}
}


static void flash_device(void *data, size_t size)
{
	int i;
	size_t len;
	uint8_t buf[256];

	for (i = 0; i < size; i += 256)
		fputc('-', stderr);
	fputc('\r', stderr);

	flash_init();
	flash_device_erase();

	for (i = 0; i < size; i += 256) {
		fputc('*', stderr);
		fflush(stderr);
		len = size-i <= 256 ? size-i : 256;
		flash_block_write(i, data+i, len);
	}
	fputc('\r', stderr);

	for (i = 0; i < size; i += 256) {
		fputc('#', stderr);
		fflush(stderr);
		len = size-i <= 256 ? size-i : 256;
		flash_block_read(i, buf, len);
		if (memcmp(buf, data+i, len)) {
			fprintf(stderr, "compare error at 0x%04x\n", i);
			dump("Expected", data+i, len);
			dump("Read", buf, len);
			exit(1);
		}
	}
	fputc('\n', stderr);
}


static void erase_flash(void)
{
	flash_init();
	flash_device_erase();
}


static void dump_flash(size_t size)
{
	int i, j;
	size_t len;
	uint8_t buf[256], last[256];
	int skipping = 0;

	flash_init();
	for (i = 0; i < size; i += 16) {
		len = size-i <= 16 ? size-i : 16;
		flash_block_read(i, buf, len);
		if (i && !memcmp(last, buf, len)) {
			printf("%04x: *%c", i, skipping ? '\r' : '\n');
			fflush(stdout);
			skipping = 1;
			continue;
		}
		skipping = 0;
		memcpy(last, buf, len);
		printf("%04x:", i);
		for (j = 0; j != len; j++)
			printf(" %02x", buf[j]);
		printf("  ");
		for (j = 0; j != len; j++)
			printf("%c",
			    buf[j] >= ' ' && buf[j] <= '~' ? buf[j] : '.');
		putchar('\n');
		fflush(stdout);
	}
}


static void identify(void)
{
	int i;

	c2_addr_write(0);
	printf("Dev");
	for (i = 0; i != 10; i++)
		printf(" 0x%02x", c2_data_read(1));
	c2_addr_write(1);
	printf("\nRev");
	for (i = 0; i != 10; i++)
		printf(" 0x%02x", c2_data_read(1));
	printf("\n");
}


static void do_flash(const char *name)
{
	FILE *file;
	uint8_t code[16384];

	file = fopen(name, "r");
	if (!file) {
		perror(name);
		exit(1);
	}
	file_size = fread(code, 1, sizeof(code), file);
	(void) fclose(file);
	flash_device(code, file_size);
}


static void protect(void)
{
	uint8_t pages, lock_byte;

	pages = (file_size+511) >> 9;
	printf("Protecting %d page%s\n", pages, pages == 1 ? "" : "s");
	lock_byte = ~pages;
	flash_block_write(LOCK_BYTE, &lock_byte, 1);
}


static void usage(const char *name)
{
	fprintf(stderr,
"usage: %s [-n] [-p] file\n"
"       %s [-n] -d\n"
"       %s [-n] -e\n"
"       %s [-n] -b pin_setup\n"
"       %s [-n]\n\n"
"  -b pin_setup\n"
"    Perform a boundary scan. pin_setup sets all 14 pins in this order:\n"
"    P0_0, P0_1, ..., P0_7, P2_0, ..., P2_5.\n"
"    Pins can be set to 0, 1, or R (pull-up). Dots can be used to structure\n"
"    the bit string. Prints what the pins read back (0 or 1) in the same\n"
"    order, with a dot between P0 and P2.\n"
"  -d  dump Flash content\n"
"  -e  erase whole Flash\n"
"  -n  do not provide power to the target (default: do provide power)\n"
"  -p  protect the data after writing\n"
"Invocation without argument resets the F32x.\n"
  , name, name, name, name, name);
	exit(1);
}


int main(int argc, char **argv)
{
	enum {
		mode_default = 0,
		mode_flash,
		mode_dump,
		mode_erase,
		mode_scan,
	} mode = mode_default;
	int do_protect = 0, power = 1;
	int c;

	while ((c = getopt(argc, argv, "bdenp")) != EOF)
		switch (c) {
		case 'd':
			if (mode)
				usage(*argv);
			mode = mode_dump;
			break;
		case 'e':
			if (mode)
				usage(*argv);
			mode = mode_erase;;
			break;
		case 'b':
			if (mode)
				usage(*argv);
			mode = mode_scan;;
			break;
		case 'n':
			power = 0;
			break;
		case 'p':
			do_protect = 1;
			break;
		default:
			usage(*argv);
		}

	switch (mode) {
	case mode_default:
		switch (argc-optind) {
		case 0:
			break;
		case 1:
			mode = mode_flash;
			break;
		default:
			usage(*argv);
		}
		break;
	case mode_scan:
		if (argc != optind+1)
			usage(*argv);
		break;
	default:
		if (argc != optind)
			usage(*argv);
		break;
	}

	c2_init(power);
	identify();

	switch (mode) {
	case mode_default:
		/* just reset */
		break;
	case mode_dump:
		dump_flash(0x4000);
		break;
	case mode_erase:
		erase_flash();
		break;
	case mode_flash:
		do_flash(argv[optind]);
		if (do_protect)
			protect();
		identify();
		break;
	case mode_scan:
		boundary(argv[optind]);
		break;
	default:
		abort();
	}

	c2_reset();

	return 0;
}