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