git.sur5r.net Git - openocd/blob - src/target/avrt.c

   1 /***************************************************************************\r
   2  *   Copyright (C) 2009 by Simon Qian                                      *\r
   3  *   SimonQian@SimonQian.com                                               *\r
   4  *                                                                         *\r
   5  *   This program is free software; you can redistribute it and/or modify  *\r
   6  *   it under the terms of the GNU General Public License as published by  *\r
   7  *   the Free Software Foundation; either version 2 of the License, or     *\r
   8  *   (at your option) any later version.                                   *\r
   9  *                                                                         *\r
  10  *   This program is distributed in the hope that it will be useful,       *\r
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *\r
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *\r
  13  *   GNU General Public License for more details.                          *\r
  14  *                                                                         *\r
  15  *   You should have received a copy of the GNU General Public License     *\r
  16  *   along with this program; if not, write to the                         *\r
  17  *   Free Software Foundation, Inc.,                                       *\r
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *\r
  19  ***************************************************************************/\r
  20 #ifdef HAVE_CONFIG_H\r
  21 #include "config.h"\r
  22 #endif\r
  23 \r
  24 #include "replacements.h"\r
  25 \r
  26 #include "avrt.h"\r
  27 \r
  28 #include "register.h"\r
  29 #include "target.h"\r
  30 #include "log.h"\r
  31 #include "jtag.h"\r
  32 #include "binarybuffer.h"\r
  33 #include "time_support.h"\r
  34 #include "breakpoints.h"\r
  35 #include "fileio.h"\r
  36 \r
  37 #include <stdlib.h>\r
  38 #include <string.h>\r
  39 \r
  40 #include <sys/types.h>\r
  41 #include <unistd.h>\r
  42 #include <errno.h>\r
  43 \r
  44 #define AVR_JTAG_INS_LEN                                                        4\r
  45 \r
  46 /* cli handling */\r
  47 int avr_register_commands(struct command_context_s *cmd_ctx);\r
  48 \r
  49 /* forward declarations */\r
  50 int avr_target_create(struct target_s *target, Jim_Interp *interp);\r
  51 int avr_init_target(struct command_context_s *cmd_ctx, struct target_s *target);\r
  52 int avr_quit(void);\r
  53 \r
  54 int avr_arch_state(struct target_s *target);\r
  55 int avr_poll(target_t *target);\r
  56 int avr_halt(target_t *target);\r
  57 int avr_resume(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution);\r
  58 int avr_step(struct target_s *target, int current, u32 address, int handle_breakpoints);\r
  59 \r
  60 int avr_assert_reset(target_t *target);\r
  61 int avr_deassert_reset(target_t *target);\r
  62 int avr_soft_reset_halt(struct target_s *target);\r
  63 \r
  64 /* IR and DR functions */\r
  65 int avr_jtag_sendinstr(jtag_tap_t *tap, u8 *ir_in, u8 ir_out);\r
  66 int avr_jtag_senddat(jtag_tap_t *tap, u32 *dr_in, u32 dr_out, int len);\r
  67 \r
  68 int mcu_write_ir(jtag_tap_t *tap, u8 *ir_in, u8 *ir_out, int ir_len, int rti);\r
  69 int mcu_write_dr(jtag_tap_t *tap, u8 *dr_in, u8 *dr_out, int dr_len, int rti);\r
  70 int mcu_write_ir_u8(jtag_tap_t *tap, u8 *ir_in, u8 ir_out, int ir_len, int rti);\r
  71 int mcu_write_dr_u8(jtag_tap_t *tap, u8 *ir_in, u8 ir_out, int dr_len, int rti);\r
  72 int mcu_write_ir_u16(jtag_tap_t *tap, u16 *ir_in, u16 ir_out, int ir_len, int rti);\r
  73 int mcu_write_dr_u16(jtag_tap_t *tap, u16 *ir_in, u16 ir_out, int dr_len, int rti);\r
  74 int mcu_write_ir_u32(jtag_tap_t *tap, u32 *ir_in, u32 ir_out, int ir_len, int rti);\r
  75 int mcu_write_dr_u32(jtag_tap_t *tap, u32 *ir_in, u32 ir_out, int dr_len, int rti);\r
  76 int mcu_execute_queue(void);\r
  77 \r
  78 target_type_t avr_target =\r
  79 {\r
  80         .name = "avr",\r
  81 \r
  82         .poll = avr_poll,\r
  83         .arch_state = avr_arch_state,\r
  84 \r
  85         .target_request_data = NULL,\r
  86 \r
  87         .halt = avr_halt,\r
  88         .resume = avr_resume,\r
  89         .step = avr_step,\r
  90 \r
  91         .assert_reset = avr_assert_reset,\r
  92         .deassert_reset = avr_deassert_reset,\r
  93         .soft_reset_halt = avr_soft_reset_halt,\r
  94 /*\r
  95         .get_gdb_reg_list = avr_get_gdb_reg_list,\r
  96 \r
  97         .read_memory = avr_read_memory,\r
  98         .write_memory = avr_write_memory,\r
  99         .bulk_write_memory = avr_bulk_write_memory,\r
 100         .checksum_memory = avr_checksum_memory,\r
 101         .blank_check_memory = avr_blank_check_memory,\r
 102 \r
 103         .run_algorithm = avr_run_algorithm,\r
 104 \r
 105         .add_breakpoint = avr_add_breakpoint,\r
 106         .remove_breakpoint = avr_remove_breakpoint,\r
 107         .add_watchpoint = avr_add_watchpoint,\r
 108         .remove_watchpoint = avr_remove_watchpoint,\r
 109 */\r
 110         .register_commands = avr_register_commands,\r
 111         .target_create = avr_target_create,\r
 112         .init_target = avr_init_target,\r
 113         .quit = avr_quit,\r
 114 /*\r
 115         .virt2phys = avr_virt2phys,\r
 116         .mmu = avr_mmu\r
 117 */\r
 118 };\r
 119 \r
 120 int avr_register_commands(struct command_context_s *cmd_ctx)\r
 121 {\r
 122         LOG_DEBUG(__FUNCTION__);\r
 123         return ERROR_OK;\r
 124 }\r
 125 \r
 126 int avr_target_create(struct target_s *target, Jim_Interp *interp)\r
 127 {\r
 128         avr_common_t *avr = calloc(1, sizeof(avr_common_t));\r
 129         \r
 130         avr->jtag_info.tap = target->tap;\r
 131         target->arch_info = avr;\r
 132         \r
 133         return ERROR_OK;\r
 134 }\r
 135 \r
 136 int avr_init_target(struct command_context_s *cmd_ctx, struct target_s *target)\r
 137 {\r
 138         LOG_DEBUG(__FUNCTION__);\r
 139         return ERROR_OK;\r
 140 }\r
 141 \r
 142 int avr_quit(void)\r
 143 {\r
 144         LOG_DEBUG(__FUNCTION__);\r
 145         return ERROR_OK;\r
 146 }\r
 147 \r
 148 int avr_arch_state(struct target_s *target)\r
 149 {\r
 150         LOG_DEBUG(__FUNCTION__);\r
 151         return ERROR_OK;\r
 152 }\r
 153 \r
 154 int avr_poll(target_t *target)\r
 155 {\r
 156         if ((target->state == TARGET_RUNNING) || (target->state == TARGET_DEBUG_RUNNING))\r
 157         {\r
 158                 target->state = TARGET_HALTED;\r
 159         }\r
 160         \r
 161         LOG_DEBUG(__FUNCTION__);\r
 162         return ERROR_OK;\r
 163 }\r
 164 \r
 165 int avr_halt(target_t *target)\r
 166 {\r
 167         LOG_DEBUG(__FUNCTION__);\r
 168         return ERROR_OK;\r
 169 }\r
 170 \r
 171 int avr_resume(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution)\r
 172 {\r
 173         LOG_DEBUG(__FUNCTION__);\r
 174         return ERROR_OK;\r
 175 }\r
 176 \r
 177 int avr_step(struct target_s *target, int current, u32 address, int handle_breakpoints)\r
 178 {\r
 179         LOG_DEBUG(__FUNCTION__);\r
 180         return ERROR_OK;\r
 181 }\r
 182 \r
 183 int avr_assert_reset(target_t *target)\r
 184 {\r
 185         target->state = TARGET_RESET;\r
 186         \r
 187         LOG_DEBUG(__FUNCTION__);\r
 188         return ERROR_OK;\r
 189 }\r
 190 \r
 191 int avr_deassert_reset(target_t *target)\r
 192 {\r
 193         target->state = TARGET_RUNNING;\r
 194         \r
 195         LOG_DEBUG(__FUNCTION__);\r
 196         return ERROR_OK;\r
 197 }\r
 198 \r
 199 int avr_soft_reset_halt(struct target_s *target)\r
 200 {\r
 201         LOG_DEBUG(__FUNCTION__);\r
 202         return ERROR_OK;\r
 203 }\r
 204 \r
 205 int avr_jtag_senddat(jtag_tap_t *tap, u32* dr_in, u32 dr_out, int len)\r
 206 {\r
 207         return mcu_write_dr_u32(tap, dr_in, dr_out, len, 1);\r
 208 }\r
 209 \r
 210 int avr_jtag_sendinstr(jtag_tap_t *tap, u8 *ir_in, u8 ir_out)\r
 211 {\r
 212         return mcu_write_ir_u8(tap, ir_in, ir_out, AVR_JTAG_INS_LEN, 1);\r
 213 }\r
 214 \r
 215 /* IR and DR functions */\r
 216 int mcu_write_ir(jtag_tap_t *tap, u8 *ir_in, u8 *ir_out, int ir_len, int rti)\r
 217 {\r
 218         if (NULL == tap)\r
 219         {\r
 220                 LOG_ERROR("invalid tap");\r
 221                 return ERROR_FAIL;\r
 222         }\r
 223         if (ir_len != tap->ir_length)\r
 224         {\r
 225                 LOG_ERROR("invalid ir_len");\r
 226                 return ERROR_FAIL;\r
 227         }\r
 228         \r
 229         {\r
 230                 scan_field_t field[1];\r
 231                 \r
 232                 field[0].tap = tap;\r
 233                 field[0].num_bits = tap->ir_length;\r
 234                 field[0].out_value = ir_out;\r
 235                 field[0].out_mask = NULL;\r
 236                 field[0].in_value = ir_in;\r
 237                 field[0].in_check_value = NULL;\r
 238                 field[0].in_check_mask = NULL;\r
 239                 field[0].in_handler = NULL;\r
 240                 field[0].in_handler_priv = NULL;\r
 241                 jtag_add_plain_ir_scan(sizeof(field) / sizeof(field[0]), field, TAP_IDLE);\r
 242         }\r
 243         \r
 244         return ERROR_OK;\r
 245 }\r
 246 \r
 247 int mcu_write_dr(jtag_tap_t *tap, u8 *dr_in, u8 *dr_out, int dr_len, int rti)\r
 248 {\r
 249         if (NULL == tap)\r
 250         {\r
 251                 LOG_ERROR("invalid tap");\r
 252                 return ERROR_FAIL;\r
 253         }\r
 254         \r
 255         {\r
 256                 scan_field_t field[1];\r
 257                 \r
 258                 field[0].tap = tap;\r
 259                 field[0].num_bits = dr_len;\r
 260                 field[0].out_value = dr_out;\r
 261                 field[0].out_mask = NULL;\r
 262                 field[0].in_value = dr_in;\r
 263                 field[0].in_check_value = NULL;\r
 264                 field[0].in_check_mask = NULL;\r
 265                 field[0].in_handler = NULL;\r
 266                 field[0].in_handler_priv = NULL;\r
 267                 jtag_add_plain_dr_scan(sizeof(field) / sizeof(field[0]), field, TAP_IDLE);\r
 268         }\r
 269         \r
 270         return ERROR_OK;\r
 271 }\r
 272 \r
 273 int mcu_write_ir_u8(jtag_tap_t *tap, u8 *ir_in, u8 ir_out, int ir_len, int rti)\r
 274 {\r
 275         if (ir_len > 8)\r
 276         {\r
 277                 LOG_ERROR("ir_len overflow, maxium is 8");\r
 278                 return ERROR_FAIL;\r
 279         }\r
 280         \r
 281         mcu_write_ir(tap, ir_in, &ir_out, ir_len, rti);\r
 282         \r
 283         return ERROR_OK;\r
 284 }\r
 285 \r
 286 int mcu_write_dr_u8(jtag_tap_t *tap, u8 *dr_in, u8 dr_out, int dr_len, int rti)\r
 287 {\r
 288         if (dr_len > 8)\r
 289         {\r
 290                 LOG_ERROR("dr_len overflow, maxium is 8");\r
 291                 return ERROR_FAIL;\r
 292         }\r
 293         \r
 294         mcu_write_dr(tap, dr_in, &dr_out, dr_len, rti);\r
 295         \r
 296         return ERROR_OK;\r
 297 }\r
 298 \r
 299 int mcu_write_ir_u16(jtag_tap_t *tap, u16 *ir_in, u16 ir_out, int ir_len, int rti)\r
 300 {\r
 301         if (ir_len > 16)\r
 302         {\r
 303                 LOG_ERROR("ir_len overflow, maxium is 16");\r
 304                 return ERROR_FAIL;\r
 305         }\r
 306         \r
 307         mcu_write_ir(tap, (u8*)ir_in, (u8*)&ir_out, ir_len, rti);\r
 308         \r
 309         return ERROR_OK;\r
 310 }\r
 311 \r
 312 int mcu_write_dr_u16(jtag_tap_t *tap, u16 *dr_in, u16 dr_out, int dr_len, int rti)\r
 313 {\r
 314         if (dr_len > 16)\r
 315         {\r
 316                 LOG_ERROR("dr_len overflow, maxium is 16");\r
 317                 return ERROR_FAIL;\r
 318         }\r
 319         \r
 320         mcu_write_dr(tap, (u8*)dr_in, (u8*)&dr_out, dr_len, rti);\r
 321         \r
 322         return ERROR_OK;\r
 323 }\r
 324 \r
 325 int mcu_write_ir_u32(jtag_tap_t *tap, u32 *ir_in, u32 ir_out, int ir_len, int rti)\r
 326 {\r
 327         if (ir_len > 32)\r
 328         {\r
 329                 LOG_ERROR("ir_len overflow, maxium is 32");\r
 330                 return ERROR_FAIL;\r
 331         }\r
 332         \r
 333         mcu_write_ir(tap, (u8*)ir_in, (u8*)&ir_out, ir_len, rti);\r
 334         \r
 335         return ERROR_OK;\r
 336 }\r
 337 \r
 338 int mcu_write_dr_u32(jtag_tap_t *tap, u32 *dr_in, u32 dr_out, int dr_len, int rti)\r
 339 {\r
 340         if (dr_len > 32)\r
 341         {\r
 342                 LOG_ERROR("dr_len overflow, maxium is 32");\r
 343                 return ERROR_FAIL;\r
 344         }\r
 345         \r
 346         mcu_write_dr(tap, (u8*)dr_in, (u8*)&dr_out, dr_len, rti);\r
 347         \r
 348         return ERROR_OK;\r
 349 }\r
 350 \r
 351 int mcu_execute_queue(void)\r
 352 {\r
 353         return jtag_execute_queue();\r
 354 }\r