/*
List connected TCTEC Relays
*/
void
listRelays()
{
int ret, i, bRelayStates;
struct ftdi_device_list *devlist, *curdev;
char manufacturer[128], description[128], serial[128],
buf[1];
if ((ret = ftdi_usb_find_all(&ftdic, &devlist, 0x0403, 0x6001)) < 0) {
fprintf(stderr, "ftdi_usb_find_all failed: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return;
}
printf("Number of FTDI devices found: %d\n", ret);
for (curdev = devlist; curdev != NULL; i++) {
if ((ret = ftdi_usb_get_strings(&ftdic, curdev->dev, manufacturer, 128, description, 128, serial, 128)) < 0) {
fprintf(stderr, "ftdi_usb_get_strings failed: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return;
}
if (strncmp(description, "TCTEC USB RELAY", 15) == 0) {
printf("Manufacturer: %s, Description: %s, Serial: %s\n\n", manufacturer, description, serial);
}
curdev = curdev->next;
}
ftdi_list_free(&devlist);
ftdi_deinit(&ftdic);
return;
}
static struct ftdi_context *open_ftdi_device(int vid, int pid,
int interface, char *serial)
{
struct ftdi_context *ftdi;
int ret;
ftdi = ftdi_new();
if (!ftdi) {
fprintf(stderr, "Cannot allocate context memory\n");
return NULL;
}
ret = ftdi_set_interface(ftdi, interface);
if (ret < 0) {
fprintf(stderr, "cannot set ftdi interface %d: %s(%d)\n",
interface, ftdi_get_error_string(ftdi), ret);
goto open_failed;
}
ret = ftdi_usb_open_desc(ftdi, vid, pid, NULL, serial);
if (ret < 0) {
fprintf(stderr, "unable to open ftdi device: %s(%d)\n",
ftdi_get_error_string(ftdi), ret);
goto open_failed;
}
return ftdi;
open_failed:
ftdi_free(ftdi);
return NULL;
}
void OBDDevice::setupFTDI() {
if ( !(ftdi = ftdi_new()) ) {
qDebug() << __FILE__ << __LINE__ << ": Failed to create ftdi context";
return;
}
if ( ftdi_set_interface( ftdi, INTERFACE_ANY ) < 0 ) {
qDebug() << __FILE__ << __LINE__ << ": Unable to set interface: " << ftdi_get_error_string( ftdi );
return;
}
if ( ftdi_usb_open_desc( ftdi, VID, PID, DESCRIPTION, NULL ) < 0 ) {
qDebug() << __FILE__ << __LINE__ << ": Unable to open ftdi device: " << ftdi_get_error_string( ftdi );
return;
}
if ( ftdi_set_baudrate( ftdi, BAUDRATE ) < 0 ) {
qDebug() << __FILE__ << __LINE__ << ": Unable to set baudrate: " << ftdi_get_error_string( ftdi );
return;
}
if ( ftdi_set_line_property( ftdi, BITS_8, STOP_BIT_1, NONE ) < 0 ) {
qDebug() << __FILE__ << __LINE__ << ": Unable to set line parameters: " << ftdi_get_error_string( ftdi );
return;
}
ftdi_usb_purge_buffers(ftdi);
}
static int dmx_init(struct ftdi_context* ftdic)
{
int ret;
if (ftdi_init(ftdic) < 0)
{
fprintf(stderr, "ftdi_init failed\n");
return EXIT_FAILURE;
}
if ((ret = ftdi_usb_open(ftdic, 0x0403, 0x6001)) < 0)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(ftdic));
return EXIT_FAILURE;
}
if ((ret = ftdi_set_baudrate(ftdic, 250000)) < 0)
{
fprintf(stderr, "unable to set baudrate: %d (%s)\n", ret, ftdi_get_error_string(ftdic));
return EXIT_FAILURE;
}
if ((ret = ftdi_set_line_property(ftdic, BITS_8, STOP_BIT_2, NONE)) < 0)
{
fprintf(stderr, "unable to set line property: %d (%s)\n", ret, ftdi_get_error_string(ftdic));
return EXIT_FAILURE;
}
if ((ret = ftdi_setflowctrl(ftdic, SIO_DISABLE_FLOW_CTRL)) < 0)
{
fprintf(stderr, "unable to set flow control: %d (%s)\n", ret, ftdi_get_error_string(ftdic));
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
void spi_init(void) {
int ret;
ftdi = ftdi_new();
if (!ftdi) {
fatal_error("ftdi_new failed!\n");
}
ret = ftdi_usb_open(ftdi, 0x0403, 0x6001);
if (ret < 0 && ret != -5) {
ftdi_free(ftdi);
fatal_error("unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
}
ret = ftdi_set_bitmode(ftdi, PINS_OUT, BITMODE_SYNCBB);
if (ret != 0) {
ftdi_free(ftdi);
fatal_error("unable to set bitmode: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
}
ret = ftdi_set_baudrate(ftdi, 57600);
if (ret != 0) {
ftdi_disable_bitbang(ftdi);
ftdi_free(ftdi);
fatal_error("unable to set baudrate: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
}
}
/**
* Close the USB port and reset the sequencer logic.
*
* @param devc The struct containing private per-device-instance data.
*
* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
*/
static int close_usb_reset_sequencer(struct dev_context *devc)
{
/* Magic sequence of bytes for resetting the sequencer logic. */
uint8_t buf[8] = {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
int ret;
/* Note: Caller checked that devc and devc->ftdic != NULL. */
if (devc->ftdic->usb_dev) {
/* Reset the sequencer logic, then wait 100ms. */
sr_dbg("Resetting sequencer logic.");
(void) cv_write(devc, buf, 8); /* Ignore errors. */
g_usleep(100 * 1000);
/* Purge FTDI buffers, then reset and close the FTDI device. */
sr_dbg("Purging buffers, resetting+closing FTDI device.");
/* Log errors, but ignore them (i.e., don't abort). */
if ((ret = ftdi_usb_purge_buffers(devc->ftdic)) < 0)
sr_err("Failed to purge FTDI buffers (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
if ((ret = ftdi_usb_reset(devc->ftdic)) < 0)
sr_err("Failed to reset FTDI device (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
if ((ret = ftdi_usb_close(devc->ftdic)) < 0)
sr_err("Failed to close FTDI device (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
}
/* Close USB device, deinitialize and free the FTDI context. */
ftdi_free(devc->ftdic);
devc->ftdic = NULL;
return SR_OK;
}
static int ux400_gps_sys_init()
{
int ret, i;
struct ftdi_device_list *devlist, *curdev;
char manufacturer[128], description[128], serialno[128];
if (ftdi_init(&ux400_gps_ftdic) < 0)
{
fprintf(stderr, "ftdi_init failed\n");
return EXIT_FAILURE;
}
ftdi_set_interface(&ux400_gps_ftdic, UX400_RS232_A);
if((ret = ftdi_usb_open_desc(&ux400_gps_ftdic, UX400VENDOR, UX400PRODUCT, UX400DES, UX400_RS232_SN)) < 0)
{
fprintf(stderr, "ftdi_usb_open_desc failed: %d (%s)\n", ret, ftdi_get_error_string(&ux400_gps_ftdic));
return EXIT_FAILURE;
}
// Set baudrate
ret = ftdi_set_baudrate(&ux400_gps_ftdic, GPS_BAUDRATE);
if (ret < 0)
{
fprintf(stderr, "unable to set baudrate: %d (%s)\n", ret, ftdi_get_error_string(&ux400_gps_ftdic));
return EXIT_FAILURE;
}
return 0;
}
int tx(int d)
{
uint8_t cmd[] = { 0x37, 7, d };
uint8_t ans = 0;
int i,f;
f = ftdi_write_data(ftdi, cmd, 3);
if(f != 3) {
fprintf(stderr, "unable to write command3 to ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi));
err = 1;
return 0;
}
for(i=0; i < 10; i++) {
f = ftdi_read_data(ftdi,&ans,1);
if(f == 0) {
usleep(1);
continue;
}
if(f == 1) break;
else {
fprintf(stderr, "unable to read data from ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi));
err = 1;
return 0;
}
}
return ans & 0xff;
}
SR_PRIV int scanaplus_get_device_id(struct dev_context *devc)
{
int ret;
uint16_t val1, val2;
/* FTDI EEPROM indices 16+17 contain the 3 device ID bytes. */
if ((ret = ftdi_read_eeprom_location(devc->ftdic, 16, &val1)) < 0) {
sr_err("Failed to read EEPROM index 16 (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
return SR_ERR;
}
if ((ret = ftdi_read_eeprom_location(devc->ftdic, 17, &val2)) < 0) {
sr_err("Failed to read EEPROM index 17 (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
return SR_ERR;
}
/*
* Note: Bit 7 of the three bytes must not be used, apparently.
*
* Even though the three bits can be either 0 or 1 (we've seen both
* in actual ScanaPLUS devices), the device ID as sent to the FPGA
* has bit 7 of each byte zero'd out.
*
* It is unknown whether bit 7 of these bytes has any meaning,
* whether it's used somewhere, or whether it can be simply ignored.
*/
devc->devid[0] = ((val1 >> 0) & 0xff) & ~(1 << 7);
devc->devid[1] = ((val1 >> 8) & 0xff) & ~(1 << 7);
devc->devid[2] = ((val2 >> 0) & 0xff) & ~(1 << 7);
return SR_OK;
}
int Write_JTAG(struct ftdi_context * handle, unsigned char value, unsigned char direction, unsigned int len)
{
unsigned char cmd [3] = { 0x00 };
int ret = 0;
int i = 0;
if((ret = ftdi_usb_purge_tx_buffer (handle)) < 0)
{
fprintf(stderr, "ftdi_usb_purge_tx_buffer failed: %d (%s)\n", ret, ftdi_get_error_string(&ux400_ftdic));
return EXIT_FAILURE;
}
for(i = 0; i < len; i ++)
{
cmd[0] = 0x82;
cmd[1] = value;
cmd[2] = direction;
if((ret = ftdi_write_data (handle, cmd, 3)) < 0)
{
fprintf(stderr, "ftdi_write_data failed: %d (%s)\n", ret, ftdi_get_error_string(&ux400_ftdic));
return EXIT_FAILURE;
}
}
return ret;
}
static int scanaplus_write(struct dev_context *devc, uint8_t *buf, int size)
{
int i, bytes_written;
GString *s;
/* Note: Caller checks devc, devc->ftdic, buf, size. */
s = g_string_sized_new(100);
g_string_printf(s, "Writing %d bytes: ", size);
for (i = 0; i < size; i++)
g_string_append_printf(s, "0x%02x ", buf[i]);
sr_spew("%s", s->str);
g_string_free(s, TRUE);
bytes_written = ftdi_write_data(devc->ftdic, buf, size);
if (bytes_written < 0) {
sr_err("Failed to write FTDI data (%d): %s.",
bytes_written, ftdi_get_error_string(devc->ftdic));
} else if (bytes_written != size) {
sr_err("FTDI write error, only %d/%d bytes written: %s.",
bytes_written, size, ftdi_get_error_string(devc->ftdic));
}
return bytes_written;
}
int init_rs485(struct rs485_data_t *rs485_data) {
int ret;
rs485_data->ftdi = ftdi_new();
if (!rs485_data->ftdi) {
fprintf(stderr, "ftdi_new failed\n");
return -1;
}
/* check for FT232RL device */
if ((ret = ftdi_usb_open(rs485_data->ftdi, 0x0403, 0x6001)) < 0) {
fprintf(stderr, "unable to open FTDI device: %d (%s)\n", ret, ftdi_get_error_string(rs485_data->ftdi));
ftdi_free(rs485_data->ftdi);
return EXIT_FAILURE;
}
if ((ret = ftdi_set_baudrate(rs485_data->ftdi, rs485_data->speed)) < 0) {
fprintf(stderr, "unable to set baudrate: %d (%s)\n", ret, ftdi_get_error_string(rs485_data->ftdi));
ftdi_free(rs485_data->ftdi);
return EXIT_FAILURE;
}
if ((ret = ftdi_setflowctrl(rs485_data->ftdi, SIO_DISABLE_FLOW_CTRL)) < 0) {
fprintf(stderr, "unable to set flow control: %d (%s)\n", ret, ftdi_get_error_string(rs485_data->ftdi));
return EXIT_FAILURE;
}
return 0;
}
int Read_JTAG(struct ftdi_context * handle, unsigned char * buff, unsigned int len)
{
unsigned char cmd [2] = { 0x00 };
int ret = 0;
cmd[0] = 0x83;
cmd[1] = 0x87;
if((ret = ftdi_usb_purge_rx_buffer (handle)) < 0)
{
fprintf(stderr, "ftdi_usb_purge_rx_buffer failed: %d (%s)\n", ret, ftdi_get_error_string(&ux400_ftdic));
return EXIT_FAILURE;
}
if((ret = ftdi_usb_purge_tx_buffer (handle)) < 0)
{
fprintf(stderr, "ftdi_usb_purge_tx_buffer failed: %d (%s)\n", ret, ftdi_get_error_string(&ux400_ftdic));
return EXIT_FAILURE;
}
if((ret = ftdi_write_data (handle, cmd, 2)) < 0)
{
fprintf(stderr, "ftdi_write_data failed: %d (%s)\n", ret, ftdi_get_error_string(&ux400_ftdic));
return EXIT_FAILURE;
}
if((ret = ftdi_read_data (handle, buff, len)) < 0)
{
fprintf(stderr, "ftdi_read_data failed: %d (%s)\n", ret, ftdi_get_error_string(&ux400_ftdic));
return EXIT_FAILURE;
}
return ret;
}
//
// Open the serial port.
// Initialise ftdi_context and use it to open the device
static dc_status_t serial_ftdi_open (void **userdata, const char* name)
{
// Allocate memory.
ftdi_serial_t *device = (ftdi_serial_t *) malloc (sizeof (ftdi_serial_t));
if (device == NULL) {
SYSERROR (context, errno);
return DC_STATUS_NOMEMORY;
}
struct ftdi_context *ftdi_ctx = ftdi_new();
if (ftdi_ctx == NULL) {
free(device);
SYSERROR (context, errno);
return DC_STATUS_NOMEMORY;
}
// Library context.
//device->context = context;
// Default to blocking reads.
device->timeout = -1;
// Default to full-duplex.
device->halfduplex = 0;
device->baudrate = 0;
device->nbits = 0;
// Initialize device ftdi context
ftdi_init(ftdi_ctx);
if (ftdi_set_interface(ftdi_ctx,INTERFACE_ANY)) {
free(device);
ERROR (context, "%s", ftdi_get_error_string(ftdi_ctx));
return DC_STATUS_IO;
}
if (serial_ftdi_open_device(ftdi_ctx) < 0) {
free(device);
ERROR (context, "%s", ftdi_get_error_string(ftdi_ctx));
return DC_STATUS_IO;
}
if (ftdi_usb_reset(ftdi_ctx)) {
free(device);
ERROR (context, "%s", ftdi_get_error_string(ftdi_ctx));
return DC_STATUS_IO;
}
if (ftdi_usb_purge_buffers(ftdi_ctx)) {
free(device);
ERROR (context, "%s", ftdi_get_error_string(ftdi_ctx));
return DC_STATUS_IO;
}
device->ftdi_ctx = ftdi_ctx;
*userdata = device;
return DC_STATUS_SUCCESS;
}
bool GovernorFtdi::open(OpenMode mode)
{
int ret;
if(ftdi_init(&ftdic) < 0)
qDebug("ftdi_init failed");
ret = ftdi_set_interface(&ftdic, INTERFACE_B);
if(ret < 0){
qDebug("Error: unable to set interface: %d (%s)", ret, ftdi_get_error_string(&ftdic));
return false;
}
ret = ftdi_usb_open(&ftdic, 0x0403, 0x6010);
if(ret < 0){
qDebug("Error: unable to open ftdi device: %d (%s)", ret, ftdi_get_error_string(&ftdic));
return false;
}
ret = ftdi_set_baudrate(&ftdic, 115200);
if(ret < 0){
qDebug("Error: unable to set baudrate: %d (%s)", ret, ftdi_get_error_string(&ftdic));
return false;
}
readThread = new GovernorFtdiReadThread(this, &ftdic);
connect(readThread, SIGNAL(readyRead()), this, SLOT(on_readThread_readyRead()));
readThread->start();
QIODevice::open(mode);
return true;
}
int Write_bus(struct ftdi_context * handle, unsigned char haddr, unsigned char laddr, unsigned char * buff, unsigned int len)
{
unsigned char cmd [4] = { 0x00 };
int ret = 0;
int i = 0;
if((ret = ftdi_usb_purge_tx_buffer (handle)) < 0)
{
fprintf(stderr, "ftdi_usb_purge_tx_buffer failed: %d (%s)\n", ret, ftdi_get_error_string(&ux400_ftdic));
return EXIT_FAILURE;
}
for(i = 0; i < len; i ++)
{
cmd[0] = 0x93;
cmd[1] = haddr;
cmd[2] = laddr;
cmd[3] = buff[i];
if((ret = ftdi_write_data (handle, cmd, 4)) < 0)
{
fprintf(stderr, "ftdi_write_data failed: %d (%s)\n", ret, ftdi_get_error_string(&ux400_ftdic));
return EXIT_FAILURE;
}
}
return ret;
}
bool EnttecDMXUSBOpen::open()
{
if (isOpen() == false)
{
if (ftdi_usb_open_desc(&m_context, EnttecDMXUSBWidget::VID,
EnttecDMXUSBWidget::PID,
name().toAscii(),
serial().toAscii()) < 0)
{
qWarning() << "Unable to open" << uniqueName()
<< ":" << ftdi_get_error_string(&m_context);
return false;
}
if (ftdi_usb_reset(&m_context) < 0)
{
qWarning() << "Unable to reset" << uniqueName()
<< ":" << ftdi_get_error_string(&m_context);
return close();
}
if (ftdi_set_line_property(&m_context, BITS_8, STOP_BIT_2, NONE) < 0)
{
qWarning() << "Unable to set 8N2 serial properties to"
<< uniqueName()
<< ":" << ftdi_get_error_string(&m_context);
return close();
}
if (ftdi_set_baudrate(&m_context, 250000) < 0)
{
qWarning() << "Unable to set 250kbps baudrate for"
<< uniqueName()
<< ":" << ftdi_get_error_string(&m_context);
return close();
}
if (ftdi_setrts(&m_context, 0) < 0)
{
qWarning() << "Unable to set RTS line to 0 for"
<< uniqueName()
<< ":" << ftdi_get_error_string(&m_context);
return close();
}
if (isRunning() == false)
start();
return true;
}
else
{
/* Already open */
return true;
}
}
static int dev_open(struct sr_dev_inst *sdi)
{
struct dev_context *devc;
int ret;
if (!(devc = sdi->priv))
return SR_ERR_BUG;
/* Allocate memory for the FTDI context and initialize it. */
if (!(devc->ftdic = ftdi_new())) {
sr_err("Failed to initialize libftdi.");
return SR_ERR;
}
sr_dbg("Opening %s device (%04x:%04x).", devc->prof->modelname,
devc->usb_vid, devc->usb_pid);
/* Open the device. */
if ((ret = ftdi_usb_open_desc(devc->ftdic, devc->usb_vid,
devc->usb_pid, devc->prof->iproduct, NULL)) < 0) {
sr_err("Failed to open FTDI device (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
goto err_ftdi_free;
}
sr_dbg("Device opened successfully.");
/* Purge RX/TX buffers in the FTDI chip. */
if ((ret = ftdi_usb_purge_buffers(devc->ftdic)) < 0) {
sr_err("Failed to purge FTDI buffers (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
goto err_ftdi_free;
}
sr_dbg("FTDI buffers purged successfully.");
/* Enable flow control in the FTDI chip. */
if ((ret = ftdi_setflowctrl(devc->ftdic, SIO_RTS_CTS_HS)) < 0) {
sr_err("Failed to enable FTDI flow control (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
goto err_ftdi_free;
}
sr_dbg("FTDI flow control enabled successfully.");
/* Wait 100ms. */
g_usleep(100 * 1000);
sdi->status = SR_ST_ACTIVE;
if (ret == SR_OK)
return SR_OK;
err_ftdi_free:
ftdi_free(devc->ftdic); /* Close device (if open), free FTDI context. */
devc->ftdic = NULL;
return ret;
}
void list_devices() {
struct ftdi_context *ftdi;
struct ftdi_device_list *dev_list;
struct ftdi_device_list *dev_current;
int num_devices;
ftdi = ftdi_new();
if (!ftdi) {
fprintf(stderr, "failed to initialize ftdi context\n");
exit(1);
}
num_devices = ftdi_usb_find_all(ftdi, &dev_list, VID, PID);
if (num_devices < 0) {
fprintf(stderr, "ftdi error: %s\n",
ftdi_get_error_string(ftdi));
goto error;
}
if (!num_devices) {
printf("unable to find saturn device!\n");
goto done;
}
dev_current = dev_list;
num_devices = 0;
while (dev_current) {
char manufacturer[255];
char description[255];
char serial[255];
if (ftdi_usb_get_strings(ftdi, dev_current->dev,
manufacturer, 255,
description, 255,
serial, 255) < 0) {
fprintf(stderr, "ftdi error: %s\n",
ftdi_get_error_string(ftdi));
goto done;
}
if (strcmp(DESCRIPTION, description) == 0)
printf("%d: %s (%s, %s)\n", num_devices++, description,
manufacturer, serial);
dev_current = dev_current->next;
}
if (!num_devices)
printf("unable to find saturn device!\n");
done:
ftdi_list_free(&dev_list);
error:
ftdi_free(ftdi);
}
int
main (void)
{
unsigned char buf[128];
unsigned char rbuf[128];
int ret;
int i;
struct ftdi_context ftdicon;
struct ftdi_context *ftdic = &ftdicon;
unsigned char d;
if (ftdi_init (ftdic) < 0)
{
fprintf (stderr, "ftdi_init failed\n");
return EXIT_FAILURE;
}
if ((ret = ftdi_usb_open (ftdic, 0x0403, 0x6010)) < 0)
{
fprintf (stderr, "unable to open ftdi device: %d (%s)\n", ret,
ftdi_get_error_string (ftdic));
return EXIT_FAILURE;
}
fprintf (stdout, "FTDI Opened. Starting SPI init\n");
ft2232_spi_init (ftdic);
// Enable accelerometer
buf[0] = 0x20;
buf[1] = 0x67;
ret = ft2232_spi_send_command (ftdic, 2, 0, buf, rbuf);
while (1)
{
buf[0] = ReadAccelerometerRegister (ftdic, ACC_X_AXIS);
buf[1] = ReadAccelerometerRegister (ftdic, ACC_Y_AXIS);
buf[2] = ReadAccelerometerRegister (ftdic, ACC_Z_AXIS);
printf ("X: 0x%02x\tY: 0x%02x\tZ: 0x%02x\n", buf[0], buf[1], buf[2]);
usleep (10);
}
if ((ret = ftdi_usb_close (ftdic)) < 0)
{
fprintf (stderr, "unable to close ftdi device: %d (%s)\n", ret,
ftdi_get_error_string (ftdic));
return EXIT_FAILURE;
}
ftdi_deinit (ftdic);
return EXIT_SUCCESS;
}
struct ftdi_context *
bub_init(unsigned int baud_rate,
unsigned char latency,
unsigned int tx_buf_size,
unsigned int rx_buf_size) {
int ret = 0;
struct ftdi_context *ftdic;
ftdic = malloc(sizeof(struct ftdi_context));
if(ftdic == NULL) {
perror("malloc");
return(NULL);
}
ret = ftdi_init(ftdic);
if (ret < 0) {
fprintf(stderr, "ftdi_init failed: %d.\n", ret);
return(NULL);
}
ftdi_set_interface(ftdic, INTERFACE_ANY);
ret = ftdi_usb_open(ftdic, 0x0403, 0x6001); // FIXME make nice defines
if(ret < 0) {
fprintf(stderr, "unable to open ftdi device: %d (%s)\n",
ret, ftdi_get_error_string(ftdic));
return(NULL);
}
if(ftdi_usb_reset(ftdic) != 0)
fprintf(stderr, "WARN: ftdi_usb_reset failed!\n");
ftdi_disable_bitbang(ftdic);
if (ftdi_set_baudrate(ftdic, baud_rate) < 0) {
fprintf(stderr, "Unable to set baudrate: (%s)\n",
ftdi_get_error_string(ftdic));
return(NULL);
}
ftdi_set_latency_timer(ftdic, latency);
if(tx_buf_size > 0)
ftdi_write_data_set_chunksize(ftdic, tx_buf_size);
if(rx_buf_size > 0)
ftdi_read_data_set_chunksize(ftdic, rx_buf_size);
return(ftdic);
}
static int jtagkey_init(unsigned short vid, unsigned short pid) {
int ret = 0;
unsigned char c;
if ((ret = ftdi_init(&ftdic)) != 0) {
fprintf(stderr, "unable to initialise libftdi: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
if ((ret = ftdi_usb_open(&ftdic, vid, pid)) != 0) {
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
if ((ret = ftdi_usb_reset(&ftdic)) != 0) {
fprintf(stderr, "unable reset device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
if ((ret = ftdi_set_interface(&ftdic, INTERFACE_A)) != 0) {
fprintf(stderr, "unable to set interface: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
if ((ret = ftdi_write_data_set_chunksize(&ftdic, USBBUFSIZE)) != 0) {
fprintf(stderr, "unable to set write chunksize: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
if ((ret = ftdi_read_data_set_chunksize(&ftdic, USBBUFSIZE)) != 0) {
fprintf(stderr, "unable to set read chunksize: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
if ((ret = jtagkey_latency(OTHER_LATENCY)) != 0)
return ret;
c = 0x00;
ftdi_write_data(&ftdic, &c, 1);
if ((ret = ftdi_set_bitmode(&ftdic, JTAGKEY_TCK|JTAGKEY_TDI|JTAGKEY_TMS|JTAGKEY_OEn, BITMODE_SYNCBB)) != 0) {
fprintf(stderr, "unable to enable bitbang mode: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
if ((ret = ftdi_set_baudrate(&ftdic, JTAG_SPEED)) != 0) {
fprintf(stderr, "unable to set baudrate: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
if ((ret = ftdi_usb_purge_buffers(&ftdic)) != 0) {
fprintf(stderr, "unable to purge buffers: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return ret;
}
return ret;
}
static int dev_open(struct sr_dev_inst *sdi)
{
struct dev_context *devc;
int ret;
if (!(devc = sdi->priv)) {
sr_err("%s: sdi->priv was NULL.", __func__);
return SR_ERR_BUG;
}
sr_dbg("Opening LA8 device (%04x:%04x).", USB_VENDOR_ID,
devc->usb_pid);
/* Open the device. */
if ((ret = ftdi_usb_open_desc(devc->ftdic, USB_VENDOR_ID,
devc->usb_pid, USB_DESCRIPTION, NULL)) < 0) {
sr_err("%s: ftdi_usb_open_desc: (%d) %s",
__func__, ret, ftdi_get_error_string(devc->ftdic));
(void) la8_close_usb_reset_sequencer(devc); /* Ignore errors. */
return SR_ERR;
}
sr_dbg("Device opened successfully.");
/* Purge RX/TX buffers in the FTDI chip. */
if ((ret = ftdi_usb_purge_buffers(devc->ftdic)) < 0) {
sr_err("%s: ftdi_usb_purge_buffers: (%d) %s",
__func__, ret, ftdi_get_error_string(devc->ftdic));
(void) la8_close_usb_reset_sequencer(devc); /* Ignore errors. */
goto err_dev_open_close_ftdic;
}
sr_dbg("FTDI buffers purged successfully.");
/* Enable flow control in the FTDI chip. */
if ((ret = ftdi_setflowctrl(devc->ftdic, SIO_RTS_CTS_HS)) < 0) {
sr_err("%s: ftdi_setflowcontrol: (%d) %s",
__func__, ret, ftdi_get_error_string(devc->ftdic));
(void) la8_close_usb_reset_sequencer(devc); /* Ignore errors. */
goto err_dev_open_close_ftdic;
}
sr_dbg("FTDI flow control enabled successfully.");
/* Wait 100ms. */
g_usleep(100 * 1000);
sdi->status = SR_ST_ACTIVE;
return SR_OK;
err_dev_open_close_ftdic:
(void) la8_close(devc); /* Log, but ignore errors. */
return SR_ERR;
}
bool IntanThread::initializeUSB(bool verbose)
{
int return_value;
// Step 1: initialise the ftdi_context:
if (ftdi_init(&ftdic) < 0) // -1 = couldn't allocate read buffer
{
// -2 = couldn't allocate struct buffer
if (verbose)
fprintf(stderr, "ftdi_init failed\n");
return false;
}
else
{
if (verbose)
std::cout << "FTDI context initialized." << std::endl;
}
// Step 2: open USB device
// -3 = device not found
// -8 = wrong permissions
if ((return_value = ftdi_usb_open(&ftdic, vendorID, productID)) < 0)
{
if (verbose)
fprintf(stderr, "unable to open FTDI device: %d (%s)\n",
return_value,
ftdi_get_error_string(&ftdic));
return false;
}
else
{
std::cout << "USB connection opened." << std::endl;
}
// Step 3: set the baud rate
if ((return_value = ftdi_set_baudrate(&ftdic, baudrate)) < 0)
{
if (verbose)
fprintf(stderr, "unable to set baud rate: %d (%s)\n",
return_value,
ftdi_get_error_string(&ftdic));
return false;
}
else
{
std::cout << "Baud rate set to 115200" << std::endl;
}
return true;
}
int main(void)
{
struct ftdi_context ftdic;
int f;
unsigned char buf[1];
unsigned char bitmask;
unsigned char input[10];
if (ftdi_init(&ftdic) < 0)
{
fprintf(stderr, "ftdi_init failed\n");
return EXIT_FAILURE;
}
f = ftdi_usb_open(&ftdic, 0x0403, 0x6001);
if (f < 0 && f != -5)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(&ftdic));
exit(-1);
}
printf("ftdi open succeeded: %d\n",f);
while (1)
{
// Set bitmask from input
fgets(input, sizeof(input) - 1, stdin);
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);
if (f < 0)
{
fprintf(stderr, "set_bitmode failed for 0x%x, error %d (%s)\n", bitmask, f, ftdi_get_error_string(&ftdic));
exit(-1);
}
// read CBUS
f = ftdi_read_pins(&ftdic, &buf[0]);
if (f < 0)
{
fprintf(stderr, "read_pins failed, error %d (%s)\n", f, ftdi_get_error_string(&ftdic));
exit(-1);
}
printf("Read returned 0x%01x\n", buf[0] & 0x0f);
}
printf("disabling bitbang mode\n");
ftdi_disable_bitbang(&ftdic);
ftdi_usb_close(&ftdic);
ftdi_deinit(&ftdic);
}
int GetFTDIDevicePortNumUSingLibFTDI(UInt32 locationIDFromInterface)
{
int ret, i;
struct ftdi_context ftdic;
struct ftdi_device_list *devlist, *curdev;
char manufacturer[128], description[128];
if (ftdi_init(&ftdic) < 0)
{
fprintf(stderr, "ftdi_init failed\n");
return -1;
}
if ((ret = ftdi_usb_find_all(&ftdic, &devlist, 0x0403, 0x6001)) < 0)
{
fprintf(stderr, "ftdi_usb_find_all failed: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return -1;
}
printf("Number of FTDI devices found: %d\n", ret);
i = 0;
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)
{
fprintf(stderr, "ftdi_usb_get_strings failed: %d (%s)\n", ret, ftdi_get_error_string(&ftdic));
return -1;
}
uint32_t *locationId = (uint32_t *)malloc(sizeof(uint32_t));
xlibusb_get_device_location_id((struct libusb_device *)curdev->dev->dev,locationId);
printf("Manufacturer: %s, Description: %s\n\n", manufacturer, description);
if ((*locationId) == locationIDFromInterface) {
free(locationId);
return i;
}
free(locationId);
//printf("0x%x deviceDesc[%d] %s",(unsigned int)&(deviceDesc[i]),i,deviceDesc[i]);
curdev = curdev->next;
}
ftdi_list_free(&devlist);
ftdi_deinit(&ftdic);
return -1;
}
int main(int argc, char **argv)
{
struct ftdi_context *ftdi;
int f;
unsigned char buf[1];
int retval = 0;
if ((ftdi = ftdi_new()) == 0)
{
fprintf(stderr, "ftdi_new failed\n");
return EXIT_FAILURE;
}
// fprintf(stderr, "ftdi_new result = %d\n", ftdi);
f = ftdi_usb_open(ftdi, 0x0403, 0x6001);
// fprintf(stderr, "ftdi_usb_open result = %d\n", f);
if (f < 0 && f != -5)
{
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(ftdi, 0x02, BITMODE_BITBANG);
// usleep(3 * 1000000);
buf[0] = 0xff;
// printf("turning everything on\n");
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(ftdi));
}
// ftdi_disable_bitbang(ftdi);
ftdi_usb_close(ftdi);
ftdi_free(ftdi);
done:
return retval;
}
static dc_status_t serial_ftdi_write (void *io, const void *data, size_t size, size_t *actual)
{
ftdi_serial_t *device = io;
if (device == NULL)
return DC_STATUS_INVALIDARGS;
unsigned int nbytes = 0;
while (nbytes < size) {
int n = ftdi_write_data (device->ftdi_ctx, (unsigned char *) data + nbytes, size - nbytes);
if (n < 0) {
if (n == LIBUSB_ERROR_INTERRUPTED)
continue; // Retry.
ERROR (device->context, "%s", ftdi_get_error_string(device->ftdi_ctx));
return DC_STATUS_IO; // Error during write call.
} else if (n == 0) {
break; // EOF.
}
nbytes += n;
}
INFO (device->context, "Wrote %d bytes", nbytes);
if (actual)
*actual = nbytes;
return DC_STATUS_SUCCESS;
}
void ftdi_fatal (struct ftdi_context *ftdi, char *str)
{
fprintf (stderr, "%s: %s\n",
str, ftdi_get_error_string (ftdi));
ftdi_free(ftdi);
exit (1);
}
/**
* Read a certain amount of bytes from the LA8's FTDI device.
*
* @param devc The struct containing private per-device-instance data. Must not
* be NULL. devc->ftdic must not be NULL either.
* @param buf The buffer where the received data will be stored. Must not
* be NULL.
* @param size The number of bytes to read. Must be >= 1.
* @return The number of bytes read, or a negative value upon errors.
*/
SR_PRIV int la8_read(struct dev_context *devc, uint8_t *buf, int size)
{
int bytes_read;
/* Note: Caller checked that devc and devc->ftdic != NULL. */
if (!buf) {
sr_err("%s: buf was NULL.", __func__);
return SR_ERR_ARG;
}
if (size <= 0) {
sr_err("%s: size was <= 0.", __func__);
return SR_ERR_ARG;
}
bytes_read = ftdi_read_data(devc->ftdic, buf, size);
if (bytes_read < 0) {
sr_err("%s: ftdi_read_data: (%d) %s.", __func__,
bytes_read, ftdi_get_error_string(devc->ftdic));
} else if (bytes_read != size) {
// sr_err("%s: Bytes to read: %d, bytes read: %d.",
// __func__, size, bytes_read);
}
return bytes_read;
}
