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