git://developer.intra2net.com / libftdi / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Don't return before cleanup
[libftdi] / src / ftdi.c
... / ...
CommitLineData
1/***************************************************************************
2 ftdi.c - description
3 -------------------
4 begin : Fri Apr 4 2003
5 copyright : (C) 2003-2011 by Intra2net AG and the libftdi developers
6 email : opensource@intra2net.com
7 ***************************************************************************/
8
9/***************************************************************************
10 * *
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; *
14 * *
15 ***************************************************************************/
16
17/**
18 \mainpage libftdi API documentation
19
20 Library to talk to FTDI chips. You find the latest versions of libftdi at
21 http://www.intra2net.com/en/developer/libftdi/
22
23 The library is easy to use. Have a look at this short example:
24 \include simple.c
25
26 More examples can be found in the "examples" directory.
27*/
28/** \addtogroup libftdi */
29/* @{ */
30
31#include <libusb.h>
32#include <string.h>
33#include <errno.h>
34#include <stdio.h>
35#include <stdlib.h>
36
37#include "ftdi.h"
38
39#define ftdi_error_return(code, str) do { \
40 ftdi->error_str = str; \
41 return code; \
42 } while(0);
43
44#define ftdi_error_return_free_device_list(code, str, devs) do { \
45 libusb_free_device_list(devs,1); \
46 ftdi->error_str = str; \
47 return code; \
48 } while(0);
49
50
51/**
52 Internal function to close usb device pointer.
53 Sets ftdi->usb_dev to NULL.
54 \internal
55
56 \param ftdi pointer to ftdi_context
57
58 \retval none
59*/
60static void ftdi_usb_close_internal (struct ftdi_context *ftdi)
61{
62 if (ftdi && ftdi->usb_dev)
63 {
64 libusb_close (ftdi->usb_dev);
65 ftdi->usb_dev = NULL;
66 }
67}
68
69/**
70 Initializes a ftdi_context.
71
72 \param ftdi pointer to ftdi_context
73
74 \retval 0: all fine
75 \retval -1: couldn't allocate read buffer
76 \retval -2: couldn't allocate struct buffer
77 \retval -3: libusb_init() failed
78
79 \remark This should be called before all functions
80*/
81int ftdi_init(struct ftdi_context *ftdi)
82{
83 struct ftdi_eeprom* eeprom = (struct ftdi_eeprom *)malloc(sizeof(struct ftdi_eeprom));
84 ftdi->usb_ctx = NULL;
85 ftdi->usb_dev = NULL;
86 ftdi->usb_read_timeout = 5000;
87 ftdi->usb_write_timeout = 5000;
88
89 ftdi->type = TYPE_BM; /* chip type */
90 ftdi->baudrate = -1;
91 ftdi->bitbang_enabled = 0; /* 0: normal mode 1: any of the bitbang modes enabled */
92
93 ftdi->readbuffer = NULL;
94 ftdi->readbuffer_offset = 0;
95 ftdi->readbuffer_remaining = 0;
96 ftdi->writebuffer_chunksize = 4096;
97 ftdi->max_packet_size = 0;
98 ftdi->error_str = NULL;
99 ftdi->module_detach_mode = AUTO_DETACH_SIO_MODULE;
100
101 if (libusb_init(&ftdi->usb_ctx) < 0)
102 ftdi_error_return(-3, "libusb_init() failed");
103
104 ftdi_set_interface(ftdi, INTERFACE_ANY);
105 ftdi->bitbang_mode = 1; /* when bitbang is enabled this holds the number of the mode */
106
107 if (eeprom == 0)
108 ftdi_error_return(-2, "Can't malloc struct ftdi_eeprom");
109 memset(eeprom, 0, sizeof(struct ftdi_eeprom));
110 ftdi->eeprom = eeprom;
111
112 /* All fine. Now allocate the readbuffer */
113 return ftdi_read_data_set_chunksize(ftdi, 4096);
114}
115
116/**
117 Allocate and initialize a new ftdi_context
118
119 \return a pointer to a new ftdi_context, or NULL on failure
120*/
121struct ftdi_context *ftdi_new(void)
122{
123 struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context));
124
125 if (ftdi == NULL)
126 {
127 return NULL;
128 }
129
130 if (ftdi_init(ftdi) != 0)
131 {
132 free(ftdi);
133 return NULL;
134 }
135
136 return ftdi;
137}
138
139/**
140 Open selected channels on a chip, otherwise use first channel.
141
142 \param ftdi pointer to ftdi_context
143 \param interface Interface to use for FT2232C/2232H/4232H chips.
144
145 \retval 0: all fine
146 \retval -1: unknown interface
147 \retval -2: USB device unavailable
148*/
149int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
150{
151 if (ftdi == NULL)
152 ftdi_error_return(-2, "USB device unavailable");
153
154 switch (interface)
155 {
156 case INTERFACE_ANY:
157 case INTERFACE_A:
158 ftdi->interface = 0;
159 ftdi->index = INTERFACE_A;
160 ftdi->in_ep = 0x02;
161 ftdi->out_ep = 0x81;
162 break;
163 case INTERFACE_B:
164 ftdi->interface = 1;
165 ftdi->index = INTERFACE_B;
166 ftdi->in_ep = 0x04;
167 ftdi->out_ep = 0x83;
168 break;
169 case INTERFACE_C:
170 ftdi->interface = 2;
171 ftdi->index = INTERFACE_C;
172 ftdi->in_ep = 0x06;
173 ftdi->out_ep = 0x85;
174 break;
175 case INTERFACE_D:
176 ftdi->interface = 3;
177 ftdi->index = INTERFACE_D;
178 ftdi->in_ep = 0x08;
179 ftdi->out_ep = 0x87;
180 break;
181 default:
182 ftdi_error_return(-1, "Unknown interface");
183 }
184 return 0;
185}
186
187/**
188 Deinitializes a ftdi_context.
189
190 \param ftdi pointer to ftdi_context
191*/
192void ftdi_deinit(struct ftdi_context *ftdi)
193{
194 if (ftdi == NULL)
195 return;
196
197 ftdi_usb_close_internal (ftdi);
198
199 if (ftdi->readbuffer != NULL)
200 {
201 free(ftdi->readbuffer);
202 ftdi->readbuffer = NULL;
203 }
204
205 if (ftdi->eeprom != NULL)
206 {
207 if (ftdi->eeprom->manufacturer != 0)
208 {
209 free(ftdi->eeprom->manufacturer);
210 ftdi->eeprom->manufacturer = 0;
211 }
212 if (ftdi->eeprom->product != 0)
213 {
214 free(ftdi->eeprom->product);
215 ftdi->eeprom->product = 0;
216 }
217 if (ftdi->eeprom->serial != 0)
218 {
219 free(ftdi->eeprom->serial);
220 ftdi->eeprom->serial = 0;
221 }
222 free(ftdi->eeprom);
223 ftdi->eeprom = NULL;
224 }
225
226 if (ftdi->usb_ctx)
227 {
228 libusb_exit(ftdi->usb_ctx);
229 ftdi->usb_ctx = NULL;
230 }
231}
232
233/**
234 Deinitialize and free an ftdi_context.
235
236 \param ftdi pointer to ftdi_context
237*/
238void ftdi_free(struct ftdi_context *ftdi)
239{
240 ftdi_deinit(ftdi);
241 free(ftdi);
242}
243
244/**
245 Use an already open libusb device.
246
247 \param ftdi pointer to ftdi_context
248 \param usb libusb libusb_device_handle to use
249*/
250void ftdi_set_usbdev (struct ftdi_context *ftdi, libusb_device_handle *usb)
251{
252 if (ftdi == NULL)
253 return;
254
255 ftdi->usb_dev = usb;
256}
257
258
259/**
260 Finds all ftdi devices on the usb bus. Creates a new ftdi_device_list which
261 needs to be deallocated by ftdi_list_free() after use.
262
263 \param ftdi pointer to ftdi_context
264 \param devlist Pointer where to store list of found devices
265 \param vendor Vendor ID to search for
266 \param product Product ID to search for
267
268 \retval >0: number of devices found
269 \retval -3: out of memory
270 \retval -5: libusb_get_device_list() failed
271 \retval -6: libusb_get_device_descriptor() failed
272*/
273int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
274{
275 struct ftdi_device_list **curdev;
276 libusb_device *dev;
277 libusb_device **devs;
278 int count = 0;
279 int i = 0;
280
281 if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
282 ftdi_error_return(-5, "libusb_get_device_list() failed");
283
284 curdev = devlist;
285 *curdev = NULL;
286
287 while ((dev = devs[i++]) != NULL)
288 {
289 struct libusb_device_descriptor desc;
290
291 if (libusb_get_device_descriptor(dev, &desc) < 0)
292 ftdi_error_return_free_device_list(-6, "libusb_get_device_descriptor() failed", devs);
293
294 if (desc.idVendor == vendor && desc.idProduct == product)
295 {
296 *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
297 if (!*curdev)
298 ftdi_error_return_free_device_list(-3, "out of memory", devs);
299
300 (*curdev)->next = NULL;
301 (*curdev)->dev = dev;
302
303 curdev = &(*curdev)->next;
304 count++;
305 }
306 }
307 libusb_free_device_list(devs,1);
308 return count;
309}
310
311/**
312 Frees a usb device list.
313
314 \param devlist USB device list created by ftdi_usb_find_all()
315*/
316void ftdi_list_free(struct ftdi_device_list **devlist)
317{
318 struct ftdi_device_list *curdev, *next;
319
320 for (curdev = *devlist; curdev != NULL;)
321 {
322 next = curdev->next;
323 free(curdev);
324 curdev = next;
325 }
326
327 *devlist = NULL;
328}
329
330/**
331 Frees a usb device list.
332
333 \param devlist USB device list created by ftdi_usb_find_all()
334*/
335void ftdi_list_free2(struct ftdi_device_list *devlist)
336{
337 ftdi_list_free(&devlist);
338}
339
340/**
341 Return device ID strings from the usb device.
342
343 The parameters manufacturer, description and serial may be NULL
344 or pointer to buffers to store the fetched strings.
345
346 \note Use this function only in combination with ftdi_usb_find_all()
347 as it closes the internal "usb_dev" after use.
348
349 \param ftdi pointer to ftdi_context
350 \param dev libusb usb_dev to use
351 \param manufacturer Store manufacturer string here if not NULL
352 \param mnf_len Buffer size of manufacturer string
353 \param description Store product description string here if not NULL
354 \param desc_len Buffer size of product description string
355 \param serial Store serial string here if not NULL
356 \param serial_len Buffer size of serial string
357
358 \retval 0: all fine
359 \retval -1: wrong arguments
360 \retval -4: unable to open device
361 \retval -7: get product manufacturer failed
362 \retval -8: get product description failed
363 \retval -9: get serial number failed
364 \retval -11: libusb_get_device_descriptor() failed
365*/
366int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct libusb_device * dev,
367 char * manufacturer, int mnf_len, char * description, int desc_len, char * serial, int serial_len)
368{
369 struct libusb_device_descriptor desc;
370
371 if ((ftdi==NULL) || (dev==NULL))
372 return -1;
373
374 if (libusb_open(dev, &ftdi->usb_dev) < 0)
375 ftdi_error_return(-4, "libusb_open() failed");
376
377 if (libusb_get_device_descriptor(dev, &desc) < 0)
378 ftdi_error_return(-11, "libusb_get_device_descriptor() failed");
379
380 if (manufacturer != NULL)
381 {
382 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iManufacturer, (unsigned char *)manufacturer, mnf_len) < 0)
383 {
384 ftdi_usb_close_internal (ftdi);
385 ftdi_error_return(-7, "libusb_get_string_descriptor_ascii() failed");
386 }
387 }
388
389 if (description != NULL)
390 {
391 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)description, desc_len) < 0)
392 {
393 ftdi_usb_close_internal (ftdi);
394 ftdi_error_return(-8, "libusb_get_string_descriptor_ascii() failed");
395 }
396 }
397
398 if (serial != NULL)
399 {
400 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)serial, serial_len) < 0)
401 {
402 ftdi_usb_close_internal (ftdi);
403 ftdi_error_return(-9, "libusb_get_string_descriptor_ascii() failed");
404 }
405 }
406
407 ftdi_usb_close_internal (ftdi);
408
409 return 0;
410}
411
412/**
413 * Internal function to determine the maximum packet size.
414 * \param ftdi pointer to ftdi_context
415 * \param dev libusb usb_dev to use
416 * \retval Maximum packet size for this device
417 */
418static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, libusb_device *dev)
419{
420 struct libusb_device_descriptor desc;
421 struct libusb_config_descriptor *config0;
422 unsigned int packet_size;
423
424 // Sanity check
425 if (ftdi == NULL || dev == NULL)
426 return 64;
427
428 // Determine maximum packet size. Init with default value.
429 // New hi-speed devices from FTDI use a packet size of 512 bytes
430 // but could be connected to a normal speed USB hub -> 64 bytes packet size.
431 if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H )
432 packet_size = 512;
433 else
434 packet_size = 64;
435
436 if (libusb_get_device_descriptor(dev, &desc) < 0)
437 return packet_size;
438
439 if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
440 return packet_size;
441
442 if (desc.bNumConfigurations > 0)
443 {
444 if (ftdi->interface < config0->bNumInterfaces)
445 {
446 struct libusb_interface interface = config0->interface[ftdi->interface];
447 if (interface.num_altsetting > 0)
448 {
449 struct libusb_interface_descriptor descriptor = interface.altsetting[0];
450 if (descriptor.bNumEndpoints > 0)
451 {
452 packet_size = descriptor.endpoint[0].wMaxPacketSize;
453 }
454 }
455 }
456 }
457
458 libusb_free_config_descriptor (config0);
459 return packet_size;
460}
461
462/**
463 Opens a ftdi device given by an usb_device.
464
465 \param ftdi pointer to ftdi_context
466 \param dev libusb usb_dev to use
467
468 \retval 0: all fine
469 \retval -3: unable to config device
470 \retval -4: unable to open device
471 \retval -5: unable to claim device
472 \retval -6: reset failed
473 \retval -7: set baudrate failed
474 \retval -8: ftdi context invalid
475 \retval -9: libusb_get_device_descriptor() failed
476 \retval -10: libusb_get_config_descriptor() failed
477 \retval -11: libusb_detach_kernel_driver() failed
478 \retval -12: libusb_get_configuration() failed
479*/
480int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev)
481{
482 struct libusb_device_descriptor desc;
483 struct libusb_config_descriptor *config0;
484 int cfg, cfg0, detach_errno = 0;
485
486 if (ftdi == NULL)
487 ftdi_error_return(-8, "ftdi context invalid");
488
489 if (libusb_open(dev, &ftdi->usb_dev) < 0)
490 ftdi_error_return(-4, "libusb_open() failed");
491
492 if (libusb_get_device_descriptor(dev, &desc) < 0)
493 ftdi_error_return(-9, "libusb_get_device_descriptor() failed");
494
495 if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
496 ftdi_error_return(-10, "libusb_get_config_descriptor() failed");
497 cfg0 = config0->bConfigurationValue;
498 libusb_free_config_descriptor (config0);
499
500 // Try to detach ftdi_sio kernel module.
501 //
502 // The return code is kept in a separate variable and only parsed
503 // if usb_set_configuration() or usb_claim_interface() fails as the
504 // detach operation might be denied and everything still works fine.
505 // Likely scenario is a static ftdi_sio kernel module.
506 if (ftdi->module_detach_mode == AUTO_DETACH_SIO_MODULE)
507 {
508 if (libusb_detach_kernel_driver(ftdi->usb_dev, ftdi->interface) !=0)
509 detach_errno = errno;
510 }
511
512 if (libusb_get_configuration (ftdi->usb_dev, &cfg) < 0)
513 ftdi_error_return(-12, "libusb_get_configuration () failed");
514 // set configuration (needed especially for windows)
515 // tolerate EBUSY: one device with one configuration, but two interfaces
516 // and libftdi sessions to both interfaces (e.g. FT2232)
517 if (desc.bNumConfigurations > 0 && cfg != cfg0)
518 {
519 if (libusb_set_configuration(ftdi->usb_dev, cfg0) < 0)
520 {
521 ftdi_usb_close_internal (ftdi);
522 if (detach_errno == EPERM)
523 {
524 ftdi_error_return(-8, "inappropriate permissions on device!");
525 }
526 else
527 {
528 ftdi_error_return(-3, "unable to set usb configuration. Make sure the default FTDI driver is not in use");
529 }
530 }
531 }
532
533 if (libusb_claim_interface(ftdi->usb_dev, ftdi->interface) < 0)
534 {
535 ftdi_usb_close_internal (ftdi);
536 if (detach_errno == EPERM)
537 {
538 ftdi_error_return(-8, "inappropriate permissions on device!");
539 }
540 else
541 {
542 ftdi_error_return(-5, "unable to claim usb device. Make sure the default FTDI driver is not in use");
543 }
544 }
545
546 if (ftdi_usb_reset (ftdi) != 0)
547 {
548 ftdi_usb_close_internal (ftdi);
549 ftdi_error_return(-6, "ftdi_usb_reset failed");
550 }
551
552 // Try to guess chip type
553 // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
554 if (desc.bcdDevice == 0x400 || (desc.bcdDevice == 0x200
555 && desc.iSerialNumber == 0))
556 ftdi->type = TYPE_BM;
557 else if (desc.bcdDevice == 0x200)
558 ftdi->type = TYPE_AM;
559 else if (desc.bcdDevice == 0x500)
560 ftdi->type = TYPE_2232C;
561 else if (desc.bcdDevice == 0x600)
562 ftdi->type = TYPE_R;
563 else if (desc.bcdDevice == 0x700)
564 ftdi->type = TYPE_2232H;
565 else if (desc.bcdDevice == 0x800)
566 ftdi->type = TYPE_4232H;
567 else if (desc.bcdDevice == 0x900)
568 ftdi->type = TYPE_232H;
569
570 // Determine maximum packet size
571 ftdi->max_packet_size = _ftdi_determine_max_packet_size(ftdi, dev);
572
573 if (ftdi_set_baudrate (ftdi, 9600) != 0)
574 {
575 ftdi_usb_close_internal (ftdi);
576 ftdi_error_return(-7, "set baudrate failed");
577 }
578
579 ftdi_error_return(0, "all fine");
580}
581
582/**
583 Opens the first device with a given vendor and product ids.
584
585 \param ftdi pointer to ftdi_context
586 \param vendor Vendor ID
587 \param product Product ID
588
589 \retval same as ftdi_usb_open_desc()
590*/
591int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
592{
593 return ftdi_usb_open_desc(ftdi, vendor, product, NULL, NULL);
594}
595
596/**
597 Opens the first device with a given, vendor id, product id,
598 description and serial.
599
600 \param ftdi pointer to ftdi_context
601 \param vendor Vendor ID
602 \param product Product ID
603 \param description Description to search for. Use NULL if not needed.
604 \param serial Serial to search for. Use NULL if not needed.
605
606 \retval 0: all fine
607 \retval -3: usb device not found
608 \retval -4: unable to open device
609 \retval -5: unable to claim device
610 \retval -6: reset failed
611 \retval -7: set baudrate failed
612 \retval -8: get product description failed
613 \retval -9: get serial number failed
614 \retval -12: libusb_get_device_list() failed
615 \retval -13: libusb_get_device_descriptor() failed
616*/
617int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
618 const char* description, const char* serial)
619{
620 return ftdi_usb_open_desc_index(ftdi,vendor,product,description,serial,0);
621}
622
623/**
624 Opens the index-th device with a given, vendor id, product id,
625 description and serial.
626
627 \param ftdi pointer to ftdi_context
628 \param vendor Vendor ID
629 \param product Product ID
630 \param description Description to search for. Use NULL if not needed.
631 \param serial Serial to search for. Use NULL if not needed.
632 \param index Number of matching device to open if there are more than one, starts with 0.
633
634 \retval 0: all fine
635 \retval -1: usb_find_busses() failed
636 \retval -2: usb_find_devices() failed
637 \retval -3: usb device not found
638 \retval -4: unable to open device
639 \retval -5: unable to claim device
640 \retval -6: reset failed
641 \retval -7: set baudrate failed
642 \retval -8: get product description failed
643 \retval -9: get serial number failed
644 \retval -10: unable to close device
645 \retval -11: ftdi context invalid
646*/
647int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product,
648 const char* description, const char* serial, unsigned int index)
649{
650 libusb_device *dev;
651 libusb_device **devs;
652 char string[256];
653 int i = 0;
654
655 if (ftdi == NULL)
656 ftdi_error_return(-11, "ftdi context invalid");
657
658 if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
659 ftdi_error_return(-12, "libusb_get_device_list() failed");
660
661 while ((dev = devs[i++]) != NULL)
662 {
663 struct libusb_device_descriptor desc;
664 int res;
665
666 if (libusb_get_device_descriptor(dev, &desc) < 0)
667 ftdi_error_return_free_device_list(-13, "libusb_get_device_descriptor() failed", devs);
668
669 if (desc.idVendor == vendor && desc.idProduct == product)
670 {
671 if (libusb_open(dev, &ftdi->usb_dev) < 0)
672 ftdi_error_return_free_device_list(-4, "usb_open() failed", devs);
673
674 if (description != NULL)
675 {
676 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)string, sizeof(string)) < 0)
677 {
678 ftdi_usb_close_internal (ftdi);
679 ftdi_error_return_free_device_list(-8, "unable to fetch product description", devs);
680 }
681 if (strncmp(string, description, sizeof(string)) != 0)
682 {
683 ftdi_usb_close_internal (ftdi);
684 continue;
685 }
686 }
687 if (serial != NULL)
688 {
689 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)string, sizeof(string)) < 0)
690 {
691 ftdi_usb_close_internal (ftdi);
692 ftdi_error_return_free_device_list(-9, "unable to fetch serial number", devs);
693 }
694 if (strncmp(string, serial, sizeof(string)) != 0)
695 {
696 ftdi_usb_close_internal (ftdi);
697 continue;
698 }
699 }
700
701 ftdi_usb_close_internal (ftdi);
702
703 if (index > 0)
704 {
705 index--;
706 continue;
707 }
708
709 res = ftdi_usb_open_dev(ftdi, dev);
710 libusb_free_device_list(devs,1);
711 return res;
712 }
713 }
714
715 // device not found
716 ftdi_error_return_free_device_list(-3, "device not found", devs);
717}
718
719/**
720 Opens the ftdi-device described by a description-string.
721 Intended to be used for parsing a device-description given as commandline argument.
722
723 \param ftdi pointer to ftdi_context
724 \param description NULL-terminated description-string, using this format:
725 \li <tt>d:\<devicenode></tt> path of bus and device-node (e.g. "003/001") within usb device tree (usually at /proc/bus/usb/)
726 \li <tt>i:\<vendor>:\<product></tt> first device with given vendor and product id, ids can be decimal, octal (preceded by "0") or hex (preceded by "0x")
727 \li <tt>i:\<vendor>:\<product>:\<index></tt> as above with index being the number of the device (starting with 0) if there are more than one
728 \li <tt>s:\<vendor>:\<product>:\<serial></tt> first device with given vendor id, product id and serial string
729
730 \note The description format may be extended in later versions.
731
732 \retval 0: all fine
733 \retval -2: libusb_get_device_list() failed
734 \retval -3: usb device not found
735 \retval -4: unable to open device
736 \retval -5: unable to claim device
737 \retval -6: reset failed
738 \retval -7: set baudrate failed
739 \retval -8: get product description failed
740 \retval -9: get serial number failed
741 \retval -10: unable to close device
742 \retval -11: illegal description format
743 \retval -12: ftdi context invalid
744*/
745int ftdi_usb_open_string(struct ftdi_context *ftdi, const char* description)
746{
747 if (ftdi == NULL)
748 ftdi_error_return(-12, "ftdi context invalid");
749
750 if (description[0] == 0 || description[1] != ':')
751 ftdi_error_return(-11, "illegal description format");
752
753 if (description[0] == 'd')
754 {
755 libusb_device *dev;
756 libusb_device **devs;
757 unsigned int bus_number, device_address;
758 int i = 0;
759
760 if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
761 ftdi_error_return(-2, "libusb_get_device_list() failed");
762
763 /* XXX: This doesn't handle symlinks/odd paths/etc... */
764 if (sscanf (description + 2, "%u/%u", &bus_number, &device_address) != 2)
765 ftdi_error_return_free_device_list(-11, "illegal description format", devs);
766
767 while ((dev = devs[i++]) != NULL)
768 {
769 int ret;
770 if (bus_number == libusb_get_bus_number (dev)
771 && device_address == libusb_get_device_address (dev))
772 {
773 ret = ftdi_usb_open_dev(ftdi, dev);
774 libusb_free_device_list(devs,1);
775 return ret;
776 }
777 }
778
779 // device not found
780 ftdi_error_return_free_device_list(-3, "device not found", devs);
781 }
782 else if (description[0] == 'i' || description[0] == 's')
783 {
784 unsigned int vendor;
785 unsigned int product;
786 unsigned int index=0;
787 const char *serial=NULL;
788 const char *startp, *endp;
789
790 errno=0;
791 startp=description+2;
792 vendor=strtoul((char*)startp,(char**)&endp,0);
793 if (*endp != ':' || endp == startp || errno != 0)
794 ftdi_error_return(-11, "illegal description format");
795
796 startp=endp+1;
797 product=strtoul((char*)startp,(char**)&endp,0);
798 if (endp == startp || errno != 0)
799 ftdi_error_return(-11, "illegal description format");
800
801 if (description[0] == 'i' && *endp != 0)
802 {
803 /* optional index field in i-mode */
804 if (*endp != ':')
805 ftdi_error_return(-11, "illegal description format");
806
807 startp=endp+1;
808 index=strtoul((char*)startp,(char**)&endp,0);
809 if (*endp != 0 || endp == startp || errno != 0)
810 ftdi_error_return(-11, "illegal description format");
811 }
812 if (description[0] == 's')
813 {
814 if (*endp != ':')
815 ftdi_error_return(-11, "illegal description format");
816
817 /* rest of the description is the serial */
818 serial=endp+1;
819 }
820
821 return ftdi_usb_open_desc_index(ftdi, vendor, product, NULL, serial, index);
822 }
823 else
824 {
825 ftdi_error_return(-11, "illegal description format");
826 }
827}
828
829/**
830 Resets the ftdi device.
831
832 \param ftdi pointer to ftdi_context
833
834 \retval 0: all fine
835 \retval -1: FTDI reset failed
836 \retval -2: USB device unavailable
837*/
838int ftdi_usb_reset(struct ftdi_context *ftdi)
839{
840 if (ftdi == NULL || ftdi->usb_dev == NULL)
841 ftdi_error_return(-2, "USB device unavailable");
842
843 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
844 SIO_RESET_REQUEST, SIO_RESET_SIO,
845 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
846 ftdi_error_return(-1,"FTDI reset failed");
847
848 // Invalidate data in the readbuffer
849 ftdi->readbuffer_offset = 0;
850 ftdi->readbuffer_remaining = 0;
851
852 return 0;
853}
854
855/**
856 Clears the read buffer on the chip and the internal read buffer.
857
858 \param ftdi pointer to ftdi_context
859
860 \retval 0: all fine
861 \retval -1: read buffer purge failed
862 \retval -2: USB device unavailable
863*/
864int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
865{
866 if (ftdi == NULL || ftdi->usb_dev == NULL)
867 ftdi_error_return(-2, "USB device unavailable");
868
869 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
870 SIO_RESET_REQUEST, SIO_RESET_PURGE_RX,
871 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
872 ftdi_error_return(-1, "FTDI purge of RX buffer failed");
873
874 // Invalidate data in the readbuffer
875 ftdi->readbuffer_offset = 0;
876 ftdi->readbuffer_remaining = 0;
877
878 return 0;
879}
880
881/**
882 Clears the write buffer on the chip.
883
884 \param ftdi pointer to ftdi_context
885
886 \retval 0: all fine
887 \retval -1: write buffer purge failed
888 \retval -2: USB device unavailable
889*/
890int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
891{
892 if (ftdi == NULL || ftdi->usb_dev == NULL)
893 ftdi_error_return(-2, "USB device unavailable");
894
895 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
896 SIO_RESET_REQUEST, SIO_RESET_PURGE_TX,
897 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
898 ftdi_error_return(-1, "FTDI purge of TX buffer failed");
899
900 return 0;
901}
902
903/**
904 Clears the buffers on the chip and the internal read buffer.
905
906 \param ftdi pointer to ftdi_context
907
908 \retval 0: all fine
909 \retval -1: read buffer purge failed
910 \retval -2: write buffer purge failed
911 \retval -3: USB device unavailable
912*/
913int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
914{
915 int result;
916
917 if (ftdi == NULL || ftdi->usb_dev == NULL)
918 ftdi_error_return(-3, "USB device unavailable");
919
920 result = ftdi_usb_purge_rx_buffer(ftdi);
921 if (result < 0)
922 return -1;
923
924 result = ftdi_usb_purge_tx_buffer(ftdi);
925 if (result < 0)
926 return -2;
927
928 return 0;
929}
930
931
932
933/**
934 Closes the ftdi device. Call ftdi_deinit() if you're cleaning up.
935
936 \param ftdi pointer to ftdi_context
937
938 \retval 0: all fine
939 \retval -1: usb_release failed
940 \retval -3: ftdi context invalid
941*/
942int ftdi_usb_close(struct ftdi_context *ftdi)
943{
944 int rtn = 0;
945
946 if (ftdi == NULL)
947 ftdi_error_return(-3, "ftdi context invalid");
948
949 if (ftdi->usb_dev != NULL)
950 if (libusb_release_interface(ftdi->usb_dev, ftdi->interface) < 0)
951 rtn = -1;
952
953 ftdi_usb_close_internal (ftdi);
954
955 return rtn;
956}
957
958/**
959 ftdi_convert_baudrate returns nearest supported baud rate to that requested.
960 Function is only used internally
961 \internal
962*/
963static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
964 unsigned short *value, unsigned short *index)
965{
966 static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
967 static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
968 static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
969 int divisor, best_divisor, best_baud, best_baud_diff;
970 unsigned long encoded_divisor;
971 int i;
972
973 if (baudrate <= 0)
974 {
975 // Return error
976 return -1;
977 }
978
979 divisor = 24000000 / baudrate;
980
981 if (ftdi->type == TYPE_AM)
982 {
983 // Round down to supported fraction (AM only)
984 divisor -= am_adjust_dn[divisor & 7];
985 }
986
987 // Try this divisor and the one above it (because division rounds down)
988 best_divisor = 0;
989 best_baud = 0;
990 best_baud_diff = 0;
991 for (i = 0; i < 2; i++)
992 {
993 int try_divisor = divisor + i;
994 int baud_estimate;
995 int baud_diff;
996
997 // Round up to supported divisor value
998 if (try_divisor <= 8)
999 {
1000 // Round up to minimum supported divisor
1001 try_divisor = 8;
1002 }
1003 else if (ftdi->type != TYPE_AM && try_divisor < 12)
1004 {
1005 // BM doesn't support divisors 9 through 11 inclusive
1006 try_divisor = 12;
1007 }
1008 else if (divisor < 16)
1009 {
1010 // AM doesn't support divisors 9 through 15 inclusive
1011 try_divisor = 16;
1012 }
1013 else
1014 {
1015 if (ftdi->type == TYPE_AM)
1016 {
1017 // Round up to supported fraction (AM only)
1018 try_divisor += am_adjust_up[try_divisor & 7];
1019 if (try_divisor > 0x1FFF8)
1020 {
1021 // Round down to maximum supported divisor value (for AM)
1022 try_divisor = 0x1FFF8;
1023 }
1024 }
1025 else
1026 {
1027 if (try_divisor > 0x1FFFF)
1028 {
1029 // Round down to maximum supported divisor value (for BM)
1030 try_divisor = 0x1FFFF;
1031 }
1032 }
1033 }
1034 // Get estimated baud rate (to nearest integer)
1035 baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
1036 // Get absolute difference from requested baud rate
1037 if (baud_estimate < baudrate)
1038 {
1039 baud_diff = baudrate - baud_estimate;
1040 }
1041 else
1042 {
1043 baud_diff = baud_estimate - baudrate;
1044 }
1045 if (i == 0 || baud_diff < best_baud_diff)
1046 {
1047 // Closest to requested baud rate so far
1048 best_divisor = try_divisor;
1049 best_baud = baud_estimate;
1050 best_baud_diff = baud_diff;
1051 if (baud_diff == 0)
1052 {
1053 // Spot on! No point trying
1054 break;
1055 }
1056 }
1057 }
1058 // Encode the best divisor value
1059 encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
1060 // Deal with special cases for encoded value
1061 if (encoded_divisor == 1)
1062 {
1063 encoded_divisor = 0; // 3000000 baud
1064 }
1065 else if (encoded_divisor == 0x4001)
1066 {
1067 encoded_divisor = 1; // 2000000 baud (BM only)
1068 }
1069 // Split into "value" and "index" values
1070 *value = (unsigned short)(encoded_divisor & 0xFFFF);
1071 if (ftdi->type == TYPE_2232C || ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H)
1072 {
1073 *index = (unsigned short)(encoded_divisor >> 8);
1074 *index &= 0xFF00;
1075 *index |= ftdi->index;
1076 }
1077 else
1078 *index = (unsigned short)(encoded_divisor >> 16);
1079
1080 // Return the nearest baud rate
1081 return best_baud;
1082}
1083
1084/**
1085 Sets the chip baud rate
1086
1087 \param ftdi pointer to ftdi_context
1088 \param baudrate baud rate to set
1089
1090 \retval 0: all fine
1091 \retval -1: invalid baudrate
1092 \retval -2: setting baudrate failed
1093 \retval -3: USB device unavailable
1094*/
1095int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
1096{
1097 unsigned short value, index;
1098 int actual_baudrate;
1099
1100 if (ftdi == NULL || ftdi->usb_dev == NULL)
1101 ftdi_error_return(-3, "USB device unavailable");
1102
1103 if (ftdi->bitbang_enabled)
1104 {
1105 baudrate = baudrate*4;
1106 }
1107
1108 actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
1109 if (actual_baudrate <= 0)
1110 ftdi_error_return (-1, "Silly baudrate <= 0.");
1111
1112 // Check within tolerance (about 5%)
1113 if ((actual_baudrate * 2 < baudrate /* Catch overflows */ )
1114 || ((actual_baudrate < baudrate)
1115 ? (actual_baudrate * 21 < baudrate * 20)
1116 : (baudrate * 21 < actual_baudrate * 20)))
1117 ftdi_error_return (-1, "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4");
1118
1119 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1120 SIO_SET_BAUDRATE_REQUEST, value,
1121 index, NULL, 0, ftdi->usb_write_timeout) < 0)
1122 ftdi_error_return (-2, "Setting new baudrate failed");
1123
1124 ftdi->baudrate = baudrate;
1125 return 0;
1126}
1127
1128/**
1129 Set (RS232) line characteristics.
1130 The break type can only be set via ftdi_set_line_property2()
1131 and defaults to "off".
1132
1133 \param ftdi pointer to ftdi_context
1134 \param bits Number of bits
1135 \param sbit Number of stop bits
1136 \param parity Parity mode
1137
1138 \retval 0: all fine
1139 \retval -1: Setting line property failed
1140*/
1141int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
1142 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
1143{
1144 return ftdi_set_line_property2(ftdi, bits, sbit, parity, BREAK_OFF);
1145}
1146
1147/**
1148 Set (RS232) line characteristics
1149
1150 \param ftdi pointer to ftdi_context
1151 \param bits Number of bits
1152 \param sbit Number of stop bits
1153 \param parity Parity mode
1154 \param break_type Break type
1155
1156 \retval 0: all fine
1157 \retval -1: Setting line property failed
1158 \retval -2: USB device unavailable
1159*/
1160int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
1161 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity,
1162 enum ftdi_break_type break_type)
1163{
1164 unsigned short value = bits;
1165
1166 if (ftdi == NULL || ftdi->usb_dev == NULL)
1167 ftdi_error_return(-2, "USB device unavailable");
1168
1169 switch (parity)
1170 {
1171 case NONE:
1172 value |= (0x00 << 8);
1173 break;
1174 case ODD:
1175 value |= (0x01 << 8);
1176 break;
1177 case EVEN:
1178 value |= (0x02 << 8);
1179 break;
1180 case MARK:
1181 value |= (0x03 << 8);
1182 break;
1183 case SPACE:
1184 value |= (0x04 << 8);
1185 break;
1186 }
1187
1188 switch (sbit)
1189 {
1190 case STOP_BIT_1:
1191 value |= (0x00 << 11);
1192 break;
1193 case STOP_BIT_15:
1194 value |= (0x01 << 11);
1195 break;
1196 case STOP_BIT_2:
1197 value |= (0x02 << 11);
1198 break;
1199 }
1200
1201 switch (break_type)
1202 {
1203 case BREAK_OFF:
1204 value |= (0x00 << 14);
1205 break;
1206 case BREAK_ON:
1207 value |= (0x01 << 14);
1208 break;
1209 }
1210
1211 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1212 SIO_SET_DATA_REQUEST, value,
1213 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1214 ftdi_error_return (-1, "Setting new line property failed");
1215
1216 return 0;
1217}
1218
1219/**
1220 Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip
1221
1222 \param ftdi pointer to ftdi_context
1223 \param buf Buffer with the data
1224 \param size Size of the buffer
1225
1226 \retval -666: USB device unavailable
1227 \retval <0: error code from usb_bulk_write()
1228 \retval >0: number of bytes written
1229*/
1230int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1231{
1232 int offset = 0;
1233 int actual_length;
1234
1235 if (ftdi == NULL || ftdi->usb_dev == NULL)
1236 ftdi_error_return(-666, "USB device unavailable");
1237
1238 while (offset < size)
1239 {
1240 int write_size = ftdi->writebuffer_chunksize;
1241
1242 if (offset+write_size > size)
1243 write_size = size-offset;
1244
1245 if (libusb_bulk_transfer(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, &actual_length, ftdi->usb_write_timeout) < 0)
1246 ftdi_error_return(-1, "usb bulk write failed");
1247
1248 offset += actual_length;
1249 }
1250
1251 return offset;
1252}
1253
1254static void ftdi_read_data_cb(struct libusb_transfer *transfer)
1255{
1256 struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1257 struct ftdi_context *ftdi = tc->ftdi;
1258 int packet_size, actual_length, num_of_chunks, chunk_remains, i, ret;
1259
1260 packet_size = ftdi->max_packet_size;
1261
1262 actual_length = transfer->actual_length;
1263
1264 if (actual_length > 2)
1265 {
1266 // skip FTDI status bytes.
1267 // Maybe stored in the future to enable modem use
1268 num_of_chunks = actual_length / packet_size;
1269 chunk_remains = actual_length % packet_size;
1270 //printf("actual_length = %X, num_of_chunks = %X, chunk_remains = %X, readbuffer_offset = %X\n", actual_length, num_of_chunks, chunk_remains, ftdi->readbuffer_offset);
1271
1272 ftdi->readbuffer_offset += 2;
1273 actual_length -= 2;
1274
1275 if (actual_length > packet_size - 2)
1276 {
1277 for (i = 1; i < num_of_chunks; i++)
1278 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1279 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1280 packet_size - 2);
1281 if (chunk_remains > 2)
1282 {
1283 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1284 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1285 chunk_remains-2);
1286 actual_length -= 2*num_of_chunks;
1287 }
1288 else
1289 actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1290 }
1291
1292 if (actual_length > 0)
1293 {
1294 // data still fits in buf?
1295 if (tc->offset + actual_length <= tc->size)
1296 {
1297 memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, actual_length);
1298 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1299 tc->offset += actual_length;
1300
1301 ftdi->readbuffer_offset = 0;
1302 ftdi->readbuffer_remaining = 0;
1303
1304 /* Did we read exactly the right amount of bytes? */
1305 if (tc->offset == tc->size)
1306 {
1307 //printf("read_data exact rem %d offset %d\n",
1308 //ftdi->readbuffer_remaining, offset);
1309 tc->completed = 1;
1310 return;
1311 }
1312 }
1313 else
1314 {
1315 // only copy part of the data or size <= readbuffer_chunksize
1316 int part_size = tc->size - tc->offset;
1317 memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, part_size);
1318 tc->offset += part_size;
1319
1320 ftdi->readbuffer_offset += part_size;
1321 ftdi->readbuffer_remaining = actual_length - part_size;
1322
1323 /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1324 part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
1325 tc->completed = 1;
1326 return;
1327 }
1328 }
1329 }
1330 ret = libusb_submit_transfer (transfer);
1331 if (ret < 0)
1332 tc->completed = 1;
1333}
1334
1335
1336static void ftdi_write_data_cb(struct libusb_transfer *transfer)
1337{
1338 struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1339 struct ftdi_context *ftdi = tc->ftdi;
1340
1341 tc->offset += transfer->actual_length;
1342
1343 if (tc->offset == tc->size)
1344 {
1345 tc->completed = 1;
1346 }
1347 else
1348 {
1349 int write_size = ftdi->writebuffer_chunksize;
1350 int ret;
1351
1352 if (tc->offset + write_size > tc->size)
1353 write_size = tc->size - tc->offset;
1354
1355 transfer->length = write_size;
1356 transfer->buffer = tc->buf + tc->offset;
1357 ret = libusb_submit_transfer (transfer);
1358 if (ret < 0)
1359 tc->completed = 1;
1360 }
1361}
1362
1363
1364/**
1365 Writes data to the chip. Does not wait for completion of the transfer
1366 nor does it make sure that the transfer was successful.
1367
1368 Use libusb 1.0 asynchronous API.
1369
1370 \param ftdi pointer to ftdi_context
1371 \param buf Buffer with the data
1372 \param size Size of the buffer
1373
1374 \retval NULL: Some error happens when submit transfer
1375 \retval !NULL: Pointer to a ftdi_transfer_control
1376*/
1377
1378struct ftdi_transfer_control *ftdi_write_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
1379{
1380 struct ftdi_transfer_control *tc;
1381 struct libusb_transfer *transfer;
1382 int write_size, ret;
1383
1384 if (ftdi == NULL || ftdi->usb_dev == NULL)
1385 return NULL;
1386
1387 tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
1388 if (!tc)
1389 return NULL;
1390
1391 transfer = libusb_alloc_transfer(0);
1392 if (!transfer)
1393 {
1394 free(tc);
1395 return NULL;
1396 }
1397
1398 tc->ftdi = ftdi;
1399 tc->completed = 0;
1400 tc->buf = buf;
1401 tc->size = size;
1402 tc->offset = 0;
1403
1404 if (size < ftdi->writebuffer_chunksize)
1405 write_size = size;
1406 else
1407 write_size = ftdi->writebuffer_chunksize;
1408
1409 libusb_fill_bulk_transfer(transfer, ftdi->usb_dev, ftdi->in_ep, buf,
1410 write_size, ftdi_write_data_cb, tc,
1411 ftdi->usb_write_timeout);
1412 transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1413
1414 ret = libusb_submit_transfer(transfer);
1415 if (ret < 0)
1416 {
1417 libusb_free_transfer(transfer);
1418 free(tc);
1419 return NULL;
1420 }
1421 tc->transfer = transfer;
1422
1423 return tc;
1424}
1425
1426/**
1427 Reads data from the chip. Does not wait for completion of the transfer
1428 nor does it make sure that the transfer was successful.
1429
1430 Use libusb 1.0 asynchronous API.
1431
1432 \param ftdi pointer to ftdi_context
1433 \param buf Buffer with the data
1434 \param size Size of the buffer
1435
1436 \retval NULL: Some error happens when submit transfer
1437 \retval !NULL: Pointer to a ftdi_transfer_control
1438*/
1439
1440struct ftdi_transfer_control *ftdi_read_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
1441{
1442 struct ftdi_transfer_control *tc;
1443 struct libusb_transfer *transfer;
1444 int ret;
1445
1446 if (ftdi == NULL || ftdi->usb_dev == NULL)
1447 return NULL;
1448
1449 tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
1450 if (!tc)
1451 return NULL;
1452
1453 tc->ftdi = ftdi;
1454 tc->buf = buf;
1455 tc->size = size;
1456
1457 if (size <= ftdi->readbuffer_remaining)
1458 {
1459 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1460
1461 // Fix offsets
1462 ftdi->readbuffer_remaining -= size;
1463 ftdi->readbuffer_offset += size;
1464
1465 /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1466
1467 tc->completed = 1;
1468 tc->offset = size;
1469 tc->transfer = NULL;
1470 return tc;
1471 }
1472
1473 tc->completed = 0;
1474 if (ftdi->readbuffer_remaining != 0)
1475 {
1476 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1477
1478 tc->offset = ftdi->readbuffer_remaining;
1479 }
1480 else
1481 tc->offset = 0;
1482
1483 transfer = libusb_alloc_transfer(0);
1484 if (!transfer)
1485 {
1486 free (tc);
1487 return NULL;
1488 }
1489
1490 ftdi->readbuffer_remaining = 0;
1491 ftdi->readbuffer_offset = 0;
1492
1493 libusb_fill_bulk_transfer(transfer, ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, ftdi_read_data_cb, tc, ftdi->usb_read_timeout);
1494 transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1495
1496 ret = libusb_submit_transfer(transfer);
1497 if (ret < 0)
1498 {
1499 libusb_free_transfer(transfer);
1500 free (tc);
1501 return NULL;
1502 }
1503 tc->transfer = transfer;
1504
1505 return tc;
1506}
1507
1508/**
1509 Wait for completion of the transfer.
1510
1511 Use libusb 1.0 asynchronous API.
1512
1513 \param tc pointer to ftdi_transfer_control
1514
1515 \retval < 0: Some error happens
1516 \retval >= 0: Data size transferred
1517*/
1518
1519int ftdi_transfer_data_done(struct ftdi_transfer_control *tc)
1520{
1521 int ret;
1522
1523 while (!tc->completed)
1524 {
1525 ret = libusb_handle_events(tc->ftdi->usb_ctx);
1526 if (ret < 0)
1527 {
1528 if (ret == LIBUSB_ERROR_INTERRUPTED)
1529 continue;
1530 libusb_cancel_transfer(tc->transfer);
1531 while (!tc->completed)
1532 if (libusb_handle_events(tc->ftdi->usb_ctx) < 0)
1533 break;
1534 libusb_free_transfer(tc->transfer);
1535 free (tc);
1536 return ret;
1537 }
1538 }
1539
1540 ret = tc->offset;
1541 /**
1542 * tc->transfer could be NULL if "(size <= ftdi->readbuffer_remaining)"
1543 * at ftdi_read_data_submit(). Therefore, we need to check it here.
1544 **/
1545 if (tc->transfer)
1546 {
1547 if (tc->transfer->status != LIBUSB_TRANSFER_COMPLETED)
1548 ret = -1;
1549 libusb_free_transfer(tc->transfer);
1550 }
1551 free(tc);
1552 return ret;
1553}
1554
1555/**
1556 Configure write buffer chunk size.
1557 Default is 4096.
1558
1559 \param ftdi pointer to ftdi_context
1560 \param chunksize Chunk size
1561
1562 \retval 0: all fine
1563 \retval -1: ftdi context invalid
1564*/
1565int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1566{
1567 if (ftdi == NULL)
1568 ftdi_error_return(-1, "ftdi context invalid");
1569
1570 ftdi->writebuffer_chunksize = chunksize;
1571 return 0;
1572}
1573
1574/**
1575 Get write buffer chunk size.
1576
1577 \param ftdi pointer to ftdi_context
1578 \param chunksize Pointer to store chunk size in
1579
1580 \retval 0: all fine
1581 \retval -1: ftdi context invalid
1582*/
1583int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1584{
1585 if (ftdi == NULL)
1586 ftdi_error_return(-1, "ftdi context invalid");
1587
1588 *chunksize = ftdi->writebuffer_chunksize;
1589 return 0;
1590}
1591
1592/**
1593 Reads data in chunks (see ftdi_read_data_set_chunksize()) from the chip.
1594
1595 Automatically strips the two modem status bytes transfered during every read.
1596
1597 \param ftdi pointer to ftdi_context
1598 \param buf Buffer to store data in
1599 \param size Size of the buffer
1600
1601 \retval -666: USB device unavailable
1602 \retval <0: error code from libusb_bulk_transfer()
1603 \retval 0: no data was available
1604 \retval >0: number of bytes read
1605
1606*/
1607int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1608{
1609 int offset = 0, ret, i, num_of_chunks, chunk_remains;
1610 int packet_size = ftdi->max_packet_size;
1611 int actual_length = 1;
1612
1613 if (ftdi == NULL || ftdi->usb_dev == NULL)
1614 ftdi_error_return(-666, "USB device unavailable");
1615
1616 // Packet size sanity check (avoid division by zero)
1617 if (packet_size == 0)
1618 ftdi_error_return(-1, "max_packet_size is bogus (zero)");
1619
1620 // everything we want is still in the readbuffer?
1621 if (size <= ftdi->readbuffer_remaining)
1622 {
1623 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1624
1625 // Fix offsets
1626 ftdi->readbuffer_remaining -= size;
1627 ftdi->readbuffer_offset += size;
1628
1629 /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1630
1631 return size;
1632 }
1633 // something still in the readbuffer, but not enough to satisfy 'size'?
1634 if (ftdi->readbuffer_remaining != 0)
1635 {
1636 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1637
1638 // Fix offset
1639 offset += ftdi->readbuffer_remaining;
1640 }
1641 // do the actual USB read
1642 while (offset < size && actual_length > 0)
1643 {
1644 ftdi->readbuffer_remaining = 0;
1645 ftdi->readbuffer_offset = 0;
1646 /* returns how much received */
1647 ret = libusb_bulk_transfer (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, &actual_length, ftdi->usb_read_timeout);
1648 if (ret < 0)
1649 ftdi_error_return(ret, "usb bulk read failed");
1650
1651 if (actual_length > 2)
1652 {
1653 // skip FTDI status bytes.
1654 // Maybe stored in the future to enable modem use
1655 num_of_chunks = actual_length / packet_size;
1656 chunk_remains = actual_length % packet_size;
1657 //printf("actual_length = %X, num_of_chunks = %X, chunk_remains = %X, readbuffer_offset = %X\n", actual_length, num_of_chunks, chunk_remains, ftdi->readbuffer_offset);
1658
1659 ftdi->readbuffer_offset += 2;
1660 actual_length -= 2;
1661
1662 if (actual_length > packet_size - 2)
1663 {
1664 for (i = 1; i < num_of_chunks; i++)
1665 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1666 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1667 packet_size - 2);
1668 if (chunk_remains > 2)
1669 {
1670 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1671 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1672 chunk_remains-2);
1673 actual_length -= 2*num_of_chunks;
1674 }
1675 else
1676 actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1677 }
1678 }
1679 else if (actual_length <= 2)
1680 {
1681 // no more data to read?
1682 return offset;
1683 }
1684 if (actual_length > 0)
1685 {
1686 // data still fits in buf?
1687 if (offset+actual_length <= size)
1688 {
1689 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, actual_length);
1690 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1691 offset += actual_length;
1692
1693 /* Did we read exactly the right amount of bytes? */
1694 if (offset == size)
1695 //printf("read_data exact rem %d offset %d\n",
1696 //ftdi->readbuffer_remaining, offset);
1697 return offset;
1698 }
1699 else
1700 {
1701 // only copy part of the data or size <= readbuffer_chunksize
1702 int part_size = size-offset;
1703 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
1704
1705 ftdi->readbuffer_offset += part_size;
1706 ftdi->readbuffer_remaining = actual_length-part_size;
1707 offset += part_size;
1708
1709 /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1710 part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
1711
1712 return offset;
1713 }
1714 }
1715 }
1716 // never reached
1717 return -127;
1718}
1719
1720/**
1721 Configure read buffer chunk size.
1722 Default is 4096.
1723
1724 Automatically reallocates the buffer.
1725
1726 \param ftdi pointer to ftdi_context
1727 \param chunksize Chunk size
1728
1729 \retval 0: all fine
1730 \retval -1: ftdi context invalid
1731*/
1732int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1733{
1734 unsigned char *new_buf;
1735
1736 if (ftdi == NULL)
1737 ftdi_error_return(-1, "ftdi context invalid");
1738
1739 // Invalidate all remaining data
1740 ftdi->readbuffer_offset = 0;
1741 ftdi->readbuffer_remaining = 0;
1742#ifdef __linux__
1743 /* We can't set readbuffer_chunksize larger than MAX_BULK_BUFFER_LENGTH,
1744 which is defined in libusb-1.0. Otherwise, each USB read request will
1745 be divided into multiple URBs. This will cause issues on Linux kernel
1746 older than 2.6.32. */
1747 if (chunksize > 16384)
1748 chunksize = 16384;
1749#endif
1750
1751 if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL)
1752 ftdi_error_return(-1, "out of memory for readbuffer");
1753
1754 ftdi->readbuffer = new_buf;
1755 ftdi->readbuffer_chunksize = chunksize;
1756
1757 return 0;
1758}
1759
1760/**
1761 Get read buffer chunk size.
1762
1763 \param ftdi pointer to ftdi_context
1764 \param chunksize Pointer to store chunk size in
1765
1766 \retval 0: all fine
1767 \retval -1: FTDI context invalid
1768*/
1769int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1770{
1771 if (ftdi == NULL)
1772 ftdi_error_return(-1, "FTDI context invalid");
1773
1774 *chunksize = ftdi->readbuffer_chunksize;
1775 return 0;
1776}
1777
1778
1779/**
1780 Enable bitbang mode.
1781
1782 \deprecated use \ref ftdi_set_bitmode with mode BITMODE_BITBANG instead
1783
1784 \param ftdi pointer to ftdi_context
1785 \param bitmask Bitmask to configure lines.
1786 HIGH/ON value configures a line as output.
1787
1788 \retval 0: all fine
1789 \retval -1: can't enable bitbang mode
1790 \retval -2: USB device unavailable
1791*/
1792int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask)
1793{
1794 unsigned short usb_val;
1795
1796 if (ftdi == NULL || ftdi->usb_dev == NULL)
1797 ftdi_error_return(-2, "USB device unavailable");
1798
1799 usb_val = bitmask; // low byte: bitmask
1800 /* FT2232C: Set bitbang_mode to 2 to enable SPI */
1801 usb_val |= (ftdi->bitbang_mode << 8);
1802
1803 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1804 SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index,
1805 NULL, 0, ftdi->usb_write_timeout) < 0)
1806 ftdi_error_return(-1, "unable to enter bitbang mode. Perhaps not a BM type chip?");
1807
1808 ftdi->bitbang_enabled = 1;
1809 return 0;
1810}
1811
1812/**
1813 Disable bitbang mode.
1814
1815 \param ftdi pointer to ftdi_context
1816
1817 \retval 0: all fine
1818 \retval -1: can't disable bitbang mode
1819 \retval -2: USB device unavailable
1820*/
1821int ftdi_disable_bitbang(struct ftdi_context *ftdi)
1822{
1823 if (ftdi == NULL || ftdi->usb_dev == NULL)
1824 ftdi_error_return(-2, "USB device unavailable");
1825
1826 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_BITMODE_REQUEST, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1827 ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?");
1828
1829 ftdi->bitbang_enabled = 0;
1830 return 0;
1831}
1832
1833/**
1834 Enable/disable bitbang modes.
1835
1836 \param ftdi pointer to ftdi_context
1837 \param bitmask Bitmask to configure lines.
1838 HIGH/ON value configures a line as output.
1839 \param mode Bitbang mode: use the values defined in \ref ftdi_mpsse_mode
1840
1841 \retval 0: all fine
1842 \retval -1: can't enable bitbang mode
1843 \retval -2: USB device unavailable
1844*/
1845int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
1846{
1847 unsigned short usb_val;
1848
1849 if (ftdi == NULL || ftdi->usb_dev == NULL)
1850 ftdi_error_return(-2, "USB device unavailable");
1851
1852 usb_val = bitmask; // low byte: bitmask
1853 usb_val |= (mode << 8);
1854 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1855 ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps not a 2232C type chip?");
1856
1857 ftdi->bitbang_mode = mode;
1858 ftdi->bitbang_enabled = (mode == BITMODE_RESET) ? 0 : 1;
1859 return 0;
1860}
1861
1862/**
1863 Directly read pin state, circumventing the read buffer. Useful for bitbang mode.
1864
1865 \param ftdi pointer to ftdi_context
1866 \param pins Pointer to store pins into
1867
1868 \retval 0: all fine
1869 \retval -1: read pins failed
1870 \retval -2: USB device unavailable
1871*/
1872int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
1873{
1874 if (ftdi == NULL || ftdi->usb_dev == NULL)
1875 ftdi_error_return(-2, "USB device unavailable");
1876
1877 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_PINS_REQUEST, 0, ftdi->index, (unsigned char *)pins, 1, ftdi->usb_read_timeout) != 1)
1878 ftdi_error_return(-1, "read pins failed");
1879
1880 return 0;
1881}
1882
1883/**
1884 Set latency timer
1885
1886 The FTDI chip keeps data in the internal buffer for a specific
1887 amount of time if the buffer is not full yet to decrease
1888 load on the usb bus.
1889
1890 \param ftdi pointer to ftdi_context
1891 \param latency Value between 1 and 255
1892
1893 \retval 0: all fine
1894 \retval -1: latency out of range
1895 \retval -2: unable to set latency timer
1896 \retval -3: USB device unavailable
1897*/
1898int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
1899{
1900 unsigned short usb_val;
1901
1902 if (latency < 1)
1903 ftdi_error_return(-1, "latency out of range. Only valid for 1-255");
1904
1905 if (ftdi == NULL || ftdi->usb_dev == NULL)
1906 ftdi_error_return(-3, "USB device unavailable");
1907
1908 usb_val = latency;
1909 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_LATENCY_TIMER_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1910 ftdi_error_return(-2, "unable to set latency timer");
1911
1912 return 0;
1913}
1914
1915/**
1916 Get latency timer
1917
1918 \param ftdi pointer to ftdi_context
1919 \param latency Pointer to store latency value in
1920
1921 \retval 0: all fine
1922 \retval -1: unable to get latency timer
1923 \retval -2: USB device unavailable
1924*/
1925int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
1926{
1927 unsigned short usb_val;
1928
1929 if (ftdi == NULL || ftdi->usb_dev == NULL)
1930 ftdi_error_return(-2, "USB device unavailable");
1931
1932 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_GET_LATENCY_TIMER_REQUEST, 0, ftdi->index, (unsigned char *)&usb_val, 1, ftdi->usb_read_timeout) != 1)
1933 ftdi_error_return(-1, "reading latency timer failed");
1934
1935 *latency = (unsigned char)usb_val;
1936 return 0;
1937}
1938
1939/**
1940 Poll modem status information
1941
1942 This function allows the retrieve the two status bytes of the device.
1943 The device sends these bytes also as a header for each read access
1944 where they are discarded by ftdi_read_data(). The chip generates
1945 the two stripped status bytes in the absence of data every 40 ms.
1946
1947 Layout of the first byte:
1948 - B0..B3 - must be 0
1949 - B4 Clear to send (CTS)
1950 0 = inactive
1951 1 = active
1952 - B5 Data set ready (DTS)
1953 0 = inactive
1954 1 = active
1955 - B6 Ring indicator (RI)
1956 0 = inactive
1957 1 = active
1958 - B7 Receive line signal detect (RLSD)
1959 0 = inactive
1960 1 = active
1961
1962 Layout of the second byte:
1963 - B0 Data ready (DR)
1964 - B1 Overrun error (OE)
1965 - B2 Parity error (PE)
1966 - B3 Framing error (FE)
1967 - B4 Break interrupt (BI)
1968 - B5 Transmitter holding register (THRE)
1969 - B6 Transmitter empty (TEMT)
1970 - B7 Error in RCVR FIFO
1971
1972 \param ftdi pointer to ftdi_context
1973 \param status Pointer to store status information in. Must be two bytes.
1974
1975 \retval 0: all fine
1976 \retval -1: unable to retrieve status information
1977 \retval -2: USB device unavailable
1978*/
1979int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
1980{
1981 char usb_val[2];
1982
1983 if (ftdi == NULL || ftdi->usb_dev == NULL)
1984 ftdi_error_return(-2, "USB device unavailable");
1985
1986 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_POLL_MODEM_STATUS_REQUEST, 0, ftdi->index, (unsigned char *)usb_val, 2, ftdi->usb_read_timeout) != 2)
1987 ftdi_error_return(-1, "getting modem status failed");
1988
1989 *status = (usb_val[1] << 8) | (usb_val[0] & 0xFF);
1990
1991 return 0;
1992}
1993
1994/**
1995 Set flowcontrol for ftdi chip
1996
1997 \param ftdi pointer to ftdi_context
1998 \param flowctrl flow control to use. should be
1999 SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS or SIO_XON_XOFF_HS
2000
2001 \retval 0: all fine
2002 \retval -1: set flow control failed
2003 \retval -2: USB device unavailable
2004*/
2005int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
2006{
2007 if (ftdi == NULL || ftdi->usb_dev == NULL)
2008 ftdi_error_return(-2, "USB device unavailable");
2009
2010 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2011 SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->index),
2012 NULL, 0, ftdi->usb_write_timeout) < 0)
2013 ftdi_error_return(-1, "set flow control failed");
2014
2015 return 0;
2016}
2017
2018/**
2019 Set dtr line
2020
2021 \param ftdi pointer to ftdi_context
2022 \param state state to set line to (1 or 0)
2023
2024 \retval 0: all fine
2025 \retval -1: set dtr failed
2026 \retval -2: USB device unavailable
2027*/
2028int ftdi_setdtr(struct ftdi_context *ftdi, int state)
2029{
2030 unsigned short usb_val;
2031
2032 if (ftdi == NULL || ftdi->usb_dev == NULL)
2033 ftdi_error_return(-2, "USB device unavailable");
2034
2035 if (state)
2036 usb_val = SIO_SET_DTR_HIGH;
2037 else
2038 usb_val = SIO_SET_DTR_LOW;
2039
2040 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2041 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2042 NULL, 0, ftdi->usb_write_timeout) < 0)
2043 ftdi_error_return(-1, "set dtr failed");
2044
2045 return 0;
2046}
2047
2048/**
2049 Set rts line
2050
2051 \param ftdi pointer to ftdi_context
2052 \param state state to set line to (1 or 0)
2053
2054 \retval 0: all fine
2055 \retval -1: set rts failed
2056 \retval -2: USB device unavailable
2057*/
2058int ftdi_setrts(struct ftdi_context *ftdi, int state)
2059{
2060 unsigned short usb_val;
2061
2062 if (ftdi == NULL || ftdi->usb_dev == NULL)
2063 ftdi_error_return(-2, "USB device unavailable");
2064
2065 if (state)
2066 usb_val = SIO_SET_RTS_HIGH;
2067 else
2068 usb_val = SIO_SET_RTS_LOW;
2069
2070 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2071 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2072 NULL, 0, ftdi->usb_write_timeout) < 0)
2073 ftdi_error_return(-1, "set of rts failed");
2074
2075 return 0;
2076}
2077
2078/**
2079 Set dtr and rts line in one pass
2080
2081 \param ftdi pointer to ftdi_context
2082 \param dtr DTR state to set line to (1 or 0)
2083 \param rts RTS state to set line to (1 or 0)
2084
2085 \retval 0: all fine
2086 \retval -1: set dtr/rts failed
2087 \retval -2: USB device unavailable
2088 */
2089int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
2090{
2091 unsigned short usb_val;
2092
2093 if (ftdi == NULL || ftdi->usb_dev == NULL)
2094 ftdi_error_return(-2, "USB device unavailable");
2095
2096 if (dtr)
2097 usb_val = SIO_SET_DTR_HIGH;
2098 else
2099 usb_val = SIO_SET_DTR_LOW;
2100
2101 if (rts)
2102 usb_val |= SIO_SET_RTS_HIGH;
2103 else
2104 usb_val |= SIO_SET_RTS_LOW;
2105
2106 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2107 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2108 NULL, 0, ftdi->usb_write_timeout) < 0)
2109 ftdi_error_return(-1, "set of rts/dtr failed");
2110
2111 return 0;
2112}
2113
2114/**
2115 Set the special event character
2116
2117 \param ftdi pointer to ftdi_context
2118 \param eventch Event character
2119 \param enable 0 to disable the event character, non-zero otherwise
2120
2121 \retval 0: all fine
2122 \retval -1: unable to set event character
2123 \retval -2: USB device unavailable
2124*/
2125int ftdi_set_event_char(struct ftdi_context *ftdi,
2126 unsigned char eventch, unsigned char enable)
2127{
2128 unsigned short usb_val;
2129
2130 if (ftdi == NULL || ftdi->usb_dev == NULL)
2131 ftdi_error_return(-2, "USB device unavailable");
2132
2133 usb_val = eventch;
2134 if (enable)
2135 usb_val |= 1 << 8;
2136
2137 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_EVENT_CHAR_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
2138 ftdi_error_return(-1, "setting event character failed");
2139
2140 return 0;
2141}
2142
2143/**
2144 Set error character
2145
2146 \param ftdi pointer to ftdi_context
2147 \param errorch Error character
2148 \param enable 0 to disable the error character, non-zero otherwise
2149
2150 \retval 0: all fine
2151 \retval -1: unable to set error character
2152 \retval -2: USB device unavailable
2153*/
2154int ftdi_set_error_char(struct ftdi_context *ftdi,
2155 unsigned char errorch, unsigned char enable)
2156{
2157 unsigned short usb_val;
2158
2159 if (ftdi == NULL || ftdi->usb_dev == NULL)
2160 ftdi_error_return(-2, "USB device unavailable");
2161
2162 usb_val = errorch;
2163 if (enable)
2164 usb_val |= 1 << 8;
2165
2166 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_ERROR_CHAR_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
2167 ftdi_error_return(-1, "setting error character failed");
2168
2169 return 0;
2170}
2171
2172/**
2173 Init eeprom with default values.
2174 \param ftdi pointer to ftdi_context
2175 \param manufacturer String to use as Manufacturer
2176 \param product String to use as Product description
2177 \param serial String to use as Serial number description
2178
2179 \retval 0: all fine
2180 \retval -1: No struct ftdi_context
2181 \retval -2: No struct ftdi_eeprom
2182*/
2183int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer,
2184 char * product, char * serial)
2185{
2186 struct ftdi_eeprom *eeprom;
2187
2188 if (ftdi == NULL)
2189 ftdi_error_return(-1, "No struct ftdi_context");
2190
2191 if (ftdi->eeprom == NULL)
2192 ftdi_error_return(-2,"No struct ftdi_eeprom");
2193
2194 eeprom = ftdi->eeprom;
2195 memset(eeprom, 0, sizeof(struct ftdi_eeprom));
2196
2197 eeprom->vendor_id = 0x0403;
2198 eeprom->use_serial = USE_SERIAL_NUM;
2199 if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM) ||
2200 (ftdi->type == TYPE_R))
2201 eeprom->product_id = 0x6001;
2202 else if (ftdi->type == TYPE_4232H)
2203 eeprom->product_id = 0x6011;
2204 else if (ftdi->type == TYPE_232H)
2205 eeprom->product_id = 0x6014;
2206 else
2207 eeprom->product_id = 0x6010;
2208 if (ftdi->type == TYPE_AM)
2209 eeprom->usb_version = 0x0101;
2210 else
2211 eeprom->usb_version = 0x0200;
2212 eeprom->max_power = 100;
2213
2214 if (eeprom->manufacturer)
2215 free (eeprom->manufacturer);
2216 eeprom->manufacturer = NULL;
2217 if (manufacturer)
2218 {
2219 eeprom->manufacturer = malloc(strlen(manufacturer)+1);
2220 if (eeprom->manufacturer)
2221 strcpy(eeprom->manufacturer, manufacturer);
2222 }
2223
2224 if (eeprom->product)
2225 free (eeprom->product);
2226 eeprom->product = NULL;
2227 if(product)
2228 {
2229 eeprom->product = malloc(strlen(product)+1);
2230 if (eeprom->product)
2231 strcpy(eeprom->product, product);
2232 }
2233
2234 if (eeprom->serial)
2235 free (eeprom->serial);
2236 eeprom->serial = NULL;
2237 if (serial)
2238 {
2239 eeprom->serial = malloc(strlen(serial)+1);
2240 if (eeprom->serial)
2241 strcpy(eeprom->serial, serial);
2242 }
2243
2244
2245 if (ftdi->type == TYPE_R)
2246 {
2247 eeprom->max_power = 90;
2248 eeprom->size = 0x80;
2249 eeprom->cbus_function[0] = CBUS_TXLED;
2250 eeprom->cbus_function[1] = CBUS_RXLED;
2251 eeprom->cbus_function[2] = CBUS_TXDEN;
2252 eeprom->cbus_function[3] = CBUS_PWREN;
2253 eeprom->cbus_function[4] = CBUS_SLEEP;
2254 }
2255 else
2256 {
2257 if(ftdi->type == TYPE_232H)
2258 {
2259 int i;
2260 for (i=0; i<10; i++)
2261 eeprom->cbus_function[i] = CBUSH_TRISTATE;
2262 }
2263 eeprom->size = -1;
2264 }
2265 return 0;
2266}
2267/*FTD2XX doesn't check for values not fitting in the ACBUS Signal oprtions*/
2268void set_ft232h_cbus(struct ftdi_eeprom *eeprom, unsigned char * output)
2269{
2270 int i;
2271 for(i=0; i<5;i++)
2272 {
2273 int mode_low, mode_high;
2274 if (eeprom->cbus_function[2*i]> CBUSH_CLK7_5)
2275 mode_low = CBUSH_TRISTATE;
2276 else
2277 mode_low = eeprom->cbus_function[2*i];
2278 if (eeprom->cbus_function[2*i+1]> CBUSH_CLK7_5)
2279 mode_high = CBUSH_TRISTATE;
2280 else
2281 mode_high = eeprom->cbus_function[2*i];
2282
2283 output[0x18+i] = mode_high <<4 | mode_low;
2284 }
2285}
2286/**
2287 Build binary buffer from ftdi_eeprom structure.
2288 Output is suitable for ftdi_write_eeprom().
2289
2290 \param ftdi pointer to ftdi_context
2291
2292 \retval >=0: size of eeprom user area in bytes
2293 \retval -1: eeprom size (128 bytes) exceeded by custom strings
2294 \retval -2: Invalid eeprom or ftdi pointer
2295 \retval -3: Invalid cbus function setting (FIXME: Not in the code?)
2296 \retval -4: Chip doesn't support invert (FIXME: Not in the code?)
2297 \retval -5: Chip doesn't support high current drive (FIXME: Not in the code?)
2298 \retval -6: No connected EEPROM or EEPROM Type unknown
2299*/
2300int ftdi_eeprom_build(struct ftdi_context *ftdi)
2301{
2302 unsigned char i, j, eeprom_size_mask;
2303 unsigned short checksum, value;
2304 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2305 int user_area_size;
2306 struct ftdi_eeprom *eeprom;
2307 unsigned char * output;
2308
2309 if (ftdi == NULL)
2310 ftdi_error_return(-2,"No context");
2311 if (ftdi->eeprom == NULL)
2312 ftdi_error_return(-2,"No eeprom structure");
2313
2314 eeprom= ftdi->eeprom;
2315 output = eeprom->buf;
2316
2317 if (eeprom->chip == -1)
2318 ftdi_error_return(-6,"No connected EEPROM or EEPROM type unknown");
2319
2320 if ((eeprom->chip == 0x56) || (eeprom->chip == 0x66))
2321 eeprom->size = 0x100;
2322 else
2323 eeprom->size = 0x80;
2324
2325 if (eeprom->manufacturer != NULL)
2326 manufacturer_size = strlen(eeprom->manufacturer);
2327 if (eeprom->product != NULL)
2328 product_size = strlen(eeprom->product);
2329 if (eeprom->serial != NULL)
2330 serial_size = strlen(eeprom->serial);
2331
2332 // eeprom size check
2333 switch (ftdi->type)
2334 {
2335 case TYPE_AM:
2336 case TYPE_BM:
2337 user_area_size = 96; // base size for strings (total of 48 characters)
2338 break;
2339 case TYPE_2232C:
2340 user_area_size = 90; // two extra config bytes and 4 bytes PnP stuff
2341 break;
2342 case TYPE_R:
2343 user_area_size = 88; // four extra config bytes + 4 bytes PnP stuff
2344 break;
2345 case TYPE_2232H: // six extra config bytes + 4 bytes PnP stuff
2346 case TYPE_4232H:
2347 user_area_size = 86;
2348 break;
2349 default:
2350 user_area_size = 0;
2351 break;
2352 }
2353 user_area_size -= (manufacturer_size + product_size + serial_size) * 2;
2354
2355 if (user_area_size < 0)
2356 ftdi_error_return(-1,"eeprom size exceeded");
2357
2358 // empty eeprom
2359 memset (ftdi->eeprom->buf, 0, FTDI_MAX_EEPROM_SIZE);
2360
2361 // Bytes and Bits set for all Types
2362
2363 // Addr 02: Vendor ID
2364 output[0x02] = eeprom->vendor_id;
2365 output[0x03] = eeprom->vendor_id >> 8;
2366
2367 // Addr 04: Product ID
2368 output[0x04] = eeprom->product_id;
2369 output[0x05] = eeprom->product_id >> 8;
2370
2371 // Addr 06: Device release number (0400h for BM features)
2372 output[0x06] = 0x00;
2373 switch (ftdi->type)
2374 {
2375 case TYPE_AM:
2376 output[0x07] = 0x02;
2377 break;
2378 case TYPE_BM:
2379 output[0x07] = 0x04;
2380 break;
2381 case TYPE_2232C:
2382 output[0x07] = 0x05;
2383 break;
2384 case TYPE_R:
2385 output[0x07] = 0x06;
2386 break;
2387 case TYPE_2232H:
2388 output[0x07] = 0x07;
2389 break;
2390 case TYPE_4232H:
2391 output[0x07] = 0x08;
2392 break;
2393 case TYPE_232H:
2394 output[0x07] = 0x09;
2395 break;
2396 default:
2397 output[0x07] = 0x00;
2398 }
2399
2400 // Addr 08: Config descriptor
2401 // Bit 7: always 1
2402 // Bit 6: 1 if this device is self powered, 0 if bus powered
2403 // Bit 5: 1 if this device uses remote wakeup
2404 // Bit 4-0: reserved - 0
2405 j = 0x80;
2406 if (eeprom->self_powered == 1)
2407 j |= 0x40;
2408 if (eeprom->remote_wakeup == 1)
2409 j |= 0x20;
2410 output[0x08] = j;
2411
2412 // Addr 09: Max power consumption: max power = value * 2 mA
2413 output[0x09] = eeprom->max_power>>1;
2414
2415 if (ftdi->type != TYPE_AM)
2416 {
2417 // Addr 0A: Chip configuration
2418 // Bit 7: 0 - reserved
2419 // Bit 6: 0 - reserved
2420 // Bit 5: 0 - reserved
2421 // Bit 4: 1 - Change USB version
2422 // Bit 3: 1 - Use the serial number string
2423 // Bit 2: 1 - Enable suspend pull downs for lower power
2424 // Bit 1: 1 - Out EndPoint is Isochronous
2425 // Bit 0: 1 - In EndPoint is Isochronous
2426 //
2427 j = 0;
2428 if (eeprom->in_is_isochronous == 1)
2429 j = j | 1;
2430 if (eeprom->out_is_isochronous == 1)
2431 j = j | 2;
2432 output[0x0A] = j;
2433 }
2434
2435 // Dynamic content
2436 // Strings start at 0x94 (TYPE_AM, TYPE_BM)
2437 // 0x96 (TYPE_2232C), 0x98 (TYPE_R) and 0x9a (TYPE_x232H)
2438 // 0xa0 (TYPE_232H)
2439 i = 0;
2440 switch (ftdi->type)
2441 {
2442 case TYPE_232H:
2443 i += 2;
2444 case TYPE_2232H:
2445 case TYPE_4232H:
2446 i += 2;
2447 case TYPE_R:
2448 i += 2;
2449 case TYPE_2232C:
2450 i += 2;
2451 case TYPE_AM:
2452 case TYPE_BM:
2453 i += 0x94;
2454 }
2455 /* Wrap around 0x80 for 128 byte EEPROMS (Internale and 93x46) */
2456 eeprom_size_mask = eeprom->size -1;
2457
2458 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2459 // Addr 0F: Length of manufacturer string
2460 // Output manufacturer
2461 output[0x0E] = i; // calculate offset
2462 output[i & eeprom_size_mask] = manufacturer_size*2 + 2, i++;
2463 output[i & eeprom_size_mask] = 0x03, i++; // type: string
2464 for (j = 0; j < manufacturer_size; j++)
2465 {
2466 output[i & eeprom_size_mask] = eeprom->manufacturer[j], i++;
2467 output[i & eeprom_size_mask] = 0x00, i++;
2468 }
2469 output[0x0F] = manufacturer_size*2 + 2;
2470
2471 // Addr 10: Offset of the product string + 0x80, calculated later
2472 // Addr 11: Length of product string
2473 output[0x10] = i | 0x80; // calculate offset
2474 output[i & eeprom_size_mask] = product_size*2 + 2, i++;
2475 output[i & eeprom_size_mask] = 0x03, i++;
2476 for (j = 0; j < product_size; j++)
2477 {
2478 output[i & eeprom_size_mask] = eeprom->product[j], i++;
2479 output[i & eeprom_size_mask] = 0x00, i++;
2480 }
2481 output[0x11] = product_size*2 + 2;
2482
2483 // Addr 12: Offset of the serial string + 0x80, calculated later
2484 // Addr 13: Length of serial string
2485 output[0x12] = i | 0x80; // calculate offset
2486 output[i & eeprom_size_mask] = serial_size*2 + 2, i++;
2487 output[i & eeprom_size_mask] = 0x03, i++;
2488 for (j = 0; j < serial_size; j++)
2489 {
2490 output[i & eeprom_size_mask] = eeprom->serial[j], i++;
2491 output[i & eeprom_size_mask] = 0x00, i++;
2492 }
2493
2494 // Legacy port name and PnP fields for FT2232 and newer chips
2495 if (ftdi->type > TYPE_BM)
2496 {
2497 output[i & eeprom_size_mask] = 0x02; /* as seen when written with FTD2XX */
2498 i++;
2499 output[i & eeprom_size_mask] = 0x03; /* as seen when written with FTD2XX */
2500 i++;
2501 output[i & eeprom_size_mask] = eeprom->is_not_pnp; /* as seen when written with FTD2XX */
2502 i++;
2503 }
2504
2505 output[0x13] = serial_size*2 + 2;
2506
2507 if (ftdi->type > TYPE_AM) /* use_serial not used in AM devices */
2508 {
2509 if (eeprom->use_serial == USE_SERIAL_NUM )
2510 output[0x0A] |= USE_SERIAL_NUM;
2511 else
2512 output[0x0A] &= ~USE_SERIAL_NUM;
2513 }
2514
2515 /* Bytes and Bits specific to (some) types
2516 Write linear, as this allows easier fixing*/
2517 switch (ftdi->type)
2518 {
2519 case TYPE_AM:
2520 break;
2521 case TYPE_BM:
2522 output[0x0C] = eeprom->usb_version & 0xff;
2523 output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2524 if (eeprom->use_usb_version == USE_USB_VERSION_BIT)
2525 output[0x0A] |= USE_USB_VERSION_BIT;
2526 else
2527 output[0x0A] &= ~USE_USB_VERSION_BIT;
2528
2529 break;
2530 case TYPE_2232C:
2531
2532 output[0x00] = (eeprom->channel_a_type)?((1<<(eeprom->channel_a_type)) & 0x7):0;
2533 if ( eeprom->channel_a_driver == DRIVER_VCP)
2534 output[0x00] |= DRIVER_VCP;
2535 else
2536 output[0x00] &= ~DRIVER_VCP;
2537
2538 if ( eeprom->high_current_a == HIGH_CURRENT_DRIVE)
2539 output[0x00] |= HIGH_CURRENT_DRIVE;
2540 else
2541 output[0x00] &= ~HIGH_CURRENT_DRIVE;
2542
2543 output[0x01] = (eeprom->channel_b_type)?((1<<(eeprom->channel_b_type)) & 0x7):0;
2544 if ( eeprom->channel_b_driver == DRIVER_VCP)
2545 output[0x01] |= DRIVER_VCP;
2546 else
2547 output[0x01] &= ~DRIVER_VCP;
2548
2549 if ( eeprom->high_current_b == HIGH_CURRENT_DRIVE)
2550 output[0x01] |= HIGH_CURRENT_DRIVE;
2551 else
2552 output[0x01] &= ~HIGH_CURRENT_DRIVE;
2553
2554 if (eeprom->in_is_isochronous == 1)
2555 output[0x0A] |= 0x1;
2556 else
2557 output[0x0A] &= ~0x1;
2558 if (eeprom->out_is_isochronous == 1)
2559 output[0x0A] |= 0x2;
2560 else
2561 output[0x0A] &= ~0x2;
2562 if (eeprom->suspend_pull_downs == 1)
2563 output[0x0A] |= 0x4;
2564 else
2565 output[0x0A] &= ~0x4;
2566 if (eeprom->use_usb_version == USE_USB_VERSION_BIT)
2567 output[0x0A] |= USE_USB_VERSION_BIT;
2568 else
2569 output[0x0A] &= ~USE_USB_VERSION_BIT;
2570
2571 output[0x0C] = eeprom->usb_version & 0xff;
2572 output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2573 output[0x14] = eeprom->chip;
2574 break;
2575 case TYPE_R:
2576 if (eeprom->high_current == HIGH_CURRENT_DRIVE_R)
2577 output[0x00] |= HIGH_CURRENT_DRIVE_R;
2578 output[0x01] = 0x40; /* Hard coded Endpoint Size*/
2579
2580 if (eeprom->suspend_pull_downs == 1)
2581 output[0x0A] |= 0x4;
2582 else
2583 output[0x0A] &= ~0x4;
2584 output[0x0B] = eeprom->invert;
2585 output[0x0C] = eeprom->usb_version & 0xff;
2586 output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2587
2588 if (eeprom->cbus_function[0] > CBUS_BB)
2589 output[0x14] = CBUS_TXLED;
2590 else
2591 output[0x14] = eeprom->cbus_function[0];
2592
2593 if (eeprom->cbus_function[1] > CBUS_BB)
2594 output[0x14] |= CBUS_RXLED<<4;
2595 else
2596 output[0x14] |= eeprom->cbus_function[1]<<4;
2597
2598 if (eeprom->cbus_function[2] > CBUS_BB)
2599 output[0x15] = CBUS_TXDEN;
2600 else
2601 output[0x15] = eeprom->cbus_function[2];
2602
2603 if (eeprom->cbus_function[3] > CBUS_BB)
2604 output[0x15] |= CBUS_PWREN<<4;
2605 else
2606 output[0x15] |= eeprom->cbus_function[3]<<4;
2607
2608 if (eeprom->cbus_function[4] > CBUS_CLK6)
2609 output[0x16] = CBUS_SLEEP;
2610 else
2611 output[0x16] = eeprom->cbus_function[4];
2612 break;
2613 case TYPE_2232H:
2614 output[0x00] = (eeprom->channel_a_type)?((1<<(eeprom->channel_a_type)) & 0x7):0;
2615 if ( eeprom->channel_a_driver == DRIVER_VCP)
2616 output[0x00] |= DRIVER_VCP;
2617 else
2618 output[0x00] &= ~DRIVER_VCP;
2619
2620 output[0x01] = (eeprom->channel_b_type)?((1<<(eeprom->channel_b_type)) & 0x7):0;
2621 if ( eeprom->channel_b_driver == DRIVER_VCP)
2622 output[0x01] |= DRIVER_VCP;
2623 else
2624 output[0x01] &= ~DRIVER_VCP;
2625 if (eeprom->suspend_dbus7 == SUSPEND_DBUS7_BIT)
2626 output[0x01] |= SUSPEND_DBUS7_BIT;
2627 else
2628 output[0x01] &= ~SUSPEND_DBUS7_BIT;
2629
2630 if (eeprom->suspend_pull_downs == 1)
2631 output[0x0A] |= 0x4;
2632 else
2633 output[0x0A] &= ~0x4;
2634
2635 if (eeprom->group0_drive > DRIVE_16MA)
2636 output[0x0c] |= DRIVE_16MA;
2637 else
2638 output[0x0c] |= eeprom->group0_drive;
2639 if (eeprom->group0_schmitt == IS_SCHMITT)
2640 output[0x0c] |= IS_SCHMITT;
2641 if (eeprom->group0_slew == SLOW_SLEW)
2642 output[0x0c] |= SLOW_SLEW;
2643
2644 if (eeprom->group1_drive > DRIVE_16MA)
2645 output[0x0c] |= DRIVE_16MA<<4;
2646 else
2647 output[0x0c] |= eeprom->group1_drive<<4;
2648 if (eeprom->group1_schmitt == IS_SCHMITT)
2649 output[0x0c] |= IS_SCHMITT<<4;
2650 if (eeprom->group1_slew == SLOW_SLEW)
2651 output[0x0c] |= SLOW_SLEW<<4;
2652
2653 if (eeprom->group2_drive > DRIVE_16MA)
2654 output[0x0d] |= DRIVE_16MA;
2655 else
2656 output[0x0d] |= eeprom->group2_drive;
2657 if (eeprom->group2_schmitt == IS_SCHMITT)
2658 output[0x0d] |= IS_SCHMITT;
2659 if (eeprom->group2_slew == SLOW_SLEW)
2660 output[0x0d] |= SLOW_SLEW;
2661
2662 if (eeprom->group3_drive > DRIVE_16MA)
2663 output[0x0d] |= DRIVE_16MA<<4;
2664 else
2665 output[0x0d] |= eeprom->group3_drive<<4;
2666 if (eeprom->group3_schmitt == IS_SCHMITT)
2667 output[0x0d] |= IS_SCHMITT<<4;
2668 if (eeprom->group3_slew == SLOW_SLEW)
2669 output[0x0d] |= SLOW_SLEW<<4;
2670
2671 output[0x18] = eeprom->chip;
2672
2673 break;
2674 case TYPE_4232H:
2675 output[0x18] = eeprom->chip;
2676 fprintf(stderr,"FIXME: Build FT4232H specific EEPROM settings\n");
2677 break;
2678 case TYPE_232H:
2679 output[0x00] = (eeprom->channel_a_type)?((1<<(eeprom->channel_a_type)) & 0xf):0;
2680 if ( eeprom->channel_a_driver == DRIVER_VCP)
2681 output[0x00] |= DRIVER_VCPH;
2682 else
2683 output[0x00] &= ~DRIVER_VCPH;
2684 if (eeprom->powersave)
2685 output[0x01] |= POWER_SAVE_DISABLE_H;
2686 else
2687 output[0x01] &= ~POWER_SAVE_DISABLE_H;
2688 if (eeprom->clock_polarity)
2689 output[0x01] |= FT1284_CLK_IDLE_STATE;
2690 else
2691 output[0x01] &= ~FT1284_CLK_IDLE_STATE;
2692 if (eeprom->data_order)
2693 output[0x01] |= FT1284_DATA_LSB;
2694 else
2695 output[0x01] &= ~FT1284_DATA_LSB;
2696 if (eeprom->flow_control)
2697 output[0x01] |= FT1284_FLOW_CONTROL;
2698 else
2699 output[0x01] &= ~FT1284_FLOW_CONTROL;
2700 if (eeprom->group0_drive > DRIVE_16MA)
2701 output[0x0c] |= DRIVE_16MA;
2702 else
2703 output[0x0c] |= eeprom->group0_drive;
2704 if (eeprom->group0_schmitt == IS_SCHMITT)
2705 output[0x0c] |= IS_SCHMITT;
2706 if (eeprom->group0_slew == SLOW_SLEW)
2707 output[0x0c] |= SLOW_SLEW;
2708
2709 if (eeprom->group1_drive > DRIVE_16MA)
2710 output[0x0d] |= DRIVE_16MA;
2711 else
2712 output[0x0d] |= eeprom->group1_drive;
2713 if (eeprom->group1_schmitt == IS_SCHMITT)
2714 output[0x0d] |= IS_SCHMITT;
2715 if (eeprom->group1_slew == SLOW_SLEW)
2716 output[0x0d] |= SLOW_SLEW;
2717
2718 set_ft232h_cbus(eeprom, output);
2719
2720 output[0x1e] = eeprom->chip;
2721 fprintf(stderr,"FIXME: Build FT232H specific EEPROM settings\n");
2722 break;
2723
2724 }
2725
2726 // calculate checksum
2727 checksum = 0xAAAA;
2728
2729 for (i = 0; i < eeprom->size/2-1; i++)
2730 {
2731 value = output[i*2];
2732 value += output[(i*2)+1] << 8;
2733
2734 checksum = value^checksum;
2735 checksum = (checksum << 1) | (checksum >> 15);
2736 }
2737
2738 output[eeprom->size-2] = checksum;
2739 output[eeprom->size-1] = checksum >> 8;
2740
2741 return user_area_size;
2742}
2743/* FTD2XX doesn't allow to set multiple bits in the interface mode bitfield*/
2744unsigned char bit2type(unsigned char bits)
2745{
2746 switch (bits)
2747 {
2748 case 0: return 0;
2749 case 1: return 1;
2750 case 2: return 2;
2751 case 4: return 3;
2752 case 8: return 4;
2753 default:
2754 fprintf(stderr," Unexpected value %d for Hardware Interface type\n",
2755 bits);
2756 }
2757 return 0;
2758}
2759
2760/**
2761 Decode binary EEPROM image into an ftdi_eeprom structure.
2762
2763 \param ftdi pointer to ftdi_context
2764 \param verbose Decode EEPROM on stdout
2765
2766 \retval 0: all fine
2767 \retval -1: something went wrong
2768
2769 FIXME: How to pass size? How to handle size field in ftdi_eeprom?
2770 FIXME: Strings are malloc'ed here and should be freed somewhere
2771*/
2772int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose)
2773{
2774 unsigned char i, j;
2775 unsigned short checksum, eeprom_checksum, value;
2776 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2777 int eeprom_size;
2778 struct ftdi_eeprom *eeprom;
2779 unsigned char *buf = ftdi->eeprom->buf;
2780 int release;
2781
2782 if (ftdi == NULL)
2783 ftdi_error_return(-1,"No context");
2784 if (ftdi->eeprom == NULL)
2785 ftdi_error_return(-1,"No eeprom structure");
2786
2787 eeprom = ftdi->eeprom;
2788 eeprom_size = eeprom->size;
2789
2790 // Addr 02: Vendor ID
2791 eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
2792
2793 // Addr 04: Product ID
2794 eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
2795
2796 release = buf[0x06] + (buf[0x07]<<8);
2797
2798 // Addr 08: Config descriptor
2799 // Bit 7: always 1
2800 // Bit 6: 1 if this device is self powered, 0 if bus powered
2801 // Bit 5: 1 if this device uses remote wakeup
2802 eeprom->self_powered = buf[0x08] & 0x40;
2803 eeprom->remote_wakeup = buf[0x08] & 0x20;
2804
2805 // Addr 09: Max power consumption: max power = value * 2 mA
2806 eeprom->max_power = buf[0x09];
2807
2808 // Addr 0A: Chip configuration
2809 // Bit 7: 0 - reserved
2810 // Bit 6: 0 - reserved
2811 // Bit 5: 0 - reserved
2812 // Bit 4: 1 - Change USB version on BM and 2232C
2813 // Bit 3: 1 - Use the serial number string
2814 // Bit 2: 1 - Enable suspend pull downs for lower power
2815 // Bit 1: 1 - Out EndPoint is Isochronous
2816 // Bit 0: 1 - In EndPoint is Isochronous
2817 //
2818 eeprom->in_is_isochronous = buf[0x0A]&0x01;
2819 eeprom->out_is_isochronous = buf[0x0A]&0x02;
2820 eeprom->suspend_pull_downs = buf[0x0A]&0x04;
2821 eeprom->use_serial = buf[0x0A] & USE_SERIAL_NUM;
2822 eeprom->use_usb_version = buf[0x0A] & USE_USB_VERSION_BIT;
2823
2824 // Addr 0C: USB version low byte when 0x0A
2825 // Addr 0D: USB version high byte when 0x0A
2826 eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
2827
2828 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2829 // Addr 0F: Length of manufacturer string
2830 manufacturer_size = buf[0x0F]/2;
2831 if (eeprom->manufacturer)
2832 free(eeprom->manufacturer);
2833 if (manufacturer_size > 0)
2834 {
2835 eeprom->manufacturer = malloc(manufacturer_size);
2836 if (eeprom->manufacturer)
2837 {
2838 // Decode manufacturer
2839 i = buf[0x0E] & (eeprom_size -1); // offset
2840 for (j=0;j<manufacturer_size-1;j++)
2841 {
2842 eeprom->manufacturer[j] = buf[2*j+i+2];
2843 }
2844 eeprom->manufacturer[j] = '\0';
2845 }
2846 }
2847 else eeprom->manufacturer = NULL;
2848
2849 // Addr 10: Offset of the product string + 0x80, calculated later
2850 // Addr 11: Length of product string
2851 if (eeprom->product)
2852 free(eeprom->product);
2853 product_size = buf[0x11]/2;
2854 if (product_size > 0)
2855 {
2856 eeprom->product = malloc(product_size);
2857 if (eeprom->product)
2858 {
2859 // Decode product name
2860 i = buf[0x10] & (eeprom_size -1); // offset
2861 for (j=0;j<product_size-1;j++)
2862 {
2863 eeprom->product[j] = buf[2*j+i+2];
2864 }
2865 eeprom->product[j] = '\0';
2866 }
2867 }
2868 else eeprom->product = NULL;
2869
2870 // Addr 12: Offset of the serial string + 0x80, calculated later
2871 // Addr 13: Length of serial string
2872 if (eeprom->serial)
2873 free(eeprom->serial);
2874 serial_size = buf[0x13]/2;
2875 if (serial_size > 0)
2876 {
2877 eeprom->serial = malloc(serial_size);
2878 if (eeprom->serial)
2879 {
2880 // Decode serial
2881 i = buf[0x12] & (eeprom_size -1); // offset
2882 for (j=0;j<serial_size-1;j++)
2883 {
2884 eeprom->serial[j] = buf[2*j+i+2];
2885 }
2886 eeprom->serial[j] = '\0';
2887 }
2888 }
2889 else eeprom->serial = NULL;
2890
2891 // verify checksum
2892 checksum = 0xAAAA;
2893
2894 for (i = 0; i < eeprom_size/2-1; i++)
2895 {
2896 value = buf[i*2];
2897 value += buf[(i*2)+1] << 8;
2898
2899 checksum = value^checksum;
2900 checksum = (checksum << 1) | (checksum >> 15);
2901 }
2902
2903 eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
2904
2905 if (eeprom_checksum != checksum)
2906 {
2907 fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
2908 ftdi_error_return(-1,"EEPROM checksum error");
2909 }
2910
2911 eeprom->channel_a_type = 0;
2912 if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM))
2913 {
2914 eeprom->chip = -1;
2915 }
2916 else if (ftdi->type == TYPE_2232C)
2917 {
2918 eeprom->channel_a_type = bit2type(buf[0x00] & 0x7);
2919 eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
2920 eeprom->high_current_a = buf[0x00] & HIGH_CURRENT_DRIVE;
2921 eeprom->channel_b_type = buf[0x01] & 0x7;
2922 eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
2923 eeprom->high_current_b = buf[0x01] & HIGH_CURRENT_DRIVE;
2924 eeprom->chip = buf[0x14];
2925 }
2926 else if (ftdi->type == TYPE_R)
2927 {
2928 /* TYPE_R flags D2XX, not VCP as all others*/
2929 eeprom->channel_a_driver = (~buf[0x00]) & DRIVER_VCP;
2930 eeprom->high_current = buf[0x00] & HIGH_CURRENT_DRIVE_R;
2931 if ( (buf[0x01]&0x40) != 0x40)
2932 fprintf(stderr,
2933 "TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size."
2934 " If this happened with the\n"
2935 " EEPROM programmed by FTDI tools, please report "
2936 "to libftdi@developer.intra2net.com\n");
2937
2938 eeprom->chip = buf[0x16];
2939 // Addr 0B: Invert data lines
2940 // Works only on FT232R, not FT245R, but no way to distinguish
2941 eeprom->invert = buf[0x0B];
2942 // Addr 14: CBUS function: CBUS0, CBUS1
2943 // Addr 15: CBUS function: CBUS2, CBUS3
2944 // Addr 16: CBUS function: CBUS5
2945 eeprom->cbus_function[0] = buf[0x14] & 0x0f;
2946 eeprom->cbus_function[1] = (buf[0x14] >> 4) & 0x0f;
2947 eeprom->cbus_function[2] = buf[0x15] & 0x0f;
2948 eeprom->cbus_function[3] = (buf[0x15] >> 4) & 0x0f;
2949 eeprom->cbus_function[4] = buf[0x16] & 0x0f;
2950 }
2951 else if ((ftdi->type == TYPE_2232H) ||(ftdi->type == TYPE_4232H))
2952 {
2953 eeprom->channel_a_type = bit2type(buf[0x00] & 0x7);
2954 eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
2955 eeprom->channel_b_type = buf[0x01] & 0x7;
2956 eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
2957
2958 if (ftdi->type == TYPE_2232H)
2959 eeprom->suspend_dbus7 = buf[0x01] & SUSPEND_DBUS7_BIT;
2960
2961 eeprom->chip = buf[0x18];
2962 eeprom->group0_drive = buf[0x0c] & DRIVE_16MA;
2963 eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT;
2964 eeprom->group0_slew = buf[0x0c] & SLOW_SLEW;
2965 eeprom->group1_drive = (buf[0x0c] >> 4) & 0x3;
2966 eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT;
2967 eeprom->group1_slew = (buf[0x0c] >> 4) & SLOW_SLEW;
2968 eeprom->group2_drive = buf[0x0d] & DRIVE_16MA;
2969 eeprom->group2_schmitt = buf[0x0d] & IS_SCHMITT;
2970 eeprom->group2_slew = buf[0x0d] & SLOW_SLEW;
2971 eeprom->group3_drive = (buf[0x0d] >> 4) & DRIVE_16MA;
2972 eeprom->group3_schmitt = (buf[0x0d] >> 4) & IS_SCHMITT;
2973 eeprom->group3_slew = (buf[0x0d] >> 4) & SLOW_SLEW;
2974 }
2975 else if (ftdi->type == TYPE_232H)
2976 {
2977 int i;
2978
2979 eeprom->channel_a_type = buf[0x00] & 0xf;
2980 eeprom->channel_a_driver = (buf[0x00] & DRIVER_VCPH)?DRIVER_VCP:0;
2981 eeprom->clock_polarity = buf[0x01] & FT1284_CLK_IDLE_STATE;
2982 eeprom->data_order = buf[0x01] & FT1284_DATA_LSB;
2983 eeprom->flow_control = buf[0x01] & FT1284_FLOW_CONTROL;
2984 eeprom->powersave = buf[0x01] & POWER_SAVE_DISABLE_H;
2985 eeprom->group0_drive = buf[0x0c] & DRIVE_16MA;
2986 eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT;
2987 eeprom->group0_slew = buf[0x0c] & SLOW_SLEW;
2988 eeprom->group1_drive = buf[0x0d] & DRIVE_16MA;
2989 eeprom->group1_schmitt = buf[0x0d] & IS_SCHMITT;
2990 eeprom->group1_slew = buf[0x0d] & SLOW_SLEW;
2991
2992 for(i=0; i<5; i++)
2993 {
2994 eeprom->cbus_function[2*i ] = buf[0x18+i] & 0x0f;
2995 eeprom->cbus_function[2*i+1] = (buf[0x18+i] >> 4) & 0x0f;
2996 }
2997 eeprom->chip = buf[0x1e];
2998 /*FIXME: Decipher more values*/
2999 }
3000
3001 if (verbose)
3002 {
3003 char *channel_mode[] = {"UART","245","CPU", "OPTO", "FT1284"};
3004 fprintf(stdout, "VID: 0x%04x\n",eeprom->vendor_id);
3005 fprintf(stdout, "PID: 0x%04x\n",eeprom->product_id);
3006 fprintf(stdout, "Release: 0x%04x\n",release);
3007
3008 if (eeprom->self_powered)
3009 fprintf(stdout, "Self-Powered%s", (eeprom->remote_wakeup)?", USB Remote Wake Up\n":"\n");
3010 else
3011 fprintf(stdout, "Bus Powered: %3d mA%s", eeprom->max_power * 2,
3012 (eeprom->remote_wakeup)?" USB Remote Wake Up\n":"\n");
3013 if (eeprom->manufacturer)
3014 fprintf(stdout, "Manufacturer: %s\n",eeprom->manufacturer);
3015 if (eeprom->product)
3016 fprintf(stdout, "Product: %s\n",eeprom->product);
3017 if (eeprom->serial)
3018 fprintf(stdout, "Serial: %s\n",eeprom->serial);
3019 fprintf(stdout, "Checksum : %04x\n", checksum);
3020 if (ftdi->type == TYPE_R)
3021 fprintf(stdout, "Internal EEPROM\n");
3022 else if (eeprom->chip >= 0x46)
3023 fprintf(stdout, "Attached EEPROM: 93x%02x\n", eeprom->chip);
3024 if (eeprom->suspend_dbus7)
3025 fprintf(stdout, "Suspend on DBUS7\n");
3026 if (eeprom->suspend_pull_downs)
3027 fprintf(stdout, "Pull IO pins low during suspend\n");
3028 if(eeprom->powersave)
3029 {
3030 if(ftdi->type >= TYPE_232H)
3031 fprintf(stdout,"Enter low power state on ACBUS7\n");
3032 }
3033 if (eeprom->remote_wakeup)
3034 fprintf(stdout, "Enable Remote Wake Up\n");
3035 fprintf(stdout, "PNP: %d\n",(eeprom->is_not_pnp)?0:1);
3036 if (ftdi->type >= TYPE_2232C)
3037 fprintf(stdout,"Channel A has Mode %s%s%s\n",
3038 channel_mode[eeprom->channel_a_type],
3039 (eeprom->channel_a_driver)?" VCP":"",
3040 (eeprom->high_current_a)?" High Current IO":"");
3041 if (ftdi->type >= TYPE_232H)
3042 {
3043 fprintf(stdout,"FT1284 Mode Clock is idle %s, %s first, %sFlow Control\n",
3044 (eeprom->clock_polarity)?"HIGH":"LOW",
3045 (eeprom->data_order)?"LSB":"MSB",
3046 (eeprom->flow_control)?"":"No ");
3047 }
3048 if ((ftdi->type >= TYPE_2232C) && (ftdi->type != TYPE_R) && (ftdi->type != TYPE_232H))
3049 fprintf(stdout,"Channel B has Mode %s%s%s\n",
3050 channel_mode[eeprom->channel_b_type],
3051 (eeprom->channel_b_driver)?" VCP":"",
3052 (eeprom->high_current_b)?" High Current IO":"");
3053 if (((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C)) &&
3054 eeprom->use_usb_version == USE_USB_VERSION_BIT)
3055 fprintf(stdout,"Use explicit USB Version %04x\n",eeprom->usb_version);
3056
3057 if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
3058 {
3059 fprintf(stdout,"%s has %d mA drive%s%s\n",
3060 (ftdi->type == TYPE_2232H)?"AL":"A",
3061 (eeprom->group0_drive+1) *4,
3062 (eeprom->group0_schmitt)?" Schmitt Input":"",
3063 (eeprom->group0_slew)?" Slow Slew":"");
3064 fprintf(stdout,"%s has %d mA drive%s%s\n",
3065 (ftdi->type == TYPE_2232H)?"AH":"B",
3066 (eeprom->group1_drive+1) *4,
3067 (eeprom->group1_schmitt)?" Schmitt Input":"",
3068 (eeprom->group1_slew)?" Slow Slew":"");
3069 fprintf(stdout,"%s has %d mA drive%s%s\n",
3070 (ftdi->type == TYPE_2232H)?"BL":"C",
3071 (eeprom->group2_drive+1) *4,
3072 (eeprom->group2_schmitt)?" Schmitt Input":"",
3073 (eeprom->group2_slew)?" Slow Slew":"");
3074 fprintf(stdout,"%s has %d mA drive%s%s\n",
3075 (ftdi->type == TYPE_2232H)?"BH":"D",
3076 (eeprom->group3_drive+1) *4,
3077 (eeprom->group3_schmitt)?" Schmitt Input":"",
3078 (eeprom->group3_slew)?" Slow Slew":"");
3079 }
3080 else if (ftdi->type == TYPE_232H)
3081 {
3082 int i;
3083 char *cbush_mux[] = {"TRISTATE","RXLED","TXLED", "TXRXLED","PWREN",
3084 "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN",
3085 "CLK30","CLK15","CLK7_5"
3086 };
3087 fprintf(stdout,"ACBUS has %d mA drive%s%s\n",
3088 (eeprom->group0_drive+1) *4,
3089 (eeprom->group0_schmitt)?" Schmitt Input":"",
3090 (eeprom->group0_slew)?" Slow Slew":"");
3091 fprintf(stdout,"ADBUS has %d mA drive%s%s\n",
3092 (eeprom->group1_drive+1) *4,
3093 (eeprom->group1_schmitt)?" Schmitt Input":"",
3094 (eeprom->group1_slew)?" Slow Slew":"");
3095 for (i=0; i<10; i++)
3096 {
3097 if (eeprom->cbus_function[i]<= CBUSH_CLK7_5 )
3098 fprintf(stdout,"C%d Function: %s\n", i,
3099 cbush_mux[eeprom->cbus_function[i]]);
3100 }
3101
3102 }
3103
3104 if (ftdi->type == TYPE_R)
3105 {
3106 char *cbus_mux[] = {"TXDEN","PWREN","RXLED", "TXLED","TX+RXLED",
3107 "SLEEP","CLK48","CLK24","CLK12","CLK6",
3108 "IOMODE","BB_WR","BB_RD"
3109 };
3110 char *cbus_BB[] = {"RXF","TXE","RD", "WR"};
3111
3112 if (eeprom->invert)
3113 {
3114 char *r_bits[] = {"TXD","RXD","RTS", "CTS","DTR","DSR","DCD","RI"};
3115 fprintf(stdout,"Inverted bits:");
3116 for (i=0; i<8; i++)
3117 if ((eeprom->invert & (1<<i)) == (1<<i))
3118 fprintf(stdout," %s",r_bits[i]);
3119 fprintf(stdout,"\n");
3120 }
3121 for (i=0; i<5; i++)
3122 {
3123 if (eeprom->cbus_function[i]<CBUS_BB)
3124 fprintf(stdout,"C%d Function: %s\n", i,
3125 cbus_mux[eeprom->cbus_function[i]]);
3126 else
3127 {
3128 if (i < 4)
3129 /* Running MPROG show that C0..3 have fixed function Synchronous
3130 Bit Bang mode */
3131 fprintf(stdout,"C%d BB Function: %s\n", i,
3132 cbus_BB[i]);
3133 else
3134 fprintf(stdout, "Unknown CBUS mode. Might be special mode?\n");
3135 }
3136 }
3137 }
3138 }
3139 return 0;
3140}
3141
3142/**
3143 Get a value from the decoded EEPROM structure
3144
3145 \param ftdi pointer to ftdi_context
3146 \param value_name Enum of the value to query
3147 \param value Pointer to store read value
3148
3149 \retval 0: all fine
3150 \retval -1: Value doesn't exist
3151*/
3152int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int* value)
3153{
3154 switch (value_name)
3155 {
3156 case VENDOR_ID:
3157 *value = ftdi->eeprom->vendor_id;
3158 break;
3159 case PRODUCT_ID:
3160 *value = ftdi->eeprom->product_id;
3161 break;
3162 case SELF_POWERED:
3163 *value = ftdi->eeprom->self_powered;
3164 break;
3165 case REMOTE_WAKEUP:
3166 *value = ftdi->eeprom->remote_wakeup;
3167 break;
3168 case IS_NOT_PNP:
3169 *value = ftdi->eeprom->is_not_pnp;
3170 break;
3171 case SUSPEND_DBUS7:
3172 *value = ftdi->eeprom->suspend_dbus7;
3173 break;
3174 case IN_IS_ISOCHRONOUS:
3175 *value = ftdi->eeprom->in_is_isochronous;
3176 break;
3177 case SUSPEND_PULL_DOWNS:
3178 *value = ftdi->eeprom->suspend_pull_downs;
3179 break;
3180 case USE_SERIAL:
3181 *value = ftdi->eeprom->use_serial;
3182 break;
3183 case USB_VERSION:
3184 *value = ftdi->eeprom->usb_version;
3185 break;
3186 case MAX_POWER:
3187 *value = ftdi->eeprom->max_power;
3188 break;
3189 case CHANNEL_A_TYPE:
3190 *value = ftdi->eeprom->channel_a_type;
3191 break;
3192 case CHANNEL_B_TYPE:
3193 *value = ftdi->eeprom->channel_b_type;
3194 break;
3195 case CHANNEL_A_DRIVER:
3196 *value = ftdi->eeprom->channel_a_driver;
3197 break;
3198 case CHANNEL_B_DRIVER:
3199 *value = ftdi->eeprom->channel_b_driver;
3200 break;
3201 case CBUS_FUNCTION_0:
3202 *value = ftdi->eeprom->cbus_function[0];
3203 break;
3204 case CBUS_FUNCTION_1:
3205 *value = ftdi->eeprom->cbus_function[1];
3206 break;
3207 case CBUS_FUNCTION_2:
3208 *value = ftdi->eeprom->cbus_function[2];
3209 break;
3210 case CBUS_FUNCTION_3:
3211 *value = ftdi->eeprom->cbus_function[3];
3212 break;
3213 case CBUS_FUNCTION_4:
3214 *value = ftdi->eeprom->cbus_function[4];
3215 break;
3216 case CBUS_FUNCTION_5:
3217 *value = ftdi->eeprom->cbus_function[5];
3218 break;
3219 case CBUS_FUNCTION_6:
3220 *value = ftdi->eeprom->cbus_function[6];
3221 break;
3222 case CBUS_FUNCTION_7:
3223 *value = ftdi->eeprom->cbus_function[7];
3224 break;
3225 case CBUS_FUNCTION_8:
3226 *value = ftdi->eeprom->cbus_function[8];
3227 break;
3228 case CBUS_FUNCTION_9:
3229 *value = ftdi->eeprom->cbus_function[8];
3230 break;
3231 case HIGH_CURRENT:
3232 *value = ftdi->eeprom->high_current;
3233 break;
3234 case HIGH_CURRENT_A:
3235 *value = ftdi->eeprom->high_current_a;
3236 break;
3237 case HIGH_CURRENT_B:
3238 *value = ftdi->eeprom->high_current_b;
3239 break;
3240 case INVERT:
3241 *value = ftdi->eeprom->invert;
3242 break;
3243 case GROUP0_DRIVE:
3244 *value = ftdi->eeprom->group0_drive;
3245 break;
3246 case GROUP0_SCHMITT:
3247 *value = ftdi->eeprom->group0_schmitt;
3248 break;
3249 case GROUP0_SLEW:
3250 *value = ftdi->eeprom->group0_slew;
3251 break;
3252 case GROUP1_DRIVE:
3253 *value = ftdi->eeprom->group1_drive;
3254 break;
3255 case GROUP1_SCHMITT:
3256 *value = ftdi->eeprom->group1_schmitt;
3257 break;
3258 case GROUP1_SLEW:
3259 *value = ftdi->eeprom->group1_slew;
3260 break;
3261 case GROUP2_DRIVE:
3262 *value = ftdi->eeprom->group2_drive;
3263 break;
3264 case GROUP2_SCHMITT:
3265 *value = ftdi->eeprom->group2_schmitt;
3266 break;
3267 case GROUP2_SLEW:
3268 *value = ftdi->eeprom->group2_slew;
3269 break;
3270 case GROUP3_DRIVE:
3271 *value = ftdi->eeprom->group3_drive;
3272 break;
3273 case GROUP3_SCHMITT:
3274 *value = ftdi->eeprom->group3_schmitt;
3275 break;
3276 case GROUP3_SLEW:
3277 *value = ftdi->eeprom->group3_slew;
3278 break;
3279 case POWER_SAVE:
3280 *value = ftdi->eeprom->powersave;
3281 break;
3282 case CLOCK_POLARITY:
3283 *value = ftdi->eeprom->clock_polarity;
3284 break;
3285 case DATA_ORDER:
3286 *value = ftdi->eeprom->data_order;
3287 break;
3288 case FLOW_CONTROL:
3289 *value = ftdi->eeprom->flow_control;
3290 break;
3291 case CHIP_TYPE:
3292 *value = ftdi->eeprom->chip;
3293 break;
3294 case CHIP_SIZE:
3295 *value = ftdi->eeprom->size;
3296 break;
3297 default:
3298 ftdi_error_return(-1, "Request for unknown EEPROM value");
3299 }
3300 return 0;
3301}
3302
3303/**
3304 Set a value in the decoded EEPROM Structure
3305 No parameter checking is performed
3306
3307 \param ftdi pointer to ftdi_context
3308 \param value_name Enum of the value to set
3309 \param value to set
3310
3311 \retval 0: all fine
3312 \retval -1: Value doesn't exist
3313 \retval -2: Value not user settable
3314*/
3315int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int value)
3316{
3317 switch (value_name)
3318 {
3319 case VENDOR_ID:
3320 ftdi->eeprom->vendor_id = value;
3321 break;
3322 case PRODUCT_ID:
3323 ftdi->eeprom->product_id = value;
3324 break;
3325 case SELF_POWERED:
3326 ftdi->eeprom->self_powered = value;
3327 break;
3328 case REMOTE_WAKEUP:
3329 ftdi->eeprom->remote_wakeup = value;
3330 break;
3331 case IS_NOT_PNP:
3332 ftdi->eeprom->is_not_pnp = value;
3333 break;
3334 case SUSPEND_DBUS7:
3335 ftdi->eeprom->suspend_dbus7 = value;
3336 break;
3337 case IN_IS_ISOCHRONOUS:
3338 ftdi->eeprom->in_is_isochronous = value;
3339 break;
3340 case SUSPEND_PULL_DOWNS:
3341 ftdi->eeprom->suspend_pull_downs = value;
3342 break;
3343 case USE_SERIAL:
3344 ftdi->eeprom->use_serial = value;
3345 break;
3346 case USB_VERSION:
3347 ftdi->eeprom->usb_version = value;
3348 break;
3349 case MAX_POWER:
3350 ftdi->eeprom->max_power = value;
3351 break;
3352 case CHANNEL_A_TYPE:
3353 ftdi->eeprom->channel_a_type = value;
3354 break;
3355 case CHANNEL_B_TYPE:
3356 ftdi->eeprom->channel_b_type = value;
3357 break;
3358 case CHANNEL_A_DRIVER:
3359 ftdi->eeprom->channel_a_driver = value;
3360 break;
3361 case CHANNEL_B_DRIVER:
3362 ftdi->eeprom->channel_b_driver = value;
3363 break;
3364 case CBUS_FUNCTION_0:
3365 ftdi->eeprom->cbus_function[0] = value;
3366 break;
3367 case CBUS_FUNCTION_1:
3368 ftdi->eeprom->cbus_function[1] = value;
3369 break;
3370 case CBUS_FUNCTION_2:
3371 ftdi->eeprom->cbus_function[2] = value;
3372 break;
3373 case CBUS_FUNCTION_3:
3374 ftdi->eeprom->cbus_function[3] = value;
3375 break;
3376 case CBUS_FUNCTION_4:
3377 ftdi->eeprom->cbus_function[4] = value;
3378 break;
3379 case CBUS_FUNCTION_5:
3380 ftdi->eeprom->cbus_function[5] = value;
3381 break;
3382 case CBUS_FUNCTION_6:
3383 ftdi->eeprom->cbus_function[6] = value;
3384 break;
3385 case CBUS_FUNCTION_7:
3386 ftdi->eeprom->cbus_function[7] = value;
3387 break;
3388 case CBUS_FUNCTION_8:
3389 ftdi->eeprom->cbus_function[8] = value;
3390 break;
3391 case CBUS_FUNCTION_9:
3392 ftdi->eeprom->cbus_function[9] = value;
3393 break;
3394 case HIGH_CURRENT:
3395 ftdi->eeprom->high_current = value;
3396 break;
3397 case HIGH_CURRENT_A:
3398 ftdi->eeprom->high_current_a = value;
3399 break;
3400 case HIGH_CURRENT_B:
3401 ftdi->eeprom->high_current_b = value;
3402 break;
3403 case INVERT:
3404 ftdi->eeprom->invert = value;
3405 break;
3406 case GROUP0_DRIVE:
3407 ftdi->eeprom->group0_drive = value;
3408 break;
3409 case GROUP0_SCHMITT:
3410 ftdi->eeprom->group0_schmitt = value;
3411 break;
3412 case GROUP0_SLEW:
3413 ftdi->eeprom->group0_slew = value;
3414 break;
3415 case GROUP1_DRIVE:
3416 ftdi->eeprom->group1_drive = value;
3417 break;
3418 case GROUP1_SCHMITT:
3419 ftdi->eeprom->group1_schmitt = value;
3420 break;
3421 case GROUP1_SLEW:
3422 ftdi->eeprom->group1_slew = value;
3423 break;
3424 case GROUP2_DRIVE:
3425 ftdi->eeprom->group2_drive = value;
3426 break;
3427 case GROUP2_SCHMITT:
3428 ftdi->eeprom->group2_schmitt = value;
3429 break;
3430 case GROUP2_SLEW:
3431 ftdi->eeprom->group2_slew = value;
3432 break;
3433 case GROUP3_DRIVE:
3434 ftdi->eeprom->group3_drive = value;
3435 break;
3436 case GROUP3_SCHMITT:
3437 ftdi->eeprom->group3_schmitt = value;
3438 break;
3439 case GROUP3_SLEW:
3440 ftdi->eeprom->group3_slew = value;
3441 break;
3442 case CHIP_TYPE:
3443 ftdi->eeprom->chip = value;
3444 break;
3445 case POWER_SAVE:
3446 ftdi->eeprom->powersave = value;
3447 break;
3448 case CLOCK_POLARITY:
3449 ftdi->eeprom->clock_polarity = value;
3450 break;
3451 case DATA_ORDER:
3452 ftdi->eeprom->data_order = value;
3453 break;
3454 case FLOW_CONTROL:
3455 ftdi->eeprom->flow_control = value;
3456 break;
3457 case CHIP_SIZE:
3458 ftdi_error_return(-2, "EEPROM Value can't be changed");
3459 default :
3460 ftdi_error_return(-1, "Request to unknown EEPROM value");
3461 }
3462 return 0;
3463}
3464
3465/** Get the read-only buffer to the binary EEPROM content
3466
3467 \param ftdi pointer to ftdi_context
3468 \param buf buffer to receive EEPROM content
3469 \param size Size of receiving buffer
3470
3471 \retval 0: All fine
3472 \retval -1: struct ftdi_contxt or ftdi_eeprom missing
3473 \retval -2: Not enough room to store eeprom
3474*/
3475int ftdi_get_eeprom_buf(struct ftdi_context *ftdi, unsigned char * buf, int size)
3476{
3477 if (!ftdi || !(ftdi->eeprom))
3478 ftdi_error_return(-1, "No appropriate structure");
3479
3480 if (!buf || size < ftdi->eeprom->size)
3481 ftdi_error_return(-1, "Not enough room to store eeprom");
3482
3483 // Only copy up to FTDI_MAX_EEPROM_SIZE bytes
3484 if (size > FTDI_MAX_EEPROM_SIZE)
3485 size = FTDI_MAX_EEPROM_SIZE;
3486
3487 memcpy(buf, ftdi->eeprom->buf, size);
3488
3489 return 0;
3490}
3491
3492/**
3493 Read eeprom location
3494
3495 \param ftdi pointer to ftdi_context
3496 \param eeprom_addr Address of eeprom location to be read
3497 \param eeprom_val Pointer to store read eeprom location
3498
3499 \retval 0: all fine
3500 \retval -1: read failed
3501 \retval -2: USB device unavailable
3502*/
3503int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
3504{
3505 if (ftdi == NULL || ftdi->usb_dev == NULL)
3506 ftdi_error_return(-2, "USB device unavailable");
3507
3508 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, eeprom_addr, (unsigned char *)eeprom_val, 2, ftdi->usb_read_timeout) != 2)
3509 ftdi_error_return(-1, "reading eeprom failed");
3510
3511 return 0;
3512}
3513
3514/**
3515 Read eeprom
3516
3517 \param ftdi pointer to ftdi_context
3518
3519 \retval 0: all fine
3520 \retval -1: read failed
3521 \retval -2: USB device unavailable
3522*/
3523int ftdi_read_eeprom(struct ftdi_context *ftdi)
3524{
3525 int i;
3526 unsigned char *buf;
3527
3528 if (ftdi == NULL || ftdi->usb_dev == NULL)
3529 ftdi_error_return(-2, "USB device unavailable");
3530 buf = ftdi->eeprom->buf;
3531
3532 for (i = 0; i < FTDI_MAX_EEPROM_SIZE/2; i++)
3533 {
3534 if (libusb_control_transfer(
3535 ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,SIO_READ_EEPROM_REQUEST, 0, i,
3536 buf+(i*2), 2, ftdi->usb_read_timeout) != 2)
3537 ftdi_error_return(-1, "reading eeprom failed");
3538 }
3539
3540 if (ftdi->type == TYPE_R)
3541 ftdi->eeprom->size = 0x80;
3542 /* Guesses size of eeprom by comparing halves
3543 - will not work with blank eeprom */
3544 else if (strrchr((const char *)buf, 0xff) == ((const char *)buf +FTDI_MAX_EEPROM_SIZE -1))
3545 ftdi->eeprom->size = -1;
3546 else if (memcmp(buf,&buf[0x80],0x80) == 0)
3547 ftdi->eeprom->size = 0x80;
3548 else if (memcmp(buf,&buf[0x40],0x40) == 0)
3549 ftdi->eeprom->size = 0x40;
3550 else
3551 ftdi->eeprom->size = 0x100;
3552 return 0;
3553}
3554
3555/*
3556 ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID
3557 Function is only used internally
3558 \internal
3559*/
3560static unsigned char ftdi_read_chipid_shift(unsigned char value)
3561{
3562 return ((value & 1) << 1) |
3563 ((value & 2) << 5) |
3564 ((value & 4) >> 2) |
3565 ((value & 8) << 4) |
3566 ((value & 16) >> 1) |
3567 ((value & 32) >> 1) |
3568 ((value & 64) >> 4) |
3569 ((value & 128) >> 2);
3570}
3571
3572/**
3573 Read the FTDIChip-ID from R-type devices
3574
3575 \param ftdi pointer to ftdi_context
3576 \param chipid Pointer to store FTDIChip-ID
3577
3578 \retval 0: all fine
3579 \retval -1: read failed
3580 \retval -2: USB device unavailable
3581*/
3582int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
3583{
3584 unsigned int a = 0, b = 0;
3585
3586 if (ftdi == NULL || ftdi->usb_dev == NULL)
3587 ftdi_error_return(-2, "USB device unavailable");
3588
3589 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x43, (unsigned char *)&a, 2, ftdi->usb_read_timeout) == 2)
3590 {
3591 a = a << 8 | a >> 8;
3592 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x44, (unsigned char *)&b, 2, ftdi->usb_read_timeout) == 2)
3593 {
3594 b = b << 8 | b >> 8;
3595 a = (a << 16) | (b & 0xFFFF);
3596 a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
3597 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
3598 *chipid = a ^ 0xa5f0f7d1;
3599 return 0;
3600 }
3601 }
3602
3603 ftdi_error_return(-1, "read of FTDIChip-ID failed");
3604}
3605
3606/**
3607 Write eeprom location
3608
3609 \param ftdi pointer to ftdi_context
3610 \param eeprom_addr Address of eeprom location to be written
3611 \param eeprom_val Value to be written
3612
3613 \retval 0: all fine
3614 \retval -1: write failed
3615 \retval -2: USB device unavailable
3616 \retval -3: Invalid access to checksum protected area below 0x80
3617 \retval -4: Device can't access unprotected area
3618 \retval -5: Reading chip type failed
3619*/
3620int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr,
3621 unsigned short eeprom_val)
3622{
3623 int chip_type_location;
3624 unsigned short chip_type;
3625
3626 if (ftdi == NULL || ftdi->usb_dev == NULL)
3627 ftdi_error_return(-2, "USB device unavailable");
3628
3629 if (eeprom_addr <0x80)
3630 ftdi_error_return(-2, "Invalid access to checksum protected area below 0x80");
3631
3632
3633 switch (ftdi->type)
3634 {
3635 case TYPE_BM:
3636 case TYPE_2232C:
3637 chip_type_location = 0x14;
3638 break;
3639 case TYPE_2232H:
3640 case TYPE_4232H:
3641 chip_type_location = 0x18;
3642 break;
3643 case TYPE_232H:
3644 chip_type_location = 0x1e;
3645 break;
3646 default:
3647 ftdi_error_return(-4, "Device can't access unprotected area");
3648 }
3649
3650 if (ftdi_read_eeprom_location( ftdi, chip_type_location>>1, &chip_type))
3651 ftdi_error_return(-5, "Reading failed failed");
3652 fprintf(stderr," loc 0x%04x val 0x%04x\n", chip_type_location,chip_type);
3653 if ((chip_type & 0xff) != 0x66)
3654 {
3655 ftdi_error_return(-6, "EEPROM is not of 93x66");
3656 }
3657
3658 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3659 SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
3660 NULL, 0, ftdi->usb_write_timeout) != 0)
3661 ftdi_error_return(-1, "unable to write eeprom");
3662
3663 return 0;
3664}
3665
3666/**
3667 Write eeprom
3668
3669 \param ftdi pointer to ftdi_context
3670
3671 \retval 0: all fine
3672 \retval -1: read failed
3673 \retval -2: USB device unavailable
3674*/
3675int ftdi_write_eeprom(struct ftdi_context *ftdi)
3676{
3677 unsigned short usb_val, status;
3678 int i, ret;
3679 unsigned char *eeprom;
3680
3681 if (ftdi == NULL || ftdi->usb_dev == NULL)
3682 ftdi_error_return(-2, "USB device unavailable");
3683 eeprom = ftdi->eeprom->buf;
3684
3685 /* These commands were traced while running MProg */
3686 if ((ret = ftdi_usb_reset(ftdi)) != 0)
3687 return ret;
3688 if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0)
3689 return ret;
3690 if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0)
3691 return ret;
3692
3693 for (i = 0; i < ftdi->eeprom->size/2; i++)
3694 {
3695 usb_val = eeprom[i*2];
3696 usb_val += eeprom[(i*2)+1] << 8;
3697 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3698 SIO_WRITE_EEPROM_REQUEST, usb_val, i,
3699 NULL, 0, ftdi->usb_write_timeout) < 0)
3700 ftdi_error_return(-1, "unable to write eeprom");
3701 }
3702
3703 return 0;
3704}
3705
3706/**
3707 Erase eeprom
3708
3709 This is not supported on FT232R/FT245R according to the MProg manual from FTDI.
3710
3711 \param ftdi pointer to ftdi_context
3712
3713 \retval 0: all fine
3714 \retval -1: erase failed
3715 \retval -2: USB device unavailable
3716 \retval -3: Writing magic failed
3717 \retval -4: Read EEPROM failed
3718 \retval -5: Unexpected EEPROM value
3719*/
3720#define MAGIC 0x55aa
3721int ftdi_erase_eeprom(struct ftdi_context *ftdi)
3722{
3723 unsigned short eeprom_value;
3724 if (ftdi == NULL || ftdi->usb_dev == NULL)
3725 ftdi_error_return(-2, "USB device unavailable");
3726
3727 if (ftdi->type == TYPE_R)
3728 {
3729 ftdi->eeprom->chip = 0;
3730 return 0;
3731 }
3732
3733 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
3734 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
3735 ftdi_error_return(-1, "unable to erase eeprom");
3736
3737
3738 /* detect chip type by writing 0x55AA as magic at word position 0xc0
3739 Chip is 93x46 if magic is read at word position 0x00, as wraparound happens around 0x40
3740 Chip is 93x56 if magic is read at word position 0x40, as wraparound happens around 0x80
3741 Chip is 93x66 if magic is only read at word position 0xc0*/
3742 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
3743 SIO_WRITE_EEPROM_REQUEST, MAGIC, 0xc0,
3744 NULL, 0, ftdi->usb_write_timeout) != 0)
3745 ftdi_error_return(-3, "Writing magic failed");
3746 if (ftdi_read_eeprom_location( ftdi, 0x00, &eeprom_value))
3747 ftdi_error_return(-4, "Reading failed failed");
3748 if (eeprom_value == MAGIC)
3749 {
3750 ftdi->eeprom->chip = 0x46;
3751 }
3752 else
3753 {
3754 if (ftdi_read_eeprom_location( ftdi, 0x40, &eeprom_value))
3755 ftdi_error_return(-4, "Reading failed failed");
3756 if (eeprom_value == MAGIC)
3757 ftdi->eeprom->chip = 0x56;
3758 else
3759 {
3760 if (ftdi_read_eeprom_location( ftdi, 0xc0, &eeprom_value))
3761 ftdi_error_return(-4, "Reading failed failed");
3762 if (eeprom_value == MAGIC)
3763 ftdi->eeprom->chip = 0x66;
3764 else
3765 {
3766 ftdi->eeprom->chip = -1;
3767 }
3768 }
3769 }
3770 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
3771 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
3772 ftdi_error_return(-1, "unable to erase eeprom");
3773 return 0;
3774}
3775
3776/**
3777 Get string representation for last error code
3778
3779 \param ftdi pointer to ftdi_context
3780
3781 \retval Pointer to error string
3782*/
3783char *ftdi_get_error_string (struct ftdi_context *ftdi)
3784{
3785 if (ftdi == NULL)
3786 return "";
3787
3788 return ftdi->error_str;
3789}
3790
3791/* @} end of doxygen libftdi group */
A library to talk to FTDI chips