From 5fb104891a4679c449568597d043734ceb9339ec Mon Sep 17 00:00:00 2001 From: Jenna Fox Date: Sun, 30 Sep 2012 13:02:16 +1000 Subject: Revised Ihsan's cli upload tool to be more future proof, and take away parts of api which allow risky writing strategies. --- commandline/Makefile | 2 +- commandline/examples/micronucleus.c | 98 +++++++--------- commandline/library/micronucleus_lib.c | 111 ++++++++++++------ commandline/library/micronucleus_lib.h | 43 ++++--- commandline/library/opendevice.c | 203 --------------------------------- commandline/library/opendevice.h | 82 ------------- 6 files changed, 145 insertions(+), 394 deletions(-) delete mode 100644 commandline/library/opendevice.c delete mode 100644 commandline/library/opendevice.h (limited to 'commandline') diff --git a/commandline/Makefile b/commandline/Makefile index 3c5f255..02da2f9 100644 --- a/commandline/Makefile +++ b/commandline/Makefile @@ -26,7 +26,7 @@ LIBS = $(USBLIBS) INCLUDE = library CFLAGS = $(USBFLAGS) $(LIBS) -I$(INCLUDE) -O -g $(OSFLAG) -LWLIBS = opendevice micronucleus_lib littleWire_util +LWLIBS = micronucleus_lib littleWire_util EXAMPLES = micronucleus .PHONY: clean library diff --git a/commandline/examples/micronucleus.c b/commandline/examples/micronucleus.c index 1a6299e..abbf9c9 100644 --- a/commandline/examples/micronucleus.c +++ b/commandline/examples/micronucleus.c @@ -31,15 +31,7 @@ /****************************************************************************** * Global definitions ******************************************************************************/ -unsigned int availableMemory; -unsigned char pageSize; -unsigned char sleepAmount; -unsigned int eraseSleep; -unsigned int pages; unsigned char dataBuffer[65536 + 256]; /* buffer for file data */ -unsigned int startAddress, endAddress; -unsigned int i; -unsigned int k; /*****************************************************************************/ /****************************************************************************** @@ -57,26 +49,30 @@ int main(int argc, char **argv) { int res; char *file = NULL; + int run = 0; micronucleus *myDevice = NULL; if(argc < 2) { - printf("usage: %s [-r] []\n", argv[0]); - return 0; + printf("usage: %s [--run] []\n", argv[0]); + return EXIT_FAILURE; } if(strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0) { - printf("usage: %s [-r] []\n", argv[0]); - return 0; + printf("usage: %s [--run] []\n", argv[0]); + return EXIT_FAILURE; } - if(strcmp(argv[1], "-r") == 0) + if(strcmp(argv[1], "--run") == 0) { + run = 1; if(argc >= 3){ file = argv[2]; } } else + { file = argv[1]; + } printf("> Please plug the device ... \n"); printf("> Press CTRL+C to terminate the program.\n"); @@ -92,55 +88,44 @@ int main(int argc, char **argv) delay(750); myDevice = micronucleus_connect(); - res = micronucleus_getDeviceInfo(myDevice, &availableMemory, &pageSize, &sleepAmount); - if(res!=0) + if(myDevice->page_size == 64) { - printf(">> Abort mission! An error has occured ...\n"); - printf(">> Please unplug the device and restart the program. \n"); - return 0; + printf("> Device looks like Attiny85!\n"); } - - if(pageSize==64) - { - printf("> Device is based on Attiny85!\n"); - } - else if(pageSize==32) + else if(myDevice->page_size == 32) { - printf("> Device is based on Attiny45!\n"); + printf("> Device looks like Attiny45!\n"); } else { printf("> Unsupported device!\n"); - return 0; + return EXIT_FAILURE; } - printf("> Available space for user application: %d bytes\n",availableMemory); - printf("> Suggested sleep time between sending pages: %u miliseconds\n",sleepAmount); - - pages = availableMemory/pageSize; - if((pages*pageSize) < availableMemory) pages++; - eraseSleep = sleepAmount*pages; - - printf("> Whole page count: %d\n",pages); - printf("> Erase function sleep duration: %d miliseconds\n",eraseSleep); + printf("> Available space for user application: %d bytes\n", myDevice->flash_size); + printf("> Suggested sleep time between sending pages: %u milliseconds\n", myDevice->write_sleep); + printf("> Whole page count: %d\n", myDevice->pages); + printf("> Erase function sleep duration: %d milliseconds\n", myDevice->erase_sleep); - startAddress = sizeof(dataBuffer); - endAddress = 0; memset(dataBuffer, 0xFF, sizeof(dataBuffer)); - - if(parseIntelHex(file, dataBuffer, &startAddress, &endAddress)) - return 0; + + int startAddress = 1, endAddress = 0; + if (parseIntelHex(file, dataBuffer, &startAddress, &endAddress)) + { + printf("> Error parsing hex file.\n"); + return EXIT_FAILURE; + } if(startAddress >= endAddress) { printf("> No data in input file, exiting.\n"); - return 0; + return EXIT_FAILURE; } - if((endAddress-startAddress)>availableMemory) + if(endAddress > myDevice->flash_size) { printf("> Program file is too big for the bootloader!\n"); - return 0; + return EXIT_FAILURE; } /* Prints the decoded intel hex file */ @@ -155,35 +140,38 @@ int main(int argc, char **argv) printf("> Decoded hex file ends ... \n");*/ printf("> Erasing the memory ...\n"); - res = micronucleus_eraseFlash(myDevice,eraseSleep); + res = micronucleus_eraseFlash(myDevice); if(res!=0) { printf(">> Abort mission! An error has occured ...\n"); printf(">> Please unplug the device and restart the program. \n"); - return 0; + return EXIT_FAILURE; } printf("> Starting to upload ...\n"); - res = micronucleus_writeFlash(myDevice,startAddress,endAddress,dataBuffer,sleepAmount); + res = micronucleus_writeFlash(myDevice,endAddress,dataBuffer); if(res!=0) { printf(">> Abort mission! An error has occured ...\n"); printf(">> Please unplug the device and restart the program. \n"); - return 0; + return EXIT_FAILURE; } - printf("> Starting the user app ...\n"); - res = micronucleus_startApp(myDevice); - if(res!=0) + if (run) { - printf(">> Abort mission! An error has occured ...\n"); - printf(">> Please unplug the device and restart the program. \n"); - return 0; - } + printf("> Starting the user app ...\n"); + res = micronucleus_startApp(myDevice); + if(res!=0) + { + printf(">> Abort mission! An error has occured ...\n"); + printf(">> Please unplug the device and restart the program. \n"); + return EXIT_FAILURE; + } + } printf(">> Micronucleus done. Thank you!\n"); - return 0; + return EXIT_SUCCESS; } /******************************************************************************/ diff --git a/commandline/library/micronucleus_lib.c b/commandline/library/micronucleus_lib.c index 8e01427..a719690 100644 --- a/commandline/library/micronucleus_lib.c +++ b/commandline/library/micronucleus_lib.c @@ -29,60 +29,98 @@ micronucleus* micronucleus_connect() { - micronucleus *tempHandle = NULL; - + micronucleus *nucleus = NULL; + struct usb_bus *busses; + + // intialise usb and find micronucleus device usb_init(); - usbOpenDevice(&tempHandle, VENDOR_ID, "*", PRODUCT_ID, "*", "*", NULL, NULL ); + usb_find_busses(); + usb_find_devices(); + + busses = usb_get_busses(); + struct usb_bus *bus; + for (bus = busses; bus; bus = bus->next) + { + struct usb_device *dev; + + for (dev = bus->devices; dev; dev = dev->next) + { + /* Check if this device is a micronucleus */ + if (dev->descriptor.idVendor == MICRONUCLEUS_VENDOR_ID && dev->descriptor.idProduct == MICRONUCLEUS_PRODUCT_ID) + { + nucleus = malloc(sizeof(micronucleus)); + nucleus->version.major = (dev->descriptor.bcdUSB >> 8) & 0xFF; + nucleus->version.minor = dev->descriptor.bcdUSB & 0xFF; + nucleus->device = usb_open(dev); + + // get nucleus info + unsigned char buffer[4]; + int res = usb_control_msg(nucleus->device, 0xC0, 0, 0, 0, buffer, 4, MICRONUCLEUS_USB_TIMEOUT); + assert(res == 4); + + nucleus->flash_size = (buffer[0]<<8) + buffer[1]; + nucleus->page_size = buffer[2]; + nucleus->pages = (nucleus->flash_size / nucleus->page_size); + if (nucleus->pages * nucleus->page_size < nucleus->flash_size) nucleus->pages += 1; + nucleus->write_sleep = buffer[3]; + nucleus->erase_sleep = nucleus->write_sleep * nucleus->pages; + } + } + } - return tempHandle; + return nucleus; } -int micronucleus_getDeviceInfo(micronucleus* deviceHandle, unsigned int* availableMemory, unsigned char* deviceSize, unsigned char* sleepAmount) +int micronucleus_eraseFlash(micronucleus* deviceHandle) { int res; - res = usb_control_msg(deviceHandle, 0xC0, 0, 0, 0, rxBuffer, 4, USB_TIMEOUT); - - if(res!=4) - return -1; + res = usb_control_msg(deviceHandle->device, 0xC0, 2, 0, 0, NULL, 0, MICRONUCLEUS_USB_TIMEOUT); - *availableMemory = (rxBuffer[0]<<8) + rxBuffer[1]; - *deviceSize = rxBuffer[2]; - *sleepAmount = rxBuffer[3]; + // give microcontroller enough time to erase all writable pages and come back online + delay(deviceHandle->erase_sleep); - return 0; -} - -int micronucleus_eraseFlash(micronucleus* deviceHandle, unsigned int sleepAmount) -{ - int res; - res = usb_control_msg(deviceHandle, 0xC0, 2, 0, 0, rxBuffer, 0, USB_TIMEOUT); - delay(sleepAmount); if(res!=0) return -1; else return 0; } -int micronucleus_writeFlash(micronucleus* deviceHandle, unsigned int startAddress, unsigned int endAddress, unsigned char* buffer, unsigned char sleepAmount) +int micronucleus_writeFlash(micronucleus* deviceHandle, unsigned int program_size, unsigned char* program) { - unsigned char tempBuffer[64]; - unsigned int i; - unsigned int k; - unsigned int res; + unsigned char page_length = deviceHandle->page_size; + unsigned char page_buffer[page_length]; + unsigned int address; // overall flash memory address + unsigned int page_address; // address within this page when copying buffer + unsigned int res; - for(i=startAddress;i<(endAddress);i+=64) - { - for(k=0;k<64;k++) - tempBuffer[k]=buffer[i+k]; + for (address = 0; address < deviceHandle->flash_size; address += deviceHandle->page_size) { + // work around a bug in older bootloader versions + if (deviceHandle->version.major == 1 && deviceHandle->version.minor <= 2 + && address / deviceHandle->page_size == deviceHandle->pages - 1) { + page_length = deviceHandle->flash_size % deviceHandle->page_size; + } - res = usb_control_msg(deviceHandle, + // copy in bytes from user program + for (page_address = 0; page_address < page_length; page_address += 1) { + if (address + page_address > program_size) { + page_buffer[page_address] = 0xFF; // pad out remainder with unprogrammed bytes + } else { + page_buffer[page_address] = program[address + page_address]; // load from user program + } + } + + // ask microcontroller to write this page's data + res = usb_control_msg(deviceHandle->device, USB_ENDPOINT_OUT| USB_TYPE_VENDOR | USB_RECIP_DEVICE, 1, - 64,i, - tempBuffer, 64, - USB_TIMEOUT); - delay(sleepAmount); - if(res!=64) return -1; + page_length, address, + page_buffer, page_length, + MICRONUCLEUS_USB_TIMEOUT); + + // give microcontroller enough time to write this page and come back online + delay(deviceHandle->write_sleep); + + if (res != 64) return -1; } return 0; @@ -91,7 +129,8 @@ int micronucleus_writeFlash(micronucleus* deviceHandle, unsigned int startAddres int micronucleus_startApp(micronucleus* deviceHandle) { int res; - res = usb_control_msg(deviceHandle, 0xC0, 4, 0, 0, rxBuffer, 0, USB_TIMEOUT); + res = usb_control_msg(deviceHandle->device, 0xC0, 4, 0, 0, NULL, 0, MICRONUCLEUS_USB_TIMEOUT); + if(res!=0) return -1; else diff --git a/commandline/library/micronucleus_lib.h b/commandline/library/micronucleus_lib.h index b724a60..dcbac83 100644 --- a/commandline/library/micronucleus_lib.h +++ b/commandline/library/micronucleus_lib.h @@ -32,25 +32,40 @@ #else #include // this is libusb, see http://libusb.sourceforge.net/ #endif -#include "opendevice.h" // common code moved to separate module +//#include "opendevice.h" // common code moved to separate module +#include /*******************************************************************************/ /******************************************************************************** * USB details ********************************************************************************/ -#define VENDOR_ID 0x16D0 -#define PRODUCT_ID 0x0753 -#define USB_TIMEOUT 0xFFFF -#define RX_BUFFER_SIZE 64 -#define TX_BUFFER_SIZE 64 +#define MICRONUCLEUS_VENDOR_ID 0x16D0 +#define MICRONUCLEUS_PRODUCT_ID 0x0753 +#define MICRONUCLEUS_USB_TIMEOUT 0xFFFF /*******************************************************************************/ /******************************************************************************** * Declearations ********************************************************************************/ -typedef usb_dev_handle micronucleus; -unsigned char rxBuffer[RX_BUFFER_SIZE]; /* This has to be unsigned for the data's sake */ -unsigned char tBuffer[TX_BUFFER_SIZE]; /* This has to be unsigned for the data's sake */ +//typedef usb_dev_handle micronucleus; +// representing version number of micronucleus device +typedef struct _micronucleus_version { + unsigned char major; + unsigned char minor; +} micronucleus_version; + +// handle representing one micronucleus device +typedef struct _micronucleus { + usb_dev_handle *device; + // general information about device + micronucleus_version version; + unsigned int flash_size; // programmable size (in bytes) of progmem + unsigned int page_size; // size (in bytes) of page + unsigned int pages; // total number of pages to program + unsigned int write_sleep; // milliseconds + unsigned int erase_sleep; // milliseconds +} micronucleus; + /*******************************************************************************/ /******************************************************************************** @@ -60,22 +75,16 @@ unsigned char tBuffer[TX_BUFFER_SIZE]; /* This has to be unsigned for the data's micronucleus* micronucleus_connect(); /*******************************************************************************/ -/******************************************************************************** -* Get the device info -********************************************************************************/ -int micronucleus_getDeviceInfo(micronucleus* deviceHandle, unsigned int* availableMemory, unsigned char* deviceSize, unsigned char* sleepAmount); -/*******************************************************************************/ - /******************************************************************************** * Erase the flash memory ********************************************************************************/ -int micronucleus_eraseFlash(micronucleus* deviceHandle,unsigned int sleepAmount); +int micronucleus_eraseFlash(micronucleus* deviceHandle); /*******************************************************************************/ /******************************************************************************** * Write the flash memory ********************************************************************************/ -int micronucleus_writeFlash(micronucleus* deviceHandle, unsigned int startAddress, unsigned int endAddress, unsigned char* buffer, unsigned char sleepAmount); +int micronucleus_writeFlash(micronucleus* deviceHandle, unsigned int program_length, unsigned char* program); /*******************************************************************************/ /******************************************************************************** diff --git a/commandline/library/opendevice.c b/commandline/library/opendevice.c deleted file mode 100644 index 137f50c..0000000 --- a/commandline/library/opendevice.c +++ /dev/null @@ -1,203 +0,0 @@ -/* Name: opendevice.c - * Project: V-USB host-side library - * Author: Christian Starkjohann - * Creation Date: 2008-04-10 - * Tabsize: 4 - * Copyright: (c) 2008 by OBJECTIVE DEVELOPMENT Software GmbH - * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt) - * This Revision: $Id: opendevice.c 740 2009-04-13 18:23:31Z cs $ - */ - -/* -General Description: -The functions in this module can be used to find and open a device based on -libusb or libusb-win32. -*/ - -#include -#include "opendevice.h" - -/* ------------------------------------------------------------------------- */ - -#define MATCH_SUCCESS 1 -#define MATCH_FAILED 0 -#define MATCH_ABORT -1 - -/* private interface: match text and p, return MATCH_SUCCESS, MATCH_FAILED, or MATCH_ABORT. */ -static int _shellStyleMatch(char *text, char *p) -{ -int last, matched, reverse; - - for(; *p; text++, p++){ - if(*text == 0 && *p != '*') - return MATCH_ABORT; - switch(*p){ - case '\\': - /* Literal match with following character. */ - p++; - /* FALLTHROUGH */ - default: - if(*text != *p) - return MATCH_FAILED; - continue; - case '?': - /* Match anything. */ - continue; - case '*': - while(*++p == '*') - /* Consecutive stars act just like one. */ - continue; - if(*p == 0) - /* Trailing star matches everything. */ - return MATCH_SUCCESS; - while(*text) - if((matched = _shellStyleMatch(text++, p)) != MATCH_FAILED) - return matched; - return MATCH_ABORT; - case '[': - reverse = p[1] == '^'; - if(reverse) /* Inverted character class. */ - p++; - matched = MATCH_FAILED; - if(p[1] == ']' || p[1] == '-') - if(*++p == *text) - matched = MATCH_SUCCESS; - for(last = *p; *++p && *p != ']'; last = *p) - if (*p == '-' && p[1] != ']' ? *text <= *++p && *text >= last : *text == *p) - matched = MATCH_SUCCESS; - if(matched == reverse) - return MATCH_FAILED; - continue; - } - } - return *text == 0; -} - -/* public interface for shell style matching: returns 0 if fails, 1 if matches */ -static int shellStyleMatch(char *text, char *pattern) -{ - if(pattern == NULL) /* NULL pattern is synonymous to "*" */ - return 1; - return _shellStyleMatch(text, pattern) == MATCH_SUCCESS; -} - -/* ------------------------------------------------------------------------- */ - -int usbGetStringAscii(usb_dev_handle *dev, int index, char *buf, int buflen) -{ -char buffer[256]; -int rval, i; - - if((rval = usb_get_string_simple(dev, index, buf, buflen)) >= 0) /* use libusb version if it works */ - return rval; - if((rval = usb_control_msg(dev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR, (USB_DT_STRING << 8) + index, 0x0409, buffer, sizeof(buffer), 5000)) < 0) - return rval; - if(buffer[1] != USB_DT_STRING){ - *buf = 0; - return 0; - } - if((unsigned char)buffer[0] < rval) - rval = (unsigned char)buffer[0]; - rval /= 2; - /* lossy conversion to ISO Latin1: */ - for(i=1;i buflen) /* destination buffer overflow */ - break; - buf[i-1] = buffer[2 * i]; - if(buffer[2 * i + 1] != 0) /* outside of ISO Latin1 range */ - buf[i-1] = '?'; - } - buf[i-1] = 0; - return i-1; -} - -/* ------------------------------------------------------------------------- */ - -int usbOpenDevice(usb_dev_handle **device, int vendorID, char *vendorNamePattern, int productID, char *productNamePattern, char *serialNamePattern, FILE *printMatchingDevicesFp, FILE *warningsFp) -{ -struct usb_bus *bus; -struct usb_device *dev; -usb_dev_handle *handle = NULL; -int errorCode = USBOPEN_ERR_NOTFOUND; - - usb_find_busses(); - usb_find_devices(); - for(bus = usb_get_busses(); bus; bus = bus->next){ - for(dev = bus->devices; dev; dev = dev->next){ /* iterate over all devices on all busses */ - if((vendorID == 0 || dev->descriptor.idVendor == vendorID) - && (productID == 0 || dev->descriptor.idProduct == productID)){ - char vendor[256], product[256], serial[256]; - int len; - handle = usb_open(dev); /* we need to open the device in order to query strings */ - if(!handle){ - errorCode = USBOPEN_ERR_ACCESS; - if(warningsFp != NULL) - fprintf(warningsFp, "Warning: cannot open VID=0x%04x PID=0x%04x: %s\n", dev->descriptor.idVendor, dev->descriptor.idProduct, usb_strerror()); - continue; - } - /* now check whether the names match: */ - len = vendor[0] = 0; - if(dev->descriptor.iManufacturer > 0){ - len = usbGetStringAscii(handle, dev->descriptor.iManufacturer, vendor, sizeof(vendor)); - } - if(len < 0){ - errorCode = USBOPEN_ERR_ACCESS; - if(warningsFp != NULL) - fprintf(warningsFp, "Warning: cannot query manufacturer for VID=0x%04x PID=0x%04x: %s\n", dev->descriptor.idVendor, dev->descriptor.idProduct, usb_strerror()); - }else{ - errorCode = USBOPEN_ERR_NOTFOUND; - /* printf("seen device from vendor ->%s<-\n", vendor); */ - if(shellStyleMatch(vendor, vendorNamePattern)){ - len = product[0] = 0; - if(dev->descriptor.iProduct > 0){ - len = usbGetStringAscii(handle, dev->descriptor.iProduct, product, sizeof(product)); - } - if(len < 0){ - errorCode = USBOPEN_ERR_ACCESS; - if(warningsFp != NULL) - fprintf(warningsFp, "Warning: cannot query product for VID=0x%04x PID=0x%04x: %s\n", dev->descriptor.idVendor, dev->descriptor.idProduct, usb_strerror()); - }else{ - errorCode = USBOPEN_ERR_NOTFOUND; - /* printf("seen product ->%s<-\n", product); */ - if(shellStyleMatch(product, productNamePattern)){ - len = serial[0] = 0; - if(dev->descriptor.iSerialNumber > 0){ - len = usbGetStringAscii(handle, dev->descriptor.iSerialNumber, serial, sizeof(serial)); - } - if(len < 0){ - errorCode = USBOPEN_ERR_ACCESS; - if(warningsFp != NULL) - fprintf(warningsFp, "Warning: cannot query serial for VID=0x%04x PID=0x%04x: %s\n", dev->descriptor.idVendor, dev->descriptor.idProduct, usb_strerror()); - } - if(shellStyleMatch(serial, serialNamePattern)){ - if(printMatchingDevicesFp != NULL){ - if(serial[0] == 0){ - fprintf(printMatchingDevicesFp, "VID=0x%04x PID=0x%04x vendor=\"%s\" product=\"%s\"\n", dev->descriptor.idVendor, dev->descriptor.idProduct, vendor, product); - }else{ - fprintf(printMatchingDevicesFp, "VID=0x%04x PID=0x%04x vendor=\"%s\" product=\"%s\" serial=\"%s\"\n", dev->descriptor.idVendor, dev->descriptor.idProduct, vendor, product, serial); - } - }else{ - break; - } - } - } - } - } - } - usb_close(handle); - handle = NULL; - } - } - if(handle) /* we have found a deice */ - break; - } - if(handle != NULL){ - errorCode = 0; - *device = handle; - } - if(printMatchingDevicesFp != NULL) /* never return an error for listing only */ - errorCode = 0; - return errorCode; -} - -/* ------------------------------------------------------------------------- */ diff --git a/commandline/library/opendevice.h b/commandline/library/opendevice.h deleted file mode 100644 index f687ccd..0000000 --- a/commandline/library/opendevice.h +++ /dev/null @@ -1,82 +0,0 @@ -/* Name: opendevice.h - * Project: V-USB host-side library - * Author: Christian Starkjohann - * Creation Date: 2008-04-10 - * Tabsize: 4 - * Copyright: (c) 2008 by OBJECTIVE DEVELOPMENT Software GmbH - * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt) - * This Revision: $Id: opendevice.h 755 2009-08-03 17:01:21Z cs $ - */ - -/* -General Description: -This module offers additional functionality for host side drivers based on -libusb or libusb-win32. It includes a function to find and open a device -based on numeric IDs and textual description. It also includes a function to -obtain textual descriptions from a device. - -To use this functionality, simply copy opendevice.c and opendevice.h into your -project and add them to your Makefile. You may modify and redistribute these -files according to the GNU General Public License (GPL) version 2 or 3. -*/ - -#ifndef __OPENDEVICE_H_INCLUDED__ -#define __OPENDEVICE_H_INCLUDED__ - -#if defined WIN - #include // this is libusb, see http://libusb.sourceforge.net/ -#else - #include // this is libusb, see http://libusb.sourceforge.net/ -#endif - -#include - -int usbGetStringAscii(usb_dev_handle *dev, int index, char *buf, int buflen); -/* This function gets a string descriptor from the device. 'index' is the - * string descriptor index. The string is returned in ISO Latin 1 encoding in - * 'buf' and it is terminated with a 0-character. The buffer size must be - * passed in 'buflen' to prevent buffer overflows. A libusb device handle - * must be given in 'dev'. - * Returns: The length of the string (excluding the terminating 0) or - * a negative number in case of an error. If there was an error, use - * usb_strerror() to obtain the error message. - */ - -int usbOpenDevice(usb_dev_handle **device, int vendorID, char *vendorNamePattern, int productID, char *productNamePattern, char *serialNamePattern, FILE *printMatchingDevicesFp, FILE *warningsFp); -/* This function iterates over all devices on all USB busses and searches for - * a device. Matching is done first by means of Vendor- and Product-ID (passed - * in 'vendorID' and 'productID'. An ID of 0 matches any numeric ID (wildcard). - * When a device matches by its IDs, matching by names is performed. Name - * matching can be done on textual vendor name ('vendorNamePattern'), product - * name ('productNamePattern') and serial number ('serialNamePattern'). A - * device matches only if all non-null pattern match. If you don't care about - * a string, pass NULL for the pattern. Patterns are Unix shell style pattern: - * '*' stands for 0 or more characters, '?' for one single character, a list - * of characters in square brackets for a single character from the list - * (dashes are allowed to specify a range) and if the lis of characters begins - * with a caret ('^'), it matches one character which is NOT in the list. - * Other parameters to the function: If 'warningsFp' is not NULL, warning - * messages are printed to this file descriptor with fprintf(). If - * 'printMatchingDevicesFp' is not NULL, no device is opened but matching - * devices are printed to the given file descriptor with fprintf(). - * If a device is opened, the resulting USB handle is stored in '*device'. A - * pointer to a "usb_dev_handle *" type variable must be passed here. - * Returns: 0 on success, an error code (see defines below) on failure. - */ - -/* usbOpenDevice() error codes: */ -#define USBOPEN_SUCCESS 0 /* no error */ -#define USBOPEN_ERR_ACCESS 1 /* not enough permissions to open device */ -#define USBOPEN_ERR_IO 2 /* I/O error */ -#define USBOPEN_ERR_NOTFOUND 3 /* device not found */ - - -/* Obdev's free USB IDs, see USB-IDs-for-free.txt for details */ - -#define USB_VID_OBDEV_SHARED 5824 /* obdev's shared vendor ID */ -#define USB_PID_OBDEV_SHARED_CUSTOM 1500 /* shared PID for custom class devices */ -#define USB_PID_OBDEV_SHARED_HID 1503 /* shared PID for HIDs except mice & keyboards */ -#define USB_PID_OBDEV_SHARED_CDCACM 1505 /* shared PID for CDC Modem devices */ -#define USB_PID_OBDEV_SHARED_MIDI 1508 /* shared PID for MIDI class devices */ - -#endif /* __OPENDEVICE_H_INCLUDED__ */ -- cgit v1.2.3