romload.c

ESS3890+SL原代码（1*16内存）

/* Copyright 2002-2003, ESS Technology, Inc.				*/
/* SCCSID @(#)romload.c	4.5.1.2 02/23/05 */

/* 
 * romload.c - 
 *	1) This tool creates a rom loader batch file with the
 *	   correct bases for the extra segments' data.
 *	2) corrects Stack size info in "stat" file.
 *	3) "dumps" extra segments if DUMPX is "1".
 *	4) checks: stack usage, code usage in dram, 
 *	   extra segments' code & data dram usage.
 */

#undef MP3_LOGO_IN_SHARE

#include <stdio.h>  
#include <stdlib.h>     
#include "common.h"
#include "memmap.h"
#include "display.h"
#include "fractint.h"
#ifdef JPEG_DEC
#include "./jpglib/jpg_dram.h"
#endif


#define DEBUG 0
#define DUMPX 0	/* "dumps" extra segments */

/* Local defines */
#define	BYTE		unsigned char  	/* 8 bits */
#define	WORD		unsigned int  	/* 16 bits */
#define	DWORD		unsigned long  	/* 32 bits */
#define	LINE_LENGTH	80

#ifdef VCDLC
#define STACK_WARN	900		/* warn at this level */
#else
#define STACK_WARN	1500		/* warn at this level */
#endif

#ifdef BIG_MEM
#define DRAM_END	0x200000	/* Bytes */
#else
#define DRAM_END	0x80000		/* Bytes */
#endif


#define RDSA_SEGMENT	0
#define DEMUX_SEGMENT	1
typedef struct {
    char name[13];
    int text_size;
    int bss_size;
    int bss_addr;    
} SEGMENT_INFO;
SEGMENT_INFO main_segments[2];


#define XTRA_SEG1	0x1
#define XTRA_SEG2	0x2
#define XTRA_SEG3	0x4
#define XTRA_SEG4	0x8
#define XTRA_SEG_TOTAL	4
char *xtra_segments[XTRA_SEG_TOTAL] = {
    "xtra_s1.rom",
    "xtra_s2.rom",
    "xtra_s3.rom",
    "xtra_s4.rom"
};
int xdata_limits[XTRA_SEG_TOTAL] = { 
    /* size in bytes */
    4*JPEG_globals_size,
    4*GMBY_globals_size,
    4*WMA_globals_size,
    4*MP3_globals_size
};
int xtext_limits[XTRA_SEG_TOTAL] = {
    /* size in bytes */
    4*JPEG_code_size,
    4*GMBY_CODE_size,
    4*WMA_CODE_size,
    4*MP3_CODE_size
};
unsigned int cur_xsegments;

/* Local prototypes */
void get_segment_info(FILE *, int);
void check_xtra_segments(FILE *);
void dump_xtra_segments(void);
char *get_next_line (FILE *);
void mk_rombat(char *);
void fix_stat_file(void);


/* Program begin */
main (int argc, char *argv [])
{ 
    char outfile[13];


    /* optional user specified output filename */
    if (argc > 1) {
	strcpy(outfile, argv[1]);
    } else {
	strcpy(outfile, "rom.bat");
    }    
    
    mk_rombat(outfile);
    fix_stat_file();
    
#if DUMPX
    dump_xtra_segments();
#endif /* DUMPX */

    exit(0);
}     

void mk_rombat(char *out)
{
    FILE  *fp;     


    /* make the rom loader batch file */
    fp = fopen(out, "w");
    if (fp == NULL) {
	fprintf(stderr, "Can't open file: %s\n", out);
	exit(1);
    }

    fprintf(fp, "vcs -b demux.rom ");
#ifdef VCDLC
    fprintf(fp, "-b rdsa.rom ");
#endif
#ifdef XSEG1_ON_FLY
    fprintf(fp, "-s %x -b xtra_s1.rom ", JPEG_globals_start<<2);
#endif /* XSEG1_ON_FLY */
#ifdef XSEG2_ON_FLY
    fprintf(fp, "-s %x -b xtra_s2.rom ", GMBY_globals_start<<2);
#endif /* XSEG2_ON_FLY */
#ifdef XSEG3_ON_FLY
    fprintf(fp, "-s %x -b xtra_s3.rom ", WMA_globals_start<<2);
#endif /* XSEG3_ON_FLY */
#ifdef XSEG4_ON_FLY
    fprintf(fp, "-s %x -b xtra_s4.rom ", MP3_globals_start<<2);
#endif /* XSEG4_ON_FLY */
    fprintf(fp, "bank30.rom\r\n");

    fclose(fp);
}


/* CAUTION: for "stat" file format as of 7/17/02 */
void fix_stat_file(void)
{
    FILE  *fp;     
    char  *line_ptr, str2match[16], filename[10];
    char dummy1[10], dummy2[10], dummy3[10]; 
    char  tmp_addr_str[15]; char tmp_size_str[15]; 
    char  str_temp[180];
    char in[] = "stat";
    int i, bss_addr, bss_size, found_demux=0, stack_size;
    int str_len, mm;
    int text_size, code_end=0;
    
    /* check "stat" file */
    fp = fopen(in, "r");
    if (fp == NULL)
    {
	fprintf(stderr, "Can't open file: %s\n", in);
	exit(2);
    }    

#ifdef VCDLC
    strcpy (main_segments[RDSA_SEGMENT].name, "rdsa.rom");
    get_segment_info(fp, RDSA_SEGMENT);
#else
    /* initialize */
    main_segments[RDSA_SEGMENT].bss_addr = 0;
    main_segments[RDSA_SEGMENT].bss_size = 0;
#endif /* VCDLC */

    strcpy (main_segments[DEMUX_SEGMENT].name, "demux.rom");
    get_segment_info(fp, DEMUX_SEGMENT);

    check_xtra_segments(fp);

    fclose(fp);
    
    /* calculate stack size */
    for (i=0; i<2; i++){
	/* demux/rdsa data end */
	main_segments[i].bss_addr += main_segments[i].bss_size;
    }
    bss_addr = max2(main_segments[RDSA_SEGMENT].bss_addr, 
		    main_segments[DEMUX_SEGMENT].bss_addr);
    stack_size = VCD20STACK - bss_addr;
    

    /* calculate code usage in dram */
#ifdef VCDLC
#ifdef DEMUX_ON_FLY
    code_end = (4*DEMUX_ROM_start) + 
	main_segments[DEMUX_SEGMENT].text_size; /* Byte addr */
#endif
#else
    code_end = (4*CODE_start) + 
	main_segments[DEMUX_SEGMENT].text_size; /* Byte addr */
#endif /* VCDLC */
    

    fp = fopen(in, "r+");
    if (fp == NULL){
	fprintf(stderr, "Can't open file: %s\n", in);
	exit(4);
    }
    fseek(fp, 0, SEEK_SET);
    strcpy (str2match, "Stack size"); 
    /*We cannot use fgets() to get the location because it 
      get the wrong location for PC and UNIX */
    fread(str_temp, 1, 180, fp);
    line_ptr = str_temp;
    /* Find stack info location */
    for(i=0; i<180; i++)
        if(!strncmp(&line_ptr[i], str2match, 10) ) break;
    
    if (i == 180) i = 0; 
    str_len = 0;
    if (i) { 
	for( mm = i; mm< 180; mm++) {
	    if(!strncmp(&line_ptr[mm], "bytes .", 7) ){
		str_len = mm - i + 6;
		if(str_len >= 80) str_len = 79;
		break;
	    }
	}
    }
    
#if DEBUG
    printf("Stack line: %s\n", line_ptr);
#endif
    /* change the Stack size  in STAT file */
    {
        char w_p[80];  int len;
	
        if(i) fseek(fp, i, SEEK_SET);
        else fseek(fp, 0, SEEK_END);
	
        for(mm = 0; mm<80; mm++) w_p[mm] = ' ';
        sprintf(w_p, "Stack size: 0x%x(%d) bytes .\n",
                stack_size, stack_size);
        len = strlen(w_p);
        if(len < str_len){
	    w_p[len -1] = ' '; w_p[len] = ' ';
	    w_p[str_len - 1] = '\n'; w_p[str_len] = 0;
        }
	
        fprintf(fp, "%s", "\n");
        fprintf(fp, "%s", w_p);
	
        fseek(fp, 0, SEEK_END);
        fprintf(fp, "%s", "\n");
        fprintf(fp, "Correct Stack Size: 0x%x(%d) bytes . \n",
                stack_size, stack_size);
	

	/* output stack info */
	if (stack_size < STACK_WARN) {
	    printf("*************************************************\n");
	    printf("* Warning: Stack is getting low..check usage!!  *\n");
	    printf("*************************************************\n");
	}
        printf("Stack size(Bytes): %d\n", stack_size);
#if DEBUG
        printf("%s\n", w_p);
#endif
    }
    
    /* output code usage info */
#ifdef VCDLC
#ifdef DEMUX_ON_FLY
    if (code_end > (DEMUX_ROM_end<<2)) {
	printf("*********************************************\n");
	printf("* ERROR: DEMUX_ROM SPACE HAS BEEN EXCEEDED!!*\n");
	printf("*********************************************\n");
	printf("Code space remaining(Bytes): %d\n", (DEMUX_ROM_end<<2)-code_end);
    }
#endif /* DEMUX_ON_FLY */
#else
    if (code_end > DRAM_END) {
	printf("******************************************\n");
	printf("* ERROR: CODE SPACE HAS BEEN EXCEEDED!!  *\n");
	printf("******************************************\n");
    }
    printf("Code space remaining(Bytes): %d\n", DRAM_END-code_end);
#endif /* VCDLC */

    fclose(fp);
}

void get_segment_info(FILE *fp, int segment)
{
    char  *line_ptr, str2match[16];
    char dummy1[10], dummy2[10], dummy3[10]; 
    char  tmp_addr_str[15]; char tmp_size_str[15]; 
    int str_len;
    SEGMENT_INFO *seginfo_ptr;
    
    
    fseek(fp, 0, SEEK_SET);
    seginfo_ptr = &main_segments[segment];
    
    strcpy (str2match, seginfo_ptr->name);
    do {	/* Find segment section */                               
	line_ptr = get_next_line (fp);
	if (line_ptr == NULL) {
	    fprintf(stderr,"%s section not found.\n", str2match);
	    exit(3);
	}
    } while (!strstr (line_ptr, str2match));	 

#if DEBUG
    printf("%s line: %s\n", str2match, line_ptr);
#endif
    
    /* The following should be segment info (next 4 lines) */
    strcpy (str2match, "text"); /* segment's text */
    do {	/* Find "text" line */                               
	line_ptr = get_next_line (fp);
	if (line_ptr == NULL) {
	    fprintf(stderr,"%s section not found.\n", str2match);
	    exit(3);
	}
    } while (!strstr (line_ptr, str2match));
#if DEBUG
    printf("text line: %s\n", line_ptr);
#endif

    /* get segment's text size..for dram's code space usage */
    sscanf(line_ptr, "%s%s%s%s%s%s%s%s%s%s%s", 
           dummy1, dummy2, tmp_addr_str, dummy3, tmp_size_str, 
	   dummy2, dummy2, dummy2, dummy2, dummy2, dummy2);
	sscanf( &tmp_size_str[2], "%x", &seginfo_ptr->text_size);

#if DEBUG
    printf("str1: %s\n", dummy1);
    printf("str3: %s\n", dummy3);
    printf("text_addr_str: %s\n", tmp_addr_str);
    printf("text_size_str: %s\n", tmp_size_str);
    printf("text size: 0x%x\n", seginfo_ptr->text_size);
#endif

    strcpy (str2match, "bss"); /* segment's bss */
    do {	/* Find  segment info section */
	line_ptr = get_next_line (fp);
	if (line_ptr == NULL) {
	    fprintf(stderr,"%s section not found.\n", str2match);
	    exit(3);
	}
    } while (!strstr (line_ptr, str2match));
#if DEBUG
    printf("bss line: %s\n", line_ptr);
#endif

    /* get segment's bss info..for stack info */
    sscanf(line_ptr, "%s%s%s%s%s", 
           dummy1, dummy2, tmp_addr_str, dummy3, tmp_size_str);
	sscanf( &tmp_addr_str[2], "%x", &seginfo_ptr->bss_addr);
	sscanf( &tmp_size_str[2], "%x", &seginfo_ptr->bss_size);

#if DEBUG
    printf("str1: %s\n", dummy1);
    printf("str2: %s\n", dummy2);
    printf("str3: %s\n", dummy3);
    printf("bss_addr_str: %s\n", tmp_addr_str);
    printf("bss_size_str: %s\n", tmp_size_str);
    printf("bss addr: 0x%x\n", seginfo_ptr->bss_addr);
    printf("bss size: 0x%x\n", seginfo_ptr->bss_size);
#endif
}

void check_xtra_segments(FILE *fp)
{     
    char  *line_ptr, str2match[16];
    char dummy1[10], dummy2[10], dummy3[10]; 
    char  tmp_addr_str[15], tmp_size_str[15]; 
    int i, bss_size, str_len, data_size, text_size;


    cur_xsegments = 0;
#ifdef XSEG1_ON_FLY    
    cur_xsegments |= XTRA_SEG1;
#endif
#ifdef XSEG2_ON_FLY
    cur_xsegments |= XTRA_SEG2;
#endif
#ifdef XSEG3_ON_FLY
    cur_xsegments |= XTRA_SEG3;
#endif
#ifdef XSEG4_ON_FLY
    cur_xsegments |= XTRA_SEG4;
#endif
    
    if (!cur_xsegments) return;
    
    for (i=0; i<XTRA_SEG_TOTAL; i++) {
	if (cur_xsegments & 0x1) {
	    fseek(fp, 0, SEEK_SET);
	    strcpy (str2match, xtra_segments[i]);
	    do {	/* Find "xtra_s#.rom" line */
		line_ptr = get_next_line (fp);
		if (line_ptr == NULL) {
		    fprintf(stderr,"%s section not found.\n", str2match);
		    exit(4);
		}
	    } while (!strstr (line_ptr, str2match));
#if DEBUG
	    printf("xtra_s%d line: %s\n", i+1, line_ptr);
#endif

	    strcpy (str2match, "text"); /* xtra_s# text */
	    do {	/* Find "text" line */
		line_ptr = get_next_line (fp);
		if (line_ptr == NULL) {
		    fprintf(stderr,"%s section not found.\n", str2match);
		    exit(4);
		}
	    } while (!strstr (line_ptr, str2match));
#if DEBUG
	    printf("text%d line: %s\n", i+1, line_ptr);
#endif

	    sscanf(line_ptr, "%s%s%s%s%s%s%s%s%s%s%s", 
		   dummy1, dummy2, tmp_addr_str, dummy3, tmp_size_str, 
		   dummy2, dummy2, dummy2, dummy2, dummy2, dummy2);
	    sscanf( &tmp_size_str[2], "%x", &text_size);

#if DEBUG
	    printf("str1: %s\n", dummy1);
	    printf("str3: %s\n", dummy3);
	    printf("text_addr_str: %s\n", tmp_addr_str);
	    printf("text_size_str: %s\n", tmp_size_str);
	    printf("text size: 0x%x\n", text_size);
#endif

	    strcpy (str2match, "data"); /* xtra_s# data */
	    do {	/* Find "data" line */
		line_ptr = get_next_line (fp);
		if (line_ptr == NULL) {
		    fprintf(stderr,"%s section not found.\n", str2match);
		    exit(4);
		}
	    } while (!strstr (line_ptr, str2match));
#if DEBUG
	    printf("data%d line: %s\n", i+1, line_ptr);
#endif

	    /* get xtra_s# data info.. */
	    sscanf(line_ptr, "%s%s%s%s%s%s%s%s%s%s%s", 
		   dummy1, dummy2, tmp_addr_str, dummy3, tmp_size_str, 
		   dummy2, dummy2, dummy2, dummy2, dummy2, dummy2);
	    sscanf( &tmp_size_str[2], "%x", &data_size);
#if DEBUG
	    printf("str1: %s\n", dummy1);
	    printf("str3: %s\n", dummy3);
	    printf("data_addr_str: %s\n", tmp_addr_str);
	    printf("data_size_str: %s\n", tmp_size_str);
	    printf("data%d size: 0x%x\n", i+1, data_size);
#endif

	    strcpy (str2match, "bss"); /* xtra_s# bss */
	    do {	/* Find "bss" line */
		line_ptr = get_next_line (fp);
		if (line_ptr == NULL) {
		    fprintf(stderr,"%s section not found.\n", str2match);
		    exit(4);
		}
	    } while (!strstr (line_ptr, str2match));
#if DEBUG
	    printf("bss line: %s\n", line_ptr);
#endif

	    /* get xtra_s# bss info.. */
	    sscanf(line_ptr, "%s%s%s%s%s", 
		   dummy1, dummy2, dummy2, dummy3, tmp_size_str);
	    sscanf( &tmp_size_str[2], "%x", &bss_size);
	    data_size += bss_size;
#if DEBUG
	    printf("str1: %s\n", dummy1);
	    printf("str3: %s\n", dummy3);
	    printf("bss_size_str: %s\n", tmp_size_str);
	    printf("bss size: 0x%x\n", bss_size);
	    printf("xdata%d size: 0x%x\n", i+1, data_size);
#endif

	    /* ALERT if usage exceeds alloted space */
	    if (text_size > xtext_limits[i]) {
		printf("*************************************************\n");
		printf("* FATAL: xtra_s%d text size(%dDW)\n*\texceeds limit(%dDW)\n",
		       i+1, text_size/4, xtext_limits[i]/4);
		printf("*************************************************\n");
	    }
	    if (data_size > xdata_limits[i]) {
		printf("*************************************************\n");
		printf("* FATAL: xtra_s%d data size(%dDW)\n*\texceeds limit(%dDW)\n",
		       i+1, data_size/4, xdata_limits[i]/4);
		printf("*************************************************\n");
	    }
	}
	cur_xsegments >>= 1;
    }
}

void dump_xtra_segments(void)
{
    char dumpxbuf[LINE_LENGTH]; 


#ifdef XSEG1_ON_FLY
    sprintf(dumpxbuf, "dump3 -f -l -%x xtra_s1.rom > xtra_s1.dmp\n", 
	    ((JPEG_code_start<<2)+0x40000)&0xfffff);
    printf("%s\n", dumpxbuf);
#if !DEBUG
    system(dumpxbuf);
#endif
#endif /* XSEG1_ON_FLY */

#ifdef XSEG2_ON_FLY
    sprintf(dumpxbuf, "dump3 -f -l -%x xtra_s2.rom > xtra_s2.dmp\n", 
	    ((GMBY_CODE_start<<2)+0x40000)&0xfffff);
    printf("%s\n", dumpxbuf);
#if !DEBUG
    system(dumpxbuf);
#endif
#endif /* XSEG2_ON_FLY */

#ifdef XSEG3_ON_FLY
    sprintf(dumpxbuf, "dump3 -f -l -%x xtra_s3.rom > xtra_s3.dmp\n", 
	    ((WMA_CODE_start<<2)+0x40000)&0xfffff);
    printf("%s\n", dumpxbuf);
#if !DEBUG
    system(dumpxbuf);
#endif
#endif /* XSEG3_ON_FLY */

#ifdef XSEG4_ON_FLY
    sprintf(dumpxbuf, "dump3 -f -l -%x xtra_s4.rom > xtra_s4.dmp\n", 
	    ((MP3_CODE_start<<2)+0x40000)&0xfffff);
    printf("%s\n", dumpxbuf);
#if !DEBUG
    system(dumpxbuf);
#endif
#endif /* XSEG4_ON_FLY */
}

char *get_next_line (FILE *fp)
{  
    static char  line[LINE_LENGTH+1];
    char  *data;

    line[LINE_LENGTH] = 0;
   
	while (fgets (line, LINE_LENGTH, fp) != NULL)
	{
	   for (data = line; *data == ' ' || *data == '\n' ||
	        *data == '\t'; data++);

	   if (*data == '#' || strlen (data) == 0)
	       continue;
	   return (data);
    } ;
                
    return (NULL);
}