00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00029
00030
00031 #include <usb.h>
00032 #include <string.h>
00033 #include <errno.h>
00034 #include <stdio.h>
00035
00036 #include "ftdi.h"
00037
00038
00039 #ifdef LIBFTDI_LINUX_ASYNC_MODE
00040 #include <sys/ioctl.h>
00041 #include <sys/time.h>
00042 #include <sys/select.h>
00043 #include <sys/types.h>
00044 #include <unistd.h>
00045 #include <linux/usbdevice_fs.h>
00046 #endif
00047
00048 #define ftdi_error_return(code, str) do { \
00049 ftdi->error_str = str; \
00050 return code; \
00051 } while(0);
00052
00053
00063 static int ftdi_usb_close_internal (struct ftdi_context *ftdi)
00064 {
00065 int ret = 0;
00066
00067 if (ftdi->usb_dev)
00068 {
00069 ret = usb_close (ftdi->usb_dev);
00070 ftdi->usb_dev = NULL;
00071 }
00072
00073 return ret;
00074 }
00075
00086 int ftdi_init(struct ftdi_context *ftdi)
00087 {
00088 unsigned int i;
00089
00090 ftdi->usb_dev = NULL;
00091 ftdi->usb_read_timeout = 5000;
00092 ftdi->usb_write_timeout = 5000;
00093
00094 ftdi->type = TYPE_BM;
00095 ftdi->baudrate = -1;
00096 ftdi->bitbang_enabled = 0;
00097
00098 ftdi->readbuffer = NULL;
00099 ftdi->readbuffer_offset = 0;
00100 ftdi->readbuffer_remaining = 0;
00101 ftdi->writebuffer_chunksize = 4096;
00102 ftdi->max_packet_size = 0;
00103
00104 ftdi->interface = 0;
00105 ftdi->index = 0;
00106 ftdi->in_ep = 0x02;
00107 ftdi->out_ep = 0x81;
00108 ftdi->bitbang_mode = 1;
00109
00110 ftdi->error_str = NULL;
00111
00112 #ifdef LIBFTDI_LINUX_ASYNC_MODE
00113 ftdi->async_usb_buffer_size=10;
00114 if ((ftdi->async_usb_buffer=malloc(sizeof(struct usbdevfs_urb)*ftdi->async_usb_buffer_size)) == NULL)
00115 ftdi_error_return(-1, "out of memory for async usb buffer");
00116
00117
00118 for (i=0; i < ftdi->async_usb_buffer_size; i++)
00119 ((struct usbdevfs_urb*)ftdi->async_usb_buffer)[i].usercontext = FTDI_URB_USERCONTEXT_COOKIE;
00120 #else
00121 ftdi->async_usb_buffer_size=0;
00122 ftdi->async_usb_buffer = NULL;
00123 #endif
00124
00125 ftdi->eeprom_size = FTDI_DEFAULT_EEPROM_SIZE;
00126
00127
00128 return ftdi_read_data_set_chunksize(ftdi, 4096);
00129 }
00130
00136 struct ftdi_context *ftdi_new(void)
00137 {
00138 struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context));
00139
00140 if (ftdi == NULL)
00141 {
00142 return NULL;
00143 }
00144
00145 if (ftdi_init(ftdi) != 0)
00146 {
00147 free(ftdi);
00148 return NULL;
00149 }
00150
00151 return ftdi;
00152 }
00153
00163 int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
00164 {
00165 switch (interface)
00166 {
00167 case INTERFACE_ANY:
00168 case INTERFACE_A:
00169
00170 break;
00171 case INTERFACE_B:
00172 ftdi->interface = 1;
00173 ftdi->index = INTERFACE_B;
00174 ftdi->in_ep = 0x04;
00175 ftdi->out_ep = 0x83;
00176 break;
00177 case INTERFACE_C:
00178 ftdi->interface = 2;
00179 ftdi->index = INTERFACE_C;
00180 ftdi->in_ep = 0x06;
00181 ftdi->out_ep = 0x85;
00182 break;
00183 case INTERFACE_D:
00184 ftdi->interface = 3;
00185 ftdi->index = INTERFACE_D;
00186 ftdi->in_ep = 0x08;
00187 ftdi->out_ep = 0x87;
00188 break;
00189 default:
00190 ftdi_error_return(-1, "Unknown interface");
00191 }
00192 return 0;
00193 }
00194
00200 void ftdi_deinit(struct ftdi_context *ftdi)
00201 {
00202 ftdi_usb_close_internal (ftdi);
00203
00204 if (ftdi->async_usb_buffer != NULL)
00205 {
00206 free(ftdi->async_usb_buffer);
00207 ftdi->async_usb_buffer = NULL;
00208 }
00209
00210 if (ftdi->readbuffer != NULL)
00211 {
00212 free(ftdi->readbuffer);
00213 ftdi->readbuffer = NULL;
00214 }
00215 }
00216
00222 void ftdi_free(struct ftdi_context *ftdi)
00223 {
00224 ftdi_deinit(ftdi);
00225 free(ftdi);
00226 }
00227
00234 void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *usb)
00235 {
00236 ftdi->usb_dev = usb;
00237 }
00238
00239
00254 int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
00255 {
00256 struct ftdi_device_list **curdev;
00257 struct usb_bus *bus;
00258 struct usb_device *dev;
00259 int count = 0;
00260
00261 usb_init();
00262 if (usb_find_busses() < 0)
00263 ftdi_error_return(-1, "usb_find_busses() failed");
00264 if (usb_find_devices() < 0)
00265 ftdi_error_return(-2, "usb_find_devices() failed");
00266
00267 curdev = devlist;
00268 *curdev = NULL;
00269 for (bus = usb_get_busses(); bus; bus = bus->next)
00270 {
00271 for (dev = bus->devices; dev; dev = dev->next)
00272 {
00273 if (dev->descriptor.idVendor == vendor
00274 && dev->descriptor.idProduct == product)
00275 {
00276 *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
00277 if (!*curdev)
00278 ftdi_error_return(-3, "out of memory");
00279
00280 (*curdev)->next = NULL;
00281 (*curdev)->dev = dev;
00282
00283 curdev = &(*curdev)->next;
00284 count++;
00285 }
00286 }
00287 }
00288
00289 return count;
00290 }
00291
00297 void ftdi_list_free(struct ftdi_device_list **devlist)
00298 {
00299 struct ftdi_device_list *curdev, *next;
00300
00301 for (curdev = *devlist; curdev != NULL;)
00302 {
00303 next = curdev->next;
00304 free(curdev);
00305 curdev = next;
00306 }
00307
00308 *devlist = NULL;
00309 }
00310
00316 void ftdi_list_free2(struct ftdi_device_list *devlist)
00317 {
00318 ftdi_list_free(&devlist);
00319 }
00320
00347 int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct usb_device * dev,
00348 char * manufacturer, int mnf_len, char * description, int desc_len, char * serial, int serial_len)
00349 {
00350 if ((ftdi==NULL) || (dev==NULL))
00351 return -1;
00352
00353 if (!(ftdi->usb_dev = usb_open(dev)))
00354 ftdi_error_return(-4, usb_strerror());
00355
00356 if (manufacturer != NULL)
00357 {
00358 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iManufacturer, manufacturer, mnf_len) <= 0)
00359 {
00360 ftdi_usb_close_internal (ftdi);
00361 ftdi_error_return(-7, usb_strerror());
00362 }
00363 }
00364
00365 if (description != NULL)
00366 {
00367 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, description, desc_len) <= 0)
00368 {
00369 ftdi_usb_close_internal (ftdi);
00370 ftdi_error_return(-8, usb_strerror());
00371 }
00372 }
00373
00374 if (serial != NULL)
00375 {
00376 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, serial, serial_len) <= 0)
00377 {
00378 ftdi_usb_close_internal (ftdi);
00379 ftdi_error_return(-9, usb_strerror());
00380 }
00381 }
00382
00383 if (ftdi_usb_close_internal (ftdi) != 0)
00384 ftdi_error_return(-10, usb_strerror());
00385
00386 return 0;
00387 }
00388
00395 static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, struct usb_device *dev)
00396 {
00397 unsigned int packet_size;
00398
00399
00400
00401
00402 if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H)
00403 packet_size = 512;
00404 else
00405 packet_size = 64;
00406
00407 if (dev->descriptor.bNumConfigurations > 0 && dev->config)
00408 {
00409 struct usb_config_descriptor config = dev->config[0];
00410
00411 if (ftdi->interface < config.bNumInterfaces)
00412 {
00413 struct usb_interface interface = config.interface[ftdi->interface];
00414 if (interface.num_altsetting > 0)
00415 {
00416 struct usb_interface_descriptor descriptor = interface.altsetting[0];
00417 if (descriptor.bNumEndpoints > 0)
00418 {
00419 packet_size = descriptor.endpoint[0].wMaxPacketSize;
00420 }
00421 }
00422 }
00423 }
00424
00425 return packet_size;
00426 }
00427
00441 int ftdi_usb_open_dev(struct ftdi_context *ftdi, struct usb_device *dev)
00442 {
00443 int detach_errno = 0;
00444 int config_val = 1;
00445 if (!(ftdi->usb_dev = usb_open(dev)))
00446 ftdi_error_return(-4, "usb_open() failed");
00447
00448 #ifdef LIBUSB_HAS_GET_DRIVER_NP
00449
00450
00451
00452
00453
00454
00455
00456 if (usb_detach_kernel_driver_np(ftdi->usb_dev, ftdi->interface) != 0 && errno != ENODATA)
00457 detach_errno = errno;
00458 #endif
00459
00460 #ifdef __WIN32__
00461
00462
00463
00464
00465 if (dev->descriptor.bNumConfigurations > 0)
00466 {
00467
00468 if (dev->config)
00469 config_val = dev->config[0].bConfigurationValue;
00470
00471 if (usb_set_configuration(ftdi->usb_dev, config_val) &&
00472 errno != EBUSY)
00473 {
00474 ftdi_usb_close_internal (ftdi);
00475 if (detach_errno == EPERM)
00476 {
00477 ftdi_error_return(-8, "inappropriate permissions on device!");
00478 }
00479 else
00480 {
00481 ftdi_error_return(-3, "unable to set usb configuration. Make sure ftdi_sio is unloaded!");
00482 }
00483 }
00484 }
00485 #endif
00486
00487 if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0)
00488 {
00489 ftdi_usb_close_internal (ftdi);
00490 if (detach_errno == EPERM)
00491 {
00492 ftdi_error_return(-8, "inappropriate permissions on device!");
00493 }
00494 else
00495 {
00496 ftdi_error_return(-5, "unable to claim usb device. Make sure ftdi_sio is unloaded!");
00497 }
00498 }
00499
00500 if (ftdi_usb_reset (ftdi) != 0)
00501 {
00502 ftdi_usb_close_internal (ftdi);
00503 ftdi_error_return(-6, "ftdi_usb_reset failed");
00504 }
00505
00506
00507
00508 if (dev->descriptor.bcdDevice == 0x400 || (dev->descriptor.bcdDevice == 0x200
00509 && dev->descriptor.iSerialNumber == 0))
00510 ftdi->type = TYPE_BM;
00511 else if (dev->descriptor.bcdDevice == 0x200)
00512 ftdi->type = TYPE_AM;
00513 else if (dev->descriptor.bcdDevice == 0x500)
00514 ftdi->type = TYPE_2232C;
00515 else if (dev->descriptor.bcdDevice == 0x600)
00516 ftdi->type = TYPE_R;
00517 else if (dev->descriptor.bcdDevice == 0x700)
00518 ftdi->type = TYPE_2232H;
00519 else if (dev->descriptor.bcdDevice == 0x800)
00520 ftdi->type = TYPE_4232H;
00521
00522
00523 switch(ftdi->type)
00524 {
00525 case TYPE_2232C:
00526 case TYPE_2232H:
00527 case TYPE_4232H:
00528 if (!ftdi->index)
00529 ftdi->index = INTERFACE_A;
00530 break;
00531 default:
00532 break;
00533 }
00534
00535
00536 ftdi->max_packet_size = _ftdi_determine_max_packet_size(ftdi, dev);
00537
00538 if (ftdi_set_baudrate (ftdi, 9600) != 0)
00539 {
00540 ftdi_usb_close_internal (ftdi);
00541 ftdi_error_return(-7, "set baudrate failed");
00542 }
00543
00544 ftdi_error_return(0, "all fine");
00545 }
00546
00556 int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
00557 {
00558 return ftdi_usb_open_desc(ftdi, vendor, product, NULL, NULL);
00559 }
00560
00583 int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
00584 const char* description, const char* serial)
00585 {
00586 return ftdi_usb_open_desc_index(ftdi,vendor,product,description,serial,0);
00587 }
00588
00612 int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product,
00613 const char* description, const char* serial, unsigned int index)
00614 {
00615 struct usb_bus *bus;
00616 struct usb_device *dev;
00617 char string[256];
00618
00619 usb_init();
00620
00621 if (usb_find_busses() < 0)
00622 ftdi_error_return(-1, "usb_find_busses() failed");
00623 if (usb_find_devices() < 0)
00624 ftdi_error_return(-2, "usb_find_devices() failed");
00625
00626 for (bus = usb_get_busses(); bus; bus = bus->next)
00627 {
00628 for (dev = bus->devices; dev; dev = dev->next)
00629 {
00630 if (dev->descriptor.idVendor == vendor
00631 && dev->descriptor.idProduct == product)
00632 {
00633 if (!(ftdi->usb_dev = usb_open(dev)))
00634 ftdi_error_return(-4, "usb_open() failed");
00635
00636 if (description != NULL)
00637 {
00638 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, string, sizeof(string)) <= 0)
00639 {
00640 ftdi_usb_close_internal (ftdi);
00641 ftdi_error_return(-8, "unable to fetch product description");
00642 }
00643 if (strncmp(string, description, sizeof(string)) != 0)
00644 {
00645 if (ftdi_usb_close_internal (ftdi) != 0)
00646 ftdi_error_return(-10, "unable to close device");
00647 continue;
00648 }
00649 }
00650 if (serial != NULL)
00651 {
00652 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, string, sizeof(string)) <= 0)
00653 {
00654 ftdi_usb_close_internal (ftdi);
00655 ftdi_error_return(-9, "unable to fetch serial number");
00656 }
00657 if (strncmp(string, serial, sizeof(string)) != 0)
00658 {
00659 if (ftdi_usb_close_internal (ftdi) != 0)
00660 ftdi_error_return(-10, "unable to close device");
00661 continue;
00662 }
00663 }
00664
00665 if (ftdi_usb_close_internal (ftdi) != 0)
00666 ftdi_error_return(-10, "unable to close device");
00667
00668 if (index > 0)
00669 {
00670 index--;
00671 continue;
00672 }
00673
00674 return ftdi_usb_open_dev(ftdi, dev);
00675 }
00676 }
00677 }
00678
00679
00680 ftdi_error_return(-3, "device not found");
00681 }
00682
00709 int ftdi_usb_open_string(struct ftdi_context *ftdi, const char* description)
00710 {
00711 if (description[0] == 0 || description[1] != ':')
00712 ftdi_error_return(-11, "illegal description format");
00713
00714 if (description[0] == 'd')
00715 {
00716 struct usb_bus *bus;
00717 struct usb_device *dev;
00718 char dev_name[PATH_MAX+1];
00719
00720 usb_init();
00721
00722 if (usb_find_busses() < 0)
00723 ftdi_error_return(-1, "usb_find_busses() failed");
00724 if (usb_find_devices() < 0)
00725 ftdi_error_return(-2, "usb_find_devices() failed");
00726
00727 for (bus = usb_get_busses(); bus; bus = bus->next)
00728 {
00729 for (dev = bus->devices; dev; dev = dev->next)
00730 {
00731 snprintf(dev_name, sizeof(dev_name), "%s/%s",bus->dirname,dev->filename);
00732 if (strcmp(description+2,dev_name) == 0)
00733 return ftdi_usb_open_dev(ftdi, dev);
00734 }
00735 }
00736
00737
00738 ftdi_error_return(-3, "device not found");
00739 }
00740 else if (description[0] == 'i' || description[0] == 's')
00741 {
00742 unsigned int vendor;
00743 unsigned int product;
00744 unsigned int index=0;
00745 const char *serial=NULL;
00746 const char *startp, *endp;
00747
00748 errno=0;
00749 startp=description+2;
00750 vendor=strtoul((char*)startp,(char**)&endp,0);
00751 if (*endp != ':' || endp == startp || errno != 0)
00752 ftdi_error_return(-11, "illegal description format");
00753
00754 startp=endp+1;
00755 product=strtoul((char*)startp,(char**)&endp,0);
00756 if (endp == startp || errno != 0)
00757 ftdi_error_return(-11, "illegal description format");
00758
00759 if (description[0] == 'i' && *endp != 0)
00760 {
00761
00762 if (*endp != ':')
00763 ftdi_error_return(-11, "illegal description format");
00764
00765 startp=endp+1;
00766 index=strtoul((char*)startp,(char**)&endp,0);
00767 if (*endp != 0 || endp == startp || errno != 0)
00768 ftdi_error_return(-11, "illegal description format");
00769 }
00770 if (description[0] == 's')
00771 {
00772 if (*endp != ':')
00773 ftdi_error_return(-11, "illegal description format");
00774
00775
00776 serial=endp+1;
00777 }
00778
00779 return ftdi_usb_open_desc_index(ftdi, vendor, product, NULL, serial, index);
00780 }
00781 else
00782 {
00783 ftdi_error_return(-11, "illegal description format");
00784 }
00785 }
00786
00795 int ftdi_usb_reset(struct ftdi_context *ftdi)
00796 {
00797 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
00798 SIO_RESET_REQUEST, SIO_RESET_SIO,
00799 ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
00800 ftdi_error_return(-1,"FTDI reset failed");
00801
00802
00803 ftdi->readbuffer_offset = 0;
00804 ftdi->readbuffer_remaining = 0;
00805
00806 return 0;
00807 }
00808
00817 int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
00818 {
00819 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
00820 SIO_RESET_REQUEST, SIO_RESET_PURGE_RX,
00821 ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
00822 ftdi_error_return(-1, "FTDI purge of RX buffer failed");
00823
00824
00825 ftdi->readbuffer_offset = 0;
00826 ftdi->readbuffer_remaining = 0;
00827
00828 return 0;
00829 }
00830
00839 int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
00840 {
00841 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
00842 SIO_RESET_REQUEST, SIO_RESET_PURGE_TX,
00843 ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
00844 ftdi_error_return(-1, "FTDI purge of TX buffer failed");
00845
00846 return 0;
00847 }
00848
00858 int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
00859 {
00860 int result;
00861
00862 result = ftdi_usb_purge_rx_buffer(ftdi);
00863 if (result < 0)
00864 return -1;
00865
00866 result = ftdi_usb_purge_tx_buffer(ftdi);
00867 if (result < 0)
00868 return -2;
00869
00870 return 0;
00871 }
00872
00873
00874
00884 int ftdi_usb_close(struct ftdi_context *ftdi)
00885 {
00886 int rtn = 0;
00887
00888 #ifdef LIBFTDI_LINUX_ASYNC_MODE
00889
00890 ftdi_async_complete(ftdi,1);
00891 #endif
00892
00893 if (ftdi->usb_dev != NULL)
00894 if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0)
00895 rtn = -1;
00896
00897 if (ftdi_usb_close_internal (ftdi) != 0)
00898 rtn = -2;
00899
00900 return rtn;
00901 }
00902
00908 static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
00909 unsigned short *value, unsigned short *index)
00910 {
00911 static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
00912 static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
00913 static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
00914 int divisor, best_divisor, best_baud, best_baud_diff;
00915 unsigned long encoded_divisor;
00916 int i;
00917
00918 if (baudrate <= 0)
00919 {
00920
00921 return -1;
00922 }
00923
00924 divisor = 24000000 / baudrate;
00925
00926 if (ftdi->type == TYPE_AM)
00927 {
00928
00929 divisor -= am_adjust_dn[divisor & 7];
00930 }
00931
00932
00933 best_divisor = 0;
00934 best_baud = 0;
00935 best_baud_diff = 0;
00936 for (i = 0; i < 2; i++)
00937 {
00938 int try_divisor = divisor + i;
00939 int baud_estimate;
00940 int baud_diff;
00941
00942
00943 if (try_divisor <= 8)
00944 {
00945
00946 try_divisor = 8;
00947 }
00948 else if (ftdi->type != TYPE_AM && try_divisor < 12)
00949 {
00950
00951 try_divisor = 12;
00952 }
00953 else if (divisor < 16)
00954 {
00955
00956 try_divisor = 16;
00957 }
00958 else
00959 {
00960 if (ftdi->type == TYPE_AM)
00961 {
00962
00963 try_divisor += am_adjust_up[try_divisor & 7];
00964 if (try_divisor > 0x1FFF8)
00965 {
00966
00967 try_divisor = 0x1FFF8;
00968 }
00969 }
00970 else
00971 {
00972 if (try_divisor > 0x1FFFF)
00973 {
00974
00975 try_divisor = 0x1FFFF;
00976 }
00977 }
00978 }
00979
00980 baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
00981
00982 if (baud_estimate < baudrate)
00983 {
00984 baud_diff = baudrate - baud_estimate;
00985 }
00986 else
00987 {
00988 baud_diff = baud_estimate - baudrate;
00989 }
00990 if (i == 0 || baud_diff < best_baud_diff)
00991 {
00992
00993 best_divisor = try_divisor;
00994 best_baud = baud_estimate;
00995 best_baud_diff = baud_diff;
00996 if (baud_diff == 0)
00997 {
00998
00999 break;
01000 }
01001 }
01002 }
01003
01004 encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
01005
01006 if (encoded_divisor == 1)
01007 {
01008 encoded_divisor = 0;
01009 }
01010 else if (encoded_divisor == 0x4001)
01011 {
01012 encoded_divisor = 1;
01013 }
01014
01015 *value = (unsigned short)(encoded_divisor & 0xFFFF);
01016 if (ftdi->type == TYPE_2232C || ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H)
01017 {
01018 *index = (unsigned short)(encoded_divisor >> 8);
01019 *index &= 0xFF00;
01020 *index |= ftdi->index;
01021 }
01022 else
01023 *index = (unsigned short)(encoded_divisor >> 16);
01024
01025
01026 return best_baud;
01027 }
01028
01039 int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
01040 {
01041 unsigned short value, index;
01042 int actual_baudrate;
01043
01044 if (ftdi->bitbang_enabled)
01045 {
01046 baudrate = baudrate*4;
01047 }
01048
01049 actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
01050 if (actual_baudrate <= 0)
01051 ftdi_error_return (-1, "Silly baudrate <= 0.");
01052
01053
01054 if ((actual_baudrate * 2 < baudrate )
01055 || ((actual_baudrate < baudrate)
01056 ? (actual_baudrate * 21 < baudrate * 20)
01057 : (baudrate * 21 < actual_baudrate * 20)))
01058 ftdi_error_return (-1, "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4");
01059
01060 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
01061 SIO_SET_BAUDRATE_REQUEST, value,
01062 index, NULL, 0, ftdi->usb_write_timeout) != 0)
01063 ftdi_error_return (-2, "Setting new baudrate failed");
01064
01065 ftdi->baudrate = baudrate;
01066 return 0;
01067 }
01068
01082 int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
01083 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
01084 {
01085 return ftdi_set_line_property2(ftdi, bits, sbit, parity, BREAK_OFF);
01086 }
01087
01100 int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
01101 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity,
01102 enum ftdi_break_type break_type)
01103 {
01104 unsigned short value = bits;
01105
01106 switch (parity)
01107 {
01108 case NONE:
01109 value |= (0x00 << 8);
01110 break;
01111 case ODD:
01112 value |= (0x01 << 8);
01113 break;
01114 case EVEN:
01115 value |= (0x02 << 8);
01116 break;
01117 case MARK:
01118 value |= (0x03 << 8);
01119 break;
01120 case SPACE:
01121 value |= (0x04 << 8);
01122 break;
01123 }
01124
01125 switch (sbit)
01126 {
01127 case STOP_BIT_1:
01128 value |= (0x00 << 11);
01129 break;
01130 case STOP_BIT_15:
01131 value |= (0x01 << 11);
01132 break;
01133 case STOP_BIT_2:
01134 value |= (0x02 << 11);
01135 break;
01136 }
01137
01138 switch (break_type)
01139 {
01140 case BREAK_OFF:
01141 value |= (0x00 << 14);
01142 break;
01143 case BREAK_ON:
01144 value |= (0x01 << 14);
01145 break;
01146 }
01147
01148 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
01149 SIO_SET_DATA_REQUEST, value,
01150 ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
01151 ftdi_error_return (-1, "Setting new line property failed");
01152
01153 return 0;
01154 }
01155
01166 int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
01167 {
01168 int ret;
01169 int offset = 0;
01170 int total_written = 0;
01171
01172 while (offset < size)
01173 {
01174 int write_size = ftdi->writebuffer_chunksize;
01175
01176 if (offset+write_size > size)
01177 write_size = size-offset;
01178
01179 ret = usb_bulk_write(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, ftdi->usb_write_timeout);
01180 if (ret < 0)
01181 ftdi_error_return(ret, "usb bulk write failed");
01182
01183 total_written += ret;
01184 offset += write_size;
01185 }
01186
01187 return total_written;
01188 }
01189
01190 #ifdef LIBFTDI_LINUX_ASYNC_MODE
01191 #if 0
01192 #error LIBFTDI_LINUX_ASYNC_MODE is not compatible with libusb-compat-0.1!
01193 #endif
01194
01195
01196 struct usb_dev_handle
01197 {
01198 int fd;
01199
01200 };
01201
01206 static int _usb_get_async_urbs_pending(struct ftdi_context *ftdi)
01207 {
01208 struct usbdevfs_urb *urb;
01209 int pending=0;
01210 unsigned int i;
01211
01212 for (i=0; i < ftdi->async_usb_buffer_size; i++)
01213 {
01214 urb=&((struct usbdevfs_urb *)(ftdi->async_usb_buffer))[i];
01215 if (urb->usercontext != FTDI_URB_USERCONTEXT_COOKIE)
01216 pending++;
01217 }
01218
01219 return pending;
01220 }
01221
01232 static void _usb_async_cleanup(struct ftdi_context *ftdi, int wait_for_more, int timeout_msec)
01233 {
01234 struct timeval tv;
01235 struct usbdevfs_urb *urb=NULL;
01236 int ret;
01237 fd_set writefds;
01238 int keep_going=0;
01239
01240 FD_ZERO(&writefds);
01241 FD_SET(ftdi->usb_dev->fd, &writefds);
01242
01243
01244 tv.tv_sec = timeout_msec / 1000;
01245 tv.tv_usec = (timeout_msec % 1000) * 1000;
01246
01247 do
01248 {
01249 while (_usb_get_async_urbs_pending(ftdi)
01250 && (ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_REAPURBNDELAY, &urb)) == -1
01251 && errno == EAGAIN)
01252 {
01253 if (keep_going && !wait_for_more)
01254 {
01255
01256 keep_going=0;
01257 break;
01258 }
01259
01260
01261 select(ftdi->usb_dev->fd+1, NULL, &writefds, NULL, &tv);
01262 }
01263
01264 if (ret == 0 && urb != NULL)
01265 {
01266
01267 urb->usercontext = FTDI_URB_USERCONTEXT_COOKIE;
01268
01269
01270 urb=NULL;
01271 keep_going=1;
01272 }
01273 else
01274 {
01275
01276 keep_going=0;
01277 }
01278 }
01279 while (keep_going);
01280 }
01281
01289 void ftdi_async_complete(struct ftdi_context *ftdi, int wait_for_more)
01290 {
01291 _usb_async_cleanup(ftdi,wait_for_more,ftdi->usb_write_timeout);
01292 }
01293
01299 static int _usb_bulk_write_async(struct ftdi_context *ftdi, int ep, char *bytes, int size)
01300 {
01301 struct usbdevfs_urb *urb;
01302 int bytesdone = 0, requested;
01303 int ret, cleanup_count;
01304 unsigned int i;
01305
01306 do
01307 {
01308
01309 urb=NULL;
01310 for (cleanup_count=0; urb==NULL && cleanup_count <= 1; cleanup_count++)
01311 {
01312 if (i==ftdi->async_usb_buffer_size)
01313 {
01314
01315 _usb_async_cleanup(ftdi,0,ftdi->usb_write_timeout);
01316 }
01317
01318 for (i=0; i < ftdi->async_usb_buffer_size; i++)
01319 {
01320 urb=&((struct usbdevfs_urb *)(ftdi->async_usb_buffer))[i];
01321 if (urb->usercontext == FTDI_URB_USERCONTEXT_COOKIE)
01322 break;
01323 urb=NULL;
01324 }
01325 }
01326
01327
01328 if (urb==NULL)
01329 return -1;
01330
01331 requested = size - bytesdone;
01332 if (requested > 4096)
01333 requested = 4096;
01334
01335 memset(urb,0,sizeof(urb));
01336
01337 urb->type = USBDEVFS_URB_TYPE_BULK;
01338 urb->endpoint = ep;
01339 urb->flags = 0;
01340 urb->buffer = bytes + bytesdone;
01341 urb->buffer_length = requested;
01342 urb->signr = 0;
01343 urb->actual_length = 0;
01344 urb->number_of_packets = 0;
01345 urb->usercontext = 0;
01346
01347 do
01348 {
01349 ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_SUBMITURB, urb);
01350 }
01351 while (ret < 0 && errno == EINTR);
01352 if (ret < 0)
01353 return ret;
01354
01355 bytesdone += requested;
01356 }
01357 while (bytesdone < size);
01358 return bytesdone;
01359 }
01360
01379 int ftdi_write_data_async(struct ftdi_context *ftdi, unsigned char *buf, int size)
01380 {
01381 int ret;
01382 int offset = 0;
01383 int total_written = 0;
01384
01385 while (offset < size)
01386 {
01387 int write_size = ftdi->writebuffer_chunksize;
01388
01389 if (offset+write_size > size)
01390 write_size = size-offset;
01391
01392 ret = _usb_bulk_write_async(ftdi, ftdi->in_ep, buf+offset, write_size);
01393 if (ret < 0)
01394 ftdi_error_return(ret, "usb bulk write async failed");
01395
01396 total_written += ret;
01397 offset += write_size;
01398 }
01399
01400 return total_written;
01401 }
01402 #endif // LIBFTDI_LINUX_ASYNC_MODE
01403
01413 int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
01414 {
01415 ftdi->writebuffer_chunksize = chunksize;
01416 return 0;
01417 }
01418
01427 int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
01428 {
01429 *chunksize = ftdi->writebuffer_chunksize;
01430 return 0;
01431 }
01432
01447 int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
01448 {
01449 int offset = 0, ret = 1, i, num_of_chunks, chunk_remains;
01450 int packet_size = ftdi->max_packet_size;
01451
01452
01453 if (packet_size == 0)
01454 ftdi_error_return(-1, "max_packet_size is bogus (zero)");
01455
01456
01457 if (size <= ftdi->readbuffer_remaining)
01458 {
01459 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
01460
01461
01462 ftdi->readbuffer_remaining -= size;
01463 ftdi->readbuffer_offset += size;
01464
01465
01466
01467 return size;
01468 }
01469
01470 if (ftdi->readbuffer_remaining != 0)
01471 {
01472 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
01473
01474
01475 offset += ftdi->readbuffer_remaining;
01476 }
01477
01478 while (offset < size && ret > 0)
01479 {
01480 ftdi->readbuffer_remaining = 0;
01481 ftdi->readbuffer_offset = 0;
01482
01483 ret = usb_bulk_read (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, ftdi->usb_read_timeout);
01484 if (ret < 0)
01485 ftdi_error_return(ret, "usb bulk read failed");
01486
01487 if (ret > 2)
01488 {
01489
01490
01491 num_of_chunks = ret / packet_size;
01492 chunk_remains = ret % packet_size;
01493
01494
01495 ftdi->readbuffer_offset += 2;
01496 ret -= 2;
01497
01498 if (ret > packet_size - 2)
01499 {
01500 for (i = 1; i < num_of_chunks; i++)
01501 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
01502 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
01503 packet_size - 2);
01504 if (chunk_remains > 2)
01505 {
01506 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
01507 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
01508 chunk_remains-2);
01509 ret -= 2*num_of_chunks;
01510 }
01511 else
01512 ret -= 2*(num_of_chunks-1)+chunk_remains;
01513 }
01514 }
01515 else if (ret <= 2)
01516 {
01517
01518 return offset;
01519 }
01520 if (ret > 0)
01521 {
01522
01523 if (offset+ret <= size)
01524 {
01525 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, ret);
01526
01527 offset += ret;
01528
01529
01530 if (offset == size)
01531
01532
01533 return offset;
01534 }
01535 else
01536 {
01537
01538 int part_size = size-offset;
01539 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
01540
01541 ftdi->readbuffer_offset += part_size;
01542 ftdi->readbuffer_remaining = ret-part_size;
01543 offset += part_size;
01544
01545
01546
01547
01548 return offset;
01549 }
01550 }
01551 }
01552
01553 return -127;
01554 }
01555
01567 int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
01568 {
01569 unsigned char *new_buf;
01570
01571
01572 ftdi->readbuffer_offset = 0;
01573 ftdi->readbuffer_remaining = 0;
01574
01575 if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL)
01576 ftdi_error_return(-1, "out of memory for readbuffer");
01577
01578 ftdi->readbuffer = new_buf;
01579 ftdi->readbuffer_chunksize = chunksize;
01580
01581 return 0;
01582 }
01583
01592 int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
01593 {
01594 *chunksize = ftdi->readbuffer_chunksize;
01595 return 0;
01596 }
01597
01598
01611 int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask)
01612 {
01613 unsigned short usb_val;
01614
01615 usb_val = bitmask;
01616
01617 usb_val |= (ftdi->bitbang_mode << 8);
01618
01619 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
01620 SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index,
01621 NULL, 0, ftdi->usb_write_timeout) != 0)
01622 ftdi_error_return(-1, "unable to enter bitbang mode. Perhaps not a BM type chip?");
01623
01624 ftdi->bitbang_enabled = 1;
01625 return 0;
01626 }
01627
01636 int ftdi_disable_bitbang(struct ftdi_context *ftdi)
01637 {
01638 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_BITMODE_REQUEST, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
01639 ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?");
01640
01641 ftdi->bitbang_enabled = 0;
01642 return 0;
01643 }
01644
01656 int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
01657 {
01658 unsigned short usb_val;
01659
01660 usb_val = bitmask;
01661 usb_val |= (mode << 8);
01662 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
01663 ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps selected mode not supported on your chip?");
01664
01665 ftdi->bitbang_mode = mode;
01666 ftdi->bitbang_enabled = (mode == BITMODE_RESET) ? 0 : 1;
01667 return 0;
01668 }
01669
01679 int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
01680 {
01681 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_PINS_REQUEST, 0, ftdi->index, (char *)pins, 1, ftdi->usb_read_timeout) != 1)
01682 ftdi_error_return(-1, "read pins failed");
01683
01684 return 0;
01685 }
01686
01701 int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
01702 {
01703 unsigned short usb_val;
01704
01705 if (latency < 1)
01706 ftdi_error_return(-1, "latency out of range. Only valid for 1-255");
01707
01708 usb_val = latency;
01709 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_LATENCY_TIMER_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
01710 ftdi_error_return(-2, "unable to set latency timer");
01711
01712 return 0;
01713 }
01714
01724 int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
01725 {
01726 unsigned short usb_val;
01727 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_GET_LATENCY_TIMER_REQUEST, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1)
01728 ftdi_error_return(-1, "reading latency timer failed");
01729
01730 *latency = (unsigned char)usb_val;
01731 return 0;
01732 }
01733
01773 int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
01774 {
01775 char usb_val[2];
01776
01777 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_POLL_MODEM_STATUS_REQUEST, 0, ftdi->index, usb_val, 2, ftdi->usb_read_timeout) != 2)
01778 ftdi_error_return(-1, "getting modem status failed");
01779
01780 *status = (usb_val[1] << 8) | usb_val[0];
01781
01782 return 0;
01783 }
01784
01795 int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
01796 {
01797 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
01798 SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->index),
01799 NULL, 0, ftdi->usb_write_timeout) != 0)
01800 ftdi_error_return(-1, "set flow control failed");
01801
01802 return 0;
01803 }
01804
01814 int ftdi_setdtr(struct ftdi_context *ftdi, int state)
01815 {
01816 unsigned short usb_val;
01817
01818 if (state)
01819 usb_val = SIO_SET_DTR_HIGH;
01820 else
01821 usb_val = SIO_SET_DTR_LOW;
01822
01823 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
01824 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
01825 NULL, 0, ftdi->usb_write_timeout) != 0)
01826 ftdi_error_return(-1, "set dtr failed");
01827
01828 return 0;
01829 }
01830
01840 int ftdi_setrts(struct ftdi_context *ftdi, int state)
01841 {
01842 unsigned short usb_val;
01843
01844 if (state)
01845 usb_val = SIO_SET_RTS_HIGH;
01846 else
01847 usb_val = SIO_SET_RTS_LOW;
01848
01849 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
01850 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
01851 NULL, 0, ftdi->usb_write_timeout) != 0)
01852 ftdi_error_return(-1, "set of rts failed");
01853
01854 return 0;
01855 }
01856
01867 int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
01868 {
01869 unsigned short usb_val;
01870
01871 if (dtr)
01872 usb_val = SIO_SET_DTR_HIGH;
01873 else
01874 usb_val = SIO_SET_DTR_LOW;
01875
01876 if (rts)
01877 usb_val |= SIO_SET_RTS_HIGH;
01878 else
01879 usb_val |= SIO_SET_RTS_LOW;
01880
01881 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
01882 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
01883 NULL, 0, ftdi->usb_write_timeout) != 0)
01884 ftdi_error_return(-1, "set of rts/dtr failed");
01885
01886 return 0;
01887 }
01888
01899 int ftdi_set_event_char(struct ftdi_context *ftdi,
01900 unsigned char eventch, unsigned char enable)
01901 {
01902 unsigned short usb_val;
01903
01904 usb_val = eventch;
01905 if (enable)
01906 usb_val |= 1 << 8;
01907
01908 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_EVENT_CHAR_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
01909 ftdi_error_return(-1, "setting event character failed");
01910
01911 return 0;
01912 }
01913
01924 int ftdi_set_error_char(struct ftdi_context *ftdi,
01925 unsigned char errorch, unsigned char enable)
01926 {
01927 unsigned short usb_val;
01928
01929 usb_val = errorch;
01930 if (enable)
01931 usb_val |= 1 << 8;
01932
01933 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_ERROR_CHAR_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
01934 ftdi_error_return(-1, "setting error character failed");
01935
01936 return 0;
01937 }
01938
01947 void ftdi_eeprom_setsize(struct ftdi_context *ftdi, struct ftdi_eeprom *eeprom, int size)
01948 {
01949 ftdi->eeprom_size=size;
01950 eeprom->size=size;
01951 }
01952
01958 void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom)
01959 {
01960 eeprom->vendor_id = 0x0403;
01961 eeprom->product_id = 0x6001;
01962
01963 eeprom->self_powered = 1;
01964 eeprom->remote_wakeup = 1;
01965 eeprom->BM_type_chip = 1;
01966
01967 eeprom->in_is_isochronous = 0;
01968 eeprom->out_is_isochronous = 0;
01969 eeprom->suspend_pull_downs = 0;
01970
01971 eeprom->use_serial = 0;
01972 eeprom->change_usb_version = 0;
01973 eeprom->usb_version = 0x0200;
01974 eeprom->max_power = 0;
01975
01976 eeprom->manufacturer = NULL;
01977 eeprom->product = NULL;
01978 eeprom->serial = NULL;
01979
01980 eeprom->size = FTDI_DEFAULT_EEPROM_SIZE;
01981 }
01982
01993 int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output)
01994 {
01995 unsigned char i, j;
01996 unsigned short checksum, value;
01997 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
01998 int size_check;
01999
02000 if (eeprom->manufacturer != NULL)
02001 manufacturer_size = strlen(eeprom->manufacturer);
02002 if (eeprom->product != NULL)
02003 product_size = strlen(eeprom->product);
02004 if (eeprom->serial != NULL)
02005 serial_size = strlen(eeprom->serial);
02006
02007 size_check = eeprom->size;
02008 size_check -= 28;
02009
02010
02011
02012
02013
02014 if (eeprom->size>=256)size_check = 120;
02015 size_check -= manufacturer_size*2;
02016 size_check -= product_size*2;
02017 size_check -= serial_size*2;
02018
02019
02020 if (size_check < 0)
02021 return (-1);
02022
02023
02024 memset (output, 0, eeprom->size);
02025
02026
02027
02028 output[0x02] = eeprom->vendor_id;
02029 output[0x03] = eeprom->vendor_id >> 8;
02030
02031
02032 output[0x04] = eeprom->product_id;
02033 output[0x05] = eeprom->product_id >> 8;
02034
02035
02036 output[0x06] = 0x00;
02037
02038 if (eeprom->BM_type_chip == 1)
02039 output[0x07] = 0x04;
02040 else
02041 output[0x07] = 0x02;
02042
02043
02044
02045
02046
02047
02048 j = 0x80;
02049 if (eeprom->self_powered == 1)
02050 j |= 0x40;
02051 if (eeprom->remote_wakeup == 1)
02052 j |= 0x20;
02053 output[0x08] = j;
02054
02055
02056 output[0x09] = eeprom->max_power;
02057
02058
02059
02060
02061
02062
02063
02064
02065
02066
02067
02068 j = 0;
02069 if (eeprom->in_is_isochronous == 1)
02070 j = j | 1;
02071 if (eeprom->out_is_isochronous == 1)
02072 j = j | 2;
02073 if (eeprom->suspend_pull_downs == 1)
02074 j = j | 4;
02075 if (eeprom->use_serial == 1)
02076 j = j | 8;
02077 if (eeprom->change_usb_version == 1)
02078 j = j | 16;
02079 output[0x0A] = j;
02080
02081
02082 output[0x0B] = 0x00;
02083
02084
02085
02086 if (eeprom->change_usb_version == 1)
02087 {
02088 output[0x0C] = eeprom->usb_version;
02089 output[0x0D] = eeprom->usb_version >> 8;
02090 }
02091
02092
02093
02094
02095 output[0x0F] = manufacturer_size*2 + 2;
02096
02097
02098
02099 output[0x11] = product_size*2 + 2;
02100
02101
02102
02103 output[0x13] = serial_size*2 + 2;
02104
02105
02106 i=0x14;
02107 if (eeprom->size>=256) i = 0x80;
02108
02109
02110
02111 output[0x0E] = i | 0x80;
02112 output[i++] = manufacturer_size*2 + 2;
02113 output[i++] = 0x03;
02114 for (j = 0; j < manufacturer_size; j++)
02115 {
02116 output[i] = eeprom->manufacturer[j], i++;
02117 output[i] = 0x00, i++;
02118 }
02119
02120
02121 output[0x10] = i | 0x80;
02122 output[i] = product_size*2 + 2, i++;
02123 output[i] = 0x03, i++;
02124 for (j = 0; j < product_size; j++)
02125 {
02126 output[i] = eeprom->product[j], i++;
02127 output[i] = 0x00, i++;
02128 }
02129
02130
02131 output[0x12] = i | 0x80;
02132 output[i] = serial_size*2 + 2, i++;
02133 output[i] = 0x03, i++;
02134 for (j = 0; j < serial_size; j++)
02135 {
02136 output[i] = eeprom->serial[j], i++;
02137 output[i] = 0x00, i++;
02138 }
02139
02140
02141 checksum = 0xAAAA;
02142
02143 for (i = 0; i < eeprom->size/2-1; i++)
02144 {
02145 value = output[i*2];
02146 value += output[(i*2)+1] << 8;
02147
02148 checksum = value^checksum;
02149 checksum = (checksum << 1) | (checksum >> 15);
02150 }
02151
02152 output[eeprom->size-2] = checksum;
02153 output[eeprom->size-1] = checksum >> 8;
02154
02155 return size_check;
02156 }
02157
02171 int ftdi_eeprom_decode(struct ftdi_eeprom *eeprom, unsigned char *buf, int size)
02172 {
02173 unsigned char i, j;
02174 unsigned short checksum, eeprom_checksum, value;
02175 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
02176 int size_check;
02177 int eeprom_size = 128;
02178 #if 0
02179 size_check = eeprom->size;
02180 size_check -= 28;
02181
02182
02183
02184
02185
02186 if (eeprom->size>=256)size_check = 120;
02187 size_check -= manufacturer_size*2;
02188 size_check -= product_size*2;
02189 size_check -= serial_size*2;
02190
02191
02192 if (size_check < 0)
02193 return (-1);
02194 #endif
02195
02196
02197 memset(eeprom, 0, sizeof(struct ftdi_eeprom));
02198
02199
02200
02201
02202 eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
02203
02204
02205 eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
02206
02207 value = buf[0x06] + (buf[0x07]<<8);
02208 switch (value)
02209 {
02210 case 0x0400:
02211 eeprom->BM_type_chip = 1;
02212 break;
02213 case 0x0200:
02214 eeprom->BM_type_chip = 0;
02215 break;
02216 default:
02217 eeprom->BM_type_chip = 0;
02218 break;
02219 }
02220
02221
02222
02223
02224
02225
02226 j = buf[0x08];
02227 if (j&0x40) eeprom->self_powered = 1;
02228 if (j&0x20) eeprom->remote_wakeup = 1;
02229
02230
02231 eeprom->max_power = buf[0x09];
02232
02233
02234
02235
02236
02237
02238
02239
02240
02241
02242
02243 j = buf[0x0A];
02244 if (j&0x01) eeprom->in_is_isochronous = 1;
02245 if (j&0x02) eeprom->out_is_isochronous = 1;
02246 if (j&0x04) eeprom->suspend_pull_downs = 1;
02247 if (j&0x08) eeprom->use_serial = 1;
02248 if (j&0x10) eeprom->change_usb_version = 1;
02249
02250
02251
02252
02253
02254 if (eeprom->change_usb_version == 1)
02255 {
02256 eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
02257 }
02258
02259
02260
02261 manufacturer_size = buf[0x0F]/2;
02262 if (manufacturer_size > 0) eeprom->manufacturer = malloc(manufacturer_size);
02263 else eeprom->manufacturer = NULL;
02264
02265
02266
02267 product_size = buf[0x11]/2;
02268 if (product_size > 0) eeprom->product = malloc(product_size);
02269 else eeprom->product = NULL;
02270
02271
02272
02273 serial_size = buf[0x13]/2;
02274 if (serial_size > 0) eeprom->serial = malloc(serial_size);
02275 else eeprom->serial = NULL;
02276
02277
02278 i = buf[0x0E] & 0x7f;
02279 for (j=0;j<manufacturer_size-1;j++)
02280 {
02281 eeprom->manufacturer[j] = buf[2*j+i+2];
02282 }
02283 eeprom->manufacturer[j] = '\0';
02284
02285
02286 i = buf[0x10] & 0x7f;
02287 for (j=0;j<product_size-1;j++)
02288 {
02289 eeprom->product[j] = buf[2*j+i+2];
02290 }
02291 eeprom->product[j] = '\0';
02292
02293
02294 i = buf[0x12] & 0x7f;
02295 for (j=0;j<serial_size-1;j++)
02296 {
02297 eeprom->serial[j] = buf[2*j+i+2];
02298 }
02299 eeprom->serial[j] = '\0';
02300
02301
02302 checksum = 0xAAAA;
02303
02304 for (i = 0; i < eeprom_size/2-1; i++)
02305 {
02306 value = buf[i*2];
02307 value += buf[(i*2)+1] << 8;
02308
02309 checksum = value^checksum;
02310 checksum = (checksum << 1) | (checksum >> 15);
02311 }
02312
02313 eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
02314
02315 if (eeprom_checksum != checksum)
02316 {
02317 fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
02318 return -1;
02319 }
02320
02321 return 0;
02322 }
02323
02334 int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
02335 {
02336 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, eeprom_addr, (char *)eeprom_val, 2, ftdi->usb_read_timeout) != 2)
02337 ftdi_error_return(-1, "reading eeprom failed");
02338
02339 return 0;
02340 }
02341
02351 int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
02352 {
02353 int i;
02354
02355 for (i = 0; i < ftdi->eeprom_size/2; i++)
02356 {
02357 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
02358 ftdi_error_return(-1, "reading eeprom failed");
02359 }
02360
02361 return 0;
02362 }
02363
02364
02365
02366
02367
02368
02369 static unsigned char ftdi_read_chipid_shift(unsigned char value)
02370 {
02371 return ((value & 1) << 1) |
02372 ((value & 2) << 5) |
02373 ((value & 4) >> 2) |
02374 ((value & 8) << 4) |
02375 ((value & 16) >> 1) |
02376 ((value & 32) >> 1) |
02377 ((value & 64) >> 4) |
02378 ((value & 128) >> 2);
02379 }
02380
02390 int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
02391 {
02392 unsigned int a = 0, b = 0;
02393
02394 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x43, (char *)&a, 2, ftdi->usb_read_timeout) == 2)
02395 {
02396 a = a << 8 | a >> 8;
02397 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x44, (char *)&b, 2, ftdi->usb_read_timeout) == 2)
02398 {
02399 b = b << 8 | b >> 8;
02400 a = (a << 16) | (b & 0xFFFF);
02401 a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
02402 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
02403 *chipid = a ^ 0xa5f0f7d1;
02404 return 0;
02405 }
02406 }
02407
02408 ftdi_error_return(-1, "read of FTDIChip-ID failed");
02409 }
02410
02421 int ftdi_read_eeprom_getsize(struct ftdi_context *ftdi, unsigned char *eeprom, int maxsize)
02422 {
02423 int i=0,j,minsize=32;
02424 int size=minsize;
02425
02426 do
02427 {
02428 for (j = 0; i < maxsize/2 && j<size; j++)
02429 {
02430 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,
02431 SIO_READ_EEPROM_REQUEST, 0, i,
02432 eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
02433 ftdi_error_return(-1, "reading eeprom failed");
02434 i++;
02435 }
02436 size*=2;
02437 }
02438 while (size<=maxsize && memcmp(eeprom,&eeprom[size/2],size/2)!=0);
02439
02440 return size/2;
02441 }
02442
02453 int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short eeprom_val)
02454 {
02455 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
02456 SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
02457 NULL, 0, ftdi->usb_write_timeout) != 0)
02458 ftdi_error_return(-1, "unable to write eeprom");
02459
02460 return 0;
02461 }
02462
02472 int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
02473 {
02474 unsigned short usb_val, status;
02475 int i, ret;
02476
02477
02478 if ((ret = ftdi_usb_reset(ftdi)) != 0)
02479 return ret;
02480 if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0)
02481 return ret;
02482 if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0)
02483 return ret;
02484
02485 for (i = 0; i < ftdi->eeprom_size/2; i++)
02486 {
02487 usb_val = eeprom[i*2];
02488 usb_val += eeprom[(i*2)+1] << 8;
02489 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
02490 SIO_WRITE_EEPROM_REQUEST, usb_val, i,
02491 NULL, 0, ftdi->usb_write_timeout) != 0)
02492 ftdi_error_return(-1, "unable to write eeprom");
02493 }
02494
02495 return 0;
02496 }
02497
02508 int ftdi_erase_eeprom(struct ftdi_context *ftdi)
02509 {
02510 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST, 0, 0, NULL, 0, ftdi->usb_write_timeout) != 0)
02511 ftdi_error_return(-1, "unable to erase eeprom");
02512
02513 return 0;
02514 }
02515
02523 char *ftdi_get_error_string (struct ftdi_context *ftdi)
02524 {
02525 return ftdi->error_str;
02526 }
02527
02528