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;
}
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;
}
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;
}
void begin(struct ftdi_context *ftdi)
{
ftdi_usb_reset(ftdi);
ftdi_usb_purge_rx_buffer(ftdi);
ftdi_usb_purge_tx_buffer(ftdi);
ftdi_setrts(ftdi, 1);
}
int Context::flush(int mask)
{
int ret = 1;
if (mask & Input)
ret &= ftdi_usb_purge_rx_buffer(d->ftdi);
if (mask & Output)
ret &= ftdi_usb_purge_tx_buffer(d->ftdi);
return ret;
}
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;
}
static dc_status_t serial_ftdi_purge (void *io, dc_direction_t queue)
{
ftdi_serial_t *device = io;
if (device == NULL)
return DC_STATUS_INVALIDARGS;
size_t input;
serial_ftdi_get_received (io, &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_reset(device->ftdi_ctx)) {
ERROR (device->context, "%s", ftdi_get_error_string(device->ftdi_ctx));
return DC_STATUS_IO;
}
break;
}
return DC_STATUS_SUCCESS;
}
/* prepare the FTDI USB device */
int do_init(struct ftdi2s88_t *fs88) {
fs88->ftdic = ftdi_new();
if (!fs88->ftdic) {
fprintf(stderr, "ftdi_new failed\n");
return -1;
}
if (ftdi_usb_open_desc(fs88->ftdic, 0x0403, 0x6001, NULL, NULL) < 0) {
/* if (ftdi_usb_open_desc(ftdic, 0x0403, 0x6015, NULL, NULL) < 0) { */
fprintf(stderr, "ftdi_usb_open_desc failed: %s\n", ftdi_get_error_string(fs88->ftdic));
return -1;
}
if (ftdi_set_bitmode(fs88->ftdic, BITBANG_MASK, BITMODE_SYNCBB) < 0) {
fprintf(stderr, "ftdi_set_bitmode failed: %s\n", ftdi_get_error_string(fs88->ftdic));
return -1;
}
if (ftdi_set_baudrate(fs88->ftdic, fs88->baudrate) < 0) {
fprintf(stderr, "ftdi_set_baudrate failed: %s\n", ftdi_get_error_string(fs88->ftdic));
return -1;
}
if (ftdi_usb_purge_tx_buffer(fs88->ftdic)) {
fprintf(stderr, "tx buffer flushing failed: %s\n", ftdi_get_error_string(fs88->ftdic));
return -1;
}
if (ftdi_usb_purge_rx_buffer(fs88->ftdic)) {
fprintf(stderr, "rx buffer flushing failed: %s\n", ftdi_get_error_string(fs88->ftdic));
return -1;
}
return 0;
}
static void child_process(int fd_rx2main, int fd_main2tx, int fd_tx2main)
{
int ret = 0;
struct ftdi_context ftdic;
alarm(0);
signal(SIGTERM, SIG_DFL);
signal(SIGPIPE, SIG_DFL);
signal(SIGINT, SIG_DFL);
signal(SIGHUP, SIG_IGN);
signal(SIGALRM, SIG_IGN);
ftdi_init(&ftdic);
/* indicate we're started: */
ret = write(fd_tx2main, &ret, 1);
while (1) {
/* Open the USB device */
if (ftdi_usb_open_desc(&ftdic, usb_vendor, usb_product, usb_desc, usb_serial) < 0) {
logprintf(LIRC_ERROR, "unable to open FTDI device (%s)", ftdi_get_error_string(&ftdic));
goto retry;
}
/* Enable bit-bang mode, setting output & input pins
* direction */
if (ftdi_set_bitmode(&ftdic, 1 << output_pin, BITMODE_BITBANG) < 0) {
logprintf(LIRC_ERROR, "unable to enable bitbang mode (%s)", ftdi_get_error_string(&ftdic));
goto retry;
}
/* Set baud rate */
if (ftdi_set_baudrate(&ftdic, rx_baud_rate) < 0) {
logprintf(LIRC_ERROR, "unable to set required baud rate (%s)", ftdi_get_error_string(&ftdic));
goto retry;
}
logprintf(LIRC_DEBUG, "opened FTDI device '%s' OK", drv.device);
do {
unsigned char buf[RXBUFSZ > TXBUFSZ ? RXBUFSZ : TXBUFSZ];
/* transmit IR */
ret = read(fd_main2tx, buf, sizeof(buf));
if (ret > 0) {
/* select correct transmit baudrate */
if (ftdi_set_baudrate(&ftdic, tx_baud_rate) < 0) {
logprintf(LIRC_ERROR, "unable to set required baud rate for transmission (%s)",
ftdi_get_error_string(&ftdic));
goto retry;
}
if (ftdi_write_data(&ftdic, buf, ret) < 0)
logprintf(LIRC_ERROR, "enable to write ftdi buffer (%s)",
ftdi_get_error_string(&ftdic));
if (ftdi_usb_purge_tx_buffer(&ftdic) < 0)
logprintf(LIRC_ERROR, "unable to purge ftdi buffer (%s)",
ftdi_get_error_string(&ftdic));
/* back to rx baudrate: */
if (ftdi_set_baudrate(&ftdic, rx_baud_rate) < 0) {
logprintf(LIRC_ERROR, "unable to set restore baudrate for reception (%s)",
ftdi_get_error_string(&ftdic));
goto retry;
}
/* signal transmission ready: */
ret = write(fd_tx2main, &ret, 1);
continue;
}
/* receive IR */
ret = ftdi_read_data(&ftdic, buf, RXBUFSZ);
if (ret > 0)
parsesamples(buf, ret, fd_rx2main);
} while (ret > 0);
retry:
/* Wait a while and try again */
usleep(500000);
}
}
