openFPGALoader

#include <stdio.h>
#include <stdlib.h>
#include <ftdi.h>
#include <unistd.h>
#include <string.h>
#include "ftdipp_mpsse.hpp"
#include "ftdispi.hpp"
//#include "ftdi_handle.h"

/*
 * SCLK -> ADBUS0
 * MOSI -> ADBUS1
 * MISO -> ADBUS2
 * CS	-> ADBUS3
 */
#define SPI_CLK (1 << 0)
#define cs_bits 0x08
#define pindir 0x0b


//uint8_t buffer[1024];
//int num = 0;

/* GGM: Faut aussi definir l'etat des broches par defaut */
/* necessaire en mode0 et 1, ainsi qu'entre 2 et 3
 */
/* Rappel :
 * Mode0 : clk idle low, ecriture avant le premier front
 * 			ie lecture sur le premier front (montant)
 * Mode1 : clk idle low, ecriture sur le premier front (montant)
 * 			lecture sur le second front (descendant)
 * Mode2 : clk idle high, ecriture avant le premier front
 * 			lecture sur le premier front (descendant)
 * Mode3 : clk idle high, ecriture sur le premier front (descendant)
 * 			lecture sur le second front (montant)
 */
void FtdiSpi::setMode(uint8_t mode)
{
	switch (mode) {
	case 0:
		_clk = 0;
		_wr_mode = MPSSE_WRITE_NEG;
		_rd_mode = 0;
		break;
	case 1:
		_clk = 0;
		_wr_mode = 0;
		_rd_mode = MPSSE_READ_NEG;
		break;
	case 2:
		_clk = SPI_CLK;
		_wr_mode = 0; //POS
		_rd_mode = MPSSE_READ_NEG;
		break;
	case 3:
		_clk = SPI_CLK;
		_wr_mode = MPSSE_WRITE_NEG;
		_rd_mode = 0;
		break;
	}
}

static FTDIpp_MPSSE::mpsse_bit_config bit_conf =
	{0x403, 0x6010, INTERFACE_B, 0x08, 0x0B, 0x08, 0x0B};

FtdiSpi::FtdiSpi(int vid, int pid, unsigned char interface, uint32_t clkHZ,
	bool verbose):
	FTDIpp_MPSSE(bit_conf, "", "", clkHZ, verbose)
{
	setMode(0);
	setCSmode(SPI_CS_AUTO);
	setEndianness(SPI_MSB_FIRST);

	init(1, 0x00, BITMODE_MPSSE, bit_conf);
}

FtdiSpi::FtdiSpi(const FTDIpp_MPSSE::mpsse_bit_config &conf, uint32_t clkHZ,
	bool verbose):
	FTDIpp_MPSSE(conf, "", "", clkHZ, verbose)
{
	setMode(0);
	setCSmode(SPI_CS_AUTO);
	setEndianness(SPI_MSB_FIRST);

	init(1, 0x00, BITMODE_MPSSE, bit_conf);
}

FtdiSpi::~FtdiSpi()
{
}

#if 0
#define CLOCK 0x08
#define LATENCY 16
#define TIMEOUT 0
#define SIZE 65536
#define TX_BUFS (60000/8-3)

int ftdi_spi_init_internal(struct ftdi_spi *spi, uint32_t clk_freq_hz);

int ftdi_spi_init_by_name(struct ftdi_spi *spi, char *devname,
			  uint8_t interface, uint32_t clk_freq_hz)
{
	spi->ftdic = open_device_by_name(devname, interface, 115200);
	if (spi->ftdic == NULL) {
		printf("opening error\n");
		return EXIT_FAILURE;
	}
	return ftdi_spi_init_internal(spi, clk_freq_hz);
}

int ftdi_spi_init(struct ftdi_spi *spi, uint32_t vid, uint32_t pid,
		  uint8_t interface, uint32_t clk_freq_hz)
{
	spi->ftdic = open_device(vid, pid, interface, 115200);
	if (spi->ftdic == NULL) {
		printf("opening error\n");
		return EXIT_FAILURE;
	}
	return ftdi_spi_init_internal(spi, clk_freq_hz);
}
#endif
#if 0
int ftdi_spi_init_internal(struct ftdi_spi *spi, uint32_t clock_freq_hz)
{
	setCSmode(spi, SPI_CS_AUTO);
	setEndianness(spi, SPI_MSB_FIRST);
	spi->tx_buff = (uint8_t *)malloc(sizeof(uint8_t) * TX_BUFS);

	if (ftdi_usb_reset(spi->ftdic) != 0) {
		printf("reset error\n");
		return -1;
	}
	if (ftdi_usb_purge_rx_buffer(spi->ftdic) != 0) {
		printf("reset error\n");
		return -1;
	}
	if (ftdi_usb_purge_tx_buffer(spi->ftdic) != 0) {
		printf("reset error\n");
		return -1;
	}
	if (ftdi_read_data_set_chunksize(spi->ftdic, SIZE) != 0) {
		printf("reset error\n");
		return -1;
	}
	if (ftdi_write_data_set_chunksize(spi->ftdic, SIZE) != 0) {
		printf("reset error\n");
		return -1;
	}
	if (ftdi_set_latency_timer(spi->ftdic, LATENCY) != 0) {
		printf("reset error\n");
		return -1;
	}
	if (ftdi_set_event_char(spi->ftdic, 0x00, 0) != 0) {
		printf("reset error\n");
		return -1;
	}
	if (ftdi_set_error_char(spi->ftdic, 0x00, 0) != 0) {
		printf("reset error\n");
		return -1;
	}
	// set the read timeouts in ms for the ft2232H
	spi->ftdic->usb_read_timeout = TIMEOUT;
	// set the write timeouts in ms for the ft2232H
	spi->ftdic->usb_write_timeout = 5000;
	if (ftdi_set_bitmode(spi->ftdic, 0x00, 0x00) != 0) {	// reset controller
		printf("reset error\n");
		return -1;
	}

	if (ftdi_set_bitmode(spi->ftdic, 0x00, 0x02) != 0) {	// enable mpsse mode
		printf("reset error\n");
		return -1;
	}

	if (ftdi_setClock(spi->ftdic, /*0x08,*/ clock_freq_hz) < 0)
		return -1;
	spi->tx_size = 0;

	spi->tx_buff[spi->tx_size++] = 0x97;	// disable adaptive clocking
	// devrait etre 8C pour enable et non 8D
	spi->tx_buff[spi->tx_size++] = 0x8d;	//disable tri phase data clocking
	if (ftdi_write_data(spi->ftdic, spi->tx_buff, spi->tx_size) != spi->tx_size) {
		printf("write error for dis clock, adaptive, tri phase\n");
		return -1;
	}
	spi->tx_size = 0;
	spi->tx_buff[spi->tx_size++] = 0x85;	// disable loopback
	if (ftdi_write_data(spi->ftdic, spi->tx_buff, spi->tx_size) != spi->tx_size) {
		printf("disable loopback error\n");
		return -1;
	}

	spi->tx_size = 0;
	spi->tx_buff[spi->tx_size++] = 0x80;
	spi->tx_buff[spi->tx_size++] = 0x08;
	spi->tx_buff[spi->tx_size++] = 0x0B;
	if (ftdi_write_data(spi->ftdic, spi->tx_buff, spi->tx_size) != spi->tx_size) {
		printf("write set bit error\n");
		return -1;
	}
	spi->tx_size = 0;
	return 0;
}
#endif

//FtdiSpi::~FtdiSpi()
//int ftdi_spi_close(struct ftdi_spi *spi)
//{
	//struct ftdi_context *ftdic = spi->ftdic;
	//free(spi->tx_buff);
	//return close_device(ftdic);
//}

// mpsse_write
/*static int send_buf(struct ftdi_context *ftdic, const unsigned char *buf,
		    int size)
{
	int r;
	r = ftdi_write_data(ftdic, (unsigned char *)buf, size);
	if (r < 0) {
		printf("ftdi_write_data: %d, %s\n", r,
			 ftdi_get_error_string(ftdic));
		return 1;
	}
	return 0;
}

static int ft_flush_buffer(struct ftdi_spi *spi)
{
	int ret = 0;
	if (spi->tx_size != 0) {
		ret = send_buf(spi->ftdic, spi->tx_buff, spi->tx_size);
		spi->tx_size = 0;
	}
	return ret;
}*/

// mpsse_store
/*static int ft_store_char(struct ftdi_spi *spi, uint8_t c)
{
	int ret = 0;
	if (spi->tx_size == TX_BUFS)
		ret = ft_flush_buffer(spi);
	spi->tx_buff[spi->tx_size] = c;
	spi->tx_size++;
	return ret;
}

static int ft_store_star_char(struct ftdi_spi *spi, uint8_t *buff, int len)
{
	int ret = 0;
	if (spi->tx_size + len + 1 == TX_BUFS)
		ret = ft_flush_buffer(spi);
	memcpy(spi->tx_buff + spi->tx_size, buff, len);
	spi->tx_size += len;
	return ret;
}*/

// mpsse read
/*static int get_buf(struct ftdi_spi *spi, const unsigned char *buf,
		   int size)
{
	int r;
	ft_store_char(spi, SEND_IMMEDIATE);
	ft_flush_buffer(spi);

	while (size > 0) {
		r = ftdi_read_data(spi->ftdic, (unsigned char *)buf, size);
		if (r < 0) {
			printf("ftdi_read_data: %d, %s\n", r,
				 ftdi_get_error_string(spi->ftdic));
			return 1;
		}
		buf += r;
		size -= r;
	}
	return 0;
}*/

/* send two consecutive cs configuration */
void FtdiSpi::confCs(char stat)
{
	uint8_t tx_buf[6] = {SET_BITS_LOW, _clk, pindir,
						 SET_BITS_LOW, _clk, pindir};

	tx_buf[1] |= (stat) ? cs_bits : 0;
	tx_buf[4] |= (stat) ? cs_bits : 0;

	if (mpsse_store(tx_buf, 6) != 0)
		printf("error\n");
}

void FtdiSpi::setCs()
{
	_cs = cs_bits;
	confCs(_cs);
}

void FtdiSpi::clearCs()
{
	_cs = 0x00;
	confCs(_cs);
}

int FtdiSpi::ft2232_spi_wr_then_rd(
						const uint8_t *tx_data, uint32_t tx_len,
						uint8_t *rx_data, uint32_t rx_len)
{
	setCSmode(SPI_CS_MANUAL);
	clearCs();
	uint32_t ret = ft2232_spi_wr_and_rd(tx_len, tx_data, NULL);
	if (ret != 0) {
		printf("%s : write error %d %d\n", __func__, ret, tx_len);
	} else {
		ret = ft2232_spi_wr_and_rd(rx_len, NULL, rx_data);
		if (ret != 0) {
			printf("%s : read error\n", __func__);
		}
	}
	setCs();
	setCSmode(SPI_CS_AUTO);
	return ret;
}

/* Returns 0 upon success, a negative number upon errors. */
int FtdiSpi::ft2232_spi_wr_and_rd(//struct ftdi_spi *spi,
			    uint32_t writecnt,
			    const uint8_t * writearr, uint8_t * readarr)
{
#define TX_BUF (60000/8-3)
	//struct ftdi_context *ftdic = spi->ftdic;
	uint8_t buf[TX_BUF+3];//65536+9];
	/* failed is special. We use bitwise ops, but it is essentially bool. */
	int i = 0, failed = 0;
	int ret = 0;

	uint8_t *rx_ptr = readarr;
	uint8_t *tx_ptr = (uint8_t *)writearr;
	uint32_t len = writecnt;
	uint32_t xfer;

	if (_cs_mode == SPI_CS_AUTO) {
		buf[i++] = SET_BITS_LOW;
		buf[i++] = (0 & ~cs_bits) | _clk;	/* assertive */
		buf[i++] = pindir;
		mpsse_store(buf, i);
		i=0;
	}
	mpsse_write();

	/*
	 * Minimize USB transfers by packing as many commands as possible
	 * together. If we're not expecting to read, we can assert CS#, write,
	 * and deassert CS# all in one shot. If reading, we do three separate
	 * operations.
	 */
	while (len > 0) {
		xfer = (len > TX_BUF) ? TX_BUF: len;

		buf[i++] = /*(spi->endian == SPI_MSB_FIRST) ? 0 : MPSSE_LSB |*/
					((readarr) ? (MPSSE_DO_READ | _rd_mode) : 0) |
					((writearr) ? (MPSSE_DO_WRITE | _wr_mode) : 0);// |
					/*MPSSE_DO_WRITE |*/// spi->wr_mode | spi->rd_mode;
		buf[i++] = (xfer - 1) & 0xff;
		buf[i++] = ((xfer - 1) >> 8) & 0xff;
		if (writearr) {
			memcpy(buf + i, tx_ptr, xfer);
			tx_ptr += xfer;
			i += xfer;
		}

		ret = mpsse_store(buf, i);
		failed = ret;
		if (ret)
			printf("send_buf failed before read: %i %s\n", ret, "plop");// ftdi_get_error_string(ftdic));
		i = 0;
		if (readarr) {
			//if (ret == 0) {
			ret = mpsse_read(rx_ptr, xfer);
			failed = ret;
			if (ret != xfer)
				printf("get_buf failed: %i\n", ret);
			//}
			rx_ptr += xfer;
		} else {
			ret = mpsse_write();
			failed = ret;
			if (ret != xfer+3)
				printf("error %d %d\n", ret, i);
		}
		len -= xfer;

	}

	if (_cs_mode == SPI_CS_AUTO) {
		buf[i++] = SET_BITS_LOW;
		buf[i++] = cs_bits | _clk;
		buf[i++] = pindir;
		ret = mpsse_store(buf, i);
		failed |= ret;
		if (ret)
			printf("send_buf failed at end: %i\n", ret);
		if (3 != mpsse_write())
			printf("send_buf failed at write\n");
	}

	return 0;//failed ? -1 : 0;
}

/* method spiInterface::spi_put */
int FtdiSpi::spi_put(uint8_t cmd, uint8_t *tx, uint8_t *rx, uint32_t len)
{
	uint32_t xfer_len = len + 1;
	uint8_t jtx[xfer_len];
	uint8_t jrx[xfer_len];

	jtx[0] = cmd;
	if (tx != NULL)
		memcpy(jtx+1, tx, len);

	/* send first alreay stored cmd,
	 * in the same time store each byte
	 * to next
	 */
	ft2232_spi_wr_and_rd(xfer_len, jtx, (rx != NULL)?jrx:NULL);

	if (rx != NULL)
		memcpy(rx, jrx+1, len);

	return 0;
}

/* method spiInterface::spi_put */
int FtdiSpi::spi_put(uint8_t *tx, uint8_t *rx, uint32_t len)
{
	return ft2232_spi_wr_and_rd(len, tx, rx);
}

/* method spiInterface::spi_wait
 */
int FtdiSpi::spi_wait(uint8_t cmd, uint8_t mask, uint8_t cond,
			uint32_t timeout, bool verbose)
{
	uint8_t rx;
	uint8_t dummy[2];
	uint32_t count = 0;

	setCSmode(SPI_CS_MANUAL);
	clearCs();
	ft2232_spi_wr_and_rd(1, &cmd, NULL);
	do {
		ft2232_spi_wr_and_rd(1, NULL, &rx);
		count ++;
		if (count == timeout) {
			printf("timeout: %2x %d\n", rx, count);
			break;
		}

		if (verbose) {
			printf("%02x %02x %02x %02x\n", rx, mask, cond, count);
		}
	} while((rx & mask) != cond);
	setCs();
	setCSmode(SPI_CS_AUTO);

	if (count == timeout) {
		printf("%x\n", rx);
		std::cout << "wait: Error" << std::endl;
		return -ETIME;
	} else
		return 0;
}