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