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: size of eeprom user area in bytes
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 user_area_size;
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     // eeprom size check
2311     switch (ftdi->type)
2312     {
2313         case TYPE_AM:
2314         case TYPE_BM:
2315             user_area_size = 96;    // base size for strings (total of 48 characters)
2316             break;
2317         case TYPE_2232C:
2318            user_area_size = 90;     // two extra config bytes and 4 bytes PnP stuff
2319            break;
2320         case TYPE_R:
2321            user_area_size = 88;     // four extra config bytes + 4 bytes PnP stuff
2322            break;
2323         case TYPE_2232H:            // six extra config bytes + 4 bytes PnP stuff
2324         case TYPE_4232H:
2325            user_area_size = 86;
2326            break;
2327     }
2328     user_area_size  -= (manufacturer_size + product_size + serial_size) * 2;
2329
2330     if (user_area_size < 0)
2331         ftdi_error_return(-1,"eeprom size exceeded");
2332
2333     // empty eeprom
2334     memset (ftdi->eeprom->buf, 0, FTDI_MAX_EEPROM_SIZE);
2335
2336     // Bytes and Bits set for all Types
2337
2338     // Addr 02: Vendor ID
2339     output[0x02] = eeprom->vendor_id;
2340     output[0x03] = eeprom->vendor_id >> 8;
2341
2342     // Addr 04: Product ID
2343     output[0x04] = eeprom->product_id;
2344     output[0x05] = eeprom->product_id >> 8;
2345
2346     // Addr 06: Device release number (0400h for BM features)
2347     output[0x06] = 0x00;
2348     switch (ftdi->type)
2349     {
2350         case TYPE_AM:
2351             output[0x07] = 0x02;
2352             break;
2353         case TYPE_BM:
2354             output[0x07] = 0x04;
2355             break;
2356         case TYPE_2232C:
2357             output[0x07] = 0x05;
2358             break;
2359         case TYPE_R:
2360             output[0x07] = 0x06;
2361             break;
2362          case TYPE_2232H:
2363             output[0x07] = 0x07;
2364             break;
2365          case TYPE_4232H:
2366             output[0x07] = 0x08;
2367             break;
2368         default:
2369             output[0x07] = 0x00;
2370     }
2371
2372     // Addr 08: Config descriptor
2373     // Bit 7: always 1
2374     // Bit 6: 1 if this device is self powered, 0 if bus powered
2375     // Bit 5: 1 if this device uses remote wakeup
2376     // Bit 4-0: reserved - 0
2377     j = 0x80;
2378     if (eeprom->self_powered == 1)
2379         j |= 0x40;
2380     if (eeprom->remote_wakeup == 1)
2381         j |= 0x20;
2382     output[0x08] = j;
2383
2384     // Addr 09: Max power consumption: max power = value * 2 mA
2385     output[0x09] = eeprom->max_power>>1;
2386
2387     if(ftdi->type != TYPE_AM)
2388     {
2389         // Addr 0A: Chip configuration
2390         // Bit 7: 0 - reserved
2391         // Bit 6: 0 - reserved
2392         // Bit 5: 0 - reserved
2393         // Bit 4: 1 - Change USB version
2394         // Bit 3: 1 - Use the serial number string
2395         // Bit 2: 1 - Enable suspend pull downs for lower power
2396         // Bit 1: 1 - Out EndPoint is Isochronous
2397         // Bit 0: 1 - In EndPoint is Isochronous
2398         //
2399         j = 0;
2400         if (eeprom->in_is_isochronous == 1)
2401             j = j | 1;
2402         if (eeprom->out_is_isochronous == 1)
2403             j = j | 2;
2404         output[0x0A] = j;
2405     }
2406
2407     // Dynamic content
2408     // Strings start at 0x94 (TYPE_AM, TYPE_BM)
2409     // 0x96 (TYPE_2232C), 0x98 (TYPE_R) and 0x9a (TYPE_x232H)
2410     i = 0;
2411     switch(ftdi->type)
2412     {
2413     case TYPE_2232H:
2414     case TYPE_4232H:
2415         i += 2;
2416     case TYPE_R:
2417         i += 2;
2418     case TYPE_2232C:
2419         i += 2;
2420     case TYPE_AM:
2421     case TYPE_BM:
2422         i += 0x94;
2423     }
2424     /* Wrap around 0x80 for 128 byte EEPROMS (Internale and 93x46) */
2425     eeprom_size_mask = eeprom->size -1;
2426
2427     // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2428     // Addr 0F: Length of manufacturer string
2429     // Output manufacturer
2430     output[0x0E] = i;  // calculate offset
2431     output[i & eeprom_size_mask] = manufacturer_size*2 + 2, i++;
2432     output[i & eeprom_size_mask] = 0x03, i++; // type: string
2433     for (j = 0; j < manufacturer_size; j++)
2434     {
2435         output[i & eeprom_size_mask] = eeprom->manufacturer[j], i++;
2436         output[i & eeprom_size_mask] = 0x00, i++;
2437     }
2438     output[0x0F] = manufacturer_size*2 + 2;
2439
2440     // Addr 10: Offset of the product string + 0x80, calculated later
2441     // Addr 11: Length of product string
2442     output[0x10] = i | 0x80;  // calculate offset
2443     output[i & eeprom_size_mask] = product_size*2 + 2, i++;
2444     output[i & eeprom_size_mask] = 0x03, i++;
2445     for (j = 0; j < product_size; j++)
2446     {
2447         output[i & eeprom_size_mask] = eeprom->product[j], i++;
2448         output[i & eeprom_size_mask] = 0x00, i++;
2449     }
2450     output[0x11] = product_size*2 + 2;
2451
2452     // Addr 12: Offset of the serial string + 0x80, calculated later
2453     // Addr 13: Length of serial string
2454     output[0x12] = i | 0x80; // calculate offset
2455     output[i & eeprom_size_mask] = serial_size*2 + 2, i++;
2456     output[i & eeprom_size_mask] = 0x03, i++;
2457     for (j = 0; j < serial_size; j++)
2458     {
2459         output[i & eeprom_size_mask] = eeprom->serial[j], i++;
2460         output[i & eeprom_size_mask] = 0x00, i++;
2461     }
2462
2463     // Legacy port name and PnP fields for FT2232 and newer chips
2464     if (ftdi->type > TYPE_BM)
2465     {
2466         output[i & eeprom_size_mask] = 0x02; /* as seen when written with FTD2XX */
2467         i++;
2468         output[i & eeprom_size_mask] = 0x03; /* as seen when written with FTD2XX */
2469         i++;
2470         output[i & eeprom_size_mask] = eeprom->is_not_pnp; /* as seen when written with FTD2XX */
2471         i++;
2472     }
2473
2474     output[0x13] = serial_size*2 + 2;
2475
2476     if(ftdi->type > TYPE_AM) /* use_serial not used in AM devices */
2477     {
2478         if (eeprom->use_serial == USE_SERIAL_NUM )
2479             output[0x0A] |= USE_SERIAL_NUM;
2480         else
2481             output[0x0A] &= ~USE_SERIAL_NUM;
2482     }
2483
2484     /* Bytes and Bits specific to (some) types
2485        Write linear, as this allows easier fixing*/
2486     switch(ftdi->type)
2487     {
2488     case TYPE_AM:
2489         break;
2490     case TYPE_BM:
2491         output[0x0C] = eeprom->usb_version & 0xff;
2492         output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2493         if (eeprom->use_usb_version == USE_USB_VERSION_BIT)
2494             output[0x0A] |= USE_USB_VERSION_BIT;
2495         else
2496             output[0x0A] &= ~USE_USB_VERSION_BIT;
2497
2498         break;
2499     case TYPE_2232C:
2500
2501         output[0x00] = (eeprom->channel_a_type);
2502         if ( eeprom->channel_a_driver == DRIVER_VCP)
2503             output[0x00] |= DRIVER_VCP;
2504         else
2505             output[0x00] &= ~DRIVER_VCP;
2506
2507         if ( eeprom->high_current_a == HIGH_CURRENT_DRIVE)
2508             output[0x00] |= HIGH_CURRENT_DRIVE;
2509         else
2510             output[0x00] &= ~HIGH_CURRENT_DRIVE;
2511
2512         output[0x01] = (eeprom->channel_b_type);
2513         if ( eeprom->channel_b_driver == DRIVER_VCP)
2514             output[0x01] |= DRIVER_VCP;
2515         else
2516             output[0x01] &= ~DRIVER_VCP;
2517
2518         if ( eeprom->high_current_b == HIGH_CURRENT_DRIVE)
2519             output[0x01] |= HIGH_CURRENT_DRIVE;
2520         else
2521             output[0x01] &= ~HIGH_CURRENT_DRIVE;
2522
2523         if (eeprom->in_is_isochronous == 1)
2524             output[0x0A] |= 0x1;
2525         else
2526             output[0x0A] &= ~0x1;
2527         if (eeprom->out_is_isochronous == 1)
2528             output[0x0A] |= 0x2;
2529         else
2530             output[0x0A] &= ~0x2;
2531         if (eeprom->suspend_pull_downs == 1)
2532             output[0x0A] |= 0x4;
2533         else
2534             output[0x0A] &= ~0x4;
2535         if (eeprom->use_usb_version == USE_USB_VERSION_BIT)
2536             output[0x0A] |= USE_USB_VERSION_BIT;
2537         else
2538             output[0x0A] &= ~USE_USB_VERSION_BIT;
2539
2540         output[0x0C] = eeprom->usb_version & 0xff;
2541         output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2542         output[0x14] = eeprom->chip;
2543         break;
2544     case TYPE_R:
2545         if(eeprom->high_current == HIGH_CURRENT_DRIVE_R)
2546             output[0x00] |= HIGH_CURRENT_DRIVE_R;
2547         output[0x01] = 0x40; /* Hard coded Endpoint Size*/
2548
2549         if (eeprom->suspend_pull_downs == 1)
2550             output[0x0A] |= 0x4;
2551         else
2552             output[0x0A] &= ~0x4;
2553         output[0x0B] = eeprom->invert;
2554         output[0x0C] = eeprom->usb_version & 0xff;
2555         output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2556
2557         if(eeprom->cbus_function[0] > CBUS_BB)
2558             output[0x14] = CBUS_TXLED;
2559         else
2560             output[0x14] = eeprom->cbus_function[0];
2561
2562         if(eeprom->cbus_function[1] > CBUS_BB)
2563             output[0x14] |= CBUS_RXLED<<4;
2564         else
2565             output[0x14] |= eeprom->cbus_function[1]<<4;
2566
2567         if(eeprom->cbus_function[2] > CBUS_BB)
2568             output[0x15] = CBUS_TXDEN;
2569         else
2570             output[0x15] = eeprom->cbus_function[2];
2571
2572         if(eeprom->cbus_function[3] > CBUS_BB)
2573             output[0x15] |= CBUS_PWREN<<4;
2574         else
2575             output[0x15] |= eeprom->cbus_function[3]<<4;
2576
2577         if(eeprom->cbus_function[4] > CBUS_CLK6)
2578             output[0x16] = CBUS_SLEEP;
2579         else
2580             output[0x16] = eeprom->cbus_function[4];
2581         break;
2582     case TYPE_2232H:
2583         output[0x00] = (eeprom->channel_a_type);
2584         if ( eeprom->channel_a_driver == DRIVER_VCP)
2585             output[0x00] |= DRIVER_VCP;
2586         else
2587             output[0x00] &= ~DRIVER_VCP;
2588
2589         output[0x01] = (eeprom->channel_b_type);
2590         if ( eeprom->channel_b_driver == DRIVER_VCP)
2591             output[0x01] |= DRIVER_VCP;
2592         else
2593             output[0x01] &= ~DRIVER_VCP;
2594         if(eeprom->suspend_dbus7 == SUSPEND_DBUS7_BIT)
2595             output[0x01] |= SUSPEND_DBUS7_BIT;
2596         else
2597             output[0x01] &= ~SUSPEND_DBUS7_BIT;
2598
2599         if (eeprom->suspend_pull_downs == 1)
2600             output[0x0A] |= 0x4;
2601         else
2602             output[0x0A] &= ~0x4;
2603
2604         if(eeprom->group0_drive > DRIVE_16MA)
2605             output[0x0c] |= DRIVE_16MA;
2606         else
2607             output[0x0c] |= eeprom->group0_drive;
2608         if (eeprom->group0_schmitt == IS_SCHMITT)
2609             output[0x0c] |= IS_SCHMITT;
2610         if (eeprom->group0_slew == SLOW_SLEW)
2611             output[0x0c] |= SLOW_SLEW;
2612
2613         if(eeprom->group1_drive > DRIVE_16MA)
2614             output[0x0c] |= DRIVE_16MA<<4;
2615         else
2616             output[0x0c] |= eeprom->group1_drive<<4;
2617         if (eeprom->group1_schmitt == IS_SCHMITT)
2618             output[0x0c] |= IS_SCHMITT<<4;
2619         if (eeprom->group1_slew == SLOW_SLEW)
2620             output[0x0c] |= SLOW_SLEW<<4;
2621
2622         if(eeprom->group2_drive > DRIVE_16MA)
2623             output[0x0d] |= DRIVE_16MA;
2624         else
2625             output[0x0d] |= eeprom->group2_drive;
2626         if (eeprom->group2_schmitt == IS_SCHMITT)
2627             output[0x0d] |= IS_SCHMITT;
2628         if (eeprom->group2_slew == SLOW_SLEW)
2629             output[0x0d] |= SLOW_SLEW;
2630
2631         if(eeprom->group3_drive > DRIVE_16MA)
2632             output[0x0d] |= DRIVE_16MA<<4;
2633         else
2634             output[0x0d] |= eeprom->group3_drive<<4;
2635         if (eeprom->group3_schmitt == IS_SCHMITT)
2636             output[0x0d] |= IS_SCHMITT<<4;
2637         if (eeprom->group3_slew == SLOW_SLEW)
2638             output[0x0d] |= SLOW_SLEW<<4;
2639
2640         output[0x18] = eeprom->chip;
2641
2642         break;
2643     case TYPE_4232H:
2644         fprintf(stderr,"FIXME: Build FT4232H specific EEPROM settings\n");
2645     }
2646
2647     // calculate checksum
2648     checksum = 0xAAAA;
2649
2650     for (i = 0; i < eeprom->size/2-1; i++)
2651     {
2652         value = output[i*2];
2653         value += output[(i*2)+1] << 8;
2654
2655         checksum = value^checksum;
2656         checksum = (checksum << 1) | (checksum >> 15);
2657     }
2658
2659     output[eeprom->size-2] = checksum;
2660     output[eeprom->size-1] = checksum >> 8;
2661
2662     return user_area_size;
2663 }
2664
2665 /**
2666    Decode binary EEPROM image into an ftdi_eeprom structure.
2667
2668    \param ftdi pointer to ftdi_context
2669    \param verbose Decode EEPROM on stdout
2670
2671    \retval 0: all fine
2672    \retval -1: something went wrong
2673
2674    FIXME: How to pass size? How to handle size field in ftdi_eeprom?
2675    FIXME: Strings are malloc'ed here and should be freed somewhere
2676 */
2677 int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose)
2678 {
2679     unsigned char i, j;
2680     unsigned short checksum, eeprom_checksum, value;
2681     unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2682     int eeprom_size;
2683     struct ftdi_eeprom *eeprom;
2684     unsigned char *buf = ftdi->eeprom->buf;
2685     int release;
2686
2687     if (ftdi == NULL)
2688         ftdi_error_return(-1,"No context");
2689     if (ftdi->eeprom == NULL)
2690         ftdi_error_return(-1,"No eeprom structure");
2691
2692     eeprom = ftdi->eeprom;
2693     eeprom_size = eeprom->size;
2694
2695     // Addr 02: Vendor ID
2696     eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
2697
2698     // Addr 04: Product ID
2699     eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
2700
2701     release = buf[0x06] + (buf[0x07]<<8);
2702
2703     // Addr 08: Config descriptor
2704     // Bit 7: always 1
2705     // Bit 6: 1 if this device is self powered, 0 if bus powered
2706     // Bit 5: 1 if this device uses remote wakeup
2707     eeprom->self_powered = buf[0x08] & 0x40;
2708     eeprom->remote_wakeup = buf[0x08] & 0x20;
2709
2710     // Addr 09: Max power consumption: max power = value * 2 mA
2711     eeprom->max_power = buf[0x09];
2712
2713     // Addr 0A: Chip configuration
2714     // Bit 7: 0 - reserved
2715     // Bit 6: 0 - reserved
2716     // Bit 5: 0 - reserved
2717     // Bit 4: 1 - Change USB version on BM and 2232C
2718     // Bit 3: 1 - Use the serial number string
2719     // Bit 2: 1 - Enable suspend pull downs for lower power
2720     // Bit 1: 1 - Out EndPoint is Isochronous
2721     // Bit 0: 1 - In EndPoint is Isochronous
2722     //
2723     eeprom->in_is_isochronous  = buf[0x0A]&0x01;
2724     eeprom->out_is_isochronous = buf[0x0A]&0x02;
2725     eeprom->suspend_pull_downs = buf[0x0A]&0x04;
2726     eeprom->use_serial         = buf[0x0A] & USE_SERIAL_NUM;
2727     eeprom->use_usb_version    = buf[0x0A] & USE_USB_VERSION_BIT;
2728
2729     // Addr 0C: USB version low byte when 0x0A
2730     // Addr 0D: USB version high byte when 0x0A
2731     eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
2732
2733     // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2734     // Addr 0F: Length of manufacturer string
2735     manufacturer_size = buf[0x0F]/2;
2736     if(eeprom->manufacturer)
2737         free(eeprom->manufacturer);
2738     if (manufacturer_size > 0)
2739     {
2740         eeprom->manufacturer = malloc(manufacturer_size);
2741         if (eeprom->manufacturer)
2742         {
2743             // Decode manufacturer
2744             i = buf[0x0E] & (eeprom_size -1); // offset
2745             for (j=0;j<manufacturer_size-1;j++)
2746             {
2747                 eeprom->manufacturer[j] = buf[2*j+i+2];
2748             }
2749             eeprom->manufacturer[j] = '\0';
2750         }
2751     }
2752     else eeprom->manufacturer = NULL;
2753
2754     // Addr 10: Offset of the product string + 0x80, calculated later
2755     // Addr 11: Length of product string
2756     if(eeprom->product)
2757         free(eeprom->product);
2758     product_size = buf[0x11]/2;
2759     if (product_size > 0)
2760     {
2761         eeprom->product = malloc(product_size);
2762         if(eeprom->product)
2763         {
2764             // Decode product name
2765             i = buf[0x10] & (eeprom_size -1); // offset
2766             for (j=0;j<product_size-1;j++)
2767             {
2768                 eeprom->product[j] = buf[2*j+i+2];
2769             }
2770             eeprom->product[j] = '\0';
2771         }
2772     }
2773     else eeprom->product = NULL;
2774
2775     // Addr 12: Offset of the serial string + 0x80, calculated later
2776     // Addr 13: Length of serial string
2777     if(eeprom->serial)
2778         free(eeprom->serial);
2779     serial_size = buf[0x13]/2;
2780     if (serial_size > 0)
2781     {
2782         eeprom->serial = malloc(serial_size);
2783         if(eeprom->serial)
2784         {
2785             // Decode serial
2786             i = buf[0x12] & (eeprom_size -1); // offset
2787             for (j=0;j<serial_size-1;j++)
2788             {
2789                 eeprom->serial[j] = buf[2*j+i+2];
2790             }
2791             eeprom->serial[j] = '\0';
2792         }
2793     }
2794     else eeprom->serial = NULL;
2795
2796     // verify checksum
2797     checksum = 0xAAAA;
2798
2799     for (i = 0; i < eeprom_size/2-1; i++)
2800     {
2801         value = buf[i*2];
2802         value += buf[(i*2)+1] << 8;
2803
2804         checksum = value^checksum;
2805         checksum = (checksum << 1) | (checksum >> 15);
2806     }
2807
2808     eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
2809
2810     if (eeprom_checksum != checksum)
2811     {
2812         fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
2813         ftdi_error_return(-1,"EEPROM checksum error");
2814     }
2815
2816     eeprom->channel_a_type   = 0;
2817     if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM))
2818     {
2819         eeprom->chip = -1;
2820     }
2821     else if(ftdi->type == TYPE_2232C)
2822     {
2823         eeprom->channel_a_type   = buf[0x00] & 0x7;
2824         eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
2825         eeprom->high_current_a   = buf[0x00] & HIGH_CURRENT_DRIVE;
2826         eeprom->channel_b_type   = buf[0x01] & 0x7;
2827         eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
2828         eeprom->high_current_b   = buf[0x01] & HIGH_CURRENT_DRIVE;
2829         eeprom->chip = buf[0x14];
2830     }
2831     else if(ftdi->type == TYPE_R)
2832     {
2833         /* TYPE_R flags D2XX, not VCP as all others*/
2834         eeprom->channel_a_driver = (~buf[0x00]) & DRIVER_VCP;
2835         eeprom->high_current     = buf[0x00] & HIGH_CURRENT_DRIVE_R;
2836         if( (buf[0x01]&0x40) != 0x40)
2837         fprintf(stderr,
2838                 "TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size."
2839                 " If this happened with the\n"
2840                 " EEPROM programmed by FTDI tools, please report "
2841                 "to libftdi@developer.intra2net.com\n");
2842
2843         eeprom->chip = buf[0x16];
2844         // Addr 0B: Invert data lines
2845         // Works only on FT232R, not FT245R, but no way to distinguish
2846         eeprom->invert = buf[0x0B];
2847         // Addr 14: CBUS function: CBUS0, CBUS1
2848         // Addr 15: CBUS function: CBUS2, CBUS3
2849         // Addr 16: CBUS function: CBUS5
2850         eeprom->cbus_function[0] = buf[0x14] & 0x0f;
2851         eeprom->cbus_function[1] = (buf[0x14] >> 4) & 0x0f;
2852         eeprom->cbus_function[2] = buf[0x15] & 0x0f;
2853         eeprom->cbus_function[3] = (buf[0x15] >> 4) & 0x0f;
2854         eeprom->cbus_function[4] = buf[0x16] & 0x0f;
2855     }
2856     else if ((ftdi->type == TYPE_2232H) ||(ftdi->type == TYPE_4232H))
2857     {
2858         eeprom->channel_a_type   = buf[0x00] & 0x7;
2859         eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
2860         eeprom->channel_b_type   = buf[0x01] & 0x7;
2861         eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
2862
2863         if(ftdi->type == TYPE_2232H)
2864             eeprom->suspend_dbus7    = buf[0x01] & SUSPEND_DBUS7_BIT;
2865
2866         eeprom->chip = buf[0x18];
2867         eeprom->group0_drive   =  buf[0x0c]       & DRIVE_16MA;
2868         eeprom->group0_schmitt =  buf[0x0c]       & IS_SCHMITT;
2869         eeprom->group0_slew    =  buf[0x0c]       & SLOW_SLEW;
2870         eeprom->group1_drive   = (buf[0x0c] >> 4) & 0x3;
2871         eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT;
2872         eeprom->group1_slew    = (buf[0x0c] >> 4) & SLOW_SLEW;
2873         eeprom->group2_drive   =  buf[0x0d]       & DRIVE_16MA;
2874         eeprom->group2_schmitt =  buf[0x0d]       & IS_SCHMITT;
2875         eeprom->group2_slew    =  buf[0x0d]       & SLOW_SLEW;
2876         eeprom->group3_drive   = (buf[0x0d] >> 4) & DRIVE_16MA;
2877         eeprom->group3_schmitt = (buf[0x0d] >> 4) & IS_SCHMITT;
2878         eeprom->group3_slew    = (buf[0x0d] >> 4) & SLOW_SLEW;
2879     }
2880
2881     if(verbose)
2882     {
2883         char *channel_mode[] = {"UART","245","CPU", "unknown", "OPTO"};
2884         fprintf(stdout, "VID:     0x%04x\n",eeprom->vendor_id);
2885         fprintf(stdout, "PID:     0x%04x\n",eeprom->product_id);
2886         fprintf(stdout, "Release: 0x%04x\n",release);
2887
2888         if(eeprom->self_powered)
2889             fprintf(stdout, "Self-Powered%s", (eeprom->remote_wakeup)?", USB Remote Wake Up\n":"\n");
2890         else
2891             fprintf(stdout, "Bus Powered: %3d mA%s", eeprom->max_power * 2,
2892                     (eeprom->remote_wakeup)?" USB Remote Wake Up\n":"\n");
2893         if(eeprom->manufacturer)
2894             fprintf(stdout, "Manufacturer: %s\n",eeprom->manufacturer);
2895         if(eeprom->product)
2896             fprintf(stdout, "Product:      %s\n",eeprom->product);
2897         if(eeprom->serial)
2898             fprintf(stdout, "Serial:       %s\n",eeprom->serial);
2899         fprintf(stdout,     "Checksum      : %04x\n", checksum);
2900         if (ftdi->type == TYPE_R)
2901             fprintf(stdout,     "Internal EEPROM\n");
2902         else if (eeprom->chip >= 0x46)
2903             fprintf(stdout,     "Attached EEPROM: 93x%02x\n", eeprom->chip);
2904         if(eeprom->suspend_dbus7)
2905             fprintf(stdout, "Suspend on DBUS7\n");
2906         if(eeprom->suspend_pull_downs)
2907             fprintf(stdout, "Pull IO pins low during suspend\n");
2908         if(eeprom->remote_wakeup)
2909             fprintf(stdout, "Enable Remote Wake Up\n");
2910         fprintf(stdout, "PNP: %d\n",(eeprom->is_not_pnp)?0:1);
2911         if (ftdi->type >= TYPE_2232C)
2912             fprintf(stdout,"Channel A has Mode %s%s%s\n",
2913                     channel_mode[eeprom->channel_a_type],
2914                     (eeprom->channel_a_driver)?" VCP":"",
2915                     (eeprom->high_current_a)?" High Current IO":"");
2916         if ((ftdi->type >= TYPE_2232C) && (ftdi->type != TYPE_R))
2917             fprintf(stdout,"Channel B has Mode %s%s%s\n",
2918                     channel_mode[eeprom->channel_b_type],
2919                     (eeprom->channel_b_driver)?" VCP":"",
2920                     (eeprom->high_current_b)?" High Current IO":"");
2921         if (((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C)) &&
2922             eeprom->use_usb_version == USE_USB_VERSION_BIT)
2923             fprintf(stdout,"Use explicit USB Version %04x\n",eeprom->usb_version);
2924
2925         if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
2926         {
2927             fprintf(stdout,"%s has %d mA drive%s%s\n",
2928                     (ftdi->type == TYPE_2232H)?"AL":"A",
2929                     (eeprom->group0_drive+1) *4,
2930                     (eeprom->group0_schmitt)?" Schmitt Input":"",
2931                     (eeprom->group0_slew)?" Slow Slew":"");
2932             fprintf(stdout,"%s has %d mA drive%s%s\n",
2933                     (ftdi->type == TYPE_2232H)?"AH":"B",
2934                     (eeprom->group1_drive+1) *4,
2935                     (eeprom->group1_schmitt)?" Schmitt Input":"",
2936                     (eeprom->group1_slew)?" Slow Slew":"");
2937             fprintf(stdout,"%s has %d mA drive%s%s\n",
2938                     (ftdi->type == TYPE_2232H)?"BL":"C",
2939                     (eeprom->group2_drive+1) *4,
2940                     (eeprom->group2_schmitt)?" Schmitt Input":"",
2941                     (eeprom->group2_slew)?" Slow Slew":"");
2942             fprintf(stdout,"%s has %d mA drive%s%s\n",
2943                     (ftdi->type == TYPE_2232H)?"BH":"D",
2944                     (eeprom->group3_drive+1) *4,
2945                     (eeprom->group3_schmitt)?" Schmitt Input":"",
2946                     (eeprom->group3_slew)?" Slow Slew":"");
2947         }
2948         if (ftdi->type == TYPE_R)
2949         {
2950             char *cbus_mux[] = {"TXDEN","PWREN","RXLED", "TXLED","TX+RXLED",
2951                                 "SLEEP","CLK48","CLK24","CLK12","CLK6",
2952                                 "IOMODE","BB_WR","BB_RD"};
2953             char *cbus_BB[] = {"RXF","TXE","RD", "WR"};
2954             int i;
2955
2956             if(eeprom->invert)
2957             {
2958                 char *r_bits[] = {"TXD","RXD","RTS", "CTS","DTR","DSR","DCD","RI"};
2959                 fprintf(stdout,"Inverted bits:");
2960                 for (i=0; i<8; i++)
2961                     if((eeprom->invert & (1<<i)) == (1<<i))
2962                         fprintf(stdout," %s",r_bits[i]);
2963                 fprintf(stdout,"\n");
2964             }
2965             for(i=0; i<5; i++)
2966             {
2967                 if(eeprom->cbus_function[i]<CBUS_BB)
2968                     fprintf(stdout,"C%d Function: %s\n", i,
2969                             cbus_mux[eeprom->cbus_function[i]]);
2970                 else
2971                     fprintf(stdout,"C%d BB Function: %s\n", i,
2972                             cbus_BB[i]);
2973             }
2974         }
2975     }
2976     return 0;
2977 }
2978
2979 /**
2980     Read eeprom location
2981
2982     \param ftdi pointer to ftdi_context
2983     \param eeprom_addr Address of eeprom location to be read
2984     \param eeprom_val Pointer to store read eeprom location
2985
2986     \retval  0: all fine
2987     \retval -1: read failed
2988     \retval -2: USB device unavailable
2989 */
2990 int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
2991 {
2992     if (ftdi == NULL || ftdi->usb_dev == NULL)
2993         ftdi_error_return(-2, "USB device unavailable");
2994
2995     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)
2996         ftdi_error_return(-1, "reading eeprom failed");
2997
2998     return 0;
2999 }
3000
3001 /**
3002     Read eeprom
3003
3004     \param ftdi pointer to ftdi_context
3005
3006     \retval  0: all fine
3007     \retval -1: read failed
3008     \retval -2: USB device unavailable
3009 */
3010 int ftdi_read_eeprom(struct ftdi_context *ftdi)
3011 {
3012     int i;
3013     unsigned char *buf;
3014
3015     if (ftdi == NULL || ftdi->usb_dev == NULL)
3016         ftdi_error_return(-2, "USB device unavailable");
3017     buf = ftdi->eeprom->buf;
3018
3019     for (i = 0; i < FTDI_MAX_EEPROM_SIZE/2; i++)
3020     {
3021         if (libusb_control_transfer(
3022                 ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,SIO_READ_EEPROM_REQUEST, 0, i,
3023                 buf+(i*2), 2, ftdi->usb_read_timeout) != 2)
3024             ftdi_error_return(-1, "reading eeprom failed");
3025     }
3026
3027     if (ftdi->type == TYPE_R)
3028         ftdi->eeprom->size = 0x80;
3029     /*    Guesses size of eeprom by comparing halves
3030           - will not work with blank eeprom */
3031     else if (strrchr((const char *)buf, 0xff) == ((const char *)buf +FTDI_MAX_EEPROM_SIZE -1))
3032         ftdi->eeprom->size = -1;
3033     else if(memcmp(buf,&buf[0x80],0x80) == 0)
3034         ftdi->eeprom->size = 0x80;
3035     else if(memcmp(buf,&buf[0x40],0x40) == 0)
3036         ftdi->eeprom->size = 0x40;
3037     else
3038         ftdi->eeprom->size = 0x100;
3039     return 0;
3040 }
3041
3042 /*
3043     ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID
3044     Function is only used internally
3045     \internal
3046 */
3047 static unsigned char ftdi_read_chipid_shift(unsigned char value)
3048 {
3049     return ((value & 1) << 1) |
3050            ((value & 2) << 5) |
3051            ((value & 4) >> 2) |
3052            ((value & 8) << 4) |
3053            ((value & 16) >> 1) |
3054            ((value & 32) >> 1) |
3055            ((value & 64) >> 4) |
3056            ((value & 128) >> 2);
3057 }
3058
3059 /**
3060     Read the FTDIChip-ID from R-type devices
3061
3062     \param ftdi pointer to ftdi_context
3063     \param chipid Pointer to store FTDIChip-ID
3064
3065     \retval  0: all fine
3066     \retval -1: read failed
3067     \retval -2: USB device unavailable
3068 */
3069 int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
3070 {
3071     unsigned int a = 0, b = 0;
3072
3073     if (ftdi == NULL || ftdi->usb_dev == NULL)
3074         ftdi_error_return(-2, "USB device unavailable");
3075
3076     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)
3077     {
3078         a = a << 8 | a >> 8;
3079         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)
3080         {
3081             b = b << 8 | b >> 8;
3082             a = (a << 16) | (b & 0xFFFF);
3083             a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
3084                 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
3085             *chipid = a ^ 0xa5f0f7d1;
3086             return 0;
3087         }
3088     }
3089
3090     ftdi_error_return(-1, "read of FTDIChip-ID failed");
3091 }
3092
3093 /**
3094     Write eeprom location
3095
3096     \param ftdi pointer to ftdi_context
3097     \param eeprom_addr Address of eeprom location to be written
3098     \param eeprom_val Value to be written
3099
3100     \retval  0: all fine
3101     \retval -1: write failed
3102     \retval -2: USB device unavailable
3103     \retval -3: Invalid access to checksum protected area below 0x80
3104     \retval -4: Device can't access unprotected area
3105     \retval -5: Reading chip type failed
3106 */
3107 int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr,
3108                                unsigned short eeprom_val)
3109 {
3110     int chip_type_location;
3111     unsigned short chip_type;
3112
3113     if (ftdi == NULL || ftdi->usb_dev == NULL)
3114         ftdi_error_return(-2, "USB device unavailable");
3115
3116     if(eeprom_addr <0x80)
3117         ftdi_error_return(-2, "Invalid access to checksum protected area  below 0x80");
3118
3119
3120     switch (ftdi->type)
3121     {
3122     case TYPE_BM:
3123     case  TYPE_2232C:
3124         chip_type_location = 0x14;
3125         break;
3126     case TYPE_2232H:
3127     case TYPE_4232H:
3128         chip_type_location = 0x18;
3129         break;
3130     default:
3131         ftdi_error_return(-4, "Device can't access unprotected area");
3132     }
3133
3134     if (ftdi_read_eeprom_location( ftdi, chip_type_location>>1, &chip_type))
3135         ftdi_error_return(-5, "Reading failed failed");
3136     fprintf(stderr," loc 0x%04x val 0x%04x\n", chip_type_location,chip_type);
3137     if((chip_type & 0xff) != 0x66)
3138     {
3139         ftdi_error_return(-6, "EEPROM is not of 93x66");
3140     }
3141
3142     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3143                                     SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
3144                                     NULL, 0, ftdi->usb_write_timeout) != 0)
3145         ftdi_error_return(-1, "unable to write eeprom");
3146
3147     return 0;
3148 }
3149
3150 /**
3151     Write eeprom
3152
3153     \param ftdi pointer to ftdi_context
3154
3155     \retval  0: all fine
3156     \retval -1: read failed
3157     \retval -2: USB device unavailable
3158 */
3159 int ftdi_write_eeprom(struct ftdi_context *ftdi)
3160 {
3161     unsigned short usb_val, status;
3162     int i, ret;
3163     unsigned char *eeprom;
3164
3165     if (ftdi == NULL || ftdi->usb_dev == NULL)
3166         ftdi_error_return(-2, "USB device unavailable");
3167     eeprom = ftdi->eeprom->buf;
3168
3169     /* These commands were traced while running MProg */
3170     if ((ret = ftdi_usb_reset(ftdi)) != 0)
3171         return ret;
3172     if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0)
3173         return ret;
3174     if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0)
3175         return ret;
3176
3177     for (i = 0; i < ftdi->eeprom->size/2; i++)
3178     {
3179         usb_val = eeprom[i*2];
3180         usb_val += eeprom[(i*2)+1] << 8;
3181         if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3182                                     SIO_WRITE_EEPROM_REQUEST, usb_val, i,
3183                                     NULL, 0, ftdi->usb_write_timeout) < 0)
3184             ftdi_error_return(-1, "unable to write eeprom");
3185     }
3186
3187     return 0;
3188 }
3189
3190 /**
3191     Erase eeprom
3192
3193     This is not supported on FT232R/FT245R according to the MProg manual from FTDI.
3194
3195     \param ftdi pointer to ftdi_context
3196
3197     \retval  0: all fine
3198     \retval -1: erase failed
3199     \retval -2: USB device unavailable
3200     \retval -3: Writing magic failed
3201     \retval -4: Read EEPROM failed
3202     \retval -5: Unexpected EEPROM value
3203 */
3204 #define MAGIC 0x55aa
3205 int ftdi_erase_eeprom(struct ftdi_context *ftdi)
3206 {
3207     unsigned short eeprom_value;
3208     if (ftdi == NULL || ftdi->usb_dev == NULL)
3209         ftdi_error_return(-2, "USB device unavailable");
3210
3211     if(ftdi->type == TYPE_R)
3212     {
3213         ftdi->eeprom->chip = 0;
3214         return 0;
3215     }
3216
3217     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
3218                                 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
3219         ftdi_error_return(-1, "unable to erase eeprom");
3220
3221
3222     /* detect chip type by writing 0x55AA as magic at word position 0xc0
3223        Chip is 93x46 if magic is read at word position 0x00, as wraparound happens around 0x40
3224        Chip is 93x56 if magic is read at word position 0x40, as wraparound happens around 0x80
3225        Chip is 93x66 if magic is only read at word position 0xc0*/
3226     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3227                                     SIO_WRITE_EEPROM_REQUEST, MAGIC, 0xc0,
3228                                     NULL, 0, ftdi->usb_write_timeout) != 0)
3229         ftdi_error_return(-3, "Writing magic failed");
3230     if (ftdi_read_eeprom_location( ftdi, 0x00, &eeprom_value))
3231         ftdi_error_return(-4, "Reading failed failed");
3232     if(eeprom_value == MAGIC)
3233     {
3234         ftdi->eeprom->chip = 0x46;
3235     }
3236     else
3237     {
3238         if (ftdi_read_eeprom_location( ftdi, 0x40, &eeprom_value))
3239             ftdi_error_return(-4, "Reading failed failed");
3240         if(eeprom_value == MAGIC)
3241             ftdi->eeprom->chip = 0x56;
3242         else
3243         {
3244             if (ftdi_read_eeprom_location( ftdi, 0xc0, &eeprom_value))
3245                 ftdi_error_return(-4, "Reading failed failed");
3246             if(eeprom_value == MAGIC)
3247                 ftdi->eeprom->chip = 0x66;
3248             else
3249             {
3250                 ftdi->eeprom->chip = -1;
3251             }
3252         }
3253     }
3254     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
3255                                 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
3256         ftdi_error_return(-1, "unable to erase eeprom");
3257     return 0;
3258 }
3259
3260 /**
3261     Get string representation for last error code
3262
3263     \param ftdi pointer to ftdi_context
3264
3265     \retval Pointer to error string
3266 */
3267 char *ftdi_get_error_string (struct ftdi_context *ftdi)
3268 {
3269     if (ftdi == NULL)
3270         return "";
3271
3272     return ftdi->error_str;
3273 }
3274
3275 /* @} end of doxygen libftdi group */