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