* version 2.1 as published by the Free Software Foundation; *
* *
***************************************************************************/
-#define _GNU_SOURCE
-#include "ftdi.h"
-#include <sys/ioctl.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-
-/* Internal USB devfs functions. Do not use outside libftdi */
-static struct usbdevfs_urb * ftdi_usbdev_alloc_urb(int iso_packets);
-static int ftdi_usbdev_submit_urb(int fd, struct usbdevfs_urb *urb);
-static int ftdi_usbdev_reap_urb_ndelay(int fd, struct usbdevfs_urb **urb_return);
+#include <usb.h>
+#include <string.h>
+#include "ftdi.h"
/* ftdi_init return codes:
0: all fine
ftdi->error_str = NULL;
- ftdi->urb = ftdi_usbdev_alloc_urb(0);
- if (!ftdi->urb) {
- ftdi->error_str = "out of memory for read URB";
- return -1;
- }
-
- // all fine. Now allocate the readbuffer
+ /* All fine. Now allocate the readbuffer */
return ftdi_read_data_set_chunksize(ftdi, 4096);
}
free(ftdi->readbuffer);
ftdi->readbuffer = NULL;
}
-
- if (ftdi->urb != NULL) {
- free (ftdi->urb);
- ftdi->urb = NULL;
- }
}
ftdi->usb_dev = usb;
}
+
/* ftdi_usb_open return codes:
0: all fine
-1: usb_find_busses() failed
-5: unable to claim device
-6: reset failed
-7: set baudrate failed
+ -8: get product description failed
+ -9: get serial number failed
+ -10: unable to close device
*/
-int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product) {
+int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
+{
+ return ftdi_usb_open_desc(ftdi, vendor, product, NULL, NULL);
+}
+
+int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
+ const char* description, const char* serial)
+{
struct usb_bus *bus;
struct usb_device *dev;
for (bus = usb_busses; bus; bus = bus->next) {
for (dev = bus->devices; dev; dev = dev->next) {
- if (dev->descriptor.idVendor == vendor && dev->descriptor.idProduct == product) {
- ftdi->usb_dev = usb_open(dev);
- if (ftdi->usb_dev) {
- if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0) {
- ftdi->error_str = "unable to claim usb device. Make sure ftdi_sio is unloaded!";
- return -5;
+ if (dev->descriptor.idVendor == vendor
+ && dev->descriptor.idProduct == product) {
+ if (!(ftdi->usb_dev = usb_open(dev))) {
+ ftdi->error_str = "usb_open() failed";
+ return -4;
+ }
+
+ char string[256];
+ if (description != NULL) {
+ if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, string, sizeof(string)) <= 0) {
+ ftdi->error_str = "unable to fetch product description\n";
+ if (usb_close (ftdi->usb_dev) != 0)
+ return -10;
+ return -8;
}
+ if (strncmp(string, description, sizeof(string)) != 0) {
+ ftdi->error_str = "product description not matching\n";
+ if (usb_close (ftdi->usb_dev) != 0)
+ return -10;
+ continue;
+ }
+ }
+ if (serial != NULL) {
+ if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, string, sizeof(string)) <= 0) {
+ ftdi->error_str = "unable to fetch serial number\n";
+ if (usb_close (ftdi->usb_dev) != 0)
+ return -10;
+ return -9;
+ }
+ if (strncmp(string, serial, sizeof(string)) != 0) {
+ ftdi->error_str = "serial number not matching\n";
+ if (usb_close (ftdi->usb_dev) != 0)
+ return -10;
+ continue;
+ }
+ }
- if (ftdi_usb_reset (ftdi) != 0)
- return -6;
-
- if (ftdi_set_baudrate (ftdi, 9600) != 0)
- return -7;
-
- // Try to guess chip type
- // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
- if (dev->descriptor.bcdDevice == 0x400 || (dev->descriptor.bcdDevice == 0x200
- && dev->descriptor.iSerialNumber == 0))
- ftdi->type = TYPE_BM;
- else if (dev->descriptor.bcdDevice == 0x200)
- ftdi->type = TYPE_AM;
- else if (dev->descriptor.bcdDevice == 0x500)
- ftdi->type = TYPE_2232C;
+ if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0) {
+ ftdi->error_str = "unable to claim usb device. Make sure ftdi_sio is unloaded!";
+ if (usb_close (ftdi->usb_dev) != 0)
+ return -10;
+ return -5;
+ }
- return 0;
- } else {
- ftdi->error_str = "usb_open() failed";
- return -4;
+ if (ftdi_usb_reset (ftdi) != 0) {
+ if (usb_close (ftdi->usb_dev) != 0)
+ return -10;
+ return -6;
+ }
+
+ if (ftdi_set_baudrate (ftdi, 9600) != 0) {
+ if (usb_close (ftdi->usb_dev) != 0)
+ return -10;
+ return -7;
}
+
+ // Try to guess chip type
+ // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
+ if (dev->descriptor.bcdDevice == 0x400 || (dev->descriptor.bcdDevice == 0x200
+ && dev->descriptor.iSerialNumber == 0))
+ ftdi->type = TYPE_BM;
+ else if (dev->descriptor.bcdDevice == 0x200)
+ ftdi->type = TYPE_AM;
+ else if (dev->descriptor.bcdDevice == 0x500)
+ ftdi->type = TYPE_2232C;
+
+ return 0;
}
}
-
}
// device not found
}
-int ftdi_usb_reset(struct ftdi_context *ftdi) {
+int ftdi_usb_reset(struct ftdi_context *ftdi)
+{
if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
ftdi->error_str = "FTDI reset failed";
return -1;
return 0;
}
-int ftdi_usb_purge_buffers(struct ftdi_context *ftdi) {
+int ftdi_usb_purge_buffers(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_str = "FTDI purge of RX buffer failed";
return -1;
-1: usb_release failed
-2: usb_close failed
*/
-int ftdi_usb_close(struct ftdi_context *ftdi) {
+int ftdi_usb_close(struct ftdi_context *ftdi)
+{
int rtn = 0;
if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0)
Function is only used internally
*/
static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
- unsigned short *value, unsigned short *index) {
+ unsigned short *value, unsigned short *index)
+{
static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
-1: invalid baudrate
-2: setting baudrate failed
*/
-int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) {
+int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
+{
unsigned short value, index;
int actual_baudrate;
}
-int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size) {
+int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
+{
int ret;
int offset = 0;
int total_written = 0;
write_size = size-offset;
ret = usb_bulk_write(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, ftdi->usb_write_timeout);
- if (ret == -1) {
- ftdi->error_str = "bulk write failed";
- return -1;
+ if (ret < 0) {
+ if (ret == -1)
+ ftdi->error_str = "bulk write failed";
+ else
+ ftdi->error_str = "usb failed";
+ return ret;
}
total_written += ret;
}
-int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize) {
+int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
+{
ftdi->writebuffer_chunksize = chunksize;
return 0;
}
-int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize) {
+int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
+{
*chunksize = ftdi->writebuffer_chunksize;
return 0;
}
-int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) {
- struct timeval tv, tv_ref, tv_now;
- struct usbdevfs_urb *returned_urb;
- int offset = 0, ret = 1, waiting;
+int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
+{
+ int offset = 0, ret = 1, i, num_of_chunks, chunk_remains;
// everything we want is still in the readbuffer?
if (size <= ftdi->readbuffer_remaining) {
// Fix offset
offset += ftdi->readbuffer_remaining;
}
-
// do the actual USB read
while (offset < size && ret > 0) {
ftdi->readbuffer_remaining = 0;
ftdi->readbuffer_offset = 0;
-
- /*
- // Old read functions, not status byte safe!
- // returns how much received
- ret = usb_bulk_read (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer,
- ftdi->readbuffer_chunksize, ftdi->usb_read_timeout);
- */
-
- /* Real userspace URB processing to cope with
- a race condition where two or more status bytes
- could already be in the kernel USB buffer */
- memset(ftdi->urb, 0, sizeof(struct usbdevfs_urb));
-
- ftdi->urb->type = USBDEVFS_URB_TYPE_BULK;
- ftdi->urb->endpoint = ftdi->out_ep | USB_DIR_IN;
- ftdi->urb->buffer = ftdi->readbuffer;
- ftdi->urb->buffer_length = ftdi->readbuffer_chunksize;
-
- /* Submit URB to USB layer */
- if (ftdi_usbdev_submit_urb(ftdi->usb_dev->fd, ftdi->urb) == -1) {
- ftdi->error_str = "ftdi_usbdev_submit_urb for bulk read failed";
- return -1;
- }
-
- /* Wait for the result to come in.
- Timer stuff is borrowed from libusb's interrupt transfer */
- gettimeofday(&tv_ref, NULL);
- tv_ref.tv_sec = tv_ref.tv_sec + ftdi->usb_read_timeout / 1000;
- tv_ref.tv_usec = tv_ref.tv_usec + (ftdi->usb_read_timeout % 1000) * 1000;
-
- if (tv_ref.tv_usec > 1e6) {
- tv_ref.tv_usec -= 1e6;
- tv_ref.tv_sec++;
- }
-
- waiting = 1;
- memset (&tv, 0, sizeof (struct timeval));
- while (((ret = ftdi_usbdev_reap_urb_ndelay(ftdi->usb_dev->fd, &returned_urb)) == -1) && waiting) {
- tv.tv_sec = 0;
- tv.tv_usec = 1000; // 1 msec
- select(0, NULL, NULL, NULL, &tv); //sub second wait
-
- /* compare with actual time, as the select timeout is not that precise */
- gettimeofday(&tv_now, NULL);
-
- if ((tv_now.tv_sec > tv_ref.tv_sec) ||
- ((tv_now.tv_sec == tv_ref.tv_sec) && (tv_now.tv_usec >= tv_ref.tv_usec)))
- waiting = 0;
- }
-
- if (!waiting) {
- ftdi->error_str = "timeout during ftdi_read_data";
- return -1;
- }
-
+ /* returns how much received */
+ ret = usb_bulk_read (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, ftdi->usb_read_timeout);
+
if (ret < 0) {
- ftdi->error_str = "ftdi_usbdev_reap_urb for bulk read failed";
- return -1;
+ if (ret == -1)
+ ftdi->error_str = "bulk read failed";
+ else
+ ftdi->error_str = "usb failed";
+ return ret;
}
-
- if (returned_urb->status) {
- ftdi->error_str = "URB return status not OK";
- return -1;
- }
-
- /* Paranoia check */
- if (returned_urb->buffer != ftdi->readbuffer) {
- ftdi->error_str = "buffer paranoia check failed";
- return -1;
- }
-
- ret = returned_urb->actual_length;
+
if (ret > 2) {
// skip FTDI status bytes.
// Maybe stored in the future to enable modem use
+ num_of_chunks = ret / 64;
+ chunk_remains = ret % 64;
+ //printf("ret = %X, num_of_chunks = %X, chunk_remains = %X, readbuffer_offset = %X\n", ret, num_of_chunks, chunk_remains, ftdi->readbuffer_offset);
+
ftdi->readbuffer_offset += 2;
ret -= 2;
+
+ if (ret > 64) {
+ for (i = 1; i < num_of_chunks; i++)
+ memmove (ftdi->readbuffer+ftdi->readbuffer_offset+62*i,
+ ftdi->readbuffer+ftdi->readbuffer_offset+64*i,
+ 62);
+ if (chunk_remains > 2) {
+ memmove (ftdi->readbuffer+ftdi->readbuffer_offset+62*i,
+ ftdi->readbuffer+ftdi->readbuffer_offset+64*i,
+ chunk_remains-2);
+ ret -= 2*num_of_chunks;
+ } else
+ ret -= 2*(num_of_chunks-1)+chunk_remains;
+ }
} else if (ret <= 2) {
// no more data to read?
return offset;
// only copy part of the data or size <= readbuffer_chunksize
int part_size = size-offset;
memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
-
+
ftdi->readbuffer_offset += part_size;
ftdi->readbuffer_remaining = ret-part_size;
offset += part_size;
}
}
// never reached
- return -2;
+ return -127;
}
-int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize) {
+int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
+{
+ unsigned char *new_buf;
+
// Invalidate all remaining data
ftdi->readbuffer_offset = 0;
ftdi->readbuffer_remaining = 0;
- unsigned char *new_buf;
if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL) {
ftdi->error_str = "out of memory for readbuffer";
return -1;
}
-int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize) {
+int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
+{
*chunksize = ftdi->readbuffer_chunksize;
return 0;
}
-int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask) {
+int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask)
+{
unsigned short usb_val;
usb_val = bitmask; // low byte: bitmask
}
-int ftdi_disable_bitbang(struct ftdi_context *ftdi) {
+int ftdi_disable_bitbang(struct ftdi_context *ftdi)
+{
if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
ftdi->error_str = "Unable to leave bitbang mode. Perhaps not a BM type chip?";
return -1;
}
-int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins) {
+int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
+{
unsigned short usb_val;
if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0C, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1) {
ftdi->error_str = "Read pins failed";
}
-int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency) {
+int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
+{
unsigned short usb_val;
if (latency < 1) {
}
-int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency) {
+int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
+{
unsigned short usb_val;
if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0A, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1) {
ftdi->error_str = "Reading latency timer failed";
}
-void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom) {
+void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom)
+{
eeprom->vendor_id = 0x0403;
eeprom->product_id = 0x6001;
positive value: used eeprom size
-1: eeprom size (128 bytes) exceeded by custom strings
*/
-int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) {
+int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output)
+{
unsigned char i, j;
unsigned short checksum, value;
unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
}
-int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) {
+int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
+{
int i;
for (i = 0; i < 64; i++) {
}
-int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) {
+int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
+{
unsigned short usb_val;
int i;
}
-int ftdi_erase_eeprom(struct ftdi_context *ftdi) {
+int ftdi_erase_eeprom(struct ftdi_context *ftdi)
+{
if (usb_control_msg(ftdi->usb_dev, 0x40, 0x92, 0, 0, NULL, 0, ftdi->usb_write_timeout) != 0) {
ftdi->error_str = "Unable to erase eeprom";
return -1;
return 0;
}
-
-
-/* Functions needed for userspace URB processing */
-static struct usbdevfs_urb * ftdi_usbdev_alloc_urb(int iso_packets)
-{
- return calloc(sizeof(struct usbdevfs_urb)
- + iso_packets * sizeof(struct usbdevfs_iso_packet_desc),
- 1);
-}
-
-
-static int ftdi_usbdev_submit_urb(int fd, struct usbdevfs_urb *urb)
-{
- return ioctl(fd, USBDEVFS_SUBMITURB, urb);
-}
-
-
-static int ftdi_usbdev_reap_urb_ndelay(int fd, struct usbdevfs_urb **urb_return)
-{
- return ioctl(fd, USBDEVFS_REAPURBNDELAY, urb_return);
-}
git://developer.intra2net.com / libftdi / blobdiff