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