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 != 0 && product != 0) &&
332 desc.idVendor == vendor && desc.idProduct == product) ||
333 ((vendor == 0 && product == 0) &&
334 (desc.idVendor == 0x403) && (desc.idProduct == 0x6001 || desc.idProduct == 0x6010
335 || desc.idProduct == 0x6011 || desc.idProduct == 0x6014)))
341 (*curdev)->next = NULL;
342 (*curdev)->dev =
dev;
343 libusb_ref_device(dev);
344 curdev = &(*curdev)->
next;
348 libusb_free_device_list(devs,1);
361 for (curdev = *devlist; curdev != NULL;)
364 libusb_unref_device(curdev->
dev);
409 char * manufacturer,
int mnf_len,
char * description,
int desc_len,
char * serial,
int serial_len)
411 struct libusb_device_descriptor desc;
413 if ((ftdi==NULL) || (dev==NULL))
416 if (libusb_open(dev, &ftdi->
usb_dev) < 0)
419 if (libusb_get_device_descriptor(dev, &desc) < 0)
422 if (manufacturer != NULL)
424 if (libusb_get_string_descriptor_ascii(ftdi->
usb_dev, desc.iManufacturer, (
unsigned char *)manufacturer, mnf_len) < 0)
426 ftdi_usb_close_internal (ftdi);
431 if (description != NULL)
433 if (libusb_get_string_descriptor_ascii(ftdi->
usb_dev, desc.iProduct, (
unsigned char *)description, desc_len) < 0)
435 ftdi_usb_close_internal (ftdi);
442 if (libusb_get_string_descriptor_ascii(ftdi->
usb_dev, desc.iSerialNumber, (
unsigned char *)serial, serial_len) < 0)
444 ftdi_usb_close_internal (ftdi);
449 ftdi_usb_close_internal (ftdi);
460 static unsigned int _ftdi_determine_max_packet_size(
struct ftdi_context *ftdi, libusb_device *dev)
462 struct libusb_device_descriptor desc;
463 struct libusb_config_descriptor *config0;
464 unsigned int packet_size;
467 if (ftdi == NULL || dev == NULL)
478 if (libusb_get_device_descriptor(dev, &desc) < 0)
481 if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
484 if (desc.bNumConfigurations > 0)
486 if (ftdi->
interface < config0->bNumInterfaces)
488 struct libusb_interface interface = config0->interface[ftdi->
interface];
489 if (interface.num_altsetting > 0)
491 struct libusb_interface_descriptor descriptor = interface.altsetting[0];
492 if (descriptor.bNumEndpoints > 0)
494 packet_size = descriptor.endpoint[0].wMaxPacketSize;
500 libusb_free_config_descriptor (config0);
524 struct libusb_device_descriptor desc;
525 struct libusb_config_descriptor *config0;
526 int cfg, cfg0, detach_errno = 0;
531 if (libusb_open(dev, &ftdi->
usb_dev) < 0)
534 if (libusb_get_device_descriptor(dev, &desc) < 0)
537 if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
539 cfg0 = config0->bConfigurationValue;
540 libusb_free_config_descriptor (config0);
551 detach_errno = errno;
554 if (libusb_get_configuration (ftdi->
usb_dev, &cfg) < 0)
559 if (desc.bNumConfigurations > 0 && cfg != cfg0)
561 if (libusb_set_configuration(ftdi->
usb_dev, cfg0) < 0)
563 ftdi_usb_close_internal (ftdi);
564 if (detach_errno == EPERM)
570 ftdi_error_return(-3,
"unable to set usb configuration. Make sure the default FTDI driver is not in use");
577 ftdi_usb_close_internal (ftdi);
578 if (detach_errno == EPERM)
584 ftdi_error_return(-5,
"unable to claim usb device. Make sure the default FTDI driver is not in use");
590 ftdi_usb_close_internal (ftdi);
596 if (desc.bcdDevice == 0x400 || (desc.bcdDevice == 0x200
597 && desc.iSerialNumber == 0))
599 else if (desc.bcdDevice == 0x200)
601 else if (desc.bcdDevice == 0x500)
603 else if (desc.bcdDevice == 0x600)
605 else if (desc.bcdDevice == 0x700)
607 else if (desc.bcdDevice == 0x800)
609 else if (desc.bcdDevice == 0x900)
611 else if (desc.bcdDevice == 0x1000)
619 ftdi_usb_close_internal (ftdi);
662 const char* description,
const char* serial)
692 const char* description,
const char* serial,
unsigned int index)
695 libusb_device **devs;
702 if (libusb_get_device_list(ftdi->
usb_ctx, &devs) < 0)
705 while ((dev = devs[i++]) != NULL)
707 struct libusb_device_descriptor desc;
710 if (libusb_get_device_descriptor(dev, &desc) < 0)
713 if (desc.idVendor == vendor && desc.idProduct == product)
715 if (libusb_open(dev, &ftdi->
usb_dev) < 0)
718 if (description != NULL)
720 if (libusb_get_string_descriptor_ascii(ftdi->
usb_dev, desc.iProduct, (
unsigned char *)
string,
sizeof(
string)) < 0)
722 ftdi_usb_close_internal (ftdi);
725 if (strncmp(
string, description,
sizeof(
string)) != 0)
727 ftdi_usb_close_internal (ftdi);
733 if (libusb_get_string_descriptor_ascii(ftdi->
usb_dev, desc.iSerialNumber, (
unsigned char *)
string,
sizeof(
string)) < 0)
735 ftdi_usb_close_internal (ftdi);
738 if (strncmp(
string, serial,
sizeof(
string)) != 0)
740 ftdi_usb_close_internal (ftdi);
745 ftdi_usb_close_internal (ftdi);
754 libusb_free_device_list(devs,1);
794 if (description[0] == 0 || description[1] !=
':')
797 if (description[0] ==
'd')
800 libusb_device **devs;
801 unsigned int bus_number, device_address;
804 if (libusb_get_device_list(ftdi->
usb_ctx, &devs) < 0)
808 if (sscanf (description + 2,
"%u/%u", &bus_number, &device_address) != 2)
811 while ((dev = devs[i++]) != NULL)
814 if (bus_number == libusb_get_bus_number (dev)
815 && device_address == libusb_get_device_address (dev))
818 libusb_free_device_list(devs,1);
826 else if (description[0] ==
'i' || description[0] ==
's')
829 unsigned int product;
830 unsigned int index=0;
831 const char *serial=NULL;
832 const char *startp, *endp;
835 startp=description+2;
836 vendor=strtoul((
char*)startp,(
char**)&endp,0);
837 if (*endp !=
':' || endp == startp || errno != 0)
841 product=strtoul((
char*)startp,(
char**)&endp,0);
842 if (endp == startp || errno != 0)
845 if (description[0] ==
'i' && *endp != 0)
852 index=strtoul((
char*)startp,(
char**)&endp,0);
853 if (*endp != 0 || endp == startp || errno != 0)
856 if (description[0] ==
's')
884 if (ftdi == NULL || ftdi->
usb_dev == NULL)
910 if (ftdi == NULL || ftdi->
usb_dev == NULL)
936 if (ftdi == NULL || ftdi->
usb_dev == NULL)
961 if (ftdi == NULL || ftdi->
usb_dev == NULL)
997 ftdi_usb_close_internal (ftdi);
1014 static int ftdi_to_clkbits_AM(
int baudrate,
unsigned long *encoded_divisor)
1017 static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
1018 static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
1019 static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
1020 int divisor, best_divisor, best_baud, best_baud_diff;
1021 divisor = 24000000 / baudrate;
1025 divisor -= am_adjust_dn[divisor & 7];
1031 for (i = 0; i < 2; i++)
1033 int try_divisor = divisor + i;
1038 if (try_divisor <= 8)
1043 else if (divisor < 16)
1051 try_divisor += am_adjust_up[try_divisor & 7];
1052 if (try_divisor > 0x1FFF8)
1055 try_divisor = 0x1FFF8;
1059 baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
1061 if (baud_estimate < baudrate)
1063 baud_diff = baudrate - baud_estimate;
1067 baud_diff = baud_estimate - baudrate;
1069 if (i == 0 || baud_diff < best_baud_diff)
1072 best_divisor = try_divisor;
1073 best_baud = baud_estimate;
1074 best_baud_diff = baud_diff;
1083 *encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
1085 if (*encoded_divisor == 1)
1087 *encoded_divisor = 0;
1089 else if (*encoded_divisor == 0x4001)
1091 *encoded_divisor = 1;
1120 static int ftdi_to_clkbits(
int baudrate,
unsigned int clk,
int clk_div,
unsigned long *encoded_divisor)
1122 static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
1124 int divisor, best_divisor;
1125 if (baudrate >= clk/clk_div)
1127 *encoded_divisor = 0;
1128 best_baud = clk/clk_div;
1130 else if (baudrate >= clk/(clk_div + clk_div/2))
1132 *encoded_divisor = 1;
1133 best_baud = clk/(clk_div + clk_div/2);
1135 else if (baudrate >= clk/(2*clk_div))
1137 *encoded_divisor = 2;
1138 best_baud = clk/(2*clk_div);
1143 divisor = clk*16/clk_div / baudrate;
1145 best_divisor = divisor /2 +1;
1147 best_divisor = divisor/2;
1148 if(best_divisor > 0x20000)
1149 best_divisor = 0x1ffff;
1150 best_baud = clk*16/clk_div/best_divisor;
1152 best_baud = best_baud /2 +1;
1154 best_baud = best_baud /2;
1155 *encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 0x7] << 14);
1164 static int ftdi_convert_baudrate(
int baudrate,
struct ftdi_context *ftdi,
1165 unsigned short *value,
unsigned short *index)
1168 unsigned long encoded_divisor;
1176 #define H_CLK 120000000 1177 #define C_CLK 48000000 1180 if(baudrate*10 >
H_CLK /0x3fff)
1187 best_baud = ftdi_to_clkbits(baudrate,
H_CLK, 10, &encoded_divisor);
1188 encoded_divisor |= 0x20000;
1191 best_baud = ftdi_to_clkbits(baudrate,
C_CLK, 16, &encoded_divisor);
1195 best_baud = ftdi_to_clkbits(baudrate,
C_CLK, 16, &encoded_divisor);
1199 best_baud = ftdi_to_clkbits_AM(baudrate, &encoded_divisor);
1202 *value = (
unsigned short)(encoded_divisor & 0xFFFF);
1205 *index = (
unsigned short)(encoded_divisor >> 8);
1207 *index |= ftdi->
index;
1210 *index = (
unsigned short)(encoded_divisor >> 16);
1221 unsigned short *value,
unsigned short *index)
1223 return ftdi_convert_baudrate(baudrate, ftdi, value, index);
1239 unsigned short value, index;
1240 int actual_baudrate;
1242 if (ftdi == NULL || ftdi->
usb_dev == NULL)
1247 baudrate = baudrate*4;
1250 actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
1251 if (actual_baudrate <= 0)
1255 if ((actual_baudrate * 2 < baudrate )
1256 || ((actual_baudrate < baudrate)
1257 ? (actual_baudrate * 21 < baudrate * 20)
1258 : (baudrate * 21 < actual_baudrate * 20)))
1259 ftdi_error_return (-1,
"Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4");
1306 unsigned short value = bits;
1308 if (ftdi == NULL || ftdi->
usb_dev == NULL)
1314 value |= (0x00 << 8);
1317 value |= (0x01 << 8);
1320 value |= (0x02 << 8);
1323 value |= (0x03 << 8);
1326 value |= (0x04 << 8);
1333 value |= (0x00 << 11);
1336 value |= (0x01 << 11);
1339 value |= (0x02 << 11);
1346 value |= (0x00 << 14);
1349 value |= (0x01 << 14);
1377 if (ftdi == NULL || ftdi->
usb_dev == NULL)
1380 while (offset < size)
1384 if (offset+write_size > size)
1385 write_size = size-offset;
1390 offset += actual_length;
1396 static void ftdi_read_data_cb(
struct libusb_transfer *transfer)
1400 int packet_size, actual_length, num_of_chunks, chunk_remains, i, ret;
1404 actual_length = transfer->actual_length;
1406 if (actual_length > 2)
1410 num_of_chunks = actual_length / packet_size;
1411 chunk_remains = actual_length % packet_size;
1417 if (actual_length > packet_size - 2)
1419 for (i = 1; i < num_of_chunks; i++)
1423 if (chunk_remains > 2)
1428 actual_length -= 2*num_of_chunks;
1431 actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1434 if (actual_length > 0)
1441 tc->
offset += actual_length;
1472 ret = libusb_submit_transfer (transfer);
1478 static void ftdi_write_data_cb(
struct libusb_transfer *
transfer)
1483 tc->
offset += transfer->actual_length;
1497 transfer->length = write_size;
1498 transfer->buffer = tc->
buf + tc->
offset;
1499 ret = libusb_submit_transfer (transfer);
1523 struct libusb_transfer *transfer;
1524 int write_size, ret;
1526 if (ftdi == NULL || ftdi->
usb_dev == NULL)
1533 transfer = libusb_alloc_transfer(0);
1551 libusb_fill_bulk_transfer(transfer, ftdi->
usb_dev, ftdi->
in_ep, buf,
1552 write_size, ftdi_write_data_cb, tc,
1554 transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1556 ret = libusb_submit_transfer(transfer);
1559 libusb_free_transfer(transfer);
1585 struct libusb_transfer *transfer;
1588 if (ftdi == NULL || ftdi->
usb_dev == NULL)
1625 transfer = libusb_alloc_transfer(0);
1636 transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1638 ret = libusb_submit_transfer(transfer);
1641 libusb_free_transfer(transfer);
1670 if (ret == LIBUSB_ERROR_INTERRUPTED)
1672 libusb_cancel_transfer(tc->
transfer);
1676 libusb_free_transfer(tc->
transfer);
1689 if (tc->
transfer->status != LIBUSB_TRANSFER_COMPLETED)
1691 libusb_free_transfer(tc->
transfer);
1751 int offset = 0, ret, i, num_of_chunks, chunk_remains;
1753 int actual_length = 1;
1755 if (ftdi == NULL || ftdi->
usb_dev == NULL)
1759 if (packet_size == 0)
1784 while (offset < size && actual_length > 0)
1793 if (actual_length > 2)
1797 num_of_chunks = actual_length / packet_size;
1798 chunk_remains = actual_length % packet_size;
1804 if (actual_length > packet_size - 2)
1806 for (i = 1; i < num_of_chunks; i++)
1810 if (chunk_remains > 2)
1815 actual_length -= 2*num_of_chunks;
1818 actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1821 else if (actual_length <= 2)
1826 if (actual_length > 0)
1829 if (offset+actual_length <= size)
1833 offset += actual_length;
1844 int part_size = size-
offset;
1849 offset += part_size;
1876 unsigned char *new_buf;
1889 if (chunksize > 16384)
1893 if ((new_buf = (
unsigned char *)realloc(ftdi->
readbuffer, chunksize)) == NULL)
1934 unsigned short usb_val;
1936 if (ftdi == NULL || ftdi->
usb_dev == NULL)
1940 usb_val |= (mode << 8);
1942 ftdi_error_return(-1,
"unable to configure bitbang mode. Perhaps not a BM/2232C type chip?");
1960 if (ftdi == NULL || ftdi->
usb_dev == NULL)
1964 ftdi_error_return(-1,
"unable to leave bitbang mode. Perhaps not a BM type chip?");
1983 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2009 unsigned short usb_val;
2014 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2036 unsigned short usb_val;
2038 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2044 *latency = (
unsigned char)usb_val;
2092 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2098 *status = (usb_val[1] << 8) | (usb_val[0] & 0xFF);
2116 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2139 unsigned short usb_val;
2141 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2169 unsigned short usb_val;
2171 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2200 unsigned short usb_val;
2202 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2235 unsigned char eventch,
unsigned char enable)
2237 unsigned short usb_val;
2239 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2264 unsigned char errorch,
unsigned char enable)
2266 unsigned short usb_val;
2268 if (ftdi == NULL || ftdi->
usb_dev == NULL)
2294 char * product,
char * serial)
2301 if (ftdi->
eeprom == NULL)
2345 eeprom->
product = malloc(strlen(product)+1);
2347 strcpy(eeprom->
product, product);
2351 const char* default_product;
2354 case TYPE_AM: default_product =
"AM";
break;
2355 case TYPE_BM: default_product =
"BM";
break;
2356 case TYPE_2232C: default_product =
"Dual RS232";
break;
2357 case TYPE_R: default_product =
"FT232R USB UART";
break;
2358 case TYPE_2232H: default_product =
"Dual RS232-HS";
break;
2359 case TYPE_4232H: default_product =
"FT4232H";
break;
2360 case TYPE_232H: default_product =
"Single-RS232-HS";
break;
2361 case TYPE_230X: default_product =
"FT230X Basic UART";
break;
2365 eeprom->
product = malloc(strlen(default_product) +1);
2367 strcpy(eeprom->
product, default_product);
2375 eeprom->
serial = malloc(strlen(serial)+1);
2377 strcpy(eeprom->
serial, serial);
2383 eeprom->
size = 0x80;
2393 eeprom->
size = 0x100;
2404 for (i=0; i<10; i++)
2449 if (ftdi->
eeprom == NULL)
2470 eeprom->
product = malloc(strlen(product)+1);
2472 strcpy(eeprom->
product, product);
2479 eeprom->
serial = malloc(strlen(serial)+1);
2482 strcpy(eeprom->
serial, serial);
2496 int mode_low, mode_high;
2506 output[0x18+i] = (mode_high <<4) | mode_low;
2562 unsigned char i, j, eeprom_size_mask;
2563 unsigned short checksum, value;
2564 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2567 unsigned char * output;
2571 if (ftdi->
eeprom == NULL)
2575 output = eeprom->
buf;
2577 if (eeprom->
chip == -1)
2580 if (eeprom->
size == -1)
2582 if ((eeprom->
chip == 0x56) || (eeprom->
chip == 0x66))
2583 eeprom->
size = 0x100;
2585 eeprom->
size = 0x80;
2591 product_size = strlen(eeprom->
product);
2592 if (eeprom->
serial != NULL)
2593 serial_size = strlen(eeprom->
serial);
2600 user_area_size = 96;
2603 user_area_size = 90;
2607 user_area_size = 88;
2611 user_area_size = 86;
2614 user_area_size = 80;
2620 user_area_size -= (manufacturer_size + product_size + serial_size) * 2;
2622 if (user_area_size < 0)
2711 eeprom_size_mask = eeprom->
size -1;
2717 output[i & eeprom_size_mask] = manufacturer_size*2 + 2, i++;
2718 output[i & eeprom_size_mask] = 0x03, i++;
2719 for (j = 0; j < manufacturer_size; j++)
2721 output[i & eeprom_size_mask] = eeprom->
manufacturer[j], i++;
2722 output[i & eeprom_size_mask] = 0x00, i++;
2724 output[0x0F] = manufacturer_size*2 + 2;
2728 output[0x10] = i | 0x80;
2729 output[i & eeprom_size_mask] = product_size*2 + 2, i++;
2730 output[i & eeprom_size_mask] = 0x03, i++;
2731 for (j = 0; j < product_size; j++)
2733 output[i & eeprom_size_mask] = eeprom->
product[j], i++;
2734 output[i & eeprom_size_mask] = 0x00, i++;
2736 output[0x11] = product_size*2 + 2;
2740 output[0x12] = i | 0x80;
2741 output[i & eeprom_size_mask] = serial_size*2 + 2, i++;
2742 output[i & eeprom_size_mask] = 0x03, i++;
2743 for (j = 0; j < serial_size; j++)
2745 output[i & eeprom_size_mask] = eeprom->
serial[j], i++;
2746 output[i & eeprom_size_mask] = 0x00, i++;
2752 output[i & eeprom_size_mask] = 0x02;
2754 output[i & eeprom_size_mask] = 0x03;
2756 output[i & eeprom_size_mask] = eeprom->
is_not_pnp;
2760 output[0x13] = serial_size*2 + 2;
2810 output[0x0A] |= 0x1;
2812 output[0x0A] &= ~0x1;
2814 output[0x0A] |= 0x2;
2816 output[0x0A] &= ~0x2;
2818 output[0x0A] |= 0x4;
2820 output[0x0A] &= ~0x4;
2828 output[0x14] = eeprom->
chip;
2833 output[0x01] = 0x40;
2836 output[0x0A] |= 0x4;
2838 output[0x0A] &= ~0x4;
2839 output[0x0B] = eeprom->
invert;
2886 output[0x0A] |= 0x4;
2888 output[0x0A] &= ~0x4;
2926 output[0x18] = eeprom->
chip;
2948 output[0x0a] |= 0x4;
2950 output[0x0a] &= ~0x4;
3005 output[0x18] = eeprom->
chip;
3020 output[0x0a] |= 0x4;
3022 output[0x0a] &= ~0x4;
3056 output[0x1e] = eeprom->
chip;
3057 fprintf(stderr,
"FIXME: Build FT232H specific EEPROM settings\n");
3060 output[0x00] = 0x80;
3061 output[0x0a] = 0x08;
3062 output[0x0c] = (0x01) | (0x3 << 4);
3063 for (j = 0; j <= 6; j++)
3073 for (i = 0; i < eeprom->
size/2-1; i++)
3080 value = output[i*2];
3081 value += output[(i*2)+1] << 8;
3083 checksum = value^checksum;
3084 checksum = (checksum << 1) | (checksum >> 15);
3087 output[eeprom->
size-2] = checksum;
3088 output[eeprom->
size-1] = checksum >> 8;
3091 return user_area_size;
3098 static unsigned char bit2type(
unsigned char bits)
3108 fprintf(stderr,
" Unexpected value %d for Hardware Interface type\n",
3128 unsigned short checksum, eeprom_checksum, value;
3129 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
3132 unsigned char *
buf = NULL;
3136 if (ftdi->
eeprom == NULL)
3140 eeprom_size = eeprom->
size;
3144 eeprom->
vendor_id = buf[0x02] + (buf[0x03] << 8);
3147 eeprom->
product_id = buf[0x04] + (buf[0x05] << 8);
3180 eeprom->
usb_version = buf[0x0C] + (buf[0x0D] << 8);
3184 manufacturer_size = buf[0x0F]/2;
3187 if (manufacturer_size > 0)
3193 i = buf[0x0E] & (eeprom_size -1);
3194 for (j=0; j<manufacturer_size-1; j++)
3207 product_size = buf[0x11]/2;
3208 if (product_size > 0)
3210 eeprom->
product = malloc(product_size);
3214 i = buf[0x10] & (eeprom_size -1);
3215 for (j=0; j<product_size-1; j++)
3217 eeprom->
product[j] = buf[2*j+i+2];
3228 serial_size = buf[0x13]/2;
3229 if (serial_size > 0)
3231 eeprom->
serial = malloc(serial_size);
3235 i = buf[0x12] & (eeprom_size -1);
3236 for (j=0; j<serial_size-1; j++)
3238 eeprom->
serial[j] = buf[2*j+i+2];
3240 eeprom->
serial[j] =
'\0';
3243 else eeprom->
serial = NULL;
3248 for (i = 0; i < eeprom_size/2-1; i++)
3256 value += buf[(i*2)+1] << 8;
3258 checksum = value^checksum;
3259 checksum = (checksum << 1) | (checksum >> 15);
3262 eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
3264 if (eeprom_checksum != checksum)
3266 fprintf(stderr,
"Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
3283 eeprom->
chip = buf[0x14];
3290 if ( (buf[0x01]&0x40) != 0x40)
3292 "TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size." 3293 " If this happened with the\n" 3294 " EEPROM programmed by FTDI tools, please report " 3295 "to libftdi@developer.intra2net.com\n");
3297 eeprom->
chip = buf[0x16];
3300 eeprom->
invert = buf[0x0B];
3331 eeprom->
chip = buf[0x18];
3337 eeprom->
group1_slew = (buf[0x0c] >> 4) & SLOW_SLEW;
3343 eeprom->
group3_slew = (buf[0x0d] >> 4) & SLOW_SLEW;
3367 eeprom->
chip = buf[0x1e];
3381 eeprom->
group1_slew = (buf[0x0c] >> 4) & SLOW_SLEW;
3386 char *channel_mode[] = {
"UART",
"FIFO",
"CPU",
"OPTO",
"FT1284"};
3387 fprintf(stdout,
"VID: 0x%04x\n",eeprom->
vendor_id);
3388 fprintf(stdout,
"PID: 0x%04x\n",eeprom->
product_id);
3392 fprintf(stdout,
"Self-Powered%s", (eeprom->
remote_wakeup)?
", USB Remote Wake Up\n":
"\n");
3394 fprintf(stdout,
"Bus Powered: %3d mA%s", eeprom->
max_power,
3397 fprintf(stdout,
"Manufacturer: %s\n",eeprom->
manufacturer);
3399 fprintf(stdout,
"Product: %s\n",eeprom->
product);
3401 fprintf(stdout,
"Serial: %s\n",eeprom->
serial);
3402 fprintf(stdout,
"Checksum : %04x\n", checksum);
3404 fprintf(stdout,
"Internal EEPROM\n");
3405 else if (eeprom->
chip >= 0x46)
3406 fprintf(stdout,
"Attached EEPROM: 93x%02x\n", eeprom->
chip);
3408 fprintf(stdout,
"Suspend on DBUS7\n");
3410 fprintf(stdout,
"Pull IO pins low during suspend\n");
3414 fprintf(stdout,
"Enter low power state on ACBUS7\n");
3417 fprintf(stdout,
"Enable Remote Wake Up\n");
3418 fprintf(stdout,
"PNP: %d\n",(eeprom->
is_not_pnp)?0:1);
3420 fprintf(stdout,
"Channel A has Mode %s%s%s\n",
3426 fprintf(stdout,
"FT1284 Mode Clock is idle %s, %s first, %sFlow Control\n",
3432 fprintf(stdout,
"Channel B has Mode %s%s%s\n",
3438 fprintf(stdout,
"Use explicit USB Version %04x\n",eeprom->
usb_version);
3442 fprintf(stdout,
"%s has %d mA drive%s%s\n",
3447 fprintf(stdout,
"%s has %d mA drive%s%s\n",
3452 fprintf(stdout,
"%s has %d mA drive%s%s\n",
3457 fprintf(stdout,
"%s has %d mA drive%s%s\n",
3466 char *cbush_mux[] = {
"TRISTATE",
"RXLED",
"TXLED",
"TXRXLED",
"PWREN",
3467 "SLEEP",
"DRIVE_0",
"DRIVE_1",
"IOMODE",
"TXDEN",
3468 "CLK30",
"CLK15",
"CLK7_5" 3470 fprintf(stdout,
"ACBUS has %d mA drive%s%s\n",
3474 fprintf(stdout,
"ADBUS has %d mA drive%s%s\n",
3478 for (i=0; i<10; i++)
3481 fprintf(stdout,
"C%d Function: %s\n", i,
3488 char *cbush_mux[] = {
"TRISTATE",
"RXLED",
"TXLED",
"TXRXLED",
"PWREN",
3489 "SLEEP",
"DRIVE_0",
"DRIVE_1",
"IOMODE",
"TXDEN",
3490 "CLK24",
"CLK12",
"CLK6",
"BAT_DETECT",
"BAT_DETECT#",
3491 "I2C_TXE#",
"I2C_RXF#",
"VBUS_SENSE",
"BB_WR#",
3492 "BBRD#",
"TIME_STAMP",
"AWAKE#",
3494 fprintf(stdout,
"IOBUS has %d mA drive%s%s\n",
3498 fprintf(stdout,
"CBUS has %d mA drive%s%s\n",
3505 fprintf(stdout,
"CBUS%d Function: %s\n", i, cbush_mux[eeprom->
cbus_function[i]]);
3511 char *cbus_mux[] = {
"TXDEN",
"PWREN",
"RXLED",
"TXLED",
"TX+RXLED",
3512 "SLEEP",
"CLK48",
"CLK24",
"CLK12",
"CLK6",
3513 "IOMODE",
"BB_WR",
"BB_RD" 3515 char *cbus_BB[] = {
"RXF",
"TXE",
"RD",
"WR"};
3519 char *r_bits[] = {
"TXD",
"RXD",
"RTS",
"CTS",
"DTR",
"DSR",
"DCD",
"RI"};
3520 fprintf(stdout,
"Inverted bits:");
3522 if ((eeprom->
invert & (1<<i)) == (1<<i))
3523 fprintf(stdout,
" %s",r_bits[i]);
3524 fprintf(stdout,
"\n");
3529 fprintf(stdout,
"C%d Function: %s\n", i,
3536 fprintf(stdout,
"C%d BB Function: %s\n", i,
3539 fprintf(stdout,
"Unknown CBUS mode. Might be special mode?\n");
3937 if (!ftdi || !(ftdi->
eeprom))
3940 if (!buf || size < ftdi->eeprom->size)
3963 if (!ftdi || !(ftdi->
eeprom) || !buf)
3988 if (ftdi == NULL || ftdi->
usb_dev == NULL)
4011 if (ftdi == NULL || ftdi->
usb_dev == NULL)
4017 if (libusb_control_transfer(
4029 else if (memcmp(buf,&buf[0x80],0x80) == 0)
4031 else if (memcmp(buf,&buf[0x40],0x40) == 0)
4043 static unsigned char ftdi_read_chipid_shift(
unsigned char value)
4045 return ((value & 1) << 1) |
4046 ((value & 2) << 5) |
4047 ((value & 4) >> 2) |
4048 ((value & 8) << 4) |
4049 ((value & 16) >> 1) |
4050 ((value & 32) >> 1) |
4051 ((value & 64) >> 4) |
4052 ((value & 128) >> 2);
4067 unsigned int a = 0, b = 0;
4069 if (ftdi == NULL || ftdi->
usb_dev == NULL)
4074 a = a << 8 | a >> 8;
4077 b = b << 8 | b >> 8;
4078 a = (a << 16) | (b & 0xFFFF);
4079 a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
4080 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
4081 *chipid = a ^ 0xa5f0f7d1;
4104 unsigned short eeprom_val)
4106 int chip_type_location;
4107 unsigned short chip_type;
4109 if (ftdi == NULL || ftdi->
usb_dev == NULL)
4112 if (eeprom_addr <0x80)
4120 chip_type_location = 0x14;
4124 chip_type_location = 0x18;
4127 chip_type_location = 0x1e;
4135 fprintf(stderr,
" loc 0x%04x val 0x%04x\n", chip_type_location,chip_type);
4136 if ((chip_type & 0xff) != 0x66)
4161 unsigned short usb_val, status;
4163 unsigned char *eeprom;
4165 if (ftdi == NULL || ftdi->
usb_dev == NULL)
4188 usb_val = eeprom[i*2];
4189 usb_val += eeprom[(i*2)+1] << 8;
4213 #define MAGIC 0x55aa 4216 unsigned short eeprom_value;
4217 if (ftdi == NULL || ftdi->
usb_dev == NULL)
4241 if (eeprom_value ==
MAGIC)
4249 if (eeprom_value ==
MAGIC)
4255 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