int spectrig_connect(struct ftdi_context *ftdi)
{
int ret;
ftdi_init(ftdi);
/* TODO: Be a bit more selective and support multiple devices properly */
ret = open_by_desc_prefix(ftdi, 0x0403, 0x6010, spectrig_descs);
if (ret < 0) {
perror("Failed to open the device");
return ret;
}
ftdi_usb_purge_buffers(ftdi);
/* Initialize synchronous communication */
ret = ftdi_set_latency_timer(ftdi, 2);
if (ret < 0) {
perror("Failed to set the latency timer");
goto close;
}
ret = ftdi_read_data_set_chunksize(ftdi, 0x10000);
if (ret < 0) {
perror("Failed to set read data chunksize");
goto close;
}
ret = ftdi_write_data_set_chunksize(ftdi, 0x10000);
if (ret < 0) {
perror("Failed to write read data chunksize");
goto close;
}
ret = ftdi_setflowctrl(ftdi, SIO_RTS_CTS_HS);
if (ret < 0) {
perror("Failed to set flow control");
goto close;
}
msleep(20);
ret = ftdi_set_bitmode(ftdi, 0xff, 0x00);
if (ret < 0) {
perror("Failed to set bitmode 0x00");
goto close;
}
msleep(20);
ftdi_set_bitmode(ftdi, 0xff, 0x40);
if (ret < 0) {
perror("Failed to set bitmode 0x40");
goto close;
}
msleep(300);
ftdi_usb_purge_buffers(ftdi);
return 0;
close:
ftdi_usb_close(ftdi);
ftdi_deinit(ftdi);
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;
}
static int config_i2c(struct ftdi_context *ftdi)
{
int ret;
uint8_t buf[5];
uint16_t divisor;
ret = ftdi_set_latency_timer(ftdi, 16 /* ms */);
if (ret < 0)
fprintf(stderr, "Cannot set latency\n");
ret = ftdi_set_bitmode(ftdi, 0, BITMODE_RESET);
if (ret < 0) {
fprintf(stderr, "Cannot reset MPSSE\n");
return -EIO;
}
ret = ftdi_set_bitmode(ftdi, 0, BITMODE_MPSSE);
if (ret < 0) {
fprintf(stderr, "Cannot enable MPSSE\n");
return -EIO;
}
ret = ftdi_usb_purge_buffers(ftdi);
if (ret < 0)
fprintf(stderr, "Cannot purge buffers\n");
/* configure the clock */
divisor = (60000000 / (2 * I2C_FREQ * 3 / 2 /* 3-phase CLK */) - 1);
buf[0] = EN_3_PHASE;
buf[1] = DIS_DIV_5;
buf[2] = TCK_DIVISOR;
buf[3] = divisor & 0xff;
buf[4] = divisor >> 8;
ret = ftdi_write_data(ftdi, buf, sizeof(buf));
return ret;
}
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);
}
/*-----------------------------------------------------------------------------
* Purge the serial buffers.
* Returns 0 if successful, < 0 if error
*/
int ics_purge(ICSData * r)
{
assert(r);
if (ftdi_usb_purge_buffers(&r->ftdic) < 0)
ics_ftdi_error(r, "ics_purge");
return 0;
}
/**
* 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;
}
bool FalconCommLibFTDI::setFirmwareMode()
{
unsigned int bytes_written, bytes_read;
unsigned char check_msg_1_send[3] = {0x0a, 0x43, 0x0d};
unsigned char check_msg_1_recv[4] = {0x0a, 0x44, 0x2c, 0x0d};
unsigned char check_msg_2[1] = {0x41};
unsigned char send_buf[128], receive_buf[128];
int k;
if(!m_isCommOpen)
{
m_errorCode = FALCON_COMM_DEVICE_NOT_VALID_ERROR;
return false;
}
//Save ourselves having to reset this on every error
m_errorCode = FALCON_COMM_DEVICE_ERROR;
//Clear out current buffers to make sure we have a fresh start
if((m_deviceErrorCode = ftdi_usb_purge_buffers((m_falconDevice))) < 0) return false;
//Reset the device
if((m_deviceErrorCode = ftdi_usb_reset((m_falconDevice))) < 0) return false;
//Make sure our latency timer is at 16ms, otherwise firmware checks tend to always fail
if((m_deviceErrorCode = ftdi_set_latency_timer((m_falconDevice), 16)) < 0) return false;
//Set to:
// 9600 baud
// 8n1
// No Flow Control
// RTS Low
// DTR High
if((m_deviceErrorCode = ftdi_set_baudrate((m_falconDevice), 9600)) < 0) return false;
if((m_deviceErrorCode = ftdi_set_line_property((m_falconDevice), BITS_8, STOP_BIT_1, NONE)) < 0) return false;
if((m_deviceErrorCode = ftdi_setflowctrl((m_falconDevice), SIO_DISABLE_FLOW_CTRL)) < 0) return false;
if((m_deviceErrorCode = ftdi_setrts((m_falconDevice), 0)) < 0) return false;
if((m_deviceErrorCode = ftdi_setdtr((m_falconDevice), 0)) < 0) return false;
if((m_deviceErrorCode = ftdi_setdtr((m_falconDevice), 1)) < 0) return false;
//Send 3 bytes: 0x0a 0x43 0x0d
if(!write(check_msg_1_send, 3)) return false;
if(!read(receive_buf, 4)) return false;
//Set to:
// DTR Low
// 140000 baud (0x15 clock ticks per signal)
if((m_deviceErrorCode = ftdi_setdtr((m_falconDevice),0)) < 0) return false;
if((m_deviceErrorCode = ftdi_set_baudrate((m_falconDevice), 140000)) < 0) return false;
//Send "A" character
if(!write(check_msg_2, 1)) return false;
//Expect back 2 bytes:
// 0x13 0x41
if(!read(receive_buf, 2)) return false;
m_errorCode = 0;
return true;
}
ReturnCode reader_purge(struct reader *reader)
{
if(ftdi_usb_purge_buffers(reader->ftdic) < 0){
return RC_IO_ERROR;
}else{
return RC_SUCCESS;
}
}
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))
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;
}
bool QLCFTDI::purgeBuffers()
{
if (ftdi_usb_purge_buffers(&m_handle) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
int ftdi_device_close(ftdi_device_t* dev) {
error_clear(&dev->error);
if (ftdi_usb_purge_buffers(dev->libftdi_context))
error_setf(&dev->error, FTDI_ERROR_PURGE, "%03:%03", dev->bus,
dev->address);
else if (ftdi_usb_close(dev->libftdi_context))
error_setf(&dev->error, FTDI_ERROR_CLOSE, "%03:%03", dev->bus,
dev->address);
return error_get(&dev->error);
}
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;
}
int platform_init(void)
{
int err;
if(ftdic) {
ftdi_usb_close(ftdic);
ftdi_free(ftdic);
ftdic = NULL;
}
if((ftdic = ftdi_new()) == NULL) {
fprintf(stderr, "ftdi_new: %s\n",
ftdi_get_error_string(ftdic));
abort();
}
if((err = ftdi_set_interface(ftdic, INTERFACE_A)) != 0) {
fprintf(stderr, "ftdi_set_interface: %d: %s\n",
err, ftdi_get_error_string(ftdic));
abort();
}
if((err = ftdi_usb_open(ftdic, FT2232_VID, FT2232_PID)) != 0) {
fprintf(stderr, "unable to open ftdi device: %d (%s)\n",
err, ftdi_get_error_string(ftdic));
abort();
}
if((err = ftdi_set_latency_timer(ftdic, 1)) != 0) {
fprintf(stderr, "ftdi_set_latency_timer: %d: %s\n",
err, ftdi_get_error_string(ftdic));
abort();
}
if((err = ftdi_set_baudrate(ftdic, 1000000)) != 0) {
fprintf(stderr, "ftdi_set_baudrate: %d: %s\n",
err, ftdi_get_error_string(ftdic));
abort();
}
if((err = ftdi_usb_purge_buffers(ftdic)) != 0) {
fprintf(stderr, "ftdi_set_baudrate: %d: %s\n",
err, ftdi_get_error_string(ftdic));
abort();
}
if((err = ftdi_write_data_set_chunksize(ftdic, BUF_SIZE)) != 0) {
fprintf(stderr, "ftdi_write_data_set_chunksize: %d: %s\n",
err, ftdi_get_error_string(ftdic));
abort();
}
assert(gdb_if_init() == 0);
jtag_scan(NULL);
return 0;
}
bool FTDIDevice::connect (int baudrate) throw ()
{
#ifdef FOUND_ftdi
int ret, i;
disconnect();
ftdi_init (&_ftdic);
while ((ret = ftdi_usb_open(&_ftdic, 0x0403, 0x6001)) < 0)
FTDERROR("unable to open ftdi device: " << ret << " (" << ftdi_get_error_string(&_ftdic) << ")");
for (i=0, ret=-1; i<10 && ret!=0; i++)
ret = ftdi_usb_reset(&_ftdic);
if (ret != 0) {
FTDERROR("unable to reset ftdi device.");
return false;
}
for (i=0, ret=-1; i<10 && ret!=0; i++)
ret = ftdi_set_baudrate(&_ftdic, baudrate);
if (ret != 0) {
FTDERROR("unable to set baud rate.");
return false;
}
if (_latency > 0) for (i=0, ret=-1; i<10 && ret!=0; i++)
ret = ftdi_set_latency_timer(&_ftdic, _latency);
if (ret != 0) {
FTDERROR("unable to set latency timer.");
return false;
}
for (i=0, ret=-1; i<10 && ret!=0; i++)
ret = ftdi_usb_purge_buffers(&_ftdic);
if (ret != 0) {
FTDERROR("unable to purge buffers.");
return false;
}
_initialized = true;
FTDLOG("Connection successful.");
return true;
#else
_initialized = false;
FTDERROR("cannot connect FTDI device: compiled without required libraries");
return false;
#endif
}
bool FalconCommLibFTDI::open(uint8_t device_index)
{
LOG_INFO("Opening device " << device_index);
if(!m_isInitialized)
{
LOG_ERROR("Device not initialized");
m_errorCode = FALCON_COMM_NOT_INITIALIZED;
return false;
}
unsigned int count, i, status;
struct ftdi_device_list *dev_list, *current;
if(m_isCommOpen) close();
count = ftdi_usb_find_all((m_falconDevice), &dev_list, FALCON_VENDOR_ID, FALCON_PRODUCT_ID);
if(count <= 0 || device_index > count)
{
ftdi_list_free(&dev_list);
if(count == 0)
{
LOG_ERROR("No devices found");
m_errorCode = FALCON_COMM_DEVICE_NOT_FOUND_ERROR;
return false;
}
else if(device_index > count)
{
LOG_ERROR("Device index " << device_index << " out of range");
m_errorCode = FALCON_COMM_DEVICE_INDEX_OUT_OF_RANGE_ERROR;
return false;
}
}
for(i = 0, current = dev_list; current != NULL && i < device_index; current = current->next, ++i);
if(current==NULL)
{
LOG_ERROR("No devices found");
m_errorCode = FALCON_COMM_DEVICE_NOT_FOUND_ERROR;
return false;
}
if((m_deviceErrorCode = ftdi_usb_open_dev((m_falconDevice), current->dev)) < 0)
{
LOG_ERROR("Device error " << m_deviceErrorCode);
m_errorCode = FALCON_COMM_DEVICE_ERROR;
ftdi_list_free(&dev_list);
return false;
}
ftdi_list_free(&dev_list);
m_isCommOpen = true;
//Purge buffers
if((m_deviceErrorCode = ftdi_usb_purge_buffers((m_falconDevice))) < 0) return false;
setNormalMode();
return true;
}
void gecko_flush() {
#ifdef USE_LIBFTDI
if (gUsingFTDI) {
ftdi_usb_purge_buffers(&gFTDIContext);
return;
}
#endif
#ifndef __WIN32__
tcflush(fd_gecko, TCIOFLUSH);
#else
PurgeComm(handle_gecko, PURGE_RXCLEAR | PURGE_TXCLEAR |
PURGE_TXABORT | PURGE_RXABORT);
#endif
}
int FtdiDevice::purgeBuffers( int bufType ) const
{
if ( ! isOpen() ) return RV_DEVICE_NOT_OPEN;
int rv;
switch ( bufType ) {
case RX_BUFFER: rv = ftdi_usb_purge_rx_buffer( context_ ); break;
case TX_BUFFER: rv = ftdi_usb_purge_tx_buffer( context_ ); break;
case RX_TX_BUFFER: rv = ftdi_usb_purge_buffers( context_ ); break;
default: assert( false ); rv = 0; break; //illegal argument given
}
//if ( rv < 0 ) fprintf( stderr, "purgeBuffers: purging failed (%i)\n", rv ); //LOG
return rv;
}
//Try to find the ftdi chip and open it.
int FtdiNand::open(int vid, int pid, bool doslow) {
unsigned char slow=DIS_DIV_5;
if (doslow) slow=EN_DIV_5;
m_slowAccess=doslow;
//If vid/pid is zero, use default FT2232H vid/pid.
if (vid==0) vid=0x0403;
if (pid==0) pid=0x6010;
//Open FTDI communications
if (ftdi_init(&m_ftdi)<0) return error("init");
if (ftdi_usb_open(&m_ftdi, vid, pid)<0) return error("open");
if (ftdi_set_bitmode(&m_ftdi, 0, BITMODE_MCU)<0) error("bitmode");
if (ftdi_write_data(&m_ftdi, &slow, 1)<0) return error("writing div5 cmd");
if (ftdi_set_latency_timer(&m_ftdi, 1)<0) return error("setting latency");
ftdi_usb_purge_buffers(&m_ftdi);
return 1;
}
void EnttecDMXUSBOpen::run()
{
ftdi_usb_purge_buffers(&m_context);
m_running = true;
while (m_running == true)
{
if (isOpen() == false)
continue;
if (ftdi_set_line_property2(&m_context, BITS_8, STOP_BIT_2,
NONE, BREAK_ON) < 0)
{
qWarning() << "Unable to toggle BREAK_ON for"
<< uniqueName()
<< ":" << ftdi_get_error_string(&m_context);
goto framesleep;
}
sleep(88);
if (ftdi_set_line_property2(&m_context, BITS_8, STOP_BIT_2,
NONE, BREAK_OFF) < 0)
{
qWarning() << "Unable to toggle BREAK_OFF for"
<< uniqueName()
<< ":" << ftdi_get_error_string(&m_context);
goto framesleep;
}
sleep(8);
m_mutex.lock();
if (ftdi_write_data(&m_context, (unsigned char*) m_universe.data(),
m_universe.size()) < 0)
{
qWarning() << "Unable to write DMX data to"
<< uniqueName()
<< ":" << ftdi_get_error_string(&m_context);
}
m_mutex.unlock();
framesleep:
sleep(22754);
}
}
// flush serial line
void CPlatform::clearLine(void) {
char Rxch;
unsigned long numread=0;
#ifdef WIN32
do {
ReadFile(hSerialPort, &Rxch, 1, &numread, NULL);
} while(numread!=0);
#else
#ifdef USE_FTDI
ftdi_usb_purge_buffers (&ftdi);
return;
#endif
if(fdSerialPort != -1) {
tcflush(fdSerialPort, TCIFLUSH);
}
#endif
}
/**
* Close the ChronoVu LA8 USB port and reset the LA8 sequencer logic.
*
* @param devc The struct containing private per-device-instance data.
* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
*/
SR_PRIV int la8_close_usb_reset_sequencer(struct dev_context *devc)
{
/* Magic sequence of bytes for resetting the LA8 sequencer logic. */
uint8_t buf[8] = {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01};
int ret;
if (!devc) {
sr_err("%s: devc was NULL.", __func__);
return SR_ERR_ARG;
}
if (!devc->ftdic) {
sr_err("%s: devc->ftdic was NULL.", __func__);
return SR_ERR_ARG;
}
if (devc->ftdic->usb_dev) {
/* Reset the LA8 sequencer logic, then wait 100ms. */
sr_dbg("Resetting sequencer logic.");
(void) la8_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("%s: ftdi_usb_purge_buffers: (%d) %s.",
__func__, ret, ftdi_get_error_string(devc->ftdic));
if ((ret = ftdi_usb_reset(devc->ftdic)) < 0)
sr_err("%s: ftdi_usb_reset: (%d) %s.", __func__,
ret, ftdi_get_error_string(devc->ftdic));
if ((ret = ftdi_usb_close(devc->ftdic)) < 0)
sr_err("%s: ftdi_usb_close: (%d) %s.", __func__,
ret, ftdi_get_error_string(devc->ftdic));
}
/* Close USB device, deinitialize and free the FTDI context. */
ftdi_free(devc->ftdic); /* Returns void. */
devc->ftdic = NULL;
return SR_OK;
}
static dc_status_t serial_ftdi_flush (void **userdata, dc_direction_t queue)
{
ftdi_serial_t *device = (ftdi_serial_t*) *userdata;
if (device == NULL)
return DC_STATUS_INVALIDARGS;
size_t input;
serial_ftdi_get_received (userdata, &input);
INFO (device->context, "Flush: queue=%u, input=%lu, output=%i", queue, input,
serial_ftdi_get_transmitted (device));
switch (queue) {
case DC_DIRECTION_INPUT: /**< Input direction */
if (ftdi_usb_purge_tx_buffer(device->ftdi_ctx)) {
ERROR (device->context, "%s", ftdi_get_error_string(device->ftdi_ctx));
return DC_STATUS_IO;
}
break;
case DC_DIRECTION_OUTPUT: /**< Output direction */
if (ftdi_usb_purge_rx_buffer(device->ftdi_ctx)) {
ERROR (device->context, "%s", ftdi_get_error_string(device->ftdi_ctx));
return DC_STATUS_IO;
}
break;
case DC_DIRECTION_ALL: /**< All directions */
default:
if (ftdi_usb_purge_buffers(device->ftdi_ctx)) {
ERROR (device->context, "%s", ftdi_get_error_string(device->ftdi_ctx));
return DC_STATUS_IO;
}
break;
}
return DC_STATUS_SUCCESS;
}
static int send_special_waveform(struct ftdi_context *ftdi)
{
int ret;
int i;
uint64_t *wave;
uint8_t release_lines[] = {SET_BITS_LOW, 0, 0};
wave = malloc(SPECIAL_BUFFER_SIZE);
printf("Waiting for the EC power-on sequence ...");
fflush(stdout);
retry:
/* Reset the FTDI into a known state */
ret = ftdi_set_bitmode(ftdi, 0xFF, BITMODE_RESET);
if (ret != 0) {
fprintf(stderr, "failed to reset FTDI\n");
goto special_failed;
}
/*
* set the clock divider,
* so we output a new bitbang value every 2.5us.
*/
ret = ftdi_set_baudrate(ftdi, 160000);
if (ret != 0) {
fprintf(stderr, "failed to set bitbang clock\n");
goto special_failed;
}
/* Enable asynchronous bit-bang mode */
ret = ftdi_set_bitmode(ftdi, 0xFF, BITMODE_BITBANG);
if (ret != 0) {
fprintf(stderr, "failed to set bitbang mode\n");
goto special_failed;
}
/* do usb special waveform */
wave[0] = 0x0;
ftdi_write_data(ftdi, (uint8_t *)wave, 1);
usleep(5000);
/* program each special tick */
for (i = 0; i < TICK_COUNT; ) {
wave[i++] = SPECIAL_PATTERN_SDA_L_SCL_L;
wave[i++] = SPECIAL_PATTERN_SDA_H_SCL_L;
wave[i++] = SPECIAL_PATTERN_SDA_L_SCL_L;
}
wave[19] = SPECIAL_PATTERN_SDA_H_SCL_H;
/* fill the buffer with the waveform pattern */
for (i = TICK_COUNT; i < SPECIAL_BUFFER_SIZE / sizeof(uint64_t); i++)
wave[i] = SPECIAL_PATTERN;
ret = ftdi_write_data(ftdi, (uint8_t *)wave, SPECIAL_BUFFER_SIZE);
if (ret < 0)
fprintf(stderr, "Cannot output special waveform\n");
/* clean everything to go back to regular I2C communication */
ftdi_usb_purge_buffers(ftdi);
ftdi_set_bitmode(ftdi, 0xff, BITMODE_RESET);
config_i2c(ftdi);
ftdi_write_data(ftdi, release_lines, sizeof(release_lines));
/* wait for PLL stable for 5ms (plus remaining USB transfers) */
usleep(10 * MSEC);
/* if we cannot communicate, retry the sequence */
if (check_chipid(ftdi) < 0) {
sleep(1);
goto retry;
}
special_failed:
printf("Done.\n");
free(wave);
return ret;
}
//
// Open the serial port.
// Initialise ftdi_context and use it to open the device
static dc_status_t serial_ftdi_open (void **io, dc_context_t *context)
{
INFO(0, "serial_ftdi_open called");
// Allocate memory.
ftdi_serial_t *device = (ftdi_serial_t *) malloc (sizeof (ftdi_serial_t));
if (device == NULL) {
INFO(0, "couldn't allocate memory");
SYSERROR (context, errno);
return DC_STATUS_NOMEMORY;
}
INFO(0, "setting up ftdi_ctx");
struct ftdi_context *ftdi_ctx = ftdi_new();
if (ftdi_ctx == NULL) {
INFO(0, "failed ftdi_new()");
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->baudrate = 0;
device->nbits = 0;
device->databits = 0;
device->stopbits = 0;
device->parity = 0;
// Initialize device ftdi context
INFO(0, "initialize ftdi_ctx");
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;
}
INFO(0, "call serial_ftdi_open_device");
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;
*io = device;
return DC_STATUS_SUCCESS;
}
int nifalcon_load_firmware(falcon_device* dev, const char* firmware_filename)
{
unsigned int bytes_written, bytes_read;
unsigned char check_msg_1_send[3] = {0x0a, 0x43, 0x0d};
unsigned char check_msg_1_recv[4] = {0x0a, 0x44, 0x2c, 0x0d};
unsigned char check_msg_2[1] = {0x41};
unsigned char send_buf[128], receive_buf[128];
FILE* firmware_file;
int k;
if(!dev->is_initialized) nifalcon_error_return(NIFALCON_DEVICE_NOT_VALID_ERROR, "tried to load firmware on an uninitialized device");
if(!dev->is_open) nifalcon_error_return(NIFALCON_DEVICE_NOT_FOUND_ERROR, "tried to load firmware on an unopened device");
//Clear out current buffers to make sure we have a fresh start
if((dev->falcon_status_code = ftdi_usb_purge_buffers(&(dev->falcon))) < 0) return dev->falcon_status_code;
//Reset the device
if((dev->falcon_status_code = ftdi_usb_reset(&(dev->falcon))) < 0) return dev->falcon_status_code;
//Make sure our latency timer is at 16ms, otherwise firmware checks tend to always fail
if((dev->falcon_status_code = ftdi_set_latency_timer(&(dev->falcon), 16)) < 0) return dev->falcon_status_code;
//Set to:
// 9600 baud
// 8n1
// No Flow Control
// RTS Low
// DTR High
if((dev->falcon_status_code = ftdi_set_baudrate(&(dev->falcon), 9600)) < 0) return dev->falcon_status_code;
if((dev->falcon_status_code = ftdi_set_line_property(&(dev->falcon), BITS_8, STOP_BIT_1, NONE)) < 0) return dev->falcon_status_code;
if((dev->falcon_status_code = ftdi_setflowctrl(&(dev->falcon), SIO_DISABLE_FLOW_CTRL)) < 0) return dev->falcon_status_code;
if((dev->falcon_status_code = ftdi_setrts(&(dev->falcon), 0)) < 0) return dev->falcon_status_code;
if((dev->falcon_status_code = ftdi_setdtr(&(dev->falcon), 0)) < 0) return dev->falcon_status_code;
if((dev->falcon_status_code = ftdi_setdtr(&(dev->falcon), 1)) < 0) return dev->falcon_status_code;
//Send 3 bytes: 0x0a 0x43 0x0d
if((dev->falcon_status_code = nifalcon_write(dev, check_msg_1_send, 3)) < 0) return dev->falcon_status_code;
if((dev->falcon_status_code = nifalcon_read(dev, receive_buf, 4, 1000)) < 0) return dev->falcon_status_code;
//Set to:
// DTR Low
// 140000 baud (0x15 clock ticks per signal)
if((dev->falcon_status_code = ftdi_setdtr(&(dev->falcon),0)) < 0) return dev->falcon_status_code;
if((dev->falcon_status_code = ftdi_set_baudrate(&(dev->falcon), 140000)) < 0) return dev->falcon_status_code;
//Send "A" character
if((dev->falcon_status_code = nifalcon_write(dev, check_msg_2, 1)) < 0) return dev->falcon_status_code;
//Expect back 2 bytes:
// 0x13 0x41
if((dev->falcon_status_code = nifalcon_read(dev, receive_buf, 2, 1000)) < 0) return dev->falcon_status_code;
firmware_file = fopen(firmware_filename, "rb");
if(!firmware_file)
{
nifalcon_error_return(NIFALCON_FIRMWARE_NOT_FOUND_ERROR, "cannot find falcon firmware file");
}
while(!feof(firmware_file))
{
int firmware_bytes_read;
int i;
firmware_bytes_read = fread(send_buf, 1, 128, firmware_file);
if((dev->falcon_status_code = nifalcon_write(dev, send_buf, firmware_bytes_read)) < 0) return dev->falcon_status_code;
if((dev->falcon_status_code = nifalcon_read(dev, receive_buf, firmware_bytes_read, 1000)) < firmware_bytes_read)
{
nifalcon_error_return(NIFALCON_FIRMWARE_CHECKSUM_ERROR, "error sending firmware (firmware send step, 128 byte reply not received)");
}
for(i = 0; i < firmware_bytes_read; ++i)
{
if(send_buf[i] != receive_buf[i])
{
nifalcon_error_return(NIFALCON_FIRMWARE_CHECKSUM_ERROR, "error sending firmware (firmware send step, checksum does not match)");
}
}
if(firmware_bytes_read < 128) break;
}
fclose(firmware_file);
//VERY IMPORTANT
//If we do not reset latency to 1ms, then we either have to fill the FTDI butter (64bytes) or wait 16ms
//to get any data back. This is what was causing massive slowness in pre-1.0 releases
if((dev->falcon_status_code = ftdi_set_latency_timer(&(dev->falcon), 1)) < 0) return dev->falcon_status_code;
//Shift to full speed
if((dev->falcon_status_code = ftdi_set_baudrate(&(dev->falcon), 1456312)) < 0) return dev->falcon_status_code;
return 0;
}
static int dev_open(struct sr_dev_inst *sdi)
{
struct dev_context *devc;
int ret;
devc = sdi->priv;
/* Select interface A, otherwise communication will fail. */
ret = ftdi_set_interface(devc->ftdic, INTERFACE_A);
if (ret < 0) {
sr_err("Failed to set FTDI interface A (%d): %s", ret,
ftdi_get_error_string(devc->ftdic));
return SR_ERR;
}
sr_dbg("FTDI chip interface A set successfully.");
/* Open the device. */
ret = ftdi_usb_open_desc(devc->ftdic, USB_VENDOR_ID, USB_DEVICE_ID,
USB_IPRODUCT, NULL);
if (ret < 0) {
sr_err("Failed to open device (%d): %s", ret,
ftdi_get_error_string(devc->ftdic));
return SR_ERR;
}
sr_dbg("FTDI 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 RX/TX buffers (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
goto err_dev_open_close_ftdic;
}
sr_dbg("FTDI chip buffers purged successfully.");
/* Reset the FTDI bitmode. */
ret = ftdi_set_bitmode(devc->ftdic, 0xff, BITMODE_RESET);
if (ret < 0) {
sr_err("Failed to reset the FTDI chip bitmode (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
goto err_dev_open_close_ftdic;
}
sr_dbg("FTDI chip bitmode reset successfully.");
/* Set FTDI bitmode to "sync FIFO". */
ret = ftdi_set_bitmode(devc->ftdic, 0xff, BITMODE_SYNCFF);
if (ret < 0) {
sr_err("Failed to put FTDI chip into sync FIFO mode (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
goto err_dev_open_close_ftdic;
}
sr_dbg("FTDI chip sync FIFO mode entered successfully.");
/* Set the FTDI latency timer to 2. */
ret = ftdi_set_latency_timer(devc->ftdic, 2);
if (ret < 0) {
sr_err("Failed to set FTDI latency timer (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
goto err_dev_open_close_ftdic;
}
sr_dbg("FTDI chip latency timer set successfully.");
/* Set the FTDI read data chunk size to 64kB. */
ret = ftdi_read_data_set_chunksize(devc->ftdic, 64 * 1024);
if (ret < 0) {
sr_err("Failed to set FTDI read data chunk size (%d): %s.",
ret, ftdi_get_error_string(devc->ftdic));
goto err_dev_open_close_ftdic;
}
sr_dbg("FTDI chip read data chunk size set successfully.");
/* Get the ScanaPLUS device ID from the FTDI EEPROM. */
if ((ret = scanaplus_get_device_id(devc)) < 0) {
sr_err("Failed to get ScanaPLUS device ID: %d.", ret);
goto err_dev_open_close_ftdic;
}
sr_dbg("Received ScanaPLUS device ID successfully: %02x %02x %02x.",
devc->devid[0], devc->devid[1], devc->devid[2]);
sdi->status = SR_ST_ACTIVE;
return SR_OK;
err_dev_open_close_ftdic:
scanaplus_close(devc);
return SR_ERR;
}
Ft245sync::Ft245sync(unsigned int chunkSizeRead,
unsigned int chunkSizeWrite,
uint8_t gpio,
struct ftdi_context * vftdic,
struct ftdi_context * vftdic2)
{
if(vftdic == NULL)
{
this->ftdic = static_cast<struct ftdi_context*>(malloc(sizeof(struct ftdi_context)));
}
else
{
this->ftdic = vftdic;
}
if(vftdic2 == NULL)
{
this->ftdic2 = static_cast<struct ftdi_context*>(malloc(sizeof(struct ftdi_context)));
}
else
{
this->ftdic2 = vftdic2;
}
int f;
// Init 1. channel
if (ftdi_init(ftdic) < 0)
{
throw Exception("ftdi_init failure\n");
}
ftdi_set_interface(ftdic, INTERFACE_A);
f = ftdi_usb_open(ftdic, 0x0403, PID);
if (f < 0 && f != -5)
{
throw Exception("Unable to open FTDI device, channel A\n");
}
// Init 2. channel
if (ftdi_init(ftdic2) < 0)
{
throw Exception("ftdi_init failure\n");
}
ftdi_usb_reset(ftdic);
ftdi_usb_reset(ftdic2);
ftdi_set_interface(ftdic2, INTERFACE_B);
f = ftdi_usb_open(ftdic2, 0x0403, PID);
if (f < 0 && f != -5)
{
throw Exception("Unable to open FTDI device, channel B\n");
}
ftdi_write_data_set_chunksize(ftdic2, 512);
ftdi_set_interface(ftdic2, INTERFACE_B);
ftdi_usb_reset(ftdic2);
ftdi_set_latency_timer(ftdic2, 2);
ftdi_setflowctrl(ftdic2, SIO_RTS_CTS_HS);
ftdi_set_bitmode(ftdic2, 0, BBMODE_SPI);
uint8_t buf[3];
buf[0] = SET_BITS_LOW;
buf[1] = 8;
buf[2] = BIT_DIR; //holding programming of FPGA*/
ftdi_write_data(ftdic2, buf, 3);
buf[0] = SET_BITS_HIGH;
buf[1] = 0xFF; //lighting leds
buf[2] = BIT_DIR;
ftdi_write_data(ftdic2, buf, 3);
buf[0] = SET_BITS_HIGH;
buf[1] = 0x00; //lighting leds
buf[2] = BIT_DIR;
ftdi_write_data(ftdic2, buf, 3);
buf[0] = SET_BITS_LOW;
buf[1] = gpio;
buf[2] = BIT_DIR; //releasing programming of FPGA
ftdi_write_data(ftdic2, buf, 3);
sleep(1);
buf[0] = SET_BITS_LOW;
buf[1] = 0xFF; //reseting design in FPGA
buf[2] = BIT_DIR;
ftdi_write_data(ftdic2, buf, 3);
sleep(1);
buf[0] = SET_BITS_LOW;
buf[1] = 0xDD; //releasing reset
buf[2] = BIT_DIR;
ftdi_write_data(ftdic2, buf, 3);
sleep(1);
buf[0] = SET_BITS_HIGH;
buf[1] = 0xFF; //lighting leds
buf[2] = BIT_DIR;
ftdi_write_data(ftdic2, buf, 3);
if (ftdi_usb_purge_buffers(ftdic2))
{
throw Exception("Purging buffers failed\n");
}
ftdi_usb_close(ftdic2); // close channel 2
ftdi_deinit(ftdic2); // close channel 2
ftdic->usb_read_timeout = READ_TIMEOUT;
ftdic->usb_write_timeout = WRITE_TIMEOUT;
ftdi_read_data_set_chunksize(ftdic, chunkSizeRead);
ftdi_write_data_set_chunksize(ftdic, chunkSizeWrite);
if (ftdi_usb_reset(ftdic))
{
throw Exception("Reset failed\n");
}
usleep(1000);
if(ftdi_usb_purge_buffers(ftdic) < 0)
{
throw Exception("Setting FT2232 synchronous bitmode failed\n");
}
if(ftdi_set_bitmode(ftdic, 0xFF, 0x00) < 0)
{
throw Exception("Setting FT2232 synchronous bitmode failed\n");
}
if(ftdi_set_bitmode(ftdic, 0xFF, 0x40) < 0)
{
throw Exception("Setting FT2232 synchronous bitmode failed\n");
}
if (ftdi_set_latency_timer(ftdic, 2)) /* AN_130 */
{
throw Exception("Set latency failed failed\n");
}
//SetUSBParameters(ftHandle,0x10000, 0x10000);
if (ftdi_setflowctrl(ftdic, SIO_RTS_CTS_HS)) // AN_130
{
throw Exception("Set RTS_CTS failed\n");
}
/*if(ftdi_usb_purge_buffers(ftdic) < 0)
{
throw Exception("Setting FT2232 synchronous bitmode failed\n");
}*/
//fixes unalignment of first read (should be fixed in cleaner manner)
usleep(400);
unsigned char cleanup[10] = { 0xBB, 0xBB, 0xBB, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA };
ftdi_write_data(ftdic, cleanup, 10);
unsigned char recvbuf[4000];
read(recvbuf);
}
QList<DMXInterface *> LibFTDIInterface::interfaces(QList<DMXInterface *> discoveredList)
{
QList <DMXInterface*> interfacesList;
int id = 0;
struct ftdi_context ftdi;
ftdi_init(&ftdi);
#ifdef LIBFTDI1
libusb_device *dev;
libusb_device **devs;
struct libusb_device_descriptor dev_descriptor;
int i = 0;
if (libusb_get_device_list(ftdi.usb_ctx, &devs) < 0)
{
qDebug() << "usb_find_devices() failed";
return interfacesList;
}
while ((dev = devs[i++]) != NULL)
{
libusb_get_device_descriptor(dev, &dev_descriptor);
#else
struct usb_bus *bus;
struct usb_device *dev;
struct usb_device_descriptor dev_descriptor;
usb_init();
if (usb_find_busses() < 0)
{
qDebug() << "usb_find_busses() failed";
return interfacesList;
}
if (usb_find_devices() < 0)
{
qDebug() << "usb_find_devices() failed";
return interfacesList;
}
for (bus = usb_get_busses(); bus; bus = bus->next)
{
for (dev = bus->devices; dev; dev = dev->next)
{
dev_descriptor = dev->descriptor;
#endif
Q_ASSERT(dev != NULL);
// Skip non wanted devices
if (validInterface(dev_descriptor.idVendor, dev_descriptor.idProduct) == false)
continue;
char ser[256];
memset(ser, 0, 256);
char nme[256];
char vend[256];
ftdi_usb_get_strings(&ftdi, dev, vend, 256, nme, 256, ser, 256);
QString serial(ser);
QString name(nme);
QString vendor(vend);
qDebug() << Q_FUNC_INFO << "DMX USB VID:" << QString::number(dev_descriptor.idVendor, 16) <<
"PID:" << QString::number(dev_descriptor.idProduct, 16);
qDebug() << Q_FUNC_INFO << "DMX USB serial: " << serial << "name:" << name << "vendor:" << vendor;
bool found = false;
for (int c = 0; c < discoveredList.count(); c++)
{
if (discoveredList.at(c)->checkInfo(serial, name, vendor) == true)
{
found = true;
break;
}
}
if (found == false)
{
LibFTDIInterface *iface = new LibFTDIInterface(serial, name, vendor, dev_descriptor.idVendor,
dev_descriptor.idProduct, id++);
#ifdef LIBFTDI1
iface->setBusLocation(libusb_get_port_number(dev));
#else
iface->setBusLocation(dev->bus->location);
#endif
interfacesList << iface;
}
#ifndef LIBFTDI1
}
#endif
}
#ifdef LIBFTDI1
libusb_free_device_list(devs, 1);
#endif
ftdi_deinit(&ftdi);
return interfacesList;
}
bool LibFTDIInterface::open()
{
if (isOpen() == true)
return true;
QByteArray sba = serial().toLatin1();
const char *ser = NULL;
if (serial().isEmpty() == false)
ser = (const char *)sba.data();
if (ftdi_usb_open_desc(&m_handle, vendorID(), productID(),
name().toLatin1(), ser) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::openByPID(const int PID)
{
if (isOpen() == true)
return true;
if (ftdi_usb_open(&m_handle, DMXInterface::FTDIVID, PID) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::close()
{
if (ftdi_usb_close(&m_handle) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::isOpen() const
{
return (m_handle.usb_dev != NULL) ? true : false;
}
bool LibFTDIInterface::reset()
{
if (ftdi_usb_reset(&m_handle) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::setLineProperties()
{
if (ftdi_set_line_property(&m_handle, BITS_8, STOP_BIT_2, NONE) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::setBaudRate()
{
if (ftdi_set_baudrate(&m_handle, 250000) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::setFlowControl()
{
if (ftdi_setflowctrl(&m_handle, SIO_DISABLE_FLOW_CTRL) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::clearRts()
{
if (ftdi_setrts(&m_handle, 0) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::purgeBuffers()
{
if (ftdi_usb_purge_buffers(&m_handle) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
bool LibFTDIInterface::setBreak(bool on)
{
ftdi_break_type type;
if (on == true)
type = BREAK_ON;
else
type = BREAK_OFF;
if (ftdi_set_line_property2(&m_handle, BITS_8, STOP_BIT_2, NONE, type) < 0)
{
qWarning() << Q_FUNC_INFO << name() << ftdi_get_error_string(&m_handle);
return false;
}
else
{
return true;
}
}
int spi_open(int nport)
{
LOG(DEBUG, "(%d) spi_dev_open=%d", nport, spi_dev_open);
if (spi_dev_open > 0) {
LOG(WARN, "Superfluos call to spi_open()");
return 0;
}
if (spi_nports == 0 || nport < spi_nports - 1) {
SPI_ERR("No FTDI device found");
goto open_err;
}
#ifdef SPI_STATS
memset(&spi_stats, 0, sizeof(spi_stats));
if (gettimeofday(&spi_stats.tv_open_begin, NULL) < 0)
LOG(WARN, "gettimeofday failed: %s", strerror(errno));
#endif
/*ftdi_set_interface(&ftdic, INTERFACE_A);*/ /* XXX for multichannel chips */
if (ftdi_usb_open_desc(&ftdic, spi_ports[nport].vid, spi_ports[nport].pid,
NULL, spi_ports[nport].serial) < 0)
{
SPI_ERR("FTDI: ftdi_usb_open_desc() failed: %s", ftdi_get_error_string(&ftdic));
goto open_err;
}
spi_dev_open++;
LOG(INFO, "FTDI: using FTDI device: \"%s\"", spi_ports[nport].name);
if (ftdi_usb_reset(&ftdic) < 0) {
SPI_ERR("FTDI: reset failed: %s", ftdi_get_error_string(&ftdic));
goto open_err;
}
if (ftdi_usb_purge_buffers(&ftdic) < 0) {
SPI_ERR("FTDI: purge buffers failed: %s", ftdi_get_error_string(&ftdic));
goto open_err;
}
/* Set 1 ms latency timer, see FTDI AN232B-04 */
if (ftdi_set_latency_timer(&ftdic, 1) < 0) {
SPI_ERR("FTDI: setting latency timer failed: %s", ftdi_get_error_string(&ftdic));
goto open_err;
}
if (ftdi_set_bitmode(&ftdic, 0, BITMODE_RESET) < 0) {
SPI_ERR("FTDI: reset bitmode failed: %s", ftdi_get_error_string(&ftdic));
goto open_err;
}
if (ftdi_set_bitmode(&ftdic, PINS_OUTPUT, BITMODE_SYNCBB) < 0) {
SPI_ERR("FTDI: set synchronous bitbang mode failed: %s", ftdi_get_error_string(&ftdic));
goto open_err;
}
/*
* Note on buffer sizes:
*
* FT232R has 256 byte receive buffer and 128 byte transmit buffer. It works
* like 384 byte buffer. See:
* http://developer.intra2net.com/mailarchive/html/libftdi/2011/msg00410.html
* http://developer.intra2net.com/mailarchive/html/libftdi/2011/msg00413.html
* http://jdelfes.blogspot.ru/2014/03/ft232r-bitbang-spi-part-2.html
*
* FT2232C has 128 byte TX and 384 byte RX buffers per channel.
* FT2232H has 4kB RX and TX buffers per channel.
* FT4232H has 2kB RX and TX buffers per channel.
* FT232H has 1 kB RX and TX buffers.
* FT230X has 512 byte TX and RX buffers.
*/
switch (ftdic.type) {
case TYPE_AM:
ftdi_type_str = "FT232AM";
SPI_ERR("This chip type is not supported: %s", ftdi_type_str);
goto open_err;
break;
case TYPE_BM:
ftdi_type_str = "FT232BM";
SPI_ERR("This chip type is not supported: %s", ftdi_type_str);
goto open_err;
break;
case TYPE_2232C:
ftdi_type_str = "FT2232C/D";
ftdi_buf_size = 512;
break;
case TYPE_R:
ftdi_type_str = "FT232R";
ftdi_buf_size = 384;
break;
case TYPE_2232H:
ftdi_type_str = "FT2232H";
ftdi_buf_size = 8192;
break;
case TYPE_4232H:
ftdi_type_str = "FT4232H";
ftdi_buf_size = 4096;
break;
case TYPE_232H:
ftdi_type_str = "FT232H";
ftdi_buf_size = 2048;
break;
/* TYPE_230X is supported since libftdi1-1.2 */
/*case TYPE_230X:
ftdi_type_str = "FT230X";
ftdi_buf_size = 1024;
break;
*/
default:
LOG(WARN, "Unknown FTDI chip type, assuming FT232R");
ftdi_type_str = "Unknown";
ftdi_buf_size = 384;
break;
}
LOG(INFO, "Detected %s type programmer chip, buffer size: %u",
ftdi_type_str, ftdi_buf_size);
/* Initialize xfer buffer */
ftdi_buf = malloc(ftdi_buf_size);
if (ftdi_buf == NULL) {
SPI_ERR("Not enough memory");
goto open_err;
}
ftdi_buf_write_offset = 0;
ftdi_pin_state = PINS_INIT;
ftdi_buf[ftdi_buf_write_offset++] = ftdi_pin_state;
return 0;
open_err:
if (spi_dev_open > 0)
ftdi_usb_close(&ftdic);
spi_dev_open = 0;
return -1;
}
