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