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