git://developer.intra2net.com / libftdi / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Don't install baud_test program
[libftdi] / src / ftdi.c
... / ...
CommitLineData
1/***************************************************************************
2 ftdi.c - description
3 -------------------
4 begin : Fri Apr 4 2003
5 copyright : (C) 2003-2008 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 <usb.h>
32#include <string.h>
33#include <errno.h>
34#include <stdio.h>
35
36#include "ftdi.h"
37
38/* stuff needed for async write */
39#ifdef LIBFTDI_LINUX_ASYNC_MODE
40#include <sys/ioctl.h>
41#include <sys/time.h>
42#include <sys/select.h>
43#include <sys/types.h>
44#include <unistd.h>
45#include <linux/usbdevice_fs.h>
46#endif
47
48#define ftdi_error_return(code, str) do { \
49 ftdi->error_str = str; \
50 return code; \
51 } while(0);
52
53/**
54 Internal function to close usb device pointer.
55 Sets ftdi->usb_dev to NULL.
56 \internal
57
58 \param ftdi pointer to ftdi_context
59
60 \retval zero if all is fine, otherwise error code from usb_close()
61*/
62static int ftdi_usb_close_internal (struct ftdi_context *ftdi)
63{
64 int ret = 0;
65
66 if (ftdi->usb_dev)
67 {
68 ret = usb_close (ftdi->usb_dev);
69 ftdi->usb_dev = NULL;
70 }
71
72 return ret;
73}
74
75/**
76 Initializes a ftdi_context.
77
78 \param ftdi pointer to ftdi_context
79
80 \retval 0: all fine
81 \retval -1: couldn't allocate read buffer
82
83 \remark This should be called before all functions
84*/
85int ftdi_init(struct ftdi_context *ftdi)
86{
87 unsigned int i;
88
89 ftdi->usb_dev = NULL;
90 ftdi->usb_read_timeout = 5000;
91 ftdi->usb_write_timeout = 5000;
92
93 ftdi->type = TYPE_BM; /* chip type */
94 ftdi->baudrate = -1;
95 ftdi->bitbang_enabled = 0;
96
97 ftdi->readbuffer = NULL;
98 ftdi->readbuffer_offset = 0;
99 ftdi->readbuffer_remaining = 0;
100 ftdi->writebuffer_chunksize = 4096;
101 ftdi->max_packet_size = 0;
102
103 ftdi->interface = 0;
104 ftdi->index = 0;
105 ftdi->in_ep = 0x02;
106 ftdi->out_ep = 0x81;
107 ftdi->bitbang_mode = 1; /* 1: Normal bitbang mode, 2: SPI bitbang mode */
108
109 ftdi->error_str = NULL;
110
111#ifdef LIBFTDI_LINUX_ASYNC_MODE
112 ftdi->async_usb_buffer_size=10;
113 if ((ftdi->async_usb_buffer=malloc(sizeof(struct usbdevfs_urb)*ftdi->async_usb_buffer_size)) == NULL)
114 ftdi_error_return(-1, "out of memory for async usb buffer");
115
116 /* initialize async usb buffer with unused-marker */
117 for (i=0; i < ftdi->async_usb_buffer_size; i++)
118 ((struct usbdevfs_urb*)ftdi->async_usb_buffer)[i].usercontext = FTDI_URB_USERCONTEXT_COOKIE;
119#else
120 ftdi->async_usb_buffer_size=0;
121 ftdi->async_usb_buffer = NULL;
122#endif
123
124 ftdi->eeprom_size = FTDI_DEFAULT_EEPROM_SIZE;
125
126 /* All fine. Now allocate the readbuffer */
127 return ftdi_read_data_set_chunksize(ftdi, 4096);
128}
129
130/**
131 Allocate and initialize a new ftdi_context
132
133 \return a pointer to a new ftdi_context, or NULL on failure
134*/
135struct ftdi_context *ftdi_new(void)
136{
137 struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context));
138
139 if (ftdi == NULL)
140 {
141 return NULL;
142 }
143
144 if (ftdi_init(ftdi) != 0)
145 {
146 free(ftdi);
147 return NULL;
148 }
149
150 return ftdi;
151}
152
153/**
154 Open selected channels on a chip, otherwise use first channel.
155
156 \param ftdi pointer to ftdi_context
157 \param interface Interface to use for FT2232C/2232H/4232H chips.
158
159 \retval 0: all fine
160 \retval -1: unknown interface
161*/
162int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
163{
164 switch (interface)
165 {
166 case INTERFACE_ANY:
167 case INTERFACE_A:
168 /* ftdi_usb_open_desc cares to set the right index, depending on the found chip */
169 break;
170 case INTERFACE_B:
171 ftdi->interface = 1;
172 ftdi->index = INTERFACE_B;
173 ftdi->in_ep = 0x04;
174 ftdi->out_ep = 0x83;
175 break;
176 case INTERFACE_C:
177 ftdi->interface = 2;
178 ftdi->index = INTERFACE_C;
179 ftdi->in_ep = 0x06;
180 ftdi->out_ep = 0x85;
181 break;
182 case INTERFACE_D:
183 ftdi->interface = 3;
184 ftdi->index = INTERFACE_D;
185 ftdi->in_ep = 0x08;
186 ftdi->out_ep = 0x87;
187 break;
188 default:
189 ftdi_error_return(-1, "Unknown interface");
190 }
191 return 0;
192}
193
194/**
195 Deinitializes a ftdi_context.
196
197 \param ftdi pointer to ftdi_context
198*/
199void ftdi_deinit(struct ftdi_context *ftdi)
200{
201 ftdi_usb_close_internal (ftdi);
202
203 if (ftdi->async_usb_buffer != NULL)
204 {
205 free(ftdi->async_usb_buffer);
206 ftdi->async_usb_buffer = NULL;
207 }
208
209 if (ftdi->readbuffer != NULL)
210 {
211 free(ftdi->readbuffer);
212 ftdi->readbuffer = NULL;
213 }
214}
215
216/**
217 Deinitialize and free an ftdi_context.
218
219 \param ftdi pointer to ftdi_context
220*/
221void ftdi_free(struct ftdi_context *ftdi)
222{
223 ftdi_deinit(ftdi);
224 free(ftdi);
225}
226
227/**
228 Use an already open libusb device.
229
230 \param ftdi pointer to ftdi_context
231 \param usb libusb usb_dev_handle to use
232*/
233void ftdi_set_usbdev (struct ftdi_context *ftdi, usb_dev_handle *usb)
234{
235 ftdi->usb_dev = usb;
236}
237
238
239/**
240 Finds all ftdi devices on the usb bus. Creates a new ftdi_device_list which
241 needs to be deallocated by ftdi_list_free() after use.
242
243 \param ftdi pointer to ftdi_context
244 \param devlist Pointer where to store list of found devices
245 \param vendor Vendor ID to search for
246 \param product Product ID to search for
247
248 \retval >0: number of devices found
249 \retval -1: usb_find_busses() failed
250 \retval -2: usb_find_devices() failed
251 \retval -3: out of memory
252*/
253int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
254{
255 struct ftdi_device_list **curdev;
256 struct usb_bus *bus;
257 struct usb_device *dev;
258 int count = 0;
259
260 usb_init();
261 if (usb_find_busses() < 0)
262 ftdi_error_return(-1, "usb_find_busses() failed");
263 if (usb_find_devices() < 0)
264 ftdi_error_return(-2, "usb_find_devices() failed");
265
266 curdev = devlist;
267 *curdev = NULL;
268 for (bus = usb_get_busses(); bus; bus = bus->next)
269 {
270 for (dev = bus->devices; dev; dev = dev->next)
271 {
272 if (dev->descriptor.idVendor == vendor
273 && dev->descriptor.idProduct == product)
274 {
275 *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
276 if (!*curdev)
277 ftdi_error_return(-3, "out of memory");
278
279 (*curdev)->next = NULL;
280 (*curdev)->dev = dev;
281
282 curdev = &(*curdev)->next;
283 count++;
284 }
285 }
286 }
287
288 return count;
289}
290
291/**
292 Frees a usb device list.
293
294 \param devlist USB device list created by ftdi_usb_find_all()
295*/
296void ftdi_list_free(struct ftdi_device_list **devlist)
297{
298 struct ftdi_device_list *curdev, *next;
299
300 for (curdev = *devlist; curdev != NULL;)
301 {
302 next = curdev->next;
303 free(curdev);
304 curdev = next;
305 }
306
307 *devlist = NULL;
308}
309
310/**
311 Frees a usb device list.
312
313 \param devlist USB device list created by ftdi_usb_find_all()
314*/
315void ftdi_list_free2(struct ftdi_device_list *devlist)
316{
317 ftdi_list_free(&devlist);
318}
319
320/**
321 Return device ID strings from the usb device.
322
323 The parameters manufacturer, description and serial may be NULL
324 or pointer to buffers to store the fetched strings.
325
326 \note Use this function only in combination with ftdi_usb_find_all()
327 as it closes the internal "usb_dev" after use.
328
329 \param ftdi pointer to ftdi_context
330 \param dev libusb usb_dev to use
331 \param manufacturer Store manufacturer string here if not NULL
332 \param mnf_len Buffer size of manufacturer string
333 \param description Store product description string here if not NULL
334 \param desc_len Buffer size of product description string
335 \param serial Store serial string here if not NULL
336 \param serial_len Buffer size of serial string
337
338 \retval 0: all fine
339 \retval -1: wrong arguments
340 \retval -4: unable to open device
341 \retval -7: get product manufacturer failed
342 \retval -8: get product description failed
343 \retval -9: get serial number failed
344 \retval -10: unable to close device
345*/
346int ftdi_usb_get_strings(struct ftdi_context * ftdi, struct usb_device * dev,
347 char * manufacturer, int mnf_len, char * description, int desc_len, char * serial, int serial_len)
348{
349 if ((ftdi==NULL) || (dev==NULL))
350 return -1;
351
352 if (!(ftdi->usb_dev = usb_open(dev)))
353 ftdi_error_return(-4, usb_strerror());
354
355 if (manufacturer != NULL)
356 {
357 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iManufacturer, manufacturer, mnf_len) <= 0)
358 {
359 ftdi_usb_close_internal (ftdi);
360 ftdi_error_return(-7, usb_strerror());
361 }
362 }
363
364 if (description != NULL)
365 {
366 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, description, desc_len) <= 0)
367 {
368 ftdi_usb_close_internal (ftdi);
369 ftdi_error_return(-8, usb_strerror());
370 }
371 }
372
373 if (serial != NULL)
374 {
375 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, serial, serial_len) <= 0)
376 {
377 ftdi_usb_close_internal (ftdi);
378 ftdi_error_return(-9, usb_strerror());
379 }
380 }
381
382 if (ftdi_usb_close_internal (ftdi) != 0)
383 ftdi_error_return(-10, usb_strerror());
384
385 return 0;
386}
387
388/**
389 * Internal function to determine the maximum packet size.
390 * \param ftdi pointer to ftdi_context
391 * \param dev libusb usb_dev to use
392 * \retval Maximum packet size for this device
393 */
394static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, struct usb_device *dev)
395{
396 unsigned int packet_size;
397
398 // Determine maximum packet size. Init with default value.
399 // New hi-speed devices from FTDI use a packet size of 512 bytes
400 // but could be connected to a normal speed USB hub -> 64 bytes packet size.
401 if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H)
402 packet_size = 512;
403 else
404 packet_size = 64;
405
406 if (dev->descriptor.bNumConfigurations > 0 && dev->config)
407 {
408 struct usb_config_descriptor config = dev->config[0];
409
410 if (ftdi->interface < config.bNumInterfaces)
411 {
412 struct usb_interface interface = config.interface[ftdi->interface];
413 if (interface.num_altsetting > 0)
414 {
415 struct usb_interface_descriptor descriptor = interface.altsetting[0];
416 if (descriptor.bNumEndpoints > 0)
417 {
418 packet_size = descriptor.endpoint[0].wMaxPacketSize;
419 }
420 }
421 }
422 }
423
424 return packet_size;
425}
426
427/**
428 Opens a ftdi device given by a usb_device.
429
430 \param ftdi pointer to ftdi_context
431 \param dev libusb usb_dev to use
432
433 \retval 0: all fine
434 \retval -3: unable to config device
435 \retval -4: unable to open device
436 \retval -5: unable to claim device
437 \retval -6: reset failed
438 \retval -7: set baudrate failed
439*/
440int ftdi_usb_open_dev(struct ftdi_context *ftdi, struct usb_device *dev)
441{
442 int detach_errno = 0;
443 int config_val = 1;
444 if (!(ftdi->usb_dev = usb_open(dev)))
445 ftdi_error_return(-4, "usb_open() failed");
446
447#ifdef LIBUSB_HAS_GET_DRIVER_NP
448 // Try to detach ftdi_sio kernel module.
449 // Returns ENODATA if driver is not loaded.
450 //
451 // The return code is kept in a separate variable and only parsed
452 // if usb_set_configuration() or usb_claim_interface() fails as the
453 // detach operation might be denied and everything still works fine.
454 // Likely scenario is a static ftdi_sio kernel module.
455 if (usb_detach_kernel_driver_np(ftdi->usb_dev, ftdi->interface) != 0 && errno != ENODATA)
456 detach_errno = errno;
457#endif
458
459#ifdef __WIN32__
460 // set configuration (needed especially for windows)
461 // tolerate EBUSY: one device with one configuration, but two interfaces
462 // and libftdi sessions to both interfaces (e.g. FT2232)
463
464 if (dev->descriptor.bNumConfigurations > 0)
465 {
466 // libusb-win32 on Windows 64 can return a null pointer for a valid device
467 if (dev->config)
468 config_val = dev->config[0].bConfigurationValue;
469
470 if (usb_set_configuration(ftdi->usb_dev, config_val) &&
471 errno != EBUSY)
472 {
473 ftdi_usb_close_internal (ftdi);
474 if (detach_errno == EPERM)
475 {
476 ftdi_error_return(-8, "inappropriate permissions on device!");
477 }
478 else
479 {
480 ftdi_error_return(-3, "unable to set usb configuration. Make sure ftdi_sio is unloaded!");
481 }
482 }
483 }
484#endif
485
486 if (usb_claim_interface(ftdi->usb_dev, ftdi->interface) != 0)
487 {
488 ftdi_usb_close_internal (ftdi);
489 if (detach_errno == EPERM)
490 {
491 ftdi_error_return(-8, "inappropriate permissions on device!");
492 }
493 else
494 {
495 ftdi_error_return(-5, "unable to claim usb device. Make sure ftdi_sio is unloaded!");
496 }
497 }
498
499 if (ftdi_usb_reset (ftdi) != 0)
500 {
501 ftdi_usb_close_internal (ftdi);
502 ftdi_error_return(-6, "ftdi_usb_reset failed");
503 }
504
505 // Try to guess chip type
506 // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
507 if (dev->descriptor.bcdDevice == 0x400 || (dev->descriptor.bcdDevice == 0x200
508 && dev->descriptor.iSerialNumber == 0))
509 ftdi->type = TYPE_BM;
510 else if (dev->descriptor.bcdDevice == 0x200)
511 ftdi->type = TYPE_AM;
512 else if (dev->descriptor.bcdDevice == 0x500)
513 ftdi->type = TYPE_2232C;
514 else if (dev->descriptor.bcdDevice == 0x600)
515 ftdi->type = TYPE_R;
516 else if (dev->descriptor.bcdDevice == 0x700)
517 ftdi->type = TYPE_2232H;
518 else if (dev->descriptor.bcdDevice == 0x800)
519 ftdi->type = TYPE_4232H;
520
521 // Set default interface on dual/quad type chips
522 switch(ftdi->type)
523 {
524 case TYPE_2232C:
525 case TYPE_2232H:
526 case TYPE_4232H:
527 if (!ftdi->index)
528 ftdi->index = INTERFACE_A;
529 break;
530 default:
531 break;
532 }
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 -1: usb_find_busses() failed
572 \retval -2: usb_find_devices() failed
573 \retval -3: usb device not found
574 \retval -4: unable to open device
575 \retval -5: unable to claim device
576 \retval -6: reset failed
577 \retval -7: set baudrate failed
578 \retval -8: get product description failed
579 \retval -9: get serial number failed
580 \retval -10: unable to close device
581*/
582int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
583 const char* description, const char* serial)
584{
585 struct usb_bus *bus;
586 struct usb_device *dev;
587 char string[256];
588
589 usb_init();
590
591 if (usb_find_busses() < 0)
592 ftdi_error_return(-1, "usb_find_busses() failed");
593 if (usb_find_devices() < 0)
594 ftdi_error_return(-2, "usb_find_devices() failed");
595
596 for (bus = usb_get_busses(); bus; bus = bus->next)
597 {
598 for (dev = bus->devices; dev; dev = dev->next)
599 {
600 if (dev->descriptor.idVendor == vendor
601 && dev->descriptor.idProduct == product)
602 {
603 if (!(ftdi->usb_dev = usb_open(dev)))
604 ftdi_error_return(-4, "usb_open() failed");
605
606 if (description != NULL)
607 {
608 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iProduct, string, sizeof(string)) <= 0)
609 {
610 ftdi_usb_close_internal (ftdi);
611 ftdi_error_return(-8, "unable to fetch product description");
612 }
613 if (strncmp(string, description, sizeof(string)) != 0)
614 {
615 if (ftdi_usb_close_internal (ftdi) != 0)
616 ftdi_error_return(-10, "unable to close device");
617 continue;
618 }
619 }
620 if (serial != NULL)
621 {
622 if (usb_get_string_simple(ftdi->usb_dev, dev->descriptor.iSerialNumber, string, sizeof(string)) <= 0)
623 {
624 ftdi_usb_close_internal (ftdi);
625 ftdi_error_return(-9, "unable to fetch serial number");
626 }
627 if (strncmp(string, serial, sizeof(string)) != 0)
628 {
629 if (ftdi_usb_close_internal (ftdi) != 0)
630 ftdi_error_return(-10, "unable to close device");
631 continue;
632 }
633 }
634
635 if (ftdi_usb_close_internal (ftdi) != 0)
636 ftdi_error_return(-10, "unable to close device");
637
638 return ftdi_usb_open_dev(ftdi, dev);
639 }
640 }
641 }
642
643 // device not found
644 ftdi_error_return(-3, "device not found");
645}
646
647/**
648 Resets the ftdi device.
649
650 \param ftdi pointer to ftdi_context
651
652 \retval 0: all fine
653 \retval -1: FTDI reset failed
654*/
655int ftdi_usb_reset(struct ftdi_context *ftdi)
656{
657 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
658 SIO_RESET_REQUEST, SIO_RESET_SIO,
659 ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
660 ftdi_error_return(-1,"FTDI reset failed");
661
662 // Invalidate data in the readbuffer
663 ftdi->readbuffer_offset = 0;
664 ftdi->readbuffer_remaining = 0;
665
666 return 0;
667}
668
669/**
670 Clears the read buffer on the chip and the internal read buffer.
671
672 \param ftdi pointer to ftdi_context
673
674 \retval 0: all fine
675 \retval -1: read buffer purge failed
676*/
677int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
678{
679 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
680 SIO_RESET_REQUEST, SIO_RESET_PURGE_RX,
681 ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
682 ftdi_error_return(-1, "FTDI purge of RX buffer failed");
683
684 // Invalidate data in the readbuffer
685 ftdi->readbuffer_offset = 0;
686 ftdi->readbuffer_remaining = 0;
687
688 return 0;
689}
690
691/**
692 Clears the write buffer on the chip.
693
694 \param ftdi pointer to ftdi_context
695
696 \retval 0: all fine
697 \retval -1: write buffer purge failed
698*/
699int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
700{
701 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
702 SIO_RESET_REQUEST, SIO_RESET_PURGE_TX,
703 ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
704 ftdi_error_return(-1, "FTDI purge of TX buffer failed");
705
706 return 0;
707}
708
709/**
710 Clears the buffers on the chip and the internal read buffer.
711
712 \param ftdi pointer to ftdi_context
713
714 \retval 0: all fine
715 \retval -1: read buffer purge failed
716 \retval -2: write buffer purge failed
717*/
718int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
719{
720 int result;
721
722 result = ftdi_usb_purge_rx_buffer(ftdi);
723 if (result < 0)
724 return -1;
725
726 result = ftdi_usb_purge_tx_buffer(ftdi);
727 if (result < 0)
728 return -2;
729
730 return 0;
731}
732
733
734
735/**
736 Closes the ftdi device. Call ftdi_deinit() if you're cleaning up.
737
738 \param ftdi pointer to ftdi_context
739
740 \retval 0: all fine
741 \retval -1: usb_release failed
742 \retval -2: usb_close failed
743*/
744int ftdi_usb_close(struct ftdi_context *ftdi)
745{
746 int rtn = 0;
747
748#ifdef LIBFTDI_LINUX_ASYNC_MODE
749 /* try to release some kernel resources */
750 ftdi_async_complete(ftdi,1);
751#endif
752
753 if (ftdi->usb_dev != NULL)
754 if (usb_release_interface(ftdi->usb_dev, ftdi->interface) != 0)
755 rtn = -1;
756
757 if (ftdi_usb_close_internal (ftdi) != 0)
758 rtn = -2;
759
760 return rtn;
761}
762
763/*
764 ftdi_convert_baudrate returns nearest supported baud rate to that requested.
765 Function is only used internally
766 \internal
767*/
768static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
769 unsigned short *value, unsigned short *index)
770{
771 static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
772 static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
773 static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
774 int divisor, best_divisor, best_baud, best_baud_diff;
775 unsigned long encoded_divisor;
776 int i;
777
778 if (baudrate <= 0)
779 {
780 // Return error
781 return -1;
782 }
783
784 divisor = 24000000 / baudrate;
785
786 if (ftdi->type == TYPE_AM)
787 {
788 // Round down to supported fraction (AM only)
789 divisor -= am_adjust_dn[divisor & 7];
790 }
791
792 // Try this divisor and the one above it (because division rounds down)
793 best_divisor = 0;
794 best_baud = 0;
795 best_baud_diff = 0;
796 for (i = 0; i < 2; i++)
797 {
798 int try_divisor = divisor + i;
799 int baud_estimate;
800 int baud_diff;
801
802 // Round up to supported divisor value
803 if (try_divisor <= 8)
804 {
805 // Round up to minimum supported divisor
806 try_divisor = 8;
807 }
808 else if (ftdi->type != TYPE_AM && try_divisor < 12)
809 {
810 // BM doesn't support divisors 9 through 11 inclusive
811 try_divisor = 12;
812 }
813 else if (divisor < 16)
814 {
815 // AM doesn't support divisors 9 through 15 inclusive
816 try_divisor = 16;
817 }
818 else
819 {
820 if (ftdi->type == TYPE_AM)
821 {
822 // Round up to supported fraction (AM only)
823 try_divisor += am_adjust_up[try_divisor & 7];
824 if (try_divisor > 0x1FFF8)
825 {
826 // Round down to maximum supported divisor value (for AM)
827 try_divisor = 0x1FFF8;
828 }
829 }
830 else
831 {
832 if (try_divisor > 0x1FFFF)
833 {
834 // Round down to maximum supported divisor value (for BM)
835 try_divisor = 0x1FFFF;
836 }
837 }
838 }
839 // Get estimated baud rate (to nearest integer)
840 baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
841 // Get absolute difference from requested baud rate
842 if (baud_estimate < baudrate)
843 {
844 baud_diff = baudrate - baud_estimate;
845 }
846 else
847 {
848 baud_diff = baud_estimate - baudrate;
849 }
850 if (i == 0 || baud_diff < best_baud_diff)
851 {
852 // Closest to requested baud rate so far
853 best_divisor = try_divisor;
854 best_baud = baud_estimate;
855 best_baud_diff = baud_diff;
856 if (baud_diff == 0)
857 {
858 // Spot on! No point trying
859 break;
860 }
861 }
862 }
863 // Encode the best divisor value
864 encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
865 // Deal with special cases for encoded value
866 if (encoded_divisor == 1)
867 {
868 encoded_divisor = 0; // 3000000 baud
869 }
870 else if (encoded_divisor == 0x4001)
871 {
872 encoded_divisor = 1; // 2000000 baud (BM only)
873 }
874 // Split into "value" and "index" values
875 *value = (unsigned short)(encoded_divisor & 0xFFFF);
876 if (ftdi->type == TYPE_2232C || ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H)
877 {
878 *index = (unsigned short)(encoded_divisor >> 8);
879 *index &= 0xFF00;
880 *index |= ftdi->index;
881 }
882 else
883 *index = (unsigned short)(encoded_divisor >> 16);
884
885 // Return the nearest baud rate
886 return best_baud;
887}
888
889/**
890 Sets the chip baud rate
891
892 \param ftdi pointer to ftdi_context
893 \param baudrate baud rate to set
894
895 \retval 0: all fine
896 \retval -1: invalid baudrate
897 \retval -2: setting baudrate failed
898*/
899int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
900{
901 unsigned short value, index;
902 int actual_baudrate;
903
904 if (ftdi->bitbang_enabled)
905 {
906 baudrate = baudrate*4;
907 }
908
909 actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
910 if (actual_baudrate <= 0)
911 ftdi_error_return (-1, "Silly baudrate <= 0.");
912
913 // Check within tolerance (about 5%)
914 if ((actual_baudrate * 2 < baudrate /* Catch overflows */ )
915 || ((actual_baudrate < baudrate)
916 ? (actual_baudrate * 21 < baudrate * 20)
917 : (baudrate * 21 < actual_baudrate * 20)))
918 ftdi_error_return (-1, "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4");
919
920 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
921 SIO_SET_BAUDRATE_REQUEST, value,
922 index, NULL, 0, ftdi->usb_write_timeout) != 0)
923 ftdi_error_return (-2, "Setting new baudrate failed");
924
925 ftdi->baudrate = baudrate;
926 return 0;
927}
928
929/**
930 Set (RS232) line characteristics.
931 The break type can only be set via ftdi_set_line_property2()
932 and defaults to "off".
933
934 \param ftdi pointer to ftdi_context
935 \param bits Number of bits
936 \param sbit Number of stop bits
937 \param parity Parity mode
938
939 \retval 0: all fine
940 \retval -1: Setting line property failed
941*/
942int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
943 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
944{
945 return ftdi_set_line_property2(ftdi, bits, sbit, parity, BREAK_OFF);
946}
947
948/**
949 Set (RS232) line characteristics
950
951 \param ftdi pointer to ftdi_context
952 \param bits Number of bits
953 \param sbit Number of stop bits
954 \param parity Parity mode
955 \param break_type Break type
956
957 \retval 0: all fine
958 \retval -1: Setting line property failed
959*/
960int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
961 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity,
962 enum ftdi_break_type break_type)
963{
964 unsigned short value = bits;
965
966 switch (parity)
967 {
968 case NONE:
969 value |= (0x00 << 8);
970 break;
971 case ODD:
972 value |= (0x01 << 8);
973 break;
974 case EVEN:
975 value |= (0x02 << 8);
976 break;
977 case MARK:
978 value |= (0x03 << 8);
979 break;
980 case SPACE:
981 value |= (0x04 << 8);
982 break;
983 }
984
985 switch (sbit)
986 {
987 case STOP_BIT_1:
988 value |= (0x00 << 11);
989 break;
990 case STOP_BIT_15:
991 value |= (0x01 << 11);
992 break;
993 case STOP_BIT_2:
994 value |= (0x02 << 11);
995 break;
996 }
997
998 switch (break_type)
999 {
1000 case BREAK_OFF:
1001 value |= (0x00 << 14);
1002 break;
1003 case BREAK_ON:
1004 value |= (0x01 << 14);
1005 break;
1006 }
1007
1008 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1009 SIO_SET_DATA_REQUEST, value,
1010 ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1011 ftdi_error_return (-1, "Setting new line property failed");
1012
1013 return 0;
1014}
1015
1016/**
1017 Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip
1018
1019 \param ftdi pointer to ftdi_context
1020 \param buf Buffer with the data
1021 \param size Size of the buffer
1022
1023 \retval <0: error code from usb_bulk_write()
1024 \retval >0: number of bytes written
1025*/
1026int ftdi_write_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1027{
1028 int ret;
1029 int offset = 0;
1030 int total_written = 0;
1031
1032 while (offset < size)
1033 {
1034 int write_size = ftdi->writebuffer_chunksize;
1035
1036 if (offset+write_size > size)
1037 write_size = size-offset;
1038
1039 ret = usb_bulk_write(ftdi->usb_dev, ftdi->in_ep, buf+offset, write_size, ftdi->usb_write_timeout);
1040 if (ret < 0)
1041 ftdi_error_return(ret, "usb bulk write failed");
1042
1043 total_written += ret;
1044 offset += write_size;
1045 }
1046
1047 return total_written;
1048}
1049
1050#ifdef LIBFTDI_LINUX_ASYNC_MODE
1051#ifdef USB_CLASS_PTP
1052#error LIBFTDI_LINUX_ASYNC_MODE is not compatible with libusb-compat-0.1!
1053#endif
1054/* this is strongly dependent on libusb using the same struct layout. If libusb
1055 changes in some later version this may break horribly (this is for libusb 0.1.12) */
1056struct usb_dev_handle
1057{
1058 int fd;
1059 // some other stuff coming here we don't need
1060};
1061
1062/**
1063 Check for pending async urbs
1064 \internal
1065*/
1066static int _usb_get_async_urbs_pending(struct ftdi_context *ftdi)
1067{
1068 struct usbdevfs_urb *urb;
1069 int pending=0;
1070 unsigned int i;
1071
1072 for (i=0; i < ftdi->async_usb_buffer_size; i++)
1073 {
1074 urb=&((struct usbdevfs_urb *)(ftdi->async_usb_buffer))[i];
1075 if (urb->usercontext != FTDI_URB_USERCONTEXT_COOKIE)
1076 pending++;
1077 }
1078
1079 return pending;
1080}
1081
1082/**
1083 Wait until one or more async URBs are completed by the kernel and mark their
1084 positions in the async-buffer as unused
1085
1086 \param ftdi pointer to ftdi_context
1087 \param wait_for_more if != 0 wait for more than one write to complete
1088 \param timeout_msec max milliseconds to wait
1089
1090 \internal
1091*/
1092static void _usb_async_cleanup(struct ftdi_context *ftdi, int wait_for_more, int timeout_msec)
1093{
1094 struct timeval tv;
1095 struct usbdevfs_urb *urb=NULL;
1096 int ret;
1097 fd_set writefds;
1098 int keep_going=0;
1099
1100 FD_ZERO(&writefds);
1101 FD_SET(ftdi->usb_dev->fd, &writefds);
1102
1103 /* init timeout only once, select writes time left after call */
1104 tv.tv_sec = timeout_msec / 1000;
1105 tv.tv_usec = (timeout_msec % 1000) * 1000;
1106
1107 do
1108 {
1109 while (_usb_get_async_urbs_pending(ftdi)
1110 && (ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_REAPURBNDELAY, &urb)) == -1
1111 && errno == EAGAIN)
1112 {
1113 if (keep_going && !wait_for_more)
1114 {
1115 /* don't wait if repeating only for keep_going */
1116 keep_going=0;
1117 break;
1118 }
1119
1120 /* wait for timeout msec or something written ready */
1121 select(ftdi->usb_dev->fd+1, NULL, &writefds, NULL, &tv);
1122 }
1123
1124 if (ret == 0 && urb != NULL)
1125 {
1126 /* got a free urb, mark it */
1127 urb->usercontext = FTDI_URB_USERCONTEXT_COOKIE;
1128
1129 /* try to get more urbs that are ready now, but don't wait anymore */
1130 urb=NULL;
1131 keep_going=1;
1132 }
1133 else
1134 {
1135 /* no more urbs waiting */
1136 keep_going=0;
1137 }
1138 }
1139 while (keep_going);
1140}
1141
1142/**
1143 Wait until one or more async URBs are completed by the kernel and mark their
1144 positions in the async-buffer as unused.
1145
1146 \param ftdi pointer to ftdi_context
1147 \param wait_for_more if != 0 wait for more than one write to complete (until write timeout)
1148*/
1149void ftdi_async_complete(struct ftdi_context *ftdi, int wait_for_more)
1150{
1151 _usb_async_cleanup(ftdi,wait_for_more,ftdi->usb_write_timeout);
1152}
1153
1154/**
1155 Stupid libusb does not offer async writes nor does it allow
1156 access to its fd - so we need some hacks here.
1157 \internal
1158*/
1159static int _usb_bulk_write_async(struct ftdi_context *ftdi, int ep, char *bytes, int size)
1160{
1161 struct usbdevfs_urb *urb;
1162 int bytesdone = 0, requested;
1163 int ret, cleanup_count;
1164 unsigned int i;
1165
1166 do
1167 {
1168 /* find a free urb buffer we can use */
1169 urb=NULL;
1170 for (cleanup_count=0; urb==NULL && cleanup_count <= 1; cleanup_count++)
1171 {
1172 if (i==ftdi->async_usb_buffer_size)
1173 {
1174 /* wait until some buffers are free */
1175 _usb_async_cleanup(ftdi,0,ftdi->usb_write_timeout);
1176 }
1177
1178 for (i=0; i < ftdi->async_usb_buffer_size; i++)
1179 {
1180 urb=&((struct usbdevfs_urb *)(ftdi->async_usb_buffer))[i];
1181 if (urb->usercontext == FTDI_URB_USERCONTEXT_COOKIE)
1182 break; /* found a free urb position */
1183 urb=NULL;
1184 }
1185 }
1186
1187 /* no free urb position found */
1188 if (urb==NULL)
1189 return -1;
1190
1191 requested = size - bytesdone;
1192 if (requested > 4096)
1193 requested = 4096;
1194
1195 memset(urb,0,sizeof(urb));
1196
1197 urb->type = USBDEVFS_URB_TYPE_BULK;
1198 urb->endpoint = ep;
1199 urb->flags = 0;
1200 urb->buffer = bytes + bytesdone;
1201 urb->buffer_length = requested;
1202 urb->signr = 0;
1203 urb->actual_length = 0;
1204 urb->number_of_packets = 0;
1205 urb->usercontext = 0;
1206
1207 do
1208 {
1209 ret = ioctl(ftdi->usb_dev->fd, USBDEVFS_SUBMITURB, urb);
1210 }
1211 while (ret < 0 && errno == EINTR);
1212 if (ret < 0)
1213 return ret; /* the caller can read errno to get more info */
1214
1215 bytesdone += requested;
1216 }
1217 while (bytesdone < size);
1218 return bytesdone;
1219}
1220
1221/**
1222 Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip.
1223 Does not wait for completion of the transfer nor does it make sure that
1224 the transfer was successful.
1225
1226 This function could be extended to use signals and callbacks to inform the
1227 caller of completion or error - but this is not done yet, volunteers welcome.
1228
1229 Works around libusb and directly accesses functions only available on Linux.
1230 Only available if compiled with --with-async-mode.
1231
1232 \param ftdi pointer to ftdi_context
1233 \param buf Buffer with the data
1234 \param size Size of the buffer
1235
1236 \retval <0: error code from usb_bulk_write()
1237 \retval >0: number of bytes written
1238*/
1239int ftdi_write_data_async(struct ftdi_context *ftdi, unsigned char *buf, int size)
1240{
1241 int ret;
1242 int offset = 0;
1243 int total_written = 0;
1244
1245 while (offset < size)
1246 {
1247 int write_size = ftdi->writebuffer_chunksize;
1248
1249 if (offset+write_size > size)
1250 write_size = size-offset;
1251
1252 ret = _usb_bulk_write_async(ftdi, ftdi->in_ep, buf+offset, write_size);
1253 if (ret < 0)
1254 ftdi_error_return(ret, "usb bulk write async failed");
1255
1256 total_written += ret;
1257 offset += write_size;
1258 }
1259
1260 return total_written;
1261}
1262#endif // LIBFTDI_LINUX_ASYNC_MODE
1263
1264/**
1265 Configure write buffer chunk size.
1266 Default is 4096.
1267
1268 \param ftdi pointer to ftdi_context
1269 \param chunksize Chunk size
1270
1271 \retval 0: all fine
1272*/
1273int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1274{
1275 ftdi->writebuffer_chunksize = chunksize;
1276 return 0;
1277}
1278
1279/**
1280 Get write buffer chunk size.
1281
1282 \param ftdi pointer to ftdi_context
1283 \param chunksize Pointer to store chunk size in
1284
1285 \retval 0: all fine
1286*/
1287int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1288{
1289 *chunksize = ftdi->writebuffer_chunksize;
1290 return 0;
1291}
1292
1293/**
1294 Reads data in chunks (see ftdi_read_data_set_chunksize()) from the chip.
1295
1296 Automatically strips the two modem status bytes transfered during every read.
1297
1298 \param ftdi pointer to ftdi_context
1299 \param buf Buffer to store data in
1300 \param size Size of the buffer
1301
1302 \retval <0: error code from usb_bulk_read()
1303 \retval 0: no data was available
1304 \retval >0: number of bytes read
1305
1306 \remark This function is not useful in bitbang mode.
1307 Use ftdi_read_pins() to get the current state of the pins.
1308*/
1309int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1310{
1311 int offset = 0, ret = 1, i, num_of_chunks, chunk_remains;
1312 int packet_size = ftdi->max_packet_size;
1313
1314 // Packet size sanity check (avoid division by zero)
1315 if (packet_size == 0)
1316 ftdi_error_return(-1, "max_packet_size is bogus (zero)");
1317
1318 // everything we want is still in the readbuffer?
1319 if (size <= ftdi->readbuffer_remaining)
1320 {
1321 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1322
1323 // Fix offsets
1324 ftdi->readbuffer_remaining -= size;
1325 ftdi->readbuffer_offset += size;
1326
1327 /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
1328
1329 return size;
1330 }
1331 // something still in the readbuffer, but not enough to satisfy 'size'?
1332 if (ftdi->readbuffer_remaining != 0)
1333 {
1334 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
1335
1336 // Fix offset
1337 offset += ftdi->readbuffer_remaining;
1338 }
1339 // do the actual USB read
1340 while (offset < size && ret > 0)
1341 {
1342 ftdi->readbuffer_remaining = 0;
1343 ftdi->readbuffer_offset = 0;
1344 /* returns how much received */
1345 ret = usb_bulk_read (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, ftdi->usb_read_timeout);
1346 if (ret < 0)
1347 ftdi_error_return(ret, "usb bulk read failed");
1348
1349 if (ret > 2)
1350 {
1351 // skip FTDI status bytes.
1352 // Maybe stored in the future to enable modem use
1353 num_of_chunks = ret / packet_size;
1354 chunk_remains = ret % packet_size;
1355 //printf("ret = %X, num_of_chunks = %X, chunk_remains = %X, readbuffer_offset = %X\n", ret, num_of_chunks, chunk_remains, ftdi->readbuffer_offset);
1356
1357 ftdi->readbuffer_offset += 2;
1358 ret -= 2;
1359
1360 if (ret > packet_size - 2)
1361 {
1362 for (i = 1; i < num_of_chunks; i++)
1363 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1364 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1365 packet_size - 2);
1366 if (chunk_remains > 2)
1367 {
1368 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1369 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1370 chunk_remains-2);
1371 ret -= 2*num_of_chunks;
1372 }
1373 else
1374 ret -= 2*(num_of_chunks-1)+chunk_remains;
1375 }
1376 }
1377 else if (ret <= 2)
1378 {
1379 // no more data to read?
1380 return offset;
1381 }
1382 if (ret > 0)
1383 {
1384 // data still fits in buf?
1385 if (offset+ret <= size)
1386 {
1387 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, ret);
1388 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1389 offset += ret;
1390
1391 /* Did we read exactly the right amount of bytes? */
1392 if (offset == size)
1393 //printf("read_data exact rem %d offset %d\n",
1394 //ftdi->readbuffer_remaining, offset);
1395 return offset;
1396 }
1397 else
1398 {
1399 // only copy part of the data or size <= readbuffer_chunksize
1400 int part_size = size-offset;
1401 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
1402
1403 ftdi->readbuffer_offset += part_size;
1404 ftdi->readbuffer_remaining = ret-part_size;
1405 offset += part_size;
1406
1407 /* printf("Returning part: %d - size: %d - offset: %d - ret: %d - remaining: %d\n",
1408 part_size, size, offset, ret, ftdi->readbuffer_remaining); */
1409
1410 return offset;
1411 }
1412 }
1413 }
1414 // never reached
1415 return -127;
1416}
1417
1418/**
1419 Configure read buffer chunk size.
1420 Default is 4096.
1421
1422 Automatically reallocates the buffer.
1423
1424 \param ftdi pointer to ftdi_context
1425 \param chunksize Chunk size
1426
1427 \retval 0: all fine
1428*/
1429int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1430{
1431 unsigned char *new_buf;
1432
1433 // Invalidate all remaining data
1434 ftdi->readbuffer_offset = 0;
1435 ftdi->readbuffer_remaining = 0;
1436
1437 if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL)
1438 ftdi_error_return(-1, "out of memory for readbuffer");
1439
1440 ftdi->readbuffer = new_buf;
1441 ftdi->readbuffer_chunksize = chunksize;
1442
1443 return 0;
1444}
1445
1446/**
1447 Get read buffer chunk size.
1448
1449 \param ftdi pointer to ftdi_context
1450 \param chunksize Pointer to store chunk size in
1451
1452 \retval 0: all fine
1453*/
1454int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1455{
1456 *chunksize = ftdi->readbuffer_chunksize;
1457 return 0;
1458}
1459
1460
1461/**
1462 Enable bitbang mode.
1463
1464 For advanced bitbang modes of the FT2232C chip use ftdi_set_bitmode().
1465
1466 \param ftdi pointer to ftdi_context
1467 \param bitmask Bitmask to configure lines.
1468 HIGH/ON value configures a line as output.
1469
1470 \retval 0: all fine
1471 \retval -1: can't enable bitbang mode
1472*/
1473int ftdi_enable_bitbang(struct ftdi_context *ftdi, unsigned char bitmask)
1474{
1475 unsigned short usb_val;
1476
1477 usb_val = bitmask; // low byte: bitmask
1478 /* FT2232C: Set bitbang_mode to 2 to enable SPI */
1479 usb_val |= (ftdi->bitbang_mode << 8);
1480
1481 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1482 SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index,
1483 NULL, 0, ftdi->usb_write_timeout) != 0)
1484 ftdi_error_return(-1, "unable to enter bitbang mode. Perhaps not a BM type chip?");
1485
1486 ftdi->bitbang_enabled = 1;
1487 return 0;
1488}
1489
1490/**
1491 Disable bitbang mode.
1492
1493 \param ftdi pointer to ftdi_context
1494
1495 \retval 0: all fine
1496 \retval -1: can't disable bitbang mode
1497*/
1498int ftdi_disable_bitbang(struct ftdi_context *ftdi)
1499{
1500 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_BITMODE_REQUEST, 0, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1501 ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?");
1502
1503 ftdi->bitbang_enabled = 0;
1504 return 0;
1505}
1506
1507/**
1508 Enable advanced bitbang mode for FT2232C chips.
1509
1510 \param ftdi pointer to ftdi_context
1511 \param bitmask Bitmask to configure lines.
1512 HIGH/ON value configures a line as output.
1513 \param mode Bitbang mode: 1 for normal mode, 2 for SPI mode
1514
1515 \retval 0: all fine
1516 \retval -1: can't enable bitbang mode
1517*/
1518int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
1519{
1520 unsigned short usb_val;
1521
1522 usb_val = bitmask; // low byte: bitmask
1523 usb_val |= (mode << 8);
1524 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_BITMODE_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1525 ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps not a 2232C type chip?");
1526
1527 ftdi->bitbang_mode = mode;
1528 ftdi->bitbang_enabled = (mode == BITMODE_BITBANG || mode == BITMODE_SYNCBB)?1:0;
1529 return 0;
1530}
1531
1532/**
1533 Directly read pin state. Useful for bitbang mode.
1534
1535 \param ftdi pointer to ftdi_context
1536 \param pins Pointer to store pins into
1537
1538 \retval 0: all fine
1539 \retval -1: read pins failed
1540*/
1541int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
1542{
1543 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_PINS_REQUEST, 0, ftdi->index, (char *)pins, 1, ftdi->usb_read_timeout) != 1)
1544 ftdi_error_return(-1, "read pins failed");
1545
1546 return 0;
1547}
1548
1549/**
1550 Set latency timer
1551
1552 The FTDI chip keeps data in the internal buffer for a specific
1553 amount of time if the buffer is not full yet to decrease
1554 load on the usb bus.
1555
1556 \param ftdi pointer to ftdi_context
1557 \param latency Value between 1 and 255
1558
1559 \retval 0: all fine
1560 \retval -1: latency out of range
1561 \retval -2: unable to set latency timer
1562*/
1563int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
1564{
1565 unsigned short usb_val;
1566
1567 if (latency < 1)
1568 ftdi_error_return(-1, "latency out of range. Only valid for 1-255");
1569
1570 usb_val = latency;
1571 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_LATENCY_TIMER_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1572 ftdi_error_return(-2, "unable to set latency timer");
1573
1574 return 0;
1575}
1576
1577/**
1578 Get latency timer
1579
1580 \param ftdi pointer to ftdi_context
1581 \param latency Pointer to store latency value in
1582
1583 \retval 0: all fine
1584 \retval -1: unable to get latency timer
1585*/
1586int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
1587{
1588 unsigned short usb_val;
1589 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_GET_LATENCY_TIMER_REQUEST, 0, ftdi->index, (char *)&usb_val, 1, ftdi->usb_read_timeout) != 1)
1590 ftdi_error_return(-1, "reading latency timer failed");
1591
1592 *latency = (unsigned char)usb_val;
1593 return 0;
1594}
1595
1596/**
1597 Poll modem status information
1598
1599 This function allows the retrieve the two status bytes of the device.
1600 The device sends these bytes also as a header for each read access
1601 where they are discarded by ftdi_read_data(). The chip generates
1602 the two stripped status bytes in the absence of data every 40 ms.
1603
1604 Layout of the first byte:
1605 - B0..B3 - must be 0
1606 - B4 Clear to send (CTS)
1607 0 = inactive
1608 1 = active
1609 - B5 Data set ready (DTS)
1610 0 = inactive
1611 1 = active
1612 - B6 Ring indicator (RI)
1613 0 = inactive
1614 1 = active
1615 - B7 Receive line signal detect (RLSD)
1616 0 = inactive
1617 1 = active
1618
1619 Layout of the second byte:
1620 - B0 Data ready (DR)
1621 - B1 Overrun error (OE)
1622 - B2 Parity error (PE)
1623 - B3 Framing error (FE)
1624 - B4 Break interrupt (BI)
1625 - B5 Transmitter holding register (THRE)
1626 - B6 Transmitter empty (TEMT)
1627 - B7 Error in RCVR FIFO
1628
1629 \param ftdi pointer to ftdi_context
1630 \param status Pointer to store status information in. Must be two bytes.
1631
1632 \retval 0: all fine
1633 \retval -1: unable to retrieve status information
1634*/
1635int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
1636{
1637 char usb_val[2];
1638
1639 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_POLL_MODEM_STATUS_REQUEST, 0, ftdi->index, usb_val, 2, ftdi->usb_read_timeout) != 2)
1640 ftdi_error_return(-1, "getting modem status failed");
1641
1642 *status = (usb_val[1] << 8) | usb_val[0];
1643
1644 return 0;
1645}
1646
1647/**
1648 Set flowcontrol for ftdi chip
1649
1650 \param ftdi pointer to ftdi_context
1651 \param flowctrl flow control to use. should be
1652 SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS or SIO_XON_XOFF_HS
1653
1654 \retval 0: all fine
1655 \retval -1: set flow control failed
1656*/
1657int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
1658{
1659 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1660 SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->index),
1661 NULL, 0, ftdi->usb_write_timeout) != 0)
1662 ftdi_error_return(-1, "set flow control failed");
1663
1664 return 0;
1665}
1666
1667/**
1668 Set dtr line
1669
1670 \param ftdi pointer to ftdi_context
1671 \param state state to set line to (1 or 0)
1672
1673 \retval 0: all fine
1674 \retval -1: set dtr failed
1675*/
1676int ftdi_setdtr(struct ftdi_context *ftdi, int state)
1677{
1678 unsigned short usb_val;
1679
1680 if (state)
1681 usb_val = SIO_SET_DTR_HIGH;
1682 else
1683 usb_val = SIO_SET_DTR_LOW;
1684
1685 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1686 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
1687 NULL, 0, ftdi->usb_write_timeout) != 0)
1688 ftdi_error_return(-1, "set dtr failed");
1689
1690 return 0;
1691}
1692
1693/**
1694 Set rts line
1695
1696 \param ftdi pointer to ftdi_context
1697 \param state state to set line to (1 or 0)
1698
1699 \retval 0: all fine
1700 \retval -1 set rts failed
1701*/
1702int ftdi_setrts(struct ftdi_context *ftdi, int state)
1703{
1704 unsigned short usb_val;
1705
1706 if (state)
1707 usb_val = SIO_SET_RTS_HIGH;
1708 else
1709 usb_val = SIO_SET_RTS_LOW;
1710
1711 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1712 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
1713 NULL, 0, ftdi->usb_write_timeout) != 0)
1714 ftdi_error_return(-1, "set of rts failed");
1715
1716 return 0;
1717}
1718
1719/**
1720 Set dtr and rts line in one pass
1721
1722 \param ftdi pointer to ftdi_context
1723 \param dtr DTR state to set line to (1 or 0)
1724 \param rts RTS state to set line to (1 or 0)
1725
1726 \retval 0: all fine
1727 \retval -1 set dtr/rts failed
1728 */
1729int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
1730{
1731 unsigned short usb_val;
1732
1733 if (dtr)
1734 usb_val = SIO_SET_DTR_HIGH;
1735 else
1736 usb_val = SIO_SET_DTR_LOW;
1737
1738 if (rts)
1739 usb_val |= SIO_SET_RTS_HIGH;
1740 else
1741 usb_val |= SIO_SET_RTS_LOW;
1742
1743 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1744 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
1745 NULL, 0, ftdi->usb_write_timeout) != 0)
1746 ftdi_error_return(-1, "set of rts/dtr failed");
1747
1748 return 0;
1749}
1750
1751/**
1752 Set the special event character
1753
1754 \param ftdi pointer to ftdi_context
1755 \param eventch Event character
1756 \param enable 0 to disable the event character, non-zero otherwise
1757
1758 \retval 0: all fine
1759 \retval -1: unable to set event character
1760*/
1761int ftdi_set_event_char(struct ftdi_context *ftdi,
1762 unsigned char eventch, unsigned char enable)
1763{
1764 unsigned short usb_val;
1765
1766 usb_val = eventch;
1767 if (enable)
1768 usb_val |= 1 << 8;
1769
1770 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_EVENT_CHAR_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1771 ftdi_error_return(-1, "setting event character failed");
1772
1773 return 0;
1774}
1775
1776/**
1777 Set error character
1778
1779 \param ftdi pointer to ftdi_context
1780 \param errorch Error character
1781 \param enable 0 to disable the error character, non-zero otherwise
1782
1783 \retval 0: all fine
1784 \retval -1: unable to set error character
1785*/
1786int ftdi_set_error_char(struct ftdi_context *ftdi,
1787 unsigned char errorch, unsigned char enable)
1788{
1789 unsigned short usb_val;
1790
1791 usb_val = errorch;
1792 if (enable)
1793 usb_val |= 1 << 8;
1794
1795 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_SET_ERROR_CHAR_REQUEST, usb_val, ftdi->index, NULL, 0, ftdi->usb_write_timeout) != 0)
1796 ftdi_error_return(-1, "setting error character failed");
1797
1798 return 0;
1799}
1800
1801/**
1802 Set the eeprom size
1803
1804 \param ftdi pointer to ftdi_context
1805 \param eeprom Pointer to ftdi_eeprom
1806 \param size
1807
1808*/
1809void ftdi_eeprom_setsize(struct ftdi_context *ftdi, struct ftdi_eeprom *eeprom, int size)
1810{
1811 ftdi->eeprom_size=size;
1812 eeprom->size=size;
1813}
1814
1815/**
1816 Init eeprom with default values.
1817
1818 \param eeprom Pointer to ftdi_eeprom
1819*/
1820void ftdi_eeprom_initdefaults(struct ftdi_eeprom *eeprom)
1821{
1822 eeprom->vendor_id = 0x0403;
1823 eeprom->product_id = 0x6001;
1824
1825 eeprom->self_powered = 1;
1826 eeprom->remote_wakeup = 1;
1827 eeprom->BM_type_chip = 1;
1828
1829 eeprom->in_is_isochronous = 0;
1830 eeprom->out_is_isochronous = 0;
1831 eeprom->suspend_pull_downs = 0;
1832
1833 eeprom->use_serial = 0;
1834 eeprom->change_usb_version = 0;
1835 eeprom->usb_version = 0x0200;
1836 eeprom->max_power = 0;
1837
1838 eeprom->manufacturer = NULL;
1839 eeprom->product = NULL;
1840 eeprom->serial = NULL;
1841
1842 eeprom->size = FTDI_DEFAULT_EEPROM_SIZE;
1843}
1844
1845/**
1846 Build binary output from ftdi_eeprom structure.
1847 Output is suitable for ftdi_write_eeprom().
1848
1849 \param eeprom Pointer to ftdi_eeprom
1850 \param output Buffer of 128 bytes to store eeprom image to
1851
1852 \retval >0: used eeprom size
1853 \retval -1: eeprom size (128 bytes) exceeded by custom strings
1854*/
1855int ftdi_eeprom_build(struct ftdi_eeprom *eeprom, unsigned char *output)
1856{
1857 unsigned char i, j;
1858 unsigned short checksum, value;
1859 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
1860 int size_check;
1861
1862 if (eeprom->manufacturer != NULL)
1863 manufacturer_size = strlen(eeprom->manufacturer);
1864 if (eeprom->product != NULL)
1865 product_size = strlen(eeprom->product);
1866 if (eeprom->serial != NULL)
1867 serial_size = strlen(eeprom->serial);
1868
1869 size_check = eeprom->size;
1870 size_check -= 28; // 28 are always in use (fixed)
1871
1872 // Top half of a 256byte eeprom is used just for strings and checksum
1873 // it seems that the FTDI chip will not read these strings from the lower half
1874 // Each string starts with two bytes; offset and type (0x03 for string)
1875 // the checksum needs two bytes, so without the string data that 8 bytes from the top half
1876 if (eeprom->size>=256)size_check = 120;
1877 size_check -= manufacturer_size*2;
1878 size_check -= product_size*2;
1879 size_check -= serial_size*2;
1880
1881 // eeprom size exceeded?
1882 if (size_check < 0)
1883 return (-1);
1884
1885 // empty eeprom
1886 memset (output, 0, eeprom->size);
1887
1888 // Addr 00: Stay 00 00
1889 // Addr 02: Vendor ID
1890 output[0x02] = eeprom->vendor_id;
1891 output[0x03] = eeprom->vendor_id >> 8;
1892
1893 // Addr 04: Product ID
1894 output[0x04] = eeprom->product_id;
1895 output[0x05] = eeprom->product_id >> 8;
1896
1897 // Addr 06: Device release number (0400h for BM features)
1898 output[0x06] = 0x00;
1899
1900 if (eeprom->BM_type_chip == 1)
1901 output[0x07] = 0x04;
1902 else
1903 output[0x07] = 0x02;
1904
1905 // Addr 08: Config descriptor
1906 // Bit 7: always 1
1907 // Bit 6: 1 if this device is self powered, 0 if bus powered
1908 // Bit 5: 1 if this device uses remote wakeup
1909 // Bit 4: 1 if this device is battery powered
1910 j = 0x80;
1911 if (eeprom->self_powered == 1)
1912 j |= 0x40;
1913 if (eeprom->remote_wakeup == 1)
1914 j |= 0x20;
1915 output[0x08] = j;
1916
1917 // Addr 09: Max power consumption: max power = value * 2 mA
1918 output[0x09] = eeprom->max_power;
1919
1920 // Addr 0A: Chip configuration
1921 // Bit 7: 0 - reserved
1922 // Bit 6: 0 - reserved
1923 // Bit 5: 0 - reserved
1924 // Bit 4: 1 - Change USB version
1925 // Bit 3: 1 - Use the serial number string
1926 // Bit 2: 1 - Enable suspend pull downs for lower power
1927 // Bit 1: 1 - Out EndPoint is Isochronous
1928 // Bit 0: 1 - In EndPoint is Isochronous
1929 //
1930 j = 0;
1931 if (eeprom->in_is_isochronous == 1)
1932 j = j | 1;
1933 if (eeprom->out_is_isochronous == 1)
1934 j = j | 2;
1935 if (eeprom->suspend_pull_downs == 1)
1936 j = j | 4;
1937 if (eeprom->use_serial == 1)
1938 j = j | 8;
1939 if (eeprom->change_usb_version == 1)
1940 j = j | 16;
1941 output[0x0A] = j;
1942
1943 // Addr 0B: reserved
1944 output[0x0B] = 0x00;
1945
1946 // Addr 0C: USB version low byte when 0x0A bit 4 is set
1947 // Addr 0D: USB version high byte when 0x0A bit 4 is set
1948 if (eeprom->change_usb_version == 1)
1949 {
1950 output[0x0C] = eeprom->usb_version;
1951 output[0x0D] = eeprom->usb_version >> 8;
1952 }
1953
1954
1955 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
1956 // Addr 0F: Length of manufacturer string
1957 output[0x0F] = manufacturer_size*2 + 2;
1958
1959 // Addr 10: Offset of the product string + 0x80, calculated later
1960 // Addr 11: Length of product string
1961 output[0x11] = product_size*2 + 2;
1962
1963 // Addr 12: Offset of the serial string + 0x80, calculated later
1964 // Addr 13: Length of serial string
1965 output[0x13] = serial_size*2 + 2;
1966
1967 // Dynamic content
1968 i=0x14;
1969 if (eeprom->size>=256) i = 0x80;
1970
1971
1972 // Output manufacturer
1973 output[0x0E] = i | 0x80; // calculate offset
1974 output[i++] = manufacturer_size*2 + 2;
1975 output[i++] = 0x03; // type: string
1976 for (j = 0; j < manufacturer_size; j++)
1977 {
1978 output[i] = eeprom->manufacturer[j], i++;
1979 output[i] = 0x00, i++;
1980 }
1981
1982 // Output product name
1983 output[0x10] = i | 0x80; // calculate offset
1984 output[i] = product_size*2 + 2, i++;
1985 output[i] = 0x03, i++;
1986 for (j = 0; j < product_size; j++)
1987 {
1988 output[i] = eeprom->product[j], i++;
1989 output[i] = 0x00, i++;
1990 }
1991
1992 // Output serial
1993 output[0x12] = i | 0x80; // calculate offset
1994 output[i] = serial_size*2 + 2, i++;
1995 output[i] = 0x03, i++;
1996 for (j = 0; j < serial_size; j++)
1997 {
1998 output[i] = eeprom->serial[j], i++;
1999 output[i] = 0x00, i++;
2000 }
2001
2002 // calculate checksum
2003 checksum = 0xAAAA;
2004
2005 for (i = 0; i < eeprom->size/2-1; i++)
2006 {
2007 value = output[i*2];
2008 value += output[(i*2)+1] << 8;
2009
2010 checksum = value^checksum;
2011 checksum = (checksum << 1) | (checksum >> 15);
2012 }
2013
2014 output[eeprom->size-2] = checksum;
2015 output[eeprom->size-1] = checksum >> 8;
2016
2017 return size_check;
2018}
2019
2020/**
2021 Decode binary EEPROM image into an ftdi_eeprom structure.
2022
2023 \param eeprom Pointer to ftdi_eeprom which will be filled in.
2024 \param buf Buffer of \a size bytes of raw eeprom data
2025 \param size size size of eeprom data in bytes
2026
2027 \retval 0: all fine
2028 \retval -1: something went wrong
2029
2030 FIXME: How to pass size? How to handle size field in ftdi_eeprom?
2031 FIXME: Strings are malloc'ed here and should be freed somewhere
2032*/
2033int ftdi_eeprom_decode(struct ftdi_eeprom *eeprom, unsigned char *buf, int size)
2034{
2035 unsigned char i, j;
2036 unsigned short checksum, eeprom_checksum, value;
2037 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
2038 int size_check;
2039 int eeprom_size = 128;
2040#if 0
2041 size_check = eeprom->size;
2042 size_check -= 28; // 28 are always in use (fixed)
2043
2044 // Top half of a 256byte eeprom is used just for strings and checksum
2045 // it seems that the FTDI chip will not read these strings from the lower half
2046 // Each string starts with two bytes; offset and type (0x03 for string)
2047 // the checksum needs two bytes, so without the string data that 8 bytes from the top half
2048 if (eeprom->size>=256)size_check = 120;
2049 size_check -= manufacturer_size*2;
2050 size_check -= product_size*2;
2051 size_check -= serial_size*2;
2052
2053 // eeprom size exceeded?
2054 if (size_check < 0)
2055 return (-1);
2056#endif
2057
2058 // empty eeprom struct
2059 memset(eeprom, 0, sizeof(struct ftdi_eeprom));
2060
2061 // Addr 00: Stay 00 00
2062
2063 // Addr 02: Vendor ID
2064 eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
2065
2066 // Addr 04: Product ID
2067 eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
2068
2069 value = buf[0x06] + (buf[0x07]<<8);
2070 switch (value)
2071 {
2072 case 0x0400:
2073 eeprom->BM_type_chip = 1;
2074 break;
2075 case 0x0200:
2076 eeprom->BM_type_chip = 0;
2077 break;
2078 default: // Unknown device
2079 eeprom->BM_type_chip = 0;
2080 break;
2081 }
2082
2083 // Addr 08: Config descriptor
2084 // Bit 7: always 1
2085 // Bit 6: 1 if this device is self powered, 0 if bus powered
2086 // Bit 5: 1 if this device uses remote wakeup
2087 // Bit 4: 1 if this device is battery powered
2088 j = buf[0x08];
2089 if (j&0x40) eeprom->self_powered = 1;
2090 if (j&0x20) eeprom->remote_wakeup = 1;
2091
2092 // Addr 09: Max power consumption: max power = value * 2 mA
2093 eeprom->max_power = buf[0x09];
2094
2095 // Addr 0A: Chip configuration
2096 // Bit 7: 0 - reserved
2097 // Bit 6: 0 - reserved
2098 // Bit 5: 0 - reserved
2099 // Bit 4: 1 - Change USB version
2100 // Bit 3: 1 - Use the serial number string
2101 // Bit 2: 1 - Enable suspend pull downs for lower power
2102 // Bit 1: 1 - Out EndPoint is Isochronous
2103 // Bit 0: 1 - In EndPoint is Isochronous
2104 //
2105 j = buf[0x0A];
2106 if (j&0x01) eeprom->in_is_isochronous = 1;
2107 if (j&0x02) eeprom->out_is_isochronous = 1;
2108 if (j&0x04) eeprom->suspend_pull_downs = 1;
2109 if (j&0x08) eeprom->use_serial = 1;
2110 if (j&0x10) eeprom->change_usb_version = 1;
2111
2112 // Addr 0B: reserved
2113
2114 // Addr 0C: USB version low byte when 0x0A bit 4 is set
2115 // Addr 0D: USB version high byte when 0x0A bit 4 is set
2116 if (eeprom->change_usb_version == 1)
2117 {
2118 eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
2119 }
2120
2121 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2122 // Addr 0F: Length of manufacturer string
2123 manufacturer_size = buf[0x0F]/2;
2124 if (manufacturer_size > 0) eeprom->manufacturer = malloc(manufacturer_size);
2125 else eeprom->manufacturer = NULL;
2126
2127 // Addr 10: Offset of the product string + 0x80, calculated later
2128 // Addr 11: Length of product string
2129 product_size = buf[0x11]/2;
2130 if (product_size > 0) eeprom->product = malloc(product_size);
2131 else eeprom->product = NULL;
2132
2133 // Addr 12: Offset of the serial string + 0x80, calculated later
2134 // Addr 13: Length of serial string
2135 serial_size = buf[0x13]/2;
2136 if (serial_size > 0) eeprom->serial = malloc(serial_size);
2137 else eeprom->serial = NULL;
2138
2139 // Decode manufacturer
2140 i = buf[0x0E] & 0x7f; // offset
2141 for (j=0;j<manufacturer_size-1;j++)
2142 {
2143 eeprom->manufacturer[j] = buf[2*j+i+2];
2144 }
2145 eeprom->manufacturer[j] = '\0';
2146
2147 // Decode product name
2148 i = buf[0x10] & 0x7f; // offset
2149 for (j=0;j<product_size-1;j++)
2150 {
2151 eeprom->product[j] = buf[2*j+i+2];
2152 }
2153 eeprom->product[j] = '\0';
2154
2155 // Decode serial
2156 i = buf[0x12] & 0x7f; // offset
2157 for (j=0;j<serial_size-1;j++)
2158 {
2159 eeprom->serial[j] = buf[2*j+i+2];
2160 }
2161 eeprom->serial[j] = '\0';
2162
2163 // verify checksum
2164 checksum = 0xAAAA;
2165
2166 for (i = 0; i < eeprom_size/2-1; i++)
2167 {
2168 value = buf[i*2];
2169 value += buf[(i*2)+1] << 8;
2170
2171 checksum = value^checksum;
2172 checksum = (checksum << 1) | (checksum >> 15);
2173 }
2174
2175 eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
2176
2177 if (eeprom_checksum != checksum)
2178 {
2179 fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
2180 return -1;
2181 }
2182
2183 return 0;
2184}
2185
2186/**
2187 Read eeprom location
2188
2189 \param ftdi pointer to ftdi_context
2190 \param eeprom_addr Address of eeprom location to be read
2191 \param eeprom_val Pointer to store read eeprom location
2192
2193 \retval 0: all fine
2194 \retval -1: read failed
2195*/
2196int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
2197{
2198 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, eeprom_addr, (char *)eeprom_val, 2, ftdi->usb_read_timeout) != 2)
2199 ftdi_error_return(-1, "reading eeprom failed");
2200
2201 return 0;
2202}
2203
2204/**
2205 Read eeprom
2206
2207 \param ftdi pointer to ftdi_context
2208 \param eeprom Pointer to store eeprom into
2209
2210 \retval 0: all fine
2211 \retval -1: read failed
2212*/
2213int ftdi_read_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
2214{
2215 int i;
2216
2217 for (i = 0; i < ftdi->eeprom_size/2; i++)
2218 {
2219 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, i, eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
2220 ftdi_error_return(-1, "reading eeprom failed");
2221 }
2222
2223 return 0;
2224}
2225
2226/*
2227 ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID
2228 Function is only used internally
2229 \internal
2230*/
2231static unsigned char ftdi_read_chipid_shift(unsigned char value)
2232{
2233 return ((value & 1) << 1) |
2234 ((value & 2) << 5) |
2235 ((value & 4) >> 2) |
2236 ((value & 8) << 4) |
2237 ((value & 16) >> 1) |
2238 ((value & 32) >> 1) |
2239 ((value & 64) >> 4) |
2240 ((value & 128) >> 2);
2241}
2242
2243/**
2244 Read the FTDIChip-ID from R-type devices
2245
2246 \param ftdi pointer to ftdi_context
2247 \param chipid Pointer to store FTDIChip-ID
2248
2249 \retval 0: all fine
2250 \retval -1: read failed
2251*/
2252int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
2253{
2254 unsigned int a = 0, b = 0;
2255
2256 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x43, (char *)&a, 2, ftdi->usb_read_timeout) == 2)
2257 {
2258 a = a << 8 | a >> 8;
2259 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x44, (char *)&b, 2, ftdi->usb_read_timeout) == 2)
2260 {
2261 b = b << 8 | b >> 8;
2262 a = (a << 16) | (b & 0xFFFF);
2263 a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
2264 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
2265 *chipid = a ^ 0xa5f0f7d1;
2266 return 0;
2267 }
2268 }
2269
2270 ftdi_error_return(-1, "read of FTDIChip-ID failed");
2271}
2272
2273/**
2274 Guesses size of eeprom by reading eeprom and comparing halves - will not work with blank eeprom
2275 Call this function then do a write then call again to see if size changes, if so write again.
2276
2277 \param ftdi pointer to ftdi_context
2278 \param eeprom Pointer to store eeprom into
2279 \param maxsize the size of the buffer to read into
2280
2281 \retval size of eeprom
2282*/
2283int ftdi_read_eeprom_getsize(struct ftdi_context *ftdi, unsigned char *eeprom, int maxsize)
2284{
2285 int i=0,j,minsize=32;
2286 int size=minsize;
2287
2288 do
2289 {
2290 for (j = 0; i < maxsize/2 && j<size; j++)
2291 {
2292 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,
2293 SIO_READ_EEPROM_REQUEST, 0, i,
2294 eeprom+(i*2), 2, ftdi->usb_read_timeout) != 2)
2295 ftdi_error_return(-1, "reading eeprom failed");
2296 i++;
2297 }
2298 size*=2;
2299 }
2300 while (size<=maxsize && memcmp(eeprom,&eeprom[size/2],size/2)!=0);
2301
2302 return size/2;
2303}
2304
2305/**
2306 Write eeprom location
2307
2308 \param ftdi pointer to ftdi_context
2309 \param eeprom_addr Address of eeprom location to be written
2310 \param eeprom_val Value to be written
2311
2312 \retval 0: all fine
2313 \retval -1: read failed
2314*/
2315int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr, unsigned short eeprom_val)
2316{
2317 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2318 SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
2319 NULL, 0, ftdi->usb_write_timeout) != 0)
2320 ftdi_error_return(-1, "unable to write eeprom");
2321
2322 return 0;
2323}
2324
2325/**
2326 Write eeprom
2327
2328 \param ftdi pointer to ftdi_context
2329 \param eeprom Pointer to read eeprom from
2330
2331 \retval 0: all fine
2332 \retval -1: read failed
2333*/
2334int ftdi_write_eeprom(struct ftdi_context *ftdi, unsigned char *eeprom)
2335{
2336 unsigned short usb_val, status;
2337 int i, ret;
2338
2339 /* These commands were traced while running MProg */
2340 if ((ret = ftdi_usb_reset(ftdi)) != 0)
2341 return ret;
2342 if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0)
2343 return ret;
2344 if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0)
2345 return ret;
2346
2347 for (i = 0; i < ftdi->eeprom_size/2; i++)
2348 {
2349 usb_val = eeprom[i*2];
2350 usb_val += eeprom[(i*2)+1] << 8;
2351 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2352 SIO_WRITE_EEPROM_REQUEST, usb_val, i,
2353 NULL, 0, ftdi->usb_write_timeout) != 0)
2354 ftdi_error_return(-1, "unable to write eeprom");
2355 }
2356
2357 return 0;
2358}
2359
2360/**
2361 Erase eeprom
2362
2363 This is not supported on FT232R/FT245R according to the MProg manual from FTDI.
2364
2365 \param ftdi pointer to ftdi_context
2366
2367 \retval 0: all fine
2368 \retval -1: erase failed
2369*/
2370int ftdi_erase_eeprom(struct ftdi_context *ftdi)
2371{
2372 if (usb_control_msg(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST, 0, 0, NULL, 0, ftdi->usb_write_timeout) != 0)
2373 ftdi_error_return(-1, "unable to erase eeprom");
2374
2375 return 0;
2376}
2377
2378/**
2379 Get string representation for last error code
2380
2381 \param ftdi pointer to ftdi_context
2382
2383 \retval Pointer to error string
2384*/
2385char *ftdi_get_error_string (struct ftdi_context *ftdi)
2386{
2387 return ftdi->error_str;
2388}
2389
2390/* @} end of doxygen libftdi group */
A library to talk to FTDI chips