Code Review / openocd.git / blob
? search:


02caa3fe5663358455f4ee1cdcad6b9d44fa9315
[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(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(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(void)
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(void)
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 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 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 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 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(void)
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 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 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 addr, uint32_t length, uint8_t *buffer)
594 {
595 char line[AICE_PIPE_MAXLINE + 1];
596 char command[AICE_PIPE_MAXLINE];
597 uint32_t remain_len = length;
598 uint32_t prepare_len;
599 char *received_line;
600 uint32_t received_len;
601 int read_len;
602
603 command[0] = AICE_READ_MEM_BULK;
604 set_u32(command + 1, addr);
605 set_u32(command + 5, length);
606
607 if (aice_pipe_write(command, 9) < 0)
608 return ERROR_FAIL;
609
610 while (remain_len > 0) {
611 if (remain_len > AICE_PIPE_MAXLINE)
612 prepare_len = AICE_PIPE_MAXLINE;
613 else
614 prepare_len = remain_len;
615
616 prepare_len++;
617 received_len = 0;
618 received_line = line;
619 do {
620 read_len = aice_pipe_read(received_line, prepare_len - received_len);
621 if (read_len < 0)
622 return ERROR_FAIL;
623 received_line += read_len;
624 received_len += read_len;
625 } while (received_len < prepare_len);
626
627 if (line[0] != AICE_OK)
628 return ERROR_FAIL;
629
630 prepare_len--;
631 memcpy(buffer, line + 1, prepare_len);
632 remain_len -= prepare_len;
633 buffer += prepare_len;
634 }
635
636 return ERROR_OK;
637 }
638
639 static int aice_pipe_write_mem_bulk(uint32_t addr, 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 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 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_select_target(uint32_t target_id)
750 {
751 char line[AICE_PIPE_MAXLINE];
752 char command[AICE_PIPE_MAXLINE];
753
754 command[0] = AICE_SELECT_TARGET;
755 set_u32(command + 1, target_id);
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_access(enum nds_memory_access access_channel)
770 {
771 char line[AICE_PIPE_MAXLINE];
772 char command[AICE_PIPE_MAXLINE];
773
774 command[0] = AICE_MEMORY_ACCESS;
775 set_u32(command + 1, access_channel);
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_memory_mode(enum nds_memory_select mem_select)
790 {
791 char line[AICE_PIPE_MAXLINE];
792 char command[AICE_PIPE_MAXLINE];
793
794 command[0] = AICE_MEMORY_MODE;
795 set_u32(command + 1, mem_select);
796
797 if (aice_pipe_write(command, 5) != 5)
798 return ERROR_FAIL;
799
800 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
801 return ERROR_FAIL;
802
803 if (line[0] == AICE_OK)
804 return ERROR_OK;
805 else
806 return ERROR_FAIL;
807 }
808
809 static int aice_pipe_read_tlb(uint32_t virtual_address, uint32_t *physical_address)
810 {
811 char line[AICE_PIPE_MAXLINE];
812 char command[AICE_PIPE_MAXLINE];
813
814 command[0] = AICE_READ_TLB;
815 set_u32(command + 1, virtual_address);
816
817 if (aice_pipe_write(command, 5) != 5)
818 return ERROR_FAIL;
819
820 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
821 return ERROR_FAIL;
822
823 if (line[0] == AICE_OK) {
824 *physical_address = get_u32(line + 1);
825 return ERROR_OK;
826 } else
827 return ERROR_FAIL;
828 }
829
830 static int aice_pipe_cache_ctl(uint32_t subtype, uint32_t address)
831 {
832 char line[AICE_PIPE_MAXLINE];
833 char command[AICE_PIPE_MAXLINE];
834
835 command[0] = AICE_CACHE_CTL;
836 set_u32(command + 1, subtype);
837 set_u32(command + 5, address);
838
839 if (aice_pipe_write(command, 9) != 9)
840 return ERROR_FAIL;
841
842 if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
843 return ERROR_FAIL;
844
845 if (line[0] == AICE_OK)
846 return ERROR_OK;
847 else
848 return ERROR_FAIL;
849 }
850
851 static int aice_pipe_set_retry_times(uint32_t a_retry_times)
852 {
853 return ERROR_OK;
854 }
855
856 /** */
857 struct aice_port_api_s aice_pipe = {
858 /** */
859 .open = aice_pipe_open,
860 /** */
861 .close = aice_pipe_close,
862 /** */
863 .idcode = aice_pipe_idcode,
864 /** */
865 .state = aice_pipe_state,
866 /** */
867 .reset = aice_pipe_reset,
868 /** */
869 .assert_srst = aice_pipe_assert_srst,
870 /** */
871 .run = aice_pipe_run,
872 /** */
873 .halt = aice_pipe_halt,
874 /** */
875 .step = aice_pipe_step,
876 /** */
877 .read_reg = aice_pipe_read_reg,
878 /** */
879 .write_reg = aice_pipe_write_reg,
880 /** */
881 .read_reg_64 = aice_pipe_read_reg_64,
882 /** */
883 .write_reg_64 = aice_pipe_write_reg_64,
884 /** */
885 .read_mem_unit = aice_pipe_read_mem_unit,
886 /** */
887 .write_mem_unit = aice_pipe_write_mem_unit,
888 /** */
889 .read_mem_bulk = aice_pipe_read_mem_bulk,
890 /** */
891 .write_mem_bulk = aice_pipe_write_mem_bulk,
892 /** */
893 .read_debug_reg = aice_pipe_read_debug_reg,
894 /** */
895 .write_debug_reg = aice_pipe_write_debug_reg,
896
897 /** */
898 .set_jtag_clock = aice_pipe_set_jtag_clock,
899 /** */
900 .select_target = aice_pipe_select_target,
901
902 /** */
903 .memory_access = aice_pipe_memory_access,
904 /** */
905 .memory_mode = aice_pipe_memory_mode,
906
907 /** */
908 .read_tlb = aice_pipe_read_tlb,
909
910 /** */
911 .cache_ctl = aice_pipe_cache_ctl,
912
913 /** */
914 .set_retry_times = aice_pipe_set_retry_times,
915 };
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)