Subversion Repositories ftdi_wb_bridge

#include <stdio.h>

#include <ftdi.h>

#include "ftdi_hw.h"

//-----------------------------------------------------------------

// Defines:

//-----------------------------------------------------------------

#define CMD_NOP        0x0

#define CMD_WR         0x1

#define CMD_RD         0x2

#define CMD_GP_WR      0x3

#define CMD_GP_RD      0x4

#define MAX_TX_SIZE    2048

#define HDR_SIZE       6

#define FTDI_PID       0x0403

#define FTDI_VID       0x6010

//-----------------------------------------------------------------

// Locals:

//-----------------------------------------------------------------

static struct ftdi_context *_handle;

//-----------------------------------------------------------------

// ftdi_hw_init:

//-----------------------------------------------------------------

int ftdi_hw_init(int interface)

{

    int status;

    _handle = ftdi_new();

    if (!_handle)

        return -1;

    // Open channel

    ftdi_set_interface(_handle, interface ? INTERFACE_B : INTERFACE_A);

    status = ftdi_usb_open(_handle, FTDI_PID, FTDI_VID);

    if (status != 0)

    {

        ftdi_free(_handle);

        _handle = NULL;

        return -1;

    }

    // Reset FTDI

    status = ftdi_usb_reset(_handle);

    if (status != 0)

    {

        ftdi_usb_close(_handle);

        ftdi_free(_handle);

        _handle = NULL;

        return -1;

    }

    // Flush buffers

    status = ftdi_usb_purge_buffers(_handle);

    if (status != 0)

    {

        ftdi_usb_close(_handle);

        ftdi_free(_handle);

        _handle = NULL;

        return -1;

    }

    // Set transfer mode

    status = ftdi_set_bitmode(_handle, 0xFF, BITMODE_RESET);

    if (status != 0)

    {

        ftdi_usb_close(_handle);

        ftdi_free(_handle);

        _handle = NULL;

        return -1;

    }

    return 0;

}

//-----------------------------------------------------------------

// ftdi_hw_close:

//-----------------------------------------------------------------

int ftdi_hw_close(void)

{

    if (_handle)

    {

        ftdi_usb_close(_handle);

        ftdi_free(_handle);

        _handle = NULL;

    }

    return 0;

}

//-----------------------------------------------------------------

// ftdi_hw_mem_write:

//-----------------------------------------------------------------

int ftdi_hw_mem_write(uint32_t addr, uint8_t *data, int length)

{

    int i;

    int sent = 0;

    int size = length;

    int res;

    uint8_t buffer[MAX_TX_SIZE + HDR_SIZE];

    uint8_t *p;

    while (sent < length)

    {

        size = (length - sent);

        if (size > MAX_TX_SIZE)

            size = MAX_TX_SIZE;

        // Build packet header

        p = buffer;

        *p++ = (((size >> 8) & 0xF) << 4) | CMD_WR;

        *p++ = (size & 0xFF);

        *p++ = (addr >> 24);

        *p++ = (addr >> 16);

        *p++ = (addr >> 8);

        *p++ = (addr >> 0);

        // Fill packet payload

        for (i=0;i<size;i++)

            *p++ = *data++;

        // Write request + data to FTDI device

        res = ftdi_write_data(_handle, buffer, (size + HDR_SIZE));

        if (res != (size + HDR_SIZE))

        {

            fprintf(stderr, "ftdi_hw_mem_write: Failed to send\n");

            return -1;

        }

        sent += size;

        addr += size;

    }

    return sent;

}

//-----------------------------------------------------------------

// ftdi_hw_mem_read:

//-----------------------------------------------------------------

int ftdi_hw_mem_read(uint32_t addr, uint8_t *data, int length)

{

    int i;

    int received = 0;

    int size = length;

    int remain;

    int res;

    uint8_t buffer[HDR_SIZE];

    uint8_t *p;

    while (received < length)

    {

        size = (length - received);

        if (size > MAX_TX_SIZE)

            size = MAX_TX_SIZE;

        // Round up to nearest 4 byte multiple

        size = (size + 3) & ~3;

        // Build packet header

        p = buffer;

        *p++ = (((size >> 8) & 0xF) << 4) | CMD_RD;

        *p++ = (size & 0xFF);

        *p++ = (addr >> 24);

        *p++ = (addr >> 16);

        *p++ = (addr >> 8);

        *p++ = (addr >> 0);

        // Write request to FTDI device

        res = ftdi_write_data(_handle, buffer, HDR_SIZE);

        if (res != HDR_SIZE)

        {

            fprintf(stderr, "ftdi_hw_mem_read: Failed to send request\n");

            return -1;

        }

        remain = size;

        do

        {

            res = ftdi_read_data(_handle, data, remain);

            if (res < 0)

            {

                fprintf(stderr, "ftdi_hw_mem_read: Failed to read data\n");

                return -1;

            }

            remain -= res;

            data += res;

        }

        while (remain > 0);

        received += size;

        addr     += size;

    }

    return received;

}

//-----------------------------------------------------------------

// ftdi_hw_mem_write_word:

//-----------------------------------------------------------------

int ftdi_hw_mem_write_word(uint32_t addr, uint32_t data)

{

    uint8_t buffer[4];

    buffer[3] = (data >> 24);

    buffer[2] = (data >> 16);

    buffer[1] = (data >> 8);

    buffer[0] = (data >> 0);

    return ftdi_hw_mem_write(addr, buffer, 4);

}

//-----------------------------------------------------------------

// ftdi_hw_mem_read_word:

//-----------------------------------------------------------------

int ftdi_hw_mem_read_word(uint32_t addr, uint32_t *data)

{

    uint8_t buffer[4];

    int res = ftdi_hw_mem_read(addr, buffer, 4);

    if (res > 0)

    {

        (*data) = ((uint32_t)buffer[3]) << 24;

        (*data)|= ((uint32_t)buffer[2]) << 16;

        (*data)|= ((uint32_t)buffer[1]) << 8;

        (*data)|= ((uint32_t)buffer[0]) << 0;

    }

    return res;

}

//-----------------------------------------------------------------

// ftdi_hw_gpio_write:

//-----------------------------------------------------------------

int ftdi_hw_gpio_write(uint8_t value)

{

    uint8_t buffer[2] = { CMD_GP_WR, value };

    // Write request to FTDI device

    int res = ftdi_write_data(_handle, buffer, sizeof(buffer));

    if (res != sizeof(buffer))

    {

        fprintf(stderr, "ftdi_hw_mem_write: Failed to send\n");

        return -1;

    }

    return 0;

}

//-----------------------------------------------------------------

// ftdi_hw_gpio_read:

//-----------------------------------------------------------------

int ftdi_hw_gpio_read(uint8_t *value)

{

    // Write request to FTDI device

    uint8_t request = CMD_GP_RD;

    int res = ftdi_write_data(_handle, &request, 1);

    if (res != 1)

    {

        fprintf(stderr, "ftdi_hw_mem_write: Failed to send\n");

        return -1;

    }

    // Poll for response

    do

    {

        res = ftdi_read_data(_handle, value, 1);

        if (res < 0)

        {

            fprintf(stderr, "ftdi_hw_mem_read: Failed to read data\n");

            return -1;

        }

    }

    while (res != 1);

    return 0;

}