X-Git-Url: http://developer.intra2net.com/git/?a=blobdiff_plain;f=src%2Fftdi.c;h=043d24a3153d330256f567aaeed212922c205d0f;hb=c3034a16d2e7394f71357938b3f9844168716b0a;hp=985133bb17ba1cb2328a3dbb815f403d62fc41a4;hpb=7cc9950ec21b5cdba8b80ed18dbf686e5024aee1;p=libftdi diff --git a/src/ftdi.c b/src/ftdi.c index 985133b..043d24a 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 ***************************************************************************/ @@ -35,12 +35,14 @@ #include "ftdi.h" /* stuff needed for async write */ -#include -#include -#include -#include -#include -#include +#ifdef LIBFTDI_LINUX_ASYNC_MODE + #include + #include + #include + #include + #include + #include +#endif #define ftdi_error_return(code, str) do { \ ftdi->error_str = str; \ @@ -83,6 +85,7 @@ int ftdi_init(struct ftdi_context *ftdi) ftdi->error_str = NULL; +#ifdef LIBFTDI_LINUX_ASYNC_MODE 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"); @@ -90,12 +93,39 @@ int ftdi_init(struct ftdi_context *ftdi) /* 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; +#else + ftdi->async_usb_buffer_size=0; + ftdi->async_usb_buffer = NULL; +#endif + + ftdi->eeprom_size = FTDI_DEFAULT_EEPROM_SIZE; /* All fine. Now allocate the readbuffer */ return ftdi_read_data_set_chunksize(ftdi, 4096); } /** + Allocate and initialize a new ftdi_context + + \return a pointer to a new ftdi_context, or NULL on failure +*/ +struct ftdi_context *ftdi_new() +{ + struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context)); + + if (ftdi == NULL) { + return NULL; + } + + if (ftdi_init(ftdi) != 0) { + free(ftdi); + return NULL; + } + + return ftdi; +} + +/** Open selected channels on a chip, otherwise use first channel. \param ftdi pointer to ftdi_context @@ -142,6 +172,17 @@ void ftdi_deinit(struct ftdi_context *ftdi) } /** + Deinitialize and free an ftdi_context. + + \param ftdi pointer to ftdi_context +*/ +void ftdi_free(struct ftdi_context *ftdi) +{ + ftdi_deinit(ftdi); + free(ftdi); +} + +/** Use an already open libusb device. \param ftdi pointer to ftdi_context @@ -182,7 +223,7 @@ int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devli curdev = devlist; *curdev = NULL; - for (bus = usb_busses; bus; bus = bus->next) { + for (bus = usb_get_busses(); bus; bus = bus->next) { for (dev = bus->devices; dev; dev = dev->next) { if (dev->descriptor.idVendor == vendor && dev->descriptor.idProduct == product) @@ -222,6 +263,16 @@ void ftdi_list_free(struct ftdi_device_list **devlist) } /** + Frees a usb device list. + + \param devlist USB device list created by ftdi_usb_find_all() +*/ +void ftdi_list_free2(struct ftdi_device_list *devlist) +{ + ftdi_list_free(&devlist); +} + +/** Return device ID strings from the usb device. The parameters manufacturer, description and serial may be NULL @@ -394,7 +445,7 @@ int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product, if (usb_find_devices() < 0) ftdi_error_return(-2, "usb_find_devices() failed"); - for (bus = usb_busses; bus; bus = bus->next) { + for (bus = usb_get_busses(); bus; bus = bus->next) { for (dev = bus->devices; dev; dev = dev->next) { if (dev->descriptor.idVendor == vendor && dev->descriptor.idProduct == product) { @@ -457,15 +508,14 @@ int ftdi_usb_reset(struct ftdi_context *ftdi) } /** - Clears the buffers on the chip. + Clears the read buffer on the chip and the internal read buffer. \param ftdi pointer to ftdi_context \retval 0: all fine - \retval -1: write buffer purge failed - \retval -2: read buffer purge failed + \retval -1: read buffer purge failed */ -int ftdi_usb_purge_buffers(struct ftdi_context *ftdi) +int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi) { if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 1, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) ftdi_error_return(-1, "FTDI purge of RX buffer failed"); @@ -474,8 +524,45 @@ int ftdi_usb_purge_buffers(struct ftdi_context *ftdi) ftdi->readbuffer_offset = 0; ftdi->readbuffer_remaining = 0; + return 0; +} + +/** + Clears the write buffer on the chip. + + \param ftdi pointer to ftdi_context + + \retval 0: all fine + \retval -1: write buffer purge failed +*/ +int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi) +{ if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 2, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) - ftdi_error_return(-2, "FTDI purge of TX buffer failed"); + ftdi_error_return(-1, "FTDI purge of TX buffer failed"); + + return 0; +} + +/** + Clears the buffers on the chip and the internal read buffer. + + \param ftdi pointer to ftdi_context + + \retval 0: all fine + \retval -1: read buffer purge failed + \retval -2: write buffer purge failed +*/ +int ftdi_usb_purge_buffers(struct ftdi_context *ftdi) +{ + int result; + + result = ftdi_usb_purge_rx_buffer(ftdi); + if (result < 0) + return -1; + + result = ftdi_usb_purge_tx_buffer(ftdi); + if (result < 0) + return -2; return 0; } @@ -493,8 +580,10 @@ int ftdi_usb_close(struct ftdi_context *ftdi) { int rtn = 0; +#ifdef LIBFTDI_LINUX_ASYNC_MODE /* try to release some kernel resources */ ftdi_async_complete(ftdi,1); +#endif if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0) rtn = -1; @@ -729,6 +818,7 @@ int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size) return total_written; } +#ifdef LIBFTDI_LINUX_ASYNC_MODE /* 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 { @@ -736,7 +826,11 @@ struct usb_dev_handle { // some other stuff coming here we don't need }; -static int usb_get_async_urbs_pending(struct ftdi_context *ftdi) +/** + Check for pending async urbs + \internal +*/ +static int _usb_get_async_urbs_pending(struct ftdi_context *ftdi) { struct usbdevfs_urb *urb; int pending=0; @@ -751,7 +845,17 @@ static int usb_get_async_urbs_pending(struct ftdi_context *ftdi) return pending; } -static void usb_async_cleanup(struct ftdi_context *ftdi, int wait_for_more, int timeout_msec) +/** + 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; @@ -767,7 +871,7 @@ static void usb_async_cleanup(struct ftdi_context *ftdi, int wait_for_more, int tv.tv_usec = (timeout_msec % 1000) * 1000; do { - while (usb_get_async_urbs_pending(ftdi) + while (_usb_get_async_urbs_pending(ftdi) && (ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_REAPURBNDELAY, &urb)) == -1 && errno == EAGAIN) { @@ -796,21 +900,23 @@ static void usb_async_cleanup(struct ftdi_context *ftdi, int wait_for_more, int } /** - Wait until at least one async write is complete + 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); + _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(struct ftdi_context *ftdi, int ep, char *bytes, int size) +static int _usb_bulk_write_async(struct ftdi_context *ftdi, int ep, char *bytes, int size) { struct usbdevfs_urb *urb; int bytesdone = 0, requested; @@ -824,7 +930,7 @@ static int usb_bulk_write_async(struct ftdi_context *ftdi, int ep, char *bytes, { if (i==ftdi->async_usb_buffer_size) { /* wait until some buffers are free */ - usb_async_cleanup(ftdi,0,ftdi->usb_write_timeout); + _usb_async_cleanup(ftdi,0,ftdi->usb_write_timeout); } for (i=0; i < ftdi->async_usb_buffer_size; i++) { @@ -875,6 +981,7 @@ static int usb_bulk_write_async(struct ftdi_context *ftdi, int ep, char *bytes, caller of completion or error - but this is not done yet, volunteers welcome. Works around libusb and directly accesses functions only available on Linux. + Only available if compiled with --with-async-mode. \param ftdi pointer to ftdi_context \param buf Buffer with the data @@ -895,7 +1002,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, 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"); @@ -905,7 +1012,7 @@ int ftdi_write_data_async(struct ftdi_context *ftdi, unsigned char *buf, int siz return total_written; } - +#endif // LIBFTDI_LINUX_ASYNC_MODE /** Configure write buffer chunk size. @@ -1220,6 +1327,121 @@ int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency) } /** + Poll modem status information + + This function allows the retrieve the two status bytes of the device. + The device sends these bytes also as a header for each read access + where they are discarded by ftdi_read_data(). The chip generates + the two stripped status bytes in the absence of data every 40 ms. + + Layout of the first byte: + - B0..B3 - must be 0 + - B4 Clear to send (CTS) + 0 = inactive + 1 = active + - B5 Data set ready (DTS) + 0 = inactive + 1 = active + - B6 Ring indicator (RI) + 0 = inactive + 1 = active + - B7 Receive line signal detect (RLSD) + 0 = inactive + 1 = active + + Layout of the second byte: + - B0 Data ready (DR) + - B1 Overrun error (OE) + - B2 Parity error (PE) + - B3 Framing error (FE) + - B4 Break interrupt (BI) + - B5 Transmitter holding register (THRE) + - B6 Transmitter empty (TEMT) + - B7 Error in RCVR FIFO + + \param ftdi pointer to ftdi_context + \param status Pointer to store status information in. Must be two bytes. + + \retval 0: all fine + \retval -1: unable to retrieve status information +*/ +int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status) +{ + char usb_val[2]; + + if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x05, 0, ftdi->index, usb_val, 2, ftdi->usb_read_timeout) != 2) + ftdi_error_return(-1, "getting modem status failed"); + + *status = (usb_val[1] << 8) | usb_val[0]; + + return 0; +} + +/** + Set the special event character + + \param ftdi pointer to ftdi_context + \param eventch Event character + \param enable 0 to disable the event character, non-zero otherwise + + \retval 0: all fine + \retval -1: unable to set event character +*/ +int ftdi_set_event_char(struct ftdi_context *ftdi, + unsigned char eventch, unsigned char enable) +{ + unsigned short usb_val; + + usb_val = eventch; + if (enable) + usb_val |= 1 << 8; + + if (usb_control_msg(ftdi->usb_dev, 0x40, 0x06, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + ftdi_error_return(-1, "setting event character failed"); + + return 0; +} + +/** + Set error character + + \param ftdi pointer to ftdi_context + \param errorch Error character + \param enable 0 to disable the error character, non-zero otherwise + + \retval 0: all fine + \retval -1: unable to set error character +*/ +int ftdi_set_error_char(struct ftdi_context *ftdi, + unsigned char errorch, unsigned char enable) +{ + unsigned short usb_val; + + usb_val = errorch; + if (enable) + usb_val |= 1 << 8; + + if (usb_control_msg(ftdi->usb_dev, 0x40, 0x07, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) + ftdi_error_return(-1, "setting error character failed"); + + return 0; +} + +/** + 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 @@ -1245,6 +1467,8 @@ void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom) eeprom->manufacturer = NULL; eeprom->product = NULL; eeprom->serial = NULL; + + eeprom->size = FTDI_DEFAULT_EEPROM_SIZE; } /** @@ -1271,8 +1495,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; @@ -1282,7 +1512,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 @@ -1302,19 +1532,19 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) output[0x07] = 0x02; // Addr 08: Config descriptor - // Bit 1: remote wakeup if 1 - // Bit 0: self powered if 1 - // - j = 0; + // Bit 7: always 1 + // Bit 6: 1 if this device is self powered, 0 if bus powered + // Bit 5: 1 if this device uses remote wakeup + // Bit 4: 1 if this device is battery powered + j = 0x80; if (eeprom->self_powered == 1) - j = j | 1; + j |= 0x40; if (eeprom->remote_wakeup == 1) - j = j | 2; + j |= 0x20; output[0x08] = j; // Addr 09: Max power consumption: max power = value * 2 mA output[0x09] = eeprom->max_power; - ; // Addr 0A: Chip configuration // Bit 7: 0 - reserved @@ -1350,9 +1580,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; @@ -1365,19 +1593,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=0x14; + if(eeprom->size>=256) i = 0x80; - i = 0x16, j = 0; - // Output manufacturer + // 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++) { @@ -1386,7 +1616,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++) { @@ -1397,7 +1627,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; @@ -1405,8 +1635,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; } @@ -1424,7 +1654,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"); } @@ -1480,6 +1710,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 @@ -1493,7 +1750,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)