static int ublast_ftdi_init(struct ublast_lowlevel *low)
{
uint8_t latency_timer;
struct ftdi_context *ftdic = ublast_getftdic(low);
LOG_INFO("usb blaster interface using libftdi");
if (ftdi_init(ftdic) < 0)
return ERROR_JTAG_INIT_FAILED;
/* context, vendor id, product id */
if (ftdi_usb_open(ftdic, low->ublast_vid, low->ublast_pid) < 0) {
LOG_ERROR("unable to open ftdi device: %s", ftdic->error_str);
return ERROR_JTAG_INIT_FAILED;
}
if (ftdi_usb_reset(ftdic) < 0) {
LOG_ERROR("unable to reset ftdi device");
return ERROR_JTAG_INIT_FAILED;
}
if (ftdi_set_latency_timer(ftdic, 2) < 0) {
LOG_ERROR("unable to set latency timer");
return ERROR_JTAG_INIT_FAILED;
}
if (ftdi_get_latency_timer(ftdic, &latency_timer) < 0) {
LOG_ERROR("unable to get latency timer");
return ERROR_JTAG_INIT_FAILED;
}
LOG_DEBUG("current latency timer: %u", latency_timer);
ftdi_disable_bitbang(ftdic);
return ERROR_OK;
}
void spi_end()
{
prog_end();
ftdi_disable_bitbang(ftdi);
ftdi_free(ftdi);
}
void spi_init(void) {
int ret;
ftdi = ftdi_new();
if (!ftdi) {
fatal_error("ftdi_new failed!\n");
}
ret = ftdi_usb_open(ftdi, 0x0403, 0x6001);
if (ret < 0 && ret != -5) {
ftdi_free(ftdi);
fatal_error("unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
}
ret = ftdi_set_bitmode(ftdi, PINS_OUT, BITMODE_SYNCBB);
if (ret != 0) {
ftdi_free(ftdi);
fatal_error("unable to set bitmode: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
}
ret = ftdi_set_baudrate(ftdi, 57600);
if (ret != 0) {
ftdi_disable_bitbang(ftdi);
ftdi_free(ftdi);
fatal_error("unable to set baudrate: %d (%s)\n", ret, ftdi_get_error_string(ftdi));
}
}
void jtagkey_close(int handle) {
if (handle == 0xff) {
ftdi_disable_bitbang(&ftdic);
ftdi_usb_close(&ftdic);
ftdi_deinit(&ftdic);
}
}
/*
* use libftdi and libusb to send command
* no kernel driver needed
*/
int usbWriteFtdi(char *cmdstr)
{
struct ftdi_context ctx;
int device=0x0c30, vendor=0x1781;
if (ftdi_init( &ctx )) {
fprintf(stderr, "usb - init error !\n");
return 1;
}
if (ftdi_usb_open(&ctx, vendor, device)) {
fprintf(stderr, "usb - open error (cannot find?) !\n");
ftdi_deinit( &ctx );
return 2;
}
if (ftdi_usb_reset( &ctx )) {
fprintf(stderr, "usb - reset error !\n");
ftdi_usb_close( &ctx );
ftdi_deinit( &ctx );
return 3;
}
ftdi_disable_bitbang( &ctx );
ftdi_set_baudrate(&ctx, BAUD);
ftdi_write_data( &ctx, cmdstr, strlen(cmdstr) );
sleep(1); /* just for sure */
ftdi_usb_close( &ctx );
ftdi_deinit( &ctx );
return 0;
}
void release(void)
{
if(ftdi) {
ftdi_disable_bitbang(ftdi);
ftdi_usb_close(ftdi);
ftdi_free(ftdi);
ftdi = NULL;
}
}
struct ftdi_context *
bub_init(unsigned int baud_rate,
unsigned char latency,
unsigned int tx_buf_size,
unsigned int rx_buf_size) {
int ret = 0;
struct ftdi_context *ftdic;
ftdic = malloc(sizeof(struct ftdi_context));
if(ftdic == NULL) {
perror("malloc");
return(NULL);
}
ret = ftdi_init(ftdic);
if (ret < 0) {
fprintf(stderr, "ftdi_init failed: %d.\n", ret);
return(NULL);
}
ftdi_set_interface(ftdic, INTERFACE_ANY);
ret = ftdi_usb_open(ftdic, 0x0403, 0x6001); // FIXME make nice defines
if(ret < 0) {
fprintf(stderr, "unable to open ftdi device: %d (%s)\n",
ret, ftdi_get_error_string(ftdic));
return(NULL);
}
if(ftdi_usb_reset(ftdic) != 0)
fprintf(stderr, "WARN: ftdi_usb_reset failed!\n");
ftdi_disable_bitbang(ftdic);
if (ftdi_set_baudrate(ftdic, baud_rate) < 0) {
fprintf(stderr, "Unable to set baudrate: (%s)\n",
ftdi_get_error_string(ftdic));
return(NULL);
}
ftdi_set_latency_timer(ftdic, latency);
if(tx_buf_size > 0)
ftdi_write_data_set_chunksize(ftdic, tx_buf_size);
if(rx_buf_size > 0)
ftdi_read_data_set_chunksize(ftdic, rx_buf_size);
return(ftdic);
}
int main(void)
{
struct ftdi_context ftdic;
int f;
unsigned char buf[1];
unsigned char bitmask;
unsigned char input[10];
if (ftdi_init(&ftdic) < 0)
{
fprintf(stderr, "ftdi_init failed\n");
return EXIT_FAILURE;
}
f = ftdi_usb_open(&ftdic, 0x0403, 0x6001);
if (f < 0 && f != -5)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(&ftdic));
exit(-1);
}
printf("ftdi open succeeded: %d\n",f);
while (1)
{
// Set bitmask from input
fgets(input, sizeof(input) - 1, stdin);
if (input[0] == '\n') break;
bitmask = strtol(input, NULL, 0);
printf("Using bitmask 0x%02x\n", bitmask);
f = ftdi_set_bitmode(&ftdic, bitmask, BITMODE_CBUS);
if (f < 0)
{
fprintf(stderr, "set_bitmode failed for 0x%x, error %d (%s)\n", bitmask, f, ftdi_get_error_string(&ftdic));
exit(-1);
}
// read CBUS
f = ftdi_read_pins(&ftdic, &buf[0]);
if (f < 0)
{
fprintf(stderr, "read_pins failed, error %d (%s)\n", f, ftdi_get_error_string(&ftdic));
exit(-1);
}
printf("Read returned 0x%01x\n", buf[0] & 0x0f);
}
printf("disabling bitbang mode\n");
ftdi_disable_bitbang(&ftdic);
ftdi_usb_close(&ftdic);
ftdi_deinit(&ftdic);
}
int main(void) {
snd_rawmidi_open(&midi_in, &midi_out, "virtual", SND_RAWMIDI_NONBLOCK);
//snd_rawmidi_open(&midi_in, &midi_out, "virtual", 0);
if (ftdi_init( &ftdi )) {
fprintf(stderr, "usb - init error !\n");
return 1;
}
if (ftdi_usb_open(&ftdi, 0x0403, 0x6001)) {
fprintf(stderr, "usb - open error (cannot find?) !\n");
fprintf(stderr, "ftdi_usb_open failed, error (%s)\n", ftdi_get_error_string(&ftdi));
ftdi_deinit( &ftdi );
return 2;
}
if (ftdi_usb_reset( &ftdi )) {
fprintf(stderr, "usb - reset error !\n");
ftdi_usb_close( &ftdi );
ftdi_deinit( &ftdi );
return 3;
}
ftdi_disable_bitbang( &ftdi );
ftdi_set_baudrate(&ftdi, BAUD);
unsigned char buf[BUFFER_SIZE];
int ret;
while(1) {
//FTDI2MIDI
ret = ftdi_read_data(&ftdi, buf, BUFFER_SIZE);
if(ret < 0) break;
if(ret > 0) snd_rawmidi_write(midi_out, buf, BUFFER_SIZE);
//MIDI2FTDI
/*
ret = snd_rawmidi_read(midi_in, buf,BUFFER_SIZE);
if(ret < 0 && ret != -EAGAIN) break;
if(ret > 0) ftdi_write_data(&ftdi, buf,BUFFER_SIZE);
*/
usleep(LATENCY);
}
exit(0);
}
int main()
{
unsigned char c = 0;
struct ftdi_context ftdic;
/* Initialize context for subsequent function calls */
ftdi_init(&ftdic);
/* Open FTDI device based on FT232R vendor & product IDs */
if(ftdi_usb_open(&ftdic, 0x0403, 0x6001) < 0) {
puts("Can't open device");
return 1;
}
/* Enable bitbang mode with a single output line */
// ftdi_enable_bitbang(&ftdic, LED);
if (ftdi_set_bitmode(&ftdic, LED, BITMODE_BITBANG) < 0)
puts( "Can't enable bitbang");
/* Endless loop: invert LED state, write output, pause 1 second */
// for(;;) {
ftdi_write_data(&ftdic, &c, 1); //low
sleep(1);
c ^= LED;
ftdi_write_data(&ftdic, &c, 1);//high
sleep(1);
c ^= LED;
ftdi_write_data(&ftdic, &c, 1);//low
// }
// ftdi_set_bitmode(&ftdic, LED, 0x00);
if(ftdi_disable_bitbang(&ftdic) < 0)
puts("Can't disable bitbang");
// if(ftdi_usb_reset(&ftdic) < 0)
// puts("Can't reset device");
if(ftdi_usb_close(&ftdic)<0)
puts("Can't close device");
ftdi_deinit(&ftdic);
}
int Context::bitbang_disable()
{
return ftdi_disable_bitbang(d->ftdi);
}
void relay_cleanup () {
ftdi_disable_bitbang(ftdi);
ftdi_usb_close(ftdi);
ftdi_free(ftdi);
}
int main(int argc, char **argv)
{
struct ftdi_context ftdic;
char buf[16];
int r,i;
// Initialize FTDI Driver
if (ftdi_init(&ftdic) < 0)
{
fprintf(stderr, "ftdi_init failed\n");
return EXIT_FAILURE;
}
// Initialize Channel A on Device with corresponding VID, PID
ftdi_set_interface(&ftdic, INTERFACE_A);
r = ftdi_usb_open(&ftdic, DEVICE_VID, DEVICE_PID);
if (r < 0 && r != -5)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", r, ftdi_get_error_string(&ftdic));
exit(-1);
}
printf("FTDI Open Succeeded on Channel A: %d\n",r);
printf("Enabling MPSSE Mode on Channel A\n\n");
ftdi_set_bitmode(&ftdic, 0xFF, BITMODE_MPSSE);
// Enable the Div-By-5 Clock Prescaler
buf[0] = EN_DIV_5;
send_buf(&ftdic, buf, 1);
recv_buf(&ftdic, buf, 1);
// Configure the clock divisor for SPI
buf[0] = TCK_DIVISOR;
buf[1] = 0x00; // set to 0x0000 for 6MHz SPI Clock
buf[2] = 0x00;
send_buf(&ftdic, buf, 3);
// Configure and check Pin State
buf[0] = SET_BITS_LOW;
buf[1] = 0x08; // 0x08 = 0b00001000 ==> CS=High, Start SK low
buf[2] = 0x0B; // 0x0B = 0b00001011 ==> SK,DO,CS=Output
send_buf(&ftdic, buf, 3);
buf[0] = GET_BITS_LOW;
send_buf(&ftdic, buf, 1);
recv_buf(&ftdic, buf, 1);
printf("Current State of IO Pins = 0x%02X\n\n", (uint8_t)buf[0]);
SPI_SRAM_23K256_Init(&ftdic);
SPI_SRAM_23K256_Read_Byte(&ftdic, 0x5555);
SPI_SRAM_23K256_Write_Byte(&ftdic, 0x5555, ((uint8_t)(&buf)) ); // a random value
SPI_SRAM_23K256_Read_Byte(&ftdic, 0x5555);
SPI_SRAM_23K256_Read_Byte(&ftdic, 0x5556);
printf("\nDisabling and Exiting FTDI Communication\n");
ftdi_disable_bitbang(&ftdic);
ftdi_usb_close(&ftdic);
ftdi_deinit(&ftdic);
}
int main(int argc, char **argv)
{
struct ftdi_context ftdic;
int f,i;
char buf[1];
if (ftdi_init(&ftdic) < 0)
{
fprintf(stderr, "ftdi_init failed\n");
return EXIT_FAILURE;
}
f = ftdi_usb_open(&ftdic, 0x0403, 0x6001);
if (f < 0 && f != -5)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(&ftdic));
exit(-1);
}
printf("ftdi open succeeded: %d\n",f);
printf("enabling bitbang mode\n");
ftdi_set_bitmode(&ftdic, 0xFF, BITMODE_BITBANG);
sleep(3);
buf[0] = 0x0;
printf("turning everything on\n");
f = ftdi_write_data(&ftdic, buf, 1);
if (f < 0)
{
fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, ftdi_get_error_string(&ftdic));
}
sleep(3);
buf[0] = 0xFF;
printf("turning everything off\n");
f = ftdi_write_data(&ftdic, buf, 1);
if (f < 0)
{
fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, ftdi_get_error_string(&ftdic));
}
sleep(3);
for (i = 0; i < 32; i++)
{
buf[0] = 0 | (0xFF ^ 1 << (i % 8));
if ( i > 0 && (i % 8) == 0)
{
printf("\n");
}
printf("%02hhx ",buf[0]);
fflush(stdout);
f = ftdi_write_data(&ftdic, buf, 1);
if (f < 0)
{
fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, ftdi_get_error_string(&ftdic));
}
sleep(1);
}
printf("\n");
printf("disabling bitbang mode\n");
ftdi_disable_bitbang(&ftdic);
ftdi_usb_close(&ftdic);
ftdi_deinit(&ftdic);
}
int spi_begin(uint8_t bus, uint8_t port)
{
int ret;
ftdi = ftdi_new();
if (ftdi == 0) {
fprintf(stderr, "ftdi_new failed\n");
return -1;
}
if (bus > 0) {
struct ftdi_device_list *list = NULL;
struct ftdi_device_list *p;
ret = ftdi_usb_find_all(ftdi, &list, 0, 0);
if (ret < 0) {
fprintf(stderr, "unable to list devices: %d (%s)\n",
ret, ftdi_get_error_string(ftdi));
ftdi_free(ftdi);
return -2;
}
p = list;
while (p) {
if (bus == libusb_get_bus_number(p->dev) &&
port == libusb_get_port_number(p->dev)) {
ret = ftdi_usb_open_dev(ftdi, p->dev);
break;
}
p = p->next;
}
ftdi_list_free(&list);
if (!p) {
fprintf(stderr, "dev on bus %i and port %i not found\n",
bus, port);
ftdi_free(ftdi);
return -3;
}
} else
ret = ftdi_usb_open(ftdi, 0x0403, 0x6001);
if (ret < 0 && ret != -5) {
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret,
ftdi_get_error_string(ftdi));
ftdi_free(ftdi);
return -4;
}
ret = ftdi_set_bitmode(ftdi, PINS_OUT, BITMODE_SYNCBB);
if (ret != 0) {
fprintf(stderr, "unable to set bitmode: %d (%s)\n", ret,
ftdi_get_error_string(ftdi));
ftdi_free(ftdi);
return -5;
}
ret = ftdi_set_baudrate(ftdi, 57600);
if (ret != 0) {
fprintf(stderr, "unable to set baudrate: %d (%s)\n", ret,
ftdi_get_error_string(ftdi));
ftdi_disable_bitbang(ftdi);
ftdi_free(ftdi);
return -6;
}
digitalWrite(PIN_PROG, LOW);
digitalWrite(PIN_FSCK, LOW);
digitalWrite(PIN_FCSN, HIGH);
digitalWrite(PIN_FMOSI, LOW);
digitalWrite(PIN_RESET, HIGH);
prog_begin();
return 0;
}
void spi_done(void) {
ftdi_disable_bitbang(ftdi);
ftdi_free(ftdi);
}
int main(int argc, char **argv)
{
struct ftdi_context ftdic, ftdic2;
char buf[1];
int f,i;
// Init 1. channel
if (ftdi_init(&ftdic) < 0)
{
fprintf(stderr, "ftdi_init failed\n");
return EXIT_FAILURE;
}
ftdi_set_interface(&ftdic, INTERFACE_A);
f = ftdi_usb_open(&ftdic, 0x0403, 0x6001);
if (f < 0 && f != -5)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(&ftdic));
exit(-1);
}
printf("ftdi open succeeded(channel 1): %d\n",f);
printf("enabling bitbang mode(channel 1)\n");
ftdi_set_bitmode(&ftdic, 0xFF, BITMODE_BITBANG);
// Init 2. channel
if (ftdi_init(&ftdic2) < 0)
{
fprintf(stderr, "ftdi_init failed\n");
return EXIT_FAILURE;
}
ftdi_set_interface(&ftdic2, INTERFACE_B);
f = ftdi_usb_open(&ftdic2, 0x0403, 0x6001);
if (f < 0 && f != -5)
{
fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(&ftdic2));
exit(-1);
}
printf("ftdi open succeeded(channel 2): %d\n",f);
printf("enabling bitbang mode (channel 2)\n");
ftdi_set_bitmode(&ftdic2, 0xFF, BITMODE_BITBANG);
// Write data
printf("startloop\n");
for (i = 0; i < 23; i++)
{
buf[0] = 0x1;
printf("porta: %02i: 0x%02x \n",i,buf[0]);
f = ftdi_write_data(&ftdic, buf, 1);
if (f < 0)
fprintf(stderr,"write failed on channel 1 for 0x%x, error %d (%s)\n", buf[0], f, ftdi_get_error_string(&ftdic));
sleep(1);
buf[0] = 0x2;
printf("porta: %02i: 0x%02x \n",i,buf[0]);
f = ftdi_write_data(&ftdic, buf, 1);
if (f < 0)
fprintf(stderr,"write failed on channel 1 for 0x%x, error %d (%s)\n", buf[0], f, ftdi_get_error_string(&ftdic));
sleep(1);
buf[0] = 0x1;
printf("portb: %02i: 0x%02x \n",i,buf[0]);
f = ftdi_write_data(&ftdic2, buf, 1);
if (f < 0)
fprintf(stderr,"write failed on channel 2 for 0x%x, error %d (%s)\n", buf[0], f, ftdi_get_error_string(&ftdic2));
sleep(1);
buf[0] = 0x2;
printf("portb: %02i: 0x%02x \n",i,buf[0]);
f = ftdi_write_data(&ftdic2, buf, 1);
if (f < 0)
fprintf(stderr,"write failed on channel 2 for 0x%x, error %d (%s)\n", buf[0], f, ftdi_get_error_string(&ftdic2));
sleep(1);
}
printf("\n");
printf("disabling bitbang mode(channel 1)\n");
ftdi_disable_bitbang(&ftdic);
ftdi_usb_close(&ftdic);
ftdi_deinit(&ftdic);
printf("disabling bitbang mode(channel 2)\n");
ftdi_disable_bitbang(&ftdic2);
ftdi_usb_close(&ftdic2);
ftdi_deinit(&ftdic2);
}
