libftdi1  1.4
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-2017 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)
72  ftdi->eeprom->initialized_for_connected_device = 0;
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;
106  ftdi->module_detach_mode = AUTO_DETACH_SIO_MODULE;
107 
108  if (libusb_init(&ftdi->usb_ctx) < 0)
109  ftdi_error_return(-3, "libusb_init() failed");
110 
111  ftdi_set_interface(ftdi, INTERFACE_ANY);
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 
157 int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
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 
281 struct ftdi_version_info ftdi_get_library_version(void)
282 {
283  struct ftdi_version_info ver;
284 
285  ver.major = FTDI_MAJOR_VERSION;
286  ver.minor = FTDI_MINOR_VERSION;
287  ver.micro = FTDI_MICRO_VERSION;
288  ver.version_str = FTDI_VERSION_STRING;
289  ver.snapshot_str = FTDI_SNAPSHOT_VERSION;
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 || product) &&
332  desc.idVendor == vendor && desc.idProduct == product) ||
333  (!(vendor || product) &&
334  (desc.idVendor == 0x403) && (desc.idProduct == 0x6001 || desc.idProduct == 0x6010
335  || desc.idProduct == 0x6011 || desc.idProduct == 0x6014
336  || desc.idProduct == 0x6015)))
337  {
338  *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
339  if (!*curdev)
340  ftdi_error_return_free_device_list(-3, "out of memory", devs);
341 
342  (*curdev)->next = NULL;
343  (*curdev)->dev = dev;
344  libusb_ref_device(dev);
345  curdev = &(*curdev)->next;
346  count++;
347  }
348  }
349  libusb_free_device_list(devs,1);
350  return count;
351 }
352 
358 void ftdi_list_free(struct ftdi_device_list **devlist)
359 {
360  struct ftdi_device_list *curdev, *next;
361 
362  for (curdev = *devlist; curdev != NULL;)
363  {
364  next = curdev->next;
365  libusb_unref_device(curdev->dev);
366  free(curdev);
367  curdev = next;
368  }
369 
370  *devlist = NULL;
371 }
372 
378 void ftdi_list_free2(struct ftdi_device_list *devlist)
379 {
380  ftdi_list_free(&devlist);
381 }
382 
409 int ftdi_usb_get_strings(struct ftdi_context *ftdi,
410  struct libusb_device *dev,
411  char *manufacturer, int mnf_len,
412  char *description, int desc_len,
413  char *serial, int serial_len)
414 {
415  int ret;
416 
417  if ((ftdi==NULL) || (dev==NULL))
418  return -1;
419 
420  if (ftdi->usb_dev == NULL && libusb_open(dev, &ftdi->usb_dev) < 0)
421  ftdi_error_return(-4, "libusb_open() failed");
422 
423  // ftdi->usb_dev will not be NULL when entering ftdi_usb_get_strings2(), so
424  // it won't be closed either. This allows us to close it whether we actually
425  // called libusb_open() up above or not. This matches the expected behavior
426  // (and note) for ftdi_usb_get_strings().
427  ret = ftdi_usb_get_strings2(ftdi, dev,
428  manufacturer, mnf_len,
429  description, desc_len,
430  serial, serial_len);
431 
432  // only close it if it was successful, as all other return codes close
433  // before returning already.
434  if (ret == 0)
435  ftdi_usb_close_internal(ftdi);
436 
437  return ret;
438 }
439 
466 int ftdi_usb_get_strings2(struct ftdi_context *ftdi, struct libusb_device *dev,
467  char *manufacturer, int mnf_len,
468  char *description, int desc_len,
469  char *serial, int serial_len)
470 {
471  struct libusb_device_descriptor desc;
472  char need_open;
473 
474  if ((ftdi==NULL) || (dev==NULL))
475  return -1;
476 
477  need_open = (ftdi->usb_dev == NULL);
478  if (need_open && libusb_open(dev, &ftdi->usb_dev) < 0)
479  ftdi_error_return(-4, "libusb_open() failed");
480 
481  if (libusb_get_device_descriptor(dev, &desc) < 0)
482  ftdi_error_return(-11, "libusb_get_device_descriptor() failed");
483 
484  if (manufacturer != NULL)
485  {
486  if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iManufacturer, (unsigned char *)manufacturer, mnf_len) < 0)
487  {
488  ftdi_usb_close_internal (ftdi);
489  ftdi_error_return(-7, "libusb_get_string_descriptor_ascii() failed");
490  }
491  }
492 
493  if (description != NULL)
494  {
495  if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)description, desc_len) < 0)
496  {
497  ftdi_usb_close_internal (ftdi);
498  ftdi_error_return(-8, "libusb_get_string_descriptor_ascii() failed");
499  }
500  }
501 
502  if (serial != NULL)
503  {
504  if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)serial, serial_len) < 0)
505  {
506  ftdi_usb_close_internal (ftdi);
507  ftdi_error_return(-9, "libusb_get_string_descriptor_ascii() failed");
508  }
509  }
510 
511  if (need_open)
512  ftdi_usb_close_internal (ftdi);
513 
514  return 0;
515 }
516 
523 static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, libusb_device *dev)
524 {
525  struct libusb_device_descriptor desc;
526  struct libusb_config_descriptor *config0;
527  unsigned int packet_size;
528 
529  // Sanity check
530  if (ftdi == NULL || dev == NULL)
531  return 64;
532 
533  // Determine maximum packet size. Init with default value.
534  // New hi-speed devices from FTDI use a packet size of 512 bytes
535  // but could be connected to a normal speed USB hub -> 64 bytes packet size.
536  if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H)
537  packet_size = 512;
538  else
539  packet_size = 64;
540 
541  if (libusb_get_device_descriptor(dev, &desc) < 0)
542  return packet_size;
543 
544  if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
545  return packet_size;
546 
547  if (desc.bNumConfigurations > 0)
548  {
549  if (ftdi->interface < config0->bNumInterfaces)
550  {
551  struct libusb_interface interface = config0->interface[ftdi->interface];
552  if (interface.num_altsetting > 0)
553  {
554  struct libusb_interface_descriptor descriptor = interface.altsetting[0];
555  if (descriptor.bNumEndpoints > 0)
556  {
557  packet_size = descriptor.endpoint[0].wMaxPacketSize;
558  }
559  }
560  }
561  }
562 
563  libusb_free_config_descriptor (config0);
564  return packet_size;
565 }
566 
585 int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev)
586 {
587  struct libusb_device_descriptor desc;
588  struct libusb_config_descriptor *config0;
589  int cfg, cfg0, detach_errno = 0;
590 
591  if (ftdi == NULL)
592  ftdi_error_return(-8, "ftdi context invalid");
593 
594  if (libusb_open(dev, &ftdi->usb_dev) < 0)
595  ftdi_error_return(-4, "libusb_open() failed");
596 
597  if (libusb_get_device_descriptor(dev, &desc) < 0)
598  ftdi_error_return(-9, "libusb_get_device_descriptor() failed");
599 
600  if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
601  ftdi_error_return(-10, "libusb_get_config_descriptor() failed");
602  cfg0 = config0->bConfigurationValue;
603  libusb_free_config_descriptor (config0);
604 
605  // Try to detach ftdi_sio kernel module.
606  //
607  // The return code is kept in a separate variable and only parsed
608  // if usb_set_configuration() or usb_claim_interface() fails as the
609  // detach operation might be denied and everything still works fine.
610  // Likely scenario is a static ftdi_sio kernel module.
611  if (ftdi->module_detach_mode == AUTO_DETACH_SIO_MODULE)
612  {
613  if (libusb_detach_kernel_driver(ftdi->usb_dev, ftdi->interface) !=0)
614  detach_errno = errno;
615  }
616 
617  if (libusb_get_configuration (ftdi->usb_dev, &cfg) < 0)
618  ftdi_error_return(-12, "libusb_get_configuration () failed");
619  // set configuration (needed especially for windows)
620  // tolerate EBUSY: one device with one configuration, but two interfaces
621  // and libftdi sessions to both interfaces (e.g. FT2232)
622  if (desc.bNumConfigurations > 0 && cfg != cfg0)
623  {
624  if (libusb_set_configuration(ftdi->usb_dev, cfg0) < 0)
625  {
626  ftdi_usb_close_internal (ftdi);
627  if (detach_errno == EPERM)
628  {
629  ftdi_error_return(-8, "inappropriate permissions on device!");
630  }
631  else
632  {
633  ftdi_error_return(-3, "unable to set usb configuration. Make sure the default FTDI driver is not in use");
634  }
635  }
636  }
637 
638  if (libusb_claim_interface(ftdi->usb_dev, ftdi->interface) < 0)
639  {
640  ftdi_usb_close_internal (ftdi);
641  if (detach_errno == EPERM)
642  {
643  ftdi_error_return(-8, "inappropriate permissions on device!");
644  }
645  else
646  {
647  ftdi_error_return(-5, "unable to claim usb device. Make sure the default FTDI driver is not in use");
648  }
649  }
650 
651  if (ftdi_usb_reset (ftdi) != 0)
652  {
653  ftdi_usb_close_internal (ftdi);
654  ftdi_error_return(-6, "ftdi_usb_reset failed");
655  }
656 
657  // Try to guess chip type
658  // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
659  if (desc.bcdDevice == 0x400 || (desc.bcdDevice == 0x200
660  && desc.iSerialNumber == 0))
661  ftdi->type = TYPE_BM;
662  else if (desc.bcdDevice == 0x200)
663  ftdi->type = TYPE_AM;
664  else if (desc.bcdDevice == 0x500)
665  ftdi->type = TYPE_2232C;
666  else if (desc.bcdDevice == 0x600)
667  ftdi->type = TYPE_R;
668  else if (desc.bcdDevice == 0x700)
669  ftdi->type = TYPE_2232H;
670  else if (desc.bcdDevice == 0x800)
671  ftdi->type = TYPE_4232H;
672  else if (desc.bcdDevice == 0x900)
673  ftdi->type = TYPE_232H;
674  else if (desc.bcdDevice == 0x1000)
675  ftdi->type = TYPE_230X;
676 
677  // Determine maximum packet size
678  ftdi->max_packet_size = _ftdi_determine_max_packet_size(ftdi, dev);
679 
680  if (ftdi_set_baudrate (ftdi, 9600) != 0)
681  {
682  ftdi_usb_close_internal (ftdi);
683  ftdi_error_return(-7, "set baudrate failed");
684  }
685 
686  ftdi_error_return(0, "all fine");
687 }
688 
698 int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
699 {
700  return ftdi_usb_open_desc(ftdi, vendor, product, NULL, NULL);
701 }
702 
724 int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
725  const char* description, const char* serial)
726 {
727  return ftdi_usb_open_desc_index(ftdi,vendor,product,description,serial,0);
728 }
729 
755 int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product,
756  const char* description, const char* serial, unsigned int index)
757 {
758  libusb_device *dev;
759  libusb_device **devs;
760  char string[256];
761  int i = 0;
762 
763  if (ftdi == NULL)
764  ftdi_error_return(-11, "ftdi context invalid");
765 
766  if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
767  ftdi_error_return(-12, "libusb_get_device_list() failed");
768 
769  while ((dev = devs[i++]) != NULL)
770  {
771  struct libusb_device_descriptor desc;
772  int res;
773 
774  if (libusb_get_device_descriptor(dev, &desc) < 0)
775  ftdi_error_return_free_device_list(-13, "libusb_get_device_descriptor() failed", devs);
776 
777  if (desc.idVendor == vendor && desc.idProduct == product)
778  {
779  if (libusb_open(dev, &ftdi->usb_dev) < 0)
780  ftdi_error_return_free_device_list(-4, "usb_open() failed", devs);
781 
782  if (description != NULL)
783  {
784  if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)string, sizeof(string)) < 0)
785  {
786  ftdi_usb_close_internal (ftdi);
787  ftdi_error_return_free_device_list(-8, "unable to fetch product description", devs);
788  }
789  if (strncmp(string, description, sizeof(string)) != 0)
790  {
791  ftdi_usb_close_internal (ftdi);
792  continue;
793  }
794  }
795  if (serial != NULL)
796  {
797  if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)string, sizeof(string)) < 0)
798  {
799  ftdi_usb_close_internal (ftdi);
800  ftdi_error_return_free_device_list(-9, "unable to fetch serial number", devs);
801  }
802  if (strncmp(string, serial, sizeof(string)) != 0)
803  {
804  ftdi_usb_close_internal (ftdi);
805  continue;
806  }
807  }
808 
809  ftdi_usb_close_internal (ftdi);
810 
811  if (index > 0)
812  {
813  index--;
814  continue;
815  }
816 
817  res = ftdi_usb_open_dev(ftdi, dev);
818  libusb_free_device_list(devs,1);
819  return res;
820  }
821  }
822 
823  // device not found
824  ftdi_error_return_free_device_list(-3, "device not found", devs);
825 }
826 
848 int ftdi_usb_open_bus_addr(struct ftdi_context *ftdi, uint8_t bus, uint8_t addr)
849 {
850  libusb_device *dev;
851  libusb_device **devs;
852  int i = 0;
853 
854  if (ftdi == NULL)
855  ftdi_error_return(-11, "ftdi context invalid");
856 
857  if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
858  ftdi_error_return(-12, "libusb_get_device_list() failed");
859 
860  while ((dev = devs[i++]) != NULL)
861  {
862  if (libusb_get_bus_number(dev) == bus && libusb_get_device_address(dev) == addr)
863  {
864  int res;
865  res = ftdi_usb_open_dev(ftdi, dev);
866  libusb_free_device_list(devs,1);
867  return res;
868  }
869  }
870 
871  // device not found
872  ftdi_error_return_free_device_list(-3, "device not found", devs);
873 }
874 
901 int ftdi_usb_open_string(struct ftdi_context *ftdi, const char* description)
902 {
903  if (ftdi == NULL)
904  ftdi_error_return(-12, "ftdi context invalid");
905 
906  if (description[0] == 0 || description[1] != ':')
907  ftdi_error_return(-11, "illegal description format");
908 
909  if (description[0] == 'd')
910  {
911  libusb_device *dev;
912  libusb_device **devs;
913  unsigned int bus_number, device_address;
914  int i = 0;
915 
916  if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
917  ftdi_error_return(-2, "libusb_get_device_list() failed");
918 
919  /* XXX: This doesn't handle symlinks/odd paths/etc... */
920  if (sscanf (description + 2, "%u/%u", &bus_number, &device_address) != 2)
921  ftdi_error_return_free_device_list(-11, "illegal description format", devs);
922 
923  while ((dev = devs[i++]) != NULL)
924  {
925  int ret;
926  if (bus_number == libusb_get_bus_number (dev)
927  && device_address == libusb_get_device_address (dev))
928  {
929  ret = ftdi_usb_open_dev(ftdi, dev);
930  libusb_free_device_list(devs,1);
931  return ret;
932  }
933  }
934 
935  // device not found
936  ftdi_error_return_free_device_list(-3, "device not found", devs);
937  }
938  else if (description[0] == 'i' || description[0] == 's')
939  {
940  unsigned int vendor;
941  unsigned int product;
942  unsigned int index=0;
943  const char *serial=NULL;
944  const char *startp, *endp;
945 
946  errno=0;
947  startp=description+2;
948  vendor=strtoul((char*)startp,(char**)&endp,0);
949  if (*endp != ':' || endp == startp || errno != 0)
950  ftdi_error_return(-11, "illegal description format");
951 
952  startp=endp+1;
953  product=strtoul((char*)startp,(char**)&endp,0);
954  if (endp == startp || errno != 0)
955  ftdi_error_return(-11, "illegal description format");
956 
957  if (description[0] == 'i' && *endp != 0)
958  {
959  /* optional index field in i-mode */
960  if (*endp != ':')
961  ftdi_error_return(-11, "illegal description format");
962 
963  startp=endp+1;
964  index=strtoul((char*)startp,(char**)&endp,0);
965  if (*endp != 0 || endp == startp || errno != 0)
966  ftdi_error_return(-11, "illegal description format");
967  }
968  if (description[0] == 's')
969  {
970  if (*endp != ':')
971  ftdi_error_return(-11, "illegal description format");
972 
973  /* rest of the description is the serial */
974  serial=endp+1;
975  }
976 
977  return ftdi_usb_open_desc_index(ftdi, vendor, product, NULL, serial, index);
978  }
979  else
980  {
981  ftdi_error_return(-11, "illegal description format");
982  }
983 }
984 
994 int ftdi_usb_reset(struct ftdi_context *ftdi)
995 {
996  if (ftdi == NULL || ftdi->usb_dev == NULL)
997  ftdi_error_return(-2, "USB device unavailable");
998 
999  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1000  SIO_RESET_REQUEST, SIO_RESET_SIO,
1001  ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1002  ftdi_error_return(-1,"FTDI reset failed");
1003 
1004  // Invalidate data in the readbuffer
1005  ftdi->readbuffer_offset = 0;
1006  ftdi->readbuffer_remaining = 0;
1007 
1008  return 0;
1009 }
1010 
1020 int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
1021 {
1022  if (ftdi == NULL || ftdi->usb_dev == NULL)
1023  ftdi_error_return(-2, "USB device unavailable");
1024 
1025  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1026  SIO_RESET_REQUEST, SIO_RESET_PURGE_RX,
1027  ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1028  ftdi_error_return(-1, "FTDI purge of RX buffer failed");
1029 
1030  // Invalidate data in the readbuffer
1031  ftdi->readbuffer_offset = 0;
1032  ftdi->readbuffer_remaining = 0;
1033 
1034  return 0;
1035 }
1036 
1046 int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
1047 {
1048  if (ftdi == NULL || ftdi->usb_dev == NULL)
1049  ftdi_error_return(-2, "USB device unavailable");
1050 
1051  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1052  SIO_RESET_REQUEST, SIO_RESET_PURGE_TX,
1053  ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1054  ftdi_error_return(-1, "FTDI purge of TX buffer failed");
1055 
1056  return 0;
1057 }
1058 
1069 int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
1070 {
1071  int result;
1072 
1073  if (ftdi == NULL || ftdi->usb_dev == NULL)
1074  ftdi_error_return(-3, "USB device unavailable");
1075 
1076  result = ftdi_usb_purge_rx_buffer(ftdi);
1077  if (result < 0)
1078  return -1;
1079 
1080  result = ftdi_usb_purge_tx_buffer(ftdi);
1081  if (result < 0)
1082  return -2;
1083 
1084  return 0;
1085 }
1086 
1087 
1088 
1098 int ftdi_usb_close(struct ftdi_context *ftdi)
1099 {
1100  int rtn = 0;
1101 
1102  if (ftdi == NULL)
1103  ftdi_error_return(-3, "ftdi context invalid");
1104 
1105  if (ftdi->usb_dev != NULL)
1106  if (libusb_release_interface(ftdi->usb_dev, ftdi->interface) < 0)
1107  rtn = -1;
1108 
1109  ftdi_usb_close_internal (ftdi);
1110 
1111  return rtn;
1112 }
1113 
1114 /* ftdi_to_clkbits_AM For the AM device, convert a requested baudrate
1115  to encoded divisor and the achievable baudrate
1116  Function is only used internally
1117  \internal
1118 
1119  See AN120
1120  clk/1 -> 0
1121  clk/1.5 -> 1
1122  clk/2 -> 2
1123  From /2, 0.125/ 0.25 and 0.5 steps may be taken
1124  The fractional part has frac_code encoding
1125 */
1126 static int ftdi_to_clkbits_AM(int baudrate, unsigned long *encoded_divisor)
1127 
1128 {
1129  static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
1130  static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
1131  static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
1132  int divisor, best_divisor, best_baud, best_baud_diff;
1133  int i;
1134  divisor = 24000000 / baudrate;
1135 
1136  // Round down to supported fraction (AM only)
1137  divisor -= am_adjust_dn[divisor & 7];
1138 
1139  // Try this divisor and the one above it (because division rounds down)
1140  best_divisor = 0;
1141  best_baud = 0;
1142  best_baud_diff = 0;
1143  for (i = 0; i < 2; i++)
1144  {
1145  int try_divisor = divisor + i;
1146  int baud_estimate;
1147  int baud_diff;
1148 
1149  // Round up to supported divisor value
1150  if (try_divisor <= 8)
1151  {
1152  // Round up to minimum supported divisor
1153  try_divisor = 8;
1154  }
1155  else if (divisor < 16)
1156  {
1157  // AM doesn't support divisors 9 through 15 inclusive
1158  try_divisor = 16;
1159  }
1160  else
1161  {
1162  // Round up to supported fraction (AM only)
1163  try_divisor += am_adjust_up[try_divisor & 7];
1164  if (try_divisor > 0x1FFF8)
1165  {
1166  // Round down to maximum supported divisor value (for AM)
1167  try_divisor = 0x1FFF8;
1168  }
1169  }
1170  // Get estimated baud rate (to nearest integer)
1171  baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
1172  // Get absolute difference from requested baud rate
1173  if (baud_estimate < baudrate)
1174  {
1175  baud_diff = baudrate - baud_estimate;
1176  }
1177  else
1178  {
1179  baud_diff = baud_estimate - baudrate;
1180  }
1181  if (i == 0 || baud_diff < best_baud_diff)
1182  {
1183  // Closest to requested baud rate so far
1184  best_divisor = try_divisor;
1185  best_baud = baud_estimate;
1186  best_baud_diff = baud_diff;
1187  if (baud_diff == 0)
1188  {
1189  // Spot on! No point trying
1190  break;
1191  }
1192  }
1193  }
1194  // Encode the best divisor value
1195  *encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
1196  // Deal with special cases for encoded value
1197  if (*encoded_divisor == 1)
1198  {
1199  *encoded_divisor = 0; // 3000000 baud
1200  }
1201  else if (*encoded_divisor == 0x4001)
1202  {
1203  *encoded_divisor = 1; // 2000000 baud (BM only)
1204  }
1205  return best_baud;
1206 }
1207 
1208 /* ftdi_to_clkbits Convert a requested baudrate for a given system clock and predivisor
1209  to encoded divisor and the achievable baudrate
1210  Function is only used internally
1211  \internal
1212 
1213  See AN120
1214  clk/1 -> 0
1215  clk/1.5 -> 1
1216  clk/2 -> 2
1217  From /2, 0.125 steps may be taken.
1218  The fractional part has frac_code encoding
1219 
1220  value[13:0] of value is the divisor
1221  index[9] mean 12 MHz Base(120 MHz/10) rate versus 3 MHz (48 MHz/16) else
1222 
1223  H Type have all features above with
1224  {index[8],value[15:14]} is the encoded subdivisor
1225 
1226  FT232R, FT2232 and FT232BM have no option for 12 MHz and with
1227  {index[0],value[15:14]} is the encoded subdivisor
1228 
1229  AM Type chips have only four fractional subdivisors at value[15:14]
1230  for subdivisors 0, 0.5, 0.25, 0.125
1231 */
1232 static int ftdi_to_clkbits(int baudrate, unsigned int clk, int clk_div, unsigned long *encoded_divisor)
1233 {
1234  static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
1235  int best_baud = 0;
1236  int divisor, best_divisor;
1237  if (baudrate >= clk/clk_div)
1238  {
1239  *encoded_divisor = 0;
1240  best_baud = clk/clk_div;
1241  }
1242  else if (baudrate >= clk/(clk_div + clk_div/2))
1243  {
1244  *encoded_divisor = 1;
1245  best_baud = clk/(clk_div + clk_div/2);
1246  }
1247  else if (baudrate >= clk/(2*clk_div))
1248  {
1249  *encoded_divisor = 2;
1250  best_baud = clk/(2*clk_div);
1251  }
1252  else
1253  {
1254  /* We divide by 16 to have 3 fractional bits and one bit for rounding */
1255  divisor = clk*16/clk_div / baudrate;
1256  if (divisor & 1) /* Decide if to round up or down*/
1257  best_divisor = divisor /2 +1;
1258  else
1259  best_divisor = divisor/2;
1260  if(best_divisor > 0x20000)
1261  best_divisor = 0x1ffff;
1262  best_baud = clk*16/clk_div/best_divisor;
1263  if (best_baud & 1) /* Decide if to round up or down*/
1264  best_baud = best_baud /2 +1;
1265  else
1266  best_baud = best_baud /2;
1267  *encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 0x7] << 14);
1268  }
1269  return best_baud;
1270 }
1276 static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
1277  unsigned short *value, unsigned short *index)
1278 {
1279  int best_baud;
1280  unsigned long encoded_divisor;
1281 
1282  if (baudrate <= 0)
1283  {
1284  // Return error
1285  return -1;
1286  }
1287 
1288 #define H_CLK 120000000
1289 #define C_CLK 48000000
1290  if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H) || (ftdi->type == TYPE_232H))
1291  {
1292  if(baudrate*10 > H_CLK /0x3fff)
1293  {
1294  /* On H Devices, use 12 000 000 Baudrate when possible
1295  We have a 14 bit divisor, a 1 bit divisor switch (10 or 16)
1296  three fractional bits and a 120 MHz clock
1297  Assume AN_120 "Sub-integer divisors between 0 and 2 are not allowed" holds for
1298  DIV/10 CLK too, so /1, /1.5 and /2 can be handled the same*/
1299  best_baud = ftdi_to_clkbits(baudrate, H_CLK, 10, &encoded_divisor);
1300  encoded_divisor |= 0x20000; /* switch on CLK/10*/
1301  }
1302  else
1303  best_baud = ftdi_to_clkbits(baudrate, C_CLK, 16, &encoded_divisor);
1304  }
1305  else if ((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C) || (ftdi->type == TYPE_R) || (ftdi->type == TYPE_230X))
1306  {
1307  best_baud = ftdi_to_clkbits(baudrate, C_CLK, 16, &encoded_divisor);
1308  }
1309  else
1310  {
1311  best_baud = ftdi_to_clkbits_AM(baudrate, &encoded_divisor);
1312  }
1313  // Split into "value" and "index" values
1314  *value = (unsigned short)(encoded_divisor & 0xFFFF);
1315  if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H)
1316  {
1317  *index = (unsigned short)(encoded_divisor >> 8);
1318  *index &= 0xFF00;
1319  *index |= ftdi->index;
1320  }
1321  else
1322  *index = (unsigned short)(encoded_divisor >> 16);
1323 
1324  // Return the nearest baud rate
1325  return best_baud;
1326 }
1327 
1332 int convert_baudrate_UT_export(int baudrate, struct ftdi_context *ftdi,
1333  unsigned short *value, unsigned short *index)
1334 {
1335  return ftdi_convert_baudrate(baudrate, ftdi, value, index);
1336 }
1337 
1349 int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
1350 {
1351  unsigned short value, index;
1352  int actual_baudrate;
1353 
1354  if (ftdi == NULL || ftdi->usb_dev == NULL)
1355  ftdi_error_return(-3, "USB device unavailable");
1356 
1357  if (ftdi->bitbang_enabled)
1358  {
1359  baudrate = baudrate*4;
1360  }
1361 
1362  actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
1363  if (actual_baudrate <= 0)
1364  ftdi_error_return (-1, "Silly baudrate <= 0.");
1365 
1366  // Check within tolerance (about 5%)
1367  if ((actual_baudrate * 2 < baudrate /* Catch overflows */ )
1368  || ((actual_baudrate < baudrate)
1369  ? (actual_baudrate * 21 < baudrate * 20)
1370  : (baudrate * 21 < actual_baudrate * 20)))
1371  ftdi_error_return (-1, "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4");
1372 
1373  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1374  SIO_SET_BAUDRATE_REQUEST, value,
1375  index, NULL, 0, ftdi->usb_write_timeout) < 0)
1376  ftdi_error_return (-2, "Setting new baudrate failed");
1377 
1378  ftdi->baudrate = baudrate;
1379  return 0;
1380 }
1381 
1395 int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
1396  enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
1397 {
1398  return ftdi_set_line_property2(ftdi, bits, sbit, parity, BREAK_OFF);
1399 }
1400 
1414 int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
1415  enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity,
1416  enum ftdi_break_type break_type)
1417 {
1418  unsigned short value = bits;
1419 
1420  if (ftdi == NULL || ftdi->usb_dev == NULL)
1421  ftdi_error_return(-2, "USB device unavailable");
1422 
1423  switch (parity)
1424  {
1425  case NONE:
1426  value |= (0x00 << 8);
1427  break;
1428  case ODD:
1429  value |= (0x01 << 8);
1430  break;
1431  case EVEN:
1432  value |= (0x02 << 8);
1433  break;
1434  case MARK:
1435  value |= (0x03 << 8);
1436  break;
1437  case SPACE:
1438  value |= (0x04 << 8);
1439  break;
1440  }
1441 
1442  switch (sbit)
1443  {
1444  case STOP_BIT_1:
1445  value |= (0x00 << 11);
1446  break;
1447  case STOP_BIT_15:
1448  value |= (0x01 << 11);
1449  break;
1450  case STOP_BIT_2:
1451  value |= (0x02 << 11);
1452  break;
1453  }
1454 
1455  switch (break_type)
1456  {
1457  case BREAK_OFF:
1458  value |= (0x00 << 14);
1459  break;
1460  case BREAK_ON:
1461  value |= (0x01 << 14);
1462  break;
1463  }
1464 
1465  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1466  SIO_SET_DATA_REQUEST, value,
1467  ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1468  ftdi_error_return (-1, "Setting new line property failed");
1469 
1470  return 0;
1471 }
1472 
1484 int ftdi_write_data(struct ftdi_context *ftdi, const unsigned char *buf, int size)
1485 {
1486  int offset = 0;
1487  int actual_length;
1488 
1489  if (ftdi == NULL || ftdi->usb_dev == NULL)
1490  ftdi_error_return(-666, "USB device unavailable");
1491 
1492  while (offset < size)
1493  {
1494  int write_size = ftdi->writebuffer_chunksize;
1495 
1496  if (offset+write_size > size)
1497  write_size = size-offset;
1498 
1499  if (libusb_bulk_transfer(ftdi->usb_dev, ftdi->in_ep, (unsigned char *)buf+offset, write_size, &actual_length, ftdi->usb_write_timeout) < 0)
1500  ftdi_error_return(-1, "usb bulk write failed");
1501 
1502  offset += actual_length;
1503  }
1504 
1505  return offset;
1506 }
1507 
1508 static void LIBUSB_CALL ftdi_read_data_cb(struct libusb_transfer *transfer)
1509 {
1510  struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1511  struct ftdi_context *ftdi = tc->ftdi;
1512  int packet_size, actual_length, num_of_chunks, chunk_remains, i, ret;
1513 
1514  packet_size = ftdi->max_packet_size;
1515 
1516  actual_length = transfer->actual_length;
1517 
1518  if (actual_length > 2)
1519  {
1520  // skip FTDI status bytes.
1521  // Maybe stored in the future to enable modem use
1522  num_of_chunks = actual_length / packet_size;
1523  chunk_remains = actual_length % packet_size;
1524  //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);
1525 
1526  ftdi->readbuffer_offset += 2;
1527  actual_length -= 2;
1528 
1529  if (actual_length > packet_size - 2)
1530  {
1531  for (i = 1; i < num_of_chunks; i++)
1532  memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1533  ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1534  packet_size - 2);
1535  if (chunk_remains > 2)
1536  {
1537  memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1538  ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1539  chunk_remains-2);
1540  actual_length -= 2*num_of_chunks;
1541  }
1542  else
1543  actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1544  }
1545 
1546  if (actual_length > 0)
1547  {
1548  // data still fits in buf?
1549  if (tc->offset + actual_length <= tc->size)
1550  {
1551  memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, actual_length);
1552  //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1553  tc->offset += actual_length;
1554 
1555  ftdi->readbuffer_offset = 0;
1556  ftdi->readbuffer_remaining = 0;
1557 
1558  /* Did we read exactly the right amount of bytes? */
1559  if (tc->offset == tc->size)
1560  {
1561  //printf("read_data exact rem %d offset %d\n",
1562  //ftdi->readbuffer_remaining, offset);
1563  tc->completed = 1;
1564  return;
1565  }
1566  }
1567  else
1568  {
1569  // only copy part of the data or size <= readbuffer_chunksize
1570  int part_size = tc->size - tc->offset;
1571  memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, part_size);
1572  tc->offset += part_size;
1573 
1574  ftdi->readbuffer_offset += part_size;
1575  ftdi->readbuffer_remaining = actual_length - part_size;
1576 
1577  /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1578  part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
1579  tc->completed = 1;
1580  return;
1581  }
1582  }
1583  }
1584 
1585  if (transfer->status == LIBUSB_TRANSFER_CANCELLED)
1586  tc->completed = LIBUSB_TRANSFER_CANCELLED;
1587  else
1588  {
1589  ret = libusb_submit_transfer (transfer);
1590  if (ret < 0)
1591  tc->completed = 1;
1592  }
1593 }
1594 
1595 
1596 static void LIBUSB_CALL ftdi_write_data_cb(struct libusb_transfer *transfer)
1597 {
1598  struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1599  struct ftdi_context *ftdi = tc->ftdi;
1600 
1601  tc->offset += transfer->actual_length;
1602 
1603  if (tc->offset == tc->size)
1604  {
1605  tc->completed = 1;
1606  }
1607  else
1608  {
1609  int write_size = ftdi->writebuffer_chunksize;
1610  int ret;
1611 
1612  if (tc->offset + write_size > tc->size)
1613  write_size = tc->size - tc->offset;
1614 
1615  transfer->length = write_size;
1616  transfer->buffer = tc->buf + tc->offset;
1617 
1618  if (transfer->status == LIBUSB_TRANSFER_CANCELLED)
1619  tc->completed = LIBUSB_TRANSFER_CANCELLED;
1620  else
1621  {
1622  ret = libusb_submit_transfer (transfer);
1623  if (ret < 0)
1624  tc->completed = 1;
1625  }
1626  }
1627 }
1628 
1629 
1644 struct ftdi_transfer_control *ftdi_write_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
1645 {
1646  struct ftdi_transfer_control *tc;
1647  struct libusb_transfer *transfer;
1648  int write_size, ret;
1649 
1650  if (ftdi == NULL || ftdi->usb_dev == NULL)
1651  return NULL;
1652 
1653  tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
1654  if (!tc)
1655  return NULL;
1656 
1657  transfer = libusb_alloc_transfer(0);
1658  if (!transfer)
1659  {
1660  free(tc);
1661  return NULL;
1662  }
1663 
1664  tc->ftdi = ftdi;
1665  tc->completed = 0;
1666  tc->buf = buf;
1667  tc->size = size;
1668  tc->offset = 0;
1669 
1670  if (size < (int)ftdi->writebuffer_chunksize)
1671  write_size = size;
1672  else
1673  write_size = ftdi->writebuffer_chunksize;
1674 
1675  libusb_fill_bulk_transfer(transfer, ftdi->usb_dev, ftdi->in_ep, buf,
1676  write_size, ftdi_write_data_cb, tc,
1677  ftdi->usb_write_timeout);
1678  transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1679 
1680  ret = libusb_submit_transfer(transfer);
1681  if (ret < 0)
1682  {
1683  libusb_free_transfer(transfer);
1684  free(tc);
1685  return NULL;
1686  }
1687  tc->transfer = transfer;
1688 
1689  return tc;
1690 }
1691 
1706 struct ftdi_transfer_control *ftdi_read_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
1707 {
1708  struct ftdi_transfer_control *tc;
1709  struct libusb_transfer *transfer;
1710  int ret;
1711 
1712  if (ftdi == NULL || ftdi->usb_dev == NULL)
1713  return NULL;
1714 
1715  tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
1716  if (!tc)
1717  return NULL;
1718 
1719  tc->ftdi = ftdi;
1720  tc->buf = buf;
1721  tc->size = size;
1722 
1723  if (size <= (int)ftdi->readbuffer_remaining)
1724  {
1725  memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1726 
1727  // Fix offsets
1728  ftdi->readbuffer_remaining -= size;
1729  ftdi->readbuffer_offset += size;
1730 
1731  /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1732 
1733  tc->completed = 1;
1734  tc->offset = size;
1735  tc->transfer = NULL;
1736  return tc;
1737  }
1738 
1739  tc->completed = 0;
1740  if (ftdi->readbuffer_remaining != 0)
1741  {
1742  memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1743 
1744  tc->offset = ftdi->readbuffer_remaining;
1745  }
1746  else
1747  tc->offset = 0;
1748 
1749  transfer = libusb_alloc_transfer(0);
1750  if (!transfer)
1751  {
1752  free (tc);
1753  return NULL;
1754  }
1755 
1756  ftdi->readbuffer_remaining = 0;
1757  ftdi->readbuffer_offset = 0;
1758 
1759  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);
1760  transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1761 
1762  ret = libusb_submit_transfer(transfer);
1763  if (ret < 0)
1764  {
1765  libusb_free_transfer(transfer);
1766  free (tc);
1767  return NULL;
1768  }
1769  tc->transfer = transfer;
1770 
1771  return tc;
1772 }
1773 
1785 int ftdi_transfer_data_done(struct ftdi_transfer_control *tc)
1786 {
1787  int ret;
1788  struct timeval to = { 0, 0 };
1789  while (!tc->completed)
1790  {
1791  ret = libusb_handle_events_timeout_completed(tc->ftdi->usb_ctx,
1792  &to, &tc->completed);
1793  if (ret < 0)
1794  {
1795  if (ret == LIBUSB_ERROR_INTERRUPTED)
1796  continue;
1797  libusb_cancel_transfer(tc->transfer);
1798  while (!tc->completed)
1799  if (libusb_handle_events_timeout_completed(tc->ftdi->usb_ctx,
1800  &to, &tc->completed) < 0)
1801  break;
1802  libusb_free_transfer(tc->transfer);
1803  free (tc);
1804  return ret;
1805  }
1806  }
1807 
1808  ret = tc->offset;
1813  if (tc->transfer)
1814  {
1815  if (tc->transfer->status != LIBUSB_TRANSFER_COMPLETED)
1816  ret = -1;
1817  libusb_free_transfer(tc->transfer);
1818  }
1819  free(tc);
1820  return ret;
1821 }
1822 
1832 void ftdi_transfer_data_cancel(struct ftdi_transfer_control *tc,
1833  struct timeval * to)
1834 {
1835  struct timeval tv = { 0, 0 };
1836 
1837  if (!tc->completed && tc->transfer != NULL)
1838  {
1839  if (to == NULL)
1840  to = &tv;
1841 
1842  libusb_cancel_transfer(tc->transfer);
1843  while (!tc->completed)
1844  {
1845  if (libusb_handle_events_timeout_completed(tc->ftdi->usb_ctx, to, &tc->completed) < 0)
1846  break;
1847  }
1848  }
1849 
1850  if (tc->transfer)
1851  libusb_free_transfer(tc->transfer);
1852 
1853  free (tc);
1854 }
1855 
1866 int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1867 {
1868  if (ftdi == NULL)
1869  ftdi_error_return(-1, "ftdi context invalid");
1870 
1871  ftdi->writebuffer_chunksize = chunksize;
1872  return 0;
1873 }
1874 
1884 int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1885 {
1886  if (ftdi == NULL)
1887  ftdi_error_return(-1, "ftdi context invalid");
1888 
1889  *chunksize = ftdi->writebuffer_chunksize;
1890  return 0;
1891 }
1892 
1908 int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1909 {
1910  int offset = 0, ret, i, num_of_chunks, chunk_remains;
1911  int packet_size = ftdi->max_packet_size;
1912  int actual_length = 1;
1913 
1914  if (ftdi == NULL || ftdi->usb_dev == NULL)
1915  ftdi_error_return(-666, "USB device unavailable");
1916 
1917  // Packet size sanity check (avoid division by zero)
1918  if (packet_size == 0)
1919  ftdi_error_return(-1, "max_packet_size is bogus (zero)");
1920 
1921  // everything we want is still in the readbuffer?
1922  if (size <= (int)ftdi->readbuffer_remaining)
1923  {
1924  memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1925 
1926  // Fix offsets
1927  ftdi->readbuffer_remaining -= size;
1928  ftdi->readbuffer_offset += size;
1929 
1930  /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1931 
1932  return size;
1933  }
1934  // something still in the readbuffer, but not enough to satisfy 'size'?
1935  if (ftdi->readbuffer_remaining != 0)
1936  {
1937  memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1938 
1939  // Fix offset
1940  offset += ftdi->readbuffer_remaining;
1941  }
1942  // do the actual USB read
1943  while (offset < size && actual_length > 0)
1944  {
1945  ftdi->readbuffer_remaining = 0;
1946  ftdi->readbuffer_offset = 0;
1947  /* returns how much received */
1948  ret = libusb_bulk_transfer (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, &actual_length, ftdi->usb_read_timeout);
1949  if (ret < 0)
1950  ftdi_error_return(ret, "usb bulk read failed");
1951 
1952  if (actual_length > 2)
1953  {
1954  // skip FTDI status bytes.
1955  // Maybe stored in the future to enable modem use
1956  num_of_chunks = actual_length / packet_size;
1957  chunk_remains = actual_length % packet_size;
1958  //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);
1959 
1960  ftdi->readbuffer_offset += 2;
1961  actual_length -= 2;
1962 
1963  if (actual_length > packet_size - 2)
1964  {
1965  for (i = 1; i < num_of_chunks; i++)
1966  memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1967  ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1968  packet_size - 2);
1969  if (chunk_remains > 2)
1970  {
1971  memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1972  ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1973  chunk_remains-2);
1974  actual_length -= 2*num_of_chunks;
1975  }
1976  else
1977  actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1978  }
1979  }
1980  else if (actual_length <= 2)
1981  {
1982  // no more data to read?
1983  return offset;
1984  }
1985  if (actual_length > 0)
1986  {
1987  // data still fits in buf?
1988  if (offset+actual_length <= size)
1989  {
1990  memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, actual_length);
1991  //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1992  offset += actual_length;
1993 
1994  /* Did we read exactly the right amount of bytes? */
1995  if (offset == size)
1996  //printf("read_data exact rem %d offset %d\n",
1997  //ftdi->readbuffer_remaining, offset);
1998  return offset;
1999  }
2000  else
2001  {
2002  // only copy part of the data or size <= readbuffer_chunksize
2003  int part_size = size-offset;
2004  memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
2005 
2006  ftdi->readbuffer_offset += part_size;
2007  ftdi->readbuffer_remaining = actual_length-part_size;
2008  offset += part_size;
2009 
2010  /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
2011  part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
2012 
2013  return offset;
2014  }
2015  }
2016  }
2017  // never reached
2018  return -127;
2019 }
2020 
2033 int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
2034 {
2035  unsigned char *new_buf;
2036 
2037  if (ftdi == NULL)
2038  ftdi_error_return(-1, "ftdi context invalid");
2039 
2040  // Invalidate all remaining data
2041  ftdi->readbuffer_offset = 0;
2042  ftdi->readbuffer_remaining = 0;
2043 #ifdef __linux__
2044  /* We can't set readbuffer_chunksize larger than MAX_BULK_BUFFER_LENGTH,
2045  which is defined in libusb-1.0. Otherwise, each USB read request will
2046  be divided into multiple URBs. This will cause issues on Linux kernel
2047  older than 2.6.32. */
2048  if (chunksize > 16384)
2049  chunksize = 16384;
2050 #endif
2051 
2052  if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL)
2053  ftdi_error_return(-1, "out of memory for readbuffer");
2054 
2055  ftdi->readbuffer = new_buf;
2056  ftdi->readbuffer_chunksize = chunksize;
2057 
2058  return 0;
2059 }
2060 
2070 int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
2071 {
2072  if (ftdi == NULL)
2073  ftdi_error_return(-1, "FTDI context invalid");
2074 
2075  *chunksize = ftdi->readbuffer_chunksize;
2076  return 0;
2077 }
2078 
2091 int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
2092 {
2093  unsigned short usb_val;
2094 
2095  if (ftdi == NULL || ftdi->usb_dev == NULL)
2096  ftdi_error_return(-2, "USB device unavailable");
2097 
2098  usb_val = bitmask; // low byte: bitmask
2099  usb_val |= (mode << 8);
2100  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)
2101  ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps not a BM/2232C type chip?");
2102 
2103  ftdi->bitbang_mode = mode;
2104  ftdi->bitbang_enabled = (mode == BITMODE_RESET) ? 0 : 1;
2105  return 0;
2106 }
2107 
2117 int ftdi_disable_bitbang(struct ftdi_context *ftdi)
2118 {
2119  if (ftdi == NULL || ftdi->usb_dev == NULL)
2120  ftdi_error_return(-2, "USB device unavailable");
2121 
2122  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)
2123  ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?");
2124 
2125  ftdi->bitbang_enabled = 0;
2126  return 0;
2127 }
2128 
2129 
2140 int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
2141 {
2142  if (ftdi == NULL || ftdi->usb_dev == NULL)
2143  ftdi_error_return(-2, "USB device unavailable");
2144 
2145  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)
2146  ftdi_error_return(-1, "read pins failed");
2147 
2148  return 0;
2149 }
2150 
2166 int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
2167 {
2168  unsigned short usb_val;
2169 
2170  if (latency < 1)
2171  ftdi_error_return(-1, "latency out of range. Only valid for 1-255");
2172 
2173  if (ftdi == NULL || ftdi->usb_dev == NULL)
2174  ftdi_error_return(-3, "USB device unavailable");
2175 
2176  usb_val = latency;
2177  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)
2178  ftdi_error_return(-2, "unable to set latency timer");
2179 
2180  return 0;
2181 }
2182 
2193 int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
2194 {
2195  unsigned short usb_val;
2196 
2197  if (ftdi == NULL || ftdi->usb_dev == NULL)
2198  ftdi_error_return(-2, "USB device unavailable");
2199 
2200  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)
2201  ftdi_error_return(-1, "reading latency timer failed");
2202 
2203  *latency = (unsigned char)usb_val;
2204  return 0;
2205 }
2206 
2247 int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
2248 {
2249  char usb_val[2];
2250 
2251  if (ftdi == NULL || ftdi->usb_dev == NULL)
2252  ftdi_error_return(-2, "USB device unavailable");
2253 
2254  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)
2255  ftdi_error_return(-1, "getting modem status failed");
2256 
2257  *status = (usb_val[1] << 8) | (usb_val[0] & 0xFF);
2258 
2259  return 0;
2260 }
2261 
2273 int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
2274 {
2275  if (ftdi == NULL || ftdi->usb_dev == NULL)
2276  ftdi_error_return(-2, "USB device unavailable");
2277 
2278  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2279  SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->index),
2280  NULL, 0, ftdi->usb_write_timeout) < 0)
2281  ftdi_error_return(-1, "set flow control failed");
2282 
2283  return 0;
2284 }
2285 
2296 int ftdi_setdtr(struct ftdi_context *ftdi, int state)
2297 {
2298  unsigned short usb_val;
2299 
2300  if (ftdi == NULL || ftdi->usb_dev == NULL)
2301  ftdi_error_return(-2, "USB device unavailable");
2302 
2303  if (state)
2304  usb_val = SIO_SET_DTR_HIGH;
2305  else
2306  usb_val = SIO_SET_DTR_LOW;
2307 
2308  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2309  SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2310  NULL, 0, ftdi->usb_write_timeout) < 0)
2311  ftdi_error_return(-1, "set dtr failed");
2312 
2313  return 0;
2314 }
2315 
2326 int ftdi_setrts(struct ftdi_context *ftdi, int state)
2327 {
2328  unsigned short usb_val;
2329 
2330  if (ftdi == NULL || ftdi->usb_dev == NULL)
2331  ftdi_error_return(-2, "USB device unavailable");
2332 
2333  if (state)
2334  usb_val = SIO_SET_RTS_HIGH;
2335  else
2336  usb_val = SIO_SET_RTS_LOW;
2337 
2338  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2339  SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2340  NULL, 0, ftdi->usb_write_timeout) < 0)
2341  ftdi_error_return(-1, "set of rts failed");
2342 
2343  return 0;
2344 }
2345 
2357 int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
2358 {
2359  unsigned short usb_val;
2360 
2361  if (ftdi == NULL || ftdi->usb_dev == NULL)
2362  ftdi_error_return(-2, "USB device unavailable");
2363 
2364  if (dtr)
2365  usb_val = SIO_SET_DTR_HIGH;
2366  else
2367  usb_val = SIO_SET_DTR_LOW;
2368 
2369  if (rts)
2370  usb_val |= SIO_SET_RTS_HIGH;
2371  else
2372  usb_val |= SIO_SET_RTS_LOW;
2373 
2374  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2375  SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2376  NULL, 0, ftdi->usb_write_timeout) < 0)
2377  ftdi_error_return(-1, "set of rts/dtr failed");
2378 
2379  return 0;
2380 }
2381 
2393 int ftdi_set_event_char(struct ftdi_context *ftdi,
2394  unsigned char eventch, unsigned char enable)
2395 {
2396  unsigned short usb_val;
2397 
2398  if (ftdi == NULL || ftdi->usb_dev == NULL)
2399  ftdi_error_return(-2, "USB device unavailable");
2400 
2401  usb_val = eventch;
2402  if (enable)
2403  usb_val |= 1 << 8;
2404 
2405  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)
2406  ftdi_error_return(-1, "setting event character failed");
2407 
2408  return 0;
2409 }
2410 
2422 int ftdi_set_error_char(struct ftdi_context *ftdi,
2423  unsigned char errorch, unsigned char enable)
2424 {
2425  unsigned short usb_val;
2426 
2427  if (ftdi == NULL || ftdi->usb_dev == NULL)
2428  ftdi_error_return(-2, "USB device unavailable");
2429 
2430  usb_val = errorch;
2431  if (enable)
2432  usb_val |= 1 << 8;
2433 
2434  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)
2435  ftdi_error_return(-1, "setting error character failed");
2436 
2437  return 0;
2438 }
2439 
2452 int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer,
2453  char * product, char * serial)
2454 {
2455  struct ftdi_eeprom *eeprom;
2456 
2457  if (ftdi == NULL)
2458  ftdi_error_return(-1, "No struct ftdi_context");
2459 
2460  if (ftdi->eeprom == NULL)
2461  ftdi_error_return(-2,"No struct ftdi_eeprom");
2462 
2463  eeprom = ftdi->eeprom;
2464  memset(eeprom, 0, sizeof(struct ftdi_eeprom));
2465 
2466  if (ftdi->usb_dev == NULL)
2467  ftdi_error_return(-3, "No connected device or device not yet opened");
2468 
2469  eeprom->vendor_id = 0x0403;
2470  eeprom->use_serial = 1;
2471  if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM) ||
2472  (ftdi->type == TYPE_R))
2473  eeprom->product_id = 0x6001;
2474  else if (ftdi->type == TYPE_4232H)
2475  eeprom->product_id = 0x6011;
2476  else if (ftdi->type == TYPE_232H)
2477  eeprom->product_id = 0x6014;
2478  else if (ftdi->type == TYPE_230X)
2479  eeprom->product_id = 0x6015;
2480  else
2481  eeprom->product_id = 0x6010;
2482 
2483  if (ftdi->type == TYPE_AM)
2484  eeprom->usb_version = 0x0101;
2485  else
2486  eeprom->usb_version = 0x0200;
2487  eeprom->max_power = 100;
2488 
2489  if (eeprom->manufacturer)
2490  free (eeprom->manufacturer);
2491  eeprom->manufacturer = NULL;
2492  if (manufacturer)
2493  {
2494  eeprom->manufacturer = (char *)malloc(strlen(manufacturer)+1);
2495  if (eeprom->manufacturer)
2496  strcpy(eeprom->manufacturer, manufacturer);
2497  }
2498 
2499  if (eeprom->product)
2500  free (eeprom->product);
2501  eeprom->product = NULL;
2502  if(product)
2503  {
2504  eeprom->product = (char *)malloc(strlen(product)+1);
2505  if (eeprom->product)
2506  strcpy(eeprom->product, product);
2507  }
2508  else
2509  {
2510  const char* default_product;
2511  switch(ftdi->type)
2512  {
2513  case TYPE_AM: default_product = "AM"; break;
2514  case TYPE_BM: default_product = "BM"; break;
2515  case TYPE_2232C: default_product = "Dual RS232"; break;
2516  case TYPE_R: default_product = "FT232R USB UART"; break;
2517  case TYPE_2232H: default_product = "Dual RS232-HS"; break;
2518  case TYPE_4232H: default_product = "FT4232H"; break;
2519  case TYPE_232H: default_product = "Single-RS232-HS"; break;
2520  case TYPE_230X: default_product = "FT230X Basic UART"; break;
2521  default:
2522  ftdi_error_return(-3, "Unknown chip type");
2523  }
2524  eeprom->product = (char *)malloc(strlen(default_product) +1);
2525  if (eeprom->product)
2526  strcpy(eeprom->product, default_product);
2527  }
2528 
2529  if (eeprom->serial)
2530  free (eeprom->serial);
2531  eeprom->serial = NULL;
2532  if (serial)
2533  {
2534  eeprom->serial = (char *)malloc(strlen(serial)+1);
2535  if (eeprom->serial)
2536  strcpy(eeprom->serial, serial);
2537  }
2538 
2539  if (ftdi->type == TYPE_R)
2540  {
2541  eeprom->max_power = 90;
2542  eeprom->size = 0x80;
2543  eeprom->cbus_function[0] = CBUS_TXLED;
2544  eeprom->cbus_function[1] = CBUS_RXLED;
2545  eeprom->cbus_function[2] = CBUS_TXDEN;
2546  eeprom->cbus_function[3] = CBUS_PWREN;
2547  eeprom->cbus_function[4] = CBUS_SLEEP;
2548  }
2549  else if (ftdi->type == TYPE_230X)
2550  {
2551  eeprom->max_power = 90;
2552  eeprom->size = 0x100;
2553  eeprom->cbus_function[0] = CBUSX_TXDEN;
2554  eeprom->cbus_function[1] = CBUSX_RXLED;
2555  eeprom->cbus_function[2] = CBUSX_TXLED;
2556  eeprom->cbus_function[3] = CBUSX_SLEEP;
2557  }
2558  else
2559  {
2560  if(ftdi->type == TYPE_232H)
2561  {
2562  int i;
2563  for (i=0; i<10; i++)
2564  eeprom->cbus_function[i] = CBUSH_TRISTATE;
2565  }
2566  eeprom->size = -1;
2567  }
2568  switch (ftdi->type)
2569  {
2570  case TYPE_AM:
2571  eeprom->release_number = 0x0200;
2572  break;
2573  case TYPE_BM:
2574  eeprom->release_number = 0x0400;
2575  break;
2576  case TYPE_2232C:
2577  eeprom->release_number = 0x0500;
2578  break;
2579  case TYPE_R:
2580  eeprom->release_number = 0x0600;
2581  break;
2582  case TYPE_2232H:
2583  eeprom->release_number = 0x0700;
2584  break;
2585  case TYPE_4232H:
2586  eeprom->release_number = 0x0800;
2587  break;
2588  case TYPE_232H:
2589  eeprom->release_number = 0x0900;
2590  break;
2591  case TYPE_230X:
2592  eeprom->release_number = 0x1000;
2593  break;
2594  default:
2595  eeprom->release_number = 0x00;
2596  }
2597  return 0;
2598 }
2599 
2600 int ftdi_eeprom_set_strings(struct ftdi_context *ftdi, char * manufacturer,
2601  char * product, char * serial)
2602 {
2603  struct ftdi_eeprom *eeprom;
2604 
2605  if (ftdi == NULL)
2606  ftdi_error_return(-1, "No struct ftdi_context");
2607 
2608  if (ftdi->eeprom == NULL)
2609  ftdi_error_return(-2,"No struct ftdi_eeprom");
2610 
2611  eeprom = ftdi->eeprom;
2612 
2613  if (ftdi->usb_dev == NULL)
2614  ftdi_error_return(-3, "No connected device or device not yet opened");
2615 
2616  if (manufacturer)
2617  {
2618  if (eeprom->manufacturer)
2619  free (eeprom->manufacturer);
2620  eeprom->manufacturer = (char *)malloc(strlen(manufacturer)+1);
2621  if (eeprom->manufacturer)
2622  strcpy(eeprom->manufacturer, manufacturer);
2623  }
2624 
2625  if(product)
2626  {
2627  if (eeprom->product)
2628  free (eeprom->product);
2629  eeprom->product = (char *)malloc(strlen(product)+1);
2630  if (eeprom->product)
2631  strcpy(eeprom->product, product);
2632  }
2633 
2634  if (serial)
2635  {
2636  if (eeprom->serial)
2637  free (eeprom->serial);
2638  eeprom->serial = (char *)malloc(strlen(serial)+1);
2639  if (eeprom->serial)
2640  {
2641  strcpy(eeprom->serial, serial);
2642  eeprom->use_serial = 1;
2643  }
2644  }
2645  return 0;
2646 }
2647 
2666 int ftdi_eeprom_get_strings(struct ftdi_context *ftdi,
2667  char *manufacturer, int mnf_len,
2668  char *product, int prod_len,
2669  char *serial, int serial_len)
2670 {
2671  struct ftdi_eeprom *eeprom;
2672 
2673  if (ftdi == NULL)
2674  ftdi_error_return(-1, "No struct ftdi_context");
2675  if (ftdi->eeprom == NULL)
2676  ftdi_error_return(-2, "No struct ftdi_eeprom");
2677 
2678  eeprom = ftdi->eeprom;
2679 
2680  if (manufacturer)
2681  {
2682  strncpy(manufacturer, eeprom->manufacturer, mnf_len);
2683  if (mnf_len > 0)
2684  manufacturer[mnf_len - 1] = '\0';
2685  }
2686 
2687  if (product)
2688  {
2689  strncpy(product, eeprom->product, prod_len);
2690  if (prod_len > 0)
2691  product[prod_len - 1] = '\0';
2692  }
2693 
2694  if (serial)
2695  {
2696  strncpy(serial, eeprom->serial, serial_len);
2697  if (serial_len > 0)
2698  serial[serial_len - 1] = '\0';
2699  }
2700 
2701  return 0;
2702 }
2703 
2704 /*FTD2XX doesn't check for values not fitting in the ACBUS Signal options*/
2705 void set_ft232h_cbus(struct ftdi_eeprom *eeprom, unsigned char * output)
2706 {
2707  int i;
2708  for(i=0; i<5; i++)
2709  {
2710  int mode_low, mode_high;
2711  if (eeprom->cbus_function[2*i]> CBUSH_CLK7_5)
2712  mode_low = CBUSH_TRISTATE;
2713  else
2714  mode_low = eeprom->cbus_function[2*i];
2715  if (eeprom->cbus_function[2*i+1]> CBUSH_CLK7_5)
2716  mode_high = CBUSH_TRISTATE;
2717  else
2718  mode_high = eeprom->cbus_function[2*i+1];
2719 
2720  output[0x18+i] = (mode_high <<4) | mode_low;
2721  }
2722 }
2723 /* Return the bits for the encoded EEPROM Structure of a requested Mode
2724  *
2725  */
2726 static unsigned char type2bit(unsigned char type, enum ftdi_chip_type chip)
2727 {
2728  switch (chip)
2729  {
2730  case TYPE_2232H:
2731  case TYPE_2232C:
2732  {
2733  switch (type)
2734  {
2735  case CHANNEL_IS_UART: return 0;
2736  case CHANNEL_IS_FIFO: return 0x01;
2737  case CHANNEL_IS_OPTO: return 0x02;
2738  case CHANNEL_IS_CPU : return 0x04;
2739  default: return 0;
2740  }
2741  }
2742  case TYPE_232H:
2743  {
2744  switch (type)
2745  {
2746  case CHANNEL_IS_UART : return 0;
2747  case CHANNEL_IS_FIFO : return 0x01;
2748  case CHANNEL_IS_OPTO : return 0x02;
2749  case CHANNEL_IS_CPU : return 0x04;
2750  case CHANNEL_IS_FT1284 : return 0x08;
2751  default: return 0;
2752  }
2753  }
2754  case TYPE_R:
2755  {
2756  switch (type)
2757  {
2758  case CHANNEL_IS_UART : return 0;
2759  case CHANNEL_IS_FIFO : return 0x01;
2760  default: return 0;
2761  }
2762  }
2763  case TYPE_230X: /* FT230X is only UART */
2764  default: return 0;
2765  }
2766  return 0;
2767 }
2768 
2783 int ftdi_eeprom_build(struct ftdi_context *ftdi)
2784 {
2785  unsigned char i, j, eeprom_size_mask;
2786  unsigned short checksum, value;
2787  unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2788  int user_area_size, free_start, free_end;
2789  struct ftdi_eeprom *eeprom;
2790  unsigned char * output;
2791 
2792  if (ftdi == NULL)
2793  ftdi_error_return(-2,"No context");
2794  if (ftdi->eeprom == NULL)
2795  ftdi_error_return(-2,"No eeprom structure");
2796 
2797  eeprom= ftdi->eeprom;
2798  output = eeprom->buf;
2799 
2800  if (eeprom->chip == -1)
2801  ftdi_error_return(-6,"No connected EEPROM or EEPROM type unknown");
2802 
2803  if (eeprom->size == -1)
2804  {
2805  if ((eeprom->chip == 0x56) || (eeprom->chip == 0x66))
2806  eeprom->size = 0x100;
2807  else
2808  eeprom->size = 0x80;
2809  }
2810 
2811  if (eeprom->manufacturer != NULL)
2812  manufacturer_size = strlen(eeprom->manufacturer);
2813  if (eeprom->product != NULL)
2814  product_size = strlen(eeprom->product);
2815  if (eeprom->serial != NULL)
2816  serial_size = strlen(eeprom->serial);
2817 
2818  // eeprom size check
2819  switch (ftdi->type)
2820  {
2821  case TYPE_AM:
2822  case TYPE_BM:
2823  case TYPE_R:
2824  user_area_size = 96; // base size for strings (total of 48 characters)
2825  break;
2826  case TYPE_2232C:
2827  user_area_size = 90; // two extra config bytes and 4 bytes PnP stuff
2828  break;
2829  case TYPE_230X:
2830  user_area_size = 88; // four extra config bytes + 4 bytes PnP stuff
2831  break;
2832  case TYPE_2232H: // six extra config bytes + 4 bytes PnP stuff
2833  case TYPE_4232H:
2834  user_area_size = 86;
2835  break;
2836  case TYPE_232H:
2837  user_area_size = 80;
2838  break;
2839  default:
2840  user_area_size = 0;
2841  break;
2842  }
2843  user_area_size -= (manufacturer_size + product_size + serial_size) * 2;
2844 
2845  if (user_area_size < 0)
2846  ftdi_error_return(-1,"eeprom size exceeded");
2847 
2848  // empty eeprom
2849  if (ftdi->type == TYPE_230X)
2850  {
2851  /* FT230X have a reserved section in the middle of the MTP,
2852  which cannot be written to, but must be included in the checksum */
2853  memset(ftdi->eeprom->buf, 0, 0x80);
2854  memset((ftdi->eeprom->buf + 0xa0), 0, (FTDI_MAX_EEPROM_SIZE - 0xa0));
2855  }
2856  else
2857  {
2858  memset(ftdi->eeprom->buf, 0, FTDI_MAX_EEPROM_SIZE);
2859  }
2860 
2861  // Bytes and Bits set for all Types
2862 
2863  // Addr 02: Vendor ID
2864  output[0x02] = eeprom->vendor_id;
2865  output[0x03] = eeprom->vendor_id >> 8;
2866 
2867  // Addr 04: Product ID
2868  output[0x04] = eeprom->product_id;
2869  output[0x05] = eeprom->product_id >> 8;
2870 
2871  // Addr 06: Device release number (0400h for BM features)
2872  output[0x06] = eeprom->release_number;
2873  output[0x07] = eeprom->release_number >> 8;
2874 
2875  // Addr 08: Config descriptor
2876  // Bit 7: always 1
2877  // Bit 6: 1 if this device is self powered, 0 if bus powered
2878  // Bit 5: 1 if this device uses remote wakeup
2879  // Bit 4-0: reserved - 0
2880  j = 0x80;
2881  if (eeprom->self_powered)
2882  j |= 0x40;
2883  if (eeprom->remote_wakeup)
2884  j |= 0x20;
2885  output[0x08] = j;
2886 
2887  // Addr 09: Max power consumption: max power = value * 2 mA
2888  output[0x09] = eeprom->max_power / MAX_POWER_MILLIAMP_PER_UNIT;
2889 
2890  if ((ftdi->type != TYPE_AM) && (ftdi->type != TYPE_230X))
2891  {
2892  // Addr 0A: Chip configuration
2893  // Bit 7: 0 - reserved
2894  // Bit 6: 0 - reserved
2895  // Bit 5: 0 - reserved
2896  // Bit 4: 1 - Change USB version
2897  // Bit 3: 1 - Use the serial number string
2898  // Bit 2: 1 - Enable suspend pull downs for lower power
2899  // Bit 1: 1 - Out EndPoint is Isochronous
2900  // Bit 0: 1 - In EndPoint is Isochronous
2901  //
2902  j = 0;
2903  if (eeprom->in_is_isochronous)
2904  j = j | 1;
2905  if (eeprom->out_is_isochronous)
2906  j = j | 2;
2907  output[0x0A] = j;
2908  }
2909 
2910  // Dynamic content
2911  // Strings start at 0x94 (TYPE_AM, TYPE_BM)
2912  // 0x96 (TYPE_2232C), 0x98 (TYPE_R) and 0x9a (TYPE_x232H)
2913  // 0xa0 (TYPE_232H)
2914  i = 0;
2915  switch (ftdi->type)
2916  {
2917  case TYPE_2232H:
2918  case TYPE_4232H:
2919  i += 2;
2920  case TYPE_R:
2921  i += 2;
2922  case TYPE_2232C:
2923  i += 2;
2924  case TYPE_AM:
2925  case TYPE_BM:
2926  i += 0x94;
2927  break;
2928  case TYPE_232H:
2929  case TYPE_230X:
2930  i = 0xa0;
2931  break;
2932  }
2933  /* Wrap around 0x80 for 128 byte EEPROMS (Internale and 93x46) */
2934  eeprom_size_mask = eeprom->size -1;
2935  free_end = i & eeprom_size_mask;
2936 
2937  // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2938  // Addr 0F: Length of manufacturer string
2939  // Output manufacturer
2940  output[0x0E] = i; // calculate offset
2941  output[i & eeprom_size_mask] = manufacturer_size*2 + 2, i++;
2942  output[i & eeprom_size_mask] = 0x03, i++; // type: string
2943  for (j = 0; j < manufacturer_size; j++)
2944  {
2945  output[i & eeprom_size_mask] = eeprom->manufacturer[j], i++;
2946  output[i & eeprom_size_mask] = 0x00, i++;
2947  }
2948  output[0x0F] = manufacturer_size*2 + 2;
2949 
2950  // Addr 10: Offset of the product string + 0x80, calculated later
2951  // Addr 11: Length of product string
2952  output[0x10] = i | 0x80; // calculate offset
2953  output[i & eeprom_size_mask] = product_size*2 + 2, i++;
2954  output[i & eeprom_size_mask] = 0x03, i++;
2955  for (j = 0; j < product_size; j++)
2956  {
2957  output[i & eeprom_size_mask] = eeprom->product[j], i++;
2958  output[i & eeprom_size_mask] = 0x00, i++;
2959  }
2960  output[0x11] = product_size*2 + 2;
2961 
2962  // Addr 12: Offset of the serial string + 0x80, calculated later
2963  // Addr 13: Length of serial string
2964  output[0x12] = i | 0x80; // calculate offset
2965  output[i & eeprom_size_mask] = serial_size*2 + 2, i++;
2966  output[i & eeprom_size_mask] = 0x03, i++;
2967  for (j = 0; j < serial_size; j++)
2968  {
2969  output[i & eeprom_size_mask] = eeprom->serial[j], i++;
2970  output[i & eeprom_size_mask] = 0x00, i++;
2971  }
2972 
2973  // Legacy port name and PnP fields for FT2232 and newer chips
2974  if (ftdi->type > TYPE_BM)
2975  {
2976  output[i & eeprom_size_mask] = 0x02; /* as seen when written with FTD2XX */
2977  i++;
2978  output[i & eeprom_size_mask] = 0x03; /* as seen when written with FTD2XX */
2979  i++;
2980  output[i & eeprom_size_mask] = eeprom->is_not_pnp; /* as seen when written with FTD2XX */
2981  i++;
2982  }
2983 
2984  output[0x13] = serial_size*2 + 2;
2985 
2986  if (ftdi->type > TYPE_AM) /* use_serial not used in AM devices */
2987  {
2988  if (eeprom->use_serial)
2989  output[0x0A] |= USE_SERIAL_NUM;
2990  else
2991  output[0x0A] &= ~USE_SERIAL_NUM;
2992  }
2993 
2994  /* Bytes and Bits specific to (some) types
2995  Write linear, as this allows easier fixing*/
2996  switch (ftdi->type)
2997  {
2998  case TYPE_AM:
2999  break;
3000  case TYPE_BM:
3001  output[0x0C] = eeprom->usb_version & 0xff;
3002  output[0x0D] = (eeprom->usb_version>>8) & 0xff;
3003  if (eeprom->use_usb_version)
3004  output[0x0A] |= USE_USB_VERSION_BIT;
3005  else
3006  output[0x0A] &= ~USE_USB_VERSION_BIT;
3007 
3008  break;
3009  case TYPE_2232C:
3010 
3011  output[0x00] = type2bit(eeprom->channel_a_type, TYPE_2232C);
3012  if ( eeprom->channel_a_driver == DRIVER_VCP)
3013  output[0x00] |= DRIVER_VCP;
3014  else
3015  output[0x00] &= ~DRIVER_VCP;
3016 
3017  if ( eeprom->high_current_a == HIGH_CURRENT_DRIVE)
3018  output[0x00] |= HIGH_CURRENT_DRIVE;
3019  else
3020  output[0x00] &= ~HIGH_CURRENT_DRIVE;
3021 
3022  output[0x01] = type2bit(eeprom->channel_b_type, TYPE_2232C);
3023  if ( eeprom->channel_b_driver == DRIVER_VCP)
3024  output[0x01] |= DRIVER_VCP;
3025  else
3026  output[0x01] &= ~DRIVER_VCP;
3027 
3028  if ( eeprom->high_current_b == HIGH_CURRENT_DRIVE)
3029  output[0x01] |= HIGH_CURRENT_DRIVE;
3030  else
3031  output[0x01] &= ~HIGH_CURRENT_DRIVE;
3032 
3033  if (eeprom->in_is_isochronous)
3034  output[0x0A] |= 0x1;
3035  else
3036  output[0x0A] &= ~0x1;
3037  if (eeprom->out_is_isochronous)
3038  output[0x0A] |= 0x2;
3039  else
3040  output[0x0A] &= ~0x2;
3041  if (eeprom->suspend_pull_downs)
3042  output[0x0A] |= 0x4;
3043  else
3044  output[0x0A] &= ~0x4;
3045  if (eeprom->use_usb_version)
3046  output[0x0A] |= USE_USB_VERSION_BIT;
3047  else
3048  output[0x0A] &= ~USE_USB_VERSION_BIT;
3049 
3050  output[0x0C] = eeprom->usb_version & 0xff;
3051  output[0x0D] = (eeprom->usb_version>>8) & 0xff;
3052  output[0x14] = eeprom->chip;
3053  break;
3054  case TYPE_R:
3055  output[0x00] = type2bit(eeprom->channel_a_type, TYPE_R);
3056  if (eeprom->high_current == HIGH_CURRENT_DRIVE_R)
3057  output[0x00] |= HIGH_CURRENT_DRIVE_R;
3058  if (eeprom->external_oscillator)
3059  output[0x00] |= 0x02;
3060  output[0x01] = 0x40; /* Hard coded Endpoint Size*/
3061 
3062  if (eeprom->suspend_pull_downs)
3063  output[0x0A] |= 0x4;
3064  else
3065  output[0x0A] &= ~0x4;
3066  output[0x0B] = eeprom->invert;
3067  output[0x0C] = eeprom->usb_version & 0xff;
3068  output[0x0D] = (eeprom->usb_version>>8) & 0xff;
3069 
3070  if (eeprom->cbus_function[0] > CBUS_BB_RD)
3071  output[0x14] = CBUS_TXLED;
3072  else
3073  output[0x14] = eeprom->cbus_function[0];
3074 
3075  if (eeprom->cbus_function[1] > CBUS_BB_RD)
3076  output[0x14] |= CBUS_RXLED<<4;
3077  else
3078  output[0x14] |= eeprom->cbus_function[1]<<4;
3079 
3080  if (eeprom->cbus_function[2] > CBUS_BB_RD)
3081  output[0x15] = CBUS_TXDEN;
3082  else
3083  output[0x15] = eeprom->cbus_function[2];
3084 
3085  if (eeprom->cbus_function[3] > CBUS_BB_RD)
3086  output[0x15] |= CBUS_PWREN<<4;
3087  else
3088  output[0x15] |= eeprom->cbus_function[3]<<4;
3089 
3090  if (eeprom->cbus_function[4] > CBUS_CLK6)
3091  output[0x16] = CBUS_SLEEP;
3092  else
3093  output[0x16] = eeprom->cbus_function[4];
3094  break;
3095  case TYPE_2232H:
3096  output[0x00] = type2bit(eeprom->channel_a_type, TYPE_2232H);
3097  if ( eeprom->channel_a_driver == DRIVER_VCP)
3098  output[0x00] |= DRIVER_VCP;
3099  else
3100  output[0x00] &= ~DRIVER_VCP;
3101 
3102  output[0x01] = type2bit(eeprom->channel_b_type, TYPE_2232H);
3103  if ( eeprom->channel_b_driver == DRIVER_VCP)
3104  output[0x01] |= DRIVER_VCP;
3105  else
3106  output[0x01] &= ~DRIVER_VCP;
3107  if (eeprom->suspend_dbus7 == SUSPEND_DBUS7_BIT)
3108  output[0x01] |= SUSPEND_DBUS7_BIT;
3109  else
3110  output[0x01] &= ~SUSPEND_DBUS7_BIT;
3111 
3112  if (eeprom->suspend_pull_downs)
3113  output[0x0A] |= 0x4;
3114  else
3115  output[0x0A] &= ~0x4;
3116 
3117  if (eeprom->group0_drive > DRIVE_16MA)
3118  output[0x0c] |= DRIVE_16MA;
3119  else
3120  output[0x0c] |= eeprom->group0_drive;
3121  if (eeprom->group0_schmitt == IS_SCHMITT)
3122  output[0x0c] |= IS_SCHMITT;
3123  if (eeprom->group0_slew == SLOW_SLEW)
3124  output[0x0c] |= SLOW_SLEW;
3125 
3126  if (eeprom->group1_drive > DRIVE_16MA)
3127  output[0x0c] |= DRIVE_16MA<<4;
3128  else
3129  output[0x0c] |= eeprom->group1_drive<<4;
3130  if (eeprom->group1_schmitt == IS_SCHMITT)
3131  output[0x0c] |= IS_SCHMITT<<4;
3132  if (eeprom->group1_slew == SLOW_SLEW)
3133  output[0x0c] |= SLOW_SLEW<<4;
3134 
3135  if (eeprom->group2_drive > DRIVE_16MA)
3136  output[0x0d] |= DRIVE_16MA;
3137  else
3138  output[0x0d] |= eeprom->group2_drive;
3139  if (eeprom->group2_schmitt == IS_SCHMITT)
3140  output[0x0d] |= IS_SCHMITT;
3141  if (eeprom->group2_slew == SLOW_SLEW)
3142  output[0x0d] |= SLOW_SLEW;
3143 
3144  if (eeprom->group3_drive > DRIVE_16MA)
3145  output[0x0d] |= DRIVE_16MA<<4;
3146  else
3147  output[0x0d] |= eeprom->group3_drive<<4;
3148  if (eeprom->group3_schmitt == IS_SCHMITT)
3149  output[0x0d] |= IS_SCHMITT<<4;
3150  if (eeprom->group3_slew == SLOW_SLEW)
3151  output[0x0d] |= SLOW_SLEW<<4;
3152 
3153  output[0x18] = eeprom->chip;
3154 
3155  break;
3156  case TYPE_4232H:
3157  if (eeprom->channel_a_driver == DRIVER_VCP)
3158  output[0x00] |= DRIVER_VCP;
3159  else
3160  output[0x00] &= ~DRIVER_VCP;
3161  if (eeprom->channel_b_driver == DRIVER_VCP)
3162  output[0x01] |= DRIVER_VCP;
3163  else
3164  output[0x01] &= ~DRIVER_VCP;
3165  if (eeprom->channel_c_driver == DRIVER_VCP)
3166  output[0x00] |= (DRIVER_VCP << 4);
3167  else
3168  output[0x00] &= ~(DRIVER_VCP << 4);
3169  if (eeprom->channel_d_driver == DRIVER_VCP)
3170  output[0x01] |= (DRIVER_VCP << 4);
3171  else
3172  output[0x01] &= ~(DRIVER_VCP << 4);
3173 
3174  if (eeprom->suspend_pull_downs)
3175  output[0x0a] |= 0x4;
3176  else
3177  output[0x0a] &= ~0x4;
3178 
3179  if (eeprom->channel_a_rs485enable)
3180  output[0x0b] |= CHANNEL_IS_RS485 << 0;
3181  else
3182  output[0x0b] &= ~(CHANNEL_IS_RS485 << 0);
3183  if (eeprom->channel_b_rs485enable)
3184  output[0x0b] |= CHANNEL_IS_RS485 << 1;
3185  else
3186  output[0x0b] &= ~(CHANNEL_IS_RS485 << 1);
3187  if (eeprom->channel_c_rs485enable)
3188  output[0x0b] |= CHANNEL_IS_RS485 << 2;
3189  else
3190  output[0x0b] &= ~(CHANNEL_IS_RS485 << 2);
3191  if (eeprom->channel_d_rs485enable)
3192  output[0x0b] |= CHANNEL_IS_RS485 << 3;
3193  else
3194  output[0x0b] &= ~(CHANNEL_IS_RS485 << 3);
3195 
3196  if (eeprom->group0_drive > DRIVE_16MA)
3197  output[0x0c] |= DRIVE_16MA;
3198  else
3199  output[0x0c] |= eeprom->group0_drive;
3200  if (eeprom->group0_schmitt == IS_SCHMITT)
3201  output[0x0c] |= IS_SCHMITT;
3202  if (eeprom->group0_slew == SLOW_SLEW)
3203  output[0x0c] |= SLOW_SLEW;
3204 
3205  if (eeprom->group1_drive > DRIVE_16MA)
3206  output[0x0c] |= DRIVE_16MA<<4;
3207  else
3208  output[0x0c] |= eeprom->group1_drive<<4;
3209  if (eeprom->group1_schmitt == IS_SCHMITT)
3210  output[0x0c] |= IS_SCHMITT<<4;
3211  if (eeprom->group1_slew == SLOW_SLEW)
3212  output[0x0c] |= SLOW_SLEW<<4;
3213 
3214  if (eeprom->group2_drive > DRIVE_16MA)
3215  output[0x0d] |= DRIVE_16MA;
3216  else
3217  output[0x0d] |= eeprom->group2_drive;
3218  if (eeprom->group2_schmitt == IS_SCHMITT)
3219  output[0x0d] |= IS_SCHMITT;
3220  if (eeprom->group2_slew == SLOW_SLEW)
3221  output[0x0d] |= SLOW_SLEW;
3222 
3223  if (eeprom->group3_drive > DRIVE_16MA)
3224  output[0x0d] |= DRIVE_16MA<<4;
3225  else
3226  output[0x0d] |= eeprom->group3_drive<<4;
3227  if (eeprom->group3_schmitt == IS_SCHMITT)
3228  output[0x0d] |= IS_SCHMITT<<4;
3229  if (eeprom->group3_slew == SLOW_SLEW)
3230  output[0x0d] |= SLOW_SLEW<<4;
3231 
3232  output[0x18] = eeprom->chip;
3233 
3234  break;
3235  case TYPE_232H:
3236  output[0x00] = type2bit(eeprom->channel_a_type, TYPE_232H);
3237  if ( eeprom->channel_a_driver == DRIVER_VCP)
3238  output[0x00] |= DRIVER_VCPH;
3239  else
3240  output[0x00] &= ~DRIVER_VCPH;
3241  if (eeprom->powersave)
3242  output[0x01] |= POWER_SAVE_DISABLE_H;
3243  else
3244  output[0x01] &= ~POWER_SAVE_DISABLE_H;
3245 
3246  if (eeprom->suspend_pull_downs)
3247  output[0x0a] |= 0x4;
3248  else
3249  output[0x0a] &= ~0x4;
3250 
3251  if (eeprom->clock_polarity)
3252  output[0x01] |= FT1284_CLK_IDLE_STATE;
3253  else
3254  output[0x01] &= ~FT1284_CLK_IDLE_STATE;
3255  if (eeprom->data_order)
3256  output[0x01] |= FT1284_DATA_LSB;
3257  else
3258  output[0x01] &= ~FT1284_DATA_LSB;
3259  if (eeprom->flow_control)
3260  output[0x01] |= FT1284_FLOW_CONTROL;
3261  else
3262  output[0x01] &= ~FT1284_FLOW_CONTROL;
3263  if (eeprom->group0_drive > DRIVE_16MA)
3264  output[0x0c] |= DRIVE_16MA;
3265  else
3266  output[0x0c] |= eeprom->group0_drive;
3267  if (eeprom->group0_schmitt == IS_SCHMITT)
3268  output[0x0c] |= IS_SCHMITT;
3269  if (eeprom->group0_slew == SLOW_SLEW)
3270  output[0x0c] |= SLOW_SLEW;
3271 
3272  if (eeprom->group1_drive > DRIVE_16MA)
3273  output[0x0d] |= DRIVE_16MA;
3274  else
3275  output[0x0d] |= eeprom->group1_drive;
3276  if (eeprom->group1_schmitt == IS_SCHMITT)
3277  output[0x0d] |= IS_SCHMITT;
3278  if (eeprom->group1_slew == SLOW_SLEW)
3279  output[0x0d] |= SLOW_SLEW;
3280 
3281  set_ft232h_cbus(eeprom, output);
3282 
3283  output[0x1e] = eeprom->chip;
3284  fprintf(stderr,"FIXME: Build FT232H specific EEPROM settings\n");
3285  break;
3286  case TYPE_230X:
3287  output[0x00] = 0x80; /* Actually, leave the default value */
3288  /*FIXME: Make DBUS & CBUS Control configurable*/
3289  output[0x0c] = 0; /* DBUS drive 4mA, CBUS drive 4 mA like factory default */
3290  for (j = 0; j <= 6; j++)
3291  {
3292  output[0x1a + j] = eeprom->cbus_function[j];
3293  }
3294  output[0x0b] = eeprom->invert;
3295  break;
3296  }
3297 
3298  /* First address without use */
3299  free_start = 0;
3300  switch (ftdi->type)
3301  {
3302  case TYPE_230X:
3303  free_start += 2;
3304  case TYPE_232H:
3305  free_start += 6;
3306  case TYPE_2232H:
3307  case TYPE_4232H:
3308  free_start += 2;
3309  case TYPE_R:
3310  free_start += 2;
3311  case TYPE_2232C:
3312  free_start++;
3313  case TYPE_AM:
3314  case TYPE_BM:
3315  free_start += 0x14;
3316  }
3317 
3318  /* Arbitrary user data */
3319  if (eeprom->user_data && eeprom->user_data_size >= 0)
3320  {
3321  if (eeprom->user_data_addr < free_start)
3322  fprintf(stderr,"Warning, user data starts inside the generated data!\n");
3323  if (eeprom->user_data_addr + eeprom->user_data_size >= free_end)
3324  fprintf(stderr,"Warning, user data overlaps the strings area!\n");
3325  if (eeprom->user_data_addr + eeprom->user_data_size > eeprom->size)
3326  ftdi_error_return(-1,"eeprom size exceeded");
3327  memcpy(output + eeprom->user_data_addr, eeprom->user_data, eeprom->user_data_size);
3328  }
3329 
3330  // calculate checksum
3331  checksum = 0xAAAA;
3332 
3333  for (i = 0; i < eeprom->size/2-1; i++)
3334  {
3335  if ((ftdi->type == TYPE_230X) && (i == 0x12))
3336  {
3337  /* FT230X has a user section in the MTP which is not part of the checksum */
3338  i = 0x40;
3339  }
3340  if ((ftdi->type == TYPE_230X) && (i >= 0x40) && (i < 0x50)) {
3341  uint16_t data;
3342  if (ftdi_read_eeprom_location(ftdi, i, &data)) {
3343  fprintf(stderr, "Reading Factory Configuration Data failed\n");
3344  i = 0x50;
3345  }
3346  value = data;
3347  }
3348  else {
3349  value = output[i*2];
3350  value += output[(i*2)+1] << 8;
3351  }
3352  checksum = value^checksum;
3353  checksum = (checksum << 1) | (checksum >> 15);
3354  }
3355 
3356  output[eeprom->size-2] = checksum;
3357  output[eeprom->size-1] = checksum >> 8;
3358 
3359  eeprom->initialized_for_connected_device = 1;
3360  return user_area_size;
3361 }
3362 /* Decode the encoded EEPROM field for the FTDI Mode into a value for the abstracted
3363  * EEPROM structure
3364  *
3365  * FTD2XX doesn't allow to set multiple bits in the interface mode bitfield, and so do we
3366  */
3367 static unsigned char bit2type(unsigned char bits)
3368 {
3369  switch (bits)
3370  {
3371  case 0: return CHANNEL_IS_UART;
3372  case 1: return CHANNEL_IS_FIFO;
3373  case 2: return CHANNEL_IS_OPTO;
3374  case 4: return CHANNEL_IS_CPU;
3375  case 8: return CHANNEL_IS_FT1284;
3376  default:
3377  fprintf(stderr," Unexpected value %d for Hardware Interface type\n",
3378  bits);
3379  }
3380  return 0;
3381 }
3382 /* Decode 230X / 232R type chips invert bits
3383  * Prints directly to stdout.
3384 */
3385 static void print_inverted_bits(int invert)
3386 {
3387  const char *r_bits[] = {"TXD","RXD","RTS","CTS","DTR","DSR","DCD","RI"};
3388  int i;
3389 
3390  fprintf(stdout,"Inverted bits:");
3391  for (i=0; i<8; i++)
3392  if ((invert & (1<<i)) == (1<<i))
3393  fprintf(stdout," %s",r_bits[i]);
3394 
3395  fprintf(stdout,"\n");
3396 }
3411 int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose)
3412 {
3413  int i, j;
3414  unsigned short checksum, eeprom_checksum, value;
3415  unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
3416  int eeprom_size;
3417  struct ftdi_eeprom *eeprom;
3418  unsigned char *buf = NULL;
3419 
3420  if (ftdi == NULL)
3421  ftdi_error_return(-1,"No context");
3422  if (ftdi->eeprom == NULL)
3423  ftdi_error_return(-1,"No eeprom structure");
3424 
3425  eeprom = ftdi->eeprom;
3426  eeprom_size = eeprom->size;
3427  buf = ftdi->eeprom->buf;
3428 
3429  // Addr 02: Vendor ID
3430  eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
3431 
3432  // Addr 04: Product ID
3433  eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
3434 
3435  // Addr 06: Device release number
3436  eeprom->release_number = buf[0x06] + (buf[0x07]<<8);
3437 
3438  // Addr 08: Config descriptor
3439  // Bit 7: always 1
3440  // Bit 6: 1 if this device is self powered, 0 if bus powered
3441  // Bit 5: 1 if this device uses remote wakeup
3442  eeprom->self_powered = buf[0x08] & 0x40;
3443  eeprom->remote_wakeup = buf[0x08] & 0x20;
3444 
3445  // Addr 09: Max power consumption: max power = value * 2 mA
3446  eeprom->max_power = MAX_POWER_MILLIAMP_PER_UNIT * buf[0x09];
3447 
3448  // Addr 0A: Chip configuration
3449  // Bit 7: 0 - reserved
3450  // Bit 6: 0 - reserved
3451  // Bit 5: 0 - reserved
3452  // Bit 4: 1 - Change USB version on BM and 2232C
3453  // Bit 3: 1 - Use the serial number string
3454  // Bit 2: 1 - Enable suspend pull downs for lower power
3455  // Bit 1: 1 - Out EndPoint is Isochronous
3456  // Bit 0: 1 - In EndPoint is Isochronous
3457  //
3458  eeprom->in_is_isochronous = buf[0x0A]&0x01;
3459  eeprom->out_is_isochronous = buf[0x0A]&0x02;
3460  eeprom->suspend_pull_downs = buf[0x0A]&0x04;
3461  eeprom->use_serial = !!(buf[0x0A] & USE_SERIAL_NUM);
3462  eeprom->use_usb_version = !!(buf[0x0A] & USE_USB_VERSION_BIT);
3463 
3464  // Addr 0C: USB version low byte when 0x0A
3465  // Addr 0D: USB version high byte when 0x0A
3466  eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
3467 
3468  // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
3469  // Addr 0F: Length of manufacturer string
3470  manufacturer_size = buf[0x0F]/2;
3471  if (eeprom->manufacturer)
3472  free(eeprom->manufacturer);
3473  if (manufacturer_size > 0)
3474  {
3475  eeprom->manufacturer = (char *)malloc(manufacturer_size);
3476  if (eeprom->manufacturer)
3477  {
3478  // Decode manufacturer
3479  i = buf[0x0E] & (eeprom_size -1); // offset
3480  for (j=0; j<manufacturer_size-1; j++)
3481  {
3482  eeprom->manufacturer[j] = buf[2*j+i+2];
3483  }
3484  eeprom->manufacturer[j] = '\0';
3485  }
3486  }
3487  else eeprom->manufacturer = NULL;
3488 
3489  // Addr 10: Offset of the product string + 0x80, calculated later
3490  // Addr 11: Length of product string
3491  if (eeprom->product)
3492  free(eeprom->product);
3493  product_size = buf[0x11]/2;
3494  if (product_size > 0)
3495  {
3496  eeprom->product = (char *)malloc(product_size);
3497  if (eeprom->product)
3498  {
3499  // Decode product name
3500  i = buf[0x10] & (eeprom_size -1); // offset
3501  for (j=0; j<product_size-1; j++)
3502  {
3503  eeprom->product[j] = buf[2*j+i+2];
3504  }
3505  eeprom->product[j] = '\0';
3506  }
3507  }
3508  else eeprom->product = NULL;
3509 
3510  // Addr 12: Offset of the serial string + 0x80, calculated later
3511  // Addr 13: Length of serial string
3512  if (eeprom->serial)
3513  free(eeprom->serial);
3514  serial_size = buf[0x13]/2;
3515  if (serial_size > 0)
3516  {
3517  eeprom->serial = (char *)malloc(serial_size);
3518  if (eeprom->serial)
3519  {
3520  // Decode serial
3521  i = buf[0x12] & (eeprom_size -1); // offset
3522  for (j=0; j<serial_size-1; j++)
3523  {
3524  eeprom->serial[j] = buf[2*j+i+2];
3525  }
3526  eeprom->serial[j] = '\0';
3527  }
3528  }
3529  else eeprom->serial = NULL;
3530 
3531  // verify checksum
3532  checksum = 0xAAAA;
3533 
3534  for (i = 0; i < eeprom_size/2-1; i++)
3535  {
3536  if ((ftdi->type == TYPE_230X) && (i == 0x12))
3537  {
3538  /* FT230X has a user section in the MTP which is not part of the checksum */
3539  i = 0x40;
3540  }
3541  value = buf[i*2];
3542  value += buf[(i*2)+1] << 8;
3543 
3544  checksum = value^checksum;
3545  checksum = (checksum << 1) | (checksum >> 15);
3546  }
3547 
3548  eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
3549 
3550  if (eeprom_checksum != checksum)
3551  {
3552  fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
3553  ftdi_error_return(-1,"EEPROM checksum error");
3554  }
3555 
3556  eeprom->channel_a_type = 0;
3557  if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM))
3558  {
3559  eeprom->chip = -1;
3560  }
3561  else if (ftdi->type == TYPE_2232C)
3562  {
3563  eeprom->channel_a_type = bit2type(buf[0x00] & 0x7);
3564  eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
3565  eeprom->high_current_a = buf[0x00] & HIGH_CURRENT_DRIVE;
3566  eeprom->channel_b_type = buf[0x01] & 0x7;
3567  eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
3568  eeprom->high_current_b = buf[0x01] & HIGH_CURRENT_DRIVE;
3569  eeprom->chip = buf[0x14];
3570  }
3571  else if (ftdi->type == TYPE_R)
3572  {
3573  /* TYPE_R flags D2XX, not VCP as all others*/
3574  eeprom->channel_a_driver = ~buf[0x00] & DRIVER_VCP;
3575  eeprom->high_current = buf[0x00] & HIGH_CURRENT_DRIVE_R;
3576  eeprom->external_oscillator = buf[0x00] & 0x02;
3577  if ( (buf[0x01]&0x40) != 0x40)
3578  fprintf(stderr,
3579  "TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size."
3580  " If this happened with the\n"
3581  " EEPROM programmed by FTDI tools, please report "
3582  "to libftdi@developer.intra2net.com\n");
3583 
3584  eeprom->chip = buf[0x16];
3585  // Addr 0B: Invert data lines
3586  // Works only on FT232R, not FT245R, but no way to distinguish
3587  eeprom->invert = buf[0x0B];
3588  // Addr 14: CBUS function: CBUS0, CBUS1
3589  // Addr 15: CBUS function: CBUS2, CBUS3
3590  // Addr 16: CBUS function: CBUS5
3591  eeprom->cbus_function[0] = buf[0x14] & 0x0f;
3592  eeprom->cbus_function[1] = (buf[0x14] >> 4) & 0x0f;
3593  eeprom->cbus_function[2] = buf[0x15] & 0x0f;
3594  eeprom->cbus_function[3] = (buf[0x15] >> 4) & 0x0f;
3595  eeprom->cbus_function[4] = buf[0x16] & 0x0f;
3596  }
3597  else if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
3598  {
3599  eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
3600  eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
3601 
3602  if (ftdi->type == TYPE_2232H)
3603  {
3604  eeprom->channel_a_type = bit2type(buf[0x00] & 0x7);
3605  eeprom->channel_b_type = bit2type(buf[0x01] & 0x7);
3606  eeprom->suspend_dbus7 = buf[0x01] & SUSPEND_DBUS7_BIT;
3607  }
3608  else
3609  {
3610  eeprom->channel_c_driver = (buf[0x00] >> 4) & DRIVER_VCP;
3611  eeprom->channel_d_driver = (buf[0x01] >> 4) & DRIVER_VCP;
3612  eeprom->channel_a_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 0);
3613  eeprom->channel_b_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 1);
3614  eeprom->channel_c_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 2);
3615  eeprom->channel_d_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 3);
3616  }
3617 
3618  eeprom->chip = buf[0x18];
3619  eeprom->group0_drive = buf[0x0c] & DRIVE_16MA;
3620  eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT;
3621  eeprom->group0_slew = buf[0x0c] & SLOW_SLEW;
3622  eeprom->group1_drive = (buf[0x0c] >> 4) & 0x3;
3623  eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT;
3624  eeprom->group1_slew = (buf[0x0c] >> 4) & SLOW_SLEW;
3625  eeprom->group2_drive = buf[0x0d] & DRIVE_16MA;
3626  eeprom->group2_schmitt = buf[0x0d] & IS_SCHMITT;
3627  eeprom->group2_slew = buf[0x0d] & SLOW_SLEW;
3628  eeprom->group3_drive = (buf[0x0d] >> 4) & DRIVE_16MA;
3629  eeprom->group3_schmitt = (buf[0x0d] >> 4) & IS_SCHMITT;
3630  eeprom->group3_slew = (buf[0x0d] >> 4) & SLOW_SLEW;
3631  }
3632  else if (ftdi->type == TYPE_232H)
3633  {
3634  eeprom->channel_a_type = buf[0x00] & 0xf;
3635  eeprom->channel_a_driver = (buf[0x00] & DRIVER_VCPH)?DRIVER_VCP:0;
3636  eeprom->clock_polarity = buf[0x01] & FT1284_CLK_IDLE_STATE;
3637  eeprom->data_order = buf[0x01] & FT1284_DATA_LSB;
3638  eeprom->flow_control = buf[0x01] & FT1284_FLOW_CONTROL;
3639  eeprom->powersave = buf[0x01] & POWER_SAVE_DISABLE_H;
3640  eeprom->group0_drive = buf[0x0c] & DRIVE_16MA;
3641  eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT;
3642  eeprom->group0_slew = buf[0x0c] & SLOW_SLEW;
3643  eeprom->group1_drive = buf[0x0d] & DRIVE_16MA;
3644  eeprom->group1_schmitt = buf[0x0d] & IS_SCHMITT;
3645  eeprom->group1_slew = buf[0x0d] & SLOW_SLEW;
3646 
3647  for(i=0; i<5; i++)
3648  {
3649  eeprom->cbus_function[2*i ] = buf[0x18+i] & 0x0f;
3650  eeprom->cbus_function[2*i+1] = (buf[0x18+i] >> 4) & 0x0f;
3651  }
3652  eeprom->chip = buf[0x1e];
3653  /*FIXME: Decipher more values*/
3654  }
3655  else if (ftdi->type == TYPE_230X)
3656  {
3657  for(i=0; i<4; i++)
3658  {
3659  eeprom->cbus_function[i] = buf[0x1a + i] & 0xFF;
3660  }
3661  eeprom->group0_drive = buf[0x0c] & 0x03;
3662  eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT;
3663  eeprom->group0_slew = buf[0x0c] & SLOW_SLEW;
3664  eeprom->group1_drive = (buf[0x0c] >> 4) & 0x03;
3665  eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT;
3666  eeprom->group1_slew = (buf[0x0c] >> 4) & SLOW_SLEW;
3667 
3668  eeprom->invert = buf[0xb];
3669  }
3670 
3671  if (verbose)
3672  {
3673  const char *channel_mode[] = {"UART", "FIFO", "CPU", "OPTO", "FT1284"};
3674  fprintf(stdout, "VID: 0x%04x\n",eeprom->vendor_id);
3675  fprintf(stdout, "PID: 0x%04x\n",eeprom->product_id);
3676  fprintf(stdout, "Release: 0x%04x\n",eeprom->release_number);
3677 
3678  if (eeprom->self_powered)
3679  fprintf(stdout, "Self-Powered%s", (eeprom->remote_wakeup)?", USB Remote Wake Up\n":"\n");
3680  else
3681  fprintf(stdout, "Bus Powered: %3d mA%s", eeprom->max_power,
3682  (eeprom->remote_wakeup)?" USB Remote Wake Up\n":"\n");
3683  if (eeprom->manufacturer)
3684  fprintf(stdout, "Manufacturer: %s\n",eeprom->manufacturer);
3685  if (eeprom->product)
3686  fprintf(stdout, "Product: %s\n",eeprom->product);
3687  if (eeprom->serial)
3688  fprintf(stdout, "Serial: %s\n",eeprom->serial);
3689  fprintf(stdout, "Checksum : %04x\n", checksum);
3690  if (ftdi->type == TYPE_R) {
3691  fprintf(stdout, "Internal EEPROM\n");
3692  fprintf(stdout,"Oscillator: %s\n", eeprom->external_oscillator?"External":"Internal");
3693  }
3694  else if (eeprom->chip >= 0x46)
3695  fprintf(stdout, "Attached EEPROM: 93x%02x\n", eeprom->chip);
3696  if (eeprom->suspend_dbus7)
3697  fprintf(stdout, "Suspend on DBUS7\n");
3698  if (eeprom->suspend_pull_downs)
3699  fprintf(stdout, "Pull IO pins low during suspend\n");
3700  if(eeprom->powersave)
3701  {
3702  if(ftdi->type >= TYPE_232H)
3703  fprintf(stdout,"Enter low power state on ACBUS7\n");
3704  }
3705  if (eeprom->remote_wakeup)
3706  fprintf(stdout, "Enable Remote Wake Up\n");
3707  fprintf(stdout, "PNP: %d\n",(eeprom->is_not_pnp)?0:1);
3708  if (ftdi->type >= TYPE_2232C)
3709  fprintf(stdout,"Channel A has Mode %s%s%s\n",
3710  channel_mode[eeprom->channel_a_type],
3711  (eeprom->channel_a_driver)?" VCP":"",
3712  (eeprom->high_current_a)?" High Current IO":"");
3713  if (ftdi->type == TYPE_232H)
3714  {
3715  fprintf(stdout,"FT1284 Mode Clock is idle %s, %s first, %sFlow Control\n",
3716  (eeprom->clock_polarity)?"HIGH":"LOW",
3717  (eeprom->data_order)?"LSB":"MSB",
3718  (eeprom->flow_control)?"":"No ");
3719  }
3720  if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
3721  fprintf(stdout,"Channel B has Mode %s%s%s\n",
3722  channel_mode[eeprom->channel_b_type],
3723  (eeprom->channel_b_driver)?" VCP":"",
3724  (eeprom->high_current_b)?" High Current IO":"");
3725  if (((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C)) &&
3726  eeprom->use_usb_version)
3727  fprintf(stdout,"Use explicit USB Version %04x\n",eeprom->usb_version);
3728 
3729  if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
3730  {
3731  fprintf(stdout,"%s has %d mA drive%s%s\n",
3732  (ftdi->type == TYPE_2232H)?"AL":"A",
3733  (eeprom->group0_drive+1) *4,
3734  (eeprom->group0_schmitt)?" Schmitt Input":"",
3735  (eeprom->group0_slew)?" Slow Slew":"");
3736  fprintf(stdout,"%s has %d mA drive%s%s\n",
3737  (ftdi->type == TYPE_2232H)?"AH":"B",
3738  (eeprom->group1_drive+1) *4,
3739  (eeprom->group1_schmitt)?" Schmitt Input":"",
3740  (eeprom->group1_slew)?" Slow Slew":"");
3741  fprintf(stdout,"%s has %d mA drive%s%s\n",
3742  (ftdi->type == TYPE_2232H)?"BL":"C",
3743  (eeprom->group2_drive+1) *4,
3744  (eeprom->group2_schmitt)?" Schmitt Input":"",
3745  (eeprom->group2_slew)?" Slow Slew":"");
3746  fprintf(stdout,"%s has %d mA drive%s%s\n",
3747  (ftdi->type == TYPE_2232H)?"BH":"D",
3748  (eeprom->group3_drive+1) *4,
3749  (eeprom->group3_schmitt)?" Schmitt Input":"",
3750  (eeprom->group3_slew)?" Slow Slew":"");
3751  }
3752  else if (ftdi->type == TYPE_232H)
3753  {
3754  const char *cbush_mux[] = {"TRISTATE","TXLED","RXLED", "TXRXLED","PWREN",
3755  "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN",
3756  "CLK30","CLK15","CLK7_5"
3757  };
3758  fprintf(stdout,"ACBUS has %d mA drive%s%s\n",
3759  (eeprom->group0_drive+1) *4,
3760  (eeprom->group0_schmitt)?" Schmitt Input":"",
3761  (eeprom->group0_slew)?" Slow Slew":"");
3762  fprintf(stdout,"ADBUS has %d mA drive%s%s\n",
3763  (eeprom->group1_drive+1) *4,
3764  (eeprom->group1_schmitt)?" Schmitt Input":"",
3765  (eeprom->group1_slew)?" Slow Slew":"");
3766  for (i=0; i<10; i++)
3767  {
3768  if (eeprom->cbus_function[i]<= CBUSH_CLK7_5 )
3769  fprintf(stdout,"C%d Function: %s\n", i,
3770  cbush_mux[eeprom->cbus_function[i]]);
3771  }
3772  }
3773  else if (ftdi->type == TYPE_230X)
3774  {
3775  const char *cbusx_mux[] = {"TRISTATE","TXLED","RXLED", "TXRXLED","PWREN",
3776  "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN",
3777  "CLK24","CLK12","CLK6","BAT_DETECT","BAT_DETECT#",
3778  "I2C_TXE#", "I2C_RXF#", "VBUS_SENSE", "BB_WR#",
3779  "BBRD#", "TIME_STAMP", "AWAKE#",
3780  };
3781  fprintf(stdout,"DBUS has %d mA drive%s%s\n",
3782  (eeprom->group0_drive+1) *4,
3783  (eeprom->group0_schmitt)?" Schmitt Input":"",
3784  (eeprom->group0_slew)?" Slow Slew":"");
3785  fprintf(stdout,"CBUS has %d mA drive%s%s\n",
3786  (eeprom->group1_drive+1) *4,
3787  (eeprom->group1_schmitt)?" Schmitt Input":"",
3788  (eeprom->group1_slew)?" Slow Slew":"");
3789  for (i=0; i<4; i++)
3790  {
3791  if (eeprom->cbus_function[i]<= CBUSX_AWAKE)
3792  fprintf(stdout,"CBUS%d Function: %s\n", i, cbusx_mux[eeprom->cbus_function[i]]);
3793  }
3794 
3795  if (eeprom->invert)
3796  print_inverted_bits(eeprom->invert);
3797  }
3798 
3799  if (ftdi->type == TYPE_R)
3800  {
3801  const char *cbus_mux[] = {"TXDEN","PWREN","RXLED", "TXLED","TX+RXLED",
3802  "SLEEP","CLK48","CLK24","CLK12","CLK6",
3803  "IOMODE","BB_WR","BB_RD"
3804  };
3805  const char *cbus_BB[] = {"RXF","TXE","RD", "WR"};
3806 
3807  if (eeprom->invert)
3808  print_inverted_bits(eeprom->invert);
3809 
3810  for (i=0; i<5; i++)
3811  {
3812  if (eeprom->cbus_function[i]<=CBUS_BB_RD)
3813  fprintf(stdout,"C%d Function: %s\n", i,
3814  cbus_mux[eeprom->cbus_function[i]]);
3815  else
3816  {
3817  if (i < 4)
3818  /* Running MPROG show that C0..3 have fixed function Synchronous
3819  Bit Bang mode */
3820  fprintf(stdout,"C%d BB Function: %s\n", i,
3821  cbus_BB[i]);
3822  else
3823  fprintf(stdout, "Unknown CBUS mode. Might be special mode?\n");
3824  }
3825  }
3826  }
3827  }
3828  return 0;
3829 }
3830 
3841 int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int* value)
3842 {
3843  switch (value_name)
3844  {
3845  case VENDOR_ID:
3846  *value = ftdi->eeprom->vendor_id;
3847  break;
3848  case PRODUCT_ID:
3849  *value = ftdi->eeprom->product_id;
3850  break;
3851  case RELEASE_NUMBER:
3852  *value = ftdi->eeprom->release_number;
3853  break;
3854  case SELF_POWERED:
3855  *value = ftdi->eeprom->self_powered;
3856  break;
3857  case REMOTE_WAKEUP:
3858  *value = ftdi->eeprom->remote_wakeup;
3859  break;
3860  case IS_NOT_PNP:
3861  *value = ftdi->eeprom->is_not_pnp;
3862  break;
3863  case SUSPEND_DBUS7:
3864  *value = ftdi->eeprom->suspend_dbus7;
3865  break;
3866  case IN_IS_ISOCHRONOUS:
3867  *value = ftdi->eeprom->in_is_isochronous;
3868  break;
3869  case OUT_IS_ISOCHRONOUS:
3870  *value = ftdi->eeprom->out_is_isochronous;
3871  break;
3872  case SUSPEND_PULL_DOWNS:
3873  *value = ftdi->eeprom->suspend_pull_downs;
3874  break;
3875  case USE_SERIAL:
3876  *value = ftdi->eeprom->use_serial;
3877  break;
3878  case USB_VERSION:
3879  *value = ftdi->eeprom->usb_version;
3880  break;
3881  case USE_USB_VERSION:
3882  *value = ftdi->eeprom->use_usb_version;
3883  break;
3884  case MAX_POWER:
3885  *value = ftdi->eeprom->max_power;
3886  break;
3887  case CHANNEL_A_TYPE:
3888  *value = ftdi->eeprom->channel_a_type;
3889  break;
3890  case CHANNEL_B_TYPE:
3891  *value = ftdi->eeprom->channel_b_type;
3892  break;
3893  case CHANNEL_A_DRIVER:
3894  *value = ftdi->eeprom->channel_a_driver;
3895  break;
3896  case CHANNEL_B_DRIVER:
3897  *value = ftdi->eeprom->channel_b_driver;
3898  break;
3899  case CHANNEL_C_DRIVER:
3900  *value = ftdi->eeprom->channel_c_driver;
3901  break;
3902  case CHANNEL_D_DRIVER:
3903  *value = ftdi->eeprom->channel_d_driver;
3904  break;
3905  case CHANNEL_A_RS485:
3906  *value = ftdi->eeprom->channel_a_rs485enable;
3907  break;
3908  case CHANNEL_B_RS485:
3909  *value = ftdi->eeprom->channel_b_rs485enable;
3910  break;
3911  case CHANNEL_C_RS485:
3912  *value = ftdi->eeprom->channel_c_rs485enable;
3913  break;
3914  case CHANNEL_D_RS485:
3915  *value = ftdi->eeprom->channel_d_rs485enable;
3916  break;
3917  case CBUS_FUNCTION_0:
3918  *value = ftdi->eeprom->cbus_function[0];
3919  break;
3920  case CBUS_FUNCTION_1:
3921  *value = ftdi->eeprom->cbus_function[1];
3922  break;
3923  case CBUS_FUNCTION_2:
3924  *value = ftdi->eeprom->cbus_function[2];
3925  break;
3926  case CBUS_FUNCTION_3:
3927  *value = ftdi->eeprom->cbus_function[3];
3928  break;
3929  case CBUS_FUNCTION_4:
3930  *value = ftdi->eeprom->cbus_function[4];
3931  break;
3932  case CBUS_FUNCTION_5:
3933  *value = ftdi->eeprom->cbus_function[5];
3934  break;
3935  case CBUS_FUNCTION_6:
3936  *value = ftdi->eeprom->cbus_function[6];
3937  break;
3938  case CBUS_FUNCTION_7:
3939  *value = ftdi->eeprom->cbus_function[7];
3940  break;
3941  case CBUS_FUNCTION_8:
3942  *value = ftdi->eeprom->cbus_function[8];
3943  break;
3944  case CBUS_FUNCTION_9:
3945  *value = ftdi->eeprom->cbus_function[9];
3946  break;
3947  case HIGH_CURRENT:
3948  *value = ftdi->eeprom->high_current;
3949  break;
3950  case HIGH_CURRENT_A:
3951  *value = ftdi->eeprom->high_current_a;
3952  break;
3953  case HIGH_CURRENT_B:
3954  *value = ftdi->eeprom->high_current_b;
3955  break;
3956  case INVERT:
3957  *value = ftdi->eeprom->invert;
3958  break;
3959  case GROUP0_DRIVE:
3960  *value = ftdi->eeprom->group0_drive;
3961  break;
3962  case GROUP0_SCHMITT:
3963  *value = ftdi->eeprom->group0_schmitt;
3964  break;
3965  case GROUP0_SLEW:
3966  *value = ftdi->eeprom->group0_slew;
3967  break;
3968  case GROUP1_DRIVE:
3969  *value = ftdi->eeprom->group1_drive;
3970  break;
3971  case GROUP1_SCHMITT:
3972  *value = ftdi->eeprom->group1_schmitt;
3973  break;
3974  case GROUP1_SLEW:
3975  *value = ftdi->eeprom->group1_slew;
3976  break;
3977  case GROUP2_DRIVE:
3978  *value = ftdi->eeprom->group2_drive;
3979  break;
3980  case GROUP2_SCHMITT:
3981  *value = ftdi->eeprom->group2_schmitt;
3982  break;
3983  case GROUP2_SLEW:
3984  *value = ftdi->eeprom->group2_slew;
3985  break;
3986  case GROUP3_DRIVE:
3987  *value = ftdi->eeprom->group3_drive;
3988  break;
3989  case GROUP3_SCHMITT:
3990  *value = ftdi->eeprom->group3_schmitt;
3991  break;
3992  case GROUP3_SLEW:
3993  *value = ftdi->eeprom->group3_slew;
3994  break;
3995  case POWER_SAVE:
3996  *value = ftdi->eeprom->powersave;
3997  break;
3998  case CLOCK_POLARITY:
3999  *value = ftdi->eeprom->clock_polarity;
4000  break;
4001  case DATA_ORDER:
4002  *value = ftdi->eeprom->data_order;
4003  break;
4004  case FLOW_CONTROL:
4005  *value = ftdi->eeprom->flow_control;
4006  break;
4007  case CHIP_TYPE:
4008  *value = ftdi->eeprom->chip;
4009  break;
4010  case CHIP_SIZE:
4011  *value = ftdi->eeprom->size;
4012  break;
4013  case EXTERNAL_OSCILLATOR:
4014  *value = ftdi->eeprom->external_oscillator;
4015  break;
4016  default:
4017  ftdi_error_return(-1, "Request for unknown EEPROM value");
4018  }
4019  return 0;
4020 }
4021 
4034 int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int value)
4035 {
4036  switch (value_name)
4037  {
4038  case VENDOR_ID:
4039  ftdi->eeprom->vendor_id = value;
4040  break;
4041  case PRODUCT_ID:
4042  ftdi->eeprom->product_id = value;
4043  break;
4044  case RELEASE_NUMBER:
4045  ftdi->eeprom->release_number = value;
4046  break;
4047  case SELF_POWERED:
4048  ftdi->eeprom->self_powered = value;
4049  break;
4050  case REMOTE_WAKEUP:
4051  ftdi->eeprom->remote_wakeup = value;
4052  break;
4053  case IS_NOT_PNP:
4054  ftdi->eeprom->is_not_pnp = value;
4055  break;
4056  case SUSPEND_DBUS7:
4057  ftdi->eeprom->suspend_dbus7 = value;
4058  break;
4059  case IN_IS_ISOCHRONOUS:
4060  ftdi->eeprom->in_is_isochronous = value;
4061  break;
4062  case OUT_IS_ISOCHRONOUS:
4063  ftdi->eeprom->out_is_isochronous = value;
4064  break;
4065  case SUSPEND_PULL_DOWNS:
4066  ftdi->eeprom->suspend_pull_downs = value;
4067  break;
4068  case USE_SERIAL:
4069  ftdi->eeprom->use_serial = value;
4070  break;
4071  case USB_VERSION:
4072  ftdi->eeprom->usb_version = value;
4073  break;
4074  case USE_USB_VERSION:
4075  ftdi->eeprom->use_usb_version = value;
4076  break;
4077  case MAX_POWER:
4078  ftdi->eeprom->max_power = value;
4079  break;
4080  case CHANNEL_A_TYPE:
4081  ftdi->eeprom->channel_a_type = value;
4082  break;
4083  case CHANNEL_B_TYPE:
4084  ftdi->eeprom->channel_b_type = value;
4085  break;
4086  case CHANNEL_A_DRIVER:
4087  ftdi->eeprom->channel_a_driver = value;
4088  break;
4089  case CHANNEL_B_DRIVER:
4090  ftdi->eeprom->channel_b_driver = value;
4091  break;
4092  case CHANNEL_C_DRIVER:
4093  ftdi->eeprom->channel_c_driver = value;
4094  break;
4095  case CHANNEL_D_DRIVER:
4096  ftdi->eeprom->channel_d_driver = value;
4097  break;
4098  case CHANNEL_A_RS485:
4099  ftdi->eeprom->channel_a_rs485enable = value;
4100  break;
4101  case CHANNEL_B_RS485:
4102  ftdi->eeprom->channel_b_rs485enable = value;
4103  break;
4104  case CHANNEL_C_RS485:
4105  ftdi->eeprom->channel_c_rs485enable = value;
4106  break;
4107  case CHANNEL_D_RS485:
4108  ftdi->eeprom->channel_d_rs485enable = value;
4109  break;
4110  case CBUS_FUNCTION_0:
4111  ftdi->eeprom->cbus_function[0] = value;
4112  break;
4113  case CBUS_FUNCTION_1:
4114  ftdi->eeprom->cbus_function[1] = value;
4115  break;
4116  case CBUS_FUNCTION_2:
4117  ftdi->eeprom->cbus_function[2] = value;
4118  break;
4119  case CBUS_FUNCTION_3:
4120  ftdi->eeprom->cbus_function[3] = value;
4121  break;
4122  case CBUS_FUNCTION_4:
4123  ftdi->eeprom->cbus_function[4] = value;
4124  break;
4125  case CBUS_FUNCTION_5:
4126  ftdi->eeprom->cbus_function[5] = value;
4127  break;
4128  case CBUS_FUNCTION_6:
4129  ftdi->eeprom->cbus_function[6] = value;
4130  break;
4131  case CBUS_FUNCTION_7:
4132  ftdi->eeprom->cbus_function[7] = value;
4133  break;
4134  case CBUS_FUNCTION_8:
4135  ftdi->eeprom->cbus_function[8] = value;
4136  break;
4137  case CBUS_FUNCTION_9:
4138  ftdi->eeprom->cbus_function[9] = value;
4139  break;
4140  case HIGH_CURRENT:
4141  ftdi->eeprom->high_current = value;
4142  break;
4143  case HIGH_CURRENT_A:
4144  ftdi->eeprom->high_current_a = value;
4145  break;
4146  case HIGH_CURRENT_B:
4147  ftdi->eeprom->high_current_b = value;
4148  break;
4149  case INVERT:
4150  ftdi->eeprom->invert = value;
4151  break;
4152  case GROUP0_DRIVE:
4153  ftdi->eeprom->group0_drive = value;
4154  break;
4155  case GROUP0_SCHMITT:
4156  ftdi->eeprom->group0_schmitt = value;
4157  break;
4158  case GROUP0_SLEW:
4159  ftdi->eeprom->group0_slew = value;
4160  break;
4161  case GROUP1_DRIVE:
4162  ftdi->eeprom->group1_drive = value;
4163  break;
4164  case GROUP1_SCHMITT:
4165  ftdi->eeprom->group1_schmitt = value;
4166  break;
4167  case GROUP1_SLEW:
4168  ftdi->eeprom->group1_slew = value;
4169  break;
4170  case GROUP2_DRIVE:
4171  ftdi->eeprom->group2_drive = value;
4172  break;
4173  case GROUP2_SCHMITT:
4174  ftdi->eeprom->group2_schmitt = value;
4175  break;
4176  case GROUP2_SLEW:
4177  ftdi->eeprom->group2_slew = value;
4178  break;
4179  case GROUP3_DRIVE:
4180  ftdi->eeprom->group3_drive = value;
4181  break;
4182  case GROUP3_SCHMITT:
4183  ftdi->eeprom->group3_schmitt = value;
4184  break;
4185  case GROUP3_SLEW:
4186  ftdi->eeprom->group3_slew = value;
4187  break;
4188  case CHIP_TYPE:
4189  ftdi->eeprom->chip = value;
4190  break;
4191  case POWER_SAVE:
4192  ftdi->eeprom->powersave = value;
4193  break;
4194  case CLOCK_POLARITY:
4195  ftdi->eeprom->clock_polarity = value;
4196  break;
4197  case DATA_ORDER:
4198  ftdi->eeprom->data_order = value;
4199  break;
4200  case FLOW_CONTROL:
4201  ftdi->eeprom->flow_control = value;
4202  break;
4203  case CHIP_SIZE:
4204  ftdi_error_return(-2, "EEPROM Value can't be changed");
4205  break;
4206  case EXTERNAL_OSCILLATOR:
4207  ftdi->eeprom->external_oscillator = value;
4208  break;
4209  case USER_DATA_ADDR:
4210  ftdi->eeprom->user_data_addr = value;
4211  break;
4212 
4213  default :
4214  ftdi_error_return(-1, "Request to unknown EEPROM value");
4215  }
4216  ftdi->eeprom->initialized_for_connected_device = 0;
4217  return 0;
4218 }
4219 
4230 int ftdi_get_eeprom_buf(struct ftdi_context *ftdi, unsigned char * buf, int size)
4231 {
4232  if (!ftdi || !(ftdi->eeprom))
4233  ftdi_error_return(-1, "No appropriate structure");
4234 
4235  if (!buf || size < ftdi->eeprom->size)
4236  ftdi_error_return(-1, "Not enough room to store eeprom");
4237 
4238  // Only copy up to FTDI_MAX_EEPROM_SIZE bytes
4239  if (size > FTDI_MAX_EEPROM_SIZE)
4240  size = FTDI_MAX_EEPROM_SIZE;
4241 
4242  memcpy(buf, ftdi->eeprom->buf, size);
4243 
4244  return 0;
4245 }
4246 
4256 int ftdi_set_eeprom_buf(struct ftdi_context *ftdi, const unsigned char * buf, int size)
4257 {
4258  if (!ftdi || !(ftdi->eeprom) || !buf)
4259  ftdi_error_return(-1, "No appropriate structure");
4260 
4261  // Only copy up to FTDI_MAX_EEPROM_SIZE bytes
4262  if (size > FTDI_MAX_EEPROM_SIZE)
4263  size = FTDI_MAX_EEPROM_SIZE;
4264 
4265  memcpy(ftdi->eeprom->buf, buf, size);
4266 
4267  return 0;
4268 }
4269 
4279 int ftdi_set_eeprom_user_data(struct ftdi_context *ftdi, const char * buf, int size)
4280 {
4281  if (!ftdi || !(ftdi->eeprom) || !buf)
4282  ftdi_error_return(-1, "No appropriate structure");
4283 
4284  ftdi->eeprom->user_data_size = size;
4285  ftdi->eeprom->user_data = buf;
4286  return 0;
4287 }
4288 
4300 int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
4301 {
4302  unsigned char buf[2];
4303 
4304  if (ftdi == NULL || ftdi->usb_dev == NULL)
4305  ftdi_error_return(-2, "USB device unavailable");
4306 
4307  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, eeprom_addr, buf, 2, ftdi->usb_read_timeout) != 2)
4308  ftdi_error_return(-1, "reading eeprom failed");
4309 
4310  *eeprom_val = (0xff & buf[0]) | (buf[1] << 8);
4311 
4312  return 0;
4313 }
4314 
4324 int ftdi_read_eeprom(struct ftdi_context *ftdi)
4325 {
4326  int i;
4327  unsigned char *buf;
4328 
4329  if (ftdi == NULL || ftdi->usb_dev == NULL)
4330  ftdi_error_return(-2, "USB device unavailable");
4331  buf = ftdi->eeprom->buf;
4332 
4333  for (i = 0; i < FTDI_MAX_EEPROM_SIZE/2; i++)
4334  {
4335  if (libusb_control_transfer(
4336  ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,SIO_READ_EEPROM_REQUEST, 0, i,
4337  buf+(i*2), 2, ftdi->usb_read_timeout) != 2)
4338  ftdi_error_return(-1, "reading eeprom failed");
4339  }
4340 
4341  if (ftdi->type == TYPE_R)
4342  ftdi->eeprom->size = 0x80;
4343  /* Guesses size of eeprom by comparing halves
4344  - will not work with blank eeprom */
4345  else if (strrchr((const char *)buf, 0xff) == ((const char *)buf +FTDI_MAX_EEPROM_SIZE -1))
4346  ftdi->eeprom->size = -1;
4347  else if (memcmp(buf,&buf[0x80],0x80) == 0)
4348  ftdi->eeprom->size = 0x80;
4349  else if (memcmp(buf,&buf[0x40],0x40) == 0)
4350  ftdi->eeprom->size = 0x40;
4351  else
4352  ftdi->eeprom->size = 0x100;
4353  return 0;
4354 }
4355 
4356 /*
4357  ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID
4358  Function is only used internally
4359  \internal
4360 */
4361 static unsigned char ftdi_read_chipid_shift(unsigned char value)
4362 {
4363  return ((value & 1) << 1) |
4364  ((value & 2) << 5) |
4365  ((value & 4) >> 2) |
4366  ((value & 8) << 4) |
4367  ((value & 16) >> 1) |
4368  ((value & 32) >> 1) |
4369  ((value & 64) >> 4) |
4370  ((value & 128) >> 2);
4371 }
4372 
4383 int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
4384 {
4385  unsigned int a = 0, b = 0;
4386 
4387  if (ftdi == NULL || ftdi->usb_dev == NULL)
4388  ftdi_error_return(-2, "USB device unavailable");
4389 
4390  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)
4391  {
4392  a = a << 8 | a >> 8;
4393  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)
4394  {
4395  b = b << 8 | b >> 8;
4396  a = (a << 16) | (b & 0xFFFF);
4397  a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
4398  | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
4399  *chipid = a ^ 0xa5f0f7d1;
4400  return 0;
4401  }
4402  }
4403 
4404  ftdi_error_return(-1, "read of FTDIChip-ID failed");
4405 }
4406 
4421 int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr,
4422  unsigned short eeprom_val)
4423 {
4424  int chip_type_location;
4425  unsigned short chip_type;
4426 
4427  if (ftdi == NULL || ftdi->usb_dev == NULL)
4428  ftdi_error_return(-2, "USB device unavailable");
4429 
4430  if (eeprom_addr <0x80)
4431  ftdi_error_return(-2, "Invalid access to checksum protected area below 0x80");
4432 
4433 
4434  switch (ftdi->type)
4435  {
4436  case TYPE_BM:
4437  case TYPE_2232C:
4438  chip_type_location = 0x14;
4439  break;
4440  case TYPE_2232H:
4441  case TYPE_4232H:
4442  chip_type_location = 0x18;
4443  break;
4444  case TYPE_232H:
4445  chip_type_location = 0x1e;
4446  break;
4447  default:
4448  ftdi_error_return(-4, "Device can't access unprotected area");
4449  }
4450 
4451  if (ftdi_read_eeprom_location( ftdi, chip_type_location>>1, &chip_type))
4452  ftdi_error_return(-5, "Reading failed");
4453  fprintf(stderr," loc 0x%04x val 0x%04x\n", chip_type_location,chip_type);
4454  if ((chip_type & 0xff) != 0x66)
4455  {
4456  ftdi_error_return(-6, "EEPROM is not of 93x66");
4457  }
4458 
4459  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
4460  SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
4461  NULL, 0, ftdi->usb_write_timeout) != 0)
4462  ftdi_error_return(-1, "unable to write eeprom");
4463 
4464  return 0;
4465 }
4466 
4477 int ftdi_write_eeprom(struct ftdi_context *ftdi)
4478 {
4479  unsigned short usb_val, status;
4480  int i, ret;
4481  unsigned char *eeprom;
4482 
4483  if (ftdi == NULL || ftdi->usb_dev == NULL)
4484  ftdi_error_return(-2, "USB device unavailable");
4485 
4486  if(ftdi->eeprom->initialized_for_connected_device == 0)
4487  ftdi_error_return(-3, "EEPROM not initialized for the connected device");
4488 
4489  eeprom = ftdi->eeprom->buf;
4490 
4491  /* These commands were traced while running MProg */
4492  if ((ret = ftdi_usb_reset(ftdi)) != 0)
4493  return ret;
4494  if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0)
4495  return ret;
4496  if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0)
4497  return ret;
4498 
4499  for (i = 0; i < ftdi->eeprom->size/2; i++)
4500  {
4501  /* Do not try to write to reserved area */
4502  if ((ftdi->type == TYPE_230X) && (i == 0x40))
4503  {
4504  i = 0x50;
4505  }
4506  usb_val = eeprom[i*2];
4507  usb_val += eeprom[(i*2)+1] << 8;
4508  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
4509  SIO_WRITE_EEPROM_REQUEST, usb_val, i,
4510  NULL, 0, ftdi->usb_write_timeout) < 0)
4511  ftdi_error_return(-1, "unable to write eeprom");
4512  }
4513 
4514  return 0;
4515 }
4516 
4531 #define MAGIC 0x55aa
4532 int ftdi_erase_eeprom(struct ftdi_context *ftdi)
4533 {
4534  unsigned short eeprom_value;
4535  if (ftdi == NULL || ftdi->usb_dev == NULL)
4536  ftdi_error_return(-2, "USB device unavailable");
4537 
4538  if ((ftdi->type == TYPE_R) || (ftdi->type == TYPE_230X))
4539  {
4540  ftdi->eeprom->chip = 0;
4541  return 0;
4542  }
4543 
4544  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
4545  0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
4546  ftdi_error_return(-1, "unable to erase eeprom");
4547 
4548 
4549  /* detect chip type by writing 0x55AA as magic at word position 0xc0
4550  Chip is 93x46 if magic is read at word position 0x00, as wraparound happens around 0x40
4551  Chip is 93x56 if magic is read at word position 0x40, as wraparound happens around 0x80
4552  Chip is 93x66 if magic is only read at word position 0xc0*/
4553  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
4554  SIO_WRITE_EEPROM_REQUEST, MAGIC, 0xc0,
4555  NULL, 0, ftdi->usb_write_timeout) != 0)
4556  ftdi_error_return(-3, "Writing magic failed");
4557  if (ftdi_read_eeprom_location( ftdi, 0x00, &eeprom_value))
4558  ftdi_error_return(-4, "Reading failed");
4559  if (eeprom_value == MAGIC)
4560  {
4561  ftdi->eeprom->chip = 0x46;
4562  }
4563  else
4564  {
4565  if (ftdi_read_eeprom_location( ftdi, 0x40, &eeprom_value))
4566  ftdi_error_return(-4, "Reading failed");
4567  if (eeprom_value == MAGIC)
4568  ftdi->eeprom->chip = 0x56;
4569  else
4570  {
4571  if (ftdi_read_eeprom_location( ftdi, 0xc0, &eeprom_value))
4572  ftdi_error_return(-4, "Reading failed");
4573  if (eeprom_value == MAGIC)
4574  ftdi->eeprom->chip = 0x66;
4575  else
4576  {
4577  ftdi->eeprom->chip = -1;
4578  }
4579  }
4580  }
4581  if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
4582  0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
4583  ftdi_error_return(-1, "unable to erase eeprom");
4584  return 0;
4585 }
4586 
4594 const char *ftdi_get_error_string (struct ftdi_context *ftdi)
4595 {
4596  if (ftdi == NULL)
4597  return "";
4598 
4599  return ftdi->error_str;
4600 }
4601 
4602 /* @} end of doxygen libftdi group */
convert_baudrate_UT_export
int convert_baudrate_UT_export(int baudrate, struct ftdi_context *ftdi, unsigned short *value, unsigned short *index)
Wrapper function to export ftdi_convert_baudrate() to the unit test Do not use, it's only for the uni...
Definition: ftdi.c:1332
CHANNEL_IS_FT1284
#define CHANNEL_IS_FT1284
Definition: ftdi.h:402
ftdi_eeprom::powersave
int powersave
Definition: ftdi_i.h:122
ftdi_write_data_submit
struct ftdi_transfer_control * ftdi_write_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
Definition: ftdi.c:1644
ftdi_read_pins
int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
Definition: ftdi.c:2140
ftdi_usb_open
int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
Definition: ftdi.c:698
FTDI_DEVICE_OUT_REQTYPE
#define FTDI_DEVICE_OUT_REQTYPE
Definition: ftdi.h:154
ftdi_transfer_control::completed
int completed
Definition: ftdi.h:208
ftdi_eeprom_get_strings
int ftdi_eeprom_get_strings(struct ftdi_context *ftdi, char *manufacturer, int mnf_len, char *product, int prod_len, char *serial, int serial_len)
Definition: ftdi.c:2666
ftdi_context::module_detach_mode
enum ftdi_module_detach_mode module_detach_mode
Definition: ftdi.h:273
SIO_SET_LATENCY_TIMER_REQUEST
#define SIO_SET_LATENCY_TIMER_REQUEST
Definition: ftdi.h:166
FT1284_CLK_IDLE_STATE
#define FT1284_CLK_IDLE_STATE
Definition: ftdi.h:351
ftdi_eeprom::out_is_isochronous
int out_is_isochronous
Definition: ftdi_i.h:54
ftdi_chip_type
ftdi_chip_type
Definition: ftdi.h:38
NONE
Definition: ftdi.h:50
ftdi_device_list
list of usb devices created by ftdi_usb_find_all()
Definition: ftdi.h:344
SLOW_SLEW
#define SLOW_SLEW
Definition: ftdi.h:410
ftdi_device_list::next
struct ftdi_device_list * next
Definition: ftdi.h:347
ftdi_version_info::minor
int minor
Definition: ftdi.h:458
ftdi_eeprom_set_strings
int ftdi_eeprom_set_strings(struct ftdi_context *ftdi, char *manufacturer, char *product, char *serial)
Definition: ftdi.c:2600
ftdi_eeprom::usb_version
int usb_version
Definition: ftdi_i.h:61
ftdi_read_data_get_chunksize
int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
Definition: ftdi.c:2070
ftdi_transfer_data_cancel
void ftdi_transfer_data_cancel(struct ftdi_transfer_control *tc, struct timeval *to)
Definition: ftdi.c:1832
ftdi_list_free2
void ftdi_list_free2(struct ftdi_device_list *devlist)
Definition: ftdi.c:378
ftdi_usb_purge_tx_buffer
int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
Definition: ftdi.c:1046
ftdi_eeprom::external_oscillator
int external_oscillator
Definition: ftdi_i.h:102
SIO_SET_EVENT_CHAR_REQUEST
#define SIO_SET_EVENT_CHAR_REQUEST
Definition: ftdi.h:164
ftdi_read_eeprom_location
int ftdi_read_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
Definition: ftdi.c:4300
ftdi_eeprom::clock_polarity
int clock_polarity
Definition: ftdi_i.h:124
ftdi_deinit
void ftdi_deinit(struct ftdi_context *ftdi)
Definition: ftdi.c:210
HIGH_CURRENT_DRIVE
#define HIGH_CURRENT_DRIVE
Definition: ftdi.h:422
ftdi_set_usbdev
void ftdi_set_usbdev(struct ftdi_context *ftdi, libusb_device_handle *usb)
Definition: ftdi.c:268
ftdi_eeprom::remote_wakeup
int remote_wakeup
Definition: ftdi_i.h:44
SIO_READ_PINS_REQUEST
#define SIO_READ_PINS_REQUEST
Definition: ftdi.h:169
SIO_RESET_REQUEST
#define SIO_RESET_REQUEST
Definition: ftdi.h:158
ftdi_eeprom_value
ftdi_eeprom_value
Definition: ftdi.h:279
ftdi_interface
ftdi_interface
Definition: ftdi.h:74
ftdi_usb_open_desc_index
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:755
SUSPEND_DBUS7_BIT
#define SUSPEND_DBUS7_BIT
Definition: ftdi.h:419
FTDI_MINOR_VERSION
#define FTDI_MINOR_VERSION
Definition: ftdi_version_i.h:5
BREAK_ON
Definition: ftdi.h:56
set_ft232h_cbus
void set_ft232h_cbus(struct ftdi_eeprom *eeprom, unsigned char *output)
Definition: ftdi.c:2705
SIO_SET_BAUDRATE_REQUEST
#define SIO_SET_BAUDRATE_REQUEST
Definition: ftdi.h:159
ftdi_transfer_control::transfer
struct libusb_transfer * transfer
Definition: ftdi.h:213
DRIVE_16MA
#define DRIVE_16MA
Definition: ftdi.h:409
ftdi_eeprom::channel_b_driver
int channel_b_driver
Definition: ftdi_i.h:81
ftdi_set_baudrate
int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
Definition: ftdi.c:1349
FTDI_MAJOR_VERSION
#define FTDI_MAJOR_VERSION
Definition: ftdi_version_i.h:4
SIO_SET_DATA_REQUEST
#define SIO_SET_DATA_REQUEST
Definition: ftdi.h:160
ftdi_write_data
int ftdi_write_data(struct ftdi_context *ftdi, const unsigned char *buf, int size)
Definition: ftdi.c:1484
SIO_WRITE_EEPROM_REQUEST
#define SIO_WRITE_EEPROM_REQUEST
Definition: ftdi.h:171
ftdi_eeprom::group3_drive
int group3_drive
Definition: ftdi_i.h:118
ftdi_context
Main context structure for all libftdi functions.
Definition: ftdi.h:221
ftdi_eeprom::channel_c_driver
int channel_c_driver
Definition: ftdi_i.h:82
ftdi_version_info::version_str
const char * version_str
Definition: ftdi.h:460
ftdi_eeprom::group3_schmitt
int group3_schmitt
Definition: ftdi_i.h:119
ftdi_set_event_char
int ftdi_set_event_char(struct ftdi_context *ftdi, unsigned char eventch, unsigned char enable)
Definition: ftdi.c:2393
DRIVER_VCP
#define DRIVER_VCP
Definition: ftdi.h:414
ftdi_eeprom::max_power
int max_power
Definition: ftdi_i.h:65
TYPE_R
Definition: ftdi.h:43
MAX_POWER_MILLIAMP_PER_UNIT
#define MAX_POWER_MILLIAMP_PER_UNIT
Definition: ftdi_i.h:25
ftdi_eeprom::group1_schmitt
int group1_schmitt
Definition: ftdi_i.h:113
ftdi_eeprom::user_data_size
int user_data_size
Definition: ftdi_i.h:130
ftdi_version_i.h
ftdi_set_bitmode
int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
Definition: ftdi.c:2091
ftdi_list_free
void ftdi_list_free(struct ftdi_device_list **devlist)
Definition: ftdi.c:358
ftdi_context::type
enum ftdi_chip_type type
Definition: ftdi.h:235
ftdi_eeprom::serial
char * serial
Definition: ftdi_i.h:72
CHANNEL_IS_UART
#define CHANNEL_IS_UART
Definition: ftdi.h:398
FTDI_DEVICE_IN_REQTYPE
#define FTDI_DEVICE_IN_REQTYPE
Definition: ftdi.h:155
ftdi_set_line_property
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:1395
ftdi_eeprom::channel_b_rs485enable
int channel_b_rs485enable
Definition: ftdi_i.h:86
ftdi_eeprom::cbus_function
int cbus_function[10]
Definition: ftdi_i.h:92
ftdi_context::error_str
const char * error_str
Definition: ftdi.h:270
ftdi_usb_purge_rx_buffer
int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
Definition: ftdi.c:1020
DRIVER_VCPH
#define DRIVER_VCPH
Definition: ftdi.h:415
ftdi_new
struct ftdi_context * ftdi_new(void)
Definition: ftdi.c:128
ftdi_version_info::major
int major
Definition: ftdi.h:457
ftdi_erase_eeprom
int ftdi_erase_eeprom(struct ftdi_context *ftdi)
Definition: ftdi.c:4532
TYPE_230X
Definition: ftdi.h:47
TYPE_BM
Definition: ftdi.h:41
ftdi_set_eeprom_user_data
int ftdi_set_eeprom_user_data(struct ftdi_context *ftdi, const char *buf, int size)
Definition: ftdi.c:4279
ftdi_set_interface
int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
Definition: ftdi.c:157
C_CLK
#define C_CLK
ftdi_eeprom_initdefaults
int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char *manufacturer, char *product, char *serial)
Definition: ftdi.c:2452
ftdi_transfer_data_done
int ftdi_transfer_data_done(struct ftdi_transfer_control *tc)
Definition: ftdi.c:1785
ftdi_eeprom::size
int size
Definition: ftdi_i.h:135
ftdi_context::readbuffer_remaining
unsigned int readbuffer_remaining
Definition: ftdi.h:245
ftdi_version_info::micro
int micro
Definition: ftdi.h:459
ftdi_eeprom::group0_slew
int group0_slew
Definition: ftdi_i.h:111
ftdi_set_error_char
int ftdi_set_error_char(struct ftdi_context *ftdi, unsigned char errorch, unsigned char enable)
Definition: ftdi.c:2422
USE_SERIAL_NUM
#define USE_SERIAL_NUM
Definition: ftdi.h:356
ftdi_eeprom_decode
int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose)
Definition: ftdi.c:3411
ftdi_eeprom::vendor_id
int vendor_id
Definition: ftdi_i.h:33
ftdi_eeprom::in_is_isochronous
int in_is_isochronous
Definition: ftdi_i.h:52
ftdi_transfer_control::offset
int offset
Definition: ftdi.h:211
ftdi_context::out_ep
int out_ep
Definition: ftdi.h:261
CHANNEL_IS_FIFO
#define CHANNEL_IS_FIFO
Definition: ftdi.h:399
ftdi_device_list::dev
struct libusb_device * dev
Definition: ftdi.h:349
ftdi_get_eeprom_value
int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int *value)
Definition: ftdi.c:3841
ftdi_eeprom::chip
int chip
Definition: ftdi_i.h:137
SIO_GET_LATENCY_TIMER_REQUEST
#define SIO_GET_LATENCY_TIMER_REQUEST
Definition: ftdi.h:167
ftdi_eeprom::initialized_for_connected_device
int initialized_for_connected_device
Definition: ftdi_i.h:39
ftdi_bits_type
ftdi_bits_type
Definition: ftdi.h:54
FTDI_MICRO_VERSION
#define FTDI_MICRO_VERSION
Definition: ftdi_version_i.h:6
TYPE_232H
Definition: ftdi.h:46
ftdi_eeprom::high_current_b
int high_current_b
Definition: ftdi_i.h:98
FT1284_FLOW_CONTROL
#define FT1284_FLOW_CONTROL
Definition: ftdi.h:353
ftdi_eeprom::channel_c_rs485enable
int channel_c_rs485enable
Definition: ftdi_i.h:87
ftdi_init
int ftdi_init(struct ftdi_context *ftdi)
Definition: ftdi.c:88
ftdi_eeprom::group0_schmitt
int group0_schmitt
Definition: ftdi_i.h:110
ftdi_eeprom::flow_control
int flow_control
Definition: ftdi_i.h:126
ftdi_context::readbuffer
unsigned char * readbuffer
Definition: ftdi.h:241
USE_USB_VERSION_BIT
#define USE_USB_VERSION_BIT
Definition: ftdi.h:417
ftdi_eeprom::user_data
const char * user_data
Definition: ftdi_i.h:131
ftdi_read_data_submit
struct ftdi_transfer_control * ftdi_read_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
Definition: ftdi.c:1706
ftdi_context::usb_ctx
struct libusb_context * usb_ctx
Definition: ftdi.h:225
ftdi_eeprom::buf
unsigned char buf[FTDI_MAX_EEPROM_SIZE]
Definition: ftdi_i.h:138
ftdi_context::usb_write_timeout
int usb_write_timeout
Definition: ftdi.h:231
ftdi_eeprom::suspend_dbus7
int suspend_dbus7
Definition: ftdi_i.h:49
ftdi_context::writebuffer_chunksize
unsigned int writebuffer_chunksize
Definition: ftdi.h:249
CHANNEL_IS_RS485
#define CHANNEL_IS_RS485
Definition: ftdi.h:404
TYPE_AM
Definition: ftdi.h:40
SIO_READ_EEPROM_REQUEST
#define SIO_READ_EEPROM_REQUEST
Definition: ftdi.h:170
ODD
Definition: ftdi.h:50
ftdi_poll_modem_status
int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
Definition: ftdi.c:2247
ftdi_eeprom::user_data_addr
int user_data_addr
Definition: ftdi_i.h:129
FTDI_MAX_EEPROM_SIZE
#define FTDI_MAX_EEPROM_SIZE
Definition: ftdi_i.h:22
ftdi_eeprom::group1_drive
int group1_drive
Definition: ftdi_i.h:112
ftdi_context::usb_read_timeout
int usb_read_timeout
Definition: ftdi.h:229
ftdi_context::index
int index
Definition: ftdi.h:257
ftdi_eeprom::channel_d_driver
int channel_d_driver
Definition: ftdi_i.h:83
ftdi_setdtr_rts
int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
Definition: ftdi.c:2357
ftdi_context::in_ep
int in_ep
Definition: ftdi.h:260
HIGH_CURRENT_DRIVE_R
#define HIGH_CURRENT_DRIVE_R
Definition: ftdi.h:423
IS_SCHMITT
#define IS_SCHMITT
Definition: ftdi.h:411
SIO_SET_FLOW_CTRL_REQUEST
#define SIO_SET_FLOW_CTRL_REQUEST
Definition: ftdi.h:161
ftdi_eeprom::high_current_a
int high_current_a
Definition: ftdi_i.h:96
FT1284_DATA_LSB
#define FT1284_DATA_LSB
Definition: ftdi.h:352
ftdi_eeprom::manufacturer
char * manufacturer
Definition: ftdi_i.h:68
SIO_SET_BITMODE_REQUEST
#define SIO_SET_BITMODE_REQUEST
Definition: ftdi.h:168
ftdi_set_eeprom_buf
int ftdi_set_eeprom_buf(struct ftdi_context *ftdi, const unsigned char *buf, int size)
Definition: ftdi.c:4256
SIO_SET_ERROR_CHAR_REQUEST
#define SIO_SET_ERROR_CHAR_REQUEST
Definition: ftdi.h:165
ftdi_write_data_set_chunksize
int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
Definition: ftdi.c:1866
ftdi_eeprom::channel_b_type
int channel_b_type
Definition: ftdi_i.h:78
ftdi_context::bitbang_mode
unsigned char bitbang_mode
Definition: ftdi.h:264
CHANNEL_IS_CPU
#define CHANNEL_IS_CPU
Definition: ftdi.h:401
ftdi_usb_open_dev
int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev)
Definition: ftdi.c:585
ftdi_transfer_control::ftdi
struct ftdi_context * ftdi
Definition: ftdi.h:212
ftdi_set_eeprom_value
int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int value)
Definition: ftdi.c:4034
SPACE
Definition: ftdi.h:50
ftdi_eeprom::group0_drive
int group0_drive
Definition: ftdi_i.h:109
ftdi_eeprom::group2_slew
int group2_slew
Definition: ftdi_i.h:117
ftdi_eeprom::suspend_pull_downs
int suspend_pull_downs
Definition: ftdi_i.h:56
ftdi_version_info::snapshot_str
const char * snapshot_str
Definition: ftdi.h:461
POWER_SAVE_DISABLE_H
#define POWER_SAVE_DISABLE_H
Definition: ftdi.h:354
ftdi_eeprom::product_id
int product_id
Definition: ftdi_i.h:35
SIO_SET_MODEM_CTRL_REQUEST
#define SIO_SET_MODEM_CTRL_REQUEST
Definition: ftdi.h:162
SIO_POLL_MODEM_STATUS_REQUEST
#define SIO_POLL_MODEM_STATUS_REQUEST
Definition: ftdi.h:163
EVEN
Definition: ftdi.h:50
ftdi_transfer_control::size
int size
Definition: ftdi.h:210
ftdi_setflowctrl
int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
Definition: ftdi.c:2273
ftdi_usb_open_desc
int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product, const char *description, const char *serial)
Definition: ftdi.c:724
ftdi_eeprom::product
char * product
Definition: ftdi_i.h:70
ftdi_eeprom::invert
int invert
Definition: ftdi_i.h:100
MARK
Definition: ftdi.h:50
ftdi_get_error_string
const char * ftdi_get_error_string(struct ftdi_context *ftdi)
Definition: ftdi.c:4594
ftdi_context::usb_dev
struct libusb_device_handle * usb_dev
Definition: ftdi.h:227
ftdi_context::interface
int interface
Definition: ftdi.h:255
ftdi_break_type
ftdi_break_type
Definition: ftdi.h:56
ftdi_version_info
Definition: ftdi.h:455
ftdi_usb_close
int ftdi_usb_close(struct ftdi_context *ftdi)
Definition: ftdi.c:1098
ftdi_eeprom::channel_d_rs485enable
int channel_d_rs485enable
Definition: ftdi_i.h:88
ftdi_context::max_packet_size
unsigned int max_packet_size
Definition: ftdi.h:251
ftdi_setrts
int ftdi_setrts(struct ftdi_context *ftdi, int state)
Definition: ftdi.c:2326
ftdi_usb_reset
int ftdi_usb_reset(struct ftdi_context *ftdi)
Definition: ftdi.c:994
ftdi_get_latency_timer
int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
Definition: ftdi.c:2193
ftdi_usb_get_strings
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:409
ftdi_eeprom::channel_a_type
int channel_a_type
Definition: ftdi_i.h:77
ftdi_parity_type
ftdi_parity_type
Definition: ftdi.h:50
ftdi_usb_get_strings2
int ftdi_usb_get_strings2(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:466
ftdi_eeprom::use_serial
int use_serial
Definition: ftdi_i.h:59
ftdi_eeprom::group2_schmitt
int group2_schmitt
Definition: ftdi_i.h:116
ftdi_transfer_control::buf
unsigned char * buf
Definition: ftdi.h:209
ftdi_get_library_version
struct ftdi_version_info ftdi_get_library_version(void)
Get libftdi library version.
Definition: ftdi.c:281
ftdi_read_data_set_chunksize
int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
Definition: ftdi.c:2033
SIO_RESET_PURGE_RX
#define SIO_RESET_PURGE_RX
Definition: ftdi.h:176
ftdi_eeprom::data_order
int data_order
Definition: ftdi_i.h:125
ftdi_write_data_get_chunksize
int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
Definition: ftdi.c:1884
SIO_SET_DTR_HIGH
#define SIO_SET_DTR_HIGH
Definition: ftdi.h:185
SIO_RESET_SIO
#define SIO_RESET_SIO
Definition: ftdi.h:175
ftdi_context::bitbang_enabled
unsigned char bitbang_enabled
Definition: ftdi.h:239
ftdi_eeprom::channel_a_rs485enable
int channel_a_rs485enable
Definition: ftdi_i.h:85
ftdi_write_eeprom
int ftdi_write_eeprom(struct ftdi_context *ftdi)
Definition: ftdi.c:4477
ftdi_usb_open_string
int ftdi_usb_open_string(struct ftdi_context *ftdi, const char *description)
Definition: ftdi.c:901
ftdi_disable_bitbang
int ftdi_disable_bitbang(struct ftdi_context *ftdi)
Definition: ftdi.c:2117
ftdi_eeprom::self_powered
int self_powered
Definition: ftdi_i.h:42
ftdi_setdtr
int ftdi_setdtr(struct ftdi_context *ftdi, int state)
Definition: ftdi.c:2296
ftdi_set_latency_timer
int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
Definition: ftdi.c:2166
ftdi_stopbits_type
ftdi_stopbits_type
Definition: ftdi.h:52
ftdi_eeprom
FTDI eeprom structure.
Definition: ftdi_i.h:30
CHANNEL_IS_OPTO
#define CHANNEL_IS_OPTO
Definition: ftdi.h:400
SIO_RESET_PURGE_TX
#define SIO_RESET_PURGE_TX
Definition: ftdi.h:177
ftdi_eeprom::high_current
int high_current
Definition: ftdi_i.h:94
ftdi_context::readbuffer_chunksize
unsigned int readbuffer_chunksize
Definition: ftdi.h:247
ftdi_eeprom::channel_a_driver
int channel_a_driver
Definition: ftdi_i.h:80
ftdi_read_eeprom
int ftdi_read_eeprom(struct ftdi_context *ftdi)
Definition: ftdi.c:4324
ftdi_context::baudrate
int baudrate
Definition: ftdi.h:237
SIO_ERASE_EEPROM_REQUEST
#define SIO_ERASE_EEPROM_REQUEST
Definition: ftdi.h:172
ftdi_usb_open_bus_addr
int ftdi_usb_open_bus_addr(struct ftdi_context *ftdi, uint8_t bus, uint8_t addr)
Definition: ftdi.c:848
ftdi_eeprom_build
int ftdi_eeprom_build(struct ftdi_context *ftdi)
Definition: ftdi.c:2783
ftdi_i.h
INVERT
Definition: ftdi.h:311
ftdi_eeprom::release_number
int release_number
Definition: ftdi_i.h:141
ftdi_usb_purge_buffers
int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
Definition: ftdi.c:1069
ftdi_read_data
int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
Definition: ftdi.c:1908
ftdi_write_eeprom_location
int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short eeprom_val)
Definition: ftdi.c:4421
ftdi_error_return_free_device_list
#define ftdi_error_return_free_device_list(code, str, devs)
Definition: ftdi.c:49
ftdi_get_eeprom_buf
int ftdi_get_eeprom_buf(struct ftdi_context *ftdi, unsigned char *buf, int size)
Definition: ftdi.c:4230
ftdi_eeprom::group3_slew
int group3_slew
Definition: ftdi_i.h:120
H_CLK
#define H_CLK
BREAK_OFF
Definition: ftdi.h:56
ftdi_error_return
#define ftdi_error_return(code, str)
Definition: ftdi.c:41
ftdi_context::readbuffer_offset
unsigned int readbuffer_offset
Definition: ftdi.h:243
ftdi_eeprom::group1_slew
int group1_slew
Definition: ftdi_i.h:114
ftdi_free
void ftdi_free(struct ftdi_context *ftdi)
Definition: ftdi.c:256
ftdi_read_chipid
int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
Definition: ftdi.c:4383
ftdi_eeprom::group2_drive
int group2_drive
Definition: ftdi_i.h:115
ftdi_usb_find_all
int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
Definition: ftdi.c:310
SIO_SET_RTS_HIGH
#define SIO_SET_RTS_HIGH
Definition: ftdi.h:188
SIO_SET_RTS_LOW
#define SIO_SET_RTS_LOW
Definition: ftdi.h:189
MAGIC
#define MAGIC
Definition: ftdi.c:4531
ftdi_set_line_property2
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:1414
FTDI_VERSION_STRING
const char FTDI_VERSION_STRING[]
Definition: ftdi_version_i.h:8
ftdi_eeprom::is_not_pnp
int is_not_pnp
Definition: ftdi_i.h:46
FTDI_SNAPSHOT_VERSION
const char FTDI_SNAPSHOT_VERSION[]
Definition: ftdi_version_i.h:9
SIO_SET_DTR_LOW
#define SIO_SET_DTR_LOW
Definition: ftdi.h:186
ftdi_context::eeprom
struct ftdi_eeprom * eeprom
Definition: ftdi.h:267
ftdi_eeprom::use_usb_version
int use_usb_version
Definition: ftdi_i.h:63
ftdi_transfer_control
Definition: ftdi.h:206
Generated on Wed Jan 10 2018 21:59:42 for libftdi1 by   doxygen 1.8.8