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; }