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; }
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; }
static void ft245r_close(PROGRAMMER * pgm) { if (handle) { // I think the switch to BB mode and back flushes the buffer. ftdi_set_bitmode(handle, 0, BITMODE_SYNCBB); // set Synchronous BitBang, all in puts ftdi_set_bitmode(handle, 0, BITMODE_RESET); // disable Synchronous BitBang ftdi_usb_close(handle); ftdi_deinit (handle); pthread_cancel(readerthread); pthread_join(readerthread, NULL); free(handle); handle = NULL; } }
int main(int argc, char *argv[]) { struct ftdi_context ftdic; int portrelay = MOTOR_RELAY; unsigned char relay = 0; /* 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"); fprintf(stderr, "unable to open ftdi device: (%s)\n", ftdi_get_error_string(&ftdic)); return EXIT_FAILURE; } ftdi_set_bitmode(&ftdic, 0xFF, BITMODE_BITBANG); /* Reading existing state */ relay = 0; ftdi_read_data(&ftdic, &relay, 1); // printf("Activating relay %d\n", MOTOR_RELAY); relay |= (1 << portrelay); ftdi_write_data(&ftdic, &relay, 1); // printf("Sleeping for %dms\n", SLEEP_TIME); usleep(SLEEP_TIME * 1000); // usleep want microsecs // printf("Dectivating relay %d\n", MOTOR_RELAY); relay &= ~(1 << portrelay); ftdi_write_data(&ftdic, &relay, 1); return 0; }
static int ft245r_drain(PROGRAMMER * pgm, int display) { int r; unsigned char t; // flush the buffer in the chip by changing the mode..... r = ftdi_set_bitmode(handle, 0, BITMODE_RESET); // reset if (r) return -1; r = ftdi_set_bitmode(handle, ft245r_ddr, BITMODE_SYNCBB); // set Synchronuse BitBang if (r) return -1; // drain our buffer. while (head != tail) { ft245r_recv (pgm, &t, 1); } return 0; }
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)); } }
int main() { unsigned char d = 0; unsigned char i; 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"); fprintf(stderr, "unable to open ftdi device: (%s)\n", ftdi_get_error_string(&ftdic)); return EXIT_FAILURE; } ftdi_set_bitmode(&ftdic, 0xFF, BITMODE_BITBANG); ftdi_write_data(&ftdic, &d, 1); sleep(1); for(i=0;i<8;i++) { printf("%d\n",d); d |= d<<1; ftdi_write_data(&ftdic, &d, 1); usleep(200 * 1000); } sleep(2); d = 0; ftdi_write_data(&ftdic, &d, 1); return 0; }
int sys_init() { int ret, i; struct ftdi_device_list *devlist, *curdev; char manufacturer[128], description[128], serialno[128]; if (ftdi_init(&ux400_ftdic) < 0) { fprintf(stderr, "ftdi_init failed\n"); return EXIT_FAILURE; } if((ret = ftdi_usb_open_desc(&ux400_ftdic, UX400VENDOR, UX400PRODUCT, UX400DES, UX400_LOCAL_SN)) < 0) { fprintf(stderr, "ftdi_usb_open_desc failed: %d (%s)\n", ret, ftdi_get_error_string(&ux400_ftdic)); return EXIT_FAILURE; } if((ret = ftdi_usb_reset(&ux400_ftdic)) < 0) { fprintf(stderr, "ftdi_usb_reset failed: %d (%s)\n", ret, ftdi_get_error_string(&ux400_ftdic)); return EXIT_FAILURE; } if((ret = ftdi_set_baudrate(&ux400_ftdic, 9600)) < 0) { fprintf(stderr, "ftdi_set_baudrate failed: %d (%s)\n", ret, ftdi_get_error_string(&ux400_ftdic)); return EXIT_FAILURE; } if((ret = ftdi_set_bitmode(&ux400_ftdic, 0x00, BITMODE_RESET)) < 0) { fprintf(stderr, "ftdi_set_bitmode failed: %d (%s)\n", ret, ftdi_get_error_string(&ux400_ftdic)); return EXIT_FAILURE; } usleep(10000); if((ret = ftdi_set_bitmode(&ux400_ftdic, 0x00, BITMODE_MCU)) < 0) { fprintf(stderr, "ftdi_set_bitmode failed: %d (%s)\n", ret, ftdi_get_error_string(&ux400_ftdic)); return EXIT_FAILURE; } return 0; }
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; }
void swdptap_turnaround(uint8_t dir) { static uint8_t olddir = 0; //DEBUG("%s", dir ? "\n-> ":"\n<- "); platform_buffer_flush(); if(dir == olddir) return; olddir = dir; if(dir) /* SWDIO goes to input */ assert(ftdi_set_bitmode(ftdic, 0xA3, BITMODE_BITBANG) == 0); /* One clock cycle */ ftdi_write_data(ftdic, "\xAB\xA8", 2); if(!dir) /* SWDIO goes to output */ assert(ftdi_set_bitmode(ftdic, 0xAB, BITMODE_BITBANG) == 0); }
static void swdptap_init_internal(void) { int err; if((err = ftdi_set_bitmode(ftdic, 0, BITMODE_RESET)) || (err = ftdi_set_bitmode(ftdic, 0, BITMODE_MPSSE))) { fprintf(stderr, "ftdi_set_bitmode: %d: %s\n", err, ftdi_get_error_string(ftdic)); abort(); } uint8_t setup[] = { DIS_DIV_5, TCK_DIVISOR, 0, 1, LOOPBACK_END }; platform_buffer_write(setup, sizeof(setup)); swdptap_set_bits(); platform_buffer_flush(); }
void initBoard(char *serial) { //Init FTDI communication ftdi_init(&ftdic); if (0) { //Open ret = ftdi_usb_open(&ftdic, 0x0403, 0x6001); } else { //Open via serial number, to be implemented later. ret = ftdi_usb_open_desc(&ftdic, 0x0403, 0x6001, NULL, serial); } ret = ftdi_read_pins(&ftdic, bits); //Board has just been plugged in or power lost if (bits[0] == 0xFF) { //Prevents 0xFF from flipping all switches on //ftdi_enable_bitbang(&ftdic, 0xF0); ftdi_set_bitmode(&ftdic, 0xF0, BITMODE_BITBANG); setPins(0); } ftdi_set_bitmode(&ftdic, 0xFF, BITMODE_BITBANG); //ftdi_enable_bitbang(&ftdic, 0xFF); }
int jtagtap_init(void) { int err; assert(ftdic != NULL); if((err = ftdi_set_bitmode(ftdic, 0, BITMODE_RESET)) || (err = ftdi_set_bitmode(ftdic, 0, BITMODE_MPSSE))) { fprintf(stderr, "ftdi_set_bitmode: %d: %s\n", err, ftdi_get_error_string(ftdic)); abort(); } assert(ftdi_write_data(ftdic, "\x8B\x86\x06\x00\x80\xA8\xAB\x85", 8) == 8); /* Go to JTAG mode for SWJ-DP */ for(int i = 0; i <= 50; i++) jtagtap_next(1, 0); /* Reset SW-DP */ jtagtap_tms_seq(0xE73C, 16); /* SWD to JTAG sequence */ jtagtap_soft_reset(); return 0; }
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); }
void init_hw () { ftdi_ok = FALSE; if (ftdi_init (&ctx) >= 0) { int f = ftdi_usb_open (&ctx, 0x0403, 0x6001); if (f >= 0 || f == -5) { purple_debug_info ("hwnotify", "INIT OK\n"); ftdi_set_bitmode (&ctx, 0xFF, BITMODE_BITBANG); ftdi_ok = TRUE; } } }
int main(int argc, char **argv) { struct ftdi_context *ftdi; int f; unsigned char buf[1]; int retval = 0; if ((ftdi = ftdi_new()) == 0) { fprintf(stderr, "ftdi_new failed\n"); return EXIT_FAILURE; } // fprintf(stderr, "ftdi_new result = %d\n", ftdi); f = ftdi_usb_open(ftdi, 0x0403, 0x6001); // fprintf(stderr, "ftdi_usb_open result = %d\n", f); if (f < 0 && f != -5) { fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi)); retval = 1; goto done; } // printf("ftdi open succeeded: %d\n",f); // printf("enabling bitbang mode\n"); ftdi_set_bitmode(ftdi, 0x02, BITMODE_BITBANG); // usleep(3 * 1000000); buf[0] = 0xff; // printf("turning everything on\n"); f = ftdi_write_data(ftdi, buf, 1); if (f < 0) { fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, ftdi_get_error_string(ftdi)); } // ftdi_disable_bitbang(ftdi); ftdi_usb_close(ftdi); ftdi_free(ftdi); done: return retval; }
int main ( int argc, char *argv[] ) { unsigned char c = 0; char check = '2'; const char serial[] = "A602HSI6"; const char *descriptor = NULL; 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_desc(&ftdic, 0x0403, 0x6001, descriptor, serial) < 0) { //puts("Can't open device cooler USB"); return 1; } if ( argc == 1 ) { //printf( "cooler USB device found, all OK\n"); return 0; } if ( argc != 2 ) /* argc should be 2 for correct execution */ { /* We print argv[0] assuming it is the program name */ printf( "usage: %s [0|1]\n", argv[0] ); return 1; } else { check = argv[1][0]; /*printf("Argument: %s C:%c\n",argv[1],check);*/ if (check == '1') { c ^= LED; /*printf("On\n");*/ } /* Enable bitbang mode with a single output line */ ftdi_set_bitmode(&ftdic, LED, BITMODE_BITBANG); ftdi_write_data(&ftdic, &c, 1); return 0; } }
//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; }
int main(int argc, char **argv) { struct ftdi_context *ftdi; int i, t; unsigned char data; int delay = 100000; /* 100 thousand microseconds: 1 tenth of a second */ while ((t = getopt (argc, argv, "d:")) != -1) { switch (t) { case 'd': delay = atoi (optarg); break; } } if ((ftdi = ftdi_new()) == 0) { fprintf(stderr, "ftdi_bew failed\n"); return EXIT_FAILURE; } if (ftdi_usb_open(ftdi, 0x0403, 0x6010) < 0) ftdi_fatal (ftdi, "Can't open ftdi device"); if (ftdi_set_bitmode(ftdi, 0xFF, BITMODE_BITBANG) < 0) ftdi_fatal (ftdi, "Can't enable bitbang"); for (i=optind; i < argc ; i++) { sscanf (argv[i], "%x", &t); data = t; if (ftdi_write_data(ftdi, &data, 1) < 0) { fprintf(stderr,"write failed for 0x%x: %s\n", data, ftdi_get_error_string(ftdi)); } usleep(delay); } ftdi_usb_close(ftdi); ftdi_free(ftdi); exit (0); }
void relay_setup (void) { int f; if ((ftdi = ftdi_new()) == 0) { printf("ftdi_new failed\nFatal error, exiting\n"); exit (1); } f = ftdi_usb_open(ftdi, 0x0403, 0x6001); if (f < 0 && f != -5) { printf("Unable to open ftdi device %s\nFatal error, exiting\n", ftdi_get_error_string(ftdi)); ftdi_free(ftdi); exit (1); } ftdi_set_bitmode(ftdi, 0xFF, BITMODE_BITBANG); return; }
int init() { int f; if ((ftdi = ftdi_new()) == 0) { fprintf(stderr, "ftdi_new failed\n"); return -1; } f = ftdi_usb_open(ftdi, 0x0403, 0x6010); if (f < 0 && f != -5) { fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi)); ftdi_free(ftdi); ftdi = NULL; return -1; } f = ftdi_set_bitmode(ftdi, 0xff, BITMODE_MPSSE); if(f != 0) { fprintf(stderr, "unable to set bit mode: %d (%s)\n", f, ftdi_get_error_string(ftdi)); release(); return -1; } uint8_t p[] = { 0x80, 0, 3 }; f = ftdi_write_data(ftdi, p, 3); if(f != 3) { fprintf(stderr, "unable to write command to ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi)); release(); return -1; } //Set TCK/SK Divisor 0x86, 0xValueL, 0xValueH uint8_t p1[] = { 0x86, 0, 1 }; //250KHz // uint8_t p1[] = { 0x86, 0, 10 }; //25KHz f = ftdi_write_data(ftdi, p1, 3); if(f != 3) { fprintf(stderr, "unable to write command2 to ftdi device: %d (%s)\n", f, ftdi_get_error_string(ftdi)); release(); return -1; } return 0; }
int main(void) { int ret; struct ftdi_context ftdic; if (ftdi_init(&ftdic) < 0) { fprintf(stderr, "ftdi_init failed\n"); return EXIT_FAILURE; } if ((ret = ftdi_usb_open(&ftdic, 0x15ba, 0x002a)) < 0) { fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic)); return EXIT_FAILURE; } // Read out FTDIChip-ID of R type chips if (ftdic.type == TYPE_R) { unsigned int chipid; printf("ftdi_read_chipid: %d\n", ftdi_read_chipid(&ftdic, &chipid)); printf("FTDI chipid: %X\n", chipid); } ftdi_set_bitmode(&ftdic, 0x0b, BITMODE_MPSSE); /* ctx, JTAG I/O mask */ write_ftdi_command(&ftdic, SET_BITS_LOW, 0x00, 0x0b); write_ftdi_command(&ftdic, SET_BITS_HIGH, OLIMEX_CBUS_nSRST, OLIMEX_CBUS_nSRST|OLIMEX_CBUS_LED); usleep(100); write_ftdi_command(&ftdic, SET_BITS_HIGH, OLIMEX_CBUS_LED, OLIMEX_CBUS_nSRST|OLIMEX_CBUS_LED); usleep(1500000); write_ftdi_command(&ftdic, SET_BITS_LOW, 0x00, 0x00); if ((ret = ftdi_usb_close(&ftdic)) < 0) { fprintf(stderr, "unable to close ftdi device: %d (%s)\n", ret, ftdi_get_error_string(&ftdic)); return EXIT_FAILURE; } ftdi_deinit(&ftdic); return EXIT_SUCCESS; }
int spi_close(void) { LOG(DEBUG, "spi_nrefs=%d, spi_dev_open=%d", spi_nrefs, spi_dev_open); if (spi_dev_open) { #ifdef ENABLE_LEDS spi_led(SPI_LED_OFF); #endif /* Flush and reset the buffer */ if (ftdi_buf_write_offset) { if (spi_ftdi_xfer(ftdi_buf, ftdi_buf_write_offset) < 0) return -1; ftdi_buf_write_offset = 0; } if (ftdi_set_bitmode(&ftdic, 0, BITMODE_RESET) < 0) { SPI_ERR("FTDI: reset bitmode failed: %s", ftdi_get_error_string(&ftdic)); return -1; } if (ftdi_usb_close(&ftdic) < 0) { SPI_ERR("FTDI: close failed: %s", ftdi_get_error_string(&ftdic)); return -1; } #ifdef SPI_STATS spi_output_stats(); #endif free(ftdi_buf); ftdi_buf = NULL; ftdi_buf_size = 0; spi_dev_open = 0; } return 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); }
/* 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; }
int main(int argc, char *argv[]) { struct ftdi_context ftdic; unsigned char state; /* 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"); fprintf(stderr, "unable to open ftdi device: (%s)\n", ftdi_get_error_string(&ftdic)); return EXIT_FAILURE; } ftdi_set_bitmode(&ftdic, 0xFF, BITMODE_BITBANG); /* Reading existing state */ state = 0; ftdi_read_data(&ftdic, &state, 1); printf("Bitbang state, byte one: 0x%0x\n", state); return state; }
int swdptap_init(void) { int err; assert(ftdic != NULL); if((err = ftdi_set_bitmode(ftdic, 0xAB, BITMODE_BITBANG)) != 0) { fprintf(stderr, "ftdi_set_bitmode: %d: %s\n", err, ftdi_get_error_string(ftdic)); abort(); } assert(ftdi_write_data(ftdic, "\xAB\xA8", 2) == 2); /* This must be investigated in more detail. * As described in STM32 Reference Manual... */ swdptap_seq_out(0xFFFF, 16); swdptap_reset(); swdptap_seq_out(0xE79E, 16); /* 0b0111100111100111 */ swdptap_reset(); swdptap_seq_out(0, 16); return 0; }
int main() { struct ftdi_context ftdic; ftdi_init(&ftdic); uint8_t data[256]; uint8_t data2[256]; if(ftdi_usb_open_desc(&ftdic, 0x0403, 0x6001, NULL, NULL) < 0) { fprintf(stderr, "ftdi_usb_open_desc failed: %s\n", ftdi_get_error_string(&ftdic)); exit(1); } if(ftdi_set_bitmode(&ftdic, 0xff, BITMODE_SYNCBB) < 0) { fprintf(stderr, "ftdi_set_bitmode failed: %s\n", ftdi_get_error_string(&ftdic)); exit(1); } if(ftdi_set_baudrate(&ftdic, 4096) < 0) { fprintf(stderr, "ftdi_set_baudrate failed: %s\n", ftdi_get_error_string(&ftdic)); exit(1); } for(int i=0; i<sizeof(data); i++) { data[i] = (uint8_t ) i & 0xff; } for(;;) { ftdi_write_data(&ftdic, data, sizeof(data)); ftdi_read_data(&ftdic, data2, sizeof(data2)); } return 0; }
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; }
int main(int argc, char **argv) { struct ftdi_context ftdi; uint8_t buf[4]; uint8_t conf_buf[] = {SET_BITS_LOW, 0x08, 0x0b, SET_BITS_HIGH, 0x00, 0x00, TCK_DIVISOR, 0x00, 0x00, LOOPBACK_END}; if (argc < 2) { usage(argv[0]); return 1; } if (strcmp (argv[1], "idcode") && strcmp (argv[1], "reset") && strcmp (argv[1], "load") && strcmp (argv[1], "readreg") && strcmp (argv[1], "read") && strcmp (argv[1], "write") ) { usage(argv[0]); return 1; } /* Init */ ftdi_init(&ftdi); if (ftdi_usb_open_desc(&ftdi, VENDOR, PRODUCT, 0, 0) < 0) { fprintf(stderr, "Can't open device %04x:%04x\n", VENDOR, PRODUCT); return 1; } ftdi_usb_reset(&ftdi); ftdi_set_interface(&ftdi, INTERFACE_A); ftdi_set_latency_timer(&ftdi, 1); ftdi_set_bitmode(&ftdi, 0xfb, BITMODE_MPSSE); if (ftdi_write_data(&ftdi, conf_buf, 10) != 10) { fprintf(stderr, "Can't configure device %04x:%04x\n", VENDOR, PRODUCT); return 1; } buf[0] = GET_BITS_LOW; buf[1] = SEND_IMMEDIATE; if (ftdi_write_data(&ftdi, buf, 2) != 2) { fprintf(stderr, "Can't send command to device\n"); return 1; } ftdi_read_data(&ftdi, &buf[2], 1); if (!(buf[2] & 0x10)) { fprintf(stderr, "Vref not detected. Please power on target board\n"); return 1; } if (!strcmp(argv[1], "idcode")) { uint8_t out[4]; tap_reset_rti(&ftdi); tap_shift_dr_bits(&ftdi, NULL, 32, out); rev_dump(out, 4); printf("\n"); } if (!strcmp (argv[1], "reset")) brd_reset(&ftdi); if (!strcmp (argv[1], "load")) { int i; struct load_bits *bs; FILE *fp; uint8_t *dr_data; uint32_t u; if(argc < 3) { usage(argv[0]); goto exit; } if (!strcmp(argv[2], "-")) fp = stdin; else { fp = fopen(argv[2], "r"); if (!fp) { perror("Unable to open file"); goto exit; } } bs = calloc(1, sizeof(*bs)); if (!bs) { perror("memory allocation failed"); goto exit; } if (load_bits(fp, bs) != 0) { fprintf(stderr, "%s not supported\n", argv[2]); goto free_bs; } printf("Bitstream information:\n"); printf("\tDesign: %s\n", bs->design); printf("\tPart name: %s\n", bs->part_name); printf("\tDate: %s\n", bs->date); printf("\tTime: %s\n", bs->time); printf("\tBitstream length: %d\n", bs->length); /* copy data into shift register */ dr_data = calloc(1, bs->length); if (!dr_data) { perror("memory allocation failed"); goto free_bs; } for (u = 0; u < bs->length; u++) dr_data[u] = rev8(bs->data[u]); brd_reset(&ftdi); tap_shift_ir(&ftdi, CFG_IN); tap_shift_dr_bits(&ftdi, dr_data, bs->length * 8, NULL); /* ug380.pdf * P161: a minimum of 16 clock cycles to the TCK */ tap_shift_ir(&ftdi, JSTART); for (i = 0; i < 32; i++) tap_tms(&ftdi, 0, 0); tap_reset_rti(&ftdi); free(dr_data); free_bs: bits_free(bs); fclose(fp); } if (!strcmp(argv[1], "readreg") && argc == 3) { int i; char *err; uint8_t reg; uint8_t out[2]; uint8_t dr_in[14]; uint8_t in[14] = { 0xaa, 0x99, 0x55, 0x66, 0x00, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00, 0x20, 0x00 }; uint16_t cmd = 0x2801; /* type 1 packet (word count = 1) */ reg = strtol(argv[2], &err, 0); if((*err != 0x00) || (reg < 0) || (reg > 0x22)) { fprintf(stderr, "Invalid register, use a decimal or hexadecimal(0x...) number between 0x0 and 0x22\n"); goto exit; } cmd |= ((reg & 0x3f) << 5); in[4] = (cmd & 0xff00) >> 8; in[5] = cmd & 0xff; tap_reset_rti(&ftdi); tap_tms(&ftdi, 1, 0); tap_tms(&ftdi, 1, 0); tap_tms(&ftdi, 0, 0); tap_tms(&ftdi, 0, 0); /* Goto shift IR */ tap_shift_ir_only(&ftdi, CFG_IN); tap_tms(&ftdi, 1, 0); tap_tms(&ftdi, 1, 0); tap_tms(&ftdi, 0, 0); tap_tms(&ftdi, 0, 0); /* Goto SHIFT-DR */ for (i = 0; i < 14; i++) dr_in[i] = rev8(in[i]); tap_shift_dr_bits_only(&ftdi, dr_in, 14 * 8, NULL); tap_tms(&ftdi, 1, 0); tap_tms(&ftdi, 1, 0); tap_tms(&ftdi, 1, 0); /* Goto SELECT-IR */ tap_tms(&ftdi, 0, 0); tap_tms(&ftdi, 0, 0); /* Goto SHIFT-IR */ tap_shift_ir_only(&ftdi, CFG_OUT); tap_tms(&ftdi, 1, 0); tap_tms(&ftdi, 1, 0); tap_tms(&ftdi, 0, 0); tap_tms(&ftdi, 0, 0); /* Goto SHIFT-IR */ tap_shift_dr_bits_only(&ftdi, NULL, 2 * 8, out); tap_tms(&ftdi, 1, 0); tap_tms(&ftdi, 1, 0); tap_tms(&ftdi, 1, 0); /* Goto SELECT-IR */ tap_tms(&ftdi, 0, 0); tap_tms(&ftdi, 0, 0); /* Goto SHIFT-IR */ tap_reset_rti(&ftdi); out[0] = rev8(out[0]); out[1] = rev8(out[1]); printf("REG[%d]: 0x%02x%02x\n", reg, out[0], out[1]); }