URL https://opencores.org/ocsvn/System09/System09/trunk

Subversion Repositories System09

[/] [System09/] [trunk/] [Tools/] [s19tovhd/] [S19toVHD.cpp] - Blame information for rev 110

Go to most recent revision | Details | Compare with Previous | View Log


// S19toVHD.cpp : Defines the entry point for the console application.
//
 
/*
* epedit
*
* binary file editer program
*/
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <math.h>
 
/*
* equates
*/
#define EPROM_MAX (1<<16)
#define CMD_LINE_MAX 80
#define FALSE 0
#define TRUE !FALSE
#define BINARY 0
#define MOTOROLA 1
#define INTEL 2
#define SMAL32 3
#define VHDL_BIN 4
#define VHDL_BYTE 5
#define VHDL_WORD 6
 
/*
* global variables
*/
FILE *cmdfp;                            /* command input pointer */
char cmdbuff[CMD_LINE_MAX];
unsigned char eprom_buff[EPROM_MAX];    /* eprom buffer */
int eprom_top;                          /* top of EPROM buffer */
int mod_flag;                           /* buffer has been modified */
int auxflag;                            /* Auxillary input file specified */
int count;
int checksum;
int offset;                             /* Eprom Buffer memory offset */
int format_type;                        /* load / save format type */
char *hex_str = "0123456789ABCDEF";
 
 
/*
* compare a string of specified length
* return TRUE if a match
* return FALSE if no match
* ignore case
*/
int str_equal( char *s1, char *s2, int len )
{
        int i = 0;
        while( i<len ) {
                if( toupper( s1[i] ) == toupper( s2[i] ) )
                        i++;
                else
                        return FALSE;
        }
        return TRUE;
}
 
int to_hexadecimal( char c )
{
        for( int k=0; k<16; k++ ) {
                if( toupper(c) == hex_str[k] ) return k;
        }
        return -1;
}
 
/*
* extract an address from the command line
* returns an offset to the end of the argument.
*/
int get_address( char *cb, int *addr )
{
        int i, j, k;
 
        j = i = 0;
 
        while((k = to_hexadecimal(cb[i])) != -1) {
                i++;
                j = j *16 + k;
        }
        *addr = j;
        if( i == 0 ) return i;
        while( isspace( cb[i]) ) i++;
        return i;
}
 
/*
* Motorola S1 format to Intel hex format
* Usage
* mot2hex <file_name>
*/
 
int gethex( FILE *fp_in )
{
        int hex;
 
        hex = fgetc( fp_in );
        return( to_hexadecimal( hex ) );
}
 
int get2hex( FILE *fp_in )
{
        int hexhi, hexlo, byte;
 
        hexhi = gethex( fp_in );
        if( hexhi != -1 )
        {
                hexlo = gethex( fp_in );
                if( hexlo != -1 )
                {
                        byte = hexhi * 16 + hexlo;
                        checksum = (checksum + byte) & 0xff;
                        return byte;
                }
        }
        return -1;
}
 
int get4hex( FILE *fp_in )
{
        int bytehi, bytelo, addr;
 
        bytehi = get2hex( fp_in );
        if( bytehi != -1 )
        {
                bytelo = get2hex( fp_in );
                if( bytelo != -1 )
                {
                        addr = (bytehi * 256) + bytelo;
                        return addr;
                }
        }
        return -1;
}
 
int get6hex( FILE *fp_in )
{
        int bytehi, bytemid, bytelow, addr;
 
        bytehi = get2hex( fp_in );
        if( bytehi != -1 )
        {
                bytemid = get2hex( fp_in );
                if( bytemid != -1 )
                {
                        bytelow = get2hex( fp_in );
                        if( bytelow != -1 )
                        {
                                addr = (bytehi << 16) + (bytemid << 8) + bytelow;
                                return addr;
                        }
                }
        }
        return -1;
}
 
long get8hex( FILE *fp_in )
{
        int wordhi, wordlow;
        long addr;
 
        wordhi = get4hex( fp_in );
        if( wordhi != -1 )
        {
                wordlow = get4hex( fp_in );
                if( wordlow != -1 )
                {
                        addr = ((long)wordhi << 16) + (long)wordlow;
                        return addr;
                }
        }
        return -1;
}
 
/*
* load motorola formatted file
*/
 
bool load_mot( char *fname_in )
{
        FILE *fp_in;
        int byte, addr, i;
 
        fp_in = fopen( fname_in, "r" );
        if ( !fp_in ) {
                printf( "\nCan't open %s", fname_in );
                return false;
        }
 
        byte = 0;
        addr = 0;
 
        while( byte != -1 ) {
                do {
                        byte = fgetc( fp_in);
                } while( (byte != 'S') && (byte != -1) );
 
                byte = fgetc( fp_in );
                checksum = 0;
                if ( (byte == '1') || (byte == '2') ) {
                        count = get2hex( fp_in );
                        if ( byte == '1' ) {
                                addr = get4hex( fp_in );
                                count -= 3;
                        } else {
                                addr = get6hex( fp_in );
                                count -= 4;
                        }
                        for( i=0; i<count; i++ ) {
                                byte = get2hex( fp_in );
                                eprom_buff[( addr - offset) % EPROM_MAX ] = (unsigned char)byte;
                                addr++;
                        }
                        byte = get2hex( fp_in);
                        checksum = (~checksum) & 0xff;
                        if ( checksum != 0 )
                                printf( "\nchecksum error - read check = %02x", byte );
                }
        }
        fclose( fp_in );
        return true;
}
 
int put2hex( FILE *fp, int h )
{
        int hex = (h & 0xf0)>>4;
        int i = fputc( (int)hex_str[hex], fp );
        hex = (h & 0xf);
        i = fputc( (int)hex_str[hex], fp );
        checksum = (checksum + h) & 0xff;
        return i;
}
 
int put4hex( FILE * fp, int h )
{
        int i = put2hex( fp, (h & 0xff00 )>>8 );
        i = put2hex( fp, (h & 0xff) );
        return i;
}
 
char *bin_string( int num, int num_len )
{
        static char retbuf[33];
        char *p;
        int i;
 
        p = &retbuf[sizeof(retbuf)-1];
        *p = '\0';
        for (i=0; i<num_len; i++ ) {
                *--p = "01"[num % 2];
                num >>= 1;
        }
        return p;
}
 
/*
* save VHDL hexadecimal file 4KBit Block RAM (Spartan 2)
*/
 
void save_vhdl_b4( FILE *fp_out, char *entity_name, int start_addr, int end_addr )
{
        int addr;
        int i,j;
        int byte;
        int rom_num, rom_max, rom_len;
        int addr_len;
 
        rom_max = (end_addr+1-start_addr)/512;
        rom_len = 8;
        addr_len = (int)(log((double)(end_addr-start_addr))/log(2.0));
 
        fprintf(fp_out, "library IEEE;\n");
        fprintf(fp_out, "   use IEEE.std_logic_1164.all;\n");
        fprintf(fp_out, "   use IEEE.std_logic_arith.all;\n");
        fprintf(fp_out, "library unisim;\n");
        fprintf(fp_out, "   use unisim.vcomponents.all;\n");
        fprintf(fp_out, "\n");
        fprintf(fp_out, "entity %s is\n", entity_name);
        fprintf(fp_out, "   port(\n");
        fprintf(fp_out, "      clk       : in  std_logic;\n");
        fprintf(fp_out, "      rst       : in  std_logic;\n");
        fprintf(fp_out, "      cs        : in  std_logic;\n");
        fprintf(fp_out, "      rw        : in  std_logic;\n");
        fprintf(fp_out, "      addr      : in  std_logic_vector(%d downto 0);\n", addr_len);
        fprintf(fp_out, "      data_out  : out std_logic_vector(7 downto 0);\n");
        fprintf(fp_out, "      data_in   : in  std_logic_vector(7 downto 0)\n");
        fprintf(fp_out, "   );\n");
        fprintf(fp_out, "end %s;\n", entity_name);
        fprintf(fp_out, "\n");
        fprintf(fp_out, "architecture rtl of %s is\n", entity_name);
        fprintf(fp_out, "\n");
        fprintf(fp_out, "   type data_array is array(0 to %d) of std_logic_vector(7 downto 0);\n",rom_max-1);
        fprintf(fp_out, "   signal xdata : data_array;\n");
        fprintf(fp_out, "   signal en : std_logic_vector(%d downto 0);\n", rom_max-1);
        fprintf(fp_out, "   signal we : std_logic;\n");
        fprintf(fp_out, "\n");
        fprintf(fp_out,"   begin\n");
        fprintf(fp_out, "\n");
 
        addr=start_addr;
        for( rom_num=0; rom_num<rom_max; rom_num++) {
                fprintf(fp_out, "   ROM%02x: RAMB4_S8\n", rom_num );
                fprintf(fp_out, "      generic map (\n");
                for( j=0; j<16; j++ ) {
                        fprintf( fp_out, "         INIT_%02x => x\"", j );
                        for(i=31; i>=0; i-- ) {
                                byte = (int)eprom_buff[(addr - offset + i) % EPROM_MAX];
                                putc( hex_str[(byte >>4) & 0xf], fp_out );
                                putc( hex_str[byte & 0xf], fp_out );
                        }
                        if (j < 15) {
                                fprintf( fp_out, "\",\n" );
                        } else {
                                fprintf( fp_out, "\"\n" );
                        }
                        addr+=32;
                }
                fprintf(fp_out, "      )\n");
                fprintf(fp_out, "      port map (\n");
                fprintf(fp_out, "         clk     => clk,\n");
                fprintf(fp_out, "         en      => en(%d),\n", rom_num );
                fprintf(fp_out, "         we      => we,\n");
                fprintf(fp_out, "         rst     => rst,\n");
                fprintf(fp_out, "         addr    => addr(8 downto 0),\n");
                fprintf(fp_out, "         di      => data_in,\n");
                fprintf(fp_out, "         do      => xdata(%d)\n", rom_num );
                fprintf(fp_out, "      );\n");
                fprintf(fp_out, "\n");
        }
 
        fprintf(fp_out, "   rom_glue: process (cs, rw, addr, xdata)\n");
        fprintf(fp_out, "   begin\n");
        if( addr_len > rom_len ) {
                fprintf(fp_out, "      en <= (others=>'0');\n");
                fprintf(fp_out, "      case addr(%d downto %d) is\n", addr_len, rom_len+1 );
 
                for( rom_num=0; rom_num<rom_max; rom_num++ ) {
                        fprintf(fp_out, "      when \"%s\" =>\n", bin_string(rom_num, addr_len-rom_len) );
                        fprintf(fp_out, "         en(%d)  <= cs;\n", rom_num );
                        fprintf(fp_out, "         data_out  <= xdata(%d);\n", rom_num);
                }
 
                fprintf(fp_out, "      when others =>\n");
                fprintf(fp_out, "         null;\n");
                fprintf(fp_out, "      end case;\n");
        } else {
                fprintf(fp_out, "      en(0)  <= cs;\n" );
                fprintf(fp_out, "      data_out  <= xdata(0);\n" );
        }
        fprintf(fp_out, "      we <= not rw;\n");
        fprintf(fp_out, "   end process;\n");
        fprintf(fp_out, "end architecture rtl;\n\n");
}
 
 
/*
* save VHDL hexadecimal file 16 KBit Block RAM (Spartan 3)
*/
 
void save_vhdl_b16( FILE *fp_out, char *entity_name, int start_addr, int end_addr )
{
        int addr;
        int i,j;
        int byte;
        int rom_num, rom_max, rom_len;
        int addr_len;
 
        rom_max = (end_addr+1-start_addr)/2048;
        rom_len = 10;
        addr_len = (int)(log((double)(end_addr-start_addr))/log(2.0));
 
        fprintf(fp_out, "library IEEE;\n");
        fprintf(fp_out, "   use IEEE.std_logic_1164.all;\n");
        fprintf(fp_out, "   use IEEE.std_logic_arith.all;\n");
        fprintf(fp_out, "library unisim;\n");
        fprintf(fp_out, "   use unisim.vcomponents.all;\n");
        fprintf(fp_out, "\n");
        fprintf(fp_out, "entity %s is\n", entity_name);
        fprintf(fp_out, "   port(\n");
        fprintf(fp_out, "      clk       : in  std_logic;\n");
        fprintf(fp_out, "      rst       : in  std_logic;\n");
        fprintf(fp_out, "      cs        : in  std_logic;\n");
        fprintf(fp_out, "      rw        : in  std_logic;\n");
        fprintf(fp_out, "      addr      : in  std_logic_vector(%d downto 0);\n", addr_len);
        fprintf(fp_out, "      data_out  : out std_logic_vector(7 downto 0);\n");
        fprintf(fp_out, "      data_in   : in  std_logic_vector(7 downto 0)\n");
        fprintf(fp_out, "   );\n");
        fprintf(fp_out, "end %s;\n", entity_name);
        fprintf(fp_out, "\n");
        fprintf(fp_out, "architecture rtl of %s is\n", entity_name);
        fprintf(fp_out, "\n");
        fprintf(fp_out, "   type data_array is array(0 to %d) of std_logic_vector(7 downto 0);\n",rom_max-1);
        fprintf(fp_out, "   signal xdata : data_array;\n");
        fprintf(fp_out, "   signal en : std_logic_vector(%d downto 0);\n", rom_max-1);
        fprintf(fp_out, "   signal dp : std_logic_vector(%d downto 0);\n", rom_max-1);
        fprintf(fp_out, "   signal we : std_logic;\n");
        fprintf(fp_out, "\n");
        fprintf(fp_out, "   begin\n");
        fprintf(fp_out, "\n");
 
        addr=start_addr;
        for( rom_num=0; rom_num<rom_max; rom_num++) {
                fprintf(fp_out, "   ROM%02x: RAMB16_S9\n", rom_num );
                fprintf(fp_out, "      generic map (\n");
                for( j=0; j<64; j++ ) {
                        fprintf( fp_out, "         INIT_%02x => x\"", j );
                        for(i=31; i>=0; i-- ) {
                                byte = (int)eprom_buff[(addr - offset + i) % EPROM_MAX];
                                putc( hex_str[(byte >>4) & 0xf], fp_out );
                                putc( hex_str[byte & 0xf], fp_out );
                        }
                        if (j < 63)  {
                                fprintf( fp_out, "\",\n" );
                        } else {
                                fprintf( fp_out, "\"\n" );
                        }
                        addr+=32;
                }
                fprintf(fp_out, "      )\n");
                fprintf(fp_out, "      port map (\n");
                fprintf(fp_out, "         CLK     => clk,\n");
                fprintf(fp_out, "         SSR     => rst,\n");
                fprintf(fp_out, "         EN      => en(%d),\n", rom_num );
                fprintf(fp_out, "         WE      => we,\n");
                fprintf(fp_out, "         ADDR    => addr(10 downto 0),\n");
                fprintf(fp_out, "         DI      => data_in,\n");
                fprintf(fp_out, "         DIP(0)  => dp(%d),\n", rom_num );
                fprintf(fp_out, "         DO      => xdata(%d),\n", rom_num );
                fprintf(fp_out, "         DOP(0)  => dp(%d)\n", rom_num );
                fprintf(fp_out, "      );\n");
        }
 
        fprintf(fp_out, "   rom_glue: process (cs, rw, addr, xdata)\n");
        fprintf(fp_out, "   begin\n");
        if( addr_len > rom_len ) {
                fprintf(fp_out, "      en <= (others=>'0');\n");
                fprintf(fp_out, "      case addr(%d downto %d) is\n", addr_len, rom_len+1 );
 
                for( rom_num=0; rom_num<rom_max; rom_num++ ) {
                        fprintf(fp_out, "      when \"%s\" =>\n", bin_string(rom_num, addr_len-rom_len) );
                        fprintf(fp_out, "         en(%d)  <= cs;\n", rom_num );
                        fprintf(fp_out, "         data_out  <= xdata(%d);\n", rom_num);
                }
 
                fprintf(fp_out, "      when others =>\n");
                fprintf(fp_out, "         null;\n");
                fprintf(fp_out, "      end case;\n");
        } else {
                fprintf(fp_out, "      en(0)  <= cs;\n");
                fprintf(fp_out, "      data_out  <= xdata(0);\n");
        }
        fprintf(fp_out, "      we <= not rw;\n");
        fprintf(fp_out, "   end process;\n");
        fprintf(fp_out, "end architecture rtl;\n\n");
}
 
/*
* epedit main program
*/
int main(int argc, char* argv[])
{
        int start_addr;
        int end_addr;
        int arglen;
        char entity_name_buf[512];
        char hdl_file_buf[1024];
        char buf[1024];
        char *curpos;
        FILE *fp_out;
 
        if (argc < 5)
        {
                printf("Usage: s19tovhd <bram_type> <s19 file> <base vhd file> <vhdl base entity name> <addr> [<addr> ...]\n");
                return(-1);
        }
        int bram_type_arg_pos = 1;
        int s19_file_arg_pos = 2;
        int base_vhdl_file_arg_pos = 3;
        int entity_name_arg_pos = 4;
        int first_addr_arg_pos = 5;
 
        char *bram_type = argv[bram_type_arg_pos];
        char *s19_file = argv[s19_file_arg_pos];
        char *base_vhd_file = argv[base_vhdl_file_arg_pos];
        char *entity_name = argv[entity_name_arg_pos];
        printf("Block-RAM type '%s'\n", bram_type);
        printf("Reading Motorola S19 from file '%s'\n", s19_file);
        printf("VHDL file name '%s'\n", base_vhd_file);
        printf("Base RAM/ROM entity name is '%s'\n", entity_name);
        if (! load_mot( s19_file )) return (-1);
 
        if (strcmp(bram_type,"b16") == 0) {
                if( (fp_out = fopen( base_vhd_file, "w" )) == NULL ) {
                        printf( "\nCan't open '%s' for write ", base_vhd_file );
                        return(-1);
                }
 
                for (int cnt=first_addr_arg_pos; cnt<argc; cnt++) {
                        if( (arglen = get_address( argv[cnt], &start_addr )) == 0 ) {
                                printf("Expected hex start address, got %s\n", argv[cnt]);
                                continue;
                        }
                        end_addr = start_addr + 2047;
                        sprintf(entity_name_buf, "%s_%4X", entity_name, start_addr);
 
                        printf("Entity '%s' (address range '0x%4X'-'0x%4X') written to file '%s'\n",
                                entity_name_buf, start_addr, end_addr, base_vhd_file);
                        save_vhdl_b16( fp_out, entity_name_buf, start_addr, end_addr );
                }
                if (fp_out) fclose(fp_out);
        }
        if (strcmp(bram_type,"b4") == 0) {
                if( (fp_out = fopen( base_vhd_file, "w" )) == NULL ) {
                        printf( "\nCan't open '%s' for write ", base_vhd_file );
                        return(-1);
                }
 
                for (int cnt=first_addr_arg_pos; cnt<argc; cnt++) {
                        if( (arglen = get_address( argv[cnt], &start_addr )) == 0 ) {
                                printf("Expected hex start address, got %s\n", argv[cnt]);
                                continue;
                        }
                        end_addr = start_addr + 2047;
                        sprintf(entity_name_buf, "%s_%4X", entity_name, start_addr);
 
                        printf("Entity '%s' (address range '0x%4X'-'0x%4X') written to file '%s'\n",
                                entity_name_buf, start_addr, end_addr, base_vhd_file);
                        save_vhdl_b4( fp_out, entity_name_buf, start_addr, end_addr );
                }
                if (fp_out) fclose(fp_out);
        }
        return(0);
}
 

Line No.	Rev	Author	Line
1	25	davidgb	`// S19toVHD.cpp : Defines the entry point for the console application.`
2			`//`
3
4			`/*`
5			`* epedit`
6			`*`
7			`* binary file editer program`
8			`*/`
9			`#include <stdio.h>`
10			`#include <string.h>`
11			`#include <ctype.h>`
12	90	davidgb	`#include <math.h>`
13
14	25	davidgb	`/*`
15			`* equates`
16			`*/`
17			`#define EPROM_MAX (1<<16)`
18			`#define CMD_LINE_MAX 80`
19			`#define FALSE 0`
20			`#define TRUE !FALSE`
21			`#define BINARY 0`
22			`#define MOTOROLA 1`
23			`#define INTEL 2`
24			`#define SMAL32 3`
25			`#define VHDL_BIN 4`
26			`#define VHDL_BYTE 5`
27			`#define VHDL_WORD 6`
28
29			`/*`
30			`* global variables`
31			`*/`
32			`FILE cmdfp; / command input pointer */`
33			`char cmdbuff[CMD_LINE_MAX];`
34			`unsigned char eprom_buff[EPROM_MAX]; /* eprom buffer */`
35			`int eprom_top; /* top of EPROM buffer */`
36			`int mod_flag; /* buffer has been modified */`
37			`int auxflag; /* Auxillary input file specified */`
38			`int count;`
39			`int checksum;`
40			`int offset; /* Eprom Buffer memory offset */`
41			`int format_type; /* load / save format type */`
42			`char *hex_str = "0123456789ABCDEF";`
43
44
45			`/*`
46			`* compare a string of specified length`
47			`* return TRUE if a match`
48			`* return FALSE if no match`
49			`* ignore case`
50			`*/`
51			`int str_equal( char s1, char s2, int len )`
52			`{`
53	90	davidgb	`int i = 0;`
54			`while( i<len ) {`
55	25	davidgb	`if( toupper( s1[i] ) == toupper( s2[i] ) )`
56			`i++;`
57	90	davidgb	`else`
58			`return FALSE;`
59	25	davidgb	`}`
60			`return TRUE;`
61			`}`
62
63			`int to_hexadecimal( char c )`
64			`{`
65	90	davidgb	`for( int k=0; k<16; k++ ) {`
66			`if( toupper(c) == hex_str[k] ) return k;`
67	25	davidgb	`}`
68			`return -1;`
69			`}`
70
71			`/*`
72			`* extract an address from the command line`
73			`* returns an offset to the end of the argument.`
74			`*/`
75			`int get_address( char cb, int addr )`
76			`{`
77			`int i, j, k;`
78
79	90	davidgb	`j = i = 0;`
80	25	davidgb
81	90	davidgb	`while((k = to_hexadecimal(cb[i])) != -1) {`
82	25	davidgb	`i++;`
83			`j = j *16 + k;`
84			`}`
85			`*addr = j;`
86	90	davidgb	`if( i == 0 ) return i;`
87			`while( isspace( cb[i]) ) i++;`
88	25	davidgb	`return i;`
89			`}`
90
91			`/*`
92			`* Motorola S1 format to Intel hex format`
93			`* Usage`
94			`* mot2hex <file_name>`
95			`*/`
96
97			`int gethex( FILE *fp_in )`
98			`{`
99			`int hex;`
100
101			`hex = fgetc( fp_in );`
102			`return( to_hexadecimal( hex ) );`
103			`}`
104
105			`int get2hex( FILE *fp_in )`
106			`{`
107			`int hexhi, hexlo, byte;`
108
109			`hexhi = gethex( fp_in );`
110			`if( hexhi != -1 )`
111			`{`
112			`hexlo = gethex( fp_in );`
113			`if( hexlo != -1 )`
114			`{`
115			`byte = hexhi * 16 + hexlo;`
116			`checksum = (checksum + byte) & 0xff;`
117			`return byte;`
118			`}`
119			`}`
120			`return -1;`
121			`}`
122
123			`int get4hex( FILE *fp_in )`
124			`{`
125			`int bytehi, bytelo, addr;`
126
127			`bytehi = get2hex( fp_in );`
128			`if( bytehi != -1 )`
129			`{`
130			`bytelo = get2hex( fp_in );`
131			`if( bytelo != -1 )`
132			`{`
133			`addr = (bytehi * 256) + bytelo;`
134			`return addr;`
135			`}`
136			`}`
137			`return -1;`
138			`}`
139
140			`int get6hex( FILE *fp_in )`
141			`{`
142			`int bytehi, bytemid, bytelow, addr;`
143
144			`bytehi = get2hex( fp_in );`
145			`if( bytehi != -1 )`
146			`{`
147			`bytemid = get2hex( fp_in );`
148			`if( bytemid != -1 )`
149			`{`
150			`bytelow = get2hex( fp_in );`
151			`if( bytelow != -1 )`
152			`{`
153			`addr = (bytehi << 16) + (bytemid << 8) + bytelow;`
154			`return addr;`
155			`}`
156			`}`
157			`}`
158			`return -1;`
159			`}`
160
161			`long get8hex( FILE *fp_in )`
162			`{`
163			`int wordhi, wordlow;`
164			`long addr;`
165
166			`wordhi = get4hex( fp_in );`
167			`if( wordhi != -1 )`
168			`{`
169			`wordlow = get4hex( fp_in );`
170			`if( wordlow != -1 )`
171			`{`
172			`addr = ((long)wordhi << 16) + (long)wordlow;`
173			`return addr;`
174			`}`
175			`}`
176			`return -1;`
177	90	davidgb	`}`
178	25	davidgb
179			`/*`
180			`* load motorola formatted file`
181			`*/`
182
183	78	davidgb	`bool load_mot( char *fname_in )`
184	25	davidgb	`{`
185			`FILE *fp_in;`
186			`int byte, addr, i;`
187
188			`fp_in = fopen( fname_in, "r" );`
189	90	davidgb	`if ( !fp_in ) {`
190	25	davidgb	`printf( "\nCan't open %s", fname_in );`
191	78	davidgb	`return false;`
192	25	davidgb	`}`
193
194			`byte = 0;`
195			`addr = 0;`
196
197	90	davidgb	`while( byte != -1 ) {`
198	25	davidgb	`do {`
199			`byte = fgetc( fp_in);`
200			`} while( (byte != 'S') && (byte != -1) );`
201
202			`byte = fgetc( fp_in );`
203			`checksum = 0;`
204	90	davidgb	`if ( (byte == '1') \|\| (byte == '2') ) {`
205	25	davidgb	`count = get2hex( fp_in );`
206	90	davidgb	`if ( byte == '1' ) {`
207	25	davidgb	`addr = get4hex( fp_in );`
208			`count -= 3;`
209	90	davidgb	`} else {`
210	25	davidgb	`addr = get6hex( fp_in );`
211			`count -= 4;`
212			`}`
213	90	davidgb	`for( i=0; i<count; i++ ) {`
214	25	davidgb	`byte = get2hex( fp_in );`
215			`eprom_buff[( addr - offset) % EPROM_MAX ] = (unsigned char)byte;`
216			`addr++;`
217			`}`
218			`byte = get2hex( fp_in);`
219			`checksum = (~checksum) & 0xff;`
220	90	davidgb	`if ( checksum != 0 )`
221	25	davidgb	`printf( "\nchecksum error - read check = %02x", byte );`
222			`}`
223			`}`
224			`fclose( fp_in );`
225	78	davidgb	`return true;`
226	25	davidgb	`}`
227
228			`int put2hex( FILE *fp, int h )`
229			`{`
230	90	davidgb	`int hex = (h & 0xf0)>>4;`
231			`int i = fputc( (int)hex_str[hex], fp );`
232	25	davidgb	`hex = (h & 0xf);`
233			`i = fputc( (int)hex_str[hex], fp );`
234			`checksum = (checksum + h) & 0xff;`
235			`return i;`
236			`}`
237
238			`int put4hex( FILE * fp, int h )`
239			`{`
240	90	davidgb	`int i = put2hex( fp, (h & 0xff00 )>>8 );`
241	25	davidgb	`i = put2hex( fp, (h & 0xff) );`
242			`return i;`
243			`}`
244
245	90	davidgb	`char *bin_string( int num, int num_len )`
246			`{`
247			`static char retbuf[33];`
248			`char *p;`
249			`int i;`
250	25	davidgb
251	90	davidgb	`p = &retbuf[sizeof(retbuf)-1];`
252			`*p = '\0';`
253			`for (i=0; i<num_len; i++ ) {`
254			`*--p = "01"[num % 2];`
255			`num >>= 1;`
256			`}`
257			`return p;`
258			`}`
259
260	25	davidgb	`/*`
261	90	davidgb	`* save VHDL hexadecimal file 4KBit Block RAM (Spartan 2)`
262	25	davidgb	`*/`
263
264	90	davidgb	`void save_vhdl_b4( FILE fp_out, char entity_name, int start_addr, int end_addr )`
265	25	davidgb	`{`
266			`int addr;`
267			`int i,j;`
268			`int byte;`
269	90	davidgb	`int rom_num, rom_max, rom_len;`
270			`int addr_len;`
271	25	davidgb
272	90	davidgb	`rom_max = (end_addr+1-start_addr)/512;`
273			`rom_len = 8;`
274			`addr_len = (int)(log((double)(end_addr-start_addr))/log(2.0));`
275
276	25	davidgb	`fprintf(fp_out, "library IEEE;\n");`
277			`fprintf(fp_out, " use IEEE.std_logic_1164.all;\n");`
278			`fprintf(fp_out, " use IEEE.std_logic_arith.all;\n");`
279			`fprintf(fp_out, "library unisim;\n");`
280			`fprintf(fp_out, " use unisim.vcomponents.all;\n");`
281			`fprintf(fp_out, "\n");`
282			`fprintf(fp_out, "entity %s is\n", entity_name);`
283			`fprintf(fp_out, " port(\n");`
284	98	davidgb	`fprintf(fp_out, " clk : in std_logic;\n");`
285			`fprintf(fp_out, " rst : in std_logic;\n");`
286			`fprintf(fp_out, " cs : in std_logic;\n");`
287			`fprintf(fp_out, " rw : in std_logic;\n");`
288			`fprintf(fp_out, " addr : in std_logic_vector(%d downto 0);\n", addr_len);`
289			`fprintf(fp_out, " data_out : out std_logic_vector(7 downto 0);\n");`
290			`fprintf(fp_out, " data_in : in std_logic_vector(7 downto 0)\n");`
291	25	davidgb	`fprintf(fp_out, " );\n");`
292			`fprintf(fp_out, "end %s;\n", entity_name);`
293			`fprintf(fp_out, "\n");`
294			`fprintf(fp_out, "architecture rtl of %s is\n", entity_name);`
295	90	davidgb	`fprintf(fp_out, "\n");`
296			`fprintf(fp_out, " type data_array is array(0 to %d) of std_logic_vector(7 downto 0);\n",rom_max-1);`
297			`fprintf(fp_out, " signal xdata : data_array;\n");`
298			`fprintf(fp_out, " signal en : std_logic_vector(%d downto 0);\n", rom_max-1);`
299	25	davidgb	`fprintf(fp_out, " signal we : std_logic;\n");`
300	90	davidgb	`fprintf(fp_out, "\n");`
301			`fprintf(fp_out," begin\n");`
302			`fprintf(fp_out, "\n");`
303	25	davidgb
304	90	davidgb	`addr=start_addr;`
305			`for( rom_num=0; rom_num<rom_max; rom_num++) {`
306			`fprintf(fp_out, " ROM%02x: RAMB4_S8\n", rom_num );`
307			`fprintf(fp_out, " generic map (\n");`
308			`for( j=0; j<16; j++ ) {`
309			`fprintf( fp_out, " INIT_%02x => x\"", j );`
310			`for(i=31; i>=0; i-- ) {`
311			`byte = (int)eprom_buff[(addr - offset + i) % EPROM_MAX];`
312			`putc( hex_str[(byte >>4) & 0xf], fp_out );`
313			`putc( hex_str[byte & 0xf], fp_out );`
314			`}`
315			`if (j < 15) {`
316			`fprintf( fp_out, "\",\n" );`
317			`} else {`
318			`fprintf( fp_out, "\"\n" );`
319			`}`
320			`addr+=32;`
321	25	davidgb	`}`
322	90	davidgb	`fprintf(fp_out, " )\n");`
323			`fprintf(fp_out, " port map (\n");`
324			`fprintf(fp_out, " clk => clk,\n");`
325			`fprintf(fp_out, " en => en(%d),\n", rom_num );`
326			`fprintf(fp_out, " we => we,\n");`
327			`fprintf(fp_out, " rst => rst,\n");`
328			`fprintf(fp_out, " addr => addr(8 downto 0),\n");`
329	98	davidgb	`fprintf(fp_out, " di => data_in,\n");`
330	90	davidgb	`fprintf(fp_out, " do => xdata(%d)\n", rom_num );`
331			`fprintf(fp_out, " );\n");`
332			`fprintf(fp_out, "\n");`
333			`}`
334
335			`fprintf(fp_out, " rom_glue: process (cs, rw, addr, xdata)\n");`
336			`fprintf(fp_out, " begin\n");`
337			`if( addr_len > rom_len ) {`
338			`fprintf(fp_out, " en <= (others=>'0');\n");`
339			`fprintf(fp_out, " case addr(%d downto %d) is\n", addr_len, rom_len+1 );`
340
341			`for( rom_num=0; rom_num<rom_max; rom_num++ ) {`
342			`fprintf(fp_out, " when \"%s\" =>\n", bin_string(rom_num, addr_len-rom_len) );`
343			`fprintf(fp_out, " en(%d) <= cs;\n", rom_num );`
344	98	davidgb	`fprintf(fp_out, " data_out <= xdata(%d);\n", rom_num);`
345	25	davidgb	`}`
346	90	davidgb
347			`fprintf(fp_out, " when others =>\n");`
348			`fprintf(fp_out, " null;\n");`
349			`fprintf(fp_out, " end case;\n");`
350			`} else {`
351			`fprintf(fp_out, " en(0) <= cs;\n" );`
352	98	davidgb	`fprintf(fp_out, " data_out <= xdata(0);\n" );`
353	25	davidgb	`}`
354			`fprintf(fp_out, " we <= not rw;\n");`
355			`fprintf(fp_out, " end process;\n");`
356			`fprintf(fp_out, "end architecture rtl;\n\n");`
357			`}`
358
359
360	90	davidgb	`/*`
361			`* save VHDL hexadecimal file 16 KBit Block RAM (Spartan 3)`
362			`*/`
363	25	davidgb
364	90	davidgb	`void save_vhdl_b16( FILE fp_out, char entity_name, int start_addr, int end_addr )`
365			`{`
366			`int addr;`
367			`int i,j;`
368			`int byte;`
369			`int rom_num, rom_max, rom_len;`
370			`int addr_len;`
371	25	davidgb
372	90	davidgb	`rom_max = (end_addr+1-start_addr)/2048;`
373			`rom_len = 10;`
374			`addr_len = (int)(log((double)(end_addr-start_addr))/log(2.0));`
375
376			`fprintf(fp_out, "library IEEE;\n");`
377			`fprintf(fp_out, " use IEEE.std_logic_1164.all;\n");`
378			`fprintf(fp_out, " use IEEE.std_logic_arith.all;\n");`
379			`fprintf(fp_out, "library unisim;\n");`
380			`fprintf(fp_out, " use unisim.vcomponents.all;\n");`
381			`fprintf(fp_out, "\n");`
382			`fprintf(fp_out, "entity %s is\n", entity_name);`
383			`fprintf(fp_out, " port(\n");`
384	98	davidgb	`fprintf(fp_out, " clk : in std_logic;\n");`
385			`fprintf(fp_out, " rst : in std_logic;\n");`
386			`fprintf(fp_out, " cs : in std_logic;\n");`
387			`fprintf(fp_out, " rw : in std_logic;\n");`
388			`fprintf(fp_out, " addr : in std_logic_vector(%d downto 0);\n", addr_len);`
389			`fprintf(fp_out, " data_out : out std_logic_vector(7 downto 0);\n");`
390			`fprintf(fp_out, " data_in : in std_logic_vector(7 downto 0)\n");`
391	90	davidgb	`fprintf(fp_out, " );\n");`
392			`fprintf(fp_out, "end %s;\n", entity_name);`
393			`fprintf(fp_out, "\n");`
394			`fprintf(fp_out, "architecture rtl of %s is\n", entity_name);`
395			`fprintf(fp_out, "\n");`
396			`fprintf(fp_out, " type data_array is array(0 to %d) of std_logic_vector(7 downto 0);\n",rom_max-1);`
397			`fprintf(fp_out, " signal xdata : data_array;\n");`
398			`fprintf(fp_out, " signal en : std_logic_vector(%d downto 0);\n", rom_max-1);`
399			`fprintf(fp_out, " signal dp : std_logic_vector(%d downto 0);\n", rom_max-1);`
400			`fprintf(fp_out, " signal we : std_logic;\n");`
401			`fprintf(fp_out, "\n");`
402			`fprintf(fp_out, " begin\n");`
403			`fprintf(fp_out, "\n");`
404
405			`addr=start_addr;`
406			`for( rom_num=0; rom_num<rom_max; rom_num++) {`
407			`fprintf(fp_out, " ROM%02x: RAMB16_S9\n", rom_num );`
408			`fprintf(fp_out, " generic map (\n");`
409			`for( j=0; j<64; j++ ) {`
410			`fprintf( fp_out, " INIT_%02x => x\"", j );`
411			`for(i=31; i>=0; i-- ) {`
412			`byte = (int)eprom_buff[(addr - offset + i) % EPROM_MAX];`
413			`putc( hex_str[(byte >>4) & 0xf], fp_out );`
414			`putc( hex_str[byte & 0xf], fp_out );`
415			`}`
416			`if (j < 63) {`
417			`fprintf( fp_out, "\",\n" );`
418			`} else {`
419			`fprintf( fp_out, "\"\n" );`
420			`}`
421			`addr+=32;`
422			`}`
423			`fprintf(fp_out, " )\n");`
424			`fprintf(fp_out, " port map (\n");`
425			`fprintf(fp_out, " CLK => clk,\n");`
426			`fprintf(fp_out, " SSR => rst,\n");`
427			`fprintf(fp_out, " EN => en(%d),\n", rom_num );`
428			`fprintf(fp_out, " WE => we,\n");`
429			`fprintf(fp_out, " ADDR => addr(10 downto 0),\n");`
430	98	davidgb	`fprintf(fp_out, " DI => data_in,\n");`
431	90	davidgb	`fprintf(fp_out, " DIP(0) => dp(%d),\n", rom_num );`
432			`fprintf(fp_out, " DO => xdata(%d),\n", rom_num );`
433			`fprintf(fp_out, " DOP(0) => dp(%d)\n", rom_num );`
434			`fprintf(fp_out, " );\n");`
435			`}`
436
437			`fprintf(fp_out, " rom_glue: process (cs, rw, addr, xdata)\n");`
438			`fprintf(fp_out, " begin\n");`
439			`if( addr_len > rom_len ) {`
440			`fprintf(fp_out, " en <= (others=>'0');\n");`
441			`fprintf(fp_out, " case addr(%d downto %d) is\n", addr_len, rom_len+1 );`
442
443			`for( rom_num=0; rom_num<rom_max; rom_num++ ) {`
444			`fprintf(fp_out, " when \"%s\" =>\n", bin_string(rom_num, addr_len-rom_len) );`
445			`fprintf(fp_out, " en(%d) <= cs;\n", rom_num );`
446	98	davidgb	`fprintf(fp_out, " data_out <= xdata(%d);\n", rom_num);`
447	90	davidgb	`}`
448
449			`fprintf(fp_out, " when others =>\n");`
450			`fprintf(fp_out, " null;\n");`
451			`fprintf(fp_out, " end case;\n");`
452			`} else {`
453			`fprintf(fp_out, " en(0) <= cs;\n");`
454	98	davidgb	`fprintf(fp_out, " data_out <= xdata(0);\n");`
455	90	davidgb	`}`
456			`fprintf(fp_out, " we <= not rw;\n");`
457			`fprintf(fp_out, " end process;\n");`
458			`fprintf(fp_out, "end architecture rtl;\n\n");`
459			`}`
460
461	25	davidgb	`/*`
462			`* epedit main program`
463			`*/`
464			`int main(int argc, char* argv[])`
465			`{`
466			`int start_addr;`
467			`int end_addr;`
468			`int arglen;`
469			`char entity_name_buf[512];`
470			`char hdl_file_buf[1024];`
471			`char buf[1024];`
472			`char *curpos;`
473			`FILE *fp_out;`
474
475	90	davidgb	`if (argc < 5)`
476			`{`
477			`printf("Usage: s19tovhd <bram_type> <s19 file> <base vhd file> <vhdl base entity name> <addr> [<addr> ...]\n");`
478	25	davidgb	`return(-1);`
479			`}`
480	90	davidgb	`int bram_type_arg_pos = 1;`
481			`int s19_file_arg_pos = 2;`
482			`int base_vhdl_file_arg_pos = 3;`
483			`int entity_name_arg_pos = 4;`
484			`int first_addr_arg_pos = 5;`
485	25	davidgb
486	90	davidgb	`char *bram_type = argv[bram_type_arg_pos];`
487			`char *s19_file = argv[s19_file_arg_pos];`
488			`char *base_vhd_file = argv[base_vhdl_file_arg_pos];`
489			`char *entity_name = argv[entity_name_arg_pos];`
490			`printf("Block-RAM type '%s'\n", bram_type);`
491			`printf("Reading Motorola S19 from file '%s'\n", s19_file);`
492			`printf("VHDL file name '%s'\n", base_vhd_file);`
493			`printf("Base RAM/ROM entity name is '%s'\n", entity_name);`
494			`if (! load_mot( s19_file )) return (-1);`
495
496			`if (strcmp(bram_type,"b16") == 0) {`
497			`if( (fp_out = fopen( base_vhd_file, "w" )) == NULL ) {`
498			`printf( "\nCan't open '%s' for write ", base_vhd_file );`
499			`return(-1);`
500	25	davidgb	`}`

Browse

Tools

Subversion Repositories System09

[/] [System09/] [trunk/] [Tools/] [s19tovhd/] [S19toVHD.cpp] - Blame information for rev 110