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