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

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