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