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