X-Git-Url: http://developer.intra2net.com/git/?p=libftdi;a=blobdiff_plain;f=src%2Fftdi.c;h=b284209c943fe279d63f3b92ddd58e28e22d7696;hp=4b53ac310828cc4dc6e4ba4ebfe0171f4e029247;hb=84f85aaa33a7d2ee7080acfbe56dabc0ca317411;hpb=4c9e381219d807ff74556eb35cae1c90986242bc diff --git a/src/ftdi.c b/src/ftdi.c index 4b53ac3..b284209 100644 --- a/src/ftdi.c +++ b/src/ftdi.c @@ -2,7 +2,7 @@ ftdi.c - description ------------------- begin : Fri Apr 4 2003 - copyright : (C) 2003 by Intra2net AG + copyright : (C) 2003-2008 by Intra2net AG email : opensource@intra2net.com ***************************************************************************/ @@ -31,10 +31,17 @@ #include #include #include -#include #include "ftdi.h" +/* stuff needed for async write */ +#include +#include +#include +#include +#include +#include + #define ftdi_error_return(code, str) do { \ ftdi->error_str = str; \ return code; \ @@ -53,6 +60,8 @@ */ int ftdi_init(struct ftdi_context *ftdi) { + int i; + ftdi->usb_dev = NULL; ftdi->usb_read_timeout = 5000; ftdi->usb_write_timeout = 5000; @@ -74,6 +83,16 @@ int ftdi_init(struct ftdi_context *ftdi) ftdi->error_str = NULL; + ftdi->async_usb_buffer_size=10; + if ((ftdi->async_usb_buffer=malloc(sizeof(struct usbdevfs_urb)*ftdi->async_usb_buffer_size)) == NULL) + ftdi_error_return(-1, "out of memory for async usb buffer"); + + /* initialize async usb buffer with unused-marker */ + for (i=0; i < ftdi->async_usb_buffer_size; i++) + ((struct usbdevfs_urb*)ftdi->async_usb_buffer)[i].usercontext = FTDI_URB_USERCONTEXT_COOKIE; + + ftdi->eeprom_size = FTDI_DEFAULT_EEPROM_SIZE; + /* All fine. Now allocate the readbuffer */ return ftdi_read_data_set_chunksize(ftdi, 4096); } @@ -113,6 +132,11 @@ int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface) */ void ftdi_deinit(struct ftdi_context *ftdi) { + if (ftdi->async_usb_buffer != NULL) { + free(ftdi->async_usb_buffer); + ftdi->async_usb_buffer = NULL; + } + if (ftdi->readbuffer != NULL) { free(ftdi->readbuffer); ftdi->readbuffer = NULL; @@ -471,6 +495,9 @@ int ftdi_usb_close(struct ftdi_context *ftdi) { int rtn = 0; + /* try to release some kernel resources */ + ftdi_async_complete(ftdi,1); + if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0) rtn = -1; @@ -704,32 +731,6 @@ int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size) return total_written; } -/* these structs are stolen from libusb linux implementation - they are needed to directly access usbfs and offer async - writing */ - -struct usb_iso_packet_desc { - unsigned int length; - unsigned int actual_length; - unsigned int status; -}; - -struct usb_urb { - unsigned char type; - unsigned char endpoint; - int status; - unsigned int flags; - void *buffer; - int buffer_length; - int actual_length; - int start_frame; - int number_of_packets; - int error_count; - unsigned int signr; /* signal to be sent on error, -1 if none should be sent */ - void *usercontext; - struct usb_iso_packet_desc iso_frame_desc[0]; -}; - /* this is strongly dependent on libusb using the same struct layout. If libusb changes in some later version this may break horribly (this is for libusb 0.1.12) */ struct usb_dev_handle { @@ -737,40 +738,144 @@ struct usb_dev_handle { // some other stuff coming here we don't need }; -// some defines for direct usb access, taken from libusb -#define MAX_READ_WRITE (16 * 1024) -#define IOCTL_USB_SUBMITURB _IOR('U', 10, struct usb_urb) -#define USB_URB_TYPE_BULK 3 +/** + Check for pending async urbs + \internal +*/ +static int _usb_get_async_urbs_pending(struct ftdi_context *ftdi) +{ + struct usbdevfs_urb *urb; + int pending=0; + int i; + + for (i=0; i < ftdi->async_usb_buffer_size; i++) { + urb=&((struct usbdevfs_urb *)(ftdi->async_usb_buffer))[i]; + if (urb->usercontext != FTDI_URB_USERCONTEXT_COOKIE) + pending++; + } + + return pending; +} + +/** + Wait until one or more async URBs are completed by the kernel and mark their + positions in the async-buffer as unused + + \param ftdi pointer to ftdi_context + \param wait_for_more if != 0 wait for more than one write to complete + \param timeout_msec max milliseconds to wait + + \internal +*/ +static void _usb_async_cleanup(struct ftdi_context *ftdi, int wait_for_more, int timeout_msec) +{ + struct timeval tv; + struct usbdevfs_urb *urb=NULL; + int ret; + fd_set writefds; + int keep_going=0; + + FD_ZERO(&writefds); + FD_SET(ftdi->usb_dev->fd, &writefds); + + /* init timeout only once, select writes time left after call */ + tv.tv_sec = timeout_msec / 1000; + tv.tv_usec = (timeout_msec % 1000) * 1000; + + do { + while (_usb_get_async_urbs_pending(ftdi) + && (ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_REAPURBNDELAY, &urb)) == -1 + && errno == EAGAIN) + { + if (keep_going && !wait_for_more) { + /* don't wait if repeating only for keep_going */ + keep_going=0; + break; + } + + /* wait for timeout msec or something written ready */ + select(ftdi->usb_dev->fd+1, NULL, &writefds, NULL, &tv); + } + + if (ret == 0 && urb != NULL) { + /* got a free urb, mark it */ + urb->usercontext = FTDI_URB_USERCONTEXT_COOKIE; + + /* try to get more urbs that are ready now, but don't wait anymore */ + urb=NULL; + keep_going=1; + } else { + /* no more urbs waiting */ + keep_going=0; + } + } while (keep_going); +} + +/** + Wait until one or more async URBs are completed by the kernel and mark their + positions in the async-buffer as unused. + + \param ftdi pointer to ftdi_context + \param wait_for_more if != 0 wait for more than one write to complete (until write timeout) +*/ +void ftdi_async_complete(struct ftdi_context *ftdi, int wait_for_more) +{ + _usb_async_cleanup(ftdi,wait_for_more,ftdi->usb_write_timeout); +} /** Stupid libusb does not offer async writes nor does it allow access to its fd - so we need some hacks here. + \internal */ -static int usb_bulk_write_async(usb_dev_handle *dev, int ep, char *bytes, int size) +static int _usb_bulk_write_async(struct ftdi_context *ftdi, int ep, char *bytes, int size) { - struct usb_urb urb; + struct usbdevfs_urb *urb; int bytesdone = 0, requested; - struct usb_urb *context; - int ret, waiting; + int ret, i; + int cleanup_count; do { - fd_set writefds; + /* find a free urb buffer we can use */ + urb=NULL; + for (cleanup_count=0; urb==NULL && cleanup_count <= 1; cleanup_count++) + { + if (i==ftdi->async_usb_buffer_size) { + /* wait until some buffers are free */ + _usb_async_cleanup(ftdi,0,ftdi->usb_write_timeout); + } + + for (i=0; i < ftdi->async_usb_buffer_size; i++) { + urb=&((struct usbdevfs_urb *)(ftdi->async_usb_buffer))[i]; + if (urb->usercontext == FTDI_URB_USERCONTEXT_COOKIE) + break; /* found a free urb position */ + urb=NULL; + } + } + + /* no free urb position found */ + if (urb==NULL) + return -1; requested = size - bytesdone; - if (requested > MAX_READ_WRITE) - requested = MAX_READ_WRITE; - - urb.type = USB_URB_TYPE_BULK; - urb.endpoint = ep; - urb.flags = 0; - urb.buffer = bytes + bytesdone; - urb.buffer_length = requested; - urb.signr = 0; - urb.actual_length = 0; - urb.number_of_packets = 0; /* don't do isochronous yet */ - urb.usercontext = (void*)1000; /* use something else than libusb... */ - - ret = ioctl(dev->fd, IOCTL_USB_SUBMITURB, &urb); + if (requested > 4096) + requested = 4096; + + memset(urb,0,sizeof(urb)); + + urb->type = USBDEVFS_URB_TYPE_BULK; + urb->endpoint = ep; + urb->flags = 0; + urb->buffer = bytes + bytesdone; + urb->buffer_length = requested; + urb->signr = 0; + urb->actual_length = 0; + urb->number_of_packets = 0; + urb->usercontext = 0; + + do { + ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_SUBMITURB, urb); + } while (ret < 0 && errno == EINTR); if (ret < 0) return ret; /* the caller can read errno to get more info */ @@ -808,7 +913,7 @@ int ftdi_write_data_async(struct ftdi_context *ftdi, unsigned char *buf, int siz if (offset+write_size > size) write_size = size-offset; - ret = usb_bulk_write_async(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size); + ret = _usb_bulk_write_async(ftdi, ftdi->in_ep, buf+offset, write_size); if (ret < 0) ftdi_error_return(ret, "usb bulk write async failed"); @@ -1133,6 +1238,20 @@ int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency) } /** + Set the eeprom size + + \param ftdi pointer to ftdi_context + \param eeprom Pointer to ftdi_eeprom + \param size + +*/ +void ftdi_eeprom_setsize(struct ftdi_context *ftdi, struct ftdi_eeprom *eeprom, int size) +{ + ftdi->eeprom_size=size; + eeprom->size=size; +} + +/** Init eeprom with default values. \param eeprom Pointer to ftdi_eeprom @@ -1158,6 +1277,8 @@ void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom) eeprom->manufacturer = NULL; eeprom->product = NULL; eeprom->serial = NULL; + + eeprom->size = FTDI_DEFAULT_EEPROM_SIZE; } /** @@ -1184,8 +1305,14 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) if (eeprom->serial != NULL) serial_size = strlen(eeprom->serial); - size_check = 128; // eeprom is 128 bytes + size_check = eeprom->size; size_check -= 28; // 28 are always in use (fixed) + + // Top half of a 256byte eeprom is used just for strings and checksum + // it seems that the FTDI chip will not read these strings from the lower half + // Each string starts with two bytes; offset and type (0x03 for string) + // the checksum needs two bytes, so without the string data that 8 bytes from the top half + if(eeprom->size>=256)size_check = 120; size_check -= manufacturer_size*2; size_check -= product_size*2; size_check -= serial_size*2; @@ -1195,7 +1322,7 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) return (-1); // empty eeprom - memset (output, 0, 128); + memset (output, 0, eeprom->size); // Addr 00: Stay 00 00 // Addr 02: Vendor ID @@ -1263,9 +1390,7 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) } - // Addr 0E: Offset of the manufacturer string + 0x80 - output[0x0E] = 0x14 + 0x80; - + // Addr 0E: Offset of the manufacturer string + 0x80, calculated later // Addr 0F: Length of manufacturer string output[0x0F] = manufacturer_size*2 + 2; @@ -1278,19 +1403,21 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) output[0x13] = serial_size*2 + 2; // Dynamic content - output[0x14] = manufacturer_size*2 + 2; - output[0x15] = 0x03; // type: string - - i = 0x16, j = 0; - - // Output manufacturer + i=0x14; + if(eeprom->size>=256) i = 0x80; + + + // Output manufacturer + output[0x0E] = i | 0x80; // calculate offset + output[i++] = manufacturer_size*2 + 2; + output[i++] = 0x03; // type: string for (j = 0; j < manufacturer_size; j++) { output[i] = eeprom->manufacturer[j], i++; output[i] = 0x00, i++; } // Output product name - output[0x10] = i + 0x80; // calculate offset + output[0x10] = i | 0x80; // calculate offset output[i] = product_size*2 + 2, i++; output[i] = 0x03, i++; for (j = 0; j < product_size; j++) { @@ -1299,7 +1426,7 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) } // Output serial - output[0x12] = i + 0x80; // calculate offset + output[0x12] = i | 0x80; // calculate offset output[i] = serial_size*2 + 2, i++; output[i] = 0x03, i++; for (j = 0; j < serial_size; j++) { @@ -1310,7 +1437,7 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) // calculate checksum checksum = 0xAAAA; - for (i = 0; i < 63; i++) { + for (i = 0; i < eeprom->size/2-1; i++) { value = output[i*2]; value += output[(i*2)+1] << 8; @@ -1318,8 +1445,8 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) checksum = (checksum << 1) | (checksum >> 15); } - output[0x7E] = checksum; - output[0x7F] = checksum >> 8; + output[eeprom->size-2] = checksum; + output[eeprom->size-1] = checksum >> 8; return size_check; } @@ -1337,7 +1464,7 @@ int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) { int i; - for (i = 0; i < 64; i++) { + for (i = 0; i < ftdi->eeprom_size/2; i++) { if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2) ftdi_error_return(-1, "reading eeprom failed"); } @@ -1393,6 +1520,33 @@ int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid) } /** + Guesses size of eeprom by reading eeprom and comparing halves - will not work with blank eeprom + Call this function then do a write then call again to see if size changes, if so write again. + + \param ftdi pointer to ftdi_context + \param eeprom Pointer to store eeprom into + \param maxsize the size of the buffer to read into + + \retval size of eeprom +*/ +int ftdi_read_eeprom_getsize(struct ftdi_context *ftdi, unsigned char *eeprom, int maxsize) +{ + int i=0,j,minsize=32; + int size=minsize; + + do{ + for (j = 0; i < maxsize/2 && jusb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2) + ftdi_error_return(-1, "reading eeprom failed"); + i++; + } + size*=2; + }while(size<=maxsize && memcmp(eeprom,&eeprom[size/2],size/2)!=0); + + return size/2; +} + +/** Write eeprom \param ftdi pointer to ftdi_context @@ -1406,7 +1560,7 @@ int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) unsigned short usb_val; int i; - for (i = 0; i < 64; i++) { + for (i = 0; i < ftdi->eeprom_size/2; i++) { usb_val = eeprom[i*2]; usb_val += eeprom[(i*2)+1] << 8; if (usb_control_msg(ftdi->usb_dev, 0x40, 0x91, usb_val, i, NULL, 0, ftdi->usb_write_timeout) != 0)