Fix usage of timeval_ms()

[fw/openocd] / src / target / nds32_v3_common.c

diff --git a/src/target/nds32_v3_common.c b/src/target/nds32_v3_common.c
index f0cd77d234079ab1e37a768adbf2be16f5311f87..191f4b5cc1b63c9d8b1fb8e664028af412357c13 100644 (file)
--- a/src/target/nds32_v3_common.c
+++ b/src/target/nds32_v3_common.c
@@ -13,9 +13,7 @@
  *   GNU General Public License for more details.                          *
  *                                                                         *
  *   You should have received a copy of the GNU General Public License     *
- *   along with this program; if not, write to the                         *
- *   Free Software Foundation, Inc.,                                       *
- *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.           *
+ *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
  ***************************************************************************/
 
 #ifdef HAVE_CONFIG_H
@@ -29,18 +27,6 @@
 #include "nds32_aice.h"
 #include "nds32_v3_common.h"
 
-static struct breakpoint syscall_breakpoint = {
-       0x80,
-       0,
-       4,
-       BKPT_SOFT,
-       0,
-       NULL,
-       NULL,
-       0x515CA11,
-       0,
-};
-
 static struct nds32_v3_common_callback *v3_common_callback;
 
 static int nds32_v3_register_mapping(struct nds32 *nds32, int reg_no)
@@ -71,8 +57,6 @@ static int nds32_v3_debug_entry(struct nds32 *nds32, bool enable_watchpoint)
 {
        LOG_DEBUG("nds32_v3_debug_entry");
 
-       jtag_poll_set_enabled(false);
-
        enum target_state backup_state = nds32->target->state;
        nds32->target->state = TARGET_HALTED;
 
@@ -92,17 +76,18 @@ static int nds32_v3_debug_entry(struct nds32 *nds32, bool enable_watchpoint)
        if (enable_watchpoint)
                CHECK_RETVAL(v3_common_callback->deactivate_hardware_watchpoint(nds32->target));
 
+       struct breakpoint *syscall_break = &(nds32->syscall_break);
        if (nds32->virtual_hosting) {
-               if (syscall_breakpoint.set) {
+               if (syscall_break->set) {
                        /** disable virtual hosting */
 
                        /* remove breakpoint at syscall entry */
-                       target_remove_breakpoint(nds32->target, &syscall_breakpoint);
-                       syscall_breakpoint.set = 0;
+                       target_remove_breakpoint(nds32->target, syscall_break);
+                       syscall_break->set = 0;
 
                        uint32_t value_pc;
                        nds32_get_mapped_reg(nds32, PC, &value_pc);
-                       if (value_pc == syscall_breakpoint.address)
+                       if (value_pc == syscall_break->address)
                                /** process syscall for virtual hosting */
                                nds32->hit_syscall = true;
                }
@@ -117,8 +102,6 @@ static int nds32_v3_debug_entry(struct nds32 *nds32, bool enable_watchpoint)
                if (enable_watchpoint)
                        CHECK_RETVAL(v3_common_callback->activate_hardware_watchpoint(nds32->target));
 
-               jtag_poll_set_enabled(true);
-
                return ERROR_FAIL;
        }
 
@@ -222,14 +205,13 @@ static int nds32_v3_leave_debug_state(struct nds32 *nds32, bool enable_watchpoin
                }
 
                /* insert breakpoint at syscall entry */
-               syscall_breakpoint.address = syscall_address;
-               syscall_breakpoint.type = BKPT_SOFT;
-               syscall_breakpoint.set = 1;
-               target_add_breakpoint(target, &syscall_breakpoint);
-       }
+               struct breakpoint *syscall_break = &(nds32->syscall_break);
 
-       /* enable polling */
-       jtag_poll_set_enabled(true);
+               syscall_break->address = syscall_address;
+               syscall_break->type = BKPT_SOFT;
+               syscall_break->set = 1;
+               target_add_breakpoint(target, syscall_break);
+       }
 
        return ERROR_OK;
 }
@@ -247,6 +229,7 @@ static int nds32_v3_get_exception_address(struct nds32 *nds32,
        uint32_t match_count;
        int32_t i;
        static int32_t number_of_hard_break;
+       uint32_t bp_control;
 
        if (number_of_hard_break == 0) {
                aice_read_debug_reg(aice, NDS_EDM_SR_EDM_CFG, &edm_cfg);
@@ -262,6 +245,14 @@ static int nds32_v3_get_exception_address(struct nds32 *nds32,
                if (match_bits & (1 << i)) {
                        aice_read_debug_reg(aice, NDS_EDM_SR_BPA0 + i, address);
                        match_count++;
+
+                       /* If target hits multiple read/access watchpoint,
+                        * select the first one. */
+                       aice_read_debug_reg(aice, NDS_EDM_SR_BPC0 + i, &bp_control);
+                       if (0x3 == (bp_control & 0x3)) {
+                               match_count = 1;
+                               break;
+                       }
                }
        }
 
@@ -288,8 +279,8 @@ static int nds32_v3_get_exception_address(struct nds32 *nds32,
                nds32_read_opcode(nds32, val_pc, &opcode);
                nds32_evaluate_opcode(nds32, opcode, val_pc, &instruction);
 
-               LOG_DEBUG("PC: 0x%08x, access start: 0x%08x, end: 0x%08x", val_pc,
-                               instruction.access_start, instruction.access_end);
+               LOG_DEBUG("PC: 0x%08" PRIx32 ", access start: 0x%08" PRIx32 ", end: 0x%08" PRIx32,
+                               val_pc, instruction.access_start, instruction.access_end);
 
                /* check if multiple hits in the access range */
                uint32_t in_range_watch_count = 0;
@@ -376,12 +367,6 @@ int nds32_v3_target_request_data(struct target *target,
        return ERROR_OK;
 }
 
-int nds32_v3_soft_reset_halt(struct target *target)
-{
-       struct aice_port_s *aice = target_to_aice(target);
-       return aice_assert_srst(aice, AICE_RESET_HOLD);
-}
-
 int nds32_v3_checksum_memory(struct target *target,
                uint32_t address, uint32_t count, uint32_t *checksum)
 {
@@ -553,19 +538,25 @@ int nds32_v3_write_buffer(struct target *target, uint32_t address,
                return ERROR_FAIL;
 
        if (nds32->hit_syscall) {
-               /* Use bus mode to access memory during virtual hosting */
                struct aice_port_s *aice = target_to_aice(target);
                enum nds_memory_access origin_access_channel;
-               int result;
-
                origin_access_channel = memory->access_channel;
-               memory->access_channel = NDS_MEMORY_ACC_BUS;
-               aice_memory_access(aice, NDS_MEMORY_ACC_BUS);
 
+               /* If target has no cache, use BUS mode to access memory. */
+               if ((memory->dcache.line_size == 0)
+                       || (memory->dcache.enable == false)) {
+                       /* There is no Dcache or Dcache is disabled. */
+                       memory->access_channel = NDS_MEMORY_ACC_BUS;
+                       aice_memory_access(aice, NDS_MEMORY_ACC_BUS);
+               }
+
+               int result;
                result = nds32_gdb_fileio_write_memory(nds32, address, size, buffer);
 
-               memory->access_channel = origin_access_channel;
-               aice_memory_access(aice, origin_access_channel);
+               if (NDS_MEMORY_ACC_CPU == origin_access_channel) {
+                       memory->access_channel = NDS_MEMORY_ACC_CPU;
+                       aice_memory_access(aice, NDS_MEMORY_ACC_CPU);
+               }
 
                return result;
        }