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