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