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