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

diff --git a/ftdi/ftdi.c b/ftdi/ftdi.c
index 1f3e0f3..18c4d1d 100644
--- a/ftdi/ftdi.c
+++ b/ftdi/ftdi.c
@@ -3,7 +3,7 @@
                              -------------------
     begin                : Fri Apr 4 2003
     copyright            : (C) 2003 by Intra2net AG
-    email                : info@intra2net.com
+    email                : opensource@intra2net.com
  ***************************************************************************/
 
 /***************************************************************************
@@ -15,19 +15,44 @@
  ***************************************************************************/
 
 #include <usb.h>
- 
+
 #include "ftdi.h"
 
+/* ftdi_init return codes:
+   0: all fine
+  -1: couldn't allocate read buffer
+*/
 int ftdi_init(struct ftdi_context *ftdi) {
     ftdi->usb_dev = NULL;
-    ftdi->usb_timeout = 5000;
+    ftdi->usb_read_timeout = 5000;
+    ftdi->usb_write_timeout = 5000;
 
     ftdi->baudrate = -1;
     ftdi->bitbang_enabled = 0;
 
+    ftdi->readbuffer = NULL;
+    ftdi->readbuffer_offset = 0;
+    ftdi->readbuffer_remaining = 0;
+    ftdi->writebuffer_chunksize = 4096;
+
+    ftdi->interface = 0;
+    ftdi->index = 0;
+    ftdi->in_ep = 0x02;
+    ftdi->out_ep = 0x81;
+    ftdi->bitbang_mode = 1; /* 1: Normal bitbang mode, 2: SPI bitbang mode */
+    
     ftdi->error_str = NULL;
 
-    return 0;
+    // all fine. Now allocate the readbuffer
+    return ftdi_read_data_set_chunksize(ftdi, 4096);
+}
+
+
+void ftdi_deinit(struct ftdi_context *ftdi) {
+    if (ftdi->readbuffer != NULL) {
+        free(ftdi->readbuffer);
+        ftdi->readbuffer = NULL;
+    }
 }
 
 
@@ -67,16 +92,16 @@ int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product) {
             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, 0) != 0) {
+                    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 (ftdi_usb_reset (ftdi) != 0)
-                       return -6;
+                        return -6;
 
                     if (ftdi_set_baudrate (ftdi, 9600) != 0)
-                       return -7;
+                        return -7;
 
                     return 0;
                 } else {
@@ -94,14 +119,34 @@ int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product) {
 
 
 int ftdi_usb_reset(struct ftdi_context *ftdi) {
-    if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 0, 0, NULL, 0, ftdi->usb_timeout) != 0) {
+    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;
     }
+    // Invalidate data in the readbuffer
+    ftdi->readbuffer_offset = 0;
+    ftdi->readbuffer_remaining = 0;
 
     return 0;
 }
 
+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;
+    }
+    // Invalidate data in the readbuffer
+    ftdi->readbuffer_offset = 0;
+    ftdi->readbuffer_remaining = 0;
+
+    if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 2, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
+        ftdi->error_str = "FTDI purge of TX buffer failed";
+        return -1;
+    }
+
+
+    return 0;
+}
 
 /* ftdi_usb_close return codes
     0: all fine
@@ -111,7 +156,7 @@ int ftdi_usb_reset(struct ftdi_context *ftdi) {
 int ftdi_usb_close(struct ftdi_context *ftdi) {
     int rtn = 0;
 
-    if (usb_release_interface(ftdi->usb_dev, 0) != 0)
+    if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0)
         rtn = -1;
 
     if (usb_close (ftdi->usb_dev) != 0)
@@ -179,7 +224,8 @@ int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) {
         return -1;
     }
 
-    if (usb_control_msg(ftdi->usb_dev, 0x40, 3, ftdi_baudrate, 0, NULL, 0, ftdi->usb_timeout) != 0) {
+
+    if (usb_control_msg(ftdi->usb_dev, 0x40, 3, ftdi_baudrate, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
         ftdi->error_str = "Setting new baudrate failed";
         return -2;
     }
@@ -189,55 +235,159 @@ int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) {
 }
 
 
-int ftdi_write_data(struct ftdi_context *ftdi, 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;
     while (offset < size) {
-        int write_size = 64;
+        int write_size = ftdi->writebuffer_chunksize;
 
         if (offset+write_size > size)
             write_size = size-offset;
 
-        ret=usb_bulk_write(ftdi->usb_dev, 2, buf+offset, write_size, ftdi->usb_timeout);
-        if (ret == -1)
+        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;
+        }
+        total_written += ret;
 
         offset += write_size;
     }
 
+    return total_written;
+}
+
+
+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) {
+    *chunksize = ftdi->writebuffer_chunksize;
     return 0;
 }
 
 
-int ftdi_read_data(struct ftdi_context *ftdi, char *buf, int size) {
-    /*
-      unsigned char buf[64];
-      int read_bytes;
+int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) {
+    int offset = 0, ret = 1;
+
+    // everything we want is still in the readbuffer?
+    if (size <= ftdi->readbuffer_remaining) {
+        memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
+
+        // Fix offsets
+        ftdi->readbuffer_remaining -= size;
+        ftdi->readbuffer_offset += size;
+
+        /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
+
+        return size;
+    }
+    // something still in the readbuffer, but not enough to satisfy 'size'?
+    if (ftdi->readbuffer_remaining != 0) {
+        memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
+
+        // Fix offset
+        offset += ftdi->readbuffer_remaining;
+    }
+    // do the actual USB read
+    while (offset < size && ret > 0) {
+        ftdi->readbuffer_remaining = 0;
+        ftdi->readbuffer_offset = 0;
+        /* 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 > 2) {
+            // skip FTDI status bytes.
+            // Maybe stored in the future to enable modem use
+            ftdi->readbuffer_offset += 2;
+            ret -= 2;
+        } else if (ret <= 2) {
+            // no more data to read?
+            return offset;
+        }
+        if (ret > 0) {
+            // data still fits in buf?
+            if (offset+ret <= size) {
+                memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, ret);
+                //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
+                offset += ret;
+
+		/* Did we read exactly the right amount of bytes? */
+                if (offset == size)
+                    return offset;
+            } else {
+                // only copy part of the data or size <= readbuffer_chunksize
+                int part_size = size-offset;
+                memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
+
+                ftdi->readbuffer_offset += part_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); */
+
+                return offset;
+            }
+        }
+    }
+    // never reached
+    return -2;
+}
+
+
+int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize) {
+    // 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;
+    }
+
+    ftdi->readbuffer = new_buf;
+    ftdi->readbuffer_chunksize = chunksize;
+
+    return 0;
+}
+
 
-      read_bytes = usb_bulk_read (udev, 0x81, (char *)&buf, 64, USB_TIMEOUT);
-    */
-    ftdi->error_str = "Not implemented yet";
-    return -1;
+int ftdi_readt_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) {
     unsigned short usb_val;
 
-    usb_val = bitmask;	// low byte: bitmask
-    usb_val += 1 << 8;	// high byte: enable flag
-    if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, 0, NULL, 0, ftdi->usb_timeout) != 0) {
+    usb_val = bitmask; // low byte: bitmask
+    /* FT2232C: Set bitbang_mode to 2 to enable SPI */
+    usb_val |= (ftdi->bitbang_mode << 8);
+
+    if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
         ftdi->error_str = "Unable to enter bitbang mode. Perhaps not a BM type chip?";
         return -1;
     }
-
     ftdi->bitbang_enabled = 1;
     return 0;
 }
 
 
 int ftdi_disable_bitbang(struct ftdi_context *ftdi) {
-    if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, 0, 0, NULL, 0, ftdi->usb_timeout) != 0) {
+    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;
     }
@@ -249,7 +399,7 @@ int ftdi_disable_bitbang(struct ftdi_context *ftdi) {
 
 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, 0, (char *)&usb_val, 1, ftdi->usb_timeout) != 1) {
+    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";
         return -1;
     }
@@ -263,13 +413,14 @@ int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency) {
     unsigned short usb_val;
 
     if (latency < 1) {
-       ftdi->error_str = "Latency out of range. Only valid for 1-255";
-       return -1;
+        ftdi->error_str = "Latency out of range. Only valid for 1-255";
+        return -1;
     }
 
-    if (usb_control_msg(ftdi->usb_dev, 0x40, 0x09, usb_val, 0, NULL, 0, ftdi->usb_timeout) != 0) {
-       ftdi->error_str = "Unable to set latency timer";
-       return -2;
+    usb_val = latency;
+    if (usb_control_msg(ftdi->usb_dev, 0x40, 0x09, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
+        ftdi->error_str = "Unable to set latency timer";
+        return -2;
     }
     return 0;
 }
@@ -277,7 +428,7 @@ int ftdi_set_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, 0x09, 0, 0, (char *)&usb_val, 1, ftdi->usb_timeout) != 1) {
+    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";
         return -1;
     }
@@ -287,13 +438,195 @@ int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency) {
 }
 
 
-int ftdi_read_eeprom(struct ftdi_context *ftdi, char *eeprom) {
+void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom) {
+    eeprom->vendor_id = 0403;
+    eeprom->product_id = 6001;
+
+    eeprom->self_powered = 1;
+    eeprom->remote_wakeup = 1;
+    eeprom->BM_type_chip = 1;
+
+    eeprom->in_is_isochronous = 0;
+    eeprom->out_is_isochronous = 0;
+    eeprom->suspend_pull_downs = 0;
+
+    eeprom->use_serial = 0;
+    eeprom->change_usb_version = 0;
+    eeprom->usb_version = 200;
+    eeprom->max_power = 0;
+
+    eeprom->manufacturer = NULL;
+    eeprom->product = NULL;
+    eeprom->serial = NULL;
+}
+
+
+/*
+    ftdi_eeprom_build return codes:
+    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) {
+    unsigned char i, j;
+    unsigned short checksum, value;
+    unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
+    int size_check;
+
+    if (eeprom->manufacturer != NULL)
+        manufacturer_size = strlen(eeprom->manufacturer);
+    if (eeprom->product != NULL)
+        product_size = strlen(eeprom->product);
+    if (eeprom->serial != NULL)
+        serial_size = strlen(eeprom->serial);
+
+    size_check = 128; // eeprom is 128 bytes
+    size_check -= 28; // 28 are always in use (fixed)
+    size_check -= manufacturer_size*2;
+    size_check -= product_size*2;
+    size_check -= serial_size*2;
+
+    // eeprom size exceeded?
+    if (size_check < 0)
+        return (-1);
+
+    // empty eeprom
+    memset (output, 0, 128);
+
+    // Addr 00: Stay 00 00
+    // Addr 02: Vendor ID
+    output[0x02] = eeprom->vendor_id;
+    output[0x03] = eeprom->vendor_id >> 8;
+
+    // Addr 04: Product ID
+    output[0x04] = eeprom->product_id;
+    output[0x05] = eeprom->product_id >> 8;
+
+    // Addr 06: Device release number (0400h for BM features)
+    output[0x06] = 0x00;
+
+    if (eeprom->BM_type_chip == 1)
+        output[0x07] = 0x04;
+    else
+        output[0x07] = 0x02;
+
+    // Addr 08: Config descriptor
+    // Bit 1: remote wakeup if 1
+    // Bit 0: self powered if 1
+    //
+    j = 0;
+    if (eeprom->self_powered == 1)
+        j = j | 1;
+    if (eeprom->remote_wakeup == 1)
+        j = j | 2;
+    output[0x08] = j;
+
+    // Addr 09: Max power consumption: max power = value * 2 mA
+    output[0x09] = eeprom->max_power;
+    ;
+
+    // Addr 0A: Chip configuration
+    // Bit 7: 0 - reserved
+    // Bit 6: 0 - reserved
+    // Bit 5: 0 - reserved
+    // Bit 4: 1 - Change USB version
+    // Bit 3: 1 - Use the serial number string
+    // Bit 2: 1 - Enable suspend pull downs for lower power
+    // Bit 1: 1 - Out EndPoint is Isochronous
+    // Bit 0: 1 - In EndPoint is Isochronous
+    //
+    j = 0;
+    if (eeprom->in_is_isochronous == 1)
+        j = j | 1;
+    if (eeprom->out_is_isochronous == 1)
+        j = j | 2;
+    if (eeprom->suspend_pull_downs == 1)
+        j = j | 4;
+    if (eeprom->use_serial == 1)
+        j = j | 8;
+    if (eeprom->change_usb_version == 1)
+        j = j | 16;
+    output[0x0A] = j;
+
+    // Addr 0B: reserved
+    output[0x0B] = 0x00;
+
+    // Addr 0C: USB version low byte when 0x0A bit 4 is set
+    // Addr 0D: USB version high byte when 0x0A bit 4 is set
+    if (eeprom->change_usb_version == 1) {
+        output[0x0C] = eeprom->usb_version;
+        output[0x0D] = eeprom->usb_version >> 8;
+    }
+
+
+    // Addr 0E: Offset of the manufacturer string + 0x80
+    output[0x0E] = 0x14 + 0x80;
+
+    // Addr 0F: Length of manufacturer string
+    output[0x0F] = manufacturer_size*2 + 2;
+
+    // Addr 10: Offset of the product string + 0x80, calculated later
+    // Addr 11: Length of product string
+    output[0x11] = product_size*2 + 2;
+
+    // Addr 12: Offset of the serial string + 0x80, calculated later
+    // Addr 13: Length of serial string
+    output[0x13] = serial_size*2 + 2;
+
+    // Dynamic content
+    output[0x14] = manufacturer_size*2 + 2;
+    output[0x15] = 0x03; // type: string
+
+    i = 0x16, j = 0;
+
+    // Output manufacturer
+    for (j = 0; j < manufacturer_size; j++) {
+        output[i] = eeprom->manufacturer[j], i++;
+        output[i] = 0x00, i++;
+    }
+
+    // Output product name
+    output[0x10] = i + 0x80;  // calculate offset
+    output[i] = product_size*2 + 2, i++;
+    output[i] = 0x03, i++;
+    for (j = 0; j < product_size; j++) {
+        output[i] = eeprom->product[j], i++;
+        output[i] = 0x00, i++;
+    }
+
+    // Output serial
+    output[0x12] = i + 0x80; // calculate offset
+    output[i] = serial_size*2 + 2, i++;
+    output[i] = 0x03, i++;
+    for (j = 0; j < serial_size; j++) {
+        output[i] = eeprom->serial[j], i++;
+        output[i] = 0x00, i++;
+    }
+
+    // calculate checksum
+    checksum = 0xAAAA;
+
+    for (i = 0; i < 63; i++) {
+        value = output[i*2];
+        value += output[(i*2)+1] << 8;
+
+        checksum = value^checksum;
+        checksum = (checksum << 1) | (checksum >> 15);
+    }
+
+    output[0x7E] = checksum;
+    output[0x7F] = checksum >> 8;
+
+    return size_check;
+}
+
+
+int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) {
     int i;
 
     for (i = 0; i < 64; i++) {
-        if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_timeout) != 2) {
-           ftdi->error_str = "Reading eeprom failed";
-           return -1;
+        if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2) {
+            ftdi->error_str = "Reading eeprom failed";
+            return -1;
         }
     }
 
@@ -301,17 +634,17 @@ int ftdi_read_eeprom(struct ftdi_context *ftdi, char *eeprom) {
 }
 
 
-int ftdi_write_eeprom(struct ftdi_context *ftdi, char *eeprom) {
+int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) {
     unsigned short usb_val;
     int i;
 
     for (i = 0; i < 64; i++) {
-       usb_val = eeprom[i*2];
-       usb_val += eeprom[(i*2)+1] << 8;
-       if (usb_control_msg(ftdi->usb_dev, 0x40, 0x91, usb_val, i, NULL, 0, ftdi->usb_timeout) != 0) {
-          ftdi->error_str = "Unable to write eeprom";
-          return -1;
-       }
+        usb_val = eeprom[i*2];
+        usb_val += eeprom[(i*2)+1] << 8;
+        if (usb_control_msg(ftdi->usb_dev, 0x40, 0x91, usb_val, i, NULL, 0, ftdi->usb_write_timeout) != 0) {
+            ftdi->error_str = "Unable to write eeprom";
+            return -1;
+        }
     }
 
     return 0;
@@ -319,7 +652,7 @@ int ftdi_write_eeprom(struct ftdi_context *ftdi, char *eeprom) {
 
 
 int ftdi_erase_eeprom(struct ftdi_context *ftdi) {
-    if (usb_control_msg(ftdi->usb_dev, 0x40, 0x92, 0, 0, NULL, 0, ftdi->usb_timeout) != 0) {
+    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;
     }