1 /***************************************************************************
5 copyright : (C) 2003 by Intra2net AG
6 email : opensource@intra2net.com
7 ***************************************************************************/
9 /***************************************************************************
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU Lesser General Public License *
13 * version 2.1 as published by the Free Software Foundation; *
15 ***************************************************************************/
21 /* ftdi_init return codes:
23 -1: couldn't allocate read buffer
25 int ftdi_init(struct ftdi_context *ftdi) {
27 ftdi->usb_read_timeout = 5000;
28 ftdi->usb_write_timeout = 5000;
30 ftdi->type = TYPE_BM; /* chip type */
32 ftdi->bitbang_enabled = 0;
34 ftdi->readbuffer = NULL;
35 ftdi->readbuffer_offset = 0;
36 ftdi->readbuffer_remaining = 0;
37 ftdi->writebuffer_chunksize = 4096;
43 ftdi->bitbang_mode = 1; /* 1: Normal bitbang mode, 2: SPI bitbang mode */
45 ftdi->error_str = NULL;
47 // all fine. Now allocate the readbuffer
48 return ftdi_read_data_set_chunksize(ftdi, 4096);
52 void ftdi_deinit(struct ftdi_context *ftdi) {
53 if (ftdi->readbuffer != NULL) {
54 free(ftdi->readbuffer);
55 ftdi->readbuffer = NULL;
60 void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *usb) {
65 /* ftdi_usb_open return codes:
67 -1: usb_find_busses() failed
68 -2: usb_find_devices() failed
69 -3: usb device not found
70 -4: unable to open device
71 -5: unable to claim device
73 -7: set baudrate failed
75 int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product) {
77 struct usb_device *dev;
81 if (usb_find_busses() < 0) {
82 ftdi->error_str = "usb_find_busses() failed";
86 if (usb_find_devices() < 0) {
87 ftdi->error_str = "usb_find_devices() failed";
91 for (bus = usb_busses; bus; bus = bus->next) {
92 for (dev = bus->devices; dev; dev = dev->next) {
93 if (dev->descriptor.idVendor == vendor && dev->descriptor.idProduct == product) {
94 ftdi->usb_dev = usb_open(dev);
96 if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0) {
97 ftdi->error_str = "unable to claim usb device. Make sure ftdi_sio is unloaded!";
101 if (ftdi_usb_reset (ftdi) != 0)
104 if (ftdi_set_baudrate (ftdi, 9600) != 0)
109 ftdi->error_str = "usb_open() failed";
122 int ftdi_usb_reset(struct ftdi_context *ftdi) {
123 if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
124 ftdi->error_str = "FTDI reset failed";
127 // Invalidate data in the readbuffer
128 ftdi->readbuffer_offset = 0;
129 ftdi->readbuffer_remaining = 0;
134 int ftdi_usb_purge_buffers(struct ftdi_context *ftdi) {
135 if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 1, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
136 ftdi->error_str = "FTDI purge of RX buffer failed";
139 // Invalidate data in the readbuffer
140 ftdi->readbuffer_offset = 0;
141 ftdi->readbuffer_remaining = 0;
143 if (usb_control_msg(ftdi->usb_dev, 0x40, 0, 2, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
144 ftdi->error_str = "FTDI purge of TX buffer failed";
152 /* ftdi_usb_close return codes
154 -1: usb_release failed
157 int ftdi_usb_close(struct ftdi_context *ftdi) {
160 if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0)
163 if (usb_close (ftdi->usb_dev) != 0)
171 ftdi_convert_baudrate returns nearest supported baud rate to that requested.
172 Function is only used internally
174 static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
175 unsigned short *value, unsigned short *index) {
176 static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
177 static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
178 static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
179 int divisor, best_divisor, best_baud, best_baud_diff;
180 unsigned long encoded_divisor;
188 divisor = 24000000 / baudrate;
190 if (ftdi->type == TYPE_AM) {
191 // Round down to supported fraction (AM only)
192 divisor -= am_adjust_dn[divisor & 7];
195 // Try this divisor and the one above it (because division rounds down)
199 for (i = 0; i < 2; i++) {
200 int try_divisor = divisor + i;
204 // Round up to supported divisor value
205 if (try_divisor < 8) {
206 // Round up to minimum supported divisor
208 } else if (ftdi->type != TYPE_AM && try_divisor < 12) {
209 // BM doesn't support divisors 9 through 11 inclusive
211 } else if (divisor < 16) {
212 // AM doesn't support divisors 9 through 15 inclusive
215 if (ftdi->type == TYPE_AM) {
216 // Round up to supported fraction (AM only)
217 try_divisor += am_adjust_up[try_divisor & 7];
218 if (try_divisor > 0x1FFF8) {
219 // Round down to maximum supported divisor value (for AM)
220 try_divisor = 0x1FFF8;
223 if (try_divisor > 0x1FFFF) {
224 // Round down to maximum supported divisor value (for BM)
225 try_divisor = 0x1FFFF;
229 // Get estimated baud rate (to nearest integer)
230 baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
231 // Get absolute difference from requested baud rate
232 if (baud_estimate < baudrate) {
233 baud_diff = baudrate - baud_estimate;
235 baud_diff = baud_estimate - baudrate;
237 if (i == 0 || baud_diff < best_baud_diff) {
238 // Closest to requested baud rate so far
239 best_divisor = try_divisor;
240 best_baud = baud_estimate;
241 best_baud_diff = baud_diff;
242 if (baud_diff == 0) {
243 // Spot on! No point trying
248 // Encode the best divisor value
249 encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
250 // Deal with special cases for encoded value
251 if (encoded_divisor == 1) {
252 encoded_divisor = 0; // 3000000 baud
253 } else if (encoded_divisor == 0x4001) {
254 encoded_divisor = 1; // 2000000 baud (BM only)
256 // Split into "value" and "index" values
257 *value = (unsigned short)(encoded_divisor & 0xFFFF);
258 if(ftdi->type == TYPE_FT2232C) {
259 *index = (unsigned short)(encoded_divisor >> 8);
261 *index |= ftdi->interface;
264 *index = (unsigned short)(encoded_divisor >> 16);
266 // Return the nearest baud rate
271 ftdi_set_baudrate return codes:
274 -2: setting baudrate failed
276 int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate) {
277 unsigned short value, index;
280 if (ftdi->bitbang_enabled) {
281 baudrate = baudrate*4;
284 actual_baudrate = convert_baudrate(baudrate, ftdi, &value, &index);
285 if (actual_baudrate <= 0) {
286 ftdi->error_str = "Silly baudrate <= 0.";
290 // Check within tolerance (about 5%)
291 if ((actual_baudrate * 2 < baudrate /* Catch overflows */ )
292 || ((actual_baudrate < baudrate)
293 ? (actual_baudrate * 21 < baudrate * 20)
294 : (baudrate * 21 < actual_baudrate * 20))) {
295 ftdi->error_str = "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4";
299 if (usb_control_msg(ftdi->usb_dev, 0x40, 3, value, index, NULL, 0, ftdi->usb_write_timeout) != 0) {
300 ftdi->error_str = "Setting new baudrate failed";
304 ftdi->baudrate = baudrate;
309 int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size) {
312 int total_written = 0;
313 while (offset < size) {
314 int write_size = ftdi->writebuffer_chunksize;
316 if (offset+write_size > size)
317 write_size = size-offset;
319 ret = usb_bulk_write(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, ftdi->usb_write_timeout);
321 ftdi->error_str = "bulk write failed";
324 total_written += ret;
326 offset += write_size;
329 return total_written;
333 int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize) {
334 ftdi->writebuffer_chunksize = chunksize;
339 int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize) {
340 *chunksize = ftdi->writebuffer_chunksize;
345 int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size) {
346 int offset = 0, ret = 1;
348 // everything we want is still in the readbuffer?
349 if (size <= ftdi->readbuffer_remaining) {
350 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
353 ftdi->readbuffer_remaining -= size;
354 ftdi->readbuffer_offset += size;
356 /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
360 // something still in the readbuffer, but not enough to satisfy 'size'?
361 if (ftdi->readbuffer_remaining != 0) {
362 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
365 offset += ftdi->readbuffer_remaining;
367 // do the actual USB read
368 while (offset < size && ret > 0) {
369 ftdi->readbuffer_remaining = 0;
370 ftdi->readbuffer_offset = 0;
371 /* returns how much received */
372 ret = usb_bulk_read (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, ftdi->usb_read_timeout);
375 ftdi->error_str = "bulk read failed";
380 // skip FTDI status bytes.
381 // Maybe stored in the future to enable modem use
382 ftdi->readbuffer_offset += 2;
384 } else if (ret <= 2) {
385 // no more data to read?
389 // data still fits in buf?
390 if (offset+ret <= size) {
391 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, ret);
392 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
395 /* Did we read exactly the right amount of bytes? */
399 // only copy part of the data or size <= readbuffer_chunksize
400 int part_size = size-offset;
401 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
403 ftdi->readbuffer_offset += part_size;
404 ftdi->readbuffer_remaining = ret-part_size;
407 /* printf("Returning part: %d - size: %d - offset: %d - ret: %d - remaining: %d\n",
408 part_size, size, offset, ret, ftdi->readbuffer_remaining); */
419 int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize) {
420 // Invalidate all remaining data
421 ftdi->readbuffer_offset = 0;
422 ftdi->readbuffer_remaining = 0;
424 unsigned char *new_buf;
425 if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL) {
426 ftdi->error_str = "out of memory for readbuffer";
430 ftdi->readbuffer = new_buf;
431 ftdi->readbuffer_chunksize = chunksize;
437 int ftdi_readt_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize) {
438 *chunksize = ftdi->readbuffer_chunksize;
444 int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask) {
445 unsigned short usb_val;
447 usb_val = bitmask; // low byte: bitmask
448 /* FT2232C: Set bitbang_mode to 2 to enable SPI */
449 usb_val |= (ftdi->bitbang_mode << 8);
451 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
452 ftdi->error_str = "Unable to enter bitbang mode. Perhaps not a BM type chip?";
455 ftdi->bitbang_enabled = 1;
460 int ftdi_disable_bitbang(struct ftdi_context *ftdi) {
461 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x0B, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
462 ftdi->error_str = "Unable to leave bitbang mode. Perhaps not a BM type chip?";
466 ftdi->bitbang_enabled = 0;
471 int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins) {
472 unsigned short usb_val;
473 if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0C, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1) {
474 ftdi->error_str = "Read pins failed";
478 *pins = (unsigned char)usb_val;
483 int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency) {
484 unsigned short usb_val;
487 ftdi->error_str = "Latency out of range. Only valid for 1-255";
492 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x09, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0) {
493 ftdi->error_str = "Unable to set latency timer";
500 int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency) {
501 unsigned short usb_val;
502 if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x0A, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1) {
503 ftdi->error_str = "Reading latency timer failed";
507 *latency = (unsigned char)usb_val;
512 void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom) {
513 eeprom->vendor_id = 0403;
514 eeprom->product_id = 6001;
516 eeprom->self_powered = 1;
517 eeprom->remote_wakeup = 1;
518 eeprom->BM_type_chip = 1;
520 eeprom->in_is_isochronous = 0;
521 eeprom->out_is_isochronous = 0;
522 eeprom->suspend_pull_downs = 0;
524 eeprom->use_serial = 0;
525 eeprom->change_usb_version = 0;
526 eeprom->usb_version = 200;
527 eeprom->max_power = 0;
529 eeprom->manufacturer = NULL;
530 eeprom->product = NULL;
531 eeprom->serial = NULL;
536 ftdi_eeprom_build return codes:
537 positive value: used eeprom size
538 -1: eeprom size (128 bytes) exceeded by custom strings
540 int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output) {
542 unsigned short checksum, value;
543 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
546 if (eeprom->manufacturer != NULL)
547 manufacturer_size = strlen(eeprom->manufacturer);
548 if (eeprom->product != NULL)
549 product_size = strlen(eeprom->product);
550 if (eeprom->serial != NULL)
551 serial_size = strlen(eeprom->serial);
553 size_check = 128; // eeprom is 128 bytes
554 size_check -= 28; // 28 are always in use (fixed)
555 size_check -= manufacturer_size*2;
556 size_check -= product_size*2;
557 size_check -= serial_size*2;
559 // eeprom size exceeded?
564 memset (output, 0, 128);
566 // Addr 00: Stay 00 00
567 // Addr 02: Vendor ID
568 output[0x02] = eeprom->vendor_id;
569 output[0x03] = eeprom->vendor_id >> 8;
571 // Addr 04: Product ID
572 output[0x04] = eeprom->product_id;
573 output[0x05] = eeprom->product_id >> 8;
575 // Addr 06: Device release number (0400h for BM features)
578 if (eeprom->BM_type_chip == 1)
583 // Addr 08: Config descriptor
584 // Bit 1: remote wakeup if 1
585 // Bit 0: self powered if 1
588 if (eeprom->self_powered == 1)
590 if (eeprom->remote_wakeup == 1)
594 // Addr 09: Max power consumption: max power = value * 2 mA
595 output[0x09] = eeprom->max_power;
598 // Addr 0A: Chip configuration
599 // Bit 7: 0 - reserved
600 // Bit 6: 0 - reserved
601 // Bit 5: 0 - reserved
602 // Bit 4: 1 - Change USB version
603 // Bit 3: 1 - Use the serial number string
604 // Bit 2: 1 - Enable suspend pull downs for lower power
605 // Bit 1: 1 - Out EndPoint is Isochronous
606 // Bit 0: 1 - In EndPoint is Isochronous
609 if (eeprom->in_is_isochronous == 1)
611 if (eeprom->out_is_isochronous == 1)
613 if (eeprom->suspend_pull_downs == 1)
615 if (eeprom->use_serial == 1)
617 if (eeprom->change_usb_version == 1)
624 // Addr 0C: USB version low byte when 0x0A bit 4 is set
625 // Addr 0D: USB version high byte when 0x0A bit 4 is set
626 if (eeprom->change_usb_version == 1) {
627 output[0x0C] = eeprom->usb_version;
628 output[0x0D] = eeprom->usb_version >> 8;
632 // Addr 0E: Offset of the manufacturer string + 0x80
633 output[0x0E] = 0x14 + 0x80;
635 // Addr 0F: Length of manufacturer string
636 output[0x0F] = manufacturer_size*2 + 2;
638 // Addr 10: Offset of the product string + 0x80, calculated later
639 // Addr 11: Length of product string
640 output[0x11] = product_size*2 + 2;
642 // Addr 12: Offset of the serial string + 0x80, calculated later
643 // Addr 13: Length of serial string
644 output[0x13] = serial_size*2 + 2;
647 output[0x14] = manufacturer_size*2 + 2;
648 output[0x15] = 0x03; // type: string
652 // Output manufacturer
653 for (j = 0; j < manufacturer_size; j++) {
654 output[i] = eeprom->manufacturer[j], i++;
655 output[i] = 0x00, i++;
658 // Output product name
659 output[0x10] = i + 0x80; // calculate offset
660 output[i] = product_size*2 + 2, i++;
661 output[i] = 0x03, i++;
662 for (j = 0; j < product_size; j++) {
663 output[i] = eeprom->product[j], i++;
664 output[i] = 0x00, i++;
668 output[0x12] = i + 0x80; // calculate offset
669 output[i] = serial_size*2 + 2, i++;
670 output[i] = 0x03, i++;
671 for (j = 0; j < serial_size; j++) {
672 output[i] = eeprom->serial[j], i++;
673 output[i] = 0x00, i++;
676 // calculate checksum
679 for (i = 0; i < 63; i++) {
681 value += output[(i*2)+1] << 8;
683 checksum = value^checksum;
684 checksum = (checksum << 1) | (checksum >> 15);
687 output[0x7E] = checksum;
688 output[0x7F] = checksum >> 8;
694 int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) {
697 for (i = 0; i < 64; i++) {
698 if (usb_control_msg(ftdi->usb_dev, 0xC0, 0x90, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2) {
699 ftdi->error_str = "Reading eeprom failed";
708 int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom) {
709 unsigned short usb_val;
712 for (i = 0; i < 64; i++) {
713 usb_val = eeprom[i*2];
714 usb_val += eeprom[(i*2)+1] << 8;
715 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x91, usb_val, i, NULL, 0, ftdi->usb_write_timeout) != 0) {
716 ftdi->error_str = "Unable to write eeprom";
725 int ftdi_erase_eeprom(struct ftdi_context *ftdi) {
726 if (usb_control_msg(ftdi->usb_dev, 0x40, 0x92, 0, 0, NULL, 0, ftdi->usb_write_timeout) != 0) {
727 ftdi->error_str = "Unable to erase eeprom";