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_srst_asserted(int *srst_asserted
)
107 *srst_asserted
=readSRST();
111 static int zy1000_power_dropout(int *dropout
)
113 *dropout
=readPowerDropout();
118 jtag_interface_t zy1000_interface
=
121 .execute_queue
= bitbang_execute_queue
,
122 .speed
= zy1000_speed
,
123 .register_commands
= zy1000_register_commands
,
127 .speed_div
= zy1000_speed_div
,
128 .power_dropout
= zy1000_power_dropout
,
129 .srst_asserted
= zy1000_srst_asserted
,
132 bitbang_interface_t zy1000_bitbang
=
135 .write
= zy1000_write
,
136 .reset
= zy1000_reset
141 static void zy1000_write(int tck
, int tms
, int tdi
)
146 int zy1000_read(void)
151 extern bool readSRST();
153 void zy1000_reset(int trst
, int srst
)
155 LOG_DEBUG("zy1000 trst=%d, srst=%d", trst
, srst
);
158 ZY1000_POKE(0x08000014, 0x00000001);
162 /* Danger!!! if clk!=0 when in
163 * idle in TAP_RTI, reset halt on str912 will fail.
165 ZY1000_POKE(0x08000010, 0x00000001);
170 ZY1000_POKE(0x08000014, 0x00000002);
175 ZY1000_POKE(0x08000010, 0x00000002);
178 if (trst
||(srst
&&(jtag_reset_config
& RESET_SRST_PULLS_TRST
)))
181 /* we're now in the TLR state until trst is deasserted */
182 ZY1000_POKE(0x08000020, TAP_TLR
);
185 /* We'll get RCLK failure when we assert TRST, so clear any false positives here */
186 ZY1000_POKE(0x08000014, 0x400);
189 /* wait for srst to float back up */
193 for (i
=0; i
<1000; i
++)
195 // We don't want to sense our own reset, so we clear here.
196 // There is of course a timing hole where we could loose
207 LOG_USER("SRST didn't deassert after %dms", i
);
210 LOG_USER("SRST took %dms to deassert", i
);
215 int zy1000_speed(int speed
)
221 ZY1000_POKE(0x08000010, 0x100);
222 LOG_DEBUG("jtag_speed using RCLK");
226 if(speed
> 8190 || speed
< 2)
228 LOG_ERROR("valid ZY1000 jtag_speed=[8190,2]. Divisor is 64MHz / even values between 8190-2, i.e. min 7814Hz, max 32MHz");
229 return ERROR_INVALID_ARGUMENTS
;
232 LOG_USER("jtag_speed %d => JTAG clk=%f", speed
, 64.0/(float)speed
);
233 ZY1000_POKE(0x08000014, 0x100);
234 ZY1000_POKE(0x0800001c, speed
&~1);
239 int zy1000_register_commands(struct command_context_s
*cmd_ctx
)
245 int zy1000_init(void)
247 ZY1000_POKE(0x08000010, 0x30); // Turn on LED1 & LED2
249 /* deassert resets. Important to avoid infinite loop waiting for SRST to deassert */
251 zy1000_speed(jtag_speed
);
253 bitbang_interface
= &zy1000_bitbang
;
258 int zy1000_quit(void)
266 /* loads a file and returns a pointer to it in memory. The file contains
267 * a 0 byte(sentinel) after len bytes - the length of the file. */
268 int loadFile(const char *fileName
, void **data
, int *len
)
271 pFile
= fopen (fileName
,"rb");
274 LOG_ERROR("Can't open %s\n", fileName
);
275 return ERROR_JTAG_DEVICE_ERROR
;
277 if (fseek (pFile
, 0, SEEK_END
)!=0)
279 LOG_ERROR("Can't open %s\n", fileName
);
281 return ERROR_JTAG_DEVICE_ERROR
;
286 LOG_ERROR("Can't open %s\n", fileName
);
288 return ERROR_JTAG_DEVICE_ERROR
;
291 if (fseek (pFile
, 0, SEEK_SET
)!=0)
293 LOG_ERROR("Can't open %s\n", fileName
);
295 return ERROR_JTAG_DEVICE_ERROR
;
297 *data
=malloc(*len
+1);
300 LOG_ERROR("Can't open %s\n", fileName
);
302 return ERROR_JTAG_DEVICE_ERROR
;
305 if (fread(*data
, 1, *len
, pFile
)!=*len
)
309 LOG_ERROR("Can't open %s\n", fileName
);
310 return ERROR_JTAG_DEVICE_ERROR
;
313 *(((char *)(*data
))+*len
)=0; /* sentinel */
324 int interface_jtag_execute_queue(void)
329 ZY1000_PEEK(0x08000010, empty
);
330 /* clear JTAG error register */
331 ZY1000_POKE(0x08000014, 0x400);
333 if ((empty
&0x400)!=0)
335 LOG_WARNING("RCLK timeout");
336 /* the error is informative only as we don't want to break the firmware if there
337 * is a false positive.
339 // return ERROR_FAIL;
348 static cyg_uint32
getShiftValue()
352 ZY1000_PEEK(0x0800000c, value
);
353 VERBOSE(LOG_INFO("getShiftValue %08x", value
));
357 static cyg_uint32
getShiftValueFlip()
361 ZY1000_PEEK(0x08000018, value
);
362 VERBOSE(LOG_INFO("getShiftValue %08x (flipped)", value
));
368 static void shiftValueInnerFlip(const enum tap_state state
, const enum tap_state endState
, int repeat
, cyg_uint32 value
)
370 VERBOSE(LOG_INFO("shiftValueInner %s %s %d %08x (flipped)", tap_state_strings
[state
], tap_state_strings
[endState
], repeat
, value
));
374 ZY1000_POKE(0x0800000c, value
);
375 ZY1000_POKE(0x08000008, (1<<15)|(repeat
<<8)|(a
<<4)|b
);
376 VERBOSE(getShiftValueFlip());
380 extern int jtag_check_value(u8
*captured
, void *priv
);
382 static void gotoEndState()
384 setCurrentState(cmd_queue_end_state
);
387 static __inline
void scanFields(int num_fields
, scan_field_t
*fields
, enum tap_state shiftState
, int pause
)
393 for (i
= 0; i
< num_fields
; i
++)
397 static u8
*in_buff
=NULL
; /* pointer to buffer for scanned data */
398 static int in_buff_size
=0;
402 // figure out where to store the input data
403 int num_bits
=fields
[i
].num_bits
;
404 if (fields
[i
].in_value
!=NULL
)
406 inBuffer
=fields
[i
].in_value
;
407 } else if (fields
[i
].in_handler
!=NULL
)
409 if (in_buff_size
*8<num_bits
)
411 // we need more space
415 in_buff_size
=(num_bits
+7)/8;
416 in_buff
=malloc(in_buff_size
);
419 LOG_ERROR("Out of memory");
420 jtag_error
=ERROR_JTAG_QUEUE_FAILED
;
427 // here we shuffle N bits out/in
431 enum tap_state pause_state
;
434 pause_state
=(shiftState
==TAP_SD
)?TAP_SD
:TAP_SI
;
438 /* we have more to shift out */
439 } else if (pause
&&(i
== num_fields
-1))
441 /* this was the last to shift out this time */
442 pause_state
=(shiftState
==TAP_SD
)?TAP_PD
:TAP_PI
;
445 // we have (num_bits+7)/8 bytes of bits to toggle out.
446 // bits are pushed out LSB to MSB
448 if (fields
[i
].out_value
!=NULL
)
452 value
|=fields
[i
].out_value
[(j
+l
)/8]<<l
;
455 /* mask away unused bits for easier debugging */
456 value
&=~(((u32
)0xffffffff)<<k
);
458 shiftValueInner(shiftState
, pause_state
, k
, value
);
462 // data in, LSB to MSB
463 value
=getShiftValue();
464 // we're shifting in data to MSB, shift data to be aligned for returning the value
469 inBuffer
[(j
+l
)/8]=(value
>>l
)&0xff;
475 if (fields
[i
].in_handler
!=NULL
)
478 int r
=fields
[i
].in_handler(inBuffer
, fields
[i
].in_handler_priv
, fields
+i
);
481 /* this will cause jtag_execute_queue() to return an error */
488 int interface_jtag_add_end_state(enum tap_state state
)
494 int interface_jtag_add_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
499 jtag_device_t
*device
;
501 for (i
=0; i
< jtag_num_devices
; i
++)
503 int pause
=i
==(jtag_num_devices
-1);
505 device
= jtag_get_device(i
);
506 scan_size
= device
->ir_length
;
508 /* search the list */
509 for (j
=0; j
< num_fields
; j
++)
511 if (i
== fields
[j
].device
)
515 if ((jtag_verify_capture_ir
)&&(fields
[j
].in_handler
==NULL
))
517 jtag_set_check_value(fields
+j
, device
->expected
, device
->expected_mask
, NULL
);
518 } else if (jtag_verify_capture_ir
)
520 fields
[j
].in_check_value
= device
->expected
;
521 fields
[j
].in_check_mask
= device
->expected_mask
;
524 scanFields(1, fields
+j
, TAP_SI
, pause
);
525 /* update device information */
526 buf_cpy(fields
[j
].out_value
, jtag_get_device(i
)->cur_instr
, scan_size
);
535 /* if a device isn't listed, set it to BYPASS */
536 u8 ones
[]={0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff};
539 memset(&tmp
, 0, sizeof(tmp
));
540 tmp
.out_value
= ones
;
541 tmp
.num_bits
= scan_size
;
542 scanFields(1, &tmp
, TAP_SI
, pause
);
543 /* update device information */
544 buf_cpy(tmp
.out_value
, jtag_get_device(i
)->cur_instr
, scan_size
);
557 int interface_jtag_add_plain_ir_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
559 scanFields(num_fields
, fields
, TAP_SI
, 1);
565 /*extern jtag_command_t **jtag_get_last_command_p(void);*/
567 int interface_jtag_add_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
570 for (i
=0; i
< jtag_num_devices
; i
++)
573 int pause
= (i
==(jtag_num_devices
-1));
575 for (j
=0; j
< num_fields
; j
++)
577 if (i
== fields
[j
].device
)
581 scanFields(1, fields
+j
, TAP_SD
, pause
);
586 #ifdef _DEBUG_JTAG_IO_
587 /* if a device isn't listed, the BYPASS register should be selected */
588 if (!jtag_get_device(i
)->bypass
)
590 LOG_ERROR("BUG: no scan data for a device not in BYPASS");
596 /* program the scan field to 1 bit length, and ignore it's value */
598 tmp
.out_value
= NULL
;
601 tmp
.in_check_value
= NULL
;
602 tmp
.in_check_mask
= NULL
;
603 tmp
.in_handler
= NULL
;
604 tmp
.in_handler_priv
= NULL
;
606 scanFields(1, &tmp
, TAP_SD
, pause
);
610 #ifdef _DEBUG_JTAG_IO_
611 /* if a device is listed, the BYPASS register must not be selected */
612 if (jtag_get_device(i
)->bypass
)
614 LOG_WARNING("scan data for a device in BYPASS");
623 int interface_jtag_add_plain_dr_scan(int num_fields
, scan_field_t
*fields
, enum tap_state state
)
625 scanFields(num_fields
, fields
, TAP_SD
, 1);
631 int interface_jtag_add_tlr()
633 setCurrentState(TAP_TLR
);
640 extern int jtag_nsrst_delay
;
641 extern int jtag_ntrst_delay
;
643 int interface_jtag_add_reset(int req_trst
, int req_srst
)
645 zy1000_reset(req_trst
, req_srst
);
649 int interface_jtag_add_runtest(int num_cycles
, enum tap_state state
)
651 /* num_cycles can be 0 */
652 setCurrentState(TAP_RTI
);
654 /* execute num_cycles, 32 at the time. */
656 for (i
=0; i
<num_cycles
; i
+=32)
660 if (num_cycles
-i
<num
)
664 shiftValueInner(TAP_RTI
, TAP_RTI
, num
, 0);
668 /* finish in end_state */
669 setCurrentState(state
);
671 enum tap_state t
=TAP_RTI
;
672 /* test manual drive code on any target */
674 u8 tms_scan
= TAP_MOVE(t
, state
);
676 for (i
= 0; i
< 7; i
++)
678 tms
= (tms_scan
>> i
) & 1;
680 ZY1000_POKE(0x08000028, tms
);
683 ZY1000_POKE(0x08000020, state
);
690 int interface_jtag_add_sleep(u32 us
)
696 int interface_jtag_add_pathmove(int num_states
, enum tap_state
*path
)
701 /*wait for the fifo to be empty*/
706 enum tap_state cur_state
=cmd_queue_cur_state
;
710 if (tap_transitions
[cur_state
].low
== path
[state_count
])
714 else if (tap_transitions
[cur_state
].high
== path
[state_count
])
720 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings
[cur_state
], tap_state_strings
[path
[state_count
]]);
725 ZY1000_POKE(0x08000028, tms
);
727 cur_state
= path
[state_count
];
733 ZY1000_POKE(0x08000020, cur_state
);
739 void embeddedice_write_dcc(int chain_pos
, int reg_addr
, u8
*buffer
, int little
, int count
)
741 // static int const reg_addr=0x5;
742 enum tap_state end_state
=cmd_queue_end_state
;
743 if (jtag_num_devices
==1)
745 /* better performance via code duplication */
749 for (i
= 0; i
< count
; i
++)
751 shiftValueInner(TAP_SD
, TAP_SD
, 32, fast_target_buffer_get_u32(buffer
, 1));
752 shiftValueInner(TAP_SD
, end_state
, 6, reg_addr
|(1<<5));
758 for (i
= 0; i
< count
; i
++)
760 shiftValueInner(TAP_SD
, TAP_SD
, 32, fast_target_buffer_get_u32(buffer
, 0));
761 shiftValueInner(TAP_SD
, end_state
, 6, reg_addr
|(1<<5));
769 for (i
= 0; i
< count
; i
++)
771 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)