From 332c16dac73c3dc27e7a2e3afc44dba34784c5f9 Mon Sep 17 00:00:00 2001 From: uniederer Date: Wed, 4 Apr 2012 13:58:33 +0000 Subject: [PATCH] - Adding Roger Millischers work on the java side making libusb 1.0 run git-svn-id: https://svn.code.sf.net/p/libusbjava/code/trunk@284 94ad28fe-ef68-46b1-9651-e7ae4fcf1c4c --- java/.classpath | 1 + java/.project | 6 + java/META-INF/MANIFEST.MF | 10 +- java/UsbView.launch | 12 + java/build.properties | 5 +- java/build.xml | 2 +- java/project.properties | 2 +- java/src/ch/ntb/inf/libusbJava/Device.java | 20 +- .../src/ch/ntb/inf/libusbJava/LibusbJava.java | 421 ++++-- .../ch/ntb/inf/libusbJava/LibusbJava1.java | 1339 +++++++++++++++++ .../ch/ntb/inf/libusbJava/Libusb_event.java | 19 + .../ch/ntb/inf/libusbJava/Libusb_pollfd.java | 7 + java/src/ch/ntb/inf/libusbJava/Usb_Bus.java | 21 + .../ch/ntb/inf/libusbJava/Usb_Descriptor.java | 4 +- .../src/ch/ntb/inf/libusbJava/Usb_Device.java | 10 + .../inf/libusbJava/Usb_Device_Descriptor.java | 5 +- .../libusbJava/Usb_Endpoint_Descriptor.java | 25 +- .../ch/ntb/inf/libusbJava/demo/ReadWrite.java | 6 +- .../inf/libusbJava/testApp/TestDevice.java | 6 +- .../inf/libusbJava/usbView/UsbTreeModel.java | 4 +- .../ntb/inf/libusbJava/usbView/UsbView.java | 8 +- .../ntb/inf/libusbJava/test/DeviceTest.java | 2 +- .../inf/libusbJava/test/MemoryLeakTest.java | 3 +- .../inf/libusbJava/test/TestLibUsbJava.java | 4 +- .../libusbJava/test/devices/AT90USB1287.java | 6 +- java/version.properties | 8 +- 26 files changed, 1808 insertions(+), 148 deletions(-) create mode 100644 java/UsbView.launch create mode 100644 java/src/ch/ntb/inf/libusbJava/LibusbJava1.java create mode 100644 java/src/ch/ntb/inf/libusbJava/Libusb_event.java create mode 100644 java/src/ch/ntb/inf/libusbJava/Libusb_pollfd.java diff --git a/java/.classpath b/java/.classpath index 4eb8e08..91624f7 100644 --- a/java/.classpath +++ b/java/.classpath @@ -4,5 +4,6 @@ + diff --git a/java/.project b/java/.project index 9aa9f0b..d404604 100644 --- a/java/.project +++ b/java/.project @@ -20,11 +20,17 @@ + + net.sf.eclipsensis.installoptions.InstallOptionsBuilder + + + org.eclipse.jem.workbench.JavaEMFNature org.eclipse.jdt.core.javanature org.eclipse.jem.beaninfo.BeanInfoNature org.eclipse.pde.PluginNature + net.sf.eclipsensis.installoptions.InstallOptionsNature diff --git a/java/META-INF/MANIFEST.MF b/java/META-INF/MANIFEST.MF index 5718e20..67ec8ca 100644 --- a/java/META-INF/MANIFEST.MF +++ b/java/META-INF/MANIFEST.MF @@ -1,9 +1,13 @@ Manifest-Version: 1.0 Bundle-ManifestVersion: 2 -Bundle-Name: Java libusb wrapper -Bundle-SymbolicName: ch.ntb.usb +Bundle-Name: Java libusb-1.0 wrapper +Bundle-SymbolicName: ch.ntb.inf.libusbJava Bundle-Version: 1.0.2 Bundle-Vendor: libusbjava.sourceforge.net Require-Bundle: org.junit4 -Export-Package: ch.ntb.inf.libusbJava +Export-Package: ch.ntb.inf.libusbJava, + ch.ntb.inf.libusbJava.logger, + ch.ntb.inf.libusbJava.testApp, + ch.ntb.inf.libusbJava.usbView Bundle-RequiredExecutionEnvironment: J2SE-1.5 +Import-Package: ch.ntb.inf.libusbJava diff --git a/java/UsbView.launch b/java/UsbView.launch new file mode 100644 index 0000000..e067e1e --- /dev/null +++ b/java/UsbView.launch @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/java/build.properties b/java/build.properties index c7069a0..4790385 100644 --- a/java/build.properties +++ b/java/build.properties @@ -1,4 +1 @@ -source.. = src/,\ - test/ -bin.includes = META-INF/,\ - . +# MTJ Build Properties diff --git a/java/build.xml b/java/build.xml index b154039..00f17ad 100644 --- a/java/build.xml +++ b/java/build.xml @@ -14,7 +14,7 @@ - + diff --git a/java/project.properties b/java/project.properties index bd48a3e..6c301cf 100644 --- a/java/project.properties +++ b/java/project.properties @@ -1,4 +1,4 @@ -#Thu Aug 24 14:28:28 CEST 2006 +#Tue Mar 30 10:58:35 CEST 2010 project.name=ch.ntb.inf.libusbJava project.vendor=inf.ntb.ch project.dir.src=src diff --git a/java/src/ch/ntb/inf/libusbJava/Device.java b/java/src/ch/ntb/inf/libusbJava/Device.java index a345a78..8979a14 100644 --- a/java/src/ch/ntb/inf/libusbJava/Device.java +++ b/java/src/ch/ntb/inf/libusbJava/Device.java @@ -223,9 +223,9 @@ public class Device { if (dev != null) { long res = LibusbJava.usb_open(dev); - if (res == 0) { + if (res <= 0) { throw new USBException("LibusbJava.usb_open: " - + LibusbJava.usb_strerror()); + + LibusbJava.usb_strerror() + " (" + res + ")"); } usbDevHandle = res; } @@ -743,14 +743,20 @@ public class Device { } /** - * Check if the device is open.
- * This checks only for a valid device handle. It doesn't check if the - * device is still attached or working. + * Check if the device is open, attached and work.
* - * @return true if the device is open + * @return true if the device is open and work. */ public boolean isOpen() { - return usbDevHandle != 0; + if(usbDevHandle != 0){ + try { + updateDescriptors(); + } catch (USBException e) { + return false; + } + return dev != null; + } + return false; } /** diff --git a/java/src/ch/ntb/inf/libusbJava/LibusbJava.java b/java/src/ch/ntb/inf/libusbJava/LibusbJava.java index f96dac3..cea1f16 100644 --- a/java/src/ch/ntb/inf/libusbJava/LibusbJava.java +++ b/java/src/ch/ntb/inf/libusbJava/LibusbJava.java @@ -4,32 +4,22 @@ * * http://libusbjava.sourceforge.net * This library is covered by the LGPL, read LGPL.txt for details. + * + * Changes: + * 18.10.2010 NTB / Roger Millischer change from native interface to compatibility layer + * */ package ch.ntb.inf.libusbJava; /** - * This class represents the Java Native Interface to the shared library which - * is (with some exceptions) a one-to-one representation of the libusb API.
- *
- *

Project Description

- * Java libusb is a Java wrapper for the libusb and libusb-win32 USB library. - * - * libusb aim is to create a - * library for use by user level applications to access USB devices regardless - * of OS.
- * Libusb-win32 is a port of - * the USB library libusb to the - * Windows operating systems. The library allows user space applications to - * access any USB device on Windows in a generic way without writing any line of - * kernel driver code.
- *
- * The API description of this class has been copied from the libusb documentation - * and adapted where neccessary.
+ * This class is used as compatibility layer for libusb 0.1 projects. For new + * projects use {@link LibusbJava1} * */ public class LibusbJava { + private static Usb_Bus busses = null; + private static long defaultCTX = 0; /** * System error codes.
* This list is not complete! For more error codes see the file 'errorno.h' @@ -49,15 +39,29 @@ public class LibusbJava { * @param level * 0 to 255 */ - public static native void usb_set_debug(int level); + public static void usb_set_debug(int level) { + LibusbJava1.libusb_set_debug(0, level); + } // Core /** * Just like the name implies, usb_init sets up some internal - * structures. usb_init must be called before any other - * libusb functions. + * structures. usb_init must be called before any other libusb + * functions. */ - public static native void usb_init(); + public static void usb_init() { + if (defaultCTX > 0) { + return; + } + defaultCTX = LibusbJava1.libusb_init(); + LibusbJava1.libusb_set_debug(0, 0); + if (defaultCTX < 0) { + System.out.println("LibusbJava-1.0 init failed with errorcode: " + + defaultCTX); + return; + } + + } /** * usb_find_busses will find all of the busses on the system. @@ -65,7 +69,107 @@ public class LibusbJava { * @return the number of changes since previous call to this function (total * of new busses and busses removed). */ - public static native int usb_find_busses(); + public static int usb_find_busses() { + int changes = 0; + long tmpBusNumber; + Usb_Bus nbusses = null; + Usb_Bus bus = nbusses, tmp; + boolean found = false; + Usb_Device devices = null; + devices = LibusbJava1.libusb_get_device_list(0); + + // no busses + if (devices.getDevnum() == -1) { + while (busses != null) { + changes++; + busses = busses.getNext(); + } + return changes; + } + // find busses + while (devices != null) { + tmpBusNumber = (long) LibusbJava1.libusb_get_bus_number(devices); + while (bus != null) { + if (bus.getLocation() == tmpBusNumber) { + found = true; + break; + } + bus = bus.getNext(); + } + if (found) { + devices = devices.getNext(); + found = false; + continue; + } + if (nbusses == null) { + nbusses = new Usb_Bus(Long.toString(tmpBusNumber), tmpBusNumber); + } else { + tmp = new Usb_Bus(Long.toString(tmpBusNumber), tmpBusNumber); + bus = nbusses; + // append + while (bus.getNext() != null) { + bus = bus.getNext(); + } + tmp.setPrev(bus); + bus.setNext(tmp); + } + bus = nbusses; + devices = devices.getNext(); + } + // compare to existing bus-list + bus = busses; + tmp = nbusses; + found = false; + while (bus != null) { + tmpBusNumber = bus.getLocation(); + while (tmp != null) { + if (tmpBusNumber == tmp.getLocation()) { + found = true; + // remove from nbusses list + if (tmp.getPrev() != null) { + tmp.getPrev().setNext(tmp.getNext()); + } else { + nbusses = tmp.getNext(); + } + if (tmp.getNext() != null) { + tmp.getNext().setPrev(tmp.getPrev()); + } + break; + } + tmp = tmp.getNext(); + } + if (!found) { + // remove from busses an increment changes + if (bus.getPrev() != null) { + bus.getPrev().setNext(bus.getNext()); + } else { + busses = bus.getNext(); + } + if (bus.getNext() != null) { + bus.getNext().setPrev(bus.getPrev()); + } + changes++; + } + bus = bus.getNext(); + tmp = nbusses; + found = false; + } + // add new busses + bus = busses; + while (tmp != null) { + tmp = tmp.getNext(); + changes++; + } + if (busses != null) { + while (bus.getNext() != null) { + bus = bus.getNext(); + } + bus.setNext(nbusses); + } else { + busses = nbusses; + } + return changes; + } /** * usb_find_devices will find all of the devices on each bus. @@ -74,7 +178,85 @@ public class LibusbJava { * @return the number of changes since the previous call to this function * (total of new device and devices removed). */ - public static native int usb_find_devices(); + public static int usb_find_devices() { + int changes = 0; + byte tmpDevnum; + long tmpBusNumber; + Usb_Bus bus = busses; + boolean found = false; + Usb_Device devices, dev, ndev; + + devices = LibusbJava1.libusb_get_device_list(0); + // Compare to existing bus-structure and remove removed devices + while (bus != null) { + dev = bus.getDevices(); + while (dev != null) { + tmpDevnum = dev.getDevnum(); + ndev = devices; + while (ndev != null) { + // if dev already exist remove from ndev list + if (tmpDevnum == ndev.getDevnum()) { + found = true; + if (ndev.getPrev() != null) { + ndev.getPrev().setNext(ndev.getNext()); + } else { + devices = ndev.getNext(); + } + if (ndev.getNext() != null) { + ndev.getNext().setPrev(ndev.getPrev()); + } + break; + } + ndev = ndev.getNext(); + } + if (!found) { + // remove device from bus an increment changes + if (dev.getPrev() != null) { + dev.getPrev().setNext(dev.getNext()); + } else { + bus.setDevices(dev.getNext()); + } + if (dev.getNext() != null) { + dev.getNext().setPrev(dev.getPrev()); + } + changes++; + } else { + found = false; + } + dev = dev.getNext(); + } + bus = bus.getNext(); + } + // Add new Devices + bus = busses; + while (devices != null) { + ndev = devices.getNext(); + // find correct bus + tmpBusNumber = (long) LibusbJava1.libusb_get_bus_number(devices); + while (bus != null) { + if (bus.getLocation() == tmpBusNumber) { + break; + } + bus = bus.getNext(); + } + // insert device + if (bus != null) { + if (bus.getDevices() == null) { + devices.setNext(null); + } else { + devices.setNext(bus.getDevices()); + devices.getNext().setPrev(devices); + } + devices.setPrev(null); + bus.setDevices(devices); + devices.setBus(bus); + changes++; + } + devices = ndev; + bus = busses; + } + return changes; + } /** * usb_get_busses returns a tree of descriptor objects.
@@ -87,7 +269,9 @@ public class LibusbJava { * @return the structure of all busses and devices. Note: The * java objects are copies of the C structs. */ - public static native Usb_Bus usb_get_busses(); + public static Usb_Bus usb_get_busses() { + return busses; + } // Device Operations /** @@ -100,17 +284,22 @@ public class LibusbJava { * @return a handle used in future communication with the device. 0 if an * error has occurred. */ - public static native long usb_open(Usb_Device dev); + public static long usb_open(Usb_Device dev) { +// return LibusbJava1.libusb_open_device_with_vid_pid(defaultCTX, dev.getDescriptor().getIdVendor(), dev.getDescriptor().getIdProduct()); + return LibusbJava1.libusb_open(dev); + } /** - * usb_close closes a device opened with - * usb_open. + * usb_close closes a device opened with usb_open. * * @param dev_handle * The handle to the device. - * @return 0 on success or < 0 on error. + * @return 0 */ - public static native int usb_close(long dev_handle); + public static int usb_close(long dev_handle) { + LibusbJava1.libusb_close(dev_handle); + return 0; + } /** * Sets the active configuration of a device @@ -122,8 +311,9 @@ public class LibusbJava { * bConfigurationValue. * @return 0 on success or < 0 on error. */ - public static native int usb_set_configuration(long dev_handle, - int configuration); + public static int usb_set_configuration(long dev_handle, int configuration) { + return LibusbJava1.libusb_set_configuration(dev_handle, configuration); + } /** * Sets the active alternate setting of the current interface @@ -135,7 +325,26 @@ public class LibusbJava { * bAlternateSetting. * @return 0 on success or < 0 on error. */ - public static native int usb_set_altinterface(long dev_handle, int alternate); + public static int usb_set_altinterface(long dev_handle, int alternate) { + Usb_Device dev = LibusbJava1.libusb_get_device(dev_handle); + int nofInterfaces = LibusbJava1 + .libusb_get_active_config_descriptor(dev).getBNumInterfaces(); + int interface_number, success = -1; + for (interface_number = 0; interface_number < nofInterfaces; interface_number++) { + success = LibusbJava1.libusb_release_interface(dev_handle, + interface_number); + if (success >= 0) { + success = LibusbJava1.libusb_claim_interface(dev_handle, + interface_number); + if (success < 0) { + return success; + } + break; + } + } + return LibusbJava1.libusb_set_interface_alt_setting(dev_handle, + interface_number, alternate); + } /** * Clears any halt status on an endpoint. @@ -146,27 +355,37 @@ public class LibusbJava { * The value specified in the descriptor field bEndpointAddress. * @return 0 on success or < 0 on error. */ - public static native int usb_clear_halt(long dev_handle, int ep); + public static int usb_clear_halt(long dev_handle, int ep) { + + return LibusbJava1.libusb_clear_halt(dev_handle, (short) ep); + } /** * Resets a device by sending a RESET down the port it is connected to.
*
- * Causes re-enumeration: After calling usb_reset, - * the device will need to re-enumerate and thusly, requires you to find the - * new device and open a new handle. The handle used to call + * Causes re-enumeration: After calling usb_reset, the + * device will need to re-enumerate and thusly, requires you to find the new + * device and open a new handle. The handle used to call * usb_reset will no longer work. * * @param dev_handle * The handle to the device. * @return 0 on success or < 0 on error. */ - public static native int usb_reset(long dev_handle); + public static int usb_reset(long dev_handle) { + LibusbJava1.libusb_claim_interface(dev_handle, 0); + int res = LibusbJava1.libusb_reset_device(dev_handle); + LibusbJava1.libusb_release_interface(dev_handle, 0); + LibusbJava1.libusb_close(dev_handle); + return res; + + } /** * Claim an interface of a device.
*
- * Must be called!: usb_claim_interface must be - * called before you perform any operations related to this interface (like + * Must be called!: usb_claim_interface must be called + * before you perform any operations related to this interface (like * usb_set_altinterface, usb_bulk_write, etc). * * @param dev_handle @@ -176,7 +395,9 @@ public class LibusbJava { * bInterfaceNumber. * @return 0 on success or < 0 on error. */ - public static native int usb_claim_interface(long dev_handle, int interface_); + public static int usb_claim_interface(long dev_handle, int interface_) { + return LibusbJava1.libusb_claim_interface(dev_handle, interface_); + } /** * Releases a previously claimed interface @@ -188,8 +409,9 @@ public class LibusbJava { * bInterfaceNumber. * @return 0 on success or < 0 on error. */ - public static native int usb_release_interface(long dev_handle, - int interface_); + public static int usb_release_interface(long dev_handle, int interface_) { + return LibusbJava1.libusb_release_interface(dev_handle, interface_); + } // Control Transfers /** @@ -207,9 +429,12 @@ public class LibusbJava { * @param timeout * @return the number of bytes written/read or < 0 on error. */ - public static native int usb_control_msg(long dev_handle, int requesttype, + public static int usb_control_msg(long dev_handle, int requesttype, int request, int value, int index, byte[] bytes, int size, - int timeout); + int timeout) { + return LibusbJava1.libusb_control_transfer(dev_handle, requesttype, + request, value, index, bytes, size, timeout); + } /** * Retrieves the string descriptor specified by index and langid from a @@ -221,8 +446,10 @@ public class LibusbJava { * @param langid * @return the descriptor String or null */ - public static native String usb_get_string(long dev_handle, int index, - int langid); + public static String usb_get_string(long dev_handle, int index, int langid) { + + return LibusbJava1.libusb_get_string_descriptor(dev_handle, (short) index, langid, 255); + } /** * usb_get_string_simple is a wrapper around @@ -234,7 +461,9 @@ public class LibusbJava { * @param index * @return the descriptor String or null */ - public static native String usb_get_string_simple(long dev_handle, int index); + public static String usb_get_string_simple(long dev_handle, int index) { + return LibusbJava1.libusb_get_string_descriptor_ascii(dev_handle,(short) index, 255); + } /** * Retrieves a descriptor from the device identified by the type and index @@ -252,8 +481,10 @@ public class LibusbJava { * resulting String) * @return the descriptor String or null */ - public static native String usb_get_descriptor(long dev_handle, byte type, - byte index, int size); + public static byte[] usb_get_descriptor(long dev_handle, byte type, + byte index, int size) { + return LibusbJava1.libusb_get_descriptor(dev_handle, type, index, size); + } /** * Retrieves a descriptor from the device identified by the type and index @@ -269,8 +500,24 @@ public class LibusbJava { * resulting String) * @return the descriptor String or null */ - public static native String usb_get_descriptor_by_endpoint(long dev_handle, - int ep, byte type, byte index, int size); + public static String usb_get_descriptor_by_endpoint(long dev_handle, + int ep, byte type, byte index, int size) { + + // We just send a control message directly; + byte data[] = new byte[size]; + char string[] = new char[size]; + int transfered; + transfered = LibusbJava1.libusb_control_transfer(dev_handle, + 0x80 | (ep & 0xFF), 0x07, (type << 8) | index, 0, data, size, + 1000); + if (transfered > 0) { + for (int i = 0; i < transfered; i++) { + string[i] = (char) data[i]; + } + return String.valueOf(string); + } + return null; + } // Bulk Transfers /** @@ -284,8 +531,11 @@ public class LibusbJava { * @param timeout * @return the number of bytes written on success or < 0 on error. */ - public static native int usb_bulk_write(long dev_handle, int ep, - byte[] bytes, int size, int timeout); + public static int usb_bulk_write(long dev_handle, int ep, byte[] bytes, + int size, int timeout) { + return LibusbJava1.libusb_bulk_transfer(dev_handle, (byte) ep, bytes, + size, timeout); + } /** * Performs a bulk read request to the endpoint specified by ep. @@ -298,8 +548,11 @@ public class LibusbJava { * @param timeout * @return the number of bytes read on success or < 0 on error. */ - public static native int usb_bulk_read(long dev_handle, int ep, - byte[] bytes, int size, int timeout); + public static int usb_bulk_read(long dev_handle, int ep, byte[] bytes, + int size, int timeout) { + return LibusbJava1.libusb_bulk_transfer(dev_handle, (byte) ep, bytes, + size, timeout); + } // Interrupt Transfers /** @@ -313,8 +566,11 @@ public class LibusbJava { * @param timeout * @return the number of bytes written on success or < 0 on error. */ - public static native int usb_interrupt_write(long dev_handle, int ep, - byte[] bytes, int size, int timeout); + public static int usb_interrupt_write(long dev_handle, int ep, + byte[] bytes, int size, int timeout) { + return LibusbJava1.libusb_interrupt_transfer(dev_handle, (byte) ep, + bytes, size, timeout); + } /** * Performs a interrupt read request to the endpoint specified by ep. @@ -327,52 +583,19 @@ public class LibusbJava { * @param timeout * @return the number of bytes read on success or < 0 on error. */ - public static native int usb_interrupt_read(long dev_handle, int ep, - byte[] bytes, int size, int timeout); + public static int usb_interrupt_read(long dev_handle, int ep, byte[] bytes, + int size, int timeout) { + return LibusbJava1.libusb_interrupt_transfer(dev_handle, (byte) ep, + bytes, size, timeout); + } /** * Returns the error string after an error occured. * * @return the last error sring. */ - public static native String usb_strerror(); - - /** **************************************************************** */ - - /** - * Maps the Java error code to the system error code.
- *
- * Note that not all error codes are be mapped by this method. For more - * error codes see the file 'errno.h' on your system.
- *
- * 1: EBADF: Bad file descriptor.
- * 2: ENXIO: No such device or address.
- * 3: EBUSY: Device or resource busy.
- * 4: EINVAL: Invalid argument.
- * 5: ETIMEDOUT: Connection timed out.
- * 6: EIO: I/O error.
- * 7: ENOMEM: Not enough memory.
- * - * - * @return the system error code or 100000 if no mapping has been found. - */ - private static native int usb_error_no(int value); - - static { - String os = System.getProperty("os.name"); - if (os.contains("Windows")) { - System.loadLibrary("LibusbJava"); - } else { - System.loadLibrary("usbJava"); - } - // define the error codes - ERROR_SUCCESS = 0; - ERROR_BAD_FILE_DESCRIPTOR = -usb_error_no(1); - ERROR_NO_SUCH_DEVICE_OR_ADDRESS = -usb_error_no(2); - ERROR_BUSY = -usb_error_no(3); - ERROR_INVALID_PARAMETER = -usb_error_no(4); - ERROR_TIMEDOUT = -usb_error_no(5); - ERROR_IO_ERROR = -usb_error_no(6); - ERROR_NOT_ENOUGH_MEMORY = -usb_error_no(7); + public static String usb_strerror() { + return LibusbJava1.libusb_strerror(); } + } \ No newline at end of file diff --git a/java/src/ch/ntb/inf/libusbJava/LibusbJava1.java b/java/src/ch/ntb/inf/libusbJava/LibusbJava1.java new file mode 100644 index 0000000..b463f93 --- /dev/null +++ b/java/src/ch/ntb/inf/libusbJava/LibusbJava1.java @@ -0,0 +1,1339 @@ +/** + * Java libusb1.0 wrapper + * Roger Millischer + * + * This library is covered by the LGPL, read LGPL.txt for details. + */ +package ch.ntb.inf.libusbJava; + +/** + * This class represents the Java Native Interface to the shared library which + * is (with some exceptions) a one-to-one representation of the libusb1.0 API.
+ *
+ *

Project Description

Java libusb1.0 is a Java wrapper for the + * libusb1.0 USB library. + * + * libusb aim is to create a library for + * use by user level applications to access USB devices regardless of OS.
+ * Libusb-Windows + * backend aim of this project is to bring a Windows backend to the mainline + * libusb 1.0 branch, so that libusb 1.0 can easily be used on Windows + * platforms. The library allows user space applications to access any USB + * device on Windows in a generic way without writing any line of kernel driver + * code.
+ *
+ * The API description of this class has been copied from the libusb-1.0 API + * Reference and adapted where neccessary.
+ * + */ +public class LibusbJava1 { + + /** + * System error codes.
+ * This list is not complete! For more error codes see the file 'errorno.h' + * on your system. + */ + public static final int LIBUSB_SUCCESS = 0; + public static final int LIBUSB_ERROR_IO = -1; + public static final int LIBUSB_ERROR_INVALID_PARAM = -2; + public static final int LIBUSB_ERROR_ACCESS = -3; + public static final int LIBUSB_ERROR_NO_DEVICE = -4; + public static final int LIBUSB_ERROR_NOT_FOUND = -5; + public static final int LIBUSB_ERROR_BUSY = -6; + public static final int LIBUSB_ERROR_TIMEOUT = -7; + public static final int LIBUSB_ERROR_OVERFLOW = -8; + public static final int LIBUSB_ERROR_PIPE = -9; + public static final int LIBUSB_ERROR_INTERRUPTED = -10; + public static final int LIBUSB_ERROR_NO_MEM = -11; + public static final int LIBUSB_ERROR_NOT_SUPPORTED = -12; + public static final int LIBUSB_ERROR_OTHER = -99; + + /** + * Set message verbosity. + *
    + *
  • Level 0: no messages ever printed by the library (default)
    • + *
  • Level 1: error messages are printed to stderr
    • + *
  • Level 2: warning and error messages are printed to stderr
    • + *
  • Level 3: informational messages are printed to stdout, warning and + * error messages are printed to stderr
    • + *
+ * + * The default level is 0, which means no messages are ever printed. If you + * choose to increase the message verbosity level, ensure that your + * application does not close the stdout/stderr file descriptors.
+ *
+ * You are advised to set level 3. libusb is conservative with its message + * logging and most of the time, will only log messages that explain error + * conditions and other oddities. This will help you debug your software.
+ *
+ * If the LIBUSB_DEBUG environment variable was set when libusb was + * initialized, this function does nothing: the message verbosity is fixed + * to the value in the environment variable.
+ *
+ * If libusb was compiled without any message logging, this function does + * nothing: you'll never get any messages.
+ *
+ * If libusb was compiled with verbose debug message logging, this function + * does nothing: you'll always get messages from all levels.
+ *
+ * + * @param ctx + * the context to operate on, or NULL for the default context + * @param level + * debug level to set + */ + + public static native void libusb_set_debug(long ctx, int level); + + /** + * Initialize libusb.
+ *
+ * This function must be called before calling any other libusb function.
+ *
+ * + * @return a context to operate on
+ * or a LIBUSB_ERROR code on failure + */ + public static native long libusb_init(); + + /** + * Deinitialize libusb.
+ *
+ * Should be called after closing all open devices and before your + * application terminates.
+ *
+ * + * @param ctx + * the context to deinitialize, or NULL for the default context + */ + public static native void libusb_exit(long ctx); + + /** + * Returns a list of USB devices currently attached to the system.
+ *
+ * This is your entry point into finding a USB device to operate.
+ *
+ * + * @param ctx + * the context to operate on, or NULL for the default context + * + * @return Usb_Devices currently attached to the system
+ * if no device is attached the devnum of the returned device is set + * to -1
+ * or NULL if a failure occurs + */ + public static native Usb_Device libusb_get_device_list(long ctx); + + /** + * Get the number of the bus that a device is connected to. + * + * @param dev a device + * @return the bus number + */ + public static native short libusb_get_bus_number(Usb_Device dev); + + /** + * Calculate the maximum packet size which a specific endpoint is capable is + * sending or receiving in the duration of 1 microframe.
+ *
+ * Only the active configution is examined. The calculation is based on the + * wMaxPacketSize field in the endpoint descriptor as described in section + * 9.6.6 in the USB 2.0 specifications.
+ *
+ * If acting on an isochronous or interrupt endpoint, this function will + * multiply the value found in bits 0:10 by the number of transactions per + * microframe (determined by bits 11:12). Otherwise, this function just + * returns the numeric value found in bits 0:10.
+ *
+ * This function is useful for setting up isochronous transfers, for example + * you might pass the return value from this function to + * libusb_set_iso_packet_lengths() in order to set the length + * field of every isochronous packet in a transfer.
+ *
+ * Since libusb v1.0.3.
+ *
+ * This functionality is not available on Windows-Systems
+ *
+ * + * @param dev + * a device + * @param endpoint + * address of the endpoint in question + * @return the maximum packet size which can be sent/received on this + * endpoint
+ * LIBUSB_ERROR_NOT_FOUND if the endpoint does not exist
+ * LIBUSB_ERROR_OTHER on other failure
+ * TODO wenn funktion impl. richtig verlinken @see + * libusb_set_iso_packet_lengths() + */ + + public static native int libusb_get_max_iso_packet_size(Usb_Device dev, + short endpoint); + + /** + * Increment the reference count of a device. + * + * @param dev + * the device to reference + * @return the same device + */ + public static native Usb_Device libusb_ref_device(Usb_Device dev); + + /** + * Decrement the reference count of a device.
+ *
+ * If the decrement operation causes the reference count to reach zero, the + * device shall be destroyed.
+ *
+ * + * @param dev + * the device to unreference + */ + + public static native void libusb_unref_device(Usb_Device dev); + + /** + * Open a device and obtain a device handle.
+ *
+ * A handle allows you to perform I/O on the device in question.
+ *
+ * Internally, this function adds a reference to the device and makes it + * available to you through libusb_get_device(). This reference + * is removed during libusb_close().
+ *
+ * This is a non-blocking function; no requests are sent over the bus.
+ *
+ * + * @param dev + * the device to open + * + * @return a device handler + * + * @see #libusb_get_device(long) + */ + public static native long libusb_open(Usb_Device dev); + + /** + * Convenience function for finding a device with a particular + * idVendor/idProduct combination.
+ *
+ * This function is intended for those scenarios where you are using libusb + * to knock up a quick test application - it allows you to avoid calling + * libusb_get_device_list() and worrying about + * traversing/freeing the list.
+ *
+ * This function has limitations and is hence not intended for use in real + * applications: if multiple devices have the same IDs it will only give you + * the first one, etc.
+ * + * @param ctx + * the context to operate on, or NULL for the default context + * @param vendor_id + * the idVendor value to search for + * @param product_id + * the idProduct value to search for + * @return a handle for the first found device, or NULL on error or if the + * device could not be found. + * @see #libusb_get_device_list(long) + */ + public static native long libusb_open_device_with_vid_pid(long ctx, + int vendor_id, int product_id); + + /** + * Close a device handle.
+ *
+ * Should be called on all open handles before your application exits.
+ *
+ * Internally, this function destroys the reference that was added by + * libusb_open() on the given device.
+ *
+ * This is a non-blocking function; no requests are sent over the bus.
+ *
+ * + * @param dev_handle + * the handle to close + */ + public static native void libusb_close(long dev_handle); + + /** + * Get the underlying device for a handle.
+ *
+ * This function does not modify the reference count of the returned device, + * so do not feel compelled to unreference it when you are done.
+ *
+ * + * @param dev_handle + * a device handle + * @return the underlying {@link Usb_Device} + */ + public static native Usb_Device libusb_get_device(long dev_handle); + + /** + * Determine the bConfigurationValue of the currently active configuration.
+ *
+ * You could formulate your own control request to obtain this information, + * but this function has the advantage that it may be able to retrieve the + * information from operating system caches (no I/O involved).
+ *
+ * If the OS does not cache this information, then this function will block + * while a control transfer is submitted to retrieve the information.
+ *
+ * This function will return a value of 0 if the device is in unconfigured + * state.
+ *
+ * + * @param dev_handle + * a device handle + * @return bConfigurationValue of the currently active configuration + * + */ + public static native byte libusb_get_configuration(long dev_handle); + + /** + * Set the active configuration for a device.
+ *
+ * The operating system may or may not have already set an active + * configuration on the device. It is up to your application to ensure the + * correct configuration is selected before you attempt to claim interfaces + * and perform other operations.
+ *
+ * If you call this function on a device already configured with the + * selected configuration, then this function will act as a lightweight + * device reset: it will issue a SET_CONFIGURATION request using the current + * configuration, causing most USB-related device state to be reset + * (altsetting reset to zero, endpoint halts cleared, toggles reset).
+ *
+ * You cannot change/reset configuration if your application has claimed + * interfaces - you should free them with + * {@link #libusb_release_interface(long, int)} first. You cannot + * change/reset configuration if other applications or drivers have claimed + * interfaces.
+ *
+ * A configuration value of -1 will put the device in unconfigured state. + * The USB specifications state that a configuration value of 0 does this, + * however buggy devices exist which actually have a configuration 0.
+ *
+ * You should always use this function rather than formulating your own + * SET_CONFIGURATION control request. This is because the underlying + * operating system needs to know when such changes happen.
+ *
+ * This is a blocking function.
+ *
+ * + * @param dev_handle + * a device handle + * @param configuration + * the bConfigurationValue of the configuration you wish to + * activate, or -1 if you wish to put the device in unconfigured + * state + * @return 0 on success
+ * LIBUSB_ERROR_NOT_FOUND if the requested configuration does not + * exist
+ * LIBUSB_ERROR_BUSY if interfaces are currently claimed
+ * LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * another LIBUSB_ERROR code on other failure
+ */ + public static native int libusb_set_configuration(long dev_handle, + int configuration); + + /** + * Claim an interface on a given device handle.
+ *
+ * You must claim the interface you wish to use before you can perform I/O + * on any of its endpoints.
+ *
+ * It is legal to attempt to claim an already-claimed interface, in which + * case libusb just returns 0 without doing anything.
+ *
+ * Claiming of interfaces is a purely logical operation, it does not cause + * any requests to be sent over the bus. Interface claiming is used to + * instruct the underlying operating system that your application wishes to + * take ownership of the interface.
+ *
+ * This is a non-blocking function.
+ *
+ * + * @param dev_handle + * a device handle + * @param interface_number + * the bInterfaceNumber of the interface you wish to claim + * @return 0 on success
+ * LIBUSB_ERROR_NOT_FOUND if the interface was not claimed
+ * LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * LIBUSB_ERROR_BUSY if another program or driver has claimed the + * interface
+ * another LIBUSB_ERROR code on other failure
+ */ + public static native int libusb_claim_interface(long dev_handle, + int interface_number); + + /** + * Release an interface previously claimed with + * {@link #libusb_claim_interface(long, int)}.
+ *
+ * You should release all claimed interfaces before closing a device handle.
+ *
+ * This is a blocking function. A SET_INTERFACE control request will be sent + * to the device, resetting interface state to the first alternate setting.
+ *
+ * + * @param dev_handle + * a device handle + * @param interface_number + * the bInterfaceNumber of the previously-claimed interface + * @return 0 on success
+ * LIBUSB_ERROR_NOT_FOUND if the interface was not claimed
+ * LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * another LIBUSB_ERROR code on other failure
+ */ + public static native int libusb_release_interface(long dev_handle, + int interface_number); + + /** + * Activate an alternate setting for an interface.
+ *
+ * The interface must have been previously claimed with + *{@link #libusb_claim_interface(long, int)}.
+ *
+ * You should always use this function rather than formulating your own + * SET_INTERFACE control request. This is because the underlying operating + * system needs to know when such changes happen.
+ *
+ * This is a blocking function.
+ *
+ * + * @param dev_handle + * a device handle + * @param interface_number + * the bInterfaceNumber of the previously-claimed interface + * @param alternate_setting + * the bAlternateSetting of the alternate setting to activate + * @return 0 on success
+ * LIBUSB_ERROR_NOT_FOUND if the interface was not claimed, or the + * requested alternate setting does not exist
+ * LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * another LIBUSB_ERROR code on other failure
+ */ + public static native int libusb_set_interface_alt_setting(long dev_handle, + int interface_number, int alternate_setting); + + /** + * Clear the halt/stall condition for an endpoint.
+ *
+ * Endpoints with halt status are unable to receive or transmit data until + * the halt condition is stalled.
+ *
+ * You should cancel all pending transfers before attempting to clear the + * halt condition.
+ *
+ * This is a blocking function.
+ *
+ * + * @param dev_handle + * a device handle + * @param endpoint + * the endpoint to clear halt status + * @return 0 on success
+ * LIBUSB_ERROR_NOT_FOUND if the endpoint does not exist
+ * LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * another LIBUSB_ERROR code on other failure
+ */ + public static native int libusb_clear_halt(long dev_handle, short endpoint); + + /** + * Perform a USB port reset to reinitialize a device.
+ *
+ * The system will attempt to restore the previous configuration and + * alternate settings after the reset has completed.
+ *
+ * If the reset fails, the descriptors change, or the previous state cannot + * be restored, the device will appear to be disconnected and reconnected. + * This means that the device handle is no longer valid (you should close + * it) and rediscover the device. A return code of LIBUSB_ERROR_NOT_FOUND + * indicates when this is the case.
+ *
+ * This is a blocking function which usually incurs a noticeable delay.
+ *
+ * + * @param dev_handle + * a handle of the device to reset + * @return 0 on success
+ * LIBUSB_ERROR_NOT_FOUND if re-enumeration is required, or if the + * device has been disconnected
+ * another LIBUSB_ERROR code on other failure
+ */ + public static native int libusb_reset_device(long dev_handle); + + /** + * Determine if a kernel driver is active on an interface.
+ *
+ * If a kernel driver is active, you cannot claim the interface, and libusb + * will be unable to perform I/O.
+ *
+ * + * @param dev_handle + * a device handle + * @param interface_number + * the interface to check + * @return 0 if no kernel driver is active
+ * 1 if a kernel driver is active
+ * LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * another LIBUSB_ERROR code on other failure
+ * @see #libusb_detach_kernel_driver(long, int) + */ + public static native int libusb_kernel_driver_active(long dev_handle, + int interface_number); + + /** + * Detach a kernel driver from an interface.
+ *
+ * If successful, you will then be able to claim the interface and perform + * I/O.
+ *
+ * + * @param dev_handle + * a device handle + * @param interface_number + * the interface to detach the driver from + * @return 0 on success
+ * LIBUSB_ERROR_NOT_FOUND if no kernel driver was active
+ * LIBUSB_ERROR_INVALID_PARAM if the interface does not exist
+ * LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * another LIBUSB_ERROR code on other failure
+ * @see #libusb_kernel_driver_active(long, int) + */ + public static native int libusb_detach_kernel_driver(long dev_handle, + int interface_number); + + /** + * Re-attach an interface's kernel driver, which was previously detached + * using {@link #libusb_detach_kernel_driver(long, int)}.
+ * + * @param dev_handle + * a device handle + * @param interface_number + * the interface to attach the driver from + * @return 0 on success
+ * LIBUSB_ERROR_NOT_FOUND if no kernel driver was active
+ * LIBUSB_ERROR_INVALID_PARAM if the interface does not exist
+ * LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * LIBUSB_ERROR_BUSY if the driver cannot be attached because the + * interface is claimed by a program or driver
+ * another LIBUSB_ERROR code on other failure
+ * @see #libusb_kernel_driver_active(long, int) + */ + public static native int libusb_attach_kernel_driver(long dev_handle, + int interface_number); + + /** + * Get the USB configuration descriptor for the currently active + * configuration.
+ *
+ * This is a non-blocking function which does not involve any requests being + * sent to the device.
+ *
+ * + * @param dev + * a device + * @return {@link Usb_Config_Descriptor} + */ + public static native Usb_Config_Descriptor libusb_get_active_config_descriptor( + Usb_Device dev); + + /** + * Retrieve a string descriptor in C style ASCII.
+ *
+ * Wrapper around + * {@link #libusb_get_string_descriptor(long, short, int, int)}. Uses the + * first language supported by the device. + * + * @param dev_handle + * a device handle + * @param desc_index + * the index of the descriptor to retrieve + * @param size + * number of charactes which will be retrieved (the length of the + * resulting String) + * @return a string which contains the string descriptor + */ + public static native String libusb_get_string_descriptor_ascii( + long dev_handle, short desc_index, int size); + + /** + * Retrieve a descriptor from the default control pipe.
+ *
+ * This is a convenience function which formulates the appropriate control + * message to retrieve the descriptor. + * + * @param dev_handle + * a device handle + * @param desc_type + * the descriptor type + * @param desc_index + * the index of the descriptor to retrieve + * @param size + * number of bytes which will be retrieved (the length of the + * resulting byte[]) + * @return a byte[] which contains the descriptor or null on failure + * + */ + public static native byte[] libusb_get_descriptor(long dev_handle, + int desc_type, short desc_index, int size); + + /** + * Retrieve a descriptor from a device.
+ *
+ * This is a convenience function which formulates the appropriate control + * message to retrieve the descriptor. The string returned is Unicode, as + * detailed in the USB specifications. + * + * @param dev_handle + * a device handle + * @param desc_index + * the index of the descriptor to retrieve + * @param langid + * the language ID for the string descriptor + * @param size + * number of charactes which will be retrieved (the length of the + * resulting String) + * @return a string which contains the string descriptor + * @see #libusb_get_string_descriptor_ascii(long, short, int) + */ + public static native String libusb_get_string_descriptor(long dev_handle, + short desc_index, int langid, int size); + + /** + * Allocate a libusb transfer with a specified number of isochronous packet + * descriptors.
+ * + * The returned transfer is pre-initialized for you. When the new transfer + * is no longer needed, it should be freed with + * libusb_free_transfer().
+ *
+ * Transfers intended for non-isochronous endpoints (e.g. control, bulk, + * interrupt) should specify an iso_packets count of zero.
+ *
+ * For transfers intended for isochronous endpoints, specify an appropriate + * number of packet descriptors to be allocated as part of the transfer. The + * returned transfer is not specially initialized for isochronous I/O you + * are still required to set the num_iso_packets and type + * fields accordingly.
+ *
+ * It is safe to allocate a transfer with some isochronous packets and then + * use it on a non-isochronous endpoint. If you do this, ensure that at time + * of submission, num_iso_packets is 0 and that type is set appropriately.
+ * + * @param iso_packets + * number of isochronous packet descriptors to allocate + * @return a newly allocated transfernumber, or NULL on error + */ + public static native long libusb_alloc_transfer(int iso_packets); + + /** + * Free a transfer. + * + * This should be called for all transfers allocated with + * libusb_alloc_transfer().
+ *
+ * It is legal to call this function with a NULL transfer. In this case, the + * function will simply return safely.
+ *
+ * It is not legal to free an active transfer (one which has been submitted + * and has not yet completed).
+ *
+ * + * @param transfernumber + * the transfer to free + */ + public static native void libusb_free_transfer(long transfernumber); + + /** + * Submit a transfer.
+ *
+ * This function will fire off the USB transfer and then return immediately.
+ *
+ * + * @param transfernumber + * the transfer to submit + * @return 0 on success
+ * LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * LIBUSB_ERROR_BUSY if the transfer has already been submitted.
+ * another LIBUSB_ERROR code on other failure
+ */ + public static native int libusb_submit_transfer(long transfernumber); + + /** + * Asynchronously cancel a previously submitted transfer.
+ *
+ * This function returns immediately, but this does not indicate + * cancellation is complete. Libusb_event will be invoked at some later time + * to notify you. + * + * @param transfernumber + * a transfer + * @return 0 on success
+ * LIBUSB_ERROR_NOT_FOUND if the transfer is already complete or + * cancelled.
+ * a LIBUSB_ERROR code on failure
+ */ + public static native int libusb_cancel_transfer(long transfernumber); + + /** + * Get the data section of a control transfer.
+ *
+ * This convenience function is here to remind you that the data does not + * start until 8 bytes into the actual buffer, as the setup packet comes + * first.
+ *
+ * Calling this function only makes sense from a transfer event handler, or + * situations where you have already allocated a suitably sized buffer. + * + * @param transfernumber + * a transfer + * @return the data section from the transfer + */ + public static native byte[] libusb_control_transfer_get_data( + long transfernumber); + + /** + * Get the control setup packet of a control transfer.
+ *
+ * This convenience function is here to remind you that the control setup + * occupies the first 8 bytes of the transfer data buffer.
+ *
+ * Calling this function only makes sense from a transfer event handler, or + * situations where you have already allocated a suitably sized buffer at + * transfer->buffer. + * + * @param transfernumber + * a transfer + * @return the setup packet from the transfer + */ + public static native byte[] libusb_control_transfer_get_setup( + long transfernumber); + + /** + * Helper function to populate the setup packet (first 8 bytes of the data + * buffer) for a control transfer.
+ * + * @param bmRequestType + * @param bRequest + * @param wValue + * @param wIndex + * @param wLength + * @return the setup packet + */ + public static native byte[] libusb_fill_control_setup(int bmRequestType, + int bRequest, int wValue, int wIndex, int wLength); + + /** + * Helper function to populate the required libusb_transfer fields for a + * control transfer.
+ *
+ * If you pass a transfer buffer to this function, the first 8 bytes will be + * interpreted as a control setup packet, and the wLength field will be used + * to automatically populate the length field of the transfer. Therefore the + * recommended approach is:
+ *
+ * 1. Call libusb_fill_control_setup()
+ * 2. Allocate a suitably sized data buffer (including space for control + * setup)
+ * 3. Put the retrieved setup packet into the firste 8 byte of the data + * buffer.
+ * 4. If this is a host-to-device transfer with a data stage, put the data + * in place after the setup packet
+ * 5. Call this function
+ * 6. Call libusb_submit_transfer()
+ *
+ * It is also legal to pass a NULL buffer to this function, in which case + * this function will not attempt to populate the length field. Remember + * that you must then populate the buffer and length fields later. + * + * @param transfernumber + * transfer to populate + * @param dev_handle + * handle of the device that + * @param buffer + * data buffer. If provided, this function will interpret the + * first 8 bytes as a setup packet and infer the transfer length + * from that. + * @param timeout + * timeout for the transfer in milliseconds + */ + public static native void libusb_fill_control_transfer(long transfernumber, + long dev_handle, byte[] buffer, int timeout); + + /** + * Helper function to populate the required libusb_transfer fields for a + * bulk transfer. + * + * @param transfernumber + * the transfer to populate + * @param dev_handle + * handle of the device that will handle the transfer + * @param endpoint + * address of the endpoint where this transfer will be sent + * @param buffer + * data buffer + * @param length + * length of data buffer + * @param timeout + * timeout for the transfer in milliseconds + */ + public static native void libusb_fill_bulk_transfer(long transfernumber, + long dev_handle, byte endpoint, byte[] buffer, int length, + int timeout); + + /** + * Helper function to populate the required libusb_transfer fields for an + * interrupt transfer. + * + * @param transfernumber + * the transfer to populate + * @param dev_handle + * handle of the device that will handle the transfer + * @param endpoint + * address of the endpoint where this transfer will be sent + * @param buffer + * data buffer + * @param length + * length of data buffer + * @param timeout + * timeout for the transfer in milliseconds + */ + public static native void libusb_fill_interrupt_transfer( + long transfernumber, long dev_handle, byte endpoint, byte[] buffer, + int length, int timeout); + + /** + * Helper function to populate the required libusb_transfer fields for an + * isochronous transfer. + * + * @param transfernumber + * the transfer to populate + * @param dev_handle + * handle of the device that will handle the transfer + * @param endpoint + * address of the endpoint where this transfer will be sent + * @param buffer + * data buffer + * @param length + * length of data buffer + * @param num_iso_packets + * the number of isochronous packets + * @param timeout + * timeout for the transfer in milliseconds + */ + public static native void libusb_fill_iso_transfer(long transfernumber, + long dev_handle, byte endpoint, byte[] buffer, int length, + int num_iso_packets, int timeout); + + /** + * Convenience function to set the length of all packets in an isochronous + * transfer, based on the num_iso_packets field in the transfer structure. + * + * @param transfer + * a transfer + * @param length + * the length to set in each isochronous packet descriptor + */ + public static native void libusb_set_iso_packet_lengths(long transfer, + int length); + + /** + * Convenience function to locate the position of an isochronous packet + * within the buffer of an isochronous transfer.
+ *
+ * This is a thorough function which loops through all preceding packets, + * accumulating their lengths to find the position of the specified packet. + * Typically you will assign equal lengths to each packet in the transfer, + * and hence the above method is sub-optimal. You may wish to use + * libusb_get_iso_packet_buffer_simple() instead.
+ *
+ * + * @param transfer + * a transfer + * @param packet + * the packet to return + * @return the packet buffer inside the transfer buffer, or NULL if the + * packet does not exist + */ + public static native byte[] libusb_get_iso_packet_buffer(long transfer, + int packet); + + /** + * Convenience function to locate the position of an isochronous packet + * within the buffer of an isochronous transfer, for transfers where each + * packet is of identical size.
+ *
+ * This function relies on the assumption that every packet within the + * transfer is of identical size to the first packet. Calculating the + * location of the packet buffer is then just a simple calculation: buffer + + * (packet_size * packet)
+ *
+ * Do not use this function on transfers other than those that have + * identical packet lengths for each packet. + * + * @param transfernumber + * a transfer + * @param packet + * he packet to return + * @return the packet buffer inside the transfer buffer, or NULL if the + * packet does not exist. + */ + public static native byte[] libusb_get_iso_packet_buffer_simple( + long transfernumber, int packet); + + /** + * Attempt to acquire the event handling lock.
+ *
+ * This lock is used to ensure that only one thread is monitoring libusb + * event sources at any one time.
+ *
+ * You only need to use this lock if you are developing an application which + * calls poll() or select() on libusb's file descriptors directly. If you + * stick to libusb's event handling loop functions (e.g. + * libusb_handle_events()) then you do not need to be concerned + * with this locking.
+ *
+ * While holding this lock, you are trusted to actually be handling events. + * If you are no longer handling events, you must call + * libusb_unlock_events() as soon as possible. + * + * @param ctx + * the context to operate on, or NULL for the default context + * @return 0 if the lock was obtained successfully
+ * 1 if the lock was not obtained (i.e. another thread holds the + * lock)
+ */ + public static native int libusb_try_lock_events(long ctx); + + /** + * Acquire the event handling lock, blocking until successful acquisition if + * it is contended.
+ *
+ * This lock is used to ensure that only one thread is monitoring libusb + * event sources at any one time.
+ *
+ * You only need to use this lock if you are developing an application which + * calls poll() or select() on libusb's file descriptors directly. If you + * stick to libusb's event handling loop functions (e.g. + * libusb_handle_events()) then you do not need to be concerned + * with this locking.
+ *
+ * While holding this lock, you are trusted to actually be handling events. + * If you are no longer handling events, you must call + * libusb_unlock_events() as soon as possible. + * + * @param ctx + * the context to operate on, or NULL for the default context + */ + public static native void libusb_lock_events(long ctx); + + /** + * Release the lock previously acquired with + * libusb_try_lock_events() or + * libusb_lock_events().
+ *
+ * Releasing this lock will wake up any threads blocked on + * libusb_wait_for_event(). + * + * @param ctx + * the context to operate on, or NULL for the default context + */ + public static native void libusb_unlock_events(long ctx); + + /** + * Determine if it is still OK for this thread to be doing event handling.
+ *
+ * Sometimes, libusb needs to temporarily pause all event handlers, and this + * is the function you should use before polling file descriptors to see if + * this is the case.
+ *
+ * If this function instructs your thread to give up the events lock, you + * should just continue the usual logic. On the next iteration, your thread + * will fail to obtain the events lock, and will hence become an event + * waiter.
+ *
+ * This function should be called while the events lock is held: you don't + * need to worry about the results of this function if your thread is not + * the current event handler. + * + * @param ctx + * the context to operate on, or NULL for the default context + * @return 1 if event handling can start or continue
+ * 0 if this thread must give up the events lock
+ */ + public static native int libusb_event_handling_ok(long ctx); + + /** + * Determine if an active thread is handling events (i.e. if anyone is + * holding the event handling lock). + * + * @param ctx + * the context to operate on, or NULL for the default context + * @return 1 if a thread is handling events
+ * 0 if there are no threads currently handling events
+ */ + public static native int libusb_event_handler_active(long ctx); + + /** + * Acquire the event waiters lock.
+ *
+ * This lock is designed to be obtained under the situation where you want + * to be aware when events are completed, but some other thread is event + * handling so calling libusb_handle_events() is not allowed.
+ *
+ * You then obtain this lock, re-check that another thread is still handling + * events, then call libusb_wait_for_event().
+ *
+ * You only need to use this lock if you are developing an application which + * calls poll() or select() on libusb's file descriptors directly, and may + * potentially be handling events from 2 threads simultaenously. If you + * stick to libusb's event handling loop functions (e.g. + * libusb_handle_events()) then you do not need to be concerned + * with this locking. + * + * @param ctx + * the context to operate on, or NULL for the default context + */ + public static native void libusb_lock_event_waiters(long ctx); + + /** + * Release the event waiters lock. + * + * @param ctx + * the context to operate on, or NULL for the default context + */ + public static native void libusb_unlock_event_waiters(long ctx); + + /** + * Wait for another thread to signal completion of an event.
+ *
+ * Must be called with the event waiters lock held, see + * libusb_lock_event_waiters().
+ *
+ * This function will block until any of the following conditions are met:
+ * + * 1. The timeout expires
+ * 2. A transfer completes
+ * 3. A thread releases the event handling lock through + * libusb_unlock_events()
+ *
+ * Condition 1 is obvious. Condition 2 unblocks your thread after the + * callback for the transfer has completed. Condition 3 is important because + * it means that the thread that was previously handling events is no longer + * doing so, so if any events are to complete, another thread needs to step + * up and start event handling.
+ *
+ * This function releases the event waiters lock before putting your thread + * to sleep, and reacquires the lock as it is being woken up. + * + * @param ctx + * the context to operate on, or NULL for the default context + * @param timeval + * maximum timeout in seconds for this blocking function. 0 + * seconds indicates unlimited timeout + * @return 0 after a transfer completes or another thread stops event + * handling
+ * 1 if the timeout expired
+ */ + public static native int libusb_wait_for_event(long ctx, long timeval); + + /** + * Handle any pending events.
+ *
+ * libusb determines "pending events" by checking if any timeouts have + * expired and by checking the set of file descriptors for activity.
+ *
+ * If a zero timeval is passed, this function will handle any + * already-pending events and then immediately return in non-blocking style.
+ *
+ * If a non-zero timeval is passed and no events are currently pending, this + * function will block waiting for events to handle up until the specified + * timeout. If an event arrives or a signal is raised, this function will + * return early. + * + * @param ctx + * the context to operate on, or NULL for the default context + * @param timeval + * the maximum time to block waiting for events, or zero for + * non-blocking mode + * @return 0 on success, or a LIBUSB_ERROR code on failure + */ + public static native int libusb_handle_events_timeout(long ctx, long timeval); + + /** + * Handle any pending events in blocking mode with a sensible timeout.
+ *
+ * This timeout is currently hardcoded at 2 seconds but we may change this + * if we decide other values are more sensible. For finer control over + * whether this function is blocking or non-blocking, or the maximum + * timeout, use libusb_handle_events_timeout() instead. + * + * @param ctx + * the context to operate on, or NULL for the default context + * @return 0 on success, or a LIBUSB_ERROR code on failure + */ + public static native int libusb_handle_events(long ctx); + + /** + * Handle any pending events by polling file descriptors, without checking + * if any other threads are already doing so.
+ *
+ * Must be called with the event lock held, see + * libusb_lock_events().
+ *
+ * This function is designed to be called under the situation where you have + * taken the event lock and are calling poll()/select() directly on libusb's + * file descriptors (as opposed to using libusb_handle_events() + * or similar). You detect events on libusb's descriptors, so you then call + * this function with a zero timeout value (while still holding the event + * lock). + * + * @param ctx + * the context to operate on, or NULL for the default context + * @param timeval + * the maximum time in seconds to block waiting for events, or + * zero for non-blocking mode + * @return 0 on success, or a LIBUSB_ERROR code on failure + */ + public static native int libusb_handle_events_locked(long ctx, long timeval); + + /** + * Determines whether your application must apply special timing + * considerations when monitoring libusb's file descriptors.
+ *
+ * This function is only useful for applications which retrieve and poll + * libusb's file descriptors in their own main loop (The more advanced + * option).
+ *
+ * Ordinarily, libusb's event handler needs to be called into at specific + * moments in time (in addition to times when there is activity on the file + * descriptor set). The usual approach is to use + * libusb_get_next_timeout() to learn about when the next + * timeout occurs, and to adjust your poll()/select() timeout accordingly so + * that you can make a call into the library at that time.
+ *
+ * Some platforms supported by libusb do not come with this baggage - any + * events relevant to timing will be represented by activity on the file + * descriptor set, and libusb_get_next_timeout() will always + * return 0. This function allows you to detect whether you are running on + * such a platform.
+ *
+ * Since v1.0.5. + * + * @param ctx + * the context to operate on, or NULL for the default context + * @return 0 if you must call into libusb at times determined by + * libusb_get_next_timeout(), or 1 if all timeout + * events are handled internally or through regular activity on the + * file descriptors. + */ + public static native int libusb_pollfds_handle_timeouts(long ctx); + + /** + * Determine the next internal timeout that libusb needs to handle.
+ *
+ * You only need to use this function if you are calling poll() or select() + * or similar on libusb's file descriptors yourself - you do not need to use + * it if you are calling libusb_handle_events() or a variant directly.
+ *
+ * You should call this function in your main loop in order to determine how + * long to wait for select() or poll() to return results. libusb needs to be + * called into at this timeout, so you should use it as an upper bound on + * your select() or poll() call.
+ *
+ * When the timeout has expired, call into libusb_handle_events_timeout() + * (perhaps in non-blocking mode) so that libusb can handle the timeout.
+ *
+ * This function may return an zero timevalue. If this is the case, it + * indicates that libusb has a timeout that has already expired so you + * should call libusb_handle_events_timeout() or similar immediately. A + * return code of -999 indicates that there are no pending timeouts.
+ *
+ * On some platforms, this function will always returns -999 (no pending + * timeouts). + * + * @param ctx + * the context to operate on, or NULL for the default context + * @return -999 if there are no pending timeouts
+ * time to next timeout
+ * LIBUSB_ERROR_OTHER on failure + */ + public static native int libusb_get_next_timeout(long ctx); + + /** + * Register notification functions for file descriptor additions/removals.
+ *
+ * These functions will be invoked for every new or removed file descriptor + * that libusb uses as an event source.
+ *
+ * To remove notifiers, set remove TRUE.
+ *
+ * Note that file descriptors may have been added even before you register + * these notifiers (e.g. at libusb_init() time).
+ *
+ * Additionally, note that the removal notifier may be called during + * libusb_exit() (e.g. when it is closing file descriptors that + * were opened and added to the poll set at libusb_init() + * time).
+ * If you don't want this, remove the notifiers immediately before calling + * libusb_exit(). + * + * @param ctx + * the context to operate on, or NULL for the default context + * @param remove + * select add or remove notifiers + */ + public static native void libusb_set_pollfd_notifiers(long ctx, + boolean remove); + + /** + * Retrieve a array of file descriptors that should be polled by your main + * loop as libusb event sources.
+ *
+ * + * The actual list contents must not be touched. + * + * @param ctx + * the context to operate on, or NULL for the default context + * @return array of Libusb_pollfd or NULL on error + */ + public static native Libusb_pollfd[] libusb_get_pollfds(long ctx); + + /** + * Perform a USB control transfer.
+ *
+ * The direction of the transfer is inferred from the bmRequestType field of + * the setup packet.
+ *
+ * The wValue, wIndex and wLength fields values should be given in + * host-endian byte order. + * + * @param dev_handle + * a handle for the device to communicate with + * @param bmRequestType + * the request type field for the setup packet + * @param bRequest + * the request field for the setup packet + * @param wValue + * the value field for the setup packet + * @param wIndex + * the index field for the setup packet + * @param data + * a suitably-sized data buffer for either input or output + * (depending on direction bits within bmRequestType) + * @param wLength + * the length field for the setup packet. The data buffer should + * be at least this size. + * @param timeout + * timeout (in millseconds) that this function should wait before + * giving up due to no response being received. For an unlimited + * timeout, use value 0. + * @return on success, the number of bytes actually transferred
+ * LIBUSB_ERROR_TIMEOUT if the transfer timed out
+ * LIBUSB_ERROR_PIPE if the control request was not supported by the + * device
+ * LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * another LIBUSB_ERROR code on other failures + */ + public static native int libusb_control_transfer(long dev_handle, + int bmRequestType, int bRequest, int wValue, int wIndex, + byte[] data, int wLength, int timeout); + + /** + * Perform a USB bulk transfer.
+ *
+ * The direction of the transfer is inferred from the direction bits of the + * endpoint address.
+ *
+ * For bulk reads, the length field indicates the maximum length of data you + * are expecting to receive. If less data arrives than expected, this + * function will return that data, so be sure to check the returned value.
+ *
+ * You should also check this value for bulk writes. Not all of the data may + * have been written. + * + * @param dev_handle + * a handle for the device to communicate with + * @param endpoint + * the address of a valid endpoint to communicate with + * @param data + * a suitably-sized data buffer for either input or output + * (depending on endpoint) + * @param length + * for bulk writes, the number of bytes from data to be sent. for + * bulk reads, the maximum number of bytes to receive into the + * data buffer. + * @param timeout + * timeout (in millseconds) that this function should wait before + * giving up due to no response being received. For an unlimited + * timeout, use value 0. + * @return on success, the number of bytes actually transferred
+ * LIBUSB_ERROR_TIMEOUT if the transfer timed out
+ * LIBUSB_ERROR_PIPE if the control request was not supported by the + * device
+ * LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * another LIBUSB_ERROR code on other failures. + */ + public static native int libusb_bulk_transfer(long dev_handle, + byte endpoint, byte[] data, int length, int timeout); + + /** + * Perform a USB interrupt transfer.
+ *
+ * The direction of the transfer is inferred from the direction bits of the + * endpoint address.
+ *
+ * For bulk reads, the length field indicates the maximum length of data you + * are expecting to receive. If less data arrives than expected, this + * function will return that data, so be sure to check the returned value.
+ *
+ * You should also check this value for bulk writes. Not all of the data may + * have been written.
+ *
+ * The default endpoint bInterval value is used as the polling interval. + * + * @param dev_handle + * a handle for the device to communicate with + * @param endpoint + * the address of a valid endpoint to communicate with + * @param data + * a suitably-sized data buffer for either input or output + * (depending on endpoint) + * @param length + * for bulk writes, the number of bytes from data to be sent. for + * bulk reads, the maximum number of bytes to receive into the + * data buffer. + * @param timeout + * timeout (in millseconds) that this function should wait before + * giving up due to no response being received. For an unlimited + * timeout, use value 0. + * @return on success, the number of bytes actually transferred
+ * LIBUSB_ERROR_TIMEOUT if the transfer timed out
+ * LIBUSB_ERROR_PIPE if the control request was not supported by the + * device
+ * LIBUSB_ERROR_NO_DEVICE if the device has been disconnected
+ * another LIBUSB_ERROR code on other failures + */ + public static native int libusb_interrupt_transfer(long dev_handle, + byte endpoint, byte[] data, int length, int timeout); + + /** + * Returns the error string after an error occured. + * + * @return the last error sring. + */ + public static native String libusb_strerror(); + + static { + String os = System.getProperty("os.name"); + if (os.contains("Windows")) { + System.loadLibrary("LibusbJava-1_0"); + } else { + System.loadLibrary("usbJava-1.0"); + } + } +} diff --git a/java/src/ch/ntb/inf/libusbJava/Libusb_event.java b/java/src/ch/ntb/inf/libusbJava/Libusb_event.java new file mode 100644 index 0000000..5268951 --- /dev/null +++ b/java/src/ch/ntb/inf/libusbJava/Libusb_event.java @@ -0,0 +1,19 @@ +package ch.ntb.inf.libusbJava; + +public class Libusb_event { + + public void transferCallback(){ + + } + + public void fdAddedCallback(int fd){ + System.out.println("addedCallback"); + + } + + public void fdRemovedCallback(int fd){ + System.out.println("removedCallback"); + + } + +} diff --git a/java/src/ch/ntb/inf/libusbJava/Libusb_pollfd.java b/java/src/ch/ntb/inf/libusbJava/Libusb_pollfd.java new file mode 100644 index 0000000..64c2552 --- /dev/null +++ b/java/src/ch/ntb/inf/libusbJava/Libusb_pollfd.java @@ -0,0 +1,7 @@ +package ch.ntb.inf.libusbJava; + +public class Libusb_pollfd { + int fd; + byte events; + +} diff --git a/java/src/ch/ntb/inf/libusbJava/Usb_Bus.java b/java/src/ch/ntb/inf/libusbJava/Usb_Bus.java index 7e00096..6930ee7 100644 --- a/java/src/ch/ntb/inf/libusbJava/Usb_Bus.java +++ b/java/src/ch/ntb/inf/libusbJava/Usb_Bus.java @@ -25,6 +25,11 @@ public class Usb_Bus { private Usb_Device root_dev; + public Usb_Bus(String dirname, long location) { + this.dirname = dirname; + this.location = location; + } + /** * Get the first device ojects of the devices linked list.
* @@ -34,6 +39,10 @@ public class Usb_Bus { return devices; } + protected void setDevices(Usb_Device devices) { + this.devices = devices; + } + /** * Returns the systems String representation of the bus.
* @@ -52,6 +61,10 @@ public class Usb_Bus { return next; } + protected void setNext(Usb_Bus bus) { + next = bus; + } + /** * Returns the previous bus object.
* @@ -61,6 +74,10 @@ public class Usb_Bus { return prev; } + protected void setPrev(Usb_Bus bus) { + prev = bus; + } + /** * Get the root device of this bus.
* @@ -79,6 +96,10 @@ public class Usb_Bus { return location; } + protected void setLocation(long busnumber) { + location = busnumber; + } + @Override public String toString() { return "Usb_Bus " + dirname; diff --git a/java/src/ch/ntb/inf/libusbJava/Usb_Descriptor.java b/java/src/ch/ntb/inf/libusbJava/Usb_Descriptor.java index e08f6e1..10e183e 100644 --- a/java/src/ch/ntb/inf/libusbJava/Usb_Descriptor.java +++ b/java/src/ch/ntb/inf/libusbJava/Usb_Descriptor.java @@ -23,7 +23,9 @@ public class Usb_Descriptor { /** * Descriptor types ({@link #bDescriptorType}). */ - public static final int USB_DT_HID = 0x21, USB_DT_REPORT = 0x22, + public static final int LIBUSB_DT_DEVICE = 0x01, LIBUSB_DT_CONFIG = 0x02, + LIBUSB_DT_STRING = 0x03, LIBUSB_DT_INTERFACE = 0x04, + LIBUSB_DT_ENDPOINT = 0x05, USB_DT_HID = 0x21, USB_DT_REPORT = 0x22, USB_DT_PHYSICAL = 0x23, USB_DT_HUB = 0x29; /** diff --git a/java/src/ch/ntb/inf/libusbJava/Usb_Device.java b/java/src/ch/ntb/inf/libusbJava/Usb_Device.java index 7a3cdd3..4612176 100644 --- a/java/src/ch/ntb/inf/libusbJava/Usb_Device.java +++ b/java/src/ch/ntb/inf/libusbJava/Usb_Device.java @@ -45,6 +45,9 @@ public class Usb_Device { public Usb_Bus getBus() { return bus; } + protected void setBus(Usb_Bus bus){ + this.bus = bus; + } /** * Returns a reference to the first child.
@@ -99,6 +102,10 @@ public class Usb_Device { public Usb_Device getNext() { return next; } + + protected void setNext(Usb_Device dev){ + next = dev; + } /** * Returns the number of children of this device.
@@ -117,6 +124,9 @@ public class Usb_Device { public Usb_Device getPrev() { return prev; } + protected void setPrev(Usb_Device dev){ + prev = dev; + } @Override public String toString() { diff --git a/java/src/ch/ntb/inf/libusbJava/Usb_Device_Descriptor.java b/java/src/ch/ntb/inf/libusbJava/Usb_Device_Descriptor.java index f78f717..9dc20b3 100644 --- a/java/src/ch/ntb/inf/libusbJava/Usb_Device_Descriptor.java +++ b/java/src/ch/ntb/inf/libusbJava/Usb_Device_Descriptor.java @@ -22,8 +22,9 @@ public class Usb_Device_Descriptor extends Usb_Descriptor { * Device and/or interface class codes. */ public static final int USB_CLASS_PER_INTERFACE = 0, USB_CLASS_AUDIO = 1, - USB_CLASS_COMM = 2, USB_CLASS_HID = 3, USB_CLASS_PRINTER = 7, - USB_CLASS_MASS_STORAGE = 8, USB_CLASS_HUB = 9, USB_CLASS_DATA = 10, + USB_CLASS_COMM = 2, USB_CLASS_HID = 3, LIBUSB_CLASS_PTP = 6, + USB_CLASS_PRINTER = 7, USB_CLASS_MASS_STORAGE = 8, + USB_CLASS_HUB = 9, USB_CLASS_DATA = 10, USB_CLASS_VENDOR_SPEC = 0xff; private short bcdUSB; diff --git a/java/src/ch/ntb/inf/libusbJava/Usb_Endpoint_Descriptor.java b/java/src/ch/ntb/inf/libusbJava/Usb_Endpoint_Descriptor.java index 1284ba9..bd83147 100644 --- a/java/src/ch/ntb/inf/libusbJava/Usb_Endpoint_Descriptor.java +++ b/java/src/ch/ntb/inf/libusbJava/Usb_Endpoint_Descriptor.java @@ -36,15 +36,32 @@ public class Usb_Endpoint_Descriptor extends Usb_Descriptor { /** * Endpoint type mask (in bmAttributes). */ - public static final int USB_ENDPOINT_TYPE_MASK = 0x03; + public static final int USB_ENDPOINT_TRANSFER_TYPE_MASK = 0x03, + USB_ENDPOINT_ISO_SYNC_TYPE = 0x0C, + USB_ENDPOINT_ISO_USAGE_TYPE = 0x30; /** * Possible endpoint types (in bmAttributes). */ - public static final int USB_ENDPOINT_TYPE_CONTROL = 0, - USB_ENDPOINT_TYPE_ISOCHRONOUS = 1, USB_ENDPOINT_TYPE_BULK = 2, - USB_ENDPOINT_TYPE_INTERRUPT = 3; + public static final int USB_ENDPOINT_TRANSFER_TYPE_CONTROL = 0, + USB_ENDPOINT_TRANSFER_TYPE_ISOCHRONOUS = 1, + USB_ENDPOINT_TRANSFER_TYPE_BULK = 2, + USB_ENDPOINT_TRANSFER_TYPE_INTERRUPT = 3; + /** + * Possible synchronization types for isochronous endpoints. + */ + public static final int USB_ENDPOINT_ISO_SYNC_TYPE_NONE = 0, + USB_ENDPOINT_ISO_SYNC_TYPE_ASYNC = 1, + USB_ENDPOINT_ISO_SYNC_TYPE_ADAPTIVE = 2, + USB_ENDPOINT_ISO_SYNC_TYPE_SYNC = 3; + /** + * Possible usage types for isochronous endpoints + */ + public static final int USB_ENDPOINT_ISO_USAGE_TYPE_DATA = 0, + USB_ENDPOINT_ISO_USAGE_TYPE_FEEDBACK = 1, + USB_ENDPOINT_ISO_USAGE_TYPE_IMPLICIT = 2; + private byte bEndpointAddress; private byte bmAttributes; diff --git a/java/src/ch/ntb/inf/libusbJava/demo/ReadWrite.java b/java/src/ch/ntb/inf/libusbJava/demo/ReadWrite.java index 72d61a3..e692f64 100644 --- a/java/src/ch/ntb/inf/libusbJava/demo/ReadWrite.java +++ b/java/src/ch/ntb/inf/libusbJava/demo/ReadWrite.java @@ -27,7 +27,7 @@ public class ReadWrite { public static void main(String[] args) { // get a device instance with vendor id and product id - Device dev = USB.getDevice((short) 0x8235, (short) 0x0222); + Device dev = USB.getDevice((short) 0x8235, (short) 0x0100); try { // data to write to the device byte[] data = new byte[] { 0, 1, 2, 3 }; @@ -41,12 +41,12 @@ public class ReadWrite { // write some data to the device // 0x03 is the endpoint address of the OUT endpoint 3 (from PC to // device) - dev.writeInterrupt(0x03, data, data.length, 2000, false); + dev.writeInterrupt(0x02, data, data.length, 2000, false); // read some data from the device // 0x84 is the endpoint address of the IN endpoint 4 (from PC to // device) // bit 7 (0x80) is set in case of an IN endpoint - dev.readInterrupt(0x84, readData, readData.length, 2000, false); + dev.readInterrupt(0x86, readData, readData.length, 2000, false); // log the data from the device logData(readData); // close the device diff --git a/java/src/ch/ntb/inf/libusbJava/testApp/TestDevice.java b/java/src/ch/ntb/inf/libusbJava/testApp/TestDevice.java index 8a699ed..89bca5a 100644 --- a/java/src/ch/ntb/inf/libusbJava/testApp/TestDevice.java +++ b/java/src/ch/ntb/inf/libusbJava/testApp/TestDevice.java @@ -44,15 +44,15 @@ public class TestDevice extends AbstractDeviceInfo { @Override public void initValues() { setIdVendor((short) 0x8235); - setIdProduct((short) 0x0222); + setIdProduct((short) 0x0200); setTimeout(2000); setConfiguration(1); setInterface(0); setAltinterface(-1); setOutEPBulk(0x01); setInEPBulk(0x82); - setOutEPInt(0x03); - setInEPInt(0x84); + setOutEPInt(0x01); + setInEPInt(0x82); setSleepTimeout(2000); setMaxDataSize(USB.FULLSPEED_MAX_BULK_PACKET_SIZE); setMode(TransferMode.Bulk); diff --git a/java/src/ch/ntb/inf/libusbJava/usbView/UsbTreeModel.java b/java/src/ch/ntb/inf/libusbJava/usbView/UsbTreeModel.java index fa38f0b..2ed0bec 100644 --- a/java/src/ch/ntb/inf/libusbJava/usbView/UsbTreeModel.java +++ b/java/src/ch/ntb/inf/libusbJava/usbView/UsbTreeModel.java @@ -279,9 +279,7 @@ public class UsbTreeModel implements TreeModel, TreeSelectionListener { break; } if (dev.getDescriptor().getIManufacturer() > 0) { - String manufacturer = LibusbJava - .usb_get_string_simple(handle, devDesc - .getIManufacturer()); + String manufacturer = LibusbJava.usb_get_string_simple(handle, devDesc.getIManufacturer()); if (manufacturer == null) manufacturer = "unable to fetch manufacturer string"; sb.append("\tiManufacturer: " + manufacturer diff --git a/java/src/ch/ntb/inf/libusbJava/usbView/UsbView.java b/java/src/ch/ntb/inf/libusbJava/usbView/UsbView.java index 83fb90e..a4fba49 100644 --- a/java/src/ch/ntb/inf/libusbJava/usbView/UsbView.java +++ b/java/src/ch/ntb/inf/libusbJava/usbView/UsbView.java @@ -306,12 +306,12 @@ public class UsbView extends JFrame { for (int i = 0; i < nofInEPs; i++) { int type = inEPs[i].getBmAttributes() & 0x03; switch (type) { - case Usb_Endpoint_Descriptor.USB_ENDPOINT_TYPE_BULK: + case Usb_Endpoint_Descriptor.USB_ENDPOINT_TRANSFER_TYPE_BULK: testDevice.setInEPBulk(inEPs[i] .getBEndpointAddress() & 0xff); testDevice.setInMode(TransferMode.Bulk); break; - case Usb_Endpoint_Descriptor.USB_ENDPOINT_TYPE_INTERRUPT: + case Usb_Endpoint_Descriptor.USB_ENDPOINT_TRANSFER_TYPE_INTERRUPT: testDevice.setInEPInt(inEPs[i] .getBEndpointAddress() & 0xff); testDevice.setInMode(TransferMode.Interrupt); @@ -325,12 +325,12 @@ public class UsbView extends JFrame { for (int i = 0; i < nofOutEPs; i++) { int type = outEPs[i].getBmAttributes() & 0x03; switch (type) { - case Usb_Endpoint_Descriptor.USB_ENDPOINT_TYPE_BULK: + case Usb_Endpoint_Descriptor.USB_ENDPOINT_TRANSFER_TYPE_BULK: testDevice.setOutEPBulk(outEPs[i] .getBEndpointAddress() & 0xff); testDevice.setOutMode(TransferMode.Bulk); break; - case Usb_Endpoint_Descriptor.USB_ENDPOINT_TYPE_INTERRUPT: + case Usb_Endpoint_Descriptor.USB_ENDPOINT_TRANSFER_TYPE_INTERRUPT: testDevice.setOutEPInt(outEPs[i] .getBEndpointAddress() & 0xff); testDevice.setOutMode(TransferMode.Interrupt); diff --git a/java/test/ch/ntb/inf/libusbJava/test/DeviceTest.java b/java/test/ch/ntb/inf/libusbJava/test/DeviceTest.java index 5dd08ad..e1a09d9 100644 --- a/java/test/ch/ntb/inf/libusbJava/test/DeviceTest.java +++ b/java/test/ch/ntb/inf/libusbJava/test/DeviceTest.java @@ -72,13 +72,13 @@ public class DeviceTest { testData = new byte[devinfo.getMaxDataSize()]; readData = new byte[testData.length]; // initialise the device - LibusbJava.usb_set_debug(255); dev = USB.getDevice(devinfo.getIdVendor(), devinfo.getIdProduct(), devinfo.getBusName(), devinfo.getFilename()); assertNotNull(dev); // print the devices LibusbJava.usb_init(); +// LibusbJava.usb_set_debug(255); LibusbJava.usb_find_busses(); LibusbJava.usb_find_devices(); Usb_Bus bus = LibusbJava.usb_get_busses(); diff --git a/java/test/ch/ntb/inf/libusbJava/test/MemoryLeakTest.java b/java/test/ch/ntb/inf/libusbJava/test/MemoryLeakTest.java index 9de91ab..bc70d69 100644 --- a/java/test/ch/ntb/inf/libusbJava/test/MemoryLeakTest.java +++ b/java/test/ch/ntb/inf/libusbJava/test/MemoryLeakTest.java @@ -65,13 +65,12 @@ public class MemoryLeakTest { testData = new byte[devinfo.getMaxDataSize()]; readData = new byte[testData.length]; // initialise the device - LibusbJava.usb_set_debug(255); dev = USB.getDevice(devinfo.getIdVendor(), devinfo.getIdProduct()); assertNotNull(dev); // print the devices LibusbJava.usb_init(); - LibusbJava.usb_find_busses(); +// LibusbJava.usb_find_busses(); LibusbJava.usb_find_devices(); Usb_Bus bus = LibusbJava.usb_get_busses(); ByteArrayOutputStream baos = new ByteArrayOutputStream(); diff --git a/java/test/ch/ntb/inf/libusbJava/test/TestLibUsbJava.java b/java/test/ch/ntb/inf/libusbJava/test/TestLibUsbJava.java index 80896a6..a495590 100644 --- a/java/test/ch/ntb/inf/libusbJava/test/TestLibUsbJava.java +++ b/java/test/ch/ntb/inf/libusbJava/test/TestLibUsbJava.java @@ -217,10 +217,8 @@ public class TestLibUsbJava { } // used for debugging. 0 = no debugging, 255 = with debugging - // - LibusbJava.usb_set_debug(255); - LibusbJava.usb_init(); + LibusbJava.usb_set_debug(255); LibusbJava.usb_find_busses(); LibusbJava.usb_find_devices(); diff --git a/java/test/ch/ntb/inf/libusbJava/test/devices/AT90USB1287.java b/java/test/ch/ntb/inf/libusbJava/test/devices/AT90USB1287.java index ba17351..518b7d9 100644 --- a/java/test/ch/ntb/inf/libusbJava/test/devices/AT90USB1287.java +++ b/java/test/ch/ntb/inf/libusbJava/test/devices/AT90USB1287.java @@ -15,15 +15,15 @@ public class AT90USB1287 extends AbstractDeviceInfo { @Override public void initValues() { setIdVendor((short) 0x8235); - setIdProduct((short) 0x0222); + setIdProduct((short) 0x0200); setTimeout(2000); setConfiguration(1); setInterface(0); setAltinterface(-1); setOutEPBulk(0x01); setInEPBulk(0x82); - setOutEPInt(0x03); - setInEPInt(0x84); + setOutEPInt(0x01); + setInEPInt(0x82); setSleepTimeout(2000); setMaxDataSize(USB.FULLSPEED_MAX_BULK_PACKET_SIZE); setMode(TransferMode.Bulk); diff --git a/java/version.properties b/java/version.properties index 05bf58e..9326970 100644 --- a/java/version.properties +++ b/java/version.properties @@ -1,4 +1,4 @@ -#Thu Aug 24 14:28:28 CEST 2006 -version.major=0 -version.minor=5 -version.release=9 +#Tue Mar 30 10:58:35 CEST 2010 +version.major=1 +version.minor=0 +version.release=0