src/target/avrt.c

   1 /***************************************************************************
   2  *   Copyright (C) 2009 by Simon Qian                                      *
   3  *   SimonQian@SimonQian.com                                               *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #endif
  23
  24 #include "avrt.h"
  25 #include "target.h"
  26 #include "target_type.h"
  27
  28
  29 #define AVR_JTAG_INS_LEN        4
  30
  31 /* forward declarations */
  32 static int avr_target_create(struct target *target, Jim_Interp *interp);
  33 static int avr_init_target(struct command_context *cmd_ctx, struct target *target);
  34
  35 static int avr_arch_state(struct target *target);
  36 static int avr_poll(struct target *target);
  37 static int avr_halt(struct target *target);
  38 static int avr_resume(struct target *target, int current, uint32_t address, int handle_breakpoints, int debug_execution);
  39 static int avr_step(struct target *target, int current, uint32_t address, int handle_breakpoints);
  40
  41 static int avr_assert_reset(struct target *target);
  42 static int avr_deassert_reset(struct target *target);
  43 static int avr_soft_reset_halt(struct target *target);
  44
  45 /* IR and DR functions */
  46 static int mcu_write_ir(struct jtag_tap *tap, uint8_t *ir_in, uint8_t *ir_out, int ir_len, int rti);
  47 static int mcu_write_dr(struct jtag_tap *tap, uint8_t *dr_in, uint8_t *dr_out, int dr_len, int rti);
  48 static int mcu_write_ir_u8(struct jtag_tap *tap, uint8_t *ir_in, uint8_t ir_out, int ir_len, int rti);
  49 static int mcu_write_dr_u32(struct jtag_tap *tap, uint32_t *ir_in, uint32_t ir_out, int dr_len, int rti);
  50
  51 struct target_type avr_target =
  52 {
  53         .name = "avr",
  54
  55         .poll = avr_poll,
  56         .arch_state = avr_arch_state,
  57
  58         .target_request_data = NULL,
  59
  60         .halt = avr_halt,
  61         .resume = avr_resume,
  62         .step = avr_step,
  63
  64         .assert_reset = avr_assert_reset,
  65         .deassert_reset = avr_deassert_reset,
  66         .soft_reset_halt = avr_soft_reset_halt,
  67 /*
  68         .get_gdb_reg_list = avr_get_gdb_reg_list,
  69
  70         .read_memory = avr_read_memory,
  71         .write_memory = avr_write_memory,
  72         .bulk_write_memory = avr_bulk_write_memory,
  73         .checksum_memory = avr_checksum_memory,
  74         .blank_check_memory = avr_blank_check_memory,
  75
  76         .run_algorithm = avr_run_algorithm,
  77
  78         .add_breakpoint = avr_add_breakpoint,
  79         .remove_breakpoint = avr_remove_breakpoint,
  80         .add_watchpoint = avr_add_watchpoint,
  81         .remove_watchpoint = avr_remove_watchpoint,
  82 */
  83         .target_create = avr_target_create,
  84         .init_target = avr_init_target,
  85 };
  86
  87 static int avr_target_create(struct target *target, Jim_Interp *interp)
  88 {
  89         struct avr_common *avr = calloc(1, sizeof(struct avr_common));
  90
  91         avr->jtag_info.tap = target->tap;
  92         target->arch_info = avr;
  93
  94         return ERROR_OK;
  95 }
  96
  97 static int avr_init_target(struct command_context *cmd_ctx, struct target *target)
  98 {
  99         LOG_DEBUG("%s", __FUNCTION__);
 100         return ERROR_OK;
 101 }
 102
 103 static int avr_arch_state(struct target *target)
 104 {
 105         LOG_DEBUG("%s", __FUNCTION__);
 106         return ERROR_OK;
 107 }
 108
 109 static int avr_poll(struct target *target)
 110 {
 111         if ((target->state == TARGET_RUNNING) || (target->state == TARGET_DEBUG_RUNNING))
 112         {
 113                 target->state = TARGET_HALTED;
 114         }
 115
 116         LOG_DEBUG("%s", __FUNCTION__);
 117         return ERROR_OK;
 118 }
 119
 120 static int avr_halt(struct target *target)
 121 {
 122         LOG_DEBUG("%s", __FUNCTION__);
 123         return ERROR_OK;
 124 }
 125
 126 static int avr_resume(struct target *target, int current, uint32_t address,
 127                 int handle_breakpoints, int debug_execution)
 128 {
 129         LOG_DEBUG("%s", __FUNCTION__);
 130         return ERROR_OK;
 131 }
 132
 133 static int avr_step(struct target *target, int current, uint32_t address, int handle_breakpoints)
 134 {
 135         LOG_DEBUG("%s", __FUNCTION__);
 136         return ERROR_OK;
 137 }
 138
 139 static int avr_assert_reset(struct target *target)
 140 {
 141         target->state = TARGET_RESET;
 142
 143         LOG_DEBUG("%s", __FUNCTION__);
 144         return ERROR_OK;
 145 }
 146
 147 static int avr_deassert_reset(struct target *target)
 148 {
 149         target->state = TARGET_RUNNING;
 150
 151         LOG_DEBUG("%s", __FUNCTION__);
 152         return ERROR_OK;
 153 }
 154
 155 static int avr_soft_reset_halt(struct target *target)
 156 {
 157         LOG_DEBUG("%s", __FUNCTION__);
 158         return ERROR_OK;
 159 }
 160
 161 int avr_jtag_senddat(struct jtag_tap *tap, uint32_t* dr_in, uint32_t dr_out,
 162                 int len)
 163 {
 164         return mcu_write_dr_u32(tap, dr_in, dr_out, len, 1);
 165 }
 166
 167 int avr_jtag_sendinstr(struct jtag_tap *tap, uint8_t *ir_in, uint8_t ir_out)
 168 {
 169         return mcu_write_ir_u8(tap, ir_in, ir_out, AVR_JTAG_INS_LEN, 1);
 170 }
 171
 172 /* IR and DR functions */
 173 static int mcu_write_ir(struct jtag_tap *tap, uint8_t *ir_in, uint8_t *ir_out,
 174                 int ir_len, int rti)
 175 {
 176         if (NULL == tap)
 177         {
 178                 LOG_ERROR("invalid tap");
 179                 return ERROR_FAIL;
 180         }
 181         if (ir_len != tap->ir_length)
 182         {
 183                 LOG_ERROR("invalid ir_len");
 184                 return ERROR_FAIL;
 185         }
 186
 187         {
 188                 jtag_add_plain_ir_scan(tap->ir_length, ir_out, ir_in, TAP_IDLE);
 189         }
 190
 191         return ERROR_OK;
 192 }
 193
 194 static int mcu_write_dr(struct jtag_tap *tap, uint8_t *dr_in, uint8_t *dr_out,
 195                 int dr_len, int rti)
 196 {
 197         if (NULL == tap)
 198         {
 199                 LOG_ERROR("invalid tap");
 200                 return ERROR_FAIL;
 201         }
 202
 203         {
 204                 jtag_add_plain_dr_scan(dr_len, dr_out, dr_in, TAP_IDLE);
 205         }
 206
 207         return ERROR_OK;
 208 }
 209
 210 static int mcu_write_ir_u8(struct jtag_tap *tap, uint8_t *ir_in,
 211                 uint8_t ir_out, int ir_len, int rti)
 212 {
 213         if (ir_len > 8)
 214         {
 215                 LOG_ERROR("ir_len overflow, maxium is 8");
 216                 return ERROR_FAIL;
 217         }
 218
 219         mcu_write_ir(tap, ir_in, &ir_out, ir_len, rti);
 220
 221         return ERROR_OK;
 222 }
 223
 224 static int mcu_write_dr_u32(struct jtag_tap *tap, uint32_t *dr_in,
 225                 uint32_t dr_out, int dr_len, int rti)
 226 {
 227         if (dr_len > 32)
 228         {
 229                 LOG_ERROR("dr_len overflow, maxium is 32");
 230                 return ERROR_FAIL;
 231         }
 232
 233         mcu_write_dr(tap, (uint8_t*)dr_in, (uint8_t*)&dr_out, dr_len, rti);
 234
 235         return ERROR_OK;
 236 }
 237
 238 int mcu_execute_queue(void)
 239 {
 240         return jtag_execute_queue();
 241 }