converter/nexus/FManDebugLog.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 <sstream>
  24 #include <iomanip>
  25 #include <assert.h>
  26
  27 #include "FManDebugLog.h"
  28
  29 using std::ostringstream;
  30 using std::endl;
  31 using std::hex;
  32 using std::dec;
  33 using std::setfill;
  34 using std::setw;
  35
  36 // return the log to the initial state
  37 void FManDebugLog::reset()
  38 {
  39         log_complete_ = false;
  40         log_parse_error_ = LOG_PARSE_NO_ERROR;
  41         vector<FManModuleDebugLog*>::iterator it;
  42         for (it = logs_.begin(); it != logs_.end(); it++) {
  43                 delete *it;
  44         }
  45         logs_.clear();
  46
  47         context_complete_ = false;
  48         context_data_.clear();
  49 }
  50
  51 // add context data to the log
  52 bool FManDebugLog::addContextData(uint32_t context_data)
  53 {
  54         if (!context_complete_) {
  55                 context_data_.push_back(context_data);
  56         }
  57         return !context_complete_;
  58 }
  59
  60 // parse the context data into the defined sub module logs
  61 bool FManDebugLog::parseContextData()
  62 {
  63         FManModuleDebugLog *log;
  64
  65         if (!context_complete_) {
  66                 log_complete_ = false;
  67                 return log_complete_;
  68         }
  69
  70         vector<uint32_t>::iterator pos = context_data_.begin();
  71         while (pos < context_data_.end() &&
  72                 log_parse_error_ == LOG_PARSE_NO_ERROR) {
  73
  74                 // size of this log entry context data in bytes
  75                 // except for Fman Controller where it denotes words
  76                 uint32_t data_len = (*pos >> NIA_SIZE_SHIFT & NIA_SIZE_MASK);
  77                 if (data_len == 0) {
  78                         log_parse_error_ = LOG_PARSE_DATA_LENGTH_ERROR;
  79                         break;
  80                 }
  81
  82                 // identify the type of log from the word at pos
  83                 int eng = *pos >> NIA_ENG_SHIFT & NIA_ENG_MASK;
  84                 switch (eng) {
  85                 case 0x0: {
  86                         // data_len is measured here in words (4bytes)
  87                         assert(data_len == 1 || data_len == 2 || data_len == 3);
  88                         vector<uint32_t>::iterator frame_end = pos + data_len;
  89                         vector<uint32_t> c_data(pos, frame_end);
  90                         log = new FManControllerDebugLog();
  91                         log->parseContextData(c_data);
  92                         logs_.push_back(log);
  93                         pos = frame_end;
  94                 }
  95                         break;
  96                 case 0x11: // FManParser
  97                 {
  98                         // round up the data_len to the next 4 byte multiple
  99                         data_len =
 100                                 data_len % 4 ?
 101                                         (data_len & 0xfffffffc) + 4 : data_len;
 102                         assert(data_len % 4 == 0);
 103                         vector<uint32_t>::iterator frame_end = pos
 104                                 + data_len / 4;
 105                         vector<uint32_t> c_data(pos, frame_end);
 106                         log = new FManParserDebugLog();
 107                         log->parseContextData(c_data);
 108                         logs_.push_back(log);
 109                         pos = frame_end;
 110                 }
 111                         break;
 112                 case 0x12: // FManKeyGen
 113                 {
 114                         assert(
 115                                 data_len == 4 || data_len == 8
 116                                         || data_len == 12);
 117                         vector<uint32_t>::iterator frame_end = pos
 118                                 + data_len / 4;
 119                         vector<uint32_t> c_data(pos, frame_end);
 120                         log = new FManKeyGenDebugLog();
 121                         log->parseContextData(c_data);
 122                         logs_.push_back(log);
 123                         pos = frame_end;
 124                 }
 125                         break;
 126                 case 0x13: // FmanPolicer
 127                 {
 128                         assert(
 129                                 data_len == 8 || data_len == 16
 130                                         || data_len == 32);
 131                         vector<uint32_t>::iterator frame_end = pos
 132                                 + data_len / 4;
 133                         vector<uint32_t> c_data(pos, frame_end);
 134                         log = new FManPolicerDebugLog();
 135                         log->parseContextData(c_data);
 136                         logs_.push_back(log);
 137                         pos = frame_end;
 138                 }
 139                         break;
 140                 case 0x14: // FManBMI
 141                 {
 142                         assert(
 143                                 data_len == 8 || data_len == 16
 144                                         || data_len == 32);
 145                         vector<uint32_t>::iterator frame_end = pos
 146                                 + data_len / 4;
 147                         if (frame_end <= context_data_.end()) {
 148                                 vector<uint32_t> c_data(pos, frame_end);
 149                                 log = new FManBMIDebugLog();
 150                                 log->parseContextData(c_data);
 151                                 logs_.push_back(log);
 152                                 pos = frame_end;
 153                         } else {
 154                                 log_parse_error_ = LOG_PARSE_DATA_LENGTH_ERROR;
 155                         }
 156                 }
 157                         break;
 158                 case 0x15: {
 159                         assert(
 160                                 data_len == 4 || data_len == 8
 161                                         || data_len == 20);
 162                         vector<uint32_t>::iterator frame_end = pos
 163                                 + data_len / 4;
 164                         vector<uint32_t> c_data(pos, frame_end);
 165                         log = new FManQMIEnqueueDebugLog();
 166                         log->parseContextData(c_data);
 167                         logs_.push_back(log);
 168                         pos = frame_end;
 169                 }
 170                         break;
 171                 case 0x16: {
 172                         assert(
 173                                 data_len == 4 || data_len == 8
 174                                         || data_len == 20);
 175                         vector<uint32_t>::iterator frame_end = pos
 176                                 + data_len / 4;
 177                         vector<uint32_t> c_data(pos, frame_end);
 178                         log = new FManQMIDequeueDebugLog();
 179                         log->parseContextData(c_data);
 180                         logs_.push_back(log);
 181                         pos = frame_end;
 182                 }
 183                         break;
 184                 default:
 185                         log_parse_error_ = LOG_PARSE_UNDEFINED_ENG_ERROR;
 186                         break;
 187                 }
 188         }
 189
 190         log_complete_ = true;
 191
 192         return log_complete_;
 193 }
 194
 195 // Output logs as a string
 196 // Enforces a format template for log output
 197 string FManDebugLog::asString() const
 198 {
 199         ostringstream os;
 200         os << "Debug Trace Log for FMAN" << (fmanID_ + 1) << endl;
 201         os << "-------------------------" << endl;
 202
 203         // for debug only print out the context data
 204         if (log_parse_error_ == LOG_PARSE_NO_ERROR) {
 205                 // print all the existing module specific (sub) logs
 206                 vector<FManModuleDebugLog*>::const_iterator it;
 207                 for (it = logs_.begin(); it != logs_.end(); it++) {
 208                         os << (*it)->asString();
 209                 }
 210                 os << endl;
 211         } else {
 212                 os << "Warning: Detected error during evaluation of context data."
 213                         << endl;
 214                 switch (log_parse_error_) {
 215                 case LOG_PARSE_DATA_LENGTH_ERROR:
 216                         os << "Data length value is incorrect." << endl;
 217                         break;
 218                 case LOG_PARSE_UNDEFINED_ENG_ERROR:
 219                         os << "Undefined FMan Engine." << endl;
 220                         break;
 221                 default:
 222                         os << "PROGRAM ERROR: Report this!" << endl;
 223                         break;
 224                 }
 225                 os << "Context raw data follows:"
 226                         << endl;
 227                 vector<uint32_t>::const_iterator i;
 228                 for (i = context_data_.begin(); i != context_data_.end(); i++) {
 229                         os << "0x" << hex << setw(8) << setfill('0') << *i
 230                                 << dec << endl;
 231                 }
 232         }
 233
 234         return os.str();
 235 }
 236 // output top level log as a string
 237 string FManModuleDebugLog::asString() const
 238 {
 239         ostringstream os;
 240
 241         // module identifier
 242         os << nameAsString() << endl;
 243
 244         // Module generic information
 245         os << "NIA VL    : " << verbosity_level_;
 246         switch (verbosity_level_) {
 247         case FMAN_TRACE_DISABLED:
 248                 os << " - Trace Disabled";
 249                 break;
 250         case FMAN_TRACE_MINIMUM:
 251                 os << " - Minimal Trace";
 252                 break;
 253         case FMAN_TRACE_VERBOSE:
 254                 os << " - Verbose Trace";
 255                 break;
 256         case FMAN_TRACE_VERY_VERBOSE:
 257                 os << " - Very Verbose Trace";
 258                 break;
 259         default:
 260                 os << " - Invalid verbosity level";
 261                 break;
 262         }
 263         os << endl;
 264
 265         os << "NIA ORR   : " << dec << order_restoration_required_
 266                 << " - Order restoration "
 267                 << (order_restoration_required_ ? "is" : "is NOT")
 268                 << " required." << endl;
 269
 270         // add the module specific information
 271         os << asString_();
 272
 273         if (has_timestamp_) {
 274                 os << "FM TSTAMP : " << timestamp_ << " (0x" << hex << setw(8)
 275                         << setfill('0') << timestamp_ << ")" << dec << endl;
 276         }
 277
 278         return os.str();
 279 }
 280
 281 // parse the context data header before calling the log specific parser
 282 bool FManModuleDebugLog::parseContextData(vector<uint32_t> &context_data)
 283 {
 284         vector<uint32_t>::iterator start = context_data.begin();
 285
 286         verbosity_level_ = *start >> NIA_VL_SHIFT & NIA_VL_MASK;
 287         order_restoration_required_ = *start >> NIA_ORR_SHIFT & NIA_ORR_MASK;
 288
 289         return parseContextData_(context_data);
 290 }
 291
 292 // output a port ID string
 293 string FManModuleDebugLog::portIDasString_(uint32_t port_id) const
 294 {
 295         ostringstream os;
 296
 297         switch (port_id) {
 298         case 0x1:
 299         case 0x2:
 300         case 0x3:
 301         case 0x4:
 302         case 0x5:
 303         case 0x6:
 304         case 0x7:
 305                 os << "Offline/Host " << dec << port_id;
 306                 break;
 307         case 0x8:
 308         case 0x9:
 309         case 0xa:
 310         case 0xb:
 311         case 0xc:
 312         case 0xd:
 313         case 0xe:
 314         case 0xf:
 315                 os << "1/2.5G Eth" << dec << port_id - 0x8 << " Rx";
 316                 break;
 317         case 0x10:
 318                 os << "(10G Eth1 - 1/2.5G Eth9) Rx";
 319                 break;
 320         case 0x11:
 321                 os << "(10G Eth2 - 1/2.5G Eth10) Rx";
 322                 break;
 323         case 0x28:
 324         case 0x29:
 325         case 0x2a:
 326         case 0x2b:
 327         case 0x2c:
 328         case 0x2d:
 329         case 0x2e:
 330         case 0x2f:
 331                 os << "1/2.5G Eth" << dec << port_id - 0x8 << " Tx";
 332                 break;
 333         case 0x30:
 334                 os << "(10G Eth1 - 1/2.5G Eth9) Tx";
 335                 break;
 336         case 0x31:
 337                 os << "(10G Eth2 - 1/2.5G Eth10) Tx";
 338                 break;
 339         default:
 340                 os << "Unknown Port ID";
 341                 break;
 342         }
 343
 344         return os.str();
 345 }
 346
 347 // ------------------------------------------------------------------------------
 348
 349 // parse the context data
 350 bool FManControllerDebugLog::parseContextData_(vector<uint32_t> &context_data)
 351 {
 352         bool ret = true;
 353
 354         if (verbosity_level_ == FMAN_TRACE_VERBOSE
 355                 || verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 356                 timestamp_ = context_data[1];
 357                 has_timestamp_ = true;
 358         }
 359
 360         if (verbosity_level_ == FMAN_TRACE_MINIMUM
 361                 || verbosity_level_ == FMAN_TRACE_VERBOSE
 362                 || verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 363                 action_code_ = context_data[0] >> NIA_AC_SHIFT & NIA_AC_MASK;
 364         }
 365
 366         return ret;
 367 }
 368
 369 // output log as a string
 370 string FManControllerDebugLog::asString_() const
 371 {
 372         ostringstream os;
 373
 374         // Display the formatted Action code
 375         os << "ACTION CD : 0x" << hex << setw(8) << setfill('0') << action_code_
 376                 << dec << " - ";
 377         switch (action_code_) {
 378         case CTRL_CLASSIF_CMD:
 379                 os << "Coarse Classification";
 380                 break;
 381         case CTRL_INDEP_TX_CMD:
 382                 os << "Independent Mode Transmit";
 383                 break;
 384         case CTRL_INDEP_RX_CMD:
 385                 os << "Independent Mode Receive";
 386                 break;
 387         case CTRL_HOST_CMD:
 388                 os << "Host Commands";
 389                 break;
 390         default:
 391                 os << "Unknown Action Code";
 392                 break;
 393         }
 394         os << endl;
 395
 396         return os.str();
 397 }
 398
 399 // parse the context data
 400 bool FManParserDebugLog::parseContextData_(vector<uint32_t> &context_data)
 401 {
 402         bool ret = true;
 403
 404         if (verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 405                 parse_start_point_ = context_data[2];
 406                 // gather up to max program counters
 407                 // from the remaining data
 408         }
 409
 410         if (verbosity_level_ == FMAN_TRACE_VERBOSE
 411                 || verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 412                 timestamp_ = context_data[1];
 413                 has_timestamp_ = true;
 414         }
 415
 416         if (verbosity_level_ == FMAN_TRACE_MINIMUM
 417                 || verbosity_level_ == FMAN_TRACE_VERBOSE
 418                 || verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 419                 hxs_id_ = context_data[0] >> NIA_AC_HXS_ID_SHIFT
 420                         & NIA_AC_HXS_ID_MASK;
 421         }
 422
 423         return ret;
 424 }
 425
 426 // output log as a string
 427 string FManParserDebugLog::asString_() const
 428 {
 429         ostringstream os;
 430
 431         // Display the formatted Action code
 432         os << "HXS ID    : 0x" << hex << setw(8) << setfill('0') << hxs_id_
 433                 << dec << " - ";
 434         switch (hxs_id_) {
 435         case PARSER_ETH_CMD:
 436                 os << "Ethernet HXS";
 437                 break;
 438         case PARSER_LLC_SNAP_CMD:
 439                 os << "LLC+SNAP HXS";
 440                 break;
 441         case PARSER_VLAN_CMD:
 442                 os << "VLAN HXS";
 443                 break;
 444         case PARSER_PPP_CMD:
 445                 os << "PPPoE+PPP HXS";
 446                 break;
 447         case PARSER_MPLS_CMD:
 448                 os << "MPLS HXS";
 449                 break;
 450         case PARSER_IPV4_CMD:
 451                 os << "IPV4 HXS";
 452                 break;
 453         case PARSER_IPV6_CMD:
 454                 os << "IPV6 HXS";
 455                 break;
 456         case PARSER_GRE_CMD:
 457                 os << "GRE HXS";
 458                 break;
 459         case PARSER_MINENCAP_CMD:
 460                 os << "MinEncap HXS";
 461                 break;
 462         case PARSER_OTHER_L3_CMD:
 463                 os << "Other L3 Shell HXS";
 464                 break;
 465         case PARSER_TCP_CMD:
 466                 os << "TCP HXS";
 467                 break;
 468         case PARSER_UDP_CMD:
 469                 os << "UDP HXS";
 470                 break;
 471         case PARSER_IPSEC_CMD:
 472                 os << "IPSec Shell HXS";
 473                 break;
 474         case PARSER_SCTP_CMD:
 475                 os << "SCTP Shell HXS";
 476                 break;
 477         case PARSER_DCCP_CMD:
 478                 os << "DCCP Shell HXS";
 479                 break;
 480         case PARSER_OTHER_L4_CMD:
 481                 os << "Other L4 Shell HXS";
 482                 break;
 483         case PARSER_NULL_CMD:
 484                 os << "Null Parsing";
 485                 break;
 486         default:
 487                 if (hxs_id_ >= 0x020 && hxs_id_ <= 0x3fd) {
 488                         os << "Soft Parse Program 0x" << hex << setw(8)
 489                                 << setfill('0') << hxs_id_;
 490                 } else {
 491                         os << "unknown value";
 492                 }
 493                 break;
 494         }
 495         os << endl;
 496
 497         return os.str();
 498 }
 499
 500 // parse the context data
 501 bool FManKeyGenDebugLog::parseContextData_(vector<uint32_t> &context_data)
 502 {
 503         bool ret = true;
 504
 505         if (verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 506                 selected_scheme_ = context_data[2] >> FMKG_SS_SHIFT & FMKG_SS_MASK;
 507                 int_frame_ptr_ = context_data[2] >> FMKG_IFP_SHIFT & FMKG_IFP_MASK;
 508         }
 509
 510         if (verbosity_level_ == FMAN_TRACE_VERBOSE
 511                 || verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 512                 timestamp_ = context_data[1];
 513                 has_timestamp_ = true;
 514         }
 515
 516         if (verbosity_level_ == FMAN_TRACE_MINIMUM
 517                 || verbosity_level_ == FMAN_TRACE_VERBOSE
 518                 || verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 519                 ccen_ = context_data[0] >> NIA_AC_CCEN_SHIFT & NIA_AC_CCEN_MASK;
 520                 ss_ = context_data[0] >> NIA_AC_SS_SHIFT & NIA_AC_SS_MASK;
 521                 scheme_ = context_data[0] >> NIA_AC_SCHEME_SHIFT
 522                         & NIA_AC_SCHEME_MASK;
 523         }
 524
 525         return ret;
 526 }
 527
 528 // output log as a string
 529 string FManKeyGenDebugLog::asString_() const
 530 {
 531         ostringstream os;
 532
 533         // Display the formatted Action code
 534         os << "CCEN      : " << ccen_ << " - Coarse Classification "
 535                 << (ccen_ ? "does" : "does NOT")
 536                 << " overwrite the IC field CCBASE" << endl;
 537         os << "SCHEME SEL: " << ss_ << " - "
 538                 << (ss_ ? "Using SCHEME number" :
 539                         "Selected according to parse result") << endl;
 540         if (ss_) {
 541                 os << "SCHEME    : 0x" << setw(2) << setfill('0')
 542                         << scheme_ << dec << endl;
 543         }
 544
 545         if (verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 546                 os << "SEL SCHEME: 0x" << setw(2) << setfill('0')
 547                         << selected_scheme_ << dec << endl;
 548                 os << "IN FRM PTR: 0x" << setw(4) << setfill('0')
 549                         << int_frame_ptr_ << dec << endl;
 550         }
 551
 552         return os.str();
 553 }
 554
 555 // parse the context data
 556 bool FManPolicerDebugLog::parseContextData_(vector<uint32_t> &context_data)
 557 {
 558         bool ret = true;
 559
 560         if (verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 561                 profile_cbs_ = context_data[4];
 562                 profile_cts_ = context_data[5];
 563                 profile_pbs_ebs_ = context_data[6];
 564                 profile_ets_ = context_data[7];
 565         }
 566
 567         if (verbosity_level_ == FMAN_TRACE_VERBOSE
 568                 || verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 569                 fcs_action_ = (uint8_t) (context_data[2] >> POLICE_FCS_SHIFT
 570                         & POLICE_FCS_MASK);
 571                 port_id_ = (uint8_t) (context_data[2] >> POLICE_PORTID_SHIFT
 572                         & POLICE_PORTID_MASK);
 573                 pkt_length_ = (context_data[3] >> POLICE_PKTLEN_LSB_SHIFT
 574                         & POLICE_PKTLEN_LSB_MASK)
 575                         | ((context_data[2] >> POLICE_PKTLEN_MSB_SHIFT
 576                                 & POLICE_PKTLEN_MSB_MASK) << 16);
 577         }
 578
 579         if (verbosity_level_ == FMAN_TRACE_MINIMUM
 580                 || verbosity_level_ == FMAN_TRACE_VERBOSE
 581                 || verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 582                 timestamp_ = context_data[1];
 583                 has_timestamp_ = true;
 584                 pmo_ = context_data[0] >> NIA_AC_PMO_SHIFT & NIA_AC_PMO_MASK;
 585                 pnum_ = context_data[0] >> NIA_AC_PNUM_SHIFT & NIA_AC_PNUM_MASK;
 586         }
 587
 588         return ret;
 589 }
 590
 591 // output log as a string
 592 string FManPolicerDebugLog::asString_() const
 593 {
 594         ostringstream os;
 595         // Display the formatted Action code
 596
 597         if (verbosity_level_ == FMAN_TRACE_MINIMUM
 598                 || verbosity_level_ == FMAN_TRACE_VERBOSE
 599                 || verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 600                 os << "NIA PMO   : " << (uint32_t)pmo_ << endl;
 601                 os << "NIA PNUM  : 0x" << hex << setw(2) << setfill('0')
 602                         << (uint32_t)pnum_ << dec << endl;
 603         }
 604
 605         if (verbosity_level_ == FMAN_TRACE_VERBOSE
 606                 || verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 607                 os << "FCS       : " << (uint32_t)fcs_action_ << endl;
 608                 os << "PORT ID   : 0x" << hex << setw(8) << setfill('0')
 609                         << (uint32_t)port_id_ << dec
 610                         << " - " << portIDasString_(port_id_) << endl;
 611                 os << "PKT LEN   : 0x" << hex << setw(8) << setfill('0')
 612                         << pkt_length_ << dec << endl;
 613         }
 614
 615         if (verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 616                 os << "PRFL_CBS  : 0x" << hex << setw(8) << setfill('0')
 617                         << profile_cbs_ << dec << endl;
 618                 os << "PRFL_CTS  : 0x" << hex << setw(8) << setfill('0')
 619                         << profile_cts_ << dec << endl;
 620                 os << "PRFL_P/EBS: 0x" << hex << setw(8) << setfill('0')
 621                         << profile_pbs_ebs_ << dec << endl;
 622                 os << "PRFL_CTS  : 0x" << hex << setw(8) << setfill('0')
 623                         << profile_cts_ << dec << endl;
 624         }
 625
 626         return os.str();
 627 }
 628
 629 // parse the context data
 630 bool FManBMIDebugLog::parseContextData_(vector<uint32_t> &context_data)
 631 {
 632         static const uint32_t BMI_PORTID_MASK = 0xff;
 633         static const uint32_t BMI_PORTID_SHIFT = 0;
 634         static const uint32_t BMI_TRAP_STATE_MASK = 0x7;
 635         static const uint32_t BMI_TRAP_STATE_SHIFT = 8;
 636         static const uint32_t BMI_FD_MASK = 0xffff;
 637         static const uint32_t BMI_FD_SHIFT = 15;
 638
 639         bool ret = true;
 640
 641         // Special handling for the FD data
 642         fd_[0] = fd_[1] = fd_[2] = fd_[3] = 0;
 643         switch (verbosity_level_) {
 644         case FMAN_TRACE_VERY_VERBOSE:
 645                 fd_[0] = context_data[4];
 646                 fd_[1] = context_data[5];
 647                 fd_[2] = context_data[6];
 648                 fd_[3] = context_data[7];
 649                 break;
 650         case FMAN_TRACE_VERBOSE:
 651                 fd_[2] = context_data[1] >> BMI_FD_SHIFT & BMI_FD_MASK;
 652                 fd_[3] = context_data[3];
 653                 break;
 654         case FMAN_TRACE_MINIMUM:
 655                 fd_[2] = context_data[1] >> BMI_FD_SHIFT & BMI_FD_MASK;
 656                 break;
 657         case FMAN_TRACE_DISABLED:
 658         default:
 659                 break;
 660         }
 661
 662         if (verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 663         }
 664
 665         if (verbosity_level_ == FMAN_TRACE_VERBOSE
 666                 || verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 667                 timestamp_ = context_data[2];
 668                 has_timestamp_ = true;
 669         }
 670
 671         if (verbosity_level_ == FMAN_TRACE_MINIMUM
 672                 || verbosity_level_ == FMAN_TRACE_VERBOSE
 673                 || verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 674                 port_id_ = context_data[1] >> BMI_PORTID_SHIFT
 675                         & BMI_PORTID_MASK;
 676                 debug_trap_state_ = context_data[1] >> BMI_TRAP_STATE_SHIFT
 677                         & BMI_TRAP_STATE_MASK;
 678                 action_code_ = context_data[0] >> NIA_AC_SHIFT & NIA_AC_MASK;
 679         }
 680
 681         return ret;
 682 }
 683
 684 // output log as a string
 685 string FManBMIDebugLog::asString_() const
 686 {
 687         ostringstream os;
 688
 689         // Display the formatted Action code
 690         os << "ACTION CD : 0x" << hex << setw(8) << setfill('0') << action_code_
 691                 << dec << " - ";
 692         switch (action_code_) {
 693         case BMI_INI_CMD:
 694                 os << "Initialize";
 695                 break;
 696         case BMI_REL_INT_BUF_TNUM_TERM_CMD:
 697                 os
 698                         << "Release internal buffers and tnum. Termination of the task";
 699                 break;
 700         case BMI_REL_INT_IC_BUF_TNUM_TERM_CMD:
 701                 os
 702                         << "Release internal IC buffers and tnum. Termination of the task";
 703                 break;
 704         case BMI_TX_FR_REL_BUF_OR_ENQ_CMD:
 705                 os
 706                         << "Transmit frame and release external and internal buffers or enqueue to return FQID";
 707                 break;
 708         case BMI_TX_FR_NO_DMA_CMD:
 709                 os << "Transmit frame without DMA";
 710                 break;
 711         case BMI_TX_FR_NO_DMA_REL_INT_BUF_CMD:
 712                 os << "Transmit frame without DMA and release internal buffers";
 713                 break;
 714         case BMI_TX_FR_NO_DMA_REL_INT_BUF_TERM_CMD:
 715                 os
 716                         << "Transmit frame without DMA, release internal buffers and terminate";
 717                 break;
 718         case BMI_ENQ_FR_CMD:
 719                 os << "Prepare to enqueue frame";
 720                 break;
 721         case BMI_DISC_FR_TERM_CMD:
 722                 os << "Discard frame. Termination of the task";
 723                 break;
 724         case BMI_FETCH_FR_EXE_CMD:
 725                 os << "Fetch frame and execute";
 726                 break;
 727         case BMI_FETCH_FR_HDR_EXE_CMD:
 728                 os << "Fetch frame header and execute";
 729                 break;
 730         default:
 731                 os << "Unknown Action code";
 732                 break;
 733         }
 734         os << endl;
 735
 736         os << "PORT ID   : 0x" << hex << port_id_ << dec
 737                 << " - " << portIDasString_(port_id_) << endl;
 738         os << "TRAP STATE: 0x" << hex << debug_trap_state_ << dec << " -";
 739         os << (debug_trap_state_ & 0x4 ? " A:set" : " A:clr");
 740         os << (debug_trap_state_ & 0x2 ? " B:set" : " B:clr");
 741         os << (debug_trap_state_ & 0x1 ? " C:set" : " C:clr");
 742         os << endl;
 743         os << "FD Addr   : 0x" << hex << setw(8) << setfill('0') << fd_[0]
 744                 << ":" << setw(8) << setfill('0') << fd_[1] << ":" << setw(8)
 745                 << setfill('0') << fd_[2] << ":" << setw(8) << setfill('0')
 746                 << fd_[3] << dec << endl;
 747
 748         return os.str();
 749 }
 750
 751 // parse the context data
 752 bool FManQMIDebugLog::parseContextData_(vector<uint32_t> &context_data)
 753 {
 754         bool ret = true;
 755
 756         if (verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 757                 cfg_port_pri_ = (uint8_t) (context_data[3]
 758                         >> QMI_CFG_PORTPRI_SHIFT & QMI_CFG_PORTPRI_MASK);
 759                 cfg_deq_opt_ = (uint8_t) (context_data[3]
 760                         >> QMI_CFG_DEQOPT_SHIFT & QMI_CFG_DEQOPT_MASK);
 761                 cfg_port_en_ = (uint8_t) (context_data[3]
 762                         >> QMI_CFG_PORTEN_SHIFT & QMI_CFG_PORTEN_MASK);
 763                 cfg_pref_opt_ = (uint8_t) (context_data[3]
 764                         >> QMI_CFG_PREFOPT_SHIFT & QMI_CFG_PREFOPT_MASK);
 765                 cfg_frm_cnt_ = (uint8_t) (context_data[3]
 766                         >> QMI_CFG_FRMCNT_SHIFT & QMI_CFG_FRMCNT_MASK);
 767                 cfg_sub_port_ = (uint8_t) (context_data[3]
 768                         >> QMI_CFG_SUBPORT_SHIFT & QMI_CFG_SUBPORT_MASK);
 769                 cfg_byte_cnt_ = context_data[3] >> QMI_CFG_BYTECNT_SHIFT
 770                         & QMI_CFG_BYTECNT_MASK;
 771
 772                 fd_cmd_ = context_data[3];
 773
 774                 res_sp_ = (uint8_t) (context_data[4] >> QMI_RES_SP_SHIFT
 775                         & QMI_RES_SP_MASK);
 776                 res_fqid_src_ = (uint8_t) (context_data[4]
 777                         >> QMI_RES_FQIDSRC_SHIFT & QMI_RES_FQIDSRC_MASK);
 778                 res_byte_cnt_ = (context_data[4] >> QMI_RES_BYTECNT_SHIFT
 779                         & QMI_RES_BYTECNT_MASK);
 780                 res_frm_cnt_ = (uint8_t) (context_data[4]
 781                         >> QMI_RES_FRMCNT_SHIFT & QMI_RES_FRMCNT_MASK);
 782                 res_tag_ = (uint8_t) (context_data[4] >> QMI_RES_TAG_SHIFT
 783                         & QMI_RES_TAG_MASK);
 784         }
 785
 786         if (verbosity_level_ == FMAN_TRACE_VERBOSE
 787                 || verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 788                 timestamp_ = context_data[1];
 789                 has_timestamp_ = true;
 790         }
 791
 792         if (verbosity_level_ == FMAN_TRACE_MINIMUM
 793                 || verbosity_level_ == FMAN_TRACE_VERBOSE
 794                 || verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 795         }
 796
 797         return ret;
 798 }
 799
 800 // output log as a string
 801 string FManQMIDebugLog::asString_() const
 802 {
 803         ostringstream os;
 804
 805         if (verbosity_level_ == FMAN_TRACE_VERY_VERBOSE) {
 806                 os << "PORT ENB  : " << (uint32_t)cfg_port_en_ << " - Port "
 807                         << (cfg_port_en_ ? "is" : "is NOT") << " enabled"
 808                         << endl;
 809                 os << "PORT PRI  : " << (uint32_t)cfg_port_pri_
 810                         << (cfg_port_pri_ ? " - High" : " - Normal")
 811                         << " priority" << endl;
 812                 os << "DEQUE OPT : " << (uint32_t)cfg_deq_opt_ << " - ";
 813                 switch (cfg_deq_opt_) {
 814                 case 0:
 815                         os << "Reserved" << endl;
 816                         break;
 817                 case 1:
 818                         os
 819                                 << "Dequeue with priority precedence and use intra-class scheduling"
 820                                 << endl;
 821                         break;
 822                 case 2:
 823                         os
 824                                 << "Dequeue with active FQ precedence and use intra-class scheduling"
 825                                 << endl;
 826                         break;
 827                 case 3:
 828                         os
 829                                 << "Dequeue with active FQ precedence and override intra-class scheduling"
 830                                 << endl;
 831                         break;
 832                 default:
 833                         os << "Reserved" << endl;
 834                         break;
 835                 }
 836                 os << "PREF OPT  : " << (uint32_t)cfg_pref_opt_ << endl;
 837                 os << "FRAME CNT : " << (uint32_t)cfg_frm_cnt_ << " - Dequeue "
 838                         << (cfg_frm_cnt_ ? "up to three" : "at most one")
 839                         << endl;
 840                 os << "CFG BYT CNT: 0x" << hex << setw(4) << setfill('0')
 841                         << cfg_byte_cnt_ << dec << endl;
 842                 os << "FD CMD    : 0x" << hex << setw(8) << setfill('0')
 843                         << fd_cmd_ << dec << endl;
 844                 os << "SUB PORT  : " << (uint32_t)cfg_sub_port_
 845                         << " - Response sub portal" << endl;
 846                 os << "RES SP    : " << (uint32_t)res_sp_ << endl;
 847                 os << "RES FQID  : " << (uint32_t)res_fqid_src_;
 848                 switch (res_fqid_src_) {
 849                 case 0:
 850                         os << " - Default" << endl;
 851                         break;
 852                 case 1:
 853                         os << " - Context B" << endl;
 854                         break;
 855                 case 2:
 856                         os << " - FD command field" << endl;
 857                         break;
 858                 case 3:
 859                         os << " - TNUM has bypassed dequeue block" << endl;
 860                         break;
 861                 default:
 862                         os << " - Unknown" << endl;
 863                         break;
 864                 }
 865                 os << "RES BYT CNT: " << hex << setw(4) << setfill('0')
 866                         << res_byte_cnt_ << dec
 867                         << " - Response byte count level control" << endl;
 868                 os << "RES FRM CNT: " << (uint32_t)res_frm_cnt_ << endl;
 869                 os << "RES TAG    : 0x" << hex << setw(2) << setfill('0')
 870                         << (uint32_t)res_tag_ << dec << endl;
 871         }
 872
 873         return os.str();
 874 }