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