src/jtag/zy1000/zy1000.c

   1 /***************************************************************************
   2  *   Copyright (C) 2007-2008 by Øyvind Harboe                              *
   3  *                                                                         *
   4  *   This program is free software; you can redistribute it and/or modify  *
   5  *   it under the terms of the GNU General Public License as published by  *
   6  *   the Free Software Foundation; either version 2 of the License, or     *
   7  *   (at your option) any later version.                                   *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  18  ***************************************************************************/
  19 #ifdef HAVE_CONFIG_H
  20 #include "config.h"
  21 #endif
  22
  23 #include "embeddedice.h"
  24 #include "minidriver.h"
  25 #include "interface.h"
  26
  27 #include <cyg/hal/hal_io.h>             // low level i/o
  28 #include <cyg/hal/hal_diag.h>
  29
  30
  31 #define ZYLIN_VERSION "1.52"
  32 #define ZYLIN_DATE __DATE__
  33 #define ZYLIN_TIME __TIME__
  34 #define ZYLIN_OPENOCD "$Revision$"
  35 #define ZYLIN_OPENOCD_VERSION "Zylin JTAG ZY1000 " ZYLIN_VERSION " " ZYLIN_DATE " " ZYLIN_TIME
  36
  37 /* low level command set
  38  */
  39 int zy1000_read(void);
  40 static void zy1000_write(int tck, int tms, int tdi);
  41 void zy1000_reset(int trst, int srst);
  42
  43
  44 int zy1000_speed(int speed);
  45 int zy1000_register_commands(struct command_context_s *cmd_ctx);
  46 int zy1000_init(void);
  47 int zy1000_quit(void);
  48
  49 /* interface commands */
  50 int zy1000_handle_zy1000_port_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
  51
  52 static int zy1000_khz(int khz, int *jtag_speed)
  53 {
  54         if (khz==0)
  55         {
  56                 *jtag_speed=0;
  57         }
  58         else
  59         {
  60                 *jtag_speed=64000/khz;
  61         }
  62         return ERROR_OK;
  63 }
  64
  65 static int zy1000_speed_div(int speed, int *khz)
  66 {
  67         if (speed==0)
  68         {
  69                 *khz = 0;
  70         }
  71         else
  72         {
  73                 *khz=64000/speed;
  74         }
  75
  76         return ERROR_OK;
  77 }
  78
  79 static bool readPowerDropout(void)
  80 {
  81         cyg_uint32 state;
  82         // sample and clear power dropout
  83         HAL_WRITE_UINT32(ZY1000_JTAG_BASE+0x10, 0x80);
  84         HAL_READ_UINT32(ZY1000_JTAG_BASE+0x10, state);
  85         bool powerDropout;
  86         powerDropout = (state & 0x80) != 0;
  87         return powerDropout;
  88 }
  89
  90
  91 static bool readSRST(void)
  92 {
  93         cyg_uint32 state;
  94         // sample and clear SRST sensing
  95         HAL_WRITE_UINT32(ZY1000_JTAG_BASE+0x10, 0x00000040);
  96         HAL_READ_UINT32(ZY1000_JTAG_BASE+0x10, state);
  97         bool srstAsserted;
  98         srstAsserted = (state & 0x40) != 0;
  99         return srstAsserted;
 100 }
 101
 102 static int zy1000_srst_asserted(int *srst_asserted)
 103 {
 104         *srst_asserted=readSRST();
 105         return ERROR_OK;
 106 }
 107
 108 static int zy1000_power_dropout(int *dropout)
 109 {
 110         *dropout=readPowerDropout();
 111         return ERROR_OK;
 112 }
 113
 114
 115 jtag_interface_t zy1000_interface =
 116 {
 117         .name = "ZY1000",
 118         .execute_queue = NULL,
 119         .speed = zy1000_speed,
 120         .register_commands = zy1000_register_commands,
 121         .init = zy1000_init,
 122         .quit = zy1000_quit,
 123         .khz = zy1000_khz,
 124         .speed_div = zy1000_speed_div,
 125         .power_dropout = zy1000_power_dropout,
 126         .srst_asserted = zy1000_srst_asserted,
 127 };
 128
 129 static void zy1000_write(int tck, int tms, int tdi)
 130 {
 131
 132 }
 133
 134 int zy1000_read(void)
 135 {
 136         return -1;
 137 }
 138
 139 extern bool readSRST(void);
 140
 141 void zy1000_reset(int trst, int srst)
 142 {
 143         LOG_DEBUG("zy1000 trst=%d, srst=%d", trst, srst);
 144         if(!srst)
 145         {
 146                 ZY1000_POKE(ZY1000_JTAG_BASE+0x14, 0x00000001);
 147         }
 148         else
 149         {
 150                 /* Danger!!! if clk!=0 when in
 151                  * idle in TAP_IDLE, reset halt on str912 will fail.
 152                  */
 153                 ZY1000_POKE(ZY1000_JTAG_BASE+0x10, 0x00000001);
 154         }
 155
 156         if(!trst)
 157         {
 158                 ZY1000_POKE(ZY1000_JTAG_BASE+0x14, 0x00000002);
 159         }
 160         else
 161         {
 162                 /* assert reset */
 163                 ZY1000_POKE(ZY1000_JTAG_BASE+0x10, 0x00000002);
 164         }
 165
 166         if (trst||(srst&&(jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
 167         {
 168                 waitIdle();
 169                 /* we're now in the RESET state until trst is deasserted */
 170                 ZY1000_POKE(ZY1000_JTAG_BASE+0x20, TAP_RESET);
 171         } else
 172         {
 173                 /* We'll get RCLK failure when we assert TRST, so clear any false positives here */
 174                 ZY1000_POKE(ZY1000_JTAG_BASE+0x14, 0x400);
 175         }
 176
 177         /* wait for srst to float back up */
 178         if (!srst)
 179         {
 180                 int i;
 181                 for (i=0; i<1000; i++)
 182                 {
 183                         // We don't want to sense our own reset, so we clear here.
 184                         // There is of course a timing hole where we could loose
 185                         // a "real" reset.
 186                         if (!readSRST())
 187                                 break;
 188
 189                         /* wait 1ms */
 190                         alive_sleep(1);
 191                 }
 192
 193                 if (i==1000)
 194                 {
 195                         LOG_USER("SRST didn't deassert after %dms", i);
 196                 } else if (i>1)
 197                 {
 198                         LOG_USER("SRST took %dms to deassert", i);
 199                 }
 200         }
 201 }
 202
 203 int zy1000_speed(int speed)
 204 {
 205         if(speed == 0)
 206         {
 207                 /*0 means RCLK*/
 208                 speed = 0;
 209                 ZY1000_POKE(ZY1000_JTAG_BASE+0x10, 0x100);
 210                 LOG_DEBUG("jtag_speed using RCLK");
 211         }
 212         else
 213         {
 214                 if(speed > 8190 || speed < 2)
 215                 {
 216                         LOG_USER("valid ZY1000 jtag_speed=[8190,2]. Divisor is 64MHz / even values between 8190-2, i.e. min 7814Hz, max 32MHz");
 217                         return ERROR_INVALID_ARGUMENTS;
 218                 }
 219
 220                 LOG_USER("jtag_speed %d => JTAG clk=%f", speed, 64.0/(float)speed);
 221                 ZY1000_POKE(ZY1000_JTAG_BASE+0x14, 0x100);
 222                 ZY1000_POKE(ZY1000_JTAG_BASE+0x1c, speed&~1);
 223         }
 224         return ERROR_OK;
 225 }
 226
 227 static bool savePower;
 228
 229
 230 static void setPower(bool power)
 231 {
 232         savePower = power;
 233         if (power)
 234         {
 235                 HAL_WRITE_UINT32(ZY1000_JTAG_BASE+0x14, 0x8);
 236         } else
 237         {
 238                 HAL_WRITE_UINT32(ZY1000_JTAG_BASE+0x10, 0x8);
 239         }
 240 }
 241
 242 int handle_power_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
 243 {
 244         if (argc > 1)
 245         {
 246                 return ERROR_INVALID_ARGUMENTS;
 247         }
 248
 249         if (argc == 1)
 250         {
 251                 if (strcmp(args[0], "on") == 0)
 252                 {
 253                         setPower(1);
 254                 }
 255                 else if (strcmp(args[0], "off") == 0)
 256                 {
 257                         setPower(0);
 258                 } else
 259                 {
 260                         command_print(cmd_ctx, "arg is \"on\" or \"off\"");
 261                         return ERROR_INVALID_ARGUMENTS;
 262                 }
 263         }
 264
 265         command_print(cmd_ctx, "Target power %s", savePower ? "on" : "off");
 266
 267         return ERROR_OK;
 268 }
 269
 270
 271 /* Give TELNET a way to find out what version this is */
 272 static int jim_zy1000_version(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
 273 {
 274         if ((argc < 1) || (argc > 2))
 275                 return JIM_ERR;
 276         char buff[128];
 277         const char *version_str=NULL;
 278
 279         if (argc == 1)
 280         {
 281                 version_str=ZYLIN_OPENOCD_VERSION;
 282         } else
 283         {
 284                 const char *str = Jim_GetString(argv[1], NULL);
 285                 if (strcmp("openocd", str) == 0)
 286                 {
 287                         int revision;
 288                         revision = atol(ZYLIN_OPENOCD+strlen("XRevision: "));
 289                         sprintf(buff, "%d", revision);
 290                         version_str=buff;
 291                 }
 292                 else if (strcmp("zy1000", str) == 0)
 293                 {
 294                         version_str=ZYLIN_VERSION;
 295                 }
 296                 else if (strcmp("date", str) == 0)
 297                 {
 298                         version_str=ZYLIN_DATE;
 299                 }
 300                 else
 301                 {
 302                         return JIM_ERR;
 303                 }
 304         }
 305
 306         Jim_SetResult(interp, Jim_NewStringObj(interp, version_str, -1));
 307
 308         return JIM_OK;
 309 }
 310
 311
 312 static int
 313 zylinjtag_Jim_Command_powerstatus(Jim_Interp *interp,
 314                                                                    int argc,
 315                 Jim_Obj * const *argv)
 316 {
 317         if (argc != 1)
 318         {
 319                 Jim_WrongNumArgs(interp, 1, argv, "powerstatus");
 320                 return JIM_ERR;
 321         }
 322
 323         cyg_uint32 status;
 324         ZY1000_PEEK(ZY1000_JTAG_BASE+0x10, status);
 325
 326         Jim_SetResult(interp, Jim_NewIntObj(interp, (status&0x80)!=0));
 327
 328         return JIM_OK;
 329 }
 330
 331 int zy1000_register_commands(struct command_context_s *cmd_ctx)
 332 {
 333         register_command(cmd_ctx, NULL, "power", handle_power_command, COMMAND_ANY,
 334                         "power <on/off> - turn power switch to target on/off. No arguments - print status.");
 335
 336         Jim_CreateCommand(interp, "zy1000_version", jim_zy1000_version, NULL, NULL);
 337
 338
 339         Jim_CreateCommand(interp, "powerstatus", zylinjtag_Jim_Command_powerstatus, NULL, NULL);
 340
 341         return ERROR_OK;
 342 }
 343
 344
 345
 346
 347 int zy1000_init(void)
 348 {
 349         LOG_USER("%s", ZYLIN_OPENOCD_VERSION);
 350
 351         ZY1000_POKE(ZY1000_JTAG_BASE+0x10, 0x30); // Turn on LED1 & LED2
 352
 353         setPower(true); // on by default
 354
 355
 356          /* deassert resets. Important to avoid infinite loop waiting for SRST to deassert */
 357         zy1000_reset(0, 0);
 358         zy1000_speed(jtag_get_speed());
 359
 360         return ERROR_OK;
 361 }
 362
 363 int zy1000_quit(void)
 364 {
 365
 366         return ERROR_OK;
 367 }
 368
 369
 370
 371 int interface_jtag_execute_queue(void)
 372 {
 373         cyg_uint32 empty;
 374
 375         waitIdle();
 376         ZY1000_PEEK(ZY1000_JTAG_BASE+0x10, empty);
 377         /* clear JTAG error register */
 378         ZY1000_POKE(ZY1000_JTAG_BASE+0x14, 0x400);
 379
 380         if ((empty&0x400)!=0)
 381         {
 382                 LOG_WARNING("RCLK timeout");
 383                 /* the error is informative only as we don't want to break the firmware if there
 384                  * is a false positive.
 385                  */
 386 //              return ERROR_FAIL;
 387         }
 388         return ERROR_OK;
 389 }
 390
 391
 392
 393
 394
 395 static cyg_uint32 getShiftValue(void)
 396 {
 397         cyg_uint32 value;
 398         waitIdle();
 399         ZY1000_PEEK(ZY1000_JTAG_BASE+0xc, value);
 400         VERBOSE(LOG_INFO("getShiftValue %08x", value));
 401         return value;
 402 }
 403 #if 0
 404 static cyg_uint32 getShiftValueFlip(void)
 405 {
 406         cyg_uint32 value;
 407         waitIdle();
 408         ZY1000_PEEK(ZY1000_JTAG_BASE+0x18, value);
 409         VERBOSE(LOG_INFO("getShiftValue %08x (flipped)", value));
 410         return value;
 411 }
 412 #endif
 413
 414 #if 0
 415 static void shiftValueInnerFlip(const tap_state_t state, const tap_state_t endState, int repeat, cyg_uint32 value)
 416 {
 417         VERBOSE(LOG_INFO("shiftValueInner %s %s %d %08x (flipped)", tap_state_name(state), tap_state_name(endState), repeat, value));
 418         cyg_uint32 a,b;
 419         a=state;
 420         b=endState;
 421         ZY1000_POKE(ZY1000_JTAG_BASE+0xc, value);
 422         ZY1000_POKE(ZY1000_JTAG_BASE+0x8, (1<<15)|(repeat<<8)|(a<<4)|b);
 423         VERBOSE(getShiftValueFlip());
 424 }
 425 #endif
 426
 427 extern int jtag_check_value(uint8_t *captured, void *priv);
 428
 429 static __inline void scanFields(int num_fields, scan_field_t *fields, tap_state_t shiftState, tap_state_t end_state)
 430 {
 431         int i;
 432         int j;
 433         int k;
 434
 435         for (i = 0; i < num_fields; i++)
 436         {
 437                 cyg_uint32 value;
 438
 439                 static uint8_t *in_buff=NULL; /* pointer to buffer for scanned data */
 440                 static int in_buff_size=0;
 441                 uint8_t *inBuffer=NULL;
 442
 443
 444                 // figure out where to store the input data
 445                 int num_bits=fields[i].num_bits;
 446                 if (fields[i].in_value!=NULL)
 447                 {
 448                         inBuffer=fields[i].in_value;
 449                 }
 450
 451                 // here we shuffle N bits out/in
 452                 j=0;
 453                 while (j<num_bits)
 454                 {
 455                         tap_state_t pause_state;
 456                         int l;
 457                         k=num_bits-j;
 458                         pause_state=(shiftState==TAP_DRSHIFT)?TAP_DRSHIFT:TAP_IRSHIFT;
 459                         if (k>32)
 460                         {
 461                                 k=32;
 462                                 /* we have more to shift out */
 463                         } else if (i == num_fields-1)
 464                         {
 465                                 /* this was the last to shift out this time */
 466                                 pause_state=end_state;
 467                         }
 468
 469                         // we have (num_bits+7)/8 bytes of bits to toggle out.
 470                         // bits are pushed out LSB to MSB
 471                         value=0;
 472                         if (fields[i].out_value!=NULL)
 473                         {
 474                                 for (l=0; l<k; l+=8)
 475                                 {
 476                                         value|=fields[i].out_value[(j+l)/8]<<l;
 477                                 }
 478                         }
 479                         /* mask away unused bits for easier debugging */
 480                         value&=~(((u32)0xffffffff)<<k);
 481
 482                         shiftValueInner(shiftState, pause_state, k, value);
 483
 484                         if (inBuffer!=NULL)
 485                         {
 486                                 // data in, LSB to MSB
 487                                 value=getShiftValue();
 488                                 // we're shifting in data to MSB, shift data to be aligned for returning the value
 489                                 value >>= 32-k;
 490
 491                                 for (l=0; l<k; l+=8)
 492                                 {
 493                                         inBuffer[(j+l)/8]=(value>>l)&0xff;
 494                                 }
 495                         }
 496                         j+=k;
 497                 }
 498         }
 499 }
 500
 501 int interface_jtag_set_end_state(tap_state_t state)
 502 {
 503         return ERROR_OK;
 504 }
 505
 506
 507 int interface_jtag_add_ir_scan(int num_fields, const scan_field_t *fields, tap_state_t state)
 508 {
 509
 510         int j;
 511         int scan_size = 0;
 512         jtag_tap_t *tap, *nextTap;
 513         for(tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap=nextTap)
 514         {
 515                 nextTap=jtag_tap_next_enabled(tap);
 516                 tap_state_t end_state;
 517                 if (nextTap==NULL)
 518                 {
 519                         end_state = state;
 520                 } else
 521                 {
 522                         end_state = TAP_IRSHIFT;
 523                 }
 524
 525                 int found = 0;
 526
 527                 scan_size = tap->ir_length;
 528
 529                 /* search the list */
 530                 for (j=0; j < num_fields; j++)
 531                 {
 532                         if (tap == fields[j].tap)
 533                         {
 534                                 found = 1;
 535
 536                                 scanFields(1, fields+j, TAP_IRSHIFT, end_state);
 537                                 /* update device information */
 538                                 buf_cpy(fields[j].out_value, tap->cur_instr, scan_size);
 539
 540                                 tap->bypass = 0;
 541                                 break;
 542                         }
 543                 }
 544
 545                 if (!found)
 546                 {
 547                         /* if a device isn't listed, set it to BYPASS */
 548                         uint8_t ones[]={0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
 549
 550                         scan_field_t tmp;
 551                         memset(&tmp, 0, sizeof(tmp));
 552                         tmp.out_value = ones;
 553                         tmp.num_bits = scan_size;
 554                         scanFields(1, &tmp, TAP_IRSHIFT, end_state);
 555                         /* update device information */
 556                         buf_cpy(tmp.out_value, tap->cur_instr, scan_size);
 557                         tap->bypass = 1;
 558                 }
 559         }
 560
 561         return ERROR_OK;
 562 }
 563
 564
 565
 566
 567
 568 int interface_jtag_add_plain_ir_scan(int num_fields, const scan_field_t *fields, tap_state_t state)
 569 {
 570         scanFields(num_fields, fields, TAP_IRSHIFT, state);
 571
 572         return ERROR_OK;
 573 }
 574
 575 /*extern jtag_command_t **jtag_get_last_command_p(void);*/
 576
 577 int interface_jtag_add_dr_scan(int num_fields, const scan_field_t *fields, tap_state_t state)
 578 {
 579
 580         int j;
 581         jtag_tap_t *tap, *nextTap;
 582         for(tap = jtag_tap_next_enabled(NULL); tap!= NULL; tap=nextTap)
 583         {
 584                 nextTap=jtag_tap_next_enabled(tap);
 585                 int found=0;
 586                 tap_state_t end_state;
 587                 if (nextTap==NULL)
 588                 {
 589                         end_state = state;
 590                 } else
 591                 {
 592                         end_state = TAP_DRSHIFT;
 593                 }
 594
 595                 for (j=0; j < num_fields; j++)
 596                 {
 597                         if (tap == fields[j].tap)
 598                         {
 599                                 found = 1;
 600
 601                                 scanFields(1, fields+j, TAP_DRSHIFT, end_state);
 602                         }
 603                 }
 604                 if (!found)
 605                 {
 606                         scan_field_t tmp;
 607                         /* program the scan field to 1 bit length, and ignore it's value */
 608                         tmp.num_bits = 1;
 609                         tmp.out_value = NULL;
 610                         tmp.in_value = NULL;
 611
 612                         scanFields(1, &tmp, TAP_DRSHIFT, end_state);
 613                 }
 614                 else
 615                 {
 616                 }
 617         }
 618         return ERROR_OK;
 619 }
 620
 621 int interface_jtag_add_plain_dr_scan(int num_fields, const scan_field_t *fields, tap_state_t state)
 622 {
 623         scanFields(num_fields, fields, TAP_DRSHIFT, state);
 624         return ERROR_OK;
 625 }
 626
 627
 628 int interface_jtag_add_tlr()
 629 {
 630         setCurrentState(TAP_RESET);
 631         return ERROR_OK;
 632 }
 633
 634
 635
 636
 637 extern int jtag_nsrst_delay;
 638 extern int jtag_ntrst_delay;
 639
 640 int interface_jtag_add_reset(int req_trst, int req_srst)
 641 {
 642         zy1000_reset(req_trst, req_srst);
 643         return ERROR_OK;
 644 }
 645
 646 static int zy1000_jtag_add_clocks(int num_cycles, tap_state_t state, tap_state_t clockstate)
 647 {
 648         /* num_cycles can be 0 */
 649         setCurrentState(clockstate);
 650
 651         /* execute num_cycles, 32 at the time. */
 652         int i;
 653         for (i=0; i<num_cycles; i+=32)
 654         {
 655                 int num;
 656                 num=32;
 657                 if (num_cycles-i<num)
 658                 {
 659                         num=num_cycles-i;
 660                 }
 661                 shiftValueInner(clockstate, clockstate, num, 0);
 662         }
 663
 664 #if !TEST_MANUAL()
 665         /* finish in end_state */
 666         setCurrentState(state);
 667 #else
 668         tap_state_t t=TAP_IDLE;
 669         /* test manual drive code on any target */
 670         int tms;
 671         uint8_t tms_scan = tap_get_tms_path(t, state);
 672         int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
 673
 674         for (i = 0; i < tms_count; i++)
 675         {
 676                 tms = (tms_scan >> i) & 1;
 677                 waitIdle();
 678                 ZY1000_POKE(ZY1000_JTAG_BASE+0x28,  tms);
 679         }
 680         waitIdle();
 681         ZY1000_POKE(ZY1000_JTAG_BASE+0x20, state);
 682 #endif
 683
 684
 685         return ERROR_OK;
 686 }
 687
 688 int interface_jtag_add_runtest(int num_cycles, tap_state_t state)
 689 {
 690         return zy1000_jtag_add_clocks(num_cycles, state, TAP_IDLE);
 691 }
 692
 693 int interface_jtag_add_clocks(int num_cycles)
 694 {
 695         return zy1000_jtag_add_clocks(num_cycles, cmd_queue_cur_state, cmd_queue_cur_state);
 696 }
 697
 698 int interface_jtag_add_sleep(u32 us)
 699 {
 700         jtag_sleep(us);
 701         return ERROR_OK;
 702 }
 703
 704 int interface_jtag_add_pathmove(int num_states, const tap_state_t *path)
 705 {
 706         int state_count;
 707         int tms = 0;
 708
 709         /*wait for the fifo to be empty*/
 710         waitIdle();
 711
 712         state_count = 0;
 713
 714         tap_state_t cur_state=cmd_queue_cur_state;
 715
 716         while (num_states)
 717         {
 718                 if (tap_state_transition(cur_state, false) == path[state_count])
 719                 {
 720                         tms = 0;
 721                 }
 722                 else if (tap_state_transition(cur_state, true) == path[state_count])
 723                 {
 724                         tms = 1;
 725                 }
 726                 else
 727                 {
 728                         LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(cur_state), tap_state_name(path[state_count]));
 729                         exit(-1);
 730                 }
 731
 732                 waitIdle();
 733                 ZY1000_POKE(ZY1000_JTAG_BASE+0x28,  tms);
 734
 735                 cur_state = path[state_count];
 736                 state_count++;
 737                 num_states--;
 738         }
 739
 740         waitIdle();
 741         ZY1000_POKE(ZY1000_JTAG_BASE+0x20,  cur_state);
 742         return ERROR_OK;
 743 }
 744
 745
 746
 747 void embeddedice_write_dcc(jtag_tap_t *tap, int reg_addr, uint8_t *buffer, int little, int count)
 748 {
 749 //      static int const reg_addr=0x5;
 750         tap_state_t end_state=jtag_get_end_state();
 751         if (jtag_tap_next_enabled(jtag_tap_next_enabled(NULL))==NULL)
 752         {
 753                 /* better performance via code duplication */
 754                 if (little)
 755                 {
 756                         int i;
 757                         for (i = 0; i < count; i++)
 758                         {
 759                                 shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, 32, fast_target_buffer_get_u32(buffer, 1));
 760                                 shiftValueInner(TAP_DRSHIFT, end_state, 6, reg_addr|(1<<5));
 761                                 buffer+=4;
 762                         }
 763                 } else
 764                 {
 765                         int i;
 766                         for (i = 0; i < count; i++)
 767                         {
 768                                 shiftValueInner(TAP_DRSHIFT, TAP_DRSHIFT, 32, fast_target_buffer_get_u32(buffer, 0));
 769                                 shiftValueInner(TAP_DRSHIFT, end_state, 6, reg_addr|(1<<5));
 770                                 buffer+=4;
 771                         }
 772                 }
 773         }
 774         else
 775         {
 776                 int i;
 777                 for (i = 0; i < count; i++)
 778                 {
 779                         embeddedice_write_reg_inner(tap, reg_addr, fast_target_buffer_get_u32(buffer, little));
 780                         buffer += 4;
 781                 }
 782         }
 783 }
 784
 785