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