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 != 0 && product != 0) &&
 332                 desc.idVendor == vendor && desc.idProduct == product) ||
 333                 ((vendor == 0 && product == 0) &&
 334                  (desc.idVendor == 0x403) && (desc.idProduct == 0x6001 || desc.idProduct == 0x6010
 335                                               || desc.idProduct == 0x6011 || desc.idProduct == 0x6014)))
 336         {
 337             *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
 338             if (!*curdev)
 339                 ftdi_error_return_free_device_list(-3, "out of memory", devs);
 340
 341             (*curdev)->next = NULL;
 342             (*curdev)->dev = dev;
 343             libusb_ref_device(dev);
 344             curdev = &(*curdev)->next;
 345             count++;
 346         }
 347     }
 348     libusb_free_device_list(devs,1);
 349     return count;
 350 }
 351
 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 (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     divisor = 24000000 / baudrate;
1022     int i;
1023
1024     // Round down to supported fraction (AM only)
1025     divisor -= am_adjust_dn[divisor & 7];
1026
1027     // Try this divisor and the one above it (because division rounds down)
1028     best_divisor = 0;
1029     best_baud = 0;
1030     best_baud_diff = 0;
1031     for (i = 0; i < 2; i++)
1032     {
1033         int try_divisor = divisor + i;
1034         int baud_estimate;
1035         int baud_diff;
1036
1037         // Round up to supported divisor value
1038         if (try_divisor <= 8)
1039         {
1040             // Round up to minimum supported divisor
1041             try_divisor = 8;
1042         }
1043         else if (divisor < 16)
1044         {
1045             // AM doesn't support divisors 9 through 15 inclusive
1046             try_divisor = 16;
1047         }
1048         else
1049         {
1050             // Round up to supported fraction (AM only)
1051             try_divisor += am_adjust_up[try_divisor & 7];
1052             if (try_divisor > 0x1FFF8)
1053             {
1054                 // Round down to maximum supported divisor value (for AM)
1055                 try_divisor = 0x1FFF8;
1056             }
1057         }
1058         // Get estimated baud rate (to nearest integer)
1059         baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
1060         // Get absolute difference from requested baud rate
1061         if (baud_estimate < baudrate)
1062         {
1063             baud_diff = baudrate - baud_estimate;
1064         }
1065         else
1066         {
1067             baud_diff = baud_estimate - baudrate;
1068         }
1069         if (i == 0 || baud_diff < best_baud_diff)
1070         {
1071             // Closest to requested baud rate so far
1072             best_divisor = try_divisor;
1073             best_baud = baud_estimate;
1074             best_baud_diff = baud_diff;
1075             if (baud_diff == 0)
1076             {
1077                 // Spot on! No point trying
1078                 break;
1079             }
1080         }
1081     }
1082     // Encode the best divisor value
1083     *encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
1084     // Deal with special cases for encoded value
1085     if (*encoded_divisor == 1)
1086     {
1087         *encoded_divisor = 0;    // 3000000 baud
1088     }
1089     else if (*encoded_divisor == 0x4001)
1090     {
1091         *encoded_divisor = 1;    // 2000000 baud (BM only)
1092     }
1093     return best_baud;
1094 }
1095
1096 /*  ftdi_to_clkbits Convert a requested baudrate for a given system clock  and predivisor
1097                     to encoded divisor and the achievable baudrate
1098     Function is only used internally
1099     \internal
1100
1101     See AN120
1102    clk/1   -> 0
1103    clk/1.5 -> 1
1104    clk/2   -> 2
1105    From /2, 0.125 steps may be taken.
1106    The fractional part has frac_code encoding
1107
1108    value[13:0] of value is the divisor
1109    index[9] mean 12 MHz Base(120 MHz/10) rate versus 3 MHz (48 MHz/16) else
1110
1111    H Type have all features above with
1112    {index[8],value[15:14]} is the encoded subdivisor
1113
1114    FT232R, FT2232 and FT232BM have no option for 12 MHz and with
1115    {index[0],value[15:14]} is the encoded subdivisor
1116
1117    AM Type chips have only four fractional subdivisors at value[15:14]
1118    for subdivisors 0, 0.5, 0.25, 0.125
1119 */
1120 static int ftdi_to_clkbits(int baudrate, unsigned int clk, int clk_div, unsigned long *encoded_divisor)
1121 {
1122     static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
1123     int best_baud = 0;
1124     int divisor, best_divisor;
1125     if (baudrate >=  clk/clk_div)
1126     {
1127         *encoded_divisor = 0;
1128         best_baud = clk/clk_div;
1129     }
1130     else if (baudrate >=  clk/(clk_div + clk_div/2))
1131     {
1132         *encoded_divisor = 1;
1133         best_baud = clk/(clk_div + clk_div/2);
1134     }
1135     else if (baudrate >=  clk/(2*clk_div))
1136     {
1137         *encoded_divisor = 2;
1138         best_baud = clk/(2*clk_div);
1139     }
1140     else
1141     {
1142         /* We divide by 16 to have 3 fractional bits and one bit for rounding */
1143         divisor = clk*16/clk_div / baudrate;
1144         if (divisor & 1) /* Decide if to round up or down*/
1145             best_divisor = divisor /2 +1;
1146         else
1147             best_divisor = divisor/2;
1148         if(best_divisor > 0x20000)
1149             best_divisor = 0x1ffff;
1150         best_baud = clk*16/clk_div/best_divisor;
1151         if (best_baud & 1) /* Decide if to round up or down*/
1152             best_baud = best_baud /2 +1;
1153         else
1154             best_baud = best_baud /2;
1155         *encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 0x7] << 14);
1156     }
1157     return best_baud;
1158 }
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 ftdi_read_data_cb(struct libusb_transfer *transfer)
1397 {
1398     struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1399     struct ftdi_context *ftdi = tc->ftdi;
1400     int packet_size, actual_length, num_of_chunks, chunk_remains, i, ret;
1401
1402     packet_size = ftdi->max_packet_size;
1403
1404     actual_length = transfer->actual_length;
1405
1406     if (actual_length > 2)
1407     {
1408         // skip FTDI status bytes.
1409         // Maybe stored in the future to enable modem use
1410         num_of_chunks = actual_length / packet_size;
1411         chunk_remains = actual_length % packet_size;
1412         //printf("actual_length = %X, num_of_chunks = %X, chunk_remains = %X, readbuffer_offset = %X\n", actual_length, num_of_chunks, chunk_remains, ftdi->readbuffer_offset);
1413
1414         ftdi->readbuffer_offset += 2;
1415         actual_length -= 2;
1416
1417         if (actual_length > packet_size - 2)
1418         {
1419             for (i = 1; i < num_of_chunks; i++)
1420                 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1421                          ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1422                          packet_size - 2);
1423             if (chunk_remains > 2)
1424             {
1425                 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1426                          ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1427                          chunk_remains-2);
1428                 actual_length -= 2*num_of_chunks;
1429             }
1430             else
1431                 actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1432         }
1433
1434         if (actual_length > 0)
1435         {
1436             // data still fits in buf?
1437             if (tc->offset + actual_length <= tc->size)
1438             {
1439                 memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, actual_length);
1440                 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1441                 tc->offset += actual_length;
1442
1443                 ftdi->readbuffer_offset = 0;
1444                 ftdi->readbuffer_remaining = 0;
1445
1446                 /* Did we read exactly the right amount of bytes? */
1447                 if (tc->offset == tc->size)
1448                 {
1449                     //printf("read_data exact rem %d offset %d\n",
1450                     //ftdi->readbuffer_remaining, offset);
1451                     tc->completed = 1;
1452                     return;
1453                 }
1454             }
1455             else
1456             {
1457                 // only copy part of the data or size <= readbuffer_chunksize
1458                 int part_size = tc->size - tc->offset;
1459                 memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, part_size);
1460                 tc->offset += part_size;
1461
1462                 ftdi->readbuffer_offset += part_size;
1463                 ftdi->readbuffer_remaining = actual_length - part_size;
1464
1465                 /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1466                 part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
1467                 tc->completed = 1;
1468                 return;
1469             }
1470         }
1471     }
1472     ret = libusb_submit_transfer (transfer);
1473     if (ret < 0)
1474         tc->completed = 1;
1475 }
1476
1477
1478 static void ftdi_write_data_cb(struct libusb_transfer *transfer)
1479 {
1480     struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1481     struct ftdi_context *ftdi = tc->ftdi;
1482
1483     tc->offset += transfer->actual_length;
1484
1485     if (tc->offset == tc->size)
1486     {
1487         tc->completed = 1;
1488     }
1489     else
1490     {
1491         int write_size = ftdi->writebuffer_chunksize;
1492         int ret;
1493
1494         if (tc->offset + write_size > tc->size)
1495             write_size = tc->size - tc->offset;
1496
1497         transfer->length = write_size;
1498         transfer->buffer = tc->buf + tc->offset;
1499         ret = libusb_submit_transfer (transfer);
1500         if (ret < 0)
1501             tc->completed = 1;
1502     }
1503 }
1504
1505
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             output[0x0c] = (0x01) | (0x3 << 4); /* DBUS drive 4mA, CBUS drive 16mA */
3063             for (j = 0; j <= 6; j++)
3064             {
3065                 output[0x1a + j] = eeprom->cbus_function[j];
3066             }
3067             break;
3068     }
3069
3070     // calculate checksum
3071     checksum = 0xAAAA;
3072
3073     for (i = 0; i < eeprom->size/2-1; i++)
3074     {
3075         if ((ftdi->type == TYPE_230X) && (i == 0x12))
3076         {
3077             /* FT230X has a user section in the MTP which is not part of the checksum */
3078             i = 0x40;
3079         }
3080         if ((ftdi->type == TYPE_230X) && (i >=  0x40) && (i < 0x50)) {
3081             uint16_t data;
3082             if (ftdi_read_eeprom_location(ftdi, i, &data)) {
3083                 fprintf(stderr, "Reading Factory Configuration Data failed\n");
3084                 i = 0x50;
3085             }
3086             value = data;
3087         }
3088         else {
3089             value = output[i*2];
3090             value += output[(i*2)+1] << 8;
3091         }
3092         checksum = value^checksum;
3093         checksum = (checksum << 1) | (checksum >> 15);
3094     }
3095
3096     output[eeprom->size-2] = checksum;
3097     output[eeprom->size-1] = checksum >> 8;
3098
3099     eeprom->initialized_for_connected_device = 1;
3100     return user_area_size;
3101 }
3102 /* Decode the encoded EEPROM field for the FTDI Mode into a value for the abstracted
3103  * EEPROM structure
3104  *
3105  * FTD2XX doesn't allow to set multiple bits in the interface mode bitfield, and so do we
3106  */
3107 static unsigned char bit2type(unsigned char bits)
3108 {
3109     switch (bits)
3110     {
3111         case   0: return CHANNEL_IS_UART;
3112         case   1: return CHANNEL_IS_FIFO;
3113         case   2: return CHANNEL_IS_OPTO;
3114         case   4: return CHANNEL_IS_CPU;
3115         case   8: return CHANNEL_IS_FT1284;
3116         default:
3117             fprintf(stderr," Unexpected value %d for Hardware Interface type\n",
3118                     bits);
3119     }
3120     return 0;
3121 }
3122 /**
3123    Decode binary EEPROM image into an ftdi_eeprom structure.
3124
3125    \param ftdi pointer to ftdi_context
3126    \param verbose Decode EEPROM on stdout
3127
3128    \retval 0: all fine
3129    \retval -1: something went wrong
3130
3131    FIXME: How to pass size? How to handle size field in ftdi_eeprom?
3132    FIXME: Strings are malloc'ed here and should be freed somewhere
3133 */
3134 int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose)
3135 {
3136     unsigned char i, j;
3137     unsigned short checksum, eeprom_checksum, value;
3138     unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
3139     int eeprom_size;
3140     struct ftdi_eeprom *eeprom;
3141     unsigned char *buf = NULL;
3142
3143     if (ftdi == NULL)
3144         ftdi_error_return(-1,"No context");
3145     if (ftdi->eeprom == NULL)
3146         ftdi_error_return(-1,"No eeprom structure");
3147
3148     eeprom = ftdi->eeprom;
3149     eeprom_size = eeprom->size;
3150     buf = ftdi->eeprom->buf;
3151
3152     // Addr 02: Vendor ID
3153     eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
3154
3155     // Addr 04: Product ID
3156     eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
3157
3158     // Addr 06: Device release number
3159     eeprom->release_number = buf[0x06] + (buf[0x07]<<8);
3160
3161     // Addr 08: Config descriptor
3162     // Bit 7: always 1
3163     // Bit 6: 1 if this device is self powered, 0 if bus powered
3164     // Bit 5: 1 if this device uses remote wakeup
3165     eeprom->self_powered = buf[0x08] & 0x40;
3166     eeprom->remote_wakeup = buf[0x08] & 0x20;
3167
3168     // Addr 09: Max power consumption: max power = value * 2 mA
3169     eeprom->max_power = MAX_POWER_MILLIAMP_PER_UNIT * buf[0x09];
3170
3171     // Addr 0A: Chip configuration
3172     // Bit 7: 0 - reserved
3173     // Bit 6: 0 - reserved
3174     // Bit 5: 0 - reserved
3175     // Bit 4: 1 - Change USB version on BM and 2232C
3176     // Bit 3: 1 - Use the serial number string
3177     // Bit 2: 1 - Enable suspend pull downs for lower power
3178     // Bit 1: 1 - Out EndPoint is Isochronous
3179     // Bit 0: 1 - In EndPoint is Isochronous
3180     //
3181     eeprom->in_is_isochronous  = buf[0x0A]&0x01;
3182     eeprom->out_is_isochronous = buf[0x0A]&0x02;
3183     eeprom->suspend_pull_downs = buf[0x0A]&0x04;
3184     eeprom->use_serial         = (buf[0x0A] & USE_SERIAL_NUM)?1:0;
3185     eeprom->use_usb_version    = buf[0x0A] & USE_USB_VERSION_BIT;
3186
3187     // Addr 0C: USB version low byte when 0x0A
3188     // Addr 0D: USB version high byte when 0x0A
3189     eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
3190
3191     // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
3192     // Addr 0F: Length of manufacturer string
3193     manufacturer_size = buf[0x0F]/2;
3194     if (eeprom->manufacturer)
3195         free(eeprom->manufacturer);
3196     if (manufacturer_size > 0)
3197     {
3198         eeprom->manufacturer = malloc(manufacturer_size);
3199         if (eeprom->manufacturer)
3200         {
3201             // Decode manufacturer
3202             i = buf[0x0E] & (eeprom_size -1); // offset
3203             for (j=0; j<manufacturer_size-1; j++)
3204             {
3205                 eeprom->manufacturer[j] = buf[2*j+i+2];
3206             }
3207             eeprom->manufacturer[j] = '\0';
3208         }
3209     }
3210     else eeprom->manufacturer = NULL;
3211
3212     // Addr 10: Offset of the product string + 0x80, calculated later
3213     // Addr 11: Length of product string
3214     if (eeprom->product)
3215         free(eeprom->product);
3216     product_size = buf[0x11]/2;
3217     if (product_size > 0)
3218     {
3219         eeprom->product = malloc(product_size);
3220         if (eeprom->product)
3221         {
3222             // Decode product name
3223             i = buf[0x10] & (eeprom_size -1); // offset
3224             for (j=0; j<product_size-1; j++)
3225             {
3226                 eeprom->product[j] = buf[2*j+i+2];
3227             }
3228             eeprom->product[j] = '\0';
3229         }
3230     }
3231     else eeprom->product = NULL;
3232
3233     // Addr 12: Offset of the serial string + 0x80, calculated later
3234     // Addr 13: Length of serial string
3235     if (eeprom->serial)
3236         free(eeprom->serial);
3237     serial_size = buf[0x13]/2;
3238     if (serial_size > 0)
3239     {
3240         eeprom->serial = malloc(serial_size);
3241         if (eeprom->serial)
3242         {
3243             // Decode serial
3244             i = buf[0x12] & (eeprom_size -1); // offset
3245             for (j=0; j<serial_size-1; j++)
3246             {
3247                 eeprom->serial[j] = buf[2*j+i+2];
3248             }
3249             eeprom->serial[j] = '\0';
3250         }
3251     }
3252     else eeprom->serial = NULL;
3253
3254     // verify checksum
3255     checksum = 0xAAAA;
3256
3257     for (i = 0; i < eeprom_size/2-1; i++)
3258     {
3259         if ((ftdi->type == TYPE_230X) && (i == 0x12))
3260         {
3261             /* FT230X has a user section in the MTP which is not part of the checksum */
3262             i = 0x40;
3263         }
3264         value = buf[i*2];
3265         value += buf[(i*2)+1] << 8;
3266
3267         checksum = value^checksum;
3268         checksum = (checksum << 1) | (checksum >> 15);
3269     }
3270
3271     eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
3272
3273     if (eeprom_checksum != checksum)
3274     {
3275         fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
3276         ftdi_error_return(-1,"EEPROM checksum error");
3277     }
3278
3279     eeprom->channel_a_type   = 0;
3280     if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM))
3281     {
3282         eeprom->chip = -1;
3283     }
3284     else if (ftdi->type == TYPE_2232C)
3285     {
3286         eeprom->channel_a_type   = bit2type(buf[0x00] & 0x7);
3287         eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
3288         eeprom->high_current_a   = buf[0x00] & HIGH_CURRENT_DRIVE;
3289         eeprom->channel_b_type   = buf[0x01] & 0x7;
3290         eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
3291         eeprom->high_current_b   = buf[0x01] & HIGH_CURRENT_DRIVE;
3292         eeprom->chip = buf[0x14];
3293     }
3294     else if (ftdi->type == TYPE_R)
3295     {
3296         /* TYPE_R flags D2XX, not VCP as all others*/
3297         eeprom->channel_a_driver = ~buf[0x00] & DRIVER_VCP;
3298         eeprom->high_current     = buf[0x00] & HIGH_CURRENT_DRIVE_R;
3299         if ( (buf[0x01]&0x40) != 0x40)
3300             fprintf(stderr,
3301                     "TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size."
3302                     " If this happened with the\n"
3303                     " EEPROM programmed by FTDI tools, please report "
3304                     "to libftdi@developer.intra2net.com\n");
3305
3306         eeprom->chip = buf[0x16];
3307         // Addr 0B: Invert data lines
3308         // Works only on FT232R, not FT245R, but no way to distinguish
3309         eeprom->invert = buf[0x0B];
3310         // Addr 14: CBUS function: CBUS0, CBUS1
3311         // Addr 15: CBUS function: CBUS2, CBUS3
3312         // Addr 16: CBUS function: CBUS5
3313         eeprom->cbus_function[0] = buf[0x14] & 0x0f;
3314         eeprom->cbus_function[1] = (buf[0x14] >> 4) & 0x0f;
3315         eeprom->cbus_function[2] = buf[0x15] & 0x0f;
3316         eeprom->cbus_function[3] = (buf[0x15] >> 4) & 0x0f;
3317         eeprom->cbus_function[4] = buf[0x16] & 0x0f;
3318     }
3319     else if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
3320     {
3321         eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
3322         eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
3323
3324         if (ftdi->type == TYPE_2232H)
3325         {
3326             eeprom->channel_a_type   = bit2type(buf[0x00] & 0x7);
3327             eeprom->channel_b_type   = bit2type(buf[0x01] & 0x7);
3328             eeprom->suspend_dbus7    = buf[0x01] & SUSPEND_DBUS7_BIT;
3329         }
3330         else
3331         {
3332             eeprom->channel_c_driver = (buf[0x00] >> 4) & DRIVER_VCP;
3333             eeprom->channel_d_driver = (buf[0x01] >> 4) & DRIVER_VCP;
3334             eeprom->channel_a_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 0);
3335             eeprom->channel_b_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 1);
3336             eeprom->channel_c_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 2);
3337             eeprom->channel_d_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 3);
3338         }
3339
3340         eeprom->chip = buf[0x18];
3341         eeprom->group0_drive   =  buf[0x0c]       & DRIVE_16MA;
3342         eeprom->group0_schmitt =  buf[0x0c]       & IS_SCHMITT;
3343         eeprom->group0_slew    =  buf[0x0c]       & SLOW_SLEW;
3344         eeprom->group1_drive   = (buf[0x0c] >> 4) & 0x3;
3345         eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT;
3346         eeprom->group1_slew    = (buf[0x0c] >> 4) & SLOW_SLEW;
3347         eeprom->group2_drive   =  buf[0x0d]       & DRIVE_16MA;
3348         eeprom->group2_schmitt =  buf[0x0d]       & IS_SCHMITT;
3349         eeprom->group2_slew    =  buf[0x0d]       & SLOW_SLEW;
3350         eeprom->group3_drive   = (buf[0x0d] >> 4) & DRIVE_16MA;
3351         eeprom->group3_schmitt = (buf[0x0d] >> 4) & IS_SCHMITT;
3352         eeprom->group3_slew    = (buf[0x0d] >> 4) & SLOW_SLEW;
3353     }
3354     else if (ftdi->type == TYPE_232H)
3355     {
3356         int i;
3357
3358         eeprom->channel_a_type   = buf[0x00] & 0xf;
3359         eeprom->channel_a_driver = (buf[0x00] & DRIVER_VCPH)?DRIVER_VCP:0;
3360         eeprom->clock_polarity =  buf[0x01]       & FT1284_CLK_IDLE_STATE;
3361         eeprom->data_order     =  buf[0x01]       & FT1284_DATA_LSB;
3362         eeprom->flow_control   =  buf[0x01]       & FT1284_FLOW_CONTROL;
3363         eeprom->powersave      =  buf[0x01]       & POWER_SAVE_DISABLE_H;
3364         eeprom->group0_drive   =  buf[0x0c]       & DRIVE_16MA;
3365         eeprom->group0_schmitt =  buf[0x0c]       & IS_SCHMITT;
3366         eeprom->group0_slew    =  buf[0x0c]       & SLOW_SLEW;
3367         eeprom->group1_drive   =  buf[0x0d]       & DRIVE_16MA;
3368         eeprom->group1_schmitt =  buf[0x0d]       & IS_SCHMITT;
3369         eeprom->group1_slew    =  buf[0x0d]       & SLOW_SLEW;
3370
3371         for(i=0; i<5; i++)
3372         {
3373             eeprom->cbus_function[2*i  ] =  buf[0x18+i] & 0x0f;
3374             eeprom->cbus_function[2*i+1] = (buf[0x18+i] >> 4) & 0x0f;
3375         }
3376         eeprom->chip = buf[0x1e];
3377         /*FIXME: Decipher more values*/
3378     }
3379     else if (ftdi->type == TYPE_230X)
3380     {
3381         for(i=0; i<4; i++)
3382         {
3383             eeprom->cbus_function[i] =  buf[0x1a + i] & 0xFF;
3384         }
3385         eeprom->group0_drive   =  buf[0x0c]       & 0x03;
3386         eeprom->group0_schmitt =  buf[0x0c]       & IS_SCHMITT;
3387         eeprom->group0_slew    =  buf[0x0c]       & SLOW_SLEW;
3388         eeprom->group1_drive   = (buf[0x0c] >> 4) & 0x03;
3389         eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT;
3390         eeprom->group1_slew    = (buf[0x0c] >> 4) & SLOW_SLEW;
3391     }
3392
3393     if (verbose)
3394     {
3395         char *channel_mode[] = {"UART", "FIFO", "CPU", "OPTO", "FT1284"};
3396         fprintf(stdout, "VID:     0x%04x\n",eeprom->vendor_id);
3397         fprintf(stdout, "PID:     0x%04x\n",eeprom->product_id);
3398         fprintf(stdout, "Release: 0x%04x\n",eeprom->release_number);
3399
3400         if (eeprom->self_powered)
3401             fprintf(stdout, "Self-Powered%s", (eeprom->remote_wakeup)?", USB Remote Wake Up\n":"\n");
3402         else
3403             fprintf(stdout, "Bus Powered: %3d mA%s", eeprom->max_power,
3404                     (eeprom->remote_wakeup)?" USB Remote Wake Up\n":"\n");
3405         if (eeprom->manufacturer)
3406             fprintf(stdout, "Manufacturer: %s\n",eeprom->manufacturer);
3407         if (eeprom->product)
3408             fprintf(stdout, "Product:      %s\n",eeprom->product);
3409         if (eeprom->serial)
3410             fprintf(stdout, "Serial:       %s\n",eeprom->serial);
3411         fprintf(stdout,     "Checksum      : %04x\n", checksum);
3412         if (ftdi->type == TYPE_R)
3413             fprintf(stdout,     "Internal EEPROM\n");
3414         else if (eeprom->chip >= 0x46)
3415             fprintf(stdout,     "Attached EEPROM: 93x%02x\n", eeprom->chip);
3416         if (eeprom->suspend_dbus7)
3417             fprintf(stdout, "Suspend on DBUS7\n");
3418         if (eeprom->suspend_pull_downs)
3419             fprintf(stdout, "Pull IO pins low during suspend\n");
3420         if(eeprom->powersave)
3421         {
3422             if(ftdi->type >= TYPE_232H)
3423                 fprintf(stdout,"Enter low power state on ACBUS7\n");
3424         }
3425         if (eeprom->remote_wakeup)
3426             fprintf(stdout, "Enable Remote Wake Up\n");
3427         fprintf(stdout, "PNP: %d\n",(eeprom->is_not_pnp)?0:1);
3428         if (ftdi->type >= TYPE_2232C)
3429             fprintf(stdout,"Channel A has Mode %s%s%s\n",
3430                     channel_mode[eeprom->channel_a_type],
3431                     (eeprom->channel_a_driver)?" VCP":"",
3432                     (eeprom->high_current_a)?" High Current IO":"");
3433         if (ftdi->type >= TYPE_232H)
3434         {
3435             fprintf(stdout,"FT1284 Mode Clock is idle %s, %s first, %sFlow Control\n",
3436                     (eeprom->clock_polarity)?"HIGH":"LOW",
3437                     (eeprom->data_order)?"LSB":"MSB",
3438                     (eeprom->flow_control)?"":"No ");
3439         }
3440         if ((ftdi->type >= TYPE_2232C) && (ftdi->type != TYPE_R) && (ftdi->type != TYPE_232H))
3441             fprintf(stdout,"Channel B has Mode %s%s%s\n",
3442                     channel_mode[eeprom->channel_b_type],
3443                     (eeprom->channel_b_driver)?" VCP":"",
3444                     (eeprom->high_current_b)?" High Current IO":"");
3445         if (((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C)) &&
3446                 eeprom->use_usb_version == USE_USB_VERSION_BIT)
3447             fprintf(stdout,"Use explicit USB Version %04x\n",eeprom->usb_version);
3448
3449         if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
3450         {
3451             fprintf(stdout,"%s has %d mA drive%s%s\n",
3452                     (ftdi->type == TYPE_2232H)?"AL":"A",
3453                     (eeprom->group0_drive+1) *4,
3454                     (eeprom->group0_schmitt)?" Schmitt Input":"",
3455                     (eeprom->group0_slew)?" Slow Slew":"");
3456             fprintf(stdout,"%s has %d mA drive%s%s\n",
3457                     (ftdi->type == TYPE_2232H)?"AH":"B",
3458                     (eeprom->group1_drive+1) *4,
3459                     (eeprom->group1_schmitt)?" Schmitt Input":"",
3460                     (eeprom->group1_slew)?" Slow Slew":"");
3461             fprintf(stdout,"%s has %d mA drive%s%s\n",
3462                     (ftdi->type == TYPE_2232H)?"BL":"C",
3463                     (eeprom->group2_drive+1) *4,
3464                     (eeprom->group2_schmitt)?" Schmitt Input":"",
3465                     (eeprom->group2_slew)?" Slow Slew":"");
3466             fprintf(stdout,"%s has %d mA drive%s%s\n",
3467                     (ftdi->type == TYPE_2232H)?"BH":"D",
3468                     (eeprom->group3_drive+1) *4,
3469                     (eeprom->group3_schmitt)?" Schmitt Input":"",
3470                     (eeprom->group3_slew)?" Slow Slew":"");
3471         }
3472         else if (ftdi->type == TYPE_232H)
3473         {
3474             int i;
3475             char *cbush_mux[] = {"TRISTATE","RXLED","TXLED", "TXRXLED","PWREN",
3476                                  "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN",
3477                                  "CLK30","CLK15","CLK7_5"
3478                                 };
3479             fprintf(stdout,"ACBUS has %d mA drive%s%s\n",
3480                     (eeprom->group0_drive+1) *4,
3481                     (eeprom->group0_schmitt)?" Schmitt Input":"",
3482                     (eeprom->group0_slew)?" Slow Slew":"");
3483             fprintf(stdout,"ADBUS has %d mA drive%s%s\n",
3484                     (eeprom->group1_drive+1) *4,
3485                     (eeprom->group1_schmitt)?" Schmitt Input":"",
3486                     (eeprom->group1_slew)?" Slow Slew":"");
3487             for (i=0; i<10; i++)
3488             {
3489                 if (eeprom->cbus_function[i]<= CBUSH_CLK7_5 )
3490                     fprintf(stdout,"C%d Function: %s\n", i,
3491                             cbush_mux[eeprom->cbus_function[i]]);
3492             }
3493         }
3494         else if (ftdi->type == TYPE_230X)
3495         {
3496             int i;
3497             char *cbush_mux[] = {"TRISTATE","RXLED","TXLED", "TXRXLED","PWREN",
3498                                  "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN",
3499                                  "CLK24","CLK12","CLK6","BAT_DETECT","BAT_DETECT#",
3500                                  "I2C_TXE#", "I2C_RXF#", "VBUS_SENSE", "BB_WR#",
3501                                  "BBRD#", "TIME_STAMP", "AWAKE#",
3502                                 };
3503             fprintf(stdout,"IOBUS has %d mA drive%s%s\n",
3504                     (eeprom->group0_drive+1) *4,
3505                     (eeprom->group0_schmitt)?" Schmitt Input":"",
3506                     (eeprom->group0_slew)?" Slow Slew":"");
3507             fprintf(stdout,"CBUS has %d mA drive%s%s\n",
3508                     (eeprom->group1_drive+1) *4,
3509                     (eeprom->group1_schmitt)?" Schmitt Input":"",
3510                     (eeprom->group1_slew)?" Slow Slew":"");
3511             for (i=0; i<4; i++)
3512             {
3513                 if (eeprom->cbus_function[i]<= CBUSH_AWAKE)
3514                     fprintf(stdout,"CBUS%d Function: %s\n", i, cbush_mux[eeprom->cbus_function[i]]);
3515             }
3516         }
3517
3518         if (ftdi->type == TYPE_R)
3519         {
3520             char *cbus_mux[] = {"TXDEN","PWREN","RXLED", "TXLED","TX+RXLED",
3521                                 "SLEEP","CLK48","CLK24","CLK12","CLK6",
3522                                 "IOMODE","BB_WR","BB_RD"
3523                                };
3524             char *cbus_BB[] = {"RXF","TXE","RD", "WR"};
3525
3526             if (eeprom->invert)
3527             {
3528                 char *r_bits[] = {"TXD","RXD","RTS", "CTS","DTR","DSR","DCD","RI"};
3529                 fprintf(stdout,"Inverted bits:");
3530                 for (i=0; i<8; i++)
3531                     if ((eeprom->invert & (1<<i)) == (1<<i))
3532                         fprintf(stdout," %s",r_bits[i]);
3533                 fprintf(stdout,"\n");
3534             }
3535             for (i=0; i<5; i++)
3536             {
3537                 if (eeprom->cbus_function[i]<CBUS_BB)
3538                     fprintf(stdout,"C%d Function: %s\n", i,
3539                             cbus_mux[eeprom->cbus_function[i]]);
3540                 else
3541                 {
3542                     if (i < 4)
3543                         /* Running MPROG show that C0..3 have fixed function Synchronous
3544                            Bit Bang mode */
3545                         fprintf(stdout,"C%d BB Function: %s\n", i,
3546                                 cbus_BB[i]);
3547                     else
3548                         fprintf(stdout, "Unknown CBUS mode. Might be special mode?\n");
3549                 }
3550             }
3551         }
3552     }
3553     return 0;
3554 }
3555
3556 /**
3557    Get a value from the decoded EEPROM structure
3558
3559    \param ftdi pointer to ftdi_context
3560    \param value_name Enum of the value to query
3561    \param value Pointer to store read value
3562
3563    \retval 0: all fine
3564    \retval -1: Value doesn't exist
3565 */
3566 int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int* value)
3567 {
3568     switch (value_name)
3569     {
3570         case VENDOR_ID:
3571             *value = ftdi->eeprom->vendor_id;
3572             break;
3573         case PRODUCT_ID:
3574             *value = ftdi->eeprom->product_id;
3575             break;
3576         case RELEASE_NUMBER:
3577             *value = ftdi->eeprom->release_number;
3578             break;
3579         case SELF_POWERED:
3580             *value = ftdi->eeprom->self_powered;
3581             break;
3582         case REMOTE_WAKEUP:
3583             *value = ftdi->eeprom->remote_wakeup;
3584             break;
3585         case IS_NOT_PNP:
3586             *value = ftdi->eeprom->is_not_pnp;
3587             break;
3588         case SUSPEND_DBUS7:
3589             *value = ftdi->eeprom->suspend_dbus7;
3590             break;
3591         case IN_IS_ISOCHRONOUS:
3592             *value = ftdi->eeprom->in_is_isochronous;
3593             break;
3594         case OUT_IS_ISOCHRONOUS:
3595             *value = ftdi->eeprom->out_is_isochronous;
3596             break;
3597         case SUSPEND_PULL_DOWNS:
3598             *value = ftdi->eeprom->suspend_pull_downs;
3599             break;
3600         case USE_SERIAL:
3601             *value = ftdi->eeprom->use_serial;
3602             break;
3603         case USB_VERSION:
3604             *value = ftdi->eeprom->usb_version;
3605             break;
3606         case USE_USB_VERSION:
3607             *value = ftdi->eeprom->use_usb_version;
3608             break;
3609         case MAX_POWER:
3610             *value = ftdi->eeprom->max_power;
3611             break;
3612         case CHANNEL_A_TYPE:
3613             *value = ftdi->eeprom->channel_a_type;
3614             break;
3615         case CHANNEL_B_TYPE:
3616             *value = ftdi->eeprom->channel_b_type;
3617             break;
3618         case CHANNEL_A_DRIVER:
3619             *value = ftdi->eeprom->channel_a_driver;
3620             break;
3621         case CHANNEL_B_DRIVER:
3622             *value = ftdi->eeprom->channel_b_driver;
3623             break;
3624         case CHANNEL_C_DRIVER:
3625             *value = ftdi->eeprom->channel_c_driver;
3626             break;
3627         case CHANNEL_D_DRIVER:
3628             *value = ftdi->eeprom->channel_d_driver;
3629             break;
3630         case CHANNEL_A_RS485:
3631             *value = ftdi->eeprom->channel_a_rs485enable;
3632             break;
3633         case CHANNEL_B_RS485:
3634             *value = ftdi->eeprom->channel_b_rs485enable;
3635             break;
3636         case CHANNEL_C_RS485:
3637             *value = ftdi->eeprom->channel_c_rs485enable;
3638             break;
3639         case CHANNEL_D_RS485:
3640             *value = ftdi->eeprom->channel_d_rs485enable;
3641             break;
3642         case CBUS_FUNCTION_0:
3643             *value = ftdi->eeprom->cbus_function[0];
3644             break;
3645         case CBUS_FUNCTION_1:
3646             *value = ftdi->eeprom->cbus_function[1];
3647             break;
3648         case CBUS_FUNCTION_2:
3649             *value = ftdi->eeprom->cbus_function[2];
3650             break;
3651         case CBUS_FUNCTION_3:
3652             *value = ftdi->eeprom->cbus_function[3];
3653             break;
3654         case CBUS_FUNCTION_4:
3655             *value = ftdi->eeprom->cbus_function[4];
3656             break;
3657         case CBUS_FUNCTION_5:
3658             *value = ftdi->eeprom->cbus_function[5];
3659             break;
3660         case CBUS_FUNCTION_6:
3661             *value = ftdi->eeprom->cbus_function[6];
3662             break;
3663         case CBUS_FUNCTION_7:
3664             *value = ftdi->eeprom->cbus_function[7];
3665             break;
3666         case CBUS_FUNCTION_8:
3667             *value = ftdi->eeprom->cbus_function[8];
3668             break;
3669         case CBUS_FUNCTION_9:
3670             *value = ftdi->eeprom->cbus_function[8];
3671             break;
3672         case HIGH_CURRENT:
3673             *value = ftdi->eeprom->high_current;
3674             break;
3675         case HIGH_CURRENT_A:
3676             *value = ftdi->eeprom->high_current_a;
3677             break;
3678         case HIGH_CURRENT_B:
3679             *value = ftdi->eeprom->high_current_b;
3680             break;
3681         case INVERT:
3682             *value = ftdi->eeprom->invert;
3683             break;
3684         case GROUP0_DRIVE:
3685             *value = ftdi->eeprom->group0_drive;
3686             break;
3687         case GROUP0_SCHMITT:
3688             *value = ftdi->eeprom->group0_schmitt;
3689             break;
3690         case GROUP0_SLEW:
3691             *value = ftdi->eeprom->group0_slew;
3692             break;
3693         case GROUP1_DRIVE:
3694             *value = ftdi->eeprom->group1_drive;
3695             break;
3696         case GROUP1_SCHMITT:
3697             *value = ftdi->eeprom->group1_schmitt;
3698             break;
3699         case GROUP1_SLEW:
3700             *value = ftdi->eeprom->group1_slew;
3701             break;
3702         case GROUP2_DRIVE:
3703             *value = ftdi->eeprom->group2_drive;
3704             break;
3705         case GROUP2_SCHMITT:
3706             *value = ftdi->eeprom->group2_schmitt;
3707             break;
3708         case GROUP2_SLEW:
3709             *value = ftdi->eeprom->group2_slew;
3710             break;
3711         case GROUP3_DRIVE:
3712             *value = ftdi->eeprom->group3_drive;
3713             break;
3714         case GROUP3_SCHMITT:
3715             *value = ftdi->eeprom->group3_schmitt;
3716             break;
3717         case GROUP3_SLEW:
3718             *value = ftdi->eeprom->group3_slew;
3719             break;
3720         case POWER_SAVE:
3721             *value = ftdi->eeprom->powersave;
3722             break;
3723         case CLOCK_POLARITY:
3724             *value = ftdi->eeprom->clock_polarity;
3725             break;
3726         case DATA_ORDER:
3727             *value = ftdi->eeprom->data_order;
3728             break;
3729         case FLOW_CONTROL:
3730             *value = ftdi->eeprom->flow_control;
3731             break;
3732         case CHIP_TYPE:
3733             *value = ftdi->eeprom->chip;
3734             break;
3735         case CHIP_SIZE:
3736             *value = ftdi->eeprom->size;
3737             break;
3738         default:
3739             ftdi_error_return(-1, "Request for unknown EEPROM value");
3740     }
3741     return 0;
3742 }
3743
3744 /**
3745    Set a value in the decoded EEPROM Structure
3746    No parameter checking is performed
3747
3748    \param ftdi pointer to ftdi_context
3749    \param value_name Enum of the value to set
3750    \param value to set
3751
3752    \retval 0: all fine
3753    \retval -1: Value doesn't exist
3754    \retval -2: Value not user settable
3755 */
3756 int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int value)
3757 {
3758     switch (value_name)
3759     {
3760         case VENDOR_ID:
3761             ftdi->eeprom->vendor_id = value;
3762             break;
3763         case PRODUCT_ID:
3764             ftdi->eeprom->product_id = value;
3765             break;
3766         case RELEASE_NUMBER:
3767             ftdi->eeprom->release_number = value;
3768             break;
3769         case SELF_POWERED:
3770             ftdi->eeprom->self_powered = value;
3771             break;
3772         case REMOTE_WAKEUP:
3773             ftdi->eeprom->remote_wakeup = value;
3774             break;
3775         case IS_NOT_PNP:
3776             ftdi->eeprom->is_not_pnp = value;
3777             break;
3778         case SUSPEND_DBUS7:
3779             ftdi->eeprom->suspend_dbus7 = value;
3780             break;
3781         case IN_IS_ISOCHRONOUS:
3782             ftdi->eeprom->in_is_isochronous = value;
3783             break;
3784         case OUT_IS_ISOCHRONOUS:
3785             ftdi->eeprom->out_is_isochronous = value;
3786             break;
3787         case SUSPEND_PULL_DOWNS:
3788             ftdi->eeprom->suspend_pull_downs = value;
3789             break;
3790         case USE_SERIAL:
3791             ftdi->eeprom->use_serial = value;
3792             break;
3793         case USB_VERSION:
3794             ftdi->eeprom->usb_version = value;
3795             break;
3796         case USE_USB_VERSION:
3797             ftdi->eeprom->use_usb_version = value;
3798             break;
3799         case MAX_POWER:
3800             ftdi->eeprom->max_power = value;
3801             break;
3802         case CHANNEL_A_TYPE:
3803             ftdi->eeprom->channel_a_type = value;
3804             break;
3805         case CHANNEL_B_TYPE:
3806             ftdi->eeprom->channel_b_type = value;
3807             break;
3808         case CHANNEL_A_DRIVER:
3809             ftdi->eeprom->channel_a_driver = value;
3810             break;
3811         case CHANNEL_B_DRIVER:
3812             ftdi->eeprom->channel_b_driver = value;
3813             break;
3814         case CHANNEL_C_DRIVER:
3815             ftdi->eeprom->channel_c_driver = value;
3816             break;
3817         case CHANNEL_D_DRIVER:
3818             ftdi->eeprom->channel_d_driver = value;
3819             break;
3820         case CHANNEL_A_RS485:
3821             ftdi->eeprom->channel_a_rs485enable = value;
3822             break;
3823         case CHANNEL_B_RS485:
3824             ftdi->eeprom->channel_b_rs485enable = value;
3825             break;
3826         case CHANNEL_C_RS485:
3827             ftdi->eeprom->channel_c_rs485enable = value;
3828             break;
3829         case CHANNEL_D_RS485:
3830             ftdi->eeprom->channel_d_rs485enable = value;
3831             break;
3832         case CBUS_FUNCTION_0:
3833             ftdi->eeprom->cbus_function[0] = value;
3834             break;
3835         case CBUS_FUNCTION_1:
3836             ftdi->eeprom->cbus_function[1] = value;
3837             break;
3838         case CBUS_FUNCTION_2:
3839             ftdi->eeprom->cbus_function[2] = value;
3840             break;
3841         case CBUS_FUNCTION_3:
3842             ftdi->eeprom->cbus_function[3] = value;
3843             break;
3844         case CBUS_FUNCTION_4:
3845             ftdi->eeprom->cbus_function[4] = value;
3846             break;
3847         case CBUS_FUNCTION_5:
3848             ftdi->eeprom->cbus_function[5] = value;
3849             break;
3850         case CBUS_FUNCTION_6:
3851             ftdi->eeprom->cbus_function[6] = value;
3852             break;
3853         case CBUS_FUNCTION_7:
3854             ftdi->eeprom->cbus_function[7] = value;
3855             break;
3856         case CBUS_FUNCTION_8:
3857             ftdi->eeprom->cbus_function[8] = value;
3858             break;
3859         case CBUS_FUNCTION_9:
3860             ftdi->eeprom->cbus_function[9] = value;
3861             break;
3862         case HIGH_CURRENT:
3863             ftdi->eeprom->high_current = value;
3864             break;
3865         case HIGH_CURRENT_A:
3866             ftdi->eeprom->high_current_a = value;
3867             break;
3868         case HIGH_CURRENT_B:
3869             ftdi->eeprom->high_current_b = value;
3870             break;
3871         case INVERT:
3872             ftdi->eeprom->invert = value;
3873             break;
3874         case GROUP0_DRIVE:
3875             ftdi->eeprom->group0_drive = value;
3876             break;
3877         case GROUP0_SCHMITT:
3878             ftdi->eeprom->group0_schmitt = value;
3879             break;
3880         case GROUP0_SLEW:
3881             ftdi->eeprom->group0_slew = value;
3882             break;
3883         case GROUP1_DRIVE:
3884             ftdi->eeprom->group1_drive = value;
3885             break;
3886         case GROUP1_SCHMITT:
3887             ftdi->eeprom->group1_schmitt = value;
3888             break;
3889         case GROUP1_SLEW:
3890             ftdi->eeprom->group1_slew = value;
3891             break;
3892         case GROUP2_DRIVE:
3893             ftdi->eeprom->group2_drive = value;
3894             break;
3895         case GROUP2_SCHMITT:
3896             ftdi->eeprom->group2_schmitt = value;
3897             break;
3898         case GROUP2_SLEW:
3899             ftdi->eeprom->group2_slew = value;
3900             break;
3901         case GROUP3_DRIVE:
3902             ftdi->eeprom->group3_drive = value;
3903             break;
3904         case GROUP3_SCHMITT:
3905             ftdi->eeprom->group3_schmitt = value;
3906             break;
3907         case GROUP3_SLEW:
3908             ftdi->eeprom->group3_slew = value;
3909             break;
3910         case CHIP_TYPE:
3911             ftdi->eeprom->chip = value;
3912             break;
3913         case POWER_SAVE:
3914             ftdi->eeprom->powersave = value;
3915             break;
3916         case CLOCK_POLARITY:
3917             ftdi->eeprom->clock_polarity = value;
3918             break;
3919         case DATA_ORDER:
3920             ftdi->eeprom->data_order = value;
3921             break;
3922         case FLOW_CONTROL:
3923             ftdi->eeprom->flow_control = value;
3924             break;
3925         case CHIP_SIZE:
3926             ftdi_error_return(-2, "EEPROM Value can't be changed");
3927         default :
3928             ftdi_error_return(-1, "Request to unknown EEPROM value");
3929     }
3930     ftdi->eeprom->initialized_for_connected_device = 0;
3931     return 0;
3932 }
3933
3934 /** Get the read-only buffer to the binary EEPROM content
3935
3936     \param ftdi pointer to ftdi_context
3937     \param buf buffer to receive EEPROM content
3938     \param size Size of receiving buffer
3939
3940     \retval 0: All fine
3941     \retval -1: struct ftdi_contxt or ftdi_eeprom missing
3942     \retval -2: Not enough room to store eeprom
3943 */
3944 int ftdi_get_eeprom_buf(struct ftdi_context *ftdi, unsigned char * buf, int size)
3945 {
3946     if (!ftdi || !(ftdi->eeprom))
3947         ftdi_error_return(-1, "No appropriate structure");
3948
3949     if (!buf || size < ftdi->eeprom->size)
3950         ftdi_error_return(-1, "Not enough room to store eeprom");
3951
3952     // Only copy up to FTDI_MAX_EEPROM_SIZE bytes
3953     if (size > FTDI_MAX_EEPROM_SIZE)
3954         size = FTDI_MAX_EEPROM_SIZE;
3955
3956     memcpy(buf, ftdi->eeprom->buf, size);
3957
3958     return 0;
3959 }
3960
3961 /** Set the EEPROM content from the user-supplied prefilled buffer
3962
3963     \param ftdi pointer to ftdi_context
3964     \param buf buffer to read EEPROM content
3965     \param size Size of buffer
3966
3967     \retval 0: All fine
3968     \retval -1: struct ftdi_contxt or ftdi_eeprom of buf missing
3969 */
3970 int ftdi_set_eeprom_buf(struct ftdi_context *ftdi, const unsigned char * buf, int size)
3971 {
3972     if (!ftdi || !(ftdi->eeprom) || !buf)
3973         ftdi_error_return(-1, "No appropriate structure");
3974
3975     // Only copy up to FTDI_MAX_EEPROM_SIZE bytes
3976     if (size > FTDI_MAX_EEPROM_SIZE)
3977         size = FTDI_MAX_EEPROM_SIZE;
3978
3979     memcpy(ftdi->eeprom->buf, buf, size);
3980
3981     return 0;
3982 }
3983
3984 /**
3985     Read eeprom location
3986
3987     \param ftdi pointer to ftdi_context
3988     \param eeprom_addr Address of eeprom location to be read
3989     \param eeprom_val Pointer to store read eeprom location
3990
3991     \retval  0: all fine
3992     \retval -1: read failed
3993     \retval -2: USB device unavailable
3994 */
3995 int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
3996 {
3997     if (ftdi == NULL || ftdi->usb_dev == NULL)
3998         ftdi_error_return(-2, "USB device unavailable");
3999
4000     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)
4001         ftdi_error_return(-1, "reading eeprom failed");
4002
4003     return 0;
4004 }
4005
4006 /**
4007     Read eeprom
4008
4009     \param ftdi pointer to ftdi_context
4010
4011     \retval  0: all fine
4012     \retval -1: read failed
4013     \retval -2: USB device unavailable
4014 */
4015 int ftdi_read_eeprom(struct ftdi_context *ftdi)
4016 {
4017     int i;
4018     unsigned char *buf;
4019
4020     if (ftdi == NULL || ftdi->usb_dev == NULL)
4021         ftdi_error_return(-2, "USB device unavailable");
4022     buf = ftdi->eeprom->buf;
4023
4024     for (i = 0; i < FTDI_MAX_EEPROM_SIZE/2; i++)
4025     {
4026         if (libusb_control_transfer(
4027                     ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,SIO_READ_EEPROM_REQUEST, 0, i,
4028                     buf+(i*2), 2, ftdi->usb_read_timeout) != 2)
4029             ftdi_error_return(-1, "reading eeprom failed");
4030     }
4031
4032     if (ftdi->type == TYPE_R)
4033         ftdi->eeprom->size = 0x80;
4034     /*    Guesses size of eeprom by comparing halves
4035           - will not work with blank eeprom */
4036     else if (strrchr((const char *)buf, 0xff) == ((const char *)buf +FTDI_MAX_EEPROM_SIZE -1))
4037         ftdi->eeprom->size = -1;
4038     else if (memcmp(buf,&buf[0x80],0x80) == 0)
4039         ftdi->eeprom->size = 0x80;
4040     else if (memcmp(buf,&buf[0x40],0x40) == 0)
4041         ftdi->eeprom->size = 0x40;
4042     else
4043         ftdi->eeprom->size = 0x100;
4044     return 0;
4045 }
4046
4047 /*
4048     ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID
4049     Function is only used internally
4050     \internal
4051 */
4052 static unsigned char ftdi_read_chipid_shift(unsigned char value)
4053 {
4054     return ((value & 1) << 1) |
4055            ((value & 2) << 5) |
4056            ((value & 4) >> 2) |
4057            ((value & 8) << 4) |
4058            ((value & 16) >> 1) |
4059            ((value & 32) >> 1) |
4060            ((value & 64) >> 4) |
4061            ((value & 128) >> 2);
4062 }
4063
4064 /**
4065     Read the FTDIChip-ID from R-type devices
4066
4067     \param ftdi pointer to ftdi_context
4068     \param chipid Pointer to store FTDIChip-ID
4069
4070     \retval  0: all fine
4071     \retval -1: read failed
4072     \retval -2: USB device unavailable
4073 */
4074 int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
4075 {
4076     unsigned int a = 0, b = 0;
4077
4078     if (ftdi == NULL || ftdi->usb_dev == NULL)
4079         ftdi_error_return(-2, "USB device unavailable");
4080
4081     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)
4082     {
4083         a = a << 8 | a >> 8;
4084         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)
4085         {
4086             b = b << 8 | b >> 8;
4087             a = (a << 16) | (b & 0xFFFF);
4088             a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
4089                 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
4090             *chipid = a ^ 0xa5f0f7d1;
4091             return 0;
4092         }
4093     }
4094
4095     ftdi_error_return(-1, "read of FTDIChip-ID failed");
4096 }
4097
4098 /**
4099     Write eeprom location
4100
4101     \param ftdi pointer to ftdi_context
4102     \param eeprom_addr Address of eeprom location to be written
4103     \param eeprom_val Value to be written
4104
4105     \retval  0: all fine
4106     \retval -1: write failed
4107     \retval -2: USB device unavailable
4108     \retval -3: Invalid access to checksum protected area below 0x80
4109     \retval -4: Device can't access unprotected area
4110     \retval -5: Reading chip type failed
4111 */
4112 int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr,
4113                                unsigned short eeprom_val)
4114 {
4115     int chip_type_location;
4116     unsigned short chip_type;
4117
4118     if (ftdi == NULL || ftdi->usb_dev == NULL)
4119         ftdi_error_return(-2, "USB device unavailable");
4120
4121     if (eeprom_addr <0x80)
4122         ftdi_error_return(-2, "Invalid access to checksum protected area  below 0x80");
4123
4124
4125     switch (ftdi->type)
4126     {
4127         case TYPE_BM:
4128         case  TYPE_2232C:
4129             chip_type_location = 0x14;
4130             break;
4131         case TYPE_2232H:
4132         case TYPE_4232H:
4133             chip_type_location = 0x18;
4134             break;
4135         case TYPE_232H:
4136             chip_type_location = 0x1e;
4137             break;
4138         default:
4139             ftdi_error_return(-4, "Device can't access unprotected area");
4140     }
4141
4142     if (ftdi_read_eeprom_location( ftdi, chip_type_location>>1, &chip_type))
4143         ftdi_error_return(-5, "Reading failed");
4144     fprintf(stderr," loc 0x%04x val 0x%04x\n", chip_type_location,chip_type);
4145     if ((chip_type & 0xff) != 0x66)
4146     {
4147         ftdi_error_return(-6, "EEPROM is not of 93x66");
4148     }
4149
4150     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
4151                                 SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
4152                                 NULL, 0, ftdi->usb_write_timeout) != 0)
4153         ftdi_error_return(-1, "unable to write eeprom");
4154
4155     return 0;
4156 }
4157
4158 /**
4159     Write eeprom
4160
4161     \param ftdi pointer to ftdi_context
4162
4163     \retval  0: all fine
4164     \retval -1: read failed
4165     \retval -2: USB device unavailable
4166     \retval -3: EEPROM not initialized for the connected device;
4167 */
4168 int ftdi_write_eeprom(struct ftdi_context *ftdi)
4169 {
4170     unsigned short usb_val, status;
4171     int i, ret;
4172     unsigned char *eeprom;
4173
4174     if (ftdi == NULL || ftdi->usb_dev == NULL)
4175         ftdi_error_return(-2, "USB device unavailable");
4176
4177     if(ftdi->eeprom->initialized_for_connected_device == 0)
4178         ftdi_error_return(-3, "EEPROM not initialized for the connected device");
4179
4180     eeprom = ftdi->eeprom->buf;
4181
4182     /* These commands were traced while running MProg */
4183     if ((ret = ftdi_usb_reset(ftdi)) != 0)
4184         return ret;
4185     if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0)
4186         return ret;
4187     if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0)
4188         return ret;
4189
4190     for (i = 0; i < ftdi->eeprom->size/2; i++)
4191     {
4192         /* Do not try to write to reserved area */
4193         if ((ftdi->type == TYPE_230X) && (i == 0x40))
4194         {
4195             i = 0x50;
4196         }
4197         usb_val = eeprom[i*2];
4198         usb_val += eeprom[(i*2)+1] << 8;
4199         if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
4200                                     SIO_WRITE_EEPROM_REQUEST, usb_val, i,
4201                                     NULL, 0, ftdi->usb_write_timeout) < 0)
4202             ftdi_error_return(-1, "unable to write eeprom");
4203     }
4204
4205     return 0;
4206 }
4207
4208 /**
4209     Erase eeprom
4210
4211     This is not supported on FT232R/FT245R according to the MProg manual from FTDI.
4212
4213     \param ftdi pointer to ftdi_context
4214
4215     \retval  0: all fine
4216     \retval -1: erase failed
4217     \retval -2: USB device unavailable
4218     \retval -3: Writing magic failed
4219     \retval -4: Read EEPROM failed
4220     \retval -5: Unexpected EEPROM value
4221 */
4222 #define MAGIC 0x55aa
4223 int ftdi_erase_eeprom(struct ftdi_context *ftdi)
4224 {
4225     unsigned short eeprom_value;
4226     if (ftdi == NULL || ftdi->usb_dev == NULL)
4227         ftdi_error_return(-2, "USB device unavailable");
4228
4229     if ((ftdi->type == TYPE_R) || (ftdi->type == TYPE_230X))
4230     {
4231         ftdi->eeprom->chip = 0;
4232         return 0;
4233     }
4234
4235     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
4236                                 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
4237         ftdi_error_return(-1, "unable to erase eeprom");
4238
4239
4240     /* detect chip type by writing 0x55AA as magic at word position 0xc0
4241        Chip is 93x46 if magic is read at word position 0x00, as wraparound happens around 0x40
4242        Chip is 93x56 if magic is read at word position 0x40, as wraparound happens around 0x80
4243        Chip is 93x66 if magic is only read at word position 0xc0*/
4244     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
4245                                 SIO_WRITE_EEPROM_REQUEST, MAGIC, 0xc0,
4246                                 NULL, 0, ftdi->usb_write_timeout) != 0)
4247         ftdi_error_return(-3, "Writing magic failed");
4248     if (ftdi_read_eeprom_location( ftdi, 0x00, &eeprom_value))
4249         ftdi_error_return(-4, "Reading failed");
4250     if (eeprom_value == MAGIC)
4251     {
4252         ftdi->eeprom->chip = 0x46;
4253     }
4254     else
4255     {
4256         if (ftdi_read_eeprom_location( ftdi, 0x40, &eeprom_value))
4257             ftdi_error_return(-4, "Reading failed");
4258         if (eeprom_value == MAGIC)
4259             ftdi->eeprom->chip = 0x56;
4260         else
4261         {
4262             if (ftdi_read_eeprom_location( ftdi, 0xc0, &eeprom_value))
4263                 ftdi_error_return(-4, "Reading failed");
4264             if (eeprom_value == MAGIC)
4265                 ftdi->eeprom->chip = 0x66;
4266             else
4267             {
4268                 ftdi->eeprom->chip = -1;
4269             }
4270         }
4271     }
4272     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
4273                                 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
4274         ftdi_error_return(-1, "unable to erase eeprom");
4275     return 0;
4276 }
4277
4278 /**
4279     Get string representation for last error code
4280
4281     \param ftdi pointer to ftdi_context
4282
4283     \retval Pointer to error string
4284 */
4285 char *ftdi_get_error_string (struct ftdi_context *ftdi)
4286 {
4287     if (ftdi == NULL)
4288         return "";
4289
4290     return ftdi->error_str;
4291 }
4292
4293 /* @} end of doxygen libftdi group */