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

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