FreeCalypso > hg > freecalypso-tools

comparison rvinterf/tmsh/tmcore.c @ 69:2159f260ed13

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
fc-tmsh: all commands internally return values in preparation for adding one-shot mode of operation
author Mychaela Falconia <falcon@freecalypso.org>
date Wed, 26 Oct 2016 23:17:03 +0000
parents e7502631a0f9
children 4c7f3778dc24
comparison
equal deleted inserted replaced
68:585f63e5bca6 69:2159f260ed13
10 #include <stdlib.h> 10 #include <stdlib.h>
11 #include "pktmux.h" 11 #include "pktmux.h"
12 #include "limits.h" 12 #include "limits.h"
13 #include "localtypes.h" 13 #include "localtypes.h"
14 #include "etm.h" 14 #include "etm.h"
15 #include "exitcodes.h"
15 16
16 extern u_char rvi_msg[]; 17 extern u_char rvi_msg[];
17 extern int rvi_msg_len; 18 extern int rvi_msg_len;
18 19
19 static void 20 static void
192 unknown: 193 unknown:
193 print_etm_pkt_raw("ETM_CORE resp"); 194 print_etm_pkt_raw("ETM_CORE resp");
194 } 195 }
195 } 196 }
196 197
197 void
198 cmd_r8(argc, argv) 198 cmd_r8(argc, argv)
199 char **argv; 199 char **argv;
200 { 200 {
201 u32 addr; 201 u32 addr;
202 int count; 202 int count;
207 count = strtoul(argv[2], 0, 0); 207 count = strtoul(argv[2], 0, 0);
208 else 208 else
209 count = 1; 209 count = 1;
210 if (count < 1 || count > 253) { 210 if (count < 1 || count > 253) {
211 printf("error: count argument outside valid range\n"); 211 printf("error: count argument outside valid range\n");
212 return; 212 return(ERROR_USAGE);
213 } 213 }
214 cmdpkt[1] = ETM_CORE; 214 cmdpkt[1] = ETM_CORE;
215 cmdpkt[2] = TMCORE_OPC_MEM; 215 cmdpkt[2] = TMCORE_OPC_MEM;
216 cmdpkt[3] = 0x01; 216 cmdpkt[3] = 0x01;
217 cmdpkt[4] = count; 217 cmdpkt[4] = count;
218 cmdpkt[5] = addr; 218 cmdpkt[5] = addr;
219 cmdpkt[6] = addr >> 8; 219 cmdpkt[6] = addr >> 8;
220 cmdpkt[7] = addr >> 16; 220 cmdpkt[7] = addr >> 16;
221 cmdpkt[8] = addr >> 24; 221 cmdpkt[8] = addr >> 24;
222 send_etm_cmd(cmdpkt, 8); 222 send_etm_cmd(cmdpkt, 8);
223 } 223 return(0);
224 224 }
225 void 225
226 cmd_r16(argc, argv) 226 cmd_r16(argc, argv)
227 char **argv; 227 char **argv;
228 { 228 {
229 u32 addr; 229 u32 addr;
230 int count; 230 int count;
235 count = strtoul(argv[2], 0, 0); 235 count = strtoul(argv[2], 0, 0);
236 else 236 else
237 count = 1; 237 count = 1;
238 if (addr & 1) { 238 if (addr & 1) {
239 printf("error: address not aligned\n"); 239 printf("error: address not aligned\n");
240 return; 240 return(ERROR_USAGE);
241 } 241 }
242 if (count < 1 || count > 126) { 242 if (count < 1 || count > 126) {
243 printf("error: count argument outside valid range\n"); 243 printf("error: count argument outside valid range\n");
244 return; 244 return(ERROR_USAGE);
245 } 245 }
246 cmdpkt[1] = ETM_CORE; 246 cmdpkt[1] = ETM_CORE;
247 cmdpkt[2] = TMCORE_OPC_MEM; 247 cmdpkt[2] = TMCORE_OPC_MEM;
248 cmdpkt[3] = 0x02; 248 cmdpkt[3] = 0x02;
249 cmdpkt[4] = count; 249 cmdpkt[4] = count;
250 cmdpkt[5] = addr; 250 cmdpkt[5] = addr;
251 cmdpkt[6] = addr >> 8; 251 cmdpkt[6] = addr >> 8;
252 cmdpkt[7] = addr >> 16; 252 cmdpkt[7] = addr >> 16;
253 cmdpkt[8] = addr >> 24; 253 cmdpkt[8] = addr >> 24;
254 send_etm_cmd(cmdpkt, 8); 254 send_etm_cmd(cmdpkt, 8);
255 } 255 return(0);
256 256 }
257 void 257
258 cmd_r32(argc, argv) 258 cmd_r32(argc, argv)
259 char **argv; 259 char **argv;
260 { 260 {
261 u32 addr; 261 u32 addr;
262 int count; 262 int count;
267 count = strtoul(argv[2], 0, 0); 267 count = strtoul(argv[2], 0, 0);
268 else 268 else
269 count = 1; 269 count = 1;
270 if (addr & 3) { 270 if (addr & 3) {
271 printf("error: address not aligned\n"); 271 printf("error: address not aligned\n");
272 return; 272 return(ERROR_USAGE);
273 } 273 }
274 if (count < 1 || count > 63) { 274 if (count < 1 || count > 63) {
275 printf("error: count argument outside valid range\n"); 275 printf("error: count argument outside valid range\n");
276 return; 276 return(ERROR_USAGE);
277 } 277 }
278 cmdpkt[1] = ETM_CORE; 278 cmdpkt[1] = ETM_CORE;
279 cmdpkt[2] = TMCORE_OPC_MEM; 279 cmdpkt[2] = TMCORE_OPC_MEM;
280 cmdpkt[3] = 0x04; 280 cmdpkt[3] = 0x04;
281 cmdpkt[4] = count; 281 cmdpkt[4] = count;
282 cmdpkt[5] = addr; 282 cmdpkt[5] = addr;
283 cmdpkt[6] = addr >> 8; 283 cmdpkt[6] = addr >> 8;
284 cmdpkt[7] = addr >> 16; 284 cmdpkt[7] = addr >> 16;
285 cmdpkt[8] = addr >> 24; 285 cmdpkt[8] = addr >> 24;
286 send_etm_cmd(cmdpkt, 8); 286 send_etm_cmd(cmdpkt, 8);
287 } 287 return(0);
288 288 }
289 void 289
290 cmd_w8(argc, argv) 290 cmd_w8(argc, argv)
291 char **argv; 291 char **argv;
292 { 292 {
293 u32 addr, v; 293 u32 addr, v;
294 u_char cmdpkt[MAX_PKT_TO_TARGET]; 294 u_char cmdpkt[MAX_PKT_TO_TARGET];
308 for (ap = argv + 2; *ap; ap++) { 308 for (ap = argv + 2; *ap; ap++) {
309 v = strtoul(*ap, 0, 16); 309 v = strtoul(*ap, 0, 16);
310 cmdpkt[di++] = v; 310 cmdpkt[di++] = v;
311 } 311 }
312 send_etm_cmd(cmdpkt, di - 1); 312 send_etm_cmd(cmdpkt, di - 1);
313 } 313 return(0);
314 314 }
315 void 315
316 cmd_w16(argc, argv) 316 cmd_w16(argc, argv)
317 char **argv; 317 char **argv;
318 { 318 {
319 u32 addr, v; 319 u32 addr, v;
320 u_char cmdpkt[MAX_PKT_TO_TARGET]; 320 u_char cmdpkt[MAX_PKT_TO_TARGET];
322 char **ap; 322 char **ap;
323 323
324 addr = strtoul(argv[1], 0, 16); 324 addr = strtoul(argv[1], 0, 16);
325 if (addr & 1) { 325 if (addr & 1) {
326 printf("error: address not aligned\n"); 326 printf("error: address not aligned\n");
327 return; 327 return(ERROR_USAGE);
328 } 328 }
329 cmdpkt[1] = ETM_CORE; 329 cmdpkt[1] = ETM_CORE;
330 cmdpkt[2] = TMCORE_OPC_MEM; 330 cmdpkt[2] = TMCORE_OPC_MEM;
331 cmdpkt[3] = 0x12; 331 cmdpkt[3] = 0x12;
332 cmdpkt[4] = argc - 2; 332 cmdpkt[4] = argc - 2;
339 v = strtoul(*ap, 0, 16); 339 v = strtoul(*ap, 0, 16);
340 cmdpkt[di++] = v; 340 cmdpkt[di++] = v;
341 cmdpkt[di++] = v >> 8; 341 cmdpkt[di++] = v >> 8;
342 } 342 }
343 send_etm_cmd(cmdpkt, di - 1); 343 send_etm_cmd(cmdpkt, di - 1);
344 } 344 return(0);
345 345 }
346 void 346
347 cmd_w32(argc, argv) 347 cmd_w32(argc, argv)
348 char **argv; 348 char **argv;
349 { 349 {
350 u32 addr, v; 350 u32 addr, v;
351 u_char cmdpkt[MAX_PKT_TO_TARGET]; 351 u_char cmdpkt[MAX_PKT_TO_TARGET];
353 char **ap; 353 char **ap;
354 354
355 addr = strtoul(argv[1], 0, 16); 355 addr = strtoul(argv[1], 0, 16);
356 if (addr & 3) { 356 if (addr & 3) {
357 printf("error: address not aligned\n"); 357 printf("error: address not aligned\n");
358 return; 358 return(ERROR_USAGE);
359 } 359 }
360 cmdpkt[1] = ETM_CORE; 360 cmdpkt[1] = ETM_CORE;
361 cmdpkt[2] = TMCORE_OPC_MEM; 361 cmdpkt[2] = TMCORE_OPC_MEM;
362 cmdpkt[3] = 0x14; 362 cmdpkt[3] = 0x14;
363 cmdpkt[4] = argc - 2; 363 cmdpkt[4] = argc - 2;
372 cmdpkt[di++] = v >> 8; 372 cmdpkt[di++] = v >> 8;
373 cmdpkt[di++] = v >> 16; 373 cmdpkt[di++] = v >> 16;
374 cmdpkt[di++] = v >> 24; 374 cmdpkt[di++] = v >> 24;
375 } 375 }
376 send_etm_cmd(cmdpkt, di - 1); 376 send_etm_cmd(cmdpkt, di - 1);
377 } 377 return(0);
378 378 }
379 void 379
380 cmd_dieid(argc, argv) 380 cmd_dieid(argc, argv)
381 char **argv; 381 char **argv;
382 { 382 {
383 u_char cmdpkt[4]; 383 u_char cmdpkt[4];
384 384
385 cmdpkt[1] = ETM_CORE; 385 cmdpkt[1] = ETM_CORE;
386 cmdpkt[2] = TMCORE_OPC_DIEID; 386 cmdpkt[2] = TMCORE_OPC_DIEID;
387 send_etm_cmd(cmdpkt, 2); 387 send_etm_cmd(cmdpkt, 2);
388 } 388 return(0);
389 389 }
390 void 390
391 cmd_ping(argc, argv) 391 cmd_ping(argc, argv)
392 char **argv; 392 char **argv;
393 { 393 {
394 int delay, size; 394 int delay, size;
395 u_char cmdpkt[8]; 395 u_char cmdpkt[8];
396 396
397 if (argc > 1) { 397 if (argc > 1) {
398 delay = strtoul(argv[1], 0, 0); 398 delay = strtoul(argv[1], 0, 0);
399 if (delay > 65535) { 399 if (delay > 65535) {
400 printf("error: ping delay argument too big\n"); 400 printf("error: ping delay argument too big\n");
401 return; 401 return(ERROR_USAGE);
402 } 402 }
403 } else 403 } else
404 delay = 0; 404 delay = 0;
405 if (argc > 2) { 405 if (argc > 2) {
406 size = strtoul(argv[2], 0, 0); 406 size = strtoul(argv[2], 0, 0);
407 if (size > 240) { 407 if (size > 240) {
408 printf("error: ping size argument too big\n"); 408 printf("error: ping size argument too big\n");
409 return; 409 return(ERROR_USAGE);
410 } 410 }
411 } else 411 } else
412 size = 1; 412 size = 1;
413 cmdpkt[1] = ETM_CORE; 413 cmdpkt[1] = ETM_CORE;
414 cmdpkt[2] = TMCORE_OPC_ECHO; 414 cmdpkt[2] = TMCORE_OPC_ECHO;
415 cmdpkt[3] = delay; 415 cmdpkt[3] = delay;
416 cmdpkt[4] = delay >> 8; 416 cmdpkt[4] = delay >> 8;
417 cmdpkt[5] = size; 417 cmdpkt[5] = size;
418 cmdpkt[6] = size >> 8; 418 cmdpkt[6] = size >> 8;
419 send_etm_cmd(cmdpkt, 6); 419 send_etm_cmd(cmdpkt, 6);
420 } 420 return(0);
421 421 }
422 void 422
423 cmd_tgtreset(argc, argv) 423 cmd_tgtreset(argc, argv)
424 char **argv; 424 char **argv;
425 { 425 {
426 u_char cmdpkt[4]; 426 u_char cmdpkt[4];
427 427
428 cmdpkt[1] = ETM_CORE; 428 cmdpkt[1] = ETM_CORE;
429 cmdpkt[2] = TMCORE_OPC_RESET; 429 cmdpkt[2] = TMCORE_OPC_RESET;
430 send_etm_cmd(cmdpkt, 2); 430 send_etm_cmd(cmdpkt, 2);
431 } 431 return(0);
432 432 }
433 void 433
434 cmd_version(argc, argv) 434 cmd_version(argc, argv)
435 char **argv; 435 char **argv;
436 { 436 {
437 u32 arg; 437 u32 arg;
438 u_char cmdpkt[8]; 438 u_char cmdpkt[8];
443 cmdpkt[3] = arg; 443 cmdpkt[3] = arg;
444 cmdpkt[4] = arg >> 8; 444 cmdpkt[4] = arg >> 8;
445 cmdpkt[5] = arg >> 16; 445 cmdpkt[5] = arg >> 16;
446 cmdpkt[6] = arg >> 24; 446 cmdpkt[6] = arg >> 24;
447 send_etm_cmd(cmdpkt, 6); 447 send_etm_cmd(cmdpkt, 6);
448 } 448 return(0);
449 }