libftdi1  1.1
ftdi.c
Go to the documentation of this file.
1 /***************************************************************************
2  ftdi.c - description
3  -------------------
4  begin : Fri Apr 4 2003
5  copyright : (C) 2003-2014 by Intra2net AG and the libftdi developers
6  email : opensource@intra2net.com
7  ***************************************************************************/
8 
9 /***************************************************************************
10  * *
11  * This program is free software; you can redistribute it and/or modify *
12  * it under the terms of the GNU Lesser General Public License *
13  * version 2.1 as published by the Free Software Foundation; *
14  * *
15  ***************************************************************************/
16 
29 /* @{ */
30 
31 #include <libusb.h>
32 #include <string.h>
33 #include <errno.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 
37 #include "ftdi_i.h"
38 #include "ftdi.h"
39 #include "ftdi_version_i.h"
40 
41 #define ftdi_error_return(code, str) do { \
42  if ( ftdi ) \
43  ftdi->error_str = str; \
44  else \
45  fprintf(stderr, str); \
46  return code; \
47  } while(0);
48 
49 #define ftdi_error_return_free_device_list(code, str, devs) do { \
50  libusb_free_device_list(devs,1); \
51  ftdi->error_str = str; \
52  return code; \
53  } while(0);
54 
55 
65 static void ftdi_usb_close_internal (struct ftdi_context *ftdi)
66 {
67  if (ftdi && ftdi->usb_dev)
68  {
69  libusb_close (ftdi->usb_dev);
70  ftdi->usb_dev = NULL;
71  if(ftdi->eeprom)
73  }
74 }
75 
88 int ftdi_init(struct ftdi_context *ftdi)
89 {
90  struct ftdi_eeprom* eeprom = (struct ftdi_eeprom *)malloc(sizeof(struct ftdi_eeprom));
91  ftdi->usb_ctx = NULL;
92  ftdi->usb_dev = NULL;
93  ftdi->usb_read_timeout = 5000;
94  ftdi->usb_write_timeout = 5000;
95 
96  ftdi->type = TYPE_BM; /* chip type */
97  ftdi->baudrate = -1;
98  ftdi->bitbang_enabled = 0; /* 0: normal mode 1: any of the bitbang modes enabled */
99 
100  ftdi->readbuffer = NULL;
101  ftdi->readbuffer_offset = 0;
102  ftdi->readbuffer_remaining = 0;
103  ftdi->writebuffer_chunksize = 4096;
104  ftdi->max_packet_size = 0;
105  ftdi->error_str = NULL;
107 
108  if (libusb_init(&ftdi->usb_ctx) < 0)
109  ftdi_error_return(-3, "libusb_init() failed");
110 
112  ftdi->bitbang_mode = 1; /* when bitbang is enabled this holds the number of the mode */
113 
114  if (eeprom == 0)
115  ftdi_error_return(-2, "Can't malloc struct ftdi_eeprom");
116  memset(eeprom, 0, sizeof(struct ftdi_eeprom));
117  ftdi->eeprom = eeprom;
118 
119  /* All fine. Now allocate the readbuffer */
120  return ftdi_read_data_set_chunksize(ftdi, 4096);
121 }
122 
128 struct ftdi_context *ftdi_new(void)
129 {
130  struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context));
131 
132  if (ftdi == NULL)
133  {
134  return NULL;
135  }
136 
137  if (ftdi_init(ftdi) != 0)
138  {
139  free(ftdi);
140  return NULL;
141  }
142 
143  return ftdi;
144 }
145 
158 {
159  if (ftdi == NULL)
160  ftdi_error_return(-2, "USB device unavailable");
161 
162  if (ftdi->usb_dev != NULL)
163  {
164  int check_interface = interface;
165  if (check_interface == INTERFACE_ANY)
166  check_interface = INTERFACE_A;
167 
168  if (ftdi->index != check_interface)
169  ftdi_error_return(-3, "Interface can not be changed on an already open device");
170  }
171 
172  switch (interface)
173  {
174  case INTERFACE_ANY:
175  case INTERFACE_A:
176  ftdi->interface = 0;
177  ftdi->index = INTERFACE_A;
178  ftdi->in_ep = 0x02;
179  ftdi->out_ep = 0x81;
180  break;
181  case INTERFACE_B:
182  ftdi->interface = 1;
183  ftdi->index = INTERFACE_B;
184  ftdi->in_ep = 0x04;
185  ftdi->out_ep = 0x83;
186  break;
187  case INTERFACE_C:
188  ftdi->interface = 2;
189  ftdi->index = INTERFACE_C;
190  ftdi->in_ep = 0x06;
191  ftdi->out_ep = 0x85;
192  break;
193  case INTERFACE_D:
194  ftdi->interface = 3;
195  ftdi->index = INTERFACE_D;
196  ftdi->in_ep = 0x08;
197  ftdi->out_ep = 0x87;
198  break;
199  default:
200  ftdi_error_return(-1, "Unknown interface");
201  }
202  return 0;
203 }
204 
210 void ftdi_deinit(struct ftdi_context *ftdi)
211 {
212  if (ftdi == NULL)
213  return;
214 
215  ftdi_usb_close_internal (ftdi);
216 
217  if (ftdi->readbuffer != NULL)
218  {
219  free(ftdi->readbuffer);
220  ftdi->readbuffer = NULL;
221  }
222 
223  if (ftdi->eeprom != NULL)
224  {
225  if (ftdi->eeprom->manufacturer != 0)
226  {
227  free(ftdi->eeprom->manufacturer);
228  ftdi->eeprom->manufacturer = 0;
229  }
230  if (ftdi->eeprom->product != 0)
231  {
232  free(ftdi->eeprom->product);
233  ftdi->eeprom->product = 0;
234  }
235  if (ftdi->eeprom->serial != 0)
236  {
237  free(ftdi->eeprom->serial);
238  ftdi->eeprom->serial = 0;
239  }
240  free(ftdi->eeprom);
241  ftdi->eeprom = NULL;
242  }
243 
244  if (ftdi->usb_ctx)
245  {
246  libusb_exit(ftdi->usb_ctx);
247  ftdi->usb_ctx = NULL;
248  }
249 }
250 
256 void ftdi_free(struct ftdi_context *ftdi)
257 {
258  ftdi_deinit(ftdi);
259  free(ftdi);
260 }
261 
268 void ftdi_set_usbdev (struct ftdi_context *ftdi, libusb_device_handle *usb)
269 {
270  if (ftdi == NULL)
271  return;
272 
273  ftdi->usb_dev = usb;
274 }
275 
282 {
283  struct ftdi_version_info ver;
284 
290 
291  return ver;
292 }
293 
310 int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
311 {
312  struct ftdi_device_list **curdev;
313  libusb_device *dev;
314  libusb_device **devs;
315  int count = 0;
316  int i = 0;
317 
318  if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
319  ftdi_error_return(-5, "libusb_get_device_list() failed");
320 
321  curdev = devlist;
322  *curdev = NULL;
323 
324  while ((dev = devs[i++]) != NULL)
325  {
326  struct libusb_device_descriptor desc;
327 
328  if (libusb_get_device_descriptor(dev, &desc) < 0)
329  ftdi_error_return_free_device_list(-6, "libusb_get_device_descriptor() failed", devs);
330 
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)))
336  {
337  *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
338  if (!*curdev)
339  ftdi_error_return_free_device_list(-3, "out of memory", devs);
340 
341  (*curdev)->next = NULL;
342  (*curdev)->dev = dev;
343  libusb_ref_device(dev);
344  curdev = &(*curdev)->next;
345  count++;
346  }
347  }
348  libusb_free_device_list(devs,1);
349  return count;
350 }
351 
357 void ftdi_list_free(struct ftdi_device_list **devlist)
358 {
359  struct ftdi_device_list *curdev, *next;
360 
361  for (curdev = *devlist; curdev != NULL;)
362  {
363  next = curdev->next;
364  libusb_unref_device(curdev->dev);
365  free(curdev);
366  curdev = next;
367  }
368 
369  *devlist = NULL;
370 }
371 
377 void ftdi_list_free2(struct ftdi_device_list *devlist)
378 {
379  ftdi_list_free(&devlist);
380 }
381 
408 int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct libusb_device * dev,
409  char * manufacturer, int mnf_len, char * description, int desc_len, char * serial, int serial_len)
410 {
411  struct libusb_device_descriptor desc;
412 
413  if ((ftdi==NULL) || (dev==NULL))
414  return -1;
415 
416  if (libusb_open(dev, &ftdi->usb_dev) < 0)
417  ftdi_error_return(-4, "libusb_open() failed");
418 
419  if (libusb_get_device_descriptor(dev, &desc) < 0)
420  ftdi_error_return(-11, "libusb_get_device_descriptor() failed");
421 
422  if (manufacturer != NULL)
423  {
424  if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iManufacturer, (unsigned char *)manufacturer, mnf_len) < 0)
425  {
426  ftdi_usb_close_internal (ftdi);
427  ftdi_error_return(-7, "libusb_get_string_descriptor_ascii() failed");
428  }
429  }
430 
431  if (description != NULL)
432  {
433  if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)description, desc_len) < 0)
434  {
435  ftdi_usb_close_internal (ftdi);
436  ftdi_error_return(-8, "libusb_get_string_descriptor_ascii() failed");
437  }
438  }
439 
440  if (serial != NULL)
441  {
442  if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)serial, serial_len) < 0)
443  {
444  ftdi_usb_close_internal (ftdi);
445  ftdi_error_return(-9, "libusb_get_string_descriptor_ascii() failed");
446  }
447  }
448 
449  ftdi_usb_close_internal (ftdi);
450 
451  return 0;
452 }
453 
460 static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, libusb_device *dev)
461 {
462  struct libusb_device_descriptor desc;
463  struct libusb_config_descriptor *config0;
464  unsigned int packet_size;
465 
466  // Sanity check
467  if (ftdi == NULL || dev == NULL)
468  return 64;
469 
470  // Determine maximum packet size. Init with default value.
471  // New hi-speed devices from FTDI use a packet size of 512 bytes
472  // but could be connected to a normal speed USB hub -> 64 bytes packet size.
473  if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H || ftdi->type == TYPE_230X)
474  packet_size = 512;
475  else
476  packet_size = 64;
477 
478  if (libusb_get_device_descriptor(dev, &desc) < 0)
479  return packet_size;
480 
481  if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
482  return packet_size;
483 
484  if (desc.bNumConfigurations > 0)
485  {
486  if (ftdi->interface < config0->bNumInterfaces)
487  {
488  struct libusb_interface interface = config0->interface[ftdi->interface];
489  if (interface.num_altsetting > 0)
490  {
491  struct libusb_interface_descriptor descriptor = interface.altsetting[0];
492  if (descriptor.bNumEndpoints > 0)
493  {
494  packet_size = descriptor.endpoint[0].wMaxPacketSize;
495  }
496  }
497  }
498  }
499 
500  libusb_free_config_descriptor (config0);
501  return packet_size;
502 }
503 
522 int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev)
523 {
524  struct libusb_device_descriptor desc;
525  struct libusb_config_descriptor *config0;
526  int cfg, cfg0, detach_errno = 0;
527 
528  if (ftdi == NULL)
529  ftdi_error_return(-8, "ftdi context invalid");
530 
531  if (libusb_open(dev, &ftdi->usb_dev) < 0)
532  ftdi_error_return(-4, "libusb_open() failed");
533 
534  if (libusb_get_device_descriptor(dev, &desc) < 0)
535  ftdi_error_return(-9, "libusb_get_device_descriptor() failed");
536 
537  if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
538  ftdi_error_return(-10, "libusb_get_config_descriptor() failed");
539  cfg0 = config0->bConfigurationValue;
540  libusb_free_config_descriptor (config0);
541 
542  // Try to detach ftdi_sio kernel module.
543  //
544  // The return code is kept in a separate variable and only parsed
545  // if usb_set_configuration() or usb_claim_interface() fails as the
546  // detach operation might be denied and everything still works fine.
547  // Likely scenario is a static ftdi_sio kernel module.
549  {
550  if (libusb_detach_kernel_driver(ftdi->usb_dev, ftdi->interface) !=0)
551  detach_errno = errno;
552  }
553 
554  if (libusb_get_configuration (ftdi->usb_dev, &cfg) < 0)
555  ftdi_error_return(-12, "libusb_get_configuration () failed");
556  // set configuration (needed especially for windows)
557  // tolerate EBUSY: one device with one configuration, but two interfaces
558  // and libftdi sessions to both interfaces (e.g. FT2232)
559  if (desc.bNumConfigurations > 0 && cfg != cfg0)
560  {
561  if (libusb_set_configuration(ftdi->usb_dev, cfg0) < 0)
562  {
563  ftdi_usb_close_internal (ftdi);
564  if (detach_errno == EPERM)
565  {
566  ftdi_error_return(-8, "inappropriate permissions on device!");
567  }
568  else
569  {
570  ftdi_error_return(-3, "unable to set usb configuration. Make sure the default FTDI driver is not in use");
571  }
572  }
573  }
574 
575  if (libusb_claim_interface(ftdi->usb_dev, ftdi->interface) < 0)
576  {
577  ftdi_usb_close_internal (ftdi);
578  if (detach_errno == EPERM)
579  {
580  ftdi_error_return(-8, "inappropriate permissions on device!");
581  }
582  else
583  {
584  ftdi_error_return(-5, "unable to claim usb device. Make sure the default FTDI driver is not in use");
585  }
586  }
587 
588  if (ftdi_usb_reset (ftdi) != 0)
589  {
590  ftdi_usb_close_internal (ftdi);
591  ftdi_error_return(-6, "ftdi_usb_reset failed");
592  }
593 
594  // Try to guess chip type
595  // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
596  if (desc.bcdDevice == 0x400 || (desc.bcdDevice == 0x200
597  && desc.iSerialNumber == 0))
598  ftdi->type = TYPE_BM;
599  else if (desc.bcdDevice == 0x200)
600  ftdi->type = TYPE_AM;
601  else if (desc.bcdDevice == 0x500)
602  ftdi->type = TYPE_2232C;
603  else if (desc.bcdDevice == 0x600)
604  ftdi->type = TYPE_R;
605  else if (desc.bcdDevice == 0x700)
606  ftdi->type = TYPE_2232H;
607  else if (desc.bcdDevice == 0x800)
608  ftdi->type = TYPE_4232H;
609  else if (desc.bcdDevice == 0x900)
610  ftdi->type = TYPE_232H;
611  else if (desc.bcdDevice == 0x1000)
612  ftdi->type = TYPE_230X;
613 
614  // Determine maximum packet size
615  ftdi->max_packet_size = _ftdi_determine_max_packet_size(ftdi, dev);
616 
617  if (ftdi_set_baudrate (ftdi, 9600) != 0)
618  {
619  ftdi_usb_close_internal (ftdi);
620  ftdi_error_return(-7, "set baudrate failed");
621  }
622 
623  ftdi_error_return(0, "all fine");
624 }
625 
635 int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
636 {
637  return ftdi_usb_open_desc(ftdi, vendor, product, NULL, NULL);
638 }
639 
661 int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
662  const char* description, const char* serial)
663 {
664  return ftdi_usb_open_desc_index(ftdi,vendor,product,description,serial,0);
665 }
666 
691 int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product,
692  const char* description, const char* serial, unsigned int index)
693 {
694  libusb_device *dev;
695  libusb_device **devs;
696  char string[256];
697  int i = 0;
698 
699  if (ftdi == NULL)
700  ftdi_error_return(-11, "ftdi context invalid");
701 
702  if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
703  ftdi_error_return(-12, "libusb_get_device_list() failed");
704 
705  while ((dev = devs[i++]) != NULL)
706  {
707  struct libusb_device_descriptor desc;
708  int res;
709 
710  if (libusb_get_device_descriptor(dev, &desc) < 0)
711  ftdi_error_return_free_device_list(-13, "libusb_get_device_descriptor() failed", devs);
712 
713  if (desc.idVendor == vendor && desc.idProduct == product)
714  {
715  if (libusb_open(dev, &ftdi->usb_dev) < 0)
716  ftdi_error_return_free_device_list(-4, "usb_open() failed", devs);
717 
718  if (description != NULL)
719  {
720  if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)string, sizeof(string)) < 0)
721  {
722  ftdi_usb_close_internal (ftdi);
723  ftdi_error_return_free_device_list(-8, "unable to fetch product description", devs);
724  }
725  if (strncmp(string, description, sizeof(string)) != 0)
726  {
727  ftdi_usb_close_internal (ftdi);
728  continue;
729  }
730  }
731  if (serial != NULL)
732  {
733  if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)string, sizeof(string)) < 0)
734  {
735  ftdi_usb_close_internal (ftdi);
736  ftdi_error_return_free_device_list(-9, "unable to fetch serial number", devs);
737  }
738  if (strncmp(string, serial, sizeof(string)) != 0)
739  {
740  ftdi_usb_close_internal (ftdi);
741  continue;
742  }
743  }
744 
745  ftdi_usb_close_internal (ftdi);
746 
747  if (index > 0)
748  {
749  index--;
750  continue;
751  }
752 
753  res = ftdi_usb_open_dev(ftdi, dev);
754  libusb_free_device_list(devs,1);
755  return res;
756  }
757  }
758 
759  // device not found
760  ftdi_error_return_free_device_list(-3, "device not found", devs);
761 }
762 
789 int ftdi_usb_open_string(struct ftdi_context *ftdi, const char* description)
790 {
791  if (ftdi == NULL)
792  ftdi_error_return(-12, "ftdi context invalid");
793 
794  if (description[0] == 0 || description[1] != ':')
795  ftdi_error_return(-11, "illegal description format");
796 
797  if (description[0] == 'd')
798  {
799  libusb_device *dev;
800  libusb_device **devs;
801  unsigned int bus_number, device_address;
802  int i = 0;
803 
804  if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
805  ftdi_error_return(-2, "libusb_get_device_list() failed");
806 
807  /* XXX: This doesn't handle symlinks/odd paths/etc... */
808  if (sscanf (description + 2, "%u/%u", &bus_number, &device_address) != 2)
809  ftdi_error_return_free_device_list(-11, "illegal description format", devs);
810 
811  while ((dev = devs[i++]) != NULL)
812  {
813  int ret;
814  if (bus_number == libusb_get_bus_number (dev)
815  && device_address == libusb_get_device_address (dev))
816  {
817  ret = ftdi_usb_open_dev(ftdi, dev);
818  libusb_free_device_list(devs,1);
819  return ret;
820  }
821  }
822 
823  // device not found
824  ftdi_error_return_free_device_list(-3, "device not found", devs);
825  }
826  else if (description[0] == 'i' || description[0] == 's')
827  {
828  unsigned int vendor;
829  unsigned int product;
830  unsigned int index=0;
831  const char *serial=NULL;
832  const char *startp, *endp;
833 
834  errno=0;
835  startp=description+2;
836  vendor=strtoul((char*)startp,(char**)&endp,0);
837  if (*endp != ':' || endp == startp || errno != 0)
838  ftdi_error_return(-11, "illegal description format");
839 
840  startp=endp+1;
841  product=strtoul((char*)startp,(char**)&endp,0);
842  if (endp == startp || errno != 0)
843  ftdi_error_return(-11, "illegal description format");
844 
845  if (description[0] == 'i' && *endp != 0)
846  {
847  /* optional index field in i-mode */
848  if (*endp != ':')
849  ftdi_error_return(-11, "illegal description format");
850 
851  startp=endp+1;
852  index=strtoul((char*)startp,(char**)&endp,0);
853  if (*endp != 0 || endp == startp || errno != 0)
854  ftdi_error_return(-11, "illegal description format");
855  }
856  if (description[0] == 's')
857  {
858  if (*endp != ':')
859  ftdi_error_return(-11, "illegal description format");
860 
861  /* rest of the description is the serial */
862  serial=endp+1;
863  }
864 
865  return ftdi_usb_open_desc_index(ftdi, vendor, product, NULL, serial, index);
866  }
867  else
868  {
869  ftdi_error_return(-11, "illegal description format");
870  }
871 }
872 
882 int ftdi_usb_reset(struct ftdi_context *ftdi)
883 {
884  if (ftdi == NULL || ftdi->usb_dev == NULL)
885  ftdi_error_return(-2, "USB device unavailable");
886 
887  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
889  ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
890  ftdi_error_return(-1,"FTDI reset failed");
891 
892  // Invalidate data in the readbuffer
893  ftdi->readbuffer_offset = 0;
894  ftdi->readbuffer_remaining = 0;
895 
896  return 0;
897 }
898 
909 {
910  if (ftdi == NULL || ftdi->usb_dev == NULL)
911  ftdi_error_return(-2, "USB device unavailable");
912 
913  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
915  ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
916  ftdi_error_return(-1, "FTDI purge of RX buffer failed");
917 
918  // Invalidate data in the readbuffer
919  ftdi->readbuffer_offset = 0;
920  ftdi->readbuffer_remaining = 0;
921 
922  return 0;
923 }
924 
935 {
936  if (ftdi == NULL || ftdi->usb_dev == NULL)
937  ftdi_error_return(-2, "USB device unavailable");
938 
939  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
941  ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
942  ftdi_error_return(-1, "FTDI purge of TX buffer failed");
943 
944  return 0;
945 }
946 
958 {
959  int result;
960 
961  if (ftdi == NULL || ftdi->usb_dev == NULL)
962  ftdi_error_return(-3, "USB device unavailable");
963 
964  result = ftdi_usb_purge_rx_buffer(ftdi);
965  if (result < 0)
966  return -1;
967 
968  result = ftdi_usb_purge_tx_buffer(ftdi);
969  if (result < 0)
970  return -2;
971 
972  return 0;
973 }
974 
975 
976 
986 int ftdi_usb_close(struct ftdi_context *ftdi)
987 {
988  int rtn = 0;
989 
990  if (ftdi == NULL)
991  ftdi_error_return(-3, "ftdi context invalid");
992 
993  if (ftdi->usb_dev != NULL)
994  if (libusb_release_interface(ftdi->usb_dev, ftdi->interface) < 0)
995  rtn = -1;
996 
997  ftdi_usb_close_internal (ftdi);
998 
999  return rtn;
1000 }
1001 
1002 /* ftdi_to_clkbits_AM For the AM device, convert a requested baudrate
1003  to encoded divisor and the achievable baudrate
1004  Function is only used internally
1005  \internal
1006 
1007  See AN120
1008  clk/1 -> 0
1009  clk/1.5 -> 1
1010  clk/2 -> 2
1011  From /2, 0.125/ 0.25 and 0.5 steps may be taken
1012  The fractional part has frac_code encoding
1013 */
1014 static int ftdi_to_clkbits_AM(int baudrate, unsigned long *encoded_divisor)
1015 
1016 {
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;
1022  int i;
1023 
1024  // Round down to supported fraction (AM only)
1025  divisor -= am_adjust_dn[divisor & 7];
1026 
1027  // Try this divisor and the one above it (because division rounds down)
1028  best_divisor = 0;
1029  best_baud = 0;
1030  best_baud_diff = 0;
1031  for (i = 0; i < 2; i++)
1032  {
1033  int try_divisor = divisor + i;
1034  int baud_estimate;
1035  int baud_diff;
1036 
1037  // Round up to supported divisor value
1038  if (try_divisor <= 8)
1039  {
1040  // Round up to minimum supported divisor
1041  try_divisor = 8;
1042  }
1043  else if (divisor < 16)
1044  {
1045  // AM doesn't support divisors 9 through 15 inclusive
1046  try_divisor = 16;
1047  }
1048  else
1049  {
1050  // Round up to supported fraction (AM only)
1051  try_divisor += am_adjust_up[try_divisor & 7];
1052  if (try_divisor > 0x1FFF8)
1053  {
1054  // Round down to maximum supported divisor value (for AM)
1055  try_divisor = 0x1FFF8;
1056  }
1057  }
1058  // Get estimated baud rate (to nearest integer)
1059  baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
1060  // Get absolute difference from requested baud rate
1061  if (baud_estimate < baudrate)
1062  {
1063  baud_diff = baudrate - baud_estimate;
1064  }
1065  else
1066  {
1067  baud_diff = baud_estimate - baudrate;
1068  }
1069  if (i == 0 || baud_diff < best_baud_diff)
1070  {
1071  // Closest to requested baud rate so far
1072  best_divisor = try_divisor;
1073  best_baud = baud_estimate;
1074  best_baud_diff = baud_diff;
1075  if (baud_diff == 0)
1076  {
1077  // Spot on! No point trying
1078  break;
1079  }
1080  }
1081  }
1082  // Encode the best divisor value
1083  *encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
1084  // Deal with special cases for encoded value
1085  if (*encoded_divisor == 1)
1086  {
1087  *encoded_divisor = 0; // 3000000 baud
1088  }
1089  else if (*encoded_divisor == 0x4001)
1090  {
1091  *encoded_divisor = 1; // 2000000 baud (BM only)
1092  }
1093  return best_baud;
1094 }
1095 
1096 /* ftdi_to_clkbits Convert a requested baudrate for a given system clock and predivisor
1097  to encoded divisor and the achievable baudrate
1098  Function is only used internally
1099  \internal
1100 
1101  See AN120
1102  clk/1 -> 0
1103  clk/1.5 -> 1
1104  clk/2 -> 2
1105  From /2, 0.125 steps may be taken.
1106  The fractional part has frac_code encoding
1107 
1108  value[13:0] of value is the divisor
1109  index[9] mean 12 MHz Base(120 MHz/10) rate versus 3 MHz (48 MHz/16) else
1110 
1111  H Type have all features above with
1112  {index[8],value[15:14]} is the encoded subdivisor
1113 
1114  FT232R, FT2232 and FT232BM have no option for 12 MHz and with
1115  {index[0],value[15:14]} is the encoded subdivisor
1116 
1117  AM Type chips have only four fractional subdivisors at value[15:14]
1118  for subdivisors 0, 0.5, 0.25, 0.125
1119 */
1120 static int ftdi_to_clkbits(int baudrate, unsigned int clk, int clk_div, unsigned long *encoded_divisor)
1121 {
1122  static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
1123  int best_baud = 0;
1124  int divisor, best_divisor;
1125  if (baudrate >= clk/clk_div)
1126  {
1127  *encoded_divisor = 0;
1128  best_baud = clk/clk_div;
1129  }
1130  else if (baudrate >= clk/(clk_div + clk_div/2))
1131  {
1132  *encoded_divisor = 1;
1133  best_baud = clk/(clk_div + clk_div/2);
1134  }
1135  else if (baudrate >= clk/(2*clk_div))
1136  {
1137  *encoded_divisor = 2;
1138  best_baud = clk/(2*clk_div);
1139  }
1140  else
1141  {
1142  /* We divide by 16 to have 3 fractional bits and one bit for rounding */
1143  divisor = clk*16/clk_div / baudrate;
1144  if (divisor & 1) /* Decide if to round up or down*/
1145  best_divisor = divisor /2 +1;
1146  else
1147  best_divisor = divisor/2;
1148  if(best_divisor > 0x20000)
1149  best_divisor = 0x1ffff;
1150  best_baud = clk*16/clk_div/best_divisor;
1151  if (best_baud & 1) /* Decide if to round up or down*/
1152  best_baud = best_baud /2 +1;
1153  else
1154  best_baud = best_baud /2;
1155  *encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 0x7] << 14);
1156  }
1157  return best_baud;
1158 }
1164 static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
1165  unsigned short *value, unsigned short *index)
1166 {
1167  int best_baud;
1168  unsigned long encoded_divisor;
1169 
1170  if (baudrate <= 0)
1171  {
1172  // Return error
1173  return -1;
1174  }
1175 
1176 #define H_CLK 120000000
1177 #define C_CLK 48000000
1178  if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H) || (ftdi->type == TYPE_232H) || (ftdi->type == TYPE_230X))
1179  {
1180  if(baudrate*10 > H_CLK /0x3fff)
1181  {
1182  /* On H Devices, use 12 000 000 Baudrate when possible
1183  We have a 14 bit divisor, a 1 bit divisor switch (10 or 16)
1184  three fractional bits and a 120 MHz clock
1185  Assume AN_120 "Sub-integer divisors between 0 and 2 are not allowed" holds for
1186  DIV/10 CLK too, so /1, /1.5 and /2 can be handled the same*/
1187  best_baud = ftdi_to_clkbits(baudrate, H_CLK, 10, &encoded_divisor);
1188  encoded_divisor |= 0x20000; /* switch on CLK/10*/
1189  }
1190  else
1191  best_baud = ftdi_to_clkbits(baudrate, C_CLK, 16, &encoded_divisor);
1192  }
1193  else if ((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C) || (ftdi->type == TYPE_R ))
1194  {
1195  best_baud = ftdi_to_clkbits(baudrate, C_CLK, 16, &encoded_divisor);
1196  }
1197  else
1198  {
1199  best_baud = ftdi_to_clkbits_AM(baudrate, &encoded_divisor);
1200  }
1201  // Split into "value" and "index" values
1202  *value = (unsigned short)(encoded_divisor & 0xFFFF);
1203  if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H || ftdi->type == TYPE_230X)
1204  {
1205  *index = (unsigned short)(encoded_divisor >> 8);
1206  *index &= 0xFF00;
1207  *index |= ftdi->index;
1208  }
1209  else
1210  *index = (unsigned short)(encoded_divisor >> 16);
1211 
1212  // Return the nearest baud rate
1213  return best_baud;
1214 }
1215 
1220 int convert_baudrate_UT_export(int baudrate, struct ftdi_context *ftdi,
1221  unsigned short *value, unsigned short *index)
1222 {
1223  return ftdi_convert_baudrate(baudrate, ftdi, value, index);
1224 }
1225 
1237 int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
1238 {
1239  unsigned short value, index;
1240  int actual_baudrate;
1241 
1242  if (ftdi == NULL || ftdi->usb_dev == NULL)
1243  ftdi_error_return(-3, "USB device unavailable");
1244 
1245  if (ftdi->bitbang_enabled)
1246  {
1247  baudrate = baudrate*4;
1248  }
1249 
1250  actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
1251  if (actual_baudrate <= 0)
1252  ftdi_error_return (-1, "Silly baudrate <= 0.");
1253 
1254  // Check within tolerance (about 5%)
1255  if ((actual_baudrate * 2 < baudrate /* Catch overflows */ )
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");
1260 
1261  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1262  SIO_SET_BAUDRATE_REQUEST, value,
1263  index, NULL, 0, ftdi->usb_write_timeout) < 0)
1264  ftdi_error_return (-2, "Setting new baudrate failed");
1265 
1266  ftdi->baudrate = baudrate;
1267  return 0;
1268 }
1269 
1284  enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
1285 {
1286  return ftdi_set_line_property2(ftdi, bits, sbit, parity, BREAK_OFF);
1287 }
1288 
1303  enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity,
1304  enum ftdi_break_type break_type)
1305 {
1306  unsigned short value = bits;
1307 
1308  if (ftdi == NULL || ftdi->usb_dev == NULL)
1309  ftdi_error_return(-2, "USB device unavailable");
1310 
1311  switch (parity)
1312  {
1313  case NONE:
1314  value |= (0x00 << 8);
1315  break;
1316  case ODD:
1317  value |= (0x01 << 8);
1318  break;
1319  case EVEN:
1320  value |= (0x02 << 8);
1321  break;
1322  case MARK:
1323  value |= (0x03 << 8);
1324  break;
1325  case SPACE:
1326  value |= (0x04 << 8);
1327  break;
1328  }
1329 
1330  switch (sbit)
1331  {
1332  case STOP_BIT_1:
1333  value |= (0x00 << 11);
1334  break;
1335  case STOP_BIT_15:
1336  value |= (0x01 << 11);
1337  break;
1338  case STOP_BIT_2:
1339  value |= (0x02 << 11);
1340  break;
1341  }
1342 
1343  switch (break_type)
1344  {
1345  case BREAK_OFF:
1346  value |= (0x00 << 14);
1347  break;
1348  case BREAK_ON:
1349  value |= (0x01 << 14);
1350  break;
1351  }
1352 
1353  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1354  SIO_SET_DATA_REQUEST, value,
1355  ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1356  ftdi_error_return (-1, "Setting new line property failed");
1357 
1358  return 0;
1359 }
1360 
1372 int ftdi_write_data(struct ftdi_context *ftdi, const unsigned char *buf, int size)
1373 {
1374  int offset = 0;
1375  int actual_length;
1376 
1377  if (ftdi == NULL || ftdi->usb_dev == NULL)
1378  ftdi_error_return(-666, "USB device unavailable");
1379 
1380  while (offset < size)
1381  {
1382  int write_size = ftdi->writebuffer_chunksize;
1383 
1384  if (offset+write_size > size)
1385  write_size = size-offset;
1386 
1387  if (libusb_bulk_transfer(ftdi->usb_dev, ftdi->in_ep, (unsigned char *)buf+offset, write_size, &actual_length, ftdi->usb_write_timeout) < 0)
1388  ftdi_error_return(-1, "usb bulk write failed");
1389 
1390  offset += actual_length;
1391  }
1392 
1393  return offset;
1394 }
1395 
1396 static void ftdi_read_data_cb(struct libusb_transfer *transfer)
1397 {
1398  struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1399  struct ftdi_context *ftdi = tc->ftdi;
1400  int packet_size, actual_length, num_of_chunks, chunk_remains, i, ret;
1401 
1402  packet_size = ftdi->max_packet_size;
1403 
1404  actual_length = transfer->actual_length;
1405 
1406  if (actual_length > 2)
1407  {
1408  // skip FTDI status bytes.
1409  // Maybe stored in the future to enable modem use
1410  num_of_chunks = actual_length / packet_size;
1411  chunk_remains = actual_length % packet_size;
1412  //printf("actual_length = %X, num_of_chunks = %X, chunk_remains = %X, readbuffer_offset = %X\n", actual_length, num_of_chunks, chunk_remains, ftdi->readbuffer_offset);
1413 
1414  ftdi->readbuffer_offset += 2;
1415  actual_length -= 2;
1416 
1417  if (actual_length > packet_size - 2)
1418  {
1419  for (i = 1; i < num_of_chunks; i++)
1420  memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1421  ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1422  packet_size - 2);
1423  if (chunk_remains > 2)
1424  {
1425  memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1426  ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1427  chunk_remains-2);
1428  actual_length -= 2*num_of_chunks;
1429  }
1430  else
1431  actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1432  }
1433 
1434  if (actual_length > 0)
1435  {
1436  // data still fits in buf?
1437  if (tc->offset + actual_length <= tc->size)
1438  {
1439  memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, actual_length);
1440  //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1441  tc->offset += actual_length;
1442 
1443  ftdi->readbuffer_offset = 0;
1444  ftdi->readbuffer_remaining = 0;
1445 
1446  /* Did we read exactly the right amount of bytes? */
1447  if (tc->offset == tc->size)
1448  {
1449  //printf("read_data exact rem %d offset %d\n",
1450  //ftdi->readbuffer_remaining, offset);
1451  tc->completed = 1;
1452  return;
1453  }
1454  }
1455  else
1456  {
1457  // only copy part of the data or size <= readbuffer_chunksize
1458  int part_size = tc->size - tc->offset;
1459  memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, part_size);
1460  tc->offset += part_size;
1461 
1462  ftdi->readbuffer_offset += part_size;
1463  ftdi->readbuffer_remaining = actual_length - part_size;
1464 
1465  /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1466  part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
1467  tc->completed = 1;
1468  return;
1469  }
1470  }
1471  }
1472  ret = libusb_submit_transfer (transfer);
1473  if (ret < 0)
1474  tc->completed = 1;
1475 }
1476 
1477 
1478 static void ftdi_write_data_cb(struct libusb_transfer *transfer)
1479 {
1480  struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1481  struct ftdi_context *ftdi = tc->ftdi;
1482 
1483  tc->offset += transfer->actual_length;
1484 
1485  if (tc->offset == tc->size)
1486  {
1487  tc->completed = 1;
1488  }
1489  else
1490  {
1491  int write_size = ftdi->writebuffer_chunksize;
1492  int ret;
1493 
1494  if (tc->offset + write_size > tc->size)
1495  write_size = tc->size - tc->offset;
1496 
1497  transfer->length = write_size;
1498  transfer->buffer = tc->buf + tc->offset;
1499  ret = libusb_submit_transfer (transfer);
1500  if (ret < 0)
1501  tc->completed = 1;
1502  }
1503 }
1504 
1505 
1520 struct ftdi_transfer_control *ftdi_write_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
1521 {
1522  struct ftdi_transfer_control *tc;
1523  struct libusb_transfer *transfer;
1524  int write_size, ret;
1525 
1526  if (ftdi == NULL || ftdi->usb_dev == NULL)
1527  return NULL;
1528 
1529  tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
1530  if (!tc)
1531  return NULL;
1532 
1533  transfer = libusb_alloc_transfer(0);
1534  if (!transfer)
1535  {
1536  free(tc);
1537  return NULL;
1538  }
1539 
1540  tc->ftdi = ftdi;
1541  tc->completed = 0;
1542  tc->buf = buf;
1543  tc->size = size;
1544  tc->offset = 0;
1545 
1546  if (size < (int)ftdi->writebuffer_chunksize)
1547  write_size = size;
1548  else
1549  write_size = ftdi->writebuffer_chunksize;
1550 
1551  libusb_fill_bulk_transfer(transfer, ftdi->usb_dev, ftdi->in_ep, buf,
1552  write_size, ftdi_write_data_cb, tc,
1553  ftdi->usb_write_timeout);
1554  transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1555 
1556  ret = libusb_submit_transfer(transfer);
1557  if (ret < 0)
1558  {
1559  libusb_free_transfer(transfer);
1560  free(tc);
1561  return NULL;
1562  }
1563  tc->transfer = transfer;
1564 
1565  return tc;
1566 }
1567 
1582 struct ftdi_transfer_control *ftdi_read_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
1583 {
1584  struct ftdi_transfer_control *tc;
1585  struct libusb_transfer *transfer;
1586  int ret;
1587 
1588  if (ftdi == NULL || ftdi->usb_dev == NULL)
1589  return NULL;
1590 
1591  tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
1592  if (!tc)
1593  return NULL;
1594 
1595  tc->ftdi = ftdi;
1596  tc->buf = buf;
1597  tc->size = size;
1598 
1599  if (size <= (int)ftdi->readbuffer_remaining)
1600  {
1601  memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1602 
1603  // Fix offsets
1604  ftdi->readbuffer_remaining -= size;
1605  ftdi->readbuffer_offset += size;
1606 
1607  /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1608 
1609  tc->completed = 1;
1610  tc->offset = size;
1611  tc->transfer = NULL;
1612  return tc;
1613  }
1614 
1615  tc->completed = 0;
1616  if (ftdi->readbuffer_remaining != 0)
1617  {
1618  memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1619 
1620  tc->offset = ftdi->readbuffer_remaining;
1621  }
1622  else
1623  tc->offset = 0;
1624 
1625  transfer = libusb_alloc_transfer(0);
1626  if (!transfer)
1627  {
1628  free (tc);
1629  return NULL;
1630  }
1631 
1632  ftdi->readbuffer_remaining = 0;
1633  ftdi->readbuffer_offset = 0;
1634 
1635  libusb_fill_bulk_transfer(transfer, ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, ftdi_read_data_cb, tc, ftdi->usb_read_timeout);
1636  transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1637 
1638  ret = libusb_submit_transfer(transfer);
1639  if (ret < 0)
1640  {
1641  libusb_free_transfer(transfer);
1642  free (tc);
1643  return NULL;
1644  }
1645  tc->transfer = transfer;
1646 
1647  return tc;
1648 }
1649 
1662 {
1663  int ret;
1664 
1665  while (!tc->completed)
1666  {
1667  ret = libusb_handle_events(tc->ftdi->usb_ctx);
1668  if (ret < 0)
1669  {
1670  if (ret == LIBUSB_ERROR_INTERRUPTED)
1671  continue;
1672  libusb_cancel_transfer(tc->transfer);
1673  while (!tc->completed)
1674  if (libusb_handle_events(tc->ftdi->usb_ctx) < 0)
1675  break;
1676  libusb_free_transfer(tc->transfer);
1677  free (tc);
1678  return ret;
1679  }
1680  }
1681 
1682  ret = tc->offset;
1687  if (tc->transfer)
1688  {
1689  if (tc->transfer->status != LIBUSB_TRANSFER_COMPLETED)
1690  ret = -1;
1691  libusb_free_transfer(tc->transfer);
1692  }
1693  free(tc);
1694  return ret;
1695 }
1696 
1707 int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1708 {
1709  if (ftdi == NULL)
1710  ftdi_error_return(-1, "ftdi context invalid");
1711 
1712  ftdi->writebuffer_chunksize = chunksize;
1713  return 0;
1714 }
1715 
1725 int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1726 {
1727  if (ftdi == NULL)
1728  ftdi_error_return(-1, "ftdi context invalid");
1729 
1730  *chunksize = ftdi->writebuffer_chunksize;
1731  return 0;
1732 }
1733 
1749 int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1750 {
1751  int offset = 0, ret, i, num_of_chunks, chunk_remains;
1752  int packet_size = ftdi->max_packet_size;
1753  int actual_length = 1;
1754 
1755  if (ftdi == NULL || ftdi->usb_dev == NULL)
1756  ftdi_error_return(-666, "USB device unavailable");
1757 
1758  // Packet size sanity check (avoid division by zero)
1759  if (packet_size == 0)
1760  ftdi_error_return(-1, "max_packet_size is bogus (zero)");
1761 
1762  // everything we want is still in the readbuffer?
1763  if (size <= (int)ftdi->readbuffer_remaining)
1764  {
1765  memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1766 
1767  // Fix offsets
1768  ftdi->readbuffer_remaining -= size;
1769  ftdi->readbuffer_offset += size;
1770 
1771  /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1772 
1773  return size;
1774  }
1775  // something still in the readbuffer, but not enough to satisfy 'size'?
1776  if (ftdi->readbuffer_remaining != 0)
1777  {
1778  memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1779 
1780  // Fix offset
1781  offset += ftdi->readbuffer_remaining;
1782  }
1783  // do the actual USB read
1784  while (offset < size && actual_length > 0)
1785  {
1786  ftdi->readbuffer_remaining = 0;
1787  ftdi->readbuffer_offset = 0;
1788  /* returns how much received */
1789  ret = libusb_bulk_transfer (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, &actual_length, ftdi->usb_read_timeout);
1790  if (ret < 0)
1791  ftdi_error_return(ret, "usb bulk read failed");
1792 
1793  if (actual_length > 2)
1794  {
1795  // skip FTDI status bytes.
1796  // Maybe stored in the future to enable modem use
1797  num_of_chunks = actual_length / packet_size;
1798  chunk_remains = actual_length % packet_size;
1799  //printf("actual_length = %X, num_of_chunks = %X, chunk_remains = %X, readbuffer_offset = %X\n", actual_length, num_of_chunks, chunk_remains, ftdi->readbuffer_offset);
1800 
1801  ftdi->readbuffer_offset += 2;
1802  actual_length -= 2;
1803 
1804  if (actual_length > packet_size - 2)
1805  {
1806  for (i = 1; i < num_of_chunks; i++)
1807  memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1808  ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1809  packet_size - 2);
1810  if (chunk_remains > 2)
1811  {
1812  memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1813  ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1814  chunk_remains-2);
1815  actual_length -= 2*num_of_chunks;
1816  }
1817  else
1818  actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1819  }
1820  }
1821  else if (actual_length <= 2)
1822  {
1823  // no more data to read?
1824  return offset;
1825  }
1826  if (actual_length > 0)
1827  {
1828  // data still fits in buf?
1829  if (offset+actual_length <= size)
1830  {
1831  memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, actual_length);
1832  //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1833  offset += actual_length;
1834 
1835  /* Did we read exactly the right amount of bytes? */
1836  if (offset == size)
1837  //printf("read_data exact rem %d offset %d\n",
1838  //ftdi->readbuffer_remaining, offset);
1839  return offset;
1840  }
1841  else
1842  {
1843  // only copy part of the data or size <= readbuffer_chunksize
1844  int part_size = size-offset;
1845  memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
1846 
1847  ftdi->readbuffer_offset += part_size;
1848  ftdi->readbuffer_remaining = actual_length-part_size;
1849  offset += part_size;
1850 
1851  /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1852  part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
1853 
1854  return offset;
1855  }
1856  }
1857  }
1858  // never reached
1859  return -127;
1860 }
1861 
1874 int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1875 {
1876  unsigned char *new_buf;
1877 
1878  if (ftdi == NULL)
1879  ftdi_error_return(-1, "ftdi context invalid");
1880 
1881  // Invalidate all remaining data
1882  ftdi->readbuffer_offset = 0;
1883  ftdi->readbuffer_remaining = 0;
1884 #ifdef __linux__
1885  /* We can't set readbuffer_chunksize larger than MAX_BULK_BUFFER_LENGTH,
1886  which is defined in libusb-1.0. Otherwise, each USB read request will
1887  be divided into multiple URBs. This will cause issues on Linux kernel
1888  older than 2.6.32. */
1889  if (chunksize > 16384)
1890  chunksize = 16384;
1891 #endif
1892 
1893  if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL)
1894  ftdi_error_return(-1, "out of memory for readbuffer");
1895 
1896  ftdi->readbuffer = new_buf;
1897  ftdi->readbuffer_chunksize = chunksize;
1898 
1899  return 0;
1900 }
1901 
1911 int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1912 {
1913  if (ftdi == NULL)
1914  ftdi_error_return(-1, "FTDI context invalid");
1915 
1916  *chunksize = ftdi->readbuffer_chunksize;
1917  return 0;
1918 }
1919 
1932 int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
1933 {
1934  unsigned short usb_val;
1935 
1936  if (ftdi == NULL || ftdi->usb_dev == NULL)
1937  ftdi_error_return(-2, "USB device unavailable");
1938 
1939  usb_val = bitmask; // low byte: bitmask
1940  usb_val |= (mode << 8);
1941  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1942  ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps not a BM/2232C type chip?");
1943 
1944  ftdi->bitbang_mode = mode;
1945  ftdi->bitbang_enabled = (mode == BITMODE_RESET) ? 0 : 1;
1946  return 0;
1947 }
1948 
1959 {
1960  if (ftdi == NULL || ftdi->usb_dev == NULL)
1961  ftdi_error_return(-2, "USB device unavailable");
1962 
1963  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_BITMODE_REQUEST, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1964  ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?");
1965 
1966  ftdi->bitbang_enabled = 0;
1967  return 0;
1968 }
1969 
1970 
1981 int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
1982 {
1983  if (ftdi == NULL || ftdi->usb_dev == NULL)
1984  ftdi_error_return(-2, "USB device unavailable");
1985 
1986  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_PINS_REQUEST, 0, ftdi->index, (unsigned char *)pins, 1, ftdi->usb_read_timeout) != 1)
1987  ftdi_error_return(-1, "read pins failed");
1988 
1989  return 0;
1990 }
1991 
2007 int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
2008 {
2009  unsigned short usb_val;
2010 
2011  if (latency < 1)
2012  ftdi_error_return(-1, "latency out of range. Only valid for 1-255");
2013 
2014  if (ftdi == NULL || ftdi->usb_dev == NULL)
2015  ftdi_error_return(-3, "USB device unavailable");
2016 
2017  usb_val = latency;
2018  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_LATENCY_TIMER_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
2019  ftdi_error_return(-2, "unable to set latency timer");
2020 
2021  return 0;
2022 }
2023 
2034 int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
2035 {
2036  unsigned short usb_val;
2037 
2038  if (ftdi == NULL || ftdi->usb_dev == NULL)
2039  ftdi_error_return(-2, "USB device unavailable");
2040 
2041  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_GET_LATENCY_TIMER_REQUEST, 0, ftdi->index, (unsigned char *)&usb_val, 1, ftdi->usb_read_timeout) != 1)
2042  ftdi_error_return(-1, "reading latency timer failed");
2043 
2044  *latency = (unsigned char)usb_val;
2045  return 0;
2046 }
2047 
2088 int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
2089 {
2090  char usb_val[2];
2091 
2092  if (ftdi == NULL || ftdi->usb_dev == NULL)
2093  ftdi_error_return(-2, "USB device unavailable");
2094 
2095  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_POLL_MODEM_STATUS_REQUEST, 0, ftdi->index, (unsigned char *)usb_val, 2, ftdi->usb_read_timeout) != 2)
2096  ftdi_error_return(-1, "getting modem status failed");
2097 
2098  *status = (usb_val[1] << 8) | (usb_val[0] & 0xFF);
2099 
2100  return 0;
2101 }
2102 
2114 int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
2115 {
2116  if (ftdi == NULL || ftdi->usb_dev == NULL)
2117  ftdi_error_return(-2, "USB device unavailable");
2118 
2119  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2120  SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->index),
2121  NULL, 0, ftdi->usb_write_timeout) < 0)
2122  ftdi_error_return(-1, "set flow control failed");
2123 
2124  return 0;
2125 }
2126 
2137 int ftdi_setdtr(struct ftdi_context *ftdi, int state)
2138 {
2139  unsigned short usb_val;
2140 
2141  if (ftdi == NULL || ftdi->usb_dev == NULL)
2142  ftdi_error_return(-2, "USB device unavailable");
2143 
2144  if (state)
2145  usb_val = SIO_SET_DTR_HIGH;
2146  else
2147  usb_val = SIO_SET_DTR_LOW;
2148 
2149  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2150  SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2151  NULL, 0, ftdi->usb_write_timeout) < 0)
2152  ftdi_error_return(-1, "set dtr failed");
2153 
2154  return 0;
2155 }
2156 
2167 int ftdi_setrts(struct ftdi_context *ftdi, int state)
2168 {
2169  unsigned short usb_val;
2170 
2171  if (ftdi == NULL || ftdi->usb_dev == NULL)
2172  ftdi_error_return(-2, "USB device unavailable");
2173 
2174  if (state)
2175  usb_val = SIO_SET_RTS_HIGH;
2176  else
2177  usb_val = SIO_SET_RTS_LOW;
2178 
2179  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2180  SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2181  NULL, 0, ftdi->usb_write_timeout) < 0)
2182  ftdi_error_return(-1, "set of rts failed");
2183 
2184  return 0;
2185 }
2186 
2198 int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
2199 {
2200  unsigned short usb_val;
2201 
2202  if (ftdi == NULL || ftdi->usb_dev == NULL)
2203  ftdi_error_return(-2, "USB device unavailable");
2204 
2205  if (dtr)
2206  usb_val = SIO_SET_DTR_HIGH;
2207  else
2208  usb_val = SIO_SET_DTR_LOW;
2209 
2210  if (rts)
2211  usb_val |= SIO_SET_RTS_HIGH;
2212  else
2213  usb_val |= SIO_SET_RTS_LOW;
2214 
2215  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2216  SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2217  NULL, 0, ftdi->usb_write_timeout) < 0)
2218  ftdi_error_return(-1, "set of rts/dtr failed");
2219 
2220  return 0;
2221 }
2222 
2235  unsigned char eventch, unsigned char enable)
2236 {
2237  unsigned short usb_val;
2238 
2239  if (ftdi == NULL || ftdi->usb_dev == NULL)
2240  ftdi_error_return(-2, "USB device unavailable");
2241 
2242  usb_val = eventch;
2243  if (enable)
2244  usb_val |= 1 << 8;
2245 
2246  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_EVENT_CHAR_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
2247  ftdi_error_return(-1, "setting event character failed");
2248 
2249  return 0;
2250 }
2251 
2264  unsigned char errorch, unsigned char enable)
2265 {
2266  unsigned short usb_val;
2267 
2268  if (ftdi == NULL || ftdi->usb_dev == NULL)
2269  ftdi_error_return(-2, "USB device unavailable");
2270 
2271  usb_val = errorch;
2272  if (enable)
2273  usb_val |= 1 << 8;
2274 
2275  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_ERROR_CHAR_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
2276  ftdi_error_return(-1, "setting error character failed");
2277 
2278  return 0;
2279 }
2280 
2293 int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer,
2294  char * product, char * serial)
2295 {
2296  struct ftdi_eeprom *eeprom;
2297 
2298  if (ftdi == NULL)
2299  ftdi_error_return(-1, "No struct ftdi_context");
2300 
2301  if (ftdi->eeprom == NULL)
2302  ftdi_error_return(-2,"No struct ftdi_eeprom");
2303 
2304  eeprom = ftdi->eeprom;
2305  memset(eeprom, 0, sizeof(struct ftdi_eeprom));
2306 
2307  if (ftdi->usb_dev == NULL)
2308  ftdi_error_return(-3, "No connected device or device not yet opened");
2309 
2310  eeprom->vendor_id = 0x0403;
2311  eeprom->use_serial = 1;
2312  if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM) ||
2313  (ftdi->type == TYPE_R))
2314  eeprom->product_id = 0x6001;
2315  else if (ftdi->type == TYPE_4232H)
2316  eeprom->product_id = 0x6011;
2317  else if (ftdi->type == TYPE_232H)
2318  eeprom->product_id = 0x6014;
2319  else if (ftdi->type == TYPE_230X)
2320  eeprom->product_id = 0x6015;
2321  else
2322  eeprom->product_id = 0x6010;
2323 
2324  if (ftdi->type == TYPE_AM)
2325  eeprom->usb_version = 0x0101;
2326  else
2327  eeprom->usb_version = 0x0200;
2328  eeprom->max_power = 100;
2329 
2330  if (eeprom->manufacturer)
2331  free (eeprom->manufacturer);
2332  eeprom->manufacturer = NULL;
2333  if (manufacturer)
2334  {
2335  eeprom->manufacturer = malloc(strlen(manufacturer)+1);
2336  if (eeprom->manufacturer)
2337  strcpy(eeprom->manufacturer, manufacturer);
2338  }
2339 
2340  if (eeprom->product)
2341  free (eeprom->product);
2342  eeprom->product = NULL;
2343  if(product)
2344  {
2345  eeprom->product = malloc(strlen(product)+1);
2346  if (eeprom->product)
2347  strcpy(eeprom->product, product);
2348  }
2349  else
2350  {
2351  const char* default_product;
2352  switch(ftdi->type)
2353  {
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;
2362  default:
2363  ftdi_error_return(-3, "Unknown chip type");
2364  }
2365  eeprom->product = malloc(strlen(default_product) +1);
2366  if (eeprom->product)
2367  strcpy(eeprom->product, default_product);
2368  }
2369 
2370  if (eeprom->serial)
2371  free (eeprom->serial);
2372  eeprom->serial = NULL;
2373  if (serial)
2374  {
2375  eeprom->serial = malloc(strlen(serial)+1);
2376  if (eeprom->serial)
2377  strcpy(eeprom->serial, serial);
2378  }
2379 
2380  if (ftdi->type == TYPE_R)
2381  {
2382  eeprom->max_power = 90;
2383  eeprom->size = 0x80;
2384  eeprom->cbus_function[0] = CBUS_TXLED;
2385  eeprom->cbus_function[1] = CBUS_RXLED;
2386  eeprom->cbus_function[2] = CBUS_TXDEN;
2387  eeprom->cbus_function[3] = CBUS_PWREN;
2388  eeprom->cbus_function[4] = CBUS_SLEEP;
2389  }
2390  else if (ftdi->type == TYPE_230X)
2391  {
2392  eeprom->max_power = 90;
2393  eeprom->size = 0x100;
2394  eeprom->cbus_function[0] = CBUSH_TXDEN;
2395  eeprom->cbus_function[1] = CBUSH_RXLED;
2396  eeprom->cbus_function[2] = CBUSH_TXLED;
2397  eeprom->cbus_function[3] = CBUSH_SLEEP;
2398  }
2399  else
2400  {
2401  if(ftdi->type == TYPE_232H)
2402  {
2403  int i;
2404  for (i=0; i<10; i++)
2405  eeprom->cbus_function[i] = CBUSH_TRISTATE;
2406  }
2407  eeprom->size = -1;
2408  }
2409  switch (ftdi->type)
2410  {
2411  case TYPE_AM:
2412  eeprom->release_number = 0x0200;
2413  break;
2414  case TYPE_BM:
2415  eeprom->release_number = 0x0400;
2416  break;
2417  case TYPE_2232C:
2418  eeprom->release_number = 0x0500;
2419  break;
2420  case TYPE_R:
2421  eeprom->release_number = 0x0600;
2422  break;
2423  case TYPE_2232H:
2424  eeprom->release_number = 0x0700;
2425  break;
2426  case TYPE_4232H:
2427  eeprom->release_number = 0x0800;
2428  break;
2429  case TYPE_232H:
2430  eeprom->release_number = 0x0900;
2431  break;
2432  case TYPE_230X:
2433  eeprom->release_number = 0x1000;
2434  break;
2435  default:
2436  eeprom->release_number = 0x00;
2437  }
2438  return 0;
2439 }
2440 
2442  char * product, char * serial)
2443 {
2444  struct ftdi_eeprom *eeprom;
2445 
2446  if (ftdi == NULL)
2447  ftdi_error_return(-1, "No struct ftdi_context");
2448 
2449  if (ftdi->eeprom == NULL)
2450  ftdi_error_return(-2,"No struct ftdi_eeprom");
2451 
2452  eeprom = ftdi->eeprom;
2453 
2454  if (ftdi->usb_dev == NULL)
2455  ftdi_error_return(-3, "No connected device or device not yet opened");
2456 
2457  if (manufacturer)
2458  {
2459  if (eeprom->manufacturer)
2460  free (eeprom->manufacturer);
2461  eeprom->manufacturer = malloc(strlen(manufacturer)+1);
2462  if (eeprom->manufacturer)
2463  strcpy(eeprom->manufacturer, manufacturer);
2464  }
2465 
2466  if(product)
2467  {
2468  if (eeprom->product)
2469  free (eeprom->product);
2470  eeprom->product = malloc(strlen(product)+1);
2471  if (eeprom->product)
2472  strcpy(eeprom->product, product);
2473  }
2474 
2475  if (serial)
2476  {
2477  if (eeprom->serial)
2478  free (eeprom->serial);
2479  eeprom->serial = malloc(strlen(serial)+1);
2480  if (eeprom->serial)
2481  {
2482  strcpy(eeprom->serial, serial);
2483  eeprom->use_serial = 1;
2484  }
2485  }
2486  return 0;
2487 }
2488 
2489 
2490 /*FTD2XX doesn't check for values not fitting in the ACBUS Signal oprtions*/
2491 void set_ft232h_cbus(struct ftdi_eeprom *eeprom, unsigned char * output)
2492 {
2493  int i;
2494  for(i=0; i<5; i++)
2495  {
2496  int mode_low, mode_high;
2497  if (eeprom->cbus_function[2*i]> CBUSH_CLK7_5)
2498  mode_low = CBUSH_TRISTATE;
2499  else
2500  mode_low = eeprom->cbus_function[2*i];
2501  if (eeprom->cbus_function[2*i+1]> CBUSH_CLK7_5)
2502  mode_high = CBUSH_TRISTATE;
2503  else
2504  mode_high = eeprom->cbus_function[2*i+1];
2505 
2506  output[0x18+i] = (mode_high <<4) | mode_low;
2507  }
2508 }
2509 /* Return the bits for the encoded EEPROM Structure of a requested Mode
2510  *
2511  */
2512 static unsigned char type2bit(unsigned char type, enum ftdi_chip_type chip)
2513 {
2514  switch (chip)
2515  {
2516  case TYPE_2232H:
2517  case TYPE_2232C:
2518  {
2519  switch (type)
2520  {
2521  case CHANNEL_IS_UART: return 0;
2522  case CHANNEL_IS_FIFO: return 0x01;
2523  case CHANNEL_IS_OPTO: return 0x02;
2524  case CHANNEL_IS_CPU : return 0x04;
2525  default: return 0;
2526  }
2527  }
2528  case TYPE_232H:
2529  {
2530  switch (type)
2531  {
2532  case CHANNEL_IS_UART : return 0;
2533  case CHANNEL_IS_FIFO : return 0x01;
2534  case CHANNEL_IS_OPTO : return 0x02;
2535  case CHANNEL_IS_CPU : return 0x04;
2536  case CHANNEL_IS_FT1284 : return 0x08;
2537  default: return 0;
2538  }
2539  }
2540  case TYPE_230X: /* FT230X is only UART */
2541  default: return 0;
2542  }
2543  return 0;
2544 }
2545 
2561 {
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;
2565  int user_area_size;
2566  struct ftdi_eeprom *eeprom;
2567  unsigned char * output;
2568 
2569  if (ftdi == NULL)
2570  ftdi_error_return(-2,"No context");
2571  if (ftdi->eeprom == NULL)
2572  ftdi_error_return(-2,"No eeprom structure");
2573 
2574  eeprom= ftdi->eeprom;
2575  output = eeprom->buf;
2576 
2577  if (eeprom->chip == -1)
2578  ftdi_error_return(-6,"No connected EEPROM or EEPROM type unknown");
2579 
2580  if (eeprom->size == -1)
2581  {
2582  if ((eeprom->chip == 0x56) || (eeprom->chip == 0x66))
2583  eeprom->size = 0x100;
2584  else
2585  eeprom->size = 0x80;
2586  }
2587 
2588  if (eeprom->manufacturer != NULL)
2589  manufacturer_size = strlen(eeprom->manufacturer);
2590  if (eeprom->product != NULL)
2591  product_size = strlen(eeprom->product);
2592  if (eeprom->serial != NULL)
2593  serial_size = strlen(eeprom->serial);
2594 
2595  // eeprom size check
2596  switch (ftdi->type)
2597  {
2598  case TYPE_AM:
2599  case TYPE_BM:
2600  user_area_size = 96; // base size for strings (total of 48 characters)
2601  break;
2602  case TYPE_2232C:
2603  user_area_size = 90; // two extra config bytes and 4 bytes PnP stuff
2604  break;
2605  case TYPE_R:
2606  case TYPE_230X:
2607  user_area_size = 88; // four extra config bytes + 4 bytes PnP stuff
2608  break;
2609  case TYPE_2232H: // six extra config bytes + 4 bytes PnP stuff
2610  case TYPE_4232H:
2611  user_area_size = 86;
2612  break;
2613  case TYPE_232H:
2614  user_area_size = 80;
2615  break;
2616  default:
2617  user_area_size = 0;
2618  break;
2619  }
2620  user_area_size -= (manufacturer_size + product_size + serial_size) * 2;
2621 
2622  if (user_area_size < 0)
2623  ftdi_error_return(-1,"eeprom size exceeded");
2624 
2625  // empty eeprom
2626  if (ftdi->type == TYPE_230X)
2627  {
2628  /* FT230X have a reserved section in the middle of the MTP,
2629  which cannot be written to, but must be included in the checksum */
2630  memset(ftdi->eeprom->buf, 0, 0x80);
2631  memset((ftdi->eeprom->buf + 0xa0), 0, (FTDI_MAX_EEPROM_SIZE - 0xa0));
2632  }
2633  else
2634  {
2635  memset(ftdi->eeprom->buf, 0, FTDI_MAX_EEPROM_SIZE);
2636  }
2637 
2638  // Bytes and Bits set for all Types
2639 
2640  // Addr 02: Vendor ID
2641  output[0x02] = eeprom->vendor_id;
2642  output[0x03] = eeprom->vendor_id >> 8;
2643 
2644  // Addr 04: Product ID
2645  output[0x04] = eeprom->product_id;
2646  output[0x05] = eeprom->product_id >> 8;
2647 
2648  // Addr 06: Device release number (0400h for BM features)
2649  output[0x06] = eeprom->release_number;
2650  output[0x07] = eeprom->release_number >> 8;
2651 
2652  // Addr 08: Config descriptor
2653  // Bit 7: always 1
2654  // Bit 6: 1 if this device is self powered, 0 if bus powered
2655  // Bit 5: 1 if this device uses remote wakeup
2656  // Bit 4-0: reserved - 0
2657  j = 0x80;
2658  if (eeprom->self_powered)
2659  j |= 0x40;
2660  if (eeprom->remote_wakeup)
2661  j |= 0x20;
2662  output[0x08] = j;
2663 
2664  // Addr 09: Max power consumption: max power = value * 2 mA
2665  output[0x09] = eeprom->max_power / MAX_POWER_MILLIAMP_PER_UNIT;
2666 
2667  if ((ftdi->type != TYPE_AM) && (ftdi->type != TYPE_230X))
2668  {
2669  // Addr 0A: Chip configuration
2670  // Bit 7: 0 - reserved
2671  // Bit 6: 0 - reserved
2672  // Bit 5: 0 - reserved
2673  // Bit 4: 1 - Change USB version
2674  // Bit 3: 1 - Use the serial number string
2675  // Bit 2: 1 - Enable suspend pull downs for lower power
2676  // Bit 1: 1 - Out EndPoint is Isochronous
2677  // Bit 0: 1 - In EndPoint is Isochronous
2678  //
2679  j = 0;
2680  if (eeprom->in_is_isochronous)
2681  j = j | 1;
2682  if (eeprom->out_is_isochronous)
2683  j = j | 2;
2684  output[0x0A] = j;
2685  }
2686 
2687  // Dynamic content
2688  // Strings start at 0x94 (TYPE_AM, TYPE_BM)
2689  // 0x96 (TYPE_2232C), 0x98 (TYPE_R) and 0x9a (TYPE_x232H)
2690  // 0xa0 (TYPE_232H)
2691  i = 0;
2692  switch (ftdi->type)
2693  {
2694  case TYPE_2232H:
2695  case TYPE_4232H:
2696  i += 2;
2697  case TYPE_R:
2698  i += 2;
2699  case TYPE_2232C:
2700  i += 2;
2701  case TYPE_AM:
2702  case TYPE_BM:
2703  i += 0x94;
2704  break;
2705  case TYPE_232H:
2706  case TYPE_230X:
2707  i = 0xa0;
2708  break;
2709  }
2710  /* Wrap around 0x80 for 128 byte EEPROMS (Internale and 93x46) */
2711  eeprom_size_mask = eeprom->size -1;
2712 
2713  // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2714  // Addr 0F: Length of manufacturer string
2715  // Output manufacturer
2716  output[0x0E] = i; // calculate offset
2717  output[i & eeprom_size_mask] = manufacturer_size*2 + 2, i++;
2718  output[i & eeprom_size_mask] = 0x03, i++; // type: string
2719  for (j = 0; j < manufacturer_size; j++)
2720  {
2721  output[i & eeprom_size_mask] = eeprom->manufacturer[j], i++;
2722  output[i & eeprom_size_mask] = 0x00, i++;
2723  }
2724  output[0x0F] = manufacturer_size*2 + 2;
2725 
2726  // Addr 10: Offset of the product string + 0x80, calculated later
2727  // Addr 11: Length of product string
2728  output[0x10] = i | 0x80; // calculate offset
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++)
2732  {
2733  output[i & eeprom_size_mask] = eeprom->product[j], i++;
2734  output[i & eeprom_size_mask] = 0x00, i++;
2735  }
2736  output[0x11] = product_size*2 + 2;
2737 
2738  // Addr 12: Offset of the serial string + 0x80, calculated later
2739  // Addr 13: Length of serial string
2740  output[0x12] = i | 0x80; // calculate offset
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++)
2744  {
2745  output[i & eeprom_size_mask] = eeprom->serial[j], i++;
2746  output[i & eeprom_size_mask] = 0x00, i++;
2747  }
2748 
2749  // Legacy port name and PnP fields for FT2232 and newer chips
2750  if (ftdi->type > TYPE_BM)
2751  {
2752  output[i & eeprom_size_mask] = 0x02; /* as seen when written with FTD2XX */
2753  i++;
2754  output[i & eeprom_size_mask] = 0x03; /* as seen when written with FTD2XX */
2755  i++;
2756  output[i & eeprom_size_mask] = eeprom->is_not_pnp; /* as seen when written with FTD2XX */
2757  i++;
2758  }
2759 
2760  output[0x13] = serial_size*2 + 2;
2761 
2762  if (ftdi->type > TYPE_AM) /* use_serial not used in AM devices */
2763  {
2764  if (eeprom->use_serial)
2765  output[0x0A] |= USE_SERIAL_NUM;
2766  else
2767  output[0x0A] &= ~USE_SERIAL_NUM;
2768  }
2769 
2770  /* Bytes and Bits specific to (some) types
2771  Write linear, as this allows easier fixing*/
2772  switch (ftdi->type)
2773  {
2774  case TYPE_AM:
2775  break;
2776  case TYPE_BM:
2777  output[0x0C] = eeprom->usb_version & 0xff;
2778  output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2779  if (eeprom->use_usb_version == USE_USB_VERSION_BIT)
2780  output[0x0A] |= USE_USB_VERSION_BIT;
2781  else
2782  output[0x0A] &= ~USE_USB_VERSION_BIT;
2783 
2784  break;
2785  case TYPE_2232C:
2786 
2787  output[0x00] = type2bit(eeprom->channel_a_type, TYPE_2232C);
2788  if ( eeprom->channel_a_driver == DRIVER_VCP)
2789  output[0x00] |= DRIVER_VCP;
2790  else
2791  output[0x00] &= ~DRIVER_VCP;
2792 
2793  if ( eeprom->high_current_a == HIGH_CURRENT_DRIVE)
2794  output[0x00] |= HIGH_CURRENT_DRIVE;
2795  else
2796  output[0x00] &= ~HIGH_CURRENT_DRIVE;
2797 
2798  output[0x01] = type2bit(eeprom->channel_b_type, TYPE_2232C);
2799  if ( eeprom->channel_b_driver == DRIVER_VCP)
2800  output[0x01] |= DRIVER_VCP;
2801  else
2802  output[0x01] &= ~DRIVER_VCP;
2803 
2804  if ( eeprom->high_current_b == HIGH_CURRENT_DRIVE)
2805  output[0x01] |= HIGH_CURRENT_DRIVE;
2806  else
2807  output[0x01] &= ~HIGH_CURRENT_DRIVE;
2808 
2809  if (eeprom->in_is_isochronous)
2810  output[0x0A] |= 0x1;
2811  else
2812  output[0x0A] &= ~0x1;
2813  if (eeprom->out_is_isochronous)
2814  output[0x0A] |= 0x2;
2815  else
2816  output[0x0A] &= ~0x2;
2817  if (eeprom->suspend_pull_downs)
2818  output[0x0A] |= 0x4;
2819  else
2820  output[0x0A] &= ~0x4;
2821  if (eeprom->use_usb_version == USE_USB_VERSION_BIT)
2822  output[0x0A] |= USE_USB_VERSION_BIT;
2823  else
2824  output[0x0A] &= ~USE_USB_VERSION_BIT;
2825 
2826  output[0x0C] = eeprom->usb_version & 0xff;
2827  output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2828  output[0x14] = eeprom->chip;
2829  break;
2830  case TYPE_R:
2831  if (eeprom->high_current == HIGH_CURRENT_DRIVE_R)
2832  output[0x00] |= HIGH_CURRENT_DRIVE_R;
2833  output[0x01] = 0x40; /* Hard coded Endpoint Size*/
2834 
2835  if (eeprom->suspend_pull_downs)
2836  output[0x0A] |= 0x4;
2837  else
2838  output[0x0A] &= ~0x4;
2839  output[0x0B] = eeprom->invert;
2840  output[0x0C] = eeprom->usb_version & 0xff;
2841  output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2842 
2843  if (eeprom->cbus_function[0] > CBUS_BB)
2844  output[0x14] = CBUS_TXLED;
2845  else
2846  output[0x14] = eeprom->cbus_function[0];
2847 
2848  if (eeprom->cbus_function[1] > CBUS_BB)
2849  output[0x14] |= CBUS_RXLED<<4;
2850  else
2851  output[0x14] |= eeprom->cbus_function[1]<<4;
2852 
2853  if (eeprom->cbus_function[2] > CBUS_BB)
2854  output[0x15] = CBUS_TXDEN;
2855  else
2856  output[0x15] = eeprom->cbus_function[2];
2857 
2858  if (eeprom->cbus_function[3] > CBUS_BB)
2859  output[0x15] |= CBUS_PWREN<<4;
2860  else
2861  output[0x15] |= eeprom->cbus_function[3]<<4;
2862 
2863  if (eeprom->cbus_function[4] > CBUS_CLK6)
2864  output[0x16] = CBUS_SLEEP;
2865  else
2866  output[0x16] = eeprom->cbus_function[4];
2867  break;
2868  case TYPE_2232H:
2869  output[0x00] = type2bit(eeprom->channel_a_type, TYPE_2232H);
2870  if ( eeprom->channel_a_driver == DRIVER_VCP)
2871  output[0x00] |= DRIVER_VCP;
2872  else
2873  output[0x00] &= ~DRIVER_VCP;
2874 
2875  output[0x01] = type2bit(eeprom->channel_b_type, TYPE_2232H);
2876  if ( eeprom->channel_b_driver == DRIVER_VCP)
2877  output[0x01] |= DRIVER_VCP;
2878  else
2879  output[0x01] &= ~DRIVER_VCP;
2880  if (eeprom->suspend_dbus7 == SUSPEND_DBUS7_BIT)
2881  output[0x01] |= SUSPEND_DBUS7_BIT;
2882  else
2883  output[0x01] &= ~SUSPEND_DBUS7_BIT;
2884 
2885  if (eeprom->suspend_pull_downs)
2886  output[0x0A] |= 0x4;
2887  else
2888  output[0x0A] &= ~0x4;
2889 
2890  if (eeprom->group0_drive > DRIVE_16MA)
2891  output[0x0c] |= DRIVE_16MA;
2892  else
2893  output[0x0c] |= eeprom->group0_drive;
2894  if (eeprom->group0_schmitt == IS_SCHMITT)
2895  output[0x0c] |= IS_SCHMITT;
2896  if (eeprom->group0_slew == SLOW_SLEW)
2897  output[0x0c] |= SLOW_SLEW;
2898 
2899  if (eeprom->group1_drive > DRIVE_16MA)
2900  output[0x0c] |= DRIVE_16MA<<4;
2901  else
2902  output[0x0c] |= eeprom->group1_drive<<4;
2903  if (eeprom->group1_schmitt == IS_SCHMITT)
2904  output[0x0c] |= IS_SCHMITT<<4;
2905  if (eeprom->group1_slew == SLOW_SLEW)
2906  output[0x0c] |= SLOW_SLEW<<4;
2907 
2908  if (eeprom->group2_drive > DRIVE_16MA)
2909  output[0x0d] |= DRIVE_16MA;
2910  else
2911  output[0x0d] |= eeprom->group2_drive;
2912  if (eeprom->group2_schmitt == IS_SCHMITT)
2913  output[0x0d] |= IS_SCHMITT;
2914  if (eeprom->group2_slew == SLOW_SLEW)
2915  output[0x0d] |= SLOW_SLEW;
2916 
2917  if (eeprom->group3_drive > DRIVE_16MA)
2918  output[0x0d] |= DRIVE_16MA<<4;
2919  else
2920  output[0x0d] |= eeprom->group3_drive<<4;
2921  if (eeprom->group3_schmitt == IS_SCHMITT)
2922  output[0x0d] |= IS_SCHMITT<<4;
2923  if (eeprom->group3_slew == SLOW_SLEW)
2924  output[0x0d] |= SLOW_SLEW<<4;
2925 
2926  output[0x18] = eeprom->chip;
2927 
2928  break;
2929  case TYPE_4232H:
2930  if (eeprom->channel_a_driver == DRIVER_VCP)
2931  output[0x00] |= DRIVER_VCP;
2932  else
2933  output[0x00] &= ~DRIVER_VCP;
2934  if (eeprom->channel_b_driver == DRIVER_VCP)
2935  output[0x01] |= DRIVER_VCP;
2936  else
2937  output[0x01] &= ~DRIVER_VCP;
2938  if (eeprom->channel_c_driver == DRIVER_VCP)
2939  output[0x00] |= (DRIVER_VCP << 4);
2940  else
2941  output[0x00] &= ~(DRIVER_VCP << 4);
2942  if (eeprom->channel_d_driver == DRIVER_VCP)
2943  output[0x01] |= (DRIVER_VCP << 4);
2944  else
2945  output[0x01] &= ~(DRIVER_VCP << 4);
2946 
2947  if (eeprom->suspend_pull_downs)
2948  output[0x0a] |= 0x4;
2949  else
2950  output[0x0a] &= ~0x4;
2951 
2952  if (eeprom->channel_a_rs485enable)
2953  output[0x0b] |= CHANNEL_IS_RS485 << 0;
2954  else
2955  output[0x0b] &= ~(CHANNEL_IS_RS485 << 0);
2956  if (eeprom->channel_b_rs485enable)
2957  output[0x0b] |= CHANNEL_IS_RS485 << 1;
2958  else
2959  output[0x0b] &= ~(CHANNEL_IS_RS485 << 1);
2960  if (eeprom->channel_c_rs485enable)
2961  output[0x0b] |= CHANNEL_IS_RS485 << 2;
2962  else
2963  output[0x0b] &= ~(CHANNEL_IS_RS485 << 2);
2964  if (eeprom->channel_d_rs485enable)
2965  output[0x0b] |= CHANNEL_IS_RS485 << 3;
2966  else
2967  output[0x0b] &= ~(CHANNEL_IS_RS485 << 3);
2968 
2969  if (eeprom->group0_drive > DRIVE_16MA)
2970  output[0x0c] |= DRIVE_16MA;
2971  else
2972  output[0x0c] |= eeprom->group0_drive;
2973  if (eeprom->group0_schmitt == IS_SCHMITT)
2974  output[0x0c] |= IS_SCHMITT;
2975  if (eeprom->group0_slew == SLOW_SLEW)
2976  output[0x0c] |= SLOW_SLEW;
2977 
2978  if (eeprom->group1_drive > DRIVE_16MA)
2979  output[0x0c] |= DRIVE_16MA<<4;
2980  else
2981  output[0x0c] |= eeprom->group1_drive<<4;
2982  if (eeprom->group1_schmitt == IS_SCHMITT)
2983  output[0x0c] |= IS_SCHMITT<<4;
2984  if (eeprom->group1_slew == SLOW_SLEW)
2985  output[0x0c] |= SLOW_SLEW<<4;
2986 
2987  if (eeprom->group2_drive > DRIVE_16MA)
2988  output[0x0d] |= DRIVE_16MA;
2989  else
2990  output[0x0d] |= eeprom->group2_drive;
2991  if (eeprom->group2_schmitt == IS_SCHMITT)
2992  output[0x0d] |= IS_SCHMITT;
2993  if (eeprom->group2_slew == SLOW_SLEW)
2994  output[0x0d] |= SLOW_SLEW;
2995 
2996  if (eeprom->group3_drive > DRIVE_16MA)
2997  output[0x0d] |= DRIVE_16MA<<4;
2998  else
2999  output[0x0d] |= eeprom->group3_drive<<4;
3000  if (eeprom->group3_schmitt == IS_SCHMITT)
3001  output[0x0d] |= IS_SCHMITT<<4;
3002  if (eeprom->group3_slew == SLOW_SLEW)
3003  output[0x0d] |= SLOW_SLEW<<4;
3004 
3005  output[0x18] = eeprom->chip;
3006 
3007  break;
3008  case TYPE_232H:
3009  output[0x00] = type2bit(eeprom->channel_a_type, TYPE_232H);
3010  if ( eeprom->channel_a_driver == DRIVER_VCP)
3011  output[0x00] |= DRIVER_VCPH;
3012  else
3013  output[0x00] &= ~DRIVER_VCPH;
3014  if (eeprom->powersave)
3015  output[0x01] |= POWER_SAVE_DISABLE_H;
3016  else
3017  output[0x01] &= ~POWER_SAVE_DISABLE_H;
3018 
3019  if (eeprom->suspend_pull_downs)
3020  output[0x0a] |= 0x4;
3021  else
3022  output[0x0a] &= ~0x4;
3023 
3024  if (eeprom->clock_polarity)
3025  output[0x01] |= FT1284_CLK_IDLE_STATE;
3026  else
3027  output[0x01] &= ~FT1284_CLK_IDLE_STATE;
3028  if (eeprom->data_order)
3029  output[0x01] |= FT1284_DATA_LSB;
3030  else
3031  output[0x01] &= ~FT1284_DATA_LSB;
3032  if (eeprom->flow_control)
3033  output[0x01] |= FT1284_FLOW_CONTROL;
3034  else
3035  output[0x01] &= ~FT1284_FLOW_CONTROL;
3036  if (eeprom->group0_drive > DRIVE_16MA)
3037  output[0x0c] |= DRIVE_16MA;
3038  else
3039  output[0x0c] |= eeprom->group0_drive;
3040  if (eeprom->group0_schmitt == IS_SCHMITT)
3041  output[0x0c] |= IS_SCHMITT;
3042  if (eeprom->group0_slew == SLOW_SLEW)
3043  output[0x0c] |= SLOW_SLEW;
3044 
3045  if (eeprom->group1_drive > DRIVE_16MA)
3046  output[0x0d] |= DRIVE_16MA;
3047  else
3048  output[0x0d] |= eeprom->group1_drive;
3049  if (eeprom->group1_schmitt == IS_SCHMITT)
3050  output[0x0d] |= IS_SCHMITT;
3051  if (eeprom->group1_slew == SLOW_SLEW)
3052  output[0x0d] |= SLOW_SLEW;
3053 
3054  set_ft232h_cbus(eeprom, output);
3055 
3056  output[0x1e] = eeprom->chip;
3057  fprintf(stderr,"FIXME: Build FT232H specific EEPROM settings\n");
3058  break;
3059  case TYPE_230X:
3060  output[0x00] = 0x80; /* Actually, leave the default value */
3061  output[0x0a] = 0x08; /* Enable USB Serial Number */
3062  output[0x0c] = (0x01) | (0x3 << 4); /* DBUS drive 4mA, CBUS drive 16mA */
3063  for (j = 0; j <= 6; j++)
3064  {
3065  output[0x1a + j] = eeprom->cbus_function[j];
3066  }
3067  break;
3068  }
3069 
3070  // calculate checksum
3071  checksum = 0xAAAA;
3072 
3073  for (i = 0; i < eeprom->size/2-1; i++)
3074  {
3075  if ((ftdi->type == TYPE_230X) && (i == 0x12))
3076  {
3077  /* FT230X has a user section in the MTP which is not part of the checksum */
3078  i = 0x40;
3079  }
3080  value = output[i*2];
3081  value += output[(i*2)+1] << 8;
3082 
3083  checksum = value^checksum;
3084  checksum = (checksum << 1) | (checksum >> 15);
3085  }
3086 
3087  output[eeprom->size-2] = checksum;
3088  output[eeprom->size-1] = checksum >> 8;
3089 
3091  return user_area_size;
3092 }
3093 /* Decode the encoded EEPROM field for the FTDI Mode into a value for the abstracted
3094  * EEPROM structure
3095  *
3096  * FTD2XX doesn't allow to set multiple bits in the interface mode bitfield, and so do we
3097  */
3098 static unsigned char bit2type(unsigned char bits)
3099 {
3100  switch (bits)
3101  {
3102  case 0: return CHANNEL_IS_UART;
3103  case 1: return CHANNEL_IS_FIFO;
3104  case 2: return CHANNEL_IS_OPTO;
3105  case 4: return CHANNEL_IS_CPU;
3106  case 8: return CHANNEL_IS_FT1284;
3107  default:
3108  fprintf(stderr," Unexpected value %d for Hardware Interface type\n",
3109  bits);
3110  }
3111  return 0;
3112 }
3125 int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose)
3126 {
3127  unsigned char i, j;
3128  unsigned short checksum, eeprom_checksum, value;
3129  unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
3130  int eeprom_size;
3131  struct ftdi_eeprom *eeprom;
3132  unsigned char *buf = NULL;
3133 
3134  if (ftdi == NULL)
3135  ftdi_error_return(-1,"No context");
3136  if (ftdi->eeprom == NULL)
3137  ftdi_error_return(-1,"No eeprom structure");
3138 
3139  eeprom = ftdi->eeprom;
3140  eeprom_size = eeprom->size;
3141  buf = ftdi->eeprom->buf;
3142 
3143  // Addr 02: Vendor ID
3144  eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
3145 
3146  // Addr 04: Product ID
3147  eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
3148 
3149  // Addr 06: Device release number
3150  eeprom->release_number = buf[0x06] + (buf[0x07]<<8);
3151 
3152  // Addr 08: Config descriptor
3153  // Bit 7: always 1
3154  // Bit 6: 1 if this device is self powered, 0 if bus powered
3155  // Bit 5: 1 if this device uses remote wakeup
3156  eeprom->self_powered = buf[0x08] & 0x40;
3157  eeprom->remote_wakeup = buf[0x08] & 0x20;
3158 
3159  // Addr 09: Max power consumption: max power = value * 2 mA
3160  eeprom->max_power = MAX_POWER_MILLIAMP_PER_UNIT * buf[0x09];
3161 
3162  // Addr 0A: Chip configuration
3163  // Bit 7: 0 - reserved
3164  // Bit 6: 0 - reserved
3165  // Bit 5: 0 - reserved
3166  // Bit 4: 1 - Change USB version on BM and 2232C
3167  // Bit 3: 1 - Use the serial number string
3168  // Bit 2: 1 - Enable suspend pull downs for lower power
3169  // Bit 1: 1 - Out EndPoint is Isochronous
3170  // Bit 0: 1 - In EndPoint is Isochronous
3171  //
3172  eeprom->in_is_isochronous = buf[0x0A]&0x01;
3173  eeprom->out_is_isochronous = buf[0x0A]&0x02;
3174  eeprom->suspend_pull_downs = buf[0x0A]&0x04;
3175  eeprom->use_serial = (buf[0x0A] & USE_SERIAL_NUM)?1:0;
3176  eeprom->use_usb_version = buf[0x0A] & USE_USB_VERSION_BIT;
3177 
3178  // Addr 0C: USB version low byte when 0x0A
3179  // Addr 0D: USB version high byte when 0x0A
3180  eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
3181 
3182  // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
3183  // Addr 0F: Length of manufacturer string
3184  manufacturer_size = buf[0x0F]/2;
3185  if (eeprom->manufacturer)
3186  free(eeprom->manufacturer);
3187  if (manufacturer_size > 0)
3188  {
3189  eeprom->manufacturer = malloc(manufacturer_size);
3190  if (eeprom->manufacturer)
3191  {
3192  // Decode manufacturer
3193  i = buf[0x0E] & (eeprom_size -1); // offset
3194  for (j=0; j<manufacturer_size-1; j++)
3195  {
3196  eeprom->manufacturer[j] = buf[2*j+i+2];
3197  }
3198  eeprom->manufacturer[j] = '\0';
3199  }
3200  }
3201  else eeprom->manufacturer = NULL;
3202 
3203  // Addr 10: Offset of the product string + 0x80, calculated later
3204  // Addr 11: Length of product string
3205  if (eeprom->product)
3206  free(eeprom->product);
3207  product_size = buf[0x11]/2;
3208  if (product_size > 0)
3209  {
3210  eeprom->product = malloc(product_size);
3211  if (eeprom->product)
3212  {
3213  // Decode product name
3214  i = buf[0x10] & (eeprom_size -1); // offset
3215  for (j=0; j<product_size-1; j++)
3216  {
3217  eeprom->product[j] = buf[2*j+i+2];
3218  }
3219  eeprom->product[j] = '\0';
3220  }
3221  }
3222  else eeprom->product = NULL;
3223 
3224  // Addr 12: Offset of the serial string + 0x80, calculated later
3225  // Addr 13: Length of serial string
3226  if (eeprom->serial)
3227  free(eeprom->serial);
3228  serial_size = buf[0x13]/2;
3229  if (serial_size > 0)
3230  {
3231  eeprom->serial = malloc(serial_size);
3232  if (eeprom->serial)
3233  {
3234  // Decode serial
3235  i = buf[0x12] & (eeprom_size -1); // offset
3236  for (j=0; j<serial_size-1; j++)
3237  {
3238  eeprom->serial[j] = buf[2*j+i+2];
3239  }
3240  eeprom->serial[j] = '\0';
3241  }
3242  }
3243  else eeprom->serial = NULL;
3244 
3245  // verify checksum
3246  checksum = 0xAAAA;
3247 
3248  for (i = 0; i < eeprom_size/2-1; i++)
3249  {
3250  if ((ftdi->type == TYPE_230X) && (i == 0x12))
3251  {
3252  /* FT230X has a user section in the MTP which is not part of the checksum */
3253  i = 0x40;
3254  }
3255  value = buf[i*2];
3256  value += buf[(i*2)+1] << 8;
3257 
3258  checksum = value^checksum;
3259  checksum = (checksum << 1) | (checksum >> 15);
3260  }
3261 
3262  eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
3263 
3264  if (eeprom_checksum != checksum)
3265  {
3266  fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
3267  ftdi_error_return(-1,"EEPROM checksum error");
3268  }
3269 
3270  eeprom->channel_a_type = 0;
3271  if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM))
3272  {
3273  eeprom->chip = -1;
3274  }
3275  else if (ftdi->type == TYPE_2232C)
3276  {
3277  eeprom->channel_a_type = bit2type(buf[0x00] & 0x7);
3278  eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
3279  eeprom->high_current_a = buf[0x00] & HIGH_CURRENT_DRIVE;
3280  eeprom->channel_b_type = buf[0x01] & 0x7;
3281  eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
3282  eeprom->high_current_b = buf[0x01] & HIGH_CURRENT_DRIVE;
3283  eeprom->chip = buf[0x14];
3284  }
3285  else if (ftdi->type == TYPE_R)
3286  {
3287  /* TYPE_R flags D2XX, not VCP as all others*/
3288  eeprom->channel_a_driver = ~buf[0x00] & DRIVER_VCP;
3289  eeprom->high_current = buf[0x00] & HIGH_CURRENT_DRIVE_R;
3290  if ( (buf[0x01]&0x40) != 0x40)
3291  fprintf(stderr,
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");
3296 
3297  eeprom->chip = buf[0x16];
3298  // Addr 0B: Invert data lines
3299  // Works only on FT232R, not FT245R, but no way to distinguish
3300  eeprom->invert = buf[0x0B];
3301  // Addr 14: CBUS function: CBUS0, CBUS1
3302  // Addr 15: CBUS function: CBUS2, CBUS3
3303  // Addr 16: CBUS function: CBUS5
3304  eeprom->cbus_function[0] = buf[0x14] & 0x0f;
3305  eeprom->cbus_function[1] = (buf[0x14] >> 4) & 0x0f;
3306  eeprom->cbus_function[2] = buf[0x15] & 0x0f;
3307  eeprom->cbus_function[3] = (buf[0x15] >> 4) & 0x0f;
3308  eeprom->cbus_function[4] = buf[0x16] & 0x0f;
3309  }
3310  else if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
3311  {
3312  eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
3313  eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
3314 
3315  if (ftdi->type == TYPE_2232H)
3316  {
3317  eeprom->channel_a_type = bit2type(buf[0x00] & 0x7);
3318  eeprom->channel_b_type = bit2type(buf[0x01] & 0x7);
3319  eeprom->suspend_dbus7 = buf[0x01] & SUSPEND_DBUS7_BIT;
3320  }
3321  else
3322  {
3323  eeprom->channel_c_driver = (buf[0x00] >> 4) & DRIVER_VCP;
3324  eeprom->channel_d_driver = (buf[0x01] >> 4) & DRIVER_VCP;
3325  eeprom->channel_a_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 0);
3326  eeprom->channel_b_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 1);
3327  eeprom->channel_c_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 2);
3328  eeprom->channel_d_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 3);
3329  }
3330 
3331  eeprom->chip = buf[0x18];
3332  eeprom->group0_drive = buf[0x0c] & DRIVE_16MA;
3333  eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT;
3334  eeprom->group0_slew = buf[0x0c] & SLOW_SLEW;
3335  eeprom->group1_drive = (buf[0x0c] >> 4) & 0x3;
3336  eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT;
3337  eeprom->group1_slew = (buf[0x0c] >> 4) & SLOW_SLEW;
3338  eeprom->group2_drive = buf[0x0d] & DRIVE_16MA;
3339  eeprom->group2_schmitt = buf[0x0d] & IS_SCHMITT;
3340  eeprom->group2_slew = buf[0x0d] & SLOW_SLEW;
3341  eeprom->group3_drive = (buf[0x0d] >> 4) & DRIVE_16MA;
3342  eeprom->group3_schmitt = (buf[0x0d] >> 4) & IS_SCHMITT;
3343  eeprom->group3_slew = (buf[0x0d] >> 4) & SLOW_SLEW;
3344  }
3345  else if (ftdi->type == TYPE_232H)
3346  {
3347  int i;
3348 
3349  eeprom->channel_a_type = buf[0x00] & 0xf;
3350  eeprom->channel_a_driver = (buf[0x00] & DRIVER_VCPH)?DRIVER_VCP:0;
3351  eeprom->clock_polarity = buf[0x01] & FT1284_CLK_IDLE_STATE;
3352  eeprom->data_order = buf[0x01] & FT1284_DATA_LSB;
3353  eeprom->flow_control = buf[0x01] & FT1284_FLOW_CONTROL;
3354  eeprom->powersave = buf[0x01] & POWER_SAVE_DISABLE_H;
3355  eeprom->group0_drive = buf[0x0c] & DRIVE_16MA;
3356  eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT;
3357  eeprom->group0_slew = buf[0x0c] & SLOW_SLEW;
3358  eeprom->group1_drive = buf[0x0d] & DRIVE_16MA;
3359  eeprom->group1_schmitt = buf[0x0d] & IS_SCHMITT;
3360  eeprom->group1_slew = buf[0x0d] & SLOW_SLEW;
3361 
3362  for(i=0; i<5; i++)
3363  {
3364  eeprom->cbus_function[2*i ] = buf[0x18+i] & 0x0f;
3365  eeprom->cbus_function[2*i+1] = (buf[0x18+i] >> 4) & 0x0f;
3366  }
3367  eeprom->chip = buf[0x1e];
3368  /*FIXME: Decipher more values*/
3369  }
3370  else if (ftdi->type == TYPE_230X)
3371  {
3372  for(i=0; i<4; i++)
3373  {
3374  eeprom->cbus_function[i] = buf[0x1a + i] & 0xFF;
3375  }
3376  eeprom->group0_drive = buf[0x0c] & 0x03;
3377  eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT;
3378  eeprom->group0_slew = buf[0x0c] & SLOW_SLEW;
3379  eeprom->group1_drive = (buf[0x0c] >> 4) & 0x03;
3380  eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT;
3381  eeprom->group1_slew = (buf[0x0c] >> 4) & SLOW_SLEW;
3382  }
3383 
3384  if (verbose)
3385  {
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);
3389  fprintf(stdout, "Release: 0x%04x\n",eeprom->release_number);
3390 
3391  if (eeprom->self_powered)
3392  fprintf(stdout, "Self-Powered%s", (eeprom->remote_wakeup)?", USB Remote Wake Up\n":"\n");
3393  else
3394  fprintf(stdout, "Bus Powered: %3d mA%s", eeprom->max_power,
3395  (eeprom->remote_wakeup)?" USB Remote Wake Up\n":"\n");
3396  if (eeprom->manufacturer)
3397  fprintf(stdout, "Manufacturer: %s\n",eeprom->manufacturer);
3398  if (eeprom->product)
3399  fprintf(stdout, "Product: %s\n",eeprom->product);
3400  if (eeprom->serial)
3401  fprintf(stdout, "Serial: %s\n",eeprom->serial);
3402  fprintf(stdout, "Checksum : %04x\n", checksum);
3403  if (ftdi->type == TYPE_R)
3404  fprintf(stdout, "Internal EEPROM\n");
3405  else if (eeprom->chip >= 0x46)
3406  fprintf(stdout, "Attached EEPROM: 93x%02x\n", eeprom->chip);
3407  if (eeprom->suspend_dbus7)
3408  fprintf(stdout, "Suspend on DBUS7\n");
3409  if (eeprom->suspend_pull_downs)
3410  fprintf(stdout, "Pull IO pins low during suspend\n");
3411  if(eeprom->powersave)
3412  {
3413  if(ftdi->type >= TYPE_232H)
3414  fprintf(stdout,"Enter low power state on ACBUS7\n");
3415  }
3416  if (eeprom->remote_wakeup)
3417  fprintf(stdout, "Enable Remote Wake Up\n");
3418  fprintf(stdout, "PNP: %d\n",(eeprom->is_not_pnp)?0:1);
3419  if (ftdi->type >= TYPE_2232C)
3420  fprintf(stdout,"Channel A has Mode %s%s%s\n",
3421  channel_mode[eeprom->channel_a_type],
3422  (eeprom->channel_a_driver)?" VCP":"",
3423  (eeprom->high_current_a)?" High Current IO":"");
3424  if (ftdi->type >= TYPE_232H)
3425  {
3426  fprintf(stdout,"FT1284 Mode Clock is idle %s, %s first, %sFlow Control\n",
3427  (eeprom->clock_polarity)?"HIGH":"LOW",
3428  (eeprom->data_order)?"LSB":"MSB",
3429  (eeprom->flow_control)?"":"No ");
3430  }
3431  if ((ftdi->type >= TYPE_2232C) && (ftdi->type != TYPE_R) && (ftdi->type != TYPE_232H))
3432  fprintf(stdout,"Channel B has Mode %s%s%s\n",
3433  channel_mode[eeprom->channel_b_type],
3434  (eeprom->channel_b_driver)?" VCP":"",
3435  (eeprom->high_current_b)?" High Current IO":"");
3436  if (((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C)) &&
3437  eeprom->use_usb_version == USE_USB_VERSION_BIT)
3438  fprintf(stdout,"Use explicit USB Version %04x\n",eeprom->usb_version);
3439 
3440  if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
3441  {
3442  fprintf(stdout,"%s has %d mA drive%s%s\n",
3443  (ftdi->type == TYPE_2232H)?"AL":"A",
3444  (eeprom->group0_drive+1) *4,
3445  (eeprom->group0_schmitt)?" Schmitt Input":"",
3446  (eeprom->group0_slew)?" Slow Slew":"");
3447  fprintf(stdout,"%s has %d mA drive%s%s\n",
3448  (ftdi->type == TYPE_2232H)?"AH":"B",
3449  (eeprom->group1_drive+1) *4,
3450  (eeprom->group1_schmitt)?" Schmitt Input":"",
3451  (eeprom->group1_slew)?" Slow Slew":"");
3452  fprintf(stdout,"%s has %d mA drive%s%s\n",
3453  (ftdi->type == TYPE_2232H)?"BL":"C",
3454  (eeprom->group2_drive+1) *4,
3455  (eeprom->group2_schmitt)?" Schmitt Input":"",
3456  (eeprom->group2_slew)?" Slow Slew":"");
3457  fprintf(stdout,"%s has %d mA drive%s%s\n",
3458  (ftdi->type == TYPE_2232H)?"BH":"D",
3459  (eeprom->group3_drive+1) *4,
3460  (eeprom->group3_schmitt)?" Schmitt Input":"",
3461  (eeprom->group3_slew)?" Slow Slew":"");
3462  }
3463  else if (ftdi->type == TYPE_232H)
3464  {
3465  int i;
3466  char *cbush_mux[] = {"TRISTATE","RXLED","TXLED", "TXRXLED","PWREN",
3467  "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN",
3468  "CLK30","CLK15","CLK7_5"
3469  };
3470  fprintf(stdout,"ACBUS has %d mA drive%s%s\n",
3471  (eeprom->group0_drive+1) *4,
3472  (eeprom->group0_schmitt)?" Schmitt Input":"",
3473  (eeprom->group0_slew)?" Slow Slew":"");
3474  fprintf(stdout,"ADBUS has %d mA drive%s%s\n",
3475  (eeprom->group1_drive+1) *4,
3476  (eeprom->group1_schmitt)?" Schmitt Input":"",
3477  (eeprom->group1_slew)?" Slow Slew":"");
3478  for (i=0; i<10; i++)
3479  {
3480  if (eeprom->cbus_function[i]<= CBUSH_CLK7_5 )
3481  fprintf(stdout,"C%d Function: %s\n", i,
3482  cbush_mux[eeprom->cbus_function[i]]);
3483  }
3484  }
3485  else if (ftdi->type == TYPE_230X)
3486  {
3487  int 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#",
3493  };
3494  fprintf(stdout,"IOBUS has %d mA drive%s%s\n",
3495  (eeprom->group0_drive+1) *4,
3496  (eeprom->group0_schmitt)?" Schmitt Input":"",
3497  (eeprom->group0_slew)?" Slow Slew":"");
3498  fprintf(stdout,"CBUS has %d mA drive%s%s\n",
3499  (eeprom->group1_drive+1) *4,
3500  (eeprom->group1_schmitt)?" Schmitt Input":"",
3501  (eeprom->group1_slew)?" Slow Slew":"");
3502  for (i=0; i<4; i++)
3503  {
3504  if (eeprom->cbus_function[i]<= CBUSH_AWAKE)
3505  fprintf(stdout,"CBUS%d Function: %s\n", i, cbush_mux[eeprom->cbus_function[i]]);
3506  }
3507  }
3508 
3509  if (ftdi->type == TYPE_R)
3510  {
3511  char *cbus_mux[] = {"TXDEN","PWREN","RXLED", "TXLED","TX+RXLED",
3512  "SLEEP","CLK48","CLK24","CLK12","CLK6",
3513  "IOMODE","BB_WR","BB_RD"
3514  };
3515  char *cbus_BB[] = {"RXF","TXE","RD", "WR"};
3516 
3517  if (eeprom->invert)
3518  {
3519  char *r_bits[] = {"TXD","RXD","RTS", "CTS","DTR","DSR","DCD","RI"};
3520  fprintf(stdout,"Inverted bits:");
3521  for (i=0; i<8; i++)
3522  if ((eeprom->invert & (1<<i)) == (1<<i))
3523  fprintf(stdout," %s",r_bits[i]);
3524  fprintf(stdout,"\n");
3525  }
3526  for (i=0; i<5; i++)
3527  {
3528  if (eeprom->cbus_function[i]<CBUS_BB)
3529  fprintf(stdout,"C%d Function: %s\n", i,
3530  cbus_mux[eeprom->cbus_function[i]]);
3531  else
3532  {
3533  if (i < 4)
3534  /* Running MPROG show that C0..3 have fixed function Synchronous
3535  Bit Bang mode */
3536  fprintf(stdout,"C%d BB Function: %s\n", i,
3537  cbus_BB[i]);
3538  else
3539  fprintf(stdout, "Unknown CBUS mode. Might be special mode?\n");
3540  }
3541  }
3542  }
3543  }
3544  return 0;
3545 }
3546 
3557 int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int* value)
3558 {
3559  switch (value_name)
3560  {
3561  case VENDOR_ID:
3562  *value = ftdi->eeprom->vendor_id;
3563  break;
3564  case PRODUCT_ID:
3565  *value = ftdi->eeprom->product_id;
3566  break;
3567  case RELEASE_NUMBER:
3568  *value = ftdi->eeprom->release_number;
3569  break;
3570  case SELF_POWERED:
3571  *value = ftdi->eeprom->self_powered;
3572  break;
3573  case REMOTE_WAKEUP:
3574  *value = ftdi->eeprom->remote_wakeup;
3575  break;
3576  case IS_NOT_PNP:
3577  *value = ftdi->eeprom->is_not_pnp;
3578  break;
3579  case SUSPEND_DBUS7:
3580  *value = ftdi->eeprom->suspend_dbus7;
3581  break;
3582  case IN_IS_ISOCHRONOUS:
3583  *value = ftdi->eeprom->in_is_isochronous;
3584  break;
3585  case OUT_IS_ISOCHRONOUS:
3586  *value = ftdi->eeprom->out_is_isochronous;
3587  break;
3588  case SUSPEND_PULL_DOWNS:
3589  *value = ftdi->eeprom->suspend_pull_downs;
3590  break;
3591  case USE_SERIAL:
3592  *value = ftdi->eeprom->use_serial;
3593  break;
3594  case USB_VERSION:
3595  *value = ftdi->eeprom->usb_version;
3596  break;
3597  case USE_USB_VERSION:
3598  *value = ftdi->eeprom->use_usb_version;
3599  break;
3600  case MAX_POWER:
3601  *value = ftdi->eeprom->max_power;
3602  break;
3603  case CHANNEL_A_TYPE:
3604  *value = ftdi->eeprom->channel_a_type;
3605  break;
3606  case CHANNEL_B_TYPE:
3607  *value = ftdi->eeprom->channel_b_type;
3608  break;
3609  case CHANNEL_A_DRIVER:
3610  *value = ftdi->eeprom->channel_a_driver;
3611  break;
3612  case CHANNEL_B_DRIVER:
3613  *value = ftdi->eeprom->channel_b_driver;
3614  break;
3615  case CHANNEL_C_DRIVER:
3616  *value = ftdi->eeprom->channel_c_driver;
3617  break;
3618  case CHANNEL_D_DRIVER:
3619  *value = ftdi->eeprom->channel_d_driver;
3620  break;
3621  case CHANNEL_A_RS485:
3622  *value = ftdi->eeprom->channel_a_rs485enable;
3623  break;
3624  case CHANNEL_B_RS485:
3625  *value = ftdi->eeprom->channel_b_rs485enable;
3626  break;
3627  case CHANNEL_C_RS485:
3628  *value = ftdi->eeprom->channel_c_rs485enable;
3629  break;
3630  case CHANNEL_D_RS485:
3631  *value = ftdi->eeprom->channel_d_rs485enable;
3632  break;
3633  case CBUS_FUNCTION_0:
3634  *value = ftdi->eeprom->cbus_function[0];
3635  break;
3636  case CBUS_FUNCTION_1:
3637  *value = ftdi->eeprom->cbus_function[1];
3638  break;
3639  case CBUS_FUNCTION_2:
3640  *value = ftdi->eeprom->cbus_function[2];
3641  break;
3642  case CBUS_FUNCTION_3:
3643  *value = ftdi->eeprom->cbus_function[3];
3644  break;
3645  case CBUS_FUNCTION_4:
3646  *value = ftdi->eeprom->cbus_function[4];
3647  break;
3648  case CBUS_FUNCTION_5:
3649  *value = ftdi->eeprom->cbus_function[5];
3650  break;
3651  case CBUS_FUNCTION_6:
3652  *value = ftdi->eeprom->cbus_function[6];
3653  break;
3654  case CBUS_FUNCTION_7:
3655  *value = ftdi->eeprom->cbus_function[7];
3656  break;
3657  case CBUS_FUNCTION_8:
3658  *value = ftdi->eeprom->cbus_function[8];
3659  break;
3660  case CBUS_FUNCTION_9:
3661  *value = ftdi->eeprom->cbus_function[8];
3662  break;
3663  case HIGH_CURRENT:
3664  *value = ftdi->eeprom->high_current;
3665  break;
3666  case HIGH_CURRENT_A:
3667  *value = ftdi->eeprom->high_current_a;
3668  break;
3669  case HIGH_CURRENT_B:
3670  *value = ftdi->eeprom->high_current_b;
3671  break;
3672  case INVERT:
3673  *value = ftdi->eeprom->invert;
3674  break;
3675  case GROUP0_DRIVE:
3676  *value = ftdi->eeprom->group0_drive;
3677  break;
3678  case GROUP0_SCHMITT:
3679  *value = ftdi->eeprom->group0_schmitt;
3680  break;
3681  case GROUP0_SLEW:
3682  *value = ftdi->eeprom->group0_slew;
3683  break;
3684  case GROUP1_DRIVE:
3685  *value = ftdi->eeprom->group1_drive;
3686  break;
3687  case GROUP1_SCHMITT:
3688  *value = ftdi->eeprom->group1_schmitt;
3689  break;
3690  case GROUP1_SLEW:
3691  *value = ftdi->eeprom->group1_slew;
3692  break;
3693  case GROUP2_DRIVE:
3694  *value = ftdi->eeprom->group2_drive;
3695  break;
3696  case GROUP2_SCHMITT:
3697  *value = ftdi->eeprom->group2_schmitt;
3698  break;
3699  case GROUP2_SLEW:
3700  *value = ftdi->eeprom->group2_slew;
3701  break;
3702  case GROUP3_DRIVE:
3703  *value = ftdi->eeprom->group3_drive;
3704  break;
3705  case GROUP3_SCHMITT:
3706  *value = ftdi->eeprom->group3_schmitt;
3707  break;
3708  case GROUP3_SLEW:
3709  *value = ftdi->eeprom->group3_slew;
3710  break;
3711  case POWER_SAVE:
3712  *value = ftdi->eeprom->powersave;
3713  break;
3714  case CLOCK_POLARITY:
3715  *value = ftdi->eeprom->clock_polarity;
3716  break;
3717  case DATA_ORDER:
3718  *value = ftdi->eeprom->data_order;
3719  break;
3720  case FLOW_CONTROL:
3721  *value = ftdi->eeprom->flow_control;
3722  break;
3723  case CHIP_TYPE:
3724  *value = ftdi->eeprom->chip;
3725  break;
3726  case CHIP_SIZE:
3727  *value = ftdi->eeprom->size;
3728  break;
3729  default:
3730  ftdi_error_return(-1, "Request for unknown EEPROM value");
3731  }
3732  return 0;
3733 }
3734 
3747 int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int value)
3748 {
3749  switch (value_name)
3750  {
3751  case VENDOR_ID:
3752  ftdi->eeprom->vendor_id = value;
3753  break;
3754  case PRODUCT_ID:
3755  ftdi->eeprom->product_id = value;
3756  break;
3757  case RELEASE_NUMBER:
3758  ftdi->eeprom->release_number = value;
3759  break;
3760  case SELF_POWERED:
3761  ftdi->eeprom->self_powered = value;
3762  break;
3763  case REMOTE_WAKEUP:
3764  ftdi->eeprom->remote_wakeup = value;
3765  break;
3766  case IS_NOT_PNP:
3767  ftdi->eeprom->is_not_pnp = value;
3768  break;
3769  case SUSPEND_DBUS7:
3770  ftdi->eeprom->suspend_dbus7 = value;
3771  break;
3772  case IN_IS_ISOCHRONOUS:
3773  ftdi->eeprom->in_is_isochronous = value;
3774  break;
3775  case OUT_IS_ISOCHRONOUS:
3776  ftdi->eeprom->out_is_isochronous = value;
3777  break;
3778  case SUSPEND_PULL_DOWNS:
3779  ftdi->eeprom->suspend_pull_downs = value;
3780  break;
3781  case USE_SERIAL:
3782  ftdi->eeprom->use_serial = value;
3783  break;
3784  case USB_VERSION:
3785  ftdi->eeprom->usb_version = value;
3786  break;
3787  case USE_USB_VERSION:
3788  ftdi->eeprom->use_usb_version = value;
3789  break;
3790  case MAX_POWER:
3791  ftdi->eeprom->max_power = value;
3792  break;
3793  case CHANNEL_A_TYPE:
3794  ftdi->eeprom->channel_a_type = value;
3795  break;
3796  case CHANNEL_B_TYPE:
3797  ftdi->eeprom->channel_b_type = value;
3798  break;
3799  case CHANNEL_A_DRIVER:
3800  ftdi->eeprom->channel_a_driver = value;
3801  break;
3802  case CHANNEL_B_DRIVER:
3803  ftdi->eeprom->channel_b_driver = value;
3804  break;
3805  case CHANNEL_C_DRIVER:
3806  ftdi->eeprom->channel_c_driver = value;
3807  break;
3808  case CHANNEL_D_DRIVER:
3809  ftdi->eeprom->channel_d_driver = value;
3810  break;
3811  case CHANNEL_A_RS485:
3812  ftdi->eeprom->channel_a_rs485enable = value;
3813  break;
3814  case CHANNEL_B_RS485:
3815  ftdi->eeprom->channel_b_rs485enable = value;
3816  break;
3817  case CHANNEL_C_RS485:
3818  ftdi->eeprom->channel_c_rs485enable = value;
3819  break;
3820  case CHANNEL_D_RS485:
3821  ftdi->eeprom->channel_d_rs485enable = value;
3822  break;
3823  case CBUS_FUNCTION_0:
3824  ftdi->eeprom->cbus_function[0] = value;
3825  break;
3826  case CBUS_FUNCTION_1:
3827  ftdi->eeprom->cbus_function[1] = value;
3828  break;
3829  case CBUS_FUNCTION_2:
3830  ftdi->eeprom->cbus_function[2] = value;
3831  break;
3832  case CBUS_FUNCTION_3:
3833  ftdi->eeprom->cbus_function[3] = value;
3834  break;
3835  case CBUS_FUNCTION_4:
3836  ftdi->eeprom->cbus_function[4] = value;
3837  break;
3838  case CBUS_FUNCTION_5:
3839  ftdi->eeprom->cbus_function[5] = value;
3840  break;
3841  case CBUS_FUNCTION_6:
3842  ftdi->eeprom->cbus_function[6] = value;
3843  break;
3844  case CBUS_FUNCTION_7:
3845  ftdi->eeprom->cbus_function[7] = value;
3846  break;
3847  case CBUS_FUNCTION_8:
3848  ftdi->eeprom->cbus_function[8] = value;
3849  break;
3850  case CBUS_FUNCTION_9:
3851  ftdi->eeprom->cbus_function[9] = value;
3852  break;
3853  case HIGH_CURRENT:
3854  ftdi->eeprom->high_current = value;
3855  break;
3856  case HIGH_CURRENT_A:
3857  ftdi->eeprom->high_current_a = value;
3858  break;
3859  case HIGH_CURRENT_B:
3860  ftdi->eeprom->high_current_b = value;
3861  break;
3862  case INVERT:
3863  ftdi->eeprom->invert = value;
3864  break;
3865  case GROUP0_DRIVE:
3866  ftdi->eeprom->group0_drive = value;
3867  break;
3868  case GROUP0_SCHMITT:
3869  ftdi->eeprom->group0_schmitt = value;
3870  break;
3871  case GROUP0_SLEW:
3872  ftdi->eeprom->group0_slew = value;
3873  break;
3874  case GROUP1_DRIVE:
3875  ftdi->eeprom->group1_drive = value;
3876  break;
3877  case GROUP1_SCHMITT:
3878  ftdi->eeprom->group1_schmitt = value;
3879  break;
3880  case GROUP1_SLEW:
3881  ftdi->eeprom->group1_slew = value;
3882  break;
3883  case GROUP2_DRIVE:
3884  ftdi->eeprom->group2_drive = value;
3885  break;
3886  case GROUP2_SCHMITT:
3887  ftdi->eeprom->group2_schmitt = value;
3888  break;
3889  case GROUP2_SLEW:
3890  ftdi->eeprom->group2_slew = value;
3891  break;
3892  case GROUP3_DRIVE:
3893  ftdi->eeprom->group3_drive = value;
3894  break;
3895  case GROUP3_SCHMITT:
3896  ftdi->eeprom->group3_schmitt = value;
3897  break;
3898  case GROUP3_SLEW:
3899  ftdi->eeprom->group3_slew = value;
3900  break;
3901  case CHIP_TYPE:
3902  ftdi->eeprom->chip = value;
3903  break;
3904  case POWER_SAVE:
3905  ftdi->eeprom->powersave = value;
3906  break;
3907  case CLOCK_POLARITY:
3908  ftdi->eeprom->clock_polarity = value;
3909  break;
3910  case DATA_ORDER:
3911  ftdi->eeprom->data_order = value;
3912  break;
3913  case FLOW_CONTROL:
3914  ftdi->eeprom->flow_control = value;
3915  break;
3916  case CHIP_SIZE:
3917  ftdi_error_return(-2, "EEPROM Value can't be changed");
3918  default :
3919  ftdi_error_return(-1, "Request to unknown EEPROM value");
3920  }
3922  return 0;
3923 }
3924 
3935 int ftdi_get_eeprom_buf(struct ftdi_context *ftdi, unsigned char * buf, int size)
3936 {
3937  if (!ftdi || !(ftdi->eeprom))
3938  ftdi_error_return(-1, "No appropriate structure");
3939 
3940  if (!buf || size < ftdi->eeprom->size)
3941  ftdi_error_return(-1, "Not enough room to store eeprom");
3942 
3943  // Only copy up to FTDI_MAX_EEPROM_SIZE bytes
3944  if (size > FTDI_MAX_EEPROM_SIZE)
3945  size = FTDI_MAX_EEPROM_SIZE;
3946 
3947  memcpy(buf, ftdi->eeprom->buf, size);
3948 
3949  return 0;
3950 }
3951 
3961 int ftdi_set_eeprom_buf(struct ftdi_context *ftdi, const unsigned char * buf, int size)
3962 {
3963  if (!ftdi || !(ftdi->eeprom) || !buf)
3964  ftdi_error_return(-1, "No appropriate structure");
3965 
3966  // Only copy up to FTDI_MAX_EEPROM_SIZE bytes
3967  if (size > FTDI_MAX_EEPROM_SIZE)
3968  size = FTDI_MAX_EEPROM_SIZE;
3969 
3970  memcpy(ftdi->eeprom->buf, buf, size);
3971 
3972  return 0;
3973 }
3974 
3986 int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
3987 {
3988  if (ftdi == NULL || ftdi->usb_dev == NULL)
3989  ftdi_error_return(-2, "USB device unavailable");
3990 
3991  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, eeprom_addr, (unsigned char *)eeprom_val, 2, ftdi->usb_read_timeout) != 2)
3992  ftdi_error_return(-1, "reading eeprom failed");
3993 
3994  return 0;
3995 }
3996 
4007 {
4008  int i;
4009  unsigned char *buf;
4010 
4011  if (ftdi == NULL || ftdi->usb_dev == NULL)
4012  ftdi_error_return(-2, "USB device unavailable");
4013  buf = ftdi->eeprom->buf;
4014 
4015  for (i = 0; i < FTDI_MAX_EEPROM_SIZE/2; i++)
4016  {
4017  if (libusb_control_transfer(
4019  buf+(i*2), 2, ftdi->usb_read_timeout) != 2)
4020  ftdi_error_return(-1, "reading eeprom failed");
4021  }
4022 
4023  if (ftdi->type == TYPE_R)
4024  ftdi->eeprom->size = 0x80;
4025  /* Guesses size of eeprom by comparing halves
4026  - will not work with blank eeprom */
4027  else if (strrchr((const char *)buf, 0xff) == ((const char *)buf +FTDI_MAX_EEPROM_SIZE -1))
4028  ftdi->eeprom->size = -1;
4029  else if (memcmp(buf,&buf[0x80],0x80) == 0)
4030  ftdi->eeprom->size = 0x80;
4031  else if (memcmp(buf,&buf[0x40],0x40) == 0)
4032  ftdi->eeprom->size = 0x40;
4033  else
4034  ftdi->eeprom->size = 0x100;
4035  return 0;
4036 }
4037 
4038 /*
4039  ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID
4040  Function is only used internally
4041  \internal
4042 */
4043 static unsigned char ftdi_read_chipid_shift(unsigned char value)
4044 {
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);
4053 }
4054 
4065 int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
4066 {
4067  unsigned int a = 0, b = 0;
4068 
4069  if (ftdi == NULL || ftdi->usb_dev == NULL)
4070  ftdi_error_return(-2, "USB device unavailable");
4071 
4072  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x43, (unsigned char *)&a, 2, ftdi->usb_read_timeout) == 2)
4073  {
4074  a = a << 8 | a >> 8;
4075  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x44, (unsigned char *)&b, 2, ftdi->usb_read_timeout) == 2)
4076  {
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;
4082  return 0;
4083  }
4084  }
4085 
4086  ftdi_error_return(-1, "read of FTDIChip-ID failed");
4087 }
4088 
4103 int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr,
4104  unsigned short eeprom_val)
4105 {
4106  int chip_type_location;
4107  unsigned short chip_type;
4108 
4109  if (ftdi == NULL || ftdi->usb_dev == NULL)
4110  ftdi_error_return(-2, "USB device unavailable");
4111 
4112  if (eeprom_addr <0x80)
4113  ftdi_error_return(-2, "Invalid access to checksum protected area below 0x80");
4114 
4115 
4116  switch (ftdi->type)
4117  {
4118  case TYPE_BM:
4119  case TYPE_2232C:
4120  chip_type_location = 0x14;
4121  break;
4122  case TYPE_2232H:
4123  case TYPE_4232H:
4124  chip_type_location = 0x18;
4125  break;
4126  case TYPE_232H:
4127  chip_type_location = 0x1e;
4128  break;
4129  default:
4130  ftdi_error_return(-4, "Device can't access unprotected area");
4131  }
4132 
4133  if (ftdi_read_eeprom_location( ftdi, chip_type_location>>1, &chip_type))
4134  ftdi_error_return(-5, "Reading failed");
4135  fprintf(stderr," loc 0x%04x val 0x%04x\n", chip_type_location,chip_type);
4136  if ((chip_type & 0xff) != 0x66)
4137  {
4138  ftdi_error_return(-6, "EEPROM is not of 93x66");
4139  }
4140 
4141  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
4142  SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
4143  NULL, 0, ftdi->usb_write_timeout) != 0)
4144  ftdi_error_return(-1, "unable to write eeprom");
4145 
4146  return 0;
4147 }
4148 
4160 {
4161  unsigned short usb_val, status;
4162  int i, ret;
4163  unsigned char *eeprom;
4164 
4165  if (ftdi == NULL || ftdi->usb_dev == NULL)
4166  ftdi_error_return(-2, "USB device unavailable");
4167 
4169  ftdi_error_return(-3, "EEPROM not initialized for the connected device");
4170 
4171  eeprom = ftdi->eeprom->buf;
4172 
4173  /* These commands were traced while running MProg */
4174  if ((ret = ftdi_usb_reset(ftdi)) != 0)
4175  return ret;
4176  if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0)
4177  return ret;
4178  if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0)
4179  return ret;
4180 
4181  for (i = 0; i < ftdi->eeprom->size/2; i++)
4182  {
4183  /* Do not try to write to reserved area */
4184  if ((ftdi->type == TYPE_230X) && (i == 0x40))
4185  {
4186  i = 0x50;
4187  }
4188  usb_val = eeprom[i*2];
4189  usb_val += eeprom[(i*2)+1] << 8;
4190  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
4191  SIO_WRITE_EEPROM_REQUEST, usb_val, i,
4192  NULL, 0, ftdi->usb_write_timeout) < 0)
4193  ftdi_error_return(-1, "unable to write eeprom");
4194  }
4195 
4196  return 0;
4197 }
4198 
4213 #define MAGIC 0x55aa
4215 {
4216  unsigned short eeprom_value;
4217  if (ftdi == NULL || ftdi->usb_dev == NULL)
4218  ftdi_error_return(-2, "USB device unavailable");
4219 
4220  if (ftdi->type == TYPE_R)
4221  {
4222  ftdi->eeprom->chip = 0;
4223  return 0;
4224  }
4225 
4226  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
4227  0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
4228  ftdi_error_return(-1, "unable to erase eeprom");
4229 
4230 
4231  /* detect chip type by writing 0x55AA as magic at word position 0xc0
4232  Chip is 93x46 if magic is read at word position 0x00, as wraparound happens around 0x40
4233  Chip is 93x56 if magic is read at word position 0x40, as wraparound happens around 0x80
4234  Chip is 93x66 if magic is only read at word position 0xc0*/
4235  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
4237  NULL, 0, ftdi->usb_write_timeout) != 0)
4238  ftdi_error_return(-3, "Writing magic failed");
4239  if (ftdi_read_eeprom_location( ftdi, 0x00, &eeprom_value))
4240  ftdi_error_return(-4, "Reading failed");
4241  if (eeprom_value == MAGIC)
4242  {
4243  ftdi->eeprom->chip = 0x46;
4244  }
4245  else
4246  {
4247  if (ftdi_read_eeprom_location( ftdi, 0x40, &eeprom_value))
4248  ftdi_error_return(-4, "Reading failed");
4249  if (eeprom_value == MAGIC)
4250  ftdi->eeprom->chip = 0x56;
4251  else
4252  {
4253  if (ftdi_read_eeprom_location( ftdi, 0xc0, &eeprom_value))
4254  ftdi_error_return(-4, "Reading failed");
4255  if (eeprom_value == MAGIC)
4256  ftdi->eeprom->chip = 0x66;
4257  else
4258  {
4259  ftdi->eeprom->chip = -1;
4260  }
4261  }
4262  }
4263  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
4264  0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
4265  ftdi_error_return(-1, "unable to erase eeprom");
4266  return 0;
4267 }
4268 
4277 {
4278  if (ftdi == NULL)
4279  return "";
4280 
4281  return ftdi->error_str;
4282 }
4283 
4284 /* @} end of doxygen libftdi group */
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&#39;s only for the uni...
Definition: ftdi.c:1220
#define CHANNEL_IS_FT1284
Definition: ftdi.h:391
int powersave
Definition: ftdi_i.h:120
struct ftdi_transfer_control * ftdi_write_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
Definition: ftdi.c:1520
int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
Definition: ftdi.c:1981
int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
Definition: ftdi.c:635
#define FTDI_DEVICE_OUT_REQTYPE
Definition: ftdi.h:152
enum ftdi_module_detach_mode module_detach_mode
Definition: ftdi.h:271
#define SIO_SET_LATENCY_TIMER_REQUEST
Definition: ftdi.h:164
#define FT1284_CLK_IDLE_STATE
Definition: ftdi.h:347
int out_is_isochronous
Definition: ftdi_i.h:54
ftdi_chip_type
Definition: ftdi.h:36
Definition: ftdi.h:48
list of usb devices created by ftdi_usb_find_all()
Definition: ftdi.h:340
#define SLOW_SLEW
Definition: ftdi.h:399
struct ftdi_device_list * next
Definition: ftdi.h:343
int ftdi_eeprom_set_strings(struct ftdi_context *ftdi, char *manufacturer, char *product, char *serial)
Definition: ftdi.c:2441
int usb_version
Definition: ftdi_i.h:61
int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
Definition: ftdi.c:1911
void ftdi_list_free2(struct ftdi_device_list *devlist)
Definition: ftdi.c:377
int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
Definition: ftdi.c:934
#define SIO_SET_EVENT_CHAR_REQUEST
Definition: ftdi.h:162
int ftdi_read_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
Definition: ftdi.c:3986
int clock_polarity
Definition: ftdi_i.h:122
void ftdi_deinit(struct ftdi_context *ftdi)
Definition: ftdi.c:210
#define HIGH_CURRENT_DRIVE
Definition: ftdi.h:411
void ftdi_set_usbdev(struct ftdi_context *ftdi, libusb_device_handle *usb)
Definition: ftdi.c:268
int remote_wakeup
Definition: ftdi_i.h:44
#define SIO_READ_PINS_REQUEST
Definition: ftdi.h:167
#define SIO_RESET_REQUEST
Definition: ftdi.h:156
ftdi_eeprom_value
Definition: ftdi.h:277
ftdi_interface
Definition: ftdi.h:72
int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product, const char *description, const char *serial, unsigned int index)
Definition: ftdi.c:691
#define SUSPEND_DBUS7_BIT
Definition: ftdi.h:408
#define FTDI_MINOR_VERSION
Definition: ftdi_version_i.h:5
Definition: ftdi.h:54
void set_ft232h_cbus(struct ftdi_eeprom *eeprom, unsigned char *output)
Definition: ftdi.c:2491
#define SIO_SET_BAUDRATE_REQUEST
Definition: ftdi.h:157
struct libusb_transfer * transfer
Definition: ftdi.h:211
#define DRIVE_16MA
Definition: ftdi.h:398
int channel_b_driver
Definition: ftdi_i.h:81
int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
Definition: ftdi.c:1237
#define FTDI_MAJOR_VERSION
Definition: ftdi_version_i.h:4
#define SIO_SET_DATA_REQUEST
Definition: ftdi.h:158
int ftdi_write_data(struct ftdi_context *ftdi, const unsigned char *buf, int size)
Definition: ftdi.c:1372
#define SIO_WRITE_EEPROM_REQUEST
Definition: ftdi.h:169
int group3_drive
Definition: ftdi_i.h:116
Main context structure for all libftdi functions.
Definition: ftdi.h:219
int channel_c_driver
Definition: ftdi_i.h:82
const char * version_str
Definition: ftdi.h:449
int group3_schmitt
Definition: ftdi_i.h:117
int ftdi_set_event_char(struct ftdi_context *ftdi, unsigned char eventch, unsigned char enable)
Definition: ftdi.c:2234
#define DRIVER_VCP
Definition: ftdi.h:403
int max_power
Definition: ftdi_i.h:65
Definition: ftdi.h:41
#define MAX_POWER_MILLIAMP_PER_UNIT
Definition: ftdi_i.h:25
int group1_schmitt
Definition: ftdi_i.h:111
int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
Definition: ftdi.c:1932
void ftdi_list_free(struct ftdi_device_list **devlist)
Definition: ftdi.c:357
enum ftdi_chip_type type
Definition: ftdi.h:233
char * serial
Definition: ftdi_i.h:72
#define CHANNEL_IS_UART
Definition: ftdi.h:387
#define FTDI_DEVICE_IN_REQTYPE
Definition: ftdi.h:153
int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits, enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
Definition: ftdi.c:1283
int channel_b_rs485enable
Definition: ftdi_i.h:86
int cbus_function[10]
Definition: ftdi_i.h:92
int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
Definition: ftdi.c:908
#define DRIVER_VCPH
Definition: ftdi.h:404
struct ftdi_context * ftdi_new(void)
Definition: ftdi.c:128
int ftdi_erase_eeprom(struct ftdi_context *ftdi)
Definition: ftdi.c:4214
Definition: ftdi.h:45
Definition: ftdi.h:39
int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
Definition: ftdi.c:157
#define C_CLK
int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char *manufacturer, char *product, char *serial)
Definition: ftdi.c:2293
int ftdi_transfer_data_done(struct ftdi_transfer_control *tc)
Definition: ftdi.c:1661
int size
Definition: ftdi_i.h:128
unsigned int readbuffer_remaining
Definition: ftdi.h:243
int group0_slew
Definition: ftdi_i.h:109
int ftdi_set_error_char(struct ftdi_context *ftdi, unsigned char errorch, unsigned char enable)
Definition: ftdi.c:2263
#define USE_SERIAL_NUM
Definition: ftdi.h:352
int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose)
Definition: ftdi.c:3125
int vendor_id
Definition: ftdi_i.h:33
int in_is_isochronous
Definition: ftdi_i.h:52
int out_ep
Definition: ftdi.h:259
#define CHANNEL_IS_FIFO
Definition: ftdi.h:388
struct libusb_device * dev
Definition: ftdi.h:345
int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int *value)
Definition: ftdi.c:3557
int chip
Definition: ftdi_i.h:130
#define SIO_GET_LATENCY_TIMER_REQUEST
Definition: ftdi.h:165
int initialized_for_connected_device
Definition: ftdi_i.h:39
ftdi_bits_type
Definition: ftdi.h:52
#define FTDI_MICRO_VERSION
Definition: ftdi_version_i.h:6
Definition: ftdi.h:44
int high_current_b
Definition: ftdi_i.h:98
#define FT1284_FLOW_CONTROL
Definition: ftdi.h:349
int channel_c_rs485enable
Definition: ftdi_i.h:87
int ftdi_init(struct ftdi_context *ftdi)
Definition: ftdi.c:88
char * error_str
Definition: ftdi.h:268
int group0_schmitt
Definition: ftdi_i.h:108
int flow_control
Definition: ftdi_i.h:124
unsigned char * readbuffer
Definition: ftdi.h:239
#define USE_USB_VERSION_BIT
Definition: ftdi.h:406
struct ftdi_transfer_control * ftdi_read_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
Definition: ftdi.c:1582
struct libusb_context * usb_ctx
Definition: ftdi.h:223
unsigned char buf[FTDI_MAX_EEPROM_SIZE]
Definition: ftdi_i.h:131
int usb_write_timeout
Definition: ftdi.h:229
int suspend_dbus7
Definition: ftdi_i.h:49
unsigned int writebuffer_chunksize
Definition: ftdi.h:247
#define CHANNEL_IS_RS485
Definition: ftdi.h:393
Definition: ftdi.h:38
#define SIO_READ_EEPROM_REQUEST
Definition: ftdi.h:168
Definition: ftdi.h:48
int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
Definition: ftdi.c:2088
#define FTDI_MAX_EEPROM_SIZE
Definition: ftdi_i.h:22
int group1_drive
Definition: ftdi_i.h:110
int usb_read_timeout
Definition: ftdi.h:227
int index
Definition: ftdi.h:255
int channel_d_driver
Definition: ftdi_i.h:83
int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
Definition: ftdi.c:2198
int in_ep
Definition: ftdi.h:258
#define HIGH_CURRENT_DRIVE_R
Definition: ftdi.h:412
#define IS_SCHMITT
Definition: ftdi.h:400
#define SIO_SET_FLOW_CTRL_REQUEST
Definition: ftdi.h:159
int high_current_a
Definition: ftdi_i.h:96
#define FT1284_DATA_LSB
Definition: ftdi.h:348
char * manufacturer
Definition: ftdi_i.h:68
#define SIO_SET_BITMODE_REQUEST
Definition: ftdi.h:166
int ftdi_set_eeprom_buf(struct ftdi_context *ftdi, const unsigned char *buf, int size)
Definition: ftdi.c:3961
#define SIO_SET_ERROR_CHAR_REQUEST
Definition: ftdi.h:163
int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
Definition: ftdi.c:1707
int channel_b_type
Definition: ftdi_i.h:78
unsigned char bitbang_mode
Definition: ftdi.h:262
#define CHANNEL_IS_CPU
Definition: ftdi.h:390
int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev)
Definition: ftdi.c:522
struct ftdi_context * ftdi
Definition: ftdi.h:210
int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int value)
Definition: ftdi.c:3747
Definition: ftdi.h:48
int group0_drive
Definition: ftdi_i.h:107
int group2_slew
Definition: ftdi_i.h:115
int suspend_pull_downs
Definition: ftdi_i.h:56
const char * snapshot_str
Definition: ftdi.h:450
#define POWER_SAVE_DISABLE_H
Definition: ftdi.h:350
int product_id
Definition: ftdi_i.h:35
#define SIO_SET_MODEM_CTRL_REQUEST
Definition: ftdi.h:160
#define SIO_POLL_MODEM_STATUS_REQUEST
Definition: ftdi.h:161
Definition: ftdi.h:48
int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
Definition: ftdi.c:2114
int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product, const char *description, const char *serial)
Definition: ftdi.c:661
char * product
Definition: ftdi_i.h:70
int invert
Definition: ftdi_i.h:100
Definition: ftdi.h:48
struct libusb_device_handle * usb_dev
Definition: ftdi.h:225
int interface
Definition: ftdi.h:253
ftdi_break_type
Definition: ftdi.h:54
int ftdi_usb_close(struct ftdi_context *ftdi)
Definition: ftdi.c:986
int channel_d_rs485enable
Definition: ftdi_i.h:88
unsigned int max_packet_size
Definition: ftdi.h:249
int ftdi_setrts(struct ftdi_context *ftdi, int state)
Definition: ftdi.c:2167
int ftdi_usb_reset(struct ftdi_context *ftdi)
Definition: ftdi.c:882
int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
Definition: ftdi.c:2034
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)
Definition: ftdi.c:408
int channel_a_type
Definition: ftdi_i.h:77
ftdi_parity_type
Definition: ftdi.h:48
int use_serial
Definition: ftdi_i.h:59
int group2_schmitt
Definition: ftdi_i.h:114
unsigned char * buf
Definition: ftdi.h:207
struct ftdi_version_info ftdi_get_library_version(void)
Get libftdi library version.
Definition: ftdi.c:281
int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
Definition: ftdi.c:1874
#define SIO_RESET_PURGE_RX
Definition: ftdi.h:174
int data_order
Definition: ftdi_i.h:123
int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
Definition: ftdi.c:1725
#define SIO_SET_DTR_HIGH
Definition: ftdi.h:183
#define SIO_RESET_SIO
Definition: ftdi.h:173
unsigned char bitbang_enabled
Definition: ftdi.h:237
int channel_a_rs485enable
Definition: ftdi_i.h:85
int ftdi_write_eeprom(struct ftdi_context *ftdi)
Definition: ftdi.c:4159
int ftdi_usb_open_string(struct ftdi_context *ftdi, const char *description)
Definition: ftdi.c:789
int ftdi_disable_bitbang(struct ftdi_context *ftdi)
Definition: ftdi.c:1958
int self_powered
Definition: ftdi_i.h:42
int ftdi_setdtr(struct ftdi_context *ftdi, int state)
Definition: ftdi.c:2137
int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
Definition: ftdi.c:2007
ftdi_stopbits_type
Definition: ftdi.h:50
FTDI eeprom structure.
Definition: ftdi_i.h:30
#define CHANNEL_IS_OPTO
Definition: ftdi.h:389
#define SIO_RESET_PURGE_TX
Definition: ftdi.h:175
Definition: ftdi.h:357
int high_current
Definition: ftdi_i.h:94
unsigned int readbuffer_chunksize
Definition: ftdi.h:245
int channel_a_driver
Definition: ftdi_i.h:80
int ftdi_read_eeprom(struct ftdi_context *ftdi)
Definition: ftdi.c:4006
char * ftdi_get_error_string(struct ftdi_context *ftdi)
Definition: ftdi.c:4276
int baudrate
Definition: ftdi.h:235
#define SIO_ERASE_EEPROM_REQUEST
Definition: ftdi.h:170
int ftdi_eeprom_build(struct ftdi_context *ftdi)
Definition: ftdi.c:2560
Definition: ftdi.h:309
int release_number
Definition: ftdi_i.h:134
int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
Definition: ftdi.c:957
int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
Definition: ftdi.c:1749
int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short eeprom_val)
Definition: ftdi.c:4103
#define ftdi_error_return_free_device_list(code, str, devs)
Definition: ftdi.c:49
int ftdi_get_eeprom_buf(struct ftdi_context *ftdi, unsigned char *buf, int size)
Definition: ftdi.c:3935
int group3_slew
Definition: ftdi_i.h:118
#define H_CLK
Definition: ftdi.h:54
#define ftdi_error_return(code, str)
Definition: ftdi.c:41
unsigned int readbuffer_offset
Definition: ftdi.h:241
int group1_slew
Definition: ftdi_i.h:112
void ftdi_free(struct ftdi_context *ftdi)
Definition: ftdi.c:256
int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
Definition: ftdi.c:4065
int group2_drive
Definition: ftdi_i.h:113
int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
Definition: ftdi.c:310
#define SIO_SET_RTS_HIGH
Definition: ftdi.h:186
#define SIO_SET_RTS_LOW
Definition: ftdi.h:187
#define MAGIC
Definition: ftdi.c:4213
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)
Definition: ftdi.c:1302
const char FTDI_VERSION_STRING[]
Definition: ftdi_version_i.h:8
int is_not_pnp
Definition: ftdi_i.h:46
const char FTDI_SNAPSHOT_VERSION[]
Definition: ftdi_version_i.h:9
#define SIO_SET_DTR_LOW
Definition: ftdi.h:184
struct ftdi_eeprom * eeprom
Definition: ftdi.h:265
int use_usb_version
Definition: ftdi_i.h:63