developer.intra2net.com Git - libftdi/blob - src/ftdi.c

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