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

   1 /***************************************************************************
   2  *   Copyright (C) 2008 digenius technology GmbH.                          *
   3  *                                                                         *
   4  *   Copyright (C) 2008 Oyvind Harboe oyvind.harboe@zylin.com              *
   5  *                                                                         *
   6  *   This program is free software; you can redistribute it and/or modify  *
   7  *   it under the terms of the GNU General Public License as published by  *
   8  *   the Free Software Foundation; either version 2 of the License, or     *
   9  *   (at your option) any later version.                                   *
  10  *                                                                         *
  11  *   This program is distributed in the hope that it will be useful,       *
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  14  *   GNU General Public License for more details.                          *
  15  *                                                                         *
  16  *   You should have received a copy of the GNU General Public License     *
  17  *   along with this program; if not, write to the                         *
  18  *   Free Software Foundation, Inc.,                                       *
  19  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  20  ***************************************************************************/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include "arm11.h"
  27 #include "jtag.h"
  28 #include "log.h"
  29
  30 #include <stdlib.h>
  31 #include <string.h>
  32
  33 #if 0
  34 #define JTAG_DEBUG(expr ...)    DEBUG(expr)
  35 #else
  36 #define JTAG_DEBUG(expr ...)    do {} while(0)
  37 #endif
  38
  39 /*
  40 This pathmove goes from Pause-IR to Shift-IR while avoiding RTI. The
  41 behavior of the FTDI driver IIRC was to go via RTI.
  42
  43 Conversely there may be other places in this code where the ARM11 code relies
  44 on the driver to hit through RTI when coming from Update-?R.
  45 */
  46 tap_state_t arm11_move_pi_to_si_via_ci[] =
  47 {
  48     TAP_IREXIT2, TAP_IRUPDATE, TAP_DRSELECT, TAP_IRSELECT, TAP_IRCAPTURE, TAP_IRSHIFT
  49 };
  50
  51
  52 int arm11_add_ir_scan_vc(int num_fields, scan_field_t *fields, tap_state_t state)
  53 {
  54         if (cmd_queue_cur_state == TAP_IRPAUSE)
  55                 jtag_add_pathmove(asizeof(arm11_move_pi_to_si_via_ci), arm11_move_pi_to_si_via_ci);
  56
  57         jtag_add_ir_scan(num_fields, fields, state);
  58         return ERROR_OK;
  59 }
  60
  61 tap_state_t arm11_move_pd_to_sd_via_cd[] =
  62 {
  63         TAP_DREXIT2, TAP_DRUPDATE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DRSHIFT
  64 };
  65
  66 int arm11_add_dr_scan_vc(int num_fields, scan_field_t *fields, tap_state_t state)
  67 {
  68         if (cmd_queue_cur_state == TAP_DRPAUSE)
  69                 jtag_add_pathmove(asizeof(arm11_move_pd_to_sd_via_cd), arm11_move_pd_to_sd_via_cd);
  70
  71         jtag_add_dr_scan(num_fields, fields, state);
  72         return ERROR_OK;
  73 }
  74
  75
  76 /** Code de-clutter: Construct scan_field_t to write out a value
  77  *
  78  * \param arm11                 Target state variable.
  79  * \param num_bits              Length of the data field
  80  * \param out_data              pointer to the data that will be sent out
  81  *                                              <em>(data is read when it is added to the JTAG queue)</em>
  82  * \param in_data               pointer to the memory that will receive data that was clocked in
  83  *                                              <em>(data is written when the JTAG queue is executed)</em>
  84  * \param field                 target data structure that will be initialized
  85  */
  86 void arm11_setup_field(arm11_common_t * arm11, int num_bits, void * out_data, void * in_data, scan_field_t * field)
  87 {
  88         field->tap                      = arm11->jtag_info.tap;
  89         field->num_bits                 = num_bits;
  90         field->in_check_mask    = NULL;
  91         field->in_check_value   = NULL;
  92         field->in_handler               = NULL;
  93         field->in_handler_priv  = NULL;
  94
  95         field->out_value                = out_data;
  96         field->in_value                 = in_data;
  97 }
  98
  99
 100 /** Write JTAG instruction register
 101  *
 102  * \param arm11         Target state variable.
 103  * \param instr         An ARM11 DBGTAP instruction. Use enum #arm11_instructions.
 104  * \param state         Pass the final TAP state or ARM11_TAP_DEFAULT for the default value (Pause-IR).
 105  *
 106  * \remarks                     This adds to the JTAG command queue but does \em not execute it.
 107  */
 108 void arm11_add_IR(arm11_common_t * arm11, u8 instr, tap_state_t state)
 109 {
 110         jtag_tap_t *tap;
 111         tap = arm11->jtag_info.tap;
 112
 113         if (buf_get_u32(tap->cur_instr, 0, 5) == instr)
 114         {
 115                 JTAG_DEBUG("IR <= 0x%02x SKIPPED", instr);
 116                 return;
 117         }
 118
 119         JTAG_DEBUG("IR <= 0x%02x", instr);
 120
 121         scan_field_t field;
 122
 123         arm11_setup_field(arm11, 5, &instr, NULL, &field);
 124
 125         arm11_add_ir_scan_vc(1, &field, state == ARM11_TAP_DEFAULT ? TAP_IRPAUSE : state);
 126 }
 127
 128 /** Verify shifted out data from Scan Chain Register (SCREG)
 129  *  Used as parameter to scan_field_t::in_handler in
 130  *  arm11_add_debug_SCAN_N().
 131  *
 132  */
 133 static int arm11_in_handler_SCAN_N(u8 *in_value, void *priv, struct scan_field_s *field)
 134 {
 135         /** \todo TODO: clarify why this isnt properly masked in jtag.c jtag_read_buffer() */
 136         u8 v = *in_value & 0x1F;
 137
 138         if (v != 0x10)
 139         {
 140                 LOG_ERROR("'arm11 target' JTAG communication error SCREG SCAN OUT 0x%02x (expected 0x10)", v);
 141                 return ERROR_FAIL;
 142         }
 143
 144         JTAG_DEBUG("SCREG SCAN OUT 0x%02x", v);
 145         return ERROR_OK;
 146 }
 147
 148 /** Select and write to Scan Chain Register (SCREG)
 149  *
 150  * This function sets the instruction register to SCAN_N and writes
 151  * the data register with the selected chain number.
 152  *
 153  * http://infocenter.arm.com/help/topic/com.arm.doc.ddi0301f/Cacbjhfg.html
 154  *
 155  * \param arm11     Target state variable.
 156  * \param chain     Scan chain that will be selected.
 157  * \param state     Pass the final TAP state or ARM11_TAP_DEFAULT for the default
 158  *                                      value (Pause-DR).
 159  *
 160  * The chain takes effect when Update-DR is passed (usually when subsequently
 161  * the INTEXT/EXTEST instructions are written).
 162  *
 163  * \warning                     (Obsolete) Using this twice in a row will \em fail. The first
 164  *                                      call will end in Pause-DR. The second call, due to the IR
 165  *                                      caching, will not go through Capture-DR when shifting in the
 166  *                                      new scan chain number. As a result the verification in
 167  *                                      arm11_in_handler_SCAN_N() must fail.
 168  *
 169  * \remarks                     This adds to the JTAG command queue but does \em not execute it.
 170  */
 171
 172 void arm11_add_debug_SCAN_N(arm11_common_t * arm11, u8 chain, tap_state_t state)
 173 {
 174         JTAG_DEBUG("SCREG <= 0x%02x", chain);
 175
 176         arm11_add_IR(arm11, ARM11_SCAN_N, ARM11_TAP_DEFAULT);
 177
 178         scan_field_t            field;
 179
 180         arm11_setup_field(arm11, 5, &chain, NULL, &field);
 181
 182         field.in_handler = arm11_in_handler_SCAN_N; /* deprecated! invoke this from user code! */
 183
 184         arm11_add_dr_scan_vc(1, &field, state == ARM11_TAP_DEFAULT ? TAP_DRPAUSE : state);
 185 }
 186
 187 /** Write an instruction into the ITR register
 188  *
 189  * \param arm11         Target state variable.
 190  * \param inst          An ARM11 processor instruction/opcode.
 191  * \param flag          Optional parameter to retrieve the InstCompl flag
 192  *                                      (this will be written when the JTAG chain is executed).
 193  * \param state         Pass the final TAP state or ARM11_TAP_DEFAULT for the default
 194  *                                      value (Run-Test/Idle).
 195  *
 196  * \remarks                     By default this ends with Run-Test/Idle state
 197  *                                      and causes the instruction to be executed. If
 198  *                                      a subsequent write to DTR is needed before
 199  *                                      executing the instruction then TAP_DRPAUSE should be
 200  *                                      passed to \p state.
 201  *
 202  * \remarks                     This adds to the JTAG command queue but does \em not execute it.
 203  */
 204 void arm11_add_debug_INST(arm11_common_t * arm11, u32 inst, u8 * flag, tap_state_t state)
 205 {
 206         JTAG_DEBUG("INST <= 0x%08x", inst);
 207
 208         scan_field_t            itr[2];
 209
 210         arm11_setup_field(arm11, 32,    &inst,  NULL, itr + 0);
 211         arm11_setup_field(arm11, 1,         NULL,       flag, itr + 1);
 212
 213         arm11_add_dr_scan_vc(asizeof(itr), itr, state == ARM11_TAP_DEFAULT ? TAP_IDLE : state);
 214 }
 215
 216 /** Read the Debug Status and Control Register (DSCR)
 217  *
 218  * same as CP14 c1
 219  *
 220  * \param arm11         Target state variable.
 221  * \return                      DSCR content
 222  *
 223  * \remarks                     This is a stand-alone function that executes the JTAG command queue.
 224  */
 225 int arm11_read_DSCR(arm11_common_t * arm11, u32 *value)
 226 {
 227         arm11_add_debug_SCAN_N(arm11, 0x01, ARM11_TAP_DEFAULT);
 228
 229         arm11_add_IR(arm11, ARM11_INTEST, ARM11_TAP_DEFAULT);
 230
 231         u32                             dscr;
 232         scan_field_t    chain1_field;
 233
 234         arm11_setup_field(arm11, 32, NULL, &dscr, &chain1_field);
 235
 236         arm11_add_dr_scan_vc(1, &chain1_field, TAP_DRPAUSE);
 237
 238         CHECK_RETVAL(jtag_execute_queue());
 239
 240         if (arm11->last_dscr != dscr)
 241                 JTAG_DEBUG("DSCR  = %08x (OLD %08x)", dscr, arm11->last_dscr);
 242
 243         arm11->last_dscr = dscr;
 244
 245         *value=dscr;
 246
 247         return ERROR_OK;
 248 }
 249
 250 /** Write the Debug Status and Control Register (DSCR)
 251  *
 252  * same as CP14 c1
 253  *
 254  * \param arm11         Target state variable.
 255  * \param dscr          DSCR content
 256  *
 257  * \remarks                     This is a stand-alone function that executes the JTAG command queue.
 258  */
 259 int arm11_write_DSCR(arm11_common_t * arm11, u32 dscr)
 260 {
 261         arm11_add_debug_SCAN_N(arm11, 0x01, ARM11_TAP_DEFAULT);
 262
 263         arm11_add_IR(arm11, ARM11_EXTEST, ARM11_TAP_DEFAULT);
 264
 265         scan_field_t                chain1_field;
 266
 267         arm11_setup_field(arm11, 32, &dscr, NULL, &chain1_field);
 268
 269         arm11_add_dr_scan_vc(1, &chain1_field, TAP_DRPAUSE);
 270
 271         CHECK_RETVAL(jtag_execute_queue());
 272
 273         JTAG_DEBUG("DSCR <= %08x (OLD %08x)", dscr, arm11->last_dscr);
 274
 275         arm11->last_dscr = dscr;
 276
 277         return ERROR_OK;
 278 }
 279
 280
 281
 282 /** Get the debug reason from Debug Status and Control Register (DSCR)
 283  *
 284  * \param dscr          DSCR value to analyze
 285  * \return                      Debug reason
 286  *
 287  */
 288 enum target_debug_reason arm11_get_DSCR_debug_reason(u32 dscr)
 289 {
 290         switch (dscr & ARM11_DSCR_METHOD_OF_DEBUG_ENTRY_MASK)
 291         {
 292         case ARM11_DSCR_METHOD_OF_DEBUG_ENTRY_HALT:
 293                 LOG_INFO("Debug entry: JTAG HALT");
 294                 return DBG_REASON_DBGRQ;
 295
 296         case ARM11_DSCR_METHOD_OF_DEBUG_ENTRY_BREAKPOINT:
 297                 LOG_INFO("Debug entry: breakpoint");
 298                 return DBG_REASON_BREAKPOINT;
 299
 300         case ARM11_DSCR_METHOD_OF_DEBUG_ENTRY_WATCHPOINT:
 301                 LOG_INFO("Debug entry: watchpoint");
 302                 return DBG_REASON_WATCHPOINT;
 303
 304         case ARM11_DSCR_METHOD_OF_DEBUG_ENTRY_BKPT_INSTRUCTION:
 305                 LOG_INFO("Debug entry: BKPT instruction");
 306                 return DBG_REASON_BREAKPOINT;
 307
 308         case ARM11_DSCR_METHOD_OF_DEBUG_ENTRY_EDBGRQ:
 309                 LOG_INFO("Debug entry: EDBGRQ signal");
 310                 return DBG_REASON_DBGRQ;
 311
 312         case ARM11_DSCR_METHOD_OF_DEBUG_ENTRY_VECTOR_CATCH:
 313                 LOG_INFO("Debug entry: VCR vector catch");
 314                 return DBG_REASON_BREAKPOINT;
 315
 316         default:
 317                 LOG_INFO("Debug entry: unknown");
 318                 return DBG_REASON_DBGRQ;
 319         }
 320 };
 321
 322
 323
 324 /** Prepare the stage for ITR/DTR operations
 325  * from the arm11_run_instr... group of functions.
 326  *
 327  * Put arm11_run_instr_data_prepare() and arm11_run_instr_data_finish()
 328  * around a block of arm11_run_instr_... calls.
 329  *
 330  * Select scan chain 5 to allow quick access to DTR. When scan
 331  * chain 4 is needed to put in a register the ITRSel instruction
 332  * shortcut is used instead of actually changing the Scan_N
 333  * register.
 334  *
 335  * \param arm11         Target state variable.
 336  *
 337  */
 338 void arm11_run_instr_data_prepare(arm11_common_t * arm11)
 339 {
 340         arm11_add_debug_SCAN_N(arm11, 0x05, ARM11_TAP_DEFAULT);
 341 }
 342
 343 /** Cleanup after ITR/DTR operations
 344  * from the arm11_run_instr... group of functions
 345  *
 346  * Put arm11_run_instr_data_prepare() and arm11_run_instr_data_finish()
 347  * around a block of arm11_run_instr_... calls.
 348  *
 349  * Any IDLE can lead to an instruction execution when
 350  * scan chains 4 or 5 are selected and the IR holds
 351  * INTEST or EXTEST. So we must disable that before
 352  * any following activities lead to an IDLE.
 353  *
 354  * \param arm11         Target state variable.
 355  *
 356  */
 357 void arm11_run_instr_data_finish(arm11_common_t * arm11)
 358 {
 359         arm11_add_debug_SCAN_N(arm11, 0x00, ARM11_TAP_DEFAULT);
 360 }
 361
 362
 363 /** Execute one or multiple instructions via ITR
 364  *
 365  * \pre arm11_run_instr_data_prepare() /  arm11_run_instr_data_finish() block
 366  *
 367  * \param arm11         Target state variable.
 368  * \param opcode        Pointer to sequence of ARM opcodes
 369  * \param count         Number of opcodes to execute
 370  *
 371  */
 372 int arm11_run_instr_no_data(arm11_common_t * arm11, u32 * opcode, size_t count)
 373 {
 374         arm11_add_IR(arm11, ARM11_ITRSEL, ARM11_TAP_DEFAULT);
 375
 376         while (count--)
 377         {
 378                 arm11_add_debug_INST(arm11, *opcode++, NULL, TAP_IDLE);
 379
 380                 while (1)
 381                 {
 382                         u8 flag;
 383
 384                         arm11_add_debug_INST(arm11, 0, &flag, count ? TAP_IDLE : TAP_DRPAUSE);
 385
 386                         CHECK_RETVAL(jtag_execute_queue());
 387
 388                         if (flag)
 389                                 break;
 390                 }
 391         }
 392
 393         return ERROR_OK;
 394 }
 395
 396 /** Execute one instruction via ITR
 397  *
 398  * \pre arm11_run_instr_data_prepare() /  arm11_run_instr_data_finish() block
 399  *
 400  * \param arm11         Target state variable.
 401  * \param opcode        ARM opcode
 402  *
 403  */
 404 void arm11_run_instr_no_data1(arm11_common_t * arm11, u32 opcode)
 405 {
 406         arm11_run_instr_no_data(arm11, &opcode, 1);
 407 }
 408
 409
 410 /** Execute one instruction via ITR repeatedly while
 411  *  passing data to the core via DTR on each execution.
 412  *
 413  *  The executed instruction \em must read data from DTR.
 414  *
 415  * \pre arm11_run_instr_data_prepare() /  arm11_run_instr_data_finish() block
 416  *
 417  * \param arm11         Target state variable.
 418  * \param opcode        ARM opcode
 419  * \param data          Pointer to the data words to be passed to the core
 420  * \param count         Number of data words and instruction repetitions
 421  *
 422  */
 423 int arm11_run_instr_data_to_core(arm11_common_t * arm11, u32 opcode, u32 * data, size_t count)
 424 {
 425         arm11_add_IR(arm11, ARM11_ITRSEL, ARM11_TAP_DEFAULT);
 426
 427         arm11_add_debug_INST(arm11, opcode, NULL, TAP_DRPAUSE);
 428
 429         arm11_add_IR(arm11, ARM11_EXTEST, ARM11_TAP_DEFAULT);
 430
 431         scan_field_t    chain5_fields[3];
 432
 433         u32                             Data;
 434         u8                              Ready;
 435         u8                              nRetry;
 436
 437         arm11_setup_field(arm11, 32,    &Data,  NULL,           chain5_fields + 0);
 438         arm11_setup_field(arm11,  1,    NULL,   &Ready,         chain5_fields + 1);
 439         arm11_setup_field(arm11,  1,    NULL,   &nRetry,        chain5_fields + 2);
 440
 441         while (count--)
 442         {
 443                 do
 444                 {
 445                         Data        = *data;
 446
 447                         arm11_add_dr_scan_vc(asizeof(chain5_fields), chain5_fields, TAP_IDLE);
 448
 449                         CHECK_RETVAL(jtag_execute_queue());
 450
 451                         JTAG_DEBUG("DTR  Ready %d  nRetry %d", Ready, nRetry);
 452                 }
 453                 while (!Ready);
 454
 455                 data++;
 456         }
 457
 458         arm11_add_IR(arm11, ARM11_INTEST, ARM11_TAP_DEFAULT);
 459
 460         do
 461         {
 462                 Data        = 0;
 463
 464                 arm11_add_dr_scan_vc(asizeof(chain5_fields), chain5_fields, TAP_DRPAUSE);
 465
 466                 CHECK_RETVAL(jtag_execute_queue());
 467
 468                 JTAG_DEBUG("DTR  Data %08x  Ready %d  nRetry %d", Data, Ready, nRetry);
 469         }
 470         while (!Ready);
 471
 472         return ERROR_OK;
 473 }
 474
 475 /** JTAG path for arm11_run_instr_data_to_core_noack
 476  *
 477  *  The repeated TAP_IDLE's do not cause a repeated execution
 478  *  if passed without leaving the state.
 479  *
 480  *  Since this is more than 7 bits (adjustable via adding more
 481  *  TAP_IDLE's) it produces an artificial delay in the lower
 482  *  layer (FT2232) that is long enough to finish execution on
 483  *  the core but still shorter than any manually inducible delays.
 484  *
 485  *  To disable this code, try "memwrite burst false"
 486  *
 487  */
 488 tap_state_t arm11_MOVE_DRPAUSE_IDLE_DRPAUSE_with_delay[] =
 489 {
 490         TAP_DREXIT2, TAP_DRUPDATE, TAP_IDLE, TAP_IDLE, TAP_IDLE, TAP_DRSELECT, TAP_DRCAPTURE, TAP_DRSHIFT
 491 };
 492
 493
 494
 495 /** Execute one instruction via ITR repeatedly while
 496  *  passing data to the core via DTR on each execution.
 497  *
 498  *  No Ready check during transmission.
 499  *
 500  *  The executed instruction \em must read data from DTR.
 501  *
 502  * \pre arm11_run_instr_data_prepare() /  arm11_run_instr_data_finish() block
 503  *
 504  * \param arm11         Target state variable.
 505  * \param opcode        ARM opcode
 506  * \param data          Pointer to the data words to be passed to the core
 507  * \param count         Number of data words and instruction repetitions
 508  *
 509  */
 510 int arm11_run_instr_data_to_core_noack(arm11_common_t * arm11, u32 opcode, u32 * data, size_t count)
 511 {
 512         arm11_add_IR(arm11, ARM11_ITRSEL, ARM11_TAP_DEFAULT);
 513
 514         arm11_add_debug_INST(arm11, opcode, NULL, TAP_DRPAUSE);
 515
 516         arm11_add_IR(arm11, ARM11_EXTEST, ARM11_TAP_DEFAULT);
 517
 518         scan_field_t    chain5_fields[3];
 519
 520         arm11_setup_field(arm11, 32,    NULL/*&Data*/,  NULL,                           chain5_fields + 0);
 521         arm11_setup_field(arm11,  1,    NULL,                   NULL /*&Ready*/,        chain5_fields + 1);
 522         arm11_setup_field(arm11,  1,    NULL,                   NULL,                           chain5_fields + 2);
 523
 524         u8                      Readies[count + 1];
 525         u8      *               ReadyPos                        = Readies;
 526
 527         while (count--)
 528         {
 529                 chain5_fields[0].out_value      = (void *)(data++);
 530                 chain5_fields[1].in_value       = ReadyPos++;
 531
 532                 if (count)
 533                 {
 534                         jtag_add_dr_scan(asizeof(chain5_fields), chain5_fields, TAP_DRPAUSE);
 535                         jtag_add_pathmove(asizeof(arm11_MOVE_DRPAUSE_IDLE_DRPAUSE_with_delay),
 536                                 arm11_MOVE_DRPAUSE_IDLE_DRPAUSE_with_delay);
 537                 }
 538                 else
 539                 {
 540                         jtag_add_dr_scan(asizeof(chain5_fields), chain5_fields, TAP_IDLE);
 541                 }
 542         }
 543
 544         arm11_add_IR(arm11, ARM11_INTEST, ARM11_TAP_DEFAULT);
 545
 546         chain5_fields[0].out_value      = 0;
 547         chain5_fields[1].in_value   = ReadyPos++;
 548
 549         arm11_add_dr_scan_vc(asizeof(chain5_fields), chain5_fields, TAP_DRPAUSE);
 550
 551         CHECK_RETVAL(jtag_execute_queue());
 552
 553         size_t error_count = 0;
 554
 555         {size_t i;
 556         for (i = 0; i < asizeof(Readies); i++)
 557         {
 558                 if (Readies[i] != 1)
 559                 {
 560                         error_count++;
 561                 }
 562         }}
 563
 564         if (error_count)
 565                 LOG_ERROR("Transfer errors " ZU, error_count);
 566
 567         return ERROR_OK;
 568 }
 569
 570
 571 /** Execute an instruction via ITR while handing data into the core via DTR.
 572  *
 573  *  The executed instruction \em must read data from DTR.
 574  *
 575  * \pre arm11_run_instr_data_prepare() /  arm11_run_instr_data_finish() block
 576  *
 577  * \param arm11         Target state variable.
 578  * \param opcode        ARM opcode
 579  * \param data          Data word to be passed to the core via DTR
 580  *
 581  */
 582 int arm11_run_instr_data_to_core1(arm11_common_t * arm11, u32 opcode, u32 data)
 583 {
 584         return arm11_run_instr_data_to_core(arm11, opcode, &data, 1);
 585 }
 586
 587
 588 /** Execute one instruction via ITR repeatedly while
 589  *  reading data from the core via DTR on each execution.
 590  *
 591  *  The executed instruction \em must write data to DTR.
 592  *
 593  * \pre arm11_run_instr_data_prepare() /  arm11_run_instr_data_finish() block
 594  *
 595  * \param arm11         Target state variable.
 596  * \param opcode        ARM opcode
 597  * \param data          Pointer to an array that receives the data words from the core
 598  * \param count         Number of data words and instruction repetitions
 599  *
 600  */
 601 int arm11_run_instr_data_from_core(arm11_common_t * arm11, u32 opcode, u32 * data, size_t count)
 602 {
 603         arm11_add_IR(arm11, ARM11_ITRSEL, ARM11_TAP_DEFAULT);
 604
 605         arm11_add_debug_INST(arm11, opcode, NULL, TAP_IDLE);
 606
 607         arm11_add_IR(arm11, ARM11_INTEST, ARM11_TAP_DEFAULT);
 608
 609         scan_field_t    chain5_fields[3];
 610
 611         u32                     Data;
 612         u8                      Ready;
 613         u8                      nRetry;
 614
 615         arm11_setup_field(arm11, 32,    NULL,   &Data,      chain5_fields + 0);
 616         arm11_setup_field(arm11,  1,    NULL,   &Ready,     chain5_fields + 1);
 617         arm11_setup_field(arm11,  1,    NULL,   &nRetry,    chain5_fields + 2);
 618
 619         while (count--)
 620         {
 621                 do
 622                 {
 623                         arm11_add_dr_scan_vc(asizeof(chain5_fields), chain5_fields, count ? TAP_IDLE : TAP_DRPAUSE);
 624
 625                         CHECK_RETVAL(jtag_execute_queue());
 626
 627                         JTAG_DEBUG("DTR  Data %08x  Ready %d  nRetry %d", Data, Ready, nRetry);
 628                 }
 629                 while (!Ready);
 630
 631                 *data++ = Data;
 632         }
 633
 634         return ERROR_OK;
 635 }
 636
 637 /** Execute one instruction via ITR
 638  *  then load r0 into DTR and read DTR from core.
 639  *
 640  *  The first executed instruction (\p opcode) should write data to r0.
 641  *
 642  * \pre arm11_run_instr_data_prepare() /  arm11_run_instr_data_finish() block
 643  *
 644  * \param arm11         Target state variable.
 645  * \param opcode        ARM opcode to write r0 with the value of interest
 646  * \param data          Pointer to a data word that receives the value from r0 after \p opcode was executed.
 647  *
 648  */
 649 void arm11_run_instr_data_from_core_via_r0(arm11_common_t * arm11, u32 opcode, u32 * data)
 650 {
 651         arm11_run_instr_no_data1(arm11, opcode);
 652
 653         /* MCR p14,0,R0,c0,c5,0 (move r0 -> wDTR -> local var) */
 654         arm11_run_instr_data_from_core(arm11, 0xEE000E15, data, 1);
 655 }
 656
 657 /** Load data into core via DTR then move it to r0 then
 658  *  execute one instruction via ITR
 659  *
 660  *  The final executed instruction (\p opcode) should read data from r0.
 661  *
 662  * \pre arm11_run_instr_data_prepare() /  arm11_run_instr_data_finish() block
 663  *
 664  * \param arm11         Target state variable.
 665  * \param opcode        ARM opcode to read r0 act upon it
 666  * \param data          Data word that will be written to r0 before \p opcode is executed
 667  *
 668  */
 669 void arm11_run_instr_data_to_core_via_r0(arm11_common_t * arm11, u32 opcode, u32 data)
 670 {
 671         /* MRC p14,0,r0,c0,c5,0 */
 672         arm11_run_instr_data_to_core1(arm11, 0xEE100E15, data);
 673
 674         arm11_run_instr_no_data1(arm11, opcode);
 675 }
 676
 677 /** Apply reads and writes to scan chain 7
 678  *
 679  * \see arm11_sc7_action_t
 680  *
 681  * \param arm11         Target state variable.
 682  * \param actions       A list of read and/or write instructions
 683  * \param count         Number of instructions in the list.
 684  *
 685  */
 686 int arm11_sc7_run(arm11_common_t * arm11, arm11_sc7_action_t * actions, size_t count)
 687 {
 688         arm11_add_debug_SCAN_N(arm11, 0x07, ARM11_TAP_DEFAULT);
 689
 690         arm11_add_IR(arm11, ARM11_EXTEST, ARM11_TAP_DEFAULT);
 691
 692         scan_field_t    chain7_fields[3];
 693
 694         u8                              nRW;
 695         u32                             DataOut;
 696         u8                              AddressOut;
 697         u8                              Ready;
 698         u32                             DataIn;
 699         u8                              AddressIn;
 700
 701         arm11_setup_field(arm11,  1, &nRW,                      &Ready,         chain7_fields + 0);
 702         arm11_setup_field(arm11, 32, &DataOut,          &DataIn,        chain7_fields + 1);
 703         arm11_setup_field(arm11,  7, &AddressOut,       &AddressIn,     chain7_fields + 2);
 704
 705         {size_t i;
 706         for (i = 0; i < count + 1; i++)
 707         {
 708                 if (i < count)
 709                 {
 710                         nRW                     = actions[i].write ? 1 : 0;
 711                         DataOut         = actions[i].value;
 712                         AddressOut      = actions[i].address;
 713                 }
 714                 else
 715                 {
 716                         nRW                     = 0;
 717                         DataOut         = 0;
 718                         AddressOut      = 0;
 719                 }
 720
 721                 do
 722                 {
 723                         JTAG_DEBUG("SC7 <= Address %02x  Data %08x    nRW %d", AddressOut, DataOut, nRW);
 724
 725                         arm11_add_dr_scan_vc(asizeof(chain7_fields), chain7_fields, TAP_DRPAUSE);
 726
 727                         CHECK_RETVAL(jtag_execute_queue());
 728
 729                         JTAG_DEBUG("SC7 => Address %02x  Data %08x  Ready %d", AddressIn, DataIn, Ready);
 730                 }
 731                 while (!Ready); /* 'nRW' is 'Ready' on read out */
 732
 733                 if (i > 0)
 734                 {
 735                         if (actions[i - 1].address != AddressIn)
 736                         {
 737                                 LOG_WARNING("Scan chain 7 shifted out unexpected address");
 738                         }
 739
 740                         if (!actions[i - 1].write)
 741                         {
 742                                 actions[i - 1].value = DataIn;
 743                         }
 744                         else
 745                         {
 746                                 if (actions[i - 1].value != DataIn)
 747                                 {
 748                                         LOG_WARNING("Scan chain 7 shifted out unexpected data");
 749                                 }
 750                         }
 751                 }
 752         }}
 753
 754         {size_t i;
 755         for (i = 0; i < count; i++)
 756         {
 757                 JTAG_DEBUG("SC7 %02d: %02x %s %08x", i, actions[i].address, actions[i].write ? "<=" : "=>", actions[i].value);
 758         }}
 759
 760         return ERROR_OK;
 761 }
 762
 763 /** Clear VCR and all breakpoints and watchpoints via scan chain 7
 764  *
 765  * \param arm11         Target state variable.
 766  *
 767  */
 768 void arm11_sc7_clear_vbw(arm11_common_t * arm11)
 769 {
 770         arm11_sc7_action_t              clear_bw[arm11->brp + arm11->wrp + 1];
 771         arm11_sc7_action_t *    pos = clear_bw;
 772
 773         {size_t i;
 774         for (i = 0; i < asizeof(clear_bw); i++)
 775         {
 776                 clear_bw[i].write       = true;
 777                 clear_bw[i].value       = 0;
 778         }}
 779
 780         {size_t i;
 781         for (i = 0; i < arm11->brp; i++)
 782                 (pos++)->address = ARM11_SC7_BCR0 + i;
 783         }
 784
 785         {size_t i;
 786         for (i = 0; i < arm11->wrp; i++)
 787                 (pos++)->address = ARM11_SC7_WCR0 + i;
 788         }
 789
 790         (pos++)->address = ARM11_SC7_VCR;
 791
 792         arm11_sc7_run(arm11, clear_bw, asizeof(clear_bw));
 793 }
 794
 795 /** Write VCR register
 796  *
 797  * \param arm11         Target state variable.
 798  * \param value         Value to be written
 799  */
 800 void arm11_sc7_set_vcr(arm11_common_t * arm11, u32 value)
 801 {
 802         arm11_sc7_action_t              set_vcr;
 803
 804         set_vcr.write           = true;
 805         set_vcr.address         = ARM11_SC7_VCR;
 806         set_vcr.value           = value;
 807
 808
 809         arm11_sc7_run(arm11, &set_vcr, 1);
 810 }
 811
 812
 813
 814 /** Read word from address
 815  *
 816  * \param arm11         Target state variable.
 817  * \param address       Memory address to be read
 818  * \param result        Pointer where to store result
 819  *
 820  */
 821 int arm11_read_memory_word(arm11_common_t * arm11, u32 address, u32 * result)
 822 {
 823         arm11_run_instr_data_prepare(arm11);
 824
 825         /* MRC p14,0,r0,c0,c5,0 (r0 = address) */
 826         CHECK_RETVAL(arm11_run_instr_data_to_core1(arm11, 0xee100e15, address));
 827
 828         /* LDC p14,c5,[R0],#4 (DTR = [r0]) */
 829         CHECK_RETVAL(arm11_run_instr_data_from_core(arm11, 0xecb05e01, result, 1));
 830
 831         arm11_run_instr_data_finish(arm11);
 832
 833         return ERROR_OK;
 834 }
 835
 836