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 or ftdi pointer
2260     \retval -3: Invalid cbus function setting     (FIXME: Not in the code?)
2261     \retval -4: Chip doesn't support invert       (FIXME: Not in the code?)
2262     \retval -5: Chip doesn't support high current drive         (FIXME: Not in the code?)
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(-6,"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         default:
2315             user_area_size = 0;
2316             break;
2317     }
2318     user_area_size  -= (manufacturer_size + product_size + serial_size) * 2;
2319
2320     if (user_area_size < 0)
2321         ftdi_error_return(-1,"eeprom size exceeded");
2322
2323     // empty eeprom
2324     memset (ftdi->eeprom->buf, 0, FTDI_MAX_EEPROM_SIZE);
2325
2326     // Bytes and Bits set for all Types
2327
2328     // Addr 02: Vendor ID
2329     output[0x02] = eeprom->vendor_id;
2330     output[0x03] = eeprom->vendor_id >> 8;
2331
2332     // Addr 04: Product ID
2333     output[0x04] = eeprom->product_id;
2334     output[0x05] = eeprom->product_id >> 8;
2335
2336     // Addr 06: Device release number (0400h for BM features)
2337     output[0x06] = 0x00;
2338     switch (ftdi->type)
2339     {
2340         case TYPE_AM:
2341             output[0x07] = 0x02;
2342             break;
2343         case TYPE_BM:
2344             output[0x07] = 0x04;
2345             break;
2346         case TYPE_2232C:
2347             output[0x07] = 0x05;
2348             break;
2349         case TYPE_R:
2350             output[0x07] = 0x06;
2351             break;
2352         case TYPE_2232H:
2353             output[0x07] = 0x07;
2354             break;
2355         case TYPE_4232H:
2356             output[0x07] = 0x08;
2357             break;
2358         default:
2359             output[0x07] = 0x00;
2360     }
2361
2362     // Addr 08: Config descriptor
2363     // Bit 7: always 1
2364     // Bit 6: 1 if this device is self powered, 0 if bus powered
2365     // Bit 5: 1 if this device uses remote wakeup
2366     // Bit 4-0: reserved - 0
2367     j = 0x80;
2368     if (eeprom->self_powered == 1)
2369         j |= 0x40;
2370     if (eeprom->remote_wakeup == 1)
2371         j |= 0x20;
2372     output[0x08] = j;
2373
2374     // Addr 09: Max power consumption: max power = value * 2 mA
2375     output[0x09] = eeprom->max_power>>1;
2376
2377     if (ftdi->type != TYPE_AM)
2378     {
2379         // Addr 0A: Chip configuration
2380         // Bit 7: 0 - reserved
2381         // Bit 6: 0 - reserved
2382         // Bit 5: 0 - reserved
2383         // Bit 4: 1 - Change USB version
2384         // Bit 3: 1 - Use the serial number string
2385         // Bit 2: 1 - Enable suspend pull downs for lower power
2386         // Bit 1: 1 - Out EndPoint is Isochronous
2387         // Bit 0: 1 - In EndPoint is Isochronous
2388         //
2389         j = 0;
2390         if (eeprom->in_is_isochronous == 1)
2391             j = j | 1;
2392         if (eeprom->out_is_isochronous == 1)
2393             j = j | 2;
2394         output[0x0A] = j;
2395     }
2396
2397     // Dynamic content
2398     // Strings start at 0x94 (TYPE_AM, TYPE_BM)
2399     // 0x96 (TYPE_2232C), 0x98 (TYPE_R) and 0x9a (TYPE_x232H)
2400     i = 0;
2401     switch (ftdi->type)
2402     {
2403         case TYPE_2232H:
2404         case TYPE_4232H:
2405             i += 2;
2406         case TYPE_R:
2407             i += 2;
2408         case TYPE_2232C:
2409             i += 2;
2410         case TYPE_AM:
2411         case TYPE_BM:
2412             i += 0x94;
2413     }
2414     /* Wrap around 0x80 for 128 byte EEPROMS (Internale and 93x46) */
2415     eeprom_size_mask = eeprom->size -1;
2416
2417     // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2418     // Addr 0F: Length of manufacturer string
2419     // Output manufacturer
2420     output[0x0E] = i;  // calculate offset
2421     output[i & eeprom_size_mask] = manufacturer_size*2 + 2, i++;
2422     output[i & eeprom_size_mask] = 0x03, i++; // type: string
2423     for (j = 0; j < manufacturer_size; j++)
2424     {
2425         output[i & eeprom_size_mask] = eeprom->manufacturer[j], i++;
2426         output[i & eeprom_size_mask] = 0x00, i++;
2427     }
2428     output[0x0F] = manufacturer_size*2 + 2;
2429
2430     // Addr 10: Offset of the product string + 0x80, calculated later
2431     // Addr 11: Length of product string
2432     output[0x10] = i | 0x80;  // calculate offset
2433     output[i & eeprom_size_mask] = product_size*2 + 2, i++;
2434     output[i & eeprom_size_mask] = 0x03, i++;
2435     for (j = 0; j < product_size; j++)
2436     {
2437         output[i & eeprom_size_mask] = eeprom->product[j], i++;
2438         output[i & eeprom_size_mask] = 0x00, i++;
2439     }
2440     output[0x11] = product_size*2 + 2;
2441
2442     // Addr 12: Offset of the serial string + 0x80, calculated later
2443     // Addr 13: Length of serial string
2444     output[0x12] = i | 0x80; // calculate offset
2445     output[i & eeprom_size_mask] = serial_size*2 + 2, i++;
2446     output[i & eeprom_size_mask] = 0x03, i++;
2447     for (j = 0; j < serial_size; j++)
2448     {
2449         output[i & eeprom_size_mask] = eeprom->serial[j], i++;
2450         output[i & eeprom_size_mask] = 0x00, i++;
2451     }
2452
2453     // Legacy port name and PnP fields for FT2232 and newer chips
2454     if (ftdi->type > TYPE_BM)
2455     {
2456         output[i & eeprom_size_mask] = 0x02; /* as seen when written with FTD2XX */
2457         i++;
2458         output[i & eeprom_size_mask] = 0x03; /* as seen when written with FTD2XX */
2459         i++;
2460         output[i & eeprom_size_mask] = eeprom->is_not_pnp; /* as seen when written with FTD2XX */
2461         i++;
2462     }
2463
2464     output[0x13] = serial_size*2 + 2;
2465
2466     if (ftdi->type > TYPE_AM) /* use_serial not used in AM devices */
2467     {
2468         if (eeprom->use_serial == USE_SERIAL_NUM )
2469             output[0x0A] |= USE_SERIAL_NUM;
2470         else
2471             output[0x0A] &= ~USE_SERIAL_NUM;
2472     }
2473
2474     /* Bytes and Bits specific to (some) types
2475        Write linear, as this allows easier fixing*/
2476     switch (ftdi->type)
2477     {
2478         case TYPE_AM:
2479             break;
2480         case TYPE_BM:
2481             output[0x0C] = eeprom->usb_version & 0xff;
2482             output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2483             if (eeprom->use_usb_version == USE_USB_VERSION_BIT)
2484                 output[0x0A] |= USE_USB_VERSION_BIT;
2485             else
2486                 output[0x0A] &= ~USE_USB_VERSION_BIT;
2487
2488             break;
2489         case TYPE_2232C:
2490
2491             output[0x00] = (eeprom->channel_a_type);
2492             if ( eeprom->channel_a_driver == DRIVER_VCP)
2493                 output[0x00] |= DRIVER_VCP;
2494             else
2495                 output[0x00] &= ~DRIVER_VCP;
2496
2497             if ( eeprom->high_current_a == HIGH_CURRENT_DRIVE)
2498                 output[0x00] |= HIGH_CURRENT_DRIVE;
2499             else
2500                 output[0x00] &= ~HIGH_CURRENT_DRIVE;
2501
2502             output[0x01] = (eeprom->channel_b_type);
2503             if ( eeprom->channel_b_driver == DRIVER_VCP)
2504                 output[0x01] |= DRIVER_VCP;
2505             else
2506                 output[0x01] &= ~DRIVER_VCP;
2507
2508             if ( eeprom->high_current_b == HIGH_CURRENT_DRIVE)
2509                 output[0x01] |= HIGH_CURRENT_DRIVE;
2510             else
2511                 output[0x01] &= ~HIGH_CURRENT_DRIVE;
2512
2513             if (eeprom->in_is_isochronous == 1)
2514                 output[0x0A] |= 0x1;
2515             else
2516                 output[0x0A] &= ~0x1;
2517             if (eeprom->out_is_isochronous == 1)
2518                 output[0x0A] |= 0x2;
2519             else
2520                 output[0x0A] &= ~0x2;
2521             if (eeprom->suspend_pull_downs == 1)
2522                 output[0x0A] |= 0x4;
2523             else
2524                 output[0x0A] &= ~0x4;
2525             if (eeprom->use_usb_version == USE_USB_VERSION_BIT)
2526                 output[0x0A] |= USE_USB_VERSION_BIT;
2527             else
2528                 output[0x0A] &= ~USE_USB_VERSION_BIT;
2529
2530             output[0x0C] = eeprom->usb_version & 0xff;
2531             output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2532             output[0x14] = eeprom->chip;
2533             break;
2534         case TYPE_R:
2535             if (eeprom->high_current == HIGH_CURRENT_DRIVE_R)
2536                 output[0x00] |= HIGH_CURRENT_DRIVE_R;
2537             output[0x01] = 0x40; /* Hard coded Endpoint Size*/
2538
2539             if (eeprom->suspend_pull_downs == 1)
2540                 output[0x0A] |= 0x4;
2541             else
2542                 output[0x0A] &= ~0x4;
2543             output[0x0B] = eeprom->invert;
2544             output[0x0C] = eeprom->usb_version & 0xff;
2545             output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2546
2547             if (eeprom->cbus_function[0] > CBUS_BB)
2548                 output[0x14] = CBUS_TXLED;
2549             else
2550                 output[0x14] = eeprom->cbus_function[0];
2551
2552             if (eeprom->cbus_function[1] > CBUS_BB)
2553                 output[0x14] |= CBUS_RXLED<<4;
2554             else
2555                 output[0x14] |= eeprom->cbus_function[1]<<4;
2556
2557             if (eeprom->cbus_function[2] > CBUS_BB)
2558                 output[0x15] = CBUS_TXDEN;
2559             else
2560                 output[0x15] = eeprom->cbus_function[2];
2561
2562             if (eeprom->cbus_function[3] > CBUS_BB)
2563                 output[0x15] |= CBUS_PWREN<<4;
2564             else
2565                 output[0x15] |= eeprom->cbus_function[3]<<4;
2566
2567             if (eeprom->cbus_function[4] > CBUS_CLK6)
2568                 output[0x16] = CBUS_SLEEP;
2569             else
2570                 output[0x16] = eeprom->cbus_function[4];
2571             break;
2572         case TYPE_2232H:
2573             output[0x00] = (eeprom->channel_a_type);
2574             if ( eeprom->channel_a_driver == DRIVER_VCP)
2575                 output[0x00] |= DRIVER_VCP;
2576             else
2577                 output[0x00] &= ~DRIVER_VCP;
2578
2579             output[0x01] = (eeprom->channel_b_type);
2580             if ( eeprom->channel_b_driver == DRIVER_VCP)
2581                 output[0x01] |= DRIVER_VCP;
2582             else
2583                 output[0x01] &= ~DRIVER_VCP;
2584             if (eeprom->suspend_dbus7 == SUSPEND_DBUS7_BIT)
2585                 output[0x01] |= SUSPEND_DBUS7_BIT;
2586             else
2587                 output[0x01] &= ~SUSPEND_DBUS7_BIT;
2588
2589             if (eeprom->suspend_pull_downs == 1)
2590                 output[0x0A] |= 0x4;
2591             else
2592                 output[0x0A] &= ~0x4;
2593
2594             if (eeprom->group0_drive > DRIVE_16MA)
2595                 output[0x0c] |= DRIVE_16MA;
2596             else
2597                 output[0x0c] |= eeprom->group0_drive;
2598             if (eeprom->group0_schmitt == IS_SCHMITT)
2599                 output[0x0c] |= IS_SCHMITT;
2600             if (eeprom->group0_slew == SLOW_SLEW)
2601                 output[0x0c] |= SLOW_SLEW;
2602
2603             if (eeprom->group1_drive > DRIVE_16MA)
2604                 output[0x0c] |= DRIVE_16MA<<4;
2605             else
2606                 output[0x0c] |= eeprom->group1_drive<<4;
2607             if (eeprom->group1_schmitt == IS_SCHMITT)
2608                 output[0x0c] |= IS_SCHMITT<<4;
2609             if (eeprom->group1_slew == SLOW_SLEW)
2610                 output[0x0c] |= SLOW_SLEW<<4;
2611
2612             if (eeprom->group2_drive > DRIVE_16MA)
2613                 output[0x0d] |= DRIVE_16MA;
2614             else
2615                 output[0x0d] |= eeprom->group2_drive;
2616             if (eeprom->group2_schmitt == IS_SCHMITT)
2617                 output[0x0d] |= IS_SCHMITT;
2618             if (eeprom->group2_slew == SLOW_SLEW)
2619                 output[0x0d] |= SLOW_SLEW;
2620
2621             if (eeprom->group3_drive > DRIVE_16MA)
2622                 output[0x0d] |= DRIVE_16MA<<4;
2623             else
2624                 output[0x0d] |= eeprom->group3_drive<<4;
2625             if (eeprom->group3_schmitt == IS_SCHMITT)
2626                 output[0x0d] |= IS_SCHMITT<<4;
2627             if (eeprom->group3_slew == SLOW_SLEW)
2628                 output[0x0d] |= SLOW_SLEW<<4;
2629
2630             output[0x18] = eeprom->chip;
2631
2632             break;
2633         case TYPE_4232H:
2634             fprintf(stderr,"FIXME: Build FT4232H specific EEPROM settings\n");
2635     }
2636
2637     // calculate checksum
2638     checksum = 0xAAAA;
2639
2640     for (i = 0; i < eeprom->size/2-1; i++)
2641     {
2642         value = output[i*2];
2643         value += output[(i*2)+1] << 8;
2644
2645         checksum = value^checksum;
2646         checksum = (checksum << 1) | (checksum >> 15);
2647     }
2648
2649     output[eeprom->size-2] = checksum;
2650     output[eeprom->size-1] = checksum >> 8;
2651
2652     return user_area_size;
2653 }
2654
2655 /**
2656    Decode binary EEPROM image into an ftdi_eeprom structure.
2657
2658    \param ftdi pointer to ftdi_context
2659    \param verbose Decode EEPROM on stdout
2660
2661    \retval 0: all fine
2662    \retval -1: something went wrong
2663
2664    FIXME: How to pass size? How to handle size field in ftdi_eeprom?
2665    FIXME: Strings are malloc'ed here and should be freed somewhere
2666 */
2667 int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose)
2668 {
2669     unsigned char i, j;
2670     unsigned short checksum, eeprom_checksum, value;
2671     unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2672     int eeprom_size;
2673     struct ftdi_eeprom *eeprom;
2674     unsigned char *buf = ftdi->eeprom->buf;
2675     int release;
2676
2677     if (ftdi == NULL)
2678         ftdi_error_return(-1,"No context");
2679     if (ftdi->eeprom == NULL)
2680         ftdi_error_return(-1,"No eeprom structure");
2681
2682     eeprom = ftdi->eeprom;
2683     eeprom_size = eeprom->size;
2684
2685     // Addr 02: Vendor ID
2686     eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
2687
2688     // Addr 04: Product ID
2689     eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
2690
2691     release = buf[0x06] + (buf[0x07]<<8);
2692
2693     // Addr 08: Config descriptor
2694     // Bit 7: always 1
2695     // Bit 6: 1 if this device is self powered, 0 if bus powered
2696     // Bit 5: 1 if this device uses remote wakeup
2697     eeprom->self_powered = buf[0x08] & 0x40;
2698     eeprom->remote_wakeup = buf[0x08] & 0x20;
2699
2700     // Addr 09: Max power consumption: max power = value * 2 mA
2701     eeprom->max_power = buf[0x09];
2702
2703     // Addr 0A: Chip configuration
2704     // Bit 7: 0 - reserved
2705     // Bit 6: 0 - reserved
2706     // Bit 5: 0 - reserved
2707     // Bit 4: 1 - Change USB version on BM and 2232C
2708     // Bit 3: 1 - Use the serial number string
2709     // Bit 2: 1 - Enable suspend pull downs for lower power
2710     // Bit 1: 1 - Out EndPoint is Isochronous
2711     // Bit 0: 1 - In EndPoint is Isochronous
2712     //
2713     eeprom->in_is_isochronous  = buf[0x0A]&0x01;
2714     eeprom->out_is_isochronous = buf[0x0A]&0x02;
2715     eeprom->suspend_pull_downs = buf[0x0A]&0x04;
2716     eeprom->use_serial         = buf[0x0A] & USE_SERIAL_NUM;
2717     eeprom->use_usb_version    = buf[0x0A] & USE_USB_VERSION_BIT;
2718
2719     // Addr 0C: USB version low byte when 0x0A
2720     // Addr 0D: USB version high byte when 0x0A
2721     eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
2722
2723     // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2724     // Addr 0F: Length of manufacturer string
2725     manufacturer_size = buf[0x0F]/2;
2726     if (eeprom->manufacturer)
2727         free(eeprom->manufacturer);
2728     if (manufacturer_size > 0)
2729     {
2730         eeprom->manufacturer = malloc(manufacturer_size);
2731         if (eeprom->manufacturer)
2732         {
2733             // Decode manufacturer
2734             i = buf[0x0E] & (eeprom_size -1); // offset
2735             for (j=0;j<manufacturer_size-1;j++)
2736             {
2737                 eeprom->manufacturer[j] = buf[2*j+i+2];
2738             }
2739             eeprom->manufacturer[j] = '\0';
2740         }
2741     }
2742     else eeprom->manufacturer = NULL;
2743
2744     // Addr 10: Offset of the product string + 0x80, calculated later
2745     // Addr 11: Length of product string
2746     if (eeprom->product)
2747         free(eeprom->product);
2748     product_size = buf[0x11]/2;
2749     if (product_size > 0)
2750     {
2751         eeprom->product = malloc(product_size);
2752         if (eeprom->product)
2753         {
2754             // Decode product name
2755             i = buf[0x10] & (eeprom_size -1); // offset
2756             for (j=0;j<product_size-1;j++)
2757             {
2758                 eeprom->product[j] = buf[2*j+i+2];
2759             }
2760             eeprom->product[j] = '\0';
2761         }
2762     }
2763     else eeprom->product = NULL;
2764
2765     // Addr 12: Offset of the serial string + 0x80, calculated later
2766     // Addr 13: Length of serial string
2767     if (eeprom->serial)
2768         free(eeprom->serial);
2769     serial_size = buf[0x13]/2;
2770     if (serial_size > 0)
2771     {
2772         eeprom->serial = malloc(serial_size);
2773         if (eeprom->serial)
2774         {
2775             // Decode serial
2776             i = buf[0x12] & (eeprom_size -1); // offset
2777             for (j=0;j<serial_size-1;j++)
2778             {
2779                 eeprom->serial[j] = buf[2*j+i+2];
2780             }
2781             eeprom->serial[j] = '\0';
2782         }
2783     }
2784     else eeprom->serial = NULL;
2785
2786     // verify checksum
2787     checksum = 0xAAAA;
2788
2789     for (i = 0; i < eeprom_size/2-1; i++)
2790     {
2791         value = buf[i*2];
2792         value += buf[(i*2)+1] << 8;
2793
2794         checksum = value^checksum;
2795         checksum = (checksum << 1) | (checksum >> 15);
2796     }
2797
2798     eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
2799
2800     if (eeprom_checksum != checksum)
2801     {
2802         fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
2803         ftdi_error_return(-1,"EEPROM checksum error");
2804     }
2805
2806     eeprom->channel_a_type   = 0;
2807     if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM))
2808     {
2809         eeprom->chip = -1;
2810     }
2811     else if (ftdi->type == TYPE_2232C)
2812     {
2813         eeprom->channel_a_type   = buf[0x00] & 0x7;
2814         eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
2815         eeprom->high_current_a   = buf[0x00] & HIGH_CURRENT_DRIVE;
2816         eeprom->channel_b_type   = buf[0x01] & 0x7;
2817         eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
2818         eeprom->high_current_b   = buf[0x01] & HIGH_CURRENT_DRIVE;
2819         eeprom->chip = buf[0x14];
2820     }
2821     else if (ftdi->type == TYPE_R)
2822     {
2823         /* TYPE_R flags D2XX, not VCP as all others*/
2824         eeprom->channel_a_driver = (~buf[0x00]) & DRIVER_VCP;
2825         eeprom->high_current     = buf[0x00] & HIGH_CURRENT_DRIVE_R;
2826         if ( (buf[0x01]&0x40) != 0x40)
2827             fprintf(stderr,
2828                     "TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size."
2829                     " If this happened with the\n"
2830                     " EEPROM programmed by FTDI tools, please report "
2831                     "to libftdi@developer.intra2net.com\n");
2832
2833         eeprom->chip = buf[0x16];
2834         // Addr 0B: Invert data lines
2835         // Works only on FT232R, not FT245R, but no way to distinguish
2836         eeprom->invert = buf[0x0B];
2837         // Addr 14: CBUS function: CBUS0, CBUS1
2838         // Addr 15: CBUS function: CBUS2, CBUS3
2839         // Addr 16: CBUS function: CBUS5
2840         eeprom->cbus_function[0] = buf[0x14] & 0x0f;
2841         eeprom->cbus_function[1] = (buf[0x14] >> 4) & 0x0f;
2842         eeprom->cbus_function[2] = buf[0x15] & 0x0f;
2843         eeprom->cbus_function[3] = (buf[0x15] >> 4) & 0x0f;
2844         eeprom->cbus_function[4] = buf[0x16] & 0x0f;
2845     }
2846     else if ((ftdi->type == TYPE_2232H) ||(ftdi->type == TYPE_4232H))
2847     {
2848         eeprom->channel_a_type   = buf[0x00] & 0x7;
2849         eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
2850         eeprom->channel_b_type   = buf[0x01] & 0x7;
2851         eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
2852
2853         if (ftdi->type == TYPE_2232H)
2854             eeprom->suspend_dbus7    = buf[0x01] & SUSPEND_DBUS7_BIT;
2855
2856         eeprom->chip = buf[0x18];
2857         eeprom->group0_drive   =  buf[0x0c]       & DRIVE_16MA;
2858         eeprom->group0_schmitt =  buf[0x0c]       & IS_SCHMITT;
2859         eeprom->group0_slew    =  buf[0x0c]       & SLOW_SLEW;
2860         eeprom->group1_drive   = (buf[0x0c] >> 4) & 0x3;
2861         eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT;
2862         eeprom->group1_slew    = (buf[0x0c] >> 4) & SLOW_SLEW;
2863         eeprom->group2_drive   =  buf[0x0d]       & DRIVE_16MA;
2864         eeprom->group2_schmitt =  buf[0x0d]       & IS_SCHMITT;
2865         eeprom->group2_slew    =  buf[0x0d]       & SLOW_SLEW;
2866         eeprom->group3_drive   = (buf[0x0d] >> 4) & DRIVE_16MA;
2867         eeprom->group3_schmitt = (buf[0x0d] >> 4) & IS_SCHMITT;
2868         eeprom->group3_slew    = (buf[0x0d] >> 4) & SLOW_SLEW;
2869     }
2870
2871     if (verbose)
2872     {
2873         char *channel_mode[] = {"UART","245","CPU", "unknown", "OPTO"};
2874         fprintf(stdout, "VID:     0x%04x\n",eeprom->vendor_id);
2875         fprintf(stdout, "PID:     0x%04x\n",eeprom->product_id);
2876         fprintf(stdout, "Release: 0x%04x\n",release);
2877
2878         if (eeprom->self_powered)
2879             fprintf(stdout, "Self-Powered%s", (eeprom->remote_wakeup)?", USB Remote Wake Up\n":"\n");
2880         else
2881             fprintf(stdout, "Bus Powered: %3d mA%s", eeprom->max_power * 2,
2882                     (eeprom->remote_wakeup)?" USB Remote Wake Up\n":"\n");
2883         if (eeprom->manufacturer)
2884             fprintf(stdout, "Manufacturer: %s\n",eeprom->manufacturer);
2885         if (eeprom->product)
2886             fprintf(stdout, "Product:      %s\n",eeprom->product);
2887         if (eeprom->serial)
2888             fprintf(stdout, "Serial:       %s\n",eeprom->serial);
2889         fprintf(stdout,     "Checksum      : %04x\n", checksum);
2890         if (ftdi->type == TYPE_R)
2891             fprintf(stdout,     "Internal EEPROM\n");
2892         else if (eeprom->chip >= 0x46)
2893             fprintf(stdout,     "Attached EEPROM: 93x%02x\n", eeprom->chip);
2894         if (eeprom->suspend_dbus7)
2895             fprintf(stdout, "Suspend on DBUS7\n");
2896         if (eeprom->suspend_pull_downs)
2897             fprintf(stdout, "Pull IO pins low during suspend\n");
2898         if (eeprom->remote_wakeup)
2899             fprintf(stdout, "Enable Remote Wake Up\n");
2900         fprintf(stdout, "PNP: %d\n",(eeprom->is_not_pnp)?0:1);
2901         if (ftdi->type >= TYPE_2232C)
2902             fprintf(stdout,"Channel A has Mode %s%s%s\n",
2903                     channel_mode[eeprom->channel_a_type],
2904                     (eeprom->channel_a_driver)?" VCP":"",
2905                     (eeprom->high_current_a)?" High Current IO":"");
2906         if ((ftdi->type >= TYPE_2232C) && (ftdi->type != TYPE_R))
2907             fprintf(stdout,"Channel B has Mode %s%s%s\n",
2908                     channel_mode[eeprom->channel_b_type],
2909                     (eeprom->channel_b_driver)?" VCP":"",
2910                     (eeprom->high_current_b)?" High Current IO":"");
2911         if (((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C)) &&
2912                 eeprom->use_usb_version == USE_USB_VERSION_BIT)
2913             fprintf(stdout,"Use explicit USB Version %04x\n",eeprom->usb_version);
2914
2915         if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
2916         {
2917             fprintf(stdout,"%s has %d mA drive%s%s\n",
2918                     (ftdi->type == TYPE_2232H)?"AL":"A",
2919                     (eeprom->group0_drive+1) *4,
2920                     (eeprom->group0_schmitt)?" Schmitt Input":"",
2921                     (eeprom->group0_slew)?" Slow Slew":"");
2922             fprintf(stdout,"%s has %d mA drive%s%s\n",
2923                     (ftdi->type == TYPE_2232H)?"AH":"B",
2924                     (eeprom->group1_drive+1) *4,
2925                     (eeprom->group1_schmitt)?" Schmitt Input":"",
2926                     (eeprom->group1_slew)?" Slow Slew":"");
2927             fprintf(stdout,"%s has %d mA drive%s%s\n",
2928                     (ftdi->type == TYPE_2232H)?"BL":"C",
2929                     (eeprom->group2_drive+1) *4,
2930                     (eeprom->group2_schmitt)?" Schmitt Input":"",
2931                     (eeprom->group2_slew)?" Slow Slew":"");
2932             fprintf(stdout,"%s has %d mA drive%s%s\n",
2933                     (ftdi->type == TYPE_2232H)?"BH":"D",
2934                     (eeprom->group3_drive+1) *4,
2935                     (eeprom->group3_schmitt)?" Schmitt Input":"",
2936                     (eeprom->group3_slew)?" Slow Slew":"");
2937         }
2938         if (ftdi->type == TYPE_R)
2939         {
2940             char *cbus_mux[] = {"TXDEN","PWREN","RXLED", "TXLED","TX+RXLED",
2941                                 "SLEEP","CLK48","CLK24","CLK12","CLK6",
2942                                 "IOMODE","BB_WR","BB_RD"
2943                                };
2944             char *cbus_BB[] = {"RXF","TXE","RD", "WR"};
2945             int i;
2946
2947             if (eeprom->invert)
2948             {
2949                 char *r_bits[] = {"TXD","RXD","RTS", "CTS","DTR","DSR","DCD","RI"};
2950                 fprintf(stdout,"Inverted bits:");
2951                 for (i=0; i<8; i++)
2952                     if ((eeprom->invert & (1<<i)) == (1<<i))
2953                         fprintf(stdout," %s",r_bits[i]);
2954                 fprintf(stdout,"\n");
2955             }
2956             for (i=0; i<5; i++)
2957             {
2958                 if (eeprom->cbus_function[i]<CBUS_BB)
2959                     fprintf(stdout,"C%d Function: %s\n", i,
2960                             cbus_mux[eeprom->cbus_function[i]]);
2961                 else
2962                 {
2963                     /* FIXME for Uwe: This results in an access above array bounds.
2964                        Also I couldn't find documentation about this mode.
2965                     fprintf(stdout,"C%d BB Function: %s\n", i,
2966                             cbus_BB[i]);
2967                     */
2968                     fprintf(stdout, "Unknown CBUS mode. Might be special mode?\n");
2969                     (void)cbus_BB;
2970                 }
2971             }
2972         }
2973     }
2974     return 0;
2975 }
2976
2977 /**
2978    Get a value from the decoded EEPROM structure
2979
2980    \param ftdi pointer to ftdi_context
2981    \param value_name Enum of the value to query
2982    \param value Pointer to store read value
2983
2984    \retval 0: all fine
2985    \retval -1: Value doesn't exist
2986 */
2987 int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int* value)
2988 {
2989     switch (value_name)
2990     {
2991         case VENDOR_ID:
2992             *value = ftdi->eeprom->vendor_id;
2993             break;
2994         case PRODUCT_ID:
2995             *value = ftdi->eeprom->product_id;
2996             break;
2997         case SELF_POWERED:
2998             *value = ftdi->eeprom->self_powered;
2999             break;
3000         case REMOTE_WAKEUP:
3001             *value = ftdi->eeprom->remote_wakeup;
3002             break;
3003         case IS_NOT_PNP:
3004             *value = ftdi->eeprom->is_not_pnp;
3005             break;
3006         case SUSPEND_DBUS7:
3007             *value = ftdi->eeprom->suspend_dbus7;
3008             break;
3009         case IN_IS_ISOCHRONOUS:
3010             *value = ftdi->eeprom->in_is_isochronous;
3011             break;
3012         case SUSPEND_PULL_DOWNS:
3013             *value = ftdi->eeprom->suspend_pull_downs;
3014             break;
3015         case USE_SERIAL:
3016             *value = ftdi->eeprom->use_serial;
3017             break;
3018         case USB_VERSION:
3019             *value = ftdi->eeprom->usb_version;
3020             break;
3021         case MAX_POWER:
3022             *value = ftdi->eeprom->max_power;
3023             break;
3024         case CHANNEL_A_TYPE:
3025             *value = ftdi->eeprom->channel_a_type;
3026             break;
3027         case CHANNEL_B_TYPE:
3028             *value = ftdi->eeprom->channel_b_type;
3029             break;
3030         case CHANNEL_A_DRIVER:
3031             *value = ftdi->eeprom->channel_a_driver;
3032             break;
3033         case CHANNEL_B_DRIVER:
3034             *value = ftdi->eeprom->channel_b_driver;
3035             break;
3036         case CBUS_FUNCTION_0:
3037             *value = ftdi->eeprom->cbus_function[0];
3038             break;
3039         case CBUS_FUNCTION_1:
3040             *value = ftdi->eeprom->cbus_function[1];
3041             break;
3042         case CBUS_FUNCTION_2:
3043             *value = ftdi->eeprom->cbus_function[2];
3044             break;
3045         case CBUS_FUNCTION_3:
3046             *value = ftdi->eeprom->cbus_function[3];
3047             break;
3048         case CBUS_FUNCTION_4:
3049             *value = ftdi->eeprom->cbus_function[4];
3050             break;
3051         case HIGH_CURRENT:
3052             *value = ftdi->eeprom->high_current;
3053             break;
3054         case HIGH_CURRENT_A:
3055             *value = ftdi->eeprom->high_current_a;
3056             break;
3057         case HIGH_CURRENT_B:
3058             *value = ftdi->eeprom->high_current_b;
3059             break;
3060         case INVERT:
3061             *value = ftdi->eeprom->invert;
3062             break;
3063         case GROUP0_DRIVE:
3064             *value = ftdi->eeprom->group0_drive;
3065             break;
3066         case GROUP0_SCHMITT:
3067             *value = ftdi->eeprom->group0_schmitt;
3068             break;
3069         case GROUP0_SLEW:
3070             *value = ftdi->eeprom->group0_slew;
3071             break;
3072         case GROUP1_DRIVE:
3073             *value = ftdi->eeprom->group1_drive;
3074             break;
3075         case GROUP1_SCHMITT:
3076             *value = ftdi->eeprom->group1_schmitt;
3077             break;
3078         case GROUP1_SLEW:
3079             *value = ftdi->eeprom->group1_slew;
3080             break;
3081         case GROUP2_DRIVE:
3082             *value = ftdi->eeprom->group2_drive;
3083             break;
3084         case GROUP2_SCHMITT:
3085             *value = ftdi->eeprom->group2_schmitt;
3086             break;
3087         case GROUP2_SLEW:
3088             *value = ftdi->eeprom->group2_slew;
3089             break;
3090         case GROUP3_DRIVE:
3091             *value = ftdi->eeprom->group3_drive;
3092             break;
3093         case GROUP3_SCHMITT:
3094             *value = ftdi->eeprom->group3_schmitt;
3095             break;
3096         case GROUP3_SLEW:
3097             *value = ftdi->eeprom->group3_slew;
3098             break;
3099         case CHIP_TYPE:
3100             *value = ftdi->eeprom->chip;
3101             break;
3102         case CHIP_SIZE:
3103             *value = ftdi->eeprom->size;
3104             break;
3105         default:
3106             ftdi_error_return(-1, "Request for unknown EEPROM value");
3107     }
3108     return 0;
3109 }
3110
3111 /**
3112    Set a value in the decoded EEPROM Structure
3113    No parameter checking is performed
3114
3115    \param ftdi pointer to ftdi_context
3116    \param value_name Enum of the value to query
3117    \param value to set
3118
3119    \retval 0: all fine
3120    \retval -1: Value doesn't exist
3121    \retval -2: Value not user settable
3122 */
3123 int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int value)
3124 {
3125     switch (value_name)
3126     {
3127         case VENDOR_ID:
3128             ftdi->eeprom->vendor_id = value;
3129             break;
3130         case PRODUCT_ID:
3131             ftdi->eeprom->product_id = value;
3132             break;
3133         case SELF_POWERED:
3134             ftdi->eeprom->self_powered = value;
3135             break;
3136         case REMOTE_WAKEUP:
3137             ftdi->eeprom->remote_wakeup = value;
3138             break;
3139         case IS_NOT_PNP:
3140             ftdi->eeprom->is_not_pnp = value;
3141             break;
3142         case SUSPEND_DBUS7:
3143             ftdi->eeprom->suspend_dbus7 = value;
3144             break;
3145         case IN_IS_ISOCHRONOUS:
3146             ftdi->eeprom->in_is_isochronous = value;
3147             break;
3148         case SUSPEND_PULL_DOWNS:
3149             ftdi->eeprom->suspend_pull_downs = value;
3150             break;
3151         case USE_SERIAL:
3152             ftdi->eeprom->use_serial = value;
3153             break;
3154         case USB_VERSION:
3155             ftdi->eeprom->usb_version = value;
3156             break;
3157         case MAX_POWER:
3158             ftdi->eeprom->max_power = value;
3159             break;
3160         case CHANNEL_A_TYPE:
3161             ftdi->eeprom->channel_a_type = value;
3162             break;
3163         case CHANNEL_B_TYPE:
3164             ftdi->eeprom->channel_b_type = value;
3165             break;
3166         case CHANNEL_A_DRIVER:
3167             ftdi->eeprom->channel_a_driver = value;
3168             break;
3169         case CHANNEL_B_DRIVER:
3170             ftdi->eeprom->channel_b_driver = value;
3171             break;
3172         case CBUS_FUNCTION_0:
3173             ftdi->eeprom->cbus_function[0] = value;
3174             break;
3175         case CBUS_FUNCTION_1:
3176             ftdi->eeprom->cbus_function[1] = value;
3177             break;
3178         case CBUS_FUNCTION_2:
3179             ftdi->eeprom->cbus_function[2] = value;
3180             break;
3181         case CBUS_FUNCTION_3:
3182             ftdi->eeprom->cbus_function[3] = value;
3183             break;
3184         case CBUS_FUNCTION_4:
3185             ftdi->eeprom->cbus_function[4] = value;
3186             break;
3187         case HIGH_CURRENT:
3188             ftdi->eeprom->high_current = value;
3189             break;
3190         case HIGH_CURRENT_A:
3191             ftdi->eeprom->high_current_a = value;
3192             break;
3193         case HIGH_CURRENT_B:
3194             ftdi->eeprom->high_current_b = value;
3195             break;
3196         case INVERT:
3197             ftdi->eeprom->invert = value;
3198             break;
3199         case GROUP0_DRIVE:
3200             ftdi->eeprom->group0_drive = value;
3201             break;
3202         case GROUP0_SCHMITT:
3203             ftdi->eeprom->group0_schmitt = value;
3204             break;
3205         case GROUP0_SLEW:
3206             ftdi->eeprom->group0_slew = value;
3207             break;
3208         case GROUP1_DRIVE:
3209             ftdi->eeprom->group1_drive = value;
3210             break;
3211         case GROUP1_SCHMITT:
3212             ftdi->eeprom->group1_schmitt = value;
3213             break;
3214         case GROUP1_SLEW:
3215             ftdi->eeprom->group1_slew = value;
3216             break;
3217         case GROUP2_DRIVE:
3218             ftdi->eeprom->group2_drive = value;
3219             break;
3220         case GROUP2_SCHMITT:
3221             ftdi->eeprom->group2_schmitt = value;
3222             break;
3223         case GROUP2_SLEW:
3224             ftdi->eeprom->group2_slew = value;
3225             break;
3226         case GROUP3_DRIVE:
3227             ftdi->eeprom->group3_drive = value;
3228             break;
3229         case GROUP3_SCHMITT:
3230             ftdi->eeprom->group3_schmitt = value;
3231             break;
3232         case GROUP3_SLEW:
3233             ftdi->eeprom->group3_slew = value;
3234             break;
3235         case CHIP_TYPE:
3236             ftdi->eeprom->chip = value;
3237             break;
3238         case CHIP_SIZE:
3239             ftdi_error_return(-2, "EEPROM Value can't be changed");
3240         default :
3241             ftdi_error_return(-1, "Request to unknown EEPROM value");
3242     }
3243     return 0;
3244 }
3245
3246 /** Get the read-only buffer to the binary EEPROM content
3247
3248     \param ftdi pointer to ftdi_context
3249     \param buf buffer to receive EEPROM content
3250     \param size Size of receiving buffer
3251
3252     \retval 0: All fine
3253     \retval -1: struct ftdi_contxt or ftdi_eeprom missing
3254 */
3255 int ftdi_get_eeprom_buf(struct ftdi_context *ftdi, unsigned char * buf, int size)
3256 {
3257     if (!ftdi || !(ftdi->eeprom))
3258         ftdi_error_return(-1, "No appropriate structure");
3259     memcpy(buf, ftdi->eeprom->buf, size);
3260     return 0;
3261 }
3262
3263 /**
3264     Read eeprom location
3265
3266     \param ftdi pointer to ftdi_context
3267     \param eeprom_addr Address of eeprom location to be read
3268     \param eeprom_val Pointer to store read eeprom location
3269
3270     \retval  0: all fine
3271     \retval -1: read failed
3272     \retval -2: USB device unavailable
3273 */
3274 int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
3275 {
3276     if (ftdi == NULL || ftdi->usb_dev == NULL)
3277         ftdi_error_return(-2, "USB device unavailable");
3278
3279     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)
3280         ftdi_error_return(-1, "reading eeprom failed");
3281
3282     return 0;
3283 }
3284
3285 /**
3286     Read eeprom
3287
3288     \param ftdi pointer to ftdi_context
3289
3290     \retval  0: all fine
3291     \retval -1: read failed
3292     \retval -2: USB device unavailable
3293 */
3294 int ftdi_read_eeprom(struct ftdi_context *ftdi)
3295 {
3296     int i;
3297     unsigned char *buf;
3298
3299     if (ftdi == NULL || ftdi->usb_dev == NULL)
3300         ftdi_error_return(-2, "USB device unavailable");
3301     buf = ftdi->eeprom->buf;
3302
3303     for (i = 0; i < FTDI_MAX_EEPROM_SIZE/2; i++)
3304     {
3305         if (libusb_control_transfer(
3306                     ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,SIO_READ_EEPROM_REQUEST, 0, i,
3307                     buf+(i*2), 2, ftdi->usb_read_timeout) != 2)
3308             ftdi_error_return(-1, "reading eeprom failed");
3309     }
3310
3311     if (ftdi->type == TYPE_R)
3312         ftdi->eeprom->size = 0x80;
3313     /*    Guesses size of eeprom by comparing halves
3314           - will not work with blank eeprom */
3315     else if (strrchr((const char *)buf, 0xff) == ((const char *)buf +FTDI_MAX_EEPROM_SIZE -1))
3316         ftdi->eeprom->size = -1;
3317     else if (memcmp(buf,&buf[0x80],0x80) == 0)
3318         ftdi->eeprom->size = 0x80;
3319     else if (memcmp(buf,&buf[0x40],0x40) == 0)
3320         ftdi->eeprom->size = 0x40;
3321     else
3322         ftdi->eeprom->size = 0x100;
3323     return 0;
3324 }
3325
3326 /*
3327     ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID
3328     Function is only used internally
3329     \internal
3330 */
3331 static unsigned char ftdi_read_chipid_shift(unsigned char value)
3332 {
3333     return ((value & 1) << 1) |
3334            ((value & 2) << 5) |
3335            ((value & 4) >> 2) |
3336            ((value & 8) << 4) |
3337            ((value & 16) >> 1) |
3338            ((value & 32) >> 1) |
3339            ((value & 64) >> 4) |
3340            ((value & 128) >> 2);
3341 }
3342
3343 /**
3344     Read the FTDIChip-ID from R-type devices
3345
3346     \param ftdi pointer to ftdi_context
3347     \param chipid Pointer to store FTDIChip-ID
3348
3349     \retval  0: all fine
3350     \retval -1: read failed
3351     \retval -2: USB device unavailable
3352 */
3353 int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
3354 {
3355     unsigned int a = 0, b = 0;
3356
3357     if (ftdi == NULL || ftdi->usb_dev == NULL)
3358         ftdi_error_return(-2, "USB device unavailable");
3359
3360     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)
3361     {
3362         a = a << 8 | a >> 8;
3363         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)
3364         {
3365             b = b << 8 | b >> 8;
3366             a = (a << 16) | (b & 0xFFFF);
3367             a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
3368                 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
3369             *chipid = a ^ 0xa5f0f7d1;
3370             return 0;
3371         }
3372     }
3373
3374     ftdi_error_return(-1, "read of FTDIChip-ID failed");
3375 }
3376
3377 /**
3378     Write eeprom location
3379
3380     \param ftdi pointer to ftdi_context
3381     \param eeprom_addr Address of eeprom location to be written
3382     \param eeprom_val Value to be written
3383
3384     \retval  0: all fine
3385     \retval -1: write failed
3386     \retval -2: USB device unavailable
3387     \retval -3: Invalid access to checksum protected area below 0x80
3388     \retval -4: Device can't access unprotected area
3389     \retval -5: Reading chip type failed
3390 */
3391 int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr,
3392                                unsigned short eeprom_val)
3393 {
3394     int chip_type_location;
3395     unsigned short chip_type;
3396
3397     if (ftdi == NULL || ftdi->usb_dev == NULL)
3398         ftdi_error_return(-2, "USB device unavailable");
3399
3400     if (eeprom_addr <0x80)
3401         ftdi_error_return(-2, "Invalid access to checksum protected area  below 0x80");
3402
3403
3404     switch (ftdi->type)
3405     {
3406         case TYPE_BM:
3407         case  TYPE_2232C:
3408             chip_type_location = 0x14;
3409             break;
3410         case TYPE_2232H:
3411         case TYPE_4232H:
3412             chip_type_location = 0x18;
3413             break;
3414         default:
3415             ftdi_error_return(-4, "Device can't access unprotected area");
3416     }
3417
3418     if (ftdi_read_eeprom_location( ftdi, chip_type_location>>1, &chip_type))
3419         ftdi_error_return(-5, "Reading failed failed");
3420     fprintf(stderr," loc 0x%04x val 0x%04x\n", chip_type_location,chip_type);
3421     if ((chip_type & 0xff) != 0x66)
3422     {
3423         ftdi_error_return(-6, "EEPROM is not of 93x66");
3424     }
3425
3426     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3427                                 SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
3428                                 NULL, 0, ftdi->usb_write_timeout) != 0)
3429         ftdi_error_return(-1, "unable to write eeprom");
3430
3431     return 0;
3432 }
3433
3434 /**
3435     Write eeprom
3436
3437     \param ftdi pointer to ftdi_context
3438
3439     \retval  0: all fine
3440     \retval -1: read failed
3441     \retval -2: USB device unavailable
3442 */
3443 int ftdi_write_eeprom(struct ftdi_context *ftdi)
3444 {
3445     unsigned short usb_val, status;
3446     int i, ret;
3447     unsigned char *eeprom;
3448
3449     if (ftdi == NULL || ftdi->usb_dev == NULL)
3450         ftdi_error_return(-2, "USB device unavailable");
3451     eeprom = ftdi->eeprom->buf;
3452
3453     /* These commands were traced while running MProg */
3454     if ((ret = ftdi_usb_reset(ftdi)) != 0)
3455         return ret;
3456     if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0)
3457         return ret;
3458     if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0)
3459         return ret;
3460
3461     for (i = 0; i < ftdi->eeprom->size/2; i++)
3462     {
3463         usb_val = eeprom[i*2];
3464         usb_val += eeprom[(i*2)+1] << 8;
3465         if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3466                                     SIO_WRITE_EEPROM_REQUEST, usb_val, i,
3467                                     NULL, 0, ftdi->usb_write_timeout) < 0)
3468             ftdi_error_return(-1, "unable to write eeprom");
3469     }
3470
3471     return 0;
3472 }
3473
3474 /**
3475     Erase eeprom
3476
3477     This is not supported on FT232R/FT245R according to the MProg manual from FTDI.
3478
3479     \param ftdi pointer to ftdi_context
3480
3481     \retval  0: all fine
3482     \retval -1: erase failed
3483     \retval -2: USB device unavailable
3484     \retval -3: Writing magic failed
3485     \retval -4: Read EEPROM failed
3486     \retval -5: Unexpected EEPROM value
3487 */
3488 #define MAGIC 0x55aa
3489 int ftdi_erase_eeprom(struct ftdi_context *ftdi)
3490 {
3491     unsigned short eeprom_value;
3492     if (ftdi == NULL || ftdi->usb_dev == NULL)
3493         ftdi_error_return(-2, "USB device unavailable");
3494
3495     if (ftdi->type == TYPE_R)
3496     {
3497         ftdi->eeprom->chip = 0;
3498         return 0;
3499     }
3500
3501     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
3502                                 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
3503         ftdi_error_return(-1, "unable to erase eeprom");
3504
3505
3506     /* detect chip type by writing 0x55AA as magic at word position 0xc0
3507        Chip is 93x46 if magic is read at word position 0x00, as wraparound happens around 0x40
3508        Chip is 93x56 if magic is read at word position 0x40, as wraparound happens around 0x80
3509        Chip is 93x66 if magic is only read at word position 0xc0*/
3510     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3511                                 SIO_WRITE_EEPROM_REQUEST, MAGIC, 0xc0,
3512                                 NULL, 0, ftdi->usb_write_timeout) != 0)
3513         ftdi_error_return(-3, "Writing magic failed");
3514     if (ftdi_read_eeprom_location( ftdi, 0x00, &eeprom_value))
3515         ftdi_error_return(-4, "Reading failed failed");
3516     if (eeprom_value == MAGIC)
3517     {
3518         ftdi->eeprom->chip = 0x46;
3519     }
3520     else
3521     {
3522         if (ftdi_read_eeprom_location( ftdi, 0x40, &eeprom_value))
3523             ftdi_error_return(-4, "Reading failed failed");
3524         if (eeprom_value == MAGIC)
3525             ftdi->eeprom->chip = 0x56;
3526         else
3527         {
3528             if (ftdi_read_eeprom_location( ftdi, 0xc0, &eeprom_value))
3529                 ftdi_error_return(-4, "Reading failed failed");
3530             if (eeprom_value == MAGIC)
3531                 ftdi->eeprom->chip = 0x66;
3532             else
3533             {
3534                 ftdi->eeprom->chip = -1;
3535             }
3536         }
3537     }
3538     if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
3539                                 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
3540         ftdi_error_return(-1, "unable to erase eeprom");
3541     return 0;
3542 }
3543
3544 /**
3545     Get string representation for last error code
3546
3547     \param ftdi pointer to ftdi_context
3548
3549     \retval Pointer to error string
3550 */
3551 char *ftdi_get_error_string (struct ftdi_context *ftdi)
3552 {
3553     if (ftdi == NULL)
3554         return "";
3555
3556     return ftdi->error_str;
3557 }
3558
3559 /* @} end of doxygen libftdi group */