/*************************************************************************** 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; }