1 /*- 2 * Copyright (C) 2013 Emulex 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that 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 Emulex 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 * Contact Information: 32 * freebsd-drivers@emulex.com 33 * 34 * Emulex 35 * 3333 Susan Street 36 * Costa Mesa, CA 92626 37 */ 38 39 /* $FreeBSD$ */ 40 41 #include "oce_if.h" 42 43 static void copy_stats_to_sc_xe201(POCE_SOFTC sc); 44 static void copy_stats_to_sc_be3(POCE_SOFTC sc); 45 static void copy_stats_to_sc_be2(POCE_SOFTC sc); 46 static void copy_stats_to_sc_sh(POCE_SOFTC sc); 47 static int oce_sysctl_loopback(SYSCTL_HANDLER_ARGS); 48 static int oce_sys_aic_enable(SYSCTL_HANDLER_ARGS); 49 static int oce_be3_fwupgrade(POCE_SOFTC sc, const struct firmware *fw); 50 static int oce_skyhawk_fwupgrade(POCE_SOFTC sc, const struct firmware *fw); 51 static int oce_sys_fwupgrade(SYSCTL_HANDLER_ARGS); 52 static int oce_lancer_fwupgrade(POCE_SOFTC sc, const struct firmware *fw); 53 static int oce_sysctl_sfp_vpd_dump(SYSCTL_HANDLER_ARGS); 54 static boolean_t oce_phy_flashing_required(POCE_SOFTC sc); 55 static boolean_t oce_img_flashing_required(POCE_SOFTC sc, const char *p, 56 int img_optype, uint32_t img_offset, 57 uint32_t img_size, uint32_t hdrs_size); 58 static void oce_add_stats_sysctls_be3(POCE_SOFTC sc, 59 struct sysctl_ctx_list *ctx, 60 struct sysctl_oid *stats_node); 61 static void oce_add_stats_sysctls_xe201(POCE_SOFTC sc, 62 struct sysctl_ctx_list *ctx, 63 struct sysctl_oid *stats_node); 64 65 66 extern char component_revision[32]; 67 uint32_t sfp_vpd_dump_buffer[TRANSCEIVER_DATA_NUM_ELE]; 68 69 struct flash_img_attri { 70 int img_offset; 71 int img_size; 72 int img_type; 73 bool skip_image; 74 int optype; 75 }; 76 77 void 78 oce_add_sysctls(POCE_SOFTC sc) 79 { 80 81 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->dev); 82 struct sysctl_oid *tree = device_get_sysctl_tree(sc->dev); 83 struct sysctl_oid_list *child = SYSCTL_CHILDREN(tree); 84 struct sysctl_oid *stats_node; 85 86 SYSCTL_ADD_STRING(ctx, child, 87 OID_AUTO, "component_revision", 88 CTLFLAG_RD, 89 component_revision, 90 sizeof(component_revision), 91 "EMULEX One-Connect device driver revision"); 92 93 SYSCTL_ADD_STRING(ctx, child, 94 OID_AUTO, "firmware_version", 95 CTLFLAG_RD, 96 sc->fw_version, 97 sizeof(sc->fw_version), 98 "EMULEX One-Connect Firmware Version"); 99 100 SYSCTL_ADD_INT(ctx, child, 101 OID_AUTO, "max_rsp_handled", 102 CTLFLAG_RW, 103 &oce_max_rsp_handled, 104 sizeof(oce_max_rsp_handled), 105 "Maximum receive frames handled per interupt"); 106 107 if ((sc->function_mode & FNM_FLEX10_MODE) || 108 (sc->function_mode & FNM_UMC_MODE)) 109 SYSCTL_ADD_UINT(ctx, child, 110 OID_AUTO, "speed", 111 CTLFLAG_RD, 112 &sc->qos_link_speed, 113 0,"QOS Speed"); 114 else 115 SYSCTL_ADD_UINT(ctx, child, 116 OID_AUTO, "speed", 117 CTLFLAG_RD, 118 &sc->speed, 119 0,"Link Speed"); 120 121 if (sc->function_mode & FNM_UMC_MODE) 122 SYSCTL_ADD_UINT(ctx, child, 123 OID_AUTO, "pvid", 124 CTLFLAG_RD, 125 &sc->pvid, 126 0,"PVID"); 127 128 SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "loop_back", 129 CTLTYPE_INT | CTLFLAG_RW, (void *)sc, 0, 130 oce_sysctl_loopback, "I", "Loop Back Tests"); 131 132 SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "fw_upgrade", 133 CTLTYPE_STRING | CTLFLAG_RW, (void *)sc, 0, 134 oce_sys_fwupgrade, "A", "Firmware ufi file"); 135 136 SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "aic_enable", 137 CTLTYPE_INT | CTLFLAG_RW, (void *)sc, 1, 138 oce_sys_aic_enable, "I", "aic flags"); 139 140 /* 141 * Dumps Transceiver data 142 * "sysctl dev.oce.0.sfp_vpd_dump=0" 143 * "sysctl -x dev.oce.0.sfp_vpd_dump_buffer" for hex dump 144 * "sysctl -b dev.oce.0.sfp_vpd_dump_buffer > sfp.bin" for binary dump 145 */ 146 SYSCTL_ADD_PROC(ctx, child, OID_AUTO, "sfp_vpd_dump", 147 CTLTYPE_INT | CTLFLAG_RW, (void *)sc, 0, oce_sysctl_sfp_vpd_dump, 148 "I", "Initiate a sfp_vpd_dump operation"); 149 SYSCTL_ADD_OPAQUE(ctx, child, OID_AUTO, "sfp_vpd_dump_buffer", 150 CTLFLAG_RD, sfp_vpd_dump_buffer, 151 TRANSCEIVER_DATA_SIZE, "IU", "Access sfp_vpd_dump buffer"); 152 153 stats_node = SYSCTL_ADD_NODE(ctx, child, OID_AUTO, "stats", 154 CTLFLAG_RD, NULL, "Ethernet Statistics"); 155 156 if (IS_BE(sc) || IS_SH(sc)) 157 oce_add_stats_sysctls_be3(sc, ctx, stats_node); 158 else 159 oce_add_stats_sysctls_xe201(sc, ctx, stats_node); 160 161 162 } 163 164 165 static uint32_t 166 oce_loopback_test(struct oce_softc *sc, uint8_t loopback_type) 167 { 168 uint32_t status = 0; 169 170 oce_mbox_cmd_set_loopback(sc, sc->port_id, loopback_type, 1); 171 status = oce_mbox_cmd_test_loopback(sc, sc->port_id, loopback_type, 172 1500, 2, 0xabc); 173 oce_mbox_cmd_set_loopback(sc, sc->port_id, OCE_NO_LOOPBACK, 1); 174 175 return status; 176 } 177 178 static int 179 oce_sys_aic_enable(SYSCTL_HANDLER_ARGS) 180 { 181 int value = 0; 182 uint32_t status, vector; 183 POCE_SOFTC sc = (struct oce_softc *)arg1; 184 struct oce_aic_obj *aic; 185 186 /* set current value for proper sysctl logging */ 187 value = sc->aic_obj[0].enable; 188 status = sysctl_handle_int(oidp, &value, 0, req); 189 if (status || !req->newptr) 190 return status; 191 192 for (vector = 0; vector < sc->intr_count; vector++) { 193 aic = &sc->aic_obj[vector]; 194 195 if (value == 0){ 196 aic->max_eqd = aic->min_eqd = aic->et_eqd = 0; 197 aic->enable = 0; 198 } 199 else { 200 aic->max_eqd = OCE_MAX_EQD; 201 aic->min_eqd = OCE_MIN_EQD; 202 aic->et_eqd = OCE_MIN_EQD; 203 aic->enable = TRUE; 204 } 205 } 206 return 0; 207 } 208 209 static int 210 oce_sysctl_loopback(SYSCTL_HANDLER_ARGS) 211 { 212 int value = 0; 213 uint32_t status; 214 struct oce_softc *sc = (struct oce_softc *)arg1; 215 216 status = sysctl_handle_int(oidp, &value, 0, req); 217 if (status || !req->newptr) 218 return status; 219 220 if (value != 1) { 221 device_printf(sc->dev, 222 "Not a Valid value. Set to loop_back=1 to run tests\n"); 223 return 0; 224 } 225 226 if ((status = oce_loopback_test(sc, OCE_MAC_LOOPBACK))) { 227 device_printf(sc->dev, 228 "MAC Loopback Test = Failed (Error status = %d)\n", 229 status); 230 } else 231 device_printf(sc->dev, "MAC Loopback Test = Success\n"); 232 233 if ((status = oce_loopback_test(sc, OCE_PHY_LOOPBACK))) { 234 device_printf(sc->dev, 235 "PHY Loopback Test = Failed (Error status = %d)\n", 236 status); 237 } else 238 device_printf(sc->dev, "PHY Loopback Test = Success\n"); 239 240 if ((status = oce_loopback_test(sc, OCE_ONE_PORT_EXT_LOOPBACK))) { 241 device_printf(sc->dev, 242 "EXT Loopback Test = Failed (Error status = %d)\n", 243 status); 244 } else 245 device_printf(sc->dev, "EXT Loopback Test = Success\n"); 246 247 return 0; 248 } 249 250 251 static int 252 oce_sys_fwupgrade(SYSCTL_HANDLER_ARGS) 253 { 254 char ufiname[256] = {0}; 255 uint32_t status = 1; 256 struct oce_softc *sc = (struct oce_softc *)arg1; 257 const struct firmware *fw; 258 259 status = sysctl_handle_string(oidp, ufiname, sizeof(ufiname), req); 260 if (status || !req->newptr) 261 return status; 262 263 fw = firmware_get(ufiname); 264 if (fw == NULL) { 265 device_printf(sc->dev, "Unable to get Firmware. " 266 "Make sure %s is copied to /boot/modules\n", ufiname); 267 return ENOENT; 268 } 269 270 if (IS_BE(sc)) { 271 if ((sc->flags & OCE_FLAGS_BE2)) { 272 device_printf(sc->dev, 273 "Flashing not supported for BE2 yet.\n"); 274 status = 1; 275 goto done; 276 } 277 status = oce_be3_fwupgrade(sc, fw); 278 } else if (IS_SH(sc)) { 279 status = oce_skyhawk_fwupgrade(sc,fw); 280 } else 281 status = oce_lancer_fwupgrade(sc, fw); 282 done: 283 if (status) { 284 device_printf(sc->dev, "Firmware Upgrade failed\n"); 285 } else { 286 device_printf(sc->dev, "Firmware Flashed successfully\n"); 287 } 288 289 /* Release Firmware*/ 290 firmware_put(fw, FIRMWARE_UNLOAD); 291 292 return status; 293 } 294 295 static void oce_fill_flash_img_data(POCE_SOFTC sc, const struct flash_sec_info * fsec, 296 struct flash_img_attri *pimg, int i, 297 const struct firmware *fw, int bin_offset) 298 { 299 if (IS_SH(sc)) { 300 pimg->img_offset = HOST_32(fsec->fsec_entry[i].offset); 301 pimg->img_size = HOST_32(fsec->fsec_entry[i].pad_size); 302 } 303 304 pimg->img_type = HOST_32(fsec->fsec_entry[i].type); 305 pimg->skip_image = FALSE; 306 switch (pimg->img_type) { 307 case IMG_ISCSI: 308 pimg->optype = 0; 309 if (IS_BE3(sc)) { 310 pimg->img_offset = 2097152; 311 pimg->img_size = 2097152; 312 } 313 break; 314 case IMG_REDBOOT: 315 pimg->optype = 1; 316 if (IS_BE3(sc)) { 317 pimg->img_offset = 262144; 318 pimg->img_size = 1048576; 319 } 320 if (!oce_img_flashing_required(sc, fw->data, 321 pimg->optype, 322 pimg->img_offset, 323 pimg->img_size, 324 bin_offset)) 325 pimg->skip_image = TRUE; 326 break; 327 case IMG_BIOS: 328 pimg->optype = 2; 329 if (IS_BE3(sc)) { 330 pimg->img_offset = 12582912; 331 pimg->img_size = 524288; 332 } 333 break; 334 case IMG_PXEBIOS: 335 pimg->optype = 3; 336 if (IS_BE3(sc)) { 337 pimg->img_offset = 13107200; 338 pimg->img_size = 524288; 339 } 340 break; 341 case IMG_FCOEBIOS: 342 pimg->optype = 8; 343 if (IS_BE3(sc)) { 344 pimg->img_offset = 13631488; 345 pimg->img_size = 524288; 346 } 347 break; 348 case IMG_ISCSI_BAK: 349 pimg->optype = 9; 350 if (IS_BE3(sc)) { 351 pimg->img_offset = 4194304; 352 pimg->img_size = 2097152; 353 } 354 break; 355 case IMG_FCOE: 356 pimg->optype = 10; 357 if (IS_BE3(sc)) { 358 pimg->img_offset = 6291456; 359 pimg->img_size = 2097152; 360 } 361 break; 362 case IMG_FCOE_BAK: 363 pimg->optype = 11; 364 if (IS_BE3(sc)) { 365 pimg->img_offset = 8388608; 366 pimg->img_size = 2097152; 367 } 368 break; 369 case IMG_NCSI: 370 pimg->optype = 13; 371 if (IS_BE3(sc)) { 372 pimg->img_offset = 15990784; 373 pimg->img_size = 262144; 374 } 375 break; 376 case IMG_PHY: 377 pimg->optype = 99; 378 if (IS_BE3(sc)) { 379 pimg->img_offset = 1310720; 380 pimg->img_size = 262144; 381 } 382 if (!oce_phy_flashing_required(sc)) 383 pimg->skip_image = TRUE; 384 break; 385 default: 386 pimg->skip_image = TRUE; 387 break; 388 } 389 390 } 391 392 static int 393 oce_sh_be3_flashdata(POCE_SOFTC sc, const struct firmware *fw, int32_t num_imgs) 394 { 395 char cookie[2][16] = {"*** SE FLAS", "H DIRECTORY *** "}; 396 const char *p = (const char *)fw->data; 397 const struct flash_sec_info *fsec = NULL; 398 struct mbx_common_read_write_flashrom *req; 399 int rc = 0, i, bin_offset = 0, opcode, num_bytes; 400 OCE_DMA_MEM dma_mem; 401 struct flash_img_attri imgatt; 402 403 /* Validate Cookie */ 404 bin_offset = (sizeof(struct flash_file_hdr) + 405 (num_imgs * sizeof(struct image_hdr))); 406 p += bin_offset; 407 while (p < ((const char *)fw->data + fw->datasize)) { 408 fsec = (const struct flash_sec_info *)p; 409 if (!memcmp(cookie, fsec->cookie, sizeof(cookie))) 410 break; 411 fsec = NULL; 412 p += 32; 413 } 414 415 if (!fsec) { 416 device_printf(sc->dev, 417 "Invalid Cookie. Firmware image corrupted ?\n"); 418 return EINVAL; 419 } 420 421 rc = oce_dma_alloc(sc, sizeof(struct mbx_common_read_write_flashrom), 422 &dma_mem, 0); 423 if (rc) { 424 device_printf(sc->dev, 425 "Memory allocation failure while flashing\n"); 426 return ENOMEM; 427 } 428 req = OCE_DMAPTR(&dma_mem, struct mbx_common_read_write_flashrom); 429 430 if (IS_SH(sc)) 431 num_imgs = HOST_32(fsec->fsec_hdr.num_images); 432 else if (IS_BE3(sc)) 433 num_imgs = MAX_FLASH_COMP; 434 435 for (i = 0; i < num_imgs; i++) { 436 437 bzero(&imgatt, sizeof(struct flash_img_attri)); 438 439 oce_fill_flash_img_data(sc, fsec, &imgatt, i, fw, bin_offset); 440 441 if (imgatt.skip_image) 442 continue; 443 444 p = fw->data; 445 p = p + bin_offset + imgatt.img_offset; 446 447 if ((p + imgatt.img_size) > ((const char *)fw->data + fw->datasize)) { 448 rc = 1; 449 goto ret; 450 } 451 452 while (imgatt.img_size) { 453 454 if (imgatt.img_size > 32*1024) 455 num_bytes = 32*1024; 456 else 457 num_bytes = imgatt.img_size; 458 imgatt.img_size -= num_bytes; 459 460 if (!imgatt.img_size) 461 opcode = FLASHROM_OPER_FLASH; 462 else 463 opcode = FLASHROM_OPER_SAVE; 464 465 memcpy(req->data_buffer, p, num_bytes); 466 p += num_bytes; 467 468 rc = oce_mbox_write_flashrom(sc, imgatt.optype, opcode, 469 &dma_mem, num_bytes); 470 if (rc) { 471 device_printf(sc->dev, 472 "cmd to write to flash rom failed.\n"); 473 rc = EIO; 474 goto ret; 475 } 476 /* Leave the CPU for others for some time */ 477 pause("yield", 10); 478 479 } 480 481 } 482 483 ret: 484 oce_dma_free(sc, &dma_mem); 485 return rc; 486 } 487 488 #define UFI_TYPE2 2 489 #define UFI_TYPE3 3 490 #define UFI_TYPE3R 10 491 #define UFI_TYPE4 4 492 #define UFI_TYPE4R 11 493 static int oce_get_ufi_type(POCE_SOFTC sc, 494 const struct flash_file_hdr *fhdr) 495 { 496 if (fhdr == NULL) 497 goto be_get_ufi_exit; 498 499 if (IS_SH(sc) && fhdr->build[0] == '4') { 500 if (fhdr->asic_type_rev >= 0x10) 501 return UFI_TYPE4R; 502 else 503 return UFI_TYPE4; 504 } else if (IS_BE3(sc) && fhdr->build[0] == '3') { 505 if (fhdr->asic_type_rev == 0x10) 506 return UFI_TYPE3R; 507 else 508 return UFI_TYPE3; 509 } else if (IS_BE2(sc) && fhdr->build[0] == '2') 510 return UFI_TYPE2; 511 512 be_get_ufi_exit: 513 device_printf(sc->dev, 514 "UFI and Interface are not compatible for flashing\n"); 515 return -1; 516 } 517 518 519 static int 520 oce_skyhawk_fwupgrade(POCE_SOFTC sc, const struct firmware *fw) 521 { 522 int rc = 0, num_imgs = 0, i = 0, ufi_type; 523 const struct flash_file_hdr *fhdr; 524 const struct image_hdr *img_ptr; 525 526 fhdr = (const struct flash_file_hdr *)fw->data; 527 528 ufi_type = oce_get_ufi_type(sc, fhdr); 529 530 /* Display flash version */ 531 device_printf(sc->dev, "Flashing Firmware %s\n", &fhdr->build[2]); 532 533 num_imgs = fhdr->num_imgs; 534 for (i = 0; i < num_imgs; i++) { 535 img_ptr = (const struct image_hdr *)((const char *)fw->data + 536 sizeof(struct flash_file_hdr) + 537 (i * sizeof(struct image_hdr))); 538 539 if (img_ptr->imageid != 1) 540 continue; 541 542 switch (ufi_type) { 543 case UFI_TYPE4R: 544 rc = oce_sh_be3_flashdata(sc, fw, 545 num_imgs); 546 break; 547 case UFI_TYPE4: 548 if (sc->asic_revision < 0x10) 549 rc = oce_sh_be3_flashdata(sc, fw, 550 num_imgs); 551 else { 552 rc = -1; 553 device_printf(sc->dev, 554 "Cant load SH A0 UFI on B0\n"); 555 } 556 break; 557 default: 558 rc = -1; 559 break; 560 561 } 562 } 563 564 return rc; 565 } 566 567 static int 568 oce_be3_fwupgrade(POCE_SOFTC sc, const struct firmware *fw) 569 { 570 int rc = 0, num_imgs = 0, i = 0; 571 const struct flash_file_hdr *fhdr; 572 const struct image_hdr *img_ptr; 573 574 fhdr = (const struct flash_file_hdr *)fw->data; 575 if (fhdr->build[0] != '3') { 576 device_printf(sc->dev, "Invalid BE3 firmware image\n"); 577 return EINVAL; 578 } 579 /* Display flash version */ 580 device_printf(sc->dev, "Flashing Firmware %s\n", &fhdr->build[2]); 581 582 num_imgs = fhdr->num_imgs; 583 for (i = 0; i < num_imgs; i++) { 584 img_ptr = (const struct image_hdr *)((const char *)fw->data + 585 sizeof(struct flash_file_hdr) + 586 (i * sizeof(struct image_hdr))); 587 if (img_ptr->imageid == 1) { 588 rc = oce_sh_be3_flashdata(sc, fw, num_imgs); 589 590 break; 591 } 592 } 593 594 return rc; 595 } 596 597 598 static boolean_t 599 oce_phy_flashing_required(POCE_SOFTC sc) 600 { 601 int status = 0; 602 struct oce_phy_info phy_info; 603 604 status = oce_mbox_get_phy_info(sc, &phy_info); 605 if (status) 606 return FALSE; 607 608 if ((phy_info.phy_type == TN_8022) && 609 (phy_info.interface_type == PHY_TYPE_BASET_10GB)) { 610 return TRUE; 611 } 612 613 return FALSE; 614 } 615 616 617 static boolean_t 618 oce_img_flashing_required(POCE_SOFTC sc, const char *p, 619 int img_optype, uint32_t img_offset, 620 uint32_t img_size, uint32_t hdrs_size) 621 { 622 uint32_t crc_offset; 623 uint8_t flashed_crc[4]; 624 int status; 625 626 crc_offset = hdrs_size + img_offset + img_size - 4; 627 628 p += crc_offset; 629 630 status = oce_mbox_get_flashrom_crc(sc, flashed_crc, 631 (img_size - 4), img_optype); 632 if (status) 633 return TRUE; /* Some thing worng. ReFlash */ 634 635 /*update redboot only if crc does not match*/ 636 if (bcmp(flashed_crc, p, 4)) 637 return TRUE; 638 else 639 return FALSE; 640 } 641 642 643 static int 644 oce_lancer_fwupgrade(POCE_SOFTC sc, const struct firmware *fw) 645 { 646 647 int rc = 0; 648 OCE_DMA_MEM dma_mem; 649 const uint8_t *data = NULL; 650 uint8_t *dest_image_ptr = NULL; 651 size_t size = 0; 652 uint32_t data_written = 0, chunk_size = 0; 653 uint32_t offset = 0, add_status = 0; 654 655 if (!IS_ALIGNED(fw->datasize, sizeof(uint32_t))) { 656 device_printf(sc->dev, 657 "Lancer FW image is not 4 byte aligned."); 658 return EINVAL; 659 } 660 661 rc = oce_dma_alloc(sc, 32*1024, &dma_mem, 0); 662 if (rc) { 663 device_printf(sc->dev, 664 "Memory allocation failure while flashing Lancer\n"); 665 return ENOMEM; 666 } 667 668 size = fw->datasize; 669 data = fw->data; 670 dest_image_ptr = OCE_DMAPTR(&dma_mem, uint8_t); 671 672 while (size) { 673 chunk_size = MIN(size, (32*1024)); 674 675 bcopy(data, dest_image_ptr, chunk_size); 676 677 rc = oce_mbox_lancer_write_flashrom(sc, chunk_size, offset, 678 &dma_mem, &data_written, &add_status); 679 680 if (rc) 681 break; 682 683 size -= data_written; 684 data += data_written; 685 offset += data_written; 686 pause("yield", 10); 687 688 } 689 690 if (!rc) 691 /* Commit the firmware*/ 692 rc = oce_mbox_lancer_write_flashrom(sc, 0, offset, &dma_mem, 693 &data_written, &add_status); 694 if (rc) { 695 device_printf(sc->dev, "Lancer firmware load error. " 696 "Addstatus = 0x%x, status = %d \n", add_status, rc); 697 rc = EIO; 698 } 699 oce_dma_free(sc, &dma_mem); 700 return rc; 701 702 } 703 704 705 static void 706 oce_add_stats_sysctls_be3(POCE_SOFTC sc, 707 struct sysctl_ctx_list *ctx, 708 struct sysctl_oid *stats_node) 709 { 710 struct sysctl_oid *rx_stats_node, *tx_stats_node; 711 struct sysctl_oid_list *rx_stat_list, *tx_stat_list; 712 struct sysctl_oid_list *queue_stats_list; 713 struct sysctl_oid *queue_stats_node; 714 struct oce_drv_stats *stats; 715 char prefix[32]; 716 int i; 717 718 stats = &sc->oce_stats_info; 719 720 rx_stats_node = SYSCTL_ADD_NODE(ctx, 721 SYSCTL_CHILDREN(stats_node), 722 OID_AUTO,"rx", CTLFLAG_RD, 723 NULL, "RX Ethernet Statistics"); 724 rx_stat_list = SYSCTL_CHILDREN(rx_stats_node); 725 726 727 SYSCTL_ADD_QUAD(ctx, rx_stat_list, OID_AUTO, "total_pkts", 728 CTLFLAG_RD, &stats->rx.t_rx_pkts, 729 "Total Received Packets"); 730 SYSCTL_ADD_QUAD(ctx, rx_stat_list, OID_AUTO, "total_bytes", 731 CTLFLAG_RD, &stats->rx.t_rx_bytes, 732 "Total Received Bytes"); 733 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_frags", 734 CTLFLAG_RD, &stats->rx.t_rx_frags, 0, 735 "Total Received Fragements"); 736 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_mcast_pkts", 737 CTLFLAG_RD, &stats->rx.t_rx_mcast_pkts, 0, 738 "Total Received Multicast Packets"); 739 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_ucast_pkts", 740 CTLFLAG_RD, &stats->rx.t_rx_ucast_pkts, 0, 741 "Total Received Unicast Packets"); 742 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_rxcp_errs", 743 CTLFLAG_RD, &stats->rx.t_rxcp_errs, 0, 744 "Total Receive completion errors"); 745 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "pause_frames", 746 CTLFLAG_RD, &stats->u0.be.rx_pause_frames, 0, 747 "Pause Frames"); 748 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "priority_pause_frames", 749 CTLFLAG_RD, &stats->u0.be.rx_priority_pause_frames, 0, 750 "Priority Pause Frames"); 751 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "control_frames", 752 CTLFLAG_RD, &stats->u0.be.rx_control_frames, 0, 753 "Control Frames"); 754 755 for (i = 0; i < sc->nrqs; i++) { 756 sprintf(prefix, "queue%d",i); 757 queue_stats_node = SYSCTL_ADD_NODE(ctx, 758 SYSCTL_CHILDREN(rx_stats_node), 759 OID_AUTO, prefix, CTLFLAG_RD, 760 NULL, "Queue name"); 761 queue_stats_list = SYSCTL_CHILDREN(queue_stats_node); 762 763 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "rx_pkts", 764 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_pkts, 765 "Receive Packets"); 766 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "rx_bytes", 767 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_bytes, 768 "Recived Bytes"); 769 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "rx_frags", 770 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_frags, 0, 771 "Received Fragments"); 772 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, 773 "rx_mcast_pkts", CTLFLAG_RD, 774 &sc->rq[i]->rx_stats.rx_mcast_pkts, 0, 775 "Received Multicast Packets"); 776 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, 777 "rx_ucast_pkts", CTLFLAG_RD, 778 &sc->rq[i]->rx_stats.rx_ucast_pkts, 0, 779 "Received Unicast Packets"); 780 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "rxcp_err", 781 CTLFLAG_RD, &sc->rq[i]->rx_stats.rxcp_err, 0, 782 "Received Completion Errors"); 783 if(IS_SH(sc)) { 784 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "rx_drops_no_frags", 785 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_drops_no_frags, 0, 786 "num of packet drops due to no fragments"); 787 } 788 } 789 790 rx_stats_node = SYSCTL_ADD_NODE(ctx, 791 SYSCTL_CHILDREN(rx_stats_node), 792 OID_AUTO, "err", CTLFLAG_RD, 793 NULL, "Receive Error Stats"); 794 rx_stat_list = SYSCTL_CHILDREN(rx_stats_node); 795 796 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "crc_errs", 797 CTLFLAG_RD, &stats->u0.be.rx_crc_errors, 0, 798 "CRC Errors"); 799 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "pbuf_errors", 800 CTLFLAG_RD, &stats->u0.be.rx_drops_no_pbuf, 0, 801 "Drops due to pbuf full"); 802 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "erx_errors", 803 CTLFLAG_RD, &stats->u0.be.rx_drops_no_erx_descr, 0, 804 "ERX Errors"); 805 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "alignment_errors", 806 CTLFLAG_RD, &stats->u0.be.rx_drops_too_many_frags, 0, 807 "RX Alignmnet Errors"); 808 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "in_range_errors", 809 CTLFLAG_RD, &stats->u0.be.rx_in_range_errors, 0, 810 "In Range Errors"); 811 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "out_range_errors", 812 CTLFLAG_RD, &stats->u0.be.rx_out_range_errors, 0, 813 "Out Range Errors"); 814 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "frame_too_long", 815 CTLFLAG_RD, &stats->u0.be.rx_frame_too_long, 0, 816 "Frame Too Long"); 817 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "address_match_errors", 818 CTLFLAG_RD, &stats->u0.be.rx_address_match_errors, 0, 819 "Address Match Errors"); 820 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_too_small", 821 CTLFLAG_RD, &stats->u0.be.rx_dropped_too_small, 0, 822 "Dropped Too Small"); 823 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_too_short", 824 CTLFLAG_RD, &stats->u0.be.rx_dropped_too_short, 0, 825 "Dropped Too Short"); 826 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, 827 "dropped_header_too_small", CTLFLAG_RD, 828 &stats->u0.be.rx_dropped_header_too_small, 0, 829 "Dropped Header Too Small"); 830 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_tcp_length", 831 CTLFLAG_RD, &stats->u0.be.rx_dropped_tcp_length, 0, 832 "Dropped TCP Length"); 833 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_runt", 834 CTLFLAG_RD, &stats->u0.be.rx_dropped_runt, 0, 835 "Dropped runt"); 836 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "ip_checksum_errs", 837 CTLFLAG_RD, &stats->u0.be.rx_ip_checksum_errs, 0, 838 "IP Checksum Errors"); 839 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "tcp_checksum_errs", 840 CTLFLAG_RD, &stats->u0.be.rx_tcp_checksum_errs, 0, 841 "TCP Checksum Errors"); 842 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "udp_checksum_errs", 843 CTLFLAG_RD, &stats->u0.be.rx_udp_checksum_errs, 0, 844 "UDP Checksum Errors"); 845 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "fifo_overflow_drop", 846 CTLFLAG_RD, &stats->u0.be.rxpp_fifo_overflow_drop, 0, 847 "FIFO Overflow Drop"); 848 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, 849 "input_fifo_overflow_drop", CTLFLAG_RD, 850 &stats->u0.be.rx_input_fifo_overflow_drop, 0, 851 "Input FIFO Overflow Drop"); 852 853 tx_stats_node = SYSCTL_ADD_NODE(ctx, 854 SYSCTL_CHILDREN(stats_node), OID_AUTO, 855 "tx",CTLFLAG_RD, NULL, 856 "TX Ethernet Statistics"); 857 tx_stat_list = SYSCTL_CHILDREN(tx_stats_node); 858 859 SYSCTL_ADD_QUAD(ctx, tx_stat_list, OID_AUTO, "total_tx_pkts", 860 CTLFLAG_RD, &stats->tx.t_tx_pkts, 861 "Total Transmit Packets"); 862 SYSCTL_ADD_QUAD(ctx, tx_stat_list, OID_AUTO, "total_tx_bytes", 863 CTLFLAG_RD, &stats->tx.t_tx_bytes, 864 "Total Transmit Bytes"); 865 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_reqs", 866 CTLFLAG_RD, &stats->tx.t_tx_reqs, 0, 867 "Total Transmit Requests"); 868 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_stops", 869 CTLFLAG_RD, &stats->tx.t_tx_stops, 0, 870 "Total Transmit Stops"); 871 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_wrbs", 872 CTLFLAG_RD, &stats->tx.t_tx_wrbs, 0, 873 "Total Transmit WRB's"); 874 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_compl", 875 CTLFLAG_RD, &stats->tx.t_tx_compl, 0, 876 "Total Transmit Completions"); 877 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, 878 "total_ipv6_ext_hdr_tx_drop", CTLFLAG_RD, 879 &stats->tx.t_ipv6_ext_hdr_tx_drop, 0, 880 "Total Transmit IPV6 Drops"); 881 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "pauseframes", 882 CTLFLAG_RD, &stats->u0.be.tx_pauseframes, 0, 883 "Pause Frames"); 884 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "priority_pauseframes", 885 CTLFLAG_RD, &stats->u0.be.tx_priority_pauseframes, 0, 886 "Priority Pauseframes"); 887 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "controlframes", 888 CTLFLAG_RD, &stats->u0.be.tx_controlframes, 0, 889 "Tx Control Frames"); 890 891 for (i = 0; i < sc->nwqs; i++) { 892 sprintf(prefix, "queue%d",i); 893 queue_stats_node = SYSCTL_ADD_NODE(ctx, 894 SYSCTL_CHILDREN(tx_stats_node), 895 OID_AUTO, prefix, CTLFLAG_RD, 896 NULL, "Queue name"); 897 queue_stats_list = SYSCTL_CHILDREN(queue_stats_node); 898 899 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "tx_pkts", 900 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_pkts, 901 "Transmit Packets"); 902 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "tx_bytes", 903 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_bytes, 904 "Transmit Bytes"); 905 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_reqs", 906 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_reqs, 0, 907 "Transmit Requests"); 908 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_stops", 909 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_stops, 0, 910 "Transmit Stops"); 911 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_wrbs", 912 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_wrbs, 0, 913 "Transmit WRB's"); 914 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_compl", 915 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_compl, 0, 916 "Transmit Completions"); 917 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, 918 "ipv6_ext_hdr_tx_drop",CTLFLAG_RD, 919 &sc->wq[i]->tx_stats.ipv6_ext_hdr_tx_drop, 0, 920 "Transmit IPV6 Ext Header Drop"); 921 922 } 923 return; 924 } 925 926 927 static void 928 oce_add_stats_sysctls_xe201(POCE_SOFTC sc, 929 struct sysctl_ctx_list *ctx, 930 struct sysctl_oid *stats_node) 931 { 932 struct sysctl_oid *rx_stats_node, *tx_stats_node; 933 struct sysctl_oid_list *rx_stat_list, *tx_stat_list; 934 struct sysctl_oid_list *queue_stats_list; 935 struct sysctl_oid *queue_stats_node; 936 struct oce_drv_stats *stats; 937 char prefix[32]; 938 int i; 939 940 stats = &sc->oce_stats_info; 941 942 rx_stats_node = SYSCTL_ADD_NODE(ctx, 943 SYSCTL_CHILDREN(stats_node), 944 OID_AUTO, "rx", CTLFLAG_RD, 945 NULL, "RX Ethernet Statistics"); 946 rx_stat_list = SYSCTL_CHILDREN(rx_stats_node); 947 948 949 SYSCTL_ADD_QUAD(ctx, rx_stat_list, OID_AUTO, "total_pkts", 950 CTLFLAG_RD, &stats->rx.t_rx_pkts, 951 "Total Received Packets"); 952 SYSCTL_ADD_QUAD(ctx, rx_stat_list, OID_AUTO, "total_bytes", 953 CTLFLAG_RD, &stats->rx.t_rx_bytes, 954 "Total Received Bytes"); 955 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_frags", 956 CTLFLAG_RD, &stats->rx.t_rx_frags, 0, 957 "Total Received Fragements"); 958 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_mcast_pkts", 959 CTLFLAG_RD, &stats->rx.t_rx_mcast_pkts, 0, 960 "Total Received Multicast Packets"); 961 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_ucast_pkts", 962 CTLFLAG_RD, &stats->rx.t_rx_ucast_pkts, 0, 963 "Total Received Unicast Packets"); 964 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "total_rxcp_errs", 965 CTLFLAG_RD, &stats->rx.t_rxcp_errs, 0, 966 "Total Receive completion errors"); 967 SYSCTL_ADD_UQUAD(ctx, rx_stat_list, OID_AUTO, "pause_frames", 968 CTLFLAG_RD, &stats->u0.xe201.rx_pause_frames, 969 "Pause Frames"); 970 SYSCTL_ADD_UQUAD(ctx, rx_stat_list, OID_AUTO, "control_frames", 971 CTLFLAG_RD, &stats->u0.xe201.rx_control_frames, 972 "Control Frames"); 973 974 for (i = 0; i < sc->nrqs; i++) { 975 sprintf(prefix, "queue%d",i); 976 queue_stats_node = SYSCTL_ADD_NODE(ctx, 977 SYSCTL_CHILDREN(rx_stats_node), 978 OID_AUTO, prefix, CTLFLAG_RD, 979 NULL, "Queue name"); 980 queue_stats_list = SYSCTL_CHILDREN(queue_stats_node); 981 982 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "rx_pkts", 983 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_pkts, 984 "Receive Packets"); 985 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "rx_bytes", 986 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_bytes, 987 "Recived Bytes"); 988 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "rx_frags", 989 CTLFLAG_RD, &sc->rq[i]->rx_stats.rx_frags, 0, 990 "Received Fragments"); 991 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, 992 "rx_mcast_pkts", CTLFLAG_RD, 993 &sc->rq[i]->rx_stats.rx_mcast_pkts, 0, 994 "Received Multicast Packets"); 995 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, 996 "rx_ucast_pkts",CTLFLAG_RD, 997 &sc->rq[i]->rx_stats.rx_ucast_pkts, 0, 998 "Received Unicast Packets"); 999 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "rxcp_err", 1000 CTLFLAG_RD, &sc->rq[i]->rx_stats.rxcp_err, 0, 1001 "Received Completion Errors"); 1002 1003 } 1004 1005 rx_stats_node = SYSCTL_ADD_NODE(ctx, 1006 SYSCTL_CHILDREN(rx_stats_node), 1007 OID_AUTO, "err", CTLFLAG_RD, 1008 NULL, "Receive Error Stats"); 1009 rx_stat_list = SYSCTL_CHILDREN(rx_stats_node); 1010 1011 SYSCTL_ADD_UQUAD(ctx, rx_stat_list, OID_AUTO, "crc_errs", 1012 CTLFLAG_RD, &stats->u0.xe201.rx_crc_errors, 1013 "CRC Errors"); 1014 SYSCTL_ADD_UQUAD(ctx, rx_stat_list, OID_AUTO, "alignment_errors", 1015 CTLFLAG_RD, &stats->u0.xe201.rx_alignment_errors, 1016 "RX Alignmnet Errors"); 1017 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "in_range_errors", 1018 CTLFLAG_RD, &stats->u0.xe201.rx_in_range_errors, 0, 1019 "In Range Errors"); 1020 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "out_range_errors", 1021 CTLFLAG_RD, &stats->u0.xe201.rx_out_of_range_errors, 0, 1022 "Out Range Errors"); 1023 SYSCTL_ADD_UQUAD(ctx, rx_stat_list, OID_AUTO, "frame_too_long", 1024 CTLFLAG_RD, &stats->u0.xe201.rx_frames_too_long, 1025 "Frame Too Long"); 1026 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "address_match_errors", 1027 CTLFLAG_RD, &stats->u0.xe201.rx_address_match_errors, 0, 1028 "Address Match Errors"); 1029 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_too_small", 1030 CTLFLAG_RD, &stats->u0.xe201.rx_dropped_too_small, 0, 1031 "Dropped Too Small"); 1032 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_too_short", 1033 CTLFLAG_RD, &stats->u0.xe201.rx_dropped_too_short, 0, 1034 "Dropped Too Short"); 1035 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, 1036 "dropped_header_too_small", CTLFLAG_RD, 1037 &stats->u0.xe201.rx_dropped_header_too_small, 0, 1038 "Dropped Header Too Small"); 1039 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, 1040 "dropped_tcp_length", CTLFLAG_RD, 1041 &stats->u0.xe201.rx_dropped_invalid_tcp_length, 0, 1042 "Dropped TCP Length"); 1043 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "dropped_runt", 1044 CTLFLAG_RD, &stats->u0.xe201.rx_dropped_runt, 0, 1045 "Dropped runt"); 1046 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "ip_checksum_errs", 1047 CTLFLAG_RD, &stats->u0.xe201.rx_ip_checksum_errors, 0, 1048 "IP Checksum Errors"); 1049 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "tcp_checksum_errs", 1050 CTLFLAG_RD, &stats->u0.xe201.rx_tcp_checksum_errors, 0, 1051 "TCP Checksum Errors"); 1052 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "udp_checksum_errs", 1053 CTLFLAG_RD, &stats->u0.xe201.rx_udp_checksum_errors, 0, 1054 "UDP Checksum Errors"); 1055 SYSCTL_ADD_UINT(ctx, rx_stat_list, OID_AUTO, "input_fifo_overflow_drop", 1056 CTLFLAG_RD, &stats->u0.xe201.rx_fifo_overflow, 0, 1057 "Input FIFO Overflow Drop"); 1058 1059 tx_stats_node = SYSCTL_ADD_NODE(ctx, 1060 SYSCTL_CHILDREN(stats_node), 1061 OID_AUTO, "tx", CTLFLAG_RD, 1062 NULL, "TX Ethernet Statistics"); 1063 tx_stat_list = SYSCTL_CHILDREN(tx_stats_node); 1064 1065 SYSCTL_ADD_QUAD(ctx, tx_stat_list, OID_AUTO, "total_tx_pkts", 1066 CTLFLAG_RD, &stats->tx.t_tx_pkts, 1067 "Total Transmit Packets"); 1068 SYSCTL_ADD_QUAD(ctx, tx_stat_list, OID_AUTO, "total_tx_bytes", 1069 CTLFLAG_RD, &stats->tx.t_tx_bytes, 1070 "Total Transmit Bytes"); 1071 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_reqs", 1072 CTLFLAG_RD, &stats->tx.t_tx_reqs, 0, 1073 "Total Transmit Requests"); 1074 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_stops", 1075 CTLFLAG_RD, &stats->tx.t_tx_stops, 0, 1076 "Total Transmit Stops"); 1077 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_wrbs", 1078 CTLFLAG_RD, &stats->tx.t_tx_wrbs, 0, 1079 "Total Transmit WRB's"); 1080 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, "total_tx_compl", 1081 CTLFLAG_RD, &stats->tx.t_tx_compl, 0, 1082 "Total Transmit Completions"); 1083 SYSCTL_ADD_UINT(ctx, tx_stat_list, OID_AUTO, 1084 "total_ipv6_ext_hdr_tx_drop", 1085 CTLFLAG_RD, &stats->tx.t_ipv6_ext_hdr_tx_drop, 0, 1086 "Total Transmit IPV6 Drops"); 1087 SYSCTL_ADD_UQUAD(ctx, tx_stat_list, OID_AUTO, "pauseframes", 1088 CTLFLAG_RD, &stats->u0.xe201.tx_pause_frames, 1089 "Pause Frames"); 1090 SYSCTL_ADD_UQUAD(ctx, tx_stat_list, OID_AUTO, "controlframes", 1091 CTLFLAG_RD, &stats->u0.xe201.tx_control_frames, 1092 "Tx Control Frames"); 1093 1094 for (i = 0; i < sc->nwqs; i++) { 1095 sprintf(prefix, "queue%d",i); 1096 queue_stats_node = SYSCTL_ADD_NODE(ctx, 1097 SYSCTL_CHILDREN(tx_stats_node), 1098 OID_AUTO, prefix, CTLFLAG_RD, 1099 NULL, "Queue name"); 1100 queue_stats_list = SYSCTL_CHILDREN(queue_stats_node); 1101 1102 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "tx_pkts", 1103 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_pkts, 1104 "Transmit Packets"); 1105 SYSCTL_ADD_QUAD(ctx, queue_stats_list, OID_AUTO, "tx_bytes", 1106 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_bytes, 1107 "Transmit Bytes"); 1108 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_reqs", 1109 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_reqs, 0, 1110 "Transmit Requests"); 1111 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_stops", 1112 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_stops, 0, 1113 "Transmit Stops"); 1114 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_wrbs", 1115 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_wrbs, 0, 1116 "Transmit WRB's"); 1117 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, "tx_compl", 1118 CTLFLAG_RD, &sc->wq[i]->tx_stats.tx_compl, 0, 1119 "Transmit Completions"); 1120 SYSCTL_ADD_UINT(ctx, queue_stats_list, OID_AUTO, 1121 "ipv6_ext_hdr_tx_drop", CTLFLAG_RD, 1122 &sc->wq[i]->tx_stats.ipv6_ext_hdr_tx_drop, 0, 1123 "Transmit IPV6 Ext Header Drop"); 1124 1125 } 1126 return; 1127 } 1128 1129 1130 void 1131 oce_refresh_queue_stats(POCE_SOFTC sc) 1132 { 1133 struct oce_drv_stats *adapter_stats; 1134 int i; 1135 1136 adapter_stats = &sc->oce_stats_info; 1137 1138 /* Caluculate total TX and TXstats from all queues */ 1139 1140 bzero(&adapter_stats->rx, sizeof(struct oce_rx_stats)); 1141 for (i = 0; i < sc->nrqs; i++) { 1142 1143 adapter_stats->rx.t_rx_pkts += sc->rq[i]->rx_stats.rx_pkts; 1144 adapter_stats->rx.t_rx_bytes += sc->rq[i]->rx_stats.rx_bytes; 1145 adapter_stats->rx.t_rx_frags += sc->rq[i]->rx_stats.rx_frags; 1146 adapter_stats->rx.t_rx_mcast_pkts += 1147 sc->rq[i]->rx_stats.rx_mcast_pkts; 1148 adapter_stats->rx.t_rx_ucast_pkts += 1149 sc->rq[i]->rx_stats.rx_ucast_pkts; 1150 adapter_stats->rx.t_rxcp_errs += sc-> rq[i]->rx_stats.rxcp_err; 1151 } 1152 1153 bzero(&adapter_stats->tx, sizeof(struct oce_tx_stats)); 1154 for (i = 0; i < sc->nwqs; i++) { 1155 adapter_stats->tx.t_tx_reqs += sc->wq[i]->tx_stats.tx_reqs; 1156 adapter_stats->tx.t_tx_stops += sc->wq[i]->tx_stats.tx_stops; 1157 adapter_stats->tx.t_tx_wrbs += sc->wq[i]->tx_stats.tx_wrbs; 1158 adapter_stats->tx.t_tx_compl += sc->wq[i]->tx_stats.tx_compl; 1159 adapter_stats->tx.t_tx_bytes += sc->wq[i]->tx_stats.tx_bytes; 1160 adapter_stats->tx.t_tx_pkts += sc->wq[i]->tx_stats.tx_pkts; 1161 adapter_stats->tx.t_ipv6_ext_hdr_tx_drop += 1162 sc->wq[i]->tx_stats.ipv6_ext_hdr_tx_drop; 1163 } 1164 1165 } 1166 1167 1168 1169 static void 1170 copy_stats_to_sc_xe201(POCE_SOFTC sc) 1171 { 1172 struct oce_xe201_stats *adapter_stats; 1173 struct mbx_get_pport_stats *nic_mbx; 1174 struct pport_stats *port_stats; 1175 1176 nic_mbx = OCE_DMAPTR(&sc->stats_mem, struct mbx_get_pport_stats); 1177 port_stats = &nic_mbx->params.rsp.pps; 1178 adapter_stats = &sc->oce_stats_info.u0.xe201; 1179 1180 adapter_stats->tx_pkts = port_stats->tx_pkts; 1181 adapter_stats->tx_unicast_pkts = port_stats->tx_unicast_pkts; 1182 adapter_stats->tx_multicast_pkts = port_stats->tx_multicast_pkts; 1183 adapter_stats->tx_broadcast_pkts = port_stats->tx_broadcast_pkts; 1184 adapter_stats->tx_bytes = port_stats->tx_bytes; 1185 adapter_stats->tx_unicast_bytes = port_stats->tx_unicast_bytes; 1186 adapter_stats->tx_multicast_bytes = port_stats->tx_multicast_bytes; 1187 adapter_stats->tx_broadcast_bytes = port_stats->tx_broadcast_bytes; 1188 adapter_stats->tx_discards = port_stats->tx_discards; 1189 adapter_stats->tx_errors = port_stats->tx_errors; 1190 adapter_stats->tx_pause_frames = port_stats->tx_pause_frames; 1191 adapter_stats->tx_pause_on_frames = port_stats->tx_pause_on_frames; 1192 adapter_stats->tx_pause_off_frames = port_stats->tx_pause_off_frames; 1193 adapter_stats->tx_internal_mac_errors = 1194 port_stats->tx_internal_mac_errors; 1195 adapter_stats->tx_control_frames = port_stats->tx_control_frames; 1196 adapter_stats->tx_pkts_64_bytes = port_stats->tx_pkts_64_bytes; 1197 adapter_stats->tx_pkts_65_to_127_bytes = 1198 port_stats->tx_pkts_65_to_127_bytes; 1199 adapter_stats->tx_pkts_128_to_255_bytes = 1200 port_stats->tx_pkts_128_to_255_bytes; 1201 adapter_stats->tx_pkts_256_to_511_bytes = 1202 port_stats->tx_pkts_256_to_511_bytes; 1203 adapter_stats->tx_pkts_512_to_1023_bytes = 1204 port_stats->tx_pkts_512_to_1023_bytes; 1205 adapter_stats->tx_pkts_1024_to_1518_bytes = 1206 port_stats->tx_pkts_1024_to_1518_bytes; 1207 adapter_stats->tx_pkts_1519_to_2047_bytes = 1208 port_stats->tx_pkts_1519_to_2047_bytes; 1209 adapter_stats->tx_pkts_2048_to_4095_bytes = 1210 port_stats->tx_pkts_2048_to_4095_bytes; 1211 adapter_stats->tx_pkts_4096_to_8191_bytes = 1212 port_stats->tx_pkts_4096_to_8191_bytes; 1213 adapter_stats->tx_pkts_8192_to_9216_bytes = 1214 port_stats->tx_pkts_8192_to_9216_bytes; 1215 adapter_stats->tx_lso_pkts = port_stats->tx_lso_pkts; 1216 adapter_stats->rx_pkts = port_stats->rx_pkts; 1217 adapter_stats->rx_unicast_pkts = port_stats->rx_unicast_pkts; 1218 adapter_stats->rx_multicast_pkts = port_stats->rx_multicast_pkts; 1219 adapter_stats->rx_broadcast_pkts = port_stats->rx_broadcast_pkts; 1220 adapter_stats->rx_bytes = port_stats->rx_bytes; 1221 adapter_stats->rx_unicast_bytes = port_stats->rx_unicast_bytes; 1222 adapter_stats->rx_multicast_bytes = port_stats->rx_multicast_bytes; 1223 adapter_stats->rx_broadcast_bytes = port_stats->rx_broadcast_bytes; 1224 adapter_stats->rx_unknown_protos = port_stats->rx_unknown_protos; 1225 adapter_stats->rx_discards = port_stats->rx_discards; 1226 adapter_stats->rx_errors = port_stats->rx_errors; 1227 adapter_stats->rx_crc_errors = port_stats->rx_crc_errors; 1228 adapter_stats->rx_alignment_errors = port_stats->rx_alignment_errors; 1229 adapter_stats->rx_symbol_errors = port_stats->rx_symbol_errors; 1230 adapter_stats->rx_pause_frames = port_stats->rx_pause_frames; 1231 adapter_stats->rx_pause_on_frames = port_stats->rx_pause_on_frames; 1232 adapter_stats->rx_pause_off_frames = port_stats->rx_pause_off_frames; 1233 adapter_stats->rx_frames_too_long = port_stats->rx_frames_too_long; 1234 adapter_stats->rx_internal_mac_errors = 1235 port_stats->rx_internal_mac_errors; 1236 adapter_stats->rx_undersize_pkts = port_stats->rx_undersize_pkts; 1237 adapter_stats->rx_oversize_pkts = port_stats->rx_oversize_pkts; 1238 adapter_stats->rx_fragment_pkts = port_stats->rx_fragment_pkts; 1239 adapter_stats->rx_jabbers = port_stats->rx_jabbers; 1240 adapter_stats->rx_control_frames = port_stats->rx_control_frames; 1241 adapter_stats->rx_control_frames_unknown_opcode = 1242 port_stats->rx_control_frames_unknown_opcode; 1243 adapter_stats->rx_in_range_errors = port_stats->rx_in_range_errors; 1244 adapter_stats->rx_out_of_range_errors = 1245 port_stats->rx_out_of_range_errors; 1246 adapter_stats->rx_address_match_errors = 1247 port_stats->rx_address_match_errors; 1248 adapter_stats->rx_vlan_mismatch_errors = 1249 port_stats->rx_vlan_mismatch_errors; 1250 adapter_stats->rx_dropped_too_small = port_stats->rx_dropped_too_small; 1251 adapter_stats->rx_dropped_too_short = port_stats->rx_dropped_too_short; 1252 adapter_stats->rx_dropped_header_too_small = 1253 port_stats->rx_dropped_header_too_small; 1254 adapter_stats->rx_dropped_invalid_tcp_length = 1255 port_stats->rx_dropped_invalid_tcp_length; 1256 adapter_stats->rx_dropped_runt = port_stats->rx_dropped_runt; 1257 adapter_stats->rx_ip_checksum_errors = 1258 port_stats->rx_ip_checksum_errors; 1259 adapter_stats->rx_tcp_checksum_errors = 1260 port_stats->rx_tcp_checksum_errors; 1261 adapter_stats->rx_udp_checksum_errors = 1262 port_stats->rx_udp_checksum_errors; 1263 adapter_stats->rx_non_rss_pkts = port_stats->rx_non_rss_pkts; 1264 adapter_stats->rx_ipv4_pkts = port_stats->rx_ipv4_pkts; 1265 adapter_stats->rx_ipv6_pkts = port_stats->rx_ipv6_pkts; 1266 adapter_stats->rx_ipv4_bytes = port_stats->rx_ipv4_bytes; 1267 adapter_stats->rx_ipv6_bytes = port_stats->rx_ipv6_bytes; 1268 adapter_stats->rx_nic_pkts = port_stats->rx_nic_pkts; 1269 adapter_stats->rx_tcp_pkts = port_stats->rx_tcp_pkts; 1270 adapter_stats->rx_iscsi_pkts = port_stats->rx_iscsi_pkts; 1271 adapter_stats->rx_management_pkts = port_stats->rx_management_pkts; 1272 adapter_stats->rx_switched_unicast_pkts = 1273 port_stats->rx_switched_unicast_pkts; 1274 adapter_stats->rx_switched_multicast_pkts = 1275 port_stats->rx_switched_multicast_pkts; 1276 adapter_stats->rx_switched_broadcast_pkts = 1277 port_stats->rx_switched_broadcast_pkts; 1278 adapter_stats->num_forwards = port_stats->num_forwards; 1279 adapter_stats->rx_fifo_overflow = port_stats->rx_fifo_overflow; 1280 adapter_stats->rx_input_fifo_overflow = 1281 port_stats->rx_input_fifo_overflow; 1282 adapter_stats->rx_drops_too_many_frags = 1283 port_stats->rx_drops_too_many_frags; 1284 adapter_stats->rx_drops_invalid_queue = 1285 port_stats->rx_drops_invalid_queue; 1286 adapter_stats->rx_drops_mtu = port_stats->rx_drops_mtu; 1287 adapter_stats->rx_pkts_64_bytes = port_stats->rx_pkts_64_bytes; 1288 adapter_stats->rx_pkts_65_to_127_bytes = 1289 port_stats->rx_pkts_65_to_127_bytes; 1290 adapter_stats->rx_pkts_128_to_255_bytes = 1291 port_stats->rx_pkts_128_to_255_bytes; 1292 adapter_stats->rx_pkts_256_to_511_bytes = 1293 port_stats->rx_pkts_256_to_511_bytes; 1294 adapter_stats->rx_pkts_512_to_1023_bytes = 1295 port_stats->rx_pkts_512_to_1023_bytes; 1296 adapter_stats->rx_pkts_1024_to_1518_bytes = 1297 port_stats->rx_pkts_1024_to_1518_bytes; 1298 adapter_stats->rx_pkts_1519_to_2047_bytes = 1299 port_stats->rx_pkts_1519_to_2047_bytes; 1300 adapter_stats->rx_pkts_2048_to_4095_bytes = 1301 port_stats->rx_pkts_2048_to_4095_bytes; 1302 adapter_stats->rx_pkts_4096_to_8191_bytes = 1303 port_stats->rx_pkts_4096_to_8191_bytes; 1304 adapter_stats->rx_pkts_8192_to_9216_bytes = 1305 port_stats->rx_pkts_8192_to_9216_bytes; 1306 } 1307 1308 1309 1310 static void 1311 copy_stats_to_sc_be2(POCE_SOFTC sc) 1312 { 1313 struct oce_be_stats *adapter_stats; 1314 struct oce_pmem_stats *pmem; 1315 struct oce_rxf_stats_v0 *rxf_stats; 1316 struct oce_port_rxf_stats_v0 *port_stats; 1317 struct mbx_get_nic_stats_v0 *nic_mbx; 1318 uint32_t port = sc->port_id; 1319 1320 nic_mbx = OCE_DMAPTR(&sc->stats_mem, struct mbx_get_nic_stats_v0); 1321 pmem = &nic_mbx->params.rsp.stats.pmem; 1322 rxf_stats = &nic_mbx->params.rsp.stats.rxf; 1323 port_stats = &nic_mbx->params.rsp.stats.rxf.port[port]; 1324 1325 adapter_stats = &sc->oce_stats_info.u0.be; 1326 1327 1328 /* Update stats */ 1329 adapter_stats->rx_pause_frames = port_stats->rx_pause_frames; 1330 adapter_stats->rx_crc_errors = port_stats->rx_crc_errors; 1331 adapter_stats->rx_control_frames = port_stats->rx_control_frames; 1332 adapter_stats->rx_in_range_errors = port_stats->rx_in_range_errors; 1333 adapter_stats->rx_frame_too_long = port_stats->rx_frame_too_long; 1334 adapter_stats->rx_dropped_runt = port_stats->rx_dropped_runt; 1335 adapter_stats->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs; 1336 adapter_stats->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs; 1337 adapter_stats->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs; 1338 adapter_stats->rxpp_fifo_overflow_drop = 1339 port_stats->rxpp_fifo_overflow_drop; 1340 adapter_stats->rx_dropped_tcp_length = 1341 port_stats->rx_dropped_tcp_length; 1342 adapter_stats->rx_dropped_too_small = port_stats->rx_dropped_too_small; 1343 adapter_stats->rx_dropped_too_short = port_stats->rx_dropped_too_short; 1344 adapter_stats->rx_out_range_errors = port_stats->rx_out_range_errors; 1345 adapter_stats->rx_dropped_header_too_small = 1346 port_stats->rx_dropped_header_too_small; 1347 adapter_stats->rx_input_fifo_overflow_drop = 1348 port_stats->rx_input_fifo_overflow_drop; 1349 adapter_stats->rx_address_match_errors = 1350 port_stats->rx_address_match_errors; 1351 adapter_stats->rx_alignment_symbol_errors = 1352 port_stats->rx_alignment_symbol_errors; 1353 adapter_stats->tx_pauseframes = port_stats->tx_pauseframes; 1354 adapter_stats->tx_controlframes = port_stats->tx_controlframes; 1355 1356 if (sc->if_id) 1357 adapter_stats->jabber_events = rxf_stats->port1_jabber_events; 1358 else 1359 adapter_stats->jabber_events = rxf_stats->port0_jabber_events; 1360 1361 adapter_stats->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf; 1362 adapter_stats->rx_drops_no_txpb = rxf_stats->rx_drops_no_txpb; 1363 adapter_stats->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr; 1364 adapter_stats->rx_drops_invalid_ring = rxf_stats->rx_drops_invalid_ring; 1365 adapter_stats->forwarded_packets = rxf_stats->forwarded_packets; 1366 adapter_stats->rx_drops_mtu = rxf_stats->rx_drops_mtu; 1367 adapter_stats->rx_drops_no_tpre_descr = 1368 rxf_stats->rx_drops_no_tpre_descr; 1369 adapter_stats->rx_drops_too_many_frags = 1370 rxf_stats->rx_drops_too_many_frags; 1371 adapter_stats->eth_red_drops = pmem->eth_red_drops; 1372 } 1373 1374 1375 static void 1376 copy_stats_to_sc_be3(POCE_SOFTC sc) 1377 { 1378 struct oce_be_stats *adapter_stats; 1379 struct oce_pmem_stats *pmem; 1380 struct oce_rxf_stats_v1 *rxf_stats; 1381 struct oce_port_rxf_stats_v1 *port_stats; 1382 struct mbx_get_nic_stats_v1 *nic_mbx; 1383 uint32_t port = sc->port_id; 1384 1385 nic_mbx = OCE_DMAPTR(&sc->stats_mem, struct mbx_get_nic_stats_v1); 1386 pmem = &nic_mbx->params.rsp.stats.pmem; 1387 rxf_stats = &nic_mbx->params.rsp.stats.rxf; 1388 port_stats = &nic_mbx->params.rsp.stats.rxf.port[port]; 1389 1390 adapter_stats = &sc->oce_stats_info.u0.be; 1391 1392 /* Update stats */ 1393 adapter_stats->pmem_fifo_overflow_drop = 1394 port_stats->pmem_fifo_overflow_drop; 1395 adapter_stats->rx_priority_pause_frames = 1396 port_stats->rx_priority_pause_frames; 1397 adapter_stats->rx_pause_frames = port_stats->rx_pause_frames; 1398 adapter_stats->rx_crc_errors = port_stats->rx_crc_errors; 1399 adapter_stats->rx_control_frames = port_stats->rx_control_frames; 1400 adapter_stats->rx_in_range_errors = port_stats->rx_in_range_errors; 1401 adapter_stats->rx_frame_too_long = port_stats->rx_frame_too_long; 1402 adapter_stats->rx_dropped_runt = port_stats->rx_dropped_runt; 1403 adapter_stats->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs; 1404 adapter_stats->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs; 1405 adapter_stats->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs; 1406 adapter_stats->rx_dropped_tcp_length = 1407 port_stats->rx_dropped_tcp_length; 1408 adapter_stats->rx_dropped_too_small = port_stats->rx_dropped_too_small; 1409 adapter_stats->rx_dropped_too_short = port_stats->rx_dropped_too_short; 1410 adapter_stats->rx_out_range_errors = port_stats->rx_out_range_errors; 1411 adapter_stats->rx_dropped_header_too_small = 1412 port_stats->rx_dropped_header_too_small; 1413 adapter_stats->rx_input_fifo_overflow_drop = 1414 port_stats->rx_input_fifo_overflow_drop; 1415 adapter_stats->rx_address_match_errors = 1416 port_stats->rx_address_match_errors; 1417 adapter_stats->rx_alignment_symbol_errors = 1418 port_stats->rx_alignment_symbol_errors; 1419 adapter_stats->rxpp_fifo_overflow_drop = 1420 port_stats->rxpp_fifo_overflow_drop; 1421 adapter_stats->tx_pauseframes = port_stats->tx_pauseframes; 1422 adapter_stats->tx_controlframes = port_stats->tx_controlframes; 1423 adapter_stats->jabber_events = port_stats->jabber_events; 1424 1425 adapter_stats->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf; 1426 adapter_stats->rx_drops_no_txpb = rxf_stats->rx_drops_no_txpb; 1427 adapter_stats->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr; 1428 adapter_stats->rx_drops_invalid_ring = rxf_stats->rx_drops_invalid_ring; 1429 adapter_stats->forwarded_packets = rxf_stats->forwarded_packets; 1430 adapter_stats->rx_drops_mtu = rxf_stats->rx_drops_mtu; 1431 adapter_stats->rx_drops_no_tpre_descr = 1432 rxf_stats->rx_drops_no_tpre_descr; 1433 adapter_stats->rx_drops_too_many_frags = 1434 rxf_stats->rx_drops_too_many_frags; 1435 1436 adapter_stats->eth_red_drops = pmem->eth_red_drops; 1437 } 1438 1439 static void 1440 copy_stats_to_sc_sh(POCE_SOFTC sc) 1441 { 1442 struct oce_be_stats *adapter_stats; 1443 struct oce_pmem_stats *pmem; 1444 struct oce_rxf_stats_v2 *rxf_stats; 1445 struct oce_port_rxf_stats_v2 *port_stats; 1446 struct mbx_get_nic_stats_v2 *nic_mbx; 1447 struct oce_erx_stats_v2 *erx_stats; 1448 uint32_t port = sc->port_id; 1449 1450 nic_mbx = OCE_DMAPTR(&sc->stats_mem, struct mbx_get_nic_stats_v2); 1451 pmem = &nic_mbx->params.rsp.stats.pmem; 1452 rxf_stats = &nic_mbx->params.rsp.stats.rxf; 1453 erx_stats = &nic_mbx->params.rsp.stats.erx; 1454 port_stats = &nic_mbx->params.rsp.stats.rxf.port[port]; 1455 1456 adapter_stats = &sc->oce_stats_info.u0.be; 1457 1458 /* Update stats */ 1459 adapter_stats->pmem_fifo_overflow_drop = 1460 port_stats->pmem_fifo_overflow_drop; 1461 adapter_stats->rx_priority_pause_frames = 1462 port_stats->rx_priority_pause_frames; 1463 adapter_stats->rx_pause_frames = port_stats->rx_pause_frames; 1464 adapter_stats->rx_crc_errors = port_stats->rx_crc_errors; 1465 adapter_stats->rx_control_frames = port_stats->rx_control_frames; 1466 adapter_stats->rx_in_range_errors = port_stats->rx_in_range_errors; 1467 adapter_stats->rx_frame_too_long = port_stats->rx_frame_too_long; 1468 adapter_stats->rx_dropped_runt = port_stats->rx_dropped_runt; 1469 adapter_stats->rx_ip_checksum_errs = port_stats->rx_ip_checksum_errs; 1470 adapter_stats->rx_tcp_checksum_errs = port_stats->rx_tcp_checksum_errs; 1471 adapter_stats->rx_udp_checksum_errs = port_stats->rx_udp_checksum_errs; 1472 adapter_stats->rx_dropped_tcp_length = 1473 port_stats->rx_dropped_tcp_length; 1474 adapter_stats->rx_dropped_too_small = port_stats->rx_dropped_too_small; 1475 adapter_stats->rx_dropped_too_short = port_stats->rx_dropped_too_short; 1476 adapter_stats->rx_out_range_errors = port_stats->rx_out_range_errors; 1477 adapter_stats->rx_dropped_header_too_small = 1478 port_stats->rx_dropped_header_too_small; 1479 adapter_stats->rx_input_fifo_overflow_drop = 1480 port_stats->rx_input_fifo_overflow_drop; 1481 adapter_stats->rx_address_match_errors = 1482 port_stats->rx_address_match_errors; 1483 adapter_stats->rx_alignment_symbol_errors = 1484 port_stats->rx_alignment_symbol_errors; 1485 adapter_stats->rxpp_fifo_overflow_drop = 1486 port_stats->rxpp_fifo_overflow_drop; 1487 adapter_stats->tx_pauseframes = port_stats->tx_pauseframes; 1488 adapter_stats->tx_controlframes = port_stats->tx_controlframes; 1489 adapter_stats->jabber_events = port_stats->jabber_events; 1490 1491 adapter_stats->rx_drops_no_pbuf = rxf_stats->rx_drops_no_pbuf; 1492 adapter_stats->rx_drops_no_txpb = rxf_stats->rx_drops_no_txpb; 1493 adapter_stats->rx_drops_no_erx_descr = rxf_stats->rx_drops_no_erx_descr; 1494 adapter_stats->rx_drops_invalid_ring = rxf_stats->rx_drops_invalid_ring; 1495 adapter_stats->forwarded_packets = rxf_stats->forwarded_packets; 1496 adapter_stats->rx_drops_mtu = rxf_stats->rx_drops_mtu; 1497 adapter_stats->rx_drops_no_tpre_descr = 1498 rxf_stats->rx_drops_no_tpre_descr; 1499 adapter_stats->rx_drops_too_many_frags = 1500 rxf_stats->rx_drops_too_many_frags; 1501 1502 adapter_stats->eth_red_drops = pmem->eth_red_drops; 1503 1504 /* populate erx stats */ 1505 for (int i = 0; i < sc->nrqs; i++) 1506 sc->rq[i]->rx_stats.rx_drops_no_frags = erx_stats->rx_drops_no_fragments[sc->rq[i]->rq_id]; 1507 } 1508 1509 1510 1511 int 1512 oce_stats_init(POCE_SOFTC sc) 1513 { 1514 int rc = 0, sz = 0; 1515 1516 1517 if( IS_BE2(sc) ) 1518 sz = sizeof(struct mbx_get_nic_stats_v0); 1519 else if( IS_BE3(sc) ) 1520 sz = sizeof(struct mbx_get_nic_stats_v1); 1521 else if( IS_SH(sc)) 1522 sz = sizeof(struct mbx_get_nic_stats_v2); 1523 else if( IS_XE201(sc) ) 1524 sz = sizeof(struct mbx_get_pport_stats); 1525 1526 rc = oce_dma_alloc(sc, sz, &sc->stats_mem, 0); 1527 1528 return rc; 1529 } 1530 1531 1532 void 1533 oce_stats_free(POCE_SOFTC sc) 1534 { 1535 1536 oce_dma_free(sc, &sc->stats_mem); 1537 1538 } 1539 1540 1541 int 1542 oce_refresh_nic_stats(POCE_SOFTC sc) 1543 { 1544 int rc = 0, reset = 0; 1545 1546 if( IS_BE2(sc) ) { 1547 rc = oce_mbox_get_nic_stats_v0(sc, &sc->stats_mem); 1548 if (!rc) 1549 copy_stats_to_sc_be2(sc); 1550 }else if( IS_BE3(sc) ) { 1551 rc = oce_mbox_get_nic_stats_v1(sc, &sc->stats_mem); 1552 if (!rc) 1553 copy_stats_to_sc_be3(sc); 1554 }else if( IS_SH(sc)) { 1555 rc = oce_mbox_get_nic_stats_v2(sc, &sc->stats_mem); 1556 if (!rc) 1557 copy_stats_to_sc_sh(sc); 1558 }else if( IS_XE201(sc) ){ 1559 rc = oce_mbox_get_pport_stats(sc, &sc->stats_mem, reset); 1560 if (!rc) 1561 copy_stats_to_sc_xe201(sc); 1562 } 1563 1564 return rc; 1565 } 1566 1567 static int 1568 oce_sysctl_sfp_vpd_dump(SYSCTL_HANDLER_ARGS) 1569 { 1570 int result = 0, error; 1571 int rc = 0; 1572 POCE_SOFTC sc = (POCE_SOFTC) arg1; 1573 1574 /* sysctl default handler */ 1575 error = sysctl_handle_int(oidp, &result, 0, req); 1576 if (error || !req->newptr) 1577 return (error); 1578 1579 if(result == -1) { 1580 return EINVAL; 1581 } 1582 bzero((char *)sfp_vpd_dump_buffer, TRANSCEIVER_DATA_SIZE); 1583 1584 rc = oce_mbox_read_transrecv_data(sc, PAGE_NUM_A0); 1585 if(rc) 1586 return rc; 1587 1588 rc = oce_mbox_read_transrecv_data(sc, PAGE_NUM_A2); 1589 if(rc) 1590 return rc; 1591 1592 return rc; 1593 } 1594