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-2008 by Intra2net AG
   6     email                : opensource@intra2net.com
   7  ***************************************************************************/
   8
   9 /***************************************************************************
  10  *                                                                         *
  11  *   This program is free software; you can redistribute it and/or modify  *
  12  *   it under the terms of the GNU Lesser General Public License           *
  13  *   version 2.1 as published by the Free Software Foundation;             *
  14  *                                                                         *
  15  ***************************************************************************/
  16
  17 /**
  18     \mainpage libftdi API documentation
  19
  20     Library to talk to FTDI chips. You find the latest versions of libftdi at
  21     http://www.intra2net.com/en/developer/libftdi/
  22
  23     The library is easy to use. Have a look at this short example:
  24     \include simple.c
  25
  26     More examples can be found in the "examples" directory.
  27 */
  28 /** \addtogroup libftdi */
  29 /* @{ */
  30
  31 #include <usb.h>
  32 #include <string.h>
  33 #include <errno.h>
  34 #include <stdio.h>
  35
  36 #include "ftdi.h"
  37
  38 /* stuff needed for async write */
  39 #ifdef LIBFTDI_LINUX_ASYNC_MODE
  40 #include <sys/ioctl.h>
  41 #include <sys/time.h>
  42 #include <sys/select.h>
  43 #include <sys/types.h>
  44 #include <unistd.h>
  45 #include <linux/usbdevice_fs.h>
  46 #endif
  47
  48 #define ftdi_error_return(code, str) do {  \
  49         ftdi->error_str = str;             \
  50         return code;                       \
  51    } while(0);
  52
  53 /**
  54     Internal function to close usb device pointer.
  55     Sets ftdi->usb_dev to NULL.
  56     \internal
  57
  58     \param ftdi pointer to ftdi_context
  59
  60     \retval  zero if all is fine, otherwise error code from usb_close()
  61 */
  62 static int ftdi_usb_close_internal (struct ftdi_context *ftdi)
  63 {
  64     int ret = 0;
  65
  66     if (ftdi->usb_dev)
  67     {
  68        ret = usb_close (ftdi->usb_dev);
  69        ftdi->usb_dev = NULL;
  70     }
  71
  72     return ret;
  73 }
  74
  75 /**
  76     Initializes a ftdi_context.
  77
  78     \param ftdi pointer to ftdi_context
  79
  80     \retval  0: all fine
  81     \retval -1: couldn't allocate read buffer
  82
  83     \remark This should be called before all functions
  84 */
  85 int ftdi_init(struct ftdi_context *ftdi)
  86 {
  87     unsigned int i;
  88
  89     ftdi->usb_dev = NULL;
  90     ftdi->usb_read_timeout = 5000;
  91     ftdi->usb_write_timeout = 5000;
  92
  93     ftdi->type = TYPE_BM;    /* chip type */
  94     ftdi->baudrate = -1;
  95     ftdi->bitbang_enabled = 0;
  96
  97     ftdi->readbuffer = NULL;
  98     ftdi->readbuffer_offset = 0;
  99     ftdi->readbuffer_remaining = 0;
 100     ftdi->writebuffer_chunksize = 4096;
 101     ftdi->max_packet_size = 0;
 102
 103     ftdi->interface = 0;
 104     ftdi->index = 0;
 105     ftdi->in_ep = 0x02;
 106     ftdi->out_ep = 0x81;
 107     ftdi->bitbang_mode = 1; /* 1: Normal bitbang mode, 2: SPI bitbang mode */
 108
 109     ftdi->error_str = NULL;
 110
 111 #ifdef LIBFTDI_LINUX_ASYNC_MODE
 112     ftdi->async_usb_buffer_size=10;
 113     if ((ftdi->async_usb_buffer=malloc(sizeof(struct usbdevfs_urb)*ftdi->async_usb_buffer_size)) == NULL)
 114         ftdi_error_return(-1, "out of memory for async usb buffer");
 115
 116     /* initialize async usb buffer with unused-marker */
 117     for (i=0; i < ftdi->async_usb_buffer_size; i++)
 118         ((struct usbdevfs_urb*)ftdi->async_usb_buffer)[i].usercontext = FTDI_URB_USERCONTEXT_COOKIE;
 119 #else
 120     ftdi->async_usb_buffer_size=0;
 121     ftdi->async_usb_buffer = NULL;
 122 #endif
 123
 124     ftdi->eeprom_size = FTDI_DEFAULT_EEPROM_SIZE;
 125
 126     /* All fine. Now allocate the readbuffer */
 127     return ftdi_read_data_set_chunksize(ftdi, 4096);
 128 }
 129
 130 /**
 131     Allocate and initialize a new ftdi_context
 132
 133     \return a pointer to a new ftdi_context, or NULL on failure
 134 */
 135 struct ftdi_context *ftdi_new(void)
 136 {
 137     struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context));
 138
 139     if (ftdi == NULL)
 140     {
 141         return NULL;
 142     }
 143
 144     if (ftdi_init(ftdi) != 0)
 145     {
 146         free(ftdi);
 147         return NULL;
 148     }
 149
 150     return ftdi;
 151 }
 152
 153 /**
 154     Open selected channels on a chip, otherwise use first channel.
 155
 156     \param ftdi pointer to ftdi_context
 157     \param interface Interface to use for FT2232C/2232H/4232H chips.
 158
 159     \retval  0: all fine
 160     \retval -1: unknown interface
 161 */
 162 int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
 163 {
 164     switch (interface)
 165     {
 166         case INTERFACE_ANY:
 167         case INTERFACE_A:
 168             /* ftdi_usb_open_desc cares to set the right index, depending on the found chip */
 169             break;
 170         case INTERFACE_B:
 171             ftdi->interface = 1;
 172             ftdi->index     = INTERFACE_B;
 173             ftdi->in_ep     = 0x04;
 174             ftdi->out_ep    = 0x83;
 175             break;
 176         case INTERFACE_C:
 177             ftdi->interface = 2;
 178             ftdi->index     = INTERFACE_C;
 179             ftdi->in_ep     = 0x06;
 180             ftdi->out_ep    = 0x85;
 181             break;
 182         case INTERFACE_D:
 183             ftdi->interface = 3;
 184             ftdi->index     = INTERFACE_D;
 185             ftdi->in_ep     = 0x08;
 186             ftdi->out_ep    = 0x87;
 187             break;
 188         default:
 189             ftdi_error_return(-1, "Unknown interface");
 190     }
 191     return 0;
 192 }
 193
 194 /**
 195     Deinitializes a ftdi_context.
 196
 197     \param ftdi pointer to ftdi_context
 198 */
 199 void ftdi_deinit(struct ftdi_context *ftdi)
 200 {
 201     ftdi_usb_close_internal (ftdi);
 202
 203     if (ftdi->async_usb_buffer != NULL)
 204     {
 205         free(ftdi->async_usb_buffer);
 206         ftdi->async_usb_buffer = NULL;
 207     }
 208
 209     if (ftdi->readbuffer != NULL)
 210     {
 211         free(ftdi->readbuffer);
 212         ftdi->readbuffer = NULL;
 213     }
 214 }
 215
 216 /**
 217     Deinitialize and free an ftdi_context.
 218
 219     \param ftdi pointer to ftdi_context
 220 */
 221 void ftdi_free(struct ftdi_context *ftdi)
 222 {
 223     ftdi_deinit(ftdi);
 224     free(ftdi);
 225 }
 226
 227 /**
 228     Use an already open libusb device.
 229
 230     \param ftdi pointer to ftdi_context
 231     \param usb libusb usb_dev_handle to use
 232 */
 233 void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *usb)
 234 {
 235     ftdi->usb_dev = usb;
 236 }
 237
 238
 239 /**
 240     Finds all ftdi devices on the usb bus. Creates a new ftdi_device_list which
 241     needs to be deallocated by ftdi_list_free() after use.
 242
 243     \param ftdi pointer to ftdi_context
 244     \param devlist Pointer where to store list of found devices
 245     \param vendor Vendor ID to search for
 246     \param product Product ID to search for
 247
 248     \retval >0: number of devices found
 249     \retval -1: usb_find_busses() failed
 250     \retval -2: usb_find_devices() failed
 251     \retval -3: out of memory
 252 */
 253 int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
 254 {
 255     struct ftdi_device_list **curdev;
 256     struct usb_bus *bus;
 257     struct usb_device *dev;
 258     int count = 0;
 259
 260     usb_init();
 261     if (usb_find_busses() < 0)
 262         ftdi_error_return(-1, "usb_find_busses() failed");
 263     if (usb_find_devices() < 0)
 264         ftdi_error_return(-2, "usb_find_devices() failed");
 265
 266     curdev = devlist;
 267     *curdev = NULL;
 268     for (bus = usb_get_busses(); bus; bus = bus->next)
 269     {
 270         for (dev = bus->devices; dev; dev = dev->next)
 271         {
 272             if (dev->descriptor.idVendor == vendor
 273                     && dev->descriptor.idProduct == product)
 274             {
 275                 *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
 276                 if (!*curdev)
 277                     ftdi_error_return(-3, "out of memory");
 278
 279                 (*curdev)->next = NULL;
 280                 (*curdev)->dev = dev;
 281
 282                 curdev = &(*curdev)->next;
 283                 count++;
 284             }
 285         }
 286     }
 287
 288     return count;
 289 }
 290
 291 /**
 292     Frees a usb device list.
 293
 294     \param devlist USB device list created by ftdi_usb_find_all()
 295 */
 296 void ftdi_list_free(struct ftdi_device_list **devlist)
 297 {
 298     struct ftdi_device_list *curdev, *next;
 299
 300     for (curdev = *devlist; curdev != NULL;)
 301     {
 302         next = curdev->next;
 303         free(curdev);
 304         curdev = next;
 305     }
 306
 307     *devlist = NULL;
 308 }
 309
 310 /**
 311     Frees a usb device list.
 312
 313     \param devlist USB device list created by ftdi_usb_find_all()
 314 */
 315 void ftdi_list_free2(struct ftdi_device_list *devlist)
 316 {
 317     ftdi_list_free(&devlist);
 318 }
 319
 320 /**
 321     Return device ID strings from the usb device.
 322
 323     The parameters manufacturer, description and serial may be NULL
 324     or pointer to buffers to store the fetched strings.
 325
 326     \note Use this function only in combination with ftdi_usb_find_all()
 327           as it closes the internal "usb_dev" after use.
 328
 329     \param ftdi pointer to ftdi_context
 330     \param dev libusb usb_dev to use
 331     \param manufacturer Store manufacturer string here if not NULL
 332     \param mnf_len Buffer size of manufacturer string
 333     \param description Store product description string here if not NULL
 334     \param desc_len Buffer size of product description string
 335     \param serial Store serial string here if not NULL
 336     \param serial_len Buffer size of serial string
 337
 338     \retval   0: all fine
 339     \retval  -1: wrong arguments
 340     \retval  -4: unable to open device
 341     \retval  -7: get product manufacturer failed
 342     \retval  -8: get product description failed
 343     \retval  -9: get serial number failed
 344     \retval -10: unable to close device
 345 */
 346 int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct usb_device * dev,
 347                          char * manufacturer, int mnf_len, char * description, int desc_len, char * serial, int serial_len)
 348 {
 349     if ((ftdi==NULL) || (dev==NULL))
 350         return -1;
 351
 352     if (!(ftdi->usb_dev = usb_open(dev)))
 353         ftdi_error_return(-4, usb_strerror());
 354
 355     if (manufacturer != NULL)
 356     {
 357         if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iManufacturer, manufacturer, mnf_len) <= 0)
 358         {
 359             ftdi_usb_close_internal (ftdi);
 360             ftdi_error_return(-7, usb_strerror());
 361         }
 362     }
 363
 364     if (description != NULL)
 365     {
 366         if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, description, desc_len) <= 0)
 367         {
 368             ftdi_usb_close_internal (ftdi);
 369             ftdi_error_return(-8, usb_strerror());
 370         }
 371     }
 372
 373     if (serial != NULL)
 374     {
 375         if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, serial, serial_len) <= 0)
 376         {
 377             ftdi_usb_close_internal (ftdi);
 378             ftdi_error_return(-9, usb_strerror());
 379         }
 380     }
 381
 382     if (ftdi_usb_close_internal (ftdi) != 0)
 383         ftdi_error_return(-10, usb_strerror());
 384
 385     return 0;
 386 }
 387
 388 /**
 389  * Internal function to determine the maximum packet size.
 390  * \param ftdi pointer to ftdi_context
 391  * \param dev libusb usb_dev to use
 392  * \retval Maximum packet size for this device
 393  */
 394 static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, struct usb_device *dev)
 395 {
 396     unsigned int packet_size;
 397
 398     // Determine maximum packet size. Init with default value.
 399     // New hi-speed devices from FTDI use a packet size of 512 bytes
 400     // but could be connected to a normal speed USB hub -> 64 bytes packet size.
 401     if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H)
 402         packet_size = 512;
 403     else
 404         packet_size = 64;
 405
 406     if (dev->descriptor.bNumConfigurations > 0 && dev->config)
 407     {
 408         struct usb_config_descriptor config = dev->config[0];
 409
 410         if (ftdi->interface < config.bNumInterfaces)
 411         {
 412             struct usb_interface interface = config.interface[ftdi->interface];
 413             if (interface.num_altsetting > 0)
 414             {
 415                 struct usb_interface_descriptor descriptor = interface.altsetting[0];
 416                 if (descriptor.bNumEndpoints > 0)
 417                 {
 418                     packet_size = descriptor.endpoint[0].wMaxPacketSize;
 419                 }
 420             }
 421         }
 422     }
 423
 424     return packet_size;
 425 }
 426
 427 /**
 428     Opens a ftdi device given by a usb_device.
 429
 430     \param ftdi pointer to ftdi_context
 431     \param dev libusb usb_dev to use
 432
 433     \retval  0: all fine
 434     \retval -3: unable to config device
 435     \retval -4: unable to open device
 436     \retval -5: unable to claim device
 437     \retval -6: reset failed
 438     \retval -7: set baudrate failed
 439 */
 440 int ftdi_usb_open_dev(struct ftdi_context *ftdi, struct usb_device *dev)
 441 {
 442     int detach_errno = 0;
 443     int config_val = 1;
 444     if (!(ftdi->usb_dev = usb_open(dev)))
 445         ftdi_error_return(-4, "usb_open() failed");
 446
 447 #ifdef LIBUSB_HAS_GET_DRIVER_NP
 448     // Try to detach ftdi_sio kernel module.
 449     // Returns ENODATA if driver is not loaded.
 450     //
 451     // The return code is kept in a separate variable and only parsed
 452     // if usb_set_configuration() or usb_claim_interface() fails as the
 453     // detach operation might be denied and everything still works fine.
 454     // Likely scenario is a static ftdi_sio kernel module.
 455     if (usb_detach_kernel_driver_np(ftdi->usb_dev, ftdi->interface) != 0 && errno != ENODATA)
 456         detach_errno = errno;
 457 #endif
 458
 459 #ifdef __WIN32__
 460     // set configuration (needed especially for windows)
 461     // tolerate EBUSY: one device with one configuration, but two interfaces
 462     //    and libftdi sessions to both interfaces (e.g. FT2232)
 463
 464     if (dev->descriptor.bNumConfigurations > 0)
 465     {
 466         // libusb-win32 on Windows 64 can return a null pointer for a valid device
 467         if (dev->config)
 468             config_val = dev->config[0].bConfigurationValue;
 469
 470         if (usb_set_configuration(ftdi->usb_dev, config_val) &&
 471             errno != EBUSY)
 472         {
 473             ftdi_usb_close_internal (ftdi);
 474             if (detach_errno == EPERM)
 475             {
 476                 ftdi_error_return(-8, "inappropriate permissions on device!");
 477             }
 478             else
 479             {
 480                 ftdi_error_return(-3, "unable to set usb configuration. Make sure ftdi_sio is unloaded!");
 481             }
 482         }
 483     }
 484 #endif
 485
 486     if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0)
 487     {
 488         ftdi_usb_close_internal (ftdi);
 489         if (detach_errno == EPERM)
 490         {
 491             ftdi_error_return(-8, "inappropriate permissions on device!");
 492         }
 493         else
 494         {
 495             ftdi_error_return(-5, "unable to claim usb device. Make sure ftdi_sio is unloaded!");
 496         }
 497     }
 498
 499     if (ftdi_usb_reset (ftdi) != 0)
 500     {
 501         ftdi_usb_close_internal (ftdi);
 502         ftdi_error_return(-6, "ftdi_usb_reset failed");
 503     }
 504
 505     // Try to guess chip type
 506     // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
 507     if (dev->descriptor.bcdDevice == 0x400 || (dev->descriptor.bcdDevice == 0x200
 508             && dev->descriptor.iSerialNumber == 0))
 509         ftdi->type = TYPE_BM;
 510     else if (dev->descriptor.bcdDevice == 0x200)
 511         ftdi->type = TYPE_AM;
 512     else if (dev->descriptor.bcdDevice == 0x500)
 513         ftdi->type = TYPE_2232C;
 514     else if (dev->descriptor.bcdDevice == 0x600)
 515         ftdi->type = TYPE_R;
 516     else if (dev->descriptor.bcdDevice == 0x700)
 517         ftdi->type = TYPE_2232H;
 518     else if (dev->descriptor.bcdDevice == 0x800)
 519         ftdi->type = TYPE_4232H;
 520
 521     // Set default interface on dual/quad type chips
 522     switch(ftdi->type)
 523     {
 524         case TYPE_2232C:
 525         case TYPE_2232H:
 526         case TYPE_4232H:
 527             if (!ftdi->index)
 528                 ftdi->index = INTERFACE_A;
 529             break;
 530         default:
 531             break;
 532     }
 533
 534     // Determine maximum packet size
 535     ftdi->max_packet_size = _ftdi_determine_max_packet_size(ftdi, dev);
 536
 537     if (ftdi_set_baudrate (ftdi, 9600) != 0)
 538     {
 539         ftdi_usb_close_internal (ftdi);
 540         ftdi_error_return(-7, "set baudrate failed");
 541     }
 542
 543     ftdi_error_return(0, "all fine");
 544 }
 545
 546 /**
 547     Opens the first device with a given vendor and product ids.
 548
 549     \param ftdi pointer to ftdi_context
 550     \param vendor Vendor ID
 551     \param product Product ID
 552
 553     \retval same as ftdi_usb_open_desc()
 554 */
 555 int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
 556 {
 557     return ftdi_usb_open_desc(ftdi, vendor, product, NULL, NULL);
 558 }
 559
 560 /**
 561     Opens the first device with a given, vendor id, product id,
 562     description and serial.
 563
 564     \param ftdi pointer to ftdi_context
 565     \param vendor Vendor ID
 566     \param product Product ID
 567     \param description Description to search for. Use NULL if not needed.
 568     \param serial Serial to search for. Use NULL if not needed.
 569
 570     \retval  0: all fine
 571     \retval -1: usb_find_busses() failed
 572     \retval -2: usb_find_devices() failed
 573     \retval -3: usb device not found
 574     \retval -4: unable to open device
 575     \retval -5: unable to claim device
 576     \retval -6: reset failed
 577     \retval -7: set baudrate failed
 578     \retval -8: get product description failed
 579     \retval -9: get serial number failed
 580     \retval -10: unable to close device
 581 */
 582 int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
 583                        const char* description, const char* serial)
 584 {
 585     struct usb_bus *bus;
 586     struct usb_device *dev;
 587     char string[256];
 588
 589     usb_init();
 590
 591     if (usb_find_busses() < 0)
 592         ftdi_error_return(-1, "usb_find_busses() failed");
 593     if (usb_find_devices() < 0)
 594         ftdi_error_return(-2, "usb_find_devices() failed");
 595
 596     for (bus = usb_get_busses(); bus; bus = bus->next)
 597     {
 598         for (dev = bus->devices; dev; dev = dev->next)
 599         {
 600             if (dev->descriptor.idVendor == vendor
 601                     && dev->descriptor.idProduct == product)
 602             {
 603                 if (!(ftdi->usb_dev = usb_open(dev)))
 604                     ftdi_error_return(-4, "usb_open() failed");
 605
 606                 if (description != NULL)
 607                 {
 608                     if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, string, sizeof(string)) <= 0)
 609                     {
 610                         ftdi_usb_close_internal (ftdi);
 611                         ftdi_error_return(-8, "unable to fetch product description");
 612                     }
 613                     if (strncmp(string, description, sizeof(string)) != 0)
 614                     {
 615                         if (ftdi_usb_close_internal (ftdi) != 0)
 616                             ftdi_error_return(-10, "unable to close device");
 617                         continue;
 618                     }
 619                 }
 620                 if (serial != NULL)
 621                 {
 622                     if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, string, sizeof(string)) <= 0)
 623                     {
 624                         ftdi_usb_close_internal (ftdi);
 625                         ftdi_error_return(-9, "unable to fetch serial number");
 626                     }
 627                     if (strncmp(string, serial, sizeof(string)) != 0)
 628                     {
 629                         if (ftdi_usb_close_internal (ftdi) != 0)
 630                             ftdi_error_return(-10, "unable to close device");
 631                         continue;
 632                     }
 633                 }
 634
 635                 if (ftdi_usb_close_internal (ftdi) != 0)
 636                     ftdi_error_return(-10, "unable to close device");
 637
 638                 return ftdi_usb_open_dev(ftdi, dev);
 639             }
 640         }
 641     }
 642
 643     // device not found
 644     ftdi_error_return(-3, "device not found");
 645 }
 646
 647 /**
 648     Resets the ftdi device.
 649
 650     \param ftdi pointer to ftdi_context
 651
 652     \retval  0: all fine
 653     \retval -1: FTDI reset failed
 654 */
 655 int ftdi_usb_reset(struct ftdi_context *ftdi)
 656 {
 657     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
 658                         SIO_RESET_REQUEST, SIO_RESET_SIO,
 659                         ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
 660         ftdi_error_return(-1,"FTDI reset failed");
 661
 662     // Invalidate data in the readbuffer
 663     ftdi->readbuffer_offset = 0;
 664     ftdi->readbuffer_remaining = 0;
 665
 666     return 0;
 667 }
 668
 669 /**
 670     Clears the read buffer on the chip and the internal read buffer.
 671
 672     \param ftdi pointer to ftdi_context
 673
 674     \retval  0: all fine
 675     \retval -1: read buffer purge failed
 676 */
 677 int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
 678 {
 679     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
 680                         SIO_RESET_REQUEST, SIO_RESET_PURGE_RX,
 681                         ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
 682         ftdi_error_return(-1, "FTDI purge of RX buffer failed");
 683
 684     // Invalidate data in the readbuffer
 685     ftdi->readbuffer_offset = 0;
 686     ftdi->readbuffer_remaining = 0;
 687
 688     return 0;
 689 }
 690
 691 /**
 692     Clears the write buffer on the chip.
 693
 694     \param ftdi pointer to ftdi_context
 695
 696     \retval  0: all fine
 697     \retval -1: write buffer purge failed
 698 */
 699 int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
 700 {
 701     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
 702                         SIO_RESET_REQUEST, SIO_RESET_PURGE_TX,
 703                         ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
 704         ftdi_error_return(-1, "FTDI purge of TX buffer failed");
 705
 706     return 0;
 707 }
 708
 709 /**
 710     Clears the buffers on the chip and the internal read buffer.
 711
 712     \param ftdi pointer to ftdi_context
 713
 714     \retval  0: all fine
 715     \retval -1: read buffer purge failed
 716     \retval -2: write buffer purge failed
 717 */
 718 int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
 719 {
 720     int result;
 721
 722     result = ftdi_usb_purge_rx_buffer(ftdi);
 723     if (result < 0)
 724         return -1;
 725
 726     result = ftdi_usb_purge_tx_buffer(ftdi);
 727     if (result < 0)
 728         return -2;
 729
 730     return 0;
 731 }
 732
 733
 734
 735 /**
 736     Closes the ftdi device. Call ftdi_deinit() if you're cleaning up.
 737
 738     \param ftdi pointer to ftdi_context
 739
 740     \retval  0: all fine
 741     \retval -1: usb_release failed
 742     \retval -2: usb_close failed
 743 */
 744 int ftdi_usb_close(struct ftdi_context *ftdi)
 745 {
 746     int rtn = 0;
 747
 748 #ifdef LIBFTDI_LINUX_ASYNC_MODE
 749     /* try to release some kernel resources */
 750     ftdi_async_complete(ftdi,1);
 751 #endif
 752
 753     if (ftdi->usb_dev != NULL)
 754         if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0)
 755             rtn = -1;
 756
 757     if (ftdi_usb_close_internal (ftdi) != 0)
 758         rtn = -2;
 759
 760     return rtn;
 761 }
 762
 763 /*
 764     ftdi_convert_baudrate returns nearest supported baud rate to that requested.
 765     Function is only used internally
 766     \internal
 767 */
 768 static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
 769                                  unsigned short *value, unsigned short *index)
 770 {
 771     static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
 772     static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
 773     static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
 774     int divisor, best_divisor, best_baud, best_baud_diff;
 775     unsigned long encoded_divisor;
 776     int i;
 777
 778     if (baudrate <= 0)
 779     {
 780         // Return error
 781         return -1;
 782     }
 783
 784     divisor = 24000000 / baudrate;
 785
 786     if (ftdi->type == TYPE_AM)
 787     {
 788         // Round down to supported fraction (AM only)
 789         divisor -= am_adjust_dn[divisor & 7];
 790     }
 791
 792     // Try this divisor and the one above it (because division rounds down)
 793     best_divisor = 0;
 794     best_baud = 0;
 795     best_baud_diff = 0;
 796     for (i = 0; i < 2; i++)
 797     {
 798         int try_divisor = divisor + i;
 799         int baud_estimate;
 800         int baud_diff;
 801
 802         // Round up to supported divisor value
 803         if (try_divisor <= 8)
 804         {
 805             // Round up to minimum supported divisor
 806             try_divisor = 8;
 807         }
 808         else if (ftdi->type != TYPE_AM && try_divisor < 12)
 809         {
 810             // BM doesn't support divisors 9 through 11 inclusive
 811             try_divisor = 12;
 812         }
 813         else if (divisor < 16)
 814         {
 815             // AM doesn't support divisors 9 through 15 inclusive
 816             try_divisor = 16;
 817         }
 818         else
 819         {
 820             if (ftdi->type == TYPE_AM)
 821             {
 822                 // Round up to supported fraction (AM only)
 823                 try_divisor += am_adjust_up[try_divisor & 7];
 824                 if (try_divisor > 0x1FFF8)
 825                 {
 826                     // Round down to maximum supported divisor value (for AM)
 827                     try_divisor = 0x1FFF8;
 828                 }
 829             }
 830             else
 831             {
 832                 if (try_divisor > 0x1FFFF)
 833                 {
 834                     // Round down to maximum supported divisor value (for BM)
 835                     try_divisor = 0x1FFFF;
 836                 }
 837             }
 838         }
 839         // Get estimated baud rate (to nearest integer)
 840         baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
 841         // Get absolute difference from requested baud rate
 842         if (baud_estimate < baudrate)
 843         {
 844             baud_diff = baudrate - baud_estimate;
 845         }
 846         else
 847         {
 848             baud_diff = baud_estimate - baudrate;
 849         }
 850         if (i == 0 || baud_diff < best_baud_diff)
 851         {
 852             // Closest to requested baud rate so far
 853             best_divisor = try_divisor;
 854             best_baud = baud_estimate;
 855             best_baud_diff = baud_diff;
 856             if (baud_diff == 0)
 857             {
 858                 // Spot on! No point trying
 859                 break;
 860             }
 861         }
 862     }
 863     // Encode the best divisor value
 864     encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
 865     // Deal with special cases for encoded value
 866     if (encoded_divisor == 1)
 867     {
 868         encoded_divisor = 0;    // 3000000 baud
 869     }
 870     else if (encoded_divisor == 0x4001)
 871     {
 872         encoded_divisor = 1;    // 2000000 baud (BM only)
 873     }
 874     // Split into "value" and "index" values
 875     *value = (unsigned short)(encoded_divisor & 0xFFFF);
 876     if (ftdi->type == TYPE_2232C || ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H)
 877     {
 878         *index = (unsigned short)(encoded_divisor >> 8);
 879         *index &= 0xFF00;
 880         *index |= ftdi->index;
 881     }
 882     else
 883         *index = (unsigned short)(encoded_divisor >> 16);
 884
 885     // Return the nearest baud rate
 886     return best_baud;
 887 }
 888
 889 /**
 890     Sets the chip baud rate
 891
 892     \param ftdi pointer to ftdi_context
 893     \param baudrate baud rate to set
 894
 895     \retval  0: all fine
 896     \retval -1: invalid baudrate
 897     \retval -2: setting baudrate failed
 898 */
 899 int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
 900 {
 901     unsigned short value, index;
 902     int actual_baudrate;
 903
 904     if (ftdi->bitbang_enabled)
 905     {
 906         baudrate = baudrate*4;
 907     }
 908
 909     actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
 910     if (actual_baudrate <= 0)
 911         ftdi_error_return (-1, "Silly baudrate <= 0.");
 912
 913     // Check within tolerance (about 5%)
 914     if ((actual_baudrate * 2 < baudrate /* Catch overflows */ )
 915             || ((actual_baudrate < baudrate)
 916                 ? (actual_baudrate * 21 < baudrate * 20)
 917                 : (baudrate * 21 < actual_baudrate * 20)))
 918         ftdi_error_return (-1, "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4");
 919
 920     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
 921                         SIO_SET_BAUDRATE_REQUEST, value,
 922                         index, NULL, 0, ftdi->usb_write_timeout) != 0)
 923         ftdi_error_return (-2, "Setting new baudrate failed");
 924
 925     ftdi->baudrate = baudrate;
 926     return 0;
 927 }
 928
 929 /**
 930     Set (RS232) line characteristics.
 931     The break type can only be set via ftdi_set_line_property2()
 932     and defaults to "off".
 933
 934     \param ftdi pointer to ftdi_context
 935     \param bits Number of bits
 936     \param sbit Number of stop bits
 937     \param parity Parity mode
 938
 939     \retval  0: all fine
 940     \retval -1: Setting line property failed
 941 */
 942 int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
 943                            enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
 944 {
 945     return ftdi_set_line_property2(ftdi, bits, sbit, parity, BREAK_OFF);
 946 }
 947
 948 /**
 949     Set (RS232) line characteristics
 950
 951     \param ftdi pointer to ftdi_context
 952     \param bits Number of bits
 953     \param sbit Number of stop bits
 954     \param parity Parity mode
 955     \param break_type Break type
 956
 957     \retval  0: all fine
 958     \retval -1: Setting line property failed
 959 */
 960 int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
 961                             enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity,
 962                             enum ftdi_break_type break_type)
 963 {
 964     unsigned short value = bits;
 965
 966     switch (parity)
 967     {
 968         case NONE:
 969             value |= (0x00 << 8);
 970             break;
 971         case ODD:
 972             value |= (0x01 << 8);
 973             break;
 974         case EVEN:
 975             value |= (0x02 << 8);
 976             break;
 977         case MARK:
 978             value |= (0x03 << 8);
 979             break;
 980         case SPACE:
 981             value |= (0x04 << 8);
 982             break;
 983     }
 984
 985     switch (sbit)
 986     {
 987         case STOP_BIT_1:
 988             value |= (0x00 << 11);
 989             break;
 990         case STOP_BIT_15:
 991             value |= (0x01 << 11);
 992             break;
 993         case STOP_BIT_2:
 994             value |= (0x02 << 11);
 995             break;
 996     }
 997
 998     switch (break_type)
 999     {
1000         case BREAK_OFF:
1001             value |= (0x00 << 14);
1002             break;
1003         case BREAK_ON:
1004             value |= (0x01 << 14);
1005             break;
1006     }
1007
1008     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1009                         SIO_SET_DATA_REQUEST, value,
1010                         ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1011         ftdi_error_return (-1, "Setting new line property failed");
1012
1013     return 0;
1014 }
1015
1016 /**
1017     Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip
1018
1019     \param ftdi pointer to ftdi_context
1020     \param buf Buffer with the data
1021     \param size Size of the buffer
1022
1023     \retval <0: error code from usb_bulk_write()
1024     \retval >0: number of bytes written
1025 */
1026 int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1027 {
1028     int ret;
1029     int offset = 0;
1030     int total_written = 0;
1031
1032     while (offset < size)
1033     {
1034         int write_size = ftdi->writebuffer_chunksize;
1035
1036         if (offset+write_size > size)
1037             write_size = size-offset;
1038
1039         ret = usb_bulk_write(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, ftdi->usb_write_timeout);
1040         if (ret < 0)
1041             ftdi_error_return(ret, "usb bulk write failed");
1042
1043         total_written += ret;
1044         offset += write_size;
1045     }
1046
1047     return total_written;
1048 }
1049
1050 #ifdef LIBFTDI_LINUX_ASYNC_MODE
1051 #ifdef USB_CLASS_PTP
1052 #error LIBFTDI_LINUX_ASYNC_MODE is not compatible with libusb-compat-0.1!
1053 #endif
1054 /* this is strongly dependent on libusb using the same struct layout. If libusb
1055    changes in some later version this may break horribly (this is for libusb 0.1.12) */
1056 struct usb_dev_handle
1057 {
1058     int fd;
1059     // some other stuff coming here we don't need
1060 };
1061
1062 /**
1063     Check for pending async urbs
1064     \internal
1065 */
1066 static int _usb_get_async_urbs_pending(struct ftdi_context *ftdi)
1067 {
1068     struct usbdevfs_urb *urb;
1069     int pending=0;
1070     unsigned int i;
1071
1072     for (i=0; i < ftdi->async_usb_buffer_size; i++)
1073     {
1074         urb=&((struct usbdevfs_urb *)(ftdi->async_usb_buffer))[i];
1075         if (urb->usercontext != FTDI_URB_USERCONTEXT_COOKIE)
1076             pending++;
1077     }
1078
1079     return pending;
1080 }
1081
1082 /**
1083     Wait until one or more async URBs are completed by the kernel and mark their
1084     positions in the async-buffer as unused
1085
1086     \param ftdi pointer to ftdi_context
1087     \param wait_for_more if != 0 wait for more than one write to complete
1088     \param timeout_msec max milliseconds to wait
1089
1090     \internal
1091 */
1092 static void _usb_async_cleanup(struct ftdi_context *ftdi, int wait_for_more, int timeout_msec)
1093 {
1094     struct timeval tv;
1095     struct usbdevfs_urb *urb=NULL;
1096     int ret;
1097     fd_set writefds;
1098     int keep_going=0;
1099
1100     FD_ZERO(&writefds);
1101     FD_SET(ftdi->usb_dev->fd, &writefds);
1102
1103     /* init timeout only once, select writes time left after call */
1104     tv.tv_sec = timeout_msec / 1000;
1105     tv.tv_usec = (timeout_msec % 1000) * 1000;
1106
1107     do
1108     {
1109         while (_usb_get_async_urbs_pending(ftdi)
1110                 && (ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_REAPURBNDELAY, &urb)) == -1
1111                 && errno == EAGAIN)
1112         {
1113             if (keep_going && !wait_for_more)
1114             {
1115                 /* don't wait if repeating only for keep_going */
1116                 keep_going=0;
1117                 break;
1118             }
1119
1120             /* wait for timeout msec or something written ready */
1121             select(ftdi->usb_dev->fd+1, NULL, &writefds, NULL, &tv);
1122         }
1123
1124         if (ret == 0 && urb != NULL)
1125         {
1126             /* got a free urb, mark it */
1127             urb->usercontext = FTDI_URB_USERCONTEXT_COOKIE;
1128
1129             /* try to get more urbs that are ready now, but don't wait anymore */
1130             urb=NULL;
1131             keep_going=1;
1132         }
1133         else
1134         {
1135             /* no more urbs waiting */
1136             keep_going=0;
1137         }
1138     }
1139     while (keep_going);
1140 }
1141
1142 /**
1143     Wait until one or more async URBs are completed by the kernel and mark their
1144     positions in the async-buffer as unused.
1145
1146     \param ftdi pointer to ftdi_context
1147     \param wait_for_more if != 0 wait for more than one write to complete (until write timeout)
1148 */
1149 void ftdi_async_complete(struct ftdi_context *ftdi, int wait_for_more)
1150 {
1151     _usb_async_cleanup(ftdi,wait_for_more,ftdi->usb_write_timeout);
1152 }
1153
1154 /**
1155     Stupid libusb does not offer async writes nor does it allow
1156     access to its fd - so we need some hacks here.
1157     \internal
1158 */
1159 static int _usb_bulk_write_async(struct ftdi_context *ftdi, int ep, char *bytes, int size)
1160 {
1161     struct usbdevfs_urb *urb;
1162     int bytesdone = 0, requested;
1163     int ret, cleanup_count;
1164     unsigned int i;
1165
1166     do
1167     {
1168         /* find a free urb buffer we can use */
1169         urb=NULL;
1170         for (cleanup_count=0; urb==NULL && cleanup_count <= 1; cleanup_count++)
1171         {
1172             if (i==ftdi->async_usb_buffer_size)
1173             {
1174                 /* wait until some buffers are free */
1175                 _usb_async_cleanup(ftdi,0,ftdi->usb_write_timeout);
1176             }
1177
1178             for (i=0; i < ftdi->async_usb_buffer_size; i++)
1179             {
1180                 urb=&((struct usbdevfs_urb *)(ftdi->async_usb_buffer))[i];
1181                 if (urb->usercontext == FTDI_URB_USERCONTEXT_COOKIE)
1182                     break;  /* found a free urb position */
1183                 urb=NULL;
1184             }
1185         }
1186
1187         /* no free urb position found */
1188         if (urb==NULL)
1189             return -1;
1190
1191         requested = size - bytesdone;
1192         if (requested > 4096)
1193             requested = 4096;
1194
1195         memset(urb,0,sizeof(urb));
1196
1197         urb->type = USBDEVFS_URB_TYPE_BULK;
1198         urb->endpoint = ep;
1199         urb->flags = 0;
1200         urb->buffer = bytes + bytesdone;
1201         urb->buffer_length = requested;
1202         urb->signr = 0;
1203         urb->actual_length = 0;
1204         urb->number_of_packets = 0;
1205         urb->usercontext = 0;
1206
1207         do
1208         {
1209             ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_SUBMITURB, urb);
1210         }
1211         while (ret < 0 && errno == EINTR);
1212         if (ret < 0)
1213             return ret;       /* the caller can read errno to get more info */
1214
1215         bytesdone += requested;
1216     }
1217     while (bytesdone < size);
1218     return bytesdone;
1219 }
1220
1221 /**
1222     Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip.
1223     Does not wait for completion of the transfer nor does it make sure that
1224     the transfer was successful.
1225
1226     This function could be extended to use signals and callbacks to inform the
1227     caller of completion or error - but this is not done yet, volunteers welcome.
1228
1229     Works around libusb and directly accesses functions only available on Linux.
1230     Only available if compiled with --with-async-mode.
1231
1232     \param ftdi pointer to ftdi_context
1233     \param buf Buffer with the data
1234     \param size Size of the buffer
1235
1236     \retval <0: error code from usb_bulk_write()
1237     \retval >0: number of bytes written
1238 */
1239 int ftdi_write_data_async(struct ftdi_context *ftdi, unsigned char *buf, int size)
1240 {
1241     int ret;
1242     int offset = 0;
1243     int total_written = 0;
1244
1245     while (offset < size)
1246     {
1247         int write_size = ftdi->writebuffer_chunksize;
1248
1249         if (offset+write_size > size)
1250             write_size = size-offset;
1251
1252         ret = _usb_bulk_write_async(ftdi, ftdi->in_ep, buf+offset, write_size);
1253         if (ret < 0)
1254             ftdi_error_return(ret, "usb bulk write async failed");
1255
1256         total_written += ret;
1257         offset += write_size;
1258     }
1259
1260     return total_written;
1261 }
1262 #endif // LIBFTDI_LINUX_ASYNC_MODE
1263
1264 /**
1265     Configure write buffer chunk size.
1266     Default is 4096.
1267
1268     \param ftdi pointer to ftdi_context
1269     \param chunksize Chunk size
1270
1271     \retval 0: all fine
1272 */
1273 int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1274 {
1275     ftdi->writebuffer_chunksize = chunksize;
1276     return 0;
1277 }
1278
1279 /**
1280     Get write buffer chunk size.
1281
1282     \param ftdi pointer to ftdi_context
1283     \param chunksize Pointer to store chunk size in
1284
1285     \retval 0: all fine
1286 */
1287 int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1288 {
1289     *chunksize = ftdi->writebuffer_chunksize;
1290     return 0;
1291 }
1292
1293 /**
1294     Reads data in chunks (see ftdi_read_data_set_chunksize()) from the chip.
1295
1296     Automatically strips the two modem status bytes transfered during every read.
1297
1298     \param ftdi pointer to ftdi_context
1299     \param buf Buffer to store data in
1300     \param size Size of the buffer
1301
1302     \retval <0: error code from usb_bulk_read()
1303     \retval  0: no data was available
1304     \retval >0: number of bytes read
1305
1306     \remark This function is not useful in bitbang mode.
1307             Use ftdi_read_pins() to get the current state of the pins.
1308 */
1309 int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1310 {
1311     int offset = 0, ret = 1, i, num_of_chunks, chunk_remains;
1312     int packet_size = ftdi->max_packet_size;
1313
1314     // Packet size sanity check (avoid division by zero)
1315     if (packet_size == 0)
1316         ftdi_error_return(-1, "max_packet_size is bogus (zero)");
1317
1318     // everything we want is still in the readbuffer?
1319     if (size <= ftdi->readbuffer_remaining)
1320     {
1321         memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1322
1323         // Fix offsets
1324         ftdi->readbuffer_remaining -= size;
1325         ftdi->readbuffer_offset += size;
1326
1327         /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1328
1329         return size;
1330     }
1331     // something still in the readbuffer, but not enough to satisfy 'size'?
1332     if (ftdi->readbuffer_remaining != 0)
1333     {
1334         memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1335
1336         // Fix offset
1337         offset += ftdi->readbuffer_remaining;
1338     }
1339     // do the actual USB read
1340     while (offset < size && ret > 0)
1341     {
1342         ftdi->readbuffer_remaining = 0;
1343         ftdi->readbuffer_offset = 0;
1344         /* returns how much received */
1345         ret = usb_bulk_read (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, ftdi->usb_read_timeout);
1346         if (ret < 0)
1347             ftdi_error_return(ret, "usb bulk read failed");
1348
1349         if (ret > 2)
1350         {
1351             // skip FTDI status bytes.
1352             // Maybe stored in the future to enable modem use
1353             num_of_chunks = ret / packet_size;
1354             chunk_remains = ret % packet_size;
1355             //printf("ret = %X, num_of_chunks = %X, chunk_remains = %X, readbuffer_offset = %X\n", ret, num_of_chunks, chunk_remains, ftdi->readbuffer_offset);
1356
1357             ftdi->readbuffer_offset += 2;
1358             ret -= 2;
1359
1360             if (ret > packet_size - 2)
1361             {
1362                 for (i = 1; i < num_of_chunks; i++)
1363                     memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1364                              ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1365                              packet_size - 2);
1366                 if (chunk_remains > 2)
1367                 {
1368                     memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1369                              ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1370                              chunk_remains-2);
1371                     ret -= 2*num_of_chunks;
1372                 }
1373                 else
1374                     ret -= 2*(num_of_chunks-1)+chunk_remains;
1375             }
1376         }
1377         else if (ret <= 2)
1378         {
1379             // no more data to read?
1380             return offset;
1381         }
1382         if (ret > 0)
1383         {
1384             // data still fits in buf?
1385             if (offset+ret <= size)
1386             {
1387                 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, ret);
1388                 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1389                 offset += ret;
1390
1391                 /* Did we read exactly the right amount of bytes? */
1392                 if (offset == size)
1393                     //printf("read_data exact rem %d offset %d\n",
1394                     //ftdi->readbuffer_remaining, offset);
1395                     return offset;
1396             }
1397             else
1398             {
1399                 // only copy part of the data or size <= readbuffer_chunksize
1400                 int part_size = size-offset;
1401                 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
1402
1403                 ftdi->readbuffer_offset += part_size;
1404                 ftdi->readbuffer_remaining = ret-part_size;
1405                 offset += part_size;
1406
1407                 /* printf("Returning part: %d - size: %d - offset: %d - ret: %d - remaining: %d\n",
1408                 part_size, size, offset, ret, ftdi->readbuffer_remaining); */
1409
1410                 return offset;
1411             }
1412         }
1413     }
1414     // never reached
1415     return -127;
1416 }
1417
1418 /**
1419     Configure read buffer chunk size.
1420     Default is 4096.
1421
1422     Automatically reallocates the buffer.
1423
1424     \param ftdi pointer to ftdi_context
1425     \param chunksize Chunk size
1426
1427     \retval 0: all fine
1428 */
1429 int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1430 {
1431     unsigned char *new_buf;
1432
1433     // Invalidate all remaining data
1434     ftdi->readbuffer_offset = 0;
1435     ftdi->readbuffer_remaining = 0;
1436
1437     if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL)
1438         ftdi_error_return(-1, "out of memory for readbuffer");
1439
1440     ftdi->readbuffer = new_buf;
1441     ftdi->readbuffer_chunksize = chunksize;
1442
1443     return 0;
1444 }
1445
1446 /**
1447     Get read buffer chunk size.
1448
1449     \param ftdi pointer to ftdi_context
1450     \param chunksize Pointer to store chunk size in
1451
1452     \retval 0: all fine
1453 */
1454 int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1455 {
1456     *chunksize = ftdi->readbuffer_chunksize;
1457     return 0;
1458 }
1459
1460
1461 /**
1462     Enable bitbang mode.
1463
1464     For advanced bitbang modes of the FT2232C chip use ftdi_set_bitmode().
1465
1466     \param ftdi pointer to ftdi_context
1467     \param bitmask Bitmask to configure lines.
1468            HIGH/ON value configures a line as output.
1469
1470     \retval  0: all fine
1471     \retval -1: can't enable bitbang mode
1472 */
1473 int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask)
1474 {
1475     unsigned short usb_val;
1476
1477     usb_val = bitmask; // low byte: bitmask
1478     /* FT2232C: Set bitbang_mode to 2 to enable SPI */
1479     usb_val |= (ftdi->bitbang_mode << 8);
1480
1481     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1482                         SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index,
1483                         NULL, 0, ftdi->usb_write_timeout) != 0)
1484         ftdi_error_return(-1, "unable to enter bitbang mode. Perhaps not a BM type chip?");
1485
1486     ftdi->bitbang_enabled = 1;
1487     return 0;
1488 }
1489
1490 /**
1491     Disable bitbang mode.
1492
1493     \param ftdi pointer to ftdi_context
1494
1495     \retval  0: all fine
1496     \retval -1: can't disable bitbang mode
1497 */
1498 int ftdi_disable_bitbang(struct ftdi_context *ftdi)
1499 {
1500     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_BITMODE_REQUEST, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1501         ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?");
1502
1503     ftdi->bitbang_enabled = 0;
1504     return 0;
1505 }
1506
1507 /**
1508     Enable advanced bitbang mode for FT2232C chips.
1509
1510     \param ftdi pointer to ftdi_context
1511     \param bitmask Bitmask to configure lines.
1512            HIGH/ON value configures a line as output.
1513     \param mode Bitbang mode: 1 for normal mode, 2 for SPI mode
1514
1515     \retval  0: all fine
1516     \retval -1: can't enable bitbang mode
1517 */
1518 int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
1519 {
1520     unsigned short usb_val;
1521
1522     usb_val = bitmask; // low byte: bitmask
1523     usb_val |= (mode << 8);
1524     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1525         ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps not a 2232C type chip?");
1526
1527     ftdi->bitbang_mode = mode;
1528     ftdi->bitbang_enabled = (mode == BITMODE_BITBANG || mode == BITMODE_SYNCBB)?1:0;
1529     return 0;
1530 }
1531
1532 /**
1533     Directly read pin state. Useful for bitbang mode.
1534
1535     \param ftdi pointer to ftdi_context
1536     \param pins Pointer to store pins into
1537
1538     \retval  0: all fine
1539     \retval -1: read pins failed
1540 */
1541 int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
1542 {
1543     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_PINS_REQUEST, 0, ftdi->index, (char *)pins, 1, ftdi->usb_read_timeout) != 1)
1544         ftdi_error_return(-1, "read pins failed");
1545
1546     return 0;
1547 }
1548
1549 /**
1550     Set latency timer
1551
1552     The FTDI chip keeps data in the internal buffer for a specific
1553     amount of time if the buffer is not full yet to decrease
1554     load on the usb bus.
1555
1556     \param ftdi pointer to ftdi_context
1557     \param latency Value between 1 and 255
1558
1559     \retval  0: all fine
1560     \retval -1: latency out of range
1561     \retval -2: unable to set latency timer
1562 */
1563 int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
1564 {
1565     unsigned short usb_val;
1566
1567     if (latency < 1)
1568         ftdi_error_return(-1, "latency out of range. Only valid for 1-255");
1569
1570     usb_val = latency;
1571     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_LATENCY_TIMER_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1572         ftdi_error_return(-2, "unable to set latency timer");
1573
1574     return 0;
1575 }
1576
1577 /**
1578     Get latency timer
1579
1580     \param ftdi pointer to ftdi_context
1581     \param latency Pointer to store latency value in
1582
1583     \retval  0: all fine
1584     \retval -1: unable to get latency timer
1585 */
1586 int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
1587 {
1588     unsigned short usb_val;
1589     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_GET_LATENCY_TIMER_REQUEST, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1)
1590         ftdi_error_return(-1, "reading latency timer failed");
1591
1592     *latency = (unsigned char)usb_val;
1593     return 0;
1594 }
1595
1596 /**
1597     Poll modem status information
1598
1599     This function allows the retrieve the two status bytes of the device.
1600     The device sends these bytes also as a header for each read access
1601     where they are discarded by ftdi_read_data(). The chip generates
1602     the two stripped status bytes in the absence of data every 40 ms.
1603
1604     Layout of the first byte:
1605     - B0..B3 - must be 0
1606     - B4       Clear to send (CTS)
1607                  0 = inactive
1608                  1 = active
1609     - B5       Data set ready (DTS)
1610                  0 = inactive
1611                  1 = active
1612     - B6       Ring indicator (RI)
1613                  0 = inactive
1614                  1 = active
1615     - B7       Receive line signal detect (RLSD)
1616                  0 = inactive
1617                  1 = active
1618
1619     Layout of the second byte:
1620     - B0       Data ready (DR)
1621     - B1       Overrun error (OE)
1622     - B2       Parity error (PE)
1623     - B3       Framing error (FE)
1624     - B4       Break interrupt (BI)
1625     - B5       Transmitter holding register (THRE)
1626     - B6       Transmitter empty (TEMT)
1627     - B7       Error in RCVR FIFO
1628
1629     \param ftdi pointer to ftdi_context
1630     \param status Pointer to store status information in. Must be two bytes.
1631
1632     \retval  0: all fine
1633     \retval -1: unable to retrieve status information
1634 */
1635 int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
1636 {
1637     char usb_val[2];
1638
1639     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_POLL_MODEM_STATUS_REQUEST, 0, ftdi->index, usb_val, 2, ftdi->usb_read_timeout) != 2)
1640         ftdi_error_return(-1, "getting modem status failed");
1641
1642     *status = (usb_val[1] << 8) | usb_val[0];
1643
1644     return 0;
1645 }
1646
1647 /**
1648     Set flowcontrol for ftdi chip
1649
1650     \param ftdi pointer to ftdi_context
1651     \param flowctrl flow control to use. should be
1652            SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS or SIO_XON_XOFF_HS
1653
1654     \retval  0: all fine
1655     \retval -1: set flow control failed
1656 */
1657 int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
1658 {
1659     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1660                         SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->index),
1661                         NULL, 0, ftdi->usb_write_timeout) != 0)
1662         ftdi_error_return(-1, "set flow control failed");
1663
1664     return 0;
1665 }
1666
1667 /**
1668     Set dtr line
1669
1670     \param ftdi pointer to ftdi_context
1671     \param state state to set line to (1 or 0)
1672
1673     \retval  0: all fine
1674     \retval -1: set dtr failed
1675 */
1676 int ftdi_setdtr(struct ftdi_context *ftdi, int state)
1677 {
1678     unsigned short usb_val;
1679
1680     if (state)
1681         usb_val = SIO_SET_DTR_HIGH;
1682     else
1683         usb_val = SIO_SET_DTR_LOW;
1684
1685     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1686                         SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
1687                         NULL, 0, ftdi->usb_write_timeout) != 0)
1688         ftdi_error_return(-1, "set dtr failed");
1689
1690     return 0;
1691 }
1692
1693 /**
1694     Set rts line
1695
1696     \param ftdi pointer to ftdi_context
1697     \param state state to set line to (1 or 0)
1698
1699     \retval  0: all fine
1700     \retval -1 set rts failed
1701 */
1702 int ftdi_setrts(struct ftdi_context *ftdi, int state)
1703 {
1704     unsigned short usb_val;
1705
1706     if (state)
1707         usb_val = SIO_SET_RTS_HIGH;
1708     else
1709         usb_val = SIO_SET_RTS_LOW;
1710
1711     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1712                         SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
1713                         NULL, 0, ftdi->usb_write_timeout) != 0)
1714         ftdi_error_return(-1, "set of rts failed");
1715
1716     return 0;
1717 }
1718
1719 /**
1720  Set dtr and rts line in one pass
1721
1722  \param ftdi pointer to ftdi_context
1723  \param dtr  DTR state to set line to (1 or 0)
1724  \param rts  RTS state to set line to (1 or 0)
1725
1726  \retval  0: all fine
1727  \retval -1 set dtr/rts failed
1728  */
1729 int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
1730 {
1731     unsigned short usb_val;
1732
1733     if (dtr)
1734         usb_val = SIO_SET_DTR_HIGH;
1735     else
1736         usb_val = SIO_SET_DTR_LOW;
1737
1738     if (rts)
1739         usb_val |= SIO_SET_RTS_HIGH;
1740     else
1741         usb_val |= SIO_SET_RTS_LOW;
1742
1743     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1744                         SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
1745                         NULL, 0, ftdi->usb_write_timeout) != 0)
1746         ftdi_error_return(-1, "set of rts/dtr failed");
1747
1748     return 0;
1749 }
1750
1751 /**
1752     Set the special event character
1753
1754     \param ftdi pointer to ftdi_context
1755     \param eventch Event character
1756     \param enable 0 to disable the event character, non-zero otherwise
1757
1758     \retval  0: all fine
1759     \retval -1: unable to set event character
1760 */
1761 int ftdi_set_event_char(struct ftdi_context *ftdi,
1762                         unsigned char eventch, unsigned char enable)
1763 {
1764     unsigned short usb_val;
1765
1766     usb_val = eventch;
1767     if (enable)
1768         usb_val |= 1 << 8;
1769
1770     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_EVENT_CHAR_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1771         ftdi_error_return(-1, "setting event character failed");
1772
1773     return 0;
1774 }
1775
1776 /**
1777     Set error character
1778
1779     \param ftdi pointer to ftdi_context
1780     \param errorch Error character
1781     \param enable 0 to disable the error character, non-zero otherwise
1782
1783     \retval  0: all fine
1784     \retval -1: unable to set error character
1785 */
1786 int ftdi_set_error_char(struct ftdi_context *ftdi,
1787                         unsigned char errorch, unsigned char enable)
1788 {
1789     unsigned short usb_val;
1790
1791     usb_val = errorch;
1792     if (enable)
1793         usb_val |= 1 << 8;
1794
1795     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_ERROR_CHAR_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1796         ftdi_error_return(-1, "setting error character failed");
1797
1798     return 0;
1799 }
1800
1801 /**
1802    Set the eeprom size
1803
1804    \param ftdi pointer to ftdi_context
1805    \param eeprom Pointer to ftdi_eeprom
1806    \param size
1807
1808 */
1809 void ftdi_eeprom_setsize(struct ftdi_context *ftdi, struct ftdi_eeprom *eeprom, int size)
1810 {
1811     ftdi->eeprom_size=size;
1812     eeprom->size=size;
1813 }
1814
1815 /**
1816     Init eeprom with default values.
1817
1818     \param eeprom Pointer to ftdi_eeprom
1819 */
1820 void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom)
1821 {
1822     eeprom->vendor_id = 0x0403;
1823     eeprom->product_id = 0x6001;
1824
1825     eeprom->self_powered = 1;
1826     eeprom->remote_wakeup = 1;
1827     eeprom->BM_type_chip = 1;
1828
1829     eeprom->in_is_isochronous = 0;
1830     eeprom->out_is_isochronous = 0;
1831     eeprom->suspend_pull_downs = 0;
1832
1833     eeprom->use_serial = 0;
1834     eeprom->change_usb_version = 0;
1835     eeprom->usb_version = 0x0200;
1836     eeprom->max_power = 0;
1837
1838     eeprom->manufacturer = NULL;
1839     eeprom->product = NULL;
1840     eeprom->serial = NULL;
1841
1842     eeprom->size = FTDI_DEFAULT_EEPROM_SIZE;
1843 }
1844
1845 /**
1846    Build binary output from ftdi_eeprom structure.
1847    Output is suitable for ftdi_write_eeprom().
1848
1849    \param eeprom Pointer to ftdi_eeprom
1850    \param output Buffer of 128 bytes to store eeprom image to
1851
1852    \retval >0: used eeprom size
1853    \retval -1: eeprom size (128 bytes) exceeded by custom strings
1854 */
1855 int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output)
1856 {
1857     unsigned char i, j;
1858     unsigned short checksum, value;
1859     unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
1860     int size_check;
1861
1862     if (eeprom->manufacturer != NULL)
1863         manufacturer_size = strlen(eeprom->manufacturer);
1864     if (eeprom->product != NULL)
1865         product_size = strlen(eeprom->product);
1866     if (eeprom->serial != NULL)
1867         serial_size = strlen(eeprom->serial);
1868
1869     size_check = eeprom->size;
1870     size_check -= 28; // 28 are always in use (fixed)
1871
1872     // Top half of a 256byte eeprom is used just for strings and checksum
1873     // it seems that the FTDI chip will not read these strings from the lower half
1874     // Each string starts with two bytes; offset and type (0x03 for string)
1875     // the checksum needs two bytes, so without the string data that 8 bytes from the top half
1876     if (eeprom->size>=256)size_check = 120;
1877     size_check -= manufacturer_size*2;
1878     size_check -= product_size*2;
1879     size_check -= serial_size*2;
1880
1881     // eeprom size exceeded?
1882     if (size_check < 0)
1883         return (-1);
1884
1885     // empty eeprom
1886     memset (output, 0, eeprom->size);
1887
1888     // Addr 00: Stay 00 00
1889     // Addr 02: Vendor ID
1890     output[0x02] = eeprom->vendor_id;
1891     output[0x03] = eeprom->vendor_id >> 8;
1892
1893     // Addr 04: Product ID
1894     output[0x04] = eeprom->product_id;
1895     output[0x05] = eeprom->product_id >> 8;
1896
1897     // Addr 06: Device release number (0400h for BM features)
1898     output[0x06] = 0x00;
1899
1900     if (eeprom->BM_type_chip == 1)
1901         output[0x07] = 0x04;
1902     else
1903         output[0x07] = 0x02;
1904
1905     // Addr 08: Config descriptor
1906     // Bit 7: always 1
1907     // Bit 6: 1 if this device is self powered, 0 if bus powered
1908     // Bit 5: 1 if this device uses remote wakeup
1909     // Bit 4: 1 if this device is battery powered
1910     j = 0x80;
1911     if (eeprom->self_powered == 1)
1912         j |= 0x40;
1913     if (eeprom->remote_wakeup == 1)
1914         j |= 0x20;
1915     output[0x08] = j;
1916
1917     // Addr 09: Max power consumption: max power = value * 2 mA
1918     output[0x09] = eeprom->max_power;
1919
1920     // Addr 0A: Chip configuration
1921     // Bit 7: 0 - reserved
1922     // Bit 6: 0 - reserved
1923     // Bit 5: 0 - reserved
1924     // Bit 4: 1 - Change USB version
1925     // Bit 3: 1 - Use the serial number string
1926     // Bit 2: 1 - Enable suspend pull downs for lower power
1927     // Bit 1: 1 - Out EndPoint is Isochronous
1928     // Bit 0: 1 - In EndPoint is Isochronous
1929     //
1930     j = 0;
1931     if (eeprom->in_is_isochronous == 1)
1932         j = j | 1;
1933     if (eeprom->out_is_isochronous == 1)
1934         j = j | 2;
1935     if (eeprom->suspend_pull_downs == 1)
1936         j = j | 4;
1937     if (eeprom->use_serial == 1)
1938         j = j | 8;
1939     if (eeprom->change_usb_version == 1)
1940         j = j | 16;
1941     output[0x0A] = j;
1942
1943     // Addr 0B: reserved
1944     output[0x0B] = 0x00;
1945
1946     // Addr 0C: USB version low byte when 0x0A bit 4 is set
1947     // Addr 0D: USB version high byte when 0x0A bit 4 is set
1948     if (eeprom->change_usb_version == 1)
1949     {
1950         output[0x0C] = eeprom->usb_version;
1951         output[0x0D] = eeprom->usb_version >> 8;
1952     }
1953
1954
1955     // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
1956     // Addr 0F: Length of manufacturer string
1957     output[0x0F] = manufacturer_size*2 + 2;
1958
1959     // Addr 10: Offset of the product string + 0x80, calculated later
1960     // Addr 11: Length of product string
1961     output[0x11] = product_size*2 + 2;
1962
1963     // Addr 12: Offset of the serial string + 0x80, calculated later
1964     // Addr 13: Length of serial string
1965     output[0x13] = serial_size*2 + 2;
1966
1967     // Dynamic content
1968     i=0x14;
1969     if (eeprom->size>=256) i = 0x80;
1970
1971
1972     // Output manufacturer
1973     output[0x0E] = i | 0x80;  // calculate offset
1974     output[i++] = manufacturer_size*2 + 2;
1975     output[i++] = 0x03; // type: string
1976     for (j = 0; j < manufacturer_size; j++)
1977     {
1978         output[i] = eeprom->manufacturer[j], i++;
1979         output[i] = 0x00, i++;
1980     }
1981
1982     // Output product name
1983     output[0x10] = i | 0x80;  // calculate offset
1984     output[i] = product_size*2 + 2, i++;
1985     output[i] = 0x03, i++;
1986     for (j = 0; j < product_size; j++)
1987     {
1988         output[i] = eeprom->product[j], i++;
1989         output[i] = 0x00, i++;
1990     }
1991
1992     // Output serial
1993     output[0x12] = i | 0x80; // calculate offset
1994     output[i] = serial_size*2 + 2, i++;
1995     output[i] = 0x03, i++;
1996     for (j = 0; j < serial_size; j++)
1997     {
1998         output[i] = eeprom->serial[j], i++;
1999         output[i] = 0x00, i++;
2000     }
2001
2002     // calculate checksum
2003     checksum = 0xAAAA;
2004
2005     for (i = 0; i < eeprom->size/2-1; i++)
2006     {
2007         value = output[i*2];
2008         value += output[(i*2)+1] << 8;
2009
2010         checksum = value^checksum;
2011         checksum = (checksum << 1) | (checksum >> 15);
2012     }
2013
2014     output[eeprom->size-2] = checksum;
2015     output[eeprom->size-1] = checksum >> 8;
2016
2017     return size_check;
2018 }
2019
2020 /**
2021    Decode binary EEPROM image into an ftdi_eeprom structure.
2022
2023    \param eeprom Pointer to ftdi_eeprom which will be filled in.
2024    \param buf Buffer of \a size bytes of raw eeprom data
2025    \param size size size of eeprom data in bytes
2026
2027    \retval 0: all fine
2028    \retval -1: something went wrong
2029
2030    FIXME: How to pass size? How to handle size field in ftdi_eeprom?
2031    FIXME: Strings are malloc'ed here and should be freed somewhere
2032 */
2033 int ftdi_eeprom_decode(struct ftdi_eeprom *eeprom, unsigned char *buf, int size)
2034 {
2035     unsigned char i, j;
2036     unsigned short checksum, eeprom_checksum, value;
2037     unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2038     int size_check;
2039     int eeprom_size = 128;
2040 #if 0
2041     size_check = eeprom->size;
2042     size_check -= 28; // 28 are always in use (fixed)
2043
2044     // Top half of a 256byte eeprom is used just for strings and checksum
2045     // it seems that the FTDI chip will not read these strings from the lower half
2046     // Each string starts with two bytes; offset and type (0x03 for string)
2047     // the checksum needs two bytes, so without the string data that 8 bytes from the top half
2048     if (eeprom->size>=256)size_check = 120;
2049     size_check -= manufacturer_size*2;
2050     size_check -= product_size*2;
2051     size_check -= serial_size*2;
2052
2053     // eeprom size exceeded?
2054     if (size_check < 0)
2055         return (-1);
2056 #endif
2057
2058     // empty eeprom struct
2059     memset(eeprom, 0, sizeof(struct ftdi_eeprom));
2060
2061     // Addr 00: Stay 00 00
2062
2063     // Addr 02: Vendor ID
2064     eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
2065
2066     // Addr 04: Product ID
2067     eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
2068
2069     value = buf[0x06] + (buf[0x07]<<8);
2070     switch (value)
2071     {
2072         case 0x0400:
2073             eeprom->BM_type_chip = 1;
2074             break;
2075         case 0x0200:
2076             eeprom->BM_type_chip = 0;
2077             break;
2078         default: // Unknown device
2079             eeprom->BM_type_chip = 0;
2080             break;
2081     }
2082
2083     // Addr 08: Config descriptor
2084     // Bit 7: always 1
2085     // Bit 6: 1 if this device is self powered, 0 if bus powered
2086     // Bit 5: 1 if this device uses remote wakeup
2087     // Bit 4: 1 if this device is battery powered
2088     j = buf[0x08];
2089     if (j&0x40) eeprom->self_powered = 1;
2090     if (j&0x20) eeprom->remote_wakeup = 1;
2091
2092     // Addr 09: Max power consumption: max power = value * 2 mA
2093     eeprom->max_power = buf[0x09];
2094
2095     // Addr 0A: Chip configuration
2096     // Bit 7: 0 - reserved
2097     // Bit 6: 0 - reserved
2098     // Bit 5: 0 - reserved
2099     // Bit 4: 1 - Change USB version
2100     // Bit 3: 1 - Use the serial number string
2101     // Bit 2: 1 - Enable suspend pull downs for lower power
2102     // Bit 1: 1 - Out EndPoint is Isochronous
2103     // Bit 0: 1 - In EndPoint is Isochronous
2104     //
2105     j = buf[0x0A];
2106     if (j&0x01) eeprom->in_is_isochronous = 1;
2107     if (j&0x02) eeprom->out_is_isochronous = 1;
2108     if (j&0x04) eeprom->suspend_pull_downs = 1;
2109     if (j&0x08) eeprom->use_serial = 1;
2110     if (j&0x10) eeprom->change_usb_version = 1;
2111
2112     // Addr 0B: reserved
2113
2114     // Addr 0C: USB version low byte when 0x0A bit 4 is set
2115     // Addr 0D: USB version high byte when 0x0A bit 4 is set
2116     if (eeprom->change_usb_version == 1)
2117     {
2118         eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
2119     }
2120
2121     // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2122     // Addr 0F: Length of manufacturer string
2123     manufacturer_size = buf[0x0F]/2;
2124     if (manufacturer_size > 0) eeprom->manufacturer = malloc(manufacturer_size);
2125     else eeprom->manufacturer = NULL;
2126
2127     // Addr 10: Offset of the product string + 0x80, calculated later
2128     // Addr 11: Length of product string
2129     product_size = buf[0x11]/2;
2130     if (product_size > 0) eeprom->product = malloc(product_size);
2131     else eeprom->product = NULL;
2132
2133     // Addr 12: Offset of the serial string + 0x80, calculated later
2134     // Addr 13: Length of serial string
2135     serial_size = buf[0x13]/2;
2136     if (serial_size > 0) eeprom->serial = malloc(serial_size);
2137     else eeprom->serial = NULL;
2138
2139     // Decode manufacturer
2140     i = buf[0x0E] & 0x7f; // offset
2141     for (j=0;j<manufacturer_size-1;j++)
2142     {
2143         eeprom->manufacturer[j] = buf[2*j+i+2];
2144     }
2145     eeprom->manufacturer[j] = '\0';
2146
2147     // Decode product name
2148     i = buf[0x10] & 0x7f; // offset
2149     for (j=0;j<product_size-1;j++)
2150     {
2151         eeprom->product[j] = buf[2*j+i+2];
2152     }
2153     eeprom->product[j] = '\0';
2154
2155     // Decode serial
2156     i = buf[0x12] & 0x7f; // offset
2157     for (j=0;j<serial_size-1;j++)
2158     {
2159         eeprom->serial[j] = buf[2*j+i+2];
2160     }
2161     eeprom->serial[j] = '\0';
2162
2163     // verify checksum
2164     checksum = 0xAAAA;
2165
2166     for (i = 0; i < eeprom_size/2-1; i++)
2167     {
2168         value = buf[i*2];
2169         value += buf[(i*2)+1] << 8;
2170
2171         checksum = value^checksum;
2172         checksum = (checksum << 1) | (checksum >> 15);
2173     }
2174
2175     eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
2176
2177     if (eeprom_checksum != checksum)
2178     {
2179         fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
2180         return -1;
2181     }
2182
2183     return 0;
2184 }
2185
2186 /**
2187     Read eeprom location
2188
2189     \param ftdi pointer to ftdi_context
2190     \param eeprom_addr Address of eeprom location to be read
2191     \param eeprom_val Pointer to store read eeprom location
2192
2193     \retval  0: all fine
2194     \retval -1: read failed
2195 */
2196 int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
2197 {
2198     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, eeprom_addr, (char *)eeprom_val, 2, ftdi->usb_read_timeout) != 2)
2199         ftdi_error_return(-1, "reading eeprom failed");
2200
2201     return 0;
2202 }
2203
2204 /**
2205     Read eeprom
2206
2207     \param ftdi pointer to ftdi_context
2208     \param eeprom Pointer to store eeprom into
2209
2210     \retval  0: all fine
2211     \retval -1: read failed
2212 */
2213 int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
2214 {
2215     int i;
2216
2217     for (i = 0; i < ftdi->eeprom_size/2; i++)
2218     {
2219         if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
2220             ftdi_error_return(-1, "reading eeprom failed");
2221     }
2222
2223     return 0;
2224 }
2225
2226 /*
2227     ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID
2228     Function is only used internally
2229     \internal
2230 */
2231 static unsigned char ftdi_read_chipid_shift(unsigned char value)
2232 {
2233     return ((value & 1) << 1) |
2234            ((value & 2) << 5) |
2235            ((value & 4) >> 2) |
2236            ((value & 8) << 4) |
2237            ((value & 16) >> 1) |
2238            ((value & 32) >> 1) |
2239            ((value & 64) >> 4) |
2240            ((value & 128) >> 2);
2241 }
2242
2243 /**
2244     Read the FTDIChip-ID from R-type devices
2245
2246     \param ftdi pointer to ftdi_context
2247     \param chipid Pointer to store FTDIChip-ID
2248
2249     \retval  0: all fine
2250     \retval -1: read failed
2251 */
2252 int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
2253 {
2254     unsigned int a = 0, b = 0;
2255
2256     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x43, (char *)&a, 2, ftdi->usb_read_timeout) == 2)
2257     {
2258         a = a << 8 | a >> 8;
2259         if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x44, (char *)&b, 2, ftdi->usb_read_timeout) == 2)
2260         {
2261             b = b << 8 | b >> 8;
2262             a = (a << 16) | (b & 0xFFFF);
2263             a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
2264                 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
2265             *chipid = a ^ 0xa5f0f7d1;
2266             return 0;
2267         }
2268     }
2269
2270     ftdi_error_return(-1, "read of FTDIChip-ID failed");
2271 }
2272
2273 /**
2274    Guesses size of eeprom by reading eeprom and comparing halves - will not work with blank eeprom
2275    Call this function then do a write then call again to see if size changes, if so write again.
2276
2277    \param ftdi pointer to ftdi_context
2278    \param eeprom Pointer to store eeprom into
2279    \param maxsize the size of the buffer to read into
2280
2281    \retval size of eeprom
2282 */
2283 int ftdi_read_eeprom_getsize(struct ftdi_context *ftdi, unsigned char *eeprom, int maxsize)
2284 {
2285     int i=0,j,minsize=32;
2286     int size=minsize;
2287
2288     do
2289     {
2290         for (j = 0; i < maxsize/2 && j<size; j++)
2291         {
2292             if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,
2293                                 SIO_READ_EEPROM_REQUEST, 0, i,
2294                                 eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
2295                 ftdi_error_return(-1, "reading eeprom failed");
2296             i++;
2297         }
2298         size*=2;
2299     }
2300     while (size<=maxsize && memcmp(eeprom,&eeprom[size/2],size/2)!=0);
2301
2302     return size/2;
2303 }
2304
2305 /**
2306     Write eeprom location
2307
2308     \param ftdi pointer to ftdi_context
2309     \param eeprom_addr Address of eeprom location to be written
2310     \param eeprom_val Value to be written
2311
2312     \retval  0: all fine
2313     \retval -1: read failed
2314 */
2315 int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short eeprom_val)
2316 {
2317     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2318                                     SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
2319                                     NULL, 0, ftdi->usb_write_timeout) != 0)
2320         ftdi_error_return(-1, "unable to write eeprom");
2321
2322     return 0;
2323 }
2324
2325 /**
2326     Write eeprom
2327
2328     \param ftdi pointer to ftdi_context
2329     \param eeprom Pointer to read eeprom from
2330
2331     \retval  0: all fine
2332     \retval -1: read failed
2333 */
2334 int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
2335 {
2336     unsigned short usb_val, status;
2337     int i, ret;
2338
2339     /* These commands were traced while running MProg */
2340     if ((ret = ftdi_usb_reset(ftdi)) != 0)
2341         return ret;
2342     if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0)
2343         return ret;
2344     if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0)
2345         return ret;
2346
2347     for (i = 0; i < ftdi->eeprom_size/2; i++)
2348     {
2349         usb_val = eeprom[i*2];
2350         usb_val += eeprom[(i*2)+1] << 8;
2351         if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2352                             SIO_WRITE_EEPROM_REQUEST, usb_val, i,
2353                             NULL, 0, ftdi->usb_write_timeout) != 0)
2354             ftdi_error_return(-1, "unable to write eeprom");
2355     }
2356
2357     return 0;
2358 }
2359
2360 /**
2361     Erase eeprom
2362
2363     This is not supported on FT232R/FT245R according to the MProg manual from FTDI.
2364
2365     \param ftdi pointer to ftdi_context
2366
2367     \retval  0: all fine
2368     \retval -1: erase failed
2369 */
2370 int ftdi_erase_eeprom(struct ftdi_context *ftdi)
2371 {
2372     if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST, 0, 0, NULL, 0, ftdi->usb_write_timeout) != 0)
2373         ftdi_error_return(-1, "unable to erase eeprom");
2374
2375     return 0;
2376 }
2377
2378 /**
2379     Get string representation for last error code
2380
2381     \param ftdi pointer to ftdi_context
2382
2383     \retval Pointer to error string
2384 */
2385 char *ftdi_get_error_string (struct ftdi_context *ftdi)
2386 {
2387     return ftdi->error_str;
2388 }
2389
2390 /* @} end of doxygen libftdi group */