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-2010 by Intra2net AG
   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.h"
  38
  39 #define ftdi_error_return(code, str) do {  \
  40         ftdi->error_str = str;             \
  41         return code;                       \
  42    } while(0);
  43
  44 #define ftdi_error_return_free_device_list(code, str, devs) do {    \
  45         libusb_free_device_list(devs,1);   \
  46         ftdi->error_str = str;             \
  47         return code;                       \
  48    } while(0);
  49
  50
  51 /**
  52     Internal function to close usb device pointer.
  53     Sets ftdi->usb_dev to NULL.
  54     \internal
  55
  56     \param ftdi pointer to ftdi_context
  57
  58     \retval none
  59 */
  60 static void ftdi_usb_close_internal (struct ftdi_context *ftdi)
  61 {
  62     if (ftdi && ftdi->usb_dev)
  63     {
  64        libusb_close (ftdi->usb_dev);
  65        ftdi->usb_dev = NULL;
  66     }
  67 }
  68
  69 /**
  70     Initializes a ftdi_context.
  71
  72     \param ftdi pointer to ftdi_context
  73
  74     \retval  0: all fine
  75     \retval -1: couldn't allocate read buffer
  76     \retval -2: couldn't allocate struct  buffer
  77
  78     \remark This should be called before all functions
  79 */
  80 int ftdi_init(struct ftdi_context *ftdi)
  81 {
  82     struct ftdi_eeprom* eeprom = (struct ftdi_eeprom *)malloc(sizeof(struct ftdi_eeprom));
  83     ftdi->usb_ctx = NULL;
  84     ftdi->usb_dev = NULL;
  85     ftdi->usb_read_timeout = 5000;
  86     ftdi->usb_write_timeout = 5000;
  87
  88     ftdi->type = TYPE_BM;    /* chip type */
  89     ftdi->baudrate = -1;
  90     ftdi->bitbang_enabled = 0;  /* 0: normal mode 1: any of the bitbang modes enabled */
  91
  92     ftdi->readbuffer = NULL;
  93     ftdi->readbuffer_offset = 0;
  94     ftdi->readbuffer_remaining = 0;
  95     ftdi->writebuffer_chunksize = 4096;
  96     ftdi->max_packet_size = 0;
  97
  98     ftdi->interface = 0;
  99     ftdi->index = 0;
 100     ftdi->in_ep = 0x02;
 101     ftdi->out_ep = 0x81;
 102     ftdi->bitbang_mode = 1; /* when bitbang is enabled this holds the number of the mode  */
 103
 104     ftdi->error_str = NULL;
 105
 106     if (eeprom == 0)
 107         ftdi_error_return(-2, "Can't malloc struct ftdi_eeprom");
 108     memset(eeprom, 0, sizeof(struct ftdi_eeprom));
 109     ftdi->eeprom = eeprom;
 110
 111     /* All fine. Now allocate the readbuffer */
 112     return ftdi_read_data_set_chunksize(ftdi, 4096);
 113 }
 114
 115 /**
 116     Allocate and initialize a new ftdi_context
 117
 118     \return a pointer to a new ftdi_context, or NULL on failure
 119 */
 120 struct ftdi_context *ftdi_new(void)
 121 {
 122     struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context));
 123
 124     if (ftdi == NULL)
 125     {
 126         return NULL;
 127     }
 128
 129     if (ftdi_init(ftdi) != 0)
 130     {
 131         free(ftdi);
 132         return NULL;
 133     }
 134
 135     return ftdi;
 136 }
 137
 138 /**
 139     Open selected channels on a chip, otherwise use first channel.
 140
 141     \param ftdi pointer to ftdi_context
 142     \param interface Interface to use for FT2232C/2232H/4232H chips.
 143
 144     \retval  0: all fine
 145     \retval -1: unknown interface
 146     \retval -2: USB device unavailable
 147 */
 148 int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
 149 {
 150     if (ftdi == NULL)
 151         ftdi_error_return(-2, "USB device unavailable");
 152
 153     switch (interface)
 154     {
 155         case INTERFACE_ANY:
 156         case INTERFACE_A:
 157             /* ftdi_usb_open_desc cares to set the right index, depending on the found chip */
 158             break;
 159         case INTERFACE_B:
 160             ftdi->interface = 1;
 161             ftdi->index     = INTERFACE_B;
 162             ftdi->in_ep     = 0x04;
 163             ftdi->out_ep    = 0x83;
 164             break;
 165         case INTERFACE_C:
 166             ftdi->interface = 2;
 167             ftdi->index     = INTERFACE_C;
 168             ftdi->in_ep     = 0x06;
 169             ftdi->out_ep    = 0x85;
 170             break;
 171         case INTERFACE_D:
 172             ftdi->interface = 3;
 173             ftdi->index     = INTERFACE_D;
 174             ftdi->in_ep     = 0x08;
 175             ftdi->out_ep    = 0x87;
 176             break;
 177         default:
 178             ftdi_error_return(-1, "Unknown interface");
 179     }
 180     return 0;
 181 }
 182
 183 /**
 184     Deinitializes a ftdi_context.
 185
 186     \param ftdi pointer to ftdi_context
 187 */
 188 void ftdi_deinit(struct ftdi_context *ftdi)
 189 {
 190     if (ftdi == NULL)
 191         return;
 192
 193     ftdi_usb_close_internal (ftdi);
 194
 195     if (ftdi->readbuffer != NULL)
 196     {
 197         free(ftdi->readbuffer);
 198         ftdi->readbuffer = NULL;
 199     }
 200
 201     if (ftdi->eeprom != NULL)
 202     {
 203         if (ftdi->eeprom->manufacturer != 0)
 204         {
 205             free(ftdi->eeprom->manufacturer);
 206             ftdi->eeprom->manufacturer = 0;
 207         }
 208         if (ftdi->eeprom->product != 0)
 209         {
 210             free(ftdi->eeprom->product);
 211             ftdi->eeprom->product = 0;
 212         }
 213         if (ftdi->eeprom->serial != 0)
 214         {
 215             free(ftdi->eeprom->serial);
 216             ftdi->eeprom->serial = 0;
 217         }
 218         free(ftdi->eeprom);
 219         ftdi->eeprom = NULL;
 220     }
 221     libusb_exit(ftdi->usb_ctx);
 222 }
 223
 224 /**
 225     Deinitialize and free an ftdi_context.
 226
 227     \param ftdi pointer to ftdi_context
 228 */
 229 void ftdi_free(struct ftdi_context *ftdi)
 230 {
 231     ftdi_deinit(ftdi);
 232     free(ftdi);
 233 }
 234
 235 /**
 236     Use an already open libusb device.
 237
 238     \param ftdi pointer to ftdi_context
 239     \param usb libusb libusb_device_handle to use
 240 */
 241 void ftdi_set_usbdev (struct ftdi_context *ftdi, libusb_device_handle *usb)
 242 {
 243     if (ftdi == NULL)
 244         return;
 245
 246     ftdi->usb_dev = usb;
 247 }
 248
 249
 250 /**
 251     Finds all ftdi devices on the usb bus. Creates a new ftdi_device_list which
 252     needs to be deallocated by ftdi_list_free() after use.
 253
 254     \param ftdi pointer to ftdi_context
 255     \param devlist Pointer where to store list of found devices
 256     \param vendor Vendor ID to search for
 257     \param product Product ID to search for
 258
 259     \retval >0: number of devices found
 260     \retval -3: out of memory
 261     \retval -4: libusb_init() failed
 262     \retval -5: libusb_get_device_list() failed
 263     \retval -6: libusb_get_device_descriptor() failed
 264 */
 265 int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
 266 {
 267     struct ftdi_device_list **curdev;
 268     libusb_device *dev;
 269     libusb_device **devs;
 270     int count = 0;
 271     int i = 0;
 272
 273     if (libusb_init(&ftdi->usb_ctx) < 0)
 274         ftdi_error_return(-4, "libusb_init() failed");
 275
 276     if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
 277         ftdi_error_return(-5, "libusb_get_device_list() failed");
 278
 279     curdev = devlist;
 280     *curdev = NULL;
 281
 282     while ((dev = devs[i++]) != NULL)
 283     {
 284         struct libusb_device_descriptor desc;
 285
 286         if (libusb_get_device_descriptor(dev, &desc) < 0)
 287             ftdi_error_return(-6, "libusb_get_device_descriptor() failed");
 288
 289         if (desc.idVendor == vendor && desc.idProduct == product)
 290         {
 291             *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
 292             if (!*curdev)
 293                 ftdi_error_return(-3, "out of memory");
 294
 295             (*curdev)->next = NULL;
 296             (*curdev)->dev = dev;
 297
 298             curdev = &(*curdev)->next;
 299             count++;
 300         }
 301     }
 302
 303     return count;
 304 }
 305
 306 /**
 307     Frees a usb device list.
 308
 309     \param devlist USB device list created by ftdi_usb_find_all()
 310 */
 311 void ftdi_list_free(struct ftdi_device_list **devlist)
 312 {
 313     struct ftdi_device_list *curdev, *next;
 314
 315     for (curdev = *devlist; curdev != NULL;)
 316     {
 317         next = curdev->next;
 318         free(curdev);
 319         curdev = next;
 320     }
 321
 322     *devlist = NULL;
 323 }
 324
 325 /**
 326     Frees a usb device list.
 327
 328     \param devlist USB device list created by ftdi_usb_find_all()
 329 */
 330 void ftdi_list_free2(struct ftdi_device_list *devlist)
 331 {
 332     ftdi_list_free(&devlist);
 333 }
 334
 335 /**
 336     Return device ID strings from the usb device.
 337
 338     The parameters manufacturer, description and serial may be NULL
 339     or pointer to buffers to store the fetched strings.
 340
 341     \note Use this function only in combination with ftdi_usb_find_all()
 342           as it closes the internal "usb_dev" after use.
 343
 344     \param ftdi pointer to ftdi_context
 345     \param dev libusb usb_dev to use
 346     \param manufacturer Store manufacturer string here if not NULL
 347     \param mnf_len Buffer size of manufacturer string
 348     \param description Store product description string here if not NULL
 349     \param desc_len Buffer size of product description string
 350     \param serial Store serial string here if not NULL
 351     \param serial_len Buffer size of serial string
 352
 353     \retval   0: all fine
 354     \retval  -1: wrong arguments
 355     \retval  -4: unable to open device
 356     \retval  -7: get product manufacturer failed
 357     \retval  -8: get product description failed
 358     \retval  -9: get serial number failed
 359     \retval -11: libusb_get_device_descriptor() failed
 360 */
 361 int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct libusb_device * dev,
 362                          char * manufacturer, int mnf_len, char * description, int desc_len, char * serial, int serial_len)
 363 {
 364     struct libusb_device_descriptor desc;
 365
 366     if ((ftdi==NULL) || (dev==NULL))
 367         return -1;
 368
 369     if (libusb_open(dev, &ftdi->usb_dev) < 0)
 370         ftdi_error_return(-4, "libusb_open() failed");
 371
 372     if (libusb_get_device_descriptor(dev, &desc) < 0)
 373         ftdi_error_return(-11, "libusb_get_device_descriptor() failed");
 374
 375     if (manufacturer != NULL)
 376     {
 377         if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iManufacturer, (unsigned char *)manufacturer, mnf_len) < 0)
 378         {
 379             ftdi_usb_close_internal (ftdi);
 380             ftdi_error_return(-7, "libusb_get_string_descriptor_ascii() failed");
 381         }
 382     }
 383
 384     if (description != NULL)
 385     {
 386         if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)description, desc_len) < 0)
 387         {
 388             ftdi_usb_close_internal (ftdi);
 389             ftdi_error_return(-8, "libusb_get_string_descriptor_ascii() failed");
 390         }
 391     }
 392
 393     if (serial != NULL)
 394     {
 395         if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)serial, serial_len) < 0)
 396         {
 397             ftdi_usb_close_internal (ftdi);
 398             ftdi_error_return(-9, "libusb_get_string_descriptor_ascii() failed");
 399         }
 400     }
 401
 402     ftdi_usb_close_internal (ftdi);
 403
 404     return 0;
 405 }
 406
 407 /**
 408  * Internal function to determine the maximum packet size.
 409  * \param ftdi pointer to ftdi_context
 410  * \param dev libusb usb_dev to use
 411  * \retval Maximum packet size for this device
 412  */
 413 static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, libusb_device *dev)
 414 {
 415     struct libusb_device_descriptor desc;
 416     struct libusb_config_descriptor *config0;
 417     unsigned int packet_size;
 418
 419     // Sanity check
 420     if (ftdi == NULL || dev == NULL)
 421         return 64;
 422
 423     // Determine maximum packet size. Init with default value.
 424     // New hi-speed devices from FTDI use a packet size of 512 bytes
 425     // but could be connected to a normal speed USB hub -> 64 bytes packet size.
 426     if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H)
 427         packet_size = 512;
 428     else
 429         packet_size = 64;
 430
 431     if (libusb_get_device_descriptor(dev, &desc) < 0)
 432         return packet_size;
 433
 434     if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
 435         return packet_size;
 436
 437     if (desc.bNumConfigurations > 0)
 438     {
 439         if (ftdi->interface < config0->bNumInterfaces)
 440         {
 441             struct libusb_interface interface = config0->interface[ftdi->interface];
 442             if (interface.num_altsetting > 0)
 443             {
 444                 struct libusb_interface_descriptor descriptor = interface.altsetting[0];
 445                 if (descriptor.bNumEndpoints > 0)
 446                 {
 447                     packet_size = descriptor.endpoint[0].wMaxPacketSize;
 448                 }
 449             }
 450         }
 451     }
 452
 453     libusb_free_config_descriptor (config0);
 454     return packet_size;
 455 }
 456
 457 /**
 458     Opens a ftdi device given by an usb_device.
 459
 460     \param ftdi pointer to ftdi_context
 461     \param dev libusb usb_dev to use
 462
 463     \retval  0: all fine
 464     \retval -3: unable to config device
 465     \retval -4: unable to open device
 466     \retval -5: unable to claim device
 467     \retval -6: reset failed
 468     \retval -7: set baudrate failed
 469     \retval -8: ftdi context invalid
 470     \retval -9: libusb_get_device_descriptor() failed
 471     \retval -10: libusb_get_config_descriptor() failed
 472     \retval -11: libusb_etach_kernel_driver() failed
 473     \retval -12: libusb_get_configuration() failed
 474 */
 475 int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev)
 476 {
 477     struct libusb_device_descriptor desc;
 478     struct libusb_config_descriptor *config0;
 479     int cfg, cfg0, detach_errno = 0;
 480
 481     if (ftdi == NULL)
 482         ftdi_error_return(-8, "ftdi context invalid");
 483
 484     if (libusb_open(dev, &ftdi->usb_dev) < 0)
 485         ftdi_error_return(-4, "libusb_open() failed");
 486
 487     if (libusb_get_device_descriptor(dev, &desc) < 0)
 488         ftdi_error_return(-9, "libusb_get_device_descriptor() failed");
 489
 490     if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
 491         ftdi_error_return(-10, "libusb_get_config_descriptor() failed");
 492     cfg0 = config0->bConfigurationValue;
 493     libusb_free_config_descriptor (config0);
 494
 495     // Try to detach ftdi_sio kernel module.
 496     //
 497     // The return code is kept in a separate variable and only parsed
 498     // if usb_set_configuration() or usb_claim_interface() fails as the
 499     // detach operation might be denied and everything still works fine.
 500     // Likely scenario is a static ftdi_sio kernel module.
 501     if (libusb_detach_kernel_driver(ftdi->usb_dev, ftdi->interface) !=0)
 502         detach_errno = errno;
 503
 504     if (libusb_get_configuration (ftdi->usb_dev, &cfg) < 0)
 505         ftdi_error_return(-12, "libusb_get_configuration () failed");
 506     // set configuration (needed especially for windows)
 507     // tolerate EBUSY: one device with one configuration, but two interfaces
 508     //    and libftdi sessions to both interfaces (e.g. FT2232)
 509     if (desc.bNumConfigurations > 0 && cfg != cfg0)
 510     {
 511         if (libusb_set_configuration(ftdi->usb_dev, cfg0) < 0)
 512         {
 513             ftdi_usb_close_internal (ftdi);
 514             if(detach_errno == EPERM)
 515             {
 516                 ftdi_error_return(-8, "inappropriate permissions on device!");
 517             }
 518             else
 519             {
 520                 ftdi_error_return(-3, "unable to set usb configuration. Make sure the default FTDI driver is not in use");
 521             }
 522         }
 523     }
 524
 525     if (libusb_claim_interface(ftdi->usb_dev, ftdi->interface) < 0)
 526     {
 527         ftdi_usb_close_internal (ftdi);
 528         if(detach_errno == EPERM)
 529         {
 530             ftdi_error_return(-8, "inappropriate permissions on device!");
 531         }
 532         else
 533         {
 534             ftdi_error_return(-5, "unable to claim usb device. Make sure the default FTDI driver is not in use");
 535         }
 536     }
 537
 538     if (ftdi_usb_reset (ftdi) != 0)
 539     {
 540         ftdi_usb_close_internal (ftdi);
 541         ftdi_error_return(-6, "ftdi_usb_reset failed");
 542     }
 543
 544     // Try to guess chip type
 545     // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
 546     if (desc.bcdDevice == 0x400 || (desc.bcdDevice == 0x200
 547             && desc.iSerialNumber == 0))
 548         ftdi->type = TYPE_BM;
 549     else if (desc.bcdDevice == 0x200)
 550         ftdi->type = TYPE_AM;
 551     else if (desc.bcdDevice == 0x500)
 552         ftdi->type = TYPE_2232C;
 553     else if (desc.bcdDevice == 0x600)
 554         ftdi->type = TYPE_R;
 555     else if (desc.bcdDevice == 0x700)
 556         ftdi->type = TYPE_2232H;
 557     else if (desc.bcdDevice == 0x800)
 558         ftdi->type = TYPE_4232H;
 559
 560     // Set default interface on dual/quad type chips
 561     switch(ftdi->type)
 562     {
 563         case TYPE_2232C:
 564         case TYPE_2232H:
 565         case TYPE_4232H:
 566             if (!ftdi->index)
 567                 ftdi->index = INTERFACE_A;
 568             break;
 569         default:
 570             break;
 571     }
 572
 573     // Determine maximum packet size
 574     ftdi->max_packet_size = _ftdi_determine_max_packet_size(ftdi, dev);
 575
 576     if (ftdi_set_baudrate (ftdi, 9600) != 0)
 577     {
 578         ftdi_usb_close_internal (ftdi);
 579         ftdi_error_return(-7, "set baudrate failed");
 580     }
 581
 582     ftdi_error_return(0, "all fine");
 583 }
 584
 585 /**
 586     Opens the first device with a given vendor and product ids.
 587
 588     \param ftdi pointer to ftdi_context
 589     \param vendor Vendor ID
 590     \param product Product ID
 591
 592     \retval same as ftdi_usb_open_desc()
 593 */
 594 int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
 595 {
 596     return ftdi_usb_open_desc(ftdi, vendor, product, NULL, NULL);
 597 }
 598
 599 /**
 600     Opens the first device with a given, vendor id, product id,
 601     description and serial.
 602
 603     \param ftdi pointer to ftdi_context
 604     \param vendor Vendor ID
 605     \param product Product ID
 606     \param description Description to search for. Use NULL if not needed.
 607     \param serial Serial to search for. Use NULL if not needed.
 608
 609     \retval  0: all fine
 610     \retval -3: usb device not found
 611     \retval -4: unable to open device
 612     \retval -5: unable to claim device
 613     \retval -6: reset failed
 614     \retval -7: set baudrate failed
 615     \retval -8: get product description failed
 616     \retval -9: get serial number failed
 617     \retval -11: libusb_init() failed
 618     \retval -12: libusb_get_device_list() failed
 619     \retval -13: libusb_get_device_descriptor() failed
 620 */
 621 int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
 622                        const char* description, const char* serial)
 623 {
 624     return ftdi_usb_open_desc_index(ftdi,vendor,product,description,serial,0);
 625 }
 626
 627 /**
 628     Opens the index-th device with a given, vendor id, product id,
 629     description and serial.
 630
 631     \param ftdi pointer to ftdi_context
 632     \param vendor Vendor ID
 633     \param product Product ID
 634     \param description Description to search for. Use NULL if not needed.
 635     \param serial Serial to search for. Use NULL if not needed.
 636     \param index Number of matching device to open if there are more than one, starts with 0.
 637
 638     \retval  0: all fine
 639     \retval -1: usb_find_busses() failed
 640     \retval -2: usb_find_devices() failed
 641     \retval -3: usb device not found
 642     \retval -4: unable to open device
 643     \retval -5: unable to claim device
 644     \retval -6: reset failed
 645     \retval -7: set baudrate failed
 646     \retval -8: get product description failed
 647     \retval -9: get serial number failed
 648     \retval -10: unable to close device
 649     \retval -11: ftdi context invalid
 650 */
 651 int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product,
 652                        const char* description, const char* serial, unsigned int index)
 653 {
 654     libusb_device *dev;
 655     libusb_device **devs;
 656     char string[256];
 657     int i = 0;
 658
 659     if (libusb_init(&ftdi->usb_ctx) < 0)
 660         ftdi_error_return(-11, "libusb_init() failed");
 661
 662     if (ftdi == NULL)
 663         ftdi_error_return(-11, "ftdi context invalid");
 664
 665     if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
 666         ftdi_error_return(-12, "libusb_get_device_list() failed");
 667
 668     while ((dev = devs[i++]) != NULL)
 669     {
 670         struct libusb_device_descriptor desc;
 671         int res;
 672
 673         if (libusb_get_device_descriptor(dev, &desc) < 0)
 674             ftdi_error_return_free_device_list(-13, "libusb_get_device_descriptor() failed", devs);
 675
 676         if (desc.idVendor == vendor && desc.idProduct == product)
 677         {
 678             if (libusb_open(dev, &ftdi->usb_dev) < 0)
 679                 ftdi_error_return_free_device_list(-4, "usb_open() failed", devs);
 680
 681             if (description != NULL)
 682             {
 683                 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)string, sizeof(string)) < 0)
 684                 {
 685                     libusb_close (ftdi->usb_dev);
 686                     ftdi_error_return_free_device_list(-8, "unable to fetch product description", devs);
 687                 }
 688                 if (strncmp(string, description, sizeof(string)) != 0)
 689                 {
 690                     libusb_close (ftdi->usb_dev);
 691                     continue;
 692                 }
 693             }
 694             if (serial != NULL)
 695             {
 696                 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)string, sizeof(string)) < 0)
 697                 {
 698                     ftdi_usb_close_internal (ftdi);
 699                     ftdi_error_return_free_device_list(-9, "unable to fetch serial number", devs);
 700                 }
 701                 if (strncmp(string, serial, sizeof(string)) != 0)
 702                 {
 703                     ftdi_usb_close_internal (ftdi);
 704                     continue;
 705                 }
 706             }
 707
 708             ftdi_usb_close_internal (ftdi);
 709
 710                 if (index > 0)
 711                 {
 712                     index--;
 713                     continue;
 714                 }
 715
 716             res = ftdi_usb_open_dev(ftdi, dev);
 717             libusb_free_device_list(devs,1);
 718             return res;
 719         }
 720     }
 721
 722     // device not found
 723     ftdi_error_return_free_device_list(-3, "device not found", devs);
 724 }
 725
 726 /**
 727     Opens the ftdi-device described by a description-string.
 728     Intended to be used for parsing a device-description given as commandline argument.
 729
 730     \param ftdi pointer to ftdi_context
 731     \param description NULL-terminated description-string, using this format:
 732         \li <tt>d:\<devicenode></tt> path of bus and device-node (e.g. "003/001") within usb device tree (usually at /proc/bus/usb/)
 733         \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")
 734         \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
 735         \li <tt>s:\<vendor>:\<product>:\<serial></tt> first device with given vendor id, product id and serial string
 736
 737     \note The description format may be extended in later versions.
 738
 739     \retval  0: all fine
 740     \retval -1: libusb_init() failed
 741     \retval -2: libusb_get_device_list() failed
 742     \retval -3: usb device not found
 743     \retval -4: unable to open device
 744     \retval -5: unable to claim device
 745     \retval -6: reset failed
 746     \retval -7: set baudrate failed
 747     \retval -8: get product description failed
 748     \retval -9: get serial number failed
 749     \retval -10: unable to close device
 750     \retval -11: illegal description format
 751     \retval -12: ftdi context invalid
 752 */
 753 int ftdi_usb_open_string(struct ftdi_context *ftdi, const char* description)
 754 {
 755     if (ftdi == NULL)
 756         ftdi_error_return(-12, "ftdi context invalid");
 757
 758     if (description[0] == 0 || description[1] != ':')
 759         ftdi_error_return(-11, "illegal description format");
 760
 761     if (description[0] == 'd')
 762     {
 763         libusb_device *dev;
 764         libusb_device **devs;
 765         unsigned int bus_number, device_address;
 766         int i = 0;
 767
 768         if (libusb_init (&ftdi->usb_ctx) < 0)
 769             ftdi_error_return(-1, "libusb_init() failed");
 770
 771         if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
 772             ftdi_error_return(-2, "libusb_get_device_list() failed");
 773
 774         /* XXX: This doesn't handle symlinks/odd paths/etc... */
 775         if (sscanf (description + 2, "%u/%u", &bus_number, &device_address) != 2)
 776             ftdi_error_return_free_device_list(-11, "illegal description format", devs);
 777
 778         while ((dev = devs[i++]) != NULL)
 779         {
 780             int ret;
 781             if (bus_number == libusb_get_bus_number (dev)
 782                 && device_address == libusb_get_device_address (dev))
 783             {
 784                 ret = ftdi_usb_open_dev(ftdi, dev);
 785                 libusb_free_device_list(devs,1);
 786                 return ret;
 787             }
 788         }
 789
 790         // device not found
 791         ftdi_error_return_free_device_list(-3, "device not found", devs);
 792     }
 793     else if (description[0] == 'i' || description[0] == 's')
 794     {
 795         unsigned int vendor;
 796         unsigned int product;
 797         unsigned int index=0;
 798         const char *serial=NULL;
 799         const char *startp, *endp;
 800
 801         errno=0;
 802         startp=description+2;
 803         vendor=strtoul((char*)startp,(char**)&endp,0);
 804         if (*endp != ':' || endp == startp || errno != 0)
 805             ftdi_error_return(-11, "illegal description format");
 806
 807         startp=endp+1;
 808         product=strtoul((char*)startp,(char**)&endp,0);
 809         if (endp == startp || errno != 0)
 810             ftdi_error_return(-11, "illegal description format");
 811
 812         if (description[0] == 'i' && *endp != 0)
 813         {
 814             /* optional index field in i-mode */
 815             if (*endp != ':')
 816                 ftdi_error_return(-11, "illegal description format");
 817
 818             startp=endp+1;
 819             index=strtoul((char*)startp,(char**)&endp,0);
 820             if (*endp != 0 || endp == startp || errno != 0)
 821                 ftdi_error_return(-11, "illegal description format");
 822         }
 823         if (description[0] == 's')
 824         {
 825             if (*endp != ':')
 826                 ftdi_error_return(-11, "illegal description format");
 827
 828             /* rest of the description is the serial */
 829             serial=endp+1;
 830         }
 831
 832         return ftdi_usb_open_desc_index(ftdi, vendor, product, NULL, serial, index);
 833     }
 834     else
 835     {
 836         ftdi_error_return(-11, "illegal description format");
 837     }
 838 }
 839
 840 /**
 841     Resets the ftdi device.
 842
 843     \param ftdi pointer to ftdi_context
 844
 845     \retval  0: all fine
 846     \retval -1: FTDI reset failed
 847     \retval -2: USB device unavailable
 848 */
 849 int ftdi_usb_reset(struct ftdi_context *ftdi)
 850 {
 851     if (ftdi == NULL || ftdi->usb_dev == NULL)
 852         ftdi_error_return(-2, "USB device unavailable");
 853
 854     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
 855                                 SIO_RESET_REQUEST, SIO_RESET_SIO,
 856                                 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
 857         ftdi_error_return(-1,"FTDI reset failed");
 858
 859     // Invalidate data in the readbuffer
 860     ftdi->readbuffer_offset = 0;
 861     ftdi->readbuffer_remaining = 0;
 862
 863     return 0;
 864 }
 865
 866 /**
 867     Clears the read buffer on the chip and the internal read buffer.
 868
 869     \param ftdi pointer to ftdi_context
 870
 871     \retval  0: all fine
 872     \retval -1: read buffer purge failed
 873     \retval -2: USB device unavailable
 874 */
 875 int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
 876 {
 877     if (ftdi == NULL || ftdi->usb_dev == NULL)
 878         ftdi_error_return(-2, "USB device unavailable");
 879
 880     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
 881                                 SIO_RESET_REQUEST, SIO_RESET_PURGE_RX,
 882                                 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
 883         ftdi_error_return(-1, "FTDI purge of RX buffer failed");
 884
 885     // Invalidate data in the readbuffer
 886     ftdi->readbuffer_offset = 0;
 887     ftdi->readbuffer_remaining = 0;
 888
 889     return 0;
 890 }
 891
 892 /**
 893     Clears the write buffer on the chip.
 894
 895     \param ftdi pointer to ftdi_context
 896
 897     \retval  0: all fine
 898     \retval -1: write buffer purge failed
 899     \retval -2: USB device unavailable
 900 */
 901 int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
 902 {
 903     if (ftdi == NULL || ftdi->usb_dev == NULL)
 904         ftdi_error_return(-2, "USB device unavailable");
 905
 906     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
 907                                 SIO_RESET_REQUEST, SIO_RESET_PURGE_TX,
 908                                 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
 909         ftdi_error_return(-1, "FTDI purge of TX buffer failed");
 910
 911     return 0;
 912 }
 913
 914 /**
 915     Clears the buffers on the chip and the internal read buffer.
 916
 917     \param ftdi pointer to ftdi_context
 918
 919     \retval  0: all fine
 920     \retval -1: read buffer purge failed
 921     \retval -2: write buffer purge failed
 922     \retval -3: USB device unavailable
 923 */
 924 int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
 925 {
 926     int result;
 927
 928     if (ftdi == NULL || ftdi->usb_dev == NULL)
 929         ftdi_error_return(-3, "USB device unavailable");
 930
 931     result = ftdi_usb_purge_rx_buffer(ftdi);
 932     if (result < 0)
 933         return -1;
 934
 935     result = ftdi_usb_purge_tx_buffer(ftdi);
 936     if (result < 0)
 937         return -2;
 938
 939     return 0;
 940 }
 941
 942
 943
 944 /**
 945     Closes the ftdi device. Call ftdi_deinit() if you're cleaning up.
 946
 947     \param ftdi pointer to ftdi_context
 948
 949     \retval  0: all fine
 950     \retval -1: usb_release failed
 951     \retval -3: ftdi context invalid
 952 */
 953 int ftdi_usb_close(struct ftdi_context *ftdi)
 954 {
 955     int rtn = 0;
 956
 957     if (ftdi == NULL)
 958         ftdi_error_return(-3, "ftdi context invalid");
 959
 960     if (ftdi->usb_dev != NULL)
 961         if (libusb_release_interface(ftdi->usb_dev, ftdi->interface) < 0)
 962             rtn = -1;
 963
 964     ftdi_usb_close_internal (ftdi);
 965
 966     return rtn;
 967 }
 968
 969 /**
 970     ftdi_convert_baudrate returns nearest supported baud rate to that requested.
 971     Function is only used internally
 972     \internal
 973 */
 974 static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
 975                                  unsigned short *value, unsigned short *index)
 976 {
 977     static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
 978     static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
 979     static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
 980     int divisor, best_divisor, best_baud, best_baud_diff;
 981     unsigned long encoded_divisor;
 982     int i;
 983
 984     if (baudrate <= 0)
 985     {
 986         // Return error
 987         return -1;
 988     }
 989
 990     divisor = 24000000 / baudrate;
 991
 992     if (ftdi->type == TYPE_AM)
 993     {
 994         // Round down to supported fraction (AM only)
 995         divisor -= am_adjust_dn[divisor & 7];
 996     }
 997
 998     // Try this divisor and the one above it (because division rounds down)
 999     best_divisor = 0;
1000     best_baud = 0;
1001     best_baud_diff = 0;
1002     for (i = 0; i < 2; i++)
1003     {
1004         int try_divisor = divisor + i;
1005         int baud_estimate;
1006         int baud_diff;
1007
1008         // Round up to supported divisor value
1009         if (try_divisor <= 8)
1010         {
1011             // Round up to minimum supported divisor
1012             try_divisor = 8;
1013         }
1014         else if (ftdi->type != TYPE_AM && try_divisor < 12)
1015         {
1016             // BM doesn't support divisors 9 through 11 inclusive
1017             try_divisor = 12;
1018         }
1019         else if (divisor < 16)
1020         {
1021             // AM doesn't support divisors 9 through 15 inclusive
1022             try_divisor = 16;
1023         }
1024         else
1025         {
1026             if (ftdi->type == TYPE_AM)
1027             {
1028                 // Round up to supported fraction (AM only)
1029                 try_divisor += am_adjust_up[try_divisor & 7];
1030                 if (try_divisor > 0x1FFF8)
1031                 {
1032                     // Round down to maximum supported divisor value (for AM)
1033                     try_divisor = 0x1FFF8;
1034                 }
1035             }
1036             else
1037             {
1038                 if (try_divisor > 0x1FFFF)
1039                 {
1040                     // Round down to maximum supported divisor value (for BM)
1041                     try_divisor = 0x1FFFF;
1042                 }
1043             }
1044         }
1045         // Get estimated baud rate (to nearest integer)
1046         baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
1047         // Get absolute difference from requested baud rate
1048         if (baud_estimate < baudrate)
1049         {
1050             baud_diff = baudrate - baud_estimate;
1051         }
1052         else
1053         {
1054             baud_diff = baud_estimate - baudrate;
1055         }
1056         if (i == 0 || baud_diff < best_baud_diff)
1057         {
1058             // Closest to requested baud rate so far
1059             best_divisor = try_divisor;
1060             best_baud = baud_estimate;
1061             best_baud_diff = baud_diff;
1062             if (baud_diff == 0)
1063             {
1064                 // Spot on! No point trying
1065                 break;
1066             }
1067         }
1068     }
1069     // Encode the best divisor value
1070     encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
1071     // Deal with special cases for encoded value
1072     if (encoded_divisor == 1)
1073     {
1074         encoded_divisor = 0;    // 3000000 baud
1075     }
1076     else if (encoded_divisor == 0x4001)
1077     {
1078         encoded_divisor = 1;    // 2000000 baud (BM only)
1079     }
1080     // Split into "value" and "index" values
1081     *value = (unsigned short)(encoded_divisor & 0xFFFF);
1082     if (ftdi->type == TYPE_2232C || ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H)
1083     {
1084         *index = (unsigned short)(encoded_divisor >> 8);
1085         *index &= 0xFF00;
1086         *index |= ftdi->index;
1087     }
1088     else
1089         *index = (unsigned short)(encoded_divisor >> 16);
1090
1091     // Return the nearest baud rate
1092     return best_baud;
1093 }
1094
1095 /**
1096     Sets the chip baud rate
1097
1098     \param ftdi pointer to ftdi_context
1099     \param baudrate baud rate to set
1100
1101     \retval  0: all fine
1102     \retval -1: invalid baudrate
1103     \retval -2: setting baudrate failed
1104     \retval -3: USB device unavailable
1105 */
1106 int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
1107 {
1108     unsigned short value, index;
1109     int actual_baudrate;
1110
1111     if (ftdi == NULL || ftdi->usb_dev == NULL)
1112         ftdi_error_return(-3, "USB device unavailable");
1113
1114     if (ftdi->bitbang_enabled)
1115     {
1116         baudrate = baudrate*4;
1117     }
1118
1119     actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
1120     if (actual_baudrate <= 0)
1121         ftdi_error_return (-1, "Silly baudrate <= 0.");
1122
1123     // Check within tolerance (about 5%)
1124     if ((actual_baudrate * 2 < baudrate /* Catch overflows */ )
1125             || ((actual_baudrate < baudrate)
1126                 ? (actual_baudrate * 21 < baudrate * 20)
1127                 : (baudrate * 21 < actual_baudrate * 20)))
1128         ftdi_error_return (-1, "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4");
1129
1130     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1131                                 SIO_SET_BAUDRATE_REQUEST, value,
1132                                 index, NULL, 0, ftdi->usb_write_timeout) < 0)
1133         ftdi_error_return (-2, "Setting new baudrate failed");
1134
1135     ftdi->baudrate = baudrate;
1136     return 0;
1137 }
1138
1139 /**
1140     Set (RS232) line characteristics.
1141     The break type can only be set via ftdi_set_line_property2()
1142     and defaults to "off".
1143
1144     \param ftdi pointer to ftdi_context
1145     \param bits Number of bits
1146     \param sbit Number of stop bits
1147     \param parity Parity mode
1148
1149     \retval  0: all fine
1150     \retval -1: Setting line property failed
1151 */
1152 int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
1153                            enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
1154 {
1155     return ftdi_set_line_property2(ftdi, bits, sbit, parity, BREAK_OFF);
1156 }
1157
1158 /**
1159     Set (RS232) line characteristics
1160
1161     \param ftdi pointer to ftdi_context
1162     \param bits Number of bits
1163     \param sbit Number of stop bits
1164     \param parity Parity mode
1165     \param break_type Break type
1166
1167     \retval  0: all fine
1168     \retval -1: Setting line property failed
1169     \retval -2: USB device unavailable
1170 */
1171 int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
1172                             enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity,
1173                             enum ftdi_break_type break_type)
1174 {
1175     unsigned short value = bits;
1176
1177     if (ftdi == NULL || ftdi->usb_dev == NULL)
1178         ftdi_error_return(-2, "USB device unavailable");
1179
1180     switch (parity)
1181     {
1182         case NONE:
1183             value |= (0x00 << 8);
1184             break;
1185         case ODD:
1186             value |= (0x01 << 8);
1187             break;
1188         case EVEN:
1189             value |= (0x02 << 8);
1190             break;
1191         case MARK:
1192             value |= (0x03 << 8);
1193             break;
1194         case SPACE:
1195             value |= (0x04 << 8);
1196             break;
1197     }
1198
1199     switch (sbit)
1200     {
1201         case STOP_BIT_1:
1202             value |= (0x00 << 11);
1203             break;
1204         case STOP_BIT_15:
1205             value |= (0x01 << 11);
1206             break;
1207         case STOP_BIT_2:
1208             value |= (0x02 << 11);
1209             break;
1210     }
1211
1212     switch (break_type)
1213     {
1214         case BREAK_OFF:
1215             value |= (0x00 << 14);
1216             break;
1217         case BREAK_ON:
1218             value |= (0x01 << 14);
1219             break;
1220     }
1221
1222     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1223                                 SIO_SET_DATA_REQUEST, value,
1224                                 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1225         ftdi_error_return (-1, "Setting new line property failed");
1226
1227     return 0;
1228 }
1229
1230 /**
1231     Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip
1232
1233     \param ftdi pointer to ftdi_context
1234     \param buf Buffer with the data
1235     \param size Size of the buffer
1236
1237     \retval -666: USB device unavailable
1238     \retval <0: error code from usb_bulk_write()
1239     \retval >0: number of bytes written
1240 */
1241 int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1242 {
1243     int offset = 0;
1244     int actual_length;
1245
1246     if (ftdi == NULL || ftdi->usb_dev == NULL)
1247         ftdi_error_return(-666, "USB device unavailable");
1248
1249     while (offset < size)
1250     {
1251         int write_size = ftdi->writebuffer_chunksize;
1252
1253         if (offset+write_size > size)
1254             write_size = size-offset;
1255
1256         if (libusb_bulk_transfer(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, &actual_length, ftdi->usb_write_timeout) < 0)
1257             ftdi_error_return(-1, "usb bulk write failed");
1258
1259         offset += actual_length;
1260     }
1261
1262     return offset;
1263 }
1264
1265 static void ftdi_read_data_cb(struct libusb_transfer *transfer)
1266 {
1267     struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1268     struct ftdi_context *ftdi = tc->ftdi;
1269     int packet_size, actual_length, num_of_chunks, chunk_remains, i, ret;
1270
1271     packet_size = ftdi->max_packet_size;
1272
1273     actual_length = transfer->actual_length;
1274
1275     if (actual_length > 2)
1276     {
1277         // skip FTDI status bytes.
1278         // Maybe stored in the future to enable modem use
1279         num_of_chunks = actual_length / packet_size;
1280         chunk_remains = actual_length % packet_size;
1281         //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);
1282
1283         ftdi->readbuffer_offset += 2;
1284         actual_length -= 2;
1285
1286         if (actual_length > packet_size - 2)
1287         {
1288             for (i = 1; i < num_of_chunks; i++)
1289               memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1290                        ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1291                        packet_size - 2);
1292             if (chunk_remains > 2)
1293             {
1294                 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1295                          ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1296                          chunk_remains-2);
1297                 actual_length -= 2*num_of_chunks;
1298             }
1299             else
1300               actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1301         }
1302
1303         if (actual_length > 0)
1304         {
1305             // data still fits in buf?
1306             if (tc->offset + actual_length <= tc->size)
1307             {
1308                 memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, actual_length);
1309                 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1310                 tc->offset += actual_length;
1311
1312                 ftdi->readbuffer_offset = 0;
1313                 ftdi->readbuffer_remaining = 0;
1314
1315                 /* Did we read exactly the right amount of bytes? */
1316                 if (tc->offset == tc->size)
1317                 {
1318                     //printf("read_data exact rem %d offset %d\n",
1319                     //ftdi->readbuffer_remaining, offset);
1320                     tc->completed = 1;
1321                     return;
1322                 }
1323             }
1324             else
1325             {
1326                 // only copy part of the data or size <= readbuffer_chunksize
1327                 int part_size = tc->size - tc->offset;
1328                 memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, part_size);
1329                 tc->offset += part_size;
1330
1331                 ftdi->readbuffer_offset += part_size;
1332                 ftdi->readbuffer_remaining = actual_length - part_size;
1333
1334                 /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1335                 part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
1336                 tc->completed = 1;
1337                 return;
1338             }
1339         }
1340     }
1341     ret = libusb_submit_transfer (transfer);
1342     if (ret < 0)
1343         tc->completed = 1;
1344 }
1345
1346
1347 static void ftdi_write_data_cb(struct libusb_transfer *transfer)
1348 {
1349     struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1350     struct ftdi_context *ftdi = tc->ftdi;
1351
1352     tc->offset += transfer->actual_length;
1353
1354     if (tc->offset == tc->size)
1355     {
1356         tc->completed = 1;
1357     }
1358     else
1359     {
1360         int write_size = ftdi->writebuffer_chunksize;
1361         int ret;
1362
1363         if (tc->offset + write_size > tc->size)
1364             write_size = tc->size - tc->offset;
1365
1366         transfer->length = write_size;
1367         transfer->buffer = tc->buf + tc->offset;
1368         ret = libusb_submit_transfer (transfer);
1369         if (ret < 0)
1370             tc->completed = 1;
1371     }
1372 }
1373
1374
1375 /**
1376     Writes data to the chip. Does not wait for completion of the transfer
1377     nor does it make sure that the transfer was successful.
1378
1379     Use libusb 1.0 asynchronous API.
1380
1381     \param ftdi pointer to ftdi_context
1382     \param buf Buffer with the data
1383     \param size Size of the buffer
1384
1385     \retval NULL: Some error happens when submit transfer
1386     \retval !NULL: Pointer to a ftdi_transfer_control
1387 */
1388
1389 struct ftdi_transfer_control *ftdi_write_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
1390 {
1391     struct ftdi_transfer_control *tc;
1392     struct libusb_transfer *transfer = libusb_alloc_transfer(0);
1393     int write_size, ret;
1394
1395     if (ftdi == NULL || ftdi->usb_dev == NULL)
1396     {
1397         libusb_free_transfer(transfer);
1398         return NULL;
1399     }
1400
1401     tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
1402
1403     if (!tc || !transfer)
1404         return NULL;
1405
1406     tc->ftdi = ftdi;
1407     tc->completed = 0;
1408     tc->buf = buf;
1409     tc->size = size;
1410     tc->offset = 0;
1411
1412     if (size < ftdi->writebuffer_chunksize)
1413       write_size = size;
1414     else
1415       write_size = ftdi->writebuffer_chunksize;
1416
1417     libusb_fill_bulk_transfer(transfer, ftdi->usb_dev, ftdi->in_ep, buf,
1418                               write_size, ftdi_write_data_cb, tc,
1419                               ftdi->usb_write_timeout);
1420     transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1421
1422     ret = libusb_submit_transfer(transfer);
1423     if (ret < 0)
1424     {
1425         libusb_free_transfer(transfer);
1426         tc->completed = 1;
1427         tc->transfer = NULL;
1428         return NULL;
1429     }
1430     tc->transfer = transfer;
1431
1432     return tc;
1433 }
1434
1435 /**
1436     Reads data from the chip. Does not wait for completion of the transfer
1437     nor does it make sure that the transfer was successful.
1438
1439     Use libusb 1.0 asynchronous API.
1440
1441     \param ftdi pointer to ftdi_context
1442     \param buf Buffer with the data
1443     \param size Size of the buffer
1444
1445     \retval NULL: Some error happens when submit transfer
1446     \retval !NULL: Pointer to a ftdi_transfer_control
1447 */
1448
1449 struct ftdi_transfer_control *ftdi_read_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
1450 {
1451     struct ftdi_transfer_control *tc;
1452     struct libusb_transfer *transfer;
1453     int ret;
1454
1455     if (ftdi == NULL || ftdi->usb_dev == NULL)
1456         return NULL;
1457
1458     tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
1459     if (!tc)
1460         return NULL;
1461
1462     tc->ftdi = ftdi;
1463     tc->buf = buf;
1464     tc->size = size;
1465
1466     if (size <= ftdi->readbuffer_remaining)
1467     {
1468         memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1469
1470         // Fix offsets
1471         ftdi->readbuffer_remaining -= size;
1472         ftdi->readbuffer_offset += size;
1473
1474         /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1475
1476         tc->completed = 1;
1477         tc->offset = size;
1478         tc->transfer = NULL;
1479         return tc;
1480     }
1481
1482     tc->completed = 0;
1483     if (ftdi->readbuffer_remaining != 0)
1484     {
1485         memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1486
1487         tc->offset = ftdi->readbuffer_remaining;
1488     }
1489     else
1490         tc->offset = 0;
1491
1492     transfer = libusb_alloc_transfer(0);
1493     if (!transfer)
1494     {
1495         free (tc);
1496         return NULL;
1497     }
1498
1499     ftdi->readbuffer_remaining = 0;
1500     ftdi->readbuffer_offset = 0;
1501
1502     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);
1503     transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1504
1505     ret = libusb_submit_transfer(transfer);
1506     if (ret < 0)
1507     {
1508         libusb_free_transfer(transfer);
1509         free (tc);
1510         return NULL;
1511     }
1512     tc->transfer = transfer;
1513
1514     return tc;
1515 }
1516
1517 /**
1518     Wait for completion of the transfer.
1519
1520     Use libusb 1.0 asynchronous API.
1521
1522     \param tc pointer to ftdi_transfer_control
1523
1524     \retval < 0: Some error happens
1525     \retval >= 0: Data size transferred
1526 */
1527
1528 int ftdi_transfer_data_done(struct ftdi_transfer_control *tc)
1529 {
1530     int ret;
1531
1532     while (!tc->completed)
1533     {
1534         ret = libusb_handle_events(tc->ftdi->usb_ctx);
1535         if (ret < 0)
1536         {
1537             if (ret == LIBUSB_ERROR_INTERRUPTED)
1538                 continue;
1539             libusb_cancel_transfer(tc->transfer);
1540             while (!tc->completed)
1541                 if (libusb_handle_events(tc->ftdi->usb_ctx) < 0)
1542                     break;
1543             libusb_free_transfer(tc->transfer);
1544             free (tc);
1545             return ret;
1546         }
1547     }
1548
1549     ret = tc->offset;
1550     /**
1551      * tc->transfer could be NULL if "(size <= ftdi->readbuffer_remaining)"
1552      * at ftdi_read_data_submit(). Therefore, we need to check it here.
1553      **/
1554     if (tc->transfer)
1555     {
1556         if (tc->transfer->status != LIBUSB_TRANSFER_COMPLETED)
1557             ret = -1;
1558         libusb_free_transfer(tc->transfer);
1559     }
1560     free(tc);
1561     return ret;
1562 }
1563
1564 /**
1565     Configure write buffer chunk size.
1566     Default is 4096.
1567
1568     \param ftdi pointer to ftdi_context
1569     \param chunksize Chunk size
1570
1571     \retval 0: all fine
1572     \retval -1: ftdi context invalid
1573 */
1574 int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1575 {
1576     if (ftdi == NULL)
1577         ftdi_error_return(-1, "ftdi context invalid");
1578
1579     ftdi->writebuffer_chunksize = chunksize;
1580     return 0;
1581 }
1582
1583 /**
1584     Get write buffer chunk size.
1585
1586     \param ftdi pointer to ftdi_context
1587     \param chunksize Pointer to store chunk size in
1588
1589     \retval 0: all fine
1590     \retval -1: ftdi context invalid
1591 */
1592 int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1593 {
1594     if (ftdi == NULL)
1595         ftdi_error_return(-1, "ftdi context invalid");
1596
1597     *chunksize = ftdi->writebuffer_chunksize;
1598     return 0;
1599 }
1600
1601 /**
1602     Reads data in chunks (see ftdi_read_data_set_chunksize()) from the chip.
1603
1604     Automatically strips the two modem status bytes transfered during every read.
1605
1606     \param ftdi pointer to ftdi_context
1607     \param buf Buffer to store data in
1608     \param size Size of the buffer
1609
1610     \retval -666: USB device unavailable
1611     \retval <0: error code from libusb_bulk_transfer()
1612     \retval  0: no data was available
1613     \retval >0: number of bytes read
1614
1615 */
1616 int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1617 {
1618     int offset = 0, ret, i, num_of_chunks, chunk_remains;
1619     int packet_size = ftdi->max_packet_size;
1620     int actual_length = 1;
1621
1622     if (ftdi == NULL || ftdi->usb_dev == NULL)
1623         ftdi_error_return(-666, "USB device unavailable");
1624
1625     // Packet size sanity check (avoid division by zero)
1626     if (packet_size == 0)
1627         ftdi_error_return(-1, "max_packet_size is bogus (zero)");
1628
1629     // everything we want is still in the readbuffer?
1630     if (size <= ftdi->readbuffer_remaining)
1631     {
1632         memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1633
1634         // Fix offsets
1635         ftdi->readbuffer_remaining -= size;
1636         ftdi->readbuffer_offset += size;
1637
1638         /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1639
1640         return size;
1641     }
1642     // something still in the readbuffer, but not enough to satisfy 'size'?
1643     if (ftdi->readbuffer_remaining != 0)
1644     {
1645         memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1646
1647         // Fix offset
1648         offset += ftdi->readbuffer_remaining;
1649     }
1650     // do the actual USB read
1651     while (offset < size && actual_length > 0)
1652     {
1653         ftdi->readbuffer_remaining = 0;
1654         ftdi->readbuffer_offset = 0;
1655         /* returns how much received */
1656         ret = libusb_bulk_transfer (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, &actual_length, ftdi->usb_read_timeout);
1657         if (ret < 0)
1658             ftdi_error_return(ret, "usb bulk read failed");
1659
1660         if (actual_length > 2)
1661         {
1662             // skip FTDI status bytes.
1663             // Maybe stored in the future to enable modem use
1664             num_of_chunks = actual_length / packet_size;
1665             chunk_remains = actual_length % packet_size;
1666             //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);
1667
1668             ftdi->readbuffer_offset += 2;
1669             actual_length -= 2;
1670
1671             if (actual_length > packet_size - 2)
1672             {
1673                 for (i = 1; i < num_of_chunks; i++)
1674                     memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1675                              ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1676                              packet_size - 2);
1677                 if (chunk_remains > 2)
1678                 {
1679                     memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1680                              ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1681                              chunk_remains-2);
1682                     actual_length -= 2*num_of_chunks;
1683                 }
1684                 else
1685                     actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1686             }
1687         }
1688         else if (actual_length <= 2)
1689         {
1690             // no more data to read?
1691             return offset;
1692         }
1693         if (actual_length > 0)
1694         {
1695             // data still fits in buf?
1696             if (offset+actual_length <= size)
1697             {
1698                 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, actual_length);
1699                 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1700                 offset += actual_length;
1701
1702                 /* Did we read exactly the right amount of bytes? */
1703                 if (offset == size)
1704                     //printf("read_data exact rem %d offset %d\n",
1705                     //ftdi->readbuffer_remaining, offset);
1706                     return offset;
1707             }
1708             else
1709             {
1710                 // only copy part of the data or size <= readbuffer_chunksize
1711                 int part_size = size-offset;
1712                 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
1713
1714                 ftdi->readbuffer_offset += part_size;
1715                 ftdi->readbuffer_remaining = actual_length-part_size;
1716                 offset += part_size;
1717
1718                 /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1719                 part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
1720
1721                 return offset;
1722             }
1723         }
1724     }
1725     // never reached
1726     return -127;
1727 }
1728
1729 /**
1730     Configure read buffer chunk size.
1731     Default is 4096.
1732
1733     Automatically reallocates the buffer.
1734
1735     \param ftdi pointer to ftdi_context
1736     \param chunksize Chunk size
1737
1738     \retval 0: all fine
1739     \retval -1: ftdi context invalid
1740 */
1741 int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1742 {
1743     unsigned char *new_buf;
1744
1745     if (ftdi == NULL)
1746         ftdi_error_return(-1, "ftdi context invalid");
1747
1748     // Invalidate all remaining data
1749     ftdi->readbuffer_offset = 0;
1750     ftdi->readbuffer_remaining = 0;
1751 #ifdef __linux__
1752     /* We can't set readbuffer_chunksize larger than MAX_BULK_BUFFER_LENGTH,
1753        which is defined in libusb-1.0.  Otherwise, each USB read request will
1754        be divided into multiple URBs.  This will cause issues on Linux kernel
1755        older than 2.6.32.  */
1756     if (chunksize > 16384)
1757         chunksize = 16384;
1758 #endif
1759
1760     if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL)
1761         ftdi_error_return(-1, "out of memory for readbuffer");
1762
1763     ftdi->readbuffer = new_buf;
1764     ftdi->readbuffer_chunksize = chunksize;
1765
1766     return 0;
1767 }
1768
1769 /**
1770     Get read buffer chunk size.
1771
1772     \param ftdi pointer to ftdi_context
1773     \param chunksize Pointer to store chunk size in
1774
1775     \retval 0: all fine
1776     \retval -1: FTDI context invalid
1777 */
1778 int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1779 {
1780     if (ftdi == NULL)
1781         ftdi_error_return(-1, "FTDI context invalid");
1782
1783     *chunksize = ftdi->readbuffer_chunksize;
1784     return 0;
1785 }
1786
1787
1788 /**
1789     Enable bitbang mode.
1790
1791     \deprecated use \ref ftdi_set_bitmode with mode BITMODE_BITBANG instead
1792
1793     \param ftdi pointer to ftdi_context
1794     \param bitmask Bitmask to configure lines.
1795            HIGH/ON value configures a line as output.
1796
1797     \retval  0: all fine
1798     \retval -1: can't enable bitbang mode
1799     \retval -2: USB device unavailable
1800 */
1801 int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask)
1802 {
1803     unsigned short usb_val;
1804
1805     if (ftdi == NULL || ftdi->usb_dev == NULL)
1806         ftdi_error_return(-2, "USB device unavailable");
1807
1808     usb_val = bitmask; // low byte: bitmask
1809     /* FT2232C: Set bitbang_mode to 2 to enable SPI */
1810     usb_val |= (ftdi->bitbang_mode << 8);
1811
1812     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1813                                 SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index,
1814                                 NULL, 0, ftdi->usb_write_timeout) < 0)
1815         ftdi_error_return(-1, "unable to enter bitbang mode. Perhaps not a BM type chip?");
1816
1817     ftdi->bitbang_enabled = 1;
1818     return 0;
1819 }
1820
1821 /**
1822     Disable bitbang mode.
1823
1824     \param ftdi pointer to ftdi_context
1825
1826     \retval  0: all fine
1827     \retval -1: can't disable bitbang mode
1828     \retval -2: USB device unavailable
1829 */
1830 int ftdi_disable_bitbang(struct ftdi_context *ftdi)
1831 {
1832     if (ftdi == NULL || ftdi->usb_dev == NULL)
1833         ftdi_error_return(-2, "USB device unavailable");
1834
1835     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)
1836         ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?");
1837
1838     ftdi->bitbang_enabled = 0;
1839     return 0;
1840 }
1841
1842 /**
1843     Enable/disable bitbang modes.
1844
1845     \param ftdi pointer to ftdi_context
1846     \param bitmask Bitmask to configure lines.
1847            HIGH/ON value configures a line as output.
1848     \param mode Bitbang mode: use the values defined in \ref ftdi_mpsse_mode
1849
1850     \retval  0: all fine
1851     \retval -1: can't enable bitbang mode
1852     \retval -2: USB device unavailable
1853 */
1854 int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
1855 {
1856     unsigned short usb_val;
1857
1858     if (ftdi == NULL || ftdi->usb_dev == NULL)
1859         ftdi_error_return(-2, "USB device unavailable");
1860
1861     usb_val = bitmask; // low byte: bitmask
1862     usb_val |= (mode << 8);
1863     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)
1864         ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps not a 2232C type chip?");
1865
1866     ftdi->bitbang_mode = mode;
1867     ftdi->bitbang_enabled = (mode == BITMODE_RESET) ? 0 : 1;
1868     return 0;
1869 }
1870
1871 /**
1872     Directly read pin state, circumventing the read buffer. Useful for bitbang mode.
1873
1874     \param ftdi pointer to ftdi_context
1875     \param pins Pointer to store pins into
1876
1877     \retval  0: all fine
1878     \retval -1: read pins failed
1879     \retval -2: USB device unavailable
1880 */
1881 int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
1882 {
1883     if (ftdi == NULL || ftdi->usb_dev == NULL)
1884         ftdi_error_return(-2, "USB device unavailable");
1885
1886     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)
1887         ftdi_error_return(-1, "read pins failed");
1888
1889     return 0;
1890 }
1891
1892 /**
1893     Set latency timer
1894
1895     The FTDI chip keeps data in the internal buffer for a specific
1896     amount of time if the buffer is not full yet to decrease
1897     load on the usb bus.
1898
1899     \param ftdi pointer to ftdi_context
1900     \param latency Value between 1 and 255
1901
1902     \retval  0: all fine
1903     \retval -1: latency out of range
1904     \retval -2: unable to set latency timer
1905     \retval -3: USB device unavailable
1906 */
1907 int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
1908 {
1909     unsigned short usb_val;
1910
1911     if (latency < 1)
1912         ftdi_error_return(-1, "latency out of range. Only valid for 1-255");
1913
1914     if (ftdi == NULL || ftdi->usb_dev == NULL)
1915         ftdi_error_return(-3, "USB device unavailable");
1916
1917     usb_val = latency;
1918     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)
1919         ftdi_error_return(-2, "unable to set latency timer");
1920
1921     return 0;
1922 }
1923
1924 /**
1925     Get latency timer
1926
1927     \param ftdi pointer to ftdi_context
1928     \param latency Pointer to store latency value in
1929
1930     \retval  0: all fine
1931     \retval -1: unable to get latency timer
1932     \retval -2: USB device unavailable
1933 */
1934 int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
1935 {
1936     unsigned short usb_val;
1937
1938     if (ftdi == NULL || ftdi->usb_dev == NULL)
1939         ftdi_error_return(-2, "USB device unavailable");
1940
1941     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)
1942         ftdi_error_return(-1, "reading latency timer failed");
1943
1944     *latency = (unsigned char)usb_val;
1945     return 0;
1946 }
1947
1948 /**
1949     Poll modem status information
1950
1951     This function allows the retrieve the two status bytes of the device.
1952     The device sends these bytes also as a header for each read access
1953     where they are discarded by ftdi_read_data(). The chip generates
1954     the two stripped status bytes in the absence of data every 40 ms.
1955
1956     Layout of the first byte:
1957     - B0..B3 - must be 0
1958     - B4       Clear to send (CTS)
1959                  0 = inactive
1960                  1 = active
1961     - B5       Data set ready (DTS)
1962                  0 = inactive
1963                  1 = active
1964     - B6       Ring indicator (RI)
1965                  0 = inactive
1966                  1 = active
1967     - B7       Receive line signal detect (RLSD)
1968                  0 = inactive
1969                  1 = active
1970
1971     Layout of the second byte:
1972     - B0       Data ready (DR)
1973     - B1       Overrun error (OE)
1974     - B2       Parity error (PE)
1975     - B3       Framing error (FE)
1976     - B4       Break interrupt (BI)
1977     - B5       Transmitter holding register (THRE)
1978     - B6       Transmitter empty (TEMT)
1979     - B7       Error in RCVR FIFO
1980
1981     \param ftdi pointer to ftdi_context
1982     \param status Pointer to store status information in. Must be two bytes.
1983
1984     \retval  0: all fine
1985     \retval -1: unable to retrieve status information
1986     \retval -2: USB device unavailable
1987 */
1988 int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
1989 {
1990     char usb_val[2];
1991
1992     if (ftdi == NULL || ftdi->usb_dev == NULL)
1993         ftdi_error_return(-2, "USB device unavailable");
1994
1995     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)
1996         ftdi_error_return(-1, "getting modem status failed");
1997
1998     *status = (usb_val[1] << 8) | usb_val[0];
1999
2000     return 0;
2001 }
2002
2003 /**
2004     Set flowcontrol for ftdi chip
2005
2006     \param ftdi pointer to ftdi_context
2007     \param flowctrl flow control to use. should be
2008            SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS or SIO_XON_XOFF_HS
2009
2010     \retval  0: all fine
2011     \retval -1: set flow control failed
2012     \retval -2: USB device unavailable
2013 */
2014 int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
2015 {
2016     if (ftdi == NULL || ftdi->usb_dev == NULL)
2017         ftdi_error_return(-2, "USB device unavailable");
2018
2019     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2020                                 SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->index),
2021                                 NULL, 0, ftdi->usb_write_timeout) < 0)
2022         ftdi_error_return(-1, "set flow control failed");
2023
2024     return 0;
2025 }
2026
2027 /**
2028     Set dtr line
2029
2030     \param ftdi pointer to ftdi_context
2031     \param state state to set line to (1 or 0)
2032
2033     \retval  0: all fine
2034     \retval -1: set dtr failed
2035     \retval -2: USB device unavailable
2036 */
2037 int ftdi_setdtr(struct ftdi_context *ftdi, int state)
2038 {
2039     unsigned short usb_val;
2040
2041     if (ftdi == NULL || ftdi->usb_dev == NULL)
2042         ftdi_error_return(-2, "USB device unavailable");
2043
2044     if (state)
2045         usb_val = SIO_SET_DTR_HIGH;
2046     else
2047         usb_val = SIO_SET_DTR_LOW;
2048
2049     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2050                                 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2051                                 NULL, 0, ftdi->usb_write_timeout) < 0)
2052         ftdi_error_return(-1, "set dtr failed");
2053
2054     return 0;
2055 }
2056
2057 /**
2058     Set rts line
2059
2060     \param ftdi pointer to ftdi_context
2061     \param state state to set line to (1 or 0)
2062
2063     \retval  0: all fine
2064     \retval -1: set rts failed
2065     \retval -2: USB device unavailable
2066 */
2067 int ftdi_setrts(struct ftdi_context *ftdi, int state)
2068 {
2069     unsigned short usb_val;
2070
2071     if (ftdi == NULL || ftdi->usb_dev == NULL)
2072         ftdi_error_return(-2, "USB device unavailable");
2073
2074     if (state)
2075         usb_val = SIO_SET_RTS_HIGH;
2076     else
2077         usb_val = SIO_SET_RTS_LOW;
2078
2079     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2080                                 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2081                                 NULL, 0, ftdi->usb_write_timeout) < 0)
2082         ftdi_error_return(-1, "set of rts failed");
2083
2084     return 0;
2085 }
2086
2087 /**
2088     Set dtr and rts line in one pass
2089
2090     \param ftdi pointer to ftdi_context
2091     \param dtr  DTR state to set line to (1 or 0)
2092     \param rts  RTS state to set line to (1 or 0)
2093
2094     \retval  0: all fine
2095     \retval -1: set dtr/rts failed
2096     \retval -2: USB device unavailable
2097  */
2098 int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
2099 {
2100     unsigned short usb_val;
2101
2102     if (ftdi == NULL || ftdi->usb_dev == NULL)
2103         ftdi_error_return(-2, "USB device unavailable");
2104
2105     if (dtr)
2106         usb_val = SIO_SET_DTR_HIGH;
2107     else
2108         usb_val = SIO_SET_DTR_LOW;
2109
2110     if (rts)
2111         usb_val |= SIO_SET_RTS_HIGH;
2112     else
2113         usb_val |= SIO_SET_RTS_LOW;
2114
2115     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2116                                 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2117                                 NULL, 0, ftdi->usb_write_timeout) < 0)
2118         ftdi_error_return(-1, "set of rts/dtr failed");
2119
2120     return 0;
2121 }
2122
2123 /**
2124     Set the special event character
2125
2126     \param ftdi pointer to ftdi_context
2127     \param eventch Event character
2128     \param enable 0 to disable the event character, non-zero otherwise
2129
2130     \retval  0: all fine
2131     \retval -1: unable to set event character
2132     \retval -2: USB device unavailable
2133 */
2134 int ftdi_set_event_char(struct ftdi_context *ftdi,
2135                         unsigned char eventch, unsigned char enable)
2136 {
2137     unsigned short usb_val;
2138
2139     if (ftdi == NULL || ftdi->usb_dev == NULL)
2140         ftdi_error_return(-2, "USB device unavailable");
2141
2142     usb_val = eventch;
2143     if (enable)
2144         usb_val |= 1 << 8;
2145
2146     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)
2147         ftdi_error_return(-1, "setting event character failed");
2148
2149     return 0;
2150 }
2151
2152 /**
2153     Set error character
2154
2155     \param ftdi pointer to ftdi_context
2156     \param errorch Error character
2157     \param enable 0 to disable the error character, non-zero otherwise
2158
2159     \retval  0: all fine
2160     \retval -1: unable to set error character
2161     \retval -2: USB device unavailable
2162 */
2163 int ftdi_set_error_char(struct ftdi_context *ftdi,
2164                         unsigned char errorch, unsigned char enable)
2165 {
2166     unsigned short usb_val;
2167
2168     if (ftdi == NULL || ftdi->usb_dev == NULL)
2169         ftdi_error_return(-2, "USB device unavailable");
2170
2171     usb_val = errorch;
2172     if (enable)
2173         usb_val |= 1 << 8;
2174
2175     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)
2176         ftdi_error_return(-1, "setting error character failed");
2177
2178     return 0;
2179 }
2180
2181 /**
2182     Init eeprom with default values.
2183     \param ftdi pointer to ftdi_context
2184     \param manufacturer String to use as Manufacturer
2185     \param product String to use as Product description
2186     \param serial String to use as Serial number description
2187
2188     \retval  0: all fine
2189     \retval -1: No struct ftdi_context
2190     \retval -2: No struct ftdi_eeprom
2191 */
2192 int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer,
2193                               char * product, char * serial)
2194 {
2195     struct ftdi_eeprom *eeprom;
2196
2197     if (ftdi == NULL)
2198         ftdi_error_return(-1, "No struct ftdi_context");
2199
2200     if (ftdi->eeprom == NULL)
2201         ftdi_error_return(-2,"No struct ftdi_eeprom");
2202
2203     eeprom = ftdi->eeprom;
2204     memset(eeprom, 0, sizeof(struct ftdi_eeprom));
2205
2206     eeprom->vendor_id = 0x0403;
2207     eeprom->use_serial = USE_SERIAL_NUM;
2208     if((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM) ||
2209        (ftdi->type == TYPE_R))
2210         eeprom->product_id = 0x6001;
2211     else
2212         eeprom->product_id = 0x6010;
2213     if (ftdi->type == TYPE_AM)
2214         eeprom->usb_version = 0x0101;
2215     else
2216         eeprom->usb_version = 0x0200;
2217     eeprom->max_power = 100;
2218
2219     if (eeprom->manufacturer)
2220         free (eeprom->manufacturer);
2221     eeprom->manufacturer = NULL;
2222     if (manufacturer)
2223     {
2224         eeprom->manufacturer = malloc(strlen(manufacturer)+1);
2225         if (eeprom->manufacturer)
2226             strcpy(eeprom->manufacturer, manufacturer);
2227     }
2228
2229     if (eeprom->product)
2230         free (eeprom->product);
2231     eeprom->product = NULL;
2232     {
2233         eeprom->product = malloc(strlen(product)+1);
2234         if (eeprom->product)
2235             strcpy(eeprom->product, product);
2236     }
2237
2238     if (eeprom->serial)
2239         free (eeprom->serial);
2240     eeprom->serial = NULL;
2241     if (serial)
2242     {
2243         eeprom->serial = malloc(strlen(serial)+1);
2244         if (eeprom->serial)
2245             strcpy(eeprom->serial, serial);
2246     }
2247
2248
2249     if(ftdi->type == TYPE_R)
2250     {
2251         eeprom->max_power = 90;
2252         eeprom->size = 0x80;
2253         eeprom->cbus_function[0] = CBUS_TXLED;
2254         eeprom->cbus_function[1] = CBUS_RXLED;
2255         eeprom->cbus_function[2] = CBUS_TXDEN;
2256         eeprom->cbus_function[3] = CBUS_PWREN;
2257         eeprom->cbus_function[4] = CBUS_SLEEP;
2258     }
2259     else
2260         eeprom->size = -1;
2261     return 0;
2262 }
2263
2264 /**
2265     Build binary buffer from ftdi_eeprom structure.
2266     Output is suitable for ftdi_write_eeprom().
2267
2268     \param ftdi pointer to ftdi_context
2269
2270     \retval >0: free eeprom size
2271     \retval -1: eeprom size (128 bytes) exceeded by custom strings
2272     \retval -2: Invalid eeprom pointer
2273     \retval -3: Invalid cbus function setting
2274     \retval -4: Chip doesn't support invert
2275     \retval -5: Chip doesn't support high current drive
2276     \retval -6: No connected EEPROM or EEPROM Type unknown
2277 */
2278 int ftdi_eeprom_build(struct ftdi_context *ftdi)
2279 {
2280     unsigned char i, j, eeprom_size_mask;
2281     unsigned short checksum, value;
2282     unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2283     int size_check;
2284     struct ftdi_eeprom *eeprom;
2285     unsigned char * output;
2286
2287     if (ftdi == NULL)
2288         ftdi_error_return(-2,"No context");
2289     if (ftdi->eeprom == NULL)
2290         ftdi_error_return(-2,"No eeprom structure");
2291
2292     eeprom= ftdi->eeprom;
2293     output = eeprom->buf;
2294
2295     if(eeprom->chip == -1)
2296         ftdi_error_return(-5,"No connected EEPROM or EEPROM type unknown");
2297
2298     if ((eeprom->chip == 0x56) || (eeprom->chip == 0x66))
2299         eeprom->size = 0x100;
2300     else
2301         eeprom->size = 0x80;
2302
2303     if (eeprom->manufacturer != NULL)
2304         manufacturer_size = strlen(eeprom->manufacturer);
2305     if (eeprom->product != NULL)
2306         product_size = strlen(eeprom->product);
2307     if (eeprom->serial != NULL)
2308         serial_size = strlen(eeprom->serial);
2309
2310     size_check = 0x80;
2311     switch(ftdi->type)
2312     {
2313     case TYPE_2232H:
2314     case TYPE_4232H:
2315         size_check -= 4;
2316     case TYPE_R:
2317         size_check -= 4;
2318     case TYPE_2232C:
2319         size_check -= 4;
2320     case TYPE_AM:
2321     case TYPE_BM:
2322         size_check -= 0x14*2;
2323     }
2324
2325     size_check -= manufacturer_size*2;
2326     size_check -= product_size*2;
2327     size_check -= serial_size*2;
2328
2329     /* Space for the string type and pointer bytes */
2330     size_check -= -9;
2331
2332     // eeprom size exceeded?
2333     if (size_check < 0)
2334         return (-1);
2335
2336     // empty eeprom
2337     memset (ftdi->eeprom->buf, 0, FTDI_MAX_EEPROM_SIZE);
2338
2339     // Bytes and Bits set for all Types
2340
2341     // Addr 02: Vendor ID
2342     output[0x02] = eeprom->vendor_id;
2343     output[0x03] = eeprom->vendor_id >> 8;
2344
2345     // Addr 04: Product ID
2346     output[0x04] = eeprom->product_id;
2347     output[0x05] = eeprom->product_id >> 8;
2348
2349     // Addr 06: Device release number (0400h for BM features)
2350     output[0x06] = 0x00;
2351     switch (ftdi->type) {
2352         case TYPE_AM:
2353             output[0x07] = 0x02;
2354             break;
2355         case TYPE_BM:
2356             output[0x07] = 0x04;
2357             break;
2358         case TYPE_2232C:
2359             output[0x07] = 0x05;
2360             break;
2361         case TYPE_R:
2362             output[0x07] = 0x06;
2363             break;
2364          case TYPE_2232H:
2365             output[0x07] = 0x07;
2366             break;
2367          case TYPE_4232H:
2368             output[0x07] = 0x08;
2369             break;
2370         default:
2371             output[0x07] = 0x00;
2372     }
2373
2374     // Addr 08: Config descriptor
2375     // Bit 7: always 1
2376     // Bit 6: 1 if this device is self powered, 0 if bus powered
2377     // Bit 5: 1 if this device uses remote wakeup
2378     // Bit 4-0: reserved - 0
2379     j = 0x80;
2380     if (eeprom->self_powered == 1)
2381         j |= 0x40;
2382     if (eeprom->remote_wakeup == 1)
2383         j |= 0x20;
2384     output[0x08] = j;
2385
2386     // Addr 09: Max power consumption: max power = value * 2 mA
2387     output[0x09] = eeprom->max_power>>1;
2388
2389     if(ftdi->type != TYPE_AM)
2390     {
2391         // Addr 0A: Chip configuration
2392         // Bit 7: 0 - reserved
2393         // Bit 6: 0 - reserved
2394         // Bit 5: 0 - reserved
2395         // Bit 4: 1 - Change USB version
2396         // Bit 3: 1 - Use the serial number string
2397         // Bit 2: 1 - Enable suspend pull downs for lower power
2398         // Bit 1: 1 - Out EndPoint is Isochronous
2399         // Bit 0: 1 - In EndPoint is Isochronous
2400         //
2401         j = 0;
2402         if (eeprom->in_is_isochronous == 1)
2403             j = j | 1;
2404         if (eeprom->out_is_isochronous == 1)
2405             j = j | 2;
2406         output[0x0A] = j;
2407     }
2408
2409     // Dynamic content
2410     // Strings start at 0x94 (TYPE_AM, TYPE_BM)
2411     // 0x96 (TYPE_2232C), 0x98 (TYPE_R) and 0x9a (TYPE_x232H)
2412     i = 0;
2413     switch(ftdi->type)
2414     {
2415     case TYPE_2232H:
2416     case TYPE_4232H:
2417         i += 2;
2418     case TYPE_R:
2419         i += 2;
2420     case TYPE_2232C:
2421         i += 2;
2422     case TYPE_AM:
2423     case TYPE_BM:
2424         i += 0x94;
2425     }
2426     /* Wrap around 0x80 for 128 byte EEPROMS (Internale and 93x46) */
2427     eeprom_size_mask = eeprom->size -1;
2428
2429     // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2430     // Addr 0F: Length of manufacturer string
2431     // Output manufacturer
2432     output[0x0E] = i;  // calculate offset
2433     output[i & eeprom_size_mask] = manufacturer_size*2 + 2, i++;
2434     output[i & eeprom_size_mask] = 0x03, i++; // type: string
2435     for (j = 0; j < manufacturer_size; j++)
2436     {
2437         output[i & eeprom_size_mask] = eeprom->manufacturer[j], i++;
2438         output[i & eeprom_size_mask] = 0x00, i++;
2439     }
2440     output[0x0F] = manufacturer_size*2 + 2;
2441
2442     // Addr 10: Offset of the product string + 0x80, calculated later
2443     // Addr 11: Length of product string
2444     output[0x10] = i | 0x80;  // calculate offset
2445     output[i & eeprom_size_mask] = product_size*2 + 2, i++;
2446     output[i & eeprom_size_mask] = 0x03, i++;
2447     for (j = 0; j < product_size; j++)
2448     {
2449         output[i & eeprom_size_mask] = eeprom->product[j], i++;
2450         output[i & eeprom_size_mask] = 0x00, i++;
2451     }
2452     output[0x11] = product_size*2 + 2;
2453
2454     // Addr 12: Offset of the serial string + 0x80, calculated later
2455     // Addr 13: Length of serial string
2456     output[0x12] = i | 0x80; // calculate offset
2457     output[i & eeprom_size_mask] = serial_size*2 + 2, i++;
2458     output[i & eeprom_size_mask] = 0x03, i++;
2459     for (j = 0; j < serial_size; j++)
2460     {
2461         output[i & eeprom_size_mask] = eeprom->serial[j], i++;
2462         output[i & eeprom_size_mask] = 0x00, i++;
2463     }
2464     output[i & eeprom_size_mask] = 0x02; /* as seen when written with FTD2XX */
2465     i++;
2466     output[i & eeprom_size_mask] = 0x03; /* as seen when written with FTD2XX */
2467     i++;
2468     output[i & eeprom_size_mask] = eeprom->is_not_pnp; /* as seen when written with FTD2XX */
2469     i++;
2470
2471     output[0x13] = serial_size*2 + 2;
2472
2473     if(ftdi->type > TYPE_AM) /*use_serial not used in AM devices*/
2474     {
2475         if (eeprom->use_serial == USE_SERIAL_NUM )
2476             output[0x0A] |= USE_SERIAL_NUM;
2477         else
2478             output[0x0A] &= ~USE_SERIAL_NUM;
2479     }
2480     /* Fixme: ftd2xx seems to append 0x02, 0x03 and 0x01 for PnP = 0 or 0x00 else */
2481     // calculate checksum
2482
2483     /* Bytes and Bits specific to (some) types
2484        Write linear, as this allows easier fixing*/
2485     switch(ftdi->type)
2486     {
2487     case TYPE_AM:
2488         break;
2489     case TYPE_BM:
2490         output[0x0C] = eeprom->usb_version & 0xff;
2491         output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2492         output[0x14] = eeprom->chip;
2493         break;
2494     case TYPE_2232C:
2495
2496         output[0x00] = (eeprom->channel_a_type);
2497         if ( eeprom->channel_a_driver == DRIVER_VCP)
2498             output[0x00] |= DRIVER_VCP;
2499         else
2500             output[0x00] &= ~DRIVER_VCP;
2501
2502         if ( eeprom->high_current_a == HIGH_CURRENT_DRIVE)
2503             output[0x00] |= HIGH_CURRENT_DRIVE;
2504         else
2505             output[0x00] &= ~HIGH_CURRENT_DRIVE;
2506
2507         output[0x01] = (eeprom->channel_b_type);
2508         if ( eeprom->channel_b_driver == DRIVER_VCP)
2509             output[0x01] |= DRIVER_VCP;
2510         else
2511             output[0x01] &= ~DRIVER_VCP;
2512
2513         if ( eeprom->high_current_b == HIGH_CURRENT_DRIVE)
2514             output[0x01] |= HIGH_CURRENT_DRIVE;
2515         else
2516             output[0x01] &= ~HIGH_CURRENT_DRIVE;
2517
2518         if (eeprom->in_is_isochronous == 1)
2519             output[0x0A] |= 0x1;
2520         else
2521             output[0x0A] &= ~0x1;
2522         if (eeprom->out_is_isochronous == 1)
2523             output[0x0A] |= 0x2;
2524         else
2525             output[0x0A] &= ~0x2;
2526         if (eeprom->suspend_pull_downs == 1)
2527             output[0x0A] |= 0x4;
2528         else
2529             output[0x0A] &= ~0x4;
2530         output[0x0C] = eeprom->usb_version & 0xff;
2531         output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2532         output[0x14] = eeprom->chip;
2533         break;
2534     case TYPE_R:
2535         if(eeprom->high_current == HIGH_CURRENT_DRIVE_R)
2536             output[0x00] |= HIGH_CURRENT_DRIVE_R;
2537         output[0x01] = 0x40; /* Hard coded Endpoint Size*/
2538
2539         if (eeprom->suspend_pull_downs == 1)
2540             output[0x0A] |= 0x4;
2541         else
2542             output[0x0A] &= ~0x4;
2543         output[0x0B] = eeprom->invert;
2544         output[0x0C] = eeprom->usb_version & 0xff;
2545         output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2546
2547         if(eeprom->cbus_function[0] > CBUS_BB)
2548             output[0x14] = CBUS_TXLED;
2549         else
2550             output[0x14] = eeprom->cbus_function[0];
2551
2552         if(eeprom->cbus_function[1] > CBUS_BB)
2553             output[0x14] |= CBUS_RXLED<<4;
2554         else
2555             output[0x14] |= eeprom->cbus_function[1]<<4;
2556
2557         if(eeprom->cbus_function[2] > CBUS_BB)
2558             output[0x15] = CBUS_TXDEN;
2559         else
2560             output[0x15] = eeprom->cbus_function[2];
2561
2562         if(eeprom->cbus_function[3] > CBUS_BB)
2563             output[0x15] |= CBUS_PWREN<<4;
2564         else
2565             output[0x15] |= eeprom->cbus_function[3]<<4;
2566
2567         if(eeprom->cbus_function[4] > CBUS_CLK6)
2568             output[0x16] = CBUS_SLEEP;
2569         else
2570             output[0x16] = eeprom->cbus_function[4];
2571         break;
2572     case TYPE_2232H:
2573         output[0x00] = (eeprom->channel_a_type);
2574         if ( eeprom->channel_a_driver == DRIVER_VCP)
2575             output[0x00] |= DRIVER_VCP;
2576         else
2577             output[0x00] &= ~DRIVER_VCP;
2578
2579         output[0x01] = (eeprom->channel_b_type);
2580         if ( eeprom->channel_b_driver == DRIVER_VCP)
2581             output[0x01] |= DRIVER_VCP;
2582         else
2583             output[0x01] &= ~DRIVER_VCP;
2584         if(eeprom->suspend_dbus7 == SUSPEND_DBUS7)
2585             output[0x01] |= SUSPEND_DBUS7;
2586         else
2587             output[0x01] &= ~SUSPEND_DBUS7;
2588
2589         if (eeprom->suspend_pull_downs == 1)
2590             output[0x0A] |= 0x4;
2591         else
2592             output[0x0A] &= ~0x4;
2593
2594         if(eeprom->group0_drive > DRIVE_16MA)
2595             output[0x0c] |= DRIVE_16MA;
2596         else
2597             output[0x0c] |= eeprom->group0_drive;
2598         if (eeprom->group0_schmitt == IS_SCHMITT)
2599             output[0x0c] |= IS_SCHMITT;
2600         if (eeprom->group0_slew == SLOW_SLEW)
2601             output[0x0c] |= SLOW_SLEW;
2602
2603         if(eeprom->group1_drive > DRIVE_16MA)
2604             output[0x0c] |= DRIVE_16MA<<4;
2605         else
2606             output[0x0c] |= eeprom->group1_drive<<4;
2607         if (eeprom->group1_schmitt == IS_SCHMITT)
2608             output[0x0c] |= IS_SCHMITT<<4;
2609         if (eeprom->group1_slew == SLOW_SLEW)
2610             output[0x0c] |= SLOW_SLEW<<4;
2611
2612         if(eeprom->group2_drive > DRIVE_16MA)
2613             output[0x0d] |= DRIVE_16MA;
2614         else
2615             output[0x0d] |= eeprom->group2_drive;
2616         if (eeprom->group2_schmitt == IS_SCHMITT)
2617             output[0x0d] |= IS_SCHMITT;
2618         if (eeprom->group2_slew == SLOW_SLEW)
2619             output[0x0d] |= SLOW_SLEW;
2620
2621         if(eeprom->group3_drive > DRIVE_16MA)
2622             output[0x0d] |= DRIVE_16MA<<4;
2623         else
2624             output[0x0d] |= eeprom->group3_drive<<4;
2625         if (eeprom->group3_schmitt == IS_SCHMITT)
2626             output[0x0d] |= IS_SCHMITT<<4;
2627         if (eeprom->group3_slew == SLOW_SLEW)
2628             output[0x0d] |= SLOW_SLEW<<4;
2629
2630         output[0x18] = eeprom->chip;
2631
2632         break;
2633     case TYPE_4232H:
2634         fprintf(stderr,"FIXME: Build FT4232H specific EEPROM settings\n");
2635     }
2636
2637     // calculate checksum
2638     checksum = 0xAAAA;
2639
2640     for (i = 0; i < eeprom->size/2-1; i++)
2641     {
2642         value = output[i*2];
2643         value += output[(i*2)+1] << 8;
2644
2645         checksum = value^checksum;
2646         checksum = (checksum << 1) | (checksum >> 15);
2647     }
2648
2649     output[eeprom->size-2] = checksum;
2650     output[eeprom->size-1] = checksum >> 8;
2651
2652     return size_check;
2653 }
2654
2655 /**
2656    Decode binary EEPROM image into an ftdi_eeprom structure.
2657
2658    \param ftdi pointer to ftdi_context
2659    \param verbose Decode EEPROM on stdout
2660
2661    \retval 0: all fine
2662    \retval -1: something went wrong
2663
2664    FIXME: How to pass size? How to handle size field in ftdi_eeprom?
2665    FIXME: Strings are malloc'ed here and should be freed somewhere
2666 */
2667 int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose)
2668 {
2669     unsigned char i, j;
2670     unsigned short checksum, eeprom_checksum, value;
2671     unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2672     int eeprom_size;
2673     struct ftdi_eeprom *eeprom;
2674     unsigned char *buf = ftdi->eeprom->buf;
2675     int release;
2676
2677     if (ftdi == NULL)
2678         ftdi_error_return(-1,"No context");
2679     if (ftdi->eeprom == NULL)
2680         ftdi_error_return(-1,"No eeprom structure");
2681
2682     eeprom = ftdi->eeprom;
2683     eeprom_size = eeprom->size;
2684
2685     // Addr 02: Vendor ID
2686     eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
2687
2688     // Addr 04: Product ID
2689     eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
2690
2691     release = buf[0x06] + (buf[0x07]<<8);
2692
2693     // Addr 08: Config descriptor
2694     // Bit 7: always 1
2695     // Bit 6: 1 if this device is self powered, 0 if bus powered
2696     // Bit 5: 1 if this device uses remote wakeup
2697     eeprom->self_powered = buf[0x08] & 0x40;
2698     eeprom->remote_wakeup = buf[0x08] & 0x20;;
2699
2700     // Addr 09: Max power consumption: max power = value * 2 mA
2701     eeprom->max_power = buf[0x09];
2702
2703     // Addr 0A: Chip configuration
2704     // Bit 7: 0 - reserved
2705     // Bit 6: 0 - reserved
2706     // Bit 5: 0 - reserved
2707     // Bit 4: 1 - Change USB version
2708     //            Not seen on FT2232(D)
2709     // Bit 3: 1 - Use the serial number string
2710     // Bit 2: 1 - Enable suspend pull downs for lower power
2711     // Bit 1: 1 - Out EndPoint is Isochronous
2712     // Bit 0: 1 - In EndPoint is Isochronous
2713     //
2714     eeprom->in_is_isochronous  = buf[0x0A]&0x01;
2715     eeprom->out_is_isochronous = buf[0x0A]&0x02;
2716     eeprom->suspend_pull_downs = buf[0x0A]&0x04;
2717     eeprom->use_serial         = buf[0x0A] & USE_SERIAL_NUM;
2718     if(buf[0x0A]&0x10)
2719         fprintf(stderr,
2720                 "EEPROM byte[0x0a] Bit 4 unexpected set. If this happened with the EEPROM\n"
2721                 "programmed by FTDI tools, please report to libftdi@developer.intra2net.com\n");
2722
2723
2724     // Addr 0C: USB version low byte when 0x0A
2725     // Addr 0D: USB version high byte when 0x0A
2726     eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
2727
2728     // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2729     // Addr 0F: Length of manufacturer string
2730     manufacturer_size = buf[0x0F]/2;
2731     if(eeprom->manufacturer)
2732         free(eeprom->manufacturer);
2733     if (manufacturer_size > 0)
2734     {
2735         eeprom->manufacturer = malloc(manufacturer_size);
2736         if (eeprom->manufacturer)
2737         {
2738             // Decode manufacturer
2739             i = buf[0x0E] & (eeprom_size -1); // offset
2740             for (j=0;j<manufacturer_size-1;j++)
2741             {
2742                 eeprom->manufacturer[j] = buf[2*j+i+2];
2743             }
2744             eeprom->manufacturer[j] = '\0';
2745         }
2746     }
2747     else eeprom->manufacturer = NULL;
2748
2749     // Addr 10: Offset of the product string + 0x80, calculated later
2750     // Addr 11: Length of product string
2751     if(eeprom->product)
2752         free(eeprom->product);
2753     product_size = buf[0x11]/2;
2754     if (product_size > 0)
2755     {
2756         eeprom->product = malloc(product_size);
2757         if(eeprom->product)
2758         {
2759             // Decode product name
2760             i = buf[0x10] & (eeprom_size -1); // offset
2761             for (j=0;j<product_size-1;j++)
2762             {
2763                 eeprom->product[j] = buf[2*j+i+2];
2764             }
2765             eeprom->product[j] = '\0';
2766         }
2767     }
2768     else eeprom->product = NULL;
2769
2770     // Addr 12: Offset of the serial string + 0x80, calculated later
2771     // Addr 13: Length of serial string
2772     if(eeprom->serial)
2773         free(eeprom->serial);
2774     serial_size = buf[0x13]/2;
2775     if (serial_size > 0)
2776     {
2777         eeprom->serial = malloc(serial_size);
2778         if(eeprom->serial)
2779         {
2780             // Decode serial
2781             i = buf[0x12] & (eeprom_size -1); // offset
2782             for (j=0;j<serial_size-1;j++)
2783             {
2784                 eeprom->serial[j] = buf[2*j+i+2];
2785             }
2786             eeprom->serial[j] = '\0';
2787         }
2788     }
2789     else eeprom->serial = NULL;
2790
2791     // verify checksum
2792     checksum = 0xAAAA;
2793
2794     for (i = 0; i < eeprom_size/2-1; i++)
2795     {
2796         value = buf[i*2];
2797         value += buf[(i*2)+1] << 8;
2798
2799         checksum = value^checksum;
2800         checksum = (checksum << 1) | (checksum >> 15);
2801     }
2802
2803     eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
2804
2805     if (eeprom_checksum != checksum)
2806     {
2807         fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
2808         ftdi_error_return(-1,"EEPROM checksum error");
2809     }
2810
2811     eeprom->channel_a_type   = 0;
2812     if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM))
2813     {
2814         eeprom->chip = -1;
2815     }
2816     else if(ftdi->type == TYPE_2232C)
2817     {
2818         eeprom->channel_a_type   = buf[0x00] & 0x7;
2819         eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
2820         eeprom->high_current_a   = buf[0x00] & HIGH_CURRENT_DRIVE;
2821         eeprom->channel_b_type   = buf[0x01] & 0x7;
2822         eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
2823         eeprom->high_current_b   = buf[0x01] & HIGH_CURRENT_DRIVE;
2824         eeprom->chip = buf[0x14];
2825     }
2826     else if(ftdi->type == TYPE_R)
2827     {
2828         /* TYPE_R flags D2XX, not VCP as all others*/
2829         eeprom->channel_a_driver = (~buf[0x00]) & DRIVER_VCP;
2830         eeprom->high_current     = buf[0x00] & HIGH_CURRENT_DRIVE_R;
2831         if( (buf[0x01]&0x40) != 0x40)
2832         fprintf(stderr,
2833                 "TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size."
2834                 " If this happened with the\n"
2835                 " EEPROM programmed by FTDI tools, please report "
2836                 "to libftdi@developer.intra2net.com\n");
2837
2838         eeprom->chip = buf[0x16];
2839         // Addr 0B: Invert data lines
2840         // Works only on FT232R, not FT245R, but no way to distinguish
2841         eeprom->invert = buf[0x0B];
2842         // Addr 14: CBUS function: CBUS0, CBUS1
2843         // Addr 15: CBUS function: CBUS2, CBUS3
2844         // Addr 16: CBUS function: CBUS5
2845         eeprom->cbus_function[0] = buf[0x14] & 0x0f;
2846         eeprom->cbus_function[1] = (buf[0x14] >> 4) & 0x0f;
2847         eeprom->cbus_function[2] = buf[0x15] & 0x0f;
2848         eeprom->cbus_function[3] = (buf[0x15] >> 4) & 0x0f;
2849         eeprom->cbus_function[4] = buf[0x16] & 0x0f;
2850     }
2851     else if ((ftdi->type == TYPE_2232H) ||(ftdi->type == TYPE_4232H))
2852     {
2853         eeprom->channel_a_type   = buf[0x00] & 0x7;
2854         eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
2855         eeprom->channel_b_type   = buf[0x01] & 0x7;
2856         eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
2857
2858         if(ftdi->type == TYPE_2232H)
2859             eeprom->suspend_dbus7    = buf[0x01] & SUSPEND_DBUS7;
2860
2861         eeprom->chip = buf[0x18];
2862         eeprom->group0_drive   =  buf[0x0c]       & DRIVE_16MA;
2863         eeprom->group0_schmitt =  buf[0x0c]       & IS_SCHMITT;
2864         eeprom->group0_slew    =  buf[0x0c]       & SLOW_SLEW;
2865         eeprom->group1_drive   = (buf[0x0c] >> 4) & 0x3;
2866         eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT;
2867         eeprom->group1_slew    = (buf[0x0c] >> 4) & SLOW_SLEW;
2868         eeprom->group2_drive   =  buf[0x0d]       & DRIVE_16MA;
2869         eeprom->group2_schmitt =  buf[0x0d]       & IS_SCHMITT;
2870         eeprom->group2_slew    =  buf[0x0d]       & SLOW_SLEW;
2871         eeprom->group3_drive   = (buf[0x0d] >> 4) & DRIVE_16MA;
2872         eeprom->group3_schmitt = (buf[0x0d] >> 4) & IS_SCHMITT;
2873         eeprom->group3_slew    = (buf[0x0d] >> 4) & SLOW_SLEW;
2874     }
2875
2876     if(verbose)
2877     {
2878         char *channel_mode[] = {"UART","245","CPU", "unknown", "OPTO"};
2879         fprintf(stdout, "VID:     0x%04x\n",eeprom->vendor_id);
2880         fprintf(stdout, "PID:     0x%04x\n",eeprom->product_id);
2881         fprintf(stdout, "Release: 0x%04x\n",release);
2882
2883         if(eeprom->self_powered)
2884             fprintf(stdout, "Self-Powered%s", (eeprom->remote_wakeup)?", USB Remote Wake Up\n":"\n");
2885         else
2886             fprintf(stdout, "Bus Powered: %3d mA%s", eeprom->max_power * 2,
2887                     (eeprom->remote_wakeup)?" USB Remote Wake Up\n":"\n");
2888         if(eeprom->manufacturer)
2889             fprintf(stdout, "Manufacturer: %s\n",eeprom->manufacturer);
2890         if(eeprom->product)
2891             fprintf(stdout, "Product:      %s\n",eeprom->product);
2892         if(eeprom->serial)
2893             fprintf(stdout, "Serial:       %s\n",eeprom->serial);
2894         fprintf(stdout,     "Checksum      : %04x\n", checksum);
2895         if (ftdi->type == TYPE_R)
2896             fprintf(stdout,     "Internal EEPROM\n");
2897         else if (eeprom->chip >= 0x46)
2898             fprintf(stdout,     "Attached EEPROM: 93x%02x\n", eeprom->chip);
2899         if(eeprom->suspend_dbus7)
2900             fprintf(stdout, "Suspend on DBUS7\n");
2901         if(eeprom->suspend_pull_downs)
2902             fprintf(stdout, "Pull IO pins low during suspend\n");
2903         if(eeprom->remote_wakeup)
2904             fprintf(stdout, "Enable Remote Wake Up\n");
2905         fprintf(stdout, "PNP: %d\n",(eeprom->is_not_pnp)?0:1);
2906         if (ftdi->type >= TYPE_2232C)
2907             fprintf(stdout,"Channel A has Mode %s%s%s\n",
2908                     channel_mode[eeprom->channel_a_type],
2909                     (eeprom->channel_a_driver)?" VCP":"",
2910                     (eeprom->high_current_a)?" High Current IO":"");
2911         if ((ftdi->type >= TYPE_2232C) && (ftdi->type != TYPE_R))
2912             fprintf(stdout,"Channel B has Mode %s%s%s\n",
2913                     channel_mode[eeprom->channel_b_type],
2914                     (eeprom->channel_b_driver)?" VCP":"",
2915                     (eeprom->high_current_b)?" High Current IO":"");
2916         if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
2917         {
2918             fprintf(stdout,"%s has %d mA drive%s%s\n",
2919                     (ftdi->type == TYPE_2232H)?"AL":"A",
2920                     (eeprom->group0_drive+1) *4,
2921                     (eeprom->group0_schmitt)?" Schmitt Input":"",
2922                     (eeprom->group0_slew)?" Slow Slew":"");
2923             fprintf(stdout,"%s has %d mA drive%s%s\n",
2924                     (ftdi->type == TYPE_2232H)?"AH":"B",
2925                     (eeprom->group1_drive+1) *4,
2926                     (eeprom->group1_schmitt)?" Schmitt Input":"",
2927                     (eeprom->group1_slew)?" Slow Slew":"");
2928             fprintf(stdout,"%s has %d mA drive%s%s\n",
2929                     (ftdi->type == TYPE_2232H)?"BL":"C",
2930                     (eeprom->group2_drive+1) *4,
2931                     (eeprom->group2_schmitt)?" Schmitt Input":"",
2932                     (eeprom->group2_slew)?" Slow Slew":"");
2933             fprintf(stdout,"%s has %d mA drive%s%s\n",
2934                     (ftdi->type == TYPE_2232H)?"BH":"D",
2935                     (eeprom->group3_drive+1) *4,
2936                     (eeprom->group3_schmitt)?" Schmitt Input":"",
2937                     (eeprom->group3_slew)?" Slow Slew":"");
2938         }
2939         if (ftdi->type == TYPE_R)
2940         {
2941             char *cbus_mux[] = {"TXDEN","PWREN","RXLED", "TXLED","TX+RXLED",
2942                                 "SLEEP","CLK48","CLK24","CLK12","CLK6",
2943                                 "IOMODE","BB_WR","BB_RD"};
2944             char *cbus_BB[] = {"RXF","TXE","RD", "WR"};
2945             int i;
2946
2947             if(eeprom->invert)
2948             {
2949                 char *r_bits[] = {"TXD","RXD","RTS", "CTS","DTR","DSR","DCD","RI"};
2950                 fprintf(stdout,"Inverted bits:");
2951                 for (i=0; i<8; i++)
2952                     if((eeprom->invert & (1<<i)) == (1<<i))
2953                         fprintf(stdout," %s",r_bits[i]);
2954                 fprintf(stdout,"\n");
2955             }
2956             for(i=0; i<5; i++)
2957             {
2958                 if(eeprom->cbus_function[i]<CBUS_BB)
2959                     fprintf(stdout,"C%d Function: %s\n", i,
2960                             cbus_mux[eeprom->cbus_function[i]]);
2961                 else
2962                     fprintf(stdout,"C%d BB Function: %s\n", i,
2963                             cbus_BB[i]);
2964             }
2965         }
2966     }
2967     return 0;
2968 }
2969
2970 /**
2971     Read eeprom location
2972
2973     \param ftdi pointer to ftdi_context
2974     \param eeprom_addr Address of eeprom location to be read
2975     \param eeprom_val Pointer to store read eeprom location
2976
2977     \retval  0: all fine
2978     \retval -1: read failed
2979     \retval -2: USB device unavailable
2980 */
2981 int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
2982 {
2983     if (ftdi == NULL || ftdi->usb_dev == NULL)
2984         ftdi_error_return(-2, "USB device unavailable");
2985
2986     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)
2987         ftdi_error_return(-1, "reading eeprom failed");
2988
2989     return 0;
2990 }
2991
2992 /**
2993     Read eeprom
2994
2995     \param ftdi pointer to ftdi_context
2996
2997     \retval  0: all fine
2998     \retval -1: read failed
2999     \retval -2: USB device unavailable
3000 */
3001 int ftdi_read_eeprom(struct ftdi_context *ftdi)
3002 {
3003     int i;
3004     unsigned char *buf;
3005
3006     if (ftdi == NULL || ftdi->usb_dev == NULL)
3007         ftdi_error_return(-2, "USB device unavailable");
3008     buf = ftdi->eeprom->buf;
3009
3010     for (i = 0; i < FTDI_MAX_EEPROM_SIZE/2; i++)
3011     {
3012         if (libusb_control_transfer(
3013                 ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,SIO_READ_EEPROM_REQUEST, 0, i,
3014                 buf+(i*2), 2, ftdi->usb_read_timeout) != 2)
3015             ftdi_error_return(-1, "reading eeprom failed");
3016     }
3017
3018     if (ftdi->type == TYPE_R)
3019         ftdi->eeprom->size = 0x80;
3020     /*    Guesses size of eeprom by comparing halves
3021           - will not work with blank eeprom */
3022     else if (strrchr((const char *)buf, 0xff) == ((const char *)buf +FTDI_MAX_EEPROM_SIZE -1))
3023         ftdi->eeprom->size = -1;
3024     else if(memcmp(buf,&buf[0x80],0x80) == 0)
3025         ftdi->eeprom->size = 0x80;
3026     else if(memcmp(buf,&buf[0x40],0x40) == 0)
3027         ftdi->eeprom->size = 0x40;
3028     else
3029         ftdi->eeprom->size = 0x100;
3030     return 0;
3031 }
3032
3033 /*
3034     ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID
3035     Function is only used internally
3036     \internal
3037 */
3038 static unsigned char ftdi_read_chipid_shift(unsigned char value)
3039 {
3040     return ((value & 1) << 1) |
3041            ((value & 2) << 5) |
3042            ((value & 4) >> 2) |
3043            ((value & 8) << 4) |
3044            ((value & 16) >> 1) |
3045            ((value & 32) >> 1) |
3046            ((value & 64) >> 4) |
3047            ((value & 128) >> 2);
3048 }
3049
3050 /**
3051     Read the FTDIChip-ID from R-type devices
3052
3053     \param ftdi pointer to ftdi_context
3054     \param chipid Pointer to store FTDIChip-ID
3055
3056     \retval  0: all fine
3057     \retval -1: read failed
3058     \retval -2: USB device unavailable
3059 */
3060 int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
3061 {
3062     unsigned int a = 0, b = 0;
3063
3064     if (ftdi == NULL || ftdi->usb_dev == NULL)
3065         ftdi_error_return(-2, "USB device unavailable");
3066
3067     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)
3068     {
3069         a = a << 8 | a >> 8;
3070         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)
3071         {
3072             b = b << 8 | b >> 8;
3073             a = (a << 16) | (b & 0xFFFF);
3074             a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
3075                 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
3076             *chipid = a ^ 0xa5f0f7d1;
3077             return 0;
3078         }
3079     }
3080
3081     ftdi_error_return(-1, "read of FTDIChip-ID failed");
3082 }
3083
3084 /**
3085     Write eeprom location
3086
3087     \param ftdi pointer to ftdi_context
3088     \param eeprom_addr Address of eeprom location to be written
3089     \param eeprom_val Value to be written
3090
3091     \retval  0: all fine
3092     \retval -1: write failed
3093     \retval -2: USB device unavailable
3094     \retval -3: Invalid access to checksum protected area below 0x80
3095     \retval -4: Device can't access unprotected area
3096     \retval -5: Reading chip type failed
3097 */
3098 int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr,
3099                                unsigned short eeprom_val)
3100 {
3101     int chip_type_location;
3102     unsigned short chip_type;
3103
3104     if (ftdi == NULL || ftdi->usb_dev == NULL)
3105         ftdi_error_return(-2, "USB device unavailable");
3106
3107     if(eeprom_addr <0x80)
3108         ftdi_error_return(-2, "Invalid access to checksum protected area  below 0x80");
3109
3110
3111     switch (ftdi->type)
3112     {
3113     case TYPE_BM:
3114     case  TYPE_2232C:
3115         chip_type_location = 0x14;
3116         break;
3117     case TYPE_2232H:
3118     case TYPE_4232H:
3119         chip_type_location = 0x18;
3120         break;
3121     default:
3122         ftdi_error_return(-4, "Device can't access unprotected area");
3123     }
3124
3125     if (ftdi_read_eeprom_location( ftdi, chip_type_location>>1, &chip_type))
3126         ftdi_error_return(-5, "Reading failed failed");
3127     fprintf(stderr," loc 0x%04x val 0x%04x\n", chip_type_location,chip_type);
3128     if((chip_type & 0xff) != 0x66)
3129     {
3130         ftdi_error_return(-6, "EEPROM is not of 93x66");
3131     }
3132
3133     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3134                                     SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
3135                                     NULL, 0, ftdi->usb_write_timeout) != 0)
3136         ftdi_error_return(-1, "unable to write eeprom");
3137
3138     return 0;
3139 }
3140
3141 /**
3142     Write eeprom
3143
3144     \param ftdi pointer to ftdi_context
3145
3146     \retval  0: all fine
3147     \retval -1: read failed
3148     \retval -2: USB device unavailable
3149 */
3150 int ftdi_write_eeprom(struct ftdi_context *ftdi)
3151 {
3152     unsigned short usb_val, status;
3153     int i, ret;
3154     unsigned char *eeprom;
3155
3156     if (ftdi == NULL || ftdi->usb_dev == NULL)
3157         ftdi_error_return(-2, "USB device unavailable");
3158     eeprom = ftdi->eeprom->buf;
3159
3160     /* These commands were traced while running MProg */
3161     if ((ret = ftdi_usb_reset(ftdi)) != 0)
3162         return ret;
3163     if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0)
3164         return ret;
3165     if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0)
3166         return ret;
3167
3168     for (i = 0; i < ftdi->eeprom->size/2; i++)
3169     {
3170         usb_val = eeprom[i*2];
3171         usb_val += eeprom[(i*2)+1] << 8;
3172         if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3173                                     SIO_WRITE_EEPROM_REQUEST, usb_val, i,
3174                                     NULL, 0, ftdi->usb_write_timeout) < 0)
3175             ftdi_error_return(-1, "unable to write eeprom");
3176     }
3177
3178     return 0;
3179 }
3180
3181 /**
3182     Erase eeprom
3183
3184     This is not supported on FT232R/FT245R according to the MProg manual from FTDI.
3185
3186     \param ftdi pointer to ftdi_context
3187
3188     \retval  0: all fine
3189     \retval -1: erase failed
3190     \retval -2: USB device unavailable
3191     \retval -3: Writing magic failed
3192     \retval -4: Read EEPROM failed
3193     \retval -5: Unexpected EEPROM value
3194 */
3195 #define MAGIC 0x55aa
3196 int ftdi_erase_eeprom(struct ftdi_context *ftdi)
3197 {
3198     unsigned short eeprom_value;
3199     if (ftdi == NULL || ftdi->usb_dev == NULL)
3200         ftdi_error_return(-2, "USB device unavailable");
3201
3202     if(ftdi->type == TYPE_R)
3203     {
3204         ftdi->eeprom->chip = 0;
3205         return 0;
3206     }
3207
3208     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
3209                                 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
3210         ftdi_error_return(-1, "unable to erase eeprom");
3211
3212
3213     /* detect chip type by writing 0x55AA as magic at word position 0xc0
3214        Chip is 93x46 if magic is read at word position 0x00, as wraparound happens around 0x40
3215        Chip is 93x56 if magic is read at word position 0x40, as wraparound happens around 0x80
3216        Chip is 93x66 if magic is only read at word position 0xc0*/
3217     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3218                                     SIO_WRITE_EEPROM_REQUEST, MAGIC, 0xc0,
3219                                     NULL, 0, ftdi->usb_write_timeout) != 0)
3220         ftdi_error_return(-3, "Writing magic failed");
3221     if (ftdi_read_eeprom_location( ftdi, 0x00, &eeprom_value))
3222         ftdi_error_return(-4, "Reading failed failed");
3223     if(eeprom_value == MAGIC)
3224     {
3225         ftdi->eeprom->chip = 0x46;
3226     }
3227     else
3228     {
3229         if (ftdi_read_eeprom_location( ftdi, 0x40, &eeprom_value))
3230             ftdi_error_return(-4, "Reading failed failed");
3231         if(eeprom_value == MAGIC)
3232             ftdi->eeprom->chip = 0x56;
3233         else
3234         {
3235             if (ftdi_read_eeprom_location( ftdi, 0xc0, &eeprom_value))
3236                 ftdi_error_return(-4, "Reading failed failed");
3237             if(eeprom_value == MAGIC)
3238                 ftdi->eeprom->chip = 0x66;
3239             else
3240             {
3241                 ftdi->eeprom->chip = -1;
3242             }
3243         }
3244     }
3245     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
3246                                 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
3247         ftdi_error_return(-1, "unable to erase eeprom");
3248     return 0;
3249 }
3250
3251 /**
3252     Get string representation for last error code
3253
3254     \param ftdi pointer to ftdi_context
3255
3256     \retval Pointer to error string
3257 */
3258 char *ftdi_get_error_string (struct ftdi_context *ftdi)
3259 {
3260     if (ftdi == NULL)
3261         return "";
3262
3263     return ftdi->error_str;
3264 }
3265
3266 /* @} end of doxygen libftdi group */