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