uLab
/
remotelaboratory
mirror of https://mirror.git.trinitydesktop.org/gitea/uLab/remotelaboratory
0
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd1b70f8018'
${ noResults }
remotelaboratory/fpga/xilinx/programmer/dependencies/libxsvf/svf.c

658 lines
15 KiB
Raw Blame History

/*
* Lib(X)SVF - A library for implementing SVF and XSVF JTAG players
*
* Copyright (C) 2009 RIEGL Research ForschungsGmbH
* Copyright (C) 2009 Clifford Wolf <clifford@clifford.at>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
*/
#include "libxsvf.h"
static int read_command(struct libxsvf_host *h, char **buffer_p, int *len_p)
{
char *buffer = *buffer_p;
int braket_mode = 0;
int len = *len_p;
int p = 0;
while (1)
{
if (len < p+10) {
len = len < 64 ? 96 : len*2;
buffer = LIBXSVF_HOST_REALLOC(buffer, len, LIBXSVF_MEM_SVF_COMMANDBUF);
*buffer_p = buffer;
*len_p = len;
if (!buffer) {
LIBXSVF_HOST_REPORT_ERROR("Allocating memory failed.");
return -1;
}
}
buffer[p] = 0;
int ch = LIBXSVF_HOST_GETBYTE();
if (ch < 0) {
handle_eof:
if (p == 0)
return 0;
LIBXSVF_HOST_REPORT_ERROR("Unexpected EOF.");
return -1;
}
if (ch <= ' ') {
insert_eol:
if (!braket_mode && p > 0 && buffer[p-1] != ' ')
buffer[p++] = ' ';
continue;
}
if (ch == '!') {
skip_to_eol:
while (1) {
ch = LIBXSVF_HOST_GETBYTE();
if (ch < 0)
goto handle_eof;
if (ch < ' ' && ch != '\t')
goto insert_eol;
}
}
if (ch == '/' && p > 0 && buffer[p-1] == '/') {
p--;
goto skip_to_eol;
}
if (ch == ';')
break;
if (ch == '(') {
if (!braket_mode && p > 0 && buffer[p-1] != ' ')
buffer[p++] = ' ';
braket_mode++;
}
if (ch >= 'a' && ch <= 'z')
buffer[p++] = ch - ('a' - 'A');
else
buffer[p++] = ch;
if (ch == ')') {
braket_mode--;
if (!braket_mode)
buffer[p++] = ' ';
}
}
return 1;
}
static int strtokencmp(const char *str1, const char *str2)
{
int i = 0;
while (1) {
if ((str1[i] == ' ' || str1[i] == 0) && (str2[i] == ' ' || str2[i] == 0))
return 0;
if (str1[i] < str2[i])
return -1;
if (str1[i] > str2[i])
return +1;
i++;
}
}
static int strtokenskip(const char *str1)
{
int i = 0;
while (str1[i] != 0 && str1[i] != ' ') i++;
while (str1[i] == ' ') i++;
return i;
}
static int token2tapstate(const char *str1)
{
#define X(_t) if (!strtokencmp(str1, #_t)) return LIBXSVF_TAP_ ## _t;
X(RESET)
X(IDLE)
X(DRSELECT)
X(DRCAPTURE)
X(DRSHIFT)
X(DREXIT1)
X(DRPAUSE)
X(DREXIT2)
X(DRUPDATE)
X(IRSELECT)
X(IRCAPTURE)
X(IRSHIFT)
X(IREXIT1)
X(IRPAUSE)
X(IREXIT2)
X(IRUPDATE)
#undef X
return -1;
}
struct bitdata_s {
int len, alloced_len;
int alloced_bytes;
unsigned char *tdi_data;
unsigned char *tdi_mask;
unsigned char *tdo_data;
unsigned char *tdo_mask;
unsigned char *ret_mask;
int has_tdo_data;
};
static void bitdata_free(struct libxsvf_host *h, struct bitdata_s *bd, int offset)
{
LIBXSVF_HOST_REALLOC(bd->tdi_data, 0, offset+0);
LIBXSVF_HOST_REALLOC(bd->tdi_mask, 0, offset+1);
LIBXSVF_HOST_REALLOC(bd->tdo_data, 0, offset+2);
LIBXSVF_HOST_REALLOC(bd->tdo_mask, 0, offset+3);
LIBXSVF_HOST_REALLOC(bd->ret_mask, 0, offset+4);
bd->tdi_data = (void*)0;
bd->tdi_mask = (void*)0;
bd->tdo_data = (void*)0;
bd->tdo_mask = (void*)0;
bd->ret_mask = (void*)0;
}
static int hex(char ch)
{
if (ch >= 'A' && ch <= 'Z')
return (ch - 'A') + 10;
if (ch >= '0' && ch <= '9')
return ch - '0';
return 0;
}
static const char *bitdata_parse(struct libxsvf_host *h, const char *p, struct bitdata_s *bd, int offset)
{
int i, j;
bd->len = 0;
bd->has_tdo_data = 0;
while (*p >= '0' && *p <= '9') {
bd->len = bd->len * 10 + (*p - '0');
p++;
}
while (*p == ' ') {
p++;
}
if (bd->len != bd->alloced_len) {
bitdata_free(h, bd, offset);
bd->alloced_len = bd->len;
bd->alloced_bytes = (bd->len+7) / 8;
}
while (*p)
{
int memnum = 0;
unsigned char **dp = (void*)0;
if (!strtokencmp(p, "TDI")) {
p += strtokenskip(p);
dp = &bd->tdi_data;
memnum = 0;
}
if (!strtokencmp(p, "TDO")) {
p += strtokenskip(p);
dp = &bd->tdo_data;
bd->has_tdo_data = 1;
memnum = 1;
}
if (!strtokencmp(p, "SMASK")) {
p += strtokenskip(p);
dp = &bd->tdi_mask;
memnum = 2;
}
if (!strtokencmp(p, "MASK")) {
p += strtokenskip(p);
dp = &bd->tdo_mask;
memnum = 3;
}
if (!strtokencmp(p, "RMASK")) {
p += strtokenskip(p);
dp = &bd->ret_mask;
memnum = 4;
}
if (!dp)
return (void*)0;
if (*dp == (void*)0) {
*dp = LIBXSVF_HOST_REALLOC(*dp, bd->alloced_bytes, offset+memnum);
}
if (*dp == (void*)0) {
LIBXSVF_HOST_REPORT_ERROR("Allocating memory failed.");
return (void*)0;
}
unsigned char *d = *dp;
for (i=0; i<bd->alloced_bytes; i++)
d[i] = 0;
if (*p != '(')
return (void*)0;
p++;
int hexdigits = 0;
for (i=0; (p[i] >= 'A' && p[i] <= 'F') || (p[i] >= '0' && p[i] <= '9'); i++)
hexdigits++;
i = bd->alloced_bytes*2 - hexdigits;
for (j=0; j<hexdigits; j++, i++, p++) {
if (i%2 == 0) {
d[i/2] |= hex(*p) << 4;
} else {
d[i/2] |= hex(*p);
}
}
if (*p != ')')
return (void*)0;
p++;
while (*p == ' ') {
p++;
}
}
#if 0
/* Debugging Output, needs <stdio.h> */
printf("--- Parsed bitdata [%d] ---\n", bd->len);
if (bd->tdi_data) {
printf("TDI DATA:");
for (i=0; i<bd->alloced_bytes; i++)
printf(" %02x", bd->tdi_data[i]);
printf("\n");
}
if (bd->tdo_data && has_tdo_data) {
printf("TDO DATA:");
for (i=0; i<bd->alloced_bytes; i++)
printf(" %02x", bd->tdo_data[i]);
printf("\n");
}
if (bd->tdi_mask) {
printf("TDI MASK:");
for (i=0; i<bd->alloced_bytes; i++)
printf(" %02x", bd->tdi_mask[i]);
printf("\n");
}
if (bd->tdo_mask) {
printf("TDO MASK:");
for (i=0; i<bd->alloced_bytes; i++)
printf(" %02x", bd->tdo_mask[i]);
printf("\n");
}
#endif
return p;
}
static int getbit(unsigned char *data, int n)
{
return (data[n/8] & (1 << (7 - n%8))) ? 1 : 0;
}
static int bitdata_play(struct libxsvf_host *h, struct bitdata_s *bd, enum libxsvf_tap_state estate)
{
int left_padding = (8 - bd->len % 8) % 8;
int tdo_error = 0;
int tms = 0;
int i;
for (i=bd->len+left_padding-1; i >= left_padding; i--) {
if (i == left_padding && h->tap_state != estate) {
h->tap_state++;
tms = 1;
}
int tdi = -1;
if (bd->tdi_data) {
if (!bd->tdi_mask || getbit(bd->tdi_mask, i))
tdi = getbit(bd->tdi_data, i);
}
int tdo = -1;
if (bd->tdo_data && bd->has_tdo_data && (!bd->tdo_mask || getbit(bd->tdo_mask, i)))
tdo = getbit(bd->tdo_data, i);
int rmask = bd->ret_mask && getbit(bd->ret_mask, i);
if (LIBXSVF_HOST_PULSE_TCK(tms, tdi, tdo, rmask, 0) < 0)
tdo_error = 1;
}
if (tms)
LIBXSVF_HOST_REPORT_TAPSTATE();
if (!tdo_error)
return 0;
LIBXSVF_HOST_REPORT_ERROR("TDO mismatch.");
return -1;
}
int libxsvf_svf(struct libxsvf_host *h)
{
char *command_buffer = (void*)0;
int command_buffer_len = 0;
int rc, i;
struct bitdata_s bd_hdr = { 0, 0, 0, (void*)0, (void*)0, (void*)0, (void*)0, (void*)0 };
struct bitdata_s bd_hir = { 0, 0, 0, (void*)0, (void*)0, (void*)0, (void*)0, (void*)0 };
struct bitdata_s bd_tdr = { 0, 0, 0, (void*)0, (void*)0, (void*)0, (void*)0, (void*)0 };
struct bitdata_s bd_tir = { 0, 0, 0, (void*)0, (void*)0, (void*)0, (void*)0, (void*)0 };
struct bitdata_s bd_sdr = { 0, 0, 0, (void*)0, (void*)0, (void*)0, (void*)0, (void*)0 };
struct bitdata_s bd_sir = { 0, 0, 0, (void*)0, (void*)0, (void*)0, (void*)0, (void*)0 };
int state_endir = LIBXSVF_TAP_IDLE;
int state_enddr = LIBXSVF_TAP_IDLE;
int state_run = LIBXSVF_TAP_IDLE;
int state_endrun = LIBXSVF_TAP_IDLE;
while (1)
{
rc = read_command(h, &command_buffer, &command_buffer_len);
if (rc <= 0)
break;
const char *p = command_buffer;
LIBXSVF_HOST_REPORT_STATUS(command_buffer);
if (!strtokencmp(p, "ENDIR")) {
p += strtokenskip(p);
state_endir = token2tapstate(p);
if (state_endir < 0)
goto syntax_error;
p += strtokenskip(p);
goto eol_check;
}
if (!strtokencmp(p, "ENDDR")) {
p += strtokenskip(p);
state_enddr = token2tapstate(p);
if (state_endir < 0)
goto syntax_error;
p += strtokenskip(p);
goto eol_check;
}
if (!strtokencmp(p, "FREQUENCY")) {
unsigned long number = 0;
int exp = 0;
p += strtokenskip(p);
if (*p < '0' || *p > '9')
goto syntax_error;
while (*p >= '0' && *p <= '9') {
number = number*10 + (*p - '0');
p++;
}
if(*p == 'E' || *p == 'e') {
p++;
while (*p >= '0' && *p <= '9') {
exp = exp*10 + (*p - '0');
p++;
}
for(i=0; i<exp; i++)
number *= 10;
}
while (*p == ' ') {
p++;
}
p += strtokenskip(p);
if (LIBXSVF_HOST_SET_FREQUENCY(number) < 0) {
LIBXSVF_HOST_REPORT_ERROR("FREQUENCY command failed!");
goto error;
}
goto eol_check;
}
if (!strtokencmp(p, "HDR")) {
p += strtokenskip(p);
p = bitdata_parse(h, p, &bd_hdr, LIBXSVF_MEM_SVF_HDR_TDI_DATA);
if (!p)
goto syntax_error;
goto eol_check;
}
if (!strtokencmp(p, "HIR")) {
p += strtokenskip(p);
p = bitdata_parse(h, p, &bd_hir, LIBXSVF_MEM_SVF_HIR_TDI_DATA);
if (!p)
goto syntax_error;
goto eol_check;
}
if (!strtokencmp(p, "PIO") || !strtokencmp(p, "PIOMAP")) {
goto unsupported_error;
}
if (!strtokencmp(p, "RUNTEST")) {
p += strtokenskip(p);
int tck_count = -1;
int sck_count = -1;
int min_time = -1;
int max_time = -1;
while (*p) {
int got_maximum = 0;
if (!strtokencmp(p, "MAXIMUM")) {
p += strtokenskip(p);
got_maximum = 1;
}
int got_endstate = 0;
if (!strtokencmp(p, "ENDSTATE")) {
p += strtokenskip(p);
got_endstate = 1;
}
int st = token2tapstate(p);
if (st >= 0) {
p += strtokenskip(p);
if (got_endstate)
state_endrun = st;
else
state_run = st;
continue;
}
if (*p < '0' || *p > '9')
goto syntax_error;
int number = 0;
int exp = 0, expsign = 1;
int number_e6, exp_e6;
while (*p >= '0' && *p <= '9') {
number = number*10 + (*p - '0');
p++;
}
if(*p == 'E' || *p == 'e') {
p++;
if(*p == '-') {
expsign = -1;
p++;
}
while (*p >= '0' && *p <= '9') {
exp = exp*10 + (*p - '0');
p++;
}
exp = exp * expsign;
number_e6 = number;
exp_e6 = exp + 6;
while (exp < 0) {
number /= 10;
exp++;
}
while (exp > 0) {
number *= 10;
exp--;
}
while (exp_e6 < 0) {
number_e6 /= 10;
exp_e6++;
}
while (exp_e6 > 0) {
number_e6 *= 10;
exp_e6--;
}
} else {
number_e6 = number * 1000000;
}
while (*p == ' ') {
p++;
}
if (!strtokencmp(p, "SEC")) {
p += strtokenskip(p);
if (got_maximum)
max_time = number_e6;
else
min_time = number_e6;
continue;
}
if (!strtokencmp(p, "TCK")) {
p += strtokenskip(p);
tck_count = number;
continue;
}
if (!strtokencmp(p, "SCK")) {
p += strtokenskip(p);
sck_count = number;
continue;
}
goto syntax_error;
}
if (libxsvf_tap_walk(h, state_run) < 0)
goto error;
if (max_time >= 0) {
LIBXSVF_HOST_REPORT_ERROR("WARNING: Maximum time in SVF RUNTEST command is ignored.");
}
if (sck_count >= 0) {
for (i=0; i < sck_count; i++) {
LIBXSVF_HOST_PULSE_SCK();
}
}
if (min_time >= 0 || tck_count >= 0) {
LIBXSVF_HOST_UDELAY(min_time >= 0 ? min_time : 0, 0, tck_count >= 0 ? tck_count : 0);
}
if (libxsvf_tap_walk(h, state_endrun) < 0)
goto error;
goto eol_check;
}
if (!strtokencmp(p, "SDR")) {
p += strtokenskip(p);
p = bitdata_parse(h, p, &bd_sdr, LIBXSVF_MEM_SVF_SDR_TDI_DATA);
if (!p)
goto syntax_error;
if (libxsvf_tap_walk(h, LIBXSVF_TAP_DRSHIFT) < 0)
goto error;
if (bitdata_play(h, &bd_hdr, bd_sdr.len+bd_tdr.len > 0 ? LIBXSVF_TAP_DRSHIFT : state_enddr) < 0)
goto error;
if (bitdata_play(h, &bd_sdr, bd_tdr.len > 0 ? LIBXSVF_TAP_DRSHIFT : state_enddr) < 0)
goto error;
if (bitdata_play(h, &bd_tdr, state_enddr) < 0)
goto error;
if (libxsvf_tap_walk(h, state_enddr) < 0)
goto error;
goto eol_check;
}
if (!strtokencmp(p, "SIR")) {
p += strtokenskip(p);
p = bitdata_parse(h, p, &bd_sir, LIBXSVF_MEM_SVF_SIR_TDI_DATA);
if (!p)
goto syntax_error;
if (libxsvf_tap_walk(h, LIBXSVF_TAP_IRSHIFT) < 0)
goto error;
if (bitdata_play(h, &bd_hir, bd_sir.len+bd_tir.len > 0 ? LIBXSVF_TAP_IRSHIFT : state_endir) < 0)
goto error;
if (bitdata_play(h, &bd_sir, bd_tir.len > 0 ? LIBXSVF_TAP_IRSHIFT : state_endir) < 0)
goto error;
if (bitdata_play(h, &bd_tir, state_endir) < 0)
goto error;
if (libxsvf_tap_walk(h, state_endir) < 0)
goto error;
goto eol_check;
}
if (!strtokencmp(p, "STATE")) {
p += strtokenskip(p);
while (*p) {
int st = token2tapstate(p);
if (st < 0)
goto syntax_error;
if (libxsvf_tap_walk(h, st) < 0)
goto error;
p += strtokenskip(p);
}
goto eol_check;
}
if (!strtokencmp(p, "TDR")) {
p += strtokenskip(p);
p = bitdata_parse(h, p, &bd_tdr, LIBXSVF_MEM_SVF_TDR_TDI_DATA);
if (!p)
goto syntax_error;
goto eol_check;
}
if (!strtokencmp(p, "TIR")) {
p += strtokenskip(p);
p = bitdata_parse(h, p, &bd_tir, LIBXSVF_MEM_SVF_TIR_TDI_DATA);
if (!p)
goto syntax_error;
goto eol_check;
}
if (!strtokencmp(p, "TRST")) {
p += strtokenskip(p);
if (!strtokencmp(p, "ON")) {
p += strtokenskip(p);
LIBXSVF_HOST_SET_TRST(1);
goto eol_check;
}
if (!strtokencmp(p, "OFF")) {
p += strtokenskip(p);
LIBXSVF_HOST_SET_TRST(0);
goto eol_check;
}
if (!strtokencmp(p, "Z")) {
p += strtokenskip(p);
LIBXSVF_HOST_SET_TRST(-1);
goto eol_check;
}
if (!strtokencmp(p, "ABSENT")) {
p += strtokenskip(p);
LIBXSVF_HOST_SET_TRST(-2);
goto eol_check;
}
goto syntax_error;
}
eol_check:
while (*p == ' ')
p++;
if (*p == 0)
continue;
syntax_error:
LIBXSVF_HOST_REPORT_ERROR("SVF Syntax Error:");
if (0) {
unsupported_error:
LIBXSVF_HOST_REPORT_ERROR("Error in SVF input: unsupported command:");
}
LIBXSVF_HOST_REPORT_ERROR(command_buffer);
error:
rc = -1;
break;
}
if (LIBXSVF_HOST_SYNC() != 0 && rc >= 0 ) {
LIBXSVF_HOST_REPORT_ERROR("TDO mismatch.");
rc = -1;
}
bitdata_free(h, &bd_hdr, LIBXSVF_MEM_SVF_HDR_TDI_DATA);
bitdata_free(h, &bd_hir, LIBXSVF_MEM_SVF_HIR_TDI_DATA);
bitdata_free(h, &bd_tdr, LIBXSVF_MEM_SVF_TDR_TDI_DATA);
bitdata_free(h, &bd_tir, LIBXSVF_MEM_SVF_TIR_TDI_DATA);
bitdata_free(h, &bd_sdr, LIBXSVF_MEM_SVF_SDR_TDI_DATA);
bitdata_free(h, &bd_sir, LIBXSVF_MEM_SVF_SIR_TDI_DATA);
LIBXSVF_HOST_REALLOC(command_buffer, 0, LIBXSVF_MEM_SVF_COMMANDBUF);
return rc;
}
Reference in new issue View Git Blame Copy Permalink