X-Git-Url: http://developer.intra2net.com/git/?p=libftdi;a=blobdiff_plain;f=ftdi%2Fftdi.c;h=4c6b7385486bc4c064096f0ba363bb209bf09295;hp=18c4d1dc0a4d4ff606f83660a167e5db5362457b;hb=1c733d337b6383a0202220a52a2fbe74209180a4;hpb=3119537ff1cf8b9a6f945806dbb75d3bc71935e2

diff --git a/ftdi/ftdi.c b/ftdi/ftdi.c
index 18c4d1d..4c6b738 100644
--- a/ftdi/ftdi.c
+++ b/ftdi/ftdi.c
@@ -15,6 +15,7 @@
  ***************************************************************************/
 
 #include <usb.h>
+#include <string.h>
 
 #include "ftdi.h"
 
@@ -22,11 +23,13 @@
    0: all fine
   -1: couldn't allocate read buffer
 */
-int ftdi_init(struct ftdi_context *ftdi) {
+int ftdi_init(struct ftdi_context *ftdi)
+{
     ftdi->usb_dev = NULL;
     ftdi->usb_read_timeout = 5000;
     ftdi->usb_write_timeout = 5000;
 
+    ftdi->type = TYPE_BM;    /* chip type */
     ftdi->baudrate = -1;
     ftdi->bitbang_enabled = 0;
 
@@ -40,15 +43,16 @@ int ftdi_init(struct ftdi_context *ftdi) {
     ftdi->in_ep = 0x02;
     ftdi->out_ep = 0x81;
     ftdi->bitbang_mode = 1; /* 1: Normal bitbang mode, 2: SPI bitbang mode */
-    
+
     ftdi->error_str = NULL;
 
-    // all fine. Now allocate the readbuffer
+    /* All fine. Now allocate the readbuffer */
     return ftdi_read_data_set_chunksize(ftdi, 4096);
 }
 
 
-void ftdi_deinit(struct ftdi_context *ftdi) {
+void ftdi_deinit(struct ftdi_context *ftdi)
+{
     if (ftdi->readbuffer != NULL) {
         free(ftdi->readbuffer);
         ftdi->readbuffer = NULL;
@@ -56,7 +60,8 @@ void ftdi_deinit(struct ftdi_context *ftdi) {
 }
 
 
-void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *usb) {
+void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *usb)
+{
     ftdi->usb_dev = usb;
 }
 
@@ -70,8 +75,18 @@ void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *usb) {
   -5: unable to claim device
   -6: reset failed
   -7: set baudrate failed
+  -8: get product description failed
+  -9: get serial number failed
+  -10: unable to close device
 */
-int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product) {
+int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
+{
+    return ftdi_usb_open_desc(ftdi, vendor, product, NULL, NULL);
+}
+
+int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
+                       const char* description, const char* serial)
+{
     struct usb_bus *bus;
     struct usb_device *dev;
 
@@ -89,28 +104,75 @@ int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product) {
 
     for (bus = usb_busses; bus; bus = bus->next) {
         for (dev = bus->devices; dev; dev = dev->next) {
-            if (dev->descriptor.idVendor == vendor && dev->descriptor.idProduct == product) {
-                ftdi->usb_dev = usb_open(dev);
-                if (ftdi->usb_dev) {
-                    if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0) {
-                        ftdi->error_str = "unable to claim usb device. You can still use it though...";
-                        return -5;
+            if (dev->descriptor.idVendor == vendor
+                && dev->descriptor.idProduct == product) {
+                if (!(ftdi->usb_dev = usb_open(dev))) {
+                    ftdi->error_str = "usb_open() failed";
+                    return -4;
+                }
+                
+                char string[256];
+                if (description != NULL) {
+                    if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, string, sizeof(string)) <= 0) {
+                        ftdi->error_str = "unable to fetch product description\n";
+                        if (usb_close (ftdi->usb_dev) != 0)
+                            return -10;
+                        return -8;
                     }
+                    if (strncmp(string, description, sizeof(string)) != 0) {
+                        ftdi->error_str = "product description not matching\n";
+                        if (usb_close (ftdi->usb_dev) != 0)
+                            return -10;
+                        continue;
+                    }
+                }
+                if (serial != NULL) {
+                    if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, string, sizeof(string)) <= 0) {
+                        ftdi->error_str = "unable to fetch serial number\n";
+                        if (usb_close (ftdi->usb_dev) != 0)
+                            return -10;
+                        return -9;
+                    }
+                    if (strncmp(string, serial, sizeof(string)) != 0) {
+                        ftdi->error_str = "serial number not matching\n";
+                        if (usb_close (ftdi->usb_dev) != 0)
+                            return -10;
+                        continue;
+                    }
+                }
 
-                    if (ftdi_usb_reset (ftdi) != 0)
-                        return -6;
-
-                    if (ftdi_set_baudrate (ftdi, 9600) != 0)
-                        return -7;
+                if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0) {
+                    ftdi->error_str = "unable to claim usb device. Make sure ftdi_sio is unloaded!";
+                    if (usb_close (ftdi->usb_dev) != 0)
+                        return -10;
+                    return -5;
+                }
 
-                    return 0;
-                } else {
-                    ftdi->error_str = "usb_open() failed";
-                    return -4;
+                if (ftdi_usb_reset (ftdi) != 0) {
+                    if (usb_close (ftdi->usb_dev) != 0)
+                        return -10;
+                    return -6;
                 }
+                    
+                if (ftdi_set_baudrate (ftdi, 9600) != 0) {
+                    if (usb_close (ftdi->usb_dev) != 0)
+                        return -10;
+                    return -7;
+                }
+
+                // Try to guess chip type
+                // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
+                if (dev->descriptor.bcdDevice == 0x400 || (dev->descriptor.bcdDevice == 0x200
+                        && dev->descriptor.iSerialNumber == 0))
+                    ftdi->type = TYPE_BM;
+                else if (dev->descriptor.bcdDevice == 0x200)
+                    ftdi->type = TYPE_AM;
+                else if (dev->descriptor.bcdDevice == 0x500)
+                    ftdi->type = TYPE_2232C;
+
+                return 0;
             }
         }
-
     }
 
     // device not found
@@ -118,7 +180,8 @@ int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product) {
 }
 
 
-int ftdi_usb_reset(struct ftdi_context *ftdi) {
+int ftdi_usb_reset(struct ftdi_context *ftdi)
+{
     if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
         ftdi->error_str = "FTDI reset failed";
         return -1;
@@ -130,7 +193,8 @@ int ftdi_usb_reset(struct ftdi_context *ftdi) {
     return 0;
 }
 
-int ftdi_usb_purge_buffers(struct ftdi_context *ftdi) {
+int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
+{
     if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 1, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
         ftdi->error_str = "FTDI purge of RX buffer failed";
         return -1;
@@ -153,7 +217,8 @@ int ftdi_usb_purge_buffers(struct ftdi_context *ftdi) {
    -1: usb_release failed
    -2: usb_close failed
 */
-int ftdi_usb_close(struct ftdi_context *ftdi) {
+int ftdi_usb_close(struct ftdi_context *ftdi)
+{
     int rtn = 0;
 
     if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0)
@@ -167,65 +232,137 @@ int ftdi_usb_close(struct ftdi_context *ftdi) {
 
 
 /*
+    ftdi_convert_baudrate returns nearest supported baud rate to that requested.
+    Function is only used internally
+*/
+static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
+                                 unsigned short *value, unsigned short *index)
+{
+    static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
+    static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
+    static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
+    int divisor, best_divisor, best_baud, best_baud_diff;
+    unsigned long encoded_divisor;
+    int i;
+
+    if (baudrate <= 0) {
+        // Return error
+        return -1;
+    }
+
+    divisor = 24000000 / baudrate;
+
+    if (ftdi->type == TYPE_AM) {
+        // Round down to supported fraction (AM only)
+        divisor -= am_adjust_dn[divisor & 7];
+    }
+
+    // Try this divisor and the one above it (because division rounds down)
+    best_divisor = 0;
+    best_baud = 0;
+    best_baud_diff = 0;
+    for (i = 0; i < 2; i++) {
+        int try_divisor = divisor + i;
+        int baud_estimate;
+        int baud_diff;
+
+        // Round up to supported divisor value
+        if (try_divisor < 8) {
+            // Round up to minimum supported divisor
+            try_divisor = 8;
+        } else if (ftdi->type != TYPE_AM && try_divisor < 12) {
+            // BM doesn't support divisors 9 through 11 inclusive
+            try_divisor = 12;
+        } else if (divisor < 16) {
+            // AM doesn't support divisors 9 through 15 inclusive
+            try_divisor = 16;
+        } else {
+            if (ftdi->type == TYPE_AM) {
+                // Round up to supported fraction (AM only)
+                try_divisor += am_adjust_up[try_divisor & 7];
+                if (try_divisor > 0x1FFF8) {
+                    // Round down to maximum supported divisor value (for AM)
+                    try_divisor = 0x1FFF8;
+                }
+            } else {
+                if (try_divisor > 0x1FFFF) {
+                    // Round down to maximum supported divisor value (for BM)
+                    try_divisor = 0x1FFFF;
+                }
+            }
+        }
+        // Get estimated baud rate (to nearest integer)
+        baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
+        // Get absolute difference from requested baud rate
+        if (baud_estimate < baudrate) {
+            baud_diff = baudrate - baud_estimate;
+        } else {
+            baud_diff = baud_estimate - baudrate;
+        }
+        if (i == 0 || baud_diff < best_baud_diff) {
+            // Closest to requested baud rate so far
+            best_divisor = try_divisor;
+            best_baud = baud_estimate;
+            best_baud_diff = baud_diff;
+            if (baud_diff == 0) {
+                // Spot on! No point trying
+                break;
+            }
+        }
+    }
+    // Encode the best divisor value
+    encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
+    // Deal with special cases for encoded value
+    if (encoded_divisor == 1) {
+        encoded_divisor = 0;	// 3000000 baud
+    } else if (encoded_divisor == 0x4001) {
+        encoded_divisor = 1;	// 2000000 baud (BM only)
+    }
+    // Split into "value" and "index" values
+    *value = (unsigned short)(encoded_divisor & 0xFFFF);
+    if(ftdi->type == TYPE_2232C) {
+        *index = (unsigned short)(encoded_divisor >> 8);
+        *index &= 0xFF00;
+        *index |= ftdi->interface;
+    }
+    else
+        *index = (unsigned short)(encoded_divisor >> 16);
+    
+    // Return the nearest baud rate
+    return best_baud;
+}
+
+/*
     ftdi_set_baudrate return codes:
      0: all fine
     -1: invalid baudrate
     -2: setting baudrate failed
 */
-int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) {
-    unsigned short ftdi_baudrate;
+int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
+{
+    unsigned short value, index;
+    int actual_baudrate;
 
     if (ftdi->bitbang_enabled) {
         baudrate = baudrate*4;
     }
 
-    switch (baudrate) {
-    case 300:
-        ftdi_baudrate = 0x2710;
-        break;
-    case 600:
-        ftdi_baudrate = 0x1388;
-        break;
-    case 1200:
-        ftdi_baudrate = 0x09C4;
-        break;
-    case 2400:
-        ftdi_baudrate = 0x04E2;
-        break;
-    case 4800:
-        ftdi_baudrate = 0x0271;
-        break;
-    case 9600:
-        ftdi_baudrate = 0x4138;
-        break;
-    case 19200:
-        ftdi_baudrate = 0x809C;
-        break;
-    case 38400:
-        ftdi_baudrate = 0xC04E;
-        break;
-    case 57600:
-        ftdi_baudrate = 0x0034;
-        break;
-    case 115200:
-        ftdi_baudrate = 0x001A;
-        break;
-    case 230400:
-        ftdi_baudrate = 0x000D;
-        break;
-    case 460800:
-        ftdi_baudrate = 0x4006;
-        break;
-    case 921600:
-        ftdi_baudrate = 0x8003;
-        break;
-    default:
-        ftdi->error_str = "Unknown baudrate. Note: bitbang baudrates are automatically multiplied by 4";
+    actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
+    if (actual_baudrate <= 0) {
+        ftdi->error_str = "Silly baudrate <= 0.";
         return -1;
     }
 
+    // Check within tolerance (about 5%)
+    if ((actual_baudrate * 2 < baudrate /* Catch overflows */ )
+            || ((actual_baudrate < baudrate)
+                ? (actual_baudrate * 21 < baudrate * 20)
+                : (baudrate * 21 < actual_baudrate * 20))) {
+        ftdi->error_str = "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4";
+        return -1;
+    }
 
-    if (usb_control_msg(ftdi->usb_dev, 0x40, 3, ftdi_baudrate, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
+    if (usb_control_msg(ftdi->usb_dev, 0x40, 3, value, index, NULL, 0, ftdi->usb_write_timeout) != 0) {
         ftdi->error_str = "Setting new baudrate failed";
         return -2;
     }
@@ -235,7 +372,8 @@ int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) {
 }
 
 
-int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size) {
+int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
+{
     int ret;
     int offset = 0;
     int total_written = 0;
@@ -246,9 +384,12 @@ int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size) {
             write_size = size-offset;
 
         ret = usb_bulk_write(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, ftdi->usb_write_timeout);
-        if (ret == -1) {
-            ftdi->error_str = "bulk write failed";
-            return -1;
+        if (ret < 0) {
+            if (ret == -1)
+                ftdi->error_str = "bulk write failed";
+            else
+                ftdi->error_str = "usb failed";
+            return ret;
         }
         total_written += ret;
 
@@ -259,20 +400,23 @@ int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size) {
 }
 
 
-int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize) {
+int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
+{
     ftdi->writebuffer_chunksize = chunksize;
     return 0;
 }
 
 
-int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize) {
+int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
+{
     *chunksize = ftdi->writebuffer_chunksize;
     return 0;
 }
 
 
-int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) {
-    int offset = 0, ret = 1;
+int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
+{
+    int offset = 0, ret = 1, i, num_of_chunks, chunk_remains;
 
     // everything we want is still in the readbuffer?
     if (size <= ftdi->readbuffer_remaining) {
@@ -300,16 +444,37 @@ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) {
         /* returns how much received */
         ret = usb_bulk_read (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, ftdi->usb_read_timeout);
 
-        if (ret == -1) {
-            ftdi->error_str = "bulk read failed";
-            return -1;
+        if (ret < 0) {
+            if (ret == -1)
+                ftdi->error_str = "bulk read failed";
+            else
+                ftdi->error_str = "usb failed";
+            return ret;
         }
 
         if (ret > 2) {
             // skip FTDI status bytes.
             // Maybe stored in the future to enable modem use
+            num_of_chunks = ret / 64;
+            chunk_remains = ret % 64;
+            //printf("ret = %X, num_of_chunks = %X, chunk_remains = %X, readbuffer_offset = %X\n", ret, num_of_chunks, chunk_remains, ftdi->readbuffer_offset);
+
             ftdi->readbuffer_offset += 2;
             ret -= 2;
+
+            if (ret > 64) {
+                for (i = 1; i < num_of_chunks; i++)
+                    memmove (ftdi->readbuffer+ftdi->readbuffer_offset+62*i,
+                             ftdi->readbuffer+ftdi->readbuffer_offset+64*i,
+                             62);
+                if (chunk_remains > 2) {
+                    memmove (ftdi->readbuffer+ftdi->readbuffer_offset+62*i,
+                             ftdi->readbuffer+ftdi->readbuffer_offset+64*i,
+                             chunk_remains-2);
+                    ret -= 2*num_of_chunks;
+                } else
+                    ret -= 2*(num_of_chunks-1)+chunk_remains;
+            }
         } else if (ret <= 2) {
             // no more data to read?
             return offset;
@@ -321,7 +486,7 @@ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) {
                 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
                 offset += ret;
 
-		/* Did we read exactly the right amount of bytes? */
+                /* Did we read exactly the right amount of bytes? */
                 if (offset == size)
                     return offset;
             } else {
@@ -333,24 +498,26 @@ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) {
                 ftdi->readbuffer_remaining = ret-part_size;
                 offset += part_size;
 
-                /* printf("Returning part: %d - size: %d - offset: %d - ret: %d - remaining: %d\n", 
-		           part_size, size, offset, ret, ftdi->readbuffer_remaining); */
+                /* printf("Returning part: %d - size: %d - offset: %d - ret: %d - remaining: %d\n",
+                part_size, size, offset, ret, ftdi->readbuffer_remaining); */
 
                 return offset;
             }
         }
     }
     // never reached
-    return -2;
+    return -127;
 }
 
 
-int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize) {
+int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
+{
+    unsigned char *new_buf;
+
     // Invalidate all remaining data
     ftdi->readbuffer_offset = 0;
     ftdi->readbuffer_remaining = 0;
 
-    unsigned char *new_buf;
     if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL) {
         ftdi->error_str = "out of memory for readbuffer";
         return -1;
@@ -363,14 +530,16 @@ int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksi
 }
 
 
-int ftdi_readt_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize) {
+int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
+{
     *chunksize = ftdi->readbuffer_chunksize;
     return 0;
 }
 
 
 
-int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask) {
+int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask)
+{
     unsigned short usb_val;
 
     usb_val = bitmask; // low byte: bitmask
@@ -386,7 +555,8 @@ int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask) {
 }
 
 
-int ftdi_disable_bitbang(struct ftdi_context *ftdi) {
+int ftdi_disable_bitbang(struct ftdi_context *ftdi)
+{
     if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
         ftdi->error_str = "Unable to leave bitbang mode. Perhaps not a BM type chip?";
         return -1;
@@ -397,7 +567,8 @@ int ftdi_disable_bitbang(struct ftdi_context *ftdi) {
 }
 
 
-int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins) {
+int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
+{
     unsigned short usb_val;
     if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0C, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1) {
         ftdi->error_str = "Read pins failed";
@@ -409,7 +580,8 @@ int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins) {
 }
 
 
-int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency) {
+int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
+{
     unsigned short usb_val;
 
     if (latency < 1) {
@@ -426,7 +598,8 @@ int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency) {
 }
 
 
-int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency) {
+int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
+{
     unsigned short usb_val;
     if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0A, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1) {
         ftdi->error_str = "Reading latency timer failed";
@@ -438,9 +611,10 @@ int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency) {
 }
 
 
-void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom) {
-    eeprom->vendor_id = 0403;
-    eeprom->product_id = 6001;
+void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom)
+{
+    eeprom->vendor_id = 0x0403;
+    eeprom->product_id = 0x6001;
 
     eeprom->self_powered = 1;
     eeprom->remote_wakeup = 1;
@@ -452,7 +626,7 @@ void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom) {
 
     eeprom->use_serial = 0;
     eeprom->change_usb_version = 0;
-    eeprom->usb_version = 200;
+    eeprom->usb_version = 0x0200;
     eeprom->max_power = 0;
 
     eeprom->manufacturer = NULL;
@@ -466,7 +640,8 @@ void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom) {
     positive value: used eeprom size
     -1: eeprom size (128 bytes) exceeded by custom strings
 */
-int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) {
+int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output)
+{
     unsigned char i, j;
     unsigned short checksum, value;
     unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
@@ -620,7 +795,8 @@ int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) {
 }
 
 
-int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) {
+int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
+{
     int i;
 
     for (i = 0; i < 64; i++) {
@@ -634,7 +810,8 @@ int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) {
 }
 
 
-int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) {
+int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
+{
     unsigned short usb_val;
     int i;
 
@@ -651,7 +828,8 @@ int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) {
 }
 
 
-int ftdi_erase_eeprom(struct ftdi_context *ftdi) {
+int ftdi_erase_eeprom(struct ftdi_context *ftdi)
+{
     if (usb_control_msg(ftdi->usb_dev, 0x40, 0x92, 0, 0, NULL, 0, ftdi->usb_write_timeout) != 0) {
         ftdi->error_str = "Unable to erase eeprom";
         return -1;