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