tools/tools/vxge/vxge_log.c

   1 /*-
   2  * Copyright(c) 2002-2011 Exar Corp.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification are permitted provided the following conditions are met:
   7  *
   8  *    1. Redistributions of source code must retain the above copyright notice,
   9  *       this list of conditions and the following disclaimer.
  10  *
  11  *    2. Redistributions in binary form must reproduce the above copyright
  12  *       notice, this list of conditions and the following disclaimer in the
  13  *       documentation and/or other materials provided with the distribution.
  14  *
  15  *    3. Neither the name of the Exar Corporation nor the names of its
  16  *       contributors may be used to endorse or promote products derived from
  17  *       this software without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  23  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31 /*$FreeBSD$*/
  32
  33 #include "vxge_log.h"
  34
  35 static FILE *fdAll;
  36
  37 /*
  38  * vxge_print_registers
  39  * Prints/logs Register values
  40  * @registers Register values
  41  */
  42 void
  43 vxge_print_registers(void *registers)
  44 {
  45         int i = 0, j = 0;
  46         u64 noffset, nRegValue = 0;
  47         char szName[64];
  48
  49         fdAll = fopen("vxge_regs.log", "w+");
  50         if (!fdAll)
  51                 return;
  52
  53         VXGE_PRINT_REG_NAME(fdAll, "Registers : COMMON");
  54         VXGE_PRINT_HEADER_REGS(fdAll);
  55
  56         for (i = 0; i < VXGE_HAL_MGMT_REG_COUNT_COMMON; i++) {
  57                 if (reginfo_registers[i].size == 1)
  58                         strlcpy(szName, reginfo_registers[i].name,
  59                             sizeof(szName));
  60
  61                 for (j = 0; j < reginfo_registers[i].size; j++) {
  62                         noffset = reginfo_registers[i].offset + (0x8 * j);
  63
  64                         if (reginfo_registers[i].size > 1)
  65                                 snprintf(szName, sizeof(szName),
  66                                     reginfo_registers[i].name, j);
  67
  68                         nRegValue = *((u64 *) ((unsigned char *) registers +
  69                             noffset));
  70
  71                         VXGE_PRINT_REGS(fdAll, (const char *) szName, noffset,
  72                             nRegValue);
  73                 }
  74         }
  75
  76         VXGE_PRINT_LINE(fdAll);
  77         fclose(fdAll);
  78 }
  79
  80 /*
  81  * vxge_print_registers_legacy
  82  * Prints/logs legacy Register values
  83  * @registers Register values
  84  */
  85 void
  86 vxge_print_registers_legacy(void *registers)
  87 {
  88         int i = 0, j = 0;
  89         u64 noffset, nRegValue = 0;
  90         char szName[64];
  91
  92         fdAll = fopen("vxge_regs.log", "a+");
  93         if (!fdAll)
  94                 return;
  95
  96         VXGE_PRINT_REG_NAME(fdAll, "Registers : LEGACY");
  97         VXGE_PRINT_HEADER_REGS(fdAll);
  98
  99         for (i = 0; i < VXGE_HAL_MGMT_REG_COUNT_LEGACY; i++) {
 100                 if (reginfo_legacy[i].size == 1)
 101                         strlcpy(szName, reginfo_legacy[i].name, sizeof(szName));
 102
 103                 for (j = 0; j < reginfo_legacy[i].size; j++) {
 104                         noffset = reginfo_legacy[i].offset + (0x8 * j);
 105
 106                         if (reginfo_legacy[i].size > 1)
 107                                 snprintf(szName, sizeof(szName),
 108                                     reginfo_legacy[i].name, j);
 109
 110                         nRegValue = *((u64 *) ((unsigned char *) registers +
 111                             noffset));
 112
 113                         VXGE_PRINT_REGS(fdAll, (const char *) szName, noffset,
 114                             nRegValue);
 115                 }
 116         }
 117
 118         VXGE_PRINT_LINE(fdAll);
 119         fclose(fdAll);
 120 }
 121
 122 /*
 123  * vxge_print_registers_toc
 124  * Prints/logs toc Register values
 125  * @registers Register values
 126  */
 127 void
 128 vxge_print_registers_toc(void *registers)
 129 {
 130         int i = 0, j = 0;
 131         u64 noffset, nRegValue = 0;
 132         char szName[64];
 133
 134         fdAll = fopen("vxge_regs.log", "a+");
 135         if (!fdAll)
 136                 return;
 137
 138         VXGE_PRINT_REG_NAME(fdAll, "Registers : TOC");
 139         VXGE_PRINT_HEADER_REGS(fdAll);
 140
 141         for (i = 0; i < VXGE_HAL_MGMT_REG_COUNT_TOC; i++) {
 142                 if (reginfo_toc[i].size == 1)
 143                         strlcpy(szName, reginfo_toc[i].name, sizeof(szName));
 144
 145                 for (j = 0; j < reginfo_toc[i].size; j++) {
 146                         noffset = reginfo_toc[i].offset + (0x8 * j);
 147
 148                         if (reginfo_toc[i].size > 1)
 149                                 snprintf(szName, sizeof(szName),
 150                                     reginfo_toc[i].name, j);
 151
 152                         nRegValue = *((u64 *) ((unsigned char *) registers +
 153                             noffset));
 154
 155                         VXGE_PRINT_REGS(fdAll, (const char *) szName, noffset,
 156                             nRegValue);
 157                 }
 158         }
 159
 160         VXGE_PRINT_LINE(fdAll);
 161         fclose(fdAll);
 162 }
 163
 164 /*
 165  * vxge_print_registers_pcicfgmgmt
 166  * Prints/logs pcicfgmgmt Register values
 167  * @registers Register values
 168  */
 169 void
 170 vxge_print_registers_pcicfgmgmt(void *registers)
 171 {
 172         int i = 0, j = 0;
 173         u64 noffset, nRegValue;
 174         char szName[64];
 175
 176         fdAll = fopen("vxge_regs.log", "a+");
 177         if (!fdAll)
 178                 return;
 179
 180         VXGE_PRINT_REG_NAME(fdAll, "Registers : PCICFGMGMT");
 181         VXGE_PRINT_HEADER_REGS(fdAll);
 182
 183         for (i = 0; i < VXGE_HAL_MGMT_REG_COUNT_PCICFGMGMT; i++) {
 184                 if (reginfo_pcicfgmgmt[i].size == 1)
 185                         strlcpy(szName, reginfo_pcicfgmgmt[i].name,
 186                             sizeof(szName));
 187
 188                 for (j = 0; j < reginfo_pcicfgmgmt[i].size; j++) {
 189
 190                         noffset = reginfo_pcicfgmgmt[i].offset + (0x8 * j);
 191
 192                         if (reginfo_pcicfgmgmt[i].size > 1)
 193                                 snprintf(szName, sizeof(szName),
 194                                     reginfo_pcicfgmgmt[i].name, j);
 195
 196                         nRegValue = *((u64 *) ((unsigned char *) registers +
 197                             noffset));
 198
 199                         VXGE_PRINT_REGS(fdAll, (const char *) szName, noffset,
 200                             nRegValue);
 201                 }
 202         }
 203
 204         VXGE_PRINT_LINE(fdAll);
 205         fclose(fdAll);
 206 }
 207
 208 /*
 209  * vxge_print_registers_vpath
 210  * Prints/logs vpath Register values
 211  * @registers Register values
 212  */
 213 void
 214 vxge_print_registers_vpath(void *registers, int vpath_num)
 215 {
 216         int i = 0, j = 0;
 217         u64 noffset, nRegValue = 0;
 218         char szName[64];
 219
 220         fdAll = fopen("vxge_regs.log", "a+");
 221         if (!fdAll)
 222                 return;
 223
 224         VXGE_PRINT_REG_NAME(fdAll, "Registers : VPATH");
 225         VXGE_PRINT_HEADER_REGS(fdAll);
 226
 227         for (i = 0; i < VXGE_HAL_MGMT_REG_COUNT_VPATH; i++) {
 228                 if (reginfo_vpath[i].size == 1)
 229                         snprintf(szName, sizeof(szName),
 230                             reginfo_vpath[i].name, vpath_num);
 231
 232                 for (j = 0; j < reginfo_vpath[i].size; j++) {
 233                         noffset = reginfo_vpath[i].offset + (0x8 * j);
 234
 235                         if (reginfo_vpath[i].size > 1)
 236                                 snprintf(szName, sizeof(szName), reginfo_vpath[i].name, j, vpath_num);
 237
 238                         nRegValue = *((u64 *) ((unsigned char *) registers +
 239                             noffset));
 240
 241                         VXGE_PRINT_REGS(fdAll, (const char *) szName, noffset,
 242                             nRegValue);
 243                 }
 244         }
 245
 246         VXGE_PRINT_LINE(fdAll);
 247         fclose(fdAll);
 248 }
 249
 250 /*
 251  * vxge_print_registers_vpmgmt
 252  * Prints/logs vpmgmt Register values
 253  * @registers Register values
 254  */
 255 void
 256 vxge_print_registers_vpmgmt(void *registers)
 257 {
 258         int i = 0, j = 0;
 259         u64 noffset, nRegValue = 0;
 260         char szName[64];
 261
 262         fdAll = fopen("vxge_regs.log", "a+");
 263         if (!fdAll)
 264                 return;
 265
 266         VXGE_PRINT_REG_NAME(fdAll, "Registers : VPMGMT");
 267         VXGE_PRINT_HEADER_REGS(fdAll);
 268
 269         for (i = 0; i < VXGE_HAL_MGMT_REG_COUNT_VPMGMT; i++) {
 270
 271                 if (reginfo_vpmgmt[i].size == 1)
 272                         strlcpy(szName, reginfo_vpmgmt[i].name, sizeof(szName));
 273
 274                 for (j = 0; j < reginfo_vpmgmt[i].size; j++) {
 275
 276                         noffset = reginfo_vpmgmt[i].offset + (0x8 * j);
 277
 278                         if (reginfo_vpmgmt[i].size > 1)
 279                                 snprintf(szName, sizeof(szName),
 280                                     reginfo_vpmgmt[i].name, j);
 281
 282                         nRegValue = *((u64 *) ((unsigned char *) registers +
 283                             noffset));
 284
 285                         VXGE_PRINT_REGS(fdAll, (const char *) szName, noffset,
 286                             nRegValue);
 287                 }
 288         }
 289
 290         VXGE_PRINT_LINE(fdAll);
 291         fclose(fdAll);
 292 }
 293
 294 /*
 295  * vxge_print_registers_mrpcim
 296  * Prints/logs mrpcim Register values
 297  * @registers Register values
 298  */
 299 void
 300 vxge_print_registers_mrpcim(void *registers)
 301 {
 302         int i = 0, j = 0;
 303         u64 noffset, nRegValue = 0;
 304         char szName[64];
 305
 306         fdAll = fopen("vxge_regs.log", "a+");
 307         if (!fdAll)
 308                 return;
 309
 310         VXGE_PRINT_REG_NAME(fdAll, "Registers : MRPCIM");
 311         VXGE_PRINT_HEADER_REGS(fdAll);
 312
 313         for (i = 0; i < VXGE_HAL_MGMT_REG_COUNT_MRPCIM; i++) {
 314
 315                 if (reginfo_mrpcim[i].size == 1)
 316                         strlcpy(szName, reginfo_mrpcim[i].name, sizeof(szName));
 317
 318                 for (j = 0; j < reginfo_mrpcim[i].size; j++) {
 319
 320                         noffset = reginfo_mrpcim[i].offset + (0x8 * j);
 321
 322                         if (reginfo_mrpcim[i].size > 1)
 323                                 snprintf(szName, sizeof(szName),
 324                                     reginfo_mrpcim[i].name, j);
 325
 326                         nRegValue = *((u64 *) ((unsigned char *) registers +
 327                             noffset));
 328
 329                         VXGE_PRINT_REGS(fdAll, (const char *) szName, noffset,
 330                             nRegValue);
 331                 }
 332         }
 333
 334         VXGE_PRINT_LINE(fdAll);
 335         fclose(fdAll);
 336 }
 337
 338 /*
 339  * vxge_print_registers_srpcim
 340  * Prints/logs srpcim Register values
 341  * @registers Register values
 342  */
 343 void
 344 vxge_print_registers_srpcim(void *registers)
 345 {
 346         int i = 0, j = 0;
 347         u64 noffset, nRegValue = 0;
 348         char szName[64];
 349
 350         fdAll = fopen("vxge_regs.log", "a+");
 351         if (!fdAll)
 352                 return;
 353
 354         VXGE_PRINT_REG_NAME(fdAll, "Registers : SRPCIM");
 355         VXGE_PRINT_HEADER_REGS(fdAll);
 356
 357         for (i = 0; i < VXGE_HAL_MGMT_REG_COUNT_SRPCIM; i++) {
 358
 359                 if (reginfo_srpcim[i].size == 1)
 360                         strlcpy(szName, reginfo_srpcim[i].name, sizeof(szName));
 361
 362                 for (j = 0; j < reginfo_srpcim[i].size; j++) {
 363
 364                         noffset = reginfo_srpcim[i].offset + (0x8 * j);
 365
 366                         if (reginfo_srpcim[i].size > 1)
 367                                 snprintf(szName, sizeof(szName),
 368                                     reginfo_srpcim[i].name, j);
 369
 370                         nRegValue = *((u64 *) ((unsigned char *) registers +
 371                             noffset));
 372
 373                         VXGE_PRINT_REGS(fdAll, (const char *) szName, noffset,
 374                             nRegValue);
 375                 }
 376         }
 377
 378         VXGE_PRINT_LINE(fdAll);
 379         fclose(fdAll);
 380 }
 381
 382 /*
 383  * vxge_print_stats_drv
 384  * Prints/logs Driver Statistics
 385  * @driver_stats Driver Statistics
 386  */
 387 void
 388 vxge_print_stats_drv(void *driver_stats, int vpath_num)
 389 {
 390         int i, j;
 391         u32 no_of_vpath;
 392
 393         no_of_vpath = vxge_get_num_vpath();
 394         fdAll = fopen("vxge_drv_stats.log", "w+");
 395         if (!fdAll)
 396                 return;
 397
 398         for (i = 0; i < no_of_vpath; i++) {
 399
 400                 if (vpath_num != -1) {
 401                         if (vpath_num != i) {
 402                                 driver_stats = driver_stats +
 403                                     (VXGE_HAL_MGMT_STATS_COUNT_DRIVER * sizeof(u64));
 404                                 continue;
 405                         }
 406                 }
 407
 408                 VXGE_PRINT_LINE(fdAll);
 409                 VXGE_PRINT(fdAll, " VPath # %d ", i);
 410                 VXGE_PRINT_LINE(fdAll);
 411
 412                 for (j = 0; j < VXGE_HAL_MGMT_STATS_COUNT_DRIVER; j++) {
 413
 414                         driverInfo[j].value =
 415                             *((u64 *) ((unsigned char *) driver_stats +
 416                             (j * (sizeof(u64)))));
 417
 418                         VXGE_PRINT_STATS(fdAll, (const char *)
 419                             driverInfo[j].name, driverInfo[j].value);
 420                 }
 421                 driver_stats = driver_stats + (j * sizeof(u64));
 422         }
 423
 424         VXGE_PRINT_LINE(fdAll);
 425         fclose(fdAll);
 426 }
 427
 428 /*
 429  * vxge_print_stats
 430  * Prints/logs Statistics
 431  * @driver_stats Driver Statistics
 432  */
 433 void
 434 vxge_print_stats(void *stats, vxge_query_device_info_e stat_type)
 435 {
 436         fdAll = fopen("vxge_stats.log", "a+");
 437         if (!fdAll)
 438                 return;
 439
 440         switch (stat_type) {
 441         case VXGE_GET_MRPCIM_STATS:
 442                 VXGE_PRINT_LINE(fdAll);
 443                 VXGE_PRINT_REG_NAME(fdAll, "Statistics : MRPCIM");
 444                 VXGE_PRINT_LINE(fdAll);
 445                 break;
 446
 447         case VXGE_GET_DEVICE_STATS:
 448                 VXGE_PRINT_LINE(fdAll);
 449                 VXGE_PRINT_REG_NAME(fdAll, "Statistics: COMMON");
 450                 VXGE_PRINT_LINE(fdAll);
 451                 break;
 452         }
 453
 454         VXGE_PRINT(fdAll, "%s", stats);
 455         fclose(fdAll);
 456 }
 457
 458 void
 459 vxge_print_pci_config(void *info)
 460 {
 461         fdAll = fopen("vxge_regs.log", "a+");
 462         if (!fdAll)
 463                 return;
 464
 465         VXGE_PRINT_LINE(fdAll);
 466         VXGE_PRINT_REG_NAME(fdAll, "PCI CONFIG SPACE");
 467         VXGE_PRINT_LINE(fdAll);
 468         VXGE_PRINT(fdAll, "%s", info);
 469         fclose(fdAll);
 470 }
 471
 472 void
 473 vxge_print_hw_info(void *info)
 474 {
 475         u32 i;
 476         vxge_device_hw_info_t *dev_hw_info;
 477         vxge_hal_device_hw_info_t *hw_info;
 478         vxge_hal_device_pmd_info_t *pmd_port;
 479
 480         fdAll = fopen("vxge_regs.log", "w+");
 481         if (!fdAll)
 482                 return;
 483
 484         dev_hw_info = (vxge_device_hw_info_t *) info;
 485         hw_info = &(dev_hw_info->hw_info);
 486         pmd_port = &(hw_info->pmd_port0);
 487
 488         VXGE_PRINT_LINE(fdAll);
 489         VXGE_PRINT_REG_NAME(fdAll, "HARDWARE INFO");
 490         VXGE_PRINT_LINE(fdAll);
 491
 492         VXGE_PRINT(fdAll, "Description \t\t: %s",
 493             hw_info->product_description);
 494
 495         VXGE_PRINT(fdAll, "Serial Number \t\t: %s", hw_info->serial_number);
 496         VXGE_PRINT(fdAll, "Part Number \t\t: %s", hw_info->part_number);
 497
 498         VXGE_PRINT(fdAll, "Firmware Version \t: %s",
 499             hw_info->fw_version.version);
 500
 501         VXGE_PRINT(fdAll, "Firmware Date \t\t: %s", hw_info->fw_date.date);
 502
 503         VXGE_PRINT(fdAll, "Function Mode \t\t: %s",
 504             vxge_func_mode[hw_info->function_mode]);
 505
 506         for (i = 0; i < hw_info->ports; i++) {
 507
 508                 vxge_null_terminate(pmd_port->vendor,
 509                     sizeof(pmd_port->vendor));
 510
 511                 if (strlen(pmd_port->vendor) == 0) {
 512                         VXGE_PRINT(fdAll,
 513                             "PMD Port %d \t\t: vendor=??, sn=??, pn=??", i);
 514
 515                         pmd_port = &(hw_info->pmd_port1);
 516                         continue;
 517                 }
 518
 519                 vxge_null_terminate(pmd_port->ser_num,
 520                     sizeof(pmd_port->ser_num));
 521
 522                 vxge_null_terminate(pmd_port->part_num,
 523                     sizeof(pmd_port->part_num));
 524
 525                 VXGE_PRINT(fdAll,
 526                     "PMD Port %d \t\t: vendor=%s, sn=%s, pn=%s", i,
 527                     pmd_port->vendor, pmd_port->ser_num,
 528                     pmd_port->part_num);
 529
 530                 pmd_port = &(hw_info->pmd_port1);
 531         }
 532
 533         if (hw_info->ports > 1) {
 534
 535                 VXGE_PRINT(fdAll, "Port mode \t\t: %s",
 536                     vxge_port_mode[dev_hw_info->port_mode]);
 537
 538                 if (dev_hw_info->port_mode != VXGE_HAL_DP_NP_MODE_SINGLE_PORT) {
 539                         VXGE_PRINT(fdAll, "Port failure \t\t: %s",
 540                             vxge_port_failure[dev_hw_info->port_failure]);
 541                 }
 542         }
 543
 544         VXGE_PRINT_LINE(fdAll);
 545         fclose(fdAll);
 546 }
 547
 548 void
 549 vxge_print_bw_priority(void *info)
 550 {
 551         u32 i;
 552         u64 func_id;
 553         vxge_bw_info_t *buffer;
 554
 555         fdAll = fopen("vxge_stats.log", "a+");
 556         if (!fdAll)
 557                 return;
 558
 559         buffer = (vxge_bw_info_t *) info;
 560         func_id = buffer->func_id;
 561
 562         VXGE_PRINT_LINE(fdAll);
 563
 564         VXGE_PRINT(fdAll,
 565             "Function : %02lld Bandwidth : %05d\tPriority : %d",
 566             func_id, (buffer->bandwidth ?
 567             buffer->bandwidth : VXGE_MAX_BANDWIDTH),
 568             buffer->priority);
 569
 570         VXGE_PRINT_LINE(fdAll);
 571         fclose(fdAll);
 572 }
 573
 574 void
 575 vxge_print_port_mode(void *info)
 576 {
 577         vxge_port_info_t *buffer;
 578
 579         fdAll = fopen("vxge_stats.log", "a+");
 580         if (!fdAll)
 581                 return;
 582
 583         buffer = (vxge_port_info_t *) info;
 584
 585         VXGE_PRINT_LINE(fdAll);
 586
 587         VXGE_PRINT(fdAll,
 588             "Port Mode: %s\tPort Failure: %s",
 589             vxge_port_mode[buffer->port_mode],
 590             vxge_port_failure[buffer->port_failure]);
 591
 592         VXGE_PRINT_LINE(fdAll);
 593         fclose(fdAll);
 594 }