int main(int argc, char **argv)
{
- struct ftdi_context ftdic;
+ struct ftdi_context *ftdi;
int i, t;
unsigned char *txbuf;
unsigned char *rxbuf;
return EXIT_FAILURE;
}
- if (ftdi_init(&ftdic) < 0)
+ if ((ftdi = ftdi_new()) == 0)
{
- fprintf(stderr, "ftdi_init failed\n");
+ fprintf(stderr, "ftdi_new failed\n");
retval = EXIT_FAILURE;
goto done;
}
- if (ftdi_usb_open_string(&ftdic, devicedesc) < 0)
+ if (ftdi_usb_open_string(ftdi, devicedesc) < 0)
{
- fprintf(stderr,"Can't open ftdi device: %s\n",ftdi_get_error_string(&ftdic));
+ fprintf(stderr,"Can't open ftdi device: %s\n",ftdi_get_error_string(ftdi));
retval = EXIT_FAILURE;
goto do_deinit;
}
set_baud=baud/16;
}
- ftdi_set_baudrate(&ftdic,set_baud);
- printf("real baudrate used: %d\n",(test_mode==BITMODE_RESET) ? ftdic.baudrate : ftdic.baudrate*16);
+ ftdi_set_baudrate(ftdi,set_baud);
+ printf("real baudrate used: %d\n",(test_mode==BITMODE_RESET) ? ftdi->baudrate : ftdi->baudrate*16);
- if (ftdi_set_bitmode(&ftdic, 0xFF,test_mode) < 0)
+ if (ftdi_set_bitmode(ftdi, 0xFF,test_mode) < 0)
{
- fprintf(stderr,"Can't set mode: %s\n",ftdi_get_error_string(&ftdic));
+ fprintf(stderr,"Can't set mode: %s\n",ftdi_get_error_string(ftdi));
retval = EXIT_FAILURE;
goto do_close;
}
txbuf[i]=(i%2) ? 0xff : 0;
}
- if (ftdi_write_data_set_chunksize(&ftdic, txchunksize) < 0 ||
- ftdi_read_data_set_chunksize(&ftdic, txchunksize) < 0)
+ if (ftdi_write_data_set_chunksize(ftdi, txchunksize) < 0 ||
+ ftdi_read_data_set_chunksize(ftdi, txchunksize) < 0)
{
- fprintf(stderr,"Can't set chunksize: %s\n",ftdi_get_error_string(&ftdic));
+ fprintf(stderr,"Can't set chunksize: %s\n",ftdi_get_error_string(ftdi));
retval = EXIT_FAILURE;
goto do_close;
}
if (test_mode==BITMODE_SYNCBB)
{
// completely clear the receive buffer before beginning
- while (ftdi_read_data(&ftdic, rxbuf, txchunksize)>0);
+ while (ftdi_read_data(ftdi, rxbuf, txchunksize)>0);
}
start=get_prec_time();
// don't wait for more data to arrive, take what we get and keep on sending
// yes, we really would like to have libusb 1.0+ with async read/write...
- ftdic.usb_read_timeout=1;
+ ftdi->usb_read_timeout=1;
i=0;
while (i < datasize)
if (i+sendsize > datasize)
sendsize=datasize-i;
- if ((sendsize=ftdi_write_data(&ftdic, txbuf, sendsize)) < 0)
+ if ((sendsize=ftdi_write_data(ftdi, txbuf, sendsize)) < 0)
{
fprintf(stderr,"write failed at %d: %s\n",
- i, ftdi_get_error_string(&ftdic));
+ i, ftdi_get_error_string(ftdi));
retval = EXIT_FAILURE;
goto do_close;
}
if (test_mode==BITMODE_SYNCBB)
{
// read the same amount of data as sent
- ftdi_read_data(&ftdic, rxbuf, sendsize);
+ ftdi_read_data(ftdi, rxbuf, sendsize);
}
}
duration=get_prec_time()-start;
printf("and took %.4f seconds, this is %.0f baud or factor %.3f\n",duration,(plan*baud)/duration,plan/duration);
do_close:
- ftdi_usb_close(&ftdic);
+ ftdi_usb_close(ftdi);
do_deinit:
- ftdi_deinit(&ftdic);
+ ftdi_free(ftdi);
done:
if(rxbuf)
free(rxbuf);
int main(int argc, char **argv)
{
- struct ftdi_context ftdic;
+ struct ftdi_context *ftdi;
int f,i;
unsigned char buf[1];
int retval = 0;
- if (ftdi_init(&ftdic) < 0)
+ if ((ftdi = ftdi_new()) == 0)
{
- fprintf(stderr, "ftdi_init failed\n");
+ fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
- f = ftdi_usb_open(&ftdic, 0x0403, 0x6001);
+ f = ftdi_usb_open(ftdi, 0x0403, 0x6001);
if (f < 0 && f != -5)
{
- fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(&ftdic));
+ fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi));
retval = 1;
goto done;
}
printf("ftdi open succeeded: %d\n",f);
printf("enabling bitbang mode\n");
- ftdi_set_bitmode(&ftdic, 0xFF, BITMODE_BITBANG);
+ ftdi_set_bitmode(ftdi, 0xFF, BITMODE_BITBANG);
sleep(3);
buf[0] = 0x0;
printf("turning everything on\n");
- f = ftdi_write_data(&ftdic, buf, 1);
+ f = ftdi_write_data(ftdi, buf, 1);
if (f < 0)
{
- fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, ftdi_get_error_string(&ftdic));
+ fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, ftdi_get_error_string(ftdi));
}
sleep(3);
buf[0] = 0xFF;
printf("turning everything off\n");
- f = ftdi_write_data(&ftdic, buf, 1);
+ f = ftdi_write_data(ftdi, buf, 1);
if (f < 0)
{
- fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, ftdi_get_error_string(&ftdic));
+ fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, ftdi_get_error_string(ftdi));
}
sleep(3);
}
printf("%02hhx ",buf[0]);
fflush(stdout);
- f = ftdi_write_data(&ftdic, buf, 1);
+ f = ftdi_write_data(ftdi, buf, 1);
if (f < 0)
{
- fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, ftdi_get_error_string(&ftdic));
+ fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, ftdi_get_error_string(ftdi));
}
sleep(1);
}
printf("\n");
printf("disabling bitbang mode\n");
- ftdi_disable_bitbang(&ftdic);
+ ftdi_disable_bitbang(ftdi);
- ftdi_usb_close(&ftdic);
+ ftdi_usb_close(ftdi);
done:
- ftdi_deinit(&ftdic);
+ ftdi_free(ftdi);
return retval;
}
int main(int argc, char **argv)
{
- struct ftdi_context ftdic;
+ struct ftdi_context *ftdi;
int i, t;
unsigned char data;
int delay = 100000; /* 100 thousand microseconds: 1 tenth of a second */
}
}
- if (ftdi_init(&ftdic) < 0)
+ if ((ftdi = ftdi_new()) == 0)
{
- fprintf(stderr, "ftdi_init failed\n");
- ftdi_deinit(&ftdic);
+ fprintf(stderr, "ftdi_bew failed\n");
return EXIT_FAILURE;
}
- if (ftdi_usb_open(&ftdic, 0x0403, 0x6001) < 0)
- ftdi_fatal (&ftdic, "Can't open ftdi device");
+ if (ftdi_usb_open(ftdi, 0x0403, 0x6001) < 0)
+ ftdi_fatal (ftdi, "Can't open ftdi device");
- if (ftdi_set_bitmode(&ftdic, 0xFF, BITMODE_BITBANG) < 0)
- ftdi_fatal (&ftdic, "Can't enable bitbang");
+ if (ftdi_set_bitmode(ftdi, 0xFF, BITMODE_BITBANG) < 0)
+ ftdi_fatal (ftdi, "Can't enable bitbang");
for (i=optind; i < argc ; i++)
{
sscanf (argv[i], "%x", &t);
data = t;
- if (ftdi_write_data(&ftdic, &data, 1) < 0)
+ if (ftdi_write_data(ftdi, &data, 1) < 0)
{
fprintf(stderr,"write failed for 0x%x: %s\n",
- data, ftdi_get_error_string(&ftdic));
+ data, ftdi_get_error_string(ftdi));
}
usleep(delay);
}
- ftdi_usb_close(&ftdic);
- ftdi_deinit(&ftdic);
+ ftdi_usb_close(ftdi);
+ ftdi_free(ftdi);
exit (0);
}
int main(void)
{
- struct ftdi_context ftdic;
+ struct ftdi_context *ftdi;
int f;
unsigned char buf[1];
unsigned char bitmask;
char input[10];
int retval = 0;
- if (ftdi_init(&ftdic) < 0)
+ if ((ftdi = ftdi_new()) == 0)
{
- fprintf(stderr, "ftdi_init failed\n");
+ fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
- f = ftdi_usb_open(&ftdic, 0x0403, 0x6001);
+ f = ftdi_usb_open(ftdi, 0x0403, 0x6001);
if (f < 0 && f != -5)
{
- fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(&ftdic));
- ftdi_deinit(&ftdic);
+ fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi));
+ ftdi_deinit(ftdi);
exit(-1);
}
printf("ftdi open succeeded: %d\n",f);
if (input[0] == '\n') break;
bitmask = strtol(input, NULL, 0);
printf("Using bitmask 0x%02x\n", bitmask);
- f = ftdi_set_bitmode(&ftdic, bitmask, BITMODE_CBUS);
+ f = ftdi_set_bitmode(ftdi, bitmask, BITMODE_CBUS);
if (f < 0)
{
- fprintf(stderr, "set_bitmode failed for 0x%x, error %d (%s)\n", bitmask, f, ftdi_get_error_string(&ftdic));
- ftdi_usb_close(&ftdic);
- ftdi_deinit(&ftdic);
+ fprintf(stderr, "set_bitmode failed for 0x%x, error %d (%s)\n", bitmask, f, ftdi_get_error_string(ftdi));
+ ftdi_usb_close(ftdi);
+ ftdi_deinit(ftdi);
retval = -1;
}
// read CBUS
- f = ftdi_read_pins(&ftdic, &buf[0]);
+ f = ftdi_read_pins(ftdi, &buf[0]);
if (f < 0)
{
- fprintf(stderr, "read_pins failed, error %d (%s)\n", f, ftdi_get_error_string(&ftdic));
- ftdi_usb_close(&ftdic);
- ftdi_deinit(&ftdic);
+ fprintf(stderr, "read_pins failed, error %d (%s)\n", f, ftdi_get_error_string(ftdi));
+ ftdi_usb_close(ftdi);
+ ftdi_deinit(ftdi);
exit(-1);
}
printf("Read returned 0x%01x\n", buf[0] & 0x0f);
}
printf("disabling bitbang mode\n");
- ftdi_disable_bitbang(&ftdic);
+ ftdi_disable_bitbang(ftdi);
- ftdi_usb_close(&ftdic);
- ftdi_deinit(&ftdic);
+ ftdi_usb_close(ftdi);
+ ftdi_free(ftdi);
return 0;
}
int main(int argc, char **argv)
{
- struct ftdi_context ftdic, ftdic2;
+ struct ftdi_context *ftdi, *ftdi2;
unsigned char buf[1];
int f,i;
// Init 1. channel
- if (ftdi_init(&ftdic) < 0)
+ if ((ftdi = ftdi_new()) == 0)
{
- fprintf(stderr, "ftdi_init failed\n");
+ fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
- ftdi_set_interface(&ftdic, INTERFACE_A);
- f = ftdi_usb_open(&ftdic, 0x0403, 0x6001);
+ ftdi_set_interface(ftdi, INTERFACE_A);
+ f = ftdi_usb_open(ftdi, 0x0403, 0x6001);
if (f < 0 && f != -5)
{
- fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(&ftdic));
- ftdi_deinit(&ftdic);
+ fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi));
+ ftdi_deinit(ftdi);
exit(-1);
}
printf("ftdi open succeeded(channel 1): %d\n",f);
printf("enabling bitbang mode(channel 1)\n");
- ftdi_set_bitmode(&ftdic, 0xFF, BITMODE_BITBANG);
+ ftdi_set_bitmode(ftdi, 0xFF, BITMODE_BITBANG);
// Init 2. channel
- if (ftdi_init(&ftdic2) < 0)
+ if ((ftdi2 = ftdi_new()) == 0)
{
- fprintf(stderr, "ftdi_init failed\n");
+ fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
- ftdi_set_interface(&ftdic2, INTERFACE_B);
- f = ftdi_usb_open(&ftdic2, 0x0403, 0x6001);
+ ftdi_set_interface(ftdi2, INTERFACE_B);
+ f = ftdi_usb_open(ftdi2, 0x0403, 0x6001);
if (f < 0 && f != -5)
{
- fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(&ftdic2));
- ftdi_deinit(&ftdic2);
+ fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi2));
+ ftdi_deinit(ftdi2);
exit(-1);
}
printf("ftdi open succeeded(channel 2): %d\n",f);
printf("enabling bitbang mode (channel 2)\n");
- ftdi_set_bitmode(&ftdic2, 0xFF, BITMODE_BITBANG);
+ ftdi_set_bitmode(ftdi2, 0xFF, BITMODE_BITBANG);
// Write data
printf("startloop\n");
{
buf[0] = 0x1;
printf("porta: %02i: 0x%02x \n",i,buf[0]);
- f = ftdi_write_data(&ftdic, buf, 1);
+ f = ftdi_write_data(ftdi, buf, 1);
if (f < 0)
- fprintf(stderr,"write failed on channel 1 for 0x%x, error %d (%s)\n", buf[0], f, ftdi_get_error_string(&ftdic));
+ fprintf(stderr,"write failed on channel 1 for 0x%x, error %d (%s)\n", buf[0], f, ftdi_get_error_string(ftdi));
sleep(1);
buf[0] = 0x2;
printf("porta: %02i: 0x%02x \n",i,buf[0]);
- f = ftdi_write_data(&ftdic, buf, 1);
+ f = ftdi_write_data(ftdi, buf, 1);
if (f < 0)
- fprintf(stderr,"write failed on channel 1 for 0x%x, error %d (%s)\n", buf[0], f, ftdi_get_error_string(&ftdic));
+ fprintf(stderr,"write failed on channel 1 for 0x%x, error %d (%s)\n", buf[0], f, ftdi_get_error_string(ftdi));
sleep(1);
buf[0] = 0x1;
printf("portb: %02i: 0x%02x \n",i,buf[0]);
- f = ftdi_write_data(&ftdic2, buf, 1);
+ f = ftdi_write_data(ftdi2, buf, 1);
if (f < 0)
- fprintf(stderr,"write failed on channel 2 for 0x%x, error %d (%s)\n", buf[0], f, ftdi_get_error_string(&ftdic2));
+ fprintf(stderr,"write failed on channel 2 for 0x%x, error %d (%s)\n", buf[0], f, ftdi_get_error_string(ftdi2));
sleep(1);
buf[0] = 0x2;
printf("portb: %02i: 0x%02x \n",i,buf[0]);
- f = ftdi_write_data(&ftdic2, buf, 1);
+ f = ftdi_write_data(ftdi2, buf, 1);
if (f < 0)
- fprintf(stderr,"write failed on channel 2 for 0x%x, error %d (%s)\n", buf[0], f, ftdi_get_error_string(&ftdic2));
+ fprintf(stderr,"write failed on channel 2 for 0x%x, error %d (%s)\n", buf[0], f, ftdi_get_error_string(ftdi2));
sleep(1);
}
printf("\n");
printf("disabling bitbang mode(channel 1)\n");
- ftdi_disable_bitbang(&ftdic);
- ftdi_usb_close(&ftdic);
- ftdi_deinit(&ftdic);
+ ftdi_disable_bitbang(ftdi);
+ ftdi_usb_close(ftdi);
+ ftdi_deinit(ftdi);
printf("disabling bitbang mode(channel 2)\n");
- ftdi_disable_bitbang(&ftdic2);
- ftdi_usb_close(&ftdic2);
- ftdi_deinit(&ftdic2);
+ ftdi_disable_bitbang(ftdi2);
+ ftdi_usb_close(ftdi2);
+ ftdi_free(ftdi2);
return 0;
}
int main(void)
{
int ret, i;
- struct ftdi_context ftdic;
+ struct ftdi_context *ftdi;
struct ftdi_device_list *devlist, *curdev;
char manufacturer[128], description[128];
int retval = EXIT_SUCCESS;
- if (ftdi_init(&ftdic) < 0)
+ if ((ftdi = ftdi_new()) == 0)
{
- fprintf(stderr, "ftdi_init failed\n");
+ fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
- if ((ret = ftdi_usb_find_all(&ftdic, &devlist, 0, 0)) < 0)
+ if ((ret = ftdi_usb_find_all(ftdi, &devlist, 0, 0)) < 0)
{
- fprintf(stderr, "ftdi_usb_find_all failed: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
+ fprintf(stderr, "ftdi_usb_find_all failed: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
retval = EXIT_FAILURE;
goto do_deinit;
}
for (curdev = devlist; curdev != NULL; i++)
{
printf("Checking device: %d\n", i);
- if ((ret = ftdi_usb_get_strings(&ftdic, curdev->dev, manufacturer, 128, description, 128, NULL, 0)) < 0)
+ if ((ret = ftdi_usb_get_strings(ftdi, curdev->dev, manufacturer, 128, description, 128, NULL, 0)) < 0)
{
- fprintf(stderr, "ftdi_usb_get_strings failed: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
+ fprintf(stderr, "ftdi_usb_get_strings failed: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
retval = EXIT_FAILURE;
goto done;
}
done:
ftdi_list_free(&devlist);
do_deinit:
- ftdi_deinit(&ftdic);
+ ftdi_free(ftdi);
return retval;
}
int main(void)
{
int ret;
- struct ftdi_context ftdic;
+ struct ftdi_context *ftdi;
struct ftdi_version_info version;
- if (ftdi_init(&ftdic) < 0)
- {
- fprintf(stderr, "ftdi_init failed\n");
+ if ((ftdi = ftdi_new()) == 0)
+ {
+ fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
version.version_str, version.major, version.minor, version.micro,
version.snapshot_str);
- if ((ret = ftdi_usb_open(&ftdic, 0x0403, 0x6001)) < 0)
+ if ((ret = ftdi_usb_open(ftdi, 0x0403, 0x6001)) < 0)
{
- fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
- ftdi_deinit(&ftdic);
+ fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
+ ftdi_free(ftdi);
return EXIT_FAILURE;
}
// Read out FTDIChip-ID of R type chips
- if (ftdic.type == TYPE_R)
+ if (ftdi->type == TYPE_R)
{
unsigned int chipid;
- printf("ftdi_read_chipid: %d\n", ftdi_read_chipid(&ftdic, &chipid));
+ printf("ftdi_read_chipid: %d\n", ftdi_read_chipid(ftdi, &chipid));
printf("FTDI chipid: %X\n", chipid);
}
- if ((ret = ftdi_usb_close(&ftdic)) < 0)
+ if ((ret = ftdi_usb_close(ftdi)) < 0)
{
- fprintf(stderr, "unable to close ftdi device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
- ftdi_deinit(&ftdic);
+ fprintf(stderr, "unable to close ftdi device: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
+ ftdi_free(ftdi);
return EXIT_FAILURE;
}
- ftdi_deinit(&ftdic);
+ ftdi_free(ftdi);
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
- struct ftdi_context ftdic;
+ struct ftdi_context *ftdi;
int err, c;
FILE *of = NULL;
char const *outfile = 0;
usage(argv[0]);
}
- if (ftdi_init(&ftdic) < 0)
+ if ((ftdi = ftdi_new()) == 0)
{
- fprintf(stderr, "ftdi_init failed\n");
+ fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
- if (ftdi_set_interface(&ftdic, INTERFACE_A) < 0)
+ if (ftdi_set_interface(ftdi, INTERFACE_A) < 0)
{
fprintf(stderr, "ftdi_set_interface failed\n");
- ftdi_deinit(&ftdic);
+ ftdi_free(ftdi);
return EXIT_FAILURE;
}
- if (ftdi_usb_open_desc(&ftdic, 0x0403, 0x6010, descstring, NULL) < 0)
+ if (ftdi_usb_open_desc(ftdi, 0x0403, 0x6010, descstring, NULL) < 0)
{
- fprintf(stderr,"Can't open ftdi device: %s\n",ftdi_get_error_string(&ftdic));
- ftdi_deinit(&ftdic);
+ fprintf(stderr,"Can't open ftdi device: %s\n",ftdi_get_error_string(ftdi));
+ ftdi_free(ftdi);
return EXIT_FAILURE;
}
/* A timeout value of 1 results in may skipped blocks */
- if(ftdi_set_latency_timer(&ftdic, 2))
+ if(ftdi_set_latency_timer(ftdi, 2))
{
- fprintf(stderr,"Can't set latency, Error %s\n",ftdi_get_error_string(&ftdic));
- ftdi_usb_close(&ftdic);
- ftdi_deinit(&ftdic);
+ fprintf(stderr,"Can't set latency, Error %s\n",ftdi_get_error_string(ftdi));
+ ftdi_usb_close(ftdi);
+ ftdi_free(ftdi);
return EXIT_FAILURE;
}
-/* if(ftdi_usb_purge_rx_buffer(&ftdic) < 0)
+/* if(ftdi_usb_purge_rx_buffer(ftdi) < 0)
{
- fprintf(stderr,"Can't rx purge\n",ftdi_get_error_string(&ftdic));
+ fprintf(stderr,"Can't rx purge\n",ftdi_get_error_string(ftdi));
return EXIT_FAILURE;
}*/
if (outfile)
outputFile = of;
signal(SIGINT, sigintHandler);
- err = ftdi_readstream(&ftdic, readCallback, NULL, 8, 256);
+ err = ftdi_readstream(ftdi, readCallback, NULL, 8, 256);
if (err < 0 && !exitRequested)
exit(1);
}
fprintf(stderr, "Capture ended.\n");
- if (ftdi_set_bitmode(&ftdic, 0xff, BITMODE_RESET) < 0)
+ if (ftdi_set_bitmode(ftdi, 0xff, BITMODE_RESET) < 0)
{
- fprintf(stderr,"Can't set synchronous fifo mode, Error %s\n",ftdi_get_error_string(&ftdic));
- ftdi_usb_close(&ftdic);
- ftdi_deinit(&ftdic);
+ fprintf(stderr,"Can't set synchronous fifo mode, Error %s\n",ftdi_get_error_string(ftdi));
+ ftdi_usb_close(ftdi);
+ ftdi_free(ftdi);
return EXIT_FAILURE;
}
- ftdi_usb_close(&ftdic);
- ftdi_deinit(&ftdic);
+ ftdi_usb_close(ftdi);
+ ftdi_free(ftdi);
signal(SIGINT, SIG_DFL);
if (check && outfile)
{
if ((outputFile = fopen(outfile,"r")) == 0)
{
fprintf(stderr,"Can't open logfile %s, Error %s\n", outfile, strerror(errno));
- ftdi_usb_close(&ftdic);
- ftdi_deinit(&ftdic);
+ ftdi_usb_close(ftdi);
+ ftdi_free(ftdi);
return EXIT_FAILURE;
}
check_outfile(descstring);