if (type != SCAN_OUT)
{
scan_size = jtag_scan_size(cmd->cmd.scan);
- buffer = calloc(CEIL(scan_size, 8), 1);
+ buffer = calloc(DIV_ROUND_UP(scan_size, 8), 1);
ft2232_read_scan(type, buffer, scan_size);
if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
retval = ERROR_JTAG_QUEUE_FAILED;
int bits_left = scan_size;
int cur_byte = 0;
int last_bit;
- uint8_t* receive_buffer = malloc(CEIL(scan_size, 8));
+ uint8_t* receive_buffer = malloc(DIV_ROUND_UP(scan_size, 8));
uint8_t* receive_pointer = receive_buffer;
uint32_t bytes_written;
uint32_t bytes_read;
if (type == SCAN_IN) /* only from device to host */
{
/* complete bytes */
- predicted_size += CEIL(num_bytes, 65536) * 3;
+ predicted_size += DIV_ROUND_UP(num_bytes, 65536) * 3;
/* remaining bits - 1 (up to 7) */
predicted_size += ((scan_size - 1) % 8) ? 2 : 0;
else /* host to device, or bidirectional */
{
/* complete bytes */
- predicted_size += num_bytes + CEIL(num_bytes, 65536) * 3;
+ predicted_size += num_bytes + DIV_ROUND_UP(num_bytes, 65536) * 3;
/* remaining bits -1 (up to 7) */
predicted_size += ((scan_size - 1) % 8) ? 3 : 0;
if (type != SCAN_OUT)
{
/* complete bytes */
- predicted_size += (CEIL(scan_size, 8) > 1) ? (CEIL(scan_size, 8) - 1) : 0;
+ predicted_size += (DIV_ROUND_UP(scan_size, 8) > 1) ? (DIV_ROUND_UP(scan_size, 8) - 1) : 0;
/* remaining bits - 1 */
predicted_size += ((scan_size - 1) % 8) ? 1 : 0;
predicted_size = 0;
if (tap_get_state() != TAP_IDLE)
predicted_size += 3;
- predicted_size += 3 * CEIL(cmd->cmd.runtest->num_cycles, 7);
+ predicted_size += 3 * DIV_ROUND_UP(cmd->cmd.runtest->num_cycles, 7);
if (cmd->cmd.runtest->end_state != TAP_IDLE)
predicted_size += 3;
if (tap_get_end_state() != TAP_IDLE)
tap_state_name(path[num_states-1]));
/* only send the maximum buffer size that FT2232C can handle */
- predicted_size = 3 * CEIL(num_states, 7);
+ predicted_size = 3 * DIV_ROUND_UP(num_states, 7);
if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE)
{
if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
int retval;
retval = ERROR_OK;
- DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
+ DEBUG_JTAG_IO("sleep %" PRIi32, cmd->cmd.sleep->us);
if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK)
retval = ERROR_JTAG_QUEUE_FAILED;
first_unsent = cmd->next;
jtag_sleep(cmd->cmd.sleep->us);
- DEBUG_JTAG_IO("sleep %i usec while in %s",
+ DEBUG_JTAG_IO("sleep %" PRIi32 " usec while in %s",
cmd->cmd.sleep->us,
tap_state_name(tap_get_state()));
return retval;
{
static const char* type_str[] =
{"BM", "AM", "100AX", "UNKNOWN", "2232C", "232R", "2232H", "4232H"};
- unsigned no_of_known_types = sizeof(type_str) / sizeof(type_str[0]) - 1;
+ unsigned no_of_known_types = ARRAY_SIZE(type_str) - 1;
unsigned type_index = ((unsigned)ftdi_device <= no_of_known_types)
? ftdi_device : FT_DEVICE_UNKNOWN;
LOG_INFO("device: %lu \"%s\"", ftdi_device, type_str[type_index]);
ftdi_device = ftdic.type;
static const char* type_str[] =
{"AM", "BM", "2232C", "R", "2232H", "4232H", "Unknown"};
- unsigned no_of_known_types = sizeof(type_str) / sizeof(type_str[0]) - 1;
+ unsigned no_of_known_types = ARRAY_SIZE(type_str) - 1;
unsigned type_index = ((unsigned)ftdi_device < no_of_known_types)
? ftdi_device : no_of_known_types;
LOG_DEBUG("FTDI chip type: %i \"%s\"", (int)ftdi_device, type_str[type_index]);
{
char *cp;
char buf[200];
- if (argc == 1)
+ if (CMD_ARGC == 1)
{
- ft2232_device_desc = strdup(args[0]);
+ ft2232_device_desc = strdup(CMD_ARGV[0]);
cp = strchr(ft2232_device_desc, 0);
/* under Win32, the FTD2XX driver appends an "A" to the end
* of the description, this examines the given desc
COMMAND_HANDLER(ft2232_handle_serial_command)
{
- if (argc == 1)
+ if (CMD_ARGC == 1)
{
- ft2232_serial = strdup(args[0]);
+ ft2232_serial = strdup(CMD_ARGV[0]);
}
else
{
COMMAND_HANDLER(ft2232_handle_layout_command)
{
- if (argc == 0)
+ if (CMD_ARGC == 0)
return ERROR_OK;
- ft2232_layout = malloc(strlen(args[0]) + 1);
- strcpy(ft2232_layout, args[0]);
+ ft2232_layout = malloc(strlen(CMD_ARGV[0]) + 1);
+ strcpy(ft2232_layout, CMD_ARGV[0]);
return ERROR_OK;
}
COMMAND_HANDLER(ft2232_handle_vid_pid_command)
{
- if (argc > MAX_USB_IDS * 2)
+ if (CMD_ARGC > MAX_USB_IDS * 2)
{
LOG_WARNING("ignoring extra IDs in ft2232_vid_pid "
"(maximum is %d pairs)", MAX_USB_IDS);
- argc = MAX_USB_IDS * 2;
+ CMD_ARGC = MAX_USB_IDS * 2;
}
- if (argc < 2 || (argc & 1))
+ if (CMD_ARGC < 2 || (CMD_ARGC & 1))
{
LOG_WARNING("incomplete ft2232_vid_pid configuration directive");
- if (argc < 2)
+ if (CMD_ARGC < 2)
return ERROR_COMMAND_SYNTAX_ERROR;
/* remove the incomplete trailing id */
- argc -= 1;
+ CMD_ARGC -= 1;
}
unsigned i;
- for (i = 0; i < argc; i += 2)
+ for (i = 0; i < CMD_ARGC; i += 2)
{
- COMMAND_PARSE_NUMBER(u16, args[i], ft2232_vid[i >> 1]);
- COMMAND_PARSE_NUMBER(u16, args[i + 1], ft2232_pid[i >> 1]);
+ COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i], ft2232_vid[i >> 1]);
+ COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], ft2232_pid[i >> 1]);
}
/*
COMMAND_HANDLER(ft2232_handle_latency_command)
{
- if (argc == 1)
+ if (CMD_ARGC == 1)
{
- ft2232_latency = atoi(args[0]);
+ ft2232_latency = atoi(CMD_ARGV[0]);
}
else
{
buffer_write(high_direction);
}
-static int ft2232_register_commands(struct command_context_s* cmd_ctx)
-{
- register_command(cmd_ctx, NULL, "ft2232_device_desc",
- ft2232_handle_device_desc_command, COMMAND_CONFIG,
- "the USB device description of the FTDI FT2232 device");
- register_command(cmd_ctx, NULL, "ft2232_serial",
- ft2232_handle_serial_command, COMMAND_CONFIG,
- "the serial number of the FTDI FT2232 device");
- register_command(cmd_ctx, NULL, "ft2232_layout",
- ft2232_handle_layout_command, COMMAND_CONFIG,
- "the layout of the FT2232 GPIO signals used "
- "to control output-enables and reset signals");
- register_command(cmd_ctx, NULL, "ft2232_vid_pid",
- ft2232_handle_vid_pid_command, COMMAND_CONFIG,
- "the vendor ID and product ID of the FTDI FT2232 device");
- register_command(cmd_ctx, NULL, "ft2232_latency",
- ft2232_handle_latency_command, COMMAND_CONFIG,
- "set the FT2232 latency timer to a new value");
-
- return ERROR_OK;
-}
-
+static const struct command_registration ft2232_command_handlers[] = {
+ {
+ .name = "ft2232_device_desc",
+ .handler = &ft2232_handle_device_desc_command,
+ .mode = COMMAND_CONFIG,
+ .help = "set the USB device description of the FTDI FT2232 device",
+ .usage = "<description>",
+ },
+ {
+ .name = "ft2232_serial",
+ .handler = &ft2232_handle_serial_command,
+ .mode = COMMAND_CONFIG,
+ .help = "set the serial number of the FTDI FT2232 device",
+ .usage = "<serial#>",
+ },
+ {
+ .name = "ft2232_layout",
+ .handler = &ft2232_handle_layout_command,
+ .mode = COMMAND_CONFIG,
+ .help = "set the layout of the FT2232 GPIO signals used "
+ "to control output-enables and reset signals",
+ .usage = "<layout>",
+ },
+ {
+ .name = "ft2232_vid_pid",
+ .handler = &ft2232_handle_vid_pid_command,
+ .mode = COMMAND_CONFIG,
+ .help = "the vendor ID and product ID of the FTDI FT2232 device",
+ .usage = "<vid> <pid> [...]",
+ },
+ {
+ .name = "ft2232_latency",
+ .handler = &ft2232_handle_latency_command,
+ .mode = COMMAND_CONFIG,
+ .help = "set the FT2232 latency timer to a new value",
+ .usage = "<vid> <pid> [...]",
+ },
+ COMMAND_REGISTRATION_DONE
+};
struct jtag_interface ft2232_interface = {
.name = "ft2232",
- .register_commands = &ft2232_register_commands,
+ .commands = ft2232_command_handlers,
.init = &ft2232_init,
.quit = &ft2232_quit,
.speed = &ft2232_speed,
Code Review / openocd.git / blobdiff