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