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