X-Git-Url: http://developer.intra2net.com/git/?p=libftdi;a=blobdiff_plain;f=src%2Fftdi.c;h=297fa28a908b05bd91fb4965ff73a11accccbc9e;hp=81fd2d5bfd327ca2a4d02f32c97333c4daec78a5;hb=38801bf8af278a43149862ab7a07128f8c4d5aab;hpb=065edc587bed136ef4a1cca5980f116c69e9ae00 diff --git a/src/ftdi.c b/src/ftdi.c index 81fd2d5..297fa28 100644 --- a/src/ftdi.c +++ b/src/ftdi.c @@ -2186,34 +2186,29 @@ void ftdi_eeprom_initdefaults(struct ftdi_context *ftdi) return; eeprom = ftdi->eeprom; + memset(eeprom, 0, sizeof(struct ftdi_eeprom)); eeprom->vendor_id = 0x0403; - eeprom->product_id = 0x6001; - - eeprom->self_powered = 1; - eeprom->remote_wakeup = 1; - eeprom->release = 0; - - 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->use_serial = USE_SERIAL_NUM; + if((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM) || + (ftdi->type == TYPE_R)) + eeprom->product_id = 0x6001; + else + eeprom->product_id = 0x6010; + if (ftdi->type == TYPE_AM) + eeprom->usb_version = 0x0101; + else + eeprom->usb_version = 0x0200; + eeprom->max_power = 50; eeprom->manufacturer = NULL; eeprom->product = NULL; eeprom->serial = NULL; - for (i=0; i < 5; i++) - { - eeprom->cbus_function[i] = 0; - } - eeprom->high_current = 0; - eeprom->invert = 0; - eeprom->size = FTDI_MAX_EEPROM_SIZE; + if(ftdi->type == TYPE_R) + eeprom->size = 0x80; + else + eeprom->size = -1; } /** @@ -2258,14 +2253,14 @@ void ftdi_eeprom_free(struct ftdi_context *ftdi) \retval -3: Invalid cbus function setting \retval -4: Chip doesn't support invert \retval -5: Chip doesn't support high current drive + \retval -6: No connected EEPROM or EEPROM Type unknown */ int ftdi_eeprom_build(struct ftdi_context *ftdi, unsigned char *output) { - unsigned char i, j; + unsigned char i, j, k; unsigned short checksum, value; unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0; int size_check; - const int cbus_max[5] = {13, 13, 13, 13, 9}; struct ftdi_eeprom *eeprom; if (ftdi == NULL) @@ -2275,6 +2270,14 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi, unsigned char *output) eeprom= ftdi->eeprom; + if(eeprom->chip == -1) + ftdi_error_return(-5,"No connected EEPROM or EEPROM Type unknown"); + + if ((eeprom->chip == 0x56) || (eeprom->chip == 0x66)) + eeprom->size = 0x100; + else + eeprom->size = 0x80; + if (eeprom->manufacturer != NULL) manufacturer_size = strlen(eeprom->manufacturer); if (eeprom->product != NULL) @@ -2282,30 +2285,28 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi, unsigned char *output) if (eeprom->serial != NULL) serial_size = strlen(eeprom->serial); - // highest allowed cbus value - for (i = 0; i < 5; i++) - { - if ((eeprom->cbus_function[i] > cbus_max[i]) || - (eeprom->cbus_function[i] && ftdi->type != TYPE_R)) return -3; - } - if (ftdi->type != TYPE_R) + size_check = 0x80; + switch(ftdi->type) { - if (eeprom->invert) return -4; - if (eeprom->high_current) return -5; + case TYPE_2232H: + case TYPE_4232H: + size_check -= 4; + case TYPE_R: + size_check -= 4; + case TYPE_2232C: + size_check -= 4; + case TYPE_AM: + case TYPE_BM: + size_check -= 0x14*2; } - size_check = eeprom->size; - size_check -= 28; // 28 are always in use (fixed) - - // Top half of a 256byte eeprom is used just for strings and checksum - // it seems that the FTDI chip will not read these strings from the lower half - // Each string starts with two bytes; offset and type (0x03 for string) - // the checksum needs two bytes, so without the string data that 8 bytes from the top half - if (eeprom->size>=256) size_check = 120; size_check -= manufacturer_size*2; size_check -= product_size*2; size_check -= serial_size*2; + /* Space for the string type and pointer bytes */ + size_check -= -6; + // eeprom size exceeded? if (size_check < 0) return (-1); @@ -2313,12 +2314,8 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi, unsigned char *output) // empty eeprom memset (output, 0, eeprom->size); - // Addr 00: High current IO - output[0x00] = eeprom->high_current ? HIGH_CURRENT_DRIVE : 0; - // Addr 01: IN endpoint size (for R type devices, different for FT2232) - if (ftdi->type == TYPE_R) { - output[0x01] = 0x40; - } + // Bytes and Bits set for all Types + // Addr 02: Vendor ID output[0x02] = eeprom->vendor_id; output[0x03] = eeprom->vendor_id >> 8; @@ -2329,7 +2326,7 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi, unsigned char *output) // Addr 06: Device release number (0400h for BM features) output[0x06] = 0x00; - switch (eeprom->release) { + switch (ftdi->type) { case TYPE_AM: output[0x07] = 0x02; break; @@ -2342,6 +2339,12 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi, unsigned char *output) case TYPE_R: output[0x07] = 0x06; break; + case TYPE_2232H: + output[0x07] = 0x07; + break; + case TYPE_4232H: + output[0x07] = 0x08; + break; default: output[0x07] = 0x00; } @@ -2361,100 +2364,243 @@ int ftdi_eeprom_build(struct ftdi_context *ftdi, unsigned char *output) // 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: Invert data lines - output[0x0B] = eeprom->invert & 0xff; + if(ftdi->type != TYPE_AM) + { + // 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; + output[0x0A] = j; + } - // 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) + // Dynamic content + // Strings start at 0x94 (TYPE_AM, TYPE_BM) + // 0x96 (TYPE_2232C), 0x98 (TYPE_R) and 0x9a (TYPE_x232H) + i = 0; + switch(ftdi->type) { - output[0x0C] = eeprom->usb_version; - output[0x0D] = eeprom->usb_version >> 8; + case TYPE_2232H: + case TYPE_4232H: + i += 2; + case TYPE_R: + i += 2; + case TYPE_2232C: + i += 2; + case TYPE_AM: + case TYPE_BM: + i += 0x94; } - + /* Wrap around 0x80 for 128 byte EEPROMS (Internale and 93x46) */ + k = eeprom->size -1; // Addr 0E: Offset of the manufacturer string + 0x80, calculated later // Addr 0F: Length of manufacturer string + // Output manufacturer + output[0x0E] = i; // calculate offset + output[i++ & k] = manufacturer_size*2 + 2; + output[i++ & k] = 0x03; // type: string + for (j = 0; j < manufacturer_size; j++) + { + output[i & k] = eeprom->manufacturer[j], i++; + output[i & k] = 0x00, i++; + } output[0x0F] = manufacturer_size*2 + 2; // Addr 10: Offset of the product string + 0x80, calculated later // Addr 11: Length of product string + output[0x10] = i | 0x80; // calculate offset + output[i & k] = product_size*2 + 2, i++; + output[i & k] = 0x03, i++; + for (j = 0; j < product_size; j++) + { + output[i & k] = eeprom->product[j], i++; + output[i & k] = 0x00, i++; + } output[0x11] = product_size*2 + 2; - + // Addr 12: Offset of the serial string + 0x80, calculated later // Addr 13: Length of serial string + output[0x12] = i | 0x80; // calculate offset + output[i & k] = serial_size*2 + 2, i++; + output[i & k] = 0x03, i++; + for (j = 0; j < serial_size; j++) + { + output[i & k] = eeprom->serial[j], i++; + output[i & k] = 0x00, i++; + } output[0x13] = serial_size*2 + 2; - // Addr 14: CBUS function: CBUS0, CBUS1 - // Addr 15: CBUS function: CBUS2, CBUS3 - // Addr 16: CBUS function: CBUS5 - output[0x14] = eeprom->cbus_function[0] | (eeprom->cbus_function[1] << 4); - output[0x15] = eeprom->cbus_function[2] | (eeprom->cbus_function[3] << 4); - output[0x16] = eeprom->cbus_function[4]; - // Addr 17: Unknown + /* Fixme: ftd2xx seems to append 0x02, 0x03 and 0x01 for PnP = 0 or 0x00 else */ + // calculate checksum - // Dynamic content - // In images produced by FTDI's FT_Prog for FT232R strings start at 0x18 - // Space till 0x18 should be considered as reserved. - if (ftdi->type >= TYPE_R) { - i = 0x18; - } else { - i = 0x14; - } - if (eeprom->size >= 256) i = 0x80; + /* Bytes and Bits specific to (some) types + Write linear, as this allows easier fixing*/ + switch(ftdi->type) + { + case TYPE_AM: + break; + case TYPE_BM: + output[0x0C] = eeprom->usb_version & 0xff; + output[0x0D] = (eeprom->usb_version>>8) & 0xff; + if (eeprom->use_serial == 1) + output[0x0A] |= 0x8; + else + output[0x0A] &= ~0x8; + output[0x14] = eeprom->chip; + break; + case TYPE_2232C: + + output[0x00] = (eeprom->channel_a_type); + if ( eeprom->channel_a_driver == DRIVER_VCP) + output[0x00] |= DRIVER_VCP; + else + output[0x00] &= ~DRIVER_VCP; + + if ( eeprom->high_current_a == HIGH_CURRENT_DRIVE) + output[0x00] |= HIGH_CURRENT_DRIVE; + else + output[0x00] &= ~HIGH_CURRENT_DRIVE; + output[0x01] = (eeprom->channel_b_type); + if ( eeprom->channel_b_driver == DRIVER_VCP) + output[0x01] |= DRIVER_VCP; + else + output[0x01] &= ~DRIVER_VCP; + + if ( eeprom->high_current_b == HIGH_CURRENT_DRIVE) + output[0x01] |= HIGH_CURRENT_DRIVE; + else + output[0x01] &= ~HIGH_CURRENT_DRIVE; - // Output manufacturer - output[0x0E] = i | 0x80; // calculate offset - output[i++] = manufacturer_size*2 + 2; - output[i++] = 0x03; // type: string - for (j = 0; j < manufacturer_size; j++) - { - output[i] = eeprom->manufacturer[j], i++; - output[i] = 0x00, i++; - } + if (eeprom->in_is_isochronous == 1) + output[0x0A] |= 0x1; + else + output[0x0A] &= ~0x1; + if (eeprom->out_is_isochronous == 1) + output[0x0A] |= 0x2; + else + output[0x0A] &= ~0x2; + if (eeprom->suspend_pull_downs == 1) + output[0x0A] |= 0x4; + else + output[0x0A] &= ~0x4; + if (eeprom->use_serial == USE_SERIAL_NUM ) + output[0x0A] |= USE_SERIAL_NUM; + else + output[0x0A] &= ~0x8; + output[0x0C] = eeprom->usb_version & 0xff; + output[0x0D] = (eeprom->usb_version>>8) & 0xff; + output[0x14] = eeprom->chip; + break; + case TYPE_R: + if(eeprom->high_current == HIGH_CURRENT_DRIVE_R) + output[0x00] |= HIGH_CURRENT_DRIVE_R; + output[0x01] = 0x40; /* Hard coded Endpoint Size*/ + + if (eeprom->suspend_pull_downs == 1) + output[0x0A] |= 0x4; + else + output[0x0A] &= ~0x4; + if (eeprom->use_serial == USE_SERIAL_NUM) + output[0x0A] |= USE_SERIAL_NUM; + else + output[0x0A] &= ~0x8; + output[0x0B] = eeprom->invert; + output[0x0C] = eeprom->usb_version & 0xff; + output[0x0D] = (eeprom->usb_version>>8) & 0xff; + + if(eeprom->cbus_function[0] > CBUS_BB) + output[0x14] = CBUS_BB; + else + output[0x14] = eeprom->cbus_function[0]; + + if(eeprom->cbus_function[1] > CBUS_BB) + output[0x14] |= CBUS_BB<<4; + else + output[0x14] |= eeprom->cbus_function[1]; + + if(eeprom->cbus_function[2] > CBUS_BB) + output[0x15] |= CBUS_BB<<4; + else + output[0x15] |= eeprom->cbus_function[2]; + + if(eeprom->cbus_function[3] > CBUS_BB) + output[0x15] |= CBUS_BB<<4; + else + output[0x15] |= eeprom->cbus_function[3]; + + if(eeprom->cbus_function[5] > CBUS_BB) + output[0x16] = CBUS_BB; + else + output[0x16] = eeprom->cbus_function[0]; + break; + case TYPE_2232H: + output[0x00] = (eeprom->channel_a_type); + if ( eeprom->channel_a_driver == DRIVER_VCP) + output[0x00] |= DRIVER_VCP; + else + output[0x00] &= ~DRIVER_VCP; + + output[0x01] = (eeprom->channel_b_type); + if ( eeprom->channel_b_driver == DRIVER_VCP) + output[0x01] |= DRIVER_VCP; + else + output[0x01] &= ~DRIVER_VCP; + if(eeprom->suspend_dbus7 == SUSPEND_DBUS7) + output[0x01] |= SUSPEND_DBUS7; + else + output[0x01] &= ~SUSPEND_DBUS7; + + if(eeprom->group0_drive > DRIVE_16MA) + output[0x0c] |= DRIVE_16MA; + else + output[0x0c] |= eeprom->group0_drive; + if (eeprom->group0_schmitt == IS_SCHMITT) + output[0x0c] |= IS_SCHMITT; + if (eeprom->group0_slew == SLOW_SLEW) + output[0x0c] |= SLOW_SLEW; + + if(eeprom->group1_drive > DRIVE_16MA) + output[0x0c] |= DRIVE_16MA<<4; + else + output[0x0c] |= eeprom->group1_drive<<4; + if (eeprom->group1_schmitt == IS_SCHMITT) + output[0x0c] |= IS_SCHMITT<<4; + if (eeprom->group1_slew == SLOW_SLEW) + output[0x0c] |= SLOW_SLEW<<4; + + if(eeprom->group2_drive > DRIVE_16MA) + output[0x0d] |= DRIVE_16MA; + else + output[0x0d] |= eeprom->group2_drive; + if (eeprom->group2_schmitt == IS_SCHMITT) + output[0x0d] |= IS_SCHMITT; + if (eeprom->group2_slew == SLOW_SLEW) + output[0x0d] |= SLOW_SLEW; + + if(eeprom->group3_drive > DRIVE_16MA) + output[0x0d] |= DRIVE_16MA<<4; + else + output[0x0d] |= eeprom->group3_drive<<4; + if (eeprom->group3_schmitt == IS_SCHMITT) + output[0x0d] |= IS_SCHMITT<<4; + if (eeprom->group3_slew == SLOW_SLEW) + output[0x0d] |= SLOW_SLEW<<4; - // 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[0x18] = eeprom->chip; - // 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++; + break; } // calculate checksum @@ -2495,11 +2641,12 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, unsigned char *buf, int size, unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0; int eeprom_size; struct ftdi_eeprom *eeprom; + int release; if (ftdi == NULL) ftdi_error_return(-1,"No context"); if (ftdi->eeprom == NULL) - ftdi_error_return(-1,"No eeprom"); + ftdi_error_return(-1,"No eeprom structure"); eeprom_size = ftdi->eeprom->size; if(ftdi->type == TYPE_R) @@ -2512,7 +2659,7 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, unsigned char *buf, int size, // Addr 04: Product ID eeprom->product_id = buf[0x04] + (buf[0x05] << 8); - eeprom->release = buf[0x06] + (buf[0x07]<<8); + release = buf[0x06] + (buf[0x07]<<8); // Addr 08: Config descriptor // Bit 7: always 1 @@ -2530,27 +2677,25 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, unsigned char *buf, int size, // Bit 6: 0 - reserved // Bit 5: 0 - reserved // Bit 4: 1 - Change USB version + // Not seen on FT2232(D) // 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 = buf[0x0A]; - if (j&0x01) eeprom->in_is_isochronous = 1; - if (j&0x02) eeprom->out_is_isochronous = 1; - if (j&0x04) eeprom->suspend_pull_downs = 1; - if (j&0x08) eeprom->use_serial = 1; - if (j&0x10) eeprom->change_usb_version = 1; + eeprom->in_is_isochronous = buf[0x0A]&0x01; + eeprom->out_is_isochronous = buf[0x0A]&0x02; + eeprom->suspend_pull_downs = buf[0x0A]&0x04; + eeprom->use_serial = buf[0x0A] & USE_SERIAL_NUM; + if(buf[0x0A]&0x10) + fprintf(stderr, + "EEPROM byte[0x0a] Bit 4 unexpected set. If this happened with the EEPROM\n" + "programmed by FTDI tools, please report to libftdi@developer.intra2net.com\n"); - // Addr 0B: Invert data lines - eeprom->invert = buf[0x0B]; - // 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) - { - eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8); - } + // Addr 0C: USB version low byte when 0x0A + // Addr 0D: USB version high byte when 0x0A + eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8); // Addr 0E: Offset of the manufacturer string + 0x80, calculated later // Addr 0F: Length of manufacturer string @@ -2561,7 +2706,7 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, unsigned char *buf, int size, if (eeprom->manufacturer) { // Decode manufacturer - i = buf[0x0E]; // offset + i = buf[0x0E] & (eeprom_size -1); // offset for (j=0;jmanufacturer[j] = buf[2*j+i+2]; @@ -2580,7 +2725,7 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, unsigned char *buf, int size, if(eeprom->product) { // Decode product name - i = buf[0x10]; // offset + i = buf[0x10] & (eeprom_size -1); // offset for (j=0;jproduct[j] = buf[2*j+i+2]; @@ -2599,7 +2744,7 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, unsigned char *buf, int size, if(eeprom->serial) { // Decode serial - i = buf[0x12]; // offset + i = buf[0x12] & (eeprom_size -1); // offset for (j=0;jserial[j] = buf[2*j+i+2]; @@ -2629,38 +2774,82 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, unsigned char *buf, int size, ftdi_error_return(-1,"EEPROM checksum error"); } - if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C)) + eeprom->channel_a_type = 0; + if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM)) { - eeprom->chip = buf[14]; + eeprom->chip = -1; } - if(ftdi->type == TYPE_2) + else if(ftdi->type == TYPE_2232C) { + eeprom->channel_a_type = buf[0x00] & 0x7; + eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP; + eeprom->high_current_a = buf[0x00] & HIGH_CURRENT_DRIVE; + eeprom->channel_b_type = buf[0x01] & 0x7; + eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP; + eeprom->high_current_b = buf[0x01] & HIGH_CURRENT_DRIVE; + eeprom->chip = buf[0x14]; } - if(ftdi->type == TYPE_R) + else if(ftdi->type == TYPE_R) { + /* TYPE_R flags D2XX, not VCP as all others*/ + eeprom->channel_a_driver = (~buf[0x00]) & DRIVER_VCP; + eeprom->high_current = buf[0x00] & HIGH_CURRENT_DRIVE_R; + if( (buf[0x01]&0x40) != 0x40) + fprintf(stderr, + "TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size." + " If this happened with the\n" + " EEPROM programmed by FTDI tools, please report " + "to libftdi@developer.intra2net.com\n"); + + eeprom->chip = buf[0x16]; + // Addr 0B: Invert data lines + // Works only on FT232R, not FT245R, but no way to distinguish + eeprom->invert = buf[0x0B]; // Addr 14: CBUS function: CBUS0, CBUS1 // Addr 15: CBUS function: CBUS2, CBUS3 // Addr 16: CBUS function: CBUS5 - if (ftdi->type == TYPE_R) { - eeprom->cbus_function[0] = buf[0x14] & 0x0f; - eeprom->cbus_function[1] = (buf[0x14] >> 4) & 0x0f; - eeprom->cbus_function[2] = buf[0x15] & 0x0f; - eeprom->cbus_function[3] = (buf[0x15] >> 4) & 0x0f; - eeprom->cbus_function[4] = buf[0x16] & 0x0f; - } else { - for (j=0; j<5; j++) eeprom->cbus_function[j] = 0; - } + eeprom->cbus_function[0] = buf[0x14] & 0x0f; + eeprom->cbus_function[1] = (buf[0x14] >> 4) & 0x0f; + eeprom->cbus_function[2] = buf[0x15] & 0x0f; + eeprom->cbus_function[3] = (buf[0x15] >> 4) & 0x0f; + eeprom->cbus_function[4] = buf[0x16] & 0x0f; + } + else if ((ftdi->type == TYPE_2232H) ||(ftdi->type == TYPE_4232H)) + { + eeprom->high_current = buf[0x00] & HIGH_CURRENT_DRIVE_R; + eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP; + eeprom->channel_b_type = buf[0x01] & 0x7; + eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP; + + if(ftdi->type == TYPE_2232H) + eeprom->suspend_dbus7 = buf[0x01] & SUSPEND_DBUS7; + + eeprom->chip = buf[0x18]; + eeprom->group0_drive = buf[0x0c] & DRIVE_16MA; + eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT; + eeprom->group0_slew = buf[0x0c] & SLOW_SLEW; + eeprom->group1_drive = (buf[0x0c] >> 4) & 0x3; + eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT; + eeprom->group1_slew = (buf[0x0c] >> 4) & SLOW_SLEW; + eeprom->group2_drive = buf[0x0d] & DRIVE_16MA; + eeprom->group2_schmitt = buf[0x0d] & IS_SCHMITT; + eeprom->group2_slew = buf[0x0d] & SLOW_SLEW; + eeprom->group3_drive = (buf[0x0d] >> 4) & DRIVE_16MA; + eeprom->group3_schmitt = (buf[0x0d] >> 4) & IS_SCHMITT; + eeprom->group3_slew = (buf[0x0d] >> 4) & SLOW_SLEW; } + if(verbose) { + char *channel_mode[] = {"UART","245","CPU", "unknown", "OPTO"}; fprintf(stdout, "VID: 0x%04x\n",eeprom->vendor_id); fprintf(stdout, "PID: 0x%04x\n",eeprom->product_id); - fprintf(stdout, "Release: 0x%04x\n",eeprom->release); + fprintf(stdout, "Release: 0x%04x\n",release); 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 * 2, (eeprom->remote_wakeup)?" USB Remote Wake Up\n":"\n"); if(eeprom->manufacturer) fprintf(stdout, "Manufacturer: %s\n",eeprom->manufacturer); @@ -2668,7 +2857,50 @@ int ftdi_eeprom_decode(struct ftdi_context *ftdi, unsigned char *buf, int size, fprintf(stdout, "Product: %s\n",eeprom->product); if(eeprom->serial) fprintf(stdout, "Serial: %s\n",eeprom->serial); - fprintf(stderr, "Checksum : %04x %04x\n", checksum); + fprintf(stdout, "Checksum : %04x\n", checksum); + if (ftdi->type == TYPE_R) + fprintf(stdout, "Internal EEPROM\n"); + else if (eeprom->chip >= 0x46) + fprintf(stdout, "Attached EEPROM: 93x%02x\n", eeprom->chip); + if(eeprom->suspend_dbus7) + fprintf(stdout, "Suspend on DBUS7\n"); + if(eeprom->suspend_pull_downs) + fprintf(stdout, "Pull IO pins low during suspend\n"); + if(eeprom->remote_wakeup) + fprintf(stdout, "Enable Remote Wake Up\n"); + if (ftdi->type >= TYPE_2232C) + fprintf(stdout,"Channel A has Mode %s%s%s\n", + channel_mode[eeprom->channel_a_type], + (eeprom->channel_a_driver)?" VCP":"", + (eeprom->high_current_a)?" High Current IO":""); + if ((ftdi->type >= TYPE_2232C) && (ftdi->type != TYPE_R)) + fprintf(stdout,"Channel B has Mode %s%s%s\n", + channel_mode[eeprom->channel_b_type], + (eeprom->channel_b_driver)?" VCP":"", + (eeprom->high_current_b)?" High Current IO":""); + if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H)) + { + fprintf(stdout,"%s has %d mA drive%s%s\n", + (ftdi->type == TYPE_2232H)?"AL":"A", + (eeprom->group0_drive+1) *4, + (eeprom->group0_schmitt)?" Schmitt Input":"", + (eeprom->group0_slew)?" Slow Slew":""); + fprintf(stdout,"%s has %d mA drive%s%s\n", + (ftdi->type == TYPE_2232H)?"AH":"B", + (eeprom->group1_drive+1) *4, + (eeprom->group1_schmitt)?" Schmitt Input":"", + (eeprom->group1_slew)?" Slow Slew":""); + fprintf(stdout,"%s has %d mA drive%s%s\n", + (ftdi->type == TYPE_2232H)?"BL":"C", + (eeprom->group2_drive+1) *4, + (eeprom->group2_schmitt)?" Schmitt Input":"", + (eeprom->group2_slew)?" Slow Slew":""); + fprintf(stdout,"%s has %d mA drive%s%s\n", + (ftdi->type == TYPE_2232H)?"BH":"D", + (eeprom->group3_drive+1) *4, + (eeprom->group3_schmitt)?" Schmitt Input":"", + (eeprom->group3_slew)?" Slow Slew":""); + } } @@ -2859,15 +3091,61 @@ int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) \retval 0: all fine \retval -1: erase failed \retval -2: USB device unavailable + \retval -3: Writing magic failed + \retval -4: Read EEPROM failed + \retval -5: Unexpected EEPROM value */ +#define MAGIC 0x55aa int ftdi_erase_eeprom(struct ftdi_context *ftdi) { + unsigned short eeprom_value; if (ftdi == NULL || ftdi->usb_dev == NULL) ftdi_error_return(-2, "USB device unavailable"); - if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST, 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0) + if(ftdi->type == TYPE_R) + { + ftdi->eeprom->chip = 0; + return 0; + } + + if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST, + 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0) ftdi_error_return(-1, "unable to erase eeprom"); + + /* detect chip type by writing 0x55AA as magic at word position 0xc0 + Chip is 93x46 if magic is read at word position 0x00, as wraparound happens around 0x40 + Chip is 93x56 if magic is read at word position 0x40, as wraparound happens around 0x80 + Chip is 93x66 if magic is only read at word position 0xc0*/ + if( ftdi_write_eeprom_location(ftdi, 0xc0, MAGIC)) + ftdi_error_return(-3, "Writing magic failed"); + if (ftdi_read_eeprom_location( ftdi, 0x00, &eeprom_value)) + ftdi_error_return(-4, "Reading failed failed"); + if(eeprom_value == MAGIC) + { + ftdi->eeprom->chip = 0x46; + } + else + { + if (ftdi_read_eeprom_location( ftdi, 0x40, &eeprom_value)) + ftdi_error_return(-4, "Reading failed failed"); + if(eeprom_value == MAGIC) + ftdi->eeprom->chip = 0x56; + else + { + if (ftdi_read_eeprom_location( ftdi, 0xc0, &eeprom_value)) + ftdi_error_return(-4, "Reading failed failed"); + if(eeprom_value == MAGIC) + ftdi->eeprom->chip = 0x66; + else + { + ftdi->eeprom->chip = -1; + } + } + } + if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST, + 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0) + ftdi_error_return(-1, "unable to erase eeprom"); return 0; }