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