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