wince2aif.c

WinCE 3.0 BSP, 包含Inter SA1110, Intel_815E, Advantech_PCM9574 等

#include <string.h>
#include "aif.h"

/*
 * one of these needs to be defined
 */
#if 1
# define LITTLEEND
#else
# define BIGEND
#endif /* 0/1 */

int brutus = 0;

#define BRUTUS_VIRT_BASE	0x80000000
#define BRUTUS_PHYS_BASE_1	0xd0000000
#define BRUTUS_PHYS_BASE_2	0xd8000000
#define BRUTUS_BANK_SIZE	0x00400000

#define TO_BRUTUS(x) to_brutus(x)

unsigned32 to_brutus(unsigned32 x)
{
    if (!brutus) return x;
    x -= BRUTUS_VIRT_BASE;
    x += (x < BRUTUS_BANK_SIZE) ? BRUTUS_PHYS_BASE_1 : (BRUTUS_PHYS_BASE_2-BRUTUS_BANK_SIZE);
    return x;
}

#ifdef LITTLEEND
/*
 * Read a word from the NK.BIN file
 * This is always little endian???
 */
unsigned readword(FILE *f, char *name)
{
    unsigned w;
    int c;
    int i;

    w = 0;
    for (i = 0; i < 4; i++) {
	c = fgetc(f);
	if (c == -1) {
	    fprintf(stderr, "Error reading %s, unexpected EOF\n", name);
	    exit(1);
	}
	w = (w >> 8) | (c << 24);
    }
    return w;
}

void writeword(FILE *f, char *name, unsigned w)
{
    int i;

    for (i = 0; i < 4; i++) {
	if (fputc(w & 0xff, f) == -1) {
	    fprintf(stderr, "Error writing %s\n", name);
	    exit(1);
	}
	w >>= 8;
    }
}
#endif /* def LITTLEEND */

#ifdef BIGEND
/*
 * Versions of {read,write}word()
 * for big-endian hosts
 */
unsigned readword(FILE *f, char *name)
{
    unsigned w;
    int c;
    int i;

    w = 0;
    for (i = 0; i < 4; i++) {
	c = fgetc(f);
	if (c == -1) {
	    fprintf(stderr, "Error reading %s, unexpected EOF\n", name);
	    exit(1);
	}
	w = (w >> 8) | (c << 24);
    }
    return w;
}

void writeword(FILE *f, char *name, unsigned w)
{
    int i;

    for (i = 0; i < 4; i++) {
	if (fputc((w >> 24) & 0xff, f) == -1) {
	    fprintf(stderr, "Error writing %s\n", name);
	    exit(1);
	}
	w <<= 8;
    }
}
#endif /* def BIGEND */

void write_header(FILE *f, char *name, aif_hdr *h)
{
    unsigned *w = (unsigned *)h;
    int i;

    for (i = 0; i < sizeof(aif_hdr)/sizeof(unsigned); i++)
	writeword(f, name, w[i]);
}

void write_fragment_header(FILE *f, char *name, fragment_header *h)
{
    int rc;

    writeword(f, name, h->next_fragment_offset);
    writeword(f, name, h->load_address);
    writeword(f, name, h->size);
    rc = fwrite(h->name, 1, 32, f);
    if (rc < 32) {
	fprintf(stderr, "Error writing %s\n", name);
	exit(1);
    }
}

void usage(void)
{
    fprintf(stderr, "Usage: wince2aif <NK.BIN> <NK.AIF>\n");
    exit(1);
}

int main(int argc, char **argv)
{
    FILE *inf, *outf;
    char *infile, *outfile;
    fragment_header *fragment_list = 0;
    fragment_header **pfl = &fragment_list;
    fragment_header *fl, *nfl, *root;
    aif_hdr h;
    int i;
    int rc;
    char magic[8];
    unsigned img_addr, img_len, rec_addr, rec_len, cksum, pc;
    unsigned offset;
    char *s;

    infile = outfile = 0;
    while (s = *(++argv)) {
	if (*s == '-') {
	    if (tolower(s[1] == 'b')) {
		brutus = 1;
	    } else
		usage();
	} else {
	    if (infile) usage();
	    infile = outfile;
	    outfile = s;
	}
    }
    if (!infile) usage();

    inf = fopen(infile, "rb");
    if (!inf) {
	fprintf(stderr, "Error opening %s for input\n", infile);
	exit(1);
    }
    outf = fopen(outfile, "wb");
    if (!outf) {
	fprintf(stderr, "Error opening %s for output\n", outfile);
	exit(1);
    }
    rc = fread(magic, 1, 7, inf);
    if (rc != 7) {
	fprintf(stderr, "Error reading %s, is it an NK.BIN file?\n", infile);
	exit(1);
    }
    if (strncmp(magic, "B000FF", 6) != 0) {
	fprintf(stderr, "Bad magic number in %s, is it an NK.BIN file?\n", infile);
	exit(1);
    }
    img_addr = readword(inf, infile);
    img_len = readword(inf, infile);
    printf("HEADER: address = 0x%08x, length = 0x%08x\n", img_addr, img_len);
    while (1) {
	rec_addr = readword(inf, infile);
	rec_len = readword(inf, infile);
	cksum = readword(inf, infile);
	if (rec_addr == 0 && cksum == 0) {
	    pc = TO_BRUTUS(rec_len);
	    break;
	} else {
	    signed32 load_address, size;

	    load_address = TO_BRUTUS((unsigned32)rec_addr);
	    size = (unsigned32)rec_len;
	    printf("section @ 0x%08x, length %d -> 0x%08x\n", rec_addr, rec_len, load_address);
	    /* Does this section cross a physical memory bank on Brutus */
	    if (brutus && load_address < (BRUTUS_PHYS_BASE_1 + BRUTUS_BANK_SIZE)
		&& (load_address+size) > (BRUTUS_PHYS_BASE_1 + BRUTUS_BANK_SIZE)) {
		printf("  (splitting section across physical memory banks)\n");
		size = (BRUTUS_PHYS_BASE_1 + BRUTUS_BANK_SIZE) - load_address;
		fl = malloc(sizeof(fragment_header) + size);
		if (!fl) {
		    fprintf(stderr, "Error allocating memory for fragment (%d bytes)\n", sizeof(fragment_header) + size);
		    exit(1);
		}
		memset(fl->name, 0, 32);
		fl->next_fragment_offset = 0;
		fl->load_address = load_address;
		fl->size = size;
		sprintf(fl->name, "SECTION_%08X__LEN_%08X", load_address, size);
		rc = fread(fl+1, 1, size, inf);
		if (rc < size) {
		    fprintf(stderr, "Error reading %s\n", infile);
		    exit(1);
		}
		*pfl = fl;
		pfl = (fragment_header **)&fl->next_fragment_offset;
		load_address = BRUTUS_PHYS_BASE_2;
		size = (unsigned32)rec_len - size;
	    }
	    fl = malloc(sizeof(fragment_header) + size);
	    if (!fl) {
		fprintf(stderr, "Error allocating memory for fragment (%d bytes)\n", sizeof(fragment_header) + size);
		exit(1);
	    }
	    memset(fl->name, 0, 32);
	    fl->next_fragment_offset = 0;
	    fl->load_address = load_address;
	    fl->size = size;
	    sprintf(fl->name, "SECTION_%08X__LEN_%08X", load_address, size);
	    rc = fread(fl+1, 1, size, inf);
	    if (rc < size) {
		fprintf(stderr, "Error reading %s\n", infile);
		exit(1);
	    }
	    *pfl = fl;
	    pfl = (fragment_header **)&fl->next_fragment_offset;
	}
    }
    pfl = &fragment_list;
    root = 0;
    while (fl = *pfl) {
	if (pc >= fl->load_address && pc < fl->load_address + fl->size) {
	    root = fl;
	    *pfl = (fragment_header *)fl->next_fragment_offset;
	    break;
	}
	pfl = (fragment_header **)&fl->next_fragment_offset;
    }
    if (!root) {
	fprintf(stderr, "Entrypoint 0x%08x is not within any of the sections\n", pc);
	exit(1);
    }
    h.compress_br = AIF_NOOP;
    h.reloc_br = AIF_NOOP;
    h.zinit_br = AIF_NOOP;
    h.entry_br = pc - root->load_address;
    h.exit_swi = OS_EXIT;
    h.rosize = root->size;
    h.rwsize = 0;
    h.dbgsize = 0;
    h.zinitsize = 0;
    h.dbgtype = 0;
    h.imagebase = root->load_address;
    h.workspace = 0;
    h.address_mode = 32;
    h.data_base = 0;
    h.fragment_offset = (fragment_list == 0) ? 0 : sizeof(aif_hdr) + root->size;
    h.spare2 = 0;
    h.debug_swi = AIF_NOOP;
    for (i = 0; i < 15; i++)
	h.zinitcode[i] = 0;
    write_header(outf, outfile, &h);
    rc = fwrite(root+1, 1, root->size, outf);
    if (rc < root->size) {
	fprintf(stderr, "Error writing %s\n", outfile);
	exit(1);
    }
    fl = fragment_list;
    offset = h.fragment_offset;
    while (fl) {
	nfl = (fragment_header *)fl->next_fragment_offset;
	offset += sizeof(fragment_header) + fl->size;
	fl->next_fragment_offset = (nfl == 0) ? 0 : offset;
	write_fragment_header(outf, outfile, fl);
	rc = fwrite(fl+1, 1, fl->size, outf);
	if (rc < fl->size) {
	    fprintf(stderr, "Error writing %s\n", outfile);
	    exit(1);
	}
	fl = nfl;
    }
    fclose(inf);
    fclose(outf);
}