developer.intra2net.com Git - libftdi/blob - src/ftdi.c

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