Subversion Repositories rise

/*

 * RISE microprocessor bin2vhd utility

 * Copyright (c) 2006 Christian Walter <wolti@sil.at>

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. The name of the author may not be used to endorse or promote products

 *    derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * File: $Id: bin2vhd.c,v 1.2 2007-01-25 21:08:25 cwalter Exp $

 */

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <getopt.h>

#include <errno.h>

#include <assert.h>

#define PROGNAME                "bin2vhd"

#define VHDL_ENTITY_NAME        "pgrom"

#define VHDL_ARCHITECTURE_NAME  "pgrom_rtl"

#define ADDRESS_BITS            16

#define DATA_BITS               16

#define IS_SYNCHRONOUS          0

#define PC_INCREMENT            2

#define NELEMS( x )             ( sizeof( x )/ sizeof( x[0] ) )

void            vPrintUsage( void );

void            vWriteEntity( FILE * pxOutputFile );

void            vWriteArchitectureHeader( FILE * pxOutputFile );

void            vWriteArchitectureData( FILE * pxOutputFile, const unsigned char *pucData,

                                        int iNBytes );

void            vWriteArchitectureFooter( FILE * pxOutputFile );

const char     *pcData2Hex( unsigned int uiHexValue );

const char     *pcAddress2Hex( unsigned int uiHexValue );

int

main( int argc, char **argv )

{

    int             iExitStatus = EXIT_FAILURE;

    FILE           *pxInputFile, *pxOutputFile;

    unsigned char   arucBuffer[80];

    size_t          xNBytesRead;

    size_t          xNBytesOffset;

    if( argc != 3 )

    {

        vPrintUsage(  );

    }

    else if( ( pxInputFile = fopen( argv[1], "r" ) ) == NULL )

    {

        fprintf( stderr, "%s: can't open input file %s: %s\n", PROGNAME, argv[1],

                 strerror( errno ) );

    }

    else if( ( pxOutputFile = fopen( argv[2], "w" ) ) == NULL )

    {

        fprintf( stderr, "%s: can't open input file %s: %s\n", PROGNAME, argv[1],

                 strerror( errno ) );

    }

    else

    {

        assert( ( DATA_BITS % 8 ) == 0 );

        assert( ( ADDRESS_BITS % 8 ) == 0 );

        vWriteEntity( pxOutputFile );

        vWriteArchitectureHeader( pxOutputFile );

        xNBytesOffset = 0;

        do

        {

            xNBytesRead = fread( &arucBuffer[xNBytesOffset], 1,

                                 NELEMS( arucBuffer ) - xNBytesOffset, pxInputFile );

            if( xNBytesRead > 0 )

            {

                xNBytesOffset = xNBytesRead % ( DATA_BITS / 8 );

                vWriteArchitectureData( pxOutputFile, arucBuffer, xNBytesRead - xNBytesOffset );

            }

        }

        while( xNBytesRead > 0 );

        vWriteArchitectureFooter( pxOutputFile );

        ( void )fclose( pxOutputFile );

        ( void )fclose( pxInputFile );

    }

}

void

vPrintUsage(  )

{

    fprintf( stderr, "Usage:\n" );

    fprintf( stderr, "  bin2vhd source dest\n" );

}

void

vWriteEntity( FILE * pxOutputFile )

{

    fprintf( pxOutputFile, "library IEEE;\n" );

    fprintf( pxOutputFile, "use IEEE.STD_LOGIC_1164.all;\n" );

    fprintf( pxOutputFile, "use IEEE.NUMERIC_STD.all;\n" );

    fprintf( pxOutputFile, "entity %s is\n", VHDL_ENTITY_NAME );

    fprintf( pxOutputFile, "port (\n" );

    fprintf( pxOutputFile, "  clk   : in std_logic;\n" );

    fprintf( pxOutputFile, "  addr  : in std_logic_vector(%d downto 0 );\n", ( ADDRESS_BITS - 1 ) );

    fprintf( pxOutputFile, "  data  : out std_logic_vector(%d downto 0 ) );\n", ( DATA_BITS - 1 ) );

    fprintf( pxOutputFile, "end %s;\n", VHDL_ENTITY_NAME );

    fprintf( pxOutputFile, "\n" );

}

void

vWriteArchitectureHeader( FILE * pxOutputFile )

{

    fprintf( pxOutputFile, "architecture %s of %s is\n", VHDL_ARCHITECTURE_NAME, VHDL_ENTITY_NAME );

    fprintf( pxOutputFile, "  signal sig_data_next :  std_logic_vector(%d downto 0 );\n",

             ( DATA_BITS - 1 ) );

    if( IS_SYNCHRONOUS )

    {

        fprintf( pxOutputFile, "  signal sig_data_int :  std_logic_vector(%d downto 0 ) );\n",

                 ( DATA_BITS - 1 ) );

        fprintf( pxOutputFile, "begin\n" );

        fprintf( pxOutputFile, "  data <= sig_data_int\n" );

        fprintf( pxOutputFile, "process (clk)\n" );

        fprintf( pxOutputFile, "  if clk'event and clk = '1' then\n" );

        fprintf( pxOutputFile, "    sig_data_int <= sig_data_next;\n" );

        fprintf( pxOutputFile, "  end if;\n" );

        fprintf( pxOutputFile, "end process;\n" );

    }

    else

    {

        fprintf( pxOutputFile, "begin\n" );

        fprintf( pxOutputFile, "  data <= sig_data_next;\n" );

    }

    fprintf( pxOutputFile, "\n" );

    fprintf( pxOutputFile, "  process( addr )\n" );

    fprintf( pxOutputFile, "  begin\n" );

    fprintf( pxOutputFile, "    case addr is\n" );

}

void

vWriteArchitectureData( FILE * pxOutputFile, const unsigned char *pucData, int iNBytes )

{

    static char     arucBuffer[( DATA_BITS / 4 ) + 1];

    static unsigned int uiProgrammCounter = 0;

    int             iBytePos, i;

    for( iBytePos = 0; iBytePos < iNBytes; )

    {

        for( i = 0; i < ( DATA_BITS / 4 ); i += 2, iBytePos++ )

        {

            sprintf( &arucBuffer[i], "%02X", pucData[iBytePos] );

        }

        fprintf( pxOutputFile, "      when x\"%s\" => sig_data_next <= x\"%*s\";\n",

                 pcAddress2Hex( uiProgrammCounter ), DATA_BITS / 4, arucBuffer );

        uiProgrammCounter += PC_INCREMENT;

    }

}

void

vWriteArchitectureFooter( FILE * pxOutputFile )

{

    fprintf( pxOutputFile, "      when others  => sig_data_next <= ( others => '0' );\n" );

    fprintf( pxOutputFile, "    end case;\n" );

    fprintf( pxOutputFile, "  end process;\n" );

    fprintf( pxOutputFile, "\n" );

    fprintf( pxOutputFile, "end %s;", VHDL_ARCHITECTURE_NAME );

}

const char     *

pcAddress2Hex( unsigned int uiHexValue )

{

    static char     arucBuffer[ADDRESS_BITS / 4 + 1];

    snprintf( arucBuffer, NELEMS( arucBuffer ), "%0*x", DATA_BITS / 4, uiHexValue );

    return arucBuffer;

}