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