Code Review / openocd.git / blob
? search:


ac6e997efe86bcad52e209fa680f377bd3b242ea
[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(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(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(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(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(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.", jaylink_strerror(ret));
446 return ERROR_FAIL;
447 }
448
449 handle_found = false;
450
451 for (i = 0; i < count; i++) {
452 if (connlist[i].handle == conn.handle) {
453 handle_found = true;
454 break;
455 }
456 }
457
458 if (!handle_found) {
459 LOG_ERROR("Registration failed: maximum number of connections on the "
460 "device reached.");
461 return ERROR_FAIL;
462 }
463
464 return ERROR_OK;
465 }
466
467 /*
468 * Adjust the SWD transaction buffer size depending on the free device internal
469 * memory. This ensures that the SWD transactions sent to the device do not
470 * exceed the internal memory of the device.
471 */
472 static bool adjust_swd_buffer_size(void)
473 {
474 int ret;
475 uint32_t tmp;
476
477 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_FREE_MEMORY))
478 return true;
479
480 ret = jaylink_get_free_memory(devh, &tmp);
481
482 if (ret != JAYLINK_OK) {
483 LOG_ERROR("jaylink_get_free_memory() failed: %s.",
484 jaylink_strerror(ret));
485 return false;
486 }
487
488 if (tmp < 143) {
489 LOG_ERROR("Not enough free device internal memory: %u bytes.", tmp);
490 return false;
491 }
492
493 tmp = MIN(JLINK_TAP_BUFFER_SIZE, (tmp - 16) / 2);
494
495 if (tmp != swd_buffer_size) {
496 swd_buffer_size = tmp;
497 LOG_DEBUG("Adjusted SWD transaction buffer size to %u bytes.",
498 swd_buffer_size);
499 }
500
501 return true;
502 }
503
504 static int jaylink_log_handler(const struct jaylink_context *ctx,
505 enum jaylink_log_level level, const char *format, va_list args,
506 void *user_data)
507 {
508 enum log_levels tmp;
509
510 switch (level) {
511 case JAYLINK_LOG_LEVEL_ERROR:
512 tmp = LOG_LVL_ERROR;
513 break;
514 case JAYLINK_LOG_LEVEL_WARNING:
515 tmp = LOG_LVL_WARNING;
516 break;
517 /*
518 * Forward info messages to the debug output because they are more verbose
519 * than info messages of OpenOCD.
520 */
521 case JAYLINK_LOG_LEVEL_INFO:
522 case JAYLINK_LOG_LEVEL_DEBUG:
523 tmp = LOG_LVL_DEBUG;
524 break;
525 case JAYLINK_LOG_LEVEL_DEBUG_IO:
526 tmp = LOG_LVL_DEBUG_IO;
527 break;
528 default:
529 tmp = LOG_LVL_WARNING;
530 }
531
532 log_vprintf_lf(tmp, __FILE__, __LINE__, __func__, format, args);
533
534 return 0;
535 }
536
537 static int jlink_init(void)
538 {
539 int ret;
540 struct jaylink_device **devs;
541 unsigned int i;
542 bool found_device;
543 uint32_t tmp;
544 char *firmware_version;
545 struct jaylink_hardware_version hwver;
546 struct jaylink_hardware_status hwstatus;
547 enum jaylink_usb_address address;
548 size_t length;
549 size_t num_devices;
550
551 LOG_DEBUG("Using libjaylink %s (compiled with %s).",
552 jaylink_version_package_get_string(), JAYLINK_VERSION_PACKAGE_STRING);
553
554 if (!jaylink_library_has_cap(JAYLINK_CAP_HIF_USB) && use_usb_address) {
555 LOG_ERROR("J-Link driver does not support USB devices.");
556 return ERROR_JTAG_INIT_FAILED;
557 }
558
559 ret = jaylink_init(&jayctx);
560
561 if (ret != JAYLINK_OK) {
562 LOG_ERROR("jaylink_init() failed: %s.", jaylink_strerror(ret));
563 return ERROR_JTAG_INIT_FAILED;
564 }
565
566 ret = jaylink_log_set_callback(jayctx, &jaylink_log_handler, NULL);
567
568 if (ret != JAYLINK_OK) {
569 LOG_ERROR("jaylink_log_set_callback() failed: %s.",
570 jaylink_strerror(ret));
571 jaylink_exit(jayctx);
572 return ERROR_JTAG_INIT_FAILED;
573 }
574
575 ret = jaylink_discovery_scan(jayctx, 0);
576
577 if (ret != JAYLINK_OK) {
578 LOG_ERROR("jaylink_discovery_scan() failed: %s.",
579 jaylink_strerror(ret));
580 jaylink_exit(jayctx);
581 return ERROR_JTAG_INIT_FAILED;
582 }
583
584 ret = jaylink_get_devices(jayctx, &devs, &num_devices);
585
586 if (ret != JAYLINK_OK) {
587 LOG_ERROR("jaylink_get_devices() failed: %s.", jaylink_strerror(ret));
588 jaylink_exit(jayctx);
589 return ERROR_JTAG_INIT_FAILED;
590 }
591
592 if (!use_serial_number && !use_usb_address && num_devices > 1) {
593 LOG_ERROR("Multiple devices found, specify the desired device.");
594 jaylink_free_devices(devs, true);
595 jaylink_exit(jayctx);
596 return ERROR_JTAG_INIT_FAILED;
597 }
598
599 found_device = false;
600
601 for (i = 0; devs[i]; i++) {
602 if (use_serial_number) {
603 ret = jaylink_device_get_serial_number(devs[i], &tmp);
604
605 if (ret == JAYLINK_ERR_NOT_AVAILABLE) {
606 continue;
607 } else if (ret != JAYLINK_OK) {
608 LOG_WARNING("jaylink_device_get_serial_number() failed: %s.",
609 jaylink_strerror(ret));
610 continue;
611 }
612
613 if (serial_number != tmp)
614 continue;
615 }
616
617 if (use_usb_address) {
618 ret = jaylink_device_get_usb_address(devs[i], &address);
619
620 if (ret == JAYLINK_ERR_NOT_SUPPORTED) {
621 continue;
622 } else if (ret != JAYLINK_OK) {
623 LOG_WARNING("jaylink_device_get_usb_address() failed: %s.",
624 jaylink_strerror(ret));
625 continue;
626 }
627
628 if (usb_address != address)
629 continue;
630 }
631
632 ret = jaylink_open(devs[i], &devh);
633
634 if (ret == JAYLINK_OK) {
635 found_device = true;
636 break;
637 }
638
639 LOG_ERROR("Failed to open device: %s.", jaylink_strerror(ret));
640 }
641
642 jaylink_free_devices(devs, true);
643
644 if (!found_device) {
645 LOG_ERROR("No J-Link device found.");
646 jaylink_exit(jayctx);
647 return ERROR_JTAG_INIT_FAILED;
648 }
649
650 /*
651 * Be careful with changing the following initialization sequence because
652 * some devices are known to be sensitive regarding the order.
653 */
654
655 ret = jaylink_get_firmware_version(devh, &firmware_version, &length);
656
657 if (ret != JAYLINK_OK) {
658 LOG_ERROR("jaylink_get_firmware_version() failed: %s.",
659 jaylink_strerror(ret));
660 jaylink_close(devh);
661 jaylink_exit(jayctx);
662 return ERROR_JTAG_INIT_FAILED;
663 } else if (length > 0) {
664 LOG_INFO("%s", firmware_version);
665 free(firmware_version);
666 } else {
667 LOG_WARNING("Device responds empty firmware version string.");
668 }
669
670 memset(caps, 0, JAYLINK_DEV_EXT_CAPS_SIZE);
671 ret = jaylink_get_caps(devh, caps);
672
673 if (ret != JAYLINK_OK) {
674 LOG_ERROR("jaylink_get_caps() failed: %s.", jaylink_strerror(ret));
675 jaylink_close(devh);
676 jaylink_exit(jayctx);
677 return ERROR_JTAG_INIT_FAILED;
678 }
679
680 if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_EXT_CAPS)) {
681 ret = jaylink_get_extended_caps(devh, caps);
682
683 if (ret != JAYLINK_OK) {
684 LOG_ERROR("jaylink_get_extended_caps() failed: %s.",
685 jaylink_strerror(ret));
686 jaylink_close(devh);
687 jaylink_exit(jayctx);
688 return ERROR_JTAG_INIT_FAILED;
689 }
690 }
691
692 jtag_command_version = JAYLINK_JTAG_VERSION_2;
693
694 if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_HW_VERSION)) {
695 ret = jaylink_get_hardware_version(devh, &hwver);
696
697 if (ret != JAYLINK_OK) {
698 LOG_ERROR("Failed to retrieve hardware version: %s.",
699 jaylink_strerror(ret));
700 jaylink_close(devh);
701 jaylink_exit(jayctx);
702 return ERROR_JTAG_INIT_FAILED;
703 }
704
705 LOG_INFO("Hardware version: %u.%02u", hwver.major, hwver.minor);
706
707 if (hwver.major >= 5)
708 jtag_command_version = JAYLINK_JTAG_VERSION_3;
709 }
710
711 if (iface == JAYLINK_TIF_SWD) {
712 /*
713 * Adjust the SWD transaction buffer size in case there is already
714 * allocated memory on the device. This happens for example if the
715 * memory for SWO capturing is still allocated because the software
716 * which used the device before has not been shut down properly.
717 */
718 if (!adjust_swd_buffer_size()) {
719 jaylink_close(devh);
720 jaylink_exit(jayctx);
721 return ERROR_JTAG_INIT_FAILED;
722 }
723 }
724
725 if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
726 if (!read_device_config(&config)) {
727 LOG_ERROR("Failed to read device configuration data.");
728 jaylink_close(devh);
729 jaylink_exit(jayctx);
730 return ERROR_JTAG_INIT_FAILED;
731 }
732
733 memcpy(&tmp_config, &config, sizeof(struct device_config));
734 }
735
736 ret = jaylink_get_hardware_status(devh, &hwstatus);
737
738 if (ret != JAYLINK_OK) {
739 LOG_ERROR("jaylink_get_hardware_status() failed: %s.",
740 jaylink_strerror(ret));
741 jaylink_close(devh);
742 jaylink_exit(jayctx);
743 return ERROR_JTAG_INIT_FAILED;
744 }
745
746 LOG_INFO("VTarget = %u.%03u V", hwstatus.target_voltage / 1000,
747 hwstatus.target_voltage % 1000);
748
749 conn.handle = 0;
750 conn.pid = 0;
751 strcpy(conn.hid, "0.0.0.0");
752 conn.iid = 0;
753 conn.cid = 0;
754
755 ret = jlink_register();
756
757 if (ret != ERROR_OK) {
758 jaylink_close(devh);
759 jaylink_exit(jayctx);
760 return ERROR_JTAG_INIT_FAILED;
761 }
762
763 ret = select_interface();
764
765 if (ret != ERROR_OK) {
766 jaylink_close(devh);
767 jaylink_exit(jayctx);
768 return ret;
769 }
770
771 jlink_reset(0, 0);
772 jtag_sleep(3000);
773 jlink_tap_init();
774
775 jlink_speed(jtag_get_speed_khz());
776
777 if (iface == JAYLINK_TIF_JTAG) {
778 /*
779 * J-Link devices with firmware version v5 and v6 seems to have an issue
780 * if the first tap move is not divisible by 8, so we send a TLR on
781 * first power up.
782 */
783 uint8_t tms = 0xff;
784 jlink_clock_data(NULL, 0, &tms, 0, NULL, 0, 8);
785
786 jlink_flush();
787 }
788
789 return ERROR_OK;
790 }
791
792 static int jlink_quit(void)
793 {
794 int ret;
795 size_t count;
796
797 if (trace_enabled) {
798 ret = jaylink_swo_stop(devh);
799
800 if (ret != JAYLINK_OK)
801 LOG_ERROR("jaylink_swo_stop() failed: %s.", jaylink_strerror(ret));
802 }
803
804 if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_REGISTER)) {
805 ret = jaylink_unregister(devh, &conn, connlist, &count);
806
807 if (ret != JAYLINK_OK)
808 LOG_ERROR("jaylink_unregister() failed: %s.",
809 jaylink_strerror(ret));
810 }
811
812 jaylink_close(devh);
813 jaylink_exit(jayctx);
814
815 return ERROR_OK;
816 }
817
818 /***************************************************************************/
819 /* Queue command implementations */
820
821 static void jlink_end_state(tap_state_t state)
822 {
823 if (tap_is_state_stable(state))
824 tap_set_end_state(state);
825 else {
826 LOG_ERROR("BUG: %i is not a valid end state", state);
827 exit(-1);
828 }
829 }
830
831 /* Goes to the end state. */
832 static void jlink_state_move(void)
833 {
834 uint8_t tms_scan;
835 uint8_t tms_scan_bits;
836
837 tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
838 tms_scan_bits = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
839
840 jlink_clock_data(NULL, 0, &tms_scan, 0, NULL, 0, tms_scan_bits);
841
842 tap_set_state(tap_get_end_state());
843 }
844
845 static void jlink_path_move(int num_states, tap_state_t *path)
846 {
847 int i;
848 uint8_t tms = 0xff;
849
850 for (i = 0; i < num_states; i++) {
851 if (path[i] == tap_state_transition(tap_get_state(), false))
852 jlink_clock_data(NULL, 0, NULL, 0, NULL, 0, 1);
853 else if (path[i] == tap_state_transition(tap_get_state(), true))
854 jlink_clock_data(NULL, 0, &tms, 0, NULL, 0, 1);
855 else {
856 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition.",
857 tap_state_name(tap_get_state()), tap_state_name(path[i]));
858 exit(-1);
859 }
860
861 tap_set_state(path[i]);
862 }
863
864 tap_set_end_state(tap_get_state());
865 }
866
867 static void jlink_stableclocks(int num_cycles)
868 {
869 int i;
870
871 uint8_t tms = tap_get_state() == TAP_RESET;
872 /* Execute num_cycles. */
873 for (i = 0; i < num_cycles; i++)
874 jlink_clock_data(NULL, 0, &tms, 0, NULL, 0, 1);
875 }
876
877 static void jlink_runtest(int num_cycles)
878 {
879 tap_state_t saved_end_state = tap_get_end_state();
880
881 /* Only do a state_move when we're not already in IDLE. */
882 if (tap_get_state() != TAP_IDLE) {
883 jlink_end_state(TAP_IDLE);
884 jlink_state_move();
885 /* num_cycles--; */
886 }
887
888 jlink_stableclocks(num_cycles);
889
890 /* Finish in end_state. */
891 jlink_end_state(saved_end_state);
892
893 if (tap_get_state() != tap_get_end_state())
894 jlink_state_move();
895 }
896
897 static void jlink_reset(int trst, int srst)
898 {
899 LOG_DEBUG("TRST: %i, SRST: %i.", trst, srst);
900
901 /* Signals are active low. */
902 if (srst == 0)
903 jaylink_set_reset(devh);
904
905 if (srst == 1)
906 jaylink_clear_reset(devh);
907
908 if (trst == 1)
909 jaylink_jtag_clear_trst(devh);
910
911 if (trst == 0)
912 jaylink_jtag_set_trst(devh);
913 }
914
915 COMMAND_HANDLER(jlink_usb_command)
916 {
917 int tmp;
918
919 if (CMD_ARGC != 1) {
920 command_print(CMD_CTX, "Need exactly one argument for jlink usb.");
921 return ERROR_COMMAND_SYNTAX_ERROR;
922 }
923
924 if (sscanf(CMD_ARGV[0], "%i", &tmp) != 1) {
925 command_print(CMD_CTX, "Invalid USB address: %s.", CMD_ARGV[0]);
926 return ERROR_FAIL;
927 }
928
929 if (tmp < JAYLINK_USB_ADDRESS_0 || tmp > JAYLINK_USB_ADDRESS_3) {
930 command_print(CMD_CTX, "Invalid USB address: %s.", CMD_ARGV[0]);
931 return ERROR_FAIL;
932 }
933
934 usb_address = tmp;
935
936 use_serial_number = false;
937 use_usb_address = true;
938
939 return ERROR_OK;
940 }
941
942 COMMAND_HANDLER(jlink_serial_command)
943 {
944 int ret;
945
946 if (CMD_ARGC != 1) {
947 command_print(CMD_CTX, "Need exactly one argument for jlink serial.");
948 return ERROR_COMMAND_SYNTAX_ERROR;
949 }
950
951 ret = jaylink_parse_serial_number(CMD_ARGV[0], &serial_number);
952
953 if (ret == JAYLINK_ERR) {
954 command_print(CMD_CTX, "Invalid serial number: %s.", CMD_ARGV[0]);
955 return ERROR_FAIL;
956 } else if (ret != JAYLINK_OK) {
957 command_print(CMD_CTX, "jaylink_parse_serial_number() failed: %s.",
958 jaylink_strerror(ret));
959 return ERROR_FAIL;
960 }
961
962 use_serial_number = true;
963 use_usb_address = false;
964
965 return ERROR_OK;
966 }
967
968 COMMAND_HANDLER(jlink_handle_hwstatus_command)
969 {
970 int ret;
971 struct jaylink_hardware_status status;
972
973 ret = jaylink_get_hardware_status(devh, &status);
974
975 if (ret != JAYLINK_OK) {
976 command_print(CMD_CTX, "jaylink_get_hardware_status() failed: %s.",
977 jaylink_strerror(ret));
978 return ERROR_FAIL;
979 }
980
981 command_print(CMD_CTX, "VTarget = %u.%03u V",
982 status.target_voltage / 1000, status.target_voltage % 1000);
983
984 command_print(CMD_CTX, "TCK = %u TDI = %u TDO = %u TMS = %u SRST = %u "
985 "TRST = %u", status.tck, status.tdi, status.tdo, status.tms,
986 status.tres, status.trst);
987
988 if (status.target_voltage < 1500)
989 command_print(CMD_CTX, "Target voltage too low. Check target power.");
990
991 return ERROR_OK;
992 }
993
994 COMMAND_HANDLER(jlink_handle_free_memory_command)
995 {
996 int ret;
997 uint32_t tmp;
998
999 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_FREE_MEMORY)) {
1000 command_print(CMD_CTX, "Retrieval of free memory is not supported by "
1001 "the device.");
1002 return ERROR_OK;
1003 }
1004
1005 ret = jaylink_get_free_memory(devh, &tmp);
1006
1007 if (ret != JAYLINK_OK) {
1008 command_print(CMD_CTX, "jaylink_get_free_memory() failed: %s.",
1009 jaylink_strerror(ret));
1010 return ERROR_FAIL;
1011 }
1012
1013 command_print(CMD_CTX, "Device has %u bytes of free memory.", tmp);
1014
1015 return ERROR_OK;
1016 }
1017
1018 COMMAND_HANDLER(jlink_handle_jlink_jtag_command)
1019 {
1020 int tmp;
1021 int version;
1022
1023 if (!CMD_ARGC) {
1024 switch (jtag_command_version) {
1025 case JAYLINK_JTAG_VERSION_2:
1026 version = 2;
1027 break;
1028 case JAYLINK_JTAG_VERSION_3:
1029 version = 3;
1030 break;
1031 default:
1032 return ERROR_FAIL;
1033 }
1034
1035 command_print(CMD_CTX, "JTAG command version: %i", version);
1036 } else if (CMD_ARGC == 1) {
1037 if (sscanf(CMD_ARGV[0], "%i", &tmp) != 1) {
1038 command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]);
1039 return ERROR_COMMAND_SYNTAX_ERROR;
1040 }
1041
1042 switch (tmp) {
1043 case 2:
1044 jtag_command_version = JAYLINK_JTAG_VERSION_2;
1045 break;
1046 case 3:
1047 jtag_command_version = JAYLINK_JTAG_VERSION_3;
1048 break;
1049 default:
1050 command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]);
1051 return ERROR_COMMAND_SYNTAX_ERROR;
1052 }
1053 } else {
1054 command_print(CMD_CTX, "Need exactly one argument for jlink jtag.");
1055 return ERROR_COMMAND_SYNTAX_ERROR;
1056 }
1057
1058 return ERROR_OK;
1059 }
1060
1061 COMMAND_HANDLER(jlink_handle_target_power_command)
1062 {
1063 int ret;
1064 int enable;
1065
1066 if (CMD_ARGC != 1) {
1067 command_print(CMD_CTX, "Need exactly one argument for jlink "
1068 "targetpower.");
1069 return ERROR_COMMAND_SYNTAX_ERROR;
1070 }
1071
1072 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_SET_TARGET_POWER)) {
1073 command_print(CMD_CTX, "Target power supply is not supported by the "
1074 "device.");
1075 return ERROR_OK;
1076 }
1077
1078 if (!strcmp(CMD_ARGV[0], "on")) {
1079 enable = true;
1080 } else if (!strcmp(CMD_ARGV[0], "off")) {
1081 enable = false;
1082 } else {
1083 command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]);
1084 return ERROR_FAIL;
1085 }
1086
1087 ret = jaylink_set_target_power(devh, enable);
1088
1089 if (ret != JAYLINK_OK) {
1090 command_print(CMD_CTX, "jaylink_set_target_power() failed: %s.",
1091 jaylink_strerror(ret));
1092 return ERROR_FAIL;
1093 }
1094
1095 return ERROR_OK;
1096 }
1097
1098 static void show_config_usb_address(struct command_context *ctx)
1099 {
1100 if (config.usb_address != tmp_config.usb_address)
1101 command_print(ctx, "USB address: %u [%u]", config.usb_address,
1102 tmp_config.usb_address);
1103 else
1104 command_print(ctx, "USB address: %u", config.usb_address);
1105 }
1106
1107 static void show_config_ip_address(struct command_context *ctx)
1108 {
1109 if (!memcmp(config.ip_address, tmp_config.ip_address, 4))
1110 command_print(ctx, "IP address: %d.%d.%d.%d",
1111 config.ip_address[3], config.ip_address[2],
1112 config.ip_address[1], config.ip_address[0]);
1113 else
1114 command_print(ctx, "IP address: %d.%d.%d.%d [%d.%d.%d.%d]",
1115 config.ip_address[3], config.ip_address[2],
1116 config.ip_address[1], config.ip_address[0],
1117 tmp_config.ip_address[3], tmp_config.ip_address[2],
1118 tmp_config.ip_address[1], tmp_config.ip_address[0]);
1119
1120 if (!memcmp(config.subnet_mask, tmp_config.subnet_mask, 4))
1121 command_print(ctx, "Subnet mask: %d.%d.%d.%d",
1122 config.subnet_mask[3], config.subnet_mask[2],
1123 config.subnet_mask[1], config.subnet_mask[0]);
1124 else
1125 command_print(ctx, "Subnet mask: %d.%d.%d.%d [%d.%d.%d.%d]",
1126 config.subnet_mask[3], config.subnet_mask[2],
1127 config.subnet_mask[1], config.subnet_mask[0],
1128 tmp_config.subnet_mask[3], tmp_config.subnet_mask[2],
1129 tmp_config.subnet_mask[1], tmp_config.subnet_mask[0]);
1130 }
1131
1132 static void show_config_mac_address(struct command_context *ctx)
1133 {
1134 if (!memcmp(config.mac_address, tmp_config.mac_address, 6))
1135 command_print(ctx, "MAC address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x",
1136 config.mac_address[5], config.mac_address[4],
1137 config.mac_address[3], config.mac_address[2],
1138 config.mac_address[1], config.mac_address[0]);
1139 else
1140 command_print(ctx, "MAC address: %.02x:%.02x:%.02x:%.02x:%.02x:%.02x "
1141 "[%.02x:%.02x:%.02x:%.02x:%.02x:%.02x]",
1142 config.mac_address[5], config.mac_address[4],
1143 config.mac_address[3], config.mac_address[2],
1144 config.mac_address[1], config.mac_address[0],
1145 tmp_config.mac_address[5], tmp_config.mac_address[4],
1146 tmp_config.mac_address[3], tmp_config.mac_address[2],
1147 tmp_config.mac_address[1], tmp_config.mac_address[0]);
1148 }
1149
1150 static void show_config_target_power(struct command_context *ctx)
1151 {
1152 const char *target_power;
1153 const char *current_target_power;
1154
1155 if (!config.target_power)
1156 target_power = "off";
1157 else
1158 target_power = "on";
1159
1160 if (!tmp_config.target_power)
1161 current_target_power = "off";
1162 else
1163 current_target_power = "on";
1164
1165 if (config.target_power != tmp_config.target_power)
1166 command_print(ctx, "Target power supply: %s [%s]", target_power,
1167 current_target_power);
1168 else
1169 command_print(ctx, "Target power supply: %s", target_power);
1170 }
1171
1172 static void show_config(struct command_context *ctx)
1173 {
1174 command_print(ctx, "J-Link device configuration:");
1175
1176 show_config_usb_address(ctx);
1177
1178 if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_SET_TARGET_POWER))
1179 show_config_target_power(ctx);
1180
1181 if (jaylink_has_cap(caps, JAYLINK_DEV_CAP_ETHERNET)) {
1182 show_config_ip_address(ctx);
1183 show_config_mac_address(ctx);
1184 }
1185 }
1186
1187 static int poll_trace(uint8_t *buf, size_t *size)
1188 {
1189 int ret;
1190 uint32_t length;
1191
1192 length = *size;
1193
1194 ret = jaylink_swo_read(devh, buf, &length);
1195
1196 if (ret != JAYLINK_OK) {
1197 LOG_ERROR("jaylink_swo_read() failed: %s.", jaylink_strerror(ret));
1198 return ERROR_FAIL;
1199 }
1200
1201 *size = length;
1202
1203 return ERROR_OK;
1204 }
1205
1206 static uint32_t calculate_trace_buffer_size(void)
1207 {
1208 int ret;
1209 uint32_t tmp;
1210
1211 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_GET_FREE_MEMORY))
1212 return 0;
1213
1214 ret = jaylink_get_free_memory(devh, &tmp);
1215
1216 if (ret != JAYLINK_OK) {
1217 LOG_ERROR("jaylink_get_free_memory() failed: %s.",
1218 jaylink_strerror(ret));
1219 return ERROR_FAIL;
1220 }
1221
1222 if (tmp > 0x3fff || tmp <= 0x600)
1223 tmp = tmp >> 1;
1224 else
1225 tmp = tmp - 0x400;
1226
1227 return tmp & 0xffffff00;
1228 }
1229
1230 static bool check_trace_freq(struct jaylink_swo_speed speed,
1231 uint32_t trace_freq)
1232 {
1233 double min;
1234 double deviation;
1235 uint32_t divider;
1236
1237 min = fabs(1.0 - (speed.freq / ((double)trace_freq * speed.min_div)));
1238
1239 for (divider = speed.min_div; divider < speed.max_div; divider++) {
1240 deviation = fabs(1.0 - (speed.freq / ((double)trace_freq * divider)));
1241
1242 if (deviation < 0.03) {
1243 LOG_DEBUG("Found suitable frequency divider %u with deviation of "
1244 "%.02f %%.", divider, deviation);
1245 return true;
1246 }
1247
1248 if (deviation < min)
1249 min = deviation;
1250 }
1251
1252 LOG_ERROR("Selected trace frequency is not supported by the device. "
1253 "Please choose a different trace frequency.");
1254 LOG_ERROR("Maximum permitted deviation is 3.00 %%, but only %.02f %% "
1255 "could be achieved.", min * 100);
1256
1257 return false;
1258 }
1259
1260 static int config_trace(bool enabled, enum tpio_pin_protocol pin_protocol,
1261 uint32_t port_size, unsigned int *trace_freq)
1262 {
1263 int ret;
1264 uint32_t buffer_size;
1265 struct jaylink_swo_speed speed;
1266
1267 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_SWO)) {
1268 LOG_ERROR("Trace capturing is not supported by the device.");
1269 return ERROR_FAIL;
1270 }
1271
1272 if (pin_protocol != ASYNC_UART) {
1273 LOG_ERROR("Selected pin protocol is not supported.");
1274 return ERROR_FAIL;
1275 }
1276
1277 trace_enabled = enabled;
1278
1279 ret = jaylink_swo_stop(devh);
1280
1281 if (ret != JAYLINK_OK) {
1282 LOG_ERROR("jaylink_swo_stop() failed: %s.", jaylink_strerror(ret));
1283 return ERROR_FAIL;
1284 }
1285
1286 if (!enabled) {
1287 /*
1288 * Adjust the SWD transaction buffer size as stopping SWO capturing
1289 * deallocates device internal memory.
1290 */
1291 if (!adjust_swd_buffer_size())
1292 return ERROR_FAIL;
1293
1294 return ERROR_OK;
1295 }
1296
1297 buffer_size = calculate_trace_buffer_size();
1298
1299 if (!buffer_size) {
1300 LOG_ERROR("Not enough free device memory to start trace capturing.");
1301 return ERROR_FAIL;
1302 }
1303
1304 ret = jaylink_swo_get_speeds(devh, JAYLINK_SWO_MODE_UART, &speed);
1305
1306 if (ret != JAYLINK_OK) {
1307 LOG_ERROR("jaylink_swo_get_speeds() failed: %s.",
1308 jaylink_strerror(ret));
1309 return ERROR_FAIL;
1310 }
1311
1312 if (!*trace_freq)
1313 *trace_freq = speed.freq / speed.min_div;
1314
1315 if (!check_trace_freq(speed, *trace_freq))
1316 return ERROR_FAIL;
1317
1318 LOG_DEBUG("Using %u bytes device memory for trace capturing.", buffer_size);
1319
1320 ret = jaylink_swo_start(devh, JAYLINK_SWO_MODE_UART, *trace_freq,
1321 buffer_size);
1322
1323 if (ret != JAYLINK_OK) {
1324 LOG_ERROR("jaylink_start_swo() failed: %s.", jaylink_strerror(ret));
1325 return ERROR_FAIL;
1326 }
1327
1328 /*
1329 * Adjust the SWD transaction buffer size as starting SWO capturing
1330 * allocates device internal memory.
1331 */
1332 if (!adjust_swd_buffer_size())
1333 return ERROR_FAIL;
1334
1335 return ERROR_OK;
1336 }
1337
1338 COMMAND_HANDLER(jlink_handle_config_usb_address_command)
1339 {
1340 uint8_t tmp;
1341
1342 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1343 command_print(CMD_CTX, "Reading configuration is not supported by the "
1344 "device.");
1345 return ERROR_OK;
1346 }
1347
1348 if (!CMD_ARGC) {
1349 show_config_usb_address(CMD_CTX);
1350 } else if (CMD_ARGC == 1) {
1351 if (sscanf(CMD_ARGV[0], "%" SCNd8, &tmp) != 1) {
1352 command_print(CMD_CTX, "Invalid USB address: %s.", CMD_ARGV[0]);
1353 return ERROR_FAIL;
1354 }
1355
1356 if (tmp > JAYLINK_USB_ADDRESS_3) {
1357 command_print(CMD_CTX, "Invalid USB address: %u.", tmp);
1358 return ERROR_FAIL;
1359 }
1360
1361 tmp_config.usb_address = tmp;
1362 } else {
1363 command_print(CMD_CTX, "Need exactly one argument for jlink config "
1364 "usb.");
1365 return ERROR_COMMAND_SYNTAX_ERROR;
1366 }
1367
1368 return ERROR_OK;
1369 }
1370
1371 COMMAND_HANDLER(jlink_handle_config_target_power_command)
1372 {
1373 int enable;
1374
1375 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1376 command_print(CMD_CTX, "Reading configuration is not supported by the "
1377 "device.");
1378 return ERROR_OK;
1379 }
1380
1381 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_SET_TARGET_POWER)) {
1382 command_print(CMD_CTX, "Target power supply is not supported by the "
1383 "device.");
1384 return ERROR_OK;
1385 }
1386
1387 if (!CMD_ARGC) {
1388 show_config_target_power(CMD_CTX);
1389 } else if (CMD_ARGC == 1) {
1390 if (!strcmp(CMD_ARGV[0], "on")) {
1391 enable = true;
1392 } else if (!strcmp(CMD_ARGV[0], "off")) {
1393 enable = false;
1394 } else {
1395 command_print(CMD_CTX, "Invalid argument: %s.", CMD_ARGV[0]);
1396 return ERROR_FAIL;
1397 }
1398
1399 tmp_config.target_power = enable;
1400 } else {
1401 command_print(CMD_CTX, "Need exactly one argument for jlink config "
1402 "targetpower.");
1403 return ERROR_COMMAND_SYNTAX_ERROR;
1404 }
1405
1406 return ERROR_OK;
1407 }
1408
1409 COMMAND_HANDLER(jlink_handle_config_mac_address_command)
1410 {
1411 uint8_t addr[6];
1412 int i;
1413 char *e;
1414 const char *str;
1415
1416 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1417 command_print(CMD_CTX, "Reading configuration is not supported by the "
1418 "device.");
1419 return ERROR_OK;
1420 }
1421
1422 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_ETHERNET)) {
1423 command_print(CMD_CTX, "Ethernet connectivity is not supported by the "
1424 "device.");
1425 return ERROR_OK;
1426 }
1427
1428 if (!CMD_ARGC) {
1429 show_config_mac_address(CMD_CTX);
1430 } else if (CMD_ARGC == 1) {
1431 str = CMD_ARGV[0];
1432
1433 if ((strlen(str) != 17) || (str[2] != ':' || str[5] != ':' || \
1434 str[8] != ':' || str[11] != ':' || str[14] != ':')) {
1435 command_print(CMD_CTX, "Invalid MAC address format.");
1436 return ERROR_COMMAND_SYNTAX_ERROR;
1437 }
1438
1439 for (i = 5; i >= 0; i--) {
1440 addr[i] = strtoul(str, &e, 16);
1441 str = e + 1;
1442 }
1443
1444 if (!(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5])) {
1445 command_print(CMD_CTX, "Invalid MAC address: zero address.");
1446 return ERROR_COMMAND_SYNTAX_ERROR;
1447 }
1448
1449 if (!(0x01 & addr[0])) {
1450 command_print(CMD_CTX, "Invalid MAC address: multicast address.");
1451 return ERROR_COMMAND_SYNTAX_ERROR;
1452 }
1453
1454 memcpy(tmp_config.mac_address, addr, sizeof(addr));
1455 } else {
1456 command_print(CMD_CTX, "Need exactly one argument for jlink config "
1457 " mac.");
1458 return ERROR_COMMAND_SYNTAX_ERROR;
1459 }
1460
1461 return ERROR_OK;
1462 }
1463
1464 static bool string_to_ip(const char *s, uint8_t *ip, int *pos)
1465 {
1466 uint8_t lip[4];
1467 char *e;
1468 const char *s_save = s;
1469 int i;
1470
1471 if (!s)
1472 return false;
1473
1474 for (i = 0; i < 4; i++) {
1475 lip[i] = strtoul(s, &e, 10);
1476
1477 if (*e != '.' && i != 3)
1478 return false;
1479
1480 s = e + 1;
1481 }
1482
1483 *pos = e - s_save;
1484 memcpy(ip, lip, sizeof(lip));
1485
1486 return true;
1487 }
1488
1489 static void cpy_ip(uint8_t *dst, uint8_t *src)
1490 {
1491 int i, j;
1492
1493 for (i = 0, j = 3; i < 4; i++, j--)
1494 dst[i] = src[j];
1495 }
1496
1497 COMMAND_HANDLER(jlink_handle_config_ip_address_command)
1498 {
1499 uint8_t ip_address[4];
1500 uint32_t subnet_mask = 0;
1501 int i, len;
1502 uint8_t subnet_bits = 24;
1503
1504 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1505 command_print(CMD_CTX, "Reading configuration is not supported by the "
1506 "device.");
1507 return ERROR_OK;
1508 }
1509
1510 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_ETHERNET)) {
1511 command_print(CMD_CTX, "Ethernet connectivity is not supported by the "
1512 "device.");
1513 return ERROR_OK;
1514 }
1515
1516 if (!CMD_ARGC) {
1517 show_config_ip_address(CMD_CTX);
1518 } else {
1519 if (!string_to_ip(CMD_ARGV[0], ip_address, &i))
1520 return ERROR_COMMAND_SYNTAX_ERROR;
1521
1522 len = strlen(CMD_ARGV[0]);
1523
1524 /* Check for format A.B.C.D/E. */
1525 if (i < len) {
1526 if (CMD_ARGV[0][i] != '/')
1527 return ERROR_COMMAND_SYNTAX_ERROR;
1528
1529 COMMAND_PARSE_NUMBER(u8, CMD_ARGV[0] + i + 1, subnet_bits);
1530 } else if (CMD_ARGC > 1) {
1531 if (!string_to_ip(CMD_ARGV[1], (uint8_t *)&subnet_mask, &i))
1532 return ERROR_COMMAND_SYNTAX_ERROR;
1533 }
1534
1535 if (!subnet_mask)
1536 subnet_mask = (uint32_t)(subnet_bits < 32 ?
1537 ((1ULL << subnet_bits) - 1) : 0xffffffff);
1538
1539 cpy_ip(tmp_config.ip_address, ip_address);
1540 cpy_ip(tmp_config.subnet_mask, (uint8_t *)&subnet_mask);
1541 }
1542
1543 return ERROR_OK;
1544 }
1545
1546 COMMAND_HANDLER(jlink_handle_config_reset_command)
1547 {
1548 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG))
1549 return ERROR_OK;
1550
1551 memcpy(&tmp_config, &config, sizeof(struct device_config));
1552
1553 return ERROR_OK;
1554 }
1555
1556
1557 COMMAND_HANDLER(jlink_handle_config_write_command)
1558 {
1559 int ret;
1560
1561 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1562 command_print(CMD_CTX, "Reading configuration is not supported by the "
1563 "device.");
1564 return ERROR_OK;
1565 }
1566
1567 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_WRITE_CONFIG)) {
1568 command_print(CMD_CTX, "Writing configuration is not supported by the "
1569 "device.");
1570 return ERROR_OK;
1571 }
1572
1573 if (!memcmp(&config, &tmp_config, sizeof(struct device_config))) {
1574 command_print(CMD_CTX, "Operation not performed due to no changes in "
1575 "the configuration.");
1576 return ERROR_OK;
1577 }
1578
1579 ret = jaylink_write_raw_config(devh, (const uint8_t *)&tmp_config);
1580
1581 if (ret != JAYLINK_OK) {
1582 LOG_ERROR("jaylink_write_raw_config() failed: %s.",
1583 jaylink_strerror(ret));
1584 return ERROR_FAIL;
1585 }
1586
1587 if (!read_device_config(&config)) {
1588 LOG_ERROR("Failed to read device configuration for verification.");
1589 return ERROR_FAIL;
1590 }
1591
1592 if (memcmp(&config, &tmp_config, sizeof(struct device_config))) {
1593 LOG_ERROR("Verification of device configuration failed. Please check "
1594 "your device.");
1595 return ERROR_FAIL;
1596 }
1597
1598 memcpy(&tmp_config, &config, sizeof(struct device_config));
1599 command_print(CMD_CTX, "The new device configuration applies after power "
1600 "cycling the J-Link device.");
1601
1602 return ERROR_OK;
1603 }
1604
1605 COMMAND_HANDLER(jlink_handle_config_command)
1606 {
1607 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_READ_CONFIG)) {
1608 command_print(CMD_CTX, "Device doesn't support reading configuration.");
1609 return ERROR_OK;
1610 }
1611
1612 if (CMD_ARGC == 0)
1613 show_config(CMD_CTX);
1614
1615 return ERROR_OK;
1616 }
1617
1618 COMMAND_HANDLER(jlink_handle_emucom_write_command)
1619 {
1620 int ret;
1621 size_t tmp;
1622 uint32_t channel;
1623 uint32_t length;
1624 uint8_t *buf;
1625 size_t dummy;
1626
1627 if (CMD_ARGC != 2)
1628 return ERROR_COMMAND_SYNTAX_ERROR;
1629
1630 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_EMUCOM)) {
1631 LOG_ERROR("Device does not support EMUCOM.");
1632 return ERROR_FAIL;
1633 }
1634
1635 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], channel);
1636
1637 tmp = strlen(CMD_ARGV[1]);
1638
1639 if (tmp % 2 != 0) {
1640 LOG_ERROR("Data must be encoded as hexadecimal pairs.");
1641 return ERROR_COMMAND_ARGUMENT_INVALID;
1642 }
1643
1644 buf = malloc(tmp / 2);
1645
1646 if (!buf) {
1647 LOG_ERROR("Failed to allocate buffer.");
1648 return ERROR_FAIL;
1649 }
1650
1651 dummy = unhexify(buf, CMD_ARGV[1], tmp / 2);
1652
1653 if (dummy != (tmp / 2)) {
1654 LOG_ERROR("Data must be encoded as hexadecimal pairs.");
1655 free(buf);
1656 return ERROR_COMMAND_ARGUMENT_INVALID;
1657 }
1658
1659 length = tmp / 2;
1660 ret = jaylink_emucom_write(devh, channel, buf, &length);
1661
1662 free(buf);
1663
1664 if (ret == JAYLINK_ERR_DEV_NOT_SUPPORTED) {
1665 LOG_ERROR("Channel not supported by the device.");
1666 return ERROR_FAIL;
1667 } else if (ret != JAYLINK_OK) {
1668 LOG_ERROR("Failed to write to channel: %s.", jaylink_strerror(ret));
1669 return ERROR_FAIL;
1670 }
1671
1672 if (length != (tmp / 2))
1673 LOG_WARNING("Only %" PRIu32 " bytes written to the channel.", length);
1674
1675 return ERROR_OK;
1676 }
1677
1678 COMMAND_HANDLER(jlink_handle_emucom_read_command)
1679 {
1680 int ret;
1681 uint32_t channel;
1682 uint32_t length;
1683 uint8_t *buf;
1684 size_t tmp;
1685
1686 if (CMD_ARGC != 2)
1687 return ERROR_COMMAND_SYNTAX_ERROR;
1688
1689 if (!jaylink_has_cap(caps, JAYLINK_DEV_CAP_EMUCOM)) {
1690 LOG_ERROR("Device does not support EMUCOM.");
1691 return ERROR_FAIL;
1692 }
1693
1694 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], channel);
1695 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
1696
1697 buf = malloc(length * 3 + 1);
1698
1699 if (!buf) {
1700 LOG_ERROR("Failed to allocate buffer.");
1701 return ERROR_FAIL;
1702 }
1703
1704 ret = jaylink_emucom_read(devh, channel, buf, &length);
1705
1706 if (ret == JAYLINK_ERR_DEV_NOT_SUPPORTED) {
1707 LOG_ERROR("Channel is not supported by the device.");
1708 free(buf);
1709 return ERROR_FAIL;
1710 } else if (ret == JAYLINK_ERR_DEV_NOT_AVAILABLE) {
1711 LOG_ERROR("Channel is not available for the requested amount of data. "
1712 "%" PRIu32 " bytes are avilable.", length);
1713 free(buf);
1714 return ERROR_FAIL;
1715 } else if (ret != JAYLINK_OK) {
1716 LOG_ERROR("Failed to read from channel: %s.", jaylink_strerror(ret));
1717 free(buf);
1718 return ERROR_FAIL;
1719 }
1720
1721 tmp = hexify((char *)buf + length, buf, length, 2 * length + 1);
1722
1723 if (tmp != 2 * length) {
1724 LOG_ERROR("Failed to convert data into hexadecimal string.");
1725 free(buf);
1726 return ERROR_FAIL;
1727 }
1728
1729 command_print(CMD_CTX, "%s", buf + length);
1730 free(buf);
1731
1732 return ERROR_OK;
1733 }
1734
1735 static const struct command_registration jlink_config_subcommand_handlers[] = {
1736 {
1737 .name = "usb",
1738 .handler = &jlink_handle_config_usb_address_command,
1739 .mode = COMMAND_EXEC,
1740 .help = "set the USB address",
1741 .usage = "[0-3]",
1742 },
1743 {
1744 .name = "targetpower",
1745 .handler = &jlink_handle_config_target_power_command,
1746 .mode = COMMAND_EXEC,
1747 .help = "set the target power supply",
1748 .usage = "[on|off]"
1749 },
1750 {
1751 .name = "mac",
1752 .handler = &jlink_handle_config_mac_address_command,
1753 .mode = COMMAND_EXEC,
1754 .help = "set the MAC Address",
1755 .usage = "[ff:ff:ff:ff:ff:ff]",
1756 },
1757 {
1758 .name = "ip",
1759 .handler = &jlink_handle_config_ip_address_command,
1760 .mode = COMMAND_EXEC,
1761 .help = "set the IP address, where A.B.C.D is the IP address, "
1762 "E the bit of the subnet mask, F.G.H.I the subnet mask",
1763 .usage = "[A.B.C.D[/E] [F.G.H.I]]",
1764 },
1765 {
1766 .name = "reset",
1767 .handler = &jlink_handle_config_reset_command,
1768 .mode = COMMAND_EXEC,
1769 .help = "undo configuration changes"
1770 },
1771 {
1772 .name = "write",
1773 .handler = &jlink_handle_config_write_command,
1774 .mode = COMMAND_EXEC,
1775 .help = "write configuration to the device"
1776 },
1777 COMMAND_REGISTRATION_DONE
1778 };
1779
1780 static const struct command_registration jlink_emucom_subcommand_handlers[] = {
1781 {
1782 .name = "write",
1783 .handler = &jlink_handle_emucom_write_command,
1784 .mode = COMMAND_EXEC,
1785 .help = "write to a channel",
1786 .usage = "<channel> <data>",
1787 },
1788 {
1789 .name = "read",
1790 .handler = &jlink_handle_emucom_read_command,
1791 .mode = COMMAND_EXEC,
1792 .help = "read from a channel",
1793 .usage = "<channel> <length>"
1794 },
1795 COMMAND_REGISTRATION_DONE
1796 };
1797
1798 static const struct command_registration jlink_subcommand_handlers[] = {
1799 {
1800 .name = "jtag",
1801 .handler = &jlink_handle_jlink_jtag_command,
1802 .mode = COMMAND_EXEC,
1803 .help = "select the JTAG command version",
1804 .usage = "[2|3]",
1805 },
1806 {
1807 .name = "targetpower",
1808 .handler = &jlink_handle_target_power_command,
1809 .mode = COMMAND_EXEC,
1810 .help = "set the target power supply",
1811 .usage = "<on|off>"
1812 },
1813 {
1814 .name = "freemem",
1815 .handler = &jlink_handle_free_memory_command,
1816 .mode = COMMAND_EXEC,
1817 .help = "show free device memory"
1818 },
1819 {
1820 .name = "hwstatus",
1821 .handler = &jlink_handle_hwstatus_command,
1822 .mode = COMMAND_EXEC,
1823 .help = "show the hardware status"
1824 },
1825 {
1826 .name = "usb",
1827 .handler = &jlink_usb_command,
1828 .mode = COMMAND_CONFIG,
1829 .help = "set the USB address of the device that should be used",
1830 .usage = "<0-3>"
1831 },
1832 {
1833 .name = "serial",
1834 .handler = &jlink_serial_command,
1835 .mode = COMMAND_CONFIG,
1836 .help = "set the serial number of the device that should be used",
1837 .usage = "<serial number>"
1838 },
1839 {
1840 .name = "config",
1841 .handler = &jlink_handle_config_command,
1842 .mode = COMMAND_EXEC,
1843 .help = "access the device configuration. If no argument is given "
1844 "this will show the device configuration",
1845 .chain = jlink_config_subcommand_handlers,
1846 },
1847 {
1848 .name = "emucom",
1849 .mode = COMMAND_EXEC,
1850 .help = "access EMUCOM channel",
1851 .chain = jlink_emucom_subcommand_handlers
1852 },
1853 COMMAND_REGISTRATION_DONE
1854 };
1855
1856 static const struct command_registration jlink_command_handlers[] = {
1857 {
1858 .name = "jlink",
1859 .mode = COMMAND_ANY,
1860 .help = "perform jlink management",
1861 .chain = jlink_subcommand_handlers,
1862 },
1863 COMMAND_REGISTRATION_DONE
1864 };
1865
1866 static int jlink_swd_init(void)
1867 {
1868 iface = JAYLINK_TIF_SWD;
1869
1870 return ERROR_OK;
1871 }
1872
1873 static void jlink_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
1874 {
1875 assert(!(cmd & SWD_CMD_RnW));
1876 jlink_swd_queue_cmd(cmd, NULL, value, ap_delay_clk);
1877 }
1878
1879 static void jlink_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
1880 {
1881 assert(cmd & SWD_CMD_RnW);
1882 jlink_swd_queue_cmd(cmd, value, 0, ap_delay_clk);
1883 }
1884
1885 static int_least32_t jlink_swd_frequency(int_least32_t hz)
1886 {
1887 if (hz > 0)
1888 jlink_speed(hz / 1000);
1889
1890 return hz;
1891 }
1892
1893 /***************************************************************************/
1894 /* J-Link tap functions */
1895
1896 static unsigned tap_length;
1897 /* In SWD mode use tms buffer for direction control */
1898 static uint8_t tms_buffer[JLINK_TAP_BUFFER_SIZE];
1899 static uint8_t tdi_buffer[JLINK_TAP_BUFFER_SIZE];
1900 static uint8_t tdo_buffer[JLINK_TAP_BUFFER_SIZE];
1901
1902 struct pending_scan_result {
1903 /** First bit position in tdo_buffer to read. */
1904 unsigned first;
1905 /** Number of bits to read. */
1906 unsigned length;
1907 /** Location to store the result */
1908 void *buffer;
1909 /** Offset in the destination buffer */
1910 unsigned buffer_offset;
1911 };
1912
1913 #define MAX_PENDING_SCAN_RESULTS 256
1914
1915 static int pending_scan_results_length;
1916 static struct pending_scan_result pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS];
1917
1918 static void jlink_tap_init(void)
1919 {
1920 tap_length = 0;
1921 pending_scan_results_length = 0;
1922 memset(tms_buffer, 0, sizeof(tms_buffer));
1923 memset(tdi_buffer, 0, sizeof(tdi_buffer));
1924 }
1925
1926 static void jlink_clock_data(const uint8_t *out, unsigned out_offset,
1927 const uint8_t *tms_out, unsigned tms_offset,
1928 uint8_t *in, unsigned in_offset,
1929 unsigned length)
1930 {
1931 do {
1932 unsigned available_length = JLINK_TAP_BUFFER_SIZE - tap_length / 8;
1933
1934 if (!available_length ||
1935 (in && pending_scan_results_length == MAX_PENDING_SCAN_RESULTS)) {
1936 if (jlink_flush() != ERROR_OK)
1937 return;
1938 available_length = JLINK_TAP_BUFFER_SIZE;
1939 }
1940
1941 struct pending_scan_result *pending_scan_result =
1942 &pending_scan_results_buffer[pending_scan_results_length];
1943
1944 unsigned scan_length = length > available_length ?
1945 available_length : length;
1946
1947 if (out)
1948 buf_set_buf(out, out_offset, tdi_buffer, tap_length, scan_length);
1949 if (tms_out)
1950 buf_set_buf(tms_out, tms_offset, tms_buffer, tap_length, scan_length);
1951
1952 if (in) {
1953 pending_scan_result->first = tap_length;
1954 pending_scan_result->length = scan_length;
1955 pending_scan_result->buffer = in;
1956 pending_scan_result->buffer_offset = in_offset;
1957 pending_scan_results_length++;
1958 }
1959
1960 tap_length += scan_length;
1961 out_offset += scan_length;
1962 tms_offset += scan_length;
1963 in_offset += scan_length;
1964 length -= scan_length;
1965 } while (length > 0);
1966 }
1967
1968 static int jlink_flush(void)
1969 {
1970 int i;
1971 int ret;
1972
1973 if (!tap_length)
1974 return ERROR_OK;
1975
1976 jlink_last_state = jtag_debug_state_machine(tms_buffer, tdi_buffer,
1977 tap_length, jlink_last_state);
1978
1979 ret = jaylink_jtag_io(devh, tms_buffer, tdi_buffer, tdo_buffer,
1980 tap_length, jtag_command_version);
1981
1982 if (ret != JAYLINK_OK) {
1983 LOG_ERROR("jaylink_jtag_io() failed: %s.", jaylink_strerror(ret));
1984 jlink_tap_init();
1985 return ERROR_JTAG_QUEUE_FAILED;
1986 }
1987
1988 for (i = 0; i < pending_scan_results_length; i++) {
1989 struct pending_scan_result *p = &pending_scan_results_buffer[i];
1990
1991 buf_set_buf(tdo_buffer, p->first, p->buffer,
1992 p->buffer_offset, p->length);
1993
1994 DEBUG_JTAG_IO("Pending scan result, length = %d.", p->length);
1995 }
1996
1997 jlink_tap_init();
1998
1999 return ERROR_OK;
2000 }
2001
2002 static void fill_buffer(uint8_t *buf, uint32_t val, uint32_t len)
2003 {
2004 unsigned int tap_pos = tap_length;
2005
2006 while (len > 32) {
2007 buf_set_u32(buf, tap_pos, 32, val);
2008 len -= 32;
2009 tap_pos += 32;
2010 }
2011
2012 if (len)
2013 buf_set_u32(buf, tap_pos, len, val);
2014 }
2015
2016 static void jlink_queue_data_out(const uint8_t *data, uint32_t len)
2017 {
2018 const uint32_t dir_out = 0xffffffff;
2019
2020 if (data)
2021 bit_copy(tdi_buffer, tap_length, data, 0, len);
2022 else
2023 fill_buffer(tdi_buffer, 0, len);
2024
2025 fill_buffer(tms_buffer, dir_out, len);
2026 tap_length += len;
2027 }
2028
2029 static void jlink_queue_data_in(uint32_t len)
2030 {
2031 const uint32_t dir_in = 0;
2032
2033 fill_buffer(tms_buffer, dir_in, len);
2034 tap_length += len;
2035 }
2036
2037 static int jlink_swd_switch_seq(enum swd_special_seq seq)
2038 {
2039 const uint8_t *s;
2040 unsigned int s_len;
2041
2042 switch (seq) {
2043 case LINE_RESET:
2044 LOG_DEBUG("SWD line reset");
2045 s = swd_seq_line_reset;
2046 s_len = swd_seq_line_reset_len;
2047 break;
2048 case JTAG_TO_SWD:
2049 LOG_DEBUG("JTAG-to-SWD");
2050 s = swd_seq_jtag_to_swd;
2051 s_len = swd_seq_jtag_to_swd_len;
2052 break;
2053 case SWD_TO_JTAG:
2054 LOG_DEBUG("SWD-to-JTAG");
2055 s = swd_seq_swd_to_jtag;
2056 s_len = swd_seq_swd_to_jtag_len;
2057 break;
2058 default:
2059 LOG_ERROR("Sequence %d not supported.", seq);
2060 return ERROR_FAIL;
2061 }
2062
2063 jlink_queue_data_out(s, s_len);
2064
2065 return ERROR_OK;
2066 }
2067
2068 static int jlink_swd_run_queue(void)
2069 {
2070 int i;
2071 int ret;
2072
2073 LOG_DEBUG("Executing %d queued transactions.", pending_scan_results_length);
2074
2075 if (queued_retval != ERROR_OK) {
2076 LOG_DEBUG("Skipping due to previous errors: %d.", queued_retval);
2077 goto skip;
2078 }
2079
2080 /*
2081 * A transaction must be followed by another transaction or at least 8 idle
2082 * cycles to ensure that data is clocked through the AP.
2083 */
2084 jlink_queue_data_out(NULL, 8);
2085
2086 ret = jaylink_swd_io(devh, tms_buffer, tdi_buffer, tdo_buffer, tap_length);
2087
2088 if (ret != JAYLINK_OK) {
2089 LOG_ERROR("jaylink_swd_io() failed: %s.", jaylink_strerror(ret));
2090 goto skip;
2091 }
2092
2093 for (i = 0; i < pending_scan_results_length; i++) {
2094 int ack = buf_get_u32(tdo_buffer, pending_scan_results_buffer[i].first, 3);
2095
2096 if (ack != SWD_ACK_OK) {
2097 LOG_DEBUG("SWD ack not OK: %d %s", ack,
2098 ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK");
2099 queued_retval = ack == SWD_ACK_WAIT ? ERROR_WAIT : ERROR_FAIL;
2100 goto skip;
2101 } else if (pending_scan_results_buffer[i].length) {
2102 uint32_t data = buf_get_u32(tdo_buffer, 3 + pending_scan_results_buffer[i].first, 32);
2103 int parity = buf_get_u32(tdo_buffer, 3 + 32 + pending_scan_results_buffer[i].first, 1);
2104
2105 if (parity != parity_u32(data)) {
2106 LOG_ERROR("SWD: Read data parity mismatch.");
2107 queued_retval = ERROR_FAIL;
2108 goto skip;
2109 }
2110
2111 if (pending_scan_results_buffer[i].buffer)
2112 *(uint32_t *)pending_scan_results_buffer[i].buffer = data;
2113 }
2114 }
2115
2116 skip:
2117 jlink_tap_init();
2118 ret = queued_retval;
2119 queued_retval = ERROR_OK;
2120
2121 return ret;
2122 }
2123
2124 static void jlink_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data, uint32_t ap_delay_clk)
2125 {
2126 uint8_t data_parity_trn[DIV_ROUND_UP(32 + 1, 8)];
2127 if (tap_length + 46 + 8 + ap_delay_clk >= sizeof(tdi_buffer) * 8 ||
2128 pending_scan_results_length == MAX_PENDING_SCAN_RESULTS) {
2129 /* Not enough room in the queue. Run the queue. */
2130 queued_retval = jlink_swd_run_queue();
2131 }
2132
2133 if (queued_retval != ERROR_OK)
2134 return;
2135
2136 cmd |= SWD_CMD_START | SWD_CMD_PARK;
2137
2138 jlink_queue_data_out(&cmd, 8);
2139
2140 pending_scan_results_buffer[pending_scan_results_length].first = tap_length;
2141
2142 if (cmd & SWD_CMD_RnW) {
2143 /* Queue a read transaction. */
2144 pending_scan_results_buffer[pending_scan_results_length].length = 32;
2145 pending_scan_results_buffer[pending_scan_results_length].buffer = dst;
2146
2147 jlink_queue_data_in(1 + 3 + 32 + 1 + 1);
2148 } else {
2149 /* Queue a write transaction. */
2150 pending_scan_results_buffer[pending_scan_results_length].length = 0;
2151 jlink_queue_data_in(1 + 3 + 1);
2152
2153 buf_set_u32(data_parity_trn, 0, 32, data);
2154 buf_set_u32(data_parity_trn, 32, 1, parity_u32(data));
2155
2156 jlink_queue_data_out(data_parity_trn, 32 + 1);
2157 }
2158
2159 pending_scan_results_length++;
2160
2161 /* Insert idle cycles after AP accesses to avoid WAIT. */
2162 if (cmd & SWD_CMD_APnDP)
2163 jlink_queue_data_out(NULL, ap_delay_clk);
2164 }
2165
2166 static const struct swd_driver jlink_swd = {
2167 .init = &jlink_swd_init,
2168 .frequency = &jlink_swd_frequency,
2169 .switch_seq = &jlink_swd_switch_seq,
2170 .read_reg = &jlink_swd_read_reg,
2171 .write_reg = &jlink_swd_write_reg,
2172 .run = &jlink_swd_run_queue,
2173 };
2174
2175 static const char * const jlink_transports[] = { "jtag", "swd", NULL };
2176
2177 struct jtag_interface jlink_interface = {
2178 .name = "jlink",
2179 .commands = jlink_command_handlers,
2180 .transports = jlink_transports,
2181 .swd = &jlink_swd,
2182 .execute_queue = &jlink_execute_queue,
2183 .speed = &jlink_speed,
2184 .speed_div = &jlink_speed_div,
2185 .khz = &jlink_khz,
2186 .init = &jlink_init,
2187 .quit = &jlink_quit,
2188 .config_trace = &config_trace,
2189 .poll_trace = &poll_trace,
2190 };
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)