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