From a25d11b59b1e1afd1ee87752603bcb053942e929 Mon Sep 17 00:00:00 2001 From: schlaepfer Date: Fri, 28 Oct 2005 11:54:22 +0000 Subject: [PATCH] libusbdll moved to trunk git-svn-id: https://svn.code.sf.net/p/libusbjava/code/trunk@33 94ad28fe-ef68-46b1-9651-e7ae4fcf1c4c --- libusbdll/.cdtproject | 83 +++++ libusbdll/.project | 90 +++++ libusbdll/LibusbTest.cpp | 327 ++++++++++++++++++ libusbdll/LibusbTest.exe | Bin 0 -> 22944 bytes libusbdll/LibusbWin.cpp | 691 +++++++++++++++++++++++++++++++++++++++ libusbdll/LibusbWin.dll | Bin 0 -> 37740 bytes libusbdll/LibusbWin.h | 189 +++++++++++ libusbdll/libusb.lib | Bin 0 -> 10792 bytes libusbdll/makefile | 20 ++ libusbdll/stdafx.h | 13 + libusbdll/usb.h | 374 +++++++++++++++++++++ 11 files changed, 1787 insertions(+) create mode 100644 libusbdll/.cdtproject create mode 100644 libusbdll/.project create mode 100644 libusbdll/LibusbTest.cpp create mode 100644 libusbdll/LibusbTest.exe create mode 100644 libusbdll/LibusbWin.cpp create mode 100644 libusbdll/LibusbWin.dll create mode 100644 libusbdll/LibusbWin.h create mode 100644 libusbdll/libusb.lib create mode 100644 libusbdll/makefile create mode 100644 libusbdll/stdafx.h create mode 100644 libusbdll/usb.h diff --git a/libusbdll/.cdtproject b/libusbdll/.cdtproject new file mode 100644 index 0000000..60a6b94 --- /dev/null +++ b/libusbdll/.cdtproject @@ -0,0 +1,83 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +make + +cleanDll +false +true + + +make + +testExe +false +true + + +make + +dll +false +true + + + + + diff --git a/libusbdll/.project b/libusbdll/.project new file mode 100644 index 0000000..61972a2 --- /dev/null +++ b/libusbdll/.project @@ -0,0 +1,90 @@ + + + LibusbDllJNIMinGW + + + + + + org.eclipse.cdt.make.core.makeBuilder + clean,full,incremental, + + + org.eclipse.cdt.make.core.build.arguments + + + + org.eclipse.cdt.core.errorOutputParser + org.eclipse.cdt.core.MakeErrorParser;org.eclipse.cdt.core.GCCErrorParser;org.eclipse.cdt.core.GASErrorParser;org.eclipse.cdt.core.GLDErrorParser;org.eclipse.cdt.core.VCErrorParser; + + + org.eclipse.cdt.make.core.enableAutoBuild + false + + + org.eclipse.cdt.make.core.environment + + + + org.eclipse.cdt.make.core.enableFullBuild + true + + + org.eclipse.cdt.make.core.build.target.inc + all + + + org.eclipse.cdt.make.core.enabledIncrementalBuild + true + + + org.eclipse.cdt.make.core.build.location + + + + org.eclipse.cdt.make.core.build.target.clean + clean + + + org.eclipse.cdt.make.core.build.command + make + + + org.eclipse.cdt.make.core.enableCleanBuild + true + + + org.eclipse.cdt.make.core.append_environment + true + + + org.eclipse.cdt.make.core.build.target.full + clean all + + + org.eclipse.cdt.make.core.useDefaultBuildCmd + true + + + org.eclipse.cdt.make.core.build.target.auto + all + + + org.eclipse.cdt.make.core.stopOnError + false + + + + + org.eclipse.cdt.make.core.ScannerConfigBuilder + + + + + + org.eclipse.cdt.core.cnature + org.eclipse.cdt.make.core.makeNature + org.eclipse.cdt.make.core.ScannerConfigNature + org.eclipse.cdt.core.ccnature + + diff --git a/libusbdll/LibusbTest.cpp b/libusbdll/LibusbTest.cpp new file mode 100644 index 0000000..36ea2d6 --- /dev/null +++ b/libusbdll/LibusbTest.cpp @@ -0,0 +1,327 @@ +/* + * testlibusb.c + * + * Test suite program + */ + +#include +#include +#include "usb.h" + +#define snprintf printf + +#define ID_PRODUCT 0x1004 //0x8613 +#define ID_VENDOR 0x04B4 + +#define CONFIGURATION 1 +#define INTERFACE 0 +#define ALTINTERFACE 0 +#define TIMEOUT 2000 + +#define OUT_ENDPOINT 0x02 +#define IN_ENDPOINT 0x86 + +int verbose = 0; + +void print_endpoint(struct usb_endpoint_descriptor *endpoint) +{ + printf(" bEndpointAddress: %02xh\n", endpoint->bEndpointAddress); + printf(" bmAttributes: %02xh\n", endpoint->bmAttributes); + printf(" wMaxPacketSize: %d\n", endpoint->wMaxPacketSize); + printf(" bInterval: %d\n", endpoint->bInterval); + printf(" bRefresh: %d\n", endpoint->bRefresh); + printf(" bSynchAddress: %d\n", endpoint->bSynchAddress); +} + +void print_altsetting(struct usb_interface_descriptor *interface) +{ + int i; + + printf(" bInterfaceNumber: %d\n", interface->bInterfaceNumber); + printf(" bAlternateSetting: %d\n", interface->bAlternateSetting); + printf(" bNumEndpoints: %d\n", interface->bNumEndpoints); + printf(" bInterfaceClass: %d\n", interface->bInterfaceClass); + printf(" bInterfaceSubClass: %d\n", interface->bInterfaceSubClass); + printf(" bInterfaceProtocol: %d\n", interface->bInterfaceProtocol); + printf(" iInterface: %d\n", interface->iInterface); + + for (i = 0; i < interface->bNumEndpoints; i++) + print_endpoint(&interface->endpoint[i]); +} + +void print_interface(struct usb_interface *interface) +{ + int i; + + for (i = 0; i < interface->num_altsetting; i++) + print_altsetting(&interface->altsetting[i]); +} + +void print_configuration(struct usb_config_descriptor *config) +{ + int i; + + printf(" wTotalLength: %d\n", config->wTotalLength); + printf(" bNumInterfaces: %d\n", config->bNumInterfaces); + printf(" bConfigurationValue: %d\n", config->bConfigurationValue); + printf(" iConfiguration: %d\n", config->iConfiguration); + printf(" bmAttributes: %02xh\n", config->bmAttributes); + printf(" MaxPower: %d\n", config->MaxPower); + + for (i = 0; i < config->bNumInterfaces; i++) + print_interface(&config->interface[i]); +} + +int print_device(struct usb_device *dev, int level) +{ + usb_dev_handle *udev; + char description[256]; + char string[256]; + int ret, i; + + udev = usb_open(dev); + if (udev) { + if (dev->descriptor.iManufacturer) { + ret = usb_get_string_simple(udev, dev->descriptor.iManufacturer, string, sizeof(string)); + if (ret > 0) + snprintf(description, sizeof(description), "%s - ", string); + else + snprintf(description, sizeof(description), "%04X - ", + dev->descriptor.idVendor); + } else + snprintf(description, sizeof(description), "%04X - ", + dev->descriptor.idVendor); + + if (dev->descriptor.iProduct) { + ret = usb_get_string_simple(udev, dev->descriptor.iProduct, string, sizeof(string)); + if (ret > 0) + snprintf(description + strlen(description), sizeof(description) - + strlen(description), "%s", string); + else + snprintf(description + strlen(description), sizeof(description) - + strlen(description), "%04X", dev->descriptor.idProduct); + } else + snprintf(description + strlen(description), sizeof(description) - + strlen(description), "%04X", dev->descriptor.idProduct); + + } else + snprintf(description, sizeof(description), "%04X - %04X", + dev->descriptor.idVendor, dev->descriptor.idProduct); + + printf("%.*sDev #%d: %s\n", level * 2, " ", dev->devnum, + description); + + if (udev && verbose) { + if (dev->descriptor.iSerialNumber) { + ret = usb_get_string_simple(udev, dev->descriptor.iSerialNumber, string, sizeof(string)); + if (ret > 0) + printf("%.*s - Serial Number: %s\n", level * 2, + " ", string); + } + } + + if (udev) + usb_close(udev); + + if (verbose) { + if (!dev->config) { + printf(" Couldn't retrieve descriptors\n"); + return 0; + } + + for (i = 0; i < dev->descriptor.bNumConfigurations; i++) + print_configuration(&dev->config[i]); + } else { + for (i = 0; i < dev->num_children; i++) + print_device(dev->children[i], level + 1); + } + + return 0; +} + +int read(struct usb_dev_handle *handle) +{ + if (usb_claim_interface(handle, INTERFACE) < 0) { + printf("error on usb_claim_interface: %s\n", usb_strerror()); + return -1; + } + printf("usb_claim_interface successful\n"); + if (usb_set_altinterface(handle, ALTINTERFACE) < 0){ + printf("usb_set_altinterface failed: %s\n", usb_strerror()); + } + + int size = 512, res; + char *data = (char *) malloc(size*sizeof(char)); + res = usb_bulk_read(handle, IN_ENDPOINT, data, size, TIMEOUT); + if (res < 0){ + printf("usb_bulk_read failed: %s\n", usb_strerror()); + } + printf("usb_bulk_read: %d bytes read: ", res); + for (int i = 0; i < res; ++i) { + printf("%3x ", data[i]); + } + printf("\n"); + + usb_release_interface(handle, INTERFACE); +} + +int write(struct usb_dev_handle *handle) +{ + int size = 12; + char *data = (char *) malloc(size*sizeof(char)); + data[0] = 0x33; + data[1] = 0x5B; + data[2] = 0x02; + data[3] = 0x01; + data[4] = 0x00; + data[5] = 0x05; + data[6] = 0x01; + data[7] = 0x03; + data[8] = 0x07; + data[9] = 0x0F; + data[10] = 0x7F; + data[11] = 0x1F; + // data = {0x33, 0x5B, 0x02, 0x01, 0x00, 0x05, 0x01, 0x03, 0x07, 0x0F, 0x7F, 0x1F}; + + if (usb_claim_interface(handle, INTERFACE) < 0) { + printf("error on usb_claim_interface: %s\n", usb_strerror()); + return -1; + } + printf("usb_claim_interface successful\n"); + if (usb_set_altinterface(handle, ALTINTERFACE) < 0){ + printf("usb_set_altinterface failed: %s\n", usb_strerror()); + } + printf("usb_bulk_write: writing %d bytes: ", size); + for (int i = 0; i < size; ++i) { + printf("%3x ", data[i]); + } + printf("\n"); + + int res = usb_bulk_write(handle, OUT_ENDPOINT, data, size, TIMEOUT); + if (res < 0){ + printf("usb_bulk_write failed: %s\n", usb_strerror()); + return -1; + } + + printf("usb_bulk_write: %d bytes written\n", res); + + usb_release_interface(handle, INTERFACE); +} + +int main(int argc, char *argv[]) +{ + struct usb_bus *bus; + struct usb_device *dev; + struct usb_dev_handle *handle; + + bool run = true; + +// if (argc > 1 && !strcmp(argv[1], "-v")) +// verbose = 1; + + verbose = 1; + + usb_set_debug(255); + + usb_init(); + + usb_find_busses(); + usb_find_devices(); + +// for (bus = usb_get_busses(); bus; bus = bus->next) { +// if (bus->root_dev && !verbose) +// print_device(bus->root_dev, 0); +// else { +// struct usb_device *dev; +// +// for (dev = bus->devices; dev; dev = dev->next) +// print_device(dev, 0); +// } +// } + + int size = 512; + char *data = (char *) malloc(size*sizeof(char)); + + + for (bus = usb_get_busses(); bus; bus = bus->next) { + for (dev = bus->devices; dev; dev = dev->next) { + if ((dev->descriptor.idProduct == ID_PRODUCT) && (dev->descriptor.idVendor == ID_VENDOR)){ + printf("Device found\n"); + handle = usb_open(dev); + if (!handle) { + printf("invalid handle: %s\n", usb_strerror()); + system("PAUSE"); + return -1; + } + if (usb_set_configuration(handle, CONFIGURATION) < 0) { + printf("error on usb_set_configuration: %s\n", usb_strerror()); + system("PAUSE"); + return -1; + } + + printf("w=write, r=read, x=exit, t=write+read:\n"); + + while (run) { + scanf("%s", data); + + switch (data[0]) { + case 'w': // write + write(handle); + break; + case 'r': // read + read(handle); + break; + case 'x': // exit + run = false; + break; + case 't': // write + read + if (write(handle)) { + read(handle); + } + break; + default: + break; + } + + // printf("type a string...\n"); + // scanf("%s", data); // Get a string + + // if (usb_claim_interface(handle, INTERFACE) < 0) { + // printf("error on usb_claim_interface: %s\n", usb_strerror()); + // system("PAUSE"); + // return -1; + // } + // printf("usb_claim_interface successful\n"); + // if (usb_set_altinterface(handle, ALTINTERFACE) < 0){ + // printf("usb_set_altinterface failed: %s\n", usb_strerror()); + // } + // + // if (usb_bulk_write(handle, OUT_ENDPOINT, data, strlen(data), 3000) < 0){ + // printf("usb_bulk_write failed: %s\n", usb_strerror()); + // system("PAUSE"); + // return -1; + // } + // + // strcpy(data, "12345678901234567890"); + // printf("%s\n", "read data"); + // if (usb_bulk_read(handle, IN_ENDPOINT, data, size, 3000) < 0){ + // printf("usb_bulk_read failed: %s\n", usb_strerror()); + // } + // printf("output %d, %s\n", size, data); + // // for (int i = 0; i < size; ++i) { + // // printf("%4x ", data[i]); + // // } + // + // usb_release_interface(handle, INTERFACE); + // } + // + // usb_close(handle); + } + printf("\ndone\n"); + } + } + } + system("PAUSE"); + + return 1; +} diff --git a/libusbdll/LibusbTest.exe b/libusbdll/LibusbTest.exe new file mode 100644 index 0000000000000000000000000000000000000000..557c4127a721bdd2c2b558f8133d6f439c309bd2 GIT binary patch literal 22944 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 +#include +#include +#include +#include "LibusbWin.h" +#include "usb.h" + +//#define DEBUGON + +// global bus (updated when usb_get_busses() is called) +struct usb_bus *busses; +// device class +jclass usb_devClazz; +// usb_device.devnum +jfieldID usb_devFID_devnum; + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_init + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_ch_ntb_usb_LibusbWin_usb_1init + (JNIEnv *env, jobject obj) + { + usb_init(); + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_find_busses + * Signature: ()I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1find_1busses + (JNIEnv *env, jobject obj) + { + return usb_find_busses(); + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_find_devices + * Signature: ()I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1find_1devices + (JNIEnv *env, jobject obj) + { + return usb_find_devices(); + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_get_busses + * Signature: ()Lch/ntb/usb/Usb_Bus; + */ +JNIEXPORT jobject JNICALL Java_ch_ntb_usb_LibusbWin_usb_1get_1busses + (JNIEnv *env, jobject obj) + { + // classes + jclass usb_busClazz, /*usb_devClazz,*/ usb_devDescClazz, usb_confDescClazz, \ + usb_intClazz, usb_intDescClazz, usb_epDescClazz; + // method IDs + jmethodID usb_busMid, usb_devMid, usb_devDescMid, usb_confDescMid, \ + usb_intMid, usb_intDescMid, usb_epDescMid; + // usb_bus + jfieldID usb_busFID_next, usb_busFID_prev, usb_busFID_dirname, \ + usb_busFID_devices, usb_busFID_location, usb_busFID_root_dev; + // usb_device + jfieldID usb_devFID_next, usb_devFID_prev, usb_devFID_filename, \ + usb_devFID_bus, usb_devFID_descriptor, usb_devFID_config, \ + /*usb_devFID_devnum,*/ usb_devFID_num_children, usb_devFID_children; + // usb_deviceDescriptor + jfieldID usb_devDescFID_bLength, usb_devDescFID_bDescriptorType, \ + usb_devDescFID_bcdUSB, usb_devDescFID_bDeviceClass, \ + usb_devDescFID_bDeviceSubClass, usb_devDescFID_bDeviceProtocol, \ + usb_devDescFID_bMaxPacketSize0, usb_devDescFID_idVendor, \ + usb_devDescFID_idProduct, usb_devDescFID_bcdDevice, \ + usb_devDescFID_iManufacturer, usb_devDescFID_iProduct, \ + usb_devDescFID_iSerialNumber, usb_devDescFID_bNumConfigurations; + // usb_configurationDescriptor + jfieldID usb_confDescFID_bLength, usb_confDescFID_bDescriptorType, usb_confDescFID_wTotalLength, \ + usb_confDescFID_bNumInterfaces, usb_confDescFID_bConfigurationValue, \ + usb_confDescFID_iConfiguration, usb_confDescFID_bmAttributes, usb_confDescFID_MaxPower, \ + usb_confDescFID_interface_, usb_confDescFID_extra, usb_confDescFID_extralen; + // usb_interface + jfieldID usb_intFID_altsetting, usb_intFID_num_altsetting; + // usb_intDesc + jfieldID usb_intDescFID_bLength, usb_intDescFID_bDescriptorType, \ + usb_intDescFID_bInterfaceNumber, usb_intDescFID_bAlternateSetting, \ + usb_intDescFID_bNumEndpoints, usb_intDescFID_bInterfaceClass, \ + usb_intDescFID_bInterfaceSubClass, usb_intDescFID_bInterfaceProtocol, \ + usb_intDescFID_iInterface, usb_intDescFID_endpoint, usb_intDescFID_extra, \ + usb_intDescFID_extralen; + // usb_endpointDescriptor + jfieldID usb_epDescFID_bLength, usb_epDescFID_bDescriptorType, \ + usb_epDescFID_bEndpointAddress, usb_epDescFID_bmAttributes, \ + usb_epDescFID_wMaxPacketSize, usb_epDescFID_bInterval, \ + usb_epDescFID_bRefresh, usb_epDescFID_bSynchAddress, usb_epDescFID_extra, \ + usb_epDescFID_extralen; + + // find classes and field ids + // usb_bus + usb_busClazz = env->FindClass("ch/ntb/usb/Usb_Bus"); + if (usb_busClazz == NULL) { return NULL; /* exception thrown */ } + usb_busMid = env->GetMethodID(usb_busClazz, "","()V"); + if (usb_busMid == NULL) { return NULL; } + + usb_busFID_next = env->GetFieldID(usb_busClazz, "next", "Lch/ntb/usb/Usb_Bus;"); + usb_busFID_prev = env->GetFieldID(usb_busClazz, "prev", "Lch/ntb/usb/Usb_Bus;"); + usb_busFID_dirname = env->GetFieldID(usb_busClazz, "dirname", "Ljava/lang/String;"); + usb_busFID_devices = env->GetFieldID(usb_busClazz, "devices", "Lch/ntb/usb/Usb_Device;"); + usb_busFID_location = env->GetFieldID(usb_busClazz, "location", "J"); + usb_busFID_root_dev = env->GetFieldID(usb_busClazz, "root_dev", "Lch/ntb/usb/Usb_Device;"); + + + // usb_device + usb_devClazz = env->FindClass("ch/ntb/usb/Usb_Device"); + if (usb_devClazz == NULL) { return NULL; /* exception thrown */ } + usb_devMid = env->GetMethodID(usb_devClazz, "","()V"); + if (usb_devMid == NULL) { return NULL; } + + usb_devFID_next = env->GetFieldID(usb_devClazz, "next", "Lch/ntb/usb/Usb_Device;"); + usb_devFID_prev = env->GetFieldID(usb_devClazz, "prev", "Lch/ntb/usb/Usb_Device;"); + usb_devFID_filename = env->GetFieldID(usb_devClazz, "filename", "Ljava/lang/String;"); + usb_devFID_bus = env->GetFieldID(usb_devClazz, "bus", "Lch/ntb/usb/Usb_Bus;"); + usb_devFID_descriptor = env->GetFieldID(usb_devClazz, "descriptor", "Lch/ntb/usb/Usb_Device_Descriptor;"); + usb_devFID_config = env->GetFieldID(usb_devClazz, "config", "[Lch/ntb/usb/Usb_Config_Descriptor;"); + usb_devFID_devnum = env->GetFieldID(usb_devClazz, "devnum", "B"); + usb_devFID_num_children = env->GetFieldID(usb_devClazz, "num_children", "B"); + usb_devFID_children = env->GetFieldID(usb_devClazz, "children", "Lch/ntb/usb/Usb_Device;"); + + + // usb_device_descriptor + usb_devDescClazz = env->FindClass("ch/ntb/usb/Usb_Device_Descriptor"); + if (usb_devDescClazz == NULL) { return NULL; /* exception thrown */ } + usb_devDescMid = env->GetMethodID(usb_devDescClazz, "","()V"); + if (usb_devDescMid == NULL) { return NULL; } + + usb_devDescFID_bLength = env->GetFieldID(usb_devDescClazz, "bLength", "B"); + usb_devDescFID_bDescriptorType = env->GetFieldID(usb_devDescClazz, "bDescriptorType", "B"); + usb_devDescFID_bcdUSB = env->GetFieldID(usb_devDescClazz, "bcdUSB", "S"); + usb_devDescFID_bDeviceClass = env->GetFieldID(usb_devDescClazz, "bDeviceClass", "B"); + usb_devDescFID_bDeviceSubClass = env->GetFieldID(usb_devDescClazz, "bDeviceSubClass", "B"); + usb_devDescFID_bDeviceProtocol = env->GetFieldID(usb_devDescClazz, "bDeviceProtocol", "B"); + usb_devDescFID_bMaxPacketSize0 = env->GetFieldID(usb_devDescClazz, "bMaxPacketSize0", "B"); + usb_devDescFID_idVendor = env->GetFieldID(usb_devDescClazz, "idVendor", "S"); + usb_devDescFID_idProduct = env->GetFieldID(usb_devDescClazz, "idProduct", "S"); + usb_devDescFID_bcdDevice = env->GetFieldID(usb_devDescClazz, "bcdDevice", "S"); + usb_devDescFID_iManufacturer = env->GetFieldID(usb_devDescClazz, "iManufacturer", "B"); + usb_devDescFID_iProduct = env->GetFieldID(usb_devDescClazz, "iProduct", "B"); + usb_devDescFID_iSerialNumber = env->GetFieldID(usb_devDescClazz, "iSerialNumber", "B"); + usb_devDescFID_bNumConfigurations = env->GetFieldID(usb_devDescClazz, "bNumConfigurations", "B"); + + + // usb_configuration_descriptor + usb_confDescClazz = env->FindClass("ch/ntb/usb/Usb_Config_Descriptor"); + if (usb_confDescClazz == NULL) { return NULL; /* exception thrown */ } + usb_confDescMid = env->GetMethodID(usb_confDescClazz, "","()V"); + if (usb_confDescMid == NULL) { return NULL; } + + usb_confDescFID_bLength = env->GetFieldID(usb_confDescClazz, "bLength", "B"); + usb_confDescFID_bDescriptorType = env->GetFieldID(usb_confDescClazz, "bDescriptorType", "B"); + usb_confDescFID_wTotalLength = env->GetFieldID(usb_confDescClazz, "wTotalLength", "S"); + usb_confDescFID_bNumInterfaces = env->GetFieldID(usb_confDescClazz, "bNumInterfaces", "B"); + usb_confDescFID_bConfigurationValue = env->GetFieldID(usb_confDescClazz, "bConfigurationValue", "B"); + usb_confDescFID_iConfiguration = env->GetFieldID(usb_confDescClazz, "iConfiguration", "B"); + usb_confDescFID_bmAttributes = env->GetFieldID(usb_confDescClazz, "bmAttributes", "B"); + usb_confDescFID_MaxPower = env->GetFieldID(usb_confDescClazz, "MaxPower", "B"); + usb_confDescFID_interface_ = env->GetFieldID(usb_confDescClazz, "interface_", "[Lch/ntb/usb/Usb_Interface;"); + usb_confDescFID_extra = env->GetFieldID(usb_confDescClazz, "extra", "Lch/ntb/usb/Usb_Config_Descriptor;"); + usb_confDescFID_extralen = env->GetFieldID(usb_confDescClazz, "extralen", "I"); + + // usb_interface + usb_intClazz = env->FindClass("ch/ntb/usb/Usb_Interface"); + if (usb_intClazz == NULL) { return NULL; /* exception thrown */ } + usb_intMid = env->GetMethodID(usb_intClazz, "","()V"); + if (usb_intMid == NULL) { return NULL; } + + usb_intFID_altsetting = env->GetFieldID(usb_intClazz, "altsetting", "[Lch/ntb/usb/Usb_Interface_Descriptor;"); + usb_intFID_num_altsetting = env->GetFieldID(usb_intClazz, "num_altsetting", "I"); + + // usb_interface_descriptor + usb_intDescClazz = env->FindClass("ch/ntb/usb/Usb_Interface_Descriptor"); + if (usb_intDescClazz == NULL) { return NULL; /* exception thrown */ } + usb_intDescMid = env->GetMethodID(usb_intDescClazz, "","()V"); + if (usb_intDescMid == NULL) { return NULL; } + + usb_intDescFID_bLength = env->GetFieldID(usb_intDescClazz, "bLength", "B"); + usb_intDescFID_bDescriptorType = env->GetFieldID(usb_intDescClazz, "bDescriptorType", "B"); + usb_intDescFID_bInterfaceNumber = env->GetFieldID(usb_intDescClazz, "bInterfaceNumber", "B"); + usb_intDescFID_bAlternateSetting = env->GetFieldID(usb_intDescClazz, "bAlternateSetting", "B"); + usb_intDescFID_bNumEndpoints = env->GetFieldID(usb_intDescClazz, "bNumEndpoints", "B"); + usb_intDescFID_bInterfaceClass = env->GetFieldID(usb_intDescClazz, "bInterfaceClass", "B"); + usb_intDescFID_bInterfaceSubClass = env->GetFieldID(usb_intDescClazz, "bInterfaceSubClass", "B"); + usb_intDescFID_bInterfaceProtocol = env->GetFieldID(usb_intDescClazz, "bInterfaceProtocol", "B"); + usb_intDescFID_iInterface = env->GetFieldID(usb_intDescClazz, "iInterface", "B"); + usb_intDescFID_endpoint = env->GetFieldID(usb_intDescClazz, "endpoint", "[Lch/ntb/usb/Usb_Endpoint_Descriptor;"); + usb_intDescFID_extra = env->GetFieldID(usb_intDescClazz, "extra", "Lch/ntb/usb/Usb_Interface_Descriptor;"); + usb_intDescFID_extralen = env->GetFieldID(usb_intDescClazz, "extralen", "I"); + + // usb_endpoint_descriptor + usb_epDescClazz = env->FindClass("ch/ntb/usb/Usb_Endpoint_Descriptor"); + if (usb_epDescClazz == NULL) { return NULL; /* exception thrown */ } + usb_epDescMid = env->GetMethodID(usb_epDescClazz, "","()V"); + if (usb_epDescMid == NULL) { return NULL; } + + usb_epDescFID_bLength = env->GetFieldID(usb_epDescClazz, "bLength", "B"); + usb_epDescFID_bDescriptorType = env->GetFieldID(usb_epDescClazz, "bDescriptorType", "B"); + usb_epDescFID_bEndpointAddress = env->GetFieldID(usb_epDescClazz, "bEndpointAddress", "B"); + usb_epDescFID_bmAttributes = env->GetFieldID(usb_epDescClazz, "bmAttributes", "B"); + usb_epDescFID_wMaxPacketSize = env->GetFieldID(usb_epDescClazz, "wMaxPacketSize", "S"); + usb_epDescFID_bInterval = env->GetFieldID(usb_epDescClazz, "bInterval", "B"); + usb_epDescFID_bRefresh = env->GetFieldID(usb_epDescClazz, "bRefresh", "B"); + usb_epDescFID_bSynchAddress = env->GetFieldID(usb_epDescClazz, "bSynchAddress", "B"); + usb_epDescFID_extra = env->GetFieldID(usb_epDescClazz, "extra", "Lch/ntb/usb/Usb_Endpoint_Descriptor;"); + usb_epDescFID_extralen = env->GetFieldID(usb_epDescClazz, "extralen", "I"); + + //************************************************************************// + +#ifdef DEBUGON + printf("usb_get_busses: Field initialization done (1)\n"); +#endif + + struct usb_device *dev; + struct usb_bus *bus; + + busses = usb_get_busses(); + bus = busses; + if (!bus){ + return NULL; + } + + // objects + jobject main_usb_busObj, usb_busObj, usb_busObj_next, usb_busObj_prev, \ + main_usb_devObj, usb_devObj, usb_devObj_next, usb_devObj_prev, \ + usb_devDescObj, usb_confDescObj, usb_intObj, usb_intDescObj, \ + usb_epDescObj; + + jobjectArray usb_confDescObjArray, usb_intObjArray, usb_intDescObjArray, usb_epDescObjArray; + + usb_busObj = NULL; + usb_busObj_prev = NULL; + main_usb_busObj = NULL; + +#ifdef DEBUGON + printf("usb_get_busses: usb_get_busses done (2)\n"); +#endif + + while (bus){ +#ifdef DEBUGON + printf("\tusb_get_busses: bus %x (2)\n", bus); +#endif + + // create a new object for every bus + if (!usb_busObj) { + usb_busObj = env->NewObject(usb_busClazz, usb_busMid); + if (!usb_busObj) { printf("Error NewObject 1\n"); return NULL; } + main_usb_busObj = usb_busObj; + } + + // fill the fields of the object + usb_busObj_next = NULL; + if (bus->next){ + usb_busObj_next = env->NewObject(usb_busClazz, usb_busMid); + if (!usb_busObj_next) { printf("Error NewObject 2\n"); return NULL; } + } + env->SetObjectField(usb_busObj, usb_busFID_next, usb_busObj_next); + env->SetObjectField(usb_busObj, usb_busFID_prev, usb_busObj_prev); + env->SetObjectField(usb_busObj, usb_busFID_dirname, env->NewStringUTF(bus->dirname)); + env->SetLongField(usb_busObj, usb_busFID_location, bus->location); + + dev = bus->devices; + usb_devObj = NULL; + usb_devObj_prev = NULL; + main_usb_devObj = NULL; + + while (dev){ +#ifdef DEBUGON + printf("\tusb_get_busses: dev %x (3)\n", dev); +#endif + // create a new object for every device + if (!usb_devObj){ + usb_devObj = env->NewObject(usb_devClazz, usb_devMid); + if (!usb_devObj) { printf("Error NewObject 3\n"); return NULL; } + main_usb_devObj = usb_devObj; + } + // fill the fields of the object + usb_devObj_next = NULL; + if (dev->next){ + usb_devObj_next = env->NewObject(usb_devClazz, usb_devMid); + if (!usb_devObj_next) { printf("Error NewObject 4\n"); return NULL; } + } + env->SetObjectField(usb_devObj, usb_devFID_next, usb_devObj_next); + env->SetObjectField(usb_devObj, usb_devFID_prev, usb_devObj_prev); + env->SetObjectField(usb_devObj, usb_devFID_bus, usb_busObj); + env->SetObjectField(usb_devObj, usb_devFID_filename, env->NewStringUTF(dev->filename)); + env->SetByteField(usb_devObj, usb_devFID_devnum, dev->devnum); + env->SetByteField(usb_devObj, usb_devFID_num_children, dev->num_children); + + // device descriptor + usb_devDescObj = env->NewObject(usb_devDescClazz, usb_devDescMid); + if (!usb_devDescObj) { printf("Error NewObject 5\n"); return NULL; } + env->SetByteField(usb_devDescObj, usb_devDescFID_bLength, dev->descriptor.bLength); + env->SetByteField(usb_devDescObj, usb_devDescFID_bDescriptorType, dev->descriptor.bDescriptorType); + env->SetShortField(usb_devDescObj, usb_devDescFID_bcdUSB, dev->descriptor.bcdUSB); + env->SetByteField(usb_devDescObj, usb_devDescFID_bDeviceClass, dev->descriptor.bDeviceClass); + env->SetByteField(usb_devDescObj, usb_devDescFID_bDeviceSubClass, dev->descriptor.bDeviceSubClass); + env->SetByteField(usb_devDescObj, usb_devDescFID_bDeviceProtocol, dev->descriptor.bDeviceProtocol); + env->SetByteField(usb_devDescObj, usb_devDescFID_bMaxPacketSize0, dev->descriptor.bMaxPacketSize0); + env->SetShortField(usb_devDescObj, usb_devDescFID_idVendor, dev->descriptor.idVendor); + env->SetShortField(usb_devDescObj, usb_devDescFID_idProduct, dev->descriptor.idProduct); + env->SetShortField(usb_devDescObj, usb_devDescFID_bcdDevice, dev->descriptor.bcdDevice); + env->SetByteField(usb_devDescObj, usb_devDescFID_iManufacturer, dev->descriptor.iManufacturer); + env->SetByteField(usb_devDescObj, usb_devDescFID_iProduct, dev->descriptor.iProduct); + env->SetByteField(usb_devDescObj, usb_devDescFID_iSerialNumber, dev->descriptor.iSerialNumber); + env->SetByteField(usb_devDescObj, usb_devDescFID_bNumConfigurations, dev->descriptor.bNumConfigurations); + + env->SetObjectField(usb_devObj, usb_devFID_descriptor, usb_devDescObj); + // configuration descriptor + // Loop through all of the configurations + usb_confDescObjArray = env->NewObjectArray(dev->descriptor.bNumConfigurations, usb_confDescClazz, NULL); + if (!usb_confDescObjArray) { printf("Error NewObject 6\n"); return NULL; } + for (int c = 0; c < dev->descriptor.bNumConfigurations; c++){ +#ifdef DEBUGON + printf("\t\tusb_get_busses: configuration %x (4)\n", c); +#endif + if (dev->config == NULL) { + printf("dev->config == NULL\n"); + return main_usb_busObj; + } + + usb_confDescObj = env->NewObject(usb_confDescClazz, usb_confDescMid); + if (!usb_confDescObj) { printf("Error NewObject 7\n"); return NULL; } + env->SetObjectArrayElement(usb_confDescObjArray, c, usb_confDescObj); + env->SetByteField(usb_confDescObj, usb_confDescFID_bLength, dev->config[c].bLength); + env->SetByteField(usb_confDescObj, usb_confDescFID_bDescriptorType, dev->config[c].bDescriptorType); + env->SetShortField(usb_confDescObj, usb_confDescFID_wTotalLength, dev->config[c].wTotalLength); + env->SetByteField(usb_confDescObj, usb_confDescFID_bNumInterfaces, dev->config[c].bNumInterfaces); + env->SetByteField(usb_confDescObj, usb_confDescFID_bConfigurationValue, dev->config[c].bConfigurationValue); + env->SetByteField(usb_confDescObj, usb_confDescFID_iConfiguration, dev->config[c].iConfiguration); + env->SetByteField(usb_confDescObj, usb_confDescFID_bmAttributes, dev->config[c].bmAttributes); + env->SetByteField(usb_confDescObj, usb_confDescFID_MaxPower, dev->config[c].MaxPower); + env->SetIntField(usb_confDescObj, usb_confDescFID_extralen, dev->config[c].extralen); + // extra descriptors are not interpreted!!! + env->SetObjectField(usb_confDescObj, usb_confDescFID_extra, NULL); + if (dev->config[c].extra){ + printf("The Device %d contains an extra descriptor!\n", dev->devnum); + printf("Extra descriptors are not passed to java!\n"); + } + // interface + usb_intObjArray = env->NewObjectArray(dev->config[c].bNumInterfaces, usb_intClazz, NULL); + if (!usb_intObjArray) { printf("Error NewObject 8\n"); return NULL; } + for (int i = 0; i < dev->config[c].bNumInterfaces; i++){ +#ifdef DEBUGON + printf("\t\t\tusb_get_busses: interface %x (5)\n", i); +#endif + if (dev->config[c].interface == NULL) { + printf("dev->config[c].interface == NULL\n"); + return main_usb_busObj; + } + + usb_intObj = env->NewObject(usb_intClazz, usb_intMid); + if (!usb_intObj) { printf("Error NewObject 9\n"); return NULL; } + env->SetObjectArrayElement(usb_intObjArray, i, usb_intObj); + env->SetIntField(usb_intObj, usb_intFID_num_altsetting, dev->config[c].interface[i].num_altsetting); + // interface descriptor + usb_intDescObjArray = env->NewObjectArray(dev->config[c].interface[i].num_altsetting, usb_intDescClazz, NULL); + if (!usb_intDescObjArray) { printf("Error NewObject 10\n"); return NULL; } + for (int a = 0; a < dev->config[c].interface[i].num_altsetting; a++){ +#ifdef DEBUGON + printf("\t\t\t\tusb_get_busses: interface descriptor %x (6)\n", a); +#endif + if (dev->config[c].interface[i].altsetting == NULL) { + printf("dev->config[c].interface[i].altsetting == NULL\n"); + return main_usb_busObj; + } + + usb_intDescObj = env->NewObject(usb_intDescClazz, usb_intDescMid); + if (!usb_intDescObj) { printf("Error NewObject 11\n"); return NULL; } + env->SetObjectArrayElement(usb_intDescObjArray, a, usb_intDescObj); + env->SetByteField(usb_intDescObj, usb_intDescFID_bLength, dev->config[c].interface[i].altsetting[a].bLength); + env->SetByteField(usb_intDescObj, usb_intDescFID_bDescriptorType, dev->config[c].interface[i].altsetting[a].bDescriptorType); + env->SetByteField(usb_intDescObj, usb_intDescFID_bInterfaceNumber, dev->config[c].interface[i].altsetting[a].bInterfaceNumber); + env->SetByteField(usb_intDescObj, usb_intDescFID_bAlternateSetting, dev->config[c].interface[i].altsetting[a].bAlternateSetting); + env->SetByteField(usb_intDescObj, usb_intDescFID_bNumEndpoints, dev->config[c].interface[i].altsetting[a].bNumEndpoints); + env->SetByteField(usb_intDescObj, usb_intDescFID_bInterfaceClass, dev->config[c].interface[i].altsetting[a].bInterfaceClass); + env->SetByteField(usb_intDescObj, usb_intDescFID_bInterfaceSubClass, dev->config[c].interface[i].altsetting[a].bInterfaceSubClass); + env->SetByteField(usb_intDescObj, usb_intDescFID_bInterfaceProtocol, dev->config[c].interface[i].altsetting[a].bInterfaceProtocol); + env->SetByteField(usb_intDescObj, usb_intDescFID_iInterface, dev->config[c].interface[i].altsetting[a].iInterface); + env->SetIntField(usb_intDescObj, usb_intDescFID_extralen, dev->config[c].interface[i].altsetting[a].extralen); + // extra descriptors are not interpreted!!! + if (dev->config[c].interface[i].altsetting[a].extra){ + printf("The Device %d contains an extra interface descriptor!\n", dev->devnum); + printf("Extra descriptors are not passed to java!\n"); + } + env->SetObjectField(usb_intDescObj, usb_intDescFID_extra, NULL); + // endpoint descriptor + usb_epDescObjArray = env->NewObjectArray(dev->config[c].interface[i].altsetting[a].bNumEndpoints, usb_epDescClazz, NULL); + if (!usb_epDescObjArray) { printf("Error NewObject 12\n"); return NULL; } + for (int e = 0; e < dev->config[c].interface[i].altsetting[a].bNumEndpoints; e++){ +#ifdef DEBUGON + printf("\t\t\t\t\tusb_get_busses: endpoint descriptor %x (7)\n", e); +#endif + if (dev->config[c].interface[i].altsetting[a].endpoint == NULL) { + printf("dev->config[c].interface[i].altsetting[a].endpoint == NULL\n"); + return main_usb_busObj; + } + + usb_epDescObj = env->NewObject(usb_epDescClazz, usb_epDescMid); + if (!usb_epDescObj) { printf("Error NewObject 13\n"); return NULL; } + env->SetObjectArrayElement(usb_epDescObjArray, e, usb_epDescObj); + env->SetByteField(usb_epDescObj, usb_epDescFID_bLength, dev->config[c].interface[i].altsetting[a].endpoint[e].bLength); + env->SetByteField(usb_epDescObj, usb_epDescFID_bDescriptorType, dev->config[c].interface[i].altsetting[a].endpoint[e].bDescriptorType); + env->SetByteField(usb_epDescObj, usb_epDescFID_bEndpointAddress, dev->config[c].interface[i].altsetting[a].endpoint[e].bEndpointAddress); + env->SetByteField(usb_epDescObj, usb_epDescFID_bmAttributes, dev->config[c].interface[i].altsetting[a].endpoint[e].bmAttributes); + env->SetShortField(usb_epDescObj, usb_epDescFID_wMaxPacketSize, dev->config[c].interface[i].altsetting[a].endpoint[e].wMaxPacketSize); + env->SetByteField(usb_epDescObj, usb_epDescFID_bInterval, dev->config[c].interface[i].altsetting[a].endpoint[e].bInterval); + env->SetByteField(usb_epDescObj, usb_epDescFID_bRefresh, dev->config[c].interface[i].altsetting[a].endpoint[e].bRefresh); + env->SetByteField(usb_epDescObj, usb_epDescFID_bSynchAddress, dev->config[c].interface[i].altsetting[a].endpoint[e].bSynchAddress); + env->SetIntField(usb_epDescObj, usb_epDescFID_extralen, dev->config[c].interface[i].altsetting[a].endpoint[e].extralen); + // extra descriptors are not interpreted!!! + if (dev->config[c].interface[i].altsetting[a].endpoint[e].extra){ + printf("The Device %d contains an extra endpoint descriptor!\n", dev->devnum); + printf("Extra descriptors are not passed to java!\n"); + } + env->SetObjectField(usb_epDescObj, usb_epDescFID_extra, NULL); + } + env->SetObjectField(usb_intDescObj, usb_intDescFID_endpoint, usb_epDescObjArray); + } + env->SetObjectField(usb_intObj, usb_intFID_altsetting, usb_intDescObjArray); + } + env->SetObjectField(usb_confDescObj, usb_confDescFID_interface_, usb_intObjArray); + } + + + env->SetObjectField(usb_devObj, usb_devFID_config, usb_confDescObjArray); + + usb_devObj_prev = usb_devObj; + usb_devObj = usb_devObj_next; + dev = dev->next; + } + env->SetObjectField(usb_busObj, usb_busFID_devices, main_usb_devObj); + env->SetObjectField(usb_busObj, usb_busFID_root_dev, main_usb_devObj); + + usb_busObj_prev = usb_busObj; + usb_busObj = usb_busObj_next; + bus = bus->next; + } + +#ifdef DEBUGON + printf("usb_get_busses: done\n"); +#endif + return main_usb_busObj; + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_open + * Signature: (Lch/ntb/usb/Usb_Device;)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1open + (JNIEnv *env, jobject obj, jobject dev) + { + if (busses == NULL) { return -1; } + + unsigned char devnum = env->GetByteField(dev, usb_devFID_devnum); + struct usb_bus *tmpBus; + + for (tmpBus = busses; tmpBus; tmpBus = tmpBus->next) { + struct usb_device *device; + for (device = tmpBus->devices; device; device = device->next) { + if (device->devnum == devnum){ + return (jint) usb_open(device); + } + } + } + return -3; + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_close + * Signature: (I)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1close + (JNIEnv *env, jobject obj, jint dev_handle) + { + return (jint) usb_close((usb_dev_handle *) dev_handle); + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_set_configuration + * Signature: (II)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1set_1configuration + (JNIEnv *env, jobject obj, jint dev_handle, jint configuration) + { + return usb_set_configuration((usb_dev_handle *) dev_handle, configuration); + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_set_altinterface + * Signature: (II)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1set_1altinterface + (JNIEnv *env, jobject obj, jint dev_handle, jint alternate) + { + return usb_set_altinterface((usb_dev_handle *) dev_handle, alternate); + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_clear_halt + * Signature: (II)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1clear_1halt + (JNIEnv *env, jobject obj, jint dev_handle, jint ep) + { + return usb_clear_halt((usb_dev_handle *) dev_handle, (unsigned) ep); + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_reset + * Signature: (I)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1reset + (JNIEnv *env, jobject obj, jint dev_handle) + { + return usb_reset((usb_dev_handle *) dev_handle); + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_claim_interface + * Signature: (II)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1claim_1interface + (JNIEnv *env, jobject obj, jint dev_handle, jint interface) + { + return usb_claim_interface((usb_dev_handle *) dev_handle, interface); + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_release_interface + * Signature: (II)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1release_1interface + (JNIEnv *env, jobject obj, jint dev_handle, jint interface) + { + return usb_release_interface((usb_dev_handle *) dev_handle, interface); + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_control_msg + * Signature: (IIIII[BII)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1control_1msg + (JNIEnv *env, jobject obj, jint dev_handle, jint requesttype, jint request, jint value, jint index, jbyteArray jbytes, jint size, jint timeout) + { + jbyte *bytes = env->GetByteArrayElements(jbytes, NULL); + int retVal = usb_control_msg((usb_dev_handle *) dev_handle, requesttype, request, value, index, (char *) bytes, size, timeout); + if (bytes) { return retVal; } + jbytes = env->NewByteArray(size); + env->SetByteArrayRegion(jbytes, 0, size, bytes); + return retVal; + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_get_string + * Signature: (IIILjava/lang/String;I)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1get_1string + (JNIEnv *env, jobject obj, jint dev_handle, jint index, jint langid, jstring jbuf, jint buflen) + { + const jchar *buf = env->GetStringChars(jbuf, NULL); + int retVal = usb_get_string((usb_dev_handle *) dev_handle, index, langid, (char *) buf, buflen); + jbuf = env->NewString(buf, buflen); + return retVal; + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_get_string_simple + * Signature: (IILjava/lang/String;I)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1get_1string_1simple + (JNIEnv *env, jobject obj, jint dev_handle, jint index, jstring jbuf, jint buflen) + { + const jchar *buf = env->GetStringChars(jbuf, NULL); + int retVal = usb_get_string_simple((usb_dev_handle *) dev_handle, index, (char *) buf, buflen); + jbuf = env->NewString(buf, buflen); + return retVal; + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_get_descriptor + * Signature: (IBBLjava/lang/String;I)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1get_1descriptor + (JNIEnv *env, jobject obj, jint dev_handle, jbyte type, jbyte index, jstring buf, jint size) + { + return usb_get_descriptor((usb_dev_handle *) dev_handle, (unsigned) type, (unsigned) index, buf, size); + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_get_descriptor_by_endpoint + * Signature: (IIBBLjava/lang/String;I)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1get_1descriptor_1by_1endpoint + (JNIEnv *env, jobject obj, jint dev_handle, jint ep, jbyte type, jbyte index, jstring buf, jint size) + { + return usb_get_descriptor_by_endpoint((usb_dev_handle *) dev_handle, ep, (unsigned) type, (unsigned) index, buf, size); + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_bulk_write + * Signature: (II[BII)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1bulk_1write + (JNIEnv *env, jobject obj, jint dev_handle, jint ep, jbyteArray jbytes, jint size, jint timeout) + { + jbyte *bytes = env->GetByteArrayElements(jbytes, NULL); + return usb_bulk_write((usb_dev_handle *) dev_handle, ep, (char *) bytes, size, timeout); + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_bulk_read + * Signature: (II[BII)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1bulk_1read + (JNIEnv *env, jobject obj, jint dev_handle, jint ep, jbyteArray jbytes, jint size, jint timeout) + { + char *bytes = (char *) malloc(size*sizeof(char)); + int retVal = usb_bulk_read((usb_dev_handle *) dev_handle, ep, bytes, size, timeout); + if (!bytes) { return retVal; } + // jbytes = env->NewByteArray(size); + env->SetByteArrayRegion(jbytes, 0, size, (jbyte *) bytes); + free(bytes); + return retVal; + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_interrupt_write + * Signature: (II[BII)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1interrupt_1write + (JNIEnv *env, jobject obj, jint dev_handle, jint ep, jbyteArray jbytes, jint size, jint timeout) + { + jbyte *bytes = env->GetByteArrayElements(jbytes, NULL); + return usb_interrupt_write((usb_dev_handle *) dev_handle, ep, (char *) bytes, size, timeout); + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_interrupt_read + * Signature: (II[BII)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1interrupt_1read + (JNIEnv *env, jobject obj, jint dev_handle, jint ep, jbyteArray jbytes, jint size, jint timeout) + { + jbyte *bytes; + int retVal = usb_interrupt_write((usb_dev_handle *) dev_handle, ep, (char *) bytes, size, timeout); + if (bytes) { return retVal; } + jbytes = env->NewByteArray(size); + env->SetByteArrayRegion(jbytes, 0, size, bytes); + return retVal; + } + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_strerror + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_ch_ntb_usb_LibusbWin_usb_1strerror + (JNIEnv *env, jobject obj){ + + char *str = usb_strerror(); + return env->NewStringUTF(str); + } + + diff --git a/libusbdll/LibusbWin.dll b/libusbdll/LibusbWin.dll new file mode 100644 index 0000000000000000000000000000000000000000..fb5fd4a957698d0fef9ca9511c347865a4bbcca8 GIT binary patch literal 37740 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

WQ+XWZ5?rW=VS_#Z9Gb zXg7+U)-WQY`ea6(llDxLb{Zoabh(2j?b|hs(0=4IX{W)4L02ISV+<5`t4aGd4I{Gd z0Z@j^I$0|8qs_>kQGK`m?Qb=WX<513tjEu$+`z+VN*&#H z-g2V}>zl%gf?v*=2FzGZx~iHw+B#AA7i6!%no4TVMJ70Drf8@;MfAyB1I4{F8BnQ0mQ2r=%QJHYer=Z9dn^P`Bg2uCEY9vFRugP{>{l)59>lOu6L8L6L1Hr~C+%O$P0+nz)XcCW6;$JO0j|KYoJg>HOY^GGSPtP z1*J!ogZ2kYEO`F#7?P)lfU&DF#M4anx^AaRA;mm7e-&BjG1$Bwm>vVyw@8k` z!Y4tYO^e1)K$&i^XCEl#z-V>n*PsxGX5k-&9F2k{K#JQSXB;TRrpd7p1)D}G1ZA1Q z!iAvJ7`Rq~ve|&SQ^?V@Z#7Y#1f|&^rw^1mgPbFv)EY1!fzrpKD%*|Gd5U5)a9sh4 z-9Whklm=CfSG@Gy&E&|IWIiyxj3Oo92Ffy(i{jD&im`3^1}HrSU5|ny$74JXe+){i zLC$`XgAGJf#W!)~tqBGf;jw-7l7{+-FBIwOta3Op76^pGc(EEoFT73WrS<6Q1=`*Y zZ+LZZwU@o)>`k#Ogg{lrN-7v%$HWI5X~V_4*lFO|`Xp648*=A+zp_}aR&hA${gDOj zksAa4V6#VCx>8r-UEM;o1vNnoTF#Ndq{c~V_{!Qjp^$IAC+KhUw?{m64wqak!|3|O zGkUF`h2La^!>umw6-Ly}@~+1ExNul=+~{mt9A-r>cw66!wGktPHEh(B9*bF(6RPH} zkN8K>p$Mf^&(_2(ZMe}>x3DQms_C{_gj>zF5v;9u zc#V?N<}xWPQ4`CfrIf?&UESu7w058l-EGj62Hd2=VV~#c>9n9mr(|JMy(`I$k$`5g z4v1YOtQ=YHh)9#*5?WitJ~v=0!sJ^i+EH4dLQS(tg~JKkQ{=uO?&&e4FsCVq^)sxi zNC6CEA&tYZ3a83Zl(IWuT>5oA=`iv2L2S(~ga0*)7SnMpc};OTHp+ES+Dhbfxa5i| zT0LClwp%1Yv1kBUlfJ~i3Jc!RtvI}^8__EAP9<2kFsThpm&qdMP}M2tL=TdbUr9Gj z>`tnjI(F6zhLh~AYc)tsn$3p|zPyPRIWUfbJ-PYJEV zTS1J}-sCTEC>Za1TbjIU{Ob#x?4pC{F0(q#W4h-TGaj6(GX^g?N;j7*UEHu>k;hwC z?^#-Nvv-N7_U3AD?SlFSOw8GrAlRBrM9mlRVf`s4Cv?N>t!cP`lgnbi=$4PEeOVQ7(wC_Yokoy|T65pl1_I8JOT!Gbxw(%i`}_<@YwyHzcT8V zVJ)!cBV~}5g)CrbIoOkAvA&;$hpH;2GyQUB5xn8*i+EV5%V#;#V|hSdbK~K+Amd3R zH3{Y-Pcr#lk!@c3NS3!@{?f$@y)|6_J_PJLEow{t0YXC+DEY~LyIe`*&2LT&L5<% zR@5PL&Z=?Ibr0ljJEu~15Xou sJ8rB;ylhnType02T9U)}_@db+Yxq+|YTUG_8@p#h$!aPSl;_8P0#mM+r~m)} literal 0 HcmV?d00001 diff --git a/libusbdll/LibusbWin.h b/libusbdll/LibusbWin.h new file mode 100644 index 0000000..97542f9 --- /dev/null +++ b/libusbdll/LibusbWin.h @@ -0,0 +1,189 @@ +/* DO NOT EDIT THIS FILE - it is machine generated */ +#include +/* Header for class ch_ntb_usb_LibusbWin */ + +#ifndef _Included_ch_ntb_usb_LibusbWin +#define _Included_ch_ntb_usb_LibusbWin +#ifdef __cplusplus +extern "C" { +#endif +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_init + * Signature: ()V + */ +JNIEXPORT void JNICALL Java_ch_ntb_usb_LibusbWin_usb_1init + (JNIEnv *, jobject); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_find_busses + * Signature: ()I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1find_1busses + (JNIEnv *, jobject); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_find_devices + * Signature: ()I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1find_1devices + (JNIEnv *, jobject); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_get_busses + * Signature: ()Lch/ntb/usb/Usb_Bus; + */ +JNIEXPORT jobject JNICALL Java_ch_ntb_usb_LibusbWin_usb_1get_1busses + (JNIEnv *, jobject); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_open + * Signature: (Lch/ntb/usb/Usb_Device;)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1open + (JNIEnv *, jobject, jobject); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_close + * Signature: (I)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1close + (JNIEnv *, jobject, jint); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_set_configuration + * Signature: (II)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1set_1configuration + (JNIEnv *, jobject, jint, jint); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_set_altinterface + * Signature: (II)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1set_1altinterface + (JNIEnv *, jobject, jint, jint); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_clear_halt + * Signature: (II)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1clear_1halt + (JNIEnv *, jobject, jint, jint); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_reset + * Signature: (I)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1reset + (JNIEnv *, jobject, jint); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_claim_interface + * Signature: (II)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1claim_1interface + (JNIEnv *, jobject, jint, jint); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_release_interface + * Signature: (II)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1release_1interface + (JNIEnv *, jobject, jint, jint); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_control_msg + * Signature: (IIIII[BII)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1control_1msg + (JNIEnv *, jobject, jint, jint, jint, jint, jint, jbyteArray, jint, jint); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_get_string + * Signature: (IIILjava/lang/String;I)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1get_1string + (JNIEnv *, jobject, jint, jint, jint, jstring, jint); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_get_string_simple + * Signature: (IILjava/lang/String;I)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1get_1string_1simple + (JNIEnv *, jobject, jint, jint, jstring, jint); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_get_descriptor + * Signature: (IBBLjava/lang/String;I)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1get_1descriptor + (JNIEnv *, jobject, jint, jbyte, jbyte, jstring, jint); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_get_descriptor_by_endpoint + * Signature: (IIBBLjava/lang/String;I)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1get_1descriptor_1by_1endpoint + (JNIEnv *, jobject, jint, jint, jbyte, jbyte, jstring, jint); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_bulk_write + * Signature: (II[BII)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1bulk_1write + (JNIEnv *, jobject, jint, jint, jbyteArray, jint, jint); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_bulk_read + * Signature: (II[BII)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1bulk_1read + (JNIEnv *, jobject, jint, jint, jbyteArray, jint, jint); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_interrupt_write + * Signature: (II[BII)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1interrupt_1write + (JNIEnv *, jobject, jint, jint, jbyteArray, jint, jint); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_interrupt_read + * Signature: (II[BII)I + */ +JNIEXPORT jint JNICALL Java_ch_ntb_usb_LibusbWin_usb_1interrupt_1read + (JNIEnv *, jobject, jint, jint, jbyteArray, jint, jint); + +/* + * Class: ch_ntb_usb_LibusbWin + * Method: usb_strerror + * Signature: ()Ljava/lang/String; + */ +JNIEXPORT jstring JNICALL Java_ch_ntb_usb_LibusbWin_usb_1strerror + (JNIEnv *, jobject); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/libusbdll/libusb.lib b/libusbdll/libusb.lib new file mode 100644 index 0000000000000000000000000000000000000000..b5467c0748d2152ac7f9d773f7eec54749581849 GIT binary patch literal 10792 zcmcIq&2Jn<7Jqi|CO8I+lQ?$b#N%%}KsIq^94tkV`B=0GCW%bYo=|%{(~es^?yVo9+y>^rov`y;r~b zc(3YJ^~~L92CajeqkpU=pQ~5bH`g~CZ#FiQ{3|NEer;o2CU-}P=r2SQ&xp>f5>4(B zEj*HR?lzI2i{MA}Io_ZPUn#nQH)!fJNoT(%5;XsXq`4;z3=ECtQ91v$>G z5ANOFx$nIDrw`xRxpnXU-5san?e)XGE95wLKHA>S3eew`ge<@R=a25Z@4Wlg{kNdu z9UeIjw4Lse>k~_vl2)f1y0S}p|rcK^dY{VtcNVmFvFX(oh!%z)-f??!B%npk7y$AiE+4H(;f-P*L)9N(6Lnp%C zZ?@ujPce;r;C9?*=%zI+Y@;I@(CqY5AX%=_2war9M{>mDj45xS5rK1nN~H+T8>vW< z)xqZ;R*V_z2C~@XjJD@{s&<(&C8FhRcdxHzgJq4(zUQ|c_-W{d5+cD!$+g{wUMnFO zbBv^9$;x!vlnUqKa6E6MJU{F;I~^x<1A*xHYKU$8A}uHA`|VCgHYTea7n?fzepXDX z+e?ZyV*s&~*(!(yOg$RE9e5AjAk%fmF3^eV6~LJq<5E*YuiI}OKyu&N_c~_4E$jlF zxL$#pQH@JY4Py4u$uM365)32fh27Rc(Dl3h5H`{4A34qN6ThYAHLuXi7xyUEn+euZ=noD$)=Q(@9#PQF@)m=`@Yd%XFTm z=^VX5GxQ>zpg+)YTB5TwNAq-nF49Z1N@KK4FVH1=jb5cQbc!bE6`G<+TB8M8q*_q<8wv3eOvtDYPuaT83}994@^bTdUBq zWjZeW)dkZCWGpIo|?ydwqp31jg~hnQ)rnvTVTTLu$9Nvh^?Nj9&t9aZSoaENF~>bh+~iO(;>7u z_VG1ARG?P_kxr}wF+)n|P&c*fajzE|Nw1c{Mv|BGbgiR(JeiNZTeD-o77QN6OJ`$& zo)k#26Ek4*U#?~RI;EEMS*fCVnJLWpX(XQ)eu+YJd^i3l2h!x3KMEC#CrUP&qg9dA zr!FK@ekY^_H|24f%}+$JmqmpM{}P;x^GN&*J29ps8;ZtNX9r(e0sQ^uK@IeP?V4aSvh|5!PIe`oH+0%o4qg#6NUKy|-xm?aN-f*=sJY z>mpnY(Z50eRg7bJZ_$-+l-!15BLcz$JS``(TU7gI81D(hP2xGpI<-ot#*c$1>J!g# zL|h|d6CZf3pc{7gd$rY_wc7TrJMYWl)UQAjnxY0mYczjra5&X0|v!14Z{)qn)p$VsGVq2<-}{4cJTXL zQQL23DeH}^%uTG4(g? zy~9xxR>ONI<6l-kv2-b{hW`AK>K%^TSiKZhBKBek)zPlmdo~BO7h<$jT*m<`&tB13 zju^x^XyjllU1}`rIlaSG1y28ZETiubtm^6(S=S3nYR<&Ebv(vl(e7YqIrfjs4`8WY zsZg2&v2?l7E9jNDKZ(BT@GzYLR3F14yB|%U=`#R_W9f2zEAZ%(F`7AFu=*?eSdqn# zX)Jbj83e1L?(S+SORT{*UgB8n9%K-_jT~Ei9e6L>@e*gQL9mO)^%ah-&U1rcH5&GH zasmAu&tmDbB8RNLQWp5%s~l4wLaXdF)&l+;m~yIl2^ zMgNN+?GyMwj(cIXj_Ctr*uv^U{kk6!%%@LpD@N_B6jhsF2HDFHW zW7@h~*pDJ=;ERUtY0ga!H{r_2^@4Tbyhe_$i8u^Pmzv3Y ztC4e7!G|e)2U25cu*~%q>s0kssA%Q8Xi(GtdKd_^DE^%_nD7feh}HX6&)FUExexa! z@rVKkw|)clsOaoBr;&h@yi(+lEM3l8a{4BA{&|j=ysl(0&oQ1k7Aj8D3mjA4g${<5 zvq#|*F1~oGxr_g|!l78Y+(;IjY?opreu>KvxY?9LE10)sjh49y<}lUgttir1$;Gs7 oy{zZudYf~e!H0Kz)mF1;yT49!xGL&K&KQgT4XhQR+PXaYf7ONaEC2ui literal 0 HcmV?d00001 diff --git a/libusbdll/makefile b/libusbdll/makefile new file mode 100644 index 0000000..2eddc1b --- /dev/null +++ b/libusbdll/makefile @@ -0,0 +1,20 @@ +CC = gcc +SOURCENAME = LibusbWin +DDLNAME = LibusbWin +EXENAME = LibusbTest +JAVAPATH = "C:/Program Files/Java/jdk1.5.0_04" +TARGETDIR = D:/work/USB/libusb/libusbdllMinGW +## -IDLOUT:$(DDLNAME) -MIDL:$(DDLNAME) -TLBOUT:$(DDLNAME) +## $(CC) -LD $(SOURCENAME).c -Fe$(DDLNAME).dll -link libusb.lib + +dll: $(DDLNAME).dll +$(DDLNAME).dll: $(SOURCENAME).cpp + $(CC) -Wall -D_JNI_IMPLEMENTATION_ -Wl,--kill-at -I$(JAVAPATH)/include -I$(JAVAPATH)/include/win32 -shared $(SOURCENAME).cpp -o $(DDLNAME).dll libusb.lib + +cleanDll: + rm $(DDLNAME).dll + +testExe: $(EXENAME).exe +$(EXENAME).exe: $(EXENAME).cpp + $(CC) $(EXENAME).cpp -o $(EXENAME).exe $(TARGETDIR)/libusb.a + diff --git a/libusbdll/stdafx.h b/libusbdll/stdafx.h new file mode 100644 index 0000000..1ad3b78 --- /dev/null +++ b/libusbdll/stdafx.h @@ -0,0 +1,13 @@ +// stdafx.h : include file for standard system include files, +// or project specific include files that are used frequently, but +// are changed infrequently +// + +#pragma once + + +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers +// Windows Header Files: +#include + +// TODO: reference additional headers your program requires here diff --git a/libusbdll/usb.h b/libusbdll/usb.h new file mode 100644 index 0000000..04f5afa --- /dev/null +++ b/libusbdll/usb.h @@ -0,0 +1,374 @@ +#ifndef __USB_H__ +#define __USB_H__ + +#include + +/* + * 'interface' is defined somewhere in the Windows header files. This macro + * is deleted here to avoid conflicts and compile errors. + */ + +#ifdef interface +#undef interface +#endif + +/* + * PATH_MAX from limits.h can't be used on Windows if the dll and + * import libraries are build/used by different compilers + */ + +#define LIBUSB_PATH_MAX 512 + + +/* + * USB spec information + * + * This is all stuff grabbed from various USB specs and is pretty much + * not subject to change + */ + +/* + * Device and/or Interface Class codes + */ +#define USB_CLASS_PER_INTERFACE 0 /* for DeviceClass */ +#define USB_CLASS_AUDIO 1 +#define USB_CLASS_COMM 2 +#define USB_CLASS_HID 3 +#define USB_CLASS_PRINTER 7 +#define USB_CLASS_MASS_STORAGE 8 +#define USB_CLASS_HUB 9 +#define USB_CLASS_DATA 10 +#define USB_CLASS_VENDOR_SPEC 0xff + +/* + * Descriptor types + */ +#define USB_DT_DEVICE 0x01 +#define USB_DT_CONFIG 0x02 +#define USB_DT_STRING 0x03 +#define USB_DT_INTERFACE 0x04 +#define USB_DT_ENDPOINT 0x05 + +#define USB_DT_HID 0x21 +#define USB_DT_REPORT 0x22 +#define USB_DT_PHYSICAL 0x23 +#define USB_DT_HUB 0x29 + +/* + * Descriptor sizes per descriptor type + */ +#define USB_DT_DEVICE_SIZE 18 +#define USB_DT_CONFIG_SIZE 9 +#define USB_DT_INTERFACE_SIZE 9 +#define USB_DT_ENDPOINT_SIZE 7 +#define USB_DT_ENDPOINT_AUDIO_SIZE 9 /* Audio extension */ +#define USB_DT_HUB_NONVAR_SIZE 7 + + +/* ensure byte-packed structures */ +#include + + +/* All standard descriptors have these 2 fields in common */ +struct usb_descriptor_header { + unsigned char bLength; + unsigned char bDescriptorType; +}; + +/* String descriptor */ +struct usb_string_descriptor { + unsigned char bLength; + unsigned char bDescriptorType; + unsigned short wData[1]; +}; + +/* HID descriptor */ +struct usb_hid_descriptor { + unsigned char bLength; + unsigned char bDescriptorType; + unsigned short bcdHID; + unsigned char bCountryCode; + unsigned char bNumDescriptors; +}; + +/* Endpoint descriptor */ +#define USB_MAXENDPOINTS 32 +struct usb_endpoint_descriptor { + unsigned char bLength; + unsigned char bDescriptorType; + unsigned char bEndpointAddress; + unsigned char bmAttributes; + unsigned short wMaxPacketSize; + unsigned char bInterval; + unsigned char bRefresh; + unsigned char bSynchAddress; + + unsigned char *extra; /* Extra descriptors */ + int extralen; +}; + +#define USB_ENDPOINT_ADDRESS_MASK 0x0f /* in bEndpointAddress */ +#define USB_ENDPOINT_DIR_MASK 0x80 + +#define USB_ENDPOINT_TYPE_MASK 0x03 /* in bmAttributes */ +#define USB_ENDPOINT_TYPE_CONTROL 0 +#define USB_ENDPOINT_TYPE_ISOCHRONOUS 1 +#define USB_ENDPOINT_TYPE_BULK 2 +#define USB_ENDPOINT_TYPE_INTERRUPT 3 + +/* Interface descriptor */ +#define USB_MAXINTERFACES 32 +struct usb_interface_descriptor { + unsigned char bLength; + unsigned char bDescriptorType; + unsigned char bInterfaceNumber; + unsigned char bAlternateSetting; + unsigned char bNumEndpoints; + unsigned char bInterfaceClass; + unsigned char bInterfaceSubClass; + unsigned char bInterfaceProtocol; + unsigned char iInterface; + + struct usb_endpoint_descriptor *endpoint; + + unsigned char *extra; /* Extra descriptors */ + int extralen; +}; + +#define USB_MAXALTSETTING 128 /* Hard limit */ + +struct usb_interface { + struct usb_interface_descriptor *altsetting; + + int num_altsetting; +}; + +/* Configuration descriptor information.. */ +#define USB_MAXCONFIG 8 +struct usb_config_descriptor { + unsigned char bLength; + unsigned char bDescriptorType; + unsigned short wTotalLength; + unsigned char bNumInterfaces; + unsigned char bConfigurationValue; + unsigned char iConfiguration; + unsigned char bmAttributes; + unsigned char MaxPower; + + struct usb_interface *interface; + + unsigned char *extra; /* Extra descriptors */ + int extralen; +}; + +/* Device descriptor */ +struct usb_device_descriptor { + unsigned char bLength; + unsigned char bDescriptorType; + unsigned short bcdUSB; + unsigned char bDeviceClass; + unsigned char bDeviceSubClass; + unsigned char bDeviceProtocol; + unsigned char bMaxPacketSize0; + unsigned short idVendor; + unsigned short idProduct; + unsigned short bcdDevice; + unsigned char iManufacturer; + unsigned char iProduct; + unsigned char iSerialNumber; + unsigned char bNumConfigurations; +}; + +struct usb_ctrl_setup { + unsigned char bRequestType; + unsigned char bRequest; + unsigned short wValue; + unsigned short wIndex; + unsigned short wLength; +}; + +/* + * Standard requests + */ +#define USB_REQ_GET_STATUS 0x00 +#define USB_REQ_CLEAR_FEATURE 0x01 +/* 0x02 is reserved */ +#define USB_REQ_SET_FEATURE 0x03 +/* 0x04 is reserved */ +#define USB_REQ_SET_ADDRESS 0x05 +#define USB_REQ_GET_DESCRIPTOR 0x06 +#define USB_REQ_SET_DESCRIPTOR 0x07 +#define USB_REQ_GET_CONFIGURATION 0x08 +#define USB_REQ_SET_CONFIGURATION 0x09 +#define USB_REQ_GET_INTERFACE 0x0A +#define USB_REQ_SET_INTERFACE 0x0B +#define USB_REQ_SYNCH_FRAME 0x0C + +#define USB_TYPE_STANDARD (0x00 << 5) +#define USB_TYPE_CLASS (0x01 << 5) +#define USB_TYPE_VENDOR (0x02 << 5) +#define USB_TYPE_RESERVED (0x03 << 5) + +#define USB_RECIP_DEVICE 0x00 +#define USB_RECIP_INTERFACE 0x01 +#define USB_RECIP_ENDPOINT 0x02 +#define USB_RECIP_OTHER 0x03 + +/* + * Various libusb API related stuff + */ + +#define USB_ENDPOINT_IN 0x80 +#define USB_ENDPOINT_OUT 0x00 + +/* Error codes */ +#define USB_ERROR_BEGIN 500000 + +/* + * This is supposed to look weird. This file is generated from autoconf + * and I didn't want to make this too complicated. + */ +#define USB_LE16_TO_CPU(x) + +/* Data types */ +/* struct usb_device; */ +/* struct usb_bus; */ + +struct usb_device { + struct usb_device *next, *prev; + + char filename[LIBUSB_PATH_MAX]; + + struct usb_bus *bus; + + struct usb_device_descriptor descriptor; + struct usb_config_descriptor *config; + + void *dev; /* Darwin support */ + + unsigned char devnum; + + unsigned char num_children; + struct usb_device **children; +}; + +struct usb_bus { + struct usb_bus *next, *prev; + + char dirname[LIBUSB_PATH_MAX]; + + struct usb_device *devices; + unsigned long location; + + struct usb_device *root_dev; +}; + +/* Version information, Windows specific */ +struct usb_version { + struct { + int major; + int minor; + int micro; + int nano; + } dll; + struct { + int major; + int minor; + int micro; + int nano; + } driver; +}; + + +struct usb_dev_handle; +typedef struct usb_dev_handle usb_dev_handle; + +/* Variables */ +extern struct usb_bus *usb_busses; + + +#include + + +#ifdef __cplusplus +extern "C" { +#endif + + /* Function prototypes */ + + /* usb.c */ + usb_dev_handle *usb_open(struct usb_device *dev); + int usb_close(usb_dev_handle *dev); + int usb_get_string(usb_dev_handle *dev, int index, int langid, char *buf, + size_t buflen); + int usb_get_string_simple(usb_dev_handle *dev, int index, char *buf, + size_t buflen); + + /* descriptors.c */ + int usb_get_descriptor_by_endpoint(usb_dev_handle *udev, int ep, + unsigned char type, unsigned char index, + void *buf, int size); + int usb_get_descriptor(usb_dev_handle *udev, unsigned char type, + unsigned char index, void *buf, int size); + + /* .c */ + int usb_bulk_write(usb_dev_handle *dev, int ep, char *bytes, int size, + int timeout); + int usb_bulk_read(usb_dev_handle *dev, int ep, char *bytes, int size, + int timeout); + int usb_interrupt_write(usb_dev_handle *dev, int ep, char *bytes, int size, + int timeout); + int usb_interrupt_read(usb_dev_handle *dev, int ep, char *bytes, int size, + int timeout); + int usb_control_msg(usb_dev_handle *dev, int requesttype, int request, + int value, int index, char *bytes, int size, + int timeout); + int usb_set_configuration(usb_dev_handle *dev, int configuration); + int usb_claim_interface(usb_dev_handle *dev, int interface); + int usb_release_interface(usb_dev_handle *dev, int interface); + int usb_set_altinterface(usb_dev_handle *dev, int alternate); + int usb_resetep(usb_dev_handle *dev, unsigned int ep); + int usb_clear_halt(usb_dev_handle *dev, unsigned int ep); + int usb_reset(usb_dev_handle *dev); + + char *usb_strerror(void); + + void usb_init(void); + void usb_set_debug(int level); + int usb_find_busses(void); + int usb_find_devices(void); + struct usb_device *usb_device(usb_dev_handle *dev); + struct usb_bus *usb_get_busses(void); + + + /* Windows specific functions */ + + #define LIBUSB_HAS_INSTALL_SERVICE_NP 1 + int usb_install_service_np(void); + + #define LIBUSB_HAS_UNINSTALL_SERVICE_NP 1 + int usb_uninstall_service_np(void); + + #define LIBUSB_HAS_INSTALL_DRIVER_NP 1 + int usb_install_driver_np(const char *inf_file); + + const struct usb_version *usb_get_version(void); + + int usb_isochronous_setup_async(usb_dev_handle *dev, void **context, + unsigned char ep, int pktsize); + int usb_bulk_setup_async(usb_dev_handle *dev, void **context, + unsigned char ep); + int usb_interrupt_setup_async(usb_dev_handle *dev, void **context, + unsigned char ep); + + int usb_submit_async(void *context, char *bytes, int size); + int usb_reap_async(void *context, int timeout); + int usb_free_async(void **context); + + +#ifdef __cplusplus +} +#endif + +#endif /* __USB_H__ */ +