Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
jlink: fix jlink regression introduced by ae8cdc commit
[openocd.git] / src / jtag / drivers / jlink.c
1 /***************************************************************************
2 * Copyright (C) 2007 by Juergen Stuber <juergen@jstuber.net> *
3 * based on Dominic Rath's and Benedikt Sauter's usbprog.c *
4 * *
5 * Copyright (C) 2008 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
7 * *
8 * Copyright (C) 2011 by Jean-Christophe PLAGNIOL-VIILARD *
9 * plagnioj@jcrosoft.com *
10 * *
11 * Copyright (C) 2015 by Marc Schink *
12 * openocd-dev@marcschink.de *
13 * *
14 * Copyright (C) 2015 by Paul Fertser *
15 * fercerpav@gmail.com *
16 * *
17 * This program is free software; you can redistribute it and/or modify *
18 * it under the terms of the GNU General Public License as published by *
19 * the Free Software Foundation; either version 2 of the License, or *
20 * (at your option) any later version. *
21 * *
22 * This program is distributed in the hope that it will be useful, *
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
25 * GNU General Public License for more details. *
26 * *
27 * You should have received a copy of the GNU General Public License *
28 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
29 ***************************************************************************/
30
31 #ifdef HAVE_CONFIG_H
32 #include "config.h"
33 #endif
34
35 #include <stdint.h>
36 #include <math.h>
37
38 #include <jtag/interface.h>
39 #include <jtag/swd.h>
40 #include <jtag/commands.h>
41
42 #include <libjaylink/libjaylink.h>
43
44 static struct jaylink_context *jayctx;
45 static struct jaylink_device_handle *devh;
46 static struct jaylink_connection conn;
47 static struct jaylink_connection connlist[JAYLINK_MAX_CONNECTIONS];
48 static enum jaylink_jtag_version jtag_command_version;
49 static uint8_t caps[JAYLINK_DEV_EXT_CAPS_SIZE];
50
51 static uint32_t serial_number;
52 static bool use_serial_number;
53 static enum jaylink_usb_address usb_address;
54 static bool use_usb_address;
55 static enum jaylink_target_interface iface = JAYLINK_TIF_JTAG;
56 static bool trace_enabled;
57
58 #define JLINK_MAX_SPEED 12000
59 #define JLINK_TAP_BUFFER_SIZE 2048
60
61 static unsigned int swd_buffer_size = JLINK_TAP_BUFFER_SIZE;
62
63 /* 256 byte non-volatile memory */
64 struct device_config {
65 uint8_t usb_address;
66 /* 0ffset 0x01 to 0x03 */
67 uint8_t reserved_1[3];
68 uint32_t target_power;
69 /* 0ffset 0x08 to 0x1f */
70 uint8_t reserved_2[24];
71 /* IP only for J-Link Pro */
72 uint8_t ip_address[4];
73 uint8_t subnet_mask[4];
74 /* 0ffset 0x28 to 0x2f */
75 uint8_t reserved_3[8];
76 uint8_t mac_address[6];
77 /* 0ffset 0x36 to 0xff */
78 uint8_t reserved_4[202];
79 } __attribute__ ((packed));
80
81 static struct device_config config;
82 static struct device_config tmp_config;
83
84 /* Queue command functions */
85 static void jlink_end_state(tap_state_t state);
86 static void jlink_state_move(void);
87 static void jlink_path_move(int num_states, tap_state_t *path);
88 static void jlink_stableclocks(int num_cycles);
89 static void jlink_runtest(int num_cycles);
90 static void jlink_reset(int trst, int srst);
91 static int jlink_swd_run_queue(void);
92 static void jlink_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data, uint32_t ap_delay_clk);
93 static int jlink_swd_switch_seq(enum swd_special_seq seq);
94
95 /* J-Link tap buffer functions */
96 static void jlink_tap_init(void);
97 static int jlink_flush(void);
98 /**
99 * Queue data to go out and in, flushing the queue as many times as
100 * necessary.
101 *
102 * @param out A pointer to TDI data, if NULL, old stale data will be used.
103 * @param out_offset A bit offset for TDI data.
104 * @param tms_out A pointer to TMS data, if NULL, zeroes will be emitted.
105 * @param tms_offset A bit offset for TMS data.
106 * @param in A pointer to store TDO data to, if NULL the data will be discarded.
107 * @param in_offset A bit offset for TDO data.
108 * @param length Amount of bits to transfer out and in.
109 *
110 * @retval This function doesn't return any value.
111 */
112 static void jlink_clock_data(const uint8_t *out, unsigned out_offset,
113 const uint8_t *tms_out, unsigned tms_offset,
114 uint8_t *in, unsigned in_offset,
115 unsigned length);
116
117 static enum tap_state jlink_last_state = TAP_RESET;
118 static int queued_retval;
119
120 /***************************************************************************/
121 /* External interface implementation */
122
123 static void jlink_execute_stableclocks(struct jtag_command *cmd)
124 {
125 DEBUG_JTAG_IO("stableclocks %i cycles", cmd->cmd.runtest->num_cycles);
126 jlink_stableclocks(cmd->cmd.runtest->num_cycles);
127 }
128
129 static void jlink_execute_runtest(struct jtag_command *cmd)
130 {
131 DEBUG_JTAG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles,
132 cmd->cmd.runtest->end_state);
133
134 jlink_end_state(cmd->cmd.runtest->end_state);
135 jlink_runtest(cmd->cmd.runtest->num_cycles);
136 }
137
138 static void jlink_execute_statemove(struct jtag_command *cmd)
139 {
140 DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
141
142 jlink_end_state(cmd->cmd.statemove->end_state);
143 jlink_state_move();
144 }
145
146 static void jlink_execute_pathmove(struct jtag_command *cmd)
147 {
148 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
149 cmd->cmd.pathmove->num_states,
150 cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
151
152 jlink_path_move(cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path);
153 }
154
155 static void jlink_execute_scan(struct jtag_command *cmd)
156 {
157 DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN",
158 jtag_scan_type(cmd->cmd.scan));
159
160 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
161 while (cmd->cmd.scan->num_fields > 0
162 && cmd->cmd.scan->fields[cmd->cmd.scan->num_fields - 1].num_bits == 0) {
163 cmd->cmd.scan->num_fields--;
164 LOG_DEBUG("discarding trailing empty field");
165 }
166
167 if (cmd->cmd.scan->num_fields == 0) {
168 LOG_DEBUG("empty scan, doing nothing");
169 return;
170 }
171
172 if (cmd->cmd.scan->ir_scan) {
173 if (tap_get_state() != TAP_IRSHIFT) {
174 jlink_end_state(TAP_IRSHIFT);
175 jlink_state_move();
176 }
177 } else {
178 if (tap_get_state() != TAP_DRSHIFT) {
179 jlink_end_state(TAP_DRSHIFT);
180 jlink_state_move();
181 }
182 }
183
184 jlink_end_state(cmd->cmd.scan->end_state);
185
186 struct scan_field *field = cmd->cmd.scan->fields;
187 unsigned scan_size = 0;
188
189 for (int i = 0; i < cmd->cmd.scan->num_fields; i++, field++) {
190 scan_size += field->num_bits;
191 DEBUG_JTAG_IO("%s%s field %d/%d %d bits",
192 field->in_value ? "in" : "",
193 field->out_value ? "out" : "",
194 i,
195 cmd->cmd.scan->num_fields,
196 field->num_bits);
197
198 if (i == cmd->cmd.scan->num_fields - 1 && tap_get_state() != tap_get_end_state()) {
199 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
200 * movement. This last field can't have length zero, it was checked above. */
201 jlink_clock_data(field->out_value,
202 0,
203 NULL,
204 0,
205 field->in_value,
206 0,
207 field->num_bits - 1);
208 uint8_t last_bit = 0;
209 if (field->out_value)
210 bit_copy(&last_bit, 0, field->out_value, field->num_bits - 1, 1);
211 uint8_t tms_bits = 0x01;
212 jlink_clock_data(&last_bit,
213 0,
214 &tms_bits,
215 0,
216 field->in_value,
217 field->num_bits - 1,
218 1);
219 tap_set_state(tap_state_transition(tap_get_state(), 1));
220 jlink_clock_data(NULL,
221 0,
222 &tms_bits,
223 1,
224 NULL,
225 0,
226 1);
227 tap_set_state(tap_state_transition(tap_get_state(), 0));
228 } else
229 jlink_clock_data(field->out_value,
230 0,
231 NULL,
232 0,
233 field->in_value,
234 0,
235 field->num_bits);
236 }
237
238 if (tap_get_state() != tap_get_end_state()) {
239 jlink_end_state(tap_get_end_state());
240 jlink_state_move();
241 }
242
243 DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
244 (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
245 tap_state_name(tap_get_end_state()));
246 }
247
248 static void jlink_execute_reset(struct jtag_command *cmd)
249 {
250 DEBUG_JTAG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst,
251 cmd->cmd.reset->srst);
252
253 jlink_flush();
254 jlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
255 jlink_flush();
256 }
257
258 static void jlink_execute_sleep(struct jtag_command *cmd)
259 {
260 DEBUG_JTAG_IO("sleep %" PRIi32 "", cmd->cmd.sleep->us);
261 jlink_flush();
262 jtag_sleep(cmd->cmd.sleep->us);
263 }
264
265 static int jlink_execute_command(struct jtag_command *cmd)
266 {
267 switch (cmd->type) {
268 case JTAG_STABLECLOCKS:
269 jlink_execute_stableclocks(cmd);
270 break;
271 case JTAG_RUNTEST:
272 jlink_execute_runtest(cmd);
273 break;
274 case JTAG_TLR_RESET:
275 jlink_execute_statemove(cmd);
276 break;
277 case JTAG_PATHMOVE:
278 jlink_execute_pathmove(cmd);
279 break;
280 case JTAG_SCAN:
281 jlink_execute_scan(cmd);
282 break;
283 case JTAG_RESET:
284 jlink_execute_reset(cmd);
285 break;
286 case JTAG_SLEEP:
287 jlink_execute_sleep(cmd);
288 break;
289 default:
290 LOG_ERROR("BUG: Unknown JTAG command type encountered.");
291 return ERROR_JTAG_QUEUE_FAILED;
292 }
293
294 return ERROR_OK;
295 }
296
297 static int jlink_execute_queue(void)
298 {
299 int ret;
300 struct jtag_command *cmd = jtag_command_queue;
301
302 while (cmd != NULL) {
303 ret = jlink_execute_command(cmd);
304
305 if (ret != ERROR_OK)
306 return ret;
307
308 cmd = cmd->next;
309 }
310
311 return jlink_flush();
312 }
313
314 static int jlink_speed(int speed)
315 {
316 int ret;
317 uint32_t freq;
318 uint16_t divider;
319 int max_speed;
320
321 if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_SPEEDS)) {
322 ret = jaylink_get_speeds(devh, &freq, &divider);
323
324 if (ret != JAYLINK_OK) {
325 LOG_ERROR("jaylink_get_speeds() failed: %s.",
326 jaylink_strerror_name(ret));
327 return ERROR_JTAG_DEVICE_ERROR;
328 }
329
330 freq = freq / 1000;
331 max_speed = freq / divider;
332 } else {
333 max_speed = JLINK_MAX_SPEED;
334 }
335
336 if (!speed) {
337 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_ADAPTIVE_CLOCKING)) {
338 LOG_ERROR("Adaptive clocking is not supported by the device.");
339 return ERROR_JTAG_NOT_IMPLEMENTED;
340 }
341
342 speed = JAYLINK_SPEED_ADAPTIVE_CLOCKING;
343 } else if (speed > max_speed) {
344 LOG_INFO("Reduced speed from %d kHz to %d kHz (maximum).", speed,
345 max_speed);
346 speed = max_speed;
347 }
348
349 ret = jaylink_set_speed(devh, speed);
350
351 if (ret != JAYLINK_OK) {
352 LOG_ERROR("jaylink_set_speed() failed: %s.",
353 jaylink_strerror_name(ret));
354 return ERROR_JTAG_DEVICE_ERROR;
355 }
356
357 return ERROR_OK;
358 }
359
360 static int jlink_speed_div(int speed, int *khz)
361 {
362 *khz = speed;
363
364 return ERROR_OK;
365 }
366
367 static int jlink_khz(int khz, int *jtag_speed)
368 {
369 *jtag_speed = khz;
370
371 return ERROR_OK;
372 }
373
374 static bool read_device_config(struct device_config *cfg)
375 {
376 int ret;
377
378 ret = jaylink_read_raw_config(devh, (uint8_t *)cfg);
379
380 if (ret != JAYLINK_OK) {
381 LOG_ERROR("jaylink_read_raw_config() failed: %s.",
382 jaylink_strerror_name(ret));
383 return false;
384 }
385
386 if (cfg->usb_address == 0xff)
387 cfg->usb_address = 0x00;
388
389 if (cfg->target_power == 0xffffffff)
390 cfg->target_power = 0;
391
392 return true;
393 }
394
395 static int select_interface(void)
396 {
397 int ret;
398 uint32_t interfaces;
399
400 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_SELECT_TIF)) {
401 if (iface != JAYLINK_TIF_JTAG) {
402 LOG_ERROR("Device supports JTAG transport only.");
403 return ERROR_JTAG_INIT_FAILED;
404 }
405
406 return ERROR_OK;
407 }
408
409 ret = jaylink_get_available_interfaces(devh, &interfaces);
410
411 if (ret != JAYLINK_OK) {
412 LOG_ERROR("jaylink_get_available_interfaces() failed: %s.",
413 jaylink_strerror_name(ret));
414 return ERROR_JTAG_INIT_FAILED;
415 }
416
417 if (!(interfaces & (1 << iface))) {
418 LOG_ERROR("Selected transport is not supported by the device.");
419 return ERROR_JTAG_INIT_FAILED;
420 }
421
422 ret = jaylink_select_interface(devh, iface, NULL);
423
424 if (ret < 0) {
425 LOG_ERROR("jaylink_select_interface() failed: %s.",
426 jaylink_strerror_name(ret));
427 return ERROR_JTAG_INIT_FAILED;
428 }
429
430 return ERROR_OK;
431 }
432
433 static int jlink_register(void)
434 {
435 int ret;
436 int i;
437 bool handle_found;
438
439 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_REGISTER))
440 return ERROR_OK;
441
442 ret = jaylink_register(devh, &conn, connlist, NULL, NULL);
443
444 if (ret < 0) {
445 LOG_ERROR("jaylink_register() failed: %s.",
446 jaylink_strerror_name(ret));
447 return ERROR_FAIL;
448 }
449
450 handle_found = false;
451
452 for (i = 0; i < ret; i++) {
453 if (connlist[i].handle == conn.handle) {
454 handle_found = true;
455 break;
456 }
457 }
458
459 if (!handle_found) {
460 LOG_ERROR("Registration failed: maximum number of connections on the "
461 "device reached.");
462 return ERROR_FAIL;
463 }
464
465 return ERROR_OK;
466 }
467
468 /*
469 * Adjust the SWD transaction buffer size depending on the free device internal
470 * memory. This ensures that the SWD transactions sent to the device do not
471 * exceed the internal memory of the device.
472 */
473 static bool adjust_swd_buffer_size(void)
474 {
475 int ret;
476 uint32_t tmp;
477
478 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_FREE_MEMORY))
479 return true;
480
481 ret = jaylink_get_free_memory(devh, &tmp);
482
483 if (ret != JAYLINK_OK) {
484 LOG_ERROR("jaylink_get_free_memory() failed: %s.",
485 jaylink_strerror_name(ret));
486 return false;
487 }
488
489 if (tmp < 143) {
490 LOG_ERROR("Not enough free device internal memory: %u bytes.", tmp);
491 return false;
492 }
493
494 tmp = MIN(JLINK_TAP_BUFFER_SIZE, (tmp - 16) / 2);
495
496 if (tmp != swd_buffer_size) {
497 swd_buffer_size = tmp;
498 LOG_DEBUG("Adjusted SWD transaction buffer size to %u bytes.",
499 swd_buffer_size);
500 }
501
502 return true;
503 }
504
505 static int jlink_init(void)
506 {
507 int ret;
508 struct jaylink_device **devs;
509 unsigned int i;
510 bool found_device;
511 uint32_t tmp;
512 char *firmware_version;
513 struct jaylink_hardware_version hwver;
514 struct jaylink_hardware_status hwstatus;
515 enum jaylink_usb_address address;
516 size_t length;
517
518 ret = jaylink_init(&jayctx);
519
520 if (ret != JAYLINK_OK) {
521 LOG_ERROR("jaylink_init() failed: %s.",
522 jaylink_strerror_name(ret));
523 return ERROR_JTAG_INIT_FAILED;
524 }
525
526 ret = jaylink_get_device_list(jayctx, &devs);
527
528 if (ret < 0) {
529 LOG_ERROR("jaylink_get_device_list() failed: %s.",
530 jaylink_strerror_name(ret));
531 jaylink_exit(jayctx);
532 return ERROR_JTAG_INIT_FAILED;
533 }
534
535 found_device = false;
536
537 if (!use_serial_number && !use_usb_address)
538 LOG_INFO("No device selected, using first device.");
539
540 for (i = 0; devs[i]; i++) {
541 if (use_serial_number) {
542 ret = jaylink_device_get_serial_number(devs[i], &tmp);
543
544 if (ret == JAYLINK_ERR_NOT_AVAILABLE) {
545 continue;
546 } else if (ret != JAYLINK_OK) {
547 LOG_WARNING("jaylink_device_get_serial_number() failed: %s.",
548 jaylink_strerror_name(ret));
549 continue;
550 }
551
552 if (serial_number != tmp)
553 continue;
554 }
555
556 if (use_usb_address) {
557 ret = jaylink_device_get_usb_address(devs[i], &address);
558
559 if (ret != JAYLINK_OK) {
560 LOG_WARNING("jaylink_device_get_usb_address() failed: %s.",
561 jaylink_strerror_name(ret));
562 continue;
563 }
564
565 if (usb_address != address)
566 continue;
567 }
568
569 ret = jaylink_open(devs[i], &devh);
570
571 if (ret == JAYLINK_OK) {
572 found_device = true;
573 break;
574 }
575
576 LOG_ERROR("Failed to open device: %s.", jaylink_strerror_name(ret));
577 }
578
579 jaylink_free_device_list(devs, 1);
580
581 if (!found_device) {
582 LOG_ERROR("No J-Link device found.");
583 jaylink_exit(jayctx);
584 return ERROR_JTAG_INIT_FAILED;
585 }
586
587 /*
588 * Be careful with changing the following initialization sequence because
589 * some devices are known to be sensitive regarding the order.
590 */
591
592 ret = jaylink_get_firmware_version(devh, &firmware_version, &length);
593
594 if (ret != JAYLINK_OK) {
595 LOG_ERROR("jaylink_get_firmware_version() failed: %s.",
596 jaylink_strerror_name(ret));
597 jaylink_close(devh);
598 jaylink_exit(jayctx);
599 return ERROR_JTAG_INIT_FAILED;
600 } else if (length > 0) {
601 LOG_INFO("%s", firmware_version);
602 free(firmware_version);
603 } else {
604 LOG_WARNING("Device responds empty firmware version string.");
605 }
606
607 memset(caps, 0, JAYLINK_DEV_EXT_CAPS_SIZE);
608 ret = jaylink_get_caps(devh, caps);
609
610 if (ret != JAYLINK_OK) {
611 LOG_ERROR("jaylink_get_caps() failed: %s.", jaylink_strerror_name(ret));
612 jaylink_close(devh);
613 jaylink_exit(jayctx);
614 return ERROR_JTAG_INIT_FAILED;
615 }
616
617 if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_EXT_CAPS)) {
618 ret = jaylink_get_extended_caps(devh, caps);
619
620 if (ret != JAYLINK_OK) {
621 LOG_ERROR("jaylink_get_extended_caps() failed: %s.",
622 jaylink_strerror_name(ret));
623 jaylink_close(devh);
624 jaylink_exit(jayctx);
625 return ERROR_JTAG_INIT_FAILED;
626 }
627 }
628
629 jtag_command_version = JAYLINK_JTAG_V2;
630
631 if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_HW_VERSION)) {
632 ret = jaylink_get_hardware_version(devh, &hwver);
633
634 if (ret != JAYLINK_OK) {
635 LOG_ERROR("Failed to retrieve hardware version: %s.",
636 jaylink_strerror_name(ret));
637 jaylink_close(devh);
638 jaylink_exit(jayctx);
639 return ERROR_JTAG_INIT_FAILED;
640 }
641
642 LOG_INFO("Hardware version: %u.%02u", hwver.major, hwver.minor);
643
644 if (hwver.major >= 5)
645 jtag_command_version = JAYLINK_JTAG_V3;
646 }
647
648 if (iface == JAYLINK_TIF_SWD) {
649 /*
650 * Adjust the SWD transaction buffer size in case there is already
651 * allocated memory on the device. This happens for example if the
652 * memory for SWO capturing is still allocated because the software
653 * which used the device before has not been shut down properly.
654 */
655 if (!adjust_swd_buffer_size()) {
656 jaylink_close(devh);
657 jaylink_exit(jayctx);
658 return ERROR_JTAG_INIT_FAILED;
659 }
660 }
661
662 if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
663 if (!read_device_config(&config)) {
664 LOG_ERROR("Failed to read device configuration data.");
665 jaylink_close(devh);
666 jaylink_exit(jayctx);
667 return ERROR_JTAG_INIT_FAILED;
668 }
669
670 memcpy(&tmp_config, &config, sizeof(struct device_config));
671 }
672
673 ret = jaylink_get_hardware_status(devh, &hwstatus);
674
675 if (ret != JAYLINK_OK) {
676 LOG_ERROR("jaylink_get_hardware_status() failed: %s.",
677 jaylink_strerror_name(ret));
678 jaylink_close(devh);
679 jaylink_exit(jayctx);
680 return ERROR_JTAG_INIT_FAILED;
681 }
682
683 LOG_INFO("VTarget = %u.%03u V", hwstatus.target_voltage / 1000,
684 hwstatus.target_voltage % 1000);
685
686 conn.handle = 0;
687 conn.pid = 0;
688 conn.hid = 0;
689 conn.iid = 0;
690 conn.cid = 0;
691
692 ret = jlink_register();
693
694 if (ret != ERROR_OK) {
695 jaylink_close(devh);
696 jaylink_exit(jayctx);
697 return ERROR_JTAG_INIT_FAILED;
698 }
699
700 ret = select_interface();
701
702 if (ret != ERROR_OK) {
703 jaylink_close(devh);
704 jaylink_exit(jayctx);
705 return ret;
706 }
707
708 jlink_reset(0, 0);
709 jtag_sleep(3000);
710 jlink_tap_init();
711
712 jlink_speed(jtag_get_speed_khz());
713
714 if (iface == JAYLINK_TIF_JTAG) {
715 /*
716 * J-Link devices with firmware version v5 and v6 seems to have an issue
717 * if the first tap move is not divisible by 8, so we send a TLR on
718 * first power up.
719 */
720 uint8_t tms = 0xff;
721 jlink_clock_data(NULL, 0, &tms, 0, NULL, 0, 8);
722
723 jlink_flush();
724 }
725
726 return ERROR_OK;
727 }
728
729 static int jlink_quit(void)
730 {
731 int ret;
732
733 if (trace_enabled) {
734 ret = jaylink_swo_stop(devh);
735
736 if (ret != JAYLINK_OK)
737 LOG_ERROR("jaylink_swo_stop() failed: %s.",
738 jaylink_strerror_name(ret));
739 }
740
741 if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_REGISTER)) {
742 ret = jaylink_unregister(devh, &conn, connlist, NULL, NULL);
743
744 if (ret < 0)
745 LOG_ERROR("jaylink_unregister() failed: %s.",
746 jaylink_strerror_name(ret));
747 }
748
749 jaylink_close(devh);
750 jaylink_exit(jayctx);
751
752 return ERROR_OK;
753 }
754
755 /***************************************************************************/
756 /* Queue command implementations */
757
758 static void jlink_end_state(tap_state_t state)
759 {
760 if (tap_is_state_stable(state))
761 tap_set_end_state(state);
762 else {
763 LOG_ERROR("BUG: %i is not a valid end state", state);
764 exit(-1);
765 }
766 }
767
768 /* Goes to the end state. */
769 static void jlink_state_move(void)
770 {
771 uint8_t tms_scan;
772 uint8_t tms_scan_bits;
773
774 tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
775 tms_scan_bits = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
776
777 jlink_clock_data(NULL, 0, &tms_scan, 0, NULL, 0, tms_scan_bits);
778
779 tap_set_state(tap_get_end_state());
780 }
781
782 static void jlink_path_move(int num_states, tap_state_t *path)
783 {
784 int i;
785 uint8_t tms = 0xff;
786
787 for (i = 0; i < num_states; i++) {
788 if (path[i] == tap_state_transition(tap_get_state(), false))
789 jlink_clock_data(NULL, 0, NULL, 0, NULL, 0, 1);
790 else if (path[i] == tap_state_transition(tap_get_state(), true))
791 jlink_clock_data(NULL, 0, &tms, 0, NULL, 0, 1);
792 else {
793 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition.",
794 tap_state_name(tap_get_state()), tap_state_name(path[i]));
795 exit(-1);
796 }
797
798 tap_set_state(path[i]);
799 }
800
801 tap_set_end_state(tap_get_state());
802 }
803
804 static void jlink_stableclocks(int num_cycles)
805 {
806 int i;
807
808 uint8_t tms = tap_get_state() == TAP_RESET;
809 /* Execute num_cycles. */
810 for (i = 0; i < num_cycles; i++)
811 jlink_clock_data(NULL, 0, &tms, 0, NULL, 0, 1);
812 }
813
814 static void jlink_runtest(int num_cycles)
815 {
816 tap_state_t saved_end_state = tap_get_end_state();
817
818 /* Only do a state_move when we're not already in IDLE. */
819 if (tap_get_state() != TAP_IDLE) {
820 jlink_end_state(TAP_IDLE);
821 jlink_state_move();
822 /* num_cycles--; */
823 }
824
825 jlink_stableclocks(num_cycles);
826
827 /* Finish in end_state. */
828 jlink_end_state(saved_end_state);
829
830 if (tap_get_state() != tap_get_end_state())
831 jlink_state_move();
832 }
833
834 static void jlink_reset(int trst, int srst)
835 {
836 LOG_DEBUG("TRST: %i, SRST: %i.", trst, srst);
837
838 /* Signals are active low. */
839 if (srst == 0)
840 jaylink_set_reset(devh);
841
842 if (srst == 1)
843 jaylink_clear_reset(devh);
844
845 if (trst == 1)
846 jaylink_jtag_clear_trst(devh);
847
848 if (trst == 0)
849 jaylink_jtag_set_trst(devh);
850 }
851
852 COMMAND_HANDLER(jlink_usb_command)
853 {
854 int tmp;
855
856 if (CMD_ARGC != 1) {
857 command_print(CMD_CTX, "Need exactly one argument for jlink usb.");
858 return ERROR_COMMAND_SYNTAX_ERROR;
859 }
860
861 if (sscanf(CMD_ARGV[0], "%i", &tmp) != 1) {
862 command_print(CMD_CTX, "Invalid USB address: %s.", CMD_ARGV[0]);
863 return ERROR_FAIL;
864 }
865
866 if (tmp < JAYLINK_USB_ADDRESS_0 || tmp > JAYLINK_USB_ADDRESS_3) {
867 command_print(CMD_CTX, "Invalid USB address: %s.", CMD_ARGV[0]);
868 return ERROR_FAIL;
869 }
870
871 usb_address = tmp;
872
873 use_serial_number = false;
874 use_usb_address = true;
875
876 return ERROR_OK;
877 }
878
879 COMMAND_HANDLER(jlink_serial_command)
880 {
881 if (CMD_ARGC != 1) {
882 command_print(CMD_CTX, "Need exactly one argument for jlink serial.");
883 return ERROR_COMMAND_SYNTAX_ERROR;
884 }
885
886 if (sscanf(CMD_ARGV[0], "%" SCNd32, &serial_number) != 1) {
887 command_print(CMD_CTX, "Invalid serial number: %s.", CMD_ARGV[0]);
888 return ERROR_FAIL;
889 }
890
891 use_serial_number = true;
892 use_usb_address = false;
893
894 return ERROR_OK;
895 }
896
897 COMMAND_HANDLER(jlink_handle_hwstatus_command)
898 {
899 int ret;
900 struct jaylink_hardware_status status;
901
902 ret = jaylink_get_hardware_status(devh, &status);
903
904 if (ret != JAYLINK_OK) {
905 command_print(CMD_CTX, "jaylink_get_hardware_status() failed: %s.",
906 jaylink_strerror_name(ret));
907 return ERROR_FAIL;
908 }
909
910 command_print(CMD_CTX, "VTarget = %u.%03u V",
911 status.target_voltage / 1000, status.target_voltage % 1000);
912
913 command_print(CMD_CTX, "TCK = %u TDI = %u TDO = %u TMS = %u SRST = %u "
914 "TRST = %u", status.tck, status.tdi, status.tdo, status.tms,
915 status.tres, status.trst);
916
917 if (status.target_voltage < 1500)
918 command_print(CMD_CTX, "Target voltage too low. Check target power.");
919
920 return ERROR_OK;
921 }
922
923 COMMAND_HANDLER(jlink_handle_free_memory_command)
924 {
925 int ret;
926 uint32_t tmp;
927
928 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_FREE_MEMORY)) {
929 command_print(CMD_CTX, "Retrieval of free memory is not supported by "
930 "the device.");
931 return ERROR_OK;
932 }
933
934 ret = jaylink_get_free_memory(devh, &tmp);
935
936 if (ret != JAYLINK_OK) {
937 command_print(CMD_CTX, "jaylink_get_free_memory() failed: %s.",
938 jaylink_strerror_name(ret));
939 return ERROR_FAIL;
940 }
941
942 command_print(CMD_CTX, "Device has %u bytes of free memory.", tmp);
943
944 return ERROR_OK;
945 }
946
947 COMMAND_HANDLER(jlink_handle_jlink_jtag_command)
948 {
949 int tmp;
950 int version;
951
952 if (!CMD_ARGC) {
953 switch (jtag_command_version) {
954 case JAYLINK_JTAG_V2:
955 version = 2;
956 break;
957 case JAYLINK_JTAG_V3:
958 version = 3;
959 break;
960 default:
961 return ERROR_FAIL;
962 }
963
964 command_print(CMD_CTX, "JTAG command version: %i", version);
965 } else if (CMD_ARGC == 1) {
966 if (sscanf(CMD_ARGV[0], "%i", &tmp) != 1) {
967 command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]);
968 return ERROR_COMMAND_SYNTAX_ERROR;
969 }
970
971 switch (tmp) {
972 case 2:
973 jtag_command_version = JAYLINK_JTAG_V2;
974 break;
975 case 3:
976 jtag_command_version = JAYLINK_JTAG_V3;
977 break;
978 default:
979 command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]);
980 return ERROR_COMMAND_SYNTAX_ERROR;
981 }
982 } else {
983 command_print(CMD_CTX, "Need exactly one argument for jlink jtag.");
984 return ERROR_COMMAND_SYNTAX_ERROR;
985 }
986
987 return ERROR_OK;
988 }
989
990 COMMAND_HANDLER(jlink_handle_target_power_command)
991 {
992 int ret;
993 int enable;
994
995 if (CMD_ARGC != 1) {
996 command_print(CMD_CTX, "Need exactly one argument for jlink "
997 "targetpower.");
998 return ERROR_COMMAND_SYNTAX_ERROR;
999 }
1000
1001 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_SET_TARGET_POWER)) {
1002 command_print(CMD_CTX, "Target power supply is not supported by the "
1003 "device.");
1004 return ERROR_OK;
1005 }
1006
1007 if (!strcmp(CMD_ARGV[0], "on")) {
1008 enable = true;
1009 } else if (!strcmp(CMD_ARGV[0], "off")) {
1010 enable = false;
1011 } else {
1012 command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]);
1013 return ERROR_FAIL;
1014 }
1015
1016 ret = jaylink_set_target_power(devh, enable);
1017
1018 if (ret != JAYLINK_OK) {
1019 command_print(CMD_CTX, "jaylink_set_target_power() failed: %s.",
1020 jaylink_strerror_name(ret));
1021 return ERROR_FAIL;
1022 }
1023
1024 return ERROR_OK;
1025 }
1026
1027 static void show_config_usb_address(struct command_context *ctx)
1028 {
1029 if (config.usb_address != tmp_config.usb_address)
1030 command_print(ctx, "USB address: %u [%u]", config.usb_address,
1031 tmp_config.usb_address);
1032 else
1033 command_print(ctx, "USB address: %u", config.usb_address);
1034 }
1035
1036 static void show_config_ip_address(struct command_context *ctx)
1037 {
1038 if (!memcmp(config.ip_address, tmp_config.ip_address, 4))
1039 command_print(ctx, "IP address: %d.%d.%d.%d",
1040 config.ip_address[3], config.ip_address[2],
1041 config.ip_address[1], config.ip_address[0]);
1042 else
1043 command_print(ctx, "IP address: %d.%d.%d.%d [%d.%d.%d.%d]",
1044 config.ip_address[3], config.ip_address[2],
1045 config.ip_address[1], config.ip_address[0],
1046 tmp_config.ip_address[3], tmp_config.ip_address[2],
1047 tmp_config.ip_address[1], tmp_config.ip_address[0]);
1048
1049 if (!memcmp(config.subnet_mask, tmp_config.subnet_mask, 4))
1050 command_print(ctx, "Subnet mask: %d.%d.%d.%d",
1051 config.subnet_mask[3], config.subnet_mask[2],
1052 config.subnet_mask[1], config.subnet_mask[0]);
1053 else
1054 command_print(ctx, "Subnet mask: %d.%d.%d.%d [%d.%d.%d.%d]",
1055 config.subnet_mask[3], config.subnet_mask[2],
1056 config.subnet_mask[1], config.subnet_mask[0],
1057 tmp_config.subnet_mask[3], tmp_config.subnet_mask[2],
1058 tmp_config.subnet_mask[1], tmp_config.subnet_mask[0]);
1059 }
1060
1061 static void show_config_mac_address(struct command_context *ctx)
1062 {
1063 if (!memcmp(config.mac_address, tmp_config.mac_address, 6))
1064 command_print(ctx, "MAC address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x",
1065 config.mac_address[5], config.mac_address[4],
1066 config.mac_address[3], config.mac_address[2],
1067 config.mac_address[1], config.mac_address[0]);
1068 else
1069 command_print(ctx, "MAC address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x "
1070 "[%.02x:%.02x:%.02x:%.02x:%.02x:%.02x]",
1071 config.mac_address[5], config.mac_address[4],
1072 config.mac_address[3], config.mac_address[2],
1073 config.mac_address[1], config.mac_address[0],
1074 tmp_config.mac_address[5], tmp_config.mac_address[4],
1075 tmp_config.mac_address[3], tmp_config.mac_address[2],
1076 tmp_config.mac_address[1], tmp_config.mac_address[0]);
1077 }
1078
1079 static void show_config_target_power(struct command_context *ctx)
1080 {
1081 const char *target_power;
1082 const char *current_target_power;
1083
1084 if (!config.target_power)
1085 target_power = "off";
1086 else
1087 target_power = "on";
1088
1089 if (!tmp_config.target_power)
1090 current_target_power = "off";
1091 else
1092 current_target_power = "on";
1093
1094 if (config.target_power != tmp_config.target_power)
1095 command_print(ctx, "Target power supply: %s [%s]", target_power,
1096 current_target_power);
1097 else
1098 command_print(ctx, "Target power supply: %s", target_power);
1099 }
1100
1101 static void show_config(struct command_context *ctx)
1102 {
1103 command_print(ctx, "J-Link device configuration:");
1104
1105 show_config_usb_address(ctx);
1106
1107 if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_SET_TARGET_POWER))
1108 show_config_target_power(ctx);
1109
1110 if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_ETHERNET)) {
1111 show_config_ip_address(ctx);
1112 show_config_mac_address(ctx);
1113 }
1114 }
1115
1116 static int poll_trace(uint8_t *buf, size_t *size)
1117 {
1118 int ret;
1119 uint32_t length;
1120
1121 length = *size;
1122
1123 ret = jaylink_swo_read(devh, buf, &length);
1124
1125 if (ret != JAYLINK_OK) {
1126 LOG_ERROR("jaylink_swo_read() failed: %s.", jaylink_strerror_name(ret));
1127 return ERROR_FAIL;
1128 }
1129
1130 *size = length;
1131
1132 return ERROR_OK;
1133 }
1134
1135 static uint32_t calculate_trace_buffer_size(void)
1136 {
1137 int ret;
1138 uint32_t tmp;
1139
1140 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_FREE_MEMORY))
1141 return 0;
1142
1143 ret = jaylink_get_free_memory(devh, &tmp);
1144
1145 if (ret != JAYLINK_OK) {
1146 LOG_ERROR("jaylink_get_free_memory() failed: %s.",
1147 jaylink_strerror_name(ret));
1148 return ERROR_FAIL;
1149 }
1150
1151 if (tmp > 0x3fff || tmp <= 0x600)
1152 tmp = tmp >> 1;
1153 else
1154 tmp = tmp - 0x400;
1155
1156 return tmp & 0xffffff00;
1157 }
1158
1159 static bool check_trace_freq(struct jaylink_swo_speed speed,
1160 uint32_t trace_freq)
1161 {
1162 double min;
1163 double deviation;
1164 uint32_t divider;
1165
1166 min = fabs(1.0 - (speed.freq / ((double)trace_freq * speed.min_div)));
1167
1168 for (divider = speed.min_div; divider < speed.max_div; divider++) {
1169 deviation = fabs(1.0 - (speed.freq / ((double)trace_freq * divider)));
1170
1171 if (deviation < 0.03) {
1172 LOG_DEBUG("Found suitable frequency divider %u with deviation of "
1173 "%.02f %%.", divider, deviation);
1174 return true;
1175 }
1176
1177 if (deviation < min)
1178 min = deviation;
1179 }
1180
1181 LOG_ERROR("Selected trace frequency is not supported by the device. "
1182 "Please choose a different trace frequency.");
1183 LOG_ERROR("Maximum permitted deviation is 3.00 %%, but only %.02f %% "
1184 "could be achieved.", min * 100);
1185
1186 return false;
1187 }
1188
1189 static int config_trace(bool enabled, enum tpio_pin_protocol pin_protocol,
1190 uint32_t port_size, unsigned int *trace_freq)
1191 {
1192 int ret;
1193 uint32_t buffer_size;
1194 struct jaylink_swo_speed speed;
1195
1196 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_SWO)) {
1197 LOG_ERROR("Trace capturing is not supported by the device.");
1198 return ERROR_FAIL;
1199 }
1200
1201 if (pin_protocol != ASYNC_UART) {
1202 LOG_ERROR("Selected pin protocol is not supported.");
1203 return ERROR_FAIL;
1204 }
1205
1206 trace_enabled = enabled;
1207
1208 ret = jaylink_swo_stop(devh);
1209
1210 if (ret != JAYLINK_OK) {
1211 LOG_ERROR("jaylink_swo_stop() failed: %s.", jaylink_strerror_name(ret));
1212 return ERROR_FAIL;
1213 }
1214
1215 if (!enabled) {
1216 /*
1217 * Adjust the SWD transaction buffer size as stopping SWO capturing
1218 * deallocates device internal memory.
1219 */
1220 if (!adjust_swd_buffer_size())
1221 return ERROR_FAIL;
1222
1223 return ERROR_OK;
1224 }
1225
1226 buffer_size = calculate_trace_buffer_size();
1227
1228 if (!buffer_size) {
1229 LOG_ERROR("Not enough free device memory to start trace capturing.");
1230 return ERROR_FAIL;
1231 }
1232
1233 ret = jaylink_swo_get_speeds(devh, JAYLINK_SWO_MODE_UART, &speed);
1234
1235 if (ret != JAYLINK_OK) {
1236 LOG_ERROR("jaylink_swo_get_speeds() failed: %s.",
1237 jaylink_strerror_name(ret));
1238 return ERROR_FAIL;
1239 }
1240
1241 if (!*trace_freq)
1242 *trace_freq = speed.freq / speed.min_div;
1243
1244 if (!check_trace_freq(speed, *trace_freq))
1245 return ERROR_FAIL;
1246
1247 LOG_DEBUG("Using %u bytes device memory for trace capturing.", buffer_size);
1248
1249 ret = jaylink_swo_start(devh, JAYLINK_SWO_MODE_UART, *trace_freq,
1250 buffer_size);
1251
1252 if (ret != JAYLINK_OK) {
1253 LOG_ERROR("jaylink_start_swo() failed: %s.",
1254 jaylink_strerror_name(ret));
1255 return ERROR_FAIL;
1256 }
1257
1258 /*
1259 * Adjust the SWD transaction buffer size as starting SWO capturing
1260 * allocates device internal memory.
1261 */
1262 if (!adjust_swd_buffer_size())
1263 return ERROR_FAIL;
1264
1265 return ERROR_OK;
1266 }
1267
1268 COMMAND_HANDLER(jlink_handle_config_usb_address_command)
1269 {
1270 uint8_t tmp;
1271
1272 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1273 command_print(CMD_CTX, "Reading configuration is not supported by the "
1274 "device.");
1275 return ERROR_OK;
1276 }
1277
1278 if (!CMD_ARGC) {
1279 show_config_usb_address(CMD_CTX);
1280 } else if (CMD_ARGC == 1) {
1281 if (sscanf(CMD_ARGV[0], "%" SCNd8, &tmp) != 1) {
1282 command_print(CMD_CTX, "Invalid USB address: %s.", CMD_ARGV[0]);
1283 return ERROR_FAIL;
1284 }
1285
1286 if (tmp > JAYLINK_USB_ADDRESS_3) {
1287 command_print(CMD_CTX, "Invalid USB address: %u.", tmp);
1288 return ERROR_FAIL;
1289 }
1290
1291 tmp_config.usb_address = tmp;
1292 } else {
1293 command_print(CMD_CTX, "Need exactly one argument for jlink config "
1294 "usb.");
1295 return ERROR_COMMAND_SYNTAX_ERROR;
1296 }
1297
1298 return ERROR_OK;
1299 }
1300
1301 COMMAND_HANDLER(jlink_handle_config_target_power_command)
1302 {
1303 int enable;
1304
1305 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1306 command_print(CMD_CTX, "Reading configuration is not supported by the "
1307 "device.");
1308 return ERROR_OK;
1309 }
1310
1311 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_SET_TARGET_POWER)) {
1312 command_print(CMD_CTX, "Target power supply is not supported by the "
1313 "device.");
1314 return ERROR_OK;
1315 }
1316
1317 if (!CMD_ARGC) {
1318 show_config_target_power(CMD_CTX);
1319 } else if (CMD_ARGC == 1) {
1320 if (!strcmp(CMD_ARGV[0], "on")) {
1321 enable = true;
1322 } else if (!strcmp(CMD_ARGV[0], "off")) {
1323 enable = false;
1324 } else {
1325 command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]);
1326 return ERROR_FAIL;
1327 }
1328
1329 tmp_config.target_power = enable;
1330 } else {
1331 command_print(CMD_CTX, "Need exactly one argument for jlink config "
1332 "targetpower.");
1333 return ERROR_COMMAND_SYNTAX_ERROR;
1334 }
1335
1336 return ERROR_OK;
1337 }
1338
1339 COMMAND_HANDLER(jlink_handle_config_mac_address_command)
1340 {
1341 uint8_t addr[6];
1342 int i;
1343 char *e;
1344 const char *str;
1345
1346 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1347 command_print(CMD_CTX, "Reading configuration is not supported by the "
1348 "device.");
1349 return ERROR_OK;
1350 }
1351
1352 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_ETHERNET)) {
1353 command_print(CMD_CTX, "Ethernet connectivity is not supported by the "
1354 "device.");
1355 return ERROR_OK;
1356 }
1357
1358 if (!CMD_ARGC) {
1359 show_config_mac_address(CMD_CTX);
1360 } else if (CMD_ARGC == 1) {
1361 str = CMD_ARGV[0];
1362
1363 if ((strlen(str) != 17) || (str[2] != ':' || str[5] != ':' || \
1364 str[8] != ':' || str[11] != ':' || str[14] != ':')) {
1365 command_print(CMD_CTX, "Invalid MAC address format.");
1366 return ERROR_COMMAND_SYNTAX_ERROR;
1367 }
1368
1369 for (i = 5; i >= 0; i--) {
1370 addr[i] = strtoul(str, &e, 16);
1371 str = e + 1;
1372 }
1373
1374 if (!(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5])) {
1375 command_print(CMD_CTX, "Invalid MAC address: zero address.");
1376 return ERROR_COMMAND_SYNTAX_ERROR;
1377 }
1378
1379 if (!(0x01 & addr[0])) {
1380 command_print(CMD_CTX, "Invalid MAC address: multicast address.");
1381 return ERROR_COMMAND_SYNTAX_ERROR;
1382 }
1383
1384 memcpy(tmp_config.mac_address, addr, sizeof(addr));
1385 } else {
1386 command_print(CMD_CTX, "Need exactly one argument for jlink config "
1387 " mac.");
1388 return ERROR_COMMAND_SYNTAX_ERROR;
1389 }
1390
1391 return ERROR_OK;
1392 }
1393
1394 static bool string_to_ip(const char *s, uint8_t *ip, int *pos)
1395 {
1396 uint8_t lip[4];
1397 char *e;
1398 const char *s_save = s;
1399 int i;
1400
1401 if (!s)
1402 return false;
1403
1404 for (i = 0; i < 4; i++) {
1405 lip[i] = strtoul(s, &e, 10);
1406
1407 if (*e != '.' && i != 3)
1408 return false;
1409
1410 s = e + 1;
1411 }
1412
1413 *pos = e - s_save;
1414 memcpy(ip, lip, sizeof(lip));
1415
1416 return true;
1417 }
1418
1419 static void cpy_ip(uint8_t *dst, uint8_t *src)
1420 {
1421 int i, j;
1422
1423 for (i = 0, j = 3; i < 4; i++, j--)
1424 dst[i] = src[j];
1425 }
1426
1427 COMMAND_HANDLER(jlink_handle_config_ip_address_command)
1428 {
1429 uint8_t ip_address[4];
1430 uint32_t subnet_mask = 0;
1431 int i, len;
1432 uint8_t subnet_bits = 24;
1433
1434 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1435 command_print(CMD_CTX, "Reading configuration is not supported by the "
1436 "device.");
1437 return ERROR_OK;
1438 }
1439
1440 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_ETHERNET)) {
1441 command_print(CMD_CTX, "Ethernet connectivity is not supported by the "
1442 "device.");
1443 return ERROR_OK;
1444 }
1445
1446 if (!CMD_ARGC) {
1447 show_config_ip_address(CMD_CTX);
1448 } else {
1449 if (!string_to_ip(CMD_ARGV[0], ip_address, &i))
1450 return ERROR_COMMAND_SYNTAX_ERROR;
1451
1452 len = strlen(CMD_ARGV[0]);
1453
1454 /* Check for format A.B.C.D/E. */
1455 if (i < len) {
1456 if (CMD_ARGV[0][i] != '/')
1457 return ERROR_COMMAND_SYNTAX_ERROR;
1458
1459 COMMAND_PARSE_NUMBER(u8, CMD_ARGV[0] + i + 1, subnet_bits);
1460 } else if (CMD_ARGC > 1) {
1461 if (!string_to_ip(CMD_ARGV[1], (uint8_t *)&subnet_mask, &i))
1462 return ERROR_COMMAND_SYNTAX_ERROR;
1463 }
1464
1465 if (!subnet_mask)
1466 subnet_mask = (uint32_t)(subnet_bits < 32 ?
1467 ((1ULL << subnet_bits) - 1) : 0xffffffff);
1468
1469 cpy_ip(tmp_config.ip_address, ip_address);
1470 cpy_ip(tmp_config.subnet_mask, (uint8_t *)&subnet_mask);
1471 }
1472
1473 return ERROR_OK;
1474 }
1475
1476 COMMAND_HANDLER(jlink_handle_config_reset_command)
1477 {
1478 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG))
1479 return ERROR_OK;
1480
1481 memcpy(&tmp_config, &config, sizeof(struct device_config));
1482
1483 return ERROR_OK;
1484 }
1485
1486
1487 COMMAND_HANDLER(jlink_handle_config_write_command)
1488 {
1489 int ret;
1490
1491 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1492 command_print(CMD_CTX, "Reading configuration is not supported by the "
1493 "device.");
1494 return ERROR_OK;
1495 }
1496
1497 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_WRITE_CONFIG)) {
1498 command_print(CMD_CTX, "Writing configuration is not supported by the "
1499 "device.");
1500 return ERROR_OK;
1501 }
1502
1503 if (!memcmp(&config, &tmp_config, sizeof(struct device_config))) {
1504 command_print(CMD_CTX, "Operation not performed due to no changes in "
1505 "the configuration.");
1506 return ERROR_OK;
1507 }
1508
1509 ret = jaylink_write_raw_config(devh, (const uint8_t *)&tmp_config);
1510
1511 if (ret != JAYLINK_OK) {
1512 LOG_ERROR("jaylink_write_raw_config() failed: %s.",
1513 jaylink_strerror_name(ret));
1514 return ERROR_FAIL;
1515 }
1516
1517 if (!read_device_config(&config)) {
1518 LOG_ERROR("Failed to read device configuration for verification.");
1519 return ERROR_FAIL;
1520 }
1521
1522 if (memcmp(&config, &tmp_config, sizeof(struct device_config))) {
1523 LOG_ERROR("Verification of device configuration failed. Please check "
1524 "your device.");
1525 return ERROR_FAIL;
1526 }
1527
1528 memcpy(&tmp_config, &config, sizeof(struct device_config));
1529 command_print(CMD_CTX, "The new device configuration applies after power "
1530 "cycling the J-Link device.");
1531
1532 return ERROR_OK;
1533 }
1534
1535 COMMAND_HANDLER(jlink_handle_config_command)
1536 {
1537 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1538 command_print(CMD_CTX, "Device doesn't support reading configuration.");
1539 return ERROR_OK;
1540 }
1541
1542 if (CMD_ARGC == 0)
1543 show_config(CMD_CTX);
1544
1545 return ERROR_OK;
1546 }
1547
1548 static const struct command_registration jlink_config_subcommand_handlers[] = {
1549 {
1550 .name = "usb",
1551 .handler = &jlink_handle_config_usb_address_command,
1552 .mode = COMMAND_EXEC,
1553 .help = "set the USB address",
1554 .usage = "[0-3]",
1555 },
1556 {
1557 .name = "targetpower",
1558 .handler = &jlink_handle_config_target_power_command,
1559 .mode = COMMAND_EXEC,
1560 .help = "set the target power supply",
1561 .usage = "[on|off]"
1562 },
1563 {
1564 .name = "mac",
1565 .handler = &jlink_handle_config_mac_address_command,
1566 .mode = COMMAND_EXEC,
1567 .help = "set the MAC Address",
1568 .usage = "[ff:ff:ff:ff:ff:ff]",
1569 },
1570 {
1571 .name = "ip",
1572 .handler = &jlink_handle_config_ip_address_command,
1573 .mode = COMMAND_EXEC,
1574 .help = "set the IP address, where A.B.C.D is the IP address, "
1575 "E the bit of the subnet mask, F.G.H.I the subnet mask",
1576 .usage = "[A.B.C.D[/E] [F.G.H.I]]",
1577 },
1578 {
1579 .name = "reset",
1580 .handler = &jlink_handle_config_reset_command,
1581 .mode = COMMAND_EXEC,
1582 .help = "undo configuration changes"
1583 },
1584 {
1585 .name = "write",
1586 .handler = &jlink_handle_config_write_command,
1587 .mode = COMMAND_EXEC,
1588 .help = "write configuration to the device"
1589 },
1590 COMMAND_REGISTRATION_DONE
1591 };
1592
1593 static const struct command_registration jlink_subcommand_handlers[] = {
1594 {
1595 .name = "jtag",
1596 .handler = &jlink_handle_jlink_jtag_command,
1597 .mode = COMMAND_EXEC,
1598 .help = "select the JTAG command version",
1599 .usage = "[2|3]",
1600 },
1601 {
1602 .name = "targetpower",
1603 .handler = &jlink_handle_target_power_command,
1604 .mode = COMMAND_EXEC,
1605 .help = "set the target power supply",
1606 .usage = "<on|off>"
1607 },
1608 {
1609 .name = "freemem",
1610 .handler = &jlink_handle_free_memory_command,
1611 .mode = COMMAND_EXEC,
1612 .help = "show free device memory"
1613 },
1614 {
1615 .name = "hwstatus",
1616 .handler = &jlink_handle_hwstatus_command,
1617 .mode = COMMAND_EXEC,
1618 .help = "show the hardware status"
1619 },
1620 {
1621 .name = "usb",
1622 .handler = &jlink_usb_command,
1623 .mode = COMMAND_CONFIG,
1624 .help = "set the USB address of the device that should be used",
1625 .usage = "<0-3>"
1626 },
1627 {
1628 .name = "serial",
1629 .handler = &jlink_serial_command,
1630 .mode = COMMAND_CONFIG,
1631 .help = "set the serial number of the device that should be used",
1632 .usage = "<serial number>"
1633 },
1634 {
1635 .name = "config",
1636 .handler = &jlink_handle_config_command,
1637 .mode = COMMAND_EXEC,
1638 .help = "access the device configuration. If no argument is given "
1639 "this will show the device configuration",
1640 .chain = jlink_config_subcommand_handlers,
1641 },
1642 COMMAND_REGISTRATION_DONE
1643 };
1644
1645 static const struct command_registration jlink_command_handlers[] = {
1646 {
1647 .name = "jlink",
1648 .mode = COMMAND_ANY,
1649 .help = "perform jlink management",
1650 .chain = jlink_subcommand_handlers,
1651 },
1652 COMMAND_REGISTRATION_DONE
1653 };
1654
1655 static int jlink_swd_init(void)
1656 {
1657 iface = JAYLINK_TIF_SWD;
1658
1659 return ERROR_OK;
1660 }
1661
1662 static void jlink_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
1663 {
1664 assert(!(cmd & SWD_CMD_RnW));
1665 jlink_swd_queue_cmd(cmd, NULL, value, ap_delay_clk);
1666 }
1667
1668 static void jlink_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
1669 {
1670 assert(cmd & SWD_CMD_RnW);
1671 jlink_swd_queue_cmd(cmd, value, 0, ap_delay_clk);
1672 }
1673
1674 static int_least32_t jlink_swd_frequency(int_least32_t hz)
1675 {
1676 if (hz > 0)
1677 jlink_speed(hz / 1000);
1678
1679 return hz;
1680 }
1681
1682 /***************************************************************************/
1683 /* J-Link tap functions */
1684
1685 static unsigned tap_length;
1686 /* In SWD mode use tms buffer for direction control */
1687 static uint8_t tms_buffer[JLINK_TAP_BUFFER_SIZE];
1688 static uint8_t tdi_buffer[JLINK_TAP_BUFFER_SIZE];
1689 static uint8_t tdo_buffer[JLINK_TAP_BUFFER_SIZE];
1690
1691 struct pending_scan_result {
1692 /** First bit position in tdo_buffer to read. */
1693 unsigned first;
1694 /** Number of bits to read. */
1695 unsigned length;
1696 /** Location to store the result */
1697 void *buffer;
1698 /** Offset in the destination buffer */
1699 unsigned buffer_offset;
1700 };
1701
1702 #define MAX_PENDING_SCAN_RESULTS 256
1703
1704 static int pending_scan_results_length;
1705 static struct pending_scan_result pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS];
1706
1707 static void jlink_tap_init(void)
1708 {
1709 tap_length = 0;
1710 pending_scan_results_length = 0;
1711 memset(tms_buffer, 0, sizeof(tms_buffer));
1712 memset(tdi_buffer, 0, sizeof(tdi_buffer));
1713 }
1714
1715 static void jlink_clock_data(const uint8_t *out, unsigned out_offset,
1716 const uint8_t *tms_out, unsigned tms_offset,
1717 uint8_t *in, unsigned in_offset,
1718 unsigned length)
1719 {
1720 do {
1721 unsigned available_length = JLINK_TAP_BUFFER_SIZE - tap_length / 8;
1722
1723 if (!available_length ||
1724 (in && pending_scan_results_length == MAX_PENDING_SCAN_RESULTS)) {
1725 if (jlink_flush() != ERROR_OK)
1726 return;
1727 available_length = JLINK_TAP_BUFFER_SIZE;
1728 }
1729
1730 struct pending_scan_result *pending_scan_result =
1731 &pending_scan_results_buffer[pending_scan_results_length];
1732
1733 unsigned scan_length = length > available_length ?
1734 available_length : length;
1735
1736 if (out)
1737 buf_set_buf(out, out_offset, tdi_buffer, tap_length, scan_length);
1738 if (tms_out)
1739 buf_set_buf(tms_out, tms_offset, tms_buffer, tap_length, scan_length);
1740
1741 if (in) {
1742 pending_scan_result->first = tap_length;
1743 pending_scan_result->length = scan_length;
1744 pending_scan_result->buffer = in;
1745 pending_scan_result->buffer_offset = in_offset;
1746 pending_scan_results_length++;
1747 }
1748
1749 tap_length += scan_length;
1750 out_offset += scan_length;
1751 tms_offset += scan_length;
1752 in_offset += scan_length;
1753 length -= scan_length;
1754 } while (length > 0);
1755 }
1756
1757 static int jlink_flush(void)
1758 {
1759 int i;
1760 int ret;
1761
1762 if (!tap_length)
1763 return ERROR_OK;
1764
1765 jlink_last_state = jtag_debug_state_machine(tms_buffer, tdi_buffer,
1766 tap_length, jlink_last_state);
1767
1768 ret = jaylink_jtag_io(devh, tms_buffer, tdi_buffer, tdo_buffer,
1769 tap_length, jtag_command_version);
1770
1771 if (ret != JAYLINK_OK) {
1772 LOG_ERROR("jaylink_jtag_io() failed: %s.", jaylink_strerror_name(ret));
1773 jlink_tap_init();
1774 return ERROR_JTAG_QUEUE_FAILED;
1775 }
1776
1777 for (i = 0; i < pending_scan_results_length; i++) {
1778 struct pending_scan_result *p = &pending_scan_results_buffer[i];
1779
1780 buf_set_buf(tdo_buffer, p->first, p->buffer,
1781 p->buffer_offset, p->length);
1782
1783 DEBUG_JTAG_IO("Pending scan result, length = %d.", p->length);
1784 }
1785
1786 jlink_tap_init();
1787
1788 return ERROR_OK;
1789 }
1790
1791 static void fill_buffer(uint8_t *buf, uint32_t val, uint32_t len)
1792 {
1793 unsigned int tap_pos = tap_length;
1794
1795 while (len > 32) {
1796 buf_set_u32(buf, tap_pos, 32, val);
1797 len -= 32;
1798 tap_pos += 32;
1799 }
1800
1801 if (len)
1802 buf_set_u32(buf, tap_pos, len, val);
1803 }
1804
1805 static void jlink_queue_data_out(const uint8_t *data, uint32_t len)
1806 {
1807 const uint32_t dir_out = 0xffffffff;
1808
1809 if (data)
1810 bit_copy(tdi_buffer, tap_length, data, 0, len);
1811 else
1812 fill_buffer(tdi_buffer, 0, len);
1813
1814 fill_buffer(tms_buffer, dir_out, len);
1815 tap_length += len;
1816 }
1817
1818 static void jlink_queue_data_in(uint32_t len)
1819 {
1820 const uint32_t dir_in = 0;
1821
1822 fill_buffer(tms_buffer, dir_in, len);
1823 tap_length += len;
1824 }
1825
1826 static int jlink_swd_switch_seq(enum swd_special_seq seq)
1827 {
1828 const uint8_t *s;
1829 unsigned int s_len;
1830
1831 switch (seq) {
1832 case LINE_RESET:
1833 LOG_DEBUG("SWD line reset");
1834 s = swd_seq_line_reset;
1835 s_len = swd_seq_line_reset_len;
1836 break;
1837 case JTAG_TO_SWD:
1838 LOG_DEBUG("JTAG-to-SWD");
1839 s = swd_seq_jtag_to_swd;
1840 s_len = swd_seq_jtag_to_swd_len;
1841 break;
1842 case SWD_TO_JTAG:
1843 LOG_DEBUG("SWD-to-JTAG");
1844 s = swd_seq_swd_to_jtag;
1845 s_len = swd_seq_swd_to_jtag_len;
1846 break;
1847 default:
1848 LOG_ERROR("Sequence %d not supported.", seq);
1849 return ERROR_FAIL;
1850 }
1851
1852 jlink_queue_data_out(s, s_len);
1853
1854 return ERROR_OK;
1855 }
1856
1857 static int jlink_swd_run_queue(void)
1858 {
1859 int i;
1860 int ret;
1861
1862 LOG_DEBUG("Executing %d queued transactions.", pending_scan_results_length);
1863
1864 if (queued_retval != ERROR_OK) {
1865 LOG_DEBUG("Skipping due to previous errors: %d.", queued_retval);
1866 goto skip;
1867 }
1868
1869 /*
1870 * A transaction must be followed by another transaction or at least 8 idle
1871 * cycles to ensure that data is clocked through the AP.
1872 */
1873 jlink_queue_data_out(NULL, 8);
1874
1875 ret = jaylink_swd_io(devh, tms_buffer, tdi_buffer, tdo_buffer, tap_length);
1876
1877 if (ret != JAYLINK_OK) {
1878 LOG_ERROR("jaylink_swd_io() failed: %s.", jaylink_strerror_name(ret));
1879 goto skip;
1880 }
1881
1882 for (i = 0; i < pending_scan_results_length; i++) {
1883 int ack = buf_get_u32(tdo_buffer, pending_scan_results_buffer[i].first, 3);
1884
1885 if (ack != SWD_ACK_OK) {
1886 LOG_DEBUG("SWD ack not OK: %d %s", ack,
1887 ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK");
1888 queued_retval = ack == SWD_ACK_WAIT ? ERROR_WAIT : ERROR_FAIL;
1889 goto skip;
1890 } else if (pending_scan_results_buffer[i].length) {
1891 uint32_t data = buf_get_u32(tdo_buffer, 3 + pending_scan_results_buffer[i].first, 32);
1892 int parity = buf_get_u32(tdo_buffer, 3 + 32 + pending_scan_results_buffer[i].first, 1);
1893
1894 if (parity != parity_u32(data)) {
1895 LOG_ERROR("SWD: Read data parity mismatch.");
1896 queued_retval = ERROR_FAIL;
1897 goto skip;
1898 }
1899
1900 if (pending_scan_results_buffer[i].buffer)
1901 *(uint32_t *)pending_scan_results_buffer[i].buffer = data;
1902 }
1903 }
1904
1905 skip:
1906 jlink_tap_init();
1907 ret = queued_retval;
1908 queued_retval = ERROR_OK;
1909
1910 return ret;
1911 }
1912
1913 static void jlink_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data, uint32_t ap_delay_clk)
1914 {
1915 uint8_t data_parity_trn[DIV_ROUND_UP(32 + 1, 8)];
1916 if (tap_length + 46 + 8 + ap_delay_clk >= sizeof(tdi_buffer) * 8 ||
1917 pending_scan_results_length == MAX_PENDING_SCAN_RESULTS) {
1918 /* Not enough room in the queue. Run the queue. */
1919 queued_retval = jlink_swd_run_queue();
1920 }
1921
1922 if (queued_retval != ERROR_OK)
1923 return;
1924
1925 cmd |= SWD_CMD_START | SWD_CMD_PARK;
1926
1927 jlink_queue_data_out(&cmd, 8);
1928
1929 pending_scan_results_buffer[pending_scan_results_length].first = tap_length;
1930
1931 if (cmd & SWD_CMD_RnW) {
1932 /* Queue a read transaction. */
1933 pending_scan_results_buffer[pending_scan_results_length].length = 32;
1934 pending_scan_results_buffer[pending_scan_results_length].buffer = dst;
1935
1936 jlink_queue_data_in(1 + 3 + 32 + 1 + 1);
1937 } else {
1938 /* Queue a write transaction. */
1939 pending_scan_results_buffer[pending_scan_results_length].length = 0;
1940 jlink_queue_data_in(1 + 3 + 1);
1941
1942 buf_set_u32(data_parity_trn, 0, 32, data);
1943 buf_set_u32(data_parity_trn, 32, 1, parity_u32(data));
1944
1945 jlink_queue_data_out(data_parity_trn, 32 + 1);
1946 }
1947
1948 pending_scan_results_length++;
1949
1950 /* Insert idle cycles after AP accesses to avoid WAIT. */
1951 if (cmd & SWD_CMD_APnDP)
1952 jlink_queue_data_out(NULL, ap_delay_clk);
1953 }
1954
1955 static const struct swd_driver jlink_swd = {
1956 .init = &jlink_swd_init,
1957 .frequency = &jlink_swd_frequency,
1958 .switch_seq = &jlink_swd_switch_seq,
1959 .read_reg = &jlink_swd_read_reg,
1960 .write_reg = &jlink_swd_write_reg,
1961 .run = &jlink_swd_run_queue,
1962 };
1963
1964 static const char * const jlink_transports[] = { "jtag", "swd", NULL };
1965
1966 struct jtag_interface jlink_interface = {
1967 .name = "jlink",
1968 .commands = jlink_command_handlers,
1969 .transports = jlink_transports,
1970 .swd = &jlink_swd,
1971 .execute_queue = &jlink_execute_queue,
1972 .speed = &jlink_speed,
1973 .speed_div = &jlink_speed_div,
1974 .khz = &jlink_khz,
1975 .init = &jlink_init,
1976 .quit = &jlink_quit,
1977 .config_trace = &config_trace,
1978 .poll_trace = &poll_trace,
1979 };
Open On-Chip Debugger

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)