tools/tools/vxge/vxge_log.c

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