* 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/stat.h>
-#include <fcntl.h>
-#include <dirent.h>
-
-/* Internal USB devfs functions. Do not use outside libftdi */
-
-/* Those two functions are borrowed from "usbstress" */
-static int ftdi_usbdev_parsedev(int fd, unsigned int *bus, unsigned int *dev, int vendorid, int productid);
-int ftdi_usbdev_open(int vendorid, int productid);
-
-int ftdi_usbdev_claim_interface(int fd, unsigned int interface);
-int ftdi_usbdev_release_interface(int fd, int interface);
-int ftdi_usbdev_bulk_write(int fd, unsigned int endpoint, const void *data,
- unsigned int size, unsigned int timeout);
-int ftdi_usbdev_control_msg(int fd, unsigned int requesttype, unsigned int request,
- unsigned int value, unsigned int index,
- void *data, unsigned int size, unsigned int timeout);
-struct usbdevfs_urb * ftdi_usbdev_alloc_urb(int iso_packets);
-int ftdi_usbdev_submit_urb(int fd, struct usbdevfs_urb *urb);
-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
*/
int ftdi_init(struct ftdi_context *ftdi)
{
- ftdi->usb_fd = -1;
+ ftdi->usb_dev = NULL;
ftdi->usb_read_timeout = 5000;
ftdi->usb_write_timeout = 5000;
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;
- }
}
+
+void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *usb)
+{
+ ftdi->usb_dev = usb;
+}
+
+
/* ftdi_usb_open return codes:
0: all fine
- -1: usb device not found or unable to open
- -2: unable to claim device
- -3: reset failed
- -4: set baudrate failed
+ -1: usb_find_busses() failed
+ -2: usb_find_devices() failed
+ -3: usb device not found
+ -4: unable to open device
+ -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) {
- if ((ftdi->usb_fd = ftdi_usbdev_open(vendor, product)) < 0) {
- ftdi->error_str = "Device not found or unable to open it (permission problem?)";
- ftdi->usb_fd = -1;
- return -1;
- }
-
- if (ftdi_usbdev_claim_interface(ftdi->usb_fd, ftdi->interface) != 0) {
- ftdi->error_str = "unable to claim usb device. Make sure ftdi_sio is unloaded!";
- close (ftdi->usb_fd);
- ftdi->usb_fd = -1;
+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;
+
+ usb_init();
+
+ if (usb_find_busses() < 0) {
+ ftdi->error_str = "usb_find_busses() failed";
+ return -1;
+ }
+
+ if (usb_find_devices() < 0) {
+ ftdi->error_str = "usb_find_devices() failed";
return -2;
}
- if (ftdi_usb_reset (ftdi) != 0)
- return -6;
+ 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) {
+ 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_set_baudrate (ftdi, 9600) != 0)
- return -7;
+ 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;
+ }
-/*
- // 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;
+ 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
+ return -3;
}
-int ftdi_usb_reset(struct ftdi_context *ftdi) {
- if (ftdi_usbdev_control_msg(ftdi->usb_fd, 0x40, 0, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
+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) {
- if (ftdi_usbdev_control_msg(ftdi->usb_fd, 0x40, 0, 1, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
+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;
}
ftdi->readbuffer_offset = 0;
ftdi->readbuffer_remaining = 0;
- if (ftdi_usbdev_control_msg(ftdi->usb_fd, 0x40, 0, 2, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
+ if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 2, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
ftdi->error_str = "FTDI purge of TX buffer failed";
return -1;
}
/* ftdi_usb_close return codes
0: all fine
- -1: ftdi_usb_release failed
- -2: close failed
+ -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 (ftdi_usbdev_release_interface(ftdi->usb_fd, ftdi->interface) != 0) {
- ftdi->error_str = "Unable to release interface";
+ if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0)
rtn = -1;
- }
-
-
- if (close (ftdi->usb_fd) != 0) {
- ftdi->error_str = "Unable to close file descriptor";
+
+ if (usb_close (ftdi->usb_dev) != 0)
rtn = -2;
- }
-
+
return rtn;
}
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;
return -1;
}
- if (ftdi_usbdev_control_msg(ftdi->usb_fd, 0x40, 3, value, index, NULL, 0, ftdi->usb_write_timeout) != 0) {
+ if (usb_control_msg(ftdi->usb_dev, 0x40, 3, value, index, NULL, 0, ftdi->usb_write_timeout) != 0) {
ftdi->error_str = "Setting new baudrate failed";
return -2;
}
}
-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;
if (offset+write_size > size)
write_size = size-offset;
- ret = ftdi_usbdev_bulk_write(ftdi->usb_fd, ftdi->in_ep, buf+offset, write_size, ftdi->usb_write_timeout);
- if (ret == -1) {
- ftdi->error_str = "bulk write failed";
- return -1;
+ ret = usb_bulk_write(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, ftdi->usb_write_timeout);
+ 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;
-
- /* 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_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_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 (returned_urb->status) {
- ftdi->error_str = "URB return status not OK";
- return -1;
+ if (ret == -1)
+ ftdi->error_str = "bulk read failed";
+ else
+ ftdi->error_str = "usb failed";
+ return ret;
}
-
- /* 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
/* FT2232C: Set bitbang_mode to 2 to enable SPI */
usb_val |= (ftdi->bitbang_mode << 8);
- if (ftdi_usbdev_control_msg(ftdi->usb_fd, 0x40, 0x0B, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
+ if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
ftdi->error_str = "Unable to enter bitbang mode. Perhaps not a BM type chip?";
return -1;
}
}
-int ftdi_disable_bitbang(struct ftdi_context *ftdi) {
- if (ftdi_usbdev_control_msg(ftdi->usb_fd, 0x40, 0x0B, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
+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 (ftdi_usbdev_control_msg(ftdi->usb_fd, 0xC0, 0x0C, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1) {
+ 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";
return -1;
}
}
-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) {
}
usb_val = latency;
- if (ftdi_usbdev_control_msg(ftdi->usb_fd, 0x40, 0x09, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
+ if (usb_control_msg(ftdi->usb_dev, 0x40, 0x09, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
ftdi->error_str = "Unable to set latency timer";
return -2;
}
}
-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 (ftdi_usbdev_control_msg(ftdi->usb_fd, 0xC0, 0x0A, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1) {
+ 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";
return -1;
}
}
-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++) {
- if (ftdi_usbdev_control_msg(ftdi->usb_fd, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2) {
+ if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2) {
ftdi->error_str = "Reading eeprom failed";
return -1;
}
}
-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;
for (i = 0; i < 64; i++) {
usb_val = eeprom[i*2];
usb_val += eeprom[(i*2)+1] << 8;
- if (ftdi_usbdev_control_msg(ftdi->usb_fd, 0x40, 0x91, usb_val, i, NULL, 0, ftdi->usb_write_timeout) != 0) {
+ if (usb_control_msg(ftdi->usb_dev, 0x40, 0x91, usb_val, i, NULL, 0, ftdi->usb_write_timeout) != 0) {
ftdi->error_str = "Unable to write eeprom";
return -1;
}
}
-int ftdi_erase_eeprom(struct ftdi_context *ftdi) {
- if (ftdi_usbdev_control_msg(ftdi->usb_fd, 0x40, 0x92, 0, 0, NULL, 0, ftdi->usb_write_timeout) != 0) {
+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;
}
-
-
-/* libusb like functions - currently linux only */
-static int check_usb_vfs(const unsigned char *dirname)
-{
- DIR *dir;
- struct dirent *entry;
- int found = 0;
-
- dir = opendir(dirname);
- if (!dir)
- return 0;
-
- while ((entry = readdir(dir)) != NULL) {
- /* Skip anything starting with a . */
- if (entry->d_name[0] == '.')
- continue;
-
- /* We assume if we find any files that it must be the right place */
- found = 1;
- break;
- }
-
- closedir(dir);
-
- return found;
-}
-
-static int ftdi_usbdev_parsedev(int fd, unsigned int *bus, unsigned int *dev, int vendorid, int productid)
-{
- char buf[16384];
- char *start, *end, *lineend, *cp;
- int devnum = -1, busnum = -1, vendor = -1, product = -1;
- int ret;
-
- if (lseek(fd, 0, SEEK_SET) == (off_t)-1)
- return -1;
- ret = read(fd, buf, sizeof(buf)-1);
- if (ret == -1)
- return -1;
- end = buf + ret;
- *end = 0;
- start = buf;
- ret = 0;
- while (start < end) {
- lineend = strchr(start, '\n');
- if (!lineend)
- break;
- *lineend = 0;
- switch (start[0]) {
- case 'T': /* topology line */
- if ((cp = strstr(start, "Dev#="))) {
- devnum = strtoul(cp + 5, NULL, 0);
- } else
- devnum = -1;
- if ((cp = strstr(start, "Bus="))) {
- busnum = strtoul(cp + 4, NULL, 0);
- } else
- busnum = -1;
- break;
-
- case 'P':
- if ((cp = strstr(start, "Vendor="))) {
- vendor = strtoul(cp + 7, NULL, 16);
- } else
- vendor = -1;
- if ((cp = strstr(start, "ProdID="))) {
- product = strtoul(cp + 7, NULL, 16);
- } else
- product = -1;
- if (vendor != -1 && product != -1 && devnum >= 1 && devnum <= 127 &&
- busnum >= 0 && busnum <= 999 &&
- (vendorid == vendor || vendorid == -1) &&
- (productid == product || productid == -1)) {
- if (bus)
- *bus = busnum;
- if (dev)
- *dev = devnum;
- ret++;
- }
- break;
- }
- start = lineend + 1;
- }
- return ret;
-}
-
-int ftdi_usbdev_open(int vendorid, int productid)
-{
- unsigned int busnum, devnum, fd, ret;
- char usb_path[PATH_MAX+1] = "";
- char usb_devices_path[PATH_MAX*2];
-
- /* Find the path to the virtual filesystem */
- if (getenv("USB_DEVFS_PATH")) {
- if (check_usb_vfs((char*)getenv("USB_DEVFS_PATH"))) {
- strncpy(usb_path, (char*)getenv("USB_DEVFS_PATH"), sizeof(usb_path) - 1);
- usb_path[sizeof(usb_path) - 1] = 0;
- }
- }
-
- if (!usb_path[0]) {
- if (check_usb_vfs("/proc/bus/usb")) {
- strncpy(usb_path, "/proc/bus/usb", sizeof(usb_path) - 1);
- usb_path[sizeof(usb_path) - 1] = 0;
- } else if (check_usb_vfs("/sys/bus/usb")) { /* 2.6 Kernel with sysfs */
- strncpy(usb_path, "/sys/bus/usb", sizeof(usb_path) -1);
- usb_path[sizeof(usb_path) - 1] = 0;
- } else if (check_usb_vfs("/dev/usb")) {
- strncpy(usb_path, "/dev/usb", sizeof(usb_path) - 1);
- usb_path[sizeof(usb_path) - 1] = 0;
- } else
- usb_path[0] = 0;
- }
-
- /* No path, no USB support */
- if (!usb_path[0])
- return -1;
-
- /* Parse device list */
- snprintf(usb_devices_path, sizeof(usb_devices_path), "%s/devices", usb_path);
- if ((fd = open(usb_devices_path, O_RDONLY)) == -1)
- return -2;
-
- ret = ftdi_usbdev_parsedev(fd, &busnum, &devnum, vendorid, productid);
- close (fd);
-
- // Device not found
- if (ret != 1)
- return -3;
-
- snprintf(usb_devices_path, sizeof(usb_devices_path), "%s/%03u/%03u", usb_path, busnum, devnum);
- if ((fd = open(usb_devices_path, O_RDWR)) == -1)
- return -4;
-
- return fd;
-}
-
-int ftdi_usbdev_claim_interface(int fd, unsigned int interface)
-{
- return ioctl(fd, USBDEVFS_CLAIMINTERFACE, &interface);
-}
-
-int ftdi_usbdev_release_interface(int fd, int interface)
-{
- return ioctl(fd, USBDEVFS_RELEASEINTERFACE, &interface);
-}
-
-
-int ftdi_usbdev_bulk_write(int fd, unsigned int endpoint, const void *data,
- unsigned int size, unsigned int timeout)
-{
- struct usbdevfs_bulktransfer arg;
-
- arg.ep = endpoint & ~USB_DIR_IN;
- arg.len = size;
- arg.timeout = timeout;
- arg.data = (void *) data;
-
- return ioctl(fd, USBDEVFS_BULK, &arg);
-}
-
-int ftdi_usbdev_control_msg(int fd, unsigned int requesttype,
- unsigned int request, unsigned int value, unsigned int index,
- void *data, unsigned int size, unsigned int timeout)
-{
- struct usbdevfs_ctrltransfer arg;
-
- arg.requesttype = requesttype;
- arg.request = request;
- arg.value = value;
- arg.index = index;
- arg.length = size;
- arg.timeout = timeout;
- arg.data = data;
-
- return ioctl(fd, USBDEVFS_CONTROL, &arg);
-}
-
-/* Functions needed for userspace URB processing */
-struct usbdevfs_urb * ftdi_usbdev_alloc_urb(int iso_packets)
-{
- return (struct usbdevfs_urb *)calloc(sizeof(struct usbdevfs_urb)
- + iso_packets * sizeof(struct usbdevfs_iso_packet_desc),
- 1);
-}
-
-
-int ftdi_usbdev_submit_urb(int fd, struct usbdevfs_urb *urb)
-{
- return ioctl(fd, USBDEVFS_SUBMITURB, urb);
-}
-
-
-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