git.gag.com Git - fw/openocd/blob - src/target/arm11.c

   1 /***************************************************************************\r
   2  *   Copyright (C) 2008 digenius technology GmbH.                          *\r
   3  *                                                                         *\r
   4  *   This program is free software; you can redistribute it and/or modify  *\r
   5  *   it under the terms of the GNU General Public License as published by  *\r
   6  *   the Free Software Foundation; either version 2 of the License, or     *\r
   7  *   (at your option) any later version.                                   *\r
   8  *                                                                         *\r
   9  *   This program is distributed in the hope that it will be useful,       *\r
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *\r
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *\r
  12  *   GNU General Public License for more details.                          *\r
  13  *                                                                         *\r
  14  *   You should have received a copy of the GNU General Public License     *\r
  15  *   along with this program; if not, write to the                         *\r
  16  *   Free Software Foundation, Inc.,                                       *\r
  17  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *\r
  18  ***************************************************************************/\r
  19 \r
  20 #ifdef HAVE_CONFIG_H\r
  21 #include "config.h"\r
  22 #endif\r
  23 \r
  24 #include "arm11.h"\r
  25 #include "jtag.h"\r
  26 #include "log.h"\r
  27 \r
  28 #include <stdlib.h>\r
  29 #include <string.h>\r
  30 \r
  31 #if 0\r
  32 #define _DEBUG_INSTRUCTION_EXECUTION_\r
  33 #endif\r
  34 \r
  35 \r
  36 #if 0\r
  37 #define FNC_INFO    DEBUG("-")\r
  38 #else\r
  39 #define FNC_INFO\r
  40 #endif\r
  41 \r
  42 #if 1\r
  43 #define FNC_INFO_NOTIMPLEMENTED    do { DEBUG("NOT IMPLEMENTED"); /*exit(-1);*/ } while (0)\r
  44 #else\r
  45 #define FNC_INFO_NOTIMPLEMENTED\r
  46 #endif\r
  47 \r
  48 static void arm11_on_enter_debug_state(arm11_common_t * arm11);\r
  49 \r
  50 \r
  51 #define ARM11_HANDLER(x)        \\r
  52     .x                          = arm11_##x\r
  53 \r
  54 target_type_t arm11_target =\r
  55 {\r
  56     .name                       = "arm11",\r
  57 \r
  58     ARM11_HANDLER(poll),\r
  59     ARM11_HANDLER(arch_state),\r
  60 \r
  61     ARM11_HANDLER(target_request_data),\r
  62 \r
  63     ARM11_HANDLER(halt),\r
  64     ARM11_HANDLER(resume),\r
  65     ARM11_HANDLER(step),\r
  66 \r
  67     ARM11_HANDLER(assert_reset),\r
  68     ARM11_HANDLER(deassert_reset),\r
  69     ARM11_HANDLER(soft_reset_halt),\r
  70     ARM11_HANDLER(prepare_reset_halt),\r
  71         \r
  72     ARM11_HANDLER(get_gdb_reg_list),\r
  73         \r
  74     ARM11_HANDLER(read_memory),\r
  75     ARM11_HANDLER(write_memory),\r
  76         \r
  77     ARM11_HANDLER(bulk_write_memory),\r
  78         \r
  79     ARM11_HANDLER(checksum_memory),\r
  80 \r
  81     ARM11_HANDLER(add_breakpoint),\r
  82     ARM11_HANDLER(remove_breakpoint),\r
  83     ARM11_HANDLER(add_watchpoint),\r
  84     ARM11_HANDLER(remove_watchpoint),\r
  85 \r
  86     ARM11_HANDLER(run_algorithm),\r
  87         \r
  88     ARM11_HANDLER(register_commands),\r
  89     ARM11_HANDLER(target_command),\r
  90     ARM11_HANDLER(init_target),\r
  91     ARM11_HANDLER(quit),\r
  92 };\r
  93 \r
  94 int arm11_regs_arch_type = -1;\r
  95 \r
  96 \r
  97 enum arm11_regtype\r
  98 {\r
  99     ARM11_REGISTER_CORE,\r
 100     ARM11_REGISTER_CPSR,\r
 101 \r
 102     ARM11_REGISTER_FX,\r
 103     ARM11_REGISTER_FPS,\r
 104 \r
 105     ARM11_REGISTER_FIQ,\r
 106     ARM11_REGISTER_SVC,\r
 107     ARM11_REGISTER_ABT,\r
 108     ARM11_REGISTER_IRQ,\r
 109     ARM11_REGISTER_UND,\r
 110     ARM11_REGISTER_MON,\r
 111 \r
 112     ARM11_REGISTER_SPSR_FIQ,\r
 113     ARM11_REGISTER_SPSR_SVC,\r
 114     ARM11_REGISTER_SPSR_ABT,\r
 115     ARM11_REGISTER_SPSR_IRQ,\r
 116     ARM11_REGISTER_SPSR_UND,\r
 117     ARM11_REGISTER_SPSR_MON,\r
 118 \r
 119     /* debug regs */\r
 120     ARM11_REGISTER_DSCR,\r
 121     ARM11_REGISTER_WDTR,\r
 122     ARM11_REGISTER_RDTR,\r
 123 };\r
 124 \r
 125 \r
 126 typedef struct arm11_reg_defs_s\r
 127 {\r
 128     char *                      name;\r
 129     u32                         num;\r
 130     int                         gdb_num;\r
 131     enum arm11_regtype          type;\r
 132 } arm11_reg_defs_t;\r
 133 \r
 134 /* update arm11_regcache_ids when changing this */\r
 135 static const arm11_reg_defs_t arm11_reg_defs[] =\r
 136 {\r
 137     {"r0",      0,      0,      ARM11_REGISTER_CORE},\r
 138     {"r1",      1,      1,      ARM11_REGISTER_CORE},\r
 139     {"r2",      2,      2,      ARM11_REGISTER_CORE},\r
 140     {"r3",      3,      3,      ARM11_REGISTER_CORE},\r
 141     {"r4",      4,      4,      ARM11_REGISTER_CORE},\r
 142     {"r5",      5,      5,      ARM11_REGISTER_CORE},\r
 143     {"r6",      6,      6,      ARM11_REGISTER_CORE},\r
 144     {"r7",      7,      7,      ARM11_REGISTER_CORE},\r
 145     {"r8",      8,      8,      ARM11_REGISTER_CORE},\r
 146     {"r9",      9,      9,      ARM11_REGISTER_CORE},\r
 147     {"r10",     10,     10,     ARM11_REGISTER_CORE},\r
 148     {"r11",     11,     11,     ARM11_REGISTER_CORE},\r
 149     {"r12",     12,     12,     ARM11_REGISTER_CORE},\r
 150     {"sp",      13,     13,     ARM11_REGISTER_CORE},\r
 151     {"lr",      14,     14,     ARM11_REGISTER_CORE},\r
 152     {"pc",      15,     15,     ARM11_REGISTER_CORE},\r
 153 \r
 154 #if ARM11_REGCACHE_FREGS\r
 155     {"f0",      0,      16,     ARM11_REGISTER_FX},\r
 156     {"f1",      1,      17,     ARM11_REGISTER_FX},\r
 157     {"f2",      2,      18,     ARM11_REGISTER_FX},\r
 158     {"f3",      3,      19,     ARM11_REGISTER_FX},\r
 159     {"f4",      4,      20,     ARM11_REGISTER_FX},\r
 160     {"f5",      5,      21,     ARM11_REGISTER_FX},\r
 161     {"f6",      6,      22,     ARM11_REGISTER_FX},\r
 162     {"f7",      7,      23,     ARM11_REGISTER_FX},\r
 163     {"fps",     0,      24,     ARM11_REGISTER_FPS},\r
 164 #endif\r
 165 \r
 166     {"cpsr",    0,      25,     ARM11_REGISTER_CPSR},\r
 167 \r
 168 #if ARM11_REGCACHE_MODEREGS\r
 169     {"r8_fiq",  8,      -1,     ARM11_REGISTER_FIQ},\r
 170     {"r9_fiq",  9,      -1,     ARM11_REGISTER_FIQ},\r
 171     {"r10_fiq", 10,     -1,     ARM11_REGISTER_FIQ},\r
 172     {"r11_fiq", 11,     -1,     ARM11_REGISTER_FIQ},\r
 173     {"r12_fiq", 12,     -1,     ARM11_REGISTER_FIQ},\r
 174     {"r13_fiq", 13,     -1,     ARM11_REGISTER_FIQ},\r
 175     {"r14_fiq", 14,     -1,     ARM11_REGISTER_FIQ},\r
 176     {"spsr_fiq", 0,     -1,     ARM11_REGISTER_SPSR_FIQ},\r
 177 \r
 178     {"r13_svc", 13,     -1,     ARM11_REGISTER_SVC},\r
 179     {"r14_svc", 14,     -1,     ARM11_REGISTER_SVC},\r
 180     {"spsr_svc", 0,     -1,     ARM11_REGISTER_SPSR_SVC},\r
 181 \r
 182     {"r13_abt", 13,     -1,     ARM11_REGISTER_ABT},\r
 183     {"r14_abt", 14,     -1,     ARM11_REGISTER_ABT},\r
 184     {"spsr_abt", 0,     -1,     ARM11_REGISTER_SPSR_ABT},\r
 185 \r
 186     {"r13_irq", 13,     -1,     ARM11_REGISTER_IRQ},\r
 187     {"r14_irq", 14,     -1,     ARM11_REGISTER_IRQ},\r
 188     {"spsr_irq", 0,     -1,     ARM11_REGISTER_SPSR_IRQ},\r
 189 \r
 190     {"r13_und", 13,     -1,     ARM11_REGISTER_UND},\r
 191     {"r14_und", 14,     -1,     ARM11_REGISTER_UND},\r
 192     {"spsr_und", 0,     -1,     ARM11_REGISTER_SPSR_UND},\r
 193 \r
 194     /* ARM1176 only */\r
 195     {"r13_mon", 13,     -1,     ARM11_REGISTER_MON},\r
 196     {"r14_mon", 14,     -1,     ARM11_REGISTER_MON},\r
 197     {"spsr_mon", 0,     -1,     ARM11_REGISTER_SPSR_MON},\r
 198 #endif\r
 199 \r
 200     /* Debug Registers */\r
 201     {"dscr",    0,      -1,     ARM11_REGISTER_DSCR},\r
 202     {"wdtr",    0,      -1,     ARM11_REGISTER_WDTR},\r
 203     {"rdtr",    0,      -1,     ARM11_REGISTER_RDTR},\r
 204 };\r
 205 \r
 206 enum arm11_regcache_ids\r
 207 {\r
 208     ARM11_RC_R0,\r
 209     ARM11_RC_RX                 = ARM11_RC_R0,\r
 210 \r
 211     ARM11_RC_R1,\r
 212     ARM11_RC_R2,\r
 213     ARM11_RC_R3,\r
 214     ARM11_RC_R4,\r
 215     ARM11_RC_R5,\r
 216     ARM11_RC_R6,\r
 217     ARM11_RC_R7,\r
 218     ARM11_RC_R8,\r
 219     ARM11_RC_R9,\r
 220     ARM11_RC_R10,\r
 221     ARM11_RC_R11,\r
 222     ARM11_RC_R12,\r
 223     ARM11_RC_R13,\r
 224     ARM11_RC_SP                 = ARM11_RC_R13,\r
 225     ARM11_RC_R14,\r
 226     ARM11_RC_LR                 = ARM11_RC_R14,\r
 227     ARM11_RC_R15,\r
 228     ARM11_RC_PC                 = ARM11_RC_R15,\r
 229 \r
 230 #if ARM11_REGCACHE_FREGS\r
 231     ARM11_RC_F0,\r
 232     ARM11_RC_FX                 = ARM11_RC_F0,\r
 233     ARM11_RC_F1,\r
 234     ARM11_RC_F2,\r
 235     ARM11_RC_F3,\r
 236     ARM11_RC_F4,\r
 237     ARM11_RC_F5,\r
 238     ARM11_RC_F6,\r
 239     ARM11_RC_F7,\r
 240     ARM11_RC_FPS,\r
 241 #endif\r
 242 \r
 243     ARM11_RC_CPSR,\r
 244 \r
 245 #if ARM11_REGCACHE_MODEREGS\r
 246     ARM11_RC_R8_FIQ,\r
 247     ARM11_RC_R9_FIQ,\r
 248     ARM11_RC_R10_FIQ,\r
 249     ARM11_RC_R11_FIQ,\r
 250     ARM11_RC_R12_FIQ,\r
 251     ARM11_RC_R13_FIQ,\r
 252     ARM11_RC_R14_FIQ,\r
 253     ARM11_RC_SPSR_FIQ,\r
 254 \r
 255     ARM11_RC_R13_SVC,\r
 256     ARM11_RC_R14_SVC,\r
 257     ARM11_RC_SPSR_SVC,\r
 258 \r
 259     ARM11_RC_R13_ABT,\r
 260     ARM11_RC_R14_ABT,\r
 261     ARM11_RC_SPSR_ABT,\r
 262 \r
 263     ARM11_RC_R13_IRQ,\r
 264     ARM11_RC_R14_IRQ,\r
 265     ARM11_RC_SPSR_IRQ,\r
 266 \r
 267     ARM11_RC_R13_UND,\r
 268     ARM11_RC_R14_UND,\r
 269     ARM11_RC_SPSR_UND,\r
 270 \r
 271     ARM11_RC_R13_MON,\r
 272     ARM11_RC_R14_MON,\r
 273     ARM11_RC_SPSR_MON,\r
 274 #endif\r
 275 \r
 276     ARM11_RC_DSCR,\r
 277     ARM11_RC_WDTR,\r
 278     ARM11_RC_RDTR,\r
 279 \r
 280 \r
 281     ARM11_RC_MAX,\r
 282 };\r
 283 \r
 284 #define ARM11_GDB_REGISTER_COUNT        26\r
 285 \r
 286 u8 arm11_gdb_dummy_fp_value[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};\r
 287 \r
 288 reg_t arm11_gdb_dummy_fp_reg =\r
 289 {\r
 290     "GDB dummy floating-point register", arm11_gdb_dummy_fp_value, 0, 1, 96, NULL, 0, NULL, 0\r
 291 };\r
 292 \r
 293 u8 arm11_gdb_dummy_fps_value[] = {0, 0, 0, 0};\r
 294 \r
 295 reg_t arm11_gdb_dummy_fps_reg =\r
 296 {\r
 297     "GDB dummy floating-point status register", arm11_gdb_dummy_fps_value, 0, 1, 32, NULL, 0, NULL, 0\r
 298 };\r
 299 \r
 300 \r
 301 \r
 302 /** Check and if necessary take control of the system\r
 303  *\r
 304  * \param arm11         Target state variable.\r
 305  * \param dscr          If the current DSCR content is\r
 306  *                      available a pointer to a word holding the\r
 307  *                      DSCR can be passed. Otherwise use NULL.\r
 308  */\r
 309 void arm11_check_init(arm11_common_t * arm11, u32 * dscr)\r
 310 {\r
 311     FNC_INFO;\r
 312 \r
 313     u32                 dscr_local_tmp_copy;\r
 314 \r
 315     if (!dscr)\r
 316     {\r
 317         dscr = &dscr_local_tmp_copy;\r
 318         *dscr = arm11_read_DSCR(arm11);\r
 319     }\r
 320 \r
 321     if (!(*dscr & ARM11_DSCR_MODE_SELECT))\r
 322     {\r
 323         DEBUG("Bringing target into debug mode");\r
 324 \r
 325         *dscr |= ARM11_DSCR_MODE_SELECT;                /* Halt debug-mode */\r
 326         arm11_write_DSCR(arm11, *dscr);\r
 327 \r
 328         /* add further reset initialization here */\r
 329 \r
 330         if (*dscr & ARM11_DSCR_CORE_HALTED)\r
 331         {\r
 332             arm11->target->state        = TARGET_HALTED;\r
 333             arm11->target->debug_reason = arm11_get_DSCR_debug_reason(*dscr);\r
 334         }\r
 335         else\r
 336         {\r
 337             arm11->target->state        = TARGET_RUNNING;\r
 338             arm11->target->debug_reason = DBG_REASON_NOTHALTED;\r
 339         }\r
 340 \r
 341         arm11_sc7_clear_bw(arm11);\r
 342     }\r
 343 }\r
 344 \r
 345 \r
 346 \r
 347 #define R(x) \\r
 348     (arm11->reg_values[ARM11_RC_##x])\r
 349 \r
 350 /** Save processor state.\r
 351   *\r
 352   * This is called when the HALT instruction has succeeded\r
 353   * or on other occasions that stop the processor.\r
 354   *\r
 355   */\r
 356 static void arm11_on_enter_debug_state(arm11_common_t * arm11)\r
 357 {\r
 358     FNC_INFO;\r
 359 \r
 360     {size_t i;\r
 361     for(i = 0; i < asizeof(arm11->reg_values); i++)\r
 362     {\r
 363         arm11->reg_list[i].valid        = 1;\r
 364         arm11->reg_list[i].dirty        = 0;\r
 365     }}\r
 366 \r
 367     /* Save DSCR */\r
 368 \r
 369     R(DSCR) = arm11_read_DSCR(arm11);\r
 370 \r
 371     /* Save wDTR */\r
 372 \r
 373     if (R(DSCR) & ARM11_DSCR_WDTR_FULL)\r
 374     {\r
 375         arm11_add_debug_SCAN_N(arm11, 0x05, -1);\r
 376 \r
 377         arm11_add_IR(arm11, ARM11_INTEST, -1);\r
 378 \r
 379         scan_field_t    chain5_fields[3];\r
 380 \r
 381         arm11_setup_field(arm11, 32, NULL, &R(WDTR),    chain5_fields + 0);\r
 382         arm11_setup_field(arm11,  1, NULL, NULL,        chain5_fields + 1);\r
 383         arm11_setup_field(arm11,  1, NULL, NULL,        chain5_fields + 2);\r
 384 \r
 385         jtag_add_dr_scan_vc(asizeof(chain5_fields), chain5_fields, TAP_PD);\r
 386     }\r
 387     else\r
 388     {\r
 389         arm11->reg_list[ARM11_RC_WDTR].valid    = 0;\r
 390     }\r
 391 \r
 392 \r
 393     /* DSCR: set ARM11_DSCR_EXECUTE_ARM_INSTRUCTION_ENABLE */\r
 394     /* ARM1176 spec says this is needed only for wDTR/rDTR's "ITR mode", but not to issue ITRs\r
 395        ARM1136 seems to require this to issue ITR's as well */\r
 396 \r
 397     u32 new_dscr = R(DSCR) | ARM11_DSCR_EXECUTE_ARM_INSTRUCTION_ENABLE;\r
 398 \r
 399     /* this executes JTAG queue: */ \r
 400 \r
 401     arm11_write_DSCR(arm11, new_dscr);\r
 402 \r
 403 //    jtag_execute_queue();\r
 404 \r
 405 \r
 406 \r
 407 //    DEBUG("SAVE DSCR %08x", R(DSCR));\r
 408 \r
 409 //    if (R(DSCR) & ARM11_DSCR_WDTR_FULL)\r
 410 //      DEBUG("SAVE wDTR %08x", R(WDTR));\r
 411 \r
 412 \r
 413     /* From the spec:\r
 414         Before executing any instruction in debug state you have to drain the write buffer.\r
 415         This ensures that no imprecise Data Aborts can return at a later point:*/\r
 416 \r
 417     /** \todo TODO: Test drain write buffer. */\r
 418 \r
 419 #if 0\r
 420     while (1)\r
 421     {\r
 422         /* MRC p14,0,R0,c5,c10,0 */\r
 423 //      arm11_run_instr_no_data1(arm11, /*0xee150e1a*/0xe320f000);\r
 424 \r
 425         /* mcr     15, 0, r0, cr7, cr10, {4} */\r
 426         arm11_run_instr_no_data1(arm11, 0xee070f9a);\r
 427                 \r
 428         u32 dscr = arm11_read_DSCR(arm11);\r
 429 \r
 430         DEBUG("DRAIN, DSCR %08x", dscr);\r
 431 \r
 432         if (dscr & ARM11_DSCR_STICKY_IMPRECISE_DATA_ABORT)\r
 433         {\r
 434             arm11_run_instr_no_data1(arm11, 0xe320f000);\r
 435 \r
 436             dscr = arm11_read_DSCR(arm11);\r
 437 \r
 438             DEBUG("DRAIN, DSCR %08x (DONE)", dscr);\r
 439 \r
 440             break;\r
 441         }\r
 442     }\r
 443 #endif\r
 444 \r
 445 \r
 446     arm11_run_instr_data_prepare(arm11);\r
 447 \r
 448     /* save r0 - r14 */\r
 449 \r
 450 \r
 451     /** \todo TODO: handle other mode registers */\r
 452 \r
 453     {size_t i;\r
 454     for (i = 0; i < 15; i++)\r
 455     {\r
 456         /* MCR p14,0,R?,c0,c5,0 */\r
 457         arm11_run_instr_data_from_core(arm11, 0xEE000E15 | (i << 12), &R(RX + i), 1);\r
 458     }}\r
 459 \r
 460 \r
 461     /* save rDTR */\r
 462 \r
 463     /* check rDTRfull in DSCR */\r
 464 \r
 465     if (R(DSCR) & ARM11_DSCR_RDTR_FULL)\r
 466     {\r
 467         /* MRC p14,0,R0,c0,c5,0 (move rDTR -> r0 (-> wDTR -> local var)) */\r
 468         arm11_run_instr_data_from_core_via_r0(arm11, 0xEE100E15, &R(RDTR));\r
 469     }\r
 470     else\r
 471     {\r
 472         arm11->reg_list[ARM11_RC_RDTR].valid    = 0;\r
 473     }\r
 474 \r
 475     /* save CPSR */\r
 476 \r
 477     /* MRS r0,CPSR (move CPSR -> r0 (-> wDTR -> local var)) */\r
 478     arm11_run_instr_data_from_core_via_r0(arm11, 0xE10F0000, &R(CPSR));\r
 479 \r
 480     /* save PC */\r
 481 \r
 482     /* MOV R0,PC (move PC -> r0 (-> wDTR -> local var)) */\r
 483     arm11_run_instr_data_from_core_via_r0(arm11, 0xE1A0000F, &R(PC));\r
 484 \r
 485     /* adjust PC depending on ARM state */\r
 486 \r
 487     if (R(CPSR) & ARM11_CPSR_J) /* Java state */\r
 488     {\r
 489         arm11->reg_values[ARM11_RC_PC] -= 0;\r
 490     }\r
 491     else if (R(CPSR) & ARM11_CPSR_T)    /* Thumb state */\r
 492     {\r
 493         arm11->reg_values[ARM11_RC_PC] -= 4;\r
 494     }\r
 495     else                                        /* ARM state */\r
 496     {\r
 497         arm11->reg_values[ARM11_RC_PC] -= 8;\r
 498     }\r
 499 \r
 500 //    DEBUG("SAVE PC   %08x", R(PC));\r
 501 \r
 502     arm11_run_instr_data_finish(arm11);\r
 503 \r
 504 \r
 505     {size_t i;\r
 506     for(i = 0; i < ARM11_REGCACHE_COUNT; i++)\r
 507     {\r
 508         if (!arm11->reg_list[i].valid)\r
 509         {\r
 510             if (arm11->reg_history[i].valid)\r
 511                 INFO("%8s INVALID    (%08x)", arm11_reg_defs[i].name, arm11->reg_history[i].value);\r
 512         }\r
 513         else\r
 514         {\r
 515             if (arm11->reg_history[i].valid)\r
 516             {\r
 517                 if (arm11->reg_history[i].value != arm11->reg_values[i])\r
 518                     INFO("%8s %08x (%08x)", arm11_reg_defs[i].name, arm11->reg_values[i], arm11->reg_history[i].value);\r
 519             }\r
 520             else\r
 521             {\r
 522                 INFO("%8s %08x (INVALID)", arm11_reg_defs[i].name, arm11->reg_values[i]);\r
 523             }\r
 524         }\r
 525     }}\r
 526 }\r
 527 \r
 528 \r
 529 /** Restore processor state\r
 530   *\r
 531   * This is called in preparation for the RESTART function.\r
 532   *\r
 533   */\r
 534 void arm11_leave_debug_state(arm11_common_t * arm11)\r
 535 {\r
 536     FNC_INFO;\r
 537 \r
 538     arm11_run_instr_data_prepare(arm11);\r
 539 \r
 540     /** \todo TODO: handle other mode registers */\r
 541 \r
 542     /* restore R1 - R14 */\r
 543     {size_t i;\r
 544     for (i = 1; i < 15; i++)\r
 545     {\r
 546         if (!arm11->reg_list[ARM11_RC_RX + i].dirty)\r
 547             continue;\r
 548 \r
 549         /* MRC p14,0,r?,c0,c5,0 */\r
 550         arm11_run_instr_data_to_core1(arm11, 0xee100e15 | (i << 12), R(RX + i));\r
 551 \r
 552 //      DEBUG("RESTORE R%d %08x", i, R(RX + i));\r
 553     }}\r
 554 \r
 555     arm11_run_instr_data_finish(arm11);\r
 556 \r
 557 \r
 558     /* spec says clear wDTR and rDTR; we assume they are clear as\r
 559        otherwide out programming would be sloppy */\r
 560 \r
 561     {\r
 562         u32 DSCR = arm11_read_DSCR(arm11);\r
 563 \r
 564         if (DSCR & (ARM11_DSCR_RDTR_FULL | ARM11_DSCR_WDTR_FULL))\r
 565         {\r
 566             ERROR("wDTR/rDTR inconsistent (DSCR %08x)", DSCR);\r
 567         }\r
 568     }\r
 569 \r
 570     arm11_run_instr_data_prepare(arm11);\r
 571 \r
 572     /* restore original wDTR */\r
 573 \r
 574     if ((R(DSCR) & ARM11_DSCR_WDTR_FULL) || arm11->reg_list[ARM11_RC_WDTR].dirty)\r
 575     {\r
 576         /* MCR p14,0,R0,c0,c5,0 */\r
 577         arm11_run_instr_data_to_core_via_r0(arm11, 0xee000e15, R(WDTR));\r
 578     }\r
 579 \r
 580     /* restore CPSR */\r
 581 \r
 582     /* MSR CPSR,R0*/\r
 583     arm11_run_instr_data_to_core_via_r0(arm11, 0xe129f000, R(CPSR));\r
 584 \r
 585 \r
 586     /* restore PC */\r
 587 \r
 588     /* MOV PC,R0 */\r
 589     arm11_run_instr_data_to_core_via_r0(arm11, 0xe1a0f000, R(PC));\r
 590 \r
 591 \r
 592     /* restore R0 */\r
 593 \r
 594     /* MRC p14,0,r0,c0,c5,0 */\r
 595     arm11_run_instr_data_to_core1(arm11, 0xee100e15, R(R0));\r
 596 \r
 597     arm11_run_instr_data_finish(arm11);\r
 598 \r
 599 \r
 600     /* restore DSCR */\r
 601 \r
 602     arm11_write_DSCR(arm11, R(DSCR));\r
 603 \r
 604 \r
 605     /* restore rDTR */\r
 606     \r
 607     if (R(DSCR) & ARM11_DSCR_RDTR_FULL || arm11->reg_list[ARM11_RC_RDTR].dirty)\r
 608     {\r
 609         arm11_add_debug_SCAN_N(arm11, 0x05, -1);\r
 610 \r
 611         arm11_add_IR(arm11, ARM11_EXTEST, -1);\r
 612 \r
 613         scan_field_t    chain5_fields[3];\r
 614 \r
 615         u8                      Ready       = 0;        /* ignored */\r
 616         u8                      Valid       = 0;        /* ignored */\r
 617 \r
 618         arm11_setup_field(arm11, 32, &R(RDTR),  NULL, chain5_fields + 0);\r
 619         arm11_setup_field(arm11,  1, &Ready,    NULL, chain5_fields + 1);\r
 620         arm11_setup_field(arm11,  1, &Valid,    NULL, chain5_fields + 2);\r
 621 \r
 622         jtag_add_dr_scan_vc(asizeof(chain5_fields), chain5_fields, TAP_PD);\r
 623     }\r
 624 \r
 625 \r
 626     {size_t i;\r
 627     for(i = 0; i < ARM11_REGCACHE_COUNT; i++)\r
 628     {\r
 629         arm11->reg_history[i].value     = arm11->reg_values[i];\r
 630         arm11->reg_history[i].valid     = arm11->reg_list[i].valid;\r
 631 \r
 632         arm11->reg_list[i].valid        = 0;\r
 633         arm11->reg_list[i].dirty        = 0;\r
 634     }}\r
 635 }\r
 636 \r
 637 \r
 638 /* poll current target status */\r
 639 int arm11_poll(struct target_s *target)\r
 640 {\r
 641     FNC_INFO;\r
 642 \r
 643     arm11_common_t * arm11 = target->arch_info;\r
 644 \r
 645     if (arm11->trst_active)\r
 646         return ERROR_OK;\r
 647 \r
 648     u32 dscr = arm11_read_DSCR(arm11);\r
 649 \r
 650     DEBUG("DSCR %08x", dscr);\r
 651 \r
 652     arm11_check_init(arm11, &dscr);\r
 653 \r
 654     if (dscr & ARM11_DSCR_CORE_HALTED)\r
 655     {\r
 656 //      DEBUG("CH %d", target->state);\r
 657 \r
 658         if (target->state != TARGET_HALTED)\r
 659         {\r
 660             DEBUG("enter TARGET_HALTED");\r
 661             target->state               = TARGET_HALTED;\r
 662             target->debug_reason        = arm11_get_DSCR_debug_reason(dscr);\r
 663             arm11_on_enter_debug_state(arm11);\r
 664         }\r
 665     }\r
 666     else\r
 667     {\r
 668 //      DEBUG("CR %d", target->state);\r
 669 \r
 670         if (target->state != TARGET_RUNNING)\r
 671         {\r
 672             DEBUG("enter TARGET_RUNNING");\r
 673             target->state               = TARGET_RUNNING;\r
 674             target->debug_reason        = DBG_REASON_NOTHALTED;\r
 675         }\r
 676     }\r
 677 \r
 678     return ERROR_OK;\r
 679 }\r
 680 /* architecture specific status reply */\r
 681 int arm11_arch_state(struct target_s *target)\r
 682 {\r
 683     FNC_INFO_NOTIMPLEMENTED;\r
 684 \r
 685     return ERROR_OK;\r
 686 }\r
 687 \r
 688 \r
 689 /* target request support */\r
 690 int arm11_target_request_data(struct target_s *target, u32 size, u8 *buffer)\r
 691 {\r
 692     FNC_INFO_NOTIMPLEMENTED;\r
 693 \r
 694     return ERROR_OK;\r
 695 }\r
 696 \r
 697 \r
 698 \r
 699 /* target execution control */\r
 700 int arm11_halt(struct target_s *target)\r
 701 {\r
 702     FNC_INFO;\r
 703 \r
 704     arm11_common_t * arm11 = target->arch_info;\r
 705 \r
 706     DEBUG("target->state: %s", target_state_strings[target->state]);\r
 707 \r
 708     if (target->state == TARGET_HALTED)\r
 709     {\r
 710         WARNING("target was already halted");\r
 711         return ERROR_TARGET_ALREADY_HALTED;\r
 712     }\r
 713 \r
 714     if (arm11->trst_active)\r
 715     {\r
 716         arm11->halt_requested = true;\r
 717         return ERROR_OK;\r
 718     }\r
 719 \r
 720     arm11_add_IR(arm11, ARM11_HALT, TAP_RTI);\r
 721 \r
 722     jtag_execute_queue();\r
 723 \r
 724     u32 dscr;\r
 725 \r
 726     while (1)\r
 727     {\r
 728         dscr = arm11_read_DSCR(arm11);\r
 729 \r
 730         if (dscr & ARM11_DSCR_CORE_HALTED)\r
 731             break;\r
 732     }\r
 733 \r
 734     arm11_on_enter_debug_state(arm11);\r
 735 \r
 736     target->state               = TARGET_HALTED;\r
 737     target->debug_reason        = arm11_get_DSCR_debug_reason(dscr);\r
 738     \r
 739     return ERROR_OK;\r
 740 }\r
 741 \r
 742 \r
 743 int arm11_resume(struct target_s *target, int current, u32 address, int handle_breakpoints, int debug_execution)\r
 744 {\r
 745     FNC_INFO;\r
 746 \r
 747     arm11_common_t * arm11 = target->arch_info;\r
 748 \r
 749     DEBUG("target->state: %s", target_state_strings[target->state]);\r
 750 \r
 751     if (target->state != TARGET_HALTED)\r
 752     {\r
 753         WARNING("target was not halted");\r
 754         return ERROR_TARGET_NOT_HALTED;\r
 755     }\r
 756 \r
 757     if (!current)\r
 758         R(PC) = address;\r
 759 \r
 760     target->state               = TARGET_RUNNING;\r
 761     target->debug_reason        = DBG_REASON_NOTHALTED;\r
 762 \r
 763     arm11_leave_debug_state(arm11);\r
 764 \r
 765     arm11_add_IR(arm11, ARM11_RESTART, TAP_RTI);\r
 766 \r
 767     jtag_execute_queue();\r
 768 \r
 769     while (1)\r
 770     {\r
 771         u32 dscr = arm11_read_DSCR(arm11);\r
 772 \r
 773         DEBUG("DSCR %08x", dscr);\r
 774 \r
 775         if (dscr & ARM11_DSCR_CORE_RESTARTED)\r
 776             break;\r
 777     }\r
 778 \r
 779     DEBUG("RES %d", target->state);\r
 780 \r
 781     return ERROR_OK;\r
 782 }\r
 783 \r
 784 int arm11_step(struct target_s *target, int current, u32 address, int handle_breakpoints)\r
 785 {\r
 786     FNC_INFO;\r
 787 \r
 788     DEBUG("target->state: %s", target_state_strings[target->state]);\r
 789 \r
 790     if (target->state != TARGET_HALTED)\r
 791     {\r
 792         WARNING("target was not halted");\r
 793         return ERROR_TARGET_NOT_HALTED;\r
 794     }\r
 795 \r
 796     arm11_common_t * arm11 = target->arch_info;\r
 797 \r
 798     /** \todo TODO: check if break-/watchpoints make any sense at all in combination\r
 799       * with this. */\r
 800 \r
 801     /** \todo TODO: check if disabling IRQs might be a good idea here. Alternatively\r
 802         the VCR might be something worth looking into. */\r
 803 \r
 804     /* Set up breakpoint for stepping */\r
 805 \r
 806     arm11_sc7_action_t  brp[2];\r
 807 \r
 808     brp[0].write        = 1;\r
 809     brp[0].address      = ARM11_SC7_BVR0;\r
 810     brp[0].value        = R(PC);\r
 811     brp[1].write        = 1;\r
 812     brp[1].address      = ARM11_SC7_BCR0;\r
 813     brp[1].value        = 0x1 | (3 << 1) | (0x0F << 5) | (0 << 14) | (0 << 16) | (0 << 20) | (2 << 21);\r
 814 \r
 815     arm11_sc7_run(arm11, brp, asizeof(brp));\r
 816 \r
 817     /* resume */\r
 818 \r
 819     arm11_leave_debug_state(arm11);\r
 820 \r
 821     arm11_add_IR(arm11, ARM11_RESTART, TAP_RTI);\r
 822 \r
 823     jtag_execute_queue();\r
 824 \r
 825     /** \todo TODO: add a timeout */\r
 826 \r
 827     /* wait for halt */\r
 828 \r
 829     while (1)\r
 830     {\r
 831         u32 dscr = arm11_read_DSCR(arm11);\r
 832 \r
 833         DEBUG("DSCR %08x", dscr);\r
 834 \r
 835         if ((dscr & (ARM11_DSCR_CORE_RESTARTED | ARM11_DSCR_CORE_HALTED)) ==\r
 836             (ARM11_DSCR_CORE_RESTARTED | ARM11_DSCR_CORE_HALTED))\r
 837             break;\r
 838     }\r
 839 \r
 840 \r
 841     /* clear breakpoint */\r
 842 \r
 843     arm11_sc7_clear_bw(arm11);\r
 844 \r
 845 \r
 846     /* save state */\r
 847 \r
 848     arm11_on_enter_debug_state(arm11);\r
 849 \r
 850 //    target->state             = TARGET_HALTED;\r
 851     target->debug_reason        = DBG_REASON_SINGLESTEP;\r
 852 \r
 853     return ERROR_OK;\r
 854 }\r
 855 \r
 856 \r
 857 /* target reset control */\r
 858 int arm11_assert_reset(struct target_s *target)\r
 859 {\r
 860     FNC_INFO;\r
 861 \r
 862 #if 0\r
 863     /* assert reset lines */\r
 864     /* resets only the DBGTAP, not the ARM */\r
 865 \r
 866     jtag_add_reset(1, 0);\r
 867     jtag_add_sleep(5000);\r
 868 \r
 869     arm11_common_t * arm11 = target->arch_info;\r
 870     arm11->trst_active = true;\r
 871 #endif\r
 872 \r
 873     return ERROR_OK;\r
 874 }\r
 875 \r
 876 int arm11_deassert_reset(struct target_s *target)\r
 877 {\r
 878     FNC_INFO;\r
 879 \r
 880 #if 0\r
 881     DEBUG("target->state: %s", target_state_strings[target->state]);\r
 882 \r
 883     /* deassert reset lines */\r
 884     jtag_add_reset(0, 0);\r
 885 \r
 886     arm11_common_t * arm11 = target->arch_info;\r
 887     arm11->trst_active = false;\r
 888 \r
 889     if (arm11->halt_requested)\r
 890         return arm11_halt(target);\r
 891 #endif\r
 892 \r
 893     return ERROR_OK;\r
 894 }\r
 895 \r
 896 int arm11_soft_reset_halt(struct target_s *target)\r
 897 {\r
 898     FNC_INFO_NOTIMPLEMENTED;\r
 899 \r
 900     return ERROR_OK;\r
 901 }\r
 902 \r
 903 int arm11_prepare_reset_halt(struct target_s *target)\r
 904 {\r
 905     FNC_INFO_NOTIMPLEMENTED;\r
 906 \r
 907     return ERROR_OK;\r
 908 }\r
 909 \r
 910 \r
 911 /* target register access for gdb */\r
 912 int arm11_get_gdb_reg_list(struct target_s *target, struct reg_s **reg_list[], int *reg_list_size)\r
 913 {\r
 914     FNC_INFO;\r
 915 \r
 916     arm11_common_t * arm11 = target->arch_info;\r
 917 \r
 918     if (target->state != TARGET_HALTED)\r
 919     {\r
 920         return ERROR_TARGET_NOT_HALTED;\r
 921     }\r
 922         \r
 923     *reg_list_size  = ARM11_GDB_REGISTER_COUNT;\r
 924     *reg_list       = malloc(sizeof(reg_t*) * ARM11_GDB_REGISTER_COUNT);\r
 925 \r
 926     {size_t i;\r
 927     for (i = 16; i < 24; i++)\r
 928     {\r
 929         (*reg_list)[i] = &arm11_gdb_dummy_fp_reg;\r
 930     }}\r
 931 \r
 932     (*reg_list)[24] = &arm11_gdb_dummy_fps_reg;\r
 933 \r
 934 \r
 935     {size_t i;\r
 936     for (i = 0; i < ARM11_REGCACHE_COUNT; i++)\r
 937     {\r
 938         if (arm11_reg_defs[i].gdb_num == -1)\r
 939             continue;\r
 940 \r
 941         (*reg_list)[arm11_reg_defs[i].gdb_num] = arm11->reg_list + i;\r
 942     }}\r
 943 \r
 944     return ERROR_OK;\r
 945 }\r
 946 \r
 947 \r
 948 /* target memory access \r
 949 * size: 1 = byte (8bit), 2 = half-word (16bit), 4 = word (32bit)\r
 950 * count: number of items of <size>\r
 951 */\r
 952 int arm11_read_memory(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer)\r
 953 {\r
 954     /** \todo TODO: check if buffer cast to u32* and u16* might cause alignment problems */\r
 955 \r
 956     FNC_INFO;\r
 957 \r
 958     DEBUG("ADDR %08x  SIZE %08x  COUNT %08x", address, size, count);\r
 959 \r
 960     arm11_common_t * arm11 = target->arch_info;\r
 961 \r
 962     arm11_run_instr_data_prepare(arm11);\r
 963 \r
 964     /* MRC p14,0,r0,c0,c5,0 */\r
 965     arm11_run_instr_data_to_core1(arm11, 0xee100e15, address);\r
 966 \r
 967     switch (size)\r
 968     {\r
 969     case 1:\r
 970         /** \todo TODO: check if dirty is the right choice to force a rewrite on arm11_resume() */\r
 971         arm11->reg_list[ARM11_RC_R1].dirty = 1;\r
 972 \r
 973         while (count--)\r
 974         {\r
 975             /* ldrb    r1, [r0], #1 */\r
 976             arm11_run_instr_no_data1(arm11, 0xe4d01001);\r
 977 \r
 978             u32 res;\r
 979             /* MCR p14,0,R1,c0,c5,0 */\r
 980             arm11_run_instr_data_from_core(arm11, 0xEE001E15, &res, 1);\r
 981 \r
 982             *buffer++ = res;\r
 983         }\r
 984         break;\r
 985 \r
 986     case 2:\r
 987     {\r
 988         arm11->reg_list[ARM11_RC_R1].dirty = 1;\r
 989 \r
 990         u16 * buf16 = (u16*)buffer;\r
 991 \r
 992         while (count--)\r
 993         {\r
 994             /* ldrh    r1, [r0], #2 */\r
 995             arm11_run_instr_no_data1(arm11, 0xe0d010b2);\r
 996 \r
 997             u32 res;\r
 998 \r
 999             /* MCR p14,0,R1,c0,c5,0 */\r
1000             arm11_run_instr_data_from_core(arm11, 0xEE001E15, &res, 1);\r
1001 \r
1002             *buf16++ = res;\r
1003         }\r
1004         break;\r
1005     }\r
1006 \r
1007     case 4:\r
1008 \r
1009         /* LDC p14,c5,[R0],#4 */\r
1010         arm11_run_instr_data_from_core(arm11, 0xecb05e01, (u32 *)buffer, count);\r
1011         break;\r
1012     }\r
1013 \r
1014     arm11_run_instr_data_finish(arm11);\r
1015 \r
1016     return ERROR_OK;\r
1017 }\r
1018 \r
1019 int arm11_write_memory(struct target_s *target, u32 address, u32 size, u32 count, u8 *buffer)\r
1020 {\r
1021     FNC_INFO;\r
1022 \r
1023     DEBUG("ADDR %08x  SIZE %08x  COUNT %08x", address, size, count);\r
1024 \r
1025     arm11_common_t * arm11 = target->arch_info;\r
1026 \r
1027     arm11_run_instr_data_prepare(arm11);\r
1028 \r
1029     /* MRC p14,0,r0,c0,c5,0 */\r
1030     arm11_run_instr_data_to_core1(arm11, 0xee100e15, address);\r
1031 \r
1032     switch (size)\r
1033     {\r
1034     case 1:\r
1035         arm11->reg_list[ARM11_RC_R1].dirty = 1;\r
1036 \r
1037         while (count--)\r
1038         {\r
1039             /* MRC p14,0,r1,c0,c5,0 */\r
1040             arm11_run_instr_data_to_core1(arm11, 0xee101e15, *buffer++);\r
1041 \r
1042             /* strb    r1, [r0], #1 */\r
1043             arm11_run_instr_no_data1(arm11, 0xe4c01001);\r
1044         }\r
1045         break;\r
1046 \r
1047     case 2:\r
1048     {\r
1049         arm11->reg_list[ARM11_RC_R1].dirty = 1;\r
1050 \r
1051         u16 * buf16 = (u16*)buffer;\r
1052 \r
1053         while (count--)\r
1054         {\r
1055             /* MRC p14,0,r1,c0,c5,0 */\r
1056             arm11_run_instr_data_to_core1(arm11, 0xee101e15, *buf16++);\r
1057 \r
1058             /* strh    r1, [r0], #2 */\r
1059             arm11_run_instr_no_data1(arm11, 0xe0c010b2);\r
1060         }\r
1061         break;\r
1062     }\r
1063 \r
1064     case 4:\r
1065         /** \todo TODO: check if buffer cast to u32* might cause alignment problems */\r
1066 \r
1067         /* STC p14,c5,[R0],#4 */\r
1068         arm11_run_instr_data_to_core(arm11, 0xeca05e01, (u32 *)buffer, count);\r
1069         break;\r
1070     }\r
1071 \r
1072     arm11_run_instr_data_finish(arm11);\r
1073 \r
1074     return ERROR_OK;\r
1075 }\r
1076 \r
1077 \r
1078 /* write target memory in multiples of 4 byte, optimized for writing large quantities of data */\r
1079 int arm11_bulk_write_memory(struct target_s *target, u32 address, u32 count, u8 *buffer)\r
1080 {\r
1081     FNC_INFO;\r
1082 \r
1083     return arm11_write_memory(target, address, 4, count, buffer);\r
1084 }\r
1085 \r
1086 \r
1087 int arm11_checksum_memory(struct target_s *target, u32 address, u32 count, u32* checksum)\r
1088 {\r
1089     FNC_INFO_NOTIMPLEMENTED;\r
1090 \r
1091     return ERROR_OK;\r
1092 }\r
1093 \r
1094 \r
1095 /* target break-/watchpoint control \r
1096 * rw: 0 = write, 1 = read, 2 = access\r
1097 */\r
1098 int arm11_add_breakpoint(struct target_s *target, breakpoint_t *breakpoint)\r
1099 {\r
1100     FNC_INFO_NOTIMPLEMENTED;\r
1101 \r
1102     return ERROR_OK;\r
1103 }\r
1104 \r
1105 int arm11_remove_breakpoint(struct target_s *target, breakpoint_t *breakpoint)\r
1106 {\r
1107     FNC_INFO_NOTIMPLEMENTED;\r
1108 \r
1109     return ERROR_OK;\r
1110 }\r
1111 \r
1112 int arm11_add_watchpoint(struct target_s *target, watchpoint_t *watchpoint)\r
1113 {\r
1114     FNC_INFO_NOTIMPLEMENTED;\r
1115 \r
1116     return ERROR_OK;\r
1117 }\r
1118 \r
1119 int arm11_remove_watchpoint(struct target_s *target, watchpoint_t *watchpoint)\r
1120 {\r
1121     FNC_INFO_NOTIMPLEMENTED;\r
1122 \r
1123     return ERROR_OK;\r
1124 }\r
1125 \r
1126 \r
1127 /* target algorithm support */\r
1128 int arm11_run_algorithm(struct target_s *target, int num_mem_params, mem_param_t *mem_params, int num_reg_params, reg_param_t *reg_param, u32 entry_point, u32 exit_point, int timeout_ms, void *arch_info)\r
1129 {\r
1130     FNC_INFO_NOTIMPLEMENTED;\r
1131 \r
1132     return ERROR_OK;\r
1133 }\r
1134 \r
1135 \r
1136 int arm11_register_commands(struct command_context_s *cmd_ctx)\r
1137 {\r
1138     FNC_INFO;\r
1139 \r
1140     return ERROR_OK;\r
1141 }\r
1142 \r
1143 int arm11_target_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc, struct target_s *target)\r
1144 {\r
1145     FNC_INFO;\r
1146 \r
1147     if (argc < 4)\r
1148     {\r
1149         ERROR("'target arm11' 4th argument <jtag chain pos>");\r
1150         exit(-1);\r
1151     }\r
1152 \r
1153     int chain_pos = strtoul(args[3], NULL, 0);\r
1154 \r
1155     NEW(arm11_common_t, arm11, 1);\r
1156 \r
1157     arm11->target = target;\r
1158 \r
1159     /* prepare JTAG information for the new target */\r
1160     arm11->jtag_info.chain_pos  = chain_pos;\r
1161     arm11->jtag_info.scann_size = 5;\r
1162 \r
1163     arm_jtag_setup_connection(&arm11->jtag_info);\r
1164 \r
1165     jtag_device_t *device = jtag_get_device(chain_pos);\r
1166 \r
1167     if (device->ir_length != 5)\r
1168     {\r
1169         ERROR("'target arm11' expects 'jtag_device 5 0x01 0x1F 0x1E'");\r
1170         exit(-1);\r
1171     }\r
1172 \r
1173     target->arch_info = arm11;\r
1174 \r
1175     return ERROR_OK;\r
1176 }\r
1177 \r
1178 int arm11_init_target(struct command_context_s *cmd_ctx, struct target_s *target)\r
1179 {\r
1180     FNC_INFO;\r
1181 \r
1182     arm11_common_t * arm11 = target->arch_info;\r
1183 \r
1184     /* check IDCODE */\r
1185 \r
1186     arm11_add_IR(arm11, ARM11_IDCODE, -1);\r
1187 \r
1188     scan_field_t                idcode_field;\r
1189 \r
1190     arm11_setup_field(arm11, 32, NULL, &arm11->device_id, &idcode_field);\r
1191 \r
1192     jtag_add_dr_scan_vc(1, &idcode_field, TAP_PD);\r
1193 \r
1194     /* check DIDR */\r
1195 \r
1196     arm11_add_debug_SCAN_N(arm11, 0x00, -1);\r
1197 \r
1198     arm11_add_IR(arm11, ARM11_INTEST, -1);\r
1199 \r
1200     scan_field_t                chain0_fields[2];\r
1201 \r
1202     arm11_setup_field(arm11, 32, NULL,  &arm11->didr,           chain0_fields + 0);\r
1203     arm11_setup_field(arm11,  8, NULL,  &arm11->implementor,    chain0_fields + 1);\r
1204 \r
1205     jtag_add_dr_scan_vc(asizeof(chain0_fields), chain0_fields, TAP_RTI);\r
1206 \r
1207     jtag_execute_queue();\r
1208 \r
1209 \r
1210     switch (arm11->device_id & 0x0FFFF000)\r
1211     {\r
1212     case 0x07B36000:    INFO("found ARM1136"); break;\r
1213     case 0x07B56000:    INFO("found ARM1156"); break;\r
1214     case 0x07B76000:    INFO("found ARM1176"); break;\r
1215     default:\r
1216     {\r
1217         ERROR("'target arm11' expects IDCODE 0x*7B*7****");\r
1218         exit(-1);\r
1219     }\r
1220     }\r
1221 \r
1222     arm11->brp  = ((arm11->didr >> 24) & 0x0F) + 1;\r
1223     arm11->wrp  = ((arm11->didr >> 28) & 0x0F) + 1;\r
1224 \r
1225 \r
1226     DEBUG("IDCODE %08x IMPLEMENTOR %02x DIDR %08x",\r
1227         arm11->device_id,\r
1228         arm11->implementor,\r
1229         arm11->didr);\r
1230 \r
1231     arm11_build_reg_cache(target);\r
1232 \r
1233 \r
1234     /* as a side-effect this reads DSCR and thus\r
1235      * clears the ARM11_DSCR_STICKY_PRECISE_DATA_ABORT / Sticky Precise Data Abort Flag\r
1236      * as suggested by the spec.\r
1237      */\r
1238 \r
1239     arm11_check_init(arm11, NULL);\r
1240 \r
1241     return ERROR_OK;\r
1242 }\r
1243 \r
1244 int arm11_quit(void)\r
1245 {\r
1246     FNC_INFO_NOTIMPLEMENTED;\r
1247 \r
1248     return ERROR_OK;\r
1249 }\r
1250 \r
1251 /** Load a register that is marked !valid in the register cache */\r
1252 int arm11_get_reg(reg_t *reg)\r
1253 {\r
1254     FNC_INFO;\r
1255 \r
1256     target_t * target = ((arm11_reg_state_t *)reg->arch_info)->target;\r
1257 \r
1258     if (target->state != TARGET_HALTED)\r
1259     {\r
1260         return ERROR_TARGET_NOT_HALTED;\r
1261     }\r
1262 \r
1263     /** \todo TODO: Check this. We assume that all registers are fetched debug entry. */\r
1264 \r
1265 #if 0\r
1266     arm11_common_t *arm11 = target->arch_info;\r
1267     const arm11_reg_defs_t * arm11_reg_info = arm11_reg_defs + ((arm11_reg_state_t *)reg->arch_info)->def_index;\r
1268 #endif\r
1269 \r
1270     return ERROR_OK;\r
1271 }\r
1272 \r
1273 /** Change a value in the register cache */\r
1274 int arm11_set_reg(reg_t *reg, u8 *buf)\r
1275 {\r
1276     FNC_INFO;\r
1277 \r
1278     target_t * target = ((arm11_reg_state_t *)reg->arch_info)->target;\r
1279     arm11_common_t *arm11 = target->arch_info;\r
1280 //    const arm11_reg_defs_t * arm11_reg_info = arm11_reg_defs + ((arm11_reg_state_t *)reg->arch_info)->def_index;\r
1281 \r
1282     arm11->reg_values[((arm11_reg_state_t *)reg->arch_info)->def_index] = buf_get_u32(buf, 0, 32);\r
1283     reg->valid  = 1;\r
1284     reg->dirty  = 1;\r
1285 \r
1286     return ERROR_OK;\r
1287 }\r
1288 \r
1289 \r
1290 void arm11_build_reg_cache(target_t *target)\r
1291 {\r
1292     arm11_common_t *arm11 = target->arch_info;\r
1293 \r
1294     NEW(reg_cache_t,            cache,                  1);\r
1295     NEW(reg_t,                  reg_list,               ARM11_REGCACHE_COUNT);\r
1296     NEW(arm11_reg_state_t,      arm11_reg_states,       ARM11_REGCACHE_COUNT);\r
1297 \r
1298     if (arm11_regs_arch_type == -1)\r
1299         arm11_regs_arch_type = register_reg_arch_type(arm11_get_reg, arm11_set_reg);\r
1300 \r
1301     arm11->reg_list     = reg_list;\r
1302 \r
1303     /* Build the process context cache */ \r
1304     cache->name         = "arm11 registers";\r
1305     cache->next         = NULL;\r
1306     cache->reg_list     = reg_list;\r
1307     cache->num_regs     = ARM11_REGCACHE_COUNT;\r
1308 \r
1309     reg_cache_t **cache_p = register_get_last_cache_p(&target->reg_cache);\r
1310     (*cache_p) = cache;\r
1311 \r
1312 //    armv7m->core_cache = cache;\r
1313 //    armv7m->process_context = cache;\r
1314 \r
1315     size_t i;\r
1316 \r
1317     /* Not very elegant assertion */\r
1318     if (ARM11_REGCACHE_COUNT != asizeof(arm11->reg_values) ||\r
1319         ARM11_REGCACHE_COUNT != asizeof(arm11_reg_defs) ||\r
1320         ARM11_REGCACHE_COUNT != ARM11_RC_MAX)\r
1321     {\r
1322         ERROR("arm11->reg_values inconsistent (%d %d %d %d)", ARM11_REGCACHE_COUNT, asizeof(arm11->reg_values), asizeof(arm11_reg_defs), ARM11_RC_MAX);\r
1323         exit(-1);\r
1324     }\r
1325 \r
1326     for (i = 0; i < ARM11_REGCACHE_COUNT; i++)\r
1327     {\r
1328         reg_t *                         r       = reg_list              + i;\r
1329         const arm11_reg_defs_t *        rd      = arm11_reg_defs        + i;\r
1330         arm11_reg_state_t *             rs      = arm11_reg_states      + i;\r
1331 \r
1332         r->name                 = rd->name;\r
1333         r->size                 = 32;\r
1334         r->value                = (u8 *)(arm11->reg_values + i);\r
1335         r->dirty                = 0;\r
1336         r->valid                = 0;\r
1337         r->bitfield_desc        = NULL;\r
1338         r->num_bitfields        = 0;\r
1339         r->arch_type            = arm11_regs_arch_type;\r
1340         r->arch_info            = rs;\r
1341 \r
1342         rs->def_index           = i;\r
1343         rs->target              = target;\r
1344     }\r
1345 }\r
1346 \r
1347 #if 0\r
1348     arm11_run_instr_data_prepare(arm11);\r
1349 \r
1350     /* MRC p14,0,r0,c0,c5,0 */\r
1351     arm11_run_instr_data_to_core(arm11, 0xee100e15, 0xCA00003C);\r
1352     /* MRC p14,0,r1,c0,c5,0 */\r
1353     arm11_run_instr_data_to_core(arm11, 0xee101e15, 0xFFFFFFFF);\r
1354 \r
1355     arm11_run_instr_data_finish(arm11);\r
1356 #endif\r
1357 \r
1358 \r