Subversion Repositories usb_fpga_2_14

/*%
   Java host software API of ZTEX SDK
   Copyright (C) 2009-2017 ZTEX GmbH.
   http://www.ztex.de
 
   This Source Code Form is subject to the terms of the Mozilla Public
   License, v. 2.0. If a copy of the MPL was not distributed with this file,
   You can obtain one at http://mozilla.org/MPL/2.0/.
 
   Alternatively, the contents of this file may be used under the terms
   of the GNU General Public License Version 3, as described below:
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 3 as
   published by the Free Software Foundation.
 
   This program is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
   General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program; if not, see http://www.gnu.org/licenses/.
%*/
 
/* 
    Reads a firmware image. .ihx and .img format is supported supported
*/
package ztex;
 
import java.io.*;
import java.util.*;
import java.net.*;
/**
  * A class representing a firmware image.
  */
public class ImgFile {
 
/**
  * This array stores the firmware image.
  * Values <0 and >255 mean that the data is undefined.
  */
    public short data[] = null;
 
/**
  * Start vector. 
  * Values <0 mean that no start vector is defined.
  */    
    public long startVector = -1;
 
/**
  * Assumed to be an FX3 firmware.
  * This value is also set by {@link ZtexImgFile1}.
  */    
    public boolean isFx3 = false;
 
 
// ******* compressAddr ********************************************************
/**
  * Compresses the FX3 address space.
  * @param addr Uncompressed address
  * @param len Length of the data packet (used for address validity check).
  * @return Compressed address.
  * @throws ImgParseException If an invalid address occurs.
  */
    private static final int compressAddr( long addr, int len ) throws ImgParseException {
	int sector = (int) (addr >> 28);
	addr = addr & 0xfffffff;
	int addr_max = 64*1024;
	int addr_offs = 0;
	if ( sector >= 1 ) { addr_offs+=addr_max+1; addr_max=8*1024; }      // 64*1024+1
	if ( sector >= 4 ) { addr_offs+=addr_max+1; addr_max=512*1024; }    // 72*1024+2
	if ( sector >= 0xe ) { addr_offs+=addr_max+1; addr_max=256*1024; }  // 584*1024+3
	if ( sector >= 0xf ) { addr_offs+=addr_max+1; addr_max=32*1024; }   // 840*1024+4 .. 872*1024+3
	if ( addr<0 || addr+len>addr_max ) throw new ImgParseException( "Address out of range: " + Integer.toHexString((int)addr) );
	return (int)addr + addr_offs;
    }
 
// ******* uncompressAddr ******************************************************
/**
  * Uncompresses the FX3 address space.
  * @param addr Compressed address
  * @return Uncompressed address.
  */
    public static final long uncompressAddr( int addr ) {
	if ( addr >= 840*1024+4 ) return addr - (840*1024+4) + 0xf0000000;
	if ( addr >= 584*1024+3 ) return addr - (584*1024+3) + 0xe0000000;
	if ( addr >=  72*1024+2 ) return addr - ( 72*1024+2) + 0x40000000;
	if ( addr >=  64*1024+1 ) return addr - ( 64*1024+1) + 0x10000000;
	return addr;
    }
 
// ******* read ****************************************************************
    private static final int read( InputStream in ) throws IOException, ImgParseException {
	int b = in.read();
	if ( b<0 ) throw new ImgParseException( "Unexpected end of file" );
	return b;
    }
 
// ******* readHexDigit ********************************************************
    private static final int readHexDigit( InputStream in ) throws IOException, ImgParseException {
        int b = in.read();
	if ( b>=(byte) '0' && b<=(byte) '9' )
	    return b-(byte) '0';
	if ( b>=(byte) 'a' && b<=(byte) 'f' )
	    return 10+b-(byte) 'a';
	if ( b>=(byte) 'A' && b<=(byte) 'F' )
	    return 10+b-(byte) 'A';
	if ( b == -1 )
	    throw new ImgParseException( "Unexpected end of file" );
	throw new ImgParseException( "Hex digit expected: " + (char) b );
    }
 
// ******* readHexByte *********************************************************
    private static final int readHexByte(InputStream in) throws IOException, ImgParseException {
	return (readHexDigit(in) << 4) | readHexDigit(in);
    }
 
// ******* ImgFile *************************************************************
/**
  * Constructs an instance from a given file name.
  * This method can also read system resources, e.g. files from the current jar archive.
  * @param in Input stream from which the firmware file is read.
  * @param name Name of the input.
  * @throws IOException If an read error occurred.
  * @throws ImgFileDamagedException If the firmware file is damaged.
  */
    public ImgFile ( InputStream in, String name ) throws IOException, ImgFileDamagedException {
	int b, len, cs, addr;
	byte buf[] = new byte[256];
	boolean eof = false;
	int line = 0;
 
	boolean isImg = false;
 
	cs = 0;
	try {
	    b = read(in);
	    if ( b == (byte) 'C' ) {
		b = read(in);
		isFx3 = isImg = b == (byte) 'Y';
	    }
 
	    data = isImg ? new short[873*1024] : new short[64*1024];
 
	    for ( int i=0; i<data.length; i++ )
		data[i] = -1;
 
	    if ( isImg ) {			// img file
		startVector = ( (read(in) & 1)==0 ) ? 0 : -1;
		if ( (b=read(in)) != 0xb0 ) throw new ImgParseException( "Invalid image type: " + Integer.toHexString(b) );
		while ( true ) {
		    len = read(in) | (read(in) << 8) | (read(in) << 16) | (read(in) << 24);
		    if ( len==0 ) break;
		    addr = compressAddr(read(in) | (read(in) << 8) | (read(in) << 16) | (read(in) << 24), len*4);
//		    System.out.println("ImgFile: " + len*4 + " bytes at 0x" + Integer.toHexString(addr));
		    for ( int i=0; i<len; i++ ) {
			data[addr+i*4] = (short) read(in);
			data[addr+i*4+1] = (short) read(in);
			data[addr+i*4+2] = (short) read(in);
			data[addr+i*4+3] = (short) read(in);
			cs += data[addr+i*4] | (data[addr+i*4+1]<<8) | (data[addr+i*4+2]<<16) | (data[addr+i*4+3] << 24);
		    }
		}
		if ( startVector==0 ) {
		    startVector=read(in) | (read(in) << 8) | (read(in) << 16) | (read(in) << 24);
		}
		else {
		    System.err.println("Warning: No program entry defined");
		}
		b = read(in) | (read(in) << 8) | (read(in) << 16) | (read(in) << 24);
		if ( b != cs )
		    throw new ImgParseException( "Checksum error" );
	    }
	    else {				// ihx file
		while ( ! eof ) {
		    while ( b != (byte) ':' ) {
			b = read(in);
		    }
 
		    line ++;
 
		    len = readHexByte(in);		// length field 
		    cs = len;
 
		    b = readHexByte(in);		// address field 
		    cs += b;
		    addr = b << 8;
		    b = readHexByte(in);
		    cs += b;
		    addr |= b;
 
		    b = readHexByte(in);		// record type field
		    cs += b;
 
		    for ( int i=0; i<len; i++ ) {	// data
			buf[i] = (byte) readHexByte(in);
			cs+=buf[i];
		    }
 
		    cs += readHexByte(in);		// checksum
		    if ( (cs & 0xff) != 0 ) {
			throw new ImgParseException( "Checksum error" );
		    }
 
		    if ( b == 0 ) {			// data record
			for (int i=0; i<len; i++ ) {
			    if ( data[addr+i]>=0 ) System.err.println ( "Warning: Memory at position " + Integer.toHexString(i) + " overwritten" );
			    data[addr+i] = (short) (buf[i] & 255);
			}
		    }
		    else if (b == 1 ) {		// eof record
			eof = true;
		    }
		    else {
			throw new ImgParseException( "Invalid record type: " + b );
		    }
		}	    
	    }
	}
	catch ( ImgParseException e ) {
	    throw new ImgFileDamagedException ( name, line, e.getLocalizedMessage() );
	}
 
	try {
	    in.close();
	}
	catch ( Exception e ) {
	    System.err.println( "Warning: Error closing file " + name + ": " + e.getLocalizedMessage() );
	}
    }
 
/**
  * Constructs an instance from a given file name.
  * This method can also read system resources, e.g. files from the current jar archive.
  * @param fileName The file name.
  * @throws IOException If an read error occurred.
  * @throws ImgFileDamagedException If the firmware image file is damaged.
  */
    public ImgFile ( String fileName ) throws IOException, ImgFileDamagedException {
	this( JInputStream.getInputStream( fileName ), fileName );
    }
 
// ******* dataInfo ************************************************************
 /**
  * Print out some information about the memory usage.
  * @param out Where the data is printed out.
  */
   public void dataInfo( PrintStream out ) {
	int addr=-1;
	for ( int i=0; i<=data.length; i++ ) {	// data
	    if ( (i==data.length || data[i]<0) && addr>=0 ) {
		System.out.println( i-addr + " Bytes from " + Integer.toHexString(addr) + " to " + Integer.toHexString(i-1) );
		addr = -1;
	    }
	    if ( i<data.length && data[i]>=0 && addr<0 ) 
		addr = i;
	}
    }
 
}