f32xbase/f32x/f32x.c

/*
 * f32x/f32x.c - Simple C8051F326/7 Flash programmer
 *
 * Written 2008, 2009 by Werner Almesberger
 * Copyright 2008, 2009 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 <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 [-p] file\n"
"       %s -d\n"
"       %s -e\n"
"       %s -b pin_setup\n"
"       %s\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"
"  -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)
{
    c2_init();
    identify();

    switch (argc) {
    case 1:
	/* just reset */
	break;
    case 2:
	if (!strcmp(argv[1], "-d"))
	    dump_flash(0x4000);
	else if (!strcmp(argv[1], "-e"))
	    erase_flash();
	else if (*argv[1] == '-')
	    usage(*argv);
	else {
	    do_flash(argv[1]);
	    identify();
	}
	break;
    case 3:
	if (!strcmp(argv[1], "-p")) {
	    if (*argv[2] == '-')
		usage(*argv);
	    do_flash(argv[2]);
	    protect();
	    identify();
	    break;
	}
	if (strcmp(argv[1], "-b"))
	    usage(*argv);
	boundary(argv[2]);
	break;
    default:
	usage(*argv);
    }
    c2_reset();

    return 0;
}