developer.intra2net.com Git - libftdi/blob - src/ftdi.c

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