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/.
%*/
 
package ztex;
 
import java.io.*;
import java.util.*;
import java.nio.*;
 
import org.usb4java.*;
 
/**
  * A helper class to implement asynchronous bulk and interrupt read transfers. This class also has a speed test mode.
  */
 
// *****************************************************************************
// ******* ZtexUsbReader *******************************************************
// *****************************************************************************
public class ZtexUsbReader {
    private Device dev;
    private DeviceHandle handle;
    private int ep;
    private boolean isInt;
    private int bufNum;
    private int bufSize;
 
    private ByteBuffer[] bufs;
    private Transfer[] transfers;
    private volatile boolean[] pending;
    private long getCount = 0;
    private volatile long byteCount = 0;
 
    private volatile boolean speedTest = false;
    private volatile long remaining;
 
    /*
     * Timeout for USB transfers in ms. Default value is 5000.
     */
    public int usbTimeOut = 5000;
 
    private final TransferCallback callback = new TransferCallback() {
    	public void processTransfer(Transfer transfer) {
	byteCount += transfer.actualLength();
    	// find index
    	int i=0;
    	while ( (i<bufNum) && (!transfer.equals(transfers[i])) ) i++;
    	if ( i < bufNum ) {
    	    if ( speedTest ) {
    		try {
    		    submit(i);
    		}
    		catch (Exception e) {
    		    System.err.println(e);
    		}
    	    }
    	    else pending[i] = false;
    	}
    	else System.err.println("Internal error: unknown transfer");
    	}
    };
 
 
// ******* ZtexUsbReader *******************************************************
/**
  * Creates the reader for a given USB device and endpoint number.
  * @param p_handle The device handle used for communication (must be opened).
  * @param p_ep The input endpoint.
  * @param p_isInt True if it is an interrupt transfer.
  * @param p_bufSize size of each buffer. Typical values are 64KByte to 512KByte
  * @param p_bufNum number of buffers. Recommended queue size is 2MByte to 8MByte.
  */
    public ZtexUsbReader ( DeviceHandle p_handle, int p_ep, boolean p_isInt, int p_bufNum, int p_bufSize ) {
        dev = LibUsb.getDevice(p_handle);
        handle = p_handle;
        ep = p_ep;
        isInt = p_isInt;
        bufNum = p_bufNum;
        bufSize = p_bufSize;
        bufs = new ByteBuffer[bufNum];
        transfers = new Transfer[bufNum];
        pending = new boolean[bufNum];
	for (int i=0; i<bufNum; i++) {
	    bufs[i] = BufferUtils.allocateByteBuffer(bufSize);
	    transfers[i] = null;
	    pending[i] = false;
	}
    }
 
/**
  * Creates the reader from a given ZTEX device and endpoint number.
  * @param ztex The ZTEX device.
  * @param p_ep The number of the input endpoint
  * @param p_isInt True if it is an interrupt transfer.
  * @param p_bufSize size of each buffer. Typical values are 64KByte to 512KByte
  * @param p_bufNum number of buffer. Recommended queue size is 2MByte to 8MByte.
  */
    public ZtexUsbReader ( Ztex1 ztex, int p_ep, boolean p_isInt, int p_bufNum, int p_bufSize ) {
	this(ztex.handle(), 128 | p_ep, p_isInt, p_bufNum, p_bufSize);
    }
 
/**
  * Creates the reader for the input endpoint of the default interface of a ZTEX device.
  * @param ztex The ZTEX device.
  * @param p_bufSize size of each buffer. Typical values are 64KByte to 512KByte
  * @param p_bufNum number of buffer. Recommended queue size is 2MByte to 8MByte.
  * @throws InvalidFirmwareException if interface 1 is not supported.
  * @throws CapabilityException if default interface if not present or version number is lower than required
  * @throws UsbExcption if a communication error occurred.
  */
    public ZtexUsbReader ( Ztex1v1 ztex, int p_bufNum, int p_bufSize ) throws InvalidFirmwareException, UsbException, CapabilityException {
	this(ztex.handle(), ztex.defaultInEP(), false, p_bufNum, p_bufSize);
    }
 
// ******* submit **************************************************************
    private void submit(int i) throws UsbException {
	if ( transfers[i] == null ) return;
	if ( remaining <=0 ) {
	    LibUsb.freeTransfer(transfers[i]);
	    transfers[i] = null;
	    return;
	}
	remaining--;
        int result = LibUsb.submitTransfer(transfers[i]);
        if ( (result!=LibUsb.SUCCESS) && (result!=LibUsb.ERROR_BUSY) ) throw new UsbException(dev, "Error submitting buffer " + i, result);
        pending[i] = true;
    }
 
// ******* getBuffer ***********************************************************
/**
  * Get the next buffer. This does not work in speed test mode, see see {@link #start(long)}.
  * @param buf The byte array where to store the data.
  * @param timeout Timeout in ms. If timeout occurs the function returns -1.
  * @return The number of bytes read or -1 if timeout occurs.
  * @throws UsbExecption if an error occurred.
  */
    public int getBuffer(byte[] buf, int timeout) throws UsbException {
	if ( speedTest ) throw new UsbException(dev, "Unable to get buffer: Device is in speed test mode");
	int j = (int)(getCount % bufNum);
	for (int i=0; pending[j] && (i<timeout); i++ ) {
   	    try { Thread.sleep(1); } catch ( InterruptedException e) { } 
	}
	if ( pending[j] ) return -1;
	else if ( transfers[j] == null ) {
	    getCount++;
	    return 0;
	}
	else if ( transfers[j].status() != LibUsb.TRANSFER_COMPLETED ) throw new UsbException(dev, "Error receving buffer " + getCount + ": " + transfers[j].status());
 
	final int k = Math.min(transfers[j].actualLength(), buf.length);
	bufs[j].rewind();
	bufs[j].get(buf, 0, k);
	submit(j);
	getCount++;
	return k;
    }
 
// ******* transferStatus ******************************************************
/**
  * Return status of current transfer (see LibUsb.TRANSFER_*), -1 if transfer is pending or -2 if transfer has not been started.
  * @return Transfer status.
  */
    public int transferStatus() {
	int j = (int)(getCount % bufNum);
	return transfers[j] == null ? -2 : pending[j] ? -1 : transfers[j].status();
    }
 
// ******* byteCount ***********************************************************
/**
  * Return the number of bytes read since last {@link #start(long)}.
  * @return The number of bytes read since last {@link #start(long)}.
  */
    public long byteCount () {
	return byteCount;
    } 
 
// ******* bufSize *************************************************************
/**
  * Return the buffer size.
  * @return The buffer size.
  */
    public int bufSize () {
	return bufSize;
    } 
 
// ******* cancel **************************************************************
/**
  * Cancels all pending transfers, also see {@link #cancelWait(int)},
  * @throws UsbExecption if an error occurred.
  */
    public void cancel() throws UsbException {
	speedTest = false;
	remaining = 0;
	for (int i=0; i<bufNum; i++ ) {
	    if ( (transfers[i] != null) && pending[i] ) {
		int result = LibUsb.cancelTransfer(transfers[i]);
	    	if ( (result!=LibUsb.SUCCESS) && (result!=LibUsb.ERROR_NOT_FOUND) ) throw new UsbException(dev, "Unable to cancel transfer", result);
	    }
	}
    }
 
// ******* cancelWait **********************************************************
/**
  * Cancels all pending transfers and waits until transfers are canceled.
  * @param timeout Timeout in ms
  * @return True if all transfers are finished or cancelled
  * @throws UsbExecption if an error occurred.
  */
    public boolean cancelWait(int timeout) throws UsbException {
	cancel();
 
	boolean b = true;
	for (int i=0; b && i<=timeout; i+=20 ) {
	    b = false;
	    for (int j=0; j<bufNum; j++ ) {
		if ( transfers[j] != null ) {
		    b = b || pending[j];
		    if ( !pending[j] ) {
			LibUsb.freeTransfer(transfers[j]);
			transfers[j] = null;
		    }
		}
	    }
	    try { if ( b ) Thread.sleep(20); } catch ( InterruptedException e) { } 
	}
	return !b;
    }
 
// ******* start ***************************************************************
/**
  * Start the reader. 
  * The amount of buffers to be read is defined using the parameter maxCount.
  * A value of 0 starts infinite reads, a value of -1 starts the reader in speed test mode.
  * In this mode the buffer content is ignored and new read transfer are initiated immediately.
  * @param maxCount Maximum amount of bytes to read or 0 for infinite transfers or <0 for speed test mode.
  * @throws UsbExecption if an error occurred.
  */
    public void start(long maxCount) throws UsbException {
	byteCount = 0;
	speedTest = maxCount < 0;
	remaining = maxCount < 1 ? Long.MAX_VALUE : maxCount;
	for (int i=0; i<bufNum && remaining>0; i++) {
	    int j = (int)((getCount+i) % bufNum);
	    if ( transfers[j] == null ) {
		transfers[j] = LibUsb.allocTransfer();
		if ( transfers[j] == null ) throw new UsbException(dev, "Error allocating transfer buffer "+j);
		if ( isInt ) LibUsb.fillInterruptTransfer(transfers[j], handle, (byte)ep, bufs[j], callback, this, usbTimeOut);
		else LibUsb.fillBulkTransfer(transfers[j], handle, (byte)ep, bufs[j], callback, this, usbTimeOut);
	    }
	    submit(j);
	}
    }
}