Subversion Repositories usb_fpga_1_2

/*!
   Java Driver API for the ZTEX Firmware Kit
   Copyright (C) 2008-2009 ZTEX e.K.
   http://www.ztex.de
 
   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/.
!*/
 
/* 
    USB device with ZTEX descriptor 1 and/or Cypress EZ-USB FX2 device
*/
package ztex;
 
import java.io.*;
import java.util.*;
 
import ch.ntb.usb.*;
 
public class ZtexDevice1 {
    public static final int cypressVendorId = 0x4b4;
    public static final int cypressProductId = 0x8613;
 
    private Usb_Device dev = null;
    private boolean isCypress = false; 		// true if Cypress device
    private boolean valid = false;		// true if descriptor 1 is available
    private int usbVendorId = -1;
    private int usbProductId = -1;
    private String manufacturerString = null;
    private String productString = null;
    private String snString = null;
    private byte productId[] = { 0,0,0,0 };	// product ID from the ZTEX descpriptor, not the USB product ID
    private byte fwVersion = 0;
    private byte interfaceVersion = 0;
    private byte interfaceCapabilities[] = { 0,0,0,0, 0,0 };
    private byte moduleReserved[] = { 0,0,0,0, 0,0,0,0, 0,0,0,0 };
 
// ******* byteArrayString *****************************************************
    public static String byteArrayString ( byte buf[] ) {
	String s = new String( "" );
	for ( int i = 0; i<buf.length; i++ ) {
	    if ( i != 0 ) 
		s+=".";
	    s+=buf[i] & 255;
	}
	return s;
    }
 
// ******* ZtexDevice1 *********************************************************
// Read the ZTEX descriptor if usbVendorId=pUsbVendorId and usbProductId=pUsbProductId
    public ZtexDevice1 (Usb_Device p_dev, int pUsbVendorId, int pUsbProductId) throws UsbException, ZtexDescriptorException {
	dev = p_dev;
 
	Usb_Device_Descriptor dd = dev.getDescriptor();
	usbVendorId = dd.getIdVendor() & 65535;
	usbProductId = dd.getIdProduct() & 65535;
 
	if ( usbVendorId == cypressVendorId  &&  usbProductId == cypressProductId ) {
	    isCypress = true;
	}
 
	int handle = LibusbJava.usb_open(dev);
 
	if ( handle > 0 ) {
	    if ( dd.getIManufacturer() > 0 ) 
	    	manufacturerString = LibusbJava.usb_get_string_simple( handle, dd.getIManufacturer() );
	    if ( dd.getIProduct() > 0 ) 
	    	productString = LibusbJava.usb_get_string_simple( handle, dd.getIProduct() );
	    if ( dd.getISerialNumber() > 0 )  
	    	snString = LibusbJava.usb_get_string_simple( handle, dd.getISerialNumber() );
 
	    if ( usbVendorId == pUsbVendorId  &&  usbProductId == pUsbProductId ) {
		if ( snString == null ) {
		    LibusbJava.usb_close(handle);
		    throw new ZtexDescriptorException( dev, "Not a ZTEX device" );  // ZTEX devices always have a SN. See also the next comment a few lines below
		} 
 
	    	byte[] buf = new byte[42];
		int i = LibusbJava.usb_control_msg(handle, 0xc0, 0x22, 0, 0, buf, 40, 500);	// Failing of this may cause problems under windows. Therefore we check for the SN above.
		if ( i < 0 ) {
		    LibusbJava.usb_close(handle);
		    throw new ZtexDescriptorException( dev, "Error reading ZTEX descriptor: " + LibusbJava.usb_strerror() );
		}
		else if ( i != 40 ) {
		    LibusbJava.usb_close(handle);
		    throw new ZtexDescriptorException( dev, "Error reading ZTEX descriptor: Invalid size: " + i );
		}
		if ( buf[0]!=40 || buf[1]!=1 || buf[2]!='Z' || buf[3]!='T' || buf[4]!='E' || buf[5]!='X' ) {
		    LibusbJava.usb_close(handle);
		    throw new ZtexDescriptorException( dev, "Invalid ZTEX descriptor" );
		}
		productId[0] = buf[6];
		productId[1] = buf[7];
		productId[2] = buf[8];
		productId[3] = buf[9];
		fwVersion = buf[10];
		interfaceVersion = buf[11];
		interfaceCapabilities[0] = buf[12];
		interfaceCapabilities[1] = buf[13];
		interfaceCapabilities[2] = buf[14];
		interfaceCapabilities[3] = buf[15];
		interfaceCapabilities[4] = buf[16];
		interfaceCapabilities[5] = buf[17];
		moduleReserved[0] = buf[18];
		moduleReserved[1] = buf[19];
		moduleReserved[2] = buf[20];
		moduleReserved[3] = buf[21];
		moduleReserved[4] = buf[22];
		moduleReserved[5] = buf[23];
		moduleReserved[6] = buf[24];
		moduleReserved[7] = buf[25];
		moduleReserved[8] = buf[26];
		moduleReserved[9] = buf[27];
		moduleReserved[10] = buf[28];
		moduleReserved[11] = buf[29];
 
		valid = true;
	    }
	}
	else {
	    throw new UsbException( dev, "Error opening device: " + LibusbJava.usb_strerror() );
	}
 
        LibusbJava.usb_close(handle);
    }
 
// ******* toString ************************************************************
    public String toString () {
	return "bus=" + dev.getBus().getDirname() + "  device=" + dev.getFilename() + 
	    "\n   " + ( isCypress ? "Cypress" : "" ) +
	      ( manufacturerString == null ? "" : ("    Manufacturer=\""  + manufacturerString + "\"") ) +
	      ( productString == null ? "" : ("  Product=\""  + productString + "\"") ) +
	      ( snString == null ? "" : ("    SerialNumber=\""  + snString + "\"") ) +
	    ( valid ? "\n   productID=" + byteArrayString(productId) + "  fwVer="+(fwVersion & 255) + "  ifVer="+(interfaceVersion & 255)  : "" );
    }
 
// ******* compatible **********************************************************
    public final boolean compatible( int productId0, int productId1, int productId2, int productId3 ) {
	return ( productId[0]==0 || productId0<=0 || (productId[0] & 255) == productId0 ) &&
	       ( productId[1]==0 || productId1<=0 || (productId[1] & 255) == productId1 ) &&
	       ( productId[2]==0 || productId2<=0 || (productId[2] & 255) == productId2 ) &&
	       ( productId[3]==0 || productId3<=0 || (productId[3] & 255) == productId3 );
    }
 
// ******* dev *****************************************************************
    public final Usb_Device dev() {
	return dev;
    }
 
// ******* isCypress ***********************************************************
    public final boolean isCypress() {
	return isCypress;
    }
 
// ******* valid ***************************************************************
    public final boolean valid() {
	return valid;
    }
 
// ******* usbVendorId *********************************************************
    public final int usbVendorId() {
	return usbVendorId;
    }
 
// ******* usbProductId *********************************************************
    public final int usbProductId() {
	return usbProductId;
    }
 
// ******* manufacturerString **************************************************
    public final String manufacturerString() {
	return manufacturerString;
    }
 
// ******* productString *******************************************************
    public final String productString() {
	return productString;
    }
 
// ******* snString ************************************************************
    public final String snString() {
	return snString;
    }
 
// ******* productId ***********************************************************
    public final byte[] productId() {
	return productId;
    }
 
    public int productId( int i ) {
	return productId[i] & 255;
    }
 
// ******* fwVersion ***********************************************************
    public final int fwVersion() {
	return fwVersion & 255;
    }
 
// ******* interfaceVersion *****************************************************
    public final int interfaceVersion() {
	return interfaceVersion & 255;
    }
 
// ******* interfaceCapabilities ************************************************
    public final byte[] interfaceCapabilities() {
	return interfaceCapabilities;
    }
 
    public final int interfaceCapabilities( int i ) {
	return interfaceCapabilities[i] & 255;
    }
 
    public final boolean interfaceCapabilities( int i, int j ) {
	return 	(i>=0) && (i<=5) && (j>=0) && (j<8) &&
		(((interfaceCapabilities[i] & 255) & (1 << j)) != 0);
    }
 
// ******* moduleReserved ******************************************************
    public final byte[] moduleReserved() {
	return moduleReserved;
    }
 
    public final int moduleReserved( int i ) {
	return moduleReserved[i] & 255;
    }
 
}