Clean up the PLD files:
- Get rid of some extraneous whitespace
- Make various functions static
- Wrap overlong lines
git-svn-id: svn://svn.berlios.de/openocd/trunk@2272
b42882b7-edfa-0310-969c-
e2dbd0fdcd60
*/
extern pld_driver_t virtex2_pld;
*/
extern pld_driver_t virtex2_pld;
-pld_driver_t *pld_drivers[] =
+static pld_driver_t *pld_drivers[] =
-pld_device_t *pld_devices;
+static pld_device_t *pld_devices;
static command_t *pld_cmd;
static command_t *pld_cmd;
-int handle_pld_devices_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_pld_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
-int handle_pld_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
+static int handle_pld_devices_command(struct command_context_s *cmd_ctx,
+ char *cmd, char **args, int argc);
+static int handle_pld_device_command(struct command_context_s *cmd_ctx,
+ char *cmd, char **args, int argc);
+static int handle_pld_load_command(struct command_context_s *cmd_ctx,
+ char *cmd, char **args, int argc);
int pld_init(struct command_context_s *cmd_ctx)
{
int pld_init(struct command_context_s *cmd_ctx)
{
register_command(cmd_ctx, pld_cmd, "load", handle_pld_load_command, COMMAND_EXEC,
"load configuration <file> into programmable logic device");
}
register_command(cmd_ctx, pld_cmd, "load", handle_pld_load_command, COMMAND_EXEC,
"load configuration <file> into programmable logic device");
}
return NULL;
}
/* pld device <driver> [driver_options ...]
*/
return NULL;
}
/* pld device <driver> [driver_options ...]
*/
-int handle_pld_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_pld_device_command(struct command_context_s *cmd_ctx,
+ char *cmd, char **args, int argc)
- LOG_WARNING("incomplete 'pld bank' configuration");
+ LOG_WARNING("incomplete 'pld device' command");
for (i = 0; pld_drivers[i]; i++)
{
if (strcmp(args[0], pld_drivers[i]->name) == 0)
{
pld_device_t *p, *c;
for (i = 0; pld_drivers[i]; i++)
{
if (strcmp(args[0], pld_drivers[i]->name) == 0)
{
pld_device_t *p, *c;
/* register pld specific commands */
if (pld_drivers[i]->register_commands(cmd_ctx) != ERROR_OK)
{
LOG_ERROR("couldn't register '%s' commands", args[0]);
exit(-1);
}
/* register pld specific commands */
if (pld_drivers[i]->register_commands(cmd_ctx) != ERROR_OK)
{
LOG_ERROR("couldn't register '%s' commands", args[0]);
exit(-1);
}
c = malloc(sizeof(pld_device_t));
c->driver = pld_drivers[i];
c->next = NULL;
c = malloc(sizeof(pld_device_t));
c->driver = pld_drivers[i];
c->next = NULL;
if (pld_drivers[i]->pld_device_command(cmd_ctx, cmd, args, argc, c) != ERROR_OK)
{
LOG_ERROR("'%s' driver rejected pld device", args[0]);
free(c);
return ERROR_OK;
}
if (pld_drivers[i]->pld_device_command(cmd_ctx, cmd, args, argc, c) != ERROR_OK)
{
LOG_ERROR("'%s' driver rejected pld device", args[0]);
free(c);
return ERROR_OK;
}
/* put pld device in linked list */
if (pld_devices)
{
/* put pld device in linked list */
if (pld_devices)
{
/* no matching pld driver found */
if (!found)
{
LOG_ERROR("pld driver '%s' not found", args[0]);
exit(-1);
}
/* no matching pld driver found */
if (!found)
{
LOG_ERROR("pld driver '%s' not found", args[0]);
exit(-1);
}
-int handle_pld_devices_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_pld_devices_command(struct command_context_s *cmd_ctx,
+ char *cmd, char **args, int argc)
{
pld_device_t *p;
int i = 0;
{
pld_device_t *p;
int i = 0;
if (!pld_devices)
{
command_print(cmd_ctx, "no pld devices configured");
return ERROR_OK;
}
if (!pld_devices)
{
command_print(cmd_ctx, "no pld devices configured");
return ERROR_OK;
}
for (p = pld_devices; p; p = p->next)
{
command_print(cmd_ctx, "#%i: %s", i++, p->driver->name);
}
for (p = pld_devices; p; p = p->next)
{
command_print(cmd_ctx, "#%i: %s", i++, p->driver->name);
}
-int handle_pld_load_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int handle_pld_load_command(struct command_context_s *cmd_ctx,
+ char *cmd, char **args, int argc)
{
int retval;
struct timeval start, end, duration;
pld_device_t *p;
{
int retval;
struct timeval start, end, duration;
pld_device_t *p;
gettimeofday(&start, NULL);
gettimeofday(&start, NULL);
if (argc < 2)
{
command_print(cmd_ctx, "usage: pld load <device#> <file>");
return ERROR_OK;
}
if (argc < 2)
{
command_print(cmd_ctx, "usage: pld load <device#> <file>");
return ERROR_OK;
}
p = get_pld_device_by_num(strtoul(args[0], NULL, 0));
if (!p)
{
command_print(cmd_ctx, "pld device '#%s' is out of bounds", args[0]);
return ERROR_OK;
}
p = get_pld_device_by_num(strtoul(args[0], NULL, 0));
if (!p)
{
command_print(cmd_ctx, "pld device '#%s' is out of bounds", args[0]);
return ERROR_OK;
}
if ((retval = p->driver->load(p, args[1])) != ERROR_OK)
{
command_print(cmd_ctx, "failed loading file %s to pld device %lu",
if ((retval = p->driver->load(p, args[1])) != ERROR_OK)
{
command_print(cmd_ctx, "failed loading file %s to pld device %lu",
- gettimeofday(&end, NULL);
+ gettimeofday(&end, NULL);
timeval_subtract(&duration, &end, &start);
command_print(cmd_ctx, "loaded file %s to pld device %lu in %jis %jius",
args[1], strtoul(args[0], NULL, 0),
(intmax_t)duration.tv_sec, (intmax_t)duration.tv_usec);
}
timeval_subtract(&duration, &end, &start);
command_print(cmd_ctx, "loaded file %s to pld device %lu in %jis %jius",
args[1], strtoul(args[0], NULL, 0),
(intmax_t)duration.tv_sec, (intmax_t)duration.tv_usec);
}
return ERROR_OK;
}
int pld_register_commands(struct command_context_s *cmd_ctx)
{
pld_cmd = register_command(cmd_ctx, NULL, "pld", NULL, COMMAND_ANY, "programmable logic device commands");
return ERROR_OK;
}
int pld_register_commands(struct command_context_s *cmd_ctx)
{
pld_cmd = register_command(cmd_ctx, NULL, "pld", NULL, COMMAND_ANY, "programmable logic device commands");
register_command(cmd_ctx, pld_cmd, "device", handle_pld_device_command, COMMAND_CONFIG, NULL);
register_command(cmd_ctx, pld_cmd, "device", handle_pld_device_command, COMMAND_CONFIG, NULL);
-int virtex2_register_commands(struct command_context_s *cmd_ctx);
-int virtex2_pld_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct pld_device_s *pld_device);
-int virtex2_load(struct pld_device_s *pld_device, char *filename);
+static int virtex2_register_commands(struct command_context_s *cmd_ctx);
+static int virtex2_pld_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct pld_device_s *pld_device);
+static int virtex2_load(struct pld_device_s *pld_device, char *filename);
pld_driver_t virtex2_pld =
{
pld_driver_t virtex2_pld =
{
-int virtex2_set_instr(jtag_tap_t *tap, u32 new_instr)
+static int virtex2_set_instr(jtag_tap_t *tap, u32 new_instr)
return ERROR_FAIL;
if (buf_get_u32(tap->cur_instr, 0, tap->ir_length) != new_instr)
return ERROR_FAIL;
if (buf_get_u32(tap->cur_instr, 0, tap->ir_length) != new_instr)
field.num_bits = tap->ir_length;
field.out_value = calloc(CEIL(field.num_bits, 8), 1);
buf_set_u32(field.out_value, 0, field.num_bits, new_instr);
field.num_bits = tap->ir_length;
field.out_value = calloc(CEIL(field.num_bits, 8), 1);
buf_set_u32(field.out_value, 0, field.num_bits, new_instr);
jtag_add_ir_scan(1, &field, jtag_set_end_state(TAP_IDLE));
free(field.out_value);
jtag_add_ir_scan(1, &field, jtag_set_end_state(TAP_IDLE));
free(field.out_value);
-int virtex2_send_32(struct pld_device_s *pld_device, int num_words, u32 *words)
+static int virtex2_send_32(struct pld_device_s *pld_device,
+ int num_words, u32 *words)
{
virtex2_pld_device_t *virtex2_info = pld_device->driver_priv;
scan_field_t scan_field;
{
virtex2_pld_device_t *virtex2_info = pld_device->driver_priv;
scan_field_t scan_field;
static __inline__ void virtexflip32(u8 *in)
{
static __inline__ void virtexflip32(u8 *in)
{
- *((u32 *)in)=flip_u32(le_to_h_u32(in), 32);
+ *((u32 *)in) = flip_u32(le_to_h_u32(in), 32);
-int virtex2_receive_32(struct pld_device_s *pld_device, int num_words, u32 *words)
+static int virtex2_receive_32(struct pld_device_s *pld_device,
+ int num_words, u32 *words)
{
virtex2_pld_device_t *virtex2_info = pld_device->driver_priv;
scan_field_t scan_field;
{
virtex2_pld_device_t *virtex2_info = pld_device->driver_priv;
scan_field_t scan_field;
while (num_words--)
{
scan_field.in_value = (u8 *)words;
while (num_words--)
{
scan_field.in_value = (u8 *)words;
jtag_add_dr_scan(1, &scan_field, jtag_set_end_state(TAP_DRPAUSE));
jtag_add_callback(virtexflip32, (u8 *)words);
jtag_add_dr_scan(1, &scan_field, jtag_set_end_state(TAP_DRPAUSE));
jtag_add_callback(virtexflip32, (u8 *)words);
-int virtex2_read_stat(struct pld_device_s *pld_device, u32 *status)
+static int virtex2_read_stat(struct pld_device_s *pld_device, u32 *status)
-int virtex2_load(struct pld_device_s *pld_device, char *filename)
+static int virtex2_load(struct pld_device_s *pld_device, char *filename)
{
virtex2_pld_device_t *virtex2_info = pld_device->driver_priv;
xilinx_bit_file_t bit_file;
int retval;
unsigned int i;
{
virtex2_pld_device_t *virtex2_info = pld_device->driver_priv;
xilinx_bit_file_t bit_file;
int retval;
unsigned int i;
scan_field_t field;
field.tap = virtex2_info->tap;
scan_field_t field;
field.tap = virtex2_info->tap;
if ((retval = xilinx_read_bit_file(&bit_file, filename)) != ERROR_OK)
return retval;
if ((retval = xilinx_read_bit_file(&bit_file, filename)) != ERROR_OK)
return retval;
-int virtex2_handle_read_stat_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+static int virtex2_handle_read_stat_command(struct command_context_s *cmd_ctx,
+ char *cmd, char **args, int argc)
{
pld_device_t *device;
virtex2_pld_device_t *virtex2_info;
{
pld_device_t *device;
virtex2_pld_device_t *virtex2_info;
-int virtex2_register_commands(struct command_context_s *cmd_ctx)
+static int virtex2_register_commands(struct command_context_s *cmd_ctx)
{
command_t *virtex2_cmd = register_command(cmd_ctx, NULL, "virtex2", NULL, COMMAND_ANY, "virtex2 specific commands");
{
command_t *virtex2_cmd = register_command(cmd_ctx, NULL, "virtex2", NULL, COMMAND_ANY, "virtex2 specific commands");
-int virtex2_pld_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct pld_device_s *pld_device)
+static int virtex2_pld_device_command(struct command_context_s *cmd_ctx,
+ char *cmd, char **args, int argc, struct pld_device_s *pld_device)
return ERROR_PLD_DEVICE_INVALID;
}
return ERROR_PLD_DEVICE_INVALID;
}
- tap = jtag_tap_by_string( args[1] );
- if( tap == NULL ){
+ tap = jtag_tap_by_string(args[1]);
+ if (tap == NULL) {
command_print( cmd_ctx, "Tap: %s does not exist", args[1] );
return ERROR_OK;
}
command_print( cmd_ctx, "Tap: %s does not exist", args[1] );
return ERROR_OK;
}
-int read_section(FILE *input_file, int length_size, char section, u32 *buffer_length, u8 **buffer)
+static int read_section(FILE *input_file, int length_size, char section,
+ u32 *buffer_length, u8 **buffer)
{
u8 length_buffer[4];
int length;
char section_char;
int read_count;
{
u8 length_buffer[4];
int length;
char section_char;
int read_count;
if ((length_size != 2) && (length_size != 4))
{
LOG_ERROR("BUG: length_size neither 2 nor 4");
if ((length_size != 2) && (length_size != 4))
{
LOG_ERROR("BUG: length_size neither 2 nor 4");
{
return ERROR_PLD_FILE_LOAD_FAILED;
}
{
return ERROR_PLD_FILE_LOAD_FAILED;
}
if (section_char != section)
{
return ERROR_PLD_FILE_LOAD_FAILED;
if (section_char != section)
{
return ERROR_PLD_FILE_LOAD_FAILED;
{
return ERROR_PLD_FILE_LOAD_FAILED;
}
{
return ERROR_PLD_FILE_LOAD_FAILED;
}
if (length_size == 4)
length = be_to_h_u32(length_buffer);
else /* (length_size == 2) */
length = be_to_h_u16(length_buffer);
if (length_size == 4)
length = be_to_h_u32(length_buffer);
else /* (length_size == 2) */
length = be_to_h_u16(length_buffer);
if (buffer_length)
*buffer_length = length;
if (buffer_length)
*buffer_length = length;
*buffer = malloc(length);
*buffer = malloc(length);
if ((read_count = fread(*buffer, 1, length, input_file)) != length)
{
return ERROR_PLD_FILE_LOAD_FAILED;
}
if ((read_count = fread(*buffer, 1, length, input_file)) != length)
{
return ERROR_PLD_FILE_LOAD_FAILED;
}
FILE *input_file;
struct stat input_stat;
int read_count;
FILE *input_file;
struct stat input_stat;
int read_count;
if (!filename || !bit_file)
return ERROR_INVALID_ARGUMENTS;
if (!filename || !bit_file)
return ERROR_INVALID_ARGUMENTS;
if (stat(filename, &input_stat) == -1)
{
LOG_ERROR("couldn't stat() %s: %s", filename, strerror(errno));
if (stat(filename, &input_stat) == -1)
{
LOG_ERROR("couldn't stat() %s: %s", filename, strerror(errno));
LOG_ERROR("%s is a directory", filename);
return ERROR_PLD_FILE_LOAD_FAILED;
}
LOG_ERROR("%s is a directory", filename);
return ERROR_PLD_FILE_LOAD_FAILED;
}
if (input_stat.st_size == 0){
LOG_ERROR("Empty file %s", filename);
return ERROR_PLD_FILE_LOAD_FAILED;
}
if (input_stat.st_size == 0){
LOG_ERROR("Empty file %s", filename);
return ERROR_PLD_FILE_LOAD_FAILED;
}
if (!(input_file = fopen(filename, "rb")))
{
LOG_ERROR("couldn't open %s: %s", filename, strerror(errno));
return ERROR_PLD_FILE_LOAD_FAILED;
}
if (!(input_file = fopen(filename, "rb")))
{
LOG_ERROR("couldn't open %s: %s", filename, strerror(errno));
return ERROR_PLD_FILE_LOAD_FAILED;
}
if ((read_count = fread(bit_file->unknown_header, 1, 13, input_file)) != 13)
{
LOG_ERROR("couldn't read unknown_header from file '%s'", filename);
return ERROR_PLD_FILE_LOAD_FAILED;
}
if ((read_count = fread(bit_file->unknown_header, 1, 13, input_file)) != 13)
{
LOG_ERROR("couldn't read unknown_header from file '%s'", filename);
return ERROR_PLD_FILE_LOAD_FAILED;
}
if (read_section(input_file, 2, 'a', NULL, &bit_file->source_file) != ERROR_OK)
return ERROR_PLD_FILE_LOAD_FAILED;
if (read_section(input_file, 2, 'a', NULL, &bit_file->source_file) != ERROR_OK)
return ERROR_PLD_FILE_LOAD_FAILED;
if (read_section(input_file, 2, 'b', NULL, &bit_file->part_name) != ERROR_OK)
return ERROR_PLD_FILE_LOAD_FAILED;
if (read_section(input_file, 2, 'b', NULL, &bit_file->part_name) != ERROR_OK)
return ERROR_PLD_FILE_LOAD_FAILED;
if (read_section(input_file, 2, 'c', NULL, &bit_file->date) != ERROR_OK)
return ERROR_PLD_FILE_LOAD_FAILED;
if (read_section(input_file, 2, 'c', NULL, &bit_file->date) != ERROR_OK)
return ERROR_PLD_FILE_LOAD_FAILED;
if (read_section(input_file, 4, 'e', &bit_file->length, &bit_file->data) != ERROR_OK)
return ERROR_PLD_FILE_LOAD_FAILED;
if (read_section(input_file, 4, 'e', &bit_file->length, &bit_file->data) != ERROR_OK)
return ERROR_PLD_FILE_LOAD_FAILED;
LOG_DEBUG("bit_file: %s %s %s,%s %i", bit_file->source_file, bit_file->part_name,
bit_file->date, bit_file->time, bit_file->length);
LOG_DEBUG("bit_file: %s %s %s,%s %i", bit_file->source_file, bit_file->part_name,
bit_file->date, bit_file->time, bit_file->length);
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)