Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
target/armv7m_trace: Calculate prescaler for external capture devices
[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 trace_enabled = enabled;
1328
1329 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_SWO)) {
1330 if (!enabled)
1331 return ERROR_OK;
1332
1333 LOG_ERROR("Trace capturing is not supported by the device.");
1334 return ERROR_FAIL;
1335 }
1336
1337 ret = jaylink_swo_stop(devh);
1338
1339 if (ret != JAYLINK_OK) {
1340 LOG_ERROR("jaylink_swo_stop() failed: %s.", jaylink_strerror(ret));
1341 return ERROR_FAIL;
1342 }
1343
1344 if (!enabled) {
1345 /*
1346 * Adjust the SWD transaction buffer size as stopping SWO capturing
1347 * deallocates device internal memory.
1348 */
1349 if (!adjust_swd_buffer_size())
1350 return ERROR_FAIL;
1351
1352 return ERROR_OK;
1353 }
1354
1355 if (pin_protocol != TPIU_PIN_PROTOCOL_ASYNC_UART) {
1356 LOG_ERROR("Selected pin protocol is not supported.");
1357 return ERROR_FAIL;
1358 }
1359
1360 buffer_size = calculate_trace_buffer_size();
1361
1362 if (!buffer_size) {
1363 LOG_ERROR("Not enough free device memory to start trace capturing.");
1364 return ERROR_FAIL;
1365 }
1366
1367 ret = jaylink_swo_get_speeds(devh, JAYLINK_SWO_MODE_UART, &speed);
1368
1369 if (ret != JAYLINK_OK) {
1370 LOG_ERROR("jaylink_swo_get_speeds() failed: %s.",
1371 jaylink_strerror(ret));
1372 return ERROR_FAIL;
1373 }
1374
1375 if (*trace_freq > 0) {
1376 divider = speed.freq / *trace_freq;
1377 min_freq = speed.freq / speed.max_div;
1378 max_freq = speed.freq / speed.min_div;
1379
1380 if (*trace_freq > max_freq) {
1381 LOG_INFO("Given SWO frequency too high, using %u Hz instead.",
1382 max_freq);
1383 *trace_freq = max_freq;
1384 } else if (*trace_freq < min_freq) {
1385 LOG_INFO("Given SWO frequency too low, using %u Hz instead.",
1386 min_freq);
1387 *trace_freq = min_freq;
1388 } else if (*trace_freq != speed.freq / divider) {
1389 *trace_freq = speed.freq / divider;
1390
1391 LOG_INFO("Given SWO frequency is not supported by the device, "
1392 "using %u Hz instead.", *trace_freq);
1393 }
1394
1395 if (!calculate_swo_prescaler(traceclkin_freq, *trace_freq,
1396 prescaler)) {
1397 LOG_ERROR("SWO frequency is not suitable. Please choose a "
1398 "different frequency or use auto-detection.");
1399 return ERROR_FAIL;
1400 }
1401 } else {
1402 LOG_INFO("Trying to auto-detect SWO frequency.");
1403
1404 if (!detect_swo_freq_and_prescaler(speed, traceclkin_freq, trace_freq,
1405 prescaler)) {
1406 LOG_ERROR("Maximum permitted frequency deviation of %.02f %% "
1407 "could not be achieved.", SWO_MAX_FREQ_DEV);
1408 LOG_ERROR("Auto-detection of SWO frequency failed.");
1409 return ERROR_FAIL;
1410 }
1411
1412 LOG_INFO("Using SWO frequency of %u Hz.", *trace_freq);
1413 }
1414
1415 ret = jaylink_swo_start(devh, JAYLINK_SWO_MODE_UART, *trace_freq,
1416 buffer_size);
1417
1418 if (ret != JAYLINK_OK) {
1419 LOG_ERROR("jaylink_start_swo() failed: %s.", jaylink_strerror(ret));
1420 return ERROR_FAIL;
1421 }
1422
1423 LOG_DEBUG("Using %u bytes device memory for trace capturing.",
1424 buffer_size);
1425
1426 /*
1427 * Adjust the SWD transaction buffer size as starting SWO capturing
1428 * allocates device internal memory.
1429 */
1430 if (!adjust_swd_buffer_size())
1431 return ERROR_FAIL;
1432
1433 return ERROR_OK;
1434 }
1435
1436 COMMAND_HANDLER(jlink_handle_config_usb_address_command)
1437 {
1438 uint8_t tmp;
1439
1440 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1441 command_print(CMD, "Reading configuration is not supported by the "
1442 "device.");
1443 return ERROR_OK;
1444 }
1445
1446 if (!CMD_ARGC) {
1447 show_config_usb_address(CMD);
1448 } else if (CMD_ARGC == 1) {
1449 if (sscanf(CMD_ARGV[0], "%" SCNd8, &tmp) != 1) {
1450 command_print(CMD, "Invalid USB address: %s.", CMD_ARGV[0]);
1451 return ERROR_FAIL;
1452 }
1453
1454 if (tmp > JAYLINK_USB_ADDRESS_3) {
1455 command_print(CMD, "Invalid USB address: %u.", tmp);
1456 return ERROR_FAIL;
1457 }
1458
1459 tmp_config.usb_address = tmp;
1460 } else {
1461 command_print(CMD, "Need exactly one argument for jlink config "
1462 "usb.");
1463 return ERROR_COMMAND_SYNTAX_ERROR;
1464 }
1465
1466 return ERROR_OK;
1467 }
1468
1469 COMMAND_HANDLER(jlink_handle_config_target_power_command)
1470 {
1471 int enable;
1472
1473 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1474 command_print(CMD, "Reading configuration is not supported by the "
1475 "device.");
1476 return ERROR_OK;
1477 }
1478
1479 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_SET_TARGET_POWER)) {
1480 command_print(CMD, "Target power supply is not supported by the "
1481 "device.");
1482 return ERROR_OK;
1483 }
1484
1485 if (!CMD_ARGC) {
1486 show_config_target_power(CMD);
1487 } else if (CMD_ARGC == 1) {
1488 if (!strcmp(CMD_ARGV[0], "on")) {
1489 enable = true;
1490 } else if (!strcmp(CMD_ARGV[0], "off")) {
1491 enable = false;
1492 } else {
1493 command_print(CMD, "Invalid argument: %s.", CMD_ARGV[0]);
1494 return ERROR_FAIL;
1495 }
1496
1497 tmp_config.target_power = enable;
1498 } else {
1499 command_print(CMD, "Need exactly one argument for jlink config "
1500 "targetpower.");
1501 return ERROR_COMMAND_SYNTAX_ERROR;
1502 }
1503
1504 return ERROR_OK;
1505 }
1506
1507 COMMAND_HANDLER(jlink_handle_config_mac_address_command)
1508 {
1509 uint8_t addr[6];
1510 int i;
1511 char *e;
1512 const char *str;
1513
1514 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1515 command_print(CMD, "Reading configuration is not supported by the "
1516 "device.");
1517 return ERROR_OK;
1518 }
1519
1520 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_ETHERNET)) {
1521 command_print(CMD, "Ethernet connectivity is not supported by the "
1522 "device.");
1523 return ERROR_OK;
1524 }
1525
1526 if (!CMD_ARGC) {
1527 show_config_mac_address(CMD);
1528 } else if (CMD_ARGC == 1) {
1529 str = CMD_ARGV[0];
1530
1531 if ((strlen(str) != 17) || (str[2] != ':' || str[5] != ':' ||
1532 str[8] != ':' || str[11] != ':' || str[14] != ':')) {
1533 command_print(CMD, "Invalid MAC address format.");
1534 return ERROR_COMMAND_SYNTAX_ERROR;
1535 }
1536
1537 for (i = 5; i >= 0; i--) {
1538 addr[i] = strtoul(str, &e, 16);
1539 str = e + 1;
1540 }
1541
1542 if (!(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5])) {
1543 command_print(CMD, "Invalid MAC address: zero address.");
1544 return ERROR_COMMAND_SYNTAX_ERROR;
1545 }
1546
1547 if (!(0x01 & addr[0])) {
1548 command_print(CMD, "Invalid MAC address: multicast address.");
1549 return ERROR_COMMAND_SYNTAX_ERROR;
1550 }
1551
1552 memcpy(tmp_config.mac_address, addr, sizeof(addr));
1553 } else {
1554 command_print(CMD, "Need exactly one argument for jlink config "
1555 " mac.");
1556 return ERROR_COMMAND_SYNTAX_ERROR;
1557 }
1558
1559 return ERROR_OK;
1560 }
1561
1562 static bool string_to_ip(const char *s, uint8_t *ip, int *pos)
1563 {
1564 uint8_t lip[4];
1565 char *e;
1566 const char *s_save = s;
1567 int i;
1568
1569 if (!s)
1570 return false;
1571
1572 for (i = 0; i < 4; i++) {
1573 lip[i] = strtoul(s, &e, 10);
1574
1575 if (*e != '.' && i != 3)
1576 return false;
1577
1578 s = e + 1;
1579 }
1580
1581 *pos = e - s_save;
1582 memcpy(ip, lip, sizeof(lip));
1583
1584 return true;
1585 }
1586
1587 static void cpy_ip(uint8_t *dst, uint8_t *src)
1588 {
1589 int i, j;
1590
1591 for (i = 0, j = 3; i < 4; i++, j--)
1592 dst[i] = src[j];
1593 }
1594
1595 COMMAND_HANDLER(jlink_handle_config_ip_address_command)
1596 {
1597 uint8_t ip_address[4];
1598 uint32_t subnet_mask = 0;
1599 int i, len;
1600 uint8_t subnet_bits = 24;
1601
1602 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1603 command_print(CMD, "Reading configuration is not supported by the "
1604 "device.");
1605 return ERROR_OK;
1606 }
1607
1608 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_ETHERNET)) {
1609 command_print(CMD, "Ethernet connectivity is not supported by the "
1610 "device.");
1611 return ERROR_OK;
1612 }
1613
1614 if (!CMD_ARGC) {
1615 show_config_ip_address(CMD);
1616 } else {
1617 if (!string_to_ip(CMD_ARGV[0], ip_address, &i))
1618 return ERROR_COMMAND_SYNTAX_ERROR;
1619
1620 len = strlen(CMD_ARGV[0]);
1621
1622 /* Check for format A.B.C.D/E. */
1623 if (i < len) {
1624 if (CMD_ARGV[0][i] != '/')
1625 return ERROR_COMMAND_SYNTAX_ERROR;
1626
1627 COMMAND_PARSE_NUMBER(u8, CMD_ARGV[0] + i + 1, subnet_bits);
1628 } else if (CMD_ARGC > 1) {
1629 if (!string_to_ip(CMD_ARGV[1], (uint8_t *)&subnet_mask, &i))
1630 return ERROR_COMMAND_SYNTAX_ERROR;
1631 }
1632
1633 if (!subnet_mask)
1634 subnet_mask = (uint32_t)(subnet_bits < 32 ?
1635 ((1ULL << subnet_bits) - 1) : 0xffffffff);
1636
1637 cpy_ip(tmp_config.ip_address, ip_address);
1638 cpy_ip(tmp_config.subnet_mask, (uint8_t *)&subnet_mask);
1639 }
1640
1641 return ERROR_OK;
1642 }
1643
1644 COMMAND_HANDLER(jlink_handle_config_reset_command)
1645 {
1646 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG))
1647 return ERROR_OK;
1648
1649 memcpy(&tmp_config, &config, sizeof(struct device_config));
1650
1651 return ERROR_OK;
1652 }
1653
1654
1655 COMMAND_HANDLER(jlink_handle_config_write_command)
1656 {
1657 int ret;
1658
1659 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1660 command_print(CMD, "Reading configuration is not supported by the "
1661 "device.");
1662 return ERROR_OK;
1663 }
1664
1665 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_WRITE_CONFIG)) {
1666 command_print(CMD, "Writing configuration is not supported by the "
1667 "device.");
1668 return ERROR_OK;
1669 }
1670
1671 if (!memcmp(&config, &tmp_config, sizeof(struct device_config))) {
1672 command_print(CMD, "Operation not performed due to no changes in "
1673 "the configuration.");
1674 return ERROR_OK;
1675 }
1676
1677 ret = jaylink_write_raw_config(devh, (const uint8_t *)&tmp_config);
1678
1679 if (ret != JAYLINK_OK) {
1680 LOG_ERROR("jaylink_write_raw_config() failed: %s.",
1681 jaylink_strerror(ret));
1682 return ERROR_FAIL;
1683 }
1684
1685 if (!read_device_config(&config)) {
1686 LOG_ERROR("Failed to read device configuration for verification.");
1687 return ERROR_FAIL;
1688 }
1689
1690 if (memcmp(&config, &tmp_config, sizeof(struct device_config))) {
1691 LOG_ERROR("Verification of device configuration failed. Please check "
1692 "your device.");
1693 return ERROR_FAIL;
1694 }
1695
1696 memcpy(&tmp_config, &config, sizeof(struct device_config));
1697 command_print(CMD, "The new device configuration applies after power "
1698 "cycling the J-Link device.");
1699
1700 return ERROR_OK;
1701 }
1702
1703 COMMAND_HANDLER(jlink_handle_config_command)
1704 {
1705 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1706 command_print(CMD, "Device doesn't support reading configuration.");
1707 return ERROR_OK;
1708 }
1709
1710 if (CMD_ARGC == 0)
1711 show_config(CMD);
1712
1713 return ERROR_OK;
1714 }
1715
1716 COMMAND_HANDLER(jlink_handle_emucom_write_command)
1717 {
1718 int ret;
1719 size_t tmp;
1720 uint32_t channel;
1721 uint32_t length;
1722 uint8_t *buf;
1723 size_t dummy;
1724
1725 if (CMD_ARGC != 2)
1726 return ERROR_COMMAND_SYNTAX_ERROR;
1727
1728 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_EMUCOM)) {
1729 LOG_ERROR("Device does not support EMUCOM.");
1730 return ERROR_FAIL;
1731 }
1732
1733 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], channel);
1734
1735 tmp = strlen(CMD_ARGV[1]);
1736
1737 if (tmp % 2 != 0) {
1738 LOG_ERROR("Data must be encoded as hexadecimal pairs.");
1739 return ERROR_COMMAND_ARGUMENT_INVALID;
1740 }
1741
1742 buf = malloc(tmp / 2);
1743
1744 if (!buf) {
1745 LOG_ERROR("Failed to allocate buffer.");
1746 return ERROR_FAIL;
1747 }
1748
1749 dummy = unhexify(buf, CMD_ARGV[1], tmp / 2);
1750
1751 if (dummy != (tmp / 2)) {
1752 LOG_ERROR("Data must be encoded as hexadecimal pairs.");
1753 free(buf);
1754 return ERROR_COMMAND_ARGUMENT_INVALID;
1755 }
1756
1757 length = tmp / 2;
1758 ret = jaylink_emucom_write(devh, channel, buf, &length);
1759
1760 free(buf);
1761
1762 if (ret == JAYLINK_ERR_DEV_NOT_SUPPORTED) {
1763 LOG_ERROR("Channel not supported by the device.");
1764 return ERROR_FAIL;
1765 } else if (ret != JAYLINK_OK) {
1766 LOG_ERROR("Failed to write to channel: %s.", jaylink_strerror(ret));
1767 return ERROR_FAIL;
1768 }
1769
1770 if (length != (tmp / 2))
1771 LOG_WARNING("Only %" PRIu32 " bytes written to the channel.", length);
1772
1773 return ERROR_OK;
1774 }
1775
1776 COMMAND_HANDLER(jlink_handle_emucom_read_command)
1777 {
1778 int ret;
1779 uint32_t channel;
1780 uint32_t length;
1781 uint8_t *buf;
1782 size_t tmp;
1783
1784 if (CMD_ARGC != 2)
1785 return ERROR_COMMAND_SYNTAX_ERROR;
1786
1787 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_EMUCOM)) {
1788 LOG_ERROR("Device does not support EMUCOM.");
1789 return ERROR_FAIL;
1790 }
1791
1792 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], channel);
1793 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
1794
1795 buf = malloc(length * 3 + 1);
1796
1797 if (!buf) {
1798 LOG_ERROR("Failed to allocate buffer.");
1799 return ERROR_FAIL;
1800 }
1801
1802 ret = jaylink_emucom_read(devh, channel, buf, &length);
1803
1804 if (ret == JAYLINK_ERR_DEV_NOT_SUPPORTED) {
1805 LOG_ERROR("Channel is not supported by the device.");
1806 free(buf);
1807 return ERROR_FAIL;
1808 } else if (ret == JAYLINK_ERR_DEV_NOT_AVAILABLE) {
1809 LOG_ERROR("Channel is not available for the requested amount of data. "
1810 "%" PRIu32 " bytes are avilable.", length);
1811 free(buf);
1812 return ERROR_FAIL;
1813 } else if (ret != JAYLINK_OK) {
1814 LOG_ERROR("Failed to read from channel: %s.", jaylink_strerror(ret));
1815 free(buf);
1816 return ERROR_FAIL;
1817 }
1818
1819 tmp = hexify((char *)buf + length, buf, length, 2 * length + 1);
1820
1821 if (tmp != 2 * length) {
1822 LOG_ERROR("Failed to convert data into hexadecimal string.");
1823 free(buf);
1824 return ERROR_FAIL;
1825 }
1826
1827 command_print(CMD, "%s", buf + length);
1828 free(buf);
1829
1830 return ERROR_OK;
1831 }
1832
1833 static const struct command_registration jlink_config_subcommand_handlers[] = {
1834 {
1835 .name = "usb",
1836 .handler = &jlink_handle_config_usb_address_command,
1837 .mode = COMMAND_EXEC,
1838 .help = "set the USB address",
1839 .usage = "[0-3]",
1840 },
1841 {
1842 .name = "targetpower",
1843 .handler = &jlink_handle_config_target_power_command,
1844 .mode = COMMAND_EXEC,
1845 .help = "set the target power supply",
1846 .usage = "[on|off]"
1847 },
1848 {
1849 .name = "mac",
1850 .handler = &jlink_handle_config_mac_address_command,
1851 .mode = COMMAND_EXEC,
1852 .help = "set the MAC Address",
1853 .usage = "[ff:ff:ff:ff:ff:ff]",
1854 },
1855 {
1856 .name = "ip",
1857 .handler = &jlink_handle_config_ip_address_command,
1858 .mode = COMMAND_EXEC,
1859 .help = "set the IP address, where A.B.C.D is the IP address, "
1860 "E the bit of the subnet mask, F.G.H.I the subnet mask",
1861 .usage = "[A.B.C.D[/E] [F.G.H.I]]",
1862 },
1863 {
1864 .name = "reset",
1865 .handler = &jlink_handle_config_reset_command,
1866 .mode = COMMAND_EXEC,
1867 .help = "undo configuration changes",
1868 .usage = "",
1869 },
1870 {
1871 .name = "write",
1872 .handler = &jlink_handle_config_write_command,
1873 .mode = COMMAND_EXEC,
1874 .help = "write configuration to the device",
1875 .usage = "",
1876 },
1877 COMMAND_REGISTRATION_DONE
1878 };
1879
1880 static const struct command_registration jlink_emucom_subcommand_handlers[] = {
1881 {
1882 .name = "write",
1883 .handler = &jlink_handle_emucom_write_command,
1884 .mode = COMMAND_EXEC,
1885 .help = "write to a channel",
1886 .usage = "<channel> <data>",
1887 },
1888 {
1889 .name = "read",
1890 .handler = &jlink_handle_emucom_read_command,
1891 .mode = COMMAND_EXEC,
1892 .help = "read from a channel",
1893 .usage = "<channel> <length>"
1894 },
1895 COMMAND_REGISTRATION_DONE
1896 };
1897
1898 static const struct command_registration jlink_subcommand_handlers[] = {
1899 {
1900 .name = "jtag",
1901 .handler = &jlink_handle_jlink_jtag_command,
1902 .mode = COMMAND_EXEC,
1903 .help = "select the JTAG command version",
1904 .usage = "[2|3]",
1905 },
1906 {
1907 .name = "targetpower",
1908 .handler = &jlink_handle_target_power_command,
1909 .mode = COMMAND_EXEC,
1910 .help = "set the target power supply",
1911 .usage = "<on|off>"
1912 },
1913 {
1914 .name = "freemem",
1915 .handler = &jlink_handle_free_memory_command,
1916 .mode = COMMAND_EXEC,
1917 .help = "show free device memory",
1918 .usage = "",
1919 },
1920 {
1921 .name = "hwstatus",
1922 .handler = &jlink_handle_hwstatus_command,
1923 .mode = COMMAND_EXEC,
1924 .help = "show the hardware status",
1925 .usage = "",
1926 },
1927 {
1928 .name = "usb",
1929 .handler = &jlink_usb_command,
1930 .mode = COMMAND_CONFIG,
1931 .help = "set the USB address of the device that should be used",
1932 .usage = "<0-3>"
1933 },
1934 {
1935 .name = "serial",
1936 .handler = &jlink_serial_command,
1937 .mode = COMMAND_CONFIG,
1938 .help = "set the serial number of the device that should be used",
1939 .usage = "<serial number>"
1940 },
1941 {
1942 .name = "config",
1943 .handler = &jlink_handle_config_command,
1944 .mode = COMMAND_EXEC,
1945 .help = "access the device configuration. If no argument is given "
1946 "this will show the device configuration",
1947 .chain = jlink_config_subcommand_handlers,
1948 .usage = "[<cmd>]",
1949 },
1950 {
1951 .name = "emucom",
1952 .mode = COMMAND_EXEC,
1953 .help = "access EMUCOM channel",
1954 .chain = jlink_emucom_subcommand_handlers,
1955 .usage = "",
1956 },
1957 COMMAND_REGISTRATION_DONE
1958 };
1959
1960 static const struct command_registration jlink_command_handlers[] = {
1961 {
1962 .name = "jlink",
1963 .mode = COMMAND_ANY,
1964 .help = "perform jlink management",
1965 .chain = jlink_subcommand_handlers,
1966 .usage = "",
1967 },
1968 COMMAND_REGISTRATION_DONE
1969 };
1970
1971 static int jlink_swd_init(void)
1972 {
1973 iface = JAYLINK_TIF_SWD;
1974
1975 return ERROR_OK;
1976 }
1977
1978 static void jlink_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
1979 {
1980 assert(!(cmd & SWD_CMD_RnW));
1981 jlink_swd_queue_cmd(cmd, NULL, value, ap_delay_clk);
1982 }
1983
1984 static void jlink_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
1985 {
1986 assert(cmd & SWD_CMD_RnW);
1987 jlink_swd_queue_cmd(cmd, value, 0, ap_delay_clk);
1988 }
1989
1990 /***************************************************************************/
1991 /* J-Link tap functions */
1992
1993 static unsigned tap_length;
1994 /* In SWD mode use tms buffer for direction control */
1995 static uint8_t tms_buffer[JLINK_TAP_BUFFER_SIZE];
1996 static uint8_t tdi_buffer[JLINK_TAP_BUFFER_SIZE];
1997 static uint8_t tdo_buffer[JLINK_TAP_BUFFER_SIZE];
1998
1999 struct pending_scan_result {
2000 /** First bit position in tdo_buffer to read. */
2001 unsigned first;
2002 /** Number of bits to read. */
2003 unsigned length;
2004 /** Location to store the result */
2005 void *buffer;
2006 /** Offset in the destination buffer */
2007 unsigned buffer_offset;
2008 };
2009
2010 #define MAX_PENDING_SCAN_RESULTS 256
2011
2012 static int pending_scan_results_length;
2013 static struct pending_scan_result pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS];
2014
2015 static void jlink_tap_init(void)
2016 {
2017 tap_length = 0;
2018 pending_scan_results_length = 0;
2019 memset(tms_buffer, 0, sizeof(tms_buffer));
2020 memset(tdi_buffer, 0, sizeof(tdi_buffer));
2021 }
2022
2023 static void jlink_clock_data(const uint8_t *out, unsigned out_offset,
2024 const uint8_t *tms_out, unsigned tms_offset,
2025 uint8_t *in, unsigned in_offset,
2026 unsigned length)
2027 {
2028 do {
2029 unsigned available_length = JLINK_TAP_BUFFER_SIZE - tap_length / 8;
2030
2031 if (!available_length ||
2032 (in && pending_scan_results_length == MAX_PENDING_SCAN_RESULTS)) {
2033 if (jlink_flush() != ERROR_OK)
2034 return;
2035 available_length = JLINK_TAP_BUFFER_SIZE;
2036 }
2037
2038 struct pending_scan_result *pending_scan_result =
2039 &pending_scan_results_buffer[pending_scan_results_length];
2040
2041 unsigned scan_length = length > available_length ?
2042 available_length : length;
2043
2044 if (out)
2045 buf_set_buf(out, out_offset, tdi_buffer, tap_length, scan_length);
2046 if (tms_out)
2047 buf_set_buf(tms_out, tms_offset, tms_buffer, tap_length, scan_length);
2048
2049 if (in) {
2050 pending_scan_result->first = tap_length;
2051 pending_scan_result->length = scan_length;
2052 pending_scan_result->buffer = in;
2053 pending_scan_result->buffer_offset = in_offset;
2054 pending_scan_results_length++;
2055 }
2056
2057 tap_length += scan_length;
2058 out_offset += scan_length;
2059 tms_offset += scan_length;
2060 in_offset += scan_length;
2061 length -= scan_length;
2062 } while (length > 0);
2063 }
2064
2065 static int jlink_flush(void)
2066 {
2067 int i;
2068 int ret;
2069
2070 if (!tap_length)
2071 return ERROR_OK;
2072
2073 jlink_last_state = jtag_debug_state_machine(tms_buffer, tdi_buffer,
2074 tap_length, jlink_last_state);
2075
2076 ret = jaylink_jtag_io(devh, tms_buffer, tdi_buffer, tdo_buffer,
2077 tap_length, jtag_command_version);
2078
2079 if (ret != JAYLINK_OK) {
2080 LOG_ERROR("jaylink_jtag_io() failed: %s.", jaylink_strerror(ret));
2081 jlink_tap_init();
2082 return ERROR_JTAG_QUEUE_FAILED;
2083 }
2084
2085 for (i = 0; i < pending_scan_results_length; i++) {
2086 struct pending_scan_result *p = &pending_scan_results_buffer[i];
2087
2088 buf_set_buf(tdo_buffer, p->first, p->buffer,
2089 p->buffer_offset, p->length);
2090
2091 LOG_DEBUG_IO("Pending scan result, length = %d.", p->length);
2092 }
2093
2094 jlink_tap_init();
2095
2096 return ERROR_OK;
2097 }
2098
2099 static void fill_buffer(uint8_t *buf, uint32_t val, uint32_t len)
2100 {
2101 unsigned int tap_pos = tap_length;
2102
2103 while (len > 32) {
2104 buf_set_u32(buf, tap_pos, 32, val);
2105 len -= 32;
2106 tap_pos += 32;
2107 }
2108
2109 if (len)
2110 buf_set_u32(buf, tap_pos, len, val);
2111 }
2112
2113 static void jlink_queue_data_out(const uint8_t *data, uint32_t len)
2114 {
2115 const uint32_t dir_out = 0xffffffff;
2116
2117 if (data)
2118 bit_copy(tdi_buffer, tap_length, data, 0, len);
2119 else
2120 fill_buffer(tdi_buffer, 0, len);
2121
2122 fill_buffer(tms_buffer, dir_out, len);
2123 tap_length += len;
2124 }
2125
2126 static void jlink_queue_data_in(uint32_t len)
2127 {
2128 const uint32_t dir_in = 0;
2129
2130 fill_buffer(tms_buffer, dir_in, len);
2131 tap_length += len;
2132 }
2133
2134 static int jlink_swd_switch_seq(enum swd_special_seq seq)
2135 {
2136 const uint8_t *s;
2137 unsigned int s_len;
2138
2139 switch (seq) {
2140 case LINE_RESET:
2141 LOG_DEBUG("SWD line reset");
2142 s = swd_seq_line_reset;
2143 s_len = swd_seq_line_reset_len;
2144 break;
2145 case JTAG_TO_SWD:
2146 LOG_DEBUG("JTAG-to-SWD");
2147 s = swd_seq_jtag_to_swd;
2148 s_len = swd_seq_jtag_to_swd_len;
2149 break;
2150 case SWD_TO_JTAG:
2151 LOG_DEBUG("SWD-to-JTAG");
2152 s = swd_seq_swd_to_jtag;
2153 s_len = swd_seq_swd_to_jtag_len;
2154 break;
2155 default:
2156 LOG_ERROR("Sequence %d not supported.", seq);
2157 return ERROR_FAIL;
2158 }
2159
2160 jlink_queue_data_out(s, s_len);
2161
2162 return ERROR_OK;
2163 }
2164
2165 static int jlink_swd_run_queue(void)
2166 {
2167 int i;
2168 int ret;
2169
2170 LOG_DEBUG("Executing %d queued transactions.", pending_scan_results_length);
2171
2172 if (queued_retval != ERROR_OK) {
2173 LOG_DEBUG("Skipping due to previous errors: %d.", queued_retval);
2174 goto skip;
2175 }
2176
2177 /*
2178 * A transaction must be followed by another transaction or at least 8 idle
2179 * cycles to ensure that data is clocked through the AP.
2180 */
2181 jlink_queue_data_out(NULL, 8);
2182
2183 ret = jaylink_swd_io(devh, tms_buffer, tdi_buffer, tdo_buffer, tap_length);
2184
2185 if (ret != JAYLINK_OK) {
2186 LOG_ERROR("jaylink_swd_io() failed: %s.", jaylink_strerror(ret));
2187 goto skip;
2188 }
2189
2190 for (i = 0; i < pending_scan_results_length; i++) {
2191 int ack = buf_get_u32(tdo_buffer, pending_scan_results_buffer[i].first, 3);
2192
2193 if (ack != SWD_ACK_OK) {
2194 LOG_DEBUG("SWD ack not OK: %d %s", ack,
2195 ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK");
2196 queued_retval = ack == SWD_ACK_WAIT ? ERROR_WAIT : ERROR_FAIL;
2197 goto skip;
2198 } else if (pending_scan_results_buffer[i].length) {
2199 uint32_t data = buf_get_u32(tdo_buffer, 3 + pending_scan_results_buffer[i].first, 32);
2200 int parity = buf_get_u32(tdo_buffer, 3 + 32 + pending_scan_results_buffer[i].first, 1);
2201
2202 if (parity != parity_u32(data)) {
2203 LOG_ERROR("SWD: Read data parity mismatch.");
2204 queued_retval = ERROR_FAIL;
2205 goto skip;
2206 }
2207
2208 if (pending_scan_results_buffer[i].buffer)
2209 *(uint32_t *)pending_scan_results_buffer[i].buffer = data;
2210 }
2211 }
2212
2213 skip:
2214 jlink_tap_init();
2215 ret = queued_retval;
2216 queued_retval = ERROR_OK;
2217
2218 return ret;
2219 }
2220
2221 static void jlink_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data, uint32_t ap_delay_clk)
2222 {
2223 uint8_t data_parity_trn[DIV_ROUND_UP(32 + 1, 8)];
2224 if (tap_length + 46 + 8 + ap_delay_clk >= swd_buffer_size * 8 ||
2225 pending_scan_results_length == MAX_PENDING_SCAN_RESULTS) {
2226 /* Not enough room in the queue. Run the queue. */
2227 queued_retval = jlink_swd_run_queue();
2228 }
2229
2230 if (queued_retval != ERROR_OK)
2231 return;
2232
2233 cmd |= SWD_CMD_START | SWD_CMD_PARK;
2234
2235 jlink_queue_data_out(&cmd, 8);
2236
2237 pending_scan_results_buffer[pending_scan_results_length].first = tap_length;
2238
2239 if (cmd & SWD_CMD_RnW) {
2240 /* Queue a read transaction. */
2241 pending_scan_results_buffer[pending_scan_results_length].length = 32;
2242 pending_scan_results_buffer[pending_scan_results_length].buffer = dst;
2243
2244 jlink_queue_data_in(1 + 3 + 32 + 1 + 1);
2245 } else {
2246 /* Queue a write transaction. */
2247 pending_scan_results_buffer[pending_scan_results_length].length = 0;
2248 jlink_queue_data_in(1 + 3 + 1);
2249
2250 buf_set_u32(data_parity_trn, 0, 32, data);
2251 buf_set_u32(data_parity_trn, 32, 1, parity_u32(data));
2252
2253 jlink_queue_data_out(data_parity_trn, 32 + 1);
2254 }
2255
2256 pending_scan_results_length++;
2257
2258 /* Insert idle cycles after AP accesses to avoid WAIT. */
2259 if (cmd & SWD_CMD_APnDP)
2260 jlink_queue_data_out(NULL, ap_delay_clk);
2261 }
2262
2263 static const struct swd_driver jlink_swd = {
2264 .init = &jlink_swd_init,
2265 .switch_seq = &jlink_swd_switch_seq,
2266 .read_reg = &jlink_swd_read_reg,
2267 .write_reg = &jlink_swd_write_reg,
2268 .run = &jlink_swd_run_queue,
2269 };
2270
2271 static const char * const jlink_transports[] = { "jtag", "swd", NULL };
2272
2273 static struct jtag_interface jlink_interface = {
2274 .execute_queue = &jlink_execute_queue,
2275 };
2276
2277 struct adapter_driver jlink_adapter_driver = {
2278 .name = "jlink",
2279 .transports = jlink_transports,
2280 .commands = jlink_command_handlers,
2281
2282 .init = &jlink_init,
2283 .quit = &jlink_quit,
2284 .reset = &jlink_reset_safe,
2285 .speed = &jlink_speed,
2286 .khz = &jlink_khz,
2287 .speed_div = &jlink_speed_div,
2288 .config_trace = &config_trace,
2289 .poll_trace = &poll_trace,
2290
2291 .jtag_ops = &jlink_interface,
2292 .swd_ops = &jlink_swd,
2293 };
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)