src/target/armv7a.c

   1 /***************************************************************************
   2  *    Copyright (C) 2009 by David Brownell                                 *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  18  ***************************************************************************/
  19 #ifdef HAVE_CONFIG_H
  20 #include "config.h"
  21 #endif
  22
  23 #include "replacements.h"
  24
  25 #include "armv7a.h"
  26 #include "arm_disassembler.h"
  27
  28 #include "register.h"
  29 #include "binarybuffer.h"
  30 #include "command.h"
  31
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <unistd.h>
  35
  36
  37 static void armv7a_show_fault_registers(struct target *target)
  38 {
  39         uint32_t dfsr, ifsr, dfar, ifar;
  40         struct armv7a_common *armv7a = target_to_armv7a(target);
  41         struct arm_dpm *dpm = armv7a->armv4_5_common.dpm;
  42         int retval;
  43
  44         retval = dpm->prepare(dpm);
  45         if (retval != ERROR_OK)
  46                 return;
  47
  48         /* ARMV4_5_MRC(cpnum, op1, r0, CRn, CRm, op2) */
  49
  50         /* c5/c0 - {data, instruction} fault status registers */
  51         retval = dpm->instr_read_data_r0(dpm,
  52                         ARMV4_5_MRC(15, 0, 0, 5, 0, 0),
  53                         &dfsr);
  54         if (retval != ERROR_OK)
  55                 goto done;
  56
  57         retval = dpm->instr_read_data_r0(dpm,
  58                         ARMV4_5_MRC(15, 0, 0, 5, 0, 1),
  59                         &ifsr);
  60         if (retval != ERROR_OK)
  61                 goto done;
  62
  63         /* c6/c0 - {data, instruction} fault address registers */
  64         retval = dpm->instr_read_data_r0(dpm,
  65                         ARMV4_5_MRC(15, 0, 0, 6, 0, 0),
  66                         &dfar);
  67         if (retval != ERROR_OK)
  68                 goto done;
  69
  70         retval = dpm->instr_read_data_r0(dpm,
  71                         ARMV4_5_MRC(15, 0, 0, 6, 0, 2),
  72                         &ifar);
  73         if (retval != ERROR_OK)
  74                 goto done;
  75
  76         LOG_USER("Data fault registers        DFSR: %8.8" PRIx32
  77                         ", DFAR: %8.8" PRIx32, dfsr, dfar);
  78         LOG_USER("Instruction fault registers IFSR: %8.8" PRIx32
  79                         ", IFAR: %8.8" PRIx32, ifsr, ifar);
  80
  81 done:
  82         /* (void) */ dpm->finish(dpm);
  83 }
  84
  85 int armv7a_arch_state(struct target *target)
  86 {
  87         static const char *state[] =
  88         {
  89                 "disabled", "enabled"
  90         };
  91
  92         struct armv7a_common *armv7a = target_to_armv7a(target);
  93         struct arm *armv4_5 = &armv7a->armv4_5_common;
  94
  95         if (armv7a->common_magic != ARMV7_COMMON_MAGIC)
  96         {
  97                 LOG_ERROR("BUG: called for a non-ARMv7A target");
  98                 return ERROR_INVALID_ARGUMENTS;
  99         }
 100
 101         LOG_USER("target halted in %s state due to %s, current mode: %s\n"
 102                          "cpsr: 0x%8.8" PRIx32 " pc: 0x%8.8" PRIx32 "\n"
 103                          "MMU: %s, D-Cache: %s, I-Cache: %s",
 104                  armv4_5_state_strings[armv4_5->core_state],
 105                  Jim_Nvp_value2name_simple(nvp_target_debug_reason,
 106                                 target->debug_reason)->name,
 107                  arm_mode_name(armv4_5->core_mode),
 108                  buf_get_u32(armv4_5->cpsr->value, 0, 32),
 109                  buf_get_u32(armv4_5->core_cache->reg_list[15].value, 0, 32),
 110                  state[armv7a->armv4_5_mmu.mmu_enabled],
 111                  state[armv7a->armv4_5_mmu.armv4_5_cache.d_u_cache_enabled],
 112                  state[armv7a->armv4_5_mmu.armv4_5_cache.i_cache_enabled]);
 113
 114         if (armv4_5->core_mode == ARMV4_5_MODE_ABT)
 115                 armv7a_show_fault_registers(target);
 116
 117         return ERROR_OK;
 118 }
 119
 120
 121 COMMAND_HANDLER(handle_dap_baseaddr_command)
 122 {
 123         struct target *target = get_current_target(CMD_CTX);
 124         struct armv7a_common *armv7a = target_to_armv7a(target);
 125         struct swjdp_common *swjdp = &armv7a->swjdp_info;
 126
 127         return CALL_COMMAND_HANDLER(dap_baseaddr_command, swjdp);
 128 }
 129
 130 COMMAND_HANDLER(handle_dap_memaccess_command)
 131 {
 132         struct target *target = get_current_target(CMD_CTX);
 133         struct armv7a_common *armv7a = target_to_armv7a(target);
 134         struct swjdp_common *swjdp = &armv7a->swjdp_info;
 135
 136         return CALL_COMMAND_HANDLER(dap_memaccess_command, swjdp);
 137 }
 138
 139 COMMAND_HANDLER(handle_dap_apsel_command)
 140 {
 141         struct target *target = get_current_target(CMD_CTX);
 142         struct armv7a_common *armv7a = target_to_armv7a(target);
 143         struct swjdp_common *swjdp = &armv7a->swjdp_info;
 144
 145         return CALL_COMMAND_HANDLER(dap_apsel_command, swjdp);
 146 }
 147
 148 COMMAND_HANDLER(handle_dap_apid_command)
 149 {
 150         struct target *target = get_current_target(CMD_CTX);
 151         struct armv7a_common *armv7a = target_to_armv7a(target);
 152         struct swjdp_common *swjdp = &armv7a->swjdp_info;
 153
 154         return CALL_COMMAND_HANDLER(dap_apid_command, swjdp);
 155 }
 156
 157 COMMAND_HANDLER(handle_dap_info_command)
 158 {
 159         struct target *target = get_current_target(CMD_CTX);
 160         struct armv7a_common *armv7a = target_to_armv7a(target);
 161         struct swjdp_common *swjdp = &armv7a->swjdp_info;
 162         uint32_t apsel;
 163
 164         switch (CMD_ARGC) {
 165         case 0:
 166                 apsel = swjdp->apsel;
 167                 break;
 168         case 1:
 169                 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], apsel);
 170                 break;
 171         default:
 172                 return ERROR_COMMAND_SYNTAX_ERROR;
 173         }
 174
 175         return dap_info_command(CMD_CTX, swjdp, apsel);
 176 }
 177
 178 static const struct command_registration armv7a_exec_command_handlers[] = {
 179         {
 180                 .name = "info",
 181                 .handler = &handle_dap_info_command,
 182                 .mode = COMMAND_EXEC,
 183                 .help = "dap info for ap [num], "
 184                         "default currently selected AP",
 185         },
 186         {
 187                 .name = "apsel",
 188                 .handler = &handle_dap_apsel_command,
 189                 .mode = COMMAND_EXEC,
 190                 .help = "select a different AP [num] (default 0)",
 191         },
 192         {
 193                 .name = "apid",
 194                 .handler = &handle_dap_apid_command,
 195                 .mode = COMMAND_EXEC,
 196                 .help = "return id reg from AP [num], "
 197                         "default currently selected AP",
 198         },
 199         {
 200                 .name = "baseaddr",
 201                 .handler = &handle_dap_baseaddr_command,
 202                 .mode = COMMAND_EXEC,
 203                 .help = "return debug base address from AP [num], "
 204                         "default currently selected AP",
 205         },
 206         {
 207                 .name = "memaccess",
 208                 .handler = &handle_dap_memaccess_command,
 209                 .mode = COMMAND_EXEC,
 210                 .help = "set/get number of extra tck for mem-ap memory "
 211                         "bus access [0-255]",
 212         },
 213         COMMAND_REGISTRATION_DONE
 214 };
 215 const struct command_registration armv7a_command_handlers[] = {
 216         {
 217                 .name = "dap",
 218                 .mode = COMMAND_ANY,
 219                 .help = "Cortex DAP command group",
 220                 .chain = armv7a_exec_command_handlers,
 221         },
 222         COMMAND_REGISTRATION_DONE
 223 };
 224