39 #include "ftdi_version_i.h"
41 #define ftdi_error_return(code, str) do { \
43 ftdi->error_str = str; \
45 fprintf(stderr, str); \
49 #define ftdi_error_return_free_device_list(code, str, devs) do { \
50 libusb_free_device_list(devs,1); \
51 ftdi->error_str = str; \
65 static void ftdi_usb_close_internal (
struct ftdi_context *ftdi)
108 if (libusb_init(&ftdi->
usb_ctx) < 0)
168 if (ftdi->
index != check_interface)
215 ftdi_usb_close_internal (ftdi);
285 ver.
major = FTDI_MAJOR_VERSION;
286 ver.
minor = FTDI_MINOR_VERSION;
287 ver.
micro = FTDI_MICRO_VERSION;
314 libusb_device **devs;
318 if (libusb_get_device_list(ftdi->
usb_ctx, &devs) < 0)
324 while ((dev = devs[i++]) != NULL)
326 struct libusb_device_descriptor desc;
328 if (libusb_get_device_descriptor(dev, &desc) < 0)
331 if (((vendor || product) &&
332 desc.idVendor == vendor && desc.idProduct == product) ||
333 (!(vendor || product) &&
334 (desc.idVendor == 0x403) && (desc.idProduct == 0x6001 || desc.idProduct == 0x6010
335 || desc.idProduct == 0x6011 || desc.idProduct == 0x6014
336 || desc.idProduct == 0x6015)))
342 (*curdev)->next = NULL;
343 (*curdev)->dev =
dev;
344 libusb_ref_device(dev);
345 curdev = &(*curdev)->
next;
349 libusb_free_device_list(devs,1);
362 for (curdev = *devlist; curdev != NULL;)
365 libusb_unref_device(curdev->
dev);
410 char * manufacturer,
int mnf_len,
char * description,
int desc_len,
char * serial,
int serial_len)
412 struct libusb_device_descriptor desc;
414 if ((ftdi==NULL) || (dev==NULL))
417 if (ftdi->
usb_dev == NULL && libusb_open(dev, &ftdi->
usb_dev) < 0)
420 if (libusb_get_device_descriptor(dev, &desc) < 0)
423 if (manufacturer != NULL)
425 if (libusb_get_string_descriptor_ascii(ftdi->
usb_dev, desc.iManufacturer, (
unsigned char *)manufacturer, mnf_len) < 0)
427 ftdi_usb_close_internal (ftdi);
432 if (description != NULL)
434 if (libusb_get_string_descriptor_ascii(ftdi->
usb_dev, desc.iProduct, (
unsigned char *)description, desc_len) < 0)
436 ftdi_usb_close_internal (ftdi);
443 if (libusb_get_string_descriptor_ascii(ftdi->
usb_dev, desc.iSerialNumber, (
unsigned char *)serial, serial_len) < 0)
445 ftdi_usb_close_internal (ftdi);
450 ftdi_usb_close_internal (ftdi);
461 static unsigned int _ftdi_determine_max_packet_size(
struct ftdi_context *ftdi, libusb_device *dev)
463 struct libusb_device_descriptor desc;
464 struct libusb_config_descriptor *config0;
465 unsigned int packet_size;
468 if (ftdi == NULL || dev == NULL)
479 if (libusb_get_device_descriptor(dev, &desc) < 0)
482 if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
485 if (desc.bNumConfigurations > 0)
487 if (ftdi->
interface < config0->bNumInterfaces)
489 struct libusb_interface interface = config0->interface[ftdi->
interface];
490 if (interface.num_altsetting > 0)
492 struct libusb_interface_descriptor descriptor = interface.altsetting[0];
493 if (descriptor.bNumEndpoints > 0)
495 packet_size = descriptor.endpoint[0].wMaxPacketSize;
501 libusb_free_config_descriptor (config0);
525 struct libusb_device_descriptor desc;
526 struct libusb_config_descriptor *config0;
527 int cfg, cfg0, detach_errno = 0;
532 if (libusb_open(dev, &ftdi->
usb_dev) < 0)
535 if (libusb_get_device_descriptor(dev, &desc) < 0)
538 if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
540 cfg0 = config0->bConfigurationValue;
541 libusb_free_config_descriptor (config0);
552 detach_errno = errno;
555 if (libusb_get_configuration (ftdi->
usb_dev, &cfg) < 0)
560 if (desc.bNumConfigurations > 0 && cfg != cfg0)
562 if (libusb_set_configuration(ftdi->
usb_dev, cfg0) < 0)
564 ftdi_usb_close_internal (ftdi);
565 if (detach_errno == EPERM)
571 ftdi_error_return(-3,
"unable to set usb configuration. Make sure the default FTDI driver is not in use");
578 ftdi_usb_close_internal (ftdi);
579 if (detach_errno == EPERM)
585 ftdi_error_return(-5,
"unable to claim usb device. Make sure the default FTDI driver is not in use");
591 ftdi_usb_close_internal (ftdi);
597 if (desc.bcdDevice == 0x400 || (desc.bcdDevice == 0x200
598 && desc.iSerialNumber == 0))
600 else if (desc.bcdDevice == 0x200)
602 else if (desc.bcdDevice == 0x500)
604 else if (desc.bcdDevice == 0x600)
606 else if (desc.bcdDevice == 0x700)
608 else if (desc.bcdDevice == 0x800)
610 else if (desc.bcdDevice == 0x900)
612 else if (desc.bcdDevice == 0x1000)
620 ftdi_usb_close_internal (ftdi);
663 const char* description,
const char* serial)
693 const char* description,
const char* serial,
unsigned int index)
696 libusb_device **devs;
703 if (libusb_get_device_list(ftdi->
usb_ctx, &devs) < 0)
706 while ((dev = devs[i++]) != NULL)
708 struct libusb_device_descriptor desc;
711 if (libusb_get_device_descriptor(dev, &desc) < 0)
714 if (desc.idVendor == vendor && desc.idProduct == product)
716 if (libusb_open(dev, &ftdi->
usb_dev) < 0)
719 if (description != NULL)
721 if (libusb_get_string_descriptor_ascii(ftdi->
usb_dev, desc.iProduct, (
unsigned char *)
string,
sizeof(
string)) < 0)
723 ftdi_usb_close_internal (ftdi);
726 if (strncmp(
string, description,
sizeof(
string)) != 0)
728 ftdi_usb_close_internal (ftdi);
734 if (libusb_get_string_descriptor_ascii(ftdi->
usb_dev, desc.iSerialNumber, (
unsigned char *)
string,
sizeof(
string)) < 0)
736 ftdi_usb_close_internal (ftdi);
739 if (strncmp(
string, serial,
sizeof(
string)) != 0)
741 ftdi_usb_close_internal (ftdi);
746 ftdi_usb_close_internal (ftdi);
755 libusb_free_device_list(devs,1);
795 if (description[0] == 0 || description[1] !=
':')
798 if (description[0] ==
'd')
801 libusb_device **devs;
802 unsigned int bus_number, device_address;
805 if (libusb_get_device_list(ftdi->
usb_ctx, &devs) < 0)
809 if (sscanf (description + 2,
"%u/%u", &bus_number, &device_address) != 2)
812 while ((dev = devs[i++]) != NULL)
815 if (bus_number == libusb_get_bus_number (dev)
816 && device_address == libusb_get_device_address (dev))
819 libusb_free_device_list(devs,1);
827 else if (description[0] ==
'i' || description[0] ==
's')
830 unsigned int product;
831 unsigned int index=0;
832 const char *serial=NULL;
833 const char *startp, *endp;
836 startp=description+2;
837 vendor=strtoul((
char*)startp,(
char**)&endp,0);
838 if (*endp !=
':' || endp == startp || errno != 0)
842 product=strtoul((
char*)startp,(
char**)&endp,0);
843 if (endp == startp || errno != 0)
846 if (description[0] ==
'i' && *endp != 0)
853 index=strtoul((
char*)startp,(
char**)&endp,0);
854 if (*endp != 0 || endp == startp || errno != 0)
857 if (description[0] ==
's')
885 if (ftdi == NULL || ftdi->
usb_dev == NULL)
911 if (ftdi == NULL || ftdi->
usb_dev == NULL)
937 if (ftdi == NULL || ftdi->
usb_dev == NULL)
962 if (ftdi == NULL || ftdi->
usb_dev == NULL)
998 ftdi_usb_close_internal (ftdi);
1015 static int ftdi_to_clkbits_AM(
int baudrate,
unsigned long *encoded_divisor)
1018 static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
1019 static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
1020 static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
1021 int divisor, best_divisor, best_baud, best_baud_diff;
1023 divisor = 24000000 / baudrate;
1026 divisor -= am_adjust_dn[divisor & 7];
1032 for (i = 0; i < 2; i++)
1034 int try_divisor = divisor + i;
1039 if (try_divisor <= 8)
1044 else if (divisor < 16)
1052 try_divisor += am_adjust_up[try_divisor & 7];
1053 if (try_divisor > 0x1FFF8)
1056 try_divisor = 0x1FFF8;
1060 baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
1062 if (baud_estimate < baudrate)
1064 baud_diff = baudrate - baud_estimate;
1068 baud_diff = baud_estimate - baudrate;
1070 if (i == 0 || baud_diff < best_baud_diff)
1073 best_divisor = try_divisor;
1074 best_baud = baud_estimate;
1075 best_baud_diff = baud_diff;
1084 *encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
1086 if (*encoded_divisor == 1)
1088 *encoded_divisor = 0;
1090 else if (*encoded_divisor == 0x4001)
1092 *encoded_divisor = 1;
1121 static int ftdi_to_clkbits(
int baudrate,
unsigned int clk,
int clk_div,
unsigned long *encoded_divisor)
1123 static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
1125 int divisor, best_divisor;
1126 if (baudrate >= clk/clk_div)
1128 *encoded_divisor = 0;
1129 best_baud = clk/clk_div;
1131 else if (baudrate >= clk/(clk_div + clk_div/2))
1133 *encoded_divisor = 1;
1134 best_baud = clk/(clk_div + clk_div/2);
1136 else if (baudrate >= clk/(2*clk_div))
1138 *encoded_divisor = 2;
1139 best_baud = clk/(2*clk_div);
1144 divisor = clk*16/clk_div / baudrate;
1146 best_divisor = divisor /2 +1;
1148 best_divisor = divisor/2;
1149 if(best_divisor > 0x20000)
1150 best_divisor = 0x1ffff;
1151 best_baud = clk*16/clk_div/best_divisor;
1153 best_baud = best_baud /2 +1;
1155 best_baud = best_baud /2;
1156 *encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 0x7] << 14);
1165 static int ftdi_convert_baudrate(
int baudrate,
struct ftdi_context *ftdi,
1166 unsigned short *value,
unsigned short *index)
1169 unsigned long encoded_divisor;
1177 #define H_CLK 120000000
1178 #define C_CLK 48000000
1181 if(baudrate*10 >
H_CLK /0x3fff)
1188 best_baud = ftdi_to_clkbits(baudrate,
H_CLK, 10, &encoded_divisor);
1189 encoded_divisor |= 0x20000;
1192 best_baud = ftdi_to_clkbits(baudrate,
C_CLK, 16, &encoded_divisor);
1196 best_baud = ftdi_to_clkbits(baudrate,
C_CLK, 16, &encoded_divisor);
1200 best_baud = ftdi_to_clkbits_AM(baudrate, &encoded_divisor);
1203 *value = (
unsigned short)(encoded_divisor & 0xFFFF);
1206 *index = (
unsigned short)(encoded_divisor >> 8);
1208 *index |= ftdi->
index;
1211 *index = (
unsigned short)(encoded_divisor >> 16);
1222 unsigned short *value,
unsigned short *index)
1224 return ftdi_convert_baudrate(baudrate, ftdi, value, index);
1240 unsigned short value, index;
1241 int actual_baudrate;
1243 if (ftdi == NULL || ftdi->
usb_dev == NULL)
1248 baudrate = baudrate*4;
1251 actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
1252 if (actual_baudrate <= 0)
1256 if ((actual_baudrate * 2 < baudrate )
1257 || ((actual_baudrate < baudrate)
1258 ? (actual_baudrate * 21 < baudrate * 20)
1259 : (baudrate * 21 < actual_baudrate * 20)))
1260 ftdi_error_return (-1,
"Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4");
1307 unsigned short value = bits;
1309 if (ftdi == NULL || ftdi->
usb_dev == NULL)
1315 value |= (0x00 << 8);
1318 value |= (0x01 << 8);
1321 value |= (0x02 << 8);
1324 value |= (0x03 << 8);
1327 value |= (0x04 << 8);
1334 value |= (0x00 << 11);
1337 value |= (0x01 << 11);
1340 value |= (0x02 << 11);
1347 value |= (0x00 << 14);
1350 value |= (0x01 << 14);
1378 if (ftdi == NULL || ftdi->
usb_dev == NULL)
1381 while (offset < size)
1385 if (offset+write_size > size)
1386 write_size = size-offset;
1391 offset += actual_length;
1397 static void LIBUSB_CALL ftdi_read_data_cb(
struct libusb_transfer *transfer)
1401 int packet_size, actual_length, num_of_chunks, chunk_remains, i, ret;
1405 actual_length = transfer->actual_length;
1407 if (actual_length > 2)
1411 num_of_chunks = actual_length / packet_size;
1412 chunk_remains = actual_length % packet_size;
1418 if (actual_length > packet_size - 2)
1420 for (i = 1; i < num_of_chunks; i++)
1424 if (chunk_remains > 2)
1429 actual_length -= 2*num_of_chunks;
1432 actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1435 if (actual_length > 0)
1442 tc->
offset += actual_length;
1473 ret = libusb_submit_transfer (transfer);
1479 static void LIBUSB_CALL ftdi_write_data_cb(
struct libusb_transfer *transfer)
1484 tc->
offset += transfer->actual_length;
1498 transfer->length = write_size;
1499 transfer->buffer = tc->
buf + tc->
offset;
1500 ret = libusb_submit_transfer (transfer);
1524 struct libusb_transfer *transfer;
1525 int write_size, ret;
1527 if (ftdi == NULL || ftdi->
usb_dev == NULL)
1534 transfer = libusb_alloc_transfer(0);
1552 libusb_fill_bulk_transfer(transfer, ftdi->
usb_dev, ftdi->
in_ep, buf,
1553 write_size, ftdi_write_data_cb, tc,
1555 transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1557 ret = libusb_submit_transfer(transfer);
1560 libusb_free_transfer(transfer);
1586 struct libusb_transfer *transfer;
1589 if (ftdi == NULL || ftdi->
usb_dev == NULL)
1626 transfer = libusb_alloc_transfer(0);
1637 transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1639 ret = libusb_submit_transfer(transfer);
1642 libusb_free_transfer(transfer);
1671 if (ret == LIBUSB_ERROR_INTERRUPTED)
1673 libusb_cancel_transfer(tc->
transfer);
1677 libusb_free_transfer(tc->
transfer);
1690 if (tc->
transfer->status != LIBUSB_TRANSFER_COMPLETED)
1692 libusb_free_transfer(tc->
transfer);
1752 int offset = 0, ret, i, num_of_chunks, chunk_remains;
1754 int actual_length = 1;
1756 if (ftdi == NULL || ftdi->
usb_dev == NULL)
1760 if (packet_size == 0)
1785 while (offset < size && actual_length > 0)
1794 if (actual_length > 2)
1798 num_of_chunks = actual_length / packet_size;
1799 chunk_remains = actual_length % packet_size;
1805 if (actual_length > packet_size - 2)
1807 for (i = 1; i < num_of_chunks; i++)
1811 if (chunk_remains > 2)
1816 actual_length -= 2*num_of_chunks;
1819 actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1822 else if (actual_length <= 2)
1827 if (actual_length > 0)
1830 if (offset+actual_length <= size)
1834 offset += actual_length;
1845 int part_size = size-
offset;
1850 offset += part_size;
1877 unsigned char *new_buf;
1890 if (chunksize > 16384)
1894 if ((new_buf = (
unsigned char *)realloc(ftdi->
readbuffer, chunksize)) == NULL)
1935 unsigned short usb_val;
1937 if (ftdi == NULL || ftdi->
usb_dev == NULL)
1941 usb_val |= (mode << 8);
1943 ftdi_error_return(-1,
"unable to configure bitbang mode. Perhaps not a BM/2232C type chip?");
1961 if (ftdi == NULL || ftdi->
usb_dev == NULL)
1965 ftdi_error_return(-1,
"unable to leave bitbang mode. Perhaps not a BM type chip?");
1984 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2010 unsigned short usb_val;
2015 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2037 unsigned short usb_val;
2039 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2045 *latency = (
unsigned char)usb_val;
2093 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2099 *status = (usb_val[1] << 8) | (usb_val[0] & 0xFF);
2117 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2140 unsigned short usb_val;
2142 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2170 unsigned short usb_val;
2172 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2201 unsigned short usb_val;
2203 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2236 unsigned char eventch,
unsigned char enable)
2238 unsigned short usb_val;
2240 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2265 unsigned char errorch,
unsigned char enable)
2267 unsigned short usb_val;
2269 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2295 char * product,
char * serial)
2302 if (ftdi->
eeprom == NULL)
2346 eeprom->
product = malloc(strlen(product)+1);
2348 strcpy(eeprom->
product, product);
2352 const char* default_product;
2355 case TYPE_AM: default_product =
"AM";
break;
2356 case TYPE_BM: default_product =
"BM";
break;
2357 case TYPE_2232C: default_product =
"Dual RS232";
break;
2358 case TYPE_R: default_product =
"FT232R USB UART";
break;
2359 case TYPE_2232H: default_product =
"Dual RS232-HS";
break;
2360 case TYPE_4232H: default_product =
"FT4232H";
break;
2361 case TYPE_232H: default_product =
"Single-RS232-HS";
break;
2362 case TYPE_230X: default_product =
"FT230X Basic UART";
break;
2366 eeprom->
product = malloc(strlen(default_product) +1);
2368 strcpy(eeprom->
product, default_product);
2376 eeprom->
serial = malloc(strlen(serial)+1);
2378 strcpy(eeprom->
serial, serial);
2384 eeprom->
size = 0x80;
2394 eeprom->
size = 0x100;
2405 for (i=0; i<10; i++)
2450 if (ftdi->
eeprom == NULL)
2471 eeprom->
product = malloc(strlen(product)+1);
2473 strcpy(eeprom->
product, product);
2480 eeprom->
serial = malloc(strlen(serial)+1);
2483 strcpy(eeprom->
serial, serial);
2497 int mode_low, mode_high;
2507 output[0x18+i] = (mode_high <<4) | mode_low;
2563 unsigned char i, j, eeprom_size_mask;
2564 unsigned short checksum, value;
2565 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2568 unsigned char * output;
2572 if (ftdi->
eeprom == NULL)
2576 output = eeprom->
buf;
2578 if (eeprom->
chip == -1)
2581 if (eeprom->
size == -1)
2583 if ((eeprom->
chip == 0x56) || (eeprom->
chip == 0x66))
2584 eeprom->
size = 0x100;
2586 eeprom->
size = 0x80;
2592 product_size = strlen(eeprom->
product);
2593 if (eeprom->
serial != NULL)
2594 serial_size = strlen(eeprom->
serial);
2601 user_area_size = 96;
2604 user_area_size = 90;
2608 user_area_size = 88;
2612 user_area_size = 86;
2615 user_area_size = 80;
2621 user_area_size -= (manufacturer_size + product_size + serial_size) * 2;
2623 if (user_area_size < 0)
2712 eeprom_size_mask = eeprom->
size -1;
2718 output[i & eeprom_size_mask] = manufacturer_size*2 + 2, i++;
2719 output[i & eeprom_size_mask] = 0x03, i++;
2720 for (j = 0; j < manufacturer_size; j++)
2722 output[i & eeprom_size_mask] = eeprom->
manufacturer[j], i++;
2723 output[i & eeprom_size_mask] = 0x00, i++;
2725 output[0x0F] = manufacturer_size*2 + 2;
2729 output[0x10] = i | 0x80;
2730 output[i & eeprom_size_mask] = product_size*2 + 2, i++;
2731 output[i & eeprom_size_mask] = 0x03, i++;
2732 for (j = 0; j < product_size; j++)
2734 output[i & eeprom_size_mask] = eeprom->
product[j], i++;
2735 output[i & eeprom_size_mask] = 0x00, i++;
2737 output[0x11] = product_size*2 + 2;
2741 output[0x12] = i | 0x80;
2742 output[i & eeprom_size_mask] = serial_size*2 + 2, i++;
2743 output[i & eeprom_size_mask] = 0x03, i++;
2744 for (j = 0; j < serial_size; j++)
2746 output[i & eeprom_size_mask] = eeprom->
serial[j], i++;
2747 output[i & eeprom_size_mask] = 0x00, i++;
2753 output[i & eeprom_size_mask] = 0x02;
2755 output[i & eeprom_size_mask] = 0x03;
2757 output[i & eeprom_size_mask] = eeprom->
is_not_pnp;
2761 output[0x13] = serial_size*2 + 2;
2811 output[0x0A] |= 0x1;
2813 output[0x0A] &= ~0x1;
2815 output[0x0A] |= 0x2;
2817 output[0x0A] &= ~0x2;
2819 output[0x0A] |= 0x4;
2821 output[0x0A] &= ~0x4;
2829 output[0x14] = eeprom->
chip;
2834 output[0x01] = 0x40;
2837 output[0x0A] |= 0x4;
2839 output[0x0A] &= ~0x4;
2840 output[0x0B] = eeprom->
invert;
2887 output[0x0A] |= 0x4;
2889 output[0x0A] &= ~0x4;
2927 output[0x18] = eeprom->
chip;
2949 output[0x0a] |= 0x4;
2951 output[0x0a] &= ~0x4;
3006 output[0x18] = eeprom->
chip;
3021 output[0x0a] |= 0x4;
3023 output[0x0a] &= ~0x4;
3057 output[0x1e] = eeprom->
chip;
3058 fprintf(stderr,
"FIXME: Build FT232H specific EEPROM settings\n");
3061 output[0x00] = 0x80;
3062 output[0x0a] = 0x08;
3065 for (j = 0; j <= 6; j++)
3069 output[0x0b] = eeprom->
invert;
3076 for (i = 0; i < eeprom->
size/2-1; i++)
3083 if ((ftdi->
type ==
TYPE_230X) && (i >= 0x40) && (i < 0x50)) {
3086 fprintf(stderr,
"Reading Factory Configuration Data failed\n");
3092 value = output[i*2];
3093 value += output[(i*2)+1] << 8;
3095 checksum = value^checksum;
3096 checksum = (checksum << 1) | (checksum >> 15);
3099 output[eeprom->
size-2] = checksum;
3100 output[eeprom->
size-1] = checksum >> 8;
3103 return user_area_size;
3110 static unsigned char bit2type(
unsigned char bits)
3120 fprintf(stderr,
" Unexpected value %d for Hardware Interface type\n",
3128 static void print_inverted_bits(
int invert)
3130 char *r_bits[] = {
"TXD",
"RXD",
"RTS",
"CTS",
"DTR",
"DSR",
"DCD",
"RI"};
3133 fprintf(stdout,
"Inverted bits:");
3135 if ((invert & (1<<i)) == (1<<i))
3136 fprintf(stdout,
" %s",r_bits[i]);
3138 fprintf(stdout,
"\n");
3157 unsigned short checksum, eeprom_checksum, value;
3158 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
3161 unsigned char *
buf = NULL;
3165 if (ftdi->
eeprom == NULL)
3169 eeprom_size = eeprom->
size;
3173 eeprom->
vendor_id = buf[0x02] + (buf[0x03] << 8);
3176 eeprom->
product_id = buf[0x04] + (buf[0x05] << 8);
3209 eeprom->
usb_version = buf[0x0C] + (buf[0x0D] << 8);
3213 manufacturer_size = buf[0x0F]/2;
3216 if (manufacturer_size > 0)
3222 i = buf[0x0E] & (eeprom_size -1);
3223 for (j=0; j<manufacturer_size-1; j++)
3236 product_size = buf[0x11]/2;
3237 if (product_size > 0)
3239 eeprom->
product = malloc(product_size);
3243 i = buf[0x10] & (eeprom_size -1);
3244 for (j=0; j<product_size-1; j++)
3246 eeprom->
product[j] = buf[2*j+i+2];
3257 serial_size = buf[0x13]/2;
3258 if (serial_size > 0)
3260 eeprom->
serial = malloc(serial_size);
3264 i = buf[0x12] & (eeprom_size -1);
3265 for (j=0; j<serial_size-1; j++)
3267 eeprom->
serial[j] = buf[2*j+i+2];
3269 eeprom->
serial[j] =
'\0';
3272 else eeprom->
serial = NULL;
3277 for (i = 0; i < eeprom_size/2-1; i++)
3285 value += buf[(i*2)+1] << 8;
3287 checksum = value^checksum;
3288 checksum = (checksum << 1) | (checksum >> 15);
3291 eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
3293 if (eeprom_checksum != checksum)
3295 fprintf(stderr,
"Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
3312 eeprom->
chip = buf[0x14];
3319 if ( (buf[0x01]&0x40) != 0x40)
3321 "TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size."
3322 " If this happened with the\n"
3323 " EEPROM programmed by FTDI tools, please report "
3324 "to libftdi@developer.intra2net.com\n");
3326 eeprom->
chip = buf[0x16];
3329 eeprom->
invert = buf[0x0B];
3360 eeprom->
chip = buf[0x18];
3366 eeprom->
group1_slew = (buf[0x0c] >> 4) & SLOW_SLEW;
3372 eeprom->
group3_slew = (buf[0x0d] >> 4) & SLOW_SLEW;
3394 eeprom->
chip = buf[0x1e];
3408 eeprom->
group1_slew = (buf[0x0c] >> 4) & SLOW_SLEW;
3410 eeprom->
invert = buf[0xb];
3415 char *channel_mode[] = {
"UART",
"FIFO",
"CPU",
"OPTO",
"FT1284"};
3416 fprintf(stdout,
"VID: 0x%04x\n",eeprom->
vendor_id);
3417 fprintf(stdout,
"PID: 0x%04x\n",eeprom->
product_id);
3421 fprintf(stdout,
"Self-Powered%s", (eeprom->
remote_wakeup)?
", USB Remote Wake Up\n":
"\n");
3423 fprintf(stdout,
"Bus Powered: %3d mA%s", eeprom->
max_power,
3426 fprintf(stdout,
"Manufacturer: %s\n",eeprom->
manufacturer);
3428 fprintf(stdout,
"Product: %s\n",eeprom->
product);
3430 fprintf(stdout,
"Serial: %s\n",eeprom->
serial);
3431 fprintf(stdout,
"Checksum : %04x\n", checksum);
3433 fprintf(stdout,
"Internal EEPROM\n");
3434 else if (eeprom->
chip >= 0x46)
3435 fprintf(stdout,
"Attached EEPROM: 93x%02x\n", eeprom->
chip);
3437 fprintf(stdout,
"Suspend on DBUS7\n");
3439 fprintf(stdout,
"Pull IO pins low during suspend\n");
3443 fprintf(stdout,
"Enter low power state on ACBUS7\n");
3446 fprintf(stdout,
"Enable Remote Wake Up\n");
3447 fprintf(stdout,
"PNP: %d\n",(eeprom->
is_not_pnp)?0:1);
3449 fprintf(stdout,
"Channel A has Mode %s%s%s\n",
3455 fprintf(stdout,
"FT1284 Mode Clock is idle %s, %s first, %sFlow Control\n",
3461 fprintf(stdout,
"Channel B has Mode %s%s%s\n",
3467 fprintf(stdout,
"Use explicit USB Version %04x\n",eeprom->
usb_version);
3471 fprintf(stdout,
"%s has %d mA drive%s%s\n",
3476 fprintf(stdout,
"%s has %d mA drive%s%s\n",
3481 fprintf(stdout,
"%s has %d mA drive%s%s\n",
3486 fprintf(stdout,
"%s has %d mA drive%s%s\n",
3494 char *cbush_mux[] = {
"TRISTATE",
"RXLED",
"TXLED",
"TXRXLED",
"PWREN",
3495 "SLEEP",
"DRIVE_0",
"DRIVE_1",
"IOMODE",
"TXDEN",
3496 "CLK30",
"CLK15",
"CLK7_5"
3498 fprintf(stdout,
"ACBUS has %d mA drive%s%s\n",
3502 fprintf(stdout,
"ADBUS has %d mA drive%s%s\n",
3506 for (i=0; i<10; i++)
3509 fprintf(stdout,
"C%d Function: %s\n", i,
3515 char *cbush_mux[] = {
"TRISTATE",
"RXLED",
"TXLED",
"TXRXLED",
"PWREN",
3516 "SLEEP",
"DRIVE_0",
"DRIVE_1",
"IOMODE",
"TXDEN",
3517 "CLK24",
"CLK12",
"CLK6",
"BAT_DETECT",
"BAT_DETECT#",
3518 "I2C_TXE#",
"I2C_RXF#",
"VBUS_SENSE",
"BB_WR#",
3519 "BBRD#",
"TIME_STAMP",
"AWAKE#",
3521 fprintf(stdout,
"DBUS has %d mA drive%s%s\n",
3525 fprintf(stdout,
"CBUS has %d mA drive%s%s\n",
3532 fprintf(stdout,
"CBUS%d Function: %s\n", i, cbush_mux[eeprom->
cbus_function[i]]);
3536 print_inverted_bits(eeprom->
invert);
3541 char *cbus_mux[] = {
"TXDEN",
"PWREN",
"RXLED",
"TXLED",
"TX+RXLED",
3542 "SLEEP",
"CLK48",
"CLK24",
"CLK12",
"CLK6",
3543 "IOMODE",
"BB_WR",
"BB_RD"
3545 char *cbus_BB[] = {
"RXF",
"TXE",
"RD",
"WR"};
3548 print_inverted_bits(eeprom->
invert);
3553 fprintf(stdout,
"C%d Function: %s\n", i,
3560 fprintf(stdout,
"C%d BB Function: %s\n", i,
3563 fprintf(stdout,
"Unknown CBUS mode. Might be special mode?\n");
3963 if (!ftdi || !(ftdi->
eeprom))
3966 if (!buf || size < ftdi->eeprom->size)
3989 if (!ftdi || !(ftdi->
eeprom) || !buf)
4014 if (ftdi == NULL || ftdi->
usb_dev == NULL)
4037 if (ftdi == NULL || ftdi->
usb_dev == NULL)
4043 if (libusb_control_transfer(
4055 else if (memcmp(buf,&buf[0x80],0x80) == 0)
4057 else if (memcmp(buf,&buf[0x40],0x40) == 0)
4069 static unsigned char ftdi_read_chipid_shift(
unsigned char value)
4071 return ((value & 1) << 1) |
4072 ((value & 2) << 5) |
4073 ((value & 4) >> 2) |
4074 ((value & 8) << 4) |
4075 ((value & 16) >> 1) |
4076 ((value & 32) >> 1) |
4077 ((value & 64) >> 4) |
4078 ((value & 128) >> 2);
4093 unsigned int a = 0, b = 0;
4095 if (ftdi == NULL || ftdi->
usb_dev == NULL)
4100 a = a << 8 | a >> 8;
4103 b = b << 8 | b >> 8;
4104 a = (a << 16) | (b & 0xFFFF);
4105 a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
4106 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
4107 *chipid = a ^ 0xa5f0f7d1;
4130 unsigned short eeprom_val)
4132 int chip_type_location;
4133 unsigned short chip_type;
4135 if (ftdi == NULL || ftdi->
usb_dev == NULL)
4138 if (eeprom_addr <0x80)
4146 chip_type_location = 0x14;
4150 chip_type_location = 0x18;
4153 chip_type_location = 0x1e;
4161 fprintf(stderr,
" loc 0x%04x val 0x%04x\n", chip_type_location,chip_type);
4162 if ((chip_type & 0xff) != 0x66)
4187 unsigned short usb_val, status;
4189 unsigned char *eeprom;
4191 if (ftdi == NULL || ftdi->
usb_dev == NULL)
4214 usb_val = eeprom[i*2];
4215 usb_val += eeprom[(i*2)+1] << 8;
4239 #define MAGIC 0x55aa
4242 unsigned short eeprom_value;
4243 if (ftdi == NULL || ftdi->
usb_dev == NULL)
4267 if (eeprom_value ==
MAGIC)
4275 if (eeprom_value ==
MAGIC)
4281 if (eeprom_value ==
MAGIC)
int convert_baudrate_UT_export(int baudrate, struct ftdi_context *ftdi, unsigned short *value, unsigned short *index)
Wrapper function to export ftdi_convert_baudrate() to the unit test Do not use, it's only for the uni...
#define CHANNEL_IS_FT1284
struct ftdi_transfer_control * ftdi_write_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
#define FTDI_DEVICE_OUT_REQTYPE
enum ftdi_module_detach_mode module_detach_mode
#define SIO_SET_LATENCY_TIMER_REQUEST
#define FT1284_CLK_IDLE_STATE
list of usb devices created by ftdi_usb_find_all()
struct ftdi_device_list * next
int ftdi_eeprom_set_strings(struct ftdi_context *ftdi, char *manufacturer, char *product, char *serial)
int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
void ftdi_list_free2(struct ftdi_device_list *devlist)
int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
#define SIO_SET_EVENT_CHAR_REQUEST
int ftdi_read_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
void ftdi_deinit(struct ftdi_context *ftdi)
#define HIGH_CURRENT_DRIVE
void ftdi_set_usbdev(struct ftdi_context *ftdi, libusb_device_handle *usb)
#define SIO_READ_PINS_REQUEST
#define SIO_RESET_REQUEST
int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product, const char *description, const char *serial, unsigned int index)
#define SUSPEND_DBUS7_BIT
void set_ft232h_cbus(struct ftdi_eeprom *eeprom, unsigned char *output)
#define SIO_SET_BAUDRATE_REQUEST
struct libusb_transfer * transfer
int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
#define SIO_SET_DATA_REQUEST
int ftdi_write_data(struct ftdi_context *ftdi, const unsigned char *buf, int size)
#define SIO_WRITE_EEPROM_REQUEST
Main context structure for all libftdi functions.
int ftdi_set_event_char(struct ftdi_context *ftdi, unsigned char eventch, unsigned char enable)
#define MAX_POWER_MILLIAMP_PER_UNIT
int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
void ftdi_list_free(struct ftdi_device_list **devlist)
#define FTDI_DEVICE_IN_REQTYPE
int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
int channel_b_rs485enable
int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
struct ftdi_context * ftdi_new(void)
int ftdi_erase_eeprom(struct ftdi_context *ftdi)
int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char *manufacturer, char *product, char *serial)
int ftdi_transfer_data_done(struct ftdi_transfer_control *tc)
unsigned int readbuffer_remaining
int ftdi_set_error_char(struct ftdi_context *ftdi, unsigned char errorch, unsigned char enable)
int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose)
struct libusb_device * dev
int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int *value)
#define SIO_GET_LATENCY_TIMER_REQUEST
int initialized_for_connected_device
#define FT1284_FLOW_CONTROL
int channel_c_rs485enable
int ftdi_init(struct ftdi_context *ftdi)
unsigned char * readbuffer
#define USE_USB_VERSION_BIT
struct ftdi_transfer_control * ftdi_read_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
struct libusb_context * usb_ctx
unsigned char buf[FTDI_MAX_EEPROM_SIZE]
unsigned int writebuffer_chunksize
#define SIO_READ_EEPROM_REQUEST
int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
#define FTDI_MAX_EEPROM_SIZE
int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
#define HIGH_CURRENT_DRIVE_R
#define SIO_SET_FLOW_CTRL_REQUEST
#define SIO_SET_BITMODE_REQUEST
int ftdi_set_eeprom_buf(struct ftdi_context *ftdi, const unsigned char *buf, int size)
#define SIO_SET_ERROR_CHAR_REQUEST
int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
unsigned char bitbang_mode
int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev)
struct ftdi_context * ftdi
int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int value)
const char * snapshot_str
#define POWER_SAVE_DISABLE_H
#define SIO_SET_MODEM_CTRL_REQUEST
#define SIO_POLL_MODEM_STATUS_REQUEST
int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product, const char *description, const char *serial)
struct libusb_device_handle * usb_dev
int ftdi_usb_close(struct ftdi_context *ftdi)
int channel_d_rs485enable
unsigned int max_packet_size
int ftdi_setrts(struct ftdi_context *ftdi, int state)
int ftdi_usb_reset(struct ftdi_context *ftdi)
int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
int ftdi_usb_get_strings(struct ftdi_context *ftdi, struct libusb_device *dev, char *manufacturer, int mnf_len, char *description, int desc_len, char *serial, int serial_len)
struct ftdi_version_info ftdi_get_library_version(void)
Get libftdi library version.
int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
#define SIO_RESET_PURGE_RX
int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
unsigned char bitbang_enabled
int channel_a_rs485enable
int ftdi_write_eeprom(struct ftdi_context *ftdi)
int ftdi_usb_open_string(struct ftdi_context *ftdi, const char *description)
int ftdi_disable_bitbang(struct ftdi_context *ftdi)
int ftdi_setdtr(struct ftdi_context *ftdi, int state)
int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
#define SIO_RESET_PURGE_TX
unsigned int readbuffer_chunksize
int ftdi_read_eeprom(struct ftdi_context *ftdi)
char * ftdi_get_error_string(struct ftdi_context *ftdi)
#define SIO_ERASE_EEPROM_REQUEST
int ftdi_eeprom_build(struct ftdi_context *ftdi)
int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short eeprom_val)
#define ftdi_error_return_free_device_list(code, str, devs)
int ftdi_get_eeprom_buf(struct ftdi_context *ftdi, unsigned char *buf, int size)
#define ftdi_error_return(code, str)
unsigned int readbuffer_offset
void ftdi_free(struct ftdi_context *ftdi)
int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity, enum ftdi_break_type break_type)
struct ftdi_eeprom * eeprom