git.sur5r.net Git - openocd/blob - src/target/arm11_dbgtap.c

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