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 35static FILE *fdAll; 36 37/* 38 * vxge_print_registers 39 * Prints/logs Register values 40 * @registers Register values 41 */ 42void 43vxge_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 */ 85void 86vxge_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 */ 127void 128vxge_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 */ 169void 170vxge_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 */ 213void 214vxge_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 */ 255void 256vxge_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 */ 299void 300vxge_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 */ 343void 344vxge_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 */ 387void 388vxge_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 */ 433void 434vxge_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 458void 459vxge_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 472void 473vxge_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 548void 549vxge_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 574void 575vxge_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} 595