git://developer.intra2net.com / libftdi / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Check ftdi pointer before accessing it
[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_set_interface(ftdi, INTERFACE_ANY);
97 ftdi->bitbang_mode = 1; /* when bitbang is enabled this holds the number of the mode */
98
99 ftdi->error_str = NULL;
100
101 ftdi->eeprom_size = FTDI_DEFAULT_EEPROM_SIZE;
102
103 /* All fine. Now allocate the readbuffer */
104 return ftdi_read_data_set_chunksize(ftdi, 4096);
105}
106
107/**
108 Allocate and initialize a new ftdi_context
109
110 \return a pointer to a new ftdi_context, or NULL on failure
111*/
112struct ftdi_context *ftdi_new(void)
113{
114 struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context));
115
116 if (ftdi == NULL)
117 {
118 return NULL;
119 }
120
121 if (ftdi_init(ftdi) != 0)
122 {
123 free(ftdi);
124 return NULL;
125 }
126
127 return ftdi;
128}
129
130/**
131 Open selected channels on a chip, otherwise use first channel.
132
133 \param ftdi pointer to ftdi_context
134 \param interface Interface to use for FT2232C/2232H/4232H chips.
135
136 \retval 0: all fine
137 \retval -1: unknown interface
138 \retval -2: USB device unavailable
139*/
140int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
141{
142 if (ftdi == NULL)
143 ftdi_error_return(-2, "USB device unavailable");
144
145 switch (interface)
146 {
147 case INTERFACE_ANY:
148 case INTERFACE_A:
149 ftdi->interface = 0;
150 ftdi->index = INTERFACE_A;
151 ftdi->in_ep = 0x02;
152 ftdi->out_ep = 0x81;
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 // Determine maximum packet size
535 ftdi->max_packet_size = _ftdi_determine_max_packet_size(ftdi, dev);
536
537 if (ftdi_set_baudrate (ftdi, 9600) != 0)
538 {
539 ftdi_usb_close_internal (ftdi);
540 ftdi_error_return(-7, "set baudrate failed");
541 }
542
543 ftdi_error_return(0, "all fine");
544}
545
546/**
547 Opens the first device with a given vendor and product ids.
548
549 \param ftdi pointer to ftdi_context
550 \param vendor Vendor ID
551 \param product Product ID
552
553 \retval same as ftdi_usb_open_desc()
554*/
555int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
556{
557 return ftdi_usb_open_desc(ftdi, vendor, product, NULL, NULL);
558}
559
560/**
561 Opens the first device with a given, vendor id, product id,
562 description and serial.
563
564 \param ftdi pointer to ftdi_context
565 \param vendor Vendor ID
566 \param product Product ID
567 \param description Description to search for. Use NULL if not needed.
568 \param serial Serial to search for. Use NULL if not needed.
569
570 \retval 0: all fine
571 \retval -3: usb device not found
572 \retval -4: unable to open device
573 \retval -5: unable to claim device
574 \retval -6: reset failed
575 \retval -7: set baudrate failed
576 \retval -8: get product description failed
577 \retval -9: get serial number failed
578 \retval -11: libusb_init() failed
579 \retval -12: libusb_get_device_list() failed
580 \retval -13: libusb_get_device_descriptor() failed
581*/
582int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
583 const char* description, const char* serial)
584{
585 return ftdi_usb_open_desc_index(ftdi,vendor,product,description,serial,0);
586}
587
588/**
589 Opens the index-th device with a given, vendor id, product id,
590 description and serial.
591
592 \param ftdi pointer to ftdi_context
593 \param vendor Vendor ID
594 \param product Product ID
595 \param description Description to search for. Use NULL if not needed.
596 \param serial Serial to search for. Use NULL if not needed.
597 \param index Number of matching device to open if there are more than one, starts with 0.
598
599 \retval 0: all fine
600 \retval -1: usb_find_busses() failed
601 \retval -2: usb_find_devices() failed
602 \retval -3: usb device not found
603 \retval -4: unable to open device
604 \retval -5: unable to claim device
605 \retval -6: reset failed
606 \retval -7: set baudrate failed
607 \retval -8: get product description failed
608 \retval -9: get serial number failed
609 \retval -10: unable to close device
610 \retval -11: ftdi context invalid
611*/
612int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product,
613 const char* description, const char* serial, unsigned int index)
614{
615 libusb_device *dev;
616 libusb_device **devs;
617 char string[256];
618 int i = 0;
619
620 if (ftdi == NULL)
621 ftdi_error_return(-11, "ftdi context invalid");
622
623 if (libusb_init(&ftdi->usb_ctx) < 0)
624 ftdi_error_return(-11, "libusb_init() failed");
625
626 if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
627 ftdi_error_return(-12, "libusb_get_device_list() failed");
628
629 while ((dev = devs[i++]) != NULL)
630 {
631 struct libusb_device_descriptor desc;
632 int res;
633
634 if (libusb_get_device_descriptor(dev, &desc) < 0)
635 ftdi_error_return_free_device_list(-13, "libusb_get_device_descriptor() failed", devs);
636
637 if (desc.idVendor == vendor && desc.idProduct == product)
638 {
639 if (libusb_open(dev, &ftdi->usb_dev) < 0)
640 ftdi_error_return_free_device_list(-4, "usb_open() failed", devs);
641
642 if (description != NULL)
643 {
644 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)string, sizeof(string)) < 0)
645 {
646 libusb_close (ftdi->usb_dev);
647 ftdi_error_return_free_device_list(-8, "unable to fetch product description", devs);
648 }
649 if (strncmp(string, description, sizeof(string)) != 0)
650 {
651 libusb_close (ftdi->usb_dev);
652 continue;
653 }
654 }
655 if (serial != NULL)
656 {
657 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)string, sizeof(string)) < 0)
658 {
659 ftdi_usb_close_internal (ftdi);
660 ftdi_error_return_free_device_list(-9, "unable to fetch serial number", devs);
661 }
662 if (strncmp(string, serial, sizeof(string)) != 0)
663 {
664 ftdi_usb_close_internal (ftdi);
665 continue;
666 }
667 }
668
669 ftdi_usb_close_internal (ftdi);
670
671 if (index > 0)
672 {
673 index--;
674 continue;
675 }
676
677 res = ftdi_usb_open_dev(ftdi, dev);
678 libusb_free_device_list(devs,1);
679 return res;
680 }
681 }
682
683 // device not found
684 ftdi_error_return_free_device_list(-3, "device not found", devs);
685}
686
687/**
688 Opens the ftdi-device described by a description-string.
689 Intended to be used for parsing a device-description given as commandline argument.
690
691 \param ftdi pointer to ftdi_context
692 \param description NULL-terminated description-string, using this format:
693 \li <tt>d:\<devicenode></tt> path of bus and device-node (e.g. "003/001") within usb device tree (usually at /proc/bus/usb/)
694 \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")
695 \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
696 \li <tt>s:\<vendor>:\<product>:\<serial></tt> first device with given vendor id, product id and serial string
697
698 \note The description format may be extended in later versions.
699
700 \retval 0: all fine
701 \retval -1: libusb_init() failed
702 \retval -2: libusb_get_device_list() failed
703 \retval -3: usb device not found
704 \retval -4: unable to open device
705 \retval -5: unable to claim device
706 \retval -6: reset failed
707 \retval -7: set baudrate failed
708 \retval -8: get product description failed
709 \retval -9: get serial number failed
710 \retval -10: unable to close device
711 \retval -11: illegal description format
712 \retval -12: ftdi context invalid
713*/
714int ftdi_usb_open_string(struct ftdi_context *ftdi, const char* description)
715{
716 if (ftdi == NULL)
717 ftdi_error_return(-12, "ftdi context invalid");
718
719 if (description[0] == 0 || description[1] != ':')
720 ftdi_error_return(-11, "illegal description format");
721
722 if (description[0] == 'd')
723 {
724 libusb_device *dev;
725 libusb_device **devs;
726 unsigned int bus_number, device_address;
727 int i = 0;
728
729 if (libusb_init (&ftdi->usb_ctx) < 0)
730 ftdi_error_return(-1, "libusb_init() failed");
731
732 if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
733 ftdi_error_return(-2, "libusb_get_device_list() failed");
734
735 /* XXX: This doesn't handle symlinks/odd paths/etc... */
736 if (sscanf (description + 2, "%u/%u", &bus_number, &device_address) != 2)
737 ftdi_error_return_free_device_list(-11, "illegal description format", devs);
738
739 while ((dev = devs[i++]) != NULL)
740 {
741 int ret;
742 if (bus_number == libusb_get_bus_number (dev)
743 && device_address == libusb_get_device_address (dev))
744 {
745 ret = ftdi_usb_open_dev(ftdi, dev);
746 libusb_free_device_list(devs,1);
747 return ret;
748 }
749 }
750
751 // device not found
752 ftdi_error_return_free_device_list(-3, "device not found", devs);
753 }
754 else if (description[0] == 'i' || description[0] == 's')
755 {
756 unsigned int vendor;
757 unsigned int product;
758 unsigned int index=0;
759 const char *serial=NULL;
760 const char *startp, *endp;
761
762 errno=0;
763 startp=description+2;
764 vendor=strtoul((char*)startp,(char**)&endp,0);
765 if (*endp != ':' || endp == startp || errno != 0)
766 ftdi_error_return(-11, "illegal description format");
767
768 startp=endp+1;
769 product=strtoul((char*)startp,(char**)&endp,0);
770 if (endp == startp || errno != 0)
771 ftdi_error_return(-11, "illegal description format");
772
773 if (description[0] == 'i' && *endp != 0)
774 {
775 /* optional index field in i-mode */
776 if (*endp != ':')
777 ftdi_error_return(-11, "illegal description format");
778
779 startp=endp+1;
780 index=strtoul((char*)startp,(char**)&endp,0);
781 if (*endp != 0 || endp == startp || errno != 0)
782 ftdi_error_return(-11, "illegal description format");
783 }
784 if (description[0] == 's')
785 {
786 if (*endp != ':')
787 ftdi_error_return(-11, "illegal description format");
788
789 /* rest of the description is the serial */
790 serial=endp+1;
791 }
792
793 return ftdi_usb_open_desc_index(ftdi, vendor, product, NULL, serial, index);
794 }
795 else
796 {
797 ftdi_error_return(-11, "illegal description format");
798 }
799}
800
801/**
802 Resets the ftdi device.
803
804 \param ftdi pointer to ftdi_context
805
806 \retval 0: all fine
807 \retval -1: FTDI reset failed
808 \retval -2: USB device unavailable
809*/
810int ftdi_usb_reset(struct ftdi_context *ftdi)
811{
812 if (ftdi == NULL || ftdi->usb_dev == NULL)
813 ftdi_error_return(-2, "USB device unavailable");
814
815 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
816 SIO_RESET_REQUEST, SIO_RESET_SIO,
817 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
818 ftdi_error_return(-1,"FTDI reset failed");
819
820 // Invalidate data in the readbuffer
821 ftdi->readbuffer_offset = 0;
822 ftdi->readbuffer_remaining = 0;
823
824 return 0;
825}
826
827/**
828 Clears the read buffer on the chip and the internal read buffer.
829
830 \param ftdi pointer to ftdi_context
831
832 \retval 0: all fine
833 \retval -1: read buffer purge failed
834 \retval -2: USB device unavailable
835*/
836int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
837{
838 if (ftdi == NULL || ftdi->usb_dev == NULL)
839 ftdi_error_return(-2, "USB device unavailable");
840
841 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
842 SIO_RESET_REQUEST, SIO_RESET_PURGE_RX,
843 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
844 ftdi_error_return(-1, "FTDI purge of RX buffer failed");
845
846 // Invalidate data in the readbuffer
847 ftdi->readbuffer_offset = 0;
848 ftdi->readbuffer_remaining = 0;
849
850 return 0;
851}
852
853/**
854 Clears the write buffer on the chip.
855
856 \param ftdi pointer to ftdi_context
857
858 \retval 0: all fine
859 \retval -1: write buffer purge failed
860 \retval -2: USB device unavailable
861*/
862int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
863{
864 if (ftdi == NULL || ftdi->usb_dev == NULL)
865 ftdi_error_return(-2, "USB device unavailable");
866
867 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
868 SIO_RESET_REQUEST, SIO_RESET_PURGE_TX,
869 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
870 ftdi_error_return(-1, "FTDI purge of TX buffer failed");
871
872 return 0;
873}
874
875/**
876 Clears the buffers on the chip and the internal read buffer.
877
878 \param ftdi pointer to ftdi_context
879
880 \retval 0: all fine
881 \retval -1: read buffer purge failed
882 \retval -2: write buffer purge failed
883 \retval -3: USB device unavailable
884*/
885int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
886{
887 int result;
888
889 if (ftdi == NULL || ftdi->usb_dev == NULL)
890 ftdi_error_return(-3, "USB device unavailable");
891
892 result = ftdi_usb_purge_rx_buffer(ftdi);
893 if (result < 0)
894 return -1;
895
896 result = ftdi_usb_purge_tx_buffer(ftdi);
897 if (result < 0)
898 return -2;
899
900 return 0;
901}
902
903
904
905/**
906 Closes the ftdi device. Call ftdi_deinit() if you're cleaning up.
907
908 \param ftdi pointer to ftdi_context
909
910 \retval 0: all fine
911 \retval -1: usb_release failed
912 \retval -3: ftdi context invalid
913*/
914int ftdi_usb_close(struct ftdi_context *ftdi)
915{
916 int rtn = 0;
917
918 if (ftdi == NULL)
919 ftdi_error_return(-3, "ftdi context invalid");
920
921 if (ftdi->usb_dev != NULL)
922 if (libusb_release_interface(ftdi->usb_dev, ftdi->interface) < 0)
923 rtn = -1;
924
925 ftdi_usb_close_internal (ftdi);
926
927 return rtn;
928}
929
930/**
931 ftdi_convert_baudrate returns nearest supported baud rate to that requested.
932 Function is only used internally
933 \internal
934*/
935static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
936 unsigned short *value, unsigned short *index)
937{
938 static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
939 static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
940 static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
941 int divisor, best_divisor, best_baud, best_baud_diff;
942 unsigned long encoded_divisor;
943 int i;
944
945 if (baudrate <= 0)
946 {
947 // Return error
948 return -1;
949 }
950
951 divisor = 24000000 / baudrate;
952
953 if (ftdi->type == TYPE_AM)
954 {
955 // Round down to supported fraction (AM only)
956 divisor -= am_adjust_dn[divisor & 7];
957 }
958
959 // Try this divisor and the one above it (because division rounds down)
960 best_divisor = 0;
961 best_baud = 0;
962 best_baud_diff = 0;
963 for (i = 0; i < 2; i++)
964 {
965 int try_divisor = divisor + i;
966 int baud_estimate;
967 int baud_diff;
968
969 // Round up to supported divisor value
970 if (try_divisor <= 8)
971 {
972 // Round up to minimum supported divisor
973 try_divisor = 8;
974 }
975 else if (ftdi->type != TYPE_AM && try_divisor < 12)
976 {
977 // BM doesn't support divisors 9 through 11 inclusive
978 try_divisor = 12;
979 }
980 else if (divisor < 16)
981 {
982 // AM doesn't support divisors 9 through 15 inclusive
983 try_divisor = 16;
984 }
985 else
986 {
987 if (ftdi->type == TYPE_AM)
988 {
989 // Round up to supported fraction (AM only)
990 try_divisor += am_adjust_up[try_divisor & 7];
991 if (try_divisor > 0x1FFF8)
992 {
993 // Round down to maximum supported divisor value (for AM)
994 try_divisor = 0x1FFF8;
995 }
996 }
997 else
998 {
999 if (try_divisor > 0x1FFFF)
1000 {
1001 // Round down to maximum supported divisor value (for BM)
1002 try_divisor = 0x1FFFF;
1003 }
1004 }
1005 }
1006 // Get estimated baud rate (to nearest integer)
1007 baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
1008 // Get absolute difference from requested baud rate
1009 if (baud_estimate < baudrate)
1010 {
1011 baud_diff = baudrate - baud_estimate;
1012 }
1013 else
1014 {
1015 baud_diff = baud_estimate - baudrate;
1016 }
1017 if (i == 0 || baud_diff < best_baud_diff)
1018 {
1019 // Closest to requested baud rate so far
1020 best_divisor = try_divisor;
1021 best_baud = baud_estimate;
1022 best_baud_diff = baud_diff;
1023 if (baud_diff == 0)
1024 {
1025 // Spot on! No point trying
1026 break;
1027 }
1028 }
1029 }
1030 // Encode the best divisor value
1031 encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
1032 // Deal with special cases for encoded value
1033 if (encoded_divisor == 1)
1034 {
1035 encoded_divisor = 0; // 3000000 baud
1036 }
1037 else if (encoded_divisor == 0x4001)
1038 {
1039 encoded_divisor = 1; // 2000000 baud (BM only)
1040 }
1041 // Split into "value" and "index" values
1042 *value = (unsigned short)(encoded_divisor & 0xFFFF);
1043 if (ftdi->type == TYPE_2232C || ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H)
1044 {
1045 *index = (unsigned short)(encoded_divisor >> 8);
1046 *index &= 0xFF00;
1047 *index |= ftdi->index;
1048 }
1049 else
1050 *index = (unsigned short)(encoded_divisor >> 16);
1051
1052 // Return the nearest baud rate
1053 return best_baud;
1054}
1055
1056/**
1057 Sets the chip baud rate
1058
1059 \param ftdi pointer to ftdi_context
1060 \param baudrate baud rate to set
1061
1062 \retval 0: all fine
1063 \retval -1: invalid baudrate
1064 \retval -2: setting baudrate failed
1065 \retval -3: USB device unavailable
1066*/
1067int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
1068{
1069 unsigned short value, index;
1070 int actual_baudrate;
1071
1072 if (ftdi == NULL || ftdi->usb_dev == NULL)
1073 ftdi_error_return(-3, "USB device unavailable");
1074
1075 if (ftdi->bitbang_enabled)
1076 {
1077 baudrate = baudrate*4;
1078 }
1079
1080 actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
1081 if (actual_baudrate <= 0)
1082 ftdi_error_return (-1, "Silly baudrate <= 0.");
1083
1084 // Check within tolerance (about 5%)
1085 if ((actual_baudrate * 2 < baudrate /* Catch overflows */ )
1086 || ((actual_baudrate < baudrate)
1087 ? (actual_baudrate * 21 < baudrate * 20)
1088 : (baudrate * 21 < actual_baudrate * 20)))
1089 ftdi_error_return (-1, "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4");
1090
1091 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1092 SIO_SET_BAUDRATE_REQUEST, value,
1093 index, NULL, 0, ftdi->usb_write_timeout) < 0)
1094 ftdi_error_return (-2, "Setting new baudrate failed");
1095
1096 ftdi->baudrate = baudrate;
1097 return 0;
1098}
1099
1100/**
1101 Set (RS232) line characteristics.
1102 The break type can only be set via ftdi_set_line_property2()
1103 and defaults to "off".
1104
1105 \param ftdi pointer to ftdi_context
1106 \param bits Number of bits
1107 \param sbit Number of stop bits
1108 \param parity Parity mode
1109
1110 \retval 0: all fine
1111 \retval -1: Setting line property failed
1112*/
1113int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
1114 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
1115{
1116 return ftdi_set_line_property2(ftdi, bits, sbit, parity, BREAK_OFF);
1117}
1118
1119/**
1120 Set (RS232) line characteristics
1121
1122 \param ftdi pointer to ftdi_context
1123 \param bits Number of bits
1124 \param sbit Number of stop bits
1125 \param parity Parity mode
1126 \param break_type Break type
1127
1128 \retval 0: all fine
1129 \retval -1: Setting line property failed
1130 \retval -2: USB device unavailable
1131*/
1132int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
1133 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity,
1134 enum ftdi_break_type break_type)
1135{
1136 unsigned short value = bits;
1137
1138 if (ftdi == NULL || ftdi->usb_dev == NULL)
1139 ftdi_error_return(-2, "USB device unavailable");
1140
1141 switch (parity)
1142 {
1143 case NONE:
1144 value |= (0x00 << 8);
1145 break;
1146 case ODD:
1147 value |= (0x01 << 8);
1148 break;
1149 case EVEN:
1150 value |= (0x02 << 8);
1151 break;
1152 case MARK:
1153 value |= (0x03 << 8);
1154 break;
1155 case SPACE:
1156 value |= (0x04 << 8);
1157 break;
1158 }
1159
1160 switch (sbit)
1161 {
1162 case STOP_BIT_1:
1163 value |= (0x00 << 11);
1164 break;
1165 case STOP_BIT_15:
1166 value |= (0x01 << 11);
1167 break;
1168 case STOP_BIT_2:
1169 value |= (0x02 << 11);
1170 break;
1171 }
1172
1173 switch (break_type)
1174 {
1175 case BREAK_OFF:
1176 value |= (0x00 << 14);
1177 break;
1178 case BREAK_ON:
1179 value |= (0x01 << 14);
1180 break;
1181 }
1182
1183 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1184 SIO_SET_DATA_REQUEST, value,
1185 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1186 ftdi_error_return (-1, "Setting new line property failed");
1187
1188 return 0;
1189}
1190
1191/**
1192 Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip
1193
1194 \param ftdi pointer to ftdi_context
1195 \param buf Buffer with the data
1196 \param size Size of the buffer
1197
1198 \retval -666: USB device unavailable
1199 \retval <0: error code from usb_bulk_write()
1200 \retval >0: number of bytes written
1201*/
1202int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1203{
1204 int offset = 0;
1205 int actual_length;
1206
1207 if (ftdi == NULL || ftdi->usb_dev == NULL)
1208 ftdi_error_return(-666, "USB device unavailable");
1209
1210 while (offset < size)
1211 {
1212 int write_size = ftdi->writebuffer_chunksize;
1213
1214 if (offset+write_size > size)
1215 write_size = size-offset;
1216
1217 if (libusb_bulk_transfer(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, &actual_length, ftdi->usb_write_timeout) < 0)
1218 ftdi_error_return(-1, "usb bulk write failed");
1219
1220 offset += actual_length;
1221 }
1222
1223 return offset;
1224}
1225
1226static void ftdi_read_data_cb(struct libusb_transfer *transfer)
1227{
1228 struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1229 struct ftdi_context *ftdi = tc->ftdi;
1230 int packet_size, actual_length, num_of_chunks, chunk_remains, i, ret;
1231
1232 packet_size = ftdi->max_packet_size;
1233
1234 actual_length = transfer->actual_length;
1235
1236 if (actual_length > 2)
1237 {
1238 // skip FTDI status bytes.
1239 // Maybe stored in the future to enable modem use
1240 num_of_chunks = actual_length / packet_size;
1241 chunk_remains = actual_length % packet_size;
1242 //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);
1243
1244 ftdi->readbuffer_offset += 2;
1245 actual_length -= 2;
1246
1247 if (actual_length > packet_size - 2)
1248 {
1249 for (i = 1; i < num_of_chunks; i++)
1250 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1251 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1252 packet_size - 2);
1253 if (chunk_remains > 2)
1254 {
1255 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1256 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1257 chunk_remains-2);
1258 actual_length -= 2*num_of_chunks;
1259 }
1260 else
1261 actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1262 }
1263
1264 if (actual_length > 0)
1265 {
1266 // data still fits in buf?
1267 if (tc->offset + actual_length <= tc->size)
1268 {
1269 memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, actual_length);
1270 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1271 tc->offset += actual_length;
1272
1273 ftdi->readbuffer_offset = 0;
1274 ftdi->readbuffer_remaining = 0;
1275
1276 /* Did we read exactly the right amount of bytes? */
1277 if (tc->offset == tc->size)
1278 {
1279 //printf("read_data exact rem %d offset %d\n",
1280 //ftdi->readbuffer_remaining, offset);
1281 tc->completed = 1;
1282 return;
1283 }
1284 }
1285 else
1286 {
1287 // only copy part of the data or size <= readbuffer_chunksize
1288 int part_size = tc->size - tc->offset;
1289 memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, part_size);
1290 tc->offset += part_size;
1291
1292 ftdi->readbuffer_offset += part_size;
1293 ftdi->readbuffer_remaining = actual_length - part_size;
1294
1295 /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1296 part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
1297 tc->completed = 1;
1298 return;
1299 }
1300 }
1301 }
1302 ret = libusb_submit_transfer (transfer);
1303 if (ret < 0)
1304 tc->completed = 1;
1305}
1306
1307
1308static void ftdi_write_data_cb(struct libusb_transfer *transfer)
1309{
1310 struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1311 struct ftdi_context *ftdi = tc->ftdi;
1312
1313 tc->offset += transfer->actual_length;
1314
1315 if (tc->offset == tc->size)
1316 {
1317 tc->completed = 1;
1318 }
1319 else
1320 {
1321 int write_size = ftdi->writebuffer_chunksize;
1322 int ret;
1323
1324 if (tc->offset + write_size > tc->size)
1325 write_size = tc->size - tc->offset;
1326
1327 transfer->length = write_size;
1328 transfer->buffer = tc->buf + tc->offset;
1329 ret = libusb_submit_transfer (transfer);
1330 if (ret < 0)
1331 tc->completed = 1;
1332 }
1333}
1334
1335
1336/**
1337 Writes data to the chip. Does not wait for completion of the transfer
1338 nor does it make sure that the transfer was successful.
1339
1340 Use libusb 1.0 asynchronous API.
1341
1342 \param ftdi pointer to ftdi_context
1343 \param buf Buffer with the data
1344 \param size Size of the buffer
1345
1346 \retval NULL: Some error happens when submit transfer
1347 \retval !NULL: Pointer to a ftdi_transfer_control
1348*/
1349
1350struct ftdi_transfer_control *ftdi_write_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
1351{
1352 struct ftdi_transfer_control *tc;
1353 struct libusb_transfer *transfer = libusb_alloc_transfer(0);
1354 int write_size, ret;
1355
1356 if (ftdi == NULL || ftdi->usb_dev == NULL)
1357 {
1358 libusb_free_transfer(transfer);
1359 return NULL;
1360 }
1361
1362 tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
1363
1364 if (!tc || !transfer)
1365 return NULL;
1366
1367 tc->ftdi = ftdi;
1368 tc->completed = 0;
1369 tc->buf = buf;
1370 tc->size = size;
1371 tc->offset = 0;
1372
1373 if (size < ftdi->writebuffer_chunksize)
1374 write_size = size;
1375 else
1376 write_size = ftdi->writebuffer_chunksize;
1377
1378 libusb_fill_bulk_transfer(transfer, ftdi->usb_dev, ftdi->in_ep, buf,
1379 write_size, ftdi_write_data_cb, tc,
1380 ftdi->usb_write_timeout);
1381 transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1382
1383 ret = libusb_submit_transfer(transfer);
1384 if (ret < 0)
1385 {
1386 libusb_free_transfer(transfer);
1387 tc->completed = 1;
1388 tc->transfer = NULL;
1389 return NULL;
1390 }
1391 tc->transfer = transfer;
1392
1393 return tc;
1394}
1395
1396/**
1397 Reads data from the chip. Does not wait for completion of the transfer
1398 nor does it make sure that the transfer was successful.
1399
1400 Use libusb 1.0 asynchronous API.
1401
1402 \param ftdi pointer to ftdi_context
1403 \param buf Buffer with the data
1404 \param size Size of the buffer
1405
1406 \retval NULL: Some error happens when submit transfer
1407 \retval !NULL: Pointer to a ftdi_transfer_control
1408*/
1409
1410struct ftdi_transfer_control *ftdi_read_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
1411{
1412 struct ftdi_transfer_control *tc;
1413 struct libusb_transfer *transfer;
1414 int ret;
1415
1416 if (ftdi == NULL || ftdi->usb_dev == NULL)
1417 return NULL;
1418
1419 tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
1420 if (!tc)
1421 return NULL;
1422
1423 tc->ftdi = ftdi;
1424 tc->buf = buf;
1425 tc->size = size;
1426
1427 if (size <= ftdi->readbuffer_remaining)
1428 {
1429 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1430
1431 // Fix offsets
1432 ftdi->readbuffer_remaining -= size;
1433 ftdi->readbuffer_offset += size;
1434
1435 /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1436
1437 tc->completed = 1;
1438 tc->offset = size;
1439 tc->transfer = NULL;
1440 return tc;
1441 }
1442
1443 tc->completed = 0;
1444 if (ftdi->readbuffer_remaining != 0)
1445 {
1446 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1447
1448 tc->offset = ftdi->readbuffer_remaining;
1449 }
1450 else
1451 tc->offset = 0;
1452
1453 transfer = libusb_alloc_transfer(0);
1454 if (!transfer)
1455 {
1456 free (tc);
1457 return NULL;
1458 }
1459
1460 ftdi->readbuffer_remaining = 0;
1461 ftdi->readbuffer_offset = 0;
1462
1463 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);
1464 transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1465
1466 ret = libusb_submit_transfer(transfer);
1467 if (ret < 0)
1468 {
1469 libusb_free_transfer(transfer);
1470 free (tc);
1471 return NULL;
1472 }
1473 tc->transfer = transfer;
1474
1475 return tc;
1476}
1477
1478/**
1479 Wait for completion of the transfer.
1480
1481 Use libusb 1.0 asynchronous API.
1482
1483 \param tc pointer to ftdi_transfer_control
1484
1485 \retval < 0: Some error happens
1486 \retval >= 0: Data size transferred
1487*/
1488
1489int ftdi_transfer_data_done(struct ftdi_transfer_control *tc)
1490{
1491 int ret;
1492
1493 while (!tc->completed)
1494 {
1495 ret = libusb_handle_events(tc->ftdi->usb_ctx);
1496 if (ret < 0)
1497 {
1498 if (ret == LIBUSB_ERROR_INTERRUPTED)
1499 continue;
1500 libusb_cancel_transfer(tc->transfer);
1501 while (!tc->completed)
1502 if (libusb_handle_events(tc->ftdi->usb_ctx) < 0)
1503 break;
1504 libusb_free_transfer(tc->transfer);
1505 free (tc);
1506 return ret;
1507 }
1508 }
1509
1510 ret = tc->offset;
1511 /**
1512 * tc->transfer could be NULL if "(size <= ftdi->readbuffer_remaining)"
1513 * at ftdi_read_data_submit(). Therefore, we need to check it here.
1514 **/
1515 if (tc->transfer)
1516 {
1517 if (tc->transfer->status != LIBUSB_TRANSFER_COMPLETED)
1518 ret = -1;
1519 libusb_free_transfer(tc->transfer);
1520 }
1521 free(tc);
1522 return ret;
1523}
1524
1525/**
1526 Configure write buffer chunk size.
1527 Default is 4096.
1528
1529 \param ftdi pointer to ftdi_context
1530 \param chunksize Chunk size
1531
1532 \retval 0: all fine
1533 \retval -1: ftdi context invalid
1534*/
1535int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1536{
1537 if (ftdi == NULL)
1538 ftdi_error_return(-1, "ftdi context invalid");
1539
1540 ftdi->writebuffer_chunksize = chunksize;
1541 return 0;
1542}
1543
1544/**
1545 Get write buffer chunk size.
1546
1547 \param ftdi pointer to ftdi_context
1548 \param chunksize Pointer to store chunk size in
1549
1550 \retval 0: all fine
1551 \retval -1: ftdi context invalid
1552*/
1553int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1554{
1555 if (ftdi == NULL)
1556 ftdi_error_return(-1, "ftdi context invalid");
1557
1558 *chunksize = ftdi->writebuffer_chunksize;
1559 return 0;
1560}
1561
1562/**
1563 Reads data in chunks (see ftdi_read_data_set_chunksize()) from the chip.
1564
1565 Automatically strips the two modem status bytes transfered during every read.
1566
1567 \param ftdi pointer to ftdi_context
1568 \param buf Buffer to store data in
1569 \param size Size of the buffer
1570
1571 \retval -666: USB device unavailable
1572 \retval <0: error code from libusb_bulk_transfer()
1573 \retval 0: no data was available
1574 \retval >0: number of bytes read
1575
1576*/
1577int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1578{
1579 int offset = 0, ret, i, num_of_chunks, chunk_remains;
1580 int packet_size = ftdi->max_packet_size;
1581 int actual_length = 1;
1582
1583 if (ftdi == NULL || ftdi->usb_dev == NULL)
1584 ftdi_error_return(-666, "USB device unavailable");
1585
1586 // Packet size sanity check (avoid division by zero)
1587 if (packet_size == 0)
1588 ftdi_error_return(-1, "max_packet_size is bogus (zero)");
1589
1590 // everything we want is still in the readbuffer?
1591 if (size <= ftdi->readbuffer_remaining)
1592 {
1593 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1594
1595 // Fix offsets
1596 ftdi->readbuffer_remaining -= size;
1597 ftdi->readbuffer_offset += size;
1598
1599 /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1600
1601 return size;
1602 }
1603 // something still in the readbuffer, but not enough to satisfy 'size'?
1604 if (ftdi->readbuffer_remaining != 0)
1605 {
1606 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1607
1608 // Fix offset
1609 offset += ftdi->readbuffer_remaining;
1610 }
1611 // do the actual USB read
1612 while (offset < size && actual_length > 0)
1613 {
1614 ftdi->readbuffer_remaining = 0;
1615 ftdi->readbuffer_offset = 0;
1616 /* returns how much received */
1617 ret = libusb_bulk_transfer (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, &actual_length, ftdi->usb_read_timeout);
1618 if (ret < 0)
1619 ftdi_error_return(ret, "usb bulk read failed");
1620
1621 if (actual_length > 2)
1622 {
1623 // skip FTDI status bytes.
1624 // Maybe stored in the future to enable modem use
1625 num_of_chunks = actual_length / packet_size;
1626 chunk_remains = actual_length % packet_size;
1627 //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);
1628
1629 ftdi->readbuffer_offset += 2;
1630 actual_length -= 2;
1631
1632 if (actual_length > packet_size - 2)
1633 {
1634 for (i = 1; i < num_of_chunks; i++)
1635 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1636 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1637 packet_size - 2);
1638 if (chunk_remains > 2)
1639 {
1640 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1641 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1642 chunk_remains-2);
1643 actual_length -= 2*num_of_chunks;
1644 }
1645 else
1646 actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1647 }
1648 }
1649 else if (actual_length <= 2)
1650 {
1651 // no more data to read?
1652 return offset;
1653 }
1654 if (actual_length > 0)
1655 {
1656 // data still fits in buf?
1657 if (offset+actual_length <= size)
1658 {
1659 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, actual_length);
1660 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1661 offset += actual_length;
1662
1663 /* Did we read exactly the right amount of bytes? */
1664 if (offset == size)
1665 //printf("read_data exact rem %d offset %d\n",
1666 //ftdi->readbuffer_remaining, offset);
1667 return offset;
1668 }
1669 else
1670 {
1671 // only copy part of the data or size <= readbuffer_chunksize
1672 int part_size = size-offset;
1673 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
1674
1675 ftdi->readbuffer_offset += part_size;
1676 ftdi->readbuffer_remaining = actual_length-part_size;
1677 offset += part_size;
1678
1679 /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1680 part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
1681
1682 return offset;
1683 }
1684 }
1685 }
1686 // never reached
1687 return -127;
1688}
1689
1690/**
1691 Configure read buffer chunk size.
1692 Default is 4096.
1693
1694 Automatically reallocates the buffer.
1695
1696 \param ftdi pointer to ftdi_context
1697 \param chunksize Chunk size
1698
1699 \retval 0: all fine
1700 \retval -1: ftdi context invalid
1701*/
1702int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1703{
1704 unsigned char *new_buf;
1705
1706 if (ftdi == NULL)
1707 ftdi_error_return(-1, "ftdi context invalid");
1708
1709 // Invalidate all remaining data
1710 ftdi->readbuffer_offset = 0;
1711 ftdi->readbuffer_remaining = 0;
1712#ifdef __linux__
1713 /* We can't set readbuffer_chunksize larger than MAX_BULK_BUFFER_LENGTH,
1714 which is defined in libusb-1.0. Otherwise, each USB read request will
1715 be divided into multiple URBs. This will cause issues on Linux kernel
1716 older than 2.6.32. */
1717 if (chunksize > 16384)
1718 chunksize = 16384;
1719#endif
1720
1721 if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL)
1722 ftdi_error_return(-1, "out of memory for readbuffer");
1723
1724 ftdi->readbuffer = new_buf;
1725 ftdi->readbuffer_chunksize = chunksize;
1726
1727 return 0;
1728}
1729
1730/**
1731 Get read buffer chunk size.
1732
1733 \param ftdi pointer to ftdi_context
1734 \param chunksize Pointer to store chunk size in
1735
1736 \retval 0: all fine
1737 \retval -1: FTDI context invalid
1738*/
1739int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1740{
1741 if (ftdi == NULL)
1742 ftdi_error_return(-1, "FTDI context invalid");
1743
1744 *chunksize = ftdi->readbuffer_chunksize;
1745 return 0;
1746}
1747
1748
1749/**
1750 Enable bitbang mode.
1751
1752 \deprecated use \ref ftdi_set_bitmode with mode BITMODE_BITBANG instead
1753
1754 \param ftdi pointer to ftdi_context
1755 \param bitmask Bitmask to configure lines.
1756 HIGH/ON value configures a line as output.
1757
1758 \retval 0: all fine
1759 \retval -1: can't enable bitbang mode
1760 \retval -2: USB device unavailable
1761*/
1762int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask)
1763{
1764 unsigned short usb_val;
1765
1766 if (ftdi == NULL || ftdi->usb_dev == NULL)
1767 ftdi_error_return(-2, "USB device unavailable");
1768
1769 usb_val = bitmask; // low byte: bitmask
1770 /* FT2232C: Set bitbang_mode to 2 to enable SPI */
1771 usb_val |= (ftdi->bitbang_mode << 8);
1772
1773 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1774 SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index,
1775 NULL, 0, ftdi->usb_write_timeout) < 0)
1776 ftdi_error_return(-1, "unable to enter bitbang mode. Perhaps not a BM type chip?");
1777
1778 ftdi->bitbang_enabled = 1;
1779 return 0;
1780}
1781
1782/**
1783 Disable bitbang mode.
1784
1785 \param ftdi pointer to ftdi_context
1786
1787 \retval 0: all fine
1788 \retval -1: can't disable bitbang mode
1789 \retval -2: USB device unavailable
1790*/
1791int ftdi_disable_bitbang(struct ftdi_context *ftdi)
1792{
1793 if (ftdi == NULL || ftdi->usb_dev == NULL)
1794 ftdi_error_return(-2, "USB device unavailable");
1795
1796 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)
1797 ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?");
1798
1799 ftdi->bitbang_enabled = 0;
1800 return 0;
1801}
1802
1803/**
1804 Enable/disable bitbang modes.
1805
1806 \param ftdi pointer to ftdi_context
1807 \param bitmask Bitmask to configure lines.
1808 HIGH/ON value configures a line as output.
1809 \param mode Bitbang mode: use the values defined in \ref ftdi_mpsse_mode
1810
1811 \retval 0: all fine
1812 \retval -1: can't enable bitbang mode
1813 \retval -2: USB device unavailable
1814*/
1815int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
1816{
1817 unsigned short usb_val;
1818
1819 if (ftdi == NULL || ftdi->usb_dev == NULL)
1820 ftdi_error_return(-2, "USB device unavailable");
1821
1822 usb_val = bitmask; // low byte: bitmask
1823 usb_val |= (mode << 8);
1824 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)
1825 ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps not a 2232C type chip?");
1826
1827 ftdi->bitbang_mode = mode;
1828 ftdi->bitbang_enabled = (mode == BITMODE_RESET) ? 0 : 1;
1829 return 0;
1830}
1831
1832/**
1833 Directly read pin state, circumventing the read buffer. Useful for bitbang mode.
1834
1835 \param ftdi pointer to ftdi_context
1836 \param pins Pointer to store pins into
1837
1838 \retval 0: all fine
1839 \retval -1: read pins failed
1840 \retval -2: USB device unavailable
1841*/
1842int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
1843{
1844 if (ftdi == NULL || ftdi->usb_dev == NULL)
1845 ftdi_error_return(-2, "USB device unavailable");
1846
1847 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)
1848 ftdi_error_return(-1, "read pins failed");
1849
1850 return 0;
1851}
1852
1853/**
1854 Set latency timer
1855
1856 The FTDI chip keeps data in the internal buffer for a specific
1857 amount of time if the buffer is not full yet to decrease
1858 load on the usb bus.
1859
1860 \param ftdi pointer to ftdi_context
1861 \param latency Value between 1 and 255
1862
1863 \retval 0: all fine
1864 \retval -1: latency out of range
1865 \retval -2: unable to set latency timer
1866 \retval -3: USB device unavailable
1867*/
1868int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
1869{
1870 unsigned short usb_val;
1871
1872 if (latency < 1)
1873 ftdi_error_return(-1, "latency out of range. Only valid for 1-255");
1874
1875 if (ftdi == NULL || ftdi->usb_dev == NULL)
1876 ftdi_error_return(-3, "USB device unavailable");
1877
1878 usb_val = latency;
1879 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)
1880 ftdi_error_return(-2, "unable to set latency timer");
1881
1882 return 0;
1883}
1884
1885/**
1886 Get latency timer
1887
1888 \param ftdi pointer to ftdi_context
1889 \param latency Pointer to store latency value in
1890
1891 \retval 0: all fine
1892 \retval -1: unable to get latency timer
1893 \retval -2: USB device unavailable
1894*/
1895int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
1896{
1897 unsigned short usb_val;
1898
1899 if (ftdi == NULL || ftdi->usb_dev == NULL)
1900 ftdi_error_return(-2, "USB device unavailable");
1901
1902 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)
1903 ftdi_error_return(-1, "reading latency timer failed");
1904
1905 *latency = (unsigned char)usb_val;
1906 return 0;
1907}
1908
1909/**
1910 Poll modem status information
1911
1912 This function allows the retrieve the two status bytes of the device.
1913 The device sends these bytes also as a header for each read access
1914 where they are discarded by ftdi_read_data(). The chip generates
1915 the two stripped status bytes in the absence of data every 40 ms.
1916
1917 Layout of the first byte:
1918 - B0..B3 - must be 0
1919 - B4 Clear to send (CTS)
1920 0 = inactive
1921 1 = active
1922 - B5 Data set ready (DTS)
1923 0 = inactive
1924 1 = active
1925 - B6 Ring indicator (RI)
1926 0 = inactive
1927 1 = active
1928 - B7 Receive line signal detect (RLSD)
1929 0 = inactive
1930 1 = active
1931
1932 Layout of the second byte:
1933 - B0 Data ready (DR)
1934 - B1 Overrun error (OE)
1935 - B2 Parity error (PE)
1936 - B3 Framing error (FE)
1937 - B4 Break interrupt (BI)
1938 - B5 Transmitter holding register (THRE)
1939 - B6 Transmitter empty (TEMT)
1940 - B7 Error in RCVR FIFO
1941
1942 \param ftdi pointer to ftdi_context
1943 \param status Pointer to store status information in. Must be two bytes.
1944
1945 \retval 0: all fine
1946 \retval -1: unable to retrieve status information
1947 \retval -2: USB device unavailable
1948*/
1949int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
1950{
1951 char usb_val[2];
1952
1953 if (ftdi == NULL || ftdi->usb_dev == NULL)
1954 ftdi_error_return(-2, "USB device unavailable");
1955
1956 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)
1957 ftdi_error_return(-1, "getting modem status failed");
1958
1959 *status = (usb_val[1] << 8) | usb_val[0];
1960
1961 return 0;
1962}
1963
1964/**
1965 Set flowcontrol for ftdi chip
1966
1967 \param ftdi pointer to ftdi_context
1968 \param flowctrl flow control to use. should be
1969 SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS or SIO_XON_XOFF_HS
1970
1971 \retval 0: all fine
1972 \retval -1: set flow control failed
1973 \retval -2: USB device unavailable
1974*/
1975int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
1976{
1977 if (ftdi == NULL || ftdi->usb_dev == NULL)
1978 ftdi_error_return(-2, "USB device unavailable");
1979
1980 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1981 SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->index),
1982 NULL, 0, ftdi->usb_write_timeout) < 0)
1983 ftdi_error_return(-1, "set flow control failed");
1984
1985 return 0;
1986}
1987
1988/**
1989 Set dtr line
1990
1991 \param ftdi pointer to ftdi_context
1992 \param state state to set line to (1 or 0)
1993
1994 \retval 0: all fine
1995 \retval -1: set dtr failed
1996 \retval -2: USB device unavailable
1997*/
1998int ftdi_setdtr(struct ftdi_context *ftdi, int state)
1999{
2000 unsigned short usb_val;
2001
2002 if (ftdi == NULL || ftdi->usb_dev == NULL)
2003 ftdi_error_return(-2, "USB device unavailable");
2004
2005 if (state)
2006 usb_val = SIO_SET_DTR_HIGH;
2007 else
2008 usb_val = SIO_SET_DTR_LOW;
2009
2010 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2011 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2012 NULL, 0, ftdi->usb_write_timeout) < 0)
2013 ftdi_error_return(-1, "set dtr failed");
2014
2015 return 0;
2016}
2017
2018/**
2019 Set rts line
2020
2021 \param ftdi pointer to ftdi_context
2022 \param state state to set line to (1 or 0)
2023
2024 \retval 0: all fine
2025 \retval -1: set rts failed
2026 \retval -2: USB device unavailable
2027*/
2028int ftdi_setrts(struct ftdi_context *ftdi, int state)
2029{
2030 unsigned short usb_val;
2031
2032 if (ftdi == NULL || ftdi->usb_dev == NULL)
2033 ftdi_error_return(-2, "USB device unavailable");
2034
2035 if (state)
2036 usb_val = SIO_SET_RTS_HIGH;
2037 else
2038 usb_val = SIO_SET_RTS_LOW;
2039
2040 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2041 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2042 NULL, 0, ftdi->usb_write_timeout) < 0)
2043 ftdi_error_return(-1, "set of rts failed");
2044
2045 return 0;
2046}
2047
2048/**
2049 Set dtr and rts line in one pass
2050
2051 \param ftdi pointer to ftdi_context
2052 \param dtr DTR state to set line to (1 or 0)
2053 \param rts RTS state to set line to (1 or 0)
2054
2055 \retval 0: all fine
2056 \retval -1: set dtr/rts failed
2057 \retval -2: USB device unavailable
2058 */
2059int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
2060{
2061 unsigned short usb_val;
2062
2063 if (ftdi == NULL || ftdi->usb_dev == NULL)
2064 ftdi_error_return(-2, "USB device unavailable");
2065
2066 if (dtr)
2067 usb_val = SIO_SET_DTR_HIGH;
2068 else
2069 usb_val = SIO_SET_DTR_LOW;
2070
2071 if (rts)
2072 usb_val |= SIO_SET_RTS_HIGH;
2073 else
2074 usb_val |= SIO_SET_RTS_LOW;
2075
2076 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2077 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2078 NULL, 0, ftdi->usb_write_timeout) < 0)
2079 ftdi_error_return(-1, "set of rts/dtr failed");
2080
2081 return 0;
2082}
2083
2084/**
2085 Set the special event character
2086
2087 \param ftdi pointer to ftdi_context
2088 \param eventch Event character
2089 \param enable 0 to disable the event character, non-zero otherwise
2090
2091 \retval 0: all fine
2092 \retval -1: unable to set event character
2093 \retval -2: USB device unavailable
2094*/
2095int ftdi_set_event_char(struct ftdi_context *ftdi,
2096 unsigned char eventch, unsigned char enable)
2097{
2098 unsigned short usb_val;
2099
2100 if (ftdi == NULL || ftdi->usb_dev == NULL)
2101 ftdi_error_return(-2, "USB device unavailable");
2102
2103 usb_val = eventch;
2104 if (enable)
2105 usb_val |= 1 << 8;
2106
2107 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)
2108 ftdi_error_return(-1, "setting event character failed");
2109
2110 return 0;
2111}
2112
2113/**
2114 Set error character
2115
2116 \param ftdi pointer to ftdi_context
2117 \param errorch Error character
2118 \param enable 0 to disable the error character, non-zero otherwise
2119
2120 \retval 0: all fine
2121 \retval -1: unable to set error character
2122 \retval -2: USB device unavailable
2123*/
2124int ftdi_set_error_char(struct ftdi_context *ftdi,
2125 unsigned char errorch, unsigned char enable)
2126{
2127 unsigned short usb_val;
2128
2129 if (ftdi == NULL || ftdi->usb_dev == NULL)
2130 ftdi_error_return(-2, "USB device unavailable");
2131
2132 usb_val = errorch;
2133 if (enable)
2134 usb_val |= 1 << 8;
2135
2136 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)
2137 ftdi_error_return(-1, "setting error character failed");
2138
2139 return 0;
2140}
2141
2142/**
2143 Set the eeprom size
2144
2145 \param ftdi pointer to ftdi_context
2146 \param eeprom Pointer to ftdi_eeprom
2147 \param size
2148
2149*/
2150void ftdi_eeprom_setsize(struct ftdi_context *ftdi, struct ftdi_eeprom *eeprom, int size)
2151{
2152 if (ftdi == NULL)
2153 return;
2154
2155 ftdi->eeprom_size=size;
2156 eeprom->size=size;
2157}
2158
2159/**
2160 Init eeprom with default values.
2161
2162 \param eeprom Pointer to ftdi_eeprom
2163*/
2164void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom)
2165{
2166 int i;
2167
2168 if (eeprom == NULL)
2169 return;
2170
2171 eeprom->vendor_id = 0x0403;
2172 eeprom->product_id = 0x6001;
2173
2174 eeprom->self_powered = 1;
2175 eeprom->remote_wakeup = 1;
2176 eeprom->chip_type = TYPE_BM;
2177
2178 eeprom->in_is_isochronous = 0;
2179 eeprom->out_is_isochronous = 0;
2180 eeprom->suspend_pull_downs = 0;
2181
2182 eeprom->use_serial = 0;
2183 eeprom->change_usb_version = 0;
2184 eeprom->usb_version = 0x0200;
2185 eeprom->max_power = 0;
2186
2187 eeprom->manufacturer = NULL;
2188 eeprom->product = NULL;
2189 eeprom->serial = NULL;
2190 for (i=0; i < 5; i++)
2191 {
2192 eeprom->cbus_function[i] = 0;
2193 }
2194 eeprom->high_current = 0;
2195 eeprom->invert = 0;
2196
2197 eeprom->size = FTDI_DEFAULT_EEPROM_SIZE;
2198}
2199
2200/**
2201 Frees allocated memory in eeprom.
2202
2203 \param eeprom Pointer to ftdi_eeprom
2204*/
2205void ftdi_eeprom_free(struct ftdi_eeprom *eeprom)
2206{
2207 if (eeprom->manufacturer != 0) {
2208 free(eeprom->manufacturer);
2209 eeprom->manufacturer = 0;
2210 }
2211 if (eeprom->product != 0) {
2212 free(eeprom->product);
2213 eeprom->product = 0;
2214 }
2215 if (eeprom->serial != 0) {
2216 free(eeprom->serial);
2217 eeprom->serial = 0;
2218 }
2219}
2220
2221/**
2222 Build binary output from ftdi_eeprom structure.
2223 Output is suitable for ftdi_write_eeprom().
2224
2225 \note This function doesn't handle FT2232x devices. Only FT232x.
2226 \param eeprom Pointer to ftdi_eeprom
2227 \param output Buffer of 128 bytes to store eeprom image to
2228
2229 \retval >0: free eeprom size
2230 \retval -1: eeprom size (128 bytes) exceeded by custom strings
2231 \retval -2: Invalid eeprom pointer
2232 \retval -3: Invalid cbus function setting
2233 \retval -4: Chip doesn't support invert
2234 \retval -5: Chip doesn't support high current drive
2235*/
2236int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output)
2237{
2238 unsigned char i, j;
2239 unsigned short checksum, value;
2240 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2241 int size_check;
2242 const int cbus_max[5] = {13, 13, 13, 13, 9};
2243
2244 if (eeprom == NULL)
2245 return -2;
2246
2247 if (eeprom->manufacturer != NULL)
2248 manufacturer_size = strlen(eeprom->manufacturer);
2249 if (eeprom->product != NULL)
2250 product_size = strlen(eeprom->product);
2251 if (eeprom->serial != NULL)
2252 serial_size = strlen(eeprom->serial);
2253
2254 // highest allowed cbus value
2255 for (i = 0; i < 5; i++)
2256 {
2257 if ((eeprom->cbus_function[i] > cbus_max[i]) ||
2258 (eeprom->cbus_function[i] && eeprom->chip_type != TYPE_R)) return -3;
2259 }
2260 if (eeprom->chip_type != TYPE_R)
2261 {
2262 if (eeprom->invert) return -4;
2263 if (eeprom->high_current) return -5;
2264 }
2265
2266 size_check = eeprom->size;
2267 size_check -= 28; // 28 are always in use (fixed)
2268
2269 // Top half of a 256byte eeprom is used just for strings and checksum
2270 // it seems that the FTDI chip will not read these strings from the lower half
2271 // Each string starts with two bytes; offset and type (0x03 for string)
2272 // the checksum needs two bytes, so without the string data that 8 bytes from the top half
2273 if (eeprom->size>=256) size_check = 120;
2274 size_check -= manufacturer_size*2;
2275 size_check -= product_size*2;
2276 size_check -= serial_size*2;
2277
2278 // eeprom size exceeded?
2279 if (size_check < 0)
2280 return (-1);
2281
2282 // empty eeprom
2283 memset (output, 0, eeprom->size);
2284
2285 // Addr 00: High current IO
2286 output[0x00] = eeprom->high_current ? HIGH_CURRENT_DRIVE : 0;
2287 // Addr 01: IN endpoint size (for R type devices, different for FT2232)
2288 if (eeprom->chip_type == TYPE_R) {
2289 output[0x01] = 0x40;
2290 }
2291 // Addr 02: Vendor ID
2292 output[0x02] = eeprom->vendor_id;
2293 output[0x03] = eeprom->vendor_id >> 8;
2294
2295 // Addr 04: Product ID
2296 output[0x04] = eeprom->product_id;
2297 output[0x05] = eeprom->product_id >> 8;
2298
2299 // Addr 06: Device release number (0400h for BM features)
2300 output[0x06] = 0x00;
2301 switch (eeprom->chip_type) {
2302 case TYPE_AM:
2303 output[0x07] = 0x02;
2304 break;
2305 case TYPE_BM:
2306 output[0x07] = 0x04;
2307 break;
2308 case TYPE_2232C:
2309 output[0x07] = 0x05;
2310 break;
2311 case TYPE_R:
2312 output[0x07] = 0x06;
2313 break;
2314 default:
2315 output[0x07] = 0x00;
2316 }
2317
2318 // Addr 08: Config descriptor
2319 // Bit 7: always 1
2320 // Bit 6: 1 if this device is self powered, 0 if bus powered
2321 // Bit 5: 1 if this device uses remote wakeup
2322 // Bit 4: 1 if this device is battery powered
2323 j = 0x80;
2324 if (eeprom->self_powered == 1)
2325 j |= 0x40;
2326 if (eeprom->remote_wakeup == 1)
2327 j |= 0x20;
2328 output[0x08] = j;
2329
2330 // Addr 09: Max power consumption: max power = value * 2 mA
2331 output[0x09] = eeprom->max_power;
2332
2333 // Addr 0A: Chip configuration
2334 // Bit 7: 0 - reserved
2335 // Bit 6: 0 - reserved
2336 // Bit 5: 0 - reserved
2337 // Bit 4: 1 - Change USB version
2338 // Bit 3: 1 - Use the serial number string
2339 // Bit 2: 1 - Enable suspend pull downs for lower power
2340 // Bit 1: 1 - Out EndPoint is Isochronous
2341 // Bit 0: 1 - In EndPoint is Isochronous
2342 //
2343 j = 0;
2344 if (eeprom->in_is_isochronous == 1)
2345 j = j | 1;
2346 if (eeprom->out_is_isochronous == 1)
2347 j = j | 2;
2348 if (eeprom->suspend_pull_downs == 1)
2349 j = j | 4;
2350 if (eeprom->use_serial == 1)
2351 j = j | 8;
2352 if (eeprom->change_usb_version == 1)
2353 j = j | 16;
2354 output[0x0A] = j;
2355
2356 // Addr 0B: Invert data lines
2357 output[0x0B] = eeprom->invert & 0xff;
2358
2359 // Addr 0C: USB version low byte when 0x0A bit 4 is set
2360 // Addr 0D: USB version high byte when 0x0A bit 4 is set
2361 if (eeprom->change_usb_version == 1)
2362 {
2363 output[0x0C] = eeprom->usb_version;
2364 output[0x0D] = eeprom->usb_version >> 8;
2365 }
2366
2367
2368 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2369 // Addr 0F: Length of manufacturer string
2370 output[0x0F] = manufacturer_size*2 + 2;
2371
2372 // Addr 10: Offset of the product string + 0x80, calculated later
2373 // Addr 11: Length of product string
2374 output[0x11] = product_size*2 + 2;
2375
2376 // Addr 12: Offset of the serial string + 0x80, calculated later
2377 // Addr 13: Length of serial string
2378 output[0x13] = serial_size*2 + 2;
2379
2380 // Addr 14: CBUS function: CBUS0, CBUS1
2381 // Addr 15: CBUS function: CBUS2, CBUS3
2382 // Addr 16: CBUS function: CBUS5
2383 output[0x14] = eeprom->cbus_function[0] | (eeprom->cbus_function[1] << 4);
2384 output[0x15] = eeprom->cbus_function[2] | (eeprom->cbus_function[3] << 4);
2385 output[0x16] = eeprom->cbus_function[4];
2386 // Addr 17: Unknown
2387
2388 // Dynamic content
2389 // In images produced by FTDI's FT_Prog for FT232R strings start at 0x18
2390 // Space till 0x18 should be considered as reserved.
2391 if (eeprom->chip_type >= TYPE_R) {
2392 i = 0x18;
2393 } else {
2394 i = 0x14;
2395 }
2396 if (eeprom->size >= 256) i = 0x80;
2397
2398
2399 // Output manufacturer
2400 output[0x0E] = i | 0x80; // calculate offset
2401 output[i++] = manufacturer_size*2 + 2;
2402 output[i++] = 0x03; // type: string
2403 for (j = 0; j < manufacturer_size; j++)
2404 {
2405 output[i] = eeprom->manufacturer[j], i++;
2406 output[i] = 0x00, i++;
2407 }
2408
2409 // Output product name
2410 output[0x10] = i | 0x80; // calculate offset
2411 output[i] = product_size*2 + 2, i++;
2412 output[i] = 0x03, i++;
2413 for (j = 0; j < product_size; j++)
2414 {
2415 output[i] = eeprom->product[j], i++;
2416 output[i] = 0x00, i++;
2417 }
2418
2419 // Output serial
2420 output[0x12] = i | 0x80; // calculate offset
2421 output[i] = serial_size*2 + 2, i++;
2422 output[i] = 0x03, i++;
2423 for (j = 0; j < serial_size; j++)
2424 {
2425 output[i] = eeprom->serial[j], i++;
2426 output[i] = 0x00, i++;
2427 }
2428
2429 // calculate checksum
2430 checksum = 0xAAAA;
2431
2432 for (i = 0; i < eeprom->size/2-1; i++)
2433 {
2434 value = output[i*2];
2435 value += output[(i*2)+1] << 8;
2436
2437 checksum = value^checksum;
2438 checksum = (checksum << 1) | (checksum >> 15);
2439 }
2440
2441 output[eeprom->size-2] = checksum;
2442 output[eeprom->size-1] = checksum >> 8;
2443
2444 return size_check;
2445}
2446
2447/**
2448 Decode binary EEPROM image into an ftdi_eeprom structure.
2449
2450 \param eeprom Pointer to ftdi_eeprom which will be filled in.
2451 \param buf Buffer of \a size bytes of raw eeprom data
2452 \param size size size of eeprom data in bytes
2453
2454 \retval 0: all fine
2455 \retval -1: something went wrong
2456
2457 FIXME: How to pass size? How to handle size field in ftdi_eeprom?
2458 FIXME: Strings are malloc'ed here and should be freed somewhere
2459*/
2460int ftdi_eeprom_decode(struct ftdi_eeprom *eeprom, unsigned char *buf, int size)
2461{
2462 unsigned char i, j;
2463 unsigned short checksum, eeprom_checksum, value;
2464 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2465 int eeprom_size = 128;
2466
2467 if (eeprom == NULL)
2468 return -1;
2469#if 0
2470 size_check = eeprom->size;
2471 size_check -= 28; // 28 are always in use (fixed)
2472
2473 // Top half of a 256byte eeprom is used just for strings and checksum
2474 // it seems that the FTDI chip will not read these strings from the lower half
2475 // Each string starts with two bytes; offset and type (0x03 for string)
2476 // the checksum needs two bytes, so without the string data that 8 bytes from the top half
2477 if (eeprom->size>=256)size_check = 120;
2478 size_check -= manufacturer_size*2;
2479 size_check -= product_size*2;
2480 size_check -= serial_size*2;
2481
2482 // eeprom size exceeded?
2483 if (size_check < 0)
2484 return (-1);
2485#endif
2486
2487 // empty eeprom struct
2488 memset(eeprom, 0, sizeof(struct ftdi_eeprom));
2489
2490 // Addr 00: High current IO
2491 eeprom->high_current = (buf[0x02] & HIGH_CURRENT_DRIVE);
2492
2493 // Addr 02: Vendor ID
2494 eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
2495
2496 // Addr 04: Product ID
2497 eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
2498
2499 value = buf[0x06] + (buf[0x07]<<8);
2500 switch (value)
2501 {
2502 case 0x0600:
2503 eeprom->chip_type = TYPE_R;
2504 break;
2505 case 0x0400:
2506 eeprom->chip_type = TYPE_BM;
2507 break;
2508 case 0x0200:
2509 eeprom->chip_type = TYPE_AM;
2510 break;
2511 default: // Unknown device
2512 eeprom->chip_type = 0;
2513 break;
2514 }
2515
2516 // Addr 08: Config descriptor
2517 // Bit 7: always 1
2518 // Bit 6: 1 if this device is self powered, 0 if bus powered
2519 // Bit 5: 1 if this device uses remote wakeup
2520 // Bit 4: 1 if this device is battery powered
2521 j = buf[0x08];
2522 if (j&0x40) eeprom->self_powered = 1;
2523 if (j&0x20) eeprom->remote_wakeup = 1;
2524
2525 // Addr 09: Max power consumption: max power = value * 2 mA
2526 eeprom->max_power = buf[0x09];
2527
2528 // Addr 0A: Chip configuration
2529 // Bit 7: 0 - reserved
2530 // Bit 6: 0 - reserved
2531 // Bit 5: 0 - reserved
2532 // Bit 4: 1 - Change USB version
2533 // Bit 3: 1 - Use the serial number string
2534 // Bit 2: 1 - Enable suspend pull downs for lower power
2535 // Bit 1: 1 - Out EndPoint is Isochronous
2536 // Bit 0: 1 - In EndPoint is Isochronous
2537 //
2538 j = buf[0x0A];
2539 if (j&0x01) eeprom->in_is_isochronous = 1;
2540 if (j&0x02) eeprom->out_is_isochronous = 1;
2541 if (j&0x04) eeprom->suspend_pull_downs = 1;
2542 if (j&0x08) eeprom->use_serial = 1;
2543 if (j&0x10) eeprom->change_usb_version = 1;
2544
2545 // Addr 0B: Invert data lines
2546 eeprom->invert = buf[0x0B];
2547
2548 // Addr 0C: USB version low byte when 0x0A bit 4 is set
2549 // Addr 0D: USB version high byte when 0x0A bit 4 is set
2550 if (eeprom->change_usb_version == 1)
2551 {
2552 eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
2553 }
2554
2555 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2556 // Addr 0F: Length of manufacturer string
2557 manufacturer_size = buf[0x0F]/2;
2558 if (manufacturer_size > 0) eeprom->manufacturer = malloc(manufacturer_size);
2559 else eeprom->manufacturer = NULL;
2560
2561 // Addr 10: Offset of the product string + 0x80, calculated later
2562 // Addr 11: Length of product string
2563 product_size = buf[0x11]/2;
2564 if (product_size > 0) eeprom->product = malloc(product_size);
2565 else eeprom->product = NULL;
2566
2567 // Addr 12: Offset of the serial string + 0x80, calculated later
2568 // Addr 13: Length of serial string
2569 serial_size = buf[0x13]/2;
2570 if (serial_size > 0) eeprom->serial = malloc(serial_size);
2571 else eeprom->serial = NULL;
2572
2573 // Addr 14: CBUS function: CBUS0, CBUS1
2574 // Addr 15: CBUS function: CBUS2, CBUS3
2575 // Addr 16: CBUS function: CBUS5
2576 if (eeprom->chip_type == TYPE_R) {
2577 eeprom->cbus_function[0] = buf[0x14] & 0x0f;
2578 eeprom->cbus_function[1] = (buf[0x14] >> 4) & 0x0f;
2579 eeprom->cbus_function[2] = buf[0x15] & 0x0f;
2580 eeprom->cbus_function[3] = (buf[0x15] >> 4) & 0x0f;
2581 eeprom->cbus_function[4] = buf[0x16] & 0x0f;
2582 } else {
2583 for (j=0; j<5; j++) eeprom->cbus_function[j] = 0;
2584 }
2585
2586 // Decode manufacturer
2587 i = buf[0x0E] & 0x7f; // offset
2588 for (j=0;j<manufacturer_size-1;j++)
2589 {
2590 eeprom->manufacturer[j] = buf[2*j+i+2];
2591 }
2592 eeprom->manufacturer[j] = '\0';
2593
2594 // Decode product name
2595 i = buf[0x10] & 0x7f; // offset
2596 for (j=0;j<product_size-1;j++)
2597 {
2598 eeprom->product[j] = buf[2*j+i+2];
2599 }
2600 eeprom->product[j] = '\0';
2601
2602 // Decode serial
2603 i = buf[0x12] & 0x7f; // offset
2604 for (j=0;j<serial_size-1;j++)
2605 {
2606 eeprom->serial[j] = buf[2*j+i+2];
2607 }
2608 eeprom->serial[j] = '\0';
2609
2610 // verify checksum
2611 checksum = 0xAAAA;
2612
2613 for (i = 0; i < eeprom_size/2-1; i++)
2614 {
2615 value = buf[i*2];
2616 value += buf[(i*2)+1] << 8;
2617
2618 checksum = value^checksum;
2619 checksum = (checksum << 1) | (checksum >> 15);
2620 }
2621
2622 eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
2623
2624 if (eeprom_checksum != checksum)
2625 {
2626 fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
2627 return -1;
2628 }
2629
2630 return 0;
2631}
2632
2633/**
2634 Read eeprom location
2635
2636 \param ftdi pointer to ftdi_context
2637 \param eeprom_addr Address of eeprom location to be read
2638 \param eeprom_val Pointer to store read eeprom location
2639
2640 \retval 0: all fine
2641 \retval -1: read failed
2642 \retval -2: USB device unavailable
2643*/
2644int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
2645{
2646 if (ftdi == NULL || ftdi->usb_dev == NULL)
2647 ftdi_error_return(-2, "USB device unavailable");
2648
2649 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)
2650 ftdi_error_return(-1, "reading eeprom failed");
2651
2652 return 0;
2653}
2654
2655/**
2656 Read eeprom
2657
2658 \param ftdi pointer to ftdi_context
2659 \param eeprom Pointer to store eeprom into
2660
2661 \retval 0: all fine
2662 \retval -1: read failed
2663 \retval -2: USB device unavailable
2664*/
2665int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
2666{
2667 int i;
2668
2669 if (ftdi == NULL || ftdi->usb_dev == NULL)
2670 ftdi_error_return(-2, "USB device unavailable");
2671
2672 for (i = 0; i < ftdi->eeprom_size/2; i++)
2673 {
2674 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)
2675 ftdi_error_return(-1, "reading eeprom failed");
2676 }
2677
2678 return 0;
2679}
2680
2681/*
2682 ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID
2683 Function is only used internally
2684 \internal
2685*/
2686static unsigned char ftdi_read_chipid_shift(unsigned char value)
2687{
2688 return ((value & 1) << 1) |
2689 ((value & 2) << 5) |
2690 ((value & 4) >> 2) |
2691 ((value & 8) << 4) |
2692 ((value & 16) >> 1) |
2693 ((value & 32) >> 1) |
2694 ((value & 64) >> 4) |
2695 ((value & 128) >> 2);
2696}
2697
2698/**
2699 Read the FTDIChip-ID from R-type devices
2700
2701 \param ftdi pointer to ftdi_context
2702 \param chipid Pointer to store FTDIChip-ID
2703
2704 \retval 0: all fine
2705 \retval -1: read failed
2706 \retval -2: USB device unavailable
2707*/
2708int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
2709{
2710 unsigned int a = 0, b = 0;
2711
2712 if (ftdi == NULL || ftdi->usb_dev == NULL)
2713 ftdi_error_return(-2, "USB device unavailable");
2714
2715 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)
2716 {
2717 a = a << 8 | a >> 8;
2718 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)
2719 {
2720 b = b << 8 | b >> 8;
2721 a = (a << 16) | (b & 0xFFFF);
2722 a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
2723 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
2724 *chipid = a ^ 0xa5f0f7d1;
2725 return 0;
2726 }
2727 }
2728
2729 ftdi_error_return(-1, "read of FTDIChip-ID failed");
2730}
2731
2732/**
2733 Guesses size of eeprom by reading eeprom and comparing halves - will not work with blank eeprom
2734 Call this function then do a write then call again to see if size changes, if so write again.
2735
2736 \param ftdi pointer to ftdi_context
2737 \param eeprom Pointer to store eeprom into
2738 \param maxsize the size of the buffer to read into
2739
2740 \retval -1: eeprom read failed
2741 \retval -2: USB device unavailable
2742 \retval >=0: size of eeprom
2743*/
2744int ftdi_read_eeprom_getsize(struct ftdi_context *ftdi, unsigned char *eeprom, int maxsize)
2745{
2746 int i=0,j,minsize=32;
2747 int size=minsize;
2748
2749 if (ftdi == NULL || ftdi->usb_dev == NULL)
2750 ftdi_error_return(-2, "USB device unavailable");
2751
2752 do
2753 {
2754 for (j = 0; i < maxsize/2 && j<size; j++)
2755 {
2756 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,
2757 SIO_READ_EEPROM_REQUEST, 0, i,
2758 eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
2759 ftdi_error_return(-1, "eeprom read failed");
2760 i++;
2761 }
2762 size*=2;
2763 }
2764 while (size<=maxsize && memcmp(eeprom,&eeprom[size/2],size/2)!=0);
2765
2766 return size/2;
2767}
2768
2769/**
2770 Write eeprom location
2771
2772 \param ftdi pointer to ftdi_context
2773 \param eeprom_addr Address of eeprom location to be written
2774 \param eeprom_val Value to be written
2775
2776 \retval 0: all fine
2777 \retval -1: read failed
2778 \retval -2: USB device unavailable
2779*/
2780int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short eeprom_val)
2781{
2782 if (ftdi == NULL || ftdi->usb_dev == NULL)
2783 ftdi_error_return(-2, "USB device unavailable");
2784
2785 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2786 SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
2787 NULL, 0, ftdi->usb_write_timeout) != 0)
2788 ftdi_error_return(-1, "unable to write eeprom");
2789
2790 return 0;
2791}
2792
2793/**
2794 Write eeprom
2795
2796 \param ftdi pointer to ftdi_context
2797 \param eeprom Pointer to read eeprom from
2798
2799 \retval 0: all fine
2800 \retval -1: read failed
2801 \retval -2: USB device unavailable
2802*/
2803int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
2804{
2805 unsigned short usb_val, status;
2806 int i, ret;
2807
2808 if (ftdi == NULL || ftdi->usb_dev == NULL)
2809 ftdi_error_return(-2, "USB device unavailable");
2810
2811 /* These commands were traced while running MProg */
2812 if ((ret = ftdi_usb_reset(ftdi)) != 0)
2813 return ret;
2814 if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0)
2815 return ret;
2816 if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0)
2817 return ret;
2818
2819 for (i = 0; i < ftdi->eeprom_size/2; i++)
2820 {
2821 usb_val = eeprom[i*2];
2822 usb_val += eeprom[(i*2)+1] << 8;
2823 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2824 SIO_WRITE_EEPROM_REQUEST, usb_val, i,
2825 NULL, 0, ftdi->usb_write_timeout) < 0)
2826 ftdi_error_return(-1, "unable to write eeprom");
2827 }
2828
2829 return 0;
2830}
2831
2832/**
2833 Erase eeprom
2834
2835 This is not supported on FT232R/FT245R according to the MProg manual from FTDI.
2836
2837 \param ftdi pointer to ftdi_context
2838
2839 \retval 0: all fine
2840 \retval -1: erase failed
2841 \retval -2: USB device unavailable
2842*/
2843int ftdi_erase_eeprom(struct ftdi_context *ftdi)
2844{
2845 if (ftdi == NULL || ftdi->usb_dev == NULL)
2846 ftdi_error_return(-2, "USB device unavailable");
2847
2848 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST, 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
2849 ftdi_error_return(-1, "unable to erase eeprom");
2850
2851 return 0;
2852}
2853
2854/**
2855 Get string representation for last error code
2856
2857 \param ftdi pointer to ftdi_context
2858
2859 \retval Pointer to error string
2860*/
2861char *ftdi_get_error_string (struct ftdi_context *ftdi)
2862{
2863 if (ftdi == NULL)
2864 return "";
2865
2866 return ftdi->error_str;
2867}
2868
2869/* @} end of doxygen libftdi group */
A library to talk to FTDI chips