X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fjtag%2Fcommands.c;h=8d7875af288f8fde79e8137236a4f33df8fce145;hb=efa2068f1a2b1d6e96c9aa4067174787207ff2bc;hp=c9c7cf7f840db8162874033913de7fc0dbd2abb2;hpb=80d66c9fcbe16d1adb42de52ec53901fca9f11ae;p=fw%2Fopenocd diff --git a/src/jtag/commands.c b/src/jtag/commands.c index c9c7cf7f8..8d7875af2 100644 --- a/src/jtag/commands.c +++ b/src/jtag/commands.c @@ -1,3 +1,5 @@ +/* SPDX-License-Identifier: GPL-2.0-or-later */ + /*************************************************************************** * Copyright (C) 2005 by Dominic Rath * * Dominic.Rath@gmx.de * @@ -11,60 +13,61 @@ * * * Copyright (C) 2009 Zachary T Welch * * zw@superlucidity.net * - * * - * This program is free software; you can redistribute it and/or modify * - * it under the terms of the GNU General Public License as published by * - * the Free Software Foundation; either version 2 of the License, or * - * (at your option) any later version. * - * * - * This program is distributed in the hope that it will be useful, * - * but WITHOUT ANY WARRANTY; without even the implied warranty of * - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * - * GNU General Public License for more details. * - * * - * You should have received a copy of the GNU General Public License * - * along with this program; if not, write to the * - * Free Software Foundation, Inc., * - * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ + #ifdef HAVE_CONFIG_H #include "config.h" #endif +#include +#include #include "commands.h" -typedef struct cmd_queue_page_s -{ +struct cmd_queue_page { + struct cmd_queue_page *next; void *address; size_t used; - struct cmd_queue_page_s *next; -} cmd_queue_page_t; +}; #define CMD_QUEUE_PAGE_SIZE (1024 * 1024) -static cmd_queue_page_t *cmd_queue_pages = NULL; +static struct cmd_queue_page *cmd_queue_pages; +static struct cmd_queue_page *cmd_queue_pages_tail; -jtag_command_t *jtag_command_queue = NULL; -static jtag_command_t **next_command_pointer = &jtag_command_queue; +struct jtag_command *jtag_command_queue; +static struct jtag_command **next_command_pointer = &jtag_command_queue; -void jtag_queue_command(jtag_command_t * cmd) +void jtag_queue_command(struct jtag_command *cmd) { - // this command goes on the end, so ensure the queue terminates + if (!transport_is_jtag()) { + /* + * FIXME: This should not happen! + * There could be old code that queues jtag commands with non jtag interfaces so, for + * the moment simply highlight it by log an error. + * We should fix it quitting with assert(0) because it is an internal error, or returning + * an error after call to jtag_command_queue_reset() to free the jtag queue and avoid + * memory leaks. + * The fix can be applied immediately after next release (v0.11.0 ?) + */ + LOG_ERROR("JTAG API jtag_queue_command() called on non JTAG interface"); + } + + /* this command goes on the end, so ensure the queue terminates */ cmd->next = NULL; - jtag_command_t **last_cmd = next_command_pointer; - assert(NULL != last_cmd); - assert(NULL == *last_cmd); + struct jtag_command **last_cmd = next_command_pointer; + assert(last_cmd); + assert(!*last_cmd); *last_cmd = cmd; - // store location where the next command pointer will be stored + /* store location where the next command pointer will be stored */ next_command_pointer = &cmd->next; } -void* cmd_queue_alloc(size_t size) +void *cmd_queue_alloc(size_t size) { - cmd_queue_page_t **p_page = &cmd_queue_pages; + struct cmd_queue_page **p_page = &cmd_queue_pages; int offset; - u8 *t; + uint8_t *t; /* * WARNING: @@ -95,45 +98,45 @@ void* cmd_queue_alloc(size_t size) #define ALIGN_SIZE (sizeof(union worse_case_align)) /* The alignment process. */ - size = (size + ALIGN_SIZE -1) & (~(ALIGN_SIZE-1)); + size = (size + ALIGN_SIZE - 1) & (~(ALIGN_SIZE - 1)); /* Done... */ - if (*p_page) - { - while ((*p_page)->next) - p_page = &((*p_page)->next); + if (*p_page) { + p_page = &cmd_queue_pages_tail; if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size) p_page = &((*p_page)->next); } - if (!*p_page) - { - *p_page = malloc(sizeof(cmd_queue_page_t)); + if (!*p_page) { + *p_page = malloc(sizeof(struct cmd_queue_page)); (*p_page)->used = 0; - (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE); + size_t alloc_size = (size < CMD_QUEUE_PAGE_SIZE) ? + CMD_QUEUE_PAGE_SIZE : size; + (*p_page)->address = malloc(alloc_size); (*p_page)->next = NULL; + cmd_queue_pages_tail = *p_page; } offset = (*p_page)->used; (*p_page)->used += size; - t=(u8 *)((*p_page)->address); + t = (*p_page)->address; return t + offset; } -void cmd_queue_free(void) +static void cmd_queue_free(void) { - cmd_queue_page_t *page = cmd_queue_pages; + struct cmd_queue_page *page = cmd_queue_pages; - while (page) - { - cmd_queue_page_t *last = page; + while (page) { + struct cmd_queue_page *last = page; free(page->address); page = page->next; free(last); } cmd_queue_pages = NULL; + cmd_queue_pages_tail = NULL; } void jtag_command_queue_reset(void) @@ -144,13 +147,24 @@ void jtag_command_queue_reset(void) next_command_pointer = &jtag_command_queue; } -enum scan_type jtag_scan_type(const scan_command_t *cmd) +/** + * Copy a struct scan_field for insertion into the queue. + * + * This allocates a new copy of out_value using cmd_queue_alloc. + */ +void jtag_scan_field_clone(struct scan_field *dst, const struct scan_field *src) +{ + dst->num_bits = src->num_bits; + dst->out_value = buf_cpy(src->out_value, cmd_queue_alloc(DIV_ROUND_UP(src->num_bits, 8)), src->num_bits); + dst->in_value = src->in_value; +} + +enum scan_type jtag_scan_type(const struct scan_command *cmd) { int i; int type = 0; - for (i = 0; i < cmd->num_fields; i++) - { + for (i = 0; i < cmd->num_fields; i++) { if (cmd->fields[i].in_value) type |= SCAN_IN; if (cmd->fields[i].out_value) @@ -160,65 +174,60 @@ enum scan_type jtag_scan_type(const scan_command_t *cmd) return type; } -int jtag_scan_size(const scan_command_t *cmd) +int jtag_scan_size(const struct scan_command *cmd) { int bit_count = 0; int i; /* count bits in scan command */ for (i = 0; i < cmd->num_fields; i++) - { bit_count += cmd->fields[i].num_bits; - } return bit_count; } -int jtag_build_buffer(const scan_command_t *cmd, u8 **buffer) +int jtag_build_buffer(const struct scan_command *cmd, uint8_t **buffer) { int bit_count = 0; int i; bit_count = jtag_scan_size(cmd); - *buffer = calloc(1,CEIL(bit_count, 8)); + *buffer = calloc(1, DIV_ROUND_UP(bit_count, 8)); bit_count = 0; -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("%s num_fields: %i", cmd->ir_scan ? "IRSCAN" : "DRSCAN", cmd->num_fields); -#endif - - for (i = 0; i < cmd->num_fields; i++) - { - if (cmd->fields[i].out_value) - { -#ifdef _DEBUG_JTAG_IO_ - char* char_buf = buf_to_str(cmd->fields[i].out_value, (cmd->fields[i].num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : cmd->fields[i].num_bits, 16); -#endif - buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits); -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i, cmd->fields[i].num_bits, char_buf); - free(char_buf); -#endif - } - else - { -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("fields[%i].out_value[%i]: NULL", i, cmd->fields[i].num_bits); -#endif + LOG_DEBUG_IO("%s num_fields: %i", + cmd->ir_scan ? "IRSCAN" : "DRSCAN", + cmd->num_fields); + + for (i = 0; i < cmd->num_fields; i++) { + if (cmd->fields[i].out_value) { + if (LOG_LEVEL_IS(LOG_LVL_DEBUG_IO)) { + char *char_buf = buf_to_hex_str(cmd->fields[i].out_value, + (cmd->fields[i].num_bits > DEBUG_JTAG_IOZ) + ? DEBUG_JTAG_IOZ + : cmd->fields[i].num_bits); + + LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i, + cmd->fields[i].num_bits, char_buf); + free(char_buf); + } + buf_set_buf(cmd->fields[i].out_value, 0, *buffer, + bit_count, cmd->fields[i].num_bits); + } else { + LOG_DEBUG_IO("fields[%i].out_value[%i]: NULL", + i, cmd->fields[i].num_bits); } bit_count += cmd->fields[i].num_bits; } -#ifdef _DEBUG_JTAG_IO_ - //LOG_DEBUG("bit_count totalling: %i", bit_count ); -#endif + /*LOG_DEBUG_IO("bit_count totalling: %i", bit_count); */ return bit_count; } -int jtag_read_buffer(u8 *buffer, const scan_command_t *cmd) +int jtag_read_buffer(uint8_t *buffer, const struct scan_command *cmd) { int i; int bit_count = 0; @@ -227,26 +236,28 @@ int jtag_read_buffer(u8 *buffer, const scan_command_t *cmd) /* we return ERROR_OK, unless a check fails, or a handler reports a problem */ retval = ERROR_OK; - for (i = 0; i < cmd->num_fields; i++) - { + for (i = 0; i < cmd->num_fields; i++) { /* if neither in_value nor in_handler * are specified we don't have to examine this field */ - if (cmd->fields[i].in_value) - { + if (cmd->fields[i].in_value) { int num_bits = cmd->fields[i].num_bits; - u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits); - -#ifdef _DEBUG_JTAG_IO_ - char *char_buf = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16); - LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i, num_bits, char_buf); - free(char_buf); -#endif + uint8_t *captured = buf_set_buf(buffer, bit_count, + malloc(DIV_ROUND_UP(num_bits, 8)), 0, num_bits); + + if (LOG_LEVEL_IS(LOG_LVL_DEBUG_IO)) { + char *char_buf = buf_to_hex_str(captured, + (num_bits > DEBUG_JTAG_IOZ) + ? DEBUG_JTAG_IOZ + : num_bits); + + LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", + i, num_bits, char_buf); + free(char_buf); + } if (cmd->fields[i].in_value) - { buf_cpy(captured, cmd->fields[i].in_value, num_bits); - } free(captured); } @@ -255,5 +266,3 @@ int jtag_read_buffer(u8 *buffer, const scan_command_t *cmd) return retval; } - -