diff options
Diffstat (limited to 'src')
166 files changed, 2714 insertions, 4407 deletions
diff --git a/src/flash/Makefile.am b/src/flash/Makefile.am index a1b46f8..4c70702 100644 --- a/src/flash/Makefile.am +++ b/src/flash/Makefile.am @@ -1,7 +1,6 @@ noinst_LTLIBRARIES += %D%/libflash.la %C%_libflash_la_SOURCES = \ - %D%/common.c %D%/common.h \ - %D%/mflash.c %D%/mflash.h + %D%/common.c %D%/common.h %C%_libflash_la_LIBADD = \ %D%/nor/libocdflashnor.la \ diff --git a/src/flash/mflash.c b/src/flash/mflash.c deleted file mode 100644 index 4c95d21..0000000 --- a/src/flash/mflash.c +++ /dev/null @@ -1,1449 +0,0 @@ -/*************************************************************************** - * Copyright (C) 2007-2008 by unsik Kim <donari75@gmail.com> * - * * - * 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, see <http://www.gnu.org/licenses/>. * - ***************************************************************************/ - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#include "mflash.h" -#include <target/target.h> -#include <helper/time_support.h> -#include <helper/fileio.h> -#include <helper/log.h> - -static int s3c2440_set_gpio_to_output(struct mflash_gpio_num gpio); -static int s3c2440_set_gpio_output_val(struct mflash_gpio_num gpio, uint8_t val); -static int pxa270_set_gpio_to_output(struct mflash_gpio_num gpio); -static int pxa270_set_gpio_output_val(struct mflash_gpio_num gpio, uint8_t val); - -static struct mflash_bank *mflash_bank; - -static struct mflash_gpio_drv pxa270_gpio = { - .name = "pxa270", - .set_gpio_to_output = pxa270_set_gpio_to_output, - .set_gpio_output_val = pxa270_set_gpio_output_val -}; - -static struct mflash_gpio_drv s3c2440_gpio = { - .name = "s3c2440", - .set_gpio_to_output = s3c2440_set_gpio_to_output, - .set_gpio_output_val = s3c2440_set_gpio_output_val -}; - -static struct mflash_gpio_drv *mflash_gpio[] = { - &pxa270_gpio, - &s3c2440_gpio, - NULL -}; - -#define PXA270_GAFR0_L 0x40E00054 -#define PXA270_GAFR3_U 0x40E00070 -#define PXA270_GAFR3_U_RESERVED_BITS 0xfffc0000u -#define PXA270_GPDR0 0x40E0000C -#define PXA270_GPDR3 0x40E0010C -#define PXA270_GPDR3_RESERVED_BITS 0xfe000000u -#define PXA270_GPSR0 0x40E00018 -#define PXA270_GPCR0 0x40E00024 - -static int pxa270_set_gpio_to_output(struct mflash_gpio_num gpio) -{ - uint32_t addr, value, mask; - struct target *target = mflash_bank->target; - int ret; - - /* remove alternate function. */ - mask = 0x3u << (gpio.num & 0xF)*2; - - addr = PXA270_GAFR0_L + (gpio.num >> 4) * 4; - - ret = target_read_u32(target, addr, &value); - if (ret != ERROR_OK) - return ret; - - value &= ~mask; - if (addr == PXA270_GAFR3_U) - value &= ~PXA270_GAFR3_U_RESERVED_BITS; - - ret = target_write_u32(target, addr, value); - if (ret != ERROR_OK) - return ret; - - /* set direction to output */ - mask = 0x1u << (gpio.num & 0x1F); - - addr = PXA270_GPDR0 + (gpio.num >> 5) * 4; - - ret = target_read_u32(target, addr, &value); - if (ret != ERROR_OK) - return ret; - - value |= mask; - if (addr == PXA270_GPDR3) - value &= ~PXA270_GPDR3_RESERVED_BITS; - - ret = target_write_u32(target, addr, value); - return ret; -} - -static int pxa270_set_gpio_output_val(struct mflash_gpio_num gpio, uint8_t val) -{ - uint32_t addr, value, mask; - struct target *target = mflash_bank->target; - int ret; - - mask = 0x1u << (gpio.num & 0x1F); - - if (val) - addr = PXA270_GPSR0 + (gpio.num >> 5) * 4; - else - addr = PXA270_GPCR0 + (gpio.num >> 5) * 4; - - ret = target_read_u32(target, addr, &value); - if (ret != ERROR_OK) - return ret; - - value |= mask; - - ret = target_write_u32(target, addr, value); - - return ret; -} - -#define S3C2440_GPACON 0x56000000 -#define S3C2440_GPADAT 0x56000004 -#define S3C2440_GPJCON 0x560000d0 -#define S3C2440_GPJDAT 0x560000d4 - -static int s3c2440_set_gpio_to_output(struct mflash_gpio_num gpio) -{ - uint32_t data, mask, gpio_con; - struct target *target = mflash_bank->target; - int ret; - - if (gpio.port[0] >= 'a' && gpio.port[0] <= 'h') - gpio_con = S3C2440_GPACON + (gpio.port[0] - 'a') * 0x10; - else if (gpio.port[0] == 'j') - gpio_con = S3C2440_GPJCON; - else { - LOG_ERROR("mflash: invalid port %d%s", gpio.num, gpio.port); - return ERROR_COMMAND_SYNTAX_ERROR; - } - - ret = target_read_u32(target, gpio_con, &data); - - if (ret == ERROR_OK) { - if (gpio.port[0] == 'a') { - mask = 1 << gpio.num; - data &= ~mask; - } else { - mask = 3 << gpio.num * 2; - data &= ~mask; - data |= (1 << gpio.num * 2); - } - - ret = target_write_u32(target, gpio_con, data); - } - return ret; -} - -static int s3c2440_set_gpio_output_val(struct mflash_gpio_num gpio, uint8_t val) -{ - uint32_t data, mask, gpio_dat; - struct target *target = mflash_bank->target; - int ret; - - if (gpio.port[0] >= 'a' && gpio.port[0] <= 'h') - gpio_dat = S3C2440_GPADAT + (gpio.port[0] - 'a') * 0x10; - else if (gpio.port[0] == 'j') - gpio_dat = S3C2440_GPJDAT; - else { - LOG_ERROR("mflash: invalid port %d%s", gpio.num, gpio.port); - return ERROR_COMMAND_SYNTAX_ERROR; - } - - ret = target_read_u32(target, gpio_dat, &data); - - if (ret == ERROR_OK) { - mask = 1 << gpio.num; - if (val) - data |= mask; - else - data &= ~mask; - - ret = target_write_u32(target, gpio_dat, data); - } - return ret; -} - -static int mg_hdrst(uint8_t level) -{ - return mflash_bank->gpio_drv->set_gpio_output_val(mflash_bank->rst_pin, level); -} - -static int mg_init_gpio(void) -{ - int ret; - struct mflash_gpio_drv *gpio_drv = mflash_bank->gpio_drv; - - ret = gpio_drv->set_gpio_to_output(mflash_bank->rst_pin); - if (ret != ERROR_OK) - return ret; - - ret = gpio_drv->set_gpio_output_val(mflash_bank->rst_pin, 1); - - return ret; -} - -static int mg_dsk_wait(mg_io_type_wait wait_local, uint32_t time_var) -{ - uint8_t status, error; - struct target *target = mflash_bank->target; - uint32_t mg_task_reg = mflash_bank->base + MG_REG_OFFSET; - int ret; - long long t = 0; - - struct duration bench; - duration_start(&bench); - - while (time_var) { - - ret = target_read_u8(target, mg_task_reg + MG_REG_STATUS, &status); - if (ret != ERROR_OK) - return ret; - - if (status & mg_io_rbit_status_busy) { - if (wait_local == mg_io_wait_bsy) - return ERROR_OK; - } else { - switch (wait_local) { - case mg_io_wait_not_bsy: - return ERROR_OK; - case mg_io_wait_rdy_noerr: - if (status & mg_io_rbit_status_ready) - return ERROR_OK; - break; - case mg_io_wait_drq_noerr: - if (status & mg_io_rbit_status_data_req) - return ERROR_OK; - break; - default: - break; - } - - /* Now we check the error condition! */ - if (status & mg_io_rbit_status_error) { - ret = target_read_u8(target, mg_task_reg + MG_REG_ERROR, &error); - if (ret != ERROR_OK) - return ret; - - LOG_ERROR("mflash: io error 0x%02x", error); - - return ERROR_MG_IO; - } - - switch (wait_local) { - case mg_io_wait_rdy: - if (status & mg_io_rbit_status_ready) - return ERROR_OK; - /* fallthrough */ - case mg_io_wait_drq: - if (status & mg_io_rbit_status_data_req) - return ERROR_OK; - /* fallthrough */ - default: - break; - } - } - - ret = duration_measure(&bench); - if (ERROR_OK == ret) - t = duration_elapsed(&bench) * 1000.0; - else - LOG_ERROR("mflash: duration measurement failed: %d", ret); - - if (t > time_var) - break; - } - - LOG_ERROR("mflash: timeout occured"); - return ERROR_MG_TIMEOUT; -} - -static int mg_dsk_srst(uint8_t on) -{ - struct target *target = mflash_bank->target; - uint32_t mg_task_reg = mflash_bank->base + MG_REG_OFFSET; - uint8_t value; - int ret; - - ret = target_read_u8(target, mg_task_reg + MG_REG_DRV_CTRL, &value); - if (ret != ERROR_OK) - return ret; - - if (on) - value |= (mg_io_rbit_devc_srst); - else - value &= ~mg_io_rbit_devc_srst; - - ret = target_write_u8(target, mg_task_reg + MG_REG_DRV_CTRL, value); - return ret; -} - -static int mg_dsk_io_cmd(uint32_t sect_num, uint32_t cnt, uint8_t cmd) -{ - struct target *target = mflash_bank->target; - uint32_t mg_task_reg = mflash_bank->base + MG_REG_OFFSET; - uint8_t value; - int ret; - - ret = mg_dsk_wait(mg_io_wait_rdy_noerr, MG_OEM_DISK_WAIT_TIME_NORMAL); - if (ret != ERROR_OK) - return ret; - - value = mg_io_rval_dev_drv_master | mg_io_rval_dev_lba_mode | ((sect_num >> 24) & 0xf); - - ret = target_write_u8(target, mg_task_reg + MG_REG_DRV_HEAD, value); - ret |= target_write_u8(target, mg_task_reg + MG_REG_SECT_CNT, (uint8_t)cnt); - ret |= target_write_u8(target, mg_task_reg + MG_REG_SECT_NUM, (uint8_t)sect_num); - ret |= target_write_u8(target, mg_task_reg + MG_REG_CYL_LOW, (uint8_t)(sect_num >> 8)); - ret |= target_write_u8(target, mg_task_reg + MG_REG_CYL_HIGH, (uint8_t)(sect_num >> 16)); - - if (ret != ERROR_OK) - return ret; - - return target_write_u8(target, mg_task_reg + MG_REG_COMMAND, cmd); -} - -static int mg_dsk_drv_info(void) -{ - struct target *target = mflash_bank->target; - uint32_t mg_buff = mflash_bank->base + MG_BUFFER_OFFSET; - int ret; - - ret = mg_dsk_io_cmd(0, 1, mg_io_cmd_identify); - if (ret != ERROR_OK) - return ret; - - ret = mg_dsk_wait(mg_io_wait_drq, MG_OEM_DISK_WAIT_TIME_NORMAL); - if (ret != ERROR_OK) - return ret; - - LOG_INFO("mflash: read drive info"); - - if (!mflash_bank->drv_info) - mflash_bank->drv_info = malloc(sizeof(struct mg_drv_info)); - - ret = target_read_memory(target, mg_buff, 2, - sizeof(mg_io_type_drv_info) >> 1, - (uint8_t *)&mflash_bank->drv_info->drv_id); - if (ret != ERROR_OK) - return ret; - - mflash_bank->drv_info->tot_sects = - (uint32_t)(mflash_bank->drv_info->drv_id.total_user_addressable_sectors_hi << 16) - + mflash_bank->drv_info->drv_id.total_user_addressable_sectors_lo; - - return target_write_u8(target, - mflash_bank->base + MG_REG_OFFSET + MG_REG_COMMAND, - mg_io_cmd_confirm_read); -} - -static int mg_mflash_rst(void) -{ - int ret; - - ret = mg_init_gpio(); - if (ret != ERROR_OK) - return ret; - - ret = mg_hdrst(0); - if (ret != ERROR_OK) - return ret; - - ret = mg_dsk_wait(mg_io_wait_bsy, MG_OEM_DISK_WAIT_TIME_LONG); - if (ret != ERROR_OK) - return ret; - - ret = mg_hdrst(1); - if (ret != ERROR_OK) - return ret; - - ret = mg_dsk_wait(mg_io_wait_not_bsy, MG_OEM_DISK_WAIT_TIME_LONG); - if (ret != ERROR_OK) - return ret; - - ret = mg_dsk_srst(1); - if (ret != ERROR_OK) - return ret; - - ret = mg_dsk_wait(mg_io_wait_bsy, MG_OEM_DISK_WAIT_TIME_LONG); - if (ret != ERROR_OK) - return ret; - - ret = mg_dsk_srst(0); - if (ret != ERROR_OK) - return ret; - - ret = mg_dsk_wait(mg_io_wait_not_bsy, MG_OEM_DISK_WAIT_TIME_LONG); - if (ret != ERROR_OK) - return ret; - - LOG_INFO("mflash: reset ok"); - - return ERROR_OK; -} - -static int mg_mflash_probe(void) -{ - int ret = mg_mflash_rst(); - if (ret != ERROR_OK) - return ret; - - return mg_dsk_drv_info(); -} - -COMMAND_HANDLER(mg_probe_cmd) -{ - int ret; - - ret = mg_mflash_probe(); - - if (ret == ERROR_OK) { - command_print(CMD_CTX, - "mflash (total %" PRIu32 " sectors) found at 0x%8.8" PRIx32 "", - mflash_bank->drv_info->tot_sects, - mflash_bank->base); - } - - return ret; -} - -static int mg_mflash_do_read_sects(void *buff, uint32_t sect_num, uint32_t sect_cnt) -{ - uint32_t i, address; - int ret; - struct target *target = mflash_bank->target; - uint8_t *buff_ptr = buff; - - ret = mg_dsk_io_cmd(sect_num, sect_cnt, mg_io_cmd_read); - if (ret != ERROR_OK) - return ret; - - address = mflash_bank->base + MG_BUFFER_OFFSET; - - struct duration bench; - duration_start(&bench); - - for (i = 0; i < sect_cnt; i++) { - ret = mg_dsk_wait(mg_io_wait_drq, MG_OEM_DISK_WAIT_TIME_NORMAL); - if (ret != ERROR_OK) - return ret; - - ret = target_read_memory(target, address, 2, MG_MFLASH_SECTOR_SIZE / 2, buff_ptr); - if (ret != ERROR_OK) - return ret; - - buff_ptr += MG_MFLASH_SECTOR_SIZE; - - ret = target_write_u8(target, - mflash_bank->base + MG_REG_OFFSET + MG_REG_COMMAND, - mg_io_cmd_confirm_read); - if (ret != ERROR_OK) - return ret; - - LOG_DEBUG("mflash: %" PRIu32 " (0x%8.8" PRIx32 ") sector read", sect_num + i, - (sect_num + i) * MG_MFLASH_SECTOR_SIZE); - - ret = duration_measure(&bench); - if ((ERROR_OK == ret) && (duration_elapsed(&bench) > 3)) { - LOG_INFO("mflash: read %" PRIu32 "'th sectors", sect_num + i); - duration_start(&bench); - } - } - - return mg_dsk_wait(mg_io_wait_rdy, MG_OEM_DISK_WAIT_TIME_NORMAL); -} - -static int mg_mflash_read_sects(void *buff, uint32_t sect_num, uint32_t sect_cnt) -{ - uint32_t quotient, residue, i; - uint8_t *buff_ptr = buff; - int ret = ERROR_OK; - - quotient = sect_cnt >> 8; - residue = sect_cnt % 256; - - for (i = 0; i < quotient; i++) { - LOG_DEBUG("mflash: sect num : %" PRIu32 " buff : %p", - sect_num, buff_ptr); - ret = mg_mflash_do_read_sects(buff_ptr, sect_num, 256); - if (ret != ERROR_OK) - return ret; - - sect_num += 256; - buff_ptr += 256 * MG_MFLASH_SECTOR_SIZE; - } - - if (residue) { - LOG_DEBUG("mflash: sect num : %" PRIx32 " buff : %p", - sect_num, buff_ptr); - return mg_mflash_do_read_sects(buff_ptr, sect_num, residue); - } - - return ret; -} - -static int mg_mflash_do_write_sects(void *buff, uint32_t sect_num, uint32_t sect_cnt, - uint8_t cmd) -{ - uint32_t i, address; - int ret; - struct target *target = mflash_bank->target; - uint8_t *buff_ptr = buff; - - ret = mg_dsk_io_cmd(sect_num, sect_cnt, cmd); - if (ret != ERROR_OK) - return ret; - - address = mflash_bank->base + MG_BUFFER_OFFSET; - - struct duration bench; - duration_start(&bench); - - for (i = 0; i < sect_cnt; i++) { - ret = mg_dsk_wait(mg_io_wait_drq, MG_OEM_DISK_WAIT_TIME_NORMAL); - if (ret != ERROR_OK) - return ret; - - ret = target_write_memory(target, address, 2, MG_MFLASH_SECTOR_SIZE / 2, buff_ptr); - if (ret != ERROR_OK) - return ret; - - buff_ptr += MG_MFLASH_SECTOR_SIZE; - - ret = target_write_u8(target, - mflash_bank->base + MG_REG_OFFSET + MG_REG_COMMAND, - mg_io_cmd_confirm_write); - if (ret != ERROR_OK) - return ret; - - LOG_DEBUG("mflash: %" PRIu32 " (0x%8.8" PRIx32 ") sector write", sect_num + i, - (sect_num + i) * MG_MFLASH_SECTOR_SIZE); - - ret = duration_measure(&bench); - if ((ERROR_OK == ret) && (duration_elapsed(&bench) > 3)) { - LOG_INFO("mflash: wrote %" PRIu32 "'th sectors", sect_num + i); - duration_start(&bench); - } - } - - if (cmd == mg_io_cmd_write) - ret = mg_dsk_wait(mg_io_wait_rdy, MG_OEM_DISK_WAIT_TIME_NORMAL); - else - ret = mg_dsk_wait(mg_io_wait_rdy, MG_OEM_DISK_WAIT_TIME_LONG); - - return ret; -} - -static int mg_mflash_write_sects(void *buff, uint32_t sect_num, uint32_t sect_cnt) -{ - uint32_t quotient, residue, i; - uint8_t *buff_ptr = buff; - int ret = ERROR_OK; - - quotient = sect_cnt >> 8; - residue = sect_cnt % 256; - - for (i = 0; i < quotient; i++) { - LOG_DEBUG("mflash: sect num : %" PRIu32 "buff : %p", sect_num, - buff_ptr); - ret = mg_mflash_do_write_sects(buff_ptr, sect_num, 256, mg_io_cmd_write); - if (ret != ERROR_OK) - return ret; - - sect_num += 256; - buff_ptr += 256 * MG_MFLASH_SECTOR_SIZE; - } - - if (residue) { - LOG_DEBUG("mflash: sect num : %" PRIu32 " buff : %p", sect_num, - buff_ptr); - return mg_mflash_do_write_sects(buff_ptr, sect_num, residue, mg_io_cmd_write); - } - - return ret; -} - -static int mg_mflash_read(uint32_t addr, uint8_t *buff, uint32_t len) -{ - uint8_t *buff_ptr = buff; - uint8_t sect_buff[MG_MFLASH_SECTOR_SIZE]; - uint32_t cur_addr, next_sec_addr, end_addr, cnt, sect_num; - int ret = ERROR_OK; - - cnt = 0; - cur_addr = addr; - end_addr = addr + len; - - if (cur_addr & MG_MFLASH_SECTOR_SIZE_MASK) { - - next_sec_addr = (cur_addr + MG_MFLASH_SECTOR_SIZE) & ~MG_MFLASH_SECTOR_SIZE_MASK; - sect_num = cur_addr >> MG_MFLASH_SECTOR_SIZE_SHIFT; - ret = mg_mflash_read_sects(sect_buff, sect_num, 1); - if (ret != ERROR_OK) - return ret; - - if (end_addr < next_sec_addr) { - memcpy(buff_ptr, - sect_buff + (cur_addr & MG_MFLASH_SECTOR_SIZE_MASK), - end_addr - cur_addr); - LOG_DEBUG( - "mflash: copies %" PRIu32 " byte from sector offset 0x%8.8" PRIx32 "", - end_addr - cur_addr, - cur_addr); - cur_addr = end_addr; - } else { - memcpy(buff_ptr, - sect_buff + (cur_addr & MG_MFLASH_SECTOR_SIZE_MASK), - next_sec_addr - cur_addr); - LOG_DEBUG( - "mflash: copies %" PRIu32 " byte from sector offset 0x%8.8" PRIx32 "", - next_sec_addr - cur_addr, - cur_addr); - buff_ptr += (next_sec_addr - cur_addr); - cur_addr = next_sec_addr; - } - } - - if (cur_addr < end_addr) { - - sect_num = cur_addr >> MG_MFLASH_SECTOR_SIZE_SHIFT; - next_sec_addr = cur_addr + MG_MFLASH_SECTOR_SIZE; - - while (next_sec_addr <= end_addr) { - cnt++; - next_sec_addr += MG_MFLASH_SECTOR_SIZE; - } - - if (cnt) { - ret = mg_mflash_read_sects(buff_ptr, sect_num, cnt); - if (ret != ERROR_OK) - return ret; - } - - buff_ptr += cnt * MG_MFLASH_SECTOR_SIZE; - cur_addr += cnt * MG_MFLASH_SECTOR_SIZE; - - if (cur_addr < end_addr) { - - sect_num = cur_addr >> MG_MFLASH_SECTOR_SIZE_SHIFT; - ret = mg_mflash_read_sects(sect_buff, sect_num, 1); - if (ret != ERROR_OK) - return ret; - - memcpy(buff_ptr, sect_buff, end_addr - cur_addr); - LOG_DEBUG("mflash: copies %u byte", (unsigned)(end_addr - cur_addr)); - } - } - - return ret; -} - -static int mg_mflash_write(uint32_t addr, uint8_t *buff, uint32_t len) -{ - uint8_t *buff_ptr = buff; - uint8_t sect_buff[MG_MFLASH_SECTOR_SIZE]; - uint32_t cur_addr, next_sec_addr, end_addr, cnt, sect_num; - int ret = ERROR_OK; - - cnt = 0; - cur_addr = addr; - end_addr = addr + len; - - if (cur_addr & MG_MFLASH_SECTOR_SIZE_MASK) { - - next_sec_addr = (cur_addr + MG_MFLASH_SECTOR_SIZE) & ~MG_MFLASH_SECTOR_SIZE_MASK; - sect_num = cur_addr >> MG_MFLASH_SECTOR_SIZE_SHIFT; - ret = mg_mflash_read_sects(sect_buff, sect_num, 1); - if (ret != ERROR_OK) - return ret; - - if (end_addr < next_sec_addr) { - memcpy(sect_buff + (cur_addr & MG_MFLASH_SECTOR_SIZE_MASK), - buff_ptr, - end_addr - cur_addr); - LOG_DEBUG( - "mflash: copies %" PRIu32 " byte to sector offset 0x%8.8" PRIx32 "", - end_addr - cur_addr, - cur_addr); - cur_addr = end_addr; - } else { - memcpy(sect_buff + (cur_addr & MG_MFLASH_SECTOR_SIZE_MASK), - buff_ptr, - next_sec_addr - cur_addr); - LOG_DEBUG( - "mflash: copies %" PRIu32 " byte to sector offset 0x%8.8" PRIx32 "", - next_sec_addr - cur_addr, - cur_addr); - buff_ptr += (next_sec_addr - cur_addr); - cur_addr = next_sec_addr; - } - - ret = mg_mflash_write_sects(sect_buff, sect_num, 1); - if (ret != ERROR_OK) - return ret; - } - - if (cur_addr < end_addr) { - - sect_num = cur_addr >> MG_MFLASH_SECTOR_SIZE_SHIFT; - next_sec_addr = cur_addr + MG_MFLASH_SECTOR_SIZE; - - while (next_sec_addr <= end_addr) { - cnt++; - next_sec_addr += MG_MFLASH_SECTOR_SIZE; - } - - if (cnt) { - ret = mg_mflash_write_sects(buff_ptr, sect_num, cnt); - if (ret != ERROR_OK) - return ret; - } - - buff_ptr += cnt * MG_MFLASH_SECTOR_SIZE; - cur_addr += cnt * MG_MFLASH_SECTOR_SIZE; - - if (cur_addr < end_addr) { - - sect_num = cur_addr >> MG_MFLASH_SECTOR_SIZE_SHIFT; - ret = mg_mflash_read_sects(sect_buff, sect_num, 1); - if (ret != ERROR_OK) - return ret; - - memcpy(sect_buff, buff_ptr, end_addr - cur_addr); - LOG_DEBUG("mflash: copies %" PRIu32 " byte", end_addr - cur_addr); - ret = mg_mflash_write_sects(sect_buff, sect_num, 1); - } - } - - return ret; -} - -COMMAND_HANDLER(mg_write_cmd) -{ - uint32_t address, cnt, res, i; - uint8_t *buffer; - struct fileio *fileio; - int ret; - - if (CMD_ARGC != 3) - return ERROR_COMMAND_SYNTAX_ERROR; - - COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], address); - - ret = fileio_open(&fileio, CMD_ARGV[1], FILEIO_READ, FILEIO_BINARY); - if (ret != ERROR_OK) - return ret; - - size_t filesize; - buffer = malloc(MG_FILEIO_CHUNK); - if (!buffer) { - fileio_close(fileio); - return ERROR_FAIL; - } - int retval = fileio_size(fileio, &filesize); - if (retval != ERROR_OK) { - fileio_close(fileio); - free(buffer); - return retval; - } - - cnt = filesize / MG_FILEIO_CHUNK; - res = filesize % MG_FILEIO_CHUNK; - - struct duration bench; - duration_start(&bench); - - size_t buf_cnt; - for (i = 0; i < cnt; i++) { - ret = fileio_read(fileio, MG_FILEIO_CHUNK, buffer, &buf_cnt); - if (ret != ERROR_OK) - goto mg_write_cmd_err; - ret = mg_mflash_write(address, buffer, MG_FILEIO_CHUNK); - if (ret != ERROR_OK) - goto mg_write_cmd_err; - address += MG_FILEIO_CHUNK; - } - - if (res) { - ret = fileio_read(fileio, res, buffer, &buf_cnt); - if (ret != ERROR_OK) - goto mg_write_cmd_err; - ret = mg_mflash_write(address, buffer, res); - if (ret != ERROR_OK) - goto mg_write_cmd_err; - } - - if (duration_measure(&bench) == ERROR_OK) { - command_print(CMD_CTX, "wrote %zu bytes from file %s " - "in %fs (%0.3f kB/s)", filesize, CMD_ARGV[1], - duration_elapsed(&bench), duration_kbps(&bench, filesize)); - } - - free(buffer); - fileio_close(fileio); - - return ERROR_OK; - -mg_write_cmd_err: - free(buffer); - fileio_close(fileio); - - return ret; -} - -COMMAND_HANDLER(mg_dump_cmd) -{ - uint32_t address, size, cnt, res, i; - uint8_t *buffer; - struct fileio *fileio; - int ret; - - if (CMD_ARGC != 4) - return ERROR_COMMAND_SYNTAX_ERROR; - - COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], address); - COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], size); - - ret = fileio_open(&fileio, CMD_ARGV[1], FILEIO_WRITE, FILEIO_BINARY); - if (ret != ERROR_OK) - return ret; - - buffer = malloc(MG_FILEIO_CHUNK); - if (!buffer) { - fileio_close(fileio); - return ERROR_FAIL; - } - - cnt = size / MG_FILEIO_CHUNK; - res = size % MG_FILEIO_CHUNK; - - struct duration bench; - duration_start(&bench); - - size_t size_written; - for (i = 0; i < cnt; i++) { - ret = mg_mflash_read(address, buffer, MG_FILEIO_CHUNK); - if (ret != ERROR_OK) - goto mg_dump_cmd_err; - ret = fileio_write(fileio, MG_FILEIO_CHUNK, buffer, &size_written); - if (ret != ERROR_OK) - goto mg_dump_cmd_err; - address += MG_FILEIO_CHUNK; - } - - if (res) { - ret = mg_mflash_read(address, buffer, res); - if (ret != ERROR_OK) - goto mg_dump_cmd_err; - ret = fileio_write(fileio, res, buffer, &size_written); - if (ret != ERROR_OK) - goto mg_dump_cmd_err; - } - - if (duration_measure(&bench) == ERROR_OK) { - command_print(CMD_CTX, "dump image (address 0x%8.8" PRIx32 " " - "size %" PRIu32 ") to file %s in %fs (%0.3f kB/s)", - address, size, CMD_ARGV[1], - duration_elapsed(&bench), duration_kbps(&bench, size)); - } - - free(buffer); - fileio_close(fileio); - - return ERROR_OK; - -mg_dump_cmd_err: - free(buffer); - fileio_close(fileio); - - return ret; -} - -static int mg_set_feature(mg_feature_id feature, mg_feature_val config) -{ - struct target *target = mflash_bank->target; - uint32_t mg_task_reg = mflash_bank->base + MG_REG_OFFSET; - int ret; - - ret = mg_dsk_wait(mg_io_wait_rdy_noerr, MG_OEM_DISK_WAIT_TIME_NORMAL); - if (ret != ERROR_OK) - return ret; - - ret = target_write_u8(target, mg_task_reg + MG_REG_FEATURE, feature); - ret |= target_write_u8(target, mg_task_reg + MG_REG_SECT_CNT, config); - ret |= target_write_u8(target, mg_task_reg + MG_REG_COMMAND, - mg_io_cmd_set_feature); - - return ret; -} - -static int mg_is_valid_pll(double XIN, int N, double CLK_OUT, int NO) -{ - double v1 = XIN / N; - double v2 = CLK_OUT * NO; - - if (v1 < 1000000 || v1 > 15000000 || v2 < 100000000 || v2 > 500000000) - return ERROR_MG_INVALID_PLL; - - return ERROR_OK; -} - -static int mg_pll_get_M(unsigned short feedback_div) -{ - int i, M; - - for (i = 1, M = 0; i < 512; i <<= 1, feedback_div >>= 1) - M += (feedback_div & 1) * i; - - return M + 2; -} - -static int mg_pll_get_N(unsigned char input_div) -{ - int i, N; - - for (i = 1, N = 0; i < 32; i <<= 1, input_div >>= 1) - N += (input_div & 1) * i; - - return N + 2; -} - -static int mg_pll_get_NO(unsigned char output_div) -{ - int i, NO; - - for (i = 0, NO = 1; i < 2; ++i, output_div >>= 1) - if (output_div & 1) - NO = NO << 1; - - return NO; -} - -static double mg_do_calc_pll(double XIN, mg_pll_t *p_pll_val, int is_approximate) -{ - unsigned short i; - unsigned char j, k; - int M, N, NO; - double CLK_OUT; - double DIV = 1; - double ROUND = 0; - - if (is_approximate) { - DIV = 1000000; - ROUND = 500000; - } - - for (i = 0; i < MG_PLL_MAX_FEEDBACKDIV_VAL; ++i) { - M = mg_pll_get_M(i); - - for (j = 0; j < MG_PLL_MAX_INPUTDIV_VAL; ++j) { - N = mg_pll_get_N(j); - - for (k = 0; k < MG_PLL_MAX_OUTPUTDIV_VAL; ++k) { - NO = mg_pll_get_NO(k); - - CLK_OUT = XIN * ((double)M / N) / NO; - - if ((int)((CLK_OUT + ROUND) / DIV) - == (int)(MG_PLL_CLK_OUT / DIV)) { - if (mg_is_valid_pll(XIN, N, CLK_OUT, NO) == ERROR_OK) { - p_pll_val->lock_cyc = - (int)(XIN * MG_PLL_STD_LOCKCYCLE / - MG_PLL_STD_INPUTCLK); - p_pll_val->feedback_div = i; - p_pll_val->input_div = j; - p_pll_val->output_div = k; - - return CLK_OUT; - } - } - } - } - } - - return 0; -} - -static double mg_calc_pll(double XIN, mg_pll_t *p_pll_val) -{ - double CLK_OUT; - - CLK_OUT = mg_do_calc_pll(XIN, p_pll_val, 0); - - if (!CLK_OUT) - return mg_do_calc_pll(XIN, p_pll_val, 1); - else - return CLK_OUT; -} - -static int mg_verify_interface(void) -{ - uint16_t buff[MG_MFLASH_SECTOR_SIZE >> 1]; - uint16_t i, j; - uint32_t address = mflash_bank->base + MG_BUFFER_OFFSET; - struct target *target = mflash_bank->target; - int ret; - - for (j = 0; j < 10; j++) { - for (i = 0; i < MG_MFLASH_SECTOR_SIZE >> 1; i++) - buff[i] = i; - - ret = target_write_memory(target, address, 2, - MG_MFLASH_SECTOR_SIZE / 2, (uint8_t *)buff); - if (ret != ERROR_OK) - return ret; - - memset(buff, 0xff, MG_MFLASH_SECTOR_SIZE); - - ret = target_read_memory(target, address, 2, - MG_MFLASH_SECTOR_SIZE / 2, (uint8_t *)buff); - if (ret != ERROR_OK) - return ret; - - for (i = 0; i < MG_MFLASH_SECTOR_SIZE >> 1; i++) { - if (buff[i] != i) { - LOG_ERROR("mflash: verify interface fail"); - return ERROR_MG_INTERFACE; - } - } - } - - LOG_INFO("mflash: verify interface ok"); - return ret; -} - -static const char g_strSEG_SerialNum[20] = { - 'G', 'm', 'n', 'i', '-', 'e', 'e', 'S', 'g', 'a', 'e', 'l', - 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 -}; - -static const char g_strSEG_FWRev[8] = { - 'F', 'X', 'L', 'T', '2', 'v', '0', '.' -}; - -static const char g_strSEG_ModelNum[40] = { - 'F', 'X', 'A', 'L', 'H', 'S', '2', 0x20, '0', '0', 's', '7', - 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, - 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, - 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20 -}; - -static void mg_gen_ataid(mg_io_type_drv_info *pSegIdDrvInfo) -{ - /* b15 is ATA device(0) , b7 is Removable Media Device */ - pSegIdDrvInfo->general_configuration = 0x045A; - /* 128MB : Cylinder=> 977 , Heads=> 8 , Sectors=> 32 - * 256MB : Cylinder=> 980 , Heads=> 16 , Sectors=> 32 - * 384MB : Cylinder=> 745 , Heads=> 16 , Sectors=> 63 - */ - pSegIdDrvInfo->number_of_cylinders = 0x02E9; - pSegIdDrvInfo->reserved1 = 0x0; - pSegIdDrvInfo->number_of_heads = 0x10; - pSegIdDrvInfo->unformatted_bytes_per_track = 0x0; - pSegIdDrvInfo->unformatted_bytes_per_sector = 0x0; - pSegIdDrvInfo->sectors_per_track = 0x3F; - pSegIdDrvInfo->vendor_unique1[0] = 0x000B; - pSegIdDrvInfo->vendor_unique1[1] = 0x7570; - pSegIdDrvInfo->vendor_unique1[2] = 0x8888; - - memcpy(pSegIdDrvInfo->serial_number, g_strSEG_SerialNum, 20); - /* 0x2 : dual buffer */ - pSegIdDrvInfo->buffer_type = 0x2; - /* buffer size : 2KB */ - pSegIdDrvInfo->buffer_sector_size = 0x800; - pSegIdDrvInfo->number_of_ecc_bytes = 0; - - memcpy(pSegIdDrvInfo->firmware_revision, g_strSEG_FWRev, 8); - - memcpy(pSegIdDrvInfo->model_number, g_strSEG_ModelNum, 40); - - pSegIdDrvInfo->maximum_block_transfer = 0x4; - pSegIdDrvInfo->vendor_unique2 = 0x0; - pSegIdDrvInfo->dword_io = 0x00; - /* b11 : IORDY support(PIO Mode 4), b10 : Disable/Enbale IORDY - * b9 : LBA support, b8 : DMA mode support - */ - pSegIdDrvInfo->capabilities = 0x1 << 9; - - pSegIdDrvInfo->reserved2 = 0x4000; - pSegIdDrvInfo->vendor_unique3 = 0x00; - /* PIOMode-2 support */ - pSegIdDrvInfo->pio_cycle_timing_mode = 0x02; - pSegIdDrvInfo->vendor_unique4 = 0x00; - /* MultiWord-2 support */ - pSegIdDrvInfo->dma_cycle_timing_mode = 0x00; - /* b1 : word64~70 is valid - * b0 : word54~58 are valid and reflect the current numofcyls,heads,sectors - * b2 : If device supports Ultra DMA , set to one to vaildate word88 - */ - pSegIdDrvInfo->translation_fields_valid = (0x1 << 1) | (0x1 << 0); - pSegIdDrvInfo->number_of_current_cylinders = 0x02E9; - pSegIdDrvInfo->number_of_current_heads = 0x10; - pSegIdDrvInfo->current_sectors_per_track = 0x3F; - pSegIdDrvInfo->current_sector_capacity_lo = 0x7570; - pSegIdDrvInfo->current_sector_capacity_hi = 0x000B; - - pSegIdDrvInfo->multi_sector_count = 0x04; - /* b8 : Multiple secotr setting valid , b[7:0] num of secotrs per block */ - pSegIdDrvInfo->multi_sector_setting_valid = 0x01; - pSegIdDrvInfo->total_user_addressable_sectors_lo = 0x7570; - pSegIdDrvInfo->total_user_addressable_sectors_hi = 0x000B; - pSegIdDrvInfo->single_dma_modes_supported = 0x00; - pSegIdDrvInfo->single_dma_transfer_active = 0x00; - /* b2 :Multi-word DMA mode 2, b1 : Multi-word DMA mode 1 */ - pSegIdDrvInfo->multi_dma_modes_supported = (0x1 << 0); - /* b2 :Multi-word DMA mode 2, b1 : Multi-word DMA mode 1 */ - pSegIdDrvInfo->multi_dma_transfer_active = (0x1 << 0); - /* b0 : PIO Mode-3 support, b1 : PIO Mode-4 support */ - pSegIdDrvInfo->adv_pio_mode = 0x00; - /* 480(0x1E0)nsec for Multi-word DMA mode0 - * 150(0x96) nsec for Multi-word DMA mode1 - * 120(0x78) nsec for Multi-word DMA mode2 - */ - pSegIdDrvInfo->min_dma_cyc = 0x1E0; - pSegIdDrvInfo->recommend_dma_cyc = 0x1E0; - pSegIdDrvInfo->min_pio_cyc_no_iordy = 0x1E0; - pSegIdDrvInfo->min_pio_cyc_with_iordy = 0x1E0; - memset(pSegIdDrvInfo->reserved3, 0x00, 22); - /* b7 : ATA/ATAPI-7 ,b6 : ATA/ATAPI-6 ,b5 : ATA/ATAPI-5,b4 : ATA/ATAPI-4 */ - pSegIdDrvInfo->major_ver_num = 0x7E; - /* 0x1C : ATA/ATAPI-6 T13 1532D revision1 */ - pSegIdDrvInfo->minor_ver_num = 0x19; - /* NOP/READ BUFFER/WRITE BUFFER/Power management feature set support */ - pSegIdDrvInfo->feature_cmd_set_suprt0 = 0x7068; - /* Features/command set is valid/Advanced Pwr management/CFA feature set - * not support - */ - pSegIdDrvInfo->feature_cmd_set_suprt1 = 0x400C; - pSegIdDrvInfo->feature_cmd_set_suprt2 = 0x4000; - /* READ/WRITE BUFFER/PWR Management enable */ - pSegIdDrvInfo->feature_cmd_set_en0 = 0x7000; - /* CFA feature is disabled / Advancde power management disable */ - pSegIdDrvInfo->feature_cmd_set_en1 = 0x0; - pSegIdDrvInfo->feature_cmd_set_en2 = 0x4000; - pSegIdDrvInfo->reserved4 = 0x0; - /* 0x1 * 2minutes */ - pSegIdDrvInfo->req_time_for_security_er_done = 0x19; - pSegIdDrvInfo->req_time_for_enhan_security_er_done = 0x19; - /* Advanced power management level 1 */ - pSegIdDrvInfo->adv_pwr_mgm_lvl_val = 0x0; - pSegIdDrvInfo->reserved5 = 0x0; - memset(pSegIdDrvInfo->reserved6, 0x00, 68); - /* Security mode feature is disabled */ - pSegIdDrvInfo->security_stas = 0x0; - memset(pSegIdDrvInfo->vendor_uniq_bytes, 0x00, 62); - /* CFA power mode 1 support in maximum 200mA */ - pSegIdDrvInfo->cfa_pwr_mode = 0x0100; - memset(pSegIdDrvInfo->reserved7, 0x00, 190); -} - -static int mg_storage_config(void) -{ - uint8_t buff[512]; - int ret; - - ret = mg_set_feature(mg_feature_id_transmode, mg_feature_val_trans_vcmd); - if (ret != ERROR_OK) - return ret; - - mg_gen_ataid((mg_io_type_drv_info *)(void *)buff); - - ret = mg_mflash_do_write_sects(buff, 0, 1, mg_vcmd_update_stgdrvinfo); - if (ret != ERROR_OK) - return ret; - - ret = mg_set_feature(mg_feature_id_transmode, mg_feature_val_trans_default); - if (ret != ERROR_OK) - return ret; - - LOG_INFO("mflash: storage config ok"); - return ret; -} - -static int mg_boot_config(void) -{ - uint8_t buff[512]; - int ret; - - ret = mg_set_feature(mg_feature_id_transmode, mg_feature_val_trans_vcmd); - if (ret != ERROR_OK) - return ret; - - memset(buff, 0xff, 512); - - buff[0] = mg_op_mode_snd; /* operation mode */ - buff[1] = MG_UNLOCK_OTP_AREA; - buff[2] = 4; /* boot size */ - *((uint32_t *)(void *)(buff + 4)) = 0; /* XIP size */ - - ret = mg_mflash_do_write_sects(buff, 0, 1, mg_vcmd_update_xipinfo); - if (ret != ERROR_OK) - return ret; - - ret = mg_set_feature(mg_feature_id_transmode, mg_feature_val_trans_default); - if (ret != ERROR_OK) - return ret; - - LOG_INFO("mflash: boot config ok"); - return ret; -} - -static int mg_set_pll(mg_pll_t *pll) -{ - uint8_t buff[512]; - int ret; - - memset(buff, 0xff, 512); - /* PLL Lock cycle and Feedback 9bit Divider */ - memcpy(buff, &pll->lock_cyc, sizeof(uint32_t)); - memcpy(buff + 4, &pll->feedback_div, sizeof(uint16_t)); - buff[6] = pll->input_div; /* PLL Input 5bit Divider */ - buff[7] = pll->output_div; /* PLL Output Divider */ - - ret = mg_set_feature(mg_feature_id_transmode, mg_feature_val_trans_vcmd); - if (ret != ERROR_OK) - return ret; - - ret = mg_mflash_do_write_sects(buff, 0, 1, mg_vcmd_wr_pll); - if (ret != ERROR_OK) - return ret; - - ret = mg_set_feature(mg_feature_id_transmode, mg_feature_val_trans_default); - if (ret != ERROR_OK) - return ret; - - LOG_INFO("mflash: set pll ok"); - return ret; -} - -static int mg_erase_nand(void) -{ - int ret; - - ret = mg_set_feature(mg_feature_id_transmode, mg_feature_val_trans_vcmd); - if (ret != ERROR_OK) - return ret; - - ret = mg_mflash_do_write_sects(NULL, 0, 0, mg_vcmd_purge_nand); - if (ret != ERROR_OK) - return ret; - - ret = mg_set_feature(mg_feature_id_transmode, mg_feature_val_trans_default); - if (ret != ERROR_OK) - return ret; - - LOG_INFO("mflash: erase nand ok"); - return ret; -} - -COMMAND_HANDLER(mg_config_cmd) -{ - double fin, fout; - mg_pll_t pll; - int ret; - - ret = mg_verify_interface(); - if (ret != ERROR_OK) - return ret; - - ret = mg_mflash_rst(); - if (ret != ERROR_OK) - return ret; - - switch (CMD_ARGC) { - case 2: - if (!strcmp(CMD_ARGV[1], "boot")) - return mg_boot_config(); - else if (!strcmp(CMD_ARGV[1], "storage")) - return mg_storage_config(); - else - return ERROR_COMMAND_NOTFOUND; - break; - case 3: - if (!strcmp(CMD_ARGV[1], "pll")) { - unsigned long freq; - COMMAND_PARSE_NUMBER(ulong, CMD_ARGV[2], freq); - fin = freq; - - if (fin > MG_PLL_CLK_OUT) { - LOG_ERROR("mflash: input freq. is too large"); - return ERROR_MG_INVALID_OSC; - } - - fout = mg_calc_pll(fin, &pll); - - if (!fout) { - LOG_ERROR("mflash: cannot generate valid pll"); - return ERROR_MG_INVALID_PLL; - } - - LOG_INFO("mflash: Fout=%" PRIu32 " Hz, feedback=%u," - "indiv=%u, outdiv=%u, lock=%u", - (uint32_t)fout, pll.feedback_div, - pll.input_div, pll.output_div, - pll.lock_cyc); - - ret = mg_erase_nand(); - if (ret != ERROR_OK) - return ret; - - return mg_set_pll(&pll); - } else - return ERROR_COMMAND_NOTFOUND; - break; - default: - return ERROR_COMMAND_SYNTAX_ERROR; - } -} - -static const struct command_registration mflash_exec_command_handlers[] = { - { - .name = "probe", - .handler = mg_probe_cmd, - .mode = COMMAND_EXEC, - .help = "Detect bank configuration information", - }, - { - .name = "write", - .handler = mg_write_cmd, - .mode = COMMAND_EXEC, - /* FIXME bank_num is unused */ - .usage = "bank_num filename address", - .help = "Write binary file at the specified address.", - }, - { - .name = "dump", - .handler = mg_dump_cmd, - .mode = COMMAND_EXEC, - /* FIXME bank_num is unused */ - .usage = "bank_num filename address size", - .help = "Write specified number of bytes from a binary file " - "to the specified, address.", - }, - { - .name = "config", - .handler = mg_config_cmd, - .mode = COMMAND_EXEC, - .help = "Configure MFLASH options.", - .usage = "('boot'|'storage'|'pll' frequency)", - }, - COMMAND_REGISTRATION_DONE -}; - -static int mflash_init_drivers(struct command_context *cmd_ctx) -{ - if (!mflash_bank) - return ERROR_OK; - return register_commands(cmd_ctx, NULL, mflash_exec_command_handlers); -} - -COMMAND_HANDLER(handle_mflash_init_command) -{ - if (CMD_ARGC != 0) - return ERROR_COMMAND_SYNTAX_ERROR; - - static bool mflash_initialized; - if (mflash_initialized) { - LOG_INFO("'mflash init' has already been called"); - return ERROR_OK; - } - mflash_initialized = true; - - LOG_DEBUG("Initializing mflash devices..."); - return mflash_init_drivers(CMD_CTX); -} - -COMMAND_HANDLER(mg_bank_cmd) -{ - struct target *target; - int i; - - if (CMD_ARGC < 4) - return ERROR_COMMAND_SYNTAX_ERROR; - - target = get_target(CMD_ARGV[3]); - if (target == NULL) { - LOG_ERROR("target '%s' not defined", CMD_ARGV[3]); - return ERROR_FAIL; - } - - mflash_bank = calloc(sizeof(struct mflash_bank), 1); - COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], mflash_bank->base); - /** @todo Verify how this parsing should work, then document it. */ - char *str; - mflash_bank->rst_pin.num = strtoul(CMD_ARGV[2], &str, 0); - if (*str) - mflash_bank->rst_pin.port[0] = (uint16_t) - tolower((unsigned)str[0]); - - mflash_bank->target = target; - - for (i = 0; mflash_gpio[i]; i++) { - if (!strcmp(mflash_gpio[i]->name, CMD_ARGV[0])) - mflash_bank->gpio_drv = mflash_gpio[i]; - } - - if (!mflash_bank->gpio_drv) { - LOG_ERROR("%s is unsupported soc", CMD_ARGV[0]); - return ERROR_MG_UNSUPPORTED_SOC; - } - - return ERROR_OK; -} - -static const struct command_registration mflash_config_command_handlers[] = { - { - .name = "bank", - .handler = mg_bank_cmd, - .mode = COMMAND_CONFIG, - .help = "configure a mflash device bank", - .usage = "soc_type base_addr pin_id target", - }, - { - .name = "init", - .mode = COMMAND_CONFIG, - .handler = handle_mflash_init_command, - .help = "initialize mflash devices", - .usage = "" - }, - COMMAND_REGISTRATION_DONE -}; -static const struct command_registration mflash_command_handler[] = { - { - .name = "mflash", - .mode = COMMAND_ANY, - .help = "mflash command group", - .usage = "", - .chain = mflash_config_command_handlers, - }, - COMMAND_REGISTRATION_DONE -}; -int mflash_register_commands(struct command_context *cmd_ctx) -{ - return register_commands(cmd_ctx, NULL, mflash_command_handler); -} diff --git a/src/flash/mflash.h b/src/flash/mflash.h deleted file mode 100644 index 18da403..0000000 --- a/src/flash/mflash.h +++ /dev/null @@ -1,289 +0,0 @@ -/*************************************************************************** - * Copyright (C) 2007-2008 by unsik Kim <donari75@gmail.com> * - * * - * 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, see <http://www.gnu.org/licenses/>. * - ***************************************************************************/ - -#ifndef OPENOCD_FLASH_MFLASH_H -#define OPENOCD_FLASH_MFLASH_H - -struct command_context; - -typedef unsigned long mg_io_uint32; -typedef unsigned short mg_io_uint16; -typedef unsigned char mg_io_uint8; - -struct mflash_gpio_num { - char port[2]; - signed short num; -}; - -struct mflash_gpio_drv { - const char *name; - int (*set_gpio_to_output)(struct mflash_gpio_num gpio); - int (*set_gpio_output_val)(struct mflash_gpio_num gpio, uint8_t val); -}; - -typedef struct _mg_io_type_drv_info { - - mg_io_uint16 general_configuration; /* 00 */ - mg_io_uint16 number_of_cylinders; /* 01 */ - mg_io_uint16 reserved1; /* 02 */ - mg_io_uint16 number_of_heads; /* 03 */ - mg_io_uint16 unformatted_bytes_per_track; /* 04 */ - mg_io_uint16 unformatted_bytes_per_sector; /* 05 */ - mg_io_uint16 sectors_per_track; /* 06 */ - mg_io_uint16 vendor_unique1[3]; /* 07/08/09 */ - - mg_io_uint8 serial_number[20]; /* 10~19 */ - - mg_io_uint16 buffer_type; /* 20 */ - mg_io_uint16 buffer_sector_size; /* 21 */ - mg_io_uint16 number_of_ecc_bytes; /* 22 */ - - mg_io_uint8 firmware_revision[8]; /* 23~26 */ - mg_io_uint8 model_number[40]; /* 27 */ - - mg_io_uint8 maximum_block_transfer; /* 47 low byte */ - mg_io_uint8 vendor_unique2; /* 47 high byte */ - mg_io_uint16 dword_io; /* 48 */ - - mg_io_uint16 capabilities; /* 49 */ - mg_io_uint16 reserved2; /* 50 */ - - mg_io_uint8 vendor_unique3; /* 51 low byte */ - mg_io_uint8 pio_cycle_timing_mode; /* 51 high byte */ - mg_io_uint8 vendor_unique4; /* 52 low byte */ - mg_io_uint8 dma_cycle_timing_mode; /* 52 high byte */ - mg_io_uint16 translation_fields_valid; /* 53 (low bit) */ - mg_io_uint16 number_of_current_cylinders; /* 54 */ - mg_io_uint16 number_of_current_heads; /* 55 */ - mg_io_uint16 current_sectors_per_track; /* 56 */ - mg_io_uint16 current_sector_capacity_lo; /* 57 & 58 */ - mg_io_uint16 current_sector_capacity_hi; /* 57 & 58 */ - mg_io_uint8 multi_sector_count; /* 59 low */ - mg_io_uint8 multi_sector_setting_valid; /* 59 high (low bit) */ - - mg_io_uint16 total_user_addressable_sectors_lo; /* 60 & 61 */ - mg_io_uint16 total_user_addressable_sectors_hi; /* 60 & 61 */ - - mg_io_uint8 single_dma_modes_supported; /* 62 low byte */ - mg_io_uint8 single_dma_transfer_active; /* 62 high byte */ - mg_io_uint8 multi_dma_modes_supported; /* 63 low byte */ - mg_io_uint8 multi_dma_transfer_active; /* 63 high byte */ - mg_io_uint16 adv_pio_mode; - mg_io_uint16 min_dma_cyc; - mg_io_uint16 recommend_dma_cyc; - mg_io_uint16 min_pio_cyc_no_iordy; - mg_io_uint16 min_pio_cyc_with_iordy; - mg_io_uint8 reserved3[22]; - mg_io_uint16 major_ver_num; - mg_io_uint16 minor_ver_num; - mg_io_uint16 feature_cmd_set_suprt0; - mg_io_uint16 feature_cmd_set_suprt1; - mg_io_uint16 feature_cmd_set_suprt2; - mg_io_uint16 feature_cmd_set_en0; - mg_io_uint16 feature_cmd_set_en1; - mg_io_uint16 feature_cmd_set_en2; - mg_io_uint16 reserved4; - mg_io_uint16 req_time_for_security_er_done; - mg_io_uint16 req_time_for_enhan_security_er_done; - mg_io_uint16 adv_pwr_mgm_lvl_val; - mg_io_uint16 reserved5; - mg_io_uint16 re_of_hw_rst; - mg_io_uint8 reserved6[68]; - mg_io_uint16 security_stas; - mg_io_uint8 vendor_uniq_bytes[62]; - mg_io_uint16 cfa_pwr_mode; - mg_io_uint8 reserved7[186]; - - mg_io_uint16 scts_per_secure_data_unit; - mg_io_uint16 integrity_word; - -} mg_io_type_drv_info; - -typedef struct _mg_pll_t { - unsigned int lock_cyc; - unsigned short feedback_div; /* 9bit divider */ - unsigned char input_div; /* 5bit divider */ - unsigned char output_div; /* 2bit divider */ -} mg_pll_t; - -struct mg_drv_info { - mg_io_type_drv_info drv_id; - uint32_t tot_sects; -}; - -struct mflash_bank { - uint32_t base; - - struct mflash_gpio_num rst_pin; - - struct mflash_gpio_drv *gpio_drv; - struct target *target; - struct mg_drv_info *drv_info; -}; - -int mflash_register_commands(struct command_context *cmd_ctx); - -#define MG_MFLASH_SECTOR_SIZE (0x200) /* 512Bytes = 2^9 */ -#define MG_MFLASH_SECTOR_SIZE_MASK (0x200-1) -#define MG_MFLASH_SECTOR_SIZE_SHIFT (9) - -#define MG_BUFFER_OFFSET 0x8000 -#define MG_REG_OFFSET 0xC000 -#define MG_REG_FEATURE 0x2 /* write case */ -#define MG_REG_ERROR 0x2 /* read case */ -#define MG_REG_SECT_CNT 0x4 -#define MG_REG_SECT_NUM 0x6 -#define MG_REG_CYL_LOW 0x8 -#define MG_REG_CYL_HIGH 0xA -#define MG_REG_DRV_HEAD 0xC -#define MG_REG_COMMAND 0xE /* write case */ -#define MG_REG_STATUS 0xE /* read case */ -#define MG_REG_DRV_CTRL 0x10 -#define MG_REG_BURST_CTRL 0x12 - -#define MG_OEM_DISK_WAIT_TIME_LONG 15000 /* msec */ -#define MG_OEM_DISK_WAIT_TIME_NORMAL 3000 /* msec */ -#define MG_OEM_DISK_WAIT_TIME_SHORT 1000 /* msec */ - -#define MG_PLL_CLK_OUT 66000000.0 /* 66Mhz */ -#define MG_PLL_MAX_FEEDBACKDIV_VAL 512 -#define MG_PLL_MAX_INPUTDIV_VAL 32 -#define MG_PLL_MAX_OUTPUTDIV_VAL 4 - -#define MG_PLL_STD_INPUTCLK 12000000.0 /* 12Mhz */ -#define MG_PLL_STD_LOCKCYCLE 10000 - -#define MG_UNLOCK_OTP_AREA 0xFF - -#define MG_FILEIO_CHUNK 1048576 - -#define ERROR_MG_IO (-1600) -#define ERROR_MG_TIMEOUT (-1601) -#define ERROR_MG_INVALID_PLL (-1603) -#define ERROR_MG_INTERFACE (-1604) -#define ERROR_MG_INVALID_OSC (-1605) -#define ERROR_MG_UNSUPPORTED_SOC (-1606) - -typedef enum _mg_io_type_wait { - - mg_io_wait_bsy = 1, - mg_io_wait_not_bsy = 2, - mg_io_wait_rdy = 3, - mg_io_wait_drq = 4, /* wait for data request */ - mg_io_wait_drq_noerr = 5, /* wait for DRQ but ignore the error status bit */ - mg_io_wait_rdy_noerr = 6 /* wait for ready, but ignore error status bit */ - -} mg_io_type_wait; - -/*= "Status Register" bit masks. */ -typedef enum _mg_io_type_rbit_status { - - mg_io_rbit_status_error = 0x01, /* error bit in status register */ - mg_io_rbit_status_corrected_error = 0x04, /* corrected error in status register */ - mg_io_rbit_status_data_req = 0x08, /* data request bit in status register */ - mg_io_rbit_status_seek_done = 0x10, /* DSC - Drive Seek Complete */ - mg_io_rbit_status_write_fault = 0x20, /* DWF - Drive Write Fault */ - mg_io_rbit_status_ready = 0x40, - mg_io_rbit_status_busy = 0x80 - -} mg_io_type_rbit_status; - -/*= "Error Register" bit masks. */ -typedef enum _mg_io_type_rbit_error { - - mg_io_rbit_err_general = 0x01, - mg_io_rbit_err_aborted = 0x04, - mg_io_rbit_err_bad_sect_num = 0x10, - mg_io_rbit_err_uncorrectable = 0x40, - mg_io_rbit_err_bad_block = 0x80 - -} mg_io_type_rbit_error; - -/* = "Device Control Register" bit. */ -typedef enum _mg_io_type_rbit_devc { - - mg_io_rbit_devc_intr = 0x02, /* interrupt enable bit (1:disable, 0:enable) */ - mg_io_rbit_devc_srst = 0x04 /* softwrae reset bit (1:assert, 0:de-assert) */ - -} mg_io_type_rbit_devc; - -/* "Drive Select/Head Register" values. */ -typedef enum _mg_io_type_rval_dev { - - mg_io_rval_dev_must_be_on = 0x80, /* These 1 bits are always on */ - mg_io_rval_dev_drv_master = (0x00 | mg_io_rval_dev_must_be_on), /* Master */ - mg_io_rval_dev_drv_slave0 = (0x10 | mg_io_rval_dev_must_be_on), /* Slave0 */ - mg_io_rval_dev_drv_slave1 = (0x20 | mg_io_rval_dev_must_be_on), /* Slave1 */ - mg_io_rval_dev_drv_slave2 = (0x30 | mg_io_rval_dev_must_be_on), /* Slave2 */ - mg_io_rval_dev_lba_mode = (0x40 | mg_io_rval_dev_must_be_on) - -} mg_io_type_rval_dev; - -typedef enum _mg_io_type_cmd { - mg_io_cmd_read = 0x20, - mg_io_cmd_write = 0x30, - - mg_io_cmd_setmul = 0xC6, - mg_io_cmd_readmul = 0xC4, - mg_io_cmd_writemul = 0xC5, - - mg_io_cmd_idle = 0x97, /* 0xE3 */ - mg_io_cmd_idle_immediate = 0x95, /* 0xE1 */ - - mg_io_cmd_setsleep = 0x99, /* 0xE6 */ - mg_io_cmd_stdby = 0x96, /* 0xE2 */ - mg_io_cmd_stdby_immediate = 0x94, /* 0xE0 */ - - mg_io_cmd_identify = 0xEC, - mg_io_cmd_set_feature = 0xEF, - - mg_io_cmd_confirm_write = 0x3C, - mg_io_cmd_confirm_read = 0x40, - mg_io_cmd_wakeup = 0xC3 - -} mg_io_type_cmd; - -typedef enum _mg_feature_id { - mg_feature_id_transmode = 0x3 -} mg_feature_id; - -typedef enum _mg_feature_val { - mg_feature_val_trans_default = 0x0, - mg_feature_val_trans_vcmd = 0x3, - mg_feature_val_trand_vcmds = 0x2 -} mg_feature_val; - -typedef enum _mg_vcmd { - mg_vcmd_update_xipinfo = 0xFA, /* FWPATCH commmand through IOM I/O */ - mg_vcmd_verify_fwpatch = 0xFB, /* FWPATCH commmand through IOM I/O */ - mg_vcmd_update_stgdrvinfo = 0xFC, /* IOM identificatin info program command */ - mg_vcmd_prep_fwpatch = 0xFD, /* FWPATCH commmand through IOM I/O */ - mg_vcmd_exe_fwpatch = 0xFE, /* FWPATCH commmand through IOM I/O */ - mg_vcmd_wr_pll = 0x8B, - mg_vcmd_purge_nand = 0x8C, /* Only for Seagle */ - mg_vcmd_lock_otp = 0x8D, - mg_vcmd_rd_otp = 0x8E, - mg_vcmd_wr_otp = 0x8F -} mg_vcmd; - -typedef enum _mg_opmode { - mg_op_mode_xip = 1, /* TRUE XIP */ - mg_op_mode_snd = 2, /* BOOT + Storage */ - mg_op_mode_stg = 0 /* Only Storage */ -} mg_opmode; - -#endif /* OPENOCD_FLASH_MFLASH_H */ diff --git a/src/flash/nand/at91sam9.c b/src/flash/nand/at91sam9.c index 0af12b2..47c0505 100644 --- a/src/flash/nand/at91sam9.c +++ b/src/flash/nand/at91sam9.c @@ -547,14 +547,14 @@ COMMAND_HANDLER(handle_at91sam9_cle_command) unsigned num, address_line; if (CMD_ARGC != 2) { - command_print(CMD_CTX, "incorrect number of arguments for 'at91sam9 cle' command"); + command_print(CMD, "incorrect number of arguments for 'at91sam9 cle' command"); return ERROR_OK; } COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num); nand = get_nand_device_by_num(num); if (!nand) { - command_print(CMD_CTX, "invalid nand device number: %s", CMD_ARGV[0]); + command_print(CMD, "invalid nand device number: %s", CMD_ARGV[0]); return ERROR_OK; } @@ -582,7 +582,7 @@ COMMAND_HANDLER(handle_at91sam9_ale_command) COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num); nand = get_nand_device_by_num(num); if (!nand) { - command_print(CMD_CTX, "invalid nand device number: %s", CMD_ARGV[0]); + command_print(CMD, "invalid nand device number: %s", CMD_ARGV[0]); return ERROR_COMMAND_ARGUMENT_INVALID; } @@ -610,7 +610,7 @@ COMMAND_HANDLER(handle_at91sam9_rdy_busy_command) COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num); nand = get_nand_device_by_num(num); if (!nand) { - command_print(CMD_CTX, "invalid nand device number: %s", CMD_ARGV[0]); + command_print(CMD, "invalid nand device number: %s", CMD_ARGV[0]); return ERROR_COMMAND_ARGUMENT_INVALID; } @@ -641,7 +641,7 @@ COMMAND_HANDLER(handle_at91sam9_ce_command) COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num); nand = get_nand_device_by_num(num); if (!nand) { - command_print(CMD_CTX, "invalid nand device number: %s", CMD_ARGV[0]); + command_print(CMD, "invalid nand device number: %s", CMD_ARGV[0]); return ERROR_COMMAND_ARGUMENT_INVALID; } diff --git a/src/flash/nand/core.c b/src/flash/nand/core.c index 7428d22..b9ac793 100644 --- a/src/flash/nand/core.c +++ b/src/flash/nand/core.c @@ -217,7 +217,7 @@ COMMAND_HELPER(nand_command_get_device, unsigned name_index, COMMAND_PARSE_NUMBER(uint, str, num); *nand = get_nand_device_by_num(num); if (!*nand) { - command_print(CMD_CTX, "NAND flash device '%s' not found", str); + command_print(CMD, "NAND flash device '%s' not found", str); return ERROR_COMMAND_SYNTAX_ERROR; } return ERROR_OK; diff --git a/src/flash/nand/fileio.c b/src/flash/nand/fileio.c index 64c32c0..f65f957 100644 --- a/src/flash/nand/fileio.c +++ b/src/flash/nand/fileio.c @@ -54,12 +54,12 @@ void nand_fileio_init(struct nand_fileio_state *state) state->oob_format = NAND_OOB_NONE; } -int nand_fileio_start(struct command_context *cmd_ctx, +int nand_fileio_start(struct command_invocation *cmd, struct nand_device *nand, const char *filename, int filemode, struct nand_fileio_state *state) { if (state->address % nand->page_size) { - command_print(cmd_ctx, "only page-aligned addresses are supported"); + command_print(cmd, "only page-aligned addresses are supported"); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -69,7 +69,7 @@ int nand_fileio_start(struct command_context *cmd_ctx, int retval = fileio_open(&state->fileio, filename, filemode, FILEIO_BINARY); if (ERROR_OK != retval) { const char *msg = (FILEIO_READ == filemode) ? "read" : "write"; - command_print(cmd_ctx, "failed to open '%s' for %s access", + command_print(cmd, "failed to open '%s' for %s access", filename, msg); return retval; } @@ -131,7 +131,7 @@ COMMAND_HELPER(nand_fileio_parse_args, struct nand_fileio_state *state, return retval; if (NULL == nand->device) { - command_print(CMD_CTX, "#%s: not probed", CMD_ARGV[0]); + command_print(CMD, "#%s: not probed", CMD_ARGV[0]); return ERROR_NAND_DEVICE_NOT_PROBED; } @@ -139,7 +139,7 @@ COMMAND_HELPER(nand_fileio_parse_args, struct nand_fileio_state *state, if (need_size) { COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], state->size); if (state->size % nand->page_size) { - command_print(CMD_CTX, "only page-aligned sizes are supported"); + command_print(CMD, "only page-aligned sizes are supported"); return ERROR_COMMAND_SYNTAX_ERROR; } } @@ -155,13 +155,13 @@ COMMAND_HELPER(nand_fileio_parse_args, struct nand_fileio_state *state, else if (sw_ecc && !strcmp(CMD_ARGV[i], "oob_softecc_kw")) state->oob_format |= NAND_OOB_SW_ECC_KW; else { - command_print(CMD_CTX, "unknown option: %s", CMD_ARGV[i]); + command_print(CMD, "unknown option: %s", CMD_ARGV[i]); return ERROR_COMMAND_SYNTAX_ERROR; } } } - retval = nand_fileio_start(CMD_CTX, nand, CMD_ARGV[1], filemode, state); + retval = nand_fileio_start(CMD, nand, CMD_ARGV[1], filemode, state); if (ERROR_OK != retval) return retval; diff --git a/src/flash/nand/fileio.h b/src/flash/nand/fileio.h index af6c766..6a094c2 100644 --- a/src/flash/nand/fileio.h +++ b/src/flash/nand/fileio.h @@ -41,7 +41,7 @@ struct nand_fileio_state { }; void nand_fileio_init(struct nand_fileio_state *state); -int nand_fileio_start(struct command_context *cmd_ctx, +int nand_fileio_start(struct command_invocation *cmd, struct nand_device *nand, const char *filename, int filemode, struct nand_fileio_state *state); int nand_fileio_cleanup(struct nand_fileio_state *state); diff --git a/src/flash/nand/lpc3180.c b/src/flash/nand/lpc3180.c index d15fdce..389c18a 100644 --- a/src/flash/nand/lpc3180.c +++ b/src/flash/nand/lpc3180.c @@ -237,7 +237,7 @@ static int lpc3180_init(struct nand_device *nand) /* SLC_CFG = 0x (Force nCE assert, DMA ECC enabled, ECC enabled, DMA burst enabled, *DMA read from SLC, WIDTH = bus_width) */ - target_write_u32(target, 0x20020014, 0x3e | (bus_width == 16) ? 1 : 0); + target_write_u32(target, 0x20020014, 0x3e | ((bus_width == 16) ? 1 : 0)); /* SLC_IEN = 3 (INT_RDY_EN = 1) ,(INT_TC_STAT = 1) */ target_write_u32(target, 0x20020020, 0x03); @@ -1290,7 +1290,7 @@ COMMAND_HANDLER(handle_lpc3180_select_command) COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num); struct nand_device *nand = get_nand_device_by_num(num); if (!nand) { - command_print(CMD_CTX, "nand device '#%s' is out of bounds", CMD_ARGV[0]); + command_print(CMD, "nand device '#%s' is out of bounds", CMD_ARGV[0]); return ERROR_OK; } @@ -1310,10 +1310,10 @@ COMMAND_HANDLER(handle_lpc3180_select_command) } if (lpc3180_info->selected_controller == LPC3180_MLC_CONTROLLER) - command_print(CMD_CTX, "%s controller selected", + command_print(CMD, "%s controller selected", selected[lpc3180_info->selected_controller]); else - command_print(CMD_CTX, + command_print(CMD, lpc3180_info->is_bulk ? "%s controller selected bulk mode is available" : "%s controller selected bulk mode is not available", selected[lpc3180_info->selected_controller]); diff --git a/src/flash/nand/lpc32xx.c b/src/flash/nand/lpc32xx.c index 1ed16df..058d9a5 100644 --- a/src/flash/nand/lpc32xx.c +++ b/src/flash/nand/lpc32xx.c @@ -332,7 +332,7 @@ static int lpc32xx_init(struct nand_device *nand) WIDTH = bus_width) */ retval = target_write_u32(target, 0x20020014, - 0x3e | (bus_width == 16) ? 1 : 0); + 0x3e | ((bus_width == 16) ? 1 : 0)); if (ERROR_OK != retval) { LOG_ERROR("could not set SLC_CFG"); return ERROR_NAND_OPERATION_FAILED; @@ -1760,7 +1760,7 @@ COMMAND_HANDLER(handle_lpc32xx_select_command) COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], num); struct nand_device *nand = get_nand_device_by_num(num); if (!nand) { - command_print(CMD_CTX, "nand device '#%s' is out of bounds", + command_print(CMD, "nand device '#%s' is out of bounds", CMD_ARGV[0]); return ERROR_OK; } @@ -1778,7 +1778,7 @@ COMMAND_HANDLER(handle_lpc32xx_select_command) return ERROR_COMMAND_SYNTAX_ERROR; } - command_print(CMD_CTX, "%s controller selected", + command_print(CMD, "%s controller selected", selected[lpc32xx_info->selected_controller]); return ERROR_OK; diff --git a/src/flash/nand/mxc.c b/src/flash/nand/mxc.c index 6be4160..b541157 100644 --- a/src/flash/nand/mxc.c +++ b/src/flash/nand/mxc.c @@ -157,7 +157,7 @@ COMMAND_HANDLER(handle_mxc_biswap_command) int retval = CALL_COMMAND_HANDLER(nand_command_get_device, 0, &nand); if (retval != ERROR_OK) { - command_print(CMD_CTX, "invalid nand device number or name: %s", CMD_ARGV[0]); + command_print(CMD, "invalid nand device number or name: %s", CMD_ARGV[0]); return ERROR_COMMAND_ARGUMENT_INVALID; } @@ -169,9 +169,9 @@ COMMAND_HANDLER(handle_mxc_biswap_command) mxc_nf_info->flags.biswap_enabled = false; } if (mxc_nf_info->flags.biswap_enabled) - command_print(CMD_CTX, "BI-swapping enabled on %s", nand->name); + command_print(CMD, "BI-swapping enabled on %s", nand->name); else - command_print(CMD_CTX, "BI-swapping disabled on %s", nand->name); + command_print(CMD, "BI-swapping disabled on %s", nand->name); return ERROR_OK; } @@ -193,7 +193,8 @@ static const struct command_registration mxc_nand_command_handler[] = { .name = "mxc", .mode = COMMAND_ANY, .help = "MXC NAND flash controller commands", - .chain = mxc_sub_command_handlers + .chain = mxc_sub_command_handlers, + .usage = "", }, COMMAND_REGISTRATION_DONE }; diff --git a/src/flash/nand/tcl.c b/src/flash/nand/tcl.c index d9738c5..5480e0d 100644 --- a/src/flash/nand/tcl.c +++ b/src/flash/nand/tcl.c @@ -37,20 +37,20 @@ COMMAND_HANDLER(handle_nand_list_command) int i; if (!nand_devices) { - command_print(CMD_CTX, "no NAND flash devices configured"); + command_print(CMD, "no NAND flash devices configured"); return ERROR_OK; } for (p = nand_devices, i = 0; p; p = p->next, i++) { if (p->device) - command_print(CMD_CTX, "#%i: %s (%s) " + command_print(CMD, "#%i: %s (%s) " "pagesize: %i, buswidth: %i,\n\t" "blocksize: %i, blocks: %i", i, p->device->name, p->manufacturer->name, p->page_size, p->bus_width, p->erase_size, p->num_blocks); else - command_print(CMD_CTX, "#%i: not probed", i); + command_print(CMD, "#%i: not probed", i); } return ERROR_OK; @@ -87,7 +87,7 @@ COMMAND_HANDLER(handle_nand_info_command) return retval; if (NULL == p->device) { - command_print(CMD_CTX, "#%s: not probed", CMD_ARGV[0]); + command_print(CMD, "#%s: not probed", CMD_ARGV[0]); return ERROR_OK; } @@ -97,7 +97,7 @@ COMMAND_HANDLER(handle_nand_info_command) if (last >= p->num_blocks) last = p->num_blocks - 1; - command_print(CMD_CTX, + command_print(CMD, "#%i: %s (%s) pagesize: %i, buswidth: %i, erasesize: %i", i++, p->device->name, @@ -123,7 +123,7 @@ COMMAND_HANDLER(handle_nand_info_command) else bad_state = " (block condition unknown)"; - command_print(CMD_CTX, + command_print(CMD, "\t#%i: 0x%8.8" PRIx32 " (%" PRId32 "kB) %s%s", j, p->blocks[j].offset, @@ -147,7 +147,7 @@ COMMAND_HANDLER(handle_nand_probe_command) retval = nand_probe(p); if (retval == ERROR_OK) { - command_print(CMD_CTX, "NAND flash device '%s (%s)' found", + command_print(CMD, "NAND flash device '%s (%s)' found", p->device->name, p->manufacturer->name); } @@ -189,7 +189,7 @@ COMMAND_HANDLER(handle_nand_erase_command) retval = nand_erase(p, offset, offset + length - 1); if (retval == ERROR_OK) { - command_print(CMD_CTX, "erased blocks %lu to %lu " + command_print(CMD, "erased blocks %lu to %lu " "on NAND flash device #%s '%s'", offset, offset + length - 1, CMD_ARGV[0], p->device->name); @@ -233,7 +233,7 @@ COMMAND_HANDLER(handle_nand_check_bad_blocks_command) retval = nand_build_bbt(p, first, last); if (retval == ERROR_OK) { - command_print(CMD_CTX, "checked NAND flash device for bad blocks, " + command_print(CMD, "checked NAND flash device for bad blocks, " "use \"nand info\" command to list blocks"); } @@ -253,7 +253,7 @@ COMMAND_HANDLER(handle_nand_write_command) while (s.size > 0) { int bytes_read = nand_fileio_read(nand, &s); if (bytes_read <= 0) { - command_print(CMD_CTX, "error while reading file"); + command_print(CMD, "error while reading file"); nand_fileio_cleanup(&s); return ERROR_FAIL; } @@ -262,7 +262,7 @@ COMMAND_HANDLER(handle_nand_write_command) retval = nand_write_page(nand, s.address / nand->page_size, s.page, s.page_size, s.oob, s.oob_size); if (ERROR_OK != retval) { - command_print(CMD_CTX, "failed writing file %s " + command_print(CMD, "failed writing file %s " "to NAND flash %s at offset 0x%8.8" PRIx32, CMD_ARGV[1], CMD_ARGV[0], s.address); nand_fileio_cleanup(&s); @@ -272,7 +272,7 @@ COMMAND_HANDLER(handle_nand_write_command) } if (nand_fileio_finish(&s) == ERROR_OK) { - command_print(CMD_CTX, "wrote file %s to NAND flash %s up to " + command_print(CMD, "wrote file %s to NAND flash %s up to " "offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)", CMD_ARGV[1], CMD_ARGV[0], s.address, duration_elapsed(&s.bench), duration_kbps(&s.bench, total_bytes)); @@ -294,7 +294,7 @@ COMMAND_HANDLER(handle_nand_verify_command) dev.address = file.address; dev.size = file.size; dev.oob_format = file.oob_format; - retval = nand_fileio_start(CMD_CTX, nand, NULL, FILEIO_NONE, &dev); + retval = nand_fileio_start(CMD, nand, NULL, FILEIO_NONE, &dev); if (ERROR_OK != retval) return retval; @@ -302,7 +302,7 @@ COMMAND_HANDLER(handle_nand_verify_command) retval = nand_read_page(nand, dev.address / dev.page_size, dev.page, dev.page_size, dev.oob, dev.oob_size); if (ERROR_OK != retval) { - command_print(CMD_CTX, "reading NAND flash page failed"); + command_print(CMD, "reading NAND flash page failed"); nand_fileio_cleanup(&dev); nand_fileio_cleanup(&file); return retval; @@ -310,7 +310,7 @@ COMMAND_HANDLER(handle_nand_verify_command) int bytes_read = nand_fileio_read(nand, &file); if (bytes_read <= 0) { - command_print(CMD_CTX, "error while reading file"); + command_print(CMD, "error while reading file"); nand_fileio_cleanup(&dev); nand_fileio_cleanup(&file); return ERROR_FAIL; @@ -318,7 +318,7 @@ COMMAND_HANDLER(handle_nand_verify_command) if ((dev.page && memcmp(dev.page, file.page, dev.page_size)) || (dev.oob && memcmp(dev.oob, file.oob, dev.oob_size))) { - command_print(CMD_CTX, "NAND flash contents differ " + command_print(CMD, "NAND flash contents differ " "at 0x%8.8" PRIx32, dev.address); nand_fileio_cleanup(&dev); nand_fileio_cleanup(&file); @@ -330,7 +330,7 @@ COMMAND_HANDLER(handle_nand_verify_command) } if (nand_fileio_finish(&file) == ERROR_OK) { - command_print(CMD_CTX, "verified file %s in NAND flash %s " + command_print(CMD, "verified file %s in NAND flash %s " "up to offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)", CMD_ARGV[1], CMD_ARGV[0], dev.address, duration_elapsed(&file.bench), duration_kbps(&file.bench, dev.size)); @@ -354,7 +354,7 @@ COMMAND_HANDLER(handle_nand_dump_command) retval = nand_read_page(nand, s.address / nand->page_size, s.page, s.page_size, s.oob, s.oob_size); if (ERROR_OK != retval) { - command_print(CMD_CTX, "reading NAND flash page failed"); + command_print(CMD, "reading NAND flash page failed"); nand_fileio_cleanup(&s); return retval; } @@ -374,7 +374,7 @@ COMMAND_HANDLER(handle_nand_dump_command) return retval; if (nand_fileio_finish(&s) == ERROR_OK) { - command_print(CMD_CTX, "dumped %zu bytes in %fs (%0.3f KiB/s)", + command_print(CMD, "dumped %zu bytes in %fs (%0.3f KiB/s)", filesize, duration_elapsed(&s.bench), duration_kbps(&s.bench, filesize)); } @@ -392,7 +392,7 @@ COMMAND_HANDLER(handle_nand_raw_access_command) return retval; if (NULL == p->device) { - command_print(CMD_CTX, "#%s: not probed", CMD_ARGV[0]); + command_print(CMD, "#%s: not probed", CMD_ARGV[0]); return ERROR_OK; } @@ -400,7 +400,7 @@ COMMAND_HANDLER(handle_nand_raw_access_command) COMMAND_PARSE_ENABLE(CMD_ARGV[1], p->use_raw); const char *msg = p->use_raw ? "enabled" : "disabled"; - command_print(CMD_CTX, "raw access is %s", msg); + command_print(CMD, "raw access is %s", msg); return ERROR_OK; } @@ -411,6 +411,7 @@ static const struct command_registration nand_exec_command_handlers[] = { .handler = handle_nand_list_command, .mode = COMMAND_EXEC, .help = "list configured NAND flash devices", + .usage = "", }, { .name = "info", @@ -500,15 +501,15 @@ COMMAND_HANDLER(handle_nand_init_command) static int nand_list_walker(struct nand_flash_controller *c, void *x) { - struct command_context *cmd_ctx = x; - command_print(cmd_ctx, " %s", c->name); + struct command_invocation *cmd = x; + command_print(cmd, " %s", c->name); return ERROR_OK; } COMMAND_HANDLER(handle_nand_list_drivers) { - command_print(CMD_CTX, "Available NAND flash controller drivers:"); - return nand_driver_walk(&nand_list_walker, CMD_CTX); + command_print(CMD, "Available NAND flash controller drivers:"); + return nand_driver_walk(&nand_list_walker, CMD); } static COMMAND_HELPER(create_nand_device, const char *bank_name, diff --git a/src/flash/nor/Makefile.am b/src/flash/nor/Makefile.am index 135128e..34f91ce 100644 --- a/src/flash/nor/Makefile.am +++ b/src/flash/nor/Makefile.am @@ -63,6 +63,7 @@ NOR_DRIVERS = \ %D%/str7x.c \ %D%/str9x.c \ %D%/str9xpec.c \ + %D%/swm050.c \ %D%/tms470.c \ %D%/virtual.c \ %D%/w600.c \ diff --git a/src/flash/nor/ambiqmicro.c b/src/flash/nor/ambiqmicro.c index a536d54..b1e3e72 100644 --- a/src/flash/nor/ambiqmicro.c +++ b/src/flash/nor/ambiqmicro.c @@ -791,9 +791,9 @@ COMMAND_HANDLER(ambiqmicro_handle_mass_erase_command) for (i = 0; i < bank->num_sectors; i++) bank->sectors[i].is_erased = 1; - command_print(CMD_CTX, "ambiqmicro mass erase complete"); + command_print(CMD, "ambiqmicro mass erase complete"); } else - command_print(CMD_CTX, "ambiqmicro mass erase failed"); + command_print(CMD, "ambiqmicro mass erase failed"); return ERROR_OK; } @@ -815,9 +815,9 @@ COMMAND_HANDLER(ambiqmicro_handle_page_erase_command) return retval; if (ambiqmicro_erase(bank, first, last) == ERROR_OK) - command_print(CMD_CTX, "ambiqmicro page erase complete"); + command_print(CMD, "ambiqmicro page erase complete"); else - command_print(CMD_CTX, "ambiqmicro page erase failed"); + command_print(CMD, "ambiqmicro page erase failed"); return ERROR_OK; } @@ -838,7 +838,7 @@ COMMAND_HANDLER(ambiqmicro_handle_program_otp_command) COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], offset); COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], count); - command_print(CMD_CTX, "offset=0x%08x count=%d", offset, count); + command_print(CMD, "offset=0x%08x count=%d", offset, count); CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank); diff --git a/src/flash/nor/at91sam3.c b/src/flash/nor/at91sam3.c index 2d61a87..2457c15 100644 --- a/src/flash/nor/at91sam3.c +++ b/src/flash/nor/at91sam3.c @@ -249,14 +249,14 @@ struct sam3_reg_list { static struct sam3_chip *all_sam3_chips; -static struct sam3_chip *get_current_sam3(struct command_context *cmd_ctx) +static struct sam3_chip *get_current_sam3(struct command_invocation *cmd) { struct target *t; static struct sam3_chip *p; - t = get_current_target(cmd_ctx); + t = get_current_target(cmd->ctx); if (!t) { - command_print(cmd_ctx, "No current target?"); + command_print(cmd, "No current target?"); return NULL; } @@ -264,7 +264,7 @@ static struct sam3_chip *get_current_sam3(struct command_context *cmd_ctx) if (!p) { /* this should not happen */ /* the command is not registered until the chip is created? */ - command_print(cmd_ctx, "No SAM3 chips exist?"); + command_print(cmd, "No SAM3 chips exist?"); return NULL; } @@ -273,7 +273,7 @@ static struct sam3_chip *get_current_sam3(struct command_context *cmd_ctx) return p; p = p->next; } - command_print(cmd_ctx, "Cannot find SAM3 chip?"); + command_print(cmd, "Cannot find SAM3 chip?"); return NULL; } @@ -3538,7 +3538,7 @@ done: COMMAND_HANDLER(sam3_handle_info_command) { struct sam3_chip *pChip; - pChip = get_current_sam3(CMD_CTX); + pChip = get_current_sam3(CMD); if (!pChip) return ERROR_OK; @@ -3549,7 +3549,7 @@ COMMAND_HANDLER(sam3_handle_info_command) if (pChip->details.bank[0].pBank == NULL) { x = 0; need_define: - command_print(CMD_CTX, + command_print(CMD, "Please define bank %d via command: flash bank %s ... ", x, at91sam3_flash.name); @@ -3598,7 +3598,7 @@ COMMAND_HANDLER(sam3_handle_gpnvm_command) int r, who; struct sam3_chip *pChip; - pChip = get_current_sam3(CMD_CTX); + pChip = get_current_sam3(CMD); if (!pChip) return ERROR_OK; @@ -3608,7 +3608,7 @@ COMMAND_HANDLER(sam3_handle_gpnvm_command) } if (pChip->details.bank[0].pBank == NULL) { - command_print(CMD_CTX, "Bank0 must be defined first via: flash bank %s ...", + command_print(CMD, "Bank0 must be defined first via: flash bank %s ...", at91sam3_flash.name); return ERROR_FAIL; } @@ -3647,22 +3647,22 @@ showall: r = FLASHD_GetGPNVM(&(pChip->details.bank[0]), x, &v); if (r != ERROR_OK) break; - command_print(CMD_CTX, "sam3-gpnvm%u: %u", x, v); + command_print(CMD, "sam3-gpnvm%u: %u", x, v); } return r; } if ((who >= 0) && (((unsigned)(who)) < pChip->details.n_gpnvms)) { r = FLASHD_GetGPNVM(&(pChip->details.bank[0]), who, &v); - command_print(CMD_CTX, "sam3-gpnvm%u: %u", who, v); + command_print(CMD, "sam3-gpnvm%u: %u", who, v); return r; } else { - command_print(CMD_CTX, "sam3-gpnvm invalid GPNVM: %u", who); + command_print(CMD, "sam3-gpnvm invalid GPNVM: %u", who); return ERROR_COMMAND_SYNTAX_ERROR; } } if (who == -1) { - command_print(CMD_CTX, "Missing GPNVM number"); + command_print(CMD, "Missing GPNVM number"); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -3672,7 +3672,7 @@ showall: (0 == strcmp("clear", CMD_ARGV[0]))) /* quietly accept both */ r = FLASHD_ClrGPNVM(&(pChip->details.bank[0]), who); else { - command_print(CMD_CTX, "Unknown command: %s", CMD_ARGV[0]); + command_print(CMD, "Unknown command: %s", CMD_ARGV[0]); r = ERROR_COMMAND_SYNTAX_ERROR; } return r; @@ -3682,7 +3682,7 @@ COMMAND_HANDLER(sam3_handle_slowclk_command) { struct sam3_chip *pChip; - pChip = get_current_sam3(CMD_CTX); + pChip = get_current_sam3(CMD); if (!pChip) return ERROR_OK; @@ -3697,7 +3697,7 @@ COMMAND_HANDLER(sam3_handle_slowclk_command) COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], v); if (v > 200000) { /* absurd slow clock of 200Khz? */ - command_print(CMD_CTX, "Absurd/illegal slow clock freq: %d\n", (int)(v)); + command_print(CMD, "Absurd/illegal slow clock freq: %d\n", (int)(v)); return ERROR_COMMAND_SYNTAX_ERROR; } pChip->cfg.slow_freq = v; @@ -3705,11 +3705,11 @@ COMMAND_HANDLER(sam3_handle_slowclk_command) } default: /* error */ - command_print(CMD_CTX, "Too many parameters"); + command_print(CMD, "Too many parameters"); return ERROR_COMMAND_SYNTAX_ERROR; break; } - command_print(CMD_CTX, "Slowclk freq: %d.%03dkhz", + command_print(CMD, "Slowclk freq: %d.%03dkhz", (int)(pChip->cfg.slow_freq / 1000), (int)(pChip->cfg.slow_freq % 1000)); return ERROR_OK; @@ -3731,6 +3731,7 @@ static const struct command_registration at91sam3_exec_command_handlers[] = { .mode = COMMAND_EXEC, .help = "Print information about the current at91sam3 chip" "and its flash configuration.", + .usage = "", }, { .name = "slowclk", diff --git a/src/flash/nor/at91sam4.c b/src/flash/nor/at91sam4.c index 446f798..621754c 100644 --- a/src/flash/nor/at91sam4.c +++ b/src/flash/nor/at91sam4.c @@ -228,14 +228,14 @@ struct sam4_reg_list { static struct sam4_chip *all_sam4_chips; -static struct sam4_chip *get_current_sam4(struct command_context *cmd_ctx) +static struct sam4_chip *get_current_sam4(struct command_invocation *cmd) { struct target *t; static struct sam4_chip *p; - t = get_current_target(cmd_ctx); + t = get_current_target(cmd->ctx); if (!t) { - command_print(cmd_ctx, "No current target?"); + command_print(cmd, "No current target?"); return NULL; } @@ -243,7 +243,7 @@ static struct sam4_chip *get_current_sam4(struct command_context *cmd_ctx) if (!p) { /* this should not happen */ /* the command is not registered until the chip is created? */ - command_print(cmd_ctx, "No SAM4 chips exist?"); + command_print(cmd, "No SAM4 chips exist?"); return NULL; } @@ -252,7 +252,7 @@ static struct sam4_chip *get_current_sam4(struct command_context *cmd_ctx) return p; p = p->next; } - command_print(cmd_ctx, "Cannot find SAM4 chip?"); + command_print(cmd, "Cannot find SAM4 chip?"); return NULL; } @@ -3018,7 +3018,7 @@ done: COMMAND_HANDLER(sam4_handle_info_command) { struct sam4_chip *pChip; - pChip = get_current_sam4(CMD_CTX); + pChip = get_current_sam4(CMD); if (!pChip) return ERROR_OK; @@ -3029,7 +3029,7 @@ COMMAND_HANDLER(sam4_handle_info_command) if (pChip->details.bank[0].pBank == NULL) { x = 0; need_define: - command_print(CMD_CTX, + command_print(CMD, "Please define bank %d via command: flash bank %s ... ", x, at91sam4_flash.name); @@ -3078,7 +3078,7 @@ COMMAND_HANDLER(sam4_handle_gpnvm_command) int r, who; struct sam4_chip *pChip; - pChip = get_current_sam4(CMD_CTX); + pChip = get_current_sam4(CMD); if (!pChip) return ERROR_OK; @@ -3088,7 +3088,7 @@ COMMAND_HANDLER(sam4_handle_gpnvm_command) } if (pChip->details.bank[0].pBank == NULL) { - command_print(CMD_CTX, "Bank0 must be defined first via: flash bank %s ...", + command_print(CMD, "Bank0 must be defined first via: flash bank %s ...", at91sam4_flash.name); return ERROR_FAIL; } @@ -3127,23 +3127,23 @@ showall: r = FLASHD_GetGPNVM(&(pChip->details.bank[0]), x, &v); if (r != ERROR_OK) break; - command_print(CMD_CTX, "sam4-gpnvm%u: %u", x, v); + command_print(CMD, "sam4-gpnvm%u: %u", x, v); } return r; } if ((who >= 0) && (((unsigned)(who)) < pChip->details.n_gpnvms)) { r = FLASHD_GetGPNVM(&(pChip->details.bank[0]), who, &v); if (r == ERROR_OK) - command_print(CMD_CTX, "sam4-gpnvm%u: %u", who, v); + command_print(CMD, "sam4-gpnvm%u: %u", who, v); return r; } else { - command_print(CMD_CTX, "sam4-gpnvm invalid GPNVM: %u", who); + command_print(CMD, "sam4-gpnvm invalid GPNVM: %u", who); return ERROR_COMMAND_SYNTAX_ERROR; } } if (who == -1) { - command_print(CMD_CTX, "Missing GPNVM number"); + command_print(CMD, "Missing GPNVM number"); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -3153,7 +3153,7 @@ showall: (0 == strcmp("clear", CMD_ARGV[0]))) /* quietly accept both */ r = FLASHD_ClrGPNVM(&(pChip->details.bank[0]), who); else { - command_print(CMD_CTX, "Unknown command: %s", CMD_ARGV[0]); + command_print(CMD, "Unknown command: %s", CMD_ARGV[0]); r = ERROR_COMMAND_SYNTAX_ERROR; } return r; @@ -3163,7 +3163,7 @@ COMMAND_HANDLER(sam4_handle_slowclk_command) { struct sam4_chip *pChip; - pChip = get_current_sam4(CMD_CTX); + pChip = get_current_sam4(CMD); if (!pChip) return ERROR_OK; @@ -3178,7 +3178,7 @@ COMMAND_HANDLER(sam4_handle_slowclk_command) COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], v); if (v > 200000) { /* absurd slow clock of 200Khz? */ - command_print(CMD_CTX, "Absurd/illegal slow clock freq: %d\n", (int)(v)); + command_print(CMD, "Absurd/illegal slow clock freq: %d\n", (int)(v)); return ERROR_COMMAND_SYNTAX_ERROR; } pChip->cfg.slow_freq = v; @@ -3186,11 +3186,11 @@ COMMAND_HANDLER(sam4_handle_slowclk_command) } default: /* error */ - command_print(CMD_CTX, "Too many parameters"); + command_print(CMD, "Too many parameters"); return ERROR_COMMAND_SYNTAX_ERROR; break; } - command_print(CMD_CTX, "Slowclk freq: %d.%03dkhz", + command_print(CMD, "Slowclk freq: %d.%03dkhz", (int)(pChip->cfg.slow_freq / 1000), (int)(pChip->cfg.slow_freq % 1000)); return ERROR_OK; @@ -3212,6 +3212,7 @@ static const struct command_registration at91sam4_exec_command_handlers[] = { .mode = COMMAND_EXEC, .help = "Print information about the current at91sam4 chip" "and its flash configuration.", + .usage = "", }, { .name = "slowclk", diff --git a/src/flash/nor/at91sam4l.c b/src/flash/nor/at91sam4l.c index 1c2402f..d356398 100644 --- a/src/flash/nor/at91sam4l.c +++ b/src/flash/nor/at91sam4l.c @@ -668,7 +668,8 @@ static const struct command_registration at91sam4l_exec_command_handlers[] = { .name = "smap_reset_deassert", .handler = sam4l_handle_reset_deassert, .mode = COMMAND_EXEC, - .help = "deasert internal reset held by SMAP" + .help = "deassert internal reset held by SMAP", + .usage = "", }, COMMAND_REGISTRATION_DONE }; diff --git a/src/flash/nor/at91sam7.c b/src/flash/nor/at91sam7.c index 15b93a2..232260b 100644 --- a/src/flash/nor/at91sam7.c +++ b/src/flash/nor/at91sam7.c @@ -1067,7 +1067,7 @@ COMMAND_HANDLER(at91sam7_handle_gpnvm_command) if (bank == NULL) return ERROR_FLASH_BANK_INVALID; if (strcmp(bank->driver->name, "at91sam7")) { - command_print(CMD_CTX, "not an at91sam7 flash bank '%s'", CMD_ARGV[0]); + command_print(CMD, "not an at91sam7 flash bank '%s'", CMD_ARGV[0]); return ERROR_FLASH_BANK_INVALID; } if (bank->target->state != TARGET_HALTED) { @@ -1091,7 +1091,7 @@ COMMAND_HANDLER(at91sam7_handle_gpnvm_command) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], bit); if ((bit < 0) || (bit >= at91sam7_info->num_nvmbits)) { - command_print(CMD_CTX, + command_print(CMD, "gpnvm bit '#%s' is out of bounds for target %s", CMD_ARGV[0], at91sam7_info->target_name); diff --git a/src/flash/nor/at91samd.c b/src/flash/nor/at91samd.c index ad0da5d..b6cff9a 100644 --- a/src/flash/nor/at91samd.c +++ b/src/flash/nor/at91samd.c @@ -947,9 +947,9 @@ COMMAND_HANDLER(samd_handle_chip_erase_command) * perform the erase. */ res = target_write_u8(target, SAMD_DSU + SAMD_DSU_CTRL_EXT, (1<<4)); if (res == ERROR_OK) - command_print(CMD_CTX, "chip erase started"); + command_print(CMD, "chip erase started"); else - command_print(CMD_CTX, "write to DSU CTRL failed"); + command_print(CMD, "write to DSU CTRL failed"); } return res; @@ -961,7 +961,7 @@ COMMAND_HANDLER(samd_handle_set_security_command) struct target *target = get_current_target(CMD_CTX); if (CMD_ARGC < 1 || (CMD_ARGC >= 1 && (strcmp(CMD_ARGV[0], "enable")))) { - command_print(CMD_CTX, "supply the \"enable\" argument to proceed."); + command_print(CMD, "supply the \"enable\" argument to proceed."); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -975,9 +975,9 @@ COMMAND_HANDLER(samd_handle_set_security_command) /* Check (and clear) error conditions */ if (res == ERROR_OK) - command_print(CMD_CTX, "chip secured on next power-cycle"); + command_print(CMD, "chip secured on next power-cycle"); else - command_print(CMD_CTX, "failed to secure chip"); + command_print(CMD, "failed to secure chip"); } return res; @@ -1008,7 +1008,7 @@ COMMAND_HANDLER(samd_handle_eeprom_command) } if (code > 6) { - command_print(CMD_CTX, "Invalid EEPROM size. Please see " + command_print(CMD, "Invalid EEPROM size. Please see " "datasheet for a list valid sizes."); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1022,10 +1022,10 @@ COMMAND_HANDLER(samd_handle_eeprom_command) uint32_t size = ((val >> 4) & 0x7); /* grab size code */ if (size == 0x7) - command_print(CMD_CTX, "EEPROM is disabled"); + command_print(CMD, "EEPROM is disabled"); else { /* Otherwise, 6 is 256B, 0 is 16KB */ - command_print(CMD_CTX, "EEPROM size is %u bytes", + command_print(CMD, "EEPROM size is %u bytes", (2 << (13 - size))); } } @@ -1038,7 +1038,7 @@ COMMAND_HANDLER(samd_handle_eeprom_command) static COMMAND_HELPER(get_u64_from_hexarg, unsigned int num, uint64_t *value) { if (num >= CMD_ARGC) { - command_print(CMD_CTX, "Too few Arguments."); + command_print(CMD, "Too few Arguments."); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1049,12 +1049,12 @@ static COMMAND_HELPER(get_u64_from_hexarg, unsigned int num, uint64_t *value) *value = strtoull(&(CMD_ARGV[num][2]), &check, 16); if ((value == 0 && errno == ERANGE) || check == NULL || *check != 0) { - command_print(CMD_CTX, "Invalid 64-bit hex value in argument %d.", + command_print(CMD, "Invalid 64-bit hex value in argument %d.", num + 1); return ERROR_COMMAND_SYNTAX_ERROR; } } else { - command_print(CMD_CTX, "Argument %d needs to be a hex value.", num + 1); + command_print(CMD, "Argument %d needs to be a hex value.", num + 1); return ERROR_COMMAND_SYNTAX_ERROR; } return ERROR_OK; @@ -1067,7 +1067,7 @@ COMMAND_HANDLER(samd_handle_nvmuserrow_command) if (target) { if (CMD_ARGC > 2) { - command_print(CMD_CTX, "Too much Arguments given."); + command_print(CMD, "Too much Arguments given."); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1105,7 +1105,7 @@ COMMAND_HANDLER(samd_handle_nvmuserrow_command) uint64_t value; res = read_userrow(target, &value); if (res == ERROR_OK) - command_print(CMD_CTX, "NVMUSERROW: 0x%016"PRIX64, value); + command_print(CMD, "NVMUSERROW: 0x%016"PRIX64, value); else LOG_ERROR("NVMUSERROW could not be read."); } @@ -1145,7 +1145,7 @@ COMMAND_HANDLER(samd_handle_bootloader_command) } if (code > 6) { - command_print(CMD_CTX, "Invalid bootloader size. Please " + command_print(CMD, "Invalid bootloader size. Please " "see datasheet for a list valid sizes."); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1166,7 +1166,7 @@ COMMAND_HANDLER(samd_handle_bootloader_command) nb = (2 << (8 - size)) * page_size; /* There are 4 pages per row */ - command_print(CMD_CTX, "Bootloader size is %" PRIu32 " bytes (%" PRIu32 " rows)", + command_print(CMD, "Bootloader size is %" PRIu32 " bytes (%" PRIu32 " rows)", nb, (uint32_t)(nb / (page_size * 4))); } } @@ -1217,7 +1217,8 @@ static const struct command_registration at91samd_exec_command_handlers[] = { .name = "dsu_reset_deassert", .handler = samd_handle_reset_deassert, .mode = COMMAND_EXEC, - .help = "Deasert internal reset held by DSU." + .help = "Deassert internal reset held by DSU.", + .usage = "", }, { .name = "info", @@ -1225,6 +1226,7 @@ static const struct command_registration at91samd_exec_command_handlers[] = { .mode = COMMAND_EXEC, .help = "Print information about the current at91samd chip " "and its flash configuration.", + .usage = "", }, { .name = "chip-erase", @@ -1232,6 +1234,7 @@ static const struct command_registration at91samd_exec_command_handlers[] = { .mode = COMMAND_EXEC, .help = "Erase the entire Flash by using the Chip-" "Erase feature in the Device Service Unit (DSU).", + .usage = "", }, { .name = "set-security", @@ -1241,6 +1244,7 @@ static const struct command_registration at91samd_exec_command_handlers[] = { "This makes it impossible to read the Flash contents. " "The only way to undo this is to issue the chip-erase " "command.", + .usage = "'enable'", }, { .name = "eeprom", diff --git a/src/flash/nor/atsame5.c b/src/flash/nor/atsame5.c index 833177e..eac7847 100644 --- a/src/flash/nor/atsame5.c +++ b/src/flash/nor/atsame5.c @@ -765,9 +765,9 @@ COMMAND_HANDLER(same5_handle_chip_erase_command) * perform the erase. */ int res = target_write_u8(target, SAMD_DSU + SAMD_DSU_CTRL_EXT, (1<<4)); if (res == ERROR_OK) - command_print(CMD_CTX, "chip erase started"); + command_print(CMD, "chip erase started"); else - command_print(CMD_CTX, "write to DSU CTRL failed"); + command_print(CMD, "write to DSU CTRL failed"); return res; } @@ -781,7 +781,7 @@ COMMAND_HANDLER(same5_handle_userpage_command) return ERROR_FAIL; if (CMD_ARGC > 2) { - command_print(CMD_CTX, "Too much Arguments given."); + command_print(CMD, "Too much Arguments given."); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -806,7 +806,7 @@ COMMAND_HANDLER(same5_handle_userpage_command) int res2 = target_read_memory(target, SAMD_USER_ROW, 4, 2, buffer); if (res2 == ERROR_OK) { uint64_t value = target_buffer_get_u64(target, buffer); - command_print(CMD_CTX, "USER PAGE: 0x%016"PRIX64, value); + command_print(CMD, "USER PAGE: 0x%016"PRIX64, value); } else { LOG_ERROR("USER PAGE could not be read."); } @@ -829,7 +829,7 @@ COMMAND_HANDLER(same5_handle_bootloader_command) unsigned long size = strtoul(CMD_ARGV[0], NULL, 0); uint32_t code = (size + 8191) / 8192; if (code > 15) { - command_print(CMD_CTX, "Invalid bootloader size. Please " + command_print(CMD, "Invalid bootloader size. Please " "see datasheet for a list valid sizes."); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -842,7 +842,7 @@ COMMAND_HANDLER(same5_handle_bootloader_command) if (res2 == ERROR_OK) { uint32_t code = (val >> 26) & 0xf; /* grab size code */ uint32_t size = (15 - code) * 8192; - command_print(CMD_CTX, "Bootloader protected in the first %" + command_print(CMD, "Bootloader protected in the first %" PRIu32 " bytes", size); } @@ -893,12 +893,14 @@ COMMAND_HANDLER(samd_handle_reset_deassert) static const struct command_registration same5_exec_command_handlers[] = { { .name = "dsu_reset_deassert", + .usage = "", .handler = samd_handle_reset_deassert, .mode = COMMAND_EXEC, - .help = "Deasert internal reset held by DSU." + .help = "Deassert internal reset held by DSU." }, { .name = "chip-erase", + .usage = "", .handler = same5_handle_chip_erase_command, .mode = COMMAND_EXEC, .help = "Erase the entire Flash by using the Chip-" diff --git a/src/flash/nor/atsamv.c b/src/flash/nor/atsamv.c index 5beeefc..d6f1a0a 100644 --- a/src/flash/nor/atsamv.c +++ b/src/flash/nor/atsamv.c @@ -672,22 +672,22 @@ showall: r = samv_get_gpnvm(target, x, &v); if (r != ERROR_OK) break; - command_print(CMD_CTX, "samv-gpnvm%u: %u", x, v); + command_print(CMD, "samv-gpnvm%u: %u", x, v); } return r; } if ((who >= 0) && (((unsigned)who) < SAMV_NUM_GPNVM_BITS)) { r = samv_get_gpnvm(target, who, &v); - command_print(CMD_CTX, "samv-gpnvm%u: %u", who, v); + command_print(CMD, "samv-gpnvm%u: %u", who, v); return r; } else { - command_print(CMD_CTX, "invalid gpnvm: %u", who); + command_print(CMD, "invalid gpnvm: %u", who); return ERROR_COMMAND_SYNTAX_ERROR; } } if (who == -1) { - command_print(CMD_CTX, "missing gpnvm number"); + command_print(CMD, "missing gpnvm number"); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -696,7 +696,7 @@ showall: else if (!strcmp("clr", CMD_ARGV[0]) || !strcmp("clear", CMD_ARGV[0])) r = samv_clear_gpnvm(target, who); else { - command_print(CMD_CTX, "unknown command: %s", CMD_ARGV[0]); + command_print(CMD, "unknown command: %s", CMD_ARGV[0]); r = ERROR_COMMAND_SYNTAX_ERROR; } return r; diff --git a/src/flash/nor/avrf.c b/src/flash/nor/avrf.c index 6969f77..178567e 100644 --- a/src/flash/nor/avrf.c +++ b/src/flash/nor/avrf.c @@ -433,9 +433,9 @@ COMMAND_HANDLER(avrf_handle_mass_erase_command) for (i = 0; i < bank->num_sectors; i++) bank->sectors[i].is_erased = 1; - command_print(CMD_CTX, "avr mass erase complete"); + command_print(CMD, "avr mass erase complete"); } else - command_print(CMD_CTX, "avr mass erase failed"); + command_print(CMD, "avr mass erase failed"); LOG_DEBUG("%s", __func__); return ERROR_OK; diff --git a/src/flash/nor/core.h b/src/flash/nor/core.h index f6bd0cf..ff5cb60 100644 --- a/src/flash/nor/core.h +++ b/src/flash/nor/core.h @@ -45,9 +45,12 @@ struct flash_sector { uint32_t size; /** * Indication of erasure status: 0 = not erased, 1 = erased, - * other = unknown. Set by @c flash_driver_s::erase_check. + * other = unknown. Set by @c flash_driver_s::erase_check only. * - * Flag is not used in protection block + * This information must be considered stale immediately. + * Don't set it in flash_driver_s::erase or a device mass_erase + * Don't clear it in flash_driver_s::write + * The flag is not used in a protection block */ int is_erased; /** @@ -118,7 +121,7 @@ struct flash_bank { /** * The number of sectors on this chip. This value will - * be set intially to 0, and the flash driver must set this to + * be set initially to 0, and the flash driver must set this to * some non-zero value during "probe()" or "auto_probe()". */ int num_sectors; @@ -127,12 +130,12 @@ struct flash_bank { /** * The number of protection blocks in this bank. This value - * is set intially to 0 and sectors are used as protection blocks. + * is set initially to 0 and sectors are used as protection blocks. * Driver probe can set protection blocks array to work with * protection granularity different than sector size. */ int num_prot_blocks; - /** Array of protection blocks, allocated and initilized by the flash driver */ + /** Array of protection blocks, allocated and initialized by the flash driver */ struct flash_sector *prot_blocks; struct flash_bank *next; /**< The next flash bank on this chip */ @@ -239,8 +242,8 @@ struct flash_bank *get_flash_bank_by_name_noprobe(const char *name); */ int get_flash_bank_by_num(int num, struct flash_bank **bank); /** - * Retreives @a bank from a command argument, reporting errors parsing - * the bank identifier or retreiving the specified bank. The bank + * Retrieves @a bank from a command argument, reporting errors parsing + * the bank identifier or retrieving the specified bank. The bank * may be identified by its bank number or by @c name.instance, where * @a instance is driver-specific. * @param name_index The index to the string in args containing the diff --git a/src/flash/nor/drivers.c b/src/flash/nor/drivers.c index 955d149..551f389 100644 --- a/src/flash/nor/drivers.c +++ b/src/flash/nor/drivers.c @@ -77,6 +77,7 @@ extern const struct flash_driver stmsmi_flash; extern const struct flash_driver str7x_flash; extern const struct flash_driver str9x_flash; extern const struct flash_driver str9xpec_flash; +extern const struct flash_driver swm050_flash; extern const struct flash_driver tms470_flash; extern const struct flash_driver virtual_flash; extern const struct flash_driver w600_flash; @@ -146,6 +147,7 @@ static const struct flash_driver * const flash_drivers[] = { &str7x_flash, &str9x_flash, &str9xpec_flash, + &swm050_flash, &tms470_flash, &virtual_flash, &xcf_flash, diff --git a/src/flash/nor/efm32.c b/src/flash/nor/efm32.c index d2ac3a8..83d133f 100644 --- a/src/flash/nor/efm32.c +++ b/src/flash/nor/efm32.c @@ -1093,7 +1093,7 @@ COMMAND_HANDLER(efm32x_handle_debuglock_command) return retval; } - command_print(CMD_CTX, "efm32x debug interface locked, reset the device to apply"); + command_print(CMD, "efm32x debug interface locked, reset the device to apply"); return ERROR_OK; } diff --git a/src/flash/nor/em357.c b/src/flash/nor/em357.c index e6b2728..38fb731 100644 --- a/src/flash/nor/em357.c +++ b/src/flash/nor/em357.c @@ -776,7 +776,7 @@ COMMAND_HANDLER(em357_handle_lock_command) } if (em357_erase_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "em357 failed to erase options"); + command_print(CMD, "em357 failed to erase options"); return ERROR_OK; } @@ -784,11 +784,11 @@ COMMAND_HANDLER(em357_handle_lock_command) em357_info->option_bytes.RDP = 0; if (em357_write_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "em357 failed to lock device"); + command_print(CMD, "em357 failed to lock device"); return ERROR_OK; } - command_print(CMD_CTX, "em357 locked"); + command_print(CMD, "em357 locked"); return ERROR_OK; } @@ -813,16 +813,16 @@ COMMAND_HANDLER(em357_handle_unlock_command) } if (em357_erase_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "em357 failed to unlock device"); + command_print(CMD, "em357 failed to unlock device"); return ERROR_OK; } if (em357_write_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "em357 failed to lock device"); + command_print(CMD, "em357 failed to lock device"); return ERROR_OK; } - command_print(CMD_CTX, "em357 unlocked.\n" + command_print(CMD, "em357 unlocked.\n" "INFO: a reset or power cycle is required " "for the new settings to take effect."); @@ -886,9 +886,9 @@ COMMAND_HANDLER(em357_handle_mass_erase_command) for (i = 0; i < bank->num_sectors; i++) bank->sectors[i].is_erased = 1; - command_print(CMD_CTX, "em357 mass erase complete"); + command_print(CMD, "em357 mass erase complete"); } else - command_print(CMD_CTX, "em357 mass erase failed"); + command_print(CMD, "em357 mass erase failed"); return retval; } diff --git a/src/flash/nor/esirisc_flash.c b/src/flash/nor/esirisc_flash.c index 948d001..3bed065 100644 --- a/src/flash/nor/esirisc_flash.c +++ b/src/flash/nor/esirisc_flash.c @@ -92,7 +92,7 @@ #endif #define CONTROL_TIMEOUT 5000 /* 5s */ -#define PAGE_SIZE 4096 +#define FLASH_PAGE_SIZE 4096 #define PB_MAX 32 #define NUM_NS_PER_S 1000000000ULL @@ -264,7 +264,7 @@ static int esirisc_flash_erase(struct flash_bank *bank, int first, int last) (void)esirisc_flash_disable_protect(bank); for (int page = first; page < last; ++page) { - uint32_t address = page * PAGE_SIZE; + uint32_t address = page * FLASH_PAGE_SIZE; target_write_u32(target, esirisc_info->cfg + ADDRESS, address); @@ -464,8 +464,8 @@ static int esirisc_flash_probe(struct flash_bank *bank) if (target->state != TARGET_HALTED) return ERROR_TARGET_NOT_HALTED; - bank->num_sectors = bank->size / PAGE_SIZE; - bank->sectors = alloc_block_array(0, PAGE_SIZE, bank->num_sectors); + bank->num_sectors = bank->size / FLASH_PAGE_SIZE; + bank->sectors = alloc_block_array(0, FLASH_PAGE_SIZE, bank->num_sectors); retval = esirisc_flash_init(bank); if (retval != ERROR_OK) { @@ -516,7 +516,7 @@ COMMAND_HANDLER(handle_esirisc_flash_mass_erase_command) retval = esirisc_flash_mass_erase(bank); - command_print(CMD_CTX, "mass erase %s", + command_print(CMD, "mass erase %s", (retval == ERROR_OK) ? "successful" : "failed"); return retval; @@ -536,7 +536,7 @@ COMMAND_HANDLER(handle_esirisc_flash_ref_erase_command) retval = esirisc_flash_ref_erase(bank); - command_print(CMD_CTX, "erase reference cell %s", + command_print(CMD, "erase reference cell %s", (retval == ERROR_OK) ? "successful" : "failed"); return retval; diff --git a/src/flash/nor/faux.c b/src/flash/nor/faux.c index 49b6dcc..a894d03 100644 --- a/src/flash/nor/faux.c +++ b/src/flash/nor/faux.c @@ -109,6 +109,7 @@ static const struct command_registration faux_command_handlers[] = { .mode = COMMAND_ANY, .help = "faux flash command group", .chain = hello_command_handlers, + .usage = "", }, COMMAND_REGISTRATION_DONE }; diff --git a/src/flash/nor/fm3.c b/src/flash/nor/fm3.c index f2da2af..eeefa3f 100644 --- a/src/flash/nor/fm3.c +++ b/src/flash/nor/fm3.c @@ -958,9 +958,9 @@ COMMAND_HANDLER(fm3_handle_chip_erase_command) for (i = 0; i < bank->num_sectors; i++) bank->sectors[i].is_erased = 1; - command_print(CMD_CTX, "fm3 chip erase complete"); + command_print(CMD, "fm3 chip erase complete"); } else { - command_print(CMD_CTX, "fm3 chip erase failed"); + command_print(CMD, "fm3 chip erase failed"); } return ERROR_OK; diff --git a/src/flash/nor/kinetis.c b/src/flash/nor/kinetis.c index 22c5d5c..687a337 100644 --- a/src/flash/nor/kinetis.c +++ b/src/flash/nor/kinetis.c @@ -2895,7 +2895,7 @@ COMMAND_HANDLER(kinetis_nvm_partition) flex_nvm_partition_code = (uint8_t)((sim_fcfg1 >> 8) & 0x0f); switch (flex_nvm_partition_code) { case 0: - command_print(CMD_CTX, "No EEPROM backup, data flash only"); + command_print(CMD, "No EEPROM backup, data flash only"); break; case 1: case 2: @@ -2903,10 +2903,10 @@ COMMAND_HANDLER(kinetis_nvm_partition) case 4: case 5: case 6: - command_print(CMD_CTX, "EEPROM backup %d KB", 4 << flex_nvm_partition_code); + command_print(CMD, "EEPROM backup %d KB", 4 << flex_nvm_partition_code); break; case 8: - command_print(CMD_CTX, "No data flash, EEPROM backup only"); + command_print(CMD, "No data flash, EEPROM backup only"); break; case 0x9: case 0xA: @@ -2914,13 +2914,13 @@ COMMAND_HANDLER(kinetis_nvm_partition) case 0xC: case 0xD: case 0xE: - command_print(CMD_CTX, "data flash %d KB", 4 << (flex_nvm_partition_code & 7)); + command_print(CMD, "data flash %d KB", 4 << (flex_nvm_partition_code & 7)); break; case 0xf: - command_print(CMD_CTX, "No EEPROM backup, data flash only (DEPART not set)"); + command_print(CMD, "No EEPROM backup, data flash only (DEPART not set)"); break; default: - command_print(CMD_CTX, "Unsupported EEPROM backup size code 0x%02" PRIx8, flex_nvm_partition_code); + command_print(CMD, "Unsupported EEPROM backup size code 0x%02" PRIx8, flex_nvm_partition_code); } return ERROR_OK; @@ -2986,7 +2986,7 @@ COMMAND_HANDLER(kinetis_nvm_partition) if (result != ERROR_OK) return result; - command_print(CMD_CTX, "FlexNVM partition set. Please reset MCU."); + command_print(CMD, "FlexNVM partition set. Please reset MCU."); if (k_chip) { first_nvm_bank = k_chip->num_pflash_blocks; @@ -2996,7 +2996,7 @@ COMMAND_HANDLER(kinetis_nvm_partition) k_chip->probed = false; } - command_print(CMD_CTX, "FlexNVM banks will be re-probed to set new data flash size."); + command_print(CMD, "FlexNVM banks will be re-probed to set new data flash size."); return ERROR_OK; } @@ -3015,12 +3015,12 @@ COMMAND_HANDLER(kinetis_fcf_source_handler) } if (allow_fcf_writes) { - command_print(CMD_CTX, "Arbitrary Flash Configuration Field writes enabled."); - command_print(CMD_CTX, "Protection info writes to FCF disabled."); + command_print(CMD, "Arbitrary Flash Configuration Field writes enabled."); + command_print(CMD, "Protection info writes to FCF disabled."); LOG_WARNING("BEWARE: incorrect flash configuration may permanently lock the device."); } else { - command_print(CMD_CTX, "Protection info writes to Flash Configuration Field enabled."); - command_print(CMD_CTX, "Arbitrary FCF writes disabled. Mode safe from unwanted locking of the device."); + command_print(CMD, "Protection info writes to Flash Configuration Field enabled."); + command_print(CMD, "Arbitrary FCF writes disabled. Mode safe from unwanted locking of the device."); } return ERROR_OK; @@ -3035,7 +3035,7 @@ COMMAND_HANDLER(kinetis_fopt_handler) fcf_fopt = (uint8_t)strtoul(CMD_ARGV[0], NULL, 0); fcf_fopt_configured = true; } else { - command_print(CMD_CTX, "FCF_FOPT 0x%02" PRIx8, fcf_fopt); + command_print(CMD, "FCF_FOPT 0x%02" PRIx8, fcf_fopt); } return ERROR_OK; @@ -3074,7 +3074,8 @@ static const struct command_registration kinetis_security_command_handlers[] = { .usage = "", .handler = kinetis_mdm_mass_erase, }, - { .name = "reset", + { + .name = "reset", .mode = COMMAND_EXEC, .help = "Issue a reset via the MDM-AP", .usage = "", @@ -3126,6 +3127,7 @@ static const struct command_registration kinetis_exec_command_handlers[] = { .mode = COMMAND_CONFIG, .help = "Driver creates additional banks if device with two/four flash blocks is probed", .handler = kinetis_create_banks_handler, + .usage = "", }, COMMAND_REGISTRATION_DONE }; diff --git a/src/flash/nor/lpc2000.c b/src/flash/nor/lpc2000.c index cb3f58e..2a69af6 100644 --- a/src/flash/nor/lpc2000.c +++ b/src/flash/nor/lpc2000.c @@ -1579,11 +1579,11 @@ COMMAND_HANDLER(lpc2000_handle_part_id_command) int status_code = get_lpc2000_part_id(bank, &part_id); if (status_code != 0x0) { if (status_code == ERROR_FLASH_OPERATION_FAILED) { - command_print(CMD_CTX, "no sufficient working area specified, can't access LPC2000 IAP interface"); + command_print(CMD, "no sufficient working area specified, can't access LPC2000 IAP interface"); } else - command_print(CMD_CTX, "lpc2000 IAP returned status code %i", status_code); + command_print(CMD, "lpc2000 IAP returned status code %i", status_code); } else - command_print(CMD_CTX, "lpc2000 part id: 0x%8.8" PRIx32, part_id); + command_print(CMD, "lpc2000 part id: 0x%8.8" PRIx32, part_id); return retval; } diff --git a/src/flash/nor/lpc2900.c b/src/flash/nor/lpc2900.c index c798e44..5412c93 100644 --- a/src/flash/nor/lpc2900.c +++ b/src/flash/nor/lpc2900.c @@ -501,7 +501,7 @@ COMMAND_HANDLER(lpc2900_handle_signature_command) if (status != ERROR_OK) return status; - command_print(CMD_CTX, "signature: 0x%8.8" PRIx32 + command_print(CMD, "signature: 0x%8.8" PRIx32 ":0x%8.8" PRIx32 ":0x%8.8" PRIx32 ":0x%8.8" PRIx32, @@ -595,11 +595,11 @@ COMMAND_HANDLER(lpc2900_handle_password_command) lpc2900_info->risky = !strcmp(CMD_ARGV[1], ISS_PASSWORD); if (!lpc2900_info->risky) { - command_print(CMD_CTX, "Wrong password (use '%s')", ISS_PASSWORD); + command_print(CMD, "Wrong password (use '%s')", ISS_PASSWORD); return ERROR_COMMAND_ARGUMENT_INVALID; } - command_print(CMD_CTX, + command_print(CMD, "Potentially dangerous operation allowed in next command!"); return ERROR_OK; @@ -622,7 +622,7 @@ COMMAND_HANDLER(lpc2900_handle_write_custom_command) /* Check if command execution is allowed. */ if (!lpc2900_info->risky) { - command_print(CMD_CTX, "Command execution not allowed!"); + command_print(CMD, "Command execution not allowed!"); return ERROR_COMMAND_ARGUMENT_INVALID; } lpc2900_info->risky = 0; @@ -721,7 +721,7 @@ COMMAND_HANDLER(lpc2900_handle_secure_sector_command) /* Check if command execution is allowed. */ if (!lpc2900_info->risky) { - command_print(CMD_CTX, "Command execution not allowed! " + command_print(CMD, "Command execution not allowed! " "(use 'password' command first)"); return ERROR_COMMAND_ARGUMENT_INVALID; } @@ -734,7 +734,7 @@ COMMAND_HANDLER(lpc2900_handle_secure_sector_command) if ((first >= bank->num_sectors) || (last >= bank->num_sectors) || (first > last)) { - command_print(CMD_CTX, "Illegal sector range"); + command_print(CMD, "Illegal sector range"); return ERROR_COMMAND_ARGUMENT_INVALID; } @@ -773,7 +773,7 @@ COMMAND_HANDLER(lpc2900_handle_secure_sector_command) } } - command_print(CMD_CTX, + command_print(CMD, "Sectors security will become effective after next power cycle"); /* Update the sector security status */ @@ -803,7 +803,7 @@ COMMAND_HANDLER(lpc2900_handle_secure_jtag_command) /* Check if command execution is allowed. */ if (!lpc2900_info->risky) { - command_print(CMD_CTX, "Command execution not allowed! " + command_print(CMD, "Command execution not allowed! " "(use 'password' command first)"); return ERROR_COMMAND_ARGUMENT_INVALID; } diff --git a/src/flash/nor/max32xxx.c b/src/flash/nor/max32xxx.c index 12e3db9..3bf4b22 100644 --- a/src/flash/nor/max32xxx.c +++ b/src/flash/nor/max32xxx.c @@ -772,7 +772,7 @@ COMMAND_HANDLER(max32xxx_handle_mass_erase_command) int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank); if (CMD_ARGC < 1) { - command_print(CMD_CTX, "max32xxx mass_erase <bank>"); + command_print(CMD, "max32xxx mass_erase <bank>"); return ERROR_OK; } @@ -784,9 +784,9 @@ COMMAND_HANDLER(max32xxx_handle_mass_erase_command) for (i = 0; i < bank->num_sectors; i++) bank->sectors[i].is_erased = 1; - command_print(CMD_CTX, "max32xxx mass erase complete"); + command_print(CMD, "max32xxx mass erase complete"); } else - command_print(CMD_CTX, "max32xxx mass erase failed"); + command_print(CMD, "max32xxx mass erase failed"); return ERROR_OK; } @@ -799,7 +799,7 @@ COMMAND_HANDLER(max32xxx_handle_protection_set_command) uint32_t addr, len; if (CMD_ARGC != 3) { - command_print(CMD_CTX, "max32xxx protection_set <bank> <addr> <size>"); + command_print(CMD, "max32xxx protection_set <bank> <addr> <size>"); return ERROR_OK; } @@ -811,7 +811,7 @@ COMMAND_HANDLER(max32xxx_handle_protection_set_command) /* Convert the range to the page numbers */ if (1 != sscanf(CMD_ARGV[1], "0x%"SCNx32, &addr)) { LOG_WARNING("Error parsing address"); - command_print(CMD_CTX, "max32xxx protection_set <bank> <addr> <size>"); + command_print(CMD, "max32xxx protection_set <bank> <addr> <size>"); return ERROR_FAIL; } /* Mask off the top portion on the address */ @@ -819,7 +819,7 @@ COMMAND_HANDLER(max32xxx_handle_protection_set_command) if (1 != sscanf(CMD_ARGV[2], "0x%"SCNx32, &len)) { LOG_WARNING("Error parsing length"); - command_print(CMD_CTX, "max32xxx protection_set <bank> <addr> <size>"); + command_print(CMD, "max32xxx protection_set <bank> <addr> <size>"); return ERROR_FAIL; } @@ -840,9 +840,9 @@ COMMAND_HANDLER(max32xxx_handle_protection_set_command) len = addr + (len / info->sector_size) - 1; if (max32xxx_protect(bank, 1, addr, len) == ERROR_OK) - command_print(CMD_CTX, "max32xxx protection set complete"); + command_print(CMD, "max32xxx protection set complete"); else - command_print(CMD_CTX, "max32xxx protection set failed"); + command_print(CMD, "max32xxx protection set failed"); return ERROR_OK; } @@ -855,7 +855,7 @@ COMMAND_HANDLER(max32xxx_handle_protection_clr_command) uint32_t addr, len; if (CMD_ARGC != 3) { - command_print(CMD_CTX, "max32xxx protection_clr <bank> <addr> <size>"); + command_print(CMD, "max32xxx protection_clr <bank> <addr> <size>"); return ERROR_OK; } @@ -867,7 +867,7 @@ COMMAND_HANDLER(max32xxx_handle_protection_clr_command) /* Convert the range to the page numbers */ if (1 != sscanf(CMD_ARGV[1], "0x%"SCNx32, &addr)) { LOG_WARNING("Error parsing address"); - command_print(CMD_CTX, "max32xxx protection_clr <bank> <addr> <size>"); + command_print(CMD, "max32xxx protection_clr <bank> <addr> <size>"); return ERROR_FAIL; } /* Mask off the top portion on the address */ @@ -875,7 +875,7 @@ COMMAND_HANDLER(max32xxx_handle_protection_clr_command) if (1 != sscanf(CMD_ARGV[2], "0x%"SCNx32, &len)) { LOG_WARNING("Error parsing length"); - command_print(CMD_CTX, "max32xxx protection_clr <bank> <addr> <size>"); + command_print(CMD, "max32xxx protection_clr <bank> <addr> <size>"); return ERROR_FAIL; } @@ -896,9 +896,9 @@ COMMAND_HANDLER(max32xxx_handle_protection_clr_command) len = addr + (len / info->sector_size) - 1; if (max32xxx_protect(bank, 0, addr, len) == ERROR_OK) - command_print(CMD_CTX, "max32xxx protection clear complete"); + command_print(CMD, "max32xxx protection clear complete"); else - command_print(CMD_CTX, "max32xxx protection clear failed"); + command_print(CMD, "max32xxx protection clear failed"); return ERROR_OK; } @@ -911,7 +911,7 @@ COMMAND_HANDLER(max32xxx_handle_protection_check_command) int i; if (CMD_ARGC < 1) { - command_print(CMD_CTX, "max32xxx protection_check <bank>"); + command_print(CMD, "max32xxx protection_check <bank>"); return ERROR_OK; } @@ -977,6 +977,7 @@ static const struct command_registration max32xxx_command_handlers[] = { .mode = COMMAND_EXEC, .help = "max32xxx flash command group", .chain = max32xxx_exec_command_handlers, + .usage = "", }, COMMAND_REGISTRATION_DONE }; diff --git a/src/flash/nor/niietcm4.c b/src/flash/nor/niietcm4.c index b034ee1..7b67bb8 100644 --- a/src/flash/nor/niietcm4.c +++ b/src/flash/nor/niietcm4.c @@ -425,9 +425,9 @@ COMMAND_HANDLER(niietcm4_handle_uflash_read_byte_command) retval = target_read_u32(target, UFMD, &uflash_data); if (retval != ERROR_OK) return retval; - command_print(CMD_CTX, "Read userflash %s region:\n" - "address = 0x%04x,\n" - "value = 0x%02x.", CMD_ARGV[0], uflash_addr, uflash_data); + command_print(CMD, "Read userflash %s region:\n" + "address = 0x%04x,\n" + "value = 0x%02x.", CMD_ARGV[0], uflash_addr, uflash_data); return retval; } @@ -467,10 +467,10 @@ COMMAND_HANDLER(niietcm4_handle_uflash_write_byte_command) int page_num = uflash_addr/USERFLASH_PAGE_SIZE; - command_print(CMD_CTX, "Write userflash %s region:\n" - "address = 0x%04x,\n" - "value = 0x%02x.\n" - "Please wait ... ", CMD_ARGV[0], uflash_addr, uflash_data); + command_print(CMD, "Write userflash %s region:\n" + "address = 0x%04x,\n" + "value = 0x%02x.\n" + "Please wait ... ", CMD_ARGV[0], uflash_addr, uflash_data); /* dump */ uint32_t uflash_dump[USERFLASH_PAGE_SIZE]; niietcm4_dump_uflash_page(bank, uflash_dump, page_num, mem_type); @@ -483,7 +483,7 @@ COMMAND_HANDLER(niietcm4_handle_uflash_write_byte_command) /* write dump to userflash */ niietcm4_load_uflash_page(bank, uflash_dump, page_num, mem_type); - command_print(CMD_CTX, "done!"); + command_print(CMD, "done!"); return retval; } @@ -520,7 +520,7 @@ COMMAND_HANDLER(niietcm4_handle_uflash_full_erase_command) retval = niietcm4_uopstatus_check(bank); if (retval != ERROR_OK) return retval; - command_print(CMD_CTX, "Userflash full erase done!"); + command_print(CMD, "Userflash full erase done!"); return retval; } @@ -563,7 +563,7 @@ COMMAND_HANDLER(niietcm4_handle_uflash_erase_command) return retval; } - command_print(CMD_CTX, "Erase %s userflash pages %d through %d done!", CMD_ARGV[0], first, last); + command_print(CMD, "Erase %s userflash pages %d through %d done!", CMD_ARGV[0], first, last); return retval; } @@ -621,9 +621,9 @@ COMMAND_HANDLER(niietcm4_handle_uflash_protect_check_command) return retval; if (uflash_data & INFOWORD3_LOCK_IFB_UF) - command_print(CMD_CTX, "All sectors of info userflash are not protected!"); + command_print(CMD, "All sectors of info userflash are not protected!"); else - command_print(CMD_CTX, "All sectors of info userflash are protected!"); + command_print(CMD, "All sectors of info userflash are protected!"); } else { uflash_addr = UF_LOCK_ADDR; uflash_cmd = UFMC_MAGIC_KEY | UFMC_READ_IFB; @@ -645,10 +645,10 @@ COMMAND_HANDLER(niietcm4_handle_uflash_protect_check_command) for (j = 0; j < 8; j++) { if (uflash_data & 0x1) - command_print(CMD_CTX, "Userflash sector #%03d: 0x%04x (0x100) is not protected!", + command_print(CMD, "Userflash sector #%03d: 0x%04x (0x100) is not protected!", i*8+j, (i*8+j)*USERFLASH_PAGE_SIZE); else - command_print(CMD_CTX, "Userflash sector #%03d: 0x%04x (0x100) is protected!", + command_print(CMD, "Userflash sector #%03d: 0x%04x (0x100) is protected!", i*8+j, (i*8+j)*USERFLASH_PAGE_SIZE); uflash_data = uflash_data >> 1; } @@ -693,11 +693,11 @@ COMMAND_HANDLER(niietcm4_handle_uflash_protect_command) int set; if (strcmp("on", CMD_ARGV[3]) == 0) { - command_print(CMD_CTX, "Try to enable %s userflash sectors %d through %d protection. Please wait ... ", + command_print(CMD, "Try to enable %s userflash sectors %d through %d protection. Please wait ... ", CMD_ARGV[0], first, last); set = 1; } else if (strcmp("off", CMD_ARGV[3]) == 0) { - command_print(CMD_CTX, "Try to disable %s userflash sectors %d through %d protection. Please wait ... ", + command_print(CMD, "Try to disable %s userflash sectors %d through %d protection. Please wait ... ", CMD_ARGV[0], first, last); set = 0; } else @@ -707,7 +707,7 @@ COMMAND_HANDLER(niietcm4_handle_uflash_protect_command) if (retval != ERROR_OK) return retval; - command_print(CMD_CTX, "done!"); + command_print(CMD, "done!"); return retval; } @@ -733,10 +733,10 @@ COMMAND_HANDLER(niietcm4_handle_bflash_info_remap_command) int set; if (strcmp("on", CMD_ARGV[0]) == 0) { - command_print(CMD_CTX, "Try to enable bootflash info region remap. Please wait ..."); + command_print(CMD, "Try to enable bootflash info region remap. Please wait ..."); set = 1; } else if (strcmp("off", CMD_ARGV[0]) == 0) { - command_print(CMD_CTX, "Try to disable bootflash info region remap. Please wait ..."); + command_print(CMD, "Try to disable bootflash info region remap. Please wait ..."); set = 0; } else return ERROR_COMMAND_SYNTAX_ERROR; @@ -756,7 +756,7 @@ COMMAND_HANDLER(niietcm4_handle_bflash_info_remap_command) /* write dump to userflash */ niietcm4_load_uflash_page(bank, uflash_dump, 0, 1); - command_print(CMD_CTX, "done!"); + command_print(CMD, "done!"); return retval; } @@ -814,11 +814,11 @@ COMMAND_HANDLER(niietcm4_handle_extmem_cfg_command) else return ERROR_COMMAND_SYNTAX_ERROR; - command_print(CMD_CTX, "Try to configure external memory boot interface:\n" - "port = %s\n" - "pin = %s\n" - "func = %s\n" - "Please wait ...", CMD_ARGV[0], CMD_ARGV[1], CMD_ARGV[2]); + command_print(CMD, "Try to configure external memory boot interface:\n" + "port = %s\n" + "pin = %s\n" + "func = %s\n" + "Please wait ...", CMD_ARGV[0], CMD_ARGV[1], CMD_ARGV[2]); /* dump */ uint32_t uflash_dump[USERFLASH_PAGE_SIZE]; niietcm4_dump_uflash_page(bank, uflash_dump, 0, 1); @@ -833,7 +833,7 @@ COMMAND_HANDLER(niietcm4_handle_extmem_cfg_command) /* write dump to userflash */ niietcm4_load_uflash_page(bank, uflash_dump, 0, 1); - command_print(CMD_CTX, "done!"); + command_print(CMD, "done!"); return retval; } @@ -861,10 +861,10 @@ COMMAND_HANDLER(niietcm4_handle_extmem_boot_command) int set; if (strcmp("on", CMD_ARGV[0]) == 0) { - command_print(CMD_CTX, "Try to enable boot from external memory. Please wait ..."); + command_print(CMD, "Try to enable boot from external memory. Please wait ..."); set = 1; } else if (strcmp("off", CMD_ARGV[0]) == 0) { - command_print(CMD_CTX, "Try to disable boot from external memory. Please wait ..."); + command_print(CMD, "Try to disable boot from external memory. Please wait ..."); set = 0; } else return ERROR_COMMAND_SYNTAX_ERROR; @@ -884,7 +884,7 @@ COMMAND_HANDLER(niietcm4_handle_extmem_boot_command) /* write dump to userflash */ niietcm4_load_uflash_page(bank, uflash_dump, 0, 1); - command_print(CMD_CTX, "done!"); + command_print(CMD, "done!"); return retval; } @@ -900,7 +900,7 @@ COMMAND_HANDLER(niietcm4_handle_service_mode_erase_command) return retval; struct target *target = bank->target; - command_print(CMD_CTX, "Try to perform service mode erase. Please wait ..."); + command_print(CMD, "Try to perform service mode erase. Please wait ..."); retval = target_write_u32(target, SERVICE_MODE_ERASE_ADDR, 1); if (retval != ERROR_OK) @@ -923,7 +923,7 @@ COMMAND_HANDLER(niietcm4_handle_service_mode_erase_command) } busy_sleep(1); /* can use busy sleep for short times. */ } - command_print(CMD_CTX, "done! All data erased."); + command_print(CMD, "done! All data erased."); return retval; } @@ -938,7 +938,7 @@ COMMAND_HANDLER(niietcm4_handle_driver_info_command) if (retval != ERROR_OK) return retval; - command_print(CMD_CTX, "niietcm4 flash driver\n" + command_print(CMD, "niietcm4 flash driver\n" "version: %d.%d\n" "author: Bogdan Kolbov\n" "mail: kolbov@niiet.ru", diff --git a/src/flash/nor/nrf5.c b/src/flash/nor/nrf5.c index aab80f9..4041bfb 100644 --- a/src/flash/nor/nrf5.c +++ b/src/flash/nor/nrf5.c @@ -1118,6 +1118,7 @@ static const struct command_registration nrf5_exec_command_handlers[] = { .handler = nrf5_handle_mass_erase_command, .mode = COMMAND_EXEC, .help = "Erase all flash contents of the chip.", + .usage = "", }, COMMAND_REGISTRATION_DONE }; diff --git a/src/flash/nor/numicro.c b/src/flash/nor/numicro.c index 8d8abd5..c62af04 100644 --- a/src/flash/nor/numicro.c +++ b/src/flash/nor/numicro.c @@ -1827,11 +1827,11 @@ COMMAND_HANDLER(numicro_handle_chip_erase_command) retval = numicro_fmc_cmd(target, ISPCMD_CHIPERASE, 0, 0, &rdat); if (retval != ERROR_OK) { - command_print(CMD_CTX, "numicro chip_erase failed"); + command_print(CMD, "numicro chip_erase failed"); return retval; } - command_print(CMD_CTX, "numicro chip_erase complete"); + command_print(CMD, "numicro chip_erase complete"); return ERROR_OK; } @@ -1856,6 +1856,7 @@ static const struct command_registration numicro_exec_command_handlers[] = { .handler = numicro_handle_chip_erase_command, .mode = COMMAND_EXEC, .help = "chip erase through ISP.", + .usage = "", }, COMMAND_REGISTRATION_DONE }; diff --git a/src/flash/nor/pic32mx.c b/src/flash/nor/pic32mx.c index 5ad4cb7..81ffdc4 100644 --- a/src/flash/nor/pic32mx.c +++ b/src/flash/nor/pic32mx.c @@ -858,7 +858,7 @@ COMMAND_HANDLER(pic32mx_handle_pgm_word_command) return retval; if (address < bank->base || address >= (bank->base + bank->size)) { - command_print(CMD_CTX, "flash address '%s' is out of bounds", CMD_ARGV[0]); + command_print(CMD, "flash address '%s' is out of bounds", CMD_ARGV[0]); return ERROR_OK; } @@ -870,9 +870,9 @@ COMMAND_HANDLER(pic32mx_handle_pgm_word_command) res = ERROR_FLASH_OPERATION_FAILED; if (res == ERROR_OK) - command_print(CMD_CTX, "pic32mx pgm word complete"); + command_print(CMD, "pic32mx pgm word complete"); else - command_print(CMD_CTX, "pic32mx pgm word failed (status = 0x%x)", status); + command_print(CMD, "pic32mx pgm word failed (status = 0x%x)", status); return ERROR_OK; } @@ -885,7 +885,7 @@ COMMAND_HANDLER(pic32mx_handle_unlock_command) int timeout = 10; if (CMD_ARGC < 1) { - command_print(CMD_CTX, "pic32mx unlock <bank>"); + command_print(CMD, "pic32mx unlock <bank>"); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -907,7 +907,7 @@ COMMAND_HANDLER(pic32mx_handle_unlock_command) mips_ejtag_drscan_8(ejtag_info, &mchip_cmd); if (mchip_cmd & (1 << 7)) { /* device is not locked */ - command_print(CMD_CTX, "pic32mx is already unlocked, erasing anyway"); + command_print(CMD, "pic32mx is already unlocked, erasing anyway"); } /* unlock/erase device */ @@ -931,7 +931,7 @@ COMMAND_HANDLER(pic32mx_handle_unlock_command) /* select ejtag tap */ mips_ejtag_set_instr(ejtag_info, MTAP_SW_ETAP); - command_print(CMD_CTX, "pic32mx unlocked.\n" + command_print(CMD, "pic32mx unlocked.\n" "INFO: a reset or power cycle is required " "for the new settings to take effect."); diff --git a/src/flash/nor/psoc4.c b/src/flash/nor/psoc4.c index 0058f2d..1eb6a26 100644 --- a/src/flash/nor/psoc4.c +++ b/src/flash/nor/psoc4.c @@ -913,9 +913,9 @@ COMMAND_HANDLER(psoc4_handle_mass_erase_command) retval = psoc4_mass_erase(bank); if (retval == ERROR_OK) - command_print(CMD_CTX, "psoc mass erase complete"); + command_print(CMD, "psoc mass erase complete"); else - command_print(CMD_CTX, "psoc mass erase failed"); + command_print(CMD, "psoc mass erase failed"); return retval; } diff --git a/src/flash/nor/psoc5lp.c b/src/flash/nor/psoc5lp.c index 66e2b07..7f801f2 100644 --- a/src/flash/nor/psoc5lp.c +++ b/src/flash/nor/psoc5lp.c @@ -1501,9 +1501,9 @@ COMMAND_HANDLER(psoc5lp_handle_mass_erase_command) retval = psoc5lp_spc_erase_all(bank->target); if (retval == ERROR_OK) - command_print(CMD_CTX, "PSoC 5LP erase succeeded"); + command_print(CMD, "PSoC 5LP erase succeeded"); else - command_print(CMD_CTX, "PSoC 5LP erase failed"); + command_print(CMD, "PSoC 5LP erase failed"); return retval; } diff --git a/src/flash/nor/stellaris.c b/src/flash/nor/stellaris.c index 6b6f6e8..9c4c4bc 100644 --- a/src/flash/nor/stellaris.c +++ b/src/flash/nor/stellaris.c @@ -1336,9 +1336,9 @@ COMMAND_HANDLER(stellaris_handle_mass_erase_command) for (i = 0; i < bank->num_sectors; i++) bank->sectors[i].is_erased = 1; - command_print(CMD_CTX, "stellaris mass erase complete"); + command_print(CMD, "stellaris mass erase complete"); } else - command_print(CMD_CTX, "stellaris mass erase failed"); + command_print(CMD, "stellaris mass erase failed"); return ERROR_OK; } diff --git a/src/flash/nor/stm32f1x.c b/src/flash/nor/stm32f1x.c index d5d59c6..cf10e37 100644 --- a/src/flash/nor/stm32f1x.c +++ b/src/flash/nor/stm32f1x.c @@ -1186,7 +1186,7 @@ COMMAND_HANDLER(stm32x_handle_lock_command) return retval; if (stm32x_erase_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "stm32x failed to erase options"); + command_print(CMD, "stm32x failed to erase options"); return ERROR_OK; } @@ -1194,11 +1194,11 @@ COMMAND_HANDLER(stm32x_handle_lock_command) stm32x_info->option_bytes.rdp = 0; if (stm32x_write_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "stm32x failed to lock device"); + command_print(CMD, "stm32x failed to lock device"); return ERROR_OK; } - command_print(CMD_CTX, "stm32x locked"); + command_print(CMD, "stm32x locked"); return ERROR_OK; } @@ -1227,16 +1227,16 @@ COMMAND_HANDLER(stm32x_handle_unlock_command) return retval; if (stm32x_erase_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "stm32x failed to erase options"); + command_print(CMD, "stm32x failed to erase options"); return ERROR_OK; } if (stm32x_write_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "stm32x failed to unlock device"); + command_print(CMD, "stm32x failed to unlock device"); return ERROR_OK; } - command_print(CMD_CTX, "stm32x unlocked.\n" + command_print(CMD, "stm32x unlocked.\n" "INFO: a reset or power cycle is required " "for the new settings to take effect."); @@ -1281,30 +1281,30 @@ COMMAND_HANDLER(stm32x_handle_options_read_command) return retval; if (optionbyte & (1 << OPT_ERROR)) - command_print(CMD_CTX, "option byte complement error"); + command_print(CMD, "option byte complement error"); - command_print(CMD_CTX, "option byte register = 0x%" PRIx32 "", optionbyte); - command_print(CMD_CTX, "write protection register = 0x%" PRIx32 "", protection); + command_print(CMD, "option byte register = 0x%" PRIx32 "", optionbyte); + command_print(CMD, "write protection register = 0x%" PRIx32 "", protection); - command_print(CMD_CTX, "read protection: %s", + command_print(CMD, "read protection: %s", (optionbyte & (1 << OPT_READOUT)) ? "on" : "off"); /* user option bytes are offset depending on variant */ optionbyte >>= stm32x_info->option_offset; - command_print(CMD_CTX, "watchdog: %sware", + command_print(CMD, "watchdog: %sware", (optionbyte & (1 << OPT_RDWDGSW)) ? "soft" : "hard"); - command_print(CMD_CTX, "stop mode: %sreset generated upon entry", + command_print(CMD, "stop mode: %sreset generated upon entry", (optionbyte & (1 << OPT_RDRSTSTOP)) ? "no " : ""); - command_print(CMD_CTX, "standby mode: %sreset generated upon entry", + command_print(CMD, "standby mode: %sreset generated upon entry", (optionbyte & (1 << OPT_RDRSTSTDBY)) ? "no " : ""); if (stm32x_info->has_dual_banks) - command_print(CMD_CTX, "boot: bank %d", (optionbyte & (1 << OPT_BFB2)) ? 0 : 1); + command_print(CMD, "boot: bank %d", (optionbyte & (1 << OPT_BFB2)) ? 0 : 1); - command_print(CMD_CTX, "user data = 0x%02" PRIx16 "", user_data); + command_print(CMD, "user data = 0x%02" PRIx16 "", user_data); return ERROR_OK; } @@ -1383,7 +1383,7 @@ COMMAND_HANDLER(stm32x_handle_options_write_command) } if (stm32x_erase_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "stm32x failed to erase options"); + command_print(CMD, "stm32x failed to erase options"); return ERROR_OK; } @@ -1391,11 +1391,11 @@ COMMAND_HANDLER(stm32x_handle_options_write_command) stm32x_info->option_bytes.data = useropt; if (stm32x_write_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "stm32x failed to write options"); + command_print(CMD, "stm32x failed to write options"); return ERROR_OK; } - command_print(CMD_CTX, "stm32x write options complete.\n" + command_print(CMD, "stm32x write options complete.\n" "INFO: %spower cycle is required " "for the new settings to take effect.", stm32x_info->can_load_options @@ -1504,9 +1504,9 @@ COMMAND_HANDLER(stm32x_handle_mass_erase_command) for (i = 0; i < bank->num_sectors; i++) bank->sectors[i].is_erased = 1; - command_print(CMD_CTX, "stm32x mass erase complete"); + command_print(CMD, "stm32x mass erase complete"); } else - command_print(CMD_CTX, "stm32x mass erase failed"); + command_print(CMD, "stm32x mass erase failed"); return retval; } diff --git a/src/flash/nor/stm32f2x.c b/src/flash/nor/stm32f2x.c index 23f0030..b49e76e 100644 --- a/src/flash/nor/stm32f2x.c +++ b/src/flash/nor/stm32f2x.c @@ -1415,7 +1415,7 @@ COMMAND_HANDLER(stm32x_handle_lock_command) } if (stm32x_read_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "%s failed to read options", bank->driver->name); + command_print(CMD, "%s failed to read options", bank->driver->name); return ERROR_OK; } @@ -1423,11 +1423,11 @@ COMMAND_HANDLER(stm32x_handle_lock_command) stm32x_info->option_bytes.RDP = 0; if (stm32x_write_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "%s failed to lock device", bank->driver->name); + command_print(CMD, "%s failed to lock device", bank->driver->name); return ERROR_OK; } - command_print(CMD_CTX, "%s locked", bank->driver->name); + command_print(CMD, "%s locked", bank->driver->name); return ERROR_OK; } @@ -1454,7 +1454,7 @@ COMMAND_HANDLER(stm32x_handle_unlock_command) } if (stm32x_read_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "%s failed to read options", bank->driver->name); + command_print(CMD, "%s failed to read options", bank->driver->name); return ERROR_OK; } @@ -1466,11 +1466,11 @@ COMMAND_HANDLER(stm32x_handle_unlock_command) } if (stm32x_write_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "%s failed to unlock device", bank->driver->name); + command_print(CMD, "%s failed to unlock device", bank->driver->name); return ERROR_OK; } - command_print(CMD_CTX, "%s unlocked.\n" + command_print(CMD, "%s unlocked.\n" "INFO: a reset or power cycle is required " "for the new settings to take effect.", bank->driver->name); @@ -1525,7 +1525,7 @@ COMMAND_HANDLER(stm32x_handle_mass_erase_command) int i; if (CMD_ARGC < 1) { - command_print(CMD_CTX, "stm32x mass_erase <bank>"); + command_print(CMD, "stm32x mass_erase <bank>"); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1540,9 +1540,9 @@ COMMAND_HANDLER(stm32x_handle_mass_erase_command) for (i = 0; i < bank->num_sectors; i++) bank->sectors[i].is_erased = 1; - command_print(CMD_CTX, "stm32x mass erase complete"); + command_print(CMD, "stm32x mass erase complete"); } else { - command_print(CMD_CTX, "stm32x mass erase failed"); + command_print(CMD, "stm32x mass erase failed"); } return retval; @@ -1555,7 +1555,7 @@ COMMAND_HANDLER(stm32f2x_handle_options_read_command) struct stm32x_flash_bank *stm32x_info = NULL; if (CMD_ARGC != 1) { - command_print(CMD_CTX, "stm32f2x options_read <bank>"); + command_print(CMD, "stm32f2x options_read <bank>"); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1572,20 +1572,20 @@ COMMAND_HANDLER(stm32f2x_handle_options_read_command) if (stm32x_info->has_boot_addr) { uint32_t boot_addr = stm32x_info->option_bytes.boot_addr; - command_print(CMD_CTX, "stm32f2x user_options 0x%03X," + command_print(CMD, "stm32f2x user_options 0x%03X," " boot_add0 0x%04X, boot_add1 0x%04X", stm32x_info->option_bytes.user_options, boot_addr & 0xffff, (boot_addr & 0xffff0000) >> 16); if (stm32x_info->has_optcr2_pcrop) { - command_print(CMD_CTX, "stm32f2x optcr2_pcrop 0x%08X", + command_print(CMD, "stm32f2x optcr2_pcrop 0x%08X", stm32x_info->option_bytes.optcr2_pcrop); } } else { - command_print(CMD_CTX, "stm32f2x user_options 0x%03X", + command_print(CMD, "stm32f2x user_options 0x%03X", stm32x_info->option_bytes.user_options); } } else { - command_print(CMD_CTX, "stm32f2x user_options 0x%02X", + command_print(CMD, "stm32f2x user_options 0x%02X", stm32x_info->option_bytes.user_options); } @@ -1601,7 +1601,7 @@ COMMAND_HANDLER(stm32f2x_handle_options_write_command) uint16_t user_options, boot_addr0, boot_addr1, options_mask; if (CMD_ARGC < 1) { - command_print(CMD_CTX, "stm32f2x options_write <bank> ..."); + command_print(CMD, "stm32f2x options_write <bank> ..."); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1616,7 +1616,7 @@ COMMAND_HANDLER(stm32f2x_handle_options_write_command) stm32x_info = bank->driver_priv; if (stm32x_info->has_boot_addr) { if (CMD_ARGC != 4) { - command_print(CMD_CTX, "stm32f2x options_write <bank> <user_options>" + command_print(CMD, "stm32f2x options_write <bank> <user_options>" " <boot_addr0> <boot_addr1>"); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1625,7 +1625,7 @@ COMMAND_HANDLER(stm32f2x_handle_options_write_command) stm32x_info->option_bytes.boot_addr = boot_addr0 | (((uint32_t) boot_addr1) << 16); } else { if (CMD_ARGC != 2) { - command_print(CMD_CTX, "stm32f2x options_write <bank> <user_options>"); + command_print(CMD, "stm32f2x options_write <bank> <user_options>"); return ERROR_COMMAND_SYNTAX_ERROR; } } @@ -1634,14 +1634,14 @@ COMMAND_HANDLER(stm32f2x_handle_options_write_command) options_mask = !stm32x_info->has_extra_options ? ~0xfc : ~(((0xf00 << (stm32x_info->protection_bits - 12)) | 0xff) & 0xffc); if (user_options & options_mask) { - command_print(CMD_CTX, "stm32f2x invalid user_options"); + command_print(CMD, "stm32f2x invalid user_options"); return ERROR_COMMAND_ARGUMENT_INVALID; } stm32x_info->option_bytes.user_options = user_options; if (stm32x_write_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "stm32f2x failed to write options"); + command_print(CMD, "stm32f2x failed to write options"); return ERROR_OK; } @@ -1649,7 +1649,7 @@ COMMAND_HANDLER(stm32f2x_handle_options_write_command) /* ... and reprogramming of whole flash */ stm32x_info->probed = false; - command_print(CMD_CTX, "stm32f2x write options complete.\n" + command_print(CMD, "stm32f2x write options complete.\n" "INFO: a reset or power cycle is required " "for the new settings to take effect."); return retval; @@ -1663,7 +1663,7 @@ COMMAND_HANDLER(stm32f2x_handle_optcr2_write_command) uint32_t optcr2_pcrop; if (CMD_ARGC != 2) { - command_print(CMD_CTX, "stm32f2x optcr2_write <bank> <optcr2_value>"); + command_print(CMD, "stm32f2x optcr2_write <bank> <optcr2_value>"); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1673,11 +1673,11 @@ COMMAND_HANDLER(stm32f2x_handle_optcr2_write_command) stm32x_info = bank->driver_priv; if (!stm32x_info->has_optcr2_pcrop) { - command_print(CMD_CTX, "no optcr2 register"); + command_print(CMD, "no optcr2 register"); return ERROR_COMMAND_ARGUMENT_INVALID; } - command_print(CMD_CTX, "INFO: To disable PCROP, set PCROP_RDP" + command_print(CMD, "INFO: To disable PCROP, set PCROP_RDP" " with PCROPi bits STILL SET, then\nlock device and" " finally unlock it. Clears PCROP and mass erases flash."); @@ -1689,18 +1689,18 @@ COMMAND_HANDLER(stm32f2x_handle_optcr2_write_command) stm32x_info->option_bytes.optcr2_pcrop = optcr2_pcrop; if (stm32x_write_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "stm32f2x failed to write options"); + command_print(CMD, "stm32f2x failed to write options"); return ERROR_OK; } - command_print(CMD_CTX, "stm32f2x optcr2_write complete."); + command_print(CMD, "stm32f2x optcr2_write complete."); return retval; } COMMAND_HANDLER(stm32x_handle_otp_command) { if (CMD_ARGC < 2) { - command_print(CMD_CTX, "stm32x otp <bank> (enable|disable|show)"); + command_print(CMD, "stm32x otp <bank> (enable|disable|show)"); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1714,7 +1714,7 @@ COMMAND_HANDLER(stm32x_handle_otp_command) } else if (strcmp(CMD_ARGV[1], "disable") == 0) { stm32x_otp_disable(bank); } else if (strcmp(CMD_ARGV[1], "show") == 0) { - command_print(CMD_CTX, + command_print(CMD, "OTP memory bank #%d is %s for write commands.", bank->bank_number, stm32x_is_otp_unlocked(bank) ? "enabled" : "disabled"); @@ -1722,7 +1722,7 @@ COMMAND_HANDLER(stm32x_handle_otp_command) return ERROR_COMMAND_SYNTAX_ERROR; } } else { - command_print(CMD_CTX, "Failed: not an OTP bank."); + command_print(CMD, "Failed: not an OTP bank."); } return retval; diff --git a/src/flash/nor/stm32h7x.c b/src/flash/nor/stm32h7x.c index ce89bb4..fd6bf9a 100644 --- a/src/flash/nor/stm32h7x.c +++ b/src/flash/nor/stm32h7x.c @@ -38,18 +38,18 @@ #define FLASH_SR 0x10 #define FLASH_CCR 0x14 #define FLASH_OPTCR 0x18 -#define FLASH_OPTCUR 0x1C -#define FLASH_OPTPRG 0x20 +#define FLASH_OPTSR_CUR 0x1C +#define FLASH_OPTSR_PRG 0x20 #define FLASH_OPTCCR 0x24 -#define FLASH_WPSNCUR 0x38 -#define FLASH_WPSNPRG 0x3C +#define FLASH_WPSN_CUR 0x38 +#define FLASH_WPSN_PRG 0x3C /* FLASH_CR register bits */ #define FLASH_LOCK (1 << 0) #define FLASH_PG (1 << 1) #define FLASH_SER (1 << 2) -#define FLASH_BER_CMD (1 << 3) +#define FLASH_BER (1 << 3) #define FLASH_PSIZE_8 (0 << 4) #define FLASH_PSIZE_16 (1 << 4) #define FLASH_PSIZE_32 (2 << 4) @@ -61,6 +61,7 @@ /* FLASH_SR register bits */ #define FLASH_BSY (1 << 0) /* Operation in progress */ +#define FLASH_QW (1 << 2) /* Operation queue in progress */ #define FLASH_WRPERR (1 << 17) /* Write protection error */ #define FLASH_PGSERR (1 << 18) /* Programming sequence error */ #define FLASH_STRBERR (1 << 19) /* Strobe error */ @@ -114,7 +115,6 @@ struct stm32h7x_part_info { const struct stm32h7x_rev *revs; size_t num_revs; unsigned int page_size; - unsigned int pages_per_sector; uint16_t max_flash_size_kb; uint8_t has_dual_bank; uint16_t first_bank_size_kb; /* Used when has_dual_bank is true */ @@ -132,7 +132,7 @@ struct stm32h7x_flash_bank { }; static const struct stm32h7x_rev stm32_450_revs[] = { - { 0x1000, "A" }, { 0x1001, "Z" }, { 0x1003, "Y" }, + { 0x1000, "A" }, { 0x1001, "Z" }, { 0x1003, "Y" }, { 0x2001, "X" }, }; static const struct stm32h7x_part_info stm32h7x_parts[] = { @@ -140,7 +140,7 @@ static const struct stm32h7x_part_info stm32h7x_parts[] = { .id = 0x450, .revs = stm32_450_revs, .num_revs = ARRAY_SIZE(stm32_450_revs), - .device_str = "STM32H7xx 2M", + .device_str = "STM32H74x/75x", .page_size = 128, /* 128 KB */ .max_flash_size_kb = 2048, .first_bank_size_kb = 1024, @@ -184,33 +184,33 @@ static inline int stm32x_get_flash_status(struct flash_bank *bank, uint32_t *sta return target_read_u32(target, stm32x_get_flash_reg(bank, FLASH_SR), status); } -static int stm32x_wait_status_busy(struct flash_bank *bank, int timeout) +static int stm32x_wait_flash_op_queue(struct flash_bank *bank, int timeout) { struct target *target = bank->target; struct stm32h7x_flash_bank *stm32x_info = bank->driver_priv; uint32_t status; int retval; - /* wait for busy to clear */ + /* wait for flash operations completion */ for (;;) { retval = stm32x_get_flash_status(bank, &status); if (retval != ERROR_OK) { - LOG_INFO("wait_status_busy, target_read_u32 : error : remote address 0x%x", stm32x_info->flash_base); + LOG_INFO("wait_flash_op_queue, target_read_u32 : error : remote address 0x%x", stm32x_info->flash_base); return retval; } - if ((status & FLASH_BSY) == 0) + if ((status & FLASH_QW) == 0) break; if (timeout-- <= 0) { - LOG_INFO("wait_status_busy, time out expired, status: 0x%" PRIx32 "", status); + LOG_INFO("wait_flash_op_queue, time out expired, status: 0x%" PRIx32 "", status); return ERROR_FAIL; } alive_sleep(1); } if (status & FLASH_WRPERR) { - LOG_INFO("wait_status_busy, WRPERR : error : remote address 0x%x", stm32x_info->flash_base); + LOG_INFO("wait_flash_op_queue, WRPERR : error : remote address 0x%x", stm32x_info->flash_base); retval = ERROR_FAIL; } @@ -313,7 +313,7 @@ static int stm32x_read_options(struct flash_bank *bank) stm32x_info = bank->driver_priv; /* read current option bytes */ - int retval = target_read_u32(target, FLASH_REG_BASE_B0 + FLASH_OPTCUR, &optiondata); + int retval = target_read_u32(target, FLASH_REG_BASE_B0 + FLASH_OPTSR_CUR, &optiondata); if (retval != ERROR_OK) return retval; @@ -321,19 +321,19 @@ static int stm32x_read_options(struct flash_bank *bank) stm32x_info->option_bytes.user_options = optiondata & 0xfc; stm32x_info->option_bytes.RDP = (optiondata >> 8) & 0xff; stm32x_info->option_bytes.user2_options = (optiondata >> 16) & 0xff; - stm32x_info->option_bytes.user3_options = (optiondata >> 24) & 0x83; + stm32x_info->option_bytes.user3_options = (optiondata >> 24) & 0xa3; if (stm32x_info->option_bytes.RDP != 0xAA) LOG_INFO("Device Security Bit Set"); /* read current WPSN option bytes */ - retval = target_read_u32(target, FLASH_REG_BASE_B0 + FLASH_WPSNCUR, &optiondata); + retval = target_read_u32(target, FLASH_REG_BASE_B0 + FLASH_WPSN_CUR, &optiondata); if (retval != ERROR_OK) return retval; stm32x_info->option_bytes.protection = optiondata & 0xff; /* read current WPSN2 option bytes */ - retval = target_read_u32(target, FLASH_REG_BASE_B1 + FLASH_WPSNCUR, &optiondata); + retval = target_read_u32(target, FLASH_REG_BASE_B1 + FLASH_WPSN_CUR, &optiondata); if (retval != ERROR_OK) return retval; stm32x_info->option_bytes.protection2 = optiondata & 0xff; @@ -357,30 +357,30 @@ static int stm32x_write_options(struct flash_bank *bank) optiondata = stm32x_info->option_bytes.user_options; optiondata |= (stm32x_info->option_bytes.RDP << 8); optiondata |= (stm32x_info->option_bytes.user2_options & 0xff) << 16; - optiondata |= (stm32x_info->option_bytes.user3_options & 0x83) << 24; + optiondata |= (stm32x_info->option_bytes.user3_options & 0xa3) << 24; /* program options */ - retval = target_write_u32(target, FLASH_REG_BASE_B0 + FLASH_OPTPRG, optiondata); - if (retval != ERROR_OK) - return retval; + retval = target_write_u32(target, FLASH_REG_BASE_B0 + FLASH_OPTSR_PRG, optiondata); + if (retval != ERROR_OK) + return retval; optiondata = stm32x_info->option_bytes.protection & 0xff; /* Program protection WPSNPRG */ - retval = target_write_u32(target, FLASH_REG_BASE_B0 + FLASH_WPSNPRG, optiondata); - if (retval != ERROR_OK) - return retval; + retval = target_write_u32(target, FLASH_REG_BASE_B0 + FLASH_WPSN_PRG, optiondata); + if (retval != ERROR_OK) + return retval; optiondata = stm32x_info->option_bytes.protection2 & 0xff; /* Program protection WPSNPRG2 */ - retval = target_write_u32(target, FLASH_REG_BASE_B1 + FLASH_WPSNPRG, optiondata); - if (retval != ERROR_OK) - return retval; + retval = target_write_u32(target, FLASH_REG_BASE_B1 + FLASH_WPSN_PRG, optiondata); + if (retval != ERROR_OK) + return retval; optiondata = 0x40000000; /* Remove OPT error flag before programming */ retval = target_write_u32(target, FLASH_REG_BASE_B0 + FLASH_OPTCCR, optiondata); - if (retval != ERROR_OK) - return retval; + if (retval != ERROR_OK) + return retval; /* start programming cycle */ retval = target_write_u32(target, FLASH_REG_BASE_B0 + FLASH_OPTCR, OPT_START); @@ -393,14 +393,14 @@ static int stm32x_write_options(struct flash_bank *bank) uint32_t status; retval = target_read_u32(target, FLASH_REG_BASE_B0 + FLASH_SR, &status); if (retval != ERROR_OK) { - LOG_INFO("stm32x_write_options: wait_status_busy : error"); + LOG_INFO("stm32x_write_options: wait_flash_op_queue : error"); return retval; } - if ((status & FLASH_BSY) == 0) + if ((status & FLASH_QW) == 0) break; if (timeout-- <= 0) { - LOG_INFO("wait_status_busy, time out expired, status: 0x%" PRIx32 "", status); + LOG_INFO("wait_flash_op_queue, time out expired, status: 0x%" PRIx32 "", status); return ERROR_FAIL; } alive_sleep(1); @@ -459,12 +459,12 @@ static int stm32x_erase(struct flash_bank *bank, int first, int last) /* Sector Erase To erase a sector, follow the procedure below: - 1. Check that no Flash memory operation is ongoing by checking the BSY bit in the + 1. Check that no Flash memory operation is ongoing by checking the QW bit in the FLASH_SR register 2. Set the SER bit and select the sector you wish to erase (SNB) in the FLASH_CR register 3. Set the STRT bit in the FLASH_CR register - 4. Wait for the BSY bit to be cleared + 4. Wait for flash operations completion */ for (int i = first; i <= last; i++) { LOG_DEBUG("erase sector %d", i); @@ -480,7 +480,7 @@ static int stm32x_erase(struct flash_bank *bank, int first, int last) LOG_ERROR("Error erase sector %d", i); return retval; } - retval = stm32x_wait_status_busy(bank, FLASH_ERASE_TIMEOUT); + retval = stm32x_wait_flash_op_queue(bank, FLASH_ERASE_TIMEOUT); if (retval != ERROR_OK) { LOG_ERROR("erase time-out or operation error sector %d", i); @@ -687,11 +687,11 @@ static int stm32x_write(struct flash_bank *bank, const uint8_t *buffer, /* Standard programming The Flash memory programming sequence is as follows: - 1. Check that no main Flash memory operation is ongoing by checking the BSY bit in the + 1. Check that no main Flash memory operation is ongoing by checking the QW bit in the FLASH_SR register. 2. Set the PG bit in the FLASH_CR register 3. 8 x Word access (or Force Write FW) - 4. Wait for the BSY bit to be cleared + 4. Wait for flash operations completion */ while (blocks_remaining > 0) { retval = target_write_u32(target, stm32x_get_flash_reg(bank, FLASH_CR), FLASH_PG | FLASH_PSIZE_64); @@ -702,7 +702,7 @@ static int stm32x_write(struct flash_bank *bank, const uint8_t *buffer, if (retval != ERROR_OK) goto flash_lock; - retval = stm32x_wait_status_busy(bank, FLASH_WRITE_TIMEOUT); + retval = stm32x_wait_flash_op_queue(bank, FLASH_WRITE_TIMEOUT); if (retval != ERROR_OK) goto flash_lock; @@ -725,7 +725,7 @@ static int stm32x_write(struct flash_bank *bank, const uint8_t *buffer, if (retval != ERROR_OK) goto flash_lock; - retval = stm32x_wait_status_busy(bank, FLASH_WRITE_TIMEOUT); + retval = stm32x_wait_flash_op_queue(bank, FLASH_WRITE_TIMEOUT); if (retval != ERROR_OK) goto flash_lock; } @@ -951,7 +951,7 @@ COMMAND_HANDLER(stm32x_handle_lock_command) } if (stm32x_read_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "%s failed to read options", + command_print(CMD, "%s failed to read options", bank->driver->name); return ERROR_OK; } @@ -959,11 +959,11 @@ COMMAND_HANDLER(stm32x_handle_lock_command) stm32x_info->option_bytes.RDP = 0; if (stm32x_write_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "%s failed to lock device", + command_print(CMD, "%s failed to lock device", bank->driver->name); return ERROR_OK; } - command_print(CMD_CTX, "%s locked", bank->driver->name); + command_print(CMD, "%s locked", bank->driver->name); return ERROR_OK; } @@ -997,7 +997,7 @@ COMMAND_HANDLER(stm32x_handle_unlock_command) } if (stm32x_read_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "%s failed to read options", bank->driver->name); + command_print(CMD, "%s failed to read options", bank->driver->name); return ERROR_OK; } @@ -1006,10 +1006,10 @@ COMMAND_HANDLER(stm32x_handle_unlock_command) stm32x_info->option_bytes.RDP = 0xAA; if (stm32x_write_options(bank) != ERROR_OK) { - command_print(CMD_CTX, "%s failed to unlock device", bank->driver->name); + command_print(CMD, "%s failed to unlock device", bank->driver->name); return ERROR_OK; } - command_print(CMD_CTX, "%s unlocked.\n", bank->driver->name); + command_print(CMD, "%s unlocked.\n", bank->driver->name); return ERROR_OK; } @@ -1029,16 +1029,16 @@ static int stm32x_mass_erase(struct flash_bank *bank) return retval; /* mass erase flash memory bank */ - retval = target_write_u32(target, stm32x_get_flash_reg(bank, FLASH_CR), FLASH_BER_CMD | FLASH_PSIZE_64); + retval = target_write_u32(target, stm32x_get_flash_reg(bank, FLASH_CR), FLASH_BER | FLASH_PSIZE_64); if (retval != ERROR_OK) return retval; retval = target_write_u32(target, stm32x_get_flash_reg(bank, FLASH_CR), - FLASH_BER_CMD | FLASH_PSIZE_64 | FLASH_START); + FLASH_BER | FLASH_PSIZE_64 | FLASH_START); if (retval != ERROR_OK) return retval; - retval = stm32x_wait_status_busy(bank, 30000); + retval = stm32x_wait_flash_op_queue(bank, 30000); if (retval != ERROR_OK) return retval; @@ -1055,7 +1055,7 @@ COMMAND_HANDLER(stm32x_handle_mass_erase_command) int i; if (CMD_ARGC < 1) { - command_print(CMD_CTX, "stm32h7x mass_erase <bank>"); + command_print(CMD, "stm32h7x mass_erase <bank>"); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1070,9 +1070,9 @@ COMMAND_HANDLER(stm32x_handle_mass_erase_command) for (i = 0; i < bank->num_sectors; i++) bank->sectors[i].is_erased = 1; - command_print(CMD_CTX, "stm32h7x mass erase complete"); + command_print(CMD, "stm32h7x mass erase complete"); } else { - command_print(CMD_CTX, "stm32h7x mass erase failed"); + command_print(CMD, "stm32h7x mass erase failed"); } return retval; diff --git a/src/flash/nor/stm32l4x.c b/src/flash/nor/stm32l4x.c index 3d4303b..f680542 100644 --- a/src/flash/nor/stm32l4x.c +++ b/src/flash/nor/stm32l4x.c @@ -835,7 +835,7 @@ COMMAND_HANDLER(stm32l4_handle_mass_erase_command) uint32_t action; if (CMD_ARGC < 1) { - command_print(CMD_CTX, "stm32l4x mass_erase <STM32L4 bank>"); + command_print(CMD, "stm32l4x mass_erase <STM32L4 bank>"); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -851,9 +851,9 @@ COMMAND_HANDLER(stm32l4_handle_mass_erase_command) for (i = 0; i < bank->num_sectors; i++) bank->sectors[i].is_erased = 1; - command_print(CMD_CTX, "stm32l4x mass erase complete"); + command_print(CMD, "stm32l4x mass erase complete"); } else { - command_print(CMD_CTX, "stm32l4x mass erase failed"); + command_print(CMD, "stm32l4x mass erase failed"); } return retval; @@ -862,7 +862,7 @@ COMMAND_HANDLER(stm32l4_handle_mass_erase_command) COMMAND_HANDLER(stm32l4_handle_option_read_command) { if (CMD_ARGC < 2) { - command_print(CMD_CTX, "stm32l4x option_read <STM32L4 bank> <option_reg offset>"); + command_print(CMD, "stm32l4x option_read <STM32L4 bank> <option_reg offset>"); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -880,7 +880,7 @@ COMMAND_HANDLER(stm32l4_handle_option_read_command) if (ERROR_OK != retval) return retval; - command_print(CMD_CTX, "Option Register: <0x%" PRIx32 "> = 0x%" PRIx32 "", reg_addr, value); + command_print(CMD, "Option Register: <0x%" PRIx32 "> = 0x%" PRIx32 "", reg_addr, value); return retval; } @@ -888,7 +888,7 @@ COMMAND_HANDLER(stm32l4_handle_option_read_command) COMMAND_HANDLER(stm32l4_handle_option_write_command) { if (CMD_ARGC < 3) { - command_print(CMD_CTX, "stm32l4x option_write <STM32L4 bank> <option_reg offset> <value> [mask]"); + command_print(CMD, "stm32l4x option_write <STM32L4 bank> <option_reg offset> <value> [mask]"); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -906,7 +906,7 @@ COMMAND_HANDLER(stm32l4_handle_option_write_command) if (CMD_ARGC > 3) mask = strtoul(CMD_ARGV[3], NULL, 16); - command_print(CMD_CTX, "%s Option written.\n" + command_print(CMD, "%s Option written.\n" "INFO: a reset or power cycle is required " "for the new settings to take effect.", bank->driver->name); @@ -937,7 +937,7 @@ COMMAND_HANDLER(stm32l4_handle_option_load_command) /* Write the OBLLAUNCH bit in CR -> Cause device "POR" and option bytes reload */ retval = target_write_u32(target, stm32l4_get_flash_reg(bank, STM32_FLASH_CR), FLASH_OBLLAUNCH); - command_print(CMD_CTX, "stm32l4x option load (POR) completed."); + command_print(CMD, "stm32l4x option load (POR) completed."); return retval; } @@ -962,7 +962,7 @@ COMMAND_HANDLER(stm32l4_handle_lock_command) /* set readout protection level 1 by erasing the RDP option byte */ if (stm32l4_write_option(bank, STM32_FLASH_OPTR, 0, 0x000000FF) != ERROR_OK) { - command_print(CMD_CTX, "%s failed to lock device", bank->driver->name); + command_print(CMD, "%s failed to lock device", bank->driver->name); return ERROR_OK; } @@ -989,7 +989,7 @@ COMMAND_HANDLER(stm32l4_handle_unlock_command) } if (stm32l4_write_option(bank, STM32_FLASH_OPTR, RDP_LEVEL_0, 0x000000FF) != ERROR_OK) { - command_print(CMD_CTX, "%s failed to unlock device", bank->driver->name); + command_print(CMD, "%s failed to unlock device", bank->driver->name); return ERROR_OK; } diff --git a/src/flash/nor/stm32lx.c b/src/flash/nor/stm32lx.c index 2778010..e6473f8 100644 --- a/src/flash/nor/stm32lx.c +++ b/src/flash/nor/stm32lx.c @@ -324,9 +324,9 @@ COMMAND_HANDLER(stm32lx_handle_mass_erase_command) for (i = 0; i < bank->num_sectors; i++) bank->sectors[i].is_erased = 1; - command_print(CMD_CTX, "stm32lx mass erase complete"); + command_print(CMD, "stm32lx mass erase complete"); } else { - command_print(CMD_CTX, "stm32lx mass erase failed"); + command_print(CMD, "stm32lx mass erase failed"); } return retval; @@ -345,9 +345,9 @@ COMMAND_HANDLER(stm32lx_handle_lock_command) retval = stm32lx_lock(bank); if (retval == ERROR_OK) - command_print(CMD_CTX, "STM32Lx locked, takes effect after power cycle."); + command_print(CMD, "STM32Lx locked, takes effect after power cycle."); else - command_print(CMD_CTX, "STM32Lx lock failed"); + command_print(CMD, "STM32Lx lock failed"); return retval; } @@ -365,9 +365,9 @@ COMMAND_HANDLER(stm32lx_handle_unlock_command) retval = stm32lx_unlock(bank); if (retval == ERROR_OK) - command_print(CMD_CTX, "STM32Lx unlocked, takes effect after power cycle."); + command_print(CMD, "STM32Lx unlocked, takes effect after power cycle."); else - command_print(CMD_CTX, "STM32Lx unlock failed"); + command_print(CMD, "STM32Lx unlock failed"); return retval; } diff --git a/src/flash/nor/str9xpec.c b/src/flash/nor/str9xpec.c index b618706..6e1ecf3 100644 --- a/src/flash/nor/str9xpec.c +++ b/src/flash/nor/str9xpec.c @@ -746,7 +746,7 @@ COMMAND_HANDLER(str9xpec_handle_part_id_command) idcode = buf_get_u32(buffer, 0, 32); - command_print(CMD_CTX, "str9xpec part id: 0x%8.8" PRIx32 "", idcode); + command_print(CMD, "str9xpec part id: 0x%8.8" PRIx32 "", idcode); free(buffer); @@ -780,33 +780,33 @@ COMMAND_HANDLER(str9xpec_handle_flash_options_read_command) /* boot bank */ if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_CSMAPBIT, 1)) - command_print(CMD_CTX, "CS Map: bank1"); + command_print(CMD, "CS Map: bank1"); else - command_print(CMD_CTX, "CS Map: bank0"); + command_print(CMD, "CS Map: bank0"); /* OTP lock */ if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_OTPBIT, 1)) - command_print(CMD_CTX, "OTP Lock: OTP Locked"); + command_print(CMD, "OTP Lock: OTP Locked"); else - command_print(CMD_CTX, "OTP Lock: OTP Unlocked"); + command_print(CMD, "OTP Lock: OTP Unlocked"); /* LVD Threshold */ if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_LVDTHRESBIT, 1)) - command_print(CMD_CTX, "LVD Threshold: 2.7v"); + command_print(CMD, "LVD Threshold: 2.7v"); else - command_print(CMD_CTX, "LVD Threshold: 2.4v"); + command_print(CMD, "LVD Threshold: 2.4v"); /* LVD reset warning */ if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_LVDWARNBIT, 1)) - command_print(CMD_CTX, "LVD Reset Warning: VDD or VDDQ Inputs"); + command_print(CMD, "LVD Reset Warning: VDD or VDDQ Inputs"); else - command_print(CMD_CTX, "LVD Reset Warning: VDD Input Only"); + command_print(CMD, "LVD Reset Warning: VDD Input Only"); /* LVD reset select */ if (buf_get_u32(str9xpec_info->options, STR9XPEC_OPT_LVDSELBIT, 1)) - command_print(CMD_CTX, "LVD Reset Selection: VDD or VDDQ Inputs"); + command_print(CMD, "LVD Reset Selection: VDD or VDDQ Inputs"); else - command_print(CMD_CTX, "LVD Reset Selection: VDD Input Only"); + command_print(CMD, "LVD Reset Selection: VDD Input Only"); return ERROR_OK; } @@ -885,7 +885,7 @@ COMMAND_HANDLER(str9xpec_handle_flash_options_write_command) if ((status & ISC_STATUS_ERROR) != STR9XPEC_ISC_SUCCESS) return ERROR_FLASH_OPERATION_FAILED; - command_print(CMD_CTX, "str9xpec write options complete.\n" + command_print(CMD, "str9xpec write options complete.\n" "INFO: a reset or power cycle is required " "for the new settings to take effect."); @@ -1017,7 +1017,7 @@ COMMAND_HANDLER(str9xpec_handle_flash_unlock_command) if ((status & ISC_STATUS_ERROR) != STR9XPEC_ISC_SUCCESS) return ERROR_FLASH_OPERATION_FAILED; - command_print(CMD_CTX, "str9xpec unlocked.\n" + command_print(CMD, "str9xpec unlocked.\n" "INFO: a reset or power cycle is required " "for the new settings to take effect."); @@ -1045,19 +1045,19 @@ COMMAND_HANDLER(str9xpec_handle_flash_enable_turbo_command) tap0 = str9xpec_info->tap; if (tap0 == NULL) { /* things are *WRONG* */ - command_print(CMD_CTX, "**STR9FLASH** (tap0) invalid chain?"); + command_print(CMD, "**STR9FLASH** (tap0) invalid chain?"); return ERROR_FAIL; } tap1 = tap0->next_tap; if (tap1 == NULL) { /* things are *WRONG* */ - command_print(CMD_CTX, "**STR9FLASH** (tap1) invalid chain?"); + command_print(CMD, "**STR9FLASH** (tap1) invalid chain?"); return ERROR_FAIL; } tap2 = tap1->next_tap; if (tap2 == NULL) { /* things are *WRONG* */ - command_print(CMD_CTX, "**STR9FLASH** (tap2) invalid chain?"); + command_print(CMD, "**STR9FLASH** (tap2) invalid chain?"); return ERROR_FAIL; } @@ -1177,9 +1177,10 @@ static const struct command_registration str9xpec_config_command_handlers[] = { }, { .name = "part_id", + .usage = "<bank>", .handler = str9xpec_handle_part_id_command, .mode = COMMAND_EXEC, - .help = "print part id of str9xpec flash bank <num>", + .help = "print part id of str9xpec flash bank", }, COMMAND_REGISTRATION_DONE }; diff --git a/src/flash/nor/swm050.c b/src/flash/nor/swm050.c new file mode 100644 index 0000000..241207d --- /dev/null +++ b/src/flash/nor/swm050.c @@ -0,0 +1,211 @@ +/*************************************************************************** + * Copyright (C) 2019 Icenowy Zheng <icenowy@aosc.io> * + * Copyright (C) 2019 Caleb Szalacinski <contact@skiboy.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, see <http://www.gnu.org/licenses/>. * + ***************************************************************************/ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include "imp.h" +#include <target/image.h> + +#define SWM050_DELAY 100 + +#define SWM050_FLASH_PAGE_SIZE 0x200 +#define SWM050_FLASH_PAGES 16 + +#define SWM050_CPU_ID 0xE000ED00 +#define SWM050_CPU_ID_VAL 0x410CC200 + +#define SWM050_FLASH_REG1 0x1F000000 +#define SWM050_FLASH_REG2 0x1F000038 +#define SWM050_FLASH_KEY 0xAAAAAAAA + +#define SWM050_SYSCTL_CFG_0 0x400F0000 +#define SWM050_SYSCTL_DBLF 0x400F0008 + +static int swm050_erase(struct flash_bank *bank, int first, int last) +{ + struct target *target = bank->target; + int retval, curr_page; + uint32_t curr_addr; + + if (target->state != TARGET_HALTED) { + LOG_ERROR("Target not halted"); + return ERROR_TARGET_NOT_HALTED; + } + + /* Perform erase */ + retval = target_write_u32(target, SWM050_FLASH_REG1, 0x4); + if (retval != ERROR_OK) + return retval; + + for (curr_page = first; curr_page <= last; curr_page++) { + curr_addr = bank->base + (SWM050_FLASH_PAGE_SIZE * curr_page); + /* Perform write */ + retval = target_write_u32(target, curr_addr, SWM050_FLASH_KEY); + if (retval != ERROR_OK) + return retval; + alive_sleep(SWM050_DELAY); + } + + /* Close flash interface */ + retval = target_write_u32(target, SWM050_FLASH_REG1, 0x0); + if (retval != ERROR_OK) + return retval; + + return ERROR_OK; +} + +static int swm050_write(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t count) +{ + struct target *target = bank->target; + int retval; + + if (target->state != TARGET_HALTED) { + LOG_ERROR("Target not halted"); + retval = ERROR_TARGET_NOT_HALTED; + return retval; + } + + /* Perform write */ + retval = target_write_u32(target, SWM050_FLASH_REG1, 0x1); + if (retval != ERROR_OK) + return retval; + + retval = target_write_memory(target, bank->base + offset, 4, count/4, buffer); + if (retval != ERROR_OK) + return retval; + + /* Close flash interface */ + retval = target_write_u32(target, SWM050_FLASH_REG1, 0x0); + if (retval != ERROR_OK) + return retval; + + return ERROR_OK; +} + +static int swm050_probe(struct flash_bank *bank) +{ + return ERROR_OK; +} + +static int swm050_mass_erase(struct flash_bank *bank) +{ + struct target *target = bank->target; + int retval; + + if (target->state != TARGET_HALTED) { + LOG_ERROR("Target not halted"); + return ERROR_TARGET_NOT_HALTED; + } + + /* Perform mass erase */ + retval = target_write_u32(target, SWM050_FLASH_REG1, 0x6); + if (retval != ERROR_OK) + return retval; + retval = target_write_u32(target, SWM050_FLASH_REG2, 0x1); + if (retval != ERROR_OK) + return retval; + retval = target_write_u32(target, 0x0, SWM050_FLASH_KEY); + if (retval != ERROR_OK) + return retval; + + alive_sleep(SWM050_DELAY); + + /* Close flash interface */ + retval = target_write_u32(target, SWM050_FLASH_REG1, 0x0); + if (retval != ERROR_OK) + return retval; + + return ERROR_OK; +} + +COMMAND_HANDLER(swm050_handle_mass_erase_command) +{ + if (CMD_ARGC < 1) + return ERROR_COMMAND_SYNTAX_ERROR; + + struct flash_bank *bank; + int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank); + if (ERROR_OK != retval) + return retval; + + retval = swm050_mass_erase(bank); + if (retval == ERROR_OK) + command_print(CMD, "swm050 mass erase complete"); + else + command_print(CMD, "swm050 mass erase failed"); + + return retval; +} + +FLASH_BANK_COMMAND_HANDLER(swm050_flash_bank_command) +{ + if (bank->sectors) { + free(bank->sectors); + bank->sectors = NULL; + } + bank->write_start_alignment = 4; + bank->write_end_alignment = 4; + bank->size = SWM050_FLASH_PAGE_SIZE * SWM050_FLASH_PAGES; + + bank->num_sectors = SWM050_FLASH_PAGES; + bank->sectors = alloc_block_array(0, SWM050_FLASH_PAGE_SIZE, SWM050_FLASH_PAGES); + if (!bank->sectors) + return ERROR_FAIL; + + for (int i = 0; i < bank->num_sectors; i++) + bank->sectors[i].is_protected = 0; + + return ERROR_OK; +} + +static const struct command_registration swm050_exec_command_handlers[] = { + { + .name = "mass_erase", + .handler = swm050_handle_mass_erase_command, + .mode = COMMAND_EXEC, + .usage = "bank_id", + .help = "Erase entire flash device.", + }, + COMMAND_REGISTRATION_DONE +}; + +static const struct command_registration swm050_command_handlers[] = { + { + .name = "swm050", + .mode = COMMAND_ANY, + .help = "swm050 flash command group", + .usage = "", + .chain = swm050_exec_command_handlers, + }, + COMMAND_REGISTRATION_DONE +}; + +struct flash_driver swm050_flash = { + .name = "swm050", + .commands = swm050_command_handlers, + .flash_bank_command = swm050_flash_bank_command, + .erase = swm050_erase, + .write = swm050_write, + .read = default_flash_read, + .probe = swm050_probe, + .auto_probe = swm050_probe, + .erase_check = default_flash_blank_check, + .free_driver_priv = default_flash_free_driver_priv, +}; diff --git a/src/flash/nor/tcl.c b/src/flash/nor/tcl.c index 6e216e6..bd313a0 100644 --- a/src/flash/nor/tcl.c +++ b/src/flash/nor/tcl.c @@ -111,7 +111,7 @@ COMMAND_HANDLER(handle_flash_info_command) if (retval == ERROR_FLASH_OPER_UNSUPPORTED) LOG_WARNING("Flash protection check is not implemented."); - command_print(CMD_CTX, + command_print(CMD, "#%d : %s at " TARGET_ADDR_FMT ", size 0x%8.8" PRIx32 ", buswidth %i, chipwidth %i", p->bank_number, @@ -140,7 +140,7 @@ COMMAND_HANDLER(handle_flash_info_command) else if (!show_sectors || !prot_block_available) protect_state = "protection state unknown"; - command_print(CMD_CTX, + command_print(CMD, "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s", j, block_array[j].offset, @@ -152,7 +152,7 @@ COMMAND_HANDLER(handle_flash_info_command) if (p->driver->info != NULL) { retval = p->driver->info(p, buf, sizeof(buf)); if (retval == ERROR_OK) - command_print(CMD_CTX, "%s", buf); + command_print(CMD, "%s", buf); else LOG_ERROR("error retrieving flash info"); } @@ -176,12 +176,12 @@ COMMAND_HANDLER(handle_flash_probe_command) if (p) { retval = p->driver->probe(p); if (retval == ERROR_OK) - command_print(CMD_CTX, + command_print(CMD, "flash '%s' found at " TARGET_ADDR_FMT, p->driver->name, p->base); } else { - command_print(CMD_CTX, "flash bank '#%s' is out of bounds", CMD_ARGV[0]); + command_print(CMD, "flash bank '#%s' is out of bounds", CMD_ARGV[0]); retval = ERROR_FAIL; } @@ -202,9 +202,9 @@ COMMAND_HANDLER(handle_flash_erase_check_command) int j; retval = p->driver->erase_check(p); if (retval == ERROR_OK) - command_print(CMD_CTX, "successfully checked erase state"); + command_print(CMD, "successfully checked erase state"); else { - command_print(CMD_CTX, + command_print(CMD, "unknown error when checking erase state of flash bank #%s at " TARGET_ADDR_FMT, CMD_ARGV[0], @@ -222,7 +222,7 @@ COMMAND_HANDLER(handle_flash_erase_check_command) erase_state = "erase state unknown"; blank = false; - command_print(CMD_CTX, + command_print(CMD, "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s", j, p->sectors[j].offset, @@ -232,7 +232,7 @@ COMMAND_HANDLER(handle_flash_erase_check_command) } if (blank) - command_print(CMD_CTX, "\tBank is erased"); + command_print(CMD, "\tBank is erased"); return retval; } @@ -267,7 +267,7 @@ COMMAND_HANDLER(handle_flash_erase_address_command) COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length); if (length <= 0) { - command_print(CMD_CTX, "Length must be >0"); + command_print(CMD, "Length must be >0"); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -289,7 +289,7 @@ COMMAND_HANDLER(handle_flash_erase_address_command) retval = flash_erase_address_range(target, do_pad, address, length); if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) { - command_print(CMD_CTX, "erased address " TARGET_ADDR_FMT " (length %" + command_print(CMD, "erased address " TARGET_ADDR_FMT " (length %" PRIi32 ")" " in %fs (%0.3f KiB/s)", address, length, duration_elapsed(&bench), duration_kbps(&bench, length)); @@ -320,13 +320,13 @@ COMMAND_HANDLER(handle_flash_erase_command) COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], last); if (!(first <= last)) { - command_print(CMD_CTX, "ERROR: " + command_print(CMD, "ERROR: " "first sector must be <= last"); return ERROR_FAIL; } if (!(last <= (uint32_t)(p->num_sectors - 1))) { - command_print(CMD_CTX, "ERROR: " + command_print(CMD, "ERROR: " "last sector must be <= %" PRIu32, p->num_sectors - 1); return ERROR_FAIL; @@ -338,7 +338,7 @@ COMMAND_HANDLER(handle_flash_erase_command) retval = flash_driver_erase(p, first, last); if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) { - command_print(CMD_CTX, "erased sectors %" PRIu32 " " + command_print(CMD, "erased sectors %" PRIu32 " " "through %" PRIu32 " on flash bank %d " "in %fs", first, last, p->bank_number, duration_elapsed(&bench)); } @@ -377,14 +377,14 @@ COMMAND_HANDLER(handle_flash_protect_command) COMMAND_PARSE_ON_OFF(CMD_ARGV[3], set); if (!(first <= last)) { - command_print(CMD_CTX, "ERROR: " + command_print(CMD, "ERROR: " "first %s must be <= last", (p->num_prot_blocks) ? "block" : "sector"); return ERROR_FAIL; } if (!(last <= (uint32_t)(num_blocks - 1))) { - command_print(CMD_CTX, "ERROR: " + command_print(CMD, "ERROR: " "last %s must be <= %" PRIu32, (p->num_prot_blocks) ? "block" : "sector", num_blocks - 1); @@ -393,7 +393,7 @@ COMMAND_HANDLER(handle_flash_protect_command) retval = flash_driver_protect(p, set, first, last); if (retval == ERROR_OK) { - command_print(CMD_CTX, "%s protection for %s %" PRIu32 + command_print(CMD, "%s protection for %s %" PRIu32 " through %" PRIu32 " on flash bank %d", (set) ? "set" : "cleared", (p->num_prot_blocks) ? "blocks" : "sectors", @@ -421,12 +421,12 @@ COMMAND_HANDLER(handle_flash_write_image_command) auto_erase = 1; CMD_ARGV++; CMD_ARGC--; - command_print(CMD_CTX, "auto erase enabled"); + command_print(CMD, "auto erase enabled"); } else if (strcmp(CMD_ARGV[0], "unlock") == 0) { auto_unlock = true; CMD_ARGV++; CMD_ARGC--; - command_print(CMD_CTX, "auto unlock enabled"); + command_print(CMD, "auto unlock enabled"); } else break; } @@ -463,7 +463,7 @@ COMMAND_HANDLER(handle_flash_write_image_command) } if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) { - command_print(CMD_CTX, "wrote %" PRIu32 " bytes from file %s " + command_print(CMD, "wrote %" PRIu32 " bytes from file %s " "in %fs (%0.3f KiB/s)", written, CMD_ARGV[0], duration_elapsed(&bench), duration_kbps(&bench, written)); } @@ -602,7 +602,7 @@ COMMAND_HANDLER(handle_flash_fill_command) } if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) { - command_print(CMD_CTX, "wrote %" PRIu32 " bytes to " TARGET_ADDR_FMT + command_print(CMD, "wrote %" PRIu32 " bytes to " TARGET_ADDR_FMT " in %fs (%0.3f KiB/s)", size_bytes, address, duration_elapsed(&bench), duration_kbps(&bench, size_bytes)); } @@ -716,7 +716,7 @@ COMMAND_HANDLER(handle_flash_write_bank_command) free(buffer); if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) { - command_print(CMD_CTX, "wrote %zu bytes from file %s to flash bank %u" + command_print(CMD, "wrote %zu bytes from file %s to flash bank %u" " at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)", length, CMD_ARGV[1], bank->bank_number, offset, duration_elapsed(&bench), duration_kbps(&bench, length)); @@ -798,7 +798,7 @@ COMMAND_HANDLER(handle_flash_read_bank_command) } if (duration_measure(&bench) == ERROR_OK) - command_print(CMD_CTX, "wrote %zd bytes to file %s from flash bank %u" + command_print(CMD, "wrote %zd bytes to file %s from flash bank %u" " at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)", written, CMD_ARGV[1], p->bank_number, offset, duration_elapsed(&bench), duration_kbps(&bench, written)); @@ -900,23 +900,23 @@ COMMAND_HANDLER(handle_flash_verify_bank_command) } if (duration_measure(&bench) == ERROR_OK) - command_print(CMD_CTX, "read %zd bytes from file %s and flash bank %u" + command_print(CMD, "read %zd bytes from file %s and flash bank %u" " at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)", length, CMD_ARGV[1], p->bank_number, offset, duration_elapsed(&bench), duration_kbps(&bench, length)); differ = memcmp(buffer_file, buffer_flash, length); - command_print(CMD_CTX, "contents %s", differ ? "differ" : "match"); + command_print(CMD, "contents %s", differ ? "differ" : "match"); if (differ) { uint32_t t; int diffs = 0; for (t = 0; t < length; t++) { if (buffer_flash[t] == buffer_file[t]) continue; - command_print(CMD_CTX, "diff %d address 0x%08x. Was 0x%02x instead of 0x%02x", + command_print(CMD, "diff %d address 0x%08x. Was 0x%02x instead of 0x%02x", diffs, t + offset, buffer_flash[t], buffer_file[t]); if (diffs++ >= 127) { - command_print(CMD_CTX, "More than 128 errors, the rest are not printed."); + command_print(CMD, "More than 128 errors, the rest are not printed."); break; } keep_alive(); @@ -952,7 +952,7 @@ COMMAND_HANDLER(handle_flash_padded_value_command) COMMAND_PARSE_NUMBER(u8, CMD_ARGV[1], p->default_padded_value); - command_print(CMD_CTX, "Default padded value set to 0x%" PRIx8 " for flash bank %u", \ + command_print(CMD, "Default padded value set to 0x%" PRIx8 " for flash bank %u", \ p->default_padded_value, p->bank_number); return retval; @@ -985,7 +985,7 @@ static const struct command_registration flash_exec_command_handlers[] = { .name = "erase_sector", .handler = handle_flash_erase_command, .mode = COMMAND_EXEC, - .usage = "bank_id first_sector_num last_sector_num", + .usage = "bank_id first_sector_num (last_sector_num|'last')", .help = "Erase a range of sectors in a flash bank.", }, { @@ -1167,7 +1167,7 @@ COMMAND_HANDLER(handle_flash_banks_command) unsigned n = 0; for (struct flash_bank *p = flash_bank_list(); p; p = p->next, n++) { - LOG_USER("#%d : %s (%s) at " TARGET_ADDR_FMT ", size 0x%8.8" PRIx32 ", " + command_print(CMD, "#%d : %s (%s) at " TARGET_ADDR_FMT ", size 0x%8.8" PRIx32 ", " "buswidth %u, chipwidth %u", p->bank_number, p->name, p->driver->name, p->base, p->size, p->bus_width, p->chip_width); @@ -1239,12 +1239,14 @@ static const struct command_registration flash_config_command_handlers[] = { .mode = COMMAND_CONFIG, .handler = handle_flash_init_command, .help = "Initialize flash devices.", + .usage = "", }, { .name = "banks", .mode = COMMAND_ANY, .handler = handle_flash_banks_command, .help = "Display table with information about flash banks.", + .usage = "", }, { .name = "list", @@ -1260,6 +1262,7 @@ static const struct command_registration flash_command_handlers[] = { .mode = COMMAND_ANY, .help = "NOR flash command group", .chain = flash_config_command_handlers, + .usage = "", }, COMMAND_REGISTRATION_DONE }; diff --git a/src/flash/nor/tms470.c b/src/flash/nor/tms470.c index 195d1ae..90557b8 100644 --- a/src/flash/nor/tms470.c +++ b/src/flash/nor/tms470.c @@ -301,7 +301,7 @@ COMMAND_HANDLER(tms470_handle_flash_keyset_command) int start = (0 == strncmp(CMD_ARGV[i], "0x", 2)) ? 2 : 0; if (1 != sscanf(&CMD_ARGV[i][start], "%" SCNx32 "", &flashKeys[i])) { - command_print(CMD_CTX, "could not process flash key %s", + command_print(CMD, "could not process flash key %s", CMD_ARGV[i]); LOG_ERROR("could not process flash key %s", CMD_ARGV[i]); return ERROR_COMMAND_SYNTAX_ERROR; @@ -310,19 +310,19 @@ COMMAND_HANDLER(tms470_handle_flash_keyset_command) keysSet = 1; } else if (CMD_ARGC != 0) { - command_print(CMD_CTX, "tms470 flash_keyset <key0> <key1> <key2> <key3>"); + command_print(CMD, "tms470 flash_keyset <key0> <key1> <key2> <key3>"); return ERROR_COMMAND_SYNTAX_ERROR; } if (keysSet) { - command_print(CMD_CTX, + command_print(CMD, "using flash keys 0x%08" PRIx32 ", 0x%08" PRIx32 ", 0x%08" PRIx32 ", 0x%08" PRIx32 "", flashKeys[0], flashKeys[1], flashKeys[2], flashKeys[3]); } else - command_print(CMD_CTX, "flash keys not set"); + command_print(CMD, "flash keys not set"); return ERROR_OK; } @@ -352,12 +352,12 @@ COMMAND_HANDLER(tms470_handle_osc_megahertz_command) if (oscMHz <= 0) { LOG_ERROR("osc_megahertz must be positive and non-zero!"); - command_print(CMD_CTX, "osc_megahertz must be positive and non-zero!"); + command_print(CMD, "osc_megahertz must be positive and non-zero!"); oscMHz = 12; return ERROR_COMMAND_SYNTAX_ERROR; } - command_print(CMD_CTX, "osc_megahertz=%d", oscMHz); + command_print(CMD, "osc_megahertz=%d", oscMHz); return ERROR_OK; } @@ -375,7 +375,7 @@ COMMAND_HANDLER(tms470_handle_plldis_command) plldis = plldis ? 1 : 0; } - command_print(CMD_CTX, "plldis=%d", plldis); + command_print(CMD, "plldis=%d", plldis); return ERROR_OK; } diff --git a/src/flash/nor/xmc4xxx.c b/src/flash/nor/xmc4xxx.c index c56adb5..d6a1ad4 100644 --- a/src/flash/nor/xmc4xxx.c +++ b/src/flash/nor/xmc4xxx.c @@ -1284,9 +1284,9 @@ COMMAND_HANDLER(xmc4xxx_handle_flash_password_command) fb->pw_set = true; - command_print(CMD_CTX, "XMC4xxx flash passwords set to:\n"); - command_print(CMD_CTX, "-0x%08"PRIx32"\n", fb->pw1); - command_print(CMD_CTX, "-0x%08"PRIx32"\n", fb->pw2); + command_print(CMD, "XMC4xxx flash passwords set to:\n"); + command_print(CMD, "-0x%08"PRIx32"\n", fb->pw1); + command_print(CMD, "-0x%08"PRIx32"\n", fb->pw2); return ERROR_OK; } @@ -1329,7 +1329,8 @@ static const struct command_registration xmc4xxx_exec_command_handlers[] = { .usage = "bank_id user_level[0-1]", .help = "Permanently Removes flash protection (read and write) " "for the specified user level", - }, COMMAND_REGISTRATION_DONE + }, + COMMAND_REGISTRATION_DONE }; static const struct command_registration xmc4xxx_command_handlers[] = { diff --git a/src/hello.c b/src/hello.c index 25938bc..a1c00c0 100644 --- a/src/hello.c +++ b/src/hello.c @@ -89,7 +89,7 @@ COMMAND_HANDLER(handle_hello_command) const char *sep, *name; int retval = CALL_COMMAND_HANDLER(handle_hello_args, &sep, &name); if (ERROR_OK == retval) - command_print(CMD_CTX, "Greetings%s%s!", sep, name); + command_print(CMD, "Greetings%s%s!", sep, name); return retval; } @@ -105,8 +105,8 @@ const struct command_registration hello_command_handlers[] = { .name = "foo", .mode = COMMAND_ANY, .help = "example command handler skeleton", - .chain = foo_command_handlers, + .usage = "", }, COMMAND_REGISTRATION_DONE }; diff --git a/src/helper/Makefile.am b/src/helper/Makefile.am index e0f7f49..2b3523f 100644 --- a/src/helper/Makefile.am +++ b/src/helper/Makefile.am @@ -16,6 +16,7 @@ noinst_LTLIBRARIES += %D%/libhelper.la %D%/jep106.c \ %D%/jim-nvp.c \ %D%/binarybuffer.h \ + %D%/bits.h \ %D%/configuration.h \ %D%/ioutil.h \ %D%/list.h \ diff --git a/src/helper/binarybuffer.h b/src/helper/binarybuffer.h index f1da8c4..7ac221e 100644 --- a/src/helper/binarybuffer.h +++ b/src/helper/binarybuffer.h @@ -118,7 +118,7 @@ static inline uint32_t buf_get_u32(const uint8_t *_buffer, uint32_t result = 0; for (unsigned i = first; i < first + num; i++) { if (((buffer[i / 8] >> (i % 8)) & 1) == 1) - result |= 1 << (i - first); + result |= 1U << (i - first); } return result; } diff --git a/src/helper/bits.h b/src/helper/bits.h new file mode 100644 index 0000000..464584d --- /dev/null +++ b/src/helper/bits.h @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2018, STMicroelectronics - All Rights Reserved + * Author(s): Antonio Borneo <borneo.antonio@gmail.com> for STMicroelectronics + * + * 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, see <http://www.gnu.org/licenses/>. + */ + +/* + * The content of this file is mainly copied/inspired from Linux kernel + * code in include/linux/types.h include/linux/bitmap.h include/linux/bitops.h + */ + +#ifndef OPENOCD_HELPER_BITS_H +#define OPENOCD_HELPER_BITS_H + +#include <helper/types.h> + +#define BIT(nr) (1UL << (nr)) +#define BITS_PER_BYTE 8 +#define BITS_PER_LONG (BITS_PER_BYTE * sizeof(long)) +#define BITS_TO_LONGS(nr) DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long)) +#define BIT_MASK(nr) (1UL << ((nr) % BITS_PER_LONG)) +#define BIT_WORD(nr) ((nr) / BITS_PER_LONG) +#define DECLARE_BITMAP(name, bits) unsigned long name[BITS_TO_LONGS(bits)] + +/** + * bitmap_zero - Clears all the bits in memory + * @dst: the address of the bitmap + * @nbits: the number of bits to clear + */ +static inline void bitmap_zero(unsigned long *dst, unsigned int nbits) +{ + unsigned int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long); + memset(dst, 0, len); +} + +/** + * clear_bit - Clear a bit in memory + * @nr: the bit to set + * @addr: the address to start counting from + */ +static inline void clear_bit(unsigned int nr, volatile unsigned long *addr) +{ + unsigned long mask = BIT_MASK(nr); + unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr); + + *p &= ~mask; +} + +/** + * set_bit - Set a bit in memory + * @nr: the bit to set + * @addr: the address to start counting from + */ +static inline void set_bit(unsigned int nr, volatile unsigned long *addr) +{ + unsigned long mask = BIT_MASK(nr); + unsigned long *p = ((unsigned long *)addr) + BIT_WORD(nr); + + *p |= mask; +} + +/** + * test_bit - Determine whether a bit is set + * @nr: bit number to test + * @addr: Address to start counting from + */ +static inline int test_bit(unsigned int nr, const volatile unsigned long *addr) +{ + return 1UL & (addr[BIT_WORD(nr)] >> (nr % BITS_PER_LONG)); +} + +#endif /* OPENOCD_HELPER_BITS_H */ diff --git a/src/helper/command.c b/src/helper/command.c index 7a3c2d4..d969933 100644 --- a/src/helper/command.c +++ b/src/helper/command.c @@ -190,7 +190,7 @@ struct command_context *current_command_context(Jim_Interp *interp) } static int script_command_run(Jim_Interp *interp, - int argc, Jim_Obj * const *argv, struct command *c, bool capture) + int argc, Jim_Obj * const *argv, struct command *c) { target_call_timer_callbacks_now(); LOG_USER_N("%s", ""); /* Keep GDB connection alive*/ @@ -200,15 +200,9 @@ static int script_command_run(Jim_Interp *interp, if (NULL == words) return JIM_ERR; - struct log_capture_state *state = NULL; - if (capture) - state = command_log_capture_start(interp); - struct command_context *cmd_ctx = current_command_context(interp); int retval = run_command(cmd_ctx, c, (const char **)words, nwords); - command_log_capture_finish(state); - script_command_args_free(words, nwords); return command_retval_set(interp, retval); } @@ -220,7 +214,7 @@ static int script_command(Jim_Interp *interp, int argc, Jim_Obj *const *argv) struct command *c = interp->cmdPrivData; assert(c); script_debug(interp, c->name, argc, argv); - return script_command_run(interp, argc, argv, c, true); + return script_command_run(interp, argc, argv, c); } static struct command *command_root(struct command *c) @@ -316,7 +310,7 @@ static struct command *command_new(struct command_context *cmd_ctx, * arguments. */ if ((cr->jim_handler == NULL) && (cr->usage == NULL)) { - LOG_DEBUG("BUG: command '%s%s%s' does not have the " + LOG_ERROR("BUG: command '%s%s%s' does not have the " "'.usage' field filled out", parent && parent->name ? parent->name : "", parent && parent->name ? " " : "", @@ -357,27 +351,11 @@ static int register_command_handler(struct command_context *cmd_ctx, struct command *c) { Jim_Interp *interp = cmd_ctx->interp; - char *ocd_name = alloc_printf("ocd_%s", c->name); - if (NULL == ocd_name) - return JIM_ERR; - LOG_DEBUG("registering '%s'...", ocd_name); + LOG_DEBUG("registering '%s'...", c->name); Jim_CmdProc *func = c->handler ? &script_command : &command_unknown; - int retval = Jim_CreateCommand(interp, ocd_name, func, c, NULL); - free(ocd_name); - if (JIM_OK != retval) - return retval; - - /* we now need to add an overrideable proc */ - char *override_name = alloc_printf( - "proc %s {args} {eval ocd_bouncer %s $args}", - c->name, c->name); - if (NULL == override_name) - return JIM_ERR; - - retval = Jim_Eval_Named(interp, override_name, 0, 0); - free(override_name); + int retval = Jim_CreateCommand(interp, c->name, func, c, NULL); return retval; } @@ -502,7 +480,7 @@ void command_output_text(struct command_context *context, const char *data) context->output_handler(context, data); } -void command_print_sameline(struct command_context *context, const char *format, ...) +void command_print_sameline(struct command_invocation *cmd, const char *format, ...) { char *string; @@ -510,13 +488,13 @@ void command_print_sameline(struct command_context *context, const char *format, va_start(ap, format); string = alloc_vprintf(format, ap); - if (string != NULL) { + if (string != NULL && cmd) { /* we want this collected in the log + we also want to pick it up as a tcl return * value. * * The latter bit isn't precisely neat, but will do for now. */ - LOG_USER_N("%s", string); + Jim_AppendString(cmd->ctx->interp, cmd->output, string, -1); /* We already printed it above * command_output_text(context, string); */ free(string); @@ -525,7 +503,7 @@ void command_print_sameline(struct command_context *context, const char *format, va_end(ap); } -void command_print(struct command_context *context, const char *format, ...) +void command_print(struct command_invocation *cmd, const char *format, ...) { char *string; @@ -533,7 +511,7 @@ void command_print(struct command_context *context, const char *format, ...) va_start(ap, format); string = alloc_vprintf(format, ap); - if (string != NULL) { + if (string != NULL && cmd) { strcat(string, "\n"); /* alloc_vprintf guaranteed the buffer to be at least one *char longer */ /* we want this collected in the log + we also want to pick it up as a tcl return @@ -541,7 +519,7 @@ void command_print(struct command_context *context, const char *format, ...) * * The latter bit isn't precisely neat, but will do for now. */ - LOG_USER_N("%s", string); + Jim_AppendString(cmd->ctx->interp, cmd->output, string, -1); /* We already printed it above * command_output_text(context, string); */ free(string); @@ -628,6 +606,9 @@ static int run_command(struct command_context *context, if (c->jim_handler_data) context->current_target_override = c->jim_handler_data; + cmd.output = Jim_NewEmptyStringObj(context->interp); + Jim_IncrRefCount(cmd.output); + int retval = c->handler(&cmd); if (c->jim_handler_data) @@ -642,15 +623,17 @@ static int run_command(struct command_context *context, } } else if (retval == ERROR_COMMAND_CLOSE_CONNECTION) { /* just fall through for a shutdown request */ - } else if (retval != ERROR_OK) { - /* we do not print out an error message because the command *should* - * have printed out an error - */ - char *full_name = command_name(c, ' '); - LOG_DEBUG("Command '%s' failed with error code %d", - full_name ? full_name : c->name, retval); - free(full_name); + } else { + if (retval != ERROR_OK) { + char *full_name = command_name(c, ' '); + LOG_DEBUG("Command '%s' failed with error code %d", + full_name ? full_name : c->name, retval); + free(full_name); + } + /* Use the command output as the Tcl result */ + Jim_SetResult(context->interp, cmd.output); } + Jim_DecrRefCount(context->interp, cmd.output); return retval; } @@ -669,9 +652,11 @@ int command_run_line(struct command_context *context, char *line) * happen when the Jim Tcl interpreter is provided by eCos for * instance. */ + struct target *saved_target_override = context->current_target_override; context->current_target_override = NULL; Jim_Interp *interp = context->interp; + struct command_context *old_context = Jim_GetAssocData(interp, "context"); Jim_DeleteAssocData(interp, "context"); retcode = Jim_SetAssocData(interp, "context", NULL, context); if (retcode == JIM_OK) { @@ -684,25 +669,19 @@ int command_run_line(struct command_context *context, char *line) Jim_DeleteAssocData(interp, "retval"); } Jim_DeleteAssocData(interp, "context"); + int inner_retcode = Jim_SetAssocData(interp, "context", NULL, old_context); + if (retcode == JIM_OK) + retcode = inner_retcode; } + context->current_target_override = saved_target_override; if (retcode == JIM_OK) { const char *result; int reslen; result = Jim_GetString(Jim_GetResult(interp), &reslen); if (reslen > 0) { - int i; - char buff[256 + 1]; - for (i = 0; i < reslen; i += 256) { - int chunk; - chunk = reslen - i; - if (chunk > 256) - chunk = 256; - strncpy(buff, result + i, chunk); - buff[chunk] = 0; - LOG_USER_N("%s", buff); - } - LOG_USER_N("\n"); + command_output_text(context, result); + command_output_text(context, "\n"); } retval = ERROR_OK; } else if (retcode == JIM_EXIT) { @@ -712,6 +691,7 @@ int command_run_line(struct command_context *context, char *line) return retcode; } else { Jim_MakeErrorMessage(interp); + /* error is broadcast */ LOG_USER("%s", Jim_GetString(Jim_GetResult(interp), NULL)); if (retval == ERROR_OK) { @@ -827,8 +807,6 @@ static COMMAND_HELPER(command_help_find, struct command *head, if (0 == CMD_ARGC) return ERROR_COMMAND_SYNTAX_ERROR; *out = command_find(head, CMD_ARGV[0]); - if (NULL == *out && strncmp(CMD_ARGV[0], "ocd_", 4) == 0) - *out = command_find(head, CMD_ARGV[0] + 4); if (NULL == *out) return ERROR_COMMAND_SYNTAX_ERROR; if (--CMD_ARGC == 0) @@ -982,34 +960,85 @@ COMMAND_HANDLER(handle_help_command) } static int command_unknown_find(unsigned argc, Jim_Obj *const *argv, - struct command *head, struct command **out, bool top_level) + struct command *head, struct command **out) { if (0 == argc) return argc; const char *cmd_name = Jim_GetString(argv[0], NULL); struct command *c = command_find(head, cmd_name); - if (NULL == c && top_level && strncmp(cmd_name, "ocd_", 4) == 0) - c = command_find(head, cmd_name + 4); if (NULL == c) return argc; *out = c; - return command_unknown_find(--argc, ++argv, (*out)->children, out, false); + return command_unknown_find(--argc, ++argv, (*out)->children, out); +} + +static char *alloc_concatenate_strings(int argc, Jim_Obj * const *argv) +{ + char *prev, *all; + int i; + + assert(argc >= 1); + + all = strdup(Jim_GetString(argv[0], NULL)); + if (!all) { + LOG_ERROR("Out of memory"); + return NULL; + } + + for (i = 1; i < argc; ++i) { + prev = all; + all = alloc_printf("%s %s", all, Jim_GetString(argv[i], NULL)); + free(prev); + if (!all) { + LOG_ERROR("Out of memory"); + return NULL; + } + } + + return all; +} + +static int run_usage(Jim_Interp *interp, int argc_valid, int argc, Jim_Obj * const *argv) +{ + struct command_context *cmd_ctx = current_command_context(interp); + char *command; + int retval; + + assert(argc_valid >= 1); + assert(argc >= argc_valid); + + command = alloc_concatenate_strings(argc_valid, argv); + if (!command) + return JIM_ERR; + + retval = command_run_linef(cmd_ctx, "usage %s", command); + if (retval != ERROR_OK) { + LOG_ERROR("unable to execute command \"usage %s\"", command); + return JIM_ERR; + } + + if (argc_valid == argc) + LOG_ERROR("%s: command requires more arguments", command); + else { + free(command); + command = alloc_concatenate_strings(argc - argc_valid, argv + argc_valid); + if (!command) + return JIM_ERR; + LOG_ERROR("invalid subcommand \"%s\"", command); + } + + free(command); + return retval; } static int command_unknown(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { const char *cmd_name = Jim_GetString(argv[0], NULL); - if (strcmp(cmd_name, "unknown") == 0) { - if (argc == 1) - return JIM_OK; - argc--; - argv++; - } script_debug(interp, cmd_name, argc, argv); struct command_context *cmd_ctx = current_command_context(interp); struct command *c = cmd_ctx->commands; - int remaining = command_unknown_find(argc, argv, c, &c, true); + int remaining = command_unknown_find(argc, argv, c, &c); /* if nothing could be consumed, then it's really an unknown command */ if (remaining == argc) { const char *cmd = Jim_GetString(argv[0], NULL); @@ -1017,7 +1046,6 @@ static int command_unknown(Jim_Interp *interp, int argc, Jim_Obj *const *argv) return JIM_OK; } - bool found = true; Jim_Obj *const *start; unsigned count; if (c->handler || c->jim_handler) { @@ -1025,14 +1053,10 @@ static int command_unknown(Jim_Interp *interp, int argc, Jim_Obj *const *argv) count = remaining + 1; start = argv + (argc - remaining - 1); } else { - c = command_find(cmd_ctx->commands, "usage"); - if (NULL == c) { - LOG_ERROR("unknown command, but usage is missing too"); - return JIM_ERR; - } count = argc - remaining; start = argv; - found = false; + run_usage(interp, count, argc, start); + return JIM_ERR; } /* pass the command through to the intended handler */ if (c->jim_handler) { @@ -1043,7 +1067,7 @@ static int command_unknown(Jim_Interp *interp, int argc, Jim_Obj *const *argv) return (*c->jim_handler)(interp, count, start); } - return script_command_run(interp, count, start, c, found); + return script_command_run(interp, count, start, c); } static int jim_command_mode(Jim_Interp *interp, int argc, Jim_Obj *const *argv) @@ -1053,7 +1077,7 @@ static int jim_command_mode(Jim_Interp *interp, int argc, Jim_Obj *const *argv) if (argc > 1) { struct command *c = cmd_ctx->commands; - int remaining = command_unknown_find(argc - 1, argv + 1, c, &c, true); + int remaining = command_unknown_find(argc - 1, argv + 1, c, &c); /* if nothing could be consumed, then it's an unknown command */ if (remaining == argc - 1) { Jim_SetResultString(interp, "unknown", -1); @@ -1082,32 +1106,6 @@ static int jim_command_mode(Jim_Interp *interp, int argc, Jim_Obj *const *argv) return JIM_OK; } -static int jim_command_type(Jim_Interp *interp, int argc, Jim_Obj *const *argv) -{ - if (1 == argc) - return JIM_ERR; - - struct command_context *cmd_ctx = current_command_context(interp); - struct command *c = cmd_ctx->commands; - int remaining = command_unknown_find(argc - 1, argv + 1, c, &c, true); - /* if nothing could be consumed, then it's an unknown command */ - if (remaining == argc - 1) { - Jim_SetResultString(interp, "unknown", -1); - return JIM_OK; - } - - if (c->jim_handler) - Jim_SetResultString(interp, "native", -1); - else if (c->handler) - Jim_SetResultString(interp, "simple", -1); - else if (remaining == 0) - Jim_SetResultString(interp, "group", -1); - else - Jim_SetResultString(interp, "unknown", -1); - - return JIM_OK; -} - int help_add_command(struct command_context *cmd_ctx, struct command *parent, const char *cmd_name, const char *help_text, const char *usage) { @@ -1119,7 +1117,7 @@ int help_add_command(struct command_context *cmd_ctx, struct command *parent, .name = cmd_name, .mode = COMMAND_ANY, .help = help_text, - .usage = usage, + .usage = usage ? : "", }; nc = register_command(cmd_ctx, parent, &cr); if (NULL == nc) { @@ -1144,8 +1142,9 @@ int help_add_command(struct command_context *cmd_ctx, struct command *parent, if (usage) { bool replaced = false; if (nc->usage) { + if (*nc->usage) + replaced = true; free(nc->usage); - replaced = true; } nc->usage = strdup(usage); if (replaced) @@ -1227,15 +1226,6 @@ static const struct command_registration command_subcommand_handlers[] = { "Returns 'unknown' if an unknown command is given. " "Command can be multiple tokens.", }, - { - .name = "type", - .mode = COMMAND_ANY, - .jim_handler = jim_command_type, - .usage = "command_name [...]", - .help = "Returns the type of built-in command:" - "'native', 'simple', 'group', or 'unknown'. " - "Command can be multiple tokens.", - }, COMMAND_REGISTRATION_DONE }; @@ -1294,6 +1284,7 @@ static const struct command_registration command_builtin_handlers[] = { .mode = COMMAND_ANY, .help = "core command group (introspection)", .chain = command_subcommand_handlers, + .usage = "", }, COMMAND_REGISTRATION_DONE }; @@ -1403,6 +1394,7 @@ void process_jim_events(struct command_context *cmd_ctx) return ERROR_COMMAND_ARGUMENT_INVALID; \ } \ char *end; \ + errno = 0; \ *ul = func(str, &end, 0); \ if (*end) { \ LOG_ERROR("Invalid command argument"); \ diff --git a/src/helper/command.h b/src/helper/command.h index f9c02e5..733ba42 100644 --- a/src/helper/command.h +++ b/src/helper/command.h @@ -79,6 +79,7 @@ struct command_invocation { const char *name; unsigned argc; const char **argv; + Jim_Obj *output; }; /** @@ -122,6 +123,11 @@ struct command_invocation { #define COMMAND_HELPER(name, extra ...) __COMMAND_HANDLER(name, extra) /** + * Use this macro to access the command being handled, + * rather than accessing the variable directly. It may be moved. + */ +#define CMD (cmd) +/** * Use this macro to access the context of the command being handled, * rather than accessing the variable directly. It may be moved. */ @@ -348,9 +354,9 @@ struct command_context *copy_command_context(struct command_context *cmd_ctx); */ void command_done(struct command_context *context); -void command_print(struct command_context *context, const char *format, ...) +void command_print(struct command_invocation *cmd, const char *format, ...) __attribute__ ((format (PRINTF_ATTRIBUTE_FORMAT, 2, 3))); -void command_print_sameline(struct command_context *context, const char *format, ...) +void command_print_sameline(struct command_invocation *cmd, const char *format, ...) __attribute__ ((format (PRINTF_ATTRIBUTE_FORMAT, 2, 3))); int command_run_line(struct command_context *context, char *line); int command_run_linef(struct command_context *context, const char *format, ...) @@ -404,7 +410,7 @@ DECLARE_PARSE_WRAPPER(_target_addr, target_addr_t); do { \ int retval_macro_tmp = parse_ ## type(in, &(out)); \ if (ERROR_OK != retval_macro_tmp) { \ - command_print(CMD_CTX, stringify(out) \ + command_print(CMD, stringify(out) \ " option value ('%s') is not valid", in); \ return retval_macro_tmp; \ } \ @@ -424,9 +430,9 @@ DECLARE_PARSE_WRAPPER(_target_addr, target_addr_t); bool value; \ int retval_macro_tmp = command_parse_bool_arg(in, &value); \ if (ERROR_OK != retval_macro_tmp) { \ - command_print(CMD_CTX, stringify(out) \ + command_print(CMD, stringify(out) \ " option value ('%s') is not valid", in); \ - command_print(CMD_CTX, " choices are '%s' or '%s'", \ + command_print(CMD, " choices are '%s' or '%s'", \ on, off); \ return retval_macro_tmp; \ } \ diff --git a/src/helper/ioutil.c b/src/helper/ioutil.c index f1123cd..d4f39e2 100644 --- a/src/helper/ioutil.c +++ b/src/helper/ioutil.c @@ -113,10 +113,10 @@ COMMAND_HANDLER(handle_cat_command) int retval = load_file(CMD_ARGV[0], &data, &len); if (retval == ERROR_OK) { - command_print(CMD_CTX, "%s", data); + command_print(CMD, "%s", data); free(data); } else - command_print(CMD_CTX, "%s not found", CMD_ARGV[0]); + command_print(CMD, "%s not found", CMD_ARGV[0]); return ERROR_OK; } @@ -146,10 +146,10 @@ COMMAND_HANDLER(handle_meminfo_command) info = mallinfo(); if (prev > 0) - command_print(CMD_CTX, "Diff: %d", prev - info.fordblks); + command_print(CMD, "Diff: %d", prev - info.fordblks); prev = info.fordblks; - command_print(CMD_CTX, "Available ram: %d", info.fordblks); + command_print(CMD, "Available ram: %d", info.fordblks); return ERROR_OK; } @@ -217,7 +217,7 @@ COMMAND_HANDLER(handle_cp_command) if (retval != ERROR_OK) break; - command_print(CMD_CTX, "%zu", len - pos); + command_print(CMD, "%zu", len - pos); pos += chunk; @@ -226,9 +226,9 @@ COMMAND_HANDLER(handle_cp_command) } if (retval == ERROR_OK) - command_print(CMD_CTX, "Copied %s to %s", CMD_ARGV[0], CMD_ARGV[1]); + command_print(CMD, "Copied %s to %s", CMD_ARGV[0], CMD_ARGV[1]); else - command_print(CMD_CTX, "copy failed"); + command_print(CMD, "copy failed"); if (data != NULL) free(data); @@ -472,6 +472,7 @@ static const struct command_registration ioutil_command_handlers[] = { .handler = handle_meminfo_command, .mode = COMMAND_ANY, .help = "display free heap space", + .usage = "", }, #endif { diff --git a/src/helper/log.c b/src/helper/log.c index f980774..d65430c 100644 --- a/src/helper/log.c +++ b/src/helper/log.c @@ -213,7 +213,7 @@ COMMAND_HANDLER(handle_debug_level_command) } else if (CMD_ARGC > 1) return ERROR_COMMAND_SYNTAX_ERROR; - command_print(CMD_CTX, "debug_level: %i", debug_level); + command_print(CMD, "debug_level: %i", debug_level); return ERROR_OK; } @@ -236,7 +236,7 @@ COMMAND_HANDLER(handle_log_output_command) return ERROR_OK; } -static struct command_registration log_command_handlers[] = { +static const struct command_registration log_command_handlers[] = { { .name = "log_output", .handler = handle_log_output_command, diff --git a/src/helper/options.c b/src/helper/options.c index 12755e0..b60d58d 100644 --- a/src/helper/options.c +++ b/src/helper/options.c @@ -269,19 +269,14 @@ int parse_cmdline_args(struct command_context *cmd_ctx, int argc, char *argv[]) break; case 'd': /* --debug | -d */ { - char *command = alloc_printf("debug_level %s", optarg ? optarg : "3"); - int retval = command_run_line(cmd_ctx, command); - free(command); + int retval = command_run_linef(cmd_ctx, "debug_level %s", optarg ? optarg : "3"); if (retval != ERROR_OK) return retval; break; } case 'l': /* --log_output | -l */ - if (optarg) { - char *command = alloc_printf("log_output %s", optarg); - command_run_line(cmd_ctx, command); - free(command); - } + if (optarg) + command_run_linef(cmd_ctx, "log_output %s", optarg); break; case 'c': /* --command | -c */ if (optarg) diff --git a/src/helper/startup.tcl b/src/helper/startup.tcl index 2578de9..691e382 100644 --- a/src/helper/startup.tcl +++ b/src/helper/startup.tcl @@ -3,43 +3,6 @@ # Embedded into OpenOCD executable # - -# We need to explicitly redirect this to the OpenOCD command -# as Tcl defines the exit proc -proc exit {} { - ocd_throw exit -} - -# All commands are registered with an 'ocd_' prefix, while the "real" -# command is a wrapper that calls this function. Its primary purpose is -# to discard 'handler' command output. -# Due to the two nested proc calls, this wrapper has to explicitly run -# the wrapped command in the stack frame two levels above. -proc ocd_bouncer {name args} { - set cmd [format "ocd_%s" $name] - set type [eval ocd_command type $cmd $args] - set errcode error - set skiplevel [expr [eval info level] > 1 ? 2 : 1] - if {$type == "native"} { - return [uplevel $skiplevel $cmd $args] - } else {if {$type == "simple"} { - set errcode [catch {uplevel $skiplevel $cmd $args}] - if {$errcode == 0} { - return "" - } else { - # 'classic' commands output error message as part of progress output - set errmsg "" - } - } else {if {$type == "group"} { - catch {eval ocd_usage $name $args} - set errmsg [format "%s: command requires more arguments" \ - [concat $name " " $args]] - } else { - set errmsg [format "invalid subcommand \"%s\"" $args] - }}} - return -code $errcode $errmsg -} - # Try flipping / and \ to find file if the filename does not # match the precise spelling proc find {filename} { diff --git a/src/jtag/adapter.c b/src/jtag/adapter.c index 3fb52a7..29a9613 100644 --- a/src/jtag/adapter.c +++ b/src/jtag/adapter.c @@ -66,30 +66,6 @@ static int jim_adapter_name(Jim_Interp *interp, int argc, Jim_Obj * const *argv) return JIM_OK; } -static int default_khz(int khz, int *jtag_speed) -{ - LOG_ERROR("Translation from khz to jtag_speed not implemented"); - return ERROR_FAIL; -} - -static int default_speed_div(int speed, int *khz) -{ - LOG_ERROR("Translation from jtag_speed to khz not implemented"); - return ERROR_FAIL; -} - -static int default_power_dropout(int *dropout) -{ - *dropout = 0; /* by default we can't detect power dropout */ - return ERROR_OK; -} - -static int default_srst_asserted(int *srst_asserted) -{ - *srst_asserted = 0; /* by default we can't detect srst asserted */ - return ERROR_OK; -} - COMMAND_HANDLER(interface_transport_command) { char **transports; @@ -114,10 +90,10 @@ COMMAND_HANDLER(handle_interface_list_command) if (strcmp(CMD_NAME, "interface_list") == 0 && CMD_ARGC > 0) return ERROR_COMMAND_SYNTAX_ERROR; - command_print(CMD_CTX, "The following debug interfaces are available:"); + command_print(CMD, "The following debug interfaces are available:"); for (unsigned i = 0; NULL != jtag_interfaces[i]; i++) { const char *name = jtag_interfaces[i]->name; - command_print(CMD_CTX, "%u: %s", i + 1, name); + command_print(CMD, "%u: %s", i + 1, name); } return ERROR_OK; @@ -150,29 +126,7 @@ COMMAND_HANDLER(handle_interface_command) jtag_interface = jtag_interfaces[i]; - /* LEGACY SUPPORT ... adapter drivers must declare what - * transports they allow. Until they all do so, assume - * the legacy drivers are JTAG-only - */ - if (!jtag_interface->transports) - LOG_WARNING("Adapter driver '%s' did not declare " - "which transports it allows; assuming " - "legacy JTAG-only", jtag_interface->name); - retval = allow_transports(CMD_CTX, jtag_interface->transports - ? jtag_interface->transports : jtag_only); - if (ERROR_OK != retval) - return retval; - - if (jtag_interface->khz == NULL) - jtag_interface->khz = default_khz; - if (jtag_interface->speed_div == NULL) - jtag_interface->speed_div = default_speed_div; - if (jtag_interface->power_dropout == NULL) - jtag_interface->power_dropout = default_power_dropout; - if (jtag_interface->srst_asserted == NULL) - jtag_interface->srst_asserted = default_srst_asserted; - - return ERROR_OK; + return allow_transports(CMD_CTX, jtag_interface->transports); } /* no valid interface was found (i.e. the configuration option, @@ -394,7 +348,7 @@ next: modes[5] = ""; } - command_print(CMD_CTX, "%s %s%s%s%s%s", + command_print(CMD, "%s %s%s%s%s%s", modes[0], modes[1], modes[2], modes[3], modes[4], modes[5]); @@ -411,7 +365,7 @@ COMMAND_HANDLER(handle_adapter_nsrst_delay_command) jtag_set_nsrst_delay(delay); } - command_print(CMD_CTX, "adapter_nsrst_delay: %u", jtag_get_nsrst_delay()); + command_print(CMD, "adapter_nsrst_delay: %u", jtag_get_nsrst_delay()); return ERROR_OK; } @@ -425,7 +379,7 @@ COMMAND_HANDLER(handle_adapter_nsrst_assert_width_command) jtag_set_nsrst_assert_width(width); } - command_print(CMD_CTX, "adapter_nsrst_assert_width: %u", jtag_get_nsrst_assert_width()); + command_print(CMD, "adapter_nsrst_assert_width: %u", jtag_get_nsrst_assert_width()); return ERROR_OK; } @@ -450,9 +404,9 @@ COMMAND_HANDLER(handle_adapter_khz_command) return retval; if (cur_speed) - command_print(CMD_CTX, "adapter speed: %d kHz", cur_speed); + command_print(CMD, "adapter speed: %d kHz", cur_speed); else - command_print(CMD_CTX, "adapter speed: RCLK - adaptive"); + command_print(CMD, "adapter speed: RCLK - adaptive"); return retval; } @@ -464,7 +418,7 @@ COMMAND_HANDLER(handle_usb_location_command) if (CMD_ARGC == 1) jtag_usb_set_location(CMD_ARGV[0]); - command_print(CMD_CTX, "adapter usb location: %s", jtag_usb_get_location()); + command_print(CMD, "adapter usb location: %s", jtag_usb_get_location()); return ERROR_OK; } @@ -476,8 +430,8 @@ static const struct command_registration adapter_usb_command_handlers[] = { .name = "location", .handler = &handle_usb_location_command, .mode = COMMAND_CONFIG, - .help = "set the USB bus location of the USB device", - .usage = "<bus>-port[.port]...", + .help = "display or set the USB bus location of the USB device", + .usage = "[<bus>-port[.port]...]", }, #endif /* HAVE_LIBUSB_GET_PORT_NUMBERS */ COMMAND_REGISTRATION_DONE @@ -555,6 +509,7 @@ static const struct command_registration interface_command_handlers[] = { .handler = handle_interface_list_command, .mode = COMMAND_ANY, .help = "List all built-in debug adapter interfaces (drivers)", + .usage = "", }, { .name = "reset_config", diff --git a/src/jtag/aice/aice_interface.c b/src/jtag/aice/aice_interface.c index c758bb4..c83b8c2 100644 --- a/src/jtag/aice/aice_interface.c +++ b/src/jtag/aice/aice_interface.c @@ -150,7 +150,7 @@ static int aice_execute_reset(struct jtag_command *cmd) static int last_trst; int retval = ERROR_OK; - DEBUG_JTAG_IO("reset trst: %d", cmd->cmd.reset->trst); + LOG_DEBUG_IO("reset trst: %d", cmd->cmd.reset->trst); if (cmd->cmd.reset->trst != last_trst) { if (cmd->cmd.reset->trst) @@ -269,10 +269,10 @@ COMMAND_HANDLER(aice_handle_aice_info_command) { LOG_DEBUG("aice_handle_aice_info_command"); - command_print(CMD_CTX, "Description: %s", param.device_desc); - command_print(CMD_CTX, "Serial number: %s", param.serial); + command_print(CMD, "Description: %s", param.device_desc); + command_print(CMD, "Serial number: %s", param.serial); if (strncmp(aice_port->name, "aice_pipe", 9) == 0) - command_print(CMD_CTX, "Adapter: %s", param.adapter_name); + command_print(CMD, "Adapter: %s", param.adapter_name); return ERROR_OK; } diff --git a/src/jtag/aice/aice_transport.c b/src/jtag/aice/aice_transport.c index 0658318..15ebcac 100644 --- a/src/jtag/aice/aice_transport.c +++ b/src/jtag/aice/aice_transport.c @@ -165,9 +165,9 @@ COMMAND_HANDLER(handle_scan_chain_command) aice_scan_jtag_chain(); tap = jtag_all_taps(); - command_print(CMD_CTX, + command_print(CMD, " TapName Enabled IdCode Expected IrLen IrCap IrMask"); - command_print(CMD_CTX, + command_print(CMD, "-- ------------------- -------- ---------- ---------- ----- ----- ------"); while (tap) { @@ -183,7 +183,7 @@ COMMAND_HANDLER(handle_scan_chain_command) expected = buf_get_u32(tap->expected, 0, tap->ir_length); expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length); - command_print(CMD_CTX, + command_print(CMD, "%2d %-18s %c 0x%08x %s %5d 0x%02x 0x%02x", tap->abs_chain_position, tap->dotted_name, @@ -200,7 +200,7 @@ COMMAND_HANDLER(handle_scan_chain_command) if (tap->ignore_version) expected_id[2] = '*'; - command_print(CMD_CTX, + command_print(CMD, " %s", expected_id); } diff --git a/src/jtag/aice/aice_usb.c b/src/jtag/aice/aice_usb.c index f67ea7c..324ec7c 100644 --- a/src/jtag/aice/aice_usb.c +++ b/src/jtag/aice/aice_usb.c @@ -400,7 +400,7 @@ static int aice_usb_write(uint8_t *out_buffer, int out_length) result = usb_bulk_write_ex(aice_handler.usb_handle, aice_handler.usb_write_ep, (char *)out_buffer, out_length, AICE_USB_TIMEOUT); - DEBUG_JTAG_IO("aice_usb_write, out_length = %i, result = %i", + LOG_DEBUG_IO("aice_usb_write, out_length = %i, result = %i", out_length, result); return result; @@ -412,7 +412,7 @@ static int aice_usb_read(uint8_t *in_buffer, int expected_size) int32_t result = usb_bulk_read_ex(aice_handler.usb_handle, aice_handler.usb_read_ep, (char *)in_buffer, expected_size, AICE_USB_TIMEOUT); - DEBUG_JTAG_IO("aice_usb_read, result = %" PRId32, result); + LOG_DEBUG_IO("aice_usb_read, result = %" PRId32, result); return result; } @@ -2812,7 +2812,7 @@ static int aice_issue_reset_hold(uint32_t coreid) /* set no_dbgi_pin to 0 */ uint32_t pin_status; aice_read_ctrl(AICE_READ_CTRL_GET_JTAG_PIN_STATUS, &pin_status); - if (pin_status | 0x4) + if (pin_status & 0x4) aice_write_ctrl(AICE_WRITE_CTRL_JTAG_PIN_STATUS, pin_status & (~0x4)); /* issue restart */ diff --git a/src/jtag/commands.c b/src/jtag/commands.c index e2d22cc..3352e03 100644 --- a/src/jtag/commands.c +++ b/src/jtag/commands.c @@ -193,33 +193,33 @@ int jtag_build_buffer(const struct scan_command *cmd, uint8_t **buffer) bit_count = 0; - DEBUG_JTAG_IO("%s num_fields: %i", + 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) { -#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); - - LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i, - cmd->fields[i].num_bits, char_buf); - free(char_buf); -#endif + if (LOG_LEVEL_IS(LOG_LVL_DEBUG_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); + + 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 { - DEBUG_JTAG_IO("fields[%i].out_value[%i]: NULL", + LOG_DEBUG_IO("fields[%i].out_value[%i]: NULL", i, cmd->fields[i].num_bits); } bit_count += cmd->fields[i].num_bits; } - /*DEBUG_JTAG_IO("bit_count totalling: %i", bit_count); */ + /*LOG_DEBUG_IO("bit_count totalling: %i", bit_count); */ return bit_count; } @@ -242,16 +242,16 @@ int jtag_read_buffer(uint8_t *buffer, const struct scan_command *cmd) uint8_t *captured = buf_set_buf(buffer, bit_count, malloc(DIV_ROUND_UP(num_bits, 8)), 0, num_bits); -#ifdef _DEBUG_JTAG_IO_ - char *char_buf = buf_to_str(captured, - (num_bits > DEBUG_JTAG_IOZ) + if (LOG_LEVEL_IS(LOG_LVL_DEBUG_IO)) { + char *char_buf = buf_to_str(captured, + (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ - : num_bits, 16); + : num_bits, 16); - LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", - i, num_bits, char_buf); - free(char_buf); -#endif + 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); diff --git a/src/jtag/core.c b/src/jtag/core.c index 876faae..5e7c1e4 100644 --- a/src/jtag/core.c +++ b/src/jtag/core.c @@ -1007,7 +1007,7 @@ static bool jtag_examine_chain_match_tap(const struct jtag_tap *tap) return true; /* optionally ignore the JTAG version field - bits 28-31 of IDCODE */ - uint32_t mask = tap->ignore_version ? ~(0xf << 28) : ~0; + uint32_t mask = tap->ignore_version ? ~(0xfU << 28) : ~0U; uint32_t idcode = tap->idcode & mask; /* Loop over the expected identification codes and test for a match */ @@ -1348,19 +1348,6 @@ int adapter_init(struct command_context *cmd_ctx) return retval; jtag = jtag_interface; - /* LEGACY SUPPORT ... adapter drivers must declare what - * transports they allow. Until they all do so, assume - * the legacy drivers are JTAG-only - */ - if (!transports_are_declared()) { - LOG_ERROR("Adapter driver '%s' did not declare " - "which transports it allows; assuming " - "JTAG-only", jtag->name); - retval = allow_transports(cmd_ctx, jtag_only); - if (retval != ERROR_OK) - return retval; - } - if (jtag->speed == NULL) { LOG_INFO("This adapter doesn't support configurable speed"); return ERROR_OK; @@ -1611,14 +1598,18 @@ static int adapter_khz_to_speed(unsigned khz, int *speed) { LOG_DEBUG("convert khz to interface specific speed value"); speed_khz = khz; - if (jtag != NULL) { - LOG_DEBUG("have interface set up"); - int speed_div1; - int retval = jtag->khz(jtag_get_speed_khz(), &speed_div1); - if (ERROR_OK != retval) - return retval; - *speed = speed_div1; + if (!jtag) + return ERROR_OK; + LOG_DEBUG("have interface set up"); + if (!jtag->khz) { + LOG_ERROR("Translation from khz to jtag_speed not implemented"); + return ERROR_FAIL; } + int speed_div1; + int retval = jtag->khz(jtag_get_speed_khz(), &speed_div1); + if (ERROR_OK != retval) + return retval; + *speed = speed_div1; return ERROR_OK; } @@ -1681,7 +1672,13 @@ int jtag_get_speed_readable(int *khz) int retval = jtag_get_speed(&jtag_speed_var); if (retval != ERROR_OK) return retval; - return jtag ? jtag->speed_div(jtag_speed_var, khz) : ERROR_OK; + if (!jtag) + return ERROR_OK; + if (!jtag->speed_div) { + LOG_ERROR("Translation from jtag_speed to khz not implemented"); + return ERROR_FAIL; + } + return jtag->speed_div(jtag_speed_var, khz); } void jtag_set_verify(bool enable) @@ -1712,12 +1709,20 @@ int jtag_power_dropout(int *dropout) LOG_ERROR("No Valid JTAG Interface Configured."); exit(-1); } - return jtag->power_dropout(dropout); + if (jtag->power_dropout) + return jtag->power_dropout(dropout); + + *dropout = 0; /* by default we can't detect power dropout */ + return ERROR_OK; } int jtag_srst_asserted(int *srst_asserted) { - return jtag->srst_asserted(srst_asserted); + if (jtag->srst_asserted) + return jtag->srst_asserted(srst_asserted); + + *srst_asserted = 0; /* by default we can't detect srst asserted */ + return ERROR_OK; } enum reset_types jtag_get_reset_config(void) diff --git a/src/jtag/drivers/amt_jtagaccel.c b/src/jtag/drivers/amt_jtagaccel.c index 57c0ce6..045672f 100644 --- a/src/jtag/drivers/amt_jtagaccel.c +++ b/src/jtag/drivers/amt_jtagaccel.c @@ -343,35 +343,27 @@ static int amt_jtagaccel_execute_queue(void) while (cmd) { switch (cmd->type) { case JTAG_RESET: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("reset trst: %i srst %i", - cmd->cmd.reset->trst, - cmd->cmd.reset->srst); -#endif + LOG_DEBUG_IO("reset trst: %i srst %i", + cmd->cmd.reset->trst, + cmd->cmd.reset->srst); if (cmd->cmd.reset->trst == 1) tap_set_state(TAP_RESET); amt_jtagaccel_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); break; case JTAG_RUNTEST: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("runtest %i cycles, end in %i", - cmd->cmd.runtest->num_cycles, - cmd->cmd.runtest->end_state); -#endif + LOG_DEBUG_IO("runtest %i cycles, end in %i", + cmd->cmd.runtest->num_cycles, + cmd->cmd.runtest->end_state); amt_jtagaccel_end_state(cmd->cmd.runtest->end_state); amt_jtagaccel_runtest(cmd->cmd.runtest->num_cycles); break; case JTAG_TLR_RESET: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state); -#endif + LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state); amt_jtagaccel_end_state(cmd->cmd.statemove->end_state); amt_jtagaccel_state_move(); break; case JTAG_SCAN: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("scan end in %i", cmd->cmd.scan->end_state); -#endif + LOG_DEBUG_IO("scan end in %i", cmd->cmd.scan->end_state); amt_jtagaccel_end_state(cmd->cmd.scan->end_state); scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); type = jtag_scan_type(cmd->cmd.scan); @@ -382,9 +374,7 @@ static int amt_jtagaccel_execute_queue(void) free(buffer); break; case JTAG_SLEEP: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("sleep %" PRIi32, cmd->cmd.sleep->us); -#endif + LOG_DEBUG_IO("sleep %" PRIi32, cmd->cmd.sleep->us); jtag_sleep(cmd->cmd.sleep->us); break; default: @@ -548,7 +538,7 @@ COMMAND_HANDLER(amt_jtagaccel_handle_parport_port_command) } } - command_print(CMD_CTX, "parport port = %u", amt_jtagaccel_port); + command_print(CMD, "parport port = %u", amt_jtagaccel_port); return ERROR_OK; } @@ -556,7 +546,7 @@ COMMAND_HANDLER(amt_jtagaccel_handle_parport_port_command) COMMAND_HANDLER(amt_jtagaccel_handle_rtck_command) { if (CMD_ARGC == 0) { - command_print(CMD_CTX, + command_print(CMD, "amt_jtagaccel RTCK feature %s", (rtck_enabled) ? "enabled" : "disabled"); return ERROR_OK; @@ -596,6 +586,7 @@ static const struct command_registration amtjtagaccel_command_handlers[] = { struct jtag_interface amt_jtagaccel_interface = { .name = "amt_jtagaccel", + .transports = jtag_only, .commands = amtjtagaccel_command_handlers, .init = amt_jtagaccel_init, diff --git a/src/jtag/drivers/arm-jtag-ew.c b/src/jtag/drivers/arm-jtag-ew.c index d9ea367..285bf9b 100644 --- a/src/jtag/drivers/arm-jtag-ew.c +++ b/src/jtag/drivers/arm-jtag-ew.c @@ -106,7 +106,7 @@ static int armjtagew_execute_queue(void) while (cmd != NULL) { switch (cmd->type) { case JTAG_RUNTEST: - DEBUG_JTAG_IO("runtest %i cycles, end in %i", + LOG_DEBUG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, \ cmd->cmd.runtest->end_state); @@ -115,14 +115,14 @@ static int armjtagew_execute_queue(void) break; case JTAG_TLR_RESET: - DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state); + LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state); armjtagew_end_state(cmd->cmd.statemove->end_state); armjtagew_state_move(); break; case JTAG_PATHMOVE: - DEBUG_JTAG_IO("pathmove: %i states, end in %i", \ + LOG_DEBUG_IO("pathmove: %i states, end in %i", \ cmd->cmd.pathmove->num_states, \ cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); @@ -131,12 +131,12 @@ static int armjtagew_execute_queue(void) break; case JTAG_SCAN: - DEBUG_JTAG_IO("scan end in %i", cmd->cmd.scan->end_state); + LOG_DEBUG_IO("scan end in %i", cmd->cmd.scan->end_state); armjtagew_end_state(cmd->cmd.scan->end_state); scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); - DEBUG_JTAG_IO("scan input, length = %d", scan_size); + LOG_DEBUG_IO("scan input, length = %d", scan_size); #ifdef _DEBUG_USB_COMMS_ armjtagew_debug_buffer(buffer, (scan_size + 7) / 8); @@ -148,7 +148,7 @@ static int armjtagew_execute_queue(void) break; case JTAG_RESET: - DEBUG_JTAG_IO("reset trst: %i srst %i", + LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); @@ -160,7 +160,7 @@ static int armjtagew_execute_queue(void) break; case JTAG_SLEEP: - DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us); + LOG_DEBUG_IO("sleep %i", cmd->cmd.sleep->us); armjtagew_tap_execute(); jtag_sleep(cmd->cmd.sleep->us); break; @@ -490,6 +490,7 @@ static const struct command_registration armjtagew_command_handlers[] = { .handler = &armjtagew_handle_armjtagew_info_command, .mode = COMMAND_EXEC, .help = "query armjtagew info", + .usage = "", }, COMMAND_REGISTRATION_DONE }; @@ -646,7 +647,7 @@ static int armjtagew_tap_execute(void) /* Copy to buffer */ buf_set_buf(tdo_buffer, first, buffer, 0, length); - DEBUG_JTAG_IO("pending scan result, length = %d", length); + LOG_DEBUG_IO("pending scan result, length = %d", length); #ifdef _DEBUG_USB_COMMS_ armjtagew_debug_buffer(buffer, byte_length); @@ -746,7 +747,7 @@ static int armjtagew_usb_write(struct armjtagew *armjtagew, int out_length) result = usb_bulk_write(armjtagew->usb_handle, ARMJTAGEW_EPT_BULK_OUT, \ (char *)usb_out_buffer, out_length, ARMJTAGEW_USB_TIMEOUT); - DEBUG_JTAG_IO("armjtagew_usb_write, out_length = %d, result = %d", out_length, result); + LOG_DEBUG_IO("armjtagew_usb_write, out_length = %d, result = %d", out_length, result); #ifdef _DEBUG_USB_COMMS_ armjtagew_debug_buffer(usb_out_buffer, out_length); @@ -760,7 +761,7 @@ static int armjtagew_usb_read(struct armjtagew *armjtagew, int exp_in_length) int result = usb_bulk_read(armjtagew->usb_handle, ARMJTAGEW_EPT_BULK_IN, \ (char *)usb_in_buffer, exp_in_length, ARMJTAGEW_USB_TIMEOUT); - DEBUG_JTAG_IO("armjtagew_usb_read, result = %d", result); + LOG_DEBUG_IO("armjtagew_usb_read, result = %d", result); #ifdef _DEBUG_USB_COMMS_ armjtagew_debug_buffer(usb_in_buffer, result); diff --git a/src/jtag/drivers/at91rm9200.c b/src/jtag/drivers/at91rm9200.c index 0015da0..ac65563 100644 --- a/src/jtag/drivers/at91rm9200.c +++ b/src/jtag/drivers/at91rm9200.c @@ -183,7 +183,8 @@ static const struct command_registration at91rm9200_command_handlers[] = { .name = "at91rm9200_device", .handler = &at91rm9200_handle_device_command, .mode = COMMAND_CONFIG, - .help = "query armjtagew info", + .help = "Set at91rm9200 device [default \"rea_ecr\"]", + .usage = "<device>", }, COMMAND_REGISTRATION_DONE }; @@ -191,6 +192,7 @@ static const struct command_registration at91rm9200_command_handlers[] = { struct jtag_interface at91rm9200_interface = { .name = "at91rm9200", .execute_queue = bitbang_execute_queue, + .transports = jtag_only, .commands = at91rm9200_command_handlers, .init = at91rm9200_init, .quit = at91rm9200_quit, diff --git a/src/jtag/drivers/bcm2835gpio.c b/src/jtag/drivers/bcm2835gpio.c index 38ef163..36e10b6 100644 --- a/src/jtag/drivers/bcm2835gpio.c +++ b/src/jtag/drivers/bcm2835gpio.c @@ -199,7 +199,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_jtag_gpionums) return ERROR_COMMAND_SYNTAX_ERROR; } - command_print(CMD_CTX, + command_print(CMD, "BCM2835 GPIO config: tck = %d, tms = %d, tdi = %d, tdo = %d", tck_gpio, tms_gpio, tdi_gpio, tdo_gpio); @@ -211,7 +211,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_jtag_gpionum_tck) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tck_gpio); - command_print(CMD_CTX, "BCM2835 GPIO config: tck = %d", tck_gpio); + command_print(CMD, "BCM2835 GPIO config: tck = %d", tck_gpio); return ERROR_OK; } @@ -220,7 +220,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_jtag_gpionum_tms) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tms_gpio); - command_print(CMD_CTX, "BCM2835 GPIO config: tms = %d", tms_gpio); + command_print(CMD, "BCM2835 GPIO config: tms = %d", tms_gpio); return ERROR_OK; } @@ -229,7 +229,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_jtag_gpionum_tdo) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdo_gpio); - command_print(CMD_CTX, "BCM2835 GPIO config: tdo = %d", tdo_gpio); + command_print(CMD, "BCM2835 GPIO config: tdo = %d", tdo_gpio); return ERROR_OK; } @@ -238,7 +238,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_jtag_gpionum_tdi) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdi_gpio); - command_print(CMD_CTX, "BCM2835 GPIO config: tdi = %d", tdi_gpio); + command_print(CMD, "BCM2835 GPIO config: tdi = %d", tdi_gpio); return ERROR_OK; } @@ -247,7 +247,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_jtag_gpionum_srst) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], srst_gpio); - command_print(CMD_CTX, "BCM2835 GPIO config: srst = %d", srst_gpio); + command_print(CMD, "BCM2835 GPIO config: srst = %d", srst_gpio); return ERROR_OK; } @@ -256,7 +256,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_jtag_gpionum_trst) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], trst_gpio); - command_print(CMD_CTX, "BCM2835 GPIO config: trst = %d", trst_gpio); + command_print(CMD, "BCM2835 GPIO config: trst = %d", trst_gpio); return ERROR_OK; } @@ -269,7 +269,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_swd_gpionums) return ERROR_COMMAND_SYNTAX_ERROR; } - command_print(CMD_CTX, + command_print(CMD, "BCM2835 GPIO nums: swclk = %d, swdio = %d", swclk_gpio, swdio_gpio); @@ -281,7 +281,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_swd_gpionum_swclk) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swclk_gpio); - command_print(CMD_CTX, "BCM2835 num: swclk = %d", swclk_gpio); + command_print(CMD, "BCM2835 num: swclk = %d", swclk_gpio); return ERROR_OK; } @@ -290,7 +290,7 @@ COMMAND_HANDLER(bcm2835gpio_handle_swd_gpionum_swdio) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swdio_gpio); - command_print(CMD_CTX, "BCM2835 num: swdio = %d", swdio_gpio); + command_print(CMD, "BCM2835 num: swdio = %d", swdio_gpio); return ERROR_OK; } @@ -300,6 +300,9 @@ COMMAND_HANDLER(bcm2835gpio_handle_speed_coeffs) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], speed_coeff); COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], speed_offset); } + + command_print(CMD, "BCM2835 GPIO: speed_coeffs = %d, speed_offset = %d", + speed_coeff, speed_offset); return ERROR_OK; } @@ -307,6 +310,9 @@ COMMAND_HANDLER(bcm2835gpio_handle_peripheral_base) { if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], bcm2835_peri_base); + + command_print(CMD, "BCM2835 GPIO: peripheral_base = 0x%08x", + bcm2835_peri_base); return ERROR_OK; } @@ -316,74 +322,84 @@ static const struct command_registration bcm2835gpio_command_handlers[] = { .handler = &bcm2835gpio_handle_jtag_gpionums, .mode = COMMAND_CONFIG, .help = "gpio numbers for tck, tms, tdi, tdo. (in that order)", - .usage = "(tck tms tdi tdo)* ", + .usage = "[tck tms tdi tdo]", }, { .name = "bcm2835gpio_tck_num", .handler = &bcm2835gpio_handle_jtag_gpionum_tck, .mode = COMMAND_CONFIG, .help = "gpio number for tck.", + .usage = "[tck]", }, { .name = "bcm2835gpio_tms_num", .handler = &bcm2835gpio_handle_jtag_gpionum_tms, .mode = COMMAND_CONFIG, .help = "gpio number for tms.", + .usage = "[tms]", }, { .name = "bcm2835gpio_tdo_num", .handler = &bcm2835gpio_handle_jtag_gpionum_tdo, .mode = COMMAND_CONFIG, .help = "gpio number for tdo.", + .usage = "[tdo]", }, { .name = "bcm2835gpio_tdi_num", .handler = &bcm2835gpio_handle_jtag_gpionum_tdi, .mode = COMMAND_CONFIG, .help = "gpio number for tdi.", + .usage = "[tdi]", }, { .name = "bcm2835gpio_swd_nums", .handler = &bcm2835gpio_handle_swd_gpionums, .mode = COMMAND_CONFIG, .help = "gpio numbers for swclk, swdio. (in that order)", - .usage = "(swclk swdio)* ", + .usage = "[swclk swdio]", }, { .name = "bcm2835gpio_swclk_num", .handler = &bcm2835gpio_handle_swd_gpionum_swclk, .mode = COMMAND_CONFIG, .help = "gpio number for swclk.", + .usage = "[swclk]", }, { .name = "bcm2835gpio_swdio_num", .handler = &bcm2835gpio_handle_swd_gpionum_swdio, .mode = COMMAND_CONFIG, .help = "gpio number for swdio.", + .usage = "[swdio]", }, { .name = "bcm2835gpio_srst_num", .handler = &bcm2835gpio_handle_jtag_gpionum_srst, .mode = COMMAND_CONFIG, .help = "gpio number for srst.", + .usage = "[srst]", }, { .name = "bcm2835gpio_trst_num", .handler = &bcm2835gpio_handle_jtag_gpionum_trst, .mode = COMMAND_CONFIG, .help = "gpio number for trst.", + .usage = "[trst]", }, { .name = "bcm2835gpio_speed_coeffs", .handler = &bcm2835gpio_handle_speed_coeffs, .mode = COMMAND_CONFIG, .help = "SPEED_COEFF and SPEED_OFFSET for delay calculations.", + .usage = "[SPEED_COEFF SPEED_OFFSET]", }, { .name = "bcm2835gpio_peripheral_base", .handler = &bcm2835gpio_handle_peripheral_base, .mode = COMMAND_CONFIG, .help = "peripheral base to access GPIOs (RPi1 0x20000000, RPi2 0x3F000000).", + .usage = "[base]", }, COMMAND_REGISTRATION_DONE diff --git a/src/jtag/drivers/bitbang.c b/src/jtag/drivers/bitbang.c index da4fb33..b5078c0 100644 --- a/src/jtag/drivers/bitbang.c +++ b/src/jtag/drivers/bitbang.c @@ -100,7 +100,7 @@ static int bitbang_execute_tms(struct jtag_command *cmd) unsigned num_bits = cmd->cmd.tms->num_bits; const uint8_t *bits = cmd->cmd.tms->bits; - DEBUG_JTAG_IO("TMS: %d bits", num_bits); + LOG_DEBUG_IO("TMS: %d bits", num_bits); int tms = 0; for (unsigned i = 0; i < num_bits; i++) { @@ -315,11 +315,9 @@ int bitbang_execute_queue(void) while (cmd) { switch (cmd->type) { case JTAG_RESET: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("reset trst: %i srst %i", - cmd->cmd.reset->trst, - cmd->cmd.reset->srst); -#endif + LOG_DEBUG_IO("reset trst: %i srst %i", + cmd->cmd.reset->trst, + cmd->cmd.reset->srst); if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST))) tap_set_state(TAP_RESET); @@ -328,11 +326,9 @@ int bitbang_execute_queue(void) return ERROR_FAIL; break; case JTAG_RUNTEST: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("runtest %i cycles, end in %s", + LOG_DEBUG_IO("runtest %i cycles, end in %s", cmd->cmd.runtest->num_cycles, tap_state_name(cmd->cmd.runtest->end_state)); -#endif bitbang_end_state(cmd->cmd.runtest->end_state); if (bitbang_runtest(cmd->cmd.runtest->num_cycles) != ERROR_OK) return ERROR_FAIL; @@ -347,32 +343,26 @@ int bitbang_execute_queue(void) break; case JTAG_TLR_RESET: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("statemove end in %s", + LOG_DEBUG_IO("statemove end in %s", tap_state_name(cmd->cmd.statemove->end_state)); -#endif bitbang_end_state(cmd->cmd.statemove->end_state); if (bitbang_state_move(0) != ERROR_OK) return ERROR_FAIL; break; case JTAG_PATHMOVE: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("pathmove: %i states, end in %s", + LOG_DEBUG_IO("pathmove: %i states, end in %s", cmd->cmd.pathmove->num_states, tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1])); -#endif if (bitbang_path_move(cmd->cmd.pathmove) != ERROR_OK) return ERROR_FAIL; break; case JTAG_SCAN: bitbang_end_state(cmd->cmd.scan->end_state); scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("%s scan %d bits; end in %s", + LOG_DEBUG_IO("%s scan %d bits; end in %s", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size, tap_state_name(cmd->cmd.scan->end_state)); -#endif type = jtag_scan_type(cmd->cmd.scan); if (bitbang_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size) != ERROR_OK) @@ -383,9 +373,7 @@ int bitbang_execute_queue(void) free(buffer); break; case JTAG_SLEEP: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("sleep %" PRIi32, cmd->cmd.sleep->us); -#endif + LOG_DEBUG_IO("sleep %" PRIi32, cmd->cmd.sleep->us); jtag_sleep(cmd->cmd.sleep->us); break; case JTAG_TMS: diff --git a/src/jtag/drivers/bitq.c b/src/jtag/drivers/bitq.c index 55dfe0a..9b4eeed 100644 --- a/src/jtag/drivers/bitq.c +++ b/src/jtag/drivers/bitq.c @@ -59,9 +59,7 @@ static void bitq_in_proc(void) int tdo = bitq_interface->in(); if (tdo < 0) { -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("bitq in EOF"); -#endif + LOG_DEBUG_IO("bitq in EOF"); return; } if (in_mask == 0x01) @@ -228,9 +226,7 @@ int bitq_execute_queue(void) while (cmd) { switch (cmd->type) { case JTAG_RESET: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); -#endif + LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST))) @@ -241,37 +237,26 @@ int bitq_execute_queue(void) break; case JTAG_RUNTEST: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state); -#endif + LOG_DEBUG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state); bitq_end_state(cmd->cmd.runtest->end_state); bitq_runtest(cmd->cmd.runtest->num_cycles); break; case JTAG_TLR_RESET: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state); -#endif + LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state); bitq_end_state(cmd->cmd.statemove->end_state); bitq_state_move(tap_get_end_state()); /* uncoditional TAP move */ break; case JTAG_PATHMOVE: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, + LOG_DEBUG_IO("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); -#endif bitq_path_move(cmd->cmd.pathmove); break; case JTAG_SCAN: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("scan end in %i", cmd->cmd.scan->end_state); - if (cmd->cmd.scan->ir_scan) - LOG_DEBUG("scan ir"); - else - LOG_DEBUG("scan dr"); -#endif + LOG_DEBUG_IO("scan end in %i", cmd->cmd.scan->end_state); + LOG_DEBUG_IO("scan %s", cmd->cmd.scan->ir_scan ? "ir" : "dr"); bitq_end_state(cmd->cmd.scan->end_state); bitq_scan(cmd->cmd.scan); if (tap_get_state() != tap_get_end_state()) @@ -279,9 +264,7 @@ int bitq_execute_queue(void) break; case JTAG_SLEEP: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("sleep %i", cmd->cmd.sleep->us); -#endif + LOG_DEBUG_IO("sleep %i", cmd->cmd.sleep->us); bitq_interface->sleep(cmd->cmd.sleep->us); if (bitq_interface->in_rdy()) bitq_in_proc(); diff --git a/src/jtag/drivers/buspirate.c b/src/jtag/drivers/buspirate.c index 35649c2..872896b 100644 --- a/src/jtag/drivers/buspirate.c +++ b/src/jtag/drivers/buspirate.c @@ -171,7 +171,7 @@ static int buspirate_execute_queue(void) while (cmd) { switch (cmd->type) { case JTAG_RUNTEST: - DEBUG_JTAG_IO("runtest %i cycles, end in %s", + LOG_DEBUG_IO("runtest %i cycles, end in %s", cmd->cmd.runtest->num_cycles, tap_state_name(cmd->cmd.runtest ->end_state)); @@ -181,7 +181,7 @@ static int buspirate_execute_queue(void) ->num_cycles); break; case JTAG_TLR_RESET: - DEBUG_JTAG_IO("statemove end in %s", + LOG_DEBUG_IO("statemove end in %s", tap_state_name(cmd->cmd.statemove ->end_state)); buspirate_end_state(cmd->cmd.statemove @@ -189,7 +189,7 @@ static int buspirate_execute_queue(void) buspirate_state_move(); break; case JTAG_PATHMOVE: - DEBUG_JTAG_IO("pathmove: %i states, end in %s", + LOG_DEBUG_IO("pathmove: %i states, end in %s", cmd->cmd.pathmove->num_states, tap_state_name(cmd->cmd.pathmove ->path[cmd->cmd.pathmove @@ -199,7 +199,7 @@ static int buspirate_execute_queue(void) cmd->cmd.pathmove->path); break; case JTAG_SCAN: - DEBUG_JTAG_IO("scan end in %s", + LOG_DEBUG_IO("scan end in %s", tap_state_name(cmd->cmd.scan ->end_state)); @@ -214,7 +214,7 @@ static int buspirate_execute_queue(void) break; case JTAG_RESET: - DEBUG_JTAG_IO("reset trst: %i srst %i", + LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); /* flush buffers, so we can reset */ @@ -226,12 +226,12 @@ static int buspirate_execute_queue(void) cmd->cmd.reset->srst); break; case JTAG_SLEEP: - DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us); + LOG_DEBUG_IO("sleep %i", cmd->cmd.sleep->us); buspirate_tap_execute(); jtag_sleep(cmd->cmd.sleep->us); break; case JTAG_STABLECLOCKS: - DEBUG_JTAG_IO("stable clock %i cycles", cmd->cmd.stableclocks->num_cycles); + LOG_DEBUG_IO("stable clock %i cycles", cmd->cmd.stableclocks->num_cycles); buspirate_stableclocks(cmd->cmd.stableclocks->num_cycles); break; default: @@ -491,6 +491,7 @@ static const struct command_registration buspirate_command_handlers[] = { .handler = &buspirate_handle_adc_command, .mode = COMMAND_EXEC, .help = "reads voltages on adc pins", + .usage = "", }, { .name = "buspirate_vreg", @@ -623,7 +624,7 @@ static void buspirate_runtest(int num_cycles) for (i = 0; i < num_cycles; i++) buspirate_tap_append(0, 0); - DEBUG_JTAG_IO("runtest: cur_state %s end_state %s", + LOG_DEBUG_IO("runtest: cur_state %s end_state %s", tap_state_name(tap_get_state()), tap_state_name(tap_get_end_state())); @@ -1311,7 +1312,7 @@ static int buspirate_swd_switch_seq(enum swd_special_seq seq) { const uint8_t *sequence; int sequence_len; - uint8_t tmp[64]; + uint32_t no_bytes, sequence_offset; switch (seq) { case LINE_RESET: @@ -1334,15 +1335,24 @@ static int buspirate_swd_switch_seq(enum swd_special_seq seq) return ERROR_FAIL; } - /* FIXME: all above sequences fit into one pirate command for now - * but it may cause trouble later - */ + no_bytes = sequence_len; + sequence_offset = 0; + + while (no_bytes) { + uint8_t tmp[17]; + uint32_t to_send; + + to_send = no_bytes > 16 ? 16 : no_bytes; + + tmp[0] = 0x10 + ((to_send - 1) & 0x0F); + memcpy(tmp + 1, &sequence[sequence_offset], to_send); - tmp[0] = 0x10 + ((sequence_len - 1) & 0x0F); - memcpy(tmp + 1, sequence, sequence_len); + buspirate_serial_write(buspirate_fd, tmp, to_send + 1); + buspirate_serial_read(buspirate_fd, tmp, to_send + 1); - buspirate_serial_write(buspirate_fd, tmp, sequence_len + 1); - buspirate_serial_read(buspirate_fd, tmp, sequence_len + 1); + no_bytes -= to_send; + sequence_offset += to_send; + } return ERROR_OK; } diff --git a/src/jtag/drivers/cmsis_dap_usb.c b/src/jtag/drivers/cmsis_dap_usb.c index 14a23d4..d52d698 100644 --- a/src/jtag/drivers/cmsis_dap_usb.c +++ b/src/jtag/drivers/cmsis_dap_usb.c @@ -1246,7 +1246,7 @@ static void cmsis_dap_flush(void) if (!queued_seq_count) return; - DEBUG_JTAG_IO("Flushing %d queued sequences (%d bytes) with %d pending scan results to capture", + LOG_DEBUG_IO("Flushing %d queued sequences (%d bytes) with %d pending scan results to capture", queued_seq_count, queued_seq_buf_end, pending_scan_result_count); /* prep CMSIS-DAP packet */ @@ -1268,7 +1268,7 @@ static void cmsis_dap_flush(void) } #ifdef CMSIS_DAP_JTAG_DEBUG - DEBUG_JTAG_IO("USB response buf:"); + LOG_DEBUG_IO("USB response buf:"); for (int c = 0; c < queued_seq_buf_end + 3; ++c) printf("%02X ", buffer[c]); printf("\n"); @@ -1277,7 +1277,7 @@ static void cmsis_dap_flush(void) /* copy scan results into client buffers */ for (int i = 0; i < pending_scan_result_count; ++i) { struct pending_scan_result *scan = &pending_scan_results[i]; - DEBUG_JTAG_IO("Copying pending_scan_result %d/%d: %d bits from byte %d -> buffer + %d bits", + LOG_DEBUG_IO("Copying pending_scan_result %d/%d: %d bits from byte %d -> buffer + %d bits", i, pending_scan_result_count, scan->length, scan->first + 2, scan->buffer_offset); #ifdef CMSIS_DAP_JTAG_DEBUG for (uint32_t b = 0; b < DIV_ROUND_UP(scan->length, 8); ++b) @@ -1302,7 +1302,7 @@ static void cmsis_dap_flush(void) static void cmsis_dap_add_jtag_sequence(int s_len, const uint8_t *sequence, int s_offset, bool tms, uint8_t *tdo_buffer, int tdo_buffer_offset) { - DEBUG_JTAG_IO("[at %d] %d bits, tms %s, seq offset %d, tdo buf %p, tdo offset %d", + LOG_DEBUG_IO("[at %d] %d bits, tms %s, seq offset %d, tdo buf %p, tdo offset %d", queued_seq_buf_end, s_len, tms ? "HIGH" : "LOW", s_offset, tdo_buffer, tdo_buffer_offset); @@ -1310,12 +1310,12 @@ static void cmsis_dap_add_jtag_sequence(int s_len, const uint8_t *sequence, int return; if (s_len > 64) { - DEBUG_JTAG_IO("START JTAG SEQ SPLIT"); + LOG_DEBUG_IO("START JTAG SEQ SPLIT"); for (int offset = 0; offset < s_len; offset += 64) { int len = s_len - offset; if (len > 64) len = 64; - DEBUG_JTAG_IO("Splitting long jtag sequence: %d-bit chunk starting at offset %d", len, offset); + LOG_DEBUG_IO("Splitting long jtag sequence: %d-bit chunk starting at offset %d", len, offset); cmsis_dap_add_jtag_sequence( len, sequence, @@ -1325,7 +1325,7 @@ static void cmsis_dap_add_jtag_sequence(int s_len, const uint8_t *sequence, int tdo_buffer == NULL ? 0 : (tdo_buffer_offset + offset) ); } - DEBUG_JTAG_IO("END JTAG SEQ SPLIT"); + LOG_DEBUG_IO("END JTAG SEQ SPLIT"); return; } @@ -1362,7 +1362,7 @@ static void cmsis_dap_add_jtag_sequence(int s_len, const uint8_t *sequence, int /* queue a sequence of bits to clock out TMS, executing if the buffer is full */ static void cmsis_dap_add_tms_sequence(const uint8_t *sequence, int s_len) { - DEBUG_JTAG_IO("%d bits: %02X", s_len, *sequence); + LOG_DEBUG_IO("%d bits: %02X", s_len, *sequence); /* we use a series of CMD_DAP_JTAG_SEQ commands to toggle TMS, because even though it seems ridiculously inefficient, it allows us to combine TMS and scan sequences into the same @@ -1383,7 +1383,7 @@ static void cmsis_dap_state_move(void) tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state()); tms_scan_bits = tap_get_tms_path_len(tap_get_state(), tap_get_end_state()); - DEBUG_JTAG_IO("state move from %s to %s: %d clocks, %02X on tms", + LOG_DEBUG_IO("state move from %s to %s: %d clocks, %02X on tms", tap_state_name(tap_get_state()), tap_state_name(tap_get_end_state()), tms_scan_bits, tms_scan); cmsis_dap_add_tms_sequence(&tms_scan, tms_scan_bits); @@ -1395,7 +1395,7 @@ static void cmsis_dap_state_move(void) /* Execute a JTAG scan operation by queueing TMS and TDI/TDO sequences */ static void cmsis_dap_execute_scan(struct jtag_command *cmd) { - DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", + LOG_DEBUG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", jtag_scan_type(cmd->cmd.scan)); /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */ @@ -1429,7 +1429,7 @@ static void cmsis_dap_execute_scan(struct jtag_command *cmd) for (int i = 0; i < cmd->cmd.scan->num_fields; i++, field++) { scan_size += field->num_bits; - DEBUG_JTAG_IO("%s%s field %d/%d %d bits", + LOG_DEBUG_IO("%s%s field %d/%d %d bits", field->in_value ? "in" : "", field->out_value ? "out" : "", i, @@ -1437,7 +1437,7 @@ static void cmsis_dap_execute_scan(struct jtag_command *cmd) field->num_bits); if (i == cmd->cmd.scan->num_fields - 1 && tap_get_state() != tap_get_end_state()) { - DEBUG_JTAG_IO("Last field and have to move out of SHIFT state"); + LOG_DEBUG_IO("Last field and have to move out of SHIFT state"); /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap * movement. This last field can't have length zero, it was checked above. */ cmsis_dap_add_jtag_sequence( @@ -1471,7 +1471,7 @@ static void cmsis_dap_execute_scan(struct jtag_command *cmd) 0); tap_set_state(tap_state_transition(tap_get_state(), 0)); } else { - DEBUG_JTAG_IO("Internal field, staying in SHIFT state afterwards"); + LOG_DEBUG_IO("Internal field, staying in SHIFT state afterwards"); /* Clocking part of a sequence into DR or IR with TMS=0, leaving TMS=0 at the end so we can continue later */ cmsis_dap_add_jtag_sequence( @@ -1489,7 +1489,7 @@ static void cmsis_dap_execute_scan(struct jtag_command *cmd) cmsis_dap_state_move(); } - DEBUG_JTAG_IO("%s scan, %i bits, end in %s", + LOG_DEBUG_IO("%s scan, %i bits, end in %s", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size, tap_state_name(tap_get_end_state())); } @@ -1519,7 +1519,7 @@ static void cmsis_dap_pathmove(int num_states, tap_state_t *path) static void cmsis_dap_execute_pathmove(struct jtag_command *cmd) { - DEBUG_JTAG_IO("pathmove: %i states, end in %i", + LOG_DEBUG_IO("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); @@ -1557,7 +1557,7 @@ static void cmsis_dap_runtest(int num_cycles) static void cmsis_dap_execute_runtest(struct jtag_command *cmd) { - DEBUG_JTAG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, + LOG_DEBUG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state); cmsis_dap_end_state(cmd->cmd.runtest->end_state); @@ -1566,13 +1566,13 @@ static void cmsis_dap_execute_runtest(struct jtag_command *cmd) static void cmsis_dap_execute_stableclocks(struct jtag_command *cmd) { - DEBUG_JTAG_IO("stableclocks %i cycles", cmd->cmd.runtest->num_cycles); + LOG_DEBUG_IO("stableclocks %i cycles", cmd->cmd.runtest->num_cycles); cmsis_dap_stableclocks(cmd->cmd.runtest->num_cycles); } static void cmsis_dap_execute_tms(struct jtag_command *cmd) { - DEBUG_JTAG_IO("TMS: %d bits", cmd->cmd.tms->num_bits); + LOG_DEBUG_IO("TMS: %d bits", cmd->cmd.tms->num_bits); cmsis_dap_cmd_DAP_SWJ_Sequence(cmd->cmd.tms->num_bits, cmd->cmd.tms->bits); } @@ -1653,15 +1653,6 @@ static int cmsis_dap_khz(int khz, int *jtag_speed) return ERROR_OK; } -static int_least32_t cmsis_dap_swd_frequency(int_least32_t hz) -{ - if (hz > 0) - cmsis_dap_speed(hz / 1000); - - return hz; -} - - COMMAND_HANDLER(cmsis_dap_handle_info_command) { if (cmsis_dap_get_version_info() == ERROR_OK) @@ -1790,7 +1781,6 @@ static const struct command_registration cmsis_dap_command_handlers[] = { static const struct swd_driver cmsis_dap_swd_driver = { .init = cmsis_dap_swd_init, - .frequency = cmsis_dap_swd_frequency, .switch_seq = cmsis_dap_swd_switch_seq, .read_reg = cmsis_dap_swd_read_reg, .write_reg = cmsis_dap_swd_write_reg, diff --git a/src/jtag/drivers/dummy.c b/src/jtag/drivers/dummy.c index db1ba13..4e5b615 100644 --- a/src/jtag/drivers/dummy.c +++ b/src/jtag/drivers/dummy.c @@ -136,8 +136,8 @@ static const struct command_registration dummy_command_handlers[] = { .name = "dummy", .mode = COMMAND_ANY, .help = "dummy interface driver commands", - .chain = hello_command_handlers, + .usage = "", }, COMMAND_REGISTRATION_DONE, }; diff --git a/src/jtag/drivers/ep93xx.c b/src/jtag/drivers/ep93xx.c index 36fc777..4cf3184 100644 --- a/src/jtag/drivers/ep93xx.c +++ b/src/jtag/drivers/ep93xx.c @@ -55,6 +55,7 @@ struct jtag_interface ep93xx_interface = { .supported = DEBUG_CAP_TMS_SEQ, .execute_queue = bitbang_execute_queue, + .transports = jtag_only, .init = ep93xx_init, .quit = ep93xx_quit, diff --git a/src/jtag/drivers/ft232r.c b/src/jtag/drivers/ft232r.c index e16bcdc..8cda76e 100644 --- a/src/jtag/drivers/ft232r.c +++ b/src/jtag/drivers/ft232r.c @@ -442,7 +442,7 @@ COMMAND_HANDLER(ft232r_handle_jtag_nums_command) if (tdo_gpio < 0) return ERROR_COMMAND_SYNTAX_ERROR; - command_print(CMD_CTX, + command_print(CMD, "FT232R nums: TCK = %d %s, TMS = %d %s, TDI = %d %s, TDO = %d %s", tck_gpio, ft232r_bit_number_to_name(tck_gpio), tms_gpio, ft232r_bit_number_to_name(tms_gpio), @@ -462,7 +462,7 @@ COMMAND_HANDLER(ft232r_handle_tck_num_command) if (tck_gpio < 0) return ERROR_COMMAND_SYNTAX_ERROR; - command_print(CMD_CTX, + command_print(CMD, "FT232R num: TCK = %d %s", tck_gpio, ft232r_bit_number_to_name(tck_gpio)); return ERROR_OK; @@ -478,7 +478,7 @@ COMMAND_HANDLER(ft232r_handle_tms_num_command) if (tms_gpio < 0) return ERROR_COMMAND_SYNTAX_ERROR; - command_print(CMD_CTX, + command_print(CMD, "FT232R num: TMS = %d %s", tms_gpio, ft232r_bit_number_to_name(tms_gpio)); return ERROR_OK; @@ -494,7 +494,7 @@ COMMAND_HANDLER(ft232r_handle_tdo_num_command) if (tdo_gpio < 0) return ERROR_COMMAND_SYNTAX_ERROR; - command_print(CMD_CTX, + command_print(CMD, "FT232R num: TDO = %d %s", tdo_gpio, ft232r_bit_number_to_name(tdo_gpio)); return ERROR_OK; @@ -510,7 +510,7 @@ COMMAND_HANDLER(ft232r_handle_tdi_num_command) if (tdi_gpio < 0) return ERROR_COMMAND_SYNTAX_ERROR; - command_print(CMD_CTX, + command_print(CMD, "FT232R num: TDI = %d %s", tdi_gpio, ft232r_bit_number_to_name(tdi_gpio)); return ERROR_OK; @@ -526,7 +526,7 @@ COMMAND_HANDLER(ft232r_handle_trst_num_command) if (ntrst_gpio < 0) return ERROR_COMMAND_SYNTAX_ERROR; - command_print(CMD_CTX, + command_print(CMD, "FT232R num: TRST = %d %s", ntrst_gpio, ft232r_bit_number_to_name(ntrst_gpio)); return ERROR_OK; @@ -542,7 +542,7 @@ COMMAND_HANDLER(ft232r_handle_srst_num_command) if (nsysrst_gpio < 0) return ERROR_COMMAND_SYNTAX_ERROR; - command_print(CMD_CTX, + command_print(CMD, "FT232R num: SRST = %d %s", nsysrst_gpio, ft232r_bit_number_to_name(nsysrst_gpio)); return ERROR_OK; @@ -555,7 +555,7 @@ COMMAND_HANDLER(ft232r_handle_restore_serial_command) else if (CMD_ARGC != 0) return ERROR_COMMAND_SYNTAX_ERROR; - command_print(CMD_CTX, + command_print(CMD, "FT232R restore serial: 0x%04X (%s)", ft232r_restore_bitmode, ft232r_restore_bitmode == 0xFFFF ? "disabled" : "enabled"); @@ -675,7 +675,7 @@ static int syncbb_execute_tms(struct jtag_command *cmd) unsigned num_bits = cmd->cmd.tms->num_bits; const uint8_t *bits = cmd->cmd.tms->bits; - DEBUG_JTAG_IO("TMS: %d bits", num_bits); + LOG_DEBUG_IO("TMS: %d bits", num_bits); int tms = 0; for (unsigned i = 0; i < num_bits; i++) { diff --git a/src/jtag/drivers/ftdi.c b/src/jtag/drivers/ftdi.c index 6fbcbce..48f8d83 100644 --- a/src/jtag/drivers/ftdi.c +++ b/src/jtag/drivers/ftdi.c @@ -329,7 +329,7 @@ static void move_to_state(tap_state_t goal_state) int tms_count = tap_get_tms_path_len(start_state, goal_state); assert(tms_count <= 8); - DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state), tap_state_name(goal_state)); + LOG_DEBUG_IO("start=%s goal=%s", tap_state_name(start_state), tap_state_name(goal_state)); /* Track state transitions step by step */ for (int i = 0; i < tms_count; i++) @@ -391,7 +391,7 @@ static void ftdi_execute_runtest(struct jtag_command *cmd) int i; static const uint8_t zero; - DEBUG_JTAG_IO("runtest %i cycles, end in %s", + LOG_DEBUG_IO("runtest %i cycles, end in %s", cmd->cmd.runtest->num_cycles, tap_state_name(cmd->cmd.runtest->end_state)); @@ -412,14 +412,14 @@ static void ftdi_execute_runtest(struct jtag_command *cmd) if (tap_get_state() != tap_get_end_state()) move_to_state(tap_get_end_state()); - DEBUG_JTAG_IO("runtest: %i, end in %s", + LOG_DEBUG_IO("runtest: %i, end in %s", cmd->cmd.runtest->num_cycles, tap_state_name(tap_get_end_state())); } static void ftdi_execute_statemove(struct jtag_command *cmd) { - DEBUG_JTAG_IO("statemove end in %s", + LOG_DEBUG_IO("statemove end in %s", tap_state_name(cmd->cmd.statemove->end_state)); ftdi_end_state(cmd->cmd.statemove->end_state); @@ -435,7 +435,7 @@ static void ftdi_execute_statemove(struct jtag_command *cmd) */ static void ftdi_execute_tms(struct jtag_command *cmd) { - DEBUG_JTAG_IO("TMS: %d bits", cmd->cmd.tms->num_bits); + LOG_DEBUG_IO("TMS: %d bits", cmd->cmd.tms->num_bits); /* TODO: Missing tap state tracking, also missing from ft2232.c! */ DO_CLOCK_TMS_CS_OUT(mpsse_ctx, @@ -451,7 +451,7 @@ static void ftdi_execute_pathmove(struct jtag_command *cmd) tap_state_t *path = cmd->cmd.pathmove->path; int num_states = cmd->cmd.pathmove->num_states; - DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states, + LOG_DEBUG_IO("pathmove: %i states, current: %s end: %s", num_states, tap_state_name(tap_get_state()), tap_state_name(path[num_states-1])); @@ -459,7 +459,7 @@ static void ftdi_execute_pathmove(struct jtag_command *cmd) unsigned bit_count = 0; uint8_t tms_byte = 0; - DEBUG_JTAG_IO("-"); + LOG_DEBUG_IO("-"); /* this loop verifies that the path is legal and logs each state in the path */ while (num_states--) { @@ -499,18 +499,18 @@ static void ftdi_execute_pathmove(struct jtag_command *cmd) static void ftdi_execute_scan(struct jtag_command *cmd) { - DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", + LOG_DEBUG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", jtag_scan_type(cmd->cmd.scan)); /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */ while (cmd->cmd.scan->num_fields > 0 && cmd->cmd.scan->fields[cmd->cmd.scan->num_fields - 1].num_bits == 0) { cmd->cmd.scan->num_fields--; - DEBUG_JTAG_IO("discarding trailing empty field"); + LOG_DEBUG_IO("discarding trailing empty field"); } if (cmd->cmd.scan->num_fields == 0) { - DEBUG_JTAG_IO("empty scan, doing nothing"); + LOG_DEBUG_IO("empty scan, doing nothing"); return; } @@ -529,7 +529,7 @@ static void ftdi_execute_scan(struct jtag_command *cmd) for (int i = 0; i < cmd->cmd.scan->num_fields; i++, field++) { scan_size += field->num_bits; - DEBUG_JTAG_IO("%s%s field %d/%d %d bits", + LOG_DEBUG_IO("%s%s field %d/%d %d bits", field->in_value ? "in" : "", field->out_value ? "out" : "", i, @@ -579,14 +579,14 @@ static void ftdi_execute_scan(struct jtag_command *cmd) if (tap_get_state() != tap_get_end_state()) move_to_state(tap_get_end_state()); - DEBUG_JTAG_IO("%s scan, %i bits, end in %s", + LOG_DEBUG_IO("%s scan, %i bits, end in %s", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size, tap_state_name(tap_get_end_state())); } static void ftdi_execute_reset(struct jtag_command *cmd) { - DEBUG_JTAG_IO("reset trst: %i srst %i", + LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); if (cmd->cmd.reset->trst == 1 @@ -622,17 +622,17 @@ static void ftdi_execute_reset(struct jtag_command *cmd) ftdi_set_signal(srst, 'z'); } - DEBUG_JTAG_IO("trst: %i, srst: %i", + LOG_DEBUG_IO("trst: %i, srst: %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); } static void ftdi_execute_sleep(struct jtag_command *cmd) { - DEBUG_JTAG_IO("sleep %" PRIi32, cmd->cmd.sleep->us); + LOG_DEBUG_IO("sleep %" PRIi32, cmd->cmd.sleep->us); mpsse_flush(mpsse_ctx); jtag_sleep(cmd->cmd.sleep->us); - DEBUG_JTAG_IO("sleep %" PRIi32 " usec while in %s", + LOG_DEBUG_IO("sleep %" PRIi32 " usec while in %s", cmd->cmd.sleep->us, tap_state_name(tap_get_state())); } @@ -656,7 +656,7 @@ static void ftdi_execute_stableclocks(struct jtag_command *cmd) num_cycles -= this_len; } - DEBUG_JTAG_IO("clocks %i while in %s", + LOG_DEBUG_IO("clocks %i while in %s", cmd->cmd.stableclocks->num_cycles, tap_state_name(tap_get_state())); } @@ -1262,7 +1262,7 @@ COMMAND_HANDLER(ftdi_handle_tdo_sample_edge_command) } n = Jim_Nvp_value2name_simple(nvp_ftdi_jtag_modes, ftdi_jtag_mode); - command_print(CMD_CTX, "ftdi samples TDO on %s edge of TCK", n->name); + command_print(CMD, "ftdi samples TDO on %s edge of TCK", n->name); return ERROR_OK; } @@ -1558,14 +1558,6 @@ static void ftdi_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_cl ftdi_swd_queue_cmd(cmd, NULL, value, ap_delay_clk); } -static int_least32_t ftdi_swd_frequency(int_least32_t hz) -{ - if (hz > 0) - freq = mpsse_set_frequency(mpsse_ctx, hz); - - return freq; -} - static int ftdi_swd_switch_seq(enum swd_special_seq seq) { switch (seq) { @@ -1594,7 +1586,6 @@ static int ftdi_swd_switch_seq(enum swd_special_seq seq) static const struct swd_driver ftdi_swd = { .init = ftdi_swd_init, - .frequency = ftdi_swd_frequency, .switch_seq = ftdi_swd_switch_seq, .read_reg = ftdi_swd_read_reg, .write_reg = ftdi_swd_write_reg, diff --git a/src/jtag/drivers/gw16012.c b/src/jtag/drivers/gw16012.c index f668996..e65f56c 100644 --- a/src/jtag/drivers/gw16012.c +++ b/src/jtag/drivers/gw16012.c @@ -297,43 +297,33 @@ static int gw16012_execute_queue(void) while (cmd) { switch (cmd->type) { case JTAG_RESET: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); -#endif + LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); if (cmd->cmd.reset->trst == 1) tap_set_state(TAP_RESET); gw16012_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); break; case JTAG_RUNTEST: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, + LOG_DEBUG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state); -#endif gw16012_end_state(cmd->cmd.runtest->end_state); gw16012_runtest(cmd->cmd.runtest->num_cycles); break; case JTAG_TLR_RESET: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state); -#endif + LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state); gw16012_end_state(cmd->cmd.statemove->end_state); gw16012_state_move(); break; case JTAG_PATHMOVE: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, + LOG_DEBUG_IO("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); -#endif gw16012_path_move(cmd->cmd.pathmove); break; case JTAG_SCAN: gw16012_end_state(cmd->cmd.scan->end_state); scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); type = jtag_scan_type(cmd->cmd.scan); -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("%s scan (%i) %i bit end in %i", (cmd->cmd.scan->ir_scan) ? "ir" : "dr", + LOG_DEBUG_IO("%s scan (%i) %i bit end in %i", (cmd->cmd.scan->ir_scan) ? "ir" : "dr", type, scan_size, cmd->cmd.scan->end_state); -#endif gw16012_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size); if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK) retval = ERROR_JTAG_QUEUE_FAILED; @@ -341,9 +331,7 @@ static int gw16012_execute_queue(void) free(buffer); break; case JTAG_SLEEP: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("sleep %i", cmd->cmd.sleep->us); -#endif + LOG_DEBUG_IO("sleep %i", cmd->cmd.sleep->us); jtag_sleep(cmd->cmd.sleep->us); break; default: @@ -515,7 +503,7 @@ COMMAND_HANDLER(gw16012_handle_parport_port_command) } } - command_print(CMD_CTX, "parport port = %u", gw16012_port); + command_print(CMD, "parport port = %u", gw16012_port); return ERROR_OK; } @@ -535,6 +523,7 @@ static const struct command_registration gw16012_command_handlers[] = { struct jtag_interface gw16012_interface = { .name = "gw16012", + .transports = jtag_only, .commands = gw16012_command_handlers, .init = gw16012_init, diff --git a/src/jtag/drivers/imx_gpio.c b/src/jtag/drivers/imx_gpio.c index f42692c..4923dab 100644 --- a/src/jtag/drivers/imx_gpio.c +++ b/src/jtag/drivers/imx_gpio.c @@ -221,7 +221,7 @@ COMMAND_HANDLER(imx_gpio_handle_jtag_gpionums) return ERROR_COMMAND_SYNTAX_ERROR; } - command_print(CMD_CTX, + command_print(CMD, "imx_gpio GPIO config: tck = %d, tms = %d, tdi = %d, tdo = %d", tck_gpio, tms_gpio, tdi_gpio, tdo_gpio); @@ -233,7 +233,7 @@ COMMAND_HANDLER(imx_gpio_handle_jtag_gpionum_tck) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tck_gpio); - command_print(CMD_CTX, "imx_gpio GPIO config: tck = %d", tck_gpio); + command_print(CMD, "imx_gpio GPIO config: tck = %d", tck_gpio); return ERROR_OK; } @@ -242,7 +242,7 @@ COMMAND_HANDLER(imx_gpio_handle_jtag_gpionum_tms) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tms_gpio); - command_print(CMD_CTX, "imx_gpio GPIO config: tms = %d", tms_gpio); + command_print(CMD, "imx_gpio GPIO config: tms = %d", tms_gpio); return ERROR_OK; } @@ -251,7 +251,7 @@ COMMAND_HANDLER(imx_gpio_handle_jtag_gpionum_tdo) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdo_gpio); - command_print(CMD_CTX, "imx_gpio GPIO config: tdo = %d", tdo_gpio); + command_print(CMD, "imx_gpio GPIO config: tdo = %d", tdo_gpio); return ERROR_OK; } @@ -260,7 +260,7 @@ COMMAND_HANDLER(imx_gpio_handle_jtag_gpionum_tdi) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdi_gpio); - command_print(CMD_CTX, "imx_gpio GPIO config: tdi = %d", tdi_gpio); + command_print(CMD, "imx_gpio GPIO config: tdi = %d", tdi_gpio); return ERROR_OK; } @@ -269,7 +269,7 @@ COMMAND_HANDLER(imx_gpio_handle_jtag_gpionum_srst) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], srst_gpio); - command_print(CMD_CTX, "imx_gpio GPIO config: srst = %d", srst_gpio); + command_print(CMD, "imx_gpio GPIO config: srst = %d", srst_gpio); return ERROR_OK; } @@ -278,7 +278,7 @@ COMMAND_HANDLER(imx_gpio_handle_jtag_gpionum_trst) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], trst_gpio); - command_print(CMD_CTX, "imx_gpio GPIO config: trst = %d", trst_gpio); + command_print(CMD, "imx_gpio GPIO config: trst = %d", trst_gpio); return ERROR_OK; } @@ -291,7 +291,7 @@ COMMAND_HANDLER(imx_gpio_handle_swd_gpionums) return ERROR_COMMAND_SYNTAX_ERROR; } - command_print(CMD_CTX, + command_print(CMD, "imx_gpio GPIO nums: swclk = %d, swdio = %d", swclk_gpio, swdio_gpio); @@ -303,7 +303,7 @@ COMMAND_HANDLER(imx_gpio_handle_swd_gpionum_swclk) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swclk_gpio); - command_print(CMD_CTX, "imx_gpio num: swclk = %d", swclk_gpio); + command_print(CMD, "imx_gpio num: swclk = %d", swclk_gpio); return ERROR_OK; } @@ -312,7 +312,7 @@ COMMAND_HANDLER(imx_gpio_handle_swd_gpionum_swdio) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swdio_gpio); - command_print(CMD_CTX, "imx_gpio num: swdio = %d", swdio_gpio); + command_print(CMD, "imx_gpio num: swdio = %d", swdio_gpio); return ERROR_OK; } @@ -322,6 +322,9 @@ COMMAND_HANDLER(imx_gpio_handle_speed_coeffs) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], speed_coeff); COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], speed_offset); } + + command_print(CMD, "imx_gpio: speed_coeffs = %d, speed_offset = %d", + speed_coeff, speed_offset); return ERROR_OK; } @@ -329,6 +332,9 @@ COMMAND_HANDLER(imx_gpio_handle_peripheral_base) { if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], imx_gpio_peri_base); + + command_print(CMD, "imx_gpio: peripheral_base = 0x%08x", + imx_gpio_peri_base); return ERROR_OK; } @@ -338,74 +344,84 @@ static const struct command_registration imx_gpio_command_handlers[] = { .handler = &imx_gpio_handle_jtag_gpionums, .mode = COMMAND_CONFIG, .help = "gpio numbers for tck, tms, tdi, tdo. (in that order)", - .usage = "(tck tms tdi tdo)* ", + .usage = "[tck tms tdi tdo]", }, { .name = "imx_gpio_tck_num", .handler = &imx_gpio_handle_jtag_gpionum_tck, .mode = COMMAND_CONFIG, .help = "gpio number for tck.", + .usage = "[tck]", }, { .name = "imx_gpio_tms_num", .handler = &imx_gpio_handle_jtag_gpionum_tms, .mode = COMMAND_CONFIG, .help = "gpio number for tms.", + .usage = "[tms]", }, { .name = "imx_gpio_tdo_num", .handler = &imx_gpio_handle_jtag_gpionum_tdo, .mode = COMMAND_CONFIG, .help = "gpio number for tdo.", + .usage = "[tdo]", }, { .name = "imx_gpio_tdi_num", .handler = &imx_gpio_handle_jtag_gpionum_tdi, .mode = COMMAND_CONFIG, .help = "gpio number for tdi.", + .usage = "[tdi]", }, { .name = "imx_gpio_swd_nums", .handler = &imx_gpio_handle_swd_gpionums, .mode = COMMAND_CONFIG, .help = "gpio numbers for swclk, swdio. (in that order)", - .usage = "(swclk swdio)* ", + .usage = "[swclk swdio]", }, { .name = "imx_gpio_swclk_num", .handler = &imx_gpio_handle_swd_gpionum_swclk, .mode = COMMAND_CONFIG, .help = "gpio number for swclk.", + .usage = "[swclk]", }, { .name = "imx_gpio_swdio_num", .handler = &imx_gpio_handle_swd_gpionum_swdio, .mode = COMMAND_CONFIG, .help = "gpio number for swdio.", + .usage = "[swdio]", }, { .name = "imx_gpio_srst_num", .handler = &imx_gpio_handle_jtag_gpionum_srst, .mode = COMMAND_CONFIG, .help = "gpio number for srst.", + .usage = "[srst]", }, { .name = "imx_gpio_trst_num", .handler = &imx_gpio_handle_jtag_gpionum_trst, .mode = COMMAND_CONFIG, .help = "gpio number for trst.", + .usage = "[trst]", }, { .name = "imx_gpio_speed_coeffs", .handler = &imx_gpio_handle_speed_coeffs, .mode = COMMAND_CONFIG, .help = "SPEED_COEFF and SPEED_OFFSET for delay calculations.", + .usage = "[SPEED_COEFF SPEED_OFFSET]", }, { .name = "imx_gpio_peripheral_base", .handler = &imx_gpio_handle_peripheral_base, .mode = COMMAND_CONFIG, .help = "peripheral base to access GPIOs (0x0209c000 for most IMX).", + .usage = "[base]", }, COMMAND_REGISTRATION_DONE diff --git a/src/jtag/drivers/jlink.c b/src/jtag/drivers/jlink.c index 1eae827..09b3a85 100644 --- a/src/jtag/drivers/jlink.c +++ b/src/jtag/drivers/jlink.c @@ -38,6 +38,7 @@ #include <jtag/interface.h> #include <jtag/swd.h> #include <jtag/commands.h> +#include <jtag/drivers/jtag_usb_common.h> #include <libjaylink/libjaylink.h> @@ -50,6 +51,7 @@ static uint8_t caps[JAYLINK_DEV_EXT_CAPS_SIZE]; static uint32_t serial_number; static bool use_serial_number; +static bool use_usb_location; static enum jaylink_usb_address usb_address; static bool use_usb_address; static enum jaylink_target_interface iface = JAYLINK_TIF_JTAG; @@ -122,13 +124,13 @@ static int queued_retval; static void jlink_execute_stableclocks(struct jtag_command *cmd) { - DEBUG_JTAG_IO("stableclocks %i cycles", cmd->cmd.runtest->num_cycles); + LOG_DEBUG_IO("stableclocks %i cycles", cmd->cmd.runtest->num_cycles); jlink_stableclocks(cmd->cmd.runtest->num_cycles); } static void jlink_execute_runtest(struct jtag_command *cmd) { - DEBUG_JTAG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, + LOG_DEBUG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state); jlink_end_state(cmd->cmd.runtest->end_state); @@ -137,7 +139,7 @@ static void jlink_execute_runtest(struct jtag_command *cmd) static void jlink_execute_statemove(struct jtag_command *cmd) { - DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state); + LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state); jlink_end_state(cmd->cmd.statemove->end_state); jlink_state_move(); @@ -145,7 +147,7 @@ static void jlink_execute_statemove(struct jtag_command *cmd) static void jlink_execute_pathmove(struct jtag_command *cmd) { - DEBUG_JTAG_IO("pathmove: %i states, end in %i", + LOG_DEBUG_IO("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); @@ -154,7 +156,7 @@ static void jlink_execute_pathmove(struct jtag_command *cmd) static void jlink_execute_scan(struct jtag_command *cmd) { - DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", + LOG_DEBUG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", jtag_scan_type(cmd->cmd.scan)); /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */ @@ -188,7 +190,7 @@ static void jlink_execute_scan(struct jtag_command *cmd) for (int i = 0; i < cmd->cmd.scan->num_fields; i++, field++) { scan_size += field->num_bits; - DEBUG_JTAG_IO("%s%s field %d/%d %d bits", + LOG_DEBUG_IO("%s%s field %d/%d %d bits", field->in_value ? "in" : "", field->out_value ? "out" : "", i, @@ -240,14 +242,14 @@ static void jlink_execute_scan(struct jtag_command *cmd) jlink_state_move(); } - DEBUG_JTAG_IO("%s scan, %i bits, end in %s", + LOG_DEBUG_IO("%s scan, %i bits, end in %s", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size, tap_state_name(tap_get_end_state())); } static void jlink_execute_reset(struct jtag_command *cmd) { - DEBUG_JTAG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, + LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); jlink_flush(); @@ -257,7 +259,7 @@ static void jlink_execute_reset(struct jtag_command *cmd) static void jlink_execute_sleep(struct jtag_command *cmd) { - DEBUG_JTAG_IO("sleep %" PRIi32 "", cmd->cmd.sleep->us); + LOG_DEBUG_IO("sleep %" PRIi32 "", cmd->cmd.sleep->us); jlink_flush(); jtag_sleep(cmd->cmd.sleep->us); } @@ -534,6 +536,31 @@ static int jaylink_log_handler(const struct jaylink_context *ctx, return 0; } +static bool jlink_usb_location_equal(struct jaylink_device *dev) +{ + int retval; + uint8_t bus; + uint8_t *ports; + size_t num_ports; + bool equal = false; + + retval = jaylink_device_get_usb_bus_ports(dev, &bus, &ports, &num_ports); + + if (retval == JAYLINK_ERR_NOT_SUPPORTED) { + return false; + } else if (retval != JAYLINK_OK) { + LOG_WARNING("jaylink_device_get_usb_bus_ports() failed: %s.", + jaylink_strerror(retval)); + return false; + } + + equal = jtag_usb_location_equal(bus, ports, num_ports); + free(ports); + + return equal; +} + + static int jlink_init(void) { int ret; @@ -595,7 +622,9 @@ static int jlink_init(void) return ERROR_JTAG_INIT_FAILED; } - if (!use_serial_number && !use_usb_address && num_devices > 1) { + use_usb_location = (jtag_usb_get_location() != NULL); + + if (!use_serial_number && !use_usb_address && !use_usb_location && num_devices > 1) { LOG_ERROR("Multiple devices found, specify the desired device."); jaylink_free_devices(devs, true); jaylink_exit(jayctx); @@ -605,8 +634,10 @@ static int jlink_init(void) found_device = false; for (i = 0; devs[i]; i++) { + struct jaylink_device *dev = devs[i]; + if (use_serial_number) { - ret = jaylink_device_get_serial_number(devs[i], &tmp); + ret = jaylink_device_get_serial_number(dev, &tmp); if (ret == JAYLINK_ERR_NOT_AVAILABLE) { continue; @@ -621,7 +652,7 @@ static int jlink_init(void) } if (use_usb_address) { - ret = jaylink_device_get_usb_address(devs[i], &address); + ret = jaylink_device_get_usb_address(dev, &address); if (ret == JAYLINK_ERR_NOT_SUPPORTED) { continue; @@ -635,7 +666,10 @@ static int jlink_init(void) continue; } - ret = jaylink_open(devs[i], &devh); + if (use_usb_location && !jlink_usb_location_equal(dev)) + continue; + + ret = jaylink_open(dev, &devh); if (ret == JAYLINK_OK) { found_device = true; @@ -923,17 +957,17 @@ COMMAND_HANDLER(jlink_usb_command) int tmp; if (CMD_ARGC != 1) { - command_print(CMD_CTX, "Need exactly one argument for jlink usb."); + command_print(CMD, "Need exactly one argument for jlink usb."); return ERROR_COMMAND_SYNTAX_ERROR; } if (sscanf(CMD_ARGV[0], "%i", &tmp) != 1) { - command_print(CMD_CTX, "Invalid USB address: %s.", CMD_ARGV[0]); + command_print(CMD, "Invalid USB address: %s.", CMD_ARGV[0]); return ERROR_FAIL; } if (tmp < JAYLINK_USB_ADDRESS_0 || tmp > JAYLINK_USB_ADDRESS_3) { - command_print(CMD_CTX, "Invalid USB address: %s.", CMD_ARGV[0]); + command_print(CMD, "Invalid USB address: %s.", CMD_ARGV[0]); return ERROR_FAIL; } @@ -950,17 +984,17 @@ COMMAND_HANDLER(jlink_serial_command) int ret; if (CMD_ARGC != 1) { - command_print(CMD_CTX, "Need exactly one argument for jlink serial."); + command_print(CMD, "Need exactly one argument for jlink serial."); return ERROR_COMMAND_SYNTAX_ERROR; } ret = jaylink_parse_serial_number(CMD_ARGV[0], &serial_number); if (ret == JAYLINK_ERR) { - command_print(CMD_CTX, "Invalid serial number: %s.", CMD_ARGV[0]); + command_print(CMD, "Invalid serial number: %s.", CMD_ARGV[0]); return ERROR_FAIL; } else if (ret != JAYLINK_OK) { - command_print(CMD_CTX, "jaylink_parse_serial_number() failed: %s.", + command_print(CMD, "jaylink_parse_serial_number() failed: %s.", jaylink_strerror(ret)); return ERROR_FAIL; } @@ -979,20 +1013,20 @@ COMMAND_HANDLER(jlink_handle_hwstatus_command) ret = jaylink_get_hardware_status(devh, &status); if (ret != JAYLINK_OK) { - command_print(CMD_CTX, "jaylink_get_hardware_status() failed: %s.", + command_print(CMD, "jaylink_get_hardware_status() failed: %s.", jaylink_strerror(ret)); return ERROR_FAIL; } - command_print(CMD_CTX, "VTarget = %u.%03u V", + command_print(CMD, "VTarget = %u.%03u V", status.target_voltage / 1000, status.target_voltage % 1000); - command_print(CMD_CTX, "TCK = %u TDI = %u TDO = %u TMS = %u SRST = %u " + command_print(CMD, "TCK = %u TDI = %u TDO = %u TMS = %u SRST = %u " "TRST = %u", status.tck, status.tdi, status.tdo, status.tms, status.tres, status.trst); if (status.target_voltage < 1500) - command_print(CMD_CTX, "Target voltage too low. Check target power."); + command_print(CMD, "Target voltage too low. Check target power."); return ERROR_OK; } @@ -1003,7 +1037,7 @@ COMMAND_HANDLER(jlink_handle_free_memory_command) uint32_t tmp; if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_FREE_MEMORY)) { - command_print(CMD_CTX, "Retrieval of free memory is not supported by " + command_print(CMD, "Retrieval of free memory is not supported by " "the device."); return ERROR_OK; } @@ -1011,12 +1045,12 @@ COMMAND_HANDLER(jlink_handle_free_memory_command) ret = jaylink_get_free_memory(devh, &tmp); if (ret != JAYLINK_OK) { - command_print(CMD_CTX, "jaylink_get_free_memory() failed: %s.", + command_print(CMD, "jaylink_get_free_memory() failed: %s.", jaylink_strerror(ret)); return ERROR_FAIL; } - command_print(CMD_CTX, "Device has %u bytes of free memory.", tmp); + command_print(CMD, "Device has %u bytes of free memory.", tmp); return ERROR_OK; } @@ -1038,10 +1072,10 @@ COMMAND_HANDLER(jlink_handle_jlink_jtag_command) return ERROR_FAIL; } - command_print(CMD_CTX, "JTAG command version: %i", version); + command_print(CMD, "JTAG command version: %i", version); } else if (CMD_ARGC == 1) { if (sscanf(CMD_ARGV[0], "%i", &tmp) != 1) { - command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]); + command_print(CMD, "Invalid argument: %s.", CMD_ARGV[0]); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1053,11 +1087,11 @@ COMMAND_HANDLER(jlink_handle_jlink_jtag_command) jtag_command_version = JAYLINK_JTAG_VERSION_3; break; default: - command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]); + command_print(CMD, "Invalid argument: %s.", CMD_ARGV[0]); return ERROR_COMMAND_SYNTAX_ERROR; } } else { - command_print(CMD_CTX, "Need exactly one argument for jlink jtag."); + command_print(CMD, "Need exactly one argument for jlink jtag."); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1070,13 +1104,13 @@ COMMAND_HANDLER(jlink_handle_target_power_command) int enable; if (CMD_ARGC != 1) { - command_print(CMD_CTX, "Need exactly one argument for jlink " + command_print(CMD, "Need exactly one argument for jlink " "targetpower."); return ERROR_COMMAND_SYNTAX_ERROR; } if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_SET_TARGET_POWER)) { - command_print(CMD_CTX, "Target power supply is not supported by the " + command_print(CMD, "Target power supply is not supported by the " "device."); return ERROR_OK; } @@ -1086,14 +1120,14 @@ COMMAND_HANDLER(jlink_handle_target_power_command) } else if (!strcmp(CMD_ARGV[0], "off")) { enable = false; } else { - command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]); + command_print(CMD, "Invalid argument: %s.", CMD_ARGV[0]); return ERROR_FAIL; } ret = jaylink_set_target_power(devh, enable); if (ret != JAYLINK_OK) { - command_print(CMD_CTX, "jaylink_set_target_power() failed: %s.", + command_print(CMD, "jaylink_set_target_power() failed: %s.", jaylink_strerror(ret)); return ERROR_FAIL; } @@ -1101,49 +1135,49 @@ COMMAND_HANDLER(jlink_handle_target_power_command) return ERROR_OK; } -static void show_config_usb_address(struct command_context *ctx) +static void show_config_usb_address(struct command_invocation *cmd) { if (config.usb_address != tmp_config.usb_address) - command_print(ctx, "USB address: %u [%u]", config.usb_address, + command_print(cmd, "USB address: %u [%u]", config.usb_address, tmp_config.usb_address); else - command_print(ctx, "USB address: %u", config.usb_address); + command_print(cmd, "USB address: %u", config.usb_address); } -static void show_config_ip_address(struct command_context *ctx) +static void show_config_ip_address(struct command_invocation *cmd) { if (!memcmp(config.ip_address, tmp_config.ip_address, 4)) - command_print(ctx, "IP address: %d.%d.%d.%d", + command_print(cmd, "IP address: %d.%d.%d.%d", config.ip_address[3], config.ip_address[2], config.ip_address[1], config.ip_address[0]); else - command_print(ctx, "IP address: %d.%d.%d.%d [%d.%d.%d.%d]", + command_print(cmd, "IP address: %d.%d.%d.%d [%d.%d.%d.%d]", config.ip_address[3], config.ip_address[2], config.ip_address[1], config.ip_address[0], tmp_config.ip_address[3], tmp_config.ip_address[2], tmp_config.ip_address[1], tmp_config.ip_address[0]); if (!memcmp(config.subnet_mask, tmp_config.subnet_mask, 4)) - command_print(ctx, "Subnet mask: %d.%d.%d.%d", + command_print(cmd, "Subnet mask: %d.%d.%d.%d", config.subnet_mask[3], config.subnet_mask[2], config.subnet_mask[1], config.subnet_mask[0]); else - command_print(ctx, "Subnet mask: %d.%d.%d.%d [%d.%d.%d.%d]", + command_print(cmd, "Subnet mask: %d.%d.%d.%d [%d.%d.%d.%d]", config.subnet_mask[3], config.subnet_mask[2], config.subnet_mask[1], config.subnet_mask[0], tmp_config.subnet_mask[3], tmp_config.subnet_mask[2], tmp_config.subnet_mask[1], tmp_config.subnet_mask[0]); } -static void show_config_mac_address(struct command_context *ctx) +static void show_config_mac_address(struct command_invocation *cmd) { if (!memcmp(config.mac_address, tmp_config.mac_address, 6)) - command_print(ctx, "MAC address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x", + command_print(cmd, "MAC address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x", config.mac_address[5], config.mac_address[4], config.mac_address[3], config.mac_address[2], config.mac_address[1], config.mac_address[0]); else - command_print(ctx, "MAC address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x " + command_print(cmd, "MAC address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x " "[%.02x:%.02x:%.02x:%.02x:%.02x:%.02x]", config.mac_address[5], config.mac_address[4], config.mac_address[3], config.mac_address[2], @@ -1153,7 +1187,7 @@ static void show_config_mac_address(struct command_context *ctx) tmp_config.mac_address[1], tmp_config.mac_address[0]); } -static void show_config_target_power(struct command_context *ctx) +static void show_config_target_power(struct command_invocation *cmd) { const char *target_power; const char *current_target_power; @@ -1169,24 +1203,24 @@ static void show_config_target_power(struct command_context *ctx) current_target_power = "on"; if (config.target_power != tmp_config.target_power) - command_print(ctx, "Target power supply: %s [%s]", target_power, + command_print(cmd, "Target power supply: %s [%s]", target_power, current_target_power); else - command_print(ctx, "Target power supply: %s", target_power); + command_print(cmd, "Target power supply: %s", target_power); } -static void show_config(struct command_context *ctx) +static void show_config(struct command_invocation *cmd) { - command_print(ctx, "J-Link device configuration:"); + command_print(cmd, "J-Link device configuration:"); - show_config_usb_address(ctx); + show_config_usb_address(cmd); if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_SET_TARGET_POWER)) - show_config_target_power(ctx); + show_config_target_power(cmd); if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_ETHERNET)) { - show_config_ip_address(ctx); - show_config_mac_address(ctx); + show_config_ip_address(cmd); + show_config_mac_address(cmd); } } @@ -1346,27 +1380,27 @@ COMMAND_HANDLER(jlink_handle_config_usb_address_command) uint8_t tmp; if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) { - command_print(CMD_CTX, "Reading configuration is not supported by the " + command_print(CMD, "Reading configuration is not supported by the " "device."); return ERROR_OK; } if (!CMD_ARGC) { - show_config_usb_address(CMD_CTX); + show_config_usb_address(CMD); } else if (CMD_ARGC == 1) { if (sscanf(CMD_ARGV[0], "%" SCNd8, &tmp) != 1) { - command_print(CMD_CTX, "Invalid USB address: %s.", CMD_ARGV[0]); + command_print(CMD, "Invalid USB address: %s.", CMD_ARGV[0]); return ERROR_FAIL; } if (tmp > JAYLINK_USB_ADDRESS_3) { - command_print(CMD_CTX, "Invalid USB address: %u.", tmp); + command_print(CMD, "Invalid USB address: %u.", tmp); return ERROR_FAIL; } tmp_config.usb_address = tmp; } else { - command_print(CMD_CTX, "Need exactly one argument for jlink config " + command_print(CMD, "Need exactly one argument for jlink config " "usb."); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1379,32 +1413,32 @@ COMMAND_HANDLER(jlink_handle_config_target_power_command) int enable; if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) { - command_print(CMD_CTX, "Reading configuration is not supported by the " + command_print(CMD, "Reading configuration is not supported by the " "device."); return ERROR_OK; } if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_SET_TARGET_POWER)) { - command_print(CMD_CTX, "Target power supply is not supported by the " + command_print(CMD, "Target power supply is not supported by the " "device."); return ERROR_OK; } if (!CMD_ARGC) { - show_config_target_power(CMD_CTX); + show_config_target_power(CMD); } else if (CMD_ARGC == 1) { if (!strcmp(CMD_ARGV[0], "on")) { enable = true; } else if (!strcmp(CMD_ARGV[0], "off")) { enable = false; } else { - command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]); + command_print(CMD, "Invalid argument: %s.", CMD_ARGV[0]); return ERROR_FAIL; } tmp_config.target_power = enable; } else { - command_print(CMD_CTX, "Need exactly one argument for jlink config " + command_print(CMD, "Need exactly one argument for jlink config " "targetpower."); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1420,25 +1454,25 @@ COMMAND_HANDLER(jlink_handle_config_mac_address_command) const char *str; if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) { - command_print(CMD_CTX, "Reading configuration is not supported by the " + command_print(CMD, "Reading configuration is not supported by the " "device."); return ERROR_OK; } if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_ETHERNET)) { - command_print(CMD_CTX, "Ethernet connectivity is not supported by the " + command_print(CMD, "Ethernet connectivity is not supported by the " "device."); return ERROR_OK; } if (!CMD_ARGC) { - show_config_mac_address(CMD_CTX); + show_config_mac_address(CMD); } else if (CMD_ARGC == 1) { str = CMD_ARGV[0]; if ((strlen(str) != 17) || (str[2] != ':' || str[5] != ':' || \ str[8] != ':' || str[11] != ':' || str[14] != ':')) { - command_print(CMD_CTX, "Invalid MAC address format."); + command_print(CMD, "Invalid MAC address format."); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1448,18 +1482,18 @@ COMMAND_HANDLER(jlink_handle_config_mac_address_command) } if (!(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5])) { - command_print(CMD_CTX, "Invalid MAC address: zero address."); + command_print(CMD, "Invalid MAC address: zero address."); return ERROR_COMMAND_SYNTAX_ERROR; } if (!(0x01 & addr[0])) { - command_print(CMD_CTX, "Invalid MAC address: multicast address."); + command_print(CMD, "Invalid MAC address: multicast address."); return ERROR_COMMAND_SYNTAX_ERROR; } memcpy(tmp_config.mac_address, addr, sizeof(addr)); } else { - command_print(CMD_CTX, "Need exactly one argument for jlink config " + command_print(CMD, "Need exactly one argument for jlink config " " mac."); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1508,19 +1542,19 @@ COMMAND_HANDLER(jlink_handle_config_ip_address_command) uint8_t subnet_bits = 24; if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) { - command_print(CMD_CTX, "Reading configuration is not supported by the " + command_print(CMD, "Reading configuration is not supported by the " "device."); return ERROR_OK; } if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_ETHERNET)) { - command_print(CMD_CTX, "Ethernet connectivity is not supported by the " + command_print(CMD, "Ethernet connectivity is not supported by the " "device."); return ERROR_OK; } if (!CMD_ARGC) { - show_config_ip_address(CMD_CTX); + show_config_ip_address(CMD); } else { if (!string_to_ip(CMD_ARGV[0], ip_address, &i)) return ERROR_COMMAND_SYNTAX_ERROR; @@ -1565,19 +1599,19 @@ COMMAND_HANDLER(jlink_handle_config_write_command) int ret; if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) { - command_print(CMD_CTX, "Reading configuration is not supported by the " + command_print(CMD, "Reading configuration is not supported by the " "device."); return ERROR_OK; } if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_WRITE_CONFIG)) { - command_print(CMD_CTX, "Writing configuration is not supported by the " + command_print(CMD, "Writing configuration is not supported by the " "device."); return ERROR_OK; } if (!memcmp(&config, &tmp_config, sizeof(struct device_config))) { - command_print(CMD_CTX, "Operation not performed due to no changes in " + command_print(CMD, "Operation not performed due to no changes in " "the configuration."); return ERROR_OK; } @@ -1602,7 +1636,7 @@ COMMAND_HANDLER(jlink_handle_config_write_command) } memcpy(&tmp_config, &config, sizeof(struct device_config)); - command_print(CMD_CTX, "The new device configuration applies after power " + command_print(CMD, "The new device configuration applies after power " "cycling the J-Link device."); return ERROR_OK; @@ -1611,12 +1645,12 @@ COMMAND_HANDLER(jlink_handle_config_write_command) COMMAND_HANDLER(jlink_handle_config_command) { if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) { - command_print(CMD_CTX, "Device doesn't support reading configuration."); + command_print(CMD, "Device doesn't support reading configuration."); return ERROR_OK; } if (CMD_ARGC == 0) - show_config(CMD_CTX); + show_config(CMD); return ERROR_OK; } @@ -1732,7 +1766,7 @@ COMMAND_HANDLER(jlink_handle_emucom_read_command) return ERROR_FAIL; } - command_print(CMD_CTX, "%s", buf + length); + command_print(CMD, "%s", buf + length); free(buf); return ERROR_OK; @@ -1772,13 +1806,15 @@ static const struct command_registration jlink_config_subcommand_handlers[] = { .name = "reset", .handler = &jlink_handle_config_reset_command, .mode = COMMAND_EXEC, - .help = "undo configuration changes" + .help = "undo configuration changes", + .usage = "", }, { .name = "write", .handler = &jlink_handle_config_write_command, .mode = COMMAND_EXEC, - .help = "write configuration to the device" + .help = "write configuration to the device", + .usage = "", }, COMMAND_REGISTRATION_DONE }; @@ -1820,13 +1856,15 @@ static const struct command_registration jlink_subcommand_handlers[] = { .name = "freemem", .handler = &jlink_handle_free_memory_command, .mode = COMMAND_EXEC, - .help = "show free device memory" + .help = "show free device memory", + .usage = "", }, { .name = "hwstatus", .handler = &jlink_handle_hwstatus_command, .mode = COMMAND_EXEC, - .help = "show the hardware status" + .help = "show the hardware status", + .usage = "", }, { .name = "usb", @@ -1849,12 +1887,14 @@ static const struct command_registration jlink_subcommand_handlers[] = { .help = "access the device configuration. If no argument is given " "this will show the device configuration", .chain = jlink_config_subcommand_handlers, + .usage = "[<cmd>]", }, { .name = "emucom", .mode = COMMAND_EXEC, .help = "access EMUCOM channel", - .chain = jlink_emucom_subcommand_handlers + .chain = jlink_emucom_subcommand_handlers, + .usage = "", }, COMMAND_REGISTRATION_DONE }; @@ -1865,6 +1905,7 @@ static const struct command_registration jlink_command_handlers[] = { .mode = COMMAND_ANY, .help = "perform jlink management", .chain = jlink_subcommand_handlers, + .usage = "", }, COMMAND_REGISTRATION_DONE }; @@ -1888,14 +1929,6 @@ static void jlink_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_c jlink_swd_queue_cmd(cmd, value, 0, ap_delay_clk); } -static int_least32_t jlink_swd_frequency(int_least32_t hz) -{ - if (hz > 0) - jlink_speed(hz / 1000); - - return hz; -} - /***************************************************************************/ /* J-Link tap functions */ @@ -1997,7 +2030,7 @@ static int jlink_flush(void) buf_set_buf(tdo_buffer, p->first, p->buffer, p->buffer_offset, p->length); - DEBUG_JTAG_IO("Pending scan result, length = %d.", p->length); + LOG_DEBUG_IO("Pending scan result, length = %d.", p->length); } jlink_tap_init(); @@ -2171,7 +2204,6 @@ static void jlink_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data, uint3 static const struct swd_driver jlink_swd = { .init = &jlink_swd_init, - .frequency = &jlink_swd_frequency, .switch_seq = &jlink_swd_switch_seq, .read_reg = &jlink_swd_read_reg, .write_reg = &jlink_swd_write_reg, diff --git a/src/jtag/drivers/jtag_usb_common.c b/src/jtag/drivers/jtag_usb_common.c index 637e6c7..6337272 100644 --- a/src/jtag/drivers/jtag_usb_common.c +++ b/src/jtag/drivers/jtag_usb_common.c @@ -15,18 +15,18 @@ static char *jtag_usb_location; * ------ * 16 chars */ -#define JTAG_USB_MAX_LOCATION_LENGHT 16 +#define JTAG_USB_MAX_LOCATION_LENGTH 16 void jtag_usb_set_location(const char *location) { - if (strnlen(location, JTAG_USB_MAX_LOCATION_LENGHT) == - JTAG_USB_MAX_LOCATION_LENGHT) + if (strnlen(location, JTAG_USB_MAX_LOCATION_LENGTH) == + JTAG_USB_MAX_LOCATION_LENGTH) LOG_WARNING("usb location string is too long!!\n"); if (jtag_usb_location) free(jtag_usb_location); - jtag_usb_location = strndup(location, JTAG_USB_MAX_LOCATION_LENGHT); + jtag_usb_location = strndup(location, JTAG_USB_MAX_LOCATION_LENGTH); } const char *jtag_usb_get_location(void) @@ -37,13 +37,13 @@ const char *jtag_usb_get_location(void) bool jtag_usb_location_equal(uint8_t dev_bus, uint8_t *port_path, size_t path_len) { - size_t path_step, string_lengh; + size_t path_step, string_length; char *ptr, *loc; bool equal = false; /* strtok need non const char */ - loc = strndup(jtag_usb_get_location(), JTAG_USB_MAX_LOCATION_LENGHT); - string_lengh = strnlen(loc, JTAG_USB_MAX_LOCATION_LENGHT); + loc = strndup(jtag_usb_get_location(), JTAG_USB_MAX_LOCATION_LENGTH); + string_length = strnlen(loc, JTAG_USB_MAX_LOCATION_LENGTH); ptr = strtok(loc, "-"); if (ptr == NULL) { @@ -51,7 +51,7 @@ bool jtag_usb_location_equal(uint8_t dev_bus, uint8_t *port_path, goto done; } - string_lengh -= 1; + string_length -= 1; /* check bus mismatch */ if (atoi(ptr) != dev_bus) goto done; @@ -69,15 +69,12 @@ bool jtag_usb_location_equal(uint8_t dev_bus, uint8_t *port_path, break; path_step++; - string_lengh -= 2; + string_length -= 2; }; /* walked the full path, all elements match */ - if (path_step == path_len && !string_lengh) + if (path_step == path_len && !string_length) equal = true; - else - LOG_WARNING("excluded by device path option: %s\n", - jtag_usb_get_location()); done: free(loc); diff --git a/src/jtag/drivers/jtag_vpi.c b/src/jtag/drivers/jtag_vpi.c index 35c7031..1033ced 100644 --- a/src/jtag/drivers/jtag_vpi.c +++ b/src/jtag/drivers/jtag_vpi.c @@ -319,7 +319,7 @@ static int jtag_vpi_runtest(int cycles, tap_state_t state) if (retval != ERROR_OK) return retval; - retval = jtag_vpi_queue_tdi(NULL, cycles, TAP_SHIFT); + retval = jtag_vpi_queue_tdi(NULL, cycles, NO_TAP_SHIFT); if (retval != ERROR_OK) return retval; @@ -328,7 +328,27 @@ static int jtag_vpi_runtest(int cycles, tap_state_t state) static int jtag_vpi_stableclocks(int cycles) { - return jtag_vpi_queue_tdi(NULL, cycles, TAP_SHIFT); + uint8_t tms_bits[4]; + int cycles_remain = cycles; + int nb_bits; + int retval; + const int CYCLES_ONE_BATCH = sizeof(tms_bits) * 8; + + assert(cycles >= 0); + + /* use TMS=1 in TAP RESET state, TMS=0 in all other stable states */ + memset(&tms_bits, (tap_get_state() == TAP_RESET) ? 0xff : 0x00, sizeof(tms_bits)); + + /* send the TMS bits */ + while (cycles_remain > 0) { + nb_bits = (cycles_remain < CYCLES_ONE_BATCH) ? cycles_remain : CYCLES_ONE_BATCH; + retval = jtag_vpi_tms_seq(tms_bits, nb_bits); + if (retval != ERROR_OK) + return retval; + cycles_remain -= nb_bits; + } + + return ERROR_OK; } static int jtag_vpi_execute_queue(void) diff --git a/src/jtag/drivers/mpsse.c b/src/jtag/drivers/mpsse.c index 43e924e..c0d883b 100644 --- a/src/jtag/drivers/mpsse.c +++ b/src/jtag/drivers/mpsse.c @@ -30,26 +30,22 @@ #define LIBUSB_CALL #endif -#ifdef _DEBUG_JTAG_IO_ -#define DEBUG_IO(expr...) LOG_DEBUG(expr) #define DEBUG_PRINT_BUF(buf, len) \ do { \ - char buf_string[32 * 3 + 1]; \ - int buf_string_pos = 0; \ - for (int i = 0; i < len; i++) { \ - buf_string_pos += sprintf(buf_string + buf_string_pos, " %02x", buf[i]); \ - if (i % 32 == 32 - 1) { \ - LOG_DEBUG("%s", buf_string); \ - buf_string_pos = 0; \ + if (LOG_LEVEL_IS(LOG_LVL_DEBUG_IO)) { \ + char buf_string[32 * 3 + 1]; \ + int buf_string_pos = 0; \ + for (int i = 0; i < len; i++) { \ + buf_string_pos += sprintf(buf_string + buf_string_pos, " %02x", buf[i]); \ + if (i % 32 == 32 - 1) { \ + LOG_DEBUG_IO("%s", buf_string); \ + buf_string_pos = 0; \ + } \ } \ + if (buf_string_pos > 0) \ + LOG_DEBUG_IO("%s", buf_string);\ } \ - if (buf_string_pos > 0) \ - LOG_DEBUG("%s", buf_string);\ } while (0) -#else -#define DEBUG_IO(expr...) do {} while (0) -#define DEBUG_PRINT_BUF(buf, len) do {} while (0) -#endif #define FTDI_DEVICE_OUT_REQTYPE (LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE) #define FTDI_DEVICE_IN_REQTYPE (0x80 | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE) @@ -459,7 +455,7 @@ static unsigned buffer_read_space(struct mpsse_ctx *ctx) static void buffer_write_byte(struct mpsse_ctx *ctx, uint8_t data) { - DEBUG_IO("%02x", data); + LOG_DEBUG_IO("%02x", data); assert(ctx->write_count < ctx->write_size); ctx->write_buffer[ctx->write_count++] = data; } @@ -467,7 +463,7 @@ static void buffer_write_byte(struct mpsse_ctx *ctx, uint8_t data) static unsigned buffer_write(struct mpsse_ctx *ctx, const uint8_t *out, unsigned out_offset, unsigned bit_count) { - DEBUG_IO("%d bits", bit_count); + LOG_DEBUG_IO("%d bits", bit_count); assert(ctx->write_count + DIV_ROUND_UP(bit_count, 8) <= ctx->write_size); bit_copy(ctx->write_buffer + ctx->write_count, 0, out, out_offset, bit_count); ctx->write_count += DIV_ROUND_UP(bit_count, 8); @@ -477,7 +473,7 @@ static unsigned buffer_write(struct mpsse_ctx *ctx, const uint8_t *out, unsigned static unsigned buffer_add_read(struct mpsse_ctx *ctx, uint8_t *in, unsigned in_offset, unsigned bit_count, unsigned offset) { - DEBUG_IO("%d bits, offset %d", bit_count, offset); + LOG_DEBUG_IO("%d bits, offset %d", bit_count, offset); assert(ctx->read_count + DIV_ROUND_UP(bit_count, 8) <= ctx->read_size); bit_copy_queued(&ctx->read_queue, in, in_offset, ctx->read_buffer + ctx->read_count, offset, bit_count); @@ -501,10 +497,10 @@ void mpsse_clock_data(struct mpsse_ctx *ctx, const uint8_t *out, unsigned out_of unsigned in_offset, unsigned length, uint8_t mode) { /* TODO: Fix MSB first modes */ - DEBUG_IO("%s%s %d bits", in ? "in" : "", out ? "out" : "", length); + LOG_DEBUG_IO("%s%s %d bits", in ? "in" : "", out ? "out" : "", length); if (ctx->retval != ERROR_OK) { - DEBUG_IO("Ignoring command due to previous error"); + LOG_DEBUG_IO("Ignoring command due to previous error"); return; } @@ -577,11 +573,11 @@ void mpsse_clock_tms_cs_out(struct mpsse_ctx *ctx, const uint8_t *out, unsigned void mpsse_clock_tms_cs(struct mpsse_ctx *ctx, const uint8_t *out, unsigned out_offset, uint8_t *in, unsigned in_offset, unsigned length, bool tdi, uint8_t mode) { - DEBUG_IO("%sout %d bits, tdi=%d", in ? "in" : "", length, tdi); + LOG_DEBUG_IO("%sout %d bits, tdi=%d", in ? "in" : "", length, tdi); assert(out); if (ctx->retval != ERROR_OK) { - DEBUG_IO("Ignoring command due to previous error"); + LOG_DEBUG_IO("Ignoring command due to previous error"); return; } @@ -627,10 +623,10 @@ void mpsse_clock_tms_cs(struct mpsse_ctx *ctx, const uint8_t *out, unsigned out_ void mpsse_set_data_bits_low_byte(struct mpsse_ctx *ctx, uint8_t data, uint8_t dir) { - DEBUG_IO("-"); + LOG_DEBUG_IO("-"); if (ctx->retval != ERROR_OK) { - DEBUG_IO("Ignoring command due to previous error"); + LOG_DEBUG_IO("Ignoring command due to previous error"); return; } @@ -644,10 +640,10 @@ void mpsse_set_data_bits_low_byte(struct mpsse_ctx *ctx, uint8_t data, uint8_t d void mpsse_set_data_bits_high_byte(struct mpsse_ctx *ctx, uint8_t data, uint8_t dir) { - DEBUG_IO("-"); + LOG_DEBUG_IO("-"); if (ctx->retval != ERROR_OK) { - DEBUG_IO("Ignoring command due to previous error"); + LOG_DEBUG_IO("Ignoring command due to previous error"); return; } @@ -661,10 +657,10 @@ void mpsse_set_data_bits_high_byte(struct mpsse_ctx *ctx, uint8_t data, uint8_t void mpsse_read_data_bits_low_byte(struct mpsse_ctx *ctx, uint8_t *data) { - DEBUG_IO("-"); + LOG_DEBUG_IO("-"); if (ctx->retval != ERROR_OK) { - DEBUG_IO("Ignoring command due to previous error"); + LOG_DEBUG_IO("Ignoring command due to previous error"); return; } @@ -677,10 +673,10 @@ void mpsse_read_data_bits_low_byte(struct mpsse_ctx *ctx, uint8_t *data) void mpsse_read_data_bits_high_byte(struct mpsse_ctx *ctx, uint8_t *data) { - DEBUG_IO("-"); + LOG_DEBUG_IO("-"); if (ctx->retval != ERROR_OK) { - DEBUG_IO("Ignoring command due to previous error"); + LOG_DEBUG_IO("Ignoring command due to previous error"); return; } @@ -695,7 +691,7 @@ static void single_byte_boolean_helper(struct mpsse_ctx *ctx, bool var, uint8_t uint8_t val_if_false) { if (ctx->retval != ERROR_OK) { - DEBUG_IO("Ignoring command due to previous error"); + LOG_DEBUG_IO("Ignoring command due to previous error"); return; } @@ -716,7 +712,7 @@ void mpsse_set_divisor(struct mpsse_ctx *ctx, uint16_t divisor) LOG_DEBUG("%d", divisor); if (ctx->retval != ERROR_OK) { - DEBUG_IO("Ignoring command due to previous error"); + LOG_DEBUG_IO("Ignoring command due to previous error"); return; } @@ -818,7 +814,7 @@ static LIBUSB_CALL void read_cb(struct libusb_transfer *transfer) } } - DEBUG_IO("raw chunk %d, transferred %d of %d", transfer->actual_length, res->transferred, + LOG_DEBUG_IO("raw chunk %d, transferred %d of %d", transfer->actual_length, res->transferred, ctx->read_count); if (!res->done) @@ -833,7 +829,7 @@ static LIBUSB_CALL void write_cb(struct libusb_transfer *transfer) res->transferred += transfer->actual_length; - DEBUG_IO("transferred %d of %d", res->transferred, ctx->write_count); + LOG_DEBUG_IO("transferred %d of %d", res->transferred, ctx->write_count); DEBUG_PRINT_BUF(transfer->buffer, transfer->actual_length); @@ -852,13 +848,13 @@ int mpsse_flush(struct mpsse_ctx *ctx) int retval = ctx->retval; if (retval != ERROR_OK) { - DEBUG_IO("Ignoring flush due to previous error"); + LOG_DEBUG_IO("Ignoring flush due to previous error"); assert(ctx->write_count == 0 && ctx->read_count == 0); ctx->retval = ERROR_OK; return retval; } - DEBUG_IO("write %d%s, read %d", ctx->write_count, ctx->read_count ? "+1" : "", + LOG_DEBUG_IO("write %d%s, read %d", ctx->write_count, ctx->read_count ? "+1" : "", ctx->read_count); assert(ctx->write_count > 0 || ctx->read_count == 0); /* No read data without write data */ diff --git a/src/jtag/drivers/opendous.c b/src/jtag/drivers/opendous.c index 458df34..5f352af 100644 --- a/src/jtag/drivers/opendous.c +++ b/src/jtag/drivers/opendous.c @@ -185,7 +185,7 @@ COMMAND_HANDLER(opendous_handle_opendous_hw_jtag_command) { switch (CMD_ARGC) { case 0: - command_print(CMD_CTX, "opendous hw jtag %i", opendous_hw_jtag_version); + command_print(CMD, "opendous hw jtag %i", opendous_hw_jtag_version); break; case 1: { @@ -215,6 +215,7 @@ static const struct command_registration opendous_command_handlers[] = { .handler = &opendous_handle_opendous_info_command, .mode = COMMAND_EXEC, .help = "show opendous info", + .usage = "", }, { .name = "opendous_hw_jtag", @@ -235,6 +236,7 @@ static const struct command_registration opendous_command_handlers[] = { struct jtag_interface opendous_interface = { .name = "opendous", + .transports = jtag_only, .commands = opendous_command_handlers, .execute_queue = opendous_execute_queue, .init = opendous_init, @@ -251,7 +253,7 @@ static int opendous_execute_queue(void) while (cmd != NULL) { switch (cmd->type) { case JTAG_RUNTEST: - DEBUG_JTAG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, \ + LOG_DEBUG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, \ cmd->cmd.runtest->end_state); if (cmd->cmd.runtest->end_state != -1) @@ -260,7 +262,7 @@ static int opendous_execute_queue(void) break; case JTAG_TLR_RESET: - DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state); + LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state); if (cmd->cmd.statemove->end_state != -1) opendous_end_state(cmd->cmd.statemove->end_state); @@ -268,7 +270,7 @@ static int opendous_execute_queue(void) break; case JTAG_PATHMOVE: - DEBUG_JTAG_IO("pathmove: %i states, end in %i", \ + LOG_DEBUG_IO("pathmove: %i states, end in %i", \ cmd->cmd.pathmove->num_states, \ cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); @@ -276,13 +278,13 @@ static int opendous_execute_queue(void) break; case JTAG_SCAN: - DEBUG_JTAG_IO("scan end in %i", cmd->cmd.scan->end_state); + LOG_DEBUG_IO("scan end in %i", cmd->cmd.scan->end_state); if (cmd->cmd.scan->end_state != -1) opendous_end_state(cmd->cmd.scan->end_state); scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); - DEBUG_JTAG_IO("scan input, length = %d", scan_size); + LOG_DEBUG_IO("scan input, length = %d", scan_size); #ifdef _DEBUG_USB_COMMS_ opendous_debug_buffer(buffer, (scan_size + 7) / 8); @@ -292,7 +294,7 @@ static int opendous_execute_queue(void) break; case JTAG_RESET: - DEBUG_JTAG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); + LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); opendous_tap_execute(); @@ -302,7 +304,7 @@ static int opendous_execute_queue(void) break; case JTAG_SLEEP: - DEBUG_JTAG_IO("sleep %" PRIi32, cmd->cmd.sleep->us); + LOG_DEBUG_IO("sleep %" PRIi32, cmd->cmd.sleep->us); opendous_tap_execute(); jtag_sleep(cmd->cmd.sleep->us); break; @@ -527,7 +529,7 @@ void opendous_simple_command(uint8_t command, uint8_t _data) { int result; - DEBUG_JTAG_IO("0x%02x 0x%02x", command, _data); + LOG_DEBUG_IO("0x%02x 0x%02x", command, _data); usb_out_buffer[0] = 2; usb_out_buffer[1] = 0; @@ -596,7 +598,7 @@ void opendous_tap_append_step(int tms, int tdi) void opendous_tap_append_scan(int length, uint8_t *buffer, struct scan_command *command) { - DEBUG_JTAG_IO("append scan, length = %d", length); + LOG_DEBUG_IO("append scan, length = %d", length); struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length]; int i; @@ -678,7 +680,7 @@ int opendous_tap_execute(void) /* Copy to buffer */ buf_set_buf(tdo_buffer, first, buffer, 0, length); - DEBUG_JTAG_IO("pending scan result, length = %d", length); + LOG_DEBUG_IO("pending scan result, length = %d", length); #ifdef _DEBUG_USB_COMMS_ opendous_debug_buffer(buffer, byte_length_out); @@ -769,7 +771,7 @@ int opendous_usb_write(struct opendous_jtag *opendous_jtag, int out_length) LOG_DEBUG("USB write end: %d bytes", result); #endif - DEBUG_JTAG_IO("opendous_usb_write, out_length = %d, result = %d", out_length, result); + LOG_DEBUG_IO("opendous_usb_write, out_length = %d, result = %d", out_length, result); #ifdef _DEBUG_USB_COMMS_ opendous_debug_buffer(usb_out_buffer, out_length); @@ -795,7 +797,7 @@ int opendous_usb_read(struct opendous_jtag *opendous_jtag) #ifdef _DEBUG_USB_COMMS_ LOG_DEBUG("USB read end: %d bytes", result); #endif - DEBUG_JTAG_IO("opendous_usb_read, result = %d", result); + LOG_DEBUG_IO("opendous_usb_read, result = %d", result); #ifdef _DEBUG_USB_COMMS_ opendous_debug_buffer(usb_in_buffer, result); diff --git a/src/jtag/drivers/openjtag.c b/src/jtag/drivers/openjtag.c index 8f11b4b..7a3aa23 100644 --- a/src/jtag/drivers/openjtag.c +++ b/src/jtag/drivers/openjtag.c @@ -292,7 +292,7 @@ static int openjtag_buf_read_standard( qty - *bytes_read); if (retval < 0) { *bytes_read = 0; - DEBUG_JTAG_IO("ftdi_read_data: %s", + LOG_DEBUG_IO("ftdi_read_data: %s", ftdi_get_error_string(&ftdic)); return ERROR_JTAG_DEVICE_ERROR; } @@ -574,7 +574,7 @@ static int openjtag_execute_tap_queue(void) while (len > 0) { if (len <= 8 && openjtag_variant != OPENJTAG_VARIANT_CY7C65215) { - DEBUG_JTAG_IO("bits < 8 buf = 0x%X, will be 0x%X", + LOG_DEBUG_IO("bits < 8 buf = 0x%X, will be 0x%X", usb_rx_buf[rx_offs], usb_rx_buf[rx_offs] >> (8 - len)); buffer[count] = usb_rx_buf[rx_offs] >> (8 - len); len = 0; @@ -609,8 +609,8 @@ static void openjtag_add_byte(char buf) { if (usb_tx_buf_offs == OPENJTAG_BUFFER_SIZE) { - DEBUG_JTAG_IO("Forcing execute_tap_queue"); - DEBUG_JTAG_IO("TX Buff offs=%d", usb_tx_buf_offs); + LOG_DEBUG_IO("Forcing execute_tap_queue"); + LOG_DEBUG_IO("TX Buff offs=%d", usb_tx_buf_offs); openjtag_execute_tap_queue(); } @@ -624,8 +624,8 @@ static void openjtag_add_scan(uint8_t *buffer, int length, struct scan_command * /* Ensure space to send long chains */ /* We add two byte for each eight (or less) bits, one for command, one for data */ if (usb_tx_buf_offs + (DIV_ROUND_UP(length, 8) * 2) >= OPENJTAG_BUFFER_SIZE) { - DEBUG_JTAG_IO("Forcing execute_tap_queue from scan"); - DEBUG_JTAG_IO("TX Buff offs=%d len=%d", usb_tx_buf_offs, DIV_ROUND_UP(length, 8) * 2); + LOG_DEBUG_IO("Forcing execute_tap_queue from scan"); + LOG_DEBUG_IO("TX Buff offs=%d len=%d", usb_tx_buf_offs, DIV_ROUND_UP(length, 8) * 2); openjtag_execute_tap_queue(); } @@ -670,7 +670,7 @@ static void openjtag_add_scan(uint8_t *buffer, int length, struct scan_command * static void openjtag_execute_reset(struct jtag_command *cmd) { - DEBUG_JTAG_IO("reset trst: %i srst %i", + LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); uint8_t buf = 0x00; @@ -703,7 +703,7 @@ static void openjtag_set_state(uint8_t openocd_state) static void openjtag_execute_statemove(struct jtag_command *cmd) { - DEBUG_JTAG_IO("state move to %i", cmd->cmd.statemove->end_state); + LOG_DEBUG_IO("state move to %i", cmd->cmd.statemove->end_state); tap_set_end_state(cmd->cmd.statemove->end_state); @@ -719,7 +719,7 @@ static void openjtag_execute_scan(struct jtag_command *cmd) int scan_size, old_state; uint8_t *buffer; - DEBUG_JTAG_IO("scan ends in %s", tap_state_name(cmd->cmd.scan->end_state)); + LOG_DEBUG_IO("scan ends in %s", tap_state_name(cmd->cmd.scan->end_state)); /* get scan info */ tap_set_end_state(cmd->cmd.scan->end_state); @@ -778,7 +778,7 @@ static void openjtag_execute_runtest(struct jtag_command *cmd) static void openjtag_execute_command(struct jtag_command *cmd) { - DEBUG_JTAG_IO("openjtag_execute_command %i", cmd->type); + LOG_DEBUG_IO("openjtag_execute_command %i", cmd->type); switch (cmd->type) { case JTAG_RESET: openjtag_execute_reset(cmd); @@ -894,6 +894,7 @@ static const struct command_registration openjtag_command_handlers[] = { struct jtag_interface openjtag_interface = { .name = "openjtag", + .transports = jtag_only, .commands = openjtag_command_handlers, .execute_queue = openjtag_execute_queue, diff --git a/src/jtag/drivers/parport.c b/src/jtag/drivers/parport.c index 14fa9df..8e44dcb 100644 --- a/src/jtag/drivers/parport.c +++ b/src/jtag/drivers/parport.c @@ -413,7 +413,7 @@ COMMAND_HANDLER(parport_handle_parport_port_command) } } - command_print(CMD_CTX, "parport port = 0x%" PRIx16 "", parport_port); + command_print(CMD, "parport port = 0x%" PRIx16 "", parport_port); return ERROR_OK; } @@ -470,7 +470,7 @@ COMMAND_HANDLER(parport_handle_parport_toggling_time_command) } } - command_print(CMD_CTX, "parport toggling time = %" PRIu32 " ns", + command_print(CMD, "parport toggling time = %" PRIu32 " ns", parport_toggling_time_ns); return ERROR_OK; @@ -517,6 +517,7 @@ static const struct command_registration parport_command_handlers[] = { struct jtag_interface parport_interface = { .name = "parport", .supported = DEBUG_CAP_TMS_SEQ, + .transports = jtag_only, .commands = parport_command_handlers, .init = parport_init, diff --git a/src/jtag/drivers/presto.c b/src/jtag/drivers/presto.c index 29bc811..2a94d06 100644 --- a/src/jtag/drivers/presto.c +++ b/src/jtag/drivers/presto.c @@ -563,6 +563,7 @@ static int presto_jtag_quit(void) struct jtag_interface presto_interface = { .name = "presto", + .transports = jtag_only, .commands = presto_command_handlers, .execute_queue = bitq_execute_queue, diff --git a/src/jtag/drivers/remote_bitbang.c b/src/jtag/drivers/remote_bitbang.c index 1f8fc1a..a354894 100644 --- a/src/jtag/drivers/remote_bitbang.c +++ b/src/jtag/drivers/remote_bitbang.c @@ -345,6 +345,7 @@ static const struct command_registration remote_bitbang_command_handlers[] = { struct jtag_interface remote_bitbang_interface = { .name = "remote_bitbang", .execute_queue = &bitbang_execute_queue, + .transports = jtag_only, .commands = remote_bitbang_command_handlers, .init = &remote_bitbang_init, .quit = &remote_bitbang_quit, diff --git a/src/jtag/drivers/rlink.c b/src/jtag/drivers/rlink.c index 3f9e332..317e8b8 100644 --- a/src/jtag/drivers/rlink.c +++ b/src/jtag/drivers/rlink.c @@ -1299,11 +1299,9 @@ static int rlink_execute_queue(void) switch (cmd->type) { case JTAG_RESET: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("reset trst: %i srst %i", + LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); -#endif if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST))) @@ -1311,37 +1309,29 @@ static int rlink_execute_queue(void) rlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); break; case JTAG_RUNTEST: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("runtest %i cycles, end in %i", + LOG_DEBUG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state); -#endif if (cmd->cmd.runtest->end_state != -1) rlink_end_state(cmd->cmd.runtest->end_state); rlink_runtest(cmd->cmd.runtest->num_cycles); break; case JTAG_TLR_RESET: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state); -#endif + LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state); if (cmd->cmd.statemove->end_state != -1) rlink_end_state(cmd->cmd.statemove->end_state); rlink_state_move(); break; case JTAG_PATHMOVE: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("pathmove: %i states, end in %i", - cmd->cmd.pathmove->num_states, - cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); -#endif + LOG_DEBUG_IO("pathmove: %i states, end in %i", + cmd->cmd.pathmove->num_states, + cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); rlink_path_move(cmd->cmd.pathmove); break; case JTAG_SCAN: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("%s scan end in %i", - (cmd->cmd.scan->ir_scan) ? "IR" : "DR", - cmd->cmd.scan->end_state); -#endif + LOG_DEBUG_IO("%s scan end in %i", + (cmd->cmd.scan->ir_scan) ? "IR" : "DR", + cmd->cmd.scan->end_state); if (cmd->cmd.scan->end_state != -1) rlink_end_state(cmd->cmd.scan->end_state); scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); @@ -1350,9 +1340,7 @@ static int rlink_execute_queue(void) retval = ERROR_FAIL; break; case JTAG_SLEEP: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("sleep %i", cmd->cmd.sleep->us); -#endif + LOG_DEBUG_IO("sleep %i", cmd->cmd.sleep->us); jtag_sleep(cmd->cmd.sleep->us); break; default: @@ -1674,6 +1662,7 @@ static int rlink_quit(void) struct jtag_interface rlink_interface = { .name = "rlink", + .transports = jtag_only, .init = rlink_init, .quit = rlink_quit, .speed = rlink_speed, diff --git a/src/jtag/drivers/sysfsgpio.c b/src/jtag/drivers/sysfsgpio.c index 90e93f5..eb4941e 100644 --- a/src/jtag/drivers/sysfsgpio.c +++ b/src/jtag/drivers/sysfsgpio.c @@ -356,7 +356,7 @@ COMMAND_HANDLER(sysfsgpio_handle_jtag_gpionums) return ERROR_COMMAND_SYNTAX_ERROR; } - command_print(CMD_CTX, + command_print(CMD, "SysfsGPIO nums: tck = %d, tms = %d, tdi = %d, tdo = %d", tck_gpio, tms_gpio, tdi_gpio, tdo_gpio); @@ -368,7 +368,7 @@ COMMAND_HANDLER(sysfsgpio_handle_jtag_gpionum_tck) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tck_gpio); - command_print(CMD_CTX, "SysfsGPIO num: tck = %d", tck_gpio); + command_print(CMD, "SysfsGPIO num: tck = %d", tck_gpio); return ERROR_OK; } @@ -377,7 +377,7 @@ COMMAND_HANDLER(sysfsgpio_handle_jtag_gpionum_tms) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tms_gpio); - command_print(CMD_CTX, "SysfsGPIO num: tms = %d", tms_gpio); + command_print(CMD, "SysfsGPIO num: tms = %d", tms_gpio); return ERROR_OK; } @@ -386,7 +386,7 @@ COMMAND_HANDLER(sysfsgpio_handle_jtag_gpionum_tdo) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdo_gpio); - command_print(CMD_CTX, "SysfsGPIO num: tdo = %d", tdo_gpio); + command_print(CMD, "SysfsGPIO num: tdo = %d", tdo_gpio); return ERROR_OK; } @@ -395,7 +395,7 @@ COMMAND_HANDLER(sysfsgpio_handle_jtag_gpionum_tdi) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], tdi_gpio); - command_print(CMD_CTX, "SysfsGPIO num: tdi = %d", tdi_gpio); + command_print(CMD, "SysfsGPIO num: tdi = %d", tdi_gpio); return ERROR_OK; } @@ -404,7 +404,7 @@ COMMAND_HANDLER(sysfsgpio_handle_jtag_gpionum_srst) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], srst_gpio); - command_print(CMD_CTX, "SysfsGPIO num: srst = %d", srst_gpio); + command_print(CMD, "SysfsGPIO num: srst = %d", srst_gpio); return ERROR_OK; } @@ -413,7 +413,7 @@ COMMAND_HANDLER(sysfsgpio_handle_jtag_gpionum_trst) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], trst_gpio); - command_print(CMD_CTX, "SysfsGPIO num: trst = %d", trst_gpio); + command_print(CMD, "SysfsGPIO num: trst = %d", trst_gpio); return ERROR_OK; } @@ -426,7 +426,7 @@ COMMAND_HANDLER(sysfsgpio_handle_swd_gpionums) return ERROR_COMMAND_SYNTAX_ERROR; } - command_print(CMD_CTX, + command_print(CMD, "SysfsGPIO nums: swclk = %d, swdio = %d", swclk_gpio, swdio_gpio); @@ -438,7 +438,7 @@ COMMAND_HANDLER(sysfsgpio_handle_swd_gpionum_swclk) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swclk_gpio); - command_print(CMD_CTX, "SysfsGPIO num: swclk = %d", swclk_gpio); + command_print(CMD, "SysfsGPIO num: swclk = %d", swclk_gpio); return ERROR_OK; } @@ -447,7 +447,7 @@ COMMAND_HANDLER(sysfsgpio_handle_swd_gpionum_swdio) if (CMD_ARGC == 1) COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], swdio_gpio); - command_print(CMD_CTX, "SysfsGPIO num: swdio = %d", swdio_gpio); + command_print(CMD, "SysfsGPIO num: swdio = %d", swdio_gpio); return ERROR_OK; } diff --git a/src/jtag/drivers/ulink.c b/src/jtag/drivers/ulink.c index 550df1c..bbe08aa 100644 --- a/src/jtag/drivers/ulink.c +++ b/src/jtag/drivers/ulink.c @@ -187,12 +187,7 @@ void ulink_clear_queue(struct ulink *device); int ulink_append_queue(struct ulink *device, struct ulink_cmd *ulink_cmd); int ulink_execute_queued_commands(struct ulink *device, int timeout); -#ifdef _DEBUG_JTAG_IO_ -const char *ulink_cmd_id_string(uint8_t id); -void ulink_print_command(struct ulink_cmd *ulink_cmd); -void ulink_print_queue(struct ulink *device); -static int ulink_calculate_frequency(enum ulink_delay_type type, int delay, long *f); -#endif +static void ulink_print_queue(struct ulink *device); int ulink_append_scan_cmd(struct ulink *device, enum scan_type scan_type, @@ -708,9 +703,8 @@ int ulink_execute_queued_commands(struct ulink *device, int timeout) int ret, i, index_out, index_in, count_out, count_in, transferred; uint8_t buffer[64]; -#ifdef _DEBUG_JTAG_IO_ - ulink_print_queue(device); -#endif + if (LOG_LEVEL_IS(LOG_LVL_DEBUG_IO)) + ulink_print_queue(device); index_out = 0; count_out = 0; @@ -759,71 +753,69 @@ int ulink_execute_queued_commands(struct ulink *device, int timeout) return ERROR_OK; } -#ifdef _DEBUG_JTAG_IO_ - /** * Convert an OpenULINK command ID (\a id) to a human-readable string. * * @param id the OpenULINK command ID. * @return the corresponding human-readable string. */ -const char *ulink_cmd_id_string(uint8_t id) +static const char *ulink_cmd_id_string(uint8_t id) { switch (id) { - case CMD_SCAN_IN: - return "CMD_SCAN_IN"; - break; - case CMD_SLOW_SCAN_IN: - return "CMD_SLOW_SCAN_IN"; - break; - case CMD_SCAN_OUT: - return "CMD_SCAN_OUT"; - break; - case CMD_SLOW_SCAN_OUT: - return "CMD_SLOW_SCAN_OUT"; - break; - case CMD_SCAN_IO: - return "CMD_SCAN_IO"; - break; - case CMD_SLOW_SCAN_IO: - return "CMD_SLOW_SCAN_IO"; - break; - case CMD_CLOCK_TMS: - return "CMD_CLOCK_TMS"; - break; - case CMD_SLOW_CLOCK_TMS: - return "CMD_SLOW_CLOCK_TMS"; - break; - case CMD_CLOCK_TCK: - return "CMD_CLOCK_TCK"; - break; - case CMD_SLOW_CLOCK_TCK: - return "CMD_SLOW_CLOCK_TCK"; - break; - case CMD_SLEEP_US: - return "CMD_SLEEP_US"; - break; - case CMD_SLEEP_MS: - return "CMD_SLEEP_MS"; - break; - case CMD_GET_SIGNALS: - return "CMD_GET_SIGNALS"; - break; - case CMD_SET_SIGNALS: - return "CMD_SET_SIGNALS"; - break; - case CMD_CONFIGURE_TCK_FREQ: - return "CMD_CONFIGURE_TCK_FREQ"; - break; - case CMD_SET_LEDS: - return "CMD_SET_LEDS"; - break; - case CMD_TEST: - return "CMD_TEST"; - break; - default: - return "CMD_UNKNOWN"; - break; + case CMD_SCAN_IN: + return "CMD_SCAN_IN"; + break; + case CMD_SLOW_SCAN_IN: + return "CMD_SLOW_SCAN_IN"; + break; + case CMD_SCAN_OUT: + return "CMD_SCAN_OUT"; + break; + case CMD_SLOW_SCAN_OUT: + return "CMD_SLOW_SCAN_OUT"; + break; + case CMD_SCAN_IO: + return "CMD_SCAN_IO"; + break; + case CMD_SLOW_SCAN_IO: + return "CMD_SLOW_SCAN_IO"; + break; + case CMD_CLOCK_TMS: + return "CMD_CLOCK_TMS"; + break; + case CMD_SLOW_CLOCK_TMS: + return "CMD_SLOW_CLOCK_TMS"; + break; + case CMD_CLOCK_TCK: + return "CMD_CLOCK_TCK"; + break; + case CMD_SLOW_CLOCK_TCK: + return "CMD_SLOW_CLOCK_TCK"; + break; + case CMD_SLEEP_US: + return "CMD_SLEEP_US"; + break; + case CMD_SLEEP_MS: + return "CMD_SLEEP_MS"; + break; + case CMD_GET_SIGNALS: + return "CMD_GET_SIGNALS"; + break; + case CMD_SET_SIGNALS: + return "CMD_SET_SIGNALS"; + break; + case CMD_CONFIGURE_TCK_FREQ: + return "CMD_CONFIGURE_TCK_FREQ"; + break; + case CMD_SET_LEDS: + return "CMD_SET_LEDS"; + break; + case CMD_TEST: + return "CMD_TEST"; + break; + default: + return "CMD_UNKNOWN"; + break; } } @@ -832,7 +824,7 @@ const char *ulink_cmd_id_string(uint8_t id) * * @param ulink_cmd pointer to OpenULINK command. */ -void ulink_print_command(struct ulink_cmd *ulink_cmd) +static void ulink_print_command(struct ulink_cmd *ulink_cmd) { int i; @@ -850,7 +842,7 @@ void ulink_print_command(struct ulink_cmd *ulink_cmd) * * @param device pointer to struct ulink identifying ULINK driver instance. */ -void ulink_print_queue(struct ulink *device) +static void ulink_print_queue(struct ulink *device) { struct ulink_cmd *current; @@ -860,8 +852,6 @@ void ulink_print_queue(struct ulink *device) ulink_print_command(current); } -#endif /* _DEBUG_JTAG_IO_ */ - /** * Perform JTAG scan * @@ -1367,7 +1357,6 @@ int ulink_calculate_delay(enum ulink_delay_type type, long f, int *delay) return ERROR_OK; } -#ifdef _DEBUG_JTAG_IO_ /** * Calculate frequency for a given delay value. * @@ -1378,16 +1367,14 @@ int ulink_calculate_delay(enum ulink_delay_type type, long f, int *delay) * * @param type for which command to calculate the delay value. * @param delay delay value for which to calculate the resulting TCK frequency. - * @param f where to store the resulting TCK frequency. - * @return on success: ERROR_OK - * @return on failure: ERROR_FAIL + * @return the resulting TCK frequency */ -static int ulink_calculate_frequency(enum ulink_delay_type type, int delay, long *f) +static long ulink_calculate_frequency(enum ulink_delay_type type, int delay) { - float t, f_float, f_rounded; + float t, f_float; if (delay > 255) - return ERROR_FAIL; + return 0; switch (type) { case DELAY_CLOCK_TCK: @@ -1421,17 +1408,12 @@ static int ulink_calculate_frequency(enum ulink_delay_type type, int delay, long t = (float)(4E-6) * (float)(delay) + (float)(1.3132E-5); break; default: - return ERROR_FAIL; - break; + return 0; } f_float = 1.0 / t; - f_rounded = roundf(f_float); - *f = (long)f_rounded; - - return ERROR_OK; + return roundf(f_float); } -#endif /******************* Interface between OpenULINK and OpenOCD ******************/ @@ -2065,31 +2047,21 @@ static int ulink_khz(int khz, int *jtag_speed) return ret; } -#ifdef _DEBUG_JTAG_IO_ - long f_tck = 0, f_tms = 0, f_scan_in = 0, f_scan_out = 0, f_scan_io = 0; - - ulink_calculate_frequency(DELAY_CLOCK_TCK, ulink_handle->delay_clock_tck, - &f_tck); - ulink_calculate_frequency(DELAY_CLOCK_TMS, ulink_handle->delay_clock_tms, - &f_tms); - ulink_calculate_frequency(DELAY_SCAN_IN, ulink_handle->delay_scan_in, - &f_scan_in); - ulink_calculate_frequency(DELAY_SCAN_OUT, ulink_handle->delay_scan_out, - &f_scan_out); - ulink_calculate_frequency(DELAY_SCAN_IO, ulink_handle->delay_scan_io, - &f_scan_io); - - DEBUG_JTAG_IO("ULINK TCK setup: delay_tck = %i (%li Hz),", - ulink_handle->delay_clock_tck, f_tck); - DEBUG_JTAG_IO(" delay_tms = %i (%li Hz),", - ulink_handle->delay_clock_tms, f_tms); - DEBUG_JTAG_IO(" delay_scan_in = %i (%li Hz),", - ulink_handle->delay_scan_in, f_scan_in); - DEBUG_JTAG_IO(" delay_scan_out = %i (%li Hz),", - ulink_handle->delay_scan_out, f_scan_out); - DEBUG_JTAG_IO(" delay_scan_io = %i (%li Hz),", - ulink_handle->delay_scan_io, f_scan_io); -#endif + LOG_DEBUG_IO("ULINK TCK setup: delay_tck = %i (%li Hz),", + ulink_handle->delay_clock_tck, + ulink_calculate_frequency(DELAY_CLOCK_TCK, ulink_handle->delay_clock_tck)); + LOG_DEBUG_IO(" delay_tms = %i (%li Hz),", + ulink_handle->delay_clock_tms, + ulink_calculate_frequency(DELAY_CLOCK_TMS, ulink_handle->delay_clock_tms)); + LOG_DEBUG_IO(" delay_scan_in = %i (%li Hz),", + ulink_handle->delay_scan_in, + ulink_calculate_frequency(DELAY_SCAN_IN, ulink_handle->delay_scan_in)); + LOG_DEBUG_IO(" delay_scan_out = %i (%li Hz),", + ulink_handle->delay_scan_out, + ulink_calculate_frequency(DELAY_SCAN_OUT, ulink_handle->delay_scan_out)); + LOG_DEBUG_IO(" delay_scan_io = %i (%li Hz),", + ulink_handle->delay_scan_io, + ulink_calculate_frequency(DELAY_SCAN_IO, ulink_handle->delay_scan_io)); /* Configure the ULINK device with the new delay values */ ret = ulink_append_configure_tck_cmd(ulink_handle, diff --git a/src/jtag/drivers/usb_blaster/usb_blaster.c b/src/jtag/drivers/usb_blaster/usb_blaster.c index 8ccf871..165ebdc 100644 --- a/src/jtag/drivers/usb_blaster/usb_blaster.c +++ b/src/jtag/drivers/usb_blaster/usb_blaster.c @@ -174,7 +174,7 @@ static int ublast_buf_read(uint8_t *buf, unsigned size, uint32_t *bytes_read) int ret = info.drv->read(info.drv, buf, size, bytes_read); char *str = hexdump(buf, *bytes_read); - DEBUG_JTAG_IO("(size=%d, buf=[%s]) -> %u", size, str, + LOG_DEBUG_IO("(size=%d, buf=[%s]) -> %u", size, str, *bytes_read); free(str); return ret; @@ -185,7 +185,7 @@ static int ublast_buf_write(uint8_t *buf, int size, uint32_t *bytes_written) int ret = info.drv->write(info.drv, buf, size, bytes_written); char *str = hexdump(buf, *bytes_written); - DEBUG_JTAG_IO("(size=%d, buf=[%s]) -> %u", size, str, + LOG_DEBUG_IO("(size=%d, buf=[%s]) -> %u", size, str, *bytes_written); free(str); return ret; @@ -266,7 +266,7 @@ static void ublast_queue_byte(uint8_t abyte) info.buf[info.bufidx++] = abyte; if (nb_buf_remaining() == 0) ublast_flush_buffer(); - DEBUG_JTAG_IO("(byte=0x%02x)", abyte); + LOG_DEBUG_IO("(byte=0x%02x)", abyte); } /** @@ -337,7 +337,7 @@ static void ublast_clock_tms(int tms) { uint8_t out; - DEBUG_JTAG_IO("(tms=%d)", !!tms); + LOG_DEBUG_IO("(tms=%d)", !!tms); info.tms = !!tms; info.tdi = 0; out = ublast_build_out(SCAN_OUT); @@ -354,7 +354,7 @@ static void ublast_idle_clock(void) { uint8_t out = ublast_build_out(SCAN_OUT); - DEBUG_JTAG_IO("."); + LOG_DEBUG_IO("."); ublast_queue_byte(out); } @@ -375,7 +375,7 @@ static void ublast_clock_tdi(int tdi, enum scan_type type) { uint8_t out; - DEBUG_JTAG_IO("(tdi=%d)", !!tdi); + LOG_DEBUG_IO("(tdi=%d)", !!tdi); info.tdi = !!tdi; out = ublast_build_out(SCAN_OUT); @@ -400,7 +400,7 @@ static void ublast_clock_tdi_flip_tms(int tdi, enum scan_type type) { uint8_t out; - DEBUG_JTAG_IO("(tdi=%d)", !!tdi); + LOG_DEBUG_IO("(tdi=%d)", !!tdi); info.tdi = !!tdi; info.tms = !info.tms; @@ -430,7 +430,7 @@ static void ublast_queue_bytes(uint8_t *bytes, int nb_bytes) info.bufidx + nb_bytes); exit(-1); } - DEBUG_JTAG_IO("(nb_bytes=%d, bytes=[0x%02x, ...])", nb_bytes, + LOG_DEBUG_IO("(nb_bytes=%d, bytes=[0x%02x, ...])", nb_bytes, bytes ? bytes[0] : 0); if (bytes) memcpy(&info.buf[info.bufidx], bytes, nb_bytes); @@ -457,7 +457,7 @@ static void ublast_tms_seq(const uint8_t *bits, int nb_bits, int skip) { int i; - DEBUG_JTAG_IO("(bits=%02x..., nb_bits=%d)", bits[0], nb_bits); + LOG_DEBUG_IO("(bits=%02x..., nb_bits=%d)", bits[0], nb_bits); for (i = skip; i < nb_bits; i++) ublast_clock_tms((bits[i / 8] >> (i % 8)) & 0x01); ublast_idle_clock(); @@ -469,7 +469,7 @@ static void ublast_tms_seq(const uint8_t *bits, int nb_bits, int skip) */ static void ublast_tms(struct tms_command *cmd) { - DEBUG_JTAG_IO("(num_bits=%d)", cmd->num_bits); + LOG_DEBUG_IO("(num_bits=%d)", cmd->num_bits); ublast_tms_seq(cmd->bits, cmd->num_bits, 0); } @@ -487,7 +487,7 @@ static void ublast_path_move(struct pathmove_command *cmd) { int i; - DEBUG_JTAG_IO("(num_states=%d, last_state=%d)", + LOG_DEBUG_IO("(num_states=%d, last_state=%d)", cmd->num_states, cmd->path[cmd->num_states - 1]); for (i = 0; i < cmd->num_states; i++) { if (tap_state_transition(tap_get_state(), false) == cmd->path[i]) @@ -512,7 +512,7 @@ static void ublast_state_move(tap_state_t state, int skip) uint8_t tms_scan; int tms_len; - DEBUG_JTAG_IO("(from %s to %s)", tap_state_name(tap_get_state()), + LOG_DEBUG_IO("(from %s to %s)", tap_state_name(tap_get_state()), tap_state_name(state)); if (tap_get_state() == state) return; @@ -541,7 +541,7 @@ static int ublast_read_byteshifted_tdos(uint8_t *buf, int nb_bytes) unsigned int retlen; int ret = ERROR_OK; - DEBUG_JTAG_IO("%s(buf=%p, num_bits=%d)", __func__, buf, nb_bytes * 8); + LOG_DEBUG_IO("%s(buf=%p, num_bits=%d)", __func__, buf, nb_bytes * 8); ublast_flush_buffer(); while (ret == ERROR_OK && nb_bytes > 0) { ret = ublast_buf_read(buf, nb_bytes, &retlen); @@ -573,7 +573,7 @@ static int ublast_read_bitbang_tdos(uint8_t *buf, int nb_bits) unsigned int retlen; uint8_t tmp[8]; - DEBUG_JTAG_IO("%s(buf=%p, num_bits=%d)", __func__, buf, nb_bits); + LOG_DEBUG_IO("%s(buf=%p, num_bits=%d)", __func__, buf, nb_bits); /* * Ensure all previous bitbang writes were issued to the dongle, so that @@ -688,7 +688,7 @@ static void ublast_queue_tdi(uint8_t *bits, int nb_bits, enum scan_type scan) static void ublast_runtest(int cycles, tap_state_t state) { - DEBUG_JTAG_IO("%s(cycles=%i, end_state=%d)", __func__, cycles, state); + LOG_DEBUG_IO("%s(cycles=%i, end_state=%d)", __func__, cycles, state); ublast_state_move(TAP_IDLE, 0); ublast_queue_tdi(NULL, cycles, SCAN_OUT); @@ -697,7 +697,7 @@ static void ublast_runtest(int cycles, tap_state_t state) static void ublast_stableclocks(int cycles) { - DEBUG_JTAG_IO("%s(cycles=%i)", __func__, cycles); + LOG_DEBUG_IO("%s(cycles=%i)", __func__, cycles); ublast_queue_tdi(NULL, cycles, SCAN_OUT); } @@ -727,7 +727,7 @@ static int ublast_scan(struct scan_command *cmd) ublast_state_move(TAP_DRSHIFT, 0); log_buf = hexdump(buf, DIV_ROUND_UP(scan_bits, 8)); - DEBUG_JTAG_IO("%s(scan=%s, type=%s, bits=%d, buf=[%s], end_state=%d)", __func__, + LOG_DEBUG_IO("%s(scan=%s, type=%s, bits=%d, buf=[%s], end_state=%d)", __func__, cmd->ir_scan ? "IRSCAN" : "DRSCAN", type2str[type], scan_bits, log_buf, cmd->end_state); @@ -749,7 +749,7 @@ static int ublast_scan(struct scan_command *cmd) static void ublast_usleep(int us) { - DEBUG_JTAG_IO("%s(us=%d)", __func__, us); + LOG_DEBUG_IO("%s(us=%d)", __func__, us); jtag_sleep(us); } @@ -1068,6 +1068,7 @@ static const struct command_registration ublast_command_handlers[] = { struct jtag_interface usb_blaster_interface = { .name = "usb_blaster", + .transports = jtag_only, .commands = ublast_command_handlers, .supported = DEBUG_CAP_TMS_SEQ, diff --git a/src/jtag/drivers/usbprog.c b/src/jtag/drivers/usbprog.c index d81c329..35a9520 100644 --- a/src/jtag/drivers/usbprog.c +++ b/src/jtag/drivers/usbprog.c @@ -103,62 +103,50 @@ static int usbprog_execute_queue(void) while (cmd) { switch (cmd->type) { - case JTAG_RESET: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("reset trst: %i srst %i", - cmd->cmd.reset->trst, - cmd->cmd.reset->srst); -#endif - if (cmd->cmd.reset->trst == 1) - tap_set_state(TAP_RESET); - usbprog_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); - break; - case JTAG_RUNTEST: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("runtest %i cycles, end in %i", - cmd->cmd.runtest->num_cycles, - cmd->cmd.runtest->end_state); -#endif - usbprog_end_state(cmd->cmd.runtest->end_state); - usbprog_runtest(cmd->cmd.runtest->num_cycles); - break; - case JTAG_TLR_RESET: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state); -#endif - usbprog_end_state(cmd->cmd.statemove->end_state); - usbprog_state_move(); - break; - case JTAG_PATHMOVE: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("pathmove: %i states, end in %i", - cmd->cmd.pathmove->num_states, - cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); -#endif - usbprog_path_move(cmd->cmd.pathmove); - break; - case JTAG_SCAN: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("scan end in %i", cmd->cmd.scan->end_state); -#endif - usbprog_end_state(cmd->cmd.scan->end_state); - scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); - type = jtag_scan_type(cmd->cmd.scan); - usbprog_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size); - if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK) - return ERROR_JTAG_QUEUE_FAILED; - if (buffer) - free(buffer); - break; - case JTAG_SLEEP: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("sleep %i", cmd->cmd.sleep->us); -#endif - jtag_sleep(cmd->cmd.sleep->us); - break; - default: - LOG_ERROR("BUG: unknown JTAG command type encountered"); - exit(-1); + case JTAG_RESET: + LOG_DEBUG_IO("reset trst: %i srst %i", + cmd->cmd.reset->trst, + cmd->cmd.reset->srst); + if (cmd->cmd.reset->trst == 1) + tap_set_state(TAP_RESET); + usbprog_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); + break; + case JTAG_RUNTEST: + LOG_DEBUG_IO("runtest %i cycles, end in %i", + cmd->cmd.runtest->num_cycles, + cmd->cmd.runtest->end_state); + usbprog_end_state(cmd->cmd.runtest->end_state); + usbprog_runtest(cmd->cmd.runtest->num_cycles); + break; + case JTAG_TLR_RESET: + LOG_DEBUG_IO("statemove end in %i", cmd->cmd.statemove->end_state); + usbprog_end_state(cmd->cmd.statemove->end_state); + usbprog_state_move(); + break; + case JTAG_PATHMOVE: + LOG_DEBUG_IO("pathmove: %i states, end in %i", + cmd->cmd.pathmove->num_states, + cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); + usbprog_path_move(cmd->cmd.pathmove); + break; + case JTAG_SCAN: + LOG_DEBUG_IO("scan end in %i", cmd->cmd.scan->end_state); + usbprog_end_state(cmd->cmd.scan->end_state); + scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); + type = jtag_scan_type(cmd->cmd.scan); + usbprog_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size); + if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK) + return ERROR_JTAG_QUEUE_FAILED; + if (buffer) + free(buffer); + break; + case JTAG_SLEEP: + LOG_DEBUG_IO("sleep %i", cmd->cmd.sleep->us); + jtag_sleep(cmd->cmd.sleep->us); + break; + default: + LOG_ERROR("BUG: unknown JTAG command type encountered"); + exit(-1); } cmd = cmd->next; @@ -270,10 +258,8 @@ static void usbprog_runtest(int num_cycles) usbprog_write(0, 0, 0); } -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("runtest: cur_state %s end_state %s", tap_state_name( + LOG_DEBUG_IO("runtest: cur_state %s end_state %s", tap_state_name( tap_get_state()), tap_state_name(tap_get_end_state())); -#endif /* finish in end_state */ /* @@ -612,6 +598,7 @@ static void usbprog_jtag_tms_send(struct usbprog_jtag *usbprog_jtag) struct jtag_interface usbprog_interface = { .name = "usbprog", + .transports = jtag_only, .execute_queue = usbprog_execute_queue, .init = usbprog_init, diff --git a/src/jtag/drivers/vsllink.c b/src/jtag/drivers/vsllink.c index 6f7e9ca..4907ef0 100644 --- a/src/jtag/drivers/vsllink.c +++ b/src/jtag/drivers/vsllink.c @@ -82,9 +82,7 @@ struct vsllink { static int vsllink_usb_open(struct vsllink *vsllink); static void vsllink_usb_close(struct vsllink *vsllink); -#if defined _DEBUG_JTAG_IO_ static void vsllink_debug_buffer(uint8_t *buffer, int length); -#endif static int tap_length; static int tap_buffer_size; @@ -103,14 +101,14 @@ static int vsllink_execute_queue(void) enum scan_type type; uint8_t *buffer; - DEBUG_JTAG_IO("-------------------------------------" + LOG_DEBUG_IO("-------------------------------------" " vsllink " "-------------------------------------"); while (cmd != NULL) { switch (cmd->type) { case JTAG_RUNTEST: - DEBUG_JTAG_IO("runtest %i cycles, end in %s", + LOG_DEBUG_IO("runtest %i cycles, end in %s", cmd->cmd.runtest->num_cycles, tap_state_name(cmd->cmd.runtest->end_state)); @@ -119,7 +117,7 @@ static int vsllink_execute_queue(void) break; case JTAG_TLR_RESET: - DEBUG_JTAG_IO("statemove end in %s", + LOG_DEBUG_IO("statemove end in %s", tap_state_name(cmd->cmd.statemove->end_state)); vsllink_end_state(cmd->cmd.statemove->end_state); @@ -127,7 +125,7 @@ static int vsllink_execute_queue(void) break; case JTAG_PATHMOVE: - DEBUG_JTAG_IO("pathmove: %i states, end in %s", + LOG_DEBUG_IO("pathmove: %i states, end in %s", cmd->cmd.pathmove->num_states, tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1])); @@ -135,7 +133,7 @@ static int vsllink_execute_queue(void) break; case JTAG_SCAN: - DEBUG_JTAG_IO("JTAG Scan..."); + LOG_DEBUG_IO("JTAG Scan..."); vsllink_end_state(cmd->cmd.scan->end_state); @@ -143,23 +141,21 @@ static int vsllink_execute_queue(void) cmd->cmd.scan, &buffer); if (cmd->cmd.scan->ir_scan) - DEBUG_JTAG_IO( + LOG_DEBUG_IO( "JTAG Scan write IR(%d bits), " "end in %s:", scan_size, tap_state_name(cmd->cmd.scan->end_state)); else - DEBUG_JTAG_IO( + LOG_DEBUG_IO( "JTAG Scan write DR(%d bits), " "end in %s:", scan_size, tap_state_name(cmd->cmd.scan->end_state)); -#ifdef _DEBUG_JTAG_IO_ - vsllink_debug_buffer(buffer, - DIV_ROUND_UP(scan_size, 8)); -#endif + if (LOG_LEVEL_IS(LOG_LVL_DEBUG_IO)) + vsllink_debug_buffer(buffer, DIV_ROUND_UP(scan_size, 8)); type = jtag_scan_type(cmd->cmd.scan); @@ -169,7 +165,7 @@ static int vsllink_execute_queue(void) break; case JTAG_RESET: - DEBUG_JTAG_IO("reset trst: %i srst %i", + LOG_DEBUG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); @@ -183,13 +179,13 @@ static int vsllink_execute_queue(void) break; case JTAG_SLEEP: - DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us); + LOG_DEBUG_IO("sleep %i", cmd->cmd.sleep->us); vsllink_tap_execute(); jtag_sleep(cmd->cmd.sleep->us); break; case JTAG_STABLECLOCKS: - DEBUG_JTAG_IO("add %d clocks", + LOG_DEBUG_IO("add %d clocks", cmd->cmd.stableclocks->num_cycles); switch (tap_get_state()) { @@ -219,7 +215,7 @@ static int vsllink_execute_queue(void) break; case JTAG_TMS: - DEBUG_JTAG_IO("add %d jtag tms", + LOG_DEBUG_IO("add %d jtag tms", cmd->cmd.tms->num_bits); vsllink_tms(cmd->cmd.tms->num_bits, cmd->cmd.tms->bits); @@ -681,13 +677,11 @@ static int vsllink_jtag_execute(void) command = pending_scan_result->command; buf_set_buf(tdo_buffer, src_first, buffer, dest_first, length); -#ifdef _DEBUG_JTAG_IO_ - DEBUG_JTAG_IO( + LOG_DEBUG_IO( "JTAG scan read(%d bits, from src %d bits to dest %d bits):", length, src_first, dest_first); - vsllink_debug_buffer(buffer + dest_first / 8, - DIV_ROUND_UP(length, 7)); -#endif + if (LOG_LEVEL_IS(LOG_LVL_DEBUG_IO)) + vsllink_debug_buffer(buffer + dest_first / 8, DIV_ROUND_UP(length, 7)); if (last) { if (jtag_read_buffer(buffer, command) @@ -895,7 +889,6 @@ static void vsllink_usb_close(struct vsllink *vsllink) #define BYTES_PER_LINE 16 -#if defined _DEBUG_JTAG_IO_ static void vsllink_debug_buffer(uint8_t *buffer, int length) { char line[81]; @@ -904,46 +897,57 @@ static void vsllink_debug_buffer(uint8_t *buffer, int length) int j; for (i = 0; i < length; i += BYTES_PER_LINE) { - snprintf(line, 5, "%04x", i); + snprintf(line, 5, "%04x", i & 0xffff); for (j = i; j < i + BYTES_PER_LINE && j < length; j++) { snprintf(s, 4, " %02x", buffer[j]); strcat(line, s); } - LOG_DEBUG("%s", line); + LOG_DEBUG_IO("%s", line); } } -#endif /* _DEBUG_JTAG_IO_ */ static const struct command_registration vsllink_command_handlers[] = { { .name = "vsllink_usb_vid", .handler = &vsllink_handle_usb_vid_command, .mode = COMMAND_CONFIG, + .help = "Set USB VID", + .usage = "<vid>", }, { .name = "vsllink_usb_pid", .handler = &vsllink_handle_usb_pid_command, .mode = COMMAND_CONFIG, + .help = "Set USB PID", + .usage = "<pid>", }, { .name = "vsllink_usb_serial", .handler = &vsllink_handle_usb_serial_command, .mode = COMMAND_CONFIG, + .help = "Set or disable check for USB serial", + .usage = "[<serial>]", }, { .name = "vsllink_usb_bulkin", .handler = &vsllink_handle_usb_bulkin_command, .mode = COMMAND_CONFIG, + .help = "Set USB input endpoint", + .usage = "<ep_in>", }, { .name = "vsllink_usb_bulkout", .handler = &vsllink_handle_usb_bulkout_command, .mode = COMMAND_CONFIG, + .help = "Set USB output endpoint", + .usage = "<ep_out>", }, { .name = "vsllink_usb_interface", .handler = &vsllink_handle_usb_interface_command, .mode = COMMAND_CONFIG, + .help = "Set USB output interface", + .usage = "<interface>", }, COMMAND_REGISTRATION_DONE }; @@ -952,7 +956,6 @@ static const char * const vsllink_transports[] = {"jtag", "swd", NULL}; static const struct swd_driver vsllink_swd_driver = { .init = vsllink_swd_init, - .frequency = vsllink_swd_frequency, .switch_seq = vsllink_swd_switch_seq, .read_reg = vsllink_swd_read_reg, .write_reg = vsllink_swd_write_reg, diff --git a/src/jtag/drivers/xds110.c b/src/jtag/drivers/xds110.c index 20b8178..f25023b 100644 --- a/src/jtag/drivers/xds110.c +++ b/src/jtag/drivers/xds110.c @@ -1925,13 +1925,6 @@ static int xds110_khz(int khz, int *jtag_speed) return ERROR_OK; } -static int_least32_t xds110_swd_frequency(int_least32_t hz) -{ - if (hz > 0) - xds110_speed(hz / 1000); - return hz; -} - COMMAND_HANDLER(xds110_handle_info_command) { xds110_show_info(); @@ -2032,7 +2025,6 @@ static const struct command_registration xds110_command_handlers[] = { static const struct swd_driver xds110_swd_driver = { .init = xds110_swd_init, - .frequency = xds110_swd_frequency, .switch_seq = xds110_swd_switch_seq, .read_reg = xds110_swd_read_reg, .write_reg = xds110_swd_write_reg, diff --git a/src/jtag/interface.c b/src/jtag/interface.c index e12b2ae..de132bb 100644 --- a/src/jtag/interface.c +++ b/src/jtag/interface.c @@ -376,15 +376,13 @@ tap_state_t tap_state_by_name(const char *name) return TAP_INVALID; } -#ifdef _DEBUG_JTAG_IO_ - #define JTAG_DEBUG_STATE_APPEND(buf, len, bit) \ do { buf[len] = bit ? '1' : '0'; } while (0) #define JTAG_DEBUG_STATE_PRINT(a, b, astr, bstr) \ - DEBUG_JTAG_IO("TAP/SM: %9s -> %5s\tTMS: %s\tTDI: %s", \ + LOG_DEBUG_IO("TAP/SM: %9s -> %5s\tTMS: %s\tTDI: %s", \ tap_state_name(a), tap_state_name(b), astr, bstr) -tap_state_t jtag_debug_state_machine(const void *tms_buf, const void *tdi_buf, +tap_state_t jtag_debug_state_machine_(const void *tms_buf, const void *tdi_buf, unsigned tap_bits, tap_state_t next_state) { const uint8_t *tms_buffer; @@ -401,13 +399,13 @@ tap_state_t jtag_debug_state_machine(const void *tms_buf, const void *tdi_buf, /* set startstate (and possibly last, if tap_bits == 0) */ last_state = next_state; - DEBUG_JTAG_IO("TAP/SM: START state: %s", tap_state_name(next_state)); + LOG_DEBUG_IO("TAP/SM: START state: %s", tap_state_name(next_state)); tms_buffer = (const uint8_t *)tms_buf; tdi_buffer = (const uint8_t *)tdi_buf; tap_bytes = DIV_ROUND_UP(tap_bits, 8); - DEBUG_JTAG_IO("TAP/SM: TMS bits: %u (bytes: %u)", tap_bits, tap_bytes); + LOG_DEBUG_IO("TAP/SM: TMS bits: %u (bytes: %u)", tap_bits, tap_bytes); tap_out_bits = 0; for (cur_byte = 0; cur_byte < tap_bytes; cur_byte++) { @@ -452,11 +450,10 @@ tap_state_t jtag_debug_state_machine(const void *tms_buf, const void *tdi_buf, JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str); } - DEBUG_JTAG_IO("TAP/SM: FINAL state: %s", tap_state_name(next_state)); + LOG_DEBUG_IO("TAP/SM: FINAL state: %s", tap_state_name(next_state)); return next_state; } -#endif /* _DEBUG_JTAG_IO_ */ void tap_use_new_tms_table(bool use_new) { diff --git a/src/jtag/interface.h b/src/jtag/interface.h index e6fa0ca..905f1eb 100644 --- a/src/jtag/interface.h +++ b/src/jtag/interface.h @@ -56,18 +56,11 @@ void tap_set_state_impl(tap_state_t new_state); * @param new_state The state we think the TAPs are currently in (or * are about to enter). */ -#if defined(_DEBUG_JTAG_IO_) #define tap_set_state(new_state) \ do { \ - LOG_DEBUG("tap_set_state(%s)", tap_state_name(new_state)); \ + LOG_DEBUG_IO("tap_set_state(%s)", tap_state_name(new_state)); \ tap_set_state_impl(new_state); \ } while (0) -#else -static inline void tap_set_state(tap_state_t new_state) -{ - tap_set_state_impl(new_state); -} -#endif /** * This function gets the state of the "state follower" which tracks the @@ -164,7 +157,7 @@ void tap_use_new_tms_table(bool use_new); /** @returns True if new TMS table is active; false otherwise. */ bool tap_uses_new_tms_table(void); -#ifdef _DEBUG_JTAG_IO_ + /** * @brief Prints verbose TAP state transitions for the given TMS/TDI buffers. * @param tms_buf must points to a buffer containing the TMS bitstream. @@ -173,15 +166,18 @@ bool tap_uses_new_tms_table(void); * @param start_tap_state must specify the current TAP state. * @returns the final TAP state; pass as @a start_tap_state in following call. */ -tap_state_t jtag_debug_state_machine(const void *tms_buf, const void *tdi_buf, - unsigned tap_len, tap_state_t start_tap_state); -#else static inline tap_state_t jtag_debug_state_machine(const void *tms_buf, const void *tdi_buf, unsigned tap_len, tap_state_t start_tap_state) { - return start_tap_state; + /* Private declaration */ + tap_state_t jtag_debug_state_machine_(const void *tms_buf, const void *tdi_buf, + unsigned tap_len, tap_state_t start_tap_state); + + if (LOG_LEVEL_IS(LOG_LVL_DEBUG_IO)) + return jtag_debug_state_machine_(tms_buf, tdi_buf, tap_len, start_tap_state); + else + return start_tap_state; } -#endif /* _DEBUG_JTAG_IO_ */ /** * Represents a driver for a debugging interface. diff --git a/src/jtag/jtag.h b/src/jtag/jtag.h index a6891c0..c93243c 100644 --- a/src/jtag/jtag.h +++ b/src/jtag/jtag.h @@ -25,14 +25,6 @@ #include <helper/binarybuffer.h> #include <helper/log.h> -#ifdef _DEBUG_JTAG_IO_ -#define DEBUG_JTAG_IO(expr ...) \ - do { if (1) LOG_DEBUG(expr); } while (0) -#else -#define DEBUG_JTAG_IO(expr ...) \ - do { if (0) LOG_DEBUG(expr); } while (0) -#endif - #ifndef DEBUG_JTAG_IOZ #define DEBUG_JTAG_IOZ 64 #endif diff --git a/src/jtag/minidummy/minidummy.c b/src/jtag/minidummy/minidummy.c index b7c989f..2f26004 100644 --- a/src/jtag/minidummy/minidummy.c +++ b/src/jtag/minidummy/minidummy.c @@ -28,6 +28,7 @@ struct jtag_interface minidummy_interface = { .name = "minidummy", .execute_queue = NULL, .speed = NULL, + .transports = jtag_only, .commands = NULL, .init = NULL, .quit = NULL, diff --git a/src/jtag/swd.h b/src/jtag/swd.h index 3ff4de0..0b32105 100644 --- a/src/jtag/swd.h +++ b/src/jtag/swd.h @@ -233,24 +233,6 @@ struct swd_driver { int (*init)(void); /** - * Set the SWCLK frequency of the SWD link. - * - * The driver should round the desired value, downwards if possible, to - * the nearest supported frequency. A negative value should be ignored - * and can be used to query the current setting. If the driver does not - * support a variable frequency a fixed, nominal, value should be - * returned. - * - * If the frequency is increased, it must not apply before the currently - * queued transactions are executed. If the frequency is lowered, it may - * apply immediately. - * - * @param hz The desired frequency in Hz. - * @return The actual resulting frequency after rounding. - */ - int_least32_t (*frequency)(int_least32_t hz); - - /** * Queue a special SWDIO sequence. * * @param seq The special sequence to generate. diff --git a/src/jtag/tcl.c b/src/jtag/tcl.c index 7683014..cbdf2ad 100644 --- a/src/jtag/tcl.c +++ b/src/jtag/tcl.c @@ -307,11 +307,13 @@ static const struct command_registration jtag_command_handlers_to_move[] = { enum jtag_tap_cfg_param { - JCFG_EVENT + JCFG_EVENT, + JCFG_IDCODE, }; static Jim_Nvp nvp_config_opts[] = { { .name = "-event", .value = JCFG_EVENT }, + { .name = "-idcode", .value = JCFG_IDCODE }, { .name = NULL, .value = -1 } }; @@ -404,8 +406,23 @@ static int jtag_tap_configure_cmd(Jim_GetOptInfo *goi, struct jtag_tap *tap) if (e != JIM_OK) return e; break; + case JCFG_IDCODE: + if (goi->isconfigure) { + Jim_SetResultFormatted(goi->interp, + "not settable: %s", n->name); + return JIM_ERR; + } else { + if (goi->argc != 0) { + Jim_WrongNumArgs(goi->interp, + goi->argc, goi->argv, + "NO PARAMS"); + return JIM_ERR; + } + } + Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, tap->idcode)); + break; default: - Jim_SetResultFormatted(goi->interp, "unknown event: %s", n->name); + Jim_SetResultFormatted(goi->interp, "unknown value: %s", n->name); return JIM_ERR; } } @@ -622,6 +639,7 @@ static int jim_newtap_cmd(Jim_GetOptInfo *goi) static void jtag_tap_handle_event(struct jtag_tap *tap, enum jtag_event e) { struct jtag_tap_event_action *jteap; + int retval; for (jteap = tap->event_action; jteap != NULL; jteap = jteap->next) { if (jteap->event != e) @@ -632,7 +650,11 @@ static void jtag_tap_handle_event(struct jtag_tap *tap, enum jtag_event e) tap->dotted_name, e, nvp->name, Jim_GetString(jteap->body, NULL)); - if (Jim_EvalObj(jteap->interp, jteap->body) != JIM_OK) { + retval = Jim_EvalObj(jteap->interp, jteap->body); + if (retval == JIM_RETURN) + retval = jteap->interp->returnCode; + + if (retval != JIM_OK) { Jim_MakeErrorMessage(jteap->interp); LOG_USER("%s", Jim_GetString(Jim_GetResult(jteap->interp), NULL)); continue; @@ -935,9 +957,9 @@ COMMAND_HANDLER(handle_scan_chain_command) char expected_id[12]; tap = jtag_all_taps(); - command_print(CMD_CTX, + command_print(CMD, " TapName Enabled IdCode Expected IrLen IrCap IrMask"); - command_print(CMD_CTX, + command_print(CMD, "-- ------------------- -------- ---------- ---------- ----- ----- ------"); while (tap) { @@ -953,7 +975,7 @@ COMMAND_HANDLER(handle_scan_chain_command) expected = buf_get_u32(tap->expected, 0, tap->ir_length); expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length); - command_print(CMD_CTX, + command_print(CMD, "%2d %-18s %c 0x%08x %s %5d 0x%02x 0x%02x", tap->abs_chain_position, tap->dotted_name, @@ -970,7 +992,7 @@ COMMAND_HANDLER(handle_scan_chain_command) if (tap->ignore_version) expected_id[2] = '*'; - command_print(CMD_CTX, + command_print(CMD, " %s", expected_id); } @@ -991,7 +1013,7 @@ COMMAND_HANDLER(handle_jtag_ntrst_delay_command) jtag_set_ntrst_delay(delay); } - command_print(CMD_CTX, "jtag_ntrst_delay: %u", jtag_get_ntrst_delay()); + command_print(CMD, "jtag_ntrst_delay: %u", jtag_get_ntrst_delay()); return ERROR_OK; } @@ -1005,7 +1027,7 @@ COMMAND_HANDLER(handle_jtag_ntrst_assert_width_command) jtag_set_ntrst_assert_width(delay); } - command_print(CMD_CTX, "jtag_ntrst_assert_width: %u", jtag_get_ntrst_assert_width()); + command_print(CMD, "jtag_ntrst_assert_width: %u", jtag_get_ntrst_assert_width()); return ERROR_OK; } @@ -1030,9 +1052,9 @@ COMMAND_HANDLER(handle_jtag_rclk_command) return retval; if (cur_khz) - command_print(CMD_CTX, "RCLK not supported - fallback to %d kHz", cur_khz); + command_print(CMD, "RCLK not supported - fallback to %d kHz", cur_khz); else - command_print(CMD_CTX, "RCLK - adaptive"); + command_print(CMD, "RCLK - adaptive"); return retval; } @@ -1131,7 +1153,7 @@ COMMAND_HANDLER(handle_irscan_command) tap = jtag_tap_by_string(CMD_ARGV[i*2]); if (tap == NULL) { free(fields); - command_print(CMD_CTX, "Tap: %s unknown", CMD_ARGV[i*2]); + command_print(CMD, "Tap: %s unknown", CMD_ARGV[i*2]); return ERROR_FAIL; } @@ -1176,7 +1198,7 @@ COMMAND_HANDLER(handle_verify_ircapture_command) } const char *status = jtag_will_verify_capture_ir() ? "enabled" : "disabled"; - command_print(CMD_CTX, "verify Capture-IR is %s", status); + command_print(CMD, "verify Capture-IR is %s", status); return ERROR_OK; } @@ -1193,7 +1215,7 @@ COMMAND_HANDLER(handle_verify_jtag_command) } const char *status = jtag_will_verify() ? "enabled" : "disabled"; - command_print(CMD_CTX, "verify jtag capture is %s", status); + command_print(CMD, "verify jtag capture is %s", status); return ERROR_OK; } @@ -1215,7 +1237,7 @@ COMMAND_HANDLER(handle_tms_sequence_command) tap_use_new_tms_table(use_new_table); } - command_print(CMD_CTX, "tms sequence is %s", + command_print(CMD, "tms sequence is %s", tap_uses_new_tms_table() ? "short" : "long"); return ERROR_OK; diff --git a/src/jtag/zy1000/zy1000.c b/src/jtag/zy1000/zy1000.c index 4e53dd1..1734983 100644 --- a/src/jtag/zy1000/zy1000.c +++ b/src/jtag/zy1000/zy1000.c @@ -1242,6 +1242,7 @@ struct jtag_interface zy1000_interface = { .supported = DEBUG_CAP_TMS_SEQ, .execute_queue = NULL, .speed = zy1000_speed, + .transports = jtag_only, .commands = zy1000_commands, .init = zy1000_init, .quit = zy1000_quit, diff --git a/src/openocd.c b/src/openocd.c index f084dd4..2a9a0b3 100644 --- a/src/openocd.c +++ b/src/openocd.c @@ -36,7 +36,6 @@ #include <flash/nor/core.h> #include <flash/nand/core.h> #include <pld/pld.h> -#include <flash/mflash.h> #include <target/arm_cti.h> #include <target/arm_adi_v5.h> @@ -165,9 +164,6 @@ COMMAND_HANDLER(handle_init_command) if (command_run_line(CMD_CTX, "flash init") != ERROR_OK) return ERROR_FAIL; - if (command_run_line(CMD_CTX, "mflash init") != ERROR_OK) - return ERROR_FAIL; - if (command_run_line(CMD_CTX, "nand init") != ERROR_OK) return ERROR_FAIL; @@ -257,7 +253,6 @@ struct command_context *setup_command_handler(Jim_Interp *interp) &flash_register_commands, &nand_register_commands, &pld_register_commands, - &mflash_register_commands, &cti_register_commands, &dap_register_commands, NULL diff --git a/src/pld/pld.c b/src/pld/pld.c index 5210b97..ef7993c 100644 --- a/src/pld/pld.c +++ b/src/pld/pld.c @@ -116,12 +116,12 @@ COMMAND_HANDLER(handle_pld_devices_command) int i = 0; if (!pld_devices) { - command_print(CMD_CTX, "no pld devices configured"); + command_print(CMD, "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); + command_print(CMD, "#%i: %s", i++, p->driver->name); return ERROR_OK; } @@ -141,13 +141,13 @@ COMMAND_HANDLER(handle_pld_load_command) COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], dev_id); p = get_pld_device_by_num(dev_id); if (!p) { - command_print(CMD_CTX, "pld device '#%s' is out of bounds", CMD_ARGV[0]); + command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]); return ERROR_OK; } retval = p->driver->load(p, CMD_ARGV[1]); if (retval != ERROR_OK) { - command_print(CMD_CTX, "failed loading file %s to pld device %u", + command_print(CMD, "failed loading file %s to pld device %u", CMD_ARGV[1], dev_id); switch (retval) { } @@ -156,7 +156,7 @@ COMMAND_HANDLER(handle_pld_load_command) gettimeofday(&end, NULL); timeval_subtract(&duration, &end, &start); - command_print(CMD_CTX, "loaded file %s to pld device %u in %jis %jius", + command_print(CMD, "loaded file %s to pld device %u in %jis %jius", CMD_ARGV[1], dev_id, (intmax_t)duration.tv_sec, (intmax_t)duration.tv_usec); } @@ -170,6 +170,7 @@ static const struct command_registration pld_exec_command_handlers[] = { .handler = handle_pld_devices_command, .mode = COMMAND_EXEC, .help = "list configured pld devices", + .usage = "", }, { .name = "load", diff --git a/src/pld/virtex2.c b/src/pld/virtex2.c index 4e385e9..934a680 100644 --- a/src/pld/virtex2.c +++ b/src/pld/virtex2.c @@ -183,13 +183,13 @@ COMMAND_HANDLER(virtex2_handle_read_stat_command) COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], dev_id); device = get_pld_device_by_num(dev_id); if (!device) { - command_print(CMD_CTX, "pld device '#%s' is out of bounds", CMD_ARGV[0]); + command_print(CMD, "pld device '#%s' is out of bounds", CMD_ARGV[0]); return ERROR_OK; } virtex2_read_stat(device, &status); - command_print(CMD_CTX, "virtex2 status register: 0x%8.8" PRIx32 "", status); + command_print(CMD, "virtex2 status register: 0x%8.8" PRIx32 "", status); return ERROR_OK; } @@ -205,7 +205,7 @@ PLD_DEVICE_COMMAND_HANDLER(virtex2_pld_device_command) tap = jtag_tap_by_string(CMD_ARGV[1]); if (tap == NULL) { - command_print(CMD_CTX, "Tap: %s does not exist", CMD_ARGV[1]); + command_print(CMD, "Tap: %s does not exist", CMD_ARGV[1]); return ERROR_OK; } diff --git a/src/rtos/nuttx.c b/src/rtos/nuttx.c index 61fd9aa..8c3076e 100644 --- a/src/rtos/nuttx.c +++ b/src/rtos/nuttx.c @@ -174,7 +174,7 @@ static int rcmd_offset(const char *cmd, const char *name) static int nuttx_thread_packet(struct connection *connection, char const *packet, int packet_size) { - char cmd[GDB_BUFFER_SIZE / 2] = ""; + char cmd[GDB_BUFFER_SIZE / 2 + 1] = ""; /* Extra byte for nul-termination */ if (!strncmp(packet, "qRcmd", 5)) { size_t len = unhexify((uint8_t *)cmd, packet + 6, sizeof(cmd)); diff --git a/src/rtos/rtos.c b/src/rtos/rtos.c index 96dc99b..b402f2d 100644 --- a/src/rtos/rtos.c +++ b/src/rtos/rtos.c @@ -226,7 +226,7 @@ int rtos_qsymbol(struct connection *connection, char const *packet, int packet_s int rtos_detected = 0; uint64_t addr = 0; size_t reply_len; - char reply[GDB_BUFFER_SIZE], cur_sym[GDB_BUFFER_SIZE / 2] = ""; + char reply[GDB_BUFFER_SIZE + 1], cur_sym[GDB_BUFFER_SIZE / 2 + 1] = ""; /* Extra byte for nul-termination */ symbol_table_elem_t *next_sym = NULL; struct target *target = get_target_from_connection(connection); struct rtos *os = target->rtos; diff --git a/src/rtos/rtos.h b/src/rtos/rtos.h index 35420b1..d0c2050 100644 --- a/src/rtos/rtos.h +++ b/src/rtos/rtos.h @@ -65,7 +65,7 @@ struct rtos { struct rtos_reg { uint32_t number; uint32_t size; - uint8_t value[8]; + uint8_t value[16]; }; struct rtos_type { diff --git a/src/server/gdb_server.c b/src/server/gdb_server.c index a7d9442..8374985 100644 --- a/src/server/gdb_server.c +++ b/src/server/gdb_server.c @@ -67,7 +67,7 @@ struct target_desc_format { /* private connection data for GDB */ struct gdb_connection { - char buffer[GDB_BUFFER_SIZE]; + char buffer[GDB_BUFFER_SIZE + 1]; /* Extra byte for nul-termination */ char *buf_p; int buf_cnt; int ctrl_c; @@ -736,8 +736,6 @@ static void gdb_signal_reply(struct target *target, struct connection *connectio struct target *ct; if (target->rtos != NULL) { target->rtos->current_threadid = target->rtos->current_thread; - LOG_DEBUG("[%s] current_threadid=%" PRId64, target_name(target), - target->rtos->current_threadid); target->rtos->gdb_target_for_threadid(connection, target->rtos->current_threadid, &ct); } else { ct = target; @@ -905,7 +903,6 @@ static void gdb_frontend_halted(struct target *target, struct connection *connec static int gdb_target_callback_event_handler(struct target *target, enum target_event event, void *priv) { - int retval; struct connection *connection = priv; struct gdb_service *gdb_service = connection->service->priv; @@ -919,11 +916,6 @@ static int gdb_target_callback_event_handler(struct target *target, case TARGET_EVENT_HALTED: target_call_event_callbacks(target, TARGET_EVENT_GDB_END); break; - case TARGET_EVENT_GDB_FLASH_ERASE_START: - retval = jtag_execute_queue(); - if (retval != ERROR_OK) - return retval; - break; default: break; } @@ -1421,8 +1413,6 @@ static int gdb_error(struct connection *connection, int retval) /* We don't have to worry about the default 2 second timeout for GDB packets, * because GDB breaks up large memory reads into smaller reads. - * - * 8191 bytes by the looks of it. Why 8191 bytes instead of 8192????? */ static int gdb_read_memory_packet(struct connection *connection, char const *packet, int packet_size) @@ -1656,7 +1646,7 @@ static int gdb_breakpoint_watchpoint_packet(struct connection *connection, char *separator; int retval; - LOG_DEBUG("[%d]", target->coreid); + LOG_DEBUG("[%s]", target_name(target)); type = strtoul(packet + 1, &separator, 16); @@ -2629,7 +2619,7 @@ static int gdb_query_packet(struct connection *connection, &pos, &size, "PacketSize=%x;qXfer:memory-map:read%c;qXfer:features:read%c;qXfer:threads:read+;QStartNoAckMode+;vContSupported+", - (GDB_BUFFER_SIZE - 1), + GDB_BUFFER_SIZE, ((gdb_use_memory_map == 1) && (flash_get_bank_count() > 0)) ? '+' : '-', (gdb_target_desc_supported == 1) ? '+' : '-'); @@ -2821,13 +2811,11 @@ static bool gdb_handle_vcont_packet(struct connection *connection, const char *p if (parse[0] == 'c') { parse += 1; - packet_size -= 1; /* check if thread-id follows */ if (parse[0] == ':') { int64_t tid; parse += 1; - packet_size -= 1; tid = strtoll(parse, &endp, 16); if (tid == thread_id) { @@ -3146,7 +3134,7 @@ static void gdb_sig_halted(struct connection *connection) static int gdb_input_inner(struct connection *connection) { /* Do not allocate this on the stack */ - static char gdb_packet_buffer[GDB_BUFFER_SIZE]; + static char gdb_packet_buffer[GDB_BUFFER_SIZE + 1]; /* Extra byte for nul-termination */ struct target *target; char const *packet = gdb_packet_buffer; @@ -3169,7 +3157,7 @@ static int gdb_input_inner(struct connection *connection) * drain the rest of the buffer. */ do { - packet_size = GDB_BUFFER_SIZE-1; + packet_size = GDB_BUFFER_SIZE; retval = gdb_get_packet(connection, gdb_packet_buffer, &packet_size); if (retval != ERROR_OK) return retval; @@ -3530,7 +3518,7 @@ COMMAND_HANDLER(handle_gdb_sync_command) return ERROR_COMMAND_SYNTAX_ERROR; if (current_gdb_connection == NULL) { - command_print(CMD_CTX, + command_print(CMD, "gdb_sync command can only be run from within gdb using \"monitor gdb_sync\""); return ERROR_FAIL; } @@ -3735,6 +3723,7 @@ static const struct command_registration gdb_command_handlers[] = { .handler = handle_gdb_save_tdesc_command, .mode = COMMAND_EXEC, .help = "Save the target description file", + .usage = "", }, COMMAND_REGISTRATION_DONE }; diff --git a/src/server/server.c b/src/server/server.c index 539bdaf..9e63f74 100644 --- a/src/server/server.c +++ b/src/server/server.c @@ -769,7 +769,7 @@ COMMAND_HANDLER(handle_bindto_command) { switch (CMD_ARGC) { case 0: - command_print(CMD_CTX, "bindto name: %s", bindto_name); + command_print(CMD, "bindto name: %s", bindto_name); break; case 1: free(bindto_name); @@ -828,7 +828,7 @@ COMMAND_HELPER(server_port_command, unsigned short *out) { switch (CMD_ARGC) { case 0: - command_print(CMD_CTX, "%d", *out); + command_print(CMD, "%d", *out); break; case 1: { @@ -847,7 +847,7 @@ COMMAND_HELPER(server_pipe_command, char **out) { switch (CMD_ARGC) { case 0: - command_print(CMD_CTX, "%s", *out); + command_print(CMD, "%s", *out); break; case 1: { diff --git a/src/server/tcl_server.c b/src/server/tcl_server.c index 0676c88..1ec45ff 100644 --- a/src/server/tcl_server.c +++ b/src/server/tcl_server.c @@ -246,7 +246,7 @@ static int tcl_input(struct connection *connection) retval = tcl_output(connection, result, reslen); if (retval != ERROR_OK) return retval; - /* Always output ctrl-d as end of line to allow multiline results */ + /* Always output ctrl-z as end of line to allow multiline results */ tcl_output(connection, "\x1a", 1); } diff --git a/src/svf/svf.c b/src/svf/svf.c index 223af7e..759ba52 100644 --- a/src/svf/svf.c +++ b/src/svf/svf.c @@ -382,7 +382,7 @@ COMMAND_HANDLER(handle_svf_command) if (strcmp(CMD_ARGV[i], "-tap") == 0) { tap = jtag_tap_by_string(CMD_ARGV[i+1]); if (!tap) { - command_print(CMD_CTX, "Tap: %s unknown", CMD_ARGV[i+1]); + command_print(CMD, "Tap: %s unknown", CMD_ARGV[i+1]); return ERROR_FAIL; } i++; @@ -401,7 +401,7 @@ COMMAND_HANDLER(handle_svf_command) svf_fd = fopen(CMD_ARGV[i], "r"); if (svf_fd == NULL) { int err = errno; - command_print(CMD_CTX, "open(\"%s\"): %s", CMD_ARGV[i], strerror(err)); + command_print(CMD, "open(\"%s\"): %s", CMD_ARGV[i], strerror(err)); /* no need to free anything now */ return ERROR_COMMAND_SYNTAX_ERROR; } else @@ -534,7 +534,7 @@ COMMAND_HANDLER(handle_svf_command) time_measure_m = time_measure_s / 60; time_measure_s %= 60; if (time_measure_ms < 1000) - command_print(CMD_CTX, + command_print(CMD, "\r\nTime used: %dm%ds%" PRId64 "ms ", time_measure_m, time_measure_s, @@ -579,13 +579,13 @@ free_all: svf_free_xxd_para(&svf_para.sir_para); if (ERROR_OK == ret) - command_print(CMD_CTX, + command_print(CMD, "svf file programmed %s for %d commands with %d errors", (svf_ignore_error > 1) ? "unsuccessfully" : "successfully", command_num, (svf_ignore_error > 1) ? (svf_ignore_error - 1) : 0); else - command_print(CMD_CTX, "svf file programmed failed"); + command_print(CMD, "svf file programmed failed"); svf_ignore_error = 0; return ret; diff --git a/src/target/aarch64.c b/src/target/aarch64.c index ff68e3a..7acb472 100644 --- a/src/target/aarch64.c +++ b/src/target/aarch64.c @@ -29,6 +29,7 @@ #include "armv8_opcodes.h" #include "armv8_cache.h" #include "arm_semihosting.h" +#include "jtag/interface.h" #include "smp.h" #include <helper/time_support.h> @@ -1662,7 +1663,7 @@ static int aarch64_assert_reset(struct target *target) /* REVISIT handle "pulls" cases, if there's * hardware that needs them to work. */ - jtag_add_reset(0, 1); + adapter_assert_reset(); } else { LOG_ERROR("%s: how to reset?", target_name(target)); return ERROR_FAIL; @@ -1686,7 +1687,7 @@ static int aarch64_deassert_reset(struct target *target) LOG_DEBUG(" "); /* be certain SRST is off */ - jtag_add_reset(0, 0); + adapter_deassert_reset(); if (!target_was_examined(target)) return ERROR_OK; @@ -2533,7 +2534,7 @@ COMMAND_HANDLER(aarch64_handle_cache_info_command) struct target *target = get_current_target(CMD_CTX); struct armv8_common *armv8 = target_to_armv8(target); - return armv8_handle_cache_info_command(CMD_CTX, + return armv8_handle_cache_info_command(CMD, &armv8->armv8_mmu.armv8_cache); } @@ -2572,7 +2573,7 @@ COMMAND_HANDLER(aarch64_mask_interrupts_command) } n = Jim_Nvp_value2name_simple(nvp_maskisr_modes, aarch64->isrmasking_mode); - command_print(CMD_CTX, "aarch64 interrupt mask %s", n->name); + command_print(CMD, "aarch64 interrupt mask %s", n->name); return ERROR_OK; } diff --git a/src/target/adi_v5_swd.c b/src/target/adi_v5_swd.c index d92e296..594b508 100644 --- a/src/target/adi_v5_swd.c +++ b/src/target/adi_v5_swd.c @@ -352,6 +352,7 @@ static const struct command_registration swd_handlers[] = { .mode = COMMAND_ANY, .help = "SWD command group", .chain = swd_commands, + .usage = "", }, COMMAND_REGISTRATION_DONE }; diff --git a/src/target/arm720t.c b/src/target/arm720t.c index b592ffc..abe5f1c 100644 --- a/src/target/arm720t.c +++ b/src/target/arm720t.c @@ -233,11 +233,11 @@ static void arm720t_pre_restore_context(struct target *target) arm720t_write_cp15(target, 0xee060f10, arm720t->far_reg); } -static int arm720t_verify_pointer(struct command_context *cmd_ctx, +static int arm720t_verify_pointer(struct command_invocation *cmd, struct arm720t_common *arm720t) { if (arm720t->common_magic != ARM720T_COMMON_MAGIC) { - command_print(cmd_ctx, "target is not an ARM720"); + command_print(cmd, "target is not an ARM720"); return ERROR_TARGET_INVALID; } return ERROR_OK; @@ -442,12 +442,12 @@ COMMAND_HANDLER(arm720t_handle_cp15_command) struct target *target = get_current_target(CMD_CTX); struct arm720t_common *arm720t = target_to_arm720(target); - retval = arm720t_verify_pointer(CMD_CTX, arm720t); + retval = arm720t_verify_pointer(CMD, arm720t); if (retval != ERROR_OK) return retval; if (target->state != TARGET_HALTED) { - command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME); + command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME); return ERROR_OK; } @@ -460,7 +460,7 @@ COMMAND_HANDLER(arm720t_handle_cp15_command) uint32_t value; retval = arm720t_read_cp15(target, opcode, &value); if (retval != ERROR_OK) { - command_print(CMD_CTX, "couldn't access cp15 with opcode 0x%8.8" PRIx32 "", opcode); + command_print(CMD, "couldn't access cp15 with opcode 0x%8.8" PRIx32 "", opcode); return ERROR_OK; } @@ -468,17 +468,17 @@ COMMAND_HANDLER(arm720t_handle_cp15_command) if (retval != ERROR_OK) return retval; - command_print(CMD_CTX, "0x%8.8" PRIx32 ": 0x%8.8" PRIx32 "", opcode, value); + command_print(CMD, "0x%8.8" PRIx32 ": 0x%8.8" PRIx32 "", opcode, value); } else if (CMD_ARGC == 2) { uint32_t value; COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value); retval = arm720t_write_cp15(target, opcode, value); if (retval != ERROR_OK) { - command_print(CMD_CTX, "couldn't access cp15 with opcode 0x%8.8" PRIx32 "", opcode); + command_print(CMD, "couldn't access cp15 with opcode 0x%8.8" PRIx32 "", opcode); return ERROR_OK; } - command_print(CMD_CTX, "0x%8.8" PRIx32 ": 0x%8.8" PRIx32 "", opcode, value); + command_print(CMD, "0x%8.8" PRIx32 ": 0x%8.8" PRIx32 "", opcode, value); } } diff --git a/src/target/arm7_9_common.c b/src/target/arm7_9_common.c index c6a8a26..b2962d1 100644 --- a/src/target/arm7_9_common.c +++ b/src/target/arm7_9_common.c @@ -2747,14 +2747,14 @@ COMMAND_HANDLER(handle_arm7_9_dbgrq_command) struct arm7_9_common *arm7_9 = target_to_arm7_9(target); if (!is_arm7_9(arm7_9)) { - command_print(CMD_CTX, "current target isn't an ARM7/ARM9 target"); + command_print(CMD, "current target isn't an ARM7/ARM9 target"); return ERROR_TARGET_INVALID; } if (CMD_ARGC > 0) COMMAND_PARSE_ENABLE(CMD_ARGV[0], arm7_9->use_dbgrq); - command_print(CMD_CTX, + command_print(CMD, "use of EmbeddedICE dbgrq instead of breakpoint for target halt %s", (arm7_9->use_dbgrq) ? "enabled" : "disabled"); @@ -2767,14 +2767,14 @@ COMMAND_HANDLER(handle_arm7_9_fast_memory_access_command) struct arm7_9_common *arm7_9 = target_to_arm7_9(target); if (!is_arm7_9(arm7_9)) { - command_print(CMD_CTX, "current target isn't an ARM7/ARM9 target"); + command_print(CMD, "current target isn't an ARM7/ARM9 target"); return ERROR_TARGET_INVALID; } if (CMD_ARGC > 0) COMMAND_PARSE_ENABLE(CMD_ARGV[0], arm7_9->fast_memory_access); - command_print(CMD_CTX, + command_print(CMD, "fast memory access is %s", (arm7_9->fast_memory_access) ? "enabled" : "disabled"); @@ -2787,14 +2787,14 @@ COMMAND_HANDLER(handle_arm7_9_dcc_downloads_command) struct arm7_9_common *arm7_9 = target_to_arm7_9(target); if (!is_arm7_9(arm7_9)) { - command_print(CMD_CTX, "current target isn't an ARM7/ARM9 target"); + command_print(CMD, "current target isn't an ARM7/ARM9 target"); return ERROR_TARGET_INVALID; } if (CMD_ARGC > 0) COMMAND_PARSE_ENABLE(CMD_ARGV[0], arm7_9->dcc_downloads); - command_print(CMD_CTX, + command_print(CMD, "dcc downloads are %s", (arm7_9->dcc_downloads) ? "enabled" : "disabled"); @@ -2864,7 +2864,7 @@ int arm7_9_init_arch_info(struct target *target, struct arm7_9_common *arm7_9) static const struct command_registration arm7_9_any_command_handlers[] = { { - "dbgrq", + .name = "dbgrq", .handler = handle_arm7_9_dbgrq_command, .mode = COMMAND_ANY, .usage = "['enable'|'disable']", @@ -2872,7 +2872,7 @@ static const struct command_registration arm7_9_any_command_handlers[] = { "for target halt requests", }, { - "fast_memory_access", + .name = "fast_memory_access", .handler = handle_arm7_9_fast_memory_access_command, .mode = COMMAND_ANY, .usage = "['enable'|'disable']", @@ -2880,7 +2880,7 @@ static const struct command_registration arm7_9_any_command_handlers[] = { "but potentially safer accesses", }, { - "dcc_downloads", + .name = "dcc_downloads", .handler = handle_arm7_9_dcc_downloads_command, .mode = COMMAND_ANY, .usage = "['enable'|'disable']", diff --git a/src/target/arm920t.c b/src/target/arm920t.c index ed9d388..2ecf218 100644 --- a/src/target/arm920t.c +++ b/src/target/arm920t.c @@ -507,11 +507,11 @@ void arm920t_pre_restore_context(struct target *target) static const char arm920_not[] = "target is not an ARM920"; -static int arm920t_verify_pointer(struct command_context *cmd_ctx, +static int arm920t_verify_pointer(struct command_invocation *cmd, struct arm920t_common *arm920t) { if (arm920t->common_magic != ARM920T_COMMON_MAGIC) { - command_print(cmd_ctx, arm920_not); + command_print(cmd, arm920_not); return ERROR_TARGET_INVALID; } @@ -869,7 +869,7 @@ COMMAND_HANDLER(arm920t_handle_read_cache_command) int segment, index_t; struct reg *r; - retval = arm920t_verify_pointer(CMD_CTX, arm920t); + retval = arm920t_verify_pointer(CMD, arm920t); if (retval != ERROR_OK) return retval; @@ -1103,7 +1103,7 @@ COMMAND_HANDLER(arm920t_handle_read_cache_command) /* restore CP15 MMU and Cache settings */ arm920t_write_cp15_physical(target, CP15PHYS_CTRL, cp15_ctrl_saved); - command_print(CMD_CTX, "cache content successfully output to %s", + command_print(CMD, "cache content successfully output to %s", CMD_ARGV[0]); fclose(output); @@ -1151,7 +1151,7 @@ COMMAND_HANDLER(arm920t_handle_read_mmu_command) int victim; struct reg *r; - retval = arm920t_verify_pointer(CMD_CTX, arm920t); + retval = arm920t_verify_pointer(CMD, arm920t); if (retval != ERROR_OK) return retval; @@ -1415,7 +1415,7 @@ COMMAND_HANDLER(arm920t_handle_read_mmu_command) (i_tlb[i].cam & 0x20) ? "(valid)" : "(invalid)"); } - command_print(CMD_CTX, "mmu content successfully output to %s", + command_print(CMD, "mmu content successfully output to %s", CMD_ARGV[0]); fclose(output); @@ -1451,12 +1451,12 @@ COMMAND_HANDLER(arm920t_handle_cp15_command) struct target *target = get_current_target(CMD_CTX); struct arm920t_common *arm920t = target_to_arm920(target); - retval = arm920t_verify_pointer(CMD_CTX, arm920t); + retval = arm920t_verify_pointer(CMD, arm920t); if (retval != ERROR_OK) return retval; if (target->state != TARGET_HALTED) { - command_print(CMD_CTX, "target must be stopped for " + command_print(CMD, "target must be stopped for " "\"%s\" command", CMD_NAME); return ERROR_OK; } @@ -1472,7 +1472,7 @@ COMMAND_HANDLER(arm920t_handle_cp15_command) uint32_t value; retval = arm920t_read_cp15_physical(target, address, &value); if (retval != ERROR_OK) { - command_print(CMD_CTX, + command_print(CMD, "couldn't access reg %i", address); return ERROR_OK; } @@ -1480,7 +1480,7 @@ COMMAND_HANDLER(arm920t_handle_cp15_command) if (retval != ERROR_OK) return retval; - command_print(CMD_CTX, "%i: %8.8" PRIx32, + command_print(CMD, "%i: %8.8" PRIx32, address, value); } else if (CMD_ARGC == 2) { uint32_t value; @@ -1488,12 +1488,12 @@ COMMAND_HANDLER(arm920t_handle_cp15_command) retval = arm920t_write_cp15_physical(target, address, value); if (retval != ERROR_OK) { - command_print(CMD_CTX, + command_print(CMD, "couldn't access reg %i", address); /* REVISIT why lie? "return retval"? */ return ERROR_OK; } - command_print(CMD_CTX, "%i: %8.8" PRIx32, + command_print(CMD, "%i: %8.8" PRIx32, address, value); } } @@ -1507,13 +1507,13 @@ COMMAND_HANDLER(arm920t_handle_cp15i_command) struct target *target = get_current_target(CMD_CTX); struct arm920t_common *arm920t = target_to_arm920(target); - retval = arm920t_verify_pointer(CMD_CTX, arm920t); + retval = arm920t_verify_pointer(CMD, arm920t); if (retval != ERROR_OK) return retval; if (target->state != TARGET_HALTED) { - command_print(CMD_CTX, "target must be stopped for " + command_print(CMD, "target must be stopped for " "\"%s\" command", CMD_NAME); return ERROR_OK; } @@ -1530,14 +1530,14 @@ COMMAND_HANDLER(arm920t_handle_cp15i_command) retval = arm920t_read_cp15_interpreted(target, opcode, 0x0, &value); if (retval != ERROR_OK) { - command_print(CMD_CTX, + command_print(CMD, "couldn't execute %8.8" PRIx32, opcode); /* REVISIT why lie? "return retval"? */ return ERROR_OK; } - command_print(CMD_CTX, "%8.8" PRIx32 ": %8.8" PRIx32, + command_print(CMD, "%8.8" PRIx32 ": %8.8" PRIx32, opcode, value); } else if (CMD_ARGC == 2) { uint32_t value; @@ -1545,13 +1545,13 @@ COMMAND_HANDLER(arm920t_handle_cp15i_command) retval = arm920t_write_cp15_interpreted(target, opcode, value, 0); if (retval != ERROR_OK) { - command_print(CMD_CTX, + command_print(CMD, "couldn't execute %8.8" PRIx32, opcode); /* REVISIT why lie? "return retval"? */ return ERROR_OK; } - command_print(CMD_CTX, "%8.8" PRIx32 ": %8.8" PRIx32, + command_print(CMD, "%8.8" PRIx32 ": %8.8" PRIx32, opcode, value); } else if (CMD_ARGC == 3) { uint32_t value; @@ -1561,12 +1561,12 @@ COMMAND_HANDLER(arm920t_handle_cp15i_command) retval = arm920t_write_cp15_interpreted(target, opcode, value, address); if (retval != ERROR_OK) { - command_print(CMD_CTX, + command_print(CMD, "couldn't execute %8.8" PRIx32, opcode); /* REVISIT why lie? "return retval"? */ return ERROR_OK; } - command_print(CMD_CTX, "%8.8" PRIx32 ": %8.8" PRIx32 + command_print(CMD, "%8.8" PRIx32 ": %8.8" PRIx32 " %8.8" PRIx32, opcode, value, address); } } else @@ -1581,11 +1581,11 @@ COMMAND_HANDLER(arm920t_handle_cache_info_command) struct target *target = get_current_target(CMD_CTX); struct arm920t_common *arm920t = target_to_arm920(target); - retval = arm920t_verify_pointer(CMD_CTX, arm920t); + retval = arm920t_verify_pointer(CMD, arm920t); if (retval != ERROR_OK) return retval; - return armv4_5_handle_cache_info_command(CMD_CTX, + return armv4_5_handle_cache_info_command(CMD, &arm920t->armv4_5_mmu.armv4_5_cache); } diff --git a/src/target/arm926ejs.c b/src/target/arm926ejs.c index 3f22a8a..ac30485 100644 --- a/src/target/arm926ejs.c +++ b/src/target/arm926ejs.c @@ -501,11 +501,11 @@ static void arm926ejs_pre_restore_context(struct target *target) static const char arm926_not[] = "target is not an ARM926"; -static int arm926ejs_verify_pointer(struct command_context *cmd_ctx, +static int arm926ejs_verify_pointer(struct command_invocation *cmd, struct arm926ejs_common *arm926) { if (arm926->common_magic != ARM926EJS_COMMON_MAGIC) { - command_print(cmd_ctx, arm926_not); + command_print(cmd, arm926_not); return ERROR_TARGET_INVALID; } return ERROR_OK; @@ -729,11 +729,11 @@ COMMAND_HANDLER(arm926ejs_handle_cache_info_command) struct target *target = get_current_target(CMD_CTX); struct arm926ejs_common *arm926ejs = target_to_arm926(target); - retval = arm926ejs_verify_pointer(CMD_CTX, arm926ejs); + retval = arm926ejs_verify_pointer(CMD, arm926ejs); if (retval != ERROR_OK) return retval; - return armv4_5_handle_cache_info_command(CMD_CTX, &arm926ejs->armv4_5_mmu.armv4_5_cache); + return armv4_5_handle_cache_info_command(CMD, &arm926ejs->armv4_5_mmu.armv4_5_cache); } static int arm926ejs_virt2phys(struct target *target, target_addr_t virtual, target_addr_t *physical) diff --git a/src/target/arm946e.c b/src/target/arm946e.c index 5e25d71..112631a 100644 --- a/src/target/arm946e.c +++ b/src/target/arm946e.c @@ -99,11 +99,11 @@ static int arm946e_target_create(struct target *target, Jim_Interp *interp) return ERROR_OK; } -static int arm946e_verify_pointer(struct command_context *cmd_ctx, +static int arm946e_verify_pointer(struct command_invocation *cmd, struct arm946e_common *arm946e) { if (arm946e->common_magic != ARM946E_COMMON_MAGIC) { - command_print(cmd_ctx, "target is not an ARM946"); + command_print(cmd, "target is not an ARM946"); return ERROR_TARGET_INVALID; } return ERROR_OK; @@ -549,70 +549,54 @@ int arm946e_read_memory(struct target *target, target_addr_t address, return ERROR_OK; } -static int jim_arm946e_cp15(Jim_Interp *interp, int argc, Jim_Obj * const *argv) +COMMAND_HANDLER(arm946e_handle_cp15) { /* one or two arguments, access a single register (write if second argument is given) */ - if (argc < 2 || argc > 3) { - Jim_WrongNumArgs(interp, 1, argv, "addr [value]"); - return JIM_ERR; - } - - struct command_context *cmd_ctx = current_command_context(interp); - assert(cmd_ctx != NULL); + if (CMD_ARGC < 1 || CMD_ARGC > 2) + return ERROR_COMMAND_SYNTAX_ERROR; - struct target *target = get_current_target(cmd_ctx); - if (target == NULL) { - LOG_ERROR("arm946e: no current target"); - return JIM_ERR; - } + struct target *target = get_current_target(CMD_CTX); struct arm946e_common *arm946e = target_to_arm946(target); - int retval = arm946e_verify_pointer(cmd_ctx, arm946e); + int retval = arm946e_verify_pointer(CMD, arm946e); if (retval != ERROR_OK) - return JIM_ERR; + return retval; if (target->state != TARGET_HALTED) { - command_print(cmd_ctx, "target %s must be stopped for \"cp15\" command", target_name(target)); - return JIM_ERR; + command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME); + return ERROR_TARGET_NOT_HALTED; } - long l; uint32_t address; - retval = Jim_GetLong(interp, argv[1], &l); - address = l; - if (JIM_OK != retval) - return retval; + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address); - if (argc == 2) { + if (CMD_ARGC == 1) { uint32_t value; retval = arm946e_read_cp15(target, address, &value); if (retval != ERROR_OK) { - command_print(cmd_ctx, "%s cp15 reg %" PRIi32 " access failed", target_name(target), address); - return JIM_ERR; + command_print(CMD, "%s cp15 reg %" PRIi32 " access failed", target_name(target), address); + return retval; } retval = jtag_execute_queue(); if (retval != ERROR_OK) - return JIM_ERR; - char buf[20]; - sprintf(buf, "0x%08" PRIx32, value); + return retval; + /* Return value in hex format */ - Jim_SetResultString(interp, buf, -1); - } else if (argc == 3) { + command_print(CMD, "0x%08" PRIx32, value); + } else if (CMD_ARGC == 2) { uint32_t value; - retval = Jim_GetLong(interp, argv[2], &l); - value = l; - if (JIM_OK != retval) - return retval; + COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value); + retval = arm946e_write_cp15(target, address, value); if (retval != ERROR_OK) { - command_print(cmd_ctx, "%s cp15 reg %" PRIi32 " access failed", target_name(target), address); - return JIM_ERR; + command_print(CMD, "%s cp15 reg %" PRIi32 " access failed", target_name(target), address); + return retval; } if (address == CP15_CTL) arm946e_update_cp15_caches(target, value); } - return JIM_OK; + return ERROR_OK; } COMMAND_HANDLER(arm946e_handle_idcache) @@ -624,12 +608,12 @@ COMMAND_HANDLER(arm946e_handle_idcache) struct target *target = get_current_target(CMD_CTX); struct arm946e_common *arm946e = target_to_arm946(target); - retval = arm946e_verify_pointer(CMD_CTX, arm946e); + retval = arm946e_verify_pointer(CMD, arm946e); if (retval != ERROR_OK) return retval; if (target->state != TARGET_HALTED) { - command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME); + command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME); return ERROR_TARGET_NOT_HALTED; } @@ -639,9 +623,9 @@ COMMAND_HANDLER(arm946e_handle_idcache) bool bena = ((arm946e->cp15_control_reg & (icache ? CP15_CTL_ICACHE : CP15_CTL_DCACHE)) != 0) && (arm946e->cp15_control_reg & 0x1); if (csize == 0) - command_print(CMD_CTX, "%s-cache absent", icache ? "I" : "D"); + command_print(CMD, "%s-cache absent", icache ? "I" : "D"); else - command_print(CMD_CTX, "%s-cache size: %" PRIu32 "K, %s", + command_print(CMD, "%s-cache size: %" PRIu32 "K, %s", icache ? "I" : "D", csize, bena ? "enabled" : "disabled"); return ERROR_OK; } @@ -659,7 +643,7 @@ COMMAND_HANDLER(arm946e_handle_idcache) /* Do not invalidate or change state, if cache is absent */ if (csize == 0) { - command_print(CMD_CTX, "%s-cache absent, '%s' operation undefined", icache ? "I" : "D", CMD_ARGV[0]); + command_print(CMD, "%s-cache absent, '%s' operation undefined", icache ? "I" : "D", CMD_ARGV[0]); return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; } @@ -703,7 +687,7 @@ COMMAND_HANDLER(arm946e_handle_idcache) static const struct command_registration arm946e_exec_command_handlers[] = { { .name = "cp15", - .jim_handler = jim_arm946e_cp15, + .handler = arm946e_handle_cp15, .mode = COMMAND_EXEC, .usage = "regnum [value]", .help = "read/modify cp15 register", diff --git a/src/target/arm966e.c b/src/target/arm966e.c index c9d7f01..8462f54 100644 --- a/src/target/arm966e.c +++ b/src/target/arm966e.c @@ -56,11 +56,11 @@ static int arm966e_target_create(struct target *target, Jim_Interp *interp) return arm966e_init_arch_info(target, arm966e, target->tap); } -static int arm966e_verify_pointer(struct command_context *cmd_ctx, +static int arm966e_verify_pointer(struct command_invocation *cmd, struct arm966e_common *arm966e) { if (arm966e->common_magic != ARM966E_COMMON_MAGIC) { - command_print(cmd_ctx, "target is not an ARM966"); + command_print(cmd, "target is not an ARM966"); return ERROR_TARGET_INVALID; } return ERROR_OK; @@ -170,12 +170,12 @@ COMMAND_HANDLER(arm966e_handle_cp15_command) struct target *target = get_current_target(CMD_CTX); struct arm966e_common *arm966e = target_to_arm966(target); - retval = arm966e_verify_pointer(CMD_CTX, arm966e); + retval = arm966e_verify_pointer(CMD, arm966e); if (retval != ERROR_OK) return retval; if (target->state != TARGET_HALTED) { - command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME); + command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME); return ERROR_OK; } @@ -188,7 +188,7 @@ COMMAND_HANDLER(arm966e_handle_cp15_command) uint32_t value; retval = arm966e_read_cp15(target, address, &value); if (retval != ERROR_OK) { - command_print(CMD_CTX, + command_print(CMD, "couldn't access reg %" PRIi32, address); return ERROR_OK; @@ -197,19 +197,19 @@ COMMAND_HANDLER(arm966e_handle_cp15_command) if (retval != ERROR_OK) return retval; - command_print(CMD_CTX, "%" PRIi32 ": %8.8" PRIx32, + command_print(CMD, "%" PRIi32 ": %8.8" PRIx32, address, value); } else if (CMD_ARGC == 2) { uint32_t value; COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], value); retval = arm966e_write_cp15(target, address, value); if (retval != ERROR_OK) { - command_print(CMD_CTX, + command_print(CMD, "couldn't access reg %" PRIi32, address); return ERROR_OK; } - command_print(CMD_CTX, "%" PRIi32 ": %8.8" PRIx32, + command_print(CMD, "%" PRIi32 ": %8.8" PRIx32, address, value); } } diff --git a/src/target/arm9tdmi.c b/src/target/arm9tdmi.c index 6425027..6ab06ed 100644 --- a/src/target/arm9tdmi.c +++ b/src/target/arm9tdmi.c @@ -801,7 +801,7 @@ COMMAND_HANDLER(handle_arm9tdmi_catch_vectors_command) /* it's uncommon, but some ARM7 chips can support this */ if (arm7_9->common_magic != ARM7_9_COMMON_MAGIC || !arm7_9->has_vector_catch) { - command_print(CMD_CTX, "target doesn't have EmbeddedICE " + command_print(CMD, "target doesn't have EmbeddedICE " "with vector_catch"); return ERROR_TARGET_INVALID; } @@ -834,7 +834,7 @@ COMMAND_HANDLER(handle_arm9tdmi_catch_vectors_command) /* complain if vector wasn't found */ if (!arm9tdmi_vectors[j].name) { - command_print(CMD_CTX, "vector '%s' not found, leaving current setting unchanged", CMD_ARGV[i]); + command_print(CMD, "vector '%s' not found, leaving current setting unchanged", CMD_ARGV[i]); /* reread current setting */ vector_catch_value = buf_get_u32( @@ -852,7 +852,7 @@ COMMAND_HANDLER(handle_arm9tdmi_catch_vectors_command) /* output current settings */ for (unsigned i = 0; arm9tdmi_vectors[i].name; i++) { - command_print(CMD_CTX, "%s: %s", arm9tdmi_vectors[i].name, + command_print(CMD, "%s: %s", arm9tdmi_vectors[i].name, (vector_catch_value & arm9tdmi_vectors[i].value) ? "catch" : "don't catch"); } diff --git a/src/target/arm_adi_v5.c b/src/target/arm_adi_v5.c index 021d02a..d2ec960 100644 --- a/src/target/arm_adi_v5.c +++ b/src/target/arm_adi_v5.c @@ -914,7 +914,8 @@ int dap_find_ap(struct adiv5_dap *dap, enum ap_type type_to_find, struct adiv5_a ((id_val & IDR_TYPE) == type_to_find)) { /* type matches*/ LOG_DEBUG("Found %s at AP index: %d (IDR=0x%08" PRIX32 ")", - (type_to_find == AP_TYPE_AHB_AP) ? "AHB-AP" : + (type_to_find == AP_TYPE_AHB3_AP) ? "AHB3-AP" : + (type_to_find == AP_TYPE_AHB5_AP) ? "AHB5-AP" : (type_to_find == AP_TYPE_APB_AP) ? "APB-AP" : (type_to_find == AP_TYPE_AXI_AP) ? "AXI-AP" : (type_to_find == AP_TYPE_JTAG_AP) ? "JTAG-AP" : "Unknown", @@ -926,7 +927,8 @@ int dap_find_ap(struct adiv5_dap *dap, enum ap_type type_to_find, struct adiv5_a } LOG_DEBUG("No %s found", - (type_to_find == AP_TYPE_AHB_AP) ? "AHB-AP" : + (type_to_find == AP_TYPE_AHB3_AP) ? "AHB3-AP" : + (type_to_find == AP_TYPE_AHB5_AP) ? "AHB5-AP" : (type_to_find == AP_TYPE_APB_AP) ? "APB-AP" : (type_to_find == AP_TYPE_AXI_AP) ? "AXI-AP" : (type_to_find == AP_TYPE_JTAG_AP) ? "JTAG-AP" : "Unknown"); @@ -1190,7 +1192,7 @@ static const struct { { ANY_ID, 0x343, "TI DAPCTL", "", }, /* from OMAP3 memmap */ }; -static int dap_rom_display(struct command_context *cmd_ctx, +static int dap_rom_display(struct command_invocation *cmd, struct adiv5_ap *ap, uint32_t dbgbase, int depth) { int retval; @@ -1199,7 +1201,7 @@ static int dap_rom_display(struct command_context *cmd_ctx, char tabs[16] = ""; if (depth > 16) { - command_print(cmd_ctx, "\tTables too deep"); + command_print(cmd, "\tTables too deep"); return ERROR_FAIL; } @@ -1207,25 +1209,25 @@ static int dap_rom_display(struct command_context *cmd_ctx, snprintf(tabs, sizeof(tabs), "[L%02d] ", depth); uint32_t base_addr = dbgbase & 0xFFFFF000; - command_print(cmd_ctx, "\t\tComponent base address 0x%08" PRIx32, base_addr); + command_print(cmd, "\t\tComponent base address 0x%08" PRIx32, base_addr); retval = dap_read_part_id(ap, base_addr, &cid, &pid); if (retval != ERROR_OK) { - command_print(cmd_ctx, "\t\tCan't read component, the corresponding core might be turned off"); + command_print(cmd, "\t\tCan't read component, the corresponding core might be turned off"); return ERROR_OK; /* Don't abort recursion */ } if (!is_dap_cid_ok(cid)) { - command_print(cmd_ctx, "\t\tInvalid CID 0x%08" PRIx32, cid); + command_print(cmd, "\t\tInvalid CID 0x%08" PRIx32, cid); return ERROR_OK; /* Don't abort recursion */ } /* component may take multiple 4K pages */ uint32_t size = (pid >> 36) & 0xf; if (size > 0) - command_print(cmd_ctx, "\t\tStart address 0x%08" PRIx32, (uint32_t)(base_addr - 0x1000 * size)); + command_print(cmd, "\t\tStart address 0x%08" PRIx32, (uint32_t)(base_addr - 0x1000 * size)); - command_print(cmd_ctx, "\t\tPeripheral ID 0x%010" PRIx64, pid); + command_print(cmd, "\t\tPeripheral ID 0x%010" PRIx64, pid); uint8_t class = (cid >> 12) & 0xf; uint16_t part_num = pid & 0xfff; @@ -1233,12 +1235,12 @@ static int dap_rom_display(struct command_context *cmd_ctx, if (designer_id & 0x80) { /* JEP106 code */ - command_print(cmd_ctx, "\t\tDesigner is 0x%03" PRIx16 ", %s", + command_print(cmd, "\t\tDesigner is 0x%03" PRIx16 ", %s", designer_id, jep106_manufacturer(designer_id >> 8, designer_id & 0x7f)); } else { /* Legacy ASCII ID, clear invalid bits */ designer_id &= 0x7f; - command_print(cmd_ctx, "\t\tDesigner ASCII code 0x%02" PRIx16 ", %s", + command_print(cmd, "\t\tDesigner ASCII code 0x%02" PRIx16 ", %s", designer_id, designer_id == 0x41 ? "ARM" : "<unknown>"); } @@ -1260,8 +1262,8 @@ static int dap_rom_display(struct command_context *cmd_ctx, break; } - command_print(cmd_ctx, "\t\tPart is 0x%" PRIx16", %s %s", part_num, type, full); - command_print(cmd_ctx, "\t\tComponent class is 0x%" PRIx8 ", %s", class, class_description[class]); + command_print(cmd, "\t\tPart is 0x%" PRIx16", %s %s", part_num, type, full); + command_print(cmd, "\t\tComponent class is 0x%" PRIx8 ", %s", class, class_description[class]); if (class == 1) { /* ROM Table */ uint32_t memtype; @@ -1270,9 +1272,9 @@ static int dap_rom_display(struct command_context *cmd_ctx, return retval; if (memtype & 0x01) - command_print(cmd_ctx, "\t\tMEMTYPE system memory present on bus"); + command_print(cmd, "\t\tMEMTYPE system memory present on bus"); else - command_print(cmd_ctx, "\t\tMEMTYPE system memory not present: dedicated debug bus"); + command_print(cmd, "\t\tMEMTYPE system memory not present: dedicated debug bus"); /* Read ROM table entries from base address until we get 0x00000000 or reach the reserved area */ for (uint16_t entry_offset = 0; entry_offset < 0xF00; entry_offset += 4) { @@ -1280,17 +1282,17 @@ static int dap_rom_display(struct command_context *cmd_ctx, retval = mem_ap_read_atomic_u32(ap, base_addr | entry_offset, &romentry); if (retval != ERROR_OK) return retval; - command_print(cmd_ctx, "\t%sROMTABLE[0x%x] = 0x%" PRIx32 "", + command_print(cmd, "\t%sROMTABLE[0x%x] = 0x%" PRIx32 "", tabs, entry_offset, romentry); if (romentry & 0x01) { /* Recurse */ - retval = dap_rom_display(cmd_ctx, ap, base_addr + (romentry & 0xFFFFF000), depth + 1); + retval = dap_rom_display(cmd, ap, base_addr + (romentry & 0xFFFFF000), depth + 1); if (retval != ERROR_OK) return retval; } else if (romentry != 0) { - command_print(cmd_ctx, "\t\tComponent not present"); + command_print(cmd, "\t\tComponent not present"); } else { - command_print(cmd_ctx, "\t%s\tEnd of ROM table", tabs); + command_print(cmd, "\t%s\tEnd of ROM table", tabs); break; } } @@ -1412,7 +1414,7 @@ static int dap_rom_display(struct command_context *cmd_ctx, } break; case 6: - major = "Perfomance Monitor"; + major = "Performance Monitor"; switch (minor) { case 0: subtype = "other"; @@ -1435,7 +1437,7 @@ static int dap_rom_display(struct command_context *cmd_ctx, } break; } - command_print(cmd_ctx, "\t\tType is 0x%02" PRIx8 ", %s, %s", + command_print(cmd, "\t\tType is 0x%02" PRIx8 ", %s, %s", (uint8_t)(devtype & 0xff), major, subtype); /* REVISIT also show 0xfc8 DevId */ @@ -1444,7 +1446,7 @@ static int dap_rom_display(struct command_context *cmd_ctx, return ERROR_OK; } -int dap_info_command(struct command_context *cmd_ctx, +int dap_info_command(struct command_invocation *cmd, struct adiv5_ap *ap) { int retval; @@ -1456,27 +1458,30 @@ int dap_info_command(struct command_context *cmd_ctx, if (retval != ERROR_OK) return retval; - command_print(cmd_ctx, "AP ID register 0x%8.8" PRIx32, apid); + command_print(cmd, "AP ID register 0x%8.8" PRIx32, apid); if (apid == 0) { - command_print(cmd_ctx, "No AP found at this ap 0x%x", ap->ap_num); + command_print(cmd, "No AP found at this ap 0x%x", ap->ap_num); return ERROR_FAIL; } switch (apid & (IDR_JEP106 | IDR_TYPE)) { case IDR_JEP106_ARM | AP_TYPE_JTAG_AP: - command_print(cmd_ctx, "\tType is JTAG-AP"); + command_print(cmd, "\tType is JTAG-AP"); break; - case IDR_JEP106_ARM | AP_TYPE_AHB_AP: - command_print(cmd_ctx, "\tType is MEM-AP AHB"); + case IDR_JEP106_ARM | AP_TYPE_AHB3_AP: + command_print(cmd, "\tType is MEM-AP AHB3"); + break; + case IDR_JEP106_ARM | AP_TYPE_AHB5_AP: + command_print(cmd, "\tType is MEM-AP AHB5"); break; case IDR_JEP106_ARM | AP_TYPE_APB_AP: - command_print(cmd_ctx, "\tType is MEM-AP APB"); + command_print(cmd, "\tType is MEM-AP APB"); break; case IDR_JEP106_ARM | AP_TYPE_AXI_AP: - command_print(cmd_ctx, "\tType is MEM-AP AXI"); + command_print(cmd, "\tType is MEM-AP AXI"); break; default: - command_print(cmd_ctx, "\tUnknown AP type"); + command_print(cmd, "\tUnknown AP type"); break; } @@ -1485,17 +1490,17 @@ int dap_info_command(struct command_context *cmd_ctx, */ mem_ap = (apid & IDR_CLASS) == AP_CLASS_MEM_AP; if (mem_ap) { - command_print(cmd_ctx, "MEM-AP BASE 0x%8.8" PRIx32, dbgbase); + command_print(cmd, "MEM-AP BASE 0x%8.8" PRIx32, dbgbase); if (dbgbase == 0xFFFFFFFF || (dbgbase & 0x3) == 0x2) { - command_print(cmd_ctx, "\tNo ROM table present"); + command_print(cmd, "\tNo ROM table present"); } else { if (dbgbase & 0x01) - command_print(cmd_ctx, "\tValid ROM table present"); + command_print(cmd, "\tValid ROM table present"); else - command_print(cmd_ctx, "\tROM table in legacy format"); + command_print(cmd, "\tROM table in legacy format"); - dap_rom_display(cmd_ctx, ap, dbgbase & 0xFFFFF000, 0); + dap_rom_display(cmd, ap, dbgbase & 0xFFFFF000, 0); } } @@ -1646,7 +1651,7 @@ COMMAND_HANDLER(handle_dap_info_command) return ERROR_COMMAND_SYNTAX_ERROR; } - return dap_info_command(CMD_CTX, &dap->ap[apsel]); + return dap_info_command(CMD, &dap->ap[apsel]); } COMMAND_HANDLER(dap_baseaddr_command) @@ -1681,7 +1686,7 @@ COMMAND_HANDLER(dap_baseaddr_command) if (retval != ERROR_OK) return retval; - command_print(CMD_CTX, "0x%8.8" PRIx32, baseaddr); + command_print(CMD, "0x%8.8" PRIx32, baseaddr); return retval; } @@ -1703,7 +1708,7 @@ COMMAND_HANDLER(dap_memaccess_command) } dap->ap[dap->apsel].memaccess_tck = memaccess_tck; - command_print(CMD_CTX, "memory bus access delay set to %" PRIi32 " tck", + command_print(CMD, "memory bus access delay set to %" PRIi32 " tck", dap->ap[dap->apsel].memaccess_tck); return ERROR_OK; @@ -1716,7 +1721,7 @@ COMMAND_HANDLER(dap_apsel_command) switch (CMD_ARGC) { case 0: - command_print(CMD_CTX, "%" PRIi32, dap->apsel); + command_print(CMD, "%" PRIi32, dap->apsel); return ERROR_OK; case 1: COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel); @@ -1740,12 +1745,12 @@ COMMAND_HANDLER(dap_apcsw_command) switch (CMD_ARGC) { case 0: - command_print(CMD_CTX, "ap %" PRIi32 " selected, csw 0x%8.8" PRIx32, + command_print(CMD, "ap %" PRIi32 " selected, csw 0x%8.8" PRIx32, dap->apsel, apcsw); return ERROR_OK; case 1: if (strcmp(CMD_ARGV[0], "default") == 0) - csw_val = CSW_DEFAULT; + csw_val = CSW_AHB_DEFAULT; else COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], csw_val); @@ -1801,7 +1806,7 @@ COMMAND_HANDLER(dap_apid_command) if (retval != ERROR_OK) return retval; - command_print(CMD_CTX, "0x%8.8" PRIx32, apid); + command_print(CMD, "0x%8.8" PRIx32, apid); return retval; } @@ -1853,7 +1858,7 @@ COMMAND_HANDLER(dap_apreg_command) return retval; if (CMD_ARGC == 2) - command_print(CMD_CTX, "0x%08" PRIx32, value); + command_print(CMD, "0x%08" PRIx32, value); return retval; } @@ -1884,7 +1889,7 @@ COMMAND_HANDLER(dap_dpreg_command) return retval; if (CMD_ARGC == 1) - command_print(CMD_CTX, "0x%08" PRIx32, value); + command_print(CMD, "0x%08" PRIx32, value); return retval; } @@ -1906,7 +1911,7 @@ COMMAND_HANDLER(dap_ti_be_32_quirks_command) return ERROR_COMMAND_SYNTAX_ERROR; } dap->ti_be_32_quirks = enable; - command_print(CMD_CTX, "TI BE-32 quirks mode %s", + command_print(CMD, "TI BE-32 quirks mode %s", enable ? "enabled" : "disabled"); return 0; diff --git a/src/target/arm_adi_v5.h b/src/target/arm_adi_v5.h index 96291a7..6e2d8a1 100644 --- a/src/target/arm_adi_v5.h +++ b/src/target/arm_adi_v5.h @@ -112,15 +112,34 @@ #define CSW_ADDRINC_PACKED (2UL << 4) #define CSW_DEVICE_EN (1UL << 6) #define CSW_TRIN_PROG (1UL << 7) -/* all fields in bits 12 and above are implementation-defined! */ + +/* All fields in bits 12 and above are implementation-defined + * Defaults for AHB/AXI in "Standard Memory Access Port Definitions" from ADI + * Some bits are shared between buses + */ #define CSW_SPIDEN (1UL << 23) -#define CSW_HPROT1 (1UL << 25) /* AHB: Privileged */ -#define CSW_MASTER_DEBUG (1UL << 29) /* AHB: set HMASTER signals to AHB-AP ID */ -#define CSW_SPROT (1UL << 30) #define CSW_DBGSWENABLE (1UL << 31) -/* initial value of csw_default used for MEM-AP transfers */ -#define CSW_DEFAULT (CSW_HPROT1 | CSW_MASTER_DEBUG | CSW_DBGSWENABLE) +/* AHB: Privileged */ +#define CSW_AHB_HPROT1 (1UL << 25) +/* AHB: set HMASTER signals to AHB-AP ID */ +#define CSW_AHB_MASTER_DEBUG (1UL << 29) +/* AHB5: non-secure access via HNONSEC + * AHB3: SBO, UNPREDICTABLE if zero */ +#define CSW_AHB_SPROT (1UL << 30) +/* AHB: initial value of csw_default */ +#define CSW_AHB_DEFAULT (CSW_AHB_HPROT1 | CSW_AHB_MASTER_DEBUG | CSW_DBGSWENABLE) + +/* AXI: Privileged */ +#define CSW_AXI_ARPROT0_PRIV (1UL << 28) +/* AXI: Non-secure */ +#define CSW_AXI_ARPROT1_NONSEC (1UL << 29) +/* AXI: initial value of csw_default */ +#define CSW_AXI_DEFAULT (CSW_AXI_ARPROT0_PRIV | CSW_AXI_ARPROT1_NONSEC | CSW_DBGSWENABLE) + +/* APB: initial value of csw_default */ +#define CSW_APB_DEFAULT (CSW_DBGSWENABLE) + /* Fields of the MEM-AP's IDR register */ #define IDR_REV (0xFUL << 28) @@ -307,9 +326,10 @@ enum ap_class { */ enum ap_type { AP_TYPE_JTAG_AP = 0x0, /* JTAG-AP - JTAG master for controlling other JTAG devices */ - AP_TYPE_AHB_AP = 0x1, /* AHB Memory-AP */ + AP_TYPE_AHB3_AP = 0x1, /* AHB3 Memory-AP */ AP_TYPE_APB_AP = 0x2, /* APB Memory-AP */ AP_TYPE_AXI_AP = 0x4, /* AXI Memory-AP */ + AP_TYPE_AHB5_AP = 0x5, /* AHB5 Memory-AP. */ }; /** @@ -526,7 +546,7 @@ extern const struct command_registration dap_instance_commands[]; struct arm_dap_object; extern struct adiv5_dap *dap_instance_by_jim_obj(Jim_Interp *interp, Jim_Obj *o); extern struct adiv5_dap *adiv5_get_dap(struct arm_dap_object *obj); -extern int dap_info_command(struct command_context *cmd_ctx, +extern int dap_info_command(struct command_invocation *cmd, struct adiv5_ap *ap); extern int dap_register_commands(struct command_context *cmd_ctx); extern const char *adiv5_dap_name(struct adiv5_dap *self); diff --git a/src/target/arm_cti.c b/src/target/arm_cti.c index f333792..3f063b8 100644 --- a/src/target/arm_cti.c +++ b/src/target/arm_cti.c @@ -252,7 +252,7 @@ COMMAND_HANDLER(handle_cti_dump) return JIM_ERR; for (int i = 0; i < (int)ARRAY_SIZE(cti_names); i++) - command_print(CMD_CTX, "%8.8s (0x%04"PRIx32") 0x%08"PRIx32, + command_print(CMD, "%8.8s (0x%04"PRIx32") 0x%08"PRIx32, cti_names[i].label, cti_names[i].offset, *cti_names[i].p_val); return JIM_OK; @@ -336,7 +336,7 @@ COMMAND_HANDLER(handle_cti_read) if (retval != ERROR_OK) return retval; - command_print(CMD_CTX, "0x%08"PRIx32, value); + command_print(CMD, "0x%08"PRIx32, value); return ERROR_OK; } @@ -576,6 +576,7 @@ static const struct command_registration cti_command_handlers[] = { .mode = COMMAND_CONFIG, .help = "CTI commands", .chain = cti_subcommand_handlers, + .usage = "", }, COMMAND_REGISTRATION_DONE }; diff --git a/src/target/arm_dap.c b/src/target/arm_dap.c index 119e511..fbcfe0d 100644 --- a/src/target/arm_dap.c +++ b/src/target/arm_dap.c @@ -56,7 +56,7 @@ static void dap_instance_init(struct adiv5_dap *dap) /* Number of bits for tar autoincrement, impl. dep. at least 10 */ dap->ap[i].tar_autoincr_block = (1<<10); /* default CSW value */ - dap->ap[i].csw_default = CSW_DEFAULT; + dap->ap[i].csw_default = CSW_AHB_DEFAULT; } INIT_LIST_HEAD(&dap->cmd_journal); } @@ -331,7 +331,7 @@ COMMAND_HANDLER(handle_dap_info_command) return ERROR_COMMAND_SYNTAX_ERROR; } - return dap_info_command(CMD_CTX, &dap->ap[apsel]); + return dap_info_command(CMD, &dap->ap[apsel]); } static const struct command_registration dap_subcommand_handlers[] = { @@ -373,6 +373,7 @@ static const struct command_registration dap_commands[] = { .mode = COMMAND_CONFIG, .help = "DAP commands", .chain = dap_subcommand_handlers, + .usage = "", }, COMMAND_REGISTRATION_DONE }; diff --git a/src/target/armv4_5.c b/src/target/armv4_5.c index e16a9ec..53a6b22 100644 --- a/src/target/armv4_5.c +++ b/src/target/armv4_5.c @@ -778,17 +778,17 @@ COMMAND_HANDLER(handle_armv4_5_reg_command) struct reg *regs; if (!is_arm(arm)) { - command_print(CMD_CTX, "current target isn't an ARM"); + command_print(CMD, "current target isn't an ARM"); return ERROR_FAIL; } if (target->state != TARGET_HALTED) { - command_print(CMD_CTX, "error: target must be halted for register accesses"); + command_print(CMD, "error: target must be halted for register accesses"); return ERROR_FAIL; } if (arm->core_type != ARM_MODE_ANY) { - command_print(CMD_CTX, + command_print(CMD, "Microcontroller Profile not supported - use standard reg cmd"); return ERROR_OK; } @@ -799,7 +799,7 @@ COMMAND_HANDLER(handle_armv4_5_reg_command) } if (!arm->full_context) { - command_print(CMD_CTX, "error: target doesn't support %s", + command_print(CMD, "error: target doesn't support %s", CMD_NAME); return ERROR_FAIL; } @@ -828,7 +828,7 @@ COMMAND_HANDLER(handle_armv4_5_reg_command) shadow = "shadow "; break; } - command_print(CMD_CTX, "%s%s mode %sregisters", + command_print(CMD, "%s%s mode %sregisters", sep, name, shadow); /* display N rows of up to 4 registers each */ @@ -855,7 +855,7 @@ COMMAND_HANDLER(handle_armv4_5_reg_command) "%8s: %8.8" PRIx32 " ", reg->name, value); } - command_print(CMD_CTX, "%s", output); + command_print(CMD, "%s", output); } } @@ -868,13 +868,13 @@ COMMAND_HANDLER(handle_armv4_5_core_state_command) struct arm *arm = target_to_arm(target); if (!is_arm(arm)) { - command_print(CMD_CTX, "current target isn't an ARM"); + command_print(CMD, "current target isn't an ARM"); return ERROR_FAIL; } if (arm->core_type == ARM_MODE_THREAD) { /* armv7m not supported */ - command_print(CMD_CTX, "Unsupported Command"); + command_print(CMD, "Unsupported Command"); return ERROR_OK; } @@ -885,7 +885,7 @@ COMMAND_HANDLER(handle_armv4_5_core_state_command) arm->core_state = ARM_STATE_THUMB; } - command_print(CMD_CTX, "core state: %s", arm_state_strings[arm->core_state]); + command_print(CMD, "core state: %s", arm_state_strings[arm->core_state]); return ERROR_OK; } @@ -906,7 +906,7 @@ COMMAND_HANDLER(handle_arm_disassemble_command) int thumb = 0; if (!is_arm(arm)) { - command_print(CMD_CTX, "current target isn't an ARM"); + command_print(CMD, "current target isn't an ARM"); return ERROR_FAIL; } @@ -928,7 +928,7 @@ COMMAND_HANDLER(handle_arm_disassemble_command) COMMAND_PARSE_ADDRESS(CMD_ARGV[0], address); if (address & 0x01) { if (!thumb) { - command_print(CMD_CTX, "Disassemble as Thumb"); + command_print(CMD, "Disassemble as Thumb"); thumb = 1; } address &= ~1; @@ -963,7 +963,7 @@ usage: if (retval != ERROR_OK) break; } - command_print(CMD_CTX, "%s", cur_instruction.text); + command_print(CMD, "%s", cur_instruction.text); address += cur_instruction.instruction_size; } @@ -1140,28 +1140,28 @@ static const struct command_registration arm_exec_command_handlers[] = { .usage = "cpnum op1 CRn CRm op2", }, { - "semihosting", + .name = "semihosting", .handler = handle_common_semihosting_command, .mode = COMMAND_EXEC, .usage = "['enable'|'disable']", .help = "activate support for semihosting operations", }, { - "semihosting_cmdline", + .name = "semihosting_cmdline", .handler = handle_common_semihosting_cmdline, .mode = COMMAND_EXEC, .usage = "arguments", .help = "command line arguments to be passed to program", }, { - "semihosting_fileio", + .name = "semihosting_fileio", .handler = handle_common_semihosting_fileio_command, .mode = COMMAND_EXEC, .usage = "['enable'|'disable']", .help = "activate support for semihosting fileio operations", }, { - "semihosting_resexit", + .name = "semihosting_resexit", .handler = handle_common_semihosting_resumable_exit_command, .mode = COMMAND_EXEC, .usage = "['enable'|'disable']", diff --git a/src/target/armv4_5_cache.c b/src/target/armv4_5_cache.c index bd0091d..eda8cb7 100644 --- a/src/target/armv4_5_cache.c +++ b/src/target/armv4_5_cache.c @@ -76,23 +76,23 @@ int armv4_5_identify_cache(uint32_t cache_type_reg, struct armv4_5_cache_common return ERROR_OK; } -int armv4_5_handle_cache_info_command(struct command_context *cmd_ctx, struct armv4_5_cache_common *armv4_5_cache) +int armv4_5_handle_cache_info_command(struct command_invocation *cmd, struct armv4_5_cache_common *armv4_5_cache) { if (armv4_5_cache->ctype == -1) { - command_print(cmd_ctx, "cache not yet identified"); + command_print(cmd, "cache not yet identified"); return ERROR_OK; } - command_print(cmd_ctx, "cache type: 0x%1.1x, %s", armv4_5_cache->ctype, + command_print(cmd, "cache type: 0x%1.1x, %s", armv4_5_cache->ctype, (armv4_5_cache->separate) ? "separate caches" : "unified cache"); - command_print(cmd_ctx, "D-Cache: linelen %i, associativity %i, nsets %i, cachesize 0x%x", + command_print(cmd, "D-Cache: linelen %i, associativity %i, nsets %i, cachesize 0x%x", armv4_5_cache->d_u_size.linelen, armv4_5_cache->d_u_size.associativity, armv4_5_cache->d_u_size.nsets, armv4_5_cache->d_u_size.cachesize); - command_print(cmd_ctx, "I-Cache: linelen %i, associativity %i, nsets %i, cachesize 0x%x", + command_print(cmd, "I-Cache: linelen %i, associativity %i, nsets %i, cachesize 0x%x", armv4_5_cache->i_size.linelen, armv4_5_cache->i_size.associativity, armv4_5_cache->i_size.nsets, diff --git a/src/target/armv4_5_cache.h b/src/target/armv4_5_cache.h index 2fd1ca3..768938f 100644 --- a/src/target/armv4_5_cache.h +++ b/src/target/armv4_5_cache.h @@ -19,7 +19,7 @@ #ifndef OPENOCD_TARGET_ARMV4_5_CACHE_H #define OPENOCD_TARGET_ARMV4_5_CACHE_H -struct command_context; +struct command_invocation; struct armv4_5_cachesize { int linelen; @@ -42,7 +42,7 @@ int armv4_5_identify_cache(uint32_t cache_type_reg, int armv4_5_cache_state(uint32_t cp15_control_reg, struct armv4_5_cache_common *cache); -int armv4_5_handle_cache_info_command(struct command_context *cmd_ctx, +int armv4_5_handle_cache_info_command(struct command_invocation *cmd, struct armv4_5_cache_common *armv4_5_cache); enum { diff --git a/src/target/armv7a.c b/src/target/armv7a.c index f9594c9..2be70b7 100644 --- a/src/target/armv7a.c +++ b/src/target/armv7a.c @@ -229,7 +229,7 @@ COMMAND_HANDLER(handle_cache_l2x) if (CMD_ARGC != 2) return ERROR_COMMAND_SYNTAX_ERROR; - /* command_print(CMD_CTX, "%s %s", CMD_ARGV[0], CMD_ARGV[1]); */ + /* command_print(CMD, "%s %s", CMD_ARGV[0], CMD_ARGV[1]); */ COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], base); COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], way); @@ -239,7 +239,7 @@ COMMAND_HANDLER(handle_cache_l2x) return ERROR_OK; } -int armv7a_handle_cache_info_command(struct command_context *cmd_ctx, +int armv7a_handle_cache_info_command(struct command_invocation *cmd, struct armv7a_cache_common *armv7a_cache) { struct armv7a_l2x_cache *l2x_cache = (struct armv7a_l2x_cache *) @@ -248,7 +248,7 @@ int armv7a_handle_cache_info_command(struct command_context *cmd_ctx, int cl; if (armv7a_cache->info == -1) { - command_print(cmd_ctx, "cache not yet identified"); + command_print(cmd, "cache not yet identified"); return ERROR_OK; } @@ -256,7 +256,7 @@ int armv7a_handle_cache_info_command(struct command_context *cmd_ctx, struct armv7a_arch_cache *arch = &(armv7a_cache->arch[cl]); if (arch->ctype & 1) { - command_print(cmd_ctx, + command_print(cmd, "L%d I-Cache: linelen %" PRIi32 ", associativity %" PRIi32 ", nsets %" PRIi32 @@ -269,7 +269,7 @@ int armv7a_handle_cache_info_command(struct command_context *cmd_ctx, } if (arch->ctype >= 2) { - command_print(cmd_ctx, + command_print(cmd, "L%d D-Cache: linelen %" PRIi32 ", associativity %" PRIi32 ", nsets %" PRIi32 @@ -283,7 +283,7 @@ int armv7a_handle_cache_info_command(struct command_context *cmd_ctx, } if (l2x_cache != NULL) - command_print(cmd_ctx, "Outer unified cache Base Address 0x%" PRIx32 ", %" PRId32 " ways", + command_print(cmd, "Outer unified cache Base Address 0x%" PRIx32 ", %" PRId32 " ways", l2x_cache->base, l2x_cache->way); return ERROR_OK; @@ -307,23 +307,21 @@ static int armv7a_read_mpidr(struct target *target) if (retval != ERROR_OK) goto done; - /* ARMv7R uses a different format for MPIDR. - * When configured uniprocessor (most R cores) it reads as 0. - * This will need to be implemented for multiprocessor ARMv7R cores. */ - if (armv7a->is_armv7r) { - if (mpidr) - LOG_ERROR("MPIDR nonzero in ARMv7-R target"); - goto done; - } - - if (mpidr & 1<<31) { + /* Is register in Multiprocessing Extensions register format? */ + if (mpidr & MPIDR_MP_EXT) { + LOG_DEBUG("%s: MPIDR 0x%" PRIx32, target_name(target), mpidr); armv7a->multi_processor_system = (mpidr >> 30) & 1; + armv7a->multi_threading_processor = (mpidr >> 24) & 1; + armv7a->level2_id = (mpidr >> 16) & 0xf; armv7a->cluster_id = (mpidr >> 8) & 0xf; - armv7a->cpu_id = mpidr & 0x3; - LOG_INFO("%s cluster %x core %x %s", target_name(target), + armv7a->cpu_id = mpidr & 0xf; + LOG_INFO("%s: MPIDR level2 %x, cluster %x, core %x, %s, %s", + target_name(target), + armv7a->level2_id, armv7a->cluster_id, armv7a->cpu_id, - armv7a->multi_processor_system == 0 ? "multi core" : "mono core"); + armv7a->multi_processor_system == 0 ? "multi core" : "mono core", + armv7a->multi_threading_processor == 1 ? "SMT" : "no SMT"); } else LOG_ERROR("MPIDR not in multiprocessor format"); @@ -584,8 +582,7 @@ static const struct command_registration l2_cache_commands[] = { .name = "l2x", .handler = handle_cache_l2x, .mode = COMMAND_EXEC, - .help = "configure l2x cache " - "", + .help = "configure l2x cache", .usage = "[base_addr] [number_of_way]", }, COMMAND_REGISTRATION_DONE diff --git a/src/target/armv7a.h b/src/target/armv7a.h index 1e88c98..0ef04c1 100644 --- a/src/target/armv7a.h +++ b/src/target/armv7a.h @@ -108,6 +108,8 @@ struct armv7a_common { struct adiv5_ap *debug_ap; /* mdir */ uint8_t multi_processor_system; + uint8_t multi_threading_processor; + uint8_t level2_id; uint8_t cluster_id; uint8_t cpu_id; bool is_armv7r; @@ -183,11 +185,14 @@ static inline bool is_armv7a(struct armv7a_common *armv7a) #define DBG_VCR_PREF_ABORT_MASK ((1 << 27) | (1 << 3)) #define DBG_VCR_SVC_MASK ((1 << 26) | (1 << 2)) +/* Masks for Multiprocessor Affinity Register */ +#define MPIDR_MP_EXT (1UL << 31) + int armv7a_arch_state(struct target *target); int armv7a_identify_cache(struct target *target); int armv7a_init_arch_info(struct target *target, struct armv7a_common *armv7a); -int armv7a_handle_cache_info_command(struct command_context *cmd_ctx, +int armv7a_handle_cache_info_command(struct command_invocation *cmd, struct armv7a_cache_common *armv7a_cache); int armv7a_read_ttbcr(struct target *target); diff --git a/src/target/armv7a_cache.c b/src/target/armv7a_cache.c index 7435aab..921ba9b 100644 --- a/src/target/armv7a_cache.c +++ b/src/target/armv7a_cache.c @@ -431,7 +431,7 @@ COMMAND_HANDLER(arm7a_l1_cache_info_cmd) struct target *target = get_current_target(CMD_CTX); struct armv7a_common *armv7a = target_to_armv7a(target); - return armv7a_handle_cache_info_command(CMD_CTX, + return armv7a_handle_cache_info_command(CMD, &armv7a->armv7a_mmu.armv7a_cache); } @@ -513,7 +513,7 @@ COMMAND_HANDLER(arm7a_cache_disable_auto_cmd) struct armv7a_common *armv7a = target_to_armv7a(target); if (CMD_ARGC == 0) { - command_print(CMD_CTX, "auto cache is %s", + command_print(CMD, "auto cache is %s", armv7a->armv7a_mmu.armv7a_cache.auto_cache_enabled ? "enabled" : "disabled"); return ERROR_OK; } diff --git a/src/target/armv7a_cache_l2x.c b/src/target/armv7a_cache_l2x.c index e181f26..72e12b4 100644 --- a/src/target/armv7a_cache_l2x.c +++ b/src/target/armv7a_cache_l2x.c @@ -173,18 +173,18 @@ done: return retval; } -static int arm7a_handle_l2x_cache_info_command(struct command_context *cmd_ctx, +static int arm7a_handle_l2x_cache_info_command(struct command_invocation *cmd, struct armv7a_cache_common *armv7a_cache) { struct armv7a_l2x_cache *l2x_cache = (struct armv7a_l2x_cache *) (armv7a_cache->outer_cache); if (armv7a_cache->info == -1) { - command_print(cmd_ctx, "cache not yet identified"); + command_print(cmd, "cache not yet identified"); return ERROR_OK; } - command_print(cmd_ctx, + command_print(cmd, "L2 unified cache Base Address 0x%" PRIx32 ", %" PRId32 " ways", l2x_cache->base, l2x_cache->way); @@ -235,7 +235,7 @@ COMMAND_HANDLER(arm7a_l2x_cache_info_command) if (retval) return retval; - return arm7a_handle_l2x_cache_info_command(CMD_CTX, + return arm7a_handle_l2x_cache_info_command(CMD, &armv7a->armv7a_mmu.armv7a_cache); } @@ -312,7 +312,7 @@ COMMAND_HANDLER(armv7a_l2x_cache_conf_cmd) if (CMD_ARGC != 2) return ERROR_COMMAND_SYNTAX_ERROR; - /* command_print(CMD_CTX, "%s %s", CMD_ARGV[0], CMD_ARGV[1]); */ + /* command_print(CMD, "%s %s", CMD_ARGV[0], CMD_ARGV[1]); */ COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], base); COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], way); diff --git a/src/target/armv7a_mmu.c b/src/target/armv7a_mmu.c index 153bfcc..f83228d 100644 --- a/src/target/armv7a_mmu.c +++ b/src/target/armv7a_mmu.c @@ -34,101 +34,15 @@ #define SCTLR_BIT_AFE (1 << 29) -/* method adapted to Cortex-A : reused ARM v4 v5 method */ -int armv7a_mmu_translate_va(struct target *target, uint32_t va, uint32_t *val) -{ - uint32_t first_lvl_descriptor = 0x0; - uint32_t second_lvl_descriptor = 0x0; - int retval; - struct armv7a_common *armv7a = target_to_armv7a(target); - uint32_t ttbidx = 0; /* default to ttbr0 */ - uint32_t ttb_mask; - uint32_t va_mask; - uint32_t ttb; - - if (target->state != TARGET_HALTED) - LOG_INFO("target not halted, using cached values for translation table!"); - - /* if va is above the range handled by ttbr0, select ttbr1 */ - if (va > armv7a->armv7a_mmu.ttbr_range[0]) { - /* select ttb 1 */ - ttbidx = 1; - } - - ttb = armv7a->armv7a_mmu.ttbr[ttbidx]; - ttb_mask = armv7a->armv7a_mmu.ttbr_mask[ttbidx]; - va_mask = 0xfff00000 & armv7a->armv7a_mmu.ttbr_range[ttbidx]; - - LOG_DEBUG("ttb_mask %" PRIx32 " va_mask %" PRIx32 " ttbidx %i", - ttb_mask, va_mask, ttbidx); - retval = armv7a->armv7a_mmu.read_physical_memory(target, - (ttb & ttb_mask) | ((va & va_mask) >> 18), - 4, 1, (uint8_t *)&first_lvl_descriptor); - if (retval != ERROR_OK) - return retval; - first_lvl_descriptor = target_buffer_get_u32(target, (uint8_t *) - &first_lvl_descriptor); - /* reuse armv4_5 piece of code, specific armv7a changes may come later */ - LOG_DEBUG("1st lvl desc: %8.8" PRIx32 "", first_lvl_descriptor); - - if ((first_lvl_descriptor & 0x3) == 0) { - /* Avoid LOG_ERROR, probably GDB is guessing the stack frame */ - LOG_WARNING("Address translation failure [1]: va %8.8" PRIx32 "", va); - return ERROR_TARGET_TRANSLATION_FAULT; - } - - if ((first_lvl_descriptor & 0x40002) == 2) { - /* section descriptor */ - *val = (first_lvl_descriptor & 0xfff00000) | (va & 0x000fffff); - return ERROR_OK; - } else if ((first_lvl_descriptor & 0x40002) == 0x40002) { - /* supersection descriptor */ - if (first_lvl_descriptor & 0x00f001e0) { - LOG_ERROR("Physical address does not fit into 32 bits"); - return ERROR_TARGET_TRANSLATION_FAULT; - } - *val = (first_lvl_descriptor & 0xff000000) | (va & 0x00ffffff); - return ERROR_OK; - } - - /* page table */ - retval = armv7a->armv7a_mmu.read_physical_memory(target, - (first_lvl_descriptor & 0xfffffc00) | ((va & 0x000ff000) >> 10), - 4, 1, (uint8_t *)&second_lvl_descriptor); - if (retval != ERROR_OK) - return retval; - - second_lvl_descriptor = target_buffer_get_u32(target, (uint8_t *) - &second_lvl_descriptor); - - LOG_DEBUG("2nd lvl desc: %8.8" PRIx32 "", second_lvl_descriptor); - - if ((second_lvl_descriptor & 0x3) == 0) { - /* Avoid LOG_ERROR, probably GDB is guessing the stack frame */ - LOG_WARNING("Address translation failure [2]: va %8.8" PRIx32 "", va); - return ERROR_TARGET_TRANSLATION_FAULT; - } - - if ((second_lvl_descriptor & 0x3) == 1) { - /* large page descriptor */ - *val = (second_lvl_descriptor & 0xffff0000) | (va & 0x0000ffff); - } else { - /* small page descriptor */ - *val = (second_lvl_descriptor & 0xfffff000) | (va & 0x00000fff); - } - - return ERROR_OK; -} - /* V7 method VA TO PA */ int armv7a_mmu_translate_va_pa(struct target *target, uint32_t va, - uint32_t *val, int meminfo) + target_addr_t *val, int meminfo) { int retval = ERROR_FAIL; struct armv7a_common *armv7a = target_to_armv7a(target); struct arm_dpm *dpm = armv7a->arm.dpm; - uint32_t virt = va & ~0xfff; - uint32_t NOS, NS, INNER, OUTER; + uint32_t virt = va & ~0xfff, value; + uint32_t NOS, NS, INNER, OUTER, SS; *val = 0xdeadbeef; retval = dpm->prepare(dpm); if (retval != ERROR_OK) @@ -142,21 +56,39 @@ int armv7a_mmu_translate_va_pa(struct target *target, uint32_t va, goto done; retval = dpm->instr_read_data_r0(dpm, ARMV4_5_MRC(15, 0, 0, 7, 4, 0), - val); - /* decode memory attribute */ - NOS = (*val >> 10) & 1; /* Not Outer shareable */ - NS = (*val >> 9) & 1; /* Non secure */ - INNER = (*val >> 4) & 0x7; - OUTER = (*val >> 2) & 0x3; - + &value); if (retval != ERROR_OK) goto done; - *val = (*val & ~0xfff) + (va & 0xfff); + + /* decode memory attribute */ + SS = (value >> 1) & 1; +#if !BUILD_TARGET64 + if (SS) { + LOG_ERROR("Super section found with no-64 bit address support"); + return ERROR_FAIL; + } +#endif + NOS = (value >> 10) & 1; /* Not Outer shareable */ + NS = (value >> 9) & 1; /* Non secure */ + INNER = (value >> 4) & 0x7; + OUTER = (value >> 2) & 0x3; + + if (SS) { + /* PAR[31:24] contains PA[31:24] */ + *val = value & 0xff000000; + /* PAR [23:16] contains PA[39:32] */ + *val |= (target_addr_t)(value & 0x00ff0000) << 16; + /* PA[23:12] is the same as VA[23:12] */ + *val |= (va & 0xffffff); + } else { + *val = (value & ~0xfff) + (va & 0xfff); + } if (meminfo) { - LOG_INFO("%" PRIx32 " : %" PRIx32 " %s outer shareable %s secured", + LOG_INFO("%" PRIx32 " : %" TARGET_PRIxADDR " %s outer shareable %s secured %s super section", va, *val, NOS == 1 ? "not" : " ", - NS == 1 ? "not" : ""); + NS == 1 ? "not" : "", + SS == 0 ? "not" : ""); switch (OUTER) { case 0: LOG_INFO("outer: Non-Cacheable"); diff --git a/src/target/armv7a_mmu.h b/src/target/armv7a_mmu.h index 4372aa8..36cd9d1 100644 --- a/src/target/armv7a_mmu.h +++ b/src/target/armv7a_mmu.h @@ -19,9 +19,8 @@ #ifndef OPENOCD_TARGET_ARMV7A_MMU_H #define OPENOCD_TARGET_ARMV7A_MMU_H -extern int armv7a_mmu_translate_va(struct target *target, uint32_t va, uint32_t *val); extern int armv7a_mmu_translate_va_pa(struct target *target, uint32_t va, - uint32_t *val, int meminfo); + target_addr_t *val, int meminfo); extern const struct command_registration armv7a_mmu_command_handlers[]; diff --git a/src/target/armv7m.c b/src/target/armv7m.c index 3d73b29..4b37774 100644 --- a/src/target/armv7m.c +++ b/src/target/armv7m.c @@ -191,7 +191,7 @@ static int armv7m_get_core_reg(struct reg *reg) if (target->state != TARGET_HALTED) return ERROR_TARGET_NOT_HALTED; - retval = arm->read_core_reg(target, reg, armv7m_reg->num, arm->core_mode); + retval = arm->read_core_reg(target, reg, reg->number, arm->core_mode); return retval; } diff --git a/src/target/armv8.c b/src/target/armv8.c index c8cfcae..e736937 100644 --- a/src/target/armv8.c +++ b/src/target/armv8.c @@ -646,7 +646,7 @@ int armv8_read_mpidr(struct armv8_common *armv8) retval = dpm->instr_read_data_r0(dpm, armv8_opcode(armv8, READ_REG_MPIDR), &mpidr); if (retval != ERROR_OK) goto done; - if (mpidr & 1<<31) { + if (mpidr & 1U<<31) { armv8->multi_processor_system = (mpidr >> 30) & 1; armv8->cluster_id = (mpidr >> 8) & 0xf; armv8->cpu_id = mpidr & 0x3; @@ -1054,7 +1054,7 @@ COMMAND_HANDLER(armv8_handle_exception_catch_command) return ERROR_FAIL; } - command_print(CMD_CTX, "Exception Catch: Secure: %s, Non-Secure: %s", sec, nsec); + command_print(CMD, "Exception Catch: Secure: %s, Non-Secure: %s", sec, nsec); return ERROR_OK; } @@ -1079,16 +1079,16 @@ COMMAND_HANDLER(armv8_handle_exception_catch_command) return ERROR_OK; } -int armv8_handle_cache_info_command(struct command_context *cmd_ctx, +int armv8_handle_cache_info_command(struct command_invocation *cmd, struct armv8_cache_common *armv8_cache) { if (armv8_cache->info == -1) { - command_print(cmd_ctx, "cache not yet identified"); + command_print(cmd, "cache not yet identified"); return ERROR_OK; } if (armv8_cache->display_cache_info) - armv8_cache->display_cache_info(cmd_ctx, armv8_cache); + armv8_cache->display_cache_info(cmd, armv8_cache); return ERROR_OK; } diff --git a/src/target/armv8.h b/src/target/armv8.h index af00e52..1a61145 100644 --- a/src/target/armv8.h +++ b/src/target/armv8.h @@ -170,7 +170,7 @@ struct armv8_cache_common { /* l2 external unified cache if some */ void *l2_cache; int (*flush_all_data_cache)(struct target *target); - int (*display_cache_info)(struct command_context *cmd_ctx, + int (*display_cache_info)(struct command_invocation *cmd, struct armv8_cache_common *armv8_cache); }; @@ -301,7 +301,7 @@ int armv8_mmu_translate_va_pa(struct target *target, target_addr_t va, target_addr_t *val, int meminfo); int armv8_mmu_translate_va(struct target *target, target_addr_t va, target_addr_t *val); -int armv8_handle_cache_info_command(struct command_context *cmd_ctx, +int armv8_handle_cache_info_command(struct command_invocation *cmd, struct armv8_cache_common *armv8_cache); void armv8_set_cpsr(struct arm *arm, uint32_t cpsr); diff --git a/src/target/armv8_cache.c b/src/target/armv8_cache.c index 40965eb..41c85c9 100644 --- a/src/target/armv8_cache.c +++ b/src/target/armv8_cache.c @@ -188,13 +188,13 @@ done: return retval; } -static int armv8_handle_inner_cache_info_command(struct command_context *cmd_ctx, +static int armv8_handle_inner_cache_info_command(struct command_invocation *cmd, struct armv8_cache_common *armv8_cache) { int cl; if (armv8_cache->info == -1) { - command_print(cmd_ctx, "cache not yet identified"); + command_print(cmd, "cache not yet identified"); return ERROR_OK; } @@ -202,7 +202,7 @@ static int armv8_handle_inner_cache_info_command(struct command_context *cmd_ctx struct armv8_arch_cache *arch = &(armv8_cache->arch[cl]); if (arch->ctype & 1) { - command_print(cmd_ctx, + command_print(cmd, "L%d I-Cache: linelen %" PRIi32 ", associativity %" PRIi32 ", nsets %" PRIi32 @@ -215,7 +215,7 @@ static int armv8_handle_inner_cache_info_command(struct command_context *cmd_ctx } if (arch->ctype >= 2) { - command_print(cmd_ctx, + command_print(cmd, "L%d D-Cache: linelen %" PRIi32 ", associativity %" PRIi32 ", nsets %" PRIi32 diff --git a/src/target/cortex_a.c b/src/target/cortex_a.c index 6eb6aa9..b3a8a41 100644 --- a/src/target/cortex_a.c +++ b/src/target/cortex_a.c @@ -55,6 +55,7 @@ #include "target_type.h" #include "arm_opcodes.h" #include "arm_semihosting.h" +#include "jtag/interface.h" #include "transport/transport.h" #include "smp.h" #include <helper/time_support.h> @@ -70,6 +71,8 @@ static int cortex_a_set_hybrid_breakpoint(struct target *target, struct breakpoint *breakpoint); static int cortex_a_unset_breakpoint(struct target *target, struct breakpoint *breakpoint); +static int cortex_a_wait_dscr_bits(struct target *target, uint32_t mask, + uint32_t value, uint32_t *dscr); static int cortex_a_mmu(struct target *target, int *enabled); static int cortex_a_mmu_modify(struct target *target, int enable); static int cortex_a_virt2phys(struct target *target, @@ -250,21 +253,21 @@ static int cortex_a_wait_instrcmpl(struct target *target, uint32_t *dscr, bool f * Writes final value of DSCR into *dscr. Pass force to force always * reading DSCR at least once. */ struct armv7a_common *armv7a = target_to_armv7a(target); - int64_t then = timeval_ms(); - while ((*dscr & DSCR_INSTR_COMP) == 0 || force) { - force = false; - int retval = mem_ap_read_atomic_u32(armv7a->debug_ap, + int retval; + + if (force) { + retval = mem_ap_read_atomic_u32(armv7a->debug_ap, armv7a->debug_base + CPUDBG_DSCR, dscr); if (retval != ERROR_OK) { LOG_ERROR("Could not read DSCR register"); return retval; } - if (timeval_ms() > then + 1000) { - LOG_ERROR("Timeout waiting for InstrCompl=1"); - return ERROR_FAIL; - } } - return ERROR_OK; + + retval = cortex_a_wait_dscr_bits(target, DSCR_INSTR_COMP, DSCR_INSTR_COMP, dscr); + if (retval != ERROR_OK) + LOG_ERROR("Error waiting for InstrCompl=1"); + return retval; } /* To reduce needless round-trips, pass in a pointer to the current @@ -293,19 +296,12 @@ static int cortex_a_exec_opcode(struct target *target, if (retval != ERROR_OK) return retval; - int64_t then = timeval_ms(); - do { - retval = mem_ap_read_atomic_u32(armv7a->debug_ap, - armv7a->debug_base + CPUDBG_DSCR, &dscr); - if (retval != ERROR_OK) { - LOG_ERROR("Could not read DSCR register"); - return retval; - } - if (timeval_ms() > then + 1000) { - LOG_ERROR("Timeout waiting for cortex_a_exec_opcode"); - return ERROR_FAIL; - } - } while ((dscr & DSCR_INSTR_COMP) == 0); /* Wait for InstrCompl bit to be set */ + /* Wait for InstrCompl bit to be set */ + retval = cortex_a_wait_instrcmpl(target, &dscr, true); + if (retval != ERROR_OK) { + LOG_ERROR("Error waiting for cortex_a_exec_opcode"); + return retval; + } if (dscr_p) *dscr_p = dscr; @@ -359,17 +355,11 @@ static int cortex_a_read_dcc(struct cortex_a_common *a, uint32_t *data, dscr = *dscr_p; /* Wait for DTRRXfull */ - int64_t then = timeval_ms(); - while ((dscr & DSCR_DTR_TX_FULL) == 0) { - retval = mem_ap_read_atomic_u32(a->armv7a_common.debug_ap, - a->armv7a_common.debug_base + CPUDBG_DSCR, - &dscr); - if (retval != ERROR_OK) - return retval; - if (timeval_ms() > then + 1000) { - LOG_ERROR("Timeout waiting for read dcc"); - return ERROR_FAIL; - } + retval = cortex_a_wait_dscr_bits(a->armv7a_common.arm.target, + DSCR_DTR_TX_FULL, DSCR_DTR_TX_FULL, &dscr); + if (retval != ERROR_OK) { + LOG_ERROR("Error waiting for read dcc"); + return retval; } retval = mem_ap_read_atomic_u32(a->armv7a_common.debug_ap, @@ -391,19 +381,10 @@ static int cortex_a_dpm_prepare(struct arm_dpm *dpm) int retval; /* set up invariant: INSTR_COMP is set after ever DPM operation */ - int64_t then = timeval_ms(); - for (;; ) { - retval = mem_ap_read_atomic_u32(a->armv7a_common.debug_ap, - a->armv7a_common.debug_base + CPUDBG_DSCR, - &dscr); - if (retval != ERROR_OK) - return retval; - if ((dscr & DSCR_INSTR_COMP) != 0) - break; - if (timeval_ms() > then + 1000) { - LOG_ERROR("Timeout waiting for dpm prepare"); - return ERROR_FAIL; - } + retval = cortex_a_wait_instrcmpl(dpm->arm->target, &dscr, true); + if (retval != ERROR_OK) { + LOG_ERROR("Error waiting for dpm prepare"); + return retval; } /* this "should never happen" ... */ @@ -752,7 +733,7 @@ static int cortex_a_poll(struct target *target) static int cortex_a_halt(struct target *target) { - int retval = ERROR_OK; + int retval; uint32_t dscr; struct armv7a_common *armv7a = target_to_armv7a(target); @@ -765,18 +746,12 @@ static int cortex_a_halt(struct target *target) if (retval != ERROR_OK) return retval; - int64_t then = timeval_ms(); - for (;; ) { - retval = mem_ap_read_atomic_u32(armv7a->debug_ap, - armv7a->debug_base + CPUDBG_DSCR, &dscr); - if (retval != ERROR_OK) - return retval; - if ((dscr & DSCR_CORE_HALTED) != 0) - break; - if (timeval_ms() > then + 1000) { - LOG_ERROR("Timeout waiting for halt"); - return ERROR_FAIL; - } + dscr = 0; /* force read of dscr */ + retval = cortex_a_wait_dscr_bits(target, DSCR_CORE_HALTED, + DSCR_CORE_HALTED, &dscr); + if (retval != ERROR_OK) { + LOG_ERROR("Error waiting for halt"); + return retval; } target->debug_reason = DBG_REASON_DBGRQ; @@ -915,18 +890,12 @@ static int cortex_a_internal_restart(struct target *target) if (retval != ERROR_OK) return retval; - int64_t then = timeval_ms(); - for (;; ) { - retval = mem_ap_read_atomic_u32(armv7a->debug_ap, - armv7a->debug_base + CPUDBG_DSCR, &dscr); - if (retval != ERROR_OK) - return retval; - if ((dscr & DSCR_CORE_RESTARTED) != 0) - break; - if (timeval_ms() > then + 1000) { - LOG_ERROR("Timeout waiting for resume"); - return ERROR_FAIL; - } + dscr = 0; /* force read of dscr */ + retval = cortex_a_wait_dscr_bits(target, DSCR_CORE_RESTARTED, + DSCR_CORE_RESTARTED, &dscr); + if (retval != ERROR_OK) { + LOG_ERROR("Error waiting for resume"); + return retval; } target->debug_reason = DBG_REASON_NOTHALTED; @@ -1206,6 +1175,8 @@ static int cortex_a_step(struct target *target, int current, target_addr_t addre retval = cortex_a_poll(target); if (retval != ERROR_OK) return retval; + if (target->state == TARGET_HALTED) + break; if (timeval_ms() > then + 1000) { LOG_ERROR("timeout waiting for target halt"); return ERROR_FAIL; @@ -1689,7 +1660,7 @@ static int cortex_a_assert_reset(struct target *target) */ if (transport_is_swd() || (target->reset_halt && (jtag_get_reset_config() & RESET_SRST_NO_GATING))) - jtag_add_reset(0, 1); + adapter_assert_reset(); } else { LOG_ERROR("%s: how to reset?", target_name(target)); @@ -1712,7 +1683,7 @@ static int cortex_a_deassert_reset(struct target *target) LOG_DEBUG(" "); /* be certain SRST is off */ - jtag_add_reset(0, 0); + adapter_deassert_reset(); if (target_was_examined(target)) { retval = cortex_a_poll(target); @@ -1763,14 +1734,22 @@ static int cortex_a_wait_dscr_bits(struct target *target, uint32_t mask, { /* Waits until the specified bit(s) of DSCR take on a specified value. */ struct armv7a_common *armv7a = target_to_armv7a(target); - int64_t then = timeval_ms(); + int64_t then; int retval; - while ((*dscr & mask) != value) { + if ((*dscr & mask) == value) + return ERROR_OK; + + then = timeval_ms(); + while (1) { retval = mem_ap_read_atomic_u32(armv7a->debug_ap, armv7a->debug_base + CPUDBG_DSCR, dscr); - if (retval != ERROR_OK) + if (retval != ERROR_OK) { + LOG_ERROR("Could not read DSCR register"); return retval; + } + if ((*dscr & mask) == value) + break; if (timeval_ms() > then + 1000) { LOG_ERROR("timeout waiting for DSCR bit change"); return ERROR_FAIL; @@ -2944,7 +2923,7 @@ static int cortex_a_virt2phys(struct target *target, if (retval != ERROR_OK) return retval; return armv7a_mmu_translate_va_pa(target, (uint32_t)virt, - (uint32_t *)phys, 1); + phys, 1); } COMMAND_HANDLER(cortex_a_handle_cache_info_command) @@ -2952,7 +2931,7 @@ COMMAND_HANDLER(cortex_a_handle_cache_info_command) struct target *target = get_current_target(CMD_CTX); struct armv7a_common *armv7a = target_to_armv7a(target); - return armv7a_handle_cache_info_command(CMD_CTX, + return armv7a_handle_cache_info_command(CMD, &armv7a->armv7a_mmu.armv7a_cache); } @@ -2991,7 +2970,7 @@ COMMAND_HANDLER(handle_cortex_a_mask_interrupts_command) } n = Jim_Nvp_value2name_simple(nvp_maskisr_modes, cortex_a->isrmasking_mode); - command_print(CMD_CTX, "cortex_a interrupt mask %s", n->name); + command_print(CMD, "cortex_a interrupt mask %s", n->name); return ERROR_OK; } @@ -3017,7 +2996,7 @@ COMMAND_HANDLER(handle_cortex_a_dacrfixup_command) } n = Jim_Nvp_value2name_simple(nvp_dacrfixup_modes, cortex_a->dacrfixup_mode); - command_print(CMD_CTX, "cortex_a domain access control fixup %s", n->name); + command_print(CMD, "cortex_a domain access control fixup %s", n->name); return ERROR_OK; } diff --git a/src/target/cortex_m.c b/src/target/cortex_m.c index d341d45..7f59401 100644 --- a/src/target/cortex_m.c +++ b/src/target/cortex_m.c @@ -136,6 +136,83 @@ static int cortex_m_write_debug_halt_mask(struct target *target, return mem_ap_write_atomic_u32(armv7m->debug_ap, DCB_DHCSR, cortex_m->dcb_dhcsr); } +static int cortex_m_set_maskints(struct target *target, bool mask) +{ + struct cortex_m_common *cortex_m = target_to_cm(target); + if (!!(cortex_m->dcb_dhcsr & C_MASKINTS) != mask) + return cortex_m_write_debug_halt_mask(target, mask ? C_MASKINTS : 0, mask ? 0 : C_MASKINTS); + else + return ERROR_OK; +} + +static int cortex_m_set_maskints_for_halt(struct target *target) +{ + struct cortex_m_common *cortex_m = target_to_cm(target); + switch (cortex_m->isrmasking_mode) { + case CORTEX_M_ISRMASK_AUTO: + /* interrupts taken at resume, whether for step or run -> no mask */ + return cortex_m_set_maskints(target, false); + + case CORTEX_M_ISRMASK_OFF: + /* interrupts never masked */ + return cortex_m_set_maskints(target, false); + + case CORTEX_M_ISRMASK_ON: + /* interrupts always masked */ + return cortex_m_set_maskints(target, true); + + case CORTEX_M_ISRMASK_STEPONLY: + /* interrupts masked for single step only -> mask now if MASKINTS + * erratum, otherwise only mask before stepping */ + return cortex_m_set_maskints(target, cortex_m->maskints_erratum); + } + return ERROR_OK; +} + +static int cortex_m_set_maskints_for_run(struct target *target) +{ + switch (target_to_cm(target)->isrmasking_mode) { + case CORTEX_M_ISRMASK_AUTO: + /* interrupts taken at resume, whether for step or run -> no mask */ + return cortex_m_set_maskints(target, false); + + case CORTEX_M_ISRMASK_OFF: + /* interrupts never masked */ + return cortex_m_set_maskints(target, false); + + case CORTEX_M_ISRMASK_ON: + /* interrupts always masked */ + return cortex_m_set_maskints(target, true); + + case CORTEX_M_ISRMASK_STEPONLY: + /* interrupts masked for single step only -> no mask */ + return cortex_m_set_maskints(target, false); + } + return ERROR_OK; +} + +static int cortex_m_set_maskints_for_step(struct target *target) +{ + switch (target_to_cm(target)->isrmasking_mode) { + case CORTEX_M_ISRMASK_AUTO: + /* the auto-interrupt should already be done -> mask */ + return cortex_m_set_maskints(target, true); + + case CORTEX_M_ISRMASK_OFF: + /* interrupts never masked */ + return cortex_m_set_maskints(target, false); + + case CORTEX_M_ISRMASK_ON: + /* interrupts always masked */ + return cortex_m_set_maskints(target, true); + + case CORTEX_M_ISRMASK_STEPONLY: + /* interrupts masked for single step only -> mask */ + return cortex_m_set_maskints(target, true); + } + return ERROR_OK; +} + static int cortex_m_clear_halt(struct target *target) { struct cortex_m_common *cortex_m = target_to_cm(target); @@ -237,11 +314,8 @@ static int cortex_m_endreset_event(struct target *target) return retval; } - /* Restore proper interrupt masking setting. */ - if (cortex_m->isrmasking_mode == CORTEX_M_ISRMASK_ON) - cortex_m_write_debug_halt_mask(target, C_MASKINTS, 0); - else - cortex_m_write_debug_halt_mask(target, 0, C_MASKINTS); + /* Restore proper interrupt masking setting for running CPU. */ + cortex_m_set_maskints_for_run(target); /* Enable features controlled by ITM and DWT blocks, and catch only * the vectors we were told to pay attention to. @@ -318,7 +392,9 @@ static int cortex_m_examine_debug_reason(struct target *target) target->debug_reason = DBG_REASON_WATCHPOINT; else if (cortex_m->nvic_dfsr & DFSR_VCATCH) target->debug_reason = DBG_REASON_BREAKPOINT; - else /* EXTERNAL, HALTED */ + else if (cortex_m->nvic_dfsr & DFSR_EXTERNAL) + target->debug_reason = DBG_REASON_DBGRQ; + else /* HALTED */ target->debug_reason = DBG_REASON_UNDEFINED; } @@ -405,6 +481,10 @@ static int cortex_m_debug_entry(struct target *target) LOG_DEBUG(" "); + /* Do this really early to minimize the window where the MASKINTS erratum + * can pile up pending interrupts. */ + cortex_m_set_maskints_for_halt(target); + cortex_m_clear_halt(target); retval = mem_ap_read_atomic_u32(armv7m->debug_ap, DCB_DHCSR, &cortex_m->dcb_dhcsr); if (retval != ERROR_OK) @@ -614,6 +694,10 @@ static int cortex_m_halt(struct target *target) /* Write to Debug Halting Control and Status Register */ cortex_m_write_debug_halt_mask(target, C_HALT, 0); + /* Do this really early to minimize the window where the MASKINTS erratum + * can pile up pending interrupts. */ + cortex_m_set_maskints_for_halt(target); + target->debug_reason = DBG_REASON_DBGRQ; return ERROR_OK; @@ -632,6 +716,11 @@ static int cortex_m_soft_reset_halt(struct target *target) * core, not the peripherals */ LOG_WARNING("soft_reset_halt is deprecated, please use 'reset halt' instead."); + /* Set C_DEBUGEN */ + retval = cortex_m_write_debug_halt_mask(target, 0, C_STEP | C_MASKINTS); + if (retval != ERROR_OK) + return retval; + /* Enter debug state on reset; restore DEMCR in endreset_event() */ retval = mem_ap_write_u32(armv7m->debug_ap, DCB_DEMCR, TRCENA | VC_HARDERR | VC_BUSERR | VC_CORERESET); @@ -767,6 +856,7 @@ static int cortex_m_resume(struct target *target, int current, } /* Restart core */ + cortex_m_set_maskints_for_run(target); cortex_m_write_debug_halt_mask(target, 0, C_HALT); target->debug_reason = DBG_REASON_NOTHALTED; @@ -829,10 +919,12 @@ static int cortex_m_step(struct target *target, int current, * a normal step, otherwise we have to manually step over the bkpt * instruction - as such simulate a step */ if (bkpt_inst_found == false) { - /* Automatic ISR masking mode off: Just step over the next instruction */ - if ((cortex_m->isrmasking_mode != CORTEX_M_ISRMASK_AUTO)) + if ((cortex_m->isrmasking_mode != CORTEX_M_ISRMASK_AUTO)) { + /* Automatic ISR masking mode off: Just step over the next + * instruction, with interrupts on or off as appropriate. */ + cortex_m_set_maskints_for_step(target); cortex_m_write_debug_halt_mask(target, C_STEP, C_HALT); - else { + } else { /* Process interrupts during stepping in a way they don't interfere * debugging. * @@ -871,8 +963,9 @@ static int cortex_m_step(struct target *target, int current, LOG_DEBUG("Stepping over next instruction with interrupts disabled"); cortex_m_write_debug_halt_mask(target, C_HALT | C_MASKINTS, 0); cortex_m_write_debug_halt_mask(target, C_STEP, C_HALT); - /* Re-enable interrupts */ - cortex_m_write_debug_halt_mask(target, C_HALT, C_MASKINTS); + /* Re-enable interrupts if appropriate */ + cortex_m_write_debug_halt_mask(target, C_HALT, 0); + cortex_m_set_maskints_for_halt(target); } else { @@ -891,12 +984,17 @@ static int cortex_m_step(struct target *target, int current, bool tmp_bp_set = (retval == ERROR_OK); /* No more breakpoints left, just do a step */ - if (!tmp_bp_set) + if (!tmp_bp_set) { + cortex_m_set_maskints_for_step(target); cortex_m_write_debug_halt_mask(target, C_STEP, C_HALT); - else { + /* Re-enable interrupts if appropriate */ + cortex_m_write_debug_halt_mask(target, C_HALT, 0); + cortex_m_set_maskints_for_halt(target); + } else { /* Start the core */ LOG_DEBUG("Starting core to serve pending interrupts"); int64_t t_start = timeval_ms(); + cortex_m_set_maskints_for_run(target); cortex_m_write_debug_halt_mask(target, 0, C_HALT | C_STEP); /* Wait for pending handlers to complete or timeout */ @@ -924,12 +1022,14 @@ static int cortex_m_step(struct target *target, int current, "leaving target running"); } else { /* Step over next instruction with interrupts disabled */ + cortex_m_set_maskints_for_step(target); cortex_m_write_debug_halt_mask(target, C_HALT | C_MASKINTS, 0); cortex_m_write_debug_halt_mask(target, C_STEP, C_HALT); - /* Re-enable interrupts */ - cortex_m_write_debug_halt_mask(target, C_HALT, C_MASKINTS); + /* Re-enable interrupts if appropriate */ + cortex_m_write_debug_halt_mask(target, C_HALT, 0); + cortex_m_set_maskints_for_halt(target); } } } @@ -1031,8 +1131,7 @@ static int cortex_m_assert_reset(struct target *target) if (!target->reset_halt) { /* Set/Clear C_MASKINTS in a separate operation */ - if (cortex_m->dcb_dhcsr & C_MASKINTS) - cortex_m_write_debug_halt_mask(target, 0, C_MASKINTS); + cortex_m_set_maskints_for_run(target); /* clear any debug flags before resuming */ cortex_m_clear_halt(target); @@ -1104,7 +1203,7 @@ static int cortex_m_assert_reset(struct target *target) } target->state = TARGET_RESET; - jtag_add_sleep(50000); + jtag_sleep(50000); register_cache_invalidate(cortex_m->armv7m.arm.core_cache); @@ -1297,18 +1396,8 @@ int cortex_m_remove_breakpoint(struct target *target, struct breakpoint *breakpo int cortex_m_set_watchpoint(struct target *target, struct watchpoint *watchpoint) { int dwt_num = 0; - uint32_t mask, temp; struct cortex_m_common *cortex_m = target_to_cm(target); - /* watchpoint params were validated earlier */ - mask = 0; - temp = watchpoint->length; - while (temp) { - temp >>= 1; - mask++; - } - mask--; - /* REVISIT Don't fully trust these "not used" records ... users * may set up breakpoints by hand, e.g. dual-address data value * watchpoint using comparator #1; comparator #0 matching cycle @@ -1331,11 +1420,22 @@ int cortex_m_set_watchpoint(struct target *target, struct watchpoint *watchpoint target_write_u32(target, comparator->dwt_comparator_address + 0, comparator->comp); - comparator->mask = mask; - target_write_u32(target, comparator->dwt_comparator_address + 4, - comparator->mask); + if ((cortex_m->dwt_devarch & 0x1FFFFF) != DWT_DEVARCH_ARMV8M) { + uint32_t mask = 0, temp; + + /* watchpoint params were validated earlier */ + temp = watchpoint->length; + while (temp) { + temp >>= 1; + mask++; + } + mask--; + + comparator->mask = mask; + target_write_u32(target, comparator->dwt_comparator_address + 4, + comparator->mask); - switch (watchpoint->rw) { + switch (watchpoint->rw) { case WPT_READ: comparator->function = 5; break; @@ -1345,7 +1445,26 @@ int cortex_m_set_watchpoint(struct target *target, struct watchpoint *watchpoint case WPT_ACCESS: comparator->function = 7; break; + } + } else { + uint32_t data_size = watchpoint->length >> 1; + comparator->mask = (watchpoint->length >> 1) | 1; + + switch (watchpoint->rw) { + case WPT_ACCESS: + comparator->function = 4; + break; + case WPT_WRITE: + comparator->function = 5; + break; + case WPT_READ: + comparator->function = 6; + break; + } + comparator->function = comparator->function | (1 << 4) | + (data_size << 10); } + target_write_u32(target, comparator->dwt_comparator_address + 8, comparator->function); @@ -1888,6 +2007,9 @@ void cortex_m_dwt_setup(struct cortex_m_common *cm, struct target *target) return; } + target_read_u32(target, DWT_DEVARCH, &cm->dwt_devarch); + LOG_DEBUG("DWT_DEVARCH: 0x%" PRIx32, cm->dwt_devarch); + cm->dwt_num_comp = (dwtcr >> 28) & 0xF; cm->dwt_comp_available = cm->dwt_num_comp; cm->dwt_comparator_list = calloc(cm->dwt_num_comp, @@ -1976,6 +2098,15 @@ static void cortex_m_dwt_free(struct target *target) #define MVFR1_DEFAULT_M7_SP 0x11000011 #define MVFR1_DEFAULT_M7_DP 0x12000011 +static int cortex_m_find_mem_ap(struct adiv5_dap *swjdp, + struct adiv5_ap **debug_ap) +{ + if (dap_find_ap(swjdp, AP_TYPE_AHB3_AP, debug_ap) == ERROR_OK) + return ERROR_OK; + + return dap_find_ap(swjdp, AP_TYPE_AHB5_AP, debug_ap); +} + int cortex_m_examine(struct target *target) { int retval; @@ -1990,7 +2121,7 @@ int cortex_m_examine(struct target *target) if (!armv7m->stlink) { if (cortex_m->apsel == DP_APSEL_INVALID) { /* Search for the MEM-AP */ - retval = dap_find_ap(swjdp, AP_TYPE_AHB_AP, &armv7m->debug_ap); + retval = cortex_m_find_mem_ap(swjdp, &armv7m->debug_ap); if (retval != ERROR_OK) { LOG_ERROR("Could not find MEM-AP to control the core"); return retval; @@ -2018,14 +2149,31 @@ int cortex_m_examine(struct target *target) /* Get CPU Type */ i = (cpuid >> 4) & 0xf; + switch (cpuid & ARM_CPUID_PARTNO_MASK) { + case CORTEX_M23_PARTNO: + i = 23; + break; + + case CORTEX_M33_PARTNO: + i = 33; + break; + + default: + break; + } + + LOG_DEBUG("Cortex-M%d r%" PRId8 "p%" PRId8 " processor detected", i, (uint8_t)((cpuid >> 20) & 0xf), (uint8_t)((cpuid >> 0) & 0xf)); + cortex_m->maskints_erratum = false; if (i == 7) { uint8_t rev, patch; rev = (cpuid >> 20) & 0xf; patch = (cpuid >> 0) & 0xf; - if ((rev == 0) && (patch < 2)) - LOG_WARNING("Silicon bug: single stepping will enter pending exception handler!"); + if ((rev == 0) && (patch < 2)) { + LOG_WARNING("Silicon bug: single stepping may enter pending exception handler!"); + cortex_m->maskints_erratum = true; + } } LOG_DEBUG("cpuid: 0x%8.8" PRIx32 "", cpuid); @@ -2041,7 +2189,7 @@ int cortex_m_examine(struct target *target) LOG_DEBUG("Cortex-M%d floating point feature FPv4_SP found", i); armv7m->fp_feature = FPv4_SP; } - } else if (i == 7) { + } else if (i == 7 || i == 33) { target_read_u32(target, MVFR0, &mvfr0); target_read_u32(target, MVFR1, &mvfr1); @@ -2271,11 +2419,11 @@ static int cortex_m_target_create(struct target *target, Jim_Interp *interp) /*--------------------------------------------------------------------------*/ -static int cortex_m_verify_pointer(struct command_context *cmd_ctx, +static int cortex_m_verify_pointer(struct command_invocation *cmd, struct cortex_m_common *cm) { if (cm->common_magic != CORTEX_M_COMMON_MAGIC) { - command_print(cmd_ctx, "target is not a Cortex-M"); + command_print(cmd, "target is not a Cortex-M"); return ERROR_TARGET_INVALID; } return ERROR_OK; @@ -2309,7 +2457,7 @@ COMMAND_HANDLER(handle_cortex_m_vector_catch_command) { "reset", VC_CORERESET, }, }; - retval = cortex_m_verify_pointer(CMD_CTX, cortex_m); + retval = cortex_m_verify_pointer(CMD, cortex_m); if (retval != ERROR_OK) return retval; @@ -2364,7 +2512,7 @@ write: } for (unsigned i = 0; i < ARRAY_SIZE(vec_ids); i++) { - command_print(CMD_CTX, "%9s: %s", vec_ids[i].name, + command_print(CMD, "%9s: %s", vec_ids[i].name, (demcr & vec_ids[i].mask) ? "catch" : "ignore"); } @@ -2381,17 +2529,18 @@ COMMAND_HANDLER(handle_cortex_m_mask_interrupts_command) { .name = "auto", .value = CORTEX_M_ISRMASK_AUTO }, { .name = "off", .value = CORTEX_M_ISRMASK_OFF }, { .name = "on", .value = CORTEX_M_ISRMASK_ON }, + { .name = "steponly", .value = CORTEX_M_ISRMASK_STEPONLY }, { .name = NULL, .value = -1 }, }; const Jim_Nvp *n; - retval = cortex_m_verify_pointer(CMD_CTX, cortex_m); + retval = cortex_m_verify_pointer(CMD, cortex_m); if (retval != ERROR_OK) return retval; if (target->state != TARGET_HALTED) { - command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME); + command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME); return ERROR_OK; } @@ -2400,16 +2549,11 @@ COMMAND_HANDLER(handle_cortex_m_mask_interrupts_command) if (n->name == NULL) return ERROR_COMMAND_SYNTAX_ERROR; cortex_m->isrmasking_mode = n->value; - - - if (cortex_m->isrmasking_mode == CORTEX_M_ISRMASK_ON) - cortex_m_write_debug_halt_mask(target, C_HALT | C_MASKINTS, 0); - else - cortex_m_write_debug_halt_mask(target, C_HALT, C_MASKINTS); + cortex_m_set_maskints_for_halt(target); } n = Jim_Nvp_value2name_simple(nvp_maskisr_modes, cortex_m->isrmasking_mode); - command_print(CMD_CTX, "cortex_m interrupt mask %s", n->name); + command_print(CMD, "cortex_m interrupt mask %s", n->name); return ERROR_OK; } @@ -2421,7 +2565,7 @@ COMMAND_HANDLER(handle_cortex_m_reset_config_command) int retval; char *reset_config; - retval = cortex_m_verify_pointer(CMD_CTX, cortex_m); + retval = cortex_m_verify_pointer(CMD, cortex_m); if (retval != ERROR_OK) return retval; @@ -2454,7 +2598,7 @@ COMMAND_HANDLER(handle_cortex_m_reset_config_command) break; } - command_print(CMD_CTX, "cortex_m reset_config %s", reset_config); + command_print(CMD, "cortex_m reset_config %s", reset_config); return ERROR_OK; } @@ -2465,7 +2609,7 @@ static const struct command_registration cortex_m_exec_command_handlers[] = { .handler = handle_cortex_m_mask_interrupts_command, .mode = COMMAND_EXEC, .help = "mask cortex_m interrupts", - .usage = "['auto'|'on'|'off']", + .usage = "['auto'|'on'|'off'|'steponly']", }, { .name = "vector_catch", diff --git a/src/target/cortex_m.h b/src/target/cortex_m.h index 4b20746..54d7a02 100644 --- a/src/target/cortex_m.h +++ b/src/target/cortex_m.h @@ -38,6 +38,12 @@ #define ITM_LAR_KEY 0xC5ACCE55 #define CPUID 0xE000ED00 + +#define ARM_CPUID_PARTNO_MASK 0xFFF0 + +#define CORTEX_M23_PARTNO 0xD200 +#define CORTEX_M33_PARTNO 0xD210 + /* Debug Control Block */ #define DCB_DHCSR 0xE000EDF0 #define DCB_DCRSR 0xE000EDF4 @@ -52,6 +58,9 @@ #define DWT_COMP0 0xE0001020 #define DWT_MASK0 0xE0001024 #define DWT_FUNCTION0 0xE0001028 +#define DWT_DEVARCH 0xE0001FBC + +#define DWT_DEVARCH_ARMV8M 0x101A02 #define FP_CTRL 0xE0002000 #define FP_REMAP 0xE0002004 @@ -127,6 +136,7 @@ #define DFSR_BKPT 2 #define DFSR_DWTTRAP 4 #define DFSR_VCATCH 8 +#define DFSR_EXTERNAL 16 #define FPCR_CODE 0 #define FPCR_LITERAL 1 @@ -159,6 +169,7 @@ enum cortex_m_isrmasking_mode { CORTEX_M_ISRMASK_AUTO, CORTEX_M_ISRMASK_OFF, CORTEX_M_ISRMASK_ON, + CORTEX_M_ISRMASK_STEPONLY, }; struct cortex_m_common { @@ -179,6 +190,7 @@ struct cortex_m_common { /* Data Watchpoint and Trace (DWT) */ int dwt_num_comp; int dwt_comp_available; + uint32_t dwt_devarch; struct cortex_m_dwt_comparator *dwt_comparator_list; struct reg_cache *dwt_cache; @@ -190,6 +202,10 @@ struct cortex_m_common { struct armv7m_common armv7m; int apsel; + + /* Whether this target has the erratum that makes C_MASKINTS not apply to + * already pending interrupts */ + bool maskints_erratum; }; static inline struct cortex_m_common * diff --git a/src/target/dsp563xx.c b/src/target/dsp563xx.c index 5f13384..6a5c868 100644 --- a/src/target/dsp563xx.c +++ b/src/target/dsp563xx.c @@ -475,6 +475,7 @@ static void dsp563xx_build_reg_cache(struct target *target) reg_list[i].value = calloc(1, 4); reg_list[i].dirty = false; reg_list[i].valid = false; + reg_list[i].exist = true; reg_list[i].type = &dsp563xx_reg_type; reg_list[i].arch_info = &arch_info[i]; } @@ -1875,67 +1876,6 @@ static int dsp563xx_remove_watchpoint(struct target *target, struct watchpoint * return ERROR_TARGET_RESOURCE_NOT_AVAILABLE; } -static void handle_md_output(struct command_context *cmd_ctx, - struct target *target, - uint32_t address, - unsigned size, - unsigned count, - const uint8_t *buffer) -{ - const unsigned line_bytecnt = 32; - unsigned line_modulo = line_bytecnt / size; - - char output[line_bytecnt * 4 + 1]; - unsigned output_len = 0; - - const char *value_fmt; - switch (size) { - case 4: - value_fmt = "%8.8x "; - break; - case 2: - value_fmt = "%4.4x "; - break; - case 1: - value_fmt = "%2.2x "; - break; - default: - /* "can't happen", caller checked */ - LOG_ERROR("invalid memory read size: %u", size); - return; - } - - for (unsigned i = 0; i < count; i++) { - if (i % line_modulo == 0) - output_len += snprintf(output + output_len, - sizeof(output) - output_len, - "0x%8.8x: ", - (unsigned) (address + i)); - - uint32_t value = 0; - const uint8_t *value_ptr = buffer + i * size; - switch (size) { - case 4: - value = target_buffer_get_u32(target, value_ptr); - break; - case 2: - value = target_buffer_get_u16(target, value_ptr); - break; - case 1: - value = *value_ptr; - } - output_len += snprintf(output + output_len, - sizeof(output) - output_len, - value_fmt, - value); - - if ((i % line_modulo == line_modulo - 1) || (i == count - 1)) { - command_print(cmd_ctx, "%s", output); - output_len = 0; - } - } -} - static int dsp563xx_add_custom_watchpoint(struct target *target, uint32_t address, uint32_t memType, enum watchpoint_rw rw, enum watchpoint_condition cond) { @@ -2208,7 +2148,7 @@ COMMAND_HANDLER(dsp563xx_mem_command) err = dsp563xx_read_memory(target, mem_type, address, sizeof(uint32_t), count, buffer); if (err == ERROR_OK) - handle_md_output(CMD_CTX, target, address, sizeof(uint32_t), count, buffer); + target_handle_md_output(CMD, target, address, sizeof(uint32_t), count, buffer); } else { b = buffer; diff --git a/src/target/esirisc.c b/src/target/esirisc.c index 3d2954f..c928445 100644 --- a/src/target/esirisc.c +++ b/src/target/esirisc.c @@ -1680,7 +1680,7 @@ COMMAND_HANDLER(handle_esirisc_cache_arch_command) } } - command_print(CMD_CTX, "esirisc cache_arch %s", esirisc_cache_arch_name(esirisc)); + command_print(CMD, "esirisc cache_arch %s", esirisc_cache_arch_name(esirisc)); return ERROR_OK; } @@ -1698,7 +1698,7 @@ COMMAND_HANDLER(handle_esirisc_flush_caches_command) retval = esirisc_flush_caches(target); - command_print(CMD_CTX, "cache flush %s", + command_print(CMD, "cache flush %s", (retval == ERROR_OK) ? "successful" : "failed"); return retval; @@ -1748,7 +1748,7 @@ COMMAND_HANDLER(handle_esirisc_hwdc_command) } for (size_t i = 0; i < ARRAY_SIZE(esirisc_hwdc_masks); ++i) - command_print(CMD_CTX, "%9s: %s", esirisc_hwdc_masks[i].name, + command_print(CMD, "%9s: %s", esirisc_hwdc_masks[i].name, (esirisc->hwdc_save & esirisc_hwdc_masks[i].mask) ? "enabled" : "disabled"); return ERROR_OK; diff --git a/src/target/esirisc_trace.c b/src/target/esirisc_trace.c index 4e0a155..6a7d5a2 100644 --- a/src/target/esirisc_trace.c +++ b/src/target/esirisc_trace.c @@ -385,9 +385,9 @@ static int esirisc_trace_read_buffer(struct target *target, uint8_t *buffer) buffer_cur - trace_info->buffer_start, buffer); } -static int esirisc_trace_analyze_full(struct command_context *cmd_ctx, uint8_t *buffer, uint32_t size) +static int esirisc_trace_analyze_full(struct command_invocation *cmd, uint8_t *buffer, uint32_t size) { - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd->ctx); const uint32_t num_bits = size * 8; int retval; @@ -403,7 +403,7 @@ static int esirisc_trace_analyze_full(struct command_context *cmd_ctx, uint8_t * case ESIRISC_TRACE_ID_EXECUTE: case ESIRISC_TRACE_ID_STALL: case ESIRISC_TRACE_ID_BRANCH: - command_print(cmd_ctx, "%s", esirisc_trace_id_strings[id]); + command_print(cmd, "%s", esirisc_trace_id_strings[id]); break; case ESIRISC_TRACE_ID_EXTENDED: { @@ -417,7 +417,7 @@ static int esirisc_trace_analyze_full(struct command_context *cmd_ctx, uint8_t * case ESIRISC_TRACE_EXT_ID_STOP: case ESIRISC_TRACE_EXT_ID_WAIT: case ESIRISC_TRACE_EXT_ID_MULTICYCLE: - command_print(cmd_ctx, "%s", esirisc_trace_ext_id_strings[ext_id]); + command_print(cmd, "%s", esirisc_trace_ext_id_strings[ext_id]); break; case ESIRISC_TRACE_EXT_ID_ERET: @@ -430,11 +430,11 @@ static int esirisc_trace_analyze_full(struct command_context *cmd_ctx, uint8_t * if (retval != ERROR_OK) goto fail; - command_print(cmd_ctx, "%s PC: 0x%" PRIx32, + command_print(cmd, "%s PC: 0x%" PRIx32, esirisc_trace_ext_id_strings[ext_id], pc); if (ext_id == ESIRISC_TRACE_EXT_ID_END_PC) { - command_print(cmd_ctx, "--- end of trace ---"); + command_print(cmd, "--- end of trace ---"); return ERROR_OK; } break; @@ -450,7 +450,7 @@ static int esirisc_trace_analyze_full(struct command_context *cmd_ctx, uint8_t * if (retval != ERROR_OK) goto fail; - command_print(cmd_ctx, "%s EID: 0x%" PRIx32 ", EPC: 0x%" PRIx32, + command_print(cmd, "%s EID: 0x%" PRIx32 ", EPC: 0x%" PRIx32, esirisc_trace_ext_id_strings[ext_id], eid, epc); break; } @@ -461,34 +461,34 @@ static int esirisc_trace_analyze_full(struct command_context *cmd_ctx, uint8_t * if (retval != ERROR_OK) goto fail; - command_print(cmd_ctx, "repeats %" PRId32 " %s", count, + command_print(cmd, "repeats %" PRId32 " %s", count, (count == 1) ? "time" : "times"); break; } case ESIRISC_TRACE_EXT_ID_END: - command_print(cmd_ctx, "--- end of trace ---"); + command_print(cmd, "--- end of trace ---"); return ERROR_OK; default: - command_print(cmd_ctx, "invalid extended trace ID: %" PRId32, ext_id); + command_print(cmd, "invalid extended trace ID: %" PRId32, ext_id); return ERROR_FAIL; } break; } default: - command_print(cmd_ctx, "invalid trace ID: %" PRId32, id); + command_print(cmd, "invalid trace ID: %" PRId32, id); return ERROR_FAIL; } } fail: - command_print(cmd_ctx, "trace buffer too small"); + command_print(cmd, "trace buffer too small"); return ERROR_BUF_TOO_SMALL; } -static int esirisc_trace_analyze_simple(struct command_context *cmd_ctx, uint8_t *buffer, uint32_t size) +static int esirisc_trace_analyze_simple(struct command_invocation *cmd, uint8_t *buffer, uint32_t size) { - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd->ctx); struct esirisc_common *esirisc = target_to_esirisc(target); struct esirisc_trace *trace_info = &esirisc->trace_info; const uint32_t end_of_trace = BIT_MASK(trace_info->pc_bits) << 1; @@ -504,45 +504,45 @@ static int esirisc_trace_analyze_simple(struct command_context *cmd_ctx, uint8_t break; if (pc == end_of_trace) { - command_print(cmd_ctx, "--- end of trace ---"); + command_print(cmd, "--- end of trace ---"); return ERROR_OK; } - command_print(cmd_ctx, "PC: 0x%" PRIx32, pc); + command_print(cmd, "PC: 0x%" PRIx32, pc); } - command_print(cmd_ctx, "trace buffer too small"); + command_print(cmd, "trace buffer too small"); return ERROR_BUF_TOO_SMALL; } -static int esirisc_trace_analyze(struct command_context *cmd_ctx, uint8_t *buffer, uint32_t size) +static int esirisc_trace_analyze(struct command_invocation *cmd, uint8_t *buffer, uint32_t size) { - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd->ctx); struct esirisc_common *esirisc = target_to_esirisc(target); struct esirisc_trace *trace_info = &esirisc->trace_info; switch (trace_info->format) { case ESIRISC_TRACE_FORMAT_FULL: - command_print(cmd_ctx, "--- full pipeline ---"); - return esirisc_trace_analyze_full(cmd_ctx, buffer, size); + command_print(cmd, "--- full pipeline ---"); + return esirisc_trace_analyze_full(cmd, buffer, size); case ESIRISC_TRACE_FORMAT_BRANCH: - command_print(cmd_ctx, "--- branches taken ---"); - return esirisc_trace_analyze_full(cmd_ctx, buffer, size); + command_print(cmd, "--- branches taken ---"); + return esirisc_trace_analyze_full(cmd, buffer, size); case ESIRISC_TRACE_FORMAT_ICACHE: - command_print(cmd_ctx, "--- icache misses ---"); - return esirisc_trace_analyze_simple(cmd_ctx, buffer, size); + command_print(cmd, "--- icache misses ---"); + return esirisc_trace_analyze_simple(cmd, buffer, size); default: - command_print(cmd_ctx, "invalid trace format: %i", trace_info->format); + command_print(cmd, "invalid trace format: %i", trace_info->format); return ERROR_FAIL; } } -static int esirisc_trace_analyze_buffer(struct command_context *cmd_ctx) +static int esirisc_trace_analyze_buffer(struct command_invocation *cmd) { - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd->ctx); struct esirisc_common *esirisc = target_to_esirisc(target); struct esirisc_trace *trace_info = &esirisc->trace_info; uint8_t *buffer; @@ -552,7 +552,7 @@ static int esirisc_trace_analyze_buffer(struct command_context *cmd_ctx) size = esirisc_trace_buffer_size(trace_info); buffer = calloc(1, size); if (buffer == NULL) { - command_print(cmd_ctx, "out of memory"); + command_print(cmd, "out of memory"); return ERROR_FAIL; } @@ -560,7 +560,7 @@ static int esirisc_trace_analyze_buffer(struct command_context *cmd_ctx) if (retval != ERROR_OK) goto done; - retval = esirisc_trace_analyze(cmd_ctx, buffer, size); + retval = esirisc_trace_analyze(cmd, buffer, size); done: free(buffer); @@ -568,16 +568,16 @@ done: return retval; } -static int esirisc_trace_analyze_memory(struct command_context *cmd_ctx, +static int esirisc_trace_analyze_memory(struct command_invocation *cmd, target_addr_t address, uint32_t size) { - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd->ctx); uint8_t *buffer; int retval; buffer = calloc(1, size); if (buffer == NULL) { - command_print(cmd_ctx, "out of memory"); + command_print(cmd, "out of memory"); return ERROR_FAIL; } @@ -585,7 +585,7 @@ static int esirisc_trace_analyze_memory(struct command_context *cmd_ctx, if (retval != ERROR_OK) goto done; - retval = esirisc_trace_analyze(cmd_ctx, buffer, size); + retval = esirisc_trace_analyze(cmd, buffer, size); done: free(buffer); @@ -593,7 +593,7 @@ done: return retval; } -static int esirisc_trace_dump(struct command_context *cmd_ctx, const char *filename, +static int esirisc_trace_dump(struct command_invocation *cmd, const char *filename, uint8_t *buffer, uint32_t size) { struct fileio *fileio; @@ -602,24 +602,24 @@ static int esirisc_trace_dump(struct command_context *cmd_ctx, const char *filen retval = fileio_open(&fileio, filename, FILEIO_WRITE, FILEIO_BINARY); if (retval != ERROR_OK) { - command_print(cmd_ctx, "could not open dump file: %s", filename); + command_print(cmd, "could not open dump file: %s", filename); return retval; } retval = fileio_write(fileio, size, buffer, &size_written); if (retval == ERROR_OK) - command_print(cmd_ctx, "trace data dumped to: %s", filename); + command_print(cmd, "trace data dumped to: %s", filename); else - command_print(cmd_ctx, "could not write dump file: %s", filename); + command_print(cmd, "could not write dump file: %s", filename); fileio_close(fileio); return retval; } -static int esirisc_trace_dump_buffer(struct command_context *cmd_ctx, const char *filename) +static int esirisc_trace_dump_buffer(struct command_invocation *cmd, const char *filename) { - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd->ctx); struct esirisc_common *esirisc = target_to_esirisc(target); struct esirisc_trace *trace_info = &esirisc->trace_info; uint8_t *buffer; @@ -629,7 +629,7 @@ static int esirisc_trace_dump_buffer(struct command_context *cmd_ctx, const char size = esirisc_trace_buffer_size(trace_info); buffer = calloc(1, size); if (buffer == NULL) { - command_print(cmd_ctx, "out of memory"); + command_print(cmd, "out of memory"); return ERROR_FAIL; } @@ -637,7 +637,7 @@ static int esirisc_trace_dump_buffer(struct command_context *cmd_ctx, const char if (retval != ERROR_OK) goto done; - retval = esirisc_trace_dump(cmd_ctx, filename, buffer, size); + retval = esirisc_trace_dump(cmd, filename, buffer, size); done: free(buffer); @@ -645,16 +645,16 @@ done: return retval; } -static int esirisc_trace_dump_memory(struct command_context *cmd_ctx, const char *filename, +static int esirisc_trace_dump_memory(struct command_invocation *cmd, const char *filename, target_addr_t address, uint32_t size) { - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd->ctx); uint8_t *buffer; int retval; buffer = calloc(1, size); if (buffer == NULL) { - command_print(cmd_ctx, "out of memory"); + command_print(cmd, "out of memory"); return ERROR_FAIL; } @@ -662,7 +662,7 @@ static int esirisc_trace_dump_memory(struct command_context *cmd_ctx, const char if (retval != ERROR_OK) goto done; - retval = esirisc_trace_dump(cmd_ctx, filename, buffer, size); + retval = esirisc_trace_dump(cmd, filename, buffer, size); done: free(buffer); @@ -676,13 +676,13 @@ COMMAND_HANDLER(handle_esirisc_trace_init_command) struct esirisc_common *esirisc = target_to_esirisc(target); if (!esirisc->has_trace) { - command_print(CMD_CTX, "target does not support trace"); + command_print(CMD, "target does not support trace"); return ERROR_FAIL; } int retval = esirisc_trace_init(target); if (retval == ERROR_OK) - command_print(CMD_CTX, "trace initialized"); + command_print(CMD, "trace initialized"); return retval; } @@ -694,42 +694,42 @@ COMMAND_HANDLER(handle_esirisc_trace_info_command) struct esirisc_trace *trace_info = &esirisc->trace_info; if (!esirisc->has_trace) { - command_print(CMD_CTX, "target does not support trace"); + command_print(CMD, "target does not support trace"); return ERROR_FAIL; } if (esirisc_trace_is_fifo(trace_info)) - command_print(CMD_CTX, "trace FIFO address: 0x%" TARGET_PRIxADDR, + command_print(CMD, "trace FIFO address: 0x%" TARGET_PRIxADDR, trace_info->buffer_start); else { - command_print(CMD_CTX, "trace buffer start: 0x%" TARGET_PRIxADDR, + command_print(CMD, "trace buffer start: 0x%" TARGET_PRIxADDR, trace_info->buffer_start); - command_print(CMD_CTX, "trace buffer end: 0x%" TARGET_PRIxADDR, + command_print(CMD, "trace buffer end: 0x%" TARGET_PRIxADDR, trace_info->buffer_end); - command_print(CMD_CTX, "trace buffer will %swrap", + command_print(CMD, "trace buffer will %swrap", trace_info->buffer_wrap ? "" : "not "); } - command_print(CMD_CTX, "flow control: %s", + command_print(CMD, "flow control: %s", trace_info->flow_control ? "enabled" : "disabled"); - command_print(CMD_CTX, "trace format: %s", + command_print(CMD, "trace format: %s", esirisc_trace_format_strings[trace_info->format]); - command_print(CMD_CTX, "number of PC bits: %i", trace_info->pc_bits); + command_print(CMD, "number of PC bits: %i", trace_info->pc_bits); - command_print(CMD_CTX, "start trigger: %s", + command_print(CMD, "start trigger: %s", esirisc_trace_trigger_strings[trace_info->start_trigger]); - command_print(CMD_CTX, "start data: 0x%" PRIx32, trace_info->start_data); - command_print(CMD_CTX, "start mask: 0x%" PRIx32, trace_info->start_mask); + command_print(CMD, "start data: 0x%" PRIx32, trace_info->start_data); + command_print(CMD, "start mask: 0x%" PRIx32, trace_info->start_mask); - command_print(CMD_CTX, "stop trigger: %s", + command_print(CMD, "stop trigger: %s", esirisc_trace_trigger_strings[trace_info->stop_trigger]); - command_print(CMD_CTX, "stop data: 0x%" PRIx32, trace_info->stop_data); - command_print(CMD_CTX, "stop mask: 0x%" PRIx32, trace_info->stop_mask); + command_print(CMD, "stop data: 0x%" PRIx32, trace_info->stop_data); + command_print(CMD, "stop mask: 0x%" PRIx32, trace_info->stop_mask); - command_print(CMD_CTX, "trigger delay: %s", + command_print(CMD, "trigger delay: %s", esirisc_trace_delay_strings[trace_info->delay]); - command_print(CMD_CTX, "trigger delay cycles: %i", trace_info->delay_cycles); + command_print(CMD, "trigger delay cycles: %i", trace_info->delay_cycles); return ERROR_OK; } @@ -741,7 +741,7 @@ COMMAND_HANDLER(handle_esirisc_trace_status_command) uint32_t status; if (!esirisc->has_trace) { - command_print(CMD_CTX, "target does not support trace"); + command_print(CMD, "target does not support trace"); return ERROR_FAIL; } @@ -749,7 +749,7 @@ COMMAND_HANDLER(handle_esirisc_trace_status_command) if (retval != ERROR_OK) return retval; - command_print(CMD_CTX, "trace is %s%s%s%s", + command_print(CMD, "trace is %s%s%s%s", (status & STATUS_T) ? "started" : "stopped", (status & STATUS_TD) ? ", disabled" : "", (status & STATUS_W) ? ", wrapped" : "", @@ -764,13 +764,13 @@ COMMAND_HANDLER(handle_esirisc_trace_start_command) struct esirisc_common *esirisc = target_to_esirisc(target); if (!esirisc->has_trace) { - command_print(CMD_CTX, "target does not support trace"); + command_print(CMD, "target does not support trace"); return ERROR_FAIL; } int retval = esirisc_trace_start(target); if (retval == ERROR_OK) - command_print(CMD_CTX, "trace started"); + command_print(CMD, "trace started"); return retval; } @@ -781,13 +781,13 @@ COMMAND_HANDLER(handle_esirisc_trace_stop_command) struct esirisc_common *esirisc = target_to_esirisc(target); if (!esirisc->has_trace) { - command_print(CMD_CTX, "target does not support trace"); + command_print(CMD, "target does not support trace"); return ERROR_FAIL; } int retval = esirisc_trace_stop(target); if (retval == ERROR_OK) - command_print(CMD_CTX, "trace stopped"); + command_print(CMD, "trace stopped"); return retval; } @@ -801,7 +801,7 @@ COMMAND_HANDLER(handle_esirisc_trace_analyze_command) uint32_t size; if (!esirisc->has_trace) { - command_print(CMD_CTX, "target does not support trace"); + command_print(CMD, "target does not support trace"); return ERROR_FAIL; } @@ -817,16 +817,16 @@ COMMAND_HANDLER(handle_esirisc_trace_analyze_command) * as arguments as a workaround. */ if (esirisc_trace_is_fifo(trace_info)) { - command_print(CMD_CTX, "analyze from FIFO not supported"); + command_print(CMD, "analyze from FIFO not supported"); return ERROR_FAIL; } - return esirisc_trace_analyze_buffer(CMD_CTX); + return esirisc_trace_analyze_buffer(CMD); } else { COMMAND_PARSE_ADDRESS(CMD_ARGV[0], address); COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], size); - return esirisc_trace_analyze_memory(CMD_CTX, address, size); + return esirisc_trace_analyze_memory(CMD, address, size); } } @@ -839,7 +839,7 @@ COMMAND_HANDLER(handle_esirisc_trace_dump_command) uint32_t size; if (!esirisc->has_trace) { - command_print(CMD_CTX, "target does not support trace"); + command_print(CMD, "target does not support trace"); return ERROR_FAIL; } @@ -849,16 +849,16 @@ COMMAND_HANDLER(handle_esirisc_trace_dump_command) if (CMD_ARGC == 1) { /* also see: handle_esirisc_trace_analyze_command() */ if (esirisc_trace_is_fifo(trace_info)) { - command_print(CMD_CTX, "dump from FIFO not supported"); + command_print(CMD, "dump from FIFO not supported"); return ERROR_FAIL; } - return esirisc_trace_dump_buffer(CMD_CTX, CMD_ARGV[0]); + return esirisc_trace_dump_buffer(CMD, CMD_ARGV[0]); } else { COMMAND_PARSE_ADDRESS(CMD_ARGV[0], address); COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], size); - return esirisc_trace_dump_memory(CMD_CTX, CMD_ARGV[2], address, size); + return esirisc_trace_dump_memory(CMD, CMD_ARGV[2], address, size); } } @@ -946,7 +946,7 @@ COMMAND_HANDLER(handle_esirisc_trace_format_command) COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], pc_bits); if (pc_bits < 1 || pc_bits > 31) { - command_print(CMD_CTX, "invalid pc_bits: %i; must be 1..31", pc_bits); + command_print(CMD, "invalid pc_bits: %i; must be 1..31", pc_bits); return ERROR_COMMAND_SYNTAX_ERROR; } diff --git a/src/target/etb.c b/src/target/etb.c index 98a90a5..392c6ad 100644 --- a/src/target/etb.c +++ b/src/target/etb.c @@ -344,13 +344,13 @@ COMMAND_HANDLER(handle_etb_config_command) arm = target_to_arm(target); if (!is_arm(arm)) { - command_print(CMD_CTX, "ETB: '%s' isn't an ARM", CMD_ARGV[0]); + command_print(CMD, "ETB: '%s' isn't an ARM", CMD_ARGV[0]); return ERROR_FAIL; } tap = jtag_tap_by_string(CMD_ARGV[1]); if (tap == NULL) { - command_print(CMD_CTX, "ETB: TAP %s does not exist", CMD_ARGV[1]); + command_print(CMD, "ETB: TAP %s does not exist", CMD_ARGV[1]); return ERROR_FAIL; } @@ -382,17 +382,17 @@ COMMAND_HANDLER(handle_etb_trigger_percent_command) target = get_current_target(CMD_CTX); arm = target_to_arm(target); if (!is_arm(arm)) { - command_print(CMD_CTX, "ETB: current target isn't an ARM"); + command_print(CMD, "ETB: current target isn't an ARM"); return ERROR_FAIL; } etm = arm->etm; if (!etm) { - command_print(CMD_CTX, "ETB: target has no ETM configured"); + command_print(CMD, "ETB: target has no ETM configured"); return ERROR_FAIL; } if (etm->capture_driver != &etb_capture_driver) { - command_print(CMD_CTX, "ETB: target not using ETB"); + command_print(CMD, "ETB: target not using ETB"); return ERROR_FAIL; } etb = arm->etm->capture_driver_priv; @@ -402,13 +402,13 @@ COMMAND_HANDLER(handle_etb_trigger_percent_command) COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], new_value); if ((new_value < 2) || (new_value > 100)) - command_print(CMD_CTX, + command_print(CMD, "valid percentages are 2%% to 100%%"); else etb->trigger_percent = (unsigned) new_value; } - command_print(CMD_CTX, "%d percent of tracebuffer fills after trigger", + command_print(CMD, "%d percent of tracebuffer fills after trigger", etb->trigger_percent); return ERROR_OK; @@ -441,6 +441,7 @@ static const struct command_registration etb_command_handlers[] = { .mode = COMMAND_ANY, .help = "Embedded Trace Buffer command group", .chain = etb_config_command_handlers, + .usage = "", }, COMMAND_REGISTRATION_DONE }; diff --git a/src/target/etm.c b/src/target/etm.c index 6a00c23..5751348 100644 --- a/src/target/etm.c +++ b/src/target/etm.c @@ -859,7 +859,7 @@ static int etmv1_data(struct etm_context *ctx, int size, uint32_t *data) return 0; } -static int etmv1_analyze_trace(struct etm_context *ctx, struct command_context *cmd_ctx) +static int etmv1_analyze_trace(struct etm_context *ctx, struct command_invocation *cmd) { int retval; struct arm_instruction instruction; @@ -869,7 +869,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_context * ctx->capture_driver->read_trace(ctx); if (ctx->trace_depth == 0) { - command_print(cmd_ctx, "Trace is empty."); + command_print(cmd, "Trace is empty."); return ERROR_OK; } @@ -893,7 +893,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_context * int current_pc_ok = ctx->pc_ok; if (ctx->trace_data[ctx->pipe_index].flags & ETMV1_TRIGGER_CYCLE) - command_print(cmd_ctx, "--- trigger ---"); + command_print(cmd, "--- trigger ---"); /* instructions execute in IE/D or BE/D cycles */ if ((pipestat == STAT_IE) || (pipestat == STAT_ID)) @@ -942,7 +942,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_context * next_pc = ctx->last_branch; break; case 0x1: /* tracing enabled */ - command_print(cmd_ctx, + command_print(cmd, "--- tracing enabled at 0x%8.8" PRIx32 " ---", ctx->last_branch); ctx->current_pc = ctx->last_branch; @@ -950,7 +950,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_context * continue; break; case 0x2: /* trace restarted after FIFO overflow */ - command_print(cmd_ctx, + command_print(cmd, "--- trace restarted after FIFO overflow at 0x%8.8" PRIx32 " ---", ctx->last_branch); ctx->current_pc = ctx->last_branch; @@ -958,7 +958,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_context * continue; break; case 0x3: /* exit from debug state */ - command_print(cmd_ctx, + command_print(cmd, "--- exit from debug state at 0x%8.8" PRIx32 " ---", ctx->last_branch); ctx->current_pc = ctx->last_branch; @@ -971,7 +971,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_context * * we have to move on with the next trace cycle */ if (!current_pc_ok) { - command_print(cmd_ctx, + command_print(cmd, "--- periodic synchronization point at 0x%8.8" PRIx32 " ---", next_pc); ctx->current_pc = next_pc; @@ -998,9 +998,9 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_context * || ((ctx->last_branch >= 0xffff0000) && (ctx->last_branch <= 0xffff0020))) { if ((ctx->last_branch & 0xff) == 0x10) - command_print(cmd_ctx, "data abort"); + command_print(cmd, "data abort"); else { - command_print(cmd_ctx, + command_print(cmd, "exception vector 0x%2.2" PRIx32 "", ctx->last_branch); ctx->current_pc = ctx->last_branch; @@ -1058,7 +1058,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_context * ctx->ptr_ok = 1; if (ctx->ptr_ok) - command_print(cmd_ctx, + command_print(cmd, "address: 0x%8.8" PRIx32 "", ctx->last_ptr); } @@ -1073,7 +1073,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_context * uint32_t data; if (etmv1_data(ctx, 4, &data) != 0) return ERROR_ETM_ANALYSIS_FAILED; - command_print(cmd_ctx, + command_print(cmd, "data: 0x%8.8" PRIx32 "", data); } @@ -1084,7 +1084,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_context * if (etmv1_data(ctx, arm_access_size(&instruction), &data) != 0) return ERROR_ETM_ANALYSIS_FAILED; - command_print(cmd_ctx, "data: 0x%8.8" PRIx32 "", data); + command_print(cmd, "data: 0x%8.8" PRIx32 "", data); } } @@ -1119,7 +1119,7 @@ static int etmv1_analyze_trace(struct etm_context *ctx, struct command_context * (cycles == 1) ? "cycle" : "cycles"); } - command_print(cmd_ctx, "%s%s%s", + command_print(cmd, "%s%s%s", instruction.text, (pipestat == STAT_IN) ? " (not executed)" : "", cycles_text); @@ -1156,7 +1156,7 @@ static COMMAND_HELPER(handle_etm_tracemode_command_update, else if (strcmp(CMD_ARGV[0], "all") == 0) tracemode = ETM_CTRL_TRACE_DATA | ETM_CTRL_TRACE_ADDR; else { - command_print(CMD_CTX, "invalid option '%s'", CMD_ARGV[0]); + command_print(CMD, "invalid option '%s'", CMD_ARGV[0]); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1176,7 +1176,7 @@ static COMMAND_HELPER(handle_etm_tracemode_command_update, tracemode |= ETM_CTRL_CONTEXTID_32; break; default: - command_print(CMD_CTX, "invalid option '%s'", CMD_ARGV[1]); + command_print(CMD, "invalid option '%s'", CMD_ARGV[1]); return ERROR_COMMAND_SYNTAX_ERROR; } @@ -1207,13 +1207,13 @@ COMMAND_HANDLER(handle_etm_tracemode_command) struct etm_context *etm; if (!is_arm(arm)) { - command_print(CMD_CTX, "ETM: current target isn't an ARM"); + command_print(CMD, "ETM: current target isn't an ARM"); return ERROR_FAIL; } etm = arm->etm; if (!etm) { - command_print(CMD_CTX, "current target doesn't have an ETM configured"); + command_print(CMD, "current target doesn't have an ETM configured"); return ERROR_FAIL; } @@ -1235,47 +1235,47 @@ COMMAND_HANDLER(handle_etm_tracemode_command) * or couldn't be written; display actual hardware state... */ - command_print(CMD_CTX, "current tracemode configuration:"); + command_print(CMD, "current tracemode configuration:"); switch (tracemode & ETM_CTRL_TRACE_MASK) { default: - command_print(CMD_CTX, "data tracing: none"); + command_print(CMD, "data tracing: none"); break; case ETM_CTRL_TRACE_DATA: - command_print(CMD_CTX, "data tracing: data only"); + command_print(CMD, "data tracing: data only"); break; case ETM_CTRL_TRACE_ADDR: - command_print(CMD_CTX, "data tracing: address only"); + command_print(CMD, "data tracing: address only"); break; case ETM_CTRL_TRACE_DATA | ETM_CTRL_TRACE_ADDR: - command_print(CMD_CTX, "data tracing: address and data"); + command_print(CMD, "data tracing: address and data"); break; } switch (tracemode & ETM_CTRL_CONTEXTID_MASK) { case ETM_CTRL_CONTEXTID_NONE: - command_print(CMD_CTX, "contextid tracing: none"); + command_print(CMD, "contextid tracing: none"); break; case ETM_CTRL_CONTEXTID_8: - command_print(CMD_CTX, "contextid tracing: 8 bit"); + command_print(CMD, "contextid tracing: 8 bit"); break; case ETM_CTRL_CONTEXTID_16: - command_print(CMD_CTX, "contextid tracing: 16 bit"); + command_print(CMD, "contextid tracing: 16 bit"); break; case ETM_CTRL_CONTEXTID_32: - command_print(CMD_CTX, "contextid tracing: 32 bit"); + command_print(CMD, "contextid tracing: 32 bit"); break; } if (tracemode & ETM_CTRL_CYCLE_ACCURATE) - command_print(CMD_CTX, "cycle-accurate tracing enabled"); + command_print(CMD, "cycle-accurate tracing enabled"); else - command_print(CMD_CTX, "cycle-accurate tracing disabled"); + command_print(CMD, "cycle-accurate tracing disabled"); if (tracemode & ETM_CTRL_BRANCH_OUTPUT) - command_print(CMD_CTX, "full branch address output enabled"); + command_print(CMD, "full branch address output enabled"); else - command_print(CMD_CTX, "full branch address output disabled"); + command_print(CMD, "full branch address output disabled"); #define TRACEMODE_MASK ( \ ETM_CTRL_CONTEXTID_MASK \ @@ -1331,7 +1331,7 @@ COMMAND_HANDLER(handle_etm_config_command) arm = target_to_arm(target); if (!is_arm(arm)) { - command_print(CMD_CTX, "target '%s' is '%s'; not an ARM", + command_print(CMD, "target '%s' is '%s'; not an ARM", target_name(target), target_type_name(target)); return ERROR_FAIL; @@ -1382,7 +1382,7 @@ COMMAND_HANDLER(handle_etm_config_command) portmode |= ETM_PORT_2BIT; break; default: - command_print(CMD_CTX, + command_print(CMD, "unsupported ETM port width '%s'", CMD_ARGV[1]); return ERROR_FAIL; } @@ -1394,7 +1394,7 @@ COMMAND_HANDLER(handle_etm_config_command) else if (strcmp("demultiplexed", CMD_ARGV[2]) == 0) portmode |= ETM_PORT_DEMUXED; else { - command_print(CMD_CTX, + command_print(CMD, "unsupported ETM port mode '%s', must be 'normal', 'multiplexed' or 'demultiplexed'", CMD_ARGV[2]); return ERROR_FAIL; @@ -1405,7 +1405,7 @@ COMMAND_HANDLER(handle_etm_config_command) else if (strcmp("full", CMD_ARGV[3]) == 0) portmode |= ETM_PORT_FULL_CLOCK; else { - command_print(CMD_CTX, + command_print(CMD, "unsupported ETM port clocking '%s', must be 'full' or 'half'", CMD_ARGV[3]); return ERROR_FAIL; @@ -1461,44 +1461,44 @@ COMMAND_HANDLER(handle_etm_info_command) target = get_current_target(CMD_CTX); arm = target_to_arm(target); if (!is_arm(arm)) { - command_print(CMD_CTX, "ETM: current target isn't an ARM"); + command_print(CMD, "ETM: current target isn't an ARM"); return ERROR_FAIL; } etm = arm->etm; if (!etm) { - command_print(CMD_CTX, "current target doesn't have an ETM configured"); + command_print(CMD, "current target doesn't have an ETM configured"); return ERROR_FAIL; } - command_print(CMD_CTX, "ETM v%d.%d", + command_print(CMD, "ETM v%d.%d", etm->bcd_vers >> 4, etm->bcd_vers & 0xf); - command_print(CMD_CTX, "pairs of address comparators: %i", + command_print(CMD, "pairs of address comparators: %i", (int) (etm->config >> 0) & 0x0f); - command_print(CMD_CTX, "data comparators: %i", + command_print(CMD, "data comparators: %i", (int) (etm->config >> 4) & 0x0f); - command_print(CMD_CTX, "memory map decoders: %i", + command_print(CMD, "memory map decoders: %i", (int) (etm->config >> 8) & 0x1f); - command_print(CMD_CTX, "number of counters: %i", + command_print(CMD, "number of counters: %i", (int) (etm->config >> 13) & 0x07); - command_print(CMD_CTX, "sequencer %spresent", + command_print(CMD, "sequencer %spresent", (int) (etm->config & (1 << 16)) ? "" : "not "); - command_print(CMD_CTX, "number of ext. inputs: %i", + command_print(CMD, "number of ext. inputs: %i", (int) (etm->config >> 17) & 0x07); - command_print(CMD_CTX, "number of ext. outputs: %i", + command_print(CMD, "number of ext. outputs: %i", (int) (etm->config >> 20) & 0x07); - command_print(CMD_CTX, "FIFO full %spresent", + command_print(CMD, "FIFO full %spresent", (int) (etm->config & (1 << 23)) ? "" : "not "); if (etm->bcd_vers < 0x20) - command_print(CMD_CTX, "protocol version: %i", + command_print(CMD, "protocol version: %i", (int) (etm->config >> 28) & 0x07); else { - command_print(CMD_CTX, + command_print(CMD, "coprocessor and memory access %ssupported", (etm->config & (1 << 26)) ? "" : "not "); - command_print(CMD_CTX, "trace start/stop %spresent", + command_print(CMD, "trace start/stop %spresent", (etm->config & (1 << 26)) ? "" : "not "); - command_print(CMD_CTX, "number of context comparators: %i", + command_print(CMD, "number of context comparators: %i", (int) (etm->config >> 24) & 0x03); } @@ -1549,30 +1549,30 @@ COMMAND_HANDLER(handle_etm_info_command) LOG_ERROR("Illegal max_port_size"); return ERROR_FAIL; } - command_print(CMD_CTX, "max. port size: %i", max_port_size); + command_print(CMD, "max. port size: %i", max_port_size); if (etm->bcd_vers < 0x30) { - command_print(CMD_CTX, "half-rate clocking %ssupported", + command_print(CMD, "half-rate clocking %ssupported", (config & (1 << 3)) ? "" : "not "); - command_print(CMD_CTX, "full-rate clocking %ssupported", + command_print(CMD, "full-rate clocking %ssupported", (config & (1 << 4)) ? "" : "not "); - command_print(CMD_CTX, "normal trace format %ssupported", + command_print(CMD, "normal trace format %ssupported", (config & (1 << 5)) ? "" : "not "); - command_print(CMD_CTX, "multiplex trace format %ssupported", + command_print(CMD, "multiplex trace format %ssupported", (config & (1 << 6)) ? "" : "not "); - command_print(CMD_CTX, "demultiplex trace format %ssupported", + command_print(CMD, "demultiplex trace format %ssupported", (config & (1 << 7)) ? "" : "not "); } else { /* REVISIT show which size and format are selected ... */ - command_print(CMD_CTX, "current port size %ssupported", + command_print(CMD, "current port size %ssupported", (config & (1 << 10)) ? "" : "not "); - command_print(CMD_CTX, "current trace format %ssupported", + command_print(CMD, "current trace format %ssupported", (config & (1 << 11)) ? "" : "not "); } if (etm->bcd_vers >= 0x21) - command_print(CMD_CTX, "fetch comparisons %ssupported", + command_print(CMD, "fetch comparisons %ssupported", (config & (1 << 17)) ? "not " : ""); - command_print(CMD_CTX, "FIFO full %ssupported", + command_print(CMD, "FIFO full %ssupported", (config & (1 << 8)) ? "" : "not "); return ERROR_OK; @@ -1588,13 +1588,13 @@ COMMAND_HANDLER(handle_etm_status_command) target = get_current_target(CMD_CTX); arm = target_to_arm(target); if (!is_arm(arm)) { - command_print(CMD_CTX, "ETM: current target isn't an ARM"); + command_print(CMD, "ETM: current target isn't an ARM"); return ERROR_FAIL; } etm = arm->etm; if (!etm) { - command_print(CMD_CTX, "current target doesn't have an ETM configured"); + command_print(CMD, "current target doesn't have an ETM configured"); return ERROR_FAIL; } @@ -1608,7 +1608,7 @@ COMMAND_HANDLER(handle_etm_status_command) if (etm_get_reg(reg) == ERROR_OK) { unsigned s = buf_get_u32(reg->value, 0, reg->size); - command_print(CMD_CTX, "etm: %s%s%s%s", + command_print(CMD, "etm: %s%s%s%s", /* bit(1) == progbit */ (etm->bcd_vers >= 0x12) ? ((s & (1 << 1)) @@ -1626,21 +1626,21 @@ COMMAND_HANDLER(handle_etm_status_command) /* Trace Port Driver status */ trace_status = etm->capture_driver->status(etm); if (trace_status == TRACE_IDLE) - command_print(CMD_CTX, "%s: idle", etm->capture_driver->name); + command_print(CMD, "%s: idle", etm->capture_driver->name); else { static char *completed = " completed"; static char *running = " is running"; static char *overflowed = ", overflowed"; static char *triggered = ", triggered"; - command_print(CMD_CTX, "%s: trace collection%s%s%s", + command_print(CMD, "%s: trace collection%s%s%s", etm->capture_driver->name, (trace_status & TRACE_RUNNING) ? running : completed, (trace_status & TRACE_OVERFLOWED) ? overflowed : "", (trace_status & TRACE_TRIGGERED) ? triggered : ""); if (etm->trace_depth > 0) { - command_print(CMD_CTX, "%i frames of trace data read", + command_print(CMD, "%i frames of trace data read", (int)(etm->trace_depth)); } } @@ -1660,20 +1660,20 @@ COMMAND_HANDLER(handle_etm_image_command) target = get_current_target(CMD_CTX); arm = target_to_arm(target); if (!is_arm(arm)) { - command_print(CMD_CTX, "ETM: current target isn't an ARM"); + command_print(CMD, "ETM: current target isn't an ARM"); return ERROR_FAIL; } etm_ctx = arm->etm; if (!etm_ctx) { - command_print(CMD_CTX, "current target doesn't have an ETM configured"); + command_print(CMD, "current target doesn't have an ETM configured"); return ERROR_FAIL; } if (etm_ctx->image) { image_close(etm_ctx->image); free(etm_ctx->image); - command_print(CMD_CTX, "previously loaded image found and closed"); + command_print(CMD, "previously loaded image found and closed"); } etm_ctx->image = malloc(sizeof(struct image)); @@ -1711,24 +1711,24 @@ COMMAND_HANDLER(handle_etm_dump_command) target = get_current_target(CMD_CTX); arm = target_to_arm(target); if (!is_arm(arm)) { - command_print(CMD_CTX, "ETM: current target isn't an ARM"); + command_print(CMD, "ETM: current target isn't an ARM"); return ERROR_FAIL; } etm_ctx = arm->etm; if (!etm_ctx) { - command_print(CMD_CTX, "current target doesn't have an ETM configured"); + command_print(CMD, "current target doesn't have an ETM configured"); return ERROR_FAIL; } if (etm_ctx->capture_driver->status == TRACE_IDLE) { - command_print(CMD_CTX, "trace capture wasn't enabled, no trace data captured"); + command_print(CMD, "trace capture wasn't enabled, no trace data captured"); return ERROR_OK; } if (etm_ctx->capture_driver->status(etm_ctx) & TRACE_RUNNING) { /* TODO: if on-the-fly capture is to be supported, this needs to be changed */ - command_print(CMD_CTX, "trace capture not completed"); + command_print(CMD, "trace capture not completed"); return ERROR_FAIL; } @@ -1768,18 +1768,18 @@ COMMAND_HANDLER(handle_etm_load_command) target = get_current_target(CMD_CTX); arm = target_to_arm(target); if (!is_arm(arm)) { - command_print(CMD_CTX, "ETM: current target isn't an ARM"); + command_print(CMD, "ETM: current target isn't an ARM"); return ERROR_FAIL; } etm_ctx = arm->etm; if (!etm_ctx) { - command_print(CMD_CTX, "current target doesn't have an ETM configured"); + command_print(CMD, "current target doesn't have an ETM configured"); return ERROR_FAIL; } if (etm_ctx->capture_driver->status(etm_ctx) & TRACE_RUNNING) { - command_print(CMD_CTX, "trace capture running, stop first"); + command_print(CMD, "trace capture running, stop first"); return ERROR_FAIL; } @@ -1794,7 +1794,7 @@ COMMAND_HANDLER(handle_etm_load_command) } if (filesize % 4) { - command_print(CMD_CTX, "size isn't a multiple of 4, no valid trace data"); + command_print(CMD, "size isn't a multiple of 4, no valid trace data"); fileio_close(file); return ERROR_FAIL; } @@ -1812,7 +1812,7 @@ COMMAND_HANDLER(handle_etm_load_command) } etm_ctx->trace_data = malloc(sizeof(struct etmv1_trace_data) * etm_ctx->trace_depth); if (etm_ctx->trace_data == NULL) { - command_print(CMD_CTX, "not enough memory to perform operation"); + command_print(CMD, "not enough memory to perform operation"); fileio_close(file); return ERROR_FAIL; } @@ -1842,13 +1842,13 @@ COMMAND_HANDLER(handle_etm_start_command) target = get_current_target(CMD_CTX); arm = target_to_arm(target); if (!is_arm(arm)) { - command_print(CMD_CTX, "ETM: current target isn't an ARM"); + command_print(CMD, "ETM: current target isn't an ARM"); return ERROR_FAIL; } etm_ctx = arm->etm; if (!etm_ctx) { - command_print(CMD_CTX, "current target doesn't have an ETM configured"); + command_print(CMD, "current target doesn't have an ETM configured"); return ERROR_FAIL; } @@ -1887,13 +1887,13 @@ COMMAND_HANDLER(handle_etm_stop_command) target = get_current_target(CMD_CTX); arm = target_to_arm(target); if (!is_arm(arm)) { - command_print(CMD_CTX, "ETM: current target isn't an ARM"); + command_print(CMD, "ETM: current target isn't an ARM"); return ERROR_FAIL; } etm_ctx = arm->etm; if (!etm_ctx) { - command_print(CMD_CTX, "current target doesn't have an ETM configured"); + command_print(CMD, "current target doesn't have an ETM configured"); return ERROR_FAIL; } @@ -1923,14 +1923,14 @@ COMMAND_HANDLER(handle_etm_trigger_debug_command) target = get_current_target(CMD_CTX); arm = target_to_arm(target); if (!is_arm(arm)) { - command_print(CMD_CTX, "ETM: %s isn't an ARM", + command_print(CMD, "ETM: %s isn't an ARM", target_name(target)); return ERROR_FAIL; } etm = arm->etm; if (!etm) { - command_print(CMD_CTX, "ETM: no ETM configured for %s", + command_print(CMD, "ETM: no ETM configured for %s", target_name(target)); return ERROR_FAIL; } @@ -1955,7 +1955,7 @@ COMMAND_HANDLER(handle_etm_trigger_debug_command) buf_set_u32(etm_ctrl_reg->value, 0, 32, etm->control); } - command_print(CMD_CTX, "ETM: %s debug halt", + command_print(CMD, "ETM: %s debug halt", (etm->control & ETM_CTRL_DBGRQ) ? "triggers" : "does not trigger"); @@ -1972,33 +1972,33 @@ COMMAND_HANDLER(handle_etm_analyze_command) target = get_current_target(CMD_CTX); arm = target_to_arm(target); if (!is_arm(arm)) { - command_print(CMD_CTX, "ETM: current target isn't an ARM"); + command_print(CMD, "ETM: current target isn't an ARM"); return ERROR_FAIL; } etm_ctx = arm->etm; if (!etm_ctx) { - command_print(CMD_CTX, "current target doesn't have an ETM configured"); + command_print(CMD, "current target doesn't have an ETM configured"); return ERROR_FAIL; } - retval = etmv1_analyze_trace(etm_ctx, CMD_CTX); + retval = etmv1_analyze_trace(etm_ctx, CMD); if (retval != ERROR_OK) { /* FIX! error should be reported inside etmv1_analyze_trace() */ switch (retval) { case ERROR_ETM_ANALYSIS_FAILED: - command_print(CMD_CTX, + command_print(CMD, "further analysis failed (corrupted trace data or just end of data"); break; case ERROR_TRACE_INSTRUCTION_UNAVAILABLE: - command_print(CMD_CTX, + command_print(CMD, "no instruction for current address available, analysis aborted"); break; case ERROR_TRACE_IMAGE_UNAVAILABLE: - command_print(CMD_CTX, "no image available for trace analysis"); + command_print(CMD, "no image available for trace analysis"); break; default: - command_print(CMD_CTX, "unknown error"); + command_print(CMD, "unknown error"); } } diff --git a/src/target/etm_dummy.c b/src/target/etm_dummy.c index b18ce17..ba53c7a 100644 --- a/src/target/etm_dummy.c +++ b/src/target/etm_dummy.c @@ -37,7 +37,7 @@ COMMAND_HANDLER(handle_etm_dummy_config_command) arm = target_to_arm(target); if (!is_arm(arm)) { - command_print(CMD_CTX, "target '%s' isn't an ARM", CMD_ARGV[0]); + command_print(CMD, "target '%s' isn't an ARM", CMD_ARGV[0]); return ERROR_FAIL; } @@ -66,6 +66,7 @@ static const struct command_registration etm_dummy_command_handlers[] = { .mode = COMMAND_ANY, .help = "Dummy ETM capture driver command group", .chain = etm_dummy_config_command_handlers, + .usage = "", }, COMMAND_REGISTRATION_DONE }; diff --git a/src/target/mem_ap.c b/src/target/mem_ap.c index 584e19d..29cd37a 100644 --- a/src/target/mem_ap.c +++ b/src/target/mem_ap.c @@ -140,7 +140,7 @@ static int mem_ap_read_memory(struct target *target, target_addr_t address, { struct mem_ap *mem_ap = target->arch_info; - LOG_DEBUG("Reading memory at physical address 0x" TARGET_ADDR_FMT + LOG_DEBUG("Reading memory at physical address " TARGET_ADDR_FMT "; size %" PRId32 "; count %" PRId32, address, size, count); if (count == 0 || buffer == NULL) @@ -155,7 +155,7 @@ static int mem_ap_write_memory(struct target *target, target_addr_t address, { struct mem_ap *mem_ap = target->arch_info; - LOG_DEBUG("Writing memory at physical address 0x" TARGET_ADDR_FMT + LOG_DEBUG("Writing memory at physical address " TARGET_ADDR_FMT "; size %" PRId32 "; count %" PRId32, address, size, count); if (count == 0 || buffer == NULL) diff --git a/src/target/mips32.c b/src/target/mips32.c index d9d8ba9..5260032 100644 --- a/src/target/mips32.c +++ b/src/target/mips32.c @@ -905,11 +905,11 @@ cleanup: return 1; /* only one block has been checked */ } -static int mips32_verify_pointer(struct command_context *cmd_ctx, +static int mips32_verify_pointer(struct command_invocation *cmd, struct mips32_common *mips32) { if (mips32->common_magic != MIPS32_COMMON_MAGIC) { - command_print(cmd_ctx, "target is not an MIPS32"); + command_print(cmd, "target is not an MIPS32"); return ERROR_TARGET_INVALID; } return ERROR_OK; @@ -927,12 +927,12 @@ COMMAND_HANDLER(mips32_handle_cp0_command) struct mips_ejtag *ejtag_info = &mips32->ejtag_info; - retval = mips32_verify_pointer(CMD_CTX, mips32); + retval = mips32_verify_pointer(CMD, mips32); if (retval != ERROR_OK) return retval; if (target->state != TARGET_HALTED) { - command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME); + command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME); return ERROR_OK; } @@ -949,12 +949,12 @@ COMMAND_HANDLER(mips32_handle_cp0_command) retval = mips32_cp0_read(ejtag_info, &value, cp0_reg, cp0_sel); if (retval != ERROR_OK) { - command_print(CMD_CTX, + command_print(CMD, "couldn't access reg %" PRIi32, cp0_reg); return ERROR_OK; } - command_print(CMD_CTX, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32, + command_print(CMD, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32, cp0_reg, cp0_sel, value); } else if (CMD_ARGC == 3) { @@ -962,12 +962,12 @@ COMMAND_HANDLER(mips32_handle_cp0_command) COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], value); retval = mips32_cp0_write(ejtag_info, value, cp0_reg, cp0_sel); if (retval != ERROR_OK) { - command_print(CMD_CTX, + command_print(CMD, "couldn't access cp0 reg %" PRIi32 ", select %" PRIi32, cp0_reg, cp0_sel); return ERROR_OK; } - command_print(CMD_CTX, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32, + command_print(CMD, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32, cp0_reg, cp0_sel, value); } } @@ -986,13 +986,13 @@ COMMAND_HANDLER(mips32_handle_scan_delay_command) else if (CMD_ARGC > 1) return ERROR_COMMAND_SYNTAX_ERROR; - command_print(CMD_CTX, "scan delay: %d nsec", ejtag_info->scan_delay); + command_print(CMD, "scan delay: %d nsec", ejtag_info->scan_delay); if (ejtag_info->scan_delay >= MIPS32_SCAN_DELAY_LEGACY_MODE) { ejtag_info->mode = 0; - command_print(CMD_CTX, "running in legacy mode"); + command_print(CMD, "running in legacy mode"); } else { ejtag_info->mode = 1; - command_print(CMD_CTX, "running in fast queued mode"); + command_print(CMD, "running in fast queued mode"); } return ERROR_OK; diff --git a/src/target/mips_m4k.c b/src/target/mips_m4k.c index 653d732..ad27520 100644 --- a/src/target/mips_m4k.c +++ b/src/target/mips_m4k.c @@ -1270,11 +1270,11 @@ static int mips_m4k_bulk_write_memory(struct target *target, target_addr_t addre return retval; } -static int mips_m4k_verify_pointer(struct command_context *cmd_ctx, +static int mips_m4k_verify_pointer(struct command_invocation *cmd, struct mips_m4k_common *mips_m4k) { if (mips_m4k->common_magic != MIPSM4K_COMMON_MAGIC) { - command_print(cmd_ctx, "target is not an MIPS_M4K"); + command_print(cmd, "target is not an MIPS_M4K"); return ERROR_TARGET_INVALID; } return ERROR_OK; @@ -1287,12 +1287,12 @@ COMMAND_HANDLER(mips_m4k_handle_cp0_command) struct mips_m4k_common *mips_m4k = target_to_m4k(target); struct mips_ejtag *ejtag_info = &mips_m4k->mips32.ejtag_info; - retval = mips_m4k_verify_pointer(CMD_CTX, mips_m4k); + retval = mips_m4k_verify_pointer(CMD, mips_m4k); if (retval != ERROR_OK) return retval; if (target->state != TARGET_HALTED) { - command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME); + command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME); return ERROR_OK; } @@ -1308,12 +1308,12 @@ COMMAND_HANDLER(mips_m4k_handle_cp0_command) uint32_t value; retval = mips32_cp0_read(ejtag_info, &value, cp0_reg, cp0_sel); if (retval != ERROR_OK) { - command_print(CMD_CTX, + command_print(CMD, "couldn't access reg %" PRIi32, cp0_reg); return ERROR_OK; } - command_print(CMD_CTX, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32, + command_print(CMD, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32, cp0_reg, cp0_sel, value); } else if (CMD_ARGC == 3) { @@ -1321,12 +1321,12 @@ COMMAND_HANDLER(mips_m4k_handle_cp0_command) COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], value); retval = mips32_cp0_write(ejtag_info, value, cp0_reg, cp0_sel); if (retval != ERROR_OK) { - command_print(CMD_CTX, + command_print(CMD, "couldn't access cp0 reg %" PRIi32 ", select %" PRIi32, cp0_reg, cp0_sel); return ERROR_OK; } - command_print(CMD_CTX, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32, + command_print(CMD, "cp0 reg %" PRIi32 ", select %" PRIi32 ": %8.8" PRIx32, cp0_reg, cp0_sel, value); } } @@ -1345,13 +1345,13 @@ COMMAND_HANDLER(mips_m4k_handle_scan_delay_command) else if (CMD_ARGC > 1) return ERROR_COMMAND_SYNTAX_ERROR; - command_print(CMD_CTX, "scan delay: %d nsec", ejtag_info->scan_delay); + command_print(CMD, "scan delay: %d nsec", ejtag_info->scan_delay); if (ejtag_info->scan_delay >= MIPS32_SCAN_DELAY_LEGACY_MODE) { ejtag_info->mode = 0; - command_print(CMD_CTX, "running in legacy mode"); + command_print(CMD, "running in legacy mode"); } else { ejtag_info->mode = 1; - command_print(CMD_CTX, "running in fast queued mode"); + command_print(CMD, "running in fast queued mode"); } return ERROR_OK; diff --git a/src/target/nds32_cmd.c b/src/target/nds32_cmd.c index 500651d..1accf6f 100644 --- a/src/target/nds32_cmd.c +++ b/src/target/nds32_cmd.c @@ -46,7 +46,7 @@ COMMAND_HANDLER(handle_nds32_dssim_command) struct nds32 *nds32 = target_to_nds32(target); if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } @@ -57,7 +57,7 @@ COMMAND_HANDLER(handle_nds32_dssim_command) nds32->step_isr_enable = false; } - command_print(CMD_CTX, "%s: $INT_MASK.DSSIM: %d", target_name(target), + command_print(CMD, "%s: $INT_MASK.DSSIM: %d", target_name(target), nds32->step_isr_enable); return ERROR_OK; @@ -71,7 +71,7 @@ COMMAND_HANDLER(handle_nds32_memory_access_command) struct nds32_memory *memory = &(nds32->memory); if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } @@ -88,7 +88,7 @@ COMMAND_HANDLER(handle_nds32_memory_access_command) aice_memory_access(aice, memory->access_channel); } else { - command_print(CMD_CTX, "%s: memory access channel: %s", + command_print(CMD, "%s: memory access channel: %s", target_name(target), NDS_MEMORY_ACCESS_NAME[memory->access_channel]); } @@ -103,18 +103,18 @@ COMMAND_HANDLER(handle_nds32_memory_mode_command) struct aice_port_s *aice = target_to_aice(target); if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } if (CMD_ARGC > 0) { if (nds32->edm.access_control == false) { - command_print(CMD_CTX, "%s does not support ACC_CTL. " + command_print(CMD, "%s does not support ACC_CTL. " "Set memory mode to MEMORY", target_name(target)); nds32->memory.mode = NDS_MEMORY_SELECT_MEM; } else if (nds32->edm.direct_access_local_memory == false) { - command_print(CMD_CTX, "%s does not support direct access " + command_print(CMD, "%s does not support direct access " "local memory. Set memory mode to MEMORY", target_name(target)); nds32->memory.mode = NDS_MEMORY_SELECT_MEM; @@ -128,13 +128,13 @@ COMMAND_HANDLER(handle_nds32_memory_mode_command) nds32->memory.mode = NDS_MEMORY_SELECT_MEM; } else if (strcmp(CMD_ARGV[0], "ilm") == 0) { if (nds32->memory.ilm_base == 0) - command_print(CMD_CTX, "%s does not support ILM", + command_print(CMD, "%s does not support ILM", target_name(target)); else nds32->memory.mode = NDS_MEMORY_SELECT_ILM; } else if (strcmp(CMD_ARGV[0], "dlm") == 0) { if (nds32->memory.dlm_base == 0) - command_print(CMD_CTX, "%s does not support DLM", + command_print(CMD, "%s does not support DLM", target_name(target)); else nds32->memory.mode = NDS_MEMORY_SELECT_DLM; @@ -145,7 +145,7 @@ COMMAND_HANDLER(handle_nds32_memory_mode_command) } } - command_print(CMD_CTX, "%s: memory mode: %s", + command_print(CMD, "%s: memory mode: %s", target_name(target), NDS_MEMORY_SELECT_NAME[nds32->memory.mode]); @@ -162,7 +162,7 @@ COMMAND_HANDLER(handle_nds32_cache_command) int result; if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } @@ -173,30 +173,30 @@ COMMAND_HANDLER(handle_nds32_cache_command) /* D$ write back */ result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1D_WBALL, 0); if (result != ERROR_OK) { - command_print(CMD_CTX, "%s: Write back data cache...failed", + command_print(CMD, "%s: Write back data cache...failed", target_name(target)); return result; } - command_print(CMD_CTX, "%s: Write back data cache...done", + command_print(CMD, "%s: Write back data cache...done", target_name(target)); /* D$ invalidate */ result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1D_INVALALL, 0); if (result != ERROR_OK) { - command_print(CMD_CTX, "%s: Invalidate data cache...failed", + command_print(CMD, "%s: Invalidate data cache...failed", target_name(target)); return result; } - command_print(CMD_CTX, "%s: Invalidate data cache...done", + command_print(CMD, "%s: Invalidate data cache...done", target_name(target)); } else { if (dcache->line_size == 0) - command_print(CMD_CTX, "%s: No data cache", + command_print(CMD, "%s: No data cache", target_name(target)); else - command_print(CMD_CTX, "%s: Data cache disabled", + command_print(CMD, "%s: Data cache disabled", target_name(target)); } @@ -204,23 +204,23 @@ COMMAND_HANDLER(handle_nds32_cache_command) /* I$ invalidate */ result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1I_INVALALL, 0); if (result != ERROR_OK) { - command_print(CMD_CTX, "%s: Invalidate instruction cache...failed", + command_print(CMD, "%s: Invalidate instruction cache...failed", target_name(target)); return result; } - command_print(CMD_CTX, "%s: Invalidate instruction cache...done", + command_print(CMD, "%s: Invalidate instruction cache...done", target_name(target)); } else { if (icache->line_size == 0) - command_print(CMD_CTX, "%s: No instruction cache", + command_print(CMD, "%s: No instruction cache", target_name(target)); else - command_print(CMD_CTX, "%s: Instruction cache disabled", + command_print(CMD, "%s: Instruction cache disabled", target_name(target)); } } else - command_print(CMD_CTX, "No valid parameter"); + command_print(CMD, "No valid parameter"); } return ERROR_OK; @@ -235,14 +235,14 @@ COMMAND_HANDLER(handle_nds32_icache_command) int result; if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } if (CMD_ARGC > 0) { if (icache->line_size == 0) { - command_print(CMD_CTX, "%s: No instruction cache", + command_print(CMD, "%s: No instruction cache", target_name(target)); return ERROR_OK; } @@ -252,15 +252,15 @@ COMMAND_HANDLER(handle_nds32_icache_command) /* I$ invalidate */ result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1I_INVALALL, 0); if (result != ERROR_OK) { - command_print(CMD_CTX, "%s: Invalidate instruction cache...failed", + command_print(CMD, "%s: Invalidate instruction cache...failed", target_name(target)); return result; } - command_print(CMD_CTX, "%s: Invalidate instruction cache...done", + command_print(CMD, "%s: Invalidate instruction cache...done", target_name(target)); } else { - command_print(CMD_CTX, "%s: Instruction cache disabled", + command_print(CMD, "%s: Instruction cache disabled", target_name(target)); } } else if (strcmp(CMD_ARGV[0], "enable") == 0) { @@ -274,7 +274,7 @@ COMMAND_HANDLER(handle_nds32_icache_command) } else if (strcmp(CMD_ARGV[0], "dump") == 0) { /* TODO: dump cache content */ } else { - command_print(CMD_CTX, "%s: No valid parameter", target_name(target)); + command_print(CMD, "%s: No valid parameter", target_name(target)); } } @@ -290,14 +290,14 @@ COMMAND_HANDLER(handle_nds32_dcache_command) int result; if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } if (CMD_ARGC > 0) { if (dcache->line_size == 0) { - command_print(CMD_CTX, "%s: No data cache", target_name(target)); + command_print(CMD, "%s: No data cache", target_name(target)); return ERROR_OK; } @@ -306,26 +306,26 @@ COMMAND_HANDLER(handle_nds32_dcache_command) /* D$ write back */ result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1D_WBALL, 0); if (result != ERROR_OK) { - command_print(CMD_CTX, "%s: Write back data cache...failed", + command_print(CMD, "%s: Write back data cache...failed", target_name(target)); return result; } - command_print(CMD_CTX, "%s: Write back data cache...done", + command_print(CMD, "%s: Write back data cache...done", target_name(target)); /* D$ invalidate */ result = aice_cache_ctl(aice, AICE_CACHE_CTL_L1D_INVALALL, 0); if (result != ERROR_OK) { - command_print(CMD_CTX, "%s: Invalidate data cache...failed", + command_print(CMD, "%s: Invalidate data cache...failed", target_name(target)); return result; } - command_print(CMD_CTX, "%s: Invalidate data cache...done", + command_print(CMD, "%s: Invalidate data cache...done", target_name(target)); } else { - command_print(CMD_CTX, "%s: Data cache disabled", + command_print(CMD, "%s: Data cache disabled", target_name(target)); } } else if (strcmp(CMD_ARGV[0], "enable") == 0) { @@ -339,7 +339,7 @@ COMMAND_HANDLER(handle_nds32_dcache_command) } else if (strcmp(CMD_ARGV[0], "dump") == 0) { /* TODO: dump cache content */ } else { - command_print(CMD_CTX, "%s: No valid parameter", target_name(target)); + command_print(CMD, "%s: No valid parameter", target_name(target)); } } @@ -352,7 +352,7 @@ COMMAND_HANDLER(handle_nds32_auto_break_command) struct nds32 *nds32 = target_to_nds32(target); if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } @@ -364,10 +364,10 @@ COMMAND_HANDLER(handle_nds32_auto_break_command) } if (nds32->auto_convert_hw_bp) - command_print(CMD_CTX, "%s: convert sw break to hw break on ROM: on", + command_print(CMD, "%s: convert sw break to hw break on ROM: on", target_name(target)); else - command_print(CMD_CTX, "%s: convert sw break to hw break on ROM: off", + command_print(CMD, "%s: convert sw break to hw break on ROM: off", target_name(target)); return ERROR_OK; @@ -379,7 +379,7 @@ COMMAND_HANDLER(handle_nds32_virtual_hosting_command) struct nds32 *nds32 = target_to_nds32(target); if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } @@ -391,9 +391,9 @@ COMMAND_HANDLER(handle_nds32_virtual_hosting_command) } if (nds32->virtual_hosting) - command_print(CMD_CTX, "%s: virtual hosting: on", target_name(target)); + command_print(CMD, "%s: virtual hosting: on", target_name(target)); else - command_print(CMD_CTX, "%s: virtual hosting: off", target_name(target)); + command_print(CMD, "%s: virtual hosting: off", target_name(target)); return ERROR_OK; } @@ -404,7 +404,7 @@ COMMAND_HANDLER(handle_nds32_global_stop_command) struct nds32 *nds32 = target_to_nds32(target); if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } @@ -429,7 +429,7 @@ COMMAND_HANDLER(handle_nds32_soft_reset_halt_command) struct nds32 *nds32 = target_to_nds32(target); if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } @@ -454,7 +454,7 @@ COMMAND_HANDLER(handle_nds32_boot_time_command) struct nds32 *nds32 = target_to_nds32(target); if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } @@ -470,7 +470,7 @@ COMMAND_HANDLER(handle_nds32_login_edm_passcode_command) struct nds32 *nds32 = target_to_nds32(target); if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } @@ -485,7 +485,7 @@ COMMAND_HANDLER(handle_nds32_login_edm_operation_command) struct nds32 *nds32 = target_to_nds32(target); if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } @@ -516,7 +516,7 @@ COMMAND_HANDLER(handle_nds32_reset_halt_as_init_command) struct nds32 *nds32 = target_to_nds32(target); if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } @@ -536,7 +536,7 @@ COMMAND_HANDLER(handle_nds32_keep_target_edm_ctl_command) struct nds32 *nds32 = target_to_nds32(target); if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } @@ -556,7 +556,7 @@ COMMAND_HANDLER(handle_nds32_decode_command) struct nds32 *nds32 = target_to_nds32(target); if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } @@ -581,7 +581,7 @@ COMMAND_HANDLER(handle_nds32_decode_command) read_addr, &instruction)) return ERROR_FAIL; - command_print(CMD_CTX, "%s", instruction.text); + command_print(CMD, "%s", instruction.text); read_addr += instruction.instruction_size; i++; @@ -599,7 +599,7 @@ COMMAND_HANDLER(handle_nds32_decode_command) if (ERROR_OK != nds32_evaluate_opcode(nds32, opcode, addr, &instruction)) return ERROR_FAIL; - command_print(CMD_CTX, "%s", instruction.text); + command_print(CMD, "%s", instruction.text); } else return ERROR_FAIL; @@ -612,7 +612,7 @@ COMMAND_HANDLER(handle_nds32_word_access_mem_command) struct nds32 *nds32 = target_to_nds32(target); if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } @@ -632,11 +632,11 @@ COMMAND_HANDLER(handle_nds32_query_target_command) struct nds32 *nds32 = target_to_nds32(target); if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } - command_print(CMD_CTX, "OCD"); + command_print(CMD, "OCD"); return ERROR_OK; } @@ -647,7 +647,7 @@ COMMAND_HANDLER(handle_nds32_query_endian_command) struct nds32 *nds32 = target_to_nds32(target); if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } @@ -655,9 +655,9 @@ COMMAND_HANDLER(handle_nds32_query_endian_command) nds32_get_mapped_reg(nds32, IR0, &value_psw); if (value_psw & 0x20) - command_print(CMD_CTX, "%s: BE", target_name(target)); + command_print(CMD, "%s: BE", target_name(target)); else - command_print(CMD_CTX, "%s: LE", target_name(target)); + command_print(CMD, "%s: LE", target_name(target)); return ERROR_OK; } @@ -668,11 +668,11 @@ COMMAND_HANDLER(handle_nds32_query_cpuid_command) struct nds32 *nds32 = target_to_nds32(target); if (!is_nds32(nds32)) { - command_print(CMD_CTX, "current target isn't an Andes core"); + command_print(CMD, "current target isn't an Andes core"); return ERROR_FAIL; } - command_print(CMD_CTX, "CPUID: %s", target_name(target)); + command_print(CMD, "CPUID: %s", target_name(target)); return ERROR_OK; } diff --git a/src/target/oocd_trace.c b/src/target/oocd_trace.c index 627366d..f38916a 100644 --- a/src/target/oocd_trace.c +++ b/src/target/oocd_trace.c @@ -277,7 +277,7 @@ COMMAND_HANDLER(handle_oocd_trace_config_command) target = get_current_target(CMD_CTX); arm = target_to_arm(target); if (!is_arm(arm)) { - command_print(CMD_CTX, "current target isn't an ARM"); + command_print(CMD, "current target isn't an ARM"); return ERROR_FAIL; } @@ -306,17 +306,17 @@ COMMAND_HANDLER(handle_oocd_trace_status_command) arm = target_to_arm(target); if (!is_arm(arm)) { - command_print(CMD_CTX, "current target isn't an ARM"); + command_print(CMD, "current target isn't an ARM"); return ERROR_FAIL; } if (!arm->etm) { - command_print(CMD_CTX, "current target doesn't have an ETM configured"); + command_print(CMD, "current target doesn't have an ETM configured"); return ERROR_FAIL; } if (strcmp(arm->etm->capture_driver->name, "oocd_trace") != 0) { - command_print(CMD_CTX, "current target's ETM capture driver isn't 'oocd_trace'"); + command_print(CMD, "current target's ETM capture driver isn't 'oocd_trace'"); return ERROR_FAIL; } @@ -325,9 +325,9 @@ COMMAND_HANDLER(handle_oocd_trace_status_command) oocd_trace_read_reg(oocd_trace, OOCD_TRACE_STATUS, &status); if (status & 0x8) - command_print(CMD_CTX, "trace clock locked"); + command_print(CMD, "trace clock locked"); else - command_print(CMD_CTX, "no trace clock"); + command_print(CMD, "no trace clock"); return ERROR_OK; } @@ -344,17 +344,17 @@ COMMAND_HANDLER(handle_oocd_trace_resync_command) arm = target_to_arm(target); if (!is_arm(arm)) { - command_print(CMD_CTX, "current target isn't an ARM"); + command_print(CMD, "current target isn't an ARM"); return ERROR_FAIL; } if (!arm->etm) { - command_print(CMD_CTX, "current target doesn't have an ETM configured"); + command_print(CMD, "current target doesn't have an ETM configured"); return ERROR_FAIL; } if (strcmp(arm->etm->capture_driver->name, "oocd_trace") != 0) { - command_print(CMD_CTX, "current target's ETM capture driver isn't 'oocd_trace'"); + command_print(CMD, "current target's ETM capture driver isn't 'oocd_trace'"); return ERROR_FAIL; } @@ -366,7 +366,7 @@ COMMAND_HANDLER(handle_oocd_trace_resync_command) if (bytes_written < 1) return ERROR_FAIL; - command_print(CMD_CTX, "requesting traceclock resync"); + command_print(CMD, "requesting traceclock resync"); LOG_DEBUG("resyncing traceclk pll"); return ERROR_OK; diff --git a/src/target/openrisc/or1k.c b/src/target/openrisc/or1k.c index 34b1b07..1e5db8c 100644 --- a/src/target/openrisc/or1k.c +++ b/src/target/openrisc/or1k.c @@ -1291,7 +1291,7 @@ COMMAND_HANDLER(or1k_tap_list_command_handler) list_for_each_entry(or1k_tap, &tap_list, list) { if (or1k_tap->name) - command_print(CMD_CTX, "%s", or1k_tap->name); + command_print(CMD, "%s", or1k_tap->name); } return ERROR_OK; @@ -1339,7 +1339,7 @@ COMMAND_HANDLER(or1k_du_list_command_handler) list_for_each_entry(or1k_du, &du_list, list) { if (or1k_du->name) - command_print(CMD_CTX, "%s", or1k_du->name); + command_print(CMD, "%s", or1k_du->name); } return ERROR_OK; @@ -1374,28 +1374,28 @@ COMMAND_HANDLER(or1k_addreg_command_handler) static const struct command_registration or1k_hw_ip_command_handlers[] = { { - "tap_select", + .name = "tap_select", .handler = or1k_tap_select_command_handler, .mode = COMMAND_ANY, .usage = "tap_select name", .help = "Select the TAP core to use", }, { - "tap_list", + .name = "tap_list", .handler = or1k_tap_list_command_handler, .mode = COMMAND_ANY, .usage = "tap_list", .help = "Display available TAP core", }, { - "du_select", + .name = "du_select", .handler = or1k_du_select_command_handler, .mode = COMMAND_ANY, .usage = "du_select name", .help = "Select the Debug Unit core to use", }, { - "du_list", + .name = "du_list", .handler = or1k_du_list_command_handler, .mode = COMMAND_ANY, .usage = "select_tap name", @@ -1406,7 +1406,7 @@ static const struct command_registration or1k_hw_ip_command_handlers[] = { static const struct command_registration or1k_reg_command_handlers[] = { { - "addreg", + .name = "addreg", .handler = or1k_addreg_command_handler, .mode = COMMAND_ANY, .usage = "addreg name addr feature group", diff --git a/src/target/riscv/riscv.c b/src/target/riscv/riscv.c index 0c9b84c..6392774 100644 --- a/src/target/riscv/riscv.c +++ b/src/target/riscv/riscv.c @@ -455,16 +455,8 @@ static int riscv_init_target(struct command_context *cmd_ctx, return ERROR_OK; } -static void riscv_deinit_target(struct target *target) +static void riscv_free_registers(struct target *target) { - LOG_DEBUG("riscv_deinit_target()"); - struct target_type *tt = get_target_type(target); - if (tt) { - tt->deinit_target(target); - riscv_info_t *info = (riscv_info_t *) target->arch_info; - free(info->reg_names); - free(info); - } /* Free the shared structure use for most registers. */ if (target->reg_cache) { if (target->reg_cache->reg_list) { @@ -477,6 +469,21 @@ static void riscv_deinit_target(struct target *target) } free(target->reg_cache); } +} + +static void riscv_deinit_target(struct target *target) +{ + LOG_DEBUG("riscv_deinit_target()"); + struct target_type *tt = get_target_type(target); + if (tt) { + tt->deinit_target(target); + riscv_info_t *info = (riscv_info_t *) target->arch_info; + free(info->reg_names); + free(info); + } + + riscv_free_registers(target); + target->arch_info = NULL; } @@ -2046,7 +2053,7 @@ COMMAND_HANDLER(riscv_authdata_read) uint32_t value; if (r->authdata_read(target, &value) != ERROR_OK) return ERROR_FAIL; - command_print(CMD_CTX, "0x%" PRIx32, value); + command_print(CMD, "0x%" PRIx32, value); return ERROR_OK; } else { LOG_ERROR("authdata_read is not implemented for this target."); @@ -2099,7 +2106,7 @@ COMMAND_HANDLER(riscv_dmi_read) COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address); if (r->dmi_read(target, &value, address) != ERROR_OK) return ERROR_FAIL; - command_print(CMD_CTX, "0x%" PRIx32, value); + command_print(CMD, "0x%" PRIx32, value); return ERROR_OK; } else { LOG_ERROR("dmi_read is not implemented for this target."); @@ -2402,28 +2409,28 @@ extern __COMMAND_HANDLER(handle_common_semihosting_cmdline); */ static const struct command_registration arm_exec_command_handlers[] = { { - "semihosting", + .name = "semihosting", .handler = handle_common_semihosting_command, .mode = COMMAND_EXEC, .usage = "['enable'|'disable']", .help = "activate support for semihosting operations", }, { - "semihosting_cmdline", + .name = "semihosting_cmdline", .handler = handle_common_semihosting_cmdline, .mode = COMMAND_EXEC, .usage = "arguments", .help = "command line arguments to be passed to program", }, { - "semihosting_fileio", + .name = "semihosting_fileio", .handler = handle_common_semihosting_fileio_command, .mode = COMMAND_EXEC, .usage = "['enable'|'disable']", .help = "activate support for semihosting fileio operations", }, { - "semihosting_resexit", + .name = "semihosting_resexit", .handler = handle_common_semihosting_resumable_exit_command, .mode = COMMAND_EXEC, .usage = "['enable'|'disable']", @@ -3065,11 +3072,7 @@ int riscv_init_registers(struct target *target) { RISCV_INFO(info); - if (target->reg_cache) { - if (target->reg_cache->reg_list) - free(target->reg_cache->reg_list); - free(target->reg_cache); - } + riscv_free_registers(target); target->reg_cache = calloc(1, sizeof(*target->reg_cache)); target->reg_cache->name = "RISC-V Registers"; diff --git a/src/target/semihosting_common.c b/src/target/semihosting_common.c index 5920789..ce6a791 100644 --- a/src/target/semihosting_common.c +++ b/src/target/semihosting_common.c @@ -1470,7 +1470,7 @@ __COMMAND_HANDLER(handle_common_semihosting_command) struct semihosting *semihosting = target->semihosting; if (!semihosting) { - command_print(CMD_CTX, "semihosting not supported for current target"); + command_print(CMD, "semihosting not supported for current target"); return ERROR_FAIL; } @@ -1493,7 +1493,7 @@ __COMMAND_HANDLER(handle_common_semihosting_command) semihosting->is_active = is_active; } - command_print(CMD_CTX, "semihosting is %s", + command_print(CMD, "semihosting is %s", semihosting->is_active ? "enabled" : "disabled"); @@ -1512,19 +1512,19 @@ __COMMAND_HANDLER(handle_common_semihosting_fileio_command) struct semihosting *semihosting = target->semihosting; if (!semihosting) { - command_print(CMD_CTX, "semihosting not supported for current target"); + command_print(CMD, "semihosting not supported for current target"); return ERROR_FAIL; } if (!semihosting->is_active) { - command_print(CMD_CTX, "semihosting not yet enabled for current target"); + command_print(CMD, "semihosting not yet enabled for current target"); return ERROR_FAIL; } if (CMD_ARGC > 0) COMMAND_PARSE_ENABLE(CMD_ARGV[0], semihosting->is_fileio); - command_print(CMD_CTX, "semihosting fileio is %s", + command_print(CMD, "semihosting fileio is %s", semihosting->is_fileio ? "enabled" : "disabled"); @@ -1543,7 +1543,7 @@ __COMMAND_HANDLER(handle_common_semihosting_cmdline) struct semihosting *semihosting = target->semihosting; if (!semihosting) { - command_print(CMD_CTX, "semihosting not supported for current target"); + command_print(CMD, "semihosting not supported for current target"); return ERROR_FAIL; } @@ -1558,7 +1558,7 @@ __COMMAND_HANDLER(handle_common_semihosting_cmdline) semihosting->cmdline = cmdline; } - command_print(CMD_CTX, "semihosting command line is [%s]", + command_print(CMD, "semihosting command line is [%s]", semihosting->cmdline); return ERROR_OK; @@ -1575,19 +1575,19 @@ __COMMAND_HANDLER(handle_common_semihosting_resumable_exit_command) struct semihosting *semihosting = target->semihosting; if (!semihosting) { - command_print(CMD_CTX, "semihosting not supported for current target"); + command_print(CMD, "semihosting not supported for current target"); return ERROR_FAIL; } if (!semihosting->is_active) { - command_print(CMD_CTX, "semihosting not yet enabled for current target"); + command_print(CMD, "semihosting not yet enabled for current target"); return ERROR_FAIL; } if (CMD_ARGC > 0) COMMAND_PARSE_ENABLE(CMD_ARGV[0], semihosting->has_resumable_exit); - command_print(CMD_CTX, "semihosting resumable exit is %s", + command_print(CMD, "semihosting resumable exit is %s", semihosting->has_resumable_exit ? "enabled" : "disabled"); diff --git a/src/target/smp.c b/src/target/smp.c index f42d8ab..acd4628 100644 --- a/src/target/smp.c +++ b/src/target/smp.c @@ -106,7 +106,7 @@ COMMAND_HANDLER(default_handle_smp_command) return ERROR_COMMAND_SYNTAX_ERROR; if (!CMD_ARGC) { - command_print(CMD_CTX, "%s", target->smp ? "on" : "off"); + command_print(CMD, "%s", target->smp ? "on" : "off"); return ERROR_OK; } @@ -166,7 +166,7 @@ COMMAND_HANDLER(handle_smp_gdb_command) target->gdb_service->core[1] = coreid; } - command_print(CMD_CTX, "gdb coreid %" PRId32 " -> %" PRId32, target->gdb_service->core[0] + command_print(CMD, "gdb coreid %" PRId32 " -> %" PRId32, target->gdb_service->core[0] , target->gdb_service->core[1]); } return ERROR_OK; diff --git a/src/target/stm8.c b/src/target/stm8.c index b62ff13..fcfc170 100644 --- a/src/target/stm8.c +++ b/src/target/stm8.c @@ -2147,7 +2147,7 @@ COMMAND_HANDLER(stm8_handle_enable_step_irq_command) stm8->enable_step_irq = enable; } msg = stm8->enable_step_irq ? "enabled" : "disabled"; - command_print(CMD_CTX, "enable_step_irq = %s", msg); + command_print(CMD, "enable_step_irq = %s", msg); return ERROR_OK; } @@ -2163,7 +2163,7 @@ COMMAND_HANDLER(stm8_handle_enable_stm8l_command) stm8->enable_stm8l = enable; } msg = stm8->enable_stm8l ? "enabled" : "disabled"; - command_print(CMD_CTX, "enable_stm8l = %s", msg); + command_print(CMD, "enable_stm8l = %s", msg); stm8_init_flash_regs(stm8->enable_stm8l, stm8); return ERROR_OK; } diff --git a/src/target/target.c b/src/target/target.c index 36e63f9..cec46cc 100644 --- a/src/target/target.c +++ b/src/target/target.c @@ -375,12 +375,6 @@ uint16_t target_buffer_get_u16(struct target *target, const uint8_t *buffer) return be_to_h_u16(buffer); } -/* read a uint8_t from a buffer in target memory endianness */ -static uint8_t target_buffer_get_u8(struct target *target, const uint8_t *buffer) -{ - return *buffer & 0x0ff; -} - /* write a uint64_t to a buffer in target memory endianness */ void target_buffer_set_u64(struct target *target, uint8_t *buffer, uint64_t value) { @@ -640,7 +634,7 @@ int target_resume(struct target *target, int current, target_addr_t address, return retval; } -static int target_process_reset(struct command_context *cmd_ctx, enum target_reset_mode reset_mode) +static int target_process_reset(struct command_invocation *cmd, enum target_reset_mode reset_mode) { char buf[100]; int retval; @@ -664,13 +658,13 @@ static int target_process_reset(struct command_context *cmd_ctx, enum target_res jtag_poll_set_enabled(false); sprintf(buf, "ocd_process_reset %s", n->name); - retval = Jim_Eval(cmd_ctx->interp, buf); + retval = Jim_Eval(cmd->ctx->interp, buf); jtag_poll_set_enabled(save_poll); if (retval != JIM_OK) { - Jim_MakeErrorMessage(cmd_ctx->interp); - command_print(NULL, "%s\n", Jim_GetString(Jim_GetResult(cmd_ctx->interp), NULL)); + Jim_MakeErrorMessage(cmd->ctx->interp); + command_print(cmd, "%s", Jim_GetString(Jim_GetResult(cmd->ctx->interp), NULL)); return ERROR_FAIL; } @@ -1221,7 +1215,24 @@ int target_get_gdb_reg_list(struct target *target, struct reg **reg_list[], int *reg_list_size, enum target_register_class reg_class) { - return target->type->get_gdb_reg_list(target, reg_list, reg_list_size, reg_class); + int result = target->type->get_gdb_reg_list(target, reg_list, + reg_list_size, reg_class); + if (result != ERROR_OK) { + *reg_list = NULL; + *reg_list_size = 0; + } + return result; +} + +int target_get_gdb_reg_list_noread(struct target *target, + struct reg **reg_list[], int *reg_list_size, + enum target_register_class reg_class) +{ + if (target->type->get_gdb_reg_list_noread && + target->type->get_gdb_reg_list_noread(target, reg_list, + reg_list_size, reg_class) == ERROR_OK) + return ERROR_OK; + return target_get_gdb_reg_list(target, reg_list, reg_list_size, reg_class); } int target_get_gdb_reg_list_noread(struct target *target, @@ -1604,9 +1615,9 @@ int target_call_event_callbacks(struct target *target, enum target_event event) target_call_event_callbacks(target, TARGET_EVENT_GDB_HALT); } - LOG_DEBUG("target event %i (%s) for core %d", event, + LOG_DEBUG("target event %i (%s) for core %s", event, Jim_Nvp_value2name_simple(nvp_target_event, event)->name, - target->coreid); + target_name(target)); target_handle_event(target, event); @@ -2590,23 +2601,23 @@ int target_write_phys_u8(struct target *target, target_addr_t address, uint8_t v return retval; } -static int find_target(struct command_context *cmd_ctx, const char *name) +static int find_target(struct command_invocation *cmd, const char *name) { struct target *target = get_target(name); if (target == NULL) { - LOG_ERROR("Target: %s is unknown, try one of:\n", name); + command_print(cmd, "Target: %s is unknown, try one of:\n", name); return ERROR_FAIL; } if (!target->tap->enabled) { - LOG_USER("Target: TAP %s is disabled, " + command_print(cmd, "Target: TAP %s is disabled, " "can't be the current target\n", target->tap->dotted_name); return ERROR_FAIL; } - cmd_ctx->current_target = target; - if (cmd_ctx->current_target_override) - cmd_ctx->current_target_override = target; + cmd->ctx->current_target = target; + if (cmd->ctx->current_target_override) + cmd->ctx->current_target_override = target; return ERROR_OK; } @@ -2616,7 +2627,7 @@ COMMAND_HANDLER(handle_targets_command) { int retval = ERROR_OK; if (CMD_ARGC == 1) { - retval = find_target(CMD_CTX, CMD_ARGV[0]); + retval = find_target(CMD, CMD_ARGV[0]); if (retval == ERROR_OK) { /* we're done! */ return retval; @@ -2624,8 +2635,8 @@ COMMAND_HANDLER(handle_targets_command) } struct target *target = all_targets; - command_print(CMD_CTX, " TargetName Type Endian TapName State "); - command_print(CMD_CTX, "-- ------------------ ---------- ------ ------------------ ------------"); + command_print(CMD, " TargetName Type Endian TapName State "); + command_print(CMD, "-- ------------------ ---------- ------ ------------------ ------------"); while (target) { const char *state; char marker = ' '; @@ -2639,7 +2650,7 @@ COMMAND_HANDLER(handle_targets_command) marker = '*'; /* keep columns lined up to match the headers above */ - command_print(CMD_CTX, + command_print(CMD, "%2d%c %-18s %-10s %-6s %-18s %s", target->target_number, marker, @@ -2850,7 +2861,7 @@ COMMAND_HANDLER(handle_reg_command) while (cache) { unsigned i; - command_print(CMD_CTX, "===== %s", cache->name); + command_print(CMD, "===== %s", cache->name); for (i = 0, reg = cache->reg_list; i < cache->num_regs; @@ -2904,7 +2915,7 @@ COMMAND_HANDLER(handle_reg_command) } if (!reg) { - command_print(CMD_CTX, "%i is out of bounds, the current target " + command_print(CMD, "%i is out of bounds, the current target " "has only %i registers (0 - %i)", num, count, count - 1); return ERROR_OK; } @@ -2935,7 +2946,7 @@ COMMAND_HANDLER(handle_reg_command) } } value = buf_to_str(reg->value, reg->size, 16); - command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value); + command_print(CMD, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value); free(value); return ERROR_OK; } @@ -2955,7 +2966,7 @@ COMMAND_HANDLER(handle_reg_command) } value = buf_to_str(reg->value, reg->size, 16); - command_print(CMD_CTX, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value); + command_print(CMD, "%s (/%i): 0x%s", reg->name, (int)(reg->size), value); free(value); free(buf); @@ -2966,7 +2977,7 @@ COMMAND_HANDLER(handle_reg_command) return ERROR_COMMAND_SYNTAX_ERROR; not_found: - command_print(CMD_CTX, "register %s not found in current target", CMD_ARGV[0]); + command_print(CMD, "register %s not found in current target", CMD_ARGV[0]); return ERROR_OK; } @@ -2976,9 +2987,9 @@ COMMAND_HANDLER(handle_poll_command) struct target *target = get_current_target(CMD_CTX); if (CMD_ARGC == 0) { - command_print(CMD_CTX, "background polling: %s", + command_print(CMD, "background polling: %s", jtag_poll_get_enabled() ? "on" : "off"); - command_print(CMD_CTX, "TAP: %s (%s)", + command_print(CMD, "TAP: %s (%s)", target->tap->dotted_name, target->tap->enabled ? "enabled" : "disabled"); if (!target->tap->enabled) @@ -3104,7 +3115,7 @@ COMMAND_HANDLER(handle_reset_command) } /* reset *all* targets */ - return target_process_reset(CMD_CTX, reset_mode); + return target_process_reset(CMD, reset_mode); } @@ -3150,7 +3161,7 @@ COMMAND_HANDLER(handle_step_command) return target->type->step(target, current_pc, addr, 1); } -static void handle_md_output(struct command_context *cmd_ctx, +void target_handle_md_output(struct command_invocation *cmd, struct target *target, target_addr_t address, unsigned size, unsigned count, const uint8_t *buffer) { @@ -3208,7 +3219,7 @@ static void handle_md_output(struct command_context *cmd_ctx, value_fmt, value); if ((i % line_modulo == line_modulo - 1) || (i == count - 1)) { - command_print(cmd_ctx, "%s", output); + command_print(cmd, "%s", output); output_len = 0; } } @@ -3265,7 +3276,7 @@ COMMAND_HANDLER(handle_md_command) struct target *target = get_current_target(CMD_CTX); int retval = fn(target, address, size, count, buffer); if (ERROR_OK == retval) - handle_md_output(CMD_CTX, target, address, size, count, buffer); + target_handle_md_output(CMD, target, address, size, count, buffer); free(buffer); @@ -3438,7 +3449,7 @@ COMMAND_HANDLER(handle_load_image_command) for (i = 0; i < image.num_sections; i++) { buffer = malloc(image.sections[i].size); if (buffer == NULL) { - command_print(CMD_CTX, + command_print(CMD, "error allocating buffer for section (%d bytes)", (int)(image.sections[i].size)); retval = ERROR_FAIL; @@ -3475,7 +3486,7 @@ COMMAND_HANDLER(handle_load_image_command) break; } image_size += length; - command_print(CMD_CTX, "%u bytes written at address " TARGET_ADDR_FMT "", + command_print(CMD, "%u bytes written at address " TARGET_ADDR_FMT "", (unsigned int)length, image.sections[i].base_address + offset); } @@ -3484,7 +3495,7 @@ COMMAND_HANDLER(handle_load_image_command) } if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) { - command_print(CMD_CTX, "downloaded %" PRIu32 " bytes " + command_print(CMD, "downloaded %" PRIu32 " bytes " "in %fs (%0.3f KiB/s)", image_size, duration_elapsed(&bench), duration_kbps(&bench, image_size)); } @@ -3545,7 +3556,7 @@ COMMAND_HANDLER(handle_dump_image_command) retval = fileio_size(fileio, &filesize); if (retval != ERROR_OK) return retval; - command_print(CMD_CTX, + command_print(CMD, "dumped %zu bytes in %fs (%0.3f KiB/s)", filesize, duration_elapsed(&bench), duration_kbps(&bench, filesize)); } @@ -3610,7 +3621,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, enum verify_mode ver for (i = 0; i < image.num_sections; i++) { buffer = malloc(image.sections[i].size); if (buffer == NULL) { - command_print(CMD_CTX, + command_print(CMD, "error allocating buffer for section (%d bytes)", (int)(image.sections[i].size)); break; @@ -3661,14 +3672,14 @@ static COMMAND_HELPER(handle_verify_image_command_internal, enum verify_mode ver uint32_t t; for (t = 0; t < buf_cnt; t++) { if (data[t] != buffer[t]) { - command_print(CMD_CTX, + command_print(CMD, "diff %d address 0x%08x. Was 0x%02x instead of 0x%02x", diffs, (unsigned)(t + image.sections[i].base_address), data[t], buffer[t]); if (diffs++ >= 127) { - command_print(CMD_CTX, "More than 128 errors, the rest are not printed."); + command_print(CMD, "More than 128 errors, the rest are not printed."); free(data); free(buffer); goto done; @@ -3680,7 +3691,7 @@ static COMMAND_HELPER(handle_verify_image_command_internal, enum verify_mode ver free(data); } } else { - command_print(CMD_CTX, "address " TARGET_ADDR_FMT " length 0x%08zx", + command_print(CMD, "address " TARGET_ADDR_FMT " length 0x%08zx", image.sections[i].base_address, buf_cnt); } @@ -3689,12 +3700,12 @@ static COMMAND_HELPER(handle_verify_image_command_internal, enum verify_mode ver image_size += buf_cnt; } if (diffs > 0) - command_print(CMD_CTX, "No more differences found."); + command_print(CMD, "No more differences found."); done: if (diffs > 0) retval = ERROR_FAIL; if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) { - command_print(CMD_CTX, "verified %" PRIu32 " bytes " + command_print(CMD, "verified %" PRIu32 " bytes " "in %fs (%0.3f KiB/s)", image_size, duration_elapsed(&bench), duration_kbps(&bench, image_size)); } @@ -3719,32 +3730,32 @@ COMMAND_HANDLER(handle_test_image_command) return CALL_COMMAND_HANDLER(handle_verify_image_command_internal, IMAGE_TEST); } -static int handle_bp_command_list(struct command_context *cmd_ctx) +static int handle_bp_command_list(struct command_invocation *cmd) { - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd->ctx); struct breakpoint *breakpoint = target->breakpoints; while (breakpoint) { if (breakpoint->type == BKPT_SOFT) { char *buf = buf_to_str(breakpoint->orig_instr, breakpoint->length, 16); - command_print(cmd_ctx, "IVA breakpoint: " TARGET_ADDR_FMT ", 0x%x, %i, 0x%s", + command_print(cmd, "IVA breakpoint: " TARGET_ADDR_FMT ", 0x%x, %i, 0x%s", breakpoint->address, breakpoint->length, breakpoint->set, buf); free(buf); } else { if ((breakpoint->address == 0) && (breakpoint->asid != 0)) - command_print(cmd_ctx, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i", + command_print(cmd, "Context breakpoint: 0x%8.8" PRIx32 ", 0x%x, %i", breakpoint->asid, breakpoint->length, breakpoint->set); else if ((breakpoint->address != 0) && (breakpoint->asid != 0)) { - command_print(cmd_ctx, "Hybrid breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i", + command_print(cmd, "Hybrid breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set); - command_print(cmd_ctx, "\t|--->linked with ContextID: 0x%8.8" PRIx32, + command_print(cmd, "\t|--->linked with ContextID: 0x%8.8" PRIx32, breakpoint->asid); } else - command_print(cmd_ctx, "Breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i", + command_print(cmd, "Breakpoint(IVA): " TARGET_ADDR_FMT ", 0x%x, %i", breakpoint->address, breakpoint->length, breakpoint->set); } @@ -3754,17 +3765,17 @@ static int handle_bp_command_list(struct command_context *cmd_ctx) return ERROR_OK; } -static int handle_bp_command_set(struct command_context *cmd_ctx, +static int handle_bp_command_set(struct command_invocation *cmd, target_addr_t addr, uint32_t asid, uint32_t length, int hw) { - struct target *target = get_current_target(cmd_ctx); + struct target *target = get_current_target(cmd->ctx); int retval; if (asid == 0) { retval = breakpoint_add(target, addr, length, hw); /* error is always logged in breakpoint_add(), do not print it again */ if (ERROR_OK == retval) - command_print(cmd_ctx, "breakpoint set at " TARGET_ADDR_FMT "", addr); + command_print(cmd, "breakpoint set at " TARGET_ADDR_FMT "", addr); } else if (addr == 0) { if (target->type->add_context_breakpoint == NULL) { @@ -3774,7 +3785,7 @@ static int handle_bp_command_set(struct command_context *cmd_ctx, retval = context_breakpoint_add(target, asid, length, hw); /* error is always logged in context_breakpoint_add(), do not print it again */ if (ERROR_OK == retval) - command_print(cmd_ctx, "Context breakpoint set at 0x%8.8" PRIx32 "", asid); + command_print(cmd, "Context breakpoint set at 0x%8.8" PRIx32 "", asid); } else { if (target->type->add_hybrid_breakpoint == NULL) { @@ -3784,7 +3795,7 @@ static int handle_bp_command_set(struct command_context *cmd_ctx, retval = hybrid_breakpoint_add(target, addr, asid, length, hw); /* error is always logged in hybrid_breakpoint_add(), do not print it again */ if (ERROR_OK == retval) - command_print(cmd_ctx, "Hybrid breakpoint set at 0x%8.8" PRIx32 "", asid); + command_print(cmd, "Hybrid breakpoint set at 0x%8.8" PRIx32 "", asid); } return retval; } @@ -3798,13 +3809,13 @@ COMMAND_HANDLER(handle_bp_command) switch (CMD_ARGC) { case 0: - return handle_bp_command_list(CMD_CTX); + return handle_bp_command_list(CMD); case 2: asid = 0; COMMAND_PARSE_ADDRESS(CMD_ARGV[0], addr); COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length); - return handle_bp_command_set(CMD_CTX, addr, asid, length, hw); + return handle_bp_command_set(CMD, addr, asid, length, hw); case 3: if (strcmp(CMD_ARGV[2], "hw") == 0) { @@ -3812,13 +3823,13 @@ COMMAND_HANDLER(handle_bp_command) COMMAND_PARSE_ADDRESS(CMD_ARGV[0], addr); COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length); asid = 0; - return handle_bp_command_set(CMD_CTX, addr, asid, length, hw); + return handle_bp_command_set(CMD, addr, asid, length, hw); } else if (strcmp(CMD_ARGV[2], "hw_ctx") == 0) { hw = BKPT_HARD; COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], asid); COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length); addr = 0; - return handle_bp_command_set(CMD_CTX, addr, asid, length, hw); + return handle_bp_command_set(CMD, addr, asid, length, hw); } /* fallthrough */ case 4: @@ -3826,7 +3837,7 @@ COMMAND_HANDLER(handle_bp_command) COMMAND_PARSE_ADDRESS(CMD_ARGV[0], addr); COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], asid); COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], length); - return handle_bp_command_set(CMD_CTX, addr, asid, length, hw); + return handle_bp_command_set(CMD, addr, asid, length, hw); default: return ERROR_COMMAND_SYNTAX_ERROR; @@ -3855,7 +3866,7 @@ COMMAND_HANDLER(handle_wp_command) struct watchpoint *watchpoint = target->watchpoints; while (watchpoint) { - command_print(CMD_CTX, "address: " TARGET_ADDR_FMT + command_print(CMD, "address: " TARGET_ADDR_FMT ", len: 0x%8.8" PRIx32 ", r/w/a: %i, value: 0x%8.8" PRIx32 ", mask: 0x%8.8" PRIx32, @@ -3947,7 +3958,7 @@ COMMAND_HANDLER(handle_virt2phys_command) struct target *target = get_current_target(CMD_CTX); int retval = target->type->virt2phys(target, va, &pa); if (retval == ERROR_OK) - command_print(CMD_CTX, "Physical address " TARGET_ADDR_FMT "", pa); + command_print(CMD, "Physical address " TARGET_ADDR_FMT "", pa); return retval; } @@ -4140,7 +4151,7 @@ COMMAND_HANDLER(handle_profile_command) write_gmon(samples, num_of_samples, CMD_ARGV[1], with_range, start_address, end_address, target, duration_ms); - command_print(CMD_CTX, "Wrote %s", CMD_ARGV[1]); + command_print(CMD, "Wrote %s", CMD_ARGV[1]); free(samples); return retval; @@ -4557,6 +4568,7 @@ static int target_array2mem(Jim_Interp *interp, struct target *target, void target_handle_event(struct target *target, enum target_event e) { struct target_event_action *teap; + int retval; for (teap = target->event_action; teap != NULL; teap = teap->next) { if (teap->event == e) { @@ -4575,10 +4587,19 @@ void target_handle_event(struct target *target, enum target_event e) struct command_context *cmd_ctx = current_command_context(teap->interp); struct target *saved_target_override = cmd_ctx->current_target_override; cmd_ctx->current_target_override = target; + retval = Jim_EvalObj(teap->interp, teap->body); - if (Jim_EvalObj(teap->interp, teap->body) != JIM_OK) { + if (retval == JIM_RETURN) + retval = teap->interp->returnCode; + + if (retval != JIM_OK) { Jim_MakeErrorMessage(teap->interp); - command_print(NULL, "%s\n", Jim_GetString(Jim_GetResult(teap->interp), NULL)); + LOG_USER("Error executing event %s on target %s:\n%s", + Jim_Nvp_value2name_simple(nvp_target_event, e)->name, + target_name(target), + Jim_GetString(Jim_GetResult(teap->interp), NULL)); + /* clean both error code and stacktrace before return */ + Jim_Eval(teap->interp, "error \"\" \"\""); } cmd_ctx->current_target_override = saved_target_override; @@ -4856,7 +4877,7 @@ no_params: if (goi->argc != 0) goto no_params; } - Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->working_area_size)); + Jim_SetResult(goi->interp, Jim_NewIntObj(goi->interp, target->coreid)); /* loop for more */ break; @@ -4919,6 +4940,12 @@ no_params: case TCFG_GDB_PORT: if (goi->isconfigure) { + struct command_context *cmd_ctx = current_command_context(goi->interp); + if (cmd_ctx->mode != COMMAND_CONFIG) { + Jim_SetResultString(goi->interp, "-gdb-port must be configured before 'init'", -1); + return JIM_ERR; + } + const char *s; e = Jim_GetOpt_String(goi, &s, NULL); if (e != JIM_OK) @@ -4954,228 +4981,6 @@ static int jim_target_configure(Jim_Interp *interp, int argc, Jim_Obj * const *a return target_configure(&goi, target); } -static int jim_target_mw(Jim_Interp *interp, int argc, Jim_Obj *const *argv) -{ - const char *cmd_name = Jim_GetString(argv[0], NULL); - - Jim_GetOptInfo goi; - Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1); - - if (goi.argc < 2 || goi.argc > 4) { - Jim_SetResultFormatted(goi.interp, - "usage: %s [phys] <address> <data> [<count>]", cmd_name); - return JIM_ERR; - } - - target_write_fn fn; - fn = target_write_memory; - - int e; - if (strcmp(Jim_GetString(argv[1], NULL), "phys") == 0) { - /* consume it */ - struct Jim_Obj *obj; - e = Jim_GetOpt_Obj(&goi, &obj); - if (e != JIM_OK) - return e; - - fn = target_write_phys_memory; - } - - jim_wide a; - e = Jim_GetOpt_Wide(&goi, &a); - if (e != JIM_OK) - return e; - - jim_wide b; - e = Jim_GetOpt_Wide(&goi, &b); - if (e != JIM_OK) - return e; - - jim_wide c = 1; - if (goi.argc == 1) { - e = Jim_GetOpt_Wide(&goi, &c); - if (e != JIM_OK) - return e; - } - - /* all args must be consumed */ - if (goi.argc != 0) - return JIM_ERR; - - struct target *target = Jim_CmdPrivData(goi.interp); - unsigned data_size; - if (strcasecmp(cmd_name, "mww") == 0) - data_size = 4; - else if (strcasecmp(cmd_name, "mwh") == 0) - data_size = 2; - else if (strcasecmp(cmd_name, "mwb") == 0) - data_size = 1; - else { - LOG_ERROR("command '%s' unknown: ", cmd_name); - return JIM_ERR; - } - - return (target_fill_mem(target, a, fn, data_size, b, c) == ERROR_OK) ? JIM_OK : JIM_ERR; -} - -/** -* @brief Reads an array of words/halfwords/bytes from target memory starting at specified address. -* -* Usage: mdw [phys] <address> [<count>] - for 32 bit reads -* mdh [phys] <address> [<count>] - for 16 bit reads -* mdb [phys] <address> [<count>] - for 8 bit reads -* -* Count defaults to 1. -* -* Calls target_read_memory or target_read_phys_memory depending on -* the presence of the "phys" argument -* Reads the target memory in blocks of max. 32 bytes, and returns an array of ints formatted -* to int representation in base16. -* Also outputs read data in a human readable form using command_print -* -* @param phys if present target_read_phys_memory will be used instead of target_read_memory -* @param address address where to start the read. May be specified in decimal or hex using the standard "0x" prefix -* @param count optional count parameter to read an array of values. If not specified, defaults to 1. -* @returns: JIM_ERR on error or JIM_OK on success and sets the result string to an array of ascii formatted numbers -* on success, with [<count>] number of elements. -* -* In case of little endian target: -* Example1: "mdw 0x00000000" returns "10123456" -* Exmaple2: "mdh 0x00000000 1" returns "3456" -* Example3: "mdb 0x00000000" returns "56" -* Example4: "mdh 0x00000000 2" returns "3456 1012" -* Example5: "mdb 0x00000000 3" returns "56 34 12" -**/ -static int jim_target_md(Jim_Interp *interp, int argc, Jim_Obj *const *argv) -{ - const char *cmd_name = Jim_GetString(argv[0], NULL); - - Jim_GetOptInfo goi; - Jim_GetOpt_Setup(&goi, interp, argc - 1, argv + 1); - - if ((goi.argc < 1) || (goi.argc > 3)) { - Jim_SetResultFormatted(goi.interp, - "usage: %s [phys] <address> [<count>]", cmd_name); - return JIM_ERR; - } - - int (*fn)(struct target *target, - target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer); - fn = target_read_memory; - - int e; - if (strcmp(Jim_GetString(argv[1], NULL), "phys") == 0) { - /* consume it */ - struct Jim_Obj *obj; - e = Jim_GetOpt_Obj(&goi, &obj); - if (e != JIM_OK) - return e; - - fn = target_read_phys_memory; - } - - /* Read address parameter */ - jim_wide addr; - e = Jim_GetOpt_Wide(&goi, &addr); - if (e != JIM_OK) - return JIM_ERR; - - /* If next parameter exists, read it out as the count parameter, if not, set it to 1 (default) */ - jim_wide count; - if (goi.argc == 1) { - e = Jim_GetOpt_Wide(&goi, &count); - if (e != JIM_OK) - return JIM_ERR; - } else - count = 1; - - /* all args must be consumed */ - if (goi.argc != 0) - return JIM_ERR; - - jim_wide dwidth = 1; /* shut up gcc */ - if (strcasecmp(cmd_name, "mdw") == 0) - dwidth = 4; - else if (strcasecmp(cmd_name, "mdh") == 0) - dwidth = 2; - else if (strcasecmp(cmd_name, "mdb") == 0) - dwidth = 1; - else { - LOG_ERROR("command '%s' unknown: ", cmd_name); - return JIM_ERR; - } - - /* convert count to "bytes" */ - int bytes = count * dwidth; - - struct target *target = Jim_CmdPrivData(goi.interp); - uint8_t target_buf[32]; - jim_wide x, y, z; - while (bytes > 0) { - y = (bytes < 16) ? bytes : 16; /* y = min(bytes, 16); */ - - /* Try to read out next block */ - e = fn(target, addr, dwidth, y / dwidth, target_buf); - - if (e != ERROR_OK) { - Jim_SetResultFormatted(interp, "error reading target @ 0x%08lx", (long)addr); - return JIM_ERR; - } - - command_print_sameline(NULL, "0x%08x ", (int)(addr)); - switch (dwidth) { - case 4: - for (x = 0; x < 16 && x < y; x += 4) { - z = target_buffer_get_u32(target, &(target_buf[x])); - command_print_sameline(NULL, "%08x ", (int)(z)); - } - for (; (x < 16) ; x += 4) - command_print_sameline(NULL, " "); - break; - case 2: - for (x = 0; x < 16 && x < y; x += 2) { - z = target_buffer_get_u16(target, &(target_buf[x])); - command_print_sameline(NULL, "%04x ", (int)(z)); - } - for (; (x < 16) ; x += 2) - command_print_sameline(NULL, " "); - break; - case 1: - default: - for (x = 0 ; (x < 16) && (x < y) ; x += 1) { - z = target_buffer_get_u8(target, &(target_buf[x])); - command_print_sameline(NULL, "%02x ", (int)(z)); - } - for (; (x < 16) ; x += 1) - command_print_sameline(NULL, " "); - break; - } - /* ascii-ify the bytes */ - for (x = 0 ; x < y ; x++) { - if ((target_buf[x] >= 0x20) && - (target_buf[x] <= 0x7e)) { - /* good */ - } else { - /* smack it */ - target_buf[x] = '.'; - } - } - /* space pad */ - while (x < 16) { - target_buf[x] = ' '; - x++; - } - /* terminate */ - target_buf[16] = 0; - /* print - with a newline */ - command_print_sameline(NULL, "%s\n", target_buf); - /* NEXT... */ - bytes -= 16; - addr += 16; - } - return JIM_OK; -} - static int jim_target_mem2array(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { @@ -5389,27 +5194,25 @@ static int jim_target_wait_state(Jim_Interp *interp, int argc, Jim_Obj *const *a /* List for human, Events defined for this target. * scripts/programs should use 'name cget -event NAME' */ -static int jim_target_event_list(Jim_Interp *interp, int argc, Jim_Obj *const *argv) +COMMAND_HANDLER(handle_target_event_list) { - struct command_context *cmd_ctx = current_command_context(interp); - assert(cmd_ctx != NULL); - - struct target *target = Jim_CmdPrivData(interp); + struct target *target = get_current_target(CMD_CTX); struct target_event_action *teap = target->event_action; - command_print(cmd_ctx, "Event actions for target (%d) %s\n", + + command_print(CMD, "Event actions for target (%d) %s\n", target->target_number, target_name(target)); - command_print(cmd_ctx, "%-25s | Body", "Event"); - command_print(cmd_ctx, "------------------------- | " + command_print(CMD, "%-25s | Body", "Event"); + command_print(CMD, "------------------------- | " "----------------------------------------"); while (teap) { Jim_Nvp *opt = Jim_Nvp_value2name_simple(nvp_target_event, teap->event); - command_print(cmd_ctx, "%-25s | %s", + command_print(CMD, "%-25s | %s", opt->name, Jim_GetString(teap->body, NULL)); teap = teap->next; } - command_print(cmd_ctx, "***END***"); - return JIM_OK; + command_print(CMD, "***END***"); + return ERROR_OK; } static int jim_target_current_state(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { @@ -5444,7 +5247,7 @@ static int jim_target_invoke_event(Jim_Interp *interp, int argc, Jim_Obj *const static const struct command_registration target_instance_command_handlers[] = { { .name = "configure", - .mode = COMMAND_CONFIG, + .mode = COMMAND_ANY, .jim_handler = jim_target_configure, .help = "configure a new target for use", .usage = "[target_attribute ...]", @@ -5457,44 +5260,58 @@ static const struct command_registration target_instance_command_handlers[] = { .usage = "target_attribute", }, { + .name = "mwd", + .handler = handle_mw_command, + .mode = COMMAND_EXEC, + .help = "Write 64-bit word(s) to target memory", + .usage = "address data [count]", + }, + { .name = "mww", + .handler = handle_mw_command, .mode = COMMAND_EXEC, - .jim_handler = jim_target_mw, .help = "Write 32-bit word(s) to target memory", .usage = "address data [count]", }, { .name = "mwh", + .handler = handle_mw_command, .mode = COMMAND_EXEC, - .jim_handler = jim_target_mw, .help = "Write 16-bit half-word(s) to target memory", .usage = "address data [count]", }, { .name = "mwb", + .handler = handle_mw_command, .mode = COMMAND_EXEC, - .jim_handler = jim_target_mw, .help = "Write byte(s) to target memory", .usage = "address data [count]", }, { + .name = "mdd", + .handler = handle_md_command, + .mode = COMMAND_EXEC, + .help = "Display target memory as 64-bit words", + .usage = "address [count]", + }, + { .name = "mdw", + .handler = handle_md_command, .mode = COMMAND_EXEC, - .jim_handler = jim_target_md, .help = "Display target memory as 32-bit words", .usage = "address [count]", }, { .name = "mdh", + .handler = handle_md_command, .mode = COMMAND_EXEC, - .jim_handler = jim_target_md, .help = "Display target memory as 16-bit half-words", .usage = "address [count]", }, { .name = "mdb", + .handler = handle_md_command, .mode = COMMAND_EXEC, - .jim_handler = jim_target_md, .help = "Display target memory as 8-bit bytes", .usage = "address [count]", }, @@ -5516,9 +5333,10 @@ static const struct command_registration target_instance_command_handlers[] = { }, { .name = "eventlist", + .handler = handle_target_event_list, .mode = COMMAND_EXEC, - .jim_handler = jim_target_event_list, .help = "displays a table of events defined for this target", + .usage = "", }, { .name = "curstate", @@ -5917,6 +5735,7 @@ static const struct command_registration target_subcommand_handlers[] = { .mode = COMMAND_CONFIG, .handler = handle_target_init_command, .help = "initialize targets", + .usage = "", }, { .name = "create", @@ -6006,7 +5825,7 @@ COMMAND_HANDLER(handle_fast_load_image_command) fastload_num = image.num_sections; fastload = malloc(sizeof(struct FastLoad)*image.num_sections); if (fastload == NULL) { - command_print(CMD_CTX, "out of memory"); + command_print(CMD, "out of memory"); image_close(&image); return ERROR_FAIL; } @@ -6014,7 +5833,7 @@ COMMAND_HANDLER(handle_fast_load_image_command) for (i = 0; i < image.num_sections; i++) { buffer = malloc(image.sections[i].size); if (buffer == NULL) { - command_print(CMD_CTX, "error allocating buffer for section (%d bytes)", + command_print(CMD, "error allocating buffer for section (%d bytes)", (int)(image.sections[i].size)); retval = ERROR_FAIL; break; @@ -6046,7 +5865,7 @@ COMMAND_HANDLER(handle_fast_load_image_command) fastload[i].data = malloc(length); if (fastload[i].data == NULL) { free(buffer); - command_print(CMD_CTX, "error allocating buffer for section (%" PRIu32 " bytes)", + command_print(CMD, "error allocating buffer for section (%" PRIu32 " bytes)", length); retval = ERROR_FAIL; break; @@ -6055,7 +5874,7 @@ COMMAND_HANDLER(handle_fast_load_image_command) fastload[i].length = length; image_size += length; - command_print(CMD_CTX, "%u bytes written at address 0x%8.8x", + command_print(CMD, "%u bytes written at address 0x%8.8x", (unsigned int)length, ((unsigned int)(image.sections[i].base_address + offset))); } @@ -6064,11 +5883,11 @@ COMMAND_HANDLER(handle_fast_load_image_command) } if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) { - command_print(CMD_CTX, "Loaded %" PRIu32 " bytes " + command_print(CMD, "Loaded %" PRIu32 " bytes " "in %fs (%0.3f KiB/s)", image_size, duration_elapsed(&bench), duration_kbps(&bench, image_size)); - command_print(CMD_CTX, + command_print(CMD, "WARNING: image has not been loaded to target!" "You can issue a 'fast_load' to finish loading."); } @@ -6095,7 +5914,7 @@ COMMAND_HANDLER(handle_fast_load_command) int retval = ERROR_OK; for (i = 0; i < fastload_num; i++) { struct target *target = get_current_target(CMD_CTX); - command_print(CMD_CTX, "Write to 0x%08x, length 0x%08x", + command_print(CMD, "Write to 0x%08x, length 0x%08x", (unsigned int)(fastload[i].address), (unsigned int)(fastload[i].length)); retval = target_write_buffer(target, fastload[i].address, fastload[i].length, fastload[i].data); @@ -6105,7 +5924,7 @@ COMMAND_HANDLER(handle_fast_load_command) } if (retval == ERROR_OK) { int64_t after = timeval_ms(); - command_print(CMD_CTX, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0)); + command_print(CMD, "Loaded image %f kBytes/s", (float)(size/1024.0)/((float)(after-ms)/1000.0)); } return retval; } @@ -6123,8 +5942,8 @@ static const struct command_registration target_command_handlers[] = { .name = "target", .mode = COMMAND_CONFIG, .help = "configure target", - .chain = target_subcommand_handlers, + .usage = "", }, COMMAND_REGISTRATION_DONE }; @@ -6160,7 +5979,7 @@ COMMAND_HANDLER(handle_ps_command) if ((target->rtos) && (target->rtos->type) && (target->rtos->type->ps_command)) { display = target->rtos->type->ps_command(target); - command_print(CMD_CTX, "%s", display); + command_print(CMD, "%s", display); free(display); return ERROR_OK; } else { @@ -6169,13 +5988,13 @@ COMMAND_HANDLER(handle_ps_command) } } -static void binprint(struct command_context *cmd_ctx, const char *text, const uint8_t *buf, int size) +static void binprint(struct command_invocation *cmd, const char *text, const uint8_t *buf, int size) { if (text != NULL) - command_print_sameline(cmd_ctx, "%s", text); + command_print_sameline(cmd, "%s", text); for (int i = 0; i < size; i++) - command_print_sameline(cmd_ctx, " %02x", buf[i]); - command_print(cmd_ctx, " "); + command_print_sameline(cmd, " %02x", buf[i]); + command_print(cmd, " "); } COMMAND_HANDLER(handle_test_mem_access_command) @@ -6227,7 +6046,7 @@ COMMAND_HANDLER(handle_test_mem_access_command) read_ref[i] = rand(); read_buf[i] = read_ref[i]; } - command_print_sameline(CMD_CTX, + command_print_sameline(CMD, "Test read %" PRIu32 " x %d @ %d to %saligned buffer: ", count, size, offset, host_offset ? "un" : ""); @@ -6240,10 +6059,10 @@ COMMAND_HANDLER(handle_test_mem_access_command) duration_measure(&bench); if (retval == ERROR_TARGET_UNALIGNED_ACCESS) { - command_print(CMD_CTX, "Unsupported alignment"); + command_print(CMD, "Unsupported alignment"); goto next; } else if (retval != ERROR_OK) { - command_print(CMD_CTX, "Memory read failed"); + command_print(CMD, "Memory read failed"); goto next; } @@ -6253,13 +6072,13 @@ COMMAND_HANDLER(handle_test_mem_access_command) /* check result */ int result = memcmp(read_ref, read_buf, host_bufsiz); if (result == 0) { - command_print(CMD_CTX, "Pass in %fs (%0.3f KiB/s)", + command_print(CMD, "Pass in %fs (%0.3f KiB/s)", duration_elapsed(&bench), duration_kbps(&bench, count * size)); } else { - command_print(CMD_CTX, "Compare failed"); - binprint(CMD_CTX, "ref:", read_ref, host_bufsiz); - binprint(CMD_CTX, "buf:", read_buf, host_bufsiz); + command_print(CMD, "Compare failed"); + binprint(CMD, "ref:", read_ref, host_bufsiz); + binprint(CMD, "buf:", read_buf, host_bufsiz); } next: free(read_ref); @@ -6299,13 +6118,13 @@ out: for (size_t i = 0; i < host_bufsiz; i++) write_buf[i] = rand(); - command_print_sameline(CMD_CTX, + command_print_sameline(CMD, "Test write %" PRIu32 " x %d @ %d from %saligned buffer: ", count, size, offset, host_offset ? "un" : ""); retval = target_write_memory(target, wa->address, 1, num_bytes, test_pattern); if (retval != ERROR_OK) { - command_print(CMD_CTX, "Test pattern write failed"); + command_print(CMD, "Test pattern write failed"); goto nextw; } @@ -6322,30 +6141,30 @@ out: duration_measure(&bench); if (retval == ERROR_TARGET_UNALIGNED_ACCESS) { - command_print(CMD_CTX, "Unsupported alignment"); + command_print(CMD, "Unsupported alignment"); goto nextw; } else if (retval != ERROR_OK) { - command_print(CMD_CTX, "Memory write failed"); + command_print(CMD, "Memory write failed"); goto nextw; } /* read back */ retval = target_read_memory(target, wa->address, 1, num_bytes, read_buf); if (retval != ERROR_OK) { - command_print(CMD_CTX, "Test pattern write failed"); + command_print(CMD, "Test pattern write failed"); goto nextw; } /* check result */ int result = memcmp(read_ref, read_buf, num_bytes); if (result == 0) { - command_print(CMD_CTX, "Pass in %fs (%0.3f KiB/s)", + command_print(CMD, "Pass in %fs (%0.3f KiB/s)", duration_elapsed(&bench), duration_kbps(&bench, count * size)); } else { - command_print(CMD_CTX, "Compare failed"); - binprint(CMD_CTX, "ref:", read_ref, num_bytes); - binprint(CMD_CTX, "buf:", read_buf, num_bytes); + command_print(CMD, "Compare failed"); + binprint(CMD, "ref:", read_ref, num_bytes); + binprint(CMD, "buf:", read_buf, num_bytes); } nextw: free(read_ref); @@ -6458,7 +6277,7 @@ static const struct command_registration target_exec_command_handlers[] = { .name = "mdd", .handler = handle_md_command, .mode = COMMAND_EXEC, - .help = "display memory words", + .help = "display memory double-words", .usage = "['phys'] address [count]", }, { @@ -6486,7 +6305,7 @@ static const struct command_registration target_exec_command_handlers[] = { .name = "mwd", .handler = handle_mw_command, .mode = COMMAND_EXEC, - .help = "write memory word", + .help = "write memory double-word", .usage = "['phys'] address value [count]", }, { @@ -6515,7 +6334,7 @@ static const struct command_registration target_exec_command_handlers[] = { .handler = handle_bp_command, .mode = COMMAND_EXEC, .help = "list or set hardware or software breakpoint", - .usage = "<address> [<asid>] <length> ['hw'|'hw_ctx']", + .usage = "[<address> [<asid>] <length> ['hw'|'hw_ctx']]", }, { .name = "rbp", diff --git a/src/target/target.h b/src/target/target.h index 160ac4a..957a7d0 100644 --- a/src/target/target.h +++ b/src/target/target.h @@ -36,6 +36,7 @@ struct reg; struct trace; struct command_context; +struct command_invocation; struct breakpoint; struct watchpoint; struct mem_param; @@ -739,6 +740,10 @@ int target_arch_state(struct target *target); void target_handle_event(struct target *t, enum target_event e); +void target_handle_md_output(struct command_invocation *cmd, + struct target *target, target_addr_t address, unsigned size, + unsigned count, const uint8_t *buffer); + #define ERROR_TARGET_INVALID (-300) #define ERROR_TARGET_INIT_FAILED (-301) #define ERROR_TARGET_TIMEOUT (-302) diff --git a/src/target/target_request.c b/src/target/target_request.c index 6ca204b..c1da1a2 100644 --- a/src/target/target_request.c +++ b/src/target/target_request.c @@ -56,7 +56,7 @@ static int target_asciimsg(struct target *target, uint32_t length) LOG_DEBUG("%s", msg); while (c) { - command_print(c->cmd_ctx, "%s", msg); + command_output_text(c->cmd_ctx, msg); c = c->next; } @@ -100,7 +100,7 @@ static int target_hexmsg(struct target *target, int size, uint32_t length) LOG_DEBUG("%s", line); while (c) { - command_print(c->cmd_ctx, "%s", line); + command_output_text(c->cmd_ctx, line); c = c->next; } c = target->dbgmsg; @@ -283,7 +283,7 @@ COMMAND_HANDLER(handle_target_request_debugmsgs_command) return ERROR_COMMAND_SYNTAX_ERROR; } - command_print(CMD_CTX, "receiving debug messages from current target %s", + command_print(CMD, "receiving debug messages from current target %s", (receiving) ? (charmsg_mode ? "charmsg" : "enabled") : "disabled"); return ERROR_OK; } diff --git a/src/target/testee.c b/src/target/testee.c index 5b6cced..236ac9a 100644 --- a/src/target/testee.c +++ b/src/target/testee.c @@ -30,8 +30,8 @@ static const struct command_registration testee_command_handlers[] = { .name = "testee", .mode = COMMAND_ANY, .help = "testee target commands", - .chain = hello_command_handlers, + .usage = "", }, COMMAND_REGISTRATION_DONE }; diff --git a/src/target/trace.c b/src/target/trace.c index 63c477f..943bf1f 100644 --- a/src/target/trace.c +++ b/src/target/trace.c @@ -53,7 +53,7 @@ COMMAND_HANDLER(handle_trace_point_command) uint32_t i; for (i = 0; i < trace->num_trace_points; i++) { - command_print(CMD_CTX, "trace point 0x%8.8" PRIx32 " (%lld times hit)", + command_print(CMD, "trace point 0x%8.8" PRIx32 " (%lld times hit)", trace->trace_points[i].address, (long long)trace->trace_points[i].hit_counter); } @@ -108,14 +108,14 @@ COMMAND_HANDLER(handle_trace_history_command) COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], trace->trace_history_size); trace->trace_history = malloc(sizeof(uint32_t) * trace->trace_history_size); - command_print(CMD_CTX, "new trace history size: %i", (int)(trace->trace_history_size)); + command_print(CMD, "new trace history size: %i", (int)(trace->trace_history_size)); } else { uint32_t i; uint32_t first = 0; uint32_t last = trace->trace_history_pos; if (!trace->trace_history_size) { - command_print(CMD_CTX, "trace history buffer is not allocated"); + command_print(CMD, "trace history buffer is not allocated"); return ERROR_OK; } @@ -128,11 +128,11 @@ COMMAND_HANDLER(handle_trace_history_command) if (trace->trace_history[i % trace->trace_history_size] < trace->num_trace_points) { uint32_t address; address = trace->trace_points[trace->trace_history[i % trace->trace_history_size]].address; - command_print(CMD_CTX, "trace point %i: 0x%8.8" PRIx32 "", + command_print(CMD, "trace point %i: 0x%8.8" PRIx32 "", (int)(trace->trace_history[i % trace->trace_history_size]), address); } else - command_print(CMD_CTX, "trace point %i: -not defined-", + command_print(CMD, "trace point %i: -not defined-", (int)(trace->trace_history[i % trace->trace_history_size])); } } diff --git a/src/target/x86_32_common.c b/src/target/x86_32_common.c index 011e7d8..b85e451 100644 --- a/src/target/x86_32_common.c +++ b/src/target/x86_32_common.c @@ -1340,7 +1340,7 @@ static int write_hw_reg_from_cache(struct target *t, int num) } /* x86 32 commands */ -static void handle_iod_output(struct command_context *cmd_ctx, +static void handle_iod_output(struct command_invocation *cmd, struct target *target, uint32_t address, unsigned size, unsigned count, const uint8_t *buffer) { @@ -1392,7 +1392,7 @@ static void handle_iod_output(struct command_context *cmd_ctx, value_fmt, value); if ((i % line_modulo == line_modulo - 1) || (i == count - 1)) { - command_print(cmd_ctx, "%s", output); + command_print(cmd, "%s", output); output_len = 0; } } @@ -1429,7 +1429,7 @@ COMMAND_HANDLER(handle_iod_command) struct target *target = get_current_target(CMD_CTX); int retval = x86_32_common_read_io(target, address, size, buffer); if (ERROR_OK == retval) - handle_iod_output(CMD_CTX, target, address, size, count, buffer); + handle_iod_output(CMD, target, address, size, count, buffer); free(buffer); return retval; } diff --git a/src/target/xscale.c b/src/target/xscale.c index 09abd9e..1a099c9 100644 --- a/src/target/xscale.c +++ b/src/target/xscale.c @@ -138,11 +138,11 @@ static int xscale_set_reg_u32(struct reg *reg, uint32_t value) static const char xscale_not[] = "target is not an XScale"; -static int xscale_verify_pointer(struct command_context *cmd_ctx, +static int xscale_verify_pointer(struct command_invocation *cmd, struct xscale_common *xscale) { if (xscale->common_magic != XSCALE_COMMON_MAGIC) { - command_print(cmd_ctx, xscale_not); + command_print(cmd, xscale_not); return ERROR_TARGET_INVALID; } return ERROR_OK; @@ -2654,16 +2654,16 @@ static inline void xscale_branch_address(struct xscale_trace_data *trace_data, static inline void xscale_display_instruction(struct target *target, uint32_t pc, struct arm_instruction *instruction, - struct command_context *cmd_ctx) + struct command_invocation *cmd) { int retval = xscale_read_instruction(target, pc, instruction); if (retval == ERROR_OK) - command_print(cmd_ctx, "%s", instruction->text); + command_print(cmd, "%s", instruction->text); else - command_print(cmd_ctx, "0x%8.8" PRIx32 "\t<not found in image>", pc); + command_print(cmd, "0x%8.8" PRIx32 "\t<not found in image>", pc); } -static int xscale_analyze_trace(struct target *target, struct command_context *cmd_ctx) +static int xscale_analyze_trace(struct target *target, struct command_invocation *cmd) { struct xscale_common *xscale = target_to_xscale(target); struct xscale_trace_data *trace_data = xscale->trace.data; @@ -2771,7 +2771,7 @@ static int xscale_analyze_trace(struct target *target, struct command_context *c count = trace_data->entries[i].data & 0x0f; for (j = 0; j < count; j++) { xscale_display_instruction(target, current_pc, &instruction, - cmd_ctx); + cmd); current_pc += xscale->trace.core_state == ARM_STATE_ARM ? 4 : 2; } @@ -2779,7 +2779,7 @@ static int xscale_analyze_trace(struct target *target, struct command_context *c * rollover and some exceptions: undef, swi, prefetch abort. */ if ((trace_msg_type == 15) || (exception > 0 && exception < 4)) { xscale_display_instruction(target, current_pc, &instruction, - cmd_ctx); + cmd); current_pc += xscale->trace.core_state == ARM_STATE_ARM ? 4 : 2; } @@ -2787,13 +2787,13 @@ static int xscale_analyze_trace(struct target *target, struct command_context *c continue; if (exception) { - command_print(cmd_ctx, "--- exception %i ---", exception); + command_print(cmd, "--- exception %i ---", exception); continue; } /* not exception or rollover; next instruction is a branch and is * not included in the count */ - xscale_display_instruction(target, current_pc, &instruction, cmd_ctx); + xscale_display_instruction(target, current_pc, &instruction, cmd); /* for direct branches, extract branch destination from instruction */ if ((trace_msg_type == 8) || (trace_msg_type == 12)) { @@ -2813,7 +2813,7 @@ static int xscale_analyze_trace(struct target *target, struct command_context *c } if (current_pc == 0) - command_print(cmd_ctx, "address unknown"); + command_print(cmd, "address unknown"); continue; } @@ -2855,7 +2855,7 @@ static int xscale_analyze_trace(struct target *target, struct command_context *c /* display remaining instructions */ for (i = 0; i < gap_count; i++) { - xscale_display_instruction(target, current_pc, &instruction, cmd_ctx); + xscale_display_instruction(target, current_pc, &instruction, cmd); current_pc += xscale->trace.core_state == ARM_STATE_ARM ? 4 : 2; } @@ -2895,6 +2895,7 @@ static void xscale_build_reg_cache(struct target *target) (*cache_p)->reg_list[i].size = 32; (*cache_p)->reg_list[i].arch_info = &arch_info[i]; (*cache_p)->reg_list[i].type = &xscale_reg_type; + (*cache_p)->reg_list[i].exist = true; arch_info[i] = xscale_reg_arch_info[i]; arch_info[i].target = target; } @@ -3032,7 +3033,7 @@ COMMAND_HANDLER(xscale_handle_debug_handler_command) } xscale = target_to_xscale(target); - retval = xscale_verify_pointer(CMD_CTX, xscale); + retval = xscale_verify_pointer(CMD, xscale); if (retval != ERROR_OK) return retval; @@ -3066,7 +3067,7 @@ COMMAND_HANDLER(xscale_handle_cache_clean_address_command) return ERROR_FAIL; } xscale = target_to_xscale(target); - retval = xscale_verify_pointer(CMD_CTX, xscale); + retval = xscale_verify_pointer(CMD, xscale); if (retval != ERROR_OK) return retval; @@ -3086,11 +3087,11 @@ COMMAND_HANDLER(xscale_handle_cache_info_command) struct xscale_common *xscale = target_to_xscale(target); int retval; - retval = xscale_verify_pointer(CMD_CTX, xscale); + retval = xscale_verify_pointer(CMD, xscale); if (retval != ERROR_OK) return retval; - return armv4_5_handle_cache_info_command(CMD_CTX, &xscale->armv4_5_mmu.armv4_5_cache); + return armv4_5_handle_cache_info_command(CMD, &xscale->armv4_5_mmu.armv4_5_cache); } static int xscale_virt2phys(struct target *target, @@ -3131,12 +3132,12 @@ COMMAND_HANDLER(xscale_handle_mmu_command) struct xscale_common *xscale = target_to_xscale(target); int retval; - retval = xscale_verify_pointer(CMD_CTX, xscale); + retval = xscale_verify_pointer(CMD, xscale); if (retval != ERROR_OK) return retval; if (target->state != TARGET_HALTED) { - command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME); + command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME); return ERROR_OK; } @@ -3150,7 +3151,7 @@ COMMAND_HANDLER(xscale_handle_mmu_command) xscale->armv4_5_mmu.mmu_enabled = enable; } - command_print(CMD_CTX, "mmu %s", + command_print(CMD, "mmu %s", (xscale->armv4_5_mmu.mmu_enabled) ? "enabled" : "disabled"); return ERROR_OK; @@ -3161,12 +3162,12 @@ COMMAND_HANDLER(xscale_handle_idcache_command) struct target *target = get_current_target(CMD_CTX); struct xscale_common *xscale = target_to_xscale(target); - int retval = xscale_verify_pointer(CMD_CTX, xscale); + int retval = xscale_verify_pointer(CMD, xscale); if (retval != ERROR_OK) return retval; if (target->state != TARGET_HALTED) { - command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME); + command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME); return ERROR_OK; } @@ -3195,7 +3196,7 @@ COMMAND_HANDLER(xscale_handle_idcache_command) xscale->armv4_5_mmu.armv4_5_cache.i_cache_enabled : xscale->armv4_5_mmu.armv4_5_cache.d_u_cache_enabled; const char *msg = enabled ? "enabled" : "disabled"; - command_print(CMD_CTX, "%s %s", CMD_NAME, msg); + command_print(CMD, "%s %s", CMD_NAME, msg); return ERROR_OK; } @@ -3222,7 +3223,7 @@ COMMAND_HANDLER(xscale_handle_vector_catch_command) uint32_t catch = 0; struct reg *dcsr_reg = &xscale->reg_cache->reg_list[XSCALE_DCSR]; - retval = xscale_verify_pointer(CMD_CTX, xscale); + retval = xscale_verify_pointer(CMD, xscale); if (retval != ERROR_OK) return retval; @@ -3257,7 +3258,7 @@ COMMAND_HANDLER(xscale_handle_vector_catch_command) dcsr_value = buf_get_u32(dcsr_reg->value, 0, 32); for (unsigned i = 0; i < ARRAY_SIZE(vec_ids); i++) { - command_print(CMD_CTX, "%15s: %s", vec_ids[i].name, + command_print(CMD, "%15s: %s", vec_ids[i].name, (dcsr_value & vec_ids[i].mask) ? "catch" : "ignore"); } @@ -3272,23 +3273,23 @@ COMMAND_HANDLER(xscale_handle_vector_table_command) int err = 0; int retval; - retval = xscale_verify_pointer(CMD_CTX, xscale); + retval = xscale_verify_pointer(CMD, xscale); if (retval != ERROR_OK) return retval; if (CMD_ARGC == 0) { /* print current settings */ int idx; - command_print(CMD_CTX, "active user-set static vectors:"); + command_print(CMD, "active user-set static vectors:"); for (idx = 1; idx < 8; idx++) if (xscale->static_low_vectors_set & (1 << idx)) - command_print(CMD_CTX, + command_print(CMD, "low %d: 0x%" PRIx32, idx, xscale->static_low_vectors[idx]); for (idx = 1; idx < 8; idx++) if (xscale->static_high_vectors_set & (1 << idx)) - command_print(CMD_CTX, + command_print(CMD, "high %d: 0x%" PRIx32, idx, xscale->static_high_vectors[idx]); @@ -3330,12 +3331,12 @@ COMMAND_HANDLER(xscale_handle_trace_buffer_command) uint32_t dcsr_value; int retval; - retval = xscale_verify_pointer(CMD_CTX, xscale); + retval = xscale_verify_pointer(CMD, xscale); if (retval != ERROR_OK) return retval; if (target->state != TARGET_HALTED) { - command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME); + command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME); return ERROR_OK; } @@ -3354,7 +3355,7 @@ COMMAND_HANDLER(xscale_handle_trace_buffer_command) if (CMD_ARGC >= 3) COMMAND_PARSE_NUMBER(int, CMD_ARGV[2], buffcount); if (buffcount < 1) { /* invalid */ - command_print(CMD_CTX, "fill buffer count must be > 0"); + command_print(CMD, "fill buffer count must be > 0"); xscale->trace.mode = XSCALE_TRACE_DISABLED; return ERROR_COMMAND_SYNTAX_ERROR; } @@ -3371,11 +3372,11 @@ COMMAND_HANDLER(xscale_handle_trace_buffer_command) if (xscale->trace.mode != XSCALE_TRACE_DISABLED) { char fill_string[12]; sprintf(fill_string, "fill %d", xscale->trace.buffer_fill); - command_print(CMD_CTX, "trace buffer enabled (%s)", + command_print(CMD, "trace buffer enabled (%s)", (xscale->trace.mode == XSCALE_TRACE_FILL) ? fill_string : "wrap"); } else - command_print(CMD_CTX, "trace buffer disabled"); + command_print(CMD, "trace buffer disabled"); dcsr_value = buf_get_u32(xscale->reg_cache->reg_list[XSCALE_DCSR].value, 0, 32); if (xscale->trace.mode == XSCALE_TRACE_FILL) @@ -3395,14 +3396,14 @@ COMMAND_HANDLER(xscale_handle_trace_image_command) if (CMD_ARGC < 1) return ERROR_COMMAND_SYNTAX_ERROR; - retval = xscale_verify_pointer(CMD_CTX, xscale); + retval = xscale_verify_pointer(CMD, xscale); if (retval != ERROR_OK) return retval; if (xscale->trace.image) { image_close(xscale->trace.image); free(xscale->trace.image); - command_print(CMD_CTX, "previously loaded image found and closed"); + command_print(CMD, "previously loaded image found and closed"); } xscale->trace.image = malloc(sizeof(struct image)); @@ -3434,12 +3435,12 @@ COMMAND_HANDLER(xscale_handle_dump_trace_command) struct fileio *file; int retval; - retval = xscale_verify_pointer(CMD_CTX, xscale); + retval = xscale_verify_pointer(CMD, xscale); if (retval != ERROR_OK) return retval; if (target->state != TARGET_HALTED) { - command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME); + command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME); return ERROR_OK; } @@ -3449,7 +3450,7 @@ COMMAND_HANDLER(xscale_handle_dump_trace_command) trace_data = xscale->trace.data; if (!trace_data) { - command_print(CMD_CTX, "no trace data collected"); + command_print(CMD, "no trace data collected"); return ERROR_OK; } @@ -3482,11 +3483,11 @@ COMMAND_HANDLER(xscale_handle_analyze_trace_buffer_command) struct xscale_common *xscale = target_to_xscale(target); int retval; - retval = xscale_verify_pointer(CMD_CTX, xscale); + retval = xscale_verify_pointer(CMD, xscale); if (retval != ERROR_OK) return retval; - xscale_analyze_trace(target, CMD_CTX); + xscale_analyze_trace(target, CMD); return ERROR_OK; } @@ -3497,12 +3498,12 @@ COMMAND_HANDLER(xscale_handle_cp15) struct xscale_common *xscale = target_to_xscale(target); int retval; - retval = xscale_verify_pointer(CMD_CTX, xscale); + retval = xscale_verify_pointer(CMD, xscale); if (retval != ERROR_OK) return retval; if (target->state != TARGET_HALTED) { - command_print(CMD_CTX, "target must be stopped for \"%s\" command", CMD_NAME); + command_print(CMD, "target must be stopped for \"%s\" command", CMD_NAME); return ERROR_OK; } uint32_t reg_no = 0; @@ -3536,7 +3537,7 @@ COMMAND_HANDLER(xscale_handle_cp15) reg_no = XSCALE_CPACCESS; break; default: - command_print(CMD_CTX, "invalid register number"); + command_print(CMD, "invalid register number"); return ERROR_COMMAND_SYNTAX_ERROR; } reg = &xscale->reg_cache->reg_list[reg_no]; @@ -3548,7 +3549,7 @@ COMMAND_HANDLER(xscale_handle_cp15) /* read cp15 control register */ xscale_get_reg(reg); value = buf_get_u32(reg->value, 0, 32); - command_print(CMD_CTX, "%s (/%i): 0x%" PRIx32 "", reg->name, (int)(reg->size), + command_print(CMD, "%s (/%i): 0x%" PRIx32 "", reg->name, (int)(reg->size), value); } else if (CMD_ARGC == 2) { uint32_t value; @@ -3577,6 +3578,7 @@ static const struct command_registration xscale_exec_command_handlers[] = { .handler = xscale_handle_cache_info_command, .mode = COMMAND_EXEC, .help = "display information about CPU caches", + .usage = "", }, { .name = "mmu", diff --git a/src/transport/transport.c b/src/transport/transport.c index 7085947..77db9e2 100644 --- a/src/transport/transport.c +++ b/src/transport/transport.c @@ -258,10 +258,10 @@ COMMAND_HANDLER(handle_transport_list) if (CMD_ARGC != 0) return ERROR_COMMAND_SYNTAX_ERROR; - command_print(CMD_CTX, "The following transports are available:"); + command_print(CMD, "The following transports are available:"); for (struct transport *t = transport_list; t; t = t->next) - command_print(CMD_CTX, "\t%s", t->name); + command_print(CMD, "\t%s", t->name); return ERROR_OK; } diff --git a/src/xsvf/xsvf.c b/src/xsvf/xsvf.c index 63c8915..e574c6f 100644 --- a/src/xsvf/xsvf.c +++ b/src/xsvf/xsvf.c @@ -249,14 +249,14 @@ COMMAND_HANDLER(handle_xsvf_command) if (strcmp(CMD_ARGV[0], "plain") != 0) { tap = jtag_tap_by_string(CMD_ARGV[0]); if (!tap) { - command_print(CMD_CTX, "Tap: %s unknown", CMD_ARGV[0]); + command_print(CMD, "Tap: %s unknown", CMD_ARGV[0]); return ERROR_FAIL; } } xsvf_fd = open(filename, O_RDONLY); if (xsvf_fd < 0) { - command_print(CMD_CTX, "file \"%s\" not found", filename); + command_print(CMD, "file \"%s\" not found", filename); return ERROR_FAIL; } @@ -1005,7 +1005,7 @@ COMMAND_HANDLER(handle_xsvf_command) } if (tdo_mismatch) { - command_print(CMD_CTX, + command_print(CMD, "TDO mismatch, somewhere near offset %lu in xsvf file, aborting", file_offset); @@ -1014,14 +1014,14 @@ COMMAND_HANDLER(handle_xsvf_command) if (unsupported) { off_t offset = lseek(xsvf_fd, 0, SEEK_CUR) - 1; - command_print(CMD_CTX, + command_print(CMD, "unsupported xsvf command (0x%02X) at offset %jd, aborting", uc, (intmax_t)offset); return ERROR_FAIL; } if (do_abort) { - command_print(CMD_CTX, "premature end of xsvf file detected, aborting"); + command_print(CMD, "premature end of xsvf file detected, aborting"); return ERROR_FAIL; } @@ -1036,7 +1036,7 @@ COMMAND_HANDLER(handle_xsvf_command) close(xsvf_fd); - command_print(CMD_CTX, "XSVF file programmed successfully"); + command_print(CMD, "XSVF file programmed successfully"); return ERROR_OK; } |