static int
cmd_salias_run (urj_chain_t *chain, char *params[])
{
urj_part_t *part;
urj_part_signal_t *s;
urj_part_salias_t *sa;
if (urj_cmd_params (params) != 3)
{
urj_error_set (URJ_ERROR_SYNTAX,
"%s: #parameters should be %d, not %d",
params[0], 3, urj_cmd_params (params));
return URJ_STATUS_FAIL;
}
if (urj_cmd_test_cable (chain) != URJ_STATUS_OK)
return URJ_STATUS_FAIL;
part = urj_tap_chain_active_part (chain);
if (part == NULL)
return URJ_STATUS_FAIL;
if (urj_part_find_signal (part, params[1]) != NULL)
{
return URJ_STATUS_FAIL;
}
s = urj_part_find_signal (part, params[2]);
if (s == NULL)
{
urj_error_set (URJ_ERROR_NOTFOUND, _("Signal '%s' not found"),
params[2]);
return URJ_STATUS_FAIL;
}
sa = urj_part_salias_alloc (params[1], s);
if (!sa)
return URJ_STATUS_FAIL;
sa->next = part->saliases;
part->saliases = sa;
return URJ_STATUS_OK;
}
static int
cmd_get_run (urj_chain_t *chain, char *params[])
{
int data;
urj_part_signal_t *s;
urj_part_t *part;
if (urj_cmd_params (params) != 3)
{
urj_error_set (URJ_ERROR_SYNTAX,
"%s: #parameters should be %d, not %d",
params[0], 3, urj_cmd_params (params));
return URJ_STATUS_FAIL;
}
if (strcasecmp (params[1], "signal") != 0)
{
urj_error_set (URJ_ERROR_SYNTAX,
"params[1] must be 'signal', not '%s'", params[1]);
return URJ_STATUS_FAIL;
}
if (urj_cmd_test_cable (chain) != URJ_STATUS_OK)
return URJ_STATUS_FAIL;
part = urj_tap_chain_active_part (chain);
if (part == NULL)
return URJ_STATUS_FAIL;
s = urj_part_find_signal (part, params[2]);
if (!s)
{
urj_error_set (URJ_ERROR_NOTFOUND, _("signal '%s' not found"),
params[2]);
return URJ_STATUS_FAIL;
}
data = urj_part_get_signal (part, s);
if (data == -1)
return URJ_STATUS_FAIL;
urj_log (URJ_LOG_LEVEL_NORMAL, _("%s = %d\n"), params[2], data);
return URJ_STATUS_OK;
}
urj_part_signal_t *
urj_part_signal_define_pin (urj_chain_t *chain, const char *signal_name,
const char *pin_name)
{
urj_part_t *part;
urj_part_signal_t *s;
part = urj_tap_chain_active_part (chain);
if (urj_part_find_signal (part, signal_name) != NULL)
{
urj_error_set (URJ_ERROR_ALREADY,
_("Signal '%s' already defined"), signal_name);
return NULL;
}
s = urj_part_signal_alloc (signal_name);
if (!s)
return NULL;
if (pin_name != NULL)
{ /* Add pin number */
/* Allocate the space for the pin number & copy it */
s->pin = strdup (pin_name);
if (s->pin == NULL)
{
urj_part_signal_free (s);
urj_error_set (URJ_ERROR_OUT_OF_MEMORY, "strdup(%s) fails",
pin_name);
return NULL;
}
}
s->next = part->signals;
part->signals = s;
return s;
}
/**
* bus->driver->(*new_bus)
*
*/
static urj_bus_t *
prototype_bus_new (urj_chain_t *chain, const urj_bus_driver_t *driver,
const urj_param_t *cmd_params[])
{
urj_bus_t *bus;
urj_part_signal_t *sig;
char buff[16], fmt[16], afmt[16], dfmt[16];
int i, j, inst, max, min;
int failed = 0;
int ashift = -1;
const char *value;
bus = urj_bus_generic_new (chain, driver, sizeof (bus_params_t));
if (bus == NULL)
return NULL;
CS = OE = WE = NULL;
ALSBI = AMSBI = DLSBI = DMSBI = -1;
for (i = 0; cmd_params[i] != NULL; i++)
{
if (cmd_params[i]->key == URJ_BUS_PARAM_KEY_AMODE ||
cmd_params[i]->key == URJ_BUS_PARAM_KEY_WIDTH)
{
switch (cmd_params[i]->value.lu)
{
case 8:
ashift = 0;
break;
case 16:
ashift = 1;
break;
case 32:
ashift = 2;
break;
case 0: // "auto"
break;
default:
urj_error_set (URJ_ERROR_INVALID,
_("value %lu not defined for parameter %s"),
cmd_params[i]->value.lu,
urj_param_string(&urj_bus_param_list,
cmd_params[i]));
failed = 1; // @@@@ RFHH
break;
}
}
else
{
if (cmd_params[i]->type != URJ_PARAM_TYPE_STRING)
{
urj_error_set (URJ_ERROR_SYNTAX,
"parameter must be of type string");
failed = 1;
continue;
}
value = cmd_params[i]->value.string;
inst = 32;
prototype_bus_signal_parse (value, fmt, &inst);
// @@@@ RFHH Flag error?
// @@@@ RFHH If it is mandatory for a signal to have an int inst
// number, why does prototype_bus_signal_parse() accept values
// without an int?
if (inst > 31 || inst < 0)
continue;
sig = urj_part_find_signal (bus->part, value);
if (!sig)
{
urj_error_set (URJ_ERROR_NOTFOUND, _("signal '%s' not found"),
value);
failed = 1;
continue;
}
switch (cmd_params[i]->key)
{
case URJ_BUS_PARAM_KEY_ALSB:
ALSBI = inst;
A[inst] = sig;
strcpy (afmt, fmt);
break;
case URJ_BUS_PARAM_KEY_AMSB:
AMSBI = inst;
A[inst] = sig;
strcpy (afmt, fmt);
break;
case URJ_BUS_PARAM_KEY_DLSB:
DLSBI = inst;
D[inst] = sig;
strcpy (dfmt, fmt);
break;
case URJ_BUS_PARAM_KEY_DMSB:
DMSBI = inst;
D[inst] = sig;
strcpy (dfmt, fmt);
break;
case URJ_BUS_PARAM_KEY_CS:
case URJ_BUS_PARAM_KEY_NCS:
CS = sig;
CSA = (cmd_params[i]->key == URJ_BUS_PARAM_KEY_CS);
break;
case URJ_BUS_PARAM_KEY_OE:
case URJ_BUS_PARAM_KEY_NOE:
OE = sig;
OEA = (cmd_params[i]->key == URJ_BUS_PARAM_KEY_OE);
break;
case URJ_BUS_PARAM_KEY_WE:
case URJ_BUS_PARAM_KEY_NWE:
WE = sig;
WEA = (cmd_params[i]->key == URJ_BUS_PARAM_KEY_WE);
break;
default:
urj_error_set (URJ_ERROR_INVALID, _("parameter %s is unknown"),
urj_param_string(&urj_bus_param_list,
cmd_params[i]));
failed = 1;
break;
}
}
}
if (ALSBI >= 0 || AMSBI >= 0)
{
if (ALSBI == -1 || AMSBI == -1)
{
for (min = 0; min <= 31; min++)
{
sprintf (buff, afmt, min);
A[min] = urj_part_find_signal (bus->part, buff);
if (A[min])
break;
}
for (max = 31; max >= 0; max--)
{
sprintf (buff, afmt, max);
A[max] = urj_part_find_signal (bus->part, buff);
if (A[max])
break;
}
if (ALSBI == -1)
ALSBI = (max - AMSBI < AMSBI - min) ? min : max;
else
AMSBI = (max - ALSBI < ALSBI - min) ? min : max;
}
AI = (AMSBI > ALSBI ? 1 : -1);
AW = (AMSBI > ALSBI ? AMSBI - ALSBI : ALSBI - AMSBI) + 1;
for (i = 0, j = ALSBI; i < AW; i++, j += AI)
{
sprintf (buff, afmt, j);
// @@@@ RFHH check result
A[j] = urj_part_find_signal (bus->part, buff);
}
}
else
{
urj_error_set (URJ_ERROR_INVALID,
_("parameters alsb=<signal> and/or amsb=<signal> are not defined"));
failed = 1;
}
if (DLSBI >= 0 || DMSBI >= 0)
{
if (DLSBI == -1 || DMSBI == -1)
{
for (min = 0; min <= 31; min++)
{
sprintf (buff, dfmt, min);
D[min] = urj_part_find_signal (bus->part, buff);
if (D[min])
break;
}
for (max = 31; max >= 0; max--)
{
sprintf (buff, dfmt, max);
D[max] = urj_part_find_signal (bus->part, buff);
if (D[max])
break;
}
if (DLSBI == -1)
DLSBI = (max - DMSBI < DMSBI - min) ? min : max;
else
DMSBI = (max - DLSBI < DLSBI - min) ? min : max;
}
DI = (DMSBI > DLSBI ? 1 : -1);
DW = (DMSBI > DLSBI ? DMSBI - DLSBI : DLSBI - DMSBI) + 1;
for (i = 0, j = DLSBI; i < DW; i++, j += DI)
{
sprintf (buff, dfmt, j);
D[j] = urj_part_find_signal (bus->part, buff);
}
/* bus drivers are called with a byte address
this address needs to be adjusted by setup_address() to the memory data width */
if (ashift < 0)
{
int nbytes;
/* parameter 'amode' wasn't specified, derive the address shift from the
data bus width */
nbytes = DW / 8;
if (DW % 8 > 0)
nbytes++;
ashift = 0;
while (nbytes != 1)
{
nbytes >>= 1;
ashift++;
}
}
ASHIFT = ashift;
}
int
urj_part_bsbit_alloc_control (urj_part_t *part, int bit, const char *name,
int type, int safe,
int ctrl_num, int ctrl_val, int ctrl_state)
{
urj_bsbit_t *b;
urj_data_register_t *bsr;
urj_part_signal_t *signal;
bsr = urj_part_find_data_register (part, "BSR");
if (bsr == NULL)
{
urj_error_set(URJ_ERROR_NOTFOUND,
_("missing Boundary Scan Register (BSR)"));
return URJ_STATUS_FAIL;
}
if (bit >= bsr->in->len)
{
urj_error_set(URJ_ERROR_INVALID, _("invalid boundary bit number"));
return URJ_STATUS_FAIL;
}
if (part->bsbits[bit] != NULL)
{
urj_error_set(URJ_ERROR_ALREADY, _("duplicate bit declaration"));
return URJ_STATUS_FAIL;
}
if (ctrl_num != -1 && ctrl_num >= bsr->in->len)
{
urj_error_set(URJ_ERROR_INVALID, _("invalid control bit number"));
return URJ_STATUS_FAIL;
}
signal = urj_part_find_signal (part, name);
bsr->in->data[bit] = safe;
b = malloc (sizeof *b);
if (!b)
{
urj_error_set (URJ_ERROR_OUT_OF_MEMORY, "malloc(%zd) fails", sizeof *b);
return URJ_STATUS_FAIL;
}
b->name = strdup (name);
if (!b->name)
{
free (b);
urj_error_set (URJ_ERROR_OUT_OF_MEMORY, "strdup(%s) fails", name);
return URJ_STATUS_FAIL;
}
b->bit = bit;
b->type = type;
b->signal = signal;
b->safe = (safe == 1);
b->control = -1;
part->bsbits[bit] = b;
if (signal != NULL)
{
switch (type)
{
case URJ_BSBIT_INPUT:
signal->input = b;
break;
case URJ_BSBIT_OUTPUT:
signal->output = b;
break;
case URJ_BSBIT_BIDIR:
signal->input = b;
signal->output = b;
break;
}
}
if (ctrl_num != -1)
{
b->control = ctrl_num;
b->control_value = ctrl_val;
b->control_state = ctrl_state;
}
return URJ_STATUS_OK;
}
static int
cmd_set_run (urj_chain_t *chain, char *params[])
{
int dir;
long unsigned data = 0;
urj_part_signal_t *s;
urj_part_t *part;
if (urj_cmd_params (params) < 4 || urj_cmd_params (params) > 5)
{
urj_error_set (URJ_ERROR_SYNTAX,
"%s: #parameters should be 4 or 5, not %d",
params[0], urj_cmd_params (params));
return URJ_STATUS_FAIL;
}
if (strcasecmp (params[1], "signal") != 0)
{
urj_error_set (URJ_ERROR_SYNTAX,
"%s: second parameter must be '%s'",
params[0], params[1]);
return URJ_STATUS_FAIL;
}
if (urj_cmd_test_cable (chain) != URJ_STATUS_OK)
return URJ_STATUS_FAIL;
part = urj_tap_chain_active_part (chain);
if (part == NULL)
return URJ_STATUS_FAIL;
/* direction */
if (strcasecmp (params[3], "in") != 0
&& strcasecmp (params[3], "out") != 0)
{
urj_error_set (URJ_ERROR_SYNTAX,
"%s: DIR parameter must be 'in' or 'out', not '%s'",
params[0], params[3]);
return URJ_STATUS_FAIL;
}
dir = (strcasecmp (params[3], "in") == 0) ? 0 : 1;
if (dir)
{
if (urj_cmd_get_number (params[4], &data) != URJ_STATUS_OK)
return URJ_STATUS_FAIL;
if (data > 1)
{
urj_error_set (URJ_ERROR_SYNTAX,
"%s: DATA parameter must be '0' or '1', not '%s'",
params[0], params[4]);
return URJ_STATUS_FAIL;
}
}
s = urj_part_find_signal (part, params[2]);
if (!s)
{
urj_error_set (URJ_ERROR_NOTFOUND, _("signal '%s' not found"),
params[2]);
return URJ_STATUS_FAIL;
}
return urj_part_set_signal (part, s, dir, data);
}
