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