1 /***************************************************************************
2 * Copyright (C) 2007-2008 by Øyvind Harboe *
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. *
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. *
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 ***************************************************************************/
27 #include "../target/embeddedice.h"
30 #include <cyg/hal/hal_io.h> // low level i/o
31 #include <cyg/hal/var_io.h> // common registers
32 #include <cyg/hal/plf_io.h> // platform registers
33 #include <cyg/hal/hal_diag.h>
38 extern int jtag_error
;
40 /* low level command set
42 int zy1000_read(void);
43 static void zy1000_write(int tck
, int tms
, int tdi
);
44 void zy1000_reset(int trst
, int srst
);
47 int zy1000_speed(int speed
);
48 int zy1000_register_commands(struct command_context_s
*cmd_ctx
);
49 int zy1000_init(void);
50 int zy1000_quit(void);
52 /* interface commands */
53 int zy1000_handle_zy1000_port_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 static int zy1000_khz(int khz
, int *jtag_speed
)
63 *jtag_speed
=64000/khz
;
68 static int zy1000_speed_div(int speed
, int *khz
)
82 static bool readPowerDropout()
85 // sample and clear power dropout
86 HAL_WRITE_UINT32(0x08000010, 0x80);
87 HAL_READ_UINT32(0x08000010, state
);
89 powerDropout
= (state
& 0x80) != 0;
94 static bool readSRST()
97 // sample and clear SRST sensing
98 HAL_WRITE_UINT32(0x08000010, 0x00000040);
99 HAL_READ_UINT32(0x08000010, state
);
101 srstAsserted
= (state
& 0x40) != 0;
105 static int zy1000_power_dropout(int *dropout
)
107 *dropout
=readPowerDropout(); /* by default we can't detect power dropout */
112 jtag_interface_t zy1000_interface
=
115 .execute_queue
= bitbang_execute_queue
,
116 .speed
= zy1000_speed
,
117 .register_commands
= zy1000_register_commands
,
121 .speed_div
= zy1000_speed_div
,
122 .power_dropout
= zy1000_power_dropout
,
125 bitbang_interface_t zy1000_bitbang
=
128 .write
= zy1000_write
,
129 .reset
= zy1000_reset
134 static void zy1000_write(int tck
, int tms
, int tdi
)
139 int zy1000_read(void)
144 extern bool readSRST();
146 void zy1000_reset(int trst
, int srst
)
148 LOG_DEBUG("zy1000 trst=%d, srst=%d", trst
, srst
);
151 ZY1000_POKE(0x08000014, 0x00000001);
155 /* Danger!!! if clk!=0 when in
156 * idle in TAP_RTI, reset halt on str912 will fail.
158 ZY1000_POKE(0x08000010, 0x00000001);
163 ZY1000_POKE(0x08000014, 0x00000002);
168 ZY1000_POKE(0x08000010, 0x00000002);
171 if (trst
||(srst
&&(jtag_reset_config
& RESET_SRST_PULLS_TRST
)))
174 /* we're now in the TLR state until trst is deasserted */
175 ZY1000_POKE(0x08000020, TAP_TLR
);
178 /* We'll get RCLK failure when we assert TRST, so clear any false positives here */
179 ZY1000_POKE(0x08000014, 0x400);
182 /* wait for srst to float back up */
186 for (i
=0; i
<1000; i
++)
188 // We don't want to sense our own reset, so we clear here.
189 // There is of course a timing hole where we could loose
200 LOG_USER("SRST didn't deassert after %dms", i
);
203 LOG_USER("SRST took %dms to deassert", i
);
208 int zy1000_speed(int speed
)
214 ZY1000_POKE(0x08000010, 0x100);
215 LOG_DEBUG("jtag_speed using RCLK");
219 if(speed
> 8190 || speed
< 2)
221 LOG_ERROR("valid ZY1000 jtag_speed=[8190,2]. Divisor is 64MHz / even values between 8190-2, i.e. min 7814Hz, max 32MHz");
222 return ERROR_INVALID_ARGUMENTS
;
225 LOG_USER("jtag_speed %d => JTAG clk=%f", speed
, 64.0/(float)speed
);
226 ZY1000_POKE(0x08000014, 0x100);
227 ZY1000_POKE(0x0800001c, speed
&~1);
232 int zy1000_register_commands(struct command_context_s
*cmd_ctx
)
238 int zy1000_init(void)
240 ZY1000_POKE(0x08000010, 0x30); // Turn on LED1 & LED2
242 /* deassert resets. Important to avoid infinite loop waiting for SRST to deassert */
244 zy1000_speed(jtag_speed
);
246 bitbang_interface
= &zy1000_bitbang
;
251 int zy1000_quit(void)
259 /* loads a file and returns a pointer to it in memory. The file contains
260 * a 0 byte(sentinel) after len bytes - the length of the file. */
261 int loadFile(const char *fileName
, void **data
, int *len
)
264 pFile
= fopen (fileName
,"rb");
267 LOG_ERROR("Can't open %s\n", fileName
);
268 return ERROR_JTAG_DEVICE_ERROR
;
270 if (fseek (pFile
, 0, SEEK_END
)!=0)
272 LOG_ERROR("Can't open %s\n", fileName
);
274 return ERROR_JTAG_DEVICE_ERROR
;
279 LOG_ERROR("Can't open %s\n", fileName
);
281 return ERROR_JTAG_DEVICE_ERROR
;
284 if (fseek (pFile
, 0, SEEK_SET
)!=0)
286 LOG_ERROR("Can't open %s\n", fileName
);
288 return ERROR_JTAG_DEVICE_ERROR
;
290 *data
=malloc(*len
+1);
293 LOG_ERROR("Can't open %s\n", fileName
);
295 return ERROR_JTAG_DEVICE_ERROR
;
298 if (fread(*data
, 1, *len
, pFile
)!=*len
)
302 LOG_ERROR("Can't open %s\n", fileName
);
303 return ERROR_JTAG_DEVICE_ERROR
;
306 *(((char *)(*data
))+*len
)=0; /* sentinel */
317 int interface_jtag_execute_queue(void)
322 ZY1000_PEEK(0x08000010, empty
);
323 /* clear JTAG error register */
324 ZY1000_POKE(0x08000014, 0x400);
326 if ((empty
&0x400)!=0)
328 LOG_WARNING("RCLK timeout");
329 /* the error is informative only as we don't want to break the firmware if there
330 * is a false positive.
332 // return ERROR_FAIL;
341 static cyg_uint32
getShiftValue()
345 ZY1000_PEEK(0x0800000c, value
);
346 VERBOSE(LOG_INFO("getShiftValue %08x", value
));
350 static cyg_uint32
getShiftValueFlip()
354 ZY1000_PEEK(0x08000018, value
);
355 VERBOSE(LOG_INFO("getShiftValue %08x (flipped)", value
));
361 static void shiftValueInnerFlip(const enum tap_state state
, const enum tap_state endState
, int repeat
, cyg_uint32 value
)
363 VERBOSE(LOG_INFO("shiftValueInner %s %s %d %08x (flipped)", tap_state_strings
[state
], tap_state_strings
[endState
], repeat
, value
));
367 ZY1000_POKE(0x0800000c, value
);
368 ZY1000_POKE(0x08000008, (1<<15)|(repeat
<<8)|(a
<<4)|b
);
369 VERBOSE(getShiftValueFlip());
373 extern int jtag_check_value(u8
*captured
, void *priv
);
375 static void gotoEndState()
377 setCurrentState(cmd_queue_end_state
);
380 static __inline
void scanFields(int num_fields
, scan_field_t
*fields
, enum tap_state shiftState
, int pause
)
386 for (i
= 0; i
< num_fields
; i
++)
390 static u8
*in_buff
=NULL
; /* pointer to buffer for scanned data */
391 static int in_buff_size
=0;
395 // figure out where to store the input data
396 int num_bits
=fields
[i
].num_bits
;
397 if (fields
[i
].in_value
!=NULL
)
399 inBuffer
=fields
[i
].in_value
;
400 } else if (fields
[i
].in_handler
!=NULL
)
402 if (in_buff_size
*8<num_bits
)
404 // we need more space
408 in_buff_size
=(num_bits
+7)/8;
409 in_buff
=malloc(in_buff_size
);
412 LOG_ERROR("Out of memory");
413 jtag_error
=ERROR_JTAG_QUEUE_FAILED
;
420 // here we shuffle N bits out/in
424 enum tap_state pause_state
;
427 pause_state
=(shiftState
==TAP_SD
)?TAP_SD
:TAP_SI
;
431 /* we have more to shift out */
432 } else if (pause
&&(i
== num_fields
-1))
434 /* this was the last to shift out this time */
435 pause_state
=(shiftState
==TAP_SD
)?TAP_PD
:TAP_PI
;
438 // we have (num_bits+7)/8 bytes of bits to toggle out.
439 // bits are pushed out LSB to MSB
441 if (fields
[i
].out_value
!=NULL
)
445 value
|=fields
[i
].out_value
[(j
+l
)/8]<<l
;
448 /* mask away unused bits for easier debugging */
449 value
&=~(((u32
)0xffffffff)<<k
);
451 shiftValueInner(shiftState
, pause_state
, k
, value
);
455 // data in, LSB to MSB
456 value
=getShiftValue();
457 // we're shifting in data to MSB, shift data to be aligned for returning the value
462 inBuffer
[(j
+l
)/8]=(value
>>l
)&0xff;
468 if (fields
[i
].in_handler
!=NULL
)
471 int r
=fields
[i
].in_handler(inBuffer
, fields
[i
].in_handler_priv
, fields
+i
);
474 /* this will cause jtag_execute_queue() to return an error */
481 int interface_jtag_add_end_state(enum tap_state state
)
487 int interface_jtag_add_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
492 jtag_device_t
*device
;
494 for (i
=0; i
< jtag_num_devices
; i
++)
496 int pause
=i
==(jtag_num_devices
-1);
498 device
= jtag_get_device(i
);
499 scan_size
= device
->ir_length
;
501 /* search the list */
502 for (j
=0; j
< num_fields
; j
++)
504 if (i
== fields
[j
].device
)
508 if ((jtag_verify_capture_ir
)&&(fields
[j
].in_handler
==NULL
))
510 jtag_set_check_value(fields
+j
, device
->expected
, device
->expected_mask
, NULL
);
511 } else if (jtag_verify_capture_ir
)
513 fields
[j
].in_check_value
= device
->expected
;
514 fields
[j
].in_check_mask
= device
->expected_mask
;
517 scanFields(1, fields
+j
, TAP_SI
, pause
);
518 /* update device information */
519 buf_cpy(fields
[j
].out_value
, jtag_get_device(i
)->cur_instr
, scan_size
);
528 /* if a device isn't listed, set it to BYPASS */
529 u8 ones
[]={0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
532 memset(&tmp
, 0, sizeof(tmp
));
533 tmp
.out_value
= ones
;
534 tmp
.num_bits
= scan_size
;
535 scanFields(1, &tmp
, TAP_SI
, pause
);
536 /* update device information */
537 buf_cpy(tmp
.out_value
, jtag_get_device(i
)->cur_instr
, scan_size
);
550 int interface_jtag_add_plain_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
552 scanFields(num_fields
, fields
, TAP_SI
, 1);
558 /*extern jtag_command_t **jtag_get_last_command_p(void);*/
560 int interface_jtag_add_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
563 for (i
=0; i
< jtag_num_devices
; i
++)
566 int pause
= (i
==(jtag_num_devices
-1));
568 for (j
=0; j
< num_fields
; j
++)
570 if (i
== fields
[j
].device
)
574 scanFields(1, fields
+j
, TAP_SD
, pause
);
579 #ifdef _DEBUG_JTAG_IO_
580 /* if a device isn't listed, the BYPASS register should be selected */
581 if (!jtag_get_device(i
)->bypass
)
583 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
589 /* program the scan field to 1 bit length, and ignore it's value */
591 tmp
.out_value
= NULL
;
594 tmp
.in_check_value
= NULL
;
595 tmp
.in_check_mask
= NULL
;
596 tmp
.in_handler
= NULL
;
597 tmp
.in_handler_priv
= NULL
;
599 scanFields(1, &tmp
, TAP_SD
, pause
);
603 #ifdef _DEBUG_JTAG_IO_
604 /* if a device is listed, the BYPASS register must not be selected */
605 if (jtag_get_device(i
)->bypass
)
607 LOG_WARNING("scan data for a device in BYPASS");
616 int interface_jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
618 scanFields(num_fields
, fields
, TAP_SD
, 1);
624 int interface_jtag_add_tlr()
626 setCurrentState(TAP_TLR
);
633 extern int jtag_nsrst_delay
;
634 extern int jtag_ntrst_delay
;
636 int interface_jtag_add_reset(int req_trst
, int req_srst
)
638 zy1000_reset(req_trst
, req_srst
);
642 int interface_jtag_add_runtest(int num_cycles
, enum tap_state state
)
644 /* num_cycles can be 0 */
645 setCurrentState(TAP_RTI
);
647 /* execute num_cycles, 32 at the time. */
649 for (i
=0; i
<num_cycles
; i
+=32)
653 if (num_cycles
-i
<num
)
657 shiftValueInner(TAP_RTI
, TAP_RTI
, num
, 0);
661 /* finish in end_state */
662 setCurrentState(state
);
664 enum tap_state t
=TAP_RTI
;
665 /* test manual drive code on any target */
667 u8 tms_scan
= TAP_MOVE(t
, state
);
669 for (i
= 0; i
< 7; i
++)
671 tms
= (tms_scan
>> i
) & 1;
673 ZY1000_POKE(0x08000028, tms
);
676 ZY1000_POKE(0x08000020, state
);
683 int interface_jtag_add_sleep(u32 us
)
689 int interface_jtag_add_pathmove(int num_states
, enum tap_state
*path
)
694 /*wait for the fifo to be empty*/
699 enum tap_state cur_state
=cmd_queue_cur_state
;
703 if (tap_transitions
[cur_state
].low
== path
[state_count
])
707 else if (tap_transitions
[cur_state
].high
== path
[state_count
])
713 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings
[cur_state
], tap_state_strings
[path
[state_count
]]);
718 ZY1000_POKE(0x08000028, tms
);
720 cur_state
= path
[state_count
];
726 ZY1000_POKE(0x08000020, cur_state
);
732 void embeddedice_write_dcc(int chain_pos
, int reg_addr
, u8
*buffer
, int little
, int count
)
734 // static int const reg_addr=0x5;
735 enum tap_state end_state
=cmd_queue_end_state
;
736 if (jtag_num_devices
==1)
738 /* better performance via code duplication */
742 for (i
= 0; i
< count
; i
++)
744 shiftValueInner(TAP_SD
, TAP_SD
, 32, fast_target_buffer_get_u32(buffer
, 1));
745 shiftValueInner(TAP_SD
, end_state
, 6, reg_addr
|(1<<5));
751 for (i
= 0; i
< count
; i
++)
753 shiftValueInner(TAP_SD
, TAP_SD
, 32, fast_target_buffer_get_u32(buffer
, 0));
754 shiftValueInner(TAP_SD
, end_state
, 6, reg_addr
|(1<<5));
762 for (i
= 0; i
< count
; i
++)
764 embeddedice_write_reg_inner(chain_pos
, reg_addr
, fast_target_buffer_get_u32(buffer
, little
));
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)