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