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