Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
nds32: support multi-target debugging
[openocd.git] / src / jtag / aice / aice_pipe.c
1 /***************************************************************************
2 * Copyright (C) 2013 by Andes Technology *
3 * Hsiangkai Wang <hkwang@andestech.com> *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
19 ***************************************************************************/
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #ifdef _WIN32
25 #include <windows.h>
26 #else
27 #include <signal.h>
28 #endif
29
30 #include <helper/log.h>
31 #include <helper/time_support.h>
32 #include "aice_port.h"
33 #include "aice_pipe.h"
34
35 #define AICE_PIPE_MAXLINE 8192
36
37 #ifdef _WIN32
38 PROCESS_INFORMATION proc_info;
39
40 HANDLE aice_pipe_output[2];
41 HANDLE aice_pipe_input[2];
42
43 static int aice_pipe_write(const void *buffer, int count)
44 {
45 BOOL success;
46 DWORD written;
47
48 success = WriteFile(aice_pipe_output[1], buffer, count, &written, NULL);
49 if (!success) {
50 LOG_ERROR("(WIN32) write to pipe failed, error code: 0x%08lx", GetLastError());
51 return -1;
52 }
53
54 return written;
55 }
56
57 static int aice_pipe_read(void *buffer, int count)
58 {
59 BOOL success;
60 DWORD has_read;
61
62 success = ReadFile(aice_pipe_input[0], buffer, count, &has_read, NULL);
63 if (!success || (has_read == 0)) {
64 LOG_ERROR("(WIN32) read from pipe failed, error code: 0x%08lx", GetLastError());
65 return -1;
66 }
67
68 return has_read;
69 }
70
71 static int aice_pipe_child_init(struct aice_port_param_s *param)
72 {
73 STARTUPINFO start_info;
74 BOOL success;
75
76 ZeroMemory(&proc_info, sizeof(PROCESS_INFORMATION));
77 ZeroMemory(&start_info, sizeof(STARTUPINFO));
78 start_info.cb = sizeof(STARTUPINFO);
79 start_info.hStdError = aice_pipe_input[1];
80 start_info.hStdOutput = aice_pipe_input[1];
81 start_info.hStdInput = aice_pipe_output[0];
82 start_info.dwFlags |= STARTF_USESTDHANDLES;
83
84 success = CreateProcess(NULL,
85 param->adapter_name,
86 NULL,
87 NULL,
88 TRUE,
89 0,
90 NULL,
91 NULL,
92 &start_info,
93 &proc_info);
94
95 if (!success) {
96 LOG_ERROR("Create new process failed");
97 return ERROR_FAIL;
98 }
99
100 return ERROR_OK;
101 }
102
103 static int aice_pipe_parent_init(struct aice_port_param_s *param)
104 {
105 /* send open to adapter */
106 char line[AICE_PIPE_MAXLINE];
107 char command[AICE_PIPE_MAXLINE];
108
109 command[0] = AICE_OPEN;
110 set_u16(command + 1, param->vid);
111 set_u16(command + 3, param->pid);
112
113 if (aice_pipe_write(command, 5) != 5) {
114 LOG_ERROR("write failed\n");
115 return ERROR_FAIL;
116 }
117
118 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0) {
119 LOG_ERROR("read failed\n");
120 return ERROR_FAIL;
121 }
122
123 if (line[0] == AICE_OK)
124 return ERROR_OK;
125 else
126 return ERROR_FAIL;
127 }
128
129 static int aice_pipe_open(struct aice_port_param_s *param)
130 {
131 SECURITY_ATTRIBUTES attribute;
132
133 attribute.nLength = sizeof(SECURITY_ATTRIBUTES);
134 attribute.bInheritHandle = TRUE;
135 attribute.lpSecurityDescriptor = NULL;
136
137 if (!CreatePipe(&aice_pipe_output[0], &aice_pipe_output[1],
138 &attribute, AICE_PIPE_MAXLINE)) {
139 LOG_ERROR("Create pipes failed");
140 return ERROR_FAIL;
141 }
142 if (!CreatePipe(&aice_pipe_input[0], &aice_pipe_input[1],
143 &attribute, AICE_PIPE_MAXLINE)) {
144 LOG_ERROR("Create pipes failed");
145 return ERROR_FAIL;
146 }
147
148 /* do not inherit aice_pipe_output[1] & aice_pipe_input[0] to child process */
149 if (!SetHandleInformation(aice_pipe_output[1], HANDLE_FLAG_INHERIT, 0))
150 return ERROR_FAIL;
151 if (!SetHandleInformation(aice_pipe_input[0], HANDLE_FLAG_INHERIT, 0))
152 return ERROR_FAIL;
153
154 aice_pipe_child_init(param);
155
156 aice_pipe_parent_init(param);
157
158 return ERROR_OK;
159 }
160
161 #else
162
163 int aice_pipe_output[2];
164 int aice_pipe_input[2];
165
166 static int aice_pipe_write(const void *buffer, int count)
167 {
168 if (write(aice_pipe_output[1], buffer, count) != count) {
169 LOG_ERROR("write to pipe failed");
170 return -1;
171 }
172
173 return count;
174 }
175
176 static int aice_pipe_read(void *buffer, int count)
177 {
178 int n;
179 long long then, cur;
180
181 then = timeval_ms();
182
183 while (1) {
184 n = read(aice_pipe_input[0], buffer, count);
185
186 if ((n == -1) && (errno == EAGAIN)) {
187 cur = timeval_ms();
188 if (cur - then > 500)
189 keep_alive();
190 continue;
191 } else if (n > 0)
192 break;
193 else {
194 LOG_ERROR("read from pipe failed");
195 break;
196 }
197 }
198
199 return n;
200 }
201
202 static int aice_pipe_child_init(struct aice_port_param_s *param)
203 {
204 close(aice_pipe_output[1]);
205 close(aice_pipe_input[0]);
206
207 if (aice_pipe_output[0] != STDIN_FILENO) {
208 if (dup2(aice_pipe_output[0], STDIN_FILENO) != STDIN_FILENO) {
209 LOG_ERROR("Map aice_pipe to STDIN failed");
210 return ERROR_FAIL;
211 }
212 close(aice_pipe_output[0]);
213 }
214
215 if (aice_pipe_input[1] != STDOUT_FILENO) {
216 if (dup2(aice_pipe_input[1], STDOUT_FILENO) != STDOUT_FILENO) {
217 LOG_ERROR("Map aice_pipe to STDOUT failed");
218 return ERROR_FAIL;
219 }
220 close(aice_pipe_input[1]);
221 }
222
223 if (execl(param->adapter_name, param->adapter_name, (char *)0) < 0) {
224 LOG_ERROR("Execute aice_pipe failed");
225 return ERROR_FAIL;
226 }
227
228 return ERROR_OK;
229 }
230
231 static int aice_pipe_parent_init(struct aice_port_param_s *param)
232 {
233 close(aice_pipe_output[0]);
234 close(aice_pipe_input[1]);
235
236 /* set read end of pipe as non-blocking */
237 if (fcntl(aice_pipe_input[0], F_SETFL, O_NONBLOCK))
238 return ERROR_FAIL;
239
240 /* send open to adapter */
241 char line[AICE_PIPE_MAXLINE];
242 char command[AICE_PIPE_MAXLINE];
243
244 command[0] = AICE_OPEN;
245 set_u16(command + 1, param->vid);
246 set_u16(command + 3, param->pid);
247
248 if (aice_pipe_write(command, 5) != 5) {
249 LOG_ERROR("write failed\n");
250 return ERROR_FAIL;
251 }
252
253 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0) {
254 LOG_ERROR("read failed\n");
255 return ERROR_FAIL;
256 }
257
258 if (line[0] == AICE_OK)
259 return ERROR_OK;
260 else
261 return ERROR_FAIL;
262 }
263
264 static void sig_pipe(int signo)
265 {
266 exit(1);
267 }
268
269 static int aice_pipe_open(struct aice_port_param_s *param)
270 {
271 pid_t pid;
272
273 if (signal(SIGPIPE, sig_pipe) == SIG_ERR) {
274 LOG_ERROR("Register SIGPIPE handler failed");
275 return ERROR_FAIL;
276 }
277
278 if (pipe(aice_pipe_output) < 0 || pipe(aice_pipe_input) < 0) {
279 LOG_ERROR("Create pipes failed");
280 return ERROR_FAIL;
281 }
282
283 pid = fork();
284 if (pid < 0) {
285 LOG_ERROR("Fork new process failed");
286 return ERROR_FAIL;
287 } else if (pid == 0) {
288 if (aice_pipe_child_init(param) != ERROR_OK) {
289 LOG_ERROR("AICE_PIPE child process initial error");
290 return ERROR_FAIL;
291 } else {
292 if (aice_pipe_parent_init(param) != ERROR_OK) {
293 LOG_ERROR("AICE_PIPE parent process initial error");
294 return ERROR_FAIL;
295 }
296 }
297 }
298
299 return ERROR_OK;
300 }
301 #endif
302
303 static int aice_pipe_close(void)
304 {
305 char line[AICE_PIPE_MAXLINE];
306 char command[AICE_PIPE_MAXLINE];
307
308 command[0] = AICE_CLOSE;
309
310 if (aice_pipe_write(command, 1) != 1)
311 return ERROR_FAIL;
312
313 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
314 return ERROR_FAIL;
315
316 if (line[0] == AICE_OK) {
317 #ifdef _WIN32
318 WaitForSingleObject(proc_info.hProcess, INFINITE);
319 CloseHandle(proc_info.hProcess);
320 CloseHandle(proc_info.hThread);
321 #endif
322 return ERROR_OK;
323 } else
324 return ERROR_FAIL;
325 }
326
327 static int aice_pipe_idcode(uint32_t *idcode, uint8_t *num_of_idcode)
328 {
329 char line[AICE_PIPE_MAXLINE];
330 char command[AICE_PIPE_MAXLINE];
331
332 command[0] = AICE_IDCODE;
333
334 if (aice_pipe_write(command, 1) != 1)
335 return ERROR_FAIL;
336
337 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
338 return ERROR_FAIL;
339
340 *num_of_idcode = line[0];
341
342 if ((*num_of_idcode == 0) || (*num_of_idcode >= 16))
343 return ERROR_FAIL;
344
345 for (int i = 0 ; i < *num_of_idcode ; i++)
346 idcode[i] = get_u32(line + i * 4 + 1);
347
348 return ERROR_OK;
349 }
350
351 static int aice_pipe_state(uint32_t coreid, enum aice_target_state_s *state)
352 {
353 char line[AICE_PIPE_MAXLINE];
354 char command[AICE_PIPE_MAXLINE];
355
356 command[0] = AICE_STATE;
357
358 if (aice_pipe_write(command, 1) != 1)
359 return ERROR_FAIL;
360
361 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
362 return ERROR_FAIL;
363
364 *state = (enum aice_target_state_s)line[0];
365
366 return ERROR_OK;
367 }
368
369 static int aice_pipe_reset(void)
370 {
371 char line[AICE_PIPE_MAXLINE];
372 char command[AICE_PIPE_MAXLINE];
373
374 command[0] = AICE_RESET;
375
376 if (aice_pipe_write(command, 1) != 1)
377 return ERROR_FAIL;
378
379 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
380 return ERROR_FAIL;
381
382 if (line[0] == AICE_OK)
383 return ERROR_OK;
384 else
385 return ERROR_FAIL;
386 }
387
388 static int aice_pipe_assert_srst(uint32_t coreid, enum aice_srst_type_s srst)
389 {
390 char line[AICE_PIPE_MAXLINE];
391 char command[AICE_PIPE_MAXLINE];
392
393 command[0] = AICE_ASSERT_SRST;
394 command[1] = srst;
395
396 if (aice_pipe_write(command, 2) != 2)
397 return ERROR_FAIL;
398
399 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
400 return ERROR_FAIL;
401
402 if (line[0] == AICE_OK)
403 return ERROR_OK;
404 else
405 return ERROR_FAIL;
406 }
407
408 static int aice_pipe_run(uint32_t coreid)
409 {
410 char line[AICE_PIPE_MAXLINE];
411 char command[AICE_PIPE_MAXLINE];
412
413 command[0] = AICE_RUN;
414
415 if (aice_pipe_write(command, 1) != 1)
416 return ERROR_FAIL;
417
418 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
419 return ERROR_FAIL;
420
421 if (line[0] == AICE_OK)
422 return ERROR_OK;
423 else
424 return ERROR_FAIL;
425 }
426
427 static int aice_pipe_halt(uint32_t coreid)
428 {
429 char line[AICE_PIPE_MAXLINE];
430 char command[AICE_PIPE_MAXLINE];
431
432 command[0] = AICE_HALT;
433
434 if (aice_pipe_write(command, 1) != 1)
435 return ERROR_FAIL;
436
437 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
438 return ERROR_FAIL;
439
440 if (line[0] == AICE_OK)
441 return ERROR_OK;
442 else
443 return ERROR_FAIL;
444 }
445
446 static int aice_pipe_read_reg(uint32_t coreid, uint32_t num, uint32_t *val)
447 {
448 char line[AICE_PIPE_MAXLINE];
449 char command[AICE_PIPE_MAXLINE];
450
451 command[0] = AICE_READ_REG;
452 set_u32(command + 1, num);
453
454 if (aice_pipe_write(command, 5) != 5)
455 return ERROR_FAIL;
456
457 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
458 return ERROR_FAIL;
459
460 *val = get_u32(line);
461
462 return ERROR_OK;
463 }
464
465 static int aice_pipe_write_reg(uint32_t coreid, uint32_t num, uint32_t val)
466 {
467 char line[AICE_PIPE_MAXLINE];
468 char command[AICE_PIPE_MAXLINE];
469
470 command[0] = AICE_WRITE_REG;
471 set_u32(command + 1, num);
472 set_u32(command + 5, val);
473
474 if (aice_pipe_write(command, 9) != 9)
475 return ERROR_FAIL;
476
477 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
478 return ERROR_FAIL;
479
480 if (line[0] == AICE_OK)
481 return ERROR_OK;
482 else
483 return ERROR_FAIL;
484 }
485
486 static int aice_pipe_read_reg_64(uint32_t coreid, uint32_t num, uint64_t *val)
487 {
488 char line[AICE_PIPE_MAXLINE];
489 char command[AICE_PIPE_MAXLINE];
490
491 command[0] = AICE_READ_REG_64;
492 set_u32(command + 1, num);
493
494 if (aice_pipe_write(command, 5) != 5)
495 return ERROR_FAIL;
496
497 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
498 return ERROR_FAIL;
499
500 *val = (((uint64_t)get_u32(line + 4)) << 32) | get_u32(line);
501
502 return ERROR_OK;
503 }
504
505 static int aice_pipe_write_reg_64(uint32_t coreid, uint32_t num, uint64_t val)
506 {
507 char line[AICE_PIPE_MAXLINE];
508 char command[AICE_PIPE_MAXLINE];
509
510 command[0] = AICE_WRITE_REG_64;
511 set_u32(command + 1, num);
512 set_u32(command + 5, val & 0xFFFFFFFF);
513 set_u32(command + 9, (val >> 32) & 0xFFFFFFFF);
514
515 if (aice_pipe_write(command, 13) != 9)
516 return ERROR_FAIL;
517
518 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
519 return ERROR_FAIL;
520
521 if (line[0] == AICE_OK)
522 return ERROR_OK;
523 else
524 return ERROR_FAIL;
525 }
526
527 static int aice_pipe_step(uint32_t coreid)
528 {
529 char line[AICE_PIPE_MAXLINE];
530 char command[AICE_PIPE_MAXLINE];
531
532 command[0] = AICE_STEP;
533
534 if (aice_pipe_write(command, 1) != 1)
535 return ERROR_FAIL;
536
537 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
538 return ERROR_FAIL;
539
540 if (line[0] == AICE_OK)
541 return ERROR_OK;
542 else
543 return ERROR_FAIL;
544 }
545
546 static int aice_pipe_read_mem_unit(uint32_t coreid, uint32_t addr, uint32_t size,
547 uint32_t count, uint8_t *buffer)
548 {
549 char command[AICE_PIPE_MAXLINE];
550
551 command[0] = AICE_READ_MEM_UNIT;
552 set_u32(command + 1, addr);
553 set_u32(command + 5, size);
554 set_u32(command + 9, count);
555
556 if (aice_pipe_write(command, 13) != 13)
557 return ERROR_FAIL;
558
559 if (aice_pipe_read(buffer, size * count) < 0)
560 return ERROR_FAIL;
561
562 return ERROR_OK;
563 }
564
565 static int aice_pipe_write_mem_unit(uint32_t coreid, uint32_t addr, uint32_t size,
566 uint32_t count, const uint8_t *buffer)
567 {
568 char line[AICE_PIPE_MAXLINE];
569 char command[AICE_PIPE_MAXLINE];
570
571 command[0] = AICE_WRITE_MEM_UNIT;
572 set_u32(command + 1, addr);
573 set_u32(command + 5, size);
574 set_u32(command + 9, count);
575
576 /* WRITE_MEM_UNIT|addr|size|count|data */
577 memcpy(command + 13, buffer, size * count);
578
579 if (aice_pipe_write(command, 13 + size * count) < 0)
580 return ERROR_FAIL;
581
582 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
583 return ERROR_FAIL;
584
585 if (line[0] == AICE_OK)
586 return ERROR_OK;
587 else
588 return ERROR_FAIL;
589
590 return ERROR_OK;
591 }
592
593 static int aice_pipe_read_mem_bulk(uint32_t coreid, uint32_t addr,
594 uint32_t length, uint8_t *buffer)
595 {
596 char line[AICE_PIPE_MAXLINE + 1];
597 char command[AICE_PIPE_MAXLINE];
598 uint32_t remain_len = length;
599 uint32_t prepare_len;
600 char *received_line;
601 uint32_t received_len;
602 int read_len;
603
604 command[0] = AICE_READ_MEM_BULK;
605 set_u32(command + 1, addr);
606 set_u32(command + 5, length);
607
608 if (aice_pipe_write(command, 9) < 0)
609 return ERROR_FAIL;
610
611 while (remain_len > 0) {
612 if (remain_len > AICE_PIPE_MAXLINE)
613 prepare_len = AICE_PIPE_MAXLINE;
614 else
615 prepare_len = remain_len;
616
617 prepare_len++;
618 received_len = 0;
619 received_line = line;
620 do {
621 read_len = aice_pipe_read(received_line, prepare_len - received_len);
622 if (read_len < 0)
623 return ERROR_FAIL;
624 received_line += read_len;
625 received_len += read_len;
626 } while (received_len < prepare_len);
627
628 if (line[0] != AICE_OK)
629 return ERROR_FAIL;
630
631 prepare_len--;
632 memcpy(buffer, line + 1, prepare_len);
633 remain_len -= prepare_len;
634 buffer += prepare_len;
635 }
636
637 return ERROR_OK;
638 }
639
640 static int aice_pipe_write_mem_bulk(uint32_t coreid, uint32_t addr,
641 uint32_t length, const uint8_t *buffer)
642 {
643 char line[AICE_PIPE_MAXLINE];
644 char command[AICE_PIPE_MAXLINE + 4];
645 uint32_t remain_len = length;
646 uint32_t written_len = 0;
647 uint32_t write_len;
648
649 command[0] = AICE_WRITE_MEM_BULK;
650 set_u32(command + 1, addr);
651 set_u32(command + 5, length);
652
653 /* Send command first */
654 if (aice_pipe_write(command, 9) < 0)
655 return ERROR_FAIL;
656
657 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
658 return ERROR_FAIL;
659
660 if (line[0] == AICE_ERROR)
661 return ERROR_FAIL;
662
663 while (remain_len > 0) {
664 if (remain_len > AICE_PIPE_MAXLINE)
665 write_len = AICE_PIPE_MAXLINE;
666 else
667 write_len = remain_len;
668
669 set_u32(command, write_len);
670 memcpy(command + 4, buffer + written_len, write_len); /* data only */
671
672 if (aice_pipe_write(command, write_len + 4) < 0)
673 return ERROR_FAIL;
674
675 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
676 return ERROR_FAIL;
677
678 if (line[0] == AICE_ERROR)
679 return ERROR_FAIL;
680
681 remain_len -= write_len;
682 written_len += write_len;
683 }
684
685 if (line[0] == AICE_OK)
686 return ERROR_OK;
687 else
688 return ERROR_FAIL;
689 }
690
691 static int aice_pipe_read_debug_reg(uint32_t coreid, uint32_t addr, uint32_t *val)
692 {
693 char line[AICE_PIPE_MAXLINE];
694 char command[AICE_PIPE_MAXLINE];
695
696 command[0] = AICE_READ_DEBUG_REG;
697 set_u32(command + 1, addr);
698
699 if (aice_pipe_write(command, 5) != 5)
700 return ERROR_FAIL;
701
702 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
703 return ERROR_FAIL;
704
705 *val = get_u32(line);
706
707 return ERROR_OK;
708 }
709
710 static int aice_pipe_write_debug_reg(uint32_t coreid, uint32_t addr, const uint32_t val)
711 {
712 char line[AICE_PIPE_MAXLINE];
713 char command[AICE_PIPE_MAXLINE];
714
715 command[0] = AICE_WRITE_DEBUG_REG;
716 set_u32(command + 1, addr);
717 set_u32(command + 5, val);
718
719 if (aice_pipe_write(command, 9) != 9)
720 return ERROR_FAIL;
721
722 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
723 return ERROR_FAIL;
724
725 if (line[0] == AICE_OK)
726 return ERROR_OK;
727 else
728 return ERROR_FAIL;
729 }
730
731 static int aice_pipe_set_jtag_clock(uint32_t a_clock)
732 {
733 char line[AICE_PIPE_MAXLINE];
734 char command[AICE_PIPE_MAXLINE];
735
736 command[0] = AICE_SET_JTAG_CLOCK;
737 set_u32(command + 1, a_clock);
738
739 if (aice_pipe_write(command, 5) != 5)
740 return ERROR_FAIL;
741
742 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
743 return ERROR_FAIL;
744
745 if (line[0] == AICE_OK)
746 return ERROR_OK;
747 else
748 return ERROR_FAIL;
749 }
750
751 static int aice_pipe_memory_access(uint32_t coreid, enum nds_memory_access access_channel)
752 {
753 char line[AICE_PIPE_MAXLINE];
754 char command[AICE_PIPE_MAXLINE];
755
756 command[0] = AICE_MEMORY_ACCESS;
757 set_u32(command + 1, access_channel);
758
759 if (aice_pipe_write(command, 5) != 5)
760 return ERROR_FAIL;
761
762 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
763 return ERROR_FAIL;
764
765 if (line[0] == AICE_OK)
766 return ERROR_OK;
767 else
768 return ERROR_FAIL;
769 }
770
771 static int aice_pipe_memory_mode(uint32_t coreid, enum nds_memory_select mem_select)
772 {
773 char line[AICE_PIPE_MAXLINE];
774 char command[AICE_PIPE_MAXLINE];
775
776 command[0] = AICE_MEMORY_MODE;
777 set_u32(command + 1, mem_select);
778
779 if (aice_pipe_write(command, 5) != 5)
780 return ERROR_FAIL;
781
782 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
783 return ERROR_FAIL;
784
785 if (line[0] == AICE_OK)
786 return ERROR_OK;
787 else
788 return ERROR_FAIL;
789 }
790
791 static int aice_pipe_read_tlb(uint32_t coreid, uint32_t virtual_address,
792 uint32_t *physical_address)
793 {
794 char line[AICE_PIPE_MAXLINE];
795 char command[AICE_PIPE_MAXLINE];
796
797 command[0] = AICE_READ_TLB;
798 set_u32(command + 1, virtual_address);
799
800 if (aice_pipe_write(command, 5) != 5)
801 return ERROR_FAIL;
802
803 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
804 return ERROR_FAIL;
805
806 if (line[0] == AICE_OK) {
807 *physical_address = get_u32(line + 1);
808 return ERROR_OK;
809 } else
810 return ERROR_FAIL;
811 }
812
813 static int aice_pipe_cache_ctl(uint32_t coreid, uint32_t subtype, uint32_t address)
814 {
815 char line[AICE_PIPE_MAXLINE];
816 char command[AICE_PIPE_MAXLINE];
817
818 command[0] = AICE_CACHE_CTL;
819 set_u32(command + 1, subtype);
820 set_u32(command + 5, address);
821
822 if (aice_pipe_write(command, 9) != 9)
823 return ERROR_FAIL;
824
825 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
826 return ERROR_FAIL;
827
828 if (line[0] == AICE_OK)
829 return ERROR_OK;
830 else
831 return ERROR_FAIL;
832 }
833
834 static int aice_pipe_set_retry_times(uint32_t a_retry_times)
835 {
836 return ERROR_OK;
837 }
838
839 /** */
840 struct aice_port_api_s aice_pipe = {
841 /** */
842 .open = aice_pipe_open,
843 /** */
844 .close = aice_pipe_close,
845 /** */
846 .idcode = aice_pipe_idcode,
847 /** */
848 .set_jtag_clock = aice_pipe_set_jtag_clock,
849 /** */
850 .state = aice_pipe_state,
851 /** */
852 .reset = aice_pipe_reset,
853 /** */
854 .assert_srst = aice_pipe_assert_srst,
855 /** */
856 .run = aice_pipe_run,
857 /** */
858 .halt = aice_pipe_halt,
859 /** */
860 .step = aice_pipe_step,
861 /** */
862 .read_reg = aice_pipe_read_reg,
863 /** */
864 .write_reg = aice_pipe_write_reg,
865 /** */
866 .read_reg_64 = aice_pipe_read_reg_64,
867 /** */
868 .write_reg_64 = aice_pipe_write_reg_64,
869 /** */
870 .read_mem_unit = aice_pipe_read_mem_unit,
871 /** */
872 .write_mem_unit = aice_pipe_write_mem_unit,
873 /** */
874 .read_mem_bulk = aice_pipe_read_mem_bulk,
875 /** */
876 .write_mem_bulk = aice_pipe_write_mem_bulk,
877 /** */
878 .read_debug_reg = aice_pipe_read_debug_reg,
879 /** */
880 .write_debug_reg = aice_pipe_write_debug_reg,
881
882 /** */
883 .memory_access = aice_pipe_memory_access,
884 /** */
885 .memory_mode = aice_pipe_memory_mode,
886
887 /** */
888 .read_tlb = aice_pipe_read_tlb,
889
890 /** */
891 .cache_ctl = aice_pipe_cache_ctl,
892
893 /** */
894 .set_retry_times = aice_pipe_set_retry_times,
895 };
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)