/***************************************************************************
ftdi.c - description
-------------------
begin : Fri Apr 4 2003
copyright : (C) 2003 by Intra2net AG
email : opensource@intra2net.com
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License *
* version 2.1 as published by the Free Software Foundation; *
* *
***************************************************************************/
#include <usb.h>
#include <string.h>
#include "ftdi.h"
#define ftdi_error_return(code, str) do { \
ftdi->error_str = str; \
return code; \
} while(0);
/* ftdi_init
Initializes a ftdi_context.
Return codes:
0: All fine
-1: Couldn't allocate read buffer
*/
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;
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;
/* All fine. Now allocate the readbuffer */
return ftdi_read_data_set_chunksize( ftdi, 4096 );
}
/* ftdi_set_interface
Call after ftdi_init
Open selected channels on a chip, otherwise use first channel
0: all fine
-1: unknown interface
*/
int ftdi_set_interface( struct ftdi_context *ftdi,
enum ftdi_interface interface )
{
switch ( interface )
{
case INTERFACE_ANY:
case INTERFACE_A:
/* ftdi_usb_open_desc cares to set the right index, depending on the found chip */
break;
case INTERFACE_B:
ftdi->interface = 1;
ftdi->index = INTERFACE_B;
ftdi->in_ep = 0x04;
ftdi->out_ep = 0x83;
break;
default:
ftdi_error_return( -1, "Unknown interface" )
;
}
return 0;
}
/* ftdi_deinit
Deinitializes a ftdi_context.
*/
void ftdi_deinit( struct ftdi_context *ftdi )
{
if ( ftdi->readbuffer != NULL )
{
free( ftdi->readbuffer );
ftdi->readbuffer = NULL;
}
}
/* ftdi_set_usbdev
Use an already open device.
*/
void ftdi_set_usbdev( struct ftdi_context *ftdi, usb_dev_handle *usb )
{
ftdi->usb_dev = usb;
}
/* ftdi_usb_find_all
Finds all ftdi devices on the usb bus. Creates a new ftdi_device_list which
needs to be deallocated by ftdi_list_free after use.
Return codes:
>0: number of devices found
-1: usb_find_busses() failed
-2: usb_find_devices() failed
-3: out of memory
*/
int ftdi_usb_find_all( struct ftdi_context *ftdi,
struct ftdi_device_list **devlist, int vendor, int product )
{
struct ftdi_device_list **curdev;
struct usb_bus *bus;
struct usb_device *dev;
int count = 0;
usb_init( );
if ( usb_find_busses( ) < 0 )
ftdi_error_return( -1, "usb_find_busses() failed" );
if ( usb_find_devices( ) < 0 )
ftdi_error_return( -2, "usb_find_devices() failed" );
curdev = devlist;
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 )
{
*curdev = (struct ftdi_device_list*) malloc(
sizeof(struct ftdi_device_list) );
if ( ! *curdev )
ftdi_error_return( -3, "out of memory" );
( *curdev )->next = NULL;
( *curdev )->dev = dev;
curdev = &( *curdev )->next;
count++;
}
}
}
return count;
}
/* ftdi_list_free
Frees a created device list.
*/
void ftdi_list_free( struct ftdi_device_list **devlist )
{
struct ftdi_device_list **curdev;
for ( ; *devlist == NULL; devlist = curdev )
{
curdev = &( *devlist )->next;
free( *devlist );
}
devlist = NULL;
}
/* ftdi_usb_open_dev
Opens a ftdi device given by a usb_device.
Return codes:
0: all fine
-4: unable to open device
-5: unable to claim device
-6: reset failed
-7: set baudrate failed
*/
int ftdi_usb_open_dev( struct ftdi_context *ftdi, struct usb_device *dev )
{
if ( !( ftdi->usb_dev = usb_open( dev ) ) )
ftdi_error_return( -4, "usb_open() failed" );
if ( usb_claim_interface( ftdi->usb_dev, ftdi->interface ) != 0 )
{
usb_close( ftdi->usb_dev );
ftdi_error_return( -5,
"unable to claim usb device. Make sure ftdi_sio is unloaded!" );
}
if ( ftdi_usb_reset( ftdi ) != 0 )
{
usb_close( ftdi->usb_dev );
ftdi_error_return( -6, "ftdi_usb_reset failed" );
}
if ( ftdi_set_baudrate( ftdi, 9600 ) != 0 )
{
usb_close( ftdi->usb_dev );
ftdi_error_return( -7, "set baudrate failed" );
}
// 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;
if ( !ftdi->index )
ftdi->index = INTERFACE_A;
}
ftdi_error_return( 0, "all fine" );
}
/* ftdi_usb_open
Opens the first device with a given vendor and product ids.
Return codes:
See ftdi_usb_open_desc()
*/
int ftdi_usb_open( struct ftdi_context *ftdi, int vendor, int product )
{
return ftdi_usb_open_desc( ftdi, vendor, product, NULL, NULL );
}
/* ftdi_usb_open_desc
Opens the first device with a given, vendor id, product id,
description and serial.
Return codes:
0: all fine
-1: usb_find_busses() failed
-2: usb_find_devices() failed
-3: usb device not found
-4: unable to open device
-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_desc( struct ftdi_context *ftdi, int vendor, int product,
const char* description, const char* serial )
{
struct usb_bus *bus;
struct usb_device *dev;
char string[ 256 ];
usb_init( );
if ( usb_find_busses( ) < 0 )
ftdi_error_return( -1, "usb_find_busses() failed" );
if ( usb_find_devices( ) < 0 )
ftdi_error_return( -2, "usb_find_devices() failed" );
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 )
{
if ( !( ftdi->usb_dev = usb_open( dev ) ) )
ftdi_error_return( -4, "usb_open() failed" );
if ( description != NULL )
{
if ( usb_get_string_simple( ftdi->usb_dev, dev->descriptor.iProduct,
string, sizeof( string ) ) <= 0 )
{
usb_close( ftdi->usb_dev );
ftdi_error_return( -8, "unable to fetch product description" );
}
if ( strncmp( string, description, sizeof( string ) ) != 0 )
{
if ( usb_close( ftdi->usb_dev ) != 0 )
ftdi_error_return( -10, "unable to close device" );
continue;
}
}
if ( serial != NULL )
{
if ( usb_get_string_simple( ftdi->usb_dev,
dev->descriptor.iSerialNumber, string, sizeof( string ) ) <= 0 )
{
usb_close( ftdi->usb_dev );
ftdi_error_return( -9, "unable to fetch serial number" );
}
if ( strncmp( string, serial, sizeof( string ) ) != 0 )
{
if ( usb_close( ftdi->usb_dev ) != 0 )
ftdi_error_return( -10, "unable to close device" );
continue;
}
}
if ( usb_close( ftdi->usb_dev ) != 0 )
ftdi_error_return( -10, "unable to close device" );
return ftdi_usb_open_dev( ftdi, dev );
}
}
}
// device not found
ftdi_error_return( -3, "device not found" );
}
/* ftdi_usb_reset
Resets the ftdi device.
Return codes:
0: all fine
-1: FTDI reset failed
*/
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_return( -1, "FTDI reset failed" );
// Invalidate data in the readbuffer
ftdi->readbuffer_offset = 0;
ftdi->readbuffer_remaining = 0;
return 0;
}
/* ftdi_usb_purge_buffers
Cleans the buffers of the ftdi device.
Return codes:
0: all fine
-1: write buffer purge failed
-2: read buffer purge failed
*/
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_return( -1, "FTDI purge of RX buffer failed" );
// 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_return( -2, "FTDI purge of TX buffer failed" );
return 0;
}
/* ftdi_usb_close
Closes the ftdi device.
Return codes:
0: all fine
-1: usb_release failed
-2: usb_close failed
*/
int ftdi_usb_close( struct ftdi_context *ftdi )
{
int rtn = 0;
if ( usb_release_interface( ftdi->usb_dev, ftdi->interface ) != 0 )
rtn = -1;
if ( usb_close( ftdi->usb_dev ) != 0 )
rtn = -2;
return rtn;
}
/*
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->index;
}
else
*index = (unsigned short) ( encoded_divisor >> 16 );
// Return the nearest baud rate
return best_baud;
}
/*
ftdi_set_baudrate
Sets the chip 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 value, index;
int actual_baudrate;
if ( ftdi->bitbang_enabled )
{
baudrate = baudrate * 4;
}
actual_baudrate = ftdi_convert_baudrate( baudrate, ftdi, &value, &index );
if ( actual_baudrate <= 0 )
ftdi_error_return( -1, "Silly baudrate <= 0." );
// 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_return( -1,
"Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4" );
if ( usb_control_msg( ftdi->usb_dev, 0x40, 3, value, index, NULL, 0,
ftdi->usb_write_timeout ) != 0 )
ftdi_error_return( -2, "Setting new baudrate failed" );
ftdi->baudrate = baudrate;
return 0;
}
/*
ftdi_set_line_property
set (RS232) line characteristics by Alain Abbas
Return codes:
0: all fine
-1: Setting line property failed
*/
int ftdi_set_line_property( struct ftdi_context *ftdi, enum ftdi_bits_type bits,
enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity )
{
unsigned short value = bits;
switch ( parity )
{
case NONE:
value |= ( 0x00 << 8 );
break;
case ODD:
value |= ( 0x01 << 8 );
break;
case EVEN:
value |= ( 0x02 << 8 );
break;
case MARK:
value |= ( 0x03 << 8 );
break;
case SPACE:
value |= ( 0x04 << 8 );
break;
}
switch ( sbit )
{
case STOP_BIT_1:
value |= ( 0x00 << 11 );
break;
case STOP_BIT_15:
value |= ( 0x01 << 11 );
break;
case STOP_BIT_2:
value |= ( 0x02 << 11 );
break;
}
if ( usb_control_msg( ftdi->usb_dev, 0x40, 0x04, value, ftdi->index, NULL, 0,
ftdi->usb_write_timeout ) != 0 )
ftdi_error_return( -1, "Setting new line property failed" );
return 0;
}
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 = ftdi->writebuffer_chunksize;
if ( offset + write_size > 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 < 0 )
ftdi_error_return( ret, "usb bulk write failed" );
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, 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 )
{
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 < 0 )
ftdi_error_return( ret, "usb bulk read failed" );
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 > 62 )
{
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;
}
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 )
//printf("read_data exact rem %d offset %d\n",
//ftdi->readbuffer_remaining, offset);
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 -127;
}
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;
if ( ( new_buf = (unsigned char *) realloc( ftdi->readbuffer, chunksize ) )
== NULL )
ftdi_error_return( -1, "out of memory for readbuffer" );
ftdi->readbuffer = new_buf;
ftdi->readbuffer_chunksize = chunksize;
return 0;
}
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 )
{
unsigned short usb_val;
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_return( -1,
"unable to enter bitbang mode. Perhaps not a BM type chip?" );
ftdi->bitbang_enabled = 1;
return 0;
}
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_return( -1,
"unable to leave bitbang mode. Perhaps not a BM type chip?" );
ftdi->bitbang_enabled = 0;
return 0;
}
int ftdi_set_bitmode( struct ftdi_context *ftdi, unsigned char bitmask,
unsigned char mode )
{
unsigned short usb_val;
usb_val = bitmask; // low byte: bitmask
usb_val |= ( mode << 8 );
if ( usb_control_msg( ftdi->usb_dev, 0x40, 0x0B, usb_val, ftdi->index, NULL,
0, ftdi->usb_write_timeout ) != 0 )
ftdi_error_return( -1,
"unable to configure bitbang mode. Perhaps not a 2232C type chip?" );
ftdi->bitbang_mode = mode;
ftdi->bitbang_enabled =
( mode == BITMODE_BITBANG || mode == BITMODE_SYNCBB ) ? 1 : 0;
return 0;
}
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_return( -1, "read pins failed" );
*pins = (unsigned char) usb_val;
return 0;
}
int ftdi_set_latency_timer( struct ftdi_context *ftdi, unsigned char latency )
{
unsigned short usb_val;
if ( latency < 1 )
ftdi_error_return( -1, "latency out of range. Only valid for 1-255" );
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_return( -2, "unable to set latency timer" );
return 0;
}
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_return( -1, "reading latency timer failed" );
*latency = (unsigned char) usb_val;
return 0;
}
void ftdi_eeprom_initdefaults( struct ftdi_eeprom *eeprom )
{
eeprom->vendor_id = 0x0403;
eeprom->product_id = 0x6001;
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 = 0x0200;
eeprom->max_power = 0;
eeprom->manufacturer = NULL;
eeprom->product = NULL;
eeprom->serial = NULL;
}
/*
ftdi_eeprom_build
Build binary output from ftdi_eeprom structure.
Output is suitable for ftdi_write_eeprom.
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_read_timeout ) != 2 )
ftdi_error_return( -1, "reading eeprom failed" );
}
return 0;
}
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_write_timeout ) != 0 )
ftdi_error_return( -1, "unable to write eeprom" );
}
return 0;
}
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_return( -1, "unable to erase eeprom" );
return 0;
}
char *ftdi_get_error_string( struct ftdi_context *ftdi )
{
return ftdi->error_str;
}
int ftdi_setflowctrl( struct ftdi_context *ftdi, int flowctrl )
{
if ( usb_control_msg( ftdi->usb_dev, SIO_SET_FLOW_CTRL_REQUEST_TYPE,
SIO_SET_FLOW_CTRL_REQUEST, 0, ( flowctrl | ftdi->interface ), NULL, 0,
ftdi->usb_write_timeout ) != 0 )
ftdi_error_return( -1, "set flow control failed" );
return 0;
}
int ftdi_setdtr( struct ftdi_context *ftdi, int state )
{
unsigned short usb_val;
if ( state )
usb_val = SIO_SET_DTR_HIGH;
else
usb_val = SIO_SET_DTR_LOW;
if ( usb_control_msg( ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE,
SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->interface, NULL, 0,
ftdi->usb_write_timeout ) != 0 )
ftdi_error_return( -1, "set dtr failed" );
return 0;
}
int ftdi_setrts( struct ftdi_context *ftdi, int state )
{
unsigned short usb_val;
if ( state )
usb_val = SIO_SET_RTS_HIGH;
else
usb_val = SIO_SET_RTS_LOW;
if ( usb_control_msg( ftdi->usb_dev, SIO_SET_MODEM_CTRL_REQUEST_TYPE,
SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->interface, NULL, 0,
ftdi->usb_write_timeout ) != 0 )
ftdi_error_return( -1, "set of rts failed" );
return 0;
}
