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