converter/nexus/NxMessage.cpp

   1 /*
   2  * Copyright (C) 2013 Freescale Semiconductor, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included
  12  * in all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  17  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  20  * IN THE SOFTWARE.
  21  */
  22
  23 #include "NxMessage.h"
  24 #include <assert.h>
  25 #include <ctype.h> // for isprint()
  26 #include <sstream>
  27 #include <iomanip>
  28 using std::ostringstream;
  29 using std::endl;
  30 using std::hex;
  31 using std::dec;
  32 using std::setfill;
  33 using std::setw;
  34
  35 #define SWAPBYTES32(ui32) \
  36         (((ui32)<<24) | (((ui32) & 0xff00) << 8) |\
  37         (((ui32) & 0xff0000) >> 8) | ((ui32) >> 24))
  38
  39 string NxMessage::tcodeString() const
  40 {
  41         ostringstream os;
  42         os << "UNKNOWN-" << tcode_;
  43         return os.str();
  44 }
  45
  46 // decode the source id from the packet
  47 uint32_t NxMessage::decodeSourceId(NxPacketSet &pkt_set)
  48 {
  49         // packet index, start_pos, length
  50         uint32_t src_id = pkt_set.getField32(0, 6, 6);
  51         return src_id;
  52 }
  53
  54 // decode the timestamp from the packet
  55 uint32_t NxMessage::decodeTimestamp(NxPacketSet &pkt_set, uint32_t index)
  56 {
  57         // packet at index, start_pos, length
  58         uint32_t ts = pkt_set.getField32(index, 0, 28);
  59         return ts;
  60 }
  61
  62 // Returns the SRC_ID as a string
  63 const char * NxMessage::sourceIdString() const
  64 {
  65         switch (source_id_) {
  66         case 0x0:
  67                 return "Core0 / CPU0 (Clst0:Core0:Thread0)";
  68                 break;
  69         case 0x1:
  70                 return "Nexus Port Controller";
  71                 break;
  72         case 0x2:
  73                 return "Core1 / CPU8 (Clst1:Core0:Thread0)";
  74                 break;
  75         case 0x3:
  76                 return "Nexus Trace Collector #1";
  77                 break;
  78         case 0x4:
  79                 return "Core2 / CPU16 (Clst2:Core0:Thread0)";
  80                 break;
  81         case 0x5:
  82                 return "Nexus Trace Collector #2";
  83                 break;
  84         case 0x6:
  85                 return "Core3";
  86                 break;
  87         case 0x8:
  88                 return "Core4 / CPU2 (Clst0:Core1:Thread0)";
  89                 break;
  90         case 0x9:
  91                 return "CoreNet Debug Client";
  92                 break;
  93         case 0xa:
  94                 return "Core5 / CPU10 (Clst1:Core1:Thread0)";
  95                 break;
  96         case 0xb:
  97                 return "Datapath Debug Client";
  98                 break;
  99         case 0xc:
 100                 return "Core6 / CPU18 (Clst2:Core1:Thread0)";
 101                 break;
 102         case 0xd:
 103                 return "DDR Debug Interface";
 104                 break;
 105         case 0xe:
 106                 return "Core7";
 107                 break;
 108         case 0x10:
 109                 return "CPU4 (Clst0:Core2:Thread0)";
 110                 break;
 111         case 0x12:
 112                 return "CPU12 (Clst1:Core2:Thread0)";
 113                 break;
 114         case 0x14:
 115                 return "CPU20 (Clst2:Core2:Thread0)";
 116                 break;
 117         case 0x18:
 118                 return "CPU6 (Clst0:Core3:Thread0)";
 119                 break;
 120         case 0x19:
 121                 return "CoreNet Debug Client";
 122                 break;
 123         case 0x1a:
 124                 return "CPU14 (Clst1:Core3:Thread0)";
 125                 break;
 126         case 0x1b:
 127                 return "Datapath Debug Interface";
 128                 break;
 129         case 0x1c:
 130                 return "CPU22 (Clst2:Core3:Thread0)";
 131                 break;
 132         case 0x1d:
 133                 return "Nexus Concentrator";
 134                 break;
 135         case 0x20:
 136                 return "CPU1 (Clst0:Core0:Thread1)";
 137                 break;
 138         case 0x22:
 139                 return "CPU9 (Clst1:Core0:Thread1)";
 140                 break;
 141         case 0x24:
 142                 return "CPU17 (Clst2:Core0:Thread1)";
 143                 break;
 144         case 0x28:
 145                 return "CPU3 (Clst0:Core1:Thread1)";
 146                 break;
 147         case 0x2a:
 148                 return "CPU11 (Clst1:Core1:Thread1)";
 149                 break;
 150         case 0x2b:
 151                 return "Datapath Debug Interface";
 152                 break;
 153         case 0x2c:
 154                 return "CPU19 (Clst2:Core1:Thread1)";
 155                 break;
 156         case 0x2d:
 157                 return "DDR Debug Interface";
 158                 break;
 159         case 0x30:
 160                 return "CPU5 (Clst0:Core2:Thread1)";
 161                 break;
 162         case 0x32:
 163                 return "CPU13 (Clst1:Core2:Thread1)";
 164                 break;
 165         case 0x34:
 166                 return "CPU21 (Clst2:Core2:Thread1)";
 167                 break;
 168         case 0x38:
 169                 return "CPU7 (Clst0:Core3:Thread1)";
 170                 break;
 171         case 0x3a:
 172                 return "CPU15 (Clst1:Core3:Thread1)";
 173                 break;
 174         case 0x3c:
 175                 return "CPU23 (Clst2:Core3:Thread1)";
 176                 break;
 177         case 0x3d:
 178                 return "Event Processing Unit";
 179                 break;
 180         case 0x4d:
 181                 return "Nexus Concentrator";
 182                 break;
 183         default:
 184                 return "Reserved";
 185                 break;
 186         };
 187         return "UNKNOWN";
 188 }
 189
 190 // Determines if the TIMESTAMP value needs correction
 191 bool NxMessage::timestampNeedsCorrection() const
 192 {
 193         return (timestamp_ & 0x0f000000);
 194 }
 195
 196 // Returns the corrected TIMESTAMP value
 197 uint32_t NxMessage::correctedTimestamp() const
 198 {
 199         uint32_t correction = (timestamp_ & 0x0f000000) >> 24;
 200         uint32_t ts = (timestamp_ & 0x00ffffff) - correction;
 201         return ts;
 202 }
 203 // Returns a string representing the timestamp
 204 string NxMessage::timestampAsString() const
 205 {
 206         ostringstream os;
 207         os << dec << correctedTimestamp() << " (0x" << hex
 208                 << correctedTimestamp() << ")";
 209         return os.str();
 210 }
 211
 212 // represent this message as a formatted string
 213 string NxMessage::asString() const
 214 {
 215         ostringstream os;
 216         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
 217         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
 218                 << endl;
 219         os << "TIMESTAMP : " << timestampAsString() << endl;
 220         return os.str();
 221 }
 222
 223 // decode message info from the packet set
 224 bool NxDebugStatusMessage::decode(NxPacketSet &pkt_set)
 225 {
 226         bool ret = true;
 227         source_id_ = decodeSourceId(pkt_set);
 228
 229         // index, start_pos, length
 230         status_ = pkt_set.getField32(0, 12, 16);
 231
 232         // index, start_pos, length
 233         timestamp_ = pkt_set.getField32(0, 28, 28);
 234
 235         return ret;
 236 }
 237
 238 // represent this message as a formatted string
 239 string NxDebugStatusMessage::asString() const
 240 {
 241         ostringstream os;
 242         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
 243         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
 244                 << endl;
 245         os << "STATUS    : 0x" << hex << setfill('0') << setw(4) << status_
 246                 << endl;
 247         os << "TIMESTAMP : " << timestampAsString() << endl;
 248         return os.str();
 249 }
 250
 251 // decode message info from the packet set
 252 bool NxDeviceIDMessage::decode(NxPacketSet &pkt_set)
 253 {
 254         bool ret = true;
 255         source_id_ = decodeSourceId(pkt_set);
 256
 257         return ret;
 258 }
 259
 260 // represent this message as a formatted string
 261 string NxDeviceIDMessage::asString() const
 262 {
 263         ostringstream os;
 264         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
 265         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
 266                 << endl;
 267         return os.str();
 268 }
 269 // decode message info from the packet set
 270 bool NxOwnershipTraceMessage::decode(NxPacketSet &pkt_set)
 271 {
 272         bool ret = true;
 273         source_id_ = decodeSourceId(pkt_set);
 274
 275         // index, start_pos, length
 276         pid_index_ = pkt_set.getField32(0, 12, 4);
 277
 278         // index, start_pos, length
 279         pid_value_ = pkt_set.getField64(0, 16, 40);
 280
 281         // if there is a optional timestamp
 282         if (pkt_set.packetAtIndexExists(1)) {
 283                 timestamp_ = decodeTimestamp(pkt_set, 1);
 284         }
 285         return ret;
 286 }
 287
 288 // represent this message as a formatted string
 289 string NxOwnershipTraceMessage::asString() const
 290 {
 291         ostringstream os;
 292         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
 293         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
 294                 << endl;
 295         os << "PID INDEX : 0x" << hex << setfill('0') << setw(2) << pid_index_;
 296         os << " - " << pidIndexString() << endl;
 297         if (pid_index_ < 2) {
 298                 os << "PID VALUE : " << dec << pid_value_;
 299         } else {
 300                 os << "PID VALUE : 0x" << hex << setfill('0') << setw(10)
 301                         << pid_value_;
 302         }
 303         os << " - " << pidValueString() << endl;
 304         os << "TIMESTAMP : " << timestampAsString() << endl;
 305         return os.str();
 306 }
 307
 308 // decode the data as a string
 309 const char * NxOwnershipTraceMessage::pidIndexString() const
 310 {
 311         switch (pid_index_) {
 312         case 0:
 313                 return "OS PID";
 314                 break;
 315         case 1:
 316                 return "Hypervisor PID";
 317                 break;
 318         case 2:
 319                 return "Sync PID";
 320                 break;
 321         default:
 322                 return "Reserved";
 323                 break;
 324         };
 325         return "UNKNOWN";
 326 }
 327
 328 // decode the data as a string
 329 const char * NxOwnershipTraceMessage::pidValueString() const
 330 {
 331         switch (pid_index_) {
 332         case 0:
 333                 return "PID/NPIDR ref:DC1[OTS]";
 334                 break;
 335         case 1:
 336                 return "LPIDR";
 337                 break;
 338         case 2:
 339                 return "LPIDR, MSR[GS], PID/NPIDR (ref:DC1[OTS]), MSR[PR]";
 340                 break;
 341         default:
 342                 return "N/A";
 343                 break;
 344         };
 345         return "UNKNOWN";
 346 }
 347
 348 // decode message info from the packet set
 349 bool NxDataAcquisitionMessage::decode(NxPacketSet &pkt_set)
 350 {
 351         bool ret = true;
 352         source_id_ = decodeSourceId(pkt_set);
 353
 354         // index, start_pos, length
 355         idtag_ = pkt_set.getField32(0, 12, 8);
 356
 357         // index, start_pos, length
 358         dqdata_ = pkt_set.getField32(0, 20, 32);
 359
 360         // if there is a optional timestamp
 361         if (pkt_set.packetAtIndexExists(1)) {
 362                 timestamp_ = decodeTimestamp(pkt_set, 1);
 363         }
 364         return ret;
 365 }
 366
 367 // represent this message as a formatted string
 368 string NxDataAcquisitionMessage::asString() const
 369 {
 370         ostringstream os;
 371         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
 372         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
 373                 << endl;
 374         os << "IDTAG     : 0x" << hex << setfill('0') << setw(2) << idtag_;
 375         os << " - " << idtagString() << endl;
 376         if (idtag_ == 6) {
 377                 os << "DQDATA    : 0x" << hex << setfill('0') << setw(8)
 378                         << dqdata_;
 379                 os << " - \"" << dqdataString() << "\"" << endl;
 380         } else {
 381                 os << "DQDATA    : " << dec << dqdata_ << endl;
 382         }
 383         os << "TIMESTAMP : " << timestampAsString() << endl;
 384         return os.str();
 385 }
 386
 387 // decode the data as a string
 388 const char * NxDataAcquisitionMessage::idtagString() const
 389 {
 390         switch (idtag_) {
 391         case 1:
 392                 return "Diagnostic";
 393                 break;
 394         case 3:
 395                 return "Parent PID";
 396                 break;
 397         case 4:
 398                 return "PID";
 399                 break;
 400         case 5:
 401                 return "TGID";
 402                 break;
 403         case 6:
 404                 return "Name";
 405                 break;
 406         case 7:
 407                 return "Address";
 408                 break;
 409         default:
 410                 return "Reserved";
 411                 break;
 412         };
 413         return "UNKNOWN";
 414 }
 415
 416 // decode the data as a string
 417 string NxDataAcquisitionMessage::dqdataString() const
 418 {
 419         ostringstream os;
 420         // display as ASCII
 421         for (uint32_t i = 0; i < 4; ++i) {
 422                 char c = (dqdata_ >> ((3 - i) * 8)) & 0xff;
 423                 if (isprint(c)) {
 424                         os << c;
 425                 } else {
 426                         os << ' ';
 427                 }
 428         }
 429         return os.str();
 430 }
 431
 432 // decode message info from the packet set
 433 bool NxErrorMessage::decode(NxPacketSet &pkt_set)
 434 {
 435         bool ret = true;
 436         source_id_ = decodeSourceId(pkt_set);
 437
 438         // index, start_pos, length
 439         etype_ = pkt_set.getField32(0, 12, 4);
 440
 441         // index, start_pos, length
 442         ecode_ = pkt_set.getField32(0, 16, 8);
 443
 444         // if there is a optional timestamp
 445         if (pkt_set.packetAtIndexExists(1)) {
 446                 timestamp_ = decodeTimestamp(pkt_set, 1);
 447         }
 448         return ret;
 449 }
 450
 451 // represent this message as a formatted string
 452 string NxErrorMessage::asString() const
 453 {
 454         ostringstream os;
 455         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
 456         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
 457                 << endl;
 458         os << "ETYPE     : 0x" << hex << setfill('0') << setw(2) << etype_;
 459         os << " - " << etypeString() << endl;
 460         os << "ECODE     : 0x" << hex << setfill('0') << setw(8) << ecode_;
 461         os << " - " << ecodeString() << endl;
 462         os << "TIMESTAMP : " << timestampAsString() << endl;
 463         return os.str();
 464 }
 465 // decode the data as a string
 466 const char * NxErrorMessage::etypeString() const
 467 {
 468         switch (etype_) {
 469         case 0:
 470                 return "Message Queue Overrun";
 471                 break;
 472         case 1:
 473                 return "Contention with higher priority message";
 474                 break;
 475         default:
 476                 return "Reserved";
 477                 break;
 478         };
 479
 480         return "";
 481 }
 482 // decode the data as a string
 483 string NxErrorMessage::ecodeString() const
 484 {
 485         ostringstream os;
 486         if ((ecode_ & 0x1) && (etype_ == 0)) {
 487                 os << "Watchpoint Trace ";
 488         }
 489         if ((ecode_ & 0x2) && (etype_ == 0)) {
 490                 os << "Data Trace ";
 491         }
 492         if (ecode_ & 0x4) {
 493                 os << "Program Trace ";
 494         }
 495         if ((ecode_ & 0x8) && (etype_ == 0)) {
 496                 os << "Ownership Trace ";
 497         }
 498         if ((ecode_ & 0x10) && (etype_ == 0)) {
 499                 os << "Debug (Status) Trace ";
 500         }
 501         if (ecode_ & 0x20) {
 502                 os << "Data Acquisition Trace ";
 503         }
 504
 505         return os.str();
 506 }
 507
 508 // decode message info from the packet set
 509 bool NxProgramTraceSync::decode(NxPacketSet &pkt_set)
 510 {
 511         bool ret = true;
 512         source_id_ = decodeSourceId(pkt_set);
 513
 514         // index, start_pos, length
 515         map_ = pkt_set.getField32(0, 12, 1);
 516
 517         // index, start_pos, length
 518         icnt_ = pkt_set.getField32(0, 13, 1);
 519
 520         // index, start_pos, length
 521         pc_.lower32(pkt_set.getField32(1, 0, 32));
 522         if (pkt_set.getNumMDO(1) > 1) {
 523                 // get the upper 32bits of 64bit address
 524                 pc_.upper32(pkt_set.getField32(1, 32, 32));
 525         }
 526
 527         // if there is a optional timestamp
 528         if (pkt_set.packetAtIndexExists(2)) {
 529                 timestamp_ = decodeTimestamp(pkt_set, 2);
 530         }
 531         return ret;
 532 }
 533
 534 // represent this message as a formatted string
 535 string NxProgramTraceSync::asString() const
 536 {
 537         ostringstream os;
 538         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
 539         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
 540                 << endl;
 541         os << "MAP       : 0x" << hex << setw(1) << map_ << endl;
 542         os << "I-CNT     : " << dec << icnt_ << endl;
 543         os << "PC        : " << pc_.asString() << endl;
 544         os << "TIMESTAMP : " << timestampAsString() << endl;
 545         return os.str();
 546 }
 547
 548 // decode the data as a string
 549 const char * NxDataTraceBase::dszString() const
 550 {
 551         switch (source_id_) {
 552         case 0x0: // Core
 553         {
 554                 switch (dsz_) {
 555                 case 0:
 556                         return "0 bytes (0-bit)";
 557                         break;
 558                 case 1:
 559                         return "1 byte (8-bit)";
 560                         break;
 561                 case 2:
 562                         return "2 bytes (16-bit/half word)";
 563                         break;
 564                 case 3:
 565                         return "3 bytes (24-bit/string)";
 566                         break;
 567                 case 4:
 568                         return "4 bytes (32-bit/word)";
 569                         break;
 570                 case 5:
 571                         return "5 bytes (mis-aligned access)";
 572                         break;
 573                 case 6:
 574                         return "6 bytes (mis-aligned access)";
 575                         break;
 576                 case 7:
 577                         return "7 bytes (mis-aligned access)";
 578                         break;
 579                 case 8:
 580                         return "8 bytes (64-bit/double)";
 581                         break;
 582                 case 9:
 583                         return "16 bytes (128-bit)";
 584                         break;
 585                 case 10:
 586                         return "32 bytes (256-bit)";
 587                         break;
 588                 case 11:
 589                         return "64 bytes (512-bit)";
 590                         break;
 591                 default:
 592                         return "Reserved";
 593                         break;
 594                 };
 595         }
 596         break;
 597         case 0x1: // NPC
 598         {
 599                 switch (dsz_) {
 600                 case 1:
 601                         return "2 bytes";
 602                         break;
 603                 case 2:
 604                         return "3 bytes";
 605                         break;
 606                 case 3:
 607                         return "4 bytes";
 608                         break;
 609                 case 4:
 610                         return "5 bytes";
 611                         break;
 612                 case 5:
 613                         return "6 bytes";
 614                         break;
 615                 case 6:
 616                         return "7 bytes";
 617                         break;
 618                 case 7:
 619                         return "8 bytes";
 620                         break;
 621                 case 8:
 622                         return "16 bytes";
 623                         break;
 624                 case 9:
 625                         return "32 bytes";
 626                         break;
 627                 case 10:
 628                         return "64 bytes";
 629                         break;
 630                 case 11:
 631                         return "128 bytes";
 632                         break;
 633                 case 12:
 634                         return "256 bytes";
 635                         break;
 636                 default:
 637                         return "Not Supported";
 638                         break;
 639                 };
 640         }
 641         break;
 642         default: // All other sources
 643                 break;
 644         };
 645
 646         return "UNKNOWN";
 647 }
 648
 649 // decode message info from the packet set
 650 bool NxDataTraceWrite::decode(NxPacketSet &pkt_set)
 651 {
 652         bool ret = true;
 653         source_id_ = decodeSourceId(pkt_set);
 654
 655         // index, start_pos, length
 656         dsz_ = pkt_set.getField32(0, 12, 4);
 657
 658         // index, start_pos, length
 659         addr_ = pkt_set.getField64(0, 16, 64);
 660
 661         // index, start_pos, length
 662         data_ = pkt_set.getField64(1, 0, 64);
 663
 664         // if there is a optional timestamp
 665         if (pkt_set.packetAtIndexExists(2)) {
 666                 timestamp_ = decodeTimestamp(pkt_set, 2);
 667         }
 668         return ret;
 669 }
 670
 671 // represent this message as a formatted string
 672 string NxDataTraceWrite::asString() const
 673 {
 674         ostringstream os;
 675         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
 676         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
 677                 << endl;
 678         os << "DSZ       : 0x" << hex << setfill('0') << setw(1) << dsz_;
 679         os << " - " << dszString() << endl;
 680         os << "U-ADDR    : 0x" << hex << setfill('0') << setw(16) << addr_
 681                 << endl;
 682         os << "DATA      : 0x" << hex << setfill('0') << setw(16) << data_
 683                 << endl;
 684         os << "TIMESTAMP : " << timestampAsString() << endl;
 685         return os.str();
 686 }
 687
 688
 689 // decode message info from the packet set
 690 bool NxDataTraceRead::decode(NxPacketSet &pkt_set)
 691 {
 692         bool ret = true;
 693         source_id_ = decodeSourceId(pkt_set);
 694
 695         // index, start_pos, length
 696         dsz_ = pkt_set.getField32(0, 12, 4);
 697
 698         // index, start_pos, length
 699         addr_ = pkt_set.getField64(0, 16, 64);
 700
 701         // index, start_pos, length
 702         data_ = pkt_set.getField64(1, 0, 64);
 703
 704         // if there is a optional timestamp
 705         if (pkt_set.packetAtIndexExists(2)) {
 706                 timestamp_ = decodeTimestamp(pkt_set, 2);
 707         }
 708         return ret;
 709 }
 710
 711 // represent this message as a formatted string
 712 string NxDataTraceRead::asString() const
 713 {
 714         ostringstream os;
 715         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
 716         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
 717                 << endl;
 718         os << "DSZ       : 0x" << hex << setfill('0') << setw(1) << dsz_;
 719         os << " - " << dszString() << endl;
 720         os << "U-ADDR    : 0x" << hex << setfill('0') << setw(16) << addr_
 721                 << endl;
 722         os << "DATA      : 0x" << hex << setfill('0') << setw(16) << data_
 723                 << endl;
 724         os << "TIMESTAMP : " << timestampAsString() << endl;
 725         return os.str();
 726 }
 727
 728 // decode message info from the packet set
 729 bool NxDataTraceWriteSync::decode(NxPacketSet &pkt_set)
 730 {
 731         bool ret = true;
 732         source_id_ = decodeSourceId(pkt_set);
 733
 734         // index, start_pos, length
 735         dsz_ = pkt_set.getField32(0, 12, 4);
 736
 737         // index, start_pos, length
 738         addr_ = pkt_set.getField64(0, 16, 64);
 739
 740         // index, start_pos, length
 741         data_ = pkt_set.getField64(1, 0, 64);
 742
 743         // if there is a optional timestamp
 744         if (pkt_set.packetAtIndexExists(2)) {
 745                 timestamp_ = decodeTimestamp(pkt_set, 2);
 746         }
 747         return ret;
 748 }
 749
 750 // represent this message as a formatted string
 751 string NxDataTraceWriteSync::asString() const
 752 {
 753         ostringstream os;
 754         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
 755         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
 756                 << endl;
 757         os << "DSZ       : 0x" << hex << setfill('0') << setw(1) << dsz_;
 758         os << " - " << dszString() << endl;
 759         os << "F-ADDR    : 0x" << hex << setfill('0') << setw(16) << addr_
 760                 << endl;
 761         os << "DATA      : 0x" << hex << setfill('0') << setw(16) << data_
 762                 << endl;
 763         os << "TIMESTAMP : " << timestampAsString() << endl;
 764         return os.str();
 765 }
 766
 767
 768 // decode message info from the packet set
 769 bool NxDataTraceReadSync::decode(NxPacketSet &pkt_set)
 770 {
 771         bool ret = true;
 772         source_id_ = decodeSourceId(pkt_set);
 773
 774         // index, start_pos, length
 775         dsz_ = pkt_set.getField32(0, 12, 4);
 776
 777         // index, start_pos, length
 778         addr_ = pkt_set.getField64(0, 16, 64);
 779
 780         // index, start_pos, length
 781         data_ = pkt_set.getField64(1, 0, 64);
 782
 783         // if there is a optional timestamp
 784         if (pkt_set.packetAtIndexExists(2)) {
 785                 timestamp_ = decodeTimestamp(pkt_set, 2);
 786         }
 787         return ret;
 788 }
 789
 790 // represent this message as a formatted string
 791 string NxDataTraceReadSync::asString() const
 792 {
 793         ostringstream os;
 794         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
 795         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
 796                 << endl;
 797         os << "DSZ       : 0x" << hex << setfill('0') << setw(1) << dsz_;
 798         os << " - " << dszString() << endl;
 799         os << "F-ADDR    : 0x" << hex << setfill('0') << setw(16) << addr_
 800                 << endl;
 801         os << "DATA      : 0x" << hex << setfill('0') << setw(16) << data_
 802                 << endl;
 803         os << "TIMESTAMP : " << timestampAsString() << endl;
 804         return os.str();
 805 }
 806
 807 // decode message info from the packet set
 808 bool NxWatchpointMessage::decode(NxPacketSet &pkt_set)
 809 {
 810         bool ret = true;
 811         source_id_ = decodeSourceId(pkt_set);
 812
 813         // determine the number of bits used to represent wphit_
 814         if (pkt_set.getNumMDO(0) > 1) {
 815                 wphit_size_ = 32;
 816         }
 817
 818         // index, start_pos, length
 819         wphit_ = pkt_set.getField32(0, 12, wphit_size_);
 820
 821         // if there is a optional timestamp
 822         if (pkt_set.packetAtIndexExists(1)) {
 823                 timestamp_ = decodeTimestamp(pkt_set, 1);
 824         }
 825
 826         return ret;
 827 }
 828
 829 // represent this message as a formatted string
 830 string NxWatchpointMessage::asString() const
 831 {
 832         ostringstream os;
 833         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
 834         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
 835                 << endl;
 836         os << "WPHIT     : 0x" << hex << setfill('0') << setw(wphit_size_ / 4)
 837                 << wphit_ << " " << wphitString() << endl;
 838         os << "TIMESTAMP : " << timestampAsString() << endl;
 839         return os.str();
 840 }
 841
 842 // decode the data as a string
 843 string NxWatchpointMessage::wphitString() const
 844 {
 845         ostringstream os;
 846         switch (source_id_) {
 847         case 0x0: // Cores 0-7
 848         case 0x2:
 849         case 0x4:
 850         case 0x6:
 851         case 0x8:
 852         case 0xa:
 853         case 0xc:
 854         case 0xe:
 855                 if (wphit_ & 0x4000)
 856                         os << "Reserved:";
 857                 if (wphit_ & 0x2000)
 858                         os << "PMW2:";
 859                 if (wphit_ & 0x1000)
 860                         os << "PMW1:";
 861                 if (wphit_ & 0x0800)
 862                         os << "PMW0:";
 863                 if (wphit_ & 0x0400)
 864                         os << "PID:";
 865                 if (wphit_ & 0x0200)
 866                         os << "DVT1:";
 867                 if (wphit_ & 0x0100)
 868                         os << "DVT0:";
 869                 if (wphit_ & 0x0080)
 870                         os << "EVTI1:";
 871                 if (wphit_ & 0x0040)
 872                         os << "EVTI0:";
 873                 if (wphit_ & 0x0020)
 874                         os << "DAC2:";
 875                 if (wphit_ & 0x0010)
 876                         os << "DAC1:";
 877                 if (wphit_ & 0x0008)
 878                         os << "RFI:";
 879                 if (wphit_ & 0x0004)
 880                         os << "INT:";
 881                 if (wphit_ & 0x0002)
 882                         os << "IAC2:";
 883                 if (wphit_ & 0x0001)
 884                         os << "IAC1:";
 885                 break;
 886         case 0x1: // Nexus Port Controller
 887                 if (wphit_ & 0x0040)
 888                         os << "Client Sync:";
 889                 if (wphit_ & 0x0020)
 890                         os << "Enter Suppress:";
 891                 if (wphit_ & 0x0010)
 892                         os << "Tracebuffer Wrap:";
 893                 if (wphit_ & 0x0008)
 894                         os << "MB Overflow";
 895                 if (wphit_ & 0x0004)
 896                         os << "AXI Full:";
 897                 if (wphit_ & 0x0002)
 898                         os << "ALT Full:";
 899                 if (wphit_ & 0x0001)
 900                         os << "MSP Full:";
 901                 break;
 902         case 0x3d: //Event Processing Unit
 903                 os << ((wphit_size_ == 16) ? "SCUEVT[15:0]" : "CTREVT[31:0]");
 904                 break;
 905         case 0x9: // CoreNet
 906                 if (wphit_ & 0x4000)
 907                         os << "EWE1(4):";
 908                 if (wphit_ & 0x2000)
 909                         os << "EWE1(3):";
 910                 if (wphit_ & 0x1000)
 911                         os << "EWE1(2):";
 912                 if (wphit_ & 0x0800)
 913                         os << "EWE1(1):";
 914                 if (wphit_ & 0x0400)
 915                         os << "Reserved";
 916                 if (wphit_ & 0x0200)
 917                         os << "Reserved:";
 918                 if (wphit_ & 0x0100)
 919                         os << "Reserved:";
 920                 if (wphit_ & 0x0080)
 921                         os << "Reserved:";
 922                 if (wphit_ & 0x0040)
 923                         os << "CDVC:";
 924                 if (wphit_ & 0x0020)
 925                         os << "Reserved:";
 926                 if (wphit_ & 0x0010)
 927                         os << "Reserved:";
 928                 if (wphit_ & 0x0008)
 929                         os << "CDAC4:";
 930                 if (wphit_ & 0x0004)
 931                         os << "CDAC3:";
 932                 if (wphit_ & 0x0002)
 933                         os << "CDAC2:";
 934                 if (wphit_ & 0x0001)
 935                         os << "CDAC1:";
 936                 break;
 937         default:
 938                 os << "Unknown Src:" << source_id_;
 939                 break;
 940         };
 941         return os.str();
 942 }
 943
 944 // decode message info from the packet set
 945 bool NxResourceFullMessage::decode(NxPacketSet &pkt_set)
 946 {
 947         bool ret = true;
 948         source_id_ = decodeSourceId(pkt_set);
 949
 950         // index, start_pos, length
 951         rcode_ = pkt_set.getField32(0, 12, 4);
 952
 953         // index, start_pos, length
 954         rdata_ = pkt_set.getField32(0, 16, 30);
 955
 956         // if there is a optional timestamp
 957         if (pkt_set.packetAtIndexExists(1)) {
 958                 timestamp_ = decodeTimestamp(pkt_set, 1);
 959         }
 960         return ret;
 961 }
 962
 963 // represent this message as a formatted string
 964 string NxResourceFullMessage::asString() const
 965 {
 966         ostringstream os;
 967         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
 968         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
 969                 << endl;
 970         os << "RCODE     : 0x" << hex << setfill('0') << setw(1) << rcode_;
 971         os << " - " << rcodeString() << endl;
 972         os << "RDATA     : 0x" << hex << setfill('0') << setw(8) << rdata_
 973                 << endl;
 974         os << "TIMESTAMP : " << timestampAsString() << endl;
 975         return os.str();
 976 }
 977 // decode the data as a string
 978 const char * NxResourceFullMessage::rcodeString() const
 979 {
 980         switch (rcode_) {
 981         case 0:
 982                 return "Instruction counter";
 983                 break;
 984         case 1:
 985                 return "Branch history buffer";
 986                 break;
 987         case 8:
 988                 return "Timestamp counter";
 989                 break;
 990         default:
 991                 return "Reserved";
 992                 break;
 993         };
 994         return "UNKNOWN";
 995 }
 996
 997 // decode message info from the packet set
 998 bool NxProgramTraceIndirectBranch::decode(NxPacketSet &pkt_set)
 999 {
1000         bool ret = true;
1001         source_id_ = decodeSourceId(pkt_set);
1002
1003         // index, start_pos, length
1004         btype_ = pkt_set.getField32(0, 12, 2);
1005
1006         // index, start_pos, length
1007         icnt_ = pkt_set.getField32(0, 14, 8);
1008
1009         // index, start_pos, length
1010         uaddr_.lower32(pkt_set.getField32(1, 0, 32));
1011         if (pkt_set.getNumMDO(1) > 1) {
1012                 // get the upper 32bits of 64bit address
1013                 uaddr_.upper32(pkt_set.getField32(1, 32, 32));
1014         }
1015
1016         // index, start_pos, length
1017         hist_ = pkt_set.getField32(2, 0, 30);
1018
1019         // if there is a optional timestamp
1020         if (pkt_set.packetAtIndexExists(3)) {
1021                 timestamp_ = decodeTimestamp(pkt_set, 3);
1022         }
1023         return ret;
1024 }
1025
1026 // represent this message as a formatted string
1027 string NxProgramTraceIndirectBranch::asString() const
1028 {
1029         ostringstream os;
1030         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
1031         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
1032                 << endl;
1033         os << "BTYPE     : 0x" << hex << setfill('0') << setw(2) << btype_;
1034         os << " - " << btypeString() << endl;
1035         os << "I-CNT     : " << dec << icnt_ << endl;
1036         os << "U-ADDR    : " << uaddr_.asString() << endl;
1037         os << "HIST      : 0x" << hex << setfill('0') << setw(8) << hist_
1038                 << endl;
1039         os << "TIMESTAMP : " << timestampAsString() << endl;
1040         return os.str();
1041 }
1042
1043 // decode the data as a string
1044 const char * NxProgramTraceIndirectBranch::btypeString() const
1045 {
1046         switch (btype_) {
1047         case 0:
1048                 return "Branch Instruction";
1049                 break;
1050         case 1:
1051                 return "Interrupt";
1052                 break;
1053         default:
1054                 return "Reserved";
1055                 break;
1056         };
1057         return "UNKNOWN";
1058 }
1059
1060 // decode message info from the packet set
1061 bool NxProgramTraceIndirectBranchSync::decode(NxPacketSet &pkt_set)
1062 {
1063         bool ret = true;
1064         source_id_ = decodeSourceId(pkt_set);
1065
1066         // index, start_pos, length
1067         btype_ = pkt_set.getField32(0, 12, 2);
1068
1069         // index, start_pos, length
1070         icnt_ = pkt_set.getField32(0, 14, 8);
1071
1072         // index, start_pos, length
1073         faddr_.lower32(pkt_set.getField32(1, 0, 32));
1074         if (pkt_set.getNumMDO(1) > 1) {
1075                 // get the upper 32bits of 64bit address
1076                 faddr_.upper32(pkt_set.getField32(1, 32, 32));
1077         }
1078
1079         // index, start_pos, length
1080         hist_ = pkt_set.getField32(2, 0, 30);
1081
1082         // if there is a optional timestamp
1083         if (pkt_set.packetAtIndexExists(3)) {
1084                 timestamp_ = decodeTimestamp(pkt_set, 3);
1085         }
1086         return ret;
1087 }
1088
1089 // represent this message as a formatted string
1090 string NxProgramTraceIndirectBranchSync::asString() const
1091 {
1092         ostringstream os;
1093         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
1094         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
1095                 << endl;
1096         os << "BTYPE     : 0x" << hex << setfill('0') << setw(1) << btype_;
1097         os << " - " << btypeString() << endl;
1098         os << "I-CNT     : " << dec << icnt_ << endl;
1099         os << "F-ADDR    : " << faddr_.asString() << endl;
1100         os << "HIST      : 0x" << hex << setfill('0') << setw(8) << hist_
1101                 << endl;
1102         os << "TIMESTAMP : " << timestampAsString() << endl;
1103         return os.str();
1104 }
1105
1106 // decode the data as a string
1107 const char * NxProgramTraceIndirectBranchSync::btypeString() const
1108 {
1109         switch (btype_) {
1110         case 0:
1111                 return "Branch Instruction";
1112                 break;
1113         case 1:
1114                 return "Interrupt";
1115                 break;
1116         default:
1117                 return "Reserved";
1118                 break;
1119         };
1120         return "UNKNOWN";
1121 }
1122
1123 // decode message info from the packet set
1124 bool NxProgramTraceCorrelation::decode(NxPacketSet &pkt_set)
1125 {
1126         bool ret = true;
1127         source_id_ = decodeSourceId(pkt_set);
1128
1129         // index, start_pos, length
1130         evcode_ = pkt_set.getField32(0, 12, 4);
1131
1132         // index, start_pos, length
1133         icnt_ = pkt_set.getField32(0, 16, 8);
1134
1135         // index, start_pos, length
1136         cdata_ = pkt_set.getField32(1, 0, 32);
1137
1138         // if there is a optional timestamp
1139         if (pkt_set.packetAtIndexExists(2)) {
1140                 timestamp_ = decodeTimestamp(pkt_set, 2);
1141         }
1142         return ret;
1143 }
1144
1145 // represent this message as a formatted string
1146 string NxProgramTraceCorrelation::asString() const
1147 {
1148         ostringstream os;
1149         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
1150         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
1151                 << endl;
1152         os << "EVCODE    : 0x" << hex << setfill('0') << setw(1) << evcode_;
1153         os << " - " << evcodeString() << endl;
1154         os << "I-CNT     : " << dec << icnt_ << endl;
1155         os << "CDATA     : 0x" << hex << setfill('0') << setw(8) << cdata_
1156                 << endl;
1157         os << "TIMESTAMP : " << timestampAsString() << endl;
1158         return os.str();
1159 }
1160
1161 // decode the data as a string
1162 const char * NxProgramTraceCorrelation::evcodeString() const
1163 {
1164         switch (evcode_) {
1165         case 0:
1166                 return "Entry into Halted state for debug";
1167                 break;
1168         case 1:
1169                 return "Entry into Halted or Stopped state for Power Mgt.";
1170                 break;
1171         case 4:
1172                 return "Program Trace disabled";
1173                 break;
1174         case 9:
1175                 return "Begin masking of program trace due to MSR[PMM] = 0";
1176                 break;
1177         case 10:
1178                 return "Branch and link occurrence";
1179                 break;
1180         default:
1181                 return "Reserved";
1182                 break;
1183         };
1184         return "UNKNOWN";
1185 }
1186
1187 // ICT for both TCode 34,35
1188 string NxInCircuitTraceBase::tcodeString() const
1189 {
1190         switch (tcode()) {
1191         case 34:
1192                 return "In-Circuit Trace Message";
1193                 break;
1194         case 35:
1195                 return "In-Circuit Trace Sync Message";
1196                 break;
1197         default:
1198                 return "ICT Reserved";
1199                 break;
1200         };
1201         return "UNKNOWN";
1202 }
1203
1204 // decode message info from the packet set
1205 bool NxInCircuitTraceMessage::decode(NxPacketSet &pkt_set)
1206 {
1207         bool ret = true;
1208         source_id_ = decodeSourceId(pkt_set);
1209
1210         // if there is a optional timestamp
1211         if (pkt_set.packetAtIndexExists(1)) {
1212                 timestamp_ = decodeTimestamp(pkt_set, 1);
1213         }
1214
1215         return ret;
1216 }
1217
1218 // represent this message as a formatted string
1219 string NxInCircuitTraceMessage::asString() const
1220 {
1221         ostringstream os;
1222         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
1223         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
1224                 << endl;
1225         os << "MSG TYPE  : " << ICTMessageType() << endl;
1226         os << "TIMESTAMP : " << timestampAsString() << endl;
1227
1228         return os.str();
1229 }
1230
1231 // decode message info from the packet set
1232 bool NxDAMInCircuitTraceMessage::decode(NxPacketSet &pkt_set)
1233 {
1234         bool ret = true;
1235         source_id_ = decodeSourceId(pkt_set);
1236
1237         // index, start_pos, length
1238         ddrmid_ = pkt_set.getField32(0, 12, 1);
1239         ddrsid_ = pkt_set.getField32(0, 13, 8);
1240         ddrtt_ = pkt_set.getField32(0, 21, 3);
1241         if (ddrmid_) {
1242                 ddrsz_ = pkt_set.getField32(0, 24, 4);
1243                 uint32_t ddraddr_1 = pkt_set.getField32(0, 28, 2);
1244                 dddiec_ = pkt_set.getField32(0, 30, 11);
1245                 uint64_t ddraddr_2 = pkt_set.getField64(0, 41, 34);
1246                 ddraddr_ = (ddraddr_2 << 2) | (ddraddr_1 & 0x3);
1247         } else {
1248                 ddraddr_ = pkt_set.getField64(0, 24, 36);
1249         }
1250
1251         // if there is a optional timestamp
1252         if (pkt_set.packetAtIndexExists(1)) {
1253                 timestamp_ = decodeTimestamp(pkt_set, 1);
1254         }
1255
1256         return ret;
1257 }
1258
1259 // decode the type data as a string
1260 const char * NxDAMInCircuitTraceMessage::ddrttString() const
1261 {
1262         switch (ddrtt_) {
1263         case 0:
1264                 return "Write Transaction";
1265                 break;
1266         case 1:
1267                 return "Read Transaction";
1268                 break;
1269         case 3:
1270                 return "Speculative Read Transaction";
1271                 break;
1272         case 4:
1273                 return "Atomic_Clr; RMW, Clear selected fields to zero";
1274                 break;
1275         case 5:
1276                 return "Atomic_Set; RMW, Set selected fields to zero";
1277                 break;
1278         case 6:
1279                 return "Atomic_Dec; RMW, Decrement selected field";
1280                 break;
1281         case 7:
1282                 return "Atomic_Inc; RMW, Increment selected field";
1283                 break;
1284         case 2:
1285                 // fall through to default
1286         default:
1287                 return "Reserved";
1288                 break;
1289         };
1290         return "UNKNOWN";
1291 }
1292
1293 // decode the size data  as a string
1294 string NxDAMInCircuitTraceMessage::ddrszString() const
1295 {
1296         ostringstream os;
1297         if (ddrsz_)
1298                 os << ddrsz_ << "DW";
1299         else
1300                 os << "16DW";
1301
1302         return os.str();
1303 }
1304
1305 // represent this message as a formatted string
1306 string NxDAMInCircuitTraceMessage::asString() const
1307 {
1308         ostringstream os;
1309         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
1310         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
1311                 << endl;
1312         os << "MSG TYPE  : " << ICTMessageType() << endl;
1313         os << "DDR MID   : " << ddrmid_ << " "
1314                 << (ddrmid_ ? "Verbose" : "Terse") << endl;
1315         os << "DDR SID   : " << dec << ddrsid_ << endl;
1316         os << "DDR TT    : " << dec << ddrtt_ << " " << ddrttString() << endl;
1317         if (ddrmid_) {
1318                 os << "DDR SZ    : " << dec << ddrsz_ << " " << ddrszString()
1319                         << endl;
1320                 os << "DDDIEC    : " << dec << dddiec_ << endl;
1321         }
1322         if (isSyncMessage()) {
1323                 os << "F-ADDR    : " << hex << "0x" << ddraddr_ << endl;
1324         } else {
1325                 os << "U-ADDR    : " << hex << "0x" << ddraddr_ << endl;
1326         }
1327         os << "TIMESTAMP : " << timestampAsString() << endl;
1328         return os.str();
1329 }
1330
1331 // decode message info from the packet set
1332 bool NxDPQMInCircuitTraceMessage::decode(NxPacketSet &pkt_set)
1333 {
1334         bool ret = true;
1335         source_id_ = decodeSourceId(pkt_set);
1336
1337         // index, start_pos, length
1338         verb_ = pkt_set.getField32(0, 12, 1);
1339         dpdm_ = pkt_set.getField32(0, 13, 2);
1340         fqid_ = pkt_set.getField32(0, 15, 24);
1341         cnum_ = pkt_set.getField32(0, 39, 13);
1342         pnum_ = pkt_set.getField32(0, 52, 5);
1343         ptype_ = pkt_set.getField32(0, 57, 1);
1344         qet_ = pkt_set.getField32(0, 58, 2);
1345         orf_ = pkt_set.getField32(0, 60, 1);
1346         erf_ = pkt_set.getField32(0, 61, 1);
1347         err_ = pkt_set.getField32(0, 62, 4);
1348
1349         if (verb_) {
1350                 fmbpid_ = pkt_set.getField32(0, 66, 6);
1351                 fmsc_ = pkt_set.getField32(0, 72, 32);
1352                 fmol_ = pkt_set.getField32(0, 104, 29);
1353                 fmfmt_ = pkt_set.getField32(0, 133, 3);
1354                 fmpid_ = pkt_set.getField32(0, 136, 6);
1355                 fmaddr_ = pkt_set.getField64(0, 142, 48);
1356         }
1357         // if there is a optional timestamp
1358         if (pkt_set.packetAtIndexExists(1)) {
1359                 timestamp_ = decodeTimestamp(pkt_set, 1);
1360         }
1361
1362         return ret;
1363 }
1364
1365 // decode the queue event type as a string
1366 const char * NxDPQMInCircuitTraceMessage::queueEventTypeString() const
1367 {
1368         switch (qet_) {
1369         case 0:
1370                 return "Enqueue Command Event";
1371                 break;
1372         case 1:
1373                 return "Deferred Enqueue Complete";
1374                 break;
1375         case 2:
1376                 return "Dequeue Trace Event";
1377                 break;
1378         default:
1379                 return "Reserved";
1380                 break;
1381         };
1382         return "UNKNOWN";
1383 }
1384
1385 // decode the enqueue rejection response code as a string
1386 const char * NxDPQMInCircuitTraceMessage::enqueueRejectionString() const
1387 {
1388         if (erf_) {
1389                 switch (err_) {
1390                 case 0:
1391                         return "Enqueue Command Event";
1392                         break;
1393                 case 1:
1394                         return "Deferred Enqueue Complete";
1395                         break;
1396                 case 2:
1397                         return "Dequeue Trace Event";
1398                         break;
1399                 default:
1400                         return "Reserved";
1401                         break;
1402                 };
1403         }
1404         return "Undefined";
1405 }
1406
1407 // represent this message as a formatted string
1408 string NxDPQMInCircuitTraceMessage::asString() const
1409 {
1410         ostringstream os;
1411         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
1412         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
1413                 << endl;
1414         os << "MSG TYPE  : " << ICTMessageType() << endl;
1415         os << "DBG MARK  : " << dec << dpdm_ << endl;
1416         os << "FQ ID     : 0x" << hex << fqid_ << dec << endl;
1417         os << "CH NUM    : 0x" << hex << cnum_ << dec << endl;
1418         os << "PORT NUM  : " << dec << pnum_ << endl;
1419         os << "PORT TYP  : " << dec << ptype_
1420                 << (ptype_ ? " Direct Connect" : " Software") << endl;
1421         os << "QEVNT TYP : " << dec << qet_ << " " << queueEventTypeString()
1422                 << endl;
1423         os << "ORD REST  : " << dec << orf_ << " Order Restoration"
1424                 << (orf_ ? " was" : " was NOT") << " specified at enqueue"
1425                 << endl;
1426         os << "ENQ REJCT : " << dec << orf_ << " Enqueue operation"
1427                 << (orf_ ? " was" : " was NOT") << " rejected" << endl;
1428         os << "ENQ RESP  : " << hex << "0x" << err_ << dec << " "
1429                 << enqueueRejectionString() << endl;
1430
1431         if (verb_) {
1432                 os << "FRM BP ID : " << hex << "0x" << fmbpid_ << dec << endl;
1433                 os << "FRM STAT  : " << hex << "0x" << fmsc_ << dec << endl;
1434                 os << "FRM OFSET : " << hex << "0x" << fmol_ << dec << endl;
1435                 os << "FRM FMT   : " << hex << "0x" << fmfmt_ << dec << endl;
1436                 os << "FRM PRT ID: " << hex << "0x" << fmpid_ << dec << endl;
1437                 os << "FRM ADDR  : " << hex << "0x" << hex << setfill('0')
1438                         << setw(16) << fmaddr_ << dec << endl;
1439         }
1440
1441         os << "TIMESTAMP : " << timestampAsString() << endl;
1442
1443         return os.str();
1444 }
1445 // decode message info from the packet set
1446 bool NxDPFMInCircuitTraceMessage::decode(NxPacketSet &pkt_set)
1447 {
1448         bool ret = true;
1449         source_id_ = decodeSourceId(pkt_set);
1450
1451         // index, start_pos, length
1452         fmsel_ = pkt_set.getField32(0, 12, 1);
1453         lbeat_ = pkt_set.getField32(0, 13, 1);
1454         btcnt_ = pkt_set.getField32(0, 14, 6);
1455
1456         // capture the 128bit context data
1457         // Fman debug data is byte swapped on word boundries
1458         for (int i = 0; i < 4; i++) {
1459                 context_[i] = SWAPBYTES32(pkt_set.getField32(0, 20+i*32, 32));
1460         }
1461
1462         // if there is a optional timestamp
1463         if (pkt_set.packetAtIndexExists(1)) {
1464                 timestamp_ = decodeTimestamp(pkt_set, 1);
1465         }
1466
1467         return ret;
1468 }
1469
1470 // represent this message as a formatted string
1471 string NxDPFMInCircuitTraceMessage::asString() const
1472 {
1473         ostringstream os;
1474         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
1475         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
1476                 << endl;
1477         os << "MSG TYPE  : " << ICTMessageType() << endl;
1478         os << "FMAN SEL  : " << dec << fmsel_ << " FMAN" << (fmsel_ ? "2" : "1")
1479                 << endl;
1480         os << "LAST BEAT : " << dec << lbeat_ << endl;
1481         os << "BEAT CNT  : " << dec << btcnt_ << endl;
1482         os << "CONTEXT   : " << hex << "0x" << hex << setfill('0') << setw(8)
1483                 << context_[0] << ":" << setfill('0') << setw(8) << context_[1]
1484                 << ":" << setfill('0') << setw(8) << context_[2] << ":"
1485                 << setfill('0') << setw(8) << context_[3] << dec << endl;
1486
1487         os << "TIMESTAMP : " << timestampAsString() << endl;
1488
1489         return os.str();
1490 }
1491
1492 // decode message info from the packet set
1493 bool NxCoreInCircuitTraceMessage::decode(NxPacketSet &pkt_set)
1494 {
1495         bool ret = true;
1496         source_id_ = decodeSourceId(pkt_set);
1497
1498         // index, start_pos, length
1499         cksrc_ = pkt_set.getField32(0, 12, 3);
1500         sync_ = pkt_set.getField32(0, 15, 2);
1501         ckdf_ = pkt_set.getField32(0, 17, 2);
1502         switch (ckdf_) {
1503         case 0:
1504                 ckdata1_ = pkt_set.getField32(0, 19, 32);
1505                 break;
1506         case 1:
1507                 ckdata1_ = pkt_set.getField32(0, 19, 32);
1508                 ckdata2_ = pkt_set.getField32(1, 0, 32);
1509                 break;
1510         default:
1511                 break;
1512         };
1513
1514         // if there is a optional timestamp
1515         if (pkt_set.packetAtIndexExists(2)) {
1516                 timestamp_ = decodeTimestamp(pkt_set, 2);
1517         }
1518
1519         return ret;
1520 }
1521
1522 // decode the sync code as a string
1523 const char * NxCoreInCircuitTraceMessage::syncString() const
1524 {
1525         switch (sync_) {
1526         case 0:
1527                 return "Previous Message successful";
1528                 break;
1529         case 1:
1530                 return "Previous Message not sent due to contention";
1531                 break;
1532         case 2:
1533                 return "Previous Snapshot not completed";
1534                 break;
1535         default:
1536                 return "Reserved";
1537                 break;
1538         };
1539
1540         return "Reserved";
1541 }
1542
1543 // decode the sync code as a string
1544 const char * NxCoreInCircuitTraceMessage::cksrcString() const
1545 {
1546         switch (cksrc_) {
1547         case 0:
1548                 return "PCC[0:61]";
1549                 break;
1550         case 1:
1551                 return "PMCC0[32:64], PMCC1[32:64]";
1552                 break;
1553         case 2:
1554                 return "PMCC2[32:64], PMCC3[32:64]";
1555                 break;
1556         case 3:
1557                 return "PMCC4[32:64], PMCC5[32:64]";
1558                 break;
1559         default:
1560                 return "Reserved";
1561                 break;
1562         };
1563
1564         return "Reserved";
1565 }
1566
1567 // represent this message as a formatted string
1568 string NxCoreInCircuitTraceMessage::asString() const
1569 {
1570         ostringstream os;
1571         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
1572         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
1573                 << endl;
1574         os << "MSG TYPE  : " << ICTMessageType() << endl;
1575         os << "CKSRC     : " << cksrc_ << " - " << cksrcString() << endl;
1576         os << "SYNC      : " << sync_ << " - " << syncString() << endl;
1577         os << "CKDF      : " << ckdf_ << " - " << ckdf_+1 << " CKDATA fields included" << endl;
1578         os << "CKDATA1   : " << "0x" << hex << setfill('0') << setw(8) << ckdata1_ << endl;
1579         if (ckdf_) {
1580                 os << "CKDATA2   : " << "0x" << hex << setfill('0') << setw(8) << ckdata2_ << endl;
1581         }
1582         os << "TIMESTAMP : " << timestampAsString() << endl;
1583         return os.str();
1584 }
1585
1586 // decode message info from the packet set
1587 bool NxTimeStampCorrelation::decode(NxPacketSet &pkt_set)
1588 {
1589         bool ret = true;
1590         source_id_ = decodeSourceId(pkt_set);
1591
1592         // index, start_pos, length
1593         tcorr_ = pkt_set.getField32(0, 12, 4);
1594         ttype_ = pkt_set.getField32(0, 17, 6);
1595
1596         // T4rev1 errata A-004813
1597         if ((source_id_ & 0x1) == 0) {
1598                 tcorr_ = pkt_set.getField32(0, 16, 4);
1599                 ttype_ = pkt_set.getField32(0, 20, 6);
1600         }
1601
1602         // if there is a optional timestamp
1603         if (pkt_set.packetAtIndexExists(1)) {
1604                 timestamp_ = decodeTimestamp(pkt_set, 1);
1605         }
1606
1607         return ret;
1608 }
1609
1610 // represent this message as a formatted string
1611 string NxTimeStampCorrelation::asString() const
1612 {
1613         ostringstream os;
1614         os << "TCODE     : " << dec << tcode() << " " << tcodeString() << endl;
1615         os << "SRC ID    : " << dec << sourceId() << " " << sourceIdString()
1616                 << endl;
1617         os << "TCORR     : 0x" << hex << setfill('0') << setw(4) << tcorr_
1618                 << endl;
1619         os << "T-TYPE    : 0x" << hex << setfill('0') << setw(6) << ttype_
1620                 << " - " << ttypeString() << endl;
1621         os << "TIMESTAMP : " << timestampAsString() << endl;
1622         return os.str();
1623 }
1624
1625 // decode the time stamp type code as a string
1626 const char * NxTimeStampCorrelation::ttypeString() const
1627 {
1628         switch (ttype_) {
1629         case 0:
1630                 return "Periodic";
1631                 break;
1632         case 1:
1633                 return "Halt Mode Exit";
1634                 break;
1635         case 2:
1636                 return "Low Power Mode Exit";
1637                 break;
1638         case 3:
1639                 return "External Event";
1640                 break;
1641         case 8:
1642                 return "CLK1";
1643                 break;
1644         case 9:
1645                 return "CLK1/2";
1646                 break;
1647         case 10:
1648                 return "CLK1/4";
1649                 break;
1650         case 11:
1651                 return "CLK2";
1652                 break;
1653         case 12:
1654                 return "CLK2/2";
1655                 break;
1656         case 13:
1657                 return "CLK2/4";
1658                 break;
1659         case 14:
1660                 return "CLK3";
1661                 break;
1662         case 15:
1663                 return "CLK3/2";
1664                 break;
1665         case 16:
1666                 return "CLK3/4";
1667                 break;
1668         case 0x3f:
1669                 return "Unknown";
1670                 break;
1671         default:
1672                 return "Reserved";
1673                 break;
1674         };
1675
1676         return "Reserved";
1677 }