Remove FSF address from GPL notices
[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 long long 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, uint32_t virtual_address,
790 uint32_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 };