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 write transfers.
  */
 
// *****************************************************************************
// ******* ZtexUsbWriter *******************************************************
// *****************************************************************************
public class ZtexUsbWriter {
    private Device dev;
    private DeviceHandle handle;
    private int ep;
    private int bufNum;
    private int bufSize;
    private boolean isInt;
 
    private ByteBuffer[] bufs;
    private Transfer[] transfers;
    private volatile boolean[] pending;
    private int transmitCount = 0;
    private volatile long byteCount = 0;
    private boolean cancelled = false; 	// transfer.status() seem not to work under windows
 
    private final TransferCallback callback = new TransferCallback() {
    	public void processTransfer(Transfer transfer) {
	    byteCount += transfer.actualLength();
	    if ( (transfer.actualLength()!=transfer.length()) && (!cancelled) && (transfer.status()!=LibUsb.TRANSFER_CANCELLED) ) System.err.println( ZtexDevice1.name(dev) + ": Invalid length of sent data: " + transfer.actualLength() + " bytes sent, expected " + transfer.length() );
    	    // find index
    	    int i=0;
    	    while ( (i<bufNum) && (!transfer.equals(transfers[i])) ) i++;
    	    if ( i < bufNum ) {
    		pending[i] = false;
    	    }
    	    else System.err.println("Internal error: unknown transfer");
    	}
    };
 
 
// ******* ZtexUsbWriter *********************************************************
/**
  * Creates the writer 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 buffer. Recommended queue size are 2MByte to 8MByte.
  */
    public ZtexUsbWriter ( 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;
        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 writer 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 ZtexUsbWriter ( Ztex1 ztex, int p_ep, boolean p_isInt, int p_bufNum, int p_bufSize ) {
	this(ztex.handle(), 127 & p_ep, p_isInt, p_bufNum, p_bufSize);
    }
 
/**
  * Creates the writer 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.
  */
    public ZtexUsbWriter ( Ztex1v1 ztex, int p_bufNum, int p_bufSize ) throws InvalidFirmwareException, UsbException, CapabilityException {
	this(ztex.handle(), ztex.defaultOutEP(), false, p_bufNum, p_bufSize);
    }
 
// ******* transmitBuffer ******************************************************
/**
  * Transmit the next buffer. 
  * @param buf The byte array which contains the data.
  * @param maxLen Maximum amount of data to transmit. If it is larger than the buffer size the last bytes are ignored.
  * @param timeout Timeout in ms. If timeout occurs the function returns -1.
  * @return The number of bytes transmitted or -1 if timeout occurs.
  * @throws UsbExecption if an error occurred.
  */
    public int transmitBuffer(byte[] buf, int maxLen, int timeout) throws UsbException {
	int j = transmitCount % bufNum;
//	System.out.println("TB1 "+transmitCount);
	for (int i=0; pending[j] && (i<timeout); i++ ) {
   	    try { Thread.sleep(1); } catch ( InterruptedException e) { } 
	}
	if ( pending[j] ) {
	    return -1;
	}
//	System.out.println("TB2 "+transmitCount);
	if ( transfers[j] == null ) {
	    transfers[j] = LibUsb.allocTransfer();
	    if ( transfers[j] == null ) throw new UsbException(dev, "Error allocating transfer buffer " + transmitCount);
	    if ( isInt ) LibUsb.fillInterruptTransfer(transfers[j], handle, (byte)ep, bufs[j], callback, this, 5000);
	    else LibUsb.fillBulkTransfer(transfers[j], handle, (byte)ep, bufs[j], callback, this, 5000);
	}
//	System.out.println("TB "+transmitCount);
	final int k = Math.min(Math.min(bufSize, maxLen), buf.length);
	bufs[j].rewind();
	bufs[j].put(buf, 0, k);
	transfers[j].setLength(k);
//	System.out.println("TB3 "+k);
        int result = LibUsb.submitTransfer(transfers[j]);
        if ( result!=LibUsb.SUCCESS ) throw new UsbException(dev, "Error submitting buffer " + transmitCount, result);
	pending[j] = true;
	transmitCount++;
	cancelled = false;
//	System.out.println("TB4 "+transmitCount);
	return k;
    }
 
 
/**
  * Transmit the next buffer. 
  * @param buf The byte array which contains the data. If the array is larger than the buffer size the last bytes are ignored.
  * @param timeout Timeout in ms. If timeout occurs the function returns -1.
  * @return The number of bytes transmitted or -1 if timeout occurs.
  * @throws UsbExecption if an error occurred.
  */
    public int transmitBuffer(byte[] buf, int timeout) throws UsbException {
	return transmitBuffer(buf, buf.length, timeout);
    }
 
// ******* byteCount ***********************************************************
/**
  * Return the number of bytes transmitted.
  * @return The number of bytes transmitted.
  */
    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 {
	cancelled = true;
	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);
	    }
	}
    }
 
// ******* wait **********************************************************
/**
  * Waits until all pending transfers are finished or canceled.
  * @param timeout Timeout in ms
  * @return True if all transfers are finished or cancelled
  * @throws UsbExecption if an error occurred.
  */
    public boolean wait(int timeout) throws UsbException {
	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;
    }
 
// ******* cancelWait **********************************************************
/**
  * Cancels all pending transfers and waits until transfers are canceled.
  * @param timeout Timeout in ms
  * @return True if all transfers or cancelled.
  * @throws UsbExecption if an error occurred.
  */
    public boolean cancelWait(int timeout) throws UsbException {
	cancel();
	return wait(timeout);
    }
 
 
}