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