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