src/target/espressif/esp_xtensa.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 /***************************************************************************
   4  *   Espressif Xtensa target API for OpenOCD                               *
   5  *   Copyright (C) 2019 Espressif Systems Ltd.                             *
   6  ***************************************************************************/
   7
   8 #ifdef HAVE_CONFIG_H
   9 #include <config.h>
  10 #endif
  11
  12 #include <stdbool.h>
  13 #include <stdint.h>
  14 #include <target/smp.h>
  15 #include <target/register.h>
  16 #include "esp.h"
  17 #include "esp_xtensa.h"
  18 #include "esp_xtensa_apptrace.h"
  19 #include "esp_semihosting.h"
  20 #include "esp_xtensa_algorithm.h"
  21
  22 #define ESP_XTENSA_DBGSTUBS_UPDATE_DATA_ENTRY(_e_) \
  23         do { \
  24                 uint32_t __internal_val = (_e_); \
  25                 if (!xtensa_data_addr_valid(target, __internal_val)) { \
  26                         LOG_ERROR("No valid stub data entry found (0x%" PRIx32 ")!", __internal_val); \
  27                         return; \
  28                 } \
  29         } while (0)
  30
  31 #define ESP_XTENSA_DBGSTUBS_UPDATE_CODE_ENTRY(_e_) \
  32         do { \
  33                 uint32_t __internal_val = (_e_); \
  34                 if (__internal_val == 0) { \
  35                         LOG_ERROR("No valid stub code entry found (0x%" PRIx32 ")!", __internal_val); \
  36                         return; \
  37                 } \
  38         } while (0)
  39
  40 static void esp_xtensa_dbgstubs_info_update(struct target *target);
  41 static void esp_xtensa_dbgstubs_addr_check(struct target *target);
  42
  43 static int esp_xtensa_dbgstubs_restore(struct target *target)
  44 {
  45         struct esp_xtensa_common *esp_xtensa = target_to_esp_xtensa(target);
  46
  47         if (esp_xtensa->esp.dbg_stubs.base == 0)
  48                 return ERROR_OK;
  49
  50         LOG_TARGET_INFO(target, "Restore debug stubs address %" PRIx32, esp_xtensa->esp.dbg_stubs.base);
  51         int res = esp_xtensa_apptrace_status_reg_write(target, esp_xtensa->esp.dbg_stubs.base);
  52         if (res != ERROR_OK) {
  53                 LOG_ERROR("Failed to write trace status (%d)!", res);
  54                 return res;
  55         }
  56         return ERROR_OK;
  57 }
  58 int esp_xtensa_on_halt(struct target *target)
  59 {
  60         /* debug stubs can be used in HALTED state only, so it is OK to get info about them here */
  61         esp_xtensa_dbgstubs_info_update(target);
  62         return ERROR_OK;
  63 }
  64
  65 int esp_xtensa_init_arch_info(struct target *target,
  66         struct esp_xtensa_common *esp_xtensa,
  67         struct xtensa_debug_module_config *dm_cfg,
  68         const struct esp_semihost_ops *semihost_ops)
  69 {
  70         int ret = xtensa_init_arch_info(target, &esp_xtensa->xtensa, dm_cfg);
  71         if (ret != ERROR_OK)
  72                 return ret;
  73         ret = esp_common_init(&esp_xtensa->esp, &xtensa_algo_hw);
  74         if (ret != ERROR_OK)
  75                 return ret;
  76
  77         esp_xtensa->semihost.ops = (struct esp_semihost_ops *)semihost_ops;
  78         esp_xtensa->apptrace.hw = &esp_xtensa_apptrace_hw;
  79         return ERROR_OK;
  80 }
  81
  82 int esp_xtensa_target_init(struct command_context *cmd_ctx, struct target *target)
  83 {
  84         return xtensa_target_init(cmd_ctx, target);
  85 }
  86
  87 void esp_xtensa_target_deinit(struct target *target)
  88 {
  89         LOG_DEBUG("start");
  90
  91         if (target_was_examined(target)) {
  92                 int ret = esp_xtensa_dbgstubs_restore(target);
  93                 if (ret != ERROR_OK)
  94                         return;
  95         }
  96         xtensa_target_deinit(target);
  97         free(target_to_esp_xtensa(target));     /* same as free(xtensa) */
  98 }
  99
 100 int esp_xtensa_arch_state(struct target *target)
 101 {
 102         return ERROR_OK;
 103 }
 104
 105 int esp_xtensa_poll(struct target *target)
 106 {
 107         struct xtensa *xtensa = target_to_xtensa(target);
 108         struct esp_xtensa_common *esp_xtensa_common = target_to_esp_xtensa(target);
 109
 110         int ret = xtensa_poll(target);
 111
 112         if (xtensa_dm_power_status_get(&xtensa->dbg_mod) & PWRSTAT_COREWASRESET(xtensa)) {
 113                 LOG_TARGET_DEBUG(target, "Clear debug stubs info");
 114                 memset(&esp_xtensa_common->esp.dbg_stubs, 0, sizeof(esp_xtensa_common->esp.dbg_stubs));
 115         }
 116         if (target->state != TARGET_DEBUG_RUNNING)
 117                 esp_xtensa_dbgstubs_addr_check(target);
 118         return ret;
 119 }
 120
 121 static void esp_xtensa_dbgstubs_addr_check(struct target *target)
 122 {
 123         struct esp_xtensa_common *esp_xtensa = target_to_esp_xtensa(target);
 124         uint32_t vec_addr = 0;
 125
 126         if (esp_xtensa->esp.dbg_stubs.base != 0)
 127                 return;
 128
 129         int res = esp_xtensa_apptrace_status_reg_read(target, &vec_addr);
 130         if (res != ERROR_OK) {
 131                 LOG_ERROR("Failed to read debug stubs address location (%d)!", res);
 132                 return;
 133         }
 134         if (xtensa_data_addr_valid(target, vec_addr)) {
 135                 LOG_TARGET_INFO(target, "Detected debug stubs @ %" PRIx32, vec_addr);
 136                 res = esp_xtensa_apptrace_status_reg_write(target, 0);
 137                 if (res != ERROR_OK)
 138                         LOG_ERROR("Failed to clear debug stubs address location (%d)!", res);
 139                 esp_xtensa->esp.dbg_stubs.base = vec_addr;
 140         }
 141 }
 142
 143 static void esp_xtensa_dbgstubs_info_update(struct target *target)
 144 {
 145         struct esp_xtensa_common *esp_xtensa = target_to_esp_xtensa(target);
 146
 147         if (esp_xtensa->esp.dbg_stubs.base == 0 || esp_xtensa->esp.dbg_stubs.entries_count != 0)
 148                 return;
 149
 150         int res = esp_dbgstubs_table_read(target, &esp_xtensa->esp.dbg_stubs);
 151         if (res != ERROR_OK)
 152                 return;
 153         if (esp_xtensa->esp.dbg_stubs.entries_count == 0)
 154                 return;
 155
 156         /* read debug stubs descriptor */
 157         ESP_XTENSA_DBGSTUBS_UPDATE_DATA_ENTRY(esp_xtensa->esp.dbg_stubs.entries[ESP_DBG_STUB_DESC]);
 158         res = target_read_buffer(target, esp_xtensa->esp.dbg_stubs.entries[ESP_DBG_STUB_DESC],
 159                 sizeof(struct esp_dbg_stubs_desc),
 160                 (uint8_t *)&esp_xtensa->esp.dbg_stubs.desc);
 161         if (res != ERROR_OK) {
 162                 LOG_ERROR("Failed to read debug stubs descriptor (%d)!", res);
 163                 return;
 164         }
 165         ESP_XTENSA_DBGSTUBS_UPDATE_CODE_ENTRY(esp_xtensa->esp.dbg_stubs.desc.tramp_addr);
 166         ESP_XTENSA_DBGSTUBS_UPDATE_DATA_ENTRY(esp_xtensa->esp.dbg_stubs.desc.min_stack_addr);
 167         ESP_XTENSA_DBGSTUBS_UPDATE_CODE_ENTRY(esp_xtensa->esp.dbg_stubs.desc.data_alloc);
 168         ESP_XTENSA_DBGSTUBS_UPDATE_CODE_ENTRY(esp_xtensa->esp.dbg_stubs.desc.data_free);
 169 }
 170
 171 int esp_xtensa_breakpoint_add(struct target *target, struct breakpoint *breakpoint)
 172 {
 173         return xtensa_breakpoint_add(target, breakpoint);
 174         /* flash breakpoints will be handled in another patch */
 175 }
 176
 177 int esp_xtensa_breakpoint_remove(struct target *target, struct breakpoint *breakpoint)
 178 {
 179         return xtensa_breakpoint_remove(target, breakpoint);
 180         /* flash breakpoints will be handled in another patch */
 181 }