Subversion Repositories adv_debug_sys

   Copyright (C) 2008 Kolja Waschk (UrJTAG project)

   CPLD mode for burst transfers added by:

           Copyright (C) 2011 Raul Fajardo, rfajardo@opencores.org

   adapted from xc3sprog/ioxpc.cpp:

           Copyright (C) 2009-2011 Uwe Bonnes bon@elektron.ikp.physik.tu-darmstadt.de

#include <errno.h>

#include <string.h>

#include "utilities.h"

/*

 * The dynamic switch between FX2 and CPLD modes works fine. If a switch is required, the functions:

 *              static int cable_xpcusb_fx2_init();

 *              static int cable_xpcusb_cpld_init();

 * can be called. The variable cpld_ctrl can tell if the CPLD is active (1) or FX2 (0).

 *

 * The functions accessing the cable in this driver always check the cpld_ctrl variable and adapt the

 * cable mode accordingly.

 *

 * Therefore, we can arbitrarily define bit and stream functionality from different modes without

 * concern. Out_func and inout_func are not provided under CPLD mode because it always complete

 * a bit transfer by toggling the clock twice 0-1-0 providing a write and a read.

 *

 * When using stream functionality of the CPLD, and bit functionality of FX2, also cable_common_read_write_bit

 * works. The cable_xpcusb_read_write_bit is not necessary then. However, it is still necessary when using:

 *                      cable_common_write_stream

 *                      cable_common_read_stream

 */

#define debug(...) //fprintf(stderr, __VA_ARGS__ )

//#define CLASSIC

#define CPLDBITFUNC

#ifdef CLASSIC

#else

jtag_cable_t dlc9_cable_driver = {

    .name ="xpc_usb" ,

    .inout_func = cable_xpcusb_inout,

    .out_func = cable_xpcusb_out,

    .init_func = cable_xpcusb_init,

    .opt_func = cable_xpcusb_opt,

#ifdef CPLDBITFUNC

    .bit_out_func = cable_xpcusb_cpld_write_bit,

    .bit_inout_func = cable_xpcusb_cpld_readwrite_bit,

#else

    .bit_out_func = cable_common_write_bit,

    .bit_inout_func = cable_common_read_write_bit,

#endif

    .stream_out_func = cable_xpcusb_write_stream,

    .stream_inout_func = cable_xpcusb_readwrite_stream,

    .flush_func = NULL,

    .opts = "",

    .help = "no options\n",

   };

#endif

/*

 * send max 4096 bytes to CPLD

 * this is equal to 8192 TDI plus 8192 TDO bits

 */

#define CPLD_MAX_BYTES (1<<12)

/*

 * Buffer has to hold 8192 bits for write, each 2 bytes hold 4 bits for write, so this has to be 4096

 * Buffer has to hold 8192 bits for read, each byte holds 8 bits for read, so this has to be 1024

 * Therefore, buffer size -> CPLD_MAX_BYTES

 */

typedef struct

{

  int in_bits;

  int out_bits;

  uint8_t buf[CPLD_MAX_BYTES];

}  xpc_ext_transfer_state_t;

static struct usb_device *device = NULL;

static usb_dev_handle *h_device = NULL;

static int cpld_ctrl = 0;

static const uint32_t endianess_test = 1;

#define is_bigendian() ( (*(uint8_t*)&endianess_test) == 0 )

static int cable_xpcusb_open_cable(void);

static void cable_xpcusb_close_cable(void);

static int cable_xpcusb_fx2_init();

static int cable_xpcusb_cpld_init();

    return 0;

}

    return 0;

 *   === A6 transfer (TDI/TMS/TCK/RDO) ===

 *

 *   Vendor request 0xA6 initiates a quite universal shift operation. The data

 *   is passed directly to the CPLD as 16-bit words.

 *

 *   The argument N in the request specifies the number of state changes/bits.

 *

 *   State changes are described by the following bulk write. It consists

 *   of ceil(N/4) little-endian 16-bit words, each describing up to 4 changes.

 *   (see xpcusb_add_bit_for_ext_transfer)

 *

 *   After the bulk write, if any of the bits 12..15 was set in any word

 *   (see xpcusb_add_bit_for_ext_transfer), a bulk_read shall follow to collect

 *   the TDO data.

 */

static int xpcu_shift(struct usb_dev_handle *xpcu, int reqno, int bits, int in_len, uint8_t *in, int out_len, uint8_t *out )

{

    if(usb_control_msg(xpcu, 0x40, 0xB0, reqno, bits, NULL, 0, 1000)<0)

    {

        perror("usb_control_msg(x.x) (shift)");

        return -1;

        int i;

    printf("\n###\n");

    printf("reqno = %02X\n", reqno);

    printf("bits    = %d\n", bits);

    printf("in_len  = %d, in_len*2  = %d\n", in_len, in_len * 2);

    printf("out_len = %d, out_len*8 = %d\n", out_len, out_len * 8);

    printf("a6_display(\"%02X\", \"", bits);

    for(i=0;i<in_len;i++) printf("%02X%s", in[i], (i+1<in_len)?",":"");

    printf("\", ");

#endif

    if(usb_bulk_write(xpcu, 0x02, (char*)in, in_len, 1000)<0)

    {

        fprintf(stderr, "\nusb_bulk_write error(shift): %s\n", strerror(errno));

        fprintf(stderr, "Burst length: %d\n", in_len);

        return -1;

    }

      {

        printf("\nusb_bulk_read error(shift): %s\n", strerror(errno));

        return -1;

      }

    }

    printf("\"");

    for(i=0;i<out_len;i++) printf("%02X%s", out[i], (i+1<out_len)?",":"");

    printf("\")\n");

#endif

}

 *   Bit 0: Value for first TDI to shift out.

 *   Bit 1: Second TDI.

 *   Bit 2: Third TDI.

 *   Bit 3: Fourth TDI.

 *

 *   Bit 4: Value for first TMS to shift out.

 *   Bit 5: Second TMS.

 *   Bit 6: Third TMS.

 *   Bit 7: Fourth TMS.

 *

 *   Bit 8: Whether to raise/lower TCK for first bit.

 *   Bit 9: Same for second bit.

 *   Bit 10: Third bit.

 *   Bit 11: Fourth bit.

 *

 *   Bit 12: Whether to read TDO for first bit

 *   Bit 13: Same for second bit.

 *   Bit 14: Third bit.

 *   Bit 15: Fourth bit.

 *   */

static void xpcusb_add_bit_for_ext_transfer(xpc_ext_transfer_state_t *xts, uint8_t toggle_tclk, uint8_t tms, uint8_t tdi, uint8_t sample_tdo)

        debug("add_bit, in = %i, bit_idx = %i, buf_idx = %i\n", tdi, bit_idx, buf_idx);

        if(bit_idx == 0)

        {

                xts->buf[buf_idx] = 0;

                xts->buf[buf_idx+1] = 0;

        }

 *   In a "full" word with 32 TDO bits, the earliest one reached bit 0.

 *   The earliest of 31 bits however would be bit 1. A 17 bit transfer has the LSB

 *   as the MSB of uint16_t[0], other bits are in uint16_t[1].

 *

 *   However, if the last packet is smaller than 16, only 2 bytes are transferred.

 *   If there's only one TDO bit, it arrives as the MSB of the 16-bit word, uint16_t[0].

 *   uint16_t[1] is then skipped.

 *

 *   For full 32 bits blocks, the data is aligned. The last non 32-bits block arrives

 *   non-aligned and has to be re-aligned. Half-words (16-bits) transfers have to be

 *   re-aligned too.

 */

static int xpcusb_do_ext_transfer(xpc_ext_transfer_state_t *xts, uint32_t * tdostream)

    uint32_t out_done;

    in_len = 2 * (xts->in_bits >> 2);

    if ((xts->in_bits & 3) != 0) in_len += 2;

    if ((xts->out_bits & 15) != 0) out_len += 2;

        aligned_bytes = aligned_32bitwords*4;

        if ( is_bigendian() )                                                           //these data is aligned as little-endian

        {

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

                {

                        if ( i%4 == 0 )

                                tdostream[i/4] = 0;

                        tdostream[i/4] |= xts->buf[i] << (i%4)*8;

        }

        else

                memcpy(tdostream, xts->buf, aligned_bytes);             //these data is already little-endian

                                                                                                //out_bits > 16 and ( shift = 32 - out_bits % 32 )

                        tdostream[out_done/32] = 0;

                if (bit_val)

                        tdostream[out_done/32] |= (1<<(out_done%32));

                out_done++;

                cable_xpcusb_close_cable();

                return APP_ERR_USB;

        // open the device, if necessary

        if(h_device == NULL) {

                rv = cable_xpcusb_open_cable();

                if(rv != APP_ERR_NONE) return rv;

        }

        if ( cpld_ctrl )

        {

                rv = cable_xpcusb_fx2_init();

                if ( rv != APP_ERR_NONE) return rv;

        }

                return APP_ERR_USB;

int cable_xpcusb_cpld_write_bit(uint8_t value)

{

        uint32_t out;

        out = (value & TDO) ? 1:0;

        return cable_xpcusb_write_stream(&out, 1, value & TMS);

}

int cable_xpcusb_cpld_readwrite_bit(uint8_t value, uint8_t *inval)

{

        int r;

        uint32_t out;

        uint32_t in;

        out = (value & TDO) ? 1:0;

        r = cable_xpcusb_readwrite_stream(&out, &in, 1, value & TMS);

        if ( r < 0 )