FreeCalypso > hg > freecalypso-sw

comparison rvinterf/etm/tmcore.c @ 192:707aa640b2dc

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
fc-tmsh: w8/w16/w32 implemented
author Michael Spacefalcon <msokolov@ivan.Harhan.ORG>
date Mon, 25 Nov 2013 05:37:46 +0000
parents 405f5b46cdc4
children c9ea2f7441a5
comparison
equal deleted inserted replaced
191:cf8583923dc4 192:707aa640b2dc
15 15
16 extern u_char rvi_msg[]; 16 extern u_char rvi_msg[];
17 extern int rvi_msg_len; 17 extern int rvi_msg_len;
18 18
19 static void 19 static void
20 r8_response() 20 rw8_response()
21 { 21 {
22 char buf[MAX_PKT_FROM_TARGET*3+80], *dp; 22 char buf[MAX_PKT_FROM_TARGET*3+80], *dp;
23 int num, i; 23 int num, i;
24 24
25 if (rvi_msg[3]) { 25 if (rvi_msg[3]) {
26 print_etm_pkt_raw("r8 error"); 26 print_etm_pkt_raw("rw8 error");
27 return; 27 return;
28 } 28 }
29 num = rvi_msg_len - 7; 29 num = rvi_msg_len - 7;
30 if (!num) {
31 async_msg_output("w8 OK");
32 return;
33 }
30 strcpy(buf, "r8:"); 34 strcpy(buf, "r8:");
31 dp = buf + 3; 35 dp = buf + 3;
32 for (i = 0; i < num; i++) { 36 for (i = 0; i < num; i++) {
33 sprintf(dp, " %02X", rvi_msg[i+6]); 37 sprintf(dp, " %02X", rvi_msg[i+6]);
34 dp += 3; 38 dp += 3;
35 } 39 }
36 async_msg_output(buf); 40 async_msg_output(buf);
37 } 41 }
38 42
39 static void 43 static void
40 r16_response() 44 rw16_response()
41 { 45 {
42 char buf[MAX_PKT_FROM_TARGET*3+80], *dp; 46 char buf[MAX_PKT_FROM_TARGET*3+80], *dp;
43 int num, i, d, off; 47 int num, i, d, off;
44 48
45 if (rvi_msg[3]) { 49 if (rvi_msg[3]) {
46 print_etm_pkt_raw("r16 error"); 50 print_etm_pkt_raw("rw16 error");
47 return; 51 return;
48 } 52 }
49 num = rvi_msg_len - 7; 53 num = rvi_msg_len - 7;
54 if (!num) {
55 async_msg_output("w16 OK");
56 return;
57 }
50 if (num & 1) { 58 if (num & 1) {
51 print_etm_pkt_raw("r16 malformed resp"); 59 print_etm_pkt_raw("rw16 malformed resp");
52 return; 60 return;
53 } 61 }
54 num >>= 1; 62 num >>= 1;
55 strcpy(buf, "r16:"); 63 strcpy(buf, "r16:");
56 dp = buf + 4; 64 dp = buf + 4;
63 } 71 }
64 async_msg_output(buf); 72 async_msg_output(buf);
65 } 73 }
66 74
67 static void 75 static void
68 r32_response() 76 rw32_response()
69 { 77 {
70 char buf[MAX_PKT_FROM_TARGET*3+80], *dp; 78 char buf[MAX_PKT_FROM_TARGET*3+80], *dp;
71 int num, i, d, off; 79 int num, i, d, off;
72 80
73 if (rvi_msg[3]) { 81 if (rvi_msg[3]) {
74 print_etm_pkt_raw("r32 error"); 82 print_etm_pkt_raw("rw32 error");
75 return; 83 return;
76 } 84 }
77 num = rvi_msg_len - 7; 85 num = rvi_msg_len - 7;
86 if (!num) {
87 async_msg_output("w32 OK");
88 return;
89 }
78 if (num & 3) { 90 if (num & 3) {
79 print_etm_pkt_raw("r32 malformed resp"); 91 print_etm_pkt_raw("rw32 malformed resp");
80 return; 92 return;
81 } 93 }
82 num >>= 2; 94 num >>= 2;
83 strcpy(buf, "r32:"); 95 strcpy(buf, "r32:");
84 dp = buf + 4; 96 dp = buf + 4;
148 if (rvi_msg_len < 7) 160 if (rvi_msg_len < 7)
149 goto unknown; 161 goto unknown;
150 switch (rvi_msg[5]) { 162 switch (rvi_msg[5]) {
151 case 0x00: 163 case 0x00:
152 case 0x04: 164 case 0x04:
153 r32_response(); 165 rw32_response();
154 return; 166 return;
155 case 0x01: 167 case 0x01:
156 r8_response(); 168 rw8_response();
157 return; 169 return;
158 case 0x02: 170 case 0x02:
159 r16_response(); 171 rw16_response();
160 return; 172 return;
161 default: 173 default:
162 goto unknown; 174 goto unknown;
163 } 175 }
164 case TMCORE_OPC_ECHO: 176 case TMCORE_OPC_ECHO:
268 cmdpkt[5] = addr; 280 cmdpkt[5] = addr;
269 cmdpkt[6] = addr >> 8; 281 cmdpkt[6] = addr >> 8;
270 cmdpkt[7] = addr >> 16; 282 cmdpkt[7] = addr >> 16;
271 cmdpkt[8] = addr >> 24; 283 cmdpkt[8] = addr >> 24;
272 send_etm_cmd(cmdpkt, 8); 284 send_etm_cmd(cmdpkt, 8);
285 }
286
287 void
288 cmd_w8(argc, argv)
289 char **argv;
290 {
291 u32 addr, v;
292 u_char cmdpkt[MAX_PKT_TO_TARGET];
293 int di;
294 char **ap;
295
296 addr = strtoul(argv[1], 0, 16);
297 cmdpkt[1] = ETM_CORE;
298 cmdpkt[2] = TMCORE_OPC_MEM;
299 cmdpkt[3] = 0x11;
300 cmdpkt[4] = argc - 2;
301 cmdpkt[5] = addr;
302 cmdpkt[6] = addr >> 8;
303 cmdpkt[7] = addr >> 16;
304 cmdpkt[8] = addr >> 24;
305 di = 9;
306 for (ap = argv + 2; *ap; ap++) {
307 v = strtoul(*ap, 0, 16);
308 cmdpkt[di++] = v;
309 }
310 send_etm_cmd(cmdpkt, di - 1);
311 }
312
313 void
314 cmd_w16(argc, argv)
315 char **argv;
316 {
317 u32 addr, v;
318 u_char cmdpkt[MAX_PKT_TO_TARGET];
319 int di;
320 char **ap;
321
322 addr = strtoul(argv[1], 0, 16);
323 if (addr & 1) {
324 printf("error: address not aligned\n");
325 return;
326 }
327 cmdpkt[1] = ETM_CORE;
328 cmdpkt[2] = TMCORE_OPC_MEM;
329 cmdpkt[3] = 0x12;
330 cmdpkt[4] = argc - 2;
331 cmdpkt[5] = addr;
332 cmdpkt[6] = addr >> 8;
333 cmdpkt[7] = addr >> 16;
334 cmdpkt[8] = addr >> 24;
335 di = 9;
336 for (ap = argv + 2; *ap; ap++) {
337 v = strtoul(*ap, 0, 16);
338 cmdpkt[di++] = v;
339 cmdpkt[di++] = v >> 8;
340 }
341 send_etm_cmd(cmdpkt, di - 1);
342 }
343
344 void
345 cmd_w32(argc, argv)
346 char **argv;
347 {
348 u32 addr, v;
349 u_char cmdpkt[MAX_PKT_TO_TARGET];
350 int di;
351 char **ap;
352
353 addr = strtoul(argv[1], 0, 16);
354 if (addr & 3) {
355 printf("error: address not aligned\n");
356 return;
357 }
358 cmdpkt[1] = ETM_CORE;
359 cmdpkt[2] = TMCORE_OPC_MEM;
360 cmdpkt[3] = 0x14;
361 cmdpkt[4] = argc - 2;
362 cmdpkt[5] = addr;
363 cmdpkt[6] = addr >> 8;
364 cmdpkt[7] = addr >> 16;
365 cmdpkt[8] = addr >> 24;
366 di = 9;
367 for (ap = argv + 2; *ap; ap++) {
368 v = strtoul(*ap, 0, 16);
369 cmdpkt[di++] = v;
370 cmdpkt[di++] = v >> 8;
371 cmdpkt[di++] = v >> 16;
372 cmdpkt[di++] = v >> 24;
373 }
374 send_etm_cmd(cmdpkt, di - 1);
273 } 375 }
274 376
275 void 377 void
276 cmd_dieid(argc, argv) 378 cmd_dieid(argc, argv)
277 char **argv; 379 char **argv;