-------------------
begin : Fri Apr 4 2003
copyright : (C) 2003 by Intra2net AG
- email : info@intra2net.com
+ email : opensource@intra2net.com
***************************************************************************/
/***************************************************************************
***************************************************************************/
#include <usb.h>
-
+#include <string.h>
+
#include "ftdi.h"
-int ftdi_init(struct ftdi_context *ftdi) {
+/* ftdi_init return codes:
+ 0: all fine
+ -1: couldn't allocate read buffer
+*/
+int ftdi_init(struct ftdi_context *ftdi)
+{
ftdi->usb_dev = NULL;
- ftdi->usb_timeout = 5000;
+ ftdi->usb_read_timeout = 5000;
+ ftdi->usb_write_timeout = 5000;
+ ftdi->type = TYPE_BM; /* chip type */
ftdi->baudrate = -1;
ftdi->bitbang_enabled = 0;
+ ftdi->readbuffer = NULL;
+ ftdi->readbuffer_offset = 0;
+ ftdi->readbuffer_remaining = 0;
+ ftdi->writebuffer_chunksize = 4096;
+
+ ftdi->interface = 0;
+ ftdi->index = 0;
+ ftdi->in_ep = 0x02;
+ ftdi->out_ep = 0x81;
+ ftdi->bitbang_mode = 1; /* 1: Normal bitbang mode, 2: SPI bitbang mode */
+
ftdi->error_str = NULL;
- return 0;
+ /* All fine. Now allocate the readbuffer */
+ return ftdi_read_data_set_chunksize(ftdi, 4096);
}
-void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *usb) {
+void ftdi_deinit(struct ftdi_context *ftdi)
+{
+ if (ftdi->readbuffer != NULL) {
+ free(ftdi->readbuffer);
+ ftdi->readbuffer = NULL;
+ }
+}
+
+
+void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *usb)
+{
ftdi->usb_dev = usb;
}
-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, 0) != 0) {
- ftdi->error_str = "unable to claim usb device. You can still use it though...";
- 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;
+ 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) {
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 0, 0, NULL, 0, ftdi->usb_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;
}
+ // Invalidate data in the readbuffer
+ ftdi->readbuffer_offset = 0;
+ ftdi->readbuffer_remaining = 0;
return 0;
}
-int ftdi_usb_purge_buffers(struct ftdi_context *ftdi) {
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 1, 0, NULL, 0, ftdi->usb_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;
}
+ // Invalidate data in the readbuffer
+ ftdi->readbuffer_offset = 0;
+ ftdi->readbuffer_remaining = 0;
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 2, 0, NULL, 0, ftdi->usb_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;
}
+
return 0;
}
-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, 0) != 0)
+ if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0)
rtn = -1;
if (usb_close (ftdi->usb_dev) != 0)
/*
+ ftdi_convert_baudrate returns nearest supported baud rate to that requested.
+ Function is only used internally
+*/
+static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
+ 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};
+ int divisor, best_divisor, best_baud, best_baud_diff;
+ unsigned long encoded_divisor;
+ int i;
+
+ if (baudrate <= 0) {
+ // Return error
+ return -1;
+ }
+
+ divisor = 24000000 / baudrate;
+
+ if (ftdi->type == TYPE_AM) {
+ // Round down to supported fraction (AM only)
+ divisor -= am_adjust_dn[divisor & 7];
+ }
+
+ // Try this divisor and the one above it (because division rounds down)
+ best_divisor = 0;
+ best_baud = 0;
+ best_baud_diff = 0;
+ for (i = 0; i < 2; i++) {
+ int try_divisor = divisor + i;
+ int baud_estimate;
+ int baud_diff;
+
+ // Round up to supported divisor value
+ if (try_divisor < 8) {
+ // Round up to minimum supported divisor
+ try_divisor = 8;
+ } else if (ftdi->type != TYPE_AM && try_divisor < 12) {
+ // BM doesn't support divisors 9 through 11 inclusive
+ try_divisor = 12;
+ } else if (divisor < 16) {
+ // AM doesn't support divisors 9 through 15 inclusive
+ try_divisor = 16;
+ } else {
+ if (ftdi->type == TYPE_AM) {
+ // Round up to supported fraction (AM only)
+ try_divisor += am_adjust_up[try_divisor & 7];
+ if (try_divisor > 0x1FFF8) {
+ // Round down to maximum supported divisor value (for AM)
+ try_divisor = 0x1FFF8;
+ }
+ } else {
+ if (try_divisor > 0x1FFFF) {
+ // Round down to maximum supported divisor value (for BM)
+ try_divisor = 0x1FFFF;
+ }
+ }
+ }
+ // Get estimated baud rate (to nearest integer)
+ baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
+ // Get absolute difference from requested baud rate
+ if (baud_estimate < baudrate) {
+ baud_diff = baudrate - baud_estimate;
+ } else {
+ baud_diff = baud_estimate - baudrate;
+ }
+ if (i == 0 || baud_diff < best_baud_diff) {
+ // Closest to requested baud rate so far
+ best_divisor = try_divisor;
+ best_baud = baud_estimate;
+ best_baud_diff = baud_diff;
+ if (baud_diff == 0) {
+ // Spot on! No point trying
+ break;
+ }
+ }
+ }
+ // Encode the best divisor value
+ encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
+ // Deal with special cases for encoded value
+ if (encoded_divisor == 1) {
+ encoded_divisor = 0; // 3000000 baud
+ } else if (encoded_divisor == 0x4001) {
+ encoded_divisor = 1; // 2000000 baud (BM only)
+ }
+ // Split into "value" and "index" values
+ *value = (unsigned short)(encoded_divisor & 0xFFFF);
+ if(ftdi->type == TYPE_2232C) {
+ *index = (unsigned short)(encoded_divisor >> 8);
+ *index &= 0xFF00;
+ *index |= ftdi->interface;
+ }
+ else
+ *index = (unsigned short)(encoded_divisor >> 16);
+
+ // Return the nearest baud rate
+ return best_baud;
+}
+
+/*
ftdi_set_baudrate return codes:
0: all fine
-1: invalid baudrate
-2: setting baudrate failed
*/
-int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) {
- unsigned short ftdi_baudrate;
+int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
+{
+ unsigned short value, index;
+ int actual_baudrate;
if (ftdi->bitbang_enabled) {
baudrate = baudrate*4;
}
- switch (baudrate) {
- case 300:
- ftdi_baudrate = 0x2710;
- break;
- case 600:
- ftdi_baudrate = 0x1388;
- break;
- case 1200:
- ftdi_baudrate = 0x09C4;
- break;
- case 2400:
- ftdi_baudrate = 0x04E2;
- break;
- case 4800:
- ftdi_baudrate = 0x0271;
- break;
- case 9600:
- ftdi_baudrate = 0x4138;
- break;
- case 19200:
- ftdi_baudrate = 0x809C;
- break;
- case 38400:
- ftdi_baudrate = 0xC04E;
- break;
- case 57600:
- ftdi_baudrate = 0x0034;
- break;
- case 115200:
- ftdi_baudrate = 0x001A;
- break;
- case 230400:
- ftdi_baudrate = 0x000D;
- break;
- case 460800:
- ftdi_baudrate = 0x4006;
- break;
- case 921600:
- ftdi_baudrate = 0x8003;
- break;
- default:
- ftdi->error_str = "Unknown baudrate. Note: bitbang baudrates are automatically multiplied by 4";
+ actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
+ if (actual_baudrate <= 0) {
+ ftdi->error_str = "Silly baudrate <= 0.";
return -1;
}
- if (usb_control_msg(ftdi->usb_dev, 0x40, 3, ftdi_baudrate, 0, NULL, 0, ftdi->usb_timeout) != 0) {
+ // Check within tolerance (about 5%)
+ if ((actual_baudrate * 2 < baudrate /* Catch overflows */ )
+ || ((actual_baudrate < baudrate)
+ ? (actual_baudrate * 21 < baudrate * 20)
+ : (baudrate * 21 < actual_baudrate * 20))) {
+ ftdi->error_str = "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4";
+ return -1;
+ }
+
+ 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;
while (offset < size) {
- int write_size = 64;
+ int write_size = ftdi->writebuffer_chunksize;
if (offset+write_size > size)
write_size = size-offset;
- ret=usb_bulk_write(ftdi->usb_dev, 2, buf+offset, write_size, ftdi->usb_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;
offset += write_size;
}
+ return total_written;
+}
+
+
+int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
+{
+ ftdi->writebuffer_chunksize = chunksize;
return 0;
}
-int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) {
- static unsigned char readbuf[64];
- int ret = 1;
- int offset = 0;
+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)
+{
+ int offset = 0, ret = 1, i, num_of_chunks, chunk_remains;
+
+ // everything we want is still in the readbuffer?
+ if (size <= ftdi->readbuffer_remaining) {
+ memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
+
+ // Fix offsets
+ ftdi->readbuffer_remaining -= size;
+ ftdi->readbuffer_offset += size;
+
+ /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
- if (size != 0 && size % 64 != 0) {
- ftdi->error_str = "Sorry, read buffer size must currently be a multiple (1x, 2x, 3x...) of 64";
- return -2;
+ return size;
}
+ // something still in the readbuffer, but not enough to satisfy 'size'?
+ if (ftdi->readbuffer_remaining != 0) {
+ memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
+ // Fix offset
+ offset += ftdi->readbuffer_remaining;
+ }
+ // do the actual USB read
while (offset < size && ret > 0) {
- ret = usb_bulk_read (ftdi->usb_dev, 0x81, readbuf, 64, ftdi->usb_timeout);
- // Skip FTDI status bytes
- if (ret >= 2)
- ret-=2;
-
- if (ret > 0) {
- memcpy (buf+offset, readbuf+2, ret);
- }
-
- if (ret == -1) {
- ftdi->error_str = "bulk read failed";
- return -1;
- }
+ ftdi->readbuffer_remaining = 0;
+ ftdi->readbuffer_offset = 0;
+ /* 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) {
+ if (ret == -1)
+ ftdi->error_str = "bulk read failed";
+ else
+ ftdi->error_str = "usb failed";
+ return ret;
+ }
+
+ 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;
+ }
+ if (ret > 0) {
+ // data still fits in buf?
+ if (offset+ret <= size) {
+ memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, ret);
+ //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
+ offset += ret;
+
+ /* Did we read exactly the right amount of bytes? */
+ if (offset == size)
+ return offset;
+ } else {
+ // 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;
+
+ /* printf("Returning part: %d - size: %d - offset: %d - ret: %d - remaining: %d\n",
+ part_size, size, offset, ret, ftdi->readbuffer_remaining); */
+
+ return offset;
+ }
+ }
+ }
+ // never reached
+ return -127;
+}
+
- offset += ret;
+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;
+
+ if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL) {
+ ftdi->error_str = "out of memory for readbuffer";
+ return -1;
}
- return offset;
+ ftdi->readbuffer = new_buf;
+ ftdi->readbuffer_chunksize = chunksize;
+
+ return 0;
}
-int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask) {
+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)
+{
unsigned short usb_val;
- usb_val = bitmask; // low byte: bitmask
- usb_val += 1 << 8; // high byte: enable flag
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, 0, NULL, 0, ftdi->usb_timeout) != 0) {
+ usb_val = bitmask; // low byte: bitmask
+ /* FT2232C: Set bitbang_mode to 2 to enable SPI */
+ usb_val |= (ftdi->bitbang_mode << 8);
+
+ 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;
}
-
ftdi->bitbang_enabled = 1;
return 0;
}
-int ftdi_disable_bitbang(struct ftdi_context *ftdi) {
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, 0, 0, NULL, 0, ftdi->usb_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 (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0C, 0, 0, (char *)&usb_val, 1, ftdi->usb_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) {
- ftdi->error_str = "Latency out of range. Only valid for 1-255";
- return -1;
+ ftdi->error_str = "Latency out of range. Only valid for 1-255";
+ return -1;
}
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0x09, usb_val, 0, NULL, 0, ftdi->usb_timeout) != 0) {
- ftdi->error_str = "Unable to set latency timer";
- return -2;
+ usb_val = latency;
+ 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;
}
return 0;
}
-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, 0x09, 0, 0, (char *)&usb_val, 1, ftdi->usb_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) {
- eeprom->vendor_id = 0403;
- eeprom->product_id = 6001;
-
+void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom)
+{
+ eeprom->vendor_id = 0x0403;
+ eeprom->product_id = 0x6001;
+
eeprom->self_powered = 1;
eeprom->remote_wakeup = 1;
eeprom->BM_type_chip = 1;
-
+
eeprom->in_is_isochronous = 0;
eeprom->out_is_isochronous = 0;
eeprom->suspend_pull_downs = 0;
-
+
eeprom->use_serial = 0;
eeprom->change_usb_version = 0;
- eeprom->usb_version = 200;
+ eeprom->usb_version = 0x0200;
eeprom->max_power = 0;
-
+
eeprom->manufacturer = NULL;
eeprom->product = NULL;
eeprom->serial = NULL;
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 size_check;
if (eeprom->manufacturer != NULL)
- manufacturer_size = strlen(eeprom->manufacturer);
+ manufacturer_size = strlen(eeprom->manufacturer);
if (eeprom->product != NULL)
- product_size = strlen(eeprom->product);
+ product_size = strlen(eeprom->product);
if (eeprom->serial != NULL)
- serial_size = strlen(eeprom->serial);
+ serial_size = strlen(eeprom->serial);
- size_check = 128; // eeprom is 128 bytes
- size_check -= 28; // 28 are always in use (fixed)
+ size_check = 128; // eeprom is 128 bytes
+ size_check -= 28; // 28 are always in use (fixed)
size_check -= manufacturer_size*2;
size_check -= product_size*2;
size_check -= serial_size*2;
// eeprom size exceeded?
if (size_check < 0)
- return (-1);
+ return (-1);
// empty eeprom
memset (output, 0, 128);
// Addr 06: Device release number (0400h for BM features)
output[0x06] = 0x00;
-
+
if (eeprom->BM_type_chip == 1)
- output[0x07] = 0x04;
+ output[0x07] = 0x04;
else
- output[0x07] = 0x02;
+ output[0x07] = 0x02;
// Addr 08: Config descriptor
// Bit 1: remote wakeup if 1
//
j = 0;
if (eeprom->self_powered == 1)
- j = j | 1;
+ j = j | 1;
if (eeprom->remote_wakeup == 1)
- j = j | 2;
+ j = j | 2;
output[0x08] = j;
// Addr 09: Max power consumption: max power = value * 2 mA
- output[0x09] = eeprom->max_power;;
-
+ output[0x09] = eeprom->max_power;
+ ;
+
// Addr 0A: Chip configuration
// Bit 7: 0 - reserved
// Bit 6: 0 - reserved
//
j = 0;
if (eeprom->in_is_isochronous == 1)
- j = j | 1;
+ j = j | 1;
if (eeprom->out_is_isochronous == 1)
- j = j | 2;
+ j = j | 2;
if (eeprom->suspend_pull_downs == 1)
- j = j | 4;
+ j = j | 4;
if (eeprom->use_serial == 1)
- j = j | 8;
+ j = j | 8;
if (eeprom->change_usb_version == 1)
- j = j | 16;
+ j = j | 16;
output[0x0A] = j;
-
+
// Addr 0B: reserved
output[0x0B] = 0x00;
-
+
// Addr 0C: USB version low byte when 0x0A bit 4 is set
// Addr 0D: USB version high byte when 0x0A bit 4 is set
if (eeprom->change_usb_version == 1) {
output[0x0C] = eeprom->usb_version;
- output[0x0D] = eeprom->usb_version >> 8;
+ output[0x0D] = eeprom->usb_version >> 8;
}
// Dynamic content
output[0x14] = manufacturer_size*2 + 2;
- output[0x15] = 0x03; // type: string
-
+ output[0x15] = 0x03; // type: string
+
i = 0x16, j = 0;
-
+
// Output manufacturer
for (j = 0; j < manufacturer_size; j++) {
- output[i] = eeprom->manufacturer[j], i++;
- output[i] = 0x00, i++;
+ 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++) {
- output[i] = eeprom->product[j], i++;
- output[i] = 0x00, i++;
+ output[i] = eeprom->product[j], i++;
+ output[i] = 0x00, i++;
}
-
+
// 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++) {
- output[i] = eeprom->serial[j], i++;
- output[i] = 0x00, i++;
+ output[i] = eeprom->serial[j], i++;
+ output[i] = 0x00, i++;
}
// calculate checksum
checksum = 0xAAAA;
-
+
for (i = 0; i < 63; i++) {
- value = output[i*2];
- value += output[(i*2)+1] << 8;
+ value = output[i*2];
+ value += output[(i*2)+1] << 8;
- checksum = value^checksum;
- checksum = (checksum << 1) | (checksum >> 15);
+ checksum = value^checksum;
+ checksum = (checksum << 1) | (checksum >> 15);
}
output[0x7E] = checksum;
- output[0x7F] = checksum >> 8;
+ output[0x7F] = checksum >> 8;
return size_check;
}
-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 (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_timeout) != 2) {
- ftdi->error_str = "Reading eeprom failed";
- return -1;
+ 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 (usb_control_msg(ftdi->usb_dev, 0x40, 0x91, usb_val, i, NULL, 0, ftdi->usb_timeout) != 0) {
- ftdi->error_str = "Unable to write eeprom";
- return -1;
- }
+ 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) {
+ ftdi->error_str = "Unable to write eeprom";
+ return -1;
+ }
}
return 0;
}
-int ftdi_erase_eeprom(struct ftdi_context *ftdi) {
- if (usb_control_msg(ftdi->usb_dev, 0x40, 0x92, 0, 0, NULL, 0, ftdi->usb_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;
}
git://developer.intra2net.com / libftdi / blobdiff