X-Git-Url: http://developer.intra2net.com/git/?p=libftdi;a=blobdiff_plain;f=src%2Fftdi.c;h=3c86456c3c6398b361f1cf34bc7086363fceee7d;hp=8650be25da1da8b0230c9e3aca830f0e3a865eaf;hb=74387f27647e7123e233d31d36daedc6b485650a;hpb=be4bae37b3f851d7e06610fe474d84a3b2371efb diff --git a/src/ftdi.c b/src/ftdi.c index 8650be2..3c86456 100644 --- a/src/ftdi.c +++ b/src/ftdi.c @@ -2,7 +2,7 @@ ftdi.c - description ------------------- begin : Fri Apr 4 2003 - copyright : (C) 2003-2011 by Intra2net AG and the libftdi developers + copyright : (C) 2003-2013 by Intra2net AG and the libftdi developers email : opensource@intra2net.com ***************************************************************************/ @@ -39,7 +39,10 @@ #include "ftdi_version_i.h" #define ftdi_error_return(code, str) do { \ - ftdi->error_str = str; \ + if ( ftdi ) \ + ftdi->error_str = str; \ + else \ + fprintf(stderr, str); \ return code; \ } while(0); @@ -292,7 +295,7 @@ struct ftdi_version_info ftdi_get_library_version() Finds all ftdi devices with given VID:PID on the usb bus. Creates a new ftdi_device_list which needs to be deallocated by ftdi_list_free() after use. With VID:PID 0:0, search for the default devices - (0x403:0x6001, 0x403:0x6010, 0x403:0x6011, 0x403:0x6014) + (0x403:0x6001, 0x403:0x6010, 0x403:0x6011, 0x403:0x6014) \param ftdi pointer to ftdi_context \param devlist Pointer where to store list of found devices @@ -325,11 +328,11 @@ int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devli if (libusb_get_device_descriptor(dev, &desc) < 0) ftdi_error_return_free_device_list(-6, "libusb_get_device_descriptor() failed", devs); - if (((vendor != 0 && product != 0) && - desc.idVendor == vendor && desc.idProduct == product) || - ((vendor == 0 && product == 0) && - (desc.idVendor == 0x403) && (desc.idProduct == 0x6001 || desc.idProduct == 0x6010 - || desc.idProduct == 0x6011 || desc.idProduct == 0x6014))) + if (((vendor != 0 && product != 0) && + desc.idVendor == vendor && desc.idProduct == product) || + ((vendor == 0 && product == 0) && + (desc.idVendor == 0x403) && (desc.idProduct == 0x6001 || desc.idProduct == 0x6010 + || desc.idProduct == 0x6011 || desc.idProduct == 0x6014))) { *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list)); if (!*curdev) @@ -467,7 +470,7 @@ static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, l // Determine maximum packet size. Init with default value. // New hi-speed devices from FTDI use a packet size of 512 bytes // but could be connected to a normal speed USB hub -> 64 bytes packet size. - if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H ) + if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H || ftdi->type == TYPE_230X) packet_size = 512; else packet_size = 64; @@ -605,6 +608,8 @@ int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev) ftdi->type = TYPE_4232H; else if (desc.bcdDevice == 0x900) ftdi->type = TYPE_232H; + else if (desc.bcdDevice == 0x1000) + ftdi->type = TYPE_230X; // Determine maximum packet size ftdi->max_packet_size = _ftdi_determine_max_packet_size(ftdi, dev); @@ -994,7 +999,7 @@ int ftdi_usb_close(struct ftdi_context *ftdi) return rtn; } -/* ftdi_to_clkbits_AM For the AM device, convert a requested baudrate +/* ftdi_to_clkbits_AM For the AM device, convert a requested baudrate to encoded divisor and the achievable baudrate Function is only used internally \internal @@ -1106,7 +1111,7 @@ static int ftdi_to_clkbits_AM(int baudrate, unsigned long *encoded_divisor) H Type have all features above with {index[8],value[15:14]} is the encoded subdivisor - FT232R, FT2232 and FT232BM have no option for 12 MHz and with + FT232R, FT2232 and FT232BM have no option for 12 MHz and with {index[0],value[15:14]} is the encoded subdivisor AM Type chips have only four fractional subdivisors at value[15:14] @@ -1150,7 +1155,7 @@ static int ftdi_to_clkbits(int baudrate, unsigned int clk, int clk_div, unsigned *encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 0x7] << 14); } return best_baud; -} +} /** ftdi_convert_baudrate returns nearest supported baud rate to that requested. Function is only used internally @@ -1170,12 +1175,12 @@ static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi, #define H_CLK 120000000 #define C_CLK 48000000 - if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H) || (ftdi->type == TYPE_232H )) + if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H) || (ftdi->type == TYPE_232H) || (ftdi->type == TYPE_230X)) { if(baudrate*10 > H_CLK /0x3fff) { /* On H Devices, use 12 000 000 Baudrate when possible - We have a 14 bit divisor, a 1 bit divisor switch (10 or 16) + We have a 14 bit divisor, a 1 bit divisor switch (10 or 16) three fractional bits and a 120 MHz clock Assume AN_120 "Sub-integer divisors between 0 and 2 are not allowed" holds for DIV/10 CLK too, so /1, /1.5 and /2 can be handled the same*/ @@ -1195,8 +1200,7 @@ static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi, } // Split into "value" and "index" values *value = (unsigned short)(encoded_divisor & 0xFFFF); - if (ftdi->type == TYPE_2232H || - ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H ) + if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H || ftdi->type == TYPE_230X) { *index = (unsigned short)(encoded_divisor >> 8); *index &= 0xFF00; @@ -1214,7 +1218,7 @@ static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi, * Do not use, it's only for the unit test framework **/ int convert_baudrate_UT_export(int baudrate, struct ftdi_context *ftdi, - unsigned short *value, unsigned short *index) + unsigned short *value, unsigned short *index) { return ftdi_convert_baudrate(baudrate, ftdi, value, index); } @@ -1539,7 +1543,7 @@ struct ftdi_transfer_control *ftdi_write_data_submit(struct ftdi_context *ftdi, tc->size = size; tc->offset = 0; - if (size < ftdi->writebuffer_chunksize) + if (size < (int)ftdi->writebuffer_chunksize) write_size = size; else write_size = ftdi->writebuffer_chunksize; @@ -1592,7 +1596,7 @@ struct ftdi_transfer_control *ftdi_read_data_submit(struct ftdi_context *ftdi, u tc->buf = buf; tc->size = size; - if (size <= ftdi->readbuffer_remaining) + if (size <= (int)ftdi->readbuffer_remaining) { memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size); @@ -1756,7 +1760,7 @@ int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) ftdi_error_return(-1, "max_packet_size is bogus (zero)"); // everything we want is still in the readbuffer? - if (size <= ftdi->readbuffer_remaining) + if (size <= (int)ftdi->readbuffer_remaining) { memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size); @@ -2312,8 +2316,11 @@ int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer, eeprom->product_id = 0x6011; else if (ftdi->type == TYPE_232H) eeprom->product_id = 0x6014; + else if (ftdi->type == TYPE_230X) + eeprom->product_id = 0x6015; else eeprom->product_id = 0x6010; + if (ftdi->type == TYPE_AM) eeprom->usb_version = 0x0101; else @@ -2344,15 +2351,16 @@ int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer, const char* default_product; switch(ftdi->type) { - case TYPE_AM: default_product = "AM"; break; - case TYPE_BM: default_product = "BM"; break; - case TYPE_2232C: default_product = "Dual RS232"; break; - case TYPE_R: default_product = "FT232R USB UART"; break; - case TYPE_2232H: default_product = "Dual RS232-HS"; break; - case TYPE_4232H: default_product = "FT4232H"; break; - case TYPE_232H: default_product = "Single-RS232-HS"; break; - default: - ftdi_error_return(-3, "Unknown chip type"); + case TYPE_AM: default_product = "AM"; break; + case TYPE_BM: default_product = "BM"; break; + case TYPE_2232C: default_product = "Dual RS232"; break; + case TYPE_R: default_product = "FT232R USB UART"; break; + case TYPE_2232H: default_product = "Dual RS232-HS"; break; + case TYPE_4232H: default_product = "FT4232H"; break; + case TYPE_232H: default_product = "Single-RS232-HS"; break; + case TYPE_230X: default_product = "FT230X Basic UART"; break; + default: + ftdi_error_return(-3, "Unknown chip type"); } eeprom->product = malloc(strlen(default_product) +1); if (eeprom->product) @@ -2379,6 +2387,15 @@ int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer, eeprom->cbus_function[3] = CBUS_PWREN; eeprom->cbus_function[4] = CBUS_SLEEP; } + else if (ftdi->type == TYPE_230X) + { + eeprom->max_power = 90; + eeprom->size = 0x100; + eeprom->cbus_function[0] = CBUSH_TXDEN; + eeprom->cbus_function[1] = CBUSH_RXLED; + eeprom->cbus_function[2] = CBUSH_TXLED; + eeprom->cbus_function[3] = CBUSH_SLEEP; + } else { if(ftdi->type == TYPE_232H) @@ -2389,14 +2406,92 @@ int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer, } eeprom->size = -1; } - eeprom->initialized_for_connected_device = 1; + switch (ftdi->type) + { + case TYPE_AM: + eeprom->release_number = 0x0200; + break; + case TYPE_BM: + eeprom->release_number = 0x0400; + break; + case TYPE_2232C: + eeprom->release_number = 0x0500; + break; + case TYPE_R: + eeprom->release_number = 0x0600; + break; + case TYPE_2232H: + eeprom->release_number = 0x0700; + break; + case TYPE_4232H: + eeprom->release_number = 0x0800; + break; + case TYPE_232H: + eeprom->release_number = 0x0900; + break; + case TYPE_230X: + eeprom->release_number = 0x1000; + break; + default: + eeprom->release_number = 0x00; + } return 0; } + +int ftdi_eeprom_set_strings(struct ftdi_context *ftdi, char * manufacturer, + char * product, char * serial) +{ + struct ftdi_eeprom *eeprom; + + if (ftdi == NULL) + ftdi_error_return(-1, "No struct ftdi_context"); + + if (ftdi->eeprom == NULL) + ftdi_error_return(-2,"No struct ftdi_eeprom"); + + eeprom = ftdi->eeprom; + + if (ftdi->usb_dev == NULL) + ftdi_error_return(-3, "No connected device or device not yet opened"); + + if (manufacturer) + { + if (eeprom->manufacturer) + free (eeprom->manufacturer); + eeprom->manufacturer = malloc(strlen(manufacturer)+1); + if (eeprom->manufacturer) + strcpy(eeprom->manufacturer, manufacturer); + } + + if(product) + { + if (eeprom->product) + free (eeprom->product); + eeprom->product = malloc(strlen(product)+1); + if (eeprom->product) + strcpy(eeprom->product, product); + } + + if (serial) + { + if (eeprom->serial) + free (eeprom->serial); + eeprom->serial = malloc(strlen(serial)+1); + if (eeprom->serial) + { + strcpy(eeprom->serial, serial); + eeprom->use_serial = 1; + } + } + return 0; +} + + /*FTD2XX doesn't check for values not fitting in the ACBUS Signal oprtions*/ void set_ft232h_cbus(struct ftdi_eeprom *eeprom, unsigned char * output) { int i; - for(i=0; i<5;i++) + for(i=0; i<5; i++) { int mode_low, mode_high; if (eeprom->cbus_function[2*i]> CBUSH_CLK7_5) @@ -2406,9 +2501,9 @@ void set_ft232h_cbus(struct ftdi_eeprom *eeprom, unsigned char * output) if (eeprom->cbus_function[2*i+1]> CBUSH_CLK7_5) mode_high = CBUSH_TRISTATE; else - mode_high = eeprom->cbus_function[2*i]; + mode_high = eeprom->cbus_function[2*i+1]; - output[0x18+i] = mode_high <<4 | mode_low; + output[0x18+i] = (mode_high <<4) | mode_low; } } /* Return the bits for the encoded EEPROM Structure of a requested Mode @@ -2418,34 +2513,35 @@ static unsigned char type2bit(unsigned char type, enum ftdi_chip_type chip) { switch (chip) { - case TYPE_2232H: - case TYPE_2232C: - { - switch (type) + case TYPE_2232H: + case TYPE_2232C: { - case CHANNEL_IS_UART: return 0; - case CHANNEL_IS_FIFO: return 0x01; - case CHANNEL_IS_OPTO: return 0x02; - case CHANNEL_IS_CPU : return 0x04; - default: return 0; + switch (type) + { + case CHANNEL_IS_UART: return 0; + case CHANNEL_IS_FIFO: return 0x01; + case CHANNEL_IS_OPTO: return 0x02; + case CHANNEL_IS_CPU : return 0x04; + default: return 0; + } } - } - case TYPE_232H: - { - switch (type) + case TYPE_232H: { - case CHANNEL_IS_UART : return 0; - case CHANNEL_IS_FIFO : return 0x01; - case CHANNEL_IS_OPTO : return 0x02; - case CHANNEL_IS_CPU : return 0x04; - case CHANNEL_IS_FT1284 : return 0x08; - default: return 0; + switch (type) + { + case CHANNEL_IS_UART : return 0; + case CHANNEL_IS_FIFO : return 0x01; + case CHANNEL_IS_OPTO : return 0x02; + case CHANNEL_IS_CPU : return 0x04; + case CHANNEL_IS_FT1284 : return 0x08; + default: return 0; + } } - } - default: return 0; + case TYPE_230X: /* FT230X is only UART */ + default: return 0; } return 0; -} +} /** Build binary buffer from ftdi_eeprom structure. @@ -2481,10 +2577,13 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) if (eeprom->chip == -1) ftdi_error_return(-6,"No connected EEPROM or EEPROM type unknown"); - if ((eeprom->chip == 0x56) || (eeprom->chip == 0x66)) - eeprom->size = 0x100; - else - eeprom->size = 0x80; + if (eeprom->size == -1) + { + if ((eeprom->chip == 0x56) || (eeprom->chip == 0x66)) + eeprom->size = 0x100; + else + eeprom->size = 0x80; + } if (eeprom->manufacturer != NULL) manufacturer_size = strlen(eeprom->manufacturer); @@ -2504,6 +2603,7 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) user_area_size = 90; // two extra config bytes and 4 bytes PnP stuff break; case TYPE_R: + case TYPE_230X: user_area_size = 88; // four extra config bytes + 4 bytes PnP stuff break; case TYPE_2232H: // six extra config bytes + 4 bytes PnP stuff @@ -2523,7 +2623,17 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) ftdi_error_return(-1,"eeprom size exceeded"); // empty eeprom - memset (ftdi->eeprom->buf, 0, FTDI_MAX_EEPROM_SIZE); + if (ftdi->type == TYPE_230X) + { + /* FT230X have a reserved section in the middle of the MTP, + which cannot be written to, but must be included in the checksum */ + memset(ftdi->eeprom->buf, 0, 0x80); + memset((ftdi->eeprom->buf + 0xa0), 0, (FTDI_MAX_EEPROM_SIZE - 0xa0)); + } + else + { + memset(ftdi->eeprom->buf, 0, FTDI_MAX_EEPROM_SIZE); + } // Bytes and Bits set for all Types @@ -2536,33 +2646,8 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) output[0x05] = eeprom->product_id >> 8; // Addr 06: Device release number (0400h for BM features) - output[0x06] = 0x00; - switch (ftdi->type) - { - case TYPE_AM: - output[0x07] = 0x02; - break; - case TYPE_BM: - output[0x07] = 0x04; - break; - case TYPE_2232C: - output[0x07] = 0x05; - break; - case TYPE_R: - output[0x07] = 0x06; - break; - case TYPE_2232H: - output[0x07] = 0x07; - break; - case TYPE_4232H: - output[0x07] = 0x08; - break; - case TYPE_232H: - output[0x07] = 0x09; - break; - default: - output[0x07] = 0x00; - } + output[0x06] = eeprom->release_number; + output[0x07] = eeprom->release_number >> 8; // Addr 08: Config descriptor // Bit 7: always 1 @@ -2570,16 +2655,16 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) // Bit 5: 1 if this device uses remote wakeup // Bit 4-0: reserved - 0 j = 0x80; - if (eeprom->self_powered == 1) + if (eeprom->self_powered) j |= 0x40; - if (eeprom->remote_wakeup == 1) + if (eeprom->remote_wakeup) j |= 0x20; output[0x08] = j; // Addr 09: Max power consumption: max power = value * 2 mA - output[0x09] = eeprom->max_power>>1; + output[0x09] = eeprom->max_power / MAX_POWER_MILLIAMP_PER_UNIT; - if (ftdi->type != TYPE_AM) + if ((ftdi->type != TYPE_AM) && (ftdi->type != TYPE_230X)) { // Addr 0A: Chip configuration // Bit 7: 0 - reserved @@ -2592,9 +2677,9 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) // Bit 0: 1 - In EndPoint is Isochronous // j = 0; - if (eeprom->in_is_isochronous == 1) + if (eeprom->in_is_isochronous) j = j | 1; - if (eeprom->out_is_isochronous == 1) + if (eeprom->out_is_isochronous) j = j | 2; output[0x0A] = j; } @@ -2618,6 +2703,10 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) case TYPE_AM: case TYPE_BM: i += 0x94; + break; + case TYPE_230X: + i = 0xa0; + break; } /* Wrap around 0x80 for 128 byte EEPROMS (Internale and 93x46) */ eeprom_size_mask = eeprom->size -1; @@ -2718,15 +2807,15 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) else output[0x01] &= ~HIGH_CURRENT_DRIVE; - if (eeprom->in_is_isochronous == 1) + if (eeprom->in_is_isochronous) output[0x0A] |= 0x1; else output[0x0A] &= ~0x1; - if (eeprom->out_is_isochronous == 1) + if (eeprom->out_is_isochronous) output[0x0A] |= 0x2; else output[0x0A] &= ~0x2; - if (eeprom->suspend_pull_downs == 1) + if (eeprom->suspend_pull_downs) output[0x0A] |= 0x4; else output[0x0A] &= ~0x4; @@ -2744,7 +2833,7 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) output[0x00] |= HIGH_CURRENT_DRIVE_R; output[0x01] = 0x40; /* Hard coded Endpoint Size*/ - if (eeprom->suspend_pull_downs == 1) + if (eeprom->suspend_pull_downs) output[0x0A] |= 0x4; else output[0x0A] &= ~0x4; @@ -2794,7 +2883,7 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) else output[0x01] &= ~SUSPEND_DBUS7_BIT; - if (eeprom->suspend_pull_downs == 1) + if (eeprom->suspend_pull_downs) output[0x0A] |= 0x4; else output[0x0A] &= ~0x4; @@ -2856,7 +2945,7 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) else output[0x01] &= ~(DRIVER_VCP << 4); - if (eeprom->suspend_pull_downs == 1) + if (eeprom->suspend_pull_downs) output[0x0a] |= 0x4; else output[0x0a] &= ~0x4; @@ -2962,7 +3051,15 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) output[0x1e] = eeprom->chip; fprintf(stderr,"FIXME: Build FT232H specific EEPROM settings\n"); break; - + case TYPE_230X: + output[0x00] = 0x80; /* Actually, leave the default value */ + output[0x0a] = 0x08; /* Enable USB Serial Number */ + output[0x0c] = (0x01) | (0x3 << 4); /* DBUS drive 4mA, CBUS drive 16mA */ + for (j = 0; j <= 6; j++) + { + output[0x1a + j] = eeprom->cbus_function[j]; + } + break; } // calculate checksum @@ -2970,6 +3067,11 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) for (i = 0; i < eeprom->size/2-1; i++) { + if ((ftdi->type == TYPE_230X) && (i == 0x12)) + { + /* FT230X has a user section in the MTP which is not part of the checksum */ + i = 0x40; + } value = output[i*2]; value += output[(i*2)+1] << 8; @@ -2980,9 +3082,10 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi) output[eeprom->size-2] = checksum; output[eeprom->size-1] = checksum >> 8; + eeprom->initialized_for_connected_device = 1; return user_area_size; } -/* Decode the encoded EEPROM field for the FTDI Mode into a value for the abstracted +/* Decode the encoded EEPROM field for the FTDI Mode into a value for the abstracted * EEPROM structure * * FTD2XX doesn't allow to set multiple bits in the interface mode bitfield, and so do we @@ -2991,14 +3094,14 @@ static unsigned char bit2type(unsigned char bits) { switch (bits) { - case 0: return CHANNEL_IS_UART; - case 1: return CHANNEL_IS_FIFO; - case 2: return CHANNEL_IS_OPTO; - case 4: return CHANNEL_IS_CPU; - case 8: return CHANNEL_IS_FT1284; - default: - fprintf(stderr," Unexpected value %d for Hardware Interface type\n", - bits); + case 0: return CHANNEL_IS_UART; + case 1: return CHANNEL_IS_FIFO; + case 2: return CHANNEL_IS_OPTO; + case 4: return CHANNEL_IS_CPU; + case 8: return CHANNEL_IS_FT1284; + default: + fprintf(stderr," Unexpected value %d for Hardware Interface type\n", + bits); } return 0; } @@ -3021,8 +3124,7 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0; int eeprom_size; struct ftdi_eeprom *eeprom; - unsigned char *buf = ftdi->eeprom->buf; - int release; + unsigned char *buf = NULL; if (ftdi == NULL) ftdi_error_return(-1,"No context"); @@ -3031,6 +3133,7 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) eeprom = ftdi->eeprom; eeprom_size = eeprom->size; + buf = ftdi->eeprom->buf; // Addr 02: Vendor ID eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8); @@ -3038,7 +3141,8 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) // Addr 04: Product ID eeprom->product_id = buf[0x04] + (buf[0x05] << 8); - release = buf[0x06] + (buf[0x07]<<8); + // Addr 06: Device release number + eeprom->release_number = buf[0x06] + (buf[0x07]<<8); // Addr 08: Config descriptor // Bit 7: always 1 @@ -3048,7 +3152,7 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) eeprom->remote_wakeup = buf[0x08] & 0x20; // Addr 09: Max power consumption: max power = value * 2 mA - eeprom->max_power = buf[0x09]; + eeprom->max_power = MAX_POWER_MILLIAMP_PER_UNIT * buf[0x09]; // Addr 0A: Chip configuration // Bit 7: 0 - reserved @@ -3082,7 +3186,7 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) { // Decode manufacturer i = buf[0x0E] & (eeprom_size -1); // offset - for (j=0;jmanufacturer[j] = buf[2*j+i+2]; } @@ -3103,7 +3207,7 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) { // Decode product name i = buf[0x10] & (eeprom_size -1); // offset - for (j=0;jproduct[j] = buf[2*j+i+2]; } @@ -3124,7 +3228,7 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) { // Decode serial i = buf[0x12] & (eeprom_size -1); // offset - for (j=0;jserial[j] = buf[2*j+i+2]; } @@ -3138,6 +3242,11 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) for (i = 0; i < eeprom_size/2-1; i++) { + if ((ftdi->type == TYPE_230X) && (i == 0x12)) + { + /* FT230X has a user section in the MTP which is not part of the checksum */ + i = 0x40; + } value = buf[i*2]; value += buf[(i*2)+1] << 8; @@ -3253,18 +3362,31 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) eeprom->chip = buf[0x1e]; /*FIXME: Decipher more values*/ } + else if (ftdi->type == TYPE_230X) + { + for(i=0; i<4; i++) + { + eeprom->cbus_function[i] = buf[0x1a + i] & 0xFF; + } + eeprom->group0_drive = buf[0x0c] & 0x03; + eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT; + eeprom->group0_slew = buf[0x0c] & SLOW_SLEW; + eeprom->group1_drive = (buf[0x0c] >> 4) & 0x03; + eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT; + eeprom->group1_slew = (buf[0x0c] >> 4) & SLOW_SLEW; + } if (verbose) { char *channel_mode[] = {"UART", "FIFO", "CPU", "OPTO", "FT1284"}; fprintf(stdout, "VID: 0x%04x\n",eeprom->vendor_id); fprintf(stdout, "PID: 0x%04x\n",eeprom->product_id); - fprintf(stdout, "Release: 0x%04x\n",release); + fprintf(stdout, "Release: 0x%04x\n",eeprom->release_number); if (eeprom->self_powered) fprintf(stdout, "Self-Powered%s", (eeprom->remote_wakeup)?", USB Remote Wake Up\n":"\n"); else - fprintf(stdout, "Bus Powered: %3d mA%s", eeprom->max_power * 2, + fprintf(stdout, "Bus Powered: %3d mA%s", eeprom->max_power, (eeprom->remote_wakeup)?" USB Remote Wake Up\n":"\n"); if (eeprom->manufacturer) fprintf(stdout, "Manufacturer: %s\n",eeprom->manufacturer); @@ -3285,7 +3407,7 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) { if(ftdi->type >= TYPE_232H) fprintf(stdout,"Enter low power state on ACBUS7\n"); - } + } if (eeprom->remote_wakeup) fprintf(stdout, "Enable Remote Wake Up\n"); fprintf(stdout, "PNP: %d\n",(eeprom->is_not_pnp)?0:1); @@ -3300,7 +3422,7 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) (eeprom->clock_polarity)?"HIGH":"LOW", (eeprom->data_order)?"LSB":"MSB", (eeprom->flow_control)?"":"No "); - } + } if ((ftdi->type >= TYPE_2232C) && (ftdi->type != TYPE_R) && (ftdi->type != TYPE_232H)) fprintf(stdout,"Channel B has Mode %s%s%s\n", channel_mode[eeprom->channel_b_type], @@ -3337,9 +3459,9 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) { int i; char *cbush_mux[] = {"TRISTATE","RXLED","TXLED", "TXRXLED","PWREN", - "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN", - "CLK30","CLK15","CLK7_5" - }; + "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN", + "CLK30","CLK15","CLK7_5" + }; fprintf(stdout,"ACBUS has %d mA drive%s%s\n", (eeprom->group0_drive+1) *4, (eeprom->group0_schmitt)?" Schmitt Input":"", @@ -3355,6 +3477,29 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose) cbush_mux[eeprom->cbus_function[i]]); } } + else if (ftdi->type == TYPE_230X) + { + int i; + char *cbush_mux[] = {"TRISTATE","RXLED","TXLED", "TXRXLED","PWREN", + "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN", + "CLK24","CLK12","CLK6","BAT_DETECT","BAT_DETECT#", + "I2C_TXE#", "I2C_RXF#", "VBUS_SENSE", "BB_WR#", + "BBRD#", "TIME_STAMP", "AWAKE#", + }; + fprintf(stdout,"IOBUS has %d mA drive%s%s\n", + (eeprom->group0_drive+1) *4, + (eeprom->group0_schmitt)?" Schmitt Input":"", + (eeprom->group0_slew)?" Slow Slew":""); + fprintf(stdout,"CBUS has %d mA drive%s%s\n", + (eeprom->group1_drive+1) *4, + (eeprom->group1_schmitt)?" Schmitt Input":"", + (eeprom->group1_slew)?" Slow Slew":""); + for (i=0; i<4; i++) + { + if (eeprom->cbus_function[i]<= CBUSH_AWAKE) + fprintf(stdout,"CBUS%d Function: %s\n", i, cbush_mux[eeprom->cbus_function[i]]); + } + } if (ftdi->type == TYPE_R) { @@ -3414,6 +3559,9 @@ int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value valu case PRODUCT_ID: *value = ftdi->eeprom->product_id; break; + case RELEASE_NUMBER: + *value = ftdi->eeprom->release_number; + break; case SELF_POWERED: *value = ftdi->eeprom->self_powered; break; @@ -3555,19 +3703,19 @@ int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value valu case GROUP3_SLEW: *value = ftdi->eeprom->group3_slew; break; - case POWER_SAVE: + case POWER_SAVE: *value = ftdi->eeprom->powersave; break; - case CLOCK_POLARITY: + case CLOCK_POLARITY: *value = ftdi->eeprom->clock_polarity; break; - case DATA_ORDER: + case DATA_ORDER: *value = ftdi->eeprom->data_order; break; - case FLOW_CONTROL: + case FLOW_CONTROL: *value = ftdi->eeprom->flow_control; break; - case CHIP_TYPE: + case CHIP_TYPE: *value = ftdi->eeprom->chip; break; case CHIP_SIZE: @@ -3601,6 +3749,9 @@ int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value valu case PRODUCT_ID: ftdi->eeprom->product_id = value; break; + case RELEASE_NUMBER: + ftdi->eeprom->release_number = value; + break; case SELF_POWERED: ftdi->eeprom->self_powered = value; break; @@ -3745,16 +3896,16 @@ int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value valu case CHIP_TYPE: ftdi->eeprom->chip = value; break; - case POWER_SAVE: + case POWER_SAVE: ftdi->eeprom->powersave = value; break; - case CLOCK_POLARITY: + case CLOCK_POLARITY: ftdi->eeprom->clock_polarity = value; break; - case DATA_ORDER: + case DATA_ORDER: ftdi->eeprom->data_order = value; break; - case FLOW_CONTROL: + case FLOW_CONTROL: ftdi->eeprom->flow_control = value; break; case CHIP_SIZE: @@ -3762,6 +3913,7 @@ int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value valu default : ftdi_error_return(-1, "Request to unknown EEPROM value"); } + ftdi->eeprom->initialized_for_connected_device = 0; return 0; } @@ -4023,6 +4175,11 @@ int ftdi_write_eeprom(struct ftdi_context *ftdi) for (i = 0; i < ftdi->eeprom->size/2; i++) { + /* Do not try to write to reserved area */ + if ((ftdi->type == TYPE_230X) && (i == 0x40)) + { + i = 0x50; + } usb_val = eeprom[i*2]; usb_val += eeprom[(i*2)+1] << 8; if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,