git://developer.intra2net.com / libftdi / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Ignore patch files
[libftdi] / ftdi_eeprom / main.c
CommitLineData
e47d7975
TJ		 1/***************************************************************************
2 main.c - description
3 -------------------
4 begin : Mon Apr 7 12:05:22 CEST 2003
dcd7e8a3 5 copyright : (C) 2003-2014 by Intra2net AG and the libftdi developers
e47d7975 6 email : opensource@intra2net.com
5b110dec 7 SPDX-License-Identifier: GPL-2.0-only
e47d7975
TJ		 8 ***************************************************************************/
9
10/***************************************************************************
11 * *
12 * This program is free software; you can redistribute it and/or modify *
13 * it under the terms of the GNU General Public License version 2 as *
14 * published by the Free Software Foundation. *
15 * *
16 ***************************************************************************/
17
8a987aa2
TJ		 18/*
19 TODO:
8a987aa2
TJ		 20 - Merge Uwe's eeprom tool. Current features:
21 - Init eeprom defaults based upon eeprom type
22 - Read -> Already there
23 - Write -> Already there
24 - Erase -> Already there
25 - Decode on stdout
26 - Ability to find device by PID/VID, product name or serial
27
28 TODO nice-to-have:
29 - Out-of-the-box compatibility with FTDI's eeprom tool configuration files
30 */
31
e47d7975
TJ		 32#ifdef HAVE_CONFIG_H
33#include <config.h>
34#endif
35
36#include <stdlib.h>
37#include <stdio.h>
38#include <string.h>
701c887b 39#include <errno.h>
6e962b9a 40#include <sys/stat.h>
e47d7975
TJ		 41
42#include <confuse.h>
2e48e9fd 43#include <libusb.h>
e47d7975 44#include <ftdi.h>
ade814a5 45#include <ftdi_eeprom_version.h>
e47d7975 46
add00ad6 47static int parse_cbus(cfg_t *cfg, cfg_opt_t *opt, const char *value, void *result)
e47d7975 48{
add00ad6 49 static const char* options[] =
048eb722 50 {
add00ad6
RH		 51 "TXDEN", "PWREN", "RXLED", "TXLED", "TXRXLED", "SLEEP", "CLK48",
52 "CLK24", "CLK12", "CLK6", "IOMODE", "BB_WR", "BB_RD"
048eb722 53 };
add00ad6
RH		 54
55 int i;
56 for (i=0; i<sizeof(options)/sizeof(*options); i++)
57 {
58 if (!(strcmp(options[i], value)))
59 {
60 *(int *)result = i;
61 return 0;
62 }
63 }
64
65 cfg_error(cfg, "Invalid %s option '%s'", cfg_opt_name(opt), value);
66 return -1;
67}
68
c7db7f11
CL		 69static int parse_group0_drive(cfg_t *cfg, cfg_opt_t *opt, const char *value, void *result)
70{
71 static const char* options[] =
72 {
73 "4MA", "8MA", "12MA", "16MA"
74 };
75
76 int i;
77 for (i=0; i<sizeof(options)/sizeof(*options); i++)
78 {
79 if (!(strcasecmp(options[i], value)))
80 {
81 *(int *)result = i;
82 return 0;
83 }
84 }
85
86 cfg_error(cfg, "Invalid %s option '%s'", cfg_opt_name(opt), value);
87 return -1;
88}
89
add00ad6
RH		 90static int parse_cbush(cfg_t *cfg, cfg_opt_t *opt, const char *value, void *result)
91{
92 static const char* options[] =
93 {
94 "TRISTATE", "TXLED", "RXLED", "TXRXLED", "PWREN", "SLEEP",
95 "DRIVE_0", "DRIVE1", "IOMODE", "TXDEN", "CLK30", "CLK15", "CLK7_5"
96 };
97
98 int i;
99 for (i=0; i<sizeof(options)/sizeof(*options); i++)
100 {
101 if (!(strcmp(options[i], value)))
102 {
103 *(int *)result = i;
104 return 0;
105 }
106 }
107
108 cfg_error(cfg, "Invalid %s option '%s'", cfg_opt_name(opt), value);
109 return -1;
110}
111
112static int parse_cbusx(cfg_t *cfg, cfg_opt_t *opt, const char *value, void *result)
113{
114 static const char* options[] =
115 {
116 "TRISTATE", "TXLED", "RXLED", "TXRXLED", "PWREN", "SLEEP",
117 "DRIVE_0", "DRIVE1", "IOMODE", "TXDEN", "CLK24", "CLK12",
118 "CLK6", "BAT_DETECT", "BAT_DETECT_NEG", "I2C_TXE", "I2C_RXF", "VBUS_SENSE",
119 "BB_WR", "BB_RD", "TIME_STAMP", "AWAKE"
120 };
121
e47d7975 122 int i;
add00ad6 123 for (i=0; i<sizeof(options)/sizeof(*options); i++)
048eb722 124 {
add00ad6 125 if (!(strcmp(options[i], value)))
048eb722 126 {
add00ad6
RH		 127 *(int *)result = i;
128 return 0;
e47d7975
TJ		 129 }
130 }
add00ad6
RH		 131
132 cfg_error(cfg, "Invalid %s option '%s'", cfg_opt_name(opt), value);
133 return -1;
e47d7975
TJ		 134}
135
190fca12
SL		 136static int parse_chtype(cfg_t *cfg, cfg_opt_t *opt, const char *value, void *result)
137{
138 static const struct
139 {
140 char* key;
141 int opt;
142 } options[] =
143 {
144 { "UART", CHANNEL_IS_UART },
145 { "FIFO", CHANNEL_IS_FIFO },
146 { "OPTO", CHANNEL_IS_OPTO },
147 { "CPU", CHANNEL_IS_CPU },
148 { "FT1284", CHANNEL_IS_FT1284}
149 };
150
151 int i;
152 for (i=0; i<sizeof(options)/sizeof(*options); i++)
153 {
154 if (!(strcmp(options[i].key, value)))
155 {
156 *(int *)result = options[i].opt;
157 return 0;
158 }
159 }
160
161 cfg_error(cfg, "Invalid %s option '%s'", cfg_opt_name(opt), value);
162 return -1;
163}
164
d327f924
TJ		 165/**
166 * @brief Set eeprom value
167 *
168 * \param ftdi pointer to ftdi_context
169 * \param value_name Enum of the value to set
170 * \param value Value to set
171 *
172 * Function will abort the program on error
173 **/
174static void eeprom_set_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int value)
175{
176 if (ftdi_set_eeprom_value(ftdi, value_name, value) < 0)
177 {
178 printf("Unable to set eeprom value %d: %s. Aborting\n", value_name, ftdi_get_error_string(ftdi));
179 exit (-1);
180 }
181}
182
183/**
184 * @brief Get eeprom value
185 *
186 * \param ftdi pointer to ftdi_context
187 * \param value_name Enum of the value to get
188 * \param value Value to get
189 *
190 * Function will abort the program on error
191 **/
192static void eeprom_get_value(struct ftdi_context *ftdi, enum ftdi_eeprom_value value_name, int *value)
193{
194 if (ftdi_get_eeprom_value(ftdi, value_name, value) < 0)
195 {
196 printf("Unable to get eeprom value %d: %s. Aborting\n", value_name, ftdi_get_error_string(ftdi));
197 exit (-1);
198 }
199}
200
f6ac3c25
RH		 201static void usage(const char *program)
202{
203 fprintf(stderr, "Syntax: %s [...options...] <config-file>\n", program);
204 fprintf(stderr, "Valid Options:\n");
205 fprintf(stderr, "--device <description> Specify device to open by description string. One of:\n");
175c2a39 206 fprintf(stderr, " d:<device node>\n");
f6ac3c25
RH		 207 fprintf(stderr, " i:<vendor>:<product>\n");
208 fprintf(stderr, " i:<vendor>:<product>:<index>\n");
209 fprintf(stderr, " s:<vendor>:<product>:<serial>\n");
210 fprintf(stderr, "--read-eeprom Read eeprom and write to -filename- from config-file\n");
bc7a46d1 211 fprintf(stderr, "--build-eeprom Build eeprom image\n");
f6ac3c25
RH		 212 fprintf(stderr, "--erase-eeprom Erase eeprom\n");
213 fprintf(stderr, "--flash-eeprom Flash eeprom\n");
864bb3b9 214 fprintf(stderr, "--verbose Print more information\n");
f6ac3c25
RH		 215}
216
e47d7975
TJ		 217int main(int argc, char *argv[])
218{
219 /*
220 configuration options
221 */
222 cfg_opt_t opts[] =
223 {
224 CFG_INT("vendor_id", 0, 0),
225 CFG_INT("product_id", 0, 0),
226 CFG_BOOL("self_powered", cfg_true, 0),
227 CFG_BOOL("remote_wakeup", cfg_true, 0),
e47d7975
TJ		 228 CFG_BOOL("in_is_isochronous", cfg_false, 0),
229 CFG_BOOL("out_is_isochronous", cfg_false, 0),
230 CFG_BOOL("suspend_pull_downs", cfg_false, 0),
231 CFG_BOOL("use_serial", cfg_false, 0),
232 CFG_BOOL("change_usb_version", cfg_false, 0),
233 CFG_INT("usb_version", 0, 0),
89e7cfb5 234 CFG_INT("default_pid", 0x6001, 0),
e47d7975
TJ		 235 CFG_INT("max_power", 0, 0),
236 CFG_STR("manufacturer", "Acme Inc.", 0),
237 CFG_STR("product", "USB Serial Converter", 0),
238 CFG_STR("serial", "08-15", 0),
faa85774 239 CFG_INT("eeprom_type", 0x00, 0),
e47d7975
TJ		 240 CFG_STR("filename", "", 0),
241 CFG_BOOL("flash_raw", cfg_false, 0),
242 CFG_BOOL("high_current", cfg_false, 0),
add00ad6
RH		 243 CFG_INT_CB("cbus0", -1, 0, parse_cbus),
244 CFG_INT_CB("cbus1", -1, 0, parse_cbus),
245 CFG_INT_CB("cbus2", -1, 0, parse_cbus),
246 CFG_INT_CB("cbus3", -1, 0, parse_cbus),
247 CFG_INT_CB("cbus4", -1, 0, parse_cbus),
248 CFG_INT_CB("cbush0", -1, 0, parse_cbush),
249 CFG_INT_CB("cbush1", -1, 0, parse_cbush),
250 CFG_INT_CB("cbush2", -1, 0, parse_cbush),
251 CFG_INT_CB("cbush3", -1, 0, parse_cbush),
252 CFG_INT_CB("cbush4", -1, 0, parse_cbush),
253 CFG_INT_CB("cbush5", -1, 0, parse_cbush),
254 CFG_INT_CB("cbush6", -1, 0, parse_cbush),
255 CFG_INT_CB("cbush7", -1, 0, parse_cbush),
256 CFG_INT_CB("cbush8", -1, 0, parse_cbush),
257 CFG_INT_CB("cbush9", -1, 0, parse_cbush),
258 CFG_INT_CB("cbusx0", -1, 0, parse_cbusx),
259 CFG_INT_CB("cbusx1", -1, 0, parse_cbusx),
260 CFG_INT_CB("cbusx2", -1, 0, parse_cbusx),
261 CFG_INT_CB("cbusx3", -1, 0, parse_cbusx),
c7db7f11 262 CFG_INT_CB("group0_drive", -1, 0, parse_group0_drive),
e47d7975
TJ		 263 CFG_BOOL("invert_txd", cfg_false, 0),
264 CFG_BOOL("invert_rxd", cfg_false, 0),
265 CFG_BOOL("invert_rts", cfg_false, 0),
266 CFG_BOOL("invert_cts", cfg_false, 0),
267 CFG_BOOL("invert_dtr", cfg_false, 0),
268 CFG_BOOL("invert_dsr", cfg_false, 0),
269 CFG_BOOL("invert_dcd", cfg_false, 0),
270 CFG_BOOL("invert_ri", cfg_false, 0),
190fca12
SL		 271 CFG_INT_CB("cha_type", -1, 0, parse_chtype),
272 CFG_INT_CB("chb_type", -1, 0, parse_chtype),
273 CFG_BOOL("cha_vcp", cfg_true, 0),
274 CFG_BOOL("chb_vcp", cfg_true, 0),
275 CFG_BOOL("chc_vcp", cfg_true, 0),
276 CFG_BOOL("chd_vcp", cfg_true, 0),
277 CFG_BOOL("cha_rs485", cfg_false, 0),
278 CFG_BOOL("chb_rs485", cfg_false, 0),
279 CFG_BOOL("chc_rs485", cfg_false, 0),
280 CFG_BOOL("chd_rs485", cfg_false, 0),
a0763384 281 CFG_FUNC("include", &cfg_include),
6e962b9a
SET		 282 CFG_INT("user_data_addr", 0x18, 0),
283 CFG_STR("user_data_file", "", 0),
e47d7975
TJ		 284 CFG_END()
285 };
286 cfg_t *cfg;
287
288 /*
289 normal variables
290 */
f6ac3c25
RH		 291 enum {
292 COMMAND_READ = 1,
293 COMMAND_ERASE,
bc7a46d1
SET		 294 COMMAND_FLASH,
295 COMMAND_BUILD
f6ac3c25
RH		 296 } command = 0;
297 const char *cfg_filename = NULL;
298 const char *device_description = NULL;
6e962b9a
SET		 299 const char *user_data_file = NULL;
300 char *user_data_buffer = NULL;
200bd3ed 301
faa85774 302 const int max_eeprom_size = 256;
785ddbca 303 int my_eeprom_size = 0;
4359228a 304 unsigned char *eeprom_buf = NULL;
e47d7975
TJ		 305 char *filename;
306 int size_check;
f6ac3c25 307 int i;
e47d7975
TJ		 308 FILE *fp;
309
864bb3b9
H		 310 int verbose=0;
311
de4871c4 312 struct ftdi_context *ftdi = NULL;
e47d7975 313
ade814a5 314 printf("\nFTDI eeprom generator v%s\n", EEPROM_VERSION_STRING);
8a987aa2 315 printf ("(c) Intra2net AG and the libftdi developers <opensource@intra2net.com>\n");
e47d7975 316
f6ac3c25
RH		 317 for (i = 1; i < argc; i++) {
318 if (*argv[i] != '-')
319 {
320 cfg_filename = argv[i];
321 }
322 else if (!strcmp(argv[i], "--device"))
323 {
324 if (i+1 >= argc)
325 {
326 usage(argv[0]);
327 exit(-1);
328 }
329 device_description = argv[++i];
330 }
331 else if (!strcmp(argv[i], "--read-eeprom"))
332 {
333 command = COMMAND_READ;
334 }
335 else if (!strcmp(argv[i], "--erase-eeprom"))
336 {
337 command = COMMAND_ERASE;
338 }
339 else if (!strcmp(argv[i], "--flash-eeprom"))
340 {
341 command = COMMAND_FLASH;
342 }
bc7a46d1
SET		 343 else if (!strcmp(argv[i], "--build-eeprom"))
344 {
345 command = COMMAND_BUILD;
346 }
864bb3b9
H		 347 else if (!strcmp(argv[i], "--verbose"))
348 {
349 verbose = 1;
350 }
94c637b8
UB		 351 else
352 {
f6ac3c25
RH		 353 usage(argv[0]);
354 exit(-1);
94c637b8 355 }
e47d7975 356 }
f6ac3c25
RH		 357
358 if (!cfg_filename)
e47d7975 359 {
f6ac3c25
RH		 360 usage(argv[0]);
361 exit(-1);
e47d7975
TJ		 362 }
363
f6ac3c25 364 if ((fp = fopen(cfg_filename, "r")) == NULL)
e47d7975
TJ		 365 {
366 printf ("Can't open configuration file\n");
367 exit (-1);
368 }
369 fclose (fp);
370
371 cfg = cfg_init(opts, 0);
f6ac3c25 372 cfg_parse(cfg, cfg_filename);
e47d7975
TJ		 373 filename = cfg_getstr(cfg, "filename");
374
375 if (cfg_getbool(cfg, "self_powered") && cfg_getint(cfg, "max_power") > 0)
376 printf("Hint: Self powered devices should have a max_power setting of 0.\n");
377
de4871c4
TJ		 378 if ((ftdi = ftdi_new()) == 0)
379 {
380 fprintf(stderr, "Failed to allocate ftdi structure :%s \n",
381 ftdi_get_error_string(ftdi));
382 return EXIT_FAILURE;
383 }
384
f6ac3c25
RH		 385 if (device_description != NULL)
386 {
387 i = ftdi_usb_open_string(ftdi, device_description);
388
389 if (i != 0)
390 {
391 printf("Unable to find FTDI device with description: %s\n",
392 device_description);
393 printf("Error code: %d (%s)\n", i, ftdi_get_error_string(ftdi));
394 exit (-1);
395 }
396 }
397 else if (command > 0)
e47d7975 398 {
7bdae7cd
UB		 399 int vendor_id = cfg_getint(cfg, "vendor_id");
400 int product_id = cfg_getint(cfg, "product_id");
d327f924
TJ		 401
402 i = ftdi_usb_open(ftdi, vendor_id, product_id);
e47d7975 403
e8d32978 404 if (i != 0)
e47d7975 405 {
89e7cfb5 406 int default_pid = cfg_getint(cfg, "default_pid");
d327f924 407 printf("Unable to find FTDI devices under given vendor/product id: 0x%X/0x%X\n", vendor_id, product_id);
de4871c4 408 printf("Error code: %d (%s)\n", i, ftdi_get_error_string(ftdi));
89e7cfb5 409 printf("Retrying with default FTDI pid=%#04x.\n", default_pid);
e47d7975 410
89e7cfb5 411 i = ftdi_usb_open(ftdi, 0x0403, default_pid);
e47d7975
TJ		 412 if (i != 0)
413 {
de4871c4 414 printf("Error: %s\n", ftdi->error_str);
e47d7975
TJ		 415 exit (-1);
416 }
417 }
418 }
048eb722
TJ		 419 ftdi_eeprom_initdefaults (ftdi, cfg_getstr(cfg, "manufacturer"),
420 cfg_getstr(cfg, "product"),
e8d32978 421 cfg_getstr(cfg, "serial"));
faa85774 422
e8d32978
UB		 423 printf("FTDI read eeprom: %d\n", ftdi_read_eeprom(ftdi));
424 eeprom_get_value(ftdi, CHIP_SIZE, &my_eeprom_size);
e8d32978 425 printf("EEPROM size: %d\n", my_eeprom_size);
faa85774 426
f6ac3c25 427 if (command == COMMAND_READ)
e47d7975 428 {
864bb3b9 429 ftdi_eeprom_decode(ftdi, verbose);
e47d7975 430
4359228a
UB		 431 eeprom_buf = malloc(my_eeprom_size);
432 ftdi_get_eeprom_buf(ftdi, eeprom_buf, my_eeprom_size);
433
434 if (eeprom_buf == NULL)
435 {
436 fprintf(stderr, "Malloc failed, aborting\n");
437 goto cleanup;
438 }
e47d7975
TJ		 439 if (filename != NULL && strlen(filename) > 0)
440 {
441 FILE *fp = fopen (filename, "wb");
701c887b
TS		 442
443 if(fp)
444 {
445 fwrite(eeprom_buf, 1, my_eeprom_size, fp);
446 fclose(fp);
447 }
448 else
449 fprintf(stderr, "Could not open output file %s: %s\n", filename, strerror(errno));
e47d7975
TJ		 450 }
451 else
452 {
453 printf("Warning: Not writing eeprom, you must supply a valid filename\n");
454 }
455
456 goto cleanup;
457 }
458
7bdae7cd
UB		 459 eeprom_set_value(ftdi, VENDOR_ID, cfg_getint(cfg, "vendor_id"));
460 eeprom_set_value(ftdi, PRODUCT_ID, cfg_getint(cfg, "product_id"));
461
7bdae7cd
UB		 462 eeprom_set_value(ftdi, SELF_POWERED, cfg_getbool(cfg, "self_powered"));
463 eeprom_set_value(ftdi, REMOTE_WAKEUP, cfg_getbool(cfg, "remote_wakeup"));
464 eeprom_set_value(ftdi, MAX_POWER, cfg_getint(cfg, "max_power"));
465
466 eeprom_set_value(ftdi, IN_IS_ISOCHRONOUS, cfg_getbool(cfg, "in_is_isochronous"));
467 eeprom_set_value(ftdi, OUT_IS_ISOCHRONOUS, cfg_getbool(cfg, "out_is_isochronous"));
468 eeprom_set_value(ftdi, SUSPEND_PULL_DOWNS, cfg_getbool(cfg, "suspend_pull_downs"));
469
470 eeprom_set_value(ftdi, USE_SERIAL, cfg_getbool(cfg, "use_serial"));
471 eeprom_set_value(ftdi, USE_USB_VERSION, cfg_getbool(cfg, "change_usb_version"));
472 eeprom_set_value(ftdi, USB_VERSION, cfg_getint(cfg, "usb_version"));
faa85774 473 eeprom_set_value(ftdi, CHIP_TYPE, cfg_getint(cfg, "eeprom_type"));
7bdae7cd
UB		 474
475 eeprom_set_value(ftdi, HIGH_CURRENT, cfg_getbool(cfg, "high_current"));
add00ad6
RH		 476
477 if (ftdi->type == TYPE_R)
478 {
479 if (cfg_getint(cfg, "cbus0") != -1)
480 eeprom_set_value(ftdi, CBUS_FUNCTION_0, cfg_getint(cfg, "cbus0"));
481 if (cfg_getint(cfg, "cbus1") != -1)
482 eeprom_set_value(ftdi, CBUS_FUNCTION_1, cfg_getint(cfg, "cbus1"));
483 if (cfg_getint(cfg, "cbus2") != -1)
484 eeprom_set_value(ftdi, CBUS_FUNCTION_2, cfg_getint(cfg, "cbus2"));
485 if (cfg_getint(cfg, "cbus3") != -1)
486 eeprom_set_value(ftdi, CBUS_FUNCTION_3, cfg_getint(cfg, "cbus3"));
487 if (cfg_getint(cfg, "cbus4") != -1)
488 eeprom_set_value(ftdi, CBUS_FUNCTION_4, cfg_getint(cfg, "cbus4"));
489 }
490 else if (ftdi->type == TYPE_232H)
491 {
492 if (cfg_getint(cfg, "cbush0") != -1)
493 eeprom_set_value(ftdi, CBUS_FUNCTION_0, cfg_getint(cfg, "cbush0"));
494 if (cfg_getint(cfg, "cbush1") != -1)
495 eeprom_set_value(ftdi, CBUS_FUNCTION_1, cfg_getint(cfg, "cbush1"));
496 if (cfg_getint(cfg, "cbush2") != -1)
497 eeprom_set_value(ftdi, CBUS_FUNCTION_2, cfg_getint(cfg, "cbush2"));
498 if (cfg_getint(cfg, "cbush3") != -1)
499 eeprom_set_value(ftdi, CBUS_FUNCTION_3, cfg_getint(cfg, "cbush3"));
500 if (cfg_getint(cfg, "cbush4") != -1)
501 eeprom_set_value(ftdi, CBUS_FUNCTION_4, cfg_getint(cfg, "cbush4"));
502 if (cfg_getint(cfg, "cbush5") != -1)
503 eeprom_set_value(ftdi, CBUS_FUNCTION_5, cfg_getint(cfg, "cbush5"));
504 if (cfg_getint(cfg, "cbush6") != -1)
505 eeprom_set_value(ftdi, CBUS_FUNCTION_6, cfg_getint(cfg, "cbush6"));
506 if (cfg_getint(cfg, "cbush7") != -1)
507 eeprom_set_value(ftdi, CBUS_FUNCTION_7, cfg_getint(cfg, "cbush7"));
508 if (cfg_getint(cfg, "cbush8") != -1)
509 eeprom_set_value(ftdi, CBUS_FUNCTION_8, cfg_getint(cfg, "cbush8"));
510 if (cfg_getint(cfg, "cbush9") != -1)
511 eeprom_set_value(ftdi, CBUS_FUNCTION_9, cfg_getint(cfg, "cbush9"));
c7db7f11
CL		 512 if (cfg_getint(cfg, "group0_drive") != -1)
513 eeprom_set_value(ftdi, GROUP0_DRIVE, cfg_getint(cfg, "group0_drive"));
add00ad6
RH		 514 }
515 else if (ftdi->type == TYPE_230X)
516 {
517 if (cfg_getint(cfg, "cbusx0") != -1)
518 eeprom_set_value(ftdi, CBUS_FUNCTION_0, cfg_getint(cfg, "cbusx0"));
519 if (cfg_getint(cfg, "cbusx1") != -1)
520 eeprom_set_value(ftdi, CBUS_FUNCTION_1, cfg_getint(cfg, "cbusx1"));
521 if (cfg_getint(cfg, "cbusx2") != -1)
522 eeprom_set_value(ftdi, CBUS_FUNCTION_2, cfg_getint(cfg, "cbusx2"));
523 if (cfg_getint(cfg, "cbusx3") != -1)
524 eeprom_set_value(ftdi, CBUS_FUNCTION_3, cfg_getint(cfg, "cbusx3"));
525 }
526
7bdae7cd
UB		 527 int invert = 0;
528 if (cfg_getbool(cfg, "invert_rxd")) invert |= INVERT_RXD;
529 if (cfg_getbool(cfg, "invert_txd")) invert |= INVERT_TXD;
530 if (cfg_getbool(cfg, "invert_rts")) invert |= INVERT_RTS;
531 if (cfg_getbool(cfg, "invert_cts")) invert |= INVERT_CTS;
532 if (cfg_getbool(cfg, "invert_dtr")) invert |= INVERT_DTR;
533 if (cfg_getbool(cfg, "invert_dsr")) invert |= INVERT_DSR;
534 if (cfg_getbool(cfg, "invert_dcd")) invert |= INVERT_DCD;
535 if (cfg_getbool(cfg, "invert_ri")) invert |= INVERT_RI;
536 eeprom_set_value(ftdi, INVERT, invert);
537
190fca12
SL		 538 if (cfg_getint(cfg, "cha_type") != -1)
539 eeprom_set_value(ftdi, CHANNEL_A_TYPE, cfg_getint(cfg, "cha_type"));
540 if (cfg_getint(cfg, "chb_type") != -1)
541 eeprom_set_value(ftdi, CHANNEL_B_TYPE, cfg_getint(cfg, "chb_type"));
542
543 eeprom_set_value(ftdi, CHANNEL_A_DRIVER,
544 cfg_getbool(cfg, "cha_vcp") ? DRIVER_VCP : 0);
545 eeprom_set_value(ftdi, CHANNEL_B_DRIVER,
546 cfg_getbool(cfg, "chb_vcp") ? DRIVER_VCP : 0);
547 eeprom_set_value(ftdi, CHANNEL_C_DRIVER,
548 cfg_getbool(cfg, "chc_vcp") ? DRIVER_VCP : 0);
549 eeprom_set_value(ftdi, CHANNEL_D_DRIVER,
550 cfg_getbool(cfg, "chd_vcp") ? DRIVER_VCP : 0);
551
552 eeprom_set_value(ftdi, CHANNEL_A_RS485, cfg_getbool(cfg, "cha_rs485"));
553 eeprom_set_value(ftdi, CHANNEL_B_RS485, cfg_getbool(cfg, "chb_rs485"));
554 eeprom_set_value(ftdi, CHANNEL_C_RS485, cfg_getbool(cfg, "chc_rs485"));
555 eeprom_set_value(ftdi, CHANNEL_D_RS485, cfg_getbool(cfg, "chd_rs485"));
be4bae37 556
6e962b9a
SET		 557 /* Arbitrary user data */
558 eeprom_set_value(ftdi, USER_DATA_ADDR, cfg_getint(cfg, "user_data_addr"));
559 user_data_file = cfg_getstr(cfg, "user_data_file");
560 if (user_data_file && strlen(user_data_file) > 0)
561 {
562 int data_size;
563 struct stat st;
564
565 printf("User data file: %s\n", user_data_file);
566 /* Allocate a buffer for the user data */
567 user_data_buffer = (char *)malloc(max_eeprom_size);
568 if (user_data_buffer == NULL)
569 {
570 fprintf(stderr, "Malloc failed, aborting\n");
571 goto cleanup;
572 }
573
574 if (stat(user_data_file, &st))
575 {
576 printf ("Can't stat user data file %s.\n", user_data_file);
577 exit (-1);
578 }
579 if (st.st_size > max_eeprom_size)
580 printf("Warning: %s is too big, only reading %d bytes\n",
581 user_data_file, max_eeprom_size);
582 /* Read the user data file, no more than max_eeprom_size bytes */
583 FILE *fp = fopen(user_data_file, "rb");
584 if (fp == NULL)
585 {
586 printf ("Can't open user data file %s.\n", user_data_file);
587 exit (-1);
588 }
589 data_size = fread(user_data_buffer, 1, max_eeprom_size, fp);
590 fclose(fp);
591 if (data_size < 1)
592 {
593 printf ("Can't read user data file %s.\n", user_data_file);
594 exit (-1);
595 }
596 printf("User data size: %d\n", data_size);
597
598 ftdi_set_eeprom_user_data(ftdi, user_data_buffer, data_size);
599 }
600
601
f6ac3c25 602 if (command == COMMAND_ERASE)
e47d7975 603 {
de4871c4 604 printf("FTDI erase eeprom: %d\n", ftdi_erase_eeprom(ftdi));
e47d7975
TJ		 605 }
606
de4871c4 607 size_check = ftdi_eeprom_build(ftdi);
faa85774 608 eeprom_get_value(ftdi, CHIP_SIZE, &my_eeprom_size);
e47d7975
TJ		 609
610 if (size_check == -1)
611 {
6e962b9a 612 printf ("Sorry, the eeprom can only contain %d bytes.\n", my_eeprom_size);
e47d7975 613 goto cleanup;
048eb722
TJ		 614 }
615 else if (size_check < 0)
616 {
e47d7975 617 printf ("ftdi_eeprom_build(): error: %d\n", size_check);
f6ac3c25 618 goto cleanup;
e47d7975
TJ		 619 }
620 else
621 {
200bd3ed 622 printf ("Used eeprom space: %d bytes\n", my_eeprom_size-size_check);
e47d7975
TJ		 623 }
624
f6ac3c25 625 if (command == COMMAND_FLASH)
e47d7975
TJ		 626 {
627 if (cfg_getbool(cfg, "flash_raw"))
628 {
629 if (filename != NULL && strlen(filename) > 0)
630 {
faa85774 631 eeprom_buf = malloc(max_eeprom_size);
e47d7975 632 FILE *fp = fopen(filename, "rb");
faa85774
AL		 633 if (fp == NULL)
634 {
635 printf ("Can't open eeprom file %s.\n", filename);
636 exit (-1);
637 }
638 my_eeprom_size = fread(eeprom_buf, 1, max_eeprom_size, fp);
e47d7975 639 fclose(fp);
faa85774
AL		 640 if (my_eeprom_size < 128)
641 {
642 printf ("Can't read eeprom file %s.\n", filename);
643 exit (-1);
644 }
200bd3ed 645
23d7ac2b
TJ		 646 printf("Flashing raw eeprom from file %s (%d bytes)\n",
647 filename, my_eeprom_size);
648
98c974c7 649 ftdi_set_eeprom_buf(ftdi, eeprom_buf, my_eeprom_size);
23d7ac2b
TJ		 650 } else
651 {
652 printf ("ERROR: flash_raw mode enabled, but no eeprom filename "
653 "given in config file.\n");
654 exit (-1);
e47d7975
TJ		 655 }
656 }
de4871c4 657 printf ("FTDI write eeprom: %d\n", ftdi_write_eeprom(ftdi));
2e48e9fd 658 libusb_reset_device(ftdi->usb_dev);
e47d7975
TJ		 659 }
660
661 // Write to file?
643a89ea 662 if (filename != NULL && strlen(filename) > 0 && !cfg_getbool(cfg, "flash_raw"))
e47d7975
TJ		 663 {
664 fp = fopen(filename, "w");
665 if (fp == NULL)
666 {
667 printf ("Can't write eeprom file.\n");
668 exit (-1);
669 }
670 else
671 printf ("Writing to file: %s\n", filename);
672
243f5f66
AL		 673 if (eeprom_buf == NULL)
674 eeprom_buf = malloc(my_eeprom_size);
200bd3ed
TJ		 675 ftdi_get_eeprom_buf(ftdi, eeprom_buf, my_eeprom_size);
676
677 fwrite(eeprom_buf, my_eeprom_size, 1, fp);
e47d7975
TJ		 678 fclose(fp);
679 }
680
681cleanup:
4359228a
UB		 682 if (eeprom_buf)
683 free(eeprom_buf);
6e962b9a
SET		 684 if (user_data_buffer)
685 free(user_data_buffer);
f6ac3c25 686 if (command > 0)
e47d7975 687 {
de4871c4 688 printf("FTDI close: %d\n", ftdi_usb_close(ftdi));
e47d7975
TJ		 689 }
690
de4871c4 691 ftdi_deinit (ftdi);
4e494b76 692 ftdi_free (ftdi);
e47d7975
TJ		 693
694 cfg_free(cfg);
695
696 printf("\n");
697 return 0;
698}
A library to talk to FTDI chips