git://developer.intra2net.com / libftdi / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Add new function ftdi_usb_get_strings2()
[libftdi] / src / ftdi.c
CommitLineData
a3da1d95
GE		 1/***************************************************************************
2 ftdi.c - description
3 -------------------
4 begin : Fri Apr 4 2003
dcd7e8a3 5 copyright : (C) 2003-2014 by Intra2net AG and the libftdi developers
5fdb1cb1 6 email : opensource@intra2net.com
a3da1d95
GE		 7 ***************************************************************************/
8
9/***************************************************************************
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU Lesser General Public License *
13 * version 2.1 as published by the Free Software Foundation; *
14 * *
15 ***************************************************************************/
d9f0cce7 16
b5ec1820
TJ		 17/**
18 \mainpage libftdi API documentation
19
ad397a4b 20 Library to talk to FTDI chips. You find the latest versions of libftdi at
1bfc403c 21 http://www.intra2net.com/en/developer/libftdi/
b5ec1820 22
ad397a4b
TJ		 23 The library is easy to use. Have a look at this short example:
24 \include simple.c
25
26 More examples can be found in the "examples" directory.
b5ec1820
TJ		 27*/
28/** \addtogroup libftdi */
29/* @{ */
30
579b006f 31#include <libusb.h>
a8f46ddc 32#include <string.h>
d2f10023 33#include <errno.h>
b56d5a64 34#include <stdio.h>
579b006f 35#include <stdlib.h>
0e302db6 36
b790d38e 37#include "ftdi_i.h"
98452d97 38#include "ftdi.h"
0220adfa 39#include "ftdi_version_i.h"
a3da1d95 40
21abaf2e 41#define ftdi_error_return(code, str) do { \
b0a50459
PS		 42 if ( ftdi ) \
43 ftdi->error_str = str; \
44 else \
45 fprintf(stderr, str); \
21abaf2e 46 return code; \
d2f10023 47 } while(0);
c3d95b87 48
99650502
UB		 49#define ftdi_error_return_free_device_list(code, str, devs) do { \
50 libusb_free_device_list(devs,1); \
51 ftdi->error_str = str; \
52 return code; \
53 } while(0);
54
418aaa72 55
f3f81007
TJ		 56/**
57 Internal function to close usb device pointer.
58 Sets ftdi->usb_dev to NULL.
59 \internal
60
61 \param ftdi pointer to ftdi_context
62
579b006f 63 \retval none
f3f81007 64*/
579b006f 65static void ftdi_usb_close_internal (struct ftdi_context *ftdi)
dff4fdb0 66{
22a1b5c1 67 if (ftdi && ftdi->usb_dev)
dff4fdb0 68 {
56ac0383
TJ		 69 libusb_close (ftdi->usb_dev);
70 ftdi->usb_dev = NULL;
44f41f11
UB		 71 if(ftdi->eeprom)
72 ftdi->eeprom->initialized_for_connected_device = 0;
dff4fdb0 73 }
dff4fdb0 74}
c3d95b87 75
1941414d
TJ		 76/**
77 Initializes a ftdi_context.
4837f98a 78
1941414d 79 \param ftdi pointer to ftdi_context
4837f98a 80
1941414d
TJ		 81 \retval 0: all fine
82 \retval -1: couldn't allocate read buffer
a35aa9bd 83 \retval -2: couldn't allocate struct buffer
3a284749 84 \retval -3: libusb_init() failed
1941414d
TJ		 85
86 \remark This should be called before all functions
948f9ada 87*/
a8f46ddc
TJ		 88int ftdi_init(struct ftdi_context *ftdi)
89{
a35aa9bd 90 struct ftdi_eeprom* eeprom = (struct ftdi_eeprom *)malloc(sizeof(struct ftdi_eeprom));
02212d8e 91 ftdi->usb_ctx = NULL;
98452d97 92 ftdi->usb_dev = NULL;
545820ce
TJ		 93 ftdi->usb_read_timeout = 5000;
94 ftdi->usb_write_timeout = 5000;
a3da1d95 95
53ad271d 96 ftdi->type = TYPE_BM; /* chip type */
a3da1d95 97 ftdi->baudrate = -1;
418aaa72 98 ftdi->bitbang_enabled = 0; /* 0: normal mode 1: any of the bitbang modes enabled */
a3da1d95 99
948f9ada
TJ		 100 ftdi->readbuffer = NULL;
101 ftdi->readbuffer_offset = 0;
102 ftdi->readbuffer_remaining = 0;
103 ftdi->writebuffer_chunksize = 4096;
e2f12a4f 104 ftdi->max_packet_size = 0;
3a284749
TJ		 105 ftdi->error_str = NULL;
106 ftdi->module_detach_mode = AUTO_DETACH_SIO_MODULE;
107
108 if (libusb_init(&ftdi->usb_ctx) < 0)
109 ftdi_error_return(-3, "libusb_init() failed");
948f9ada 110
ac0af8ec 111 ftdi_set_interface(ftdi, INTERFACE_ANY);
418aaa72 112 ftdi->bitbang_mode = 1; /* when bitbang is enabled this holds the number of the mode */
53ad271d 113
a35aa9bd
UB		 114 if (eeprom == 0)
115 ftdi_error_return(-2, "Can't malloc struct ftdi_eeprom");
b4d19dea 116 memset(eeprom, 0, sizeof(struct ftdi_eeprom));
a35aa9bd 117 ftdi->eeprom = eeprom;
c201f80f 118
1c733d33
TJ		 119 /* All fine. Now allocate the readbuffer */
120 return ftdi_read_data_set_chunksize(ftdi, 4096);
948f9ada 121}
4837f98a 122
1941414d 123/**
cef378aa
TJ		 124 Allocate and initialize a new ftdi_context
125
126 \return a pointer to a new ftdi_context, or NULL on failure
127*/
672ac008 128struct ftdi_context *ftdi_new(void)
cef378aa
TJ		 129{
130 struct ftdi_context * ftdi = (struct ftdi_context *)malloc(sizeof(struct ftdi_context));
131
22d12cda
TJ		 132 if (ftdi == NULL)
133 {
cef378aa
TJ		 134 return NULL;
135 }
136
22d12cda
TJ		 137 if (ftdi_init(ftdi) != 0)
138 {
cef378aa 139 free(ftdi);
cdf448f6 140 return NULL;
cef378aa
TJ		 141 }
142
143 return ftdi;
144}
145
146/**
1941414d
TJ		 147 Open selected channels on a chip, otherwise use first channel.
148
149 \param ftdi pointer to ftdi_context
f9d69895 150 \param interface Interface to use for FT2232C/2232H/4232H chips.
1941414d
TJ		 151
152 \retval 0: all fine
153 \retval -1: unknown interface
22a1b5c1 154 \retval -2: USB device unavailable
1c5fa36b 155 \retval -3: Device already open, interface can't be set in that state
c4446c36 156*/
0ce2f5fa 157int ftdi_set_interface(struct ftdi_context *ftdi, enum ftdi_interface interface)
c4446c36 158{
1971c26d 159 if (ftdi == NULL)
22a1b5c1
TJ		 160 ftdi_error_return(-2, "USB device unavailable");
161
1c5fa36b
TJ		 162 if (ftdi->usb_dev != NULL)
163 {
164 int check_interface = interface;
165 if (check_interface == INTERFACE_ANY)
166 check_interface = INTERFACE_A;
167
168 if (ftdi->index != check_interface)
169 ftdi_error_return(-3, "Interface can not be changed on an already open device");
170 }
171
22d12cda
TJ		 172 switch (interface)
173 {
174 case INTERFACE_ANY:
175 case INTERFACE_A:
ac0af8ec
VY		 176 ftdi->interface = 0;
177 ftdi->index = INTERFACE_A;
178 ftdi->in_ep = 0x02;
179 ftdi->out_ep = 0x81;
22d12cda
TJ		 180 break;
181 case INTERFACE_B:
182 ftdi->interface = 1;
183 ftdi->index = INTERFACE_B;
184 ftdi->in_ep = 0x04;
185 ftdi->out_ep = 0x83;
186 break;
f9d69895
AH		 187 case INTERFACE_C:
188 ftdi->interface = 2;
189 ftdi->index = INTERFACE_C;
190 ftdi->in_ep = 0x06;
191 ftdi->out_ep = 0x85;
192 break;
193 case INTERFACE_D:
194 ftdi->interface = 3;
195 ftdi->index = INTERFACE_D;
196 ftdi->in_ep = 0x08;
197 ftdi->out_ep = 0x87;
198 break;
22d12cda
TJ		 199 default:
200 ftdi_error_return(-1, "Unknown interface");
c4446c36
TJ		 201 }
202 return 0;
203}
948f9ada 204
1941414d
TJ		 205/**
206 Deinitializes a ftdi_context.
4837f98a 207
1941414d 208 \param ftdi pointer to ftdi_context
4837f98a 209*/
a8f46ddc
TJ		 210void ftdi_deinit(struct ftdi_context *ftdi)
211{
22a1b5c1
TJ		 212 if (ftdi == NULL)
213 return;
214
f3f81007 215 ftdi_usb_close_internal (ftdi);
dff4fdb0 216
22d12cda
TJ		 217 if (ftdi->readbuffer != NULL)
218 {
d9f0cce7
TJ		 219 free(ftdi->readbuffer);
220 ftdi->readbuffer = NULL;
948f9ada 221 }
a35aa9bd
UB		 222
223 if (ftdi->eeprom != NULL)
224 {
74e8e79d
UB		 225 if (ftdi->eeprom->manufacturer != 0)
226 {
227 free(ftdi->eeprom->manufacturer);
228 ftdi->eeprom->manufacturer = 0;
229 }
230 if (ftdi->eeprom->product != 0)
231 {
232 free(ftdi->eeprom->product);
233 ftdi->eeprom->product = 0;
234 }
235 if (ftdi->eeprom->serial != 0)
236 {
237 free(ftdi->eeprom->serial);
238 ftdi->eeprom->serial = 0;
239 }
a35aa9bd
UB		 240 free(ftdi->eeprom);
241 ftdi->eeprom = NULL;
242 }
3a284749
TJ		 243
244 if (ftdi->usb_ctx)
245 {
246 libusb_exit(ftdi->usb_ctx);
247 ftdi->usb_ctx = NULL;
248 }
a3da1d95
GE		 249}
250
1941414d 251/**
cef378aa
TJ		 252 Deinitialize and free an ftdi_context.
253
254 \param ftdi pointer to ftdi_context
255*/
256void ftdi_free(struct ftdi_context *ftdi)
257{
258 ftdi_deinit(ftdi);
259 free(ftdi);
260}
261
262/**
1941414d
TJ		 263 Use an already open libusb device.
264
265 \param ftdi pointer to ftdi_context
579b006f 266 \param usb libusb libusb_device_handle to use
4837f98a 267*/
579b006f 268void ftdi_set_usbdev (struct ftdi_context *ftdi, libusb_device_handle *usb)
a8f46ddc 269{
22a1b5c1
TJ		 270 if (ftdi == NULL)
271 return;
272
98452d97
TJ		 273 ftdi->usb_dev = usb;
274}
275
0220adfa
TJ		 276/**
277 * @brief Get libftdi library version
278 *
279 * @return ftdi_version_info Library version information
280 **/
bd6941fd 281struct ftdi_version_info ftdi_get_library_version(void)
0220adfa
TJ		 282{
283 struct ftdi_version_info ver;
284
285 ver.major = FTDI_MAJOR_VERSION;
286 ver.minor = FTDI_MINOR_VERSION;
287 ver.micro = FTDI_MICRO_VERSION;
288 ver.version_str = FTDI_VERSION_STRING;
289 ver.snapshot_str = FTDI_SNAPSHOT_VERSION;
290
291 return ver;
292}
98452d97 293
1941414d 294/**
7879216a
UB		 295 Finds all ftdi devices with given VID:PID on the usb bus. Creates a new
296 ftdi_device_list which needs to be deallocated by ftdi_list_free() after
297 use. With VID:PID 0:0, search for the default devices
809d711d 298 (0x403:0x6001, 0x403:0x6010, 0x403:0x6011, 0x403:0x6014, 0x403:0x6015)
1941414d
TJ		 299
300 \param ftdi pointer to ftdi_context
301 \param devlist Pointer where to store list of found devices
302 \param vendor Vendor ID to search for
303 \param product Product ID to search for
edb82cbf 304
1941414d 305 \retval >0: number of devices found
1941414d 306 \retval -3: out of memory
579b006f
JZ		 307 \retval -5: libusb_get_device_list() failed
308 \retval -6: libusb_get_device_descriptor() failed
edb82cbf 309*/
d2f10023 310int ftdi_usb_find_all(struct ftdi_context *ftdi, struct ftdi_device_list **devlist, int vendor, int product)
edb82cbf
TJ		 311{
312 struct ftdi_device_list **curdev;
579b006f
JZ		 313 libusb_device *dev;
314 libusb_device **devs;
edb82cbf 315 int count = 0;
579b006f
JZ		 316 int i = 0;
317
02212d8e 318 if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
579b006f 319 ftdi_error_return(-5, "libusb_get_device_list() failed");
edb82cbf
TJ		 320
321 curdev = devlist;
6db32169 322 *curdev = NULL;
579b006f
JZ		 323
324 while ((dev = devs[i++]) != NULL)
22d12cda 325 {
579b006f 326 struct libusb_device_descriptor desc;
d2f10023 327
579b006f 328 if (libusb_get_device_descriptor(dev, &desc) < 0)
77377af7 329 ftdi_error_return_free_device_list(-6, "libusb_get_device_descriptor() failed", devs);
edb82cbf 330
8de26dde 331 if (((vendor || product) &&
74387f27 332 desc.idVendor == vendor && desc.idProduct == product) ||
8de26dde 333 (!(vendor || product) &&
74387f27 334 (desc.idVendor == 0x403) && (desc.idProduct == 0x6001 || desc.idProduct == 0x6010
809d711d
TJ		 335 || desc.idProduct == 0x6011 || desc.idProduct == 0x6014
336 || desc.idProduct == 0x6015)))
579b006f
JZ		 337 {
338 *curdev = (struct ftdi_device_list*)malloc(sizeof(struct ftdi_device_list));
339 if (!*curdev)
77377af7 340 ftdi_error_return_free_device_list(-3, "out of memory", devs);
56ac0383 341
579b006f
JZ		 342 (*curdev)->next = NULL;
343 (*curdev)->dev = dev;
0c33162c 344 libusb_ref_device(dev);
579b006f
JZ		 345 curdev = &(*curdev)->next;
346 count++;
edb82cbf
TJ		 347 }
348 }
77377af7 349 libusb_free_device_list(devs,1);
edb82cbf
TJ		 350 return count;
351}
352
1941414d
TJ		 353/**
354 Frees a usb device list.
edb82cbf 355
1941414d 356 \param devlist USB device list created by ftdi_usb_find_all()
edb82cbf 357*/
d2f10023 358void ftdi_list_free(struct ftdi_device_list **devlist)
edb82cbf 359{
6db32169
TJ		 360 struct ftdi_device_list *curdev, *next;
361
22d12cda
TJ		 362 for (curdev = *devlist; curdev != NULL;)
363 {
6db32169 364 next = curdev->next;
0c33162c 365 libusb_unref_device(curdev->dev);
6db32169
TJ		 366 free(curdev);
367 curdev = next;
edb82cbf
TJ		 368 }
369
6db32169 370 *devlist = NULL;
edb82cbf
TJ		 371}
372
1941414d 373/**
cef378aa
TJ		 374 Frees a usb device list.
375
376 \param devlist USB device list created by ftdi_usb_find_all()
377*/
378void ftdi_list_free2(struct ftdi_device_list *devlist)
379{
380 ftdi_list_free(&devlist);
381}
382
383/**
474786c0
TJ		 384 Return device ID strings from the usb device.
385
386 The parameters manufacturer, description and serial may be NULL
387 or pointer to buffers to store the fetched strings.
388
898c34dd
TJ		 389 \note Use this function only in combination with ftdi_usb_find_all()
390 as it closes the internal "usb_dev" after use.
391
474786c0
TJ		 392 \param ftdi pointer to ftdi_context
393 \param dev libusb usb_dev to use
394 \param manufacturer Store manufacturer string here if not NULL
395 \param mnf_len Buffer size of manufacturer string
396 \param description Store product description string here if not NULL
397 \param desc_len Buffer size of product description string
398 \param serial Store serial string here if not NULL
399 \param serial_len Buffer size of serial string
400
401 \retval 0: all fine
402 \retval -1: wrong arguments
403 \retval -4: unable to open device
404 \retval -7: get product manufacturer failed
405 \retval -8: get product description failed
406 \retval -9: get serial number failed
579b006f 407 \retval -11: libusb_get_device_descriptor() failed
474786c0 408*/
15079e78
FH		 409int ftdi_usb_get_strings(struct ftdi_context *ftdi,
410 struct libusb_device *dev,
411 char *manufacturer, int mnf_len,
412 char *description, int desc_len,
413 char *serial, int serial_len)
474786c0 414{
15079e78 415 int ret;
579b006f 416
474786c0
TJ		 417 if ((ftdi==NULL) || (dev==NULL))
418 return -1;
419
bc384123 420 if (ftdi->usb_dev == NULL && libusb_open(dev, &ftdi->usb_dev) < 0)
15079e78
FH		 421 ftdi_error_return(-4, "libusb_open() failed");
422
423 // ftdi->usb_dev will not be NULL when entering ftdi_usb_get_strings2(), so
424 // it won't be closed either. This allows us to close it whether we actually
425 // called libusb_open() up above or not. This matches the expected behavior
426 // (and note) for ftdi_usb_get_strings().
427 ret = ftdi_usb_get_strings2(ftdi, dev,
428 manufacturer, mnf_len,
429 description, desc_len,
430 serial, serial_len);
431
432 // only close it if it was successful, as all other return codes close
433 // before returning already.
434 if (ret == 0)
435 ftdi_usb_close_internal(ftdi);
436
437 return ret;
438}
439
440/**
441 Return device ID strings from the usb device.
442
443 The parameters manufacturer, description and serial may be NULL
444 or pointer to buffers to store the fetched strings.
445
446 \note The old function ftdi_usb_get_strings() always closes the device.
447 This version only closes the device if it was opened by it.
448
449 \param ftdi pointer to ftdi_context
450 \param dev libusb usb_dev to use
451 \param manufacturer Store manufacturer string here if not NULL
452 \param mnf_len Buffer size of manufacturer string
453 \param description Store product description string here if not NULL
454 \param desc_len Buffer size of product description string
455 \param serial Store serial string here if not NULL
456 \param serial_len Buffer size of serial string
457
458 \retval 0: all fine
459 \retval -1: wrong arguments
460 \retval -4: unable to open device
461 \retval -7: get product manufacturer failed
462 \retval -8: get product description failed
463 \retval -9: get serial number failed
464 \retval -11: libusb_get_device_descriptor() failed
465*/
466int ftdi_usb_get_strings2(struct ftdi_context *ftdi, struct libusb_device *dev,
467 char *manufacturer, int mnf_len,
468 char *description, int desc_len,
469 char *serial, int serial_len)
470{
471 struct libusb_device_descriptor desc;
472
473 if ((ftdi==NULL) || (dev==NULL))
474 return -1;
475
476 char need_open = (ftdi->usb_dev == NULL);
477 if (need_open && libusb_open(dev, &ftdi->usb_dev) < 0)
478 ftdi_error_return(-4, "libusb_open() failed");
579b006f
JZ		 479
480 if (libusb_get_device_descriptor(dev, &desc) < 0)
481 ftdi_error_return(-11, "libusb_get_device_descriptor() failed");
474786c0 482
22d12cda
TJ		 483 if (manufacturer != NULL)
484 {
579b006f 485 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iManufacturer, (unsigned char *)manufacturer, mnf_len) < 0)
22d12cda 486 {
f3f81007 487 ftdi_usb_close_internal (ftdi);
579b006f 488 ftdi_error_return(-7, "libusb_get_string_descriptor_ascii() failed");
474786c0
TJ		 489 }
490 }
491
22d12cda
TJ		 492 if (description != NULL)
493 {
579b006f 494 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)description, desc_len) < 0)
22d12cda 495 {
f3f81007 496 ftdi_usb_close_internal (ftdi);
579b006f 497 ftdi_error_return(-8, "libusb_get_string_descriptor_ascii() failed");
474786c0
TJ		 498 }
499 }
500
22d12cda
TJ		 501 if (serial != NULL)
502 {
579b006f 503 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)serial, serial_len) < 0)
22d12cda 504 {
f3f81007 505 ftdi_usb_close_internal (ftdi);
579b006f 506 ftdi_error_return(-9, "libusb_get_string_descriptor_ascii() failed");
474786c0
TJ		 507 }
508 }
509
15079e78
FH		 510 if (need_open)
511 ftdi_usb_close_internal (ftdi);
474786c0
TJ		 512
513 return 0;
514}
515
516/**
e2f12a4f
TJ		 517 * Internal function to determine the maximum packet size.
518 * \param ftdi pointer to ftdi_context
519 * \param dev libusb usb_dev to use
520 * \retval Maximum packet size for this device
521 */
579b006f 522static unsigned int _ftdi_determine_max_packet_size(struct ftdi_context *ftdi, libusb_device *dev)
e2f12a4f 523{
579b006f
JZ		 524 struct libusb_device_descriptor desc;
525 struct libusb_config_descriptor *config0;
e2f12a4f
TJ		 526 unsigned int packet_size;
527
22a1b5c1
TJ		 528 // Sanity check
529 if (ftdi == NULL || dev == NULL)
530 return 64;
531
e2f12a4f
TJ		 532 // Determine maximum packet size. Init with default value.
533 // New hi-speed devices from FTDI use a packet size of 512 bytes
534 // but could be connected to a normal speed USB hub -> 64 bytes packet size.
6ae693b2 535 if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H)
e2f12a4f
TJ		 536 packet_size = 512;
537 else
538 packet_size = 64;
539
579b006f
JZ		 540 if (libusb_get_device_descriptor(dev, &desc) < 0)
541 return packet_size;
542
543 if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
544 return packet_size;
e2f12a4f 545
579b006f
JZ		 546 if (desc.bNumConfigurations > 0)
547 {
548 if (ftdi->interface < config0->bNumInterfaces)
e2f12a4f 549 {
579b006f 550 struct libusb_interface interface = config0->interface[ftdi->interface];
e2f12a4f
TJ		 551 if (interface.num_altsetting > 0)
552 {
579b006f 553 struct libusb_interface_descriptor descriptor = interface.altsetting[0];
e2f12a4f
TJ		 554 if (descriptor.bNumEndpoints > 0)
555 {
556 packet_size = descriptor.endpoint[0].wMaxPacketSize;
557 }
558 }
559 }
560 }
561
579b006f 562 libusb_free_config_descriptor (config0);
e2f12a4f
TJ		 563 return packet_size;
564}
565
566/**
418aaa72 567 Opens a ftdi device given by an usb_device.
7b18bef6 568
1941414d
TJ		 569 \param ftdi pointer to ftdi_context
570 \param dev libusb usb_dev to use
571
572 \retval 0: all fine
23b1798d 573 \retval -3: unable to config device
1941414d
TJ		 574 \retval -4: unable to open device
575 \retval -5: unable to claim device
576 \retval -6: reset failed
577 \retval -7: set baudrate failed
22a1b5c1 578 \retval -8: ftdi context invalid
579b006f
JZ		 579 \retval -9: libusb_get_device_descriptor() failed
580 \retval -10: libusb_get_config_descriptor() failed
e375e6cb 581 \retval -11: libusb_detach_kernel_driver() failed
579b006f 582 \retval -12: libusb_get_configuration() failed
7b18bef6 583*/
579b006f 584int ftdi_usb_open_dev(struct ftdi_context *ftdi, libusb_device *dev)
7b18bef6 585{
579b006f
JZ		 586 struct libusb_device_descriptor desc;
587 struct libusb_config_descriptor *config0;
43aee24f 588 int cfg, cfg0, detach_errno = 0;
579b006f 589
22a1b5c1
TJ		 590 if (ftdi == NULL)
591 ftdi_error_return(-8, "ftdi context invalid");
592
579b006f
JZ		 593 if (libusb_open(dev, &ftdi->usb_dev) < 0)
594 ftdi_error_return(-4, "libusb_open() failed");
595
596 if (libusb_get_device_descriptor(dev, &desc) < 0)
597 ftdi_error_return(-9, "libusb_get_device_descriptor() failed");
598
599 if (libusb_get_config_descriptor(dev, 0, &config0) < 0)
600 ftdi_error_return(-10, "libusb_get_config_descriptor() failed");
601 cfg0 = config0->bConfigurationValue;
602 libusb_free_config_descriptor (config0);
d2f10023 603
22592e17 604 // Try to detach ftdi_sio kernel module.
22592e17
TJ		 605 //
606 // The return code is kept in a separate variable and only parsed
607 // if usb_set_configuration() or usb_claim_interface() fails as the
608 // detach operation might be denied and everything still works fine.
609 // Likely scenario is a static ftdi_sio kernel module.
a3d86bdb
TJ		 610 if (ftdi->module_detach_mode == AUTO_DETACH_SIO_MODULE)
611 {
612 if (libusb_detach_kernel_driver(ftdi->usb_dev, ftdi->interface) !=0)
613 detach_errno = errno;
614 }
d2f10023 615
579b006f
JZ		 616 if (libusb_get_configuration (ftdi->usb_dev, &cfg) < 0)
617 ftdi_error_return(-12, "libusb_get_configuration () failed");
b57aedfd
GE		 618 // set configuration (needed especially for windows)
619 // tolerate EBUSY: one device with one configuration, but two interfaces
620 // and libftdi sessions to both interfaces (e.g. FT2232)
579b006f 621 if (desc.bNumConfigurations > 0 && cfg != cfg0)
b57aedfd 622 {
579b006f 623 if (libusb_set_configuration(ftdi->usb_dev, cfg0) < 0)
22d12cda 624 {
a56ba2bd 625 ftdi_usb_close_internal (ftdi);
56ac0383 626 if (detach_errno == EPERM)
43aee24f
UB		 627 {
628 ftdi_error_return(-8, "inappropriate permissions on device!");
629 }
630 else
631 {
c16b162d 632 ftdi_error_return(-3, "unable to set usb configuration. Make sure the default FTDI driver is not in use");
43aee24f 633 }
23b1798d
TJ		 634 }
635 }
636
579b006f 637 if (libusb_claim_interface(ftdi->usb_dev, ftdi->interface) < 0)
22d12cda 638 {
f3f81007 639 ftdi_usb_close_internal (ftdi);
56ac0383 640 if (detach_errno == EPERM)
43aee24f
UB		 641 {
642 ftdi_error_return(-8, "inappropriate permissions on device!");
643 }
644 else
645 {
c16b162d 646 ftdi_error_return(-5, "unable to claim usb device. Make sure the default FTDI driver is not in use");
43aee24f 647 }
7b18bef6
TJ		 648 }
649
22d12cda
TJ		 650 if (ftdi_usb_reset (ftdi) != 0)
651 {
f3f81007 652 ftdi_usb_close_internal (ftdi);
7b18bef6
TJ		 653 ftdi_error_return(-6, "ftdi_usb_reset failed");
654 }
655
7b18bef6
TJ		 656 // Try to guess chip type
657 // Bug in the BM type chips: bcdDevice is 0x200 for serial == 0
579b006f 658 if (desc.bcdDevice == 0x400 || (desc.bcdDevice == 0x200
56ac0383 659 && desc.iSerialNumber == 0))
7b18bef6 660 ftdi->type = TYPE_BM;
579b006f 661 else if (desc.bcdDevice == 0x200)
7b18bef6 662 ftdi->type = TYPE_AM;
579b006f 663 else if (desc.bcdDevice == 0x500)
7b18bef6 664 ftdi->type = TYPE_2232C;
579b006f 665 else if (desc.bcdDevice == 0x600)
cb6250fa 666 ftdi->type = TYPE_R;
579b006f 667 else if (desc.bcdDevice == 0x700)
0beb9686 668 ftdi->type = TYPE_2232H;
579b006f 669 else if (desc.bcdDevice == 0x800)
0beb9686 670 ftdi->type = TYPE_4232H;
c7e4c09e
UB		 671 else if (desc.bcdDevice == 0x900)
672 ftdi->type = TYPE_232H;
2f80efc2
NP		 673 else if (desc.bcdDevice == 0x1000)
674 ftdi->type = TYPE_230X;
7b18bef6 675
e2f12a4f
TJ		 676 // Determine maximum packet size
677 ftdi->max_packet_size = _ftdi_determine_max_packet_size(ftdi, dev);
678
ef6f4838
TE		 679 if (ftdi_set_baudrate (ftdi, 9600) != 0)
680 {
681 ftdi_usb_close_internal (ftdi);
682 ftdi_error_return(-7, "set baudrate failed");
683 }
684
7b18bef6
TJ		 685 ftdi_error_return(0, "all fine");
686}
687
1941414d
TJ		 688/**
689 Opens the first device with a given vendor and product ids.
690
691 \param ftdi pointer to ftdi_context
692 \param vendor Vendor ID
693 \param product Product ID
694
9bec2387 695 \retval same as ftdi_usb_open_desc()
1941414d 696*/
edb82cbf
TJ		 697int ftdi_usb_open(struct ftdi_context *ftdi, int vendor, int product)
698{
699 return ftdi_usb_open_desc(ftdi, vendor, product, NULL, NULL);
700}
701
1941414d
TJ		 702/**
703 Opens the first device with a given, vendor id, product id,
704 description and serial.
705
706 \param ftdi pointer to ftdi_context
707 \param vendor Vendor ID
708 \param product Product ID
709 \param description Description to search for. Use NULL if not needed.
710 \param serial Serial to search for. Use NULL if not needed.
711
712 \retval 0: all fine
1941414d
TJ		 713 \retval -3: usb device not found
714 \retval -4: unable to open device
715 \retval -5: unable to claim device
716 \retval -6: reset failed
717 \retval -7: set baudrate failed
718 \retval -8: get product description failed
719 \retval -9: get serial number failed
579b006f
JZ		 720 \retval -12: libusb_get_device_list() failed
721 \retval -13: libusb_get_device_descriptor() failed
a3da1d95 722*/
04e1ea0a 723int ftdi_usb_open_desc(struct ftdi_context *ftdi, int vendor, int product,
a8f46ddc
TJ		 724 const char* description, const char* serial)
725{
5ebbdab9
GE		 726 return ftdi_usb_open_desc_index(ftdi,vendor,product,description,serial,0);
727}
728
729/**
730 Opens the index-th device with a given, vendor id, product id,
731 description and serial.
732
733 \param ftdi pointer to ftdi_context
734 \param vendor Vendor ID
735 \param product Product ID
736 \param description Description to search for. Use NULL if not needed.
737 \param serial Serial to search for. Use NULL if not needed.
738 \param index Number of matching device to open if there are more than one, starts with 0.
739
740 \retval 0: all fine
741 \retval -1: usb_find_busses() failed
742 \retval -2: usb_find_devices() failed
743 \retval -3: usb device not found
744 \retval -4: unable to open device
745 \retval -5: unable to claim device
746 \retval -6: reset failed
747 \retval -7: set baudrate failed
748 \retval -8: get product description failed
749 \retval -9: get serial number failed
750 \retval -10: unable to close device
22a1b5c1 751 \retval -11: ftdi context invalid
5ebbdab9
GE		 752*/
753int ftdi_usb_open_desc_index(struct ftdi_context *ftdi, int vendor, int product,
56ac0383 754 const char* description, const char* serial, unsigned int index)
5ebbdab9 755{
579b006f
JZ		 756 libusb_device *dev;
757 libusb_device **devs;
c3d95b87 758 char string[256];
579b006f 759 int i = 0;
98452d97 760
22a1b5c1
TJ		 761 if (ftdi == NULL)
762 ftdi_error_return(-11, "ftdi context invalid");
763
02212d8e 764 if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
99650502
UB		 765 ftdi_error_return(-12, "libusb_get_device_list() failed");
766
579b006f 767 while ((dev = devs[i++]) != NULL)
22d12cda 768 {
579b006f 769 struct libusb_device_descriptor desc;
99650502 770 int res;
579b006f
JZ		 771
772 if (libusb_get_device_descriptor(dev, &desc) < 0)
99650502 773 ftdi_error_return_free_device_list(-13, "libusb_get_device_descriptor() failed", devs);
579b006f
JZ		 774
775 if (desc.idVendor == vendor && desc.idProduct == product)
22d12cda 776 {
579b006f 777 if (libusb_open(dev, &ftdi->usb_dev) < 0)
99650502 778 ftdi_error_return_free_device_list(-4, "usb_open() failed", devs);
c3d95b87 779
579b006f
JZ		 780 if (description != NULL)
781 {
782 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iProduct, (unsigned char *)string, sizeof(string)) < 0)
22d12cda 783 {
d4afae5f 784 ftdi_usb_close_internal (ftdi);
99650502 785 ftdi_error_return_free_device_list(-8, "unable to fetch product description", devs);
a8f46ddc 786 }
579b006f 787 if (strncmp(string, description, sizeof(string)) != 0)
22d12cda 788 {
d4afae5f 789 ftdi_usb_close_internal (ftdi);
579b006f 790 continue;
a8f46ddc 791 }
579b006f
JZ		 792 }
793 if (serial != NULL)
794 {
795 if (libusb_get_string_descriptor_ascii(ftdi->usb_dev, desc.iSerialNumber, (unsigned char *)string, sizeof(string)) < 0)
796 {
797 ftdi_usb_close_internal (ftdi);
99650502 798 ftdi_error_return_free_device_list(-9, "unable to fetch serial number", devs);
579b006f
JZ		 799 }
800 if (strncmp(string, serial, sizeof(string)) != 0)
801 {
802 ftdi_usb_close_internal (ftdi);
803 continue;
804 }
805 }
98452d97 806
579b006f 807 ftdi_usb_close_internal (ftdi);
d2f10023 808
56ac0383
TJ		 809 if (index > 0)
810 {
811 index--;
812 continue;
813 }
5ebbdab9 814
99650502
UB		 815 res = ftdi_usb_open_dev(ftdi, dev);
816 libusb_free_device_list(devs,1);
817 return res;
98452d97 818 }
98452d97 819 }
a3da1d95 820
98452d97 821 // device not found
99650502 822 ftdi_error_return_free_device_list(-3, "device not found", devs);
a3da1d95
GE		 823}
824
1941414d 825/**
5ebbdab9
GE		 826 Opens the ftdi-device described by a description-string.
827 Intended to be used for parsing a device-description given as commandline argument.
828
829 \param ftdi pointer to ftdi_context
830 \param description NULL-terminated description-string, using this format:
831 \li <tt>d:\<devicenode></tt> path of bus and device-node (e.g. "003/001") within usb device tree (usually at /proc/bus/usb/)
832 \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")
833 \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
834 \li <tt>s:\<vendor>:\<product>:\<serial></tt> first device with given vendor id, product id and serial string
835
836 \note The description format may be extended in later versions.
837
838 \retval 0: all fine
579b006f 839 \retval -2: libusb_get_device_list() failed
5ebbdab9
GE		 840 \retval -3: usb device not found
841 \retval -4: unable to open device
842 \retval -5: unable to claim device
843 \retval -6: reset failed
844 \retval -7: set baudrate failed
845 \retval -8: get product description failed
846 \retval -9: get serial number failed
847 \retval -10: unable to close device
848 \retval -11: illegal description format
22a1b5c1 849 \retval -12: ftdi context invalid
5ebbdab9
GE		 850*/
851int ftdi_usb_open_string(struct ftdi_context *ftdi, const char* description)
852{
22a1b5c1
TJ		 853 if (ftdi == NULL)
854 ftdi_error_return(-12, "ftdi context invalid");
855
5ebbdab9
GE		 856 if (description[0] == 0 || description[1] != ':')
857 ftdi_error_return(-11, "illegal description format");
858
859 if (description[0] == 'd')
860 {
579b006f
JZ		 861 libusb_device *dev;
862 libusb_device **devs;
56ac0383
TJ		 863 unsigned int bus_number, device_address;
864 int i = 0;
579b006f 865
56ac0383
TJ		 866 if (libusb_get_device_list(ftdi->usb_ctx, &devs) < 0)
867 ftdi_error_return(-2, "libusb_get_device_list() failed");
5ebbdab9 868
579b006f
JZ		 869 /* XXX: This doesn't handle symlinks/odd paths/etc... */
870 if (sscanf (description + 2, "%u/%u", &bus_number, &device_address) != 2)
56ac0383 871 ftdi_error_return_free_device_list(-11, "illegal description format", devs);
5ebbdab9 872
56ac0383 873 while ((dev = devs[i++]) != NULL)
5ebbdab9 874 {
99650502 875 int ret;
56ac0383
TJ		 876 if (bus_number == libusb_get_bus_number (dev)
877 && device_address == libusb_get_device_address (dev))
99650502
UB		 878 {
879 ret = ftdi_usb_open_dev(ftdi, dev);
880 libusb_free_device_list(devs,1);
881 return ret;
882 }
5ebbdab9
GE		 883 }
884
885 // device not found
99650502 886 ftdi_error_return_free_device_list(-3, "device not found", devs);
5ebbdab9
GE		 887 }
888 else if (description[0] == 'i' || description[0] == 's')
889 {
890 unsigned int vendor;
891 unsigned int product;
892 unsigned int index=0;
0e6cf62b 893 const char *serial=NULL;
5ebbdab9
GE		 894 const char *startp, *endp;
895
896 errno=0;
897 startp=description+2;
898 vendor=strtoul((char*)startp,(char**)&endp,0);
899 if (*endp != ':' || endp == startp || errno != 0)
900 ftdi_error_return(-11, "illegal description format");
901
902 startp=endp+1;
903 product=strtoul((char*)startp,(char**)&endp,0);
904 if (endp == startp || errno != 0)
905 ftdi_error_return(-11, "illegal description format");
906
907 if (description[0] == 'i' && *endp != 0)
908 {
909 /* optional index field in i-mode */
910 if (*endp != ':')
911 ftdi_error_return(-11, "illegal description format");
912
913 startp=endp+1;
914 index=strtoul((char*)startp,(char**)&endp,0);
915 if (*endp != 0 || endp == startp || errno != 0)
916 ftdi_error_return(-11, "illegal description format");
917 }
918 if (description[0] == 's')
919 {
920 if (*endp != ':')
921 ftdi_error_return(-11, "illegal description format");
922
923 /* rest of the description is the serial */
924 serial=endp+1;
925 }
926
927 return ftdi_usb_open_desc_index(ftdi, vendor, product, NULL, serial, index);
928 }
929 else
930 {
931 ftdi_error_return(-11, "illegal description format");
932 }
933}
934
935/**
1941414d 936 Resets the ftdi device.
a3da1d95 937
1941414d
TJ		 938 \param ftdi pointer to ftdi_context
939
940 \retval 0: all fine
941 \retval -1: FTDI reset failed
22a1b5c1 942 \retval -2: USB device unavailable
4837f98a 943*/
edb82cbf 944int ftdi_usb_reset(struct ftdi_context *ftdi)
a8f46ddc 945{
22a1b5c1
TJ		 946 if (ftdi == NULL || ftdi->usb_dev == NULL)
947 ftdi_error_return(-2, "USB device unavailable");
948
579b006f
JZ		 949 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
950 SIO_RESET_REQUEST, SIO_RESET_SIO,
951 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
22d12cda 952 ftdi_error_return(-1,"FTDI reset failed");
c3d95b87 953
545820ce 954 // Invalidate data in the readbuffer
bfcee05b
TJ		 955 ftdi->readbuffer_offset = 0;
956 ftdi->readbuffer_remaining = 0;
957
a3da1d95
GE		 958 return 0;
959}
960
1941414d 961/**
1189b11a 962 Clears the read buffer on the chip and the internal read buffer.
1941414d
TJ		 963
964 \param ftdi pointer to ftdi_context
4837f98a 965
1941414d 966 \retval 0: all fine
1189b11a 967 \retval -1: read buffer purge failed
22a1b5c1 968 \retval -2: USB device unavailable
4837f98a 969*/
1189b11a 970int ftdi_usb_purge_rx_buffer(struct ftdi_context *ftdi)
a8f46ddc 971{
22a1b5c1
TJ		 972 if (ftdi == NULL || ftdi->usb_dev == NULL)
973 ftdi_error_return(-2, "USB device unavailable");
974
579b006f
JZ		 975 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
976 SIO_RESET_REQUEST, SIO_RESET_PURGE_RX,
977 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
c3d95b87
TJ		 978 ftdi_error_return(-1, "FTDI purge of RX buffer failed");
979
545820ce 980 // Invalidate data in the readbuffer
bfcee05b
TJ		 981 ftdi->readbuffer_offset = 0;
982 ftdi->readbuffer_remaining = 0;
a60be878 983
1189b11a
TJ		 984 return 0;
985}
986
987/**
988 Clears the write buffer on the chip.
989
990 \param ftdi pointer to ftdi_context
991
992 \retval 0: all fine
993 \retval -1: write buffer purge failed
22a1b5c1 994 \retval -2: USB device unavailable
1189b11a
TJ		 995*/
996int ftdi_usb_purge_tx_buffer(struct ftdi_context *ftdi)
997{
22a1b5c1
TJ		 998 if (ftdi == NULL || ftdi->usb_dev == NULL)
999 ftdi_error_return(-2, "USB device unavailable");
1000
579b006f
JZ		 1001 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1002 SIO_RESET_REQUEST, SIO_RESET_PURGE_TX,
1003 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
1189b11a
TJ		 1004 ftdi_error_return(-1, "FTDI purge of TX buffer failed");
1005
1006 return 0;
1007}
1008
1009/**
1010 Clears the buffers on the chip and the internal read buffer.
1011
1012 \param ftdi pointer to ftdi_context
1013
1014 \retval 0: all fine
1015 \retval -1: read buffer purge failed
1016 \retval -2: write buffer purge failed
22a1b5c1 1017 \retval -3: USB device unavailable
1189b11a
TJ		 1018*/
1019int ftdi_usb_purge_buffers(struct ftdi_context *ftdi)
1020{
1021 int result;
1022
22a1b5c1
TJ		 1023 if (ftdi == NULL || ftdi->usb_dev == NULL)
1024 ftdi_error_return(-3, "USB device unavailable");
1025
1189b11a 1026 result = ftdi_usb_purge_rx_buffer(ftdi);
5a2b51cb 1027 if (result < 0)
1189b11a
TJ		 1028 return -1;
1029
1030 result = ftdi_usb_purge_tx_buffer(ftdi);
5a2b51cb 1031 if (result < 0)
1189b11a 1032 return -2;
545820ce 1033
a60be878
TJ		 1034 return 0;
1035}
a3da1d95 1036
f3f81007
TJ		 1037
1038
1941414d
TJ		 1039/**
1040 Closes the ftdi device. Call ftdi_deinit() if you're cleaning up.
1041
1042 \param ftdi pointer to ftdi_context
1043
1044 \retval 0: all fine
1045 \retval -1: usb_release failed
22a1b5c1 1046 \retval -3: ftdi context invalid
a3da1d95 1047*/
a8f46ddc
TJ		 1048int ftdi_usb_close(struct ftdi_context *ftdi)
1049{
a3da1d95
GE		 1050 int rtn = 0;
1051
22a1b5c1
TJ		 1052 if (ftdi == NULL)
1053 ftdi_error_return(-3, "ftdi context invalid");
1054
dff4fdb0 1055 if (ftdi->usb_dev != NULL)
579b006f 1056 if (libusb_release_interface(ftdi->usb_dev, ftdi->interface) < 0)
dff4fdb0 1057 rtn = -1;
98452d97 1058
579b006f 1059 ftdi_usb_close_internal (ftdi);
98452d97 1060
a3da1d95
GE		 1061 return rtn;
1062}
1063
74387f27 1064/* ftdi_to_clkbits_AM For the AM device, convert a requested baudrate
f15786e4 1065 to encoded divisor and the achievable baudrate
53ad271d 1066 Function is only used internally
b5ec1820 1067 \internal
f15786e4
UB		 1068
1069 See AN120
1070 clk/1 -> 0
1071 clk/1.5 -> 1
1072 clk/2 -> 2
1073 From /2, 0.125/ 0.25 and 0.5 steps may be taken
1074 The fractional part has frac_code encoding
53ad271d 1075*/
f15786e4
UB		 1076static int ftdi_to_clkbits_AM(int baudrate, unsigned long *encoded_divisor)
1077
a8f46ddc 1078{
f15786e4 1079 static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
53ad271d
TJ		 1080 static const char am_adjust_up[8] = {0, 0, 0, 1, 0, 3, 2, 1};
1081 static const char am_adjust_dn[8] = {0, 0, 0, 1, 0, 1, 2, 3};
53ad271d 1082 int divisor, best_divisor, best_baud, best_baud_diff;
f15786e4 1083 int i;
32e2d8b0 1084 divisor = 24000000 / baudrate;
53ad271d 1085
f15786e4
UB		 1086 // Round down to supported fraction (AM only)
1087 divisor -= am_adjust_dn[divisor & 7];
53ad271d
TJ		 1088
1089 // Try this divisor and the one above it (because division rounds down)
1090 best_divisor = 0;
1091 best_baud = 0;
1092 best_baud_diff = 0;
22d12cda
TJ		 1093 for (i = 0; i < 2; i++)
1094 {
53ad271d
TJ		 1095 int try_divisor = divisor + i;
1096 int baud_estimate;
1097 int baud_diff;
1098
1099 // Round up to supported divisor value
22d12cda
TJ		 1100 if (try_divisor <= 8)
1101 {
53ad271d
TJ		 1102 // Round up to minimum supported divisor
1103 try_divisor = 8;
22d12cda 1104 }
22d12cda
TJ		 1105 else if (divisor < 16)
1106 {
53ad271d
TJ		 1107 // AM doesn't support divisors 9 through 15 inclusive
1108 try_divisor = 16;
22d12cda
TJ		 1109 }
1110 else
1111 {
f15786e4
UB		 1112 // Round up to supported fraction (AM only)
1113 try_divisor += am_adjust_up[try_divisor & 7];
1114 if (try_divisor > 0x1FFF8)
22d12cda 1115 {
f15786e4
UB		 1116 // Round down to maximum supported divisor value (for AM)
1117 try_divisor = 0x1FFF8;
53ad271d
TJ		 1118 }
1119 }
1120 // Get estimated baud rate (to nearest integer)
1121 baud_estimate = (24000000 + (try_divisor / 2)) / try_divisor;
1122 // Get absolute difference from requested baud rate
22d12cda
TJ		 1123 if (baud_estimate < baudrate)
1124 {
53ad271d 1125 baud_diff = baudrate - baud_estimate;
22d12cda
TJ		 1126 }
1127 else
1128 {
53ad271d
TJ		 1129 baud_diff = baud_estimate - baudrate;
1130 }
22d12cda
TJ		 1131 if (i == 0 || baud_diff < best_baud_diff)
1132 {
53ad271d
TJ		 1133 // Closest to requested baud rate so far
1134 best_divisor = try_divisor;
1135 best_baud = baud_estimate;
1136 best_baud_diff = baud_diff;
22d12cda
TJ		 1137 if (baud_diff == 0)
1138 {
53ad271d
TJ		 1139 // Spot on! No point trying
1140 break;
1141 }
1142 }
1143 }
1144 // Encode the best divisor value
f15786e4 1145 *encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 7] << 14);
53ad271d 1146 // Deal with special cases for encoded value
f15786e4 1147 if (*encoded_divisor == 1)
22d12cda 1148 {
f15786e4 1149 *encoded_divisor = 0; // 3000000 baud
22d12cda 1150 }
f15786e4
UB		 1151 else if (*encoded_divisor == 0x4001)
1152 {
1153 *encoded_divisor = 1; // 2000000 baud (BM only)
1154 }
1155 return best_baud;
1156}
1157
1158/* ftdi_to_clkbits Convert a requested baudrate for a given system clock and predivisor
1159 to encoded divisor and the achievable baudrate
1160 Function is only used internally
1161 \internal
1162
1163 See AN120
1164 clk/1 -> 0
1165 clk/1.5 -> 1
1166 clk/2 -> 2
1167 From /2, 0.125 steps may be taken.
1168 The fractional part has frac_code encoding
9956d428
UB		 1169
1170 value[13:0] of value is the divisor
1171 index[9] mean 12 MHz Base(120 MHz/10) rate versus 3 MHz (48 MHz/16) else
1172
1173 H Type have all features above with
1174 {index[8],value[15:14]} is the encoded subdivisor
1175
74387f27 1176 FT232R, FT2232 and FT232BM have no option for 12 MHz and with
9956d428
UB		 1177 {index[0],value[15:14]} is the encoded subdivisor
1178
1179 AM Type chips have only four fractional subdivisors at value[15:14]
1180 for subdivisors 0, 0.5, 0.25, 0.125
f15786e4
UB		 1181*/
1182static int ftdi_to_clkbits(int baudrate, unsigned int clk, int clk_div, unsigned long *encoded_divisor)
1183{
1184 static const char frac_code[8] = {0, 3, 2, 4, 1, 5, 6, 7};
1185 int best_baud = 0;
1186 int divisor, best_divisor;
1187 if (baudrate >= clk/clk_div)
1188 {
1189 *encoded_divisor = 0;
1190 best_baud = clk/clk_div;
1191 }
1192 else if (baudrate >= clk/(clk_div + clk_div/2))
1193 {
1194 *encoded_divisor = 1;
1195 best_baud = clk/(clk_div + clk_div/2);
1196 }
1197 else if (baudrate >= clk/(2*clk_div))
1198 {
1199 *encoded_divisor = 2;
1200 best_baud = clk/(2*clk_div);
1201 }
1202 else
1203 {
1204 /* We divide by 16 to have 3 fractional bits and one bit for rounding */
1205 divisor = clk*16/clk_div / baudrate;
1206 if (divisor & 1) /* Decide if to round up or down*/
1207 best_divisor = divisor /2 +1;
1208 else
1209 best_divisor = divisor/2;
1210 if(best_divisor > 0x20000)
1211 best_divisor = 0x1ffff;
aae08071
UB		 1212 best_baud = clk*16/clk_div/best_divisor;
1213 if (best_baud & 1) /* Decide if to round up or down*/
1214 best_baud = best_baud /2 +1;
1215 else
1216 best_baud = best_baud /2;
f15786e4
UB		 1217 *encoded_divisor = (best_divisor >> 3) | (frac_code[best_divisor & 0x7] << 14);
1218 }
1219 return best_baud;
74387f27 1220}
f15786e4
UB		 1221/**
1222 ftdi_convert_baudrate returns nearest supported baud rate to that requested.
1223 Function is only used internally
1224 \internal
1225*/
1226static int ftdi_convert_baudrate(int baudrate, struct ftdi_context *ftdi,
1227 unsigned short *value, unsigned short *index)
1228{
1229 int best_baud;
1230 unsigned long encoded_divisor;
1231
1232 if (baudrate <= 0)
1233 {
1234 // Return error
1235 return -1;
1236 }
1237
1238#define H_CLK 120000000
1239#define C_CLK 48000000
6ae693b2 1240 if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H) || (ftdi->type == TYPE_232H))
f15786e4
UB		 1241 {
1242 if(baudrate*10 > H_CLK /0x3fff)
1243 {
1244 /* On H Devices, use 12 000 000 Baudrate when possible
74387f27 1245 We have a 14 bit divisor, a 1 bit divisor switch (10 or 16)
f15786e4
UB		 1246 three fractional bits and a 120 MHz clock
1247 Assume AN_120 "Sub-integer divisors between 0 and 2 are not allowed" holds for
1248 DIV/10 CLK too, so /1, /1.5 and /2 can be handled the same*/
1249 best_baud = ftdi_to_clkbits(baudrate, H_CLK, 10, &encoded_divisor);
1250 encoded_divisor |= 0x20000; /* switch on CLK/10*/
1251 }
1252 else
1253 best_baud = ftdi_to_clkbits(baudrate, C_CLK, 16, &encoded_divisor);
1254 }
1255 else if ((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C) || (ftdi->type == TYPE_R ))
1256 {
1257 best_baud = ftdi_to_clkbits(baudrate, C_CLK, 16, &encoded_divisor);
1258 }
1259 else
22d12cda 1260 {
f15786e4 1261 best_baud = ftdi_to_clkbits_AM(baudrate, &encoded_divisor);
53ad271d
TJ		 1262 }
1263 // Split into "value" and "index" values
1264 *value = (unsigned short)(encoded_divisor & 0xFFFF);
6ae693b2 1265 if (ftdi->type == TYPE_2232H || ftdi->type == TYPE_4232H || ftdi->type == TYPE_232H)
22d12cda 1266 {
0126d22e
TJ		 1267 *index = (unsigned short)(encoded_divisor >> 8);
1268 *index &= 0xFF00;
a9c57c05 1269 *index |= ftdi->index;
0126d22e
TJ		 1270 }
1271 else
1272 *index = (unsigned short)(encoded_divisor >> 16);
c3d95b87 1273
53ad271d
TJ		 1274 // Return the nearest baud rate
1275 return best_baud;
1276}
1277
1941414d 1278/**
ac6944cc
TJ		 1279 * @brief Wrapper function to export ftdi_convert_baudrate() to the unit test
1280 * Do not use, it's only for the unit test framework
1281 **/
1282int convert_baudrate_UT_export(int baudrate, struct ftdi_context *ftdi,
74387f27 1283 unsigned short *value, unsigned short *index)
ac6944cc
TJ		 1284{
1285 return ftdi_convert_baudrate(baudrate, ftdi, value, index);
1286}
1287
1288/**
9bec2387 1289 Sets the chip baud rate
1941414d
TJ		 1290
1291 \param ftdi pointer to ftdi_context
9bec2387 1292 \param baudrate baud rate to set
1941414d
TJ		 1293
1294 \retval 0: all fine
1295 \retval -1: invalid baudrate
1296 \retval -2: setting baudrate failed
22a1b5c1 1297 \retval -3: USB device unavailable
a3da1d95 1298*/
a8f46ddc
TJ		 1299int ftdi_set_baudrate(struct ftdi_context *ftdi, int baudrate)
1300{
53ad271d
TJ		 1301 unsigned short value, index;
1302 int actual_baudrate;
a3da1d95 1303
22a1b5c1
TJ		 1304 if (ftdi == NULL || ftdi->usb_dev == NULL)
1305 ftdi_error_return(-3, "USB device unavailable");
1306
22d12cda
TJ		 1307 if (ftdi->bitbang_enabled)
1308 {
a3da1d95
GE		 1309 baudrate = baudrate*4;
1310 }
1311
25707904 1312 actual_baudrate = ftdi_convert_baudrate(baudrate, ftdi, &value, &index);
c3d95b87
TJ		 1313 if (actual_baudrate <= 0)
1314 ftdi_error_return (-1, "Silly baudrate <= 0.");
a3da1d95 1315
53ad271d
TJ		 1316 // Check within tolerance (about 5%)
1317 if ((actual_baudrate * 2 < baudrate /* Catch overflows */ )
1318 || ((actual_baudrate < baudrate)
1319 ? (actual_baudrate * 21 < baudrate * 20)
c3d95b87
TJ		 1320 : (baudrate * 21 < actual_baudrate * 20)))
1321 ftdi_error_return (-1, "Unsupported baudrate. Note: bitbang baudrates are automatically multiplied by 4");
545820ce 1322
579b006f
JZ		 1323 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1324 SIO_SET_BAUDRATE_REQUEST, value,
1325 index, NULL, 0, ftdi->usb_write_timeout) < 0)
c3d95b87 1326 ftdi_error_return (-2, "Setting new baudrate failed");
a3da1d95
GE		 1327
1328 ftdi->baudrate = baudrate;
1329 return 0;
1330}
1331
1941414d 1332/**
6c32e222
TJ		 1333 Set (RS232) line characteristics.
1334 The break type can only be set via ftdi_set_line_property2()
1335 and defaults to "off".
4837f98a 1336
1941414d
TJ		 1337 \param ftdi pointer to ftdi_context
1338 \param bits Number of bits
1339 \param sbit Number of stop bits
1340 \param parity Parity mode
1341
1342 \retval 0: all fine
1343 \retval -1: Setting line property failed
2f73e59f
TJ		 1344*/
1345int ftdi_set_line_property(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
d2f10023 1346 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity)
2f73e59f 1347{
6c32e222
TJ		 1348 return ftdi_set_line_property2(ftdi, bits, sbit, parity, BREAK_OFF);
1349}
1350
1351/**
1352 Set (RS232) line characteristics
1353
1354 \param ftdi pointer to ftdi_context
1355 \param bits Number of bits
1356 \param sbit Number of stop bits
1357 \param parity Parity mode
1358 \param break_type Break type
1359
1360 \retval 0: all fine
1361 \retval -1: Setting line property failed
22a1b5c1 1362 \retval -2: USB device unavailable
6c32e222
TJ		 1363*/
1364int ftdi_set_line_property2(struct ftdi_context *ftdi, enum ftdi_bits_type bits,
22d12cda
TJ		 1365 enum ftdi_stopbits_type sbit, enum ftdi_parity_type parity,
1366 enum ftdi_break_type break_type)
6c32e222 1367{
2f73e59f
TJ		 1368 unsigned short value = bits;
1369
22a1b5c1
TJ		 1370 if (ftdi == NULL || ftdi->usb_dev == NULL)
1371 ftdi_error_return(-2, "USB device unavailable");
1372
22d12cda
TJ		 1373 switch (parity)
1374 {
1375 case NONE:
1376 value |= (0x00 << 8);
1377 break;
1378 case ODD:
1379 value |= (0x01 << 8);
1380 break;
1381 case EVEN:
1382 value |= (0x02 << 8);
1383 break;
1384 case MARK:
1385 value |= (0x03 << 8);
1386 break;
1387 case SPACE:
1388 value |= (0x04 << 8);
1389 break;
2f73e59f 1390 }
d2f10023 1391
22d12cda
TJ		 1392 switch (sbit)
1393 {
1394 case STOP_BIT_1:
1395 value |= (0x00 << 11);
1396 break;
1397 case STOP_BIT_15:
1398 value |= (0x01 << 11);
1399 break;
1400 case STOP_BIT_2:
1401 value |= (0x02 << 11);
1402 break;
2f73e59f 1403 }
d2f10023 1404
22d12cda
TJ		 1405 switch (break_type)
1406 {
1407 case BREAK_OFF:
1408 value |= (0x00 << 14);
1409 break;
1410 case BREAK_ON:
1411 value |= (0x01 << 14);
1412 break;
6c32e222
TJ		 1413 }
1414
579b006f
JZ		 1415 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
1416 SIO_SET_DATA_REQUEST, value,
1417 ftdi->index, NULL, 0, ftdi->usb_write_timeout) < 0)
2f73e59f 1418 ftdi_error_return (-1, "Setting new line property failed");
d2f10023 1419
2f73e59f
TJ		 1420 return 0;
1421}
a3da1d95 1422
1941414d
TJ		 1423/**
1424 Writes data in chunks (see ftdi_write_data_set_chunksize()) to the chip
1425
1426 \param ftdi pointer to ftdi_context
1427 \param buf Buffer with the data
1428 \param size Size of the buffer
1429
22a1b5c1 1430 \retval -666: USB device unavailable
1941414d
TJ		 1431 \retval <0: error code from usb_bulk_write()
1432 \retval >0: number of bytes written
1433*/
276750c1 1434int ftdi_write_data(struct ftdi_context *ftdi, const unsigned char *buf, int size)
a8f46ddc 1435{
a3da1d95 1436 int offset = 0;
579b006f 1437 int actual_length;
c3d95b87 1438
22a1b5c1
TJ		 1439 if (ftdi == NULL || ftdi->usb_dev == NULL)
1440 ftdi_error_return(-666, "USB device unavailable");
1441
22d12cda
TJ		 1442 while (offset < size)
1443 {
948f9ada 1444 int write_size = ftdi->writebuffer_chunksize;
a3da1d95
GE		 1445
1446 if (offset+write_size > size)
1447 write_size = size-offset;
1448
276750c1 1449 if (libusb_bulk_transfer(ftdi->usb_dev, ftdi->in_ep, (unsigned char *)buf+offset, write_size, &actual_length, ftdi->usb_write_timeout) < 0)
579b006f 1450 ftdi_error_return(-1, "usb bulk write failed");
a3da1d95 1451
579b006f 1452 offset += actual_length;
a3da1d95
GE		 1453 }
1454
579b006f 1455 return offset;
a3da1d95
GE		 1456}
1457
32e2d8b0 1458static void LIBUSB_CALL ftdi_read_data_cb(struct libusb_transfer *transfer)
22d12cda 1459{
579b006f
JZ		 1460 struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1461 struct ftdi_context *ftdi = tc->ftdi;
1462 int packet_size, actual_length, num_of_chunks, chunk_remains, i, ret;
4c9e3812 1463
b1139150 1464 packet_size = ftdi->max_packet_size;
579b006f
JZ		 1465
1466 actual_length = transfer->actual_length;
1467
1468 if (actual_length > 2)
1469 {
1470 // skip FTDI status bytes.
1471 // Maybe stored in the future to enable modem use
1472 num_of_chunks = actual_length / packet_size;
1473 chunk_remains = actual_length % packet_size;
1474 //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);
1475
1476 ftdi->readbuffer_offset += 2;
1477 actual_length -= 2;
1478
1479 if (actual_length > packet_size - 2)
1480 {
1481 for (i = 1; i < num_of_chunks; i++)
56ac0383
TJ		 1482 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1483 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1484 packet_size - 2);
579b006f
JZ		 1485 if (chunk_remains > 2)
1486 {
1487 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1488 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1489 chunk_remains-2);
1490 actual_length -= 2*num_of_chunks;
1491 }
1492 else
56ac0383 1493 actual_length -= 2*(num_of_chunks-1)+chunk_remains;
579b006f
JZ		 1494 }
1495
1496 if (actual_length > 0)
1497 {
1498 // data still fits in buf?
1499 if (tc->offset + actual_length <= tc->size)
1500 {
1501 memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, actual_length);
1502 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
1503 tc->offset += actual_length;
1504
1505 ftdi->readbuffer_offset = 0;
1506 ftdi->readbuffer_remaining = 0;
1507
1508 /* Did we read exactly the right amount of bytes? */
1509 if (tc->offset == tc->size)
1510 {
1511 //printf("read_data exact rem %d offset %d\n",
1512 //ftdi->readbuffer_remaining, offset);
1513 tc->completed = 1;
1514 return;
1515 }
1516 }
1517 else
1518 {
1519 // only copy part of the data or size <= readbuffer_chunksize
1520 int part_size = tc->size - tc->offset;
1521 memcpy (tc->buf + tc->offset, ftdi->readbuffer + ftdi->readbuffer_offset, part_size);
1522 tc->offset += part_size;
1523
1524 ftdi->readbuffer_offset += part_size;
1525 ftdi->readbuffer_remaining = actual_length - part_size;
1526
1527 /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1528 part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
1529 tc->completed = 1;
1530 return;
1531 }
1532 }
1533 }
1b1bf7e4
EH		 1534
1535 if (transfer->status == LIBUSB_TRANSFER_CANCELLED)
1536 tc->completed = LIBUSB_TRANSFER_CANCELLED;
1537 else
1538 {
1539 ret = libusb_submit_transfer (transfer);
1540 if (ret < 0)
1541 tc->completed = 1;
1542 }
579b006f
JZ		 1543}
1544
1545
32e2d8b0 1546static void LIBUSB_CALL ftdi_write_data_cb(struct libusb_transfer *transfer)
7cc9950e 1547{
579b006f
JZ		 1548 struct ftdi_transfer_control *tc = (struct ftdi_transfer_control *) transfer->user_data;
1549 struct ftdi_context *ftdi = tc->ftdi;
56ac0383 1550
90ef163e 1551 tc->offset += transfer->actual_length;
56ac0383 1552
579b006f 1553 if (tc->offset == tc->size)
22d12cda 1554 {
579b006f 1555 tc->completed = 1;
7cc9950e 1556 }
579b006f
JZ		 1557 else
1558 {
1559 int write_size = ftdi->writebuffer_chunksize;
1560 int ret;
7cc9950e 1561
579b006f
JZ		 1562 if (tc->offset + write_size > tc->size)
1563 write_size = tc->size - tc->offset;
1564
1565 transfer->length = write_size;
1566 transfer->buffer = tc->buf + tc->offset;
1b1bf7e4
EH		 1567
1568 if (transfer->status == LIBUSB_TRANSFER_CANCELLED)
1569 tc->completed = LIBUSB_TRANSFER_CANCELLED;
1570 else
1571 {
1572 ret = libusb_submit_transfer (transfer);
1573 if (ret < 0)
1574 tc->completed = 1;
1575 }
579b006f 1576 }
7cc9950e
GE		 1577}
1578
579b006f 1579
84f85aaa 1580/**
579b006f
JZ		 1581 Writes data to the chip. Does not wait for completion of the transfer
1582 nor does it make sure that the transfer was successful.
1583
249888c8 1584 Use libusb 1.0 asynchronous API.
84f85aaa
GE		 1585
1586 \param ftdi pointer to ftdi_context
579b006f
JZ		 1587 \param buf Buffer with the data
1588 \param size Size of the buffer
84f85aaa 1589
579b006f
JZ		 1590 \retval NULL: Some error happens when submit transfer
1591 \retval !NULL: Pointer to a ftdi_transfer_control
c201f80f 1592*/
579b006f
JZ		 1593
1594struct ftdi_transfer_control *ftdi_write_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
7cc9950e 1595{
579b006f 1596 struct ftdi_transfer_control *tc;
5e77e870 1597 struct libusb_transfer *transfer;
579b006f 1598 int write_size, ret;
22d12cda 1599
22a1b5c1 1600 if (ftdi == NULL || ftdi->usb_dev == NULL)
22a1b5c1 1601 return NULL;
22a1b5c1 1602
579b006f 1603 tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
5e77e870
TJ		 1604 if (!tc)
1605 return NULL;
22d12cda 1606
5e77e870
TJ		 1607 transfer = libusb_alloc_transfer(0);
1608 if (!transfer)
1609 {
1610 free(tc);
579b006f 1611 return NULL;
5e77e870 1612 }
22d12cda 1613
579b006f
JZ		 1614 tc->ftdi = ftdi;
1615 tc->completed = 0;
1616 tc->buf = buf;
1617 tc->size = size;
1618 tc->offset = 0;
7cc9950e 1619
9e44fc94 1620 if (size < (int)ftdi->writebuffer_chunksize)
56ac0383 1621 write_size = size;
579b006f 1622 else
56ac0383 1623 write_size = ftdi->writebuffer_chunksize;
22d12cda 1624
90ef163e
YSL		 1625 libusb_fill_bulk_transfer(transfer, ftdi->usb_dev, ftdi->in_ep, buf,
1626 write_size, ftdi_write_data_cb, tc,
1627 ftdi->usb_write_timeout);
579b006f 1628 transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
7cc9950e 1629
579b006f
JZ		 1630 ret = libusb_submit_transfer(transfer);
1631 if (ret < 0)
1632 {
1633 libusb_free_transfer(transfer);
5e77e870 1634 free(tc);
579b006f 1635 return NULL;
7cc9950e 1636 }
579b006f
JZ		 1637 tc->transfer = transfer;
1638
1639 return tc;
7cc9950e
GE		 1640}
1641
1642/**
579b006f
JZ		 1643 Reads data from the chip. Does not wait for completion of the transfer
1644 nor does it make sure that the transfer was successful.
1645
249888c8 1646 Use libusb 1.0 asynchronous API.
7cc9950e
GE		 1647
1648 \param ftdi pointer to ftdi_context
579b006f
JZ		 1649 \param buf Buffer with the data
1650 \param size Size of the buffer
4c9e3812 1651
579b006f
JZ		 1652 \retval NULL: Some error happens when submit transfer
1653 \retval !NULL: Pointer to a ftdi_transfer_control
4c9e3812 1654*/
579b006f
JZ		 1655
1656struct ftdi_transfer_control *ftdi_read_data_submit(struct ftdi_context *ftdi, unsigned char *buf, int size)
4c9e3812 1657{
579b006f
JZ		 1658 struct ftdi_transfer_control *tc;
1659 struct libusb_transfer *transfer;
1660 int ret;
22d12cda 1661
22a1b5c1
TJ		 1662 if (ftdi == NULL || ftdi->usb_dev == NULL)
1663 return NULL;
1664
579b006f
JZ		 1665 tc = (struct ftdi_transfer_control *) malloc (sizeof (*tc));
1666 if (!tc)
1667 return NULL;
1668
1669 tc->ftdi = ftdi;
1670 tc->buf = buf;
1671 tc->size = size;
1672
9e44fc94 1673 if (size <= (int)ftdi->readbuffer_remaining)
7cc9950e 1674 {
579b006f 1675 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
7cc9950e 1676
579b006f
JZ		 1677 // Fix offsets
1678 ftdi->readbuffer_remaining -= size;
1679 ftdi->readbuffer_offset += size;
7cc9950e 1680
579b006f 1681 /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
22d12cda 1682
579b006f
JZ		 1683 tc->completed = 1;
1684 tc->offset = size;
1685 tc->transfer = NULL;
1686 return tc;
1687 }
4c9e3812 1688
579b006f
JZ		 1689 tc->completed = 0;
1690 if (ftdi->readbuffer_remaining != 0)
1691 {
1692 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
22d12cda 1693
579b006f
JZ		 1694 tc->offset = ftdi->readbuffer_remaining;
1695 }
1696 else
1697 tc->offset = 0;
22d12cda 1698
579b006f
JZ		 1699 transfer = libusb_alloc_transfer(0);
1700 if (!transfer)
1701 {
1702 free (tc);
1703 return NULL;
1704 }
22d12cda 1705
579b006f
JZ		 1706 ftdi->readbuffer_remaining = 0;
1707 ftdi->readbuffer_offset = 0;
1708
1709 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);
1710 transfer->type = LIBUSB_TRANSFER_TYPE_BULK;
1711
1712 ret = libusb_submit_transfer(transfer);
1713 if (ret < 0)
1714 {
1715 libusb_free_transfer(transfer);
1716 free (tc);
1717 return NULL;
22d12cda 1718 }
579b006f
JZ		 1719 tc->transfer = transfer;
1720
1721 return tc;
4c9e3812
GE		 1722}
1723
1724/**
579b006f 1725 Wait for completion of the transfer.
4c9e3812 1726
249888c8 1727 Use libusb 1.0 asynchronous API.
4c9e3812 1728
579b006f 1729 \param tc pointer to ftdi_transfer_control
4c9e3812 1730
579b006f
JZ		 1731 \retval < 0: Some error happens
1732 \retval >= 0: Data size transferred
4c9e3812 1733*/
579b006f
JZ		 1734
1735int ftdi_transfer_data_done(struct ftdi_transfer_control *tc)
4c9e3812
GE		 1736{
1737 int ret;
1b1bf7e4 1738 struct timeval to = { 0, 0 };
579b006f 1739 while (!tc->completed)
22d12cda 1740 {
1b1bf7e4
EH		 1741 ret = libusb_handle_events_timeout_completed(tc->ftdi->usb_ctx,
1742 &to, &tc->completed);
4c9e3812 1743 if (ret < 0)
579b006f
JZ		 1744 {
1745 if (ret == LIBUSB_ERROR_INTERRUPTED)
1746 continue;
1747 libusb_cancel_transfer(tc->transfer);
1748 while (!tc->completed)
1b1bf7e4
EH		 1749 if (libusb_handle_events_timeout_completed(tc->ftdi->usb_ctx,
1750 &to, &tc->completed) < 0)
579b006f
JZ		 1751 break;
1752 libusb_free_transfer(tc->transfer);
1753 free (tc);
579b006f
JZ		 1754 return ret;
1755 }
4c9e3812
GE		 1756 }
1757
90ef163e
YSL		 1758 ret = tc->offset;
1759 /**
1760 * tc->transfer could be NULL if "(size <= ftdi->readbuffer_remaining)"
ef15fab5 1761 * at ftdi_read_data_submit(). Therefore, we need to check it here.
90ef163e 1762 **/
ef15fab5
TJ		 1763 if (tc->transfer)
1764 {
1765 if (tc->transfer->status != LIBUSB_TRANSFER_COMPLETED)
1766 ret = -1;
1767 libusb_free_transfer(tc->transfer);
90ef163e 1768 }
579b006f
JZ		 1769 free(tc);
1770 return ret;
4c9e3812 1771}
579b006f 1772
1941414d 1773/**
1b1bf7e4
EH		 1774 Cancel transfer and wait for completion.
1775
1776 Use libusb 1.0 asynchronous API.
1777
1778 \param tc pointer to ftdi_transfer_control
1779 \param to pointer to timeout value or NULL for infinite
1780*/
1781
1782void ftdi_transfer_data_cancel(struct ftdi_transfer_control *tc,
1783 struct timeval * to)
1784{
1785 struct timeval tv = { 0, 0 };
1786
1787 if (!tc->completed && tc->transfer != NULL)
1788 {
1789 if (to == NULL)
1790 to = &tv;
1791
1792 libusb_cancel_transfer(tc->transfer);
1793 while (!tc->completed)
1794 {
1795 if (libusb_handle_events_timeout_completed(tc->ftdi->usb_ctx, to, &tc->completed) < 0)
1796 break;
1797 }
1798 }
1799
1800 if (tc->transfer)
1801 libusb_free_transfer(tc->transfer);
1802
1803 free (tc);
1804}
1805
1806/**
1941414d
TJ		 1807 Configure write buffer chunk size.
1808 Default is 4096.
1809
1810 \param ftdi pointer to ftdi_context
1811 \param chunksize Chunk size
a3da1d95 1812
1941414d 1813 \retval 0: all fine
22a1b5c1 1814 \retval -1: ftdi context invalid
1941414d 1815*/
a8f46ddc
TJ		 1816int ftdi_write_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1817{
22a1b5c1
TJ		 1818 if (ftdi == NULL)
1819 ftdi_error_return(-1, "ftdi context invalid");
1820
948f9ada
TJ		 1821 ftdi->writebuffer_chunksize = chunksize;
1822 return 0;
1823}
1824
1941414d
TJ		 1825/**
1826 Get write buffer chunk size.
1827
1828 \param ftdi pointer to ftdi_context
1829 \param chunksize Pointer to store chunk size in
948f9ada 1830
1941414d 1831 \retval 0: all fine
22a1b5c1 1832 \retval -1: ftdi context invalid
1941414d 1833*/
a8f46ddc
TJ		 1834int ftdi_write_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
1835{
22a1b5c1
TJ		 1836 if (ftdi == NULL)
1837 ftdi_error_return(-1, "ftdi context invalid");
1838
948f9ada
TJ		 1839 *chunksize = ftdi->writebuffer_chunksize;
1840 return 0;
1841}
cbabb7d3 1842
1941414d
TJ		 1843/**
1844 Reads data in chunks (see ftdi_read_data_set_chunksize()) from the chip.
1845
1846 Automatically strips the two modem status bytes transfered during every read.
948f9ada 1847
1941414d
TJ		 1848 \param ftdi pointer to ftdi_context
1849 \param buf Buffer to store data in
1850 \param size Size of the buffer
1851
22a1b5c1 1852 \retval -666: USB device unavailable
579b006f 1853 \retval <0: error code from libusb_bulk_transfer()
d77b0e94 1854 \retval 0: no data was available
1941414d
TJ		 1855 \retval >0: number of bytes read
1856
1941414d 1857*/
a8f46ddc
TJ		 1858int ftdi_read_data(struct ftdi_context *ftdi, unsigned char *buf, int size)
1859{
579b006f 1860 int offset = 0, ret, i, num_of_chunks, chunk_remains;
e2f12a4f 1861 int packet_size = ftdi->max_packet_size;
579b006f 1862 int actual_length = 1;
f2f00cb5 1863
22a1b5c1
TJ		 1864 if (ftdi == NULL || ftdi->usb_dev == NULL)
1865 ftdi_error_return(-666, "USB device unavailable");
1866
e2f12a4f
TJ		 1867 // Packet size sanity check (avoid division by zero)
1868 if (packet_size == 0)
1869 ftdi_error_return(-1, "max_packet_size is bogus (zero)");
d9f0cce7 1870
948f9ada 1871 // everything we want is still in the readbuffer?
9e44fc94 1872 if (size <= (int)ftdi->readbuffer_remaining)
22d12cda 1873 {
d9f0cce7
TJ		 1874 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, size);
1875
1876 // Fix offsets
1877 ftdi->readbuffer_remaining -= size;
1878 ftdi->readbuffer_offset += size;
1879
545820ce 1880 /* printf("Returning bytes from buffer: %d - remaining: %d\n", size, ftdi->readbuffer_remaining); */
d9f0cce7
TJ		 1881
1882 return size;
979a145c 1883 }
948f9ada 1884 // something still in the readbuffer, but not enough to satisfy 'size'?
22d12cda
TJ		 1885 if (ftdi->readbuffer_remaining != 0)
1886 {
d9f0cce7 1887 memcpy (buf, ftdi->readbuffer+ftdi->readbuffer_offset, ftdi->readbuffer_remaining);
979a145c 1888
d9f0cce7
TJ		 1889 // Fix offset
1890 offset += ftdi->readbuffer_remaining;
948f9ada 1891 }
948f9ada 1892 // do the actual USB read
579b006f 1893 while (offset < size && actual_length > 0)
22d12cda 1894 {
d9f0cce7
TJ		 1895 ftdi->readbuffer_remaining = 0;
1896 ftdi->readbuffer_offset = 0;
98452d97 1897 /* returns how much received */
579b006f 1898 ret = libusb_bulk_transfer (ftdi->usb_dev, ftdi->out_ep, ftdi->readbuffer, ftdi->readbuffer_chunksize, &actual_length, ftdi->usb_read_timeout);
c3d95b87
TJ		 1899 if (ret < 0)
1900 ftdi_error_return(ret, "usb bulk read failed");
98452d97 1901
579b006f 1902 if (actual_length > 2)
22d12cda 1903 {
d9f0cce7
TJ		 1904 // skip FTDI status bytes.
1905 // Maybe stored in the future to enable modem use
579b006f
JZ		 1906 num_of_chunks = actual_length / packet_size;
1907 chunk_remains = actual_length % packet_size;
1908 //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 1909
d9f0cce7 1910 ftdi->readbuffer_offset += 2;
579b006f 1911 actual_length -= 2;
1c733d33 1912
579b006f 1913 if (actual_length > packet_size - 2)
22d12cda 1914 {
1c733d33 1915 for (i = 1; i < num_of_chunks; i++)
f2f00cb5
DC		 1916 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1917 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1918 packet_size - 2);
22d12cda
TJ		 1919 if (chunk_remains > 2)
1920 {
f2f00cb5
DC		 1921 memmove (ftdi->readbuffer+ftdi->readbuffer_offset+(packet_size - 2)*i,
1922 ftdi->readbuffer+ftdi->readbuffer_offset+packet_size*i,
1c733d33 1923 chunk_remains-2);
579b006f 1924 actual_length -= 2*num_of_chunks;
22d12cda
TJ		 1925 }
1926 else
579b006f 1927 actual_length -= 2*(num_of_chunks-1)+chunk_remains;
1c733d33 1928 }
22d12cda 1929 }
579b006f 1930 else if (actual_length <= 2)
22d12cda 1931 {
d9f0cce7
TJ		 1932 // no more data to read?
1933 return offset;
1934 }
579b006f 1935 if (actual_length > 0)
22d12cda 1936 {
d9f0cce7 1937 // data still fits in buf?
579b006f 1938 if (offset+actual_length <= size)
22d12cda 1939 {
579b006f 1940 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, actual_length);
545820ce 1941 //printf("buf[0] = %X, buf[1] = %X\n", buf[0], buf[1]);
579b006f 1942 offset += actual_length;
d9f0cce7 1943
53ad271d 1944 /* Did we read exactly the right amount of bytes? */
d9f0cce7 1945 if (offset == size)
c4446c36
TJ		 1946 //printf("read_data exact rem %d offset %d\n",
1947 //ftdi->readbuffer_remaining, offset);
d9f0cce7 1948 return offset;
22d12cda
TJ		 1949 }
1950 else
1951 {
d9f0cce7
TJ		 1952 // only copy part of the data or size <= readbuffer_chunksize
1953 int part_size = size-offset;
1954 memcpy (buf+offset, ftdi->readbuffer+ftdi->readbuffer_offset, part_size);
98452d97 1955
d9f0cce7 1956 ftdi->readbuffer_offset += part_size;
579b006f 1957 ftdi->readbuffer_remaining = actual_length-part_size;
d9f0cce7
TJ		 1958 offset += part_size;
1959
579b006f
JZ		 1960 /* printf("Returning part: %d - size: %d - offset: %d - actual_length: %d - remaining: %d\n",
1961 part_size, size, offset, actual_length, ftdi->readbuffer_remaining); */
d9f0cce7
TJ		 1962
1963 return offset;
1964 }
1965 }
cbabb7d3 1966 }
948f9ada 1967 // never reached
29c4af7f 1968 return -127;
a3da1d95
GE		 1969}
1970
1941414d
TJ		 1971/**
1972 Configure read buffer chunk size.
1973 Default is 4096.
1974
1975 Automatically reallocates the buffer.
a3da1d95 1976
1941414d
TJ		 1977 \param ftdi pointer to ftdi_context
1978 \param chunksize Chunk size
1979
1980 \retval 0: all fine
22a1b5c1 1981 \retval -1: ftdi context invalid
1941414d 1982*/
a8f46ddc
TJ		 1983int ftdi_read_data_set_chunksize(struct ftdi_context *ftdi, unsigned int chunksize)
1984{
29c4af7f
TJ		 1985 unsigned char *new_buf;
1986
22a1b5c1
TJ		 1987 if (ftdi == NULL)
1988 ftdi_error_return(-1, "ftdi context invalid");
1989
948f9ada
TJ		 1990 // Invalidate all remaining data
1991 ftdi->readbuffer_offset = 0;
1992 ftdi->readbuffer_remaining = 0;
8de6eea4
JZ		 1993#ifdef __linux__
1994 /* We can't set readbuffer_chunksize larger than MAX_BULK_BUFFER_LENGTH,
1995 which is defined in libusb-1.0. Otherwise, each USB read request will
2e685a1f 1996 be divided into multiple URBs. This will cause issues on Linux kernel
8de6eea4
JZ		 1997 older than 2.6.32. */
1998 if (chunksize > 16384)
1999 chunksize = 16384;
2000#endif
948f9ada 2001
c3d95b87
TJ		 2002 if ((new_buf = (unsigned char *)realloc(ftdi->readbuffer, chunksize)) == NULL)
2003 ftdi_error_return(-1, "out of memory for readbuffer");
d9f0cce7 2004
948f9ada
TJ		 2005 ftdi->readbuffer = new_buf;
2006 ftdi->readbuffer_chunksize = chunksize;
2007
2008 return 0;
2009}
2010
1941414d
TJ		 2011/**
2012 Get read buffer chunk size.
948f9ada 2013
1941414d
TJ		 2014 \param ftdi pointer to ftdi_context
2015 \param chunksize Pointer to store chunk size in
2016
2017 \retval 0: all fine
22a1b5c1 2018 \retval -1: FTDI context invalid
1941414d 2019*/
a8f46ddc
TJ		 2020int ftdi_read_data_get_chunksize(struct ftdi_context *ftdi, unsigned int *chunksize)
2021{
22a1b5c1
TJ		 2022 if (ftdi == NULL)
2023 ftdi_error_return(-1, "FTDI context invalid");
2024
948f9ada
TJ		 2025 *chunksize = ftdi->readbuffer_chunksize;
2026 return 0;
2027}
2028
1941414d 2029/**
2d790e37 2030 Enable/disable bitbang modes.
1941414d
TJ		 2031
2032 \param ftdi pointer to ftdi_context
2033 \param bitmask Bitmask to configure lines.
2034 HIGH/ON value configures a line as output.
2d790e37 2035 \param mode Bitbang mode: use the values defined in \ref ftdi_mpsse_mode
1941414d
TJ		 2036
2037 \retval 0: all fine
2038 \retval -1: can't enable bitbang mode
22a1b5c1 2039 \retval -2: USB device unavailable
1941414d 2040*/
2d790e37 2041int ftdi_set_bitmode(struct ftdi_context *ftdi, unsigned char bitmask, unsigned char mode)
a8f46ddc 2042{
a3da1d95
GE		 2043 unsigned short usb_val;
2044
22a1b5c1
TJ		 2045 if (ftdi == NULL || ftdi->usb_dev == NULL)
2046 ftdi_error_return(-2, "USB device unavailable");
2047
d9f0cce7 2048 usb_val = bitmask; // low byte: bitmask
2d790e37
TJ		 2049 usb_val |= (mode << 8);
2050 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)
2051 ftdi_error_return(-1, "unable to configure bitbang mode. Perhaps not a BM/2232C type chip?");
c3d95b87 2052
2d790e37
TJ		 2053 ftdi->bitbang_mode = mode;
2054 ftdi->bitbang_enabled = (mode == BITMODE_RESET) ? 0 : 1;
a3da1d95
GE		 2055 return 0;
2056}
2057
1941414d
TJ		 2058/**
2059 Disable bitbang mode.
a3da1d95 2060
1941414d
TJ		 2061 \param ftdi pointer to ftdi_context
2062
2063 \retval 0: all fine
2064 \retval -1: can't disable bitbang mode
22a1b5c1 2065 \retval -2: USB device unavailable
1941414d 2066*/
a8f46ddc
TJ		 2067int ftdi_disable_bitbang(struct ftdi_context *ftdi)
2068{
22a1b5c1
TJ		 2069 if (ftdi == NULL || ftdi->usb_dev == NULL)
2070 ftdi_error_return(-2, "USB device unavailable");
2071
579b006f 2072 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 2073 ftdi_error_return(-1, "unable to leave bitbang mode. Perhaps not a BM type chip?");
a3da1d95
GE		 2074
2075 ftdi->bitbang_enabled = 0;
2076 return 0;
2077}
2078
c4446c36 2079
1941414d 2080/**
418aaa72 2081 Directly read pin state, circumventing the read buffer. Useful for bitbang mode.
1941414d
TJ		 2082
2083 \param ftdi pointer to ftdi_context
2084 \param pins Pointer to store pins into
2085
2086 \retval 0: all fine
2087 \retval -1: read pins failed
22a1b5c1 2088 \retval -2: USB device unavailable
1941414d 2089*/
a8f46ddc
TJ		 2090int ftdi_read_pins(struct ftdi_context *ftdi, unsigned char *pins)
2091{
22a1b5c1
TJ		 2092 if (ftdi == NULL || ftdi->usb_dev == NULL)
2093 ftdi_error_return(-2, "USB device unavailable");
2094
579b006f 2095 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 2096 ftdi_error_return(-1, "read pins failed");
a3da1d95 2097
a3da1d95
GE		 2098 return 0;
2099}
2100
1941414d
TJ		 2101/**
2102 Set latency timer
2103
2104 The FTDI chip keeps data in the internal buffer for a specific
2105 amount of time if the buffer is not full yet to decrease
2106 load on the usb bus.
a3da1d95 2107
1941414d
TJ		 2108 \param ftdi pointer to ftdi_context
2109 \param latency Value between 1 and 255
2110
2111 \retval 0: all fine
2112 \retval -1: latency out of range
2113 \retval -2: unable to set latency timer
22a1b5c1 2114 \retval -3: USB device unavailable
1941414d 2115*/
a8f46ddc
TJ		 2116int ftdi_set_latency_timer(struct ftdi_context *ftdi, unsigned char latency)
2117{
a3da1d95
GE		 2118 unsigned short usb_val;
2119
c3d95b87
TJ		 2120 if (latency < 1)
2121 ftdi_error_return(-1, "latency out of range. Only valid for 1-255");
a3da1d95 2122
22a1b5c1
TJ		 2123 if (ftdi == NULL || ftdi->usb_dev == NULL)
2124 ftdi_error_return(-3, "USB device unavailable");
2125
d79d2e68 2126 usb_val = latency;
579b006f 2127 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		 2128 ftdi_error_return(-2, "unable to set latency timer");
2129
a3da1d95
GE		 2130 return 0;
2131}
2132
1941414d
TJ		 2133/**
2134 Get latency timer
a3da1d95 2135
1941414d
TJ		 2136 \param ftdi pointer to ftdi_context
2137 \param latency Pointer to store latency value in
2138
2139 \retval 0: all fine
2140 \retval -1: unable to get latency timer
22a1b5c1 2141 \retval -2: USB device unavailable
1941414d 2142*/
a8f46ddc
TJ		 2143int ftdi_get_latency_timer(struct ftdi_context *ftdi, unsigned char *latency)
2144{
a3da1d95 2145 unsigned short usb_val;
22a1b5c1
TJ		 2146
2147 if (ftdi == NULL || ftdi->usb_dev == NULL)
2148 ftdi_error_return(-2, "USB device unavailable");
2149
579b006f 2150 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 2151 ftdi_error_return(-1, "reading latency timer failed");
a3da1d95
GE		 2152
2153 *latency = (unsigned char)usb_val;
2154 return 0;
2155}
2156
1941414d 2157/**
1189b11a
TJ		 2158 Poll modem status information
2159
2160 This function allows the retrieve the two status bytes of the device.
2161 The device sends these bytes also as a header for each read access
2162 where they are discarded by ftdi_read_data(). The chip generates
2163 the two stripped status bytes in the absence of data every 40 ms.
2164
2165 Layout of the first byte:
2166 - B0..B3 - must be 0
2167 - B4 Clear to send (CTS)
2168 0 = inactive
2169 1 = active
2170 - B5 Data set ready (DTS)
2171 0 = inactive
2172 1 = active
2173 - B6 Ring indicator (RI)
2174 0 = inactive
2175 1 = active
2176 - B7 Receive line signal detect (RLSD)
2177 0 = inactive
2178 1 = active
2179
2180 Layout of the second byte:
2181 - B0 Data ready (DR)
2182 - B1 Overrun error (OE)
2183 - B2 Parity error (PE)
2184 - B3 Framing error (FE)
2185 - B4 Break interrupt (BI)
2186 - B5 Transmitter holding register (THRE)
2187 - B6 Transmitter empty (TEMT)
2188 - B7 Error in RCVR FIFO
2189
2190 \param ftdi pointer to ftdi_context
2191 \param status Pointer to store status information in. Must be two bytes.
2192
2193 \retval 0: all fine
2194 \retval -1: unable to retrieve status information
22a1b5c1 2195 \retval -2: USB device unavailable
1189b11a
TJ		 2196*/
2197int ftdi_poll_modem_status(struct ftdi_context *ftdi, unsigned short *status)
2198{
2199 char usb_val[2];
2200
22a1b5c1
TJ		 2201 if (ftdi == NULL || ftdi->usb_dev == NULL)
2202 ftdi_error_return(-2, "USB device unavailable");
2203
579b006f 2204 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		 2205 ftdi_error_return(-1, "getting modem status failed");
2206
dc09eaa8 2207 *status = (usb_val[1] << 8) | (usb_val[0] & 0xFF);
1189b11a
TJ		 2208
2209 return 0;
2210}
2211
a7fb8440
TJ		 2212/**
2213 Set flowcontrol for ftdi chip
2214
2215 \param ftdi pointer to ftdi_context
22d12cda
TJ		 2216 \param flowctrl flow control to use. should be
2217 SIO_DISABLE_FLOW_CTRL, SIO_RTS_CTS_HS, SIO_DTR_DSR_HS or SIO_XON_XOFF_HS
a7fb8440
TJ		 2218
2219 \retval 0: all fine
2220 \retval -1: set flow control failed
22a1b5c1 2221 \retval -2: USB device unavailable
a7fb8440
TJ		 2222*/
2223int ftdi_setflowctrl(struct ftdi_context *ftdi, int flowctrl)
2224{
22a1b5c1
TJ		 2225 if (ftdi == NULL || ftdi->usb_dev == NULL)
2226 ftdi_error_return(-2, "USB device unavailable");
2227
579b006f
JZ		 2228 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2229 SIO_SET_FLOW_CTRL_REQUEST, 0, (flowctrl | ftdi->index),
2230 NULL, 0, ftdi->usb_write_timeout) < 0)
a7fb8440
TJ		 2231 ftdi_error_return(-1, "set flow control failed");
2232
2233 return 0;
2234}
2235
2236/**
2237 Set dtr line
2238
2239 \param ftdi pointer to ftdi_context
2240 \param state state to set line to (1 or 0)
2241
2242 \retval 0: all fine
2243 \retval -1: set dtr failed
22a1b5c1 2244 \retval -2: USB device unavailable
a7fb8440
TJ		 2245*/
2246int ftdi_setdtr(struct ftdi_context *ftdi, int state)
2247{
2248 unsigned short usb_val;
2249
22a1b5c1
TJ		 2250 if (ftdi == NULL || ftdi->usb_dev == NULL)
2251 ftdi_error_return(-2, "USB device unavailable");
2252
a7fb8440
TJ		 2253 if (state)
2254 usb_val = SIO_SET_DTR_HIGH;
2255 else
2256 usb_val = SIO_SET_DTR_LOW;
2257
579b006f
JZ		 2258 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2259 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2260 NULL, 0, ftdi->usb_write_timeout) < 0)
a7fb8440
TJ		 2261 ftdi_error_return(-1, "set dtr failed");
2262
2263 return 0;
2264}
2265
2266/**
2267 Set rts line
2268
2269 \param ftdi pointer to ftdi_context
2270 \param state state to set line to (1 or 0)
2271
2272 \retval 0: all fine
22a1b5c1
TJ		 2273 \retval -1: set rts failed
2274 \retval -2: USB device unavailable
a7fb8440
TJ		 2275*/
2276int ftdi_setrts(struct ftdi_context *ftdi, int state)
2277{
2278 unsigned short usb_val;
2279
22a1b5c1
TJ		 2280 if (ftdi == NULL || ftdi->usb_dev == NULL)
2281 ftdi_error_return(-2, "USB device unavailable");
2282
a7fb8440
TJ		 2283 if (state)
2284 usb_val = SIO_SET_RTS_HIGH;
2285 else
2286 usb_val = SIO_SET_RTS_LOW;
2287
579b006f
JZ		 2288 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2289 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2290 NULL, 0, ftdi->usb_write_timeout) < 0)
a7fb8440
TJ		 2291 ftdi_error_return(-1, "set of rts failed");
2292
2293 return 0;
2294}
2295
1189b11a 2296/**
22a1b5c1 2297 Set dtr and rts line in one pass
9ecfef2a 2298
22a1b5c1
TJ		 2299 \param ftdi pointer to ftdi_context
2300 \param dtr DTR state to set line to (1 or 0)
2301 \param rts RTS state to set line to (1 or 0)
9ecfef2a 2302
22a1b5c1
TJ		 2303 \retval 0: all fine
2304 \retval -1: set dtr/rts failed
2305 \retval -2: USB device unavailable
9ecfef2a
TJ		 2306 */
2307int ftdi_setdtr_rts(struct ftdi_context *ftdi, int dtr, int rts)
2308{
2309 unsigned short usb_val;
2310
22a1b5c1
TJ		 2311 if (ftdi == NULL || ftdi->usb_dev == NULL)
2312 ftdi_error_return(-2, "USB device unavailable");
2313
9ecfef2a 2314 if (dtr)
22d12cda 2315 usb_val = SIO_SET_DTR_HIGH;
9ecfef2a 2316 else
22d12cda 2317 usb_val = SIO_SET_DTR_LOW;
9ecfef2a
TJ		 2318
2319 if (rts)
22d12cda 2320 usb_val |= SIO_SET_RTS_HIGH;
9ecfef2a 2321 else
22d12cda 2322 usb_val |= SIO_SET_RTS_LOW;
9ecfef2a 2323
579b006f
JZ		 2324 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
2325 SIO_SET_MODEM_CTRL_REQUEST, usb_val, ftdi->index,
2326 NULL, 0, ftdi->usb_write_timeout) < 0)
22d12cda 2327 ftdi_error_return(-1, "set of rts/dtr failed");
9ecfef2a
TJ		 2328
2329 return 0;
2330}
2331
2332/**
1189b11a
TJ		 2333 Set the special event character
2334
2335 \param ftdi pointer to ftdi_context
2336 \param eventch Event character
2337 \param enable 0 to disable the event character, non-zero otherwise
2338
2339 \retval 0: all fine
2340 \retval -1: unable to set event character
22a1b5c1 2341 \retval -2: USB device unavailable
1189b11a
TJ		 2342*/
2343int ftdi_set_event_char(struct ftdi_context *ftdi,
22d12cda 2344 unsigned char eventch, unsigned char enable)
1189b11a
TJ		 2345{
2346 unsigned short usb_val;
2347
22a1b5c1
TJ		 2348 if (ftdi == NULL || ftdi->usb_dev == NULL)
2349 ftdi_error_return(-2, "USB device unavailable");
2350
1189b11a
TJ		 2351 usb_val = eventch;
2352 if (enable)
2353 usb_val |= 1 << 8;
2354
579b006f 2355 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		 2356 ftdi_error_return(-1, "setting event character failed");
2357
2358 return 0;
2359}
2360
2361/**
2362 Set error character
2363
2364 \param ftdi pointer to ftdi_context
2365 \param errorch Error character
2366 \param enable 0 to disable the error character, non-zero otherwise
2367
2368 \retval 0: all fine
2369 \retval -1: unable to set error character
22a1b5c1 2370 \retval -2: USB device unavailable
1189b11a
TJ		 2371*/
2372int ftdi_set_error_char(struct ftdi_context *ftdi,
22d12cda 2373 unsigned char errorch, unsigned char enable)
1189b11a
TJ		 2374{
2375 unsigned short usb_val;
2376
22a1b5c1
TJ		 2377 if (ftdi == NULL || ftdi->usb_dev == NULL)
2378 ftdi_error_return(-2, "USB device unavailable");
2379
1189b11a
TJ		 2380 usb_val = errorch;
2381 if (enable)
2382 usb_val |= 1 << 8;
2383
579b006f 2384 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		 2385 ftdi_error_return(-1, "setting error character failed");
2386
2387 return 0;
2388}
2389
2390/**
44f41f11 2391 Init eeprom with default values for the connected device
a35aa9bd 2392 \param ftdi pointer to ftdi_context
f14f84d3
UB		 2393 \param manufacturer String to use as Manufacturer
2394 \param product String to use as Product description
2395 \param serial String to use as Serial number description
4e74064b 2396
f14f84d3
UB		 2397 \retval 0: all fine
2398 \retval -1: No struct ftdi_context
2399 \retval -2: No struct ftdi_eeprom
44f41f11 2400 \retval -3: No connected device or device not yet opened
1941414d 2401*/
f14f84d3 2402int ftdi_eeprom_initdefaults(struct ftdi_context *ftdi, char * manufacturer,
56ac0383 2403 char * product, char * serial)
a8f46ddc 2404{
c0a96aed 2405 struct ftdi_eeprom *eeprom;
f505134f 2406
c0a96aed 2407 if (ftdi == NULL)
f14f84d3 2408 ftdi_error_return(-1, "No struct ftdi_context");
c0a96aed
UB		 2409
2410 if (ftdi->eeprom == NULL)
56ac0383 2411 ftdi_error_return(-2,"No struct ftdi_eeprom");
22a1b5c1 2412
c0a96aed 2413 eeprom = ftdi->eeprom;
a02587d5 2414 memset(eeprom, 0, sizeof(struct ftdi_eeprom));
c0a96aed 2415
44f41f11
UB		 2416 if (ftdi->usb_dev == NULL)
2417 ftdi_error_return(-3, "No connected device or device not yet opened");
2418
f396dbad 2419 eeprom->vendor_id = 0x0403;
d4b5af27 2420 eeprom->use_serial = 1;
56ac0383
TJ		 2421 if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM) ||
2422 (ftdi->type == TYPE_R))
a02587d5 2423 eeprom->product_id = 0x6001;
c7e4c09e
UB		 2424 else if (ftdi->type == TYPE_4232H)
2425 eeprom->product_id = 0x6011;
2426 else if (ftdi->type == TYPE_232H)
2427 eeprom->product_id = 0x6014;
2f80efc2
NP		 2428 else if (ftdi->type == TYPE_230X)
2429 eeprom->product_id = 0x6015;
a02587d5
UB		 2430 else
2431 eeprom->product_id = 0x6010;
2f80efc2 2432
b1859923
UB		 2433 if (ftdi->type == TYPE_AM)
2434 eeprom->usb_version = 0x0101;
2435 else
2436 eeprom->usb_version = 0x0200;
a886436a 2437 eeprom->max_power = 100;
d9f0cce7 2438
74e8e79d
UB		 2439 if (eeprom->manufacturer)
2440 free (eeprom->manufacturer);
b8aa7b35 2441 eeprom->manufacturer = NULL;
74e8e79d
UB		 2442 if (manufacturer)
2443 {
2444 eeprom->manufacturer = malloc(strlen(manufacturer)+1);
2445 if (eeprom->manufacturer)
2446 strcpy(eeprom->manufacturer, manufacturer);
2447 }
2448
2449 if (eeprom->product)
2450 free (eeprom->product);
b8aa7b35 2451 eeprom->product = NULL;
10771971 2452 if(product)
74e8e79d
UB		 2453 {
2454 eeprom->product = malloc(strlen(product)+1);
2455 if (eeprom->product)
2456 strcpy(eeprom->product, product);
2457 }
6a6fcd89
UB		 2458 else
2459 {
2460 const char* default_product;
2461 switch(ftdi->type)
2462 {
74387f27
TJ		 2463 case TYPE_AM: default_product = "AM"; break;
2464 case TYPE_BM: default_product = "BM"; break;
2465 case TYPE_2232C: default_product = "Dual RS232"; break;
2466 case TYPE_R: default_product = "FT232R USB UART"; break;
2467 case TYPE_2232H: default_product = "Dual RS232-HS"; break;
2468 case TYPE_4232H: default_product = "FT4232H"; break;
2469 case TYPE_232H: default_product = "Single-RS232-HS"; break;
2470 case TYPE_230X: default_product = "FT230X Basic UART"; break;
2471 default:
2472 ftdi_error_return(-3, "Unknown chip type");
6a6fcd89
UB		 2473 }
2474 eeprom->product = malloc(strlen(default_product) +1);
2475 if (eeprom->product)
2476 strcpy(eeprom->product, default_product);
2477 }
74e8e79d
UB		 2478
2479 if (eeprom->serial)
2480 free (eeprom->serial);
b8aa7b35 2481 eeprom->serial = NULL;
74e8e79d
UB		 2482 if (serial)
2483 {
2484 eeprom->serial = malloc(strlen(serial)+1);
2485 if (eeprom->serial)
2486 strcpy(eeprom->serial, serial);
2487 }
2488
56ac0383 2489 if (ftdi->type == TYPE_R)
a4980043 2490 {
a886436a 2491 eeprom->max_power = 90;
a02587d5 2492 eeprom->size = 0x80;
a4980043
UB		 2493 eeprom->cbus_function[0] = CBUS_TXLED;
2494 eeprom->cbus_function[1] = CBUS_RXLED;
2495 eeprom->cbus_function[2] = CBUS_TXDEN;
2496 eeprom->cbus_function[3] = CBUS_PWREN;
2497 eeprom->cbus_function[4] = CBUS_SLEEP;
2498 }
2f80efc2
NP		 2499 else if (ftdi->type == TYPE_230X)
2500 {
2501 eeprom->max_power = 90;
2502 eeprom->size = 0x100;
add00ad6
RH		 2503 eeprom->cbus_function[0] = CBUSX_TXDEN;
2504 eeprom->cbus_function[1] = CBUSX_RXLED;
2505 eeprom->cbus_function[2] = CBUSX_TXLED;
2506 eeprom->cbus_function[3] = CBUSX_SLEEP;
2f80efc2 2507 }
a02587d5 2508 else
263d3ba0
UB		 2509 {
2510 if(ftdi->type == TYPE_232H)
2511 {
2512 int i;
2513 for (i=0; i<10; i++)
2514 eeprom->cbus_function[i] = CBUSH_TRISTATE;
2515 }
a02587d5 2516 eeprom->size = -1;
263d3ba0 2517 }
68e78641
JS		 2518 switch (ftdi->type)
2519 {
2520 case TYPE_AM:
2521 eeprom->release_number = 0x0200;
2522 break;
2523 case TYPE_BM:
2524 eeprom->release_number = 0x0400;
2525 break;
2526 case TYPE_2232C:
2527 eeprom->release_number = 0x0500;
2528 break;
2529 case TYPE_R:
2530 eeprom->release_number = 0x0600;
2531 break;
2532 case TYPE_2232H:
2533 eeprom->release_number = 0x0700;
2534 break;
2535 case TYPE_4232H:
2536 eeprom->release_number = 0x0800;
2537 break;
2538 case TYPE_232H:
2539 eeprom->release_number = 0x0900;
2540 break;
2f80efc2
NP		 2541 case TYPE_230X:
2542 eeprom->release_number = 0x1000;
2543 break;
68e78641
JS		 2544 default:
2545 eeprom->release_number = 0x00;
2546 }
f14f84d3 2547 return 0;
b8aa7b35 2548}
878f0c6a
NP		 2549
2550int ftdi_eeprom_set_strings(struct ftdi_context *ftdi, char * manufacturer,
74387f27 2551 char * product, char * serial)
878f0c6a
NP		 2552{
2553 struct ftdi_eeprom *eeprom;
2554
2555 if (ftdi == NULL)
2556 ftdi_error_return(-1, "No struct ftdi_context");
2557
2558 if (ftdi->eeprom == NULL)
2559 ftdi_error_return(-2,"No struct ftdi_eeprom");
2560
2561 eeprom = ftdi->eeprom;
2562
2563 if (ftdi->usb_dev == NULL)
2564 ftdi_error_return(-3, "No connected device or device not yet opened");
2565
74387f27
TJ		 2566 if (manufacturer)
2567 {
878f0c6a
NP		 2568 if (eeprom->manufacturer)
2569 free (eeprom->manufacturer);
2570 eeprom->manufacturer = malloc(strlen(manufacturer)+1);
2571 if (eeprom->manufacturer)
2572 strcpy(eeprom->manufacturer, manufacturer);
2573 }
2574
74387f27
TJ		 2575 if(product)
2576 {
878f0c6a
NP		 2577 if (eeprom->product)
2578 free (eeprom->product);
2579 eeprom->product = malloc(strlen(product)+1);
2580 if (eeprom->product)
2581 strcpy(eeprom->product, product);
2582 }
2583
74387f27
TJ		 2584 if (serial)
2585 {
878f0c6a
NP		 2586 if (eeprom->serial)
2587 free (eeprom->serial);
2588 eeprom->serial = malloc(strlen(serial)+1);
74387f27
TJ		 2589 if (eeprom->serial)
2590 {
878f0c6a
NP		 2591 strcpy(eeprom->serial, serial);
2592 eeprom->use_serial = 1;
2593 }
2594 }
2595 return 0;
2596}
2597
2598
add00ad6 2599/*FTD2XX doesn't check for values not fitting in the ACBUS Signal options*/
263d3ba0
UB		 2600void set_ft232h_cbus(struct ftdi_eeprom *eeprom, unsigned char * output)
2601{
2602 int i;
74387f27 2603 for(i=0; i<5; i++)
263d3ba0
UB		 2604 {
2605 int mode_low, mode_high;
2606 if (eeprom->cbus_function[2*i]> CBUSH_CLK7_5)
2607 mode_low = CBUSH_TRISTATE;
2608 else
2609 mode_low = eeprom->cbus_function[2*i];
2610 if (eeprom->cbus_function[2*i+1]> CBUSH_CLK7_5)
2611 mode_high = CBUSH_TRISTATE;
2612 else
f37a1524 2613 mode_high = eeprom->cbus_function[2*i+1];
b8aa7b35 2614
f37a1524 2615 output[0x18+i] = (mode_high <<4) | mode_low;
263d3ba0
UB		 2616 }
2617}
c8f69686
UB		 2618/* Return the bits for the encoded EEPROM Structure of a requested Mode
2619 *
2620 */
2621static unsigned char type2bit(unsigned char type, enum ftdi_chip_type chip)
2622{
2623 switch (chip)
2624 {
74387f27
TJ		 2625 case TYPE_2232H:
2626 case TYPE_2232C:
c8f69686 2627 {
74387f27
TJ		 2628 switch (type)
2629 {
2630 case CHANNEL_IS_UART: return 0;
2631 case CHANNEL_IS_FIFO: return 0x01;
2632 case CHANNEL_IS_OPTO: return 0x02;
2633 case CHANNEL_IS_CPU : return 0x04;
2634 default: return 0;
2635 }
c8f69686 2636 }
74387f27 2637 case TYPE_232H:
c8f69686 2638 {
74387f27
TJ		 2639 switch (type)
2640 {
2641 case CHANNEL_IS_UART : return 0;
2642 case CHANNEL_IS_FIFO : return 0x01;
2643 case CHANNEL_IS_OPTO : return 0x02;
2644 case CHANNEL_IS_CPU : return 0x04;
2645 case CHANNEL_IS_FT1284 : return 0x08;
2646 default: return 0;
2647 }
c8f69686 2648 }
74387f27
TJ		 2649 case TYPE_230X: /* FT230X is only UART */
2650 default: return 0;
c8f69686
UB		 2651 }
2652 return 0;
74387f27 2653}
c8f69686 2654
1941414d 2655/**
a35aa9bd 2656 Build binary buffer from ftdi_eeprom structure.
22a1b5c1 2657 Output is suitable for ftdi_write_eeprom().
b8aa7b35 2658
a35aa9bd 2659 \param ftdi pointer to ftdi_context
1941414d 2660
516ebfb1 2661 \retval >=0: size of eeprom user area in bytes
22a1b5c1 2662 \retval -1: eeprom size (128 bytes) exceeded by custom strings
2c1e2bde
TJ		 2663 \retval -2: Invalid eeprom or ftdi pointer
2664 \retval -3: Invalid cbus function setting (FIXME: Not in the code?)
2665 \retval -4: Chip doesn't support invert (FIXME: Not in the code?)
2666 \retval -5: Chip doesn't support high current drive (FIXME: Not in the code?)
2b9a3c82 2667 \retval -6: No connected EEPROM or EEPROM Type unknown
b8aa7b35 2668*/
a35aa9bd 2669int ftdi_eeprom_build(struct ftdi_context *ftdi)
a8f46ddc 2670{
e2bbd9af 2671 unsigned char i, j, eeprom_size_mask;
b8aa7b35
TJ		 2672 unsigned short checksum, value;
2673 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
6e962b9a 2674 int user_area_size, free_start, free_end;
c0a96aed 2675 struct ftdi_eeprom *eeprom;
a35aa9bd 2676 unsigned char * output;
b8aa7b35 2677
c0a96aed 2678 if (ftdi == NULL)
cc9c9d58 2679 ftdi_error_return(-2,"No context");
c0a96aed 2680 if (ftdi->eeprom == NULL)
cc9c9d58 2681 ftdi_error_return(-2,"No eeprom structure");
c0a96aed
UB		 2682
2683 eeprom= ftdi->eeprom;
a35aa9bd 2684 output = eeprom->buf;
22a1b5c1 2685
56ac0383 2686 if (eeprom->chip == -1)
2c1e2bde 2687 ftdi_error_return(-6,"No connected EEPROM or EEPROM type unknown");
2b9a3c82 2688
74387f27
TJ		 2689 if (eeprom->size == -1)
2690 {
2f80efc2
NP		 2691 if ((eeprom->chip == 0x56) || (eeprom->chip == 0x66))
2692 eeprom->size = 0x100;
2693 else
2694 eeprom->size = 0x80;
2695 }
f75bf139 2696
b8aa7b35 2697 if (eeprom->manufacturer != NULL)
d9f0cce7 2698 manufacturer_size = strlen(eeprom->manufacturer);
b8aa7b35 2699 if (eeprom->product != NULL)
d9f0cce7 2700 product_size = strlen(eeprom->product);
b8aa7b35 2701 if (eeprom->serial != NULL)
d9f0cce7 2702 serial_size = strlen(eeprom->serial);
b8aa7b35 2703
814710ba
TJ		 2704 // eeprom size check
2705 switch (ftdi->type)
2706 {
2707 case TYPE_AM:
2708 case TYPE_BM:
6e962b9a 2709 case TYPE_R:
814710ba
TJ		 2710 user_area_size = 96; // base size for strings (total of 48 characters)
2711 break;
2712 case TYPE_2232C:
56ac0383
TJ		 2713 user_area_size = 90; // two extra config bytes and 4 bytes PnP stuff
2714 break;
2f80efc2 2715 case TYPE_230X:
56ac0383
TJ		 2716 user_area_size = 88; // four extra config bytes + 4 bytes PnP stuff
2717 break;
814710ba
TJ		 2718 case TYPE_2232H: // six extra config bytes + 4 bytes PnP stuff
2719 case TYPE_4232H:
56ac0383 2720 user_area_size = 86;
118c4561 2721 break;
c1c3d564
UB		 2722 case TYPE_232H:
2723 user_area_size = 80;
2724 break;
2c1e2bde
TJ		 2725 default:
2726 user_area_size = 0;
56ac0383 2727 break;
665cda04
UB		 2728 }
2729 user_area_size -= (manufacturer_size + product_size + serial_size) * 2;
814710ba 2730
516ebfb1
TJ		 2731 if (user_area_size < 0)
2732 ftdi_error_return(-1,"eeprom size exceeded");
b8aa7b35
TJ		 2733
2734 // empty eeprom
74387f27
TJ		 2735 if (ftdi->type == TYPE_230X)
2736 {
2f80efc2
NP		 2737 /* FT230X have a reserved section in the middle of the MTP,
2738 which cannot be written to, but must be included in the checksum */
2739 memset(ftdi->eeprom->buf, 0, 0x80);
2740 memset((ftdi->eeprom->buf + 0xa0), 0, (FTDI_MAX_EEPROM_SIZE - 0xa0));
74387f27
TJ		 2741 }
2742 else
2743 {
2f80efc2
NP		 2744 memset(ftdi->eeprom->buf, 0, FTDI_MAX_EEPROM_SIZE);
2745 }
b8aa7b35 2746
93738c79
UB		 2747 // Bytes and Bits set for all Types
2748
b8aa7b35
TJ		 2749 // Addr 02: Vendor ID
2750 output[0x02] = eeprom->vendor_id;
2751 output[0x03] = eeprom->vendor_id >> 8;
2752
2753 // Addr 04: Product ID
2754 output[0x04] = eeprom->product_id;
2755 output[0x05] = eeprom->product_id >> 8;
2756
2757 // Addr 06: Device release number (0400h for BM features)
68e78641
JS		 2758 output[0x06] = eeprom->release_number;
2759 output[0x07] = eeprom->release_number >> 8;
b8aa7b35
TJ		 2760
2761 // Addr 08: Config descriptor
8fae3e8e
TJ		 2762 // Bit 7: always 1
2763 // Bit 6: 1 if this device is self powered, 0 if bus powered
2764 // Bit 5: 1 if this device uses remote wakeup
37186e34 2765 // Bit 4-0: reserved - 0
5a1dcd55 2766 j = 0x80;
afb90824 2767 if (eeprom->self_powered)
5a1dcd55 2768 j |= 0x40;
afb90824 2769 if (eeprom->remote_wakeup)
5a1dcd55 2770 j |= 0x20;
b8aa7b35
TJ		 2771 output[0x08] = j;
2772
2773 // Addr 09: Max power consumption: max power = value * 2 mA
a7c32c59 2774 output[0x09] = eeprom->max_power / MAX_POWER_MILLIAMP_PER_UNIT;
d9f0cce7 2775
2f80efc2 2776 if ((ftdi->type != TYPE_AM) && (ftdi->type != TYPE_230X))
93738c79
UB		 2777 {
2778 // Addr 0A: Chip configuration
2779 // Bit 7: 0 - reserved
2780 // Bit 6: 0 - reserved
2781 // Bit 5: 0 - reserved
56ac0383 2782 // Bit 4: 1 - Change USB version
93738c79
UB		 2783 // Bit 3: 1 - Use the serial number string
2784 // Bit 2: 1 - Enable suspend pull downs for lower power
2785 // Bit 1: 1 - Out EndPoint is Isochronous
2786 // Bit 0: 1 - In EndPoint is Isochronous
2787 //
2788 j = 0;
afb90824 2789 if (eeprom->in_is_isochronous)
93738c79 2790 j = j | 1;
afb90824 2791 if (eeprom->out_is_isochronous)
93738c79
UB		 2792 j = j | 2;
2793 output[0x0A] = j;
2794 }
f505134f 2795
b8aa7b35 2796 // Dynamic content
93738c79
UB		 2797 // Strings start at 0x94 (TYPE_AM, TYPE_BM)
2798 // 0x96 (TYPE_2232C), 0x98 (TYPE_R) and 0x9a (TYPE_x232H)
c7e4c09e 2799 // 0xa0 (TYPE_232H)
93738c79 2800 i = 0;
56ac0383
TJ		 2801 switch (ftdi->type)
2802 {
2803 case TYPE_2232H:
2804 case TYPE_4232H:
2805 i += 2;
2806 case TYPE_R:
2807 i += 2;
2808 case TYPE_2232C:
2809 i += 2;
2810 case TYPE_AM:
2811 case TYPE_BM:
2812 i += 0x94;
2f80efc2 2813 break;
fa3032f0 2814 case TYPE_232H:
2f80efc2
NP		 2815 case TYPE_230X:
2816 i = 0xa0;
2817 break;
f505134f 2818 }
93738c79 2819 /* Wrap around 0x80 for 128 byte EEPROMS (Internale and 93x46) */
e2bbd9af 2820 eeprom_size_mask = eeprom->size -1;
6e962b9a 2821 free_end = i & eeprom_size_mask;
c201f80f 2822
93738c79
UB		 2823 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
2824 // Addr 0F: Length of manufacturer string
22d12cda 2825 // Output manufacturer
93738c79 2826 output[0x0E] = i; // calculate offset
e2bbd9af
TJ		 2827 output[i & eeprom_size_mask] = manufacturer_size*2 + 2, i++;
2828 output[i & eeprom_size_mask] = 0x03, i++; // type: string
22d12cda
TJ		 2829 for (j = 0; j < manufacturer_size; j++)
2830 {
e2bbd9af
TJ		 2831 output[i & eeprom_size_mask] = eeprom->manufacturer[j], i++;
2832 output[i & eeprom_size_mask] = 0x00, i++;
b8aa7b35 2833 }
93738c79 2834 output[0x0F] = manufacturer_size*2 + 2;
b8aa7b35 2835
93738c79
UB		 2836 // Addr 10: Offset of the product string + 0x80, calculated later
2837 // Addr 11: Length of product string
c201f80f 2838 output[0x10] = i | 0x80; // calculate offset
e2bbd9af
TJ		 2839 output[i & eeprom_size_mask] = product_size*2 + 2, i++;
2840 output[i & eeprom_size_mask] = 0x03, i++;
22d12cda
TJ		 2841 for (j = 0; j < product_size; j++)
2842 {
e2bbd9af
TJ		 2843 output[i & eeprom_size_mask] = eeprom->product[j], i++;
2844 output[i & eeprom_size_mask] = 0x00, i++;
b8aa7b35 2845 }
93738c79 2846 output[0x11] = product_size*2 + 2;
37186e34 2847
93738c79
UB		 2848 // Addr 12: Offset of the serial string + 0x80, calculated later
2849 // Addr 13: Length of serial string
c201f80f 2850 output[0x12] = i | 0x80; // calculate offset
e2bbd9af
TJ		 2851 output[i & eeprom_size_mask] = serial_size*2 + 2, i++;
2852 output[i & eeprom_size_mask] = 0x03, i++;
22d12cda
TJ		 2853 for (j = 0; j < serial_size; j++)
2854 {
e2bbd9af
TJ		 2855 output[i & eeprom_size_mask] = eeprom->serial[j], i++;
2856 output[i & eeprom_size_mask] = 0x00, i++;
b8aa7b35 2857 }
c2700d6d
TJ		 2858
2859 // Legacy port name and PnP fields for FT2232 and newer chips
2860 if (ftdi->type > TYPE_BM)
2861 {
2862 output[i & eeprom_size_mask] = 0x02; /* as seen when written with FTD2XX */
2863 i++;
2864 output[i & eeprom_size_mask] = 0x03; /* as seen when written with FTD2XX */
2865 i++;
2866 output[i & eeprom_size_mask] = eeprom->is_not_pnp; /* as seen when written with FTD2XX */
2867 i++;
2868 }
802a949e 2869
93738c79 2870 output[0x13] = serial_size*2 + 2;
b8aa7b35 2871
56ac0383 2872 if (ftdi->type > TYPE_AM) /* use_serial not used in AM devices */
bf2f6ef7 2873 {
d4b5af27 2874 if (eeprom->use_serial)
bf2f6ef7
UB		 2875 output[0x0A] |= USE_SERIAL_NUM;
2876 else
2877 output[0x0A] &= ~USE_SERIAL_NUM;
2878 }
3802140c
UB		 2879
2880 /* Bytes and Bits specific to (some) types
2881 Write linear, as this allows easier fixing*/
56ac0383
TJ		 2882 switch (ftdi->type)
2883 {
2884 case TYPE_AM:
2885 break;
2886 case TYPE_BM:
2887 output[0x0C] = eeprom->usb_version & 0xff;
2888 output[0x0D] = (eeprom->usb_version>>8) & 0xff;
3986243d 2889 if (eeprom->use_usb_version)
56ac0383
TJ		 2890 output[0x0A] |= USE_USB_VERSION_BIT;
2891 else
2892 output[0x0A] &= ~USE_USB_VERSION_BIT;
caec1294 2893
56ac0383
TJ		 2894 break;
2895 case TYPE_2232C:
3802140c 2896
c8f69686 2897 output[0x00] = type2bit(eeprom->channel_a_type, TYPE_2232C);
56ac0383
TJ		 2898 if ( eeprom->channel_a_driver == DRIVER_VCP)
2899 output[0x00] |= DRIVER_VCP;
2900 else
2901 output[0x00] &= ~DRIVER_VCP;
4e74064b 2902
56ac0383
TJ		 2903 if ( eeprom->high_current_a == HIGH_CURRENT_DRIVE)
2904 output[0x00] |= HIGH_CURRENT_DRIVE;
2905 else
2906 output[0x00] &= ~HIGH_CURRENT_DRIVE;
3802140c 2907
c8f69686 2908 output[0x01] = type2bit(eeprom->channel_b_type, TYPE_2232C);
56ac0383
TJ		 2909 if ( eeprom->channel_b_driver == DRIVER_VCP)
2910 output[0x01] |= DRIVER_VCP;
2911 else
2912 output[0x01] &= ~DRIVER_VCP;
4e74064b 2913
56ac0383
TJ		 2914 if ( eeprom->high_current_b == HIGH_CURRENT_DRIVE)
2915 output[0x01] |= HIGH_CURRENT_DRIVE;
2916 else
2917 output[0x01] &= ~HIGH_CURRENT_DRIVE;
3802140c 2918
afb90824 2919 if (eeprom->in_is_isochronous)
56ac0383
TJ		 2920 output[0x0A] |= 0x1;
2921 else
2922 output[0x0A] &= ~0x1;
afb90824 2923 if (eeprom->out_is_isochronous)
56ac0383
TJ		 2924 output[0x0A] |= 0x2;
2925 else
2926 output[0x0A] &= ~0x2;
afb90824 2927 if (eeprom->suspend_pull_downs)
56ac0383
TJ		 2928 output[0x0A] |= 0x4;
2929 else
2930 output[0x0A] &= ~0x4;
3986243d 2931 if (eeprom->use_usb_version)
56ac0383
TJ		 2932 output[0x0A] |= USE_USB_VERSION_BIT;
2933 else
2934 output[0x0A] &= ~USE_USB_VERSION_BIT;
4e74064b 2935
56ac0383
TJ		 2936 output[0x0C] = eeprom->usb_version & 0xff;
2937 output[0x0D] = (eeprom->usb_version>>8) & 0xff;
2938 output[0x14] = eeprom->chip;
2939 break;
2940 case TYPE_R:
2941 if (eeprom->high_current == HIGH_CURRENT_DRIVE_R)
2942 output[0x00] |= HIGH_CURRENT_DRIVE_R;
08518f8e
RA		 2943 if (eeprom->external_oscillator)
2944 output[0x00] |= 0x02;
56ac0383 2945 output[0x01] = 0x40; /* Hard coded Endpoint Size*/
4e74064b 2946
afb90824 2947 if (eeprom->suspend_pull_downs)
56ac0383
TJ		 2948 output[0x0A] |= 0x4;
2949 else
2950 output[0x0A] &= ~0x4;
2951 output[0x0B] = eeprom->invert;
2952 output[0x0C] = eeprom->usb_version & 0xff;
2953 output[0x0D] = (eeprom->usb_version>>8) & 0xff;
4e74064b 2954
add00ad6 2955 if (eeprom->cbus_function[0] > CBUS_BB_RD)
56ac0383
TJ		 2956 output[0x14] = CBUS_TXLED;
2957 else
2958 output[0x14] = eeprom->cbus_function[0];
4e74064b 2959
add00ad6 2960 if (eeprom->cbus_function[1] > CBUS_BB_RD)
56ac0383
TJ		 2961 output[0x14] |= CBUS_RXLED<<4;
2962 else
2963 output[0x14] |= eeprom->cbus_function[1]<<4;
4e74064b 2964
add00ad6 2965 if (eeprom->cbus_function[2] > CBUS_BB_RD)
56ac0383
TJ		 2966 output[0x15] = CBUS_TXDEN;
2967 else
2968 output[0x15] = eeprom->cbus_function[2];
4e74064b 2969
add00ad6 2970 if (eeprom->cbus_function[3] > CBUS_BB_RD)
56ac0383
TJ		 2971 output[0x15] |= CBUS_PWREN<<4;
2972 else
2973 output[0x15] |= eeprom->cbus_function[3]<<4;
4e74064b 2974
56ac0383
TJ		 2975 if (eeprom->cbus_function[4] > CBUS_CLK6)
2976 output[0x16] = CBUS_SLEEP;
2977 else
2978 output[0x16] = eeprom->cbus_function[4];
2979 break;
2980 case TYPE_2232H:
c8f69686 2981 output[0x00] = type2bit(eeprom->channel_a_type, TYPE_2232H);
56ac0383
TJ		 2982 if ( eeprom->channel_a_driver == DRIVER_VCP)
2983 output[0x00] |= DRIVER_VCP;
2984 else
2985 output[0x00] &= ~DRIVER_VCP;
6e6a1c3f 2986
c8f69686 2987 output[0x01] = type2bit(eeprom->channel_b_type, TYPE_2232H);
56ac0383
TJ		 2988 if ( eeprom->channel_b_driver == DRIVER_VCP)
2989 output[0x01] |= DRIVER_VCP;
2990 else
2991 output[0x01] &= ~DRIVER_VCP;
2992 if (eeprom->suspend_dbus7 == SUSPEND_DBUS7_BIT)
2993 output[0x01] |= SUSPEND_DBUS7_BIT;
2994 else
2995 output[0x01] &= ~SUSPEND_DBUS7_BIT;
2996
afb90824 2997 if (eeprom->suspend_pull_downs)
56ac0383
TJ		 2998 output[0x0A] |= 0x4;
2999 else
3000 output[0x0A] &= ~0x4;
3001
3002 if (eeprom->group0_drive > DRIVE_16MA)
3003 output[0x0c] |= DRIVE_16MA;
3004 else
3005 output[0x0c] |= eeprom->group0_drive;
3006 if (eeprom->group0_schmitt == IS_SCHMITT)
3007 output[0x0c] |= IS_SCHMITT;
3008 if (eeprom->group0_slew == SLOW_SLEW)
3009 output[0x0c] |= SLOW_SLEW;
3010
3011 if (eeprom->group1_drive > DRIVE_16MA)
3012 output[0x0c] |= DRIVE_16MA<<4;
3013 else
3014 output[0x0c] |= eeprom->group1_drive<<4;
3015 if (eeprom->group1_schmitt == IS_SCHMITT)
3016 output[0x0c] |= IS_SCHMITT<<4;
3017 if (eeprom->group1_slew == SLOW_SLEW)
3018 output[0x0c] |= SLOW_SLEW<<4;
3019
3020 if (eeprom->group2_drive > DRIVE_16MA)
3021 output[0x0d] |= DRIVE_16MA;
3022 else
3023 output[0x0d] |= eeprom->group2_drive;
3024 if (eeprom->group2_schmitt == IS_SCHMITT)
3025 output[0x0d] |= IS_SCHMITT;
3026 if (eeprom->group2_slew == SLOW_SLEW)
3027 output[0x0d] |= SLOW_SLEW;
3028
3029 if (eeprom->group3_drive > DRIVE_16MA)
3030 output[0x0d] |= DRIVE_16MA<<4;
3031 else
3032 output[0x0d] |= eeprom->group3_drive<<4;
3033 if (eeprom->group3_schmitt == IS_SCHMITT)
3034 output[0x0d] |= IS_SCHMITT<<4;
3035 if (eeprom->group3_slew == SLOW_SLEW)
3036 output[0x0d] |= SLOW_SLEW<<4;
3802140c 3037
56ac0383 3038 output[0x18] = eeprom->chip;
3802140c 3039
56ac0383
TJ		 3040 break;
3041 case TYPE_4232H:
be4bae37
AL		 3042 if (eeprom->channel_a_driver == DRIVER_VCP)
3043 output[0x00] |= DRIVER_VCP;
3044 else
3045 output[0x00] &= ~DRIVER_VCP;
3046 if (eeprom->channel_b_driver == DRIVER_VCP)
3047 output[0x01] |= DRIVER_VCP;
3048 else
3049 output[0x01] &= ~DRIVER_VCP;
3050 if (eeprom->channel_c_driver == DRIVER_VCP)
3051 output[0x00] |= (DRIVER_VCP << 4);
3052 else
3053 output[0x00] &= ~(DRIVER_VCP << 4);
3054 if (eeprom->channel_d_driver == DRIVER_VCP)
3055 output[0x01] |= (DRIVER_VCP << 4);
3056 else
3057 output[0x01] &= ~(DRIVER_VCP << 4);
3058
afb90824 3059 if (eeprom->suspend_pull_downs)
be4bae37
AL		 3060 output[0x0a] |= 0x4;
3061 else
3062 output[0x0a] &= ~0x4;
3063
3064 if (eeprom->channel_a_rs485enable)
3065 output[0x0b] |= CHANNEL_IS_RS485 << 0;
3066 else
3067 output[0x0b] &= ~(CHANNEL_IS_RS485 << 0);
3068 if (eeprom->channel_b_rs485enable)
3069 output[0x0b] |= CHANNEL_IS_RS485 << 1;
3070 else
3071 output[0x0b] &= ~(CHANNEL_IS_RS485 << 1);
3072 if (eeprom->channel_c_rs485enable)
3073 output[0x0b] |= CHANNEL_IS_RS485 << 2;
3074 else
3075 output[0x0b] &= ~(CHANNEL_IS_RS485 << 2);
3076 if (eeprom->channel_d_rs485enable)
3077 output[0x0b] |= CHANNEL_IS_RS485 << 3;
3078 else
3079 output[0x0b] &= ~(CHANNEL_IS_RS485 << 3);
3080
3081 if (eeprom->group0_drive > DRIVE_16MA)
3082 output[0x0c] |= DRIVE_16MA;
3083 else
3084 output[0x0c] |= eeprom->group0_drive;
3085 if (eeprom->group0_schmitt == IS_SCHMITT)
3086 output[0x0c] |= IS_SCHMITT;
3087 if (eeprom->group0_slew == SLOW_SLEW)
3088 output[0x0c] |= SLOW_SLEW;
3089
3090 if (eeprom->group1_drive > DRIVE_16MA)
3091 output[0x0c] |= DRIVE_16MA<<4;
3092 else
3093 output[0x0c] |= eeprom->group1_drive<<4;
3094 if (eeprom->group1_schmitt == IS_SCHMITT)
3095 output[0x0c] |= IS_SCHMITT<<4;
3096 if (eeprom->group1_slew == SLOW_SLEW)
3097 output[0x0c] |= SLOW_SLEW<<4;
3098
3099 if (eeprom->group2_drive > DRIVE_16MA)
3100 output[0x0d] |= DRIVE_16MA;
3101 else
3102 output[0x0d] |= eeprom->group2_drive;
3103 if (eeprom->group2_schmitt == IS_SCHMITT)
3104 output[0x0d] |= IS_SCHMITT;
3105 if (eeprom->group2_slew == SLOW_SLEW)
3106 output[0x0d] |= SLOW_SLEW;
3107
3108 if (eeprom->group3_drive > DRIVE_16MA)
3109 output[0x0d] |= DRIVE_16MA<<4;
3110 else
3111 output[0x0d] |= eeprom->group3_drive<<4;
3112 if (eeprom->group3_schmitt == IS_SCHMITT)
3113 output[0x0d] |= IS_SCHMITT<<4;
3114 if (eeprom->group3_slew == SLOW_SLEW)
3115 output[0x0d] |= SLOW_SLEW<<4;
3116
c7e4c09e 3117 output[0x18] = eeprom->chip;
be4bae37 3118
c7e4c09e
UB		 3119 break;
3120 case TYPE_232H:
c8f69686 3121 output[0x00] = type2bit(eeprom->channel_a_type, TYPE_232H);
ac4a82a5
UB		 3122 if ( eeprom->channel_a_driver == DRIVER_VCP)
3123 output[0x00] |= DRIVER_VCPH;
3124 else
3125 output[0x00] &= ~DRIVER_VCPH;
837a71d6
UB		 3126 if (eeprom->powersave)
3127 output[0x01] |= POWER_SAVE_DISABLE_H;
3128 else
3129 output[0x01] &= ~POWER_SAVE_DISABLE_H;
a7e05353
DM		 3130
3131 if (eeprom->suspend_pull_downs)
3132 output[0x0a] |= 0x4;
3133 else
3134 output[0x0a] &= ~0x4;
3135
18199b76
UB		 3136 if (eeprom->clock_polarity)
3137 output[0x01] |= FT1284_CLK_IDLE_STATE;
3138 else
3139 output[0x01] &= ~FT1284_CLK_IDLE_STATE;
3140 if (eeprom->data_order)
3141 output[0x01] |= FT1284_DATA_LSB;
3142 else
3143 output[0x01] &= ~FT1284_DATA_LSB;
3144 if (eeprom->flow_control)
3145 output[0x01] |= FT1284_FLOW_CONTROL;
3146 else
3147 output[0x01] &= ~FT1284_FLOW_CONTROL;
91d7a201
UB		 3148 if (eeprom->group0_drive > DRIVE_16MA)
3149 output[0x0c] |= DRIVE_16MA;
3150 else
3151 output[0x0c] |= eeprom->group0_drive;
3152 if (eeprom->group0_schmitt == IS_SCHMITT)
3153 output[0x0c] |= IS_SCHMITT;
3154 if (eeprom->group0_slew == SLOW_SLEW)
3155 output[0x0c] |= SLOW_SLEW;
3156
3157 if (eeprom->group1_drive > DRIVE_16MA)
3158 output[0x0d] |= DRIVE_16MA;
3159 else
3160 output[0x0d] |= eeprom->group1_drive;
3161 if (eeprom->group1_schmitt == IS_SCHMITT)
3162 output[0x0d] |= IS_SCHMITT;
3163 if (eeprom->group1_slew == SLOW_SLEW)
3164 output[0x0d] |= SLOW_SLEW;
3165
263d3ba0
UB		 3166 set_ft232h_cbus(eeprom, output);
3167
c7e4c09e
UB		 3168 output[0x1e] = eeprom->chip;
3169 fprintf(stderr,"FIXME: Build FT232H specific EEPROM settings\n");
3170 break;
2f80efc2
NP		 3171 case TYPE_230X:
3172 output[0x00] = 0x80; /* Actually, leave the default value */
3173 output[0x0a] = 0x08; /* Enable USB Serial Number */
e659737a
UB		 3174 /*FIXME: Make DBUS & CBUS Control configurable*/
3175 output[0x0c] = 0; /* DBUS drive 4mA, CBUS drive 4 mA like factory default */
74387f27
TJ		 3176 for (j = 0; j <= 6; j++)
3177 {
2f80efc2
NP		 3178 output[0x1a + j] = eeprom->cbus_function[j];
3179 }
347d87e5 3180 output[0x0b] = eeprom->invert;
2f80efc2 3181 break;
3802140c
UB		 3182 }
3183
6e962b9a
SET		 3184 /* First address without use */
3185 free_start = 0;
3186 switch (ftdi->type)
3187 {
3188 case TYPE_230X:
3189 free_start += 2;
3190 case TYPE_232H:
3191 free_start += 6;
3192 case TYPE_2232H:
3193 case TYPE_4232H:
3194 free_start += 2;
3195 case TYPE_R:
3196 free_start += 2;
3197 case TYPE_2232C:
3198 free_start++;
3199 case TYPE_AM:
3200 case TYPE_BM:
3201 free_start += 0x14;
3202 }
3203
3204 /* Arbitrary user data */
3205 if (eeprom->user_data && eeprom->user_data_size >= 0)
3206 {
3207 if (eeprom->user_data_addr < free_start)
3208 fprintf(stderr,"Warning, user data starts inside the generated data!\n");
3209 if (eeprom->user_data_addr + eeprom->user_data_size >= free_end)
3210 fprintf(stderr,"Warning, user data overlaps the strings area!\n");
3211 if (eeprom->user_data_addr + eeprom->user_data_size > eeprom->size)
3212 ftdi_error_return(-1,"eeprom size exceeded");
3213 memcpy(output + eeprom->user_data_addr, eeprom->user_data, eeprom->user_data_size);
3214 }
3215
cbf65673 3216 // calculate checksum
b8aa7b35 3217 checksum = 0xAAAA;
d9f0cce7 3218
22d12cda
TJ		 3219 for (i = 0; i < eeprom->size/2-1; i++)
3220 {
74387f27
TJ		 3221 if ((ftdi->type == TYPE_230X) && (i == 0x12))
3222 {
2f80efc2
NP		 3223 /* FT230X has a user section in the MTP which is not part of the checksum */
3224 i = 0x40;
3225 }
519bbce1
UB		 3226 if ((ftdi->type == TYPE_230X) && (i >= 0x40) && (i < 0x50)) {
3227 uint16_t data;
3228 if (ftdi_read_eeprom_location(ftdi, i, &data)) {
3229 fprintf(stderr, "Reading Factory Configuration Data failed\n");
3230 i = 0x50;
3231 }
3232 value = data;
3233 }
3234 else {
3235 value = output[i*2];
3236 value += output[(i*2)+1] << 8;
3237 }
d9f0cce7
TJ		 3238 checksum = value^checksum;
3239 checksum = (checksum << 1) | (checksum >> 15);
b8aa7b35
TJ		 3240 }
3241
c201f80f
TJ		 3242 output[eeprom->size-2] = checksum;
3243 output[eeprom->size-1] = checksum >> 8;
b8aa7b35 3244
68e78641 3245 eeprom->initialized_for_connected_device = 1;
516ebfb1 3246 return user_area_size;
b8aa7b35 3247}
74387f27 3248/* Decode the encoded EEPROM field for the FTDI Mode into a value for the abstracted
c8f69686
UB		 3249 * EEPROM structure
3250 *
3251 * FTD2XX doesn't allow to set multiple bits in the interface mode bitfield, and so do we
3252 */
3253static unsigned char bit2type(unsigned char bits)
0fc2170c
UB		 3254{
3255 switch (bits)
3256 {
74387f27
TJ		 3257 case 0: return CHANNEL_IS_UART;
3258 case 1: return CHANNEL_IS_FIFO;
3259 case 2: return CHANNEL_IS_OPTO;
3260 case 4: return CHANNEL_IS_CPU;
3261 case 8: return CHANNEL_IS_FT1284;
3262 default:
3263 fprintf(stderr," Unexpected value %d for Hardware Interface type\n",
3264 bits);
0fc2170c
UB		 3265 }
3266 return 0;
3267}
1ad9e4cc
TJ		 3268/* Decode 230X / 232R type chips invert bits
3269 * Prints directly to stdout.
3270*/
3271static void print_inverted_bits(int invert)
3272{
3273 char *r_bits[] = {"TXD","RXD","RTS","CTS","DTR","DSR","DCD","RI"};
3274 int i;
3275
3276 fprintf(stdout,"Inverted bits:");
3277 for (i=0; i<8; i++)
3278 if ((invert & (1<<i)) == (1<<i))
3279 fprintf(stdout," %s",r_bits[i]);
3280
3281 fprintf(stdout,"\n");
3282}
4af1d1bb
MK		 3283/**
3284 Decode binary EEPROM image into an ftdi_eeprom structure.
3285
e659737a
UB		 3286 For FT-X devices use AN_201 FT-X MTP memory Configuration to decode.
3287
a35aa9bd
UB		 3288 \param ftdi pointer to ftdi_context
3289 \param verbose Decode EEPROM on stdout
56ac0383 3290
4af1d1bb
MK		 3291 \retval 0: all fine
3292 \retval -1: something went wrong
3293
3294 FIXME: How to pass size? How to handle size field in ftdi_eeprom?
3295 FIXME: Strings are malloc'ed here and should be freed somewhere
3296*/
a35aa9bd 3297int ftdi_eeprom_decode(struct ftdi_context *ftdi, int verbose)
b56d5a64 3298{
3fca5ea9 3299 int i, j;
b56d5a64
MK		 3300 unsigned short checksum, eeprom_checksum, value;
3301 unsigned char manufacturer_size = 0, product_size = 0, serial_size = 0;
f2cd9fd5 3302 int eeprom_size;
c0a96aed 3303 struct ftdi_eeprom *eeprom;
3bc0387e 3304 unsigned char *buf = NULL;
22a1b5c1 3305
c0a96aed 3306 if (ftdi == NULL)
cc9c9d58 3307 ftdi_error_return(-1,"No context");
c0a96aed 3308 if (ftdi->eeprom == NULL)
6cd4f922 3309 ftdi_error_return(-1,"No eeprom structure");
56ac0383 3310
c0a96aed 3311 eeprom = ftdi->eeprom;
a35aa9bd 3312 eeprom_size = eeprom->size;
3bc0387e 3313 buf = ftdi->eeprom->buf;
b56d5a64 3314
b56d5a64
MK		 3315 // Addr 02: Vendor ID
3316 eeprom->vendor_id = buf[0x02] + (buf[0x03] << 8);
3317
3318 // Addr 04: Product ID
3319 eeprom->product_id = buf[0x04] + (buf[0x05] << 8);
22d12cda 3320
68e78641
JS		 3321 // Addr 06: Device release number
3322 eeprom->release_number = buf[0x06] + (buf[0x07]<<8);
b56d5a64
MK		 3323
3324 // Addr 08: Config descriptor
3325 // Bit 7: always 1
3326 // Bit 6: 1 if this device is self powered, 0 if bus powered
3327 // Bit 5: 1 if this device uses remote wakeup
f6ef2983 3328 eeprom->self_powered = buf[0x08] & 0x40;
814710ba 3329 eeprom->remote_wakeup = buf[0x08] & 0x20;
b56d5a64
MK		 3330
3331 // Addr 09: Max power consumption: max power = value * 2 mA
a7c32c59 3332 eeprom->max_power = MAX_POWER_MILLIAMP_PER_UNIT * buf[0x09];
b56d5a64
MK		 3333
3334 // Addr 0A: Chip configuration
3335 // Bit 7: 0 - reserved
3336 // Bit 6: 0 - reserved
3337 // Bit 5: 0 - reserved
caec1294 3338 // Bit 4: 1 - Change USB version on BM and 2232C
b56d5a64
MK		 3339 // Bit 3: 1 - Use the serial number string
3340 // Bit 2: 1 - Enable suspend pull downs for lower power
3341 // Bit 1: 1 - Out EndPoint is Isochronous
3342 // Bit 0: 1 - In EndPoint is Isochronous
3343 //
8d3fe5c9
UB		 3344 eeprom->in_is_isochronous = buf[0x0A]&0x01;
3345 eeprom->out_is_isochronous = buf[0x0A]&0x02;
3346 eeprom->suspend_pull_downs = buf[0x0A]&0x04;
3986243d
TS		 3347 eeprom->use_serial = !!(buf[0x0A] & USE_SERIAL_NUM);
3348 eeprom->use_usb_version = !!(buf[0x0A] & USE_USB_VERSION_BIT);
b56d5a64 3349
b1859923 3350 // Addr 0C: USB version low byte when 0x0A
56ac0383 3351 // Addr 0D: USB version high byte when 0x0A
b1859923 3352 eeprom->usb_version = buf[0x0C] + (buf[0x0D] << 8);
b56d5a64
MK		 3353
3354 // Addr 0E: Offset of the manufacturer string + 0x80, calculated later
3355 // Addr 0F: Length of manufacturer string
3356 manufacturer_size = buf[0x0F]/2;
56ac0383 3357 if (eeprom->manufacturer)
74e8e79d 3358 free(eeprom->manufacturer);
56ac0383 3359 if (manufacturer_size > 0)
acc1fa05
UB		 3360 {
3361 eeprom->manufacturer = malloc(manufacturer_size);
3362 if (eeprom->manufacturer)
3363 {
3364 // Decode manufacturer
84ec032f 3365 i = buf[0x0E] & (eeprom_size -1); // offset
74387f27 3366 for (j=0; j<manufacturer_size-1; j++)
acc1fa05
UB		 3367 {
3368 eeprom->manufacturer[j] = buf[2*j+i+2];
3369 }
3370 eeprom->manufacturer[j] = '\0';
3371 }
3372 }
b56d5a64
MK		 3373 else eeprom->manufacturer = NULL;
3374
3375 // Addr 10: Offset of the product string + 0x80, calculated later
3376 // Addr 11: Length of product string
56ac0383 3377 if (eeprom->product)
74e8e79d 3378 free(eeprom->product);
b56d5a64 3379 product_size = buf[0x11]/2;
acc1fa05
UB		 3380 if (product_size > 0)
3381 {
3382 eeprom->product = malloc(product_size);
56ac0383 3383 if (eeprom->product)
acc1fa05
UB		 3384 {
3385 // Decode product name
84ec032f 3386 i = buf[0x10] & (eeprom_size -1); // offset
74387f27 3387 for (j=0; j<product_size-1; j++)
acc1fa05
UB		 3388 {
3389 eeprom->product[j] = buf[2*j+i+2];
3390 }
3391 eeprom->product[j] = '\0';
3392 }
3393 }
b56d5a64
MK		 3394 else eeprom->product = NULL;
3395
3396 // Addr 12: Offset of the serial string + 0x80, calculated later
3397 // Addr 13: Length of serial string
56ac0383 3398 if (eeprom->serial)
74e8e79d 3399 free(eeprom->serial);
b56d5a64 3400 serial_size = buf[0x13]/2;
acc1fa05
UB		 3401 if (serial_size > 0)
3402 {
3403 eeprom->serial = malloc(serial_size);
56ac0383 3404 if (eeprom->serial)
acc1fa05
UB		 3405 {
3406 // Decode serial
84ec032f 3407 i = buf[0x12] & (eeprom_size -1); // offset
74387f27 3408 for (j=0; j<serial_size-1; j++)
acc1fa05
UB		 3409 {
3410 eeprom->serial[j] = buf[2*j+i+2];
3411 }
3412 eeprom->serial[j] = '\0';
3413 }
3414 }
b56d5a64
MK		 3415 else eeprom->serial = NULL;
3416
b56d5a64
MK		 3417 // verify checksum
3418 checksum = 0xAAAA;
3419
22d12cda
TJ		 3420 for (i = 0; i < eeprom_size/2-1; i++)
3421 {
74387f27
TJ		 3422 if ((ftdi->type == TYPE_230X) && (i == 0x12))
3423 {
2f80efc2
NP		 3424 /* FT230X has a user section in the MTP which is not part of the checksum */
3425 i = 0x40;
3426 }
b56d5a64
MK		 3427 value = buf[i*2];
3428 value += buf[(i*2)+1] << 8;
3429
3430 checksum = value^checksum;
3431 checksum = (checksum << 1) | (checksum >> 15);
3432 }
3433
3434 eeprom_checksum = buf[eeprom_size-2] + (buf[eeprom_size-1] << 8);
3435
22d12cda
TJ		 3436 if (eeprom_checksum != checksum)
3437 {
3438 fprintf(stderr, "Checksum Error: %04x %04x\n", checksum, eeprom_checksum);
cc9c9d58 3439 ftdi_error_return(-1,"EEPROM checksum error");
4af1d1bb
MK		 3440 }
3441
eb498cff 3442 eeprom->channel_a_type = 0;
aa099f46 3443 if ((ftdi->type == TYPE_AM) || (ftdi->type == TYPE_BM))
f6ef2983 3444 {
6cd4f922 3445 eeprom->chip = -1;
f6ef2983 3446 }
56ac0383 3447 else if (ftdi->type == TYPE_2232C)
f6ef2983 3448 {
0fc2170c 3449 eeprom->channel_a_type = bit2type(buf[0x00] & 0x7);
2cde7c52
UB		 3450 eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
3451 eeprom->high_current_a = buf[0x00] & HIGH_CURRENT_DRIVE;
3452 eeprom->channel_b_type = buf[0x01] & 0x7;
3453 eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
3454 eeprom->high_current_b = buf[0x01] & HIGH_CURRENT_DRIVE;
6cd4f922 3455 eeprom->chip = buf[0x14];
065edc58 3456 }
56ac0383 3457 else if (ftdi->type == TYPE_R)
564b2716 3458 {
2cde7c52 3459 /* TYPE_R flags D2XX, not VCP as all others*/
be4bae37 3460 eeprom->channel_a_driver = ~buf[0x00] & DRIVER_VCP;
2cde7c52 3461 eeprom->high_current = buf[0x00] & HIGH_CURRENT_DRIVE_R;
08518f8e 3462 eeprom->external_oscillator = buf[0x00] & 0x02;
56ac0383
TJ		 3463 if ( (buf[0x01]&0x40) != 0x40)
3464 fprintf(stderr,
3465 "TYPE_R EEPROM byte[0x01] Bit 6 unexpected Endpoint size."
3466 " If this happened with the\n"
3467 " EEPROM programmed by FTDI tools, please report "
3468 "to libftdi@developer.intra2net.com\n");
2cde7c52 3469
6cd4f922 3470 eeprom->chip = buf[0x16];
cecb9cb2
UB		 3471 // Addr 0B: Invert data lines
3472 // Works only on FT232R, not FT245R, but no way to distinguish
07851949
UB		 3473 eeprom->invert = buf[0x0B];
3474 // Addr 14: CBUS function: CBUS0, CBUS1
3475 // Addr 15: CBUS function: CBUS2, CBUS3
3476 // Addr 16: CBUS function: CBUS5
3477 eeprom->cbus_function[0] = buf[0x14] & 0x0f;
3478 eeprom->cbus_function[1] = (buf[0x14] >> 4) & 0x0f;
3479 eeprom->cbus_function[2] = buf[0x15] & 0x0f;
3480 eeprom->cbus_function[3] = (buf[0x15] >> 4) & 0x0f;
3481 eeprom->cbus_function[4] = buf[0x16] & 0x0f;
564b2716 3482 }
be4bae37 3483 else if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
db099ec5 3484 {
2cde7c52 3485 eeprom->channel_a_driver = buf[0x00] & DRIVER_VCP;
2cde7c52
UB		 3486 eeprom->channel_b_driver = buf[0x01] & DRIVER_VCP;
3487
56ac0383 3488 if (ftdi->type == TYPE_2232H)
be4bae37
AL		 3489 {
3490 eeprom->channel_a_type = bit2type(buf[0x00] & 0x7);
3491 eeprom->channel_b_type = bit2type(buf[0x01] & 0x7);
ec0dcd3f 3492 eeprom->suspend_dbus7 = buf[0x01] & SUSPEND_DBUS7_BIT;
be4bae37
AL		 3493 }
3494 else
3495 {
3496 eeprom->channel_c_driver = (buf[0x00] >> 4) & DRIVER_VCP;
3497 eeprom->channel_d_driver = (buf[0x01] >> 4) & DRIVER_VCP;
3498 eeprom->channel_a_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 0);
3499 eeprom->channel_b_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 1);
3500 eeprom->channel_c_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 2);
3501 eeprom->channel_d_rs485enable = buf[0x0b] & (CHANNEL_IS_RS485 << 3);
3502 }
2cde7c52 3503
6cd4f922 3504 eeprom->chip = buf[0x18];
db099ec5
UB		 3505 eeprom->group0_drive = buf[0x0c] & DRIVE_16MA;
3506 eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT;
3507 eeprom->group0_slew = buf[0x0c] & SLOW_SLEW;
3508 eeprom->group1_drive = (buf[0x0c] >> 4) & 0x3;
3509 eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT;
3510 eeprom->group1_slew = (buf[0x0c] >> 4) & SLOW_SLEW;
3511 eeprom->group2_drive = buf[0x0d] & DRIVE_16MA;
3512 eeprom->group2_schmitt = buf[0x0d] & IS_SCHMITT;
3513 eeprom->group2_slew = buf[0x0d] & SLOW_SLEW;
3514 eeprom->group3_drive = (buf[0x0d] >> 4) & DRIVE_16MA;
3515 eeprom->group3_schmitt = (buf[0x0d] >> 4) & IS_SCHMITT;
3516 eeprom->group3_slew = (buf[0x0d] >> 4) & SLOW_SLEW;
947d9552 3517 }
c7e4c09e
UB		 3518 else if (ftdi->type == TYPE_232H)
3519 {
ac4a82a5
UB		 3520 eeprom->channel_a_type = buf[0x00] & 0xf;
3521 eeprom->channel_a_driver = (buf[0x00] & DRIVER_VCPH)?DRIVER_VCP:0;
18199b76
UB		 3522 eeprom->clock_polarity = buf[0x01] & FT1284_CLK_IDLE_STATE;
3523 eeprom->data_order = buf[0x01] & FT1284_DATA_LSB;
3524 eeprom->flow_control = buf[0x01] & FT1284_FLOW_CONTROL;
837a71d6 3525 eeprom->powersave = buf[0x01] & POWER_SAVE_DISABLE_H;
91d7a201
UB		 3526 eeprom->group0_drive = buf[0x0c] & DRIVE_16MA;
3527 eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT;
3528 eeprom->group0_slew = buf[0x0c] & SLOW_SLEW;
3529 eeprom->group1_drive = buf[0x0d] & DRIVE_16MA;
3530 eeprom->group1_schmitt = buf[0x0d] & IS_SCHMITT;
3531 eeprom->group1_slew = buf[0x0d] & SLOW_SLEW;
3532
263d3ba0
UB		 3533 for(i=0; i<5; i++)
3534 {
3535 eeprom->cbus_function[2*i ] = buf[0x18+i] & 0x0f;
3536 eeprom->cbus_function[2*i+1] = (buf[0x18+i] >> 4) & 0x0f;
3537 }
c7e4c09e
UB		 3538 eeprom->chip = buf[0x1e];
3539 /*FIXME: Decipher more values*/
3540 }
2f80efc2
NP		 3541 else if (ftdi->type == TYPE_230X)
3542 {
74387f27
TJ		 3543 for(i=0; i<4; i++)
3544 {
2f80efc2
NP		 3545 eeprom->cbus_function[i] = buf[0x1a + i] & 0xFF;
3546 }
3547 eeprom->group0_drive = buf[0x0c] & 0x03;
3548 eeprom->group0_schmitt = buf[0x0c] & IS_SCHMITT;
3549 eeprom->group0_slew = buf[0x0c] & SLOW_SLEW;
3550 eeprom->group1_drive = (buf[0x0c] >> 4) & 0x03;
3551 eeprom->group1_schmitt = (buf[0x0c] >> 4) & IS_SCHMITT;
3552 eeprom->group1_slew = (buf[0x0c] >> 4) & SLOW_SLEW;
34b79ac7 3553
347d87e5 3554 eeprom->invert = buf[0xb];
2f80efc2 3555 }
56ac0383
TJ		 3556
3557 if (verbose)
f6ef2983 3558 {
c8f69686 3559 char *channel_mode[] = {"UART", "FIFO", "CPU", "OPTO", "FT1284"};
f6ef2983
UB		 3560 fprintf(stdout, "VID: 0x%04x\n",eeprom->vendor_id);
3561 fprintf(stdout, "PID: 0x%04x\n",eeprom->product_id);
68e78641 3562 fprintf(stdout, "Release: 0x%04x\n",eeprom->release_number);
f6ef2983 3563
56ac0383 3564 if (eeprom->self_powered)
f6ef2983
UB		 3565 fprintf(stdout, "Self-Powered%s", (eeprom->remote_wakeup)?", USB Remote Wake Up\n":"\n");
3566 else
a7c32c59 3567 fprintf(stdout, "Bus Powered: %3d mA%s", eeprom->max_power,
f6ef2983 3568 (eeprom->remote_wakeup)?" USB Remote Wake Up\n":"\n");
56ac0383 3569 if (eeprom->manufacturer)
f6ef2983 3570 fprintf(stdout, "Manufacturer: %s\n",eeprom->manufacturer);
56ac0383 3571 if (eeprom->product)
f6ef2983 3572 fprintf(stdout, "Product: %s\n",eeprom->product);
56ac0383 3573 if (eeprom->serial)
f6ef2983 3574 fprintf(stdout, "Serial: %s\n",eeprom->serial);
e107f509 3575 fprintf(stdout, "Checksum : %04x\n", checksum);
08518f8e 3576 if (ftdi->type == TYPE_R) {
6cd4f922 3577 fprintf(stdout, "Internal EEPROM\n");
08518f8e
RA		 3578 fprintf(stdout,"Oscillator: %s\n", eeprom->external_oscillator?"External":"Internal");
3579 }
6cd4f922
UB		 3580 else if (eeprom->chip >= 0x46)
3581 fprintf(stdout, "Attached EEPROM: 93x%02x\n", eeprom->chip);
56ac0383
TJ		 3582 if (eeprom->suspend_dbus7)
3583 fprintf(stdout, "Suspend on DBUS7\n");
3584 if (eeprom->suspend_pull_downs)
fb9bfdd1 3585 fprintf(stdout, "Pull IO pins low during suspend\n");
837a71d6
UB		 3586 if(eeprom->powersave)
3587 {
3588 if(ftdi->type >= TYPE_232H)
3589 fprintf(stdout,"Enter low power state on ACBUS7\n");
74387f27 3590 }
56ac0383 3591 if (eeprom->remote_wakeup)
fb9bfdd1 3592 fprintf(stdout, "Enable Remote Wake Up\n");
802a949e 3593 fprintf(stdout, "PNP: %d\n",(eeprom->is_not_pnp)?0:1);
db099ec5 3594 if (ftdi->type >= TYPE_2232C)
56ac0383 3595 fprintf(stdout,"Channel A has Mode %s%s%s\n",
e107f509 3596 channel_mode[eeprom->channel_a_type],
2cde7c52
UB		 3597 (eeprom->channel_a_driver)?" VCP":"",
3598 (eeprom->high_current_a)?" High Current IO":"");
f45f4237 3599 if (ftdi->type == TYPE_232H)
18199b76
UB		 3600 {
3601 fprintf(stdout,"FT1284 Mode Clock is idle %s, %s first, %sFlow Control\n",
3602 (eeprom->clock_polarity)?"HIGH":"LOW",
3603 (eeprom->data_order)?"LSB":"MSB",
3604 (eeprom->flow_control)?"":"No ");
74387f27 3605 }
f45f4237 3606 if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
56ac0383 3607 fprintf(stdout,"Channel B has Mode %s%s%s\n",
e107f509 3608 channel_mode[eeprom->channel_b_type],
2cde7c52
UB		 3609 (eeprom->channel_b_driver)?" VCP":"",
3610 (eeprom->high_current_b)?" High Current IO":"");
caec1294 3611 if (((ftdi->type == TYPE_BM) || (ftdi->type == TYPE_2232C)) &&
3986243d 3612 eeprom->use_usb_version)
caec1294
UB		 3613 fprintf(stdout,"Use explicit USB Version %04x\n",eeprom->usb_version);
3614
56ac0383 3615 if ((ftdi->type == TYPE_2232H) || (ftdi->type == TYPE_4232H))
db099ec5
UB		 3616 {
3617 fprintf(stdout,"%s has %d mA drive%s%s\n",
3618 (ftdi->type == TYPE_2232H)?"AL":"A",
3619 (eeprom->group0_drive+1) *4,
3620 (eeprom->group0_schmitt)?" Schmitt Input":"",
3621 (eeprom->group0_slew)?" Slow Slew":"");
3622 fprintf(stdout,"%s has %d mA drive%s%s\n",
3623 (ftdi->type == TYPE_2232H)?"AH":"B",
3624 (eeprom->group1_drive+1) *4,
3625 (eeprom->group1_schmitt)?" Schmitt Input":"",
3626 (eeprom->group1_slew)?" Slow Slew":"");
3627 fprintf(stdout,"%s has %d mA drive%s%s\n",
3628 (ftdi->type == TYPE_2232H)?"BL":"C",
3629 (eeprom->group2_drive+1) *4,
3630 (eeprom->group2_schmitt)?" Schmitt Input":"",
3631 (eeprom->group2_slew)?" Slow Slew":"");
3632 fprintf(stdout,"%s has %d mA drive%s%s\n",
3633 (ftdi->type == TYPE_2232H)?"BH":"D",
3634 (eeprom->group3_drive+1) *4,
3635 (eeprom->group3_schmitt)?" Schmitt Input":"",
3636 (eeprom->group3_slew)?" Slow Slew":"");
3637 }
91d7a201
UB		 3638 else if (ftdi->type == TYPE_232H)
3639 {
add00ad6 3640 char *cbush_mux[] = {"TRISTATE","TXLED","RXLED", "TXRXLED","PWREN",
74387f27
TJ		 3641 "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN",
3642 "CLK30","CLK15","CLK7_5"
3643 };
91d7a201
UB		 3644 fprintf(stdout,"ACBUS has %d mA drive%s%s\n",
3645 (eeprom->group0_drive+1) *4,
3646 (eeprom->group0_schmitt)?" Schmitt Input":"",
3647 (eeprom->group0_slew)?" Slow Slew":"");
3648 fprintf(stdout,"ADBUS has %d mA drive%s%s\n",
3649 (eeprom->group1_drive+1) *4,
3650 (eeprom->group1_schmitt)?" Schmitt Input":"",
3651 (eeprom->group1_slew)?" Slow Slew":"");
263d3ba0
UB		 3652 for (i=0; i<10; i++)
3653 {
3654 if (eeprom->cbus_function[i]<= CBUSH_CLK7_5 )
3655 fprintf(stdout,"C%d Function: %s\n", i,
3656 cbush_mux[eeprom->cbus_function[i]]);
3657 }
91d7a201 3658 }
2f80efc2
NP		 3659 else if (ftdi->type == TYPE_230X)
3660 {
add00ad6 3661 char *cbusx_mux[] = {"TRISTATE","TXLED","RXLED", "TXRXLED","PWREN",
74387f27
TJ		 3662 "SLEEP","DRIVE_0","DRIVE_1","IOMODE","TXDEN",
3663 "CLK24","CLK12","CLK6","BAT_DETECT","BAT_DETECT#",
3664 "I2C_TXE#", "I2C_RXF#", "VBUS_SENSE", "BB_WR#",
3665 "BBRD#", "TIME_STAMP", "AWAKE#",
3666 };
f45f4237 3667 fprintf(stdout,"DBUS has %d mA drive%s%s\n",
2f80efc2
NP		 3668 (eeprom->group0_drive+1) *4,
3669 (eeprom->group0_schmitt)?" Schmitt Input":"",
3670 (eeprom->group0_slew)?" Slow Slew":"");
3671 fprintf(stdout,"CBUS has %d mA drive%s%s\n",
3672 (eeprom->group1_drive+1) *4,
3673 (eeprom->group1_schmitt)?" Schmitt Input":"",
3674 (eeprom->group1_slew)?" Slow Slew":"");
3675 for (i=0; i<4; i++)
3676 {
add00ad6
RH		 3677 if (eeprom->cbus_function[i]<= CBUSX_AWAKE)
3678 fprintf(stdout,"CBUS%d Function: %s\n", i, cbusx_mux[eeprom->cbus_function[i]]);
2f80efc2 3679 }
1ad9e4cc
TJ		 3680
3681 if (eeprom->invert)
3682 print_inverted_bits(eeprom->invert);
2f80efc2 3683 }
91d7a201 3684
a4980043
UB		 3685 if (ftdi->type == TYPE_R)
3686 {
3687 char *cbus_mux[] = {"TXDEN","PWREN","RXLED", "TXLED","TX+RXLED",
13f00d3c 3688 "SLEEP","CLK48","CLK24","CLK12","CLK6",
56ac0383
TJ		 3689 "IOMODE","BB_WR","BB_RD"
3690 };
13f00d3c 3691 char *cbus_BB[] = {"RXF","TXE","RD", "WR"};
56ac0383
TJ		 3692
3693 if (eeprom->invert)
1ad9e4cc 3694 print_inverted_bits(eeprom->invert);
13ea50d2 3695
56ac0383 3696 for (i=0; i<5; i++)
a4980043 3697 {
add00ad6 3698 if (eeprom->cbus_function[i]<=CBUS_BB_RD)
a4980043
UB		 3699 fprintf(stdout,"C%d Function: %s\n", i,
3700 cbus_mux[eeprom->cbus_function[i]]);
3701 else
17431287 3702 {
598b2334
UB		 3703 if (i < 4)
3704 /* Running MPROG show that C0..3 have fixed function Synchronous
3705 Bit Bang mode */
3706 fprintf(stdout,"C%d BB Function: %s\n", i,
3707 cbus_BB[i]);
3708 else
3709 fprintf(stdout, "Unknown CBUS mode. Might be special mode?\n");
17431287 3710 }
a4980043
UB		 3711 }
3712 }
f6ef2983 3713 }
4af1d1bb 3714 return 0;
b56d5a64
MK		 3715}
3716
1941414d 3717/**
44ef02bd
UB		 3718 Get a value from the decoded EEPROM structure
3719
735e81ea
TJ		 3720 \param ftdi pointer to ftdi_context
3721 \param value_name Enum of the value to query
3722 \param value Pointer to store read value
44ef02bd 3723
735e81ea
TJ		 3724 \retval 0: all fine
3725 \retval -1: Value doesn't exist
44ef02bd
UB		 3726*/
3727int ftdi_get_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int* value)
3728{
3729 switch (value_name)
3730 {
56ac0383
TJ		 3731 case VENDOR_ID:
3732 *value = ftdi->eeprom->vendor_id;
3733 break;
3734 case PRODUCT_ID:
3735 *value = ftdi->eeprom->product_id;
3736 break;
68e78641
JS		 3737 case RELEASE_NUMBER:
3738 *value = ftdi->eeprom->release_number;
3739 break;
56ac0383
TJ		 3740 case SELF_POWERED:
3741 *value = ftdi->eeprom->self_powered;
3742 break;
3743 case REMOTE_WAKEUP:
3744 *value = ftdi->eeprom->remote_wakeup;
3745 break;
3746 case IS_NOT_PNP:
3747 *value = ftdi->eeprom->is_not_pnp;
3748 break;
3749 case SUSPEND_DBUS7:
3750 *value = ftdi->eeprom->suspend_dbus7;
3751 break;
3752 case IN_IS_ISOCHRONOUS:
3753 *value = ftdi->eeprom->in_is_isochronous;
3754 break;
cffed9f5
UB		 3755 case OUT_IS_ISOCHRONOUS:
3756 *value = ftdi->eeprom->out_is_isochronous;
3757 break;
56ac0383
TJ		 3758 case SUSPEND_PULL_DOWNS:
3759 *value = ftdi->eeprom->suspend_pull_downs;
3760 break;
3761 case USE_SERIAL:
3762 *value = ftdi->eeprom->use_serial;
3763 break;
3764 case USB_VERSION:
3765 *value = ftdi->eeprom->usb_version;
3766 break;
cffed9f5
UB		 3767 case USE_USB_VERSION:
3768 *value = ftdi->eeprom->use_usb_version;
3769 break;
56ac0383
TJ		 3770 case MAX_POWER:
3771 *value = ftdi->eeprom->max_power;
3772 break;
3773 case CHANNEL_A_TYPE:
3774 *value = ftdi->eeprom->channel_a_type;
3775 break;
3776 case CHANNEL_B_TYPE:
3777 *value = ftdi->eeprom->channel_b_type;
3778 break;
3779 case CHANNEL_A_DRIVER:
3780 *value = ftdi->eeprom->channel_a_driver;
3781 break;
3782 case CHANNEL_B_DRIVER:
3783 *value = ftdi->eeprom->channel_b_driver;
3784 break;
be4bae37
AL		 3785 case CHANNEL_C_DRIVER:
3786 *value = ftdi->eeprom->channel_c_driver;
3787 break;
3788 case CHANNEL_D_DRIVER:
3789 *value = ftdi->eeprom->channel_d_driver;
3790 break;
3791 case CHANNEL_A_RS485:
3792 *value = ftdi->eeprom->channel_a_rs485enable;
3793 break;
3794 case CHANNEL_B_RS485:
3795 *value = ftdi->eeprom->channel_b_rs485enable;
3796 break;
3797 case CHANNEL_C_RS485:
3798 *value = ftdi->eeprom->channel_c_rs485enable;
3799 break;
3800 case CHANNEL_D_RS485:
3801 *value = ftdi->eeprom->channel_d_rs485enable;
3802 break;
56ac0383
TJ		 3803 case CBUS_FUNCTION_0:
3804 *value = ftdi->eeprom->cbus_function[0];
3805 break;
3806 case CBUS_FUNCTION_1:
3807 *value = ftdi->eeprom->cbus_function[1];
3808 break;
3809 case CBUS_FUNCTION_2:
3810 *value = ftdi->eeprom->cbus_function[2];
3811 break;
3812 case CBUS_FUNCTION_3:
3813 *value = ftdi->eeprom->cbus_function[3];
3814 break;
3815 case CBUS_FUNCTION_4:
3816 *value = ftdi->eeprom->cbus_function[4];
3817 break;
263d3ba0
UB		 3818 case CBUS_FUNCTION_5:
3819 *value = ftdi->eeprom->cbus_function[5];
3820 break;
3821 case CBUS_FUNCTION_6:
3822 *value = ftdi->eeprom->cbus_function[6];
3823 break;
3824 case CBUS_FUNCTION_7:
3825 *value = ftdi->eeprom->cbus_function[7];
3826 break;
3827 case CBUS_FUNCTION_8:
3828 *value = ftdi->eeprom->cbus_function[8];
3829 break;
3830 case CBUS_FUNCTION_9:
1162549f 3831 *value = ftdi->eeprom->cbus_function[9];
263d3ba0 3832 break;
56ac0383
TJ		 3833 case HIGH_CURRENT:
3834 *value = ftdi->eeprom->high_current;
3835 break;
3836 case HIGH_CURRENT_A:
3837 *value = ftdi->eeprom->high_current_a;
3838 break;
3839 case HIGH_CURRENT_B:
3840 *value = ftdi->eeprom->high_current_b;
3841 break;
3842 case INVERT:
3843 *value = ftdi->eeprom->invert;
3844 break;
3845 case GROUP0_DRIVE:
3846 *value = ftdi->eeprom->group0_drive;
3847 break;
3848 case GROUP0_SCHMITT:
3849 *value = ftdi->eeprom->group0_schmitt;
3850 break;
3851 case GROUP0_SLEW:
3852 *value = ftdi->eeprom->group0_slew;
3853 break;
3854 case GROUP1_DRIVE:
3855 *value = ftdi->eeprom->group1_drive;
3856 break;
3857 case GROUP1_SCHMITT:
3858 *value = ftdi->eeprom->group1_schmitt;
3859 break;
3860 case GROUP1_SLEW:
3861 *value = ftdi->eeprom->group1_slew;
3862 break;
3863 case GROUP2_DRIVE:
3864 *value = ftdi->eeprom->group2_drive;
3865 break;
3866 case GROUP2_SCHMITT:
3867 *value = ftdi->eeprom->group2_schmitt;
3868 break;
3869 case GROUP2_SLEW:
3870 *value = ftdi->eeprom->group2_slew;
3871 break;
3872 case GROUP3_DRIVE:
3873 *value = ftdi->eeprom->group3_drive;
3874 break;
3875 case GROUP3_SCHMITT:
3876 *value = ftdi->eeprom->group3_schmitt;
3877 break;
3878 case GROUP3_SLEW:
3879 *value = ftdi->eeprom->group3_slew;
3880 break;
74387f27 3881 case POWER_SAVE:
837a71d6
UB		 3882 *value = ftdi->eeprom->powersave;
3883 break;
74387f27 3884 case CLOCK_POLARITY:
18199b76
UB		 3885 *value = ftdi->eeprom->clock_polarity;
3886 break;
74387f27 3887 case DATA_ORDER:
18199b76
UB		 3888 *value = ftdi->eeprom->data_order;
3889 break;
74387f27 3890 case FLOW_CONTROL:
18199b76
UB		 3891 *value = ftdi->eeprom->flow_control;
3892 break;
74387f27 3893 case CHIP_TYPE:
56ac0383
TJ		 3894 *value = ftdi->eeprom->chip;
3895 break;
3896 case CHIP_SIZE:
3897 *value = ftdi->eeprom->size;
3898 break;
08518f8e
RA		 3899 case EXTERNAL_OSCILLATOR:
3900 *value = ftdi->eeprom->external_oscillator;
3901 break;
56ac0383
TJ		 3902 default:
3903 ftdi_error_return(-1, "Request for unknown EEPROM value");
44ef02bd
UB		 3904 }
3905 return 0;
3906}
3907
3908/**
3909 Set a value in the decoded EEPROM Structure
3910 No parameter checking is performed
3911
735e81ea 3912 \param ftdi pointer to ftdi_context
545f9df9 3913 \param value_name Enum of the value to set
735e81ea 3914 \param value to set
44ef02bd 3915
735e81ea
TJ		 3916 \retval 0: all fine
3917 \retval -1: Value doesn't exist
3918 \retval -2: Value not user settable
44ef02bd
UB		 3919*/
3920int ftdi_set_eeprom_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int value)
3921{
3922 switch (value_name)
3923 {
56ac0383
TJ		 3924 case VENDOR_ID:
3925 ftdi->eeprom->vendor_id = value;
3926 break;
3927 case PRODUCT_ID:
3928 ftdi->eeprom->product_id = value;
3929 break;
68e78641
JS		 3930 case RELEASE_NUMBER:
3931 ftdi->eeprom->release_number = value;
3932 break;
56ac0383
TJ		 3933 case SELF_POWERED:
3934 ftdi->eeprom->self_powered = value;
3935 break;
3936 case REMOTE_WAKEUP:
3937 ftdi->eeprom->remote_wakeup = value;
3938 break;
3939 case IS_NOT_PNP:
3940 ftdi->eeprom->is_not_pnp = value;
3941 break;
3942 case SUSPEND_DBUS7:
3943 ftdi->eeprom->suspend_dbus7 = value;
3944 break;
3945 case IN_IS_ISOCHRONOUS:
3946 ftdi->eeprom->in_is_isochronous = value;
3947 break;
cffed9f5
UB		 3948 case OUT_IS_ISOCHRONOUS:
3949 ftdi->eeprom->out_is_isochronous = value;
3950 break;
56ac0383
TJ		 3951 case SUSPEND_PULL_DOWNS:
3952 ftdi->eeprom->suspend_pull_downs = value;
3953 break;
3954 case USE_SERIAL:
3955 ftdi->eeprom->use_serial = value;
3956 break;
3957 case USB_VERSION:
3958 ftdi->eeprom->usb_version = value;
3959 break;
cffed9f5
UB		 3960 case USE_USB_VERSION:
3961 ftdi->eeprom->use_usb_version = value;
3962 break;
56ac0383
TJ		 3963 case MAX_POWER:
3964 ftdi->eeprom->max_power = value;
3965 break;
3966 case CHANNEL_A_TYPE:
3967 ftdi->eeprom->channel_a_type = value;
3968 break;
3969 case CHANNEL_B_TYPE:
3970 ftdi->eeprom->channel_b_type = value;
3971 break;
3972 case CHANNEL_A_DRIVER:
3973 ftdi->eeprom->channel_a_driver = value;
3974 break;
3975 case CHANNEL_B_DRIVER:
3976 ftdi->eeprom->channel_b_driver = value;
3977 break;
be4bae37
AL		 3978 case CHANNEL_C_DRIVER:
3979 ftdi->eeprom->channel_c_driver = value;
3980 break;
3981 case CHANNEL_D_DRIVER:
3982 ftdi->eeprom->channel_d_driver = value;
3983 break;
3984 case CHANNEL_A_RS485:
3985 ftdi->eeprom->channel_a_rs485enable = value;
3986 break;
3987 case CHANNEL_B_RS485:
3988 ftdi->eeprom->channel_b_rs485enable = value;
3989 break;
3990 case CHANNEL_C_RS485:
3991 ftdi->eeprom->channel_c_rs485enable = value;
3992 break;
3993 case CHANNEL_D_RS485:
3994 ftdi->eeprom->channel_d_rs485enable = value;
3995 break;
56ac0383
TJ		 3996 case CBUS_FUNCTION_0:
3997 ftdi->eeprom->cbus_function[0] = value;
3998 break;
3999 case CBUS_FUNCTION_1:
4000 ftdi->eeprom->cbus_function[1] = value;
4001 break;
4002 case CBUS_FUNCTION_2:
4003 ftdi->eeprom->cbus_function[2] = value;
4004 break;
4005 case CBUS_FUNCTION_3:
4006 ftdi->eeprom->cbus_function[3] = value;
4007 break;
4008 case CBUS_FUNCTION_4:
4009 ftdi->eeprom->cbus_function[4] = value;
4010 break;
263d3ba0
UB		 4011 case CBUS_FUNCTION_5:
4012 ftdi->eeprom->cbus_function[5] = value;
4013 break;
4014 case CBUS_FUNCTION_6:
4015 ftdi->eeprom->cbus_function[6] = value;
4016 break;
4017 case CBUS_FUNCTION_7:
4018 ftdi->eeprom->cbus_function[7] = value;
4019 break;
4020 case CBUS_FUNCTION_8:
4021 ftdi->eeprom->cbus_function[8] = value;
4022 break;
4023 case CBUS_FUNCTION_9:
4024 ftdi->eeprom->cbus_function[9] = value;
4025 break;
56ac0383
TJ		 4026 case HIGH_CURRENT:
4027 ftdi->eeprom->high_current = value;
4028 break;
4029 case HIGH_CURRENT_A:
4030 ftdi->eeprom->high_current_a = value;
4031 break;
4032 case HIGH_CURRENT_B:
4033 ftdi->eeprom->high_current_b = value;
4034 break;
4035 case INVERT:
4036 ftdi->eeprom->invert = value;
4037 break;
4038 case GROUP0_DRIVE:
4039 ftdi->eeprom->group0_drive = value;
4040 break;
4041 case GROUP0_SCHMITT:
4042 ftdi->eeprom->group0_schmitt = value;
4043 break;
4044 case GROUP0_SLEW:
4045 ftdi->eeprom->group0_slew = value;
4046 break;
4047 case GROUP1_DRIVE:
4048 ftdi->eeprom->group1_drive = value;
4049 break;
4050 case GROUP1_SCHMITT:
4051 ftdi->eeprom->group1_schmitt = value;
4052 break;
4053 case GROUP1_SLEW:
4054 ftdi->eeprom->group1_slew = value;
4055 break;
4056 case GROUP2_DRIVE:
4057 ftdi->eeprom->group2_drive = value;
4058 break;
4059 case GROUP2_SCHMITT:
4060 ftdi->eeprom->group2_schmitt = value;
4061 break;
4062 case GROUP2_SLEW:
4063 ftdi->eeprom->group2_slew = value;
4064 break;
4065 case GROUP3_DRIVE:
4066 ftdi->eeprom->group3_drive = value;
4067 break;
4068 case GROUP3_SCHMITT:
4069 ftdi->eeprom->group3_schmitt = value;
4070 break;
4071 case GROUP3_SLEW:
4072 ftdi->eeprom->group3_slew = value;
4073 break;
4074 case CHIP_TYPE:
4075 ftdi->eeprom->chip = value;
4076 break;
74387f27 4077 case POWER_SAVE:
837a71d6
UB		 4078 ftdi->eeprom->powersave = value;
4079 break;
74387f27 4080 case CLOCK_POLARITY:
18199b76
UB		 4081 ftdi->eeprom->clock_polarity = value;
4082 break;
74387f27 4083 case DATA_ORDER:
18199b76
UB		 4084 ftdi->eeprom->data_order = value;
4085 break;
74387f27 4086 case FLOW_CONTROL:
18199b76
UB		 4087 ftdi->eeprom->flow_control = value;
4088 break;
56ac0383
TJ		 4089 case CHIP_SIZE:
4090 ftdi_error_return(-2, "EEPROM Value can't be changed");
34b79ac7 4091 break;
08518f8e
RA		 4092 case EXTERNAL_OSCILLATOR:
4093 ftdi->eeprom->external_oscillator = value;
4094 break;
6e962b9a
SET		 4095 case USER_DATA_ADDR:
4096 ftdi->eeprom->user_data_addr = value;
4097 break;
34b79ac7 4098
56ac0383
TJ		 4099 default :
4100 ftdi_error_return(-1, "Request to unknown EEPROM value");
44ef02bd 4101 }
45a3ebd5 4102 ftdi->eeprom->initialized_for_connected_device = 0;
44ef02bd
UB		 4103 return 0;
4104}
4105
4106/** Get the read-only buffer to the binary EEPROM content
4107
4108 \param ftdi pointer to ftdi_context
735e81ea 4109 \param buf buffer to receive EEPROM content
44ef02bd
UB		 4110 \param size Size of receiving buffer
4111
4112 \retval 0: All fine
4113 \retval -1: struct ftdi_contxt or ftdi_eeprom missing
200bd3ed 4114 \retval -2: Not enough room to store eeprom
44ef02bd 4115*/
56ac0383
TJ		 4116int ftdi_get_eeprom_buf(struct ftdi_context *ftdi, unsigned char * buf, int size)
4117{
4118 if (!ftdi || !(ftdi->eeprom))
4119 ftdi_error_return(-1, "No appropriate structure");
b95e4654 4120
200bd3ed
TJ		 4121 if (!buf || size < ftdi->eeprom->size)
4122 ftdi_error_return(-1, "Not enough room to store eeprom");
4123
b95e4654
TJ		 4124 // Only copy up to FTDI_MAX_EEPROM_SIZE bytes
4125 if (size > FTDI_MAX_EEPROM_SIZE)
4126 size = FTDI_MAX_EEPROM_SIZE;
4127
56ac0383 4128 memcpy(buf, ftdi->eeprom->buf, size);
b95e4654 4129
56ac0383
TJ		 4130 return 0;
4131}
44ef02bd 4132
672fd368
UB		 4133/** Set the EEPROM content from the user-supplied prefilled buffer
4134
4135 \param ftdi pointer to ftdi_context
4136 \param buf buffer to read EEPROM content
4137 \param size Size of buffer
4138
4139 \retval 0: All fine
6e962b9a 4140 \retval -1: struct ftdi_context or ftdi_eeprom or buf missing
672fd368
UB		 4141*/
4142int ftdi_set_eeprom_buf(struct ftdi_context *ftdi, const unsigned char * buf, int size)
4143{
4144 if (!ftdi || !(ftdi->eeprom) || !buf)
4145 ftdi_error_return(-1, "No appropriate structure");
4146
4147 // Only copy up to FTDI_MAX_EEPROM_SIZE bytes
4148 if (size > FTDI_MAX_EEPROM_SIZE)
4149 size = FTDI_MAX_EEPROM_SIZE;
4150
4151 memcpy(ftdi->eeprom->buf, buf, size);
4152
4153 return 0;
4154}
4155
6e962b9a
SET		 4156/** Set the EEPROM user data content from the user-supplied prefilled buffer
4157
4158 \param ftdi pointer to ftdi_context
4159 \param buf buffer to read EEPROM user data content
4160 \param size Size of buffer
4161
4162 \retval 0: All fine
4163 \retval -1: struct ftdi_context or ftdi_eeprom or buf missing
4164*/
4165int ftdi_set_eeprom_user_data(struct ftdi_context *ftdi, const char * buf, int size)
4166{
4167 if (!ftdi || !(ftdi->eeprom) || !buf)
4168 ftdi_error_return(-1, "No appropriate structure");
4169
4170 ftdi->eeprom->user_data_size = size;
4171 ftdi->eeprom->user_data = buf;
4172 return 0;
4173}
4174
44ef02bd 4175/**
c1c70e13
OS		 4176 Read eeprom location
4177
4178 \param ftdi pointer to ftdi_context
4179 \param eeprom_addr Address of eeprom location to be read
4180 \param eeprom_val Pointer to store read eeprom location
4181
4182 \retval 0: all fine
4183 \retval -1: read failed
22a1b5c1 4184 \retval -2: USB device unavailable
c1c70e13
OS		 4185*/
4186int ftdi_read_eeprom_location (struct ftdi_context *ftdi, int eeprom_addr, unsigned short *eeprom_val)
4187{
22a1b5c1
TJ		 4188 if (ftdi == NULL || ftdi->usb_dev == NULL)
4189 ftdi_error_return(-2, "USB device unavailable");
4190
97c6b5f6 4191 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, eeprom_addr, (unsigned char *)eeprom_val, 2, ftdi->usb_read_timeout) != 2)
c1c70e13
OS		 4192 ftdi_error_return(-1, "reading eeprom failed");
4193
4194 return 0;
4195}
4196
4197/**
1941414d
TJ		 4198 Read eeprom
4199
4200 \param ftdi pointer to ftdi_context
b8aa7b35 4201
1941414d
TJ		 4202 \retval 0: all fine
4203 \retval -1: read failed
22a1b5c1 4204 \retval -2: USB device unavailable
1941414d 4205*/
a35aa9bd 4206int ftdi_read_eeprom(struct ftdi_context *ftdi)
a8f46ddc 4207{
a3da1d95 4208 int i;
a35aa9bd 4209 unsigned char *buf;
a3da1d95 4210
22a1b5c1
TJ		 4211 if (ftdi == NULL || ftdi->usb_dev == NULL)
4212 ftdi_error_return(-2, "USB device unavailable");
a35aa9bd 4213 buf = ftdi->eeprom->buf;
22a1b5c1 4214
2d543486 4215 for (i = 0; i < FTDI_MAX_EEPROM_SIZE/2; i++)
22d12cda 4216 {
a35aa9bd 4217 if (libusb_control_transfer(
56ac0383
TJ		 4218 ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE,SIO_READ_EEPROM_REQUEST, 0, i,
4219 buf+(i*2), 2, ftdi->usb_read_timeout) != 2)
c3d95b87 4220 ftdi_error_return(-1, "reading eeprom failed");
a3da1d95
GE		 4221 }
4222
2d543486 4223 if (ftdi->type == TYPE_R)
a35aa9bd 4224 ftdi->eeprom->size = 0x80;
56ac0383 4225 /* Guesses size of eeprom by comparing halves
2d543486 4226 - will not work with blank eeprom */
a35aa9bd 4227 else if (strrchr((const char *)buf, 0xff) == ((const char *)buf +FTDI_MAX_EEPROM_SIZE -1))
2d543486 4228 ftdi->eeprom->size = -1;
56ac0383 4229 else if (memcmp(buf,&buf[0x80],0x80) == 0)
2d543486 4230 ftdi->eeprom->size = 0x80;
56ac0383 4231 else if (memcmp(buf,&buf[0x40],0x40) == 0)
2d543486
UB		 4232 ftdi->eeprom->size = 0x40;
4233 else
4234 ftdi->eeprom->size = 0x100;
a3da1d95
GE		 4235 return 0;
4236}
4237
cb6250fa
TJ		 4238/*
4239 ftdi_read_chipid_shift does the bitshift operation needed for the FTDIChip-ID
4240 Function is only used internally
4241 \internal
4242*/
4243static unsigned char ftdi_read_chipid_shift(unsigned char value)
4244{
4245 return ((value & 1) << 1) |
22d12cda
TJ		 4246 ((value & 2) << 5) |
4247 ((value & 4) >> 2) |
4248 ((value & 8) << 4) |
4249 ((value & 16) >> 1) |
4250 ((value & 32) >> 1) |
4251 ((value & 64) >> 4) |
4252 ((value & 128) >> 2);
cb6250fa
TJ		 4253}
4254
4255/**
4256 Read the FTDIChip-ID from R-type devices
4257
4258 \param ftdi pointer to ftdi_context
4259 \param chipid Pointer to store FTDIChip-ID
4260
4261 \retval 0: all fine
4262 \retval -1: read failed
22a1b5c1 4263 \retval -2: USB device unavailable
cb6250fa
TJ		 4264*/
4265int ftdi_read_chipid(struct ftdi_context *ftdi, unsigned int *chipid)
4266{
c7eb3112 4267 unsigned int a = 0, b = 0;
cb6250fa 4268
22a1b5c1
TJ		 4269 if (ftdi == NULL || ftdi->usb_dev == NULL)
4270 ftdi_error_return(-2, "USB device unavailable");
4271
579b006f 4272 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x43, (unsigned char *)&a, 2, ftdi->usb_read_timeout) == 2)
cb6250fa
TJ		 4273 {
4274 a = a << 8 | a >> 8;
579b006f 4275 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_IN_REQTYPE, SIO_READ_EEPROM_REQUEST, 0, 0x44, (unsigned char *)&b, 2, ftdi->usb_read_timeout) == 2)
cb6250fa
TJ		 4276 {
4277 b = b << 8 | b >> 8;
5230676f 4278 a = (a << 16) | (b & 0xFFFF);
912d50ca
TJ		 4279 a = ftdi_read_chipid_shift(a) | ftdi_read_chipid_shift(a>>8)<<8
4280 | ftdi_read_chipid_shift(a>>16)<<16 | ftdi_read_chipid_shift(a>>24)<<24;
cb6250fa 4281 *chipid = a ^ 0xa5f0f7d1;
c7eb3112 4282 return 0;
cb6250fa
TJ		 4283 }
4284 }
4285
c7eb3112 4286 ftdi_error_return(-1, "read of FTDIChip-ID failed");
cb6250fa
TJ		 4287}
4288
1941414d 4289/**
c1c70e13
OS		 4290 Write eeprom location
4291
4292 \param ftdi pointer to ftdi_context
4293 \param eeprom_addr Address of eeprom location to be written
4294 \param eeprom_val Value to be written
4295
4296 \retval 0: all fine
a661e3e4 4297 \retval -1: write failed
22a1b5c1 4298 \retval -2: USB device unavailable
a661e3e4
UB		 4299 \retval -3: Invalid access to checksum protected area below 0x80
4300 \retval -4: Device can't access unprotected area
4301 \retval -5: Reading chip type failed
c1c70e13 4302*/
56ac0383 4303int ftdi_write_eeprom_location(struct ftdi_context *ftdi, int eeprom_addr,
a661e3e4 4304 unsigned short eeprom_val)
c1c70e13 4305{
a661e3e4
UB		 4306 int chip_type_location;
4307 unsigned short chip_type;
4308
22a1b5c1
TJ		 4309 if (ftdi == NULL || ftdi->usb_dev == NULL)
4310 ftdi_error_return(-2, "USB device unavailable");
4311
56ac0383 4312 if (eeprom_addr <0x80)
a661e3e4
UB		 4313 ftdi_error_return(-2, "Invalid access to checksum protected area below 0x80");
4314
4315
4316 switch (ftdi->type)
4317 {
56ac0383
TJ		 4318 case TYPE_BM:
4319 case TYPE_2232C:
4320 chip_type_location = 0x14;
4321 break;
4322 case TYPE_2232H:
4323 case TYPE_4232H:
4324 chip_type_location = 0x18;
4325 break;
c7e4c09e
UB		 4326 case TYPE_232H:
4327 chip_type_location = 0x1e;
4328 break;
56ac0383
TJ		 4329 default:
4330 ftdi_error_return(-4, "Device can't access unprotected area");
a661e3e4
UB		 4331 }
4332
56ac0383 4333 if (ftdi_read_eeprom_location( ftdi, chip_type_location>>1, &chip_type))
a00c0a85 4334 ftdi_error_return(-5, "Reading failed");
56ac0383
TJ		 4335 fprintf(stderr," loc 0x%04x val 0x%04x\n", chip_type_location,chip_type);
4336 if ((chip_type & 0xff) != 0x66)
a661e3e4
UB		 4337 {
4338 ftdi_error_return(-6, "EEPROM is not of 93x66");
4339 }
4340
579b006f 4341 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
56ac0383
TJ		 4342 SIO_WRITE_EEPROM_REQUEST, eeprom_val, eeprom_addr,
4343 NULL, 0, ftdi->usb_write_timeout) != 0)
c1c70e13
OS		 4344 ftdi_error_return(-1, "unable to write eeprom");
4345
4346 return 0;
4347}
4348
4349/**
1941414d 4350 Write eeprom
a3da1d95 4351
1941414d 4352 \param ftdi pointer to ftdi_context
56ac0383 4353
1941414d
TJ		 4354 \retval 0: all fine
4355 \retval -1: read failed
22a1b5c1 4356 \retval -2: USB device unavailable
44f41f11 4357 \retval -3: EEPROM not initialized for the connected device;
1941414d 4358*/
a35aa9bd 4359int ftdi_write_eeprom(struct ftdi_context *ftdi)
a8f46ddc 4360{
ba5329be 4361 unsigned short usb_val, status;
e30da501 4362 int i, ret;
a35aa9bd 4363 unsigned char *eeprom;
a3da1d95 4364
22a1b5c1
TJ		 4365 if (ftdi == NULL || ftdi->usb_dev == NULL)
4366 ftdi_error_return(-2, "USB device unavailable");
44f41f11
UB		 4367
4368 if(ftdi->eeprom->initialized_for_connected_device == 0)
4369 ftdi_error_return(-3, "EEPROM not initialized for the connected device");
4370
a35aa9bd 4371 eeprom = ftdi->eeprom->buf;
22a1b5c1 4372
ba5329be 4373 /* These commands were traced while running MProg */
e30da501
TJ		 4374 if ((ret = ftdi_usb_reset(ftdi)) != 0)
4375 return ret;
4376 if ((ret = ftdi_poll_modem_status(ftdi, &status)) != 0)
4377 return ret;
4378 if ((ret = ftdi_set_latency_timer(ftdi, 0x77)) != 0)
4379 return ret;
ba5329be 4380
c0a96aed 4381 for (i = 0; i < ftdi->eeprom->size/2; i++)
22d12cda 4382 {
2f80efc2 4383 /* Do not try to write to reserved area */
74387f27
TJ		 4384 if ((ftdi->type == TYPE_230X) && (i == 0x40))
4385 {
2f80efc2
NP		 4386 i = 0x50;
4387 }
d9f0cce7
TJ		 4388 usb_val = eeprom[i*2];
4389 usb_val += eeprom[(i*2)+1] << 8;
579b006f
JZ		 4390 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
4391 SIO_WRITE_EEPROM_REQUEST, usb_val, i,
4392 NULL, 0, ftdi->usb_write_timeout) < 0)
c3d95b87 4393 ftdi_error_return(-1, "unable to write eeprom");
a3da1d95
GE		 4394 }
4395
4396 return 0;
4397}
4398
1941414d
TJ		 4399/**
4400 Erase eeprom
a3da1d95 4401
a5e1bd8c
MK		 4402 This is not supported on FT232R/FT245R according to the MProg manual from FTDI.
4403
1941414d
TJ		 4404 \param ftdi pointer to ftdi_context
4405
4406 \retval 0: all fine
4407 \retval -1: erase failed
22a1b5c1 4408 \retval -2: USB device unavailable
99404ad5
UB		 4409 \retval -3: Writing magic failed
4410 \retval -4: Read EEPROM failed
4411 \retval -5: Unexpected EEPROM value
1941414d 4412*/
99404ad5 4413#define MAGIC 0x55aa
a8f46ddc
TJ		 4414int ftdi_erase_eeprom(struct ftdi_context *ftdi)
4415{
99404ad5 4416 unsigned short eeprom_value;
22a1b5c1
TJ		 4417 if (ftdi == NULL || ftdi->usb_dev == NULL)
4418 ftdi_error_return(-2, "USB device unavailable");
4419
519bbce1 4420 if ((ftdi->type == TYPE_R) || (ftdi->type == TYPE_230X))
99404ad5
UB		 4421 {
4422 ftdi->eeprom->chip = 0;
4423 return 0;
4424 }
4425
56ac0383 4426 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
99404ad5 4427 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
c3d95b87 4428 ftdi_error_return(-1, "unable to erase eeprom");
a3da1d95 4429
56ac0383 4430
99404ad5
UB		 4431 /* detect chip type by writing 0x55AA as magic at word position 0xc0
4432 Chip is 93x46 if magic is read at word position 0x00, as wraparound happens around 0x40
4433 Chip is 93x56 if magic is read at word position 0x40, as wraparound happens around 0x80
4434 Chip is 93x66 if magic is only read at word position 0xc0*/
10186c1f 4435 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
56ac0383
TJ		 4436 SIO_WRITE_EEPROM_REQUEST, MAGIC, 0xc0,
4437 NULL, 0, ftdi->usb_write_timeout) != 0)
99404ad5 4438 ftdi_error_return(-3, "Writing magic failed");
56ac0383 4439 if (ftdi_read_eeprom_location( ftdi, 0x00, &eeprom_value))
a00c0a85 4440 ftdi_error_return(-4, "Reading failed");
56ac0383 4441 if (eeprom_value == MAGIC)
99404ad5
UB		 4442 {
4443 ftdi->eeprom->chip = 0x46;
4444 }
56ac0383 4445 else
99404ad5 4446 {
56ac0383 4447 if (ftdi_read_eeprom_location( ftdi, 0x40, &eeprom_value))
a00c0a85 4448 ftdi_error_return(-4, "Reading failed");
56ac0383 4449 if (eeprom_value == MAGIC)
99404ad5 4450 ftdi->eeprom->chip = 0x56;
56ac0383 4451 else
99404ad5 4452 {
56ac0383 4453 if (ftdi_read_eeprom_location( ftdi, 0xc0, &eeprom_value))
a00c0a85 4454 ftdi_error_return(-4, "Reading failed");
56ac0383 4455 if (eeprom_value == MAGIC)
99404ad5
UB		 4456 ftdi->eeprom->chip = 0x66;
4457 else
4458 {
4459 ftdi->eeprom->chip = -1;
4460 }
4461 }
4462 }
56ac0383 4463 if (libusb_control_transfer(ftdi->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_ERASE_EEPROM_REQUEST,
99404ad5
UB		 4464 0, 0, NULL, 0, ftdi->usb_write_timeout) < 0)
4465 ftdi_error_return(-1, "unable to erase eeprom");
a3da1d95
GE		 4466 return 0;
4467}
c3d95b87 4468
1941414d
TJ		 4469/**
4470 Get string representation for last error code
c3d95b87 4471
1941414d
TJ		 4472 \param ftdi pointer to ftdi_context
4473
4474 \retval Pointer to error string
4475*/
c3d95b87
TJ		 4476char *ftdi_get_error_string (struct ftdi_context *ftdi)
4477{
22a1b5c1
TJ		 4478 if (ftdi == NULL)
4479 return "";
4480
c3d95b87
TJ		 4481 return ftdi->error_str;
4482}
a01d31e2 4483
b5ec1820 4484/* @} end of doxygen libftdi group */
A library to talk to FTDI chips